867 lines
30 KiB
C++
867 lines
30 KiB
C++
/*
|
|
* Copyright (C) EdgeTX
|
|
*
|
|
* Based on code named
|
|
* opentx - https://github.com/opentx/opentx
|
|
* 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 "compounditemmodels.h"
|
|
#include "generalsettings.h"
|
|
#include "eeprominterface.h"
|
|
#include "modeldata.h"
|
|
#include "adjustmentreference.h"
|
|
|
|
// static
|
|
QString AbstractItemModel::idToString(const int value)
|
|
{
|
|
switch (value) {
|
|
case IMID_Unknown:
|
|
return "Unknown";
|
|
case IMID_RawSource:
|
|
return "RawSource";
|
|
case IMID_RawSwitch:
|
|
return "RawSwitch";
|
|
case IMID_Curve:
|
|
return "Curve";
|
|
case IMID_GVarRef:
|
|
return "GVarRef";
|
|
case IMID_ThrSource:
|
|
return "ThrSource";
|
|
case IMID_CustomFuncAction:
|
|
return "CustomFuncAction";
|
|
case IMID_CustomFuncResetParam:
|
|
return "CustomFuncResetParam";
|
|
case IMID_TeleSource:
|
|
return "TeleSource";
|
|
case IMID_CurveRefType:
|
|
return "CurveRefType";
|
|
case IMID_CurveRefFunc:
|
|
return "CurveRefFunc";
|
|
case IMID_FlexSwitches:
|
|
return "FlexSwitches";
|
|
default:
|
|
return "Custom";
|
|
}
|
|
}
|
|
|
|
// static
|
|
void AbstractItemModel::dumpItemModelContents(AbstractItemModel * 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::IMDR_Id).toInt()
|
|
<< "avail:" << itemModel->data(itemModel->index(i, 0), AbstractItemModel::IMDR_Available).toBool()
|
|
<< "flags:" << itemModel->data(itemModel->index(i, 0), AbstractItemModel::IMDR_Flags).toInt()
|
|
<< "type:" << itemModel->data(itemModel->index(i, 0), AbstractItemModel::IMDR_Type).toInt();
|
|
}
|
|
}
|
|
else
|
|
qDebug() << "Error: model not of class AbstractItemModel";
|
|
}
|
|
|
|
//
|
|
// AbstractStaticItemModel
|
|
//
|
|
|
|
void AbstractStaticItemModel::loadItemList()
|
|
{
|
|
foreach (const ListItem *item, itemList) {
|
|
QStandardItem * modelItem = new QStandardItem();
|
|
modelItem->setText(item->text);
|
|
modelItem->setData(item->id, IMDR_Id);
|
|
modelItem->setData(item->type, IMDR_Type);
|
|
modelItem->setData(item->flags, IMDR_Flags);
|
|
modelItem->setData(item->isAvailable, IMDR_Available);
|
|
appendRow(modelItem);
|
|
}
|
|
|
|
itemList.clear();
|
|
};
|
|
|
|
//
|
|
// 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(IMID_RawSource);
|
|
setUpdateMask(IMUE_All &~ (IMUE_Curves | IMUE_Scripts));
|
|
|
|
int groups = board->getCapability(Board::FunctionSwitchGroups);
|
|
|
|
// Descending source direction: inverted (!) sources
|
|
addItems(SOURCE_TYPE_TELEMETRY, RawSource::TelemGroup, -firmware->getCapability(Sensors) * 3);
|
|
addItems(SOURCE_TYPE_TIMER, RawSource::TelemGroup, -firmware->getCapability(Timers));
|
|
addItems(SOURCE_TYPE_SPECIAL, RawSource::TelemGroup, -(SOURCE_TYPE_SPECIAL_COUNT - 1));
|
|
addItems(SOURCE_TYPE_GVAR, RawSource::GVarsGroup, -firmware->getCapability(Gvars));
|
|
addItems(SOURCE_TYPE_CH, RawSource::SourcesGroup, -firmware->getCapability(Outputs));
|
|
addItems(SOURCE_TYPE_PPM, RawSource::SourcesGroup, -firmware->getCapability(TrainerInputs));
|
|
addItems(SOURCE_TYPE_CYC, RawSource::SourcesGroup, -CPN_MAX_CYC);
|
|
addItems(SOURCE_TYPE_CUSTOM_SWITCH, RawSource::SwitchesGroup, -firmware->getCapability(LogicalSwitches));
|
|
if (modelData && groups > 0)
|
|
addItems(SOURCE_TYPE_FUNCTIONSWITCH_GROUP, RawSource::SourcesGroup, -groups);
|
|
addItems(SOURCE_TYPE_SWITCH, RawSource::SwitchesGroup, -board->getCapability(Board::Switches));
|
|
addItems(SOURCE_TYPE_MAX, RawSource::SourcesGroup, -1);
|
|
addItems(SOURCE_TYPE_MIN, RawSource::SourcesGroup, -1);
|
|
addItems(SOURCE_TYPE_SPACEMOUSE, RawSource::SourcesGroup, -CPN_MAX_SPACEMOUSE);
|
|
addItems(SOURCE_TYPE_TRIM, RawSource::TrimsGroup, -board->getCapability(Board::NumTrims));
|
|
addItems(SOURCE_TYPE_INPUT, RawSource::SourcesGroup, -board->getCapability(Board::Inputs));
|
|
addItems(SOURCE_TYPE_VIRTUAL_INPUT, RawSource::InputsGroup, -firmware->getCapability(VirtualInputs));
|
|
for (int i = firmware->getCapability(LuaScripts) - 1; i >= 0; i--)
|
|
addItems(SOURCE_TYPE_LUA_OUTPUT, RawSource::ScriptsGroup, -firmware->getCapability(LuaOutputsPerScript), -i * 16);
|
|
|
|
// Ascending source direction (including zero)
|
|
addItems(SOURCE_TYPE_NONE, RawSource::NoneGroup, 1);
|
|
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_INPUT, RawSource::SourcesGroup, board->getCapability(Board::Inputs));
|
|
addItems(SOURCE_TYPE_TRIM, RawSource::TrimsGroup, board->getCapability(Board::NumTrims));
|
|
addItems(SOURCE_TYPE_SPACEMOUSE, RawSource::SourcesGroup, CPN_MAX_SPACEMOUSE);
|
|
addItems(SOURCE_TYPE_MIN, RawSource::SourcesGroup, 1);
|
|
addItems(SOURCE_TYPE_MAX, RawSource::SourcesGroup, 1);
|
|
addItems(SOURCE_TYPE_SWITCH, RawSource::SwitchesGroup, board->getCapability(Board::Switches));
|
|
if (modelData && groups > 0)
|
|
addItems(SOURCE_TYPE_FUNCTIONSWITCH_GROUP, RawSource::SourcesGroup, groups);
|
|
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, firmware->getCapability(TrainerInputs));
|
|
addItems(SOURCE_TYPE_CH, RawSource::SourcesGroup, firmware->getCapability(Outputs));
|
|
addItems(SOURCE_TYPE_GVAR, RawSource::GVarsGroup, firmware->getCapability(Gvars));
|
|
addItems(SOURCE_TYPE_SPECIAL, RawSource::TelemGroup, SOURCE_TYPE_SPECIAL_COUNT - 1);
|
|
addItems(SOURCE_TYPE_TIMER, RawSource::TelemGroup, firmware->getCapability(Timers));
|
|
addItems(SOURCE_TYPE_TELEMETRY, RawSource::TelemGroup, firmware->getCapability(Sensors) * 3);
|
|
}
|
|
|
|
void RawSourceItemModel::setDynamicItemData(QStandardItem * item, const RawSource & src) const
|
|
{
|
|
item->setText(src.toString(modelData, generalSettings, boardType));
|
|
item->setData(src.isAvailable(modelData, generalSettings, boardType), IMDR_Available);
|
|
}
|
|
|
|
void RawSourceItemModel::addItems(const RawSourceType & type, const int group, int count, const int start)
|
|
{
|
|
const int idxAdj = (type == SOURCE_TYPE_NONE ? -1 : 0);
|
|
|
|
int first = start + count < 0 ? start + count : start + 1;
|
|
int last = start + count < 0 ? start : start + count + 1;
|
|
|
|
for (int i = first; i < last; ++i) {
|
|
const RawSource src = RawSource(type, i + idxAdj);
|
|
QStandardItem * modelItem = new QStandardItem();
|
|
modelItem->setData(src.toValue(), IMDR_Id);
|
|
modelItem->setData(type, IMDR_Type);
|
|
modelItem->setData((group | (i + idxAdj < 0 ? RawSource::NegativeGroup : i > 0 ? RawSource::PositiveGroup : 0)), IMDR_Flags);
|
|
setDynamicItemData(modelItem, src);
|
|
appendRow(modelItem);
|
|
}
|
|
}
|
|
|
|
void RawSourceItemModel::update(const int event)
|
|
{
|
|
if (doUpdate(event)) {
|
|
emit aboutToBeUpdated();
|
|
|
|
for (int i = 0; i < rowCount(); ++i)
|
|
setDynamicItemData(item(i), RawSource(item(i)->data(IMDR_Id).toInt()));
|
|
|
|
emit updateComplete();
|
|
}
|
|
}
|
|
|
|
//
|
|
// RawSwitchItemModel
|
|
//
|
|
|
|
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)
|
|
{
|
|
setId(IMID_RawSwitch);
|
|
setUpdateMask(IMUE_FlightModes | IMUE_LogicalSwitches | IMUE_TeleSensors | IMUE_FunctionSwitches);
|
|
|
|
// Descending switch direction: NOT (!) switches
|
|
addItems(SWITCH_TYPE_TRAINER, -1);
|
|
addItems(SWITCH_TYPE_ACT, -1);
|
|
addItems(SWITCH_TYPE_SENSOR, -firmware->getCapability(Sensors));
|
|
addItems(SWITCH_TYPE_TELEMETRY, -1);
|
|
addItems(SWITCH_TYPE_FLIGHT_MODE, -firmware->getCapability(FlightModes));
|
|
addItems(SWITCH_TYPE_VIRTUAL, -firmware->getCapability(LogicalSwitches));
|
|
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::SwitchesPositions));
|
|
|
|
// Ascending switch direction (including zero)
|
|
addItems(SWITCH_TYPE_NONE, 1);
|
|
addItems(SWITCH_TYPE_SWITCH, board->getCapability(Board::SwitchesPositions));
|
|
addItems(SWITCH_TYPE_MULTIPOS_POT, board->getCapability(Board::MultiposPots) * board->getCapability(Board::MultiposPotsPositions));
|
|
addItems(SWITCH_TYPE_TRIM, board->getCapability(Board::NumTrimSwitches));
|
|
addItems(SWITCH_TYPE_VIRTUAL, firmware->getCapability(LogicalSwitches));
|
|
addItems(SWITCH_TYPE_FLIGHT_MODE, firmware->getCapability(FlightModes));
|
|
addItems(SWITCH_TYPE_TELEMETRY, 1);
|
|
addItems(SWITCH_TYPE_SENSOR, firmware->getCapability(Sensors));
|
|
addItems(SWITCH_TYPE_ON, 1);
|
|
addItems(SWITCH_TYPE_ONE, 1);
|
|
addItems(SWITCH_TYPE_ACT, 1);
|
|
addItems(SWITCH_TYPE_TRAINER, 1);
|
|
}
|
|
|
|
void RawSwitchItemModel::setDynamicItemData(QStandardItem * item, const RawSwitch & rsw) const
|
|
{
|
|
item->setText(rsw.toString(boardType, generalSettings, modelData));
|
|
item->setData(rsw.isAvailable(modelData, generalSettings, boardType), IMDR_Available);
|
|
}
|
|
|
|
void RawSwitchItemModel::addItems(const RawSwitchType & type, int count)
|
|
{
|
|
// Most RawSwitch() indices are one-based (vs. typical zero); these are exceptions to the rule:
|
|
const static QVector<int> rawSwitchIndexBaseZeroTypes = QVector<int>() << SWITCH_TYPE_NONE << SWITCH_TYPE_ON << SWITCH_TYPE_OFF << SWITCH_TYPE_TIMER_MODE;
|
|
// handle exceptions in RawSwitch() index values
|
|
const short rawIdxAdj = rawSwitchIndexBaseZeroTypes.contains(type) ? -1 : 0;
|
|
|
|
// determine context flags
|
|
int context = RawSwitch::AllSwitchContexts;
|
|
switch (type) {
|
|
case SWITCH_TYPE_FLIGHT_MODE:
|
|
context &= ~RawSwitch::MixesContext;
|
|
// fallthrough
|
|
case SWITCH_TYPE_VIRTUAL:
|
|
case SWITCH_TYPE_SENSOR:
|
|
context &= ~RawSwitch::GlobalFunctionsContext;
|
|
break;
|
|
|
|
case SWITCH_TYPE_ON:
|
|
case SWITCH_TYPE_ONE:
|
|
context = RawSwitch::SpecialFunctionsContext | RawSwitch::GlobalFunctionsContext;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
int i = (count < 0 ? count : 1);
|
|
count = (i < 0 ? 0 : count + i);
|
|
for ( ; i < count; ++i) {
|
|
RawSwitch rs(type, i + rawIdxAdj);
|
|
QStandardItem * modelItem = new QStandardItem();
|
|
modelItem->setData(rs.toValue(), IMDR_Id);
|
|
modelItem->setData(type, IMDR_Type);
|
|
if (type == SWITCH_TYPE_SWITCH) {
|
|
if (Boards::isSwitchFunc(div(abs(rs.index) - 1, 3).quot, boardType))
|
|
context &= ~RawSwitch::GlobalFunctionsContext;
|
|
else
|
|
context |= RawSwitch::GlobalFunctionsContext;
|
|
}
|
|
modelItem->setData(context, IMDR_Flags);
|
|
setDynamicItemData(modelItem, rs);
|
|
appendRow(modelItem);
|
|
}
|
|
}
|
|
|
|
void RawSwitchItemModel::update(const int event)
|
|
{
|
|
if (doUpdate(event)) {
|
|
emit aboutToBeUpdated();
|
|
|
|
for (int i = 0; i < rowCount(); ++i)
|
|
setDynamicItemData(item(i), RawSwitch(item(i)->data(IMDR_Id).toInt()));
|
|
|
|
emit updateComplete();
|
|
}
|
|
}
|
|
|
|
//
|
|
// CurveItemModel
|
|
//
|
|
|
|
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(IMID_Curve);
|
|
|
|
if (!modelData)
|
|
return;
|
|
|
|
setUpdateMask(IMUE_Curves);
|
|
|
|
const int count = firmware->getCapability(NumCurves);
|
|
|
|
for (int i = -count ; i <= count; ++i) {
|
|
QStandardItem * modelItem = new QStandardItem();
|
|
modelItem->setData(i, IMDR_Id);
|
|
modelItem->setData(i < 0 ? IMDG_Negative : i > 0 ? IMDG_Positive : IMDG_None, IMDR_Flags);
|
|
setDynamicItemData(modelItem, i);
|
|
appendRow(modelItem);
|
|
}
|
|
}
|
|
|
|
void CurveItemModel::setDynamicItemData(QStandardItem * item, const int value) const
|
|
{
|
|
CurveReference cr = CurveReference(CurveReference::CURVE_REF_CUSTOM, value);
|
|
item->setText(cr.toString(modelData, false));
|
|
item->setData(cr.isAvailable(), IMDR_Available);
|
|
}
|
|
|
|
void CurveItemModel::update(const int event)
|
|
{
|
|
if (doUpdate(event)) {
|
|
emit aboutToBeUpdated();
|
|
|
|
for (int i = 0; i < rowCount(); ++i)
|
|
setDynamicItemData(item(i), item(i)->data(IMDR_Id).toInt());
|
|
|
|
emit updateComplete();
|
|
}
|
|
}
|
|
|
|
//
|
|
// GVarReferenceItemModel
|
|
//
|
|
|
|
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(IMID_GVarRef);
|
|
|
|
if (!modelData)
|
|
return;
|
|
|
|
setUpdateMask(IMUE_GVars | IMUE_FlightModes | IMUE_LogicalSwitches);
|
|
|
|
const int count = firmware->getCapability(Gvars);
|
|
|
|
if (count > 0) {
|
|
addItems(-count);
|
|
addItems(count);
|
|
}
|
|
}
|
|
|
|
void GVarReferenceItemModel::addItems(int count)
|
|
{
|
|
int i = (count < 0 ? count : 1);
|
|
count = (i < 0 ? 0 : count + i);
|
|
for ( ; i < count; ++i) {
|
|
QStandardItem * modelItem = new QStandardItem();
|
|
AdjustmentReference ar(AdjustmentReference::ADJUST_REF_GVAR, i);
|
|
modelItem->setData(ar.toValue(), IMDR_Id);
|
|
modelItem->setData(i < 0 ? IMDG_Negative : i > 0 ? IMDG_Positive : IMDG_None, IMDR_Flags);
|
|
setDynamicItemData(modelItem, ar);
|
|
appendRow(modelItem);
|
|
}
|
|
}
|
|
|
|
void GVarReferenceItemModel::setDynamicItemData(QStandardItem * item, const AdjustmentReference & ar) const
|
|
{
|
|
item->setText(ar.toString(modelData, false));
|
|
item->setData(ar.isAvailable(), IMDR_Available);
|
|
}
|
|
|
|
void GVarReferenceItemModel::update(const int event)
|
|
{
|
|
if (doUpdate(event)) {
|
|
emit aboutToBeUpdated();
|
|
|
|
for (int i = 0; i < rowCount(); ++i)
|
|
setDynamicItemData(item(i), AdjustmentReference(item(i)->data(IMDR_Id).toInt()));
|
|
|
|
emit updateComplete();
|
|
}
|
|
}
|
|
|
|
//
|
|
// ThrottleSourceItemModel
|
|
//
|
|
|
|
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(IMID_ThrSource);
|
|
|
|
if (!modelData)
|
|
return;
|
|
|
|
setUpdateMask(IMUE_Channels);
|
|
|
|
for (int i = 0; i < modelData->thrTraceSrcCount(); i++) {
|
|
QStandardItem * modelItem = new QStandardItem();
|
|
modelItem->setData(i, IMDR_Id);
|
|
setDynamicItemData(modelItem, i);
|
|
appendRow(modelItem);
|
|
}
|
|
}
|
|
|
|
void ThrottleSourceItemModel::setDynamicItemData(QStandardItem * item, const int value) const
|
|
{
|
|
item->setText(modelData->thrTraceSrcToString(generalSettings, value));
|
|
item->setData(modelData->isThrTraceSrcAvailable(generalSettings, value), IMDR_Available);
|
|
}
|
|
|
|
void ThrottleSourceItemModel::update(const int event)
|
|
{
|
|
if (doUpdate(event)) {
|
|
emit aboutToBeUpdated();
|
|
|
|
for (int i = 0; i < rowCount(); ++i)
|
|
setDynamicItemData(item(i), item(i)->data(IMDR_Id).toInt());
|
|
|
|
emit updateComplete();
|
|
}
|
|
}
|
|
|
|
//
|
|
// CustomFuncActionItemModel
|
|
//
|
|
|
|
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(IMID_CustomFuncAction);
|
|
setUpdateMask(IMUE_All &~ (IMUE_Curves | IMUE_Scripts));
|
|
|
|
for (int i = 0; i < AssignFunc::FuncCount; i++) {
|
|
QStandardItem * modelItem = new QStandardItem();
|
|
modelItem->setData(i, IMDR_Id);
|
|
modelItem->setData(CustomFunctionData::funcContext(i), IMDR_Flags);
|
|
setDynamicItemData(modelItem, i);
|
|
appendRow(modelItem);
|
|
}
|
|
|
|
sort(0);
|
|
}
|
|
|
|
void CustomFuncActionItemModel::setDynamicItemData(QStandardItem * item, const int value) const
|
|
{
|
|
item->setText(CustomFunctionData::funcToString((AssignFunc)value, modelData));
|
|
item->setData(CustomFunctionData::isFuncAvailable(value, modelData), IMDR_Available);
|
|
}
|
|
|
|
void CustomFuncActionItemModel::update(const int event)
|
|
{
|
|
if (doUpdate(event)) {
|
|
emit aboutToBeUpdated();
|
|
|
|
for (int i = 0; i < rowCount(); ++i)
|
|
setDynamicItemData(item(i), item(i)->data(IMDR_Id).toInt());
|
|
|
|
sort(0);
|
|
|
|
emit updateComplete();
|
|
}
|
|
}
|
|
|
|
//
|
|
// CustomFuncResetParamItemModel
|
|
//
|
|
|
|
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(IMID_CustomFuncResetParam);
|
|
setUpdateMask(IMUE_TeleSensors | IMUE_Timers);
|
|
|
|
for (int i = 0; i < CustomFunctionData::resetParamCount(); i++) {
|
|
QStandardItem * modelItem = new QStandardItem();
|
|
modelItem->setData(i, IMDR_Id);
|
|
setDynamicItemData(modelItem, i);
|
|
appendRow(modelItem);
|
|
}
|
|
}
|
|
|
|
void CustomFuncResetParamItemModel::setDynamicItemData(QStandardItem * item, const int value) const
|
|
{
|
|
item->setText(CustomFunctionData::resetToString(value, modelData));
|
|
item->setData(CustomFunctionData::isResetParamAvailable(value, modelData), IMDR_Available);
|
|
}
|
|
|
|
void CustomFuncResetParamItemModel::update(const int event)
|
|
{
|
|
if (doUpdate(event)) {
|
|
emit aboutToBeUpdated();
|
|
|
|
for (int i = 0; i < rowCount(); ++i)
|
|
setDynamicItemData(item(i), item(i)->data(IMDR_Id).toInt());
|
|
|
|
emit updateComplete();
|
|
}
|
|
}
|
|
|
|
//
|
|
// TelemetrySourceItemModel
|
|
//
|
|
|
|
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(IMID_TeleSource);
|
|
|
|
if (!modelData)
|
|
return;
|
|
|
|
setUpdateMask(IMUE_TeleSensors | IMUE_Modules);
|
|
const int count = firmware->getCapability(Sensors);
|
|
|
|
for (int i = -count; i <= count; ++i) {
|
|
QStandardItem * modelItem = new QStandardItem();
|
|
modelItem->setData(i, IMDR_Id);
|
|
setDynamicItemData(modelItem, i);
|
|
appendRow(modelItem);
|
|
}
|
|
}
|
|
|
|
void TelemetrySourceItemModel::setDynamicItemData(QStandardItem * item, const int value) const
|
|
{
|
|
item->setText(SensorData::sourceToString(modelData, value));
|
|
item->setData(SensorData::isSourceAvailable(modelData, value), IMDR_Available);
|
|
int flags = value < 0 ? SensorData::SensorTypeFlagNeg : value > 0 ? SensorData::SensorTypeFlagPos : SensorData::SensorTypeFlagNone;
|
|
if (value > 0 && SensorData::isSourceVario(modelData, value))
|
|
flags |= SensorData::SensorTypeFlagVario;
|
|
item->setData(flags, IMDR_Flags);
|
|
}
|
|
|
|
void TelemetrySourceItemModel::update(const int event)
|
|
{
|
|
if (doUpdate(event)) {
|
|
emit aboutToBeUpdated();
|
|
|
|
for (int i = 0; i < rowCount(); ++i) {
|
|
setDynamicItemData(item(i), item(i)->data(IMDR_Id).toInt());
|
|
}
|
|
|
|
emit updateComplete();
|
|
}
|
|
}
|
|
|
|
//
|
|
// 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(IMID_CurveRefType);
|
|
|
|
for (int i = 0; i <= CurveReference::MAX_CURVE_REF_TYPE; i++) {
|
|
QStandardItem * modelItem = new QStandardItem();
|
|
modelItem->setText(CurveReference::typeToString((CurveReference::CurveRefType)i));
|
|
modelItem->setData(i, IMDR_Id);
|
|
modelItem->setData(CurveReference::isTypeAvailable((CurveReference::CurveRefType)i), IMDR_Available);
|
|
appendRow(modelItem);
|
|
}
|
|
}
|
|
|
|
//
|
|
// 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(IMID_CurveRefFunc);
|
|
|
|
for (int i = 1; i <= CurveReference::functionCount(); i++) {
|
|
QStandardItem * modelItem = new QStandardItem();
|
|
modelItem->setText(CurveReference::functionToString(i));
|
|
modelItem->setData(i, IMDR_Id);
|
|
modelItem->setData(CurveReference::isFunctionAvailable(i), IMDR_Available);
|
|
appendRow(modelItem);
|
|
}
|
|
}
|
|
|
|
//
|
|
// PrecisionItemModel
|
|
//
|
|
|
|
PrecisionItemModel::PrecisionItemModel(const int minDecimals, const int maxDecimals, const QString suffix, const bool placeholders) :
|
|
AbstractStaticItemModel()
|
|
{
|
|
for (int i = minDecimals, j = maxDecimals; j >= 0; i++, j--) {
|
|
QString str = QString("0.%1").arg(QString(i, '0'));
|
|
if (placeholders)
|
|
str.append(QString(j, '_'));
|
|
if (!suffix.isEmpty())
|
|
str.append(QString(" %1").arg(suffix));
|
|
QStandardItem * modelItem = new QStandardItem();
|
|
modelItem->setText(str);
|
|
modelItem->setData(i, IMDR_Id);
|
|
modelItem->setData(true, IMDR_Available);
|
|
appendRow(modelItem);
|
|
}
|
|
}
|
|
|
|
//
|
|
// FlexSwitchesItemModel
|
|
//
|
|
|
|
FlexSwitchesItemModel::FlexSwitchesItemModel(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(IMID_FlexSwitches);
|
|
|
|
if (!generalSettings)
|
|
return;
|
|
|
|
setUpdateMask(IMUE_FunctionSwitches);
|
|
const int count = Boards::getCapability(boardType, Board::Inputs);
|
|
|
|
{
|
|
QStandardItem * modelItem = new QStandardItem();
|
|
modelItem->setData(-1, IMDR_Id);
|
|
modelItem->setText(tr("None"));
|
|
modelItem->setData(true, IMDR_Available);
|
|
appendRow(modelItem);
|
|
}
|
|
|
|
for (int i = 0; i < count; ++i) {
|
|
QStandardItem * modelItem = new QStandardItem();
|
|
modelItem->setData(i, IMDR_Id);
|
|
setDynamicItemData(modelItem, i);
|
|
appendRow(modelItem);
|
|
}
|
|
}
|
|
|
|
void FlexSwitchesItemModel::setDynamicItemData(QStandardItem * item, const int value) const
|
|
{
|
|
item->setText(Boards::getInputName(value, boardType));
|
|
item->setData(generalSettings->isInputFlexSwitchAvailable(value), IMDR_Available);
|
|
}
|
|
|
|
void FlexSwitchesItemModel::update(const int event)
|
|
{
|
|
if (doUpdate(event)) {
|
|
emit aboutToBeUpdated();
|
|
|
|
for (int i = 1; i < rowCount(); ++i) { // skip None
|
|
setDynamicItemData(item(i), item(i)->data(IMDR_Id).toInt());
|
|
}
|
|
|
|
emit updateComplete();
|
|
}
|
|
}
|
|
|
|
//
|
|
// ControlSourceItemModel
|
|
//
|
|
|
|
ControlSourceItemModel::ControlSourceItemModel(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(IMID_ControlSource);
|
|
setUpdateMask(IMUE_Hardware);
|
|
|
|
// Descending source direction: inverted (!) sources
|
|
addItems(SOURCE_TYPE_SWITCH, -board->getCapability(Board::Switches));
|
|
addItems(SOURCE_TYPE_INPUT, -board->getCapability(Board::Inputs), -board->getCapability(Board::Sticks));
|
|
|
|
// Ascending source direction (including zero)
|
|
addItems(SOURCE_TYPE_NONE, 1);
|
|
addItems(SOURCE_TYPE_INPUT, board->getCapability(Board::Inputs), board->getCapability(Board::Sticks));
|
|
addItems(SOURCE_TYPE_SWITCH, board->getCapability(Board::Switches));
|
|
}
|
|
|
|
void ControlSourceItemModel::setDynamicItemData(QStandardItem * item, const RawSource & src) const
|
|
{
|
|
item->setText(src.toString(modelData, generalSettings, boardType));
|
|
item->setData(src.isAvailable(modelData, generalSettings, boardType, RawSource::AVAILABLE_CONTROLSRC), IMDR_Available);
|
|
}
|
|
|
|
void ControlSourceItemModel::addItems(const RawSourceType & type, int count, const int start)
|
|
{
|
|
const int idxAdj = (type == SOURCE_TYPE_NONE ? -1 : 0);
|
|
|
|
int first = start + count < 0 ? start + count : start + 1;
|
|
int last = start + count < 0 ? start : start + count + 1;
|
|
|
|
for (int i = first; i < last; ++i) {
|
|
const RawSource src = RawSource(type, i + idxAdj);
|
|
QStandardItem * modelItem = new QStandardItem();
|
|
modelItem->setData(src.toValue(), IMDR_Id);
|
|
modelItem->setData(type, IMDR_Type);
|
|
setDynamicItemData(modelItem, src);
|
|
appendRow(modelItem);
|
|
}
|
|
}
|
|
|
|
void ControlSourceItemModel::update(const int event)
|
|
{
|
|
if (doUpdate(event)) {
|
|
emit aboutToBeUpdated();
|
|
|
|
for (int i = 0; i < rowCount(); ++i)
|
|
setDynamicItemData(item(i), RawSource(item(i)->data(IMDR_Id).toInt()));
|
|
|
|
emit updateComplete();
|
|
}
|
|
}
|
|
|
|
//
|
|
// CompoundItemModelFactory
|
|
//
|
|
|
|
CompoundItemModelFactory::CompoundItemModelFactory(const GeneralSettings * const generalSettings, const ModelData * const modelData) :
|
|
generalSettings(generalSettings),
|
|
modelData(modelData)
|
|
{
|
|
firmware = getCurrentFirmware();
|
|
board = new Boards(getCurrentBoard());
|
|
boardType = getCurrentBoard();
|
|
}
|
|
|
|
CompoundItemModelFactory::~CompoundItemModelFactory()
|
|
{
|
|
unregisterItemModels();
|
|
delete board;
|
|
}
|
|
|
|
void CompoundItemModelFactory::addItemModel(const int id)
|
|
{
|
|
switch (id) {
|
|
case AbstractItemModel::IMID_RawSource:
|
|
registerItemModel(new RawSourceItemModel(generalSettings, modelData, firmware, board, boardType));
|
|
break;
|
|
case AbstractItemModel::IMID_RawSwitch:
|
|
registerItemModel(new RawSwitchItemModel(generalSettings, modelData, firmware, board, boardType));
|
|
break;
|
|
case AbstractItemModel::IMID_Curve:
|
|
registerItemModel(new CurveItemModel(generalSettings, modelData, firmware, board, boardType));
|
|
break;
|
|
case AbstractItemModel::IMID_GVarRef:
|
|
registerItemModel(new GVarReferenceItemModel(generalSettings, modelData, firmware, board, boardType));
|
|
break;
|
|
case AbstractItemModel::IMID_ThrSource:
|
|
registerItemModel(new ThrottleSourceItemModel(generalSettings, modelData, firmware, board, boardType));
|
|
break;
|
|
case AbstractItemModel::IMID_CustomFuncAction:
|
|
registerItemModel(new CustomFuncActionItemModel(generalSettings, modelData, firmware, board, boardType));
|
|
break;
|
|
case AbstractItemModel::IMID_CustomFuncResetParam:
|
|
registerItemModel(new CustomFuncResetParamItemModel(generalSettings, modelData, firmware, board, boardType));
|
|
break;
|
|
case AbstractItemModel::IMID_TeleSource:
|
|
registerItemModel(new TelemetrySourceItemModel(generalSettings, modelData, firmware, board, boardType));
|
|
break;
|
|
case AbstractItemModel::IMID_CurveRefType:
|
|
registerItemModel(new CurveRefTypeItemModel(generalSettings, modelData, firmware, board, boardType));
|
|
break;
|
|
case AbstractItemModel::IMID_CurveRefFunc:
|
|
registerItemModel(new CurveRefFuncItemModel(generalSettings, modelData, firmware, board, boardType));
|
|
break;
|
|
case AbstractItemModel::IMID_FlexSwitches:
|
|
registerItemModel(new FlexSwitchesItemModel(generalSettings, modelData, firmware, board, boardType));
|
|
break;
|
|
case AbstractItemModel::IMID_ControlSource:
|
|
registerItemModel(new ControlSourceItemModel(generalSettings, modelData, firmware, board, boardType));
|
|
break;
|
|
default:
|
|
qDebug() << "Error: unknown item model: id";
|
|
break;
|
|
}
|
|
}
|
|
|
|
int CompoundItemModelFactory::registerItemModel(AbstractItemModel * itemModel)
|
|
{
|
|
if (itemModel) {
|
|
if (!isItemModelRegistered(itemModel->getId())) {
|
|
setSourceId(itemModel);
|
|
registeredItemModels.append(itemModel);
|
|
return itemModel->getId();
|
|
}
|
|
else
|
|
return itemModel->getId();
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void CompoundItemModelFactory::unregisterItemModels()
|
|
{
|
|
foreach (AbstractItemModel *itemModel, registeredItemModels) {
|
|
delete itemModel;
|
|
}
|
|
}
|
|
|
|
void CompoundItemModelFactory::unregisterItemModel(const int id)
|
|
{
|
|
AbstractItemModel * itemModel = getItemModel(id);
|
|
if (itemModel)
|
|
delete itemModel;
|
|
}
|
|
|
|
AbstractItemModel * CompoundItemModelFactory::getItemModel(const int id) const
|
|
{
|
|
foreach (AbstractItemModel * itemModel, registeredItemModels) {
|
|
if (itemModel->getId() == id)
|
|
return itemModel;
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
AbstractItemModel * CompoundItemModelFactory::getItemModel(const QString name) const
|
|
{
|
|
foreach (AbstractItemModel * itemModel, registeredItemModels) {
|
|
if (itemModel->getName() == name)
|
|
return itemModel;
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
bool CompoundItemModelFactory::isItemModelRegistered(const int id) const
|
|
{
|
|
foreach (AbstractItemModel * itemModel, registeredItemModels) {
|
|
if (itemModel->getId() == id)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void CompoundItemModelFactory::update(const int event)
|
|
{
|
|
foreach (AbstractItemModel * itemModel, registeredItemModels) {
|
|
itemModel->update(event);
|
|
}
|
|
}
|
|
|
|
void CompoundItemModelFactory::dumpAllItemModelContents() const
|
|
{
|
|
foreach (AbstractItemModel * itemModel, registeredItemModels) {
|
|
AbstractItemModel::dumpItemModelContents(itemModel);
|
|
}
|
|
}
|
|
|
|
void CompoundItemModelFactory::setSourceId(AbstractItemModel * itemModel)
|
|
{
|
|
if (itemModel && itemModel->getId() == AbstractItemModel::IMID_Unknown)
|
|
itemModel->setId(AbstractItemModel::IMID_ReservedCount + registeredItemModels.count());
|
|
}
|