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

	ClassDef (FWTabularWidget, 0)

void	dataChanged ()

void	disableGrowInWidth ()

void	DoRedraw ()

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

TGDimension	GetDefaultSize () const

virtual Bool_t	HandleButton (Event_t *event)

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

virtual	~FWTabularWidget ()

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	(	FWTableManagerBase *	iManager,
		const TGWindow *	p = `0`,
		GContext_t	context = `getDefaultGC()()`
	)

Definition at line 40 of file FWTabularWidget.cc.

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

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

FWTabularWidget::~FWTabularWidget ( )

virtual

Definition at line 71 of file FWTabularWidget.cc.

References m_table.

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

Member Function Documentation

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

Definition at line 222 of file FWTabularWidget.cc.

References harvestRelVal::args.

Referenced by python.Vispa.Gui.BoxContentDialog.BoxContentDialog::addButton(), and HandleButton().

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

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

Definition at line 234 of file FWTabularWidget.cc.

References harvestRelVal::args.

Referenced by HandleButton().

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

FWTabularWidget::ClassDef	(	FWTabularWidget	,
		0
	)

void FWTabularWidget::dataChanged ( void )

Definition at line 92 of file FWTabularWidget.cc.

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

Referenced by FWTableWidget::dataChanged().

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

void FWTabularWidget::disableGrowInWidth ( )

inline

Definition at line 71 of file FWTabularWidget.h.

References m_growInWidth.

Referenced by FWTableWidget::disableGrowInWidth().

71 { m_growInWidth = false; }

FWTabularWidget::m_growInWidth

bool m_growInWidth

Definition: FWTabularWidget.h:94

void FWTabularWidget::DoRedraw ( )

Definition at line 247 of file FWTabularWidget.cc.

References FWTableManagerBase::cellRenderer(), 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 detailsBasic3DVector::y.

Referenced by FWPathsPopup::postProcessEvent().

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

const TGGC & FWTabularWidget::getDefaultGC ( )

static

Definition at line 355 of file FWTabularWidget.cc.

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

TGDimension FWTabularWidget::GetDefaultSize ( ) const

Definition at line 334 of file FWTabularWidget.cc.

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

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

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

Bool_t FWTabularWidget::HandleButton ( Event_t * event )

virtual

Definition at line 152 of file FWTabularWidget.cc.

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

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

UInt_t FWTabularWidget::horizontalOffset ( ) const

inline

Definition at line 46 of file FWTabularWidget.h.

References m_hOffset.

46 { return m_hOffset;}

FWTabularWidget::m_hOffset

unsigned int m_hOffset

Definition: FWTabularWidget.h:89

void FWTabularWidget::needToRedraw ( )

Definition at line 99 of file FWTabularWidget.cc.

 {
    fClient->NeedRedraw(this);
 }

void FWTabularWidget::setBackgroundAreaContext ( GContext_t iContext )

Definition at line 325 of file FWTabularWidget.cc.

References m_backgroundGC.

Referenced by FWTableWidget::SetHeaderBackgroundColor().

 {
    m_backgroundGC = iContext;
 }

void FWTabularWidget::setHorizontalOffset ( UInt_t iH )

Definition at line 143 of file FWTabularWidget.cc.

References m_hOffset.

Referenced by FWTableWidget::ProcessMessage().

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

void FWTabularWidget::setLineContext ( GContext_t iContext )

Definition at line 320 of file FWTabularWidget.cc.

References m_normGC.

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

 {
    m_normGC = iContext;
 }

void FWTabularWidget::setVerticalOffset ( UInt_t iV )

Definition at line 135 of file FWTabularWidget.cc.

References m_vOffset.

Referenced by FWTableWidget::ProcessMessage().

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

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

Definition at line 106 of file FWTabularWidget.cc.

References gen::k, kSeperatorWidth, kTextBuffer, m_growInWidth, m_table, m_tableWidth, m_widthOfTextInColumns, m_widthOfTextInColumnsMax, and FWTableManagerBase::numberOfColumns().

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

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

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 184 of file FWTabularWidget.cc.

References kSeperatorWidth, kTextBuffer, m_hOffset, m_table, m_tableWidth, m_textHeight, m_vOffset, m_widthOfTextInColumns, and FWTableManagerBase::numberOfRows().

Referenced by DoRedraw(), and HandleButton().

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