qlistview.cpp

奇趣公司比较新的qt/emd版本

                    } else {
                        right.setBottom(left.top() - 1);
                    }
                }

                // do the selections
                QItemSelection topSelection = d->selection(first);
                QItemSelection middleSelection = d->selection(middle);
                QItemSelection bottomSelection = d->selection(last);
                // merge
                selection.merge(topSelection, QItemSelectionModel::Select);
                selection.merge(middleSelection, QItemSelectionModel::Select);
                selection.merge(bottomSelection, QItemSelectionModel::Select);
            }
        }
    }

    d->selectionModel->select(selection, command);
}

/*!
  \reimp
*/
QRegion QListView::visualRegionForSelection(const QItemSelection &selection) const
{
    Q_D(const QListView);
    // ### NOTE: this is a potential bottleneck in non-static mode
    int c = d->column;
    QRegion selectionRegion;
    for (int i = 0; i < selection.count(); ++i) {
        if (!selection.at(i).isValid())
            continue;
        QModelIndex parent = selection.at(i).topLeft().parent();
        int t = selection.at(i).topLeft().row();
        int b = selection.at(i).bottomRight().row();
        if (d->viewMode == IconMode || d->isWrapping()) { // in non-static mode, we have to go through all selected items
            for (int r = t; r <= b; ++r)
                selectionRegion += QRegion(visualRect(d->model->index(r, c, parent)));
        } else { // in static mode, we can optimize a bit
            while (t <= b && d->hiddenRows.contains(t)) ++t;
            while (b >= t && d->hiddenRows.contains(b)) --b;
            const QModelIndex top = d->model->index(t, c, d->root);
            const QModelIndex bottom = d->model->index(b, c, d->root);
            QRect rect(visualRect(top).topLeft(),
                       visualRect(bottom).bottomRight());
            selectionRegion += QRegion(rect);
        }
    }

    return selectionRegion;
}

/*!
  \reimp
*/
QModelIndexList QListView::selectedIndexes() const
{
    Q_D(const QListView);
    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 && index.column() == d->column)
            viewSelected.append(index);
    }
    return viewSelected;
}

/*!
    \internal

    Layout the items according to the flow and wrapping properties.
*/
void QListView::doItemsLayout()
{
    Q_D(QListView);
    if (d->model->columnCount(d->root) > 0) { // no columns means no contents
        d->resetBatchStartRow();
        if (layoutMode() == SinglePass)
            d->doItemsLayout(d->model->rowCount(d->root)); // layout everything
        else if (!d->batchLayoutTimer.isActive()) {
            if (!d->doItemsLayout(d->batchSize)) // layout is done
                d->batchLayoutTimer.start(0, this); // do a new batch as fast as possible
        }
    }
    QAbstractItemView::doItemsLayout();
}

/*!
  \internal
*/
void QListView::updateGeometries()
{
    Q_D(QListView);
    if (d->model->rowCount(d->root) <= 0 || d->model->columnCount(d->root) <= 0) {
        horizontalScrollBar()->setRange(0, 0);
        verticalScrollBar()->setRange(0, 0);
    } else {
        QModelIndex index = d->model->index(0, d->column, d->root);
        QStyleOptionViewItemV3 option = d->viewOptionsV3();
        QSize step = d->itemSize(option, index);

        QSize csize = d->contentsSize();
        QSize vsize = d->viewport->size();
        QSize max = maximumViewportSize();
        if (max.width() >= d->contentsSize().width() && max.height() >= d->contentsSize().height())
            vsize = max;

        // ### reorder the logic

        // ### split into static and dynamic

        const bool vertical = verticalScrollMode() == QAbstractItemView::ScrollPerItem;
        const bool horizontal = horizontalScrollMode() == QAbstractItemView::ScrollPerItem;

        if (d->flow == TopToBottom) {
            if (horizontal && d->isWrapping() && d->viewMode == ListMode) {
                const QVector<int> segmentPositions = d->staticListView->segmentPositions;
                const int steps = segmentPositions.count();
                if (steps > 1) {
                    int lastSegmentWidth = segmentPositions.at(steps - 1) - segmentPositions.at(steps - 2);
                    int pageSteps = d->staticListView->perItemScrollingPageSteps(vsize.width(),
                                                                                 csize.width(),
                                                                                 isWrapping(),
                                                                                 lastSegmentWidth);
                    horizontalScrollBar()->setSingleStep(1);
                    horizontalScrollBar()->setPageStep(pageSteps);
                    horizontalScrollBar()->setRange(0, steps - pageSteps);
                }
            } else {
                horizontalScrollBar()->setSingleStep(step.width() + d->spacing());
                horizontalScrollBar()->setPageStep(vsize.width());
                horizontalScrollBar()->setRange(0, d->contentsSize().width() - vsize.width());
            }
            if (vertical && !d->isWrapping() && d->viewMode == ListMode) {
                const QVector<int> flowPositions = d->staticListView->flowPositions;
                const int steps = flowPositions.count();
                if (steps > 1) {
                    int lastFlowWidth = flowPositions.at(steps - 1) - flowPositions.at(steps - 2);
                    int pageSteps = d->staticListView->perItemScrollingPageSteps(vsize.height(),
                                                                                 csize.height(),
                                                                                 isWrapping(),
                                                                                 lastFlowWidth);
                    verticalScrollBar()->setSingleStep(1);
                    verticalScrollBar()->setPageStep(pageSteps);
                    verticalScrollBar()->setRange(0, steps - pageSteps);
                }
                // } else if (vertical && d->isWrapping() && d->movement == Static) {
                // ### wrapped scrolling in flow direction
            } else {
                verticalScrollBar()->setSingleStep(step.height() + d->spacing());
                verticalScrollBar()->setPageStep(vsize.height());
                verticalScrollBar()->setRange(0, d->contentsSize().height() - vsize.height());
            }
        } else { // LeftToRight
            if (horizontal && !d->isWrapping() && d->viewMode == ListMode) {
                const QVector<int> flowPositions = d->staticListView->flowPositions;
                int steps = flowPositions.count();
                if (steps > 1) {
                    int lastFlowWidth = flowPositions.at(steps - 1) - flowPositions.at(steps - 2);
                    int pageSteps = d->staticListView->perItemScrollingPageSteps(vsize.width(),
                                                                                 csize.width(),
                                                                                 isWrapping(),
                                                                                 lastFlowWidth);
                    horizontalScrollBar()->setSingleStep(1);
                    horizontalScrollBar()->setPageStep(pageSteps);
                    horizontalScrollBar()->setRange(0, steps - pageSteps);
                }
                // } else if (horizontal && d->isWrapping() && d->movement == Static) {
                // ### wrapped scrolling in flow direction
            } else {
                horizontalScrollBar()->setSingleStep(step.width() + d->spacing());
                horizontalScrollBar()->setPageStep(vsize.width());
                horizontalScrollBar()->setRange(0, d->contentsSize().width() - vsize.width());
            }
            if (vertical && d->isWrapping() && d->viewMode == ListMode) {
                const QVector<int> segmentPositions = d->staticListView->segmentPositions;
                int steps = segmentPositions.count();
                if (steps > 1) {
                    int lastSegmentWidth = segmentPositions.at(steps - 1) - segmentPositions.at(steps - 2);
                    int pageSteps = d->staticListView->perItemScrollingPageSteps(vsize.height(),
                                                                                 csize.height(),
                                                                                 isWrapping(),
                                                                                 lastSegmentWidth);
                    verticalScrollBar()->setSingleStep(1);
                    verticalScrollBar()->setPageStep(pageSteps);
                    verticalScrollBar()->setRange(0, steps - pageSteps);
                }
            } else {
                verticalScrollBar()->setSingleStep(step.height() + d->spacing());
                verticalScrollBar()->setPageStep(vsize.height());
                verticalScrollBar()->setRange(0, d->contentsSize().height() - vsize.height());
            }
        }
    }

    QAbstractItemView::updateGeometries();

    // if the scroll bars are turned off, we resize the contents to the viewport
    if (d->movement == Static && !d->isWrapping()) {
        d->layoutChildren(); // we need the viewport size to be updated
        if (d->flow == TopToBottom) {
            if (horizontalScrollBarPolicy() == Qt::ScrollBarAlwaysOff) {
                d->setContentsSize(viewport()->width(), contentsSize().height());
                horizontalScrollBar()->setRange(0, 0); // we see all the contents anyway
            }
        } else { // LeftToRight
            if (verticalScrollBarPolicy() == Qt::ScrollBarAlwaysOff) {
                d->setContentsSize(contentsSize().width(), viewport()->height());
                verticalScrollBar()->setRange(0, 0); // we see all the contents anyway
            }
        }
    }
}

/*!
  \reimp
*/
bool QListView::isIndexHidden(const QModelIndex &index) const
{
    Q_D(const QListView);
    return (d->hiddenRows.contains(index.row())
            && (index.parent() == d->root)
            && index.column() == d->column);
}

/*!
    \property QListView::modelColumn
    \brief the column in the model that is visible
*/
void QListView::setModelColumn(int column)
{
    Q_D(QListView);
    if (column < 0 || column >= d->model->columnCount(d->root))
        return;
    d->column = column;
    d->doDelayedItemsLayout();
}

int QListView::modelColumn() const
{
    Q_D(const QListView);
    return d->column;
}

/*!
    \property QListView::uniformItemSizes
    \brief whether all items in the listview have the same size
    \since 4.1

    This property should only be set to true if it is guaranteed that all items
    in the view have the same size. This enables the view to do some
    optimizations.
*/
void QListView::setUniformItemSizes(bool enable)
{
    Q_D(QListView);
    d->uniformItemSizes = enable;
}

bool QListView::uniformItemSizes() const
{
    Q_D(const QListView);
    return d->uniformItemSizes;
}

/*!
    \property QListView::wordWrap
    \brief the item text word-wrapping policy
    \since 4.2

    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 false by default.
*/
void QListView::setWordWrap(bool on)
{
    Q_D(QListView);
    if (d->wrapItemText == on)
        return;
    d->wrapItemText = on;
    d->doDelayedItemsLayout();
}

bool QListView::wordWrap() const
{
    Q_D(const QListView);
    return d->wrapItemText;
}

/*!
    \property QListView::selectionRectVisible
    \brief if the selection rectangle should be visible
    \since 4.3

    If this property is true then the selection rectangle is visible;
    otherwise it will be hidden.
    Note that the selection rectangle will only be visible if the selection mode
    is in a mode where more than one item can be selected, i.e. it will not draw
    a selection rectangle if the selection mode is QAbstractItemView::SingleSelection.

*/
void QListView::setSelectionRectVisible(bool show)
{
    Q_D(QListView);
    d->modeProperties |= uint(QListViewPrivate::SelectionRectVisible);
    d->setSelectionRectVisible(show);
}

bool QListView::isSelectionRectVisible() const
{
    Q_D(const QListView);
    return d->isSelectionRectVisible();
}

/*!
    \reimp
*/
bool QListView::event(QEvent *e)
{
    return QAbstractItemView::event(e);
}

/*
 * private object implementation
 */

QListViewPrivate::QListViewPrivate()
    : QAbstractItemViewPrivate(),
      dynamicListView(0),
      staticListView(0),
      wrap(false),
      space(0),
      flow(QListView::TopToBottom),
      movement(QListView::Static),
      resizeMode(QListView::Fixed),
      layoutMode(QListView::SinglePass),
      viewMode(QListView::ListMode),
      modeProperties(0),
      column(0),
      uniformItemSizes(false),
      batchSize(100)
{
}

QListViewPrivate::~QListViewPrivate()
{
    delete staticListView;
    delete dynamicListView;
}

void QListViewPrivate::clear()
{
    // ### split into dynamic and static
    // initialization of data structs
    cachedItemSize = QSize();
    if (viewMode == QListView::ListMode)
        staticListView->clear();
    else
        dynamicListView->clear();
}

void QListViewPrivate::prepareItemsLayout()
{
    Q_Q(QListView);
    clear();
    layoutBounds = QRect(QPoint(0,0), q->maximumViewportSize());

    int verticalMargin = vbarpolicy==Qt::ScrollBarAlwaysOff ? 0 :
        q->style()->pixelMetric(QStyle::PM_ScrollBarExtent, 0, q->verticalScrollBar());
    int horizontalMargin =  hbarpolicy==Qt::ScrollBarAlwaysOff ? 0 :
        q->style()->pixelMetric(QStyle::PM_ScrollBarExtent, 0, q->horizontalScrollBar());

    l