Unit Status Widget Logic

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

---

Header file:

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

#include <vrvCore/DtSelectionManager.h>
#include <vrvCore/DtStateView.h>
#include <vrvCore/DtEntityState.h>

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

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 resetUpdateRate();
      virtual void slot_onStateViewUpdated(makVrv::DtStateView<makVrv::DtVrlinkSimulatedEntityState>* s);
      virtual bool isDestroyed(makVrv::DtStateView<makVrv::DtVrlinkSimulatedEntityState>* 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(makVrv::DtStateView<makVrv::DtVrlinkSimulatedEntityState>* s);
      virtual CircleVisualHandler * createCircleVisualizer();

      virtual void displayUnitSettingsChanged();

   protected:
      makVrv::DtDe& myDe;
      DtUnitStatusInterface*  myInterface;
      makVrv::DtSimEntry*     mySimEntry;
      makVrf::DtEntityMapperKey       myKey;
      bool                    myIsDestroyed;
      CircleVisualHandler *   myCircleVisualizer;
   };
}

---

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/vrfStateViewCollectionManager.h>
#include <vrfGuiCommonQt/vrfGuiSymbolMapper.h>
#include <vrfGuiCore/vrfObjectDataState.h>
#include <vrvCore/DtSharedSettingsManager.h>

//VR-Vantage includes
#include <vrvCore/DtSimData.h>
#include <vrvCore/DtDeSharedState.h>
#include <vrvCore/DtDisplayUnitsSettingsManager.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)
   {
      DtSelectionManager::instance(de).signal_currentSelectionChanged.connect(boost::bind(
         &DtUnitStatusLogic::slot_onCurrentSelectionChanged, this, _1, _2));
      DtDisplayUnitsSettingsSignaler& signaler = 
         DtDisplayUnitsSettingsSignaler::instance(myDe.mainEventQueue());
      signaler.signal_displayUnitChanged.connect(
         boost::bind(&DtUnitStatusLogic::displayUnitSettingsChanged, this));
      signaler.signal_displayUnitDecimalsChanged.connect(
         boost::bind(&DtUnitStatusLogic::displayUnitSettingsChanged, this));
      signaler.signal_displayCoordinateSystemChanged.connect(
         boost::bind(&DtUnitStatusLogic::displayUnitSettingsChanged, this));
      signaler.signal_displayCoordinateSystemDecimalsChanged.connect(
         boost::bind(&DtUnitStatusLogic::displayUnitSettingsChanged, this));
   }

   DtUnitStatusLogic::~DtUnitStatusLogic()
   {
      DtSelectionManager::instance(myDe).signal_currentSelectionChanged.disconnect(boost::bind(
         &DtUnitStatusLogic::slot_onCurrentSelectionChanged, this, _1, _2));
      DtDisplayUnitsSettingsSignaler& signaler = 
         DtDisplayUnitsSettingsSignaler::instance(myDe.mainEventQueue());
      signaler.signal_displayUnitChanged.disconnect(
         boost::bind(&DtUnitStatusLogic::displayUnitSettingsChanged, this));
      signaler.signal_displayUnitDecimalsChanged.disconnect(
         boost::bind(&DtUnitStatusLogic::displayUnitSettingsChanged, this));
      signaler.signal_displayCoordinateSystemChanged.disconnect(
         boost::bind(&DtUnitStatusLogic::displayUnitSettingsChanged, this));
      signaler.signal_displayCoordinateSystemDecimalsChanged.disconnect(
         boost::bind(&DtUnitStatusLogic::displayUnitSettingsChanged, this));

      if ( myCircleVisualizer )
      {
         delete myCircleVisualizer;
         myCircleVisualizer = 0;
      }

      resetUpdateRate();
   }

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

      if (!selected.size())
      {
         resetUpdateRate();

         mySimEntry = 0;
         myKey = "";
         myInterface->clear();
      }
      else
      {
         DtSelectionManager::IdSet::const_iterator iter = selected.begin();
         DtVrfStateViewCollectionManager& manager = DtVrfStateViewCollectionManager::instance(myDe);

         DtUniqueID id = manager.simIdFromDisplayId(*iter);
         DtSimEntry* entry = myDe.dataBank().simData().findSimEntry(id);

         if (!entry)
         {
            myInterface->clear();
            resetUpdateRate();
         }
         else
         {
            resetUpdateRate();

            myKey = "";

            DtStateView<DtVrlinkSimulatedEntityState>* stateView =
               const_cast<DtStateView<DtVrlinkSimulatedEntityState>*>(
               manager.simulatedEntityStateViewCollection()->findStateView(id));

            if (stateView)
            {
               entry->setUpdateRate(DtSimEntryUpdater::At2Hz, stateView);
               stateView->signal_stateViewUpdated.connect(boost::bind(&DtUnitStatusLogic::slot_onStateViewUpdated, this, _1));
               mySimEntry = entry;
               slot_onStateViewUpdated(stateView);
            }
            else
            {
               myInterface->clear();
            }
         }
      }
   }

   bool DtUnitStatusLogic::isDestroyed(DtStateView<DtVrlinkSimulatedEntityState>* s) const
   {
      const DtVrlinkSimulatedEntityState* view = (const DtVrlinkSimulatedEntityState*)&s->state();

      DtAppearance app(DtEntityType(view->myEntityType.c_str()));

      app.setAppearance(view->myAppearance);

      return (app.damageState() == DtDamageDestroyed);
   }

   void DtUnitStatusLogic::slot_onStateViewUpdated(DtStateView<DtVrlinkSimulatedEntityState>* s)
   {
      if (myDe.destructing())
      {
         return;
      }

      DtEntityType type(s->state().myEntityType.c_str());
      DtEntityMapperKey key(s->state().myForce, 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->state().myMarkingText);

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

      updateMarkingText(s);
      updateLocation(s->state().myLocation);
      updateVelocity(s->state().myVelocity);
      updateAcceleration(s->state().myAcceleration);
      updateOrientation(s->state().myOrientation);
   }

   void DtUnitStatusLogic::updateMarkingText(DtStateView<DtVrlinkSimulatedEntityState>* s)
   {
      DtStateView<DtVrfObjectDataState>* stateView =
         const_cast<DtStateView<DtVrfObjectDataState>*>(
         DtVrfStateViewCollectionManager::instance(myDe).objectDataStateViewCollection()->findStateView(s->id()));

      if (stateView)
      {
         myInterface->setMarkingText(stateView->state().myEchelonIdString.c_str());
      }
   }

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

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

   void DtUnitStatusLogic::updateOrientation(const DtTaitBryan& o)
   {
      std::vector<std::string> strings = 
         DtDisplayUnitsSettingsManager::instance(myDe).converter().
         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(DtDisplayUnitsSettingsManager::instance(myDe).converter().
         convertPositionToStringList(geoc));
   }

   void DtUnitStatusLogic::resetUpdateRate()
   {
      DtVrfStateViewCollectionManager& manager = DtVrfStateViewCollectionManager::instance(myDe);

      if (mySimEntry)
      {
         DtStateView<DtVrlinkSimulatedEntityState>* stateView =
            const_cast<DtStateView<DtVrlinkSimulatedEntityState>*>(
            manager.simulatedEntityStateViewCollection()->findStateView(mySimEntry->id()));

         if (stateView)
         {
            mySimEntry->setUpdateRate(DtSimEntryUpdater::NoUpdates, stateView);            
            stateView->signal_stateViewUpdated.disconnect(boost::bind(&DtUnitStatusLogic::slot_onStateViewUpdated, this, _1));
         }
      }
   }

   void DtUnitStatusLogic::displayUnitSettingsChanged()
   {
      DtVrfStateViewCollectionManager& manager = 
         DtVrfStateViewCollectionManager::instance(myDe);
      if (mySimEntry)
      {
         DtStateView<DtVrlinkSimulatedEntityState>* stateView =
            const_cast<DtStateView<DtVrlinkSimulatedEntityState>*>(
            manager.simulatedEntityStateViewCollection()->findStateView(mySimEntry->id()));
         slot_onStateViewUpdated(stateView);
      }
   }

   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;
   }
}