detail_property_model.hpp

#pragma once
 
#pragma warning(push)
#pragma warning(disable : 4800)
#pragma warning(disable : 4251)
#pragma warning(disable : 4244)
#pragma warning(disable : 4127)
#include <QAbstractItemModel>
#include <QFont>
#include <QColor>
#pragma warning(pop)
 
#include "../../global.hpp"
#include "../../utilities/system_info.hpp"
#include "../../genapi/node_map.hpp"
#include "detail_property.hpp"
#include "detail_boolean_property.hpp"
#include "detail_category_property.hpp"
#include "detail_command_property.hpp"
#include "detail_enum_property.hpp"
#include "detail_float_property.hpp"
#include "detail_integer_property.hpp"
#include "detail_string_property.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace UI
  {
    namespace Private
    {
 
      class PropertyModel : public QAbstractItemModel
      {
 
        Q_OBJECT
 
      public:
        explicit PropertyModel(QObject *parent = 0) noexcept
            : QAbstractItemModel(parent)
            , rootProperty_(NULL)
            , maxVisibility_(GenApi::Visibility::Beginner)
            , nodeMap_(nullptr)
            , searchText_("")
            , searchResultBGColor_(255, 255, 0)
            , updateLock_(false)
        {
        }
 
        explicit PropertyModel(const NodeMapPtr &nodemap, QObject *parent = 0) noexcept
            : QAbstractItemModel(parent)
            , rootProperty_(NULL)
            , maxVisibility_(GenApi::Visibility::Beginner)
            , nodeMap_(nodemap)
            , searchText_("")
            , searchResultBGColor_(255, 255, 0)
            , updateLock_(false)
        {
          ScanNodeMap();
        }
 
        PropertyModel(const PropertyModel &other)            = delete;
        PropertyModel &operator=(const PropertyModel &other) = delete;
        PropertyModel(PropertyModel &&other)                 = delete;
        PropertyModel &operator=(PropertyModel &&other)      = delete;
        ~PropertyModel()
        {
          Clear();
        }
 
        Private::Property *Item(const QModelIndex &index) const
        {
          if (index.isValid())
          {
            auto prop = static_cast<Private::Property *>(index.internalPointer());
            if (prop)
              return prop;
          }
          return rootProperty_;
        }
 
        int rowCount(const QModelIndex &parent) const override
        {
          auto prop = rootProperty_;
          if (parent.isValid())
            prop = Item(parent);
 
          if (prop)
            return prop->ChildCount();
          return 0;
        }
 
        int columnCount(const QModelIndex & /* parent */ = QModelIndex()) const override
        {
          return defaultColumns_;
        }
 
        Qt::ItemFlags flags(const QModelIndex &index) const override
        {
          if (!index.isValid())
            return Qt::NoItemFlags;
 
          auto prop = Item(index);
          if (!prop)
            return Qt::NoItemFlags;
 
          if (prop->IsRoot())
            return Qt::NoItemFlags;
          else if (prop->IsReadOnly())
            return Qt::ItemIsSelectable;
          else if (prop->Type() == Private::Property::PT_Boolean)
            return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsUserCheckable;
          else
            return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable;
        }
 
        QModelIndex index(int row, int column, const QModelIndex &parent) const override
        {
          if (!hasIndex(row, column, parent))
            return QModelIndex();
 
          auto item = rootProperty_;
          if (parent.isValid())
            item = static_cast<Private::Property *>(parent.internalPointer());
          if (item)
          {
            auto child = item->Child(row);
            if (child)
              return createIndex(row, column, (void *)child);
          }
          return QModelIndex();
        }
 
        QModelIndex parent(const QModelIndex &child) const override
        {
          if (!child.isValid())
            return QModelIndex();
 
          auto childProp = static_cast<Private::Property *>(child.internalPointer());
          if (childProp)
          {
            auto prop = childProp->Parent();
            if (prop)
            {
              if (prop != rootProperty_)
                return createIndex(prop->Position(), 0, (void *)prop);
            }
          }
          return QModelIndex();
        }
 
        QVariant data(const QModelIndex &index, int role) const override
        {
          if (!index.isValid())
            return QVariant();
 
          auto prop = static_cast<Private::Property *>(index.internalPointer());
          if (!prop)
            return QVariant();
 
          /* The try catch blocks are necessary to catch the case if the device
             does not exist any more and the QVariant type does not fit (QVariantDelegate).
             Maybe this can be solved in a better way? */
 
          switch (role)
          {
            case Qt::CheckStateRole:
              if (prop->Type() == Private::Property::PT_Boolean && index.column() == 1)
                return prop->Value(index.column(), role);
              break;
            case Qt::ToolTipRole:
            case Qt::DisplayRole:
            case Qt::EditRole:
              return prop->Value(index.column(), role);
              break;
            case Qt::FontRole:
              if (prop->Type() == Private::Property::PT_Category)
              {
                QFont font;
                font.setBold(true);
                return font;
              }
              break;
            case Qt::ForegroundRole:
              if (prop->Type() == Private::Property::PT_Category)
              {
                return QColor(Qt::black);
              }
              else if (prop->IsReadOnly())
              {
                return QColor(Qt::darkGray);
              }
              break;
            case Qt::BackgroundColorRole:
              if (!searchText_.isEmpty())
              {
                auto param = prop->Value(0, Qt::DisplayRole).toString();
                if (param.contains(searchText_, Qt::CaseInsensitive))
                {
                  return searchResultBGColor_;
                }
              }
              break;
            case Qt::DecorationRole:
              if (prop->Type() == Private::Property::PT_Category)
                return QVariant();
 
              if (index.column() == 0 && prop->NodeHasPolling())
              {
                auto by  = QByteArray::fromBase64(pollingImg_.toLatin1());
                auto img = QImage::fromData(by, "PNG");
                return QIcon(QPixmap::fromImage(img));
              }
              break;
          };
          return QVariant();
        }
 
        bool setData(const QModelIndex &index, const QVariant &value, int role) override
        {
          if (!index.isValid())
            return false;
 
          switch (role)
          {
            case Qt::EditRole:
              return true;
            case Qt::CheckStateRole:
            {
              auto prop = static_cast<Private::Property *>(index.internalPointer());
              if (!prop)
                return false;
 
              prop->SetValue(value);
              return true;
            }
          }
 
          return false;
        }
 
        QVariant headerData(int section, Qt::Orientation orientation, int role) const override
        {
          if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
          {
            switch (section)
            {
              case 0:
              {
                auto header = QString("Property");
                if (maxVisibility_ == GenApi::Visibility::Beginner)
                  header.append(" (Beginner)");
                else if (maxVisibility_ == GenApi::Visibility::Expert)
                  header.append(" (Expert)");
                else if (maxVisibility_ == GenApi::Visibility::Guru)
                  header.append(" (Guru)");
                return header;
              }
              case 1:
              {
                return tr("Value");
              }
            }
          }
          return QVariant();
        }
 
        QModelIndex buddy(const QModelIndex &index) const override
        {
          if (index.isValid() && index.column() == 0)
            return createIndex(index.row(), 1, index.internalPointer());
          return index;
        }
 
        GenApi::NodeMapPtr NodeMap() const
        {
          return nodeMap_;
        }
 
        void SetNodeMap(const NodeMapPtr &nodeMap)
        {
          Clear();
 
          nodeMap_ = nodeMap;
          ScanNodeMap();
        }
 
        GenApi::Visibility MaxVisibility() const
        {
          return maxVisibility_;
        }
 
        void SetMaxVisibility(Visibility visibility)
        {
          maxVisibility_ = visibility;
          ScanNodeMap();
        }
 
        QModelIndexList Search(const QString &text)
        {
          searchText_ = text;
          if (searchText_.isEmpty())
            return QModelIndexList();
          return match(index(0, 0, QModelIndex()), Qt::DisplayRole, QVariant::fromValue(searchText_), -1,
                       Qt::MatchRecursive | Qt::MatchContains);
        }
 
        QModelIndex FindExactMatch(const QString &text)
        {
          if (text.isEmpty())
            return QModelIndex();
 
          auto list =
              match(index(0, 0, QModelIndex()), Qt::DisplayRole, QVariant::fromValue(text), -1, Qt::MatchRecursive);
          if (list.size() == 1)
            return list.at(0);
 
          return QModelIndex();
        }
 
        Private::Property *Property(const QString &text)
        {
          auto index = FindExactMatch(text);
          return Item(index);
        }
 
        Private::Property *Property(const QModelIndex &index)
        {
          return Item(index);
        }
 
        void ResetSearch()
        {
          searchText_ = "";
          layoutChanged();  // send signal
        }
 
        QString SearchText()
        {
          return searchText_;
        }
 
        void SetSearchResultBGColor(QColor color)
        {
          searchResultBGColor_ = color;
        }
 
        QColor SearchResultBGColor()
        {
          return searchResultBGColor_;
        }
 
        void UpdateProperty(const QModelIndex &index)
        {
          dataChanged(index, index);  // send signal
        }
 
        void Update()
        {
          // do not update all properties at timeout as this might happen, if device is disconnected
          if (!updateLock_)
            dataChanged(QModelIndex(), QModelIndex());  // send signal
        }
 
        void ResetUpdateLock()
        {
          updateLock_ = false;
        }
 
        void RemoveNodeMap()
        {
          nodeMap_.reset();
          nodeMap_ = nullptr;
        }
 
      private:
        bool ScanNodeMap()
        {
          if (nodeMap_)
          {
            if (!rootProperty_)
            {
              auto rootNode = nodeMap_->Node<CategoryNode>(CVB_LIT("Root"));
              rootProperty_ = new CategoryProperty(rootNode, nullptr);
              WalkTree(rootNode, rootProperty_, 1);
              return true;
            }
            else
            {
              beginResetModel();
              auto rootNode = rootProperty_->Node();
              WalkTree(rootNode, rootProperty_, 1);
              endResetModel();
              return true;
            }
          }
          return false;
        }
 
        void WalkTree(const NodePtr &parentNode, Private::Property *parentProperty,
                      int depth)  // NOLINT(misc-no-recursion)
        {
          if (depth >= maxDepth_)
            return;
 
          auto children      = Children(parentNode);
          auto excludedNodes = ExcludedNodes(children);
          int childCount     = 0;
 
          for (int i = 0; i < children.size(); i++)
          {
            auto child = children.at(i);
            if (child == nullptr)
              continue;
 
            // Does the node property already exist?
            auto pos = parentProperty->FindChildProperty(child);
 
            if (pos > -1)  // Property exists
            {
              if (!IsValid(child) || !IsVisible(child, MaxVisibility()))  // delete
              {
                parentProperty->RemoveChild(pos);
              }
              else  // keep and check sub nodes if available
              {
                if (auto category = std::dynamic_pointer_cast<CategoryNode>(child))
                  WalkTree(category, parentProperty->ChildProperty(pos), depth + 1);
                else if (auto selector = std::dynamic_pointer_cast<SelectorNode>(child))
                  WalkTree(selector, parentProperty->ChildProperty(pos), depth + 1);
 
                childCount = pos;
                ++childCount;
              }
            }
            else  // Property does not exist
            {
              if (!IsValid(child) || !IsVisible(child, MaxVisibility()))  // skip
                continue;
              if (excludedNodes.contains(Cvb::UI::CvbToQt(child->Name())))  // skip
                continue;
 
              auto p = CreateProperty(child, parentProperty);  // create
 
              if (p)
              {
                parentProperty->InsertChild(childCount, p);
                ++childCount;
                QObject::connect(p, &Property::NodeUpdated, [=](Private::Property *property) {
                  auto index = Index(property, QModelIndex());
                  dataChanged(index, index);  // send signal
                });
 
                QObject::connect(p, &Property::TimeoutOccurred, [=]() { updateLock_ = true; });
 
                if (auto category = std::dynamic_pointer_cast<CategoryNode>(child))
                  WalkTree(category, p, depth + 1);
                else if (auto selector = std::dynamic_pointer_cast<SelectorNode>(child))
                  WalkTree(selector, p, depth + 1);
              }
            }
          }
        }
 
        QVector<NodePtr> Children(const NodePtr &parentNode) const
        {
          QVector<NodePtr> children;
          if (auto catNode = std::dynamic_pointer_cast<CategoryNode>(parentNode))
          {
            std::vector<NodePtr> categoryNodes = catNode->Nodes();
            for (std::size_t i = 0; i < categoryNodes.size(); i++)
              children.push_back(categoryNodes.at(i));
          }
          else if (auto selNode = std::dynamic_pointer_cast<SelectorNode>(parentNode))
          {
            auto selectedNodes = selNode->SelectedNodes();
            for (std::size_t i = 0; i < selectedNodes.size(); i++)
              children.push_back(selectedNodes.at(i));
          }
          return children;
        }
 
        QSet<QString> ExcludedNodes(QVector<NodePtr> nodelist) const
        {
          QSet<QString> excluded;
          for (int i = 0; i < nodelist.size(); i++)
          {
            auto node = nodelist.at(i);
            if (node)
            {
              if (!node->IsFeature() || !node->IsImplemented())
                continue;
            }
 
            if (auto nodeSelector = std::dynamic_pointer_cast<SelectorNode>(node))
            {
              auto selectedNodes = nodeSelector->SelectedNodes();
              for (std::size_t j = 0; j < selectedNodes.size(); j++)
              {
                auto selectedNode = selectedNodes.at(j);
                if (selectedNode)
                {
                  if (selectedNode->IsFeature())
                    excluded.insert(Cvb::UI::CvbToQt(selectedNode->Name()));
                }
              }
            }
          }
          return excluded;
        }
 
        Private::Property *CreateProperty(const NodePtr &node, Private::Property *parent)
        {
          if (!IsValid(node) || !IsVisible(node, MaxVisibility()))
            return nullptr;
 
          if (auto catNode = std::dynamic_pointer_cast<CategoryNode>(node))
            return new CategoryProperty(catNode, parent);
          else if (auto strNode = std::dynamic_pointer_cast<StringNode>(node))
            return new StringProperty(strNode, parent);
          else if (auto cmdNode = std::dynamic_pointer_cast<CommandNode>(node))
            return new CommandProperty(cmdNode, parent);
          else if (auto fNode = std::dynamic_pointer_cast<FloatNode>(node))
            return new FloatProperty(fNode, parent);
          else if (auto boolNode = std::dynamic_pointer_cast<BooleanNode>(node))
            return new BooleanProperty(boolNode, parent);
          else if (auto enumNode = std::dynamic_pointer_cast<EnumerationNode>(node))
            return new EnumProperty(enumNode, parent);
          else if (auto iNode = std::dynamic_pointer_cast<IntegerNode>(node))
            return new IntegerProperty(iNode, parent);
 
          return nullptr;
        }
 
        static bool IsValid(const NodePtr &node)
        {
          return !(!node || node->Visibility() == Visibility::Invisible || node->IsDeprecated()
                   || !node->IsImplemented());
        }
 
        QModelIndex Index(Private::Property *property, const QModelIndex &parent) const  // NOLINT(misc-no-recursion)
        {
          int numRows = rowCount(parent);
          for (int row = 0; row < numRows; ++row)
          {
            auto index = this->index(row, 0, parent);
            auto prop  = Item(index);
            if (prop == property)
              return index;
 
            Index(prop, index);
          }
 
          return QModelIndex();
        }
 
        static bool IsVisible(const NodePtr &node, Visibility maxVisibility = Visibility::Guru)
        {
          return IsVisible(node ? node->Visibility() : Visibility::Invisible, maxVisibility);
        }
 
        static bool IsVisible(Visibility visibility, Visibility maxVisibility = Visibility::Guru)
        {
          return visibility != Visibility::Invisible && visibility <= maxVisibility;
        }
 
        void Clear()
        {
          // Reset search text
          searchText_ = "";
 
          // Clear the model
          beginResetModel();
          removeColumns(0, 2);
          delete rootProperty_;
          rootProperty_ = NULL;
          endResetModel();
        }
 
      private:
        const int maxDepth_       = 20;
        const int defaultColumns_ = 2;
        Private::Property *rootProperty_;
        GenApi::Visibility maxVisibility_;
        GenApi::NodeMapPtr nodeMap_;
        QString searchText_;
        QColor searchResultBGColor_;
        bool updateLock_;
        const QString pollingImg_ = QString(
            "iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/"
            "9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAA3ZpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADw/"
            "eHBhY2tldCBiZWdpbj0i77u/"
            "IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+"
            "IDx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDUuNi1jMTExIDc5LjE1ODMyNS"
            "wgMjAxNS8wOS8xMC0wMToxMDoyMCAgICAgICAgIj4gPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIy"
            "LXJkZi1zeW50YXgtbnMjIj4gPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1wTU09Imh0dHA6Ly9ucy5hZG9iZS5jb2"
            "0veGFwLzEuMC9tbS8iIHhtbG5zOnN0UmVmPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvc1R5cGUvUmVzb3VyY2VSZWYjIiB4bWxu"
            "czp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iIHhtcE1NOk9yaWdpbmFsRG9jdW1lbnRJRD0ieG1wLmRpZDo5YjExYzFmNC"
            "0yMGVhLWZiNDgtOGVkYi1kN2JlYTA3MDkyZjEiIHhtcE1NOkRvY3VtZW50SUQ9InhtcC5kaWQ6NzU4Q0ZGQjI0MDcxMTFFN0E4NUM5ODMx"
            "RTEwQ0RGOEEiIHhtcE1NOkluc3RhbmNlSUQ9InhtcC5paWQ6NzU4Q0ZGQjE0MDcxMTFFN0E4NUM5ODMxRTEwQ0RGOEEiIHhtcDpDcmVhdG"
            "9yVG9vbD0iQWRvYmUgUGhvdG9zaG9wIENDIDIwMTUgKFdpbmRvd3MpIj4gPHhtcE1NOkRlcml2ZWRGcm9tIHN0UmVmOmluc3RhbmNlSUQ9"
            "InhtcC5paWQ6OWIxMWMxZjQtMjBlYS1mYjQ4LThlZGItZDdiZWEwNzA5MmYxIiBzdFJlZjpkb2N1bWVudElEPSJ4bXAuZGlkOjliMTFjMW"
            "Y0LTIwZWEtZmI0OC04ZWRiLWQ3YmVhMDcwOTJmMSIvPiA8L3JkZjpEZXNjcmlwdGlvbj4gPC9yZGY6UkRGPiA8L3g6eG1wbWV0YT4gPD94"
            "cGFja2V0IGVuZD0iciI/"
            "PjRDl6wAAAL9SURBVHjadFNtSFNRGH7u165Tp9t00805t0ytkD6RMuhDTIqK0sp+REgpRhR9QD+DCPrRnygqLCoqrIj+"
            "FEXQj8KoKMxUFHSllebHdNbmx+Z0H/dup3MXDlf0wOHc+/K+7znP87yHwV9I1RutRlthfbI2s5KAKSIgPMeyA0G/t2nC2X9z3PmjdX4+M/"
            "fBchxMBUvr9Rb76WBYzhMFHjptGmgxpnzTmAkEoRIEX9DruTnU3XZGCs4G4g0YlsPCkg0XxDT9KYE22r21HFvL1iHfZqENOIyM/"
            "cK7lnY8fPoCLvc4BIY0fW15XRWamZ6OnZ6zaHldccUesrG6lrR3fSZzaGh8RM5dvhH/d/"
            "3ykJqTp0lRWSUpXFPeyHK8wtlgKd60a3TFlr2k09FD5mPHwWOkdOd+"
            "EgyF4jFKh2yrOUqUAw15hRWs0VZ0OBSWTdXbK7BsSVGCoKKogloUE2LpmlQcr90HWZKgz7EdYZN1mVWKYNvKN/"
            "xtCFiWAcMwEFWqhPi61auQa84Cq1KX8tSqggyqdq4pKyEpGArDPxOI7Y6vfUhRqxElUWjTNNBr02E1mzDodGXylBbPUquUNR8fWjvw5Vs/"
            "kpJEVNadiPkVDktYvNCOZ3euxujRGeGUIXFSYXI9E1MxfnOw5piQk22EJEewfvVKCIIAWZZRYLeCpbRGxn6CZ7kpPuT3vooKybVvP7YhP8"
            "8Sb6AkPr51CZIkw5xlSLhdp6MXfYNOICJ1sZ7hvgZRJczef/"
            "IcnonJhESDXvdPsYJrjY8gRwl87tG7XMDvdWl0Bl0ggrWO3u8oKy2J8f4fzjfcxrOXb8Az0Zah7tZTnBL0T7rfZ1kXlA6Nue1vmj9Bl56G"
            "bGMmtU+IFYWp5x2OHpy9eD1WnJKiHhnobK4K+CZ/xh9TUmq6xlpcckWl0R5QxLJQAa3mbPA8BzrCGHCOQo4QsFHp/"
            "bCjvZ5evyfhNf4ZHA4Z1vzNerPtkDIkkWjUSK1ieY6boKPX5fO4HrgHeu+FA7PSXM1vAQYAJKlQ2kI6nbwAAAAASUVORK5CYII=");
 
      }; /* class PropertyModel */
 
    } /* namespace Private */
  } /* namespace UI */
 
  CVB_END_INLINE_NS
 
} /* namespace Cvb */