property_grid.hpp

#pragma once
 
#pragma warning(push)
#pragma warning(disable : 4800)
#pragma warning(disable : 4251)
#pragma warning(disable : 4244)
#pragma warning(disable : 4127)
#include <QTreeView>
#include <QStyledItemDelegate>
#include <QSignalMapper>
#include <QPainter>
#include <QApplication>
#include <QEvent>
#include <QTimer>
#pragma warning(pop)
 
#include "../global.hpp"
#include "../genapi/node_map.hpp"
#include "../genapi/genapi.hpp"
#include "_detail/detail_property_model.hpp"
 
 
namespace Cvb
{
 
CVB_BEGIN_INLINE_NS
 
namespace UI
{
 
class VariantDelegate
  : public QStyledItemDelegate
{
 
Q_OBJECT
 
public:
 
explicit VariantDelegate(QObject* parent = 0)
  : QStyledItemDelegate(parent)
  , finishedMapper_(nullptr)
{
  finishedMapper_ = new QSignalMapper(this); // NOLINT
  QObject::connect(finishedMapper_, SIGNAL(mapped(QWidget*)), this, SIGNAL(commitData(QWidget*)));
  QObject::connect(finishedMapper_, SIGNAL(mapped(QWidget*)), this, SIGNAL(closeEditor(QWidget*)));
}
 
 
QWidget* createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const override
{
  QWidget* editor = 0;
 
  auto prop = static_cast<UI::Private::Property*>(index.internalPointer());
  if (prop)
  {
    switch (prop->Type())
    {
    case UI::Private::Property::PT_Boolean:
    case UI::Private::Property::PT_Category:
    case UI::Private::Property::PT_Command:
    case UI::Private::Property::PT_Enumeration:
    case UI::Private::Property::PT_Float:
    case UI::Private::Property::PT_Integer:
    case UI::Private::Property::PT_String:
      editor = prop->CreateEditor(parent);
      if (editor)
      {
        if (editor->metaObject()->indexOfSignal("editingFinished()") != -1)
        {
          QObject::connect(editor, SIGNAL(editingFinished()), finishedMapper_, SLOT(map()));
          finishedMapper_->setMapping(editor, editor);
        }
        break;
      }
      // else
      // if no editor could be created take default case
    default:
      editor = QStyledItemDelegate::createEditor(parent, option, index);
    }
  }
 
  return editor;
}
 
 
void setEditorData(QWidget * /*editor*/, const QModelIndex & /*index*/) const override
{
  // Do nothing, only override setEditorData function
}
 
void setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const override
{
  auto data = index.model()->data(index, Qt::EditRole);
  if (data.type() == QVariant::UserType)
  {
    data = static_cast<UI::Private::Property*>(index.internalPointer())->EditorData(editor);
    if (data.isValid())
    {
      model->setData(index, data, Qt::EditRole);
    }
  }
  else
    QStyledItemDelegate::setModelData(editor, model, index);
}
 
void updateEditorGeometry(QWidget *editor, const QStyleOptionViewItem &option, const QModelIndex &index) const override
{
  return QStyledItemDelegate::updateEditorGeometry(editor, option, index);
}
 
void paint(QPainter *painter, const QStyleOptionViewItem & option, const QModelIndex & index) const override
{
  painter->save();
  painter->setPen(QColor(Qt::gray));
 
  auto prop = static_cast<UI::Private::Property*>(index.internalPointer());
  if (prop->Type() == UI::Private::Property::PT_Category)
  {
    painter->fillRect(option.rect, QApplication::palette("QTreeView").brush(QPalette::Normal, QPalette::Button).color());
  }
  else
  {
    if (index.column() == 0)
      painter->drawLine(option.rect.topRight(), option.rect.bottomRight());
  }
 
  painter->drawLine(option.rect.bottomLeft(), option.rect.bottomRight());
  painter->restore();
 
  QStyledItemDelegate::paint(painter, option, index);
}
 
private:
 
QSignalMapper*  finishedMapper_;
};
 
 
 
 
 
class PropertyGrid
  : public QTreeView
{
 
Q_OBJECT
 
public:
 
 
explicit PropertyGrid(const NodeMapPtr & nodemap, QWidget *parent = nullptr)
  : QTreeView(parent)
  , propertyModel_(nullptr)
  , updateTimer_(nullptr)
{
  // Allow only single selection and remove editor after focus change
  setSelectionMode(QAbstractItemView::SingleSelection);
  setContextMenuPolicy(Qt::CustomContextMenu);
 
  propertyModel_ = new UI::Private::PropertyModel(); // NOLINT
 
  try
  {
    SetNodeMap(nodemap);
  }
  catch (const std::exception&)
  {
    delete propertyModel_;
    throw;
  }
 
  // At click create editor (otherwise double click is necessary)
  QObject::connect(this, QOverload<const QModelIndex &>::of(&PropertyGrid::clicked), [=](const QModelIndex & index)
  {
    // Do not call editing on items with no editor (return EmptyEditor())
    // otherwise error message "edit: editing failed" occurs
    auto prop = propertyModel_->Property(index);
    if (prop)
    {
      if (!prop->IsReadOnly() && prop->Type() != UI::Private::Property::PT_Boolean)
        edit(index);
    }
  });
 
  // Init the update timer
  updateTimer_ = new QTimer(this); // NOLINT(cppcoreguidelines-owning-memory)
  QObject::connect(updateTimer_, &QTimer::timeout, [=]()
  {
    update();
  });
}
 
 
PropertyGrid(const PropertyGrid& other) = delete;
PropertyGrid& operator=(const PropertyGrid& other) = delete;
PropertyGrid(PropertyGrid&& other) = delete;
PropertyGrid& operator=(PropertyGrid&& other) = delete;
~PropertyGrid()
{
  if (propertyModel_)
    delete propertyModel_;
}
 
 
void SetNodeMap(const NodeMapPtr & nodemap)
{
  propertyModel_->SetNodeMap(nodemap);
 
  setModel(propertyModel_);
  setItemDelegate(new VariantDelegate(this)); // NOLINT(cppcoreguidelines-owning-memory)
  resizeColumnToContents(0);
 
  if (columnWidth(0) < maxColumnWidth_)
    setColumnWidth(0, maxColumnWidth_);
}
 
 
NodeMapPtr NodeMap()
{
  return propertyModel_->NodeMap();
}
 
 
void ReleaseNodeMap()
{
  propertyModel_->RemoveNodeMap();
  setModel(0);
}
 
 
void SetVisibility(GenApi::Visibility visibility)
{
  propertyModel_->SetMaxVisibility(visibility);
}
 
 
GenApi::Visibility Visibility()
{
  return propertyModel_->MaxVisibility();
}
 
 
QString HtmlFormattedDescription(const QModelIndex & index)
{
  return HtmlDescription(index);
}
 
 
QModelIndexList Search(const QString & text)
{
  return propertyModel_->Search(text);
}
 
 
void ResetSearch()
{
  propertyModel_->ResetSearch();
}
 
 
QString SearchText()
{
  return propertyModel_->SearchText();
}
 
 
void SetSearchResultBackgroundColor(QColor color)
{
  propertyModel_->SetSearchResultBGColor(color);
}
 
 
QColor SearchResultBackgroundColor()
{
  return propertyModel_->SearchResultBGColor();
}
 
 
NodePtr Node(const QModelIndex & index)
{
  return propertyModel_->Item(index)->Node();
}
 
 
void ExpandSearchResult(const QModelIndexList & indexList)
{
  for (int i = 0; i < indexList.size(); i++)
    ExpandProperty(indexList.at(i));
}
 
 
void CollapseSearchResult(const QModelIndexList & indexList)
{
  for (int i = 0; i < indexList.size(); i++)
    CollapseProperty(indexList.at(i));
}
 
 
void UpdateProperty(const QModelIndex & index)
{
  propertyModel_->UpdateProperty(index);
}
 
 
void Update()
{
  propertyModel_->Update();
}
 
 
void StartAutoUpdate(int ms)
{
  updateTimer_->start(ms);
}
 
 
void StopAutoUpdate()
{
  updateTimer_->stop();
}
 
 
void ResetUpdateLock()
{
  propertyModel_->ResetUpdateLock();
}
 
private:
 
void ExpandProperty(const QModelIndex & index) // NOLINT(misc-no-recursion)
{
  // Expand the node
  setExpanded(index, true);
  scrollTo(index);
 
  // Get the parent node
  auto parentIndex = propertyModel_->parent(index);
 
  if (parentIndex != QModelIndex()) // is not root
    ExpandProperty(parentIndex);
}
 
void CollapseProperty(const QModelIndex & index) // NOLINT(misc-no-recursion)
{
  // Collapse the node
  setExpanded(index, false);
 
  // Get the parent node
  auto parentIndex = propertyModel_->parent(index);
 
  if (parentIndex != QModelIndex()) // is not root
    CollapseProperty(parentIndex);
}
 
QString HtmlDescription(const QModelIndex & index)
{
  auto prop = propertyModel_->Item(index);
 
  if (!prop)
    return QString();
 
  auto node = prop->Node();
 
  QString txt = "<b>" + UI::CvbToQt(node->DisplayName()) + " (" + UI::CvbToQt(node->Name()) + ")</b>";
  if (!node->Description().empty())
    txt.append("<br>" + UI::CvbToQt(node->Description()));
 
  txt.append("<br><table>");
  txt.append("<tr><td><b>Full Name:</b></td><td>" + UI::CvbToQt(node->Name()));
 
  if (typeid(node) != typeid(CategoryNodePtr))
  {
    txt.append("<tr><td><b>Type:</b></td><td>" + UI::CvbToQt(prop->NodeType()) + "</td></tr>");
    txt.append("<tr><td><b>Access Mode:</b></td><td>" + UI::CvbToQt(prop->NodeAccessMode()) + "</td></tr>");
    txt.append("<tr><td><b>Visibility:</b></td><td>" + UI::CvbToQt(prop->NodeVisibility()) + "</td></tr>");
    txt.append("<tr><td><b>Caching Mode:</b></td><td>" + UI::CvbToQt(prop->NodeCachingMode()) + "</td></tr>");
    if (prop->NodeIsStreamable())
      txt.append("<tr><td><b>Streamable:</b></td><td>True</td></tr>");
    else
      txt.append("<tr><td><b>Streamable:</b></td><td>False</td></tr>");
  }
  txt.append("</table>");
 
  switch (prop->Type())
  {
  default:
    break;
  case UI::Private::Property::PropertyType::PT_Integer:
  case UI::Private::Property::PropertyType::PT_Float:
  case UI::Private::Property::PropertyType::PT_String:
  case UI::Private::Property::PropertyType::PT_Enumeration:
    txt.append(prop->HtmlDescription());
    break;
  }
 
  return txt;
}
 
private:
  static const int maxColumnWidth_ = 180;
  UI::Private::PropertyModel* propertyModel_;
  QTimer* updateTimer_;
 
};  /* class PropertyGrid */
 
 
 
} /* namespace UI */
 
 
CVB_END_INLINE_NS
 
} /* namespace Cvb */