QmlObjectListModel.cc 5.88 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
/*=====================================================================
 
 QGroundControl Open Source Ground Control Station
 
 (c) 2009, 2015 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
 
 This file is part of the QGROUNDCONTROL project
 
 QGROUNDCONTROL is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.
 
 QGROUNDCONTROL 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 General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with QGROUNDCONTROL. If not, see <http://www.gnu.org/licenses/>.
 
 ======================================================================*/

/// @file
///     @author Don Gagne <don@thegagnes.com>

#include "QmlObjectListModel.h"

#include <QDebug>
Don Gagne's avatar
Don Gagne committed
30
#include <QQmlEngine>
31 32

const int QmlObjectListModel::ObjectRole = Qt::UserRole;
33
const int QmlObjectListModel::TextRole = Qt::UserRole + 1;
34 35 36

QmlObjectListModel::QmlObjectListModel(QObject* parent)
    : QAbstractListModel(parent)
Don Gagne's avatar
Don Gagne committed
37
    , _dirty(false)
Don Gagne's avatar
Don Gagne committed
38
    , _skipDirtyFirstItem(false)
39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66
{

}

QmlObjectListModel::~QmlObjectListModel()
{
    
}

int QmlObjectListModel::rowCount(const QModelIndex& parent) const
{
    Q_UNUSED(parent);
    
    return _objectList.count();
}

QVariant QmlObjectListModel::data(const QModelIndex &index, int role) const
{
    if (!index.isValid()) {
        return QVariant();
    }
    
    if (index.row() >= _objectList.count()) {
        return QVariant();
    }
    
    if (role == ObjectRole) {
        return QVariant::fromValue(_objectList[index.row()]);
67 68
    } else if (role == TextRole) {
        return QVariant::fromValue(_objectList[index.row()]->objectName());
69 70 71 72 73 74 75 76 77 78
    } else {
        return QVariant();
    }
}

QHash<int, QByteArray> QmlObjectListModel::roleNames(void) const
{
    QHash<int, QByteArray> hash;
    
    hash[ObjectRole] = "object";
79
    hash[TextRole] = "text";
80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
    
    return hash;
}

bool QmlObjectListModel::setData(const QModelIndex& index, const QVariant& value, int role)
{
    if (index.isValid() && role == ObjectRole) {
        _objectList.replace(index.row(), value.value<QObject*>());
        emit dataChanged(index, index);
        return true;
    }
    
    return false;
}

bool QmlObjectListModel::insertRows(int position, int rows, const QModelIndex& parent)
{
    Q_UNUSED(parent);
    
99 100 101 102
    if (position < 0 || position > _objectList.count() + 1) {
        qWarning() << "Invalid position position:count" << position << _objectList.count();
    }
    
103 104 105 106 107 108 109 110 111 112 113 114
    beginInsertRows(QModelIndex(), position, position + rows - 1);
    endInsertRows();
    
    emit countChanged(count());
    
    return true;
}

bool QmlObjectListModel::removeRows(int position, int rows, const QModelIndex& parent)
{
    Q_UNUSED(parent);
    
115 116 117 118 119 120
    if (position < 0 || position >= _objectList.count()) {
        qWarning() << "Invalid position position:count" << position << _objectList.count();
    } else if (position + rows > _objectList.count()) {
        qWarning() << "Invalid rows position:rows:count" << position << rows << _objectList.count();
    }
    
121 122
    beginRemoveRows(QModelIndex(), position, position + rows - 1);
    for (int row=0; row<rows; row++) {
123 124
        // FIXME: Need to figure our correct memory management for here
        //_objectList[position]->deleteLater();
125 126 127 128 129 130 131 132 133
        _objectList.removeAt(position);
    }
    endRemoveRows();
    
    emit countChanged(count());
    
    return true;
}

Don Gagne's avatar
Don Gagne committed
134 135 136 137 138 139
QObject* QmlObjectListModel::operator[](int index)
{
    return _objectList[index];
}

const QObject* QmlObjectListModel::operator[](int index) const
140 141 142 143 144 145 146
{
    return _objectList[index];
}

void QmlObjectListModel::clear(void)
{
    while (rowCount()) {
Don Gagne's avatar
Don Gagne committed
147
        removeAt(0);
148 149 150
    }
}

Don Gagne's avatar
Don Gagne committed
151
QObject* QmlObjectListModel::removeAt(int i)
152
{
Don Gagne's avatar
Don Gagne committed
153
    QObject* removedObject = _objectList[i];
154

Don Gagne's avatar
Don Gagne committed
155 156
    // Look for a dirtyChanged signal on the object
    if (_objectList[i]->metaObject()->indexOfSignal(QMetaObject::normalizedSignature("dirtyChanged(bool)")) != -1) {
Don Gagne's avatar
Don Gagne committed
157 158 159
        if (!_skipDirtyFirstItem || i != 0) {
            QObject::disconnect(_objectList[i], SIGNAL(dirtyChanged(bool)), this, SLOT(_childDirtyChanged(bool)));
        }
Don Gagne's avatar
Don Gagne committed
160 161
    }
    
162
    removeRows(i, 1);
163 164
    
    setDirty(true);
Don Gagne's avatar
Don Gagne committed
165 166
    
    return removedObject;
167 168
}

169 170 171 172 173 174
void QmlObjectListModel::insert(int i, QObject* object)
{
    if (i < 0 || i > _objectList.count()) {
        qWarning() << "Invalid index index:count" << i << _objectList.count();
    }
    
Don Gagne's avatar
Don Gagne committed
175
    QQmlEngine::setObjectOwnership(object, QQmlEngine::CppOwnership);
Don Gagne's avatar
Don Gagne committed
176 177 178
    
    // Look for a dirtyChanged signal on the object
    if (object->metaObject()->indexOfSignal(QMetaObject::normalizedSignature("dirtyChanged(bool)")) != -1) {
Don Gagne's avatar
Don Gagne committed
179 180 181
        if (!_skipDirtyFirstItem || i != 0) {
            QObject::connect(object, SIGNAL(dirtyChanged(bool)), this, SLOT(_childDirtyChanged(bool)));
        }
Don Gagne's avatar
Don Gagne committed
182
    }
Don Gagne's avatar
Don Gagne committed
183

184 185
    _objectList.insert(i, object);
    insertRows(i, 1);
186 187
    
    setDirty(true);
188 189
}

190 191
void QmlObjectListModel::append(QObject* object)
{
192
    insert(_objectList.count(), object);
193 194
}

Don Gagne's avatar
Don Gagne committed
195
int QmlObjectListModel::count(void) const
196 197 198 199
{
    return rowCount();
}

Don Gagne's avatar
Don Gagne committed
200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218
void QmlObjectListModel::setDirty(bool dirty)
{
    _dirty = dirty;

    if (!dirty) {
        // Need to clear dirty from all children
        foreach(QObject* object, _objectList) {
            if (object->property("dirty").isValid()) {
                object->setProperty("dirty", false);
            }
        }
    }
    
    emit dirtyChanged(_dirty);
}

void QmlObjectListModel::_childDirtyChanged(bool dirty)
{
    _dirty |= dirty;
219 220
    // We want to emit dirtyChanged even if the actual value of _dirty didn't change. It can be a useful
    // signal to know when a child has changed dirty state
Don Gagne's avatar
Don Gagne committed
221 222
    emit dirtyChanged(_dirty);
}