refs #395, signatures for max.aircraft and max.range

(!) This in an intermediate step, the feature is not yet fully operational

* max distance for rendering as simulator property
* set max distance / aircraft from GUI

As result of the latest meeting
* changed CCallsignList to CCollection
* fixed some warning with elevated compiler settings (e.g. removed qint values -> int)

src/blackcore/context_simulator.cpp

@@ -47,4 +47,5 @@ namespace BlackCore
             return nullptr; // simulator not mandatory
         }
     }
+
 } // namespace

src/blackcore/context_simulator.h

@@ -74,6 +74,9 @@ namespace BlackCore
         //! Simulator combined status
         void simulatorStatusChanged(bool connected, bool running, bool paused);
 
+        //! Only a limited number of aircraft displayed
+        void restrictedRenderingChanged(bool restricted);
+
         //! Installed aircraft models ready or changed
         void installedAircraftModelsChanged();
 
@@ -138,8 +141,26 @@ namespace BlackCore
         //! Max. number of remote aircraft rendered
         virtual int getMaxRenderedAircraft() const = 0;
 
-        //! Max. number of remote aircraft rendered and provide optional selection which aircraft this are
-        virtual void setMaxRenderedAircraft(int number, const BlackMisc::Aviation::CCallsignList &renderedAircraft) = 0;
+        //! Max. rendered distance
+        virtual BlackMisc::PhysicalQuantities::CLength getMaxRenderedDistance() const = 0;
+
+        //! Technical range until aircraft are visible
+        virtual BlackMisc::PhysicalQuantities::CLength getRenderedDistanceBoundary() const = 0;
+
+        //! Text describing the rendering restrictions
+        virtual QString getRenderRestrictionText() const = 0;
+
+        //! Max. number of remote aircraft rendered and provide optional selection which aircraft those are
+        virtual void setMaxRenderedAircraft(int number) = 0;
+
+        //! Max. distance until we render an aircraft
+        virtual void setMaxRenderedDistance(BlackMisc::PhysicalQuantities::CLength &distance) = 0;
+
+        //! Delete all restrictions (if any) -> unlimited number of aircraft
+        virtual void deleteAllRenderingRestrictions() = 0;
+
+        //! Is number of aircraft restricted
+        virtual bool isRenderingRestricted() const = 0;
 
         //! Time synchronization offset
         virtual BlackMisc::PhysicalQuantities::CTime getTimeSynchronizationOffset() const = 0;

src/blackcore/context_simulator_impl.cpp

@@ -171,20 +171,71 @@ namespace BlackCore
 
     int CContextSimulator::getMaxRenderedAircraft() const
     {
-        CLogMessage(this, CLogCategory::contextSlot()).debug() << Q_FUNC_INFO;
+        if (m_debugEnabled) {CLogMessage(this, CLogCategory::contextSlot()).debug() << Q_FUNC_INFO; }
         if (!m_simulator) return 0;
         return m_simulator->getMaxRenderedAircraft();
     }
 
-    void CContextSimulator::setMaxRenderedAircraft(int number, const CCallsignList &renderedAircraft)
+    void CContextSimulator::setMaxRenderedAircraft(int number)
     {
-        CLogMessage(this, CLogCategory::contextSlot()).debug() << Q_FUNC_INFO;
-        if (m_simulator) { this->m_simulator->setMaxRenderedAircraft(number, renderedAircraft); }
+        if (m_debugEnabled) { CLogMessage(this, CLogCategory::contextSlot()).debug() << Q_FUNC_INFO << number; }
+        if (m_simulator) { this->m_simulator->setMaxRenderedAircraft(number); }
+    }
+
+    void CContextSimulator::setMaxRenderedDistance(CLength &distance)
+    {
+        if (m_debugEnabled) { CLogMessage(this, CLogCategory::contextSlot()).debug() << Q_FUNC_INFO << distance; }
+        if (m_simulator) { this->m_simulator->setMaxRenderedDistance(distance); }
+    }
+
+    QString CContextSimulator::getRenderRestrictionText() const
+    {
+        if (m_debugEnabled) { CLogMessage(this, CLogCategory::contextSlot()).debug() << Q_FUNC_INFO; }
+        if (!m_simulator) { return ""; }
+        if (!m_simulator->isRenderingRestricted()) { return "none"; }
+        QString rt;
+        if (m_simulator->isMaxAircraftRestricted())
+        {
+            rt.append(QString::number(m_simulator->getMaxRenderedAircraft())).append(" A/C");
+        }
+        if (m_simulator->isMaxDistanceRestricted())
+        {
+            if (!rt.isEmpty()) { rt.append(" ");}
+            rt.append(m_simulator->getMaxRenderedDistance().valueRoundedWithUnit(CLengthUnit::NM(), 0));
+        }
+        return rt;
+    }
+
+    CLength CContextSimulator::getMaxRenderedDistance() const
+    {
+        if (m_debugEnabled) { CLogMessage(this, CLogCategory::contextSlot()).debug() << Q_FUNC_INFO; }
+        if (m_simulator) { return this->m_simulator->getMaxRenderedDistance(); }
+        return CLength(0, CLengthUnit::nullUnit());
+    }
+
+    CLength CContextSimulator::getRenderedDistanceBoundary() const
+    {
+        if (m_debugEnabled) { CLogMessage(this, CLogCategory::contextSlot()).debug() << Q_FUNC_INFO; }
+        if (m_simulator) { return this->m_simulator->getRenderedDistanceBoundary(); }
+        return CLength(20.0, CLengthUnit::NM());
+    }
+
+    void CContextSimulator::deleteAllRenderingRestrictions()
+    {
+        if (m_debugEnabled) { CLogMessage(this, CLogCategory::contextSlot()).debug() << Q_FUNC_INFO; }
+        if (m_simulator) { this->m_simulator->deleteAllRenderingRestrictions(); }
+    }
+
+    bool CContextSimulator::isRenderingRestricted() const
+    {
+        if (m_debugEnabled) { CLogMessage(this, CLogCategory::contextSlot()).debug() << Q_FUNC_INFO; }
+        if (m_simulator) { return this->m_simulator->isRenderingRestricted(); }
+        return false;
     }
 
     CTime CContextSimulator::getTimeSynchronizationOffset() const
     {
-        CLogMessage(this, CLogCategory::contextSlot()).debug() << Q_FUNC_INFO;
+        if (m_debugEnabled) { CLogMessage(this, CLogCategory::contextSlot()).debug() << Q_FUNC_INFO; }
         if (!m_simulator) return CTime(0, CTimeUnit::hrmin());
         return this->m_simulator->getTimeSynchronizationOffset();
     }
@@ -237,6 +288,7 @@ namespace BlackCore
         connect(m_simulator, &ISimulator::ownAircraftModelChanged, this, &IContextSimulator::ownAircraftModelChanged);
         connect(m_simulator, &ISimulator::modelMatchingCompleted, this, &IContextSimulator::modelMatchingCompleted);
         connect(m_simulator, &ISimulator::installedAircraftModelsChanged, this, &IContextSimulator::installedAircraftModelsChanged);
+        connect(m_simulator, &ISimulator::restrictedRenderingChanged, this, &IContextSimulator::restrictedRenderingChanged);
 
         // log from context to simulator
         connect(CLogHandler::instance(), &CLogHandler::localMessageLogged, m_simulator, &ISimulator::displayStatusMessage);

src/blackcore/context_simulator_impl.h

@@ -96,7 +96,25 @@ namespace BlackCore
         virtual int getMaxRenderedAircraft() const override;
 
         //! \copydoc IContextSimulator::setMaxRenderedAircraft
-        virtual void setMaxRenderedAircraft(int number, const BlackMisc::Aviation::CCallsignList &renderedAircraft) override;
+        virtual void setMaxRenderedAircraft(int number) override;
+
+        //! \copydoc IContextSimulator::setMaxRenderedDistance
+        virtual void setMaxRenderedDistance(BlackMisc::PhysicalQuantities::CLength &distance) override;
+
+        //! \copydoc IContextSimulator::getRenderRestrictionText
+        virtual QString getRenderRestrictionText() const override;
+
+        //! \copydoc IContextSimulator::getMaxRenderedDistance
+        virtual BlackMisc::PhysicalQuantities::CLength getMaxRenderedDistance() const override;
+
+        //! \copydoc IContextSimulator::getRenderedDistanceBoundary
+        virtual BlackMisc::PhysicalQuantities::CLength getRenderedDistanceBoundary() const override;
+
+        //! \copydoc IContextSimulator::setMaxRenderedDistance
+        virtual void deleteAllRenderingRestrictions() override;
+
+        //! \copydoc IContextSimulator::isRenderingRestricted
+        virtual bool isRenderingRestricted() const override;
 
         //! \copydoc IContextSimulator::getTimeSynchronizationOffset
         virtual BlackMisc::PhysicalQuantities::CTime getTimeSynchronizationOffset() const override;

src/blackcore/context_simulator_proxy.cpp

@@ -51,6 +51,9 @@ namespace BlackCore
         s = connection.connect(serviceName, IContextSimulator::ObjectPath(), IContextSimulator::InterfaceName(),
                                "modelMatchingCompleted", this, SIGNAL(modelMatchingCompleted(BlackMisc::Simulation::CSimulatedAircraft)));
         Q_ASSERT(s);
+        s = connection.connect(serviceName, IContextSimulator::ObjectPath(), IContextSimulator::InterfaceName(),
+                               "restrictedRenderingChanged", this, SIGNAL(restrictedRenderingChanged(bool)));
+        Q_ASSERT(s);
         Q_UNUSED(s);
     }
 
@@ -129,9 +132,39 @@ namespace BlackCore
         return m_dBusInterface->callDBusRet<bool>(QLatin1Literal("isTimeSynchronized"));
     }
 
-    void CContextSimulatorProxy::setMaxRenderedAircraft(int number, const CCallsignList &renderedAircraft)
+    void CContextSimulatorProxy::setMaxRenderedAircraft(int number)
     {
-        m_dBusInterface->callDBus(QLatin1Literal("setMaxRenderedRemoteAircraft"), number, renderedAircraft);
+        m_dBusInterface->callDBus(QLatin1Literal("setMaxRenderedAircraft"), number);
+    }
+
+    void CContextSimulatorProxy::setMaxRenderedDistance(CLength &distance)
+    {
+        m_dBusInterface->callDBus(QLatin1Literal("setMaxRenderedDistance"), distance);
+    }
+
+    void CContextSimulatorProxy::deleteAllRenderingRestrictions()
+    {
+        m_dBusInterface->callDBus(QLatin1Literal("deleteAllRenderingRestrictions"));
+    }
+
+    bool CContextSimulatorProxy::isRenderingRestricted() const
+    {
+        return m_dBusInterface->callDBusRet<bool>(QLatin1Literal("isRenderingRestricted"));
+    }
+
+    CLength CContextSimulatorProxy::getMaxRenderedDistance() const
+    {
+        return m_dBusInterface->callDBusRet<CLength>(QLatin1Literal("getMaxRenderedDistance"));
+    }
+
+    CLength CContextSimulatorProxy::getRenderedDistanceBoundary() const
+    {
+        return m_dBusInterface->callDBusRet<CLength>(QLatin1Literal("getRenderedDistanceBoundary"));
+    }
+
+    QString CContextSimulatorProxy::getRenderRestrictionText() const
+    {
+        return m_dBusInterface->callDBusRet<QString>(QLatin1Literal("getRenderRestrictionText"));
     }
 
     int CContextSimulatorProxy::getMaxRenderedAircraft() const

src/blackcore/context_simulator_proxy.h

@@ -99,7 +99,25 @@ namespace BlackCore
         virtual int getMaxRenderedAircraft() const override;
 
         //! \copydoc IContextSimulator::setMaxRenderedRemoteAircraft
-        virtual void setMaxRenderedAircraft(int number, const BlackMisc::Aviation::CCallsignList &renderedAircraft) override;
+        virtual void setMaxRenderedAircraft(int number) override;
+
+        //! \copydoc IContextSimulator::setMaxRenderedDistance
+        virtual void setMaxRenderedDistance(BlackMisc::PhysicalQuantities::CLength &distance);
+
+        //! \copydoc IContextSimulator::setMaxRenderedDistance
+        virtual void deleteAllRenderingRestrictions() override;
+
+        //! \copydoc IContextSimulator::isRenderingRestricted
+        virtual bool isRenderingRestricted() const override;
+
+        //! \copydoc IContextSimulator::getMaxRenderedDistance
+        virtual BlackMisc::PhysicalQuantities::CLength getMaxRenderedDistance() const override;
+
+        //! \copydoc IContextSimulator::getRenderedDistanceBoundary
+        virtual BlackMisc::PhysicalQuantities::CLength getRenderedDistanceBoundary() const override;
+
+        //! \copydoc IContextSimulator::getRenderRestrictionText
+        virtual QString getRenderRestrictionText() const override;
 
         //! \copydoc IContextSimulator::getTimeSynchronizationOffset
         virtual BlackMisc::PhysicalQuantities::CTime getTimeSynchronizationOffset() const override;

src/blackcore/simulator.cpp

@@ -9,7 +9,9 @@
 
 #include "simulator.h"
 #include "interpolator.h"
+#include "blackmisc/collection.h"
 
+using namespace BlackMisc;
 using namespace BlackMisc::Aviation;
 using namespace BlackMisc::Simulation;
 using namespace BlackMisc::PhysicalQuantities;
@@ -23,7 +25,9 @@ namespace BlackCore
     }
 
     CSimulatorCommon::CSimulatorCommon(const BlackSim::CSimulatorInfo &simInfo, BlackMisc::Simulation::IOwnAircraftProvider *ownAircraftProvider, BlackMisc::Simulation::IRemoteAircraftProvider *remoteAircraftProvider, QObject *parent)
-        : ISimulator(parent), COwnAircraftProviderSupport(ownAircraftProvider), CRemoteAircraftProviderSupport(remoteAircraftProvider), m_simulatorInfo(simInfo)
+        : ISimulator(parent),
+          COwnAircraftProviderSupport(ownAircraftProvider),
+          CRemoteAircraftProviderSupport(remoteAircraftProvider), m_simulatorInfo(simInfo)
     {
         m_oneSecondTimer = new QTimer(this);
         connect(this->m_oneSecondTimer, &QTimer::timeout, this, &CSimulatorCommon::ps_oneSecondTimer);
@@ -65,6 +69,27 @@ namespace BlackCore
         }
     }
 
+    void CSimulatorCommon::recalculateRestrictedAircraft()
+    {
+        if (!isMaxAircraftRestricted()) { return; }
+        if (!isRenderingEnabled()) { return; }
+
+        //! \todo Simulator, why is there no difference on CSequence?
+        CSimulatedAircraftList newAircraftInRange(remoteAircraft().getClosestObjects(getMaxRenderedAircraft()));
+        CCallsignList newAircraftCallsigns(newAircraftInRange.getCallsigns());
+        CCallsignList toBeRemovedCallsigns(m_callsignsToBeRendered.difference(newAircraftCallsigns));
+        CCallsignList toBeAddedCallsigns(newAircraftCallsigns.difference(m_callsignsToBeRendered));
+        for (const CCallsign &cs : toBeRemovedCallsigns)
+        {
+            removeRemoteAircraft(cs);
+        }
+        for (const CCallsign &cs : toBeAddedCallsigns)
+        {
+            addRemoteAircraft(newAircraftInRange.findFirstByCallsign(cs));
+        }
+        this->m_callsignsToBeRendered = newAircraftCallsigns;
+    }
+
     void CSimulatorCommon::resetAircraftFromBacked(const CCallsign &callsign)
     {
         CSimulatedAircraft aircraft(this->remoteAircraft().findFirstByCallsign(callsign));
@@ -101,13 +126,65 @@ namespace BlackCore
 
     int CSimulatorCommon::getMaxRenderedAircraft() const
     {
-        return m_maxRenderedAircraft;
+        return (m_maxRenderedAircraft <= MaxAircraftInfinite) ? m_maxRenderedAircraft : MaxAircraftInfinite;
     }
 
-    void CSimulatorCommon::setMaxRenderedAircraft(int maxRenderedAircraft, const BlackMisc::Aviation::CCallsignList &callsigns)
+    void CSimulatorCommon::setMaxRenderedAircraft(int maxRenderedAircraft)
     {
-        m_maxRenderedAircraft = maxRenderedAircraft;
-        m_callsignsToBeRendered = callsigns;
+        if (maxRenderedAircraft == m_maxRenderedAircraft) { return; }
+        if (maxRenderedAircraft < 1)
+        {
+            m_maxRenderedAircraft = 0;
+        }
+        else if (maxRenderedAircraft >= MaxAircraftInfinite)
+        {
+            m_maxRenderedAircraft = MaxAircraftInfinite;
+        }
+        else
+        {
+            m_maxRenderedAircraft = maxRenderedAircraft;
+        }
+
+        bool r = isRenderingRestricted();
+        emit restrictedRenderingChanged(r);
+    }
+
+    void CSimulatorCommon::setMaxRenderedDistance(CLength &distance)
+    {
+        if (distance == m_maxRenderedDistance) { return; }
+        if (distance.isNull() || distance >= getRenderedDistanceBoundary())
+        {
+            m_maxRenderedDistance = CLength(0.0, CLengthUnit::nullUnit());
+        }
+        else
+        {
+            Q_ASSERT(distance.isPositiveWithEpsilonConsidered());
+            m_maxRenderedDistance = distance;
+        }
+
+        bool r = isRenderingRestricted();
+        emit restrictedRenderingChanged(r);
+    }
+
+    CLength CSimulatorCommon::getMaxRenderedDistance() const
+    {
+        if (m_maxRenderedDistance.isNull()) { return getRenderedDistanceBoundary(); }
+        return m_maxRenderedDistance;
+    }
+
+    CLength CSimulatorCommon::getRenderedDistanceBoundary() const
+    {
+        return CLength(20.0, CLengthUnit::NM());
+    }
+
+    bool CSimulatorCommon::isMaxAircraftRestricted() const
+    {
+        return m_maxRenderedAircraft < MaxAircraftInfinite && isRenderingEnabled();
+    }
+
+    bool CSimulatorCommon::isMaxDistanceRestricted() const
+    {
+        return !m_maxRenderedDistance.isNull();
     }
 
     CSimulatorInfo CSimulatorCommon::getSimulatorInfo() const
@@ -140,12 +217,35 @@ namespace BlackCore
 
     bool CSimulatorCommon::isRenderingEnabled() const
     {
-        return m_maxRenderedAircraft < 1;
+        if (m_maxRenderedAircraft < 1)  { return false; }
+        if (!isMaxDistanceRestricted()) { return true; }
+
+        return m_maxRenderedDistance.valueRounded(CLengthUnit::NM(), 2) > 0.1;
+    }
+
+    bool CSimulatorCommon::isRenderingRestricted() const
+    {
+        return this->isMaxDistanceRestricted() || this->isMaxAircraftRestricted();
+    }
+
+    void CSimulatorCommon::deleteAllRenderingRestrictions()
+    {
+        if (!isRenderingEnabled()) { return; }
+        this->m_maxRenderedDistance = CLength(0, CLengthUnit::nullUnit());
+        this->m_maxRenderedAircraft = MaxAircraftInfinite;
+        emit restrictedRenderingChanged(false);
     }
 
     void CSimulatorCommon::ps_oneSecondTimer()
     {
+        m_timerCounter++;
         blinkHighlightedAircraft();
+
+        // any <n> seconds
+        if (m_timerCounter % 10 == 0)
+        {
+            recalculateRestrictedAircraft();
+        }
     }
 
 } // namespace

src/blackcore/simulator.h

@@ -43,6 +43,9 @@ namespace BlackCore
             ConnectionFailed
         };
 
+        //! Render all aircraft
+        const int MaxAircraftInfinite = 100;
+
         //! Destructor
         virtual ~ISimulator() {}
 
@@ -70,7 +73,7 @@ namespace BlackCore
             return o;
         }
 
-    public slots:
+    public:
 
         //! Connect to simulator
         virtual bool connectTo() = 0;
@@ -138,7 +141,28 @@ namespace BlackCore
         virtual int getMaxRenderedAircraft() const = 0;
 
         //! Max. rendered aircraft
-        virtual void setMaxRenderedAircraft(int maxRenderedAircraft, const BlackMisc::Aviation::CCallsignList &callsigns) = 0;
+        virtual void setMaxRenderedAircraft(int maxRenderedAircraft) = 0;
+
+        //! Max. distance for rendered aircraft
+        virtual void setMaxRenderedDistance(BlackMisc::PhysicalQuantities::CLength &distance) = 0;
+
+        //! Max. distance for rendered aircraft
+        virtual BlackMisc::PhysicalQuantities::CLength getMaxRenderedDistance() const = 0;
+
+        //! Technical range until aircraft are visible
+        virtual BlackMisc::PhysicalQuantities::CLength getRenderedDistanceBoundary() const = 0;
+
+        //! Restricted number of aircraft
+        virtual bool isMaxAircraftRestricted() const = 0;
+
+        //! Restriced distance
+        virtual bool isMaxDistanceRestricted() const = 0;
+
+        //! Is there a restriction? No rendering -> limited number of aircraft -> unlimited number of aircraft
+        virtual bool isRenderingRestricted() const = 0;
+
+        //! Delete all restrictions (if any) -> unlimited number of aircraft
+        virtual void deleteAllRenderingRestrictions() = 0;
 
         //! Enable debugging messages
         virtual void enableDebugMessages(bool driver, bool interpolator) = 0;
@@ -162,6 +186,9 @@ namespace BlackCore
         //! Simulator combined status
         void simulatorStatusChanged(bool connected, bool running, bool paused);
 
+        //! Only a limited number of aircraft displayed
+        void restrictedRenderingChanged(bool restricted);
+
         //! Simulator started
         void simulatorStarted();
 
@@ -217,13 +244,27 @@ namespace BlackCore
 
         Q_OBJECT
 
-    public slots:
-
+    public:
         //! \copydoc ISimulator::getMaxRenderedAircraft
         virtual int getMaxRenderedAircraft() const override;
 
         //! \copydoc ISimulator::setMaxRenderedAircraft
-        virtual void setMaxRenderedAircraft(int maxRenderedAircraft, const BlackMisc::Aviation::CCallsignList &callsigns) override;
+        virtual void setMaxRenderedAircraft(int maxRenderedAircraft) override;
+
+        //! \copydoc ISimulator::setMaxRenderedDistance
+        virtual void setMaxRenderedDistance(BlackMisc::PhysicalQuantities::CLength &distance) override;
+
+        //! \copydoc ISimulator::getMaxRenderedDistance
+        virtual BlackMisc::PhysicalQuantities::CLength getMaxRenderedDistance() const override;
+
+        //! \copydoc ISimulator::getRenderedDistanceBoundary
+        virtual BlackMisc::PhysicalQuantities::CLength getRenderedDistanceBoundary() const override;
+
+        //! \copydoc ISimulator::isMaxAircraftRestricted
+        virtual bool isMaxAircraftRestricted() const override;
+
+        //! \copydoc ISimulator::isMaxDistanceRestricted
+        virtual bool isMaxDistanceRestricted() const override;
 
         //! \copydoc ISimulator::getSimulatorInfo
         virtual BlackSim::CSimulatorInfo getSimulatorInfo() const override;
@@ -240,6 +281,12 @@ namespace BlackCore
         //! \copydoc IContextSimulator::isRenderingEnabled
         virtual bool isRenderingEnabled() const override;
 
+        //! \copydoc IContextSimulator::isRenderingRestricted
+        virtual bool isRenderingRestricted() const override;
+
+        //! \copydoc IContextSimulator::deleteAllRenderingRestrictions
+        virtual void deleteAllRenderingRestrictions();
+
     protected slots:
         //! Slow timer used to highlight aircraft, can be used for other things too
         virtual void ps_oneSecondTimer();
@@ -256,6 +303,9 @@ namespace BlackCore
         //! Blink the highlighted aircraft
         void blinkHighlightedAircraft();
 
+        //! Recalculate the restricted aircraft
+        void recalculateRestrictedAircraft();
+
         //! Restore aircraft from backedn data
         void resetAircraftFromBacked(const BlackMisc::Aviation::CCallsign &callsign);
 
@@ -263,15 +313,16 @@ namespace BlackCore
         void setInitialAircraftSituationAndParts(BlackMisc::Simulation::CSimulatedAircraft &aircraft) const;
 
         BlackSim::CSimulatorInfo m_simulatorInfo; //!< about the simulator
-        int m_maxRenderedAircraft = 90;           //!< max. rendered aircraft
         bool m_debugMessages = false;             //!< Display debug messages
         bool m_blinkCycle = false;                //!< use for highlighting
         IInterpolator *m_interpolator = nullptr;  //!< interpolator instance
         qint64 m_highlightEndTimeMsEpoch = 0;     //!< end highlighting
+        int m_timerCounter = 0;                   //!< allows to calculate n seconds
+        QTimer *m_oneSecondTimer = nullptr;       //!< timer
         BlackMisc::Simulation::CSimulatedAircraftList m_highlightedAircraft; //!< all other aircraft are to be ignored
         BlackMisc::Aviation::CCallsignList m_callsignsToBeRendered;          //!< callsigns which will be rendered
-        QTimer *m_oneSecondTimer = nullptr;       //!< timer
-
+        int m_maxRenderedAircraft = MaxAircraftInfinite;                     //!< max.rendered aircraft
+        BlackMisc::PhysicalQuantities::CLength m_maxRenderedDistance { 0.0, BlackMisc::PhysicalQuantities::CLengthUnit::nullUnit()}; //!< max.distance for rendering
     };
 
 } // namespace