ControlExecutive.h

Go to the documentation of this file.

 
#ifndef ControlExec_h
#define ControlExec_h
 
#include <string>
#include <vector>
#include <map>
 
#include <vapor/ParamsMgr.h>
#include <vapor/GLManager.h>
#include <vapor/DataStatus.h>
 
using namespace std;
namespace VAPoR {
 
class CalcEngineMgr;
class Visualizer;
class DataStatus;
 
//
 
class RENDER_API ControlExec : public MyBase {
public:
    //
    ControlExec(std::vector<string> appParamsNames = std::vector<string>(), std::vector<string> appRenderParamsNames = std::vector<string>(), size_t cacheSize = 1000, int nThreads = 0);
    virtual ~ControlExec();
 
    //
    virtual void LoadState();
 
    //
    virtual void LoadState(const XmlNode *node);
 
    class RelAndAbsPathsExistException : public std::exception {
    public:
        const std::string AbsolutePath;
        const std::string RelativePath;
        RelAndAbsPathsExistException(const std::string &absolute, const std::string &relative)
                : AbsolutePath(absolute), RelativePath(relative) {}
    };
    enum class LoadStateRelAndAbsPathsExistAction { Ask, LoadAbs, LoadRel };
 
    //
    virtual int LoadState(string stateFile, LoadStateRelAndAbsPathsExistAction relAndAbsPathsExistAction = LoadStateRelAndAbsPathsExistAction::LoadAbs);
 
    //
    void SetNumThreads(size_t nthreads);
 
    size_t GetNumThreads() const;
 
    //
    void SetCacheSize(size_t sizeMB);
 
    //
    int NewVisualizer(string name);
 
    //
    string GetNewVisualizerUndoTag() const { return ("NewVisualizer"); }
 
    //
    void RemoveVisualizer(string name, bool hasOpenGLContext = false);
 
    //
    string GetRemoveVisualizerUndoTag() const { return ("RemoveVisualizer"); }
 
    //
    int InitializeViz(string name, GLManager *glManager);
 
    //
    int ResizeViz(string name, int width, int height);
    
    void ClearRenderCache(const string &winName, const string &inst);
    void ClearAllRenderCaches();
 
    GLManager::Vendor GetGPUVendor() const;
 
    int GetNumVisualizers() const { return (int)_visualizers.size(); }
 
    vector<string> GetVisualizerNames() const;
 
    int Paint(string name, bool force = false);
 
 
    //
    int ActivateRender(string winName, string dataSetName, string renderType, string renderName, bool on);
 
    int ActivateRender(string winName, string dataSetName, const RenderParams *rp, string renderName, bool on);
 
    //
    string GetActivateRendererUndoTag() const { return ("ActivateRenderer"); }
 
    void RemoveRenderer(string winName, string dataSetName, string renderType, string renderName, bool hasOpenGLContext);
 
    //
    string GetRemoveRendererUndoTag() const { return ("RemoveRenderer"); }
 
    void RemoveAllRenderers(string winName, bool hasOpenGLContext = false);
 
    //
    ParamsMgr *GetParamsMgr() const { return _paramsMgr; }
 
    //
    int SaveSession(string file);
 
#ifdef VAPOR3_0_0_ALPHA
    //
    int SavePreferences(string file);
 
    //
    int RestorePreferences(string file);
#endif
 
    //
    int OpenData(const std::vector<string> &files, const std::vector<string> &options, string dataSetName, string type = "vdc");
 
    void CloseData(string dataSetName);
 
    //
    std::vector<string> GetDataNames() const { return (_dataStatus->GetDataMgrNames()); }
 
    DataStatus *GetDataStatus() const { return _dataStatus; }
 
    //
    RenderParams *GetRenderParams(string winName, string dataSetName, string renderType, string instName) const;
 
    std::vector<string> GetRenderClassNames(string winName) const;
 
    std::vector<string> GetRenderInstances(string winName, string renderType) const;
 
    static vector<string> GetAllRenderClasses();
 
    //
    bool RenderLookup(string instName, string &winName, string &dataSetName, string &rendererType) const;
 
    string MakeRendererNameUnique(string name) const;
    
    //
    int DrawText(string winName, string text, int x, int y, int size, float color[3], int type = 0);
    int DrawTextNormalizedCoords(string winName, string text, float x, float y, int size, float color[3], int type = 0);
 
    //
    int DrawText(string text, int x, int y, int size, float color[3], int type = 0);
    int DrawTextNormalizedCoords(string text, float x, float y, int size, float color[3], int type = 0);
 
    int ClearText();
    int ClearText(string winName);
 
    bool Undo();
 
    //
    bool Redo();
 
    void UndoRedoClear();
 
    size_t UndoSize() const { return (_paramsMgr->UndoSize()); }
 
    size_t RedoSize() const { return (_paramsMgr->RedoSize()); }
 
    //
    void SetSaveStateEnabled(bool enabled) { _paramsMgr->SetSaveStateEnabled(enabled); }
 
    bool GetSaveStateEnabled() const { return (_paramsMgr->GetSaveStateEnabled()); }
 
    void RebaseStateSave() { _paramsMgr->RebaseStateSave(); }
 
    int EnableImageCapture(string filename, string winName, bool fast=false);
 
 
    int EnableAnimationCapture(string winName, bool doEnable, string filename = "");
 
    //
    static string MakeStringConformant(string s);
 
    //
    int AddFunction(string scriptType, string dataSetName, string scriptName, string script, const vector<string> &inputVarNames, const vector<string> &outputVarNames,
                    const vector<string> &outputVarMeshes, bool coordFlag = false);
 
    //
    void RemoveFunction(string scriptType, string dataSetName, string scriptName);
 
    //
    bool GetFunction(string scriptType, string dataSetName, string scriptName, string &script, vector<string> &inputVarNames, vector<string> &outputVarNames, vector<string> &outputVarMeshes,
                     bool &coordFlag) const;
 
    //
    string GetFunctionStdout(string scriptType, string dataSetName, string scriptName) const;
 
    std::vector<string> GetFunctionNames(string scriptType, string dataSetName) const;
 
    void CreateRenderers() { openDataHelper(true); }
 
private:
    ParamsMgr *                    _paramsMgr;
    DataStatus *                   _dataStatus;
    CalcEngineMgr *                _calcEngineMgr;
    std::map<string, Visualizer *> _visualizers;
 
    GLManager::Vendor _cachedVendor = GLManager::Vendor::Unknown;
 
    Visualizer *getVisualizer(string winName) const
    {
        std::map<string, Visualizer *>::const_iterator it;
        it = _visualizers.find(winName);
        if (it == _visualizers.end()) return NULL;
        return it->second;
    }
 
    int  openDataHelper(bool reportErrs);
    bool _undoRedoRenderer(bool undoFlag);
    bool _undoRedoVisualizer(bool undoFlag);
 
    int activateClassRenderers(string vizName, string dataSetName, string pClassName, vector<string> instNames, bool reportErrs);
 
    void _removeRendererHelper(string winName, string dataSetName, string paramsType, string renderName, bool removeFromParamsFlag, bool hasOpenGLContext);
 
    void _autoStretchExtents(string dataSetName);
 
    void _setDefaultOrigin(string datasetName);
};
};    // namespace VAPoR
 
#endif    // ControlExec_h