mi32/mg2svg.h

Go to the documentation of this file.

/*****************************************************************************
 * \file mi32/mg2svg.h
 * \brief SVG declarations for context ... device 
 *
 * $Log: mg2svg.h_v $
 * Revision 1.91  2012/04/16 17:48:10  ldyas
 * nc.
 *
 * Revision 1.90  2012/03/30 20:03:15  ldyas
 * added elem
 *
 * Revision 1.89  2012/03/23 13:40:09  ldyas
 * Add setSymbolDirectory.
 *
 * Revision 1.88  2012/03/19 12:36:44  ldyas
 * *** empty log message ***
 *
 * Revision 1.87  2011/12/21 23:07:34  bcolombe
 * Add HasElements,SetHasElements
 *
 * Revision 1.86  2011/11/10 14:30:55  mju
 * Use rvc stylepatternhatch hdr.
 *
 * Revision 1.85  2011/11/02 14:12:38  mju
 * Remove redundant hdrs.
 *
 * Revision 1.84  2011/09/16 16:45:06  ldyas
 * added scale factors
 *
 * Revision 1.83  2011/09/15 16:16:52  ldyas
 * not calling it clipping margin
 *
 * Revision 1.82  2011/09/09 17:40:07  ldyas
 * added clipping margin
 *
 * Revision 1.79  2011/08/05 21:41:16  ldyas
 * added SVGSTYLE etc
 *
 * Revision 1.73  2006/10/06 16:12:11  dwilliss
 * changed to use MISTRINGLIST instead of mlist of mistring
 *
 * Revision 1.71  2006/09/20 22:56:13  scowan
 * Converted to new style pattern classes.
 *
 * Revision 1.65  2005/05/04 20:36:53  ldyas
 * preset activeclip
 *
 * Revision 1.63  2005/03/04 20:44:37  ldyas
 * added way to differentiate builtin symbols and custom ones
 *
 * Revision 1.50  2004/04/22 22:52:30  ldyas
 * pt enlargement control added
 *
 * Revision 1.48  2004/04/14 20:02:44  ldyas
 * added enlarge point symbols highlighting.
 *
 * Revision 1.47  2004/03/26 00:30:53  ldyas
 * link to scripts added.
 *
 * Revision 1.46  2004/03/24 19:09:14  ldyas
 * various including layer ctrl panel added.
 *
 * Revision 1.41  2004/02/20 22:38:22  ldyas
 * implemented entities for tool tip data.
 *
 * Revision 1.38  2004/02/05 23:21:42  ldyas
 * methods added to device get string write to file and validate
 *
 * Revision 1.37  2004/02/03 23:15:20  ldyas
 * added self validation to device.
 *
 * Revision 1.15  2003/08/08 20:23:09  ldyas
 * illustrator and linked styles option added
 *
 * Revision 1.1  2003/07/31 23:07:09  ldyas
 * Initial revision
 */

#ifndef INC_MI32_MG2SVG_H
#define INC_MI32_MG2SVG_H

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

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

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

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

#ifndef INC_MI32_FILELEGACY_H
#include <mi32/filelegacy.h>
#endif
 
#ifndef INC_RVC_DBTABSTY_H
#include <rvc/dbtabsty.h>
#endif

#ifndef INC_RVC_STYLE_H
#include <rvc/style.h>
#endif

#ifndef  INC_RVC_STYLEPATTERNHATCH_H
#include <rvc/stylepatternhatch.h>
#endif

#ifndef INC_RVC_DBPOLY_H
#include <rvc/dbpoly.h>
#endif

#ifndef INC_RVC_DBPOINT_H
#include <rvc/dbpoint.h>
#endif

#ifndef INC_RVC_DBLINE_H
#include <rvc/dbline.h>
#endif


#include <contrib/zlib.h>     // <<< XXX Public include files not allowed to include from contrib!


#ifndef GENERATING_DOXYGEN_OUTPUT
namespace RVC {
   class STYLEPATTERN_BITMAP;
   }

class REGION2D;
class SUBREGION2D;

struct SVGSYMBOL {
   int number;
   int id;
   int layer;
   double width;
   double height;
   bool builtin;
   };

struct SVGLAYER {
   int id;
   MISTRING name;
   MISTRING description;
   bool isGroup;
   UINT32 group;
   DPOINT2D size;
   };

struct SVGFILTER {
   int id;
   COLOR color;
   double opacity;
   double x;
   double y;
   double height;
   };

struct SVGSTYLE {
   MISTRING className;
   MISTRING code;
   };

#endif // GENERATING_DOXYGEN_OUTPUT

class SVG;
class JPEGEXT_FILE;

#ifndef GENERATING_DOXYGEN_OUTPUT
class SVGPATTERN {

public:

   SVGPATTERN ();

   ~SVGPATTERN ();

   void GetName (
      MISTRING& name,
      const COLOR *var = 0
      ) const;

   char m_name[32];
   bool m_bDefined;
   bool m_bHasVarColor;
   bool m_bHasTransparent;
   int m_OtherColorsUsed;
   int m_PatternNum;          /* The pattern number within that layer */
   int m_Version;             /* # of other patterns with same name */
   int m_NumVarColorsUsed;
   UINT8 m_ColorUsage[32];
   UINT8 *m_pattbuf;          /* Free this */
   int m_size;
   COLOR *m_VarColor;   /* Array of variable colors for which pattern should be defined */
   SVGPATTERN *m_alias;    /* Points to identical pattern from previous layer in AllPatterns */
   };
#endif // GENERATING_DOXYGEN_OUTPUT

#ifndef GENERATING_DOXYGEN_OUTPUT
struct png_struct_def;
struct png_info_struct;
#endif // GENERATING_DOXYGEN_OUTPUT

namespace MGD {

#ifndef GENERATING_DOXYGEN_OUTPUT
class CONTEXT_SVG;
#endif // GENERATING_DOXYGEN_OUTPUT

class DEVICE_SVG : public MGD::DEVICE {

   public:

      DEVICE_SVG ();

      virtual ~DEVICE_SVG();

      void InitializeDevice (
         UINT32 height,
         UINT32 width
         );

      ERRVALUE Create (
         const FILEPATH& filename, 
         double height, 
         double width, 
         const MIUNICODE* title, 
         UINT32 resolution 
         );

      ERRVALUE Close (
         ); 

      bool HasElements() {return m_bHasElements;}
      void SetHasElements() {m_bHasElements = true;}

      ERRVALUE EndLayer (
         );
 
      ERRVALUE BeginGroup (
         GRE::GROUP* gp
         );
      

      ERRVALUE EndGroup (
         GRE::GROUP* gp
         );

      ERRVALUE StartLayer (
         const MIUNICODE* layername,
         bool bIsRaster,
         GRE::LAYER* lp
         );

      ERRVALUE StartLayer (
         GRE::LAYER* lp
         );

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

      void SetForIllustrator ( 
         bool unscaled 
         ) { m_bForIllustrator = unscaled;}

      void SetEventsForWebClient ( 
         bool webscript 
         ) { m_bWebClient = webscript;}

      void EmbedWithNameSpacePrefix ( 
         const MISTRING& prefix
         ) { 
         nsPrefix.Clear();
         nsPrefix<<prefix<<":"; 
         m_bHTMLwrap = true; 
         }

      void SetSelfValidate (
         bool validate
         ) { m_bSelfValidate = validate;}

      void DoHighPrecisionLines (
         bool usedoubles
         ) {m_bDoFloat = usedoubles;}

      void SetResolution ( 
         UINT32 resolution
         ) { m_vres = m_hres = resolution; }

      void UseGZIP (  
         bool gzip
         ) { m_bGzip = gzip; }

      void LinkStylesheet ( 
         bool link
         ) { m_bExternalStyles = link; }

      void UseInlineStyles (  
         bool inlines
         ) { m_bInlineStyles = inlines; }

      void ShowCoordinates (  
         bool show
         ) { m_bIncludeShowCoordScript = show; }

      void IncludeLayerControls (  
         bool include
         ) { m_bIncludeLayerCtrlScript = include; }

      void SetIncludeMeasurementTools (
         bool include
         ) { m_bIncludeMeasurementScript = include; }

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

      void EmbedImages (
         bool embed
         ) { m_bEmbedImages = embed; }

      void SetLinkToScripts (
         bool link
         ) { m_bExternalScripts = link; }

      void LinkExternalStyleSheet (
         bool external
         ) { m_bExternalStyles = external; }

      void SetUsePNG ( 
         bool usepngs 
         ) {   m_bUsingPNG = usepngs;}

      void SetJPEGQuality (
         int quality 
         ) { m_JPEGQuality = quality;}

      void SetDisplayToView (
         const MAT3X3 matrix
         );

      void SetShowDatatips (
         bool show, 
         bool blink,
         bool invert
         ) { 
         m_bIncludeDatatipScript = show; 
         m_bBlinkHighlight = blink;
         m_bUseInverseHighlights = invert;
         }

      void SetUseLayerControlPanel (
         bool usepanel
         ) { m_bIncludeLayerCtrlPanel = usepanel; }

      void SetUseAdobeMenu (
         bool usemenu
         ) { m_bUseAdobeMenu = usemenu;}

      void SetDataTipOpacity (
         DOUBLE opacity
         ) { m_DataTipOpacity = opacity; }

      void SetUseFreehandMeasures (
         bool use
         ) { m_bUseFreehandMeasures = use;}

      void SetUseEntitiesInDataTips (
         bool use
         ) { m_bUseEntitiesInDataTips = use;}

      void SetHighlightColor (
         COLOR color
         ) { m_HighlightColor = color; }

      void SetSymbolEnlargement (
         DOUBLE enlargement
         ) { m_SymbolEnlargement = enlargement;}

      void SetSourceLayout (
         GRE::LAYOUT  *layout
         );
    
      MISTRING Escape ( 
         const MISTRING& str
         );

      ERRVALUE GetString ( 
         STRUTF8& str
         );

      ERRVALUE GetString ( //svg's are really UTF8
         STRUTF8* str
         );

      ERRVALUE WriteToFile ( 
         const FILEPATH& outpath,
         const STRUTF8& str,
         bool useGzip
         );

      ERRVALUE WriteToFile ( 
         const FILEPATH& outpath
         );

      bool GetClassNameFromStyAsTable (      // Returns TRUE if have className, FALSE if don't
         const ELEMTYPE type,
         RVC::DBTABLE_STYLE& TableStyle,
         INT32 ElemNum,
         const RVC::STYLE& StyleObj,
         MISTRING& className
         );

      ERRVALUE Validate (
         );

      void SetMargin ( //in units of pixels - actually svg internal coordinates
         DOUBLE margin
         ) { m_MasterMargin = margin;}

      void SetScale ( //in units of pixels - actually svg internal coordinates
         DOUBLE scale
         ) { m_MasterScale = scale;}

      void SetSymbolDirectory (
         const FILEPATH& dir
         ){ m_SymbolDirectory = dir; }

      void GetSymbolDirectory (
         FILEPATH& dir
         ){ dir = m_SymbolDirectory; }
   
      void SetUseSymbolDefinitions ( //some browsers have poor support //used for tilesets
         bool usesymbols
         ){ m_bUseSymbolDefinitions = usesymbols; }

   private:
#ifndef GENERATING_DOXYGEN_OUTPUT

      ERRVALUE Draw3DPNG ();

      virtual bool v_AvoidFillSpans () const;

      
      virtual ERRVALUE v_Clear (
         const COLOR& color
         );

      virtual bool v_UseAntiAliasing() const;
      
      virtual MGD::CAPABILITY v_GetCapabilities (
         ) const;

      virtual MGD::CONTEXT* v_CreateContext (
         );
 
      virtual MGD::PIXEL v_GetColorPixel (
         const COLOR& color
         ) ;
 
      virtual COLORSPACE v_GetColorSpace () const;

      virtual bool v_GetNeedFullImageLine () const;
 
      virtual void v_GetPixelColor (
         MGD::PIXEL pixel,
         COLOR& color
         ) const;

      int m_len;        //Lenght of current line
      double m_hres; //horizontal resolution
      double m_vres; //vertical resolution
      double m_LineWidth;
      DOUBLE m_DataTipOpacity;
      MGD::LINECAP m_LineCapStyle;
      MGD::LINEJOIN m_LineJoinStyle;
      int m_LayerNum;         // Incremented every time we start a layer 
      INT32 m_ElemNum;
      MISTRING m_DisplayToView;
      MISTRING m_ViewToGroup;
      MISTRING m_EquiToLatLonString;
      LRECTXY m_ClipRect;
      MISTRINGLIST m_ClipPaths;
      MISTRING m_ClipPath;
      FILEPATH m_SymbolDirectory;
      int m_ClipIndex;
      SVGPATTERN *m_Patterns; // Patterns this layer 
      int m_NumPatterns;
      SVGPATTERN *m_AllPatterns; // All patterns we've seen so far 
      int m_TotalPatterns;
      RVC::ELEMENT m_ActiveElement;
      MISTRINGLIST m_PatternNames;
      MILIST<SVGSTYLE> m_StyleSet;
      MISTRINGLIST m_Entities;
      MISTRINGLIST m_Defs; //like entitities but used for def blocks
      INT32 m_CurrentDefs;
      SVGLAYER m_SVGGroup; 

      bool m_bHasElements;
      bool m_bNeedsInit;
      bool m_bNoMessages;
      bool m_bForIllustrator;
      bool m_bExternalStyles;
      bool m_bExternalScripts;

      bool m_bStyleDefine;
      bool m_bScriptDefine;
      bool m_bClipDefine;

      bool m_bBeginningLayer;
      bool m_bBeginningGroup;
      bool m_bSingleLayerGroup;
      bool m_bInLayer;
      bool m_bInGroup;
      bool m_bInImage;
      bool m_bDisableStyles; //draw it sans style dont call activate GC etc.
      bool m_bRendering3DImage;
      bool m_bGroupIs3D;
      bool m_bProjNotFound;
      bool m_bLatLon;
      bool m_bStylesAreDefined;
      bool m_bEmbedFonts;
      bool m_bEmbedImages; //whether to embed images.
      bool m_bGzip; //whether to gzip
      bool m_bInlineStyles; //whether to inline the styles
      bool m_bStandardCompression;
      bool m_bIncludeLayerCtrlScript;
      bool m_bUseAdobeMenu;
      bool m_bIncludeLayerCtrlPanel;
      bool m_bIncludeShowCoordScript;
      bool m_bIncludeDatatipScript;
      bool m_bClickToShowData;
      bool m_bIncludeMeasurementScript;
      bool m_bUseFreehandMeasures;
      bool m_bUseEntitiesInDataTips;
      bool m_bUseInverseHighlights;
      bool m_bHighlightEnlargePointSymbol;
      bool m_bBlinkHighlight;
      bool m_bHTMLwrap;
      bool m_bClipBounds;
      bool m_bInTextBlock;
      bool m_bClippingOn;
      bool m_bCurLayerIsRaster;
      bool m_bColorIsVariable;
      bool m_bDoFill; // used by ActivateGC if false only set/create line style
      bool m_bDrawingFillPattern;
      bool m_bDrawingDataTip;
      bool m_bDoBorder;
      bool m_bUsingPNG;
      bool m_bForcePNG;
      bool m_bCoordsFound;
      bool m_bWebClient; //whether to include client server communication
      bool m_bDoFloat;
      bool m_bDoTitles;
      bool m_bSelfValidate;
      bool m_bUseStyledDataTips;
      bool m_bUseSymbolDefinitions;

      COLOR m_DrawColor;
      COLOR m_FillColor;
      COLOR m_HighlightColor;
      double m_Opacity;
      bool m_bClosed;
      
      png_struct_def *png_ptr;
      png_info_struct *info_ptr;
      JPEGEXT_FILE* m_pJPEGFile;

      MISTRING m_TextStyle,m_FontName;
      double m_BaseAngle;
      DPOINT2D m_BasePoint;

      int m_JPEGQuality;

      int m_TextCurveIndex;   // used to create a uniqueid for each textPath
      int m_CurFillPattern;   // Pattern currently active (-1) if none
      double m_ImageX, m_ImageY;
      int m_ImageLins, m_ImageCols; // For error checking on PutImageSpan 
      INT32 m_ImageSize; // for error checking on 3D image rendering
      int m_ImageLinsSeen;

      FILE_RAW m_PatternFile;
      FILE_RAW m_OutputFile;
      FILE_RAW m_StyleFile;
      FILE_RAW m_ScriptFile;
      FILE_RAW m_ActiveFile;
      FILE_RAW m_ZippedFile;

      int m_ImageFileIndex;
      FILE_LEGACY_STREAM m_ImageFile;
      MISTRING m_FilePrefix;

      FILEPATH m_OutputFilename;
      FILEPATH m_ImageFilename;

      INT32 m_StyleStartOffset;
      INT32 m_PatternStartOffset;

      int m_PngIndex;
      int m_CurrentStyle;
      int m_CurrentEntity;
      int m_CurrentGroupID;

      
      MILIST<SVGSYMBOL> m_Symbols;
      MILIST<SVGFILTER> m_Filters;
      MISTRINGLIST m_LayerNames;
      MILIST<SVGLAYER> m_SVGLayers;
      MISTRINGLIST m_Fonts;
      SIMPLE_ARRAY<UINT32> m_GroupChildren;

      //--------------------------------
      SIMPLE_ARRAY<UINT8> m_3DimageBuffer;
      DRECT2D m_GroupExtents;
      //--------------------------------

      MISTRING nsPrefix; // used to allow prefix mixed namespace svg's
      MISTRING m_LayerName;
      MISTRING m_GroupName;
      MISTRING m_DataTip;
      
      
      MISTRING m_LastFont;
      GRE::LAYER* m_Layer;
      SVGSYMBOL m_ActiveSymbol;
      SVGFILTER m_ActiveFilter;
      int m_SymbolNum,m_CurrentSymbol;
      INT32 m_CurrElem;
      INT32 m_CurrentDataTip;

      bool m_HasEquiToLatLon;
      TRANS2D_AFFINE m_EquiToLatLon;
      MISTRING m_GeoTransformStr;

      bool m_bDrawingSymbol;
      bool m_bInDefinition;
      bool m_bGzipping; //present state i am gzipping

      double vScale, hScale, vOffset, hOffset;

 
      //These stored as strings so that it can be passed
      //back as a string or validated using xml library
      //xml parse is too slow however. Using the library 
      // more extensively so it isnt parsed after the fact.

      MISTRING m_Projname;
      MISTRING m_SVG; // svg code before the entity description eventually stores all.
      MISTRING m_EntitiesString; //entities stored in output form.
      MISTRING m_Head; //code between entities and stylesheet
      MISTRING m_StyleSheet; //css styles compiled
      MISTRING m_Body; //code after styles  
      MISTRING m_Script; // stores script chunks
      DOUBLE panelLeft; //used for offsetting main map and control panel
      DOUBLE m_SymbolEnlargement;

      MISTRING m_ElementClassName; //stores stylename appropriate for currently rendering element

      RVC::DBASE_POLYGON m_DbObjPolygon;
      RVC::STYLE m_StyleObjPolygon; 
      RVC::DBTABLE_STYLE m_TableStylePolygon;

      RVC::DBASE_LINE m_DbObjLine;
      RVC::STYLE m_StyleObjLine; 
      RVC::DBTABLE_STYLE m_TableStyleLine;

      RVC::DBASE_POINT m_DbObjPoint;
      RVC::STYLE m_StyleObjPoint;   
      RVC::DBTABLE_STYLE m_TableStylePoint; 

      RVC::DBTABLE::RECORD_STYLE_ELEMENT m_RecordStyle;

      DOUBLE m_MasterMargin;
      DOUBLE m_MasterScale;
      MISTRING m_ElemTitle;
      
      //int (*m_ColorBalanceTranslate) (PRDATA *prdata, UINT8 *buf, int cols, int ColorsIn, int ColorsOut, UINT32 flags);
      // copy constructor private and unimplemented
      DEVICE_SVG (const DEVICE_SVG&);
 

      ERRVALUE AppendFile ( //uses SendString and PortWrite to control compression
         const FILEPATH& filename,
         bool b_encode64
         );

      ERRVALUE ActivateGC (
         MGD::CONTEXT_SVG* gc
         );

      
      MISTRING ActivateTC (
         MGD::CONTEXT_SVG* gc
         );

      ERRVALUE StartClipping (
         MGD::CONTEXT_SVG* gc
         );

      void IncCurveIndex() {
         m_TextCurveIndex++;
         }

      int GetCurveIndex() {
         return m_TextCurveIndex;
         };

      int FindCurrentStyle (
         const MISTRING& code,
         MISTRING& className
         );

      int FindEntity ( 
         const MISTRING& code
         );

      #ifndef NOLIBZ
       z_stream m_zstream;
      #endif
   
      UINT32 m_crc;
      UINT8 m_zbuf[32768];
      UINT32 m_filter;

      int CompressBegin (
         );

      int CompressEnd (
         );

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

      int DumpFillPattern (
         SVGPATTERN *pat,
         const RVC::STYLEPATTERN_BITMAP& BitmapPatt,
         COLOR *var,  // Variable color 
         MISTRING& name
         );


      int DumpFillPatternLayer (
         const RVC::STYLEPATTERN_BITMAP& BitmapPatt,
         int c,            // Color number 
         const COLOR& color      // RGB value of color
         );
      
      MISTRING Encode64 (
         const UINT8* buff, 
         int len
         );

      void FreePrivateData();
          
      int AddClippingPath (
         MGD::CONTEXT_SVG* gc,
         const MISTRING& region
         ) ;

      //checks to see if the shadow filter is in the list,(else outputs it and)
      //also assigns the defined filter to be the active one.
      //should be done before an activateTC but not inside an object

      INT32 FilterInList (
         double x,
         double y,
         const COLOR& color,
         double opacity,
         double height
         );

      DOUBLE GetGreatestCommonDivisor ( 
         DOUBLE a,
         DOUBLE b
         );

      DOUBLE GetLeastCommonMultiple ( 
         DOUBLE a,
         DOUBLE b
         );

      ERRVALUE InsertFile (
         FILE_RAW& file1,
         FILE_RAW& file2,
         UINT32 offset
         );

      bool IsLatLon (
         SPATREF::COORDREFSYS CoordRefSys
         );

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

      int SendEOL (
         );

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

      int WriteString (
         const MISTRING& str
         );

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

      int SendLong (
         INT32 num
         );

      int SendDouble (
         DOUBLE num
         );

      int SendGroupHeader ( 
         MGD::CONTEXT_SVG* gc,
         bool isGroup,
         const MISTRING& name
         );

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

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

      ERRVALUE SetFillPattern (
         MGD::CONTEXT_SVG* gc
         );
      
      //tests to see of the symbol is already defined 
      //and if it is returns its index else -1
      INT32 SymbolInList (
         INT32 symnum,
         bool builtin
         );

      //mostly superfulous with an svg integer coordinate system.
      void TransCoord ( 
         INT32 x, 
         INT32 y, 
         double *dx, 
         double *dy
         ) {
         *dx = (double)x; 
         *dy = (double)y;
         return;
         } 

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

      int z_put (
         int x
         );

      int putByte ( 
         int x
         );

      // Searches the list of fonts and writes the font 
      // to the style file only if it isnt already in the list
      ERRVALUE AddFontToList (
         const MISTRING& fontfam,
         const MISTRING& fontname
         );


#endif // GENERATING_DOXYGEN_OUTPUT
      friend class MGD::CONTEXT_SVG;

   };


class CONTEXT_SVG : public MGD::CONTEXT {
   public:

      ~CONTEXT_SVG (
         ) {}

   
      void AddImageViaLink ( 
         const MISTRING& url, 
         const DRECT2D& extents 
         );

#ifndef GENERATING_DOXYGEN_OUTPUT

   protected: 

      CONTEXT_SVG (
         MGD::DEVICE_SVG* dev
         ) :
         MGD::CONTEXT(dev),
         m_DevSVG(dev),
         m_bHasClip(false),
         m_bNewClipRegion(false),
         m_bDoDash(false),
         m_ActiveClip(-1)  
         {
         }

   private:
      virtual void v_SetColorIsPatternVariable (
         bool value
         );

      virtual void v_UpdateColor (
         );
 
      virtual void v_UpdateColor2 (
         const COLOR& color
         );

      ERRVALUE DrawLinesThick (
         const LPOINT2D *lpoints,
         INT32 NumPoints
         );

      ERRVALUE DrawLinesThin(
         const LPOINT2D *lpoints,
         INT32 NumPoints
         );

      ERRVALUE Initialize3DImage ();

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

      virtual void v_UpdateClipRegion (
         );

      virtual void v_UpdateClipNone (
         );

      virtual void v_UpdateClipRect (
         );

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

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

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

      virtual ERRVALUE v_FillArc (
         INT32 xcenter,
         INT32 ycenter,
         INT32 xradius,
         INT32 yradius,
         double sangle,             /* Starting angle in RADIANS */
         double eangle,             /* Ending angle in RADIANS */
         double rotangle,           /* Rotation angle in RADIANS */
         MGD::SHAPECLOSE closemode
         );
      
      virtual ERRVALUE v_DrawCircle (
         INT32 x,
         INT32 y,
         INT32 radius
         );


      virtual ERRVALUE v_DrawEllipse (
         INT32 xcenter,                      // X coordinate of center of arc
         INT32 ycenter,                      // Y coordinate of center of arc
         INT32 xradius,                      // X radius of ellipse (BEFORE ROTATION)
         INT32 yradius,                      // Y radius of ellipse (BEFORE ROTATION)
         double rotangle = 0                    // Rotation angle in RADIANS
         );

      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_DrawGlyph (
         MGD::FONT* font,
         double x,
         double y, 
         double baseangle,
         const MGD::STRINGDATA& gidstr,
         int num
         );

      virtual ERRVALUE v_DrawLinesLow (
         const LPOINT2D *lpoint,
         INT32 NumPoints
         ); 

      virtual ERRVALUE v_DrawLinesLow (
         const POLYLINE& line
         );
 
      virtual ERRVALUE v_DrawLinesDashed (
         const LPOINT2D* points,             // Point array
         INT32 numpoints,
         const double *DashArray,
         INT32 DashCount,
         double DashOffset = 0.0,                  // Start of first dash.
         bool close = false                  // Force closed polygon if true (Not very effecient)
         );
 
      virtual ERRVALUE v_DrawPoint (
         INT32 x,
         INT32 y
         );

      virtual ERRVALUE v_DrawPoint (
         const DPOINT2D& pt
         );

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

      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_FillCircle (
         INT32 x,
         INT32 y,
         INT32 radius
         );

      virtual ERRVALUE v_FillCircle (
         double x,
         double y,
         double radius
         );

      virtual ERRVALUE v_FillEllipse (
         INT32 xcenter,                      // X coordinate of center of arc
         INT32 ycenter,                      // Y coordinate of center of arc
         INT32 xradius,                      // X radius of ellipse (BEFORE ROTATION)
         INT32 yradius,                      // Y radius of ellipse (BEFORE ROTATION)
         double rotangle = 0                    // Rotation angle in RADIANS
         );

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

      virtual ERRVALUE v_FillPolygons (
         const LPOLYGON *lpolygons,
         INT32 NumPolys,
         bool bDrawBorder
         );
/*
       
      virtual ERRVALUE v_FillSubRegion (
         const SUBREGION2D& polygons,
         bool DrawOutline
         ); 

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

      virtual ERRVALUE v_ImageBegin (
         INT32 x,
         INT32 y,
         INT32 cols,
         INT32 lins,
         COLORSPACE ColorSpace,
         const COLOR_ARRAY *colmap,
         UINT32 flags
         );

      virtual ERRVALUE v_ImageEnd (
         UINT32 flags
         ); 
         
      virtual ERRVALUE v_PutImageSpanDirect (
         INT32 x,
         INT32 y,
         INT32 len,
         const void *data,
         const UINT8 *mask
         );
 
      virtual ERRVALUE v_PutPixel (
         INT32 x,
         INT32 y,
         MGD::PIXEL pixel
         ); 
 
      virtual void v_SymbolBegin ();

      virtual void v_SymbolEnd ();

      virtual void v_TextSpanBegin ();


      virtual void v_TextSpanEnd ();

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


      virtual void v_TextBlockEnd (
         const MGD::TEXTBLOCK& block   
         );
      
      bool m_bHasClip;
      bool m_bNewClipRegion;
      bool m_bDoDash;
      COLOR m_DrawColor;
      COLOR m_FillColor;
      COLOR m_SymbolColor;
      MGD::DEVICE_SVG* m_DevSVG;
      MISTRING m_Style, m_LineStyleCode, m_ActiveFill, m_DashArray;
      int m_ActiveClip;
      double m_TextHeight;
      friend class MGD::DEVICE_SVG;

      ERRVALUE BuildDataTipDef (
         const MISTRING& tip
         );

      ERRVALUE DrawLineBody ( //actually implements DrawLine in svg.
         double x1,
         double y1,
         double x2,
         double y2
         );

      ERRVALUE HatchPatch (  
         const RVC::STYLEPATTERN_HATCH::ELEMENT_SHARED& Element,
         const RVC::STYLEPATTERN_HATCH& HatchPatt,
         const DRECT2D& rect
         );

      ERRVALUE  InsertDataTip (
         const MISTRING& tip
         );

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

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

      ERRVALUE FillClipSubRegion (
         const SUBREGION2D& subregion
         );

      ERRVALUE FillClipRegion (
         const REGION2D& region
         );

      int FindDefs (
         const MISTRING& defs
         );

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

      ERRVALUE ComposeLinesFloat (
         const POLYLINE& line
         );

      ERRVALUE Prepare3DImage (
         );

      };

#endif // GENERATING_DOXYGEN_OUTPUT
}



#endif //end define INC_MI32_MG2SVG_H

---