EventDisplay/GfxDigitListCfg.cxx

Go to the documentation of this file.

#include "GfxDigitListCfg.h"
#include "Registry/Registry.h"

#include <iostream>
using namespace std;

GfxDigitListCfg::GfxDigitListCfg(Registry* init_config)
{
//    cerr << "GfxDigitListCfg(" << init_config << ")\n";

    if (init_config) this->CommitDefaultConfig(*init_config);
    else {
        Registry r(false);
        r.Set("SizeIs","Charge");
        r.Set("ScaleIs","Relative");
        r.Set("DigitEndStyle","BowTie");
        r.Set("SizeBy","Area");
        r.Set("ShapeIs","Rectangle");
        r.Set("SizeFactor",5.0);
        this->CommitDefaultConfig(r);
        this->GetConfig() = r;
    }

    Registry size_reg;
    size_reg.SetName("Size Is");
    size_reg.Set("Time","Time");
    size_reg.Set("Charge","Charge");
    
    Registry scale_reg;
    scale_reg.SetName("Scale Is");
    scale_reg.Set("Absolute","Absolute");
    scale_reg.Set("Relative","Relative");

    Registry sestyle_reg;
    sestyle_reg.SetName("Digit End Style");
    sestyle_reg.Set("Half","Half");
    sestyle_reg.Set("Full","Full");
    sestyle_reg.Set("BowTie","BowTie");
    sestyle_reg.Set("Bit","Bit");
    
    Registry sizeby_reg;
    sizeby_reg.SetName("Size by");
    sizeby_reg.Set("Area","Area");
    sizeby_reg.Set("Fixed","Fixed");
    sizeby_reg.Set("Linear","Linear");
    sizeby_reg.Set("LogLinear","LogLinear");
    sizeby_reg.Set("LogArea","LogArea");

    Registry shape_reg;
    shape_reg.SetName("Shape type");
    shape_reg.Set("Rectangle","Rectangle");
    shape_reg.Set("Ellipse","Ellipse");

    Registry possibles;
    possibles.Set("SizeIs",size_reg);
    possibles.Set("ScaleIs",scale_reg);
    possibles.Set("DigitEndStyle",sestyle_reg);
    possibles.Set("SizeBy",sizeby_reg);
    possibles.Set("ShapeIs",shape_reg);

    this->SetPossibles(possibles);
}

GfxDigitListCfg::~GfxDigitListCfg()
{

}

double GfxDigitListCfg::GetSizeFactor()
{
//    cerr << this->GetConfig() << endl;

    double sf = 1.0;
    if (! this->GetConfig().Get("SizeFactor",sf)) {
//        cerr << "Failed to get SizeFactor\n";
        return 1.0;
    }
    return sf;
}

// convert from Registry to enums.  
// FIXME: May want to cache these in the future....

GfxDigitListCfg::DigitEnd_t GfxDigitListCfg::GetStripEnd()
{
    const char* value;
    if (! this->GetConfig().Get("DigitEndStyle",value)) return kFull;
    std::string vstr = value;
    if (vstr == "Half") return kHalf;
    if (vstr == "Bit") return kBit;
    if (vstr == "BowTie") return kBowTie;
    return kFull;
}
GfxDigitListCfg::MeasureScale_t GfxDigitListCfg::GetSizeIs()
{
    const char* value;
    if (! this->GetConfig().Get("SizeIs",value)) return kTime;
    std::string vstr = value;
    if (vstr == "Charge") return kCharge;
    return kTime;
}
GfxDigitListCfg::ScaleIs_t GfxDigitListCfg::GetScaleIs()
{
    const char* value;
    if (! this->GetConfig().Get("ScaleIs",value)) return kAbsolute;
    std::string vstr = value;
    if (vstr == "Relative") return kRelative;
    return kAbsolute;
}
GfxDigitListCfg::SizeBy_t GfxDigitListCfg::GetSizeBy()
{
    const char* value;
    if (! this->GetConfig().Get("SizeBy",value)) return kArea;
    std::string vstr = value;
    if (vstr == "Fixed") return kFixed;
    if (vstr == "Linear") return kLinear;
    if (vstr == "LogLinear") return kLogLinear;
    if (vstr == "LogArea") return kLogArea;
    return kArea;
}
GfxDigitListCfg::ShapeIs_t GfxDigitListCfg::GetShapeIs()
{
    const char* value;
    if (!this->GetConfig().Get("ShapeIs",value)) return kRectangle;
    std::string vstr = value;
    if (vstr == "Ellipse") return kEllipse;
    return kRectangle;
}

---