vizwinparams.h

Go to the documentation of this file.

//************************************************************************
//                                                                      *
//           Copyright (C)  1024                                        *
//     University Corporation for Atmospheric Research                  *
//           All Rights Reserved                                        *
//                                                                      *
//************************************************************************/
//
//  File:       vizwinparams.h
//
//  Author:     Alan Norton
//          National Center for Atmospheric Research
//          PO 3000, Boulder, Colorado
//
//  Date:       April 2014
//
//  Description:    Defines the VizWinParams class.
//      This Params class is global.  Specifies properties of the VizWindows
//      Also has various static methods for obtaining and setting properties of the VizWindows
//      Each vizwin has associated with it the following:
//      index >= 0, indicating the visualizer number (as used by the ControlExec)
//      name, a string
//      width and height 
//      Several attributes apply to the set of visualizers:
//      the "current" visualizer
//      the number of visualizers
//      
//
#ifndef VIZWINPARAMS_H
#define VIZWINPARAMS_H


#include <vector>
#include <map>
#include <algorithm>
#include <vapor/common.h>
#include "params.h"
#include <vapor/MyBase.h>


using namespace VetsUtil;

namespace VAPoR {


class PARAMS_API VizWinParams : public BasicParams {
    
public: 

    static int AddVizWin(const std::string name, int viznum, int width, int height);

    static int RemoveVizWin(int viz);

    static int  GetCurrentVizWin(){
        return ((VizWinParams*)Params::GetParamsInstance(_vizWinParamsTag))->getCurrentVizWin();
    }
    static int SetCurrentVizWin(int viz){
        return ((VizWinParams*)Params::GetParamsInstance(_vizWinParamsTag))->setCurrentVizWin(viz);
    }
    static int GetWindowWidth(int viznum){
        int winnum = mapVizToWin(viznum);
        if (winnum < 0) return -1;
        return ((VizWinParams*)Params::GetParamsInstance(_vizWinParamsTag))->getWindowWidths()[winnum];
    }

    static int GetWindowHeight(int viznum){
        int winnum = mapVizToWin(viznum);
        if (winnum < 0) return -1;
        return ((VizWinParams*)Params::GetParamsInstance(_vizWinParamsTag))->getWindowHeights()[winnum];
    }
    
    static int SetWindowWidth(int viznum, int width){
        int winnum = mapVizToWin(viznum);
        if (winnum < 0) return -1;
        std::vector<long> widths =  ((VizWinParams*)Params::GetParamsInstance(_vizWinParamsTag))->getWindowWidths();
        widths[winnum] = width;
        return ((VizWinParams*)Params::GetParamsInstance(_vizWinParamsTag))->setWindowWidths(widths);
    }
    static int SetWindowHeight(int viznum, int height){
        int winnum = mapVizToWin(viznum);
        if (winnum < 0) return -1;
        vector<long>heights =  ((VizWinParams*)Params::GetParamsInstance(_vizWinParamsTag))->getWindowHeights();
        heights[winnum] = height;
        return ((VizWinParams*)Params::GetParamsInstance(_vizWinParamsTag))->setWindowHeights(heights);
    }

    static int SetVizName(int viznum, string name){
        int winnum = mapVizToWin(viznum);
        if (winnum < 0) return -1;
        vector<string> names = ((VizWinParams*)Params::GetParamsInstance(_vizWinParamsTag))->getWindowNames();
        names[winnum] = name;
        return ((VizWinParams*)Params::GetParamsInstance(_vizWinParamsTag))->setWindowNames(names);
    }
    static string GetVizName(int viznum){
        int winnum = mapVizToWin(viznum);
        if (winnum < 0) return _emptyString;
        return ((VizWinParams*)Params::GetParamsInstance(_vizWinParamsTag))->getWindowNames()[winnum];
    }

    static int GetNumVizWins(){
        return ((VizWinParams*)Params::GetParamsInstance(_vizWinParamsTag))->getVisualizerNums().size();
    }
    static vector<long> GetVisualizerNums(){
        return ((VizWinParams*)Params::GetParamsInstance(_vizWinParamsTag))->getVisualizerNums();
    }

    static void SetVizDirty(int viznum, bool val = true){
        if (_vizDirtyBits.size()== 0) return;
        if (viznum >= 0) _vizDirtyBits[viznum] = val;
        else for (int i = 0; i< _vizDirtyBits.size(); i++) _vizDirtyBits[i] = val;
    }

    static bool VizIsDirty(int viznum) {
        return _vizDirtyBits[viznum];
    }
    

    VizWinParams(XmlNode* parent, int winnum);

    virtual ~VizWinParams();
    
    virtual void Validate(int type);
    virtual void restart();
    
    static ParamsBase* CreateDefaultInstance() {return new VizWinParams(0, -1);}
    const std::string getShortName() {return _shortName;}
    vector<long> getVisualizerNums(){
        return GetValueLongVec(_visualizerNumsTag);
    }
    int getCurrentVizWin(){
        return GetValueLong(_currentWindowTag);
    }


#ifndef DOXYGEN_SKIP_THIS
    
    static const string _vizWinParamsTag;
    static const string _shortName;
    static const string _windowWidthsTag;
    static const string _windowHeightsTag;
    static const string _windowNamesTag;
    static const string _currentWindowTag;
    static const string _visualizerNumsTag;
    static const string _emptyString;

private:
    static int mapVizToWin(int viznum){
        vector<long> viznums = ((VizWinParams*)Params::GetParamsInstance(_vizWinParamsTag))->getVisualizerNums();
        for (int i = 0; i<viznums.size(); i++){
            if (viznums[i] == viznum) return i;
        }
        return -1;
    }

    static int mapWinToViz(int winnum){
        vector<long> viznums = ((VizWinParams*)Params::GetParamsInstance(_vizWinParamsTag))->getVisualizerNums();
        if (winnum < 0 || winnum >= viznums.size()) return -1;
        return viznums[winnum];
    }

    int setCurrentVizWin(int viz){
        return SetValueLong(_currentWindowTag, "Set current viz win",(long)viz);
    }
    
    vector<long> getWindowWidths(){
        return GetValueLongVec(_windowWidthsTag);
    }
    vector<long>getWindowHeights(){
        return GetValueLongVec(_windowHeightsTag);
    }
    int setWindowWidths(const vector<long> widths){
        return SetValueLong(_windowWidthsTag, "Set window widths",widths);
    }

    int setWindowHeights(const vector<long>& heights){
        return SetValueLong(_windowHeightsTag, "Set window heights",heights);
    }
    
    int setVisualizerNums(const vector<long>& viznums){
        return SetValueLong(_visualizerNumsTag,"Set visualizer numbers",viznums);
    }
    vector<string> getWindowNames(){
        std::vector<string> names;
        GetValueStringVec(_windowNamesTag,names);
        //convert "_" to " ":
        for (int i = 0; i<names.size(); i++){
            std::replace(names[i].begin(),names[i].end(),'_',' ');
        }
        return names;
    }
    int setWindowNames(const vector<string> names){
        //Replace blanks with underscores
        vector<string> namemod = names;
        for (int i = 0; i<namemod.size(); i++){
            std::replace(namemod[i].begin(),namemod[i].end(),' ','_');
        }
        return SetValueStringVec(_windowNamesTag," Set visualizer names", namemod);
    }
    static vector<bool> _vizDirtyBits;
    
#endif //DOXYGEN_SKIP_THIS
};

};
#endif //VIZWINPARAMS_H