#include <Fireworks/FWInterface/interface/FWPSetTableManager.h>

Inheritance diagram for FWPSetTableManager:

Classes
struct	ModuleInfo

struct	PathInfo

struct	PathUpdate

struct	PSetData

Public Member Functions
bool	cellDataIsSortable () const override

FWTableCellRendererBase *	cellRenderer (int iSortedRowNumber, int iCol) const override

std::vector< PSetData > &	data ()

	FWPSetTableManager ()

	FWPSetTableManager (const FWPSetTableManager &)=delete

std::vector< std::string >	getTitles () const override
	returns the title names for each column More...

void	implSort (int, bool) override
	Called by 'sort' method to actually handle the sorting of the rows. Arguments are the same as 'sort'. More...

std::vector< unsigned int >	maxWidthForColumns () const override
	for each column in the table this returns the present maximum width for that column More...

int	numberOfColumns () const override
	Number of columns in the table. More...

int	numberOfRows () const override
	Number of rows in the table. More...

const FWPSetTableManager &	operator= (const FWPSetTableManager &)=delete

virtual bool	rowIsSelected (int row) const

std::vector< int > &	rowToIndex ()

int	selectedColumn () const

int	selectedRow () const

virtual const std::string	title () const

int	unsortedRowNumber (int unsorted) const override
	when passed the index to the sorted order of the rows it returns the original row number from the underlying data More...

virtual void	updateFilter (const char *filter)

	~FWPSetTableManager () override

Public Member Functions inherited from FWTableManagerBase
virtual void	buttonPressedInRowHeader (Int_t row, Event_t *event, Int_t relX, Int_t relY)
	Called if mouse button pressed in Row Header, defaults is to do nothing. More...

virtual void	buttonReleasedInRowHeader (Int_t row, Event_t *event, Int_t relX, Int_t relY)

virtual unsigned int	cellHeight () const
	require all cells to be the same height More...

	ClassDefOverride (FWTableManagerBase, 0)

void	dataChanged ()
	Classes which inherit from FWTableManagerBase must call this when their underlying data changes. More...

	FWTableManagerBase ()

virtual bool	hasLabelHeaders () const

virtual bool	hasRowHeaders () const
	Returns 'true' if this table has row headers. Defaults return value is false. More...

virtual FWTableCellRendererBase *	rowHeader (int iSortedRowNumber) const
	Returns the renderer for the row header for the sorted row number iSortedRowNumber. More...

void	sort (int iCol, bool iSortOrder)
	Call to have table sorted on values in column iCol with the sort order being descending if iSortOrder is 'true'. More...

int	sortColumn (void)
	The current sort column. More...

bool	sortOrder (void)
	The current sort order for the table. More...

void	visualPropertiesChanged ()
	Classes which inherit from FWTableManagerBase must call this when how the data is shown (e.g. color) changes. More...

	~FWTableManagerBase () override

Protected Member Functions
bool	applyEditor ()

void	cancelEditor ()

std::vector< PSetData > &	entries ()

std::vector< ModuleInfo > &	modules ()

void	setExpanded (int row)

void	setSelection (int row, int column, int mask)

void	update (std::vector< PathUpdate > &pathUpdates)

void	updateSchedule (const edm::ScheduleInfo *info)

Private Member Functions
template<class T >
void	createScalarString (PSetData &data, T v)

template<typename T >
void	createVectorString (FWPSetTableManager::PSetData &data, const T &v, bool quotes)

void	handleEntry (const edm::Entry &entry, const std::string &key)

void	handlePSet (edm::ParameterSet *psp)

void	handlePSetEntry (edm::ParameterSetEntry &entry, const std::string &key)

void	handleVPSetEntry (edm::VParameterSetEntry &entry, const std::string &key)

void	recalculateVisibility ()

void	setCellValueEditor (FWPSetCellEditor *editor)

Private Attributes
std::vector< std::string >	m_availablePaths

FWPSetCellEditor *	m_editor

std::vector< PSetData >	m_entries

std::string	m_filter

std::vector< ModuleInfo >	m_modules

std::vector< size_t >	m_parentStack

std::map< std::string, size_t >	m_pathIndex

std::vector< PathInfo >	m_paths

FWTextTreeCellRenderer	m_renderer

std::vector< int >	m_row_to_index

int	m_selectedColumn

int	m_selectedRow

Friends
class	FWPathsPopup

Detailed Description

Description: [one line class summary]

Usage: <usage>

Definition at line 33 of file FWPSetTableManager.h.

Constructor & Destructor Documentation

FWPSetTableManager::FWPSetTableManager ( )

Definition at line 86 of file FWPSetTableManager.cc.

References FWTextTableCellRenderer::getDefaultHighlightGC(), m_renderer, recalculateVisibility(), FWTextTableCellRenderer::setHighlightContext(), and FWTableManagerBase::visualPropertiesChanged().

                                        : m_selectedRow(-1) {
   TGGC *hc = new TGGC(FWTextTableCellRenderer::getDefaultHighlightGC());
   hc->SetForeground(0xdddddd);
 
   m_renderer.setHighlightContext(hc);
 
   recalculateVisibility();
   visualPropertiesChanged();
 }

FWPSetTableManager::~FWPSetTableManager ( )

override

Definition at line 96 of file FWPSetTableManager.cc.

96 {}

FWPSetTableManager::FWPSetTableManager ( const FWPSetTableManager & )

delete

Member Function Documentation

bool FWPSetTableManager::applyEditor ( )

protected

This is invoked every single time the editor contents must be applied to the selected entry in the pset.

Returns: true on success.

Definition at line 519 of file FWPSetTableManager.cc.

References FWPSetCellEditor::apply(), data(), alignCSCRings::e, m_editor, m_entries, m_modules, m_row_to_index, m_selectedColumn, m_selectedRow, FWPSetTableManager::PSetData::module, SpecificationBuilder_cfi::parent(), FWPSetTableManager::PSetData::parent, setSelection(), summarizeEdmComparisonLogfiles::success, and FWPSetTableManager::PSetData::value.

Referenced by FWPathsPopup::applyEditor(), and FWPathsPopup::updateFilterString().

                                      {
   if (!m_editor)
     return false;
 
   if (m_selectedRow == -1 || m_selectedColumn != 1)
     return false;
 
   //  printf("FWPSetTableManager::applyEditor() \n");
   PSetData &data = m_entries[m_row_to_index[m_selectedRow]];
   PSetData &parent = m_entries[data.parent];
   bool success = false;
   try {
     success = m_editor->apply(data, parent);
 
     if (success) {
       data.value = m_editor->GetText();
       m_modules[data.module].dirty = true;
       setSelection(-1, -1, 0);
       m_editor->UnmapWindow();
       // ???
       // copy current to orig
     } else {
       // ???
       // set current from orig? reimport module ... hmmh, hard.
     }
   } catch (cms::Exception &e) {
     m_editor->SetForegroundColor(gVirtualX->GetPixel(kRed));
   }
   return success;
 }

void FWPSetTableManager::cancelEditor ( )

protected

Does not apply changes and closes window.

Definition at line 506 of file FWPSetTableManager.cc.

References m_editor, and setSelection().

Referenced by FWPathsPopup::HandleKey().

                                       {
   if (!m_editor)
     return;
 
   //  printf("FWPSetTableManager::cancelEditor() \n");
   setSelection(-1, -1, 0);
   m_editor->UnmapWindow();
 }

bool FWPSetTableManager::cellDataIsSortable ( ) const

inlineoverridevirtual

Reimplemented from FWTableManagerBase.

Definition at line 100 of file FWPSetTableManager.h.

100 { return false; }

FWTableCellRendererBase * FWPSetTableManager::cellRenderer	(	int	iSortedRowNumber,
		int	iCol
	)		const

overridevirtual

Returns the particular renderer used to handle the requested cell. Arguments: iSortedRowNumber: the row number from the present sort (i.e. the cell number of the view) iCol: the column number of the cell. The returned value must be used immediately and not held onto since the same Renderer can be used for subsequent calls

Implements FWTableManagerBase.

Definition at line 642 of file FWPSetTableManager.cc.

                                                                                               {
   const static size_t maxSize = 512;  // maximum string length
 
   static TGGC boldGC(fireworks::boldGC());
   static TGGC italicGC(fireworks::italicGC());
   static TGGC defaultGC(FWTextTableCellRenderer::getDefaultGC());
 
   const static Pixel_t gray = 0x777777;
   const static Pixel_t red = gVirtualX->GetPixel(kRed - 5);
   const static Pixel_t green = gVirtualX->GetPixel(kGreen - 5);
 
   // return in case if nothing maches filter
   if (static_cast<int>(m_row_to_index.size()) <= iSortedRowNumber) {
     m_renderer.setData(std::string(), false);
     return &m_renderer;
   }
 
   int unsortedRow = m_row_to_index[iSortedRowNumber];
   const PSetData &data = m_entries[unsortedRow];
 
   std::string value;
   std::string label;
   TGGC *gc = nullptr;
   if (data.level == 0) {
     const PathInfo &path = m_paths[data.path];
     label = data.label + " (" + data.value + ")";
     gc = &boldGC;
     gc->SetForeground(path.passed ? green : red);
   } else if (data.level == 1) {
     // "passed" means if module made decision on path
     const ModuleInfo &module = m_modules[m_paths[data.path].moduleStart + data.module];
     label = data.label + " (" + data.value + ")";
     gc = (TGGC *)&boldGC;
     gc->SetForeground(module.passed ? green : red);
   } else {
     if (data.type > 0)
       label = data.label + " (" + sTypeTranslations.table_[data.type] + ")";
     else
       label = data.label;
     value = data.value;
 
     if (data.editable) {
       gc = &defaultGC;
     } else {
       gc = &italicGC;
       gc->SetForeground(gray);
     }
   }
 
   // check string size and cut it if necessary (problems with X11)
   if (iCol == 1 && value.size() >= maxSize) {
     if (iSortedRowNumber == m_selectedRow)
       fwLog(fwlog::kWarning) << "label: " << label << " has too long value " << value << std::endl << std::endl;
 
     value = value.substr(0, maxSize);
     value += "[truncated]";
     gc->SetForeground(gVirtualX->GetPixel(kMagenta));
   }
 
   // debug
   // label = Form("%s m[%d] childm[%d] ", label.c_str(), data.matches, data.childMatches);
 
   // set text attributes
   m_renderer.setGraphicsContext(gc);
   bool selected = data.matches && (m_filter.empty() == false);
   m_renderer.setData(iCol ? value : label, selected);
 
   // set  tree attributes
   bool isParent = false;
   bool isOpen = false;
   int indent = 0;
   if (iCol == 0) {
     if (m_filter.empty()) {
       size_t nextIdx = unsortedRow + 1;
       isParent = (nextIdx < m_entries.size() && m_entries[nextIdx].parent == (size_t)unsortedRow);
       isOpen = data.expandedUser;
     } else {
       isParent = data.childMatches;
       isOpen = data.expandedFilter && data.childMatches;
     }
 
     indent = data.level * 10;
     if (!isParent)
       indent += FWTextTreeCellRenderer::iconWidth();
   }
   m_renderer.setIsParent(isParent);
   m_renderer.setIsOpen(isOpen);
   m_renderer.setIndentation(indent);
 
   // If we are rendering the selected cell,
   // we show the editor.
   bool showEdit =
       (iCol == 1 && iSortedRowNumber == m_selectedRow && iCol == m_selectedColumn && value.size() < maxSize);
   m_renderer.showEditor(data.editable && showEdit);
 
   return &m_renderer;
 }  // cellRender()

template<class T >

void FWPSetTableManager::createScalarString	(	PSetData &	data,
		T	v
	)

private

Definition at line 174 of file FWPSetTableManager.cc.

References m_entries, contentValuesCheck::ss, findQualityFiles::v, and FWPSetTableManager::PSetData::value.

Referenced by handleEntry().

                                                                {
   std::stringstream ss;
   ss << v;
   data.value = ss.str();
   m_entries.push_back(data);
 }

template<typename T >

void FWPSetTableManager::createVectorString	(	FWPSetTableManager::PSetData &	data,
		const T &	v,
		bool	quotes
	)

private

Definition at line 182 of file FWPSetTableManager.cc.

References cuy::ii, m_entries, contentValuesCheck::ss, and FWPSetTableManager::PSetData::value.

Referenced by handleEntry().

                                                                                                      {
   std::stringstream ss;
   ss << "[";
   for (size_t ii = 0, ie = v.size(); ii != ie; ++ii) {
     if (quotes)
       ss << "\"";
     ss << v[ii];
     if (quotes)
       ss << "\"";
     if (ii + 1 != ie)
       ss << ", ";
   }
   ss << "]";
   data.value = ss.str();
   m_entries.push_back(data);
 }

std::vector<PSetData>& FWPSetTableManager::data ( )

inline

Definition at line 106 of file FWPSetTableManager.h.

References m_entries.

Referenced by applyEditor(), FWPathsPopup::cellClicked(), cellRenderer(), handleEntry(), handlePSetEntry(), handleVPSetEntry(), recalculateVisibility(), setExpanded(), setSelection(), and updateFilter().

106 { return m_entries; }

FWPSetTableManager::m_entries

std::vector< PSetData > m_entries

Definition: FWPSetTableManager.h:174

std::vector<PSetData>& FWPSetTableManager::entries ( )

inlineprotected

Definition at line 144 of file FWPSetTableManager.h.

References m_entries.

Referenced by FWPathsPopup::scheduleReloadEvent().

144 { return m_entries; }

FWPSetTableManager::m_entries

std::vector< PSetData > m_entries

Definition: FWPSetTableManager.h:174

std::vector< std::string > FWPSetTableManager::getTitles ( ) const

overridevirtual

returns the title names for each column

Implements FWTableManagerBase.

Definition at line 557 of file FWPSetTableManager.cc.

References numberOfColumns().

                                                          {
   std::vector<std::string> returnValue;
   returnValue.reserve(numberOfColumns());
   returnValue.push_back("Label");
   returnValue.push_back("Value");
   return returnValue;
 }

void FWPSetTableManager::handleEntry	(	const edm::Entry &	entry,
		const std::string &	key
	)

private

Definition at line 199 of file FWPSetTableManager.cc.

Referenced by handlePSet().

                                                                                 {
   std::stringstream ss;
   FWPSetTableManager::PSetData data;
   data.label = key;
   data.tracked = entry.isTracked();
   data.type = entry.typeCode();
   data.level = m_parentStack.size();
   data.parent = m_parentStack.back();
   data.module = m_modules.size() - 1;
   data.type = entry.typeCode();
   if (data.label[0] == '@')
     data.editable = false;
   else
     data.editable = true;
 
   switch (entry.typeCode()) {
     case 'b': {
       data.value = entry.getBool() ? "True" : "False";
       m_entries.push_back(data);
       break;
     }
     case 'B': {
       data.value = entry.getBool() ? "True" : "False";
       m_entries.push_back(data);
       break;
     }
     case 'i': {
       createVectorString(data, entry.getVInt32(), false);
       break;
     }
     case 'I': {
       createScalarString(data, entry.getInt32());
       break;
     }
     case 'u': {
       createVectorString(data, entry.getVUInt32(), false);
       break;
     }
     case 'U': {
       createScalarString(data, entry.getUInt32());
       break;
     }
     case 'l': {
       createVectorString(data, entry.getVInt64(), false);
       break;
     }
     case 'L': {
       createScalarString(data, entry.getInt32());
       break;
     }
     case 'x': {
       createVectorString(data, entry.getVUInt64(), false);
       break;
     }
     case 'X': {
       createScalarString(data, entry.getUInt64());
       break;
     }
     case 's': {
       createVectorString(data, entry.getVString(), false);
       break;
     }
     case 'S': {
       createScalarString(data, entry.getString());
       break;
     }
     case 'd': {
       createVectorString(data, entry.getVDouble(), false);
       break;
     }
     case 'D': {
       createScalarString(data, entry.getDouble());
       break;
     }
     case 'p': {
       // Matevz ???
       throw std::runtime_error("FWPSetTableManager::handleEntryGet, entry type 'p' not expected.");
       // std::vector<edm::ParameterSet> psets = entry.getVPSet();
       // for (size_t psi = 0, pse = psets.size(); psi != pse; ++psi)
       //    handlePSet(psets[psi]);
       break;
     }
     case 'P': {
       // Matevz ???
       throw std::runtime_error("FWPSetTableManager::handleEntry, entry type 'P not expected.");
       // handlePSet(entry.getPSet());
       break;
     }
     case 't': {
       data.value = entry.getInputTag().encode();
       m_entries.push_back(data);
       break;
     }
     case 'v': {
       std::vector<std::string> tags;
       tags.resize(entry.getVInputTag().size());
       for (size_t iti = 0, ite = tags.size(); iti != ite; ++iti)
         tags[iti] = entry.getVInputTag()[iti].encode();
       createVectorString(data, tags, true);
       break;
     }
     case 'g': {
       data.value = entry.getESInputTag().encode();
       m_entries.push_back(data);
       break;
     }
     case 'G': {
       std::vector<std::string> tags;
       tags.resize(entry.getVESInputTag().size());
       for (size_t iti = 0, ite = tags.size(); iti != ite; ++iti)
         tags[iti] = entry.getVESInputTag()[iti].encode();
       createVectorString(data, tags, true);
       break;
     }
     case 'F': {
       createScalarString(data, entry.getFileInPath().relativePath());
       break;
     }
     case 'e': {
       data.editable = false;
       std::vector<edm::EventID> ids;
       ids.resize(entry.getVEventID().size());
       for (size_t iri = 0, ire = ids.size(); iri != ire; ++iri)
         ids[iri] = entry.getVEventID()[iri];
       createVectorString(data, ids, true);
       break;
     }
     case 'E': {
       data.editable = false;
       createScalarString(data, entry.getEventID());
       break;
     }
     case 'm': {
       data.editable = false;
       std::vector<edm::LuminosityBlockID> ids;
       ids.resize(entry.getVLuminosityBlockID().size());
       for (size_t iri = 0, ire = ids.size(); iri != ire; ++iri)
         ids[iri] = entry.getVLuminosityBlockID()[iri];
       createVectorString(data, ids, true);
       break;
     }
     case 'M': {
       data.editable = false;
       createScalarString(data, entry.getLuminosityBlockID());
       break;
     }
     case 'a': {
       data.editable = false;
       std::vector<edm::LuminosityBlockRange> ranges;
       ranges.resize(entry.getVLuminosityBlockRange().size());
       for (size_t iri = 0, ire = ranges.size(); iri != ire; ++iri)
         ranges[iri] = entry.getVLuminosityBlockRange()[iri];
       createVectorString(data, ranges, true);
       break;
     }
     case 'A': {
       data.editable = false;
       createScalarString(data, entry.getLuminosityBlockRange());
       break;
     }
     case 'r': {
       data.editable = false;
       std::vector<edm::EventRange> ranges;
       ranges.resize(entry.getVEventRange().size());
       for (size_t iri = 0, ire = ranges.size(); iri != ire; ++iri)
         ranges[iri] = entry.getVEventRange()[iri];
       createVectorString(data, ranges, true);
       break;
     }
     case 'R': {
       data.editable = false;
       createScalarString(data, entry.getEventRange());
       break;
     }
     default: {
       break;
     }
   }
 }

void FWPSetTableManager::handlePSet ( edm::ParameterSet * psp )

private

Definition at line 157 of file FWPSetTableManager.cc.

References alignCSCRings::e, handleEntry(), handlePSetEntry(), handleVPSetEntry(), mps_fire::i, edm::ParameterSet::psetTable(), edm::ParameterSet::tbl(), and edm::ParameterSet::vpsetTable().

Referenced by handlePSetEntry(), handleVPSetEntry(), and updateSchedule().

                                                         {
   edm::ParameterSet &ps = *psp;
 
   typedef edm::ParameterSet::table::const_iterator TIterator;
   for (TIterator i = ps.tbl().begin(), e = ps.tbl().end(); i != e; ++i)
     handleEntry(i->second, i->first);
 
   typedef edm::ParameterSet::psettable::const_iterator PSIterator;
   for (PSIterator i = ps.psetTable().begin(), e = ps.psetTable().end(); i != e; ++i)
     handlePSetEntry(const_cast<edm::ParameterSetEntry &>(i->second), i->first);
 
   typedef edm::ParameterSet::vpsettable::const_iterator VPSIterator;
   for (VPSIterator i = ps.vpsetTable().begin(), e = ps.vpsetTable().end(); i != e; ++i)
     handleVPSetEntry(const_cast<edm::VParameterSetEntry &>(i->second), i->first);
 }

void FWPSetTableManager::handlePSetEntry	(	edm::ParameterSetEntry &	entry,
		const std::string &	key
	)

private

Definition at line 104 of file FWPSetTableManager.cc.

Referenced by handlePSet().

                                                                                           {
   PSetData data;
   data.label = key;
   data.tracked = entry.isTracked();
   data.level = m_parentStack.size();
   data.parent = m_parentStack.back();
   data.type = 'P';
   data.module = m_modules.size() - 1;
   data.path = m_paths.size() - 1;
   data.pset = &entry.psetForUpdate();
   data.editable = false;
   m_parentStack.push_back(m_entries.size());
   m_entries.push_back(data);
 
   handlePSet(data.pset);
   m_parentStack.pop_back();
 }

void FWPSetTableManager::handleVPSetEntry	(	edm::VParameterSetEntry &	entry,
		const std::string &	key
	)

private

Definition at line 122 of file FWPSetTableManager.cc.

Referenced by handlePSet().

                                                                                             {
   PSetData data;
   data.label = key;
   data.tracked = entry.isTracked();
   data.level = m_parentStack.size();
   data.parent = m_parentStack.back();
   data.type = 'p';
   data.module = m_modules.size() - 1;
   data.path = m_paths.size() - 1;
   data.editable = false;
   m_parentStack.push_back(m_entries.size());
   m_entries.push_back(data);
 
   std::stringstream ss;
 
   for (size_t i = 0, e = entry.vpset().size(); i != e; ++i) {
     ss.str("");
     ss << key << "[" << i << "]";
     PSetData vdata;
     vdata.label = ss.str();
     vdata.tracked = entry.isTracked();
     vdata.level = m_parentStack.size();
     vdata.parent = m_parentStack.back();
     vdata.module = m_modules.size() - 1;
     vdata.path = m_paths.size() - 1;
     vdata.editable = false;
     vdata.pset = &entry.vpsetForUpdate()[i];
     m_parentStack.push_back(m_entries.size());
     m_entries.push_back(vdata);
     handlePSet(&entry.vpsetForUpdate()[i]);
     m_parentStack.pop_back();
   }
   m_parentStack.pop_back();
 }

void FWPSetTableManager::implSort	(	int	iCol,
		bool	iSortOrder
	)

overridevirtual

Called by 'sort' method to actually handle the sorting of the rows. Arguments are the same as 'sort'.

Implements FWTableManagerBase.

Definition at line 617 of file FWPSetTableManager.cc.

Referenced by update().

617 {}

std::vector< unsigned int > FWPSetTableManager::maxWidthForColumns ( ) const

overridevirtual

for each column in the table this returns the present maximum width for that column

Reimplemented from FWTableManagerBase.

Definition at line 606 of file FWPSetTableManager.cc.

References FWTableManagerBase::cellHeight(), m_editor, and FWTableManagerBase::maxWidthForColumns().

                                                                      {
   std::vector<unsigned int> ww = FWTableManagerBase::maxWidthForColumns();
   if (ww.size() > 1 && ww[1] > 0) {
     // printf("dim W %d \n",ww[1]);
     // printf("dim H %d \n",cellHeight());
     if (m_editor)
       m_editor->MoveResize(m_editor->GetX(), m_editor->GetY(), ww[1], cellHeight());
   }
   return ww;
 }

std::vector<ModuleInfo>& FWPSetTableManager::modules ( )

inlineprotected

Definition at line 143 of file FWPSetTableManager.h.

References m_modules.

Referenced by FWPathsPopup::scheduleReloadEvent().

143 { return m_modules; }

FWPSetTableManager::m_modules

std::vector< ModuleInfo > m_modules

Definition: FWPSetTableManager.h:177

int FWPSetTableManager::numberOfColumns ( ) const

overridevirtual

Number of columns in the table.

Implements FWTableManagerBase.

Definition at line 575 of file FWPSetTableManager.cc.

Referenced by getTitles().

575 { return 2; }

int FWPSetTableManager::numberOfRows ( ) const

overridevirtual

Number of rows in the table.

Implements FWTableManagerBase.

Definition at line 573 of file FWPSetTableManager.cc.

References m_row_to_index.

573 { return m_row_to_index.size(); }

FWPSetTableManager::m_row_to_index

std::vector< int > m_row_to_index

Definition: FWPSetTableManager.h:180

const FWPSetTableManager& FWPSetTableManager::operator= ( const FWPSetTableManager & )

delete

void FWPSetTableManager::recalculateVisibility ( )

private

Definition at line 817 of file FWPSetTableManager.cc.

References FWPSetTableManager::PSetData::childMatches, data(), alignCSCRings::e, mps_fire::i, FWPSetTableManager::PSetData::level, m_entries, m_filter, m_row_to_index, FWPSetTableManager::PSetData::matches, FWPSetTableManager::PSetData::parent, and FWPSetTableManager::PSetData::visible.

Referenced by FWPSetTableManager(), setExpanded(), updateFilter(), and updateSchedule().

                                                {
   m_row_to_index.clear();
 
   // Decide about visibility.
   // * If the items are toplevel and they match the filter, they get shown
   //   in any case.
   // * If the item or any of its children match the filter, the item
   //   is visible.
   // * If the filter is empty and the parent is expanded.
   for (size_t i = 0, e = m_entries.size(); i != e; ++i) {
     PSetData &data = m_entries[i];
     if (data.parent == ((size_t)-1)) {
       data.visible = data.childMatches || data.matches || m_filter.empty();
     } else {
       if (m_filter.empty()) {
         data.visible = m_entries[data.parent].expandedUser && m_entries[data.parent].visible;
       } else {
         if (data.level < 2)
           data.visible = m_entries[data.parent].expandedFilter && m_entries[data.parent].visible &&
                          (data.matches || data.childMatches);
         else
           data.visible = m_entries[data.parent].expandedFilter && m_entries[data.parent].visible;
       }
     }
   }
 
   // Put in the index only the entries which are visible.
   for (size_t i = 0, e = m_entries.size(); i != e; ++i)
     if (m_entries[i].visible)
       m_row_to_index.push_back(i);
 }

bool FWPSetTableManager::rowIsSelected ( int row ) const

virtual

Definition at line 569 of file FWPSetTableManager.cc.

References m_selectedRow.

569 { return m_selectedRow == row; }

FWPSetTableManager::m_selectedRow

int m_selectedRow

Definition: FWPSetTableManager.h:181

std::vector<int>& FWPSetTableManager::rowToIndex ( )

inline

Definition at line 107 of file FWPSetTableManager.h.

References m_row_to_index.

Referenced by FWPathsPopup::cellClicked(), and setExpanded().

107 { return m_row_to_index; }

FWPSetTableManager::m_row_to_index

std::vector< int > m_row_to_index

Definition: FWPSetTableManager.h:180

int FWPSetTableManager::selectedColumn ( ) const

Definition at line 567 of file FWPSetTableManager.cc.

References m_selectedColumn.

Referenced by FWPathsPopup::cellClicked().

567 { return m_selectedColumn; }

FWPSetTableManager::m_selectedColumn

int m_selectedColumn

Definition: FWPSetTableManager.h:182

int FWPSetTableManager::selectedRow ( ) const

Definition at line 565 of file FWPSetTableManager.cc.

References m_selectedRow.

Referenced by FWPathsPopup::cellClicked().

565 { return m_selectedRow; }

FWPSetTableManager::m_selectedRow

int m_selectedRow

Definition: FWPSetTableManager.h:181

void FWPSetTableManager::setCellValueEditor ( FWPSetCellEditor * editor )

private

Definition at line 500 of file FWPSetTableManager.cc.

References m_editor, m_renderer, and FWTextTreeCellRenderer::setCellEditor().

Referenced by FWPathsPopup::FWPathsPopup().

                                                                     {
   m_editor = editor;
   m_renderer.setCellEditor(m_editor);
 }

void FWPSetTableManager::setExpanded ( int row )

protected

Definition at line 620 of file FWPSetTableManager.cc.

References FWPSetTableManager::PSetData::childMatches, data(), FWTableManagerBase::dataChanged(), FWPSetTableManager::PSetData::expandedFilter, FWPSetTableManager::PSetData::expandedUser, m_entries, m_filter, recalculateVisibility(), rowToIndex(), and FWTableManagerBase::visualPropertiesChanged().

Referenced by FWPathsPopup::cellClicked().

                                             {
   if (row == -1)
     return;
 
   int index = rowToIndex()[row];
   PSetData &data = m_entries[index];
 
   if (m_filter.empty() == false && data.childMatches == false)
     return;
 
   if (m_filter.empty())
     data.expandedUser = !data.expandedUser;
   else
     data.expandedFilter = !data.expandedFilter;
 
   recalculateVisibility();
   dataChanged();
   visualPropertiesChanged();
 }

void FWPSetTableManager::setSelection	(	int	row,
		int	column,
		int	mask
	)

protected

Definition at line 577 of file FWPSetTableManager.cc.

References FWTableManagerBase::cellHeight(), data(), FWPSetTableManager::PSetData::editable, m_editor, m_entries, m_row_to_index, m_selectedColumn, m_selectedRow, FWPSetTableManager::PSetData::value, and FWTableManagerBase::visualPropertiesChanged().

Referenced by applyEditor(), cancelEditor(), FWPathsPopup::cellClicked(), FWPathsPopup::HandleKey(), and FWPathsPopup::updateFilterString().

                                                                      {
   // printf("set selection %d %d mode %d\n", iRow, iColumn, mask);
 
   // Nothing changes if we clicked selected
   // twice the same cell.
   if (iRow == m_selectedRow && iColumn == m_selectedColumn)
     return;
 
   // Otherwise update the selection information
   // and notify observers.
   m_selectedRow = iRow;
   m_selectedColumn = iColumn;
   if (iColumn == 1 && iRow > 0) {
     int unsortedRow = m_row_to_index[iRow];
     const PSetData &data = m_entries[unsortedRow];
     if (m_editor && data.editable) {
       m_editor->MoveResize(0, cellHeight() * iRow, m_editor->GetWidth(), m_editor->GetHeight());
       m_editor->MapWindow();
       m_editor->SetText(data.value.c_str());
       m_editor->SetFocus();
       m_editor->SetCursorPosition(data.value.size() - 1);
     }
   } else {
     if (m_editor)
       m_editor->UnmapWindow();
   }
   visualPropertiesChanged();
 }

const std::string FWPSetTableManager::title ( ) const

virtual

Definition at line 555 of file FWPSetTableManager.cc.

555 { return "Modules & their parameters"; }

int FWPSetTableManager::unsortedRowNumber ( int iSortedRowNumber ) const

overridevirtual

when passed the index to the sorted order of the rows it returns the original row number from the underlying data

Implements FWTableManagerBase.

Definition at line 571 of file FWPSetTableManager.cc.

571 { return unsorted; }

void FWPSetTableManager::update ( std::vector< PathUpdate > & pathUpdates )

protected

Update the status of a given path. This is the information that changes on event by event basis.

Definition at line 466 of file FWPSetTableManager.cc.

References FWPSetTableManager::PathUpdate::choiceMaker, fwLog, implSort(), fwlog::kError, m_modules, m_pathIndex, m_paths, hlt_dqm_clientPB-live_cfg::me, FWPSetTableManager::PathInfo::moduleEnd, FWPSetTableManager::PathInfo::moduleStart, FWPSetTableManager::ModuleInfo::passed, FWPSetTableManager::PathUpdate::passed, FWPSetTableManager::PathInfo::passed, FWPSetTableManager::PathUpdate::pathName, and pi.

Referenced by progressbar.ProgressBar::__next__(), MatrixUtil.Matrix::__setitem__(), MatrixUtil.Steps::__setitem__(), progressbar.ProgressBar::finish(), MatrixUtil.Steps::overwrite(), and FWPathsPopup::postEvent().

                                                                   {
   // Reset all the path / module status information, so that
   // by default paths and modules are considered "not passed".
   for (size_t pi = 0, pe = m_paths.size(); pi != pe; ++pi)
     m_paths[pi].passed = false;
   for (size_t mi = 0, me = m_modules.size(); mi != me; ++mi)
     m_modules[mi].passed = false;
 
   // Update whether or not a given path / module passed selection.
   for (size_t pui = 0, pue = pathUpdates.size(); pui != pue; ++pui) {
     PathUpdate &update = pathUpdates[pui];
     std::map<std::string, size_t>::const_iterator index = m_pathIndex.find(update.pathName);
     if (index == m_pathIndex.end()) {
       fwLog(fwlog::kError) << "Path " << update.pathName << "cannot be found!" << std::endl;
       continue;
     }
     PathInfo &pathInfo = m_paths[index->second];
     pathInfo.passed = update.passed;
 
     for (size_t mi = pathInfo.moduleStart, me = pathInfo.moduleEnd; mi != me; ++mi) {
       ModuleInfo &moduleInfo = m_modules[mi];
       moduleInfo.passed = update.passed || ((mi - pathInfo.moduleStart) < update.choiceMaker);
     }
   }
 
   implSort(-1, true);
 }

void FWPSetTableManager::updateFilter ( const char * filter )

virtual

Definition at line 742 of file FWPSetTableManager.cc.

References data(), FWTableManagerBase::dataChanged(), alignCSCRings::e, alcazmumu_cfi::filter, mps_fire::i, FWPSetTableManager::PSetData::label, FWPSetTableManager::PSetData::level, m_entries, m_filter, FWPSetTableManager::PSetData::matches, FWPSetTableManager::PSetData::parent, pi, recalculateVisibility(), svgfig::stack, and FWPSetTableManager::PSetData::value.

Referenced by FWPathsPopup::updateFilterString().

                                                         {
   m_filter = filter;
 
   if (m_filter.empty()) {
     // collapse entries when filter is removed
     for (size_t i = 0, e = m_entries.size(); i != e; ++i)
       m_entries[i].expandedFilter = false;
   } else {
     // Decide whether or not items match the filter.
     for (size_t i = 0, e = m_entries.size(); i != e; ++i) {
       PSetData &data = m_entries[i];
 
       // First of all decide whether or not we match
       // the filter.
       if (strstr(data.label.c_str(), m_filter.c_str()) || strstr(data.value.c_str(), m_filter.c_str()))
         data.matches = true;
       else
         data.matches = false;
     }
 
     // We reset whether or not a given parent has children that match the
     // filter, and we recompute the whole information by checking all the
     // children.
     for (size_t i = 0, e = m_entries.size(); i != e; ++i)
       m_entries[i].childMatches = false;
 
     std::vector<int> stack;
     int previousLevel = 0;
     for (size_t i = 0, e = m_entries.size(); i != e; ++i) {
       PSetData &data = m_entries[i];
       // Top level.
       if (data.parent == (size_t)-1) {
         previousLevel = 0;
         // std::cout << "reset stack for top level " << data.label << std::endl;
         stack.clear();
         continue;
       }
       // If the level is greater than the previous one,
       // it means we are among the children of the
       // previous level, hence we push the parent to
       // the stack.
       // If the level is not greater than the previous
       // one it means we have popped out n levels of
       // parents, where N is the difference between the
       // new and the old level. In this case we
       // pop up N parents from the stack.
       if (data.level > previousLevel)
         stack.push_back(data.parent);
       else
         for (size_t pi = 0, pe = previousLevel - data.level; pi != pe; ++pi)
           stack.pop_back();
 
       if (data.matches && m_entries[stack.back()].childMatches == false) {
         //  printf("match for %s with level %d\n",data.label.c_str(), data.level );
         for (size_t pi = 0, pe = stack.size(); pi != pe; ++pi) {
           //    printf("set child match to parent %s with level %d \n",m_entries[stack[pi]].label.c_str(), m_entries[stack[pi]].level);
           m_entries[stack[pi]].childMatches = true;
         }
       }
 
       previousLevel = data.level;
     }
 
     // expand to matching children
     for (size_t i = 0, e = m_entries.size(); i != e; ++i)
       m_entries[i].expandedFilter = m_entries[i].childMatches;
   }
 
   recalculateVisibility();
 
   dataChanged();
 }  // updateFilter()

void FWPSetTableManager::updateSchedule ( const edm::ScheduleInfo * info )

protected

Definition at line 383 of file FWPSetTableManager.cc.

Referenced by FWPathsPopup::postEvent().

                                                                    {
   if (!m_entries.empty())
     return;
   // Execute only once since the schedule itself
   // cannot be altered.
   assert(m_availablePaths.empty());
   info->availablePaths(m_availablePaths);
 
   for (size_t i = 0, e = m_availablePaths.size(); i != e; ++i) {
     PSetData pathEntry;
     const std::string &pathName = m_availablePaths[i];
     pathEntry.label = pathName;
     m_pathIndex.insert(std::make_pair(pathName, m_paths.size()));
 
     pathEntry.value = "Path";
     pathEntry.level = 0;
     pathEntry.parent = -1;
     pathEntry.path = i;
     pathEntry.editable = false;
 
     PathInfo pathInfo;
     pathInfo.entryId = m_entries.size();
     pathInfo.passed = false;
     pathInfo.moduleStart = m_modules.size();
     m_paths.push_back(pathInfo);
 
     m_parentStack.push_back(m_entries.size());
     m_entries.push_back(pathEntry);
 
     std::vector<std::string> pathModules;
     info->modulesInPath(pathName, pathModules);
 
     for (size_t mi = 0, me = pathModules.size(); mi != me; ++mi) {
       PSetData moduleEntry;
 
       const edm::ParameterSet *ps = info->parametersForModule(pathModules[mi]);
 
       const edm::ParameterSet::table &pst = ps->tbl();
       const edm::ParameterSet::table::const_iterator ti = pst.find("@module_edm_type");
       if (ti == pst.end())
         moduleEntry.value = "Unknown module name";
       else
         moduleEntry.value = ti->second.getString();
 
       moduleEntry.label = pathModules[mi];
       moduleEntry.parent = m_parentStack.back();
       moduleEntry.level = m_parentStack.size();
       moduleEntry.module = mi;
       moduleEntry.path = i;
       moduleEntry.editable = false;
 
       ModuleInfo moduleInfo;
       moduleInfo.path = m_paths.size() - 1;
       moduleInfo.entry = m_entries.size();
       moduleInfo.passed = false;
       moduleInfo.dirty = false;
       moduleInfo.orig_pset = new edm::ParameterSet(*ps);
       moduleInfo.current_pset = new edm::ParameterSet(*ps);
       m_modules.push_back(moduleInfo);
 
       moduleEntry.pset = moduleInfo.current_pset;
 
       m_parentStack.push_back(m_entries.size());
       m_entries.push_back(moduleEntry);
       handlePSet(moduleEntry.pset);
       m_parentStack.pop_back();
     }
     m_paths.back().moduleEnd = m_modules.size();
     m_parentStack.pop_back();
   }
 
   // Nothing is expanded by default.
   for (size_t i = 0, e = m_entries.size(); i != e; ++i)
     m_entries[i].expandedUser = false;
 
   m_filter = "";
 
   recalculateVisibility();
 }  //updateSchedule