FWPSetTableManager Class Reference

#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() [1/2]

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::~FWPSetTableManager ( )

override

Definition at line 96 of file FWPSetTableManager.cc.

{}

FWPSetTableManager() [2/2]

FWPSetTableManager::FWPSetTableManager ( const FWPSetTableManager &  )

delete

Member Function Documentation

applyEditor()

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(), MillePedeFileConverter_cfg::e, m_editor, m_entries, m_modules, m_row_to_index, m_selectedColumn, m_selectedRow, class-composition::parent, setSelection(), and summarizeEdmComparisonLogfiles::success.

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;
}

cancelEditor()

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();
}

cellDataIsSortable()

bool FWPSetTableManager::cellDataIsSortable ( ) const

inlineoverridevirtual

Reimplemented from FWTableManagerBase.

Definition at line 100 of file FWPSetTableManager.h.

{ return false; }

cellRenderer()

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.

References fireworks::boldGC(), data(), fwLog, FWTextTableCellRenderer::getDefaultGC(), FWTextTreeCellRenderer::iconWidth(), validateAlignments::indent, fireworks::italicGC(), fwlog::kWarning, label, m_entries, m_filter, m_modules, m_paths, m_renderer, m_row_to_index, m_selectedColumn, m_selectedRow, reco_skim_cfg_mod::maxSize, castor_dqm_sourceclient_file_cfg::path, DivergingColor::red, FWTextTableCellRenderer::setData(), FWTextTableCellRenderer::setGraphicsContext(), FWTextTreeCellRenderer::setIndentation(), FWTextTreeCellRenderer::setIsOpen(), FWTextTreeCellRenderer::setIsParent(), FWTextTreeCellRenderer::showEditor(), AlCaHLTBitMon_QueryRunRegistry::string, sTypeTranslations, TypeTrans::table_, and relativeConstraints::value.

                                                                                              {
  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()

createScalarString()

template<class T >

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

private

Definition at line 174 of file FWPSetTableManager.cc.

References data(), m_entries, contentValuesCheck::ss, and findQualityFiles::v.

Referenced by handleEntry().

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

createVectorString()

template<typename T >

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

private

Definition at line 182 of file FWPSetTableManager.cc.

References data(), cuy::ii, m_entries, contentValuesCheck::ss, and findQualityFiles::v.

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);
}

data()

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

inline

Definition at line 106 of file FWPSetTableManager.h.

References m_entries.

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

{ return m_entries; }

entries()

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

inlineprotected

Definition at line 144 of file FWPSetTableManager.h.

References m_entries.

Referenced by FWPathsPopup::scheduleReloadEvent().

{ return m_entries; }

getTitles()

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;
}

handleEntry()

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

private

Definition at line 199 of file FWPSetTableManager.cc.

References createScalarString(), createVectorString(), data(), mps_splice::entry, crabWrapper::key, m_entries, m_modules, m_parentStack, diffTwoXMLs::ranges, contentValuesCheck::ss, and triggerMatcherToHLTDebug_cfi::tags.

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;
    }
  }
}

handlePSet()

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

private

Definition at line 157 of file FWPSetTableManager.cc.

References MillePedeFileConverter_cfg::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);
}

handlePSetEntry()

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

private

Definition at line 104 of file FWPSetTableManager.cc.

References data(), mps_splice::entry, handlePSet(), crabWrapper::key, m_entries, m_modules, m_parentStack, and m_paths.

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();
}

handleVPSetEntry()

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

private

Definition at line 122 of file FWPSetTableManager.cc.

References data(), MillePedeFileConverter_cfg::e, FWPSetTableManager::PSetData::editable, mps_splice::entry, handlePSet(), mps_fire::i, crabWrapper::key, FWPSetTableManager::PSetData::label, FWPSetTableManager::PSetData::level, m_entries, m_modules, m_parentStack, m_paths, FWPSetTableManager::PSetData::module, FWPSetTableManager::PSetData::parent, FWPSetTableManager::PSetData::path, FWPSetTableManager::PSetData::pset, contentValuesCheck::ss, and FWPSetTableManager::PSetData::tracked.

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();
}

implSort()

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().

{}

maxWidthForColumns()

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;
}

modules()

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

inlineprotected

Definition at line 143 of file FWPSetTableManager.h.

References m_modules.

Referenced by FWPathsPopup::scheduleReloadEvent().

{ return m_modules; }

numberOfColumns()

int FWPSetTableManager::numberOfColumns ( ) const

overridevirtual

Number of columns in the table.

Implements FWTableManagerBase.

Definition at line 575 of file FWPSetTableManager.cc.

Referenced by getTitles().

{ return 2; }

numberOfRows()

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.

{ return m_row_to_index.size(); }

operator=()

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

delete

recalculateVisibility()

void FWPSetTableManager::recalculateVisibility ( )

private

Definition at line 817 of file FWPSetTableManager.cc.

References data(), MillePedeFileConverter_cfg::e, mps_fire::i, m_entries, m_filter, and m_row_to_index.

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);
}

rowIsSelected()

bool FWPSetTableManager::rowIsSelected ( int  row ) const

virtual

Definition at line 569 of file FWPSetTableManager.cc.

References m_selectedRow.

{ return m_selectedRow == row; }

rowToIndex()

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().

{ return m_row_to_index; }

selectedColumn()

int FWPSetTableManager::selectedColumn

(

)

const

Definition at line 567 of file FWPSetTableManager.cc.

References m_selectedColumn.

Referenced by FWPathsPopup::cellClicked().

{ return m_selectedColumn; }

selectedRow()

int FWPSetTableManager::selectedRow

(

)

const

Definition at line 565 of file FWPSetTableManager.cc.

References m_selectedRow.

Referenced by FWPathsPopup::cellClicked().

{ return m_selectedRow; }

setCellValueEditor()

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);
}

setExpanded()

void FWPSetTableManager::setExpanded ( int  row )

protected

Definition at line 620 of file FWPSetTableManager.cc.

References data(), FWTableManagerBase::dataChanged(), 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();
}

setSelection()

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

protected

Definition at line 577 of file FWPSetTableManager.cc.

References FWTableManagerBase::cellHeight(), data(), m_editor, m_entries, m_row_to_index, m_selectedColumn, m_selectedRow, 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();
}

title()

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

virtual

Definition at line 555 of file FWPSetTableManager.cc.

{ return "Modules & their parameters"; }

unsortedRowNumber()

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.

{ return unsorted; }

update()

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 fwLog, implSort(), fwlog::kError, m_modules, m_pathIndex, m_paths, hlt_dqm_clientPB-live_cfg::me, FWPSetTableManager::PathInfo::moduleEnd, FWPSetTableManager::PathInfo::moduleStart, TriggerAnalyzer::passed, FWPSetTableManager::ModuleInfo::passed, FWPSetTableManager::PathInfo::passed, 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);
}

updateFilter()

void FWPSetTableManager::updateFilter ( const char *  filter )

virtual

Definition at line 742 of file FWPSetTableManager.cc.

References data(), FWTableManagerBase::dataChanged(), MillePedeFileConverter_cfg::e, ALCARECOTkAlBeamHalo_cff::filter, mps_fire::i, m_entries, m_filter, pi, recalculateVisibility(), and svgfig::stack.

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()

updateSchedule()

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

protected

Definition at line 383 of file FWPSetTableManager.cc.

References cms::cuda::assert(), FWPSetTableManager::ModuleInfo::current_pset, FWPSetTableManager::ModuleInfo::dirty, MillePedeFileConverter_cfg::e, FWPSetTableManager::PSetData::editable, FWPSetTableManager::ModuleInfo::entry, FWPSetTableManager::PathInfo::entryId, handlePSet(), mps_fire::i, info(), FWPSetTableManager::PSetData::label, FWPSetTableManager::PSetData::level, m_availablePaths, m_entries, m_filter, m_modules, m_parentStack, m_pathIndex, m_paths, hlt_dqm_clientPB-live_cfg::me, FWPSetTableManager::PSetData::module, FWPSetTableManager::PathInfo::moduleStart, FWPSetTableManager::ModuleInfo::orig_pset, FWPSetTableManager::PSetData::parent, FWPSetTableManager::ModuleInfo::passed, FWPSetTableManager::PathInfo::passed, FWPSetTableManager::PSetData::path, FWPSetTableManager::ModuleInfo::path, hltMonBTagIPClient_cfi::pathName, FWPSetTableManager::PSetData::pset, recalculateVisibility(), AlCaHLTBitMon_QueryRunRegistry::string, edm::ParameterSet::tbl(), and FWPSetTableManager::PSetData::value.

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

Friends And Related Function Documentation

FWPathsPopup

friend class FWPathsPopup

friend

Definition at line 34 of file FWPSetTableManager.h.

Member Data Documentation

m_availablePaths

std::vector<std::string> FWPSetTableManager::m_availablePaths

private

Definition at line 185 of file FWPSetTableManager.h.

Referenced by updateSchedule().

m_editor

FWPSetCellEditor* FWPSetTableManager::m_editor

private

Definition at line 184 of file FWPSetTableManager.h.

Referenced by applyEditor(), cancelEditor(), FWPathsPopup::FWPathsPopup(), maxWidthForColumns(), setCellValueEditor(), and setSelection().

m_entries

std::vector<PSetData> FWPSetTableManager::m_entries

private

Definition at line 174 of file FWPSetTableManager.h.

Referenced by applyEditor(), cellRenderer(), createScalarString(), createVectorString(), data(), entries(), handleEntry(), handlePSetEntry(), handleVPSetEntry(), recalculateVisibility(), setExpanded(), setSelection(), updateFilter(), and updateSchedule().

m_filter

std::string FWPSetTableManager::m_filter

private

Definition at line 183 of file FWPSetTableManager.h.

Referenced by cellRenderer(), recalculateVisibility(), setExpanded(), updateFilter(), and updateSchedule().

m_modules

std::vector<ModuleInfo> FWPSetTableManager::m_modules

private

Definition at line 177 of file FWPSetTableManager.h.

Referenced by applyEditor(), cellRenderer(), handleEntry(), handlePSetEntry(), handleVPSetEntry(), modules(), update(), and updateSchedule().

m_parentStack

std::vector<size_t> FWPSetTableManager::m_parentStack

private

Definition at line 179 of file FWPSetTableManager.h.

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

m_pathIndex

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

private

Definition at line 178 of file FWPSetTableManager.h.

Referenced by update(), and updateSchedule().

m_paths

std::vector<PathInfo> FWPSetTableManager::m_paths

private

Index in m_entries where to find paths

Definition at line 176 of file FWPSetTableManager.h.

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

m_renderer

FWTextTreeCellRenderer FWPSetTableManager::m_renderer

mutableprivate

Definition at line 187 of file FWPSetTableManager.h.

Referenced by cellRenderer(), FWPSetTableManager(), and setCellValueEditor().

m_row_to_index

std::vector<int> FWPSetTableManager::m_row_to_index

private

Definition at line 180 of file FWPSetTableManager.h.

Referenced by applyEditor(), cellRenderer(), numberOfRows(), recalculateVisibility(), rowToIndex(), and setSelection().

m_selectedColumn

int FWPSetTableManager::m_selectedColumn

private

Definition at line 182 of file FWPSetTableManager.h.

Referenced by applyEditor(), cellRenderer(), selectedColumn(), and setSelection().

m_selectedRow

int FWPSetTableManager::m_selectedRow

private

Definition at line 181 of file FWPSetTableManager.h.

Referenced by applyEditor(), cellRenderer(), rowIsSelected(), selectedRow(), and setSelection().