subtreeproxy.cpp

Go to the documentation of this file.

// DUNE DAQ modification notice:
// This file has been modified from the original ATLAS dbe source for the DUNE DAQ project.
// Fork baseline commit: dbe-02-12-17 (2022-05-12).
// Renamed since fork: no.

#include "dbe/subtreeproxy.hpp"
#include "dbe/confaccessor.hpp"
#include "dbe/config_ui_info.hpp"
#include "dbe/messenger.hpp"
#include "dbe/tree.hpp"
#include "dbe/treenode.hpp"
 
dbe::models::subtree_proxy::subtree_proxy(const QString& Name, const QStringList& Default, QObject* parent)
  : QSortFilterProxyModel(parent)
  , this_gui_windowname(Name)
  , this_default_filter(Default)
  , this_apply_default_filter(false)
{
  check_view_type();
  model_common_connections();
}
 
dbe::models::subtree_proxy::~subtree_proxy() {}
 
void
dbe::models::subtree_proxy::ResetModel()
{
  beginResetModel();
  endResetModel();
}
 
bool
dbe::models::subtree_proxy::filterAcceptsRow(int source_row, const QModelIndex& source_parent) const
{
  if (this_apply_default_filter) {
    return ApplyDefaultFilter(source_row, source_parent);
  } else {
    return ApplyUserFilter(source_row, source_parent);
  }
}
 
bool
dbe::models::subtree_proxy::lessThan(const QModelIndex& left, const QModelIndex& right) const
{
  if (left.parent() == QModelIndex() || left.parent().parent() == QModelIndex()) {
    QVariant LeftData = sourceModel()->data(left);
    QVariant RightData = sourceModel()->data(right);
 
    switch (LeftData.type()) {
      case QVariant::Bool:
      case QVariant::UInt:
        return (LeftData.toUInt() < RightData.toUInt());
 
      case QVariant::Int:
        return (LeftData.toInt() < RightData.toInt());
 
      case QVariant::String:
        return ((LeftData.toString()).compare(RightData.toString()) > 0);
 
      default:
        return false;
    }
 
    return true;
  }
 
  return false;
}
 
void
dbe::models::subtree_proxy::check_view_type()
{
  this_window_config = confaccessor::guiconfig()->window(this_gui_windowname.toStdString());
 
  if (this_window_config.Title.isEmpty()) {
    this_apply_default_filter = true;
  }
}
 
void
dbe::models::subtree_proxy::LoadClasses()
{
  if (this_apply_default_filter == false) {
    for (QString const& i : this_window_config.GraphicalClassesList) {
      GraphicalClass Class = confaccessor::guiconfig()->graphical(i.toStdString());
      QStringList ClassList = Class.DerivedClasses;
      ClassList.append(Class.DatabaseClassName);
 
      for (QString& ClassName : ClassList) {
        treenode* ClassNode = confaccessor::gethandler()->getnode(ClassName);
 
        if (ClassNode) {
          dbe::models::tree* UnderlyingModel = static_cast<dbe::models::tree*>(sourceModel());
          QModelIndex ParentIndex = UnderlyingModel->getindex(ClassNode);
 
          if (sourceModel()->canFetchMore(ParentIndex))
            sourceModel()->fetchMore(ParentIndex);
        }
      }
    }
  }
}
 
dbe::tref
dbe::models::subtree_proxy::getobject(const QModelIndex& index) const
{
  if (index.isValid()) {
    QModelIndex sourceParent = mapToSource(index);
    dbe::models::tree* my = dynamic_cast<dbe::models::tree*>(sourceModel());
 
    if (my) {
      return my->getobject(sourceParent);
    }
  }
 
  throw daq::dbe::cannot_handle_invalid_qmodelindex(ERS_HERE);
}
 
dbe::treenode*
dbe::models::subtree_proxy::getnode(const QModelIndex& index) const
{
  QModelIndex sourceParent = mapToSource(index);
  dbe::models::tree* my = dynamic_cast<dbe::models::tree*>(sourceModel());
 
  if (my) {
    return my->getnode(sourceParent);
  }
 
  return nullptr;
}
 
dunedaq::conffwk::class_t
dbe::models::subtree_proxy::getclass(const QModelIndex& index) const
{
  QModelIndex sourceParent = mapToSource(index);
  dbe::models::tree* my = dynamic_cast<dbe::models::tree*>(sourceModel());
 
  if (my) {
    return my->getclass(sourceParent);
  }
 
  return dunedaq::conffwk::class_t();
}
 
QAbstractItemModel*
dbe::models::subtree_proxy::ReturnSourceModel() const
{
  return sourceModel();
}
 
bool
dbe::models::subtree_proxy::ApplyDefaultFilter(int source_row, const QModelIndex& source_parent) const
{
  Q_UNUSED(source_row)
  Q_UNUSED(source_parent)
 
  return true;
}
 
bool
dbe::models::subtree_proxy::ApplyUserFilter(int source_row, const QModelIndex& source_parent) const
{
  dbe::models::tree* srcmodel = static_cast<tree*>(sourceModel());
 
  QModelIndex const& nodeindex = srcmodel->index(source_row, 0, source_parent);
  treenode* tofilter = srcmodel->getnode(nodeindex);
  QString const nodename = srcmodel->data(nodeindex).toString();
 
  if (not source_parent.isValid()) {
 
    for (QString const& admissible : this_window_config.GraphicalClassesList) {
      GraphicalClass candidate = confaccessor::guiconfig()->graphical(admissible.toStdString());
 
      if (candidate.DatabaseClassName == nodename or candidate.DerivedClasses.contains(nodename)) {
        return true;
      }
    }
  } else if (dynamic_cast<ObjectNode*>(tofilter)) {
    return true;
  } else if (dynamic_cast<RelationshipNode*>(tofilter)) {
    QString const related = sourceModel()->data(nodeindex.parent().parent()).toString();
 
    for (QString const& admissible : this_window_config.GraphicalClassesList) {
      GraphicalClass candidate = confaccessor::guiconfig()->graphical(admissible.toStdString());
 
      if (candidate.DatabaseClassName == related or candidate.DerivedClasses.contains(related)) {
        return candidate.ShowAllRelationships or candidate.Relationships.contains(nodename);
      }
    }
  }
 
  return false;
}
//----------------------------------------------------------------------------------------------------
 
//----------------------------------------------------------------------------------------------------
MODEL_COMMON_INTERFACE_LOOKUP_IMPL(dbe::models::subtree_proxy)
{
  if (treenode* classnode = confaccessor::gethandler()->getnode(QString::fromStdString(obj.class_name()))) {
 
    auto found = [&obj, classnode](int i) {
      return obj.UID() == classnode->GetChild(i)->GetData(0).toString().toStdString();
    };
 
    int i = 0;
    int const childs = classnode->ChildCount();
 
    for (; i < childs and not found(i); ++i)
      ;
 
    return i == childs ? QModelIndex() : index(i, 0, QModelIndex());
  }
 
  return QModelIndex();
}
 
MODEL_COMMON_INTERFACE_CREATE_THAT_OBJ_IMPL(dbe::models::subtree_proxy)
{
  // TODO implement create object from signal for Subtreeproxymodel
  Q_UNUSED(index);
  Q_UNUSED(obj);
}
 
MODEL_COMMON_INTERFACE_DELETE_THAT_OBJ_IMPL(dbe::models::subtree_proxy)
{
  if (index.isValid()) {
    this->removeRows(index.row(), 1, index.parent());
  }
}
 
MODEL_COMMON_INTERFACE_RENAME_THAT_OBJ_IMPL(dbe::models::subtree_proxy)
{
  // TODO implement rename object
  Q_UNUSED(index);
  Q_UNUSED(obj);
}
 
MODEL_COMMON_INTERFACE_UPDATE_THAT_OBJ_IMPL(dbe::models::subtree_proxy)
{
  // TODO implement update object from signal for Subtreeproxymodel
  Q_UNUSED(index);
  Q_UNUSED(obj);
}
 
TREEMODEL_REMOVE_ROWS_DEF(dbe::models::subtree_proxy)
MODEL_COMMON_INTERFACE_SLOTS_DEF(dbe::models::subtree_proxy)
//----------------------------------------------------------------------------------------------------