| -rw-r--r-- | qtcompat/qgridview.cpp | 362 |
1 files changed, 362 insertions, 0 deletions
diff --git a/qtcompat/qgridview.cpp b/qtcompat/qgridview.cpp new file mode 100644 index 0000000..bee3698 --- a/dev/null +++ b/qtcompat/qgridview.cpp @@ -0,0 +1,362 @@ +/**************************************************************************** +** $Id$ +** +** Implementation of QGridView class +** +** Created: 010523 +** +** Copyright (C) 1992-2001 Trolltech AS. All rights reserved. +** +** This file is part of the widgets module of the Qt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.QPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition +** licenses may use this file in accordance with the Qt Commercial License +** Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about Qt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for QPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + + +#include "qgridview.h" + +#ifndef QT_NO_GRIDVIEW + +#include "qpainter.h" + +/*! + \class QGridView qgridview.h + \brief The QGridView class provides an abstract base for fixed-size + grids. + + \ingroup abstractwidgets + + A grid view consists of a number of abstract cells organized in rows + and columns. The cells have a fixed size and are identified with a + row index and a column index. The top-left cell is in row 0, column + 0. The bottom-right cell is in row numRows()-1, column numCols()-1. + + You can define \l numRows, \l numCols, \l cellWidth and + \l cellHeight. Reimplement the pure virtual function paintCell() to + draw the content of a cell. + + With ensureCellVisible(), you can ensure a certain cell is + visible. With rowAt() and columnAt() you can find a cell based on + the given x- and y-coordinates. + + If you need to monitor changes to the grid's dimensions (i.e. when + numRows or numCols is changed), reimplement the dimensionChange() + change handler. + + Note: the row, column indices are always given in the order, row + (vertical offset) then column (horizontal offset). This order is the + opposite of all pixel operations, which are given in the order x + (horizontal offset), y (vertical offset). + + QGridView is a very simple abstract class based on QScrollView. It + is designed to simplify the task of drawing many cells of the same + size in a potentially scrollable canvas. If you need rows and + columns in different sizes, use a QTable instead. If you need a + simple list of items, use a QListBox. If you need to present + hierachical data use a QListView, and if you need random objects at + random positions, consider using either a QIconView or a QCanvas. + +*/ + + +/*! + Constructs a grid view. + + The \a parent, \a name and widget flag, \a f, arguments are passed to the + QScrollView constructor. +*/ +QGridView::QGridView( QWidget *parent, const char *name, WFlags f ) + :QScrollView( parent, name ,f ),nrows(5),ncols(5),cellw(12),cellh(12) +{ + viewport()->setBackgroundMode( PaletteBase ); + setBackgroundMode( PaletteBackground ); + viewport()->setFocusProxy( this ); +} + +/*! + Destroys the grid view. +*/ +QGridView::~QGridView() +{ +} + +void QGridView::updateGrid() +{ + resizeContents( ncols * cellw, nrows * cellh ); +} + +/*! \property QGridView::numRows + \brief The number of rows in the grid + + \sa numCols +*/ +void QGridView::setNumRows( int numRows ) +{ + int oldnrows = nrows; + nrows = numRows; + dimensionChange( oldnrows, ncols ); + updateGrid(); +} + +/*! \property QGridView::numCols + \brief The number of columns in the grid + + \sa numRows +*/ +void QGridView::setNumCols( int numCols ) +{ + int oldncols = ncols; + ncols = numCols; + dimensionChange( nrows, oldncols ); + updateGrid(); +} + +/*! \property QGridView::cellWidth + \brief The width of a grid column + + All columns in a grid view have the same width. + + \sa cellHeight +*/ +void QGridView::setCellWidth( int cellWidth ) +{ + cellw = cellWidth; + updateGrid(); + updateContents( contentsX(), contentsY(), visibleWidth(), visibleHeight() ); +} + +/*! \property QGridView::cellHeight + \brief The height of a grid row + + All rows in a grid view have the same height. + + \sa cellWidth +*/ +void QGridView::setCellHeight( int cellHeight ) +{ + cellh = cellHeight; + updateGrid(); + updateContents( contentsX(), contentsY(), visibleWidth(), visibleHeight() ); +} + +/*! + Returns the geometry of cell (\a row, \a column) in the content + coordinate system. + + \sa cellRect() + */ +QRect QGridView::cellGeometry( int row, int column ) +{ + QRect r; + if ( row >= 0 && row < nrows && column >= 0 && column < ncols ) + r.setRect( cellw * column, cellh * row, cellw, cellh ); + return r; +} + +/*! Repaints cell (\a row, \a column). + + If \a erase is TRUE, Qt erases the area of the cell before the + paintCell() call; otherwise no erasing takes place. + + \sa QWidget::repaint() + */ +void QGridView::repaintCell( int row, int column, bool erase ) +{ + QScrollView::repaintContents( cellGeometry( row, column ), erase ); +} + +/*! Updates cell (\a row, \a column). + + \sa QWidget::update() + */ +void QGridView::updateCell( int row, int column ) +{ + updateContents( cellGeometry( row, column ) ); +} + +/*! + Ensure cell (\a row, \a column) is visible, scrolling the grid view + if necessary. + */ +void QGridView::ensureCellVisible( int row, int column ) +{ + QRect r = cellGeometry( row, column ); + ensureVisible( r.x(), r.y(), r.width(), r.height() ); +} + +/*! This function fills the \a cw pixels wide and \a ch pixels high + rectangle starting at position (\a cx, \a cy) with the + background color using the painter \a p. + + paintEmptyArea() is invoked by drawContents() to erase + or fill unused areas. +*/ + +void QGridView::paintEmptyArea( QPainter *p, int cx ,int cy, int cw, int ch) +{ + if ( gridSize().width() >= contentsWidth() && gridSize().height() >= contentsHeight() ) + return; + // Region of the rect we should draw + contentsToViewport( cx, cy, cx, cy ); + QRegion reg( QRect( cx, cy, cw, ch ) ); + // Subtract the table from it + reg = reg.subtract( QRect( contentsToViewport( QPoint( 0, 0 ) ), gridSize() ) ); + + // And draw the rectangles (transformed as needed) + QArray<QRect> r = reg.rects(); + QBrush brush = colorGroup().brush( QColorGroup::Background ); + for ( int i = 0; i < (int)r.count(); ++i) + p->fillRect( r[ i ], brush ); +} + +/*!\reimp + */ +void QGridView::drawContents( QPainter *p, int cx, int cy, int cw, int ch ) +{ + int colfirst = columnAt( cx ); + int collast = columnAt( cx + cw ); + int rowfirst = rowAt( cy ); + int rowlast = rowAt( cy + ch ); + + if ( rowfirst == -1 || colfirst == -1 ) { + paintEmptyArea( p, cx, cy, cw, ch ); + return; + } + + if ( collast < 0 || collast >= ncols ) + collast = ncols-1; + if ( rowlast < 0 || rowlast >= nrows ) + rowlast = nrows-1; + + // Go through the rows + for ( int r = rowfirst; r <= rowlast; ++r ) { + // get row position and height + int rowp = r * cellh; + + // Go through the columns in the row r + // if we know from where to where, go through [colfirst, collast], + // else go through all of them + for ( int c = colfirst; c <= collast; ++c ) { + // get position and width of column c + int colp = c * cellw; + // Translate painter and draw the cell + p->translate( colp, rowp ); + paintCell( p, r, c ); + p->translate( -colp, -rowp ); + } + } + + // Paint empty rects + paintEmptyArea( p, cx, cy, cw, ch ); +} + +/*! + \reimp + + (Implemented to get rid of a compiler warning.) +*/ +void QGridView::drawContents( QPainter * ) +{ +} + +/*! \fn void QGridView::dimensionChange( int oldNumRows, int oldNumCols ) + + This change handler is called whenever any of the grid's dimensions + changes. \a oldNumRows and \a oldNumCols contain the old dimensions, + numRows() and numCols() contain the new dimensions. + */ +void QGridView::dimensionChange( int, int ) {} + + + +/*! \fn int QGridView::rowAt( int y ) const + + Returns the number of the row at position \a y. \a y must be given in + content coordinates. + + \sa columnAt() + */ + +/*! \fn int QGridView::columnAt( int x ) const + + Returns the number of the column at position \a x. \a x must be + given in content coordinates. + + \sa rowAt() + */ + +/*! + \fn void QGridView::paintCell( QPainter *p, int row, int col ) + + This pure virtual function is called to paint the single cell at + (\a row, \a col) using painter \a p. The painter must be open when + paintCell() is called and must remain open. + + The coordinate system is \link QPainter::translate() translated \endlink + so 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). + + The painter is not clipped by default in order to get maximum + efficiency. If you want clipping, use + + \code + p->setClipRect( cellRect(), QPainter::CoordPainter ); + //... your drawing code + p->setClipping( FALSE ); + + \endcode + +*/ + +/*! \fn QRect QGridView::cellRect() const + + Returns the geometry of a cell in a cell's coordinate system. This + is a convenience function useful in paintCell(). It is equivalent to + QRect( 0, 0, cellWidth(), cellHeight() ). + + \sa cellGeometry() + + */ + +/*!\fn QSize QGridView::gridSize() const + + Returns the size of the grid in pixels. + + */ + +/*! + \overload + Repaints the contents. If \a erase is TRUE the + background is cleared using the background color. +*/ +void QGridView::repaintContents( bool erase ) +{ + QScrollView::repaintContents( contentsX(), contentsY(), visibleWidth(), visibleHeight(), erase ); +} + +#endif // QT_NO_GRIDVIEW |