move krunnermodel into plasma/declarativeimports where it belongs

(slight mistake on the git-filter-branch import from plasma-mobile.
So it'll live here now, so that other gizmos can use it.

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)

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)

declarativeimports/krunnermodel/qmldir

@@ -0,0 +1,2 @@
+plugin runnermodelplugin
+

declarativeimports/krunnermodel/runnermodel.cpp

@@ -0,0 +1,185 @@
+/*
+    Copyright 2011 Aaron Seigo <aseigo@kde.org>
+
+    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 <QIcon>
+#include <QAction>
+#include <QTimer>
+
+#include <KDebug>
+
+#include <Plasma/RunnerManager>
+
+RunnerModel::RunnerModel(QObject *parent)
+    : QAbstractListModel(parent),
+      m_manager(0),
+      m_startQueryTimer(new QTimer(this))
+{
+    QHash<int, QByteArray> 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<QAction*> theactions = m_manager->actionsForMatch(amatch);
+        foreach(QAction* action, theactions) {
+            actions += qVariantFromValue<QObject*>(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<Plasma::QueryMatch>)),
+                this, SLOT(matchesChanged(QList<Plasma::QueryMatch>)));
+
+        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<Plasma::QueryMatch> &matches)
+{
+    //kDebug() << "got matches:" << matches.count();
+    beginResetModel();
+    m_matches = matches;
+    endResetModel();
+    emit countChanged();
+}
+
+#include "runnermodel.moc"
+

declarativeimports/krunnermodel/runnermodel.h

@@ -0,0 +1,112 @@
+/*
+    Copyright 2011 Aaron Seigo <aseigo@kde.org>
+
+    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 <QAbstractListModel>
+#include <QStringList>
+
+namespace Plasma
+{
+    class RunnerManager;
+    class QueryMatch;
+} // namespace Plasma
+
+class QTimer;
+
+/**
+ * This model provides bindings to use KRunner from QML
+ *
+ * @author Aaron Seigo <aseigo@kde.org>
+ */
+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<Plasma::QueryMatch> &matches);
+
+private:
+    Plasma::RunnerManager *m_manager;
+    QList<Plasma::QueryMatch> m_matches;
+    QStringList m_pendingRunnersList;
+    QString m_pendingQuery;
+    QTimer *m_startQueryTimer;
+};
+
+#endif

declarativeimports/krunnermodel/runnermodelplugin.cpp

@@ -0,0 +1,37 @@
+/*
+ *   Copyright 2011 by Marco Martin <mart@kde.org>
+
+ *   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 <QtDeclarative/qdeclarative.h>
+
+#include <Plasma/QueryMatch>
+
+#include "runnermodel.h"
+
+void RunnerModelPlugin::registerTypes(const char *uri)
+{
+    Q_ASSERT(uri == QLatin1String("org.kde.runnermodel"));
+    qmlRegisterType<RunnerModel>(uri, 0, 1, "RunnerModel");
+    qmlRegisterInterface<Plasma::QueryMatch>("QueryMatch");
+    qRegisterMetaType<Plasma::QueryMatch *>("QueryMatch");
+}
+
+#include "runnermodelplugin.moc"
+

declarativeimports/krunnermodel/runnermodelplugin.h

@@ -0,0 +1,36 @@
+/*
+ *   Copyright 2011 by Marco Martin <mart@kde.org>
+ *   Copyright 2011 by Aaron Seigo <aseigo@kde.org>
+ *   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 <QDeclarativeExtensionPlugin>
+
+
+class RunnerModelPlugin : public QDeclarativeExtensionPlugin
+{
+    Q_OBJECT
+
+public:
+    void registerTypes(const char *uri);
+};
+
+Q_EXPORT_PLUGIN2(datamodelsplugin, RunnerModelPlugin)
+
+#endif

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})
+

declarativeimports/krunnermodel/test/dynamictreemodel.cpp

@@ -0,0 +1,336 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Stephen Kelly <steveire@gmail.com>
+** 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 <QtCore/QHash>
+#include <QtCore/QList>
+#include <QtCore/QTimer>
+
+
+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<QList<qint64> > childIdColumns = m_childItems.value(parent.internalId());
+
+  const qint64 grandParent = findParentId(parent.internalId());
+  if (grandParent >= 0) {
+    QList<QList<qint64> > parentTable = m_childItems.value(grandParent);
+    Q_ASSERT(parent.column() < parentTable.size());
+    QList<qint64> parentSiblings = parentTable.at(parent.column());
+    Q_ASSERT(parent.row() < parentSiblings.size());
+  }
+
+  if (childIdColumns.size() == 0)
+    return QModelIndex();
+
+  if (column >= childIdColumns.size())
+    return QModelIndex();
+
+  QList<qint64> rowIds = childIdColumns.at(column);
+
+  if ( row >= rowIds.size())
+    return QModelIndex();
+
+  qint64 id = rowIds.at(row);
+
+  return createIndex(row, column, reinterpret_cast<void *>(id));
+
+}
+
+qint64 DynamicTreeModel::findParentId(qint64 searchId) const
+{
+  if (searchId <= 0)
+    return -1;
+
+  QHashIterator<qint64, QList<QList<qint64> > > i(m_childItems);
+  while (i.hasNext())
+  {
+    i.next();
+    QListIterator<QList<qint64> > j(i.value());
+    while (j.hasNext())
+    {
+      QList<qint64> 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<qint64> childList = m_childItems.value(grandParentId).at(column);
+
+  int row = childList.indexOf(parentId);
+
+  return createIndex(row, column, reinterpret_cast<void *>(parentId));
+
+}
+
+int DynamicTreeModel::rowCount(const QModelIndex &index ) const
+{
+  QList<QList<qint64> > 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<int> rows)
+{
+  const int col = 0;
+  QModelIndex parent = QModelIndex();
+  QListIterator<int> 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<qint64>());
+      }
+//       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<qint64> 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();
+}
+

declarativeimports/krunnermodel/test/dynamictreemodel.h

@@ -0,0 +1,197 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Stephen Kelly <steveire@gmail.com>
+** 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 <QtCore/QAbstractItemModel>
+
+#include <QtCore/QHash>
+#include <QtCore/QList>
+
+
+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<qint64, QString> m_items;
+  QHash<qint64, QList<QList<qint64> > > 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<int> rowNumbers) { m_rowNumbers = rowNumbers; }
+
+  QModelIndex findIndex(QList<int> 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<int> m_rowNumbers;
+  int m_numCols;
+  int m_startRow;
+  int m_endRow;
+
+};
+
+typedef QList<ModelChangeCommand*> 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<int> rows ) { m_destRowNumbers = rows; }
+
+  void setDestRow(int row) { m_destRow = row; }
+
+protected:
+  QList<int> 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

declarativeimports/krunnermodel/test/main.cpp

@@ -0,0 +1,35 @@
+#include <QAction>
+#include <QApplication>
+#include <QDialog>
+#include <QLineEdit>
+#include <QTreeView>
+#include <QVBoxLayout>
+
+#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();
+}

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 <QtGui/QtGui>
+
+#include "modeltest.h"
+
+#include <QtTest/QtTest>
+//#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<int, QVariant> 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<QString> ( variant ) );
+    }
+    variant = model->data ( model->index ( 0, 0 ), Qt::StatusTipRole );
+    if ( variant.isValid() ) {
+        Q_ASSERT ( qVariantCanConvert<QString> ( variant ) );
+    }
+    variant = model->data ( model->index ( 0, 0 ), Qt::WhatsThisRole );
+    if ( variant.isValid() ) {
+        Q_ASSERT ( qVariantCanConvert<QString> ( variant ) );
+    }
+
+    // General Purpose roles that should return a QSize
+    variant = model->data ( model->index ( 0, 0 ), Qt::SizeHintRole );
+    if ( variant.isValid() ) {
+        Q_ASSERT ( qVariantCanConvert<QSize> ( 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<QFont> ( 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<QColor> ( colorVariant ) );
+    }
+
+    colorVariant = model->data ( model->index ( 0, 0 ), Qt::TextColorRole );
+    if ( colorVariant.isValid() ) {
+        Q_ASSERT ( qVariantCanConvert<QColor> ( 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 ) ) );
+}
+
+

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 <QtCore/QObject>
+#include <QtCore/QAbstractItemModel>
+#include <QtCore/QStack>
+
+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<Changing> insert;
+  QStack<Changing> remove;
+
+  bool fetchingMore;
+
+  QList<QPersistentModelIndex> changing;
+};
+
+#endif