1
0
mirror of https://bitbucket.org/librepilot/librepilot.git synced 2025-02-20 10:54:14 +01:00

OP-9 GCS/uavobjectbrowser: Refactoring.

git-svn-id: svn://svn.openpilot.org/OpenPilot/trunk@505 ebee16cc-31ac-478f-84a7-5cbb03baadba
This commit is contained in:
ephy 2010-04-15 19:59:45 +00:00 committed by ephy
parent c9446f1fd5
commit 27f56a014b
6 changed files with 398 additions and 340 deletions

View File

@ -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,

View File

@ -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"

View File

@ -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

View File

@ -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

View File

@ -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

View File

@ -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);
}
}