#include <Fireworks/TableWidget/interface/FWTabularWidget.h>

Inheritance diagram for FWTabularWidget:

Public Member Functions
void	buttonPressed (Int_t row, Int_t column, Event_t *event, Int_t relX, Int_t relY)

void	buttonReleased (Int_t row, Int_t column, Event_t *event, Int_t relX, Int_t relY)

	ClassDefOverride (FWTabularWidget, 0)

void	dataChanged ()

void	disableGrowInWidth ()

void	DoRedraw () override

	FWTabularWidget (FWTableManagerBase iManager, const TGWindow p=nullptr, GContext_t context=getDefaultGC()())

TGDimension	GetDefaultSize () const override

Bool_t	HandleButton (Event_t *event) override

UInt_t	horizontalOffset () const

void	needToRedraw ()

void	setBackgroundAreaContext (GContext_t iContext)

void	setHorizontalOffset (UInt_t)

void	setLineContext (GContext_t iContext)

void	setVerticalOffset (UInt_t)

void	setWidthOfTextInColumns (const std::vector< unsigned int > &)

UInt_t	verticalOffset () const

const std::vector< unsigned int > &	widthOfTextInColumns () const

	~FWTabularWidget () override

Static Public Member Functions
static const TGGC &	getDefaultGC ()

Static Public Attributes
static const int	kSeperatorWidth = 1

static const int	kTextBuffer = 2

Private Member Functions
void	translateToRowColumn (Int_t iX, Int_t iY, Int_t &oRow, Int_t &oCol, Int_t &oRelX, Int_t &oRelY) const

Private Attributes
GContext_t	m_backgroundGC

bool	m_growInWidth

unsigned int	m_hOffset

GContext_t	m_normGC

FWTableManagerBase *	m_table

int	m_tableWidth

int	m_textHeight

unsigned int	m_vOffset

std::vector< unsigned int >	m_widthOfTextInColumns

std::vector< unsigned int >	m_widthOfTextInColumnsMax

Detailed Description

Description: Widget that draws part of a table [Implementation detail of FWTableWidget]

Usage: This class is used internally by FWTableWidget.

Definition at line 31 of file FWTabularWidget.h.

Constructor & Destructor Documentation

◆ FWTabularWidget()

FWTabularWidget::FWTabularWidget	(	FWTableManagerBase *	iManager,
		const TGWindow *	p = `nullptr`,
		GContext_t	context = `getDefaultGC()()`
	)

Definition at line 38 of file FWTabularWidget.cc.

     : TGFrame(p),
       m_table(iTable),
       m_widthOfTextInColumns(m_table->numberOfColumns(), static_cast<unsigned int>(0)),
       m_vOffset(0),
       m_hOffset(0),
       m_normGC(context),
       m_backgroundGC(ULONG_MAX),
       m_growInWidth(true) {
   m_textHeight = iTable->cellHeight();
   m_widthOfTextInColumns = m_table->maxWidthForColumns();
  
   m_tableWidth = (kTextBuffer + kTextBuffer + kSeperatorWidth) * (m_widthOfTextInColumns.size()) + kSeperatorWidth;
   for (std::vector<unsigned int>::const_iterator it = m_widthOfTextInColumns.begin(),
                                                  itEnd = m_widthOfTextInColumns.end();
        it != itEnd;
        ++it) {
     m_tableWidth += *it;
   }
   Resize();
  
   gVirtualX->GrabButton(fId, kAnyButton, kAnyModifier, kButtonPressMask | kButtonReleaseMask, kNone, kNone);
   m_table->Connect("visualPropertiesChanged()", "FWTabularWidget", this, "needToRedraw()");
 }

References FWTableManagerBase::cellHeight(), WDecay::kNone, kSeperatorWidth, kTextBuffer, m_table, m_tableWidth, m_textHeight, m_widthOfTextInColumns, and FWTableManagerBase::maxWidthForColumns().

◆ ~FWTabularWidget()

FWTabularWidget::~FWTabularWidget ( )

override

Definition at line 68 of file FWTabularWidget.cc.

68 { m_table->Disconnect("visualPropertiesChanged()", this, "needToRedraw()"); }

References m_table.

Member Function Documentation

◆ buttonPressed()

void FWTabularWidget::buttonPressed	(	Int_t	row,
		Int_t	column,
		Event_t *	event,
		Int_t	relX,
		Int_t	relY
	)

Definition at line 200 of file FWTabularWidget.cc.

                                                                                                    {
   //std::cout <<"buttonPressed "<<row<<" "<<column<<std::endl;
   Long_t args[5];
   args[0] = (Long_t)row;
   args[1] = (Long_t)column;
   args[2] = (Long_t)event;
   args[3] = (Long_t)relX;
   args[4] = (Long_t)relY;
   Emit("buttonPressed(Int_t,Int_t,Event_t*,Int_t,Int_t)", args);
 }

References writedatasetfile::args.

Referenced by HandleButton().

◆ buttonReleased()

void FWTabularWidget::buttonReleased	(	Int_t	row,
		Int_t	column,
		Event_t *	event,
		Int_t	relX,
		Int_t	relY
	)

Definition at line 210 of file FWTabularWidget.cc.

                                                                                                     {
   //std::cout <<"buttonReleased "<<row<<" "<<column<<std::endl;
   Long_t args[6];
   args[0] = (Long_t)row;
   args[1] = (Long_t)column;
   args[2] = (Long_t)event;
   args[3] = (Long_t)relX;
   args[4] = (Long_t)relY;
   Emit("buttonReleased(Int_t,Int_t,Event_t*,Int_t,Int_t)", args);
 }

References writedatasetfile::args.

Referenced by HandleButton().

◆ ClassDefOverride()

FWTabularWidget::ClassDefOverride	(	FWTabularWidget	,
		0
	)

◆ dataChanged()

void FWTabularWidget::dataChanged ( void )

Definition at line 85 of file FWTabularWidget.cc.

                                   {
   m_textHeight = m_table->cellHeight();
   setWidthOfTextInColumns(m_table->maxWidthForColumns());
 }

References FWTableManagerBase::cellHeight(), m_table, m_textHeight, FWTableManagerBase::maxWidthForColumns(), and setWidthOfTextInColumns().

Referenced by FWTableWidget::dataChanged().

◆ disableGrowInWidth()

void FWTabularWidget::disableGrowInWidth ( )

inline

Definition at line 69 of file FWTabularWidget.h.

69 { m_growInWidth = false; }

References m_growInWidth.

Referenced by FWTableWidget::disableGrowInWidth().

◆ DoRedraw()

void FWTabularWidget::DoRedraw ( )

override

Definition at line 221 of file FWTabularWidget.cc.

                                {
   TGFrame::DoRedraw();
  
   //std::cout <<"DoRedraw "<<m_tableWidth<<std::endl;
  
   const int yOrigin = -m_vOffset;
   const int xOrigin = -m_hOffset;
   const int visibleWidth = m_tableWidth + xOrigin - kSeperatorWidth;
   int y = yOrigin;
   if (m_backgroundGC != ULONG_MAX) {
     gVirtualX->FillRectangle(fId, m_backgroundGC, xOrigin, y, m_tableWidth, GetHeight());
   }
   gVirtualX->DrawLine(fId, m_normGC, xOrigin, y, visibleWidth, y);
   //Draw data
   const int numRows = m_table->numberOfRows();
  
   //figure out which rows and columns are visible
   Int_t startRow, startColumn, relX, relY;
   translateToRowColumn(0, 0, startRow, startColumn, relX, relY);
   if (startRow < 0) {
     startRow = 0;
   }
   if (startColumn < 0) {
     startColumn = 0;
   }
   Int_t endRow, endColumn;
   translateToRowColumn(GetWidth(), GetHeight(), endRow, endColumn, relX, relY);
   if (endRow >= numRows) {
     endRow = numRows - 1;
   }
   if (endColumn >= static_cast<Int_t>(m_widthOfTextInColumns.size())) {
     endColumn = m_widthOfTextInColumns.size() - 1;
   }
   //std::cout <<"start "<<startRow<<" "<<startColumn<<" end "<<endRow<<" "<<endColumn<<std::endl;
  
   //calculate offset for rows and columns
   Int_t rowOffset = (kSeperatorWidth + 2 * kTextBuffer + m_textHeight) * startRow;
   Int_t columnOffset = kSeperatorWidth + kTextBuffer + xOrigin;
   for (std::vector<unsigned int>::iterator itTextWidth = m_widthOfTextInColumns.begin(),
                                            itEnd = m_widthOfTextInColumns.begin() + startColumn;
        itTextWidth != itEnd;
        ++itTextWidth) {
     columnOffset += *itTextWidth + kTextBuffer + kSeperatorWidth + kTextBuffer;
   }
  
   y += rowOffset;
   for (int row = startRow; row <= endRow; ++row) {
     std::vector<unsigned int>::iterator itTextWidth = m_widthOfTextInColumns.begin() + startColumn;
     //int x=kSeperatorWidth+kTextBuffer+xOrigin;
     int x = columnOffset;
     y += kTextBuffer + kSeperatorWidth;
     for (int col = startColumn; col <= endColumn; ++col, ++itTextWidth) {
       m_table->cellRenderer(row, col)->draw(fId, x, y, *itTextWidth, m_textHeight);
       //UInt_t textWidth = font->TextWidth(itData->c_str(),-1);
       x += *itTextWidth + kTextBuffer + kSeperatorWidth + kTextBuffer;
     }
     y += +m_textHeight + kTextBuffer;
     gVirtualX->DrawLine(fId, m_normGC, xOrigin, y, visibleWidth, y);
   }
  
   //draw column separators
   int x = xOrigin;
   gVirtualX->DrawLine(fId, m_normGC, x, 0, x, y);
   x += kSeperatorWidth;
   for (std::vector<unsigned int>::iterator itTextWidth = m_widthOfTextInColumns.begin();
        itTextWidth != m_widthOfTextInColumns.end();
        ++itTextWidth) {
     x += 2 * kTextBuffer + *itTextWidth;
     gVirtualX->DrawLine(fId, m_normGC, x, 0, x, y);
     x += kSeperatorWidth;
   }
 }

References FWTableManagerBase::cellRenderer(), cuy::col, FWTableCellRendererBase::draw(), kSeperatorWidth, kTextBuffer, m_backgroundGC, m_hOffset, m_normGC, m_table, m_tableWidth, m_textHeight, m_vOffset, m_widthOfTextInColumns, FWTableManagerBase::numberOfRows(), translateToRowColumn(), x, and y.

Referenced by FWPathsPopup::postEvent().

◆ getDefaultGC()

const TGGC & FWTabularWidget::getDefaultGC ( )

static

Definition at line 319 of file FWTabularWidget.cc.

                                           {
   static const TGGC* s_default = gClient->GetResourcePool()->GetFrameGC();
   return *s_default;
 }

◆ GetDefaultSize()

TGDimension FWTabularWidget::GetDefaultSize ( ) const

override

Definition at line 300 of file FWTabularWidget.cc.

                                                   {
   // returns default size
  
   UInt_t w = fWidth;
   if (!(GetOptions() & kFixedWidth)) {
     w = m_tableWidth;
   }
   UInt_t h = fHeight;
   if (!(GetOptions() & kFixedHeight)) {
     unsigned int numRows = m_table->numberOfRows();
  
     h = kSeperatorWidth + (m_textHeight + 2 * kTextBuffer + kSeperatorWidth) * (numRows);
   }
   return TGDimension(w, h);
 }

References kSeperatorWidth, kTextBuffer, m_table, m_tableWidth, m_textHeight, FWTableManagerBase::numberOfRows(), and w.

Referenced by FWTableWidget::GetDefaultSize(), and FWTableWidget::handleResize().

◆ HandleButton()

Bool_t FWTabularWidget::HandleButton ( Event_t * event )

override

Definition at line 132 of file FWTabularWidget.cc.

                                                    {
   if (event->fType == kButtonPress) {
     Int_t row, col, relX, relY;
     translateToRowColumn(event->fX, event->fY, row, col, relX, relY);
     //std::cout <<"Press: "<<relX<<" "<<relY<<" "<<row<<" "<<col<<" "<<m_table->numberOfRows()<<" "<<m_table->numberOfColumns()<<std::endl;
     if (row >= 0 && row < m_table->numberOfRows() && col >= 0 && col < m_table->numberOfColumns()) {
       FWTableCellRendererBase* renderer = m_table->cellRenderer(row, col);
       if (renderer) {
         renderer->buttonEvent(event, relX, relY);
       }
       buttonPressed(row, col, event, relX, relY);
     }
     return true;
   }
   if (event->fType == kButtonRelease) {
     Int_t row, col, relX, relY;
     translateToRowColumn(event->fX, event->fY, row, col, relX, relY);
     //std::cout <<"Release: "<<relX<<" "<<relY<<" "<<row<<" "<<col<<" "<<m_table->numberOfRows()<<" "<<m_table->numberOfColumns()<<std::endl;
     if (row >= 0 && row < m_table->numberOfRows() && col >= 0 && col < m_table->numberOfColumns()) {
       FWTableCellRendererBase* renderer = m_table->cellRenderer(row, col);
       if (renderer) {
         renderer->buttonEvent(event, relX, relY);
       }
       buttonReleased(row, col, event, relX, relY);
     }
     return true;
   }
   return false;
 }

References FWTableCellRendererBase::buttonEvent(), buttonPressed(), buttonReleased(), FWTableManagerBase::cellRenderer(), cuy::col, m_table, and translateToRowColumn().

◆ horizontalOffset()

UInt_t FWTabularWidget::horizontalOffset ( ) const

inline

Definition at line 44 of file FWTabularWidget.h.

44 { return m_hOffset; }

References m_hOffset.

◆ needToRedraw()

void FWTabularWidget::needToRedraw ( )

Definition at line 90 of file FWTabularWidget.cc.

90 { fClient->NeedRedraw(this); }

References hcaldqm::fClient.

◆ setBackgroundAreaContext()

void FWTabularWidget::setBackgroundAreaContext ( GContext_t iContext )

Definition at line 295 of file FWTabularWidget.cc.

295 { m_backgroundGC = iContext; }

References m_backgroundGC.

Referenced by FWTableWidget::SetHeaderBackgroundColor().

◆ setHorizontalOffset()

void FWTabularWidget::setHorizontalOffset ( UInt_t iH )

Definition at line 125 of file FWTabularWidget.cc.

                                                    {
   if (iH != m_hOffset) {
     m_hOffset = iH;
     fClient->NeedRedraw(this);
   }
 }

References hcaldqm::fClient, and m_hOffset.

Referenced by FWTableWidget::ProcessMessage().

◆ setLineContext()

void FWTabularWidget::setLineContext ( GContext_t iContext )

Definition at line 294 of file FWTabularWidget.cc.

294 { m_normGC = iContext; }

References m_normGC.

Referenced by FWTableWidget::SetHeaderForegroundColor(), and FWTableWidget::SetLineSeparatorColor().

◆ setVerticalOffset()

void FWTabularWidget::setVerticalOffset ( UInt_t iV )

Definition at line 119 of file FWTabularWidget.cc.

                                                  {
   if (iV != m_vOffset) {
     m_vOffset = iV;
     fClient->NeedRedraw(this);
   }
 }

References hcaldqm::fClient, and m_vOffset.

Referenced by FWTableWidget::ProcessMessage().

◆ setWidthOfTextInColumns()

void FWTabularWidget::setWidthOfTextInColumns ( const std::vector< unsigned int > & iNew )

Definition at line 92 of file FWTabularWidget.cc.

                                                                                  {
   assert(iNew.size() == static_cast<unsigned int>(m_table->numberOfColumns()));
  
   m_widthOfTextInColumns = iNew;
   if (m_growInWidth) {
     // with of columns grow to prevent resizing/flickering on next event
     m_widthOfTextInColumnsMax.resize(iNew.size());
     std::vector<unsigned int>::iterator k = m_widthOfTextInColumnsMax.begin();
     for (std::vector<unsigned int>::iterator it = m_widthOfTextInColumns.begin(); it != m_widthOfTextInColumns.end();
          ++it, ++k) {
       if (*it < *k)
         *it = *k;
       else
         *k = *it;
     }
   }
  
   m_tableWidth = 0;
   for (std::vector<unsigned int>::const_iterator it = m_widthOfTextInColumns.begin(),
                                                  itEnd = m_widthOfTextInColumns.end();
        it != itEnd;
        ++it) {
     m_tableWidth += *it + kTextBuffer + kTextBuffer + kSeperatorWidth;
   }
   m_tableWidth += kSeperatorWidth;
 }

References cms::cuda::assert(), dqmdumpme::k, kSeperatorWidth, kTextBuffer, m_growInWidth, m_table, m_tableWidth, m_widthOfTextInColumns, m_widthOfTextInColumnsMax, and FWTableManagerBase::numberOfColumns().

Referenced by dataChanged(), FWTableWidget::dataChanged(), and FWTableWidget::FWTableWidget().

◆ translateToRowColumn()

void FWTabularWidget::translateToRowColumn	(	Int_t	iX,
		Int_t	iY,
		Int_t &	oRow,
		Int_t &	oCol,
		Int_t &	oRelX,
		Int_t &	oRelY
	)		const

private

Definition at line 162 of file FWTabularWidget.cc.

                                                                                     {
   if (iX < 0) {
     oCol = -1;
     oRelX = 0;
   } else {
     if (iX + static_cast<Int_t>(m_hOffset) > static_cast<Int_t>(m_tableWidth)) {
       oCol = m_widthOfTextInColumns.size();
       oRelX = 0;
     } else {
       iX += m_hOffset;
       oCol = 0;
       for (std::vector<unsigned int>::const_iterator it = m_widthOfTextInColumns.begin(),
                                                      itEnd = m_widthOfTextInColumns.end();
            it != itEnd;
            ++it, ++oCol) {
         oRelX = iX - kTextBuffer;
         iX -= 2 * kTextBuffer + kSeperatorWidth + *it;
         if (iX <= 0) {
           break;
         }
       }
     }
   }
   if (iY < 0) {
     oRow = -1;
     oRelY = 0;
   } else {
     oRow = (int)(float(iY + m_vOffset) / (m_textHeight + 2 * kTextBuffer + kSeperatorWidth));
     oRelY = iY - oRow * (m_textHeight + 2 * kTextBuffer + kSeperatorWidth) + m_vOffset - kTextBuffer;
     Int_t numRows = m_table->numberOfRows();
     if (oRow > numRows) {
       oRow = numRows;
       oRelY = 0;
     }
   }
 }