Initial commit

Lts/Viewer/SituationMap/SymbologyGui/CMakeLists.txt

@@ -0,0 +1,46 @@
+#
+# $Id$
+# $HeadURL$
+# $Author$
+#
+
+# LIBRARY
+
+SET(SymbologyGui_SRCS
+  base_symbol_lookup_dialog.cpp
+  base_symbol_lookup_dialog.h
+  base_symbol_lookup_widget.cpp
+  base_symbol_lookup_widget.h
+  field_table_model.cpp
+  field_table_model.h
+  symbol_modification_widget.h
+  symbol_modification_widget.cpp
+  symbol_modification_dialog.h
+  symbol_modification_dialog.cpp
+)
+
+SOURCE_GROUP(SymbologyGui FILES ${SymbologyGui_SRCS})
+
+NGL_WRAP_UI(SymbologyGui_SRCS
+  base_symbol_lookup_widget.ui
+)
+
+NGL_ADD_LIBRARY2(WS advancedSymbologyGui SHARED ${SymbologyGui_SRCS})
+
+NGL_TARGET_INCLUDE_DIRECTORIES(advancedSymbologyGui
+  PUBLIC
+     ${CMAKE_CURRENT_SOURCE_DIR}/..
+     ${CMAKE_CURRENT_SOURCE_DIR}/../../../Common
+)
+
+NGL_TARGET_LINK_LIBRARIES(advancedSymbologyGui
+  PRIVATE
+    Qt5::Gui
+    Qt5::Network
+  PUBLIC
+    LtsWidgets
+    LtsUtilsSettings
+    advancedSymbology
+    situationMap
+    Qt5::Core
+)

Lts/Viewer/SituationMap/SymbologyGui/base_symbol_filter_proxy.cpp

@@ -0,0 +1,329 @@
+/**
+**
+** @RDE_HEADER@
+** PlanEditor.
+** $Id$
+** $HeadURL$
+** $Author$
+**
+** -----------------------------------------------------------------------------------------------
+**
+** Hardware-Environment: Intel-PC
+** Software-Environment: Windows 7, Qt 5.4. ArcGIS 10.2.5
+**
+** Language ........: C++ 11
+**
+** -----------------------------------------------------------------------------------------------
+**
+** Author ...........: Jörg Turla, SPD G, Tel. 3132
+**
+** -----------------------------------------------------------------------------------------------
+**
+** Notes .........:
+**
+**   13.06.2016, JT  : First edition for use with Qt5
+**
+** -----------------------------------------------------------------------------------------------
+*/
+
+
+#include "base_symbol_filter_proxy.h"
+
+#include <Symbology/symbol_dictionary.h>
+#include <Symbology/sidc_builder_base.h>
+#include <Symbology/sidc_codec.h>
+
+#include <QtCore/QByteArray>
+#include <QtCore/QMimeData>
+#include <QtCore/QSet>
+
+
+namespace AdvancedSymbology
+{
+namespace Gui
+{
+
+struct BaseSymbolProxyFilter::InternalData
+{
+  QStringList m_sidcList;
+  QStringList m_keyList;
+  // no need for QHash/QSet - element count is very small
+  QVector<AdvancedSymbology::GeometryType> m_geometrySet = {GeometryType::Point, GeometryType::Polyline, GeometryType::Polygon};
+  bool        m_filterParicipantSymbols = false;
+  bool        m_etsSymbols = true;
+  bool        m_xmlSymbols = true;
+  bool        m_esriDictSymbols = true;
+
+}; // class BaseSymbolProxyFilter::InternalData
+
+
+BaseSymbolProxyFilter::BaseSymbolProxyFilter(QObject *parent)
+  : QSortFilterProxyModel(parent)
+  , m_internal(new InternalData())
+{}
+
+BaseSymbolProxyFilter::~BaseSymbolProxyFilter()
+{
+  delete m_internal;
+} // BaseSymbolProxyFilter::~BaseSymbolProxyFilter()
+
+QStringList  BaseSymbolProxyFilter::mimeTypes() const
+{
+  QStringList mineTypeList = QSortFilterProxyModel::mimeTypes();
+  mineTypeList << QStringLiteral("Participant");
+  return mineTypeList;
+} // QStringList  BaseSymbolProxyFilter::mimeTypes() const
+
+
+QMimeData *BaseSymbolProxyFilter::mimeData(const QModelIndexList &indexes) const
+{
+  QMimeData *mimeData = QSortFilterProxyModel::mimeData(indexes);
+  
+  if (mimeData)
+  {
+    const QByteArray &data = QByteArray::number(int(filterParticipants()));
+    mimeData->setData(QStringLiteral("Participant"), data);
+  }
+
+  return mimeData;
+} // QMimeData * BaseSymbolProxyFilter::mimeData(const QModelIndexList &indexes) const
+
+
+void BaseSymbolProxyFilter::updateModel(const QStringList &keyList)
+{
+  m_internal->m_keyList = keyList;
+
+  if (keyList.isEmpty())
+  {
+    m_internal->m_sidcList.clear();
+    invalidateFilter();
+    return;
+  }
+
+  const AdvancedSymbology::SymbolDictionary &dict = symbolDictionary();
+
+  AdvancedSymbology::SearchParameters lookupDefs;
+
+  lookupDefs.tags = keyList;
+  lookupDefs.symbolClasses = QStringList({QStringLiteral("3"), QStringLiteral("4"), QStringLiteral("5")});
+
+  AdvancedSymbology::PropertyResultWatcher *symbolGuard  = new AdvancedSymbology::PropertyResultWatcher(this);
+
+  connect(symbolGuard, &AdvancedSymbology::SymbolResultWatcher::resultReady, this, [this, symbolGuard]()
+  {
+    BaseSymbolModel *sidcLookupModel = static_cast<BaseSymbolModel *>(sourceModel());
+    if (!sidcLookupModel)
+      return;
+
+    QSharedPointer<AdvancedSymbology::PropertyResult> lookupResult = symbolGuard->propertyResult();
+    const SymbolPropertyList &symbolPropertyList = lookupResult->properties();
+    if (symbolPropertyList.isEmpty())
+      return;
+
+    {
+      m_internal->m_sidcList.clear();
+      for (const AdvancedSymbology::SymbolProperties &prop : symbolPropertyList)
+      {
+        const QString &baseSymbolCode = SidcCodec::encodeBaseSymbolCode(symbolDictionary().symbologyType(), prop.key());
+        QString        sidc           = AdvancedSymbology::SidcBuilderBase::baseSymbolCodeToSidc(baseSymbolCode);
+        
+        if (sidc.isEmpty()) sidc = prop.sidc(); // case of ETS and XML symbol the props.key() is the filename and sidc will be empty
+
+        if (sidcLookupModel->isInModel(sidc))
+        {
+          m_internal->m_sidcList += sidc;
+        }
+      }
+      invalidateFilter();
+    }
+    symbolGuard->deleteLater();
+  });
+
+  symbolGuard->setPropertyResult(dict.searchSymbols(lookupDefs));
+
+} // void BaseSymbolProxyFilter::updateModel( const QStringList & keyList )
+
+
+bool BaseSymbolProxyFilter::filterAcceptsRow(int sourceRow, const QModelIndex &) const
+{
+  BaseSymbolModel *sidcLookupModel = static_cast<BaseSymbolModel *>(sourceModel());
+  const QString    &sidc           = sidcLookupModel->getSidc(sourceRow);
+
+  bool accept = (m_internal->m_sidcList.isEmpty()) ? true : m_internal->m_sidcList.contains(sidc);
+
+  SidcCodec::SidcType sidcType = SidcCodec::decodeSidcType(sidc);
+
+  accept = (accept) ? (    (!SidcCodec::isCivil(sidc) && m_internal->m_esriDictSymbols)
+                        || (m_internal->m_etsSymbols && (SidcCodec::SidcType::CivilEts == sidcType))
+                        || (m_internal->m_xmlSymbols && (SidcCodec::SidcType::CivilXml == sidcType)) ) : false;
+
+  if (accept)
+  {
+    if (m_internal->m_filterParicipantSymbols)
+      accept = m_internal->m_geometrySet.contains(GeometryType::Point) && sidcLookupModel->isParticipant(sourceRow);
+    else
+      accept = m_internal->m_geometrySet.contains(sidcLookupModel->getSymbolGeometry(sourceRow));
+  }
+  return accept;
+} // bool BaseSymbolProxyFilter::filterAcceptsRow( int sourceRow, const QModelIndex & sourceParent )
+
+
+const AdvancedSymbology::SymbolDictionary &BaseSymbolProxyFilter::symbolDictionary() const
+{
+  BaseSymbolModel *sidcLookupModel = static_cast<BaseSymbolModel *>(sourceModel());
+  return sidcLookupModel->symbolDictionary();
+} // const AdvancedSymbology::SymbolDictionary & BaseSymbolProxyFilter::symbolDictionary()
+
+
+void BaseSymbolProxyFilter::setSourceModel(BaseSymbolModel *sourceModel)
+{
+  setSourceModel(static_cast<QAbstractItemModel *>(sourceModel));
+} // void BaseSymbolProxyFilter::setSourceModel(  AdvancedSymbologyGui::BaseSymbolModel * sourceModel )
+
+
+bool BaseSymbolProxyFilter::isEmpty() const
+{
+  BaseSymbolModel *sidcLookupModel = static_cast<BaseSymbolModel *>(sourceModel());
+  return sidcLookupModel->isEmpty();
+} // bool BaseSymbolProxyFilter::isEmpty() const
+
+
+QString BaseSymbolProxyFilter::getSidc(int idx) const
+{
+  const QModelIndex &sourceIndex     = mapToSource(index(idx, 0));
+  BaseSymbolModel *sidcLookupModel = static_cast<BaseSymbolModel *>(sourceModel());
+  return sidcLookupModel->getSidc(sourceIndex.row());
+} // QString BaseSymbolProxyFilter::getSidc( int idx ) const
+
+
+int BaseSymbolProxyFilter::size() const
+{
+  BaseSymbolModel *sidcLookupModel = static_cast<BaseSymbolModel *>(sourceModel());
+  return sidcLookupModel->size();
+} // int BaseSymbolProxyFilter::size() const
+
+
+const QStringList &BaseSymbolProxyFilter::filterSymbolTags() const
+{
+  return m_internal->m_keyList;
+} // const QStringList & BaseSymbolProxyFilter::filterSymbolTags() const
+
+
+bool BaseSymbolProxyFilter::filterPoints() const
+{
+  return m_internal->m_geometrySet.contains(AdvancedSymbology::GeometryType::Point);
+} // bool BaseSymbolProxyFilter::filterPoints() const
+
+
+bool BaseSymbolProxyFilter::filterLines() const
+{
+  return m_internal->m_geometrySet.contains(AdvancedSymbology::GeometryType::Polyline);
+} // bool BaseSymbolProxyFilter::filterLines() const
+
+
+bool BaseSymbolProxyFilter::filterAreas() const
+{
+  return m_internal->m_geometrySet.contains(AdvancedSymbology::GeometryType::Polygon);
+} // bool BaseSymbolProxyFilter::filterAreas() const
+
+
+bool BaseSymbolProxyFilter::filterParticipants() const
+{
+  return m_internal->m_filterParicipantSymbols;
+} // bool BaseSymbolProxyFilter::filterParticipants() const
+
+
+bool BaseSymbolProxyFilter::filterExtraSymbols() const
+{
+  return m_internal->m_etsSymbols &&  m_internal->m_xmlSymbols;
+} // bool BaseSymbolProxyFilter::filterExtraSymbols() const
+
+bool BaseSymbolProxyFilter::filterEtsSymbols() const
+{
+  return m_internal->m_etsSymbols;
+} // bool BaseSymbolProxyFilter::filterEtsSymbols() const
+
+bool BaseSymbolProxyFilter::filterXmlSymbols() const
+{
+  return m_internal->m_xmlSymbols;
+} // bool BaseSymbolProxyFilter::filterXmlSymbols() const
+
+bool BaseSymbolProxyFilter::filterEsriDictSymbols() const
+{
+  return m_internal->m_esriDictSymbols;
+} // bool BaseSymbolProxyFilter::filterXmlSymbols() const
+
+
+void BaseSymbolProxyFilter::onFilterSymbolTags(const QStringList &keyList)
+{
+  updateModel(keyList);
+} // void BaseSymbolProxyFilter::onFilterSymbolTags(const QStringList &keyList)
+
+void BaseSymbolProxyFilter::onFilterExtraSymbols(bool on)
+{
+  if (m_internal->m_etsSymbols == on && m_internal->m_xmlSymbols == on)
+    return;
+  m_internal->m_etsSymbols = on;
+  m_internal->m_xmlSymbols = on;
+  invalidateFilter();
+} // void BaseSymbolProxyFilter::onFilterExtraSymbols(bool on)
+
+
+void BaseSymbolProxyFilter::onFilterEtsSymbols(bool on)
+{
+  if (m_internal->m_etsSymbols == on)
+    return;
+  m_internal->m_etsSymbols = on;
+  invalidateFilter();
+} // void BaseSymbolProxyFilter::onFilterEtsSymbols(bool on)
+
+void BaseSymbolProxyFilter::onFilterXmlSymbols(bool on)
+{
+  if (m_internal->m_xmlSymbols == on)
+    return;
+  m_internal->m_xmlSymbols = on;
+  invalidateFilter();
+} // void BaseSymbolProxyFilter::onFilterXmlSymbols(bool on)
+
+
+void BaseSymbolProxyFilter::onFilterEsriDictSymbols(bool on)
+{
+  if (m_internal->m_esriDictSymbols == on)
+    return;
+  m_internal->m_esriDictSymbols = on;
+  invalidateFilter();
+} // void BaseSymbolProxyFilter::onFilterXmlSymbols(bool on)
+
+void BaseSymbolProxyFilter::onFilterParticipants(bool on)
+{
+  if (m_internal->m_filterParicipantSymbols == on)
+    return;
+  m_internal->m_filterParicipantSymbols = on;
+  invalidateFilter();
+} // void BaseSymbolProxyFilter::onFilterParticipants(bool on)
+
+void BaseSymbolProxyFilter::onFilterPoints(bool on)
+{
+  if (on) m_internal->m_geometrySet.push_back(AdvancedSymbology::GeometryType::Point);
+  else    m_internal->m_geometrySet.removeAll(AdvancedSymbology::GeometryType::Point);
+  invalidateFilter();
+} // void BaseSymbolProxyFilter::onFilterPoints(bool on)
+
+
+void BaseSymbolProxyFilter::onFilterLines(bool on)
+{
+  if (on) m_internal->m_geometrySet.push_back(AdvancedSymbology::GeometryType::Polyline);
+  else    m_internal->m_geometrySet.removeAll(AdvancedSymbology::GeometryType::Polyline);
+  invalidateFilter();
+} // void BaseSymbolProxyFilter::onFilterLines(bool on)
+
+
+void BaseSymbolProxyFilter::onFilterAreas(bool on)
+{
+  if (on) m_internal->m_geometrySet.push_back(AdvancedSymbology::GeometryType::Polygon);
+  else    m_internal->m_geometrySet.removeAll(AdvancedSymbology::GeometryType::Polygon);
+  invalidateFilter();
+} // void BaseSymbolProxyFilter::onFilterAreas(bool on)
+
+} // namespace Gui
+} // namespace AdvancedSymbology

Lts/Viewer/SituationMap/SymbologyGui/base_symbol_filter_proxy.h

@@ -0,0 +1,142 @@
+/**
+**
+** @RDE_HEADER@
+** PlanEditor.
+** $Id$
+** $HeadURL$
+** $Author$
+**
+** -----------------------------------------------------------------------------------------------
+**
+** Hardware-Environment: Intel-PC
+** Software-Environment: Windows 7, Qt 5.4. ArcGIS 10.2.5
+**
+** Language ........: C++ 11
+**
+** -----------------------------------------------------------------------------------------------
+**
+** Author ...........: Jörg Turla, SPD G, Tel. 3132
+**
+** -----------------------------------------------------------------------------------------------
+**
+** Notes .........:
+**
+**   13.06.2016, JT  : First edition for use with Qt5
+**
+** -----------------------------------------------------------------------------------------------
+*/
+
+
+#pragma once
+
+#include "base_symbol_model.h"
+
+#include <QString>
+#include <QStringList>
+#include <QSortFilterProxyModel>
+
+
+namespace AdvancedSymbology
+{
+namespace Gui
+{
+/**
+   @brief Filter proxy to BaseSymbolModel to retain list of symbols
+
+   To retain the full list of symbols to a smaller list which can be easier handled
+   by the user a QSortFilterProxyModel is used.
+
+   @see BaseSymbolModel, BaseSymbolLookupWidget
+
+ */
+
+class ADVANCED_SYMBOLOGY_GUI_EXPORT BaseSymbolProxyFilter : public QSortFilterProxyModel
+{
+  Q_OBJECT
+
+public:
+
+  explicit BaseSymbolProxyFilter(QObject *parent = nullptr);
+
+  ~BaseSymbolProxyFilter();
+
+  const AdvancedSymbology::SymbolDictionary &symbolDictionary() const;
+
+  void setSourceModel(AdvancedSymbology::Gui::BaseSymbolModel *sourceModel);
+
+  int size() const;
+
+  bool isEmpty() const;
+
+  /**
+     Provides the code of the symbol as string.
+     @param idx row number of the symbol
+     @return full concret sidc of symbol
+   */
+  QString getSidc(int idx) const;
+
+  /**
+     Provides current constraints to filter full symbol list of BaseSymbolModel
+     @{
+   */
+  const QStringList &filterSymbolTags() const;
+
+  bool filterExtraSymbols() const;
+  bool filterEtsSymbols() const;
+  bool filterXmlSymbols() const;
+  bool filterEsriDictSymbols() const;
+
+  bool filterParticipants() const;
+
+  bool filterPoints() const;
+  bool filterLines()  const;
+  bool filterAreas()  const;
+  /* @} */
+
+  QStringList  mimeTypes() const override;
+  QMimeData  * mimeData(const QModelIndexList &indexes) const override;
+
+protected:
+
+  struct InternalData;
+
+  InternalData *m_internal;
+
+  /**
+     Internal update of filtering tags by using the dictionary (is called from \ c onFilterSymbolTags).
+   */
+  void updateModel(const QStringList &keyList);
+
+  /**
+     Overriden from QSortFilterProxyModel to associate source model with filter model.
+   */
+  void setSourceModel(QAbstractItemModel *sourceModel) override { QSortFilterProxyModel::setSourceModel(sourceModel); }
+
+  /**
+     Overriden from QSortFilterProxyModel to do the filtering.
+   */
+  bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const override;
+
+public slots:
+
+  /**
+    Define constraints to filter full symbol list of BaseSymbolModel
+    @{
+    */
+  void onFilterSymbolTags(const QStringList &keyList);
+
+  void onFilterExtraSymbols(bool on);
+  void onFilterEtsSymbols(bool on);
+  void onFilterXmlSymbols(bool on);
+  void onFilterEsriDictSymbols(bool on);
+
+  void onFilterParticipants(bool on);
+
+  void onFilterPoints(bool on);
+  void onFilterLines(bool on);
+  void onFilterAreas(bool on);
+  /* @} */
+}; // BaseSymbolProxyFilter
+
+} // namespace Gui
+} // namespace AdvancedSymbology

Lts/Viewer/SituationMap/SymbologyGui/base_symbol_lookup_dialog.cpp

@@ -0,0 +1,210 @@
+/**
+  * @RDE_HEADER@
+  * Dialog for selecting (base) symbols
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Norbert Thoden, NLE, 12.12.2019
+  */
+
+#include "base_symbol_lookup_dialog.h"
+#include "base_symbol_lookup_widget.h"
+#include <LtsWidgets/lts_dialog_button_box.h>
+#include <LtsUtilsSettings/settings.h>
+
+#include <Symbology/symbol_dictionary.h>
+#include <SymbologyImpl/symbol_dictionary_impl.h>
+#include <SymbologyImpl/base_symbol_model.h>
+
+#include <Symbology/sidc_builder_base.h> // for baseSymbolCodeToSidc
+
+#include <QVBoxLayout>
+#include <QHash>
+#include <QPointer>
+
+
+namespace AdvancedSymbology
+{
+namespace Gui
+{
+
+//------------------------------------------------------------------------------
+// BaseSymbolLookupDialog::Private
+//------------------------------------------------------------------------------
+struct BaseSymbolLookupDialog::Private
+{
+public:
+  Private() = default;
+
+  ~Private()
+  {
+    delete m_baseSymbolWidget;
+    delete m_buttonBox;
+  }
+  BaseSymbolLookupWidget       *m_baseSymbolWidget = nullptr;
+  LtsWidgets::LtsDialogButtonBox *m_buttonBox        = nullptr;
+};
+
+
+//------------------------------------------------------------------------------
+// BaseSymbolLookupDialog
+//------------------------------------------------------------------------------
+BaseSymbolLookupDialog::BaseSymbolLookupDialog(QWidget *parent)
+  : BaseClass(parent, LtsWidgets::Behaviour::Modal)
+  , m_logger(getLogger("BaseSymbolLookupDialog"))
+  , d(new Private())
+{
+  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
+  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
+}
+
+bool BaseSymbolLookupDialog::participantMode() const
+{
+  if (!d->m_baseSymbolWidget)
+    return false;
+  return d->m_baseSymbolWidget->participantMode();
+}
+void BaseSymbolLookupDialog::setParticipantMode(bool onOff)
+{
+  if (!d->m_baseSymbolWidget)
+    return;
+  d->m_baseSymbolWidget->setParticipantMode(onOff);
+}
+
+void BaseSymbolLookupDialog::setValidBaseSymbolCodes(const QSet<QString> &validBaseSymbolCodes)
+{
+  if (!d->m_baseSymbolWidget)
+    return;
+  d->m_baseSymbolWidget->setValidBaseSymbolCodes(validBaseSymbolCodes);
+}
+
+bool BaseSymbolLookupDialog::init(AdvancedSymbology::SymbolDictionary &symbolDictionary)
+{
+  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
+
+  LtsUtils::ProjectSettings *ps = LtsUtils::ProjectSettings::getInstance();
+
+  bool  enableEtsSymbols =  ps->value(QStringLiteral("SituationMap"), QStringLiteral("enableEtsSymbols"), true).toBool();
+
+  // setup:
+  delete d->m_baseSymbolWidget;
+  delete d->m_buttonBox;
+
+  AdvancedSymbology::SymbolDictionaryImpl &sdi = static_cast<AdvancedSymbology::SymbolDictionaryImpl &>(symbolDictionary);
+  AdvancedSymbology::BaseSymbolModel *bsmEsri = sdi.getBaseSymbolModelEsri();
+  AdvancedSymbology::BaseSymbolModel *bsmXml  = sdi.getBaseSymbolModelXML();
+  AdvancedSymbology::BaseSymbolModel *bsmEts  = sdi.getBaseSymbolModelEts();
+
+  DEBUG_LOG(m_logger) << LOGFUNCTION << " bsmEsri rowCount" << bsmEsri->rowCount();
+  const SymbologyType symbologyType = sdi.symbologyType();
+  AdvancedSymbology::Gui::MODEL_CONT modelCont;
+  modelCont.append(AdvancedSymbology::Gui::ModelItem(AdvancedSymbology::Gui::SYMBOL_TYPE::ESRI, toString(symbologyType),                bsmEsri));
+  modelCont.append(AdvancedSymbology::Gui::ModelItem(AdvancedSymbology::Gui::SYMBOL_TYPE::XML,  QLatin1String("User-defined Symbols"), bsmXml));
+  if (enableEtsSymbols )
+    modelCont.append(AdvancedSymbology::Gui::ModelItem(AdvancedSymbology::Gui::SYMBOL_TYPE::ETS,  QLatin1String("Ets"),                  bsmEts));
+
+  d->m_baseSymbolWidget = new AdvancedSymbology::Gui::BaseSymbolLookupWidget(modelCont, this);
+
+  connect(d->m_baseSymbolWidget, &AdvancedSymbology::Gui::BaseSymbolLookupWidget::symbolClicked,       this, &BaseSymbolLookupDialog::onSymbolClicked);
+  connect(d->m_baseSymbolWidget, &AdvancedSymbology::Gui::BaseSymbolLookupWidget::symbolDoubleClicked, this, &BaseSymbolLookupDialog::onSymbolDoubleClicked);
+
+
+  d->m_buttonBox = new LtsWidgets::LtsDialogButtonBox(this);
+
+  connect(d->m_buttonBox->getButton(LtsWidgets::DialogButton::Ok),    &QPushButton::clicked, this, &BaseSymbolLookupDialog::apply);
+  connect(d->m_buttonBox->getButton(LtsWidgets::DialogButton::Close), &QPushButton::clicked, this, &BaseSymbolLookupDialog::close);
+
+  d->m_buttonBox->getButton(LtsWidgets::DialogButton::Ok)->setEnabled(false); // until an item is selected
+
+
+  // setup layout:
+  QVBoxLayout *layout = new QVBoxLayout();
+
+  layout->addWidget(d->m_baseSymbolWidget, 2);
+  layout->addWidget(d->m_buttonBox);
+  setLayout(layout);
+
+  setMinimumWidth(800);
+  resize(sizeHint().height(), minimumWidth());
+  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
+  return true;
+}
+
+BaseSymbolLookupDialog::~BaseSymbolLookupDialog()
+{
+  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
+  delete d;
+  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
+}
+
+QString BaseSymbolLookupDialog::getCurrentBaseSymbolCode() const
+{
+  if (!d->m_baseSymbolWidget)
+    return QString();
+  return d->m_baseSymbolWidget->getCurrentBaseSymbolCode();
+}
+
+bool BaseSymbolLookupDialog::setCurrentSidc(const QString &sidc)
+{
+  if (!d->m_baseSymbolWidget)
+    return false;
+  bool success = d->m_baseSymbolWidget->setCurrentSidc(sidc);
+//  d->m_buttonBox->getButton(LtsWidgets::DialogButton::Ok)->setEnabled(success);
+  return success;
+}
+
+void BaseSymbolLookupDialog::onSymbolClicked(const QString &baseSymbolCode, const QString &sidc)
+{
+  TRACE_LOG(m_logger) << LOGFUNCTION << " START, "
+                      << " baseSymbolCode='" << baseSymbolCode << "'"
+                      << " sidc='" << sidc << "'";
+
+  d->m_buttonBox->getButton(LtsWidgets::DialogButton::Ok)->setEnabled(!sidc.isEmpty());
+
+//  slotChangesMade();
+}
+
+void BaseSymbolLookupDialog::onSymbolDoubleClicked(const QString &baseSymbolCode, const QString &sidc)
+{
+  TRACE_LOG(m_logger) << LOGFUNCTION << " START, "
+                      << " baseSymbolCode='" << baseSymbolCode << "'"
+                      << " sidc='" << sidc << "'";
+  apply();
+}
+
+void BaseSymbolLookupDialog::apply()
+{
+  if (!d->m_baseSymbolWidget)
+    return ;
+  QSharedPointer<BaseSymbolItem> bsi = d->m_baseSymbolWidget->getCurrentBaseSymbolItem();
+  if (!bsi)
+    return;
+
+  const QString &curBsc = bsi->baseSymbolCode();
+  const QString &curSidc = bsi->sidc();
+
+  emit lookupAppliedBaseSymbolCode(curBsc);
+  emit lookupAppliedCompleteSidc(curSidc);
+  accept();
+}
+
+BaseSymbolLookupDialog *BaseSymbolLookupDialog::showInstance()
+{
+  static QPointer<BaseSymbolLookupDialog> s_BaseSymbolLookupDialog;
+
+  if (!s_BaseSymbolLookupDialog)
+    s_BaseSymbolLookupDialog = createDlg();
+
+  return s_BaseSymbolLookupDialog;
+}
+
+BaseSymbolLookupDialog *BaseSymbolLookupDialog::createDlg(QWidget *parent)
+{
+  AdvancedSymbology::Gui::BaseSymbolLookupDialog *dlg = new AdvancedSymbology::Gui::BaseSymbolLookupDialog(parent);
+  dlg->init(AdvancedSymbology::SymbolDictionary::dictionary(AdvancedSymbology::SymbolDictionary::defaultSymbologyType()));
+  return dlg;
+}
+
+
+} // namespace Gui
+} // namespace AdvancedSymbology

Lts/Viewer/SituationMap/SymbologyGui/base_symbol_lookup_dialog.h

@@ -0,0 +1,76 @@
+/**
+  * @RDE_HEADER@
+  * Dialog for selecting (base) symbols
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Norbert Thoden, NLE, 12.12.2019
+  */
+
+#pragma once
+
+#include <SymbologyGui/advancedsymbologygui_export.h>
+#include <Symbology/symbology_type.h>
+#include <Common/situation_map_logging.h>
+#include <LtsWidgets/lts_frameless_dialog.h>
+
+
+namespace AdvancedSymbology
+{
+class SymbolDictionary;
+
+
+namespace Gui
+{
+
+//------------------------------------------------------------------------------
+// BaseSymbolLookupDialog
+//------------------------------------------------------------------------------
+class ADVANCEDSYMBOLOGYGUI_EXPORT BaseSymbolLookupDialog : public LtsWidgets::LtsFramelessDialog
+{
+  Q_OBJECT
+  using BaseClass = LtsWidgets::LtsFramelessDialog;
+
+public:
+  static BaseSymbolLookupDialog *showInstance();
+
+  static BaseSymbolLookupDialog *createDlg(QWidget *parent = nullptr);
+
+
+  explicit BaseSymbolLookupDialog(QWidget *parent = nullptr);
+  ~BaseSymbolLookupDialog();
+
+  bool init(SymbolDictionary &symbolDictionary);
+
+  bool participantMode() const;
+  void setParticipantMode(bool onOff);
+
+  void setValidBaseSymbolCodes(const QSet<QString> &validBaseSymbolCodes);
+
+  QString getCurrentBaseSymbolCode() const;
+  bool setCurrentSidc(const QString &sidc);
+
+Q_SIGNALS:
+  void lookupAppliedBaseSymbolCode(const QString &sidc);
+  void lookupAppliedCompleteSidc(const QString &sidc);
+
+protected:
+  void apply();
+
+protected Q_SLOTS:
+  void onSymbolDoubleClicked(const QString &baseSymbolCode, const QString &sidc);
+  void onSymbolClicked(const QString &baseSymbolCode, const QString &sidc);
+
+private:
+  SituationMap::LOGGER_T m_logger;
+
+  struct Private;
+  /**
+      * The private d->pointer to not break BC when changing internals of this class
+     */
+  Private *d = nullptr;
+}; // BaseSymbolLookupDialog
+
+
+} // namespace Gui
+} // namespace AdvancedSymbology

Lts/Viewer/SituationMap/SymbologyGui/base_symbol_lookup_widget.cpp

@@ -0,0 +1,482 @@
+/**
+  * @RDE_HEADER@
+  * Widget for selecting (base) symbols
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Norbert Thoden, NLE, 12.12.2019
+  */
+
+#include "base_symbol_lookup_widget.h"
+#include "ui_base_symbol_lookup_widget.h"
+
+#include <Symbology/sidc_builder_base.h>          // for concreteSidcToBaseSymbolCode
+#include <SymbologyImpl/base_symbol_model.h>
+
+// Lts
+//#include <LtsWidgets/lts_combo_box.h>
+#include "LtsDataView/lts_data_view.h"
+
+// Qt
+#include <QMap>
+#include <QtCore/QMimeData>
+#include <QtCore/QSignalBlocker>
+
+#include <QtGui/QDrag>
+
+#include <QtGui/QPixmap>
+
+#include <QtWidgets/QApplication>
+#include <QtWidgets/QCheckBox>
+#include <QtWidgets/QDesktopWidget>
+#include <QtWidgets/QHBoxLayout>
+#include <QtWidgets/QVBoxLayout>
+#include <QtWidgets/QLabel>
+#include <QtWidgets/QLineEdit>
+#include <QtWidgets/QPushButton>
+#include <QtWidgets/QTableView>
+#include <QtWidgets/QTextEdit>
+#include <QtWidgets/QHeaderView>
+#include <QtWidgets/QTreeView>
+
+
+namespace AdvancedSymbology
+{
+namespace Gui
+{
+
+//------------------------------------------------------------------------------
+// BaseSymbolLookupWidget::Private
+//------------------------------------------------------------------------------
+struct BaseSymbolLookupWidget::Private
+{
+  MODEL_CONT                            modelContainer;
+
+  QMap<SYMBOL_TYPE, int>                m_symbologyTypeToIdx;
+  QMap<int, SYMBOL_TYPE>                m_idxToSymbologyType;
+  QMap<int, LtsDataView::LtsDataView *> m_idxToDataViewCont; // tabIdx -> view
+  QMap<int, BaseSymbolModel *>          m_idxToModel; // tabIdx -> view
+
+  bool                                  m_participantMode = false;
+  QCheckBox                            *m_cbPoint = nullptr;
+  QCheckBox                            *m_cbLine = nullptr;
+  QCheckBox                            *m_cbArea = nullptr;
+  QSet<QString>                         m_validBaseSymbolCodes;
+};
+
+
+//------------------------------------------------------------------------------
+// BaseSymbolLookupWidget
+//------------------------------------------------------------------------------
+BaseSymbolLookupWidget::BaseSymbolLookupWidget(const MODEL_CONT &modelCont, QWidget *parent)
+  : QWidget(parent)
+  , m_logger(getLogger("BaseSymbolLookupWidget"))
+  , m_ui(new Ui::BaseSymbolLookupWidget)
+  , d(new Private())
+{
+  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
+  m_ui->setupUi(this);
+
+  // clear, we use our own widgets:
+  m_ui->tabWidget->removeTab(0);
+
+  d->modelContainer = modelCont;
+
+  for (const auto &modelData : qAsConst(d->modelContainer))
+  {
+    if (!modelData.m_baseSymbolModel)
+      continue;
+
+    LtsDataView::LtsDataView *dv = new LtsDataView::LtsDataView(this);
+
+    BaseSymbolProxyModel *proxy = new BaseSymbolProxyModel(this);
+    proxy->setSourceModel(modelData.m_baseSymbolModel);
+    proxy->setDynamicSortFilter(false);
+    dv->setModel(proxy);
+
+    // connect:
+    connect(dv, &LtsDataView::LtsDataView::clicked,       this, &BaseSymbolLookupWidget::onClicked);
+    connect(dv, &LtsDataView::LtsDataView::doubleClicked, this, &BaseSymbolLookupWidget::onDoubleClicked);
+
+    if (modelData.m_symbolType == SYMBOL_TYPE::ESRI)
+    {
+      // ESRI -> add some cbs for Point, Line, Area:
+      // HBox with 3 cbs:
+      QHBoxLayout *layoutGeomSelect = new QHBoxLayout();
+      d->m_cbPoint = new QCheckBox(tr("Point"), this);
+      d->m_cbLine  = new QCheckBox(tr("Line"), this);
+      d->m_cbArea  = new QCheckBox(tr("Area"), this);
+      layoutGeomSelect->addWidget(d->m_cbPoint, 0);
+      layoutGeomSelect->addWidget(d->m_cbLine, 0);
+      layoutGeomSelect->addWidget(d->m_cbArea, 0);
+      layoutGeomSelect->addStretch(9);
+
+      d->m_cbPoint->setChecked(proxy->filterPoints());
+      d->m_cbLine->setChecked(proxy->filterLines());
+      d->m_cbArea->setChecked(proxy->filterAreas());
+      connect(d->m_cbPoint, &QCheckBox::toggled, proxy, &BaseSymbolProxyModel::onFilterPoints);
+      connect(d->m_cbLine,  &QCheckBox::toggled, proxy, &BaseSymbolProxyModel::onFilterLines);
+      connect(d->m_cbArea,  &QCheckBox::toggled, proxy, &BaseSymbolProxyModel::onFilterAreas);
+
+      // VBox with layoutGeomSelect and LtsDataView
+      QVBoxLayout *layout = new QVBoxLayout();
+      layout->addLayout(layoutGeomSelect);
+      layout->addWidget(dv);
+
+      // wrap within a widget:
+      QWidget *w = new QWidget();
+      w->setLayout(layout);
+
+      int idx = m_ui->tabWidget->addTab(w, modelData.m_name);
+      d->m_symbologyTypeToIdx[modelData.m_symbolType] = idx;
+      d->m_idxToSymbologyType[idx] = modelData.m_symbolType;
+      d->m_idxToDataViewCont[idx] = dv;
+      d->m_idxToModel[idx] = modelData.m_baseSymbolModel;
+    }
+    else
+    {
+      const int idx = m_ui->tabWidget->addTab(dv, modelData.m_name);
+      d->m_symbologyTypeToIdx[modelData.m_symbolType] = idx;
+      d->m_idxToSymbologyType[idx] = modelData.m_symbolType;
+      d->m_idxToDataViewCont[idx] = dv;
+      d->m_idxToModel[idx] = modelData.m_baseSymbolModel;
+    }
+
+    showHideColumns(modelData.m_symbolType);
+
+  } // for
+
+  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
+}
+
+BaseSymbolLookupWidget::~BaseSymbolLookupWidget()
+{
+  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
+  delete d;
+  delete m_ui;
+  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
+}
+
+void BaseSymbolLookupWidget::setValidBaseSymbolCodes(const QSet<QString> &validBaseSymbolCodes)
+{
+  d->m_validBaseSymbolCodes = validBaseSymbolCodes;
+
+  const int tabCount = m_ui->tabWidget->count();
+  for (int tabIdx = 0; tabIdx < tabCount; ++tabIdx)
+  {
+    LtsDataView::LtsDataView *dv = d->m_idxToDataViewCont[tabIdx];
+    if (!dv)
+      continue;
+
+    BaseSymbolProxyModel *proxy = qobject_cast<BaseSymbolProxyModel *>(dv->proxyModel());
+    if (proxy)
+      proxy->setValidBaseSymbolCodes(d->m_validBaseSymbolCodes);
+  } // for
+}
+
+bool BaseSymbolLookupWidget::participantMode() const
+{
+  return d->m_participantMode;
+}
+
+void BaseSymbolLookupWidget::setParticipantMode(bool onOff)
+{
+  TRACE_LOG(m_logger) << LOGFUNCTION << " START, participantMode =" << onOff;
+  d->m_participantMode = onOff;
+  if (d->m_participantMode)
+  {
+    d->m_cbPoint->setChecked(true);
+    d->m_cbLine->setChecked(false);
+    d->m_cbArea->setChecked(false);
+  }
+  else
+  {
+    d->m_cbPoint->setChecked(true);
+    d->m_cbLine->setChecked(true);
+    d->m_cbArea->setChecked(true);
+  }
+
+  d->m_cbPoint->setVisible(!d->m_participantMode);
+  d->m_cbLine->setVisible(!d->m_participantMode);
+  d->m_cbArea->setVisible(!d->m_participantMode);
+  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
+}
+
+void BaseSymbolLookupWidget::showHideColumns(SYMBOL_TYPE symType)
+{
+  TRACE_LOG(m_logger) << LOGFUNCTION << " START, symType=" << static_cast<int>(symType);
+  if (!d->m_symbologyTypeToIdx.contains(symType))
+    return;
+
+  const int idx = d->m_symbologyTypeToIdx[symType];
+  LtsDataView::LtsDataView *dv = d->m_idxToDataViewCont[idx];
+  if (!dv)
+    return;
+
+#ifdef LTS_DEBUG
+  const bool showAll = QGuiApplication::keyboardModifiers().testFlag(Qt::KeyboardModifier::ControlModifier);
+#else
+  const bool showAll = false;
+#endif //   LTS_DEBUG
+
+  switch (symType)
+  {
+  case SYMBOL_TYPE::ESRI:
+//    dv->setColumnHidden(BaseSymbolModel::Columns::ID,             !showAll);
+    dv->setColumnHidden(BaseSymbolModel::Columns::ORIGINAL_KEY,   !showAll);
+    dv->setColumnHidden(BaseSymbolModel::Columns::KEY,            !showAll);
+    dv->setColumnHidden(BaseSymbolModel::Columns::OPERATOR_NAME,  !showAll);
+    dv->setColumnHidden(BaseSymbolModel::Columns::LAST_MODIFIED,  !showAll);
+    dv->setColumnHidden(BaseSymbolModel::Columns::SIDC,           !showAll);
+
+
+    dv->setColumnHidden(BaseSymbolModel::Columns::SEARCH_ICON,        !showAll);
+    dv->setColumnHidden(BaseSymbolModel::Columns::FETCH_ICON,         !showAll);
+//    dv->setColumnHidden(BaseSymbolModel::Columns::FIND_BASE_SYMBOL,   !showAll);
+    dv->setColumnHidden(BaseSymbolModel::Columns::FIND_PREVIEW,       !showAll);
+    dv->setColumnHidden(BaseSymbolModel::Columns::FIND_IMAGE,         !showAll);
+
+    dv->setColumnHidden(BaseSymbolModel::Columns::XML_SYMBOL_SIZE,    !showAll);
+    dv->setColumnHidden(BaseSymbolModel::Columns::CATEGORY,           !showAll);
+    dv->setColumnHidden(BaseSymbolModel::Columns::SYMBOLCLASS,        !showAll);
+//    dv->setColumnHidden(BaseSymbolModel::Columns::TAGS,               !showAll);
+    dv->setColumnHidden(BaseSymbolModel::Columns::GCTSTRING,          !showAll);
+    dv->setColumnHidden(BaseSymbolModel::Columns::GEOMETRYTYPE,       !showAll);
+    break;
+
+  case SYMBOL_TYPE::XML:
+//    dv->setColumnHidden(BaseSymbolModel::Columns::ID,                 !showAll);
+    dv->setColumnHidden(BaseSymbolModel::Columns::ORIGINAL_KEY,       !showAll);
+    dv->setColumnHidden(BaseSymbolModel::Columns::KEY,                !showAll);
+//    dv->setColumnHidden(BaseSymbolModel::Columns::OPERATOR_NAME,      !showAll);
+//    dv->setColumnHidden(BaseSymbolModel::Columns::LAST_MODIFIED,      !showAll);
+    dv->setColumnHidden(BaseSymbolModel::Columns::SIDC,               !showAll);
+    dv->setColumnHidden(BaseSymbolModel::Columns::SYMBOL_SET,         true);
+
+    dv->setColumnHidden(BaseSymbolModel::Columns::SEARCH_ICON,        !showAll);
+    dv->setColumnHidden(BaseSymbolModel::Columns::FETCH_ICON,         !showAll);
+    dv->setColumnHidden(BaseSymbolModel::Columns::FIND_BASE_SYMBOL,   !showAll);
+//    dv->setColumnHidden(BaseSymbolModel::Columns::FIND_PREVIEW,       !showAll);
+    dv->setColumnHidden(BaseSymbolModel::Columns::FIND_IMAGE,         !showAll);
+
+//    dv->setColumnHidden(BaseSymbolModel::Columns::XML_SYMBOL_SIZE,    !showAll);
+    dv->setColumnHidden(BaseSymbolModel::Columns::CATEGORY,           !showAll);
+    dv->setColumnHidden(BaseSymbolModel::Columns::SYMBOLCLASS,        !showAll);
+    dv->setColumnHidden(BaseSymbolModel::Columns::TAGS,               !showAll);
+    dv->setColumnHidden(BaseSymbolModel::Columns::GCTSTRING,          !showAll);
+    dv->setColumnHidden(BaseSymbolModel::Columns::GEOMETRYTYPE,       !showAll);
+    break;
+
+  case SYMBOL_TYPE::ETS:
+//    dv->setColumnHidden(BaseSymbolModel::Columns::ID,                 !showAll);
+    dv->setColumnHidden(BaseSymbolModel::Columns::ORIGINAL_KEY,       true);
+    dv->setColumnHidden(BaseSymbolModel::Columns::KEY,                true);
+    dv->setColumnHidden(BaseSymbolModel::Columns::OPERATOR_NAME,      true);
+    dv->setColumnHidden(BaseSymbolModel::Columns::LAST_MODIFIED,      true);
+    dv->setColumnHidden(BaseSymbolModel::Columns::SIDC,               !showAll);
+    dv->setColumnHidden(BaseSymbolModel::Columns::SYMBOL_SET,         true);
+
+    dv->setColumnHidden(BaseSymbolModel::Columns::SEARCH_ICON,        true);
+    dv->setColumnHidden(BaseSymbolModel::Columns::FETCH_ICON,         true);
+//    dv->setColumnHidden(BaseSymbolModel::Columns::FIND_BASE_SYMBOL,   !showAll);
+    dv->setColumnHidden(BaseSymbolModel::Columns::FIND_PREVIEW,       true);
+    dv->setColumnHidden(BaseSymbolModel::Columns::FIND_IMAGE,         true);
+
+    dv->setColumnHidden(BaseSymbolModel::Columns::XML_SYMBOL_SIZE,    true);
+//    dv->setColumnHidden(BaseSymbolModel::Columns::CATEGORY,           !showAll);
+    dv->setColumnHidden(BaseSymbolModel::Columns::SYMBOLCLASS,        true);
+//    dv->setColumnHidden(BaseSymbolModel::Columns::TAGS,               !showAll);
+    dv->setColumnHidden(BaseSymbolModel::Columns::GCTSTRING,          true);
+    dv->setColumnHidden(BaseSymbolModel::Columns::GEOMETRYTYPE,       true);
+    break;
+  } // switch
+
+  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
+}
+
+bool BaseSymbolLookupWidget::setCurrentTab(SYMBOL_TYPE symType)
+{
+  TRACE_LOG(m_logger) << LOGFUNCTION << " START, symType=" << static_cast<int>(symType);
+  if (!d->m_symbologyTypeToIdx.contains(symType))
+    return false;
+  const int idx = d->m_symbologyTypeToIdx[symType];
+  m_ui->tabWidget->setCurrentIndex(idx);
+  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
+  return true;
+}
+
+void BaseSymbolLookupWidget::showEvent(QShowEvent *event)
+{
+  Q_UNUSED(event);
+  showHideColumns(SYMBOL_TYPE::ESRI);
+  showHideColumns(SYMBOL_TYPE::XML);
+  showHideColumns(SYMBOL_TYPE::ETS);
+}
+
+
+QSharedPointer<BaseSymbolItem> BaseSymbolLookupWidget::getCurrentBaseSymbolItem() const
+{
+  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
+  const int tabIdx = m_ui->tabWidget->currentIndex();
+  LtsDataView::LtsDataView *dv = d->m_idxToDataViewCont[tabIdx];
+  BaseSymbolModel *bsm       = d->m_idxToModel[tabIdx];
+
+  if (!dv || !bsm)
+    return nullptr;
+
+  // found :-)
+  QItemSelectionModel *selectModel = dv->selectionModel();
+
+  if (!selectModel || !selectModel->hasSelection())
+    return nullptr;
+
+  const QItemSelection &selectionSource = dv->mapSelectionToSource(selectModel->selection());
+  const int row = selectionSource.indexes().first().row();  // assume singleSelection
+
+  return bsm->getRowData(row);
+}
+
+QString BaseSymbolLookupWidget::getCurrentBaseSymbolCode() const
+{
+  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
+
+  QSharedPointer<BaseSymbolItem> bsi = getCurrentBaseSymbolItem();
+  if (bsi)
+  {
+    DEBUG_LOG(m_logger) << LOGFUNCTION
+                        << " m_id" << bsi->m_id
+                        << ", baseSymbolCode" << bsi->baseSymbolCode();
+    return bsi->baseSymbolCode();
+  }
+  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
+  return QString();
+}
+
+QString BaseSymbolLookupWidget::getCurrentSidc() const
+{
+  QSharedPointer<BaseSymbolItem> bsi = getCurrentBaseSymbolItem();
+  if (bsi)
+  {
+    DEBUG_LOG(m_logger) << LOGFUNCTION
+                        << " m_id" << bsi->m_id
+                        << ", sidc" << bsi->sidc();
+    return bsi->sidc();
+  }
+  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
+  return QString();
+}
+
+bool BaseSymbolLookupWidget::setCurrentSidc(const QString &sidc)
+{
+  TRACE_LOG(m_logger) << LOGFUNCTION << " sidc='" << sidc << "'";
+
+  if (sidc.isEmpty())
+  {
+    DEBUG_LOG(m_logger) << LOGFUNCTION << " sidc is empty, maybe not set...";
+    return false;
+  }
+
+  if (!SidcCodec::isEncoded(sidc))
+  {
+    ERROR_LOG(m_logger) << LOGFUNCTION << " sidc isn't encoded: '" << sidc << "'";
+    return false;
+  }
+
+  SYMBOL_TYPE symType = SYMBOL_TYPE::ESRI;
+  QString baseSymbolCode = sidc;
+
+  const SidcCodec::SidcType sidcType = SidcCodec::decodeSidcType(sidc);
+  switch (sidcType)
+  {
+  case SidcCodec::SidcType::None:
+  {
+    ERROR_LOG(m_logger) << LOGFUNCTION << " SidcType::None isn't supported. Sidc= '" << sidc << "'";
+    return false;
+  }
+  case SidcCodec::SidcType::Complete:
+    baseSymbolCode = AdvancedSymbology::SidcBuilderBase::concreteSidcToBaseSymbolCode(sidc);
+  case SidcCodec::SidcType::Base:
+    break;
+  case SidcCodec::SidcType::CivilEts:
+    symType = SYMBOL_TYPE::ETS;
+    break;
+  case SidcCodec::SidcType::CivilXml:
+    symType = SYMBOL_TYPE::XML;
+    break;
+  default :
+  {
+    ERROR_LOG(m_logger) << LOGFUNCTION << " SidcType is unknown. Sidc= '" << sidc << "'";
+    return false;
+  }
+  } // switch
+
+
+  // switch to model/view/tabIdx
+
+  if (!d->m_symbologyTypeToIdx.contains(symType))
+    return false;
+
+  const int                tabIdx = d->m_symbologyTypeToIdx[symType];
+  BaseSymbolModel        *bsm   = d->m_idxToModel[tabIdx];
+  LtsDataView::LtsDataView *dv    = d->m_idxToDataViewCont[tabIdx];
+
+  if (!bsm || !dv)
+  {
+    ERROR_LOG(m_logger) << LOGFUNCTION << " switch to model/view/tabIndex failed, sidc '" << sidc << "'";
+    return false;
+  }
+
+  // switch to tabIdx
+  m_ui->tabWidget->setCurrentIndex(tabIdx);
+
+  // switch to model/view
+  const int row = bsm->findRowForBaseSymbolCode(baseSymbolCode);
+  if (row >= 0)
+  {
+    const QModelIndex sourceIdx = bsm->index(row, 0);
+    dv->selectRow(dv->proxyModel()->mapFromSource(sourceIdx));
+    dv->scrollTo(dv->proxyModel()->mapFromSource(sourceIdx));
+  }
+
+  INFO_LOG(m_logger) << LOGFUNCTION << " sidc='" << sidc << "'"
+                       << " tabIdx = " << tabIdx
+                       << " findRowForBaseSymbolCode -> row = " << row;
+
+  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
+  return (row >= 0);
+}
+
+void BaseSymbolLookupWidget::onClicked(const QModelIndex &index)
+{
+  Q_UNUSED(index);
+
+  QSharedPointer<BaseSymbolItem> bsi = getCurrentBaseSymbolItem();
+  if (!bsi)
+  {
+    ERROR_LOG(m_logger) << LOGFUNCTION << " item not found";
+    return;
+  }
+  const QString &curBsc = bsi->baseSymbolCode();
+  const QString &curSidc = bsi->sidc();
+  emit symbolClicked(curBsc, curSidc);
+}
+
+void BaseSymbolLookupWidget::onDoubleClicked(const QModelIndex &index)
+{
+  Q_UNUSED(index);
+
+  QSharedPointer<BaseSymbolItem> bsi = getCurrentBaseSymbolItem();
+  if (!bsi)
+  {
+    ERROR_LOG(m_logger) << LOGFUNCTION << " item not found";
+    return;
+  }
+  const QString &curBsc = bsi->baseSymbolCode();
+  const QString &curSidc = bsi->sidc();
+  emit symbolDoubleClicked(curBsc, curSidc);
+}
+
+
+} // namespace Gui
+} // namespace AdvancedSymbology
+

Lts/Viewer/SituationMap/SymbologyGui/base_symbol_lookup_widget.h

@@ -0,0 +1,104 @@
+/**
+  * @RDE_HEADER@
+  * Widget for selecting (base) symbols
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Norbert Thoden, NLE, 12.12.2019
+  */
+
+#pragma once
+
+#include <SymbologyGui/advancedsymbologygui_export.h>
+#include <Common/situation_map_logging.h>
+
+#include <QWidget>
+#include <QVector>
+
+
+namespace Ui
+{
+class BaseSymbolLookupWidget;
+}
+
+
+namespace AdvancedSymbology
+{
+class BaseSymbolModel;
+class BaseSymbolItem;
+namespace Gui
+{
+
+enum class SYMBOL_TYPE
+{
+  ESRI = 0,
+  XML,
+  ETS
+};
+
+struct ModelItem
+{
+  ModelItem(SYMBOL_TYPE symbolType = SYMBOL_TYPE::ESRI,
+            const QString &name = QString(),
+            BaseSymbolModel  *baseSymbolModel = nullptr)
+    : m_symbolType(symbolType),
+      m_name(name),
+      m_baseSymbolModel(baseSymbolModel)
+  {}
+  SYMBOL_TYPE         m_symbolType;
+  QString             m_name;
+  BaseSymbolModel  *m_baseSymbolModel = nullptr;
+};
+
+using MODEL_CONT = QVector<ModelItem>;
+
+
+//------------------------------------------------------------------------------
+// BaseSymbolLookupWidget
+//------------------------------------------------------------------------------
+class ADVANCEDSYMBOLOGYGUI_EXPORT BaseSymbolLookupWidget : public QWidget
+{
+  Q_OBJECT
+
+public:
+  explicit BaseSymbolLookupWidget(const MODEL_CONT &modelCont, QWidget *parent);
+  ~BaseSymbolLookupWidget();
+
+  bool participantMode() const;
+  void setParticipantMode(bool onOff);
+
+  void setValidBaseSymbolCodes(const QSet<QString> &validBaseSymbolCodes);
+
+  QSharedPointer<BaseSymbolItem> getCurrentBaseSymbolItem() const;
+  QString getCurrentBaseSymbolCode() const;   // encoded, baseSymbolCode
+  QString getCurrentSidc() const;             // encoded, complete
+  bool setCurrentSidc(const QString &sidc);   // encoded, baseSymbolCode or complete Sidc
+
+Q_SIGNALS:
+  void symbolClicked(const QString &baseSymbolCode, const QString &sidc);
+  void symbolDoubleClicked(const QString &baseSymbolCode, const QString &sidc);
+
+protected:
+  bool setCurrentTab(SYMBOL_TYPE symType);
+  void showHideColumns(SYMBOL_TYPE symType);
+
+protected Q_SLOTS:
+  void showEvent(QShowEvent *event) override;
+
+  void onClicked(const QModelIndex &index);
+  void onDoubleClicked(const QModelIndex &index);
+
+private:
+  SituationMap::LOGGER_T m_logger;
+
+  Ui::BaseSymbolLookupWidget *m_ui;
+
+  struct Private;
+  /**
+      * The private d->pointer to not break BC when changing internals of this class
+     */
+  Private *d = nullptr;
+};
+
+} // namespace Gui
+} // namespace AdvancedSymbology

Lts/Viewer/SituationMap/SymbologyGui/base_symbol_lookup_widget.ui

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>BaseSymbolLookupWidget</class>
+ <widget class="QWidget" name="BaseSymbolLookupWidget">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>840</width>
+    <height>463</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <widget class="QTabWidget" name="tabWidget">
+     <property name="currentIndex">
+      <number>0</number>
+     </property>
+     <widget class="QWidget" name="tab">
+      <attribute name="title">
+       <string>Tab 1</string>
+      </attribute>
+     </widget>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

Lts/Viewer/SituationMap/SymbologyGui/field_table_model.cpp

@@ -0,0 +1,126 @@
+/**
+  *
+  * @RDE_HEADER@
+  * Helper model for SymbolModificationWidget
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#include "field_table_model.h"
+
+namespace AdvancedSymbology
+{
+namespace Gui
+{
+
+int FieldTableModel::columnCount(const QModelIndex &parent) const
+{
+  return parent.isValid() ? 0 : 2;
+}
+
+int FieldTableModel::rowCount(const QModelIndex &parent) const
+{
+  return parent.isValid() ? 0 : m_fieldKeys.size();
+}
+
+QVariant FieldTableModel::headerData(int section, Qt::Orientation orientation, int role) const
+{
+  if (role != Qt::DisplayRole) return QVariant();
+  if (Qt::Orientation::Horizontal == orientation)
+  {
+    switch (section)
+    {
+    case 0  : return tr("Field Title");
+    case 1  : return tr("Value");
+    default : break;
+    }
+  }
+  return QVariant();
+} // QVariant headerData( int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override
+
+
+QVariant FieldTableModel::data(const QModelIndex &index, int role) const
+{
+  if (index.row() >= 0 && index.row() < m_fieldKeys.size() &&
+      role == Qt::DisplayRole)
+  {
+    const QString &key = m_fieldKeys.at(index.row());
+    switch (index.column())
+    {
+    case 0  : return key;
+    case 1  : return m_fieldValueMap[key];
+    default : QVariant();
+    }
+  }
+  return QVariant();
+} // QVariant data(const QModelIndex & index, int role = Qt::DisplayRole) const override
+
+bool FieldTableModel::setFieldAttrMap(const QMap<QString, QVariant> &fieldAttrMap)
+{
+  beginResetModel();
+  {
+    m_fieldKeys = fieldAttrMap.keys();
+    m_fieldKeys.sort();
+    m_fieldValueMap = fieldAttrMap;
+  }
+  endResetModel();
+  return true;
+} // bool setFieldAttrMap( const QMap<QString,QVariant> & fieldAttrMap )
+
+
+void FieldTableModel::setFieldAttribute(const QString &key, const QString &value)
+{
+  beginResetModel();
+  {
+    m_fieldValueMap[key] = value;
+    if (!m_fieldKeys.contains(key))
+    {
+      m_fieldKeys += key;
+      m_fieldKeys.sort();
+    }
+  }
+  endResetModel();
+} // void setFieldAttribute( const QString & key, const QString & value )
+
+
+void FieldTableModel::setFieldAttribute(SituationMap::Participant::TextModifier textMod, const QString &value)
+{
+  const QString &key = participantAttributeKey(textMod);
+  if (!key.isEmpty()) setFieldAttribute(key, value);
+} // void setFieldAttribute(SituationMap::TextModifier textMod, const QString & value)
+
+
+void FieldTableModel::removeFieldAttrMap(const QString &key)
+{
+  if (m_fieldKeys.contains(key))
+  {
+    beginResetModel();
+    {
+      m_fieldKeys.removeAll(key);
+      m_fieldValueMap.remove(key);
+    }
+    endResetModel();
+  }
+} // void removeFieldAttrMap( const QString & key )
+
+
+QString FieldTableModel::fieldAttribute(const QString &key) const
+{
+  return m_fieldValueMap.value(key).toString();
+} // void fieldAttribute( const QString & key )
+
+QString FieldTableModel::fieldAttribute(SituationMap::Participant::TextModifier textMod)
+{
+  const QString &key = participantAttributeKey(textMod);
+  if (key.isEmpty()) return QString();
+  return fieldAttribute(key);
+} // QString fieldAttribute( SituationMap::TextModifier textMod )
+
+QString FieldTableModel::participantAttributeKey(SituationMap::Participant::TextModifier textMod)
+{
+  return SituationMap::Participant::toString(textMod);
+} // QString participantAttributeKey(SituationMap::TextModifier textMod)
+
+} // namespace Gui
+} // namespace AdvancedSymbology

Lts/Viewer/SituationMap/SymbologyGui/field_table_model.h

@@ -0,0 +1,47 @@
+/**
+  *
+  * @RDE_HEADER@
+  * Helper model for SymbolModificationWidget
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+#pragma once
+
+#include <QAbstractTableModel>
+#include <SituationMap/MapObjects/participant.h>
+
+namespace AdvancedSymbology
+{
+namespace  Gui
+{
+
+class FieldTableModel : public QAbstractTableModel
+{
+  Q_OBJECT
+public:
+  using QAbstractTableModel::QAbstractTableModel;
+
+  int columnCount(const QModelIndex &parent = QModelIndex()) const override;
+  int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+  QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
+  QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
+
+  const QMap<QString, QVariant> &fieldAttrMap() const { return m_fieldValueMap; }
+  bool setFieldAttrMap(const QMap<QString, QVariant> &fieldAttrMap);
+  void setFieldAttribute(const QString &key, const QString &value);
+  void setFieldAttribute(SituationMap::Participant::TextModifier textMod, const QString &value);
+  void removeFieldAttrMap(const QString &key);
+  QString fieldAttribute(const QString &key) const;
+  QString fieldAttribute(SituationMap::Participant::TextModifier textMod);
+
+private:
+  static QString participantAttributeKey(SituationMap::Participant::TextModifier textMod);
+private:
+  QStringList             m_fieldKeys;
+  QMap<QString, QVariant> m_fieldValueMap;
+
+}; // FieldTableModel
+
+} // namespace Gui
+} // namespace AdvancedSymbology

Lts/Viewer/SituationMap/SymbologyGui/symbol_modification_dialog.cpp

@@ -0,0 +1,137 @@
+/**
+* @RDE_HEADER@
+* symbol_modification_dialog for sidc configuration
+* $Id$
+* $HeadURL$
+* $Author$
+* Created by Karwat, SLSE, 2017-09-07
+*/
+
+#include "symbol_modification_dialog.h"
+#include "symbol_modification_widget.h"
+#include <QtWidgets/QVBoxLayout>
+
+
+namespace AdvancedSymbology
+{
+namespace Gui
+{
+
+//Dialog
+
+SymbolModificationDialog::SymbolModificationDialog(SituationMap::Map *map, bool isParticipant, QWidget *parent)
+  : LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::OkCancel)
+{
+  initLayout(map, isParticipant);
+}
+
+/*
+ * TODO: FIXME: Warum ist das ein OkCancel Dialog aber Ok wird gehided und Cancel dann wieder zu close umbenannt?
+ * Warum ist das nicht gleich ein CloseONly Dialog?
+ */
+void SymbolModificationDialog::removeOkAndApplyButtons()
+{
+  m_buttonBox->getButton(LtsWidgets::DialogButton::Ok)->setVisible(false);
+  m_buttonBox->getButton(LtsWidgets::DialogButton::Apply)->setVisible(false);
+  m_buttonBox->getButton(LtsWidgets::DialogButton::Close)->setText(tr("Close"));
+}
+
+void SymbolModificationDialog::initLayout(SituationMap::Map *map, bool isParticipant)
+{
+
+  QVBoxLayout *layout = new QVBoxLayout(this);
+  m_symbolModificationWidget = new SymbolModificationWidget(map, isParticipant, map->symbolDictionary(), this);
+  connect(m_symbolModificationWidget, &SymbolModificationWidget::changed, this, &SymbolModificationDialog::changed);
+  connect(m_symbolModificationWidget, &SymbolModificationWidget::changed, this, &SymbolModificationDialog::slotChangesMade);
+  m_buttonBox->connectButton(LtsWidgets::DialogButton::No, m_symbolModificationWidget, &SymbolModificationWidget::onRevert);
+  m_buttonBox->setText(LtsWidgets::DialogButton::No, tr("Revert"));
+  layout->addWidget(m_symbolModificationWidget, 2);
+}
+
+
+
+void SymbolModificationDialog::aboutToClose() { emit signalAboutToClose(); }
+bool SymbolModificationDialog::apply()
+{
+  //const QString & sidc = getCurrentSidc();
+
+  //if (sidc.isEmpty()) return false;
+
+  //emit lookupApplied( sidc );
+  return true;
+} // SymbolModificationDialog::apply()
+
+
+void SymbolModificationDialog::retranslate()
+{
+  // lupdate doesn't like translate(tr("foo")) ...
+  const QString txt(tr("Symbol Modification"));
+  translate(txt);
+
+} // SymbolModificationDialog::retranslate()
+
+
+
+//Frameless
+SymbolModificationDialogFrameless::SymbolModificationDialogFrameless(SituationMap::Map *map, bool isParticipant, QWidget *parent)
+  : LtsWidgets::LtsFramelessDialog(parent)
+  , m_buttonBox(nullptr)
+{
+  initLayout(map, isParticipant, map->symbolDictionary());
+}
+
+SymbolModificationDialogFrameless::SymbolModificationDialogFrameless(SymbolDictionary &symbolDictionary, bool isParticipant, QWidget *parent)
+  : LtsWidgets::LtsFramelessDialog(parent)
+  , m_buttonBox(nullptr)
+{
+  initLayout(nullptr, isParticipant, symbolDictionary);
+}
+
+
+void SymbolModificationDialogFrameless::initLayout(SituationMap::Map *map, bool isParticipant, SymbolDictionary &symbolDictionary)
+{
+  QVBoxLayout *layout = new QVBoxLayout(this);
+  m_buttonBox = new LtsWidgets::LtsDialogButtonBox(this);
+  m_symbolModificationWidget = new SymbolModificationWidget(map, isParticipant, symbolDictionary, this);
+  connect(m_symbolModificationWidget, &SymbolModificationWidget::changed, this, &SymbolModificationDialogFrameless::sidcChanged);
+
+  layout->addWidget(m_symbolModificationWidget, 2);
+  layout->addWidget(m_buttonBox);
+
+  connect(m_buttonBox->getButton(LtsWidgets::DialogButton::Ok), &QPushButton::clicked, this, &SymbolModificationDialogFrameless::apply);
+  connect(m_buttonBox->getButton(LtsWidgets::DialogButton::Close), &QPushButton::clicked, this, &SymbolModificationDialogFrameless::onClose);
+  m_buttonBox->connectButton(LtsWidgets::DialogButton::No, m_symbolModificationWidget, &SymbolModificationWidget::onRevert);
+  m_buttonBox->setText(LtsWidgets::DialogButton::No, tr("Revert"));
+  setMinimumWidth(800);
+  setMinimumHeight(300);
+  resize(minimumHeight(), minimumWidth());
+}
+
+
+void SymbolModificationDialogFrameless::setSidc(const QString &sidc)
+{
+  m_symbolModificationWidget->setSidc(sidc);
+  m_oldSidc = sidc;
+}
+
+void SymbolModificationDialogFrameless::apply()
+{
+  emit sidcOnClose(m_newSidc);
+  close();
+}
+
+void SymbolModificationDialogFrameless::onClose()
+{
+  emit sidcOnClose(m_oldSidc);
+  close();
+}
+
+void SymbolModificationDialogFrameless::sidcChanged()
+{
+  const QString &newSidc  = m_symbolModificationWidget->modifiedSidc();
+  m_newSidc = newSidc;
+  emit changed();
+}
+
+} // namespace Gui
+} // namespace AdvancedSymbology

Lts/Viewer/SituationMap/SymbologyGui/symbol_modification_dialog.h

@@ -0,0 +1,86 @@
+/**
+*
+* @RDE_HEADER@
+* symbol_modification_dialog for sidc configuration
+* $Id$
+* $HeadURL$
+* $Author$
+* Created by Karwat, SLSE, 2017-09-07
+*/
+
+#pragma once
+
+#include <SymbologyGui/advancedsymbologygui_export.h>
+
+#include <LtsWidgets/lts_dialog.h>
+
+#include "symbol_modification_widget.h"
+
+
+
+namespace AdvancedSymbology
+{
+class SymbolDictionary;
+
+namespace Gui
+{
+
+class ADVANCEDSYMBOLOGYGUI_EXPORT SymbolModificationDialog : public LtsWidgets::LtsDialog
+{
+  Q_OBJECT
+
+public:
+
+  explicit SymbolModificationDialog(SituationMap::Map *map, bool isParticipant, QWidget *parent = nullptr);
+
+  SymbolModificationWidget *getWidget() { return m_symbolModificationWidget; }
+  void removeOkAndApplyButtons();
+
+signals:
+  void changed();
+  void signalAboutToClose();
+
+protected:
+
+  bool apply() override;
+
+  void aboutToClose() override;
+
+private:
+  void retranslate() override;
+  void initLayout(SituationMap::Map *map, bool isParticipant);
+
+  SymbolModificationWidget   *m_symbolModificationWidget;
+}; // SymbolModificationDialog
+
+class ADVANCEDSYMBOLOGYGUI_EXPORT SymbolModificationDialogFrameless : public LtsWidgets::LtsFramelessDialog
+{
+  Q_OBJECT
+
+public:
+  explicit SymbolModificationDialogFrameless(SituationMap::Map *map, bool isParticipant, QWidget *parent = nullptr);
+  explicit SymbolModificationDialogFrameless(SymbolDictionary &symbolDictionary, bool isParticipant, QWidget *parent = nullptr);
+
+  void setSidc(const QString &sidc);
+
+
+signals:
+  void changed();
+  void sidcOnClose(const QString &);
+
+protected slots:
+  void apply(); //next override
+  void onClose();
+  void sidcChanged();
+
+private:
+  void initLayout(SituationMap::Map *map, bool isParticipant, SymbolDictionary &symbolDictionary);
+  SymbolModificationWidget       *m_symbolModificationWidget;
+  LtsWidgets::LtsDialogButtonBox *m_buttonBox;
+  QString m_newSidc;
+  QString m_oldSidc;
+
+}; // SymbolModificationDialogFrameless
+
+} // namespace Gui
+} // namespace AdvancedSymbology

Lts/Viewer/SituationMap/SymbologyGui/symbol_modification_widget.h

@@ -0,0 +1,135 @@
+/**
+* @RDE_HEADER@
+* symbol_modification_wdiget for sidc configuration
+* $Id$
+* $HeadURL$
+* $Author$
+* Created by Karwat, SLSE, 2017-09-07
+*/
+
+#pragma once
+
+#include <SymbologyGui/advancedsymbologygui_export.h>
+
+
+#include <QWidget>
+#include <Map/map.h>
+#include <MapObjects/participant.h>
+#include <Common/simple_value.h>
+
+#include <QtCore/QMap>
+#include <QVBoxLayout>
+#include <QFormLayout>
+#include <QLabel>
+
+class QLabel;
+class QBoxLayout;
+
+namespace AdvancedSymbology
+{
+
+namespace Gui
+{
+
+class ADVANCEDSYMBOLOGYGUI_EXPORT SymbolModificationWidget : public QWidget
+{
+  Q_OBJECT
+
+public:
+
+  explicit SymbolModificationWidget(SituationMap::Map *map, bool isParticipant, SymbolDictionary &symbolDictionary, QWidget *parent = nullptr);
+  ~SymbolModificationWidget();
+
+  bool setSidc(const QString &sidc);
+  bool setFieldAttributes(const QMap<QString, QVariant> &fieldAttrMap);
+
+  const QMap<QString, QVariant> fieldAttributes();
+  bool analyze(SymbologyType symbologyType, const QString &sidc);
+  QString originalSidc()     const;
+  QString modifiedSidc()     const;
+  QString lastModifiedSidc() const;
+  QString symbolName() const;
+
+  SymbologyType symbologyType() const;
+
+protected:
+
+  void retranslate();
+
+  void setSymbolPixmap(QLabel *, const QString &sidc);
+
+  void buildSidcModifierTab_MIL2525D(QWidget *widget);
+  void buildSidcModifierTab_APP6(QWidget *widget);
+
+  void buildFieldModifierTab(QWidget *widget);
+  void buildParticipantTab(QWidget *widget);
+  void buildPreview(QWidget *widget);
+
+  void emitChanged();
+
+  class Internal;
+
+  Internal *m_internal;
+
+  struct PreviewTab
+  {
+    explicit PreviewTab(QWidget *widget)
+      : layout(new QVBoxLayout(widget))
+      , layoutPreview(new QFormLayout())
+      , lbBaseSymbolId(new QLabel(widget))
+      , lbBaseSymbolName(new QLabel(widget))
+      , lbSidcOutTxt(new QLabel(widget))
+      , lbSidcInTxt(new QLabel(widget))
+      , lbSidcOutImg(new QLabel(widget))
+      , lbSidcInImg(new QLabel(widget))
+    {}
+    QVBoxLayout *layout;
+    QFormLayout *layoutPreview;
+
+    QLabel *lbBaseSymbolId;
+    QLabel *lbBaseSymbolName;
+    QLabel *lbSidcOutTxt;
+    QLabel *lbSidcInTxt;
+    QLabel *lbSidcOutImg;
+    QLabel *lbSidcInImg;
+  };
+  PreviewTab *m_previewTab = nullptr;
+
+
+signals:
+
+  void changed();
+
+
+public Q_SLOTS:
+
+  void updatePreviewTab();
+  void onRevert();
+
+
+private Q_SLOTS:
+  
+  void onContextChanged();
+  void onIdentityChanged();
+  void onSymbolSetChanged();
+  void onStatusChanged();
+
+  void onHQTFDummyChanged();
+
+  void onAmplifierGroupChanged();
+  void onAmplifierDesriptorChanged(int);
+
+  void onSector1ModifierChanged(int);
+  void onSector2ModifierChanged(int);
+
+  void onFieldAttributeAdd(bool);
+  void onFieldAttributeRemove(bool);
+
+  void onSetFieldTitle(const QString &);
+  void onFieldItemActived(const QModelIndex &);
+
+  void onChangeApp6SizeMobility();
+};
+} //namespace Gui
+
+} //namespace AdvancedSymbology