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 {nullptr}
	Align to right. More...

TGLayoutHints *	fLeftLH {nullptr}
	Align to left. More...

TGTextButton *	fLabel {nullptr}
	Label on the left. More...

TGTextEntry *	fTextEntry {nullptr}

TGListBox *	fListBox {nullptr}

TGDoubleSlider *	fSlider {nullptr}

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 86 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 84 of file ParameterSetEditDialog.cxx.

References util::empty(), fChoice, fDOC, fGUI, fLabel, fLeftLH, fParamFlags, fRightLH, fValue, n, SetupCheckButton(), SetupListBox(), SetupRadioButtons(), SetupSlider(), SetupTextEntry(), util::size(), UnpackParameter(), and util::values().

   : fFrame(frame), 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 (empty(values)) {
     // What happened here? We'll crash if we continue though, so bail out.
     return;
   }
 
   if (fParamFlags & kVECTOR_PARAM) {
     fValue = "[";
     auto const n = size(values);
     for (std::size_t i = 0; i < n; ++i) {
       fValue += values[i];
       if (i + 1 < n)
         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 160 of file ParameterSetEditDialog.cxx.

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

 {
   cet::for_all(fCheckButton, std::default_delete<TGCheckButton>{});
   cet::for_all(fRadioButton, std::default_delete<TGRadioButton>{});
   delete fSlider;
   delete fListBox;
   delete fTextEntry;
   delete fLeftLH;
   delete fRightLH;
   delete fLabel;
 }

Member Function Documentation

std::string ParameterSetEditRow::AsFHICL ( ) const

Definition at line 656 of file ParameterSetEditDialog.cxx.

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

 {
   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 598 of file ParameterSetEditDialog.cxx.

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

 {
   int value = 0;
   for (std::size_t 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 646 of file ParameterSetEditDialog.cxx.

References fTextEntry, fValue, and TextEntryReturnPressed().

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

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

staticprivate

Definition at line 321 of file ParameterSetEditDialog.cxx.

References MF_LOG_ERROR.

Referenced by ParseGUItag().

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

void ParameterSetEditRow::ListBoxSelected ( int id )

Definition at line 565 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 537 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() == false)
     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 293 of file ParameterSetEditDialog.cxx.

References IsLegalGUItag().

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;
   while (icomma != std::string::npos) {
     size_t spos = icomma + 1;
     size_t epos = guitag.find(',', spos);
     std::string s = guitag.substr(spos, epos - spos);
     choice.push_back(s);
     icomma = epos;
   }
 }

void ParameterSetEditRow::RadioButtonClicked ( )

Definition at line 578 of file ParameterSetEditDialog.cxx.

References fFrame, fRadioButton, fValue, evdb::ParameterSetEditFrame::Modified(), and 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 430 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 370 of file ParameterSetEditDialog.cxx.

References fListBox, and util::size().

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 < size(value); ++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 406 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 451 of file ParameterSetEditDialog.cxx.

References fSlider, fTextEntry, and util::size().

Referenced by ParameterSetEditRow().

 {
   fTextEntry = new TGTextEntry(f);
   f->AddFrame(fTextEntry);
 
   std::string t;
   if (size(value) == 1) {
     t = value[0];
   }
   if (size(value) == 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 (size(value) == 1) {
     pos1 = atof(value[0].c_str());
     pos2 = pos1;
   }
   if (size(value) == 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 334 of file ParameterSetEditDialog.cxx.

References fTextEntry, and util::size().

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 (std::size_t i = 0; i < size(value); ++i) {
     buff += value[i];
     if ((i + 1) != size(value))
       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 614 of file ParameterSetEditDialog.cxx.

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

 {
   char buff[1024];
   float mn, mx;
   fSlider->GetPosition(mn, mx);
 
   float const ave = 0.5 * (mn + mx);
 
   if (fParamFlags & kINTEGER_PARAM) {
     int const mni = rint(mn);
     int const mxi = rint(mx);
     int const 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 508 of file ParameterSetEditDialog.cxx.

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

Referenced by Finalize().

 {
   if (fTextEntry == nullptr)
     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 175 of file ParameterSetEditDialog.cxx.

References util::empty(), fhicl::ParameterSet::get(), MF_LOG_ERROR, ParseGUItag(), util::size(), tmp, and fhicl::ParameterSet::to_string().

Referenced by ParameterSetEditRow().

 {
   flag = 0;
 
   // Try to extract GUI tags
   try {
     gui = p.get<std::string>(key + ".gui");
     doc = p.get<std::string>(key + ".doc");
     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 {
     auto const v = p.get<std::string>(valkey);
     value.push_back(maybe_quoted(v));
     flag |= kSINGLE_VALUED_PARAM;
     return;
   }
   catch (...) {
   }
 
   // Could not extract as single value; try extracting multiple values
   try {
     auto tmp = p.get<std::vector<std::string>>(valkey);
     for (auto& element : tmp) {
       element = maybe_quoted(element);
     }
     value = move(tmp);
     flag |= kVECTOR_PARAM;
     if (empty(value))
       value.push_back("");
     return;
   }
   catch (...) {
   }
 
   // Yikes - extracting multiple values failed; try 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:
     //
     // size(value)=2, value[0]="[0,0]", value[1]="[1,1]"
 
     flag |= kVECTOR_PARAM;
     for (std::size_t i = 0; i < size(vv); ++i) {
       std::string s{"["};
       auto const m = size(vv[i]);
       for (std::size_t j = 0; j < m; ++j) {
         s += maybe_quoted(vv[i][j]);
         if (j + 2 < m)
           s += ",";
         else
           s += "]";
       }
       value.push_back(s);
     }
     if (empty(vv))
       value.push_back("[[]]");
     return;
   }
   catch (...) {
   }
 
   // Above failed; what about another fhicl::ParameterSet?
   try {
     auto const v = p.get<fhicl::ParameterSet>(valkey);
     flag |= kPARAMETER_SET_PARAM;
     value.push_back(v.to_string());
     return;
   }
   catch (...) {
   }
 
   // Now we are very stuck.
   MF_LOG_ERROR("ParameterSetEditDialog") << "Failed to parse " << key << "\n"
                                          << p.to_string();
 }