networkMapNode.h

Go to the documentation of this file.

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

#ifndef _networkMapNode_H_
#define _networkMapNode_H_

#include <math.h>
#include <vlutil/vlString.h>
#include <iconAndTextureManager.h>

struct _vec2
{
   float x;
   float y;
};

#define RTI_NODE_SPEED 1.25

#define RTI_NODE_DEST_RANGE 0.008

class DtNetworkMapNode
{
public:

   DtNetworkMapNode();

   DtNetworkMapNode( int fedId, const MAKRti::DtString& federationName, 
      const MAKRti::DtString& processName, const MAKRti::DtString& federateType,
      const MAKRti::DtString& federateName, float radius );

   DtNetworkMapNode( int compId, const MAKRti::DtString& forwarderName, int port, float radius );

   DtNetworkMapNode( int compId, const MAKRti::DtString& execName, float radius );

   virtual ~DtNetworkMapNode() { };

   inline void setTextureId( int id )
   {
      if( id >= 0 )
         textureId = id;
   }

   inline int getTextureId()
   {
      return textureId;
   }

   inline void setRadius( float radius )
   {
      this->radius = radius;
   }

   inline float getRadius()
   {
      return radius;
   }

   inline int getFederateId() 
   {
      return federateId;
   }

   void update( float delta );

   inline void setDestination( const _vec2 &dest )
   {
      destination.x = dest.x;
      destination.y = dest.y;
   }

   inline bool isMoving() const
   {
      float xDiff = position.x - destination.x;
      float yDiff = position.y - destination.y;
      
      if(xDiff < 0)
      {
         xDiff *= -1;
      }
      if(yDiff < 0)
      {
         yDiff *= -1;
      }
      
      return (xDiff > RTI_NODE_DEST_RANGE &&
         yDiff > RTI_NODE_DEST_RANGE);
   }

   inline const _vec2 & getPosition() const { return position; }

   inline void setPosition(const _vec2 &pos )
   {
      position.x = pos.x;
      position.y = pos.y;
   }

   inline void resetTextureId()
   {
      textureId = -1;
   }

   inline void showWarning()
   {
      textureId = DtWarningTexture;
   }
  
   inline void showError()
   {
      textureId = DtErrorTexture;
   }

   // Show disconnect texture
   inline void showDisconnect()
   {
      textureId = DtDisconnectedTexture;
   }
   inline bool isDisconnected()
   {
      return ( textureId == DtDisconnectedTexture ? true : false );
   }

   inline void showNotJoined()
   {
      textureId = DtNotJoinedTexture;
   }
   inline bool isNotJoined()
   {
      return ( textureId == DtNotJoinedTexture ? true : false );
   }

   inline void resetTouched()
   {
      wasTouched = true;
   }

   inline void clearTouched()
   {
      wasTouched = false;
   }

   inline bool isTouched() { return wasTouched; };

   inline void setIsCentralForwarder() { isCentralForwarder = true; isPeerForwarder = false; isExec = false; isLightWeightCenter = false; }

   inline bool IsCentralForwarder() { return isCentralForwarder; }

   inline void setIsPeerForwarder() { isPeerForwarder = true; isCentralForwarder = false; isExec = false; isLightWeightCenter = false; }

   inline bool IsPeerForwarder() { return isPeerForwarder; }

   inline void setIsExec() { isExec = true; isPeerForwarder = false; isCentralForwarder = false; isLightWeightCenter = false; }

   inline bool IsExec() { return isExec; };

   inline void setIsLightweightCenter() { isLightWeightCenter = true; isExec = false; isCentralForwarder = false; isPeerForwarder = false; }

   inline bool IsLightweightCenter() { return isLightWeightCenter; }

   inline bool shouldBeDelete() { return deleteMe; }

   inline void startShutdown() { startDelete = true; }

   inline MAKRti::DtString& getFederationName() { return myFederationName; };
   inline MAKRti::DtString& getProcessName() { return myProcessName; };
   inline MAKRti::DtString& getFederateType() { return myFederateType; };
   inline MAKRti::DtString& getFederateName() { return myFederateName; };
   inline int getPort() { return myPort; };
   inline MAKRti::DtString getHostPort() { return myProcessName + ":" + MAKRti::DtString(myPort);}

protected:
   int textureId;                   // Texture ID ( looked up by renderer )
   unsigned int federateId;         // The federate ID ( for lookup )
   bool isExec;                     // are we the exec
   bool isCentralForwarder;         // are we the central forwarder
   bool isPeerForwarder;            // are we a peer forwarder
   bool isLightWeightCenter;        // are we a lightweight center node
   bool wasTouched;                 // have we been touched
   bool deleteMe;                   // should we delete ourselves
   bool startDelete;                // start deletion process
   float radius;                    // What's our size of this object 
   float speed;                     // Used in acceleration
   float elapsedTime;               // Delta Time
   float elapsedDeleteTime;         // Delete Delta Time
   _vec2 position;                  // Position on screen
   _vec2 acceleration;              // Acceleration
   _vec2 destination;               // Destination
   MAKRti::DtString myFederationName; // Federation name
   MAKRti::DtString myProcessName;  // processName 
   MAKRti::DtString myFederateType; // federate type
   MAKRti::DtString myFederateName; // federate name
   int myPort;
};



#endif