diff --git a/declarativeimports/CMakeLists.txt b/declarativeimports/CMakeLists.txt index 71dc28203..08430949a 100644 --- a/declarativeimports/CMakeLists.txt +++ b/declarativeimports/CMakeLists.txt @@ -2,6 +2,7 @@ add_subdirectory(core) add_subdirectory(draganddrop) add_subdirectory(graphicslayouts) add_subdirectory(graphicswidgets) +add_subdirectory(krunnermodel) add_subdirectory(qtextracomponents) add_subdirectory(plasmacomponents) add_subdirectory(plasmaextracomponents) diff --git a/declarativeimports/krunnermodel/CMakeLists.txt b/declarativeimports/krunnermodel/CMakeLists.txt new file mode 100644 index 000000000..95ac02780 --- /dev/null +++ b/declarativeimports/krunnermodel/CMakeLists.txt @@ -0,0 +1,20 @@ +project(runnermodel) + +set(runnermodel_SRCS + runnermodel.cpp + runnermodelplugin.cpp + ) + +qt4_automoc(${runnermodel_SRCS}) + +kde4_add_library(runnermodelplugin SHARED ${runnermodel_SRCS}) +target_link_libraries(runnermodelplugin + ${QT_QTCORE_LIBRARY} + ${QT_QTDECLARATIVE_LIBRARY} + ${KDE4_PLASMA_LIBS} + ) + +install(TARGETS runnermodelplugin DESTINATION ${IMPORTS_INSTALL_DIR}/org/kde/runnermodel) +install(FILES qmldir DESTINATION ${IMPORTS_INSTALL_DIR}/org/kde/runnermodel) + +#add_subdirectory(test) diff --git a/declarativeimports/krunnermodel/qmldir b/declarativeimports/krunnermodel/qmldir new file mode 100644 index 000000000..a6a966e82 --- /dev/null +++ b/declarativeimports/krunnermodel/qmldir @@ -0,0 +1,2 @@ +plugin runnermodelplugin + diff --git a/declarativeimports/krunnermodel/runnermodel.cpp b/declarativeimports/krunnermodel/runnermodel.cpp new file mode 100644 index 000000000..b2dff3d01 --- /dev/null +++ b/declarativeimports/krunnermodel/runnermodel.cpp @@ -0,0 +1,185 @@ +/* + Copyright 2011 Aaron Seigo + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include "runnermodel.h" + +#include +#include +#include + +#include + +#include + +RunnerModel::RunnerModel(QObject *parent) + : QAbstractListModel(parent), + m_manager(0), + m_startQueryTimer(new QTimer(this)) +{ + QHash roles; + roles.insert(Qt::DisplayRole, "label"); + roles.insert(Qt::DecorationRole, "icon"); + roles.insert(Type, "type"); + roles.insert(Relevance, "relevance"); + roles.insert(Data, "data"); + roles.insert(Id, "id"); + roles.insert(SubText, "description"); + roles.insert(Enabled, "enabled"); + roles.insert(RunnerId, "runnerid"); + roles.insert(RunnerName, "runnerName"); + roles.insert(Actions, "actions"); + setRoleNames(roles); + + m_startQueryTimer->setSingleShot(true); + m_startQueryTimer->setInterval(10); + connect(m_startQueryTimer, SIGNAL(timeout()), this, SLOT(startQuery())); +} + +int RunnerModel::rowCount(const QModelIndex& index) const +{ + return index.isValid() ? 0 : m_matches.count(); +} + +int RunnerModel::count() const +{ + return m_matches.count(); +} + +QStringList RunnerModel::runners() const +{ + return m_manager ? m_manager->allowedRunners() : QStringList(); +} + +void RunnerModel::setRunners(const QStringList &allowedRunners) +{ + if (m_manager) { + m_manager->setAllowedRunners(allowedRunners); + + //automagically enter single runner mode if there's only 1 allowed runner + m_manager->setSingleMode(allowedRunners.count() == 1); + emit runnersChanged(); + } else { + m_pendingRunnersList = allowedRunners; + } +} + +void RunnerModel::run(int index) +{ + if (index >= 0 && index < m_matches.count()) { + m_manager->run(m_matches.at(index)); + } +} + +QVariant RunnerModel::data(const QModelIndex &index, int role) const +{ + if (!index.isValid() || index.parent().isValid() || + index.column() > 0 || index.row() < 0 || index.row() >= m_matches.count()) { + // index requested must be valid, but we have no child items! + //kDebug() << "invalid index requested"; + return QVariant(); + } + + if (role == Qt::DisplayRole) { + return m_matches.at(index.row()).text(); + } else if (role == Qt::DecorationRole) { + return m_matches.at(index.row()).icon(); + } else if (role == Type) { + return m_matches.at(index.row()).type(); + } else if (role == Relevance) { + return m_matches.at(index.row()).relevance(); + } else if (role == Data) { + return m_matches.at(index.row()).data(); + } else if (role == Id) { + return m_matches.at(index.row()).id(); + } else if (role == SubText) { + return m_matches.at(index.row()).subtext(); + } else if (role == Enabled) { + return m_matches.at(index.row()).isEnabled(); + } else if (role == RunnerId) { + return m_matches.at(index.row()).runner()->id(); + } else if (role == RunnerName) { + return m_matches.at(index.row()).runner()->name(); + } else if (role == Actions) { + QVariantList actions; + Plasma::QueryMatch amatch = m_matches.at(index.row()); + QList theactions = m_manager->actionsForMatch(amatch); + foreach(QAction* action, theactions) { + actions += qVariantFromValue(action); + } + return actions; + } + + return QVariant(); +} + +QString RunnerModel::currentQuery() const +{ + return m_manager ? m_manager->query() : QString(); +} + +void RunnerModel::scheduleQuery(const QString &query) +{ + m_pendingQuery = query; + m_startQueryTimer->start(); +} + +void RunnerModel::startQuery() +{ + if (!m_manager && m_pendingQuery.isEmpty()) { + // avoid creating a manager just so we can run nothing + return; + } + + //kDebug() << "booooooo yah!!!!!!!!!!!!!" << query; + createManager(); + +// if (m_pendingQuery != m_manager->query()) { + //kDebug() << "running query" << query; + m_manager->launchQuery(m_pendingQuery); + emit queryChanged(); + // } +} + +void RunnerModel::createManager() +{ + if (!m_manager) { + m_manager = new Plasma::RunnerManager(this); + connect(m_manager, SIGNAL(matchesChanged(QList)), + this, SLOT(matchesChanged(QList))); + + if (!m_pendingRunnersList.isEmpty()) { + m_manager->setAllowedRunners(m_pendingRunnersList); + m_manager->setSingleMode(m_pendingRunnersList.count() == 1); + m_pendingRunnersList.clear(); + } + //connect(m_manager, SIGNAL(queryFinished()), this, SLOT(queryFinished())); + } +} + +void RunnerModel::matchesChanged(const QList &matches) +{ + //kDebug() << "got matches:" << matches.count(); + beginResetModel(); + m_matches = matches; + endResetModel(); + emit countChanged(); +} + +#include "runnermodel.moc" + diff --git a/declarativeimports/krunnermodel/runnermodel.h b/declarativeimports/krunnermodel/runnermodel.h new file mode 100644 index 000000000..6258b3775 --- /dev/null +++ b/declarativeimports/krunnermodel/runnermodel.h @@ -0,0 +1,112 @@ +/* + Copyright 2011 Aaron Seigo + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef RUNNERMODEL_H +#define RUNNERMODEL_H + +#include +#include + +namespace Plasma +{ + class RunnerManager; + class QueryMatch; +} // namespace Plasma + +class QTimer; + +/** + * This model provides bindings to use KRunner from QML + * + * @author Aaron Seigo + */ +class RunnerModel : public QAbstractListModel +{ + Q_OBJECT + + /** + * @property string set the KRunner query + */ + Q_PROPERTY(QString query WRITE scheduleQuery READ currentQuery NOTIFY queryChanged) + + /** + * @property Array The list of all allowed runner plugins that will be executed + */ + Q_PROPERTY(QStringList runners WRITE setRunners READ runners NOTIFY runnersChanged) + + /** + * @property int The number of rows of the model + */ + Q_PROPERTY(int count READ count NOTIFY countChanged) + +public: + /** + * @enum Roles of the model, they will be accessible from delegates + */ + enum Roles { + Type = Qt::UserRole + 1, + Relevance, + Data, + Id, + SubText, + Enabled, + RunnerId, + RunnerName, + Actions + }; + + RunnerModel(QObject *parent = 0); + + QString currentQuery() const; + + QStringList runners() const; + void setRunners(const QStringList &allowedRunners); + + Q_SCRIPTABLE void run(int row); + + int rowCount(const QModelIndex&) const; + int count() const; + QVariant data(const QModelIndex&, int) const; + +public Q_SLOTS: + void scheduleQuery(const QString &query); + +Q_SIGNALS: + void queryChanged(); + void countChanged(); + void runnersChanged(); + +private Q_SLOTS: + void startQuery(); + +private: + void createManager(); + +private Q_SLOTS: + void matchesChanged(const QList &matches); + +private: + Plasma::RunnerManager *m_manager; + QList m_matches; + QStringList m_pendingRunnersList; + QString m_pendingQuery; + QTimer *m_startQueryTimer; +}; + +#endif diff --git a/declarativeimports/krunnermodel/runnermodelplugin.cpp b/declarativeimports/krunnermodel/runnermodelplugin.cpp new file mode 100644 index 000000000..834e7db9d --- /dev/null +++ b/declarativeimports/krunnermodel/runnermodelplugin.cpp @@ -0,0 +1,37 @@ +/* + * Copyright 2011 by Marco Martin + + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License as + * published by the Free Software Foundation; either version 2, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Library General Public License for more details + * + * You should have received a copy of the GNU Library General Public + * License along with this program; if not, write to the + * Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "runnermodelplugin.h" + +#include + +#include + +#include "runnermodel.h" + +void RunnerModelPlugin::registerTypes(const char *uri) +{ + Q_ASSERT(uri == QLatin1String("org.kde.runnermodel")); + qmlRegisterType(uri, 0, 1, "RunnerModel"); + qmlRegisterInterface("QueryMatch"); + qRegisterMetaType("QueryMatch"); +} + +#include "runnermodelplugin.moc" + diff --git a/declarativeimports/krunnermodel/runnermodelplugin.h b/declarativeimports/krunnermodel/runnermodelplugin.h new file mode 100644 index 000000000..b15bf40ac --- /dev/null +++ b/declarativeimports/krunnermodel/runnermodelplugin.h @@ -0,0 +1,36 @@ +/* + * Copyright 2011 by Marco Martin + * Copyright 2011 by Aaron Seigo + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License as + * published by the Free Software Foundation; either version 2, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Library General Public License for more details + * + * You should have received a copy of the GNU Library General Public + * License along with this program; if not, write to the + * Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef RUNNERMODELPLUGIN_H +#define RUNNERMODELPLUGIN_H + +#include + + +class RunnerModelPlugin : public QDeclarativeExtensionPlugin +{ + Q_OBJECT + +public: + void registerTypes(const char *uri); +}; + +Q_EXPORT_PLUGIN2(datamodelsplugin, RunnerModelPlugin) + +#endif diff --git a/declarativeimports/krunnermodel/test/CMakeLists.txt b/declarativeimports/krunnermodel/test/CMakeLists.txt new file mode 100644 index 000000000..fa89a86a5 --- /dev/null +++ b/declarativeimports/krunnermodel/test/CMakeLists.txt @@ -0,0 +1,12 @@ +set(runnermodeltest_SRCS + main.cpp + dynamictreemodel.cpp + modeltest.cpp + ../runnermodel.cpp + ) + +qt4_automoc(${runnermodeltest_SRCS}) +#kde4_add_library(datamodelsplugin SHARED ${datamodels_SRCS}) +kde4_add_executable(runnermodeltest ${runnermodeltest_SRCS}) +target_link_libraries(runnermodeltest ${QT_QTTEST_LIBRARY} ${KDE4_PLASMA_LIBS}) + diff --git a/declarativeimports/krunnermodel/test/dynamictreemodel.cpp b/declarativeimports/krunnermodel/test/dynamictreemodel.cpp new file mode 100644 index 000000000..fa634b6a5 --- /dev/null +++ b/declarativeimports/krunnermodel/test/dynamictreemodel.cpp @@ -0,0 +1,336 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Stephen Kelly +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the test suite 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 "dynamictreemodel.h" + +#include +#include +#include + + +DynamicTreeModel::DynamicTreeModel(QObject *parent) + : QAbstractItemModel(parent), + nextId(1) +{ +} + +QModelIndex DynamicTreeModel::index(int row, int column, const QModelIndex &parent) const +{ +// if (column != 0) +// return QModelIndex(); + + + if ( column < 0 || row < 0 ) + return QModelIndex(); + + QList > childIdColumns = m_childItems.value(parent.internalId()); + + const qint64 grandParent = findParentId(parent.internalId()); + if (grandParent >= 0) { + QList > parentTable = m_childItems.value(grandParent); + Q_ASSERT(parent.column() < parentTable.size()); + QList parentSiblings = parentTable.at(parent.column()); + Q_ASSERT(parent.row() < parentSiblings.size()); + } + + if (childIdColumns.size() == 0) + return QModelIndex(); + + if (column >= childIdColumns.size()) + return QModelIndex(); + + QList rowIds = childIdColumns.at(column); + + if ( row >= rowIds.size()) + return QModelIndex(); + + qint64 id = rowIds.at(row); + + return createIndex(row, column, reinterpret_cast(id)); + +} + +qint64 DynamicTreeModel::findParentId(qint64 searchId) const +{ + if (searchId <= 0) + return -1; + + QHashIterator > > i(m_childItems); + while (i.hasNext()) + { + i.next(); + QListIterator > j(i.value()); + while (j.hasNext()) + { + QList l = j.next(); + if (l.contains(searchId)) + { + return i.key(); + } + } + } + return -1; +} + +QModelIndex DynamicTreeModel::parent(const QModelIndex &index) const +{ + if (!index.isValid()) + return QModelIndex(); + + qint64 searchId = index.internalId(); + qint64 parentId = findParentId(searchId); + // Will never happen for valid index, but what the hey... + if (parentId <= 0) + return QModelIndex(); + + qint64 grandParentId = findParentId(parentId); + if (grandParentId < 0) + grandParentId = 0; + + int column = 0; + QList childList = m_childItems.value(grandParentId).at(column); + + int row = childList.indexOf(parentId); + + return createIndex(row, column, reinterpret_cast(parentId)); + +} + +int DynamicTreeModel::rowCount(const QModelIndex &index ) const +{ + QList > cols = m_childItems.value(index.internalId()); + + if (cols.size() == 0 ) + return 0; + + if (index.column() > 0) + return 0; + + return cols.at(0).size(); +} + +int DynamicTreeModel::columnCount(const QModelIndex &index ) const +{ +// Q_UNUSED(index); + return m_childItems.value(index.internalId()).size(); +} + +QVariant DynamicTreeModel::data(const QModelIndex &index, int role) const +{ + if (!index.isValid()) + return QVariant(); + + if (Qt::DisplayRole == role) + { + return m_items.value(index.internalId()); + } + return QVariant(); +} + +void DynamicTreeModel::clear() +{ + beginResetModel(); + m_items.clear(); + m_childItems.clear(); + nextId = 1; + endResetModel(); +} + + +ModelChangeCommand::ModelChangeCommand( DynamicTreeModel *model, QObject *parent ) + : QObject(parent), m_model(model), m_numCols(1), m_startRow(-1), m_endRow(-1) +{ + +} + +QModelIndex ModelChangeCommand::findIndex(QList rows) +{ + const int col = 0; + QModelIndex parent = QModelIndex(); + QListIterator i(rows); + while (i.hasNext()) + { + parent = m_model->index(i.next(), col, parent); + Q_ASSERT(parent.isValid()); + } + return parent; +} + +ModelInsertCommand::ModelInsertCommand(DynamicTreeModel *model, QObject *parent ) + : ModelChangeCommand(model, parent) +{ + +} + +void ModelInsertCommand::doCommand() +{ + QModelIndex parent = findIndex(m_rowNumbers); + m_model->beginInsertRows(parent, m_startRow, m_endRow); + qint64 parentId = parent.internalId(); + for (int row = m_startRow; row <= m_endRow; row++) + { + for(int col = 0; col < m_numCols; col++ ) + { + if (m_model->m_childItems[parentId].size() <= col) + { + m_model->m_childItems[parentId].append(QList()); + } +// QString name = QUuid::createUuid().toString(); + qint64 id = m_model->newId(); + QString name = QString::number(id); + + m_model->m_items.insert(id, name); + m_model->m_childItems[parentId][col].insert(row, id); + + } + } + m_model->endInsertRows(); +} + + +ModelMoveCommand::ModelMoveCommand(DynamicTreeModel *model, QObject *parent) + : ModelChangeCommand(model, parent) +{ + +} +bool ModelMoveCommand::emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd, const QModelIndex &destParent, int destRow) +{ + return m_model->beginMoveRows(srcParent, srcStart, srcEnd, destParent, destRow); +} + +void ModelMoveCommand::doCommand() +{ + QModelIndex srcParent = findIndex(m_rowNumbers); + QModelIndex destParent = findIndex(m_destRowNumbers); + + if (!emitPreSignal(srcParent, m_startRow, m_endRow, destParent, m_destRow)) + { + return; + } + + for (int column = 0; column < m_numCols; ++column) + { + QList l = m_model->m_childItems.value(srcParent.internalId())[column].mid(m_startRow, m_endRow - m_startRow + 1 ); + + for (int i = m_startRow; i <= m_endRow ; i++) + { + m_model->m_childItems[srcParent.internalId()][column].removeAt(m_startRow); + } + int d; + if (m_destRow < m_startRow) + d = m_destRow; + else + { + if (srcParent == destParent) + d = m_destRow - (m_endRow - m_startRow + 1); + else + d = m_destRow - (m_endRow - m_startRow) + 1; + } + + foreach(const qint64 id, l) + { + m_model->m_childItems[destParent.internalId()][column].insert(d++, id); + } + } + + emitPostSignal(); +} + +void ModelMoveCommand::emitPostSignal() +{ + m_model->endMoveRows(); +} + +ModelResetCommand::ModelResetCommand(DynamicTreeModel* model, QObject* parent) + : ModelMoveCommand(model, parent) +{ + +} + +ModelResetCommand::~ModelResetCommand() +{ + +} + +bool ModelResetCommand::emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd, const QModelIndex &destParent, int destRow) +{ + Q_UNUSED(srcParent); + Q_UNUSED(srcStart); + Q_UNUSED(srcEnd); + Q_UNUSED(destParent); + Q_UNUSED(destRow); + + return true; +} + +void ModelResetCommand::emitPostSignal() +{ + m_model->reset(); +} + +ModelResetCommandFixed::ModelResetCommandFixed(DynamicTreeModel* model, QObject* parent) + : ModelMoveCommand(model, parent) +{ + +} + +ModelResetCommandFixed::~ModelResetCommandFixed() +{ + +} + +bool ModelResetCommandFixed::emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd, const QModelIndex &destParent, int destRow) +{ + Q_UNUSED(srcParent); + Q_UNUSED(srcStart); + Q_UNUSED(srcEnd); + Q_UNUSED(destParent); + Q_UNUSED(destRow); + + m_model->beginResetModel(); + return true; +} + +void ModelResetCommandFixed::emitPostSignal() +{ + m_model->endResetModel(); +} + diff --git a/declarativeimports/krunnermodel/test/dynamictreemodel.h b/declarativeimports/krunnermodel/test/dynamictreemodel.h new file mode 100644 index 000000000..809b76a3a --- /dev/null +++ b/declarativeimports/krunnermodel/test/dynamictreemodel.h @@ -0,0 +1,197 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Stephen Kelly +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the test suite 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$ +** +****************************************************************************/ + +#ifndef DYNAMICTREEMODEL_H +#define DYNAMICTREEMODEL_H + +#include + +#include +#include + + +class DynamicTreeModel : public QAbstractItemModel +{ + Q_OBJECT + +public: + DynamicTreeModel(QObject *parent = 0); + + QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const; + QModelIndex parent(const QModelIndex &index) const; + int rowCount(const QModelIndex &index = QModelIndex()) const; + int columnCount(const QModelIndex &index = QModelIndex()) const; + + QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const; + + void clear(); + +protected slots: + + /** + Finds the parent id of the string with id @p searchId. + + Returns -1 if not found. + */ + qint64 findParentId(qint64 searchId) const; + +private: + QHash m_items; + QHash > > m_childItems; + qint64 nextId; + qint64 newId() { return nextId++; }; + + QModelIndex m_nextParentIndex; + int m_nextRow; + + int m_depth; + int maxDepth; + + friend class ModelInsertCommand; + friend class ModelMoveCommand; + friend class ModelResetCommand; + friend class ModelResetCommandFixed; + +}; + + +class ModelChangeCommand : public QObject +{ + Q_OBJECT +public: + + explicit ModelChangeCommand( DynamicTreeModel *model, QObject *parent = 0 ); + + virtual ~ModelChangeCommand() {} + + void setAncestorRowNumbers(QList rowNumbers) { m_rowNumbers = rowNumbers; } + + QModelIndex findIndex(QList rows); + + void setStartRow(int row) { m_startRow = row; } + + void setEndRow(int row) { m_endRow = row; } + + void setNumCols(int cols) { m_numCols = cols; } + + virtual void doCommand() = 0; + +protected: + DynamicTreeModel* m_model; + QList m_rowNumbers; + int m_numCols; + int m_startRow; + int m_endRow; + +}; + +typedef QList ModelChangeCommandList; + +class ModelInsertCommand : public ModelChangeCommand +{ + Q_OBJECT + +public: + + explicit ModelInsertCommand(DynamicTreeModel *model, QObject *parent = 0 ); + virtual ~ModelInsertCommand() {} + + virtual void doCommand(); +}; + + +class ModelMoveCommand : public ModelChangeCommand +{ + Q_OBJECT +public: + ModelMoveCommand(DynamicTreeModel *model, QObject *parent); + + virtual ~ModelMoveCommand() {} + + virtual bool emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd, const QModelIndex &destParent, int destRow); + + virtual void doCommand(); + + virtual void emitPostSignal(); + + void setDestAncestors( QList rows ) { m_destRowNumbers = rows; } + + void setDestRow(int row) { m_destRow = row; } + +protected: + QList m_destRowNumbers; + int m_destRow; +}; + +/** + A command which does a move and emits a reset signal. +*/ +class ModelResetCommand : public ModelMoveCommand +{ + Q_OBJECT +public: + explicit ModelResetCommand(DynamicTreeModel* model, QObject* parent = 0); + + virtual ~ModelResetCommand(); + + virtual bool emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd, const QModelIndex &destParent, int destRow); + virtual void emitPostSignal(); + +}; + +/** + A command which does a move and emits a beginResetModel and endResetModel signals. +*/ +class ModelResetCommandFixed : public ModelMoveCommand +{ + Q_OBJECT +public: + explicit ModelResetCommandFixed(DynamicTreeModel* model, QObject* parent = 0); + + virtual ~ModelResetCommandFixed(); + + virtual bool emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd, const QModelIndex &destParent, int destRow); + virtual void emitPostSignal(); + +}; + + +#endif diff --git a/declarativeimports/krunnermodel/test/main.cpp b/declarativeimports/krunnermodel/test/main.cpp new file mode 100644 index 000000000..1feee19b2 --- /dev/null +++ b/declarativeimports/krunnermodel/test/main.cpp @@ -0,0 +1,35 @@ +#include +#include +#include +#include +#include +#include + +#include "../runnermodel.h" +#include "modeltest.h" + +int main(int argc, char *argv[]) +{ + QApplication app(argc, argv); + QWidget *widget = new QWidget; + QVBoxLayout *layout = new QVBoxLayout(widget); + + RunnerModel *runnerModel = new RunnerModel(widget); + new ModelTest(runnerModel, widget); + + QLineEdit *input = new QLineEdit(widget); + QObject::connect(input, SIGNAL(textChanged(QString)), runnerModel, SLOT(startQuery(QString))); + layout->addWidget(input); + + QTreeView *view = new QTreeView(widget); + view->setModel(runnerModel); + layout->addWidget(view); + + QAction *quit = new QAction(widget); + quit->setShortcut(Qt::CTRL + Qt::Key_Q); + QObject::connect(quit, SIGNAL(triggered()), &app, SLOT(quit())); + + widget->addAction(quit); + widget->show(); + return app.exec(); +} diff --git a/declarativeimports/krunnermodel/test/modeltest.cpp b/declarativeimports/krunnermodel/test/modeltest.cpp new file mode 100644 index 000000000..88677cc88 --- /dev/null +++ b/declarativeimports/krunnermodel/test/modeltest.cpp @@ -0,0 +1,566 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the test suite 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 + +#include "modeltest.h" + +#include +//#undef Q_ASSERT +//#define Q_ASSERT QVERIFY + +Q_DECLARE_METATYPE ( QModelIndex ) + +/*! + Connect to all of the models signals. Whenever anything happens recheck everything. +*/ +ModelTest::ModelTest ( QAbstractItemModel *_model, QObject *parent ) : QObject ( parent ), model ( _model ), fetchingMore ( false ) +{ + Q_ASSERT ( model ); + + connect ( model, SIGNAL (columnsAboutToBeInserted(QModelIndex,int,int)), + this, SLOT (runAllTests()) ); + connect ( model, SIGNAL (columnsAboutToBeRemoved(QModelIndex,int,int)), + this, SLOT (runAllTests()) ); + connect ( model, SIGNAL (columnsInserted(QModelIndex,int,int)), + this, SLOT (runAllTests()) ); + connect ( model, SIGNAL (columnsRemoved(QModelIndex,int,int)), + this, SLOT (runAllTests()) ); + connect ( model, SIGNAL (dataChanged(QModelIndex,QModelIndex)), + this, SLOT (runAllTests()) ); + connect ( model, SIGNAL (headerDataChanged(Qt::Orientation,int,int)), + this, SLOT (runAllTests()) ); + connect ( model, SIGNAL (layoutAboutToBeChanged()), this, SLOT (runAllTests()) ); + connect ( model, SIGNAL (layoutChanged()), this, SLOT (runAllTests()) ); + connect ( model, SIGNAL (modelReset()), this, SLOT (runAllTests()) ); + connect ( model, SIGNAL (rowsAboutToBeInserted(QModelIndex,int,int)), + this, SLOT (runAllTests()) ); + connect ( model, SIGNAL (rowsAboutToBeRemoved(QModelIndex,int,int)), + this, SLOT (runAllTests()) ); + connect ( model, SIGNAL (rowsInserted(QModelIndex,int,int)), + this, SLOT (runAllTests()) ); + connect ( model, SIGNAL (rowsRemoved(QModelIndex,int,int)), + this, SLOT (runAllTests()) ); + + // Special checks for inserting/removing + connect ( model, SIGNAL (layoutAboutToBeChanged()), + this, SLOT (layoutAboutToBeChanged()) ); + connect ( model, SIGNAL (layoutChanged()), + this, SLOT (layoutChanged()) ); + + connect ( model, SIGNAL (rowsAboutToBeInserted(QModelIndex,int,int)), + this, SLOT (rowsAboutToBeInserted(QModelIndex,int,int)) ); + connect ( model, SIGNAL (rowsAboutToBeRemoved(QModelIndex,int,int)), + this, SLOT (rowsAboutToBeRemoved(QModelIndex,int,int)) ); + connect ( model, SIGNAL (rowsInserted(QModelIndex,int,int)), + this, SLOT (rowsInserted(QModelIndex,int,int)) ); + connect ( model, SIGNAL (rowsRemoved(QModelIndex,int,int)), + this, SLOT (rowsRemoved(QModelIndex,int,int)) ); + + runAllTests(); +} + +void ModelTest::runAllTests() +{ + if ( fetchingMore ) + return; + nonDestructiveBasicTest(); + rowCount(); + columnCount(); + hasIndex(); + index(); + parent(); + data(); +} + +/*! + nonDestructiveBasicTest tries to call a number of the basic functions (not all) + to make sure the model doesn't outright segfault, testing the functions that makes sense. +*/ +void ModelTest::nonDestructiveBasicTest() +{ + Q_ASSERT ( model->buddy ( QModelIndex() ) == QModelIndex() ); + model->canFetchMore ( QModelIndex() ); + Q_ASSERT ( model->columnCount ( QModelIndex() ) >= 0 ); + Q_ASSERT ( model->data ( QModelIndex() ) == QVariant() ); + fetchingMore = true; + model->fetchMore ( QModelIndex() ); + fetchingMore = false; + Qt::ItemFlags flags = model->flags ( QModelIndex() ); + Q_ASSERT ( flags == Qt::ItemIsDropEnabled || flags == 0 ); + model->hasChildren ( QModelIndex() ); + model->hasIndex ( 0, 0 ); + model->headerData ( 0, Qt::Horizontal ); + model->index ( 0, 0 ); + model->itemData ( QModelIndex() ); + QVariant cache; + model->match ( QModelIndex(), -1, cache ); + model->mimeTypes(); + Q_ASSERT ( model->parent ( QModelIndex() ) == QModelIndex() ); + Q_ASSERT ( model->rowCount() >= 0 ); + QVariant variant; + model->setData ( QModelIndex(), variant, -1 ); + model->setHeaderData ( -1, Qt::Horizontal, QVariant() ); + model->setHeaderData ( 999999, Qt::Horizontal, QVariant() ); + QMap roles; + model->sibling ( 0, 0, QModelIndex() ); + model->span ( QModelIndex() ); + model->supportedDropActions(); +} + +/*! + Tests model's implementation of QAbstractItemModel::rowCount() and hasChildren() + + Models that are dynamically populated are not as fully tested here. + */ +void ModelTest::rowCount() +{ +// qDebug() << "rc"; + // check top row + QModelIndex topIndex = model->index ( 0, 0, QModelIndex() ); + int rows = model->rowCount ( topIndex ); + Q_ASSERT ( rows >= 0 ); + if ( rows > 0 ) + Q_ASSERT ( model->hasChildren ( topIndex ) == true ); + + QModelIndex secondLevelIndex = model->index ( 0, 0, topIndex ); + if ( secondLevelIndex.isValid() ) { // not the top level + // check a row count where parent is valid + rows = model->rowCount ( secondLevelIndex ); + Q_ASSERT ( rows >= 0 ); + if ( rows > 0 ) + Q_ASSERT ( model->hasChildren ( secondLevelIndex ) == true ); + } + + // The models rowCount() is tested more extensively in checkChildren(), + // but this catches the big mistakes +} + +/*! + Tests model's implementation of QAbstractItemModel::columnCount() and hasChildren() + */ +void ModelTest::columnCount() +{ + // check top row + QModelIndex topIndex = model->index ( 0, 0, QModelIndex() ); + Q_ASSERT ( model->columnCount ( topIndex ) >= 0 ); + + // check a column count where parent is valid + QModelIndex childIndex = model->index ( 0, 0, topIndex ); + if ( childIndex.isValid() ) + Q_ASSERT ( model->columnCount ( childIndex ) >= 0 ); + + // columnCount() is tested more extensively in checkChildren(), + // but this catches the big mistakes +} + +/*! + Tests model's implementation of QAbstractItemModel::hasIndex() + */ +void ModelTest::hasIndex() +{ +// qDebug() << "hi"; + // Make sure that invalid values returns an invalid index + Q_ASSERT ( model->hasIndex ( -2, -2 ) == false ); + Q_ASSERT ( model->hasIndex ( -2, 0 ) == false ); + Q_ASSERT ( model->hasIndex ( 0, -2 ) == false ); + + int rows = model->rowCount(); + int columns = model->columnCount(); + + // check out of bounds + Q_ASSERT ( model->hasIndex ( rows, columns ) == false ); + Q_ASSERT ( model->hasIndex ( rows + 1, columns + 1 ) == false ); + + if ( rows > 0 ) + Q_ASSERT ( model->hasIndex ( 0, 0 ) == true ); + + // hasIndex() is tested more extensively in checkChildren(), + // but this catches the big mistakes +} + +/*! + Tests model's implementation of QAbstractItemModel::index() + */ +void ModelTest::index() +{ +// qDebug() << "i"; + // Make sure that invalid values returns an invalid index + Q_ASSERT ( model->index ( -2, -2 ) == QModelIndex() ); + Q_ASSERT ( model->index ( -2, 0 ) == QModelIndex() ); + Q_ASSERT ( model->index ( 0, -2 ) == QModelIndex() ); + + int rows = model->rowCount(); + int columns = model->columnCount(); + + if ( rows == 0 ) + return; + + // Catch off by one errors + Q_ASSERT ( model->index ( rows, columns ) == QModelIndex() ); + Q_ASSERT ( model->index ( 0, 0 ).isValid() == true ); + + // Make sure that the same index is *always* returned + QModelIndex a = model->index ( 0, 0 ); + QModelIndex b = model->index ( 0, 0 ); + Q_ASSERT ( a == b ); + + // index() is tested more extensively in checkChildren(), + // but this catches the big mistakes +} + +/*! + Tests model's implementation of QAbstractItemModel::parent() + */ +void ModelTest::parent() +{ +// qDebug() << "p"; + // Make sure the model wont crash and will return an invalid QModelIndex + // when asked for the parent of an invalid index. + Q_ASSERT ( model->parent ( QModelIndex() ) == QModelIndex() ); + + if ( model->rowCount() == 0 ) + return; + + // Column 0 | Column 1 | + // QModelIndex() | | + // \- topIndex | topIndex1 | + // \- childIndex | childIndex1 | + + // Common error test #1, make sure that a top level index has a parent + // that is a invalid QModelIndex. + QModelIndex topIndex = model->index ( 0, 0, QModelIndex() ); + Q_ASSERT ( model->parent ( topIndex ) == QModelIndex() ); + + // Common error test #2, make sure that a second level index has a parent + // that is the first level index. + if ( model->rowCount ( topIndex ) > 0 ) { + QModelIndex childIndex = model->index ( 0, 0, topIndex ); + Q_ASSERT ( model->parent ( childIndex ) == topIndex ); + } + + // Common error test #3, the second column should NOT have the same children + // as the first column in a row. + // Usually the second column shouldn't have children. + QModelIndex topIndex1 = model->index ( 0, 1, QModelIndex() ); + if ( model->rowCount ( topIndex1 ) > 0 ) { + QModelIndex childIndex = model->index ( 0, 0, topIndex ); + QModelIndex childIndex1 = model->index ( 0, 0, topIndex1 ); + Q_ASSERT ( childIndex != childIndex1 ); + } + + // Full test, walk n levels deep through the model making sure that all + // parent's children correctly specify their parent. + checkChildren ( QModelIndex() ); +} + +/*! + Called from the parent() test. + + A model that returns an index of parent X should also return X when asking + for the parent of the index. + + This recursive function does pretty extensive testing on the whole model in an + effort to catch edge cases. + + This function assumes that rowCount(), columnCount() and index() already work. + If they have a bug it will point it out, but the above tests should have already + found the basic bugs because it is easier to figure out the problem in + those tests then this one. + */ +void ModelTest::checkChildren ( const QModelIndex &parent, int currentDepth ) +{ + // First just try walking back up the tree. + QModelIndex p = parent; + while ( p.isValid() ) + p = p.parent(); + + // For models that are dynamically populated + if ( model->canFetchMore ( parent ) ) { + fetchingMore = true; + model->fetchMore ( parent ); + fetchingMore = false; + } + + int rows = model->rowCount ( parent ); + int columns = model->columnCount ( parent ); + + if ( rows > 0 ) + Q_ASSERT ( model->hasChildren ( parent ) ); + + // Some further testing against rows(), columns(), and hasChildren() + Q_ASSERT ( rows >= 0 ); + Q_ASSERT ( columns >= 0 ); + if ( rows > 0 ) + Q_ASSERT ( model->hasChildren ( parent ) == true ); + + //qDebug() << "parent:" << model->data(parent).toString() << "rows:" << rows + // << "columns:" << columns << "parent column:" << parent.column(); + + Q_ASSERT ( model->hasIndex ( rows + 1, 0, parent ) == false ); + for ( int r = 0; r < rows; ++r ) { + if ( model->canFetchMore ( parent ) ) { + fetchingMore = true; + model->fetchMore ( parent ); + fetchingMore = false; + } + Q_ASSERT ( model->hasIndex ( r, columns + 1, parent ) == false ); + for ( int c = 0; c < columns; ++c ) { + Q_ASSERT ( model->hasIndex ( r, c, parent ) == true ); + QModelIndex index = model->index ( r, c, parent ); + // rowCount() and columnCount() said that it existed... + Q_ASSERT ( index.isValid() == true ); + + // index() should always return the same index when called twice in a row + QModelIndex modifiedIndex = model->index ( r, c, parent ); + Q_ASSERT ( index == modifiedIndex ); + + // Make sure we get the same index if we request it twice in a row + QModelIndex a = model->index ( r, c, parent ); + QModelIndex b = model->index ( r, c, parent ); + Q_ASSERT ( a == b ); + + // Some basic checking on the index that is returned + Q_ASSERT ( index.model() == model ); + Q_ASSERT ( index.row() == r ); + Q_ASSERT ( index.column() == c ); + // While you can technically return a QVariant usually this is a sign + // of an bug in data() Disable if this really is ok in your model. +// Q_ASSERT ( model->data ( index, Qt::DisplayRole ).isValid() == true ); + + // If the next test fails here is some somewhat useful debug you play with. + + if (model->parent(index) != parent) { + qDebug() << r << c << currentDepth << model->data(index).toString() + << model->data(parent).toString(); + qDebug() << index << parent << model->parent(index); +// And a view that you can even use to show the model. +// QTreeView view; +// view.setModel(model); +// view.show(); + } + + // Check that we can get back our real parent. +// qDebug() << model->parent ( index ) << parent ; + Q_ASSERT ( model->parent ( index ) == parent ); + + // recursively go down the children + if ( model->hasChildren ( index ) && currentDepth < 10 ) { + //qDebug() << r << c << "has children" << model->rowCount(index); + checkChildren ( index, ++currentDepth ); + }/* else { if (currentDepth >= 10) qDebug() << "checked 10 deep"; };*/ + + // make sure that after testing the children that the index doesn't change. + QModelIndex newerIndex = model->index ( r, c, parent ); + Q_ASSERT ( index == newerIndex ); + } + } +} + +/*! + Tests model's implementation of QAbstractItemModel::data() + */ +void ModelTest::data() +{ + // Invalid index should return an invalid qvariant + Q_ASSERT ( !model->data ( QModelIndex() ).isValid() ); + + if ( model->rowCount() == 0 ) + return; + + // A valid index should have a valid QVariant data + Q_ASSERT ( model->index ( 0, 0 ).isValid() ); + + // shouldn't be able to set data on an invalid index + Q_ASSERT ( model->setData ( QModelIndex(), QLatin1String ( "foo" ), Qt::DisplayRole ) == false ); + + // General Purpose roles that should return a QString + QVariant variant = model->data ( model->index ( 0, 0 ), Qt::ToolTipRole ); + if ( variant.isValid() ) { + Q_ASSERT ( qVariantCanConvert ( variant ) ); + } + variant = model->data ( model->index ( 0, 0 ), Qt::StatusTipRole ); + if ( variant.isValid() ) { + Q_ASSERT ( qVariantCanConvert ( variant ) ); + } + variant = model->data ( model->index ( 0, 0 ), Qt::WhatsThisRole ); + if ( variant.isValid() ) { + Q_ASSERT ( qVariantCanConvert ( variant ) ); + } + + // General Purpose roles that should return a QSize + variant = model->data ( model->index ( 0, 0 ), Qt::SizeHintRole ); + if ( variant.isValid() ) { + Q_ASSERT ( qVariantCanConvert ( variant ) ); + } + + // General Purpose roles that should return a QFont + QVariant fontVariant = model->data ( model->index ( 0, 0 ), Qt::FontRole ); + if ( fontVariant.isValid() ) { + Q_ASSERT ( qVariantCanConvert ( fontVariant ) ); + } + + // Check that the alignment is one we know about + QVariant textAlignmentVariant = model->data ( model->index ( 0, 0 ), Qt::TextAlignmentRole ); + if ( textAlignmentVariant.isValid() ) { + int alignment = textAlignmentVariant.toInt(); + Q_ASSERT ( alignment == ( alignment & ( Qt::AlignHorizontal_Mask | Qt::AlignVertical_Mask ) ) ); + } + + // General Purpose roles that should return a QColor + QVariant colorVariant = model->data ( model->index ( 0, 0 ), Qt::BackgroundColorRole ); + if ( colorVariant.isValid() ) { + Q_ASSERT ( qVariantCanConvert ( colorVariant ) ); + } + + colorVariant = model->data ( model->index ( 0, 0 ), Qt::TextColorRole ); + if ( colorVariant.isValid() ) { + Q_ASSERT ( qVariantCanConvert ( colorVariant ) ); + } + + // Check that the "check state" is one we know about. + QVariant checkStateVariant = model->data ( model->index ( 0, 0 ), Qt::CheckStateRole ); + if ( checkStateVariant.isValid() ) { + int state = checkStateVariant.toInt(); + Q_ASSERT ( state == Qt::Unchecked || + state == Qt::PartiallyChecked || + state == Qt::Checked ); + } +} + +/*! + Store what is about to be inserted to make sure it actually happens + + \sa rowsInserted() + */ +void ModelTest::rowsAboutToBeInserted ( const QModelIndex &parent, int start, int end ) +{ +// Q_UNUSED(end); +// qDebug() << "rowsAboutToBeInserted" << "start=" << start << "end=" << end << "parent=" << model->data ( parent ).toString() +// << "current count of parent=" << model->rowCount ( parent ); // << "display of last=" << model->data( model->index(start-1, 0, parent) ); +// qDebug() << model->index(start-1, 0, parent) << model->data( model->index(start-1, 0, parent) ); + Changing c; + c.parent = parent; + c.oldSize = model->rowCount ( parent ); + c.last = model->data ( model->index ( start - 1, 0, parent ) ); + c.next = model->data ( model->index ( start, 0, parent ) ); + insert.push ( c ); +} + +/*! + Confirm that what was said was going to happen actually did + + \sa rowsAboutToBeInserted() + */ +void ModelTest::rowsInserted ( const QModelIndex & parent, int start, int end ) +{ + Changing c = insert.pop(); + Q_ASSERT ( c.parent == parent ); +// qDebug() << "rowsInserted" << "start=" << start << "end=" << end << "oldsize=" << c.oldSize +// << "parent=" << model->data ( parent ).toString() << "current rowcount of parent=" << model->rowCount ( parent ); + +// for (int ii=start; ii <= end; ii++) +// { +// qDebug() << "itemWasInserted:" << ii << model->data ( model->index ( ii, 0, parent )); +// } +// qDebug(); + + Q_ASSERT ( c.oldSize + ( end - start + 1 ) == model->rowCount ( parent ) ); + Q_ASSERT ( c.last == model->data ( model->index ( start - 1, 0, c.parent ) ) ); + + if (c.next != model->data(model->index(end + 1, 0, c.parent))) { + qDebug() << start << end; + for (int i=0; i < model->rowCount(); ++i) + qDebug() << model->index(i, 0).data().toString(); + qDebug() << c.next << model->data(model->index(end + 1, 0, c.parent)); + } + + Q_ASSERT ( c.next == model->data ( model->index ( end + 1, 0, c.parent ) ) ); +} + +void ModelTest::layoutAboutToBeChanged() +{ + for ( int i = 0; i < qBound ( 0, model->rowCount(), 100 ); ++i ) + changing.append ( QPersistentModelIndex ( model->index ( i, 0 ) ) ); +} + +void ModelTest::layoutChanged() +{ + for ( int i = 0; i < changing.count(); ++i ) { + QPersistentModelIndex p = changing[i]; + Q_ASSERT ( p == model->index ( p.row(), p.column(), p.parent() ) ); + } + changing.clear(); +} + +/*! + Store what is about to be inserted to make sure it actually happens + + \sa rowsRemoved() + */ +void ModelTest::rowsAboutToBeRemoved ( const QModelIndex &parent, int start, int end ) +{ +qDebug() << "ratbr" << parent << start << end; + Changing c; + c.parent = parent; + c.oldSize = model->rowCount ( parent ); + c.last = model->data ( model->index ( start - 1, 0, parent ) ); + c.next = model->data ( model->index ( end + 1, 0, parent ) ); + remove.push ( c ); +} + +/*! + Confirm that what was said was going to happen actually did + + \sa rowsAboutToBeRemoved() + */ +void ModelTest::rowsRemoved ( const QModelIndex & parent, int start, int end ) +{ + qDebug() << "rr" << parent << start << end; + Changing c = remove.pop(); + Q_ASSERT ( c.parent == parent ); + Q_ASSERT ( c.oldSize - ( end - start + 1 ) == model->rowCount ( parent ) ); + Q_ASSERT ( c.last == model->data ( model->index ( start - 1, 0, c.parent ) ) ); + Q_ASSERT ( c.next == model->data ( model->index ( start, 0, c.parent ) ) ); +} + + diff --git a/declarativeimports/krunnermodel/test/modeltest.h b/declarativeimports/krunnermodel/test/modeltest.h new file mode 100644 index 000000000..f042ed2c5 --- /dev/null +++ b/declarativeimports/krunnermodel/test/modeltest.h @@ -0,0 +1,94 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the test suite 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$ +** +****************************************************************************/ + + +#ifndef MODELTEST_H +#define MODELTEST_H + +#include +#include +#include + +class ModelTest : public QObject +{ + Q_OBJECT + +public: + explicit ModelTest( QAbstractItemModel *model, QObject *parent = 0 ); + +private Q_SLOTS: + void nonDestructiveBasicTest(); + void rowCount(); + void columnCount(); + void hasIndex(); + void index(); + void parent(); + void data(); + +protected Q_SLOTS: + void runAllTests(); + void layoutAboutToBeChanged(); + void layoutChanged(); + void rowsAboutToBeInserted( const QModelIndex &parent, int start, int end ); + void rowsInserted( const QModelIndex & parent, int start, int end ); + void rowsAboutToBeRemoved( const QModelIndex &parent, int start, int end ); + void rowsRemoved( const QModelIndex & parent, int start, int end ); + +private: + void checkChildren( const QModelIndex &parent, int currentDepth = 0 ); + + QAbstractItemModel *model; + + struct Changing { + QModelIndex parent; + int oldSize; + QVariant last; + QVariant next; + }; + QStack insert; + QStack remove; + + bool fetchingMore; + + QList changing; +}; + +#endif