Major refactoring

companion/src/datamodels/itemmodelfactory.cpp

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

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

@@ -24,35 +24,57 @@
 #include "modeldata.h"
 #include "adjustmentreference.h"
 
-RawSourceItemModel::RawSourceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent) :
+// static
-  AbstractRawItemDataModel(generalSettings, modelData, parent)
+void AbstractItemModel::dumpItemModelContents(AbstractItemModel * itemModel)
 {
-  const Boards board = Boards(getCurrentBoard());
+  if (itemModel) {
-  Firmware * fw = getCurrentFirmware();
+    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++)
+  for (int i = 0; i < firmware->getCapability(LuaScripts); i++)
-    addItems(SOURCE_TYPE_LUA_OUTPUT,   RawSource::ScriptsGroup,  fw->getCapability(LuaOutputsPerScript), i * 16);
+    addItems(SOURCE_TYPE_LUA_OUTPUT,   RawSource::ScriptsGroup,  firmware->getCapability(LuaOutputsPerScript), i * 16);
-  addItems(SOURCE_TYPE_VIRTUAL_INPUT,  RawSource::InputsGroup,   fw->getCapability(VirtualInputs));
+  addItems(SOURCE_TYPE_VIRTUAL_INPUT,  RawSource::InputsGroup,   firmware->getCapability(VirtualInputs));
-  addItems(SOURCE_TYPE_STICK,          RawSource::SourcesGroup,  board.getCapability(Board::MaxAnalogs));
+  addItems(SOURCE_TYPE_STICK,          RawSource::SourcesGroup,  board->getCapability(Board::MaxAnalogs));
-  addItems(SOURCE_TYPE_ROTARY_ENCODER, RawSource::SourcesGroup,  fw->getCapability(RotaryEncoders));
+  addItems(SOURCE_TYPE_ROTARY_ENCODER, RawSource::SourcesGroup,  firmware->getCapability(RotaryEncoders));
-  addItems(SOURCE_TYPE_TRIM,           RawSource::TrimsGroup,    board.getCapability(Board::NumTrims));
+  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_SWITCH,         RawSource::SwitchesGroup, board->getCapability(Board::Switches));
-  addItems(SOURCE_TYPE_CUSTOM_SWITCH,  RawSource::SwitchesGroup, fw->getCapability(LogicalSwitches));
+  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_PPM,            RawSource::SourcesGroup,  firmware->getCapability(TrainerInputs));
-  addItems(SOURCE_TYPE_CH,             RawSource::SourcesGroup,  fw->getCapability(Outputs));
+  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_TELEMETRY,      RawSource::TelemGroup,    firmware->getCapability(Sensors) * 3);
-  addItems(SOURCE_TYPE_GVAR,           RawSource::GVarsGroup,    fw->getCapability(Gvars));
+  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, boardType));
-  item->setText(src.toString(modelData, generalSettings, board));
+  item->setData(src.isAvailable(modelData, generalSettings, boardType), IsAvailableRole);
-  item->setData(src.isAvailable(modelData, generalSettings, board), 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)
+    for (int i = 0; i < rowCount(); ++i)
-    setDynamicItemData(item(i), RawSource(item(i)->data(ItemIdRole).toInt()));
+      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) :
+RawSwitchItemModel::RawSwitchItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
-  AbstractRawItemDataModel(generalSettings, modelData, parent)
+                                       Firmware * firmware, const Boards * const board, const Board::Type boardType) :
+    AbstractDynamicItemModel(generalSettings, modelData, firmware, board, boardType)
 {
-  Boards board = Boards(getCurrentBoard());
+  setId(RawSwitchId);
-  Firmware * fw = getCurrentFirmware();
+  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_FLIGHT_MODE,    -firmware->getCapability(FlightModes));
-  addItems(SWITCH_TYPE_VIRTUAL,        -fw->getCapability(LogicalSwitches));
+  addItems(SWITCH_TYPE_VIRTUAL,        -firmware->getCapability(LogicalSwitches));
-  addItems(SWITCH_TYPE_ROTARY_ENCODER, -fw->getCapability(RotaryEncoders));
+  addItems(SWITCH_TYPE_ROTARY_ENCODER, -firmware->getCapability(RotaryEncoders));
-  addItems(SWITCH_TYPE_TRIM,           -board.getCapability(Board::NumTrimSwitches));
+  addItems(SWITCH_TYPE_TRIM,           -board->getCapability(Board::NumTrimSwitches));
-  addItems(SWITCH_TYPE_MULTIPOS_POT,   -(board.getCapability(Board::MultiposPots) * board.getCapability(Board::MultiposPotsPositions)));
+  addItems(SWITCH_TYPE_MULTIPOS_POT,   -(board->getCapability(Board::MultiposPots) * board->getCapability(Board::MultiposPotsPositions)));
-  addItems(SWITCH_TYPE_SWITCH,         -board.getCapability(Board::SwitchPositions));
+  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_SWITCH,         board->getCapability(Board::SwitchPositions));
-  addItems(SWITCH_TYPE_MULTIPOS_POT,   board.getCapability(Board::MultiposPots) * board.getCapability(Board::MultiposPotsPositions));
+  addItems(SWITCH_TYPE_MULTIPOS_POT,   board->getCapability(Board::MultiposPots) * board->getCapability(Board::MultiposPotsPositions));
-  addItems(SWITCH_TYPE_TRIM,           board.getCapability(Board::NumTrimSwitches));
+  addItems(SWITCH_TYPE_TRIM,           board->getCapability(Board::NumTrimSwitches));
-  addItems(SWITCH_TYPE_ROTARY_ENCODER, fw->getCapability(RotaryEncoders));
+  addItems(SWITCH_TYPE_ROTARY_ENCODER, firmware->getCapability(RotaryEncoders));
-  addItems(SWITCH_TYPE_VIRTUAL,        fw->getCapability(LogicalSwitches));
+  addItems(SWITCH_TYPE_VIRTUAL,        firmware->getCapability(LogicalSwitches));
-  addItems(SWITCH_TYPE_FLIGHT_MODE,    fw->getCapability(FlightModes));
+  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(boardType, generalSettings, modelData));
-  item->setText(rsw.toString(board, generalSettings, modelData));
+  item->setData(rsw.isAvailable(modelData, generalSettings, boardType), IsAvailableRole);
-  item->setData(rsw.isAvailable(modelData, generalSettings, board), 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)
+    for (int i = 0; i < rowCount(); ++i)
-    setDynamicItemData(item(i), RawSwitch(item(i)->data(ItemIdRole).toInt()));
+      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) :
+CurveItemModel::CurveItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
-  AbstractRawItemDataModel(generalSettings, modelData, parent)
+                               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)
+    for (int i = 0; i < rowCount(); ++i)
-   setDynamicItemData(item(i), item(i)->data(ItemIdRole).toInt());
+     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) :
+GVarReferenceItemModel::GVarReferenceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
-  AbstractRawItemDataModel(generalSettings, modelData, parent)
+                                               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)
+    for (int i = 0; i < rowCount(); ++i)
-   setDynamicItemData(item(i), AdjustmentReference(item(i)->data(ItemIdRole).toInt()));
+     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) :
+ThrottleSourceItemModel::ThrottleSourceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
-  AbstractRawItemDataModel(generalSettings, modelData, parent)
+                                                 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->setText(modelData->thrTraceSrcToString(value));
-  item->setData(modelData->isThrTraceSrcAvailable(generalSettings, index), IsAvailableRole);
+  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)
+    for (int i = 0; i < rowCount(); ++i)
-    setDynamicItemData(item(i), item(i)->data(ItemIdRole).toInt());
+      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) :
+CustomFuncActionItemModel::CustomFuncActionItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
-  AbstractRawItemDataModel(generalSettings, modelData, parent)
+                                                     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->setText(CustomFunctionData(AssignFunc(value)).funcToString(modelData));
-  item->setData(CustomFunctionData::isFuncAvailable(index), IsAvailableRole);
+  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)
+    for (int i = 0; i < rowCount(); ++i)
-    setDynamicItemData(item(i), item(i)->data(ItemIdRole).toInt());
+      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) :
+CustomFuncResetParamItemModel::CustomFuncResetParamItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
-  AbstractRawItemDataModel(generalSettings, modelData, parent)
+                                                             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)
+    for (int i = 0; i < rowCount(); ++i)
-    setDynamicItemData(item(i), item(i)->data(ItemIdRole).toInt());
+      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) :
+TelemetrySourceItemModel::TelemetrySourceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
-  AbstractRawItemDataModel(generalSettings, modelData, parent)
+                                                   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->setText(SensorData::sourceToString(modelData, value));
-  item->setData(SensorData::isSourceAvailable(modelData, index), IsAvailableRole);
+  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)
+    for (int i = 0; i < rowCount(); ++i) {
-   setDynamicItemData(item(i), item(i)->data(ItemIdRole).toInt());
+      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();
     }
+
+    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

@@ -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) :
+    enum ItemModelId {
-      QStandardItemModel(parent)
+      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
+    enum UpdateTrigger {
-{
+      SystemRefresh           = 1 << 0,
-    Q_OBJECT
+      ChannelsUpdated         = 1 << 1,
-  public:
+      CurvesUpdated           = 1 << 2,
-    explicit AbstractRawItemDataModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent = nullptr)  :
+      FlightModesUpdated      = 1 << 3,
-      AbstractStandardItemModel(parent),
+      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 ~AbstractItemModel() {};
-    virtual void update() = 0;
 
-  signals:
+    void setId(ItemModelId id) { m_id = id; }
-    void dataAboutToBeUpdated();
+    ItemModelId getId () const { return m_id; }
-    void dataUpdateComplete();
+
+    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 AbstractStaticItemModel: public AbstractItemModel
-class RawSourceItemModel: public AbstractRawItemDataModel
 {
     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 AbstractDynamicItemModel
-class RawSwitchItemModel: public AbstractRawItemDataModel
 {
     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 AbstractDynamicItemModel
-class CurveItemModel: public AbstractRawItemDataModel
 {
     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 AbstractDynamicItemModel
-class GVarReferenceItemModel: public AbstractRawItemDataModel
 {
     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 AbstractDynamicItemModel
-class ThrottleSourceItemModel: public AbstractRawItemDataModel
 {
     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 AbstractDynamicItemModel
-class CustomFuncActionItemModel: public AbstractRawItemDataModel
 {
     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 AbstractDynamicItemModel
-class CustomFuncResetParamItemModel: public AbstractRawItemDataModel
 {
     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 AbstractDynamicItemModel
-class TelemetrySourceItemModel: public AbstractRawItemDataModel
 {
     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 CurveRefTypeItemModel : public AbstractStaticItemModel
-class CommonItemModels: public QObject
 {
     Q_OBJECT
   public:
-    enum RadioModelObjects {
+    explicit CurveRefTypeItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
-      RMO_CHANNELS,
+                                   Firmware * firmware, const Boards * const board, const Board::Type boardType);
-      RMO_CURVES,
+    virtual ~CurveRefTypeItemModel() {};
-      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;
 };
 
-void dumpModelContents(QString desc, AbstractRawItemDataModel * dataModel);
+class CurveRefFuncItemModel : public AbstractStaticItemModel
-
-
-class CurveRefTypeItemModel : public AbstractStandardItemModel
 {
     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

@@ -20,24 +20,24 @@
 
 #include "rawitemfilteredmodel.h"
 
-RawItemFilteredModel::RawItemFilteredModel(QAbstractItemModel * sourceModel, int flags, QObject * parent) :
+FilteredItemModel::FilteredItemModel(AbstractItemModel * sourceModel, int flags) :
-  QSortFilterProxyModel(parent),
+  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, &AbstractDynamicItemModel::aboutToBeUpdated, this, &FilteredItemModel::onAboutToBeUpdated);
-    connect(itemModel, &AbstractRawItemDataModel::dataUpdateComplete, this, &RawItemFilteredModel::onDataUpdateComplete);
+    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

@@ -23,41 +23,90 @@
 
 #include "rawitemdatamodels.h"
 
+#include <QObject>
 #include <QSortFilterProxyModel>
+#include <QString>
 
-class GeneralSettings;
+class FilteredItemModel: public QSortFilterProxyModel
-class ModelData;
-
-class RawItemFilteredModel: public QSortFilterProxyModel
 {
     Q_OBJECT
   public:
     enum DataFilters {
-      AllFilter = AbstractRawItemDataModel::NegativeGroup | AbstractRawItemDataModel::NoneGroup | AbstractRawItemDataModel::PositiveGroup,
+      AllFilter = AbstractItemModel::NegativeGroup | AbstractItemModel::NoneGroup | AbstractItemModel::PositiveGroup,
-      AllExcludeNoneFilter = AllFilter &~ AbstractRawItemDataModel::NoneGroup,
+      AllExcludeNoneFilter = AllFilter &~ AbstractItemModel::NoneGroup,
-      NegativeFilter = AbstractRawItemDataModel::NegativeGroup | AbstractRawItemDataModel::NoneGroup,
+      NegativeFilter = AbstractItemModel::NegativeGroup | AbstractItemModel::NoneGroup,
-      NegativeExcludeNoneFilter = AbstractRawItemDataModel::NegativeGroup,
+      NegativeExcludeNoneFilter = AbstractItemModel::NegativeGroup,
-      PositiveFilter = AbstractRawItemDataModel::PositiveGroup | AbstractRawItemDataModel::NoneGroup,
+      PositiveFilter = AbstractItemModel::PositiveGroup | AbstractItemModel::NoneGroup,
-      PositiveExcludeNoneFilter = AbstractRawItemDataModel::PositiveGroup
+      PositiveExcludeNoneFilter = AbstractItemModel::PositiveGroup
     };
     Q_ENUM(DataFilters)
 
-    explicit RawItemFilteredModel(QAbstractItemModel * sourceModel, int flags, QObject * parent = nullptr);
+    explicit FilteredItemModel(AbstractItemModel * sourceModel, int flags);
-    explicit RawItemFilteredModel(QAbstractItemModel * sourceModel, QObject * parent = nullptr) : RawItemFilteredModel(sourceModel, 0, parent) {}
+    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 onAboutToBeUpdated();
-    void onDataUpdateComplete();
+    void onUpdateComplete();
 
   signals:
-    void dataAboutToBeUpdated();
+    void aboutToBeUpdated();
-    void dataUpdateComplete();
+    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

@@ -144,37 +144,41 @@ int CurveReference::functionCount()
  * CurveReferenceUIManager
 */
 
-CurveReferenceUIManager::CurveReferenceUIManager(QComboBox * curveValueCB, CurveReference & curve, const ModelData & model,
+CurveReferenceUIManager::CurveReferenceUIManager(QComboBox * curveValueCB, CurveReference & curveRef, const ModelData & model,
-                                                 RawItemFilteredModel * curveItemModel, RawItemFilteredModel * gvarItemModel,
+                                                 FilteredItemModel * curveItemModel, FilteredItemModel * gvarItemModel,
-                                                 QObject * parent) :
+                                                 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,
+                                                 QComboBox * curveValueCB, CurveReference & curveRef, const ModelData & model,
-                                                 RawItemFilteredModel * curveItemModel, RawItemFilteredModel * gvarItemModel,
+                                                 FilteredItemModel * curveItemModel, FilteredItemModel * gvarItemModel,
-                                                 QObject * parent) :
+                                                 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

@@ -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,
+                            CurveReference & curve, const ModelData & model, FilteredItemModel * curveItemModel,
-                            RawItemFilteredModel * gvarItemModel, QObject * parent = nullptr);
+                            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;
+    FilteredItemModel * curveItemModel;
-    RawItemFilteredModel * gvarItemModel;
+    FilteredItemModel * gvarItemModel;
-    RawItemFilteredModel * typeItemModel;
+    FilteredItemModel * typeItemModel;
-    RawItemFilteredModel * funcItemModel;
+    FilteredItemModel * funcItemModel;
 
-    void populateValueCB(QComboBox * cb);
-
-  private:
     void init(QObject * parent);
+    void populateValueCB(QComboBox * cb);
 };
 
 #endif // CURVEREFERENCE_H

companion/src/generaledit/generaledit.cpp

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

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

@@ -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);
+  FILTEREDITEMMODELNOFLAGS(curveFilteredModel, ChannelsPanel, CurveId)
-  connect(curveFilteredModel, &RawItemFilteredModel::dataAboutToBeUpdated, this, &ChannelsPanel::onModelDataAboutToBeUpdated);
-  connect(curveFilteredModel, &RawItemFilteredModel::dataUpdateComplete, this, &ChannelsPanel::onModelDataUpdateComplete);
 
   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

@@ -26,8 +26,8 @@
 
 #include <QtCore>
 
-class CommonItemModels;
+class ItemModelsFactory;
-class RawItemFilteredModel;
+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(QWidget * parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, ItemModelsFactory * sharedItemModels);
-    ~ChannelsPanel();
+    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 onItemModelAboutToBeUpdated();
-    void onModelDataUpdateComplete();
+    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;
+    ItemModelsFactory *sharedItemModels;
-    RawItemFilteredModel *curveFilteredModel;
+    FilteredItemModel *curveFilteredModel;
     void updateItemModels();
 };
 

companion/src/modeledit/curves.cpp

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

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

@@ -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);
+  FILTEREDITEMMODEL(rawSwitchFilteredModel, CustomFunctionsPanel, RawSwitchId, model ? RawSwitch::SpecialFunctionsContext : RawSwitch::GlobalFunctionsContext)
-  connect(rawSwitchFilteredModel, &RawItemFilteredModel::dataAboutToBeUpdated, this, &CustomFunctionsPanel::onModelDataAboutToBeUpdated);
+  FILTEREDITEMMODELNOFLAGS(rawSourceAllModel, CustomFunctionsPanel, RawSourceId)
-  connect(rawSwitchFilteredModel, &RawItemFilteredModel::dataUpdateComplete, this, &CustomFunctionsPanel::onModelDataUpdateComplete);
+  FILTEREDITEMMODEL(rawSourceInputsModel, CustomFunctionsPanel, RawSourceId, RawSource::InputSourceGroups)
-
+  FILTEREDITEMMODEL(rawSourceGVarsModel, CustomFunctionsPanel, RawSourceId, RawSource::GVarsGroup)
-  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);
 
   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

@@ -26,8 +26,8 @@
 
 #include <QMediaPlayer>
 
-class CommonItemModels;
+class ItemModelsFactory;
-class RawItemFilteredModel;
+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(QWidget *parent, ModelData * model, GeneralSettings & generalSettings, Firmware * firmware, ItemModelsFactory * sharedItemModels);
-    ~CustomFunctionsPanel();
+    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 onItemModelAboutToBeUpdated();
-    void onModelDataUpdateComplete();
+    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;
+    FilteredItemModel * rawSwitchFilteredModel;
-    RawItemFilteredModel * rawSwitchFilteredModel;
+    FilteredItemModel * rawSourceAllModel;
-    RawItemFilteredModel * rawSourceAllModel;
+    FilteredItemModel * rawSourceInputsModel;
-    RawItemFilteredModel * rawSourceInputsModel;
+    FilteredItemModel * rawSourceGVarsModel;
-    RawItemFilteredModel * rawSourceGVarsModel;
 
     QSet<QString> tracksSet;
     QSet<QString> scriptsSet;

companion/src/modeledit/expodialog.cpp

@@ -24,8 +24,9 @@
 #include "helpers.h"
 
 ExpoDialog::ExpoDialog(QWidget *parent, ModelData & model, ExpoData *expoData, GeneralSettings & generalSettings,
-                          Firmware * firmware, QString & inputName, RawItemFilteredModel * rawSourceModel,
+                       Firmware * firmware, QString & inputName, FilteredItemModel * rawSourceFilteredModel,
-                          RawItemFilteredModel * rawSwitchModel, RawItemFilteredModel * curveItemModel, RawItemFilteredModel * gvarItemModel) :
+                       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,
+  curveGroup = new CurveReferenceUIManager(ui->curveTypeCB, ui->curveGVarCB, ui->curveValueSB, ui->curveValueCB, ed->curve, model,
-                                           gvarItemModel, this);
+                                           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

@@ -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,
+                Firmware * firmware, QString & inputName, FilteredItemModel * rawSourceFilteredModel,
-                RawItemFilteredModel * rawSwitchItemModel, RawItemFilteredModel * curveItemModel, RawItemFilteredModel * gvarItemModel);
+                FilteredItemModel * rawSwitchFilteredModel, FilteredItemModel * curveFilteredModel, FilteredItemModel * gvarFilteredModel,
-    ~ExpoDialog();
+                FilteredItemModel * crTypeFilteredModel, FilteredItemModel * crFuncFilteredModel);
+    virtual ~ExpoDialog();
 
   protected:
     void updateScale();

companion/src/modeledit/flightmodes.cpp

@@ -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, &FilteredItemModel::aboutToBeUpdated, this, &FlightModePanel::onItemModelAboutToBeUpdated);
-  connect(rawSwitchFilteredModel, &RawItemFilteredModel::dataUpdateComplete, this, &FlightModePanel::onModelDataUpdateComplete);
+  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);
+  sharedItemModels->update(AbstractItemModel::FlightModesUpdated);
-  commonItemModels->update(CommonItemModels::RMO_GLOBAL_VARIABLES);
+  sharedItemModels->update(AbstractItemModel::GVarsUpdated);
 }
 
 void FlightModesPanel::onTabIndexChanged(int index)

companion/src/modeledit/flightmodes.h

@@ -24,8 +24,8 @@
 #include "modeledit.h"
 #include "eeprominterface.h"
 
-class CommonItemModels;
+class ItemModelsFactory;
-class RawItemFilteredModel;
+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 onItemModelAboutToBeUpdated();
-    void onModelDataUpdateComplete();
+    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;
+    ItemModelsFactory *sharedItemModels;
-    RawItemFilteredModel *rawSwitchFilteredModel;
+    FilteredItemModel *rawSwitchFilteredModel;
     QVector<GenericPanel *> panels;
     void updateItemModels();
 };

companion/src/modeledit/heli.cpp

@@ -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),
+  ui(new Ui::Heli)
-  commonItemModels(commonItemModels)
 {
   ui->setupUi(this);
 
-  rawSourceFilteredModel = new RawItemFilteredModel(commonItemModels->rawSourceItemModel(), RawSource::InputSourceGroups, this);
+  FILTEREDITEMMODEL(rawSourceFilteredModel, HeliPanel, RawSourceId, RawSource::InputSourceGroups)
-  connect(rawSourceFilteredModel, &RawItemFilteredModel::dataAboutToBeUpdated, this, &HeliPanel::onModelDataAboutToBeUpdated);
-  connect(rawSourceFilteredModel, &RawItemFilteredModel::dataUpdateComplete, this, &HeliPanel::onModelDataUpdateComplete);
 
   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

@@ -23,8 +23,8 @@
 
 #include "modeledit.h"
 
-class CommonItemModels;
+class ItemModelsFactory;
-class RawItemFilteredModel;
+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(QWidget *parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware, ItemModelsFactory * sharedItemModels);
-    ~HeliPanel();
+    virtual ~HeliPanel();
     void update();
 
   private slots:
     void edited();
-    void onModelDataAboutToBeUpdated();
+    void onItemModelAboutToBeUpdated();
-    void onModelDataUpdateComplete();
+    void onItemModelUpdateComplete();
 
   private:
     Ui::Heli *ui;
-    CommonItemModels * commonItemModels;
+    FilteredItemModel * rawSourceFilteredModel;
-    RawItemFilteredModel * rawSourceFilteredModel;
 };
 
 #endif // _HELI_H_

companion/src/modeledit/inputs.cpp

@@ -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);
+  FILTEREDITEMMODEL(rawSourceFilteredModel, InputsPanel, RawSourceId,(RawSource::InputSourceGroups & ~ RawSource::NoneGroup & ~RawSource::InputsGroup))
-  connect(rawSourceFilteredModel, &RawItemFilteredModel::dataAboutToBeUpdated, this, &InputsPanel::onModelDataAboutToBeUpdated);
+  FILTEREDITEMMODEL(rawSwitchFilteredModel, InputsPanel, RawSwitchId, RawSwitch::MixesContext)
-  connect(rawSourceFilteredModel, &RawItemFilteredModel::dataUpdateComplete, this, &InputsPanel::onModelDataUpdateComplete);
+  FILTEREDITEMMODEL(curveFilteredModel, InputsPanel, CurveId, firmware->getCapability(HasInputDiff) ? 0 : FilteredItemModel::PositiveFilter)
-
+  FILTEREDITEMMODELNOFLAGS(gvarFilteredModel, InputsPanel, GVarRefId)
-  rawSwitchFilteredModel = new RawItemFilteredModel(commonItemModels->rawSwitchItemModel(), RawSwitch::MixesContext, this);
+  FILTEREDITEMMODELNOFLAGS(crTypeFilteredModel, InputsPanel, CurveRefTypeId)
-  connect(rawSwitchFilteredModel, &RawItemFilteredModel::dataAboutToBeUpdated, this, &InputsPanel::onModelDataAboutToBeUpdated);
+  FILTEREDITEMMODELNOFLAGS(crFuncFilteredModel, InputsPanel, CurveRefFuncId)
-  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);
 
   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

@@ -25,8 +25,8 @@
 #include "mixerslistwidget.h"
 #include "modelprinter.h"
 
-class CommonItemModels;
+class ItemModelsFactory;
-class RawItemFilteredModel;
+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 onItemModelAboutToBeUpdated();
-    void onModelDataUpdateComplete();
+    void onItemModelUpdateComplete();
 
   private:
     bool expoInserted;
@@ -72,11 +72,13 @@ class InputsPanel : public ModelPanel
     ModelPrinter modelPrinter;
     int selectedIdx;
     int inputIdx;
-    CommonItemModels * commonItemModels;
+    ItemModelsFactory *sharedItemModels;
-    RawItemFilteredModel *rawSourceFilteredModel;
+    FilteredItemModel *rawSourceFilteredModel;
-    RawItemFilteredModel *rawSwitchFilteredModel;
+    FilteredItemModel *rawSwitchFilteredModel;
-    RawItemFilteredModel *curveFilteredModel;
+    FilteredItemModel *curveFilteredModel;
-    RawItemFilteredModel *gvarFilteredModel;
+    FilteredItemModel *gvarFilteredModel;
+    FilteredItemModel *crTypeFilteredModel;
+    FilteredItemModel *crFuncFilteredModel;
 
     int getExpoIndex(unsigned int dch);
     bool gm_insertExpo(int idx);

companion/src/modeledit/logicalswitches.cpp

@@ -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);
+  FILTEREDITEMMODEL(rawSwitchFilteredModel, LogicalSwitchesPanel, RawSwitchId, RawSwitch::LogicalSwitchesContext)
-  connect(rawSwitchFilteredModel, &RawItemFilteredModel::dataAboutToBeUpdated, this, &LogicalSwitchesPanel::onModelDataAboutToBeUpdated);
-  connect(rawSwitchFilteredModel, &RawItemFilteredModel::dataUpdateComplete, this, &LogicalSwitchesPanel::onModelDataUpdateComplete);
-
   const int srcGroups = firmware->getCapability(GvarsInCS) ? 0 : (RawSource::AllSourceGroups & ~RawSource::GVarsGroup);
-  rawSourceFilteredModel = new RawItemFilteredModel(commonItemModels->rawSourceItemModel(), srcGroups, this);
+  FILTEREDITEMMODEL(rawSourceFilteredModel, LogicalSwitchesPanel, RawSourceId, srcGroups)
-  connect(rawSourceFilteredModel, &RawItemFilteredModel::dataAboutToBeUpdated, this, &LogicalSwitchesPanel::onModelDataAboutToBeUpdated);
-  connect(rawSourceFilteredModel, &RawItemFilteredModel::dataUpdateComplete, this, &LogicalSwitchesPanel::onModelDataUpdateComplete);
 
   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

@@ -24,8 +24,8 @@
 #include "modeledit.h"
 #include "radiodata.h"
 
-class CommonItemModels;
+class ItemModelsFactory;
-class RawItemFilteredModel;
+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 onItemModelAboutToBeUpdated();
-    void onModelDataUpdateComplete();
+    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;
+    ItemModelsFactory * sharedItemModels;
-    RawItemFilteredModel * rawSwitchFilteredModel;
+    FilteredItemModel * rawSwitchFilteredModel;
-    RawItemFilteredModel * rawSourceFilteredModel;
+    FilteredItemModel * rawSourceFilteredModel;
     int selectedIndex;
     void populateFunctionCB(QComboBox *b);
     void updateTimerParam(QDoubleSpinBox *sb, int timer, double minimum=0);

companion/src/modeledit/mixerdialog.cpp

@@ -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,
+                         FilteredItemModel * rawSourceFilteredModel, FilteredItemModel * rawSwitchFilteredModel,
-                            RawItemFilteredModel * gvarItemModel) :
+                         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,
+  curveGroup = new CurveReferenceUIManager(ui->curveTypeCB, ui->curveGVarCB, ui->curveValueSB, ui->curveValueCB, md->curve, model,
-                                           gvarItemModel, this);
+                                           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

@@ -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,
+                FilteredItemModel * rawSourceFilteredModel, FilteredItemModel * rawSwitchFilteredModel, FilteredItemModel * curveFilteredModel,
-                  RawItemFilteredModel * gvarItemModel);
+                FilteredItemModel * gvarFilteredModel, FilteredItemModel * crTypeFilteredModel, FilteredItemModel * crFuncFilteredModel);
     ~MixerDialog();
 
   protected:

companion/src/modeledit/mixes.cpp

@@ -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);
+  FILTEREDITEMMODEL(rawSourceFilteredModel, MixesPanel, RawSourceId,((RawSource::InputSourceGroups | RawSource::ScriptsGroup) & ~ RawSource::NoneGroup))
-  connect(rawSourceFilteredModel, &RawItemFilteredModel::dataAboutToBeUpdated, this, &MixesPanel::onModelDataAboutToBeUpdated);
+  FILTEREDITEMMODEL(rawSwitchFilteredModel, MixesPanel, RawSwitchId, RawSwitch::MixesContext)
-  connect(rawSourceFilteredModel, &RawItemFilteredModel::dataUpdateComplete, this, &MixesPanel::onModelDataUpdateComplete);
+  FILTEREDITEMMODEL(curveFilteredModel, MixesPanel, CurveId, firmware->getCapability(HasMixerExpo) ? 0 : FilteredItemModel::PositiveFilter)
-
+  FILTEREDITEMMODELNOFLAGS(gvarFilteredModel, MixesPanel, GVarRefId)
-  rawSwitchFilteredModel = new RawItemFilteredModel(commonItemModels->rawSwitchItemModel(), RawSwitch::MixesContext, this);
+  FILTEREDITEMMODELNOFLAGS(crTypeFilteredModel, MixesPanel, CurveRefTypeId)
-  connect(rawSwitchFilteredModel, &RawItemFilteredModel::dataAboutToBeUpdated, this, &MixesPanel::onModelDataAboutToBeUpdated);
+  FILTEREDITEMMODELNOFLAGS(crFuncFilteredModel, MixesPanel, CurveRefFuncId)
-  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);
 
   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,
+  MixerDialog *dlg = new MixerDialog(this, *model, &mixd, generalSettings, firmware,  rawSourceFilteredModel, rawSwitchFilteredModel,
-                                     curveFilteredModel, gvarFilteredModel);
+                                     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

@@ -26,15 +26,15 @@
 #include "mixerdialog.h"
 #include "modelprinter.h"
 
-class CommonItemModels;
+class ItemModelsFactory;
-class RawItemFilteredModel;
+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 onItemModelAboutToBeUpdated();
-    void onModelDataUpdateComplete();
+    void onItemModelUpdateComplete();
 
   private:
     MixersListWidget * mixersListWidget;
     bool mixInserted;
     unsigned int highlightedSource;
     ModelPrinter modelPrinter;
-    CommonItemModels * commonItemModels;
+    ItemModelsFactory *sharedItemModels;
-    RawItemFilteredModel *rawSourceFilteredModel;
+    FilteredItemModel *rawSourceFilteredModel;
-    RawItemFilteredModel *rawSwitchFilteredModel;
+    FilteredItemModel *rawSwitchFilteredModel;
-    RawItemFilteredModel *curveFilteredModel;
+    FilteredItemModel *curveFilteredModel;
-    RawItemFilteredModel *gvarFilteredModel;
+    FilteredItemModel *gvarFilteredModel;
+    FilteredItemModel *crTypeFilteredModel;
+    FilteredItemModel *crFuncFilteredModel;
 
     int getMixerIndex(unsigned int dch);
     bool gm_insertMix(int idx);

companion/src/modeledit/modeledit.cpp

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

@@ -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;
+    RadioData &radioData;
-    Firmware * firmware;
+    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

@@ -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, &FilteredItemModel::aboutToBeUpdated, this, &TimerPanel::onItemModelAboutToBeUpdated);
-  connect(rawSwitchFilteredModel, &RawItemFilteredModel::dataUpdateComplete, this, &TimerPanel::onModelDataUpdateComplete);
+  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

@@ -26,8 +26,8 @@
 
 constexpr char MIMETYPE_TIMER[] = "application/x-companion-timer";
 
-class CommonItemModels;
+class ItemModelsFactory;
-class RawItemFilteredModel;
+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 onItemModelAboutToBeUpdated();
-    void onModelDataUpdateComplete();
+    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;
+    ItemModelsFactory * sharedItemModels;
-    RawItemFilteredModel * rawSwitchFilteredModel;
+    FilteredItemModel * rawSwitchFilteredModel;
+    FilteredItemModel * thrSourceFilteredModel;
     void updateItemModels();
   };
 

companion/src/modeledit/telemetry.cpp

@@ -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 = true;
-  lock = false;
+  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);
+    ui->source1->updateValue();
-    updateSourcesComboBox(ui->source2, true);
+    ui->source2->updateValue();
-    updateSourcesComboBox(ui->source3, true);
+    ui->source3->updateValue();
-    updateSourcesComboBox(ui->source4, true);
+    ui->source4->updateValue();
-    updateSourcesComboBox(ui->gpsSensor, false);
-    updateSourcesComboBox(ui->altSensor, false);
-    updateSourcesComboBox(ui->ampsSensor, false);
-    updateSourcesComboBox(ui->cellsSensor, false);
   }
   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);
+    ui->rssiSourceCB->updateValue();
-    populateTelemetrySourcesComboBox(ui->voltsSource, model, false);
+    ui->voltsSource->updateValue();
-    populateTelemetrySourcesComboBox(ui->altitudeSource, model, false);
+    ui->altitudeSource->updateValue();
-    populateTelemetrySourcesComboBox(ui->varioSource, model, false);
+    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();
+  if (!isLocked()) {
-  emit modified();
+    model->rssiAlarms.warning= ui->rssiAlarmWarningSB->value();
+    emit modified();
+  }
 }
 
 void TelemetryPanel::on_rssiAlarmCriticalSB_editingFinished()
 {
-  model->rssiAlarms.critical = ui->rssiAlarmCriticalSB->value();
+  if (!isLocked()) {
-  emit modified();
+    model->rssiAlarms.critical = ui->rssiAlarmCriticalSB->value();
+    emit modified();
+  }
 }
 
 void TelemetryPanel::on_varioLimitMin_DSB_editingFinished()
 {
-  model->frsky.varioMin = round(ui->varioLimitMin_DSB->value() + 10);
+  if (!isLocked()) {
-  emit modified();
+    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);
+  if (!isLocked()) {
-  emit modified();
+    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;
+  if (!isLocked()) {
-  emit modified();
+    model->frsky.fasOffset = ui->fasOffset_DSB->value() * 10;
+    emit modified();
+  }
 }
 
 void TelemetryPanel::on_mahCount_SB_editingFinished()
 {
-  model->frsky.storedMah = ui->mahCount_SB->value();
+  if (!isLocked()) {
-  emit modified();
+    model->frsky.storedMah = ui->mahCount_SB->value();
+    emit modified();
+  }
 }
 
 void TelemetryPanel::on_mahCount_ChkB_toggled(bool checked)
 {
-  model->frsky.mAhPersistent = checked;
+  if (!isLocked()) {
-  ui->mahCount_SB->setDisabled(!checked);
+    model->frsky.mAhPersistent = checked;
-  emit modified();
+    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();
+  on_dataModifiedSensor();
-  update();
-  emit modified();
 }
 
 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);
-
+  on_dataModifiedSensor();
-  updateItemModels();
-  update();
-  emit modified();
 }
 
 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);
-
+  on_dataModifiedSensor();
-  updateItemModels();
-  update();
-  emit modified();
 }
 
 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();
+    on_dataModifiedSensor();
-    update();
-    emit modified();
   }
 }
 
 void TelemetryPanel::on_dataModifiedSensor()
 {
-  updateItemModels();
+  sharedItemModels->update(AbstractItemModel::TeleSensorsUpdated);
-  update();
   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

@@ -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 onItemModelAboutToBeUpdated();
-    void onModelDataUpdateComplete();
+    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();
-
+    void onItemModelAboutToBeUpdated();
-  protected:
+    void onItemModelUpdateComplete();
-    void updateSourcesComboBox(AutoComboBox * cb, bool negative);
 
   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];
+    TelemetryCustomScreen *telemetryCustomScreens[4];
-    TelemetrySensorPanel * sensorPanels[CPN_MAX_SENSORS];
+    TelemetrySensorPanel *sensorPanels[CPN_MAX_SENSORS];
     int sensorCapability;
-    CommonItemModels * commonItemModels;
+    ItemModelsFactory *sharedItemModels;
-    RawItemFilteredModel * rawSourceFilteredModel;
+    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

@@ -37,30 +37,37 @@ class AutoComboBox: public QComboBox
 
     void clear()
     {
-      lock = true;
+      if (!hasModel) {
-      QComboBox::clear();
+        lock = true;
-      next = 0;
+        QComboBox::clear();
-      lock = false;
+        next = 0;
+        lock = false;
+      }
     }
 
     virtual void insertItems(int index, const QStringList & items)
     {
-      foreach(QString item, items) {
+      if (!hasModel) {
-        addItem(item);
+        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;
+      if (!hasModel) {
-      QComboBox::addItem(item, value);
+        lock = true;
-      lock = false;
+        QComboBox::addItem(item, value);
-      updateValue();
+        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)
+      if (!hasModel) {
-        setItemData(i, i);
+        for (int i = 0; i < count(); ++i)
-      updateValue();
+          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 (panel && panel->lock)
-      if (field && !lock) {
+        return;
-        *field = val;
+      if (index > -1) {
-        if (panel)
+        const int val = itemData(index).toInt();
-          emit panel->modified();
+        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_