elemstyl.h

Go to the documentation of this file.

/**
 * \file mi32/elemstyl.h
 * \brief Definitions for element drawing styles
 *
 * \if NODOC
 * $Id: elemstyl.h_v 1.64 2004/11/17 15:25:37 dwilliss Exp $
 *
 * $Log: elemstyl.h_v $
 * Revision 1.64  2004/11/17 15:25:37  dwilliss
 * Changed ParseTildeCodes' return value to return true if any code was
 * recgonized rather than if any was unrecgonized.  Nothing was using the
 * return value yet anyway.
 *
 * Revision 1.63  2004/10/14 16:58:03  dwilliss
 * Added a UsesAntialiasing to text style
 *
 * Revision 1.62  2004/09/03 16:02:27  scowan
 * Removed text font name typedef.
 *
 * Revision 1.61  2004/04/08 14:57:22  scowan
 * Prevent mem cmp on text style.
 *
 * Revision 1.60  2004/04/05 20:13:26  scowan
 * Do not allow memset on multi style struct.
 *
 * Revision 1.59  2004/04/01 00:03:43  dwilliss
 * TEXTSTYLE fontname is now an MISTRING
 *
 * Revision 1.58  2004/03/30 22:32:23  dwilliss
 * Text style now completely memcpy/memset/memcmp free.  We can change
 * :w
 *
 * Revision 1.57  2004/03/17 21:21:33  scowan
 * Added a font style flag for CRS inversion for label extents.
 *
 * Revision 1.56  2003/10/03 17:37:09  dwilliss
 * *** empty log message ***
 *
 * Revision 1.55  2003/10/01 22:15:52  dwilliss
 * doxygen
 *
 * Revision 1.54  2003/10/01 20:46:18  dwilliss
 * nc
 *
 * Revision 1.53  2003/09/22 19:23:44  dwilliss
 * Changed dft ctor of TEXTSTYLEDIFF to have nothing set insetad of everyting
 *
 * Revision 1.52  2003/09/22 16:13:07  dwilliss
 * Added a method to TEXTSTYLEDIFF to parse {~} codes.  It has the ability to
 * return unknown codes in an optional parameter
 *
 * Revision 1.51  2003/09/15 13:49:56  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.50  2003/09/12 19:25:11  scowan
 * Fixed line style assignment from poly style with str dup from null value.
 *
 * Revision 1.49  2003/09/08 20:33:55  dwilliss
 * Added doxygen tags for start/end of function groups
 *
 * Revision 1.48  2003/08/12 14:50:57  mju
 * In textstyle ctor default to scale to design.
 *
 * Revision 1.47  2003/06/30 16:46:27  mju
 * Fix UMR/FIM in pointstyle::copy when called by copy ctor (init Desc).
 * Do similar init and fix leaks in line/polystyle.
 *
 * Revision 1.46  2003/06/25 20:43:54  dwilliss
 * Fixed memory leak in POINTSTYLE::Copy()
 *
 * Revision 1.45  2003/06/18 22:55:37  dwilliss
 * *** empty log message ***
 *
 * Revision 1.44  2003/06/18 22:47:17  dwilliss
 * Never mind.  Was going to add a LABELSTYLE, but decided to create a new
 * lablstyl.h to avoid include file dependancy problem
 *
 * Revision 1.43  2003/06/04 22:46:13  scowan
 * Reordered code and added a poly style to line style operator.
 *
 * Revision 1.42  2003/03/13 18:15:29  mju
 * Add BuiltIn_Point_Last.
 *
 * Revision 1.41  2003/02/07 14:34:26  mju
 * Fix Mac warning.
 *
 * Revision 1.40  2003/01/21 14:58:44  mju
 * Add STYLEFLAG_ScaleIsPatternZoom.
 *
 * Revision 1.38  2002/10/17 21:22:02  dwilliss
 * TEXTSYTYLEDIFF: more methods and operators
 *
 * Revision 1.37  2002/10/11 22:39:58  dwilliss
 * Created TEXTSTYLEDIFF and keep that stuff out of the main TEXTSTYLE
 *
 * Revision 1.35  2002/10/11 21:47:32  dwilliss
 * Added some operators to TEXTSTYLE.
 *
 * Revision 1.33  2002/10/09 22:33:03  dwilliss
 * Gave POLYSTYLE an Angle member for rotation hatch patterns.  There was a
 *
 * Revision 1.32  2002/09/09 13:28:13  mju
 * Remove deprecated typedef.
 *
 * Revision 1.31  2002/08/28 13:04:41  mju
 * Don't put ';' after prevent_memfunc as causes annoying warning on Mac.
 *
 * Revision 1.30  2002/08/21 20:39:10  scowan
 * Deprecate old object name define.
 *
 * Revision 1.28  2002/06/10 19:15:45  dwilliss
 * Don't use MmFree here
 *
 * Revision 1.27  2002/06/10 17:50:30  dwilliss
 * Added Clear methods()
 *
 * Revision 1.24  2002/05/13 22:59:02  dwilliss
 * UsesTransparency now takes an optional MGD::CONTEXT.
 * Because this file is included before mgd2 (so CONTEXT can have members
 * of the structures we define), I had to move the implementation of
 * UsesTransparency.
 *
 * Revision 1.23  2002/04/22 17:00:02  dwilliss
 * Added a UsesTransparency() method to text.  Could add to others too but it
 * couldn't account for colors used by patterns/symbols since the STYLE
 * doesn't know what they are without reading them.
 *
 * Revision 1.22  2002/03/19 22:56:24  dwilliss
 * Changed default Enhanced width to 15% to be closer to old behaviour
 *
 * Revision 1.20  2002/03/08 18:13:39  dwilliss
 * Missed the UnderlineWidth setting
 *
 * Revision 1.19  2002/03/08 17:08:13  dwilliss
 * Fixed the memcpy overload to cope with amemcpy
 *
 * Revision 1.18  2002/03/08 16:53:13  dwilliss
 * Moved WidthUnits to keep from mis-aligning the struct
 *
 * Revision 1.17  2002/03/08 16:19:56  dwilliss
 * TEXTSTYLE now has copy ctor and assignment operators that cope with
 * mismatched sizes
 *
 * Revision 1.15  2002/03/07 23:47:02  dwilliss
 * Added a bunch of members to TEXTSTYLE
 *
 * Revision 1.14  2000/07/26 15:17:56  mju
 * Add equality/inequality operators.
 *
 * Revision 1.11  2000/05/25 14:31:24  mju
 * Include compat.h so works on Sun.
 *
 * Revision 1.10  2000/05/22 14:23:40  mju
 * Include std C headers needed so compiles in isolation.
 *
 * Revision 1.9  2000/05/10 16:37:30  mju
 * Deprecate TEXTSTYLEEXT typedef.
 *
 * Revision 1.7  1999/12/13 21:12:31  mju
 * Implement ctor, copy ctor, dtor, op= for ...STYLE structs.
 *
 * Revision 1.5  1999/05/13 14:34:41  dwilliss
 * Define STYLEFLAGMASK for text justification.
 *
 * Revision 1.3  1999/04/30  21:14:49  dwilliss
 * Added TEXTSTYLE flag for kerning
 *
 * Revision 1.1  1999/04/12  15:16:01  mju
 * Initial revision
 * \endif
**/

#ifndef  INC_MI32_ELEMSTYL_H
#define  INC_MI32_ELEMSTYL_H

#ifndef  INC_MI32_STDDEFNS_H
#include <mi32/stddefns.h>
#endif

#ifndef  INC_MI32_COLOR_H
#include <mi32/color.h>
#endif

#ifndef  INC_STRING_H
#include <string.h>                    // Includes defn for memset()
#define  INC_STRING_H
#endif

#ifndef  INC_STDLIB_H
#include <stdlib.h>
#define  INC_STDLIB_H
#endif

#ifndef  INC_MI32_COMPAT_H
#include <mi32/compat.h>               // Need for strdup() on Sun
#endif

#ifndef  INC_MI32_FIXEDSTR_H
#include <mi32/fixedstr.h>             // Need for TEXTSTYLE fontname
#endif


namespace MGD {
   class CONTEXT;
   }

#define  STYLEFLAG_Fill                   (0x00000001)
#define  STYLEFLAG_ScaleToMap             (0x00000002)   //!< Sizes given are relativve to MapScale
#define  STYLEFLAG_UseSymbol              (0x00000004)
#define  STYLEFLAG_UseLinePatt            (0x00000008)
#define  STYLEFLAG_UseBitmapPatt          (0x00000010)   //!< Use bitmap FILL pattern (use BorderBitmapPatt for lines)
#define  STYLEFLAG_UseHatchPatt           (0x00000020)   //!< Use "hatch" fill pattern
#define  STYLEFLAG_DrawPolyBorder         (0x00000040)   //!< Draw polygon borders
#define  STYLEFLAG_BorderBitmapPatt       (0x00000080)   //!< Use bitmap pattern for polygon border
#define  STYLEFLAG_LineJoinBevel          (0x00000100)   //!< Join lines beveled
#define  STYLEFLAG_LineJoinMiter          (0x00000200)   //!< Join lines mitered
#define  STYLEFLAG_LineJoinRound          (0x00000300)   //!< Join lines rounded
#define  STYLEFLAG_PointSymbolBuiltIn     (0x00000400)   //!< Use built-in point symbol
#define  STYLEFLAG_LinePatternBuiltIn     (0x00000400)   //!< Use built-in line pattern
#define  STYLEFLAG_PolyFillPattBuiltIn    (0x00000400)   //!< Use built-in polygon fill pattern
#define  STYLEFLAG_PolyBorderPattBuiltIn  (0x00000800)   //!< Use built-in polygon border pattern
#define  STYLEFLAG_TextHTML               (0x00002000)   //!< Text is in HTML format
#define  STYLEFLAG_TextJustifyLeft        (0x00000000)   //!< Justify left side of block
#define  STYLEFLAG_TextJustifyRight       (0x00004000)   //!< Justify right side of block
#define  STYLEFLAG_TextJustifyCenter      (0x00008000)   //!< Center lines within block
#define  STYLEFLAG_TextJustifyBoth        (0x0000C000)   //!< Justify both left and right sides of block
#define  STYLEFLAG_TextCenterVert         (0x00010000)   //!< Center text "vertically" along baseline
#define  STYLEFLAG_TextAboveBaseline      (0x00020000)   //!< Text drawn completely "above" baseline
#define  STYLEFLAG_TextBelowBaseline      (0x00040000)   //!< Text drawn completely "below" baseline
#define  STYLEFLAG_TextMirrorHorz         (0x00080000)   //!< Mirror text in "horizontal" plane
#define  STYLEFLAG_TextMirrorVert         (0x00100000)   //!< Mirror text in "vertical" plane
#define  STYLEFLAG_TextOrientOutput       (0x00200000)   //!< Orient block relative to output rather than baseline
#define  STYLEFLAG_TextUseStyleHeight     (0x00400000)   //!< Use height stored with style, otherwise use height stored with text
#define  STYLEFLAG_UseLayoutScale         (0x00800000)   //!< Sizes relative to scale int LAYOUTPARMS
#define  STYLEFLAG_PointDrawCircle        (0x01000000)   //!< Draw points as circles if no pattern is used
#define  STYLEFLAG_CenterSymbol           (0x02000000)   //!< Center point symbol, ignoring its hot-spot
#define  STYLEFLAG_PointNoSymbol          (0x04000000)   //!< Point has no symbol (probably just a label)
#define  STYLEFLAG_BlockInsert            (0x08000000)   //!< Style block insert using insert style
#define  STYLEFLAG_WordWrap               (0x10000000)   //!< Word-wrap text to style's block width
#define  STYLEFLAG_ScaleIsPatternZoom     (0x20000000)   //!< Scale values are pattern zoom factor.

#define  STYLEFLAGMASK_LineJoin           (0x00000300)
#define  STYLEFLAGMASK_Patt            (STYLEFLAG_UseSymbol | STYLEFLAG_UseLinePatt | STYLEFLAG_UseBitmapPatt | STYLEFLAG_UseHatchPatt | STYLEFLAG_BorderBitmapPatt)
#define  STYLEFLAGMASK_PattPlus        (STYLEFLAGMASK_Patt | STYLEFLAG_Fill | STYLEFLAG_PointDrawCircle | STYLEFLAG_DrawPolyBorder | STYLEFLAG_PointSymbolBuiltIn | STYLEFLAG_PolyBorderPattBuiltIn)
#define  STYLEFLAGMASK_Scale           (STYLEFLAG_ScaleToMap | STYLEFLAG_UseLayoutScale)
#define  STYLEFLAGMASK_Point           (STYLEFLAG_UseSymbol | STYLEFLAG_UseBitmapPatt | STYLEFLAG_Fill | STYLEFLAG_PointDrawCircle | STYLEFLAG_PointNoSymbol | STYLEFLAG_PointSymbolBuiltIn)
#define  STYLEFLAGMASK_Line            (STYLEFLAG_UseLinePatt | STYLEFLAG_UseBitmapPatt)
#define  STYLEFLAGMASK_PolyFill        (STYLEFLAG_UseBitmapPatt | STYLEFLAG_UseHatchPatt | STYLEFLAG_Fill)
#define  STYLEFLAGMASK_PolyBord        (STYLEFLAG_UseLinePatt | STYLEFLAG_BorderBitmapPatt | STYLEFLAG_DrawPolyBorder)
#define  STYLEFLAGMASK_Poly            (STYLEFLAGMASK_PolyFill | STYLEFLAGMASK_PolyBord)
#define  STYLEFLAGMASK_TextVertAlign   (STYLEFLAG_TextAboveBaseline | STYLEFLAG_TextCenterVert | STYLEFLAG_TextBelowBaseline)
#define  STYLEFLAGMASK_TextJustify     (STYLEFLAG_TextJustifyRight|STYLEFLAG_TextJustifyCenter)

//! Old names
#define  STYLEFLAG_TextJustifyMask     STYLEFLAGMASK_TextJustify
#define  STYLEFLAG_LineJoinMask        STYLEFLAGMASK_LineJoin

//----------------------------------------------------------------------------
//!      Element drawing style definitions are for in-memory use only            
//!      These structures are referenced by DLLs and must not shrink or have     
//!      field positions or sizes changed                                        
//----------------------------------------------------------------------------

//! In-memory structure for point feature style.
struct POINTSTYLE {  
   
   UINT32 StyleFlags;
   INT32 SymbolNum;
   double ScaleX;                      //!< X size of point (usually in millimeters) or pattern zoom factor
   double ScaleY;                      //!< Y size of point (usually in millimeters) or pattern zoom factor
   double Angle;                       //!< Symbol rotation angle in RADIANS
   COLOR DrawColor;
   double MapScale;
   UINT8 spare[4];
   char *Desc;                         //!< string from query, Symbol$ (freed in destructor)

   //! Default constructor.
   POINTSTYLE (                        
      ) {
      memset(static_cast<void*>(this),0,sizeof(*this));
      }

   //! Copy constructor.
   POINTSTYLE (                        
      const POINTSTYLE& rhs
      ): Desc(0) {
      Copy(rhs);
      }

   //! Destructor.
   ~POINTSTYLE (                       
      ) {
      if (Desc) free(Desc);
      }

   //! Assignment from POINTSTYLE.
   POINTSTYLE& operator= (             
      const POINTSTYLE& rhs
      ) {
      if (this != &rhs) {
         Copy(rhs);
         }
      return (*this);
      }

   //! Equality operator.
   bool operator== (
      const POINTSTYLE& rhs
      ) const {
      if (StyleFlags != rhs.StyleFlags || SymbolNum != rhs.SymbolNum || ScaleX != rhs.ScaleX || ScaleY != rhs.ScaleY || Angle != rhs.Angle || DrawColor != rhs.DrawColor || MapScale != rhs.MapScale) return (false);
      if (Desc == rhs.Desc) return (true);
      if (Desc == 0 || rhs.Desc == 0) return (false);
      return (!strcmp(Desc,rhs.Desc));
      }

   //! Inequality operator.
   bool operator!= (
      const POINTSTYLE& rhs
      ) const {
      return (!(*this == rhs));
      }

   //! Clear the structure
   void Clear (
      ) {
      if (Desc != 0) free(Desc);
      memset(static_cast<void*>(this), 0, sizeof(*this));
      }

   //! Helper method for copying.
   void Copy (                        
      const POINTSTYLE& rhs
      ) {
      if (Desc != 0) free(Desc);
      memcpy(static_cast<void*>(this), static_cast<const void*>(&rhs), sizeof(*this));
      Desc = 0;
      if (rhs.Desc) {
         Desc = strdup(rhs.Desc);
         }
      return;
      }
   
   //! Determine if the style uses transparency
   //! Note: if the style uses a point symbol, this method can't tell
   //! if that symbol will use transparency or not.
   bool UsesTransparency (
      ) const {
      if (DrawColor.GetTransparency() != 0) return (true);
      // XXX what about point symbols?
      return (false);
      }
   };

//! In-memory structure for polygon feature style.
struct POLYSTYLE {
      
   UINT32 StyleFlags;
   INT32 FillPatternNum;
   INT32 BorderPatternNum;
   double BorderScale;                 //!< Width of border (usually in millimeters) or pattern zoom factor
   double MapScale;
   COLOR BorderColor;
   COLOR FillColor;
   double Angle;                       //!< Rotation angle for hatch patterns (was spare[8])
   char *FillDesc;                     //!< string from query, Symbol$ (free when done)
   char *LineDesc;                     //!< string from query, Symbol$ (free when done)

   //! Default constructor.
   POLYSTYLE (                         
      ) { memset(static_cast<void*>(this),0,sizeof(*this)); }

   //! Copy constructor.
   POLYSTYLE (                         
      const POLYSTYLE& rhs
      ): FillDesc(0), LineDesc(0) { Copy(rhs); }

   //! Destructor.
   ~POLYSTYLE (                        
      ) { if (FillDesc) free(FillDesc); if (LineDesc) free(LineDesc); }

   //! Assignment from POLYSTYLE.
   POLYSTYLE& operator= (              
      const POLYSTYLE& rhs
      ) { if (this != &rhs) { Copy(rhs); } return (*this); }

   //! Equality operator.
   bool operator== (
      const POLYSTYLE& rhs
      ) const {
      if (StyleFlags != rhs.StyleFlags || FillPatternNum != rhs.FillPatternNum || BorderPatternNum != rhs.BorderPatternNum || BorderScale != rhs.BorderScale || MapScale != rhs.MapScale || BorderColor != rhs.BorderColor || FillColor != rhs.FillColor) return (false);
      if (FillDesc != rhs.FillDesc) {
         if (FillDesc == 0 || rhs.FillDesc == 0) return (false);
         if (strcmp(FillDesc,rhs.FillDesc) != 0) return (false);
         }
      if (LineDesc != rhs.LineDesc) {
         if (LineDesc == 0 || rhs.LineDesc == 0) return (false);
         if (strcmp(LineDesc,rhs.LineDesc) != 0) return (false);
         }
      return (true);
      }

   //! Inequality operator.
   bool operator!= (
      const POLYSTYLE& rhs
      ) const { return (!(*this == rhs)); }

   //! Clear the structure
   void Clear (
      ) {
      if (FillDesc != 0) free(FillDesc);
      if (LineDesc != 0) free(LineDesc);
      memset(static_cast<void*>(this), 0, sizeof(*this));
      }

   //! Helper method for copying.
   void Copy (                         
      const POLYSTYLE& rhs
      ) {
      if (FillDesc != 0) free(FillDesc);
      if (LineDesc != 0) free(LineDesc);
      memcpy(static_cast<void*>(this), static_cast<const void*>(&rhs), sizeof(*this));
      FillDesc = 0;
      LineDesc = 0;
      if (rhs.FillDesc) {
         FillDesc = strdup(rhs.FillDesc);
         }
      if (rhs.LineDesc) {
         LineDesc = strdup(rhs.LineDesc);
         }
      return;
      }

   //! Determine if the style uses transparency
   //! Note: if the style uses a fill pattern, this method can't tell
   //! if that pattern will use transparency or not.
   bool UsesTransparency (
      ) const {
      if ((StyleFlags & STYLEFLAG_Fill) && FillColor.GetTransparency() != 0) return (true);
      if ((StyleFlags & STYLEFLAG_DrawPolyBorder) && BorderColor.GetTransparency() != 0) return (true);
      return (false);
      }
   };

//! In-memory structure for line feature style.
struct LINESTYLE {      

   UINT32 StyleFlags;
   INT32 PatternNum;
   double Scale;                       //!< Width of line (usually in millimeters) or pattern zoom factor
   COLOR DrawColor;
   double MapScale;
   UINT8 spare[4];
   char *Desc;                         //!< string from query, Symbol$ (free when done)

   //! Default constructor
   LINESTYLE (                         
      ) { memset(static_cast<void*>(this),0,sizeof(*this)); }

   //! Copy constructor.
   LINESTYLE (                         
      const LINESTYLE& rhs
      ): Desc(0) { Copy(rhs); }

   //! Destructor.
   ~LINESTYLE (                        
      ) { if (Desc) free(Desc); }

   //! Assignment from LINESTYLE.
   LINESTYLE& operator= (              
      const LINESTYLE& rhs
      ) { if (this != &rhs) { Copy(rhs); } return (*this); }

   //! Assignment from POLYSTYLE.
   LINESTYLE& operator= (              
      const POLYSTYLE& rhs
      ) {
      Clear();
      StyleFlags = (rhs.StyleFlags & (STYLEFLAG_ScaleToMap | STYLEFLAG_UseLayoutScale | STYLEFLAG_UseLinePatt));
      if (rhs.StyleFlags & STYLEFLAG_BorderBitmapPatt) StyleFlags |= STYLEFLAG_UseBitmapPatt;
      PatternNum = rhs.BorderPatternNum;
      Scale = rhs.BorderScale;
      DrawColor = rhs.BorderColor;
      MapScale = rhs.MapScale;
      if (rhs.LineDesc != 0) Desc = strdup(rhs.LineDesc);
      return (*this);
      }

   //! Equality operator.
   bool operator== (
      const LINESTYLE& rhs
      ) const {
      if (StyleFlags != rhs.StyleFlags || PatternNum != rhs.PatternNum || Scale != rhs.Scale || DrawColor != rhs.DrawColor || MapScale != rhs.MapScale) return (false);
      if (Desc == rhs.Desc) return (true);
      if (Desc == 0 || rhs.Desc == 0) return (false);
      return (!strcmp(Desc,rhs.Desc));
      }

   //! Inequality operator.
   bool operator!= (
      const LINESTYLE& rhs
      ) const { return (!(*this == rhs)); }

   //! Clear the structure
   void Clear (
      ) {
      if (Desc != 0) free(Desc);
      memset(static_cast<void*>(this), 0, sizeof(*this));
      }

   //! Helper method for copying.
   void Copy (                         
      const LINESTYLE& rhs
      ) {
      if (Desc != 0) free(Desc);
      memcpy(static_cast<void*>(this), static_cast<const void*>(&rhs), sizeof(*this));
      Desc = 0;
      if (rhs.Desc) {
         Desc = strdup(rhs.Desc);
         }
      return;
      }
   
   //! Determine if the style uses transparency
   //! Note: if the style uses a line pattern, this method can't tell
   //! if that pattern will use transparency or not.
   bool UsesTransparency (
      ) const {
      if (DrawColor.GetTransparency() != 0) return (true);
      // XXX what about line patterns?
      return (false);
      }
   };


#define  FONTSTYLE_Normal        (0x00000000)
#define  FONTSTYLE_Bold          (0x00000001)
#define  FONTSTYLE_Italic        (0x00000002)
#define  FONTSTYLE_Shadow        (0x00000004)
#define  FONTSTYLE_Enhanced      (0x00000008)
#define  FONTSTYLE_Outline       (0x00000010)
#define  FONTSTYLE_Underline     (0x00000020)
#define  FONTSTYLE_Boxed         (0x00000040)
#define  FONTSTYLE_InvertGlyph   (0x00000080)   //! Invert glyphs
#define  FONTSTYLE_Smooth        (0x00000100)   //! Text Smoothing (FreeType only)
#define  FONTSTYLE_RoundWidth    (0x00000200)   //! Round all glyph width up to integer pixels (HTML Widget needs.  Screws up scale if zoomed out)
#define  FONTSTYLE_Kerning       (0x00000400)   //! Do kerning if the font supports it
#define  FONTSTYLE_InvertCRS     (0x00000800)   //! Invert Coordinate Reference System for multi-line labels

struct TEXTSTYLE {
   UINT32 StyleFlags;                  //!< STYLEFLAG_Xxxx
   INT32 FontNumber;
   COLOR FGColor;
   COLOR BGColor;
   FLOAT GlyphRotation;                //!< Rotation of each glyph individually
   FLOAT GlyphAspect;                  //!< Height to width aspect ratio
   FLOAT Shear;                        //!< Italics angle (ignored unless FONTSTYE_Italic is set)
   FLOAT Height;                       //!< Height of glyph in "HeightUnits"
   FLOAT LineSpace;                    //!< Line spacing in "SpaceUnits"
   UINT32 FontFlags;                   //!< FONTSTYLE_Xxxx or'ed together
   double MapScale;
   MISTRING fontname;               //!< font name (eg: "SYSTEM.OF")
   UINT16 HeightUnits;                 //!< Units for height (SCREENUNIT_...)
   UINT16 SpaceUnits;                  //!< Units for line spacing (SCREENUNIT_...)
   UINT16 Predefined;                  //!< Predefined label styles
   UINT16 StructSize;                  //!< Sizeof this structure.  If 0, we assume old size (128) that ended with this field.
   double Width;                       //!< Width of block (only if STYLEFLAG_TextHTML or STYLEFLAG_WordWrap)
   double StrokeWidth;                 //!< Stroke width in % of glyph height (1.0 = 100%)
   double EnhanceWidth;                //!< Enhanced width in % of glyph height (1.0 = 100%)
   double BoldnessWidth;               //!< Boldness width in % of glyph height (1.0 = 100%) Ignored unless FONTSTYLE_Bold is set
   double UnderlineWidth;              //!< Underline with in % of glyph height (1.0 = 100%)
   double UnderlineOffset;             //!< Underline Offset from baseline in % (1.0 = 100%)
   double ShadowOffset;                //!< Drop shadow offset in % (1.0 = 100%) Ignored unless FONTSTYLE_Shadow is set
   double ShadowAngle;                 //!< Drop shadow angle in radians
   double ClipWidth;                   //!< Clip extended area around text in TextAddToClip()
   bool ShadowRelative;                //!< true if shadow angle relative to baseline angle
   bool m_bInitialized;                //!< Set to true by constructor.  Used to verify that defaults are valid and not just memset to 0
   UINT16 WidthUnits;

   //! Default constructor.
   TEXTSTYLE (                         
      ) :
      StyleFlags(STYLEFLAG_UseLayoutScale),
      FontNumber(0),
      GlyphRotation(0.0F),
      Height(0.0F),
      LineSpace(0.0F),
      FontFlags(0),
      HeightUnits(0),
      SpaceUnits(0), 
      Predefined(0),
      StructSize(sizeof(TEXTSTYLE)),
      StrokeWidth(0.0),
      EnhanceWidth(0.15),     //!< 15%
      BoldnessWidth(0.03), //!< 3%
      UnderlineWidth(0.0),
      UnderlineOffset(0.0),
      ShadowOffset(0.1),      //!< 10%
      ShadowAngle(-PI/4.0),
      GlyphAspect(1.0),
      Shear(static_cast<float>(20.0 * DEGTORAD)),  //! Default shear for italic
      ClipWidth(0.2),
      MapScale(1.0),
      WidthUnits(0),
      Width(0.0),
      ShadowRelative(false),
      m_bInitialized(true)
      {
      }

   //! Copy constructor
   TEXTSTYLE(const TEXTSTYLE& rhs) {
      Copy(rhs);
      }

   //! Assignment from TEXTSTYLE.
   TEXTSTYLE& operator= (              
      const TEXTSTYLE& rhs
      ) {
      if (this != &rhs) {
         Copy(rhs);
         }
      return (*this);
      }
      

   //! Equality operator.
   bool operator== (
      const TEXTSTYLE& rhs
      ) const {
      return (StyleFlags == rhs.StyleFlags
           && FontNumber == rhs.FontNumber
           && FGColor == rhs.FGColor
           && BGColor == rhs.BGColor
           && GlyphRotation == rhs.GlyphRotation
           && GlyphAspect == rhs.GlyphAspect
           && Shear == rhs.Shear
           && Height == rhs.Height
           && LineSpace == rhs.LineSpace
           && FontFlags == rhs.FontFlags
           && MapScale == rhs.MapScale
           && fontname == rhs.fontname
           && HeightUnits == rhs.HeightUnits
           && SpaceUnits == rhs.SpaceUnits
           && Predefined == rhs.Predefined
           && Width == rhs.Width
           && StrokeWidth == rhs.StrokeWidth
           && EnhanceWidth == rhs.EnhanceWidth
           && BoldnessWidth == rhs.BoldnessWidth
           && UnderlineWidth == rhs.UnderlineWidth
           && UnderlineOffset == rhs.UnderlineOffset
           && ShadowOffset == rhs.ShadowOffset
           && ShadowAngle == rhs.ShadowAngle
           && ClipWidth == rhs.ClipWidth
           && ShadowRelative == rhs.ShadowRelative
           && WidthUnits == rhs.WidthUnits);
      }

   //! Inequality operator.   
   bool operator!= (
      const TEXTSTYLE& rhs
      ) const {
      return (!(*this == rhs));
      }


   //! Returns true if this text style will try to use transparency 
   //! If a gc is given, this will return true if the text uses antialising
   //!  AND if the device is < 300dpi (not meaningful above 300dpi)
   bool UsesTransparency (
      const MGD::CONTEXT* gc = 0
      ) const;

   //! Returns true if this text style will try to use transparency 
   bool UsesAntialiasing (
      ) const {
      return ((FontFlags & FONTSTYLE_Smooth) != 0);
      }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      void Copy (
         const TEXTSTYLE& rhs
         ) {
         // This is less important now because patches can include an update of
         // everything, so if we change the size, we just have to recompile
         // the whole world.
         StructSize = sizeof(TEXTSTYLE);
         StyleFlags = rhs.StyleFlags;
         FontNumber = rhs.FontNumber;
         FGColor = rhs.FGColor;
         BGColor = rhs.BGColor;
         GlyphRotation = rhs.GlyphRotation;
         GlyphAspect = rhs.GlyphAspect;
         Shear = rhs.Shear;
         Height = rhs.Height;
         LineSpace = rhs.LineSpace;
         FontFlags = rhs.FontFlags;
         MapScale = rhs.MapScale;
         fontname = rhs.fontname;
         HeightUnits = rhs.HeightUnits;
         SpaceUnits = rhs.SpaceUnits;
         Predefined = rhs.Predefined;
         Width = rhs.Width;
         StrokeWidth = rhs.StrokeWidth;
         EnhanceWidth = rhs.EnhanceWidth;
         BoldnessWidth = rhs.BoldnessWidth;
         UnderlineWidth = rhs.UnderlineWidth;
         UnderlineOffset = rhs.UnderlineOffset;
         ShadowOffset = rhs.ShadowOffset;
         ShadowAngle = rhs.ShadowAngle;
         ClipWidth = rhs.ClipWidth;
         ShadowRelative = rhs.ShadowRelative;
         WidthUnits = rhs.WidthUnits;
         m_bInitialized = true;
         }

      #endif // GENERATING_DOXYGEN_OUTPUT
   };

PREVENT_MEMFUNC(TEXTSTYLE);
   

struct TEXTSTYLEDIFF : public TEXTSTYLE {
   enum MEMBERMASK {
      MEMBER_NONE =              0x00000000,
      MEMBER_StyleFlags =        0x00000001,
      MEMBER_FontNumber =        0x00000002,
      MEMBER_FGColor =           0x00000004,
      MEMBER_BGColor =           0x00000008,
      MEMBER_GlyphRotation =     0x00000010,
      MEMBER_GlyphAspect   =     0x00000020,
      MEMBER_Shear   =           0x00000040,
      MEMBER_Height  =           0x00000080,
      MEMBER_LineSpace =         0x00000100,
      MEMBER_FontFlags =         0x00000200,
      MEMBER_MapScale =          0x00000400,
      MEMBER_fontname =          0x00000800,
      MEMBER_HeightUnits =       0x00001000,
      MEMBER_SpaceUnits =        0x00002000,
      MEMBER_Predefined =        0x00004000,
      MEMBER_Width =             0x00008000,
      MEMBER_StrokeWidth =       0x00010000,
      MEMBER_EnhanceWidth =      0x00020000,
      MEMBER_BoldnessWidth =     0x00040000,
      MEMBER_UnderlineWidth =    0x00080000,
      MEMBER_UnderlineOffset =   0x00100000,
      MEMBER_ShadowOffset =      0x00200000,
      MEMBER_ShadowAngle =       0x00400000,
      MEMBER_ClipWidth =         0x00800000,
      MEMBER_ShadowRelative =    0x01000000,
      MEMBER_WidthUnits =        0x02000000,
      MEMBER_ALL =               0x03FFFFFF
      };

   UINT32 StyleFlagMask;               //!< Which StyleFlags bits are meaningful
   UINT32 FontFlagMask;                //!< Which FontFlags bits are meaningful
   MEMBERMASK MemberMask;              //!< Which members are meaningful

   TEXTSTYLEDIFF() :
      TEXTSTYLE(),
      StyleFlagMask(0),
      FontFlagMask(0),                 
      MemberMask(MEMBER_NONE)
      {
      }

   //! Initialize a TEXTSTYLEDIFF with the style changes described by the 
   //! {~} codes in a text string.
   TEXTSTYLEDIFF (
      const UNICODE*    
      );

   //! Copy constructor
   TEXTSTYLEDIFF (
      const TEXTSTYLE& rhs
      ) :
      TEXTSTYLE(rhs),
      StyleFlagMask(0xFFFFFFFF),
      FontFlagMask(0xFFFFFFFF),                 
      MemberMask(MEMBER_ALL)
      {
      }

   //! Augment from another TEXTSTYLE. 
   //! Only the members of the right hand side which are valid (according to
   //! MemberMask) will be copied to the left hand side.
   TEXTSTYLEDIFF& operator|= (               
      const TEXTSTYLEDIFF& rhs
      );

   //! Augment from {~} code(s)
   TEXTSTYLEDIFF& operator+= (               
      const UNICODE* code
      );

   //! Compute the similaraties between this TEXTSTYLE and another.
   //! The left hand side will only have the MemberMask bits set for the
   //! members which are the same between its previous state and the
   //! right hand side.  The MemberMask bits for the members which are 
   //! different are cleared.
   TEXTSTYLEDIFF& operator&= (               
      const TEXTSTYLEDIFF& rhs
      );

   //! Compute the difference between this TEXTSTYLE and another.
   //! The left hand side will only have the MemberMask bits set for the
   //! members which are different between its previous state and the
   //! right hand side.  The MemberMask bits for the members which are the
   //! same are cleared.
   TEXTSTYLEDIFF& operator^= (               
      const TEXTSTYLEDIFF& rhs
      );


   //! Generate a string of TILDE codes which describe the changes that this
   //! TEXTSTYLEDIFF represent
   void GetTildeCodes (
      MISTRING& str,
      bool bClearStringFirst = true    //!< Pass false to append to existing text
      ) const;

   //! Parse a series of {~} codes.
   //! @return true if any ~ code was recgonized.
   bool ParseTildeCodes (
      const UNICODE* commands,   //!< {~} codes to parse
      MISTRING* unknowns = 0     //!< Any unrecgonized commands will be returned in this string, if provided.
      );

   };
DEFINE_ENUM_OP_BITWISE(TEXTSTYLEDIFF::MEMBERMASK);

struct MULTISTYLE {
   POINTSTYLE Point;
   LINESTYLE Line;
   POLYSTYLE Poly;
   TEXTSTYLE Text;
   };

#ifndef GENERATING_DOXYGEN_OUTPUT
//! Make sure nobody is memsetting a TEXTSTYLE to 0.
//! The following memset is an overload specific to TEXTSTYLE.  Any attempt
//! to call it will result in a compile error.
PREVENT_MEMFUNC(TEXTSTYLE)
PREVENT_MEMCMP(TEXTSTYLE)
PREVENT_MEMFUNC(POINTSTYLE)
PREVENT_MEMFUNC(LINESTYLE)
PREVENT_MEMFUNC(POLYSTYLE)
PREVENT_MEMFUNC(MULTISTYLE)
#endif // GENERATING_DOXYGEN_OUTPUT

#define  STYLE_BuiltIn_Point_None            0
#define  STYLE_BuiltIn_Point_BoxOpen         1
#define  STYLE_BuiltIn_Point_BoxFilled       2
#define  STYLE_BuiltIn_Point_CircleOpen      3
#define  STYLE_BuiltIn_Point_CircleFilled    4
#define  STYLE_BuiltIn_Point_Crosshair       5     //!< Simple thin-line crosshair
#define  STYLE_BuiltIn_Point_CrosshairHalo   6     //!< Crosshair with background halo
#define  STYLE_BuiltIn_Point_Last            6

         //! Values for TEXTSTYLE.Predefined
#define  TEXTSTYLEPREDEF_None             0
#define  TEXTSTYLEPREDEF_NauticalDepth    1

//----------------------------------------------------------------------------
//!      Functions and macros                                                    
//----------------------------------------------------------------------------

//!:Associate with "Element Style Functions"
//!\addtogroup ElementStyle Element Style Functions
//!@{

#if defined(__cplusplus)
extern "C" {
#endif

//! Compute min/max of a symbol in its coordinate system.
int MxGetSymbolMinMax (
   UINT8 *symbolbuf, 
   LRECTXY *minmax
   );

//! Compute size of symbol in its coordinate system.
int MxGetSymbolSize (
   UINT8 *symbolbuf
   );

//!   Parse text string and build symbol description.
int MxParseSymbol (
   const char* const istring, 
   UINT8 **bufp
   );

//!   Convert symbol description to text string.
char *MxSymbolToText (
   UINT8 *buf
   );

//!   Compute extents for string as it would be drawn.
int GetStringExtents (
   TEXTSTYLE *style, 
   DPOINT2D *basepts, 
   INT32 numbasepts, 
   UINT32 baseflags, 
   const UNICODE *string, 
   DRECT2D *extents
   );

//!   Compute extents for string as it would be drawn.
int GetStringExtentsJustify (
   TEXTSTYLE *style, 
   DPOINT2D *basepts, 
   INT32 numbasepts, 
   UINT32 baseflags, 
   const UNICODE *string, 
   DRECT2D *extents
   );

#if defined(__cplusplus)
}                       
#endif

//!@}

#endif   // INC_MI32_ELEMSTYL_H

---