419 lines
15 KiB
C++
Executable File
419 lines
15 KiB
C++
Executable File
/**
|
|
* @RDE_HEADER@
|
|
* Interface of SymbolDictionary
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
*/
|
|
#pragma once
|
|
|
|
// Own
|
|
#include "advanced_symbology_export.h"
|
|
#include "symbol_dictionary_types.h"
|
|
#include "property_result.h"
|
|
#include "symbol_result.h"
|
|
|
|
#include "../SymbologyXML/symbol.h"
|
|
|
|
// Qt
|
|
#include <QImage>
|
|
#include <QString>
|
|
#include <QStringList>
|
|
|
|
|
|
// Forward
|
|
class QValidator;
|
|
|
|
|
|
# include <arcgis/arcgisversion.h> // This file is created by RME, not ESRI
|
|
|
|
#if ACRGIS_VERSION >= 0x640600 // 100.6.0 / Update 6
|
|
//# define USE_ARCADE_SYMBOLOGY
|
|
#endif
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
namespace AdvancedSymbology
|
|
{
|
|
|
|
/**
|
|
* @brief The SymbolDictionary class is the main class in this namespace.
|
|
* \section secCommon Common
|
|
* To create an instance
|
|
* - use static method SymbolDictionary::dictionary() (one instance per AdvancedSymbology::SymbologyType).
|
|
* - load the dictionary (on finish the signal loaded is emitted.)
|
|
*
|
|
* To support symbol independent from an official symbology standard you can add extra symbols: insertExtraSymbol.
|
|
*
|
|
* To get symbol information there are different approaches: search, find and fetch \n
|
|
* - searchSymbol() is looking for symbol by defining some strings or stringLists as definded at SearchParameters. \n
|
|
* The result contains one or more SymbolProperties in a list (SymbolPropertyList)
|
|
*
|
|
* - find... to get an QImage
|
|
* - findImage(), findPreview() is looking using a complete sidc. \n
|
|
* \sa \ref secfindImageExplanation
|
|
*
|
|
* - findBaseSymbol() is looking using the baseSymboCode (SymbolSet and Entity). \n
|
|
* If a abtract symbol is requested the first overload should be used. \n
|
|
*
|
|
* - fetchSymbol() is looking using a complete sidc for internal use. \n
|
|
*
|
|
* Most methods are using the future pattern.
|
|
* The result value (like PropertyResult and SymbolResult) will contain the real result - when available.
|
|
* To get a (ready)signal, a propper watcher is prepared: PropertyResultWatcher or SymbolResultWatcher.
|
|
*
|
|
* This is explained at the base class ResultWatcher.
|
|
*
|
|
*
|
|
* \section secfindImageExplanation Use proper find method
|
|
*
|
|
* There are following use cases:
|
|
*
|
|
* - PlayerInfoWindow \n
|
|
* PointSymbol with frame, modifier, injury; multiPointSymbol (maybe with concrete geometry) \n
|
|
* (THE tank of a concrete party/color with concrete modifier, injury...)
|
|
*
|
|
* - PlayerTree (SymbolSelectionDlg) \n
|
|
* (A tank of party 'Unknown', (with modifier like platoon, but no space for injury))
|
|
*
|
|
* - Favourites at PlanEditor \n
|
|
* (A tank, no party (black - just the baseSymbol)
|
|
*
|
|
* To get a suitable image for your use case youd should pay attention to following table:
|
|
*
|
|
| UseCase | Method | SinglePointSymbol | MultiPointSymbol |
|
|
| :----------------------------------------------------| : ---------------| : ---------------------------|: ------------------- |
|
|
| concrete Obj with partyColor,Frame,Modifier, Injury | findImage() | fetch | lookupTable (search) |
|
|
| abstract Obj with Frame (Unknown) | findPreview() | fetch | lookupTable (search) |
|
|
| abstract Obj without Frame/Modifier | findBaseSymbol() | lookupTable (search) | lookupTable (search) |
|
|
* (lookupTable == m_baseSymbolCodeToSymbolPropertyTable & m_originalKeyToEsriSymbol)
|
|
*
|
|
*/
|
|
class ADVANCED_SYMBOLOGY_EXPORT SymbolDictionary : public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
public:
|
|
static bool doParanoiaChecks();
|
|
|
|
|
|
protected:
|
|
|
|
/*! \name Construction, Destruction */
|
|
//@{
|
|
/**
|
|
* @brief Constructor.
|
|
* @param parent
|
|
*/
|
|
explicit SymbolDictionary(QObject *parent = nullptr);
|
|
|
|
public:
|
|
/**
|
|
* @brief Initialize the SymbologyResourcePath.
|
|
* @param symbologyType Type of symbology to initialize.
|
|
* @return resulting symbologyResourcePath
|
|
*/
|
|
static QString initializeSymbologyResourcePath(SymbologyType symbologyType);
|
|
|
|
/**
|
|
* @brief Get access to dictionary of a SymbologyType (singleton per SymbologyType)
|
|
* @param symbologyType The SymbologyType the Dictionary should base on.
|
|
* @param symbologyResourcePath ResourcePath to be set (e.g. /opt/EXTFW/resources/symbols/app6b).
|
|
* @return Reference to requested SymbolDictionary.
|
|
*/
|
|
static SymbolDictionary &dictionary(SymbologyType symbologyType);
|
|
|
|
/**
|
|
* @brief Does the requested SymbolDictionary already exists?
|
|
* @param symbologyType requested SymbologyType
|
|
* @return true if already existing, otherwise false
|
|
*/
|
|
static bool alreadyExists(SymbologyType symbologyType);
|
|
|
|
/**
|
|
* @brief Provide default SymbologyType
|
|
*/
|
|
static SymbologyType defaultSymbologyType();
|
|
|
|
/**
|
|
* @brief Defines default SymbologyType. Is been called while situation map is loading map settings.
|
|
* @param symbologyType SymbologyType to set as default
|
|
*/
|
|
static void setDefaultSymbologyType( SymbologyType symbologyType );
|
|
|
|
/**
|
|
* Returns state of dictionary. In case of failure the return value is false and in other case true.
|
|
*/
|
|
virtual bool isOk() const = 0;
|
|
|
|
/**
|
|
* @brief load
|
|
* Object can load data asynchronously.
|
|
* Call load() to initiate loading.
|
|
* If loading has finished the signal loaded is emitted.
|
|
*/
|
|
virtual void load() = 0;
|
|
|
|
/**
|
|
* @brief Information about Loading.
|
|
* @return true if loaded, otherwise false.
|
|
*/
|
|
virtual bool isLoaded() const = 0;
|
|
|
|
/**
|
|
* @brief Get current loadStatus
|
|
* @return
|
|
*/
|
|
virtual LoadStatus loadStatus() const = 0;
|
|
|
|
|
|
virtual ~SymbolDictionary() = default; ///< Destructor
|
|
//@}
|
|
|
|
|
|
/** \name Ets symbols
|
|
* To support symbol independent from an official symbology standard you can add ets symbols:
|
|
*/
|
|
//@{
|
|
/**
|
|
* @brief Insert (add/update) (own) ETS symbol to dictionary.
|
|
* @param sidc Symbol Id Code to add. If sidc is already in use, the entry (properties and image) is updated.
|
|
* @param properties To be associated to sidc.
|
|
* @param image To be associated to sidc.
|
|
* @return True on success, otherwise false.
|
|
*/
|
|
virtual bool setEtsSymbol(int fileId,
|
|
const QString &sidc,
|
|
const SymbolProperties &properties,
|
|
const QImage &image) = 0;
|
|
///< remove Extra symbol
|
|
virtual void removeEtsSymbol(int fileId) = 0;
|
|
virtual void removeEtsSymbol(const QString &sidc) = 0;
|
|
|
|
///< clear all Extra symbols
|
|
virtual void clearEtsSymbols() = 0;
|
|
|
|
///< add complete directory recursively with Extra symbols.
|
|
virtual int addEtsSymbols(const QString &path = QString()) = 0;
|
|
|
|
///< complete list of all Extra symbols.
|
|
virtual QStringList etsSymbols() const = 0;
|
|
|
|
/**
|
|
* @brief Number of Extra symbols
|
|
* @return number of Extra symbols
|
|
*/
|
|
virtual int etsSymbolCount() const = 0;
|
|
//@}
|
|
|
|
|
|
/** \name Xml symbols
|
|
* To support symbol independent from ESRI symbology standard you can add symbols base on symbol editor XML based format
|
|
*/
|
|
//@{
|
|
virtual bool containsXmlSymbol(const QString &sidc) const = 0; /**< Returns true in case of symbol is in dictionary, otherwise false. */
|
|
virtual bool setXmlSymbol(int fileId, const QString &name, const QString &operatorName, qint64 lastModified, const QString &xmlSymbol, const SymbolProperties &properties) = 0; /**< Inserts (add/update) a symbol from XML format and returns true on success. */
|
|
virtual bool setXmlSymbol(int fileId, const QString &name, const QString &operatorName, qint64 lastModified, const SymbologyXML::Symbol &symbol, const SymbolProperties &properties) = 0; /**< Inserts (add/update) a symbol from SymbologyXML::Symbol and returns true on success. */
|
|
virtual void removeXmlSymbol(int fileId) = 0; /**< Remove symbol from dictionary */
|
|
virtual void removeXmlSymbol(const QString &sidc) = 0; /**< Remove symbol from dictionary */
|
|
virtual void clearXmlSymbols() = 0; /**< Remove all symbols from dictionary */
|
|
virtual void clearXmlSymbolCache() = 0; /**< Clear internal Cache for XML-Symbols */
|
|
virtual int xmlSymbolCount() const = 0; /**< Pass back the number of XML symbols in dictonary */
|
|
virtual QStringList xmlSymbols() const = 0; /**< Returns a list of all XML symbol sidc's in dictionary */
|
|
virtual QString xmlSidc(const QString &xmlSymbol) const = 0; /**< Returns the sidc of a symbol */
|
|
virtual QString xmlSidc(const SymbologyXML::Symbol &symbol) const = 0; /**< Returns the sidc of a symbol */
|
|
|
|
virtual SymbologyXML::Symbol xmlSymbol(const QString &sidc) const = 0; /**< Pass back the SymbologyXML::Symbol of sidc */
|
|
virtual SymbolProperties xmlSymbolProps(const QString &sidc) const = 0; /**< Pass back the SymbolProperties of sidc */
|
|
//@}
|
|
|
|
public:
|
|
SymbolDictionary(const SymbolDictionary &other) = delete;
|
|
SymbolDictionary &operator=(const SymbolDictionary &other) = delete;
|
|
|
|
|
|
virtual SymbologyType symbologyType() const = 0;
|
|
virtual QString specificationType() const = 0;
|
|
|
|
virtual QString symbologyResourcePath() const = 0;
|
|
|
|
|
|
virtual int symbologySpecificCount() const = 0;
|
|
|
|
static QImage temporaryImage(int sizeL = 100);
|
|
|
|
/**
|
|
* @brief Get all known attribute keys which are interpreted by rendering process
|
|
*/
|
|
virtual QStringList symbologyAttributeKeyList() const = 0;
|
|
|
|
|
|
/** \name Search */
|
|
//@{
|
|
|
|
/**
|
|
* @brief Get a list of all cached symbol codes
|
|
*/
|
|
virtual QStringList cachedBaseSymbolCodes() const = 0;
|
|
|
|
/**
|
|
* @brief Get properties (like geometry) of one symbol.
|
|
* @param baseSymbolCode like '25270100' (2 digits symbol set and 6 digits entity), see SymbolProperties::concreteSidcToBaseSymbolCode
|
|
* @return SymbolProperties
|
|
* @see SymbolProperties
|
|
*/
|
|
virtual SymbolProperties symbolProperties(const QString &baseSymbolCode) const = 0;
|
|
|
|
virtual QSharedPointer<SymbolResult> symbolPropertyImage(const SymbolProperties &symbolProperties, int sizeL = 100) const = 0;
|
|
|
|
//@}
|
|
|
|
|
|
|
|
/*! \name Render symbol: findImage, findPreview, findBaseSymbol*/
|
|
//@{
|
|
|
|
/**
|
|
* @brief findImage returns a 'concrete' symbol containing mainIcon, frame, echelon, noPosition etc.
|
|
* This is also valid for extraSymbols.
|
|
* @param symDataToRender data to render
|
|
* @return Instance of class SymbolResult (based on the FuturePattern).
|
|
* @internal fullImage containing a coreImage and additionalSymbols
|
|
*/
|
|
virtual QSharedPointer<SymbolResult> findImage(const SymbolDataToRender &symDataToRender) const = 0;
|
|
|
|
/**
|
|
* @brief findPreview returns an 'abstract' / 'typical' symbol containing mainIcon and frame but no echelon noPosition etc.
|
|
* This is also valid for extraSymbols.
|
|
* @param sidc sidc to render
|
|
* @param sizeL referenceSize to render
|
|
* @return Instance of class SymbolResult (based on the FuturePattern).
|
|
*/
|
|
virtual QSharedPointer<SymbolResult> findPreview(const QString &sidc, int sizeL = 100) const = 0;
|
|
|
|
/**
|
|
* @brief findBaseSymbol returns an 'abstract' / 'typical' symbol containing the and nothing more.
|
|
* @param sidc_8or20chars sidc to render
|
|
* @return Instance of class SymbolResult (based on the FuturePattern).
|
|
*/
|
|
virtual QSharedPointer<SymbolResult> findBaseSymbol(const QString &sidc_8or20chars) const = 0;
|
|
//@}
|
|
|
|
/*! \name Fetch
|
|
* Similar to findImage, except that fetchSymbol returns a different baseSymbolIcon for multiPoint sidcs.
|
|
* In most cases you should prefer findImage, findPreview, findBaseSymbol
|
|
*/
|
|
//@{
|
|
/**
|
|
* @brief fetchSymbol for abstract symbols. Use a sidc a input
|
|
* Similar to findImage, except that fetchSymbol returns a different baseSymbolIcon for multiPoint sidcs.
|
|
* @param sidc to find
|
|
* @param sizeL specify the reference size. Named 'L' within the standard.
|
|
* @return Instance of class SymbolResult (based on the FuturePattern).
|
|
*/
|
|
virtual QSharedPointer<SymbolResult> fetchSymbol(const QString &sidc, int sizeL = 100) const = 0;
|
|
|
|
/**
|
|
* @brief fetchSymbol for concrete symbols. Use a sidc a input as well a specific color, injury...
|
|
* Similar to findImage, except that fetchSymbol returns a different baseSymbolIcon for multiPoint sidcs.
|
|
* @param symDataToRender specify the render hints.
|
|
* @return Instance of class SymbolResult (based on the FuturePattern).
|
|
*/
|
|
virtual QSharedPointer<SymbolResult> fetchSymbol(const SymbolDataToRender &symDataToRender) const = 0;
|
|
//@}
|
|
|
|
|
|
|
|
/*! \name Handling symbol modifier */
|
|
//@{
|
|
|
|
/**
|
|
* @brief Provides a list of all modifier keys
|
|
*/
|
|
virtual QStringList symbolModifierKeys() const = 0;
|
|
|
|
/**
|
|
* @brief Get modifier data according to a modifier key
|
|
* @param key One modifier key returned from symbolModifierKeys()
|
|
* @param modifierData Reference to return symbol set of the modifier
|
|
* @return true on success in other case false
|
|
*/
|
|
virtual bool symbolModifierData(const QString &key, ModifierData &data) const = 0;
|
|
|
|
/**
|
|
* @brief Provides a list of all modifiers matching to a symbolSet
|
|
* @param symbolSet symbol set
|
|
* @param modifierSector sector of the modifier, range of values [1,2]
|
|
* @see SymbolSet
|
|
*/
|
|
virtual QList<ModifierData> symbolModifierList(SidcDefinitions::SymbolSet symbolSet, unsigned int modifierSector) const = 0;
|
|
|
|
/**
|
|
* @brief Overloads the function symbolModifierList( SymbolSet ... ) to provide a list of all modifiers matching to a symbol. The symbol set is
|
|
* determined from baseSymbolCode
|
|
* @param baseSymbolCode baseSymbolCode like '25270100' (2 digits symbol set and 6 digits entity), see SymbolProperties::concreteSidcToBaseSymbolCode
|
|
* @param modifierSector sector of the modifier, range of values [1,2]
|
|
* @see SymbolProperties
|
|
*/
|
|
virtual QList<ModifierData> symbolModifierList(const QString &baseSymbolCode, unsigned int modifierSector) const = 0;
|
|
|
|
|
|
|
|
//@}
|
|
|
|
|
|
// virtual QValidator *buildSidcPatternValidator(QObject *parent) const = 0;
|
|
|
|
|
|
/**
|
|
* @brief Test one XML symbol
|
|
*/
|
|
virtual bool insertXmlTestSymbol(const SymbolProperties &symbolProps) = 0;
|
|
virtual bool insertXmlComplexTestSymbol(const SymbolProperties &symbolProps) = 0;
|
|
//-------------------------------
|
|
|
|
|
|
virtual int count() const = 0;
|
|
|
|
// virtual const QStringList &sidcList() const = 0;
|
|
|
|
|
|
|
|
|
|
/**
|
|
* @brief createSidc in: abtract sidc, out: concrete sidc:
|
|
* @param sidc_inOut
|
|
* @param identity
|
|
* @param state
|
|
*/
|
|
// virtual void createSidc(QString &sidc_inOut,
|
|
// SymbolTypes::t_affil identity, // friend, neutral... (position 2)
|
|
// SymbolTypes::t_state state) const = 0; // present, anticipated (position 4)
|
|
|
|
// virtual bool contains(const QString &sidc) const = 0;
|
|
|
|
|
|
// virtual SymbolProperties symbolProperties(const QString &sidc) = 0;
|
|
|
|
// virtual int minNumberOfPoints(const QString &sidc) = 0;
|
|
|
|
|
|
virtual QString toString() const = 0;
|
|
|
|
|
|
Q_SIGNALS:
|
|
/// Signal emits when content changed
|
|
void changed();
|
|
void changedDelayed(); // to avoid multiple signals (delayed for ~500ms)
|
|
|
|
/// Signal emits when dictionay is loaded
|
|
void loaded();
|
|
};
|
|
|
|
|
|
void cleanupSymbolDictionaryInternal();
|
|
|
|
|
|
} // namespace AdvancedSymbology
|
|
|