/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the QtGui 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 "qtableview.h"
#ifndef QT_NO_TABLEVIEW
#include <qheaderview.h>
#include <qitemdelegate.h>
#include <qapplication.h>
#include <qpainter.h>
#include <qstyle.h>
#include <qsize.h>
#include <qevent.h>
#include <qbitarray.h>
#include <qscrollbar.h>
#include <qabstractbutton.h>
#include <private/qtableview_p.h>
#ifndef QT_NO_ACCESSIBILITY
#include <qaccessible.h>
#endif
QT_BEGIN_NAMESPACE
/** \internal
Add a span to the collection. the collection takes the ownership.
*/
void QSpanCollection::addSpan(QSpanCollection::Span *span)
{
spans.append(span);
Index::iterator it_y = index.lowerBound(-span->top());
if (it_y == index.end() || it_y.key() != -span->top()) {
//there is no spans that starts with the row in the index, so create a sublist for it.
SubIndex sub_index;
if (it_y != index.end()) {
//the previouslist is the list of spans that sarts _before_ the row of the span.
// and which may intersect this row.
const SubIndex previousList = it_y.value();
foreach(Span *s, previousList) {
//If a subspans intersect the row, we need to split it into subspans
if(s->bottom() >= span->top())
sub_index.insert(-s->left(), s);
}
}
it_y = index.insert(-span->top(), sub_index);
//we will insert span to *it_y in the later loop
}
//insert the span as supspan in all the lists that intesects the span
while(-it_y.key() <= span->bottom()) {
(*it_y).insert(-span->left(), span);
if(it_y == index.begin())
break;
--it_y;
}
}
/** \internal
* Has to be called after the height and width of a span is changed.
*
* old_height is the height before the change
*
* if the size of the span is now 0x0 the span will be deleted.
*/
void QSpanCollection::updateSpan(QSpanCollection::Span *span, int old_height)
{
if (old_height < span->height()) {
//add the span as subspan in all the lists that intersect the new covered columns
Index::iterator it_y = index.lowerBound(-(span->top() + old_height - 1));
Q_ASSERT(it_y != index.end()); //it_y must exist since the span is in the list
while (-it_y.key() <= span->bottom()) {
(*it_y).insert(-span->left(), span);
if(it_y == index.begin())
break;
--it_y;
}
} else if (old_height > span->height()) {
//remove the span from all the subspans lists that intersect the columns not covered anymore
Index::iterator it_y = index.lowerBound(-span->bottom());
if (it_y == index.end())
it_y = index.find(-span->top()); // This is the only span remaining and we are deleting it.
Q_ASSERT(it_y != index.end()); //it_y must exist since the span is in the list
while (-it_y.key() <= span->top() + old_height -1) {
if (-it_y.key() > span->bottom()) {
(*it_y).remove(-span->left());
if (it_y->isEmpty()) {
it_y = index.erase(it_y) - 1;
}
}
if(it_y == index.begin())
break;
--it_y;
}
}
if (span->width() == 0 && span->height() == 0) {
spans.removeOne(span);
delete span;
}
}
/** \internal
* \return a spans that spans over cell x,y (column,row) or 0 if there is none.
*/
QSpanCollection::Span *QSpanCollection::spanAt(int x, int y) const
{
Index::const_iterator it_y = index.lowerBound(-y);
if (it_y == index.end())
return 0;
SubIndex::const_iterator it_x = (*it_y).lowerBound(-x);
if (it_x == (*it_y).end())
return 0;
Span *span = *it_x;
if (span->right() >= x && span->bottom() >= y)
return span;
return 0;
}
/** \internal
* remove and deletes all spans inside the collection
*/
void QSpanCollection::clear()
{
qDeleteAll(spans);
index.clear();
spans.clear();
}
/** \internal
* return a list to all the spans that spans over cells in the given rectangle
*/
QList<QSpanCollection::Span *> QSpanCollection::spansInRect(int x, int y, int w, int h) const
{
QSet<Span *> list;
Index::const_iterator it_y = index.lowerBound(-y);
if(it_y == index.end())
--it_y;
while(-it_y.key() <= y + h) {
SubIndex::const_iterator it_x = (*it_y).lowerBound(-x);
if (it_x == (*it_y).end())
--it_x;
while(-it_x.key() <= x + w) {
Span *s = *it_x;
if (s->bottom() >= y && s->right() >= x)
list << s;
if (it_x == (*it_y).begin())
break;
--it_x;
}
if(it_y == index.begin())
break;
--it_y;
}
return list.toList();
}
#undef DEBUG_SPAN_UPDATE
#ifdef DEBUG_SPAN_UPDATE
QDebug operator<<(QDebug str, const QSpanCollection::Span &span)
{
str << "(" << span.top() << "," << span.left() << "," << span.bottom() << "," << span.right() << ")";
return str;
}
#endif
/** \internal
* Updates the span collection after row insertion.
*/
void QSpanCollection::updateInsertedRows(int start, int end)
{
#ifdef DEBUG_SPAN_UPDATE
qDebug() << Q_FUNC_INFO;
qDebug() << start << end;
qDebug() << index;
#endif
if (spans.isEmpty())
return;
int delta = end - start + 1;
#ifdef DEBUG_SPAN_UPDATE
qDebug("Before");
#endif
for (SpanList::iterator it = spans.begin(); it != spans.end(); ++it) {
Span *span = *it;
#ifdef DEBUG_SPAN_UPDATE
qDebug() << span << *span;
#endif
if (span->m_bottom < start)
continue;
if (span->m_top >= start)
span->m_top += delta;
span->m_bottom += delta;
}
#ifdef DEBUG_SPAN_UPDATE
qDebug("After");
foreach (QSpanCollection::Span *span, spans)
qDebug() << span << *span;
#endif
for (Index::iterator it_y = index.begin(); it_y != index.end(); ) {
int y = -it_y.key();
if (y < start) {
++it_y;
continue;
}
index.insert(-y - delta, it_y.value());
it_y = index.erase(it_y);
}
#ifdef DEBUG_SPAN_UPDATE
qDebug() << index;
#endif
}
/** \internal
* Updates the span collection after column insertion.
*/
void QSpanCollection::updateInsertedColumns(int start, int end)
{
#ifdef DEBUG_SPAN_UPDATE
qDebug() << Q_FUNC_INFO;
qDebug() << start << end;
qDebug() << index;
#endif
if (spans.isEmpty())
return;
int delta = end - start + 1;
#ifdef DEBUG_SPAN_UPDATE
qDebug("Before");
#endif
for (SpanList::iterator it = spans.begin(); it != spans.end(); ++it) {
Span *span = *it;
#ifdef DEBUG_SPAN_UPDATE
qDebug() << span << *span;
#endif
if (span->m_right < start)
continue;
if (span->m_left >= start)
span->m_left += delta;
span->m_right += delta;
}
#ifdef DEBUG_SPAN_UPDATE
qDebug("After");
foreach (QSpanCollection::Span *span, spans)
qDebug() << span << *span;
#endif
for (Index::iterator it_y = index.begin(); it_y != index.end(); ++it_y) {
SubIndex &subindex = it_y.value();
for (SubIndex::iterator it = subindex.begin(); it != subindex.end(); ) {
int x = -it.key();
if (x < start) {
++it;
continue;
}
subindex.insert(-x - delta, it.value());
it = subindex.erase(it);
}
}
#ifdef DEBUG_SPAN_UPDATE
qDebug() << index;
#endif
}
/** \internal
* Cleans a subindex from to be deleted spans. The update argument is used
* to move the spans inside the subindex, in case their anchor changed.
* \return true if no span in this subindex starts at y, and should thus be deleted.
*/
bool QSpanCollection::cleanSpanSubIndex(QSpanCollection::SubIndex &subindex, int y, bool update)
{
if (subindex.isEmpty())
return true;
bool should_be_deleted = true;
SubIndex::iterator it = subindex.end();
do {
--it;
int x = -it.key();
Span *span = it.value();
if (span->will_be_deleted) {
it = subindex.erase(it);
continue;
}
if (update && span->m_left != x) {
subindex.insert(-span->m_left, span);
it = subindex.erase(it);
}
if (should_be_deleted && span->m_top == y)
should_be_deleted = false;
} while (it != subindex.begin());
return should_be_deleted;
}
/** \internal
* Updates the span collection after row removal.
*/
void QSpanCollection::updateRemovedRows(int start, int end)
{
#ifdef DEBUG_SPAN_UPDATE
qDebug() << Q_FUNC_INFO;
qDebug() << start << end;
qDebug() << index;
#endif
if (spans.isEmpty())
return;
SpanList spansToBeDeleted;
int delta = end - start + 1;
#ifdef DEBUG_SPAN_UPDATE
qDebug("Before");
#endif
for (SpanList::iterator it = spans.begin(); it != spans.end(); ) {
Span *span = *it;
#ifdef DEBUG_SPAN_UPDATE
qDebug() << span << *span;
#endif
if (span->m_bottom < start) {
++it;
continue;
}
if (span->m_top < start) {
if (span->m_bottom <= end)
span->m_bottom = start - 1;
else
span->m_bottom -= delta;
} else {
if (span->m_bottom > end) {
if (span->m_top <= end)
span->m_top = start;
else
span->m_top -= delta;
span->m_bottom -= delta;
} else {
span->will_be_deleted = true;
}
}
if (span->m_top == span->m_bottom && span->m_left == span->m_right)
span->will_be_deleted = true;
if (span->will_be_deleted) {
spansToBeDeleted.append(span);
it = spans.erase(it);
} else {
++it;
}
}
#ifdef DEBUG_SPAN_UPDATE
qDebug("After");
foreach (QSpanCollection::Span *span, spans)
qDebug() << span << *span;
#endif
if (spans.isEmpty()) {
qDeleteAll(spansToBeDeleted);
index.clear();
return;
}
Index::iterator it_y = index.end();
do {
--it_y;
int y = -it_y.key();
SubIndex &subindex = it_y.value();
if (y < start) {
if (cleanSpanSubIndex(subindex, y))
it_y = index.erase(it_y);
} else if (y >= start && y <= end) {
bool span_at_start = false;
SubIndex spansToBeMoved;
for (SubIndex::iterator it = subindex.begin(); it != subindex.end(); ++it) {
Span *span = it.value();
if (span->will_be_deleted)
continue;
if (!span_at_start && span->m_top == start)
span_at_start = true;
spansToBeMoved.insert(it.key(), span);
}
if (y == start && span_at_start)
subindex.clear();
else
it_y = index.erase(it_y);
if (span_at_start) {
Index::iterator it_start;
if (y == start)
it_start = it_y;
else {
it_start = index.find(-start);
if (it_start == index.end())
it_start = index.insert(-start, SubIndex());
}
SubIndex &start_subindex = it_start.value();
for (SubIndex::iterator it = spansToBeMoved.begin(); it != spansToBeMoved.end(); ++it)
start_subindex.insert(it.key(), it.value());
}
} else {
if (y == end + 1) {
Index::iterator it_top = index.find(-y + delta);
if (it_top == index.end())
it_top = index.insert(-y + delta, SubIndex());
for (SubIndex::iterator it = subindex.begin(); it != subindex.end(); ) {
Span *span = it.value();
if (!span->will_be_deleted)
it_top.value().insert(it.key(), span);
++it;
}
} else {
index.insert(-y + delta, subindex);
}
it_y = index.erase(it_y);
}
} while (it_y != index.begin());
#ifdef DEBUG_SPAN_UPDATE
qDebug() << index;
qDebug("Deleted");
foreach (QSpanCollection::Span *span, spansToBeDeleted)
qDebug() << span << *span;
#endif
qDeleteAll(spansToBeDeleted);
}
/** \internal
* Updates the span collection after column removal.
*/
void QSpanCollection::updateRemovedColumns(int start, int end)
{
#ifdef DEBUG_SPAN_UPDATE
qDebug() << Q_FUNC_INFO;
qDebug() << start << end;
qDebug() << index;
#endif
if (spans.isEmpty())
return;
SpanList toBeDeleted;
int delta = end - start + 1;
#ifdef DEBUG_SPAN_UPDATE
qDebug("Before");
#endif
for (SpanList::iterator it = spans.begin(); it != spans.end(); ) {
Span *span = *it;
#ifdef DEBUG_SPAN_UPDATE
qDebug() << span << *span;
#endif
if (span->m_right < start) {
++it;
continue;
}
if (span->m_left < start) {
if (span->m_right <= end)
span->m_right = start - 1;
else
span->m_right -= delta;
} else {
if (span->m_right > end) {
if (span->m_left <= end)
span->m_left = start;
else
span->m_left -= delta;
span->m_right -= delta;
} else {
span->will_be_deleted = true;
}
}
if (span->m_top == span->m_bottom && span->m_left == span->m_right)
span->will_be_deleted = true;
if (span->will_be_deleted) {
toBeDeleted.append(span);
it = spans.erase(it);
} else {
++it;
}
}
#ifdef DEBUG_SPAN_UPDATE
qDebug("After");
foreach (QSpanCollection::Span *span, spans)
qDebug() << span << *span;
#endif
if (spans.isEmpty()) {
qDeleteAll(toBeDeleted);
index.clear();
return;
}
for (Index::iterator it_y = index.begin(); it_y != index.end(); ) {
int y = -it_y.key();
if (cleanSpanSubIndex(it_y.value(), y, true))
it_y = index.erase(it_y);
else
++it_y;
}
#ifdef DEBUG_SPAN_UPDATE
qDebug() << index;
qDebug("Deleted");
foreach (QSpanCollection::Span *span, toBeDeleted)
qDebug() << span << *span;
#endif
qDeleteAll(toBeDeleted);
}
#ifdef QT_BUILD_INTERNAL
/*!
\internal
Checks whether the span index structure is self-consistent, and consistent with the spans list.
*/
bool QSpanCollection::checkConsistency() const
{
for (Index::const_iterator it_y = index.begin(); it_y != index.end(); ++it_y) {
int y = -it_y.key();
const SubIndex &subIndex = it_y.value();
for (SubIndex::const_iterator it = subIndex.begin(); it != subIndex.end(); ++it) {
int x = -it.key();
Span *span = it.value();
if (!spans.contains(span) || span->left() != x
|| y < span->top() || y > span->bottom())
return false;
}
}
foreach (const Span *span, spans) {
if (span->width() < 1 || span->height() < 1
|| (span->width() == 1 && span->height() == 1))
return false;
for (int y = span->top(); y <= span->bottom(); ++y) {
Index::const_iterator it_y = index.find(-y);
if (it_y == index.end()) {
if (y == span->top())
return false;
else
continue;
}
const SubIndex &subIndex = it_y.value();
SubIndex::const_iterator it = subIndex.find(-span->left());
if (it == subIndex.end() || it.value() != span)
return false;
}
}
return true;
}
#endif
class QTableCornerButton : public QAbstractButton
{
Q_OBJECT
public:
QTableCornerButton(QWidget *parent) : QAbstractButton(parent) {}
void paintEvent(QPaintEvent*) {
QStyleOptionHeader opt;
opt.init(this);
QStyle::State state = QStyle::State_None;
if (isEnabled())
state |= QStyle::State_Enabled;
if (isActiveWindow())
state |= QStyle::State_Active;
if (isDown())
state |= QStyle::State_Sunken;
opt.state = state;
opt.rect = rect();
opt.position = QStyleOptionHeader::OnlyOneSection;
QPainter painter(this);
style()->drawControl(QStyle::CE_Header, &opt, &painter, this);
}
};
void QTableViewPrivate::init()
{
Q_Q(QTableView);
q->setEditTriggers(editTriggers|QAbstractItemView::AnyKeyPressed);
QHeaderView *vertical = new QHeaderView(Qt::Vertical, q);
vertical->setClickable(true);
vertical->setHighlightSections(true);
q->setVerticalHeader(vertical);
QHeaderView *horizontal = new QHeaderView(Qt::Horizontal, q);
horizontal->setClickable(true);
horizontal->setHighlightSections(true);
q->setHorizontalHeader(horizontal);
tabKeyNavigation = true;
cornerWidget = new QTableCornerButton(q);
cornerWidget->setFocusPolicy(Qt::NoFocus);
QObject::connect(cornerWidget, SIGNAL(clicked()), q, SLOT(selectAll()));
}
/*!
\internal
Trims away indices that are hidden in the treeview due to hidden horizontal or vertical sections.
*/
void QTableViewPrivate::trimHiddenSelections(QItemSelectionRange *range) const
{
Q_ASSERT(range && range->isValid());
int top = range->top();
int left = range->left();
int bottom = range->bottom();
int right = range->right();
while (bottom >= top && verticalHeader->isSectionHidden(bottom))
--bottom;
while (right >= left && horizontalHeader->isSectionHidden(right))
--right;
if (top > bottom || left > right) { // everything is hidden
*range = QItemSelectionRange();
return;
}
while (verticalHeader->isSectionHidden(top) && top <= bottom)
++top;
while (horizontalHeader->isSectionHidden(left) && left <= right)
++left;
if (top > bottom || left > right) { // everything is hidden
*range = QItemSelectionRange();
return;
}
QModelIndex bottomRight = model->index(bottom, right, range->parent());
QModelIndex topLeft = model->index(top, left, range->parent());
*range = QItemSelectionRange(topLeft, bottomRight);
}
/*!
\internal
Sets the span for the cell at (\a row, \a column).
*/
void QTableViewPrivate::setSpan(int row, int column, int rowSpan, int columnSpan)
{
if (row < 0 || column < 0 || rowSpan <= 0 || columnSpan <= 0) {
qWarning() << "QTableView::setSpan: invalid span given: (" << row << ',' << column << ',' << rowSpan << ',' << columnSpan << ')';
return;
}
QSpanCollection::Span *sp = spans.spanAt(column, row);
if (sp) {
if (sp->top() != row || sp->left() != column) {
qWarning() << "QTableView::setSpan: span cannot overlap";
return;
}
if (rowSpan == 1 && columnSpan == 1) {
rowSpan = columnSpan = 0;
}
const int old_height = sp->height();
sp->m_bottom = row + rowSpan - 1;
sp->m_right = column + columnSpan - 1;
spans.updateSpan(sp, old_height);
return;
} else if (rowSpan == 1 && columnSpan == 1) {
qWarning() << "QTableView::setSpan: single cell span won't be added";
return;
}
sp = new QSpanCollection::Span(row, column, rowSpan, columnSpan);
spans.addSpan(sp);
}
/*!
\internal
Gets the span information for the cell at (\a row, \a column).
*/
QSpanCollection::Span QTableViewPrivate::span(int row, int column) const
{
QSpanCollection::Span *sp = spans.spanAt(column, row);
if (sp)
return *sp;
return QSpanCollection::Span(row, column, 1, 1);
}
/*!
\internal
Returns the logical index of the last section that's part of the span.
*/
int QTableViewPrivate::sectionSpanEndLogical(const QHeaderView *header, int logical, int span) const
{
int visual = header->visualIndex(logical);
for (int i = 1; i < span; ) {
if (++visual >= header->count())
break;
logical = header->logicalIndex(visual);
++i;
}
return logical;
}
/*!
\internal
Returns the size of the span starting at logical index \a logical
and spanning \a span sections.
*/
int QTableViewPrivate::sectionSpanSize(const QHeaderView *header, int logical, int span) const
{
int endLogical = sectionSpanEndLogical(header, logical, span);
return header->sectionPosition(endLogical)
- header->sectionPosition(logical)
+ header->sectionSize(endLogical);
}
/*!
\internal
Returns true if the section at logical index \a logical is part of the span
starting at logical index \a spanLogical and spanning \a span sections;
otherwise, returns false.
*/
bool QTableViewPrivate::spanContainsSection(const QHeaderView *header, int logical, int spanLogical, int span) const
{
if (logical == spanLogical)
return true; // it's the start of the span
int visual = header->visualIndex(spanLogical);
for (int i = 1; i < span; ) {
if (++visual >= header->count())
break;
spanLogical = header->logicalIndex(visual);
if (logical == spanLogical)
return true;
++i;
}
return false;
}
/*!
\internal
Returns the visual rect for the given \a span.
*/
QRect QTableViewPrivate::visualSpanRect(const QSpanCollection::Span &span) const
{
Q_Q(const QTableView);
// vertical
int row = span.top();
int rowp = verticalHeader->sectionViewportPosition(row);
int rowh = rowSpanHeight(row, span.height());
// horizontal
int column = span.left();
int colw = columnSpanWidth(column, span.width());
if (q->isRightToLeft())
column = span.right();
int colp = horizontalHeader->sectionViewportPosition(column);
const int i = showGrid ? 1 : 0;
if (q->isRightToLeft())
return QRect(colp + i, rowp, colw - i, rowh - i);
return QRect(colp, rowp, colw - i, rowh - i);
}
/*!
\internal
Draws the spanning cells within rect \a area, and clips them off as
preparation for the main drawing loop.
\a drawn is a QBitArray of visualRowCountxvisualCoulumnCount which say if particular cell has been drawn
*/
void QTableViewPrivate::drawAndClipSpans(const QRegion &area, QPainter *painter,
const QStyleOptionViewItemV4 &option, QBitArray *drawn,
int firstVisualRow, int lastVisualRow, int firstVisualColumn, int lastVisualColumn)
{
bool alternateBase = false;
QRegion region = viewport->rect();
QList<QSpanCollection::Span *> visibleSpans;
bool sectionMoved = verticalHeader->sectionsMoved() || horizontalHeader->sectionsMoved();
if (!sectionMoved) {
visibleSpans = spans.spansInRect(logicalColumn(firstVisualColumn), logicalRow(firstVisualRow),
lastVisualColumn - firstVisualColumn + 1, lastVisualRow - firstVisualRow + 1);
} else {
QSet<QSpanCollection::Span *> set;
for(int x = firstVisualColumn; x <= lastVisualColumn; x++)
for(int y = firstVisualRow; y <= lastVisualRow; y++)
set.insert(spans.spanAt(x,y));
set.remove(0);
visibleSpans = set.toList();
}
foreach (QSpanCollection::Span *span, visibleSpans) {
int row = span->top();
int col = span->left();
QModelIndex index = model->index(row, col, root);
if (!index.isValid())
continue;
QRect rect = visualSpanRect(*span);
rect.translate(scrollDelayOffset);
if (!area.intersects(rect))
continue;
QStyleOptionViewItemV4 opt = option;
opt.rect = rect;
alternateBase = alternatingColors && (span->top() & 1);
if (alternateBase)
opt.features |= QStyleOptionViewItemV2::Alternate;
else
opt.features &= ~QStyleOptionViewItemV2::Alternate;
drawCell(painter, opt, index);
region -= rect;
for (int r = span->top(); r <= span->bottom(); ++r) {
const int vr = visualRow(r);
if (vr < firstVisualRow || vr > lastVisualRow)
continue;
for (int c = span->left(); c <= span->right(); ++c) {
const int vc = visualColumn(c);
if (vc < firstVisualColumn || vc > lastVisualColumn)
continue;
drawn->setBit((vr - firstVisualRow) * (lastVisualColumn - firstVisualColumn + 1)
+ vc - firstVisualColumn);
}
}
}
painter->setClipRegion(region);
}
/*!
\internal
Updates spans after row insertion.
*/
void QTableViewPrivate::_q_updateSpanInsertedRows(const QModelIndex &parent, int start, int end)
{
Q_UNUSED(parent)
spans.updateInsertedRows(start, end);
}
/*!
\internal
Updates spans after column insertion.
*/
void QTableViewPrivate::_q_updateSpanInsertedColumns(const QModelIndex &parent, int start, int end)
{
Q_UNUSED(parent)
spans.updateInsertedColumns(start, end);
}
/*!
\internal
Updates spans after row removal.
*/
void QTableViewPrivate::_q_updateSpanRemovedRows(const QModelIndex &parent, int start, int end)
{
Q_UNUSED(parent)
spans.updateRemovedRows(start, end);
}
/*!
\internal
Updates spans after column removal.
*/
void QTableViewPrivate::_q_updateSpanRemovedColumns(const QModelIndex &parent, int start, int end)
{
Q_UNUSED(parent)
spans.updateRemovedColumns(start, end);
}
/*!
\internal
Draws a table cell.
*/
void QTableViewPrivate::drawCell(QPainter *painter, const QStyleOptionViewItemV4 &option, const QModelIndex &index)
{
Q_Q(QTableView);
QStyleOptionViewItemV4 opt = option;
if (selectionModel && selectionModel->isSelected(index))
opt.state |= QStyle::State_Selected;
if (index == hover)
opt.state |= QStyle::State_MouseOver;
if (option.state & QStyle::State_Enabled) {
QPalette::ColorGroup cg;
if ((model->flags(index) & Qt::ItemIsEnabled) == 0) {
opt.state &= ~QStyle::State_Enabled;
cg = QPalette::Disabled;
} else {
cg = QPalette::Normal;
}
opt.palette.setCurrentColorGroup(cg);
}
if (index == q->currentIndex()) {
const bool focus = (q->hasFocus() || viewport->hasFocus()) && q->currentIndex().isValid();
if (focus)
opt.state |= QStyle::State_HasFocus;
}
q->style()->drawPrimitive(QStyle::PE_PanelItemViewRow, &opt, painter, q);
if (const QWidget *widget = editorForIndex(index).editor) {
painter->save();
painter->setClipRect(widget->geometry());
q->itemDelegate(index)->paint(painter, opt, index);
painter->restore();
} else {
q->itemDelegate(index)->paint(painter, opt, index);
}
}
/*!
\class QTableView
\brief The QTableView class provides a default model/view
implementation of a table view.
\ingroup model-view
\ingroup advanced
A QTableView implements a table view that displays items from a
model. This class is used to provide standard tables that were
previously provided by the QTable class, but using the more
flexible approach provided by Qt's model/view architecture.
The QTableView class is one of the \l{Model/View Classes}
and is part of Qt's \l{Model/View Programming}{model/view framework}.
QTableView implements the interfaces defined by the
QAbstractItemView class to allow it to display data provided by
models derived from the QAbstractItemModel class.
\section1 Navigation
You can navigate the cells in the table by clicking on a cell with the
mouse, or by using the arrow keys. Because QTableView enables
\l{QAbstractItemView::tabKeyNavigation}{tabKeyNavigation} by default, you
can also hit Tab and Backtab to move from cell to cell.
\section1 Visual Appearance
The table has a vertical header that can be obtained using the
verticalHeader() function, and a horizontal header that is available
through the horizontalHeader() function. The height of each row in the
table can be found by using rowHeight(); similarly, the width of
columns can be found using columnWidth(). Since both of these are plain
widgets, you can hide either of them using their hide() functions.
Rows and columns can be hidden and shown with hideRow(), hideColumn(),
showRow(), and showColumn(). They can be selected with selectRow()
and selectColumn(). The table will show a grid depending on the
\l showGrid property.
The items shown in a table view, like those in the other item views, are
rendered and edited using standard \l{QItemDelegate}{delegates}. However,
for some tasks it is sometimes useful to be able to insert widgets in a
table instead. Widgets are set for particular indexes with the
\l{QAbstractItemView::}{setIndexWidget()} function, and
later retrieved with \l{QAbstractItemView::}{indexWidget()}.
\table
\row \o \inlineimage qtableview-resized.png
\o By default, the cells in a table do not expand to fill the available space.
You can make the cells fill the available space by stretching the last
header section. Access the relevant header using horizontalHeader()
or verticalHeader() and set the header's \l{QHeaderView::}{stretchLastSection}
property.
To distribute the available space according to the space requirement of
each column or row, call the view's resizeColumnsToContents() or
resizeRowsToContents() functions.
\endtable
\section1 Coordinate Systems
For some specialized forms of tables it is useful to be able to
convert between row and column indexes and widget coordinates.
The rowAt() function provides the y-coordinate within the view of the
specified row; the row index can be used to obtain a corresponding
y-coordinate with rowViewportPosition(). The columnAt() and
columnViewportPosition() functions provide the equivalent conversion
operations between x-coordinates and column indexes.
\section1 Styles
QTableView is styled appropriately for each platform. The following images show
how it looks on three different platforms. Go to the \l{Qt Widget Gallery} to see
its appearance in other styles.
\table 100%
\row \o \inlineimage windowsxp-tableview.png Screenshot of a Windows XP style table view
\o \inlineimage macintosh-tableview.png Screenshot of a Macintosh style table view
\o \inlineimage plastique-tableview.png Screenshot of a Plastique style table view
\row \o A \l{Windows XP Style Widget Gallery}{Windows XP style} table view.
\o A \l{Macintosh Style Widget Gallery}{Macintosh style} table view.
\o A \l{Plastique Style Widget Gallery}{Plastique style} table view.
\endtable
\sa QTableWidget, {View Classes}, QAbstractItemModel, QAbstractItemView,
{Chart Example}, {Pixelator Example}, {Table Model Example}
*/
/*!
Constructs a table view with a \a parent to represent the data.
\sa QAbstractItemModel
*/
QTableView::QTableView(QWidget *parent)
: QAbstractItemView(*new QTableViewPrivate, parent)
{
Q_D(QTableView);
d->init();
}
/*!
\internal
*/
QTableView::QTableView(QTableViewPrivate &dd, QWidget *parent)
: QAbstractItemView(dd, parent)
{
Q_D(QTableView);
d->init();
}
/*!
Destroys the table view.
*/
QTableView::~QTableView()
{
}
/*!
\reimp
*/
void QTableView::setModel(QAbstractItemModel *model)
{
Q_D(QTableView);
if (model == d->model)
return;
//let's disconnect from the old model
if (d->model && d->model != QAbstractItemModelPrivate::staticEmptyModel()) {
disconnect(d->model, SIGNAL(rowsInserted(QModelIndex,int,int)),
this, SLOT(_q_updateSpanInsertedRows(QModelIndex,int,int)));
disconnect(d->model, SIGNAL(columnsInserted(QModelIndex,int,int)),
this, SLOT(_q_updateSpanInsertedColumns(QModelIndex,int,int)));
disconnect(d->model, SIGNAL(rowsRemoved(QModelIndex,int,int)),
this, SLOT(_q_updateSpanRemovedRows(QModelIndex,int,int)));
disconnect(d->model, SIGNAL(columnsRemoved(QModelIndex,int,int)),
this, SLOT(_q_updateSpanRemovedColumns(QModelIndex,int,int)));
}
if (model) { //and connect to the new one
connect(model, SIGNAL(rowsInserted(QModelIndex,int,int)),
this, SLOT(_q_updateSpanInsertedRows(QModelIndex,int,int)));
connect(model, SIGNAL(columnsInserted(QModelIndex,int,int)),
this, SLOT(_q_updateSpanInsertedColumns(QModelIndex,int,int)));
connect(model, SIGNAL(rowsRemoved(QModelIndex,int,int)),
this, SLOT(_q_updateSpanRemovedRows(QModelIndex,int,int)));
connect(model, SIGNAL(columnsRemoved(QModelIndex,int,int)),
this, SLOT(_q_updateSpanRemovedColumns(QModelIndex,int,int)));
}
d->verticalHeader->setModel(model);
d->horizontalHeader->setModel(model);
QAbstractItemView::setModel(model);
}
/*!
\reimp
*/
void QTableView::setRootIndex(const QModelIndex &index)
{
Q_D(QTableView);
if (index == d->root) {
viewport()->update();
return;
}
d->verticalHeader->setRootIndex(index);
d->horizontalHeader->setRootIndex(index);
QAbstractItemView::setRootIndex(index);
}
/*!
\reimp
*/
void QTableView::setSelectionModel(QItemSelectionModel *selectionModel)
{
Q_D(QTableView);
Q_ASSERT(selectionModel);
d->verticalHeader->setSelectionModel(selectionModel);
d->horizontalHeader->setSelectionModel(selectionModel);
QAbstractItemView::setSelectionModel(selectionModel);
}
/*!
Returns the table view's horizontal header.
\sa setHorizontalHeader(), verticalHeader(), QAbstractItemModel::headerData()
*/
QHeaderView *QTableView::horizontalHeader() const
{
Q_D(const QTableView);
return d->horizontalHeader;
}
/*!
Returns the table view's vertical header.
\sa setVerticalHeader(), horizontalHeader(), QAbstractItemModel::headerData()
*/
QHeaderView *QTableView::verticalHeader() const
{
Q_D(const QTableView);
return d->verticalHeader;
}
/*!
Sets the widget to use for the horizontal header to \a header.
\sa horizontalHeader() setVerticalHeader()
*/
void QTableView::setHorizontalHeader(QHeaderView *header)
{
Q_D(QTableView);
if (!header || header == d->horizontalHeader)
return;
if (d->horizontalHeader && d->horizontalHeader->parent() == this)
delete d->horizontalHeader;
d->horizontalHeader = header;
d->horizontalHeader->setParent(this);
if (!d->horizontalHeader->model()) {
d->horizontalHeader->setModel(d->model);
if (d->selectionModel)
d->horizontalHeader->setSelectionModel(d->selectionModel);
}
connect(d->horizontalHeader,SIGNAL(sectionResized(int,int,int)),
this, SLOT(columnResized(int,int,int)));
connect(d->horizontalHeader, SIGNAL(sectionMoved(int,int,int)),
this, SLOT(columnMoved(int,int,int)));
connect(d->horizontalHeader, SIGNAL(sectionCountChanged(int,int)),
this, SLOT(columnCountChanged(int,int)));
connect(d->horizontalHeader, SIGNAL(sectionPressed(int)), this, SLOT(selectColumn(int)));
connect(d->horizontalHeader, SIGNAL(sectionEntered(int)), this, SLOT(_q_selectColumn(int)));
connect(d->horizontalHeader, SIGNAL(sectionHandleDoubleClicked(int)),
this, SLOT(resizeColumnToContents(int)));
connect(d->horizontalHeader, SIGNAL(geometriesChanged()), this, SLOT(updateGeometries()));
//update the sorting enabled states on the new header
setSortingEnabled(d->sortingEnabled);
}
/*!
Sets the widget to use for the vertical header to \a header.
\sa verticalHeader() setHorizontalHeader()
*/
void QTableView::setVerticalHeader(QHeaderView *header)
{
Q_D(QTableView);
if (!header || header == d->verticalHeader)
return;
if (d->verticalHeader && d->verticalHeader->parent() == this)
delete d->verticalHeader;
d->verticalHeader = header;
d->verticalHeader->setParent(this);
if (!d->verticalHeader->model()) {
d->verticalHeader->setModel(d->model);
if (d->selectionModel)
d->verticalHeader->setSelectionModel(d->selectionModel);
}
connect(d->verticalHeader, SIGNAL(sectionResized(int,int,int)),
this, SLOT(rowResized(int,int,int)));
connect(d->verticalHeader, SIGNAL(sectionMoved(int,int,int)),
this, SLOT(rowMoved(int,int,int)));
connect(d->verticalHeader, SIGNAL(sectionCountChanged(int,int)),
this, SLOT(rowCountChanged(int,int)));
connect(d->verticalHeader, SIGNAL(sectionPressed(int)), this, SLOT(selectRow(int)));
connect(d->verticalHeader, SIGNAL(sectionEntered(int)), this, SLOT(_q_selectRow(int)));
connect(d->verticalHeader, SIGNAL(sectionHandleDoubleClicked(int)),
this, SLOT(resizeRowToContents(int)));
connect(d->verticalHeader, SIGNAL(geometriesChanged()), this, SLOT(updateGeometries()));
}
/*!
\internal
Scroll the contents of the table view by (\a dx, \a dy).
*/
void QTableView::scrollContentsBy(int dx, int dy)
{
Q_D(QTableView);
d->delayedAutoScroll.stop(); // auto scroll was canceled by the user scrolling
dx = isRightToLeft() ? -dx : dx;
if (dx) {
if (horizontalScrollMode() == QAbstractItemView::ScrollPerItem) {
int oldOffset = d->horizontalHeader->offset();
if (horizontalScrollBar()->value() == horizontalScrollBar()->maximum())
d->horizontalHeader->setOffsetToLastSection();
else
d->horizontalHeader->setOffsetToSectionPosition(horizontalScrollBar()->value());
int newOffset = d->horizontalHeader->offset();
dx = isRightToLeft() ? newOffset - oldOffset : oldOffset - newOffset;
} else {
d->horizontalHeader->setOffset(horizontalScrollBar()->value());
}
}
if (dy) {
if (verticalScrollMode() == QAbstractItemView::ScrollPerItem) {
int oldOffset = d->verticalHeader->offset();
if (verticalScrollBar()->value() == verticalScrollBar()->maximum())
d->verticalHeader->setOffsetToLastSection();
else
d->verticalHeader->setOffsetToSectionPosition(verticalScrollBar()->value());
int newOffset = d->verticalHeader->offset();
dy = oldOffset - newOffset;
} else {
d->verticalHeader->setOffset(verticalScrollBar()->value());
}
}
d->scrollContentsBy(dx, dy);
if (d->showGrid) {
//we need to update the first line of the previous top item in the view
//because it has the grid drawn if the header is invisible.
//It is strictly related to what's done at then end of the paintEvent
if (dy > 0 && d->horizontalHeader->isHidden() && d->verticalScrollMode == ScrollPerItem) {
d->viewport->update(0, dy, d->viewport->width(), dy);
}
if (dx > 0 && d->verticalHeader->isHidden() && d->horizontalScrollMode == ScrollPerItem) {
d->viewport->update(dx, 0, dx, d->viewport->height());
}
}
}
/*!
\reimp
*/
QStyleOptionViewItem QTableView::viewOptions() const
{
QStyleOptionViewItem option = QAbstractItemView::viewOptions();
option.showDecorationSelected = true;
return option;
}
/*!
Paints the table on receipt of the given paint event \a event.
*/
void QTableView::paintEvent(QPaintEvent *event)
{
Q_D(QTableView);
// setup temp variables for the painting
QStyleOptionViewItemV4 option = d->viewOptionsV4();
const QPoint offset = d->scrollDelayOffset;
const bool showGrid = d->showGrid;
const int gridSize = showGrid ? 1 : 0;
const int gridHint = style()->styleHint(QStyle::SH_Table_GridLineColor, &option, this);
const QColor gridColor = static_cast<QRgb>(gridHint);
const QPen gridPen = QPen(gridColor, 0, d->gridStyle);
const QHeaderView *verticalHeader = d->verticalHeader;
const QHeaderView *horizontalHeader = d->horizontalHeader;
const QStyle::State state = option.state;
const bool alternate = d->alternatingColors;
const bool rightToLeft = isRightToLeft();
QPainter painter(d->viewport);
// if there's nothing to do, clear the area and return
if (horizontalHeader->count() == 0 || verticalHeader->count() == 0 || !d->itemDelegate)
return;
uint x = horizontalHeader->length() - horizontalHeader->offset() - (rightToLeft ? 0 : 1);
uint y = verticalHeader->length() - verticalHeader->offset() - 1;
const QRegion region = event->region().translated(offset);
const QVector<QRect> rects = region.rects();
//firstVisualRow is the visual index of the first visible row. lastVisualRow is the visual index of the last visible Row.
//same goes for ...VisualColumn
int firstVisualRow = qMax(verticalHeader->visualIndexAt(0),0);
int lastVisualRow = verticalHeader->visualIndexAt(verticalHeader->viewport()->height());
if (lastVisualRow == -1)
lastVisualRow = d->model->rowCount(d->root) - 1;
int firstVisualColumn = horizontalHeader->visualIndexAt(0);
int lastVisualColumn = horizontalHeader->visualIndexAt(horizontalHeader->viewport()->width());
if (rightToLeft)
qSwap(firstVisualColumn, lastVisualColumn);
if (firstVisualColumn == -1)
firstVisualColumn = 0;
if (lastVisualColumn == -1)
lastVisualColumn = horizontalHeader->count() - 1;
QBitArray drawn((lastVisualRow - firstVisualRow + 1) * (lastVisualColumn - firstVisualColumn + 1));
if (d->hasSpans()) {
d->drawAndClipSpans(region, &painter, option, &drawn,
firstVisualRow, lastVisualRow, firstVisualColumn, lastVisualColumn);
}
for (int i = 0; i < rects.size(); ++i) {
QRect dirtyArea = rects.at(i);
dirtyArea.setBottom(qMin(dirtyArea.bottom(), int(y)));
if (rightToLeft) {
dirtyArea.setLeft(qMax(dirtyArea.left(), d->viewport->width() - int(x)));
} else {
dirtyArea.setRight(qMin(dirtyArea.right(), int(x)));
}
// get the horizontal start and end visual sections
int left = horizontalHeader->visualIndexAt(dirtyArea.left());
int right = horizontalHeader->visualIndexAt(dirtyArea.right());
if (rightToLeft)
qSwap(left, right);
if (left == -1) left = 0;
if (right == -1) right = horizontalHeader->count() - 1;
// get the vertical start and end visual sections and if alternate color
int bottom = verticalHeader->visualIndexAt(dirtyArea.bottom());
if (bottom == -1) bottom = verticalHeader->count() - 1;
int top = 0;
bool alternateBase = false;
if (alternate && verticalHeader->sectionsHidden()) {
uint verticalOffset = verticalHeader->offset();
int row = verticalHeader->logicalIndex(top);
for (int y = 0;
((uint)(y += verticalHeader->sectionSize(top)) <= verticalOffset) && (top < bottom);
++top) {
row = verticalHeader->logicalIndex(top);
if (alternate && !verticalHeader->isSectionHidden(row))
alternateBase = !alternateBase;
}
} else {
top = verticalHeader->visualIndexAt(dirtyArea.top());
alternateBase = (top & 1) && alternate;
}
if (top == -1 || top > bottom)
continue;
// Paint each row item
for (int visualRowIndex = top; visualRowIndex <= bottom; ++visualRowIndex) {
int row = verticalHeader->logicalIndex(visualRowIndex);
if (verticalHeader->isSectionHidden(row))
continue;
int rowY = rowViewportPosition(row);
rowY += offset.y();
int rowh = rowHeight(row) - gridSize;
// Paint each column item
for (int visualColumnIndex = left; visualColumnIndex <= right; ++visualColumnIndex) {
int currentBit = (visualRowIndex - firstVisualRow) * (lastVisualColumn - firstVisualColumn + 1)
+ visualColumnIndex - firstVisualColumn;
if (currentBit < 0 || currentBit >= drawn.size() || drawn.testBit(currentBit))
continue;
drawn.setBit(currentBit);
int col = horizontalHeader->logicalIndex(visualColumnIndex);
if (horizontalHeader->isSectionHidden(col))
continue;
int colp = columnViewportPosition(col);
colp += offset.x();
int colw = columnWidth(col) - gridSize;
const QModelIndex index = d->model->index(row, col, d->root);
if (index.isValid()) {
option.rect = QRect(colp + (showGrid && rightToLeft ? 1 : 0), rowY, colw, rowh);
if (alternate) {
if (alternateBase)
option.features |= QStyleOptionViewItemV2::Alternate;
else
option.features &= ~QStyleOptionViewItemV2::Alternate;
}
d->drawCell(&painter, option, index);
}
}
alternateBase = !alternateBase && alternate;
}
if (showGrid) {
// Find the bottom right (the last rows/coloumns might be hidden)
while (verticalHeader->isSectionHidden(verticalHeader->logicalIndex(bottom))) --bottom;
QPen old = painter.pen();
painter.setPen(gridPen);
// Paint each row
for (int visualIndex = top; visualIndex <= bottom; ++visualIndex) {
int row = verticalHeader->logicalIndex(visualIndex);
if (verticalHeader->isSectionHidden(row))
continue;
int rowY = rowViewportPosition(row);
rowY += offset.y();
int rowh = rowHeight(row) - gridSize;
painter.drawLine(dirtyArea.left(), rowY + rowh, dirtyArea.right(), rowY + rowh);
}
// Paint each column
for (int h = left; h <= right; ++h) {
int col = horizontalHeader->logicalIndex(h);
if (horizontalHeader->isSectionHidden(col))
continue;
int colp = columnViewportPosition(col);
colp += offset.x();
if (!rightToLeft)
colp += columnWidth(col) - gridSize;
painter.drawLine(colp, dirtyArea.top(), colp, dirtyArea.bottom());
}
//draw the top & left grid lines if the headers are not visible.
//We do update this line when subsequent scroll happen (see scrollContentsBy)
if (horizontalHeader->isHidden() && verticalScrollMode() == ScrollPerItem)
painter.drawLine(dirtyArea.left(), 0, dirtyArea.right(), 0);
if (verticalHeader->isHidden() && horizontalScrollMode() == ScrollPerItem)
painter.drawLine(0, dirtyArea.top(), 0, dirtyArea.bottom());
painter.setPen(old);
}
}
#ifndef QT_NO_DRAGANDDROP
// Paint the dropIndicator
d->paintDropIndicator(&painter);
#endif
}
/*!
Returns the index position of the model item corresponding to the
table item at position \a pos in contents coordinates.
*/
QModelIndex QTableView::indexAt(const QPoint &pos) const
{
Q_D(const QTableView);
d->executePostedLayout();
int r = rowAt(pos.y());
int c = columnAt(pos.x());
if (r >= 0 && c >= 0) {
if (d->hasSpans()) {
QSpanCollection::Span span = d->span(r, c);
r = span.top();
c = span.left();
}
return d->model->index(r, c, d->root);
}
return QModelIndex();
}
/*!
Returns the horizontal offset of the items in the table view.
Note that the table view uses the horizontal header section
positions to determine the positions of columns in the view.
\sa verticalOffset()
*/
int QTableView::horizontalOffset() const
{
Q_D(const QTableView);
return d->horizontalHeader->offset();
}
/*!
Returns the vertical offset of the items in the table view.
Note that the table view uses the vertical header section
positions to determine the positions of rows in the view.
\sa horizontalOffset()
*/
int QTableView::verticalOffset() const
{
Q_D(const QTableView);
return d->verticalHeader->offset();
}
/*!
\fn QModelIndex QTableView::moveCursor(CursorAction cursorAction, Qt::KeyboardModifiers modifiers)
Moves the cursor in accordance with the given \a cursorAction, using the
information provided by the \a modifiers.
\sa QAbstractItemView::CursorAction
*/
QModelIndex QTableView::moveCursor(CursorAction cursorAction, Qt::KeyboardModifiers modifiers)
{
Q_D(QTableView);
Q_UNUSED(modifiers);
int bottom = d->model->rowCount(d->root) - 1;
// make sure that bottom is the bottommost *visible* row
while (bottom >= 0 && isRowHidden(d->logicalRow(bottom)))
--bottom;
int right = d->model->columnCount(d->root) - 1;
while (right >= 0 && isColumnHidden(d->logicalColumn(right)))
--right;
if (bottom == -1 || right == -1)
return QModelIndex(); // model is empty
QModelIndex current = currentIndex();
if (!current.isValid()) {
int row = 0;
int column = 0;
while (column < right && isColumnHidden(d->logicalColumn(column)))
++column;
while (isRowHidden(d->logicalRow(row)) && row < bottom)
++row;
d->visualCursor = QPoint(column, row);
return d->model->index(d->logicalRow(row), d->logicalColumn(column), d->root);
}
// Update visual cursor if current index has changed.
QPoint visualCurrent(d->visualColumn(current.column()), d->visualRow(current.row()));
if (visualCurrent != d->visualCursor) {
if (d->hasSpans()) {
QSpanCollection::Span span = d->span(current.row(), current.column());
if (span.top() > d->visualCursor.y() || d->visualCursor.y() > span.bottom()
|| span.left() > d->visualCursor.x() || d->visualCursor.x() > span.right())
d->visualCursor = visualCurrent;
} else {
d->visualCursor = visualCurrent;
}
}
int visualRow = d->visualCursor.y();
if (visualRow > bottom)
visualRow = bottom;
Q_ASSERT(visualRow != -1);
int visualColumn = d->visualCursor.x();
if (visualColumn > right)
visualColumn = right;
Q_ASSERT(visualColumn != -1);
if (isRightToLeft()) {
if (cursorAction == MoveLeft)
cursorAction = MoveRight;
else if (cursorAction == MoveRight)
cursorAction = MoveLeft;
}
switch (cursorAction) {
case MoveUp: {
int originalRow = visualRow;
#ifdef QT_KEYPAD_NAVIGATION
if (QApplication::keypadNavigationEnabled() && visualRow == 0)
visualRow = d->visualRow(model()->rowCount() - 1) + 1;
// FIXME? visualRow = bottom + 1;
#endif
int r = d->logicalRow(visualRow);
int c = d->logicalColumn(visualColumn);
if (r != -1 && d->hasSpans()) {
QSpanCollection::Span span = d->span(r, c);
if (span.width() > 1 || span.height() > 1)
visualRow = d->visualRow(span.top());
}
while (visualRow >= 0) {
--visualRow;
r = d->logicalRow(visualRow);
c = d->logicalColumn(visualColumn);
if (r == -1 || (!isRowHidden(r) && d->isCellEnabled(r, c)))
break;
}
if (visualRow < 0)
visualRow = originalRow;
break;
}
case MoveDown: {
int originalRow = visualRow;
if (d->hasSpans()) {
QSpanCollection::Span span = d->span(current.row(), current.column());
visualRow = d->visualRow(d->rowSpanEndLogical(span.top(), span.height()));
}
#ifdef QT_KEYPAD_NAVIGATION
if (QApplication::keypadNavigationEnabled() && visualRow >= bottom)
visualRow = -1;
#endif
int r = d->logicalRow(visualRow);
int c = d->logicalColumn(visualColumn);
if (r != -1 && d->hasSpans()) {
QSpanCollection::Span span = d->span(r, c);
if (span.width() > 1 || span.height() > 1)
visualRow = d->visualRow(d->rowSpanEndLogical(span.top(), span.height()));
}
while (visualRow <= bottom) {
++visualRow;
r = d->logicalRow(visualRow);
c = d->logicalColumn(visualColumn);
if (r == -1 || (!isRowHidden(r) && d->isCellEnabled(r, c)))
break;
}
if (visualRow > bottom)
visualRow = originalRow;
break;
}
case MovePrevious:
case MoveLeft: {
int originalRow = visualRow;
int originalColumn = visualColumn;
bool firstTime = true;
bool looped = false;
bool wrapped = false;
do {
int r = d->logicalRow(visualRow);
int c = d->logicalColumn(visualColumn);
if (firstTime && c != -1 && d->hasSpans()) {
firstTime = false;
QSpanCollection::Span span = d->span(r, c);
if (span.width() > 1 || span.height() > 1)
visualColumn = d->visualColumn(span.left());
}
while (visualColumn >= 0) {
--visualColumn;
r = d->logicalRow(visualRow);
c = d->logicalColumn(visualColumn);
if (r == -1 || c == -1 || (!isRowHidden(r) && !isColumnHidden(c) && d->isCellEnabled(r, c)))
break;
if (wrapped && (originalRow < visualRow || (originalRow == visualRow && originalColumn <= visualColumn))) {
looped = true;
break;
}
}
if (cursorAction == MoveLeft || visualColumn >= 0)
break;
visualColumn = right + 1;
if (visualRow == 0) {
wrapped = true;
visualRow = bottom;
} else {
--visualRow;
}
} while (!looped);
if (visualColumn < 0)
visualColumn = originalColumn;
break;
}
case MoveNext:
case MoveRight: {
int originalRow = visualRow;
int originalColumn = visualColumn;
bool firstTime = true;
bool looped = false;
bool wrapped = false;
do {
int r = d->logicalRow(visualRow);
int c = d->logicalColumn(visualColumn);
if (firstTime && c != -1 && d->hasSpans()) {
firstTime = false;
QSpanCollection::Span span = d->span(r, c);
if (span.width() > 1 || span.height() > 1)
visualColumn = d->visualColumn(d->columnSpanEndLogical(span.left(), span.width()));
}
while (visualColumn <= right) {
++visualColumn;
r = d->logicalRow(visualRow);
c = d->logicalColumn(visualColumn);
if (r == -1 || c == -1 || (!isRowHidden(r) && !isColumnHidden(c) && d->isCellEnabled(r, c)))
break;
if (wrapped && (originalRow > visualRow || (originalRow == visualRow && originalColumn >= visualColumn))) {
looped = true;
break;
}
}
if (cursorAction == MoveRight || visualColumn <= right)
break;
visualColumn = -1;
if (visualRow == bottom) {
wrapped = true;
visualRow = 0;
} else {
++visualRow;
}
} while (!looped);
if (visualColumn > right)
visualColumn = originalColumn;
break;
}
case MoveHome:
visualColumn = 0;
while (visualColumn < right && d->isVisualColumnHiddenOrDisabled(visualRow, visualColumn))
++visualColumn;
if (modifiers & Qt::ControlModifier) {
visualRow = 0;
while (visualRow < bottom && d->isVisualRowHiddenOrDisabled(visualRow, visualColumn))
++visualRow;
}
break;
case MoveEnd:
visualColumn = right;
if (modifiers & Qt::ControlModifier)
visualRow = bottom;
break;
case MovePageUp: {
int newRow = rowAt(visualRect(current).top() - d->viewport->height());
if (newRow == -1)
newRow = d->logicalRow(0);
return d->model->index(newRow, current.column(), d->root);
}
case MovePageDown: {
int newRow = rowAt(visualRect(current).bottom() + d->viewport->height());
if (newRow == -1)
newRow = d->logicalRow(bottom);
return d->model->index(newRow, current.column(), d->root);
}}
d->visualCursor = QPoint(visualColumn, visualRow);
int logicalRow = d->logicalRow(visualRow);
int logicalColumn = d->logicalColumn(visualColumn);
if (!d->model->hasIndex(logicalRow, logicalColumn, d->root))
return QModelIndex();
QModelIndex result = d->model->index(logicalRow, logicalColumn, d->root);
if (!d->isRowHidden(logicalRow) && !d->isColumnHidden(logicalColumn) && d->isIndexEnabled(result))
return result;
return QModelIndex();
}
/*!
\fn void QTableView::setSelection(const QRect &rect,
QItemSelectionModel::SelectionFlags flags)
Selects the items within the given \a rect and in accordance with
the specified selection \a flags.
*/
void QTableView::setSelection(const QRect &rect, QItemSelectionModel::SelectionFlags command)
{
Q_D(QTableView);
QModelIndex tl = indexAt(QPoint(isRightToLeft() ? qMax(rect.left(), rect.right())
: qMin(rect.left(), rect.right()), qMin(rect.top(), rect.bottom())));
QModelIndex br = indexAt(QPoint(isRightToLeft() ? qMin(rect.left(), rect.right()) :
qMax(rect.left(), rect.right()), qMax(rect.top(), rect.bottom())));
if (!d->selectionModel || !tl.isValid() || !br.isValid() || !d->isIndexEnabled(tl) || !d->isIndexEnabled(br))
return;
bool verticalMoved = verticalHeader()->sectionsMoved();
bool horizontalMoved = horizontalHeader()->sectionsMoved();
QItemSelection selection;
if (d->hasSpans()) {
bool expanded;
int top = qMin(d->visualRow(tl.row()), d->visualRow(br.row()));
int left = qMin(d->visualColumn(tl.column()), d->visualColumn(br.column()));
int bottom = qMax(d->visualRow(tl.row()), d->visualRow(br.row()));
int right = qMax(d->visualColumn(tl.column()), d->visualColumn(br.column()));
do {
expanded = false;
foreach (QSpanCollection::Span *it, d->spans.spans) {
const QSpanCollection::Span &span = *it;
int t = d->visualRow(span.top());
int l = d->visualColumn(span.left());
int b = d->visualRow(d->rowSpanEndLogical(span.top(), span.height()));
int r = d->visualColumn(d->columnSpanEndLogical(span.left(), span.width()));
if ((t > bottom) || (l > right) || (top > b) || (left > r))
continue; // no intersect
if (t < top) {
top = t;
expanded = true;
}
if (l < left) {
left = l;
expanded = true;
}
if (b > bottom) {
bottom = b;
expanded = true;
}
if (r > right) {
right = r;
expanded = true;
}
if (expanded)
break;
}
} while (expanded);
for (int horizontal = left; horizontal <= right; ++horizontal) {
int column = d->logicalColumn(horizontal);
for (int vertical = top; vertical <= bottom; ++vertical) {
int row = d->logicalRow(vertical);
QModelIndex index = d->model->index(row, column, d->root);
selection.append(QItemSelectionRange(index));
}
}
} else if (verticalMoved && horizontalMoved) {
int top = d->visualRow(tl.row());
int left = d->visualColumn(tl.column());
int bottom = d->visualRow(br.row());
int right = d->visualColumn(br.column());
for (int horizontal = left; horizontal <= right; ++horizontal) {
int column = d->logicalColumn(horizontal);
for (int vertical = top; vertical <= bottom; ++vertical) {
int row = d->logicalRow(vertical);
QModelIndex index = d->model->index(row, column, d->root);
selection.append(QItemSelectionRange(index));
}
}
} else if (horizontalMoved) {
int left = d->visualColumn(tl.column());
int right = d->visualColumn(br.column());
for (int visual = left; visual <= right; ++visual) {
int column = d->logicalColumn(visual);
QModelIndex topLeft = d->model->index(tl.row(), column, d->root);
QModelIndex bottomRight = d->model->index(br.row(), column, d->root);
selection.append(QItemSelectionRange(topLeft, bottomRight));
}
} else if (verticalMoved) {
int top = d->visualRow(tl.row());
int bottom = d->visualRow(br.row());
for (int visual = top; visual <= bottom; ++visual) {
int row = d->logicalRow(visual);
QModelIndex topLeft = d->model->index(row, tl.column(), d->root);
QModelIndex bottomRight = d->model->index(row, br.column(), d->root);
selection.append(QItemSelectionRange(topLeft, bottomRight));
}
} else { // nothing moved
selection.append(QItemSelectionRange(tl, br));
}
d->selectionModel->select(selection, command);
}
/*!
\internal
Returns the rectangle from the viewport of the items in the given
\a selection.
*/
QRegion QTableView::visualRegionForSelection(const QItemSelection &selection) const
{
Q_D(const QTableView);
if (selection.isEmpty())
return QRegion();
QRegion selectionRegion;
bool verticalMoved = verticalHeader()->sectionsMoved();
bool horizontalMoved = horizontalHeader()->sectionsMoved();
if ((verticalMoved && horizontalMoved) || (d->hasSpans() && (verticalMoved || horizontalMoved))) {
for (int i = 0; i < selection.count(); ++i) {
QItemSelectionRange range = selection.at(i);
if (range.parent() != d->root || !range.isValid())
continue;
for (int r = range.top(); r <= range.bottom(); ++r)
for (int c = range.left(); c <= range.right(); ++c)
selectionRegion += QRegion(visualRect(d->model->index(r, c, d->root)));
}
} else if (horizontalMoved) {
for (int i = 0; i < selection.count(); ++i) {
QItemSelectionRange range = selection.at(i);
if (range.parent() != d->root || !range.isValid())
continue;
int top = rowViewportPosition(range.top());
int bottom = rowViewportPosition(range.bottom()) + rowHeight(range.bottom());
if (top > bottom)
qSwap<int>(top, bottom);
int height = bottom - top;
for (int c = range.left(); c <= range.right(); ++c)
selectionRegion += QRegion(QRect(columnViewportPosition(c), top,
columnWidth(c), height));
}
} else if (verticalMoved) {
for (int i = 0; i < selection.count(); ++i) {
QItemSelectionRange range = selection.at(i);
if (range.parent() != d->root || !range.isValid())
continue;
int left = columnViewportPosition(range.left());
int right = columnViewportPosition(range.right()) + columnWidth(range.right());
if (left > right)
qSwap<int>(left, right);
int width = right - left;
for (int r = range.top(); r <= range.bottom(); ++r)
selectionRegion += QRegion(QRect(left, rowViewportPosition(r),
width, rowHeight(r)));
}
} else { // nothing moved
const int gridAdjust = showGrid() ? 1 : 0;
for (int i = 0; i < selection.count(); ++i) {
QItemSelectionRange range = selection.at(i);
if (range.parent() != d->root || !range.isValid())
continue;
d->trimHiddenSelections(&range);
const int rtop = rowViewportPosition(range.top());
const int rbottom = rowViewportPosition(range.bottom()) + rowHeight(range.bottom());
int rleft;
int rright;
if (isLeftToRight()) {
rleft = columnViewportPosition(range.left());
rright = columnViewportPosition(range.right()) + columnWidth(range.right());
} else {
rleft = columnViewportPosition(range.right());
rright = columnViewportPosition(range.left()) + columnWidth(range.left());
}
selectionRegion += QRect(QPoint(rleft, rtop), QPoint(rright - 1 - gridAdjust, rbottom - 1 - gridAdjust));
if (d->hasSpans()) {
foreach (QSpanCollection::Span *s,
d->spans.spansInRect(range.left(), range.top(), range.width(), range.height())) {
if (range.contains(s->top(), s->left(), range.parent()))
selectionRegion += d->visualSpanRect(*s);
}
}
}
}
return selectionRegion;
}
/*!
\reimp
*/
QModelIndexList QTableView::selectedIndexes() const
{
Q_D(const QTableView);
QModelIndexList viewSelected;
QModelIndexList modelSelected;
if (d->selectionModel)
modelSelected = d->selectionModel->selectedIndexes();
for (int i = 0; i < modelSelected.count(); ++i) {
QModelIndex index = modelSelected.at(i);
if (!isIndexHidden(index) && index.parent() == d->root)
viewSelected.append(index);
}
return viewSelected;
}
/*!
This slot is called whenever rows are added or deleted. The
previous number of rows is specified by \a oldCount, and the new
number of rows is specified by \a newCount.
*/
void QTableView::rowCountChanged(int /*oldCount*/, int /*newCount*/ )
{
Q_D(QTableView);
updateGeometries();
if (verticalScrollMode() == QAbstractItemView::ScrollPerItem)
d->verticalHeader->setOffsetToSectionPosition(verticalScrollBar()->value());
else
d->verticalHeader->setOffset(verticalScrollBar()->value());
d->viewport->update();
}
/*!
This slot is called whenever columns are added or deleted. The
previous number of columns is specified by \a oldCount, and the new
number of columns is specified by \a newCount.
*/
void QTableView::columnCountChanged(int, int)
{
Q_D(QTableView);
updateGeometries();
if (horizontalScrollMode() == QAbstractItemView::ScrollPerItem)
d->horizontalHeader->setOffsetToSectionPosition(horizontalScrollBar()->value());
else
d->horizontalHeader->setOffset(horizontalScrollBar()->value());
d->viewport->update();
}
/*!
\reimp
*/
void QTableView::updateGeometries()
{
Q_D(QTableView);
if (d->geometryRecursionBlock)
return;
d->geometryRecursionBlock = true;
int width = 0;
if (!d->verticalHeader->isHidden()) {
width = qMax(d->verticalHeader->minimumWidth(), d->verticalHeader->sizeHint().width());
width = qMin(width, d->verticalHeader->maximumWidth());
}
int height = 0;
if (!d->horizontalHeader->isHidden()) {
height = qMax(d->horizontalHeader->minimumHeight(), d->horizontalHeader->sizeHint().height());
height = qMin(height, d->horizontalHeader->maximumHeight());
}
bool reverse = isRightToLeft();
if (reverse)
setViewportMargins(0, height, width, 0);
else
setViewportMargins(width, height, 0, 0);
// update headers
QRect vg = d->viewport->geometry();
int verticalLeft = reverse ? vg.right() + 1 : (vg.left() - width);
d->verticalHeader->setGeometry(verticalLeft, vg.top(), width, vg.height());
if (d->verticalHeader->isHidden())
QMetaObject::invokeMethod(d->verticalHeader, "updateGeometries");
int horizontalTop = vg.top() - height;
d->horizontalHeader->setGeometry(vg.left(), horizontalTop, vg.width(), height);
if (d->horizontalHeader->isHidden())
QMetaObject::invokeMethod(d->horizontalHeader, "updateGeometries");
// update cornerWidget
if (d->horizontalHeader->isHidden() || d->verticalHeader->isHidden()) {
d->cornerWidget->setHidden(true);
} else {
d->cornerWidget->setHidden(false);
d->cornerWidget->setGeometry(verticalLeft, horizontalTop, width, height);
}
// update scroll bars
// ### move this block into the if
QSize vsize = d->viewport->size();
QSize max = maximumViewportSize();
uint horizontalLength = d->horizontalHeader->length();
uint verticalLength = d->verticalHeader->length();
if ((uint)max.width() >= horizontalLength && (uint)max.height() >= verticalLength)
vsize = max;
// horizontal scroll bar
const int columnCount = d->horizontalHeader->count();
const int viewportWidth = vsize.width();
int columnsInViewport = 0;
for (int width = 0, column = columnCount - 1; column >= 0; --column) {
int logical = d->horizontalHeader->logicalIndex(column);
if (!d->horizontalHeader->isSectionHidden(logical)) {
width += d->horizontalHeader->sectionSize(logical);
if (width > viewportWidth)
break;
++columnsInViewport;
}
}
columnsInViewport = qMax(columnsInViewport, 1); //there must be always at least 1 column
if (horizontalScrollMode() == QAbstractItemView::ScrollPerItem) {
const int visibleColumns = columnCount - d->horizontalHeader->hiddenSectionCount();
horizontalScrollBar()->setRange(0, visibleColumns - columnsInViewport);
horizontalScrollBar()->setPageStep(columnsInViewport);
if (columnsInViewport >= visibleColumns)
d->horizontalHeader->setOffset(0);
horizontalScrollBar()->setSingleStep(1);
} else { // ScrollPerPixel
horizontalScrollBar()->setPageStep(vsize.width());
horizontalScrollBar()->setRange(0, horizontalLength - vsize.width());
horizontalScrollBar()->setSingleStep(qMax(vsize.width() / (columnsInViewport + 1), 2));
}
// vertical scroll bar
const int rowCount = d->verticalHeader->count();
const int viewportHeight = vsize.height();
int rowsInViewport = 0;
for (int height = 0, row = rowCount - 1; row >= 0; --row) {
int logical = d->verticalHeader->logicalIndex(row);
if (!d->verticalHeader->isSectionHidden(logical)) {
height += d->verticalHeader->sectionSize(logical);
if (height > viewportHeight)
break;
++rowsInViewport;
}
}
rowsInViewport = qMax(rowsInViewport, 1); //there must be always at least 1 row
if (verticalScrollMode() == QAbstractItemView::ScrollPerItem) {
const int visibleRows = rowCount - d->verticalHeader->hiddenSectionCount();
verticalScrollBar()->setRange(0, visibleRows - rowsInViewport);
verticalScrollBar()->setPageStep(rowsInViewport);
if (rowsInViewport >= visibleRows)
d->verticalHeader->setOffset(0);
verticalScrollBar()->setSingleStep(1);
} else { // ScrollPerPixel
verticalScrollBar()->setPageStep(vsize.height());
verticalScrollBar()->setRange(0, verticalLength - vsize.height());
verticalScrollBar()->setSingleStep(qMax(vsize.height() / (rowsInViewport + 1), 2));
}
d->geometryRecursionBlock = false;
QAbstractItemView::updateGeometries();
}
/*!
Returns the size hint for the given \a row's height or -1 if there
is no model.
If you need to set the height of a given row to a fixed value, call
QHeaderView::resizeSection() on the table's vertical header.
If you reimplement this function in a subclass, note that the value you
return is only used when resizeRowToContents() is called. In that case,
if a larger row height is required by either the vertical header or
the item delegate, that width will be used instead.
\sa QWidget::sizeHint, verticalHeader()
*/
int QTableView::sizeHintForRow(int row) const
{
Q_D(const QTableView);
if (!model())
return -1;
ensurePolished();
int left = qMax(0, columnAt(0));
int right = columnAt(d->viewport->width());
if (right == -1) // the table don't have enough columns to fill the viewport
right = d->model->columnCount(d->root) - 1;
QStyleOptionViewItemV4 option = d->viewOptionsV4();
int hint = 0;
QModelIndex index;
for (int column = left; column <= right; ++column) {
int logicalColumn = d->horizontalHeader->logicalIndex(column);
if (d->horizontalHeader->isSectionHidden(logicalColumn))
continue;
index = d->model->index(row, logicalColumn, d->root);
if (d->wrapItemText) {// for wrapping boundaries
option.rect.setY(rowViewportPosition(index.row()));
option.rect.setHeight(rowHeight(index.row()));
option.rect.setX(columnViewportPosition(index.column()));
option.rect.setWidth(columnWidth(index.column()));
}
QWidget *editor = d->editorForIndex(index).editor;
if (editor && d->persistent.contains(editor)) {
hint = qMax(hint, editor->sizeHint().height());
int min = editor->minimumSize().height();
int max = editor->maximumSize().height();
hint = qBound(min, hint, max);
}
hint = qMax(hint, itemDelegate(index)->sizeHint(option, index).height());
}
return d->showGrid ? hint + 1 : hint;
}
/*!
Returns the size hint for the given \a column's width or -1 if
there is no model.
If you need to set the width of a given column to a fixed value, call
QHeaderView::resizeSection() on the table's horizontal header.
If you reimplement this function in a subclass, note that the value you
return will be used when resizeColumnToContents() or
QHeaderView::resizeSections() is called. If a larger column width is
required by either the horizontal header or the item delegate, the larger
width will be used instead.
\sa QWidget::sizeHint, horizontalHeader()
*/
int QTableView::sizeHintForColumn(int column) const
{
Q_D(const QTableView);
if (!model())
return -1;
ensurePolished();
int top = qMax(0, rowAt(0));
int bottom = rowAt(d->viewport->height());
if (!isVisible() || bottom == -1) // the table don't have enough rows to fill the viewport
bottom = d->model->rowCount(d->root) - 1;
QStyleOptionViewItemV4 option = d->viewOptionsV4();
int hint = 0;
QModelIndex index;
for (int row = top; row <= bottom; ++row) {
int logicalRow = d->verticalHeader->logicalIndex(row);
if (d->verticalHeader->isSectionHidden(logicalRow))
continue;
index = d->model->index(logicalRow, column, d->root);
QWidget *editor = d->editorForIndex(index).editor;
if (editor && d->persistent.contains(editor)) {
hint = qMax(hint, editor->sizeHint().width());
int min = editor->minimumSize().width();
int max = editor->maximumSize().width();
hint = qBound(min, hint, max);
}
hint = qMax(hint, itemDelegate(index)->sizeHint(option, index).width());
}
return d->showGrid ? hint + 1 : hint;
}
/*!
Returns the y-coordinate in contents coordinates of the given \a
row.
*/
int QTableView::rowViewportPosition(int row) const
{
Q_D(const QTableView);
return d->verticalHeader->sectionViewportPosition(row);
}
/*!
Returns the row in which the given y-coordinate, \a y, in contents
coordinates is located.
\note This function returns -1 if the given coordinate is not valid
(has no row).
\sa columnAt()
*/
int QTableView::rowAt(int y) const
{
Q_D(const QTableView);
return d->verticalHeader->logicalIndexAt(y);
}
/*!
\since 4.1
Sets the height of the given \a row to be \a height.
*/
void QTableView::setRowHeight(int row, int height)
{
Q_D(const QTableView);
d->verticalHeader->resizeSection(row, height);
}
/*!
Returns the height of the given \a row.
\sa resizeRowToContents(), columnWidth()
*/
int QTableView::rowHeight(int row) const
{
Q_D(const QTableView);
return d->verticalHeader->sectionSize(row);
}
/*!
Returns the x-coordinate in contents coordinates of the given \a
column.
*/
int QTableView::columnViewportPosition(int column) const
{
Q_D(const QTableView);
return d->horizontalHeader->sectionViewportPosition(column);
}
/*!
Returns the column in which the given x-coordinate, \a x, in contents
coordinates is located.
\note This function returns -1 if the given coordinate is not valid
(has no column).
\sa rowAt()
*/
int QTableView::columnAt(int x) const
{
Q_D(const QTableView);
return d->horizontalHeader->logicalIndexAt(x);
}
/*!
\since 4.1
Sets the width of the given \a column to be \a width.
*/
void QTableView::setColumnWidth(int column, int width)
{
Q_D(const QTableView);
d->horizontalHeader->resizeSection(column, width);
}
/*!
Returns the width of the given \a column.
\sa resizeColumnToContents(), rowHeight()
*/
int QTableView::columnWidth(int column) const
{
Q_D(const QTableView);
return d->horizontalHeader->sectionSize(column);
}
/*!
Returns true if the given \a row is hidden; otherwise returns false.
\sa isColumnHidden()
*/
bool QTableView::isRowHidden(int row) const
{
Q_D(const QTableView);
return d->verticalHeader->isSectionHidden(row);
}
/*!
If \a hide is true \a row will be hidden, otherwise it will be shown.
\sa setColumnHidden()
*/
void QTableView::setRowHidden(int row, bool hide)
{
Q_D(QTableView);
if (row < 0 || row >= d->verticalHeader->count())
return;
d->verticalHeader->setSectionHidden(row, hide);
}
/*!
Returns true if the given \a column is hidden; otherwise returns false.
\sa isRowHidden()
*/
bool QTableView::isColumnHidden(int column) const
{
Q_D(const QTableView);
return d->horizontalHeader->isSectionHidden(column);
}
/*!
If \a hide is true the given \a column will be hidden; otherwise it
will be shown.
\sa setRowHidden()
*/
void QTableView::setColumnHidden(int column, bool hide)
{
Q_D(QTableView);
if (column < 0 || column >= d->horizontalHeader->count())
return;
d->horizontalHeader->setSectionHidden(column, hide);
}
/*!
\since 4.2
\property QTableView::sortingEnabled
\brief whether sorting is enabled
If this property is true, sorting is enabled for the table. If
this property is false, sorting is not enabled. The default value
is false.
\note. Setting the property to true with setSortingEnabled()
immediately triggers a call to sortByColumn() with the current
sort section and order.
\sa sortByColumn()
*/
/*!
If \a enabled true enables sorting for the table and immediately
trigger a call to sortByColumn() with the current sort section and
order
*/
void QTableView::setSortingEnabled(bool enable)
{
Q_D(QTableView);
d->sortingEnabled = enable;
horizontalHeader()->setSortIndicatorShown(enable);
if (enable) {
disconnect(d->horizontalHeader, SIGNAL(sectionEntered(int)),
this, SLOT(_q_selectColumn(int)));
disconnect(horizontalHeader(), SIGNAL(sectionPressed(int)),
this, SLOT(selectColumn(int)));
connect(horizontalHeader(), SIGNAL(sortIndicatorChanged(int,Qt::SortOrder)),
this, SLOT(sortByColumn(int)), Qt::UniqueConnection);
sortByColumn(horizontalHeader()->sortIndicatorSection(),
horizontalHeader()->sortIndicatorOrder());
} else {
connect(d->horizontalHeader, SIGNAL(sectionEntered(int)),
this, SLOT(_q_selectColumn(int)), Qt::UniqueConnection);
connect(horizontalHeader(), SIGNAL(sectionPressed(int)),
this, SLOT(selectColumn(int)), Qt::UniqueConnection);
disconnect(horizontalHeader(), SIGNAL(sortIndicatorChanged(int,Qt::SortOrder)),
this, SLOT(sortByColumn(int)));
}
}
bool QTableView::isSortingEnabled() const
{
Q_D(const QTableView);
return d->sortingEnabled;
}
/*!
\property QTableView::showGrid
\brief whether the grid is shown
If this property is true a grid is drawn for the table; if the
property is false, no grid is drawn. The default value is true.
*/
bool QTableView::showGrid() const
{
Q_D(const QTableView);
return d->showGrid;
}
void QTableView::setShowGrid(bool show)
{
Q_D(QTableView);
if (d->showGrid != show) {
d->showGrid = show;
d->viewport->update();
}
}
/*!
\property QTableView::gridStyle
\brief the pen style used to draw the grid.
This property holds the style used when drawing the grid (see \l{showGrid}).
*/
Qt::PenStyle QTableView::gridStyle() const
{
Q_D(const QTableView);
return d->gridStyle;
}
void QTableView::setGridStyle(Qt::PenStyle style)
{
Q_D(QTableView);
if (d->gridStyle != style) {
d->gridStyle = style;
d->viewport->update();
}
}
/*!
\property QTableView::wordWrap
\brief the item text word-wrapping policy
\since 4.3
If this property is true then the item text is wrapped where
necessary at word-breaks; otherwise it is not wrapped at all.
This property is true by default.
Note that even of wrapping is enabled, the cell will not be
expanded to fit all text. Ellipsis will be inserted according to
the current \l{QAbstractItemView::}{textElideMode}.
*/
void QTableView::setWordWrap(bool on)
{
Q_D(QTableView);
if (d->wrapItemText == on)
return;
d->wrapItemText = on;
QMetaObject::invokeMethod(d->verticalHeader, "resizeSections");
QMetaObject::invokeMethod(d->horizontalHeader, "resizeSections");
}
bool QTableView::wordWrap() const
{
Q_D(const QTableView);
return d->wrapItemText;
}
/*!
\property QTableView::cornerButtonEnabled
\brief whether the button in the top-left corner is enabled
\since 4.3
If this property is true then button in the top-left corner
of the table view is enabled. Clicking on this button will
select all the cells in the table view.
This property is true by default.
*/
void QTableView::setCornerButtonEnabled(bool enable)
{
Q_D(QTableView);
d->cornerWidget->setEnabled(enable);
}
bool QTableView::isCornerButtonEnabled() const
{
Q_D(const QTableView);
return d->cornerWidget->isEnabled();
}
/*!
\internal
Returns the rectangle on the viewport occupied by the given \a
index.
If the index is hidden in the view it will return a null QRect.
*/
QRect QTableView::visualRect(const QModelIndex &index) const
{
Q_D(const QTableView);
if (!d->isIndexValid(index) || index.parent() != d->root
|| (!d->hasSpans() && isIndexHidden(index)))
return QRect();
d->executePostedLayout();
if (d->hasSpans()) {
QSpanCollection::Span span = d->span(index.row(), index.column());
return d->visualSpanRect(span);
}
int rowp = rowViewportPosition(index.row());
int rowh = rowHeight(index.row());
int colp = columnViewportPosition(index.column());
int colw = columnWidth(index.column());
const int i = showGrid() ? 1 : 0;
return QRect(colp, rowp, colw - i, rowh - i);
}
/*!
\internal
Makes sure that the given \a item is visible in the table view,
scrolling if necessary.
*/
void QTableView::scrollTo(const QModelIndex &index, ScrollHint hint)
{
Q_D(QTableView);
// check if we really need to do anything
if (!d->isIndexValid(index)
|| (d->model->parent(index) != d->root)
|| isRowHidden(index.row()) || isColumnHidden(index.column()))
return;
QSpanCollection::Span span;
if (d->hasSpans())
span = d->span(index.row(), index.column());
// Adjust horizontal position
int viewportWidth = d->viewport->width();
int horizontalOffset = d->horizontalHeader->offset();
int horizontalPosition = d->horizontalHeader->sectionPosition(index.column());
int horizontalIndex = d->horizontalHeader->visualIndex(index.column());
int cellWidth = d->hasSpans()
? d->columnSpanWidth(index.column(), span.width())
: d->horizontalHeader->sectionSize(index.column());
if (horizontalScrollMode() == QAbstractItemView::ScrollPerItem) {
bool positionAtLeft = (horizontalPosition - horizontalOffset < 0);
bool positionAtRight = (horizontalPosition - horizontalOffset + cellWidth > viewportWidth);
if (hint == PositionAtCenter || positionAtRight) {
int w = (hint == PositionAtCenter ? viewportWidth / 2 : viewportWidth);
int x = cellWidth;
while (horizontalIndex > 0) {
x += columnWidth(d->horizontalHeader->logicalIndex(horizontalIndex-1));
if (x > w)
break;
--horizontalIndex;
}
}
if (positionAtRight || hint == PositionAtCenter || positionAtLeft) {
int hiddenSections = 0;
if (d->horizontalHeader->sectionsHidden()) {
for (int s = horizontalIndex - 1; s >= 0; --s) {
int column = d->horizontalHeader->logicalIndex(s);
if (d->horizontalHeader->isSectionHidden(column))
++hiddenSections;
}
}
horizontalScrollBar()->setValue(horizontalIndex - hiddenSections);
}
} else { // ScrollPerPixel
if (hint == PositionAtCenter) {
horizontalScrollBar()->setValue(horizontalPosition - ((viewportWidth - cellWidth) / 2));
} else {
if (horizontalPosition - horizontalOffset < 0 || cellWidth > viewportWidth)
horizontalScrollBar()->setValue(horizontalPosition);
else if (horizontalPosition - horizontalOffset + cellWidth > viewportWidth)
horizontalScrollBar()->setValue(horizontalPosition - viewportWidth + cellWidth);
}
}
// Adjust vertical position
int viewportHeight = d->viewport->height();
int verticalOffset = d->verticalHeader->offset();
int verticalPosition = d->verticalHeader->sectionPosition(index.row());
int verticalIndex = d->verticalHeader->visualIndex(index.row());
int cellHeight = d->hasSpans()
? d->rowSpanHeight(index.row(), span.height())
: d->verticalHeader->sectionSize(index.row());
if (verticalPosition - verticalOffset < 0 || cellHeight > viewportHeight) {
if (hint == EnsureVisible)
hint = PositionAtTop;
} else if (verticalPosition - verticalOffset + cellHeight > viewportHeight) {
if (hint == EnsureVisible)
hint = PositionAtBottom;
}
if (verticalScrollMode() == QAbstractItemView::ScrollPerItem) {
if (hint == PositionAtBottom || hint == PositionAtCenter) {
int h = (hint == PositionAtCenter ? viewportHeight / 2 : viewportHeight);
int y = cellHeight;
while (verticalIndex > 0) {
int row = d->verticalHeader->logicalIndex(verticalIndex - 1);
y += d->verticalHeader->sectionSize(row);
if (y > h)
break;
--verticalIndex;
}
}
if (hint == PositionAtBottom || hint == PositionAtCenter || hint == PositionAtTop) {
int hiddenSections = 0;
if (d->verticalHeader->sectionsHidden()) {
for (int s = verticalIndex - 1; s >= 0; --s) {
int row = d->verticalHeader->logicalIndex(s);
if (d->verticalHeader->isSectionHidden(row))
++hiddenSections;
}
}
verticalScrollBar()->setValue(verticalIndex - hiddenSections);
}
} else { // ScrollPerPixel
if (hint == PositionAtTop) {
verticalScrollBar()->setValue(verticalPosition);
} else if (hint == PositionAtBottom) {
verticalScrollBar()->setValue(verticalPosition - viewportHeight + cellHeight);
} else if (hint == PositionAtCenter) {
verticalScrollBar()->setValue(verticalPosition - ((viewportHeight - cellHeight) / 2));
}
}
update(index);
}
/*!
This slot is called to change the height of the given \a row. The
old height is specified by \a oldHeight, and the new height by \a
newHeight.
\sa columnResized()
*/
void QTableView::rowResized(int row, int, int)
{
Q_D(QTableView);
d->rowsToUpdate.append(row);
if (d->rowResizeTimerID == 0)
d->rowResizeTimerID = startTimer(0);
}
/*!
This slot is called to change the width of the given \a column.
The old width is specified by \a oldWidth, and the new width by \a
newWidth.
\sa rowResized()
*/
void QTableView::columnResized(int column, int, int)
{
Q_D(QTableView);
d->columnsToUpdate.append(column);
if (d->columnResizeTimerID == 0)
d->columnResizeTimerID = startTimer(0);
}
/*!
\reimp
*/
void QTableView::timerEvent(QTimerEvent *event)
{
Q_D(QTableView);
if (event->timerId() == d->columnResizeTimerID) {
updateGeometries();
killTimer(d->columnResizeTimerID);
d->columnResizeTimerID = 0;
QRect rect;
int viewportHeight = d->viewport->height();
int viewportWidth = d->viewport->width();
if (d->hasSpans()) {
rect = QRect(0, 0, viewportWidth, viewportHeight);
} else {
for (int i = d->columnsToUpdate.size()-1; i >= 0; --i) {
int column = d->columnsToUpdate.at(i);
int x = columnViewportPosition(column);
if (isRightToLeft())
rect |= QRect(0, 0, x + columnWidth(column), viewportHeight);
else
rect |= QRect(x, 0, viewportWidth - x, viewportHeight);
}
}
d->viewport->update(rect.normalized());
d->columnsToUpdate.clear();
}
if (event->timerId() == d->rowResizeTimerID) {
updateGeometries();
killTimer(d->rowResizeTimerID);
d->rowResizeTimerID = 0;
int viewportHeight = d->viewport->height();
int viewportWidth = d->viewport->width();
int top;
if (d->hasSpans()) {
top = 0;
} else {
top = viewportHeight;
for (int i = d->rowsToUpdate.size()-1; i >= 0; --i) {
int y = rowViewportPosition(d->rowsToUpdate.at(i));
top = qMin(top, y);
}
}
d->viewport->update(QRect(0, top, viewportWidth, viewportHeight - top));
d->rowsToUpdate.clear();
}
QAbstractItemView::timerEvent(event);
}
/*!
This slot is called to change the index of the given \a row in the
table view. The old index is specified by \a oldIndex, and the new
index by \a newIndex.
\sa columnMoved()
*/
void QTableView::rowMoved(int, int oldIndex, int newIndex)
{
Q_D(QTableView);
updateGeometries();
int logicalOldIndex = d->verticalHeader->logicalIndex(oldIndex);
int logicalNewIndex = d->verticalHeader->logicalIndex(newIndex);
if (d->hasSpans()) {
d->viewport->update();
} else {
int oldTop = rowViewportPosition(logicalOldIndex);
int newTop = rowViewportPosition(logicalNewIndex);
int oldBottom = oldTop + rowHeight(logicalOldIndex);
int newBottom = newTop + rowHeight(logicalNewIndex);
int top = qMin(oldTop, newTop);
int bottom = qMax(oldBottom, newBottom);
int height = bottom - top;
d->viewport->update(0, top, d->viewport->width(), height);
}
}
/*!
This slot is called to change the index of the given \a column in
the table view. The old index is specified by \a oldIndex, and
the new index by \a newIndex.
\sa rowMoved()
*/
void QTableView::columnMoved(int, int oldIndex, int newIndex)
{
Q_D(QTableView);
updateGeometries();
int logicalOldIndex = d->horizontalHeader->logicalIndex(oldIndex);
int logicalNewIndex = d->horizontalHeader->logicalIndex(newIndex);
if (d->hasSpans()) {
d->viewport->update();
} else {
int oldLeft = columnViewportPosition(logicalOldIndex);
int newLeft = columnViewportPosition(logicalNewIndex);
int oldRight = oldLeft + columnWidth(logicalOldIndex);
int newRight = newLeft + columnWidth(logicalNewIndex);
int left = qMin(oldLeft, newLeft);
int right = qMax(oldRight, newRight);
int width = right - left;
d->viewport->update(left, 0, width, d->viewport->height());
}
}
/*!
Selects the given \a row in the table view if the current
SelectionMode and SelectionBehavior allows rows to be selected.
\sa selectColumn()
*/
void QTableView::selectRow(int row)
{
Q_D(QTableView);
d->selectRow(row, true);
}
/*!
Selects the given \a column in the table view if the current
SelectionMode and SelectionBehavior allows columns to be selected.
\sa selectRow()
*/
void QTableView::selectColumn(int column)
{
Q_D(QTableView);
d->selectColumn(column, true);
}
/*!
Hide the given \a row.
\sa showRow() hideColumn()
*/
void QTableView::hideRow(int row)
{
Q_D(QTableView);
d->verticalHeader->hideSection(row);
}
/*!
Hide the given \a column.
\sa showColumn() hideRow()
*/
void QTableView::hideColumn(int column)
{
Q_D(QTableView);
d->horizontalHeader->hideSection(column);
}
/*!
Show the given \a row.
\sa hideRow() showColumn()
*/
void QTableView::showRow(int row)
{
Q_D(QTableView);
d->verticalHeader->showSection(row);
}
/*!
Show the given \a column.
\sa hideColumn() showRow()
*/
void QTableView::showColumn(int column)
{
Q_D(QTableView);
d->horizontalHeader->showSection(column);
}
/*!
Resizes the given \a row based on the size hints of the delegate
used to render each item in the row.
*/
void QTableView::resizeRowToContents(int row)
{
Q_D(QTableView);
int content = sizeHintForRow(row);
int header = d->verticalHeader->sectionSizeHint(row);
d->verticalHeader->resizeSection(row, qMax(content, header));
}
/*!
Resizes all rows based on the size hints of the delegate
used to render each item in the rows.
*/
void QTableView::resizeRowsToContents()
{
Q_D(QTableView);
d->verticalHeader->resizeSections(QHeaderView::ResizeToContents);
}
/*!
Resizes the given \a column based on the size hints of the delegate
used to render each item in the column.
\note Only visible columns will be resized. Reimplement sizeHintForColumn()
to resize hidden columns as well.
*/
void QTableView::resizeColumnToContents(int column)
{
Q_D(QTableView);
int content = sizeHintForColumn(column);
int header = d->horizontalHeader->sectionSizeHint(column);
d->horizontalHeader->resizeSection(column, qMax(content, header));
}
/*!
Resizes all columns based on the size hints of the delegate
used to render each item in the columns.
*/
void QTableView::resizeColumnsToContents()
{
Q_D(QTableView);
d->horizontalHeader->resizeSections(QHeaderView::ResizeToContents);
}
/*!
\obsolete
\overload
Sorts the model by the values in the given \a column.
*/
void QTableView::sortByColumn(int column)
{
Q_D(QTableView);
if (column == -1)
return;
d->model->sort(column, d->horizontalHeader->sortIndicatorOrder());
}
/*!
\since 4.2
Sorts the model by the values in the given \a column in the given \a order.
\sa sortingEnabled
*/
void QTableView::sortByColumn(int column, Qt::SortOrder order)
{
Q_D(QTableView);
d->horizontalHeader->setSortIndicator(column, order);
sortByColumn(column);
}
/*!
\internal
*/
void QTableView::verticalScrollbarAction(int action)
{
QAbstractItemView::verticalScrollbarAction(action);
}
/*!
\internal
*/
void QTableView::horizontalScrollbarAction(int action)
{
QAbstractItemView::horizontalScrollbarAction(action);
}
/*!
\reimp
*/
bool QTableView::isIndexHidden(const QModelIndex &index) const
{
Q_D(const QTableView);
Q_ASSERT(d->isIndexValid(index));
if (isRowHidden(index.row()) || isColumnHidden(index.column()))
return true;
if (d->hasSpans()) {
QSpanCollection::Span span = d->span(index.row(), index.column());
return !((span.top() == index.row()) && (span.left() == index.column()));
}
return false;
}
/*!
\fn void QTableView::setSpan(int row, int column, int rowSpanCount, int columnSpanCount)
\since 4.2
Sets the span of the table element at (\a row, \a column) to the number of
rows and columns specified by (\a rowSpanCount, \a columnSpanCount).
\sa rowSpan(), columnSpan()
*/
void QTableView::setSpan(int row, int column, int rowSpan, int columnSpan)
{
Q_D(QTableView);
if (row < 0 || column < 0 || rowSpan < 0 || columnSpan < 0)
return;
d->setSpan(row, column, rowSpan, columnSpan);
d->viewport->update();
}
/*!
\since 4.2
Returns the row span of the table element at (\a row, \a column).
The default is 1.
\sa setSpan(), columnSpan()
*/
int QTableView::rowSpan(int row, int column) const
{
Q_D(const QTableView);
return d->rowSpan(row, column);
}
/*!
\since 4.2
Returns the column span of the table element at (\a row, \a
column). The default is 1.
\sa setSpan(), rowSpan()
*/
int QTableView::columnSpan(int row, int column) const
{
Q_D(const QTableView);
return d->columnSpan(row, column);
}
/*!
\since 4.4
Removes all row and column spans in the table view.
\sa setSpan()
*/
void QTableView::clearSpans()
{
Q_D(QTableView);
d->spans.clear();
d->viewport->update();
}
void QTableViewPrivate::_q_selectRow(int row)
{
selectRow(row, false);
}
void QTableViewPrivate::_q_selectColumn(int column)
{
selectColumn(column, false);
}
void QTableViewPrivate::selectRow(int row, bool anchor)
{
Q_Q(QTableView);
if (q->selectionBehavior() == QTableView::SelectColumns
|| (q->selectionMode() == QTableView::SingleSelection
&& q->selectionBehavior() == QTableView::SelectItems))
return;
if (row >= 0 && row < model->rowCount(root)) {
int column = horizontalHeader->logicalIndexAt(q->isRightToLeft() ? viewport->width() : 0);
QModelIndex index = model->index(row, column, root);
QItemSelectionModel::SelectionFlags command = q->selectionCommand(index);
selectionModel->setCurrentIndex(index, QItemSelectionModel::NoUpdate);
if ((anchor && !(command & QItemSelectionModel::Current))
|| (q->selectionMode() == QTableView::SingleSelection))
rowSectionAnchor = row;
if (q->selectionMode() != QTableView::SingleSelection
&& command.testFlag(QItemSelectionModel::Toggle)) {
if (anchor)
ctrlDragSelectionFlag = verticalHeader->selectionModel()->selectedRows().contains(index)
? QItemSelectionModel::Deselect : QItemSelectionModel::Select;
command &= ~QItemSelectionModel::Toggle;
command |= ctrlDragSelectionFlag;
if (!anchor)
command |= QItemSelectionModel::Current;
}
QModelIndex tl = model->index(qMin(rowSectionAnchor, row), 0, root);
QModelIndex br = model->index(qMax(rowSectionAnchor, row), model->columnCount(root) - 1, root);
if (verticalHeader->sectionsMoved() && tl.row() != br.row())
q->setSelection(q->visualRect(tl)|q->visualRect(br), command);
else
selectionModel->select(QItemSelection(tl, br), command);
}
}
void QTableViewPrivate::selectColumn(int column, bool anchor)
{
Q_Q(QTableView);
if (q->selectionBehavior() == QTableView::SelectRows
|| (q->selectionMode() == QTableView::SingleSelection
&& q->selectionBehavior() == QTableView::SelectItems))
return;
if (column >= 0 && column < model->columnCount(root)) {
int row = verticalHeader->logicalIndexAt(0);
QModelIndex index = model->index(row, column, root);
QItemSelectionModel::SelectionFlags command = q->selectionCommand(index);
selectionModel->setCurrentIndex(index, QItemSelectionModel::NoUpdate);
if ((anchor && !(command & QItemSelectionModel::Current))
|| (q->selectionMode() == QTableView::SingleSelection))
columnSectionAnchor = column;
if (q->selectionMode() != QTableView::SingleSelection
&& command.testFlag(QItemSelectionModel::Toggle)) {
if (anchor)
ctrlDragSelectionFlag = horizontalHeader->selectionModel()->selectedColumns().contains(index)
? QItemSelectionModel::Deselect : QItemSelectionModel::Select;
command &= ~QItemSelectionModel::Toggle;
command |= ctrlDragSelectionFlag;
if (!anchor)
command |= QItemSelectionModel::Current;
}
QModelIndex tl = model->index(0, qMin(columnSectionAnchor, column), root);
QModelIndex br = model->index(model->rowCount(root) - 1,
qMax(columnSectionAnchor, column), root);
if (horizontalHeader->sectionsMoved() && tl.column() != br.column())
q->setSelection(q->visualRect(tl)|q->visualRect(br), command);
else
selectionModel->select(QItemSelection(tl, br), command);
}
}
/*!
\reimp
*/
void QTableView::currentChanged(const QModelIndex ¤t, const QModelIndex &previous)
{
#ifndef QT_NO_ACCESSIBILITY
if (QAccessible::isActive()) {
if (current.isValid()) {
int entry = visualIndex(current) + 1;
if (horizontalHeader())
++entry;
QAccessible::updateAccessibility(viewport(), entry, QAccessible::Focus);
}
}
#endif
QAbstractItemView::currentChanged(current, previous);
}
/*!
\reimp
*/
void QTableView::selectionChanged(const QItemSelection &selected,
const QItemSelection &deselected)
{
#ifndef QT_NO_ACCESSIBILITY
if (QAccessible::isActive()) {
// ### does not work properly for selection ranges.
QModelIndex sel = selected.indexes().value(0);
if (sel.isValid()) {
int entry = visualIndex(sel);
if (horizontalHeader())
++entry;
QAccessible::updateAccessibility(viewport(), entry, QAccessible::Selection);
}
QModelIndex desel = deselected.indexes().value(0);
if (desel.isValid()) {
int entry = visualIndex(sel);
if (horizontalHeader())
++entry;
QAccessible::updateAccessibility(viewport(), entry, QAccessible::SelectionRemove);
}
}
#endif
QAbstractItemView::selectionChanged(selected, deselected);
}
int QTableView::visualIndex(const QModelIndex &index) const
{
return index.row();
}
QT_END_NAMESPACE
#include "qtableview.moc"
#include "moc_qtableview.cpp"
#endif // QT_NO_TABLEVIEW