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) :
-  AbstractRawItemDataModel(generalSettings, modelData, parent)
+// static
+void AbstractItemModel::dumpItemModelContents(AbstractItemModel * itemModel)
 {
-  const Boards board = Boards(getCurrentBoard());
-  Firmware * fw = getCurrentFirmware();
+  if (itemModel) {
+    qDebug() << "modelid:" << itemModel->getId();
+    for (int i = 0; i < itemModel->rowCount(); ++i) {
+      qDebug() << "row:"   << i
+               << "text:"  << itemModel->data(itemModel->index(i, 0), Qt::DisplayRole).toString()
+               << "id:"    << itemModel->data(itemModel->index(i, 0), AbstractItemModel::ItemIdRole).toInt()
+               << "avail:" << itemModel->data(itemModel->index(i, 0), AbstractItemModel::IsAvailableRole).toBool()
+               << "flags:" << itemModel->data(itemModel->index(i, 0), AbstractItemModel::ItemFlagsRole).toInt()
+               << "type:"  << itemModel->data(itemModel->index(i, 0), AbstractItemModel::ItemTypeRole).toInt();
+    }
+  }
+  else
+    qDebug() << "Error: model did not cast";
+}
+
+//
+// RawSourceItemModel
+//
+
+RawSourceItemModel::RawSourceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
+                                       Firmware * firmware, const Boards * const board, const Board::Type boardType) :
+  AbstractDynamicItemModel(generalSettings, modelData, firmware, board, boardType)
+{
+  setId(RawSourceId);
+  setUpdateMask(AllTriggers &~ (CurvesUpdated | ScriptsUpdated));
 
   addItems(SOURCE_TYPE_NONE,           RawSource::NoneGroup,     1);
-  for (int i = 0; i < fw->getCapability(LuaScripts); i++)
-    addItems(SOURCE_TYPE_LUA_OUTPUT,   RawSource::ScriptsGroup,  fw->getCapability(LuaOutputsPerScript), i * 16);
-  addItems(SOURCE_TYPE_VIRTUAL_INPUT,  RawSource::InputsGroup,   fw->getCapability(VirtualInputs));
-  addItems(SOURCE_TYPE_STICK,          RawSource::SourcesGroup,  board.getCapability(Board::MaxAnalogs));
-  addItems(SOURCE_TYPE_ROTARY_ENCODER, RawSource::SourcesGroup,  fw->getCapability(RotaryEncoders));
-  addItems(SOURCE_TYPE_TRIM,           RawSource::TrimsGroup,    board.getCapability(Board::NumTrims));
+  for (int i = 0; i < firmware->getCapability(LuaScripts); i++)
+    addItems(SOURCE_TYPE_LUA_OUTPUT,   RawSource::ScriptsGroup,  firmware->getCapability(LuaOutputsPerScript), i * 16);
+  addItems(SOURCE_TYPE_VIRTUAL_INPUT,  RawSource::InputsGroup,   firmware->getCapability(VirtualInputs));
+  addItems(SOURCE_TYPE_STICK,          RawSource::SourcesGroup,  board->getCapability(Board::MaxAnalogs));
+  addItems(SOURCE_TYPE_ROTARY_ENCODER, RawSource::SourcesGroup,  firmware->getCapability(RotaryEncoders));
+  addItems(SOURCE_TYPE_TRIM,           RawSource::TrimsGroup,    board->getCapability(Board::NumTrims));
   addItems(SOURCE_TYPE_MAX,            RawSource::SourcesGroup,  1);
-  addItems(SOURCE_TYPE_SWITCH,         RawSource::SwitchesGroup, board.getCapability(Board::Switches));
-  addItems(SOURCE_TYPE_CUSTOM_SWITCH,  RawSource::SwitchesGroup, fw->getCapability(LogicalSwitches));
+  addItems(SOURCE_TYPE_SWITCH,         RawSource::SwitchesGroup, board->getCapability(Board::Switches));
+  addItems(SOURCE_TYPE_CUSTOM_SWITCH,  RawSource::SwitchesGroup, firmware->getCapability(LogicalSwitches));
   addItems(SOURCE_TYPE_CYC,            RawSource::SourcesGroup,  CPN_MAX_CYC);
-  addItems(SOURCE_TYPE_PPM,            RawSource::SourcesGroup,  fw->getCapability(TrainerInputs));
-  addItems(SOURCE_TYPE_CH,             RawSource::SourcesGroup,  fw->getCapability(Outputs));
+  addItems(SOURCE_TYPE_PPM,            RawSource::SourcesGroup,  firmware->getCapability(TrainerInputs));
+  addItems(SOURCE_TYPE_CH,             RawSource::SourcesGroup,  firmware->getCapability(Outputs));
   addItems(SOURCE_TYPE_SPECIAL,        RawSource::TelemGroup,    5);
-  addItems(SOURCE_TYPE_TELEMETRY,      RawSource::TelemGroup,    fw->getCapability(Sensors) * 3);
-  addItems(SOURCE_TYPE_GVAR,           RawSource::GVarsGroup,    fw->getCapability(Gvars));
+  addItems(SOURCE_TYPE_TELEMETRY,      RawSource::TelemGroup,    firmware->getCapability(Sensors) * 3);
+  addItems(SOURCE_TYPE_GVAR,           RawSource::GVarsGroup,    firmware->getCapability(Gvars));
 }
 
 void RawSourceItemModel::setDynamicItemData(QStandardItem * item, const RawSource & src) const
 {
-  Board::Type board = getCurrentBoard();
-  item->setText(src.toString(modelData, generalSettings, board));
-  item->setData(src.isAvailable(modelData, generalSettings, board), IsAvailableRole);
+  item->setText(src.toString(modelData, generalSettings, boardType));
+  item->setData(src.isAvailable(modelData, generalSettings, boardType), IsAvailableRole);
 }
 
 void RawSourceItemModel::addItems(const RawSourceType & type, const int group, const int count, const int start)
@@ -68,49 +90,51 @@ void RawSourceItemModel::addItems(const RawSourceType & type, const int group, c
   }
 }
 
-void RawSourceItemModel::update()
+void RawSourceItemModel::update(const UpdateTrigger trigger)
 {
-  emit dataAboutToBeUpdated();
+  if (doUpdate(trigger)) {
+    emit aboutToBeUpdated();
 
-  for (int i = 0; i < rowCount(); ++i)
-    setDynamicItemData(item(i), RawSource(item(i)->data(ItemIdRole).toInt()));
+    for (int i = 0; i < rowCount(); ++i)
+      setDynamicItemData(item(i), RawSource(item(i)->data(ItemIdRole).toInt()));
 
-  emit dataUpdateComplete();
+    emit updateComplete();
+  }
 }
 
-
 //
 // RawSwitchItemModel
 //
 
-RawSwitchItemModel::RawSwitchItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent) :
-  AbstractRawItemDataModel(generalSettings, modelData, parent)
+RawSwitchItemModel::RawSwitchItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
+                                       Firmware * firmware, const Boards * const board, const Board::Type boardType) :
+    AbstractDynamicItemModel(generalSettings, modelData, firmware, board, boardType)
 {
-  Boards board = Boards(getCurrentBoard());
-  Firmware * fw = getCurrentFirmware();
+  setId(RawSwitchId);
+  setUpdateMask(FlightModesUpdated | LogicalSwitchesUpdated | TeleSensorsUpdated);
 
   // Descending switch direction: NOT (!) switches
   addItems(SWITCH_TYPE_ACT,            -1);
-  addItems(SWITCH_TYPE_SENSOR,         -fw->getCapability(Sensors));
+  addItems(SWITCH_TYPE_SENSOR,         -firmware->getCapability(Sensors));
   addItems(SWITCH_TYPE_TELEMETRY,      -1);
-  addItems(SWITCH_TYPE_FLIGHT_MODE,    -fw->getCapability(FlightModes));
-  addItems(SWITCH_TYPE_VIRTUAL,        -fw->getCapability(LogicalSwitches));
-  addItems(SWITCH_TYPE_ROTARY_ENCODER, -fw->getCapability(RotaryEncoders));
-  addItems(SWITCH_TYPE_TRIM,           -board.getCapability(Board::NumTrimSwitches));
-  addItems(SWITCH_TYPE_MULTIPOS_POT,   -(board.getCapability(Board::MultiposPots) * board.getCapability(Board::MultiposPotsPositions)));
-  addItems(SWITCH_TYPE_SWITCH,         -board.getCapability(Board::SwitchPositions));
+  addItems(SWITCH_TYPE_FLIGHT_MODE,    -firmware->getCapability(FlightModes));
+  addItems(SWITCH_TYPE_VIRTUAL,        -firmware->getCapability(LogicalSwitches));
+  addItems(SWITCH_TYPE_ROTARY_ENCODER, -firmware->getCapability(RotaryEncoders));
+  addItems(SWITCH_TYPE_TRIM,           -board->getCapability(Board::NumTrimSwitches));
+  addItems(SWITCH_TYPE_MULTIPOS_POT,   -(board->getCapability(Board::MultiposPots) * board->getCapability(Board::MultiposPotsPositions)));
+  addItems(SWITCH_TYPE_SWITCH,         -board->getCapability(Board::SwitchPositions));
 
   // Ascending switch direction (including zero)
   addItems(SWITCH_TYPE_TIMER_MODE, 5);
   addItems(SWITCH_TYPE_NONE, 1);
-  addItems(SWITCH_TYPE_SWITCH,         board.getCapability(Board::SwitchPositions));
-  addItems(SWITCH_TYPE_MULTIPOS_POT,   board.getCapability(Board::MultiposPots) * board.getCapability(Board::MultiposPotsPositions));
-  addItems(SWITCH_TYPE_TRIM,           board.getCapability(Board::NumTrimSwitches));
-  addItems(SWITCH_TYPE_ROTARY_ENCODER, fw->getCapability(RotaryEncoders));
-  addItems(SWITCH_TYPE_VIRTUAL,        fw->getCapability(LogicalSwitches));
-  addItems(SWITCH_TYPE_FLIGHT_MODE,    fw->getCapability(FlightModes));
+  addItems(SWITCH_TYPE_SWITCH,         board->getCapability(Board::SwitchPositions));
+  addItems(SWITCH_TYPE_MULTIPOS_POT,   board->getCapability(Board::MultiposPots) * board->getCapability(Board::MultiposPotsPositions));
+  addItems(SWITCH_TYPE_TRIM,           board->getCapability(Board::NumTrimSwitches));
+  addItems(SWITCH_TYPE_ROTARY_ENCODER, firmware->getCapability(RotaryEncoders));
+  addItems(SWITCH_TYPE_VIRTUAL,        firmware->getCapability(LogicalSwitches));
+  addItems(SWITCH_TYPE_FLIGHT_MODE,    firmware->getCapability(FlightModes));
   addItems(SWITCH_TYPE_TELEMETRY,      1);
-  addItems(SWITCH_TYPE_SENSOR,         fw->getCapability(Sensors));
+  addItems(SWITCH_TYPE_SENSOR,         firmware->getCapability(Sensors));
   addItems(SWITCH_TYPE_ON,             1);
   addItems(SWITCH_TYPE_ONE,            1);
   addItems(SWITCH_TYPE_ACT,            1);
@@ -118,9 +142,8 @@ RawSwitchItemModel::RawSwitchItemModel(const GeneralSettings * const generalSett
 
 void RawSwitchItemModel::setDynamicItemData(QStandardItem * item, const RawSwitch & rsw) const
 {
-  const Board::Type board = getCurrentBoard();
-  item->setText(rsw.toString(board, generalSettings, modelData));
-  item->setData(rsw.isAvailable(modelData, generalSettings, board), IsAvailableRole);
+  item->setText(rsw.toString(boardType, generalSettings, modelData));
+  item->setData(rsw.isAvailable(modelData, generalSettings, boardType), IsAvailableRole);
 }
 
 void RawSwitchItemModel::addItems(const RawSwitchType & type, int count)
@@ -171,27 +194,34 @@ void RawSwitchItemModel::addItems(const RawSwitchType & type, int count)
   }
 }
 
-void RawSwitchItemModel::update()
+void RawSwitchItemModel::update(const UpdateTrigger trigger)
 {
-  emit dataAboutToBeUpdated();
+  if (doUpdate(trigger)) {
+    emit aboutToBeUpdated();
 
-  for (int i = 0; i < rowCount(); ++i)
-    setDynamicItemData(item(i), RawSwitch(item(i)->data(ItemIdRole).toInt()));
+    for (int i = 0; i < rowCount(); ++i)
+      setDynamicItemData(item(i), RawSwitch(item(i)->data(ItemIdRole).toInt()));
 
-  emit dataUpdateComplete();
+    emit updateComplete();
+  }
 }
 
 //
 // CurveItemModel
 //
 
-CurveItemModel::CurveItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent) :
-  AbstractRawItemDataModel(generalSettings, modelData, parent)
+CurveItemModel::CurveItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
+                               Firmware * firmware, const Boards * const board, const Board::Type boardType) :
+    AbstractDynamicItemModel(generalSettings, modelData, firmware, board, boardType)
 {
+  setId(CurveId);
+
   if (!modelData)
     return;
 
-  const int count = getCurrentFirmware()->getCapability(NumCurves);
+  setUpdateMask(CurvesUpdated);
+
+  const int count = firmware->getCapability(NumCurves);
 
   for (int i = -count ; i <= count; ++i) {
     QStandardItem * modelItem = new QStandardItem();
@@ -205,35 +235,42 @@ CurveItemModel::CurveItemModel(const GeneralSettings * const generalSettings, co
   }
 }
 
-void CurveItemModel::setDynamicItemData(QStandardItem * item, const int index) const
+void CurveItemModel::setDynamicItemData(QStandardItem * item, const int value) const
 {
-  CurveReference cr = CurveReference(CurveReference::CURVE_REF_CUSTOM, index);
+  CurveReference cr = CurveReference(CurveReference::CURVE_REF_CUSTOM, value);
   item->setText(cr.toString(modelData, false));
   item->setData(cr.isAvailable(), IsAvailableRole);
 }
 
-void CurveItemModel::update()
+void CurveItemModel::update(const UpdateTrigger trigger)
 {
-  emit dataAboutToBeUpdated();
+  if (doUpdate(trigger)) {
+    emit aboutToBeUpdated();
 
-  for (int i = 0; i < rowCount(); ++i)
-   setDynamicItemData(item(i), item(i)->data(ItemIdRole).toInt());
+    for (int i = 0; i < rowCount(); ++i)
+     setDynamicItemData(item(i), item(i)->data(ItemIdRole).toInt());
 
-  emit dataUpdateComplete();
+    emit updateComplete();
+  }
 }
 
-
 //
 // GVarReferenceItemModel
 //
 
-GVarReferenceItemModel::GVarReferenceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent) :
-  AbstractRawItemDataModel(generalSettings, modelData, parent)
+GVarReferenceItemModel::GVarReferenceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
+                                               Firmware * firmware, const Boards * const board, const Board::Type boardType) :
+    AbstractDynamicItemModel(generalSettings, modelData, firmware, board, boardType)
 {
+  setId(GVarRefId);
+
   if (!modelData)
     return;
 
-  const int count = getCurrentFirmware()->getCapability(Gvars);
+  setUpdateMask(GVarsUpdated | FlightModesUpdated | LogicalSwitchesUpdated);
+
+  const int count = firmware->getCapability(Gvars);
+
   if (count > 0) {
     addItems(-count);
     addItems(count);
@@ -260,27 +297,33 @@ void GVarReferenceItemModel::setDynamicItemData(QStandardItem * item, const Adju
   item->setData(ar.isAvailable(), IsAvailableRole);
 }
 
-void GVarReferenceItemModel::update()
+void GVarReferenceItemModel::update(const UpdateTrigger trigger)
 {
-  emit dataAboutToBeUpdated();
+  if (doUpdate(trigger)) {
+    emit aboutToBeUpdated();
 
-  for (int i = 0; i < rowCount(); ++i)
-   setDynamicItemData(item(i), AdjustmentReference(item(i)->data(ItemIdRole).toInt()));
+    for (int i = 0; i < rowCount(); ++i)
+     setDynamicItemData(item(i), AdjustmentReference(item(i)->data(ItemIdRole).toInt()));
 
-  emit dataUpdateComplete();
+    emit updateComplete();
+  }
 }
 
-
 //
 // ThrottleSourceItemModel
 //
 
-ThrottleSourceItemModel::ThrottleSourceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent) :
-  AbstractRawItemDataModel(generalSettings, modelData, parent)
+ThrottleSourceItemModel::ThrottleSourceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
+                                                 Firmware * firmware, const Boards * const board, const Board::Type boardType) :
+    AbstractDynamicItemModel(generalSettings, modelData, firmware, board, boardType)
 {
+  setId(ThrSourceId);
+
   if (!modelData)
     return;
 
+  setUpdateMask(TimersUpdated | InputsUpdated | TeleSensorsUpdated);
+
   for (int i = 0; i < modelData->thrTraceSrcCount(); i++) {
     QStandardItem * modelItem = new QStandardItem();
     modelItem->setData(i, ItemIdRole);
@@ -289,30 +332,35 @@ ThrottleSourceItemModel::ThrottleSourceItemModel(const GeneralSettings * const g
   }
 }
 
-void ThrottleSourceItemModel::setDynamicItemData(QStandardItem * item, const int index) const
+void ThrottleSourceItemModel::setDynamicItemData(QStandardItem * item, const int value) const
 {
-  item->setText(modelData->thrTraceSrcToString(index));
-  item->setData(modelData->isThrTraceSrcAvailable(generalSettings, index), IsAvailableRole);
+  item->setText(modelData->thrTraceSrcToString(value));
+  item->setData(modelData->isThrTraceSrcAvailable(generalSettings, value), IsAvailableRole);
 }
 
-void ThrottleSourceItemModel::update()
+void ThrottleSourceItemModel::update(const UpdateTrigger trigger)
 {
-  emit dataAboutToBeUpdated();
+  if (doUpdate(trigger)) {
+    emit aboutToBeUpdated();
 
-  for (int i = 0; i < rowCount(); ++i)
-    setDynamicItemData(item(i), item(i)->data(ItemIdRole).toInt());
+    for (int i = 0; i < rowCount(); ++i)
+      setDynamicItemData(item(i), item(i)->data(ItemIdRole).toInt());
 
-  emit dataUpdateComplete();
+    emit updateComplete();
+  }
 }
 
-
 //
 // CustomFuncActionItemModel
 //
 
-CustomFuncActionItemModel::CustomFuncActionItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent) :
-  AbstractRawItemDataModel(generalSettings, modelData, parent)
+CustomFuncActionItemModel::CustomFuncActionItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
+                                                     Firmware * firmware, const Boards * const board, const Board::Type boardType) :
+    AbstractDynamicItemModel(generalSettings, modelData, firmware, board, boardType)
 {
+  setId(CustomFuncActionId);
+  setUpdateMask(AllTriggers &~ (CurvesUpdated | ScriptsUpdated));
+
   for (int i = 0; i < AssignFunc::FuncCount; i++) {
     QStandardItem * modelItem = new QStandardItem();
     modelItem->setData(i, ItemIdRole);
@@ -322,30 +370,35 @@ CustomFuncActionItemModel::CustomFuncActionItemModel(const GeneralSettings * con
   }
 }
 
-void CustomFuncActionItemModel::setDynamicItemData(QStandardItem * item, const int index) const
+void CustomFuncActionItemModel::setDynamicItemData(QStandardItem * item, const int value) const
 {
-  item->setText(CustomFunctionData(AssignFunc(index)).funcToString(modelData));
-  item->setData(CustomFunctionData::isFuncAvailable(index), IsAvailableRole);
+  item->setText(CustomFunctionData(AssignFunc(value)).funcToString(modelData));
+  item->setData(CustomFunctionData::isFuncAvailable(value), IsAvailableRole);
 }
 
-void CustomFuncActionItemModel::update()
+void CustomFuncActionItemModel::update(const UpdateTrigger trigger)
 {
-  emit dataAboutToBeUpdated();
+  if (doUpdate(trigger)) {
+    emit aboutToBeUpdated();
 
-  for (int i = 0; i < rowCount(); ++i)
-    setDynamicItemData(item(i), item(i)->data(ItemIdRole).toInt());
+    for (int i = 0; i < rowCount(); ++i)
+      setDynamicItemData(item(i), item(i)->data(ItemIdRole).toInt());
 
-  emit dataUpdateComplete();
+    emit updateComplete();
+  }
 }
 
-
 //
 // CustomFuncResetParamItemModel
 //
 
-CustomFuncResetParamItemModel::CustomFuncResetParamItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent) :
-  AbstractRawItemDataModel(generalSettings, modelData, parent)
+CustomFuncResetParamItemModel::CustomFuncResetParamItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
+                                                             Firmware * firmware, const Boards * const board, const Board::Type boardType) :
+    AbstractDynamicItemModel(generalSettings, modelData, firmware, board, boardType)
 {
+  setId(CustomFuncResetParamId);
+  setUpdateMask(TeleSensorsUpdated);
+
   for (int i = 0; i < CustomFunctionData::resetParamCount(modelData); i++) {
     QStandardItem * modelItem = new QStandardItem();
     modelItem->setData(i, ItemIdRole);
@@ -354,38 +407,43 @@ CustomFuncResetParamItemModel::CustomFuncResetParamItemModel(const GeneralSettin
   }
 }
 
-void CustomFuncResetParamItemModel::setDynamicItemData(QStandardItem * item, const int index) const
+void CustomFuncResetParamItemModel::setDynamicItemData(QStandardItem * item, const int value) const
 {
   CustomFunctionData cfd = CustomFunctionData(AssignFunc::FuncReset);
-  cfd.param = index;
+  cfd.param = value;
   item->setText(cfd.paramToString(modelData));
-  item->setData(CustomFunctionData::isResetParamAvailable(modelData, index), IsAvailableRole);
+  item->setData(CustomFunctionData::isResetParamAvailable(modelData, value), IsAvailableRole);
 }
 
-void CustomFuncResetParamItemModel::update()
+void CustomFuncResetParamItemModel::update(const UpdateTrigger trigger)
 {
-  emit dataAboutToBeUpdated();
+  if (doUpdate(trigger)) {
+    emit aboutToBeUpdated();
 
-  for (int i = 0; i < rowCount(); ++i)
-    setDynamicItemData(item(i), item(i)->data(ItemIdRole).toInt());
+    for (int i = 0; i < rowCount(); ++i)
+      setDynamicItemData(item(i), item(i)->data(ItemIdRole).toInt());
 
-  emit dataUpdateComplete();
+    emit updateComplete();
+  }
 }
 
-
 //
 // TelemetrySourceItemModel
 //
 
-TelemetrySourceItemModel::TelemetrySourceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent) :
-  AbstractRawItemDataModel(generalSettings, modelData, parent)
+TelemetrySourceItemModel::TelemetrySourceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
+                                                   Firmware * firmware, const Boards * const board, const Board::Type boardType) :
+    AbstractDynamicItemModel(generalSettings, modelData, firmware, board, boardType)
 {
+  setId(TeleSourceId);
+
   if (!modelData)
     return;
 
-  const int count = getCurrentFirmware()->getCapability(Sensors);
+  setUpdateMask(TeleSensorsUpdated);
+  const int count = firmware->getCapability(Sensors);
 
-  for (int i = -count + 1; i < count; ++i) {
+  for (int i = -count; i <= count; ++i) {
     QStandardItem * modelItem = new QStandardItem();
     modelItem->setData(i, ItemIdRole);
     int flags = i < 0 ? DataGroups::NegativeGroup : DataGroups::PositiveGroup;
@@ -397,118 +455,35 @@ TelemetrySourceItemModel::TelemetrySourceItemModel(const GeneralSettings * const
   }
 }
 
-void TelemetrySourceItemModel::setDynamicItemData(QStandardItem * item, const int index) const
+void TelemetrySourceItemModel::setDynamicItemData(QStandardItem * item, const int value) const
 {
-  item->setText(SensorData::sourceToString(modelData, index));
-  item->setData(SensorData::isSourceAvailable(modelData, index), IsAvailableRole);
+  item->setText(SensorData::sourceToString(modelData, value));
+  item->setData(SensorData::isSourceAvailable(modelData, value), IsAvailableRole);
 }
 
-void TelemetrySourceItemModel::update()
+void TelemetrySourceItemModel::update(const UpdateTrigger trigger)
 {
-  emit dataAboutToBeUpdated();
+  if (doUpdate(trigger)) {
+    emit aboutToBeUpdated();
 
-  for (int i = 0; i < rowCount(); ++i)
-   setDynamicItemData(item(i), item(i)->data(ItemIdRole).toInt());
-
-  emit dataUpdateComplete();
-}
-
-
-//
-//  CommonItemModels  TODO  rename to DynamicDataModels
-//
-
-CommonItemModels::CommonItemModels(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent) :
-  QObject(parent)
-{
-  m_rawSourceItemModel = new RawSourceItemModel(generalSettings, modelData, parent);
-  //dumpModelContents(QString("raw source"), qobject_cast<AbstractRawItemDataModel *>(m_rawSourceItemModel));
-
-  m_rawSwitchItemModel = new RawSwitchItemModel(generalSettings, modelData, parent);
-  //dumpModelContents(QString("raw switch"), qobject_cast<AbstractRawItemDataModel *>(m_rawSwitchItemModel));
-
-  m_curveItemModel = new CurveItemModel(generalSettings, modelData, parent);
-  //dumpModelContents(QString("curve"), qobject_cast<AbstractRawItemDataModel *>(m_curveItemModel));
-
-  m_gvarReferenceItemModel = new GVarReferenceItemModel(generalSettings, modelData, parent);
-  //dumpModelContents(QString("gvar ref"), qobject_cast<AbstractRawItemDataModel *>(m_gvarReferenceItemModel));
-
-  m_throttleSourceItemModel = new ThrottleSourceItemModel(generalSettings, modelData, parent);
-  //dumpModelContents(QString("thr source"), qobject_cast<AbstractRawItemDataModel *>(m_throttleSourceItemModel));
-
-  m_customFuncActionItemModel = new CustomFuncActionItemModel(generalSettings, modelData, parent);
-  //dumpModelContents(QString("cf action"), qobject_cast<AbstractRawItemDataModel *>(m_customFuncActionItemModel));
-
-  m_customFuncResetParamItemModel = new CustomFuncResetParamItemModel(generalSettings, modelData, parent);
-  //dumpModelContents(QString("cf reset param"), qobject_cast<AbstractRawItemDataModel *>(m_customFuncResetParamItemModel));
-
-  m_telemetrySourceItemModel = new TelemetrySourceItemModel(generalSettings, modelData, parent);
-  //dumpModelContents(QString("tele source"), qobject_cast<AbstractRawItemDataModel *>(m_telemetrySourceItemModel));
-}
-
-CommonItemModels::~CommonItemModels()
-{
-}
-
-void CommonItemModels::update(const RadioModelObjects radioModelObjects)
-{
-  switch (radioModelObjects) {
-    case RMO_CHANNELS:
-      m_throttleSourceItemModel->update();
-      //  no break
-    case RMO_TIMERS:
-      m_customFuncActionItemModel->update();
-      //  no break
-    case RMO_INPUTS:
-    case RMO_TELEMETRY_SENSORS:
-      m_rawSourceItemModel->update();
-      m_customFuncResetParamItemModel->update();
-      m_telemetrySourceItemModel->update();
-      break;
-
-    case RMO_GLOBAL_VARIABLES:
-      m_gvarReferenceItemModel->update();
-      m_customFuncActionItemModel->update();
-      //  no break
-    case RMO_FLIGHT_MODES:
-    case RMO_LOGICAL_SWITCHES:
-      m_rawSourceItemModel->update();
-      m_rawSwitchItemModel->update();
-      break;
-
-    case RMO_CURVES:
-      m_curveItemModel->update();
-      break;
-
-    case RMO_SCRIPTS:
-      //  no need to refresh
-      break;
-
-    default:
-      qDebug() << "Unknown RadioModelObject:" << radioModelObjects;
-  }
-}
-
-
-void dumpModelContents(QString desc, AbstractRawItemDataModel * dataModel)
-{
-  if (dataModel) {
-    qDebug() << "model:" << desc << "rows:" << dataModel->rowCount();
-    for (int i = 0; i < dataModel->rowCount(); ++i) {
-      qDebug() << "row:"    << i << "text:" << dataModel->item(i)->data(Qt::DisplayRole).toString()
-               << "id:"     << dataModel->item(i)->data(AbstractRawItemDataModel::ItemIdRole).toInt()
-               << "avail:"  << dataModel->item(i)->data(AbstractRawItemDataModel::IsAvailableRole).toBool()
-               << "flags:"  << dataModel->item(i)->data(AbstractRawItemDataModel::ItemFlagsRole).toInt()
-               << "type:"   << dataModel->item(i)->data(AbstractRawItemDataModel::ItemTypeRole).toInt();
+    for (int i = 0; i < rowCount(); ++i) {
+      setDynamicItemData(item(i), item(i)->data(ItemIdRole).toInt());
     }
+
+    emit updateComplete();
   }
-  else
-    qDebug() << "model:" << desc << "did not cast";
 }
 
-CurveRefTypeItemModel::CurveRefTypeItemModel(QObject * parent) :
-  AbstractStandardItemModel(parent)
+//
+// CurveRefTypeItemModel
+//
+
+CurveRefTypeItemModel::CurveRefTypeItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
+                                             Firmware * firmware, const Boards * const board, const Board::Type boardType) :
+  AbstractStaticItemModel(generalSettings, modelData, firmware, board, boardType)
 {
+  setId(CurveRefTypeId);
+
   for (int i = 0; i <= CurveReference::MAX_CURVE_REF_TYPE; i++) {
     QStandardItem * modelItem = new QStandardItem();
     modelItem->setText(CurveReference::typeToString((CurveReference::CurveRefType)i));
@@ -518,9 +493,16 @@ CurveRefTypeItemModel::CurveRefTypeItemModel(QObject * parent) :
   }
 }
 
-CurveRefFuncItemModel::CurveRefFuncItemModel(QObject * parent) :
-  AbstractStandardItemModel(parent)
+//
+// CurveRefFuncItemModel
+//
+
+CurveRefFuncItemModel::CurveRefFuncItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
+                                             Firmware * firmware, const Boards * const board, const Board::Type boardType) :
+  AbstractStaticItemModel(generalSettings, modelData, firmware, board, boardType)
 {
+  setId(CurveRefFuncId);
+
   for (int i = 1; i <= CurveReference::functionCount(); i++) {
     QStandardItem * modelItem = new QStandardItem();
     modelItem->setText(CurveReference::functionToString(i));
@@ -529,3 +511,106 @@ CurveRefFuncItemModel::CurveRefFuncItemModel(QObject * parent) :
     appendRow(modelItem);
   }
 }
+
+//
+// ItemModelsFactory
+//
+
+ItemModelsFactory::ItemModelsFactory(const GeneralSettings * const generalSettings, const ModelData * const modelData) :
+  generalSettings(generalSettings),
+  modelData(modelData)
+{
+  firmware = getCurrentFirmware();
+  board = new Boards(getCurrentBoard());
+  boardType = getCurrentBoard();
+}
+
+ItemModelsFactory::~ItemModelsFactory()
+{
+  unregisterItemModels();
+  delete board;
+}
+
+void ItemModelsFactory::addItemModel(const AbstractItemModel::ItemModelId id)
+{
+  switch (id) {
+    case AbstractItemModel::RawSourceId:
+      registerItemModel(new RawSourceItemModel(generalSettings, modelData, firmware, board, boardType));
+      break;
+    case AbstractItemModel::RawSwitchId:
+      registerItemModel(new RawSwitchItemModel(generalSettings, modelData, firmware, board, boardType));
+      break;
+    case AbstractItemModel::CurveId:
+      registerItemModel(new CurveItemModel(generalSettings, modelData, firmware, board, boardType));
+      break;
+    case AbstractItemModel::GVarRefId:
+      registerItemModel(new GVarReferenceItemModel(generalSettings, modelData, firmware, board, boardType));
+      break;
+    case AbstractItemModel::ThrSourceId:
+      registerItemModel(new ThrottleSourceItemModel(generalSettings, modelData, firmware, board, boardType));
+      break;
+    case AbstractItemModel::CustomFuncActionId:
+      registerItemModel(new CustomFuncActionItemModel(generalSettings, modelData, firmware, board, boardType));
+      break;
+    case AbstractItemModel::CustomFuncResetParamId:
+      registerItemModel(new CustomFuncResetParamItemModel(generalSettings, modelData, firmware, board, boardType));
+      break;
+    case AbstractItemModel::TeleSourceId:
+      registerItemModel(new TelemetrySourceItemModel(generalSettings, modelData, firmware, board, boardType));
+      break;
+    case AbstractItemModel::CurveRefTypeId:
+      registerItemModel(new CurveRefTypeItemModel(generalSettings, modelData, firmware, board, boardType));
+      break;
+    case AbstractItemModel::CurveRefFuncId:
+      registerItemModel(new CurveRefFuncItemModel(generalSettings, modelData, firmware, board, boardType));
+      break;
+    default:
+      qDebug() << "Error: unknown item model: id";
+      break;
+  }
+}
+
+void ItemModelsFactory::registerItemModel(AbstractItemModel * itemModel)
+{
+  if (itemModel && !getItemModel(itemModel->getId())) {
+    registeredItemModels.push_back(itemModel);
+  }
+}
+
+void ItemModelsFactory::unregisterItemModels()
+{
+  foreach (AbstractItemModel *itemModel, registeredItemModels) {
+    delete itemModel;
+  }
+}
+
+void ItemModelsFactory::unregisterItemModel(const AbstractItemModel::ItemModelId id)
+{
+  AbstractItemModel * itemModel =  getItemModel(id);
+  if (itemModel)
+    delete itemModel;
+}
+
+AbstractItemModel * ItemModelsFactory::getItemModel(const AbstractItemModel::ItemModelId id) const
+{
+  foreach (AbstractItemModel * itemModel, registeredItemModels) {
+    if (itemModel->getId() == id)
+      return itemModel;
+  }
+
+  return nullptr;
+}
+
+void ItemModelsFactory::update(const AbstractItemModel::UpdateTrigger trigger)
+{
+  foreach (AbstractItemModel * itemModel, registeredItemModels) {
+    itemModel->update(trigger);
+  }
+}
+
+void ItemModelsFactory::dumpAllItemModelContents() const
+{
+  foreach (AbstractItemModel * itemModel, registeredItemModels) {
+    AbstractItemModel::dumpItemModelContents(itemModel);
+  }
+}

companion/src/datamodels/rawitemdatamodels.h

@@ -30,13 +30,24 @@ class GeneralSettings;
 class ModelData;
 class AdjustmentReference;
 
-class AbstractStandardItemModel: public QStandardItemModel
+class AbstractItemModel: public QStandardItemModel
 {
     Q_OBJECT
   public:
-    explicit AbstractStandardItemModel(QObject * parent = nullptr) :
-      QStandardItemModel(parent)
-    {}
+    enum ItemModelId {
+      UnknownId,
+      RawSourceId,
+      RawSwitchId,
+      CurveId,
+      GVarRefId,
+      ThrSourceId,
+      CustomFuncActionId,
+      CustomFuncResetParamId,
+      TeleSourceId,
+      CurveRefTypeId,
+      CurveRefFuncId
+    };
+    Q_ENUM(ItemModelId)
 
     enum DataRoles {
       ItemIdRole = Qt::UserRole,
@@ -52,203 +63,254 @@ class AbstractStandardItemModel: public QStandardItemModel
       PositiveGroup = 0x04
     };
     Q_ENUM(DataGroups)
-};
 
-class AbstractRawItemDataModel: public AbstractStandardItemModel
-{
-    Q_OBJECT
-  public:
-    explicit AbstractRawItemDataModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent = nullptr)  :
-      AbstractStandardItemModel(parent),
+    enum UpdateTrigger {
+      SystemRefresh           = 1 << 0,
+      ChannelsUpdated         = 1 << 1,
+      CurvesUpdated           = 1 << 2,
+      FlightModesUpdated      = 1 << 3,
+      GVarsUpdated            = 1 << 4,
+      InputsUpdated           = 1 << 5,
+      LogicalSwitchesUpdated  = 1 << 6,
+      ScriptsUpdated          = 1 << 7,
+      TeleSensorsUpdated      = 1 << 8,
+      TimersUpdated           = 1 << 9,
+      AllTriggers = SystemRefresh | ChannelsUpdated | CurvesUpdated | FlightModesUpdated | GVarsUpdated | InputsUpdated |
+                    LogicalSwitchesUpdated | ScriptsUpdated | TeleSensorsUpdated | TimersUpdated,
+      NoTriggers = 0
+    };
+    Q_ENUM(UpdateTrigger)
+
+    explicit AbstractItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
+                               Firmware * firmware, const Boards * const board, const Board::Type boardType) :
+      QStandardItemModel(nullptr),
       generalSettings(generalSettings),
-      modelData(modelData)
+      modelData(modelData),
+      firmware(firmware),
+      board(board),
+      boardType(boardType)
     {}
 
-  public slots:
-    virtual void update() = 0;
+    virtual ~AbstractItemModel() {};
 
-  signals:
-    void dataAboutToBeUpdated();
-    void dataUpdateComplete();
+    void setId(ItemModelId id) { m_id = id; }
+    ItemModelId getId () const { return m_id; }
+
+    void setUpdateMask(const int mask) { m_updateMask = mask; }
+    int getUpdateMask() const { return m_updateMask; }
+    inline bool doUpdate(const UpdateTrigger trigger) const { return m_updateMask & (int)trigger; }
+
+    AbstractItemModel * getItemModel(const ItemModelId id) const;
+
+    static void dumpItemModelContents(AbstractItemModel * itemModel);
+
+  public slots:
+    virtual void update(const UpdateTrigger trigger = SystemRefresh) = 0;
 
   protected:
     const GeneralSettings * generalSettings;
     const ModelData * modelData;
+    Firmware * firmware;
+    const Boards * board;
+    const Board::Type boardType;
+
+  private:
+    ItemModelId m_id = UnknownId;
+    int m_updateMask = 0;
 };
 
-
-class RawSourceItemModel: public AbstractRawItemDataModel
+class AbstractStaticItemModel: public AbstractItemModel
 {
     Q_OBJECT
   public:
-    explicit RawSourceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent = nullptr);
+    explicit AbstractStaticItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
+                                     Firmware * firmware, const Boards * const board, const Board::Type boardType) :
+      AbstractItemModel(generalSettings, modelData, firmware, board, boardType) {}
+    virtual ~AbstractStaticItemModel() {};
 
   public slots:
-    void update() override;
+    virtual void update(const UpdateTrigger trigger = SystemRefresh) override final {}
+};
+
+class AbstractDynamicItemModel: public AbstractItemModel
+{
+    Q_OBJECT
+  public:
+    explicit AbstractDynamicItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
+                                      Firmware * firmware, const Boards * const board, const Board::Type boardType) :
+      AbstractItemModel(generalSettings, modelData, firmware, board, boardType) {}
+    virtual ~AbstractDynamicItemModel() {};
+
+  public slots:
+    virtual void update(const UpdateTrigger trigger = SystemRefresh) {}
+
+  signals:
+    void aboutToBeUpdated();
+    void updateComplete();
+};
+
+class RawSourceItemModel: public AbstractDynamicItemModel
+{
+    Q_OBJECT
+  public:
+    explicit RawSourceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
+                                Firmware * firmware, const Boards * const board, const Board::Type boardType);
+    virtual ~RawSourceItemModel() {};
+
+  public slots:
+    virtual void update(const UpdateTrigger trigger = SystemRefresh) override;
 
   protected:
-    void setDynamicItemData(QStandardItem * item, const RawSource & src) const;
+    virtual void setDynamicItemData(QStandardItem * item, const RawSource & src) const;
     void addItems(const RawSourceType & type, const int group, const int count, const int start = 0);
 };
 
-
-class RawSwitchItemModel: public AbstractRawItemDataModel
+class RawSwitchItemModel: public AbstractDynamicItemModel
 {
     Q_OBJECT
   public:
-    explicit RawSwitchItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent = nullptr);
+    explicit RawSwitchItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
+                                Firmware * firmware, const Boards * const board, const Board::Type boardType);
+    virtual ~RawSwitchItemModel() {};
 
   public slots:
-    void update() override;
+    virtual void update(const UpdateTrigger trigger = SystemRefresh) override;
 
   protected:
-    void setDynamicItemData(QStandardItem * item, const RawSwitch & rsw) const;
+    virtual void setDynamicItemData(QStandardItem * item, const RawSwitch & rsw) const;
     void addItems(const RawSwitchType & type, int count);
 };
 
-
-class CurveItemModel: public AbstractRawItemDataModel
+class CurveItemModel: public AbstractDynamicItemModel
 {
     Q_OBJECT
   public:
-    explicit CurveItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent = nullptr);
+    explicit CurveItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
+                            Firmware * firmware, const Boards * const board, const Board::Type boardType);
+    virtual ~CurveItemModel() {};
 
   public slots:
-    void update() override;
+    virtual void update(const UpdateTrigger trigger = SystemRefresh) override;
 
   protected:
-    void setDynamicItemData(QStandardItem * item, const int index) const;
+    virtual void setDynamicItemData(QStandardItem * item, const int value) const;
 };
 
-
-class GVarReferenceItemModel: public AbstractRawItemDataModel
+class GVarReferenceItemModel: public AbstractDynamicItemModel
 {
     Q_OBJECT
   public:
-    explicit GVarReferenceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent = nullptr);
+    explicit GVarReferenceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
+                                    Firmware * firmware, const Boards * const board, const Board::Type boardType);
+    virtual ~GVarReferenceItemModel() {};
 
   public slots:
-    void update() override;
+    virtual void update(const UpdateTrigger trigger = SystemRefresh) override;
 
   protected:
-    void setDynamicItemData(QStandardItem * item, const AdjustmentReference & ar) const;
+    virtual void setDynamicItemData(QStandardItem * item, const AdjustmentReference & ar) const;
     void addItems(int count);
 };
 
-
-class ThrottleSourceItemModel: public AbstractRawItemDataModel
+class ThrottleSourceItemModel: public AbstractDynamicItemModel
 {
     Q_OBJECT
   public:
-    explicit ThrottleSourceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent = nullptr);
+    explicit ThrottleSourceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
+                                     Firmware * firmware, const Boards * const board, const Board::Type boardType);
+    virtual ~ThrottleSourceItemModel() {};
 
   public slots:
-    void update() override;
+    virtual void update(const UpdateTrigger trigger = SystemRefresh) override;
 
   protected:
-    void setDynamicItemData(QStandardItem * item, const int index) const;
+    virtual void setDynamicItemData(QStandardItem * item, const int value) const;
 };
 
-
-class CustomFuncActionItemModel: public AbstractRawItemDataModel
+class CustomFuncActionItemModel: public AbstractDynamicItemModel
 {
     Q_OBJECT
   public:
-    explicit CustomFuncActionItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent = nullptr);
+    explicit CustomFuncActionItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
+                                       Firmware * firmware, const Boards * const board, const Board::Type boardType);
+    virtual ~CustomFuncActionItemModel() {};
 
   public slots:
-    void update() override;
+    virtual void update(const UpdateTrigger trigger = SystemRefresh) override;
 
   protected:
-    void setDynamicItemData(QStandardItem * item, const int index) const;
+    virtual void setDynamicItemData(QStandardItem * item, const int value) const;
 };
 
-
-class CustomFuncResetParamItemModel: public AbstractRawItemDataModel
+class CustomFuncResetParamItemModel: public AbstractDynamicItemModel
 {
     Q_OBJECT
   public:
-    explicit CustomFuncResetParamItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent = nullptr);
+    explicit CustomFuncResetParamItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
+                                           Firmware * firmware, const Boards * const board, const Board::Type boardType);
+    virtual ~CustomFuncResetParamItemModel() {};
 
   public slots:
-    void update() override;
+    virtual void update(const UpdateTrigger trigger = SystemRefresh) override;
 
   protected:
-    void setDynamicItemData(QStandardItem * item, const int index) const;
+    virtual void setDynamicItemData(QStandardItem * item, const int value) const;
 };
 
-
-class TelemetrySourceItemModel: public AbstractRawItemDataModel
+class TelemetrySourceItemModel: public AbstractDynamicItemModel
 {
     Q_OBJECT
   public:
-    explicit TelemetrySourceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent = nullptr);
+    explicit TelemetrySourceItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
+                                      Firmware * firmware, const Boards * const board, const Board::Type boardType);
+    virtual ~TelemetrySourceItemModel() {};
 
   public slots:
-    void update() override;
+    virtual void update(const UpdateTrigger trigger = SystemRefresh) override;
 
   protected:
-    void setDynamicItemData(QStandardItem * item, const int index) const;
+    virtual void setDynamicItemData(QStandardItem * item, const int value) const;
 };
 
-
-class CommonItemModels: public QObject
+class CurveRefTypeItemModel : public AbstractStaticItemModel
 {
     Q_OBJECT
   public:
-    enum RadioModelObjects {
-      RMO_CHANNELS,
-      RMO_CURVES,
-      RMO_FLIGHT_MODES,
-      RMO_GLOBAL_VARIABLES,
-      RMO_INPUTS,
-      RMO_LOGICAL_SWITCHES,
-      RMO_SCRIPTS,
-      RMO_TELEMETRY_SENSORS,
-      RMO_TIMERS
-    };
-    Q_ENUM(RadioModelObjects)
-
-    explicit CommonItemModels(const GeneralSettings * const generalSettings, const ModelData * const modelData, QObject * parent = nullptr);
-    ~CommonItemModels();
-
-    void update(const RadioModelObjects radioModelObjects);
-    RawSourceItemModel * rawSourceItemModel() const { return m_rawSourceItemModel; }
-    RawSwitchItemModel * rawSwitchItemModel() const { return m_rawSwitchItemModel; }
-    CurveItemModel * curveItemModel() const { return m_curveItemModel; }
-    GVarReferenceItemModel * gvarItemModel() const { return m_gvarReferenceItemModel; }
-    ThrottleSourceItemModel * throttleSourceItemModel() const { return m_throttleSourceItemModel; }
-    CustomFuncActionItemModel * customFuncActionItemModel() const { return m_customFuncActionItemModel; }
-    CustomFuncResetParamItemModel * customFuncResetParamItemModel() const { return m_customFuncResetParamItemModel; }
-    TelemetrySourceItemModel * telemetrySourceItemModel() const { return m_telemetrySourceItemModel; }
-
-  private:
-    RawSourceItemModel *m_rawSourceItemModel;
-    RawSwitchItemModel *m_rawSwitchItemModel;
-    CurveItemModel *m_curveItemModel;
-    GVarReferenceItemModel *m_gvarReferenceItemModel;
-    ThrottleSourceItemModel *m_throttleSourceItemModel;
-    CustomFuncActionItemModel *m_customFuncActionItemModel;
-    CustomFuncResetParamItemModel *m_customFuncResetParamItemModel;
-    TelemetrySourceItemModel *m_telemetrySourceItemModel;
+    explicit CurveRefTypeItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
+                                   Firmware * firmware, const Boards * const board, const Board::Type boardType);
+    virtual ~CurveRefTypeItemModel() {};
 };
 
-void dumpModelContents(QString desc, AbstractRawItemDataModel * dataModel);
-
-
-class CurveRefTypeItemModel : public AbstractStandardItemModel
+class CurveRefFuncItemModel : public AbstractStaticItemModel
 {
     Q_OBJECT
   public:
-    explicit CurveRefTypeItemModel(QObject * parent = nullptr);
+    explicit CurveRefFuncItemModel(const GeneralSettings * const generalSettings, const ModelData * const modelData,
+                                   Firmware * firmware, const Boards * const board, const Board::Type boardType);
+    virtual ~CurveRefFuncItemModel() {};
 };
 
-class CurveRefFuncItemModel : public AbstractStandardItemModel
+class ItemModelsFactory
 {
-    Q_OBJECT
   public:
-    explicit CurveRefFuncItemModel(QObject * parent = nullptr);
-};
+    ItemModelsFactory(const GeneralSettings * const generalSettings, const ModelData * const modelData);
+    virtual ~ItemModelsFactory();
 
+    void addItemModel(const AbstractItemModel::ItemModelId id);
+    void registerItemModel(AbstractItemModel * itemModel);
+    void unregisterItemModels();
+    void unregisterItemModel(const AbstractItemModel::ItemModelId id);
+    AbstractItemModel * getItemModel(const AbstractItemModel::ItemModelId id) const;
+    void update(const AbstractItemModel::UpdateTrigger trigger = AbstractItemModel::SystemRefresh);
+    void dumpAllItemModelContents() const;
+
+  protected:
+    const GeneralSettings * generalSettings;
+    const ModelData * modelData;
+    Firmware * firmware;
+    Boards * board;
+    Board::Type boardType;
+    QVector<AbstractItemModel *> registeredItemModels;
+};
 
 #endif // RAWITEMDATAMODELS_H

companion/src/datamodels/rawitemfilteredmodel.cpp

@@ -20,24 +20,24 @@
 
 #include "rawitemfilteredmodel.h"
 
-RawItemFilteredModel::RawItemFilteredModel(QAbstractItemModel * sourceModel, int flags, QObject * parent) :
-  QSortFilterProxyModel(parent),
+FilteredItemModel::FilteredItemModel(AbstractItemModel * sourceModel, int flags) :
+  QSortFilterProxyModel(nullptr),
   filterFlags(0)
 {
-  setFilterRole(AbstractRawItemDataModel::IsAvailableRole);
+  setFilterRole(AbstractItemModel::IsAvailableRole);
   setFilterKeyColumn(0);
   setFilterFlags(flags);
   setDynamicSortFilter(true);
   setSourceModel(sourceModel);
 
-  AbstractRawItemDataModel * itemModel = qobject_cast<AbstractRawItemDataModel *>(sourceModel);
+  AbstractDynamicItemModel * itemModel = qobject_cast<AbstractDynamicItemModel *>(sourceModel);
   if (itemModel) {
-    connect(itemModel, &AbstractRawItemDataModel::dataAboutToBeUpdated, this, &RawItemFilteredModel::onDataAboutToBeUpdated);
-    connect(itemModel, &AbstractRawItemDataModel::dataUpdateComplete, this, &RawItemFilteredModel::onDataUpdateComplete);
+    connect(itemModel, &AbstractDynamicItemModel::aboutToBeUpdated, this, &FilteredItemModel::onAboutToBeUpdated);
+    connect(itemModel, &AbstractDynamicItemModel::updateComplete, this, &FilteredItemModel::onUpdateComplete);
   }
 }
 
-void RawItemFilteredModel::setFilterFlags(int flags)
+void FilteredItemModel::setFilterFlags(int flags)
 {
   if (filterFlags != flags) {
     filterFlags = flags;
@@ -45,7 +45,7 @@ void RawItemFilteredModel::setFilterFlags(int flags)
   }
 }
 
-bool RawItemFilteredModel::filterAcceptsRow(int sourceRow, const QModelIndex & sourceParent) const
+bool FilteredItemModel::filterAcceptsRow(int sourceRow, const QModelIndex & sourceParent) const
 {
   const QModelIndex & srcIdx = sourceModel()->index(sourceRow, 0, sourceParent);
   if (!srcIdx.isValid() || !sourceModel()->data(srcIdx, filterRole()).toBool())
@@ -55,23 +55,137 @@ bool RawItemFilteredModel::filterAcceptsRow(int sourceRow, const QModelIndex & s
     return true;
 
   bool ok;
-  const int flags = sourceModel()->data(srcIdx, AbstractRawItemDataModel::ItemFlagsRole).toInt(&ok);
+  const int flags = sourceModel()->data(srcIdx, AbstractItemModel::ItemFlagsRole).toInt(&ok);
   return (ok && (!flags || (filterFlags & flags)));
 }
 
-void RawItemFilteredModel::update() const
+void FilteredItemModel::update() const
 {
-  AbstractRawItemDataModel * itemModel = qobject_cast<AbstractRawItemDataModel *>(sourceModel());
+  AbstractDynamicItemModel * itemModel = qobject_cast<AbstractDynamicItemModel *>(sourceModel());
   if (itemModel)
     itemModel->update();
 }
 
-void RawItemFilteredModel::onDataAboutToBeUpdated()
+void FilteredItemModel::onAboutToBeUpdated()
 {
-  emit dataAboutToBeUpdated();
+  emit aboutToBeUpdated();
 }
 
-void RawItemFilteredModel::onDataUpdateComplete()
+void FilteredItemModel::onUpdateComplete()
 {
-  emit dataUpdateComplete();
+  emit updateComplete();
+}
+
+// static
+void FilteredItemModel::dumpItemModelContents(FilteredItemModel * itemModel)
+{
+  if (itemModel) {
+    qDebug() << "id:" << itemModel->getId() << "name:" << itemModel->getName();
+
+    for (int i = 0; i < itemModel->rowCount(); ++i) {
+      qDebug() << "row:"   << i
+               << "text:"  << itemModel->data(itemModel->index(i, 0), Qt::DisplayRole).toString()
+               << "id:"    << itemModel->data(itemModel->index(i, 0), AbstractItemModel::ItemIdRole).toInt()
+               << "avail:" << itemModel->data(itemModel->index(i, 0), AbstractItemModel::IsAvailableRole).toBool()
+               << "flags:" << itemModel->data(itemModel->index(i, 0), AbstractItemModel::ItemFlagsRole).toInt()
+               << "type:"  << itemModel->data(itemModel->index(i, 0), AbstractItemModel::ItemTypeRole).toInt();
+    }
+  }
+  else
+    qDebug() << "Error: model did not cast";
+}
+
+//
+// FilteredItemModelsFactory
+//
+
+FilteredItemModelsFactory::FilteredItemModelsFactory()
+{
+}
+
+FilteredItemModelsFactory::~FilteredItemModelsFactory()
+{
+  unregisterItemModels();
+}
+
+int FilteredItemModelsFactory::registerItemModel(FilteredItemModel * itemModel, QString name)
+{
+  if (itemModel) {
+    if (isItemModelRegistered(name))
+      qDebug() << "Warning: item model already registered with name:" << name;
+    const int id = registeredItemModels.count();
+    itemModel->setId(id);
+    itemModel->setName(name);
+    registeredItemModels.push_back(itemModel);
+    return id;
+  }
+  return 0;
+}
+
+void FilteredItemModelsFactory::unregisterItemModels()
+{
+  foreach (FilteredItemModel * itemModel, registeredItemModels) {
+    delete itemModel;
+  }
+}
+
+void FilteredItemModelsFactory::unregisterItemModel(const int id)
+{
+  FilteredItemModel * itemModel =  getItemModel(id);
+  if (itemModel)
+    delete itemModel;
+}
+
+bool FilteredItemModelsFactory::isItemModelRegistered(const int id) const
+{
+  return getItemModel(id);
+}
+
+bool FilteredItemModelsFactory::isItemModelRegistered(const QString name) const
+{
+  return getItemModel(name);
+}
+
+FilteredItemModel * FilteredItemModelsFactory::getItemModel(const int id) const
+{
+  foreach (FilteredItemModel * itemModel, registeredItemModels) {
+    if (itemModel->getId() == id)
+      return itemModel;
+  }
+
+  return nullptr;
+}
+
+FilteredItemModel * FilteredItemModelsFactory::getItemModel(const QString name) const
+{
+  foreach (FilteredItemModel * itemModel, registeredItemModels) {
+    if (itemModel->getName() == name)
+      return itemModel;
+  }
+
+  return nullptr;
+}
+
+void FilteredItemModelsFactory::update()
+{
+  foreach (FilteredItemModel * itemModel, registeredItemModels) {
+    itemModel->update();
+  }
+}
+
+void FilteredItemModelsFactory::dumpItemModelContents(const int id) const
+{
+  FilteredItemModel::dumpItemModelContents(getItemModel(id));
+}
+
+void FilteredItemModelsFactory::dumpItemModelContents(const QString name) const
+{
+  FilteredItemModel::dumpItemModelContents(getItemModel(name));
+}
+
+void FilteredItemModelsFactory::dumpAllItemModelContents() const
+{
+  foreach (FilteredItemModel * itemModel, registeredItemModels) {
+    FilteredItemModel::dumpItemModelContents(itemModel);
+  }
 }

companion/src/datamodels/rawitemfilteredmodel.h

@@ -23,41 +23,90 @@
 
 #include "rawitemdatamodels.h"
 
+#include <QObject>
 #include <QSortFilterProxyModel>
+#include <QString>
 
-class GeneralSettings;
-class ModelData;
-
-class RawItemFilteredModel: public QSortFilterProxyModel
+class FilteredItemModel: public QSortFilterProxyModel
 {
     Q_OBJECT
   public:
     enum DataFilters {
-      AllFilter = AbstractRawItemDataModel::NegativeGroup | AbstractRawItemDataModel::NoneGroup | AbstractRawItemDataModel::PositiveGroup,
-      AllExcludeNoneFilter = AllFilter &~ AbstractRawItemDataModel::NoneGroup,
-      NegativeFilter = AbstractRawItemDataModel::NegativeGroup | AbstractRawItemDataModel::NoneGroup,
-      NegativeExcludeNoneFilter = AbstractRawItemDataModel::NegativeGroup,
-      PositiveFilter = AbstractRawItemDataModel::PositiveGroup | AbstractRawItemDataModel::NoneGroup,
-      PositiveExcludeNoneFilter = AbstractRawItemDataModel::PositiveGroup
+      AllFilter = AbstractItemModel::NegativeGroup | AbstractItemModel::NoneGroup | AbstractItemModel::PositiveGroup,
+      AllExcludeNoneFilter = AllFilter &~ AbstractItemModel::NoneGroup,
+      NegativeFilter = AbstractItemModel::NegativeGroup | AbstractItemModel::NoneGroup,
+      NegativeExcludeNoneFilter = AbstractItemModel::NegativeGroup,
+      PositiveFilter = AbstractItemModel::PositiveGroup | AbstractItemModel::NoneGroup,
+      PositiveExcludeNoneFilter = AbstractItemModel::PositiveGroup
     };
     Q_ENUM(DataFilters)
 
-    explicit RawItemFilteredModel(QAbstractItemModel * sourceModel, int flags, QObject * parent = nullptr);
-    explicit RawItemFilteredModel(QAbstractItemModel * sourceModel, QObject * parent = nullptr) : RawItemFilteredModel(sourceModel, 0, parent) {}
+    explicit FilteredItemModel(AbstractItemModel * sourceModel, int flags);
+    explicit FilteredItemModel(AbstractItemModel * sourceModel) :
+      FilteredItemModel(sourceModel, 0) {}
+    virtual ~FilteredItemModel() {};
+
+    void setId(int id) { m_id = id; }
+    int getId() const { return m_id; };
+    void setName(QString name) { m_name = name; }
+    QString getName() const { return m_name; }
+
+    static void dumpItemModelContents(FilteredItemModel * itemModel);
 
   public slots:
     void setFilterFlags(int flags);
     void update() const;
-    void onDataAboutToBeUpdated();
-    void onDataUpdateComplete();
+    void onAboutToBeUpdated();
+    void onUpdateComplete();
 
   signals:
-    void dataAboutToBeUpdated();
-    void dataUpdateComplete();
+    void aboutToBeUpdated();
+    void updateComplete();
 
   protected:
     bool filterAcceptsRow(int sourceRow, const QModelIndex & sourceParent) const override;
 
     int filterFlags;
+
+  private:
+    int m_id = 0;
+    QString m_name = "";
 };
+
+class FilteredItemModelsFactory
+{
+  public:
+    FilteredItemModelsFactory();
+    virtual ~FilteredItemModelsFactory();
+
+    int registerItemModel(FilteredItemModel * itemModel, QString name);
+    void unregisterItemModels();
+    void unregisterItemModel(const int id);
+    bool isItemModelRegistered(const int id) const;
+    bool isItemModelRegistered(const QString name) const;
+    FilteredItemModel * getItemModel(const int id) const;
+    FilteredItemModel * getItemModel(const QString name) const;
+    void update();
+
+    void dumpItemModelContents(const int id) const;
+    void dumpItemModelContents(const QString name) const;
+    void dumpAllItemModelContents() const;
+
+  protected:
+    QVector<FilteredItemModel *> registeredItemModels;
+};
+
+
+#define FILTEREDITEMMODELCONNECT(fltrmodel) \
+  connect(fltrmodel, SIGNAL(aboutToBeUpdated()), this, SLOT(onItemModelAboutToBeUpdated())); \
+  connect(fltrmodel, SIGNAL(updateComplete()), this, SLOT(onItemModelUpdateComplete()));
+
+#define FILTEREDITEMMODEL(fltrmodel, class, modelid, flags) \
+  fltrmodel = new FilteredItemModel(sharedItemModels->getItemModel(AbstractItemModel::modelid), flags); \
+  FILTEREDITEMMODELCONNECT(fltrmodel)
+
+#define FILTEREDITEMMODELNOFLAGS(fltrmodel, class, modelid) \
+  fltrmodel = new FilteredItemModel(sharedItemModels->getItemModel(AbstractItemModel::modelid)); \
+  FILTEREDITEMMODELCONNECT(fltrmodel)
+
 #endif // RAWITEMFILTEREDMODEL_H