ff_undo.h

/* 
 * File:   ff_undo.h
 * Author: Jari Williamsson
 *
 * Created on den 20 oktober 2011, 13:12
 */
 
#ifndef FF_UNDO_H
#define FF_UNDO_H
 
 
class FCUndoController;
 
class __FCUndoBlockHandler : public __FCBase
{
    FCUndoController* _pOwner;
    
public:
    __FCUndoBlockHandler() :  __FCBase() { _pOwner = NULL; }
    
    virtual bool Execute() = 0;
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void _SetOwner(FCUndoController* pOwner) { _pOwner = pOwner; }
#endif
    
    FCUndoController* GetOwner() { return _pOwner; }
};
 
class FCUndoController : public __FCBase
{
    UTRANSID _utransid;
    FCString _lastundostring;
    bool _sandboxmode;
    bool _explicitrequired;
    bool _currentisexplicit;
    bool _isrunning;
    
    FCString _suspendedundostring;
    bool _suspendedisexplicit;
    bool _suspendedisrunning;
    bool _issuspended;
 
    static std::map<_state_ptr, FCUndoController> _sessionundocontrollers;
    
public:
    const char* ClassName() const override { return "FCUndoController"; }
    
    FCUndoController() : __FCBase(), _utransid(0), _sandboxmode(false), _explicitrequired(false),
            _currentisexplicit(false), _isrunning(false),
            _suspendedisexplicit(false), _issuspended(false), _suspendedisrunning(false)
    {}
    
    const FCString& GetLastUndoString() const { return _lastundostring; }
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY
    static FCUndoController& GetUndoController(_state_ptr S)
#else
    static FCUndoController& GetUndoController(_state_ptr S = nullptr)
#endif
    {
        auto it = _sessionundocontrollers.find(_LUACODE(_GetBaseLuaState(S)) _NOLUACODE(S));
        if (it != _sessionundocontrollers.end())
            return it->second;
        return CreateUndoController(false, false, S);
    }
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY
    static FCUndoController& CreateUndoController(bool sandboxmode, bool explicitrequired, _state_ptr S)
#else
    static FCUndoController& CreateUndoController(bool sandboxmode, bool explicitrequired, _state_ptr S = nullptr)
#endif
    {
        auto [newval, _] = _sessionundocontrollers.emplace(_LUACODE(_GetBaseLuaState(S)) _NOLUACODE(S), FCUndoController());
        newval->second._sandboxmode = sandboxmode;
        newval->second._explicitrequired = explicitrequired;
        return newval->second;
    }
    static void RemoveUndoBlock(_state_ptr S)
    {
        auto it = _sessionundocontrollers.find(_LUACODE(_GetBaseLuaState(S)) _NOLUACODE(S));
        if (it != _sessionundocontrollers.end())
            _sessionundocontrollers.erase(S);
    }
    
    bool StartUndo(const FCString& undoString, bool savecurrent = false, bool isexplicit = true)
    {
        EndUndo(savecurrent); // in case we have one in progress
        _utransid = undoString._StartFinaleEdit();
        _lastundostring = undoString;
        _currentisexplicit = isexplicit;
        _isrunning = true; // we have to balance Start and End even for _utransid = 0
        return true; // for now, always true
    }
    
    void EndUndo(bool savecurrent = false)
    {
        if (IsRunning())
        {
            if (savecurrent && _utransid && !_sandboxmode && (!_explicitrequired || _currentisexplicit))
                FX_EndFinaleEdit();
            else
                FX_CancelFinaleEdit();
        }
        _isrunning = false;
        _utransid = 0;
        _currentisexplicit = false;
    }
    
    void SuspendUndo(bool savecurrent = false)
    {
        if (!_issuspended)
        {
            _suspendedundostring = _lastundostring;
            _suspendedisexplicit = _currentisexplicit;
            _suspendedisrunning = _isrunning;
            _issuspended = true;
        }
        EndUndo(savecurrent);
    }
    
    void ResumeUndo(bool savecurrent = false)
    {
        if (!_issuspended || _suspendedisrunning)
        {
            if (_issuspended && ! _suspendedundostring.IsEmpty())
                StartUndo(_suspendedundostring, savecurrent, _suspendedisexplicit);
            else
                StartUndo(_lastundostring, savecurrent);
        }
        _issuspended = false;
        _suspendedisrunning = false;
        _suspendedisexplicit = false;
        _suspendedundostring.Clear();
    }
 
    bool Execute(__FCUndoBlockHandler *pHandler, const FCString *pUndoString);
    
    bool AddSession(const FCString *pUndoString, bool storecurrentblock);
    
    bool GetSandboxMode() const { return _sandboxmode; }
    
    bool GetRequireExplicitUndo() const { return _explicitrequired; }
    
    bool IsRunning() const { return _isrunning; }
 
    bool GetCurrentIsExplicitUndo() const { return _currentisexplicit; }
};
 
#endif  /* FF_UNDO_H */