vecttool.h

Go to the documentation of this file.

/****
*  \file rvc/vecttool.h
*  \brief Vector toolkit include file
*
*  \if NODOC
*  $Id: vecttool.h_v 1.44 2004/10/29 22:59:26 scowan Exp $
*
*  $Log: vecttool.h_v $
*  Revision 1.44  2004/10/29 22:59:26  scowan
*  Added internal class yet again.
*
*  Revision 1.43  2004/09/28 17:03:20  scowan
*  Added parameter to method.
*
*  Revision 1.42  2004/09/14 22:09:09  scowan
*  Added validate flag to not build std attrib tables.
*
*  Revision 1.41  2004/07/29 15:55:16  scowan
*  Added set precision method.
*
*  Revision 1.40  2004/07/13 13:58:16  scowan
*  Removed use of geo region methods.
*
*  Revision 1.39  2004/03/02 21:01:40  scowan
*  Removed unnecessary include files.
*
*  Revision 1.38  2004/02/04 21:51:47  scowan
*  Added YAC.
*
*  Revision 1.37  2004/02/04 21:44:30  scowan
*  Added panel for snap parms dialog.
*
*  Revision 1.36  2004/01/15 22:59:37  scowan
*  Added new clip to region methods.
*
*  Revision 1.35  2004/01/09 23:02:08  scowan
*  Added inline.
*
*  Revision 1.34  2004/01/06 23:43:48  scowan
*  Added inline method.
*
*  Revision 1.33  2003/11/06 18:24:26  scowan
*  Added inline method to node class.
*
*  Revision 1.32  2003/10/31 16:31:23  scowan
*  Added node delete flag.
*
*  Revision 1.31  2003/10/16 20:16:32  scowan
*  Passed mi string instead of file pointer for log in validate.
*
*  Revision 1.30  2003/10/08 22:21:08  scowan
*  Doxygen adjustments.
*
*  Revision 1.29  2003/09/30 16:52:06  dwilliss
*  Doxygen
*
*  Revision 1.28  2003/09/25 21:56:58  dwilliss
*  doxygen
*
*  Revision 1.27  2003/09/15 13:49:45  fileserver!dwilliss
*  Doxygen
*
*  Revision 1.26  2003/08/15 17:48:54  scowan
*  Added ctor to node line angle struct to remove UMR reports.
*
*  Revision 1.25  2003/07/07 16:31:21  scowan
*  Added new observable option.
*
*  Revision 1.24  2003/07/03 14:37:05  scowan
*  Added method.
*
*  Revision 1.23  2003/03/25 18:08:02  scowan
*  Moved internal methods from private to public.
*
*  Revision 1.22  2003/03/07 18:43:59  scowan
*  nc.
*
*  Revision 1.21  2003/02/17 17:32:54  scowan
*  Removed unnecessary variables and added a polygon attribute class.
*
*  Revision 1.20  2003/02/05 23:03:31  scowan
*  Fixed UMR.
*
*  Revision 1.19  2003/01/23 23:02:50  scowan
*  Modified inline method.
*
*  Revision 1.18  2003/01/23 16:14:00  scowan
*  Added method.
*
*  Revision 1.17  2003/01/22 20:52:15  scowan
*  Moved ctor for snap object to non-inline.
*
*  Revision 1.16  2003/01/17 20:13:28  scowan
*  Added methods to get the node database.
*
*  Revision 1.15  2002/10/24 22:21:03  scowan
*  Made dtors virtual.
*
*  Revision 1.14  2002/10/08 14:42:32  scowan
*  Moved forward declaration.
*
*  Revision 1.13  2002/10/04 21:19:07  scowan
*  Multiple little changes.
*
*  Revision 1.12  2002/06/27 14:32:50  scowan
*  Added parameter.
*
*  Revision 1.11  2002/05/15 20:13:30  dwilliss
*  Share, damn it!
*
*  Revision 1.10  2002/05/15 19:58:38  dwilliss
*  Can't we all just be friends?
*
*  Revision 1.9  2002/04/15 19:58:06  scowan
*  Adjusted get database method.
*
*  Revision 1.8  2002/04/08 16:34:14  scowan
*  Fixed database name chages.
*
*  Revision 1.7  2001/11/07 21:41:42  scowan
*  Method parametyer change.
*
*  Revision 1.6  2001/10/23 17:46:03  scowan
*  *** empty log message ***
*
*  Revision 1.5  2001/10/12 14:57:31  scowan
*  Added save flag.
*
*  Revision 1.4  2001/10/08 21:03:00  scowan
*  Added methods to clip to a region.
*
*  Revision 1.3  2001/09/19 16:47:46  scowan
*  Fixed MAC errors.
*
*  Revision 1.2  2001/09/18 14:12:23  scowan
*  Moved std att include file.
*
*  Revision 1.1  2001/09/18 13:56:22  scowan
*  Initial revision
*
*  \endif
****/

#ifndef  INC_RVC_VECTTOOL_H
#define  INC_RVC_VECTTOOL_H

#ifndef  INC_MI32_ELEMTYPE_H
   #include <mi32/elemtype.h>
#endif

#ifndef  INC_MI32_SIMPLEAR_H
   #include <mi32/simplear.h>
#endif

#ifndef  INC_MI32_BITSET_H
   #include <mi32/bitset.h>
#endif

#ifndef  INC_RVC_VECTOR_H
   #include <rvc/vector.h>
#endif

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

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

#ifndef  INC_MI32_OBSERVER_H
   #include <mi32/observer.h>
#endif

#ifndef  INC_RVC_MSTDATT_H
   #include <rvc/mstdatt.h>
#endif

#ifndef  INC_RVC_DBPOINT_H
   #include <rvc/dbpoint.h>
#endif

#ifndef  INC_RVC_DBLINE_H
   #include <rvc/dbline.h>
#endif

#ifndef  INC_RVC_DBPOLY_H
   #include <rvc/dbpoly.h>
#endif

#ifndef  INC_RVC_DBNODE_H
   #include <rvc/dbnode.h>
#endif

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

#ifndef  INC_RVC_LIST_H
   #include <rvc/list.h>
#endif

#ifndef  INC_MI32_POLYLINE_H
   #include <mi32/polyline.h>
#endif

#include <vector>

#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward Declarations
class REGION2D;
#endif // GENERATING_DOXYGEN_OUTPUT

namespace RVC {

#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward Declarations
class VECTORTOOLKITOBSERVER;
#endif // GENERATING_DOXYGEN_OUTPUT

//! \class VECTORTOOLKIT rvc/vecttool.h
//! \brief Vector Toolkit
//!
class VECTORTOOLKIT : public SUBJECT<VECTORTOOLKITOBSERVER> {
   private:

      #ifndef GENERATING_DOXYGEN_OUTPUT
      class LINEELEMENT;
      #endif // GENERATING_DOXYGEN_OUTPUT
      
   public:

      #ifndef GENERATING_DOXYGEN_OUTPUT
      class POLYGONDELETEFILTER;
      #endif // GENERATING_DOXYGEN_OUTPUT

      class SNAPOBJECT {
         public:
         
            SNAPOBJECT (
               );
               
            ~SNAPOBJECT (
               );
               
            const RVC::VECTOR& GetVectorObject (
               ) const { return (m_VectorObj); }
               
            const TRANS2D_MAPGEN& GetTransGen (
               ) const { return (m_VectorToObject); }
               
            bool IsSameAsEditor (
               ) const { return (m_SameAsEditor); }
               
            void SetValues (
               const VECTORTOOLKIT& vtk
               );
               
            void SetValues (
               const VECTOR& VectorObj,
               const TRANS2D_MAPGEN& VectorToObject
               );
               
         private:
         
            #ifndef GENERATING_DOXYGEN_OUTPUT
            bool m_SameAsEditor;
            VECTOR m_VectorObj;
            TRANS2D_MAPGEN m_VectorToObject;
            friend class VECTORTOOLKIT;
            friend class LINEELEMENT;
            
            SNAPOBJECT (const VECTORTOOLKIT& vtk);
               
            SNAPOBJECT& operator= (const SNAPOBJECT& rhs);
            #endif // GENERATING_DOXYGEN_OUTPUT
               
         };
      friend class SNAPOBJECT;
      
      class SNAPPARMS {
         public:
         
            class PANEL;

            enum SNAPTOELEM {
               SNAPTOELEM_AnyElement = 0,
               SNAPTOELEM_Line,
               SNAPTOELEM_Point,
               SNAPTOELEM_Node,
               SNAPTOELEM_Nothing,
               SNAPTOELEM_Vertex
               };

            enum SNAPTYPE {
               SNAPTYPE_AddVertexSnap = 0,
               SNAPTYPE_DirectSnap,
               SNAPTYPE_ContinueSnap
               };
               
            enum SNAPEND {
               SNAPEND_Both = 0,
               SNAPEND_Start,
               SNAPEND_End
               };
               
            SNAPPARMS (
               );
               
            bool CanCrossLines (
               ) const { return (!m_DontCrossLines); }

            bool CanRemoveOvershoots (
               ) const { return (m_RemOvershoots); }

            bool CanSnapToSelf (
               ) const { return (!m_DontSnapToSelf); }

            SNAPTOELEM GetElementSnap (
               ) const { return (m_SnapToElem); }

            UINT32 GetLegacyFlags (
               ) const;
               
            double GetSnapBackAngle (
               ) const { return (m_SnapBackAngle); }
               
            double GetSnapDist (
               ) const { return (m_SnapDist); }
               
            SNAPEND GetSnapEnd (
               ) const { return (m_SnapEnd); }
               
            SNAPTYPE GetSnapType (
               ) const { return (m_SnapType); }
               
            void SetCrossLines (
               bool CrossLines
               ) { m_DontCrossLines = !CrossLines; }

            void SetElementSnap (
               SNAPTOELEM element
               ) { m_SnapToElem = element; }
               
            void SetFromLegacyFlags (
               UINT32 flags
               );
               
            void SetRemoveOvershoots (
               bool RemoveOvershoots
               ) { m_RemOvershoots = RemoveOvershoots; }

            void SetSnapBackAngle (
               double angle
               ) { m_SnapBackAngle = bound(angle, 0.0, PI); }
               
            void SetSnapDist (
               double dist
               ) { m_SnapDist = dist; }
               
            void SetSnapEnd (
               SNAPEND SnapEnd
               ) { m_SnapEnd = SnapEnd; }
               
            void SetSnapToSelf (
               bool SnapToSelf
               ) { m_DontSnapToSelf = !SnapToSelf; }

            void SetSnapType (
               SNAPTYPE SnapType
               ) { m_SnapType = SnapType; }
               
         private:

            #ifndef GENERATING_DOXYGEN_OUTPUT
            SNAPTOELEM m_SnapToElem;   
            SNAPTYPE m_SnapType; 
            SNAPEND m_SnapEnd;
            double m_SnapDist;
            double m_SnapBackAngle;             //!<  Allowable variation of angle of snap point to differ with the line segment 
            bool m_RemOvershoots;
            bool m_DontCrossLines;
            bool m_DontSnapToSelf;
            #endif // GENERATING_DOXYGEN_OUTPUT
            
         };
      
      enum CLIPFLAGS {
         CLIPFLAG_None = 0x00000000,               //!< Nothing
         CLIPFLAG_ForceClipBorder = 0x00000200,    //!< Force the clip routine to add a border
         CLIPFLAG_NoClipBorder = 0x00000400,       //!< Force the clip routine to not add any border
         CLIPFLAG_OnlyClipLines = 0x00000800,      //!< Do not bother with the points and labels
         CLIPFLAG_NoStdAttrib = 0x00001000,        //!< Avoid standard attribute rebuild in validate
         CLIPFLAG_RemUnusedDBRec = 0x00002000      //!< Removed unattached database records
         };
         
      enum DELETELINE {
         DELETELINE_None = 0x0000,
         DELETELINE_RemoveExcessNodes = 0x0001
         };
         
      enum DELETEPOLYGON {
         DELETEPOLYGON_None = 0x0000,
         DELETEPOLYGON_LongLineDelete = 0x0001,
         DELETEPOLYGON_NoDeleteSpurs = 0x0002,
         DELETEPOLYGON_CombineAttrib = 0x0004,
         DELETEPOLYGON_RemoveAllIslands = 0x0008
         };
         
      enum TOOLKITFLAG {
         TOOLKITFLAG_None = 0x00,
         TOOLKITFLAG_NoConvIfElemID = 0x01,        //!< Do not convert node to point if element ID attachment only
         TOOLKITFLAG_RemExNodesDelLine = 0x02,     //!< Delete excess nodes when deleting lines
         TOOLKITFLAG_NoStatusText = 0x04,          //!< Do not show status text
         TOOLKITFLAG_NoSaveQTree = 0x08,           //!< Do not save search tree in MfvClose() or MfvStop()
         TOOLKITFLAG_NoCreateElemID = 0x10,        //!< Do not create element ID tables
         TOOLKITFLAG_NoQTrees = 0x20,              //!< Do not create search trees
         TOOLKITFLAG_KeepAttachedLabels = 0x40     //!< Keep attached labels after elements attached are gone
         };
         
      enum OPENFLAGS {
         OPENFLAGS_None = 0x00000000,
         OPENFLAGS_NoQtree = 0x00000001,
         OPENFLAGS_NoLineQtree = 0x00000002,
         OPENFLAGS_NoNodeQtree = 0x00000004,
         OPENFLAGS_NoPolygonQtree = 0x00000008,
         OPENFLAGS_NoPointQtree = 0x00000010,
         OPENFLAGS_NoLabelQtree = 0x00000020,
         OPENFLAGS_NoDatabase = 0x00000040,
         OPENFLAGS_NoCreateTables = 0x00000080,
         OPENFLAGS_NoCreateElemID = 0x00000100,
         OPENFLAGS_NoDBStatTable = 0x00000200,
         OPENFLAGS_NoCreateStyle = 0x00000400,
         OPENFLAGS_NoChangeTopoType = 0x00000800,
         OPENFLAGS_NoHyper = 0x00001000,
         OPENFLAGS_NoStyle = 0x00002000,
         OPENFLAGS_NoValidateNodes = 0x00004000,
         OPENFLAGS_WriteAbsolute = 0x00008000,
         OPENFLAGS_NoLegacyDelete = 0x00010000
         };
         
      enum SAVEFLAGS {
         SAVEFLAG_None = 0x0000,
         SAVEFLAG_RemoveExcessNodes = 0x0001,
         SAVEFLAG_RemoveExcessRecords = 0x0002,
         SAVEFLAG_Optimize = 0x0004
         };
         
      enum STDATTRIBSTATE {
         STDATTRIBSTATE_NonExistant = 1,
         STDATTRIBSTATE_NeedRebuilding,
         STDATTRIBSTATE_Valid
         };
         
      enum VALIDATEFLAG {
         VALIDATEFLAG_None =                    0x0000,
         VALIDATEFLAG_RebuildPolys =            0x0001,
         VALIDATEFLAG_RebuildIslands =          0x0002,
         VALIDATEFLAG_RebuildNodeLineList =     0x0004,
         VALIDATEFLAG_DontValidateZ =           0x0008,
         VALIDATEFLAG_NoRemoveNodes =           0x0080,
         VALIDATEFLAG_NoDBStatTable =           0x0100            //!< Do not build and / or update the standard attribute tables
         };
         
      enum NODEFLAG {
         NODEFLAG_None =            0x0000,
         NODEFLAG_NoCheckDatabase = 0x0001,
         NODEFLAG_NoCheckHyper =    0x0002,
         NODEFLAG_NoStdAttrib =     0x0004,
         NODEFLAG_RemoveIfPoint =   0x0008
         };
         
      //! Rebuild vector polygons from scratch, does not maintain attribute attachment
      static ERRVALUE BuildPolygons (
         VECTOR& VectObj
         );

      //! Determine islands by depth sort algorithm      
      static ERRVALUE DepthSortPolygons (
         VECTOR& VectObj
         );

      //! Remove excess nodes from a vector object    
      static ERRVALUE RemoveExcessNodes (
         VECTOR& VectObj,
         NODEFLAG flags
         );

      //! Split lines at max points if necessary
      //! @return > 0 if lines split into new object, 0 if not, < 0 if error
      static int SplitLinesAtMaxPoints (
         const VECTOR& VectorObj,
         INT32 MaxPoints,
         OBJECT& ParentObj,
         VECTOR& NewObject
         );
         
      //! Validate vector element ID tables
      static ERRVALUE ValidateElementID (
         VECTOR& VectorObj
         );
         
      //! Validate vector topology     
      static ERRVALUE ValidateVectorTopology (
         VECTOR& VectorObj,
         MISTRING& LogString,
         OPENFLAGS OpenFlags,
         VALIDATEFLAG flags
         );
         

      //! Default constructor
      VECTORTOOLKIT (
         );

      //! Destructor
      ~VECTORTOOLKIT (
         );
         
      ERRVALUE AddLabel (
         VECTOR::LABEL& label
         );
      
      ERRVALUE AddLine (
         POLYLINE& PolyLine
         );
      
      ERRVALUE AddLineSnapPoints (
         INT32 LineNum,
         POLYLINE& PolyLine
         );
         
      ERRVALUE AddNode (
         DPOINT3D& point         //!< Position of added node will most likely change
         );
      
      ERRVALUE AddPoint (
         const DPOINT3D& pt
         );
      
      ERRVALUE AddPolygon (
         POLYLINE& PolyLine
         );
         
      ERRVALUE AddSnapPoints (
         POLYLINE& PolyLine,
         bool& SnappedStart,
         bool& SnappedEnd
         );
         
      ERRVALUE BuildPolygons (
         );
         
      ERRVALUE ChangeLabel (
         INT32 LabelNum,
         VECTOR::LABEL& label
         );
         
      ERRVALUE ChangeLine (
         INT32 LineNum,
         POLYLINE& PolyLine
         );
         
      ERRVALUE ChangeNode (
         INT32 NodeNum,
         const DPOINT3D& NewPoint,
         const std::vector<POLYLINE>& NodeLines
         );
         
      ERRVALUE ChangePoint (
         INT32 PointNum,
         const DPOINT3D& pt,
         bool IsNode = false
         );
      
      ERRVALUE ClipToRegion (
         const REGION2D& region,
         TESTCRITERIA RegionTest,
         const BITSET* PolygonSet,
         CLIPFLAGS flags
         );
         
      ERRVALUE Close (
         bool ForceClose
         );
         
      ERRVALUE CombineNodes (
         INT32 NodeNum,
         const DPOINT3D* NewPoint,                 //!< Location of new node
         const SIMPLE_ARRAY<INT32>& NodeList       //!< List of Nodes to combine
         );
         
      ERRVALUE ConvertForward (
         const TRANS2D_MAPGEN& tmg
         );
         
      ERRVALUE ConvertNodeToPoint (
         INT32 NodeNum
         );
      
      ERRVALUE ConvertPointType (
         GEOMETRIC::POINTTYPE NewPointType
         );
         
      ERRVALUE DeleteLabel (
         INT32 LabelNum
         );
         
      ERRVALUE DeleteLabels (
         const SIMPLE_ARRAY<INT32>& LabelList
         );
         
      ERRVALUE DeleteLine (
         INT32 LineNum,
         DELETELINE flags,
         POLYGONDELETEFILTER* PolyDelFilt = 0
         );
         
      ERRVALUE DeleteLines (
         const SIMPLE_ARRAY<INT32>& LineList,
         DELETELINE flags,
         POLYGONDELETEFILTER* PolyDelFilt = 0
         );
         
      INT32 DeleteNode (
         INT32 NodeNum,
         NODEFLAG NodeFlag
         );
         
      ERRVALUE DeleteNodes (
         const SIMPLE_ARRAY<INT32>& NodeList,
         NODEFLAG NodeFlag
         );
      
      ERRVALUE DeletePoint (
         INT32 PointNum
         );
         
      ERRVALUE DeletePoints (
         const SIMPLE_ARRAY<INT32>& PointList
         );
         
      ERRVALUE DeletePolygon (
         INT32 PolyNum,
         DELETEPOLYGON flags
         );
         
      ERRVALUE DeletePolygons (
         SIMPLE_ARRAY<INT32>& PolyList,
         DELETEPOLYGON flags
         );
         
      ERRVALUE ExtractToRegion (
         const REGION2D& region,
         TESTCRITERIA RegionTest,
         CLIPFLAGS flags
         );
         
      INT32 FindClosestLineVertex (
         INT32 LineNum,
         const DPOINT2D& testpt,
         DPOINT3D *retpt
         );
         
      ERRVALUE GenerateElementIDTables (
         );
         
      ERRVALUE GenerateIntersections (
         const POLYLINE& PolyLine,
         POLYLINE::INTERSECTINFO& ints,
         INT32 MaxIntersections = 0
         );
         
      DIMENSION GetDimension (
         ) const { return (m_VectorObj.GetDimension()); }
         
      ERRVALUE GetDatabaseObject (
         ELEMTYPE ElemType,
         DBASE_ELEMENT& DBaseObj
         );
         
      INT32 GetNumElements (
         ELEMTYPE ElemType
         ) const;
         
      ERRVALUE GetObjectItem (
         OBJITEM& ObjItem
         ) const;
         
      const SNAPOBJECT& GetSnapObject (
         ) { return (m_SnapObject); }

      const SNAPPARMS& GetSnapParms (
         ) const { return (m_SnapParms); }
         
      ERRVALUE GetStyleObject (
         STYLE& StyleObj
         ) const;
         
      TOOLKITFLAG GetToolkitFlags (
         ) const { return (m_ToolkitFlags); }
         
      ERRVALUE GetVectorObject (
         VECTOR& VectorObj
         ) const;
         
      ERRVALUE GetZValue (
         ELEMTYPE ElemType,
         INT32 ElemNum,
         double& zvalue
         ) const;
         
      bool IsOpen (
         ) const { return (m_VectorObj.IsOpen()); }
      
      ERRVALUE LocateIslands (
         bool LineLeftRightValid
         );
            
      ERRVALUE Open (
         const RVC::OBJITEM& ObjItem,
         OPENFLAGS flags
         );
         
      ERRVALUE Open (
         const VECTOR& VectorObj,
         OPENFLAGS flags
         );
         
      ERRVALUE RecoverFromUndo (
         );
      
      int RemoveDangleLine (
         INT32 LineNum,
         double maxdist       //!< Remove line if smaller than this value
         );
         
      INT32 RemoveDangleLineSet (
         double maxdist
         );
         
      INT32 RemoveDangleLineSet (
         const SIMPLE_ARRAY<INT32>& LineList,
         double maxdist
         );
         
      ERRVALUE RemoveElementIDTables (
         );
         
      int RemoveExcessNodes (
         const BITSET *NodeSet = 0,
         NODEFLAG NodeFlags = NODEFLAG_None
         );
         
      INT32 RemoveIslandSet (
         double MaxArea,
         DELETEPOLYGON flags,
         INT32 *NumTotalIslands
         );
         
      ERRVALUE RemoveStandardAttributeTables (
         );
         
      ERRVALUE ReverseLines (
         const SIMPLE_ARRAY<INT32>& LineList
         );
         
      ERRVALUE Save (
         RVC::OBJITEM& ObjItem,
         SAVEFLAGS flags
         );
         
      ERRVALUE SnapLine (
         INT32 LineNum
         );
         
      ERRVALUE SnapLines (
         const BITSET_UNOWNED& LineSet,
         BITSET* UnsnappedSet,
         bool AttemptAllElements
         );
         
      ERRVALUE SetPrecision (
         int Precision
         );
         
      void SetSnapObject (
         );
         
      void SetSnapObject (
         const VECTOR& VectorObj,
         const TRANS2D_MAPGEN& VectorToObject
         );
         
      void SetSnapParms (
         const SNAPPARMS& SnapParms
         ) { m_SnapParms = SnapParms; }

      void SetToolkitFlags (
         TOOLKITFLAG ToolkitFlags
         ) { m_ToolkitFlags = ToolkitFlags; }

      ERRVALUE SetTopologyType (
         VECTOR::TOPOLOGYTYPE VectorType
         );
         
      ERRVALUE SetZValue (
         ELEMTYPE ElemType,
         INT32 ElemNum,
         double zvalue
         );
         
      ERRVALUE SplineLine (
         INT32 LineNum,
         POLYLINE::SPLINE SplineType,
         INT32 NumKnots,
         double Tolerance,
         POLYLINE::SPLINEFLAGS flags
         );
         
      ERRVALUE SplineLines (
         const BITSET* LineList,       //!<  Can be NULL 
         POLYLINE::SPLINE SplineType,
         INT32 NumKnots,
         double Tolerance,
         POLYLINE::SPLINEFLAGS flags,
         bool AttemptAllElements
         );
      
      ERRVALUE SplitLineAtMaxPoints (
         INT32 MaxPoints,
         bool SetMaxPoints
         );
         
      ERRVALUE StraightenLine (
         INT32 LineNum
         );
         
      ERRVALUE ThinLine (
         INT32 LineNum,
         POLYLINE::THINMETHOD method,
         double Factor,
         POLYLINE::SPLINE SplineType,
         POLYLINE::SPLINEFLAGS flags
         );
         
      ERRVALUE ThinLines (
         const BITSET* LineList,       //!<  Can be NULL 
         POLYLINE::THINMETHOD method,
         double Factor,
         POLYLINE::SPLINE SplineType,
         POLYLINE::SPLINEFLAGS flags,
         bool AttemptAllElements
         );
         
      ERRVALUE Update (
         );
         
      ERRVALUE UpdateStandardAttrib (
         MSTDATT::ADDSTAT flags
         );
         
      STDATTRIBSTATE ValidateStandardAttribTables (
         );
         
      ERRVALUE ValidateTopology (
         VALIDATEFLAG flags,
         MISTRING& LogString
         );
         
   private:

      #ifndef GENERATING_DOXYGEN_OUTPUT
      enum LINEORIENT {
         LINEORIENT_Start = 0,
         LINEORIENT_End
         };

      class BASEELEMENT {
         public:
         
            BASEELEMENT (
               VECTORTOOLKIT& vtk,
               ELEMTYPE elemtype
               );
               
            virtual ~BASEELEMENT (
               );

            virtual INT32 GetNumElements (
               ) const = 0;
               
            virtual ERRVALUE GetZValue (
               INT32 ElemNum,
               double& zvalue
               ) const = 0;
               
            virtual ERRVALUE SetZValue (
               INT32 ElemNum,
               double zvalue
               ) = 0;
               
            ERRVALUE AddQTreeElem (
               INT32 elemnum,
               const DRECT2D& Extents
               );
               
            ERRVALUE BuildQTree (
               );
               
            ERRVALUE ChangeQTreeElem (
               INT32 ElemNum,
               const DRECT2D& Extents
               ) { return (CopyQTreeElem(ElemNum, ElemNum, Extents)); }
               
            ERRVALUE ClearQTree (
               const DRECT2D& Extents,
               INT32 NumElements
               );
               
            void CloseBase (
               );
               
            ERRVALUE CopyQTreeElem (
               INT32 source,
               INT32 dest,
               const DRECT2D& Extents
               );
               
            ERRVALUE DeleteQTreeElem (
               INT32 elemnum
               );
               
            void DisableQTree (
               ) { m_DisableQTree = true; }
               
            bool HasSearchTree (
               ) const { return (m_HasSearchTree); }
            
            bool IsQTreeDisabled (
               ) const { return (m_DisableQTree); }
               
            ERRVALUE Open (
               OPENFLAGS flags
               );
               
            ERRVALUE RecoverFromUndo (
               );
               
         protected:
         
            ELEMTYPE m_ElemType;
            VECTORTOOLKIT& m_vtk;
            bool m_DisableQTree;
            bool m_HasSearchTree;
            
            friend class SNAPOBJECT;
            
         };
      friend class BASEELEMENT;

      class DATABASEELEMENT : public BASEELEMENT {
         public:
         
            DATABASEELEMENT (
               VECTORTOOLKIT& vtk,
               ELEMTYPE elemtype,
               DBASE_ELEMENT& Database
               );
               
            virtual ~DATABASEELEMENT (
               );
               
            virtual INT32 GetElemIDCount (
               ) const = 0;
               
            virtual bool HasStatHandle (
               ) const { return (false); }
               
            virtual ERRVALUE SetElemIDCount (
               INT32 NewValue
               ) = 0;
               
            virtual ERRVALUE ValidateElementIDTable (
               );
         
            ERRVALUE AddElemDBList (
               INT32 ElemNum
               );
         
            ERRVALUE Close (
               );
               
            ERRVALUE CombineDBLists (
               INT32 SourceElem,
               INT32 DestElem
               );
               
            int CompareDBLists (
               INT32 ElemNum1,
               INT32 ElemNum2
               );
               
            INT32 CopyDBRecordRaw (
               INT32 TableNum,
               INT32 SourceRecord,
               INT32 DestRecord
               );
               
            ERRVALUE CopyElemDBRecords (
               INT32 SourceElem,
               INT32 DestElem,
               bool DeleteIdentityRecord
               );
               
            ERRVALUE GenerateElementIDTable (
               );
               
            SIMPLE_ARRAY<DBLISTELMT>& GetDBListBuffer (
               ) { return (m_DBList); }
               
            ERRVALUE GetElementIDTable (
               ) const { return (m_ElemIDTableNum); }
               
            DBASE_ELEMENT& GetDatabase (
               ) { return (m_Database); }
            
            bool HasElementIDTable (
               ) const { return (m_ElemIDTableNum >= 0); }
               
            ERRVALUE MakeElementIDTable (
               bool SetInvalid
               );
               
            ERRVALUE Open (
               OPENFLAGS flags
               );
         
            ERRVALUE RecoverFromUndo (
               );
         
            ERRVALUE RemoveElementIDTable (
               );
               
            ERRVALUE RemoveTable (
               INT32 TableNum
               );
               
            ERRVALUE SwapDBRecords (
               INT32 ElemNum1,
               INT32 ElemNum2,
               bool DeleteElemNum2Records       //!<  If 1, the 'elem1' record is to be overwritten and 'elem2' records are to be deleted 
               );
               
            ERRVALUE UpdateCurrentElemID (
               INT32 ElemNum
               );
               
            ERRVALUE UpdateNumElements (
               INT32 NumElements
               );
               
         protected:
         
            class LOCALOBSERVER : public DBASE::OBSERVER {
               public:
               
                  LOCALOBSERVER (
                     DBASE_ELEMENT& Database,
                     INT32& ElemIDTableNum
                     ) : DBASE::OBSERVER(Database), m_ElemIDTableNum(ElemIDTableNum) {}
               
               private:
                  virtual void OnTableDropEnd (INT32 TableNum);
               
                  INT32& m_ElemIDTableNum;
               };
         
            DBASE_ELEMENT& m_Database;
            INT32 m_ElemIDTableNum;       //!< Element ID table number
            DBTABLE::RECORD m_Record;
            SIMPLE_ARRAY<DBLISTELMT> m_DBList;
            bool m_MaintainElementIDTables;
            LOCALOBSERVER* m_Observer;
         
            void AllocateObserver (
               DBASE_ELEMENT& Database
               );
               
         };
      friend class DATABASEELEMENT;
      
      class STATELEMENT : public DATABASEELEMENT {
         public:
         
            class DISABLESTATS {
               public:
               
                  DISABLESTATS (
                     STATELEMENT& StatElem,
                     bool Condition
                     ) : m_StatElem(StatElem), m_TempSdh(0), m_Condition(Condition && StatElem.m_sdh != 0) {
                     if (Condition) {
                        m_TempSdh = StatElem.m_sdh;
                        StatElem.m_sdh = 0;
                        }
                     }
                     
                  ~DISABLESTATS (
                     ) {
                     if (m_Condition) {
                        m_StatElem.m_sdh = m_TempSdh;
                        if (m_StatElem.m_sdh != 0) {
                           ERRORPOSNDISABLE Disable;
                           m_StatElem.m_sdh->RebuildTable(MSTDATT::ADDSTAT_None);
                           }
                        }
                     }
                     
                  bool IsDisabled (
                     ) const { return (m_TempSdh != 0 && m_StatElem.m_sdh == 0); }
               
               private:
                  STATELEMENT& m_StatElem;
                  VECTSTDATT* m_TempSdh;
                  bool m_Condition;
               };
            friend class DISABLESTATS;
            
            STATELEMENT (
               VECTORTOOLKIT& vtk,
               ELEMTYPE elemtype,
               DBASE_ELEMENT& Database
               );
               
            virtual ~STATELEMENT (
               );
         
            virtual bool HasStatHandle (
               ) const { return (m_sdh != 0); }
               
            void CloseStat (
               );
               
            ERRVALUE Close (
               );
               
            INT32 GetNumRecords (
               ) const;
               
            bool IsInitialized (
               ) const { return (m_sdh != 0); }
               
            ERRVALUE Open (
               OPENFLAGS flags
               );
               
            ERRVALUE RebuildTable (
               MSTDATT::ADDSTAT flags
               );
         
            ERRVALUE RecoverFromUndo (
               );
               
            ERRVALUE RemoveStatTable (
               );
               
         protected:
            VECTSTDATT *m_sdh;               //!< Standard attribute manager handle
            bool m_MaintainStdAttribIDTables;
         };
      friend class STATELEMENT;
      
      class LINEELEMENT : public STATELEMENT {
         public:
         
            enum LINESNAP {
               LINESNAP_None = 0x0000,
               LINESNAP_ForceNode = 0x0001
               };

            LINEELEMENT (
               VECTORTOOLKIT& vtk
               );
               
            virtual ~LINEELEMENT (
               );
               
            virtual INT32 GetElemIDCount (
               ) const;
               
            virtual INT32 GetNumElements (
               ) const;

            virtual ERRVALUE GetZValue (
               INT32 ElemNum,
               double& zvalue
               ) const;
               
            virtual ERRVALUE SetElemIDCount (
               INT32 NewValue
               );
               
            virtual ERRVALUE SetZValue (
               INT32 ElemNum,
               double zvalue
               );
               
            INT32 Add (
               const POLYLINE& PolyLine
               );
            
            int AddSnapPoint (
               LINEORIENT LineOrient,
               POLYLINE& PolyLine,
               LINESNAP LineSnap
               );
               
            ERRVALUE Change (
               INT32 LineNum,
               const POLYLINE& PolyLine
               );
            
            ERRVALUE ChangeLine (
               INT32 LineNum,
               const POLYLINE& PolyLine
               );
               
            ERRVALUE ChangeSnapLine (
               POLYLINE& PolyLine
               );
               
            int CheckIfIntersect (
               INT32 SkipLineNum,
               const POLYLINE& PolyLine
               );
               
            ERRVALUE Close (
               );
               
            ERRVALUE Delete (
               INT32 LineNum
               );
               
            ERRVALUE FindLineAndSplit (
               const DPOINT3D& point, 
               DPOINT3D& retpt
               );
               
            BITSET& GetLineBitset (
               ) { return (m_ElemList); }
               
            ERRVALUE JoinLines (
               INT32 NodeNum,
               INT32 RepLineNum,
               INT32 DelLineNum
               );
               
            ERRVALUE Open (
               OPENFLAGS flags
               );
         
            ERRVALUE OtherLineIntersect (
               const POLYLINE& PolyLine
               );
               
            ERRVALUE RecoverFromUndo (
               );
         
            ERRVALUE RemoveOvershoots (
               POLYLINE& PolyLine
               ) const;
               
            ERRVALUE SelfLineIntersect (
               const POLYLINE& PolyLine
               );
               
            INT32 SplitLineAtVertex (
               INT32 OldLineNum,
               INT32 vertex,
               INT32& NewLineNum
               );
               
            INT32 SplitLineNearPoint (
               INT32 LineNum,
               const DPOINT2D& point,
               INT32& NewLineNum
               );
               
            ERRVALUE UpdateStats (
               INT32 ElemNum
               );
               
         private:
         
            class OTHERLINESPLIT;
            friend class OTHERLINESPLIT;
            class SELFLINESPLIT;
            friend class SELFLINESPLIT;
            
            BITSET m_ElemList;   
            DBASE_LINE m_LineDB;
            
            ERRVALUE AddLineSegment (const POLYLINE& PolyLine);
            ERRVALUE ChangeLineSegment (const POLYLINE& PolyLine);
            ERRVALUE ComputeLineExtents (INT32 LineNum, RVCVECTLINE& vline);
            INT32 FindBestLineSnapPoint (LINEORIENT LineOrient, const POLYLINE& Polyline, DPOINT3D& retpt, double& maxdist) const;
            int GenerateExtendSnapPoint (LINEORIENT LineOrient, const POLYLINE& PolyLine, DPOINT3D& retpt, LINESNAP LineSnap);
            int GenerateSnapToPoint (LINEORIENT LineOrient, const POLYLINE& PolyLine, DPOINT3D& retpt, LINESNAP LineSnap);
            int InsertLinePoint (INT32 LineNum, INT32 segment, DPOINT3D& insertpt);
            ERRVALUE ResetLineNodeLink (LINEORIENT LineOrient, INT32 LineNum);
               
            class EXTENDSPLIT;
            class SNAPFILTINFO;

            friend class VECTORTOOLKIT;
         };
      friend class LINEELEMENT;
      friend class LINEELEMENT::EXTENDSPLIT;
      friend class LINEELEMENT::SNAPFILTINFO;
      class LINEPOLYJOIN;
      friend class LINEPOLYJOIN;

      class POINTELEMENT : public DATABASEELEMENT {
         public:
         
            POINTELEMENT (
               VECTORTOOLKIT& vtk
               );
               
            virtual ~POINTELEMENT (
               );

            virtual INT32 GetElemIDCount (
               ) const;
               
            virtual INT32 GetNumElements (
               ) const;

            virtual ERRVALUE GetZValue (
               INT32 ElemNum,
               double& zvalue
               ) const;
               
            virtual ERRVALUE SetElemIDCount (
               INT32 NewValue
               );
               
            virtual ERRVALUE SetZValue (
               INT32 ElemNum,
               double zvalue
               );
               
            virtual ERRVALUE ValidateElementIDTable (
               );
         
            ERRVALUE Add (
               const DPOINT3D& point
               );
               
            ERRVALUE Close (
               );
               
            ERRVALUE Open (
               OPENFLAGS flags
               );
         
            ERRVALUE RecoverFromUndo (
               );
         
            ERRVALUE RemoveElementIDRecord (
               INT32 PointNum
               );
               
         private:
            DBASE_POINT m_PointDB;
         };
      friend class POINTELEMENT;

      class POLYGONELEMENT : public STATELEMENT {
         public:
            class POLYLINEDELETE;
         
            POLYGONELEMENT (
               VECTORTOOLKIT& vtk
               );
               
            virtual ~POLYGONELEMENT (
               );

            virtual INT32 GetElemIDCount (
               ) const;
               
            virtual INT32 GetNumElements (
               ) const;

            virtual ERRVALUE GetZValue (
               INT32 ElemNum,
               double& zvalue
               ) const;
               
            virtual ERRVALUE SetElemIDCount (
               INT32 NewValue
               );
               
            virtual ERRVALUE SetZValue (
               INT32 ElemNum,
               double zvalue
               );
               
            ERRVALUE AddIsland (
               INT32 PolyNum,
               INT32 IslandNum
               );
               
            ERRVALUE Build (
               );
            
            ERRVALUE ChangeIsland (
               INT32 PolyNum,
               INT32 OldIsleNum,
               INT32 NewIsleNum
               );
               
            ERRVALUE ChangeLine (
               INT32 PolyNum,
               INT32 OldLineNum,
               INT32 NewLineNum
               );
               
            ERRVALUE Close (
               );
               
            ERRVALUE Delete (
               INT32 PolyNum
               );
               
            ERRVALUE DeleteByLine (
               INT32 PolyNum,
               DELETEPOLYGON flags
               );
               
            ERRVALUE DeleteIsland (
               INT32 PolyNum,
               INT32 IslandNum
               );
               
            ERRVALUE DeleteLine (
               INT32 PolyNum,
               INT32 LineNum
               );
               
            int FindPolygons (
               INT32 StartLine,
               INT32 PolyInside
               );
               
            BITSET& GetPolygonBitset (
               ) { return (m_ElemList); }
               
            ERRVALUE MergePolygons (
               INT32 LeftPolyNum,
               INT32 RightPolyNum,
               INT32 LineNum,
               POLYGONDELETEFILTER* PolyDelFilt
               );
               
            ERRVALUE Open (
               OPENFLAGS flags
               );
         
            ERRVALUE RecoverFromUndo (
               );
         
            ERRVALUE RemoveIslandInfo (
               );
               
            ERRVALUE RemovePolygonInfo (
               bool IsPolyRebuild
               );
               
            ERRVALUE SplitLineInPolygons (
               INT32 OrigLineNum,
               const RVCVECTLINE& Origvline,
               INT32 NewLineNum
               );
               
            ERRVALUE SplitLineInPoly (
               INT32 OrigLineNum, 
               const RVCVECTLINE& Origvline, 
               INT32 NewLineNum, 
               SIMPLE_ARRAY<INT32>& LineList
               ) const;
               
            ERRVALUE SplitLineInSamePoly (
               INT32 OrigLineNum, 
               const RVCVECTLINE& Origvline, 
               INT32 NewLineNum, 
               SIMPLE_ARRAY<INT32>& LineList
               ) const;
            
            ERRVALUE Update (
               INT32 PolyNum
               );
               
            void UpdateStats (
               BITSET& PolySet
               );
               
            ERRVALUE ValidatePolyInside (
               );
               
         private:
            struct LOCATEPOLY;      //!< Forward Declaration
            
            DBASE_POLYGON m_PolyDB;
            BITSET m_ElemList;   
            
            ERRVALUE ComputePolyExtents (INT32 PolyNum);
            INT32 FindNextLine (LOCATEPOLY& LocatePoly);
            ERRVALUE GenerateShellPolyList (INT32 ParentPoly, const SIMPLE_ARRAY<INT32>& LineList, SIMPLE_ARRAY<INT32>& PolyList);
            ORIENTATION OrientList (const SIMPLE_ARRAY<INT32>& LineList, const SIMPLE_ARRAY<bool>& LineOrientList) const;
            ERRVALUE RemoveZeroAreaPolygon (INT32 StartLine, LOCATEPOLY& LocatePoly);
            ERRVALUE ReparentIslands (INT32 PolyNum, INT32 NewParent, bool MoveToNewParent);
            ERRVALUE ReparentNestedIslands (INT32 CheckPoly, const SIMPLE_ARRAY<INT32>& LineList);
            ERRVALUE SearchNestedIslands (INT32 PolyInside, INT32 IslePoly, bool AddingPolygon);
            ERRVALUE SetLeftRight (const LOCATEPOLY& LocatePoly, INT32 PolyNum, INT32 ParentPolyNum);
            ERRVALUE UnparentIslets (INT32 OldParentPoly, INT32 NewParentPoly, const INT32 *LineList, INT32 NumLines);
            void ValidatePoly (LOCATEPOLY& LocatePoly, INT32 StartLine);
               
         };
      friend class POLYGONELEMENT;
      friend class POLYGONELEMENT::POLYLINEDELETE;
      class POLYLISTDELETE;
      friend class POLYLISTDELETE;
      class POLYISLANDDELETE;
      
      struct NODELINEANGLE {
         double m_Angle;               //!< Angle going out from the node
         INT32 m_LineNum;              //!< Line coming to/from the node
         bool m_Orient;                //!< true = To the node, false = From the node
         
         NODELINEANGLE (
            ) { memset(this, 0, sizeof(*this)); }     //! Fix UMR reports since there is padding after the bool
            
         static int CompareAngle (
            NODELINEANGLE *d1,
            NODELINEANGLE *d2,
            void *data
            );

         };

      class NODEELEMENT : public DATABASEELEMENT {
         public:
            NODEELEMENT (
               VECTORTOOLKIT& vtk
               );
               
            virtual ~NODEELEMENT (
               );

            virtual INT32 GetElemIDCount (
               ) const;
               
            virtual INT32 GetNumElements (
               ) const;

            virtual ERRVALUE GetZValue (
               INT32 ElemNum,
               double& zvalue
               ) const;
               
            virtual ERRVALUE SetElemIDCount (
               INT32 NewValue
               );
               
            virtual ERRVALUE SetZValue (
               INT32 ElemNum,
               double zvalue
               );
               
            virtual ERRVALUE ValidateElementIDTable (
               ) { return (0); }
         
            INT32 AddNode (
               const DPOINT3D& point
               );
               
            ERRVALUE AddNodeLine (
               INT32 NodeNum,
               INT32 LineNum
               );
         
            ERRVALUE BuildNodeLineList (
               );
               
            ERRVALUE ChangeNode (
               INT32 NodeNum,
               const DPOINT3D& point
               );
               
            ERRVALUE ChangeNodeLine (
               INT32 NodeNum,
               INT32 OldLineNum,
               INT32 NewLineNum
               );
               
            bool CheckIsPoint (
               INT32 NodeNum
               );
               
            ERRVALUE Close (
               );
               
            ERRVALUE ConvertNodePointToNode (
               INT32 NodeNum
               );
            
            ERRVALUE ConvertToPoint (
               INT32 NodeNum
               );
               
            ERRVALUE Delete (
               INT32 NodeNum
               );
               
            ERRVALUE DeleteNodeLine (
               INT32 NodeNum,
               INT32 LineNum
               );
               
            ERRVALUE FindNodeLineAngles (
               INT32 NodeNum,
               SIMPLE_ARRAY<NODELINEANGLE>& list
               ) const;
               
            DBASE_NODE& GetNodeDatabase (
               ) { return (m_NodeDB); }
               
            ERRVALUE Open (
               OPENFLAGS flags
               );
         
            ERRVALUE RecoverFromUndo (
               );
         
            ERRVALUE ValidateNodes (
               );

         private:
            DBASE_NODE m_NodeDB;
         };
      friend class NODEELEMENT;

      class LABELELEMENT : public BASEELEMENT {
         public:
         
            LABELELEMENT (
               VECTORTOOLKIT& vtk
               );
               
            virtual ~LABELELEMENT (
               );

            // VIRTUAL METHODS
            virtual INT32 GetNumElements (
               ) const;

            virtual ERRVALUE GetZValue (
               INT32 ElemNum,
               double& zvalue
               ) const;
               
            virtual ERRVALUE SetZValue (
               INT32 ElemNum,
               double zvalue
               );
               
            // METHODS  
            ERRVALUE AddLabelAttach (
               INT32 LabelNum,
               const VECTOR::LABEL& label,
               bool CheckAttach = false
               );
               
            ERRVALUE ChangeAttachPosn (
               ELEMTYPE ElemType,
               INT32 ElemNum,
               const DPOINT3D& point
               );
               
            ERRVALUE ChangeLabelAttach (
               ELEMTYPE ElemType,
               INT32 OldElemNum,
               INT32 NewElemNum
               );
            
            ERRVALUE CheckAttachments (
               STATUSCONTEXT& sc
               );
               
            void CheckLabelAttach (
               const VECTOR::LABEL& label
               );
                  
            void CleanupElemToLabelTrans (
               );
         
            ERRVALUE Close (
               );

            ERRVALUE DeleteLabelAttach (
               ELEMTYPE ElemType,
               INT32 ElemNum
               );
               
            ERRVALUE Open (
               OPENFLAGS flags
               );
         
            ERRVALUE PickLineLabelAttach (
               INT32 OldLineNum,
               INT32 NewLineNum
               );
               
            ERRVALUE PickPolyLabelAttach (
               INT32 OldPolyNum,
               INT32 NewPolyNum
               );
               
            ERRVALUE RecoverFromUndo (
               );
         
            ERRVALUE RemoveLabelAttach (
               INT32 LabelNum
               );
               
            ERRVALUE ResizeLabelAttach (
               ELEMTYPE ElemType,
               INT32 NumItems
               );
               
            ERRVALUE SetupElemToLabelTrans (
               );
               
            ERRVALUE SwapElementLabelAttach (
               ELEMTYPE ElemType,
               INT32 FirstElem,
               INT32 LastElem
               );
               
            ERRVALUE SwapLabelAttach (
               INT32 FirstLabel,
               INT32 LastLabel
               );
               
         private:
         
            LIST& GetTransList (ELEMTYPE ElemType);
            ERRVALUE ResizeLabelTransList (ELEMTYPE ElemType);
               
            OBJECT m_LabelTransFile;
            LIST m_LineToLabelID;
            LIST m_NodeToLabelID;
            LIST m_PointToLabelID;
            LIST m_PolygonToLabelID;
            LIST m_DummyID;
            
         };
      friend class LABELELEMENT;
      
      class OPENVECTOR : public VECTOR {
         public:
         
            OPENVECTOR (
               ) : VECTOR() {}
         
            OPENVECTOR (
               const OPENVECTOR& rhs
               ) : VECTOR(rhs) {}
         
            virtual ~OPENVECTOR (
               ) {}
               
            ERRVALUE ClearLinePointList (
               ) { return (VECTOR::ClearLinePointList()); }

            ERRVALUE ClearNodeLineList (
               ) { return (VECTOR::ClearNodeLineList()); }
         
            ERRVALUE ClearPolygonIslandList (
               ) { return (VECTOR::ClearPolygonIslandList()); }
         
            ERRVALUE ClearPolygonLineList (
               ) { return (VECTOR::ClearPolygonLineList()); }
         
            ERRVALUE SetNumLabels (
               INT32 NewNumLabels
               ) { return (VECTOR::SetNumLabels(NewNumLabels)); }
         
            ERRVALUE SetNumLines (
               INT32 NewNumLines
               ) { return (VECTOR::SetNumLines(NewNumLines)); }
         
            ERRVALUE SetNumNodes (
               INT32 NewNumNodes
               ) { return (VECTOR::SetNumNodes(NewNumNodes)); }
               
            ERRVALUE SetNumPoints (
               INT32 NewNumPoints
               ) { return (VECTOR::SetNumPoints(NewNumPoints)); }
            
            ERRVALUE SetNumPolygons (
               INT32 NewNumPolygons
               ) { return (VECTOR::SetNumPolygons(NewNumPolygons)); }
            
            ERRVALUE SwapLinePoints (
               INT32 Line1,
               INT32 Line2
               ) { return (VECTOR::SwapLinePoints(Line1, Line2)); }
               
            ERRVALUE SwapNodeLines (
               INT32 Node1,
               INT32 Node2
               ) { return (VECTOR::SwapNodeLines(Node1, Node2)); }
               
            ERRVALUE SwapPolyIslands (
               INT32 Poly1,
               INT32 Poly2
               ) { return (VECTOR::SwapPolyIslands(Poly1, Poly2)); }
               

            ERRVALUE SwapPolyLines (
               INT32 Poly1,
               INT32 Poly2
               ) { return (VECTOR::SwapPolyLines(Poly1, Poly2)); }
         };
      
      class DISABLETEXT {
         public:
         
            DISABLETEXT (