OP-9 GCS/uavobjectbrowser: Refactoring.

git-svn-id: svn://svn.openpilot.org/OpenPilot/trunk@505 ebee16cc-31ac-478f-84a7-5cbb03baadba

ground/src/plugins/uavobjectbrowser/browseritemdelegate.cpp

@@ -26,11 +26,7 @@
  */
 
 #include "browseritemdelegate.h"
-#include "treeitem.h"
-#include <QtGui/QSpinBox>
-#include <QtGui/QDoubleSpinBox>
-#include <QtGui/QComboBox>
-#include <limits>
+#include "fieldtreeitem.h"
 
 BrowserItemDelegate::BrowserItemDelegate(QObject *parent) :
         QStyledItemDelegate(parent)
@@ -42,27 +38,9 @@ QWidget *BrowserItemDelegate::createEditor(QWidget *parent,
                                            const QModelIndex & index ) const
 {
     FieldTreeItem *item = static_cast<FieldTreeItem*>(index.internalPointer());
-    if (item->isIntType()) {
-        IntFieldTreeItem *intItem = static_cast<IntFieldTreeItem*>(item);
-        QSpinBox *editor = new QSpinBox(parent);
-        editor->setMinimum(intItem->MIN);
-        editor->setMaximum(intItem->MAX);
-        return editor;
-    } else if (item->isEnum()) {
-        EnumFieldTreeItem *enumItem = static_cast<EnumFieldTreeItem*>(item);
-        QComboBox *editor = new QComboBox(parent);
-        foreach (QString option, enumItem->enumOptions)
-            editor->addItem(option);
-        return editor;
-    } else if (item->isFloatType()) {
-        FloatFieldTreeItem *floatItem = static_cast<FloatFieldTreeItem*>(item);
-        QDoubleSpinBox *editor = new QDoubleSpinBox(parent);
-        editor->setDecimals(6);
-        editor->setMinimum(-std::numeric_limits<float>::max());
-        return editor;
-    } else {
-        return QStyledItemDelegate::createEditor(parent, option, index);
-    }
+    QWidget *editor = item->createEditor(parent);
+    Q_ASSERT(editor);
+    return editor;
 }
 
 
@@ -70,44 +48,16 @@ void BrowserItemDelegate::setEditorData(QWidget *editor,
                                         const QModelIndex &index) const
 {
     FieldTreeItem *item = static_cast<FieldTreeItem*>(index.internalPointer());
-    if (item->isIntType()) {
-        int value = index.model()->data(index, Qt::EditRole).toInt();
-        QSpinBox *spinBox = static_cast<QSpinBox*>(editor);
-        spinBox->setValue(value);
-    } else if (item->isEnum()) {
-        int value = index.model()->data(index, Qt::EditRole).toInt();
-        QComboBox *comboBox = static_cast<QComboBox*>(editor);
-        comboBox->setCurrentIndex(value);
-    } else if (item->isFloatType()) {
-        float value = index.model()->data(index, Qt::EditRole).toDouble();
-        QDoubleSpinBox *spinBox = static_cast<QDoubleSpinBox*>(editor);
-        spinBox->setValue(value);
-    } else {
-        QStyledItemDelegate::setEditorData(editor, index);
-    }
+    QVariant value = index.model()->data(index, Qt::EditRole);
+    item->setEditorValue(editor, value);
 }
 
 void BrowserItemDelegate::setModelData(QWidget *editor, QAbstractItemModel *model,
                                        const QModelIndex &index) const
 {
     FieldTreeItem *item = static_cast<FieldTreeItem*>(index.internalPointer());
-    if (item->isIntType()) {
-        QSpinBox *spinBox = static_cast<QSpinBox*>(editor);
-        spinBox->interpretText();
-        int value = spinBox->value();
-        model->setData(index, value, Qt::EditRole);
-    } else if (item->isEnum()) {
-        QComboBox *comboBox = static_cast<QComboBox*>(editor);
-        int value = comboBox->currentIndex();
-        model->setData(index, value, Qt::EditRole);
-    } else if (item->isFloatType()) {
-        QDoubleSpinBox *spinBox = static_cast<QDoubleSpinBox*>(editor);
-        spinBox->interpretText();
-        float value = spinBox->value();
-        model->setData(index, value, Qt::EditRole);
-    } else {
-        QStyledItemDelegate::setModelData(editor, model, index);
-    }
+    QVariant value = item->getEditorValue(editor);
+    model->setData(index, value, Qt::EditRole);
 }
 
 void BrowserItemDelegate::updateEditorGeometry(QWidget *editor,

ground/src/plugins/uavobjectbrowser/fieldtreeitem.cpp

@@ -0,0 +1,29 @@
+/**
+ ******************************************************************************
+ *
+ * @file       fieldtreeitem.cpp
+ * @author     The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
+ * @brief      
+ * @see        The GNU Public License (GPL) Version 3
+ * @defgroup   uavobjectbrowser
+ * @{
+ * 
+ *****************************************************************************/
+/* 
+ * This program 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.
+ * 
+ * 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 General Public License 
+ * for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along 
+ * with this program; if not, write to the Free Software Foundation, Inc., 
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include "fieldtreeitem.h"
+

ground/src/plugins/uavobjectbrowser/fieldtreeitem.h

@@ -0,0 +1,353 @@
+/**
+ ******************************************************************************
+ *
+ * @file       fieldtreeitem.h
+ * @author     The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
+ * @brief      
+ * @see        The GNU Public License (GPL) Version 3
+ * @defgroup   uavobjectbrowser
+ * @{
+ * 
+ *****************************************************************************/
+/* 
+ * This program 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.
+ * 
+ * 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 General Public License 
+ * for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along 
+ * with this program; if not, write to the Free Software Foundation, Inc., 
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#ifndef FIELDTREEITEM_H
+#define FIELDTREEITEM_H
+
+#include "treeitem.h"
+#include <QtCore/QStringList>
+#include <QtGui/QWidget>
+#include <QtGui/QSpinBox>
+#include <QtGui/QDoubleSpinBox>
+#include <QtGui/QComboBox>
+#include <limits>
+
+#define QINT8MIN std::numeric_limits<qint8>::min()
+#define QINT8MAX std::numeric_limits<qint8>::max()
+#define QUINTMIN std::numeric_limits<quint8>::min()
+#define QUINT8MAX std::numeric_limits<quint8>::max()
+#define QINT16MIN std::numeric_limits<qint16>::min()
+#define QINT16MAX std::numeric_limits<qint16>::max()
+#define QUINT16MAX std::numeric_limits<quint16>::max()
+#define QINT32MIN std::numeric_limits<qint32>::min()
+#define QINT32MAX std::numeric_limits<qint32>::max()
+#define QUINT32MAX std::numeric_limits<qint32>::max()
+
+class FieldTreeItem : public TreeItem
+{
+Q_OBJECT
+public:
+    FieldTreeItem(int index, const QList<QVariant> &data, TreeItem *parent = 0) :
+            TreeItem(data, parent), m_index(index) { }
+    FieldTreeItem(int index, const QVariant &data, TreeItem *parent = 0) :
+            TreeItem(data, parent), m_index(index) { }
+    bool isEditable() { return true; }
+    virtual QWidget *createEditor(QWidget *parent) = 0;
+    virtual QVariant getEditorValue(QWidget *editor) = 0;
+    virtual void setEditorValue(QWidget *editor, QVariant value) = 0;
+    virtual void apply() { }
+protected:
+    int m_index;
+};
+
+class EnumFieldTreeItem : public FieldTreeItem
+{
+Q_OBJECT
+public:
+    EnumFieldTreeItem(UAVObjectFieldEnum *field, int index, const QList<QVariant> &data,
+                      TreeItem *parent = 0) :
+    FieldTreeItem(index, data, parent), m_enumOptions(field->getOptions()), m_field(field) { }
+    EnumFieldTreeItem(UAVObjectFieldEnum *field, int index, const QVariant &data,
+                      TreeItem *parent = 0) :
+    FieldTreeItem(index, data, parent), m_enumOptions(field->getOptions()), m_field(field) { }
+    void setData(QVariant value, int column) {
+        setChanged(m_field->getSelectedIndex(m_index) != value);
+        TreeItem::setData(value, column);
+    }
+    QString enumOptions(int index) { return m_enumOptions.at(index); }
+    void apply() {
+        int value = data(dataColumn).toInt();
+        m_field->setSelectedIndex(value, m_index);
+        setChanged(false);
+    }
+    void update() {
+        int value = m_field->getSelectedIndex(m_index);
+        if (data() != value || changed()) {
+            setHighlight(true);
+            TreeItem::setData(value);
+        }
+    }
+    QWidget *createEditor(QWidget *parent) {
+        QComboBox *editor = new QComboBox(parent);
+        foreach (QString option, m_enumOptions)
+            editor->addItem(option);
+        return editor;
+    }
+
+    QVariant getEditorValue(QWidget *editor) {
+        QComboBox *comboBox = static_cast<QComboBox*>(editor);
+        return comboBox->currentIndex();
+    }
+
+    void setEditorValue(QWidget *editor, QVariant value) {
+        QComboBox *comboBox = static_cast<QComboBox*>(editor);
+        comboBox->setCurrentIndex(value.toInt());
+    }
+private:
+    QStringList m_enumOptions;
+    UAVObjectFieldEnum *m_field;
+};
+
+class IntFieldTreeItem : public FieldTreeItem
+{
+Q_OBJECT
+public:
+    IntFieldTreeItem(int index, const QList<QVariant> &data, int min, int max, TreeItem *parent = 0) :
+            FieldTreeItem(index, data, parent), m_minValue(min), m_maxValue(max) { }
+    IntFieldTreeItem(int index, const QVariant &data, int min, int max, TreeItem *parent = 0) :
+            FieldTreeItem(index, data, parent), m_minValue(min), m_maxValue(max) { }
+    QWidget *createEditor(QWidget *parent) {
+        QSpinBox *editor = new QSpinBox(parent);
+        editor->setMinimum(m_minValue);
+        editor->setMaximum(m_maxValue);
+        return editor;
+    }
+
+    QVariant getEditorValue(QWidget *editor) {
+        QSpinBox *spinBox = static_cast<QSpinBox*>(editor);
+        spinBox->interpretText();
+        return spinBox->value();
+    }
+
+    void setEditorValue(QWidget *editor, QVariant value) {
+        QSpinBox *spinBox = static_cast<QSpinBox*>(editor);
+        spinBox->setValue(value.toInt());
+    }
+private:
+    int m_minValue;
+    int m_maxValue;
+};
+
+class Int8FieldTreeItem : public IntFieldTreeItem
+{
+Q_OBJECT
+public:
+    Int8FieldTreeItem(UAVObjectFieldInt8 *field, int index, const QList<QVariant> &data, TreeItem *parent = 0) :
+            IntFieldTreeItem(index, data, QINT8MIN, QINT8MAX, parent), m_field(field) { }
+    Int8FieldTreeItem(UAVObjectFieldInt8 *field, int index, const QVariant &data, TreeItem *parent = 0) :
+            IntFieldTreeItem(index, data, QINT8MIN, QINT8MAX, parent), m_field(field) { }
+    void setData(QVariant value, int column) {
+        setChanged(m_field->getValue(m_index) != value);
+        TreeItem::setData(value, column);
+    }
+    void apply() {
+        m_field->setValue(data(dataColumn).toInt());
+        setChanged(false);
+    }
+    void update() {
+        int value = m_field->getValue(m_index);
+        if (data() != value || changed()) {
+            setHighlight(true);
+            TreeItem::setData(value);
+        }
+    }
+private:
+    UAVObjectFieldInt8 *m_field;
+};
+
+class Int16FieldTreeItem : public IntFieldTreeItem
+{
+Q_OBJECT
+public:
+    Int16FieldTreeItem(UAVObjectFieldInt16 *field, int index, const QList<QVariant> &data, TreeItem *parent = 0) :
+            IntFieldTreeItem(index, data, QINT16MIN, QINT16MAX, parent), m_field(field) { }
+    Int16FieldTreeItem(UAVObjectFieldInt16 *field, int index, const QVariant &data, TreeItem *parent = 0) :
+            IntFieldTreeItem(index, data, QINT16MIN, QINT16MAX, parent), m_field(field) { }
+    void setData(QVariant value, int column) {
+        setChanged(m_field->getValue(m_index) != value);
+        TreeItem::setData(value, column);
+    }
+    void apply() {
+        m_field->setValue(data(dataColumn).toInt());
+        setChanged(false);
+    }
+    void update() {
+        int value = m_field->getValue(m_index);
+        if (data() != value || changed()) {
+            setHighlight(true);
+            TreeItem::setData(value);
+        }
+    }
+private:
+    UAVObjectFieldInt16 *m_field;
+};
+
+class Int32FieldTreeItem : public IntFieldTreeItem
+{
+Q_OBJECT
+public:
+    Int32FieldTreeItem(UAVObjectFieldInt32 *field, int index, const QList<QVariant> &data, TreeItem *parent = 0) :
+            IntFieldTreeItem(index, data, QINT32MIN, QINT32MAX, parent), m_field(field) { }
+    Int32FieldTreeItem(UAVObjectFieldInt32 *field, int index, const QVariant &data, TreeItem *parent = 0) :
+            IntFieldTreeItem(index, data, QINT32MIN, QINT32MAX, parent), m_field(field) { }
+    void setData(QVariant value, int column) {
+        setChanged(m_field->getValue(m_index) != value);
+        TreeItem::setData(value, column);
+    }
+    void apply() {
+        m_field->setValue(data(dataColumn).toInt());
+        setChanged(false);
+    }
+    void update() {
+        int value = m_field->getValue(m_index);
+        if (data() != value || changed()) {
+            setHighlight(true);
+            TreeItem::setData(value);
+        }
+    }
+private:
+    UAVObjectFieldInt32 *m_field;
+};
+
+class UInt8FieldTreeItem : public IntFieldTreeItem
+{
+Q_OBJECT
+public:
+    UInt8FieldTreeItem(UAVObjectFieldUInt8 *field, int index, const QList<QVariant> &data, TreeItem *parent = 0) :
+            IntFieldTreeItem(index, data, QUINTMIN, QUINT8MAX, parent), m_field(field) { }
+    UInt8FieldTreeItem(UAVObjectFieldUInt8 *field, int index, const QVariant &data, TreeItem *parent = 0) :
+            IntFieldTreeItem(index, data, QUINTMIN, QUINT8MAX, parent), m_field(field) { }
+    void setData(QVariant value, int column) {
+        setChanged(m_field->getValue(m_index) != value);
+        TreeItem::setData(value, column);
+    }
+    void apply() {
+        m_field->setValue(data(dataColumn).toInt());
+        setChanged(false);
+    }
+    void update() {
+        int value = m_field->getValue(m_index);
+        if (data() != value || changed()) {
+            setHighlight(true);
+            TreeItem::setData(value);
+        }
+    }
+private:
+    UAVObjectFieldUInt8 *m_field;
+};
+
+class UInt16FieldTreeItem : public IntFieldTreeItem
+{
+Q_OBJECT
+public:
+    UInt16FieldTreeItem(UAVObjectFieldUInt16 *field, int index, const QList<QVariant> &data, TreeItem *parent = 0) :
+            IntFieldTreeItem(index, data, QUINTMIN, QUINT16MAX, parent), m_field(field) { }
+    UInt16FieldTreeItem(UAVObjectFieldUInt16 *field, int index, const QVariant &data, TreeItem *parent = 0) :
+            IntFieldTreeItem(index, data, QUINTMIN, QUINT16MAX, parent), m_field(field) { }
+    void setData(QVariant value, int column) {
+        setChanged(m_field->getValue(m_index) != value);
+        TreeItem::setData(value, column);
+    }
+    void apply() {
+        m_field->setValue(data(dataColumn).toInt());
+        setChanged(false);
+    }
+    void update() {
+        int value = m_field->getValue(m_index);
+        if (data() != value || changed()) {
+            setHighlight(true);
+            TreeItem::setData(value);
+        }
+    }
+private:
+    UAVObjectFieldUInt16 *m_field;
+};
+
+class UInt32FieldTreeItem : public IntFieldTreeItem
+{
+Q_OBJECT
+public:
+    UInt32FieldTreeItem(UAVObjectFieldUInt32 *field, int index, const QList<QVariant> &data, TreeItem *parent = 0) :
+            IntFieldTreeItem(index, data, QUINTMIN, QUINT32MAX, parent), m_field(field) { }
+    UInt32FieldTreeItem(UAVObjectFieldUInt32 *field, int index, const QVariant &data, TreeItem *parent = 0) :
+            IntFieldTreeItem(index, data, QUINTMIN, QUINT32MAX, parent), m_field(field) { }
+    void setData(QVariant value, int column) {
+        setChanged(m_field->getValue(m_index) != value);
+        TreeItem::setData(value, column);
+    }
+    void apply() {
+        m_field->setValue(data(dataColumn).toInt());
+        setChanged(false);
+    }
+    void update() {
+        int value = m_field->getValue(m_index);
+        if (data() != value || changed()) {
+            setHighlight(true);
+            TreeItem::setData(value);
+        }
+    }
+private:
+    UAVObjectFieldUInt32 *m_field;
+};
+
+
+class FloatFieldTreeItem : public FieldTreeItem
+{
+Q_OBJECT
+public:
+    FloatFieldTreeItem(UAVObjectFieldFloat *field, int index, const QList<QVariant> &data, TreeItem *parent = 0) :
+            FieldTreeItem(index, data, parent), m_field(field) { }
+    FloatFieldTreeItem(UAVObjectFieldFloat *field, int index, const QVariant &data, TreeItem *parent = 0) :
+            FieldTreeItem(index, data, parent), m_field(field) { }
+    void setData(QVariant value, int column) {
+        setChanged(m_field->getValue(m_index) != value);
+        TreeItem::setData(value, column);
+    }
+    void apply() {
+        m_field->setValue(data(dataColumn).toDouble(), m_index);
+        setChanged(false);
+    }
+    void update() {
+        double value = m_field->getValue(m_index);
+        if (data() != value || changed()) {
+            setHighlight(true);
+            TreeItem::setData(value);
+        }
+    }
+    QWidget *createEditor(QWidget *parent) {
+        QDoubleSpinBox *editor = new QDoubleSpinBox(parent);
+        editor->setDecimals(6);
+        editor->setMinimum(-std::numeric_limits<float>::max());
+        editor->setMaximum(std::numeric_limits<float>::max());
+        return editor;
+    }
+
+    QVariant getEditorValue(QWidget *editor) {
+        QDoubleSpinBox *spinBox = static_cast<QDoubleSpinBox*>(editor);
+        spinBox->interpretText();
+        return spinBox->value();
+    }
+
+    void setEditorValue(QWidget *editor, QVariant value) {
+        QDoubleSpinBox *spinBox = static_cast<QDoubleSpinBox*>(editor);
+        spinBox->setValue(value.toDouble());
+    }
+private:
+    UAVObjectFieldFloat *m_field;
+};
+
+#endif // FIELDTREEITEM_H

ground/src/plugins/uavobjectbrowser/treeitem.h

@@ -30,32 +30,12 @@
 
 #include "uavobjects/uavobject.h"
 #include "uavobjects/uavmetaobject.h"
-#include "uavobjects/uavobjectfieldenum.h"
-#include "uavobjects/uavobjectfieldint8.h"
-#include "uavobjects/uavobjectfieldint16.h"
-#include "uavobjects/uavobjectfieldint32.h"
-#include "uavobjects/uavobjectfielduint8.h"
-#include "uavobjects/uavobjectfielduint16.h"
-#include "uavobjects/uavobjectfielduint32.h"
-#include "uavobjects/uavobjectfieldfloat.h"
-#include "uavobjects/uavobjectfieldenum.h"
+#include "uavobjects/uavobjectfields.h"
 #include <QtCore/QList>
 #include <QtCore/QVariant>
-#include <QtCore/QStringList>
 #include <QtCore/QTimer>
 #include <QtCore/QObject>
-#include <limits>
 
-#define QINT8MIN std::numeric_limits<qint8>::min()
-#define QINT8MAX std::numeric_limits<qint8>::max()
-#define QUINTMIN std::numeric_limits<quint8>::min()
-#define QUINT8MAX std::numeric_limits<quint8>::max()
-#define QINT16MIN std::numeric_limits<qint16>::min()
-#define QINT16MAX std::numeric_limits<qint16>::max()
-#define QUINT16MAX std::numeric_limits<quint16>::max()
-#define QINT32MIN std::numeric_limits<qint32>::min()
-#define QINT32MAX std::numeric_limits<qint32>::max()
-#define QUINT32MAX std::numeric_limits<qint32>::max()
 
 class TreeItem : public QObject
 {
@@ -200,259 +180,4 @@ public:
     ArrayFieldTreeItem(const QVariant &data, TreeItem *parent = 0) : TreeItem(data, parent) { }
 };
 
-class FieldTreeItem : public TreeItem
-{
-Q_OBJECT
-public:
-    FieldTreeItem(int index, const QList<QVariant> &data, TreeItem *parent = 0) :
-            TreeItem(data, parent), m_index(index) { }
-    FieldTreeItem(int index, const QVariant &data, TreeItem *parent = 0) :
-            TreeItem(data, parent), m_index(index) { }
-    bool isEditable() { return true; }
-    virtual bool isIntType() { return false; }
-    virtual bool isEnum() { return false; }
-    virtual bool isFloatType() { return false; }
-    virtual void apply() { }
-protected:
-    int m_index;
-};
-
-class EnumFieldTreeItem : public FieldTreeItem
-{
-Q_OBJECT
-public:
-    EnumFieldTreeItem(UAVObjectFieldEnum *field, int index, const QList<QVariant> &data,
-                      TreeItem *parent = 0) :
-    FieldTreeItem(index, data, parent), enumOptions(field->getOptions()), m_field(field) { }
-    EnumFieldTreeItem(UAVObjectFieldEnum *field, int index, const QVariant &data,
-                      TreeItem *parent = 0) :
-    FieldTreeItem(index, data, parent), enumOptions(field->getOptions()), m_field(field) { }
-    void setData(QVariant value, int column) {
-        setChanged(m_field->getSelectedIndex(m_index) != value);
-        TreeItem::setData(value, column);
-    }
-    void apply() {
-        int value = data(dataColumn).toInt();
-        m_field->setSelectedIndex(value, m_index);
-        setChanged(false);
-    }
-    void update() {
-        int value = m_field->getSelectedIndex(m_index);
-        if (data() != value || changed()) {
-            setHighlight(true);
-            TreeItem::setData(value);
-        }
-    }
-
-    bool isEnum() { return true; }
-    QStringList enumOptions;
-private:
-    UAVObjectFieldEnum *m_field;
-};
-
-class IntFieldTreeItem : public FieldTreeItem
-{
-Q_OBJECT
-public:
-    IntFieldTreeItem(int index, const QList<QVariant> &data, int min, int max, TreeItem *parent = 0) :
-            FieldTreeItem(index, data, parent), MIN(min), MAX(max) { }
-    IntFieldTreeItem(int index, const QVariant &data, int min, int max, TreeItem *parent = 0) :
-            FieldTreeItem(index, data, parent), MIN(min), MAX(max) { }
-    bool isIntType() { return true; }
-    int MIN;
-    int MAX;
-};
-
-class Int8FieldTreeItem : public IntFieldTreeItem
-{
-Q_OBJECT
-public:
-    Int8FieldTreeItem(UAVObjectFieldInt8 *field, int index, const QList<QVariant> &data, TreeItem *parent = 0) :
-            IntFieldTreeItem(index, data, QINT8MIN, QINT8MAX, parent), m_field(field) { }
-    Int8FieldTreeItem(UAVObjectFieldInt8 *field, int index, const QVariant &data, TreeItem *parent = 0) :
-            IntFieldTreeItem(index, data, QINT8MIN, QINT8MAX, parent), m_field(field) { }
-    void setData(QVariant value, int column) {
-        setChanged(m_field->getValue(m_index) != value);
-        TreeItem::setData(value, column);
-    }
-    void apply() {
-        m_field->setValue(data(dataColumn).toInt());
-        setChanged(false);
-    }
-    void update() {
-        int value = m_field->getValue(m_index);
-        if (data() != value || changed()) {
-            setHighlight(true);
-            TreeItem::setData(value);
-        }
-    }
-private:
-    UAVObjectFieldInt8 *m_field;
-};
-
-class Int16FieldTreeItem : public IntFieldTreeItem
-{
-Q_OBJECT
-public:
-    Int16FieldTreeItem(UAVObjectFieldInt16 *field, int index, const QList<QVariant> &data, TreeItem *parent = 0) :
-            IntFieldTreeItem(index, data, QINT16MIN, QINT16MAX, parent), m_field(field) { }
-    Int16FieldTreeItem(UAVObjectFieldInt16 *field, int index, const QVariant &data, TreeItem *parent = 0) :
-            IntFieldTreeItem(index, data, QINT16MIN, QINT16MAX, parent), m_field(field) { }
-    void setData(QVariant value, int column) {
-        setChanged(m_field->getValue(m_index) != value);
-        TreeItem::setData(value, column);
-    }
-    void apply() {
-        m_field->setValue(data(dataColumn).toInt());
-        setChanged(false);
-    }
-    void update() {
-        int value = m_field->getValue(m_index);
-        if (data() != value || changed()) {
-            setHighlight(true);
-            TreeItem::setData(value);
-        }
-    }
-private:
-    UAVObjectFieldInt16 *m_field;
-};
-
-class Int32FieldTreeItem : public IntFieldTreeItem
-{
-Q_OBJECT
-public:
-    Int32FieldTreeItem(UAVObjectFieldInt32 *field, int index, const QList<QVariant> &data, TreeItem *parent = 0) :
-            IntFieldTreeItem(index, data, QINT32MIN, QINT32MAX, parent), m_field(field) { }
-    Int32FieldTreeItem(UAVObjectFieldInt32 *field, int index, const QVariant &data, TreeItem *parent = 0) :
-            IntFieldTreeItem(index, data, QINT32MIN, QINT32MAX, parent), m_field(field) { }
-    void setData(QVariant value, int column) {
-        setChanged(m_field->getValue(m_index) != value);
-        TreeItem::setData(value, column);
-    }
-    void apply() {
-        m_field->setValue(data(dataColumn).toInt());
-        setChanged(false);
-    }
-    void update() {
-        int value = m_field->getValue(m_index);
-        if (data() != value || changed()) {
-            setHighlight(true);
-            TreeItem::setData(value);
-        }
-    }
-private:
-    UAVObjectFieldInt32 *m_field;
-};
-
-class UInt8FieldTreeItem : public IntFieldTreeItem
-{
-Q_OBJECT
-public:
-    UInt8FieldTreeItem(UAVObjectFieldUInt8 *field, int index, const QList<QVariant> &data, TreeItem *parent = 0) :
-            IntFieldTreeItem(index, data, QUINTMIN, QUINT8MAX, parent), m_field(field) { }
-    UInt8FieldTreeItem(UAVObjectFieldUInt8 *field, int index, const QVariant &data, TreeItem *parent = 0) :
-            IntFieldTreeItem(index, data, QUINTMIN, QUINT8MAX, parent), m_field(field) { }
-    void setData(QVariant value, int column) {
-        setChanged(m_field->getValue(m_index) != value);
-        TreeItem::setData(value, column);
-    }
-    void apply() {
-        m_field->setValue(data(dataColumn).toInt());
-        setChanged(false);
-    }
-    void update() {
-        int value = m_field->getValue(m_index);
-        if (data() != value || changed()) {
-            setHighlight(true);
-            TreeItem::setData(value);
-        }
-    }
-private:
-    UAVObjectFieldUInt8 *m_field;
-};
-
-class UInt16FieldTreeItem : public IntFieldTreeItem
-{
-Q_OBJECT
-public:
-    UInt16FieldTreeItem(UAVObjectFieldUInt16 *field, int index, const QList<QVariant> &data, TreeItem *parent = 0) :
-            IntFieldTreeItem(index, data, QUINTMIN, QUINT16MAX, parent), m_field(field) { }
-    UInt16FieldTreeItem(UAVObjectFieldUInt16 *field, int index, const QVariant &data, TreeItem *parent = 0) :
-            IntFieldTreeItem(index, data, QUINTMIN, QUINT16MAX, parent), m_field(field) { }
-    void setData(QVariant value, int column) {
-        setChanged(m_field->getValue(m_index) != value);
-        TreeItem::setData(value, column);
-    }
-    void apply() {
-        m_field->setValue(data(dataColumn).toInt());
-        setChanged(false);
-    }
-    void update() {
-        int value = m_field->getValue(m_index);
-        if (data() != value || changed()) {
-            setHighlight(true);
-            TreeItem::setData(value);
-        }
-    }
-private:
-    UAVObjectFieldUInt16 *m_field;
-};
-
-class UInt32FieldTreeItem : public IntFieldTreeItem
-{
-Q_OBJECT
-public:
-    UInt32FieldTreeItem(UAVObjectFieldUInt32 *field, int index, const QList<QVariant> &data, TreeItem *parent = 0) :
-            IntFieldTreeItem(index, data, QUINTMIN, QUINT32MAX, parent), m_field(field) { }
-    UInt32FieldTreeItem(UAVObjectFieldUInt32 *field, int index, const QVariant &data, TreeItem *parent = 0) :
-            IntFieldTreeItem(index, data, QUINTMIN, QUINT32MAX, parent), m_field(field) { }
-    void setData(QVariant value, int column) {
-        setChanged(m_field->getValue(m_index) != value);
-        TreeItem::setData(value, column);
-    }
-    void apply() {
-        m_field->setValue(data(dataColumn).toInt());
-        setChanged(false);
-    }
-    void update() {
-        int value = m_field->getValue(m_index);
-        if (data() != value || changed()) {
-            setHighlight(true);
-            TreeItem::setData(value);
-        }
-    }
-private:
-    UAVObjectFieldUInt32 *m_field;
-};
-
-
-class FloatFieldTreeItem : public FieldTreeItem
-{
-Q_OBJECT
-public:
-    FloatFieldTreeItem(UAVObjectFieldFloat *field, int index, const QList<QVariant> &data, TreeItem *parent = 0) :
-            FieldTreeItem(index, data, parent), m_field(field) { }
-    FloatFieldTreeItem(UAVObjectFieldFloat *field, int index, const QVariant &data, TreeItem *parent = 0) :
-            FieldTreeItem(index, data, parent), m_field(field) { }
-    bool isFloatType() { return true; }
-    void setData(QVariant value, int column) {
-        setChanged(m_field->getValue(m_index) != value);
-        TreeItem::setData(value, column);
-    }
-    void apply() {
-        m_field->setValue(data(dataColumn).toDouble(), m_index);
-        setChanged(false);
-    }
-    void update() {
-        double value = m_field->getValue(m_index);
-        if (data() != value || changed()) {
-            setHighlight(true);
-            TreeItem::setData(value);
-        }
-    }
-private:
-    UAVObjectFieldFloat *m_field;
-};
-
-
 #endif // TREEITEM_H

ground/src/plugins/uavobjectbrowser/uavobjectbrowser.pro

@@ -10,7 +10,8 @@ HEADERS += browserplugin.h \
     uavobjectbrowseroptionspage.h \
     uavobjecttreemodel.h \
     treeitem.h \
-    browseritemdelegate.h
+    browseritemdelegate.h \
+    fieldtreeitem.h
 SOURCES += browserplugin.cpp \
     uavobjectbrowserconfiguration.cpp \
     uavobjectbrowser.cpp \
@@ -19,6 +20,7 @@ SOURCES += browserplugin.cpp \
     uavobjectbrowseroptionspage.cpp \
     uavobjecttreemodel.cpp \
     treeitem.cpp \
-    browseritemdelegate.cpp
+    browseritemdelegate.cpp \
+    fieldtreeitem.cpp
 OTHER_FILES += UAVObjectBrowser.pluginspec
 FORMS += uavobjectbrowser.ui

ground/src/plugins/uavobjectbrowser/uavobjecttreemodel.cpp

@@ -27,6 +27,7 @@
 
 #include "uavobjecttreemodel.h"
 #include "treeitem.h"
+#include "fieldtreeitem.h"
 #include "uavobjects/uavobjectmanager.h"
 #include "uavobjects/uavdataobject.h"
 #include "uavobjects/uavmetaobject.h"
@@ -205,9 +206,7 @@ void UAVObjectTreeModel::addSingleField(int index, UAVObjectField *field, TreeIt
         data.append(field->getUnits());
         item = new FloatFieldTreeItem(floatField, index, data);
     } else {
-        data.append("Data Error");
-        data.append(field->getUnits());
-        item = new FieldTreeItem(index, data);
+        Q_ASSERT(false);
     }
     connect(item, SIGNAL(removeHighlight(TreeItem*)), this, SLOT(removeHighlight(TreeItem*)));
     parent->appendChild(item);
@@ -320,7 +319,7 @@ QVariant UAVObjectTreeModel::data(const QModelIndex &index, int role) const
         EnumFieldTreeItem *fieldItem = dynamic_cast<EnumFieldTreeItem*>(item);
         if (fieldItem) {
             int enumIndex = fieldItem->data(index.column()).toInt();
-            return fieldItem->enumOptions.at(enumIndex);
+            return fieldItem->enumOptions(enumIndex);
         }
     }