mi32/matte.h

Go to the documentation of this file.

/*****************************************************************************
 * \file mi32/matte.h
 * \brief MATTE class definition.
 *
 * \if NODOC
 * $Id: matte.h_v 1.27 2011/10/12 12:34:56 mju Exp $
 *
 * $Log: matte.h_v $
 * Revision 1.27  2011/10/12 12:34:56  mju
 * Remove redundant hdr.
 *
 * Revision 1.26  2006/09/15 15:25:51  mju
 * Serializer changes.
 *
 * Revision 1.21  2005/06/21 21:28:02  dwilliss
 * Added WillDraw method
 *
 * Revision 1.12  2001/10/04 15:04:10  dwilliss
 * Added methods to get and set cartoscript member
 *
 * Revision 1.11  2001/10/03 16:46:22  dwilliss
 * New border type flag for cartoscript
 *
 * Revision 1.8  2001/10/02 15:53:32  dwilliss
 * Added members to keep track of page color and cartoscript border
 *
 * Revision 1.5  2001/09/13 21:44:43  dwilliss
 * Control panel now returns a handle which you can use to change things
 * after the fact
 *
 * Revision 1.3  2001/09/12 21:31:44  dwilliss
 * Added drop shadow blend member
 *
 * Revision 1.2  2001/09/12 21:08:28  dwilliss
 * Added SPREADMODE member
 *
 * Revision 1.1  2001/09/12 15:44:00  dwilliss
 * Initial revision
 * \endif
 ****************************************************************************/

#ifndef INC_MI32_MATTE_H
#define INC_MI32_MATTE_H

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

#ifndef INC_MI32_SERIALIZABLEE_H
#include <mi32/serializable.h>
#endif

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

#ifndef  INC_MI32_MISTRING_H
#include <mi32/mistring.h>
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT
namespace MGD {
   class CONTEXT;
   }
#endif


class MATTE : public SERIALIZABLE {
   public:
      
      enum DRAWFLAGS {
         DRAWFLAG_None = 0,
         DRAWFLAG_DrawInsideExtents = 0x00000001   
         };

      enum FILLMODE {
         FILLMODE_None = 0,
         FILLMODE_Solid = 1,
         FILLMODE_Gradient,
         FILLMODE_Radial
         };
   
      enum SPREADMODE {
         SPREADMODE_RGB = 0,
         SPREADMODE_HISCW,
         SPREADMODE_HISCCW,
         SPREADMODE_HBSCW,
         SPREADMODE_HBSCCW
         };

      enum BORDER {
         BORDER_None = 0,
         BORDER_Solid = 1,
         BORDER_Double = 2,
         BORDER_Inset = 3,
         BORDER_Outset = 4,
         BORDER_Groove = 5,
         BORDER_Ridge = 6,
         BORDER_EtchedIn = 7,
         BORDER_EtchedOut = 8,
         BORDER_Rounded = 9,
         BORDER_CartoScript = 10
         };

      class FORM;          // Defined in <mi32/matteform.h>
   
      MATTE();

      MATTE (const MATTE&);

      virtual ~MATTE();

      MATTE& operator= (
         const MATTE& rhs
         );

      virtual ERRVALUE SerialRead (
         SERIALIZER& serializer
         );

      virtual ERRVALUE SerialWrite (
         SERIALIZER& serializer,
         const char* tagname
         ) const;

      ERRVALUE Draw (
         MGD::CONTEXT& gc,
         const LRECT2D& rect,
         double MapScale = 1.0,
         DRAWFLAGS flags = DRAWFLAG_None
         );

      ERRVALUE DrawBackground (
         MGD::CONTEXT& gc,
         const LRECT2D& rect,
         double MapScale = 1.0,
         DRAWFLAGS flags = DRAWFLAG_None
         );

      ERRVALUE DrawBorder (
         MGD::CONTEXT& gc,
         const LRECT2D& rect,
         double MapScale = 1.0,
         DRAWFLAGS flags = DRAWFLAG_None
         );

      ERRVALUE DrawDropShadow (
         MGD::CONTEXT& gc,
         const LRECT2D& rect,
         double MapScale = 1.0,
         DRAWFLAGS flags = DRAWFLAG_None
         );


      // Get Methods

      const COLOR& GetBackgroundColor (
         ) const {
         return m_BGColor1; 
         }

      const COLOR& GetBackgroundColor2 (
         ) const {
         return m_BGColor2; 
         }

      FILLMODE GetBackgroundFillMode (
         ) const {
         return m_BGFillMode; 
         }

      double GetBackgroundGradientAngle (
         ) const {
         return m_BGGradientAngle;
         }

      SPREADMODE GetBackgroundGradientSpreadMode (
         ) const {
         return m_BGSpreadMode;
         }

      const MISTRING& GetBorderCartoScript (
         ) const {
         return m_BorderCartoScript;
         }

      const COLOR& GetBorderColor (
         ) const {
         return m_BorderColor; 
         }

      double GetBorderSize (
         ) const {
         return m_BorderSize; 
         }

      BORDER GetBorderStyle (
         ) const {
         return m_BorderStyle; 
         }
      
      bool GetDropShadowBlend (
         ) const {
         return (m_DSBlend);
         }
      
      const COLOR& GetDropShadowColor (
         ) const {
         return m_DSColor; 
         }

      void GetExtraExtents (
         double& x1,
         double& y1,
         double& x2,
         double& y2
         ) const;

      double GetDropShadowDirection (
         ) const {
         return m_DSDirection; 
         }

      double GetDropShadowSize (
         ) const {
         return m_DSSize; 
         }
      
      double GetMarginBottom (
         ) const {
         return m_MarginBottom; 
         }

      double GetMarginLeft (
         ) const {
         return m_MarginLeft; 
         }

      double GetMarginRight (
         ) const {
         return m_MarginRight; 
         }

      double GetMarginTop (
         ) const {
         return m_MarginTop; 
         }
      
      SCREENUNIT GetDisplayUnits (
         ) const {
         return m_SizeUnits; 
         }

      bool IsBorderRoundedRect (
         ) const {
         return m_BorderRoundRect; 
         }

      bool NeedsTransparency (
         ) const;

      // Set Methods

      void SetBackgroundColor (
         const COLOR& color
         ) {
         m_BGColor1 = color; 
         }

      void SetBackgroundColor2 (
         const COLOR& color
         ) {
         m_BGColor2 = color; 
         }

      void SetBackgroundFillMode (
         FILLMODE mode
         ) {
         m_BGFillMode = mode; 
         }

      void SetBackgroundGradientAngle (
         double angle
         ) {
         m_BGGradientAngle = angle;
         }

      void SetBackgroundGradientSpreadMode (
         SPREADMODE mode
         ) {
         m_BGSpreadMode = mode;
         }

      void SetBorderCartoScript (
         const MISTRING& script
         ) {
         m_BorderCartoScript = script;
         }
      
      void SetBorderColor (
         const COLOR& color
         ) {
         m_BorderColor = color; 
         }

      void SetBorderIsRoundedRect (
         bool bRound
         ) {
         m_BorderRoundRect = bRound; 
         }

      void SetBorderSize (
         double size
         ) {
         m_BorderSize = size; 
         }

      void SetBorderStyle (
         BORDER style
         ) {
         m_BorderStyle = style; 
         }

      void SetDropShadowBlend (
         bool blend
         ) {
         m_DSBlend = blend;
         }
      
      void SetDropShadowColor (
         const COLOR& color
         ) {
         m_DSColor = color; 
         }

      void SetDropShadowDirection (
         double dir
         ) {
         m_DSDirection = dir; 
         }

      void SetDropShadowSize (
         double size
         ) {
         m_DSSize = size; 
         }

      void SetMarginBottom (
         double dist
         ) {
         m_MarginBottom = dist; 
         }
      
      void SetMarginLeft (
         double dist
         ) {
         m_MarginLeft = dist; 
         }

      void SetMarginRight (
         double dist
         ) {
         m_MarginRight = dist; 
         }

      void SetMarginTop (
         double dist
         ) {
         m_MarginTop = dist; 
         }
      
      void SetDisplayUnits (
         SCREENUNIT units
         ) {
         m_SizeUnits = units; 
         }

      // Runtime drawing settings
      
      void SetSolidBackground (
         const COLOR& color
         ) {
         m_bSolidBackground = true;
         m_PageColor = color;
         return;
         }
       
      void SetDirtyBackground (
         ) {
         m_bSolidBackground = false;
         return;
         }

      void SetMarginsInset (
         bool inset
         ) {
         m_bMarginsInset = inset;
         }

      bool WillDraw (
         ) const;

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      COLOR m_BGColor1;
      COLOR m_BGColor2;
      FILLMODE m_BGFillMode;
      double m_BGGradientAngle;
      SPREADMODE m_BGSpreadMode;
      double m_MarginLeft;
      double m_MarginRight;
      double m_MarginTop;
      double m_MarginBottom;
      SCREENUNIT m_SizeUnits; 
      COLOR m_DSColor;        
      double m_DSDirection;   
      double m_DSSize;
      bool m_DSBlend;      
      COLOR m_BorderColor;
      double m_BorderSize;
      BORDER m_BorderStyle;      
      bool m_BorderRoundRect;
      MISTRING m_BorderCartoScript;
      bool m_bMarginsInset;      
      COLOR m_PageColor;
      bool m_bSolidBackground;   
      
      static const SERIALIZERITEM* SerialGetItemDef (
         SERIALIZER& serializer
         );

      friend class MATTEPRIV;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

#endif

---