mi32/mg2pdf.h

Go to the documentation of this file.

/*
 * \file mi32/mg2pdf.h
 * \brief MGD PDF rendering
 *
 * \if NODOC
 * $Id: mg2pdf.h_v 1.24 2012/01/10 16:05:04 mju Exp $
 *
 * $Log: mg2pdf.h_v $
 * Revision 1.24  2012/01/10 16:05:04  mju
 * Remove unused statuscontext member and unneeded hdr.
 *
 * Revision 1.23  2011/10/04 13:28:08  mju
 * Make private stuff private and exclude from dox.
 *
 * Revision 1.22  2011/08/12 14:00:21  mju
 * Exclude log from doxygen.
 *
 * Revision 1.21  2011/08/12 13:56:13  mju
 * Use color::getColor0RGB32.
 *
 * Revision 1.19  2009/01/15 20:20:41  ldyas
 * supporting multiple page documents
 *
 * Revision 1.17  2009/01/09 18:57:03  ldyas
 * set fontrender separate from embed.
 *
 * Revision 1.16  2009/01/08 23:12:04  ldyas
 * rederfonts now has default and toggles.
 *
 * Revision 1.15  2009/01/08 22:10:57  ldyas
 * fixing font render settings.
 *
 * Revision 1.14  2008/08/28 13:42:51  mju
 * Add inclusion guards and remove headers not needed to compile this header in isolation.
 *
 * Revision 1.13  2008/07/11 21:46:26  ldyas
 * send DispToGroup to group end  and tranoord for drect2d
 *
 * Revision 1.12  2008/06/30 19:36:31  ldyas
 * scaled zero width lines
 *
 * Revision 1.11  2008/05/21 19:39:00  ldyas
 * added integer fill circle.
 *
 * Revision 1.10  2008/05/13 18:18:29  ldyas
 * made optional content groups optional
 *
 * Revision 1.9  2008/05/06 20:22:21  ldyas
 * now passing reference view index to device.
 *
 * Revision 1.6  2008/04/22 22:02:56  ldyas
 * supporting layer invisibility if reference view present.
 *
 * Revision 1.5  2008/04/15 15:29:33  ldyas
 * added layer is group bool.
 *
 * Revision 1.4  2008/04/11 18:34:38  ldyas
 * track whether layer has content.
 *
 * Revision 1.3  2008/04/10 16:54:07  ldyas
 * removed extra qualifier to make linux more happy.
 *
 * Revision 1.2  2008/04/10 16:48:49  ldyas
 * added header for mistringlist
 *
 * Revision 1.1  2008/04/10 16:24:02  ldyas
 * Initial revision
 * \endif
**/

#ifndef INC_MI32_MG2PDF_H
#define INC_MI32_MG2PDF_H

#ifndef INC_MI32_MGD2_H
   #include <mi32/mgd2.h>
#endif

#ifndef INC_MI32_FILERAW_H
   #include <mi32/fileraw.h>
#endif

#ifndef  INC_REGION2D_H
   #include <mi32/region2d.h>
#endif

#ifndef  INC_MI32_RVCSTYLE_H
   #include <mi32/rvcstyle.h>
#endif

#ifndef  INC_MI32_MISTRINGLIST_H
   #include <mi32/mistringlist.h>
#endif

#ifndef NOLIBZ
#include <zlib.h>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward declarations.
namespace GRE {
   class LAYER;
   class GROUP;
   }
namespace RVC {
   class ELEMENT;
   }
#endif


#define MAXLINELEN   79 /* Maximum line length in Postscript is 256 */

#define FLAG_NoSpace  1 /* Flag to SendString, don't add a leading space */
#define FLAG_EOL      2
#define FLAG_OptEOL   4 /* EOL after this if getting close to max line length */
#define FLAG_SJIS 8
#define FLAG_NoEOL 16 // force append

#define STREAM_ForImage    0x00000001
#define FILTER_ASCIIHEX    0x00000002
#define FILTER_FLATE       0x00000004
#define STREAM_ForLayer       0x00000008


#define PROCSET_PDF     0x00000001
#define PROCSET_ImageC  0x00000002
#define PROCSET_ImageB  0x00000004
#define PROCSET_ImageI  0x00000008
#define PROCSET_Text 0x00000010

#define HexStr "0123456789ABCDEF"

#define GlyphPrecision 3

#define NUMBER_OF_STD_FONTS 26   //Treated as standard adobe fonts to reduce file size even though 
                        //they arent really (because we don't support postscript fonts)

static char StandardFonts[26][32] = {  
   "Courier", 
   "CourierBold",
   "CourierBoldOblique", 
   "CourierOblique",
   "CourierNew",
   "CourierNew-Bold",
   "CourierNew-Italic",
   "CourierNew-BoldItalic",
   "Helvetica", 
   "Helvetica-Bold",
   "Helvetica-BoldItalic",
   "Helvetica-Italic",
   "TimesRoman-BoldItalic", 
   "TimesRoman-Bold", 
   "TimesRoman-Italic", 
   "TimesRoman", 
   "TimesNewRoman" ,
   "TimesNewRoman-BoldItalic" ,
   "TimesNewRoman-Bold" ,
   "TimesNewRoman-Italic" ,
   "Arial", 
   "ArialMT", 
   "Arial-Bold", 
   "Arial-BoldItalic",
   "Symbol",
   "ZaphDingbats"
};

#define PATSCALE  2
#define PATAND    (PATSCALE-1)
#define PATSHIFT  1

#define BEZIER (4.0*(sqrt(2.0)-1.0)/3.0)   // used to convert circles to bezier curves

struct PDFPRIVDISP;


namespace MGD {

class CONTEXT_PDF2;

class DEVICE_PDF2 : public MGD::DEVICE {

   public:

      DEVICE_PDF2 ();

      DEVICE_PDF2 (
         const DPOINT2D& size,
         const DPOINT2D& margin,
         const DOUBLE res
         );

      virtual ~DEVICE_PDF2();

      ERRVALUE AddPage ( //stores page size
         DPOINT2D& FullPageSize, 
         DPOINT2D& TopLeftMargin,
         const MIUNICODE* title,
         double dpi
         );

      ERRVALUE Create (
         const FILEPATH& filepath,
         DPOINT2D& FullPageSize,  
         DPOINT2D& TopLeftMargin,      // Sizes in inches
         const MIUNICODE* title = NULL 
         );

      ERRVALUE Close();

      ERRVALUE StartElement (
         GRE::LAYER *layer,
         const RVC::ELEMENT &element
         );

      ERRVALUE EndElement (
         );

      ERRVALUE EndLayer ();

      void EndPage ()
         { m_Pages.PushBack(m_CurrentPage); }

      ERRVALUE StartLayer (
         const MISTRING& layername,
         bool bIsRaster
         );
      
      ERRVALUE StartLayerStream (
         );

      void SetLayer (
         GRE::LAYER* layer
         ) { m_Layer = layer; }

      void SetIncludeLayerVisibility(
         bool vis
         ){ m_bIncludeLayerVisibility = vis; }

      ERRVALUE EndGroup (
         GRE::GROUP* gp,
         const TRANS2D_AFFINE& DispToGroup
         );

      ERRVALUE BeginGroup (
         GRE::GROUP* gp
         );

      int DumpFillPatternLayer (
         BITMAPPATTHDR *hdr,
         UINT8 *bitmap,
         int c,             
         COLOR *color       
         );
      
      void RenderFonts (
         bool render = true
         ) {
         m_bVersion10 = render;
         }

      void EmbedFonts (
         bool embed
         ) {
         m_bEmbedFonts = embed;
         }

      void SubstitueCourier (
         bool subcourier
         ) {
         m_bSubstituteCourier = subcourier;
         }

      void SetScaleZeroWidth (
         bool scaleit
         ) {
         m_ScaleZeroWidth = scaleit;
         }

      void SetReferenceIndex (
         int ref
         ) {
         m_reference = ref;
         }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      struct PATTERN {
         void GetName (
            const COLOR *var,
            char *name
            ) const;

         char m_name[32];
         unsigned defined:1,
                  redundant:1,   /* There's another just like it */
                  HasVarColor:1,
                  HasTransparent:1,
                  SpareBits:28;
         int PaintType;          /* 1 = Color specified by pattern, 2 = 1 user defined color */
         int OtherColorsUsed;
         int PatternNum;            /* The pattern number within that layer */
         int Version;               /* # of other patterns with same name */
         UINT8 ColorUsage[256/8];
         int NumVarColorsUsed;
         UINT8 *pattbuf;            /* Free this */
         int size;
         int id;                 /* id used if no variable colors */
         int *ids;               /* One id for each variable color used */
         BITMAPPATTHDR *hdr;        /* Offset into pattbuf.  DO NOT FREE! */
         COLOR *colors;             /* offset into pattbuf.  DO NOT FREE! */
         UINT8 *bitmap;             /* offset into pattbuf.  DO NOT FREE! */
         COLOR *VarColor;  /* Array of variable colors for which pattern should be defined */
         struct PATTERN *alias;     /* Points to identical pattern from previous layer in AllPatterns */
         };
      
      struct PDF_FONT {
         MISTRING name,file;
         TEXTSTYLE textstyle;
         FONTINFO fontinfo;
         UINT16 widths[512];
         int avgwidth;
         int maxwidth;
         bool embed;
         MISTRING type;
         UINT32 flags;
         int ID;
         };

      struct PAGE {
         INT32 pagey;
         INT32 pagex;
         INT32 lm;
         INT32 tm; 
         INT64 id;
         MISTRINGLIST viewports;
         MILIST<PDF_FONT> fonts;
         MISTRINGLIST LayerNames;
         MISTRINGLIST GroupNames;
         SIMPLE_ARRAY<UINT32> LayerIndexes;
         SIMPLE_ARRAY<bool> LayerIsGroup;
         SIMPLE_ARRAY<bool> LayerVisibilities;
         SIMPLE_ARRAY<double> TranspStates;
         SIMPLE_ARRAY<UINT32> StreamIDs; 
         SIMPLE_ARRAY<UINT32> ImageIDs;
      // SIMPLE_ARRAY<UINT32> FontIDs;
         };

      struct UNDERLINE {
         POLYLINE path;
         int width;
         COLOR color;
         int outlineWidth;
         COLOR outlineColor;
         bool stroke;
         bool fill;
         };

      PAGE *m_CurrentPage;
      MILIST<PAGE*> m_Pages;

      GRE::LAYER *m_Layer;
      GRE::GROUP *m_Group;
      int m_len;        /* Lenght of current line */
      double m_hres, m_vres;
      double m_scale, m_yshift;
      double m_LineWidth;
      MGD::LINECAP m_LineCapStyle;
      MGD::LINEJOIN m_LineJoinStyle;
      int m_LayerNum;         /* Incremented every time we start a layer */
      MISTRING m_LayerName; /* active layer name*/
      LRECTXY m_ClipRect;

      PATTERN *m_Patterns; /* Patterns this layer */
      int m_NumPatterns;
      PATTERN *m_AllPatterns; /* All patterns we've seen so far */
      int m_TotalPatterns;
      bool m_bDumpPattern;

      bool m_bVersion10;
      bool m_bForceUpdateGC;
      bool m_bInLayer;
      bool m_bInGroup;
      bool m_bInImage;
      bool m_bEmbedFonts;
      bool m_bClippingOn;
      bool m_bCurLayerIsRaster;
      bool m_ScaleZeroWidth;
      COLOR m_DrawColor;
      COLOR m_FillColor;
      int m_CurFillPattern;         /* Pattern currently active (-1) if none */
      int m_ImageX, m_ImageY, m_ImageLins, m_ImageCols;  /* For error checking on PutImageSpan */
      int m_ImageLinsSeen;
      FILE_RAW m_MaskFile, m_OutputFile, m_ImageFile;
      FILEPATH m_MaskFilename, m_ImageFilename;
      INT32 m_PatternStartOffset;
      int m_reference;


      MISTRING m_FontManagement;
      bool m_bSubstituteCourier;
      bool m_bDoFill;
      bool m_bDoBorder;
      // XXX Stuff added for PDF
      bool m_bWasInLayer;
      UINT32 m_ProcsetsNeeded;         
      int m_IDsAllocated;
      int m_InfoID;
      MISTRING m_TextBegining,m_FontName;

      SIMPLE_ARRAY<UINT32> m_offsets;

       

      int m_CurrentFont;
      MILIST<PDF_FONT> m_Fonts;
      PDF_FONT m_DefaultFont;
      bool m_bFontStream;

      INT32 m_StreamStart;
      int m_CurStreamID, m_EndStreamID, m_FontLength;
      DPOINT2D m_PrintableSize;
      DPOINT2D m_FullPageSize;
      DPOINT2D m_TopLeftMargin;

//stuff for text support
      bool m_bInTextBlock;
      bool m_bNeedFontSet;
      MISTRING m_LastFont;
      double m_TextHeight;
      MISTRING m_TextStyle;
      double m_BaseAngle;
      DPOINT2D m_BasePoint;
      MILIST<UNDERLINE> m_UnderlineList;
   // MISTRINGLIST m_LayerNames;
   // MISTRINGLIST m_GroupNames;
   // MISTRINGLIST m_ViewPorts;
      INT32 m_ActiveGroup;
      SIMPLE_ARRAY<UINT32> m_FontIDs;
   // SIMPLE_ARRAY<UINT32> m_LayerIndexes;
   // SIMPLE_ARRAY<bool> m_LayerIsGroup;
   // SIMPLE_ARRAY<bool> m_LayerVisibilities;
//transparency stuff
      double m_CurrentOpacity;
   // SIMPLE_ARRAY<double> m_TranspStates;
      SIMPLE_ARRAY<UINT8> m_Mask;
      bool m_bImageHasTransparency,m_bImageHasNullCells,m_bLayoutHasTransparency;
      bool m_LayerHasContent;
      bool m_bIncludeLayerVisibility;
      UINT32 m_crc;
      

#ifndef NOLIBZ
       z_stream m_zstream;
#endif
      char m_ahbuf[80];
      int m_ahbufpos;
      
      UINT8 m_zbuf[32768];
   
      UINT32 m_filter;
 

      int AllocID (
         );

      int CompressBegin (
         );

      int CompressEnd (
         );

      int BeginStream (
         const char *comment,
         UINT32 flags,
         int length1 = 0
         );

      int EndStream (
         int forLayer = 0
         );

      void TestClipRegion (
         MGD::CONTEXT_PDF2* gc
         );

      
      /*
      ** Function for insterting ProcSets and other resources
      ** Valid names of procsets already stored in printers.ref...
      **
      ** ADOBE2, COLORIMG, CSHOW, ILLUST5, PATTERN
      */


      ERRVALUE ActivateGC (
         CONTEXT_PDF2* gc
         );

      ERRVALUE ActivateTC (
         CONTEXT_PDF2* gc 
         );

      int DumpFillPattern (
         PATTERN *pat,
         COLOR *var        /* Variable color */
         );

      void FreePrivateData();

      int FontInList(
         MISTRING name
         );

      ERRVALUE AppendFile ( //uses PortWrite to control hexencode/compression
         const FILEPATH& filename
         );

      ERRVALUE SetFillPattern (
         CONTEXT_PDF2* gc
         );

      int PortWrite (
         const char *buf,
         int len
         ) { return (PortWrite(reinterpret_cast<const UINT8*>(buf), len)); }
      
      int PortWrite (
         const UINT8 *buf,
         int len
         );

      int PortWrite (
         const char *buf,
         int len,
         FILE_RAW& file
         ) { return (PortWrite(reinterpret_cast<const UINT8*>(buf), len, file)); }
      
      int PortWrite (
         const UINT8 *buf,
         int len,
         FILE_RAW& file
         );

      int SendEOL (
         );

      int SendString (
         const char *str,
         UINT32 flags
         );

      int SendString (
         const MISTRING& str,
         UINT32 flags
         );

      int SendLong (
         INT32 num
         );

      // Used by compression code
      int z_putLong (
         UINT32 x
         );

      int SendDouble (
         DOUBLE num
         );

      int SendXYCmdDouble (
         double x,
         double y,
         const char *cmd,
         UINT32 flags
         );

      int SendXYCmdDoubleUnscaled (
         double x,
         double y,
         const char *cmd,
         UINT32 flags
         );

      int SendXYCmdUnscaledLong (
         INT32 x,
         INT32 y,
         const char *cmd,
         UINT32 flags
         );

      void TransCoord (
         INT32 x, 
         INT32 y, 
         double *dx, 
         double *dy
         ) {
         *dx = (double)x * m_scale;
         *dy = m_yshift - (double)y * m_scale;
         return;
         }

      void TransCoord (
         double x, 
         double y, 
         double *dx, 
         double *dy
         ) {
         *dx = x * m_scale;
         *dy = m_yshift - y * m_scale;
         return;
         }
      
      void TransCoord (
         const DRECT2D& in,
         DRECT2D& out
         ) {
          out.xinit = in.xinit * m_scale;
          out.xlast = in.xlast * m_scale;
          out.ylast = m_yshift - in.ylast * m_scale;
          out.yinit = m_yshift - in.yinit * m_scale;
         return;
         }

      MISTRING Escape (
         MISTRING str
         ) {
         int len = str.GetLength();
         MISTRING temp,p1("("),p2(")"),ch;
         for(int i=0;i<len;i++){
            ch = str.GetSubString(i,i);
            if(ch.Compare(p1)==0){temp<<"\\(";}
            else if(ch.Compare(p2)==0){temp<<"\\)";}
            else{ temp<<ch; }
            }       
         return(temp);
         }

      // DEVICE overrides.

      virtual bool v_AvoidFillSpans () const
         { return (true); }

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

      MGD::CAPABILITY v_GetCapabilities () const
         { return (DEVICE::v_GetCapabilities() | MGD::CAPABILITY_MaskInImageSpan | MGD::CAPABILITY_Transparency | MGD::CAPABILITY_BitmapFill | MGD::CAPABILITY_ComplexClip | MGD::CAPABILITY_FloatingPointCoordinates ); }
 
      virtual MGD::CONTEXT* v_CreateContext ();
   
      virtual MGD::PIXEL v_GetColorPixel (const COLOR& color)
         { return (static_cast<MGD::PIXEL>(color.GetColor0RGB32())); }

      virtual COLORSPACE v_GetColorSpace () const
         { return (COLORSPACE_R8_G8_B8); }

      virtual bool v_GetNeedFullImageLine () const
         { return (true); }

      virtual void v_GetPixelColor (MGD::PIXEL pixel, COLOR& color ) const
         { color.SetRGB(static_cast<UINT16>((pixel & 0x00FF0000) >> 8), static_cast<UINT16>(pixel & 0x0000FF00), static_cast<UINT16>((pixel & 0x000000FF) << 8)); }

      friend class CONTEXT_PDF2;

      #endif   // GENERATING_DOXYGEN_OUTPUT

   };



class CONTEXT_PDF2 : public MGD::CONTEXT {
   public:

      CONTEXT_PDF2 (
         DEVICE_PDF2* dev
         ) :
         MGD::CONTEXT(dev),
         m_DevPDF(dev),
         m_bHasClip(false),
         m_bNewClipRegion(false),
         m_bDrawingGlyph(false)
         {
         }

      ~CONTEXT_PDF2 (
         ) {}

      virtual void v_UpdateColor (
         ) {
         GetPixelColor(m_DrawColorPixel, m_DrawColor);
         return;
         }

      virtual void v_UpdateColor2 (
         const COLOR& color
         ) {
         m_DrawColor = color;
         return;
         }

      virtual void v_UpdateClipRegion (
         ) {
         m_bNewClipRegion = m_bHasClip = true;
         }

      virtual void v_UpdateClipNone (
         ) {
         m_bNewClipRegion = m_bHasClip = false;
         }


      virtual void v_UpdateClipRect (
         ) {
         m_bHasClip = m_bNewClipRegion = true;
         }

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

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

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

      virtual ERRVALUE v_DrawArc (
         double xcenter, 
         double ycenter, 
         double xradius, 
         double yradius, 
         double startangle, // radians
         double sweepangle, // radians 
         double rotangle,   // radians 
         MGD::SHAPECLOSE closemode     // CLOSE_ViaCenter,  _Direct, or _None 
         );

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

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

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

      virtual ERRVALUE v_DrawLinesDashed (
         const LPOINT2D* points,              
         INT32 numpoints,
         const double *DashArray,
         INT32 DashCount,
         double DashOffset,                   
         bool close                     
         );

      virtual ERRVALUE v_DrawLinesLow (
         const LPOINT2D *lpoint,
         INT32 NumPoints
         ); 
            
      virtual ERRVALUE v_DrawLinesLow (
         const POLYLINE& line
         );
            
      virtual ERRVALUE v_DrawPoint (
         INT32 x,
         INT32 y
         );
 
      virtual ERRVALUE v_DrawPoint (
         const DPOINT2D& pt 
         );

      virtual ERRVALUE v_FillRegion (
         const REGION2D& region,
         bool DrawOutline
         );


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

      virtual ERRVALUE v_FillPolygon (
         const LPOINT2D *lpoint,
         INT32 NumPoints,
         MGD::POLYSHAPE shape = MGD::POLYSHAPE_Complex,
         bool bDrawBorder = false
         );

      virtual ERRVALUE v_FillPolygons (
         const LPOLYGON *lpolygons,
         INT32 NumPolys,
         bool bDrawBorder
         );
    
      virtual ERRVALUE v_DrawRectangle (
         INT32 x1,
         INT32 y1,
         INT32 x2,
         INT32 y2
         );

      virtual ERRVALUE v_FillRectangle (
         const DRECT2D& rect
         );


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

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

      virtual ERRVALUE v_DrawStringStraight (
         const DPOINT2D& pt,  // Base point for the string
         double baseangle,
         const MGD::STRINGDATA& gidstr,
         int sindex,    // The starting glyph index to draw
         int eindex,    // The last glyph index to draw
         double SpaceExtra,
         double GlyphExtra
         );


      virtual ERRVALUE v_ImageBegin (
         INT32 x,
         INT32 y,
         INT32 cols,
         INT32 lins,
         COLORSPACE ColorSpace,
         const COLOR_ARRAY *colmap,
         UINT32 flags
         );
         
      virtual ERRVALUE v_PutImageSpanDirect (
         INT32 x,
         INT32 y,
         INT32 len,
         const void *data,
         const UINT8 *mask
         );

      virtual ERRVALUE v_ImageEnd (
         UINT32 flags
         ); 

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

      virtual void v_TextSpanBegin ();


      virtual void v_TextSpanEnd ();

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

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

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      bool m_bHasClip;
      bool m_bNewClipRegion;
      bool m_bDrawingGlyph;
      COLOR m_DrawColor;
      COLOR m_FillColor;
      DEVICE_PDF2 *m_DevPDF;
      
      friend class DEVICE_PDF2;

      ERRVALUE ComposeArc (
         double xcenter,
         double ycenter,
         double xradius,
         double yradius,
         double sangle,             /* Starting angle in RADIANS */
         double eangle,             /* angle in RADIANS */
         double rotangle,           /* Rotation angle in RADIANS */
         MGD::SHAPECLOSE closemode
         );

      ERRVALUE DrawClipRegion (
         const LPOLYGON *lpolygons,
         INT32 NumPolys
         );

      ERRVALUE DrawClipRectangle (
         const DRECT2D& rect
         );

      ERRVALUE DrawUnderlines ();

      ERRVALUE FillClipSubRegion (
         const SUBREGION2D& subregion
         );

      ERRVALUE FillClipRegion (
         const REGION2D& region
         );

      bool InRange (
         const MGD::STRINGDATA& gidstr,
         int sindex,    // The starting glyph
         int eindex     // The last glyph
         );

      void TransCoord (
         INT32 x, 
         INT32 y, 
         double *dx, 
         double *dy
         ) {
         m_DevPDF->TransCoord(x,y,dx,dy);
         return;
         }

      void TransCoord (
         double x, 
         double y, 
         double *dx, 
         double *dy
         ) {
         m_DevPDF->TransCoord(x,y,dx,dy);
         return;
         }

      ERRVALUE ComposeLines (
         const LPOINT2D *lpoint,
         INT32 NumPoints,
         bool bClose
         );

      ERRVALUE ComposeLinesFloat (
         const POLYLINE& line
         );

      #endif   // GENERATING_DOXYGEN_OUTPUT
   };

} // End of MGD namespace

#endif   // INC_MI32_MG2PDF_H

---