#include <Fireworks/Core/interface/FWTableView.h>

Inheritance diagram for FWTableView:

Public Member Functions
void	addColumn ()

void	addTo (FWConfiguration &) const override

void	columnSelected (Int_t iCol, Int_t iButton, Int_t iKeyMod)

void	dataChanged ()

void	deleteColumn ()

	FWTableView (TEveWindowSlot , FWTableViewManager )

const FWEventItem *	item () const

void	modelSelected (Int_t iRow, Int_t iButton, Int_t iKeyMod, Int_t, Int_t)

void	modifyColumn ()

void	resetColors (const class FWColorManager &)

void	saveImageTo (const std::string &iName) const override

void	selectCollection (Int_t)

void	setBackgroundColor (Color_t)

void	setFrom (const FWConfiguration &) override

void	toggleShowHide ()

void	updateEvaluators ()

void	updateItems ()

	~FWTableView () override

Public Member Functions inherited from FWViewBase
virtual FWViewContextMenuHandlerBase *	contextMenuHandler () const

void	destroy ()

	FWViewBase (FWViewType::EType, unsigned int iVersion=1)

virtual void	populateController (ViewerParameterGUI &) const

void	promptForSaveImageTo (TGFrame *) const

FWViewType::EType	typeId () const

const std::string &	typeName () const

Public Member Functions inherited from FWConfigurableParameterizable
	FWConfigurableParameterizable (unsigned int iVersion=1)

unsigned int	version () const

	~FWConfigurableParameterizable () override

Public Member Functions inherited from FWParameterizable
void	add (FWParameterBase *)

const_iterator	begin () const

const_iterator	end () const

	FWParameterizable ()

virtual	~FWParameterizable ()

Public Member Functions inherited from FWConfigurable
	FWConfigurable ()

virtual	~FWConfigurable ()

Protected Attributes
TGComboBox *	m_collection

TGCompositeFrame *	m_column_control

FWGUIValidatingTextEntry *	m_column_expr_field

TGTextEntry *	m_column_name_field

TGTextEntry *	m_column_prec_field

FWCustomIconsButton *	m_columnUIButton

int	m_currentColumn

TEveWindowFrame *	m_eveWindow

int	m_iColl

FWTableViewManager *	m_manager

bool	m_showColumnUI

FWTableViewTableManager *	m_tableManager

FWTableWidget *	m_tableWidget

bool	m_useColumnsFromConfig

FWExpressionValidator *	m_validator

TGCompositeFrame *	m_vert

Protected Attributes inherited from FWViewBase
FWViewType	m_type

Private Member Functions
	FWTableView (const FWTableView &)=delete

const FWTableView &	operator= (const FWTableView &)=delete

Friends
class	FWTableViewTableManager

Additional Inherited Members
Public Types inherited from FWParameterizable
typedef std::vector< FWParameterBase * >::const_iterator	const_iterator

Public Attributes inherited from FWViewBase
sigc::signal< void, const FWViewBase * >	beingDestroyed_

sigc::signal< void, Int_t, Int_t >	openSelectedModelContextMenu_

Protected Member Functions inherited from FWViewBase
	~FWViewBase () override

Detailed Description

Description: <one line="" class="" summary>="">

Usage: <usage>

Definition at line 50 of file FWTableView.h.

Constructor & Destructor Documentation

FWTableView::FWTableView	(	TEveWindowSlot *	iParent,
		FWTableViewManager *	manager
	)

Definition at line 197 of file FWTableView.cc.

References arrow_right(), arrow_right_disabled(), FWColorManager::background(), FWViewManagerBase::colorManager(), FWTableWidget::disableGrowInWidth(), amptDefault_cfi::frame, RecoTauValidation_cfi::header, label, m_collection, m_column_control, m_column_expr_field, m_column_name_field, m_column_prec_field, m_columnUIButton, m_eveWindow, m_manager, m_tableManager, m_tableWidget, m_validator, m_vert, resetColors(), FWTableWidget::SetHeaderBackgroundColor(), FWGUIValidatingTextEntry::setValidator(), and updateItems().

     : FWViewBase(FWViewType::kTable),
       m_iColl(-1),
       m_manager(manager),
       m_tableManager(new FWTableViewTableManager(this)),
       m_tableWidget(nullptr),
       m_showColumnUI(false),
       m_validator(new FWExpressionValidator),
       m_currentColumn(-1),
       m_useColumnsFromConfig(false)
 
 {
   m_eveWindow = iParent->MakeFrame(nullptr);
   TGCompositeFrame *frame = m_eveWindow->GetGUICompositeFrame();
   //      TGHorizontalFrame *buttons = new TGHorizontalFrame(frame);
   //      frame->AddFrame(buttons, new TGLayoutHints(kLHintsTop | kLHintsExpandX));
 
   //      m_collection = new TGComboBox(buttons);
   m_vert = new TGVerticalFrame(frame);
   frame->AddFrame(m_vert, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY));
   TGHorizontalFrame *header = new TGHorizontalFrame(m_vert);
   m_vert->AddFrame(header, new TGLayoutHints(kLHintsTop | kLHintsExpandX));
   const bool bgIsBlack = m_manager->colorManager().background() == kBlack;
   m_columnUIButton = new FWCustomIconsButton(
       header, arrow_right(bgIsBlack), arrow_right_disabled(bgIsBlack), arrow_right_disabled(bgIsBlack));
   m_columnUIButton->Connect("Clicked()", "FWTableView", this, "toggleShowHide()");
   header->AddFrame(m_columnUIButton, new TGLayoutHints(kLHintsCenterY | kLHintsLeft, 6, 10));
 
   TGCompositeFrame *labfr = new TGHorizontalFrame(header, 60, 25, kFixedSize);
   TGLabel *label = new TGLabel(labfr, "Collection");
   labfr->AddFrame(label, new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 1, 3, 0, 0));
   header->AddFrame(labfr, new TGLayoutHints(kLHintsLeft));
 
   m_collection = new TGComboBox(header);
   updateItems();
   header->AddFrame(m_collection, new TGLayoutHints(kLHintsLeft | kLHintsExpandX | kLHintsExpandY));
   m_collection->Connect("Selected(Int_t)", "FWTableView", this, "selectCollection(Int_t)");
   m_collection->Select(2, true);
   m_column_control = new TGVerticalFrame(m_vert);
   m_vert->AddFrame(m_column_control, new TGLayoutHints(kLHintsExpandX));
   TGLabel *column_control_label = new TGLabel(m_column_control, "Column editor");
   //      column_control_label->SetBackgroundColor(bgIsBlack ? kBlack : kWhite);
   //      column_control_label->SetForegroundColor(bgIsBlack ? kWhite : kBlack);
   //      column_control_label->SetTextColor(bgIsBlack ? kWhite : kBlack);
   m_column_control->AddFrame(column_control_label, new TGLayoutHints(kLHintsExpandX));
   TGHorizontalFrame *column_control_fields = new TGHorizontalFrame(m_column_control);
   m_column_control->AddFrame(column_control_fields, new TGLayoutHints(kLHintsExpandX));
   m_column_name_field = new TGTextEntry(column_control_fields);
   m_column_name_field->SetMaxWidth(10);
   m_column_expr_field = new FWGUIValidatingTextEntry(column_control_fields);
   //      m_column_expr_field->SetEnabled(kFALSE);
   m_column_expr_field->setValidator(m_validator);
   m_column_prec_field = new TGTextEntry(column_control_fields);
   m_column_prec_field->SetMaxWidth(10);
   TGLabel *name_label = new TGLabel(column_control_fields, "Title");
   TGLabel *expr_label = new TGLabel(column_control_fields, "Expression");
   TGLabel *prec_label = new TGLabel(column_control_fields, "Precision");
   column_control_fields->AddFrame(name_label, new TGLayoutHints(kLHintsBottom, 1, 1, 2, 2));
   column_control_fields->AddFrame(m_column_name_field, new TGLayoutHints(kLHintsExpandX));
   column_control_fields->AddFrame(expr_label, new TGLayoutHints(kLHintsBottom, 1, 1, 2, 2));
   column_control_fields->AddFrame(m_column_expr_field, new TGLayoutHints(kLHintsExpandX));
   column_control_fields->AddFrame(prec_label, new TGLayoutHints(kLHintsBottom, 1, 1, 2, 2));
   column_control_fields->AddFrame(m_column_prec_field, new TGLayoutHints(kLHintsExpandX));
   TGTextButton *add_button = new TGTextButton(column_control_fields, "Add");
   TGTextButton *del_button = new TGTextButton(column_control_fields, "Delete");
   TGTextButton *mod_button = new TGTextButton(column_control_fields, "Modify");
   add_button->Connect("Clicked()", "FWTableView", this, "addColumn()");
   del_button->Connect("Clicked()", "FWTableView", this, "deleteColumn()");
   mod_button->Connect("Clicked()", "FWTableView", this, "modifyColumn()");
   column_control_fields->AddFrame(add_button, new TGLayoutHints);
   column_control_fields->AddFrame(del_button, new TGLayoutHints);
   column_control_fields->AddFrame(mod_button, new TGLayoutHints);
   m_tableWidget = new FWTableWidget(m_tableManager, m_vert);
   m_tableWidget->disableGrowInWidth();
   resetColors(m_manager->colorManager());
   m_tableWidget->SetHeaderBackgroundColor(gVirtualX->GetPixel(kWhite));
   m_tableWidget->Connect(
       "rowClicked(Int_t,Int_t,Int_t,Int_t,Int_t)", "FWTableView", this, "modelSelected(Int_t,Int_t,Int_t,Int_t,Int_t)");
   m_tableWidget->Connect("columnClicked(Int_t,Int_t,Int_t)", "FWTableView", this, "columnSelected(Int_t,Int_t,Int_t)");
   m_vert->AddFrame(m_tableWidget, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY));
   frame->MapSubwindows();
   m_vert->HideFrame(m_column_control);
   frame->Layout();
   frame->MapWindow();
 }

FWTableView::~FWTableView ( )

override

Definition at line 283 of file FWTableView.cc.

References amptDefault_cfi::frame, m_eveWindow, m_tableManager, m_validator, and m_vert.

                           {
   // take out composite frame and delete it directly ( without the timeout)
   TGCompositeFrame *frame = m_eveWindow->GetGUICompositeFrame();
   frame->RemoveFrame(m_vert);
   delete m_vert;
 
   m_eveWindow->DestroyWindowAndSlot();
   delete m_tableManager;
   delete m_validator;
 }

FWTableView::FWTableView ( const FWTableView & )

privatedelete

Member Function Documentation

void FWTableView::addColumn ( )

Definition at line 626 of file FWTableView.cc.

References FWTableViewManager::dataChanged(), MillePedeFileConverter_cfg::e, jets_cff::expr, FWTableWidget::forceLayout(), fwLog, createfilelist::int, fwlog::kInfo, m_column_expr_field, m_column_name_field, m_column_prec_field, m_currentColumn, m_manager, FWTableViewTableManager::m_tableFormats, m_tableManager, m_tableWidget, Skims_PA_cff::name, mps_setup::stdout, and AlCaHLTBitMon_QueryRunRegistry::string.

                             {
   std::string name = m_column_name_field->GetText();
   std::string expr = m_column_expr_field->GetText();
   // convert the precision to a long int
   char *endptr = nullptr;
   int prec = (int)strtol(m_column_prec_field->GetText(), &endptr, 0);
   if (name.empty() || expr.empty() || m_column_prec_field->GetText() == nullptr || *endptr != 0) {
     fwLog(fwlog::kInfo) << "bad input\n";
     fflush(stdout);
     return;
   }
   fwLog(fwlog::kInfo) << "adding column " << name << ": " << expr << ", precision " << prec << std::endl;
   fflush(stdout);
   //      m_manager->tableFormats(*item->modelType())
   FWTableViewManager::TableEntry e = {expr, name, prec};
   m_tableManager->m_tableFormats->push_back(e);
   m_currentColumn = (int)m_tableManager->m_tableFormats->size() + 1;
   // change needs to be propagated to all tables, because all
   // tables displaying objects of this type are affected
   // MT -- this is NOT true!!! FIX
   m_tableWidget->forceLayout();
   m_manager->dataChanged();
 }

void FWTableView::addTo ( FWConfiguration & iTo ) const

overridevirtual

Reimplemented from FWConfigurableParameterizable.

Definition at line 319 of file FWTableView.cc.

References FWConfiguration::addKeyValue(), FWConfigurableParameterizable::addTo(), FWTableViewManager::addToImpl(), universalConfigTemplate::collection, bysipixelclustmulteventfilter_cfi::collectionName, FWTableWidget::descendingSort(), FWTableViewManager::items(), kCollection, kDescendingSort, kSortColumn, kTableView, m_iColl, m_manager, m_tableWidget, FWTableViewManager::m_views, magneticFieldFilterJSON::main(), FWTableWidget::sortedColumn(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                   {
   // are we the first FWTableView to go into the configuration?  If
   // we are, then we are responsible for writing out the list of
   // types (which we do by letting FWTableViewManager::addToImpl
   // write into our configuration)
   if (this == m_manager->m_views.front().get())
     m_manager->addToImpl(iTo);
   // then there is the stuff we have to do anyway: remember what
   // collection we display
   FWConfiguration main(1);
   std::string collectionName;
   if (m_manager->items()[m_iColl])
     collectionName = m_manager->items()[m_iColl]->name();
   else
     collectionName = "NULL";
 
   FWConfiguration collection(collectionName);
   main.addKeyValue(kCollection, collection);
   FWConfiguration sortColumn(m_tableWidget->sortedColumn());
   main.addKeyValue(kSortColumn, sortColumn);
   FWConfiguration descendingSort(m_tableWidget->descendingSort());
   main.addKeyValue(kDescendingSort, descendingSort);
   //      FWConfiguration columns(1);
   //      for (std::vector<FWTableViewManager::TableEntry>::const_iterator
   //           i = m_tableManager->m_tableFormats->begin(),
   //           iEnd = m_tableManager->m_tableFormats->end();
   //      i != iEnd; ++i) {
   //      columns.addValue(i->name);
   //      columns.addValue(i->expression);
   //      char prec[100];
   //      snprintf(prec, 100, "%d", i->precision);
   //      columns.addValue(prec);
   //      }
   //      main.addKeyValue(kColumns, columns);
   iTo.addKeyValue(kTableView, main);
   // take care of parameters
   FWConfigurableParameterizable::addTo(iTo);
 }

void FWTableView::columnSelected	(	Int_t	iCol,
		Int_t	iButton,
		Int_t	iKeyMod
	)

Definition at line 610 of file FWTableView.cc.

References mps_splice::entry, FWTableViewManager::TableEntry::expression, m_column_expr_field, m_column_name_field, m_column_prec_field, m_currentColumn, FWTableViewTableManager::m_tableFormats, m_tableManager, FWTableViewManager::TableEntry::name, and FWTableViewManager::TableEntry::precision.

                                                                          {
   if (iButton == 1 || iButton == 3)
     m_currentColumn = iCol;
   // update contents of the column editor
   if (m_currentColumn >= 0 && m_currentColumn < (int)m_tableManager->m_tableFormats->size()) {
     const FWTableViewManager::TableEntry &entry = m_tableManager->m_tableFormats->at(m_currentColumn);
     m_column_name_field->SetText(entry.name.c_str());
     m_column_expr_field->SetText(entry.expression.c_str());
     m_column_prec_field->SetText(Form("%d", entry.precision));
   } else {
     m_column_name_field->SetText("");
     m_column_expr_field->SetText("");
     m_column_prec_field->SetText("");
   }
 }

void FWTableView::dataChanged ( )

Definition at line 550 of file FWTableView.cc.

References FWTableViewTableManager::dataChanged(), m_tableManager, and updateEvaluators().

Referenced by FWTableViewManager::notifyViews(), and selectCollection().

                               {
   //      const FWEventItem *item = m_manager->items()[m_iColl];
   updateEvaluators();
   m_tableManager->dataChanged();
   //      std::vector<FWExpressionEvaluator> &ev = m_evaluators;
   //      for (unsigned int i = 0; i < item->size(); ++i) {
   //      for (unsigned int j = 0; j < ev.size(); ++j) {
   //           printf("%s = %f\t", (*m_manager->tableFormats(item->modelType()->GetName())).second[j].name.c_str(),
   //              ev[j].evalExpression(item->modelData(i)));
   //      }
   //      printf("\n");
   //      }
   //      fflush(stdout);
 }

void FWTableView::deleteColumn ( )

Definition at line 650 of file FWTableView.cc.

References FWTableViewManager::dataChanged(), FWTableWidget::forceLayout(), m_column_expr_field, m_column_name_field, m_column_prec_field, m_currentColumn, m_manager, FWTableViewTableManager::m_tableFormats, m_tableManager, and m_tableWidget.

                                {
   if (m_currentColumn >= 0 && m_currentColumn < (int)m_tableManager->m_tableFormats->size()) {
     m_tableManager->m_tableFormats->erase(m_tableManager->m_tableFormats->begin() + m_currentColumn);
     m_column_name_field->SetText("");
     m_column_expr_field->SetText("");
     m_column_prec_field->SetText("");
     m_currentColumn = -1;
   }
   // change needs to be propagated to all tables, because all
   // tables displaying objects of this type are affected
   // MT -- this is NOT true!!! FIX
   m_tableWidget->forceLayout();
   m_manager->dataChanged();
 }

const FWEventItem * FWTableView::item ( ) const

Definition at line 544 of file FWTableView.cc.

References FWTableViewManager::items(), m_iColl, and m_manager.

Referenced by Vispa.Views.TableView.TableView::_selectedRow(), FWTableViewTableManager::cellRenderer(), FWTableViewTableManager::dataChanged(), FWTableViewTableManager::implSort(), Vispa.Views.TableView.TableView::itemSelectionChanged(), modelSelected(), FWTableViewTableManager::numberOfRows(), FWTableViewTableManager::rowHeader(), Vispa.Views.TableView.TableView::select(), selectCollection(), Vispa.Views.TableView.TableView::selection(), and updateItems().

                                            {
   if (m_iColl == -1)
     return nullptr;
   return m_manager->items()[m_iColl];
 }

void FWTableView::modelSelected	(	Int_t	iRow,
		Int_t	iButton,
		Int_t	iKeyMod,
		Int_t	iGlobalX,
		Int_t	iGlobalY
	)

Definition at line 597 of file FWTableView.cc.

References FWSelectionManager::clearSelection(), item(), FWViewBase::openSelectedModelContextMenu_, FWEventItem::select(), FWEventItem::selectionManager(), and FWEventItem::toggleSelect().

                                                                                                         {
   if (iKeyMod & kKeyControlMask) {
     item()->toggleSelect(iRow);
   } else {
     FWChangeSentry sentry(*(item()->changeManager()));
     item()->selectionManager()->clearSelection();
     item()->select(iRow);
   }
   if (iButton == kButton3) {
     openSelectedModelContextMenu_(iGlobalX, iGlobalY);
   }
 }

void FWTableView::modifyColumn ( )

Definition at line 665 of file FWTableView.cc.

References FWTableViewManager::dataChanged(), MillePedeFileConverter_cfg::e, jets_cff::expr, FWTableWidget::forceLayout(), fwLog, createfilelist::int, fwlog::kInfo, m_column_expr_field, m_column_name_field, m_column_prec_field, m_currentColumn, m_manager, FWTableViewTableManager::m_tableFormats, m_tableManager, m_tableWidget, Skims_PA_cff::name, mps_setup::stdout, and AlCaHLTBitMon_QueryRunRegistry::string.

                                {
   std::string name = m_column_name_field->GetText();
   std::string expr = m_column_expr_field->GetText();
   // convert the precision to a long int
   char *endptr = nullptr;
   int prec = (int)strtol(m_column_prec_field->GetText(), &endptr, 0);
   if (name.empty() || expr.empty() || m_column_prec_field->GetText() == nullptr || *endptr != 0) {
     fwLog(fwlog::kInfo) << "bad input\n";
     fflush(stdout);
     return;
   }
   fwLog(fwlog::kInfo) << "modify column " << name << ": " << expr << ", precision " << prec << std::endl;
   fflush(stdout);
   //      m_manager->tableFormats(*item->modelType())
   FWTableViewManager::TableEntry e = {expr, name, prec};
   m_tableManager->m_tableFormats->at(m_currentColumn) = e;
   // Change needs to be propagated to all tables, because all
   // tables displaying objects of this type are affected
   // MT -- this is NOT true!!! FIX
   m_tableWidget->forceLayout();
   m_manager->dataChanged();
 }

const FWTableView& FWTableView::operator= ( const FWTableView & )

privatedelete

void FWTableView::resetColors ( const class FWColorManager & )

Definition at line 300 of file FWTableView.cc.

References FWColorManager::background(), FWColorManager::foreground(), m_tableWidget, FWTableWidget::SetBackgroundColor(), and FWTableWidget::SetLineSeparatorColor().

Referenced by FWTableView().

                                                            {
   m_tableWidget->SetBackgroundColor(gVirtualX->GetPixel(manager.background()));
   //      m_tableWidget->SetHeaderBackgroundColor(gVirtualX->GetPixel(manager.background()));
   //      switch (manager.foreground()) {
   //      case FWColorManager::kBlackIndex:
   //      m_tableWidget->SetHeaderForegroundColor(gVirtualX->GetPixel(kBlack));
   //      break;
   //      default:
   //      m_tableWidget->SetHeaderForegroundColor(0xffffff);
   //      break;
   //      }
   m_tableWidget->SetLineSeparatorColor(gVirtualX->GetPixel(manager.foreground()));
   //      m_tableWidget->dataChanged();
 }

void FWTableView::saveImageTo ( const std::string & iName ) const

overridevirtual

Implements FWViewBase.

Definition at line 423 of file FWTableView.cc.

References HltBtagPostValidation_cff::c, FWTableViewTableManager::cellRenderer(), gather_cfg::cout, FWTextTableCellRenderer::data(), data, dqm-mbProfile::format, FWTableViewTableManager::m_tableFormats, m_tableManager, FWTableViewTableManager::numberOfColumns(), FWTableViewTableManager::numberOfRows(), alignCSCRings::r, confdb::splitter(), contentValuesCheck::ss, AlCaHLTBitMon_QueryRunRegistry::string, and FWTableViewTableManager::unsortedRowNumber().

                                                        {
   TString format;
   TString data;
   FWTextTableCellRenderer *textRenderer;
 
   // calculate widths
   int ndheader = TMath::Ceil(TMath::Log10(m_tableManager->numberOfRows()));
 
   std::vector<size_t> widths(m_tableManager->numberOfColumns());
 
   for (int c = 0; c < m_tableManager->numberOfColumns(); ++c)
     widths[c] = m_tableManager->m_tableFormats->at(c).name.size();
 
   for (int c = 0; c < m_tableManager->numberOfColumns(); ++c) {
     for (int r = 0; r < m_tableManager->numberOfRows(); r++) {
       textRenderer = (FWTextTableCellRenderer *)m_tableManager->cellRenderer(r, c);  // setup cell renderer
       size_t ss = textRenderer->data().size();
       if (widths[c] < ss)
         widths[c] = ss;
     }
   }
 
   int rlen = 0;
   for (size_t c = 0; c < (size_t)m_tableManager->numberOfColumns(); ++c)
     rlen += widths[c];
   rlen += (m_tableManager->numberOfColumns() - 1) * 3;
   rlen++;
 
   // header
   printf("\n");
   TString headerFormat;
   headerFormat.Form("%%%ds", ndheader + 3);
   data.Form(headerFormat, "  ");
   printf("%s", data.Data());
 
   int lastCol = m_tableManager->numberOfColumns() - 1;
 
   for (int c = 0; c < m_tableManager->numberOfColumns(); ++c) {
     format.Form("%%%ds", (int)widths[c]);
     data.Form(format, m_tableManager->m_tableFormats->at(c).name.c_str());
 
     if (c == lastCol)
       printf("%s", data.Data());
     else
       printf("%s | ", data.Data());
   }
   printf("\n");
 
   std::string splitter(rlen, '-');
   std::cout << splitter << std::endl;
 
   // body
   headerFormat.Form("[%%%dd] ", ndheader);
   for (int r = 0; r < m_tableManager->numberOfRows(); r++) {
     for (int c = 0; c < m_tableManager->numberOfColumns(); ++c) {
       if (!c) {
         data.Form(headerFormat, m_tableManager->unsortedRowNumber(r));
         printf("%s", data.Data());
       }
       format.Form("%%%ds", (int)widths[c]);
       textRenderer = (FWTextTableCellRenderer *)m_tableManager->cellRenderer(r, c);  // setup cell renderer
       data.Form(format, textRenderer->data().c_str());
       if (c == lastCol)
         printf("%s", data.Data());
       else
         printf("%s | ", data.Data());
     }
     printf("\n");
   }
 }

void FWTableView::selectCollection ( Int_t i_coll )

Select the collection to be displayed by the table view and updates the evaluators required to retrieve the data from the event.

Definition at line 569 of file FWTableView.cc.

References dataChanged(), FWTableWidget::forceLayout(), fwLog, item(), FWTableViewManager::items(), fwlog::kInfo, m_iColl, m_manager, FWTableViewManager::m_tableFormats, FWTableViewTableManager::m_tableFormats, m_tableManager, m_tableWidget, m_useColumnsFromConfig, m_validator, FWEventItem::modelType(), edm::second(), FWExpressionValidator::setType(), and FWTableViewManager::tableFormats().

                                                {
   //      printf("selected collection %d, ", i_coll);
   const FWEventItem *item = m_manager->items()[i_coll];
   assert(nullptr != item);
   //      printf("%s\n", item->modelType()->GetName());
   m_iColl = i_coll;
   //      m_validator = new FWExpressionValidator;
   //      m_column_expr_field->setValidator(m_validator);
   if (m_validator != nullptr) {
     //    std::cout << "setting validator to " << item->modelType()->GetName() << std::endl;
     m_validator->setType(edm::TypeWithDict(*(item->modelType()->GetTypeInfo())));
   } else {
     //    std::cout << "can't set null validator\n";
   }
   if (not m_useColumnsFromConfig) {
     if (m_manager->tableFormats(*item->modelType()) == m_manager->m_tableFormats.end()) {
       fwLog(fwlog::kInfo) << "No table format for objects of this type " << item->modelType()->GetName() << std::endl;
       m_tableManager->m_tableFormats->clear();
     } else {
       m_tableManager->m_tableFormats = &m_manager->tableFormats(*item->modelType())->second;
     }
   }
   //      columnSelected(-1, 1, 0);
   if (m_tableWidget)
     m_tableWidget->forceLayout();
   dataChanged();
 }

void FWTableView::setBackgroundColor ( Color_t iColor )

Definition at line 294 of file FWTableView.cc.

References m_tableWidget, and FWTableWidget::SetBackgroundColor().

Referenced by Vispa.Plugins.EdmBrowser.EventContentView.LabelItem::__init__().

                                                    {
   m_tableWidget->SetBackgroundColor(gVirtualX->GetPixel(iColor));
   //      m_tableWidget->SetBackgroundColor(TColor::Number2Pixel(iColor));
   //    m_viewer->GetGLViewer()->SetClearColor(iColor);
 }

void FWTableView::setFrom ( const FWConfiguration & iFrom )

overridevirtual

Reimplemented from FWConfigurableParameterizable.

Definition at line 358 of file FWTableView.cc.

References beam_dqm_sourceclient-live_cfg::cerr, universalConfigTemplate::collection, bysipixelclustmulteventfilter_cfi::collectionName, FWTableViewManager::items(), kCollection, kDescendingSort, kSortColumn, kTableView, m_collection, m_manager, m_tableManager, m_tableWidget, FWTableViewManager::m_views, FWTableViewTableManager::numberOfColumns(), FWConfigurableParameterizable::setFrom(), FWTableViewManager::setFrom(), FWTableWidget::sort(), AlCaHLTBitMon_QueryRunRegistry::string, FWConfiguration::value(), FWConfiguration::valueForKey(), and FWConfiguration::version().

                                                       {
   if (this == m_manager->m_views.front().get())
     m_manager->setFrom(iFrom);
   try {
     const FWConfiguration *main = iFrom.valueForKey(kTableView);
     assert(main != nullptr);
     // use the columns from the config, not the default columns for
     // the collection type
     //        m_useColumnsFromConfig = true;
     //    m_tableManager->m_tableFormats->clear();
     //    const FWConfiguration *columns = main->valueForKey(kColumns);
     //    for (FWConfiguration::StringValuesIt it = columns->stringValues()->begin(),
     //          itEnd = columns->stringValues()->end(); it != itEnd; ++it) {
     //         const std::string &name = *it++;
     //         const std::string &expr = *it++;
     //         int prec = atoi(it->c_str());
     //         FWTableViewManager::TableEntry e = { expr, name, prec };
     //         m_tableManager->m_tableFormats->push_back(e);
     //    }
     const FWConfiguration *collection = main->valueForKey(kCollection);
     const std::string &collectionName = collection->value();
     // find item
     for (std::vector<const FWEventItem *>::const_iterator it = m_manager->items().begin(),
                                                           itEnd = m_manager->items().end();
          it != itEnd;
          ++it) {
       if (*it && (*it)->name() == collectionName) {
         m_collection->Select(it - m_manager->items().begin(), true);
         break;
       }
     }
     const FWConfiguration *sortColumn = main->valueForKey(kSortColumn);
     const FWConfiguration *descendingSort = main->valueForKey(kDescendingSort);
     if (sortColumn != nullptr && descendingSort != nullptr) {
       unsigned int sort = sortColumn->version();
       bool descending = descendingSort->version();
       if (sort < ((unsigned int)m_tableManager->numberOfColumns()))
         m_tableWidget->sort(sort, descending);
     }
   } catch (...) {
     // configuration doesn't contain info for the table.  Be forgiving.
     std::cerr << "This configuration file contains tables, but no column information.  "
                  "(It is probably old.)  Using defaults."
               << std::endl;
   }
 
   //      main.addKeyValue(kCollection, collection);
   //      FWConfiguration columns(1);
   //      for (std::vector<FWTableViewManager::TableEntry>::const_iterator
   //           i = m_tableManager->m_tableFormats->begin(),
   //           iEnd = m_tableManager->m_tableFormats->end();
   //      i != iEnd; ++i) {
   //      columns.addValue(i->name);
   //      columns.addValue(i->expression);
   //      columns.addValue(Form("%d", i->precision));
   //      }
   //      main.addKeyValue(kColumns, columns);
   //      iTo.addKeyValue(kTableView, main);
   //      // take care of parameters
   //      FWConfigurableParameterizable::addTo(iTo);
 
   // take care of parameters
   FWConfigurableParameterizable::setFrom(iFrom);
 }

void FWTableView::toggleShowHide ( )

Definition at line 494 of file FWTableView.cc.

References arrow_down(), arrow_down_disabled(), arrow_right(), arrow_right_disabled(), FWColorManager::background(), FWViewManagerBase::colorManager(), mps_check::disabled, down, m_column_control, m_columnUIButton, m_manager, m_showColumnUI, m_vert, and FWCustomIconsButton::swapIcons().

                                  {
   m_showColumnUI = not m_showColumnUI;
   const TGPicture *picture = nullptr;
   const TGPicture *down = nullptr;
   const TGPicture *disabled = nullptr;
   const bool bgIsBlack = m_manager->colorManager().background() == kBlack;
   if (m_showColumnUI) {
     picture = arrow_down(bgIsBlack);
     down = arrow_down_disabled(bgIsBlack);
     disabled = arrow_down_disabled(bgIsBlack);
     m_vert->ShowFrame(m_column_control);
   } else {
     picture = arrow_right(bgIsBlack);
     down = arrow_right_disabled(bgIsBlack);
     disabled = arrow_right_disabled(bgIsBlack);
     m_vert->HideFrame(m_column_control);
   }
   m_vert->Layout();
   m_columnUIButton->swapIcons(picture, down, disabled);
 }

void FWTableView::updateEvaluators ( )

Definition at line 542 of file FWTableView.cc.

References m_tableManager, and FWTableViewTableManager::updateEvaluators().

Referenced by dataChanged().

542 { m_tableManager->updateEvaluators(); }

FWTableView::m_tableManager

FWTableViewTableManager * m_tableManager

Definition: FWTableView.h:91

FWTableViewTableManager::updateEvaluators

void updateEvaluators()

Definition: FWTableViewTableManager.cc:223

void FWTableView::updateItems ( void )

Reconstructs the combo box using the information coming from FWEventItemsManager.

Definition at line 518 of file FWTableView.cc.

References MillePedeFileConverter_cfg::e, mps_fire::i, item(), FWTableViewManager::items(), m_collection, m_iColl, m_manager, Min(), and FWEventItem::name().

Referenced by FWTableView(), and FWTableViewManager::notifyViews().

                                   {
   int selected = m_collection->GetSelected();
   m_collection->RemoveAll();
   int index = 0;
 
   for (size_t i = 0, e = m_manager->items().size(); i != e; ++i) {
     const FWEventItem *item = m_manager->items()[i];
     if (item)
       m_collection->AddEntry(item->name().c_str(), i);
 
     if (m_iColl == index && nullptr == item) {
       //the collection we were showing is now gone
       m_iColl = -1;
       selected = -1;
     }
   }
 
   if (selected != -1 && selected < m_collection->GetNumberOfEntries())
     m_collection->Select(selected, false);
 
   TGListBox *lb = m_collection->GetListBox();
   lb->SetHeight(TMath::Min(lb->GetNumberOfEntries() * lb->GetItemVsize() + 2 * lb->GetBorderWidth(), 200u));
 }