Initial revision

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