command.h

Go to the documentation of this file.

//************************************************************************
//                                                                      *
//           Copyright (C)  2004                                        *
//     University Corporation for Atmospheric Research                  *
//           All Rights Reserved                                        *
//                                                                      *
//************************************************************************/
//
//  File:       command.h
//
//  Author:     Alan Norton
//          National Center for Atmospheric Research
//          PO 3000, Boulder, Colorado
//
//  Date:       October 2004
//
//

#ifndef COMMAND_H
#define COMMAND_H

#define MAX_HISTORY 1000

#include "params.h"
#include "vapor/ParamNode.h"

namespace VAPoR{
class Params;

typedef void (*UndoRedoHelpCB_T) (bool isUndo, int instance, VAPoR::Params* beforeP, VAPoR::Params* afterP, VAPoR::Params* auxBP, VAPoR::Params* auxAP);
class PARAMS_API Command {
    public:
    
    Command(Params*, const char* descr, UndoRedoHelpCB_T helper = 0, Params* auxParams = 0);
    virtual ~Command( ) {
        if (_nextRoot) delete _nextRoot;
        if (_prevRoot) delete _prevRoot;
        if (_nextAuxRoot) delete _nextAuxRoot;
        if (_prevAuxRoot) delete _prevAuxRoot;
        _tag.clear();
        _auxTag.clear();
    }
    
    static Params* BackupQueue();

    static Params* AdvanceQueue();

    static void resetCommandQueue();
    
    
    //sa blockCapture, unblockCapture
    // \return bool indicates whether or not recording is enabled.
    static bool isRecording() {return (_recordingCount == 0);}
    static Command* CurrentCommand(int offset) {
        int posn = _currentQueuePos - offset;
        while (posn < 0) posn += MAX_HISTORY;
        return _commandQueue[posn%MAX_HISTORY];
    }
    void setDescription(const char* str){
        _description = str;
    }
    string getDescription(){return _description;}

    static Command* CaptureStart(Params* prevParams,  const char* desc,  UndoRedoHelpCB_T helper = 0, Params* prevAuxParams = 0){
        if (!isRecording()) return 0;
        Command* cmd = new Command(prevParams, desc, helper, prevAuxParams);
        blockCapture();
        return cmd;
    }
    static void CaptureEnd(Command* pCom, Params *nextParams, Params* nextAuxParams = 0){
        if (!pCom) return;
        if (nextParams){
            pCom->_nextRoot = nextParams->GetRootNode()->deepCopy();
            if (!pCom->_prevRoot){ //If the first Params was null, get the tag, etc. from the next params:
                pCom->_tag = nextParams->GetName();
                pCom->_instance = nextParams->GetInstanceIndex();
                pCom->_winnum = nextParams->GetVizNum();
            }
        }
        if (nextAuxParams){
            pCom->_nextAuxRoot = nextAuxParams->GetRootNode()->deepCopy();
            if (!pCom->_prevAuxRoot){ //If the first AuxParams was null, get the tag, etc. from the next params:
                pCom->_auxTag = nextAuxParams->GetName();
                pCom->_auxInstance = nextAuxParams->GetInstanceIndex();
                pCom->_auxWinnum = nextAuxParams->GetVizNum();
            }
        }
        
        unblockCapture();
        AddToHistory(pCom);
    }

    
    Params* CopyParams(ParamNode* rootNode);
    Params* CopyAuxParams(ParamNode* rootNode);
    
#ifndef DOXYGEN_SKIP_THIS
    //Anytime it is necessary to stop inserting into the _commandQueue, call blockCapture,
    //then unblock when they are done.  No recording happens until all blockers has stopped
    //blocking it.   This is not currently regarded as part of the public API.
    //
    //sa unblockCapture, isRecording
    static void blockCapture() {_recordingCount++;}
    //sa blockCapture, isRecording
    static void unblockCapture() {_recordingCount--; assert(_recordingCount>=0);}
private:
    
    void applyHelpers(bool isUndo, int instance, Params* prev, Params* next);
    static int AddToHistory(Command* cmd, bool ignoreBlocking = false);
    static Command* CurrentUndoCommand() {return CurrentCommand(0);}
    static Command* CurrentRedoCommand() {return CurrentCommand(-1);}
    static Params* reDo();
    static Params* unDo();

    UndoRedoHelpCB_T _undoRedoHelper;
    string _description;
    ParamNode* _prevRoot;
    ParamNode* _nextRoot;
    ParamNode* _prevAuxRoot;
    ParamNode* _nextAuxRoot;
    string _tag;
    string _auxTag;
    int _instance;
    int _auxInstance;
    int _winnum;
    int _auxWinnum;
    //Statics indicate state of queue:
    static Command* _commandQueue[MAX_HISTORY];
    static bool _first;
    static int _currentQueuePos;
    static int _endQueuePos;
    static int _startQueuePos;
    static int _recordingCount;
#endif //DOXYGEN_SKIP_THIS
};
    
};
#endif