matte.h

Go to the documentation of this file.

/*****************************************************************************
 *
 * \file matte.h <mi32/matte.h>
 * \brief Settings for group backgrounds
 *
 * \if NODOC
 * $Log: matte.h_v $
 * Revision 1.20  2004/03/05 15:24:16  dwilliss
 * Doh!  Save before checking in.
 *
 * Revision 1.19  2004/03/05 15:23:22  dwilliss
 * destructor needed to be virtual
 *
 * Revision 1.18  2004/02/12 22:00:21  dwilliss
 * deprecate old mgd
 *
 * Revision 1.17  2003/09/15 13:49:56  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.16  2001/12/28 21:34:16  mju
 * SerialWrite now const.
 *
 * Revision 1.15  2001/12/21 20:33:40  dwilliss
 * [ irrelevant due to deprecated stuff ]
 *
 * Revision 1.14  2001/11/12 15:35:57  scowan
 * Removed comma from end of enum.
 *
 * Revision 1.13  2001/10/12 22:46:41  dwilliss
 * *** empty log message ***
 *
 * 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.10  2001/10/03 16:40:59  dwilliss
 * Seems to be done for now.
 *
 * Revision 1.9  2001/10/02 19:35:38  dwilliss
 * Operator =
 *
 * Revision 1.8  2001/10/02 15:53:32  dwilliss
 * Added members to keep track of page color and cartoscript border
 *
 * Revision 1.7  2001/09/14 20:05:02  dwilliss
 * Seems mostly done.
 * New border styles defined
 *
 * Revision 1.6  2001/09/13 21:52:22  dwilliss
 * Fixed typo in method name
 *
 * 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.4  2001/09/13 19:07:14  dwilliss
 * Drawing functions now take a MapScale parameter
 *
 * 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_SERIALIZ_H
#include <mi32/serializ.h>
#endif

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

#ifndef INC_MI32_MCB_H
#include <mi32/mcb.h>
#endif

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


class MATTE;

//! A MATTE_CONTROLPANEL is returned by MATTE::CreateControlPanel()
//!
//! It allows you to manipulate the control panel after it was created.
//! You should never create one of these yourself.
class MATTE_CONTROLPANEL {
   public:

      void AddChangeCallback (
         McbCallbackFunc func,
         void* cbdata
         ) {
         McbAddCallback(&m_cblist, func, cbdata, 1);
         return;
         }

      void RemoveChangeCallabck (
         McbCallbackFunc func,
         void* cbdata
         ) {
         McbRemoveCallback(&m_cblist, func, cbdata, 1);
         return;
         }

      virtual void ChangeMatte (
         MATTE& matte
         ) = 0;

   protected:
      MATTE* m_matte;

      MATTE_CONTROLPANEL (
         MATTE* matte
         ) :
         m_matte(matte)
         {
         }

      virtual ~MATTE_CONTROLPANEL () {}
      
      void CallChangeCallbacks (
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      McbLIST m_cblist;
      friend class MATTE;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

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
         };
   
      //! Constructor
      MATTE();

      //! Copy Constructor
      MATTE(const MATTE&);

      //! Destructor
      virtual ~MATTE();


      // OPERATORS
      
      MATTE& operator= (
         const MATTE& rhs
         );

      //! virtual methods of SERIALIZABLE
      virtual ERRVALUE SerialRead (
         SERIALIZER& serializer
         );

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

      //! Create a control panel page
      //!
      //! Returns a pointer to a controlpanel which you can use
      //! to add a changed callback.
      //!
      //! Returns a pointer to the control panel's private data.
      //! With this pointer, you can add a callback to be called when
      //! anything on the control panel is modified, and also change 
      //! the matte being edited.
      MATTE_CONTROLPANEL* CreateControlPanel (
         MDLGPARENT form      //!< Form to create the controls in.
         );

      //! Draw the background, border and dropshadow
      //! The rectangle should be in output device coordinates and NOT include
      //! the margins, border or drop shadow.  They will all extend out from
      //! this rectangle
      ERRVALUE Draw (
         MGD::CONTEXT& gc,
         const LRECT2D& rect,
         double MapScale = 1.0,
         DRAWFLAGS flags = DRAWFLAG_None
         );

      //! Fill in the background based on background settings
      //! The rectangle should be in output device coordinates and NOT include
      //! the margins, border or drop shadow.  They will all extend out from
      //! this rectangle
      ERRVALUE DrawBackground (
         MGD::CONTEXT& gc,
         const LRECT2D& rect,
         double MapScale = 1.0,
         DRAWFLAGS flags = DRAWFLAG_None
         );

      //! Draw in the border
      //! The rectangle should be in output device coordinates and NOT include
      //! the margins, border or drop shadow.  They will all extend out from
      //! this rectangle
      ERRVALUE DrawBorder (
         MGD::CONTEXT& gc,
         const LRECT2D& rect,
         double MapScale = 1.0,
         DRAWFLAGS flags = DRAWFLAG_None
         );

      //! Draw the drop shadow
      //! The rectangle should be in output device coordinates and NOT include
      //! the margins, border or drop shadow.  They will all extend out from
      //! this rectangle
      ERRVALUE DrawDropShadow (
         MGD::CONTEXT& gc,
         const LRECT2D& rect,
         double MapScale = 1.0,
         DRAWFLAGS flags = DRAWFLAG_None
         );


      // Get Methods

      //! Return the primary background fill color
      const COLOR& GetBackgroundColor (
         ) const {
         return m_BGColor1; 
         }

      //! Return the secondary background fill color (used for gradiant fills)
      const COLOR& GetBackgroundColor2 (
         ) const {
         return m_BGColor2; 
         }

      //! Return the background fill mode
      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;
         }

      //! Get the color of the border
      const COLOR& GetBorderColor (
         ) const {
         return m_BorderColor; 
         }

      //! Get the size (in mm at output scale
      //!) of the border
      double GetBorderSize (
         ) const {
         return m_BorderSize; 
         }

      //! Get the border style
      BORDER GetBorderStyle (
         ) const {
         return m_BorderStyle; 
         }
      
      //! Get whether or not the drop shadow is drawing with a Gaussian blend.
      bool GetDropShadowBlend (
         ) const {
         return (m_DSBlend);
         }
      
      //! Get the color of the drop shadow
      const COLOR& GetDropShadowColor (
         ) const {
         return m_DSColor; 
         }

      //! Return the extents of the shadow and border (in mm at output scale
      //!)
      //! 
      //!   Computes how far outside any rectangle the drawing will extend.
      void GetExtraExtents (
         double& x1,
         double& y1,
         double& x2,
         double& y2
         ) const;

      //! Get the direction (in radians) of the drop shadow
      double GetDropShadowDirection (
         ) const {
         return m_DSDirection; 
         }

      //! Get the size (in mm at output scale) of the drop shadow
      double GetDropShadowSize (
         ) const {
         return m_DSSize; 
         }
      
      //! Return the bottom margin (in mm at output scale)
      double GetMarginBottom (
         ) const {
         return m_MarginBottom; 
         }

      //! Return the left margin (in mm at output scale)
      double GetMarginLeft (
         ) const {
         return m_MarginLeft; 
         }

      //! Return the right margin (in mm at output scale)
      double GetMarginRight (
         ) const {
         return m_MarginRight; 
         }

      //! Return the top margin (in mm at output scale)
      double GetMarginTop (
         ) const {
         return m_MarginTop; 
         }
      
      //! Return the units the user wants to see sizes in
      //! note that sizes are always stored in mm at output scale
      SCREENUNIT GetDisplayUnits (
         ) const {
         return m_SizeUnits; 
         }

      bool IsBorderRoundedRect (
         ) const {
         return m_BorderRoundRect; 
         }

      //! Determine if anything in the background or drop shadow will require
      //! it to make use of transparency effects in the display.  
      bool NeedsTransparency (
         ) const;

      // Set Methods

      //! Set the primary background fill color
      void SetBackgroundColor (
         const COLOR& color
         ) {
         m_BGColor1 = color; 
         }

      //! Set the secondary background fill color (used for gradiant fills)
      void SetBackgroundColor2 (
         const COLOR& color
         ) {
         m_BGColor2 = color; 
         }

      //! Set the background fill mode
      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;
         }
      
      //! Get the color of the border
      void SetBorderColor (
         const COLOR& color
         ) {
         m_BorderColor = color; 
         }

      //! Set the border to be a rounded rectangle.
      //! If this is set, corners of the border will be rounded.  The radius
      //! of the rounding is equal to the margin distances.
      void SetBorderIsRoundedRect (
         bool bRound
         ) {
         m_BorderRoundRect = bRound; 
         }

      //! Get the size (in mm at output scale) of the border
      void SetBorderSize (
         double size
         ) {
         m_BorderSize = size; 
         }

      //! Get the border style
      void SetBorderStyle (
         BORDER style
         ) {
         m_BorderStyle = style; 
         }

      //! Set whether or not the drop shadow is drawing with a Gaussian blend.
      void SetDropShadowBlend (
         bool blend
         ) {
         m_DSBlend = blend;
         }
      
      //! Get the color of the drop shadow
      void SetDropShadowColor (
         const COLOR& color
         ) {
         m_DSColor = color; 
         }

      //! Get the direction (in radians) of the drop shadow
      void SetDropShadowDirection (
         double dir
         ) {
         m_DSDirection = dir; 
         }

      //! Get the size (in mm at output scale) of the drop shadow
      void SetDropShadowSize (
         double size
         ) {
         m_DSSize = size; 
         }

      //! Set the bottom margin (in mm at output scale)
      void SetMarginBottom (
         double dist
         ) {
         m_MarginBottom = dist; 
         }
      
      //! Set the left margin (in mm at output scale)
      void SetMarginLeft (
         double dist
         ) {
         m_MarginLeft = dist; 
         }

      //! Set the right margin (in mm at output scale)
      void SetMarginRight (
         double dist
         ) {
         m_MarginRight = dist; 
         }

      //! Set the top margin (in mm at output scale)
      void SetMarginTop (
         double dist
         ) {
         m_MarginTop = dist; 
         }
      
      //! Set the units the user wants to see sizes in
      //! note that sizes are always stored in mm at output scale
      void SetDisplayUnits (
         SCREENUNIT units
         ) {
         m_SizeUnits = units; 
         }

      // Runtime drawing settings
      
      //! Tell the matte that the background is a solid color.
      //! This is NOT the background you want the matte to draw.  This is to
      //! allow an optimization of transparency blending effects if it is known
      //! that we're blending over a white (or other solid color) background.
      void SetSolidBackground (
         const COLOR& color
         ) {
         m_bSolidBackground = true;
         m_PageColor = color;
         return;
         }
       
      //! Clears the effects of SetSolidBackground()
      void SetDirtyBackground (
         ) {
         m_bSolidBackground = false;
         return;
         }

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

   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; //!< Units user wants to edit sizes in (always stored in mm at output res)

      COLOR m_DSColor;        //!< Color of dropshadow
      double m_DSDirection;   //!< In raidans
      double m_DSSize;
      bool m_DSBlend;      //!< Do a Gaussian blur

      COLOR m_BorderColor;
      double m_BorderSize;
      BORDER m_BorderStyle;      
      bool m_BorderRoundRect;
      MISTRING m_BorderCartoScript;

      bool m_bMarginsInset;      
      COLOR m_PageColor;
      bool m_bSolidBackground;   //!< If true, can blend with m_PageColor instead
                                 //! of doing real transparency
      
      static const SERIALIZER::ITEMDEF* SerialGetItemDef (
         SERIALIZER& serializer
         );

      friend class MATTEPRIV;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };



#endif

---