/****************************************************************************
**
** 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 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 <qglobal.h>
#ifndef QT_NO_COLUMNVIEW
#include "qcolumnview.h"
#include "qcolumnview_p.h"
#include "qcolumnviewgrip_p.h"
#include <qlistview.h>
#include <qabstractitemdelegate.h>
#include <qscrollbar.h>
#include <qpainter.h>
#include <qdebug.h>
QT_BEGIN_NAMESPACE
#define ANIMATION_DURATION_MSEC 150
/*!
\since 4.3
\class QColumnView
\brief The QColumnView class provides a model/view implementation of a column view.
\ingroup model-view
\ingroup advanced
QColumnView displays a model in a number of QListViews, one for each
hierarchy in the tree. This is sometimes referred to as a cascading list.
The QColumnView class is one of the \l{Model/View Classes}
and is part of Qt's \l{Model/View Programming}{model/view framework}.
QColumnView implements the interfaces defined by the
QAbstractItemView class to allow it to display data provided by
models derived from the QAbstractItemModel class.
\image qcolumnview.png
\sa \link model-view-programming.html Model/View Programming\endlink
*/
/*!
Constructs a column view with a \a parent to represent a model's
data. Use setModel() to set the model.
\sa QAbstractItemModel
*/
QColumnView::QColumnView(QWidget * parent)
: QAbstractItemView(*new QColumnViewPrivate, parent)
{
Q_D(QColumnView);
d->initialize();
}
/*!
\internal
*/
QColumnView::QColumnView(QColumnViewPrivate & dd, QWidget * parent)
: QAbstractItemView(dd, parent)
{
Q_D(QColumnView);
d->initialize();
}
void QColumnViewPrivate::initialize()
{
Q_Q(QColumnView);
q->setTextElideMode(Qt::ElideMiddle);
#ifndef QT_NO_ANIMATION
QObject::connect(¤tAnimation, SIGNAL(finished()), q, SLOT(_q_changeCurrentColumn()));
currentAnimation.setDuration(ANIMATION_DURATION_MSEC);
currentAnimation.setTargetObject(hbar);
currentAnimation.setPropertyName("value");
currentAnimation.setEasingCurve(QEasingCurve::InOutQuad);
#endif //QT_NO_ANIMATION
delete itemDelegate;
q->setItemDelegate(new QColumnViewDelegate(q));
}
/*!
Destroys the column view.
*/
QColumnView::~QColumnView()
{
}
/*!
\property QColumnView::resizeGripsVisible
\brief the way to specify if the list views gets resize grips or not
By default, \c visible is set to true
\sa setRootIndex()
*/
void QColumnView::setResizeGripsVisible(bool visible)
{
Q_D(QColumnView);
if (d->showResizeGrips == visible)
return;
d->showResizeGrips = visible;
for (int i = 0; i < d->columns.count(); ++i) {
QAbstractItemView *view = d->columns[i];
if (visible) {
QColumnViewGrip *grip = new QColumnViewGrip(view);
view->setCornerWidget(grip);
connect(grip, SIGNAL(gripMoved(int)), this, SLOT(_q_gripMoved(int)));
} else {
QWidget *widget = view->cornerWidget();
view->setCornerWidget(0);
widget->deleteLater();
}
}
}
bool QColumnView::resizeGripsVisible() const
{
Q_D(const QColumnView);
return d->showResizeGrips;
}
/*!
\reimp
*/
void QColumnView::setModel(QAbstractItemModel *model)
{
Q_D(QColumnView);
if (model == d->model)
return;
d->closeColumns();
QAbstractItemView::setModel(model);
}
/*!
\reimp
*/
void QColumnView::setRootIndex(const QModelIndex &index)
{
Q_D(QColumnView);
if (!model())
return;
d->closeColumns();
Q_ASSERT(d->columns.count() == 0);
QAbstractItemView *view = d->createColumn(index, true);
if (view->selectionModel())
view->selectionModel()->deleteLater();
if (view->model())
view->setSelectionModel(selectionModel());
QAbstractItemView::setRootIndex(index);
d->updateScrollbars();
}
/*!
\reimp
*/
bool QColumnView::isIndexHidden(const QModelIndex &index) const
{
Q_UNUSED(index);
return false;
}
/*!
\reimp
*/
QModelIndex QColumnView::indexAt(const QPoint &point) const
{
Q_D(const QColumnView);
for (int i = 0; i < d->columns.size(); ++i) {
QPoint topLeft = d->columns.at(i)->frameGeometry().topLeft();
QPoint adjustedPoint(point.x() - topLeft.x(), point.y() - topLeft.y());
QModelIndex index = d->columns.at(i)->indexAt(adjustedPoint);
if (index.isValid())
return index;
}
return QModelIndex();
}
/*!
\reimp
*/
QRect QColumnView::visualRect(const QModelIndex &index) const
{
if (!index.isValid())
return QRect();
Q_D(const QColumnView);
for (int i = 0; i < d->columns.size(); ++i) {
QRect rect = d->columns.at(i)->visualRect(index);
if (!rect.isNull()) {
rect.translate(d->columns.at(i)->frameGeometry().topLeft());
return rect;
}
}
return QRect();
}
/*!
\reimp
*/
void QColumnView::scrollContentsBy(int dx, int dy)
{
Q_D(QColumnView);
if (d->columns.isEmpty() || dx == 0)
return;
dx = isRightToLeft() ? -dx : dx;
for (int i = 0; i < d->columns.count(); ++i)
d->columns.at(i)->move(d->columns.at(i)->x() + dx, 0);
d->offset += dx;
QAbstractItemView::scrollContentsBy(dx, dy);
}
/*!
\reimp
*/
void QColumnView::scrollTo(const QModelIndex &index, ScrollHint hint)
{
Q_D(QColumnView);
Q_UNUSED(hint);
if (!index.isValid() || d->columns.isEmpty())
return;
#ifndef QT_NO_ANIMATION
if (d->currentAnimation.state() == QPropertyAnimation::Running)
return;
d->currentAnimation.stop();
#endif //QT_NO_ANIMATION
// Fill up what is needed to get to index
d->closeColumns(index, true);
QModelIndex indexParent = index.parent();
// Find the left edge of the column that contains index
int currentColumn = 0;
int leftEdge = 0;
while (currentColumn < d->columns.size()) {
if (indexParent == d->columns.at(currentColumn)->rootIndex())
break;
leftEdge += d->columns.at(currentColumn)->width();
++currentColumn;
}
// Don't let us scroll above the root index
if (currentColumn == d->columns.size())
return;
int indexColumn = currentColumn;
// Find the width of what we want to show (i.e. the right edge)
int visibleWidth = d->columns.at(currentColumn)->width();
// We want to always try to show two columns
if (currentColumn + 1 < d->columns.size()) {
++currentColumn;
visibleWidth += d->columns.at(currentColumn)->width();
}
int rightEdge = leftEdge + visibleWidth;
if (isRightToLeft()) {
leftEdge = viewport()->width() - leftEdge;
rightEdge = leftEdge - visibleWidth;
qSwap(rightEdge, leftEdge);
}
// If it is already visible don't animate
if (leftEdge > -horizontalOffset()
&& rightEdge <= ( -horizontalOffset() + viewport()->size().width())) {
d->columns.at(indexColumn)->scrollTo(index);
d->_q_changeCurrentColumn();
return;
}
int newScrollbarValue = 0;
if (isRightToLeft()) {
if (leftEdge < 0) {
// scroll to the right
newScrollbarValue = viewport()->size().width() - leftEdge;
} else {
// scroll to the left
newScrollbarValue = rightEdge + horizontalOffset();
}
} else {
if (leftEdge > -horizontalOffset()) {
// scroll to the right
newScrollbarValue = rightEdge - viewport()->size().width();
} else {
// scroll to the left
newScrollbarValue = leftEdge;
}
}
#ifndef QT_NO_ANIMATION
d->currentAnimation.setEndValue(newScrollbarValue);
d->currentAnimation.start();
#else
horizontalScrollBar()->setValue(newScrollbarValue);
#endif //QT_NO_ANIMATION
}
/*!
\reimp
Move left should go to the parent index
Move right should go to the child index or down if there is no child
*/
QModelIndex QColumnView::moveCursor(CursorAction cursorAction, Qt::KeyboardModifiers modifiers)
{
// the child views which have focus get to deal with this first and if
// they don't accept it then it comes up this view and we only grip left/right
Q_UNUSED(modifiers);
if (!model())
return QModelIndex();
QModelIndex current = currentIndex();
if (isRightToLeft()) {
if (cursorAction == MoveLeft)
cursorAction = MoveRight;
else if (cursorAction == MoveRight)
cursorAction = MoveLeft;
}
switch (cursorAction) {
case MoveLeft:
if (current.parent().isValid() && current.parent() != rootIndex())
return (current.parent());
else
return current;
break;
case MoveRight:
if (model()->hasChildren(current))
return model()->index(0, 0, current);
else
return current.sibling(current.row() + 1, current.column());
break;
default:
break;
}
return QModelIndex();
}
/*!
\reimp
*/
void QColumnView::resizeEvent(QResizeEvent *event)
{
Q_D(QColumnView);
d->doLayout();
d->updateScrollbars();
if (!isRightToLeft()) {
int diff = event->oldSize().width() - event->size().width();
if (diff < 0 && horizontalScrollBar()->isVisible()
&& horizontalScrollBar()->value() == horizontalScrollBar()->maximum()) {
horizontalScrollBar()->setMaximum(horizontalScrollBar()->maximum() + diff);
}
}
QAbstractItemView::resizeEvent(event);
}
/*!
\internal
*/
void QColumnViewPrivate::updateScrollbars()
{
Q_Q(QColumnView);
#ifndef QT_NO_ANIMATION
if (currentAnimation.state() == QPropertyAnimation::Running)
return;
#endif //QT_NO_ANIMATION
// find the total horizontal length of the laid out columns
int horizontalLength = 0;
if (!columns.isEmpty()) {
horizontalLength = (columns.last()->x() + columns.last()->width()) - columns.first()->x();
if (horizontalLength <= 0) // reverse mode
horizontalLength = (columns.first()->x() + columns.first()->width()) - columns.last()->x();
}
QSize viewportSize = viewport->size();
if (horizontalLength < viewportSize.width() && hbar->value() == 0) {
hbar->setRange(0, 0);
} else {
int visibleLength = qMin(horizontalLength + q->horizontalOffset(), viewportSize.width());
int hiddenLength = horizontalLength - visibleLength;
if (hiddenLength != hbar->maximum())
hbar->setRange(0, hiddenLength);
}
if (!columns.isEmpty()) {
int pageStepSize = columns.at(0)->width();
if (pageStepSize != hbar->pageStep())
hbar->setPageStep(pageStepSize);
}
bool visible = (hbar->maximum() > 0);
if (visible != hbar->isVisible())
hbar->setVisible(visible);
}
/*!
\reimp
*/
int QColumnView::horizontalOffset() const
{
Q_D(const QColumnView);
return d->offset;
}
/*!
\reimp
*/
int QColumnView::verticalOffset() const
{
return 0;
}
/*!
\reimp
*/
QRegion QColumnView::visualRegionForSelection(const QItemSelection &selection) const
{
int ranges = selection.count();
if (ranges == 0)
return QRect();
// Note that we use the top and bottom functions of the selection range
// since the data is stored in rows.
int firstRow = selection.at(0).top();
int lastRow = selection.at(0).top();
for (int i = 0; i < ranges; ++i) {
firstRow = qMin(firstRow, selection.at(i).top());
lastRow = qMax(lastRow, selection.at(i).bottom());
}
QModelIndex firstIdx = model()->index(qMin(firstRow, lastRow), 0, rootIndex());
QModelIndex lastIdx = model()->index(qMax(firstRow, lastRow), 0, rootIndex());
if (firstIdx == lastIdx)
return visualRect(firstIdx);
QRegion firstRegion = visualRect(firstIdx);
QRegion lastRegion = visualRect(lastIdx);
return firstRegion.unite(lastRegion);
}
/*!
\reimp
*/
void QColumnView::setSelection(const QRect &rect, QItemSelectionModel::SelectionFlags command)
{
Q_UNUSED(rect);
Q_UNUSED(command);
}
/*!
\reimp
*/
void QColumnView::setSelectionModel(QItemSelectionModel *newSelectionModel)
{
Q_D(const QColumnView);
for (int i = 0; i < d->columns.size(); ++i) {
if (d->columns.at(i)->selectionModel() == selectionModel()) {
d->columns.at(i)->setSelectionModel(newSelectionModel);
break;
}
}
QAbstractItemView::setSelectionModel(newSelectionModel);
}
/*!
\reimp
*/
QSize QColumnView::sizeHint() const
{
Q_D(const QColumnView);
QSize sizeHint;
for (int i = 0; i < d->columns.size(); ++i) {
sizeHint += d->columns.at(i)->sizeHint();
}
return sizeHint.expandedTo(QAbstractItemView::sizeHint());
}
/*!
\internal
Move all widgets from the corner grip and to the right
*/
void QColumnViewPrivate::_q_gripMoved(int offset)
{
Q_Q(QColumnView);
QObject *grip = q->sender();
Q_ASSERT(grip);
if (q->isRightToLeft())
offset = -1 * offset;
bool found = false;
for (int i = 0; i < columns.size(); ++i) {
if (!found && columns.at(i)->cornerWidget() == grip) {
found = true;
columnSizes[i] = columns.at(i)->width();
if (q->isRightToLeft())
columns.at(i)->move(columns.at(i)->x() + offset, 0);
continue;
}
if (!found)
continue;
int currentX = columns.at(i)->x();
columns.at(i)->move(currentX + offset, 0);
}
updateScrollbars();
}
/*!
\internal
Find where the current columns intersect parent's columns
Delete any extra columns and insert any needed columns.
*/
void QColumnViewPrivate::closeColumns(const QModelIndex &parent, bool build)
{
if (columns.isEmpty())
return;
bool clearAll = !parent.isValid();
bool passThroughRoot = false;
QList<QModelIndex> dirsToAppend;
// Find the last column that matches the parent's tree
int currentColumn = -1;
QModelIndex parentIndex = parent;
while (currentColumn == -1 && parentIndex.isValid()) {
if (columns.isEmpty())
break;
parentIndex = parentIndex.parent();
if (root == parentIndex)
passThroughRoot = true;
if (!parentIndex.isValid())
break;
for (int i = columns.size() - 1; i >= 0; --i) {
if (columns.at(i)->rootIndex() == parentIndex) {
currentColumn = i;
break;
}
}
if (currentColumn == -1)
dirsToAppend.append(parentIndex);
}
// Someone wants to go to an index that can be reached without changing
// the root index, don't allow them
if (!clearAll && !passThroughRoot && currentColumn == -1)
return;
if (currentColumn == -1 && parent.isValid())
currentColumn = 0;
// Optimization so we don't go deleting and then creating the same thing
bool alreadyExists = false;
if (build && columns.size() > currentColumn + 1) {
bool viewingParent = (columns.at(currentColumn + 1)->rootIndex() == parent);
bool viewingChild = (!model->hasChildren(parent)
&& !columns.at(currentColumn + 1)->rootIndex().isValid());
if (viewingParent || viewingChild) {
currentColumn++;
alreadyExists = true;
}
}
// Delete columns that don't match our path
for (int i = columns.size() - 1; i > currentColumn; --i) {
QAbstractItemView* notShownAnymore = columns.at(i);
columns.removeAt(i);
notShownAnymore->setVisible(false);
if (notShownAnymore != previewColumn)
notShownAnymore->deleteLater();
}
if (columns.isEmpty()) {
offset = 0;
updateScrollbars();
}
// Now fill in missing columns
while (!dirsToAppend.isEmpty()) {
QAbstractItemView *newView = createColumn(dirsToAppend.takeLast(), true);
if (!dirsToAppend.isEmpty())
newView->setCurrentIndex(dirsToAppend.last());
}
if (build && !alreadyExists)
createColumn(parent, false);
}
void QColumnViewPrivate::_q_clicked(const QModelIndex &index)
{
Q_Q(QColumnView);
QModelIndex parent = index.parent();
QAbstractItemView *columnClicked = 0;
for (int column = 0; column < columns.count(); ++column) {
if (columns.at(column)->rootIndex() == parent) {
columnClicked = columns[column];
break;
}
}
if (q->selectionModel() && columnClicked) {
QItemSelectionModel::SelectionFlags flags = QItemSelectionModel::Current;
if (columnClicked->selectionModel()->isSelected(index))
flags |= QItemSelectionModel::Select;
q->selectionModel()->setCurrentIndex(index, flags);
}
}
/*!
\internal
Create a new column for \a index. A grip is attached if requested and it is shown
if requested.
Return the new view
\sa createColumn() setPreviewWidget()
\sa doLayout()
*/
QAbstractItemView *QColumnViewPrivate::createColumn(const QModelIndex &index, bool show)
{
Q_Q(QColumnView);
QAbstractItemView *view = 0;
if (model->hasChildren(index)) {
view = q->createColumn(index);
q->connect(view, SIGNAL(clicked(QModelIndex)),
q, SLOT(_q_clicked(QModelIndex)));
} else {
if (!previewColumn)
setPreviewWidget(new QWidget(q));
view = previewColumn;
view->setMinimumWidth(qMax(view->minimumWidth(), previewWidget->minimumWidth()));
}
q->connect(view, SIGNAL(activated(QModelIndex)),
q, SIGNAL(activated(QModelIndex)));
q->connect(view, SIGNAL(clicked(QModelIndex)),
q, SIGNAL(clicked(QModelIndex)));
q->connect(view, SIGNAL(doubleClicked(QModelIndex)),
q, SIGNAL(doubleClicked(QModelIndex)));
q->connect(view, SIGNAL(entered(QModelIndex)),
q, SIGNAL(entered(QModelIndex)));
q->connect(view, SIGNAL(pressed(QModelIndex)),
q, SIGNAL(pressed(QModelIndex)));
view->setFocusPolicy(Qt::NoFocus);
view->setParent(viewport);
Q_ASSERT(view);
// Setup corner grip
if (showResizeGrips) {
QColumnViewGrip *grip = new QColumnViewGrip(view);
view->setCornerWidget(grip);
q->connect(grip, SIGNAL(gripMoved(int)), q, SLOT(_q_gripMoved(int)));
}
if (columnSizes.count() > columns.count()) {
view->setGeometry(0, 0, columnSizes.at(columns.count()), viewport->height());
} else {
int initialWidth = view->sizeHint().width();
if (q->isRightToLeft())
view->setGeometry(viewport->width() - initialWidth, 0, initialWidth, viewport->height());
else
view->setGeometry(0, 0, initialWidth, viewport->height());
columnSizes.resize(qMax(columnSizes.count(), columns.count() + 1));
columnSizes[columns.count()] = initialWidth;
}
if (!columns.isEmpty() && columns.last()->isHidden())
columns.last()->setVisible(true);
columns.append(view);
doLayout();
updateScrollbars();
if (show && view->isHidden())
view->setVisible(true);
return view;
}
/*!
\fn void QColumnView::updatePreviewWidget(const QModelIndex &index)
This signal is emitted when the preview widget should be updated to
provide rich information about \a index
\sa previewWidget()
*/
/*!
To use a custom widget for the final column when you select
an item overload this function and return a widget.
\a index is the root index that will be assigned to the view.
Return the new view. QColumnView will automatically take ownership of the widget.
\sa setPreviewWidget()
*/
QAbstractItemView *QColumnView::createColumn(const QModelIndex &index)
{
QListView *view = new QListView(viewport());
initializeColumn(view);
view->setRootIndex(index);
if (model()->canFetchMore(index))
model()->fetchMore(index);
return view;
}
/*!
Copies the behavior and options of the column view and applies them to
the \a column such as the iconSize(), textElideMode() and
alternatingRowColors(). This can be useful when reimplementing
createColumn().
\since 4.4
\sa createColumn()
*/
void QColumnView::initializeColumn(QAbstractItemView *column) const
{
Q_D(const QColumnView);
column->setFrameShape(QFrame::NoFrame);
column->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
column->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
column->setMinimumWidth(100);
column->setAttribute(Qt::WA_MacShowFocusRect, false);
#ifndef QT_NO_DRAGANDDROP
column->setDragDropMode(dragDropMode());
column->setDragDropOverwriteMode(dragDropOverwriteMode());
column->setDropIndicatorShown(showDropIndicator());
#endif
column->setAlternatingRowColors(alternatingRowColors());
column->setAutoScroll(hasAutoScroll());
column->setEditTriggers(editTriggers());
column->setHorizontalScrollMode(horizontalScrollMode());
column->setIconSize(iconSize());
column->setSelectionBehavior(selectionBehavior());
column->setSelectionMode(selectionMode());
column->setTabKeyNavigation(tabKeyNavigation());
column->setTextElideMode(textElideMode());
column->setVerticalScrollMode(verticalScrollMode());
column->setModel(model());
// Copy the custom delegate per row
QMapIterator<int, QPointer<QAbstractItemDelegate> > i(d->rowDelegates);
while (i.hasNext()) {
i.next();
column->setItemDelegateForRow(i.key(), i.value());
}
// set the delegate to be the columnview delegate
QAbstractItemDelegate *delegate = column->itemDelegate();
column->setItemDelegate(d->itemDelegate);
delete delegate;
}
/*!
Returns the preview widget, or 0 if there is none.
\sa setPreviewWidget(), updatePreviewWidget()
*/
QWidget *QColumnView::previewWidget() const
{
Q_D(const QColumnView);
return d->previewWidget;
}
/*!
Sets the preview \a widget.
The \a widget becomes a child of the column view, and will be
destroyed when the column area is deleted or when a new widget is
set.
\sa previewWidget(), updatePreviewWidget()
*/
void QColumnView::setPreviewWidget(QWidget *widget)
{
Q_D(QColumnView);
d->setPreviewWidget(widget);
}
/*!
\internal
*/
void QColumnViewPrivate::setPreviewWidget(QWidget *widget)
{
Q_Q(QColumnView);
if (previewColumn) {
if (!columns.isEmpty() && columns.last() == previewColumn)
columns.removeLast();
previewColumn->deleteLater();
}
QColumnViewPreviewColumn *column = new QColumnViewPreviewColumn(q);
column->setPreviewWidget(widget);
previewColumn = column;
previewColumn->hide();
previewColumn->setFrameShape(QFrame::NoFrame);
previewColumn->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
previewColumn->setSelectionMode(QAbstractItemView::NoSelection);
previewColumn->setMinimumWidth(qMax(previewColumn->verticalScrollBar()->width(),
previewColumn->minimumWidth()));
previewWidget = widget;
previewWidget->setParent(previewColumn->viewport());
}
/*!
Sets the column widths to the values given in the \a list. Extra values in the list are
kept and used when the columns are created.
If list contains too few values, only width of the rest of the columns will not be modified.
\sa columnWidths(), createColumn()
*/
void QColumnView::setColumnWidths(const QList<int> &list)
{
Q_D(QColumnView);
int i = 0;
for (; (i < list.count() && i < d->columns.count()); ++i) {
d->columns.at(i)->resize(list.at(i), d->columns.at(i)->height());
d->columnSizes[i] = list.at(i);
}
for (; i < list.count(); ++i)
d->columnSizes.append(list.at(i));
}
/*!
Returns a list of the width of all the columns in this view.
\sa setColumnWidths()
*/
QList<int> QColumnView::columnWidths() const
{
Q_D(const QColumnView);
QList<int> list;
for (int i = 0; i < d->columns.count(); ++i)
list.append(d->columnSizes.at(i));
return list;
}
/*!
\reimp
*/
void QColumnView::rowsInserted(const QModelIndex &parent, int start, int end)
{
QAbstractItemView::rowsInserted(parent, start, end);
d_func()->checkColumnCreation(parent);
}
/*!
\reimp
*/
void QColumnView::currentChanged(const QModelIndex ¤t, const QModelIndex &previous)
{
Q_D(QColumnView);
if (!current.isValid()) {
QAbstractItemView::currentChanged(current, previous);
return;
}
QModelIndex currentParent = current.parent();
// optimize for just moving up/down in a list where the child view doesn't change
if (currentParent == previous.parent()
&& model()->hasChildren(current) && model()->hasChildren(previous)) {
for (int i = 0; i < d->columns.size(); ++i) {
if (currentParent == d->columns.at(i)->rootIndex()) {
if (d->columns.size() > i + 1) {
QAbstractItemView::currentChanged(current, previous);
return;
}
break;
}
}
}
// Scrolling to the right we need to have an empty spot
bool found = false;
if (currentParent == previous) {
for (int i = 0; i < d->columns.size(); ++i) {
if (currentParent == d->columns.at(i)->rootIndex()) {
found = true;
if (d->columns.size() < i + 2) {
d->createColumn(current, false);
}
break;
}
}
}
if (!found)
d->closeColumns(current, true);
if (!model()->hasChildren(current))
emit updatePreviewWidget(current);
QAbstractItemView::currentChanged(current, previous);
}
/*
We have change the current column and need to update focus and selection models
on the new current column.
*/
void QColumnViewPrivate::_q_changeCurrentColumn()
{
Q_Q(QColumnView);
if (columns.isEmpty())
return;
QModelIndex current = q->currentIndex();
if (!current.isValid())
return;
// We might have scrolled far to the left so we need to close all of the children
closeColumns(current, true);
// Set up the "current" column with focus
int currentColumn = qMax(0, columns.size() - 2);
QAbstractItemView *parentColumn = columns.at(currentColumn);
if (q->hasFocus())
parentColumn->setFocus(Qt::OtherFocusReason);
q->setFocusProxy(parentColumn);
// find the column that is our current selection model and give it a new one.
for (int i = 0; i < columns.size(); ++i) {
if (columns.at(i)->selectionModel() == q->selectionModel()) {
QItemSelectionModel *replacementSelectionModel =
new QItemSelectionModel(parentColumn->model());
replacementSelectionModel->setCurrentIndex(
q->selectionModel()->currentIndex(), QItemSelectionModel::Current);
replacementSelectionModel->select(
q->selectionModel()->selection(), QItemSelectionModel::Select);
QAbstractItemView *view = columns.at(i);
view->setSelectionModel(replacementSelectionModel);
view->setFocusPolicy(Qt::NoFocus);
if (columns.size() > i + 1)
view->setCurrentIndex(columns.at(i+1)->rootIndex());
break;
}
}
parentColumn->selectionModel()->deleteLater();
parentColumn->setFocusPolicy(Qt::StrongFocus);
parentColumn->setSelectionModel(q->selectionModel());
// We want the parent selection to stay highlighted (but dimmed depending upon the color theme)
if (currentColumn > 0) {
parentColumn = columns.at(currentColumn - 1);
if (parentColumn->currentIndex() != current.parent())
parentColumn->setCurrentIndex(current.parent());
}
if (columns.last()->isHidden()) {
columns.last()->setVisible(true);
}
if (columns.last()->selectionModel())
columns.last()->selectionModel()->clear();
updateScrollbars();
}
/*!
\reimp
*/
void QColumnView::selectAll()
{
if (!model() || !selectionModel())
return;
QModelIndexList indexList = selectionModel()->selectedIndexes();
QModelIndex parent = rootIndex();
QItemSelection selection;
if (indexList.count() >= 1)
parent = indexList.at(0).parent();
if (indexList.count() == 1) {
parent = indexList.at(0);
if (!model()->hasChildren(parent))
parent = parent.parent();
else
selection.append(QItemSelectionRange(parent, parent));
}
QModelIndex tl = model()->index(0, 0, parent);
QModelIndex br = model()->index(model()->rowCount(parent) - 1,
model()->columnCount(parent) - 1,
parent);
selection.append(QItemSelectionRange(tl, br));
selectionModel()->select(selection, QItemSelectionModel::ClearAndSelect);
}
/*
* private object implementation
*/
QColumnViewPrivate::QColumnViewPrivate()
: QAbstractItemViewPrivate()
,showResizeGrips(true)
,offset(0)
,previewWidget(0)
,previewColumn(0)
{
}
QColumnViewPrivate::~QColumnViewPrivate()
{
}
/*!
\internal
*/
void QColumnViewPrivate::_q_columnsInserted(const QModelIndex &parent, int start, int end)
{
QAbstractItemViewPrivate::_q_columnsInserted(parent, start, end);
checkColumnCreation(parent);
}
/*!
\internal
Makes sure we create a corresponding column as a result of changing the model.
*/
void QColumnViewPrivate::checkColumnCreation(const QModelIndex &parent)
{
if (parent == q_func()->currentIndex() && model->hasChildren(parent)) {
//the parent has children and is the current
//let's try to find out if there is already a mapping that is good
for (int i = 0; i < columns.count(); ++i) {
QAbstractItemView *view = columns.at(i);
if (view->rootIndex() == parent) {
if (view == previewColumn) {
//let's recreate the parent
closeColumns(parent, false);
createColumn(parent, true /*show*/);
}
break;
}
}
}
}
/*!
\internal
Place all of the columns where they belong inside of the viewport, resize as necessary.
*/
void QColumnViewPrivate::doLayout()
{
Q_Q(QColumnView);
if (!model || columns.isEmpty())
return;
int viewportHeight = viewport->height();
int x = columns.at(0)->x();
if (q->isRightToLeft()) {
x = viewport->width() + q->horizontalOffset();
for (int i = 0; i < columns.size(); ++i) {
QAbstractItemView *view = columns.at(i);
x -= view->width();
if (x != view->x() || viewportHeight != view->height())
view->setGeometry(x, 0, view->width(), viewportHeight);
}
} else {
for (int i = 0; i < columns.size(); ++i) {
QAbstractItemView *view = columns.at(i);
int currentColumnWidth = view->width();
if (x != view->x() || viewportHeight != view->height())
view->setGeometry(x, 0, currentColumnWidth, viewportHeight);
x += currentColumnWidth;
}
}
}
/*!
\internal
Draws a delegate with a > if an object has children.
\sa {Model/View Programming}, QItemDelegate
*/
void QColumnViewDelegate::paint(QPainter *painter,
const QStyleOptionViewItem &option,
const QModelIndex &index) const
{
drawBackground(painter, option, index );
bool reverse = (option.direction == Qt::RightToLeft);
int width = ((option.rect.height() * 2) / 3);
// Modify the options to give us room to add an arrow
QStyleOptionViewItemV4 opt = option;
if (reverse)
opt.rect.adjust(width,0,0,0);
else
opt.rect.adjust(0,0,-width,0);
if (!(index.model()->flags(index) & Qt::ItemIsEnabled)) {
opt.showDecorationSelected = true;
opt.state |= QStyle::State_Selected;
}
QItemDelegate::paint(painter, opt, index);
if (reverse)
opt.rect = QRect(option.rect.x(), option.rect.y(), width, option.rect.height());
else
opt.rect = QRect(option.rect.x() + option.rect.width() - width, option.rect.y(),
width, option.rect.height());
// Draw >
if (index.model()->hasChildren(index)) {
const QWidget *view = opt.widget;
QStyle *style = view ? view->style() : QApplication::style();
style->drawPrimitive(QStyle::PE_IndicatorColumnViewArrow, &opt, painter, view);
}
}
QT_END_NAMESPACE
#include "moc_qcolumnview.cpp"
#endif // QT_NO_COLUMNVIEW