--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/qt3support/widgets/q3gridview.cpp Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,367 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt3Support module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include "q3gridview.h"
+#include "qpainter.h"
+
+QT_BEGIN_NAMESPACE
+
+using namespace Qt;
+
+/*!
+ \class Q3GridView
+ \brief The Q3GridView class provides an abstract base for
+ fixed-size grids.
+
+ \compat
+
+ 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{Q3GridView::numRows} {numRows},
+ \l{Q3GridView::numCols} {numCols}, \l{Q3GridView::cellWidth}
+ {cellWidth} and \l{Q3GridView::cellHeight} {cellHeight}. Reimplement
+ the pure virtual function paintCell() to draw the contents 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 and 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).
+
+ Q3GridView is a very simple abstract class based on Q3ScrollView. 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 with different sizes, use a Q3Table instead. If you need a
+ simple list of items, use a Q3ListBox. If you need to present
+ hierachical data use a Q3ListView, and if you need random objects
+ at random positions, consider using either a Q3IconView or a
+ Q3Canvas.
+*/
+
+
+/*!
+ Constructs a grid view.
+
+ The \a parent, \a name and widget flag, \a f, arguments are passed
+ to the Q3ScrollView constructor.
+*/
+Q3GridView::Q3GridView(QWidget *parent, const char *name, Qt::WindowFlags f)
+ : Q3ScrollView(parent, name, f | WStaticContents),
+ nrows(5), ncols(5), cellw(12), cellh(12)
+{
+ viewport()->setBackgroundMode(PaletteBase);
+ setBackgroundMode(PaletteBackground, PaletteBase);
+ viewport()->setFocusProxy(this);
+}
+
+/*!
+ Destroys the grid view.
+*/
+Q3GridView::~Q3GridView()
+{
+}
+
+void Q3GridView::updateGrid()
+{
+ resizeContents(ncols * cellw, nrows * cellh);
+}
+
+/*!
+ \property Q3GridView::numRows
+ \brief The number of rows in the grid
+
+ \sa numCols
+*/
+void Q3GridView::setNumRows(int numRows)
+{
+ int oldnrows = nrows;
+ nrows = numRows;
+ dimensionChange(oldnrows, ncols);
+ updateGrid();
+}
+
+/*!
+ \property Q3GridView::numCols
+ \brief The number of columns in the grid
+
+ \sa numRows
+*/
+void Q3GridView::setNumCols(int numCols)
+{
+ int oldncols = ncols;
+ ncols = numCols;
+ dimensionChange(nrows, oldncols);
+ updateGrid();
+}
+
+/*!
+ \property Q3GridView::cellWidth
+ \brief The width of a grid column
+
+ All columns in a grid view have the same width.
+
+ \sa cellHeight
+*/
+void Q3GridView::setCellWidth(int cellWidth)
+{
+ cellw = cellWidth;
+ updateGrid();
+ updateContents();
+}
+
+/*!
+ \property Q3GridView::cellHeight
+ \brief The height of a grid row
+
+ All rows in a grid view have the same height.
+
+ \sa cellWidth
+*/
+void Q3GridView::setCellHeight(int cellHeight)
+{
+ cellh = cellHeight;
+ updateGrid();
+ updateContents();
+}
+
+/*!
+ Returns the geometry of cell (\a row, \a column) in the content
+ coordinate system.
+
+ \sa cellRect()
+*/
+QRect Q3GridView::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 Q3GridView::repaintCell(int row, int column, bool erase)
+{
+ repaintContents(cellGeometry(row, column), erase);
+}
+
+/*!
+ Updates cell (\a row, \a column).
+
+ \sa QWidget::update()
+*/
+void Q3GridView::updateCell(int row, int column)
+{
+ updateContents(cellGeometry(row, column));
+}
+
+/*!
+ Ensures cell (\a row, \a column) is visible, scrolling the grid
+ view if necessary.
+*/
+void Q3GridView::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 Q3GridView::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.subtracted(QRect(contentsToViewport(QPoint(0, 0)), gridSize()));
+
+ // And draw the rectangles (transformed as needed)
+ QVector<QRect> r = reg.rects();
+ const QBrush &brush = backgroundBrush();
+ for (int i = 0; i < (int)r.count(); ++i)
+ p->fillRect(r[ i ], brush);
+}
+
+/*!\reimp
+ */
+void Q3GridView::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 Q3GridView::drawContents(QPainter *)
+{
+}
+
+/*!
+ \fn void Q3GridView::dimensionChange(int oldNumRows, int oldNumCols)
+
+ This change handler is called whenever any of the grid's
+ dimensions change. \a oldNumRows and \a oldNumCols contain the
+ old dimensions, numRows() and numCols() contain the new
+ dimensions.
+*/
+void Q3GridView::dimensionChange(int, int) {}
+
+
+
+/*!
+ \fn int Q3GridView::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 Q3GridView::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 Q3GridView::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
+
+ \snippet doc/src/snippets/code/src_qt3support_widgets_q3gridview.cpp 0
+*/
+
+/*!
+ \fn QRect Q3GridView::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 Q3GridView::gridSize() const
+
+ Returns the size of the grid in pixels.
+*/
+
+QT_END_NAMESPACE