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

// Own
#include "adapter_dds.h"

#include <Map/map.h>
#include <Map/layer_factory.h>
#include <Map/location_display.h>
#include <Map/party_id_to_color_functor.h>

#include <LtsUtilsSettings/settings.h>

// Participants:
#include "charge_effect_to_map.h"
#include "participant_to_map.h"
#include "hitlineinfo_to_map.h"
#include "buildinghitlineinfo_to_map.h"

// AES:
#include "air_support_impact_to_map.h"
#include "bccontamination_to_map.h"
#include "borderline_to_map.h"
#include "danger_area_to_map.h"
#include "explosion_area_to_map.h"
#include "explosion_single_to_map.h"
#include "explosion_cluster_to_map.h"
#include "effect_cluster_to_map.h"
#include "functional_area_to_map.h"
#include "gas_pipe_to_map.h"
#include "mine_area_to_map.h"
#include "mine_area_null_to_map.h"
#include "mine_corridor_to_map.h"
#include "ncontamination_to_map.h"
#include "recon_area_to_map.h"
#include "technical_area_to_map.h"
#include "booby_traps_to_map.h"
#include "off_route_to_map.h"

#include "dus_single_mine_to_map.h" // AHTC

// ALM:
#include "emergency_call_to_map.h"

// ASM:
#include "training_area_to_map.h"

// ISM:
#include "mounting_point_to_map.h"
#include "sound_area_to_map.h"
#include "buildings_to_map.h"
#include "mse_point_to_map.h"
#include "mse_bridge_to_map.h"
#include "special_areas_to_map.h"

// GIM
#include "guez_ied_to_map.h"

// GNA
#include "guez_nasat_9liner.h"

// CES
#include "building_ownership.h"
#include "building_contamination.h"

// PDM
#include "pdm_handler.h"

// TGT
#include "shootback_area_to_map.h"


// Qt:
#include <limits>
#include <QTimer>


#include <QDateTime>
#include <functional>


namespace SituationMap
{

AdapterDds::AdapterDds(QObject *parent)
  : QObject(parent)
  , m_logger(getLogger("AdapterDds"))
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START DDDDDDDD" ;
  TRACE_LOG(m_logger) << LOGFUNCTION << " END" ;
}

AdapterDds::~AdapterDds()
{
  // no logging here, NGLLogger lib may already be unloaded!

  qDebug() << LOGFUNCTION << " START";
  stop();
  qDeleteAll(m_aes2MapCont);

  // handle particpants explicit:
  m_particpants.clear();  // If this was the last reference, then the pointer itself will be deleted.

  // handle buildingOwnership explicit:
  m_buildingOwnership.clear();  // If this was the last reference, then the pointer itself will be deleted.
  m_buildingContamination.clear();

  m_trainingAreas.clear();
  m_shootbackAreas.clear();
  m_specialAreas.clear();

  // handle hitline2SituationMap explicit:
  m_hitlineInfo2SituationMap.clear();  // If this was the last reference, then the pointer itself will be deleted.
  m_bldHitlineInfo2SituationMap.clear();

  delete m_pdmHandler;

  qDebug() << LOGFUNCTION << " END";
}

bool AdapterDds::init(Map *map, PluginProvider *pluginProvider, QPointer<MovementTrackManager> &movementTrackMgr, bool resourceMode)
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START" ;

  if (!map || !pluginProvider)
    return false;

  m_map = map;
  m_pluginProvider = pluginProvider;
  m_movementTrackManager = movementTrackMgr;

  // pdmHandler
  m_pdmHandler = new PdmHandler(m_pluginProvider->pdmDtc());

  // Participants & Hitlines:
  {
    // Participants
    const QString participantLayername = m_map->layerFactory().participantLayername(); // == 'Participants'


    m_particpants = QSharedPointer<Participant2SituationMap>(new Participant2SituationMap(m_pdmHandler,
                                                                                          m_map->objectFactory(),
                                                                                          participantLayername,
                                                                                          "Participant2SituationMap"));
    if (!m_particpants->init(&m_map->layerFactory(), m_pluginProvider))
      ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";


    // connect signals:
    connect(m_particpants.data(), &Participant2SituationMap::participantPositionChanged,
            this, &AdapterDds::participantPositionChanged, Qt::UniqueConnection);
    if(strcmp(PROJECTBUILD, "commaster") == 0 || strcmp(PROJECTBUILD, "demotablet") == 0)
    {
      connect(m_particpants.data(), &Participant2SituationMap::participantOwnPositionChanged,
              this, &AdapterDds::onParticipantOwnPositionChanged, Qt::UniqueConnection);
    }

    m_particpants->setMovementTrackManager(m_movementTrackManager);

    // HitlineInfo:
    {
      // ensure that the hitlines are on top:
      const int drawOrder = std::numeric_limits<int>::max()/10;

      m_hitlineInfo2SituationMap = QSharedPointer<HitlineInfo2SituationMap>(new HitlineInfo2SituationMap(m_pdmHandler,
                                                                                                         m_particpants.data(),
                                                                                                         m_map->objectFactory(),
                                                                                                         participantLayername,
                                                                                                         drawOrder,
                                                                                                         "HitlineInfo2SituationMap"));
      if (!m_hitlineInfo2SituationMap->init(m_pluginProvider))
        ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";
    }

    {
      // ensure that the hitlines are on top:
      const int drawOrder = std::numeric_limits<int>::max()/10;

      m_bldHitlineInfo2SituationMap = QSharedPointer<BuildingHitlineInfo2SituationMap>(new BuildingHitlineInfo2SituationMap(m_pdmHandler,
                                                                                                                            m_particpants.data(),
                                                                                                                            m_map->objectFactory(),
                                                                                                                            participantLayername,
                                                                                                                            drawOrder,
                                                                                                                            "BldHitlineInfo2SituationMap"));
      if (!m_bldHitlineInfo2SituationMap->init(m_pluginProvider))
        ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";
    }

  }

  // Norbert Thoden, 03/2024
  // Overview Layer AES vs. AesCentral:
  //
  // Layer "AES"        -> initRenderer3D_AesExtrusion
  //                       assignUniqueValueRendererAesCentral3DExtrusion()
  //                       UniqueValue-Renderer on this->getGraphicsLayer3DExtrusion(logicalName)
  //
  // Layer "AESCentral" -> initRenderer3D_AesCentral_Booby (prepare CONE, SPERE etc:)
  //                       assignUniqueValueRendererAesCentral()
  //                       UniqueValue-Renderer on this->getGraphicsLayer3DExtrusion(logicalName)
  //
  // => die beiden UniqueValue-Renderer sind also derzeit NICHT kombinierbar!!

  // Layer "AES" AtExplosionSingle
  // Layer "AES" AtExplosionSingleCentral
  // Layer "AES" AtExplosionArea
  // Layer "AES" AtMineArea
  // Layer "AES" MineAreaNull2SituationMap
  // Layer "AES" AtMineCorridor
  // Layer "AES" AtBCContamination
  // Layer "AES" AtNContamination
  // Layer "AES" AtNContamination
  // Layer "AES" AtDangerArea
  // Layer "AES" AtFunctionalArea
  // Layer "AES" AtBorderline
  // Layer "AES" AtReconArea
  // Layer "AES" AtDusSingleMine
  // Layer "AES" AtGasPipe
  // Layer "AES" AtAirSupportImpact
  // Layer "AES" AtTechnicalArea

  // Layer "AESCentral" AtExplosionCluster
  // Layer "AESCentral" AtBoobyTrap
  // Layer "AESCentral" AtOffRouteMine
  // Layer "AESCentral" AtExplosionCluster

  {
    if (m_map->mode() == Mode::Mode_3D)
    {
      // relevant for Overview
      initRenderer3D_AesExtrusion();
    }

    {
      AreaEffectSimulation::AesType::inner_enum aesType = AreaEffectSimulation::AesType_def::AtExplosionSingle;
      ExplosionSingle2SituationMap *sim2Map = static_cast<ExplosionSingle2SituationMap *>(m_aes2MapCont.value(aesType));
      if (! sim2Map)
      {
        sim2Map = new ExplosionSingle2SituationMap(m_pdmHandler,
                                                   m_map->objectFactory(),
                                                   QLatin1String("AES"),
                                                   "ExplosionSingle2SituationMap");
        m_aes2MapCont[static_cast<int>(aesType)] = sim2Map;
      }
      if(!sim2Map->init(m_pluginProvider))
        ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";
    }

    // SingleCentral is outdated
    //    {
    //      AreaEffectSimulation::AesType::inner_enum aesType = AreaEffectSimulation::AesType_def::AtExplosionSingleCentral;
    //      ExplosionSingleCentral2SituationMap *sim2Map = static_cast<ExplosionSingleCentral2SituationMap *>(m_aes2MapCont.value(aesType));
    //      if (! sim2Map)
    //      {
    //        sim2Map = new ExplosionSingleCentral2SituationMap(m_pdmHandler,
    //                                                          m_map->objectFactory(),
    //                                                          QLatin1String("AESCentral"),
    //                                                          "ExplosionSingleCentral2SituationMap");
    //        m_aes2MapCont[static_cast<int>(aesType)] = sim2Map;
    //      }
    //      if(!sim2Map->init(m_pluginProvider))
    //        ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";
    //    }

    {
      AreaEffectSimulation::AesType::inner_enum aesType = AreaEffectSimulation::AesType_def::AtExplosionArea;
      ExplosionArea2SituationMap *sim2Map = static_cast<ExplosionArea2SituationMap *>(m_aes2MapCont.value(aesType));
      if (! sim2Map)
      {
        sim2Map = new ExplosionArea2SituationMap(m_map->objectFactory(),
                                                 QLatin1String("AES"),
                                                 "ExplosionArea2SituationMap");

        m_aes2MapCont[static_cast<int>(aesType)] = sim2Map;
      }
      if (!sim2Map->init(m_pluginProvider))
        ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";
    }

    {
      AreaEffectSimulation::AesType::inner_enum aesType = AreaEffectSimulation::AesType_def::AtMineArea;
      MineArea2SituationMap *sim2Map = static_cast<MineArea2SituationMap*>(m_aes2MapCont.value(aesType));
      if (! sim2Map)
      {
        sim2Map = new MineArea2SituationMap(m_map->objectFactory(),
                                            QLatin1String("AES"),
                                            "MineArea2SituationMap");
        m_aes2MapCont[static_cast<int>(aesType)] = sim2Map;
      }
      if (!sim2Map->init(m_pluginProvider))
        ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";
    }

    {
      const int contIdx = 0;
      MineAreaNull2SituationMap *sim2Map = static_cast<MineAreaNull2SituationMap *>(m_aes2MapCont.value(contIdx));
      if (! sim2Map)
      {
        sim2Map = new MineAreaNull2SituationMap(m_map->objectFactory(),
                                                QLatin1String("AES"),
                                                "MineAreaNull2SituationMap");
        m_aes2MapCont[static_cast<int>(contIdx)] = sim2Map;
      }
      if (!sim2Map->init(m_pluginProvider))
        ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";
    }

    {
      AreaEffectSimulation::AesType::inner_enum aesType = AreaEffectSimulation::AesType_def::AtMineCorridor;
      MineCorridor2SituationMap *sim2Map = static_cast<MineCorridor2SituationMap *>(m_aes2MapCont.value(aesType));
      if (! sim2Map)
      {
        sim2Map = new MineCorridor2SituationMap(m_map->objectFactory(),
                                                QLatin1String("AES"),
                                                "MineCorridor2SituationMap");
        m_aes2MapCont[static_cast<int>(aesType)] = sim2Map;
      }
      if (!sim2Map->init(m_pluginProvider))
        ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";
    }

    {
      AreaEffectSimulation::AesType::inner_enum aesType = AreaEffectSimulation::AesType_def::AtBCContamination;
      BCContamination2SituationMap *sim2Map = static_cast<BCContamination2SituationMap *>(m_aes2MapCont.value(aesType));
      if (! sim2Map)
      {
        sim2Map = new BCContamination2SituationMap(m_map->objectFactory(),
                                                   QLatin1String("AES"),
                                                   "BContamination2SituationMap");
        m_aes2MapCont[static_cast<int>(aesType)] = sim2Map;
      }
      if (!sim2Map->init(m_pluginProvider))
        ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";
    }

    //
    // AESCentral :
    //
    {
      // prepare UniqueValueRenderer here:

      // relevant for Overview

      static const QString layernameAesCentral(QStringLiteral("AESCentral"));

      // !!! new feature SceneMarker reuquires NContamination2SituationMap to be moved to layer with RenderingMode::Dynamic !!!
      {
        AreaEffectSimulation::AesType::inner_enum aesType = AreaEffectSimulation::AesType_def::AtNContamination;
        NContamination2SituationMap *sim2Map = static_cast<NContamination2SituationMap *>(m_aes2MapCont.value(aesType));
        if (! sim2Map)
        {
          sim2Map = new NContamination2SituationMap(m_map->objectFactory(),
                                                    layernameAesCentral,
                                                    "NContamination2SituationMap");
          m_aes2MapCont[static_cast<int>(aesType)] = sim2Map;
        }
        if (!sim2Map->init(m_pluginProvider))
          ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";
      }

      int drawOrder = 0;

      {
        AreaEffectSimulation::AesType::inner_enum aesType = AreaEffectSimulation::AesType_def::AtExplosionCluster;
        ExplosionCluster2SituationMap *sim2Map = static_cast<ExplosionCluster2SituationMap *>(m_aes2MapCont.value(aesType));
        if (! sim2Map)
        {
          sim2Map = new ExplosionCluster2SituationMap(m_pdmHandler,
                                                      m_map->objectFactory(),
                                                      layernameAesCentral,
                                                      drawOrder++,
                                                      "ExplosionCluster2SituationMap");

          m_aes2MapCont[static_cast<int>(aesType)] = sim2Map;
        }
        if (!sim2Map->init(m_pluginProvider))
          ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";
      }
      
      {
        AreaEffectSimulation::AesType::inner_enum aesType = AreaEffectSimulation::AesType_def::AtEffectCluster;
        EffectCluster2SituationMap *sim2Map = static_cast<EffectCluster2SituationMap *>(m_aes2MapCont.value(aesType));
        if (! sim2Map)
        {
          sim2Map = new EffectCluster2SituationMap(m_pdmHandler,
                                                      m_map->objectFactory(),
                                                      layernameAesCentral,
                                                      drawOrder++,
                                                      "EffectCluster2SituationMap");

          m_aes2MapCont[static_cast<int>(aesType)] = sim2Map;
        }
        if (!sim2Map->init(m_pluginProvider))
          ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";
      }

      // ChargeEffect @ layernameAesCentral
      {
        if (m_pluginProvider->partitionId() > 0)
        {
          m_chargeEffects = QSharedPointer<ChargeEffectToMap>(new ChargeEffectToMap(m_map->objectFactory(),
                                                                                    layernameAesCentral,
                                                                                    drawOrder++,
                                                                                    "ChargeEffectToMap"));
          if (!m_chargeEffects->init(m_pluginProvider))
            ERROR_LOG(m_logger) << LOGFUNCTION << " init failed (ChargeEffectToMap)";
          else
            DEBUG_LOG(m_logger) << LOGFUNCTION << " ChargeEffect2Map for ChargeEffect prepared";
        }
      }


      if (m_map->mode() == Mode::Mode_3D)
      {
        INFO_LOG(m_logger) << LOGFUNCTION << " assignUniqueValueRendererAesCentral";
        initRenderer3D_AesCentral_Booby(layernameAesCentral, {AreaEffectSimulation::AesType_def::AtBoobyTrap, AreaEffectSimulation::AesType_def::AtOffRouteMine});
      }

      {
        AreaEffectSimulation::AesType::inner_enum aesType = AreaEffectSimulation::AesType_def::AtBoobyTrap;
        BoobyTrap2SituationMap *sim2Map = static_cast<BoobyTrap2SituationMap *>(m_aes2MapCont.value(aesType));
        if (!sim2Map)
        {
          sim2Map = new BoobyTrap2SituationMap(m_map->objectFactory(),
                                               layernameAesCentral,
                                               "BoobyTrap2SituationMap");
          m_aes2MapCont[static_cast<int>(aesType)] = sim2Map;
        }
        if (!sim2Map->init(m_pluginProvider))
          ERROR_LOG(m_logger)<<LOGFUNCTION <<" init failed";
      }

      {
        AreaEffectSimulation::AesType::inner_enum aesType = AreaEffectSimulation::AesType_def::AtOffRouteMine;
        OffRoute2SituationMap *sim2Map = static_cast<OffRoute2SituationMap *>(m_aes2MapCont.value(aesType));
        if (!sim2Map)
        {
          sim2Map = new OffRoute2SituationMap(m_map->objectFactory(),
                                               layernameAesCentral,
                                               "OffRoute2SituationMap");
          m_aes2MapCont[static_cast<int>(aesType)] = sim2Map;
        }
        if (!sim2Map->init(m_pluginProvider))
          ERROR_LOG(m_logger)<<LOGFUNCTION <<" init failed";
      }

    }
    //
    // : AESCentral
    //

    {
      AreaEffectSimulation::AesType::inner_enum aesType = AreaEffectSimulation::AesType_def::AtDangerArea;
      DangerArea2SituationMap *sim2Map = static_cast<DangerArea2SituationMap *>(m_aes2MapCont.value(aesType));
      if (! sim2Map)
      {
        sim2Map = new DangerArea2SituationMap(m_map->objectFactory(),
                                              QLatin1String("AES"),
                                              "DangerArea2SituationMap");
        m_aes2MapCont[static_cast<int>(aesType)] = sim2Map;
      }
      if (!sim2Map->init(m_pluginProvider))
        ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";
    }

    {
      AreaEffectSimulation::AesType::inner_enum aesType = AreaEffectSimulation::AesType_def::AtFunctionalArea;
      FunctionalArea2SituationMap *sim2Map = static_cast<FunctionalArea2SituationMap*>(m_aes2MapCont.value(aesType));
      if (! sim2Map)
      {
        sim2Map = new FunctionalArea2SituationMap(m_map->objectFactory(),
                                                  QLatin1String("AES"),
                                                  "FunctionalArea2SituationMap");
        m_aes2MapCont[static_cast<int>(aesType)] = sim2Map;
      }
      if (!sim2Map->init(m_pluginProvider))
        ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";
    }

    {
      AreaEffectSimulation::AesType::inner_enum aesType = AreaEffectSimulation::AesType_def::AtBorderline;
      Borderline2SituationMap *sim2Map = static_cast<Borderline2SituationMap*>(m_aes2MapCont.value(aesType));
      if (! sim2Map)
      {
        sim2Map = new Borderline2SituationMap(m_map->objectFactory(),
                                              QLatin1String("AES"),
                                              "Borderline2SituationMap");
        m_aes2MapCont[static_cast<int>(aesType)] = sim2Map;
      }
      if (!sim2Map->init(m_pluginProvider))
        ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";
    }

    {
      AreaEffectSimulation::AesType::inner_enum aesType = AreaEffectSimulation::AesType_def::AtReconArea;
      ReconArea2SituationMap *sim2Map = static_cast<ReconArea2SituationMap*>(m_aes2MapCont.value(aesType));
      if (! sim2Map)
      {
        sim2Map = new ReconArea2SituationMap(m_map->objectFactory(),
                                             QLatin1String("AES"),
                                             "ReconArea2SituationMap");
        m_aes2MapCont[static_cast<int>(aesType)] = sim2Map;
      }
      if (!sim2Map->init(m_pluginProvider))
        ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";
    }

    //
    // AHTC -> DusSingleMine2SituationMap
    //
    {
      AreaEffectSimulation::AesType::inner_enum aesType = AreaEffectSimulation::AesType_def::AtDusSingleMine;
      DusSingleMine2SituationMap *sim2Map = static_cast<DusSingleMine2SituationMap*>(m_aes2MapCont.value(aesType));
      if (! sim2Map)
      {
        sim2Map = new DusSingleMine2SituationMap(m_map->objectFactory(),
                                                 QLatin1String("AES"),
                                                 "DusSingleMine2SituationMap");
        m_aes2MapCont[static_cast<int>(aesType)] = sim2Map;
      }
      if (!sim2Map->init(m_pluginProvider))
        ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";
    }

    //
    // AHTC -> DusSingleMine2SituationMap
    //
    {
      AreaEffectSimulation::AesType::inner_enum aesType = AreaEffectSimulation::AesType_def::AtGasPipe;
      GasPipe2SituationMap *sim2Map = static_cast<GasPipe2SituationMap *>(m_aes2MapCont.value(aesType));
      if (! sim2Map)
      {
        sim2Map = new GasPipe2SituationMap(m_map->objectFactory(),
                                           QLatin1String("AES"),
                                           "GasPipe2SituationMap");
        m_aes2MapCont[static_cast<int>(aesType)] = sim2Map;
      }
      if (!sim2Map->init(m_pluginProvider))
        ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";
    }

    //
    // AtAirSupport
    //
    {
      AreaEffectSimulation::AesType::inner_enum aesType = AreaEffectSimulation::AesType_def::AtAirSupportImpact;
      AirSupportImpact2SituationMap *sim2Map = static_cast<AirSupportImpact2SituationMap*>(m_aes2MapCont.value(aesType));
      if (! sim2Map)
      {
        sim2Map = new AirSupportImpact2SituationMap(m_map->objectFactory(),
                                                    QLatin1String("AES"),
                                                    "AirSupportImpact2SituationMap");

        m_aes2MapCont[static_cast<int>(aesType)] = sim2Map;
      }
      if (!sim2Map->init(m_pluginProvider))
        ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";
    }

    // AtTechnicalArea (Mout/Wls Area, ...)
    {
      AreaEffectSimulation::AesType::inner_enum aesType = AreaEffectSimulation::AesType_def::AtTechnicalArea;
      TechnicalArea2SituationMap *sim2Map = static_cast<TechnicalArea2SituationMap*>(m_aes2MapCont.value(aesType));
      if (! sim2Map)
      {
        sim2Map = new TechnicalArea2SituationMap(m_map->objectFactory(),
                                                 QLatin1String("TechnicalAreas"),    // AES -> TechnicalAreas
                                                 "TechnicalArea2SituationMap");

        m_aes2MapCont[static_cast<int>(aesType)] = sim2Map;
      }
      if (!sim2Map->init(m_pluginProvider))
        ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";
    }


  } // AES:


  // ALM:
//  if (m_pluginProvider->partitionId() > 0)  // not for adminSession
//  {
//    m_alarms  = QSharedPointer<AlarmToMap>(new AlarmToMap(m_map->objectFactory(),
//                                                          QStringLiteral("JumpPoints"),  // Check!!!
//                                                          0,
//                                                          "AlarmToMap"));
//    if (!m_alarms->init(m_pluginProvider))
//      ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";

//    // create JumpPoint for EmergencyCall:
//    connect(m_alarms.data(), &AlarmToMap::alarmUpdated,
//            this, [this](const QString &name, const Point3D &geoPosition) {
//      m_map->addJumpPoint(name, geoPosition);  // scale = -1 -> stay at current scale
//    });
//  }

  LtsUtils::ProjectSettings *ps = LtsUtils::ProjectSettings::getInstance();
  const bool enableAlmEmergencyCall = ps->value(QStringLiteral("alm"),
                                                QStringLiteral("enableEmergencyCalls")).toBool();

  if (enableAlmEmergencyCall)
  {
    if (m_pluginProvider->partitionId() > 0)
    {
      // will createLogicalLayer "EmergencyCall" implicit:
      const QString &emergencyCallLayername = m_map->layerFactory().emergencyCallLayer();
      // create according adapter:
      m_emergencyCalls = QSharedPointer<EmergencyCallToMap>(new EmergencyCallToMap(m_map->objectFactory(),
                                                                                   emergencyCallLayername,
                                                                                   0, "EmergencyCallToMap"));
      if (!m_emergencyCalls->init(m_pluginProvider))
        ERROR_LOG(m_logger) << LOGFUNCTION << " init failed (EmergencyCallToMap)";
      else
        DEBUG_LOG(m_logger) << LOGFUNCTION << " EmergencyCallToMap for AlmEmergencyCalls prepared";
    }
  }

  // ISM:
  int drawOrder = 0;

  // Building2SituationMap
  m_buildings = QSharedPointer<Building2SituationMap>(new Building2SituationMap(m_map->objectFactory(),
                                                                                QStringLiteral("Buildings"),
                                                                                drawOrder++,
                                                                                "Building2SituationMap"));

  const bool enableDamageVisualization =
      ps->value(QStringLiteral("SituationMap"), QStringLiteral("enableDamageVisualizationAtBuilding2Map")).toBool();
  if (!m_buildings->init(m_pluginProvider, enableDamageVisualization))
    ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";


  // TrainingAreaSituationMap

  const bool enableTrainingAreaBorder =
      ps->value(QStringLiteral("SituationMap"), QStringLiteral("enableTrainingAreaBorder"), false).toBool();
  if (enableTrainingAreaBorder)
  {
    m_trainingAreas = QSharedPointer<TrainingAreaToSituationMap>(new TrainingAreaToSituationMap(m_map->objectFactory(),
                                                                                                QStringLiteral("TechnicalAreas"),
                                                                                                drawOrder++,
                                                                                                "TrainingAreaToSituationMap"));
    if (!m_trainingAreas->init(m_pluginProvider))
      ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";
  }

  m_specialAreas = QSharedPointer<SpecialAreaToSituationMap>(new SpecialAreaToSituationMap(m_map->objectFactory(),
                                                                                              QStringLiteral("TechnicalAreas"),
                                                                                              drawOrder++,
                                                                                              "SpecialAreaToSituationMap"));
  if (!m_specialAreas->init(m_pluginProvider))
    ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";


  // MountingPointToMap
  m_mountingPoints = QSharedPointer<MountingPointToMap>(new MountingPointToMap(m_map->objectFactory(),
                                                                               QStringLiteral("MountingPoints"),
                                                                               drawOrder++,
                                                                               "MountingPointToMap"));
  if (!m_mountingPoints->init(m_pluginProvider, resourceMode))
    ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";


  // SoundAreaToMap
  m_soundAreas = QSharedPointer<SoundAreaToMap>(new SoundAreaToMap(m_map->objectFactory(),
                                                                   QStringLiteral("MountingPoints"),
                                                                   drawOrder++,
                                                                   "SoundAreaToMap"));
  if (!m_soundAreas->init(m_pluginProvider, resourceMode))
    ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";


  if (!resourceMode) // these MSE do not show in ResourceManagement
  {
    // MSEPointsToMap
    m_msePoints = QSharedPointer<MSEPointToMap>(new MSEPointToMap(m_map->objectFactory(),
                                                                  QStringLiteral("MountingPoints"),   // seperate layer?
                                                                  drawOrder++,
                                                                  "MsePointToMap"));
    if (!m_msePoints->init(m_pluginProvider))
      ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";

    // MSEBridgeToMap
    m_mseBridges = QSharedPointer<MSEBridgeToMap>(new MSEBridgeToMap(m_map->objectFactory(),
                                                                     QStringLiteral("TechnicalAreas"),  // TechnicalAreas->Draped // seperate layer?
                                                                     drawOrder++,
                                                                     "MseBridgeToMap"));
    if (!m_mseBridges->init(m_pluginProvider))
      ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";
  }

  // TGT:
  m_shootbackAreas = QSharedPointer<ShootbackAreaToSituationMap>(new ShootbackAreaToSituationMap(m_map->objectFactory(),
                                                                                                 QLatin1String("TechnicalAreas"),
                                                                                                 drawOrder++,
                                                                                                 "ShootbackAreaToSituationMap"));
  if (!m_shootbackAreas->init(m_pluginProvider))
    ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";

  const bool bIsOfTypeOrganizer =
      (m_pluginProvider->operatorId() == 99) ||     // 99 == Organisator
      (m_pluginProvider->operatorId() == 98);       // 98 == Organizer

  // GIM:
  if (!bIsOfTypeOrganizer)
  {
    m_guezIeds = QSharedPointer<GuezIed2SituationMap>(new GuezIed2SituationMap(m_map->objectFactory(),
                                                                               QLatin1String("IEDs"),
                                                                               drawOrder++,
                                                                               "GuezIed2SituationMap"));
    if (!m_guezIeds->init(m_pluginProvider))
      ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";
  }


  // GNA:
  m_guezNasat9Liner = QSharedPointer<GuezNasat9Liner2SituationMap>(new GuezNasat9Liner2SituationMap(m_map->objectFactory(),
                                                                                                    QLatin1String("AES"),
                                                                                                    drawOrder++,
                                                                                                    "NineLiner2SituationMap"));
  if (!m_guezNasat9Liner->init(m_pluginProvider))
    ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";


  //
  // BuildingOwnership and Contamination (just for 3D)
  //
  if ((m_map->mode() == Mode::Mode_3D) && (m_buildingOwnership.isNull()))
    m_buildingOwnership = QSharedPointer<BuildingOwnership>(new BuildingOwnership(drawOrder++, this));

  if (m_buildingOwnership)
    if (!m_buildingOwnership->init(m_map, m_pluginProvider))
      ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";

  if ((m_map->mode() == Mode::Mode_3D) && (m_buildingContamination.isNull()))
    m_buildingContamination = QSharedPointer<BuildingContamination>(new BuildingContamination(drawOrder++, this));

  if (m_buildingContamination)
    if (!m_buildingContamination->init(m_map, m_pluginProvider))
      ERROR_LOG(m_logger) << LOGFUNCTION << " init failed";
  // finish setting up of all items:

  //
  // 1.
  // signal-signal-connection: mapObjectChanged, mapObjectRemoved
  // to update MapObjectSelectionWindow
  //
  // 2.
  // connect to all xy2SituationMap using layer "AES".
  // all of mapObject on this layer should be ordered by their DDS::effectStartTime.
  // This value is accesable by startTime(UniqueMapId uniqueMapId)


  const QList<Sim2SituationMapBase *> &sim2map = listOfSim2Map();
  for (const auto &item : qAsConst(sim2map))
  {
    // 1) to update MapObjectSelectionWindow
    connect(item, &Sim2SituationMapBase::mapObjectChanged,
            this, &AdapterDds::mapObjectChanged, Qt::UniqueConnection);
    connect(item, &Sim2SituationMapBase::mapObjectRemoved,
            this, &AdapterDds::mapObjectRemoved, Qt::UniqueConnection);

    // use this approach if using layer "AES":
    if (item->layername().compare(QLatin1String("AES")) == 0)
    {
      // switch off default behaviour:
      item->setAssignDrawOrder(false);

      // switch on behaviour depending on XYChanged etc:
      // 2) to update drawOrder of MapObject
      connect(item, &Sim2SituationMapBase::mapObjectChanged,
              this, &AdapterDds::onMapObjectChangedUpdateDrawOrder, Qt::UniqueConnection);
      connect(item, &Sim2SituationMapBase::mapObjectRemoved,
              this, &AdapterDds::onMapObjectRemoved, Qt::UniqueConnection);
    }
  } // for


  TRACE_LOG(m_logger) << LOGFUNCTION << " END" ;
  return true;
}

bool AdapterDds::initRenderer3D_AesExtrusion()
{
  if (m_map->mode() != Mode::Mode_3D)
    return false;

  INFO_LOG(m_logger) << LOGFUNCTION << " START";

  //
  // showing the extrusion of aes objects via 3D cubes
  // on TechnicalLayerType::GraphicsLayer_3D_Extrusion / "GraphicsLayer_3D_Extr"
  // assignUniqueValueRendererAesCentral3DExtrusion
  //

  // partyData typically arives a little bit later:
  QTimer::singleShot(1000, this, [this] () {

    static const QString layernameAes(QStringLiteral("AES")); // AES TechnicalAreas Buildings

    // changes:
    connect(m_map, &Map::partysChangedDelayed, this, [this] () {
      DEBUG_LOG(m_logger) << LOGFUNCTION << " partysChangedDelayed ********";

      // FIRST
      bool successAes = assignUniqueValueRendererAesCentral3DExtrusion(layernameAes);
      if (successAes)
        INFO_LOG(m_logger) << LOGFUNCTION << " assignUniqueValueRendererAesCentral3DExtrusion okay" << " ('" << layernameAes << "')";
      else
        for (int i=0; i<5; ++i)
          ERROR_LOG(m_logger) << LOGFUNCTION << " assignUniqueValueRendererAesCentral3DExtrusion failed" << " ('" << layernameAes << "')";

      // SECOND
      // re-run some adapter to update colors:
      if (isRunning())
      {
        const QList<Sim2SituationMapBase *> &aes2Map = listOfAes2Map();
        for (const auto &item : qAsConst(aes2Map))
          if (item)
            item->run();
      }
    });

    // initial:
    bool successAes = assignUniqueValueRendererAesCentral3DExtrusion(layernameAes);
    if (successAes)
      INFO_LOG(m_logger) << LOGFUNCTION << " assignUniqueValueRendererAesCentral3DExtrusion okay" << " ('" << layernameAes << "')";
    else
      for (int i=0; i<5; ++i)
        ERROR_LOG(m_logger) << LOGFUNCTION << " assignUniqueValueRendererAesCentral3DExtrusion failed" << " ('" << layernameAes << "')";
  });


  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return true;
}

bool AdapterDds::initRenderer3D_AesCentral_Booby(const QString &layernameAesCentral, const QVector<int> &aesTypesForReRunIfPartyColorChanges)
{
  if (m_map->mode() != Mode::Mode_3D)
    return false;

  //
  // prepare CONE, SPERE etc:
  //

  INFO_LOG(m_logger) << LOGFUNCTION << " START, layernameAesCentral=" << layernameAesCentral;

  connect(m_map, &Map::partysChangedDelayed, this, [this, layernameAesCentral, aesTypesForReRunIfPartyColorChanges] () {
    DEBUG_LOG(m_logger) << LOGFUNCTION << " partysChangedDelayed ********";

    // FIRST
    bool successAesCentral = assignUniqueValueRendererAesCentral(layernameAesCentral);
    if (successAesCentral)
      DEBUG_LOG(m_logger) << LOGFUNCTION << " assignUniqueValueRendererAesCentral okay" << " ('" << layernameAesCentral << "')";
    else
      for (int i=0; i<5; ++i)
        ERROR_LOG(m_logger) << LOGFUNCTION << " assignUniqueValueRendererAesCentral failed" << " ('" << layernameAesCentral << "')";

    // SECOND
    // re-run some adapter to update colors:
    if (isRunning())
    {
      for (int aesTypeInt : qAsConst(aesTypesForReRunIfPartyColorChanges))
      {
        auto it = m_aes2MapCont.find(aesTypeInt);
        if (it != m_aes2MapCont.end())
          (*it)->run();
      } // For
    }

  });

  bool successAesCentral = assignUniqueValueRendererAesCentral(layernameAesCentral);
  if (successAesCentral)
    DEBUG_LOG(m_logger) << LOGFUNCTION << " assignUniqueValueRendererAesCentral okay" << " ('" << layernameAesCentral << "')";
  else
    for (int i=0; i<5; ++i)
      ERROR_LOG(m_logger) << LOGFUNCTION << " assignUniqueValueRendererAesCentral failed" << " ('" << layernameAesCentral << "')";

  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return true;
}

bool AdapterDds::assignUniqueValueRendererAesCentral(const QString &layername)
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START, layername ='" << layername << "'" ;

  QVector<LayerFactory::UniqueValueDataAesCentral::TYPE> typeVec;
  typeVec << LayerFactory::UniqueValueDataAesCentral::TYPE::CONE;
  typeVec << LayerFactory::UniqueValueDataAesCentral::TYPE::SPHERE;

  const PartyIdToColorFunctor::ColorMap &colorMap = m_map->partyIdToColorFunctor().colorMap();
  if (colorMap.isEmpty())
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << " colorMap is empty";
    return false;
  }
  QVector<QColor> colVec;
  {

    colVec.reserve( (colorMap.size()*2) + 5);
    colVec << Qt::black;   // For areas without a color (they will use the color black)

    for (const PartyIdToColorFunctor::PartyData &partyData : qAsConst(colorMap))
    {
      DEBUG_LOG(m_logger) << LOGFUNCTION << " partyName=" << partyData.m_name << "'" << " partyColor=" << partyData.m_color.name() << "'";
      colVec << partyData.m_color;
      // 27.01.2025 / GUEZE-3307: light not needed:
      // colVec << partyData.m_lightColor;

    }
  }

  QVector<float> radiuss;
  // Norbert Thoden, 20.03.2024 :
  // For BoobyTraps: we need:
  // radiuss << 1 << 5 << 10; // (system: 5 and 10 meter, fallback: 1 meter)
  // GUI (LTS_DEBUG) for BoobyTraps: {1,2,3,4,5}

  // For OffRouteMine we need 1, 2 ... 10;
  // // radiuss << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8 << 9 << 10;

  // For ExplosionCluster (3DWirksim) and its charges:
  // // radiuss << 15 << 25 << 40 << 60 << 125; // // see pdm.pdm_charge_type
  // id=381, name= HE 120mm, bIsPoint 0, bIsVulcano 0, impactRadius4Debug = 15
  // id=371, name= HE 155mm, bIsPoint 0, bIsVulcano 0, impactRadius4Debug = 25
  // ??

  // loop over a) typeVec (2) ; b) colVec (14*2+1) ; c) radiuss (15) == 870!! - Hopefully that is okay...
  // : Norbert Thoden, 20.03.2024

  // Norbert Thoden, 27.01.2025:
  // GUEZE-3307:
  // For BoobyTraps  : we need: 10m, fallback: 10m
  // For OffRouteMine: we need: 10m;
  radiuss << 10;
  // -> loop over a) typeVec (2) ; b) colVec (14*1+1) ; c) radiuss (1) == 30!! - Hopefully that is okay...
  // : Norbert Thoden, 22.01.2025

  bool success = false;
  {
    QVector<LayerFactory::UniqueValueDataAesCentral> uvCont;

    for (const LayerFactory::UniqueValueDataAesCentral::TYPE &type : qAsConst(typeVec))
    {
      for (const QColor &col : qAsConst(colVec))
      {
        for (float radius : qAsConst(radiuss))
        {
          LayerFactory::UniqueValueDataAesCentral uvd;
          QString singleVal;

          // V100.8: order seems to be relevant. Keep alphabetical;
          singleVal = QString(QStringLiteral("Impact_Color_%1")).arg(col.name()); // name is without alpha: col.name = #00ff00
          uvd.values.append(singleVal);
          singleVal = QString(QStringLiteral("Impact_Radius_%1")).arg(radius);
          uvd.values.append(singleVal);
          singleVal = QString(QStringLiteral("Impact_Type_%1")).arg(LayerFactory::toString(type));
          uvd.values.append(singleVal);

          uvd.type = type;

          uvd.col = col;
          uvd.col.setAlphaF(0.5);

          uvd.radius = radius;
          uvd.height = uvd.radius;

          uvCont.append(uvd);
        } // for
      } // for
    } // for

    INFO_LOG(m_logger) << LOGFUNCTION
                       << " typeVec.size() = " << typeVec.size()
                       << " colVec.size() = " << colVec.size() << " (colorMap.size() = " << colorMap.size() << ")"
                       << " radiuss.size() = " << radiuss.size()
                       << " -> product = " << typeVec.size() * colVec.size() * radiuss.size()
                       << " -> uvCont.size() = " << uvCont.size();

    QStringList fieldnames;
    // V100.8: order seems to be relevant. keep alphabetical
    fieldnames.append(QString(QStringLiteral("IMPACT_COLOR")));
    fieldnames.append(QString(QStringLiteral("IMPACT_RADIUS")));
    fieldnames.append(QString(QStringLiteral("IMPACT_TYPE")));

    success = m_map->layerFactory().assignUniqueValueRendererAesCentral(layername,
                                                                        fieldnames,
                                                                        uvCont);
  }

  TRACE_LOG(m_logger) << LOGFUNCTION << " END, layername ='" << layername << "'" ;
  return success;
}

bool AdapterDds::assignUniqueValueRendererAesCentral3DExtrusion(const QString &layername)
{
  DEBUG_LOG(m_logger) << LOGFUNCTION << " START, layername ='" << layername << "'" ;

  QVector<QColor> colVec;
  {
    const PartyIdToColorFunctor::ColorMap &colorMap = m_map->partyIdToColorFunctor().colorMap();
    if (colorMap.isEmpty())
    {
      ERROR_LOG(m_logger) << LOGFUNCTION << " colorMap is empty";
      return false;
    }

    colVec.reserve(colorMap.size());
    for (const PartyIdToColorFunctor::PartyData &partyData : colorMap)
    {
      DEBUG_LOG(m_logger) << LOGFUNCTION << " partyName=" << partyData.m_name << "'" << " partyColor=" << partyData.m_color.name() << "'";
      colVec << partyData.m_color
             << partyData.m_lightColor;
    }
  }

  static double s_ALPHA_VALUE_F = 0.6;

  QVector<LayerFactory::UniqueValueDataAesCentral> uvCont;
  uvCont.reserve(colVec.size());

  for (const QColor &col : qAsConst(colVec))
  {
    LayerFactory::UniqueValueDataAesCentral uvd;

    uvd.label = col.name();             // more or less optional
    uvd.values.append(col.name());      // concrete values

    uvd.col = col;
    uvd.col.setAlphaF(s_ALPHA_VALUE_F);

    uvCont.append(uvd);
  } // for

  // additional colors: / Qt-builtIn
  static QVector<QColor> addColors = {Qt::darkGray, Qt::gray, Qt::lightGray,
                                      Qt::red, Qt::green, Qt::blue,
                                      Qt::cyan, Qt::magenta, Qt::yellow,
                                      Qt::darkRed, Qt::darkGreen, Qt::darkBlue,
                                      Qt::darkCyan, Qt::darkMagenta, Qt::darkYellow};
  uvCont.reserve(uvCont.size() + addColors.size());

  for (const QColor &addColor : qAsConst(addColors))
  {
    LayerFactory::UniqueValueDataAesCentral uvd;
    uvd.label = addColor.name();             // more or less optional
    uvd.values.append(addColor.name());      // concrete values

    uvd.col = addColor;
    uvd.col.setAlphaF(s_ALPHA_VALUE_F);

    uvCont.append(uvd);
  }

  QStringList fieldnames;
  // V100.8: order seems to be relevant. Keep alphabetical
  fieldnames.append(QString(QStringLiteral("Extrusion_Color")));

  bool success = m_map->layerFactory().assignUniqueValueRendererAesCentral3DExtrusion(layername,
                                                                                      fieldnames,
                                                                                      uvCont);

  TRACE_LOG(m_logger) << LOGFUNCTION << " END, layername ='" << layername << "'"
                      << " success = " << success;
  return success;
}

bool AdapterDds::run()
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";

  if (m_isRunning)
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << " already running" ;
    return false;
  }

  bool success = true;

  const QList<Sim2SituationMapBase *> &sim2Map = listOfSim2Map();
  for (Sim2SituationMapBase *item : qAsConst(sim2Map))
  {
    success = item->run() && success;
  }

  //
  // BuildingOwnership
  //
  if (m_buildingOwnership)
  {
    // the buildingOwnership is most likely less relevant than AES or similar.
    // so start this with a short delay:
    QTimer::singleShot(1000, this, [this]()
    {
      m_buildingOwnership->run();
    });
  }

  //
  // BuildingContamination
  //
  if (m_buildingContamination)
  {
    // the BuildingContamination is most likely less relevant than AES or similar.
    // so start this with a short delay:
    QTimer::singleShot(1000, this, [this]()
    {
      m_buildingContamination->run();
    });
  }


  //
  // HitlineInfo2SituationMap
  //
  // is moved to listOfSim2Map...
  //  if (m_hitlineInfo2SituationMap)
  //    m_hitlineInfo2SituationMap->run();

  //
  // BuildingHitlineInfo2SituationMap
  //
  // is moved to listOfSim2Map...
  //  if (m_bldHitlineInfo2SituationMap)
  //    m_bldHitlineInfo2SituationMap->run();

  m_isRunning = success;


  INFO_LOG(m_logger) << LOGFUNCTION << " connect to SymbolDictionary::changed" ;
  connect(&m_map->symbolDictionary(), &AdvancedSymbology::SymbolDictionary::changed,
          this, &AdapterDds::startChangedDelayTimer, Qt::UniqueConnection);

  TRACE_LOG(m_logger) << LOGFUNCTION << " END" ;
  return success;
}

bool AdapterDds::isRunning() const
{
  return m_isRunning;
}

bool AdapterDds::stop()
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START" ;

  if (m_pluginProvider && !m_pluginProvider->isSessionValid())
  {
    m_isRunning = false;
    DEBUG_LOG(m_logger) << LOGFUNCTION << " no session anymore: ignore 'stop' -> return";
    return false;
  }

  const QList<Sim2SituationMapBase *> &sim2Map = listOfSim2Map();
  for (Sim2SituationMapBase *item : qAsConst(sim2Map))
  {
    item->stop();
  }

  //
  // Alarm
  //
  // Emergency call
  if (m_emergencyCalls)
    m_emergencyCalls->stop();


  // Charge Effect
  if (m_chargeEffects)
    m_chargeEffects->stop();

  //
  // BuildingOwnership
  //
  if (m_buildingOwnership)
    m_buildingOwnership->stop();
  //
  // BuildingContamination
  //
  if (m_buildingContamination)
    m_buildingContamination->stop();
  //
  // Hitline2SituationMap
  //
  if (m_hitlineInfo2SituationMap)
    m_hitlineInfo2SituationMap->stop();

  //
  // BuildingHitlineInfo2SituationMap
  //
  if (m_bldHitlineInfo2SituationMap)
    m_bldHitlineInfo2SituationMap->stop();

  m_isRunning = false;

  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return true;
}

void AdapterDds::clearObjects()
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";

  const QList<Sim2SituationMapBase *> &sim2Map = listOfSim2Map();
  for (Sim2SituationMapBase *item : qAsConst(sim2Map))
  {
    item->clearObjects();
  }

  //
  // Alarm
  //
  // Emergency call
  if (m_emergencyCalls)
    m_emergencyCalls->clearObjects();


  // Charge Effect call
  if (m_chargeEffects)
    m_chargeEffects->clearObjects();

  //
  // BuildingOwnership
  //
  if (m_buildingOwnership)
    m_buildingOwnership->clearObjects();

  //
  // BuildingContamination
  //
  if (m_buildingContamination)
    m_buildingContamination->clearObjects();

  //
  // Hitline2SituationMap
  //
  if (m_hitlineInfo2SituationMap)
    m_hitlineInfo2SituationMap->clearObjects();

  //
  // BuildingHitlineInfo2SituationMap
  //
  if (m_bldHitlineInfo2SituationMap)
    m_bldHitlineInfo2SituationMap->clearObjects();



  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
}

ResourceManagerMode AdapterDds::resourceManagerMode() const
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
  if (!m_mountingPoints)
    return ResourceManagerMode::Undefined;

  ResourceManagerMode rmm = m_mountingPoints->resourceManagerMode();
  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return rmm;
}

bool AdapterDds::setResourceManagerMode(ResourceManagerMode rmm)
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
  if (!m_mountingPoints)
    return false;

  bool success = m_mountingPoints->setResourceManagerMode(rmm);

  // update icons...
  emit resourceManagerModeChanged(m_mountingPoints->resourceManagerMode());

  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return success;
}

bool AdapterDds::showExpiredEmergencyCalls(bool bShowExpired)
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";

  if (!m_emergencyCalls)
    return false;

  m_emergencyCalls->showExpired(bShowExpired);
  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return true;
}


bool AdapterDds::uniqueMapId2SimId(UniqueMapId uniqueMapIdIn, int32_t &simIdOut)
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START"
                      << " uniqueMapId=" << uniqueMapIdIn;

  if (!SituationMap::isUniqueMapIdValid(uniqueMapIdIn))
    return false;

  const QList<Sim2SituationMapBase *> &sim2Map = listOfSim2Map();
  for (const auto &item : qAsConst(sim2Map))
  {
    simIdOut = -1;
    if (item->uniqueMapId2SimId(uniqueMapIdIn, simIdOut))
      return true;
  }
  return false;
}

bool AdapterDds::unifiedMapObjectData(UniqueMapId uniqueMapIdIn, UnifiedMapObjectData &umodOut) const
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START"
                      << " uniqueMapId=" << uniqueMapIdIn;

  if (!SituationMap::isUniqueMapIdValid(uniqueMapIdIn))
    return false;

  const QList<Sim2SituationMapBase *> &sim2Map = listOfSim2Map();
  for (const auto &item : qAsConst(sim2Map))
  {
    if (item->unifiedMapObjectData(uniqueMapIdIn, umodOut))
      return true;
  }
  return false;
}

UniqueMapId AdapterDds::simId2UniqueMapIdParticipant(int32_t simId) const
{
  if (!m_particpants)
    return SituationMap::INVALID_MAP_ID;
  return m_particpants->simId2UniqueMapId(simId);
}
RefPointer<Participant> AdapterDds::simId2Participant(int32_t simId)
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START, simId=" << simId ;

  UniqueMapId mapId = simId2UniqueMapIdParticipant(simId);
  if (!isUniqueMapIdValid(mapId))
    return RefPointer<Participant>();

  RefPointer<Participant> mapObj = m_map->objectFactory().get<Participant>(mapId);
  TRACE_LOG(m_logger) << LOGFUNCTION << " END" ;
  return mapObj;
}

UniqueMapId AdapterDds::simId2UniqueMapIdAes(int32_t simId) const
{
  for (const auto &item : qAsConst(m_aes2MapCont))
  {
    UniqueMapId uniqueMapId = item->simId2UniqueMapId(simId);
    if (isUniqueMapIdValid(uniqueMapId))
      return uniqueMapId;
  }
  return INVALID_MAP_ID;
}
RefPointer<AbstractMapObject> AdapterDds::simId2Aes(int32_t simId)
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START, simId=" << simId ;

  UniqueMapId mapId = simId2UniqueMapIdAes(simId);
  if (!isUniqueMapIdValid(mapId))
    return RefPointer<AbstractMapObject>();

  RefPointer<AbstractMapObject> mapObj = m_map->objectFactory().get(mapId);
  TRACE_LOG(m_logger) << LOGFUNCTION << " END" ;
  return mapObj;
}


UniqueMapId AdapterDds::simId2UniqueMapIdBuilding(int32_t simId) const
{
  if (!m_buildings)
    return SituationMap::INVALID_MAP_ID;
  return m_buildings->simId2UniqueMapId(simId);
}
RefPointer<BuildingOutline> AdapterDds::simId2Building(int32_t simId)
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START, simId=" << simId;

  UniqueMapId mapId = simId2UniqueMapIdBuilding(simId);
  if (!isUniqueMapIdValid(mapId))
    return RefPointer<BuildingOutline>();

  RefPointer<BuildingOutline> mapObj = m_map->objectFactory().get<BuildingOutline>(mapId);
  TRACE_LOG(m_logger) << LOGFUNCTION << " END" ;
  return mapObj;
}

UniqueMapId AdapterDds::simId2UniqueMapIdBridge(int32_t simId) const
{
  if (!m_mseBridges)
    return SituationMap::INVALID_MAP_ID;
  return m_mseBridges->simId2UniqueMapId(simId);
}
RefPointer<BuildingOutline> AdapterDds::simId2Bridge(int32_t simId)
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START, simId=" << simId;

  UniqueMapId mapId = simId2UniqueMapIdBridge(simId);
  if (!isUniqueMapIdValid(mapId))
    return RefPointer<BuildingOutline>();

  RefPointer<BuildingOutline> mapObj = m_map->objectFactory().get<BuildingOutline>(mapId);
  TRACE_LOG(m_logger) << LOGFUNCTION << " END" ;
  return mapObj;
}

UniqueMapId AdapterDds::simId2UniqueMapIdMountingPoint(int32_t simId) const
{
  if (!m_mountingPoints)
    return SituationMap::INVALID_MAP_ID;
  return m_mountingPoints->simId2UniqueMapId(simId);
}

RefPointer<GeoImage> AdapterDds::simId2MountingPoint(int32_t simId)
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START, simId=" << simId;

  UniqueMapId mapId = simId2UniqueMapIdMountingPoint(simId);
  if (!isUniqueMapIdValid(mapId))
    return RefPointer<GeoImage>();

  RefPointer<GeoImage> mapObj = m_map->objectFactory().get<GeoImage>(mapId);
  TRACE_LOG(m_logger) << LOGFUNCTION << " END" ;
  return mapObj;
}

UniqueMapId AdapterDds::simId2UniqueMapIdGuezIed(int32_t simId) const
{
  if (!m_guezIeds)
    return SituationMap::INVALID_MAP_ID;
  return m_guezIeds->simId2UniqueMapId(simId);
}
RefPointer<Participant> AdapterDds::simId2GuezIed(int32_t simId)
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START, simId=" << simId;

  UniqueMapId mapId = simId2UniqueMapIdGuezIed(simId);
  if (!isUniqueMapIdValid(mapId))
    return RefPointer<Participant>();

  RefPointer<Participant> mapObj = m_map->objectFactory().get<Participant>(mapId);
  TRACE_LOG(m_logger) << LOGFUNCTION << " END" ;
  return mapObj;
}

UniqueMapId AdapterDds::simId2UniqueMapIdChargeEffect(int32_t simId) const
{
  if (!m_chargeEffects)
    return SituationMap::INVALID_MAP_ID;
  return m_chargeEffects->simId2UniqueMapId(simId);
}

RefPointer<SingleFire> AdapterDds::simId2ChargeEffect(int32_t simId)
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START, simId=" << simId;

   UniqueMapId mapId = simId2UniqueMapIdChargeEffect(simId);
   if (!isUniqueMapIdValid(mapId))
     return RefPointer<SingleFire>();

   RefPointer<SingleFire> mapObj = m_map->objectFactory().get<SingleFire>(mapId);
   TRACE_LOG(m_logger) << LOGFUNCTION << " END" ;
   return mapObj;
}

UniqueMapId AdapterDds::simId2UniqueMapIdTrainingArea(int32_t simId) const
{
  if (!m_trainingAreas)
    return SituationMap::INVALID_MAP_ID;
  return m_trainingAreas->simId2UniqueMapId(simId);
}

RefPointer<Polygon> AdapterDds::simId2TrainingArea(int32_t simId)
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START, simId=" << simId;

  UniqueMapId mapId = simId2UniqueMapIdTrainingArea(simId);
  if (!isUniqueMapIdValid(mapId))
    return {};

  using MAP_T = TrainingAreaToSituationMap::MAP_T; // Polygon
  RefPointer<MAP_T> mapObj = m_map->objectFactory().get<MAP_T>(mapId);
  TRACE_LOG(m_logger) << LOGFUNCTION << " END" ;
  return mapObj;
}

UniqueMapId AdapterDds::simId2UniqueMapIdSpecialArea(int32_t simId) const
{
  if (!m_specialAreas)
    return SituationMap::INVALID_MAP_ID;
  return m_specialAreas->simId2UniqueMapId(simId);
}

RefPointer<Polygon> AdapterDds::simId2SpecialArea(int32_t simId)
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START, simId=" << simId;

  UniqueMapId mapId = simId2UniqueMapIdSpecialArea(simId);
  if (!isUniqueMapIdValid(mapId))
    return {};

  using MAP_T = SpecialAreaToSituationMap::MAP_T; // Polygon
  RefPointer<MAP_T> mapObj = m_map->objectFactory().get<MAP_T>(mapId);
  TRACE_LOG(m_logger) << LOGFUNCTION << " END" ;
  return mapObj;
}

UniqueMapId AdapterDds::simId2UniqueMapIdShootbackArea(int32_t simId) const
{
  if (!m_shootbackAreas)
    return SituationMap::INVALID_MAP_ID;
  return m_shootbackAreas->simId2UniqueMapId(simId);
}

RefPointer<Polygon> AdapterDds::simId2ShootbackArea(int32_t simId)
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START, simId=" << simId;

  UniqueMapId mapId = simId2UniqueMapIdShootbackArea(simId);
  if (!isUniqueMapIdValid(mapId))
    return {};

  using MAP_T = ShootbackAreaToSituationMap::MAP_T; // Polygon
  RefPointer<MAP_T> mapObj = m_map->objectFactory().get<MAP_T>(mapId);
  TRACE_LOG(m_logger) << LOGFUNCTION << " END" ;
  return mapObj;
}

UniqueMapId AdapterDds::simId2UniqueMapId(MapObjectType mot, int32_t simId) const
{
  UniqueMapId uniqueMapId = INVALID_MAP_ID;
  switch (mot)
  {
  case MapObjectType::MOT_Participant:
    uniqueMapId = simId2UniqueMapIdParticipant(simId);
    break;
  case MapObjectType::MOT_TrainingArea:
    uniqueMapId = simId2UniqueMapIdTrainingArea(simId);
    break;
  case MapObjectType::MOT_ShootbackArea:
    uniqueMapId = simId2UniqueMapIdShootbackArea(simId);
    break;
  case MapObjectType::MOT_Building:
    uniqueMapId = simId2UniqueMapIdBuilding(simId);
    break;
  case MapObjectType::MOT_MountingPoint:
    uniqueMapId = simId2UniqueMapIdMountingPoint(simId);
    break;

  case MapObjectType::MOT_Aes:
  case MapObjectType::MOT_GuezIed:
  {
    ERROR_LOG(m_logger) << " not supported yet!!!";
    Q_FALLTHROUGH();
  }
  default:
    break;
  } //switch
  return uniqueMapId;
}

QVector<UniqueMapId> AdapterDds::simIds2UniqueMapIds(MapObjectType mot, QVector<int32_t> simIds) const
{
  QVector<UniqueMapId> uniqueMapIds;
  uniqueMapIds.reserve(simIds.size());

  using namespace std::placeholders;
  std::function<UniqueMapId(int32_t)> simToMap = nullptr;

  switch (mot)
  {
  case MapObjectType::MOT_Participant:
    simToMap = std::bind(&AdapterDds::simId2UniqueMapIdParticipant, this, _1);
    break;
  case MapObjectType::MOT_TrainingArea:
    simToMap = std::bind(&AdapterDds::simId2UniqueMapIdTrainingArea, this, _1);
    break;
  case MapObjectType::MOT_ShootbackArea:
    simToMap = std::bind(&AdapterDds::simId2UniqueMapIdShootbackArea, this, _1);
    break;
  case MapObjectType::MOT_Building:
    simToMap = std::bind(&AdapterDds::simId2UniqueMapIdBuilding, this, _1);
    break;
  case MapObjectType::MOT_Bridge:
    simToMap = std::bind(&AdapterDds::simId2UniqueMapIdBridge, this, _1);
    break;

  case MapObjectType::MOT_Aes:
  case MapObjectType::MOT_GuezIed:
  {
    ERROR_LOG(m_logger) << " not supported yet!!!";
    Q_FALLTHROUGH();
  }
  default:
    break;
  } //switch

  for (auto simId : qAsConst(simIds))
  {
    UniqueMapId uniqueMapId = simToMap(simId);
    if (!isUniqueMapIdValid(uniqueMapId))
      continue;
    uniqueMapIds.push_back(uniqueMapId);
  } // for

  return uniqueMapIds;
}

RefPointer<AbstractMapObject> AdapterDds::simId2MapObject(MapObjectType mot, int32_t simId)
{
  UniqueMapId uniqueMapId = simId2UniqueMapId(mot, simId);
  if (!isUniqueMapIdValid(uniqueMapId))
    return {};

  RefPointer<AbstractMapObject> mapObj = m_map->objectFactory().get(uniqueMapId);
  TRACE_LOG(m_logger) << LOGFUNCTION << " END" ;
  return mapObj;
}

Sim2SituationMapBase *AdapterDds::situationMapBase(MapObjectType mot) const
{
  Sim2SituationMapBase *smBase = nullptr;

  switch (mot)
  {
  case MapObjectType::MOT_Participant:
    smBase = m_particpants.data();
    break;
  case MapObjectType::MOT_TrainingArea:
    smBase = m_trainingAreas.data();
    break;
  case MapObjectType::MOT_SpecialArea:
    smBase = m_specialAreas.data();
    break;
  case MapObjectType::MOT_ShootbackArea:
    smBase = m_shootbackAreas.data();
    break;
  case MapObjectType::MOT_Aes:
  case MapObjectType::MOT_Building:
  case MapObjectType::MOT_GuezIed:
  {
    ERROR_LOG(m_logger) << " not supported yet!!!";
    Q_FALLTHROUGH();
  }
  default:
    break;
  } //switch

  return smBase;
}

bool AdapterDds::setMapObjectSelected(MapObjectType mot, const QVector<int> &entityIds, bool selection)
{
  Sim2SituationMapBase *smBase = situationMapBase(mot);
  if (!smBase)
    return false;

  const QVector<UniqueMapId> &uniqueMapIds = simIds2UniqueMapIds(mot, entityIds);

  auto cb = [uniqueMapIds, selection](RefPointer<AbstractMapObject> &abstractMapObj)
  {
    // if (mapObj.valid()) return;  // already checked at iterateObjects<MAP_T> :-)

    if (!uniqueMapIds.contains(abstractMapObj->uniqueMapId()))
      return;     // not requested

    if (abstractMapObj->selected() == selection)
      return;     // noting to do

    abstractMapObj->setSelected(selection);
    abstractMapObj->updateView();
  };
  smBase->iterateObjects<AbstractMapObject>(cb);

  return true;
}

bool AdapterDds::clearMapObjectSelection(MapObjectType mot)
{
  Sim2SituationMapBase *smBase = situationMapBase(mot);
  if (!smBase)
    return false;

  auto cb = [](RefPointer<AbstractMapObject> &abstractMapObj)
  {
    // if (mapObj.valid()) return;  // already checked at iterateObjects<MAP_T> :-)

    if (!abstractMapObj->selected())
      return;     // noting to do

    abstractMapObj->setSelected(false);
    abstractMapObj->updateView();
  };
  smBase->iterateObjects<AbstractMapObject>(cb);

  return true;
}


bool AdapterDds::isBuildingOwnershipSupported() const
{
  return m_buildingOwnership;
}
bool AdapterDds::isBuildingOwnershipVisible() const
{
  if (!m_buildingOwnership)
    return false;
  return m_buildingOwnership->isVisible();
}
bool AdapterDds::setBuildingOwnershipVisible(bool visible)
{
  if (!m_buildingOwnership)
    return false;

  if(visible && isBuildingContaminationVisible())
    m_buildingContamination->setVisible(false);
  return m_buildingOwnership->setVisible(visible);
}

bool AdapterDds::isBuildingContaminationSupported() const
{
  return m_buildingContamination;
}
bool AdapterDds::isBuildingContaminationVisible() const
{
  if (!m_buildingContamination)
    return false;
  return m_buildingContamination->isVisible();
}
bool AdapterDds::setBuildingContaminationVisible(bool visible)
{
  if (!m_buildingContamination)
    return false;
  if(visible && isBuildingOwnershipVisible())
    m_buildingOwnership->setVisible(false);
  return m_buildingContamination->setVisible(visible);
}


bool AdapterDds::enableFireEventFlashing(bool enable)
{
  if (!m_particpants)
    return false;

  return m_particpants->enableFireEventFlashing(enable);
}

bool AdapterDds::isFireEventFlashingEnabled() const
{
  if (!m_particpants)
    return false;
  return m_particpants->isFireEventFlashingEnabled();
}

bool AdapterDds::isOwnPositionVisible() const
{
  if(!m_map)
    return false;

  return m_map->locationDisplay().isStarted();
}

bool AdapterDds::setOwnPositionVisible(bool enable)
{
  m_isShowOwnPosition = enable;

  if(!m_map)
    return false;
  if(enable)
    m_map->locationDisplay().start();
  else
    m_map->locationDisplay().stop();

  return true;
}


void AdapterDds::onSymbolDictionaryChanged()
{
  INFO_LOG(m_logger) << LOGFUNCTION << " START, workspaceId" << m_pluginProvider->workspaceId();

  if (m_particpants)
    m_particpants->reRenderObjects();
  if (m_guezIeds)
    m_guezIeds->reRenderObjects();

  // 'FunctionalArea2SituationMap' -> process all aes2Map:
  const QList<Sim2SituationMapBase *> &aes2Map = listOfAes2Map();
  for (const auto &item : qAsConst(aes2Map))
    item->reRenderObjects();


  // not relevant:
  // m_hitlineInfo2SituationMap
  // m_bldHitlineInfo2SituationMap
  // m_buildingOwnership
  // m_guezNasat9Liner


  INFO_LOG(m_logger) << LOGFUNCTION << " END, workspaceId" << m_pluginProvider->workspaceId();
}


//-----------------------------------------------------------------------------
bool AdapterDds::onMapObjectClicked(const RefPointer<AbstractMapObject> &mapObject)
{
  if (!mapObject)
    return false;
  return onMapObjectClicked(mapObject->uniqueMapId());
}
bool AdapterDds::onMapObjectClicked(UniqueMapId uniqueMapId)
{
  if (!SituationMap::isUniqueMapIdValid(uniqueMapId))
    return false;

  return onMapObjectsClicked(QVector<UniqueMapId>() << uniqueMapId);
}

bool AdapterDds::onMapObjectsClicked(const QVector<UniqueMapId> &uniqueMapIds)
{
  // participant, buildings, mountingPoints ...
  const QList<Sim2SituationMapBase *> &sim2Map = listOfSim2Map();
  for (const auto &item : qAsConst(sim2Map))
  {
    item->mapObjectsClicked(uniqueMapIds);
  }
  return true;
}

void AdapterDds::onMapObjectChangedUpdateDrawOrder(UniqueMapId uniqueMapId)
{
  //
  // update own management (m_startTimeMap):
  //
  qint64 startTime = -1;
  for (auto it = m_aes2MapCont.cbegin(); it != m_aes2MapCont.cend(); ++it)
  {
    startTime = it.value()->startTime(uniqueMapId);
    if (startTime > 0)
      break;
  }

  if (startTime < 0)
    return;

  m_startTimeMap[uniqueMapId] = startTime;

  //
  // create drawOrder by startTime and transfer to MapObjects:
  //
  // first, swap key and value:
  QMultiMap<qint64, UniqueMapId> startTime2UniqueMapIdMap;
  for (auto it = m_startTimeMap.cbegin(); it != m_startTimeMap.cend(); ++it)
    startTime2UniqueMapIdMap.insert(it.value(), it.key());

  // second, assign drawOrder based on chronological order:
  int drawOrderCounter = 0;

  const ObjectFactory &objFac = m_map->objectFactory();
  for (auto it = startTime2UniqueMapIdMap.cbegin(); it != startTime2UniqueMapIdMap.cend(); ++it)
  {
    const UniqueMapId curUniqueMapId = it.value();
    RefPointer<AbstractMapObject> mapObj = objFac.get<AbstractMapObject>(curUniqueMapId);
    if (!mapObj)
    {
      WARNING_LOG(m_logger) << LOGFUNCTION << " not found in objFac"
                            << " curUniqueMapId = " << curUniqueMapId;
      return;
    }

    mapObj->setDrawOrder(++drawOrderCounter);
    if (!mapObj->updateView())
    {
      ERROR_LOG(m_logger) << LOGFUNCTION << " debugInfo='" << mapObj->debugInfo() << "'"
                          << " updateView failed";
    }
    INFO_LOG(m_logger) << LOGFUNCTION << " debugInfo='" << mapObj->debugInfo() << "'"
                       << " set DrawOder to: " << drawOrderCounter;
  } // while
}

void AdapterDds::onMapObjectRemoved(UniqueMapId uniqueMapId)
{
  //  TRACE_LOG(m_logger) << LOGFUNCTION << " START, uniqueMapId=" << uniqueMapId;
  m_startTimeMap.remove(uniqueMapId);
}
/*!
 * \brief AdapterDds::onParticipantOwnPositionChanged
 * \param newPos
 * \author Niklas Schmidt
 * \details The own position of the ComMaster Tablet will be shown as a blue dot
 */
void AdapterDds::onParticipantOwnPositionChanged(const Point3D &newPos, int64_t sampleTime)
{
  DEBUG_LOG(m_logger) << "Own Position Changed";

  if(!m_map)
    return;
  if(!m_map->locationDisplay().isStarted() && m_isShowOwnPosition == true)
  {
    m_map->locationDisplay().start();
  }

  if(sampleTime > QDateTime::currentMSecsSinceEpoch() - 30000)
  {
    m_map->locationDisplay().setCurrentLocation(newPos); // NOTE: The other  params arent available currently
    startOwnPositionOutdatedTimer();
  }
}

void AdapterDds::startChangedDelayTimer()
{
  if (!m_map || !m_map->symbolDictionary().isLoaded())
    return;

  // connect to SymbolDictionary::changed to  trigger reRendering of (XML) symbols.
  // (SymbolDictionary::changedDelayed does not fit: It´s emitted 500ms after
  // mapReadyAndDictionaryLoaded in normal startup WITHOUT changes...)
  if (!m_changedDelayTimer)
  {
    m_changedDelayTimer = new QTimer(this);
    m_changedDelayTimer->setSingleShot(true);
    m_changedDelayTimer->setInterval(500);
    connect(m_changedDelayTimer, &QTimer::timeout, this, &AdapterDds::onSymbolDictionaryChanged);
  }
  m_changedDelayTimer->start();  // is restart timer if already running
}

void AdapterDds::startOwnPositionOutdatedTimer()
{
  if (!m_ownPositionOutdatedTimer)
  {
    m_ownPositionOutdatedTimer = new QTimer(this);
    m_ownPositionOutdatedTimer->setSingleShot(true);
    m_ownPositionOutdatedTimer->setInterval(10000);
    connect(m_ownPositionOutdatedTimer, &QTimer::timeout, this, [this](){
      if(m_map)
        m_map->locationDisplay().setOutdated(true);
    });
  }
  m_ownPositionOutdatedTimer->start();  // is restart timer if already running
}

//-----------------------------------------------------------------------------
QList<Sim2SituationMapBase *> AdapterDds::listOfSim2Map() const
{
  QList<Sim2SituationMapBase *> cont;

  // Participants:
  if (m_particpants)
    cont += m_particpants.data();

  // AES:
  cont += m_aes2MapCont.values();

  // GIM
  if (m_guezIeds)
    cont += m_guezIeds.data();

  // GNA
  if (m_guezNasat9Liner)
    cont += m_guezNasat9Liner.data();

  // ISM:
  if (m_mountingPoints)
    cont.append(m_mountingPoints.data());
  if (m_soundAreas)
    cont.append(m_soundAreas.data());
  if (m_buildings)
    cont.append(m_buildings.data());
  if (m_msePoints)
    cont.append(m_msePoints.data());
  if (m_mseBridges)
    cont.append(m_mseBridges.data());


  // ASM
  if (m_trainingAreas)
    cont.append(m_trainingAreas.data());

  // ISM
  if (m_specialAreas)
    cont.append(m_specialAreas.data());

  // ignore for now:
  //  // Alarm
  if (m_emergencyCalls)
    cont.append(m_emergencyCalls.data());

  if (m_chargeEffects)
    cont.append(m_chargeEffects.data());

  // ignore for now:
  //  // BuildingOwnership ->
  //  if (m_buildingOwnership)
  //    cont.append(m_buildingOwnership.data());
  // : ignore

  if (m_hitlineInfo2SituationMap)
    cont.append(m_hitlineInfo2SituationMap.data());

  if (m_bldHitlineInfo2SituationMap)
    cont.append(m_bldHitlineInfo2SituationMap.data());

  if (m_shootbackAreas)
    cont.append(m_shootbackAreas.data());

  return cont;
}

QList<Sim2SituationMapBase *> AdapterDds::listOfAes2Map() const
{
  return m_aes2MapCont.values();
}

}