mi32/cgm.h

Go to the documentation of this file.

#ifndef INC_MI32_CGM_H
#define INC_MI32_CGM_H

#ifndef INC_MI32_TRANS2DAFFINE_H
#include <mi32/trans2daffine.h>
#endif

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

#ifndef INC_MI32_UCSTRING_H
#include <mi32/ucstring.h>
#endif

#ifndef  INC_MI32_SCRNUNIT_H
#include <mi32/scrnunit.h>
#endif

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


class CGM;
class CGMPARM;
class CGMELEM;
class PLANECONIC;
class FILEPATH;

#ifndef GENERATING_DOXYGEN_OUTPUT
class CGMPARM {
   public:

      enum PARMTYPE {   
         PARMTYPE_REAL = 0,
         PARMTYPE_SIGNED,
         PARMTYPE_UNSIGNED,
         PARMTYPE_STRING,
         PARMTYPE_COLOR,
         PARMTYPE_POINT
         };

      PARMTYPE GetType (
         ) const {
         return (static_cast<PARMTYPE>(m_type));
         }

      double GetValueDouble (
         ) const {
         return (*((double*)GetData()));
         }
      
      INT32 GetValueSigned (
         ) const {
         return (*((INT32*)GetData()));
         }

      INT32 GetValueUnsigned (
         ) const {
         return (*((UINT32*)GetData()));
         }
      
      const MIUNICODE* GetValueString (
         ) const {
         return ((const MIUNICODE*)GetData());
         }
      
      const COLOR& GetValueColor (
         ) const {
         return (*((const COLOR*)GetData()));
         }
      
      const DPOINT2D& GetValuePoint (
         ) const {
         return (*((const DPOINT2D*)GetData()));
         }
      
      const int GetDataSize (
         ) const {
         return m_size - sizeof(CGMPARM);
         }

      const int GetFullSize (
         ) const {
         return m_size;
         }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      CGMPARM() {}   

      const void* GetData (
         ) const {
         return (this + 1);   
         }

      INT32 m_type;        
      UINT32 m_size;       

      friend class CGM;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
#endif // GENERATING_DOXYGEN_OUTPUT


class CGM {
   public:
      
      enum ASF {  
         ASF_INDIVIDUAL = 0,
         ASF_BUNDLED                          
         };

      enum VDCTYPE {
         VDCTYPE_INTEGER,
         VDCTYPE_REAL
         };

      enum REALMODE {
         REALMODE_FIXED = 0,
         REALMODE_FP
         };

      enum CLIPMODE {
         CLIPMODE_NONE,
         CLIPMODE_LOCUS,      
         CLIPMODE_SHAPE,      
         CLIPMODE_LOCUSTHENSHAPE
         };

      enum COLORMODEL {        
         COLORMODEL_RGB,
         COLORMODEL_CMYK
         };

      enum COLORMODE {
         COLORMODE_INDEXED,
         COLORMODE_DIRECT
         };

      enum INTERIORSTYLE {
         INTERIORSTYLE_HOLLOW,
         INTERIORSTYLE_SOLID,
         INTERIORSTYLE_PATTERN,
         INTERIORSTYLE_HATCH,
         INTERIORSTYLE_EMPTY,
         INTERIORSTYLE_GEOMETRIC,
         INTERIORSTYLE_INTERPOLATED
         };

      enum LINETYPE {
         LINETYPE_SOLID = 1,
         LINETYPE_DASH,
         LINETYPE_DOT,           
         LINETYPE_DASH_DOT,
         LINETYPE_DASH_DOT_DOT
         };

      enum LINECAP {          
         LINECAP_UNSPECIFIED=1,
         LINECAP_BUTT,
         LINECAP_ROUND,
         LINECAP_PROJECTING,
         LINECAP_TRIANGLE
         };

      enum LINEJOIN {         
         LINEJOIN_UNSPECIFIED=1,
         LINEJOIN_MITRE,
         LINEJOIN_ROUND,
         LINEJOIN_BEVEL
         };

      enum LINECONT {
         LINECONT_UNSPECIFIED=1,
         LINECONT_CONTINUE,
         LINECONT_RESTART,
         LINECONT_ADAPTIVE
         };

      enum MARKERTYPE {
         MARKERTYPE_DOT=1,
         MARKERTYPE_PLUS,
         MARKERTYPE_ASTERISK,
         MARKERTYPE_CIRCLE,
         MARKERTYPE_EX
         };

      enum TEXTALIGNMENT {
         TEXTALIGNMENT_NORMAL,
         TEXTALIGNMENT_LEFT,     
         TEXTALIGNMENT_CENTER,      
         TEXTALIGNMENT_RIGHT,    
         TEXTALIGNMENT_CONTINUOUS,
         TEXTALIGNMENT_TOP,      
         TEXTALIGNMENT_CAP,      
         TEXTALIGNMENT_HALF,     
         TEXTALIGNMENT_BASE,     
         TEXTALIGNMENT_BOTTOM 
         };

      enum TEXTPATH {
         TEXTPATH_LEFT,
         TEXTPATH_RIGHT,
         TEXTPATH_UP,
         TEXTPATH_DOWN
         };

      enum TEXTPRECISION {
         TEXTPRECISION_STRING,  
         TEXTPRECISION_CHARACTER,
         STROKE
         };

      enum SCALEMODE {
         SCALEMODE_ABSTRACT = 0,
         SCALEMODE_METRIC
         };

      enum SIZEMODE {
         SIZEMODE_ABSOLUTE = 0,
         SIZEMODE_SCALED,
         SIZEMODE_FRACTIONAL,
         SIZEMODE_MM
         };

      enum VIEWPORTSPECMODE {
         VIEWPORTSPECMODE_FractionOfDrawingSurface,
         VIEWPORTSPECMODE_MMWithScaleFactor,
         VIEWPORTSPECMODE_DeviceCoordinates
         };


      // CONSTRUCTOR / DESTRUCTOR

      CGM (
         );

      virtual ~CGM (
         );

      // PUBLIC METHODS

      void GetExtents (
         DRECT2D& rect
         ) const {
         rect = m_VDCExtent;
         return;
         }

      int ReadFile (
         const FILEPATH& fname
         );

      int Render (
         );

      void SetTransAffine (
         const MAT3X3 forward,
         const MAT3X3 inverse
         );

      void SetTransAffine (
         const TRANS2D_AFFINE& trans
         );


   protected:
      struct STYLEEXTRA {
         SCREENUNIT m_LineWidthUnits;        
         SCREENUNIT m_EdgeWidthUnits;        
         SCREENUNIT m_PointSizeUnits;        
         SCREENUNIT m_TextSizeUnits;         

         STYLEEXTRA() :
            m_LineWidthUnits(SCREENUNIT_Points), 
            m_EdgeWidthUnits(SCREENUNIT_Points),
            m_PointSizeUnits(SCREENUNIT_Points),
            m_TextSizeUnits(SCREENUNIT_Points)
            {
            }
         };

      struct PRIMITIVECONTEXT {
         PRIMITIVECONTEXT();

         POINTSTYLE  m_PointStyle;
         LINESTYLE   m_LineStyle;
         POLYSTYLE   m_PolyStyle;
         TEXTSTYLE   m_TextStyle;
         STYLEEXTRA  m_StyleExtra;

         UINT32 m_id;                     
         UINT32  m_LineBundleIndex;          
         LINETYPE m_LineType;             
         double m_LineWidth;              
         COLOR m_LineColor;         
         CLIPMODE m_LineClipMode;         
         LINECAP m_LineCap;               
         LINECAP m_DashCap;               
         LINEJOIN m_LineJoin;             
         LINECONT m_LineTypeContinuation;    
         double m_LineTypeInitOffset;     

         UINT32 m_MarkerBundleIndex;         
         MARKERTYPE m_MarkerType;         
         double m_MarkerSize;             
         COLOR m_MarkerColor;       
         CLIPMODE m_MarkerClipMode;       

         UINT32 m_TextBundleIndex;           
         UINT32 m_TextFontIndex;             
         TEXTPRECISION m_TextPrecision;   
         double m_CharExpFactor;          
         double m_CharSpacing;            
         COLOR m_TextColor;         
         double m_CharHeight;             

         double m_CharOrientXUp;          
         double m_CharOrientYUp;          
         double m_CharOrientXBase;        
         double m_CharOrientYBase;        
         TEXTPATH m_TextPath;             
         TEXTALIGNMENT m_TextHAlignment;  
         TEXTALIGNMENT m_TextVAlignment;  
         double m_TextContHAlign;         
         double m_TextContVAlign;         
         UINT32 m_CharSetIndex;              
         UINT32 m_AltCharSetIndex;           
         UINT32 m_TextScoreType;             
         UINT32 m_RestrictedTextType;        

         UINT32 m_FillBundleIndex;           
         INTERIORSTYLE m_InteriorStyle;   
         COLOR m_FillColor;         
         UINT32 m_HatchIndex;                
         UINT32 m_PatternIndex;              

         UINT32 m_EdgeBundleIndex;           
         LINETYPE m_EdgeType;             
         double m_EdgeWidth;              
         COLOR m_EdgeColor;         
         bool m_bEdgeVisibility;          
         CLIPMODE m_EdgeClipMode;         
         LINECAP m_EdgeCap;               
         LINECAP m_EdgeDashCap;           
         LINEJOIN m_EdgeJoin;             
         LINECONT m_EdgeTypeContinuation;    
         double m_EdgeTypeInitOffset;     
         
         DPOINT2D m_FillReferencePoint;

         COLOR m_SymbolColor;
         double m_SymbolSize;
         double m_SymbolOrientXUp;           
         double m_SymbolOrientYUp;           
         double m_SymbolOrientXBase;         
         double m_SymbolOrientYBase;         

         DRECT2D m_ClipRect;
         bool m_bClipIndicator;
         UINT32 m_ProtectionRegionIndicator; 
         COLOR m_AuxColor;
         COLOR m_TransparentCellColor;    
         bool m_bTransparency;            
         double m_MitreLimit;             
         
         ASF m_asfLineType,
             m_asfLineWidth,
             m_asfLineColor,
             m_asfMarkerType,
             m_asfMarkerSize,
             m_asfMarkerColor,
             m_asfTextFontIndex,
             m_asfTextPrecision,
             m_asfCharExpFactor,
             m_asfCharSpacing,
             m_asfTextColor,
             m_asfInteriroStyle,
             m_asfFillColor,
             m_asfHatchIndex,
             m_asfPatternIndex,
             m_asfEdgeType,
             m_asfEdgeWidth,
             m_asfEdgeColor;
         };

      // Protected methods

      const PRIMITIVECONTEXT& GetPC (
         ) {
         return m_PC;
         }


      virtual int v_RenderConic (
         const PLANECONIC& conic
         );

      virtual int v_RenderBSpline (
         int order,
         int NumPts,
         const DPOINT2D* cpoints,      
         const double* knots,          
         const double* weights,        
         double Start,
         double End
         );

      virtual int v_RenderBezier (
         int NumPts,
         DPOINT2D* cpoints,
         bool bContinuous
         );

      virtual int v_RenderCircle (
         const DPOINT2D& center,
         double radius
         );


      virtual int v_RenderEllipse (
         const DPOINT2D& center,
         double xradius,
         double yradius,
         double RotAngle
         );


      virtual int v_RenderEllipse (
         const DPOINT2D& center,
         const DPOINT2D& EndPoint1,
         const DPOINT2D& EndPoint2
         );

      virtual int v_RenderLine (
         const DPOINT2D& start,
         const DPOINT2D& end
         );

      virtual int v_RenderMarker (
         const DPOINT2D& point
         );

      virtual int v_RenderPolygon (
         const POLYLINE& polygon
         );

      virtual int v_RenderPolygons (
         const POLYLINELIST& polygons
         );

      virtual int v_RenderPolyline (
         const POLYLINE& line
         );

      virtual int v_RenderRectangle (
         const DPOINT2D* points
         );

      virtual int v_RenderRectangle (
         const DRECT2D& rect
         );

      virtual int v_RenderText (
         const DPOINT2D& basept,
         const TEXTSTYLE& style,
         const STYLEEXTRA& extra,
         const MIUNICODE* str
         );

      virtual int v_SetPointStyle (
         const POINTSTYLE& style,
         const STYLEEXTRA& extra
         );

      virtual int v_SetLineStyle (
         const LINESTYLE& style,
         const STYLEEXTRA& extra
         );

      virtual int v_SetPolyStyle (
         const POLYSTYLE& style,
         const STYLEEXTRA& extra
         );

      virtual int v_SetTextStyle (
         const TEXTSTYLE& style,
         const STYLEEXTRA& extra
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      class ELEMENT {
         public:

         int GetClass (
            ) const {
            return m_ElemClass;
            }

         int GetElementID (
            ) const {
            return m_ElemID;
            }

         int GetNumParms (
            ) const {
            return m_NumParms;
            }

         const CGMPARM* GetParm (
            const CGM* cgm,
            int ParmNum
            ) const;

         private:
            int m_ElemClass;
            int m_ElemID;
            int m_FirstParmOffset;
            int m_NumParms;

            friend class CGM;
         }; 



      // PRIVATE METHODS

      int AddParm (
         ELEMENT* elem,
         double val
         );

      int AddParm (
         ELEMENT* elem,
         INT32 val
         );

      int AddParm (
         ELEMENT* elem,
         UINT32 val
         );

      int AddParm (
         ELEMENT* elem,
         const MIUNICODE* val
         );

      int AddParm (
         ELEMENT* elem,
         COLOR& val
         );

      int AddParm (
         ELEMENT* elem,
         DPOINT2D& val
         );

      void FigureBegin();
      void FigureEnd();
      void FigureFree();
      void FigureNewPoly();
      void FigureAddPoints (
         const POLYLINE& points
         );

      double GetAngle (
         CGMELEM& elem,
         int dxParmNum,
         int dyParmNum
         );

      #ifndef GENERATING_DOXYGEN_OUTPUT
      #endif 

      int GetSI8() {
         return *((signed char*)m_pNextByte++);
         }

      int GetSI16() {
         UINT16 word = (m_pNextByte[0] << 8) | m_pNextByte[1];
         m_pNextByte += 2;
         return ((INT16)word);
         }

      int GetSI24() {
         UINT32 word = (m_pNextByte[0] << 16) | (m_pNextByte[1] << 8) | m_pNextByte[2];
         if (word & 0x00800000) word |= 0xFF000000;   
         m_pNextByte += 3;                      
         return ((INT32)word);
         }

      int GetSI32() {
         UINT32 word = (m_pNextByte[0] << 24) | (m_pNextByte[1] << 16) | (m_pNextByte[2] << 8) | m_pNextByte[3];
         m_pNextByte += 4;                      
         return ((INT32)word);
         }

      int GetSI (
         int precision
         ) {
         switch (precision) {
            case 8: return (GetSI8());
            case 16: return (GetSI16());
            case 24: return (GetSI24());
            case 32: return (GetSI32());
            }
         return (0); 
         }

      UINT8 GetUI8() {
         return *m_pNextByte++;
         }

      UINT8 GetC() {
         return *m_pNextByte++;
         }

      UINT16 GetUI16() {
         UINT16 word = (m_pNextByte[0] << 8) | m_pNextByte[1];
         m_pNextByte += 2;
         return ((INT16)word);
         }

      UINT32 GetUI24() {
         UINT32 word = (m_pNextByte[0] << 16) | (m_pNextByte[1] << 8) | m_pNextByte[2];
         m_pNextByte += 3;                      
         return (word);
         }

      UINT32 GetUI32() {
         UINT32 word = (m_pNextByte[0] << 24) | (m_pNextByte[1] << 16) | (m_pNextByte[2] << 8) | m_pNextByte[3];
         m_pNextByte += 4;                      
         return (word);
         }

      UINT32 GetUI (
         int precision
         ) {
         switch (precision) {
            case 8: return (GetUI8());
            case 16: return (GetUI16());
            case 24: return (GetUI24());
            case 32: return (GetUI32());
            }
         return (0); 
         }

      double GetFX32() {
         double WholePart = (double)GetSI16();
         double FracPart = (double)GetUI16();
         return (WholePart + (FracPart / (double)(0xffffUL))); 
         }

      double GetFX64() {
         double WholePart = (double)GetSI32();
         double FracPart = (double)GetUI32();
         return (WholePart + (FracPart / (double)(0xffffffffUL)));   
         }

      double GetFX (
         int precision
         ) {
         switch (precision) {
            case 32: return (GetFX32());
            case 64: return (GetFX64());
            }
         return (0.0);  
         }

      double GetFP32() {
         #ifdef BYTEORDER_LoHi
            UINT8 bytes[4];
            bytes[0] = *m_pNextByte++;
            bytes[1] = *m_pNextByte++;
            bytes[2] = *m_pNextByte++;
            bytes[3] = *m_pNextByte++;
            SwapBytes4(bytes, 1);
            return *(float*)bytes;
         #else
            float fp = *(float*)m_pNextByte;
            m_pNextByte += 4;
            return(fp);
         #endif
         }

      double GetFP64() {
         #ifdef BYTEORDER_LoHi
            UINT8 bytes[8];
            bytes[0] = *m_pNextByte++;
            bytes[1] = *m_pNextByte++;
            bytes[2] = *m_pNextByte++;
            bytes[3] = *m_pNextByte++;
            bytes[4] = *m_pNextByte++;
            bytes[5] = *m_pNextByte++;
            bytes[6] = *m_pNextByte++;
            bytes[7] = *m_pNextByte++;
            SwapBytes8(bytes, 1);
            return *(double*)bytes;
         #else
            double fp = *(double*)m_pNextByte;
            m_pNextByte += 4;
            return(fp);
         #endif
         }

      double GetFP (
         int precision
         ) {
         switch (precision) {
            case 32: return (GetFP32());
            case 64: return (GetFP64());
            }
         return (0.0);  
         }


      double GetR (
         int precision,
         REALMODE mode
         ) {
         if (mode == REALMODE_FIXED) {
            return (GetFX(precision));
            }
         else {
            return (GetFP(precision));
            }
         }

      double GetVDC() {
         if (m_VDCType == VDCTYPE_REAL) {
            return (GetR(m_vrp, m_VDCRealMode));
            }
         else {
            return (GetSI(m_vip));
            }
         }

      double GetVC() {
         if (m_VPSpecMode == VIEWPORTSPECMODE_FractionOfDrawingSurface) {
            return (GetR(m_rp, m_RealMode));
            }
         else {
            return (GetSI(m_ip));
            }
         }

      UINT32 GetLength () {
         UINT8 byte = GetUI8();
         if (byte < 255) return(byte);
         else return(GetLengthLongForm());
         }

      UINT32 GetLengthLongForm () {
         UINT32 length = 0;
         for (;;) {
            UINT16 word = GetUI16();
            length |= word & 0x7FFF;
            if (!(word & 0x8000)) return(length);
            length <<= 15;
            }
         }

      int ParmAlloc (
         CGMPARM::PARMTYPE type,
         const void* data,
         int size             
         );

      int ProcessClass0Element (CGMELEM& elem, bool bRender);
      int ProcessClass1Element (CGMELEM& elem, bool bRender);
      int ProcessClass2Element (CGMELEM& elem, bool bRender);
      int ProcessClass3Element (CGMELEM& elem, bool bRender);
      int ProcessClass4Element (CGMELEM& elem, bool bRender);
      int ProcessClass5Element (CGMELEM& elem, bool bRender);
      int ProcessClass6Element (CGMELEM& elem, bool bRender);
      int ProcessClass7Element (CGMELEM& elem, bool bRender);
      int ProcessClass8Element (CGMELEM& elem, bool bRender);

      int ProcessElement (
         ELEMENT* pelem,
         bool bRender
         );

      int ScanCGM ();

      int ScanCGMBinary ();
      int ScanCGMCharEncoded ();
      int ScanCGMClearText ();

      int ScanElemParms (
         ELEMENT* elem,
         const char* constParmSpec,
         int ParmListLen
         );

      PRIMITIVECONTEXT* GetPC (
         UINT32 id,
         bool bAllocIfMissing = false
         );

      // PRIVATE DATA

      SIMPLE_ARRAY<ELEMENT> m_elem;
      UINT8* m_buf;
      UINT8* m_pNextByte;     
      int m_BufSize;
      int m_ParmBufNext;      
      int m_ParmBufSize;
      UINT8* m_pParmBuf;

      // CGM states
      VDCTYPE m_VDCType;
      REALMODE m_RealMode;
      REALMODE m_VDCRealMode;
      SCALEMODE m_ScaleMode;
      double m_ScaleFactor;
      VIEWPORTSPECMODE m_VPSpecMode;
      double m_VPScaleFactor;
      UINT32 m_rp;            
      UINT32 m_ip;            
      UINT32 m_ixp;           
      UINT32 m_cip;           
      UINT32 m_dcp;           
      UINT32 m_vrp;
      UINT32 m_vip;
      UINT32 m_namep;         
      double m_TransScale;
      double m_TransRotAngle;
      double m_TransShearAngle;
      MIUNICODE** m_FontList;
      MIUNICODE** m_CharSetList;
      
      COLORMODEL m_ColorModel;
      COLORMODE m_ColorMode;
      INT32 m_ColorCalib;  
      SIZEMODE m_LineWidthMode;
      SIZEMODE m_MarkerSizeMode;
      SIZEMODE m_EdgeWidthMode;
      DRECT2D m_VDCMaxExtent;       
      DRECT2D m_VDCExtent;       
      DRECT2D m_DeviceViewPort;  

      COLOR m_BGColor;
      LPOINT3D m_RGBMin;
      LPOINT3D m_RGBMax;
      DPOINT3D m_CIEScale;
      DPOINT3D m_CIEOffset;

      int m_NumPCs;
      PRIMITIVECONTEXT **m_PCList;
      PRIMITIVECONTEXT m_PC;
      POLYLINELIST m_FigurePolygons;
      bool m_bDefineFigure;

      
      COLOR *m_pColorTable;
      UINT32 m_MaxColorIndex;       

      TRANS2D_AFFINE m_trans;    

      MAT3X3 m_FwdAffine, m_InvAffine;

      friend class CGMELEM;   
      friend class ELEMENT;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };



#ifndef GENERATING_DOXYGEN_OUTPUT
class CGMELEM {
public:

   int GetClass (
      ) const {
      return m_Elem.GetClass();
      }

   int GetElementID (
      ) const {
      return m_Elem.GetElementID();
      }

   int GetNumParms (
      ) const {
      return m_Elem.GetNumParms();
      }

   const CGMPARM* GetParm (
      int ParmNum
      ) const {
      return m_Elem.GetParm(m_pCGM, ParmNum);
      }

   bool GetParm (
      int ParmNum,
      double& retval
      ) {
      const CGMPARM* parm = GetParm(ParmNum);
      if (!parm) return(false);
      retval = parm->GetValueDouble();
      return(true);
      }

   bool GetParm (
      int ParmNum,
      UINT32& retval
      ) {
      const CGMPARM* parm = GetParm(ParmNum);
      if (!parm) return(false);
      retval = parm->GetValueUnsigned();
      return(true);
      }

   bool GetParm (
      int ParmNum,
      INT32& retval
      ) {
      const CGMPARM* parm = GetParm(ParmNum);
      if (!parm) return(false);
      retval = parm->GetValueSigned();
      return(true);
      }

   bool GetParm (
      int ParmNum,
      COLOR& retval
      ) {
      const CGMPARM* parm = GetParm(ParmNum);
      if (!parm) return(false);
      retval = parm->GetValueColor();
      return(true);
      }

   bool GetParm (
      int ParmNum,
      DPOINT2D& retval
      ) {
      const CGMPARM* parm = GetParm(ParmNum);
      if (!parm) return(false);
      retval = parm->GetValuePoint();
      return(true);
      }

   bool GetParm (
      int ParmNum,
      MIUNICODE** retval
      ) {
      const CGMPARM* parm = GetParm(ParmNum);
      if (!parm || !retval) return(false);
      *retval = ucstrdup(parm->GetValueString());
      return(true);
      }

private:
   #ifndef GENERATING_DOXYGEN_OUTPUT
   CGMELEM (
      CGM* cgm,
      const CGM::ELEMENT& elem
      ) :
      m_pCGM(cgm),
      m_Elem(elem)
      { 
      }

   CGM* m_pCGM;
   const CGM::ELEMENT& m_Elem;

   friend class CGM;    
   #endif // GENERATING_DOXYGEN_OUTPUT
   };


#endif 

#endif  // INC_MI32_CGM_H

---