806 lines
22 KiB
C++
Executable File
806 lines
22 KiB
C++
Executable File
/**
|
|
* @RDE_HEADER@
|
|
* Class SidcDefinitions
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
*/
|
|
|
|
// Own
|
|
#include "sidc_definitions.h"
|
|
#include <SymbologyImpl/symbol_dictionary_impl.h>
|
|
|
|
#ifdef XML_SYMBOL_ICONS
|
|
#include <SymbologyXML/symbol.h>
|
|
#include <SymbologyXML/symbol_reader.h>
|
|
#include <SymbologyXML/symbol_exporter.h>
|
|
#endif
|
|
|
|
#include <QtCore/QFile>
|
|
#include <QtGui/QPainter>
|
|
#include <QtGui/QPixmap>
|
|
#include <QtWidgets/QGraphicsScene>
|
|
|
|
|
|
//
|
|
//#include <sstream>
|
|
|
|
namespace AdvancedSymbology
|
|
{
|
|
|
|
|
|
SidcDefinitions::SidcDefinitions(SymbolDictionary *symbolDictionary, const char *loggerName)
|
|
: m_symbolDictionary(symbolDictionary)
|
|
, m_logger(getLogger(loggerName))
|
|
{
|
|
if (m_symbolDictionary)
|
|
{
|
|
if (m_symbolDictionary->isLoaded())
|
|
{
|
|
SymbolDictionaryImpl *symDicImpl = static_cast<SymbolDictionaryImpl *>(m_symbolDictionary);
|
|
m_esriDictProcessor = symDicImpl->getEsriDictionaryProcessor();
|
|
}
|
|
else
|
|
ERROR_LOG(m_logger) << LOGFUNCTION << " symbolDictionary not loaded";
|
|
}
|
|
else
|
|
ERROR_LOG(m_logger) << LOGFUNCTION << " no symbolDictionary";
|
|
}
|
|
|
|
QLatin1String SidcDefinitions::toString(ShapeType value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case ShapeType::Undefined:
|
|
return QLatin1String("Undefined");
|
|
case ShapeType::Circle:
|
|
return QLatin1String("Circle");
|
|
case ShapeType::Clover:
|
|
return QLatin1String("Clover");
|
|
case ShapeType::Curve:
|
|
return QLatin1String("Curve");
|
|
case ShapeType::Diamond:
|
|
return QLatin1String("Diamond");
|
|
case ShapeType::Rectangle:
|
|
return QLatin1String("Rectangle");
|
|
case ShapeType::Square:
|
|
return QLatin1String("Square");
|
|
}
|
|
return QLatin1String("ERROR-ShapeType");
|
|
}
|
|
|
|
|
|
QLatin1String SidcDefinitions::toString(Context value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case Context::Reality:
|
|
return QLatin1String("Reality");
|
|
case Context::Exercise:
|
|
return QLatin1String("Exercise");
|
|
case Context::Simulation:
|
|
return QLatin1String("Simulation");
|
|
}
|
|
return QLatin1String("ERROR-Context");
|
|
}
|
|
|
|
|
|
QPixmap SidcDefinitions::toPixmap(Context value)
|
|
{
|
|
Q_UNUSED(value)
|
|
return QPixmap();
|
|
}
|
|
|
|
|
|
QLatin1String SidcDefinitions::toString(Identity value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case Identity::Pending:
|
|
return QLatin1String("Pending");
|
|
case Identity::Unknown:
|
|
return QLatin1String("Unknown");
|
|
|
|
case Identity::AssumedFriend:
|
|
return QLatin1String("AssumedFriend");
|
|
case Identity::Friend:
|
|
return QLatin1String("Friend");
|
|
|
|
case Identity::Neutral:
|
|
return QLatin1String("Neutral");
|
|
|
|
case Identity::SuspectJoker:
|
|
return QLatin1String("SuspectJoker");
|
|
case Identity::HostileFaker:
|
|
return QLatin1String("HostileFaker");
|
|
} // switch
|
|
return QLatin1String("ERROR-Identity");
|
|
}
|
|
|
|
|
|
QPixmap SidcDefinitions::toPixmap(Identity value)
|
|
{
|
|
Q_UNUSED(value);
|
|
return QPixmap(); // render XML symbol frame not activated yet
|
|
|
|
#ifdef XML_SYMBOL_ICONS
|
|
|
|
QGraphicsScene scene;
|
|
QString frameXml;
|
|
QString frameResource;
|
|
SymbologyXML::Symbol symbol;
|
|
SymbologyXML::SymbolReader symbolReader;
|
|
QColor fillColor;
|
|
SymbologyXML::SymbolTypes::t_affil affil;
|
|
|
|
static QMap<Identity,QImage*> frameImageMap;
|
|
|
|
if (frameImageMap[value]) return QPixmap::fromImage(*frameImageMap[value]);
|
|
|
|
scene.setSceneRect( QRectF(-2.0, -2.0, 4.0, 4.0) );
|
|
|
|
switch (value)
|
|
{
|
|
case Identity::Pending :
|
|
{
|
|
affil = SymbologyXML::SymbolTypes::t_affil::PENDING;
|
|
fillColor = QColor(QStringLiteral("yellow"));
|
|
frameResource = QStringLiteral(":/Symbole/Attributes/symbolframes/frame_landunits_unknown.xml");
|
|
} break;
|
|
|
|
case Identity::Unknown :
|
|
{
|
|
affil = SymbologyXML::SymbolTypes::t_affil::UNKNOWN;
|
|
fillColor = QColor(QStringLiteral("yellow"));
|
|
frameResource = QStringLiteral(":/Symbole/Attributes/symbolframes/frame_landunits_unknown.xml");
|
|
} break;
|
|
|
|
case Identity::AssumedFriend :
|
|
{
|
|
affil = SymbologyXML::SymbolTypes::t_affil::ASSUMED_FRIEND;
|
|
fillColor = QColor(QStringLiteral("light blue"));
|
|
frameResource = QStringLiteral(":/Symbole/Attributes/symbolframes/frame_landunits_friend.xml");
|
|
} break;
|
|
|
|
case Identity::Friend :
|
|
{
|
|
affil = SymbologyXML::SymbolTypes::t_affil::FRIEND;
|
|
fillColor = QColor(QStringLiteral("light blue"));
|
|
frameResource = QStringLiteral(":/Symbole/Attributes/symbolframes/frame_landunits_friend.xml");
|
|
} break;
|
|
|
|
case Identity::Neutral :
|
|
{
|
|
affil = SymbologyXML::SymbolTypes::t_affil::NEUTRAL;
|
|
fillColor = QColor(QStringLiteral("darkseagreen"));
|
|
frameResource = QStringLiteral(":/Symbole/Attributes/symbolframes/frame_landunits_neutral.xml");
|
|
} break;
|
|
|
|
case Identity::SuspectJoker :
|
|
{
|
|
affil = SymbologyXML::SymbolTypes::t_affil::SUSPECT;
|
|
fillColor = QColor(QStringLiteral("orange"));
|
|
frameResource = QStringLiteral(":/Symbole/Attributes/symbolframes/frame_landunits_enemy.xml");
|
|
} break;
|
|
|
|
case Identity::HostileFaker :
|
|
{
|
|
affil = SymbologyXML::SymbolTypes::t_affil::ENEMY;
|
|
fillColor = QColor(QStringLiteral("red"));
|
|
frameResource = QStringLiteral(":/Symbole/Attributes/symbolframes/frame_landunits_enemy.xml");
|
|
} break;
|
|
} //switch
|
|
|
|
if (frameResource.isEmpty()) return QPixmap();
|
|
|
|
QFile fileXml(frameResource);
|
|
|
|
if (!fileXml.exists()) return QPixmap();
|
|
|
|
if (!fileXml.open(QIODevice::ReadOnly | QIODevice::Text)) return QPixmap();
|
|
frameXml = QString::fromLocal8Bit( fileXml.readAll() );
|
|
fileXml.close();
|
|
|
|
if (frameXml.isEmpty()) return QPixmap();
|
|
|
|
if (!symbolReader.read(frameXml,symbol)) return QPixmap();
|
|
|
|
symbol.setAffil(affil);
|
|
symbol.setDimen(SymbologyXML::SymbolTypes::t_dimen::LAND_UNITS);
|
|
symbol.setHeadquarter(false);
|
|
|
|
QImage *frameImage = new QImage(40,40,QImage::Format::Format_ARGB32);
|
|
QPainter painter(frameImage);
|
|
|
|
painter.setRenderHints(QPainter::Antialiasing|QPainter::SmoothPixmapTransform);
|
|
|
|
frameImage->fill(QColor(255,255,255,0));
|
|
|
|
SymbologyXML::SymbolTypes::AdditionalSymbolData options;
|
|
options.m_filltype = SymbologyXML::SymbolTypes::FILLTYPE_FILLED;
|
|
|
|
SymbologyXML::SymbolExporter::drawFrameSymbol( symbol, options, &scene, QColor(0,0,0,255), fillColor, 0.0, true);
|
|
|
|
scene.render(&painter);
|
|
|
|
frameImageMap[value] = frameImage;
|
|
|
|
return QPixmap::fromImage(*frameImage);
|
|
|
|
#endif
|
|
}
|
|
|
|
SidcDefinitions::ShapeType SidcDefinitions::StandardIdentity::getShape() const
|
|
{
|
|
switch (identity)
|
|
{
|
|
case Identity::Unknown:
|
|
case Identity::Pending:
|
|
return ShapeType::Clover;
|
|
|
|
case Identity::Friend:
|
|
case Identity::AssumedFriend:
|
|
return ShapeType::Rectangle;
|
|
|
|
case Identity::Neutral:
|
|
return ShapeType::Square;
|
|
|
|
case Identity::HostileFaker:
|
|
case Identity::SuspectJoker:
|
|
return ShapeType::Diamond;
|
|
} // switch
|
|
|
|
return ShapeType::Undefined;
|
|
}
|
|
|
|
QVector<SidcDefinitions::Context> SidcDefinitions::contexts()
|
|
{
|
|
return { Context::Reality, Context::Exercise, Context::Simulation };
|
|
}
|
|
|
|
|
|
QVector<SidcDefinitions::Identity> SidcDefinitions::identities()
|
|
{
|
|
return {Identity::Pending,
|
|
Identity::Unknown,
|
|
Identity::AssumedFriend,
|
|
Identity::Friend,
|
|
Identity::Neutral,
|
|
Identity::SuspectJoker,
|
|
Identity::HostileFaker};
|
|
}
|
|
|
|
|
|
QLatin1String SidcDefinitions::toString(HQTFDummy value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case HQTFDummy::Unknown:
|
|
return QLatin1String("Unknown");
|
|
case HQTFDummy::FeintDummy:
|
|
return QLatin1String("FeintDummy");
|
|
case HQTFDummy::Headquarters:
|
|
return QLatin1String("Headquarters");
|
|
case HQTFDummy::FeintDummy_Headquarters:
|
|
return QLatin1String("FeintDummy_Headquarters");
|
|
case HQTFDummy::TaskForce:
|
|
return QLatin1String("TaskForce");
|
|
case HQTFDummy::FeintDummy_TaskForce:
|
|
return QLatin1String("FeintDummy_TaskForce");
|
|
case HQTFDummy::TaskForce_Headquarters:
|
|
return QLatin1String("TaskForce_Headquarters");
|
|
case HQTFDummy::FeintDummy_TaskForce_Headquarters:
|
|
return QLatin1String("FeintDummy_TaskForce_Headquarters");
|
|
} // switch
|
|
return QLatin1String("ERROR-HQTFDummy");
|
|
}
|
|
|
|
|
|
QPixmap SidcDefinitions::toPixmap(HQTFDummy value)
|
|
{
|
|
Q_UNUSED(value);
|
|
return QPixmap();
|
|
}
|
|
|
|
|
|
QVector<SidcDefinitions::HQTFDummy> SidcDefinitions::hQTFDummy()
|
|
{
|
|
return {HQTFDummy::Unknown,
|
|
HQTFDummy::FeintDummy,
|
|
HQTFDummy::Headquarters,
|
|
HQTFDummy::FeintDummy_Headquarters,
|
|
HQTFDummy::TaskForce,
|
|
HQTFDummy::FeintDummy_TaskForce,
|
|
HQTFDummy::TaskForce_Headquarters,
|
|
HQTFDummy::FeintDummy_TaskForce_Headquarters
|
|
};
|
|
}
|
|
|
|
void SidcDefinitions::HQTFDummyConverter::toBool(const SidcDefinitions::HQTFDummy &hqTfDummy, bool &headquarters, bool &taskForce, bool &feintDummy)
|
|
{
|
|
uint asInt = static_cast<uint>(hqTfDummy);
|
|
headquarters = asInt & 2; // mask
|
|
taskForce = asInt & 4; // mask
|
|
feintDummy = asInt & 1; // mask
|
|
|
|
}
|
|
uint SidcDefinitions::HQTFDummyConverter::toHqTfDummyAsInt(bool headquarters, bool taskForce, bool feintDummy)
|
|
{
|
|
uint hdtffd = 0;
|
|
|
|
if (headquarters) hdtffd += 2;
|
|
if (taskForce) hdtffd += 4;
|
|
if (feintDummy) ++hdtffd;
|
|
|
|
return hdtffd;
|
|
}
|
|
SidcDefinitions::HQTFDummy SidcDefinitions::HQTFDummyConverter::toHqTfDummy(bool headquarters, bool taskForce, bool feintDummy)
|
|
{
|
|
return static_cast<HQTFDummy>(toHqTfDummyAsInt(headquarters,
|
|
taskForce,
|
|
feintDummy));
|
|
}
|
|
|
|
|
|
QLatin1String SidcDefinitions::toString(AmplifierGroup value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case AmplifierGroup::Unknown:
|
|
return QLatin1String("Unknown");
|
|
case AmplifierGroup::Echelon_BrigadeAndBelow:
|
|
return QLatin1String("Echelon_BrigadeAndBelow");
|
|
case AmplifierGroup::Echelon_DivisionAndAbove:
|
|
return QLatin1String("Echelon_DivisionAndAbove");
|
|
case AmplifierGroup::Mobility_OnLand:
|
|
return QLatin1String("Mobility_OnLand");
|
|
case AmplifierGroup::Mobility_OnSnow:
|
|
return QLatin1String("Mobility_OnSnow");
|
|
case AmplifierGroup::Mobility_OnWater:
|
|
return QLatin1String("Mobility_OnWater");
|
|
case AmplifierGroup::Naval_TowedArry:
|
|
return QLatin1String("Naval_TowedArry");
|
|
} // switch
|
|
return QLatin1String("ERROR-AmplifierGroup");
|
|
}
|
|
|
|
|
|
QPixmap SidcDefinitions::toPixmap(AmplifierGroup value)
|
|
{
|
|
Q_UNUSED(value);
|
|
return QPixmap();
|
|
}
|
|
|
|
|
|
QVector<SidcDefinitions::AmplifierGroup> SidcDefinitions::amplifierGroups()
|
|
{
|
|
return { AmplifierGroup::Unknown,
|
|
|
|
AmplifierGroup::Echelon_BrigadeAndBelow,
|
|
AmplifierGroup::Echelon_DivisionAndAbove,
|
|
|
|
AmplifierGroup::Mobility_OnLand,
|
|
AmplifierGroup::Mobility_OnSnow,
|
|
AmplifierGroup::Mobility_OnWater,
|
|
|
|
AmplifierGroup::Naval_TowedArry
|
|
};
|
|
}
|
|
|
|
|
|
QLatin1String SidcDefinitions::toString(EchelonBrigadeAndBelow value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case EchelonBrigadeAndBelow::Unknown:
|
|
return QLatin1String("Unknown");
|
|
case EchelonBrigadeAndBelow::TeamCrew:
|
|
return QLatin1String("TeamCrew");
|
|
case EchelonBrigadeAndBelow::Squad:
|
|
return QLatin1String("Squad");
|
|
|
|
case EchelonBrigadeAndBelow::Section:
|
|
return QLatin1String("Section");
|
|
case EchelonBrigadeAndBelow::PlatoonDetachment:
|
|
return QLatin1String("PlatoonDetachment");
|
|
case EchelonBrigadeAndBelow::BattalionSquadron:
|
|
return QLatin1String("BattalionSquadron");
|
|
|
|
case EchelonBrigadeAndBelow::CompanyBatteryTroop:
|
|
return QLatin1String("CompanyBatteryTroop");
|
|
case EchelonBrigadeAndBelow::RegimentGroup:
|
|
return QLatin1String("RegimentGroup");
|
|
case EchelonBrigadeAndBelow::Brigade:
|
|
return QLatin1String("Brigade");
|
|
} // switch
|
|
return QLatin1String("ERROR-EchelonBrigadeAndBelow");
|
|
}
|
|
|
|
|
|
QPixmap SidcDefinitions::toPixmap(EchelonBrigadeAndBelow value)
|
|
{
|
|
Q_UNUSED(value);
|
|
return QPixmap();
|
|
}
|
|
|
|
|
|
QVector<SidcDefinitions::EchelonBrigadeAndBelow> SidcDefinitions::echelonBrigadeAndBelows()
|
|
{
|
|
return { EchelonBrigadeAndBelow::Unknown,
|
|
EchelonBrigadeAndBelow::TeamCrew,
|
|
EchelonBrigadeAndBelow::Squad,
|
|
EchelonBrigadeAndBelow::Section,
|
|
EchelonBrigadeAndBelow::PlatoonDetachment,
|
|
EchelonBrigadeAndBelow::CompanyBatteryTroop,
|
|
EchelonBrigadeAndBelow::BattalionSquadron,
|
|
EchelonBrigadeAndBelow::RegimentGroup,
|
|
EchelonBrigadeAndBelow::Brigade
|
|
};
|
|
}
|
|
|
|
|
|
QLatin1String SidcDefinitions::toString(EchelonDivisionAndAbove value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case EchelonDivisionAndAbove::Unknown:
|
|
return QLatin1String("Unknown");
|
|
case EchelonDivisionAndAbove::Division:
|
|
return QLatin1String("Division");
|
|
case EchelonDivisionAndAbove::CorpsMEF:
|
|
return QLatin1String("CorpsMEF");
|
|
case EchelonDivisionAndAbove::Army:
|
|
return QLatin1String("Army");
|
|
case EchelonDivisionAndAbove::Army_GroupFront:
|
|
return QLatin1String("Army_GroupFront");
|
|
case EchelonDivisionAndAbove::RegionTheater:
|
|
return QLatin1String("RegionTheater");
|
|
case EchelonDivisionAndAbove::Command:
|
|
return QLatin1String("Command");
|
|
} // switch
|
|
return QLatin1String("ERROR-EchelonDivisionAndAbove");
|
|
}
|
|
|
|
QVector<SidcDefinitions::EchelonDivisionAndAbove> SidcDefinitions::echelonDivisionAndAboves()
|
|
{
|
|
return {EchelonDivisionAndAbove::Unknown,
|
|
EchelonDivisionAndAbove::Division,
|
|
EchelonDivisionAndAbove::CorpsMEF,
|
|
EchelonDivisionAndAbove::Army,
|
|
EchelonDivisionAndAbove::Army_GroupFront,
|
|
EchelonDivisionAndAbove::RegionTheater,
|
|
EchelonDivisionAndAbove::Command,
|
|
};
|
|
}
|
|
|
|
|
|
QLatin1String SidcDefinitions::toString(MobilityOnLand value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case MobilityOnLand::Unknown:
|
|
return QLatin1String("Unknown");
|
|
case MobilityOnLand::WheeledLimitedCrossCountry:
|
|
return QLatin1String("WheeledLimitedCrossCountry");
|
|
case MobilityOnLand::WheeledCrossCountry:
|
|
return QLatin1String("WheeledCrossCountry");
|
|
case MobilityOnLand::Tracked:
|
|
return QLatin1String("Tracked");
|
|
case MobilityOnLand::WheeledAndTrackedCombination:
|
|
return QLatin1String("WheeledAndTrackedCombination");
|
|
case MobilityOnLand::Towed:
|
|
return QLatin1String("Towed");
|
|
case MobilityOnLand::Rail:
|
|
return QLatin1String("Rail");
|
|
case MobilityOnLand::PackAnimal:
|
|
return QLatin1String("PackAnimal");
|
|
} // switch
|
|
return QLatin1String("ERROR-MobilityOnLand");
|
|
}
|
|
|
|
|
|
QPixmap SidcDefinitions::toPixmap(MobilityOnLand value)
|
|
{
|
|
Q_UNUSED(value);
|
|
return QPixmap();
|
|
}
|
|
|
|
|
|
QVector<SidcDefinitions::MobilityOnLand> SidcDefinitions::mobilityOnLands()
|
|
{
|
|
return { MobilityOnLand::Unknown,
|
|
MobilityOnLand::WheeledLimitedCrossCountry,
|
|
MobilityOnLand::WheeledCrossCountry,
|
|
MobilityOnLand::Tracked,
|
|
MobilityOnLand::WheeledAndTrackedCombination,
|
|
MobilityOnLand::Towed,
|
|
MobilityOnLand::Rail,
|
|
MobilityOnLand::PackAnimal
|
|
};
|
|
}
|
|
|
|
|
|
QLatin1String SidcDefinitions::toString(MobilityOnSnow value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case MobilityOnSnow::Unknown:
|
|
return QLatin1String("Unknown");
|
|
case MobilityOnSnow::OverSnow:
|
|
return QLatin1String("OverSnow");
|
|
case MobilityOnSnow::Sled:
|
|
return QLatin1String("Sled");
|
|
} // switch
|
|
return QLatin1String("ERROR-MobilityOnSnow");
|
|
}
|
|
|
|
|
|
QPixmap SidcDefinitions::toPixmap(MobilityOnSnow value)
|
|
{
|
|
Q_UNUSED(value);
|
|
return QPixmap();
|
|
}
|
|
|
|
|
|
QVector<SidcDefinitions::MobilityOnSnow> SidcDefinitions::mobilityOnSnows()
|
|
{
|
|
return { MobilityOnSnow::Unknown,
|
|
MobilityOnSnow::OverSnow,
|
|
MobilityOnSnow::Sled
|
|
};
|
|
}
|
|
|
|
QLatin1String SidcDefinitions::toString(MobilityOnWater value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case MobilityOnWater::Unknown:
|
|
return QLatin1String("Unknown");
|
|
case MobilityOnWater::Barge:
|
|
return QLatin1String("Barge");
|
|
case MobilityOnWater::Amphibious:
|
|
return QLatin1String("Amphibious");
|
|
} // switch
|
|
return QLatin1String("ERROR-MobilityOnWater");
|
|
}
|
|
|
|
|
|
QPixmap SidcDefinitions::toPixmap(MobilityOnWater value)
|
|
{
|
|
Q_UNUSED(value);
|
|
return QPixmap();
|
|
}
|
|
|
|
|
|
QVector<SidcDefinitions::MobilityOnWater> SidcDefinitions::mobilityOnWaters()
|
|
{
|
|
return { MobilityOnWater::Unknown,
|
|
MobilityOnWater::Barge,
|
|
MobilityOnWater::Amphibious
|
|
};
|
|
}
|
|
|
|
|
|
QLatin1String SidcDefinitions::toString(NavalTowedArray value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case NavalTowedArray::Unknown:
|
|
return QLatin1String("Unknown");
|
|
case NavalTowedArray::ShortTowedArray:
|
|
return QLatin1String("ShortTowedArray");
|
|
case NavalTowedArray::LongTowedArray:
|
|
return QLatin1String("LongTowedArray");
|
|
} // switch
|
|
return QLatin1String("ERROR-NavalTowedArray");
|
|
}
|
|
|
|
|
|
QPixmap SidcDefinitions::toPixmap(NavalTowedArray value)
|
|
{
|
|
Q_UNUSED(value);
|
|
return QPixmap();
|
|
}
|
|
|
|
|
|
QVector<SidcDefinitions::NavalTowedArray> SidcDefinitions::navalTowedArrays()
|
|
{
|
|
return {NavalTowedArray::Unknown,
|
|
NavalTowedArray::ShortTowedArray,
|
|
NavalTowedArray::LongTowedArray
|
|
};
|
|
}
|
|
|
|
QLatin1String SidcDefinitions::toString(SymbolSet value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case SymbolSet::Unknown:
|
|
return QLatin1String("Unknown");
|
|
case SymbolSet::Air:
|
|
return QLatin1String("Air");
|
|
case SymbolSet::AirMissle:
|
|
return QLatin1String("AirMissle");
|
|
case SymbolSet::Space:
|
|
return QLatin1String("Space");
|
|
case SymbolSet::SpaceMissle:
|
|
return QLatin1String("SpaceMissle");
|
|
case SymbolSet::LandUnit:
|
|
return QLatin1String("LandUnit");
|
|
case SymbolSet::LandCivilian_UnitOrganisation:
|
|
return QLatin1String("LandCivilian_UnitOrganisation");
|
|
case SymbolSet::LandEquipment:
|
|
return QLatin1String("LandEquipment");
|
|
case SymbolSet::LandInstallation:
|
|
return QLatin1String("LandInstallation");
|
|
case SymbolSet::ControlMeasure:
|
|
return QLatin1String("ControlMeasure");
|
|
case SymbolSet::DismountedIndividual:
|
|
return QLatin1String("DismountedIndividual");
|
|
case SymbolSet::SeaSurface:
|
|
return QLatin1String("SeaSurface");
|
|
case SymbolSet::SeaSubSurface:
|
|
return QLatin1String("SeaSubSurface");
|
|
case SymbolSet::MineWarfare:
|
|
return QLatin1String("MineWarfare");
|
|
case SymbolSet::Activities:
|
|
return QLatin1String("Activities");
|
|
case SymbolSet::Atmospheric:
|
|
return QLatin1String("Atmospheric");
|
|
case SymbolSet::Oceanographic:
|
|
return QLatin1String("Oceanographic");
|
|
case SymbolSet::MeteorologicalSpace:
|
|
return QLatin1String("MeteorologicalSpace");
|
|
case SymbolSet::SignalsIntelligence_Space:
|
|
return QLatin1String("SignalsIntelligence_Space");
|
|
case SymbolSet::SignalsIntelligence_Air:
|
|
return QLatin1String("SignalsIntelligence_Air");
|
|
case SymbolSet::SignalsIntelligence_Land:
|
|
return QLatin1String("SignalsIntelligence_Land");
|
|
case SymbolSet::SignalsIntelligence_Surface:
|
|
return QLatin1String("SignalsIntelligence_Surface");
|
|
case SymbolSet::SignalsIntelligence_Subsurface:
|
|
return QLatin1String("SignalsIntelligence_Subsurface");
|
|
case SymbolSet::Cyberspace:
|
|
return QLatin1String("Cyberspace");
|
|
} // switch
|
|
return QLatin1String("ERROR-SymbolSet");
|
|
}
|
|
|
|
|
|
QPixmap SidcDefinitions::toPixmap(SymbolSet value)
|
|
{
|
|
Q_UNUSED(value);
|
|
return QPixmap();
|
|
}
|
|
|
|
|
|
QVector<SidcDefinitions::SymbolSet> SidcDefinitions::symbolSets()
|
|
{
|
|
return {SymbolSet::Unknown,
|
|
SymbolSet::Air,
|
|
SymbolSet::AirMissle,
|
|
SymbolSet::Space,
|
|
SymbolSet::SpaceMissle,
|
|
SymbolSet::LandUnit,
|
|
SymbolSet::LandCivilian_UnitOrganisation,
|
|
SymbolSet::LandEquipment,
|
|
SymbolSet::LandInstallation,
|
|
SymbolSet::ControlMeasure,
|
|
SymbolSet::DismountedIndividual,
|
|
SymbolSet::SeaSurface,
|
|
SymbolSet::SeaSubSurface,
|
|
SymbolSet::MineWarfare,
|
|
SymbolSet::Activities,
|
|
SymbolSet::Atmospheric,
|
|
SymbolSet::Oceanographic,
|
|
SymbolSet::MeteorologicalSpace,
|
|
SymbolSet::SignalsIntelligence_Space,
|
|
SymbolSet::SignalsIntelligence_Air,
|
|
SymbolSet::SignalsIntelligence_Land,
|
|
SymbolSet::SignalsIntelligence_Surface,
|
|
SymbolSet::SignalsIntelligence_Subsurface,
|
|
SymbolSet::Cyberspace
|
|
};
|
|
}
|
|
|
|
QLatin1String SidcDefinitions::toString(Status value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case Status::Present:
|
|
return QLatin1String("Present");
|
|
case Status::Planned_Anticipated_Suspect:
|
|
return QLatin1String("Planned_Anticipated_Suspect");
|
|
case Status::Present_FullCapable:
|
|
return QLatin1String("Present_FullCapable");
|
|
case Status::Present_Damaged:
|
|
return QLatin1String("Present_Damaged");
|
|
case Status::Present_Destroyed:
|
|
return QLatin1String("Present_Destroyed");
|
|
case Status::Present_FullToCapacity:
|
|
return QLatin1String("Present_FullToCapacity");
|
|
} // switch
|
|
return QLatin1String("ERROR-Status");
|
|
}
|
|
|
|
|
|
QPixmap SidcDefinitions::toPixmap(Status value)
|
|
{
|
|
Q_UNUSED(value);
|
|
return QPixmap();
|
|
}
|
|
|
|
|
|
QVector<SidcDefinitions::Status> SidcDefinitions::statuss()
|
|
{
|
|
return
|
|
{
|
|
Status::Present,
|
|
Status::Planned_Anticipated_Suspect,
|
|
Status::Present_FullCapable,
|
|
Status::Present_Damaged,
|
|
Status::Present_Destroyed,
|
|
Status::Present_FullToCapacity
|
|
};
|
|
}
|
|
|
|
|
|
QStringList SidcDefinitions::modifierKeys() const
|
|
{
|
|
if (!m_esriDictProcessor)
|
|
{
|
|
ERROR_LOG(m_logger) << LOGFUNCTION << " no m_esriDictProcessor";
|
|
return QStringList();
|
|
}
|
|
return m_esriDictProcessor->symbolModifierKeys();
|
|
}
|
|
|
|
|
|
QVector<ModifierData> SidcDefinitions::modifierList(SidcDefinitions::SymbolSet symbolSet, unsigned int modifierSector) const
|
|
{
|
|
if (!m_esriDictProcessor)
|
|
{
|
|
ERROR_LOG(m_logger) << LOGFUNCTION << " no m_esriDictProcessor";
|
|
return QVector<ModifierData>();
|
|
}
|
|
return m_esriDictProcessor->symbolModifierList(symbolSet, modifierSector);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
std::ostream &operator<< (std::ostream &stream, const AdvancedSymbology::SidcDefinitions::ShapeType &value)
|
|
{
|
|
stream << "ShapeType(" << AdvancedSymbology::SidcDefinitions::toString(value)
|
|
<< ")";
|
|
return stream;
|
|
}
|
|
|
|
std::ostream &operator<< (std::ostream &stream, const AdvancedSymbology::SidcDefinitions::Identity &value)
|
|
{
|
|
stream << "Identity(" << AdvancedSymbology::SidcDefinitions::toString(value)
|
|
<< ")";
|
|
return stream;
|
|
}
|
|
|
|
std::ostream &operator<< (std::ostream &stream, const AdvancedSymbology::SidcDefinitions::SymbolSet &value)
|
|
{
|
|
stream << "SymbolSet(" << AdvancedSymbology::SidcDefinitions::toString(value)
|
|
<< ")";
|
|
return stream;
|
|
}
|
|
|
|
std::ostream &operator<< (std::ostream &stream, const AdvancedSymbology::SidcDefinitions::Status &value)
|
|
{
|
|
stream << "Status(" << AdvancedSymbology::SidcDefinitions::toString(value)
|
|
<< ")";
|
|
return stream;
|
|
}
|
|
|
|
|
|
} // namespace AdvancedSymbology
|