OpenLCP/platform/qt/sacn/multiverseitem.cpp

#include "multiverseitem.h"
#include "multiversemodel.h"
#include "universestatuswidget.h"

#include <QFont>
#include <QMetaEnum>
#include <QMetaType>
#include <QObject>


/**
 * @brief MultiverseItem::MultiverseItem
 * @param universe
 * @param parent
 */
MultiverseItem::MultiverseItem(MultiverseItem* parent,
                               QSacnUniverse* universe,
                               QSacnDiscoveredUniverse *discovery)
  : universe_(universe)
  , discovery_(discovery)
  , parentItem_(parent)
  , override_data_(QVariant())
  , mIndicator(nullptr)
{
  createChildren();

  if(parent)
    parent->appendChild(this);

  if (universe)
    mIndicator = new UniverseStatusWidget(nullptr, universe->get());
}


/**
 * @brief MultiverseItem::~MultiverseItem
 */
MultiverseItem::~MultiverseItem()
{
  delete mIndicator;
  qDeleteAll(childItems_);
}


/**
 * @brief MultiverseItem::appendChild
 * @param item
 */
void MultiverseItem::appendChild(MultiverseItem* item)
{
  childItems_.append(item);
}

/**
 * @brief MultiverseItem::removeChild
 * @param child
 */
void MultiverseItem::removeChild(MultiverseItem* child)
{
  for (int i = 0; i < childItems_.size(); ++i)
    if (childItems_.at(i) == child)
      childItems_.remove(i);
}


/**
 * @brief MultiverseItem::removeChildren
 */
void MultiverseItem::removeChildren()
{
  qDeleteAll(childItems_);
  childItems_.clear();
}


/**
 * @brief MultiverseItem::setOverrideData
 * @param data
 */
void MultiverseItem::setOverrideData(QVariant data)
{
  override_data_ = data;
}


/**
 * @brief MultiverseItem::createChildren
 */
void MultiverseItem::createChildren()
{
  if (!universe_)
    return;

  foreach (const auto & metadata, universe_->sources())
    {
      auto universe = universe_->sourceUniverse(metadata);
      if (universe)
        new MultiverseItem(this, universe);
    }
}


/**
 * @brief MultiverseItem::child
 * @param row
 * @return
 */
MultiverseItem* MultiverseItem::child(int row) const
{
  return (row < 0 || row >= childItems_.size()) ? nullptr : childItems_.at(row);
}


/**
 * @brief MultiverseItem::childCount
 * @return
 */
int MultiverseItem::childCount() const
{
  return childItems_.count();
}


/**
 * @brief MultiverseItem::childRow
 * @param universe
 * @return
 */
int MultiverseItem::childRow(int column, const QVariant &data) const
{
  for (int row = 0; row < childItems_.size(); row++)
    {
      auto childData = childItems_.at(row)->data(column, Qt::EditRole);
      if (data == childData)
        return row;
    }
  return -1;
}


/**
 * @brief MultiverseItem::row
 * @return
 */
int MultiverseItem::row() const
{
  if (parentItem_)
    return parentItem_->childItems_.indexOf(const_cast<MultiverseItem*>(this));
  return 0;
}


/**
 * @brief MultiverseItem::data
 * @param column
 * @return
 */
QVariant MultiverseItem::data(int column, int role) const
{
  switch (role) {
    case Qt::DisplayRole:
      {
        if (!universe_ && !discovery_)
          {
            if (column)
              return QVariant();
            return QString("%1 (%2)").arg(
                  override_data_.toString(),
                  QString::number(childCount()));
          }
        if (universe_)
          {
            switch (static_cast<MultiverseModel::Column>(column))
              {
              case MultiverseModel::Universe:
                return universe_->number();
              case MultiverseModel::Status:
                return mIndicator? mIndicator->toolTip() : QVariant();
              case MultiverseModel::Priority:
                {
                  auto priority = universe_->priority();
                  return priority <= 200 ? priority : QVariant();
                }
              case MultiverseModel::Channels:
                {
                  auto active = universe_->activeSlots();
                  return active ? active - 1 : QVariant();
                }
              case MultiverseModel::SourceName:
                return universe_->sourceName();
              default:
                return QVariant();
              }
          }
        if (discovery_)
          {
            switch (static_cast<MultiverseModel::Column>(column))
              {
              case MultiverseModel::Universe:
                return discovery_->universe;
              case MultiverseModel::SourceName:
                return QString::fromUtf8(discovery_->description.c_str());
              default:
                return QVariant();
              }
          }
      }
    case Qt::FontRole:
      {
        QFont font;
        if (!universe_ && !discovery_)
          {
            font.setBold(true);
            return font;
          }
        if (universe_ && !universe_->isEditable())
          {
            switch (universe_->status())
              {
              case sACN::Universe::DMX_NULL:
                font.setItalic(true);
                return font;
//              case sACN::Universe::DMX_ACTIVE:
//                font.setWeight(QFont::Medium);
//                return font;
              case sACN::Universe::DMX_LOST:
                font.setWeight(QFont::Light);
                return font;
              case sACN::Universe::sACN_TERMINATED:
                font.setWeight(QFont::Light);
                font.setItalic(true);
                return font;
              default:
                return QVariant();
              }
          }
        return QVariant();
      }
    case Qt::EditRole:
      if (universe_)
        {
        if (!universe_->isEditable())
          return QVariant::fromValue(universe_);
        switch (static_cast<MultiverseModel::Column>(column))
          {
          case MultiverseModel::Priority:
            return universe_->priority();
          default:
            return QVariant::fromValue(universe_);
          }
        }
      if (discovery_)
        return QVariant::fromValue(discovery_);
      return data(column, Qt::DisplayRole);
    default:
      return QVariant();
    }
}


/**
 * @brief MultiverseItem::setData
 * @param column
 * @param value
 * @param role
 * @return
 */
bool MultiverseItem::setData(int column, const QVariant &value, int role)
{
    if (!universe_->isEditable())
        return false;

    if (role != Qt::EditRole)
        return false;

    switch (column)
    {
    case MultiverseModel::Priority:
    {
        if (!value.canConvert<uint>())
            return false;
        auto p = value.toUInt();
        if (p < 0 || p > 200)
            return false;
        universe_->setPriority(p);
        return true;
    }
    default:
        return false;
    }
}



/**
 * @brief MultiverseItem::flags
 * @param column
 * @return
 */
Qt::ItemFlags MultiverseItem::flags(int column, Qt::ItemFlags base) const
{
  if (!universe_ && !discovery_)
    {
      if (column)
        return Qt::NoItemFlags;
      return base & ~Qt::ItemIsSelectable;
    }

  switch (static_cast<MultiverseModel::Column>(column))
    {
    case MultiverseModel::Universe:
    case MultiverseModel::Status:
    case MultiverseModel::Channels:
    case MultiverseModel::SourceName:
      return base;
    case MultiverseModel::Priority:
      if (universe_ && universe_->isEditable())
        return base | Qt::ItemIsEditable;
      else
        return base;
    default:
      return Qt::NoItemFlags;
    }
}


/**
 * @brief MultiverseItem::parentItem
 * @return
 */
MultiverseItem * MultiverseItem::parentItem() const
{
  return parentItem_;
}