mi32/mgd2.h

Go to the documentation of this file.

/******************************************************************************,
 * \file mi32/mgd2.h
 * \brief MicroImages Graphics Device
 *
 * \if NODOC
 * $Log: mgd2.h_v $
 * Revision 1.202  2012/03/15 17:33:31  mju
 * Add typeid support to allow device type identification.
 * Don't inline copyRect.
 *
 * Revision 1.201  2012/03/08 16:29:57  mju
 * Make getAllPlanesMask public.
 *
 * Revision 1.200  2012/01/26 22:28:30  mju
 * Remove unused drawPointPattern variant.
 *
 * Revision 1.199  2012/01/26 14:34:30  mju
 * Update some context virtual methods.
 *
 * Revision 1.198  2012/01/25 15:30:03  mju
 * Clean up context member definitions.
 *
 * Revision 1.197  2012/01/13 16:02:27  mju
 * Add useVirtualBuffer for getDepthBuffer.
 *
 * Revision 1.196  2011/12/19 15:58:22  mju
 * Use stipplemask class.
 *
 * Revision 1.195  2011/12/15 22:46:44  mju
 * Add stippleGetMaskRow/Test methods.
 *
 * Revision 1.194  2011/12/15 18:56:42  mju
 * Add base stipple support.
 *
 * Revision 1.193  2011/11/10 22:25:12  mju
 * Allow separate depth buffer for each frame buffer, and avoid implying only for 3D.
 * Add device::getNull so can hide null device defns.
 * Don't inline any virtual methods.
 * Change hatchMBR so don't need to include rvc header.
 *
 * Revision 1.192  2011/10/31 15:07:42  mju
 * In getImagePointer put useVirtualWindow parm last to reduce ambiguity.
 *
 * Revision 1.191  2011/10/28 21:14:48  mju
 * Require frame buffer parm for getImagePointer/const and writeImageBuffer.
 *
 * Revision 1.190  2011/10/26 17:58:25  mju
 * Frame buffer support.
 *
 * Revision 1.189  2011/10/12 17:05:14  mju
 * Use stylepattern_base in multiPassTestStyle.
 *
 * Revision 1.186  2010/09/16 22:50:31  bcolombe
 * Added method to textblock for turning off parsing of format chars
 *
 * Revision 1.185  2010/05/05 13:45:25  mju
 * Add device::getVirtualOffset and hasVirtualWindow protected methods.
 *
 * Revision 1.183  2009/11/12 17:14:55  mju
 * Add drawIcon using iconid.
 *
 * Revision 1.182  2009/09/28 17:45:13  mju
 * Add drawSimpleArrowHead and drawSimpleFrame.
 *
 * Revision 1.180  2008/09/23 14:47:51  mju
 * No default for prompt parm in dlgGetScalableFont.
 *
 * Revision 1.178  2008/08/07 13:29:38  mju
 * Add setNoFillRightPolyPixels.
 *
 * Revision 1.177  2008/05/01 17:38:19  bcolombe
 * Changed GetLineWidth to return double - everything that is using it expects double
 *
 * Revision 1.172  2007/07/24 20:41:19  dwilliss
 * Added method to reset virtual window
 *
 * Revision 1.167  2007/07/10 14:35:50  dwilliss
 * Added Transparency Mode
 *
 * Revision 1.166  2007/06/15 21:47:45  ldyas
 * added DrawLines Dashed which takes a polyline.
 *
 * Revision 1.150  2007/03/15 15:11:06  scowan
 * Added method to set aliasing to text block.
 * Fixed some textblock comments.
 *
 * Revision 1.133  2006/11/30 20:53:44  dwilliss
 * Added Images pointer to TEXTBLOCK
 *
 * Revision 1.120  2006/09/08 20:34:58  dwilliss
 * Added methods to fill/draw rounded rectangles
 *
 * Revision 1.105  2005/03/30 20:32:35  dwilliss
 * Added MultiPass rendering methods
 *
 * Revision 1.1  2001/07/11 17:33:41  dwilliss
 * Initial revision
 * \endif
 */

#ifndef INC_MI32_MGD2_H
#define INC_MI32_MGD2_H

#ifndef INC_MI32_MG2BASE_H
#include <mi32/mg2base.h>
#endif

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

#ifndef INC_MI32_DISPINFO_H
#include <mi32/dispinfo.h>
#endif

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

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

#ifndef INC_MI32_TEXTBASE_H
#include <mi32/textbase.h>
#endif

#ifndef  INC_MI32_COLORARRAY_H
#include <mi32/colorarray.h>
#endif

#ifndef INC_MI32_MG2CMS_H
#include <mi32/mg2cms.h>
#endif

#ifndef INC_MI32_MG2ENUMS_H
#include <mi32/mg2enums.h>
#endif

#ifndef INC_MI32_ICONID_H
#include <mi32/iconid.h>
#endif

#ifndef INC_MI32_STIPPLEMASK_H
#include <mi32/stipplemask.h>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward declarations.
class MISTRING;
class LABELSTYLE;
class POLYLINE;
class POLYLINELIST;
class REGION2D;
class SUBREGION2D;
struct TEXTMETRICS;
struct FTFACE;
struct COLORCOMPSTRUCT;
struct MICONSTRUCT;
class BINARYTOREGIONINTERFACE;
class SAVEFONTFLAGS;
namespace SPATMOD {
   namespace IMAGE {
      class STAGE_ARRAY;
      }
   }
namespace HTML {
   class HTMLDOC;
   }
namespace RVC {
   class STYLE;
   class RASTER;
   class STYLEPATTERN_BASE;
   class STYLEPATTERN_BITMAP;
   class STYLEPATTERN_LINE;
   class STYLEPATTERN_HATCH;
   class STYLEPATTERN_SYMBOL;
   }
namespace {
   class LOCALOPENFONTS;      // Located in mg2text.c
   }
namespace MGD {
   class OTPRIV;
   struct STRINGDATA;
   class CONTEXT;
   class DEVICE_MEM1;
   class DEVICE_MEM1_SPARSE;
   class DEVICE_MEM8G;
   }
#endif // GENERATING_DOXYGEN_OUTPUT


namespace MGD {

//=====================================================================================================================
// Special characters in array of Glyph IDs (GID) returned from
// FONT.UCtoGID().  When rendering or computing string width,
// These shoul be passed through to let the rendering engine handle them
// XXX These should be private to mg2textt.c and mgdtext.c
#define  MgdTEXTGID_ChangeFace      0xFFFF   
#define  MgdTEXTGID_LeftToRight     0xFFFE
#define  MgdTEXTGID_RightToLeft     0xFFFD
#define  MgdTEXTGID_NextGlyph0Width 0xFFFC
#define  MgdTEXTGID_FallbackFace    0xFFFB
#define  MgdTEXTGID_SpecialCodeMin  0xFFFB   // For quicker comparison

//=====================================================================================================================
struct GLYPHINFO {
   double lbearing;                    
   double rbearing;                    
   double rspacing;                    
   double ascent;                      
   double descent;                     
   };

//=====================================================================================================================
struct FONTINFO {
   double ascent;                      
   double descent;                     
   double linespace;                   
   UINT16 NumGlyphs;                   
   UINT16 InitChar;                    
   UINT16 LastChar;                    
   UINT16 NullChar;                    
   };

//=====================================================================================================================
class FONT {
   public:

      enum MODE {
         MODE_MIUNICODE,                     
         MODE_RAWGID,                     
         MODE_GID                         
         };

      enum FONTTYPE {
         FONTTYPE_OF,
         FONTTYPE_TTF
         };

      static ERRVALUE ReadTTF (
         const MIUNICODE* name,
         SIMPLE_ARRAY<UINT8>& data
         );

      FONT();

      virtual ~FONT();
      
      virtual int DrawGlyph (
         MGD::CONTEXT* context, 
         double dx, 
         double dy, 
         double baseangle, 
         const MIUNICODE* ucstr, 
         MGD::FONT::MODE mode
         ) = 0;

      virtual int DrawGlyph (
         MGD::CONTEXT* context, 
         double dx, 
         double dy, 
         double baseangle, 
         const STRINGDATA& string,
         int n
         ) = 0;

      virtual double NextPosition (
         MGD::CONTEXT* context, 
         double* retx, 
         double* rety, 
         double baseangle, 
         const STRINGDATA& string,
         int n,
         double SpaceExtra = 0.0,   
         double GlyphExtra = 0.0
         ) = 0;

      virtual int GetFontMetrics (
         MGD::CONTEXT* context, 
         MGD::FONTINFO& fontinfo
         ) = 0;
      
      virtual int GetGlyphMetrics (
         MGD::CONTEXT* context, 
         MIUNICODE ch, 
         MGD::GLYPHINFO& glyphinfo, 
         MGD::FONT::MODE mode
         ) = 0;

      virtual int GetGlyphExtents (
         MGD::CONTEXT* context, 
         const double& dx, 
         const double& dy, 
         const double& baseangle, 
         MIUNICODE ch, 
         DRECT2D& extents, 
         MGD::FONT::MODE mode
         ) = 0;

      virtual bool IsEmbeddable (
         ) const = 0;

      virtual int UCtoGID (
         MGD::CONTEXT* context, 
         const MIUNICODE* uc, 
         MGD::STRINGDATA& strdata
         ) = 0;

      const MIUNICODE* GetFontName (
         ) const {
         return (m_fontname);
         }

      virtual MGD::FONT::FONTTYPE GetFontType (
         ) const = 0;
      
      virtual ERRVALUE GetGlyphOutline (
         UINT16 GlyphIndex,
         REGION2D& region,
         UINT32 FontFlags
         );

      MIUNICODE GetInitChar (
         ) const {
         return (m_InitChar);
         }
      
      MIUNICODE GetLastChar (
         ) const {
         return (m_LastChar);
         }
      
      MIUNICODE GetNULLChar (
         ) const {
         return (m_NullChar);
         }
      
      MIUNICODE GetNumGlyphs (
         ) const {
         return (m_NumGlyphs);
         }

   protected:
      MISTRING m_fontname;
      FILEPATH m_filename;
      UINT16 m_NumGlyphs;              
      MIUNICODE m_InitChar;               
      MIUNICODE m_LastChar;               
      MIUNICODE m_NullChar;               
   };

//=====================================================================================================================
struct TEXTSETTINGS : public TEXTSTYLE {
   PIXEL ForegroundPixel;
   PIXEL BackgroundPixel;
   PIXEL UnderlinePixel;
   
   TEXTSETTINGS (
      ) { Reset(); }
      
   double GetBoldness (
      ) const { return (BoldnessWidth); }

   void Reset (
      );
      
   };

//=====================================================================================================================
struct TEXTBLOCK {

   TEXTBLOCK();
   TEXTBLOCK(const TEXTBLOCK&);

   ~TEXTBLOCK();

   ERRVALUE ComputeExtents (
      MGD::CONTEXT* gc,
      DRECT2D& rect
      );

   int Draw (
      MGD::CONTEXT* gc
      );

   double GetBaseAngle (
      ) const { return (m_baseangle); }

   const DPOINT2D& GetBasePoint (
      ) const { return (m_basepoint); }

   TEXTBASEORIGIN GetBaseOrigin (
      ) const { return (m_baseorigin); }

   ERRVALUE GetFirstString (
      MISTRING& string           
      );

   ERRVALUE GetFirstString (
      MGD::CONTEXT* gc,
      MISTRING& string           
      );

   HTML::HTMLDOC* GetHTMLDOC (
      );

   const TEXTSTYLE& GetStyle (
      ) const { return m_Style; }

   const MISTRING& GetText (
      ) const {
      return (m_Text);
      }

   bool IsAntialiased (
      ) const { return m_bIsAntialiased; }

   void SetAntialiasing (
      bool value
      ) { m_bIsAntialiased = value; }

   void SetBaseAngle (
      double angle = 0     
      );

   void SetBasePoint (
      const DPOINT2D& pt,
      TEXTBASEORIGIN baseorigin = TEXTBASEORIGIN_FirstLine     
      );

   void SetDoFormatting (bool bDoFormatting);

   void SetImages (
      const SIMPLE_ARRAY<MGD::DEVICE*>& Images
      );

   void SetStyle (
      const TEXTSTYLE& Style
      );

   void SetText (
      const MISTRING& text
      );

   void SetSourcePath (
      const FILEPATH& filepath
      );

   bool UsesTransparency (
      ) const { return m_bUsesTransparency; }

#ifndef GENERATING_DOXYGEN_OUTPUT
   private:
      class PRIV;
      friend class PRIV;
      PRIV* m_Priv;

      MISTRING m_Text;                       
      TEXTSTYLE m_Style;                     
      DPOINT2D m_basepoint;                  
      double m_baseangle;                    
      TEXTBASEORIGIN m_baseorigin;           
      bool m_bIsAntialiased;                 
      bool m_bUsesTransparency;              
#endif
   };

//=====================================================================================================================
class DEVICE {
   public:

      static DEVICE& GetNull ();

      virtual ~DEVICE ();

      bool AvoidFillSpans (
         ) const { return (v_AvoidFillSpans()); }

      ERRVALUE Clear (
         const COLOR& color
         ) { return (v_Clear(color)); }

      void ClearICMDestProfile (
         ) { m_DestProfile.Free(); }

      void ClearICMProofProfile ()
         { m_ProofProfileParms.m_bProofToScreen = false; }

      ERRVALUE ComputeRegion (
         BINARYTOREGIONINTERFACE& bintoreg,
         COMPONENT component = COMPONENT_Alpha,
         int threshold = 128,
         bool above = true    
         ) const;

      double ConvertScreenUnits (
         double value,                       
         int iunits,                         
         int ounits                          
         ) const { return (::ConvertScreenUnits(value,GetPixelSizeMM(),1.0,iunits,ounits)); }

      MGD::CONTEXT* CreateContext ();

      ERRVALUE DepthInit ();

      ERRVALUE DepthInit (
         UINT16 FrameBuffer               
         );

      void DepthRelease ();

      void DepthRelease (
         UINT16 FrameBuffer               
         );

      PIXEL GetAllPlanesMask (
         ) const { return (m_AllPlanesMask); }

      CAPABILITY GetCapabilities () const
         { return (v_GetCapabilities()); }

      const COLOR_ARRAY* GetColorMap (
         ) const { return (v_GetColorMap()); }

   #ifndef NO_DEPRECATED
      DEPRECATED PIXEL GetColorPixel (
         const COLOR& color
         ) { return (v_GetColorPixel(color)); }
   #endif

      COLORSPACE GetColorSpace (
         ) const { return (v_GetColorSpace()); }

      float GetDepth (
         INT32 x, 
         INT32 y,
         UINT16 FrameBuffer
         ) const;

      const DISPLAYINFO& GetDeviceInfo (
         ) const { return (m_devinfo); }

      const LRECT2D& GetExtents (
         ) const { return (m_Extents); }

      INT32 GetHeight (
         ) const { return (GetExtents().GetHeight()); }

      const PROFILE& GetICMDestProfile (
         ) const { return (m_DestProfile); }

      PROFILE::INTENT GetICMIntent (
         ) const { return (m_ICMIntent); }

      int GetImageBytesPerPixel (
         ) const { return (m_ImageBytesPerPixel); }

      UINT8* GetImagePointer (
         INT32 x,
         INT32 y,
         INT32 len,
         UINT16 FrameBuffer,
         bool UseVirtualWindow
         ) {
         if (UseVirtualWindow && m_bHasVirtualWindow) {
            x -= m_offset.x;
            y -= m_offset.y;
            }
         return (v_GetImagePointer(x,y,len,FrameBuffer));
         }

      UINT8* GetImagePointer (
         INT32 x,
         INT32 y,
         INT32 len,
         UINT16 FrameBuffer
         ) { return (v_GetImagePointer(x,y,len,FrameBuffer)); }

      bool GetNeedFullImageLine (
         ) const { return (v_GetNeedFullImageLine()); }

      UINT16 GetNumFrameBuffers () const
         { return (v_GetNumFrameBuffers()); }

   #ifndef NO_DEPRECATED
      DEPRECATED void GetPixelColor (
         PIXEL pixel,
         COLOR& color
         ) const {
         v_GetPixelColor(pixel, color);
         }
   #endif

      double GetPixelSizeMM () const;

      void GetPixelSizeMM (
         double& xsize,
         double& ysize
         ) const;

      double GetPixelSizeDPI (
         ) const { return ((1000.0 / METERSTOINCHES) / GetPixelSizeMM()); }

      void GetPixelSizeDPI (
         double& xsize,
         double& ysize
         ) const {
         double x, y;
         GetPixelSizeMM(x, y);
         xsize = (1000.0 / METERSTOINCHES) / x;
         ysize = (1000.0 / METERSTOINCHES) / y;
         }

      UINT32 GetTypeId () const
         { return (m_TypeId); }

      INT32 GetWidth (
         ) const { return (GetExtents().GetWidth()); }

      bool HasCapability (
         MGD::CAPABILITY capability
         ) const { return ((v_GetCapabilities() & capability) != 0); }

      bool HasDepth (
         UINT16 FrameBuffer               
         ) const { return (FrameBuffer < m_DepthBuffers.GetNumItems() && m_DepthBuffers[FrameBuffer] != 0); }

      void ResetVirtualWindow ();
      
      void SetDepth (
         INT32 x, 
         INT32 y,
         float z,
         UINT16 FrameBuffer
         );

      void SetICMDestProfile (
         const PROFILE& profile,
         PROFILE::INTENT intent = PROFILE::INTENT_Perceptual
         );

      void SetICMDestProfile (
         const PROFILEPARMS_PRINTER& profile
         );

      void SetICMDestProfileScreen ();

      void SetICMProofProfile (
         const PROFILEPARMS_PRINTER& profile
         );

      void SetPixelSizeMM (      
         double xsize,
         double ysize
         ) { m_mmPerPixel.Set(xsize,ysize); }

      void SetVirtualWindow (
         INT32 dx,
         INT32 dy,
         INT32 fullwidth,
         INT32 fullheight
         );
      
      bool SupportsOpacityBlendMode (
         MGD::OPACITY_MODE mode
         ) const { return (v_SupportsOpacityBlendMode(mode)); }

   protected:

      #ifndef GENERATING_DOXYGEN_OUTPUT
      LRECT2D m_Extents;            // All implementations need this
      PIXEL m_AllPlanesMask;
      int m_ImageBytesPerPixel;
      DPOINT2D m_mmPerPixel;
      LPOINT2D m_TileSize;          // Tile size hint (0's if tiles not helpful)
      #endif

      static UINT32 AllocTypeId ()
         { ++s_LastTypeId; return (s_LastTypeId); }

      DEVICE ();

      float* GetDepthBuffer (
         INT32 x,
         INT32 y,
         INT32 len,
         UINT16 FrameBuffer,
         bool UseVirtualWindow
         );

      const UINT8* GetImagePointerConst (
         INT32 x,
         INT32 y,
         INT32 len,
         UINT16 FrameBuffer,
         bool UseVirtualWindow
         ) { return (GetImagePointer(x,y,len,FrameBuffer,UseVirtualWindow)); }

      const UINT8* GetImagePointerConst (
         INT32 x,
         INT32 y,
         INT32 len,
         UINT16 FrameBuffer
         ) { return (GetImagePointer(x,y,len,FrameBuffer)); }

      UINT8* GetImagePointerNoRead (
         INT32 x,
         INT32 y,
         INT32 len,
         UINT16 FrameBuffer,
         bool UseVirtualWindow
         ) {
         if (UseVirtualWindow && m_bHasVirtualWindow) {
            x -= m_offset.x;
            y -= m_offset.y;
            }
         return (v_GetImagePointerNoRead(x,y,len,FrameBuffer));
         }

      UINT8* GetImagePointerNoRead (
         INT32 x,
         INT32 y,
         INT32 len,
         UINT16 FrameBuffer
         ) { return (v_GetImagePointerNoRead(x,y,len,FrameBuffer)); }

      const LPOINT2D& GetRealSize (
         ) const { return (m_RealSize); }

      const LPOINT2D& GetVirtualOffset () const
         { return (m_offset); }

      bool HasVirtualWindow () const
         { return (m_bHasVirtualWindow); }

      void SetDeviceColorSpace (
         COLORSPACE colorspace
         );

      ERRVALUE SetDeviceInfo (
         const DISPLAYINFO& dispinfo
         );

      void SetRealSize (
         int height,
         int width
         ) { m_RealSize.Set(width,height); }

      void SetTypeId (UINT32 TypeId)
         { m_TypeId = TypeId; }

      ERRVALUE WriteDepthBuffer (
         INT32 x,
         INT32 y,
         INT32 len,
         const float *zbuf,
         UINT16 FrameBuffer
         );

      ERRVALUE WriteImageBuffer (
         INT32 x,
         INT32 y,
         INT32 len,
         UINT8 *buf,
         UINT16 FrameBuffer
         ) { return (v_WriteImageBuffer(x,y,len,buf,FrameBuffer)); }

      virtual CAPABILITY v_GetCapabilities (
         ) const;

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      // Unimplemented.
      DEVICE (const DEVICE&);
      DEVICE& operator= (const DEVICE&);

      friend class CONTEXT;

      class ZBUFFER;

      static UINT32 s_LastTypeId;

      DISPLAYINFO m_devinfo;
      PROFILE m_DestProfile;
      PROFILE::INTENT m_ICMIntent;
      PROFILEPARMS_PRINTER m_ProofProfileParms;
      SIMPLE_ARRAY<ZBUFFER*> m_DepthBuffers;
      LPOINT2D m_offset;
      LPOINT2D m_RealSize;
      UINT32 m_TypeId;
      bool m_bHasVirtualWindow;

      static void MCB_ScreenProfileChanged (MICALLBACKLIST::ANYCALLBACKSTRUCT*, void*);
      #endif // GENERATING_DOXYGEN_OUTPUT

      virtual bool v_AvoidFillSpans () const;

      virtual ERRVALUE v_Clear (
         const COLOR& color
         );
      
      virtual MGD::CONTEXT* v_CreateContext ();

      virtual ERRVALUE v_FillSpan (
         MGD::CONTEXT *gc,
         INT32 x1,
         INT32 x2,
         INT32 y
         );

      virtual const COLOR_ARRAY* v_GetColorMap (
         ) const;

      virtual PIXEL v_GetColorPixel (
         const COLOR& color
         );

      virtual COLORSPACE v_GetColorSpace () const;

      virtual UINT8* v_GetImagePointer (
         INT32 x,
         INT32 y,
         INT32 len,
         UINT16 FrameBuffer
         );

      virtual UINT8* v_GetImagePointerNoRead (
         INT32 x,
         INT32 y,
         INT32 len,
         UINT16 FrameBuffer
         );

      virtual bool v_GetNeedFullImageLine () const;

      virtual UINT16 v_GetNumFrameBuffers () const;

      virtual void v_GetPixelColor (
         PIXEL pixel,
         COLOR& color
         ) const;

      virtual bool v_SupportsOpacityBlendMode (
         MGD::OPACITY_MODE
         ) const;

      virtual bool v_UseAntiAliasing () const;
            
      virtual ERRVALUE v_WriteImageBuffer (
         INT32 x,
         INT32 y,
         INT32 len,
         UINT8 *buf,
         UINT16 FrameBuffer
         );

   };

//=====================================================================================================================
class CONTEXT {
   public:
      // Note, default Constructor is protected

      class PRIVDATA {
         public:
            PRIVDATA() {}
            virtual ~PRIVDATA() {}
         };

      static int AllocPrivDataIndex ();

      static ERRVALUE TextGetFontName (
         int fonthandle,
         MISTRING& fontname
         );

      static ERRVALUE TextGetFontInfo (
         int fonthandle,
         MGD::FONT **font
         );

      static int TextOpenFont (
         const MIUNICODE *fontname
         );
   
      virtual ~CONTEXT();

      ERRVALUE AddExteriorToClip (
         const LRECT2D& rect
         );

      ERRVALUE AddToClip (
         const DRECT2D& rect
         );

      ERRVALUE AddToClip (
         const LRECT2D& rect
         );

      ERRVALUE AddToClip (
         const POLYLINE& polyline
         );

      ERRVALUE AddToClip (
         const REGION2D& region
         );

      bool Calculate3dDepthFunction (
         const DPOINT3D& p1,              
         const DPOINT3D& p2,
         const DPOINT3D& p3,
         const double viewPlaneDistance,  
         const bool isPerspective,        
         const MAT3X3& matrix             
         );

      void ClearClipMask ();

      void ClearICMSourceProfile (
         ) {
         m_SourceProfile.Free();
         SetupICMTransform();
         }

      ERRVALUE ComputeLabelExtents (
         REGION2D& extents,
         const MIUNICODE* text,
         const POLYLINE& BaseLine,
         const LABELSTYLE& Style,
         const POLYLINELIST& LeaderLines,
         bool bCheckClip = false,
         REGION2D* frame = 0
         );
         
      ERRVALUE ComputeLabelExtents (
         REGION2D& extents,
         const TEXTBLOCK& textblock,
         const LABELSTYLE& Style,
         const POLYLINELIST& LeaderLines,
         bool bCheckClip = false,
         REGION2D* frame = 0
         );
         
      ERRVALUE ComputeLabelFrame (
         REGION2D& frame,        
         const MIUNICODE* text,
         const POLYLINE& BaseLine,
         const LABELSTYLE& Style,
         const POLYLINELIST& LeaderLines
         );
         
      double ConvertScreenUnits (
         double value,                       
         int iunits,                         
         int ounits                          
         ) { return (::ConvertScreenUnits(value,m_dev->GetPixelSizeMM(),1.0,iunits,ounits)); }

      void Copy (
         const CONTEXT &rhs
         ) { v_Copy(rhs); }

      ERRVALUE CopyRect (
         const MGD::DEVICE *pDevSrc,
         const LRECT2D& RectSrc,
         const LPOINT2D& PtTgt,
         MGD::DEVICE_MEM8G *pDevAlpha = 0
         );

      ERRVALUE CopyRectSampled (
         const MGD::DEVICE *pDevSrc,
         const LRECT2D& srcrect, 
         const LRECT2D& destrect,
         MGD::DEVICE_MEM8G *pDevAlpha = 0
         );

      void DepthTestDisable (
         ) { SetDepthTest(MGD::DEPTHTEST_None); }

      void DepthTestEnable (
         ) { SetDepthTest(MGD::DEPTHTEST_CheckAndSet); }

      void DisableICM (
         ) { m_ICMTransform.Free(); }

      ERRVALUE DrawArc (
         INT32 xcenter,                      
         INT32 ycenter,                      
         INT32 xradius,                      
         INT32 yradius,                      
         double startangle,                  
         double sweepangle,                  
         double rotangle = 0,                   
         MGD::SHAPECLOSE closemode = SHAPECLOSE_None     
         ) { return (v_DrawArc(xcenter, ycenter, xradius, yradius, startangle, sweepangle, rotangle, closemode)); }

      ERRVALUE DrawArc (
         double xcenter,                        
         double ycenter,                        
         double xradius,                        
         double yradius,                        
         double startangle,                  
         double sweepangle,                  
         double rotangle = 0,                   
         MGD::SHAPECLOSE closemode = SHAPECLOSE_None     
         ) { return (v_DrawArc(xcenter, ycenter, xradius, yradius, startangle, sweepangle, rotangle, closemode)); }

      ERRVALUE DrawArrow (
         const DPOINT2D& EndPoint,     
         double angle,                 
         double length,                
         double sweep = 30.0 * DEGTORAD,  
         MGD::ARROWTYPE type = ARROWTYPE_FilledTriangle
         );

      ERRVALUE DrawCircle (
         INT32 xcenter,                      
         INT32 ycenter,                      
         INT32 radius                        
         ) { return (v_DrawCircle(xcenter, ycenter, radius)); }

      ERRVALUE DrawCircle (
         double xcenter,                        
         double ycenter,                        
         double radius                       
         ) { return (v_DrawCircle(xcenter, ycenter, radius)); }

      ERRVALUE DrawEllipse (
         INT32 xcenter,                      
         INT32 ycenter,                      
         INT32 xradius,                      
         INT32 yradius,                      
         double rotangle = 0                    
         ) { return (v_DrawEllipse(xcenter, ycenter, xradius, yradius, rotangle)); }

      ERRVALUE DrawEllipse (
         double xcenter,                        
         double ycenter,                        
         double xradius,                        
         double yradius,                        
         double rotangle = 0                    
         ) { return (v_DrawEllipse(xcenter, ycenter, xradius, yradius, rotangle)); }

      ERRVALUE DrawIcon (
         INT32 x, 
         INT32 y, 
         MICONSTRUCT* icon, 
         ICONFLAGS flags
         ) { return (v_DrawIcon(x, y, icon, flags)); }

      ERRVALUE DrawIcon (
         INT32 x,
         INT32 y,
         ICONID iconid,
         const COLOR& bgcolor,
         ICONFLAGS flags
         );

      ERRVALUE DrawLabel (
         const MIUNICODE* text,
         const POLYLINE& BaseLine,
         const LABELSTYLE& Style,
         const POLYLINELIST& LeaderLines
         );
         
      ERRVALUE DrawLabel (
         const TEXTBLOCK& textblock,
         const LABELSTYLE& Style,
         const POLYLINELIST& LeaderLines
         );
         
      ERRVALUE DrawLine (
         INT32 x1, 
         INT32 y1, 
         INT32 x2, 
         INT32 y2
         ) { return (v_DrawLine(x1, y1, x2, y2)); }

      ERRVALUE DrawLine3D (
         INT32 x1,                           
         INT32 y1,                           
         float z1,                           
         INT32 x2,                           
         INT32 y2,                           
         float z2                            
         ) { return (v_DrawLine3D(x1, y1, z1, x2, y2, z2)); }

      ERRVALUE DrawLines (
         const LPOINT2D* points,             
         INT32 numpoints,                    
         bool close = false                  
         );

      ERRVALUE DrawLines (
         const POLYLINE& line
         );

      ERRVALUE DrawLines (
         const SIMPLE_ARRAY<LPOINT2D>& points,              
         bool close = false                     
         ) { return (DrawLines(points, points.GetNumItems(), close)); }

      ERRVALUE DrawLinesDashed (
         const LPOINT2D* points,                
         INT32 numpoints,                       
         const SIMPLE_ARRAY<double>& DashArray, 
         double DashOffset = 0.0,               
         bool close = false                     
         ) { return (v_DrawLinesDashed(points, numpoints, DashArray, DashArray.GetNumItems(), DashOffset, close)); }
      
      ERRVALUE DrawLinesDashed (
         const SIMPLE_ARRAY<LPOINT2D>& points,  
         const SIMPLE_ARRAY<double>& DashArray, 
         double DashOffset = 0.0,               
         bool close = false                     
         ) { return (v_DrawLinesDashed(points, points.GetNumItems(), DashArray, DashArray.GetNumItems(), DashOffset, close)); }

      ERRVALUE DrawLinesDashed (
         const LPOINT2D* points,                
         INT32 numpoints,                       
         const double *DashArray,               
         INT32 DashCount,                       
         double DashOffset = 0.0,               
         bool close = false                     
         ) { return (v_DrawLinesDashed(points, numpoints, DashArray, DashCount, DashOffset, close)); }
      
      ERRVALUE DrawLinesDashed (
         const SIMPLE_ARRAY<LPOINT2D>& points,  
         const double *DashArray,               
         INT32 DashCount,                       
         double DashOffset = 0.0,               
         bool close = false                     
         ) { return (v_DrawLinesDashed(points, points.GetNumItems(), DashArray, DashCount, DashOffset, close)); }

      ERRVALUE DrawLinesDashed (
         const POLYLINE& line,                  
         const double *DashArray,               
         INT32 DashCount,                       
         double DashOffset = 0.0,               
         bool close = false                     
         );
      
      ERRVALUE DrawLineStyleSample (
         const RVC::STYLE& styleobj,   
         const LINESTYLE& style,       
         const LRECT2D& rect,          
         STYLESAMPLEFLAGS flags = STYLESAMPLE_Default
         );

      ERRVALUE DrawPixel (
         INT32 x, 
         INT32 y
         );

      ERRVALUE DrawPoint (
         INT32 x, 
         INT32 y
         ) { return (v_DrawPoint(x, y)); }

      ERRVALUE DrawPoint (
         const DPOINT2D& pt
         ) { return (v_DrawPoint(pt)); }  

      ERRVALUE DrawPoints (
         const LPOINT2D* points, 
         INT32 NumPoints
         ) { return (v_DrawPoints(points, NumPoints)); }

      ERRVALUE DrawPoints (
         const SIMPLE_ARRAY<LPOINT2D>& points               
         ) { return (DrawPoints(points, points.GetNumItems())); }

      ERRVALUE DrawPointStyleSample (
         const RVC::STYLE& styleobj,   
         const POINTSTYLE& style,      
         const LRECT2D& rect,          
         STYLESAMPLEFLAGS flags = STYLESAMPLE_Default
         );

      ERRVALUE DrawPolyStyleSample (
         const RVC::STYLE& styleobj,   
         const POLYSTYLE& style,       
         const LRECT2D& rect,          
         STYLESAMPLEFLAGS flags = STYLESAMPLE_Default
         );

      ERRVALUE DrawRectangle (
         INT32 x1,                     
         INT32 y1,                     
         INT32 x2,                     
         INT32 y2                      
         ) { return (v_DrawRectangle(x1, y1, x2, y2)); }

      ERRVALUE DrawRectangle (
         const LRECT2D& rect
         ) { return (v_DrawRectangle(rect)); }
      
      ERRVALUE DrawRectangle (
         const DRECT2D& rect
         ) { return (v_DrawRectangle(rect)); }
      
      ERRVALUE DrawRegion (
         const REGION2D& polygons
         );

      ERRVALUE DrawRoundedRectangle (
         const LRECT2D& rect,
         INT32 radius = -1
         );

      ERRVALUE DrawSegments (
         const LSEGMENT2D* segments, 
         INT32 NumSegments
         ) { return (v_DrawSegments(segments, NumSegments)); }

      ERRVALUE DrawSegments (
         const SIMPLE_ARRAY<LSEGMENT2D>& segments     
         ) { return (v_DrawSegments(segments, segments.GetNumItems())); }

      void DrawSimpleArrowHead (
         INT32 xbase,                  
         INT32 ybase,                  
         INT32 size,                   
         MGD::DIRECTION direction
         );

      void DrawSimpleFrame (
         const LRECT2D& rect,             
         const COLOR& ColorTopLeft,
         const COLOR& ColorBottomRight
         );

      ERRVALUE DrawSubRegion (
         const SUBREGION2D& polygons
         );

      ERRVALUE EraseRectangle (
         const LRECT2D& rectangle,           
         const COLOR& color                  
         ) { return (v_EraseRectangle(rectangle,color)); }

      ERRVALUE FillArc (
         INT32 xcenter,                      
         INT32 ycenter,                      
         INT32 xradius,                      
         INT32 yradius,                      
         double startangle,                  
         double sweepangle,                  
         double rotangle = 0,                   
         MGD::SHAPECLOSE closemode = SHAPECLOSE_Direct
         ) { return (v_FillArc(xcenter, ycenter, xradius, yradius, startangle, sweepangle, rotangle, closemode)); }

      ERRVALUE FillArc (
         double xcenter,                        
         double ycenter,                        
         double xradius,                        
         double yradius,                        
         double startangle,                  
         double sweepangle,                  
         double rotangle = 0,                   
         MGD::SHAPECLOSE closemode = SHAPECLOSE_Direct
         ) { return (v_FillArc(xcenter, ycenter, xradius, yradius, startangle, sweepangle, rotangle, closemode)); }

      ERRVALUE FillCircle (
         INT32 xcenter,                      
         INT32 ycenter,                      
         INT32 radius                        
         ) { return (v_FillCircle(xcenter, ycenter, radius)); }

      ERRVALUE FillCircle (
         double xcenter,                        
         double ycenter,                        
         double radius                       
         ) { return (v_FillCircle(xcenter, ycenter, radius)); }
      
      ERRVALUE FillEllipse (
         INT32 xcenter,                      
         INT32 ycenter,                      
         INT32 xradius,                      
         INT32 yradius,                      
         double rotangle = 0                    
         ) { return (v_FillEllipse(xcenter, ycenter, xradius, yradius, rotangle)); }

      ERRVALUE FillEllipse (
         double xcenter,                        
         double ycenter,                        
         double xradius,                        
         double yradius,                        
         double rotangle = 0                    
         ) { return (v_FillEllipse(xcenter, ycenter, xradius, yradius, rotangle)); }
      
      ERRVALUE FillPolygon (
         const LPOINT2D* points, 
         INT32 NumPoints, 
         MGD::POLYSHAPE shape = POLYSHAPE_Complex, 
         bool DrawOutline = false
         ) { return (v_FillPolygon(points, NumPoints, shape, DrawOutline)); }

      ERRVALUE FillPolygons (
         const LPOLYGON* polygons, 
         INT32 NumPolys, 
         bool DrawOutline = false
         ) { return (v_FillPolygons(polygons, NumPolys, DrawOutline)); }
         
      ERRVALUE FillRectangle (
         INT32 x1,      
         INT32 y1,      
         INT32 x2,      
         INT32 y2       
         ) { return (v_FillRectangle(x1, y1, x2, y2)); }

      ERRVALUE FillRectangle (
         const LRECT2D& rect
         ) { return (v_FillRectangle(rect)); }

      ERRVALUE FillRectangle (
         const DRECT2D& rect
         ) { return (v_FillRectangle(rect)); }

      ERRVALUE FillRegion (
         const REGION2D& polygons,
         bool DrawOutline = false
         ) { return (v_FillRegion(polygons, DrawOutline)); }

      ERRVALUE FillRoundedRectangle (
         const LRECT2D& rect,
         INT32 radius,
         bool bDrawBorder = false
         );

      ERRVALUE FillSpan (
         INT32 x1,
         INT32 x2,
         INT32 y
         );

      ERRVALUE FillSubRegion (
         const SUBREGION2D& polygons,
         bool DrawOutline = false
         ) { return (v_FillSubRegion(polygons, DrawOutline)); }

      void Get3dDepthFunction (
         float &xcoeff,                      
         float &ycoeff,                      
         float &zconst,                      
         bool &isPespective
         ) const {
         xcoeff = m_dfx;
         ycoeff = m_dfy;
         zconst = m_dfz;
         isPespective = m_IsPerspective;
         }
         
      bool GetAntialiasing () const;

      void GetClipRegion (
         REGION2D& region
         ) const;

      const LRECT2D& GetClipRectangle (
         ) const { return (m_ClipRect); }

      PIXEL GetColor (
         ) const { return (m_DrawColorPixel); }

      bool GetColorLock (
         ) const { return (m_bColorLocked); }

      PIXEL GetColorPixel (
         const COLOR& color
         ) const;

      PIXEL GetColorPixelNoICM (
         const COLOR& color
         ) const;

      float GetDepth3D (
         INT32 x, 
         INT32 y
         ) { return (m_dev->GetDepth(x,y,m_FrameBuffer)); }

      MGD::DEPTHTEST GetDepthTest () const
         { return (m_DepthTest); }

      MGD::DEVICE& GetDevice (
         ) const { return (*m_dev); }
      
      DEPRECATED_MSG("Use GetDevice instead") MGD::DEVICE* GetDisplay (
         ) const { return (m_dev); }

      const DISPLAYINFO& GetDisplayInfo (
         ) const { return (m_dev->GetDeviceInfo()); }

      FONT* GetFont (
         ) const { return (m_font); }

      UINT16 GetFrameBuffer () const
         { return (m_FrameBuffer); }

      ERRVALUE GetGlyphOutline (
         MIUNICODE uc,
         REGION2D& region,
         bool bUseGlyphIndex = false
         );

      void GetPixelColor (
         PIXEL pixel,
         COLOR& color
         ) const;

      void GetPixelColorNoICM (
         PIXEL pixel,
         COLOR& color
         ) const;

      bool GetLine4Connected () const
         { return m_bLine4Connected; }

      MGD::LINECAP GetLineCap () const
         { return m_LineCap; }
      
      MGD::LINEJOIN GetLineJoin () const
         { return m_LineJoin; }

      bool GetLineScaledToMap () const
         { return (m_bLineScaledToMap); }

      double GetLineWidth () const
         { return (m_LineWidth); }

   #ifndef NO_DEPRECATED
      DEPRECATED double GetMapScale () const
         { return (GetOutputScale()); }
   #endif

      OPACITY_MODE GetOpacityBlendMode (
         ) const { return m_OpacityBlendMode; }

#ifndef GENERATING_DOXYGEN_OUTPUT
      OTPRIV* GetOpenTypePriv (
         );
#endif

      double GetOutputScale () const
         { return (this == 0) ? 1.0 : m_MapScale; }
      
      MGD::PIXELFUNC GetPixelFunction (
         ) const { return m_PixelFunc; }

      double GetPixelSizeMM () const
         { return (m_dev->GetPixelSizeMM()); }

      PIXEL GetPlaneMask () const
         { return m_PlaneMask; }

      bool GetPlaneMaskLock () const
         { return m_bPlaneMaskLocked; }

      bool GetPointScaledToMap (
         ) const {
         return (m_bPointScaledToMap);
         }

      PRIVDATA* GetPrivData (
         int indx
         ) const;
         
      const POLYSTYLE& GetStyleFill (
         ) const { return (m_FillStyle); }

      const LINESTYLE& GetStyleLine (
         ) const { return (m_LineStyle); }

      const POINTSTYLE& GetStylePoint (
         ) const { return (m_PointStyle); }

      MGD::TEXTSETTINGS& GetTextSettings ()
         { return m_Text; }

      const MGD::TEXTSETTINGS& GetTextSettings () const
         { return m_Text; }

      const TEXTSTYLE& GetTextStyle () const
         { return (m_Text); }

      bool GetThinLineWidthHint () const
         { return (m_bThinLineWidthHint); }

      int GetTransparency () const
         { return (m_Transparency); }

      bool GetTransparencyLock (
         ) const { return (m_bTransparencyLocked); }
      
      bool GetUsePatternPoint (
         ) const { return (m_bUsePatternPoint); }

      bool GetUsePatternLine (
         ) const { return (m_bUsePatternLine); }

      bool GetUsePatternFill () const
         { return (m_bUsePatternFill); }

      bool HasComplexClip (
         ) const {
         return (m_ClipRegion != 0);
         }

      bool HasUsedTransparency (
         ) const {
         return (m_bHasUsedTransparency);
         }

      ERRVALUE HatchPolygonStyle (
         const LPOINT2D *point,
         INT32 numpts
         );

      ERRVALUE ImageBegin (
         INT32 x,                            
         INT32 y,                            
         INT32 width,                        
         INT32 height,                       
         COLORSPACE colorspace,              
         const COLOR_ARRAY* colormap = 0,       
         UINT32 flags = 0
         );

      ERRVALUE ImageBegin (
         const LRECT2D& rect,
         COLORSPACE colorspace,
         const COLOR_ARRAY* colormap = 0,
         UINT32 flags = 0
         ) {
         return (ImageBegin(rect.xinit, rect.yinit, rect.GetWidth(), rect.GetHeight(), colorspace, colormap, flags));
         }

      ERRVALUE ImageEnd (
         UINT32 flags = 0
         );

      ERRVALUE InterfaceTextDrawString (
         INT32 x, 
         INT32 y, 
         const MIUNICODE* string, 
         TEXTBASEORIGIN baseorigin = TEXTBASEORIGIN_FirstLine, 
         bool bVisualOrder = false,
         INTERFACETEXTSTYLE style = INTERFACETEXTSTYLE_Normal
         ) {
         return (v_InterfaceTextDrawString(x, y, string, baseorigin, bVisualOrder, style));
         }

      ERRVALUE InterfaceTextGetExtents (
         const MIUNICODE* string,               
         int *width,                         
         int *height = 0,                    
         int *ascent = 0,                    
         INTERFACETEXTSTYLE style = INTERFACETEXTSTYLE_Normal
         ) {
         return (v_InterfaceTextGetExtents(string, width, height, ascent, style));
         }

      ERRVALUE InterfaceTextGetMetrics (
         const MIUNICODE* string,               
         TEXTMETRICS& metrics,
         INTERFACETEXTSTYLE style = INTERFACETEXTSTYLE_Normal
         ) {
         return (v_InterfaceTextGetMetrics(string, metrics, style));
         }

      int InterfaceTextGetWidth (
         const MIUNICODE* string,               
         INTERFACETEXTSTYLE style = INTERFACETEXTSTYLE_Normal,
         bool bInkMetrics = true
         ) {
         return (v_InterfaceTextGetWidth(string, style, bInkMetrics));
         }

   #ifndef NO_DEPRECATED
      DEPRECATED int InterfaceTextGetWidth (
         const MIUNICODE* string,               
         bool bInkMetrics
         ) {
         return (v_InterfaceTextGetWidth(string, INTERFACETEXTSTYLE_Normal, bInkMetrics));
         }
   #endif

      ERRVALUE IntersectClip (
         const DRECT2D& rect
         );

      ERRVALUE IntersectClip (
         const LRECT2D& rect
         );

      ERRVALUE IntersectClip (
         const POLYLINE& polyline
         );

      ERRVALUE IntersectClip (
         const REGION2D& region
         );

      bool Is3dEnabled (
         ) const {
         return (GetDevice().HasCapability(CAPABILITY_3D));
         }

      void MultiPassBegin ();

      bool MultiPassIsDone () const;

      void MultiPassNext ();

      void MultiPassReset ();

      int MultiPassGetCurrentPass () const;

      int MultiPassGetNumPasses () const;

   #ifndef NO_DEPRECATED
      DEPRECATED bool MultiPassTestStyle (
         const LINESTYLE& style,
         const void* pattern,
         int patternbytes
         ) const;
   #endif

      bool MultiPassTestStyle (
         const LINESTYLE& style,
         const RVC::STYLEPATTERN_BASE *pPattern = 0   
         ) const;

      bool MultiPassTestStyle (
         const POLYSTYLE& style,
         const void* pattern = 0,
         int patternbytes = 0
         ) const;

      ERRVALUE PutImageSpan (
         INT32 x, 
         INT32 y, 
         INT32 len, 
         const void* data, 
         const UINT8 *mask = 0 
         );

      ERRVALUE PutPixel (
         INT32 x, 
         INT32 y, 
         PIXEL pixel
         );

      ERRVALUE PutPixel3D (
         INT32 x, 
         INT32 y, 
         float z, 
         PIXEL pixel
         );

      void Reset ()
         { v_Reset(); }

      void ResetUsedTransparency (
         ) { m_bHasUsedTransparency = false; }

      ERRVALUE Set3dDepthFunction (
         float xcoeff,                       
         float ycoeff,                       
         float zconst,                       
         bool isPespective
         );

      void SetAntialiasing (
         bool enable = true
         ) { m_bAntialiasingEnabled = enable; }

      void SetBitmapOrigin (
         INT32 xorigin,                      
         INT32 yorigin                       
         ) { v_SetBitmapOrigin(xorigin, yorigin); }

      void SetClipForPut (
         bool DoClipForPut = true            
         ) { m_bDoClipForPut = DoClipForPut; }

      void SetClipNone ();

      void SetClipRectangle (
         const LRECT2D & rect
         );
      
      void SetClipRectangle (
         int xinit,
         int yinit,
         int xlast,
         int ylast
         ) {
         SetClipRectangle(LRECT2D(xinit, yinit, xlast, ylast));
         }

      void SetClipRegion (
         const REGION2D& region
         );
      
      void SetColor (
         PIXEL pixel
         );

      void SetColor (
         const COLOR& color
         );

      void SetColor (
         COLOR::NAME color
         ) { SetColor(COLOR(color)); }

      void SetColorIsPatternVariable (
         bool value
         ) { v_SetColorIsPatternVariable(value); }

      void SetColorLock (
         bool ColorLocked                 
         ) { m_bColorLocked = ColorLocked; }

      DEPRECATED_MSG("Use SetColor() instead") void SetColorPixel (
         PIXEL pixel
         ) { SetColor(pixel); }

      void SetDepth3D (
         INT32 x, 
         INT32 y,
         float z
         ) { m_dev->SetDepth(x,y,z,m_FrameBuffer); }

      void SetDepthTest (
         MGD::DEPTHTEST testmode
         );
      
      void SetFont (
         MGD::FONT* font
         );

      void SetFrameBuffer (
         UINT16 FrameBuffer               
         );

      void SetICMSourceProfile (
         const PROFILE& profile
         );

      void SetLine4Connected (
         bool state = true
         ) { m_bLine4Connected = state; }

      void SetLineAttributes (
         MGD::LINECAP capstyle,
         MGD::LINEJOIN joinstyle
         );

      void SetLineScaledToMap (
         bool LineScaledToMap             
         ) { m_bLineScaledToMap = LineScaledToMap; }

      void SetLineWidth (
         double width
         );

      void SetLineWidthMM (
         double width
         ) { SetLineWidth(width / m_dev->GetPixelSizeMM()); }

      void SetNoFillRightPolyPixels (
         bool NoFillRightPolyPixels
         ) { m_bNoFillRightPolyPixels = NoFillRightPolyPixels; }
      
      void SetNoMultiPointSpan (
         bool state
         ) { m_bNoMultiPointSpan = state; }

      void SetOpacityBlendMode (
         OPACITY_MODE OpacityBlendMode
         ) { m_OpacityBlendMode = OpacityBlendMode; }

      void SetOutputScale (
         double mapscale      
         );

      void SetPixelFunction (
         MGD::PIXELFUNC func
         );

      void SetPlaneMask (
         UINT32 mask
         );

      void SetPlaneMask (
         UINT8 redmask,
         UINT8 greenmask,
         UINT8 bluemask
         ); 

      void SetPlaneMaskRGB (
         UINT8 redmask,
         UINT8 greenmask,
         UINT8 bluemask
         ) { SetPlaneMask(redmask, greenmask, bluemask); }

      void SetPlaneMaskLock (
         bool PlaneMaskLocked             
         ) { m_bPlaneMaskLocked = PlaneMaskLocked; }

      void SetPointScaledToMap (
         bool PointScaledToMap               
         ) { m_bPointScaledToMap = PointScaledToMap; }

      void SetPrivData (
         int indx,
         PRIVDATA* data
         );

   #ifndef DEPRECATE_ALL
      DEPRECATED_MSG("Use the version that takes RVC::STYLEPATTERN_BITMAP or RVC::STYLEPATTERN_HATCH") 
      ERRVALUE SetStyleFill (
         const POLYSTYLE* style,    
         const void* pattern,    
         INT32 patternbytes      
         );
   #endif

      ERRVALUE SetStyleFill (
         const POLYSTYLE* style,    
         const RVC::STYLEPATTERN_BASE* Pattern = 0    
         );

      ERRVALUE SetStyleFill (
         MGD::BUILTINFILLSTYLE style,
         const COLOR& color
         );

      ERRVALUE SetStyleLine (
         const LINESTYLE* style,    
         const RVC::STYLEPATTERN_BASE* Pattern = 0    
         );

   #ifndef DEPRECATE_ALL
      DEPRECATED_MSG("Use the version that takes RVC::STYLEPATTERN_LINE or RVC::STYLEPATTERN_BITMAP") 
      ERRVALUE SetStyleLine (
         const LINESTYLE* style,    
         const void* pattern,    
         INT32 patternbytes      
         );
   #endif

      ERRVALUE SetStylePoint (
         const POINTSTYLE* style,      
         const RVC::STYLEPATTERN_BASE* Symbol = 0  
         );

   #ifndef DEPRECATE_ALL
      DEPRECATED_MSG("Use the version that takes RVC::STYLEPATTERN_SYMBOL") 
      ERRVALUE SetStylePoint (
         const POINTSTYLE* style,   
         const void* pattern,    
         INT32 patternbytes      
         );
   #endif

      // If you're looking for SetStyleText() it's named TextSetStyle() so that it sorts with
      // all the text methods.

      void SetTextSettings (
         const MGD::TEXTSETTINGS& settings
         ) { m_Text = settings; }

      void SetTextStyle (
         const TEXTSTYLE& style                    
         ) { TextSetStyle(style); }

      void SetThinLineWidthHint (
         bool enable = true
         ) { m_bThinLineWidthHint = enable; }

      void SetTransparency (
         UINT8 transparency                  
         );

      void SetTransparencyLock (
         bool TransparencyLocked          
         ) { m_bTransparencyLocked = TransparencyLocked; }

      void SetTranspForPutImage (
         bool DoTranspForPutImage            
         ) { m_bDoTranspPutImage = DoTranspForPutImage; }

      void SetUsePatternFill (
         bool state = true
         ) { m_bUsePatternFill = state; }

      void SetUsePatternLine (
         bool state = true
         ) { m_bUsePatternLine = state; }

      void SetUsePatternPoint (
         bool state = true
         ) { m_bUsePatternPoint = state; }

      const STIPPLEMASK& StippleGetMask () const
         { return (m_StippleMask); }

      bool StippleIsUsed () const
         { return (m_StippleIsUsed); }

      void StippleSetMask (
         const STIPPLEMASK& StippleMask   
         );

      void StippleSetUsed (
         bool used               
         );

      ERRVALUE TextAddToClip (
         const MIUNICODE *string,               
         const POLYLINE& Baseline,           
         MGD::BASELINE baseflags,
         MGD::FONT::MODE mode = MGD::FONT::MODE_MIUNICODE
         );

      ERRVALUE TextBlockComputeExtents (
         MGD::TEXTBLOCK& block,
         DRECT2D& extents           
         );

      ERRVALUE TextBlockDraw (
         MGD::TEXTBLOCK& block   
         );

      ERRVALUE TextBlockGetFirstString (
         MGD::TEXTBLOCK& block,
         MISTRING& string           
         );

      ERRVALUE TextDrawGlyph (
         double x,                           
         double y,                           
         double baseangle,                   
         MIUNICODE character,                
         MGD::FONT::MODE mode = MGD::FONT::MODE_MIUNICODE
         );

      ERRVALUE TextDrawString (
         const DPOINT2D *basepoints,               
         int numbasepoints,                  
         MGD::BASELINE baseflags,                     
         const MIUNICODE *string,               
         MGD::FONT::MODE mode = MGD::FONT::MODE_MIUNICODE
         );

      ERRVALUE TextDrawStringPart (
         const DPOINT2D *basepoints,               
         int numbasepoints,                  
         MGD::BASELINE baseflags,                     
         const MIUNICODE *string,               
         int startindex = 0,                 
         int endindex = 0,                   
         MGD::FONT::MODE mode = MGD::FONT::MODE_MIUNICODE
         );

      ERRVALUE TextDrawStringSimple (
         double x,                           
         double y,                           
         double baseangle,                   
         const MIUNICODE *string,               
         MGD::FONT::MODE mode = MGD::FONT::MODE_MIUNICODE
         );

      ERRVALUE TextGetFontMetrics (
         MGD::FONTINFO& fontinfo             
         );

      ERRVALUE TextGetGlyphExtents (
         const double& x,                    
         const double& y,                    
         const double& baseangle,            
         MIUNICODE ch,                          
         DRECT2D& rect,                      
         MGD::FONT::MODE mode = MGD::FONT::MODE_MIUNICODE
         ) {
         return (GetFont()->GetGlyphExtents(this, x, y, baseangle, ch, rect, mode));
         }

      ERRVALUE TextGetGlyphMetrics (
         MIUNICODE ch,                          
         MGD::GLYPHINFO& glyphinfo,          
         MGD::FONT::MODE mode = MGD::FONT::MODE_MIUNICODE
         ) {
         return (GetFont()->GetGlyphMetrics(this, ch, glyphinfo, mode));
         }

      ERRVALUE TextGetStringExtents (
         const DPOINT2D *basepoints,               
         int numbasepoints,                  
         MGD::BASELINE baseflags,                     
         const MIUNICODE *string,               
         DRECT2D& extents,                   
         MGD::FONT::MODE mode = MGD::FONT::MODE_MIUNICODE
         );

      ERRVALUE TextGetStringExtentsJustified (
         const DPOINT2D *basepoints,               
         int numbasepoints,                  
         MGD::BASELINE baseflags,                     
         const MIUNICODE *string,               
         DRECT2D& extents,                   
         MGD::FONT::MODE mode = MGD::FONT::MODE_MIUNICODE
         );

      ERRVALUE TextGetStringExtentsSimple (
         double x,                           
         double y,                           
         double baseangle,                   
         const MIUNICODE *string,               
         DRECT2D& extents,                   
         MGD::FONT::MODE mode = MGD::FONT::MODE_MIUNICODE
         );

      ERRVALUE TextGetStringExtentsSimpleJustified (
         double x,                           
         double y,                           
         double baseangle,                   
         const MIUNICODE *string,               
         DRECT2D& extents,                   
         MGD::FONT::MODE mode = MGD::FONT::MODE_MIUNICODE
         );

      ERRVALUE TextGetStringMetrics (
         const MIUNICODE *string,               
         MGD::GLYPHINFO& glyphinfo,          
         MGD::FONT::MODE mode = MGD::FONT::MODE_MIUNICODE
         );

      ERRVALUE TextGetStringWidth (
         const MIUNICODE *string,               
         double& width,                      
         MGD::FONT::MODE mode = MGD::FONT::MODE_MIUNICODE
         );

      void TextSetClipWidth (
         double percent          
         );
         
      void TextSetColors (
         PIXEL fgpixel,                   
         PIXEL bgpixel,                   
         PIXEL ulpixel                    
         );

      void TextSetColors (
         const COLOR& fgcolor,         
         const COLOR& bgcolor,         
         const COLOR *ulcolor = 0      
         ); 

      void TextSetEnhanceWidth (
         double width,                 
         bool ValueInPixels = true
         );

      ERRVALUE TextSetFont (
         int fonthandle                      
         );

      ERRVALUE TextSetFontByName (
         const MIUNICODE *fontname,                   
         UINT32 FontFlagsRequested = 0,
         UINT32* pFontFlagsFound = 0
         );

      void TextSetHeight (
         double height,                      
         SCREENUNIT units = SCREENUNIT_Pixels
         );

      void TextSetOpenTypeFeatures (
         const MISTRING& features
         );

      void TextSetShadowValues (
         double offset,                      
         double angle,                       
         bool relative                       
         );

      void TextSetStrokeWidth (
         double width,                       
         bool ValueInPixels = true
         );

      void TextSetStyle (
         const TEXTSTYLE& style                    
         );

      void TextSetUnderlineValues (
         double offset,                      
         double thickness                    
         );

      int TTFComputeGlyphExtentsByIndex (
         UINT16 GlyphIndex,
         MGD::GLYPHINFO& glyphinfo           
         );

      int TTFDrawGlyphByIndex (
         double x,
         double y,
         double baseangle,
         UINT16 idx
         );

      int TTFGlyphToChar (
         UINT16 GlyphIndex,
         MIUNICODE& Char
         );

   protected:
      MGD::DEVICE* m_dev;
      bool m_bUsePatternPoint;      
      bool m_bUsePatternLine;       
      bool m_bUsePatternFill;       
      bool m_bLine4Connected;       
      bool m_bColorLocked;          
      bool m_bPatternFromString;    
      bool m_bTransparencyLocked;   
      bool m_bHasUsedTransparency;  
      bool m_bPlaneMaskLocked;      
      bool m_bDoClipForPut;         
      bool m_bDoTranspPutImage;     
      bool m_bDepthVariable;        
      bool m_bPointScaledToMap;     
      bool m_bLineScaledToMap;      
      bool m_bNoMultiPointSpan;
      bool m_bNoFillRightPolyPixels;

      PIXEL m_DrawColorPixel;
      PIXEL m_PlaneMask;
      double   m_LineWidth;               

      POINTSTYLE  m_PointStyle;
      LINESTYLE   m_LineStyle;
      POLYSTYLE   m_FillStyle;
      double      m_MapScale;          

      MGD::FONT   *m_font;                
      MGD::TEXTSETTINGS m_Text;

      //SIMPLE_ARRAY<UINT8> m_pattbuf;
      RVC::STYLEPATTERN_BASE* m_pFillPattern;
      RVC::STYLEPATTERN_LINE* m_pLinePattern;
      RVC::STYLEPATTERN_SYMBOL* m_pPointSymbol;
      RVC::STYLEPATTERN_BITMAP* m_pPointBitmap;

      INT32    m_bitmapxorigin;           
      INT32    m_bitmapyorigin;           
      UINT8    m_Transparency;            
      float    m_dfx, m_dfy, m_dfz;       
      INT32 m_xsize, m_ysize;             
      INT32 m_xsize2, m_ysize2;           

      DEVICE_MEM1_SPARSE *m_pClipDevice;           
      CONTEXT *m_pClipContext;
      REGION2D *m_ClipRegion;
      bool m_bNeedToUpdateClipMask;       
      
      MGD::LINECAP m_LineCap;
      MGD::LINEJOIN m_LineJoin;
      MGD::DEPTHTEST m_DepthTest;
      MGD::PIXELFUNC m_PixelFunc;

      COLOR_ARRAY m_PutImageColorMap;
      COLORSPACE m_PutImageColorSpace;
      int m_PutImageBytesPerPixel;

      LRECT2D m_ClipRect;
      COLORCOMPSTRUCT *m_ColorComp;
      SIMPLE_ARRAY<UINT8> m_ColorConvBuf;
      SIMPLE_ARRAY<UINT8> m_ICMConvBuf;

      bool m_IsPerspective;               
      SIMPLE_ARRAY<LPOINT2D> m_WorkPoints;
      PROFILE m_SourceProfile;
      TRANSFORM m_ImageICMTransform;
      TRANSFORM m_ICMTransform;
      mutable TRANSFORM m_ICMTransformInv;   

      struct EDGELIST;
      SIMPLE_ARRAY<EDGELIST> m_EdgeList;
      SIMPLE_ARRAY<INT32> m_etptr;
      SIMPLE_ARRAY<INT32> m_lptr;
      SIMPLE_ARRAY<LPOLYGON> m_PolygonArray;
      SIMPLE_ARRAY<LPOINT2D> m_PointArray;
      bool m_bAntialiasingEnabled;
      bool m_bThinLineWidthHint;

      CONTEXT (
         MGD::DEVICE* disp
         );

      ERRVALUE ClipRegionUpdateMask ();

      ERRVALUE CopyRectSampledLow (
         const MGD::DEVICE *pDevSrc,
         const LRECT2D& srcrect, 
         const LRECT2D& destrect,
         MGD::DEVICE_MEM8G *pDevAlpha = 0
         );

      float DepthCalc (
         float z
         ) const { return (m_IsPerspective ? (1.0F / z) : z); }

      bool DepthTest (
         float z,
         float bufz
         ) const { return (DepthCalc(z) >= bufz); }

      ERRVALUE _DrawGlyph (
         MGD::FONT* font,
         double x,
         double y, 
         double baseangle,
         const MGD::STRINGDATA& gidstr,
         int num
         ) {
         return (v_DrawGlyph(font, x, y, baseangle, gidstr, num));
         }

      ERRVALUE DrawLinesLow (
         const LPOINT2D* points,
         INT32 numpts
         ) {
         return (v_DrawLinesLow(points, numpts));
         }

      ERRVALUE DrawLinesLow (
         const POLYLINE& line
         ) { return (v_DrawLinesLow(line)); }

      ERRVALUE DrawStringStraight (
         const DPOINT2D& pt,  
         double baseangle,
         const MGD::STRINGDATA& gidstr,
         int sindex,    
         int eindex,    
         double SpaceExtra,
         double GlyphExtra
         ) {
         return (v_DrawStringStraight(pt, baseangle, gidstr, sindex, eindex, SpaceExtra, GlyphExtra));
         }

      COLORSPACE GetImageColorSpace (
         ) const {
         return (m_PutImageColorSpace);
         }

      int GetStringExtents (
         const DPOINT2D* baseline,
         int numpts,
         double baseangle,
         MGD::BASELINE baseflags,
         const MIUNICODE* string,
         DRECT2D& extents,
         MGD::FONT::MODE mode,
         bool TakeJustificationIntoAccount
         );
         
      int GetStringExtents (
         const DPOINT2D* baseline,
         int numpts,
         double baseangle,
         MGD::BASELINE baseflags,
         const MGD::STRINGDATA& bidstr,
         int startindex,
         int endindex,
         DRECT2D& extents,
         bool TakeJustificationIntoAccount
         );
         
      int GetStringExtentsAlongCurve (
         const DPOINT2D* baseline,
         int numpts,
         const MGD::STRINGDATA& bidstr,
         int startindex,
         int endindex,
         UINT32 baseflags,
         DRECT2D& extents
         );
      
      ERRVALUE ImageSetColorSpace (
         COLORSPACE colorspace,
         const COLOR_ARRAY* colmap = 0       
         );

      double _NextGlyphPosition (
         MGD::FONT *font,
         double *x,
         double *y,
         double baseangle,
         const MGD::STRINGDATA& gidstr,
         int num,
         double SpaceExtra = 0.0,
         double GlyphExtra = 0.0
         ) { return (font->NextPosition(this, x, y, baseangle, gidstr, num, SpaceExtra, GlyphExtra)); }

      ERRVALUE PutImageSpanDirect (
         INT32 x, 
         INT32 y, 
         INT32 len, 
         const void* data, 
         const UINT8 *mask = 0
         );

      bool StippleTest (
         INT32 x,
         INT32 y
         ) const { return (!m_StippleIsUsed || m_StippleMask.TestPoint(x,y)); }

      virtual void v_Copy (
         const CONTEXT &rhs
         );

      virtual ERRVALUE v_CopyRect (
         const MGD::DEVICE *pDevSrc,
         const LRECT2D& RectSrc,
         const LPOINT2D& PtTgt,
         MGD::DEVICE_MEM8G *pDevAlpha = 0
         );

      virtual ERRVALUE v_DrawArc (
         INT32 xcenter,                      
         INT32 ycenter,                      
         INT32 xradius,                      
         INT32 yradius,                      
         double startangle,                  
         double sweepangle,                  
         double rotangle = 0,                   
         MGD::SHAPECLOSE closemode = SHAPECLOSE_None     
         ); 

      virtual ERRVALUE v_DrawArc (
         double xcenter,                        
         double ycenter,                        
         double xradius,                        
         double yradius,                        
         double startangle,                  
         double sweepangle,                  
         double rotangle = 0,                   
         MGD::SHAPECLOSE closemode = SHAPECLOSE_None     
         ); 
      
      virtual ERRVALUE v_DrawCircle (
         INT32 xcenter,                      
         INT32 ycenter,                      
         INT32 radius                        
         );

      virtual ERRVALUE v_DrawCircle (
         double xcenter,                        
         double ycenter,                        
         double radius                       
         );

      virtual ERRVALUE v_DrawEllipse (
         INT32 xcenter,                      
         INT32 ycenter,                      
         INT32 xradius,                      
         INT32 yradius,                      
         double rotangle = 0                    
         );

      virtual ERRVALUE v_DrawEllipse (
         double xcenter,                        
         double ycenter,                        
         double xradius,                        
         double yradius,                        
         double rotangle                     
         );

      virtual ERRVALUE v_DrawGlyph (
         MGD::FONT* font,
         double x,
         double y, 
         double baseangle,
         const MGD::STRINGDATA& gidstr,
         int num
         );

      virtual ERRVALUE v_DrawLine (
         INT32 x1, 
         INT32 y1, 
         INT32 x2, 
         INT32 y2
         );

      virtual ERRVALUE v_DrawLine3D (
         INT32 x1,                           
         INT32 y1,                           
         float z1,                           
         INT32 x2,                           
         INT32 y2,                           
         float z2                            
         );
      
      virtual ERRVALUE v_DrawLinesDashed (
         const LPOINT2D *points,             
         INT32 numpoints,                    
         const double *DashArray,            
         INT32 DashCount,                    
         double DashOffset = 0.0,            
         bool close = false                  
         );

      virtual ERRVALUE v_DrawLinesLow (
         const LPOINT2D* points,
         INT32 numpts
         );

      virtual ERRVALUE v_DrawLinesLow (
         const POLYLINE& line
         );

      virtual ERRVALUE v_DrawPixel (
         INT32 x, 
         INT32 y
         ); 

      virtual ERRVALUE v_DrawPoint (
         INT32 x, 
         INT32 y
         );

      virtual ERRVALUE v_DrawPoint (
         const DPOINT2D& pt
         );

      virtual ERRVALUE v_DrawPoints (
         const LPOINT2D* points, 
         INT32 NumPoints
         );
      
      virtual ERRVALUE v_DrawRectangle (
         INT32 x1,                     
         INT32 y1,                     
         INT32 x2,                     
         INT32 y2                      
         );

      virtual ERRVALUE v_DrawRectangle (
         const LRECT2D& rect
         );

      virtual ERRVALUE v_DrawRectangle (
         const DRECT2D& rect
         );

      virtual ERRVALUE v_DrawSegments (
         const LSEGMENT2D* segments, 
         INT32 NumSegments
         );

      virtual ERRVALUE v_DrawStringStraight (
         const DPOINT2D& pt,  
         double baseangle,
         const MGD::STRINGDATA& gidstr,
         int sindex,    
         int eindex,    
         double SpaceExtra,
         double GlyphExtra
         );

      virtual ERRVALUE v_EraseRectangle (
         const LRECT2D& rectangle,           
         const COLOR& color                  
         );

      virtual ERRVALUE v_FillArc (
         INT32 xcenter,                      
         INT32 ycenter,                      
         INT32 xradius,                      
         INT32 yradius,                      
         double startangle,                  
         double sweepangle,                  
         double rotangle = 0,                   
         MGD::SHAPECLOSE closemode = SHAPECLOSE_Direct
         );

      virtual ERRVALUE v_FillArc (
         double xcenter, 
         double ycenter, 
         double xradius, 
         double yradius, 
         double startangle, 
         double sweepangle, 
         double rotangle, 
         MGD::SHAPECLOSE closemode     
         );

      virtual ERRVALUE v_FillCircle (
         INT32 xcenter,                      
         INT32 ycenter,                      
         INT32 radius                        
         );
         
      virtual ERRVALUE v_FillCircle (
         double xcenter,                        
         double ycenter,                        
         double radius                       
         );

      virtual ERRVALUE v_FillEllipse (
         INT32 xcenter,                      
         INT32 ycenter,                      
         INT32 xradius,                      
         INT32 yradius,                      
         double rotangle = 0                    
         );

      virtual ERRVALUE v_FillEllipse (
         double xcenter,                        
         double ycenter,                        
         double xradius,                        
         double yradius,                        
         double rotangle                     
         );
      
      virtual ERRVALUE v_FillPolygon (
         const LPOINT2D* points, 
         INT32 NumPoints, 
         MGD::POLYSHAPE shape = POLYSHAPE_Complex, 
         bool DrawOutline = false
         );

      virtual ERRVALUE v_FillPolygons (
         const LPOLYGON* polygons, 
         INT32 NumPolys, 
         bool DrawOutline = false
         );

      virtual ERRVALUE v_FillRectangle (
         INT32 x1,      
         INT32 y1,      
         INT32 x2,      
         INT32 y2       
         );

      virtual ERRVALUE v_FillRectangle (
         const LRECT2D& rect
         );

      virtual ERRVALUE v_FillRectangle (
         const DRECT2D& rect
         );
      
      virtual ERRVALUE v_FillRegion (
         const REGION2D& polygons,
         bool DrawOutline = false
         );

      virtual ERRVALUE v_FillSubRegion (
         const SUBREGION2D& polygons,
         bool DrawOutline = false
         );

      virtual ERRVALUE v_ImageBegin (
         INT32 x,                            
         INT32 y,                            
         INT32 width,                        
         INT32 height,                       
         COLORSPACE colorspace,              
         const COLOR_ARRAY* colormap = 0,       
         UINT32 flags = 0
         );
      
      virtual ERRVALUE v_ImageEnd (
         UINT32 flags = 0
         );

      virtual ERRVALUE v_PutImageSpanDirect (
         INT32 x, 
         INT32 y, 
         INT32 len, 
         const void* data, 
         const UINT8 *mask = 0
         );

      virtual ERRVALUE v_PutPixel (
         INT32 x, 
         INT32 y, 
         PIXEL pixel
         );

      virtual ERRVALUE v_PutPixel3D (
         INT32 x, 
         INT32 y, 
         float z, 
         PIXEL pixel
         );

      virtual void v_Reset ();

      virtual void v_SetBitmapOrigin (
         INT32 xorigin,                      
         INT32 yorigin                       
         );

      virtual void v_SetColorIsPatternVariable (
         bool value
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      SIMPLE_ARRAY<PRIVDATA*> m_PrivData;
      int m_CurrentPassNum;
      int m_NumPassesNeeded;
      MGD::OPACITY_MODE m_OpacityBlendMode;
      UINT16 m_FrameBuffer;
      STIPPLEMASK m_StippleMask;
      bool m_StippleIsUsed;

      static ERRVALUE OpenFontTTF (const MIUNICODE* fontname, MGD::FONT** pFont);
      static ERRVALUE OpenFontOF (const MIUNICODE* fontname, MGD::FONT** pFont);
      
      // Unimplemented.
      CONTEXT (const CONTEXT&);
      CONTEXT& operator= (const CONTEXT&);

      void ClipRegionValidate ();
      void ClipRegionInit ();

      ERRVALUE ComputeLabelFrame (
         REGION2D& Frame,
         const LABELSTYLE& Style,
         const DRECT2D& Extents,
         const DRECT2D* ExtentsSansDecenders,
         const DPOINT2D& BasePt,
         double RotAngle
         );

      ERRVALUE ComputeLabelExtentsAlongCurve (
         REGION2D& extents,
         const MIUNICODE* text,
         const POLYLINE& BaseLine,
         const LABELSTYLE& Style,
         const POLYLINELIST& LeaderLines,
         bool bCheckClipping = false
         );
         
      ERRVALUE ComputeTextExtentsShrinkWrapped (
         REGION2D& CombinedExtents,          
         const MIUNICODE* string,
         const POLYLINE& Baseline,
         const TEXTSTYLE& style,
         double BufferDistance = 0.0,
         MGD::BASELINE baseflags = MGD::BASELINE_Straight,
         MGD::FONT::MODE mode = MGD::FONT::MODE_MIUNICODE
         );

      ERRVALUE DrawLabelAlongCurve (const MIUNICODE *text, const POLYLINE& BaseLine, const LABELSTYLE& Style, const POLYLINELIST& LeaderLines);
      ERRVALUE DrawLabelFrameAndLeaders (const REGION2D& Frame, const LABELSTYLE& Style, const POLYLINELIST& LeaderLines);

      ERRVALUE DrawLinesPattern (const LPOINT2D* points, INT32 NumPoints);
      ERRVALUE DrawLinesPattern (const POLYLINE& lines);
      ERRVALUE DrawLinesThick (const LPOINT2D* points, INT32 NumPoints);
      ERRVALUE DrawLinesThickAA (const LPOINT2D* points, INT32 NumPoints);
      ERRVALUE DrawLinesThickAA (const POLYLINE& line);
      ERRVALUE DrawLinesThin (const LPOINT2D* points, INT32 NumPoints);
      ERRVALUE DrawLinesThinAA (const LPOINT2D* points, INT32 NumPoints);
      ERRVALUE DrawLinesThinAA (const POLYLINE& line);

      ERRVALUE DrawPointPattern (INT32 x, INT32 y);

      ERRVALUE DrawStringAlongCurve (const POLYLINE& BaseLine, const MGD::STRINGDATA& gidstr, int sindex, int eindex, UINT32 baseflags);

      ERRVALUE FillSpanSub (INT32 x1, INT32 x2, INT32 y);
      ERRVALUE FillSpanWithDepthTest (INT32 x1, INT32 x2, INT32 y);

      ERRVALUE GenArcPoints (
         const LPOINT2D& center,
         INT32 xradius,
         INT32 yradius,
         double StartAngle,
         double SweepAngle,
         double RotAngle,
         SIMPLE_ARRAY<LPOINT2D>& points,
         bool bKeepExistingPoints = false
         );

      ERRVALUE GenRoundedRectPoints (const LRECT2D& rect, INT32 radius, SIMPLE_ARRAY<LPOINT2D>& points);

      ERRVALUE HatchMBR (const LRECTXY &mbr, RVC::STYLEPATTERN_HATCH& HatchPatt, const void *vpHatchElement);
      ERRVALUE HatchPolygons (const LPOLYGON *poly, INT32 numpoly);
      ERRVALUE HatchPolygons (const REGION2D&);
      ERRVALUE HatchPolygonsStyle (const LPOLYGON *poly, INT32 numpoly);
      ERRVALUE HatchPolygonsStyle (const REGION2D& region);

      ERRVALUE LabelFrameMergeBalloonLeaders (REGION2D& frame, const LABELSTYLE& Style, const POLYLINELIST& LeaderLines);

      bool SetupICMTransform ();

      friend class MGD::DEVICE;        // Only MGD::DEVICE::CreateGC() can call our constructor
      friend struct MGD::TEXTBLOCK;    // Needs to call private methods
      friend class SAVEFONTFLAGS;   
      friend class LOCALOPENFONTS;     // Located in mg2text.c
      #endif // GENERATING_DOXYGEN_OUTPUT

      virtual ERRVALUE v_DrawIcon (
         INT32 x, 
         INT32 y, 
         MICONSTRUCT* icon, 
         ICONFLAGS flags
         );

      virtual ERRVALUE v_InterfaceTextDrawString (
         INT32 x, 
         INT32 y, 
         const MIUNICODE* string, 
         TEXTBASEORIGIN baseorigin, 
         bool bVisualOrder,
         INTERFACETEXTSTYLE style
         );

      virtual ERRVALUE v_InterfaceTextGetExtents (
         const MIUNICODE* string,               
         int *width,                         
         int *height,                     
         int *ascent,                     
         INTERFACETEXTSTYLE style
         );
      
      virtual ERRVALUE v_InterfaceTextGetMetrics (
         const MIUNICODE* string,               
         TEXTMETRICS& metrics,
         INTERFACETEXTSTYLE style
         );
      
      virtual int v_InterfaceTextGetWidth (
         const MIUNICODE* string,               
         INTERFACETEXTSTYLE style,
         bool bInkMetrics
         );

      virtual void v_SymbolBegin ();

      virtual void v_SymbolEnd ();

      virtual void v_TextBlockBegin (
         const MGD::TEXTBLOCK& block   
         );

      virtual void v_TextBlockEnd (
         const MGD::TEXTBLOCK& block   
         );

      virtual void v_TextSpanBegin ();

      virtual void v_TextSpanEnd ();

      virtual void v_UpdateClipNone ();

      virtual void v_UpdateClipRect ();

      virtual void v_UpdateClipRegion ();

      virtual void v_UpdateColor ();

      virtual void v_UpdateColor2 (const COLOR&);

      virtual void v_UpdateFont (const MGD::FONT*);

      virtual void v_UpdateLineAttributes ();

      virtual void v_UpdateLineWidth ();

      virtual void v_UpdatePixelFunc ();

      virtual void v_UpdatePlaneMask ();

      virtual void v_UpdateStipple ();

   };

//=====================================================================================================================
class SAVECLIP {
   public:
      SAVECLIP (
         MGD::CONTEXT& gc
         );

      ~SAVECLIP();

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      MGD::CONTEXT& m_gc;
      REGION2D* m_SavedClip;  
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   
//=====================================================================================================================
struct STRINGDATA {
   STRINGDATA() {}
   ~STRINGDATA() {}

   STRINGDATA (
      MGD::CONTEXT* context, 
      const MISTRING& str
      );
   
   STRINGDATA (
      MGD::CONTEXT* context, 
      const MIUNICODE* str,
      MGD::FONT::MODE mode
      );

   struct CHARDATA {
      UINT16 gid;          
      UINT16 flags;
      FTFACE* face;        
      DPOINT2D pos;
      };
   
   SIMPLE_ARRAY<UINT16> m_gid;         
   SIMPLE_ARRAY<FTFACE*> m_face;       
   SIMPLE_ARRAY<UINT16> m_gflags;      
   SIMPLE_ARRAY<DPOINT2D> m_pos;       
   MISTRING m_str;         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      STRINGDATA(const STRINGDATA&);

      ERRVALUE Initialize (
         MGD::CONTEXT* context, 
         const MIUNICODE* str,
         MGD::FONT::MODE mode
         );
      #endif // GENERATING_DOXYGEN_OUTPUT
   };



//=====================================================================================================================
class COLORLOCK {
   public:

      COLORLOCK (
         CONTEXT *pContext
         ) : m_pContext(pContext), m_locked(false) { }

      ~COLORLOCK (
         ) { Clear(); }

      void Clear (
         ) { if (m_locked) m_pContext->SetColorLock(false); m_locked = false; }

      void Set (
         ) { if (!m_locked) m_pContext->SetColorLock(true); m_locked = true; }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      CONTEXT *m_pContext;
      bool m_locked;

      COLORLOCK (const COLORLOCK&);
      COLORLOCK& operator= (const COLORLOCK&);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================
class CONTEXT_AUTOPTR {
   public:

      CONTEXT_AUTOPTR (
         ): m_pContext(DEVICE::GetNull().CreateContext())
         { }

      explicit CONTEXT_AUTOPTR (
         DEVICE& dev
         ): m_pContext(dev.CreateContext())
         { }

      ~CONTEXT_AUTOPTR (
         ) { delete m_pContext; }

      CONTEXT& operator* () const {
         return (*m_pContext);
         }

      CONTEXT* operator-> () const {
         return (m_pContext);
         }

      operator CONTEXT* (
         ) const { return (m_pContext); }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      CONTEXT_AUTOPTR(const CONTEXT_AUTOPTR&);
      CONTEXT_AUTOPTR& operator=(const CONTEXT_AUTOPTR&);

      CONTEXT *m_pContext;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================
//    Public functions in MGD namespace

ERRVALUE DlgGetScalableFont (
   MDLGPARENT dlgparent,         
   MISTRING& FontName,           
   const MISTRING& PromptStr,    
   bool TrueTypeOnly = true      
   );

DEPRECATED int TextGetFontByName (
   INIHANDLE ini,                      
   MIUNICODE *fontname,                
   MIUNICODE *family,                  
   UINT32 StyleFlags,                  
   UINT32 *pStyleFlags                 
   );

int TextGetFontByName (
   MISTRING& fontname,                 
   const MIUNICODE *family,               
   UINT32 StyleFlags,                  
   UINT32 *pStyleFlags,                
   INIHANDLE ini = 0                   
   );

int TextGetFontByFamily (
   MISTRING& fontname,                 
   const MIUNICODE *family,               
   UINT32 StyleFlags,                  
   UINT32 *pStyleFlags,                
   INIHANDLE ini = 0                   
   );

int TextGetFontByFullName (
   MISTRING& fontname,                 
   const MIUNICODE *realname,             
   UINT32 StyleFlags,                  
   UINT32 *pStyleFlags,                
   INIHANDLE ini = 0                   
   );

ERRVALUE TextGetFontInfo (
   int fhandle,                        
   MGD::FONT *font                        
   );

ERRVALUE TextGetFontName (
   int fonthandle,                     
   MISTRING& fontname                     
   );

// Can be removed after 24 Mar 07 and that the module that calls this is changed
ERRVALUE TextGetFontNameOld (
   int fonthandle,                     
   MIUNICODE* fontname                    
   );

ERRVALUE TextGetTTFName (
   INIHANDLE ini,                      
   const MIUNICODE *fontname,                
   MGD::TTFNAMEID nameid,                          
   MISTRING& name,
   UINT32 *pStyleFlags                 
   );

void GetDefaultFontName (
   MISTRING& name
   );

//=====================================================================================================================

} // End of namespace MGD

#endif   // INC_MI32_MGD2_H

---