CigiBaseSymbolCtrl.h

Go to the documentation of this file.

#if !defined(_CIGI_BASE_SYMBOL_CTRL_INCLUDED_)
#define _CIGI_BASE_SYMBOL_CTRL_INCLUDED_


#include "CigiBasePacket.h"

// ====================================================================
// preprocessor definitions
// ====================================================================

#define CIGI_SYMBOL_CONTROL_PACKET_ID_V3_3 34
#define CIGI_SYMBOL_CONTROL_PACKET_SIZE_V3_3 40


class CigiSymbolCtrlV3_3;


//=========================================================
class CIGI_SPEC CigiBaseSymbolCtrl :
   public CigiBasePacket
{

   friend class CigiSymbolCtrlV3_3;

public:

   //=========================================================
   enum SymbolStateGrp
   {
      Hidden=0,
      Visible=1,
      Destroyed=2
   };

   //=========================================================
   enum AttachStateGrp
   {
      Detach=0,
      Attach=1
   };

   //=========================================================
   enum FlashCtrlGrp
   {
      Continue=0,
      Reset=1
   };

   //=========================================================
   enum InheritColorGrp
   {
      NotInherit=0,
      Inherit=1
   };



   //==> Management

   //=========================================================
   CigiBaseSymbolCtrl(void);

   //=========================================================
   virtual ~CigiBaseSymbolCtrl(void);


   //==> Buffer Packing/Unpacking

   //=========================================================
   virtual int Pack(CigiBasePacket * Base, Cigi_uint8 * Buff, void *Spec) const=0;

   //=========================================================
   virtual int Unpack(Cigi_uint8 * Buff, bool Swap, void *Spec) =0;

   //=========================================================
        virtual int GetCnvt(CigiVersionID &CnvtVersion,
                       CigiCnvtInfoType::Type &CnvtInfo);



   //==> Accessing Member Variable Values functions

   //+> SymbolID

   //=========================================================
   int SetSymbolID(const Cigi_uint16 SymbolIDIn, bool bndchk=true)
   {
      SymbolID = SymbolIDIn;
      return(CIGI_SUCCESS);
   }

   //=========================================================
   Cigi_uint16 GetSymbolID(void) const { return(SymbolID); }
   

   //+> SymbolState

   //=========================================================
   int SetSymbolState(const SymbolStateGrp SymbolStateIn, bool bndchk=true);

   //=========================================================
   SymbolStateGrp GetSymbolState(void) const { return(SymbolState); }
   

   //+> AttachState

   //=========================================================
   int SetAttachState(const AttachStateGrp AttachStateIn, bool bndchk=true);

   //=========================================================
   AttachStateGrp GetAttachState(void) const { return(AttachState); }
   

   //+> FlashCtrl

   //=========================================================
   int SetFlashCtrl(const FlashCtrlGrp FlashCtrlIn, bool bndchk=true);

   //=========================================================
   FlashCtrlGrp GetFlashCtrl(void) const { return(FlashCtrl); }
   

   //+> InheritColor

   //=========================================================
   int SetInheritColor(const InheritColorGrp InheritColorIn, bool bndchk=true);

   //=========================================================
   InheritColorGrp GetInheritColor(void) const { return(InheritColor); }
   

   //+> ParentSymbolID

   //=========================================================
   int SetParentSymbolID(const Cigi_uint16 ParentSymbolIDIn, bool bndchk=true)
   {
      ParentSymbolID = ParentSymbolIDIn;
      return(CIGI_SUCCESS);
   }

   //=========================================================
   Cigi_uint16 GetParentSymbolID(void) const { return(ParentSymbolID); }
   

   //+> SurfaceID

   //=========================================================
   int SetSurfaceID(const Cigi_uint16 SurfaceIDIn, bool bndchk=true)
   {
      SurfaceID = SurfaceIDIn;
      return(CIGI_SUCCESS);
   }

   //=========================================================
   Cigi_uint16 GetSurfaceID(void) const { return(SurfaceID); }
   

   //+> Layer

   //=========================================================
   int SetLayer(const Cigi_uint8 LayerIn, bool bndchk=true)
   {
      Layer = LayerIn;
      return(CIGI_SUCCESS);
   }

   //=========================================================
   Cigi_uint8 GetLayer(void) const { return(Layer); }
   

   //+> FlashDutyCycle

   //=========================================================
   int SetFlashDutyCycle(const Cigi_uint8 FlashDutyCycleIn, bool bndchk=true);

   //=========================================================
   Cigi_uint8 GetFlashDutyCycle(void) const { return(FlashDutyCycle); }
   

   //+> FlashPeriod

   //=========================================================
   int SetFlashPeriod(const float FlashPeriodIn, bool bndchk=true)
   {
      FlashPeriod = FlashPeriodIn;
      return(CIGI_SUCCESS);
   }

   //=========================================================
   float GetFlashPeriod(void) const { return(FlashPeriod); }
   

   //+> UPosition

   //=========================================================
   int SetUPosition(const float UPositionIn, bool bndchk=true)
   {
      UPosition = UPositionIn;
      return(CIGI_SUCCESS);
   }

   //=========================================================
   float GetUPosition(void) const { return(UPosition); }
   

   //+> VPosition

   //=========================================================
   int SetVPosition(const float VPositionIn, bool bndchk=true)
   {
      VPosition = VPositionIn;
      return(CIGI_SUCCESS);
   }

   //=========================================================
   float GetVPosition(void) const { return(VPosition); }
   

   //+> Rotation

   //=========================================================
   int SetRotation(const float RotationIn, bool bndchk=true)
   {
      Rotation = RotationIn;
      return(CIGI_SUCCESS);
   }

   //=========================================================
   float GetRotation(void) const { return(Rotation); }


   //+> Color

   //=========================================================
   int SetColor(const Cigi_uint8 RedIn,
                const Cigi_uint8 GreenIn,
                const Cigi_uint8 BlueIn,
                const Cigi_uint8 AlphaIn,
                bool bndchk=true)
   {
      Red = RedIn;
      Green = GreenIn;
      Blue = BlueIn;
      Alpha = AlphaIn;

      return(CIGI_SUCCESS);
   }

   //=========================================================
   int GetColorDatum(Cigi_uint8 &RedValue,
                     Cigi_uint8 &GreenValue,
                     Cigi_uint8 &BlueValue,
                     Cigi_uint8 &AlphaValue,
                     bool bndchk=true)
   {
      RedValue = Red;
      GreenValue = Green;
      BlueValue = Blue;
      AlphaValue = Alpha;

      return(CIGI_SUCCESS);
   }


   //+> Red

   //=========================================================
   int SetRed(const Cigi_uint8 RedIn, bool bndchk=true)
   {
      Red = RedIn;
      return(CIGI_SUCCESS);
   }

   //=========================================================
   Cigi_uint8 GetRed(void) const { return(Red); }
   

   //+> Green

   //=========================================================
   int SetGreen(const Cigi_uint8 GreenIn, bool bndchk=true)
   {
      Green = GreenIn;
      return(CIGI_SUCCESS);
   }

   //=========================================================
   Cigi_uint8 GetGreen(void) const { return(Green); }
   

   //+> Blue

   //=========================================================
   int SetBlue(const Cigi_uint8 BlueIn, bool bndchk=true)
   {
      Blue = BlueIn;
      return(CIGI_SUCCESS);
   }

   //=========================================================
   Cigi_uint8 GetBlue(void) const { return(Blue); }
   

   //+> Alpha

   //=========================================================
   int SetAlpha(const Cigi_uint8 AlphaIn, bool bndchk=true)
   {
      Alpha = AlphaIn;
      return(CIGI_SUCCESS);
   }

   //=========================================================
   Cigi_uint8 GetAlpha(void) const { return(Alpha); }
   

   //+> ScaleU

   //=========================================================
   int SetScaleU(const float ScaleUIn, bool bndchk=true)
   {
      ScaleU = ScaleUIn;
      return(CIGI_SUCCESS);
   }

   //=========================================================
   float GetScaleU(void) const { return(ScaleU); }
   

   //+> ScaleV

   //=========================================================
   int SetScaleV(const float ScaleVIn, bool bndchk=true)
   {
      ScaleV = ScaleVIn;
      return(CIGI_SUCCESS);
   }

   //=========================================================
   float GetScaleV(void) const { return(ScaleV); }



protected:

   //==> Member variables

   //=========================================================
   Cigi_uint16 SymbolID;

   //=========================================================
   SymbolStateGrp SymbolState;

   //=========================================================
   AttachStateGrp AttachState;

   //=========================================================
   FlashCtrlGrp FlashCtrl;

   //=========================================================
   InheritColorGrp InheritColor;

   //=========================================================
   Cigi_uint16 ParentSymbolID;

   //=========================================================
   Cigi_uint16 SurfaceID;

   //=========================================================
   Cigi_uint8 Layer;

   //=========================================================
   Cigi_uint8 FlashDutyCycle;

   //=========================================================
   float FlashPeriod;

   //=========================================================
   float UPosition;

   //=========================================================
   float VPosition;

   //=========================================================
   float Rotation;

   //=========================================================
   Cigi_uint8 Red;

   //=========================================================
   Cigi_uint8 Green;

   //=========================================================
   Cigi_uint8 Blue;

   //=========================================================
   Cigi_uint8 Alpha;

   //=========================================================
   float ScaleU;

   //=========================================================
   float ScaleV;




};



#endif   //  #if !defined(_CIGI_BASE_SYMBOL_CTRL_INCLUDED_)

---