qt5-legatus-legacy/Lts/Viewer/SituationMap/SymbologyXML/symbol_reader.cpp

/**
  * @RDE_HEADER@
  * $Id$
  * $HeadURL$
  * $Author$
  */

#include "symbol_reader.h"
#include "attribute_data.h"

#include <QBuffer>
#include <QFile>
#include <QStringRef>
#include <NGLLogger/NGLLoggerBootstrap.h>

namespace SymbologyXML
{


SymbolReader::SymbolReader() : QXmlStreamReader(),
  logger(NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger("AdvSymbologyXML.SymbolReader")),
  _buffer(nullptr),
  _symbol(nullptr),
  _transformed(false)
{
  DEBUG_LOG(logger) << LOGFUNCTION ;
  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
} // SymbolReader()


SymbolReader::~SymbolReader()
{
  DEBUG_LOG(logger) << LOGFUNCTION ;
  delete _buffer;
  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
} // ~SymbolReader()


bool SymbolReader::read(QFile *xml, Symbol &target) {
  DEBUG_LOG(logger) << LOGFUNCTION ;

  _symbol = (Symbol*)&target;
  if ( xml->exists() ) {
    if ( !xml->open(QIODevice::ReadOnly) ) {
      ERROR_LOG(logger) << LOGFUNCTION
                          << " Can not open file: '" << xml->fileName() << "'" ;
      raiseError(QObject::tr("Can not open the file"));
    }
  } else {
    ERROR_LOG(logger) << LOGFUNCTION
                        << " File does not exist: '" << xml->fileName() << "'" ;
    raiseError(QObject::tr("The file does not exist"));
  }

  _filename = xml->fileName(); // For Debugging only

  setDevice(xml);
  bool result = read();
  xml->close();

  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
  return result;
} // read(QFile xml, Symbol &target)


bool SymbolReader::read(const QString &xml, Symbol &target) {
  return read(xml.toUtf8(), target);
} // read(const QString &xml, Symbol &target)


bool SymbolReader::read(const QByteArray &xml, Symbol &target) {
  DEBUG_LOG(logger) << LOGFUNCTION ;

  _symbol = (Symbol*)&target;
  delete _buffer;
  _buffer = new QBuffer();
  _buffer->setData(xml);
  _buffer->open(QBuffer::ReadOnly);
  setDevice(_buffer);
  bool result = read();
  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
  return result;
} // read(const QString &xml, Symbol &target)


bool SymbolReader::read() {
  DEBUG_LOG(logger) << LOGFUNCTION ;

  _symbol->reset();
  while (!atEnd()) {
    TokenType tt = readNext();
    if (tt == QXmlStreamReader::StartElement) {
      if ( name() == QLatin1String("symbol") ) {
        readSymbol();
      } else {
        ERROR_LOG(logger) << LOGFUNCTION
                            << " The data is not a symbol." ;
        raiseError(QObject::tr("The data is not a symbol"));
      }
    }
  }
  _symbol->_transformed = _transformed;
  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
  return (error() == QXmlStreamReader::NoError);
} // read()


void SymbolReader::readUnknownElement() {
  DEBUG_LOG(logger) << LOGFUNCTION ;
  Q_ASSERT(isStartElement());

  while (!atEnd()) {
    WARNING_LOG(logger) << LOGFUNCTION
                        << " Reading unknown/unexpected element: "
                        << qPrintable(name().toString()) ;
    TokenType tt = readNext();
    if (tt == QXmlStreamReader::EndElement) {
      break;
    }
    if (tt == QXmlStreamReader::StartElement) {
      readUnknownElement();
    }
  }
  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
} // SymbolReader::readUnknownElement()


void SymbolReader::readSymbol() {
  DEBUG_LOG(logger) << LOGFUNCTION ;
  Q_ASSERT(isStartElement() && (name() == QStringLiteral("symbol")) );

  QStringRef attrib = attributes().value(QStringLiteral("version"));
  QString ownVersion = QLatin1String(Symbol::SymbolVersion);
  if ( attrib.toString().toDouble() > ownVersion.toDouble() )
  {
    ERROR_LOG(logger) << LOGFUNCTION
                      << " Wrong symbol version. "
                      << " should be '"<< ownVersion << "'"
                      << " but is '"   << attrib.toString() << "'"
                      << getDebugInfo() ;
    raiseError(QObject::tr("Wrong symbol version"));
  }

  _symbol->setID(getAttribInt("id"));

  // undefined|air_space|land_units|land_equipment|over_water|under_water
  attrib = attributes().value(QStringLiteral("dimen"));

  if ( attrib.isEmpty() )
  {
    ERROR_LOG(logger) << LOGFUNCTION
          << " No value for attribute dimen: "
          << "'" << attrib.toString() << "' "
          << getDebugInfo() ;
  } else   {
    SymbolTypes::t_dimen dimen;
    bool bOk = false;
    dimen = SymbolTypes::instance()->getDimen()->convert_str2enum(attrib, & bOk);
    _symbol->setDimen(dimen);
    if( ! bOk )
    {
      ERROR_LOG(logger) << LOGFUNCTION
          << " Unknown value for attribute dimen: "
          << "'" << attrib.toString() << "' "
          << getDebugInfo() ;
    //    raiseError(QObject::tr("Unknown value for attribute affil."));
    }
  }

  // undefined|unknown|friend|neutral|enemy
  attrib = attributes().value(QLatin1String("affil"));

  if ( attrib.isEmpty() )
  {
    ERROR_LOG(logger) << LOGFUNCTION
          << " No value for attribute affil: "
          << "'" << attrib.toString() << "' "
          << getDebugInfo() ;
  } else {
    SymbolTypes::t_affil affil;
    bool bOk = false;
    affil = SymbolTypes::instance()->getAffil()->convert_str2enum(attrib, & bOk);
    _symbol->setAffil(affil);
    if( ! bOk )
    {
      ERROR_LOG(logger) << LOGFUNCTION
          << " Unknown value for attribute affil: "
          << "'" << attrib.toString() << "' "
          << getDebugInfo() ;

  //    raiseError(QObject::tr("Unknown value for attribute affil."));
    }
  }

  // true|false|1|0
  _transformed = getAttribBool("transformed", false, true);

  // tag bcdab:
  attrib = attributes().value(QLatin1String("bcdab"));
  if (attrib.isEmpty()) {
    _symbol->setBcdab(SymbolTypes::BCDAB_UNDEFINED);
  } else {
    _symbol->setBcdab(SymbolTypes::instance()->getBcdab()->convert_str2enum(attrib));
  }

  // tag commandLevel :
  attrib = attributes().value(QLatin1String("command_level"));
  if (attrib.isEmpty()) {
    _symbol->setCommandLevel(SymbolTypes::CL_UNDEFINED);
  } else {
    _symbol->setCommandLevel(SymbolTypes::instance()->getCommandLevel()->convert_str2enum(attrib));
  }
  // headquarter
  // true|false
  _symbol->setHeadquarter(false);
  attrib = attributes().value(QLatin1String("headquarter"));
  if (!attrib.isEmpty() ) {
    if(attrib == QStringLiteral("true")) {
      _symbol->setHeadquarter(true);
    } else if(attrib == QStringLiteral("false")) {
      _symbol->setHeadquarter(false);
    } else {
      ERROR_LOG(logger) << LOGFUNCTION
                          << " Unknown value for attribute headquarter. "
                          << getDebugInfo() ;
      raiseError(QObject::tr("Unknown value for attribute headquarter"));
    }
  }

  // Mobility
  attrib = attributes().value(QStringLiteral("mob"));
  if (attrib.isEmpty()) {
    _symbol->setMob(SymbolTypes::MOB_UNDEFINED);
  } else {
    SymbolTypes::t_mob t = SymbolTypes::instance()->getMob()->convert_str2enum(attrib);
    if(t == SymbolTypes::MOB_UNDEFINED)
      t = SymbolTypes::instance()->getMob()->convert_str2enum(QStringLiteral("mob_") + attrib.toString());
    _symbol->setMob(t);
  }


  // vehicle (optional)
  // vehicle (undefined|vehicle|util_vehicleA|util_vehicleB|util_vehicle_armored|armored_infantry|armored_infantryB|carrier|armored_tank) #IMPLIED>
  attrib = attributes().value(QStringLiteral("vehicle"));
  if (attrib.isEmpty() ) {
    _symbol->setVehicle(SymbolTypes::VEHICLE_UNDEFINED);
  } else {
    SymbolTypes::t_vehicle ivehicle = SymbolTypes::instance()->getVehicle()->convert_str2enum(attrib);
    if(ivehicle == SymbolTypes::VEHICLE_UNDEFINED)
      ivehicle = SymbolTypes::instance()->getVehicle()->convert_str2enum(QLatin1String("vehicle_") + attrib.toString());
#ifdef APP6C
    // downwards compat. :
    if(ivehicle != SymbolTypes::VEHICLE_UNDEFINED) {
      Primitive *p = newPrimitiveICON(SymbolTypes::ICON_TYPE_VEHICLE,
                                      SymbolTypes::SECTORMAIN, SymbolTypes::SECTOR_RECTPOS_LARGE,
                                      (int)ivehicle);
      if(p) {
        QRectF rect = SymbolTypes::getDefaultRect(SymbolTypes::SECTORMAIN, SymbolTypes::SECTOR_RECTPOS_LARGE);
        QPolygonF poly;
        poly.append(rect.topLeft());
        poly.append(rect.bottomRight());
        p->setPoints(poly);
        _symbol->addPrimitive(p);
      }
    }
    // : downwards compat.
#else
    _symbol->setVehicle(ivehicle);
#endif
  }

  // intrinsicMobility (optional)
  // undefined|wheel|wheel_all_terrain|chain|chain_all_terrain|trailer|train
  attrib = attributes().value(QStringLiteral("intrinsicmob"));
  if (attrib.isEmpty()) {
    _symbol->setIntrinsicMob(SymbolTypes::INTRINSICMOB_UNDEFINED);
  } else {
    SymbolTypes::t_intrinsicmob imob = SymbolTypes::instance()->getIntrinsicMob()->convert_str2enum(attrib);
    if(imob == SymbolTypes::INTRINSICMOB_UNDEFINED)
      imob = SymbolTypes::instance()->getIntrinsicMob()->convert_str2enum(QStringLiteral("intrinsicmob_") + attrib.toString());
#ifdef APP6C
    // downwards compat. :
    if(imob != SymbolTypes::INTRINSICMOB_UNDEFINED) {
      Primitive *p = newPrimitiveICON(SymbolTypes::ICON_TYPE_INTRINSIC_MOBILITY,
                                      SymbolTypes::SECTOR2, SymbolTypes::SECTOR_RECTPOS_DEFAULT,
                                      (int)imob);
      if(p) {
        _symbol->addPrimitive(p);
      }
    }
    // : downwards compat.
#else
    _symbol->setIntrinsicMob(imob);
#endif
  }

  // arming (optional)
  // undefined|gun|auto_weapon|ATGun|ADGun|morter|howitzer|rocket|missile)    #IMPLIED
  attrib = attributes().value(QStringLiteral("arming"));
  if ( ! attrib.isEmpty() ) {
    SymbolTypes::t_arming arming = SymbolTypes::instance()->getArming()->convert_str2enum(attrib);
    if(arming == SymbolTypes::ARMING_UNDEFINED)
      arming = SymbolTypes::instance()->getArming()->convert_str2enum(QStringLiteral("arming_") + attrib.toString());
#ifdef APP6C
    // downwards compat. :
    if(arming != SymbolTypes::ARMING_UNDEFINED) {
      Primitive *p = newPrimitiveICON(SymbolTypes::ICON_TYPE_ARMING,
                                      SymbolTypes::SECTORMAIN, SymbolTypes::SECTOR_RECTPOS_DEFAULT,
                                      (int)arming);
      if(p) {
        _symbol->addPrimitive(p);
      }
    }
    // : downwards compat.
#else
    _symbol->setArming(arming);
#endif
  }

    // Value is optional:
//    ERROR_LOG(logger) << LOGFUNCTION
//                        << " Unknown value for attribute arming." ;
//    raiseError(QObject::tr("Unknown value for attribute arming."));


  while (!atEnd()) {
    TokenType tt = readNext();
    if (tt == QXmlStreamReader::EndElement) {
      break;
    }
    if (tt == QXmlStreamReader::StartElement) {
      if (name() == QStringLiteral("app6class")) {
        readApp6Class();
      } else if (name() == QStringLiteral("branch")) {
        readBranch();
      } else if (name() == QStringLiteral("misc")) {
        readMisc();
      } else if (name() == QStringLiteral("name")) {
        readName();
      } else if (name() == QStringLiteral("text1")) {
        _symbol->setTextType(Symbol::TEXT1);
        readText(1);
      } else if (name() == QStringLiteral("text2")) {
        _symbol->setTextType(Symbol::TEXT2);
        readText(2);
      } else if (name() == QStringLiteral("text3")) {
        _symbol->setTextType(Symbol::TEXT3);
        readText(3);
      } else if (name() == QStringLiteral("graphic")) {
        readGraphic();
      } else {
        readUnknownElement();
      }
    }
  }
  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
} // SymbolReader::readSymbol()


void SymbolReader::readName() {
  DEBUG_LOG(logger) << LOGFUNCTION ;
  Q_ASSERT(isStartElement() && (name() == QStringLiteral("name")) );
  _symbol->setName(readElementText());
  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
} // void SymbolReader::readName()


void SymbolReader::readApp6Class() {
  DEBUG_LOG(logger) << LOGFUNCTION ;
  Q_ASSERT(isStartElement() && (name() == QStringLiteral("app6class")) );

  QStringRef attrib = attributes().value(QStringLiteral("classname"));
  if ( ! attrib.isEmpty() ) {
    _symbol->setClassName(attrib.toString());
  }
  attrib = attributes().value(QStringLiteral("classhierarchy"));
  if ( ! attrib.isEmpty() ) {
    _symbol->setClassHierarchy(attrib.toString());
  }
  attrib = attributes().value(QStringLiteral("classcodeid"));
  if ( ! attrib.isEmpty() ) {
    _symbol->setClassCodeId(attrib.toString());
  }

  while (!atEnd()) {
    TokenType tt = readNext();
    if (tt == QXmlStreamReader::EndElement) {
      break;
    } else {
      readUnknownElement();
    }
  }
  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
} // void SymbolReader::readApp6Class()


void SymbolReader::readBranch() {
  DEBUG_LOG(logger) << LOGFUNCTION ;
  Q_ASSERT(isStartElement() && (name() == QStringLiteral("branch")) );

  QStringRef attrib = attributes().value(QStringLiteral("class"));
  // undefined|tank|infantry|reconnaissance|sof_unit|artillery|army_air_defense
  // |engineer_troops|nbc_defense|army_aviation|signal|supply|psyops|medical
  // |civil_military_coop

  if ( ! attrib.isEmpty() )
  {
   bool bOK = false;
    _symbol->addBranch(SymbolTypes::instance()->getBranch()->convert_str2enum(attrib, &bOK));

    if( ! bOK )
    {
      ERROR_LOG(logger) << LOGFUNCTION
          << " Unknown value for attribute branch: "
          << "'" << attrib.toString() << "' "
          << getDebugInfo() ;
    }
  }

  while (!atEnd()) {
    TokenType tt = readNext();
    if (tt == QXmlStreamReader::EndElement) {
      break;
    } else {
      readUnknownElement();
    }
  }
  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
} // readBranch()


void SymbolReader::readMisc() {
  DEBUG_LOG(logger) << LOGFUNCTION ;
  Q_ASSERT(isStartElement() && (name() == QStringLiteral("misc")) );

  QStringRef attrib = attributes().value(QStringLiteral("class"));

  if ( ! attrib.isEmpty() )
  {
#ifdef APP6C
    // downwards compat. :
    Primitive *p = newMiscPrimitiveICON(attrib);
    if(p) {
      _symbol->addPrimitive(p);
    }
    // : downwards compat.
#else
    // undefined|lightA|mediumA|heavyA|lightB|mediumB|heavyB|lightC|mediumC|heavyC|ArmLight|ArmMedium|ArmHeavy
    bool bOk = false;
    _symbol->addMisc(SymbolTypes::instance()->getMisc()->convert_str2enum(attrib, &bOk));

    if( ! bOk )
    {
      ERROR_LOG(logger) << LOGFUNCTION
          << " Unknown value for attribute misc: "
          << "'" << attrib.toString() << "' "
          << getDebugInfo() ;
    }
#endif
  }

  while (!atEnd()) {
    TokenType tt = readNext();
    if (tt == QXmlStreamReader::EndElement) {
      break;
    } else {
      readUnknownElement();
    }
  }
  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
} // readMisc()


Primitive *SymbolReader::newMiscPrimitiveICON(const QStringRef &attrib)
{
  Primitive *retPrim = nullptr;
  bool bOK = false;

  SymbolTypes::t_misc misc = SymbolTypes::instance()->getMisc()->convert_str2enum(attrib, &bOK);
  if(!bOK) {
    ERROR_LOG(logger) << LOGFUNCTION
                        << " APP6: Unknown value for attribute misc: "
                        << "'" << attrib.toString() << "' "
                        << getDebugInfo() ;
  } else {
    if(misc != SymbolTypes::MISC_UNDEFINED) {
      retPrim = newPrimitiveICON(SymbolTypes::ICON_TYPE_MISC,
                                 SymbolTypes::SECTORMAIN, SymbolTypes::SECTOR_RECTPOS_DEFAULT,
                                 (int)misc);
    }
  }
  return retPrim;
}


void SymbolReader::readText(unsigned int lines) {
  DEBUG_LOG(logger) << LOGFUNCTION ;
  Q_ASSERT(isStartElement() &&
          ((name() == QStringLiteral("text1")) ||
           (name() == QStringLiteral("text2")) ||
           (name() == QStringLiteral("text3"))) );

  _symbol->setMaxStringLength(getAttribInt("maxdatalength"));

  unsigned int lineCount = 0;
  Symbol::t_alignment align[3];
  Symbol::t_alignment alignTmp = Symbol::ALIGNMENT_UNDEFINED;
  align[0] = Symbol::ALIGNMENT_UNDEFINED;
  align[1] = Symbol::ALIGNMENT_UNDEFINED;
  align[2] = Symbol::ALIGNMENT_UNDEFINED;
  QStringList data;
  while (!atEnd()) {
    TokenType tt = readNext();
    if (tt == QXmlStreamReader::EndElement) {
      break;
    }
    if (tt == QXmlStreamReader::StartElement) {
      if (name() == QStringLiteral("data")) {
        data.append(readData(&alignTmp));
        align[lineCount] = alignTmp;
        ++lineCount;
      } else {
        readUnknownElement();
      }
    }
  }

  if ( lineCount != lines ) {
    ERROR_LOG(logger) << LOGFUNCTION
                        << " Wrong number of lines. "
                        << getDebugInfo() ;
    raiseError(QObject::tr("Wrong number of lines"));
  } else {
    const QString nil;
    _symbol->setText((data.size()>0)?data[0]:nil, align[0],
                     (data.size()>1)?data[1]:nil, align[1],
                     (data.size()>2)?data[2]:nil, align[2]);
  }
  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
} // readText(unsigned int lines)


void SymbolReader::readGraphic() {
  DEBUG_LOG(logger) << LOGFUNCTION ;
  Q_ASSERT(isStartElement() && (name() == QStringLiteral("graphic")) );

  _symbol->setScale(getAttribDouble("scale"));

  while (!atEnd()) {
    TokenType tt = readNext();
    if (tt == QXmlStreamReader::EndElement) {
      break;
    }
    // ellipse|line|polygon|rect
    if (tt == QXmlStreamReader::StartElement) {
      if (name() == QStringLiteral("ellipse")) {
        readGEllipse();
      } else if (name() == QStringLiteral("line")) {
        readGLine();
      } else if (name() == QStringLiteral("polygon")) {
        readGPolygon();
      } else if (name() == QStringLiteral("rect")) {
        readGRect();
      } else if (name() == QStringLiteral("icon")) {
        readGIcon();
      } else if (name() == QStringLiteral("text")) {
        readGText();
      } else {
        readUnknownElement();
      }
    }
  }
  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
} // readGraphic()


QString SymbolReader::readData(Symbol::t_alignment* align) {
  DEBUG_LOG(logger) << LOGFUNCTION ;
  Q_ASSERT(isStartElement() && (name() == QStringLiteral("data")) );

  QStringRef attrib = attributes().value(QStringLiteral("align"));
  // left|center|right
  if ( attrib == QStringLiteral("left") ) {
    *align = Symbol::LEFT;
  } else if ( attrib == QStringLiteral("center") ) {
    *align = Symbol::CENTER;
  } else if ( attrib == QStringLiteral("right") ) {
    *align = Symbol::RIGHT;
  } else {
    *align = Symbol::ALIGNMENT_UNDEFINED;
    ERROR_LOG(logger) << LOGFUNCTION
                        << " Unknown value for attribute align. "
                        << getDebugInfo() ;
    raiseError(QObject::tr("Unknown value for attribute align"));
  }

  QString textData = readElementText();
  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
  return textData;
} // QString SymbolReader::readData(Symbol::t_alignment* align)


void SymbolReader::readGEllipse() {
  DEBUG_LOG(logger) << LOGFUNCTION ;
  Q_ASSERT(isStartElement() && (name() == QStringLiteral("ellipse")) );

  Primitive* p = new Primitive(Primitive::ELLIPSE);
  p->setTransform(getAttribBool("transform", true, true));
  p->setRotation(getAttribDouble("rotate"));
  p->setLineWidth(getAttribDouble("linewidth"));
  p->setLineStyle(getAttribLineStyle());
  p->setFill(getAttribBool("fill"));
  p->setClosed(getAttribBool("closed"));
  p->setStartAngle(getAttribDouble("start"));
  p->setExtent(getAttribDouble("extent"));
  p->setColor(getAttribColor());

  unsigned int count = 0;
  QPolygonF pointList;
  while (!atEnd()) {
    TokenType tt = readNext();
    if (tt == QXmlStreamReader::EndElement) {
      break;
    }
    if (tt == QXmlStreamReader::StartElement) {
      if (name() == QStringLiteral("point")) {
        pointList.append(readGPoint());
        ++count;
      } else {
        readUnknownElement();
      }
    }
  }
  p->setPoints(pointList);
  _symbol->addPrimitive(p);

  if ( count != 2 ) {
    ERROR_LOG(logger) << LOGFUNCTION
                        << " Wrong number of points for ellipse. "
                        << getDebugInfo() ;
    raiseError(QObject::tr("Wrong number of points for ellipse"));
  }
  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
} // void SymbolReader::readGEllipse()


void SymbolReader::readGLine() {
  DEBUG_LOG(logger) << LOGFUNCTION ;
  Q_ASSERT(isStartElement() && (name() == QStringLiteral("line")) );

  Primitive* p = new Primitive(Primitive::LINE);
  p->setTransform(getAttribBool("transform", true, true));
  p->setRotation(getAttribDouble("rotate"));
  p->setLineWidth(getAttribDouble("linewidth"));
  p->setLineStyle(getAttribLineStyle());
  p->setColor(getAttribColor());

  unsigned int count = 0;
  QPolygonF pointList;
  while (!atEnd()) {
    TokenType tt = readNext();
    if (tt == QXmlStreamReader::EndElement) {
      break;
    }
    if (tt == QXmlStreamReader::StartElement) {
      if (name() == QLatin1String("point")) {
        pointList.append(readGPoint());
        ++count;
      } else {
        readUnknownElement();
      }
    }
  }
  p->setPoints(pointList);
  _symbol->addPrimitive(p);

  if ( count != 2 ) {
    ERROR_LOG(logger) << LOGFUNCTION
                        << " Wrong number of points for line. "
                        << getDebugInfo() ;
    raiseError(QObject::tr("Wrong number of points for line"));
  }
  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
} // void SymbolReader::readGLine()


void SymbolReader::readGPolygon() {
  DEBUG_LOG(logger) << LOGFUNCTION ;
  Q_ASSERT(isStartElement() && (name() == QStringLiteral("polygon")) );

  Primitive* p = new Primitive(Primitive::POLYGON);
  p->setTransform(getAttribBool("transform", true, true));
  p->setRotation(getAttribDouble("rotate"));
  p->setLineWidth(getAttribDouble("linewidth"));
  p->setLineStyle(getAttribLineStyle());
  p->setFill(getAttribBool("fill"));
  p->setClosed(getAttribBool("closed"));
  p->setColor(getAttribColor());

  unsigned int count = 0;
  QPolygonF pointList;
  while (!atEnd()) {
    TokenType tt = readNext();
    if (tt == QXmlStreamReader::EndElement) {
      break;
    }
    if (tt == QXmlStreamReader::StartElement) {
      if (name() == QStringLiteral("point")) {
        pointList.append(readGPoint());
        ++count;
      } else {
        readUnknownElement();
      }
    }
  }
  p->setPoints(pointList);
  _symbol->addPrimitive(p);

  if ( count < 3 ) {
    ERROR_LOG(logger) << LOGFUNCTION
                        << " Too few points for polygon. "
                        << getDebugInfo() ;
    raiseError(QObject::tr("Too few points for polygon"));
  }
  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
} // void SymbolReader::readGPolygon()


void SymbolReader::readGRect() {
  DEBUG_LOG(logger) << LOGFUNCTION ;
  Q_ASSERT(isStartElement() && (name() == QStringLiteral("rect")) );

  Primitive* p = new Primitive(Primitive::RECT);
  p->setTransform(getAttribBool("transform", true, true));
  p->setRotation(getAttribDouble("rotate"));
  p->setLineWidth(getAttribDouble("linewidth"));
  p->setLineStyle(getAttribLineStyle());
  p->setFill(getAttribBool("fill"));
  p->setColor(getAttribColor());

  unsigned int count = 0;
  QPolygonF pointList;
  while (!atEnd()) {
    TokenType tt = readNext();
    if (tt == QXmlStreamReader::EndElement) {
      break;
    }
    if (tt == QXmlStreamReader::StartElement) {
      if (name() == QStringLiteral("point")) {
        pointList.append(readGPoint());
        ++count;
      } else {
        readUnknownElement();
      }
    }
  }
  p->setPoints(pointList);
  _symbol->addPrimitive(p);

  if ( count != 2 ) {
    ERROR_LOG(logger) << LOGFUNCTION
                        << " Wrong number of points for rect. "
                        << getDebugInfo() ;
    raiseError(QObject::tr("Wrong number of points for rect"));
  }
  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
} // void SymbolReader::readGRect()


void SymbolReader::readGText() {
  DEBUG_LOG(logger) << LOGFUNCTION ;
  Q_ASSERT(isStartElement() && (name() == QStringLiteral("text")) );

  Primitive* p = new Primitive(Primitive::TEXT);
  p->setTransform(getAttribBool("transform", true, true));
  p->setRotation(getAttribDouble("rotate"));
  // join two strings:

  QString s1 = getAttribString("sval1");
  QString s2 = getAttribString("sval2");

  p->setText( (s2.size() > 0) ?  s1 + QStringLiteral("\n") + s2 : s1 );

  //
  unsigned int count = 0;
  QPolygonF pointList;

  while (!atEnd()) {
    TokenType tt = readNext();
    if (tt == QXmlStreamReader::EndElement) {
      break;
    }
    if (tt == QXmlStreamReader::StartElement) {
      if (name() == QStringLiteral("point")) {
        pointList.append(readGPoint());
        ++count;
      } else {
        readUnknownElement();
      }
    }
  }
  p->setPoints(pointList);
  _symbol->addPrimitive(p);

  if ( count != 2 ) {
    ERROR_LOG(logger) << LOGFUNCTION
                        << " Wrong number of points for text. "
                        << getDebugInfo() ;
    raiseError(QObject::tr("Wrong number of points for text"));
  }
  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
} // void SymbolReader::readGRect()


void SymbolReader::readGIcon() {
  DEBUG_LOG(logger) << LOGFUNCTION ;
  Q_ASSERT(isStartElement() && (name() == QStringLiteral("icon")) );

  //
  QString attrib = getAttribString("icon_type");
  SymbolTypes::t_icon_type icon_type = SymbolTypes::ICON_TYPE_UNDEFINED;

  if ( attrib.isEmpty() )
  {
     ERROR_LOG(logger) << LOGFUNCTION
                         << " No attrib for icon_type "
                         << getDebugInfo() ;
  } else {
     icon_type = SymbolTypes::instance()->getIconType()->convert_str2enum(attrib);
  }
  Primitive* p = newPrimitiveICON(icon_type, getAttribPosition(), getAttribRectpos(), getAttribInt("id"));
  p->setScalemode(getAttribScalemode());
  p->setTransform(getAttribBool("transform", true, true));
  p->setRotation(getAttribDouble("rotate"));
  p->setLineWidth(getAttribDouble("linewidth"));

  unsigned int count = 0;
  QPolygonF pointList;

  while (!atEnd()) {
    TokenType tt = readNext();
    if (tt == QXmlStreamReader::EndElement) {
      break;
    }
    if (tt == QXmlStreamReader::StartElement) {
      if (name() == QStringLiteral("point")) {
        pointList.append(readGPoint());
        ++count;
      } else {
        readUnknownElement();
      }
    }
  }
  // points:
  if(count == 0) {
    QRectF defaultR = SymbolTypes::getDefaultRect(p->position(), p->rectpos());
      pointList.append(defaultR.topLeft());
      ++count;
      pointList.append(defaultR.bottomRight());
      ++count;
  }
  p->setPoints(pointList);
  _symbol->addPrimitive(p);

  if ( count != 2 ) {
    ERROR_LOG(logger) << LOGFUNCTION
                        << " Wrong number of points for icon. "
                        << getDebugInfo() ;
    raiseError(QObject::tr("Wrong number of points for icon"));
  }
  //
  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
} // void SymbolReader::readGRect()


QPointF SymbolReader::readGPoint() {
  DEBUG_LOG(logger) << LOGFUNCTION ;
  Q_ASSERT(isStartElement() && (name() == QStringLiteral("point")) );

  double x = getAttribDouble("x");
  double y = getAttribDouble("y");

  while (!atEnd()) {
    TokenType tt = readNext();
    if (tt == QXmlStreamReader::EndElement) {
      break;
    } else {
      readUnknownElement();
    }
  }
  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
  return QPointF(x, y);
} // Point SymbolReader::readGPoint()


bool SymbolReader::getAttribBool(const char *name, bool def, bool implied) {
  DEBUG_LOG(logger) << LOGFUNCTION ;
  QString value = attributes().value(QLatin1String(name)).toString().toLower();
  bool result = def;
  if ( (value == QStringLiteral("true")) || (value == QStringLiteral("1")) ) {
    result = true;
  } else if ( (value == QStringLiteral("false")) || (value == QStringLiteral("0")) ) {
    result = false;
  } else if ( !implied ) {
    ERROR_LOG(logger) << LOGFUNCTION
                        << " Can not parse bool attribute '" << name << "': "
                        << getDebugInfo() ;
    raiseError(QObject::tr("Can not parse bool-attribute"));
  }
  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
  return result;
} // bool SymbolReader::getAttribBool(const QString& name, bool def, bool implied)


double SymbolReader::getAttribDouble(const char *name, double def, bool implied) {
  DEBUG_LOG(logger) << LOGFUNCTION ;
  bool ok;
  double value = attributes().value(QLatin1String(name)).toString().toDouble(&ok);
  if ( ok ) {
    DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
    return value;
  } else if ( implied ) {
    DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
    return def;
  } else {
    ERROR_LOG(logger) << LOGFUNCTION
                      << " Can not parse double attribute '" << name << "': "
                      << getDebugInfo() ;
    raiseError(QObject::tr("Can not parse double-attribute"));
    DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
    return value;
  }
} // double SymbolReader::getAttribDouble(const QString& name, double def, bool implied)


int SymbolReader::getAttribInt(const char *name, int def, bool implied) {
  DEBUG_LOG(logger) << LOGFUNCTION ;
  bool ok;
  int value = attributes().value(QLatin1String(name)).toString().toInt(&ok,0);
  // Need this conversion for values with bit 31 set
  // unsigned long longValue = attributes().value(name).toString().toULong(&ok, 0);
  // int value = (int)(longValue & 0x7FFFFFFF);
  if ( ok ) {
    DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
    return value;
  } else if ( implied ) {
    DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
    return def;
  } else {
    ERROR_LOG(logger) << LOGFUNCTION
                      << " Can not parse int attribute '" << name << "': "
                      << getDebugInfo() ;
    raiseError(QObject::tr("Can not parse int-attribute"));
    DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
    return value;
  }
} // int SymbolReader::getAttribInt(const QString& name, int def, bool implied)

Primitive::t_linestyle SymbolReader::getAttribLineStyle()
{
  QStringRef attrib = attributes().value(QStringLiteral("linestyle"));
  // solid, dashed, dotted, dashed_dotted
  if (attrib == QStringLiteral("solid"))
    return Primitive::SOLID;
  if (attrib == QStringLiteral("dashed"))
    return Primitive::DASHED;
  if (attrib == QStringLiteral("dotted"))
    return Primitive::DOTTED;
  if (attrib == QStringLiteral("dashed_dotted"))
    return Primitive::DASHED_DOTTED;

  ERROR_LOG(logger) << LOGFUNCTION
                    << " Unknown value for attribute linestyle. "
                    << getDebugInfo() ;
  raiseError(QObject::tr("Unknown value for attribute linestyle"));
  return Primitive::SOLID;
} // Primitive::t_linestyle SymbolReader::getAttribLineStyle()


SymbolTypes::t_sector_position SymbolReader::getAttribPosition(SymbolTypes::t_sector_position def)
{
  QStringRef attrib = attributes().value(QStringLiteral("position"));

  if (attrib.isEmpty())
  {
    ERROR_LOG(logger) << LOGFUNCTION
                      << " No attrib for position "
                      << getDebugInfo();
    return SymbolTypes::SECTOR_POSITION_UNDEFINED;
  }

  bool bOK = false;
  SymbolTypes::t_sector_position value =
      SymbolTypes::instance()->getSectorPosition()->convert_str2enum(attrib, &bOK);
  if (!bOK)
  {
    value = def;

    ERROR_LOG(logger) << LOGFUNCTION
                      << " Unknown value for attribute position. "
                      << getDebugInfo() ;
    raiseError(QObject::tr("Unknown value for attribute position"));
  }

  return value;
}

SymbolTypes::t_sector_rectpos SymbolReader::getAttribRectpos(SymbolTypes::t_sector_rectpos def)
{
  QStringRef attrib = attributes().value(QStringLiteral("rectpos"));

  if (attrib.isEmpty())
    return def;

  bool bOK = false;
  SymbolTypes::t_sector_rectpos value =
      SymbolTypes::instance()->getSectorRectpos()->convert_str2enum(attrib, &bOK);
  if (!bOK)
  {
    value = def;
    ERROR_LOG(logger) << LOGFUNCTION
        << " Unknown value for attribute rectpos "
        << getDebugInfo() ;
    raiseError(QObject::tr("Unknown value for attribute rectpos"));
  }

  return value;
}

Primitive::t_scalemode SymbolReader::getAttribScalemode(Primitive::t_scalemode def)
{
  QStringRef attrib = attributes().value(QStringLiteral("scalemode"));

  return attrib.isEmpty() ? def : Primitive::scalemode(attrib.toString());
}

QString SymbolReader::getAttribString(const char *name) {
  DEBUG_LOG(logger) << LOGFUNCTION ;

  QStringRef attrib = attributes().value(QLatin1String(name));

  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
  return attrib.toString();
} // getAttribString


QColor SymbolReader::getAttribColor(const QColor &def) {
  DEBUG_LOG(logger) << LOGFUNCTION ;

  QColor result = def;
  QStringRef _attrib = attributes().value(QStringLiteral("color"));
  if ( _attrib.length() == 9 ) {
    result.setNamedColor(_attrib.left(7).toString());
    // Get Alpha-Channel
    bool ok;
    int value = _attrib.right(2).toInt(&ok,16);
    if ( ok ) {
      result.setAlpha(value);
    }
  }

  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
  return result;
} // QColor SymbolReader::getAttribColor(QColor def)


QString SymbolReader::getDebugInfo() const
{
  QString ret = QStringLiteral("[filename='") + _filename + QStringLiteral("'");
  if (_symbol)
      ret += QStringLiteral(", id=") + QString::number(_symbol->id());
  ret += QStringLiteral("]");
  return ret;
} // QString SymbolReader::getDebugInfo() const


// newPrimitiveICON --> SymbolExporter::newPrimitiveICON  !! libsymbol_gui ?
Primitive *SymbolReader::newPrimitiveICON(SymbolTypes::t_icon_type iconType,
                                          SymbolTypes::t_sector_position pos, SymbolTypes::t_sector_rectpos rectpos,
                                          int id)
{
  Primitive *p = new Primitive(Primitive::ICON);
  p->setIcon(id);
  p->setIconType(iconType);
  QRectF rect = SymbolTypes::getDefaultRect(pos, rectpos);
  QPolygonF poly;
  poly.append(rect.topLeft());
  poly.append(rect.bottomRight());
  p->setPoints(poly);
  p->setPosition(pos);
  p->setRectpos(rectpos);
  p->setLineWidth(-1); // will be set in drawICON

  return p;
}

}; // namespace SymbologyXML