piotr/edgetx-gx12
1
0
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity

Major refactoring

Browse Source
This commit is contained in:
elecpower
2020-12-31 17:15:35 +11:00
parent 613ed78527
commit 0d281cf5dd
37 changed files with 1512 additions and 799 deletions
Download Patch File Download Diff File Expand all files Collapse all files
companion/src/datamodels/itemmodelfactory.cpp
+223
View File
@@ -0,0 +1,223 @@
/*
* Copyright (C) OpenTX
*
* Based on code named
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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.
*/
#include "itemmodelfactory.h"
#include "rawitemdatamodels.h"
#include "rawitemfilteredmodel.h"
#include "eeprominterface.h"
#include "generalsettings.h"
#include "modeldata.h"
ItemModelFactory::ItemModelFactory(const GeneralSettings * const generalSettings, const ModelData * const modelData) :
generalSettings(generalSettings),
modelData(modelData)
{
firmware = getCurrentFirmware();
board = new Boards(getCurrentBoard());
boardType = getCurrentBoard();
}
ItemModelFactory::~ItemModelFactory()
{
unregisterItemModels();
delete board;
}
void ItemModelFactory::addItemModel(const AbstractItemModel::ItemModelId id)
{
switch (id) {
case AbstractItemModel::RawSourceId:
registerItemModel(new RawSourceItemModel(generalSettings, modelData, firmware, board, boardType));
break;
case AbstractItemModel::RawSwitchId:
registerItemModel(new RawSwitchItemModel(generalSettings, modelData, firmware, board, boardType));
break;
case AbstractItemModel::CurveId:
registerItemModel(new CurveItemModel(generalSettings, modelData, firmware, board, boardType));
break;
case AbstractItemModel::GVarRefId:
registerItemModel(new GVarReferenceItemModel(generalSettings, modelData, firmware, board, boardType));
break;
case AbstractItemModel::ThrSourceId:
registerItemModel(new ThrottleSourceItemModel(generalSettings, modelData, firmware, board, boardType));
break;
case AbstractItemModel::CustomFuncActionId:
registerItemModel(new CustomFuncActionItemModel(generalSettings, modelData, firmware, board, boardType));
break;
case AbstractItemModel::CustomFuncResetParamId:
registerItemModel(new CustomFuncResetParamItemModel(generalSettings, modelData, firmware, board, boardType));
break;
case AbstractItemModel::TeleSourceId:
registerItemModel(new TelemetrySourceItemModel(generalSettings, modelData, firmware, board, boardType));
break;
case AbstractItemModel::CurveRefTypeId:
registerItemModel(new CurveRefTypeItemModel(generalSettings, modelData, firmware, board, boardType));
break;
case AbstractItemModel::CurveRefFuncId:
registerItemModel(new CurveRefFuncItemModel(generalSettings, modelData, firmware, board, boardType));
break;
default:
qDebug() << "Error: unknown item model: id";
break;
}
}
void ItemModelFactory::registerItemModel(QAbstractItemModel * itemModel)
{
if (itemModel && !getItemModel(itemModel->getId())) {
registeredItemModels.push_back(itemModel);
}
}
void ItemModelFactory::unregisterItemModels()
{
foreach (QAbstractItemModel *itemModel, registeredItemModels) {
delete itemModel;
}
}
void ItemModelFactory::unregisterItemModel(const AbstractItemModel::ItemModelId id)
{
QAbstractItemModel * itemModel = getItemModel(id);
if (itemModel)
delete itemModel;
}
QAbstractItemModel * ItemModelsFactory::getItemModel(const AbstractItemModel::ItemModelId id) const
{
foreach (AbstractItemModel * itemModel, registeredItemModels) {
if (itemModel->getId() == id)
return itemModel;
}
return nullptr;
}
void ItemModelFactory::update(const AbstractItemModel::UpdateTrigger trigger)
{
foreach (AbstractItemModel * itemModel, registeredItemModels) {
itemModel->update(trigger);
}
}
void ItemModelFactory::dumpAllItemModelContents() const
{
foreach (AbstractItemModel * itemModel, registeredItemModels) {
AbstractItemModel::dumpItemModelContents(itemModel);
}
}
//
// FilteredItemModelsFactory
//
FilteredItemModelFactory::FilteredItemModelFactory()
{
}
FilteredItemModelFactory::~FilteredItemModelFactory()
{
unregisterItemModels();
}
int FilteredItemModelFactory::registerItemModel(FilteredItemModel * itemModel, QString name)
{
if (itemModel) {
if (isItemModelRegistered(name))
qDebug() << "Warning: item model already registered with name:" << name;
const int id = registeredItemModels.count();
itemModel->setId(id);
itemModel->setName(name);
registeredItemModels.push_back(itemModel);
return id;
}
return 0;
}
void FilteredItemModelFactory::unregisterItemModels()
{
foreach (FilteredItemModel * itemModel, registeredItemModels) {
delete itemModel;
}
}
void FilteredItemModelFactory::unregisterItemModel(const int id)
{
FilteredItemModel * itemModel = getItemModel(id);
if (itemModel)
delete itemModel;
}
bool FilteredItemModelFactory::isItemModelRegistered(const int id) const
{
return getItemModel(id);
}
bool FilteredItemModelFactory::isItemModelRegistered(const QString name) const
{
return getItemModel(name);
}
FilteredItemModel * FilteredItemModelFactory::getItemModel(const int id) const
{
foreach (FilteredItemModel * itemModel, registeredItemModels) {
if (itemModel->getId() == id)
return itemModel;
}
return nullptr;
}
FilteredItemModel * FilteredItemModelFactory::getItemModel(const QString name) const
{
foreach (FilteredItemModel * itemModel, registeredItemModels) {
if (itemModel->getName() == name)
return itemModel;
}
return nullptr;
}
void FilteredItemModelFactory::update()
{
foreach (FilteredItemModel * itemModel, registeredItemModels) {
itemModel->update();
}
}
void FilteredItemModelFactory::dumpItemModelContents(const int id) const
{
FilteredItemModel::dumpItemModelContents(getItemModel(id));
}
void FilteredItemModelFactory::dumpItemModelContents(const QString name) const
{
FilteredItemModel::dumpItemModelContents(getItemModel(name));
}
void FilteredItemModelFactory::dumpAllItemModelContents() const
{
foreach (FilteredItemModel * itemModel, registeredItemModels) {
FilteredItemModel::dumpItemModelContents(itemModel);
}
}
companion/src/datamodels/itemmodelfactory.h
+75
View File
@@ -0,0 +1,75 @@
/*
* Copyright (C) OpenTX
*
* Based on code named
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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.
*/
#ifndef ITEMMODELFACTORY_H
#define ITEMMODELFACTORY_H
class GeneralSettings;
class ModelData;
class AbstractItemModel;
class FilteredItemModel;
class ItemModelFactory
{
public:
ItemModelFactory(const GeneralSettings * const generalSettings, const ModelData * const modelData);
virtual ~ItemModelFactory();
void addItemModel(const AbstractItemModel::ItemModelId id);
void registerItemModel(AbstractItemModel * itemModel);
void unregisterItemModels();
void unregisterItemModel(const AbstractItemModel::ItemModelId id);
AbstractItemModel * getItemModel(const AbstractItemModel::ItemModelId id) const;
void update(const AbstractItemModel::UpdateTrigger trigger = AbstractItemModel::SystemRefresh);
void dumpAllItemModelContents() const;
protected:
const GeneralSettings * generalSettings;
const ModelData * modelData;
Firmware * firmware;
Boards * board;
Board::Type boardType;
QVector<AbstractItemModel *> registeredItemModels;
};
class FilteredItemModelsFactory
{
public:
FilteredItemModelsFactory();
virtual ~FilteredItemModelsFactory();
int registerItemModel(FilteredItemModel * itemModel, QString name);
void unregisterItemModels();
void unregisterItemModel(const int id);
bool isItemModelRegistered(const int id) const;
bool isItemModelRegistered(const QString name) const;
FilteredItemModel * getItemModel(const int id) const;
FilteredItemModel * getItemModel(const QString name) const;
void update();
void dumpItemModelContents(const int id) const;
void dumpItemModelContents(const QString name) const;
void dumpAllItemModelContents() const;
protected:
QVector<FilteredItemModel *> registeredItemModels;
};
#endif // ITEMMODELFACTORY_H
companion/src/datamodels/rawitemdatamodels.cpp
+297 -212
View File
@@ -24,35 +24,57 @@
#include "modeldata.h"
#include "adjustmentreference.h"
RawSourceItemModel::RawSourceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent) :
AbstractRawItemDataModel(generalSettings, modelData, parent)
// static
void AbstractItemModel::dumpItemModelContents(AbstractItemModel * itemModel)
{
const Boards board = Boards(getCurrentBoard());
Firmware * fw = getCurrentFirmware();
if (itemModel) {
qDebug() << "modelid:" << itemModel->getId();
for (int i = 0; i < itemModel->rowCount(); ++i) {
qDebug() << "row:" << i
<< "text:" << itemModel->data(itemModel->index(i, 0), Qt::DisplayRole).toString()
<< "id:" << itemModel->data(itemModel->index(i, 0), AbstractItemModel::ItemIdRole).toInt()
<< "avail:" << itemModel->data(itemModel->index(i, 0), AbstractItemModel::IsAvailableRole).toBool()
<< "flags:" << itemModel->data(itemModel->index(i, 0), AbstractItemModel::ItemFlagsRole).toInt()
<< "type:" << itemModel->data(itemModel->index(i, 0), AbstractItemModel::ItemTypeRole).toInt();
}
}
else
qDebug() << "Error: model did not cast";
}
//
// RawSourceItemModel
//
RawSourceItemModel::RawSourceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
Firmware * firmware, const Boards * const board, const Board::Type boardType) :
AbstractDynamicItemModel(generalSettings, modelData, firmware, board, boardType)
{
setId(RawSourceId);
setUpdateMask(AllTriggers &~ (CurvesUpdated | ScriptsUpdated));
addItems(SOURCE_TYPE_NONE, RawSource::NoneGroup, 1);
for (int i = 0; i < fw->getCapability(LuaScripts); i++)
addItems(SOURCE_TYPE_LUA_OUTPUT, RawSource::ScriptsGroup, fw->getCapability(LuaOutputsPerScript), i * 16);
addItems(SOURCE_TYPE_VIRTUAL_INPUT, RawSource::InputsGroup, fw->getCapability(VirtualInputs));
addItems(SOURCE_TYPE_STICK, RawSource::SourcesGroup, board.getCapability(Board::MaxAnalogs));
addItems(SOURCE_TYPE_ROTARY_ENCODER, RawSource::SourcesGroup, fw->getCapability(RotaryEncoders));
addItems(SOURCE_TYPE_TRIM, RawSource::TrimsGroup, board.getCapability(Board::NumTrims));
for (int i = 0; i < firmware->getCapability(LuaScripts); i++)
addItems(SOURCE_TYPE_LUA_OUTPUT, RawSource::ScriptsGroup, firmware->getCapability(LuaOutputsPerScript), i * 16);
addItems(SOURCE_TYPE_VIRTUAL_INPUT, RawSource::InputsGroup, firmware->getCapability(VirtualInputs));
addItems(SOURCE_TYPE_STICK, RawSource::SourcesGroup, board->getCapability(Board::MaxAnalogs));
addItems(SOURCE_TYPE_ROTARY_ENCODER, RawSource::SourcesGroup, firmware->getCapability(RotaryEncoders));
addItems(SOURCE_TYPE_TRIM, RawSource::TrimsGroup, board->getCapability(Board::NumTrims));
addItems(SOURCE_TYPE_MAX, RawSource::SourcesGroup, 1);
addItems(SOURCE_TYPE_SWITCH, RawSource::SwitchesGroup, board.getCapability(Board::Switches));
addItems(SOURCE_TYPE_CUSTOM_SWITCH, RawSource::SwitchesGroup, fw->getCapability(LogicalSwitches));
addItems(SOURCE_TYPE_SWITCH, RawSource::SwitchesGroup, board->getCapability(Board::Switches));
addItems(SOURCE_TYPE_CUSTOM_SWITCH, RawSource::SwitchesGroup, firmware->getCapability(LogicalSwitches));
addItems(SOURCE_TYPE_CYC, RawSource::SourcesGroup, CPN_MAX_CYC);
addItems(SOURCE_TYPE_PPM, RawSource::SourcesGroup, fw->getCapability(TrainerInputs));
addItems(SOURCE_TYPE_CH, RawSource::SourcesGroup, fw->getCapability(Outputs));
addItems(SOURCE_TYPE_PPM, RawSource::SourcesGroup, firmware->getCapability(TrainerInputs));
addItems(SOURCE_TYPE_CH, RawSource::SourcesGroup, firmware->getCapability(Outputs));
addItems(SOURCE_TYPE_SPECIAL, RawSource::TelemGroup, 5);
addItems(SOURCE_TYPE_TELEMETRY, RawSource::TelemGroup, fw->getCapability(Sensors) * 3);
addItems(SOURCE_TYPE_GVAR, RawSource::GVarsGroup, fw->getCapability(Gvars));
addItems(SOURCE_TYPE_TELEMETRY, RawSource::TelemGroup, firmware->getCapability(Sensors) * 3);
addItems(SOURCE_TYPE_GVAR, RawSource::GVarsGroup, firmware->getCapability(Gvars));
}
void RawSourceItemModel::setDynamicItemData(QStandardItem * item, const RawSource & src) const
{
Board::Type board = getCurrentBoard();
item->setText(src.toString(modelData, generalSettings, board));
item->setData(src.isAvailable(modelData, generalSettings, board), IsAvailableRole);
item->setText(src.toString(modelData, generalSettings, boardType));
item->setData(src.isAvailable(modelData, generalSettings, boardType), IsAvailableRole);
}
void RawSourceItemModel::addItems(const RawSourceType & type, const int group, const int count, const int start)
@@ -68,49 +90,51 @@ void RawSourceItemModel::addItems(const RawSourceType & type, const int group, c
}
}
void RawSourceItemModel::update()
void RawSourceItemModel::update(const UpdateTrigger trigger)
{
emit dataAboutToBeUpdated();
if (doUpdate(trigger)) {
emit aboutToBeUpdated();
for (int i = 0; i < rowCount(); ++i)
setDynamicItemData(item(i), RawSource(item(i)->data(ItemIdRole).toInt()));
for (int i = 0; i < rowCount(); ++i)
setDynamicItemData(item(i), RawSource(item(i)->data(ItemIdRole).toInt()));
emit dataUpdateComplete();
emit updateComplete();
}
}
//
// RawSwitchItemModel
//
RawSwitchItemModel::RawSwitchItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent) :
AbstractRawItemDataModel(generalSettings, modelData, parent)
RawSwitchItemModel::RawSwitchItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
Firmware * firmware, const Boards * const board, const Board::Type boardType) :
AbstractDynamicItemModel(generalSettings, modelData, firmware, board, boardType)
{
Boards board = Boards(getCurrentBoard());
Firmware * fw = getCurrentFirmware();
setId(RawSwitchId);
setUpdateMask(FlightModesUpdated | LogicalSwitchesUpdated | TeleSensorsUpdated);
// Descending switch direction: NOT (!) switches
addItems(SWITCH_TYPE_ACT, -1);
addItems(SWITCH_TYPE_SENSOR, -fw->getCapability(Sensors));
addItems(SWITCH_TYPE_SENSOR, -firmware->getCapability(Sensors));
addItems(SWITCH_TYPE_TELEMETRY, -1);
addItems(SWITCH_TYPE_FLIGHT_MODE, -fw->getCapability(FlightModes));
addItems(SWITCH_TYPE_VIRTUAL, -fw->getCapability(LogicalSwitches));
addItems(SWITCH_TYPE_ROTARY_ENCODER, -fw->getCapability(RotaryEncoders));
addItems(SWITCH_TYPE_TRIM, -board.getCapability(Board::NumTrimSwitches));
addItems(SWITCH_TYPE_MULTIPOS_POT, -(board.getCapability(Board::MultiposPots) * board.getCapability(Board::MultiposPotsPositions)));
addItems(SWITCH_TYPE_SWITCH, -board.getCapability(Board::SwitchPositions));
addItems(SWITCH_TYPE_FLIGHT_MODE, -firmware->getCapability(FlightModes));
addItems(SWITCH_TYPE_VIRTUAL, -firmware->getCapability(LogicalSwitches));
addItems(SWITCH_TYPE_ROTARY_ENCODER, -firmware->getCapability(RotaryEncoders));
addItems(SWITCH_TYPE_TRIM, -board->getCapability(Board::NumTrimSwitches));
addItems(SWITCH_TYPE_MULTIPOS_POT, -(board->getCapability(Board::MultiposPots) * board->getCapability(Board::MultiposPotsPositions)));
addItems(SWITCH_TYPE_SWITCH, -board->getCapability(Board::SwitchPositions));
// Ascending switch direction (including zero)
addItems(SWITCH_TYPE_TIMER_MODE, 5);
addItems(SWITCH_TYPE_NONE, 1);
addItems(SWITCH_TYPE_SWITCH, board.getCapability(Board::SwitchPositions));
addItems(SWITCH_TYPE_MULTIPOS_POT, board.getCapability(Board::MultiposPots) * board.getCapability(Board::MultiposPotsPositions));
addItems(SWITCH_TYPE_TRIM, board.getCapability(Board::NumTrimSwitches));
addItems(SWITCH_TYPE_ROTARY_ENCODER, fw->getCapability(RotaryEncoders));
addItems(SWITCH_TYPE_VIRTUAL, fw->getCapability(LogicalSwitches));
addItems(SWITCH_TYPE_FLIGHT_MODE, fw->getCapability(FlightModes));
addItems(SWITCH_TYPE_SWITCH, board->getCapability(Board::SwitchPositions));
addItems(SWITCH_TYPE_MULTIPOS_POT, board->getCapability(Board::MultiposPots) * board->getCapability(Board::MultiposPotsPositions));
addItems(SWITCH_TYPE_TRIM, board->getCapability(Board::NumTrimSwitches));
addItems(SWITCH_TYPE_ROTARY_ENCODER, firmware->getCapability(RotaryEncoders));
addItems(SWITCH_TYPE_VIRTUAL, firmware->getCapability(LogicalSwitches));
addItems(SWITCH_TYPE_FLIGHT_MODE, firmware->getCapability(FlightModes));
addItems(SWITCH_TYPE_TELEMETRY, 1);
addItems(SWITCH_TYPE_SENSOR, fw->getCapability(Sensors));
addItems(SWITCH_TYPE_SENSOR, firmware->getCapability(Sensors));
addItems(SWITCH_TYPE_ON, 1);
addItems(SWITCH_TYPE_ONE, 1);
addItems(SWITCH_TYPE_ACT, 1);
@@ -118,9 +142,8 @@ RawSwitchItemModel::RawSwitchItemModel(const GeneralSettings * const generalSett
void RawSwitchItemModel::setDynamicItemData(QStandardItem * item, const RawSwitch & rsw) const
{
const Board::Type board = getCurrentBoard();
item->setText(rsw.toString(board, generalSettings, modelData));
item->setData(rsw.isAvailable(modelData, generalSettings, board), IsAvailableRole);
item->setText(rsw.toString(boardType, generalSettings, modelData));
item->setData(rsw.isAvailable(modelData, generalSettings, boardType), IsAvailableRole);
}
void RawSwitchItemModel::addItems(const RawSwitchType & type, int count)
@@ -171,27 +194,34 @@ void RawSwitchItemModel::addItems(const RawSwitchType & type, int count)
}
}
void RawSwitchItemModel::update()
void RawSwitchItemModel::update(const UpdateTrigger trigger)
{
emit dataAboutToBeUpdated();
if (doUpdate(trigger)) {
emit aboutToBeUpdated();
for (int i = 0; i < rowCount(); ++i)
setDynamicItemData(item(i), RawSwitch(item(i)->data(ItemIdRole).toInt()));
for (int i = 0; i < rowCount(); ++i)
setDynamicItemData(item(i), RawSwitch(item(i)->data(ItemIdRole).toInt()));
emit dataUpdateComplete();
emit updateComplete();
}
}
//
// CurveItemModel
//
CurveItemModel::CurveItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent) :
AbstractRawItemDataModel(generalSettings, modelData, parent)
CurveItemModel::CurveItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
Firmware * firmware, const Boards * const board, const Board::Type boardType) :
AbstractDynamicItemModel(generalSettings, modelData, firmware, board, boardType)
{
setId(CurveId);
if (!modelData)
return;
const int count = getCurrentFirmware()->getCapability(NumCurves);
setUpdateMask(CurvesUpdated);
const int count = firmware->getCapability(NumCurves);
for (int i = -count ; i <= count; ++i) {
QStandardItem * modelItem = new QStandardItem();
@@ -205,35 +235,42 @@ CurveItemModel::CurveItemModel(const GeneralSettings * const generalSettings, co
}
}
void CurveItemModel::setDynamicItemData(QStandardItem * item, const int index) const
void CurveItemModel::setDynamicItemData(QStandardItem * item, const int value) const
{
CurveReference cr = CurveReference(CurveReference::CURVE_REF_CUSTOM, index);
CurveReference cr = CurveReference(CurveReference::CURVE_REF_CUSTOM, value);
item->setText(cr.toString(modelData, false));
item->setData(cr.isAvailable(), IsAvailableRole);
}
void CurveItemModel::update()
void CurveItemModel::update(const UpdateTrigger trigger)
{
emit dataAboutToBeUpdated();
if (doUpdate(trigger)) {
emit aboutToBeUpdated();
for (int i = 0; i < rowCount(); ++i)
setDynamicItemData(item(i), item(i)->data(ItemIdRole).toInt());
for (int i = 0; i < rowCount(); ++i)
setDynamicItemData(item(i), item(i)->data(ItemIdRole).toInt());
emit dataUpdateComplete();
emit updateComplete();
}
}
//
// GVarReferenceItemModel
//
GVarReferenceItemModel::GVarReferenceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent) :
AbstractRawItemDataModel(generalSettings, modelData, parent)
GVarReferenceItemModel::GVarReferenceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
Firmware * firmware, const Boards * const board, const Board::Type boardType) :
AbstractDynamicItemModel(generalSettings, modelData, firmware, board, boardType)
{
setId(GVarRefId);
if (!modelData)
return;
const int count = getCurrentFirmware()->getCapability(Gvars);
setUpdateMask(GVarsUpdated | FlightModesUpdated | LogicalSwitchesUpdated);
const int count = firmware->getCapability(Gvars);
if (count > 0) {
addItems(-count);
addItems(count);
@@ -260,27 +297,33 @@ void GVarReferenceItemModel::setDynamicItemData(QStandardItem * item, const Adju
item->setData(ar.isAvailable(), IsAvailableRole);
}
void GVarReferenceItemModel::update()
void GVarReferenceItemModel::update(const UpdateTrigger trigger)
{
emit dataAboutToBeUpdated();
if (doUpdate(trigger)) {
emit aboutToBeUpdated();
for (int i = 0; i < rowCount(); ++i)
setDynamicItemData(item(i), AdjustmentReference(item(i)->data(ItemIdRole).toInt()));
for (int i = 0; i < rowCount(); ++i)
setDynamicItemData(item(i), AdjustmentReference(item(i)->data(ItemIdRole).toInt()));
emit dataUpdateComplete();
emit updateComplete();
}
}
//
// ThrottleSourceItemModel
//
ThrottleSourceItemModel::ThrottleSourceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent) :
AbstractRawItemDataModel(generalSettings, modelData, parent)
ThrottleSourceItemModel::ThrottleSourceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
Firmware * firmware, const Boards * const board, const Board::Type boardType) :
AbstractDynamicItemModel(generalSettings, modelData, firmware, board, boardType)
{
setId(ThrSourceId);
if (!modelData)
return;
setUpdateMask(TimersUpdated | InputsUpdated | TeleSensorsUpdated);
for (int i = 0; i < modelData->thrTraceSrcCount(); i++) {
QStandardItem * modelItem = new QStandardItem();
modelItem->setData(i, ItemIdRole);
@@ -289,30 +332,35 @@ ThrottleSourceItemModel::ThrottleSourceItemModel(const GeneralSettings * const g
}
}
void ThrottleSourceItemModel::setDynamicItemData(QStandardItem * item, const int index) const
void ThrottleSourceItemModel::setDynamicItemData(QStandardItem * item, const int value) const
{
item->setText(modelData->thrTraceSrcToString(index));
item->setData(modelData->isThrTraceSrcAvailable(generalSettings, index), IsAvailableRole);
item->setText(modelData->thrTraceSrcToString(value));
item->setData(modelData->isThrTraceSrcAvailable(generalSettings, value), IsAvailableRole);
}
void ThrottleSourceItemModel::update()
void ThrottleSourceItemModel::update(const UpdateTrigger trigger)
{
emit dataAboutToBeUpdated();
if (doUpdate(trigger)) {
emit aboutToBeUpdated();
for (int i = 0; i < rowCount(); ++i)
setDynamicItemData(item(i), item(i)->data(ItemIdRole).toInt());
for (int i = 0; i < rowCount(); ++i)
setDynamicItemData(item(i), item(i)->data(ItemIdRole).toInt());
emit dataUpdateComplete();
emit updateComplete();
}
}
//
// CustomFuncActionItemModel
//
CustomFuncActionItemModel::CustomFuncActionItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent) :
AbstractRawItemDataModel(generalSettings, modelData, parent)
CustomFuncActionItemModel::CustomFuncActionItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
Firmware * firmware, const Boards * const board, const Board::Type boardType) :
AbstractDynamicItemModel(generalSettings, modelData, firmware, board, boardType)
{
setId(CustomFuncActionId);
setUpdateMask(AllTriggers &~ (CurvesUpdated | ScriptsUpdated));
for (int i = 0; i < AssignFunc::FuncCount; i++) {
QStandardItem * modelItem = new QStandardItem();
modelItem->setData(i, ItemIdRole);
@@ -322,30 +370,35 @@ CustomFuncActionItemModel::CustomFuncActionItemModel(const GeneralSettings * con
}
}
void CustomFuncActionItemModel::setDynamicItemData(QStandardItem * item, const int index) const
void CustomFuncActionItemModel::setDynamicItemData(QStandardItem * item, const int value) const
{
item->setText(CustomFunctionData(AssignFunc(index)).funcToString(modelData));
item->setData(CustomFunctionData::isFuncAvailable(index), IsAvailableRole);
item->setText(CustomFunctionData(AssignFunc(value)).funcToString(modelData));
item->setData(CustomFunctionData::isFuncAvailable(value), IsAvailableRole);
}
void CustomFuncActionItemModel::update()
void CustomFuncActionItemModel::update(const UpdateTrigger trigger)
{
emit dataAboutToBeUpdated();
if (doUpdate(trigger)) {
emit aboutToBeUpdated();
for (int i = 0; i < rowCount(); ++i)
setDynamicItemData(item(i), item(i)->data(ItemIdRole).toInt());
for (int i = 0; i < rowCount(); ++i)
setDynamicItemData(item(i), item(i)->data(ItemIdRole).toInt());
emit dataUpdateComplete();
emit updateComplete();
}
}
//
// CustomFuncResetParamItemModel
//
CustomFuncResetParamItemModel::CustomFuncResetParamItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent) :
AbstractRawItemDataModel(generalSettings, modelData, parent)
CustomFuncResetParamItemModel::CustomFuncResetParamItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
Firmware * firmware, const Boards * const board, const Board::Type boardType) :
AbstractDynamicItemModel(generalSettings, modelData, firmware, board, boardType)
{
setId(CustomFuncResetParamId);
setUpdateMask(TeleSensorsUpdated);
for (int i = 0; i < CustomFunctionData::resetParamCount(modelData); i++) {
QStandardItem * modelItem = new QStandardItem();
modelItem->setData(i, ItemIdRole);
@@ -354,38 +407,43 @@ CustomFuncResetParamItemModel::CustomFuncResetParamItemModel(const GeneralSettin
}
}
void CustomFuncResetParamItemModel::setDynamicItemData(QStandardItem * item, const int index) const
void CustomFuncResetParamItemModel::setDynamicItemData(QStandardItem * item, const int value) const
{
CustomFunctionData cfd = CustomFunctionData(AssignFunc::FuncReset);
cfd.param = index;
cfd.param = value;
item->setText(cfd.paramToString(modelData));
item->setData(CustomFunctionData::isResetParamAvailable(modelData, index), IsAvailableRole);
item->setData(CustomFunctionData::isResetParamAvailable(modelData, value), IsAvailableRole);
}
void CustomFuncResetParamItemModel::update()
void CustomFuncResetParamItemModel::update(const UpdateTrigger trigger)
{
emit dataAboutToBeUpdated();
if (doUpdate(trigger)) {
emit aboutToBeUpdated();
for (int i = 0; i < rowCount(); ++i)
setDynamicItemData(item(i), item(i)->data(ItemIdRole).toInt());
for (int i = 0; i < rowCount(); ++i)
setDynamicItemData(item(i), item(i)->data(ItemIdRole).toInt());
emit dataUpdateComplete();
emit updateComplete();
}
}
//
// TelemetrySourceItemModel
//
TelemetrySourceItemModel::TelemetrySourceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent) :
AbstractRawItemDataModel(generalSettings, modelData, parent)
TelemetrySourceItemModel::TelemetrySourceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
Firmware * firmware, const Boards * const board, const Board::Type boardType) :
AbstractDynamicItemModel(generalSettings, modelData, firmware, board, boardType)
{
setId(TeleSourceId);
if (!modelData)
return;
const int count = getCurrentFirmware()->getCapability(Sensors);
setUpdateMask(TeleSensorsUpdated);
const int count = firmware->getCapability(Sensors);
for (int i = -count + 1; i < count; ++i) {
for (int i = -count; i <= count; ++i) {
QStandardItem * modelItem = new QStandardItem();
modelItem->setData(i, ItemIdRole);
int flags = i < 0 ? DataGroups::NegativeGroup : DataGroups::PositiveGroup;
@@ -397,118 +455,35 @@ TelemetrySourceItemModel::TelemetrySourceItemModel(const GeneralSettings * const
}
}
void TelemetrySourceItemModel::setDynamicItemData(QStandardItem * item, const int index) const
void TelemetrySourceItemModel::setDynamicItemData(QStandardItem * item, const int value) const
{
item->setText(SensorData::sourceToString(modelData, index));
item->setData(SensorData::isSourceAvailable(modelData, index), IsAvailableRole);
item->setText(SensorData::sourceToString(modelData, value));
item->setData(SensorData::isSourceAvailable(modelData, value), IsAvailableRole);
}
void TelemetrySourceItemModel::update()
void TelemetrySourceItemModel::update(const UpdateTrigger trigger)
{
emit dataAboutToBeUpdated();
if (doUpdate(trigger)) {
emit aboutToBeUpdated();
for (int i = 0; i < rowCount(); ++i)
setDynamicItemData(item(i), item(i)->data(ItemIdRole).toInt());
emit dataUpdateComplete();
}
//
// CommonItemModels TODO rename to DynamicDataModels
//
CommonItemModels::CommonItemModels(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent) :
QObject(parent)
{
m_rawSourceItemModel = new RawSourceItemModel(generalSettings, modelData, parent);
//dumpModelContents(QString("raw source"), qobject_cast<AbstractRawItemDataModel *>(m_rawSourceItemModel));
m_rawSwitchItemModel = new RawSwitchItemModel(generalSettings, modelData, parent);
//dumpModelContents(QString("raw switch"), qobject_cast<AbstractRawItemDataModel *>(m_rawSwitchItemModel));
m_curveItemModel = new CurveItemModel(generalSettings, modelData, parent);
//dumpModelContents(QString("curve"), qobject_cast<AbstractRawItemDataModel *>(m_curveItemModel));
m_gvarReferenceItemModel = new GVarReferenceItemModel(generalSettings, modelData, parent);
//dumpModelContents(QString("gvar ref"), qobject_cast<AbstractRawItemDataModel *>(m_gvarReferenceItemModel));
m_throttleSourceItemModel = new ThrottleSourceItemModel(generalSettings, modelData, parent);
//dumpModelContents(QString("thr source"), qobject_cast<AbstractRawItemDataModel *>(m_throttleSourceItemModel));
m_customFuncActionItemModel = new CustomFuncActionItemModel(generalSettings, modelData, parent);
//dumpModelContents(QString("cf action"), qobject_cast<AbstractRawItemDataModel *>(m_customFuncActionItemModel));
m_customFuncResetParamItemModel = new CustomFuncResetParamItemModel(generalSettings, modelData, parent);
//dumpModelContents(QString("cf reset param"), qobject_cast<AbstractRawItemDataModel *>(m_customFuncResetParamItemModel));
m_telemetrySourceItemModel = new TelemetrySourceItemModel(generalSettings, modelData, parent);
//dumpModelContents(QString("tele source"), qobject_cast<AbstractRawItemDataModel *>(m_telemetrySourceItemModel));
}
CommonItemModels::~CommonItemModels()
{
}
void CommonItemModels::update(const RadioModelObjects radioModelObjects)
{
switch (radioModelObjects) {
case RMO_CHANNELS:
m_throttleSourceItemModel->update();
// no break
case RMO_TIMERS:
m_customFuncActionItemModel->update();
// no break
case RMO_INPUTS:
case RMO_TELEMETRY_SENSORS:
m_rawSourceItemModel->update();
m_customFuncResetParamItemModel->update();
m_telemetrySourceItemModel->update();
break;
case RMO_GLOBAL_VARIABLES:
m_gvarReferenceItemModel->update();
m_customFuncActionItemModel->update();
// no break
case RMO_FLIGHT_MODES:
case RMO_LOGICAL_SWITCHES:
m_rawSourceItemModel->update();
m_rawSwitchItemModel->update();
break;
case RMO_CURVES:
m_curveItemModel->update();
break;
case RMO_SCRIPTS:
// no need to refresh
break;
default:
qDebug() << "Unknown RadioModelObject:" << radioModelObjects;
}
}
void dumpModelContents(QString desc, AbstractRawItemDataModel * dataModel)
{
if (dataModel) {
qDebug() << "model:" << desc << "rows:" << dataModel->rowCount();
for (int i = 0; i < dataModel->rowCount(); ++i) {
qDebug() << "row:" << i << "text:" << dataModel->item(i)->data(Qt::DisplayRole).toString()
<< "id:" << dataModel->item(i)->data(AbstractRawItemDataModel::ItemIdRole).toInt()
<< "avail:" << dataModel->item(i)->data(AbstractRawItemDataModel::IsAvailableRole).toBool()
<< "flags:" << dataModel->item(i)->data(AbstractRawItemDataModel::ItemFlagsRole).toInt()
<< "type:" << dataModel->item(i)->data(AbstractRawItemDataModel::ItemTypeRole).toInt();
for (int i = 0; i < rowCount(); ++i) {
setDynamicItemData(item(i), item(i)->data(ItemIdRole).toInt());
}
emit updateComplete();
}
else
qDebug() << "model:" << desc << "did not cast";
}
CurveRefTypeItemModel::CurveRefTypeItemModel(QObject * parent) :
AbstractStandardItemModel(parent)
//
// CurveRefTypeItemModel
//
CurveRefTypeItemModel::CurveRefTypeItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
Firmware * firmware, const Boards * const board, const Board::Type boardType) :
AbstractStaticItemModel(generalSettings, modelData, firmware, board, boardType)
{
setId(CurveRefTypeId);
for (int i = 0; i <= CurveReference::MAX_CURVE_REF_TYPE; i++) {
QStandardItem * modelItem = new QStandardItem();
modelItem->setText(CurveReference::typeToString((CurveReference::CurveRefType)i));
@@ -518,9 +493,16 @@ CurveRefTypeItemModel::CurveRefTypeItemModel(QObject * parent) :
}
}
CurveRefFuncItemModel::CurveRefFuncItemModel(QObject * parent) :
AbstractStandardItemModel(parent)
//
// CurveRefFuncItemModel
//
CurveRefFuncItemModel::CurveRefFuncItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
Firmware * firmware, const Boards * const board, const Board::Type boardType) :
AbstractStaticItemModel(generalSettings, modelData, firmware, board, boardType)
{
setId(CurveRefFuncId);
for (int i = 1; i <= CurveReference::functionCount(); i++) {
QStandardItem * modelItem = new QStandardItem();
modelItem->setText(CurveReference::functionToString(i));
@@ -529,3 +511,106 @@ CurveRefFuncItemModel::CurveRefFuncItemModel(QObject * parent) :
appendRow(modelItem);
}
}
//
// ItemModelsFactory
//
ItemModelsFactory::ItemModelsFactory(const GeneralSettings * const generalSettings, const ModelData * const modelData) :
generalSettings(generalSettings),
modelData(modelData)
{
firmware = getCurrentFirmware();
board = new Boards(getCurrentBoard());
boardType = getCurrentBoard();
}
ItemModelsFactory::~ItemModelsFactory()
{
unregisterItemModels();
delete board;
}
void ItemModelsFactory::addItemModel(const AbstractItemModel::ItemModelId id)
{
switch (id) {
case AbstractItemModel::RawSourceId:
registerItemModel(new RawSourceItemModel(generalSettings, modelData, firmware, board, boardType));
break;
case AbstractItemModel::RawSwitchId:
registerItemModel(new RawSwitchItemModel(generalSettings, modelData, firmware, board, boardType));
break;
case AbstractItemModel::CurveId:
registerItemModel(new CurveItemModel(generalSettings, modelData, firmware, board, boardType));
break;
case AbstractItemModel::GVarRefId:
registerItemModel(new GVarReferenceItemModel(generalSettings, modelData, firmware, board, boardType));
break;
case AbstractItemModel::ThrSourceId:
registerItemModel(new ThrottleSourceItemModel(generalSettings, modelData, firmware, board, boardType));
break;
case AbstractItemModel::CustomFuncActionId:
registerItemModel(new CustomFuncActionItemModel(generalSettings, modelData, firmware, board, boardType));
break;
case AbstractItemModel::CustomFuncResetParamId:
registerItemModel(new CustomFuncResetParamItemModel(generalSettings, modelData, firmware, board, boardType));
break;
case AbstractItemModel::TeleSourceId:
registerItemModel(new TelemetrySourceItemModel(generalSettings, modelData, firmware, board, boardType));
break;
case AbstractItemModel::CurveRefTypeId:
registerItemModel(new CurveRefTypeItemModel(generalSettings, modelData, firmware, board, boardType));
break;
case AbstractItemModel::CurveRefFuncId:
registerItemModel(new CurveRefFuncItemModel(generalSettings, modelData, firmware, board, boardType));
break;
default:
qDebug() << "Error: unknown item model: id";
break;
}
}
void ItemModelsFactory::registerItemModel(AbstractItemModel * itemModel)
{
if (itemModel && !getItemModel(itemModel->getId())) {
registeredItemModels.push_back(itemModel);
}
}
void ItemModelsFactory::unregisterItemModels()
{
foreach (AbstractItemModel *itemModel, registeredItemModels) {
delete itemModel;
}
}
void ItemModelsFactory::unregisterItemModel(const AbstractItemModel::ItemModelId id)
{
AbstractItemModel * itemModel = getItemModel(id);
if (itemModel)
delete itemModel;
}
AbstractItemModel * ItemModelsFactory::getItemModel(const AbstractItemModel::ItemModelId id) const
{
foreach (AbstractItemModel * itemModel, registeredItemModels) {
if (itemModel->getId() == id)
return itemModel;
}
return nullptr;
}
void ItemModelsFactory::update(const AbstractItemModel::UpdateTrigger trigger)
{
foreach (AbstractItemModel * itemModel, registeredItemModels) {
itemModel->update(trigger);
}
}
void ItemModelsFactory::dumpAllItemModelContents() const
{
foreach (AbstractItemModel * itemModel, registeredItemModels) {
AbstractItemModel::dumpItemModelContents(itemModel);
}
}
companion/src/datamodels/rawitemdatamodels.h
+165 -103
View File
@@ -30,13 +30,24 @@ class GeneralSettings;
class ModelData;
class AdjustmentReference;
class AbstractStandardItemModel: public QStandardItemModel
class AbstractItemModel: public QStandardItemModel
{
Q_OBJECT
public:
explicit AbstractStandardItemModel(QObject * parent = nullptr) :
QStandardItemModel(parent)
{}
enum ItemModelId {
UnknownId,
RawSourceId,
RawSwitchId,
CurveId,
GVarRefId,
ThrSourceId,
CustomFuncActionId,
CustomFuncResetParamId,
TeleSourceId,
CurveRefTypeId,
CurveRefFuncId
};
Q_ENUM(ItemModelId)
enum DataRoles {
ItemIdRole = Qt::UserRole,
@@ -52,203 +63,254 @@ class AbstractStandardItemModel: public QStandardItemModel
PositiveGroup = 0x04
};
Q_ENUM(DataGroups)
};
class AbstractRawItemDataModel: public AbstractStandardItemModel
{
Q_OBJECT
public:
explicit AbstractRawItemDataModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent = nullptr) :
AbstractStandardItemModel(parent),
enum UpdateTrigger {
SystemRefresh = 1 << 0,
ChannelsUpdated = 1 << 1,
CurvesUpdated = 1 << 2,
FlightModesUpdated = 1 << 3,
GVarsUpdated = 1 << 4,
InputsUpdated = 1 << 5,
LogicalSwitchesUpdated = 1 << 6,
ScriptsUpdated = 1 << 7,
TeleSensorsUpdated = 1 << 8,
TimersUpdated = 1 << 9,
AllTriggers = SystemRefresh | ChannelsUpdated | CurvesUpdated | FlightModesUpdated | GVarsUpdated | InputsUpdated |
LogicalSwitchesUpdated | ScriptsUpdated | TeleSensorsUpdated | TimersUpdated,
NoTriggers = 0
};
Q_ENUM(UpdateTrigger)
explicit AbstractItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
Firmware * firmware, const Boards * const board, const Board::Type boardType) :
QStandardItemModel(nullptr),
generalSettings(generalSettings),
modelData(modelData)
modelData(modelData),
firmware(firmware),
board(board),
boardType(boardType)
{}
public slots:
virtual void update() = 0;
virtual ~AbstractItemModel() {};
signals:
void dataAboutToBeUpdated();
void dataUpdateComplete();
void setId(ItemModelId id) { m_id = id; }
ItemModelId getId () const { return m_id; }
void setUpdateMask(const int mask) { m_updateMask = mask; }
int getUpdateMask() const { return m_updateMask; }
inline bool doUpdate(const UpdateTrigger trigger) const { return m_updateMask & (int)trigger; }
AbstractItemModel * getItemModel(const ItemModelId id) const;
static void dumpItemModelContents(AbstractItemModel * itemModel);
public slots:
virtual void update(const UpdateTrigger trigger = SystemRefresh) = 0;
protected:
const GeneralSettings * generalSettings;
const ModelData * modelData;
Firmware * firmware;
const Boards * board;
const Board::Type boardType;
private:
ItemModelId m_id = UnknownId;
int m_updateMask = 0;
};
class RawSourceItemModel: public AbstractRawItemDataModel
class AbstractStaticItemModel: public AbstractItemModel
{
Q_OBJECT
public:
explicit RawSourceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent = nullptr);
explicit AbstractStaticItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
Firmware * firmware, const Boards * const board, const Board::Type boardType) :
AbstractItemModel(generalSettings, modelData, firmware, board, boardType) {}
virtual ~AbstractStaticItemModel() {};
public slots:
void update() override;
virtual void update(const UpdateTrigger trigger = SystemRefresh) override final {}
};
class AbstractDynamicItemModel: public AbstractItemModel
{
Q_OBJECT
public:
explicit AbstractDynamicItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
Firmware * firmware, const Boards * const board, const Board::Type boardType) :
AbstractItemModel(generalSettings, modelData, firmware, board, boardType) {}
virtual ~AbstractDynamicItemModel() {};
public slots:
virtual void update(const UpdateTrigger trigger = SystemRefresh) {}
signals:
void aboutToBeUpdated();
void updateComplete();
};
class RawSourceItemModel: public AbstractDynamicItemModel
{
Q_OBJECT
public:
explicit RawSourceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
Firmware * firmware, const Boards * const board, const Board::Type boardType);
virtual ~RawSourceItemModel() {};
public slots:
virtual void update(const UpdateTrigger trigger = SystemRefresh) override;
protected:
void setDynamicItemData(QStandardItem * item, const RawSource & src) const;
virtual void setDynamicItemData(QStandardItem * item, const RawSource & src) const;
void addItems(const RawSourceType & type, const int group, const int count, const int start = 0);
};
class RawSwitchItemModel: public AbstractRawItemDataModel
class RawSwitchItemModel: public AbstractDynamicItemModel
{
Q_OBJECT
public:
explicit RawSwitchItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent = nullptr);
explicit RawSwitchItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
Firmware * firmware, const Boards * const board, const Board::Type boardType);
virtual ~RawSwitchItemModel() {};
public slots:
void update() override;
virtual void update(const UpdateTrigger trigger = SystemRefresh) override;
protected:
void setDynamicItemData(QStandardItem * item, const RawSwitch & rsw) const;
virtual void setDynamicItemData(QStandardItem * item, const RawSwitch & rsw) const;
void addItems(const RawSwitchType & type, int count);
};
class CurveItemModel: public AbstractRawItemDataModel
class CurveItemModel: public AbstractDynamicItemModel
{
Q_OBJECT
public:
explicit CurveItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent = nullptr);
explicit CurveItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
Firmware * firmware, const Boards * const board, const Board::Type boardType);
virtual ~CurveItemModel() {};
public slots:
void update() override;
virtual void update(const UpdateTrigger trigger = SystemRefresh) override;
protected:
void setDynamicItemData(QStandardItem * item, const int index) const;
virtual void setDynamicItemData(QStandardItem * item, const int value) const;
};
class GVarReferenceItemModel: public AbstractRawItemDataModel
class GVarReferenceItemModel: public AbstractDynamicItemModel
{
Q_OBJECT
public:
explicit GVarReferenceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent = nullptr);
explicit GVarReferenceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
Firmware * firmware, const Boards * const board, const Board::Type boardType);
virtual ~GVarReferenceItemModel() {};
public slots:
void update() override;
virtual void update(const UpdateTrigger trigger = SystemRefresh) override;
protected:
void setDynamicItemData(QStandardItem * item, const AdjustmentReference & ar) const;
virtual void setDynamicItemData(QStandardItem * item, const AdjustmentReference & ar) const;
void addItems(int count);
};
class ThrottleSourceItemModel: public AbstractRawItemDataModel
class ThrottleSourceItemModel: public AbstractDynamicItemModel
{
Q_OBJECT
public:
explicit ThrottleSourceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent = nullptr);
explicit ThrottleSourceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
Firmware * firmware, const Boards * const board, const Board::Type boardType);
virtual ~ThrottleSourceItemModel() {};
public slots:
void update() override;
virtual void update(const UpdateTrigger trigger = SystemRefresh) override;
protected:
void setDynamicItemData(QStandardItem * item, const int index) const;
virtual void setDynamicItemData(QStandardItem * item, const int value) const;
};
class CustomFuncActionItemModel: public AbstractRawItemDataModel
class CustomFuncActionItemModel: public AbstractDynamicItemModel
{
Q_OBJECT
public:
explicit CustomFuncActionItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent = nullptr);
explicit CustomFuncActionItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
Firmware * firmware, const Boards * const board, const Board::Type boardType);
virtual ~CustomFuncActionItemModel() {};
public slots:
void update() override;
virtual void update(const UpdateTrigger trigger = SystemRefresh) override;
protected:
void setDynamicItemData(QStandardItem * item, const int index) const;
virtual void setDynamicItemData(QStandardItem * item, const int value) const;
};
class CustomFuncResetParamItemModel: public AbstractRawItemDataModel
class CustomFuncResetParamItemModel: public AbstractDynamicItemModel
{
Q_OBJECT
public:
explicit CustomFuncResetParamItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent = nullptr);
explicit CustomFuncResetParamItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
Firmware * firmware, const Boards * const board, const Board::Type boardType);
virtual ~CustomFuncResetParamItemModel() {};
public slots:
void update() override;
virtual void update(const UpdateTrigger trigger = SystemRefresh) override;
protected:
void setDynamicItemData(QStandardItem * item, const int index) const;
virtual void setDynamicItemData(QStandardItem * item, const int value) const;
};
class TelemetrySourceItemModel: public AbstractRawItemDataModel
class TelemetrySourceItemModel: public AbstractDynamicItemModel
{
Q_OBJECT
public:
explicit TelemetrySourceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent = nullptr);
explicit TelemetrySourceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
Firmware * firmware, const Boards * const board, const Board::Type boardType);
virtual ~TelemetrySourceItemModel() {};
public slots:
void update() override;
virtual void update(const UpdateTrigger trigger = SystemRefresh) override;
protected:
void setDynamicItemData(QStandardItem * item, const int index) const;
virtual void setDynamicItemData(QStandardItem * item, const int value) const;
};
class CommonItemModels: public QObject
class CurveRefTypeItemModel : public AbstractStaticItemModel
{
Q_OBJECT
public:
enum RadioModelObjects {
RMO_CHANNELS,
RMO_CURVES,
RMO_FLIGHT_MODES,
RMO_GLOBAL_VARIABLES,
RMO_INPUTS,
RMO_LOGICAL_SWITCHES,
RMO_SCRIPTS,
RMO_TELEMETRY_SENSORS,
RMO_TIMERS
};
Q_ENUM(RadioModelObjects)
explicit CommonItemModels(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent = nullptr);
~CommonItemModels();
void update(const RadioModelObjects radioModelObjects);
RawSourceItemModel * rawSourceItemModel() const { return m_rawSourceItemModel; }
RawSwitchItemModel * rawSwitchItemModel() const { return m_rawSwitchItemModel; }
CurveItemModel * curveItemModel() const { return m_curveItemModel; }
GVarReferenceItemModel * gvarItemModel() const { return m_gvarReferenceItemModel; }
ThrottleSourceItemModel * throttleSourceItemModel() const { return m_throttleSourceItemModel; }
CustomFuncActionItemModel * customFuncActionItemModel() const { return m_customFuncActionItemModel; }
CustomFuncResetParamItemModel * customFuncResetParamItemModel() const { return m_customFuncResetParamItemModel; }
TelemetrySourceItemModel * telemetrySourceItemModel() const { return m_telemetrySourceItemModel; }
private:
RawSourceItemModel *m_rawSourceItemModel;
RawSwitchItemModel *m_rawSwitchItemModel;
CurveItemModel *m_curveItemModel;
GVarReferenceItemModel *m_gvarReferenceItemModel;
ThrottleSourceItemModel *m_throttleSourceItemModel;
CustomFuncActionItemModel *m_customFuncActionItemModel;
CustomFuncResetParamItemModel *m_customFuncResetParamItemModel;
TelemetrySourceItemModel *m_telemetrySourceItemModel;
explicit CurveRefTypeItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
Firmware * firmware, const Boards * const board, const Board::Type boardType);
virtual ~CurveRefTypeItemModel() {};
};
void dumpModelContents(QString desc, AbstractRawItemDataModel * dataModel);
class CurveRefTypeItemModel : public AbstractStandardItemModel
class CurveRefFuncItemModel : public AbstractStaticItemModel
{
Q_OBJECT
public:
explicit CurveRefTypeItemModel(QObject * parent = nullptr);
explicit CurveRefFuncItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
Firmware * firmware, const Boards * const board, const Board::Type boardType);
virtual ~CurveRefFuncItemModel() {};
};
class CurveRefFuncItemModel : public AbstractStandardItemModel
class ItemModelsFactory
{
Q_OBJECT
public:
explicit CurveRefFuncItemModel(QObject * parent = nullptr);
};
ItemModelsFactory(const GeneralSettings * const generalSettings, const ModelData * const modelData);
virtual ~ItemModelsFactory();
void addItemModel(const AbstractItemModel::ItemModelId id);
void registerItemModel(AbstractItemModel * itemModel);
void unregisterItemModels();
void unregisterItemModel(const AbstractItemModel::ItemModelId id);
AbstractItemModel * getItemModel(const AbstractItemModel::ItemModelId id) const;
void update(const AbstractItemModel::UpdateTrigger trigger = AbstractItemModel::SystemRefresh);
void dumpAllItemModelContents() const;
protected:
const GeneralSettings * generalSettings;
const ModelData * modelData;
Firmware * firmware;
Boards * board;
Board::Type boardType;
QVector<AbstractItemModel *> registeredItemModels;
};
#endif // RAWITEMDATAMODELS_H
companion/src/datamodels/rawitemfilteredmodel.cpp
+129 -15
View File
@@ -20,24 +20,24 @@
#include "rawitemfilteredmodel.h"
RawItemFilteredModel::RawItemFilteredModel(QAbstractItemModel * sourceModel, int flags, QObject * parent) :
QSortFilterProxyModel(parent),
FilteredItemModel::FilteredItemModel(AbstractItemModel * sourceModel, int flags) :
QSortFilterProxyModel(nullptr),
filterFlags(0)
{
setFilterRole(AbstractRawItemDataModel::IsAvailableRole);
setFilterRole(AbstractItemModel::IsAvailableRole);
setFilterKeyColumn(0);
setFilterFlags(flags);
setDynamicSortFilter(true);
setSourceModel(sourceModel);
AbstractRawItemDataModel * itemModel = qobject_cast<AbstractRawItemDataModel *>(sourceModel);
AbstractDynamicItemModel * itemModel = qobject_cast<AbstractDynamicItemModel *>(sourceModel);
if (itemModel) {
connect(itemModel, &AbstractRawItemDataModel::dataAboutToBeUpdated, this, &RawItemFilteredModel::onDataAboutToBeUpdated);
connect(itemModel, &AbstractRawItemDataModel::dataUpdateComplete, this, &RawItemFilteredModel::onDataUpdateComplete);
connect(itemModel, &AbstractDynamicItemModel::aboutToBeUpdated, this, &FilteredItemModel::onAboutToBeUpdated);
connect(itemModel, &AbstractDynamicItemModel::updateComplete, this, &FilteredItemModel::onUpdateComplete);
}
}
void RawItemFilteredModel::setFilterFlags(int flags)
void FilteredItemModel::setFilterFlags(int flags)
{
if (filterFlags != flags) {
filterFlags = flags;
@@ -45,7 +45,7 @@ void RawItemFilteredModel::setFilterFlags(int flags)
}
}
bool RawItemFilteredModel::filterAcceptsRow(int sourceRow, const QModelIndex & sourceParent) const
bool FilteredItemModel::filterAcceptsRow(int sourceRow, const QModelIndex & sourceParent) const
{
const QModelIndex & srcIdx = sourceModel()->index(sourceRow, 0, sourceParent);
if (!srcIdx.isValid() || !sourceModel()->data(srcIdx, filterRole()).toBool())
@@ -55,23 +55,137 @@ bool RawItemFilteredModel::filterAcceptsRow(int sourceRow, const QModelIndex & s
return true;
bool ok;
const int flags = sourceModel()->data(srcIdx, AbstractRawItemDataModel::ItemFlagsRole).toInt(&ok);
const int flags = sourceModel()->data(srcIdx, AbstractItemModel::ItemFlagsRole).toInt(&ok);
return (ok && (!flags || (filterFlags & flags)));
}
void RawItemFilteredModel::update() const
void FilteredItemModel::update() const
{
AbstractRawItemDataModel * itemModel = qobject_cast<AbstractRawItemDataModel *>(sourceModel());
AbstractDynamicItemModel * itemModel = qobject_cast<AbstractDynamicItemModel *>(sourceModel());
if (itemModel)
itemModel->update();
}
void RawItemFilteredModel::onDataAboutToBeUpdated()
void FilteredItemModel::onAboutToBeUpdated()
{
emit dataAboutToBeUpdated();
emit aboutToBeUpdated();
}
void RawItemFilteredModel::onDataUpdateComplete()
void FilteredItemModel::onUpdateComplete()
{
emit dataUpdateComplete();
emit updateComplete();
}
// static
void FilteredItemModel::dumpItemModelContents(FilteredItemModel * itemModel)
{
if (itemModel) {
qDebug() << "id:" << itemModel->getId() << "name:" << itemModel->getName();
for (int i = 0; i < itemModel->rowCount(); ++i) {
qDebug() << "row:" << i
<< "text:" << itemModel->data(itemModel->index(i, 0), Qt::DisplayRole).toString()
<< "id:" << itemModel->data(itemModel->index(i, 0), AbstractItemModel::ItemIdRole).toInt()
<< "avail:" << itemModel->data(itemModel->index(i, 0), AbstractItemModel::IsAvailableRole).toBool()
<< "flags:" << itemModel->data(itemModel->index(i, 0), AbstractItemModel::ItemFlagsRole).toInt()
<< "type:" << itemModel->data(itemModel->index(i, 0), AbstractItemModel::ItemTypeRole).toInt();
}
}
else
qDebug() << "Error: model did not cast";
}
//
// FilteredItemModelsFactory
//
FilteredItemModelsFactory::FilteredItemModelsFactory()
{
}
FilteredItemModelsFactory::~FilteredItemModelsFactory()
{
unregisterItemModels();
}
int FilteredItemModelsFactory::registerItemModel(FilteredItemModel * itemModel, QString name)
{
if (itemModel) {
if (isItemModelRegistered(name))
qDebug() << "Warning: item model already registered with name:" << name;
const int id = registeredItemModels.count();
itemModel->setId(id);
itemModel->setName(name);
registeredItemModels.push_back(itemModel);
return id;
}
return 0;
}
void FilteredItemModelsFactory::unregisterItemModels()
{
foreach (FilteredItemModel * itemModel, registeredItemModels) {
delete itemModel;
}
}
void FilteredItemModelsFactory::unregisterItemModel(const int id)
{
FilteredItemModel * itemModel = getItemModel(id);
if (itemModel)
delete itemModel;
}
bool FilteredItemModelsFactory::isItemModelRegistered(const int id) const
{
return getItemModel(id);
}
bool FilteredItemModelsFactory::isItemModelRegistered(const QString name) const
{
return getItemModel(name);
}
FilteredItemModel * FilteredItemModelsFactory::getItemModel(const int id) const
{
foreach (FilteredItemModel * itemModel, registeredItemModels) {
if (itemModel->getId() == id)
return itemModel;
}
return nullptr;
}
FilteredItemModel * FilteredItemModelsFactory::getItemModel(const QString name) const
{
foreach (FilteredItemModel * itemModel, registeredItemModels) {
if (itemModel->getName() == name)
return itemModel;
}
return nullptr;
}
void FilteredItemModelsFactory::update()
{
foreach (FilteredItemModel * itemModel, registeredItemModels) {
itemModel->update();
}
}
void FilteredItemModelsFactory::dumpItemModelContents(const int id) const
{
FilteredItemModel::dumpItemModelContents(getItemModel(id));
}
void FilteredItemModelsFactory::dumpItemModelContents(const QString name) const
{
FilteredItemModel::dumpItemModelContents(getItemModel(name));
}
void FilteredItemModelsFactory::dumpAllItemModelContents() const
{
foreach (FilteredItemModel * itemModel, registeredItemModels) {
FilteredItemModel::dumpItemModelContents(itemModel);
}
}
companion/src/datamodels/rawitemfilteredmodel.h
+65 -16
View File
@@ -23,41 +23,90 @@
#include "rawitemdatamodels.h"
#include <QObject>
#include <QSortFilterProxyModel>
#include <QString>
class GeneralSettings;
class ModelData;
class RawItemFilteredModel: public QSortFilterProxyModel
class FilteredItemModel: public QSortFilterProxyModel
{
Q_OBJECT
public:
enum DataFilters {
AllFilter = AbstractRawItemDataModel::NegativeGroup | AbstractRawItemDataModel::NoneGroup | AbstractRawItemDataModel::PositiveGroup,
AllExcludeNoneFilter = AllFilter &~ AbstractRawItemDataModel::NoneGroup,
NegativeFilter = AbstractRawItemDataModel::NegativeGroup | AbstractRawItemDataModel::NoneGroup,
NegativeExcludeNoneFilter = AbstractRawItemDataModel::NegativeGroup,
PositiveFilter = AbstractRawItemDataModel::PositiveGroup | AbstractRawItemDataModel::NoneGroup,
PositiveExcludeNoneFilter = AbstractRawItemDataModel::PositiveGroup
AllFilter = AbstractItemModel::NegativeGroup | AbstractItemModel::NoneGroup | AbstractItemModel::PositiveGroup,
AllExcludeNoneFilter = AllFilter &~ AbstractItemModel::NoneGroup,
NegativeFilter = AbstractItemModel::NegativeGroup | AbstractItemModel::NoneGroup,
NegativeExcludeNoneFilter = AbstractItemModel::NegativeGroup,
PositiveFilter = AbstractItemModel::PositiveGroup | AbstractItemModel::NoneGroup,
PositiveExcludeNoneFilter = AbstractItemModel::PositiveGroup
};
Q_ENUM(DataFilters)
explicit RawItemFilteredModel(QAbstractItemModel * sourceModel, int flags, QObject * parent = nullptr);
explicit RawItemFilteredModel(QAbstractItemModel * sourceModel, QObject * parent = nullptr) : RawItemFilteredModel(sourceModel, 0, parent) {}
explicit FilteredItemModel(AbstractItemModel * sourceModel, int flags);
explicit FilteredItemModel(AbstractItemModel * sourceModel) :
FilteredItemModel(sourceModel, 0) {}
virtual ~FilteredItemModel() {};
void setId(int id) { m_id = id; }
int getId() const { return m_id; };
void setName(QString name) { m_name = name; }
QString getName() const { return m_name; }
static void dumpItemModelContents(FilteredItemModel * itemModel);
public slots:
void setFilterFlags(int flags);
void update() const;
void onDataAboutToBeUpdated();
void onDataUpdateComplete();
void onAboutToBeUpdated();
void onUpdateComplete();
signals:
void dataAboutToBeUpdated();
void dataUpdateComplete();
void aboutToBeUpdated();
void updateComplete();
protected:
bool filterAcceptsRow(int sourceRow, const QModelIndex & sourceParent) const override;
int filterFlags;
private:
int m_id = 0;
QString m_name = "";
};
class FilteredItemModelsFactory
{
public:
FilteredItemModelsFactory();
virtual ~FilteredItemModelsFactory();
int registerItemModel(FilteredItemModel * itemModel, QString name);
void unregisterItemModels();
void unregisterItemModel(const int id);
bool isItemModelRegistered(const int id) const;
bool isItemModelRegistered(const QString name) const;
FilteredItemModel * getItemModel(const int id) const;
FilteredItemModel * getItemModel(const QString name) const;
void update();
void dumpItemModelContents(const int id) const;
void dumpItemModelContents(const QString name) const;
void dumpAllItemModelContents() const;
protected:
QVector<FilteredItemModel *> registeredItemModels;
};
#define FILTEREDITEMMODELCONNECT(fltrmodel) \
connect(fltrmodel, SIGNAL(aboutToBeUpdated()), this, SLOT(onItemModelAboutToBeUpdated())); \
connect(fltrmodel, SIGNAL(updateComplete()), this, SLOT(onItemModelUpdateComplete()));
#define FILTEREDITEMMODEL(fltrmodel, class, modelid, flags) \
fltrmodel = new FilteredItemModel(sharedItemModels->getItemModel(AbstractItemModel::modelid), flags); \
FILTEREDITEMMODELCONNECT(fltrmodel)
#define FILTEREDITEMMODELNOFLAGS(fltrmodel, class, modelid) \
fltrmodel = new FilteredItemModel(sharedItemModels->getItemModel(AbstractItemModel::modelid)); \
FILTEREDITEMMODELCONNECT(fltrmodel)
#endif // RAWITEMFILTEREDMODEL_H
companion/src/firmwares/curvereference.cpp
+26 -24
View File
@@ -144,37 +144,41 @@ int CurveReference::functionCount()
* CurveReferenceUIManager
*/
CurveReferenceUIManager::CurveReferenceUIManager(QComboBox * curveValueCB, CurveReference & curve, const ModelData & model,
RawItemFilteredModel * curveItemModel, RawItemFilteredModel * gvarItemModel,
QObject * parent) :
CurveReferenceUIManager::CurveReferenceUIManager(QComboBox * curveValueCB, CurveReference & curveRef, const ModelData & model,
FilteredItemModel * curveItemModel, FilteredItemModel * gvarItemModel,
FilteredItemModel * typeItemModel, FilteredItemModel * funcItemModel, QObject * parent) :
QObject(parent),
curveTypeCB(nullptr),
curveGVarCB(nullptr),
curveValueSB(nullptr),
curveValueCB(curveValueCB),
curve(curve),
curveRef(curveRef),
model(model),
lock(false),
curveItemModel(curveItemModel),
gvarItemModel(gvarItemModel)
gvarItemModel(gvarItemModel),
typeItemModel(typeItemModel),
funcItemModel(funcItemModel)
{
init(parent);
}
CurveReferenceUIManager::CurveReferenceUIManager(QComboBox * curveTypeCB, QCheckBox * curveGVarCB, QSpinBox * curveValueSB,
QComboBox * curveValueCB, CurveReference & curve, const ModelData & model,
RawItemFilteredModel * curveItemModel, RawItemFilteredModel * gvarItemModel,
QObject * parent) :
QComboBox * curveValueCB, CurveReference & curveRef, const ModelData & model,
FilteredItemModel * curveItemModel, FilteredItemModel * gvarItemModel,
FilteredItemModel * typeItemModel, FilteredItemModel * funcItemModel, QObject * parent) :
QObject(parent),
curveTypeCB(curveTypeCB),
curveGVarCB(curveGVarCB),
curveValueSB(curveValueSB),
curveValueCB(curveValueCB),
curve(curve),
curveRef(curveRef),
model(model),
lock(false),
curveItemModel(curveItemModel),
gvarItemModel(gvarItemModel)
gvarItemModel(gvarItemModel),
typeItemModel(typeItemModel),
funcItemModel(funcItemModel)
{
init(parent);
}
@@ -188,9 +192,8 @@ void CurveReferenceUIManager::init(QObject * parent)
hasCapabilityGvars = getCurrentFirmware()->getCapability(Gvars);
if (curveTypeCB) {
typeItemModel = new RawItemFilteredModel(new CurveRefTypeItemModel(parent), parent);
curveTypeCB->setModel(typeItemModel);
curveTypeCB->setCurrentIndex(curveTypeCB->findData((int)curve.type));
curveTypeCB->setCurrentIndex(curveTypeCB->findData((int)curveRef.type));
connect(curveTypeCB, SIGNAL(currentIndexChanged(int)), this, SLOT(typeChanged(int)));
}
@@ -204,7 +207,6 @@ void CurveReferenceUIManager::init(QObject * parent)
}
if (curveValueCB) {
funcItemModel = new RawItemFilteredModel(new CurveRefFuncItemModel(parent), parent);
curveValueCB->setSizeAdjustPolicy(QComboBox::AdjustToContents);
curveValueCB->setMaxVisibleItems(10);
connect(curveValueCB, SIGNAL(currentIndexChanged(int)), this, SLOT(valueCBChanged()));
@@ -222,12 +224,12 @@ void CurveReferenceUIManager::update()
lock = true;
int widgetsMask = 0;
if (curve.type == CurveReference::CURVE_REF_DIFF || curve.type == CurveReference::CURVE_REF_EXPO) {
if (curveRef.type == CurveReference::CURVE_REF_DIFF || curveRef.type == CurveReference::CURVE_REF_EXPO) {
if (hasCapabilityGvars)
widgetsMask |= CURVE_REF_UI_GVAR_SHOW;
if (curve.isValueNumber()) {
if (curveRef.isValueNumber()) {
curveGVarCB->setChecked(false);
curveValueSB->setValue(curve.value);
curveValueSB->setValue(curveRef.value);
widgetsMask |= CURVE_REF_UI_VALUE_SHOW;
}
else {
@@ -240,7 +242,7 @@ void CurveReferenceUIManager::update()
}
if(curveTypeCB) {
curveTypeCB->setCurrentIndex(curveTypeCB->findData(curve.type));
curveTypeCB->setCurrentIndex(curveTypeCB->findData(curveRef.type));
curveTypeCB->show();
}
if(curveGVarCB)
@@ -248,7 +250,7 @@ void CurveReferenceUIManager::update()
if(curveValueSB)
curveValueSB->setVisible(widgetsMask & CURVE_REF_UI_VALUE_SHOW);
if(curveValueCB) {
if (curve.isValueReference())
if (curveRef.isValueReference())
populateValueCB(curveValueCB);
curveValueCB->setVisible(widgetsMask & CURVE_REF_UI_REF_SHOW);
}
@@ -259,7 +261,7 @@ void CurveReferenceUIManager::update()
void CurveReferenceUIManager::gvarCBChanged(int state)
{
if (!lock) {
curve.value = CurveReference::getDefaultValue(curve.type, state);
curveRef.value = CurveReference::getDefaultValue(curveRef.type, state);
update();
}
}
@@ -268,7 +270,7 @@ void CurveReferenceUIManager::typeChanged(int value)
{
if (!lock) {
CurveReference::CurveRefType type = (CurveReference::CurveRefType)curveTypeCB->itemData(curveTypeCB->currentIndex()).toInt();
curve = CurveReference(type, CurveReference::getDefaultValue(type));
curveRef = CurveReference(type, CurveReference::getDefaultValue(type));
update();
}
}
@@ -276,7 +278,7 @@ void CurveReferenceUIManager::typeChanged(int value)
void CurveReferenceUIManager::valueSBChanged()
{
if (!lock) {
curve.value = curveValueSB->value();
curveRef.value = curveValueSB->value();
update();
}
}
@@ -284,7 +286,7 @@ void CurveReferenceUIManager::valueSBChanged()
void CurveReferenceUIManager::valueCBChanged()
{
if (!lock) {
curve.value = curveValueCB->itemData(curveValueCB->currentIndex()).toInt();
curveRef.value = curveValueCB->itemData(curveValueCB->currentIndex()).toInt();
update();
}
}
@@ -292,7 +294,7 @@ void CurveReferenceUIManager::valueCBChanged()
void CurveReferenceUIManager::populateValueCB(QComboBox * cb)
{
if (cb) {
switch (curve.type) {
switch (curveRef.type) {
case CurveReference::CURVE_REF_DIFF:
case CurveReference::CURVE_REF_EXPO:
cb->setModel(gvarItemModel);
@@ -307,6 +309,6 @@ void CurveReferenceUIManager::populateValueCB(QComboBox * cb)
break;
}
cb->setCurrentIndex(cb->findData(curve.value));
cb->setCurrentIndex(cb->findData(curveRef.value));
}
}
companion/src/firmwares/curvereference.h
+15 -13
View File
@@ -29,7 +29,7 @@
class ModelData;
class RawItemFilteredModel;
class FilteredItemModel;
class CurveReference {
@@ -90,10 +90,14 @@ class CurveReferenceUIManager : public QObject {
public:
CurveReferenceUIManager(QComboBox *curveValueCB, CurveReference & curve, const ModelData & model,
RawItemFilteredModel * curveItemModel, RawItemFilteredModel * gvarItemModel, QObject * parent = nullptr);
FilteredItemModel * curveItemModel, FilteredItemModel * gvarItemModel, FilteredItemModel * typeItemModel,
FilteredItemModel * funcItemModel, QObject * parent = nullptr);
CurveReferenceUIManager(QComboBox *curveTypeCB, QCheckBox *curveGVarCB, QSpinBox *curveValueSB, QComboBox *curveValueCB,
CurveReference & curve, const ModelData & model, RawItemFilteredModel * curveItemModel,
RawItemFilteredModel * gvarItemModel, QObject * parent = nullptr);
CurveReference & curve, const ModelData & model, FilteredItemModel * curveItemModel,
FilteredItemModel * gvarItemModel, FilteredItemModel * typeItemModel,
FilteredItemModel * funcItemModel, QObject * parent = nullptr);
virtual ~CurveReferenceUIManager();
protected slots:
@@ -103,24 +107,22 @@ class CurveReferenceUIManager : public QObject {
void valueCBChanged();
void update();
protected:
private:
QComboBox *curveTypeCB;
QCheckBox *curveGVarCB;
QSpinBox *curveValueSB;
QComboBox *curveValueCB;
CurveReference & curve;
CurveReference & curveRef;
const ModelData & model;
bool lock;
bool hasCapabilityGvars;
RawItemFilteredModel * curveItemModel;
RawItemFilteredModel * gvarItemModel;
RawItemFilteredModel * typeItemModel;
RawItemFilteredModel * funcItemModel;
FilteredItemModel * curveItemModel;
FilteredItemModel * gvarItemModel;
FilteredItemModel * typeItemModel;
FilteredItemModel * funcItemModel;
void populateValueCB(QComboBox * cb);
private:
void init(QObject * parent);
void populateValueCB(QComboBox * cb);
};
#endif // CURVEREFERENCE_H
companion/src/generaledit/generaledit.cpp
+7 -2
View File
@@ -56,10 +56,14 @@ GeneralEdit::GeneralEdit(QWidget * parent, RadioData & radioData, Firmware * fir
}
}
commonItemModels = new CommonItemModels(&generalSettings, nullptr, this);
sharedItemModels = new ItemModelsFactory(&generalSettings, nullptr);
sharedItemModels->addItemModel(AbstractItemModel::RawSourceId);
sharedItemModels->addItemModel(AbstractItemModel::RawSwitchId);
sharedItemModels->addItemModel(AbstractItemModel::CustomFuncActionId);
sharedItemModels->addItemModel(AbstractItemModel::CustomFuncResetParamId);
addTab(new GeneralSetupPanel(this, generalSettings, firmware), tr("Setup"));
addTab(new CustomFunctionsPanel(this, nullptr, generalSettings, firmware, commonItemModels), tr("Global Functions"));
addTab(new CustomFunctionsPanel(this, nullptr, generalSettings, firmware, sharedItemModels), tr("Global Functions"));
addTab(new TrainerPanel(this, generalSettings, firmware), tr("Trainer"));
addTab(new HardwarePanel(this, generalSettings, firmware), tr("Hardware"));
addTab(new CalibrationPanel(this, generalSettings, firmware), tr("Calibration"));
@@ -70,6 +74,7 @@ GeneralEdit::GeneralEdit(QWidget * parent, RadioData & radioData, Firmware * fir
GeneralEdit::~GeneralEdit()
{
delete ui;
delete sharedItemModels;
}
void GeneralEdit::closeEvent(QCloseEvent *event)
companion/src/generaledit/generaledit.h
+2 -2
View File
@@ -25,7 +25,7 @@
#include "eeprominterface.h"
#include "genericpanel.h"
class CommonItemModels;
class ItemModelsFactory;
namespace Ui {
class GeneralEdit;
@@ -73,7 +73,7 @@ class GeneralEdit : public QDialog
QVector<GenericPanel *> panels;
void addTab(GenericPanel *panel, QString text);
void closeEvent(QCloseEvent *event);
CommonItemModels *commonItemModels;
ItemModelsFactory *sharedItemModels;
};
#endif // _GENERALEDIT_H_
companion/src/modeledit/channels.cpp
+7 -8
View File
@@ -96,16 +96,14 @@ void LimitsGroup::updateMinMax(int max)
}
}
}
ChannelsPanel::ChannelsPanel(QWidget * parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, CommonItemModels * commonItemModels):
ChannelsPanel::ChannelsPanel(QWidget * parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, ItemModelsFactory * sharedItemModels):
ModelPanel(parent, model, generalSettings, firmware),
commonItemModels(commonItemModels)
sharedItemModels(sharedItemModels)
{
chnCapability = firmware->getCapability(Outputs);
int channelNameMaxLen = firmware->getCapability(ChannelsName);
curveFilteredModel = new RawItemFilteredModel(commonItemModels->curveItemModel(), RawItemFilteredModel::AllFilter, this);
connect(curveFilteredModel, &RawItemFilteredModel::dataAboutToBeUpdated, this, &ChannelsPanel::onModelDataAboutToBeUpdated);
connect(curveFilteredModel, &RawItemFilteredModel::dataUpdateComplete, this, &ChannelsPanel::onModelDataUpdateComplete);
FILTEREDITEMMODELNOFLAGS(curveFilteredModel, ChannelsPanel, CurveId)
QStringList headerLabels;
headerLabels << "#";
@@ -214,6 +212,7 @@ ChannelsPanel::~ChannelsPanel()
delete centerSB[i];
delete symlimitsChk[i];
}
delete curveFilteredModel;
}
void ChannelsPanel::symlimitsEdited()
@@ -474,12 +473,12 @@ void ChannelsPanel::swapData(int idx1, int idx2)
}
}
void ChannelsPanel::onModelDataAboutToBeUpdated()
void ChannelsPanel::onItemModelAboutToBeUpdated()
{
lock = true;
}
void ChannelsPanel::onModelDataUpdateComplete()
void ChannelsPanel::onItemModelUpdateComplete()
{
update();
lock = false;
@@ -487,5 +486,5 @@ void ChannelsPanel::onModelDataUpdateComplete()
void ChannelsPanel::updateItemModels()
{
commonItemModels->update(CommonItemModels::RMO_CHANNELS);
sharedItemModels->update(AbstractItemModel::ChannelsUpdated);
}
companion/src/modeledit/channels.h
+8 -8
View File
@@ -26,8 +26,8 @@
#include <QtCore>
class CommonItemModels;
class RawItemFilteredModel;
class ItemModelsFactory;
class FilteredItemModel;
constexpr char MIMETYPE_CHANNEL[] = "application/x-companion-channel";
@@ -57,8 +57,8 @@ class ChannelsPanel : public ModelPanel
Q_OBJECT
public:
ChannelsPanel(QWidget * parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, CommonItemModels * commonItemModels);
~ChannelsPanel();
ChannelsPanel(QWidget * parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, ItemModelsFactory * sharedItemModels);
virtual ~ChannelsPanel();
public slots:
void refreshExtendedLimits();
@@ -81,8 +81,8 @@ class ChannelsPanel : public ModelPanel
void cmClear(bool prompt = true);
void cmClearAll();
void onCustomContextMenuRequested(QPoint pos);
void onModelDataAboutToBeUpdated();
void onModelDataUpdateComplete();
void onItemModelAboutToBeUpdated();
void onItemModelUpdateComplete();
private:
bool hasClipboardData(QByteArray * data = nullptr) const;
@@ -100,8 +100,8 @@ class ChannelsPanel : public ModelPanel
QCheckBox *symlimitsChk[CPN_MAX_CHNOUT];
int selectedIndex;
int chnCapability;
CommonItemModels * commonItemModels;
RawItemFilteredModel *curveFilteredModel;
ItemModelsFactory *sharedItemModels;
FilteredItemModel *curveFilteredModel;
void updateItemModels();
};
companion/src/modeledit/curves.cpp
+4 -3
View File
@@ -109,11 +109,12 @@ float curveSymmetricalX(float x, float coeff, float yMin, float yMid, float yMax
return y;
}
CurvesPanel::CurvesPanel(QWidget * parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, CommonItemModels * commonItemModels):
CurvesPanel::CurvesPanel(QWidget * parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware,
ItemModelsFactory * sharedItemModels):
ModelPanel(parent, model, generalSettings, firmware),
ui(new Ui::Curves),
currentCurve(0),
commonItemModels(commonItemModels)
sharedItemModels(sharedItemModels)
{
ui->setupUi(this);
@@ -812,7 +813,7 @@ void CurvesPanel::swapData(int idx1, int idx2)
void CurvesPanel::updateItemModels()
{
commonItemModels->update(CommonItemModels::RMO_CURVES);
sharedItemModels->update(AbstractItemModel::CurvesUpdated);
}
CustomScene::CustomScene(QGraphicsView * view) :
companion/src/modeledit/curves.h
+3 -3
View File
@@ -26,7 +26,7 @@
#include <QGraphicsScene>
#include <QGraphicsView>
class CommonItemModels;
class ItemModelsFactory;
constexpr char MIMETYPE_CURVE[] = "application/x-companion-curve";
@@ -61,7 +61,7 @@ class CurvesPanel : public ModelPanel
Q_OBJECT
public:
CurvesPanel(QWidget *parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, CommonItemModels * commonItemModels);
CurvesPanel(QWidget *parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, ItemModelsFactory * sharedItemModels);
virtual ~CurvesPanel();
virtual void update();
@@ -121,7 +121,7 @@ class CurvesPanel : public ModelPanel
bool moveDownAllowed() const;
bool moveUpAllowed() const;
void swapData(int idx1, int idx2);
CommonItemModels * commonItemModels;
ItemModelsFactory * sharedItemModels;
void updateItemModels();
};
companion/src/modeledit/customfunctions.cpp
+12 -19
View File
@@ -66,10 +66,10 @@ void RepeatComboBox::update()
setCurrentIndex(value);
}
CustomFunctionsPanel::CustomFunctionsPanel(QWidget * parent, ModelData * model, GeneralSettings & generalSettings, Firmware * firmware, CommonItemModels * commonItemModels):
CustomFunctionsPanel::CustomFunctionsPanel(QWidget * parent, ModelData * model, GeneralSettings & generalSettings, Firmware * firmware,
ItemModelsFactory * sharedItemModels):
GenericPanel(parent, model, generalSettings, firmware),
functions(model ? model->customFn : generalSettings.customFn),
commonItemModels(commonItemModels),
mediaPlayerCurrent(-1),
mediaPlayer(nullptr),
modelsUpdateCnt(0)
@@ -77,21 +77,10 @@ CustomFunctionsPanel::CustomFunctionsPanel(QWidget * parent, ModelData * model,
lock = true;
fswCapability = model ? firmware->getCapability(CustomFunctions) : firmware->getCapability(GlobalFunctions);
rawSwitchFilteredModel = new RawItemFilteredModel(commonItemModels->rawSwitchItemModel(), model ? RawSwitch::SpecialFunctionsContext : RawSwitch::GlobalFunctionsContext, this);
connect(rawSwitchFilteredModel, &RawItemFilteredModel::dataAboutToBeUpdated, this, &CustomFunctionsPanel::onModelDataAboutToBeUpdated);
connect(rawSwitchFilteredModel, &RawItemFilteredModel::dataUpdateComplete, this, &CustomFunctionsPanel::onModelDataUpdateComplete);
rawSourceAllModel = new RawItemFilteredModel(commonItemModels->rawSourceItemModel(), this);
connect(rawSourceAllModel, &RawItemFilteredModel::dataAboutToBeUpdated, this, &CustomFunctionsPanel::onModelDataAboutToBeUpdated);
connect(rawSourceAllModel, &RawItemFilteredModel::dataUpdateComplete, this, &CustomFunctionsPanel::onModelDataUpdateComplete);
rawSourceInputsModel = new RawItemFilteredModel(commonItemModels->rawSourceItemModel(), RawSource::InputSourceGroups, this);
connect(rawSourceInputsModel, &RawItemFilteredModel::dataAboutToBeUpdated, this, &CustomFunctionsPanel::onModelDataAboutToBeUpdated);
connect(rawSourceInputsModel, &RawItemFilteredModel::dataUpdateComplete, this, &CustomFunctionsPanel::onModelDataUpdateComplete);
rawSourceGVarsModel = new RawItemFilteredModel(commonItemModels->rawSourceItemModel(), RawSource::GVarsGroup, this);
connect(rawSourceGVarsModel, &RawItemFilteredModel::dataAboutToBeUpdated, this, &CustomFunctionsPanel::onModelDataAboutToBeUpdated);
connect(rawSourceGVarsModel, &RawItemFilteredModel::dataUpdateComplete, this, &CustomFunctionsPanel::onModelDataUpdateComplete);
FILTEREDITEMMODEL(rawSwitchFilteredModel, CustomFunctionsPanel, RawSwitchId, model ? RawSwitch::SpecialFunctionsContext : RawSwitch::GlobalFunctionsContext)
FILTEREDITEMMODELNOFLAGS(rawSourceAllModel, CustomFunctionsPanel, RawSourceId)
FILTEREDITEMMODEL(rawSourceInputsModel, CustomFunctionsPanel, RawSourceId, RawSource::InputSourceGroups)
FILTEREDITEMMODEL(rawSourceGVarsModel, CustomFunctionsPanel, RawSourceId, RawSource::GVarsGroup)
if (!firmware->getCapability(VoicesAsNumbers)) {
tracksSet = getFilesSet(getSoundsPath(generalSettings), QStringList() << "*.wav" << "*.WAV", firmware->getCapability(VoicesMaxLength));
@@ -253,6 +242,10 @@ CustomFunctionsPanel::~CustomFunctionsPanel()
{
if (mediaPlayer)
stopSound(mediaPlayerCurrent);
delete rawSwitchFilteredModel;
delete rawSourceAllModel;
delete rawSourceInputsModel;
delete rawSourceGVarsModel;
}
void CustomFunctionsPanel::onMediaPlayerStateChanged(QMediaPlayer::State state)
@@ -827,13 +820,13 @@ bool CustomFunctionsPanel::moveUpAllowed() const
return selectedIndex > 0;
}
void CustomFunctionsPanel::onModelDataAboutToBeUpdated()
void CustomFunctionsPanel::onItemModelAboutToBeUpdated()
{
lock = true;
modelsUpdateCnt++;
}
void CustomFunctionsPanel::onModelDataUpdateComplete()
void CustomFunctionsPanel::onItemModelUpdateComplete()
{
modelsUpdateCnt--;
if (modelsUpdateCnt < 1) {
companion/src/modeledit/customfunctions.h
+10 -11
View File
@@ -26,8 +26,8 @@
#include <QMediaPlayer>
class CommonItemModels;
class RawItemFilteredModel;
class ItemModelsFactory;
class FilteredItemModel;
class TimerEdit;
constexpr char MIMETYPE_CUSTOM_FUNCTION[] = "application/x-companion-custom-function";
@@ -55,8 +55,8 @@ class CustomFunctionsPanel : public GenericPanel
Q_OBJECT
public:
CustomFunctionsPanel(QWidget *parent, ModelData * model, GeneralSettings & generalSettings, Firmware * firmware, CommonItemModels * commonItemModels);
~CustomFunctionsPanel();
CustomFunctionsPanel(QWidget *parent, ModelData * model, GeneralSettings & generalSettings, Firmware * firmware, ItemModelsFactory * sharedItemModels);
virtual ~CustomFunctionsPanel();
virtual void update();
@@ -83,8 +83,8 @@ class CustomFunctionsPanel : public GenericPanel
void cmInsert();
void cmClear(bool prompt = true);
void cmClearAll();
void onModelDataAboutToBeUpdated();
void onModelDataUpdateComplete();
void onItemModelAboutToBeUpdated();
void onItemModelUpdateComplete();
private:
void populateFuncCB(QComboBox *b, unsigned int value);
@@ -96,11 +96,10 @@ class CustomFunctionsPanel : public GenericPanel
bool moveUpAllowed() const;
void swapData(int idx1, int idx2);
void resetCBsAndRefresh(int idx);
CommonItemModels * commonItemModels;
RawItemFilteredModel * rawSwitchFilteredModel;
RawItemFilteredModel * rawSourceAllModel;
RawItemFilteredModel * rawSourceInputsModel;
RawItemFilteredModel * rawSourceGVarsModel;
FilteredItemModel * rawSwitchFilteredModel;
FilteredItemModel * rawSourceAllModel;
FilteredItemModel * rawSourceInputsModel;
FilteredItemModel * rawSourceGVarsModel;
QSet<QString> tracksSet;
QSet<QString> scriptsSet;
companion/src/modeledit/expodialog.cpp
+7 -6
View File
@@ -24,8 +24,9 @@
#include "helpers.h"
ExpoDialog::ExpoDialog(QWidget *parent, ModelData & model, ExpoData *expoData, GeneralSettings & generalSettings,
Firmware * firmware, QString & inputName, RawItemFilteredModel * rawSourceModel,
RawItemFilteredModel * rawSwitchModel, RawItemFilteredModel * curveItemModel, RawItemFilteredModel * gvarItemModel) :
Firmware * firmware, QString & inputName, FilteredItemModel * rawSourceFilteredModel,
FilteredItemModel * rawSwitchFilteredModel, FilteredItemModel * curveFilteredModel,
FilteredItemModel * gvarFilteredModel, FilteredItemModel * crTypeFilteredModel, FilteredItemModel * crFuncFilteredModel) :
QDialog(parent),
ui(new Ui::ExpoDialog),
model(model),
@@ -50,10 +51,10 @@ ExpoDialog::ExpoDialog(QWidget *parent, ModelData & model, ExpoData *expoData, G
gvWeightGroup = new GVarGroup(ui->weightGV, ui->weightSB, ui->weightCB, ed->weight, model, 100, -100, 100);
gvOffsetGroup = new GVarGroup(ui->offsetGV, ui->offsetSB, ui->offsetCB, ed->offset, model, 0, -100, 100);
curveGroup = new CurveReferenceUIManager(ui->curveTypeCB, ui->curveGVarCB, ui->curveValueSB, ui->curveValueCB, ed->curve, model, curveItemModel,
gvarItemModel, this);
curveGroup = new CurveReferenceUIManager(ui->curveTypeCB, ui->curveGVarCB, ui->curveValueSB, ui->curveValueCB, ed->curve, model,
curveFilteredModel, gvarFilteredModel, crTypeFilteredModel, crFuncFilteredModel, this);
ui->switchesCB->setModel(rawSwitchModel);
ui->switchesCB->setModel(rawSwitchFilteredModel);
ui->switchesCB->setCurrentIndex(ui->switchesCB->findData(ed->swtch.toValue()));
ui->sideCB->setCurrentIndex(ed->mode - 1);
@@ -84,7 +85,7 @@ ExpoDialog::ExpoDialog(QWidget *parent, ModelData & model, ExpoData *expoData, G
if (firmware->getCapability(VirtualInputs)) {
ui->inputName->setMaxLength(firmware->getCapability(InputsLength));
ui->sourceCB->setModel(rawSourceModel);
ui->sourceCB->setModel(rawSourceFilteredModel);
ui->sourceCB->setCurrentIndex(ui->sourceCB->findData(ed->srcRaw.toValue()));
ui->inputName->setValidator(new QRegExpValidator(rx, this));
ui->inputName->setText(inputName);
companion/src/modeledit/expodialog.h
+5 -4
View File
@@ -26,7 +26,7 @@
#include "modelprinter.h"
class GVarGroup;
class RawItemFilteredModel;
class FilteredItemModel;
class CurveReferenceUIManager;
namespace Ui {
@@ -37,9 +37,10 @@ class ExpoDialog : public QDialog {
Q_OBJECT
public:
ExpoDialog(QWidget *parent, ModelData & model, ExpoData *expodata, GeneralSettings & generalSettings,
Firmware * firmware, QString & inputName, RawItemFilteredModel * rawSourceItemModel,
RawItemFilteredModel * rawSwitchItemModel, RawItemFilteredModel * curveItemModel, RawItemFilteredModel * gvarItemModel);
~ExpoDialog();
Firmware * firmware, QString & inputName, FilteredItemModel * rawSourceFilteredModel,
FilteredItemModel * rawSwitchFilteredModel, FilteredItemModel * curveFilteredModel, FilteredItemModel * gvarFilteredModel,
FilteredItemModel * crTypeFilteredModel, FilteredItemModel * crFuncFilteredModel);
virtual ~ExpoDialog();
protected:
void updateScale();
companion/src/modeledit/flightmodes.cpp
+22 -10
View File
@@ -24,15 +24,16 @@
#include "helpers.h"
#include "customdebug.h"
FlightModePanel::FlightModePanel(QWidget * parent, ModelData & model, int phaseIdx, GeneralSettings & generalSettings, Firmware * firmware, RawItemFilteredModel * rawSwitchFilteredModel):
FlightModePanel::FlightModePanel(QWidget * parent, ModelData & model, int phaseIdx, GeneralSettings & generalSettings, Firmware * firmware,
FilteredItemModel * rawSwitchFilteredModel):
ModelPanel(parent, model, generalSettings, firmware),
ui(new Ui::FlightMode),
phaseIdx(phaseIdx),
phase(model.flightModeData[phaseIdx])
{
ui->setupUi(this);
connect(rawSwitchFilteredModel, &RawItemFilteredModel::dataAboutToBeUpdated, this, &FlightModePanel::onModelDataAboutToBeUpdated);
connect(rawSwitchFilteredModel, &RawItemFilteredModel::dataUpdateComplete, this, &FlightModePanel::onModelDataUpdateComplete);
connect(rawSwitchFilteredModel, &FilteredItemModel::aboutToBeUpdated, this, &FlightModePanel::onItemModelAboutToBeUpdated);
connect(rawSwitchFilteredModel, &FilteredItemModel::updateComplete, this, &FlightModePanel::onItemModelUpdateComplete);
ui->labelName->setContextMenuPolicy(Qt::CustomContextMenu);
ui->labelName->setToolTip(tr("Popup menu available"));
@@ -1361,12 +1362,12 @@ void FlightModePanel::gvSwapData(int idx1, int idx2)
}
}
void FlightModePanel::onModelDataAboutToBeUpdated()
void FlightModePanel::onItemModelAboutToBeUpdated()
{
lock = true;
}
void FlightModePanel::onModelDataUpdateComplete()
void FlightModePanel::onItemModelUpdateComplete()
{
update();
lock = false;
@@ -1374,11 +1375,13 @@ void FlightModePanel::onModelDataUpdateComplete()
/**********************************************************/
FlightModesPanel::FlightModesPanel(QWidget * parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, CommonItemModels * commonItemModels):
FlightModesPanel::FlightModesPanel(QWidget * parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware,
ItemModelsFactory * sharedItemModels):
ModelPanel(parent, model, generalSettings, firmware),
commonItemModels(commonItemModels)
sharedItemModels(sharedItemModels)
{
rawSwitchFilteredModel = new RawItemFilteredModel(commonItemModels->rawSwitchItemModel(), RawSwitch::MixesContext, this);
FILTEREDITEMMODEL(rawSwitchFilteredModel, FlightModesPanel, RawSwitchId, RawSwitch::MixesContext)
modesCount = firmware->getCapability(FlightModes);
QGridLayout * gridLayout = new QGridLayout(this);
@@ -1403,6 +1406,7 @@ FlightModesPanel::FlightModesPanel(QWidget * parent, ModelData & model, GeneralS
FlightModesPanel::~FlightModesPanel()
{
delete rawSwitchFilteredModel;
}
QString FlightModesPanel::getTabName(int index)
@@ -1431,10 +1435,18 @@ void FlightModesPanel::update()
emit updated();
}
void FlightModesPanel::onItemModelAboutToBeUpdated()
{
}
void FlightModesPanel::onItemModelUpdateComplete()
{
}
void FlightModesPanel::updateItemModels()
{
commonItemModels->update(CommonItemModels::RMO_FLIGHT_MODES);
commonItemModels->update(CommonItemModels::RMO_GLOBAL_VARIABLES);
sharedItemModels->update(AbstractItemModel::FlightModesUpdated);
sharedItemModels->update(AbstractItemModel::GVarsUpdated);
}
void FlightModesPanel::onTabIndexChanged(int index)
companion/src/modeledit/flightmodes.h
+11 -8
View File
@@ -24,8 +24,8 @@
#include "modeledit.h"
#include "eeprominterface.h"
class CommonItemModels;
class RawItemFilteredModel;
class ItemModelsFactory;
class FilteredItemModel;
constexpr char MIMETYPE_FLIGHTMODE[] = "application/x-companion-flightmode";
constexpr char MIMETYPE_GVAR_PARAMS[] = "application/x-companion-gvar-params";
@@ -41,7 +41,8 @@ class FlightModePanel : public ModelPanel
Q_OBJECT
public:
FlightModePanel(QWidget *parent, ModelData &model, int modeIdx, GeneralSettings & generalSettings, Firmware * firmware, RawItemFilteredModel * rawSwitchFilteredModel);
FlightModePanel(QWidget *parent, ModelData &model, int modeIdx, GeneralSettings & generalSettings, Firmware * firmware,
FilteredItemModel * rawSwitchFilteredModel);
virtual ~FlightModePanel();
virtual void update();
@@ -90,8 +91,8 @@ class FlightModePanel : public ModelPanel
void gvCmPaste();
void gvCmMoveDown();
void gvCmMoveUp();
void onModelDataAboutToBeUpdated();
void onModelDataUpdateComplete();
void onItemModelAboutToBeUpdated();
void onItemModelUpdateComplete();
private:
Ui::FlightMode *ui;
@@ -145,7 +146,7 @@ class FlightModesPanel : public ModelPanel
Q_OBJECT
public:
FlightModesPanel(QWidget *parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, CommonItemModels * commonItemModels);
FlightModesPanel(QWidget *parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, ItemModelsFactory * sharedItemModels);
virtual ~FlightModesPanel();
public slots:
@@ -157,14 +158,16 @@ class FlightModesPanel : public ModelPanel
private slots:
void onPhaseNameChanged();
void onTabIndexChanged(int index);
void onItemModelAboutToBeUpdated();
void onItemModelUpdateComplete();
private:
QString getTabName(int index);
int modesCount;
QTabWidget *tabWidget;
CommonItemModels *commonItemModels;
RawItemFilteredModel *rawSwitchFilteredModel;
ItemModelsFactory *sharedItemModels;
FilteredItemModel *rawSwitchFilteredModel;
QVector<GenericPanel *> panels;
void updateItemModels();
};
companion/src/modeledit/heli.cpp
+6 -8
View File
@@ -23,16 +23,13 @@
#include "helpers.h"
#include "rawitemfilteredmodel.h"
HeliPanel::HeliPanel(QWidget *parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, CommonItemModels * commonItemModels):
HeliPanel::HeliPanel(QWidget *parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, ItemModelsFactory * sharedItemModels):
ModelPanel(parent, model, generalSettings, firmware),
ui(new Ui::Heli),
commonItemModels(commonItemModels)
ui(new Ui::Heli)
{
ui->setupUi(this);
rawSourceFilteredModel = new RawItemFilteredModel(commonItemModels->rawSourceItemModel(), RawSource::InputSourceGroups, this);
connect(rawSourceFilteredModel, &RawItemFilteredModel::dataAboutToBeUpdated, this, &HeliPanel::onModelDataAboutToBeUpdated);
connect(rawSourceFilteredModel, &RawItemFilteredModel::dataUpdateComplete, this, &HeliPanel::onModelDataUpdateComplete);
FILTEREDITEMMODEL(rawSourceFilteredModel, HeliPanel, RawSourceId, RawSource::InputSourceGroups)
connect(ui->swashType, SIGNAL(currentIndexChanged(int)), this, SLOT(edited()));
connect(ui->swashRingVal, SIGNAL(editingFinished()), this, SLOT(edited()));
@@ -71,6 +68,7 @@ HeliPanel::HeliPanel(QWidget *parent, ModelData & model, GeneralSettings & gener
HeliPanel::~HeliPanel()
{
delete ui;
delete rawSourceFilteredModel;
}
void HeliPanel::update()
@@ -118,12 +116,12 @@ void HeliPanel::edited()
}
}
void HeliPanel::onModelDataAboutToBeUpdated()
void HeliPanel::onItemModelAboutToBeUpdated()
{
lock = true;
}
void HeliPanel::onModelDataUpdateComplete()
void HeliPanel::onItemModelUpdateComplete()
{
update();
lock = false;
companion/src/modeledit/heli.h
+7 -8
View File
@@ -23,8 +23,8 @@
#include "modeledit.h"
class CommonItemModels;
class RawItemFilteredModel;
class ItemModelsFactory;
class FilteredItemModel;
namespace Ui {
class Heli;
@@ -35,19 +35,18 @@ class HeliPanel : public ModelPanel
Q_OBJECT
public:
HeliPanel(QWidget *parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, CommonItemModels * commonItemModels);
~HeliPanel();
HeliPanel(QWidget *parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, ItemModelsFactory * sharedItemModels);
virtual ~HeliPanel();
void update();
private slots:
void edited();
void onModelDataAboutToBeUpdated();
void onModelDataUpdateComplete();
void onItemModelAboutToBeUpdated();
void onItemModelUpdateComplete();
private:
Ui::Heli *ui;
CommonItemModels * commonItemModels;
RawItemFilteredModel * rawSourceFilteredModel;
FilteredItemModel * rawSourceFilteredModel;
};
#endif // _HELI_H_
companion/src/modeledit/inputs.cpp
+18 -22
View File
@@ -23,28 +23,18 @@
#include "helpers.h"
#include "rawitemfilteredmodel.h"
InputsPanel::InputsPanel(QWidget *parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, CommonItemModels * commonItemModels):
InputsPanel::InputsPanel(QWidget *parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, ItemModelsFactory * sharedItemModels):
ModelPanel(parent, model, generalSettings, firmware),
expoInserted(false),
modelPrinter(firmware, generalSettings, model),
commonItemModels(commonItemModels)
sharedItemModels(sharedItemModels)
{
rawSourceFilteredModel = new RawItemFilteredModel(commonItemModels->rawSourceItemModel(), (RawSource::InputSourceGroups & ~ RawSource::NoneGroup & ~RawSource::InputsGroup), this);
connect(rawSourceFilteredModel, &RawItemFilteredModel::dataAboutToBeUpdated, this, &InputsPanel::onModelDataAboutToBeUpdated);
connect(rawSourceFilteredModel, &RawItemFilteredModel::dataUpdateComplete, this, &InputsPanel::onModelDataUpdateComplete);
rawSwitchFilteredModel = new RawItemFilteredModel(commonItemModels->rawSwitchItemModel(), RawSwitch::MixesContext, this);
connect(rawSwitchFilteredModel, &RawItemFilteredModel::dataAboutToBeUpdated, this, &InputsPanel::onModelDataAboutToBeUpdated);
connect(rawSwitchFilteredModel, &RawItemFilteredModel::dataUpdateComplete, this, &InputsPanel::onModelDataUpdateComplete);
const int filter = firmware->getCapability(HasInputDiff) ? RawItemFilteredModel::AllFilter : RawItemFilteredModel::PositiveFilter;
curveFilteredModel = new RawItemFilteredModel(commonItemModels->curveItemModel(), filter, this);
connect(curveFilteredModel, &RawItemFilteredModel::dataAboutToBeUpdated, this, &InputsPanel::onModelDataAboutToBeUpdated);
connect(curveFilteredModel, &RawItemFilteredModel::dataUpdateComplete, this, &InputsPanel::onModelDataUpdateComplete);
gvarFilteredModel = new RawItemFilteredModel(commonItemModels->gvarItemModel(), RawItemFilteredModel::AllFilter, this);
connect(gvarFilteredModel, &RawItemFilteredModel::dataAboutToBeUpdated, this, &InputsPanel::onModelDataAboutToBeUpdated);
connect(gvarFilteredModel, &RawItemFilteredModel::dataUpdateComplete, this, &InputsPanel::onModelDataUpdateComplete);
FILTEREDITEMMODEL(rawSourceFilteredModel, InputsPanel, RawSourceId,(RawSource::InputSourceGroups & ~ RawSource::NoneGroup & ~RawSource::InputsGroup))
FILTEREDITEMMODEL(rawSwitchFilteredModel, InputsPanel, RawSwitchId, RawSwitch::MixesContext)
FILTEREDITEMMODEL(curveFilteredModel, InputsPanel, CurveId, firmware->getCapability(HasInputDiff) ? 0 : FilteredItemModel::PositiveFilter)
FILTEREDITEMMODELNOFLAGS(gvarFilteredModel, InputsPanel, GVarRefId)
FILTEREDITEMMODELNOFLAGS(crTypeFilteredModel, InputsPanel, CurveRefTypeId)
FILTEREDITEMMODELNOFLAGS(crFuncFilteredModel, InputsPanel, CurveRefFuncId)
inputsCount = firmware->getCapability(VirtualInputs);
if (inputsCount == 0)
@@ -84,6 +74,12 @@ InputsPanel::InputsPanel(QWidget *parent, ModelData & model, GeneralSettings & g
InputsPanel::~InputsPanel()
{
delete rawSourceFilteredModel;
delete rawSwitchFilteredModel;
delete curveFilteredModel;
delete gvarFilteredModel;
delete crTypeFilteredModel;
delete crFuncFilteredModel;
}
void InputsPanel::update()
@@ -200,7 +196,7 @@ void InputsPanel::gm_openExpo(int index)
inputName = model->inputNames[ed.chn];
ExpoDialog *dlg = new ExpoDialog(this, *model, &ed, generalSettings, firmware, inputName, rawSourceFilteredModel, rawSwitchFilteredModel,
curveFilteredModel, gvarFilteredModel);
curveFilteredModel, gvarFilteredModel, crTypeFilteredModel, crFuncFilteredModel);
if (dlg->exec()) {
model->expoData[index] = ed;
if (firmware->getCapability(VirtualInputs))
@@ -736,12 +732,12 @@ int InputsPanel::getInputIndexFromSelected()
return idx;
}
void InputsPanel::onModelDataAboutToBeUpdated()
void InputsPanel::onItemModelAboutToBeUpdated()
{
lock = true;
}
void InputsPanel::onModelDataUpdateComplete()
void InputsPanel::onItemModelUpdateComplete()
{
update();
lock = false;
@@ -749,5 +745,5 @@ void InputsPanel::onModelDataUpdateComplete()
void InputsPanel::updateItemModels()
{
commonItemModels->update(CommonItemModels::RMO_INPUTS);
sharedItemModels->update(AbstractItemModel::InputsUpdated);
}
companion/src/modeledit/inputs.h
+12 -10
View File
@@ -25,8 +25,8 @@
#include "mixerslistwidget.h"
#include "modelprinter.h"
class CommonItemModels;
class RawItemFilteredModel;
class ItemModelsFactory;
class FilteredItemModel;
constexpr char MIMETYPE_EXPO[] = "application/x-companion-expo";
@@ -35,7 +35,7 @@ class InputsPanel : public ModelPanel
Q_OBJECT
public:
InputsPanel(QWidget *parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, CommonItemModels * commonItemModels);
InputsPanel(QWidget *parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, ItemModelsFactory * sharedItemModels);
virtual ~InputsPanel();
virtual void update();
@@ -62,8 +62,8 @@ class InputsPanel : public ModelPanel
void cmInputInsert();
void cmInputMoveDown();
void cmInputMoveUp();
void onModelDataAboutToBeUpdated();
void onModelDataUpdateComplete();
void onItemModelAboutToBeUpdated();
void onItemModelUpdateComplete();
private:
bool expoInserted;
@@ -72,11 +72,13 @@ class InputsPanel : public ModelPanel
ModelPrinter modelPrinter;
int selectedIdx;
int inputIdx;
CommonItemModels * commonItemModels;
RawItemFilteredModel *rawSourceFilteredModel;
RawItemFilteredModel *rawSwitchFilteredModel;
RawItemFilteredModel *curveFilteredModel;
RawItemFilteredModel *gvarFilteredModel;
ItemModelsFactory *sharedItemModels;
FilteredItemModel *rawSourceFilteredModel;
FilteredItemModel *rawSwitchFilteredModel;
FilteredItemModel *curveFilteredModel;
FilteredItemModel *gvarFilteredModel;
FilteredItemModel *crTypeFilteredModel;
FilteredItemModel *crFuncFilteredModel;
int getExpoIndex(unsigned int dch);
bool gm_insertExpo(int idx);
companion/src/modeledit/logicalswitches.cpp
+10 -12
View File
@@ -24,20 +24,16 @@
#include <TimerEdit>
LogicalSwitchesPanel::LogicalSwitchesPanel(QWidget * parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, CommonItemModels * commonItemModels):
LogicalSwitchesPanel::LogicalSwitchesPanel(QWidget * parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware,
ItemModelsFactory * sharedItemModels):
ModelPanel(parent, model, generalSettings, firmware),
commonItemModels(commonItemModels),
sharedItemModels(sharedItemModels),
selectedIndex(0),
modelsUpdateCnt(0)
{
rawSwitchFilteredModel = new RawItemFilteredModel(commonItemModels->rawSwitchItemModel(), RawSwitch::LogicalSwitchesContext, this);
connect(rawSwitchFilteredModel, &RawItemFilteredModel::dataAboutToBeUpdated, this, &LogicalSwitchesPanel::onModelDataAboutToBeUpdated);
connect(rawSwitchFilteredModel, &RawItemFilteredModel::dataUpdateComplete, this, &LogicalSwitchesPanel::onModelDataUpdateComplete);
FILTEREDITEMMODEL(rawSwitchFilteredModel, LogicalSwitchesPanel, RawSwitchId, RawSwitch::LogicalSwitchesContext)
const int srcGroups = firmware->getCapability(GvarsInCS) ? 0 : (RawSource::AllSourceGroups & ~RawSource::GVarsGroup);
rawSourceFilteredModel = new RawItemFilteredModel(commonItemModels->rawSourceItemModel(), srcGroups, this);
connect(rawSourceFilteredModel, &RawItemFilteredModel::dataAboutToBeUpdated, this, &LogicalSwitchesPanel::onModelDataAboutToBeUpdated);
connect(rawSourceFilteredModel, &RawItemFilteredModel::dataUpdateComplete, this, &LogicalSwitchesPanel::onModelDataUpdateComplete);
FILTEREDITEMMODEL(rawSourceFilteredModel, LogicalSwitchesPanel, RawSourceId, srcGroups)
lsCapability = firmware->getCapability(LogicalSwitches);
lsCapabilityExt = firmware->getCapability(LogicalSwitchesExt);
@@ -161,6 +157,8 @@ LogicalSwitchesPanel::LogicalSwitchesPanel(QWidget * parent, ModelData & model,
LogicalSwitchesPanel::~LogicalSwitchesPanel()
{
delete rawSourceFilteredModel;
delete rawSwitchFilteredModel;
}
void LogicalSwitchesPanel::onFunctionChanged()
@@ -644,16 +642,16 @@ void LogicalSwitchesPanel::swapData(int idx1, int idx2)
void LogicalSwitchesPanel::updateItemModels()
{
lock = true;
commonItemModels->update(CommonItemModels::RMO_LOGICAL_SWITCHES);
sharedItemModels->update(AbstractItemModel::LogicalSwitchesUpdated);
}
void LogicalSwitchesPanel::onModelDataAboutToBeUpdated()
void LogicalSwitchesPanel::onItemModelAboutToBeUpdated()
{
lock = true;
modelsUpdateCnt++;
}
void LogicalSwitchesPanel::onModelDataUpdateComplete()
void LogicalSwitchesPanel::onItemModelUpdateComplete()
{
modelsUpdateCnt--;
if (modelsUpdateCnt < 1) {
companion/src/modeledit/logicalswitches.h
+8 -8
View File
@@ -24,8 +24,8 @@
#include "modeledit.h"
#include "radiodata.h"
class CommonItemModels;
class RawItemFilteredModel;
class ItemModelsFactory;
class FilteredItemModel;
class TimerEdit;
constexpr char MIMETYPE_LOGICAL_SWITCH[] = "application/x-companion-logical-switch";
@@ -35,7 +35,7 @@ class LogicalSwitchesPanel : public ModelPanel
Q_OBJECT
public:
LogicalSwitchesPanel(QWidget *parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, CommonItemModels * commonItemModels);
LogicalSwitchesPanel(QWidget *parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, ItemModelsFactory * sharedItemModels);
virtual ~LogicalSwitchesPanel();
virtual void update();
@@ -60,8 +60,8 @@ class LogicalSwitchesPanel : public ModelPanel
void cmInsert();
void cmClear(bool prompt = true);
void cmClearAll();
void onModelDataAboutToBeUpdated();
void onModelDataUpdateComplete();
void onItemModelAboutToBeUpdated();
void onItemModelUpdateComplete();
private:
QComboBox * cbFunction[CPN_MAX_LOGICAL_SWITCHES];
@@ -74,9 +74,9 @@ class LogicalSwitchesPanel : public ModelPanel
QDoubleSpinBox * dsbDelay[CPN_MAX_LOGICAL_SWITCHES];
QComboBox * cbSource1[CPN_MAX_LOGICAL_SWITCHES];
QComboBox * cbSource2[CPN_MAX_LOGICAL_SWITCHES];
CommonItemModels * commonItemModels;
RawItemFilteredModel * rawSwitchFilteredModel;
RawItemFilteredModel * rawSourceFilteredModel;
ItemModelsFactory * sharedItemModels;
FilteredItemModel * rawSwitchFilteredModel;
FilteredItemModel * rawSourceFilteredModel;
int selectedIndex;
void populateFunctionCB(QComboBox *b);
void updateTimerParam(QDoubleSpinBox *sb, int timer, double minimum=0);
companion/src/modeledit/mixerdialog.cpp
+7 -6
View File
@@ -25,8 +25,9 @@
#include "helpers.h"
MixerDialog::MixerDialog(QWidget *parent, ModelData & model, MixData * mixdata, GeneralSettings & generalSettings, Firmware * firmware,
RawItemFilteredModel * rawSourceModel, RawItemFilteredModel * rawSwitchModel, RawItemFilteredModel * curveItemModel,
RawItemFilteredModel * gvarItemModel) :
FilteredItemModel * rawSourceFilteredModel, FilteredItemModel * rawSwitchFilteredModel,
FilteredItemModel * curveFilteredModel, FilteredItemModel * gvarFilteredModel,
FilteredItemModel * crTypeFilteredModel, FilteredItemModel * crFuncFilteredModel) :
QDialog(parent),
ui(new Ui::MixerDialog),
model(model),
@@ -46,15 +47,15 @@ MixerDialog::MixerDialog(QWidget *parent, ModelData & model, MixData * mixdata,
this->setWindowTitle(tr("DEST -> %1").arg(RawSource(SOURCE_TYPE_CH, md->destCh - 1).toString(&model, &generalSettings)));
ui->sourceCB->setModel(rawSourceModel);
ui->sourceCB->setModel(rawSourceFilteredModel);
ui->sourceCB->setCurrentIndex(ui->sourceCB->findData(md->srcRaw.toValue()));
int limit = firmware->getCapability(OffsetWeight);
gvWeightGroup = new GVarGroup(ui->weightGV, ui->weightSB, ui->weightCB, md->weight, model, 100, -limit, limit);
gvOffsetGroup = new GVarGroup(ui->offsetGV, ui->offsetSB, ui->offsetCB, md->sOffset, model, 0, -limit, limit);
curveGroup = new CurveReferenceUIManager(ui->curveTypeCB, ui->curveGVarCB, ui->curveValueSB, ui->curveValueCB, md->curve, model, curveItemModel,
gvarItemModel, this);
curveGroup = new CurveReferenceUIManager(ui->curveTypeCB, ui->curveGVarCB, ui->curveValueSB, ui->curveValueCB, md->curve, model,
curveFilteredModel, gvarFilteredModel, crTypeFilteredModel, crFuncFilteredModel, this);
ui->MixDR_CB->setChecked(md->noExpo == 0);
@@ -106,7 +107,7 @@ MixerDialog::MixerDialog(QWidget *parent, ModelData & model, MixData * mixdata,
}
}
ui->switchesCB->setModel(rawSwitchModel);
ui->switchesCB->setModel(rawSwitchFilteredModel);
ui->switchesCB->setCurrentIndex(ui->switchesCB->findData(md->swtch.toValue()));
ui->warningCB->setCurrentIndex(md->mixWarn);
ui->mltpxCB->setCurrentIndex(md->mltpx);
companion/src/modeledit/mixerdialog.h
+3 -3
View File
@@ -25,7 +25,7 @@
#include "eeprominterface.h"
class GVarGroup;
class RawItemFilteredModel;
class FilteredItemModel;
class CurveReferenceUIManager;
namespace Ui {
@@ -36,8 +36,8 @@ class MixerDialog : public QDialog {
Q_OBJECT
public:
MixerDialog(QWidget *parent, ModelData & model, MixData *mixdata, GeneralSettings & generalSettings, Firmware * firmware,
RawItemFilteredModel * rawSourceModel, RawItemFilteredModel * rawSwitchModel, RawItemFilteredModel * curveItemModel,
RawItemFilteredModel * gvarItemModel);
FilteredItemModel * rawSourceFilteredModel, FilteredItemModel * rawSwitchFilteredModel, FilteredItemModel * curveFilteredModel,
FilteredItemModel * gvarFilteredModel, FilteredItemModel * crTypeFilteredModel, FilteredItemModel * crFuncFilteredModel);
~MixerDialog();
protected:
companion/src/modeledit/mixes.cpp
+18 -22
View File
@@ -22,29 +22,19 @@
#include "helpers.h"
#include "rawitemfilteredmodel.h"
MixesPanel::MixesPanel(QWidget *parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware,CommonItemModels * commonItemModels):
MixesPanel::MixesPanel(QWidget *parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, ItemModelsFactory * sharedItemModels):
ModelPanel(parent, model, generalSettings, firmware),
mixInserted(false),
highlightedSource(0),
modelPrinter(firmware, generalSettings, model),
commonItemModels(commonItemModels)
sharedItemModels(sharedItemModels)
{
rawSourceFilteredModel = new RawItemFilteredModel(commonItemModels->rawSourceItemModel(), ((RawSource::InputSourceGroups | RawSource::ScriptsGroup) & ~ RawSource::NoneGroup), this);
connect(rawSourceFilteredModel, &RawItemFilteredModel::dataAboutToBeUpdated, this, &MixesPanel::onModelDataAboutToBeUpdated);
connect(rawSourceFilteredModel, &RawItemFilteredModel::dataUpdateComplete, this, &MixesPanel::onModelDataUpdateComplete);
rawSwitchFilteredModel = new RawItemFilteredModel(commonItemModels->rawSwitchItemModel(), RawSwitch::MixesContext, this);
connect(rawSwitchFilteredModel, &RawItemFilteredModel::dataAboutToBeUpdated, this, &MixesPanel::onModelDataAboutToBeUpdated);
connect(rawSwitchFilteredModel, &RawItemFilteredModel::dataUpdateComplete, this, &MixesPanel::onModelDataUpdateComplete);
const int filter = firmware->getCapability(HasMixerExpo) ? RawItemFilteredModel::AllFilter : RawItemFilteredModel::PositiveFilter;
curveFilteredModel = new RawItemFilteredModel(commonItemModels->curveItemModel(), filter, this);
connect(curveFilteredModel, &RawItemFilteredModel::dataAboutToBeUpdated, this, &MixesPanel::onModelDataAboutToBeUpdated);
connect(curveFilteredModel, &RawItemFilteredModel::dataUpdateComplete, this, &MixesPanel::onModelDataUpdateComplete);
gvarFilteredModel = new RawItemFilteredModel(commonItemModels->gvarItemModel(), RawItemFilteredModel::AllFilter, this);
connect(gvarFilteredModel, &RawItemFilteredModel::dataAboutToBeUpdated, this, &MixesPanel::onModelDataAboutToBeUpdated);
connect(gvarFilteredModel, &RawItemFilteredModel::dataUpdateComplete, this, &MixesPanel::onModelDataUpdateComplete);
FILTEREDITEMMODEL(rawSourceFilteredModel, MixesPanel, RawSourceId,((RawSource::InputSourceGroups | RawSource::ScriptsGroup) & ~ RawSource::NoneGroup))
FILTEREDITEMMODEL(rawSwitchFilteredModel, MixesPanel, RawSwitchId, RawSwitch::MixesContext)
FILTEREDITEMMODEL(curveFilteredModel, MixesPanel, CurveId, firmware->getCapability(HasMixerExpo) ? 0 : FilteredItemModel::PositiveFilter)
FILTEREDITEMMODELNOFLAGS(gvarFilteredModel, MixesPanel, GVarRefId)
FILTEREDITEMMODELNOFLAGS(crTypeFilteredModel, MixesPanel, CurveRefTypeId)
FILTEREDITEMMODELNOFLAGS(crFuncFilteredModel, MixesPanel, CurveRefFuncId)
QGridLayout * mixesLayout = new QGridLayout(this);
@@ -79,6 +69,12 @@ MixesPanel::MixesPanel(QWidget *parent, ModelData & model, GeneralSettings & gen
MixesPanel::~MixesPanel()
{
delete rawSourceFilteredModel;
delete rawSwitchFilteredModel;
delete curveFilteredModel;
delete gvarFilteredModel;
delete crTypeFilteredModel;
delete crFuncFilteredModel;
}
void MixesPanel::update()
@@ -194,8 +190,8 @@ void MixesPanel::gm_openMix(int index)
MixData mixd(model->mixData[index]);
MixerDialog *dlg = new MixerDialog(this, *model, &mixd, generalSettings, firmware, rawSourceFilteredModel, rawSwitchFilteredModel,
curveFilteredModel, gvarFilteredModel);
MixerDialog *dlg = new MixerDialog(this, *model, &mixd, generalSettings, firmware, rawSourceFilteredModel, rawSwitchFilteredModel,
curveFilteredModel, gvarFilteredModel, crTypeFilteredModel, crFuncFilteredModel);
if(dlg->exec()) {
model->mixData[index] = mixd;
emit modified();
@@ -551,12 +547,12 @@ void MixesPanel::clearMixes()
}
}
void MixesPanel::onModelDataAboutToBeUpdated()
void MixesPanel::onItemModelAboutToBeUpdated()
{
lock = true;
}
void MixesPanel::onModelDataUpdateComplete()
void MixesPanel::onItemModelUpdateComplete()
{
update();
lock = false;
companion/src/modeledit/mixes.h
+12 -10
View File
@@ -26,15 +26,15 @@
#include "mixerdialog.h"
#include "modelprinter.h"
class CommonItemModels;
class RawItemFilteredModel;
class ItemModelsFactory;
class FilteredItemModel;
class MixesPanel : public ModelPanel
{
Q_OBJECT
public:
MixesPanel(QWidget *parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, CommonItemModels * commonItemModels);
MixesPanel(QWidget *parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, ItemModelsFactory * sharedItemModels);
virtual ~MixesPanel();
virtual void update();
@@ -60,19 +60,21 @@ class MixesPanel : public ModelPanel
void mimeMixerDropped(int index, const QMimeData *data, Qt::DropAction action);
void pasteMixerMimeData(const QMimeData * mimeData, int destIdx);
void onModelDataAboutToBeUpdated();
void onModelDataUpdateComplete();
void onItemModelAboutToBeUpdated();
void onItemModelUpdateComplete();
private:
MixersListWidget * mixersListWidget;
bool mixInserted;
unsigned int highlightedSource;
ModelPrinter modelPrinter;
CommonItemModels * commonItemModels;
RawItemFilteredModel *rawSourceFilteredModel;
RawItemFilteredModel *rawSwitchFilteredModel;
RawItemFilteredModel *curveFilteredModel;
RawItemFilteredModel *gvarFilteredModel;
ItemModelsFactory *sharedItemModels;
FilteredItemModel *rawSourceFilteredModel;
FilteredItemModel *rawSwitchFilteredModel;
FilteredItemModel *curveFilteredModel;
FilteredItemModel *gvarFilteredModel;
FilteredItemModel *crTypeFilteredModel;
FilteredItemModel *crFuncFilteredModel;
int getMixerIndex(unsigned int dch);
bool gm_insertMix(int idx);
companion/src/modeledit/modeledit.cpp
+23 -11
View File
@@ -53,42 +53,53 @@ ModelEdit::ModelEdit(QWidget * parent, RadioData & radioData, int modelId, Firmw
GeneralSettings &generalSettings = radioData.generalSettings;
ModelData &model = radioData.models[modelId];
commonItemModels = new CommonItemModels(&generalSettings, &model, this);
sharedItemModels = new ItemModelsFactory(&generalSettings, &model);
sharedItemModels->addItemModel(AbstractItemModel::RawSourceId);
sharedItemModels->addItemModel(AbstractItemModel::RawSwitchId);
sharedItemModels->addItemModel(AbstractItemModel::CurveId);
sharedItemModels->addItemModel(AbstractItemModel::GVarRefId);
sharedItemModels->addItemModel(AbstractItemModel::ThrSourceId);
sharedItemModels->addItemModel(AbstractItemModel::CustomFuncActionId);
sharedItemModels->addItemModel(AbstractItemModel::CustomFuncResetParamId);
sharedItemModels->addItemModel(AbstractItemModel::TeleSourceId);
sharedItemModels->addItemModel(AbstractItemModel::CurveRefTypeId);
sharedItemModels->addItemModel(AbstractItemModel::CurveRefFuncId);
s1.report("Init");
SetupPanel * setupPanel = new SetupPanel(this, model, generalSettings, firmware, commonItemModels);
SetupPanel * setupPanel = new SetupPanel(this, model, generalSettings, firmware, sharedItemModels);
addTab(setupPanel, tr("Setup"));
s1.report("Setup");
if (firmware->getCapability(Heli)) {
addTab(new HeliPanel(this, model, generalSettings, firmware, commonItemModels), tr("Heli"));
addTab(new HeliPanel(this, model, generalSettings, firmware, sharedItemModels), tr("Heli"));
s1.report("Heli");
}
addTab(new FlightModesPanel(this, model, generalSettings, firmware, commonItemModels), tr("Flight Modes"));
addTab(new FlightModesPanel(this, model, generalSettings, firmware, sharedItemModels), tr("Flight Modes"));
s1.report("Flight Modes");
addTab(new InputsPanel(this, model, generalSettings, firmware, commonItemModels), tr("Inputs"));
addTab(new InputsPanel(this, model, generalSettings, firmware, sharedItemModels), tr("Inputs"));
s1.report("Inputs");
addTab(new MixesPanel(this, model, generalSettings, firmware, commonItemModels), tr("Mixes"));
addTab(new MixesPanel(this, model, generalSettings, firmware, sharedItemModels), tr("Mixes"));
s1.report("Mixes");
ChannelsPanel * channelsPanel = new ChannelsPanel(this, model, generalSettings, firmware, commonItemModels);
ChannelsPanel * channelsPanel = new ChannelsPanel(this, model, generalSettings, firmware, sharedItemModels);
addTab(channelsPanel, tr("Outputs"));
s1.report("Outputs");
addTab(new CurvesPanel(this, model, generalSettings, firmware, commonItemModels), tr("Curves"));
addTab(new CurvesPanel(this, model, generalSettings, firmware, sharedItemModels), tr("Curves"));
s1.report("Curves");
addTab(new LogicalSwitchesPanel(this, model, generalSettings, firmware, commonItemModels), tr("Logical Switches"));
addTab(new LogicalSwitchesPanel(this, model, generalSettings, firmware, sharedItemModels), tr("Logical Switches"));
s1.report("Logical Switches");
addTab(new CustomFunctionsPanel(this, &model, generalSettings, firmware, commonItemModels), tr("Special Functions"));
addTab(new CustomFunctionsPanel(this, &model, generalSettings, firmware, sharedItemModels), tr("Special Functions"));
s1.report("Special Functions");
if (firmware->getCapability(Telemetry)) {
addTab(new TelemetryPanel(this, model, generalSettings, firmware, commonItemModels), tr("Telemetry"));
addTab(new TelemetryPanel(this, model, generalSettings, firmware, sharedItemModels), tr("Telemetry"));
s1.report("Telemetry");
}
@@ -104,6 +115,7 @@ ModelEdit::ModelEdit(QWidget * parent, RadioData & radioData, int modelId, Firmw
ModelEdit::~ModelEdit()
{
delete ui;
delete sharedItemModels;
}
void ModelEdit::closeEvent(QCloseEvent *event)
companion/src/modeledit/modeledit.h
+5 -5
View File
@@ -25,7 +25,7 @@
#include "genericpanel.h"
class RadioData;
class CommonItemModels;
class ItemModelsFactory;
namespace Ui {
class ModelEdit;
@@ -60,12 +60,12 @@ class ModelEdit : public QDialog
private:
Ui::ModelEdit *ui;
int modelId;
RadioData & radioData;
Firmware * firmware;
RadioData &radioData;
Firmware *firmware;
QVector<GenericPanel *> panels;
CommonItemModels * commonItemModels;
ItemModelsFactory *sharedItemModels;
void addTab(GenericPanel *panel, QString text);
void addTab(GenericPanel * panel, QString text);
void launchSimulation();
};
companion/src/modeledit/setup.cpp
+22 -9
View File
@@ -31,14 +31,15 @@
#include <QDir>
TimerPanel::TimerPanel(QWidget *parent, ModelData & model, TimerData & timer, GeneralSettings & generalSettings, Firmware * firmware, QWidget * prevFocus, RawItemFilteredModel * rawSwitchFilteredModel):
TimerPanel::TimerPanel(QWidget *parent, ModelData & model, TimerData & timer, GeneralSettings & generalSettings, Firmware * firmware,
QWidget * prevFocus, FilteredItemModel * rawSwitchFilteredModel):
ModelPanel(parent, model, generalSettings, firmware),
timer(timer),
ui(new Ui::Timer)
{
ui->setupUi(this);
connect(rawSwitchFilteredModel, &RawItemFilteredModel::dataAboutToBeUpdated, this, &TimerPanel::onModelDataAboutToBeUpdated);
connect(rawSwitchFilteredModel, &RawItemFilteredModel::dataUpdateComplete, this, &TimerPanel::onModelDataUpdateComplete);
connect(rawSwitchFilteredModel, &FilteredItemModel::aboutToBeUpdated, this, &TimerPanel::onItemModelAboutToBeUpdated);
connect(rawSwitchFilteredModel, &FilteredItemModel::updateComplete, this, &TimerPanel::onItemModelUpdateComplete);
lock = true;
@@ -172,12 +173,12 @@ void TimerPanel::on_name_editingFinished()
}
}
void TimerPanel::onModelDataAboutToBeUpdated()
void TimerPanel::onItemModelAboutToBeUpdated()
{
lock = true;
}
void TimerPanel::onModelDataUpdateComplete()
void TimerPanel::onItemModelUpdateComplete()
{
update();
lock = false;
@@ -991,13 +992,15 @@ void ModulePanel::onClearAccessRxClicked()
/******************************************************************************/
SetupPanel::SetupPanel(QWidget * parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, CommonItemModels * commonItemModels):
SetupPanel::SetupPanel(QWidget * parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware,
ItemModelsFactory * sharedItemModels) :
ModelPanel(parent, model, generalSettings, firmware),
ui(new Ui::Setup),
commonItemModels(commonItemModels)
sharedItemModels(sharedItemModels)
{
ui->setupUi(this);
rawSwitchFilteredModel = new RawItemFilteredModel(commonItemModels->rawSwitchItemModel(), RawSwitch::TimersContext, this);
FILTEREDITEMMODEL(rawSwitchFilteredModel, SetupPanel, RawSwitchId, RawSwitch::TimersContext)
FILTEREDITEMMODELNOFLAGS(thrSourceFilteredModel, SetupPanel, ThrSourceId)
Board::Type board = firmware->getBoard();
@@ -1248,6 +1251,8 @@ SetupPanel::SetupPanel(QWidget * parent, ModelData & model, GeneralSettings & ge
SetupPanel::~SetupPanel()
{
delete ui;
delete rawSwitchFilteredModel;
delete thrSourceFilteredModel;
}
void SetupPanel::on_extendedLimits_toggled(bool checked)
@@ -1750,7 +1755,15 @@ void SetupPanel::onTimerNameChanged()
updateItemModels();
}
void SetupPanel::onItemModelAboutToBeUpdated()
{
}
void SetupPanel::onItemModelUpdateComplete()
{
}
void SetupPanel::updateItemModels()
{
commonItemModels->update(CommonItemModels::RMO_TIMERS);
sharedItemModels->update(AbstractItemModel::TimersUpdated);
}
companion/src/modeledit/setup.h
+12 -8
View File
@@ -26,8 +26,8 @@
constexpr char MIMETYPE_TIMER[] = "application/x-companion-timer";
class CommonItemModels;
class RawItemFilteredModel;
class ItemModelsFactory;
class FilteredItemModel;
namespace Ui {
class Setup;
@@ -40,7 +40,8 @@ class TimerPanel : public ModelPanel
Q_OBJECT
public:
TimerPanel(QWidget *parent, ModelData & model, TimerData & timer, GeneralSettings & generalSettings, Firmware * firmware, QWidget *prevFocus, RawItemFilteredModel * switchModel);
TimerPanel(QWidget *parent, ModelData & model, TimerData & timer, GeneralSettings & generalSettings, Firmware * firmware,
QWidget *prevFocus, FilteredItemModel * switchModel);
virtual ~TimerPanel();
virtual void update();
@@ -51,8 +52,8 @@ class TimerPanel : public ModelPanel
void on_value_editingFinished();
void on_minuteBeep_toggled(bool checked);
void on_name_editingFinished();
void onModelDataAboutToBeUpdated();
void onModelDataUpdateComplete();
void onItemModelAboutToBeUpdated();
void onItemModelUpdateComplete();
signals:
void nameChanged();
@@ -131,7 +132,7 @@ class SetupPanel : public ModelPanel
Q_OBJECT
public:
SetupPanel(QWidget *parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, CommonItemModels * commonItemModels);
SetupPanel(QWidget *parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, ItemModelsFactory * sharedItemModels);
virtual ~SetupPanel();
virtual void update();
@@ -170,6 +171,8 @@ class SetupPanel : public ModelPanel
void cmTimerMoveDown();
void cmTimerMoveUp();
void onTimerNameChanged();
void onItemModelAboutToBeUpdated();
void onItemModelUpdateComplete();
private:
Ui::Setup *ui;
@@ -191,8 +194,9 @@ class SetupPanel : public ModelPanel
bool moveTimerDownAllowed() const;
bool moveTimerUpAllowed() const;
void swapTimerData(int idx1, int idx2);
CommonItemModels * commonItemModels;
RawItemFilteredModel * rawSwitchFilteredModel;
ItemModelsFactory * sharedItemModels;
FilteredItemModel * rawSwitchFilteredModel;
FilteredItemModel * thrSourceFilteredModel;
void updateItemModels();
};
companion/src/modeledit/telemetry.cpp
+180 -149
View File
@@ -24,24 +24,31 @@
#include "ui_telemetry_sensor.h"
#include "helpers.h"
#include "appdata.h"
#include "rawitemfilteredmodel.h"
#include <TimerEdit>
TelemetryCustomScreen::TelemetryCustomScreen(QWidget *parent, ModelData & model, FrSkyScreenData & screen, GeneralSettings & generalSettings, Firmware * firmware, RawItemFilteredModel * rawSourceModel):
constexpr char FIM_NAME_RAWSOURCE[] {"Raw Source"};
constexpr char FIM_NAME_TELEALLSRC[] {"Tele All Source"};
constexpr char FIM_NAME_TELEPOSSRC[] {"Tele Pos Source"};
TelemetryCustomScreen::TelemetryCustomScreen(QWidget *parent, ModelData & model, FrSkyScreenData & screen, GeneralSettings & generalSettings,
Firmware * firmware, const bool & parentLock, FilteredItemModelsFactory * localFilteredItemModels):
ModelPanel(parent, model, generalSettings, firmware),
ui(new Ui::TelemetryCustomScreen),
screen(screen)
screen(screen),
modelsUpdateCnt(0),
parentLock(parentLock)
{
ui->setupUi(this);
connect(rawSourceModel, &RawItemFilteredModel::dataAboutToBeUpdated, this, &TelemetryCustomScreen::onModelDataAboutToBeUpdated);
connect(rawSourceModel, &RawItemFilteredModel::dataUpdateComplete, this, &TelemetryCustomScreen::onModelDataUpdateComplete);
FilteredItemModel * rawSourceFilteredModel = localFilteredItemModels->getItemModel(FIM_NAME_RAWSOURCE);
connectItemModelEvents(rawSourceFilteredModel);
for (int l = 0; l < firmware->getCapability(TelemetryCustomScreensLines); l++) {
for (int c = 0; c < firmware->getCapability(TelemetryCustomScreensFieldsPerLine); c++) {
fieldsCB[l][c] = new QComboBox(this);
fieldsCB[l][c]->setProperty("index", c + (l << 8));
fieldsCB[l][c]->setModel(rawSourceModel);
fieldsCB[l][c]->setModel(rawSourceFilteredModel);
ui->screenNumsLayout->addWidget(fieldsCB[l][c], l, c, 1, 1);
connect(fieldsCB[l][c], SIGNAL(activated(int)), this, SLOT(customFieldChanged(int)));
}
@@ -50,7 +57,7 @@ TelemetryCustomScreen::TelemetryCustomScreen(QWidget *parent, ModelData & model,
for (int l = 0; l < firmware->getCapability(TelemetryCustomScreensBars); l++) {
barsCB[l] = new QComboBox(this);
barsCB[l]->setProperty("index", l);
barsCB[l]->setModel(rawSourceModel);
barsCB[l]->setModel(rawSourceFilteredModel);
connect(barsCB[l], SIGNAL(activated(int)), this, SLOT(barSourceChanged(int)));
ui->screenBarsLayout->addWidget(barsCB[l], l, 0, 1, 1);
@@ -203,7 +210,7 @@ void TelemetryCustomScreen::updateBar(int line)
void TelemetryCustomScreen::on_screenType_currentIndexChanged(int index)
{
if (!lock) {
if (!isLocked()) {
memset(reinterpret_cast<void *>(&screen.body), 0, sizeof(screen.body));
update();
emit modified();
@@ -212,7 +219,7 @@ void TelemetryCustomScreen::on_screenType_currentIndexChanged(int index)
void TelemetryCustomScreen::scriptNameEdited()
{
if (!lock) {
if (!isLocked()) {
lock = true;
Helpers::getFileComboBoxValue(ui->scriptName, screen.body.script.filename, 8);
emit modified();
@@ -222,7 +229,7 @@ void TelemetryCustomScreen::scriptNameEdited()
void TelemetryCustomScreen::customFieldChanged(int value)
{
if (lock || !sender() || !qobject_cast<QComboBox *>(sender()))
if (isLocked() || !sender() || !qobject_cast<QComboBox *>(sender()))
return;
bool ok;
@@ -238,7 +245,7 @@ void TelemetryCustomScreen::customFieldChanged(int value)
void TelemetryCustomScreen::barSourceChanged(int value)
{
if (lock || !sender() || !qobject_cast<QComboBox *>(sender()))
if (isLocked() || !sender() || !qobject_cast<QComboBox *>(sender()))
return;
bool ok;
@@ -256,7 +263,7 @@ void TelemetryCustomScreen::barSourceChanged(int value)
void TelemetryCustomScreen::barMinChanged(double value)
{
if (!lock) {
if (!isLocked()) {
int line = sender()->property("index").toInt();
screen.body.bars[line].barMin = round(value / minSB[line]->singleStep());
// TODO set min (maxSB)
@@ -266,7 +273,7 @@ void TelemetryCustomScreen::barMinChanged(double value)
void TelemetryCustomScreen::barMaxChanged(double value)
{
if (!lock) {
if (!isLocked()) {
int line = sender()->property("index").toInt();
screen.body.bars[line].barMax = round((value) / maxSB[line]->singleStep());
// TODO set max (minSB)
@@ -276,7 +283,7 @@ void TelemetryCustomScreen::barMaxChanged(double value)
void TelemetryCustomScreen::barTimeChanged()
{
if (!lock) {
if (!isLocked()) {
int line = sender()->property("index").toInt();
int & valRef = (sender()->property("type").toString() == "min" ? screen.body.bars[line].barMin : screen.body.bars[line].barMax);
TimerEdit * te = qobject_cast<TimerEdit *>(sender());
@@ -289,29 +296,49 @@ void TelemetryCustomScreen::barTimeChanged()
}
}
void TelemetryCustomScreen::onModelDataAboutToBeUpdated()
void TelemetryCustomScreen::connectItemModelEvents(const FilteredItemModel * itemModel)
{
lock = true;
connect(itemModel, &FilteredItemModel::aboutToBeUpdated, this, &TelemetryCustomScreen::onItemModelAboutToBeUpdated);
connect(itemModel, &FilteredItemModel::updateComplete, this, &TelemetryCustomScreen::onItemModelUpdateComplete);
}
void TelemetryCustomScreen::onModelDataUpdateComplete()
void TelemetryCustomScreen::onItemModelAboutToBeUpdated()
{
update();
lock = false;
lock = true;
modelsUpdateCnt++;
}
void TelemetryCustomScreen::onItemModelUpdateComplete()
{
modelsUpdateCnt--;
if (modelsUpdateCnt < 1) {
// leave updating to parent
lock = false;
}
}
/******************************************************/
TelemetrySensorPanel::TelemetrySensorPanel(QWidget *parent, SensorData & sensor, int sensorIndex, int sensorCapability, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware):
TelemetrySensorPanel::TelemetrySensorPanel(QWidget *parent, SensorData & sensor, int sensorIndex, int sensorCapability, ModelData & model,
GeneralSettings & generalSettings, Firmware * firmware, const bool & parentLock,
FilteredItemModelsFactory * localFilteredItemModels) :
ModelPanel(parent, model, generalSettings, firmware),
ui(new Ui::TelemetrySensor),
sensor(sensor),
lock(false),
//lock(false),
sensorIndex(sensorIndex),
selectedIndex(0),
sensorCapability(sensorCapability)
sensorCapability(sensorCapability),
modelsUpdateCnt(0),
parentLock(parentLock)
{
ui->setupUi(this);
FilteredItemModel * teleAllSrcFilteredModel = localFilteredItemModels->getItemModel(FIM_NAME_TELEALLSRC);
connectItemModelEvents(teleAllSrcFilteredModel);
FilteredItemModel * telePosSrcFilteredModel = localFilteredItemModels->getItemModel(FIM_NAME_TELEPOSSRC);
connectItemModelEvents(telePosSrcFilteredModel);
ui->numLabel->setText(tr("TELE%1").arg(sensorIndex + 1));
ui->numLabel->setProperty("index", sensorIndex);
ui->numLabel->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
@@ -333,9 +360,13 @@ TelemetrySensorPanel::TelemetrySensorPanel(QWidget *parent, SensorData & sensor,
ui->logs->setField(sensor.logs, this);
ui->persistent->setField(sensor.persistent, this);
ui->onlyPositive->setField(sensor.onlyPositive, this);
ui->gpsSensor->setModel(telePosSrcFilteredModel);
ui->gpsSensor->setField(sensor.gps, this);
ui->altSensor->setModel(telePosSrcFilteredModel);
ui->altSensor->setField(sensor.alt, this);
ui->ampsSensor->setModel(telePosSrcFilteredModel);
ui->ampsSensor->setField(sensor.amps, this);
ui->cellsSensor->setModel(telePosSrcFilteredModel);
ui->cellsSensor->setField(sensor.source, this);
ui->cellsIndex->addItem(tr("Lowest"), SensorData::TELEM_CELL_INDEX_LOWEST);
for (int i = SensorData::TELEM_CELL_INDEX_LOWEST + 1; i < SensorData::TELEM_CELL_INDEX_HIGHEST; i++)
@@ -343,9 +374,13 @@ TelemetrySensorPanel::TelemetrySensorPanel(QWidget *parent, SensorData & sensor,
ui->cellsIndex->addItem(tr("Highest"), SensorData::TELEM_CELL_INDEX_HIGHEST);
ui->cellsIndex->addItem(tr("Delta"), SensorData::TELEM_CELL_INDEX_DELTA);
ui->cellsIndex->setField(sensor.index);
ui->source1->setModel(teleAllSrcFilteredModel);
ui->source1->setField(sensor.sources[0], this);
ui->source2->setModel(teleAllSrcFilteredModel);
ui->source2->setField(sensor.sources[1], this);
ui->source3->setModel(teleAllSrcFilteredModel);
ui->source3->setField(sensor.sources[2], this);
ui->source4->setModel(teleAllSrcFilteredModel);
ui->source4->setField(sensor.sources[3], this);
ui->prec->setField(sensor.prec, 0, 2, false, "", this);
update();
@@ -404,14 +439,10 @@ void TelemetrySensorPanel::update()
sources12FieldsDisplayed = (sensor.formula <= SensorData::TELEM_FORMULA_MULTIPLY);
sources34FieldsDisplayed = (sensor.formula < SensorData::TELEM_FORMULA_MULTIPLY);
totalizeFieldsDisplayed = (sensor.formula == SensorData::TELEM_FORMULA_TOTALIZE);
updateSourcesComboBox(ui->source1, true);
updateSourcesComboBox(ui->source2, true);
updateSourcesComboBox(ui->source3, true);
updateSourcesComboBox(ui->source4, true);
updateSourcesComboBox(ui->gpsSensor, false);
updateSourcesComboBox(ui->altSensor, false);
updateSourcesComboBox(ui->ampsSensor, false);
updateSourcesComboBox(ui->cellsSensor, false);
ui->source1->updateValue();
ui->source2->updateValue();
ui->source3->updateValue();
ui->source4->updateValue();
}
else {
ui->idLabel->show();
@@ -483,40 +514,9 @@ void TelemetrySensorPanel::update()
lock = false;
}
void populateTelemetrySourcesComboBox(AutoComboBox * cb, const ModelData * model, bool negative)
{
cb->clear();
if (negative) {
for (int i = -CPN_MAX_SENSORS; i < 0; ++i) {
const SensorData& sensor = model->sensorData[-i - 1];
if (sensor.isAvailable()) {
if (sensor.type == SensorData::TELEM_TYPE_CUSTOM)
cb->addItem(QString("-%1 (%2)").arg(sensor.label, sensor.getOrigin(model)), i);
else
cb->addItem(QString("-%1").arg(sensor.label), i);
}
}
}
cb->addItem("---", 0);
for (unsigned i = 1; i <= CPN_MAX_SENSORS; ++i) {
const SensorData& sensor = model->sensorData[i-1];
if (sensor.isAvailable()) {
if (sensor.type == SensorData::TELEM_TYPE_CUSTOM)
cb->addItem(QString("%1 (%2)").arg(sensor.label, sensor.getOrigin(model)), i);
else
cb->addItem(QString("%1").arg(sensor.label), i);
}
}
}
void TelemetrySensorPanel::updateSourcesComboBox(AutoComboBox * cb, bool negative)
{
populateTelemetrySourcesComboBox(cb, model, negative);
}
void TelemetrySensorPanel::on_name_editingFinished()
{
if (!lock) {
if (!isLocked() && (sensor.label != ui->name->text().toLatin1())) {
strcpy(sensor.label, ui->name->text().toLatin1());
emit dataModified();
}
@@ -524,7 +524,7 @@ void TelemetrySensorPanel::on_name_editingFinished()
void TelemetrySensorPanel::on_type_currentIndexChanged(int index)
{
if (!lock) {
if (!isLocked()) {
sensor.type = index;
update();
emit modified();
@@ -533,7 +533,7 @@ void TelemetrySensorPanel::on_type_currentIndexChanged(int index)
void TelemetrySensorPanel::on_formula_currentIndexChanged(int index)
{
if (!lock) {
if (!isLocked()) {
sensor.formula = index;
if (sensor.formula == SensorData::TELEM_FORMULA_CELL) {
sensor.prec = 2;
@@ -553,7 +553,7 @@ void TelemetrySensorPanel::on_formula_currentIndexChanged(int index)
void TelemetrySensorPanel::on_unit_currentIndexChanged(int index)
{
if (!lock) {
if (!isLocked()) {
sensor.unit = index;
if (sensor.unit == SensorData::UNIT_FAHRENHEIT) {
sensor.prec = 0;
@@ -565,7 +565,7 @@ void TelemetrySensorPanel::on_unit_currentIndexChanged(int index)
void TelemetrySensorPanel::on_prec_valueChanged()
{
if (!lock) {
if (!isLocked()) {
update();
}
}
@@ -686,15 +686,52 @@ void TelemetrySensorPanel::cmMoveDown()
emit moveDownSensor(selectedIndex);
}
void TelemetrySensorPanel::connectItemModelEvents(const FilteredItemModel * itemModel)
{
connect(itemModel, &FilteredItemModel::aboutToBeUpdated, this, &TelemetrySensorPanel::onItemModelAboutToBeUpdated);
connect(itemModel, &FilteredItemModel::updateComplete, this, &TelemetrySensorPanel::onItemModelUpdateComplete);
}
void TelemetrySensorPanel::onItemModelAboutToBeUpdated()
{
lock = true;
modelsUpdateCnt++;
}
void TelemetrySensorPanel::onItemModelUpdateComplete()
{
modelsUpdateCnt--;
if (modelsUpdateCnt < 1) {
// leave updating to parent
lock = false;
}
}
/******************************************************/
TelemetryPanel::TelemetryPanel(QWidget *parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, CommonItemModels * commonItemModels):
TelemetryPanel::TelemetryPanel(QWidget *parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware,
ItemModelsFactory * sharedItemModels):
ModelPanel(parent, model, generalSettings, firmware),
ui(new Ui::Telemetry),
commonItemModels(commonItemModels)
sharedItemModels(sharedItemModels),
modelsUpdateCnt(0)
{
ui->setupUi(this);
rawSourceFilteredModel = new RawItemFilteredModel(commonItemModels->rawSourceItemModel(), this);
localFilteredItemModels = new FilteredItemModelsFactory();
int newid;
newid = localFilteredItemModels->registerItemModel(new FilteredItemModel(sharedItemModels->getItemModel(AbstractItemModel::RawSourceId)),
FIM_NAME_RAWSOURCE);
connectItemModelEvents(localFilteredItemModels->getItemModel(newid));
newid = localFilteredItemModels->registerItemModel(new FilteredItemModel(sharedItemModels->getItemModel(AbstractItemModel::TeleSourceId)),
FIM_NAME_TELEALLSRC);
connectItemModelEvents(localFilteredItemModels->getItemModel(newid));
newid = localFilteredItemModels->registerItemModel(new FilteredItemModel(sharedItemModels->getItemModel(AbstractItemModel::TeleSourceId),
FilteredItemModel::PositiveFilter), FIM_NAME_TELEPOSSRC);
connectItemModelEvents(localFilteredItemModels->getItemModel(newid));
sensorCapability = firmware->getCapability(Sensors);
if (sensorCapability > CPN_MAX_SENSORS) // TODO should be role of getCapability
@@ -704,13 +741,15 @@ TelemetryPanel::TelemetryPanel(QWidget *parent, ModelData & model, GeneralSettin
model.frsky.usrProto = 1;
}
ui->varioSource->setModel(localFilteredItemModels->getItemModel(FIM_NAME_TELEPOSSRC));
ui->varioSource->setField(model.frsky.varioSource, this);
ui->varioCenterSilent->setField(model.frsky.varioCenterSilent, this);
ui->A1GB->hide();
ui->A2GB->hide();
for (int i = 0; i < sensorCapability; ++i) {
TelemetrySensorPanel * panel = new TelemetrySensorPanel(this, model.sensorData[i], i, sensorCapability, model, generalSettings, firmware);
TelemetrySensorPanel * panel = new TelemetrySensorPanel(this, model.sensorData[i], i, sensorCapability, model, generalSettings,
firmware, lock, localFilteredItemModels);
ui->sensorsLayout->addWidget(panel);
sensorPanels[i] = panel;
connect(panel, SIGNAL(dataModified()), this, SLOT(on_dataModifiedSensor()));
@@ -723,7 +762,9 @@ TelemetryPanel::TelemetryPanel(QWidget *parent, ModelData & model, GeneralSettin
}
if (IS_TARANIS_X9(firmware->getBoard())) {
ui->voltsSource->setModel(localFilteredItemModels->getItemModel(FIM_NAME_TELEPOSSRC));
ui->voltsSource->setField(model.frsky.voltsSource, this);
ui->altitudeSource->setModel(localFilteredItemModels->getItemModel(FIM_NAME_TELEPOSSRC));
ui->altitudeSource->setField(model.frsky.altitudeSource, this);
}
else {
@@ -731,7 +772,8 @@ TelemetryPanel::TelemetryPanel(QWidget *parent, ModelData & model, GeneralSettin
}
for (int i = 0; i < firmware->getCapability(TelemetryCustomScreens); i++) {
TelemetryCustomScreen * tab = new TelemetryCustomScreen(this, model, model.frsky.screens[i], generalSettings, firmware, rawSourceFilteredModel);
TelemetryCustomScreen * tab = new TelemetryCustomScreen(this, model, model.frsky.screens[i], generalSettings, firmware, lock,
localFilteredItemModels);
ui->customScreens->addTab(tab, tr("Telemetry screen %1").arg(i + 1));
telemetryCustomScreens[i] = tab;
connect(tab, &TelemetryCustomScreen::modified, this, &TelemetryPanel::onModified);
@@ -745,10 +787,13 @@ TelemetryPanel::TelemetryPanel(QWidget *parent, ModelData & model, GeneralSettin
TelemetryPanel::~TelemetryPanel()
{
delete ui;
delete localFilteredItemModels;
}
void TelemetryPanel::update()
{
lock = true;
if (IS_HORUS_OR_TARANIS(firmware->getBoard())) {
if (model->moduleData[0].protocol == PULSES_OFF && model->moduleData[1].protocol == PULSES_PPM) {
ui->telemetryProtocol->setEnabled(true);
@@ -758,10 +803,10 @@ void TelemetryPanel::update()
ui->telemetryProtocol->setCurrentIndex(0);
}
populateTelemetrySourcesComboBox(ui->rssiSourceCB, model, false);
populateTelemetrySourcesComboBox(ui->voltsSource, model, false);
populateTelemetrySourcesComboBox(ui->altitudeSource, model, false);
populateTelemetrySourcesComboBox(ui->varioSource, model, false);
ui->rssiSourceCB->updateValue();
ui->voltsSource->updateValue();
ui->altitudeSource->updateValue();
ui->varioSource->updateValue();
}
for (int i = 0; i < sensorCapability; ++i) {
@@ -771,6 +816,8 @@ void TelemetryPanel::update()
for (int i = 0; i < firmware->getCapability(TelemetryCustomScreens); i++) {
telemetryCustomScreens[i]->update();
}
lock = false;
}
void TelemetryPanel::setup()
@@ -792,9 +839,9 @@ void TelemetryPanel::setup()
ui->rssiSourceLabel->show();
ui->rssiSourceLabel->setText(tr("Source"));
ui->rssiSourceCB->setModel(localFilteredItemModels->getItemModel(FIM_NAME_TELEPOSSRC));
ui->rssiSourceCB->setField(model->rssiSource, this);
ui->rssiSourceCB->show();
populateTelemetrySourcesComboBox(ui->rssiSourceCB, model, false);
ui->rssiAlarmWarningCB->hide();
ui->rssiAlarmCriticalCB->hide();
@@ -842,44 +889,9 @@ void TelemetryPanel::setup()
lock = false;
}
void TelemetryPanel::populateVarioSource()
{
AutoComboBox * cb = ui->varioSource;
cb->setField(model->frsky.varioSource, this);
cb->addItem(tr("Alti"), TELEMETRY_VARIO_SOURCE_ALTI);
cb->addItem(tr("Alti+"), TELEMETRY_VARIO_SOURCE_ALTI_PLUS);
cb->addItem(tr("VSpeed"), TELEMETRY_VARIO_SOURCE_VSPEED);
cb->addItem(tr("A1"), TELEMETRY_VARIO_SOURCE_A1);
cb->addItem(tr("A2"), TELEMETRY_VARIO_SOURCE_A2);
}
void TelemetryPanel::populateVoltsSource()
{
AutoComboBox * cb = ui->frskyVoltCB;
cb->setField(model->frsky.voltsSource, this);
cb->addItem(tr("A1"), TELEMETRY_VOLTS_SOURCE_A1);
cb->addItem(tr("A2"), TELEMETRY_VOLTS_SOURCE_A2);
cb->addItem(tr("A3"), TELEMETRY_VOLTS_SOURCE_A3);
cb->addItem(tr("A4"), TELEMETRY_VOLTS_SOURCE_A4);
cb->addItem(tr("FAS"), TELEMETRY_VOLTS_SOURCE_FAS);
cb->addItem(tr("Cells"), TELEMETRY_VOLTS_SOURCE_CELLS);
}
void TelemetryPanel::populateCurrentSource()
{
AutoComboBox * cb = ui->frskyCurrentCB;
cb->setField(model->frsky.currentSource, this);
cb->addItem(tr("---"), TELEMETRY_CURRENT_SOURCE_NONE);
cb->addItem(tr("A1"), TELEMETRY_CURRENT_SOURCE_A1);
cb->addItem(tr("A2"), TELEMETRY_CURRENT_SOURCE_A2);
cb->addItem(tr("A3"), TELEMETRY_CURRENT_SOURCE_A3);
cb->addItem(tr("A4"), TELEMETRY_CURRENT_SOURCE_A4);
cb->addItem(tr("FAS"), TELEMETRY_CURRENT_SOURCE_FAS);
}
void TelemetryPanel::on_telemetryProtocol_currentIndexChanged(int index)
{
if (!lock) {
if (!isLocked()) {
model->telemetryProtocol = index;
emit modified();
}
@@ -892,7 +904,7 @@ void TelemetryPanel::onModified()
void TelemetryPanel::on_bladesCount_editingFinished()
{
if (!lock) {
if (!isLocked()) {
model->frsky.blades = ui->bladesCount->value();
emit modified();
}
@@ -900,7 +912,7 @@ void TelemetryPanel::on_bladesCount_editingFinished()
void TelemetryPanel::on_frskyProtoCB_currentIndexChanged(int index)
{
if (!lock) {
if (!isLocked()) {
model->frsky.usrProto = index;
for (int i = 0; i < firmware->getCapability(TelemetryCustomScreens); i++)
telemetryCustomScreens[i]->update();
@@ -910,31 +922,39 @@ void TelemetryPanel::on_frskyProtoCB_currentIndexChanged(int index)
void TelemetryPanel::on_rssiAlarmWarningSB_editingFinished()
{
model->rssiAlarms.warning= ui->rssiAlarmWarningSB->value();
emit modified();
if (!isLocked()) {
model->rssiAlarms.warning= ui->rssiAlarmWarningSB->value();
emit modified();
}
}
void TelemetryPanel::on_rssiAlarmCriticalSB_editingFinished()
{
model->rssiAlarms.critical = ui->rssiAlarmCriticalSB->value();
emit modified();
if (!isLocked()) {
model->rssiAlarms.critical = ui->rssiAlarmCriticalSB->value();
emit modified();
}
}
void TelemetryPanel::on_varioLimitMin_DSB_editingFinished()
{
model->frsky.varioMin = round(ui->varioLimitMin_DSB->value() + 10);
emit modified();
if (!isLocked()) {
model->frsky.varioMin = round(ui->varioLimitMin_DSB->value() + 10);
emit modified();
}
}
void TelemetryPanel::on_varioLimitMax_DSB_editingFinished()
{
model->frsky.varioMax = round(ui->varioLimitMax_DSB->value() - 10);
emit modified();
if (!isLocked()) {
model->frsky.varioMax = round(ui->varioLimitMax_DSB->value() - 10);
emit modified();
}
}
void TelemetryPanel::on_varioLimitCenterMin_DSB_editingFinished()
{
if (!lock) {
if (!isLocked()) {
if (ui->varioLimitCenterMin_DSB->value() > ui->varioLimitCenterMax_DSB->value()) {
ui->varioLimitCenterMax_DSB->setValue(ui->varioLimitCenterMin_DSB->value());
}
@@ -945,7 +965,7 @@ void TelemetryPanel::on_varioLimitCenterMin_DSB_editingFinished()
void TelemetryPanel::on_varioLimitCenterMax_DSB_editingFinished()
{
if (!lock) {
if (!isLocked()) {
if (ui->varioLimitCenterMin_DSB->value() > ui->varioLimitCenterMax_DSB->value()) {
ui->varioLimitCenterMax_DSB->setValue(ui->varioLimitCenterMin_DSB->value());
}
@@ -956,21 +976,27 @@ void TelemetryPanel::on_varioLimitCenterMax_DSB_editingFinished()
void TelemetryPanel::on_fasOffset_DSB_editingFinished()
{
model->frsky.fasOffset = ui->fasOffset_DSB->value() * 10;
emit modified();
if (!isLocked()) {
model->frsky.fasOffset = ui->fasOffset_DSB->value() * 10;
emit modified();
}
}
void TelemetryPanel::on_mahCount_SB_editingFinished()
{
model->frsky.storedMah = ui->mahCount_SB->value();
emit modified();
if (!isLocked()) {
model->frsky.storedMah = ui->mahCount_SB->value();
emit modified();
}
}
void TelemetryPanel::on_mahCount_ChkB_toggled(bool checked)
{
model->frsky.mAhPersistent = checked;
ui->mahCount_SB->setDisabled(!checked);
emit modified();
if (!isLocked()) {
model->frsky.mAhPersistent = checked;
ui->mahCount_SB->setDisabled(!checked);
emit modified();
}
}
void TelemetryPanel::on_clearAllSensors()
@@ -980,9 +1006,7 @@ void TelemetryPanel::on_clearAllSensors()
model->updateAllReferences(ModelData::REF_UPD_TYPE_SENSOR, ModelData::REF_UPD_ACT_CLEAR, i);
}
updateItemModels();
update();
emit modified();
on_dataModifiedSensor();
}
void TelemetryPanel::on_insertSensor(int selectedIndex)
@@ -990,10 +1014,7 @@ void TelemetryPanel::on_insertSensor(int selectedIndex)
memmove(&model->sensorData[selectedIndex + 1], &model->sensorData[selectedIndex], (CPN_MAX_SENSORS - (selectedIndex + 1)) * sizeof(SensorData));
model->sensorData[selectedIndex].clear();
model->updateAllReferences(ModelData::REF_UPD_TYPE_SENSOR, ModelData::REF_UPD_ACT_SHIFT, selectedIndex, 0, 1);
updateItemModels();
update();
emit modified();
on_dataModifiedSensor();
}
void TelemetryPanel::on_deleteSensor(int selectedIndex)
@@ -1004,10 +1025,7 @@ void TelemetryPanel::on_deleteSensor(int selectedIndex)
memmove(&model->sensorData[selectedIndex], &model->sensorData[selectedIndex + 1], (CPN_MAX_SENSORS - (selectedIndex + 1)) * sizeof(SensorData));
model->sensorData[CPN_MAX_SENSORS - 1].clear();
model->updateAllReferences(ModelData::REF_UPD_TYPE_SENSOR, ModelData::REF_UPD_ACT_SHIFT, selectedIndex, 0, -1);
updateItemModels();
update();
emit modified();
on_dataModifiedSensor();
}
void TelemetryPanel::on_moveUpSensor(int selectedIndex)
@@ -1029,20 +1047,33 @@ void TelemetryPanel::swapData(int idx1, int idx2)
memcpy(sd2, sd1, sizeof(SensorData));
memcpy(sd1, &sdtmp, sizeof(SensorData));
model->updateAllReferences(ModelData::REF_UPD_TYPE_SENSOR, ModelData::REF_UPD_ACT_SWAP, idx1, idx2);
updateItemModels();
update();
emit modified();
on_dataModifiedSensor();
}
}
void TelemetryPanel::on_dataModifiedSensor()
{
updateItemModels();
update();
sharedItemModels->update(AbstractItemModel::TeleSensorsUpdated);
emit modified();
}
void TelemetryPanel::updateItemModels()
void TelemetryPanel::connectItemModelEvents(const FilteredItemModel * itemModel)
{
commonItemModels->update(CommonItemModels::RMO_TELEMETRY_SENSORS);
connect(itemModel, &FilteredItemModel::aboutToBeUpdated, this, &TelemetryPanel::onItemModelAboutToBeUpdated);
connect(itemModel, &FilteredItemModel::updateComplete, this, &TelemetryPanel::onItemModelUpdateComplete);
}
void TelemetryPanel::onItemModelAboutToBeUpdated()
{
lock = true;
modelsUpdateCnt++;
}
void TelemetryPanel::onItemModelUpdateComplete()
{
modelsUpdateCnt--;
if (modelsUpdateCnt < 1) {
update();
lock = false;
}
}
companion/src/modeledit/telemetry.h
+33 -21
View File
@@ -23,12 +23,11 @@
#include "modeledit.h"
#include "eeprominterface.h"
#include "rawitemfilteredmodel.h"
constexpr char MIMETYPE_TELE_SENSOR[] = "application/x-companion-tele-sensor";
constexpr char MIMETYPE_TELE_SENSOR[] {"application/x-companion-tele-sensor"};
class AutoComboBox;
class CommonItemModels;
class RawItemFilteredModel;
class TimerEdit;
namespace Ui {
@@ -42,7 +41,8 @@ class TelemetryCustomScreen: public ModelPanel
Q_OBJECT
public:
TelemetryCustomScreen(QWidget *parent, ModelData & model, FrSkyScreenData & screen, GeneralSettings & generalSettings, Firmware * firmware, RawItemFilteredModel * rawSourceModel);
TelemetryCustomScreen(QWidget *parent, ModelData & model, FrSkyScreenData & screen, GeneralSettings & generalSettings, Firmware * firmware,
const bool & parentLock, FilteredItemModelsFactory * localFilteredItemModels);
~TelemetryCustomScreen();
void update();
@@ -54,8 +54,8 @@ class TelemetryCustomScreen: public ModelPanel
void barMinChanged(double value);
void barMaxChanged(double value);
void barTimeChanged();
void onModelDataAboutToBeUpdated();
void onModelDataUpdateComplete();
void onItemModelAboutToBeUpdated();
void onItemModelUpdateComplete();
private:
void updateBar(int line);
@@ -67,6 +67,11 @@ class TelemetryCustomScreen: public ModelPanel
QDoubleSpinBox * maxSB[4];
TimerEdit * minTime[4];
TimerEdit * maxTime[4];
int modelsUpdateCnt;
const bool &parentLock;
inline bool isLocked() { return lock | parentLock; }
void connectItemModelEvents(const FilteredItemModel * itemModel);
};
class TelemetrySensorPanel: public ModelPanel
@@ -74,7 +79,9 @@ class TelemetrySensorPanel: public ModelPanel
Q_OBJECT
public:
TelemetrySensorPanel(QWidget *parent, SensorData & sensor, int sensorIndex, int sensorCapability, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware);
TelemetrySensorPanel(QWidget *parent, SensorData & sensor, int sensorIndex, int sensorCapability, ModelData & model,
GeneralSettings & generalSettings, Firmware * firmware, const bool & parentLock,
FilteredItemModelsFactory * localFilteredItemModels);
~TelemetrySensorPanel();
void update();
@@ -86,7 +93,6 @@ class TelemetrySensorPanel: public ModelPanel
void moveUpSensor(int index);
void moveDownSensor(int index);
protected slots:
void on_name_editingFinished();
void on_type_currentIndexChanged(int index);
@@ -104,20 +110,24 @@ class TelemetrySensorPanel: public ModelPanel
void cmDelete();
void cmMoveUp();
void cmMoveDown();
protected:
void updateSourcesComboBox(AutoComboBox * cb, bool negative);
void onItemModelAboutToBeUpdated();
void onItemModelUpdateComplete();
private:
Ui::TelemetrySensor * ui;
SensorData & sensor;
bool lock = false;
//bool lock = false;
int sensorIndex = 0;
int selectedIndex = 0;
int sensorCapability;
bool insertAllowed() const;
bool moveDownAllowed() const;
bool moveUpAllowed() const;
int modelsUpdateCnt;
const bool &parentLock;
inline bool isLocked() { return lock | parentLock; }
void connectItemModelEvents(const FilteredItemModel * itemModel);
};
class TelemetryPanel : public ModelPanel
@@ -125,7 +135,8 @@ class TelemetryPanel : public ModelPanel
Q_OBJECT
public:
TelemetryPanel(QWidget *parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, CommonItemModels * commonItemModels);
TelemetryPanel(QWidget *parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware,
ItemModelsFactory * sharedItemModels);
virtual ~TelemetryPanel();
virtual void update();
@@ -152,22 +163,23 @@ class TelemetryPanel : public ModelPanel
void on_moveUpSensor(int index);
void on_moveDownSensor(int index);
void on_dataModifiedSensor();
void onItemModelAboutToBeUpdated();
void onItemModelUpdateComplete();
private:
Ui::Telemetry *ui;
TelemetryCustomScreen * telemetryCustomScreens[4];
TelemetrySensorPanel * sensorPanels[CPN_MAX_SENSORS];
TelemetryCustomScreen *telemetryCustomScreens[4];
TelemetrySensorPanel *sensorPanels[CPN_MAX_SENSORS];
int sensorCapability;
CommonItemModels * commonItemModels;
RawItemFilteredModel * rawSourceFilteredModel;
ItemModelsFactory *sharedItemModels;
FilteredItemModelsFactory *localFilteredItemModels;
int modelsUpdateCnt;
void setup();
void telBarUpdate();
void populateVoltsSource();
void populateCurrentSource();
void populateVarioSource();
void swapData(int idx1, int idx2);
void updateItemModels();
void connectItemModelEvents(const FilteredItemModel * itemModel);
inline bool isLocked() { return lock; }
};
#endif // _TELEMETRY_H_
companion/src/shared/autocombobox.h
+43 -20
View File
@@ -37,30 +37,37 @@ class AutoComboBox: public QComboBox
void clear()
{
lock = true;
QComboBox::clear();
next = 0;
lock = false;
if (!hasModel) {
lock = true;
QComboBox::clear();
next = 0;
lock = false;
}
}
virtual void insertItems(int index, const QStringList & items)
{
foreach(QString item, items) {
addItem(item);
if (!hasModel) {
foreach(QString item, items) {
addItem(item);
}
}
}
virtual void addItem(const QString & item)
{
addItem(item, next++);
if (!hasModel)
addItem(item, next++);
}
virtual void addItem(const QString & item, int value)
{
lock = true;
QComboBox::addItem(item, value);
lock = false;
updateValue();
if (!hasModel) {
lock = true;
QComboBox::addItem(item, value);
lock = false;
updateValue();
}
}
void setField(unsigned int & field, GenericPanel * panel=nullptr)
@@ -77,11 +84,22 @@ class AutoComboBox: public QComboBox
updateValue();
}
void setModel(QAbstractItemModel * model)
{
lock = true;
QComboBox::setModel(model);
lock = false;
hasModel = true;
updateValue();
}
void setAutoIndexes()
{
for (int i=0; i<count(); ++i)
setItemData(i, i);
updateValue();
if (!hasModel) {
for (int i = 0; i < count(); ++i)
setItemData(i, i);
updateValue();
}
}
void updateValue()
@@ -99,13 +117,17 @@ class AutoComboBox: public QComboBox
protected slots:
void onCurrentIndexChanged(int index)
{
const int val = itemData(index).toInt();
if (field && !lock) {
*field = val;
if (panel)
emit panel->modified();
if (panel && panel->lock)
return;
if (index > -1) {
const int val = itemData(index).toInt();
if (field && !lock) {
*field = val;
if (panel)
emit panel->modified();
}
emit currentDataChanged(val);
}
emit currentDataChanged(val);
}
protected:
@@ -113,6 +135,7 @@ class AutoComboBox: public QComboBox
GenericPanel * panel = nullptr;
int next = 0;
bool lock = false;
bool hasModel = false;
};
#endif // _AUTOCOMBOBOX_H_