diff --git a/ground/src/plugins/uavobjectbrowser/browseritemdelegate.cpp b/ground/src/plugins/uavobjectbrowser/browseritemdelegate.cpp index a299fc93b..1652dff62 100644 --- a/ground/src/plugins/uavobjectbrowser/browseritemdelegate.cpp +++ b/ground/src/plugins/uavobjectbrowser/browseritemdelegate.cpp @@ -26,11 +26,7 @@ */ #include "browseritemdelegate.h" -#include "treeitem.h" -#include -#include -#include -#include +#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(index.internalPointer()); - if (item->isIntType()) { - IntFieldTreeItem *intItem = static_cast(item); - QSpinBox *editor = new QSpinBox(parent); - editor->setMinimum(intItem->MIN); - editor->setMaximum(intItem->MAX); - return editor; - } else if (item->isEnum()) { - EnumFieldTreeItem *enumItem = static_cast(item); - QComboBox *editor = new QComboBox(parent); - foreach (QString option, enumItem->enumOptions) - editor->addItem(option); - return editor; - } else if (item->isFloatType()) { - FloatFieldTreeItem *floatItem = static_cast(item); - QDoubleSpinBox *editor = new QDoubleSpinBox(parent); - editor->setDecimals(6); - editor->setMinimum(-std::numeric_limits::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(index.internalPointer()); - if (item->isIntType()) { - int value = index.model()->data(index, Qt::EditRole).toInt(); - QSpinBox *spinBox = static_cast(editor); - spinBox->setValue(value); - } else if (item->isEnum()) { - int value = index.model()->data(index, Qt::EditRole).toInt(); - QComboBox *comboBox = static_cast(editor); - comboBox->setCurrentIndex(value); - } else if (item->isFloatType()) { - float value = index.model()->data(index, Qt::EditRole).toDouble(); - QDoubleSpinBox *spinBox = static_cast(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(index.internalPointer()); - if (item->isIntType()) { - QSpinBox *spinBox = static_cast(editor); - spinBox->interpretText(); - int value = spinBox->value(); - model->setData(index, value, Qt::EditRole); - } else if (item->isEnum()) { - QComboBox *comboBox = static_cast(editor); - int value = comboBox->currentIndex(); - model->setData(index, value, Qt::EditRole); - } else if (item->isFloatType()) { - QDoubleSpinBox *spinBox = static_cast(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, diff --git a/ground/src/plugins/uavobjectbrowser/fieldtreeitem.cpp b/ground/src/plugins/uavobjectbrowser/fieldtreeitem.cpp new file mode 100644 index 000000000..94562ed5d --- /dev/null +++ b/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" + diff --git a/ground/src/plugins/uavobjectbrowser/fieldtreeitem.h b/ground/src/plugins/uavobjectbrowser/fieldtreeitem.h new file mode 100644 index 000000000..f97f96e08 --- /dev/null +++ b/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 +#include +#include +#include +#include +#include + +#define QINT8MIN std::numeric_limits::min() +#define QINT8MAX std::numeric_limits::max() +#define QUINTMIN std::numeric_limits::min() +#define QUINT8MAX std::numeric_limits::max() +#define QINT16MIN std::numeric_limits::min() +#define QINT16MAX std::numeric_limits::max() +#define QUINT16MAX std::numeric_limits::max() +#define QINT32MIN std::numeric_limits::min() +#define QINT32MAX std::numeric_limits::max() +#define QUINT32MAX std::numeric_limits::max() + +class FieldTreeItem : public TreeItem +{ +Q_OBJECT +public: + FieldTreeItem(int index, const QList &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 &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(editor); + return comboBox->currentIndex(); + } + + void setEditorValue(QWidget *editor, QVariant value) { + QComboBox *comboBox = static_cast(editor); + comboBox->setCurrentIndex(value.toInt()); + } +private: + QStringList m_enumOptions; + UAVObjectFieldEnum *m_field; +}; + +class IntFieldTreeItem : public FieldTreeItem +{ +Q_OBJECT +public: + IntFieldTreeItem(int index, const QList &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(editor); + spinBox->interpretText(); + return spinBox->value(); + } + + void setEditorValue(QWidget *editor, QVariant value) { + QSpinBox *spinBox = static_cast(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 &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 &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 &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 &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 &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 &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 &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::max()); + editor->setMaximum(std::numeric_limits::max()); + return editor; + } + + QVariant getEditorValue(QWidget *editor) { + QDoubleSpinBox *spinBox = static_cast(editor); + spinBox->interpretText(); + return spinBox->value(); + } + + void setEditorValue(QWidget *editor, QVariant value) { + QDoubleSpinBox *spinBox = static_cast(editor); + spinBox->setValue(value.toDouble()); + } +private: + UAVObjectFieldFloat *m_field; +}; + +#endif // FIELDTREEITEM_H diff --git a/ground/src/plugins/uavobjectbrowser/treeitem.h b/ground/src/plugins/uavobjectbrowser/treeitem.h index 069def514..c43a29a1a 100644 --- a/ground/src/plugins/uavobjectbrowser/treeitem.h +++ b/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 #include -#include #include #include -#include -#define QINT8MIN std::numeric_limits::min() -#define QINT8MAX std::numeric_limits::max() -#define QUINTMIN std::numeric_limits::min() -#define QUINT8MAX std::numeric_limits::max() -#define QINT16MIN std::numeric_limits::min() -#define QINT16MAX std::numeric_limits::max() -#define QUINT16MAX std::numeric_limits::max() -#define QINT32MIN std::numeric_limits::min() -#define QINT32MAX std::numeric_limits::max() -#define QUINT32MAX std::numeric_limits::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 &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 &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 &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 &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 &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 &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 &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 &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 &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 &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 diff --git a/ground/src/plugins/uavobjectbrowser/uavobjectbrowser.pro b/ground/src/plugins/uavobjectbrowser/uavobjectbrowser.pro index b625c8200..066b7294d 100644 --- a/ground/src/plugins/uavobjectbrowser/uavobjectbrowser.pro +++ b/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 diff --git a/ground/src/plugins/uavobjectbrowser/uavobjecttreemodel.cpp b/ground/src/plugins/uavobjectbrowser/uavobjecttreemodel.cpp index a3d7ad0a8..e175a0f0a 100644 --- a/ground/src/plugins/uavobjectbrowser/uavobjecttreemodel.cpp +++ b/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(item); if (fieldItem) { int enumIndex = fieldItem->data(index.column()).toInt(); - return fieldItem->enumOptions.at(enumIndex); + return fieldItem->enumOptions(enumIndex); } }