detail_enum_property.hpp

#pragma once
 
#pragma warning(push)
#pragma warning(disable : 4800)
#pragma warning(disable : 4251)
#pragma warning(disable : 4244)
#include <QComboBox>
#include <QStringList>
#include <QEvent>
#pragma warning(pop)
 
#include "../../global.hpp"
#include "../../genapi/value_node.hpp"
#include "../../genapi/enumeration_node.hpp"
#include "../../genapi/enum_entry_node.hpp"
#include "detail_property.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace UI
  {
    namespace Private
    {
 
      class EnumProperty : public Private::Property
      {
 
        Q_OBJECT
 
      public:
        EnumProperty(const ValueNodePtr &node, Property *parent)
            : Property(node, PT_Enumeration, parent)
        {
          RetrieveEntries();
        }
 
        QWidget *CreateEditor(QWidget *parent) override
        {
          auto enumNode = std::dynamic_pointer_cast<EnumerationNode>(Node());
          if (enumNode && enumNode->IsAvailable())
          {
            auto editor = new QComboBox(parent);  // NOLINT(cppcoreguidelines-owning-memory)
            editor->addItems(entriesList_);
            auto dispName = DisplayNameForSymbolicValue(UI::CvbToQt(enumNode->Value()));
            editor->setCurrentIndex(IndexForDisplayName(dispName));
 
            QObject::connect(editor, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
                             [=](int index) { SetValue(index); });
 
            return editor;
          }
          return EmptyEditor();
        }
 
        bool SetEditorData(QWidget *editor, const QVariant &data) override
        {
          if (auto cb = qobject_cast<QComboBox *>(editor))
          {
            cb->setCurrentIndex(cb->findText(data.toString()));
            return true;
          }
          return false;
        }
 
        QVariant EditorData(QWidget *editor) override
        {
          if (auto cb = qobject_cast<QComboBox *>(editor))
          {
            return QVariant(cb->currentText());
          }
          else
          {
            return QVariant();
          }
        }
 
        QVariant Value(int column, int role = Qt::UserRole) override
        {
          switch (role)
          {
            case Qt::DisplayRole:
            {
              if (column == 0)
                return Data(column, role);
 
              auto enumNode = std::dynamic_pointer_cast<EnumerationNode>(Node());
              if (enumNode && enumNode->IsAvailable())
              {
                auto dispName = DisplayNameForSymbolicValue(UI::CvbToQt(enumNode->Value()));
                return QVariant(dispName);
              }
              return QVariant("-");
            }
          }
          return QVariant();
        }
 
        void SetValue(const QVariant &value) override
        {
          auto enumNode = std::dynamic_pointer_cast<EnumerationNode>(Node());
          if (enumNode && enumNode->IsAvailable())
          {
            auto curDispName = entriesList_.at(value.toInt());
            try
            {
              enumNode->SetValue(UI::QtToCvb(SymbolicValueForDisplayName(curDispName)));
            }
            catch (const CvbException &)
            {
              // ignore the exception
            }
          }
        }
 
        QString HtmlDescription() override
        {
          auto txt = QString("<table><tr><td><b>Entries:</b></td></tr>");
          txt.append("<table border=1 cellspacing=\"0\" cellpadding=\"5\">");
          txt.append(
              "<tr><th align=\"left\"><b>Display Name</b></th><th align=\"left\"><b>Symbolic</b></th><th "
              "align=\"left\"><b>Integer</b></th><th align=\"left\"><b>ToolTip</b></b></th></tr>");
 
          QMap<int64_t, QStringList>::const_iterator i = entriesMap_.constBegin();
          while (i != entriesMap_.constEnd())
          {
            auto nInfo   = i.value();
            auto tooltip = nInfo.at(2);
            if (tooltip.isEmpty())
              tooltip = "-";
            txt.append("<tr><td>" + nInfo.at(0) + "</td><td>" + nInfo.at(1) + "</td><td>" + QString::number(i.key())
                       + "</td><td>" + tooltip + "</td></tr>");
 
            ++i;
          }
 
          txt.append("</table></table>");
          return txt;
        }
 
      private:
        void RetrieveEntries()
        {
          auto enumNode = std::dynamic_pointer_cast<EnumerationNode>(Node());
 
          if (enumNode)
          {
            entriesList_.clear();
            entriesMap_.clear();
 
            auto entries = enumNode->Entries();
 
            for (std::size_t i = 0; i < entries.size(); i++)
            {
              auto entry = entries.at(i);
              if (entry->IsAvailable())
              {
                entriesList_.append(UI::CvbToQt(entry->DisplayName()));
 
                QStringList entryInfo;
                entryInfo << UI::CvbToQt(entry->DisplayName()) << UI::CvbToQt(entry->SymbolicValue())
                          << UI::CvbToQt(entry->ToolTip());
                entriesMap_.insert(entry->NumericValue(), entryInfo);
              }
            }
          }
        }
 
        QString SymbolicValueForDisplayName(const QString &name)
        {
          QMap<int64_t, QStringList>::const_iterator iter = entriesMap_.constBegin();
          while (iter != entriesMap_.constEnd())
          {
            auto lst = iter.value();
            if (lst.at(0) == name)
              return lst.at(1);
 
            ++iter;
          }
 
          return QString("");
        }
 
        QString DisplayNameForSymbolicValue(const QString &symbolicValue)
        {
          RetrieveEntries();
 
          QMap<int64_t, QStringList>::const_iterator iter = entriesMap_.constBegin();
          while (iter != entriesMap_.constEnd())
          {
            auto lst = iter.value();
            if (lst.at(1) == symbolicValue)
              return lst.at(0);
            ++iter;
          }
          return QString("");
        }
 
        int IndexForDisplayName(const QString &displayName)
        {
          for (int i = 0; i < entriesList_.size(); i++)
          {
            if (entriesList_.at(i) == displayName)
              return i;
          }
 
          return -1;
        }
 
      private:
        QStringList entriesList_;
        QMap<int64_t, QStringList> entriesMap_;
 
      }; /* class EnumProperty */
 
    } /* namespace Private */
  } /* namespace UI */
 
  CVB_END_INLINE_NS
 
} /* namespace Cvb */