params.h

Go to the documentation of this file.

//************************************************************************
//                                  *
//           Copyright (C)  2004                *
//     University Corporation for Atmospheric Research          *
//           All Rights Reserved                *
//                                  *
//************************************************************************/
//
//  File:       params.h
//
//  Author:     Alan Norton
//          National Center for Atmospheric Research
//          PO 3000, Boulder, Colorado
//
//  Date:       October 2004
//
//  Description:    Defines the Params  classes.
//      This is an abstract class for all the tabbed panel params classes.
//      Supports functionality common to all the tabbed panel params.

//
#ifndef PARAMS_H
#define PARAMS_H

#include <vapor/XmlNode.h>
#include <vapor/ExpatParseMgr.h>
#include <vapor/ParamNode.h>
#include <map>

#include "assert.h"
#include <vapor/common.h>
#include <vapor/ParamsBase.h>
#include <vapor/RegularGrid.h>
#include "Box.h"

using namespace VetsUtil;

namespace VAPoR{

class XmlNode;
class ParamNode;
class DummyParams;
class RenderParams;
class ViewpointParams;
class RegionParams;
class DataMgrV3_0;
class Command;


class PARAMS_API Params : public MyBase, public ParamsBase {
    
public: 

Params(
    XmlNode *parent, const string &name, int winNum
 );
Params(int winNum, const string& name) : ParamsBase(name) {
    SetVizNum(winNum);
    if(winNum < 0) SetLocal(false); else SetLocal( true);
    
    previousClass = 0;
}

    virtual int GetInstanceIndex();

    static int GetCurrentParamsInstanceIndex(int pType, int winnum){
        return _currentParamsInstance[make_pair(pType,winnum)];
    }
    static int GetCurrentParamsInstanceIndex(const std::string tag, int winnum){
        return GetCurrentParamsInstanceIndex(GetTypeFromTag(tag),winnum);
    }
     
    static void SetCurrentParamsInstanceIndex(int pType, int winnum, int instance){
        _currentParamsInstance[make_pair(pType,winnum)] = instance;
    }
    
    static Params* GetParamsInstance(int pType, int winnum = -1, int instance = -1);

    static Params* GetParamsInstance(const std::string tag, int winnum = -1, int instance = -1){
        return GetParamsInstance(GetTypeFromTag(tag), winnum, instance);
    }

    static Params* GetCurrentParamsInstance(int pType, int winnum){
        Params* p = GetParamsInstance(pType, winnum, -1);
        if (!p) return p;
        if (p->IsLocal()) return p;
        return GetDefaultParams(pType);
    }
    
    static Params* GetDefaultParams(ParamsBase::ParamsBaseType pType){
        return _defaultParamsInstance[pType];
    }

    static Params* GetDefaultParams(const string& tag){
        return _defaultParamsInstance[GetTypeFromTag(tag)];
    }

    static void SetDefaultParams(int pType, Params* p) {
        _defaultParamsInstance[pType] = p;
    }

    static void SetDefaultParams(const string& tag, Params* p) {
        _defaultParamsInstance[GetTypeFromTag(tag)] = p;
    }
    static Params* CreateDefaultParams(int pType);
    
        
    static int GetNumParamsInstances(int pType, int winnum);

    static int GetNumParamsInstances(const std::string tag, int winnum){
        return GetNumParamsInstances(GetTypeFromTag(tag), winnum);
    }
    
    static void AppendParamsInstance(int pType, int winnum, Params* p){
        _paramsInstances[make_pair(pType,winnum)].push_back(p);
        if (pType == 3) assert (_paramsInstances[make_pair(pType,winnum)].size() <= 1);
    }

    static void AppendParamsInstance(const std::string tag, int winnum, Params* p){
        AppendParamsInstance(GetTypeFromTag(tag),winnum, p);
    }

    static void RemoveParamsInstance(int pType, int winnum, int instance);
    
    static vector<Params*>& GetAllParamsInstances(int pType, int winnum){
        map< pair<int,int>, vector<Params*> >::const_iterator it = _paramsInstances.find(make_pair(pType,winnum));
        if (it == _paramsInstances.end()) return (*new vector<Params*>);
        return _paramsInstances[make_pair(pType,winnum)];
    }
    static int GetAllParamsInstances(string tag, vector<Params*>&);
        
    static int DeleteVisualizer(int viznum);

    static vector<Params*>& GetAllParamsInstances(const std::string tag, int winnum){
        return GetAllParamsInstances(GetTypeFromTag(tag),winnum);
    }

    static map <int, vector<Params*> >* cloneAllParamsInstances(int winnum);

    static vector <Params*>* cloneAllDefaultParams();

    virtual void SetVizNum(int vnum){
        GetRootNode()->SetElementLong(_VisualizerNumTag,(long)vnum);
    }


    Params(const Params& p);
    virtual ~Params();

     virtual const std::string getShortName()=0;



    virtual void Validate(int type)=0;

    static bool IsRenderingEnabled(int winnum);
    
    bool isRenderParams() const;

    bool isBasicParams() const;

    virtual void restart() = 0;
    
    virtual int GetVizNum() {return (int)(GetValueLong(_VisualizerNumTag));}


    virtual int SetLocal(bool lg){
        return SetValueLong(_LocalTag,"set local or global",(long)lg);
    }

    virtual bool IsLocal() {
        return (GetValueLong(_LocalTag) != 0);
    }
    
    virtual Box* GetBox() {return 0;}

    //Following methods, while public, are not part of extensibility API
    
#ifndef DOXYGEN_SKIP_THIS
    
    static Params* CreateDummyParams(std::string tag);
    static void BailOut (const char *errstr, const char *fname, int lineno);

    static int getNumDummyClasses(){return _dummyParamsInstances.size();}
    static Params* getDummyParamsInstance(int i) {return _dummyParamsInstances[i];}
    static void addDummyParamsInstance(Params*const & p ) {_dummyParamsInstances.push_back(p);}

    static void clearDummyParamsInstances();
    static const std::string paramName(ParamsBaseType t);
    
    static const string _regionParamsTag;
    static const string _viewpointParamsTag;
    static const string _animationParamsTag;
    static const string _visualizerFeaturesParamsTag;
    static const string _arrowParamsTag;
    static const string _isolineParamsTag;
    static const string _RefinementLevelTag;
    static const string _CompressionLevelTag;
    static const string _VisualizerNumTag;
    static const string _LocalTag;
    static const string _IsoControlTag;
    static const string _IsoValueTag;
    static const string _Variables3DTag;
    static const string _Variables2DTag;
    
#endif
protected:

    virtual int SetValueLong(string tag, const char* description, long value)
        {return ParamsBase::SetValueLong(tag,description,value, this);}

    virtual int SetValueLong(string tag, const char* description, const vector<long>& value)
        {return ParamsBase::SetValueLong(tag, description, value, this);}

    virtual int SetValueDouble(string tag, const char* description, double value)
        {return ParamsBase::SetValueDouble(tag,description,value,this);}

    virtual int SetValueDouble(string tag, const char* description, const vector<double>& value)
        {return ParamsBase::SetValueDouble(tag,description,value,this);}


    virtual int SetValueString(string tag, const char* description, const string& value)
        {return ParamsBase::SetValueString(tag,description,value,this);}

    virtual int SetValueStringVec(string tag, const char* description, const vector<string>& value)
        {return ParamsBase::SetValueStringVec(tag, description, value, this);}

#ifndef DOXYGEN_SKIP_THIS
    
    //Params instances are vectors of Params*, one per instance, indexed by paramsBaseType, winNum
    static map<pair<int,int>,vector<Params*> > _paramsInstances;
    //CurrentRenderParams indexed by paramsBaseType, winNum
    static map<pair<int,int>, int> _currentParamsInstance;
    //Dummy params are those that are found in a session file but not 
    //available in the current code.
    //default params instances indexed by paramsBaseType
    static map<int, Params*> _defaultParamsInstance;
    static vector<Params*> _dummyParamsInstances;
#endif //DOXYGEN_SKIP_THIS
};
class PARAMS_API BasicParams : public Params {
public:
    BasicParams(XmlNode *parent, const string &name) : Params(parent, name, -1) {}
};


#ifndef DOXYGEN_SKIP_THIS
//Note that DummyParams are not part of the Public API
//These provide a repository for Params state for Params classes that are not
//Available at run time.
class DummyParams : public Params {
    public:
        DummyParams(XmlNode *parent, const std::string tag, int winnum);
    virtual ~DummyParams(){}
    virtual void restart(){}
    
    virtual void Validate(int) {return;}
    
    virtual bool usingVariable(const std::string& ){
        return false;
    }
    const std::string getShortName(){return _tag;}

    std::string _tag;

};


#endif //DOXYGEN_SKIP_THIS
}; //End namespace VAPoR
#endif //PARAMS_H