vrfCopyPasteHandler.h

Go to the documentation of this file.

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



#pragma once

#include <vrvUtil/signalslib.h>

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

#include <vrvCore/DtDe.h>
#include <vrvCore/DtSimEntry.h>
#include <vrvCore/DtElementEntry.h>

#include <matrix/geodeticCoord.h>

#include <boost/signal.hpp>

namespace makVrf
{
   class DtCopyObjectCreator;
   class DtCopyObject;
   class DtVrfObjectManipulationEventProcessor;

   class DT_DLL_VRFGUICORE DtVrfCopyPasteHandler
   {
   public:
      typedef std::pair<std::string, int>          DtPasteInformation;
      typedef std::map<std::string, DtPasteInformation>  DtPasteData;
      typedef std::map<DtCopyObject*, int>         DtObjectsCopying;
      typedef std::vector<DtCopyObject*>           DtObjectsDeleting;
      typedef std::vector<DtCopyObject*>           DtObjectsPasting;

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

   public:
      const DtPasteData& pasteData() const
      {
         return myPasteData;
      }

      virtual void clearPasteData();

      virtual void copy(const makVrv::DtUniqueID& id);

      virtual bool canCopy() const
      {
         return (myObjectsCopying.size() == 0);
      }

      int numCopying() const
      {
         return myObjectsCopying.size();
      }

      virtual bool canPaste() const
      {
         return ((myPasteData.size() != 0) && !pasting());
      }

      virtual void stop();

      virtual void cancelPaste();

      virtual void cancelled(DtCopyObject*);

      virtual void copied(DtCopyObject*, const std::string&);

      virtual void tick();

      virtual void copyOperationPending(DtCopyObject*, const std::string&);

      virtual DtCopyObject* createCopyObject(const makVrv::DtElementEntry&) const;

      virtual DtCopyObject* createCopyObject(int type) const = 0;

      void setPasteFlags(int f)
      {
         myPasteFlags = f;
      }

      int pasteFlags() const
      {
         return myPasteFlags;
      }

      bool hasObjectsToPaste() const
      {
         return (myObjectsPasting.size() != 0);
      }

      virtual void setPreserveOffsets(bool);
      virtual bool preserveOffsets() const;

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

      bool pasting() const
      {
         return myEventProcessor != 0;
      }

      void setMaximumToProcessInPastePass(int i)
      {
         myMaximumToProcessInPastePass = i;
      }

      int maximumToProcessInPastePass() const
      {
         return myMaximumToProcessInPastePass;
      }

      virtual void cleanup();

      virtual DtCopyObject* createObjectFromPasteData(int type, const std::string& buffer) const;

      virtual void queueObjectsToPaste();

      virtual void slot_onPaste();

      const DtObjectsPasting& objectsPasting() const
      {
         return myObjectsPasting;
      }

      virtual void setPasteData(const std::string& name, int type, const std::string& pasteBuffer);

      virtual void registerName(const DtString&);
      virtual bool nameIsRegistered(const DtString&) const;

   protected:

      virtual void pasted(DtCopyObject*);

      virtual void removeFromCopying(DtCopyObject*);

      virtual void cleanupEventProcessor();

   protected:
      virtual void slot_onLocationChanged(const DtVector&, double);

      virtual void pasteOperationPending(DtCopyObject*, const std::string&);

      virtual void pasteCancelled(DtCopyObject*);

      virtual void removeFromBeingPasted(DtCopyObject*);

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

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

   protected:
      makVrv::DtDe&     myDe;

      DtPasteData       myPasteData;
      DtObjectsCopying  myObjectsCopying;
      DtObjectsPasting  myObjectsPasting;
      DtObjectsPasting  myObjectsBeingPasted;
      DtObjectsPasting  myObjectsToPaste;
      DtObjectsDeleting myToDelete;
      DtVrfObjectManipulationEventProcessor*   myEventProcessor;
      int               myMaximumToProcessInPastePass;
      int               myPasteFlags;
      bool myQueueing;
      DtGeodeticCoord   myOrigin;
      DtReferenceEllipsoid myReferenceEllipsoid;

      bool myPreserveOffsets;

      std::set<DtString> myRegisteredNames;
   };
}