include/vrfGuiCore/DtCopyObject.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2009 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/
/******************************************************************************
** $RCSfile: DtCopyObject.h,v $ $Revision: 1.1 $ $State: Exp $
******************************************************************************/



#pragma once

#include <vrfGuiCore/vrfGuiCore.h>
#include <vrfGuiCore/DtVrfObjectFacadeInterface.h>

#include <vrvCore/DtDe.h>
#include <vrvCore/DtUniqueID.h>

#include <matrix/vlVector.h>
#include <matrix/geodCoord.h>

namespace makVrv
{
   struct DtVrlinkSimulatedBaseState;
   class DtSimEntry;
}

class DtVector;

namespace makVrf
{
   struct DtVrfObjectDataState;

   
   class DT_DLL_VRFGUICORE DtStreamString
   {
   public:
      DtStreamString();
      DtStreamString(const std::string&);
      DtStreamString(std::string*);
      DtStreamString(int size, const char* buf);

      virtual void write(std::ostringstream&) const;
      virtual void read(std::istringstream&);

      const std::string& value() const
      {
         return myValue;
      }

   protected:
      std::string    myValue;
      std::string*   myInput;
   };

   DT_DLL_VRFGUICORE std::ostringstream& operator<<(std::ostringstream&, const DtStreamString&);
   DT_DLL_VRFGUICORE std::istringstream& operator>>(std::istringstream&, DtStreamString&);

   DT_DLL_VRFGUICORE std::ostringstream& operator<<(std::ostringstream&, const DtVector&);
   DT_DLL_VRFGUICORE std::istringstream& operator>>(std::istringstream&, DtVector&);

   
   template <typename Type>
   class DtStreamNumber
   {
   public:
      DtStreamNumber(Type t)
      : myValue(t)
      , myInput(0)
      {
      }

      DtStreamNumber(Type* t)
      : myInput(t)
      {
      }

      void write(std::ostringstream& s) const
      {
         s << myValue << " ";
      }

      void read(std::istringstream& s)
      {
         s >> myValue;
         s.ignore();

         if (myInput)
         {
            *myInput = myValue;
         }
      }

      Type value() const
      {
         return myValue;
      }

   protected:
      Type    myValue;
      Type*   myInput;
   };

   template <typename Type> std::ostringstream& operator<<(std::ostringstream& s, const DtStreamNumber<Type>& num)
   {
      num.write(s);

      return s;
   }

   template <typename Type> std::istringstream& operator>>(std::istringstream& s, DtStreamNumber<Type>& num)
   {
      num.read(s);
 
      return s;
   }

   class DT_DLL_VRFGUICORE DtCopyObject
   {
      typedef std::vector<DtGeodeticCoord>   CopyOffsets;

   public:
      DtCopyObject(makVrv::DtDe&);
      virtual ~DtCopyObject();

   public:
      enum DtPasteFlags
      {
         DtPasteNewName =     0x00000001, 
         DtPasteAppearance =  0x00000002, 
         DtPasteHeading =     0x00000004, 
         DtPasteEngagement =  0x00000008,
         DtPastePlan =        0x00000010,
         DtPasteAboveSeaLevel = 0x00000020,
         DtPasteAboveTerrain = 0x00000040,
         DtPasteFormation = 0x00000080,

         DtAllPasteFlags = DtPasteNewName | DtPasteAppearance | DtPasteHeading | DtPasteEngagement | DtPastePlan | DtPasteAboveTerrain
      };

   public:
      virtual void copy(makVrv::DtSimEntry*);

      virtual void read(const std::string& buf);

      virtual void cancel();

      const std::string& name() const
      {
         return myName;
      }

      virtual std::string copyPendingMessage() const;

      virtual std::string pastePendingMessage() const;

      virtual void setAltitudeClampType(DtAltitudeClampType);
      DtAltitudeClampType altitudeClampType() const;

      void setType(int t)
      {
         myType = t;
      }

      int type() const
      {
         return myType;
      }

      void setBuffer(const std::string& b)
      {
         myBuffer = b;
      }

      const std::string& buffer() const
      {
         return myBuffer;
      }

   protected:
      virtual void write(std::ostringstream& str, const makVrv::DtVrlinkSimulatedBaseState* data, makVrv::DtUniqueID id);

      virtual void write(std::ostringstream& str, const DtVrfObjectDataState* data);

      virtual DtVrfObjectDataState* createReadableObjectStateData() const;
      virtual makVrv::DtVrlinkSimulatedBaseState* createReadableStateData() const;

      virtual void read(std::istringstream& str, makVrv::DtVrlinkSimulatedBaseState* data);

      virtual void read(std::istringstream& str, DtVrfObjectDataState* data);

      virtual void checkCopyComplete();

      virtual bool copyOperationsPending() const;

      virtual void copyComplete();

      virtual bool cancelComplete() const;

   public:
      virtual void paste(const DtVector&, int flags = DtAllPasteFlags);

      virtual DtGeodeticCoord center() const;
      virtual DtVector localCenter() const;
      virtual DtGeodeticCoord calculateCenter() const;

      virtual DtVector origin() const;

      virtual void setGeometricCenter(const DtGeodeticCoord&);

      const DtGeodeticCoord& geometricCenter() const;

      virtual void createFacade();

      virtual void setOrigin(const DtGeodeticCoord&);

      const makVrv::DtVrlinkSimulatedBaseState* readableStateData() const
      {
         return myReadableStateData;
      }

   protected:
      virtual void readComplete(std::istringstream& str);

      virtual void checkPasteComplete();

      virtual bool pasteComplete() const;

      virtual void createObject(const DtVector&);

      virtual int generateRequestId();

      virtual double groundHeight(const DtVector& currentLocal) const;

      virtual void setupOffsets(const DtGeodeticCoord&);

      virtual DtVector offsetLocation(int, const DtVector& loc) const;

      virtual DtGeodeticCoord calculateOffsetPoint(const DtGeodeticCoord& start, const DtGeodeticCoord& end,
         double& altAboveTerrain, double& altAboveSeaLevel) const;

      virtual DtVector localLocation(const DtGeodeticCoord&, int) const;

   public:
      boost::signal<void (DtCopyObject*)>                      signal_copyCancelled;
      boost::signal<void (DtCopyObject*, const std::string&)>  signal_copied;
      boost::signal<void (DtCopyObject*, const std::string&)>  signal_copyOperationPending;

      boost::signal<void (DtCopyObject*)>                      signal_pasted;
      boost::signal<void (DtCopyObject*, const std::string&)>  signal_pasteOperationPending;
      boost::signal<void (DtCopyObject*)>                      signal_pasteCancelled;

   protected:
      makVrv::DtDe&        myDe;
      std::ostringstream   myOutput;
      std::string          myName;
      int                  myPasteFlags;

      DtVrfObjectDataState*               myReadableObjectStateData;
      makVrv::DtVrlinkSimulatedBaseState* myReadableStateData;

      mutable DtGeodeticCoord     myCenter;

      CopyOffsets        myOffsets;

      typedef std::vector<double> HeightOffsets;

      HeightOffsets      myAltitudeAboveTerrain;
      HeightOffsets      myAltitudeAboveSeaLevel;

      DtAltitudeClampType myAltitudeClampType;
      DtReferenceEllipsoid myReferenceEllipsoid;

      int myType;
      std::string myBuffer;

      DtGeodeticCoord myGeometricCenter;
   };

   class DT_DLL_VRFGUICORE DtCopyObjectCreator
   {
   public:
      virtual DtCopyObject* create(makVrv::DtDe&) = 0;
   };
}