qtableview.cpp

qtopia-phone-2.2.0下公共的控件实现源代码。

  Sets the auto-update option of the table view to \e enable.

  If \e enable is TRUE (this is the default) then the view updates itself
  automatically whenever it has changed in some way (for example when a
  \link setTableFlags() flag\endlink is changed).

  If \e enable is FALSE, the view does NOT repaint itself, or update
  its internal state variables itself when it is changed.  This can be
  useful to avoid flicker during large changes, and is singularly
  useless otherwise: Disable auto-update, do the changes, re-enable
  auto-update, and call repaint().

  \warning Do not leave the view in this state for a long time
  (i.e. between events ). If, for example, the user interacts with the
  view when auto-update is off, strange things can happen.

  Setting auto-update to TRUE does not repaint the view, you must call
  repaint() to do this.

  \sa autoUpdate(), repaint()
*/

void QTableView::setAutoUpdate( bool enable )
{
    if ( isUpdatesEnabled() == enable )
	return;
    setUpdatesEnabled( enable );
    if ( enable ) {
	showOrHideScrollBars();
	updateScrollBars();
    }
}


/*!
  Repaints the cell at row \e row, column \e col if it is inside the view.

  If \e erase is TRUE, the relevant part of the view is cleared to the
  background color/pixmap before the contents are repainted.

  \sa isVisible()
*/

void QTableView::updateCell( int row, int col, bool erase )
{
    int xPos, yPos;
    if ( !colXPos( col, &xPos ) )
	return;
    if ( !rowYPos( row, &yPos ) )
	return;
    QRect uR = QRect( xPos, yPos,
		      cellW ? cellW : cellWidth(col),
		      cellH ? cellH : cellHeight(row) );
    repaint( uR.intersect(viewRect()), erase );
}


/*!
  \fn QRect QTableView::cellUpdateRect() const

  This function should only be called from the paintCell() function in
  subclasses. It returns the portion of a cell that actually needs to be
  updated, in \e cell coordinates. This is only useful for non-trivial
  paintCell().

*/

/*!
  Returns the rectangle which is the actual table, excluding any
  frame, in \e widget coordinates.
*/

QRect QTableView::viewRect() const
{
    return QRect( frameWidth(), frameWidth(), viewWidth(), viewHeight() );
}


/*!
  Returns the index of the last (bottom) row in the view.
  The index of the first row is 0.

  If no rows are visible it returns -1.	 This can happen if the
  view is too small for the first row and Tbl_cutCellsV is set.

  \sa lastColVisible()
*/

int QTableView::lastRowVisible() const
{
    int cellMaxY;
    int row = findRawRow( maxViewY(), &cellMaxY );
    if ( row == -1 || row >= nRows ) {		// maxViewY() past end?
	row = nRows - 1;			// yes: return last row
    } else {
	if ( testTableFlags(Tbl_cutCellsV) && cellMaxY > maxViewY() ) {
	    if ( row == yCellOffs )		// cut by right margin?
		return -1;			// yes, nothing in the view
	    else
	       row = row - 1;			// cut by margin, one back
	}
    }
    return row;
}

/*!
  Returns the index of the last (right) column in the view.
  The index of the first column is 0.

  If no columns are visible it returns -1.  This can happen if the
  view is too narrow for the first column and Tbl_cutCellsH is set.

  \sa lastRowVisible()
*/

int QTableView::lastColVisible() const
{
    int cellMaxX;
    int col = findRawCol( maxViewX(), &cellMaxX );
    if ( col == -1 || col >= nCols ) {		// maxViewX() past end?
	col = nCols - 1;			// yes: return last col
    } else {
	if ( testTableFlags(Tbl_cutCellsH) && cellMaxX > maxViewX() ) {
	    if ( col == xCellOffs )		// cut by bottom margin?
		return -1;			// yes, nothing in the view
	    else
	       col = col - 1;			// cell by margin, one back
	}
    }
    return col;
}

/*!
  Returns TRUE if \e row is at least partially visible.
  \sa colIsVisible()
*/

bool QTableView::rowIsVisible( int row ) const
{
    return rowYPos( row, 0 );
}

/*!
  Returns TRUE if \e col is at least partially visible.
  \sa rowIsVisible()
*/

bool QTableView::colIsVisible( int col ) const
{
    return colXPos( col, 0 );
}


/*!
  \internal
  Called when both scroll bars are active at the same time. Covers the
  bottom left corner between the two scroll bars with an empty widget.
*/

void QTableView::coverCornerSquare( bool enable )
{
    coveringCornerSquare = enable;
    if ( !cornerSquare && enable ) {
	cornerSquare = new QCornerSquare( this );
	CHECK_PTR( cornerSquare );
	cornerSquare->setGeometry( maxViewX() + 1,
				   maxViewY() + 1,
                                   VSBEXT,
                                 HSBEXT);
    }
    if ( autoUpdate() && cornerSquare ) {
	if ( enable )
	    cornerSquare->show();
	else
	    cornerSquare->hide();
    }
}


/*!
  \internal
  Scroll the view to a position such that:

  If \e horizontal is TRUE, the leftmost column shown fits snugly
  with the left edge of the view.

  If \e vertical is TRUE, the top row shown fits snugly with the top
  of the view.

  You can achieve the same effect automatically by setting any of the
  \link setTableFlags() Tbl_snapTo*Grid \endlink table flags.
*/

void QTableView::snapToGrid( bool horizontal, bool vertical )
{
    int newXCell = -1;
    int newYCell = -1;
    if ( horizontal && xCellDelta != 0 ) {
	int w = cellW ? cellW : cellWidth( xCellOffs );
	if ( xCellDelta >= w/2 )
	    newXCell = xCellOffs + 1;
	else
	    newXCell = xCellOffs;
    }
    if ( vertical && yCellDelta != 0 ) {
	int h = cellH ? cellH : cellHeight( yCellOffs );
	if ( yCellDelta >= h/2 )
	    newYCell = yCellOffs + 1;
	else
	    newYCell = yCellOffs;
    }
    setTopLeftCell( newYCell, newXCell );  //row,column
}

/*!
  \internal
  This internal slot is connected to the horizontal scroll bar's
  QScrollBar::valueChanged() signal.

  Moves the table horizontally to offset \e val without updating the
  scroll bar.
*/

void QTableView::horSbValue( int val )
{
    if ( horSliding ) {
	horSliding = FALSE;
	if ( horSnappingOff ) {
	    horSnappingOff = FALSE;
	    tFlags |= Tbl_snapToHGrid;
	}
    }
    setOffset( val, yOffs, FALSE );
}

/*!
  \internal
  This internal slot is connected to the horizontal scroll bar's
  QScrollBar::sliderMoved() signal.

  Scrolls the table smoothly horizontally even if \c Tbl_snapToHGrid is set.
*/

void QTableView::horSbSliding( int val )
{
    if ( testTableFlags(Tbl_snapToHGrid) &&
	 testTableFlags(Tbl_smoothHScrolling) ) {
	tFlags &= ~Tbl_snapToHGrid;	// turn off snapping while sliding
	setOffset( val, yOffs, FALSE );
	tFlags |= Tbl_snapToHGrid;	// turn on snapping again
    } else {
	setOffset( val, yOffs, FALSE );
    }
}

/*!
  \internal
  This internal slot is connected to the horizontal scroll bar's
  QScrollBar::sliderReleased() signal.
*/

void QTableView::horSbSlidingDone( )
{
    if ( testTableFlags(Tbl_snapToHGrid) &&
	 testTableFlags(Tbl_smoothHScrolling) )
	snapToGrid( TRUE, FALSE );
}

/*!
  \internal
  This internal slot is connected to the vertical scroll bar's
  QScrollBar::valueChanged() signal.

  Moves the table vertically to offset \e val without updating the
  scroll bar.
*/

void QTableView::verSbValue( int val )
{
    if ( verSliding ) {
	verSliding = FALSE;
	if ( verSnappingOff ) {
	    verSnappingOff = FALSE;
	    tFlags |= Tbl_snapToVGrid;
	}
    }
    setOffset( xOffs, val, FALSE );
}

/*!
  \internal
  This internal slot is connected to the vertical scroll bar's
  QScrollBar::sliderMoved() signal.

  Scrolls the table smoothly vertically even if \c Tbl_snapToVGrid is set.
*/

void QTableView::verSbSliding( int val )
{
    if ( testTableFlags(Tbl_snapToVGrid) &&
	 testTableFlags(Tbl_smoothVScrolling) ) {
	tFlags &= ~Tbl_snapToVGrid;	// turn off snapping while sliding
	setOffset( xOffs, val, FALSE );
	tFlags |= Tbl_snapToVGrid;	// turn on snapping again
    } else {
	setOffset( xOffs, val, FALSE );
    }
}

/*!
  \internal
  This internal slot is connected to the vertical scroll bar's
  QScrollBar::sliderReleased() signal.
*/

void QTableView::verSbSlidingDone( )
{
    if ( testTableFlags(Tbl_snapToVGrid) &&
	 testTableFlags(Tbl_smoothVScrolling) )
	snapToGrid( FALSE, TRUE );
}


/*!
  This virtual function is called before painting of table cells
  is started. It can be reimplemented by subclasses that want to
  to set up the painter in a special way and that do not want to
  do so for each cell.
*/

void QTableView::setupPainter( QPainter * )
{
}

/*!
  \fn void QTableView::paintCell( QPainter *p, int row, int col )

  This pure virtual function is called to paint the single cell at \e
  (row,col) using \e p, which is open when paintCell() is called and
  must remain open.

  The coordinate system is \link QPainter::translate() translated \endlink
  such that the origin is at the top left corner of the cell to be
  painted; i.e. \e cell coordinates.  Do not scale or shear the coordinate
  system (or if you do, restore the transformation matrix before you
  return).

  By default, the painter is not clipped, for maximum efficiency. For safety,
  call setTableFlags(Tbl_clipCellPainting) to enable clipping.

  \sa paintEvent(), QPainter(), setTableFlags() */


/*!
  Handles paint events for the table view.

  Calls paintCell() for the cells that needs to be repainted.
*/

void QTableView::paintEvent( QPaintEvent *e )
{
    QRect updateR = e->rect();			// update rectangle
    if ( sbDirty ) {
	bool e = eraseInPaint;
	updateScrollBars();
	eraseInPaint = e;
    }

    QPainter paint( this );

    if ( !contentsRect().contains( updateR ) ) {// update frame ?
	paint.save();
	QRegion cr(updateR.intersect(frameRect()));
	cr -= contentsRect();
	paint.setClipRegion( cr );
	if ( inherits( "QMultiLineEdit" ) ){
#ifdef QT_KEYPAD_MODE
	    if ( !qt_modalEditingEnabled || isModalEditing() )
#endif	    
	    {
		paint.eraseRect(updateR);
	    }
	    if (!hasFocus()){
		// clear the frame and margin
		QBrush brush(colorGroup().brush(QColorGroup::Base));
#ifdef QT_KEYPAD_MODE
		if( qt_modalEditingEnabled )
		    brush = colorGroup().brush(QColorGroup::Background);
#endif
		paint.fillRect(0, 0, width(), height(), brush);
	    }
	}
	
	drawFrame( &paint );
	if ( updateR.left() < frameWidth() ) 		//###
	    updateR.setLeft( frameWidth() );
	if ( updateR.top() < frameWidth() )
	    updateR.setTop( frameWidth() );
	paint.restore();
    }

    int maxWX = maxViewX();
    int maxWY = maxViewY();

#ifdef QT_KEYPAD_MODE
    if (qt_modalEditingEnabled && isModalEditing()){
	paint.fillRect(maxWX+1+margin(), 1, width(), height(), colorGroup().brush(QColorGroup::Background)); // fill gap around scrollbars 
	paint.fillRect(lineWidth(), maxWY+1+margin(), width()-2*lineWidth(), height() - maxWY, colorGroup().brush(QColorGroup::Background));  
    }
#endif

    if ( updateR.right() > maxWX )
	updateR.setRight( maxWX );
    if ( updateR.bottom() > maxWY )
	updateR.setBottom( maxWY );

    setupPainter( &paint );			// prepare for painting table

    int firstRow = findRow( updateR.y() );
    int firstCol = findCol( updateR.x() );
    int	 xStart, yStart;
    if ( !colXPos( firstCol, &xStart ) || !rowYPos( firstRow, &yStart ) ) {
	// erase area outside cells but in view
	if ( inherits( "QMultiLineEdit" ) ) {
	    const QColorGroup g = colorGroup();
#ifdef QT_KEYPAD_MODE
	    if ( qt_modalEditingEnabled && !isModalEditing() )
		paint.fillRect( updateR, g.brush(QColorGroup::Background) );
	    else
#endif
	    paint.fillRect( updateR, g.brush(QColorGroup::Base) );
	} else {
	    paint.eraseRect( updateR );
	}
	return;
    }
    int	  maxX	= updateR.right();
    int	  maxY	= updateR.bottom();
    int	  row	= firstRow;
    int	  col;
    int	  yPos	= yStart;
    int	  xPos = maxX+1; // in case the while() is empty
    int	  nextX;
    int	  nextY;
    QRect winR = viewRect();
    QRect cellR;
    QRect cellUR;
#ifndef QT_NO_TRANSFORMATIONS
    QWMatrix matrix;
#endif

    while ( yPos <= maxY && row < nRows ) {
	nextY = yPos + (cellH ? cellH : cellHeight( row ));
	if ( testTableFlags( Tbl_cutCellsV ) && nextY > ( maxWY + 1 ) )
	    break;
	col  = firstCol;
	xPos = xStart;
	while ( xPos <= maxX && col < nCols ) {
	    nextX = xPos + (cellW ? cellW : cellWidth( col ));
	    if ( testTableFlags( Tbl_cutCellsH ) && nextX > ( maxWX + 1 ) )
		break;

	    cellR.setRect( xPos, yPos, cellW ? cellW : cellWidth(col),
				       cellH ? cellH : cellHeight(row) );
	    cellUR = cellR.intersect( updateR );
	    if ( cellUR.isValid() ) {
		cellUpdateR = cellUR;
		cellUpdateR.moveBy( -xPos, -yPos ); // cell coordinates
		if ( eraseInPaint )
		    paint.eraseRect( cellUR );

#ifndef QT_NO_TRANSFORMATIONS