detail_integer_property.hpp

#pragma once
 
#include "../../global.hpp"
#include "../../genapi/value_node.hpp"
#include "../../genapi/integer_node.hpp"
#include "detail_property.hpp"
#include "detail_spinbox_slider.hpp"
#include "detail_custom_lineedit.hpp"
#include "detail_network.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace UI
  {
    namespace Private
    {
 
      inline QMetaType::Type GetTypeId(const QVariant &var)
      {
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
        return static_cast<QMetaType::Type>(var.typeId());
#else
        return static_cast<QMetaType::Type>(var.type());
#endif
      }
 
      class IntegerProperty : public Private::Property
      {
 
        Q_OBJECT
 
      public:
        IntegerProperty(const ValueNodePtr &node, Property *parent)
            : Property(node, PT_Integer, parent)
        {
          // SFNC
          ipList_ << "Std::GevCurrentIPAddress" << "Std::GevCurrentSubnetMask" << "Std::GevCurrentDefaultGateway"
                  << "Std::GevPersistentIPAddress" << "Std::GevPersistentSubnetMask"
                  << "Std::GevPersistentDefaultGateway" << "Std::GevMCDA" << "Std::GevSCDA"
                  << "Std::GevPrimaryApplicationIPAddress";
          // SI
          ipList_ << "Cust::InterfaceSubnetIP" << "Cust::InterfaceSubnetMask" << "Cust::InterfaceGateway"
                  << "Cust::IPCfg_IP" << "Cust::IPCfg_Subnet" << "Cust::IPCfg_Gateway"
                  << "Cust::DeviceIP" << "Cust::DeviceGateway" << "Cust::StreamDestinationIP";
 
          // SFNC
          macList_ << "Std::GevMACAddress";
          // SI
          macList_ << "Cust::GevInterfaceMACAddress" << "Cust::InterfaceMAC" << "Cust::IPCfg_MAC" << "Cust::DeviceMAC";
        }
 
        QWidget *CreateEditor(QWidget *parent) override
        {
          auto intNode = std::dynamic_pointer_cast<IntegerNode>(Node());
 
          if (!intNode)
            return EmptyEditor();
 
          if (!intNode->IsAvailable())
            return EmptyEditor();
 
          auto rep = intNode->Representation();
          if (rep == GenApi::NumberRepresentation::IPv4 || ipList_.contains(UI::CvbToQt(intNode->Name())))
            return CreateIpEditor(intNode, parent);
          else if (rep == GenApi::NumberRepresentation::MAC || macList_.contains(UI::CvbToQt(intNode->Name())))
            return CreateMacEditor(intNode, parent);
          return CreateIntEditor(intNode, parent);
        }
 
        QWidget *CreateIntEditor(const IntegerNodePtr &node, QWidget *parent)
        {
          // No sliders necessary if min == max
          if (node->Min() == node->Max())
          {
            auto editor = new SpinBox64(parent);  // NOLINT(cppcoreguidelines-owning-memory)
            editor->setMinimum(node->Min());
            editor->setMaximum(node->Max());
            editor->setValue(node->Value());
            editor->setSingleStep(node->Increment());
 
            QObject::connect(editor, &SpinBox64::ValueChanged, this, [this](qint64 value) { SetValue(QVariant(value)); });
            return editor;
          }
 
          // Create sliders as well
          auto editor = new SpinBoxSlider64(parent);  // NOLINT(cppcoreguidelines-owning-memory)
          editor->SetMinimum(node->Min());
          editor->SetMaximum(node->Max());
          editor->SetValue(node->Value());
          editor->SetSingleStep(node->Increment());
 
          QObject::connect(editor, &SpinBoxSlider64::ValueChanged, this,
                           [this](qint64 value) { SetValue(QVariant(value)); });
 
          return editor;
        }
 
        QWidget *CreateIpEditor(const IntegerNodePtr &node, QWidget *parent)
        {
          auto editor = new IpLineEdit(parent);  // NOLINT(cppcoreguidelines-owning-memory)
          editor->SetText(QString::fromStdString(IPV4AddressIntToString(static_cast<std::uint32_t>(node->Value()))));
 
          QObject::connect(editor, &IpLineEdit::TextChanged, this,
                           [this](const QString &text) { SetValue(QVariant(text)); });
 
          return editor;
        }
 
        QWidget *CreateMacEditor(const IntegerNodePtr &node, QWidget *parent)
        {
          auto editor = new MacLineEdit(parent);  // NOLINT(cppcoreguidelines-owning-memory)
          MacAddress mac(node->Value());
          editor->SetText(mac.ToQString());
 
          QObject::connect(editor, &MacLineEdit::TextChanged, this,
                           [this](const QString &text) { SetValue(QVariant(text)); });
 
          return editor;
        }
 
        bool SetEditorData(QWidget *editor, const QVariant &data) override
        {
          auto intNode = std::dynamic_pointer_cast<IntegerNode>(Node());
 
          if (!intNode)
            return false;
 
          auto rep = intNode->Representation();
          if (rep == GenApi::NumberRepresentation::IPv4 || ipList_.contains(UI::CvbToQt(intNode->Name())))
          {
            auto le = dynamic_cast<IpLineEdit *>(editor);
            if (le)
            {
              le->SetText(data.toString());
              return true;
            }
          }
          else if (rep == GenApi::NumberRepresentation::MAC || macList_.contains(UI::CvbToQt(intNode->Name())))
          {
            auto le = dynamic_cast<MacLineEdit *>(editor);
            if (le)
            {
              le->SetText(data.toString());
              return true;
            }
          }
          else
          {
            auto sb = dynamic_cast<SpinBoxSlider64 *>(editor);
            if (sb)
            {
              sb->SetValue(data.toInt());
              return true;
            }
          }
          return false;
        }
 
        QVariant EditorData(QWidget *editor) override
        {
          auto intNode = std::dynamic_pointer_cast<IntegerNode>(Node());
 
          auto rep = intNode->Representation();
          if (rep == GenApi::NumberRepresentation::IPv4 || ipList_.contains(UI::CvbToQt(intNode->Name())))
          {
            auto le = dynamic_cast<IpLineEdit *>(editor);
            if (le)
              return QVariant(le->Text());
          }
          else if (rep == GenApi::NumberRepresentation::MAC || macList_.contains(UI::CvbToQt(intNode->Name())))
          {
            auto le = dynamic_cast<MacLineEdit *>(editor);
            if (le)
              return QVariant(le->Text());
          }
          else
          {
            auto sb = dynamic_cast<SpinBoxSlider64 *>(editor);
            if (sb)
              return QVariant(sb->Value());
          }
 
          return QVariant();
        }
 
        QVariant Value(int column, int role = Qt::UserRole) override
        {
          switch (role)
          {
            case Qt::DisplayRole:
            {
              if (column == 0)
                return Data(column, role);
 
              auto intNode = std::dynamic_pointer_cast<IntegerNode>(Node());
              if (intNode && intNode->IsAvailable())
              {
                int32_t intValue = -1;
                try
                {
                  intValue = static_cast<std::uint32_t>(intNode->Value());
                }
                catch (const CvbException &e)
                {
                  if (e.ErrorCode() == ErrorCodes::CVB_TIMEOUT)
                    TimeoutOccurred();  // send signal
                  return QVariant("-");
                }
 
                auto rep = intNode->Representation();
                if (rep == GenApi::NumberRepresentation::IPv4 || ipList_.contains(UI::CvbToQt(intNode->Name())))
                {
                  return QString::fromStdString(IPV4AddressIntToString(intValue));
                }
                else if (rep == GenApi::NumberRepresentation::MAC || macList_.contains(UI::CvbToQt(intNode->Name())))
                {
                  MacAddress mac(intValue);
                  return mac.ToQString();
                }
                else
                {
                  return QVariant::fromValue(intValue);
                }
              }
            }
          }
          return QVariant();
        }
 
        void SetValue(const QVariant &value) override
        {
          if (auto intNode = std::dynamic_pointer_cast<IntegerNode>(Node()))
          {
            auto rep = intNode->Representation();
            if (rep == GenApi::NumberRepresentation::IPv4 || ipList_.contains(UI::CvbToQt(intNode->Name())))
            {
              if (GetTypeId(value) == QMetaType::QString)
              {
                try
                {
                  intNode->SetValue(IPV4AddressStringToInt(value.toString().toStdString()));
                }
                catch (const CvbException &)
                {
                  // ignore the exception
                }
              }
            }
            else if (rep == GenApi::NumberRepresentation::MAC || macList_.contains(UI::CvbToQt(intNode->Name())))
            {
              if (GetTypeId(value) == QMetaType::QString)
              {
                MacAddress mac(value.toString());
                try
                {
                  intNode->SetValue(mac.ToInt64());
                }
                catch (const CvbException &)
                {
                  // ignore the exception
                }
              }
            }
            else
            {
              if (GetTypeId(value) == QMetaType::LongLong)
              {
                try
                {
                  intNode->SetValue(value.toLongLong());
                }
                catch (const CvbException &)
                {
                  // ignore the exception
                }
              }
            }
          }
        }
 
        QString HtmlDescription() override
        {
          if (auto intNode = std::dynamic_pointer_cast<IntegerNode>(Node()))
          {
            auto txt = QString("<br><table>");
            auto min = QString("-");
            auto max = QString("-");
            auto rep = QString("-");
            auto inc = QString("");
 
            auto representation = intNode->Representation();
            if (representation != GenApi::NumberRepresentation::IPv4 && ipList_.contains(UI::CvbToQt(intNode->Name())))
              rep = UI::CvbToQt(NodeRepresentation(GenApi::NumberRepresentation::IPv4));
            else if (representation != GenApi::NumberRepresentation::MAC
                     && macList_.contains(UI::CvbToQt(intNode->Name())))
              rep = UI::CvbToQt(NodeRepresentation(GenApi::NumberRepresentation::MAC));
 
            inc = QString::number(intNode->Increment());
            min = QString::number(intNode->Min());
            max = QString::number(intNode->Max());
 
            txt.append("<tr><td><b>Minimum:</b></td><td align=\"right\">" + min + "</td></tr>");
            txt.append("<tr><td><b>Maximum:</b></td><td align=\"right\">" + max + "</td></tr>");
            if (!inc.isEmpty())
              txt.append("<tr><td><b>Increment:</b></td><td align=\"right\">" + inc + "</td></tr>");
            txt.append("<tr><td><b>Representation:</b></td><td align=\"right\">" + rep + "</td></tr>");
            txt.append("</table>");
            return txt;
          }
          return QString();
        }
 
      private:
        QStringList ipList_;
        QStringList macList_;
 
      }; /* class IntegerProperty */
 
    } /* namespace Private */
  } /* namespace UI */
 
  CVB_END_INLINE_NS
 
} /* namespace Cvb */