mi32/grlayout.h

Go to the documentation of this file.

#ifndef INC_MI32_GRLAYOUT_H
#define INC_MI32_GRLAYOUT_H
   
#ifndef INC_MI32_SERIALIZABLE_H
#include <mi32/serializable.h>
#endif

#ifndef INC_MI32_SERIALIZERITEM_H
#include <mi32/serializeritem.h>
#endif

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

#ifndef INC_MI32_OBSERVER_H
#include <mi32/observer.h>
#endif

#ifndef INC_MI32_UCSTRING_H
#include <mi32/ucstring.h>
#endif

#if !defined(INC_MI32_XDEFNS_H) && defined(X_NATIVE)
#include <mi32/xdefns.h>
#endif

#ifndef _VECTOR_
#include <vector> // std::vector
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT
struct MxPromptCallbackStruct;
struct UNITCONV;
class MIDIALOG;
class TRANS2D_MAPGEN;
#endif


class GRAPHICLAYOUT : public SERIALIZABLE {
   public:

   class ITEM;
   typedef MILIST<ITEM*> ITEMLIST;
   typedef ITEMLIST::ITERATOR ITERATOR;
   typedef ITEMLIST::CONST_ITERATOR CONST_ITERATOR;

   
   class OBSERVER : public OBSERVER_BASE {
      public:
         OBSERVER (
            GRAPHICLAYOUT& layout
            ) :
            OBSERVER_BASE(layout.m_Observers)
            {
            }

         virtual ~OBSERVER (
            ) {
            }

         virtual void OnRedraw (
            ) {
            return;
            }
      };

   class OBSERVERMANAGER : public SUBJECT<OBSERVER> {
      public:
         void Redraw (
            );
      
      };

   class NAMEDTEXTSTYLE : public TEXTSTYLE {
      public:
         struct TABSTOP {
            enum TYPE {
               TYPE_Left = 0,
               TYPE_Right,
               TYPE_Center,
               TYPE_Decimal
               };

            INT32 position;
            UINT8 type;    
            char padChar;  
            char spare1;
            char spare2;   
            };

         NAMEDTEXTSTYLE();
         NAMEDTEXTSTYLE(const NAMEDTEXTSTYLE&);
         ~NAMEDTEXTSTYLE();

         NAMEDTEXTSTYLE& operator= (
            const NAMEDTEXTSTYLE& rhs
            );

         bool operator== (
            const NAMEDTEXTSTYLE& rhs
            ) const {
            return (CompareIgnoringName(rhs) && ucstrcmp(m_name, rhs.m_name) == 0);
            }


         bool operator!= (
            const NAMEDTEXTSTYLE& rhs
            ) const {
            return (!(*this == rhs));
            }
/*
         void CompareBaseClass (
            const TEXTSTYLE* style
            ) {
            if (style != 0)   *(static_cast<TEXTSTYLE*>(this)) = *style;
            }
            */

         bool CompareIgnoringName (
            const NAMEDTEXTSTYLE& rhs
            ) const;


         void FreeData() { 
            MmFree(m_TabStops); 
            m_NumTabStops = 0;
            }

         const MIUNICODE* GetName (
            ) const {
            return (m_name);
            }

         INT32 GetNumTabStops (
            ) const {
            return (m_NumTabStops);
            }

         const TABSTOP& GetTabStop (
            INT32 num
            ) const {
            return (m_TabStops[num]);
            }

         void SetName (
            const MIUNICODE* name
            ) {
            ucstrcpy(m_name, name);
            }

         void SetStyle (
            const TEXTSTYLE* style
            ) {
            if (style != 0)   *(static_cast<TEXTSTYLE*>(this)) = *style;
            }

         INT32 TabStopAdd (
            const TABSTOP& stop
            );

         INT32 TabStopAdd (
            INT32 pos,
            TABSTOP::TYPE type = TABSTOP::TYPE_Left,
            char padChar = 0
            );

         void TabStopRemove (
            INT32 TabStopNum
            );

         void TabStopRemoveAll (
            ) {
            m_NumTabStops = 0;
            MmFree(m_TabStops);
            }

         void TabStopMove (
            INT32 TabStopNum,
            INT32 NewPos,
            bool bSort = true    
            );
         
         void SortTabStops();

      private:
         #ifndef GENERATING_DOXYGEN_OUTPUT
         MIUNICODE m_name[64];
         UINT32 m_NumTabStops;
         TABSTOP* m_TabStops;

         void Copy (
            const NAMEDTEXTSTYLE& rhs
            );

         friend class GRAPHICLAYOUT;
         #endif // GENERATING_DOXYGEN_OUTPUT
      };


   class TEXTBLOCK {
      public:

         static const SERIALIZERITEM* GetSerialItemDef (
            );

         TEXTBLOCK (
            );

         TEXTBLOCK (
            const MIUNICODE* str
            );

         TEXTBLOCK (
            const TEXTBLOCK& rhs
            );

         ~TEXTBLOCK (
            ) {
            }

         void ClearSizeKnown (
            ) {
            m_bSizeKnown = false;
            return;
            }

         const DPOINT2D& ComputeSize (
            const NAMEDTEXTSTYLE* style,
            DOUBLE XStart = 0.0           
            );

         void Draw (
            MGD::CONTEXT*,
            const DPOINT2D& basepoint,
            TEXTBASEORIGIN baseorigin,
            const NAMEDTEXTSTYLE* style,
            double XOffset = 0.0    
            );

         const DPOINT2D& GetSize (
            ) const {
            return (m_size);
            };

         const MISTRING& GetString (
            ) const {
            return (m_str);
            }

         bool IsSizeKnown (
            ) const {
            return (m_bSizeKnown);
            }

         void SetString (
            const MISTRING& str
            );

         const DPOINT2D& WordWrap (
            DOUBLE width,
            const NAMEDTEXTSTYLE* style,
            DOUBLE xoffset = 0.0    
            );

      private:
         void FillInBlock (
            MGD::TEXTBLOCK& block,
            const NAMEDTEXTSTYLE* style = 0,
            double XOffset = 0.0
            );
         
         void SetupTabStops (
            MISTRING& str,
            const NAMEDTEXTSTYLE& style,
            double XOffset = 0.0
            );

         MISTRING m_str;         
         MISTRING m_formatted;   
         DPOINT2D m_size;
         double m_WrapWidth;
         bool m_bSizeKnown;
         bool m_bDoWordWrap;
      };

   class ITEMPROPERTYSHEET {
#ifndef WIN32_NATIVE
      public:
         ITEMPROPERTYSHEET (
            GRAPHICLAYOUT& grlayout,
            MIDIALOG* dialog
            ) :
            m_grlayout(grlayout),  
            m_dialog(dialog)  
            {
            }

         virtual ~ITEMPROPERTYSHEET() {
            }

         virtual const char* GetLabel () const = 0;

         virtual Widget CreateForm (
            Widget parent,
            bool isMulti
            ) = 0;

         virtual void OnApply () = 0;

         virtual void OnOpen (
            ) {
            }

         virtual ERRVALUE AddItem (
            ITEM* item
            ) = 0;

         virtual void OnSetDistanceUnits (
            const UNITCONV*
            ) { }

         virtual void OnChangeTextStyle (
            int 
            ) { }

         void SetApplySensitive (
            bool sensitive = true
            );

      protected:


         void SetPromptModifyCallback (
            Widget prompt,
            bool& bModifiedFlag
            );

         void SetXeTextModifyCallback (
            Widget Widget,
            bool& bModifiedFlag
            );

         Widget CreateTextStyleOptionMenu (
            Widget parent,
            int DefaultStyleNum,
            Arg* args,
            int numargs
            );

      private:
         static void PCB_PromptModify (         
            MxPromptCallbackStruct*,
            void* cbdata
            );

         static void CB_ChangeStyle (
            Widget widget,
            void* cbdata,
            void*
            );

         static void CB_XeTextModify (
            Widget widget,
            void* cbdata,
            void*
            );

         MIDIALOG* m_dialog;
         GRAPHICLAYOUT& m_grlayout;
#endif

      };      

   class ITEMPOSITION {
      public:

         ITEMPOSITION (
            );

         ITEMPOSITION (
            const ITEMPOSITION& rhs
            );

         virtual ~ITEMPOSITION (
            ) { 
            }

         int Compare (
            const ITEMPOSITION& rhs
            ) const;

         const INT32 GetGroup (
            ) const {
            return (m_Group);
            }

         int GetLeftGuide (
            ) const {
            return m_LeftGuide;
            }

         DOUBLE GetLeftOffset (
            ) const {
            return m_LeftOffset;
            }

         int GetRightGuide (
            ) const {
            return m_RightGuide;
            }

         DOUBLE GetRightOffset (
            ) const {
            return m_RightOffset;
            }

         INT32 GetTopGuide (
            ) const {
            return m_TopGuide;
            }

         DOUBLE GetTopOffset (
            ) const {
            return m_TopOffset;
            }

         const DRECT2D& GetRect (
            ) const {
            return (m_rect);
            }

         void GetRect (
            DRECT2D& rect
            ) {
            rect = GetRect();    
            return;
            }

         void SetGroup (
            INT32 group
            ) { m_Group = group; }

      protected:
         INT32 m_LeftGuide;
         INT32 m_RightGuide;
         INT32 m_TopGuide;    
         DOUBLE m_TopOffset;
         DOUBLE m_LeftOffset;
         DOUBLE m_RightOffset;
         DRECT2D m_rect;
         INT32 m_Group;    

         friend class GRAPHICLAYOUT;
         friend class ITEM;
      };

   class ITEM : public ITEMPOSITION, SERIALIZABLE {
      public:

         ITEM (
            GRAPHICLAYOUT& parent
            );

         ITEM (
            const ITEM& rhs,
            GRAPHICLAYOUT& parent
            );

         virtual ~ITEM();

         virtual void ComputeRect (
            DRECT2D& rect
            ) = 0;

         virtual ITEM* Copy (
            GRAPHICLAYOUT& parent
            ) const = 0;

         virtual ITEMPROPERTYSHEET* CreatePropertySheet (
            GRAPHICLAYOUT& grlayout,
            MIDIALOG* dialog
            ) = 0;
            
         void Draw (
            MGD::CONTEXT* gc,       
            const DRECT2D& rect,    
            const TRANS2D_MAPGEN* trans,
            double scale
            ) { v_Draw(gc,rect,trans,scale); }

         void Draw (
            MGD::CONTEXT* gc,             
            bool bSelected = false, 
            const TRANS2D_MAPGEN* trans = 0,
            double scale = 1.0
            );

         DOUBLE GetHeight (
            ) const {
            return (m_height);
            }

         const NAMEDTEXTSTYLE* GetTextStyle (
            ) const {
            return (m_parent.GetTextStyle(m_TextStyleNum));
            }

         int GetTextStyleNumber (
            ) const {
            return (m_TextStyleNum);
            }

         DOUBLE GetWidth (
            ) const {
            return (m_width);
            }

         bool IsSelected (
            ) const {
            return (m_bSelected);
            }

         bool IsSorted (
            ) const;

         bool IsInLayout (
            ) const;

         void Move (
            DOUBLE dx,  
            DOUBLE dy,  
            bool bSnap  
            ) {
            m_parent.MoveItem(this, dx, dy, bSnap);
            return;
            }

         void Move (
            const DRECT2D& rect,    
            bool bSnap  
            ) {
            m_parent.MoveItem(this, rect, bSnap);
            return;
            }

         void MoveBelow (
            const ITEMPOSITION& above
            ) {
            m_rect.yinit = above.m_rect.yinit + .0001;
            if (IsInLayout()) m_parent.SetLayoutNeeded();
            return;
            }

         virtual const SERIALIZERITEM* SerialGetItemDef (
            SERIALIZER& serializer
            ) const = 0;

         virtual const char* SerialGetTagName (
            ) const = 0;

         virtual ERRVALUE SerialRead (
            SERIALIZER& serializer
            );

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

         void SetAttachments (
            const ITEMPOSITION& newpos
            ) {
            m_LeftGuide = newpos.m_LeftGuide;
            m_RightGuide = newpos.m_RightGuide;
            m_TopGuide = newpos.m_TopGuide;
            m_LeftOffset = newpos.m_LeftOffset;
            m_RightOffset = newpos.m_RightOffset;
            m_TopOffset = newpos.m_TopOffset;
            m_rect = newpos.m_rect;
            m_bPosKnown = true;
            if (IsInLayout()) m_parent.SetLayoutNeeded();
            return;
            }

         void SetDefaultLocation (
            );

         void SetHidden (
            bool bHidden
            ) {
            m_bHidden = bHidden;
            }

         void SetLeftOffset (
            DOUBLE offset
            ) {
            m_LeftOffset = offset;
            if (IsInLayout()) m_parent.SetLayoutNeeded();
            return;
            }

         void SetLeftPosition (
            INT32 GuideNum,
            DOUBLE offset
            ) {
            m_LeftGuide = GuideNum;
            m_LeftOffset = offset;
            if (IsInLayout()) m_parent.SetLayoutNeeded();
            return;
            }

         
         void SetRightPosition (
            INT32 GuideNum,
            DOUBLE offset
            ) {
            m_RightGuide = GuideNum;
            m_RightOffset = offset;
            if (IsInLayout()) m_parent.SetLayoutNeeded();
            return;
            }

         void SetSelected (
            bool selected
            ) {
            m_bSelected = selected;
            return;
            }

         void SetSize (
            DOUBLE height,
            DOUBLE width
            ) {
            if (height == m_height && width == m_width) return;
            m_height = height;
            m_width = width;
            if (IsInLayout()) m_parent.SetLayoutNeeded();
            return;
            }

         void SetTextStyleNumber (
            int num
            ) {
            if (num != m_TextStyleNum) {
               m_TextStyleNum = num;
               m_bSizeKnown = false;
               if (IsInLayout()) m_parent.SetLayoutNeeded();
               }
            }

         void SetTopOffset (
            DOUBLE offset
            ) {
            m_TopOffset = offset;
            if (IsInLayout()) m_parent.SetLayoutNeeded();
            return;
            }

         void SetTopPosition (
            INT32 GuideNum,      
            DOUBLE offset
            ) {
            m_TopGuide = GuideNum;
            m_TopOffset = offset;
            if (IsInLayout()) m_parent.SetLayoutNeeded();
            return;
            }

         virtual bool UsesTransparency (
            const MGD::CONTEXT* gc = 0 
            ) const;

         static const SERIALIZERITEM* GetSerialItemDef (
            );

      protected:
         bool m_bSizeKnown;
         GRAPHICLAYOUT& m_parent;

      private:
         INT32 m_TextStyleNum;
         bool m_bHidden;      
         bool m_bPosKnown;
         bool m_bSelected;
         DOUBLE m_height;
         DOUBLE m_width;
         ITEMLIST::ITERATOR m_self;    

         virtual void v_Draw (
            MGD::CONTEXT* gc,       
            const DRECT2D& rect,    
            const TRANS2D_MAPGEN* trans,
            double scale
            ) = 0;

         friend class GRAPHICLAYOUT;
      };


      class SUSPEND_REDRAW {
         public:
            SUSPEND_REDRAW (
               GRAPHICLAYOUT& layout
               ) :
               m_layout(layout)
               {
               m_layout.RedrawSuspend();
               }  

            ~SUSPEND_REDRAW (
               ) {
               m_layout.RedrawResume();
               }  

         private:
            GRAPHICLAYOUT& m_layout;
         };

      static const SERIALIZERITEM* GetSerialItemDef (
         );

      GRAPHICLAYOUT (
         );       

      GRAPHICLAYOUT (
         const GRAPHICLAYOUT& rhs
         );

      virtual ~GRAPHICLAYOUT();

      static void InstallItemType (
         const char* name,                            
         int (*Construct)(GRAPHICLAYOUT&, ITEM**)     
         );

      ITERATOR Begin (
         ) {
         return (m_ItemList.Begin());
         }

      CONST_ITERATOR Begin (
         ) const {
         return (m_ItemList.Begin());
         }

      int AddHGuide (
         DOUBLE value
         );

      void AddItem (
         ITEM* item
         );

      int AddTextStyle (
         const NAMEDTEXTSTYLE& style
         );

      int AddVGuide (
         DOUBLE value
         );

      void ComputeItemAttachments (
         const ITEM* item,
         DRECT2D& rect,
         ITEMPOSITION& newpos,   
         const ITEM *&ItemAbove,
         bool bSnap = true
         ) const;

      ERRVALUE Copy (
         const GRAPHICLAYOUT& rhs
         );

      int DoLayout (
         );

      int Draw (
         MGD::CONTEXT* gc,
         const DRECT2D* rect = 0,
         const TRANS2D_MAPGEN* trans = 0,
         double scale = 1.0
         );

      void DrawItemHandles (
         MGD::CONTEXT* gc,
         const ITEMPOSITION& position,
         const DRECT2D& rect,
         const GRAPHICLAYOUT::ITEM* ItemAbove,
         const DPOINT2D& SelectedDelta,
         double scale = 1.0
         ) const;

      ITERATOR End (
         ) {
         return (m_ItemList.End());
         }

      CONST_ITERATOR End (
         ) const {
         return (m_ItemList.End());
         }

      const LINESTYLE& GetBorderStyle (
         ) const {
         return (m_BorderStyle);
         }

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

      bool GetDrawBackground (
         ) const {
         return (m_bDrawBackground);
         }

      bool GetDrawBorder (
         ) const {
         return (m_bDrawBorder);
         }

      bool GetDrawDropShadow (
         ) const {
         return (m_bDrawDropShadow);
         }

      const COLOR& GetDropShadowColor (
         ) const {
         return (m_DropShadowColor);
         }

      double GetDropShadowDirection (
         ) const {
         return (m_DropShadowDirection);
         }

      double GetDropShadowDistance (
         ) const {
         return (m_DropShadowDistance);
         }

      DOUBLE GetHGuide (
         int GuideNum
         ) const {
         if (GuideNum < 0 || (UINT32)GuideNum >= m_NumHGuides) return 0;
         return m_HGuides[GuideNum];
         }

      DOUBLE GetHeight (
         ) const {   
         return (m_Extents.GetHeight());
         }

      INT32 GetHGuideFromLocation (
         const DPOINT2D& point,
         int tolerance = 2    
         ) const;

      INT32 GetVGuideFromLocation (
         const DPOINT2D& point,
         int tolerance = 2    
         ) const;


      ITEM* GetItemFromLocation (
         const DPOINT2D& point
         );

      const ITEM* GetItemFromLocation (
         const DPOINT2D& point
         ) const;

      int GetNumHGuides (
         ) const {
         return m_NumHGuides;
         }

      int GetNumTextStyles (
         ) const {
         return m_TextStyle.size();
         }

      int GetNumVGuides (
         ) const {
         return m_NumVGuides;
         }

      const NAMEDTEXTSTYLE* GetTextStyle (
         int num
         ) const {
         if (num < 0 || num >= GetNumTextStyles()) return NULL;
         return (&m_TextStyle[num]);
         }

      void GetTextStyle (
         int num,
         TEXTSTYLE& style
         ) const {
         style = m_TextStyle[num];
         return;
         }

      void GetTextStyle (
         int num,
         NAMEDTEXTSTYLE& style
         ) const {
         style = m_TextStyle[num];
         return;
         }


      const MIUNICODE* GetTextStyleName (
         int num
         ) const {
         if (num < 0 || num >= GetNumTextStyles()) return NULL;
         return (m_TextStyle[num].m_name);
         }

      void GetTextStyles (
         std::vector<NAMEDTEXTSTYLE>& styles
         ) {
         styles.clear();
         for (int i = 0 ; i < GetNumTextStyles() ; ++i) styles.push_back(m_TextStyle[i]);
         }

      DOUBLE GetVGuide (
         int GuideNum
         ) const {
         if (GuideNum < 0 || (UINT32)GuideNum >= m_NumVGuides) return 0;
         return m_VGuides[GuideNum];
         }

      DOUBLE GetWidth (
         ) const { 
         return (m_Extents.GetWidth());
         }

      bool IsLayoutNeeded (
         ) const {
         return (m_bLayoutNeeded);
         }

      void MoveItem (
         ITEM* item,       
         DOUBLE dx,        
         DOUBLE dy,        
         bool bSnap        
         );


      void MoveItem (
         ITEM* item,                   
         const DRECT2D& location,      
         bool bSnap                    
         );

      void RedrawSuspend (
         ) {
         ++m_RedrawSuspended;
         return;
         }

      void RedrawResume (
         ) {
         if (m_RedrawSuspended) --m_RedrawSuspended;
         if (!m_RedrawSuspended && m_bRedrawNeeded) {
            Redraw();   
            }
         return;
         }

      bool RemoveHGuide (
         int GuideNum
         );

      void RemoveItem (
         ITEM* item
         );
      
      bool RemoveVGuide (
         int GuideNum
         );

      virtual const SERIALIZERITEM* SerialGetItemDef (
         SERIALIZER& serializer
         ) const;

      virtual const char* SerialGetTagName (
         ) const {
         return "GRAPHICLAYOUT";
         }

      virtual ERRVALUE SerialRead (
         SERIALIZER& serializer
         );

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

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

      void SetBorderStyle (
         const LINESTYLE& style
         ) {
         m_BorderStyle = style;
         return;
         }

      void SetDrawBackground (
         bool DrawBackground
         ) {
         m_bDrawBackground = DrawBackground;
         return;
         }

      void SetDrawBorder (
         bool DrawBorder
         ) {
         m_bDrawBorder = DrawBorder;
         return;
         }

      void SetDrawDropShadow (
         bool DrawDropShadow
         ) {
         m_bDrawDropShadow = DrawDropShadow;
         return;
         }

      void SetDropShadowColor (
         const COLOR& color
         )  {
         m_DropShadowColor= color;
         return;
         }

      void SetDropShadowDirection (
         double angle
         )  {
         m_DropShadowDirection = angle;
         return;
         }

      void SetDropShadowDistance (
         double distance
         )  {
         m_DropShadowDistance = distance;
         return;
         }

      void SetHGuide (
         int GuideNum,
         DOUBLE value
         );

      void SetLayoutNeeded (
         ) {
         m_bLayoutNeeded = m_bRedrawNeeded = true;
         Redraw();   
         }

      void SetRedrawNeeded (
         ) {
         m_bRedrawNeeded = true;
         Redraw();   
         }

      /*
      void SetTextStyle (
         int num,
         const TEXTSTYLE& style
         );
         */

      void SetTextStyle (
         int num,
         const NAMEDTEXTSTYLE& style
         );

      void SetTextStyleName (
         int num,
         const MIUNICODE* name
         ) {
         if (num < 0 || num >= GetNumTextStyles()) return;
         ucstrcpy(m_TextStyle[num].m_name, name);
         return;
         }

      ERRVALUE SetTextStyles (
         const std::vector<NAMEDTEXTSTYLE>& styles
         );

      ERRVALUE SetTextStyles (
         const std::vector<NAMEDTEXTSTYLE>& styles,
         const SIMPLE_ARRAY<INT32>& trans
         );


      void SetVGuide (
         int GuideNum,
         DOUBLE value
         );

      bool UsesTransparency (
         const MGD::CONTEXT* gc = 0 
         ) const;

   protected:


   private:
      
      friend class OBSERVER;     

      struct ITEMTYPE {
         const char* m_name;
         int (*m_Construct)(GRAPHICLAYOUT&, ITEM**);
         };

      static ERRVALUE SerializerCB_Item (
         SERIALIZER& serializer,
         const SERIALIZERITEM *itemdef,
         void* cbdata,
         SERIALIZERITEM::ACTION action
         );

      static ERRVALUE SerializerCB_NamedTextStyle (
         SERIALIZER& serializer,
         const SERIALIZERITEM* itemdef,
         void* cbdata,
         SERIALIZERITEM::ACTION action
         );

      bool m_bLayoutNeeded;
      bool m_bRedrawNeeded;
      UINT32 m_NumHGuides;
      DOUBLE* m_HGuides;
      UINT32 m_NumVGuides;
      DOUBLE* m_VGuides;
      DRECT2D m_Extents;
      UINT32 m_RedrawSuspended;
      OBSERVERMANAGER m_Observers;
      ITEMLIST m_ItemList;
      LINESTYLE m_BorderStyle;
      bool m_bDrawBackground;
      bool m_bDrawBorder;
      bool m_bDrawDropShadow;
      COLOR m_DropShadowColor;
      COLOR m_BGColor;
      double m_DropShadowDirection;
      double m_DropShadowDistance;
      std::vector<NAMEDTEXTSTYLE> m_TextStyle;
      INT32 m_MaxGroup;

      static SIMPLE_ARRAY<ITEMTYPE> s_ItemTypes;
      
      GRAPHICLAYOUT& operator= (
         const GRAPHICLAYOUT& rhs
         );


      void DrawHandle (
         MGD::CONTEXT* gc,
         const DPOINT2D& GuideEnd,
         const DPOINT2D& ItemEnd
         ) const;

      void Free (
         );

      void SortHGuides (
         );

      void SortVGuides (
         );

      void Redraw (
         );

   };


#endif   // INC_MI32_GRLAYOUT_H

---