mi32/mg2kml.h

Go to the documentation of this file.

/*****************************************************************************
 *
 * \file mi32/mg2kml.h
 * \brief KML declarations for context ... device 
 *
 * $Log: mg2kml.h_v $
 * Revision 1.56  2012/03/22 20:32:38  ldyas
 * added method for setting symbol directory on svg
 *
 * Revision 1.55  2012/01/26 22:15:36  ldyas
 * added symbol  information variables to device
 *
 * Revision 1.54  2012/01/06 21:44:28  mju
 * Remove mstatus (legacy) hdr.
 *
 * Revision 1.53  2011/12/27 13:33:06  mju
 * Change parm type for drawPNG.
 *
 * Revision 1.52  2011/12/23 18:18:03  ldyas
 * adjusting to accept symbol directory
 *
 * Revision 1.51  2011/12/21 22:13:54  bcolombe
 * Add public method to return placemarkindex
 *
 * Revision 1.50  2011/07/01 16:29:13  ldyas
 * added setting of datatip img tag width
 *
 * Revision 1.49  2011/06/10 19:43:41  ldyas
 * store angle in kmlsymbol
 *
 * Revision 1.48  2011/06/06 21:01:43  ldyas
 * drawing builtin symbols and colors.
 *
 * Revision 1.47  2011/06/06 19:54:27  ldyas
 * setcolorizesymbols
 *
 * Revision 1.46  2011/06/06 14:25:20  ldyas
 * added method to control rendering of built in symbols.
 *
 * Revision 1.44  2011/05/26 21:49:40  ldyas
 * added line scale setting methods
 *
 * Revision 1.43  2011/04/26 16:37:22  ldyas
 * make pngname param constant
 *
 * Revision 1.42  2011/04/26 15:16:53  ldyas
 * added param to store name of icon
 *
 * Revision 1.41  2011/04/13 19:15:08  ldyas
 * added layernum to kml symbol
 *
 * Revision 1.40  2010/08/30 17:42:28  ldyas
 * added description
 *
 * Revision 1.38  2008/12/04 17:20:24  ldyas
 * added boolean show labels
 *
 * Revision 1.37  2008/11/20 20:45:36  ldyas
 * add screen overlay now with visibility passing.
 *
 * Revision 1.36  2008/11/06 21:38:46  ldyas
 * added size param to adding screen overlay.
 *
 * Revision 1.35  2008/06/30 15:15:13  ldyas
 * *** empty log message ***
 *
 * Revision 1.34  2008/06/10 20:45:15  ldyas
 * added reference index for view.
 *
 * Revision 1.33  2008/03/04 16:00:26  ldyas
 * device needs to know wms/arcims layers are dynamic do not render normally
 *
 * Revision 1.32  2008/02/23 00:12:42  ldyas
 * added has variable color to kml symbol .
 *
 * Revision 1.31  2008/02/11 18:03:40  ldyas
 * added scale control.
 *
 * Revision 1.30  2007/12/31 21:34:14  ldyas
 * added add network link.
 *
 * Revision 1.29  2007/11/13 16:08:28  ldyas
 * *** empty log message ***
 *
 * Revision 1.28  2007/11/13 15:50:43  ldyas
 * finishing that ..
 *
 * Revision 1.27  2007/11/13 15:40:40  ldyas
 * removing old status context usage.
 *
 * Revision 1.26  2007/11/07 21:09:30  ldyas
 * added add screen overlay
 *
 * Revision 1.25  2007/09/10 18:00:59  ldyas
 * nc.
 *
 * Revision 1.24  2007/09/07 15:28:17  ldyas
 * added color to kmlsymbol
 *
 * Revision 1.23  2007/09/06 15:34:53  ldyas
 * Initial code for point symbols as pngs.
 *
 * Revision 1.22  2007/08/24 21:35:55  ldyas
 * added method for adding dynamic wms layers.
 *
 * Revision 1.21  2007/07/09 16:15:55  ldyas
 * added m_digits to track decimal places of output.
 *
 * Revision 1.20  2007/06/29 19:02:33  ldyas
 * nc.
 *
 * Revision 1.19  2007/06/21 19:24:03  ldyas
 * added methods for handling viewpoint3ds for lookat points.
 *
 * Revision 1.18  2007/06/13 16:04:56  ldyas
 * overriding circle and arc methods.
 *
 * Revision 1.17  2007/06/11 16:46:09  ldyas
 * added DRECT2D version of fill rectangle.
 *
 * Revision 1.16  2007/06/11 15:36:42  ldyas
 * compress added.
 *
 * Revision 1.15  2007/06/01 23:35:22  ldyas
 * nc
 *
 * Revision 1.14  2007/05/21 17:17:08  ldyas
 * added variables for reordering groups to match.
 *
 * Revision 1.13  2007/05/19 00:19:15  ldyas
 * added setTitle
 *
 * Revision 1.12  2007/05/18 21:47:48  ldyas
 * added image count for linked image naming.
 *
 * Revision 1.11  2007/05/17 19:35:21  ldyas
 * added variables for storying geometry count to minimize multigeometries.
 *
 * Revision 1.10  2007/05/15 22:23:39  ldyas
 * added a variable to track draw order etc.
 *
 * Revision 1.9  2007/05/07 14:23:03  mju
 * Use mistringlist hdr.
 *
 * Revision 1.8  2007/05/04 19:28:32  ldyas
 * removed unnecessary members .
 *
 * Revision 1.7  2007/05/02 18:40:58  ldyas
 * giving EndLayer a parameter to enable forcing.
 *
 * Revision 1.6  2007/05/02 18:37:13  ldyas
 * added bool for layers having content to enable excluding empty layers.
 *
 * Revision 1.5  2007/05/02 15:50:06  ldyas
 * added boolean for tracking whether to end a layer.
 *
 * Revision 1.4  2007/04/30 14:28:36  ldyas
 * added activeTip and tipname to allow delaid use of data tip information .
 *
 * Revision 1.3  2007/03/22 22:52:33  ldyas
 * adjusted write to file to to not include finish code if from a string.
 *
 * Revision 1.2  2007/01/24 16:47:40  ldyas
 * *** empty log message ***
 *
 * Revision 1.1  2007/01/18 21:07:06  ldyas
 * Initial revision
 *
 */

#ifndef INC_MI32_MG2KML_H
#define INC_MI32_MG2KML_H

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

#ifndef  INC_MI32_FILEPATH_H
#include <mi32/filepath.h>
#endif

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

#ifndef INC_RVC_ELEMENT_H
#include <rvc/element.h>
#endif

#ifndef INC_MI32_TRANS2DC_H
#include <mi32/trans2dc.h>
#endif

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

#ifndef IN_MI32_FILELEGACY_H
#include <mi32/filelegacy.h>
#endif

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


#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward declarations.
class REGION2D;
class SUBREGION2D;
class KML;
class JPEGEXT_FILE;
struct png_struct_def;
struct png_info_struct;
namespace GRE {
   class LAYER;
   class GROUP;
   class LAYOUT;
   }
namespace RVC {
   class STYLEPATTERN_BITMAP;
   }

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

#endif // GENERATING_DOXYGEN_OUTPUT


#ifndef GENERATING_DOXYGEN_OUTPUT
class KMLPATTERN {
   public:

      KMLPATTERN ();

      ~KMLPATTERN ();

      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 */
      KMLPATTERN *m_alias;    /* Points to identical pattern from previous layer in AllPatterns */
   };

#endif // GENERATING_DOXYGEN_OUTPUT


namespace MGD {

#ifndef GENERATING_DOXYGEN_OUTPUT
class CONTEXT_KML;
#endif // GENERATING_DOXYGEN_OUTPUT

class DEVICE_KML : public MGD::DEVICE {

   public:

      DEVICE_KML ();

      virtual ~DEVICE_KML();

      
      void InitializeDevice (
         UINT32 height,
         UINT32 width
         );

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

      void AddScreenOverlay( //<! jpeg or png or tiff or bmp or otherwise.
         const MISTRING& url,
         const DPOINT2D& upperleft, 
         const MISTRING& layername,  //<! the name this layer should show as in legend.
         const DPOINT2D& size, //<! screen fraction size
         const bool visible = true
         );

      // append to list of viewpoints in kml 
      // if only one is added it will be the startup view. 
      void AddViewPoint( 
         const GRE::VIEWPOINT3D *viewpt,
         const MISTRING& name
         );

      void AddNetworkLink ( //<! jpeg or png or tiff or bmp or otherwise.
         const MISTRING& url,
         const DRECT3D& extents,
         const MISTRING& layername  //<! the name this layer should show as in legend.
         );

      void AddWMSOverlay( //<! jpeg or png or tiff or bmp or otherwise.
         const MISTRING& url,
         const DRECT3D& extents, 
         const MISTRING& layername  //<! the name this layer should show as in legend.
         );


      ERRVALUE EndLayer (
         bool force = false
         );
 
      ERRVALUE BeginGroup (
         GRE::GROUP* gp
         );
      
      ERRVALUE EndGroup (
         GRE::GROUP* gp
         );

      ERRVALUE EndGroup (
         );

      ERRVALUE Compress (
         const FILEPATH& path,
         int rate = 9
         );

      ERRVALUE EndElement (
         );

       void EndMultiGeometry (
         );

       void EndPlacemark (
         );

      MISTRING Escape ( 
         const MISTRING& str
         );

      int GetPlacemarkCount() {return m_PlacemarkIndex;}

      ERRVALUE GetString ( 
         STRUTF8& str
         );

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

      ERRVALUE InitializeImage ( 
         INT32 h,
         INT32 w,
         DPOINT2D ul
         );

      void SetAccuracy ( 
         DOUBLE accuracy
         ); 

      void SetColorizeSymbols ( 
         bool colorize
         ){
         m_bColorizeSymbols = colorize;
         }
      void SetDrawingScreenOverlay (
         bool overlay
         );

      void SetLineScale ( 
         double scale
         ) { m_LineScale = scale; }

      void SetMarkerSize ( 
         int size
         ) { m_MarkerSize = size; }

      void SetMarkerScale ( 
         double scale
         ) { m_MarkerScale = scale; }

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

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

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

      void SetDataTipImgTagWidth (
         int width 
         ) { m_DataTipImgTagWidth = width;}

      void SetMakeBuiltInSymbols ( 
         bool makebuiltins 
         ) {   m_bGenerateBuiltInSymbols = makebuiltins;}


      void SetMinimumLineWidth ( 
         DOUBLE width
         ){ m_MinimumLineWidth = width; }

      void SetUseDynamicWMS(
         bool useDynamic
         ){
         m_bDynamicWMS = useDynamic;
         };

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


      void SetSourceLayout (
         GRE::LAYOUT  *layout
         );
      
      void SetViewPoint( // use this viewpoint as the start up view.
         const GRE::VIEWPOINT3D *viewpt,
         const MISTRING& name
         );

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

      ERRVALUE StartLayer (
         GRE::LAYER* lp
         );

      ERRVALUE StartElement (
         GRE::LAYER* lp,
         const RVC::ELEMENT &element
         );
    
      void UseGZIP (  
         bool gzip
         ) { m_bGzip = gzip; }


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

      ERRVALUE WriteToFile ( 
         const FILEPATH& outpath,
         bool finish = true 
         );

      
      ERRVALUE Validate (
         );

      void SetTrans (
         TRANS2D_MAPGEN trans
         ) {
         GeoTrans = trans;
         }

      ERRVALUE TransForward (
         const DRECT2D& rect1,
         DRECT2D& rect2
         );

      ERRVALUE TransForward (
         const DPOINT2D& pt1,
         DPOINT2D& pt2
         );

      ERRVALUE TransForward (
         const POLYLINE& linein,
         POLYLINE& lineout
         );

     
      void SetTitle (
         const MISTRING& title
         );

      void SetDescription (
         const MISTRING& desc
         );

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

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

      void GetSymbolDirectory (
         FILEPATH& dir
         ){ dir = m_SymbolDirectory; }

      void SetCanvasSize(
         DPOINT2D size
         ){ m_Size = size; }

      TRANS2D_MAPGEN GeoTrans;

      class IMAGEDATA {
         public:
            IMAGEDATA();
            IMAGEDATA(FILEPATH& path, MISTRING& name){
               m_path = path;
               m_name = name;
               };
            ~IMAGEDATA() {}
            FILEPATH GetPath() {return m_path;}
            void SetPath(const FILEPATH& path) {m_path = path;}
            MISTRING GetName() {return m_name; }
            void SetName(const MISTRING& name) {m_name = name;} 
         private:
            FILEPATH m_path;
            MISTRING m_name;
         };

      class KMLSYMBOL {
         public:
            KMLSYMBOL ();
            KMLSYMBOL (UINT32 index, INT32 b, COLOR micolor, bool var, INT32 layer, const MISTRING& pngname, INT32 symangle){
               number = index;
               built = b;
               color = micolor;
               hasVariableColor = var;
               layernum = layer;
               name = pngname;
               angle = symangle;
               };
            ~KMLSYMBOL() {};
            INT32 number;
            INT32 built;
            INT32 angle;
            COLOR color;
            bool hasVariableColor;
            INT32 layernum;
            MISTRING name;
            FILEPATH path;
            };

   private:
#ifndef GENERATING_DOXYGEN_OUTPUT

      ERRVALUE DrawPNG (
         MISTRING& name, //returned
         INT32 number = -1,
         double angle = 0
         );

      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;

      MISTRING CreateViewPointString ( 
            const GRE::VIEWPOINT3D *viewpt
            );

      int m_len;        //Lenght of current line
      int m_digits; 
      DOUBLE m_hres; //horizontal resolution
      DOUBLE m_vres; //vertical resolution
      DOUBLE m_accuracy;
      DOUBLE m_DataTipOpacity;
      MGD::LINECAP m_LineCapStyle;
      MGD::LINEJOIN m_LineJoinStyle;
      int m_LayerNum;         // Incremented every time we start a layer 
      INT32 m_ElemNum;
      RVC::ELEMENT m_ActiveElement;
      DOUBLE m_MinimumLineWidth;
      //MISTRINGLIST m_StyleSet;

   // MISTRINGLIST m_Defs; //like entitities but used for def blocks
      INT32 m_CurrentDefs;
      KMLLAYER m_KMLGroup; 

      bool m_bHasValid;
      bool m_bNeedsInit;
      bool m_bNoMessages;
       bool m_bDrawingScreenOverlay;
      bool m_bExternalStyles;

      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
      bool m_bRenderingImage;
      bool m_bGroupIs3D;
      bool m_bProjNotFound;
      bool m_bLatLon;
      bool m_bStylesAreDefined;
      bool m_bEmbedFonts;
      bool m_bGzip; //whether to gzip
      bool m_bDynamicWMS;
      bool m_bInlineStyles; //whether to inline the styles
      bool m_bInTextBlock;
      bool m_bCurLayerIsRaster;
      bool m_bColorIsVariable;

      bool m_bDoBorder;
      bool m_bUsingPNG;
      bool m_bForcePNG;
      bool m_bCoordsFound;
      bool m_bDoTitles;
      bool m_bSelfValidate;

      COLOR m_DrawColor;
      COLOR m_FillColor;
      COLOR m_HighlightColor;
      double m_Opacity;
      bool m_bClosed;
      bool m_bShowLabels; //layer by layer allows turning the label display off when its off in the layer while still having sidebar entries 
      
      png_struct_def *png_ptr;
      png_info_struct *info_ptr;
      JPEGEXT_FILE* m_pJPEGFile;

      MISTRING m_TextStyle,m_FontName;
      MISTRING m_Title;
      MISTRING m_Description;
      double m_BaseAngle;
      DPOINT2D m_BasePoint;

      int m_MarkerSize;
      double m_MarkerScale;

      int m_JPEGQuality;
      int m_ImageX, m_ImageY, m_ImageLins, m_ImageCols;  // For error checking on PutImageSpan 
      INT32 m_ImageSize; // for error checking on symbol image rendering
      int m_ImageLinsSeen;
      int m_reference;
      

      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_CurrentGroupID;
      int m_PlacemarkIndex;
      
      MISTRINGLIST m_LayerNames;
      MILIST<KMLLAYER> m_KMLLayers;
      //--------------------------------
   
      DRECT2D m_GroupExtents;
      //--------------------------------

      MISTRING m_LayerName;
      MISTRING m_GroupName;
      GRE::LAYER* m_Layer;
      GRE::GROUP* m_Group;
      INT32 m_CurrentDataTip;
      bool m_bDrawingSymbol;
      bool m_bInSymbol;
      MISTRING m_ActiveSymbol;
      int m_SymbolNum, m_CurrentSymbol;
            
      bool m_bInDefinition;
      bool m_bInPlacemark;
      bool m_bInMultiGeometry;
      bool m_IgnoreEndLayer;
      bool m_LayerHasContent;
 
      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_KML;
      MISTRING m_Head; //code between entities and stylesheet

      MISTRINGLIST m_ViewPoints;
      MISTRINGLIST m_ViewPointNames;

      MISTRING m_StyleSheet;
      MISTRING m_PathStyle, m_PlaceStyle, m_AreaStyle;
   
      MISTRING m_ActiveTip;
      MISTRING m_TipName;
      MISTRING m_Geometry;
      INT32 m_GeomCount;
      INT32 m_ImageCount;
   
      MISTRING m_Placemark; // placemark currently being created.
      MISTRING m_LayerBody; 
      MISTRING m_GroupBody;
      MISTRING m_BodyStr;   

      SIMPLE_ARRAY<UINT8> m_imageBuffer;
      MILIST<IMAGEDATA> m_ResultImages;
      MILIST<KMLSYMBOL> m_Symbols;



      double m_LineScale;
      bool m_bGenerateBuiltInSymbols;
      bool m_bColorizeSymbols;
      int m_DataTipImgTagWidth;
      FILEPATH m_SymbolDirectory;
      COLOR m_SymbolColor;

      INT32 m_HotSpotX; //current symbol being rendered 
      INT32 m_HotSpotY;
      INT32 m_SymbolSizeX;
      INT32 m_SymbolSizeY;

      DRECT2D m_Size;

      //int (*m_ColorBalanceTranslate) (PRDATA *prdata, UINT8 *buf, int cols, int ColorsIn, int ColorsOut, UINT32 flags);
      // copy constructor private and unimplemented
      DEVICE_KML (const DEVICE_KML&);
 

      int FindCurrentStyle (
         const MISTRING& code
         );

      UINT32 m_crc;
      UINT32 m_filter;

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

      //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

      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 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_KML* gc
         );
      
      //tests to see of the symbol is already defined 
      //and if it is returns its index else -1
      INT32 FindSymbol (
         INT32 symnum,
         INT32 builtin
         );

      //mostly superfulous with an kml 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_KML;

   };


class CONTEXT_KML : public MGD::CONTEXT {
   public:

      ~CONTEXT_KML (
         ) {}
   
      void AddGroundOverlay ( 
         const MISTRING& url, 
         const DRECT2D& extents, 
         const MISTRING& name
         );

#ifndef GENERATING_DOXYGEN_OUTPUT

   protected: 

      CONTEXT_KML (
         MGD::DEVICE_KML* dev
         ) :
         MGD::CONTEXT(dev),
         m_DevKML(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
         );

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

      virtual void v_UpdateClipRegion (
         );

      virtual void v_UpdateClipNone (
         );

      virtual void v_UpdateClipRect (
         );

      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_FillCircle (
         double xcenter, 
         double ycenter, 
         double 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_DrawLinesLow (
         const POLYLINE& line
         );

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

      virtual ERRVALUE v_FillRectangle (
         const DRECT2D& rect
         );
 
      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 void v_SymbolBegin ();
   // virtual void v_SymbolEnd ();

      virtual ERRVALUE v_DrawPoint (
         INT32 x,
         INT32 y
         );
 
      virtual ERRVALUE v_DrawPoint (
         const DPOINT2D& pt 
         );
 
      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_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 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_KML* m_DevKML;
      MISTRING m_Style, m_LineStyleCode, m_ActiveFill, m_DashArray;
      int m_ActiveClip;
      double m_TextHeight;
      friend class MGD::DEVICE_KML;

      ERRVALUE GenArcLine (
         const DPOINT2D& center,
         double xradius,
         double yradius,
         double startangle,            // Start angle of UNROTATED arc in RADIANS
         double sweepangle,            // Sweep angle of UNROTATED arc in RADIANS
         double rotangle,              // Rotation angle in RADIANS
         POLYLINE& perimeter,
         bool bKeepExistingPoints
         );

      int FindDefs (
         const MISTRING& defs
         );

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

      ERRVALUE ComposeLinesFloat (
         const POLYLINE& line
         );

      ERRVALUE PrepareImage (
         );

      };

#endif // GENERATING_DOXYGEN_OUTPUT
}



#endif //end define INC_MI32_MG2KML_H

---