rvccad.h

Go to the documentation of this file.

/**
 * \file rvccad.h <mi32/rvccad.h>
 * \brief CAD object descriptions Version 2.0      (RVCCAD format)
 *
 * \if NODOC
 * $Id: rvccad.h_v 1.94 2004/09/02 16:15:32 scowan Exp $
 *
 * $Log: rvccad.h_v $
 * Revision 1.94  2004/09/02 16:15:32  scowan
 * Removed prototypes and an include file.
 *
 * Revision 1.93  2004/09/01 22:54:20  scowan
 * Most functions removed or moved to private include file.
 *
 * Revision 1.92  2004/08/24 22:09:04  scowan
 * Added total line length field to header.
 *
 * Revision 1.91  2004/08/10 21:27:12  scowan
 * *** empty log message ***
 *
 * Revision 1.90  2004/08/10 21:10:10  scowan
 * Removed now unused prototypes.
 *
 * Revision 1.89  2004/06/14 16:20:42  scowan
 * Added baseline flags.
 *
 * Revision 1.88  2004/06/03 22:10:54  scowan
 * Removed archived prototype.
 *
 * Revision 1.87  2004/05/18 21:59:57  scowan
 * Adde dmore fields to cad text.
 *
 * Revision 1.86  2004/05/17 23:30:07  scowan
 * Added many items to text structure.
 *
 * Revision 1.85  2004/04/13 16:01:18  scowan
 * Fixed invalid style flag value in cad objects.
 *
 * Revision 1.84  2004/03/10 22:47:14  mju
 * Remove getCADObjectSet, deprecate other getCADObject inlines.
 *
 * Revision 1.83  2003/10/15 17:39:00  mju
 * Deprecate groupkey.
 *
 * Revision 1.82  2003/10/13 17:05:45  scowan
 * Removed unused structre.
 *
 * Revision 1.81  2003/10/13 17:03:58  scowan
 * Removed unused function prototypes and inlines.
 *
 * Revision 1.80  2003/09/15 13:49:56  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.79  2003/08/27 21:31:17  scowan
 * Removed function to get linked file.
 *
 * Revision 1.78  2003/02/06 21:30:21  scowan
 * Removed some functions.
 *
 * Revision 1.77  2002/12/26 16:23:40  scowan
 * Fixed invalid extents handling.
 *
 * Revision 1.76  2002/09/09 13:54:00  mju
 * Use prevent_memfunc.
 *
 * Revision 1.75  2002/08/21 20:38:49  scowan
 * Deprecated old object name define.
 *
 * Revision 1.74  2002/08/20 15:08:39  mju
 * Remove deprecated dialog defines.
 *
 * Revision 1.73  2002/03/08 18:48:10  scowan
 * Added clear method.
 * delrecate mem.. functions using info struct.
 *
 * Revision 1.72  2002/01/03 22:51:29  scowan
 * Added methods to manage extents.
 *
 * Revision 1.71  2001/09/14 14:58:03  mju
 * No Mdlg in win32native.
 *
 * Revision 1.70  2001/07/18 21:04:09  scowan
 * Added TAB file linking.
 *
 * Revision 1.69  2001/07/11 16:07:34  scowan
 * Added encoding for link creation.
 *
 * Revision 1.68  2001/07/10 17:42:14  scowan
 * Mored CAD object linking to private include file.
 *
 * Revision 1.67  2001/06/18 15:40:47  mju
 * Convert RasterToCADBoundary now takes GENINFO reference.
 * ConvertVectorToCAD now takes geninfo reference.
 *
 * Revision 1.66  2001/05/29 21:11:28  scowan
 * Added functions to assist in wrapper classes.
 *
 * Revision 1.65  2000/09/06 16:39:41  scowan
 * Added read open header function.
 *
 * Revision 1.64  2000/07/13 21:30:42  mju
 * Deprecated old MfGet...UC #defines.
 *
 * Revision 1.63  2000/04/21 15:02:19  scowan
 * Added assignment operator.
 *
 * Revision 1.62  2000/03/21 23:14:32  scowan
 * More const.
 *
 * Revision 1.60  2000/01/03 20:09:26  scowan
 * More inline methods.
 *
 * Revision 1.59  1999/12/29 16:53:59  scowan
 * Move cad element definition.
 *
 * Revision 1.58  1999/12/23 16:31:24  scowan
 * Definition of new CAD element class.
 *
 * Revision 1.57  1999/12/17 18:11:21  scowan
 * More const.
 *
 * Revision 1.54  1999/10/05 22:45:08  scowan
 * Change headeer to Inheritance.
 *
 * Revision 1.53  1999/08/06 17:11:35  dwilliss
 * Just added a comment to clarify something.
 *
 * Revision 1.52  1999/07/26 19:37:08  scowan
 * Added function to return linked to file.
 *
 * Revision 1.49  1999/06/11  16:09:19  mju
 * In obj sel dlg add defaults for filter+filtdata.
 *
 * Revision 1.48  1999/06/11  14:45:09  mju
 * Obj sel dlg.
 *
 * Revision 1.47  1999/06/10  22:10:42  mju
 * Object selection dialog update.
 *
 * Revision 1.46  1999/05/07  21:22:06  mju
 * Header restruct.
 *
 *
 * By Steve Cowan    9-19-90
 * \endif
**/

#ifndef INC_MI32_RVCCAD_H
#define INC_MI32_RVCCAD_H

#ifndef  INC_MI32_RVCDEFNS_H
   #include <mi32/rvcdefns.h>
#endif

#ifndef  INC_MI32_COLOR_H
   #include <mi32/color.h>
#endif

#ifndef  INC_MI32_ELEMSTYL_H
   #include <mi32/elemstyl.h>
#endif

struct RVCCADINFO : public RVCGENINFO {
   DPOINT3D_OLD minval;    //!< 24  Min coord values for the entire CADobj 
   DPOINT3D_OLD maxval;    //!< 24  Max coord values for the entire CADobj 
   UINT16 PointType;       //!< 2   RVC CAD point types 
   UINT16 LinkType;        //!< 2   Type of link (DXF, MIF, ...) 
   UINT16 ElemHdrSize;     //!< 2   Size of CADELEMHDR  (set by MfMakeCAD routine) 
   UINT16 CAD_BlockSize;   //!< 2   Size of CADBLOCK    (set by MfMakeCAD routine) 
   UINT32 MaxSize;         //!< 4   Maximum Size of an CAD object element  (set by MfUpdateCAD routine) 
   UINT32 NumBlocks;       //!< 4   Number of CAD object Block Headers 
   DOUBLE xscale;          //!< 8   Scale between CAD object and ground distances 
   DOUBLE yscale;          //!< 8   Scale between CAD object and ground distances 
   DOUBLE zscale;          //!< 8   Scale between CAD object and ground distances 
   INT32 NextElemID;       //!< 4   Next element ID variable 
   INT32 m_EditBlockNum;   //!< 4   In memory field only
   DOUBLE m_TotalLineLength;
   
   RVCCADINFO (
      ) {Clear();}
   
   RVCCADINFO (
      const RVCGENINFO& ginfo
      ) {Clear();*static_cast<RVCGENINFO*>(this) = ginfo;}
   
   RVCCADINFO& operator= (
      const RVCGENINFO& ginfo
      ) {*static_cast<RVCGENINFO*>(this) = ginfo; return (*this);}
      
   void Clear (
      ) {memset(static_cast<void*>(this), 0, sizeof(*this));}
   
   //! Get extents of CAD object.
   //! @return extents of CAD object
   DRECT3D GetExtents (
      ) const {
      DRECT3D rect;
      rect.xinit = minval.x;     
      rect.yinit = minval.y;     
      rect.zinit = minval.z;     
      rect.xlast = maxval.x;
      rect.ylast = maxval.y;
      rect.zlast = maxval.z;
      return (rect);
      }

   //! Set extents of CAD object.
   void SetExtents (
      const DRECT3D& rect
      ) {
      minval.x = rect.xinit;     
      minval.y = rect.yinit;     
      minval.z = rect.zinit;     
      maxval.x = rect.xlast;
      maxval.y = rect.ylast;
      maxval.z = rect.zlast;
      return;
      }

   };


/* If structure size changes, geom.dll will need to be changed */
struct CADBLOCK {
   RVC::OBJECTNAME name;   //!< 32 Name of Block 
   RVC::OBJECTDESC desc;   //!< 128 Description of a block 
   DPOINT3D BasePt;        //!< 24 Base point for the block 
   DPOINT3D GridPt;        //!< 24 Base point of snap grid 
   DPOINT3D minval;        //!< 24 Minimum coordinate values for the block 
   DPOINT3D maxval;        //!< 24 Maximum coordinate values for the block 
   DOUBLE xscale;          //!<  8 Scale between CAD block and ground distances (x scale) 
   DOUBLE yscale;          //!<  8 Scale between CAD block and ground distances (y scale) 
   DOUBLE zscale;          //!<  8 Scale between CAD block and ground distances (z scale) 
   DOUBLE xsize;           //!<  8 X direction size in CAD units (snap grid) 
   DOUBLE ysize;           //!<  8 Y direction size in CAD units (snap grid) 
   DOUBLE zsize;           //!<  8 Z direction size in CAD units (snap grid) 
   COLOR GridColor;        //!<  8 Grid snap point color - XColor format 
   UINT32 NumElem;            //!<  4 Total number of elements in block 
   INT32 dbrecord;            //!<  4 Pointer to dblist entry (set by editor) 
   FLOAT rotate;           //!<  4 Rotation angle (snap grid) 
   UINT32 flags;           //!<  4 Flags defined below 
   UINT16 LinkType;        //!<  2 Type of link (DXF, MIF, ...) 
   UINT16 space;           //!<  2 Spare bytes 
   UINT32 LinkOffset;         //!<  4 File offset to linked data 
   
   CADBLOCK (
      ) {Clear();}
   
   void Clear (
      ) {memset(static_cast<void*>(this), 0, sizeof(*this));}
   
   //! Get extents of CAD block
   //! @return extents of CAD block
   DRECT3D GetExtents (
      ) const {
      DRECT3D rect;
      rect.xinit = minval.x;     
      rect.yinit = minval.y;     
      rect.zinit = minval.z;     
      rect.xlast = maxval.x;
      rect.ylast = maxval.y;
      rect.zlast = maxval.z;
      return (rect);
      }

   void SetExtents (
      const DRECT3D& rect
      ) {
      minval.x = rect.xinit;     
      minval.y = rect.yinit;     
      minval.z = rect.zinit;     
      maxval.x = rect.xlast;
      maxval.y = rect.ylast;
      maxval.z = rect.zlast;
      return;
      }

   };

//! Disallow memset/memcpy.
PREVENT_MEMFUNC(RVCCADINFO)
PREVENT_MEMFUNC(CADBLOCK)

#define RVCCAD_MaxLink     5
#define RVCCAD_Internal    0
#define RVCCAD_MIF         1     //!< Mapinfo .MIF format
#define RVCCAD_AGF         2     //!< Atlas GIS 3.0 internal format
#define RVCCAD_SHP         3     //!< Arc/Info Shapefile format
#define RVCCAD_TAB         4     //!< MapInfo TAB format

#define CADBLOCK_HasGrid      (0x00000001)
#define CADBLOCK_DrawGridPts  (0x00000002)
#define CADBLOCK_DrawLast     (0x00000004)


struct CADELEMHDR {
   INT32 ElemSize;                  //!<  Entire size of CAD element stored (set by MfUpdateCADElem()) 
   UINT16 ElemType;              //!<  Type of CADobj element stored (see below) 
   UINT8 NumAttrib;              //!<  Number of attributes in data (set by MfWriteCADElem()) 
   UINT8 NumExtra;               //!<  Number of extra attributes in extra (set by MfUpdateCADElem()) 
   };

/*--- Defined CAD elements ---*/

#define CAD_INSERT         0
#define CAD_POINT          1     //!<  Has no structure 
#define CAD_CIRCLE         2
#define CAD_ARC            3
#define CAD_ARCCHORD       4     //!<  Uses CADARC structure 
#define CAD_TEXT           5
#define CAD_BLOCKTEXT      6     //!<  Uses CADTEXT structure  N.I.Y. 
#define CAD_LINE           7
#define CAD_RBOX           8     //!<  An easy way to define a rectangle 
#define CAD_POLYGON        9
#define CAD_MESH           10
#define CAD_ELLIPSE        11
#define CAD_EARC           12
#define CAD_POLYNOMIAL     13    //!<                          N.I.Y. 
#define CAD_ARCWEDGE       14    //!<  Uses CADARC structure 
#define CAD_EARCWEDGE      15    //!<  Uses CADEARC structure 
#define CAD_EARCCHORD      16    //!<  Uses CADEARC structure 
#define CAD_MULTILINE      17
#define CAD_MULTIPOINT     18
#define CAD_MULTIPOLYGON   19
#define CAD_LAST           20

/*#define CAD_PARABOLA     21    not defined yet*/
/*#define CAD_HYPERBOLA    22    not defined yet*/
/*#define CAD_VARITEXT     23    not defined yet*/

/**
* Any addition to the list "MUST" be noted in _rvcCADInit() (rvccad.c)
* and in StyleQueryEvalCAD (dbqstyle.c)
* and in hdrdesc.ref (see person in charge of RVC).
* If structure size changes, geom.dll will need to be changed
**/

struct CADELEMOPT {
   COLOR color;                  //!<  8  Color - XColor format 
   COLOR FillColor;              //!<  8  Fill color - XColor format 
   INT32 dbrecord;               //!<  4  Pointer to dblist entry 
   INT32 LinePatt;               //!<  4  Line Pattern index 
   INT32 FillPatt;               //!<  4  Fill Pattern index 
   INT32 Symbol;                 //!<  4  Point Symbol index 
   FLOAT Angle;                  //!<  4  Angle of point symbol 
   FLOAT width;                  //!<  4  Width of element in CAD coordinates!, also X-Width for points 
   FLOAT ywidth;                 //!<  4  Y-Width for points 
   UINT32 StyleFlags;            //!<  4  See STDDEFNS.H for flag definitions 
   DPOINT3D Extrusion;           /* 24 X, Y, or Z coordinate used in VPOINT_3D?? coords.
                                       For planar data, this is the normal vector to the plane that the element is placed on. */
   INT32 HyperLink;              //!<  4  Index to hyperindex shape definition 
   UINT16 WidthUnits;            //!<  2  Units that width field is in 
   UINT16 Space;                 //!<  2  Reserved for future use 
   DOUBLE MapScale;              //!<  8  MapScale to use given scales at 
   COLOR m_LineDrawColor;
   COLOR m_PolyBorderColor;
   COLOR m_PolyFillColor;

   CADELEMOPT (
      ) {
      memset(this, 0, sizeof(CADELEMOPT));
      }

   CADELEMOPT& operator= (
      const CADELEMOPT& rhs
      ) {
      if (this != &rhs) memcpy(this, &rhs, sizeof(CADELEMOPT));
      return (*this);
      }

   void GetStyle (
      LINESTYLE& line
      ) const {
      line.StyleFlags = StyleFlags;
      line.PatternNum = LinePatt;
      line.DrawColor = color;
      line.MapScale = MapScale;
      line.Scale = width;
      return;
      }

   void GetStyle (
      POINTSTYLE& point
      ) const {
      point.StyleFlags = StyleFlags;
      point.SymbolNum = Symbol;
      point.DrawColor = color;
      point.Angle = Angle;
      point.ScaleX = width;
      point.ScaleY = ywidth;
      point.MapScale = MapScale;
      return;
      }

   void GetStyle (
      POLYSTYLE& poly
      ) const {
      poly.StyleFlags = StyleFlags;
      poly.FillPatternNum = FillPatt;
      poly.BorderPatternNum = LinePatt;
      poly.BorderColor = color;
      poly.FillColor = FillColor;
      poly.MapScale = MapScale;
      poly.BorderScale = width;
      return;
      }

   void GetStyle (
      TEXTSTYLE& text
      ) const {
      text.FGColor = color;
      text.BGColor = FillColor;
      text.StyleFlags = StyleFlags;
      text.StyleFlags &= ~STYLEFLAG_TextUseStyleHeight;
      text.MapScale = MapScale;
      return;
      }

   void SetStyle (
      const LINESTYLE& line
      ) {
      StyleFlags = line.StyleFlags;
      LinePatt = line.PatternNum;
      color = line.DrawColor;
      MapScale = line.MapScale;
      width = static_cast<float>(line.Scale);
      return;
      }

   void SetStyle (
      const POINTSTYLE& point
      ) {
      StyleFlags = point.StyleFlags;
      Symbol = point.SymbolNum;
      color = point.DrawColor;
      Angle = static_cast<float>(point.Angle);
      width = static_cast<float>(point.ScaleX);
      ywidth = static_cast<float>(point.ScaleY);
      MapScale = point.MapScale;
      return;
      }

   void SetStyle (
      const POLYSTYLE& poly
      ) {
      StyleFlags = poly.StyleFlags;
      FillPatt = poly.FillPatternNum;
      LinePatt = poly.BorderPatternNum;
      color = poly.BorderColor;
      FillColor = poly.FillColor;
      MapScale = poly.MapScale;
      width = static_cast<float>(poly.BorderScale);
      return;
      }

   void SetStyle (
      const TEXTSTYLE& text
      ) {
      color = text.FGColor;
      FillColor = text.BGColor;
      StyleFlags = text.StyleFlags;
      StyleFlags &= ~STYLEFLAG_TextUseStyleHeight;
      MapScale = text.MapScale;
      return;
      }

   };

/**
* Any addition to CADELEMOPT "MUST" be noted in _rvcCADInit() (rvccad.c)
* and in headers.def (see person in charge of RVC).
**/

/*--- Structure definitions for CAD elements */

struct CADCIRCLE {      /* Size = 32 */
   DPOINT2D_OLD center;          //!<  Center point of circle 
   DOUBLE radius;                //!<  Radius of circle 
   DOUBLE m_zvalue;              //!< Z value of center point
   };


struct CADARC {         /* Size = 48 */
   DPOINT2D_OLD center;          //!<  Center point of arc 
   DOUBLE radius;                //!<  Radius of arc 
   DOUBLE start;                 //!<  Start angle of arc 
   DOUBLE end;                   //!<  End angle of arc 
   DOUBLE m_zvalue;              //!< Z value of center point
   };


struct CADTEXT {        /* Size = 128 */
   UINT32 NumPoints;             //!< Number of points 
   UINT16 NumChars;              //!< Number of charaters in text string 
   UINT16 CharSize;              //!< Number of bytes per character (1 or 2) 
   FLOAT height;                 //!< Height of text in CAD coordinates 
   FLOAT rotate;                 //!< Rotation angle of string 
   FLOAT shear;                  //!< Shear angle 
   FLOAT textrotate;             //!< Rotation angle of each character in the string 
   FLOAT xscale;                 //!< X Scale factor relative to height (default 1.0) 
   INT32 font;                   //!< Font number 
   UINT32 FontFlags;             //!< Text style bits 
   UINT8 m_ShadowRelative;       //!< true if shadow angle relative to baseline angle
   UINT8 m_BaselineFlags;        //!< Baseline flags
   UINT8 m_bCartoonBalloonLeaders;
   UINT8 m_Predefined;              //!< Predefined label styles
   
   //!< From TEXTSTYLE
   FLOAT m_LineSpace;            //!< Line spacing in CAD units
   FLOAT m_StrokeWidth;          //!< Stroke width in % of glyph height (1.0 = 100%)
   FLOAT m_EnhanceWidth;         //!< Enhanced width in % of glyph height (1.0 = 100%)
   FLOAT m_BoldnessWidth;        //!< Boldness width in % of glyph height (1.0 = 100%) Ignored unless FONTSTYLE_Bold is set
   FLOAT m_UnderlineWidth;       //!< Underline with in % of glyph height (1.0 = 100%)
   FLOAT m_UnderlineOffset;      //!< Underline Offset from baseline in % (1.0 = 100%)
   FLOAT m_ShadowOffset;         //!< Drop shadow offset in % (1.0 = 100%) Ignored unless FONTSTYLE_Shadow is set
   FLOAT m_ShadowAngle;          //!< Drop shadow angle in radians
   FLOAT m_ClipWidth;            //!< Clip extended area around text in TextAddToClip()
   
   //!< From LABELFRAMEPARMS
   FLOAT m_Margin;               //!< Units: % of font ascent 
   FLOAT m_TMargin;              //!< Units: % of font ascent
   FLOAT m_BMargin;              //!< Units: % of font ascent
   FLOAT m_LMargin;              //!< Units: % of font ascent
   FLOAT m_RMargin;              //!< Units: % of font ascent
   UINT32 m_FrameShape;
   UINT32 m_LineStyleFlags;
   UINT32 m_PolyStyleFlags;
   FLOAT m_LineScale;            //!< Width of line (usually in millimeters) or pattern zoom factor
   FLOAT m_PolyBorderScale;      //!< Width of border (usually in millimeters) or pattern zoom factor
   UINT32 m_Arrow;

   UINT32 m_NumLeaderLines;
   UINT8 spare2[4];
// FLOAT m_HatchAngle;           //!< Use CADELEMOPT::Angle: Rotation angle for hatch patterns (was spare[8])
// INT32 PatternNum;             //!< Use CADELEMOPT::LinePatt
// INT32 FillPatternNum;         //!< Use CADELEMOPT::FillPatt
// INT32 BorderPatternNum;       //!< Use CADELEMOPT::Symbol
   };                            /* Followed by the actual points then the number of characters */

#define CADBASELINEFLAG_Straight    0x00
#define CADBASELINEFLAG_Exact       0x01
#define CADBASELINEFLAG_Spline      0x02
#define CADBASELINEFLAG_ClipUnder   0x04

struct CADINSERT {               /* Size = 72 */
   DPOINT3D_OLD InsertPt;        //!<  Point where to insert the block 
   INT32 BlockNum;               //!<  Index of block to insert 
   FLOAT rotate;                 //!<  Rotation angle 
   DOUBLE xscale;                //!<  X Scale factor          (default 1.0) 
   DOUBLE yscale;                //!<  Y Scale factor          (default 1.0) 
   DOUBLE zscale;                //!<  Z Scale factor          (default 1.0) 
   UINT16 numlins;               //!<  Number of lines         (default 1) 
   UINT16 numcols;               //!<  Number of columns       (default 1) 
   FLOAT linspace;               //!<  Spacing between lines 
   FLOAT colspace;               //!<  Spacing between columns 
   UINT32 space;
   };


struct CADRBOX {        /* Size = 8 */
   FLOAT rotate;                 //!<  Rotation of box 
   UINT32 space;
   };


struct CADLINE {        /* Size = 8 */
   UINT32 NumPoints;             //!<  Number of points in polyline 
   UINT32 CurveFit;              //!<  Type of curve fitting used 
   };                            /* Followed by the point data */


struct CADPOLY {        /* Size = 16 */
   UINT32 NumPoints;             //!<  Number of points in first polygon. 
   UINT32 NumIslands;            //!<  Number of islands in polygon.  0 if none. 
   UINT32 CurveFit;              //!<  Type of curve fitting used 
   UINT32 space;
   };                            /*
                                 * Followed by the "number of points per island" buffer and the point data for the
                                 * polygon and islands.  If NumIslands == 0 then only the polygon is stored.
                                 */

struct CADMESH {        /* Size = 16 */
   UINT32 xverts;                //!<  Number of X vertices for mesh 
   UINT32 yverts;                //!<  Number of Y vertices for mesh 
   UINT16 CurveFit;              //!<  Type of curve fitting used 
   UINT16 flags;                 //!<  1 = Closed in x verts: 2 = Closed in y verts 
   UINT32 space;
   };                            /* Followed by the point data in the form of array[xverts][yverts]. */


struct CADELLIPSE {     /* Size = 48 */
   DPOINT2D_OLD center;             //!<  Center of ellipse 
   DOUBLE xsize;                 //!<  Relative X width of ellipse 
   DOUBLE ysize;                 //!<  Relative Y width of ellipse 
   FLOAT rotate;                 //!<  Rotation of ellipse X axis with respect to the the world X axis 
   UINT32 space;
   DOUBLE m_zvalue;              //!< Z value of center point
   };


struct CADEARC {        /* Size = 64 */
   DPOINT2D_OLD center;          //!<  Center of ellipse 
   DOUBLE start;                 //!<  Start angle of elliptical arc 
   DOUBLE end;                   //!<  End angle of elliptical arc 
   DOUBLE xsize;                 //!<  Relative X width of ellipse 
   DOUBLE ysize;                 //!<  Relative Y width of ellipse 
   FLOAT rotate;                 //!<  Rotation of ellipse X axis with respect to the 
                                 /* the world X axis*/
   UINT32 space;
   DOUBLE m_zvalue;              //!< Z value of center point
   };


struct CADMULTIPOINT {
   UINT32 NumPoints;             //!<  Number of points, duh 
   UINT32 space;
   };                            /* Followed by the point data */


struct CADMULTILINE {
   UINT32 NumLines;              //!<  Number of lines, duh 
   UINT32 CurveFit;              //!<  Type of curve fitting used 
   };                            /* Followed by the number of points array then followed by the point data */


struct CADMULTIPOLY {
   UINT32 NumPolygons;           //!<  Number of CADSUBPOLY regions 
   UINT32 CurveFit;              //!<  Type of curve fitting used 
   };                            /* Followed by the array of subregion structures then by the data for each sub-region */

struct CADSUBPOLY {
   UINT32 NumPoints;             //!<  Number of points in the polygon 
   UINT32 NumIslands;            //!<  Number of islands 
   };

//! Perform byte-swapping.
inline void SwapBytes (
   CADSUBPOLY& rhs
   ) { ::SwapBytes(rhs.NumPoints); ::SwapBytes(rhs.NumIslands); }


struct CADPOLYNOM {     /* Size = 40 */
   DPOINT2D_OLD minval;          //!<  Maximum x, y range of polynomial 
   DPOINT2D_OLD maxval;          //!<  Minimum x, y range of polynomial 
   UINT32 NumCoeff;              //!<  Number of coefficients in polynomial 
   UINT32 space;
   };                            /* Followed by the coefficients of the polynomial */

union CADELEMDATA {              /* Size = 72 */
   CADINSERT insert;             //!<  Biggest structure (if changed, need to recompile) 
   CADCIRCLE circle;
   CADARC arc;
   CADTEXT text;
   CADLINE line;
   CADRBOX rbox;
   CADPOLY poly;
   CADMESH mesh;
   CADELLIPSE ellipse;
   CADEARC earc;
   CADPOLYNOM polynom;
   CADMULTIPOINT mpoint;
   CADMULTILINE mline;
   CADMULTIPOLY mpoly;
   };


/* If structure size changes, geom.dll will need to be changed */
struct CADELEMENT {
   CADELEMHDR hdr;
   CADELEMOPT opt;
   CADELEMDATA data;
   DPOINT3D pt;                  //!<  Text or point point 
   void *text;                   //!<  Either text string or CADSUBPOLY array 
   INT32 *islelist;              //!<  Array of number of points for islands or lines 
   void *points;                 //!<  All of the points that are fit to load 
   int PointSize;                //!<  Needed for functions without access to data source 
   };


/*-------------------------------------------------------------------------*/
/*    Object Selection Dialogs                                             */
/*-------------------------------------------------------------------------*/

#if (defined(X_NATIVE) || defined(WIN32_MFC)) && !defined(DEPRECATE_GROUPKEY)

DEPRECATED inline int MdlgGetCADObject (
   MDLGPARENT dlgparent,
   FILEPATH& filename,
   INT32 *inode,
   const void *prompt,
   RVCCADINFO *objinfo,
   MfFiltFuncProto filter=0,
   void *filtdata=0,
   GETOBJFLAGS flags=GETOBJFLAG_None
   ) {
   return (MdlgGetObject(dlgparent,filename,inode,prompt,OTYPE_CAD,RVCCONV_CADInfo,objinfo,sizeof(RVCCADINFO),filter,filtdata,flags));
   }


DEPRECATED inline int MdlgGetCADObject (
   MDLGPARENT dlgparent,
   UNICODE *filename,
   INT32 *inode,
   const void *prompt,
   RVCCADINFO *objinfo,
   MfFiltFuncProto filter=0,
   void *filtdata=0,
   GETOBJFLAGS flags=GETOBJFLAG_None
   ) {
   return (MdlgGetObject(dlgparent,filename,inode,prompt,OTYPE_CAD,RVCCONV_CADInfo,objinfo,sizeof(RVCCADINFO),filter,filtdata,flags));
   }

#endif   //!< X_NATIVE || WIN32_MFC

#if defined(__cplusplus)
extern "C" {
#endif

   /* Higher level CAD functions */
   ERRVALUE MfConvertRasterToCADBound (int sfhandle, INT32 irastinode, int dfhandle, RVCGENINFO& oobjinfo, UINT32 flags);
   int MfConvertRasterToCADLine (int sfhandle, INT32 irastinode, RVC::OBJITEM& DestObjItem, double ThinFactor, UINT32 flags);

#if defined(__cplusplus)
}
#endif

#endif      //!<  #ifndef  INC_MI32_RVCCAD_H

---