qt-migration-legatus/qt6-after/qt6-migrated-legatus/Lts/Viewer/SituationMap/GeometryModel/geometry_pixelTextBox.cpp

/**
  * @RDE_HEADER@
  * PixelTextBoxData as Addon to GeometryModel
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Norbert Thoden, SLSE, 2023-04-27
  */

#include "geometry_pixelTextBox.h"
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonValue>
#include <QJsonArray>

#include <QDebug>
#include <ostream>

namespace SituationMap
{

PixelTextBoxData::PixelTextBoxData(const QString &htmlText, const QColor &backgroundColor)
  : m_htmlText(htmlText), m_backgroundColor(backgroundColor)
{
}

void PixelTextBoxData::reset()
{
  m_htmlText.clear();
  m_backgroundColor = QColor();
  m_position = QPoint();
  m_size = QSize();
}

bool PixelTextBoxData::isEmpty() const
{
  return m_htmlText.isEmpty();
}

QString PixelTextBoxData::toDebugString() const
{
  QJsonDocument jDoc(toJson());
  return QString::fromStdString(jDoc.toJson(QJsonDocument::JsonFormat::Compact).toStdString());
}

bool PixelTextBoxData::operator==(const PixelTextBoxData &o) const
{
  return m_htmlText == o.m_htmlText &&
      m_backgroundColor == o.m_backgroundColor &&
      m_position == o.m_position &&
      m_size == o.m_size;
}


QJsonObject PixelTextBoxData::toJson() const
{
  QJsonObject obj;
  obj[QStringLiteral("text")]              = m_htmlText;
  obj[QStringLiteral("backgroundColor")]   = m_backgroundColor.name();

  obj[QStringLiteral("position")]          = QJsonObject({{QStringLiteral("x"), m_position.x()},
                                                          {QStringLiteral("y"), m_position.y()},
                                                         });

  obj[QStringLiteral("size")]              = QJsonObject({{QStringLiteral("width"), m_size.width()},
                                                          {QStringLiteral("height"), m_size.height()},
                                                         });
  return obj;
}


bool get(const QJsonObject &obj, const QString &key, int &val)
{
  const auto jVal = obj[key];
  if (!jVal.isDouble())
  {
    qCritical() << " isDouble failed";
  }
  val = jVal.toInt();
  return true;
}


PixelTextBoxData PixelTextBoxData::fromJson(const QJsonValue &json)
{
  if (json.isUndefined())
    return {};
  if (!json.isObject())
    return {};

  PixelTextBoxData ret;

  // text
  ret.m_htmlText = json[QStringLiteral("text")].toString();

  // backgroundColor
  QString temp = json[QStringLiteral("backgroundColor")].toString();
  ret.m_backgroundColor = QColor::fromString(temp);

  // position:
  {
    const auto jVal = json[QStringLiteral("position")];
    get(jVal.toObject(), QStringLiteral("x"), ret.m_position.rx());
    get(jVal.toObject(), QStringLiteral("y"), ret.m_position.ry());
  }

  // size:
  {
    const auto jVal = json[QStringLiteral("size")];
    get(jVal.toObject(), QStringLiteral("width"), ret.m_size.rwidth());
    get(jVal.toObject(), QStringLiteral("height"), ret.m_size.rheight());
  }

  return ret;
}

QString PixelTextBoxData::toJsonStr(QJsonDocument::JsonFormat format) const
{
  QJsonObject obj = toJson();
  QJsonDocument jDoc(obj);
  return QString::fromStdString(jDoc.toJson(format).toStdString());
}

PixelTextBoxData PixelTextBoxData::fromJsonStr(const QString &jsonStr)
{
  if (jsonStr.isEmpty())
    return {};

  QJsonParseError parseError;
  QJsonDocument jDoc(QJsonDocument::fromJson(jsonStr.toStdString().c_str(), &parseError));

  if (parseError.error != QJsonParseError::NoError)
  {
    qCritical() << " QJsonParseError->errorString: '" << parseError.errorString() << "'"
                << ", offset: " << parseError.offset;
    return {};
  }

  QJsonObject jObj = jDoc.object();
  if (jObj.isEmpty())
    return {};

  return PixelTextBoxData::fromJson(jObj);
}

//
// Container
//

QJsonObject PixelTextBoxData::pixelTextBoxContainerToJson(const QVector<PixelTextBoxData> &ptbdCont)
{
  QJsonArray arr;
  for (const PixelTextBoxData &item : std::as_const(ptbdCont))
    arr.push_back(item.toJson());

  QJsonObject jObj;
  jObj[QStringLiteral("PixelTextBoxData")] = arr;
  return jObj;
}
QVector<PixelTextBoxData> PixelTextBoxData::pixelTextBoxContainerFromJson(const QJsonValue &json)
{
  QVector<PixelTextBoxData> ret;

  if (!json.isObject())
    return ret;

  const QJsonObject jObj = json.toObject();
  if (!jObj.contains(QStringLiteral("PixelTextBoxData")))
    return ret;

  const QJsonArray &array = jObj[QStringLiteral("PixelTextBoxData")].toArray();
  ret.reserve(array.size());
  for(int i = 0; i < array.size(); ++i)
    ret.push_back(PixelTextBoxData::fromJson(array.at(i)));
  return ret;
}

QString PixelTextBoxData::pixelTextBoxContainerToJsonStr(const QVector<PixelTextBoxData> &ptbdCont, QJsonDocument::JsonFormat format)
{
  QJsonObject obj = pixelTextBoxContainerToJson(ptbdCont);
  QJsonDocument jDoc(obj);
  return QString::fromStdString(jDoc.toJson(format).toStdString());
}
QVector<PixelTextBoxData> PixelTextBoxData::pixelTextBoxContainerFromJsonStr(const QString &jsonStr)
{
  if (jsonStr.isEmpty())
    return {};

  QJsonParseError parseError;
  QJsonDocument jDoc(QJsonDocument::fromJson(jsonStr.toStdString().c_str(), &parseError));

  if (parseError.error != QJsonParseError::NoError)
  {
    qCritical() << " QJsonParseError->errorString: '" << parseError.errorString() << "'"
                << ", offset: " << parseError.offset;
    return {};
  }

  QJsonObject jObj = jDoc.object();
  if (jObj.isEmpty())
    return {};

  return PixelTextBoxData::pixelTextBoxContainerFromJson(jObj);
}

//-----------------------------------------------------------------------------
// output operator:
//-----------------------------------------------------------------------------
GEOMETRYMODEL_EXPORT std::ostream &operator<<(std::ostream &stream, const PixelTextBoxData &value)
{
  stream << value.toDebugString().toStdString().c_str();
  return stream;
}


} // namespace SituationMap