grlayout.h

Go to the documentation of this file.

/**
 * \file grlayout.h <mi32/grlayout.h>
 * \brief GRAPHICLAYOUT class
 *
 * This class was designed for the rewrite of legends.  It should be generic enough to use 
 * for other things too (perhaps the rewrite for forms?)
 *
 * \if NODOC
 * $Id: grlayout.h_v 1.32 2004/04/01 20:22:30 dwilliss Exp $
 *
 * $Log: grlayout.h_v $
 * Revision 1.32  2004/04/01 20:22:30  dwilliss
 * Change how NAMEDTEXTSTYLES are stored to use std::vector
 *
 * Revision 1.31  2004/02/12 22:05:12  dwilliss
 * Deprecate old MGD
 *
 * Revision 1.30  2003/09/15 19:31:46  scowan
 * *** empty log message ***
 *
 * Revision 1.29  2003/09/15 13:49:56  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.28  2003/06/12 20:25:48  scowan
 * nc.
 *
 * Revision 1.27  2002/12/11 16:29:22  scowan
 * get text styles now returns void.
 *
 * Revision 1.26  2002/05/14 14:23:39  dwilliss
 * UsesTransparency now takes a MGD::CONTEXT
 *
 * Revision 1.25  2002/05/06 22:44:04  dwilliss
 * Added group settings for planned addition of item grouping
 *
 * Revision 1.24  2002/04/22 16:50:11  dwilliss
 * Added UsesTransparency method
 *
 * Revision 1.23  2002/03/15 15:11:56  dwilliss
 * *** empty log message ***
 *
 * Revision 1.22  2002/03/08 17:40:02  dwilliss
 * Had to change methods to Get/Set styles to use std::vector instead of
 * SIMPLE_ARRAY.  TEXTSTYLE now prohibits memset amd memcpy
 *
 * Revision 1.21  2002/03/08 15:27:57  dwilliss
 * Structure name change for new MGD
 *
 * Revision 1.20  2001/12/28 21:34:06  mju
 * SerialWrite now const.
 *
 * Revision 1.19  2001/10/01 20:32:59  dwilliss
 * Added a flag to TabStopMove to not sort tabs after moving
 * Made SortTabStops public
 *
 * Revision 1.18  2001/10/01 20:12:58  dwilliss
 * Added a method to remove all tab stops from a named text style
 *
 * Revision 1.17  2001/02/28 21:32:35  dwilliss
 * Added new method to items
 *
 * Revision 1.16  2000/12/27 17:37:08  dwilliss
 * NAMEDTEXTSTYLE members are all private now with methods to access
 *
 * Revision 1.15  2000/12/27 14:52:41  dwilliss
 * I guess scowan already fixed it.
 *
 * Revision 1.14  2000/12/27 14:43:54  scowan
 * Fixed MAC errors.
 *
 * Revision 1.13  2000/12/26 20:41:25  dwilliss
 * Changes to text blocks
 *
 * Revision 1.12  2000/12/18 20:53:53  dwilliss
 * Added new SetTextStyles method
 *
 * Revision 1.11  2000/10/13 15:58:30  dwilliss
 * Must use "friend class NAME", not "friend NAME"
 *
 * Revision 1.10  2000/09/26 20:26:17  dwilliss
 * *** empty log message ***
 *
 * Revision 1.9  2000/09/20 21:47:34  dwilliss
 * *** empty log message ***
 *
 * Revision 1.8  2000/09/15 17:19:54  dwilliss
 * Changed all coordinate and size things to doubles
 *
 * Revision 1.7  2000/09/05 22:37:58  dwilliss
 * Changed text block's SetString to take a const MISTRING instead of UNICODE*
 *
 * Revision 1.6  2000/08/23 14:26:31  dwilliss
 * Made some method parameters ocnst
 *                             const
 *
 * Revision 1.5  2000/08/22 22:16:42  dwilliss
 * *** empty log message ***
 *
 * Revision 1.4  2000/08/21 20:45:52  dwilliss
 * API somewhat finalized now
 *
 * Revision 1.3  2000/08/11 16:58:17  dwilliss
 * Still in development
 *
 * Revision 1.2  2000/07/17 13:58:04  dwilliss
 * *** empty log message ***
 *
 * Revision 1.1  2000/07/07 21:41:28  dwilliss
 * Initial revision
 *
 * \endif
 */

//! Design goal...
//!
//!
//!   Need two classes.   the GRAPHICLAYOUT class keeps track of positions
//! of things and calls generic drawing methods but know nothing about X
//!
//!   Need another class which takes a pointer or reference to a 
//! GRAPHICLAYOUT and handles all the user input associated with
//! editing one.
//! GRAPHICLAYOUT should be SERIALIZABLE
//! For simplicity, everything's vertical position is recorded as an offset
//! from either...
//!      a) the item above it
//!      b) a guide
//! All horizontal positions are recorded as an offset from a guide
//!      If I end up using this for the rewrite of forms later, this may
//!      have to be extended to allow things to be tacked onto the end
//!      of other things at the same "Y" position.  Shouldn't be too hard.
//!
//!   Sizes and distances are defined as "points at layout map scale"
//! If drawing to something where "layout scale" is meaningless, treat them as pixels.



#ifndef INC_MI32_GRLAYOUT_H
#define INC_MI32_GRLAYOUT_H
   
#ifndef INC_MI32_SIMPLEAR_H
#include <mi32/simplear.h>
#endif

#ifndef INC_MI32_MILIST_H
#include <mi32/milist.h>
#endif

#ifndef INC_MI32_SERIALIZ_H
#include <mi32/serializ.h>
#endif

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

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

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

#ifndef INC_MI32_RECT_H
#include <mi32/rect.h>
#endif

#ifndef WIN32_NATIVE
#include <mi32/xdefns.h>
#endif

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

struct MxPromptCallbackStruct;
struct UNITCONV;
class MIDIALOG;


class GRAPHICLAYOUT : public SERIALIZABLE {
   public:

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

   //! This is a base class that any class wishing to be notified
   //! of changes to a GRAPHICLAYOUT may derive itself from.
   
   class OBSERVER : public OBSERVER_BASE {
      public:
         OBSERVER (
            GRAPHICLAYOUT& layout
            ) :
            OBSERVER_BASE(layout.m_Observers)
            {
            }

         virtual ~OBSERVER (
            ) {
            }

         //! Called whenever something causes us to need to redraw.
         virtual void OnRedraw (
            ) {
            return;
            }
      };

   class OBSERVERMANAGER : public SUBJECT<OBSERVER> {
      public:
         //! Call redraw methods
         void Redraw (
            );
      
      };

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

            INT32 position;
            UINT8 type;    //!< Would make an enum, but sizeof() important.
            char padChar;  //!< ie, ' ', '.', '-', etc...
            char spare1;
            char spare2;   //!< so sizeof(TABSTOP) is divisable by sizeof(INT32)
            };

         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;
            }
            */

         //! Compares this style to another one, ignoring the name.
         //! Returns true if the two are the same.
         bool CompareIgnoringName (
            const NAMEDTEXTSTYLE& rhs
            ) const;

         //! Frees the tab stop information.  Necessary because we store have to store these
         //! things in a plain old array which we realloc.

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

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

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

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

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

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

         //! Add a new tabstop.  
         //!Returns stop number or error < 0
         INT32 TabStopAdd (
            const TABSTOP& stop
            );

         //! Add a new tabstop.  
         //!Returns stop number or error < 0
         INT32 TabStopAdd (
            INT32 pos,
            TABSTOP::TYPE type = TABSTOP::TYPE_Left,
            char padChar = 0
            );

         //! Remove a tabstop given it's index
         void TabStopRemove (
            INT32 TabStopNum
            );

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

         void TabStopMove (
            INT32 TabStopNum,
            INT32 NewPos,
            bool bSort = true    //!< Resort the tab stops after the move
            );
         
         void SortTabStops();

      private:
         #ifndef GENERATING_DOXYGEN_OUTPUT
         UNICODE 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 SERIALIZER::ITEMDEF* GetSerialItemDef (
            );

         TEXTBLOCK (
            );

         TEXTBLOCK (
            const UNICODE* str
            );

         TEXTBLOCK (
            const TEXTBLOCK& rhs
            );

         ~TEXTBLOCK (
            ) {
            }

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

         const DPOINT2D& ComputeSize (
            const NAMEDTEXTSTYLE* style,
            DOUBLE XStart = 0.0           //!< Starting location relative to left guide (for tabs)
            );

         void Draw (
            MGD::CONTEXT*,
            const DPOINT2D& basepoint,
            TEXTBASEORIGIN baseorigin,
            const NAMEDTEXTSTYLE* style,
            double XOffset = 0.0    //!< Left margin relateive to base point
            );

         //! Get the size of the block.
         //! Must have called ComputeSize() or WordWrap() first.
         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    //!< offset into tabs
            );

      private:
         void FillInBlock (
            MGD::TEXTBLOCK& block,
            const NAMEDTEXTSTYLE* style = 0,
            double XOffset = 0.0
            );
         
         //! Sets the given string to the codes needed to set tabstops for
         //! a given text style
         void SetupTabStops (
            MISTRING& str,
            const NAMEDTEXTSTYLE& style,
            double XOffset = 0.0
            );

         MISTRING m_str;         //!< Raw string, not word-wrapped
         MISTRING m_formatted;   //!< Temp string.  tab setting codes + (m_str or m_wrapped)
         DPOINT2D m_size;
         double m_WrapWidth;
         bool m_bSizeKnown;
         bool m_bDoWordWrap;
      };

   //! This class is used to create "property sheets" for various element types.
   //! This is only used by the GUI editor.   
   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 (
            UNITCONV* conv
            )  {
            return;              
            }

         virtual void OnChangeTextStyle (
            int StyleNum
            )  {
            return;              
            }

         void SetApplySensitive (
            bool sensitive = true
            );

      protected:


         //! Setup a modify callback for an MxPrompt.
         //! The (bool*) passed in should point to a bool which will be set to true if a value changes.
         void SetPromptModifyCallback (
            Widget prompt,
            bool& bModifiedFlag
            );

         void SetXeTextModifyCallback (
            Widget Widget,
            bool& bModifiedFlag
            );

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

      private:
         //! Callback that derived class can attach to a prompt so that a bool
         //! value will be set to true when a value is edited.
         //! Pass a pointer to the bool memeber for callback data
         //! Also pass 
         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 (
            );

         //! Copy consturctor
         ITEMPOSITION (
            const ITEMPOSITION& rhs
            );

         virtual ~ITEMPOSITION (
            ) { 
            }

         //! Compare two positions for item sorting
         //! Returns -1 if *this < rhs, 0 if this == rhs, 1 if *this > rhs
         int Compare (
            const ITEMPOSITION& rhs
            ) const;

         //! Get the group number of the item (0 if not part of a group)
         const INT32 GetGroup (
            ) const {
            return (m_Group);
            }

         //! Get the left guide number.
         //! Guide -1 means it's "floating" in that direction.  Things are allowed
         //! to float on either left or right, but not both.
         int GetLeftGuide (
            ) const {
            return m_LeftGuide;
            }

         //! Return the offset to the left guide (in points).
         //! Meaningless if GetLeftGuide() returns -1
         DOUBLE GetLeftOffset (
            ) const {
            return m_LeftOffset;
            }

         //! Get the right guide number.
         //! Guide -1 means it's "floating" in that direction.  Things are allowed
         //! to float on either left or right, but not both.
         int GetRightGuide (
            ) const {
            return m_RightGuide;
            }

         //! Return the offset to the right guide (in points).
         //! Meaningless if GetRightGuide() returns -1
         DOUBLE GetRightOffset (
            ) const {
            return m_RightOffset;
            }

         //! Get the top guide number.
         //! Guide -1 means it's attached to the item "above" it (which 
         //! you can get with GetTopItem()
         INT32 GetTopGuide (
            ) const {
            return m_TopGuide;
            }

         //! Return the offset to the item or guide above us (in points).
         DOUBLE GetTopOffset (
            ) const {
            return m_TopOffset;
            }

         //! Get the size rectangle for the item.
         const DRECT2D& GetRect (
            ) const {
            return (m_rect);
            }

         void GetRect (
            DRECT2D& rect
            ) {
            rect = GetRect();    //! Use other method
            return;
            }

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

      protected:
         INT32 m_LeftGuide;
         INT32 m_RightGuide;
         INT32 m_TopGuide;    //!< if -1, relateive to m_pPrev
         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:

         //! Constructor automatically installs item in the layout.
         //! but do we want it to?  Serial Read wants to have it at
         //! the end. Normal interactive use, we want to put it at
         //! current insert position.  Perhaps layout should know
         //! insert position so we can install there by default.
         ITEM (
            GRAPHICLAYOUT& parent
            );

         //! Copy constructor (but with copy owned by a different parent)
         ITEM (
            const ITEM& rhs,
            GRAPHICLAYOUT& parent
            );

         //! Destructor automatically removes item from the layout
         virtual ~ITEM();

         //! Compute the size of the item.
         //! Should compute a default rectangle which will be used if
         //! the item has not been resized.
         //! Will only be called if m_bSizeKnown is false
         virtual void ComputeRect (
            DRECT2D& rect
            ) = 0;

         //! Make a copy of this item.  Copy will be placed in another layout
         virtual ITEM* Copy (
            GRAPHICLAYOUT& parent
            ) const = 0;

         virtual ITEMPROPERTYSHEET* CreatePropertySheet (
            GRAPHICLAYOUT& grlayout,
            MIDIALOG* dialog
            ) = 0;
            
         //! Draw the item.
         //! Derived class overrides this
         virtual void Draw (
            MGD::CONTEXT* gc,       //!< GC to use
            const DRECT2D& rect,    //!< Where to draw
            const TRANSPARM* trans,
            double scale
            ) = 0;

         //! Draw the item at its current location (possibly highlighting it as selected)
         void Draw (
            MGD::CONTEXT* gc,             //!< GC to use
            bool bSelected = false, //!< Draw as selected if true
            const TRANSPARM* trans = 0,
            double scale = 1.0
            );

         //! Return the height that the item claims it wants.
         //! This could be different from GetRect().height, but not likely
         DOUBLE GetHeight (
            ) const {
            return (m_height);
            }

         //! Get a const pointer to the text style for this item.
         const NAMEDTEXTSTYLE* GetTextStyle (
            ) const {
            return (m_parent.GetTextStyle(m_TextStyleNum));
            }

         //! Get the text style number for this item.
         int GetTextStyleNumber (
            ) const {
            return (m_TextStyleNum);
            }

         //! Get the width of the item.
         DOUBLE GetWidth (
            ) const {
            return (m_width);
            }

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

         //! Returns true if the item is in the correct sorted place in the layout's list of items.
         //! Also returns true if the item isn't the list at all, as that means the list isn't out
         //! of order on account of this item.
         bool IsSorted (
            ) const;

         //! Returns true if the item is in the layout's list of items.
         bool IsInLayout (
            ) const;

         //! Move this item relative to it's current location
         void Move (
            DOUBLE dx,  //!< delta x
            DOUBLE dy,  //!< delta y
            bool bSnap  //!< If true, snap to nearby guides
            ) {
            m_parent.MoveItem(this, dx, dy, bSnap);
            return;
            }

         //! Move this item to a new absolute position
         void Move (
            const DRECT2D& rect,    //!< New location XXX May make this a point.
            bool bSnap  //!< If true, snap to nearby guides
            ) {
            m_parent.MoveItem(this, rect, bSnap);
            return;
            }

         //! Arrange for this item to be just below a specified item
         void MoveBelow (
            const ITEMPOSITION& above
            ) {
            m_rect.yinit = above.m_rect.yinit + .0001;
            if (IsInLayout()) m_parent.SetLayoutNeeded();
            return;
            }

         //! Derived class must provide this method
         virtual const SERIALIZER::ITEMDEF* SerialGetItemDef (
            SERIALIZER& serializer
            ) const = 0;

         //! Method for implementing SERIALIZABLE behaviour.
         //! Derived class must provide this method
         virtual const char* SerialGetTagName (
            ) const = 0;

         //! Method for implementing SERIALIZABLE behaviour.
         //! ITEM provides this for all derived classes
         virtual ERRVALUE SerialRead (
            SERIALIZER& serializer
            );

         //! Method for implementing SERIALIZABLE behaviour.
         //! ITEM provides this for all derived classes
         virtual ERRVALUE SerialWrite (
            SERIALIZER& serializer,
            const char* tagname = 0
            ) const;

         //! Will also inform parent layout that it needs to recalculate layout.
         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;
            }

         //! Set the item to the default location.  That is, assume it will go at the end
         //! just past the last element and set it to that position.
         void SetDefaultLocation (
            );

         //! Set the "hidden" state of an item.  ITEM::Draw should ignore this state()
         //! GRAPHICLAYOUT::Draw() won't draw any hidden items, but the GUI will (to
         //! draw into an overlay GC while moving items)
         void SetHidden (
            bool bHidden
            ) {
            m_bHidden = bHidden;
            }

         //! Will also inform parent layout that it needs to recalculate layout.
         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;
            }

         
         //! Will also inform parent layout that it needs to recalculate layout.
         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;
            }

         //! Set the text style number.
         //! Will also inform parent layout that it needs to recalculate layout.
         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;
            }

         //! Will also inform parent layout that it needs to recalculate layout.
         void SetTopPosition (
            INT32 GuideNum,      //!< Use -1 if offset is relative to an item
            DOUBLE offset
            ) {
            m_TopGuide = GuideNum;
            m_TopOffset = offset;
            if (IsInLayout()) m_parent.SetLayoutNeeded();
            return;
            }

         virtual bool UsesTransparency (
            const MGD::CONTEXT* gc = 0 
            ) const { return false; }

         //! Called by derived classes so they can merge the ITEMDEF lists
         //! Should be protected, but then aparently derived classes also need to be nestet in GRAPHICLAYOUT
         static const SERIALIZER::ITEMDEF* GetSerialItemDef (
            );

         //! TODO: Methods to set position relative to other things
         //!    or relative to the "page"
         //! Each item should know what item is above/below it.
         //! Could possibly handle as one MILIST for each column
         //! An item could be in > 1 column if it spans columns
      protected:
         bool m_bSizeKnown;
         GRAPHICLAYOUT& m_parent;

      private:
         INT32 m_TextStyleNum;
         bool m_bHidden;      //!< Not serialized
         bool m_bPosKnown;
         bool m_bSelected;
         DOUBLE m_height;
         DOUBLE m_width;
         ITEMLIST::ITERATOR m_self;    //!< Used by destructor to remove self from list

         friend class GRAPHICLAYOUT;
      };

      //! Creating an instance of this class suspends redrawing on the
      //! layout.  When it goes out of scope, redrawing will be reenabled.
      //! This is done using a count, so multiple suspend/resumes are
      //! automatically handled.  When the final resume happens, the
      //! draw callback will be called if necessary.
      //! (It could do the draw itself, but has no gc)

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

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

         private:
            GRAPHICLAYOUT& m_layout;
         };

      //! Method for implementing SERIALIZABLE behaviour.
      static const SERIALIZER::ITEMDEF* GetSerialItemDef (
         );

      //! #include <mi32/MILIST.h>
      //! Constructor.
      GRAPHICLAYOUT (
         );       

      //! Copy constructor 
      GRAPHICLAYOUT (
         const GRAPHICLAYOUT& rhs
         );

      //! Assignment operator private and unimplemented to prevent use

      //! Destructor.
      virtual ~GRAPHICLAYOUT();

      //! Install handler for an ITEMTYPE.
      static void InstallItemType (
         const char* name,                            //!< Item type name for serialization
         int (*Construct)(GRAPHICLAYOUT&, ITEM**)     //! Function to construct an item of this type
         );

      //! Return iterator to first item in layout
      ITERATOR Begin (
         ) {
         return (m_ItemList.Begin());
         }

            //! Return const iterator to first item in layout
      CONST_ITERATOR Begin (
         ) const {
         return (m_ItemList.Begin());
         }

      //! Add a Horizontal Guide.
      //! Returns the new guide number or err < 0
      int AddHGuide (
         DOUBLE value
         );

      //! Add an item to the layout.
      //! Once added, the item is "owned" by the layout and will be destroied by the layout's destructor.
      //! If the position of the item hasn't been set yet, a default postion will be computed.
      void AddItem (
         ITEM* item
         );

      //! Add a named text style
      int AddTextStyle (
         const NAMEDTEXTSTYLE& style
         );

      //! Add a Vertical Guide.
      //! Returns the new guide number or err < 0
      int AddVGuide (
         DOUBLE value
         );

      //! Compute item attachments given a rectangle of where the item will go.
      //! If bSnap is true, then anything within 3 pixels of a guide will snap
      //! to the guide and the rectangle will be adjusted accordingly
      void ComputeItemAttachments (
         const ITEM* item,
         DRECT2D& rect,
         ITEMPOSITION& newpos,   //!< Computed and returned (Initial values unused)
         const ITEM *&ItemAbove,
         bool bSnap = true
         ) const;

      ERRVALUE Copy (
         const GRAPHICLAYOUT& rhs
         );

      //! Compute all item positions.
      //! If nothing has changed since the last layout, nothing is done.
      int DoLayout (
         );

      //! Draw.  
      //! If Rect is not 0, only draw things intersecting the rect
      int Draw (
         MGD::CONTEXT* gc,
         const DRECT2D* rect = 0,
         const TRANSPARM* trans = 0,
         double scale = 1.0
         );

      //! Draw "handles" showing item attachemts. (normally done while moving an item)
      //! SelectedDelta is the offset in output cordinates that selected items have
      //! been shifted.
      void DrawItemHandles (
         MGD::CONTEXT* gc,
         const ITEMPOSITION& position,
         const DRECT2D& rect,
         const GRAPHICLAYOUT::ITEM* ItemAbove,
         const DPOINT2D& SelectedDelta,
         double scale = 1.0
         ) const;

      //! Return iterator to compare to end of layout (0)
      ITERATOR End (
         ) {
         return (m_ItemList.End());
         }

      //! Return const iterator to compare to end of layout (0)
      CONST_ITERATOR End (
         ) const {
         return (m_ItemList.End());
         }

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

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

      //! Control wether or not the legend background is filled
      bool GetDrawBackground (
         ) const {
         return (m_bDrawBackground);
         }

      //! Control wether or not a border is drawn around the legend
      //! Use SetBorderStyle() to set the style of the border
      bool GetDrawBorder (
         ) const {
         return (m_bDrawBorder);
         }

      //! Determine if DropShadow is on or off
      bool GetDrawDropShadow (
         ) const {
         return (m_bDrawDropShadow);
         }

      //! Get the color for the drop shadow. 
      const COLOR& GetDropShadowColor (
         ) const {
         return (m_DropShadowColor);
         }

      //! Get the angle for the drop shadow (in radians).
      double GetDropShadowDirection (
         ) const {
         return (m_DropShadowDirection);
         }

      //! Get distance for the drop shadow (in points)
      double GetDropShadowDistance (
         ) const {
         return (m_DropShadowDistance);
         }

      //! Return the value of a Horizontal Guide.
      DOUBLE GetHGuide (
         int GuideNum
         ) const {
         if (GuideNum < 0 || (UINT32)GuideNum >= m_NumHGuides) return 0;
         return m_HGuides[GuideNum];
         }

      //! Get the height of the content.
      DOUBLE GetHeight (
         ) const {   
         return (m_Extents.GetHeight());
         }

      //! Given an X/Y position, return the horizontal Guide number.
      //! Returns -1 if no guide at given location.
      INT32 GetHGuideFromLocation (
         const DPOINT2D& point,
         int tolerance = 2    //!< How close do we have to be (in pixels)
         ) const;

      INT32 GetVGuideFromLocation (
         const DPOINT2D& point,
         int tolerance = 2    //!< How close do we have to be (in pixels)
         ) const;


      //! Given an x/y position return the item at that location.
      //! Returns NULL if no item at that location.
      ITEM* GetItemFromLocation (
         const DPOINT2D& point
         );

      //! Const version of GetItemFromLocation()
      const ITEM* GetItemFromLocation (
         const DPOINT2D& point
         ) const;

      //! Get the number of Horizontal Guides.
      int GetNumHGuides (
         ) const {
         return m_NumHGuides;
         }

      //! Get the number of text styles.
      int GetNumTextStyles (
         ) const {
         return m_TextStyle.size();
         }

      //! Get the number of Vertical Guides.
      int GetNumVGuides (
         ) const {
         return m_NumVGuides;
         }

      //! Get a text style (const*).
      const NAMEDTEXTSTYLE* GetTextStyle (
         int num
         ) const {
         if (num < 0 || num >= GetNumTextStyles()) return NULL;
         return (&m_TextStyle[num]);
         }

      //! Get a copy of a text style.
      void GetTextStyle (
         int num,
         TEXTSTYLE& style
         ) const {
         style = m_TextStyle[num];
         return;
         }

      //! Get a copy of a text style.
      void GetTextStyle (
         int num,
         NAMEDTEXTSTYLE& style
         ) const {
         style = m_TextStyle[num];
         return;
         }


      //! Get the name of a text style.
      const UNICODE* GetTextStyleName (
         int num
         ) const {
         if (num < 0 || num >= GetNumTextStyles()) return NULL;
         return (m_TextStyle[num].m_name);
         }

      //! Get the list of text styles.
      //! Can't return a const SIMPLE_ARRAY<>& because they're not stored that way
      //! internally for serialization reasons.
      void GetTextStyles (
         std::vector<NAMEDTEXTSTYLE>& styles
         ) {
         styles.clear();
         for (int i = 0 ; i < GetNumTextStyles() ; ++i) styles.push_back(m_TextStyle[i]);
         }

      //! Return the value of a Vertical Guide.
      DOUBLE GetVGuide (
         int GuideNum
         ) const {
         if (GuideNum < 0 || (UINT32)GuideNum >= m_NumVGuides) return 0;
         return m_VGuides[GuideNum];
         }

      //! Get the width of the content.
      DOUBLE GetWidth (
         ) const { 
         return (m_Extents.GetWidth());
         }

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

      //! Move an item relative to its current position
      void MoveItem (
         ITEM* item,       //!< Item to move
         DOUBLE dx,        //!< Distance to move (x)
         DOUBLE dy,        //!< Distance to move (y, positive == down)
         bool bSnap        //!< Snap to guide if close
         );


      //! Move an item to an absolute location
      void MoveItem (
         ITEM* item,                   //!< Item to move
         const DRECT2D& location,      //!< Where to move it to (XXX May make this a point)
         bool bSnap                    //!< Snap to guide if close   
         );

      //! Suspend redraws.
      //! RedrawSuspend()/RedrawResume() calls can be nested.
      //! If you plan to Suspend/Resume in the same function, you're better
      //! off creating an instance of a GRAPHICLAYOUT::SUSPENDREDRAW, which
      //! will automatically resume when it goes out of scope.
      void RedrawSuspend (
         ) {
         ++m_RedrawSuspended;
         return;
         }

      //! Resume redraws.
      //! If anything has changd while redraws were suspended, it will redraw.
      //! See comments on RedrawSuspend() for more information.
      void RedrawResume (
         ) {
         if (m_RedrawSuspended) --m_RedrawSuspended;
         if (!m_RedrawSuspended && m_bRedrawNeeded) {
            Redraw();   //! Notifies all observers
            }
         return;
         }

      //! Remove a Horizontal Guide.
      //! Will not allow the removal of a guide which is in use.
      //! Will return true if the guide was removed, false if it was
      //! in use or an invalid guide number.
      bool RemoveHGuide (
         int GuideNum
         );

      //! Removes an item from the layout.
      //! Does not free the item.  Once removed from the layout, it is your responsibility to destroy
      //! the item.  Any items which are in the layout at the time the layout is destroied will get
      //! destroied by the layout's destructor.
      void RemoveItem (
         ITEM* item
         );
      
      //! Remove a Vertical Guide.
      //! Will not allow the removal of a guide which is in use.
      //! Will return true if the guide was removed, false if it was
      //! in use or an invalid guide number.
      bool RemoveVGuide (
         int GuideNum
         );

      //! Method for implementing SERIALIZABLE behaviour.
      virtual const SERIALIZER::ITEMDEF* SerialGetItemDef (
         SERIALIZER& serializer
         ) const;

      //! Method for implementing SERIALIZABLE behaviour.
      virtual const char* SerialGetTagName (
         ) const {
         return "GRAPHICLAYOUT";
         }

      //! Method for implementing SERIALIZABLE behaviour.
      virtual ERRVALUE SerialRead (
         SERIALIZER& serializer
         );

      //! Method for implementing SERIALIZABLE behaviour.
      virtual ERRVALUE SerialWrite (
         SERIALIZER& serializer,
         const char* itemname
         ) const;

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

      //! Set the style of the border to draw around the legend.
      //! Use SetDrawBorder() to control wether or not this is used.
      void SetBorderStyle (
         const LINESTYLE& style
         ) {
         m_BorderStyle = style;
         return;
         }

      //! Control wether or not the background is filled
      void SetDrawBackground (
         bool DrawBackground
         ) {
         m_bDrawBackground = DrawBackground;
         return;
         }

      //! Control wether or not a border is drawn around the legend
      //! Use SetBorderStyle() to set the style of the border
      void SetDrawBorder (
         bool DrawBorder
         ) {
         m_bDrawBorder = DrawBorder;
         return;
         }

      //! Control wether or not a drop shadow is drawn around the legend
      //! Use SetDropShadowXxxx() to set the shadow parameters
      void SetDrawDropShadow (
         bool DrawDropShadow
         ) {
         m_bDrawDropShadow = DrawDropShadow;
         return;
         }

      //! Set the color for the drop shadow. 
      void SetDropShadowColor (
         const COLOR& color
         )  {
         m_DropShadowColor= color;
         return;
         }

      //! Set the angle for the drop shadow (in radians).
      //! GUI should provide intuitive way to set this.
      void SetDropShadowDirection (
         double angle
         )  {
         m_DropShadowDirection = angle;
         return;
         }

      //! Set the distance for the drop shadow (in points).
      //! GUI should provide intuitive way to set this.
      void SetDropShadowDistance (
         double distance
         )  {
         m_DropShadowDistance = distance;
         return;
         }

      //! Set the value of a horizontal guide.
      void SetHGuide (
         int GuideNum,
         DOUBLE value
         );

      //! Sets the flag indicating that layout needs to be recomputed.
      //! XXX This could be made private.
      void SetLayoutNeeded (
         ) {
         m_bLayoutNeeded = m_bRedrawNeeded = true;
         Redraw();   //! Inform observers if not suspended
         }

      //! Sets the flag indicating that layout needs to be redrawn
      //! but not necessarly layout recomputed.  Used when all was changed
      //! was color and things that don't effect size.
      void SetRedrawNeeded (
         ) {
         m_bRedrawNeeded = true;
         Redraw();   //! Inform observers if not suspended
         }

      //! Set a text style.
      /*
      void SetTextStyle (
         int num,
         const TEXTSTYLE& style
         );
         */

      //! Set a text style.
      void SetTextStyle (
         int num,
         const NAMEDTEXTSTYLE& style
         );

      //! Set the name of a text style.
      void SetTextStyleName (
         int num,
         const UNICODE* name
         ) {
         if (num < 0 || num >= GetNumTextStyles()) return;
         ucstrcpy(m_TextStyle[num].m_name, name);
         return;
         }

      //! Set the text styles
      ERRVALUE SetTextStyles (
         const std::vector<NAMEDTEXTSTYLE>& styles
         );

      //! Set the text styles, but allow for possibility of style reordering.
      //! The trans parameter is an array of INT32's that map old style number
      //! to new style number.  The size of this array should match the number
      //! of styles that are in the layout before the call.  If a style has been
      //! deleted, it's entry in the array should be -1.
      ERRVALUE SetTextStyles (
         const std::vector<NAMEDTEXTSTYLE>& styles,
         const SIMPLE_ARRAY<INT32>& trans
         );


      //! Set the value of a vertical guide.
      void SetVGuide (
         int GuideNum,
         DOUBLE value
         );

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

   protected:


   private:
      
      friend class OBSERVER;     //!< Allow its tconstructor to access m_Observers

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

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

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

      bool m_bLayoutNeeded;
      bool m_bRedrawNeeded;
      UINT32 m_NumHGuides;
      DOUBLE* m_HGuides;