rvc/cadtools.h

Go to the documentation of this file.

/****
*  \file rvc/cadtools.h
*  \brief CAD manipulation functions include file
*
*  \if NODOC
*  $Id: cadtools.h_v 1.5 2012/01/18 15:59:20 mju Exp $
*
*  $Log: cadtools.h_v $
*  Revision 1.5  2012/01/18 15:59:20  mju
*  Remove unused method prototype and exclude all private stuff from dox.
*
*  Revision 1.4  2011/12/06 22:49:37  mju
*  Remove unnecessary hdr.
*
*  Revision 1.3  2010/04/26 17:01:29  mju
*  Use unsignedset.
*
*  Revision 1.2  2005/10/20 17:00:29  scowan
*  Quadtree and geometric interface changes supported.
*
*  Revision 1.1  2004/09/01 23:02:04  scowan
*  Initial revision
*  \endif
****/

#ifndef  INC_RVC_CADTOOLS_H
#define  INC_RVC_CADTOOLS_H

#ifndef  INC_RVC_CAD_H
   #include <rvc/cad.h>
#endif

#ifndef  INC_RVC_STYLE_H
   #include <rvc/style.h>
#endif

#ifndef  INC_RVC_HYPERIDX_H
   #include <rvc/hyperidx.h>
#endif

#ifndef  INC_RVC_DBCAD_H
   #include <rvc/dbcad.h>
#endif

#ifndef  INC_RVC_DBTABLE_H
   #include <rvc/dbtable.h>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward Declarations
namespace RVC {
   class CADTOOLKITOBSERVER;
   class CADSTDATT;
   }
#endif // GENERATING_DOXYGEN_OUTPUT


namespace RVC {

class CADTOOLKIT : public SUBJECT<CADTOOLKITOBSERVER> {
   public:

      enum TOOLFLAG {
         TOOLFLAG_None = 0x000,              
         TOOLFLAG_NoQtree = 0x001,           
         TOOLFLAG_NoDBStatTable = 0x002,     
         TOOLFLAG_NoStyle = 0x004,           
         TOOLFLAG_NoDatabase = 0x008,        
         TOOLFLAG_NoHyper = 0x010,           
         TOOLFLAG_NoCreateTables = 0x020,    
         TOOLFLAG_NoCreateStyle = 0x040,     
         TOOLFLAG_IgnoreBadMinMax = 0x080,   
         TOOLFLAG_NoSaveQTree = 0x100        
         };

      enum JOINFLAG {
         JOINFLAG_BestDistance = 0x01,
         JOINFLAG_BestAngle = 0x02,
         JOINFLAG_JoinStart = 0x04,
         JOINFLAG_JoinEnd = 0x08,
         JOINFLAG_JoinBothEnds = 0x0C
         };

      CADTOOLKIT (
         );

      virtual ~CADTOOLKIT (
         );

      INT32 AddElement (
         CAD::ELEMENT& Element
         );

      ERRVALUE AppendBlock (
         INT32 SourceBlock, 
         INT32 DestBlock
         );

      ERRVALUE AppendObject (
         const RVC::OBJITEM& ObjItem
         );

      ERRVALUE BreakElement (
         INT32 ElemNum, 
         const POLYLINE& BreakPoints
         );

      ERRVALUE ChangeCurrentBlock (
         INT32 NewBlock
         );

      ERRVALUE ChangeElement (
         INT32 ElemNum, 
         RVC::CAD::ELEMENT& Element
         );

      ERRVALUE CheckForCyclic (
         INT32 SourceBlock, 
         INT32 InsertBlock
         );

      ERRVALUE Close ();

      ERRVALUE CopyElement (
         INT32 ElemNum,
         const TRANS2D_AFFINE& OldToNew
         );

      ERRVALUE CopyElements (
         const UNSIGNEDSET& set,
         const TRANS2D_AFFINE& OldToNew
         );

      INT32 CreateBlock (
         CADBLOCK& block
         );

      ERRVALUE DeleteBlock (
         UINT32 BlockNum
         );

      ERRVALUE DeleteElement (
         INT32 ElemNum
         );
         
      ERRVALUE ExplodeElement (
         INT32 ElemNum
         );

      INT32 GetBlockDBIndex (
         INT32 BlockNum
         );

      double GetZValue (
         INT32 ElemNum
         );

      bool IsBlockDeleted (
         INT32 BlockNum
         ) const;

      ERRVALUE JoinLine (
         INT32 ElemNum, 
         double MaxAngle, 
         JOINFLAG flags
         );

      ERRVALUE JoinLines (
         const UNSIGNEDSET& set,
         double MaxAngle, 
         JOINFLAG flags
         );

      ERRVALUE MoveElement (
         INT32 ElemNum,
         const TRANS2D_AFFINE& OldToNew
         );

      ERRVALUE MoveElements (
         const UNSIGNEDSET& set,
         const TRANS2D_AFFINE& OldToNew
         );

      ERRVALUE Open (
         const RVC::OBJITEM& ObjItem,
         TOOLFLAG flags
         );

      ERRVALUE Open (
         const RVC::CAD& CadObj,
         TOOLFLAG flags
         );

      ERRVALUE RecoverFromUndo (
         );

      ERRVALUE ReverseLinePoints (
         INT32 ElemNum
         );

      ERRVALUE Save (
         RVC::OBJITEM& ObjItem
         );

      ERRVALUE SaveBlock (
         INT32 BlockNum, 
         RVC::OBJITEM& ObjItem
         );

      ERRVALUE SetBlock (
         UINT32 BlockNum, 
         CADBLOCK& block
         );

      TOOLFLAG SetFlags (
         TOOLFLAG NewFlags
         );

      void SetSearchDist (
         double dist
         ) { m_SearchDist = dist; }

      ERRVALUE SetZValue (
         INT32 ElemNum, 
         double zvalue
         );

      ERRVALUE SortElement (
         INT32 ElemNum, 
         bool ToFront
         );

      ERRVALUE SortElementIndex (
         const BITSET& elemset,
         bool ToFront
         );

      ERRVALUE StraightenLine (
         INT32 ElemNum
         );

      ERRVALUE UpdateStdAttrib (
         UINT32 flags
         );

      ERRVALUE Validate ();

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      class LOCALOBSERVER;
      class EXPLODEDRAW;
      class JOINTABLE;              
         
      struct CBLOCKINFO {
         CADBLOCK m_block;
         bool m_NewBlock;           
         bool m_Deleted;            
         bool m_IsDirty;            
         INT32 m_BlockNum;       
         };

      CAD m_CadObj;
      INT32 m_CurBlock;                   
      INT32 m_ElemIDTableNum;       
      HYPERINDEX m_HyperObj;
      STYLE m_StyleObj;
      TOOLFLAG m_ToolkitFlags;
      CADSTDATT *m_sdh;             
      DBASE_CAD m_DBaseObj;
      DBTABLE::RECORD m_Record;
      SIMPLE_ARRAY<DBLISTELMT> m_DBList;
      SIMPLE_ARRAY<CBLOCKINFO> m_BlockList;
      double m_CurZValue;                 
      double m_SearchDist;
      bool m_HasDftZValue;                
      bool m_HasMinMax;
      bool m_IgnoreAddDBList;
      bool m_HasSearchTree;
      LOCALOBSERVER *m_Observer;

      ERRVALUE AddElemDBList (INT32 ElemNum);
      ERRVALUE AddQTreeElem (INT32 elemnum, const DRECT2D& Extents);
      ERRVALUE BuildQTree(INT32 BlockNum);

      void CallOnAdd (INT32 ElemNum);
      void CallOnAddBlock (INT32 BlockNum);
      void CallOnChangeBlock (INT32 BlockNum);
      void CallOnDelete (INT32 ElemNum);
      void CallOnDeleteBlock (INT32 BlockNum);
      void CallOnJoinBegin (INT32 ElemNum, INT32 OtherElemNum);
      void CallOnJoinEnd (INT32 ElemNum);
      void CallOnMoveBegin (INT32 ElemNum);
      void CallOnMoveEnd (INT32 ElemNum);
      void CallOnSortBegin (INT32 ElemNum);
      void CallOnSortEnd (INT32 ElemNum);
      void CallOnSplitBegin (INT32 ElemNum);
      void CallOnSplitEnd (INT32 ElemNum, INT32 OtherElemNum);
      
      ERRVALUE ChangeQTreeElem (
         INT32 ElemNum,
         const DRECT2D& Extents
         ) { return (CopyQTreeElem(ElemNum, ElemNum, Extents)); }

      ERRVALUE ComputeJoinLine (SIMPLE_ARRAY<JOINTABLE>& JoinTable, INT32 ElemNum, double MaxAngle, JOINFLAG flags);
      INT32 ComputeJoinLineNumber (INT32 ElemNum, int useend, DPOINT2D *endpts, double MaxAngle, bool& JoinEnd, JOINFLAG flags);
      INT32 CopyDBRecordRaw (INT32 TableNum, INT32 SourceRecord, INT32 DestRecord);
      ERRVALUE CopyDBRecords (INT32 SourceElem, INT32 DestElem);
      ERRVALUE CopyQTreeElem (INT32 source, INT32 dest, const DRECT2D& Extents);
      ERRVALUE DeleteBlockRaw (INT32 blocknum);
      ERRVALUE DeleteQTreeElem (INT32 elemnum, const DRECT2D& Extents);
      ERRVALUE GetBlockInsertList (INT32 BlockNum, BITSET& BlockSet);
      ERRVALUE JoinLineRaw (SIMPLE_ARRAY<JOINTABLE>& JoinTable, INT32 ElemNum, INT32 JoinElemNum, bool start, bool JoinEnd);
      ERRVALUE OpenBlocks ();
      ERRVALUE SaveBlockRaw (CAD& DestCadObj, INT32 sblocknum, INT32 dblocknum, SIMPLE_ARRAY<INT32>& BlockTrans);
      
      // Disallowed.
      CADTOOLKIT (const CADTOOLKIT& rhs);
      CADTOOLKIT operator= (const CADTOOLKIT& rhs);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(CADTOOLKIT::JOINFLAG)
DEFINE_ENUM_OP_BITWISE(CADTOOLKIT::TOOLFLAG)
#endif

class CADTOOLKITOBSERVER : public OBSERVER_BASE {
   public:

      CADTOOLKITOBSERVER (
         CADTOOLKIT& ctk
         ) :
         OBSERVER_BASE(ctk)
         {}
         
      virtual ~CADTOOLKITOBSERVER (
         ) {}
         
      virtual void OnAdd (
         INT32 ElemNum
         );
         
      virtual void OnAddBlock (
         INT32 BlockNum
         );

      virtual void OnChangeBlock (
         INT32 BlockNum
         );

      virtual void OnDelete (
         INT32 ElemNum
         );
         
      virtual void OnDeleteBlock (
         INT32 BlockNum
         );

      virtual void OnJoinBegin (
         INT32 ElemNum,
         INT32 OtherElemNum
         );

      virtual void OnJoinEnd (
         INT32 ElemNum
         );
         
      virtual void OnMoveBegin (
         INT32 ElemNum
         );

      virtual void OnMoveEnd (
         INT32 ElemNum
         );

      virtual void OnSplitBegin (
         INT32 ElemNum
         );
         
      virtual void OnSplitEnd (
         INT32 ElemNum,
         INT32 OtherElemNum
         );
            
      virtual void OnSortBegin (
         INT32 ElemNum
         );

      virtual void OnSortEnd (
         INT32 ElemNum
         );
            
   };

}     // End of RVC namespace

#endif      // INC_RVC_CADTOOLS_H

---