Unit Status Widget Logic

The class DtUnitStatusLogic class is repsonsible for displaying information about the currently selected entity

---

Header file:

/*******************************************************************************
** Copyright (c) 2024 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
 
//\file DtUnitStatusLogic.h 
//\brief Contains makVrfUnitStatusExample::DtUnitStatusLogic class. 

#include <vrvCore/DtSelectionManager.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrfGuiCore/guiSimObject.h>

#include <vrfGuiCore/entityMapperKey.h>
#include "circleVisualHandler.h"

#include <boost/signals2.hpp>

namespace makVrv
{
   class DtDe;
   class DtWindowEllipseAgent;
}

namespace makVrfUnitStatusExample
{
   class DtUnitStatusInterface;
   class CircleVisualHandler;

   class DtUnitStatusLogic
   {

   public: 
      //\brief Constructor (protected - use ::create() )
      DtUnitStatusLogic(makVrv::DtDe& de, DtUnitStatusInterface* iFace );

      //\brief virtual DTOR
      virtual ~DtUnitStatusLogic();

   protected:
      virtual void slot_onCurrentSelectionChanged(
         const makVrv::DtSelectionManager::IdSet& selected,
         const makVrv::DtSelectionManager::IdSet& deselected);

      virtual void slot_onStateViewUpdated(makVrf::DtSimObjectReference s);
      virtual bool isDestroyed(makVrf::DtSimObjectReference s) const;

      virtual void updateLocation(const DtVector&);
      virtual void updateVelocity(const DtVector& v);
      virtual void updateAcceleration(const DtVector& a);
      virtual void updateOrientation(const DtTaitBryan& o);
      virtual void updateMarkingText(makVrf::DtSimObjectReference s);
      virtual CircleVisualHandler * createCircleVisualizer();

      virtual void displayUnitSettingsChanged();

   protected:
      makVrv::DtDe& myDe;
      DtUnitStatusInterface*  myInterface;
      makVrf::DtSimObjectReference     mySimEntry;
      makVrf::DtEntityMapperKey       myKey;
      bool                    myIsDestroyed;
      CircleVisualHandler *   myCircleVisualizer;
      makVrv::DtSignalConnectionManager myConnections;
      boost::signals2::connection myUpdateConnection;
   };
}

---

Implementation:

/*******************************************************************************
** Copyright (c) 2011 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
 
//\file DtUnitStatusLogic.cxx
//\brief Contains DtUnitStatusLogic class. 

#include "DtUnitStatusLogic.h"
#include "DtUnitStatusInterface.h"
#include "circleVisualHandler.h"

#include <vrfGuiCore/vrfDisplayUnitsSettingsManager.h>
#include <vrfGuiCore/vrfGuiSimObjectManager.h>
#include <vrfGuiCommonQt/vrfGuiSymbolMapper.h>
#include <vrfStateData/vrfStateComponent.h>
#include <vrfStateData/entityLocationStateComponent.h>

//VR-Vantage includes
#include <vrvCore/DtSharedSettingsManager.h>
#include <vrvCore/DtDeSharedState.h>
#include <vrvCore/DtDisplayUnitsSettingsSignaler.h>
#include <vrvUtil/DtCoordinateSystem.h>
#include <vrvCore/DtWindowEllipseAgent.hpp>
#include <vrvCore/DtDriverManager.h>
#include <vrvCore/DtInputDriver.h>
#include <vrvCore/DtChannel.h>
#include <vrvCore/DtBaseConnection.h>
#include <vrvCore/DtAgentManager.h>

//VR-Link includes
#include <vlpi/appearance.h>
#include <vlpi/entityType.h>

//Qt includes
#include <QtGui/QPixmap>

//std includes
#include <stdio.h>

using namespace makVrv;
using namespace makVrf;

namespace makVrfUnitStatusExample
{
   DtUnitStatusLogic::DtUnitStatusLogic(DtDe& de, DtUnitStatusInterface* iFace )
   : myDe(de)
   , myInterface(iFace)
   , mySimEntry(0)
   , myIsDestroyed(false)
   , myCircleVisualizer(0)
   {
      myConnections += DtSelectionManager::instance(de).signal_currentSelectionChanged.connect(boost::bind(
         &DtUnitStatusLogic::slot_onCurrentSelectionChanged, this, boost::placeholders::_1, boost::placeholders::_2));
      DtDisplayUnitsSettingsSignaler& signaler = 
         DtDisplayUnitsSettingsSignaler::instance(myDe.mainEventQueue());
      myConnections += signaler.signal_displayUnitChanged.connect(
         boost::bind(&DtUnitStatusLogic::displayUnitSettingsChanged, this));
      myConnections += signaler.signal_displayUnitDecimalsChanged.connect(
         boost::bind(&DtUnitStatusLogic::displayUnitSettingsChanged, this));
   }

   DtUnitStatusLogic::~DtUnitStatusLogic()
   {
      if ( myCircleVisualizer )
      {
         delete myCircleVisualizer;
         myCircleVisualizer = 0;
      }

      myUpdateConnection.disconnect();
   }

   void DtUnitStatusLogic::slot_onCurrentSelectionChanged(
      const DtSelectionManager::IdSet& selected,
      const DtSelectionManager::IdSet& deselected)
   {
      delete myCircleVisualizer;
      myCircleVisualizer = 0;

      myUpdateConnection.disconnect();

      if (!selected.size())
      {
         mySimEntry.reset();
         myKey = "";
         myInterface->clear();
      }
      else
      {
         DtSelectionManager::IdSet::const_iterator iter = selected.begin();
         DtVrfGuiSimObjectManager& manager = DtVrfGuiSimObjectManager::instance(myDe);

         DtUniqueID id = manager.simIdFromDisplayId(*iter);
         DtSimObjectReference entry = manager.lookup(id);

         if (!entry.isValid())
         {
            myInterface->clear();
         }
         else
         {
            myKey = "";

            myUpdateConnection = entry->signal_modified.connect(boost::bind(&DtUnitStatusLogic::slot_onStateViewUpdated, this, boost::placeholders::_1));
            mySimEntry = entry;
            slot_onStateViewUpdated(entry);
         }
      }
   }

   bool DtUnitStatusLogic::isDestroyed(DtSimObjectReference s) const
   {
      return s->isDestroyed();
   }

   void DtUnitStatusLogic::slot_onStateViewUpdated(DtSimObjectReference s)
   {
      if (myDe.destructing())
      {
         return;
      }

      DtEntityType type(s->entityType());
      DtEntityMapperKey key(s->forceType(), type.kind(), type.domain(), type.country(), type.category(),
         type.subCategory(), type.specific(), type.extra());
      bool destroyed = isDestroyed(s);

      if ((key.string() != myKey.string()) || (myIsDestroyed != destroyed))
      {
         myKey = key;
         myIsDestroyed = destroyed;

         QPixmap pmap = DtVrfGuiSymbolMapper::instance(myDe).getIcon(myKey, myIsDestroyed);

         myInterface->setIcon(pmap);
      }

      myInterface->setUnitName(s->objectName().c_str());

      if ( !myCircleVisualizer )
      {
         myCircleVisualizer = createCircleVisualizer();
         myCircleVisualizer->init();
      }

      updateMarkingText(s);
      updateLocation(s->worldPosition());

      if (s->hasStateComponent<DtEntityLocationStateComponent>())
      {
         const DtEntityLocationStateComponent* comp = s->getStateComponent<DtEntityLocationStateComponent>();
         updateVelocity(comp->worldVelocity());
         updateAcceleration(comp->worldAcceleration());
         updateOrientation(comp->worldOrientation());
      }
   }

   void DtUnitStatusLogic::updateMarkingText(DtSimObjectReference s)
   {
      myInterface->setMarkingText(s->getStateComponent<DtVrfStateComponent>()->echelonId().string().c_str());
   }

   void DtUnitStatusLogic::updateVelocity(const DtVector& v)
   {
      QString velocity = DtVrfDisplayUnitsSettingsManager::instance(myDe).
         convertVelocityUnitNativeToDisplayString(v, DtSelectionManager::instance(myDe).currentSelections()).c_str();
      myInterface->setVelocity(velocity);
   }

   void DtUnitStatusLogic::updateAcceleration(const DtVector& a)
   {
      QString acceleration = DtVrfDisplayUnitsSettingsManager::instance(myDe).
         convertAccelerationUnitNativeToDisplayString(a).c_str();
      myInterface->setAcceleration(acceleration);
   }

   void DtUnitStatusLogic::updateOrientation(const DtTaitBryan& o)
   {
      std::vector<std::string> strings = 
         DtVrfDisplayUnitsSettingsManager::instance(myDe).
         convertOrientationUnitNativeToDisplayStrings(o);
      QString orientation = strings[0].c_str();
      orientation += ", ";
      orientation += strings[1].c_str();
      orientation += ", ";
      orientation += strings[2].c_str();
      myInterface->setHeading(orientation);
   }

   void DtUnitStatusLogic::updateLocation(const DtVector& geoc)
   {  
      //Draw circle
      if ( myCircleVisualizer )
      {
         myCircleVisualizer->update(geoc);
      }
      myInterface->setLocation(DtVrfDisplayUnitsSettingsManager::instance(myDe).
         convertPositionToStringList(geoc));
   }

   void DtUnitStatusLogic::displayUnitSettingsChanged()
   {
      if (mySimEntry.isValid())
      {
         slot_onStateViewUpdated(mySimEntry);
      }
   }

   CircleVisualHandler * DtUnitStatusLogic::createCircleVisualizer()
   {
      //Now we need to create a visualizer handler to represent the visual object in the scene
      //This is where you add things you'd like to be drawn in the scene,ie on the GUI
      CircleVisualHandler * visualHandler = new CircleVisualHandler(myDe, myDe.agentManager().createNewUniqueId());

      return visualHandler;
   }
}