ParamsMgr.h

Go to the documentation of this file.

//************************************************************************
//                                  *
//           Copyright (C)  2016                *
//     University Corporation for Atmospheric Research          *
//           All Rights Reserved                *
//                                  *
//************************************************************************/
//
//  File:       ParamsMgr.h
//
//  Author:     Alan Norton
//          National Center for Atmospheric Research
//          PO 3000, Boulder, Colorado
//
//  Date:       February 2016
//
//  Description:    Defines the ParamsMgr  class.
//      This provides an API for manipulating the Params Objects that are used in VAPOR applications
//
#ifndef PARAMSMGR_H
#define PARAMSMGR_H
 
#include "vapor/VAssert.h"
#include <map>
#include <deque>
#include <stack>
#include <utility>
#include <functional>
 
#include <vapor/DataMgr.h>
#include <vapor/ParamsBase.h>
#include <vapor/RenderParams.h>
#include <vapor/ViewpointParams.h>
#include <vapor/regionparams.h>
#include <vapor/AnnotationParams.h>
#include <vapor/DatasetsParams.h>
 
namespace VAPoR {
 
 
 
class PARAMS_API ParamsMgr : public MyBase {
public:
    //
    ParamsMgr(std::vector<string> appParamNames = std::vector<string>(), std::vector<string> appRenderParamNames = std::vector<string>());
 
    virtual ~ParamsMgr();
 
    //
    virtual void LoadState();
 
    //
    virtual void LoadState(const XmlNode *node);
 
    //
    virtual int LoadState(string stateFile);
 
    void AddDataMgr(string dataSetName, DataMgr *dataMgr);
 
    //
    void RemoveVisualizer(string winName);
 
    void RemoveDataMgr(string dataSetName);
 
    //
    vector<string> GetDataMgrNames() const;
 
    //
    ViewpointParams *CreateVisualizerParamsInstance(string winName);
 
    //
    void RemoveVisualizerParamsInstance(string winName);
 
    //
    RenderParams *CreateRenderParamsInstance(string winName, string dataSetName, string classType, string instName);
 
    //
    RenderParams *CreateRenderParamsInstance(string winName, string dataSetName, string instName, const RenderParams *rp);
 
    //
    void RemoveRenderParamsInstance(string winName, string dataSetName, string classType, string instName);
 
    //
    RenderParams *GetRenderParams(string winName, string dataSetName, string classType, string instName) const;
 
    void GetRenderParams(string winName, string dataSetName, vector<RenderParams *> &rParams) const;
 
    void GetRenderParams(string winName, vector<RenderParams *> &rParams) const;
 
    void GetRenderParams(vector<RenderParams *> &rParams) const;
 
    void GetRenderParamNames(string winName, string dataSetName, string classType, vector<string> &instNames) const;
 
    void GetRenderParamNames(string winName, string dataSetName, vector<string> &instNames) const;
 
    void GetRenderParamNames(string winName, vector<string> &instNames) const;
 
    void GetRenderParamNames(vector<string> &instNames) const;
 
    //
    bool RenderParamsLookup(string instName, string &winName, string &dataSetName, string &className) const;
 
    //
    vector<string> GetVisualizerNames() const;
 
    //
    vector<string> GetRenderParamsClassNames(string winName) const;
 
    //
    vector<string> GetRenderParamsClassNames(string winName, string dataSetName) const;
 
    //
    static vector<string> GetRenderParamsClassNamesAvail() { return (RenParamsFactory::Instance()->GetFactoryNames()); }
 
    //
    vector<string> GetRenderParamInstances(string winName, string dataSetName, string classType) const;
 
    vector<string> GetRenderParamInstances(string winName, string classType) const;
 
    //
    ViewpointParams *GetViewpointParams(string winName) const;
 
    //
    RegionParams *GetRegionParams(string winName) const { return ((RegionParams *)_otherParams->GetParams(RegionParams::GetClassType())); };
 
    //
    AnnotationParams *GetAnnotationParams(string winName) const { return ((AnnotationParams *)_otherParams->GetParams(AnnotationParams::GetClassType())); };
 
    //
    DatasetsParams *GetDatasetsParams() const { return ((DatasetsParams *)_otherParams->GetParams(DatasetsParams::GetClassType())); };
 
    //
    ParamsBase *GetParams(string classType) { return (_otherParams->GetParams(classType)); }
 
    //
    RenderParams *GetAppRenderParams(string dataSetName, string classType)
    {
        std::map<string, RenParamsContainer *>::const_iterator itr;
        itr = _otherRenParams.find(dataSetName);
        return (itr != _otherRenParams.cend() ? itr->second->GetParams(classType) : NULL);
    }
 
    //
    void GetAppRenderParams(string dataSetName, vector<RenderParams *> &appRenderParams) const;
 
    //
    int SaveToFile(string path) const;
 
    // const DataMgr *GetDataMgr() const {return (_dataMgr);}
 
    void BeginSaveStateGroup(string description) { _ssave.BeginGroup(description); }
 
    //
    void EndSaveStateGroup() { _ssave.EndGroup(); };
 
    void IntermediateChange() { _ssave.IntermediateChange(); }
 
    void SetSaveStateEnabled(bool enabled) { _ssave.SetEnabled(enabled); }
 
    bool GetSaveStateEnabled() const { return (_ssave.GetEnabled()); }
 
    void SetSaveStateUndoEnabled(bool enabled) { _ssave.SetUndoEnabled(enabled); }
 
    bool GetSaveStateUndoEnabled() const { return (_ssave.GetUndoEnabled()); }
 
    //
    bool Undo();
 
    //
    bool Redo();
 
    void UndoRedoClear();
 
    //
    string GetTopUndoDesc() const;
 
    //
    string GetTopRedoDesc() const;
 
    size_t UndoSize() const { return (_ssave.UndoSize()); }
 
    size_t RedoSize() const { return (_ssave.RedoSize()); }
 
    //
    void RegisterStateChangeFlag(bool *flag) { _ssave.RegisterStateChangeFlag(flag); }
 
    //
    void RegisterStateChangeCB(std::function<void()> callback) { _ssave.RegisterStateChangeCB(callback); }
 
    void RegisterIntermediateStateChangeCB(std::function<void()> callback) { _ssave.RegisterIntermediateStateChangeCB(callback); }
 
    void RebaseStateSave() { _ssave.Rebase(); }
 
    const XmlNode *GetXMLRoot() const { return (_rootSeparator->GetNode()); }
 
    //
    bool StateChanged()
    {
        if (*(_rootSeparator->GetNode()) == _prevState) return (false);
 
        _prevState = *(_rootSeparator->GetNode());
        return (true);
    }
 
private:
    class PMgrStateSave : public ParamsBase::StateSave {
    public:
        PMgrStateSave(int stackSize = 100);
        ~PMgrStateSave();
 
        void Reinit(const XmlNode *rootNode)
        {
            _rootNode = rootNode;
            emitStateChange();
        }
 
        void Rebase()
        {
            if (_state0) delete _state0;
            _state0 = _rootNode ? new XmlNode(*_rootNode) : NULL;
        }
        void Save(const XmlNode *node, string description);
        void BeginGroup(string descripion);
        void EndGroup();
        void IntermediateChange();
 
        void SetEnabled(bool onOff)
        {
            if (!_groups.empty()) return;    // Can't change inside group
            _enabled = onOff;
        }
 
        bool GetEnabled() const { return (_enabled); }
 
        void SetUndoEnabled(bool b)
        {
            if (!_groups.empty()) return;    // Can't change inside group
            _addToUndoEnabled = b;
        }
        bool GetUndoEnabled() const { return _addToUndoEnabled; }
 
        const XmlNode *GetTopUndo(string &description) const;
        const XmlNode *GetTopRedo(string &description) const;
        const XmlNode *GetBase() const { return (_state0); }
 
        bool Undo();
        bool Redo();
        void Clear();
 
        size_t UndoSize() const { return (_undoStack.size()); }
 
        size_t RedoSize() const { return (_redoStack.size()); }
 
        void RegisterStateChangeFlag(bool *flag) { _stateChangeFlags.push_back(flag); }
        void RegisterStateChangeCB(std::function<void()> callback) { _stateChangeCBs.push_back(callback); }
        void RegisterIntermediateStateChangeCB(std::function<void()> callback) { _intermediateStateChangeCBs.push_back(callback); }
 
    private:
        bool           _enabled;
        bool           _addToUndoEnabled = true;
        int            _stackSize;
        const XmlNode *_rootNode;
        const XmlNode *_state0;
 
        std::stack<string>                       _groups;
        std::deque<std::pair<string, XmlNode *>> _undoStack;
        std::deque<std::pair<string, XmlNode *>> _redoStack;
 
        std::vector<bool *>                _stateChangeFlags;
        std::vector<std::function<void()>> _stateChangeCBs;
        std::vector<std::function<void()>> _intermediateStateChangeCBs;
 
        void cleanStack(int maxN, std::deque<std::pair<string, XmlNode *>> &s);
        void emitStateChange();
        void emitIntermediateStateChange();
    };
 
    map<string, DataMgr *> _dataMgrMap;
    ParamsSeparator *      _rootSeparator;
    XmlNode                _prevState;
    std::vector<string>    _appParamNames;
    std::vector<string>    _appRenderParamNames;
 
    // Map of RenParamsContainers referenced by Window Name, then by
    // data set name, and finally Renderer Name.
    //
    map<string, map<string, map<string, RenParamsContainer *>>> _renderParamsMap;
 
    // Map of ViewpointParams referenced by Window Name
    //
    map<string, ViewpointParams *> _viewpointParamsMap;
 
    ParamsContainer *                      _otherParams;
    std::map<string, RenParamsContainer *> _otherRenParams;
 
    PMgrStateSave _ssave;
 
    static const string _rootTag;
    static const string _globalTag;
    static const string _renderersTag;
    static const string _appRenderersTag;
    static const string _windowsTag;
 
    void _init(std::vector<string> appParamNames, XmlNode *node);
    void _createAppRenParams(string dataSetName);
    void _destroy();
 
    const map<string, map<string, RenParamsContainer *>> *getWinMap3(const map<string, map<string, map<string, RenParamsContainer *>>> &m3, string key) const;
 
    const map<string, RenParamsContainer *> *getWinMap3(const map<string, map<string, map<string, RenParamsContainer *>>> &m3, string key1, string key2) const;
 
    const map<string, RenParamsContainer *> *getWinMap2(const map<string, map<string, RenParamsContainer *>> &m2, string key) const;
 
    RenParamsContainer *get_ren_container(string winName, string dataSetName, string renderName) const;
 
    map<string, map<string, RenParamsContainer *>> *getWinMap3(map<string, map<string, map<string, RenParamsContainer *>>> &m3, string key) const;
 
    map<string, RenParamsContainer *> *getWinMap3(map<string, map<string, map<string, RenParamsContainer *>>> &m3, string key1, string key2) const;
 
    map<string, RenParamsContainer *> *getWinMap2(map<string, map<string, RenParamsContainer *>> &m2, string key) const;
 
    void delete_ren_container(string winName, string dataSetName, string renderName);
 
    void delete_ren_containers(string winName, string dataSetName);
    void delete_ren_containers(string winName);
    void delete_ren_containers();
    void delete_datasets(string dataSetName);
 
    RenParamsContainer *make_ren_container(string winName, string dataSetName, string renderName);
 
    ViewpointParams *get_vp_params(string winName) const;
 
    void delete_vp_params(string winName);
 
    ViewpointParams *make_vp_params(string winName);
 
    void addDataMgrNew();
    void addDataMgrMerge(string dataSetName);
 
    bool undoRedoHelper();
 
    RenParamsContainer *createRenderParamsHelper(string winName, string dataSetName, string className, string instName);
};
 
};        // End namespace VAPoR
#endif    // PARAMSMGR_H