A single row for editing a single parameter in a set. More...

#include "ParameterSetEditDialog.h"

Public Member Functions
	ParameterSetEditRow (ParameterSetEditFrame frame, TGHorizontalFrame lhs, TGHorizontalFrame *rhs, const fhicl::ParameterSet &ps, const std::string &key)

	~ParameterSetEditRow ()

void	Finalize ()

std::string	AsFHICL () const

void	TextEntryReturnPressed ()

void	ListBoxSelectionChanged ()

void	ListBoxSelected (int id)

void	RadioButtonClicked ()

void	CheckButtonClicked ()

void	SliderPositionChanged ()

Public Attributes
ParameterSetEditFrame *	fFrame
	The parent frame. More...

TGHorizontalFrame *	fMother
	Top level frame. More...

TGLayoutHints *	fRightLH
	Align to right. More...

TGLayoutHints *	fLeftLH
	Align to left. More...

TGTextButton *	fLabel
	Label on the left. More...

TGTextEntry *	fTextEntry

TGListBox *	fListBox

TGDoubleSlider *	fSlider

std::vector< TGRadioButton * >	fRadioButton

std::vector< TGCheckButton * >	fCheckButton

unsigned int	fParamFlags

std::string	fKEY

std::string	fGUI

std::string	fDOC

std::vector< std::string >	fChoice

std::string	fValue

Private Member Functions
void	SetupTextEntry (TGCompositeFrame *f, unsigned int flags, const std::vector< std::string > &value)

void	SetupListBox (TGCompositeFrame *f, const std::vector< std::string > &choice, const std::vector< std::string > &value, bool ismulti)

void	SetupRadioButtons (TGCompositeFrame *f, const std::vector< std::string > &choice, const std::vector< std::string > &value)

void	SetupCheckButton (TGCompositeFrame *f, const std::vector< std::string > &choice, const std::vector< std::string > &value)

void	SetupSlider (TGCompositeFrame *f, const std::vector< std::string > &choice, const std::vector< std::string > &value)

Static Private Member Functions
static bool	IsLegalGUItag (const std::string &s)

static void	ParseGUItag (const std::string &guitag, std::string &frame, std::vector< std::string > &choice)

static void	UnpackParameter (const fhicl::ParameterSet &ps, const std::string &key, unsigned int &flags, std::string &tag, std::vector< std::string > &choice, std::vector< std::string > &value, std::string &gui, std::string &doc)

Detailed Description

A single row for editing a single parameter in a set.

===================================================================

Definition at line 85 of file ParameterSetEditDialog.h.

Constructor & Destructor Documentation

ParameterSetEditRow::ParameterSetEditRow	(	ParameterSetEditFrame *	frame,
		TGHorizontalFrame *	lhs,
		TGHorizontalFrame *	rhs,
		const fhicl::ParameterSet &	ps,
		const std::string &	key
	)

Definition at line 71 of file ParameterSetEditDialog.cxx.

References fChoice, fDOC, fGUI, fLabel, fLeftLH, fParamFlags, fRightLH, fValue, kCHECK_BOX, kINTEGER_PARAM, kLIST_BOX_MULTI, kLIST_BOX_SINGLE, kPARAMETER_SET_PARAM, kRADIO_BUTTONS, kSLIDER, kSLIDER_INT, kTEXT_ENTRY, kVECTOR_PARAM, SetupCheckButton(), SetupListBox(), SetupRadioButtons(), SetupSlider(), SetupTextEntry(), and UnpackParameter().

                                                                :
   fFrame(frame),
   fRightLH(0),
   fLeftLH(0),
   fLabel(0),
   fTextEntry(0),
   fListBox(0),
   fSlider(0),
   fKEY(key)
 {
   //
   // Extract information about the parameter for which we are building
   // the GUI
   //
   std::string              tag;    // What sort of frame to build?
   std::vector<std::string> values; // What is the current value?
   this->UnpackParameter(ps, key, fParamFlags, tag, fChoice, values, fGUI, fDOC);
   if (values.empty()){
     // What happened here? We'll crash if we continue though, so bail out.
     return;
   }
 
   if (fParamFlags&kVECTOR_PARAM) {
     fValue = "[";
     for (unsigned int i=0; i<values.size(); ++i) {
       fValue += values[i];
       if (i+1<values.size()) fValue += ",";
       else                   fValue += "]";
     }
   }
   else if(fParamFlags&kPARAMETER_SET_PARAM){
     fValue  = "{";
     fValue += values[0];
     fValue += "}";
   }
   else {
     fValue = values[0];
   }
 
   fLeftLH  = new TGLayoutHints(kLHintsLeft, 1,1,0,0);
   fRightLH = new TGLayoutHints(kLHintsRight,1,1,0,0);
 
   fLabel = new TGTextButton(lhs,
                             key.c_str(),
                             -1,
                             TGButton::GetDefaultGC()(),
                             TGTextButton::GetDefaultFontStruct(),
                             0);
   lhs->AddFrame(fLabel);
   fLabel->SetToolTipText(fDOC.c_str());
   fLabel->SetTextJustify(kTextRight);
 
   if (tag==kTEXT_ENTRY) {
     this->SetupTextEntry(rhs, fParamFlags, values);
   }
   if (tag==kLIST_BOX_SINGLE) {
     this->SetupListBox(rhs, fChoice, values, false);
   }
   if (tag==kLIST_BOX_MULTI) {
     this->SetupListBox(rhs, fChoice, values, true);
   }
   if (tag==kRADIO_BUTTONS) {
     this->SetupRadioButtons(rhs, fChoice, values);
   }
   if (tag==kCHECK_BOX) {
     this->SetupCheckButton(rhs, fChoice, values);
   }
   if (tag==kSLIDER) {
     this->SetupSlider(rhs, fChoice, values);
   }
   if (tag==kSLIDER_INT) {
     fParamFlags |= kINTEGER_PARAM;
     this->SetupSlider(rhs, fChoice, values);
   }
 }

ParameterSetEditRow::~ParameterSetEditRow ( )

Definition at line 153 of file ParameterSetEditDialog.cxx.

References fCheckButton, fLabel, fLeftLH, fListBox, fRadioButton, fRightLH, fSlider, and fTextEntry.

 {
   unsigned int i;
   for (i=0; i<fCheckButton.size(); ++i) {
     if (fCheckButton[i]) delete fCheckButton[i];
   }
   for (i=0; i<fRadioButton.size(); ++i) {
     if (fRadioButton[i]) delete fRadioButton[i];
   }
   if (fSlider)    delete fSlider;
   if (fListBox)   delete fListBox;
   if (fTextEntry) delete fTextEntry;
   if (fLeftLH)    delete fLeftLH;
   if (fRightLH)   delete fRightLH;
   if (fLabel)     delete fLabel;
 }

Member Function Documentation

std::string ParameterSetEditRow::AsFHICL ( ) const

Definition at line 632 of file ParameterSetEditDialog.cxx.

References fDOC, fGUI, fKEY, fParamFlags, fValue, kNO_GUI_TAGS, and s.

 {
   std::ostringstream s;
   if (fParamFlags & kNO_GUI_TAGS) {
     s << fKEY << ":" << fValue << " ";
   }
   else {
     s << fKEY
       << ": { "
       << "val:" << fValue << " "
       << "gui:\"" << fGUI << "\" "
       << "doc:\"" << fDOC << "\" "
       << "}";
   }
   return s.str();
 }

void ParameterSetEditRow::CheckButtonClicked ( )

Definition at line 573 of file ParameterSetEditDialog.cxx.

References fCheckButton, fFrame, fValue, evdb::ParameterSetEditFrame::Modified(), and fhicl::detail::atom::value().

 {
   int value = 0;
   for (unsigned int i=0; i<fCheckButton.size(); ++i) {
     if (fCheckButton[i]->IsDown()) value |= 1<<i;
   }
   char buff[256];
   sprintf(buff, "%d", value);
   fValue = buff;
   fFrame->Modified();
 }

void ParameterSetEditRow::Finalize ( )

Definition at line 621 of file ParameterSetEditDialog.cxx.

References fTextEntry, fValue, and TextEntryReturnPressed().

 {
   if (fTextEntry) {
     if (fValue != fTextEntry->GetBuffer()->GetString()) {
       this->TextEntryReturnPressed();
     }
   }
 }

bool ParameterSetEditRow::IsLegalGUItag ( const std::string & s )

staticprivate

Definition at line 320 of file ParameterSetEditDialog.cxx.

References LOG_ERROR.

Referenced by ParseGUItag().

 {
   for(unsigned int i=0; i<gsGUITAG.size(); ++i) {
     if (s==gsGUITAG[i]) return true;
   }
   LOG_ERROR("ParameterSetEditDialog") << s << " is not a legal GUI tag.";
   return false;
 }

void ParameterSetEditRow::ListBoxSelected ( int id )

Definition at line 543 of file ParameterSetEditDialog.cxx.

References fChoice, fFrame, fListBox, fValue, and evdb::ParameterSetEditFrame::Modified().

 {
   //
   // Only handle single selection list boxes here
   //
   if (fListBox->GetMultipleSelections()) return;
   fValue = fChoice[id];
   fFrame->Modified();
 }

void ParameterSetEditRow::ListBoxSelectionChanged ( )

Definition at line 517 of file ParameterSetEditDialog.cxx.

References fChoice, fFrame, fListBox, fValue, and evdb::ParameterSetEditFrame::Modified().

 {
   //
   // Only need to handle list boxes where multiple selections are
   // allowed here.
   //
   if (fListBox->GetMultipleSelections()==0) return;
 
   fValue = "[";
   TList selections;
   fListBox->GetSelectedEntries(&selections);
   TGLBEntry* sel;
   bool isfirst = true;
   for (unsigned int i=0;;++i) {
     sel = (TGLBEntry*)selections.At(i);
     if (sel==0) break;
     if (!isfirst) fValue += ",";
     fValue += fChoice[sel->EntryId()];
     isfirst = false;
   }
   fValue += "]";
   fFrame->Modified();
 }

void ParameterSetEditRow::ParseGUItag	(	const std::string &	guitag,
		std::string &	frame,
		std::vector< std::string > &	choice
	)

staticprivate

Definition at line 291 of file ParameterSetEditDialog.cxx.

References IsLegalGUItag(), kTEXT_ENTRY, and s.

Referenced by UnpackParameter().

 {
   //
   // Get the frame name. Should be piece just before the ":"
   //
   choice.clear();
   size_t icolon = guitag.find(':');
   if (icolon == std::string::npos) frame = guitag;
   else                             frame = guitag.substr(0,icolon);
   if (!IsLegalGUItag(frame))       frame = kTEXT_ENTRY;
 
   //
   // Get the list of choices. Should be comma separated.
   //
   size_t icomma = icolon;
   size_t spos, epos;
   while (icomma!=std::string::npos) {
     spos = icomma+1;
     epos = guitag.find(',',spos);
     std::string s = guitag.substr(spos,epos-spos);
     choice.push_back(s);
     icomma = epos;
   }
 }

void ParameterSetEditRow::RadioButtonClicked ( )

Definition at line 554 of file ParameterSetEditDialog.cxx.

References fFrame, fRadioButton, fValue, evdb::ParameterSetEditFrame::Modified(), and fhicl::detail::atom::value().

 {
   unsigned int value = 0;
   TGButton* b = (TGButton*)gTQSender;
   int id = b->WidgetId();
   for (size_t i=0; i<fRadioButton.size(); ++i) {
     if (fRadioButton[i]->WidgetId() != id) {
       fRadioButton[i]->SetState(kButtonUp);
     }
     else value = i;
   }
   char buff[256];
   sprintf(buff, "%d", value);
   fValue = buff;
   fFrame->Modified();
 }

void ParameterSetEditRow::SetupCheckButton	(	TGCompositeFrame *	f,
		const std::vector< std::string > &	choice,
		const std::vector< std::string > &	value
	)

private

Definition at line 417 of file ParameterSetEditDialog.cxx.

References fCheckButton.

Referenced by ParameterSetEditRow().

 {
   unsigned int mask;
   unsigned int v = atoi(value[0].c_str());
   for (size_t i=0; i<choice.size(); ++i) {
     TGCheckButton* b = new TGCheckButton(f, choice[i].c_str(), i);
     f->AddFrame(b);
     b->Connect("Clicked()",
                "evdb::ParameterSetEditRow",
                this,
                "CheckButtonClicked()");
 
     mask = (0x1)<<i;
     if (v&mask) b->SetState(kButtonDown);
 
     fCheckButton.push_back(b);
   }
 }

void ParameterSetEditRow::SetupListBox	(	TGCompositeFrame *	f,
		const std::vector< std::string > &	choice,
		const std::vector< std::string > &	value,
		bool	ismulti
	)

private

Definition at line 361 of file ParameterSetEditDialog.cxx.

References fListBox, kRowH, and kRowW.

Referenced by ParameterSetEditRow().

 {
   fListBox = new TGListBox(f);
   f->AddFrame(fListBox);
   if (ismulti) fListBox->SetMultipleSelections();
 
   for (size_t i=0; i<choice.size(); ++i) {
     fListBox->AddEntry(choice[i].c_str(), i);
     for (size_t j=0; j<value.size(); ++j) {
       if (value[j]==choice[i]) fListBox->Select(i);
     }
   }
 
   fListBox->Connect("SelectionChanged()",
                     "evdb::ParameterSetEditRow",
                     this,
                     "ListBoxSelectionChanged()");
   fListBox->Connect("Selected(Int_t)",
                     "evdb::ParameterSetEditRow",
                     this,
                     "ListBoxSelected(int)");
 
   size_t h = kRowH*choice.size();
   if (h>3*kRowH) h = 3*kRowH;
   fListBox->Resize(kRowW,h);
 }

void ParameterSetEditRow::SetupRadioButtons	(	TGCompositeFrame *	f,
		const std::vector< std::string > &	choice,
		const std::vector< std::string > &	value
	)

private

Definition at line 393 of file ParameterSetEditDialog.cxx.

References fRadioButton.

Referenced by ParameterSetEditRow().

 {
   unsigned int v = atoi(value[0].c_str());
 
   for (size_t i=0; i<choice.size(); ++i) {
     TGRadioButton* b = new TGRadioButton(f, choice[i].c_str(), i);
     f->AddFrame(b);
 
     b->SetTextJustify(kTextLeft);
     b->Connect("Clicked()",
                "evdb::ParameterSetEditRow",
                this,
                "RadioButtonClicked()");
 
     if (i==v) b->SetState(kButtonDown);
 
     fRadioButton.push_back(b);
   }
 }

void ParameterSetEditRow::SetupSlider	(	TGCompositeFrame *	f,
		const std::vector< std::string > &	choice,
		const std::vector< std::string > &	value
	)

private

Definition at line 438 of file ParameterSetEditDialog.cxx.

References fSlider, fTextEntry, kRowH, kRowW, max, and min.

Referenced by ParameterSetEditRow().

 {
   fTextEntry = new TGTextEntry(f);
   f->AddFrame(fTextEntry);
 
   std::string t;
   if (value.size()==1) { t = value[0]; }
   if (value.size()==2) {
     t = "["; t += value[0]; t += ","; t += value[1]; t += "]";
   }
   fTextEntry->SetText(t.c_str());
 
   fTextEntry->Connect("ReturnPressed()",
                       "evdb::ParameterSetEditRow",
                       this,
                       "TextEntryReturnPressed()");
 
   fSlider = new TGDoubleHSlider(f, 100, kDoubleScaleBoth);
   f->AddFrame(fSlider);
 
   float min = atof(choice[0].c_str());
   float max = atof(choice[1].c_str());
 
   float pos1 = 0;
   float pos2 = 0;
   if (value.size()==1) {
     pos1 = atof(value[0].c_str());
     pos2 = pos1;
   }
   if (value.size()==2) {
     pos1 = atof(value[0].c_str());
     pos2 = atof(value[1].c_str());
   }
 
   fSlider->SetRange(min, max);
   fSlider->SetPosition(pos1, pos2);
 
   fSlider->Connect("PositionChanged()",
                    "evdb::ParameterSetEditRow",
                    this,
                    "SliderPositionChanged()");
 
   fTextEntry->Resize(kRowW*1/5,   kRowH);
   fSlider->   Resize(kRowW*4/5,10*kRowH);
 }

void ParameterSetEditRow::SetupTextEntry	(	TGCompositeFrame *	f,
		unsigned int	flags,
		const std::vector< std::string > &	value
	)

private

Definition at line 331 of file ParameterSetEditDialog.cxx.

References fTextEntry, kPARAMETER_SET_PARAM, kRowH, kRowW, and kVECTOR_PARAM.

Referenced by ParameterSetEditRow().

 {
   static TColor* c = gROOT->GetColor(41);
 
   fTextEntry = new TGTextEntry(f);
   f->AddFrame(fTextEntry);
   fTextEntry->SetTextColor(c);
 
   fTextEntry->Connect("ReturnPressed()",
                       "evdb::ParameterSetEditRow",
                       this,
                       "TextEntryReturnPressed()");
 
   std::string buff;
   if (flags&kVECTOR_PARAM) buff += "[";
   if (flags&kPARAMETER_SET_PARAM) buff += "{";
   for (unsigned int i=0; i<value.size(); ++i) {
     buff += value[i];
     if ((i+1)!=value.size()) buff += ",";
   }
   if (flags&kVECTOR_PARAM) buff += "]";
   if (flags&kPARAMETER_SET_PARAM) buff += "}";
   fTextEntry->SetText(buff.c_str(), 0);
   fTextEntry->Resize(kRowW,kRowH);
 }

void ParameterSetEditRow::SliderPositionChanged ( )

Definition at line 587 of file ParameterSetEditDialog.cxx.

References fFrame, fParamFlags, fSlider, fTextEntry, fValue, kINTEGER_PARAM, kVECTOR_PARAM, and evdb::ParameterSetEditFrame::Modified().

 {
   char buff[1024];
   float mn, mx, ave;
   fSlider->GetPosition(mn, mx);
 
   ave = 0.5*(mn+mx);
 
   if (fParamFlags & kINTEGER_PARAM) {
     int mni  = rint(mn);
     int mxi  = rint(mx);
     int avei = rint(ave);
     if (fParamFlags & kVECTOR_PARAM) {
       sprintf(buff, "[%d, %d]",mni,mxi);
     }
     else {
       sprintf(buff, "%d",avei);
     }
   }
   else {
     if (fParamFlags & kVECTOR_PARAM) {
       sprintf(buff, "[%.1f, %.1f]",mn,mx);
     }
     else {
       sprintf(buff, "%.1f",ave);
     }
   }
   fTextEntry->SetText(buff);
   fValue = buff;
   fFrame->Modified();
 }

void ParameterSetEditRow::TextEntryReturnPressed ( )

Definition at line 488 of file ParameterSetEditDialog.cxx.

References larg4::f1, larg4::f2, fFrame, fSlider, fTextEntry, fValue, evdb::ParameterSetEditFrame::Modified(), and n.

Referenced by Finalize().

 {
   if (fTextEntry==0) return;
 
   const char* text = fTextEntry->GetBuffer()->GetString();
 
   static TColor* c = gROOT->GetColor(1);
   fTextEntry->SetTextColor(c);
 
   //
   // If we also have a slider connected to this frame, make sure its
   // state is updated
   //
   if (fSlider) {
     int   n=0;
     float f1=0, f2=0;
     n = sscanf(text, "[%f, %f]", &f1, &f2);
     if (n!=2) {
       n = sscanf(text, "%f", &f1);
       f2 = f1;
     }
     fSlider->SetPosition(f1, f2);
   }
   fValue = text;
   fFrame->Modified();
 }

void ParameterSetEditRow::UnpackParameter	(	const fhicl::ParameterSet &	ps,
		const std::string &	key,
		unsigned int &	flags,
		std::string &	tag,
		std::vector< std::string > &	choice,
		std::vector< std::string > &	value,
		std::string &	gui,
		std::string &	doc
	)

staticprivate

Definition at line 172 of file ParameterSetEditDialog.cxx.

References fhicl::ParameterSet::get(), kHAVE_GUI_TAGS, kNO_GUI_TAGS, kPARAMETER_SET_PARAM, kSINGLE_VALUED_PARAM, kTEXT_ENTRY, kVECTOR_PARAM, LOG_ERROR, ParseGUItag(), s, and fhicl::ParameterSet::to_string().

Referenced by ParameterSetEditRow().

 {
   std::string guikey = key; guikey += ".gui";
   std::string dockey = key; dockey += ".doc";
 
   flag = 0;
 
   //
   // Try to extract GUI tags
   //
   try {
     gui = p.get< std::string >(guikey);
     doc = p.get< std::string >(dockey);
     flag |= kHAVE_GUI_TAGS;
   }
   catch (...) {
     //
     // If they aren't there, try extracting it as a normal
     // parameter. Default to providing the user with a text entry box.
     //
     gui = kTEXT_ENTRY;
     doc = "See .fcl file for documentation...";
     flag |= kNO_GUI_TAGS;
   }
 
   //
   // Parse out the GUI string to find out what type of frame to build
   // and the choices we should present to the user
   //
   ParseGUItag(gui, tag, choice);
 
   //
   // Now extract the assigned value(s) of the parameter
   //
   // The key is either just the key, or in the case of GUI-enabled
   // parameters the key name with ".val" appended
   //
   std::string valkey = key;
   if ( flag&kHAVE_GUI_TAGS ) valkey += ".val";
   //
   // Try first to extract a single value.
   //
   try {
     std::string v = p.get<std::string>(valkey);
     value.push_back(v);
     flag |= kSINGLE_VALUED_PARAM;
   }
   catch (...) {
     //
     // If that fails, try extracting multiple values
     //
     try {
       value = p.get< std::vector<std::string> >(valkey);
       flag |= kVECTOR_PARAM;
       if (value.size()==0) value.push_back("");
     }
     catch (...) {
       //
       // Yikes - vector of vectors, perhaps?
       //
       try {
         std::vector< std::vector <std::string> > vv;
         vv = p.get<std::vector<std::vector<std::string> > >(valkey);
         //
         // Vectors of vectors are treated as vectors of
         // std::strings. The strings assigned to the values are
         // strings that FHICL will parse as vectors. So, this:
         //
         // [ [0,0], [1,1] ]
         //
         // is represented as:
         //
         // value.size()=2, value[0]="[0,0]", value[1]="[1,1]"
         //
         unsigned int i, j;
         flag |= kVECTOR_PARAM;
         for (i=0; i<vv.size(); ++i) {
           std::string s;
           s += "[";
           for (j=0; j<vv[i].size(); ++j) {
             s += vv[i][j];
             if (j+2<vv[i].size()) s += ",";
             else s += "]";
           }
           value.push_back(s);
         }
         if (vv.size()==0) value.push_back("[[]]");
       }
       catch (...) {
         // what about another fhicl::ParameterSet?
         try{
           fhicl::ParameterSet v = p.get< fhicl::ParameterSet >(valkey);
           flag |= kPARAMETER_SET_PARAM;
           value.push_back(v.to_string());
         }
         catch(...){
           //
           // If that fails we are very stuck. Print a message and fail.
           //
           LOG_ERROR("ParameterSetEditDialog") << "Failed to parse " << key
                                               << "\n" << p.to_string();
         }
       }
     }
   }
 }