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:

VariantDelegate(QObject* parent = 0)
  : QStyledItemDelegate(parent)
{
  finishedMapper_ = new QSignalMapper(this);
  QObject::connect(finishedMapper_, SIGNAL(mapped(QWidget*)), this, SIGNAL(commitData(QWidget*)));
  QObject::connect(finishedMapper_, SIGNAL(mapped(QWidget*)), this, SIGNAL(closeEditor(QWidget*)));
}

~VariantDelegate() = default;

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)
{
  // Allow only single selection and remove editor after focus change
  setSelectionMode(QAbstractItemView::SingleSelection);
  setContextMenuPolicy(Qt::CustomContextMenu);

  propertyModel_ = new UI::Private::PropertyModel();

  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);
  QObject::connect(updateTimer_, &QTimer::timeout, [=]()
  {
    update();
  });
}


~PropertyGrid()
{
  if (propertyModel_)
    delete propertyModel_;
}


void SetNodeMap(const NodeMapPtr & nodemap)
{
  propertyModel_->SetNodeMap(nodemap);

  setModel(propertyModel_);
  setItemDelegate(new VariantDelegate(this));
  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)
{
  // 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)
{
  // 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(CategoryNode))
  {
    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())
  {
  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());
  }

  return txt;
}

private:
  static const int maxColumnWidth_ = 180;
  UI::Private::PropertyModel* propertyModel_;
  QTimer* updateTimer_;

};  /* class PropertyGrid */



} /* namespace UI */


CVB_END_INLINE_NS

} /* namespace Cvb */