QStandardItemPrivate Class Reference

#include <qstandarditemmodel_p.h>

Public Functions
void	changeFlags (bool enable, Qt::ItemFlags f)
void	childDeleted (QStandardItem *child)
int	childIndex (int row, int column) const
int	childIndex (const QStandardItem *child)
int	columnCount () const
bool	insertColumns (int column, int count, const QList< QStandardItem *> &items)
bool	insertRows (int row, int count, const QList< QStandardItem *> &items)
bool	insertRows (int row, const QList< QStandardItem *> &items)
const QMap< int, QVariant >	itemData () const
QPair< int, int >	position () const
	QStandardItemPrivate ()
int	rowCount () const
void	setChild (int row, int column, QStandardItem *item, bool emitChanged=false)
void	setItemData (const QMap< int, QVariant > &roles)
void	setModel (QStandardItemModel *mod)
void	setParentAndModel (QStandardItem *par, QStandardItemModel *mod)
void	sortChildren (int column, Qt::SortOrder order)
virtual	~QStandardItemPrivate ()

Public Variables
QVector< QStandardItem * >	children
int	columns
int	lastIndexOf
QStandardItemModel *	model
QStandardItem *	parent
QStandardItem *	q_ptr
int	rows
QVector< QWidgetItemData >	values

Detailed Description

Definition at line 69 of file qstandarditemmodel_p.h.

Constructors and Destructors

QStandardItemPrivate()

QStandardItemPrivate::QStandardItemPrivate ( )

inline

Definition at line 73 of file qstandarditemmodel_p.h.

        : model(0),
          parent(0),
          rows(0),
          columns(0),
          q_ptr(0),
          lastIndexOf(2)
        { }

~QStandardItemPrivate()

QStandardItemPrivate::~QStandardItemPrivate ( )

virtual

Warning

This function is not part of the public interface.

Definition at line 90 of file qstandarditemmodel.cpp.

Referenced by QStandardItemPrivate().

{
    QVector<QStandardItem*>::const_iterator it;
    for (it = children.constBegin(); it != children.constEnd(); ++it) {
        QStandardItem *child = *it;
        if (child)
            child->d_func()->setModel(0);
        delete child;
    }
    children.clear();
    if (parent && model)
        parent->d_func()->childDeleted(q_func());
}

Functions

changeFlags()

void QStandardItemPrivate::changeFlags	(	bool	enable,
		Qt::ItemFlags	f
	)

Warning

This function is not part of the public interface.

Definition at line 163 of file qstandarditemmodel.cpp.

Referenced by setParentAndModel().

{
    Q_Q(QStandardItem);
    Qt::ItemFlags flags = q->flags();
    if (enable)
        flags |= f;
    else
        flags &= ~f;
    q->setFlags(flags);
}

childDeleted()

void QStandardItemPrivate::childDeleted

(

QStandardItem *

child

)

Warning

This function is not part of the public interface.

Definition at line 177 of file qstandarditemmodel.cpp.

Referenced by columnCount().

{
    int index = childIndex(child);
    Q_ASSERT(index != -1);
    children.replace(index, 0);
}

childIndex() [1/2]

int QStandardItemPrivate::childIndex ( int  row, int  column  ) const

inline

Definition at line 83 of file qstandarditemmodel_p.h.

                                                     {
        if ((row < 0) || (column < 0)
            || (row >= rowCount()) || (column >= columnCount())) {
            return -1;
        }
        return (row * columnCount()) + column;
    }

childIndex() [2/2]

int QStandardItemPrivate::childIndex ( const QStandardItem *  child )

inline

Definition at line 90 of file qstandarditemmodel_p.h.

                                                      {
        int start = qMax(0, lastIndexOf -2);
        lastIndexOf = children.indexOf(const_cast<QStandardItem*>(child), start);
        if (lastIndexOf == -1 && start != 0)
            lastIndexOf = children.lastIndexOf(const_cast<QStandardItem*>(child), start);
        return lastIndexOf;
    }

columnCount()

int QStandardItemPrivate::columnCount ( ) const

inline

Definition at line 103 of file qstandarditemmodel_p.h.

Referenced by childIndex().

                                   {
        return columns;
    }

insertColumns()

bool QStandardItemPrivate::insertColumns	(	int	column,
		int	count,
		const QList< QStandardItem *> &	items
	)

Warning

This function is not part of the public interface.

Definition at line 440 of file qstandarditemmodel.cpp.

Referenced by setParentAndModel().

{
    Q_Q(QStandardItem);
    if ((count < 1) || (column < 0) || (column > columnCount()))
        return false;
    if (model)
        model->d_func()->columnsAboutToBeInserted(q, column, column + count - 1);
    if (columnCount() == 0) {
        children.resize(rowCount() * count);
        columns = count;
    } else {
        columns += count;
        int index = childIndex(0, column);
        for (int row = 0; row < rowCount(); ++row) {
            children.insert(index, count, 0);
            index += columnCount();
        }
    }
    if (!items.isEmpty()) {
        int limit = qMin(items.count(), rowCount() * count);
        for (int i = 0; i < limit; ++i) {
            QStandardItem *item = items.at(i);
            if (item) {
                if (item->d_func()->parent == 0) {
                    item->d_func()->setParentAndModel(q, model);
                } else {
                    qWarning("QStandardItem::insertColumns: Ignoring duplicate insertion of item %p",
                             item);
                    item = 0;
                }
            }
            int r = i / count;
            int c = column + (i % count);
            int index = childIndex(r, c);
            children.replace(index, item);
        }
    }
    if (model)
        model->d_func()->columnsInserted(q, column, count);
    return true;
}

insertRows() [1/2]

bool QStandardItemPrivate::insertRows	(	int	row,
		int	count,
		const QList< QStandardItem *> &	items
	)

Definition at line 398 of file qstandarditemmodel.cpp.

Referenced by setParentAndModel().

{
    Q_Q(QStandardItem);
    if ((count < 1) || (row < 0) || (row > rowCount()))
        return false;
    if (model)
        model->d_func()->rowsAboutToBeInserted(q, row, row + count - 1);
    if (rowCount() == 0) {
        children.resize(columnCount() * count);
        rows = count;
    } else {
        rows += count;
        int index = childIndex(row, 0);
        if (index != -1)
            children.insert(index, columnCount() * count, 0);
    }
    if (!items.isEmpty()) {
        int index = childIndex(row, 0);
        int limit = qMin(items.count(), columnCount() * count);
        for (int i = 0; i < limit; ++i) {
            QStandardItem *item = items.at(i);
            if (item) {
                if (item->d_func()->parent == 0) {
                    item->d_func()->setParentAndModel(q, model);
                } else {
                    qWarning("QStandardItem::insertRows: Ignoring duplicate insertion of item %p",
                             item);
                    item = 0;
                }
            }
            children.replace(index, item);
            ++index;
        }
    }
    if (model)
        model->d_func()->rowsInserted(q, row, count);
    return true;
}

insertRows() [2/2]

bool QStandardItemPrivate::insertRows	(	int	row,
		const QList< QStandardItem *> &	items
	)

Warning

This function is not part of the public interface.

Definition at line 367 of file qstandarditemmodel.cpp.

{
    Q_Q(QStandardItem);
    if ((row < 0) || (row > rowCount()))
        return false;
    int count = items.count();
    if (model)
        model->d_func()->rowsAboutToBeInserted(q, row, row + count - 1);
    if (rowCount() == 0) {
        if (columnCount() == 0)
            q->setColumnCount(1);
        children.resize(columnCount() * count);
        rows = count;
    } else {
        rows += count;
        int index = childIndex(row, 0);
        if (index != -1)
            children.insert(index, columnCount() * count, 0);
    }
    for (int i = 0; i < items.count(); ++i) {
        QStandardItem *item = items.at(i);
        item->d_func()->model = model;
        item->d_func()->parent = q;
        int index = childIndex(i + row, 0);
        children.replace(index, item);
    }
    if (model)
        model->d_func()->rowsInserted(q, row, count);
    return true;
}

itemData()

const QMap< int, QVariant > QStandardItemPrivate::itemData

(

)

const

Warning

This function is not part of the public interface.

Definition at line 214 of file qstandarditemmodel.cpp.

Referenced by setParentAndModel().

{
    QMap<int, QVariant> result;
    QVector<QWidgetItemData>::const_iterator it;
    for (it = values.begin(); it != values.end(); ++it)
        result.insert((*it).role, (*it).value);
    return result;
}

position()

QPair< int, int > QStandardItemPrivate::position

(

)

const

Warning

This function is not part of the public interface.

Definition at line 107 of file qstandarditemmodel.cpp.

Referenced by childIndex().

{
    if (QStandardItem *par = parent) {
        int idx = par->d_func()->childIndex(q_func());
        if (idx == -1)
            return QPair<int, int>(-1, -1);
        return QPair<int, int>(idx / par->columnCount(), idx % par->columnCount());
    }
    // ### support header items?
    return QPair<int, int>(-1, -1);
}

rowCount()

int QStandardItemPrivate::rowCount ( ) const

inline

Definition at line 100 of file qstandarditemmodel_p.h.

Referenced by childIndex().

                                {
        return rows;
    }

setChild()

void QStandardItemPrivate::setChild	(	int	row,
		int	column,
		QStandardItem *	item,
		bool	emitChanged = false
	)

Warning

This function is not part of the public interface.

Definition at line 122 of file qstandarditemmodel.cpp.

Referenced by childIndex().

{
    Q_Q(QStandardItem);
    if (item == q) {
        qWarning("QStandardItem::setChild: Can't make an item a child of itself %p",
                 item);
        return;
    }
    if ((row < 0) || (column < 0))
        return;
    if (rows <= row)
        q->setRowCount(row + 1);
    if (columns <= column)
        q->setColumnCount(column + 1);
    int index = childIndex(row, column);
    Q_ASSERT(index != -1);
    QStandardItem *oldItem = children.at(index);
    if (item == oldItem)
        return;
    if (item) {
        if (item->d_func()->parent == 0) {
            item->d_func()->setParentAndModel(q, model);
        } else {
            qWarning("QStandardItem::setChild: Ignoring duplicate insertion of item %p",
                     item);
            return;
        }
    }
    if (oldItem)
        oldItem->d_func()->setModel(0);
    delete oldItem;
    children.replace(index, item);
    if (emitChanged && model)
        model->d_func()->itemChanged(item);
}

setItemData()

void QStandardItemPrivate::setItemData

(

const QMap< int, QVariant > &

roles

)

Warning

This function is not part of the public interface.

Definition at line 187 of file qstandarditemmodel.cpp.

Referenced by setParentAndModel().

{
    Q_Q(QStandardItem);

    //let's build the vector of new values
    QVector<QWidgetItemData> newValues;
    QMap<int, QVariant>::const_iterator it;
    for (it = roles.begin(); it != roles.end(); ++it) {
        QVariant value = it.value();
        if (value.isValid()) {
            int role = it.key();
            role = (role == Qt::EditRole) ? Qt::DisplayRole : role;
            QWidgetItemData wid(role,it.value());
            newValues.append(wid);
        }
    }

    if (values!=newValues) {
        values=newValues;
        if (model)
            model->d_func()->itemChanged(q);
    }
}

setModel()

void QStandardItemPrivate::setModel

(

QStandardItemModel *

mod

)

Warning

This function is not part of the public interface. set the model of this item and all its children

Definition at line 291 of file qstandarditemmodel.cpp.

Referenced by columnCount(), and setParentAndModel().

{
    if (children.isEmpty()) {
        if (model)
            model->d_func()->invalidatePersistentIndex(model->indexFromItem(q_ptr));
        model = mod;
    } else {
        QStack<QStandardItem*> stack;
        stack.push(q_ptr);
        while (!stack.isEmpty()) {
            QStandardItem *itm = stack.pop();
            if (itm->d_func()->model) {
                itm->d_func()->model->d_func()->invalidatePersistentIndex(itm->d_func()->model->indexFromItem(itm));
            }
            itm->d_func()->model = mod;
            const QVector<QStandardItem*> &childList = itm->d_func()->children;
            for (int i = 0; i < childList.count(); ++i) {
                QStandardItem *chi = childList.at(i);
                if (chi)
                    stack.push(chi);
            }
        }
    }
}

setParentAndModel()

void QStandardItemPrivate::setParentAndModel ( QStandardItem *  par, QStandardItemModel *  mod  )

inline

Definition at line 110 of file qstandarditemmodel_p.h.

                                 {
        setModel(mod);
        parent = par;
    }

sortChildren()

void QStandardItemPrivate::sortChildren	(	int	column,
		Qt::SortOrder	order
	)

Warning

This function is not part of the public interface.

Definition at line 226 of file qstandarditemmodel.cpp.

Referenced by setParentAndModel().

{
    Q_Q(QStandardItem);
    if (column >= columnCount())
        return;

    QVector<QPair<QStandardItem*, int> > sortable;
    QVector<int> unsortable;

    sortable.reserve(rowCount());
    unsortable.reserve(rowCount());

    for (int row = 0; row < rowCount(); ++row) {
        QStandardItem *itm = q->child(row, column);
        if (itm)
            sortable.append(QPair<QStandardItem*,int>(itm, row));
        else
            unsortable.append(row);
    }

    if (order == Qt::AscendingOrder) {
        QStandardItemModelLessThan lt;
        qStableSort(sortable.begin(), sortable.end(), lt);
    } else {
        QStandardItemModelGreaterThan gt;
        qStableSort(sortable.begin(), sortable.end(), gt);
    }

    QModelIndexList changedPersistentIndexesFrom, changedPersistentIndexesTo;
    QVector<QStandardItem*> sorted_children(children.count());
    for (int i = 0; i < rowCount(); ++i) {
        int r = (i < sortable.count()
                 ? sortable.at(i).second
                 : unsortable.at(i - sortable.count()));
        for (int c = 0; c < columnCount(); ++c) {
            QStandardItem *itm = q->child(r, c);
            sorted_children[childIndex(i, c)] = itm;
            if (model) {
                QModelIndex from = model->createIndex(r, c, q);
                if (model->d_func()->persistent.indexes.contains(from)) {
                    QModelIndex to = model->createIndex(i, c, q);
                    changedPersistentIndexesFrom.append(from);
                    changedPersistentIndexesTo.append(to);
                }
            }
        }
    }

    children = sorted_children;

    if (model) {
        model->changePersistentIndexList(changedPersistentIndexesFrom, changedPersistentIndexesTo);
    }

    QVector<QStandardItem*>::iterator it;
    for (it = children.begin(); it != children.end(); ++it) {
        if (*it)
            (*it)->d_func()->sortChildren(column, order);
    }
}

Properties

children

QVector<QStandardItem*> QStandardItemPrivate::children

Definition at line 130 of file qstandarditemmodel_p.h.

Referenced by childIndex(), and QStandardItemModel::mimeData().

columns

int QStandardItemPrivate::columns

Definition at line 132 of file qstandarditemmodel_p.h.

Referenced by columnCount().

lastIndexOf

int QStandardItemPrivate::lastIndexOf

Definition at line 136 of file qstandarditemmodel_p.h.

Referenced by childIndex().

model

QStandardItemModel* QStandardItemPrivate::model

Definition at line 127 of file qstandarditemmodel_p.h.

parent

QStandardItem* QStandardItemPrivate::parent

Definition at line 128 of file qstandarditemmodel_p.h.

Referenced by QStandardItemModelPrivate::itemFromIndex(), and setParentAndModel().

q_ptr

QStandardItem* QStandardItemPrivate::q_ptr

Definition at line 134 of file qstandarditemmodel_p.h.

rows

int QStandardItemPrivate::rows

Definition at line 131 of file qstandarditemmodel_p.h.

Referenced by rowCount().

values

QVector<QWidgetItemData> QStandardItemPrivate::values

Definition at line 129 of file qstandarditemmodel_p.h.

---

The documentation for this class was generated from the following files:

• /src/gui/itemviews/qstandarditemmodel_p.h
• /src/gui/itemviews/qstandarditemmodel.cpp