guiLocalObject.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2023 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/

#pragma once

#include <vrfGuiCore/vrfGuiCore.h>
#include <vrfGuiCore/guiSimObject.h>
#include <vrfutil/objectIdentificationResolver.h>

class DtRwProperties;

namespace makVrf
{
   class DtExternalNextFrameState;

   class DT_DLL_VRFGUICORE DtGuiLocalObject : public DtGuiSimObject
   {
   public:
      explicit DtGuiLocalObject(makVrv::DtDe& de, DtStateDataManager* som, const DtEntityType&, bool addToSimObjectManager = false, const DtUUID& uuid = DtUUID::nullUUID());
      explicit DtGuiLocalObject(makVrv::DtDe& de, const DtStateDataManager* simManager, const DtUUID& uuid) : DtGuiSimObject(simManager, uuid), myDe(de) {};
      explicit DtGuiLocalObject(makVrv::DtDe& de, const DtStateDataManager* simManager, const DtEntityIdentifier& id) : DtGuiSimObject(simManager, id), myDe(de) {};

      virtual ~DtGuiLocalObject() override;

      const DtStateDataManager* stateDataManager() const
      {
         return myStateDataManager;
      }

      DtStateData* stateData()
      {
         return myStateData;
      }

      void setObjectName(const DtString& objectName);
      const DtString& nextFrameObjectName();
      void setEntityType(const DtEntityType& et);
      void setEntityId(const DtEntityIdentifier&);
      void setLabel(const DtString& objectName);
      void setForceType(DtForceType);
      void setWorldPosition(const DtVector&);
      void setWorldOrientation(const DtTaitBryan&);
      void setAppearance(int);
      void setExtendedData(const DtString& key, const DtString& value);
      void removeExtendedData(const DtString& key);
      void setExtendedData(const std::map<std::string, std::string>&);
      void setExtendedData(const std::map<DtString, DtString>&);
      void setUserData(unsigned long long);
      void setOverlay(const DtString&);
      void addStateComponent(const DtFrameStateInterface*);
      void removeStateComponent(const DtFrameStateInterface*);

      DtRwProperties& stateProperties();

      void setPenStyle(int);
      void setColor(unsigned int);
      void setFillStyle(int);
      void setLineWidth(int);
      void setPhysicalLineWidth(double);
      void setPhysicalLineHeight(double);
      void setUserData(const DtString&);
      void setProjected(bool);
      void setClosedFigure(bool);

      virtual DtSimObjectReference simObjectReference();
      virtual std::shared_ptr<DtGuiLocalObject> guiLocalObjectReference();

      virtual void resetReference();

      template <typename T_Component>
      T_Component* addStateComponent(bool checkWritable = false, bool isRemote = false)
      {
         if (isValid())
         {
            T_Component* comp = myExternalNextFrameState->addStateComponent<T_Component>(checkWritable, isRemote);

            if (comp)
            {
               if (myStateData)
               {
                  makVrf::DtStateComponent* stateComponent = myStateData->getStateComponent<T_Component>(comp->id());

                  if (stateComponent)
                  {
                     stateComponent->setIsRemoteComponent(false);
                  }
               }
            }

            return comp;
         }
         else
         {
            throw makVrf::DtUnimplementedMethod("The addStateComponent is not implemented for this class.");
         }
      }

      makVrf::DtFrameStateInterface* addStateComponent(makVrf::DtStateComponent::StateComponentType t);

      void setHostId(const std::string&);
      void setHostId(const DtUUID&);

      void setGlobalId(const DtString&);

      void setCapabilities(int);
      void setGuise(const DtEntityType&);

      void setWorldVertices(const std::vector<DtVector>&);
      void setLocalVertices(const std::vector<DtVector>&);

      template <typename T_Component>
      bool hasStateComponent() const
      {
         if (myExternalNextFrameState)
         {
            return myExternalNextFrameState->hasStateComponent<T_Component>();
         }

         return DtGuiSimObject::hasStateComponent<T_Component>();
      }

      inline DtSimulatedObjectStateComponent* nextFrameSimulatedObjectStateComponent()
      {
         if (myNextFrameSimulatedObjectStateComponent)
         {
            return myNextFrameSimulatedObjectStateComponent;
         }
         else if (!myCachedComponents && hasStateComponent<DtSimulatedObjectStateComponent>())
         {
            return getNextFrameStateComponent<DtSimulatedObjectStateComponent>();
         }
         else
         {
            return nullptr;
         }
      }

      inline DtLocationStateComponent* nextFrameLocationStateComponent()
      {
         if (myNextFrameLocationStateComponent)
         {
            return myNextFrameLocationStateComponent;
         }
         else if (!myCachedComponents && hasStateComponent<DtLocationStateComponent>())
         {
            return getNextFrameStateComponent<DtLocationStateComponent>();
         }
         else
         {
            return nullptr;
         }
      }

      inline DtVrfStateComponent* nextFrameVrfStateComponent()
      {
         if (myNextFrameVrfStateComponent)
         {
            return myNextFrameVrfStateComponent;
         }
         else if (!myCachedComponents && hasStateComponent<DtVrfStateComponent>())
         {
            return getNextFrameStateComponent<DtVrfStateComponent>();
         }
         else
         {
            return nullptr;
         }
      }

      inline DtVrfGeometryStateComponent* nextFrameVrfGeometryStateComponent()
      {
         if (myNextFrameVrfGeometryStateComponent)
         {
            return myNextFrameVrfGeometryStateComponent;
         }
         else if (!myCachedComponents && hasStateComponent<DtVrfGeometryStateComponent>())
         {
            return getNextFrameStateComponent<DtVrfGeometryStateComponent>();
         }
         else
         {
            return nullptr;
         }
      }

      inline DtEnvironmentalStateComponent* nextFrameEnvironmentalStateComponent()
      {
         if (myNextFrameEnvironmentalStateComponent)
         {
            return myNextFrameEnvironmentalStateComponent;
         }
         else if (!myCachedComponents && hasStateComponent<DtEnvironmentalStateComponent>())
         {
            return getNextFrameStateComponent<DtEnvironmentalStateComponent>();
         }
         else
         {
            return nullptr;
         }
      }

      template <typename T_Component>
      T_Component* getNextFrameStateComponent()
      {
         if (myExternalNextFrameState)
         {
            return myExternalNextFrameState->getStateComponent<T_Component>();
         }

         return nullptr;
      }

      template <typename T_Component>
      const T_Component* getStateComponent() const
      {
         const T_Component* comp = DtGuiSimObject::getStateComponent<T_Component>();

         if (!comp)
         {
            comp = const_cast<DtGuiLocalObject*>(this)->getNextFrameStateComponent<T_Component>();
         }

         return comp;
      }
      bool wantsModificationSignal(int comp) const
      {
         LocalObjectModifiedSignalMap::const_iterator iter = myLocalObjectModifiedSignalMap.find(comp);

         if (iter != myLocalObjectModifiedSignalMap.end())
         {
            return ((*iter->second.get()).num_slots() > 0);
         }

         return false;
      }

      typedef boost::signals2::signal<void (DtGuiLocalObject*)> LocalObjectModifiedSignal;
      template <typename T_Component>
      LocalObjectModifiedSignal& signalWhenModified() const
      {
         return signalWhenModified(T_Component::ComponentType());
      }

      LocalObjectModifiedSignal& signalWhenModified(int comp) const
      {
         LocalObjectModifiedSignalMap::iterator iter = myLocalObjectModifiedSignalMap.find(comp);

         if (iter == myLocalObjectModifiedSignalMap.end())
         {
            myLocalObjectModifiedSignalMap[comp] = std::unique_ptr<LocalObjectModifiedSignal>(new LocalObjectModifiedSignal);
            iter = myLocalObjectModifiedSignalMap.find(comp);
         }

         return *(iter->second.get());
      }

      boost::signals2::signal<void (DtGuiLocalObject*)> signal_localObjectAboutToBeRemoved;
      boost::signals2::signal<void (DtGuiLocalObject*)> signal_stateDataDeleted;

   protected:
      virtual void setUUID(const DtUUID&) override;
      virtual const DtStateData* stateDataFor(const DtUUID& uuid) const override;

      virtual void cacheComponents() override;
      virtual void clearCachedComponents() override;
      virtual void slot_localStateDataModified();
      virtual void completeLocalStateModified(std::set<int> modifiedStateComponentTypes);
      virtual void slot_stateDataDeleted();
      virtual void slot_stateComponentAboutToBeDeleted(const DtFrameStateInterface*);

   protected:
      DtSimulatedObjectStateComponent* myNextFrameSimulatedObjectStateComponent = nullptr;
      DtVrfStateComponent* myNextFrameVrfStateComponent = nullptr;
      DtLocationStateComponent* myNextFrameLocationStateComponent = nullptr;
      DtEntityStateComponent* myNextFrameEntityStateComponent = nullptr;
      DtVrfGeometryStateComponent* myNextFrameVrfGeometryStateComponent = nullptr;
      DtEnvironmentalStateComponent* myNextFrameEnvironmentalStateComponent = nullptr;
      DtStatePropertiesStateComponent* myNextFrameStatePropertiesStateComponent = nullptr;
      DtExternalNextFrameState* myExternalNextFrameState;
      makVrv::DtDe& myDe;
      typedef std::map<int, std::unique_ptr<LocalObjectModifiedSignal>> LocalObjectModifiedSignalMap;
      mutable LocalObjectModifiedSignalMap myLocalObjectModifiedSignalMap;
      boost::signals2::connection myPostTickConnection;
      DtSimObjectReference mySimObjectReference;
      std::shared_ptr<DtGuiLocalObject> myGuiLocalObjectReference;
      std::set<const DtFrameStateInterface*> myManagedStateComponents;
      boost::signals2::scoped_connection myStateDataDeletedConnection;
      boost::signals2::scoped_connection myStateDataModifiedConnection;

   protected:
      DtStateData* myStateData;
   };
   
   class DT_DLL_VRFGUICORE DtGuiLocalObjectMarkingTextProvider : public DtUUIDMarkingTextProvider
   {
   public:
      DtGuiLocalObjectMarkingTextProvider(const DtGuiLocalObject& lo) : myGuiLocalObject(lo) {};
      DtGuiLocalObjectMarkingTextProvider(const DtGuiLocalObjectMarkingTextProvider& rhs) : myGuiLocalObject(rhs.myGuiLocalObject) {};

      virtual DtString markingText() override { return myGuiLocalObject.objectName(); };
      virtual DtUUIDMarkingTextProvider* clone() const override
      { return new DtGuiLocalObjectMarkingTextProvider(*this); };

   protected:
      const DtGuiLocalObject& myGuiLocalObject;
   };
}