mi32/rvccad.h

Go to the documentation of this file.

#ifndef INC_MI32_RVCCAD_H
#define INC_MI32_RVCCAD_H

#ifndef INC_RVC_OBJECTNAME_H
   #include <rvc/objectname.h>
#endif

#ifndef  INC_MI32_RECT_H
   #include <mi32/rect.h>
#endif

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


/* If structure size changes, geom.dll will need to be changed */
struct CADBLOCK {
   RVC::OBJECTNAME name;   
   RVC::OBJECTDESC desc;   
   DPOINT3D BasePt;        
   DPOINT3D GridPt;        
   DPOINT3D minval;        
   DPOINT3D maxval;        
   DOUBLE xscale;          
   DOUBLE yscale;          
   DOUBLE zscale;          
   DOUBLE xsize;           
   DOUBLE ysize;           
   DOUBLE zsize;           
   COLOR GridColor;        
   UINT32 NumElem;            
   INT32 dbrecord;            
   FLOAT rotate;           
   UINT32 flags;           
   UINT16 LinkType;        
   UINT16 space;           
   UINT32 LinkOffset;         
   
   CADBLOCK (
      ) {Clear();}
   
   void Clear (
      ) {memset(static_cast<void*>(this), 0, sizeof(*this));}
   
   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;
      }

   };

PREVENT_MEMFUNC(CADBLOCK)

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


struct CADELEMHDR {
   INT32 ElemSize;                  
   UINT16 ElemType;              
   UINT8 NumAttrib;              
   UINT8 NumExtra;               
   };

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

#define CAD_INSERT         0
#define CAD_POINT          1     
#define CAD_CIRCLE         2
#define CAD_ARC            3
#define CAD_ARCCHORD       4     
#define CAD_TEXT           5
#define CAD_BLOCKTEXT      6     
#define CAD_LINE           7
#define CAD_RBOX           8     
#define CAD_POLYGON        9
#define CAD_MESH           10
#define CAD_ELLIPSE        11
#define CAD_EARC           12
#define CAD_POLYNOMIAL     13    
#define CAD_ARCWEDGE       14    
#define CAD_EARCWEDGE      15    
#define CAD_EARCCHORD      16    
#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*/

struct CADELEMOPT {
   COLOR color;                  
   COLOR FillColor;              
   INT32 dbrecord;               
   INT32 LinePatt;               
   INT32 FillPatt;               
   INT32 Symbol;                 
   FLOAT Angle;                  
   FLOAT width;                  
   FLOAT ywidth;                 
   UINT32 StyleFlags;            
   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;              
   UINT16 WidthUnits;            
   UINT16 Space;                 
   DOUBLE MapScale;              
   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;
      }

   };

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

struct CADCIRCLE {      /* Size = 32 */
   DPOINT2D_OLD center;          
   DOUBLE radius;                
   DOUBLE m_zvalue;              
   };


struct CADARC {         /* Size = 48 */
   DPOINT2D_OLD center;          
   DOUBLE radius;                
   DOUBLE start;                 
   DOUBLE end;                   
   DOUBLE m_zvalue;              
   };


struct CADTEXT {        /* Size = 128 */
   UINT32 NumPoints;             
   UINT16 NumChars;              
   UINT16 CharSize;              
   FLOAT height;                 
   FLOAT rotate;                 
   FLOAT shear;                  
   FLOAT textrotate;             
   FLOAT xscale;                 
   INT32 font;                   
   UINT32 FontFlags;             
   UINT8 m_ShadowRelative;       
   UINT8 m_BaselineFlags;        
   UINT8 m_bCartoonBalloonLeaders;
   UINT8 m_Predefined;              
   
   FLOAT m_LineSpace;            
   FLOAT m_StrokeWidth;          
   FLOAT m_EnhanceWidth;         
   FLOAT m_BoldnessWidth;        
   FLOAT m_UnderlineWidth;       
   FLOAT m_UnderlineOffset;      
   FLOAT m_ShadowOffset;         
   FLOAT m_ShadowAngle;          
   FLOAT m_ClipWidth;            
   
   FLOAT m_Margin;               
   FLOAT m_TMargin;              
   FLOAT m_BMargin;              
   FLOAT m_LMargin;              
   FLOAT m_RMargin;              
   UINT32 m_FrameShape;
   UINT32 m_LineStyleFlags;
   UINT32 m_PolyStyleFlags;
   FLOAT m_LineScale;            
   FLOAT m_PolyBorderScale;      
   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;        
   INT32 BlockNum;               
   FLOAT rotate;                 
   DOUBLE xscale;                
   DOUBLE yscale;                
   DOUBLE zscale;                
   UINT16 numlins;               
   UINT16 numcols;               
   FLOAT linspace;               
   FLOAT colspace;               
   UINT32 space;
   };


struct CADRBOX {        /* Size = 8 */
   FLOAT rotate;                 
   UINT32 space;
   };


struct CADLINE {        /* Size = 8 */
   UINT32 NumPoints;             
   UINT32 CurveFit;              
   };                            /* Followed by the point data */


struct CADPOLY {        /* Size = 16 */
   UINT32 NumPoints;             
   UINT32 NumIslands;            
   UINT32 CurveFit;              
   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;                
   UINT32 yverts;                
   UINT16 CurveFit;              
   UINT16 flags;                 
   UINT32 space;
   };                            /* Followed by the point data in the form of array[xverts][yverts]. */


struct CADELLIPSE {     /* Size = 48 */
   DPOINT2D_OLD center;             
   DOUBLE xsize;                 
   DOUBLE ysize;                 
   FLOAT rotate;                 
   UINT32 space;
   DOUBLE m_zvalue;              
   };


struct CADEARC {        /* Size = 64 */
   DPOINT2D_OLD center;          
   DOUBLE start;                 
   DOUBLE end;                   
   DOUBLE xsize;                 
   DOUBLE ysize;                 
   FLOAT rotate;                 
                                 /* the world X axis*/
   UINT32 space;
   DOUBLE m_zvalue;              
   };


struct CADMULTIPOINT {
   UINT32 NumPoints;             
   UINT32 space;
   };                            /* Followed by the point data */


struct CADMULTILINE {
   UINT32 NumLines;              
   UINT32 CurveFit;              
   };                            /* Followed by the number of points array then followed by the point data */


struct CADMULTIPOLY {
   UINT32 NumPolygons;           
   UINT32 CurveFit;              
   };                            /* Followed by the array of subregion structures then by the data for each sub-region */

struct CADSUBPOLY {
   UINT32 NumPoints;             
   UINT32 NumIslands;            
   };


struct CADPOLYNOM {     /* Size = 40 */
   DPOINT2D_OLD minval;          
   DPOINT2D_OLD maxval;          
   UINT32 NumCoeff;              
   UINT32 space;
   };                            /* Followed by the coefficients of the polynomial */

union CADELEMDATA {              /* Size = 72 */
   CADINSERT insert;             
   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;
   };

#endif      

---