layout.h

Go to the documentation of this file.

/**
 * \file mgui/layout.h 
 * \brief MGUI::LAYOUT class definitions
 *
 * \if NODOC
 * $Id: layout.h_v 1.29 2004/07/28 20:52:23 mju Exp $
 *
 * $Log: layout.h_v $
 * Revision 1.29  2004/07/28 20:52:23  mju
 * Change page.create to use mistring.
 *
 * Revision 1.28  2004/07/26 15:10:28  mju
 * Add setminimumsize for equalizer.
 *
 * Revision 1.27  2004/04/01 21:02:59  dwilliss
 * Added SML interface hook method
 *
 * Revision 1.26  2004/01/12 15:37:48  mju
 * Fix comments.
 *
 * Revision 1.25  2003/10/10 13:05:45  mju
 * Include milist header.
 *
 * Revision 1.24  2003/10/03 19:41:36  linux32build!build
 * Doxygen
 *
 * Revision 1.23  2003/09/25 21:25:01  dwilliss
 * Don't capitalize enum any more. Genitor needed it, doxygen doesn't like it.
 *
 * Revision 1.22  2003/09/15 15:57:37  dwilliss
 * Fixed mismatched #ifdefs from Doxygen cleanup
 *
 * Revision 1.21  2003/09/15 13:49:32  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.20  2003/04/09 20:51:18  dwilliss
 * Don't use _T in templates. Mac's ctype.h defines a global _T
 *
 * Revision 1.19  2003/03/04 22:35:20  scowan
 * Fixed destroy callback for X.
 *
 * Revision 1.18  2003/03/04 21:45:11  mju
 * Make PaneWidget private and add protected method to set.
 *
 * Revision 1.17  2003/01/27 18:54:34  mju
 * Add ComputeText... methods usable for X.
 *
 * Revision 1.16  2002/12/11 15:21:57  mju
 * Move contrib stuff here.
 *
 * Revision 1.15  2002/10/10 14:24:23  mju
 * Only do defns for X/MFC.
 *
 * Revision 1.14  2002/10/09 15:11:35  mju
 * Moved to mgui folder.
 *
 * Revision 1.13  2002/09/09 14:31:13  mju
 * Remove deprecated stuff.
 *
 * Revision 1.12  2002/08/13 21:01:33  mju
 * Use mi32 instead of miwin.
 *
 * Revision 1.11  2002/08/08 22:04:03  mju
 * Add book/page methods for determine/setting active page and enabling/disabling.
 *
 * Revision 1.10  2002/08/08 17:06:32  mju
 * Add GetDlgParent method.
 *
 * Revision 1.9  2002/07/31 21:34:27  mju
 * Automatically add expanding whitespace at end of page pane unless turned off.
 *
 * Revision 1.8  2002/07/31 21:01:46  mju
 * Change PAGECB to not expect 3rd parm to be pointer to page.
 *
 * Revision 1.7  2001/12/20 21:26:54  mju
 * Enum docs.
 *
 * Revision 1.6  2001/12/18 16:34:32  mju
 * Add PANE_BASE::UpdateLayout().
 *
 * Revision 1.5  2001/12/17 18:51:46  mju
 * Add EQUALIZER::SetEqualize method.
 *
 * Revision 1.4  2001/12/17 16:44:59  dwilliss
 * Fixed typo in an enum.
 *
 * Revision 1.3  2001/12/14 18:52:24  mju
 * Remove inline.
 *
 * Revision 1.2  2001/12/14 15:55:29  mju
 * Add X private items.
 *
 * Revision 1.1  2001/12/13 16:59:56  mju
 * Initial revision
 * \endif
**/

#if !defined(INC_MGUI_LAYOUT_H) && (defined(X_NATIVE) || defined(WIN32_MFC))
#define  INC_MGUI_LAYOUT_H

#if !defined(INC_MI32_STDAFX_H) && defined(WIN32_MFC)
#include <mi32/stdafx.h>
#endif

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

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

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

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

#ifndef INC_MI32_I18N_H
#include <mi32/i18n.h>
#endif

#if !defined(INC_MI32_WINRESID_H) && defined(WIN32_MFC)
#include <mi32/winresid.h>
#endif

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


#ifndef GENERATING_DOXYGEN_OUTPUT

class SML_GUI_INTERFACE_BASE;

#ifdef WIN32_MFC

#include <afxtempl.h>
namespace ETSLayout {

//! Controls whether the Icon is automatically set to IDR_MAINFRAME
#define _AUTO_SET_ICON

//! Forward class declarations
class ETSLayoutPropertySheet;

//! Default border between panes.
const int nDefaultBorder = 5;

//! Minimum size for non-ABSOLUTE_... items.
const int MINCONSTRAIN = 5;

class ETSLayoutMgr {
   public:
      
      enum layResizeMode {
         GREEDY            = 0,        //!< Will eat up as much as it can
         ABSOLUTE_HORZ     = 1 << 0,   //!< Horizontal size is absolute
         RELATIVE_HORZ     = 1 << 1,   //!< Horizontal size in percent
         ABSOLUTE_VERT     = 1 << 2,   //!< Vertical size is absolute
         RELATIVE_VERT     = 1 << 3,   //!< Vertical size in percent

         NORESIZE          = ABSOLUTE_HORZ | ABSOLUTE_VERT,

         SIZE_MASK         = NORESIZE,

         ALIGN_LEFT        = 1 << 4,   //!< following only for NORESIZE
         ALIGN_RIGHT       = 1 << 5,
         ALIGN_TOP         = 1 << 6,
         ALIGN_BOTTOM      = 1 << 7,

         ALIGN_HCENTER     = ALIGN_LEFT | ALIGN_RIGHT,   
         ALIGN_VCENTER     = ALIGN_TOP | ALIGN_BOTTOM,

         ALIGN_CENTER      = ALIGN_HCENTER | ALIGN_VCENTER,
         ALIGN_MASK        = ALIGN_CENTER,

         FILL_HORZ         = 1 << 8,   //!< Fill remaining space if any and if no greedy/relative items
         FILL_VERT         = 1 << 9,
         FILL_BOTH         = FILL_HORZ | FILL_VERT,
      
         IGNORE_NONVISIBLE = 1 << 14   //!< Ignore nonvisible items in layout
         };

      enum layOrientation {
         HORIZONTAL,
         VERTICAL
         };

      //! Base class for all kind of panes. 
      class PaneBase {
         friend class ETSLayoutMgr;
         friend class CPaneBase;
         friend class CPane;

         public:

            //! Constructor.
            PaneBase (
               ETSLayoutMgr *pMgr
               ) { m_pMgr = pMgr; }

            //! Destructor.
            virtual ~PaneBase(
               ) { }

            //! Add alignment modes if none previously set.
            void addAlignmentModes (
               DWORD modeResize
               ) { if ((m_modeResize & ALIGN_MASK) == 0) m_modeResize |= (modeResize & ALIGN_MASK); }

            //! Determine how much of the given space this pane would like to receive in horizontal direction.
            virtual int getConstrainHorz (int sizeParent) = 0;

            //! Determine how much of the given space this pane would like to receive in vertical direction.
            virtual int getConstrainVert (int sizeParent) = 0;

            /**
             * Determine how much of the given space this pane
             * minimally need. This would be an absolute Value if 
             * the mode contains ABSOLUTE_HORZ or an explicit minimum
             * value, else MINCONSTRAIN
             */
            virtual int getMinConstrainHorz () = 0;

            /**
             * Determine if there is an restriction for maximum
             * space this pane needs. Return -1 for unrestricted (GREEDY
             * or RELATIVE)
             */
            virtual int getMaxConstrainHorz () = 0;

            /**
             * Determine how much of the given space this pane
             * minimally need. This would be an absolute Value if 
             * the mode contains ABSOLUTE_VERT or an explicit minimum
             * value, else MINCONSTRAIN
             */
            virtual int getMinConstrainVert () = 0;

            /**
             * Determine if there is an restriction for maximum
             * space this pane needs. Return -1 for unrestricted (GREEDY
             * or RELATIVE)
             */
            virtual int getMaxConstrainVert () = 0;

            //! Determine if pane has opposite orientation from that specified.
            virtual bool hasOppositeOrientation (layOrientation orientation) const;

            //! Determine if pane has any currently-visible items.
            virtual bool isVisible () const = 0;

            //! Do actual resize operation after the caller computed a new area for this pane
            virtual bool resizeTo (CRect& rcNewArea) = 0;

            //! Set control 'enabled' state.
            virtual void setEnabled (bool enabled) = 0;

            //! Set control 'visible' state.
            virtual void setVisible (bool visible) = 0;

            virtual void updateSizeSecondary ();

            /**
             * Returs the Resize Mode of this pane
             */
            DWORD modeResize() { return m_modeResize; };

         protected:

            DWORD m_modeResize;                 //!< How this Item will be resized, a combination of the flags above
            ETSLayoutMgr *m_pMgr;               //!< Pointer to LayoutManager
         };    //! PaneBase end

      /**
       * CPaneBase represents an autopointer to a PaneBase. Use this and you won't have to worry
       * about cleaning up any Panes. Also this autopointer lets you return Pane objects
       * from function without using pointers (at least you won't see them :) )
       */

      class CPaneBase {
         protected:
            struct PaneHolder {
               PaneHolder (PaneBase* pPane );
               ~PaneHolder ();

               void AddRef ();
               void Release ();

               PaneBase *m_pPane;
               long m_nRefCount;
               };    //! PaneHolder end

            PaneHolder*    m_pPaneHolder;

         public:
            //! Standardconstructor
            CPaneBase ();
            CPaneBase (PaneBase* pPane);
            CPaneBase (const CPaneBase& rhs);

            ~CPaneBase ();

            void operator= (PaneBase* pPane);
            void operator= (const CPaneBase& rhs);
            PaneBase* operator-> () const;
            PaneBase* GetPaneBase () { return operator->(); }

            bool IsValid() const { return (m_pPaneHolder != 0); }
            operator !() const   { return (m_pPaneHolder == 0); }
         };    //! CPaneBase end

      class Pane;

      class CPane : public CPaneBase {
         public:
            //! Standardconstructor
            CPane( );
            CPane( Pane* pPane );
            CPane( const CPane& rhs );

            ~CPane();

            void operator=( Pane* pPane );
            void operator=( const CPane& rhs );
            Pane* operator->() const;
            Pane* GetPane()         { return operator->(); }

            CPaneBase ConvertBase() const;

            CPane& operator<< ( const CPane pPane );
            CPane& operator<< ( const CPaneBase pItem );
         };    //! CPane end


      /**
       * PaneItem represents a single control
       */
      class PaneItem : public PaneBase {
         friend class ETSLayoutMgr;
         friend class Pane;
         protected:
            /**
             * Creates a new PaneItem from a Control. If sizeX or sizeY are 0
             * and modeResize is ABSOLUTE will copy the current dimensions of
             * the control to m_sizeX/Y. So the appearance does not change
             * from the Dialog Editor
             */
            PaneItem( CWnd* pWnd, ETSLayoutMgr* pMgr, layResizeMode modeResize = GREEDY, int sizeX=0, int sizeY=0, int sizeXMin=0, int sizeYMin=0);

            /**
             * If your control is not mapped you can name it by its ChildID. Pass
             * the pMgr to receive the CWnd* of nID. 
             * The rest as stated above
             */
            PaneItem( UINT nID, ETSLayoutMgr* pMgr, layResizeMode modeResize = GREEDY, int sizeX=0, int sizeY=0, int sizeXMin=0, int sizeYMin=0);

         public:
            virtual int getConstrainHorz(int sizeParent);
            virtual int getConstrainVert(int sizeParent);
            virtual int getMinConstrainHorz();
            virtual int getMinConstrainVert();
            virtual int getMaxConstrainHorz();
            virtual int getMaxConstrainVert();
            virtual bool isVisible () const;
            virtual bool resizeTo(CRect& rcNewArea);
            virtual void setEnabled (bool enabled);
            virtual void setVisible (bool visible);

            bool  isDummy()            { return (m_hwndCtrl == 0);   }

         protected:
            friend class ETSLayoutPropertySheet;

            /**
             * The horizontal size of the control (see m_modeResize)
             */
            int            m_sizeX;
            int            m_sizeXMin;

            /**
             * The vertical size of the control (see m_modeResize)
             */
            int            m_sizeY;
            int            m_sizeYMin;

            /**
             * Child Control pointer
             */
            HWND        m_hwndCtrl;

            /**
             * Combo box needs special treatment
             */
            bool        m_bComboSpecial;

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            void ComputeSizeXY();
            #endif // GENERATING_DOXYGEN_OUTPUT
         };    //! PaneItem end


      /**
       * This class encapsulates a Subpane (and indeed the root Pane too)
       * it is a container of PaneBase* which it will recursivly resize
       */
      class Pane : public PaneBase {
         friend class ETSLayoutMgr;
         friend class CPaneBase;
         friend class CPane;
         friend class ETSLayoutPropertySheet;
           
         protected:
            /**
             * Tell the pane in which direction it is positioned. A HORIZONTAL pane
             * arranges it's subpanes from left to right, a VERTICAL from top to bottom
             */
            Pane (ETSLayoutMgr* pMgr, layOrientation orientation, int sizeBorder = nDefaultBorder, int sizeExtraBorder = 0, bool IgnoreNonVisible = false);

         public:
            /**
             * If your control is not mapped you can name it by its ChildID. Pass
             * the pMgr to receive the CWnd* of nID. 
             * The rest as stated above
             */
            bool addItem( UINT nID, layResizeMode modeResize = GREEDY, int sizeX=0, int sizeY=0, int sizeXMin=-1, int sizeYMin=-1);

            /**
             * Creates a new PaneItem from an Control. If sizeX or sizeY are 0
             * and modeResize is ABSOLUTE will copy the current dimensions of
             * the control to m_sizeX/Y. So the appearance does not change
             * from the Dialog Editor
             */
            bool addItem( CWnd* pWnd, layResizeMode modeResize = GREEDY, int sizeX=0, int sizeY=0, int sizeXMin=-1, int sizeYMin=-1);

            /**
             * Add a whitespace Item (paneNull) of variable size with
             * a minimum size of 0
             */
            bool addItemGrowing();

            /**
             * Add a whitespace Item (paneNull) with fixed size
             */
            bool addItemFixed(int size);

            /**
             * Add a whitespace Item (paneNull) of fixed size based on the
             * current layout (as in the dialog template). Based on the layout
             * of the pane vertical or horizontal spacing is considered
             *
             * First argument is the left (top) item for a HORIZONTAL (VERTICAL) pane
             */
            bool addItemSpaceBetween( CWnd* pWndFirst, CWnd* pWndSecond );
            bool addItemSpaceBetween( UINT nIDFirst, UINT nIDSecond );

            /**
             * Add a whitespace Item (paneNull) of fixed size based on the
             * size of another item
             */
            bool addItemSpaceLike( CWnd* pWnd );
            bool addItemSpaceLike( UINT nID );

            /**
             * Add an item to the pane, appending at the end. This may be either obtained
             * by a call to ETSLayoutMgr::item() or one of the ETSLayoutMgr::paneXXX() calls
             */
            bool addPane( CPaneBase pItem );
            bool addPane( CPane pSubpane, layResizeMode modeResize, int sizeSecondary /* = 0 */);

            virtual int getConstrainHorz (int sizeParent);
            virtual int getConstrainVert (int sizeParent);
            virtual int getMinConstrainHorz ();
            virtual int getMinConstrainVert ();
            virtual int getMaxConstrainHorz ();
            virtual int getMaxConstrainVert ();
            virtual bool hasOppositeOrientation (layOrientation orientation) const;
            virtual bool isVisible () const;
            virtual bool resizeTo (CRect& rcNewArea);
            virtual void setEnabled (bool enabled);
            virtual void setVisible (bool visible);

            /**
             * The destructor takes care of destroying all Subpanes and items
             */
            virtual ~Pane();

            /**
             * Access to the orientation of this pane
             */
            layOrientation getOrientation() { return m_Orientation; };

         protected:

            //! Recursively update secondary pane sizes.
            virtual void updateSizeSecondary();

            layOrientation m_Orientation;    //!< Pane orientation

            /**
             * This array holds the pointers to the Items/SubPanes
             */
            CArray<CPaneBase, CPaneBase>  m_paneItems;

            int m_sizeSecondary;             //!< Size in secondary direction
            int m_sizeBorder;                //!< Space between child items
            int m_sizeExtraBorder;           //!< Extra space around border

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            int countGreedyItems () const;

            bool resizeToAbsolute (int& availSpace, CArray<int,int>& sizePrimary, CArray<int,int>& sizeMin, CArray<int,int>& sizeMax);
            
            bool resizeToRelative (int& availSpace, CArray<int,int>& sizePrimary, CArray<int,int>& sizeMin, CArray<int,int>& sizeMax);

            bool resizeToGreedy (int& availSpace, int nGreedy, CArray<int,int>& sizePrimary, CArray<int,int>& sizeMin, CArray<int,int>& sizeMax);
            #endif // GENERATING_DOXYGEN_OUTPUT

         };    // Pane end


      /**
       * This class encapsulates a Subpane which is a Tab
       * it will use calls to AdjustRect to position it's
       * childs
       */
      class PaneTab : public Pane {
         friend class ETSLayoutMgr;

         protected:
            /**
             * Tell the pane in which direction it is positioned. A HORIZONTAL pane
             * arranges it's subpanes from left to right, a VERTICAL from top to bottom
             */
            PaneTab( CTabCtrl* pTab, ETSLayoutMgr* pMgr, layOrientation orientation, int sizeBorder = nDefaultBorder, int sizeExtraBorder = 0 );

         public:
            virtual int getConstrainHorz(int sizeParent);
            virtual int getConstrainVert(int sizeParent);
            virtual int getMinConstrainHorz();
            virtual int getMinConstrainVert();
            virtual int getMaxConstrainHorz();
            virtual int getMaxConstrainVert();
            virtual bool isVisible () const;
            virtual bool resizeTo(CRect& rcNewArea);
            virtual void setEnabled (bool enabled);
            virtual void setVisible (bool visible);

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            CTabCtrl* m_pTab;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };    //! PaneTab end

      /**
       * This class encapsulates a Subpane which is a Static
       * it will use calls to AdjustRect to position it's
       * childs
       */
      class PaneCtrl : public Pane {
         friend class ETSLayoutMgr;
         protected:
            /**
             * Tell the pane in which direction it is positioned. A HORIZONTAL pane
             * arranges it's subpanes from left to right, a VERTICAL from top to bottom
             */
            PaneCtrl( CWnd* pCtrl, ETSLayoutMgr* pMgr, layOrientation orientation, int sizeBorder = nDefaultBorder, int sizeExtraBorder = 0, int sizeTopExtra = 0);
            PaneCtrl( UINT nID, ETSLayoutMgr* pMgr, layOrientation orientation, int sizeBorder = nDefaultBorder, int sizeExtraBorder = 0, int sizeTopExtra = 0 );

         public:

            virtual int getConstrainHorz(int sizeParent);
            virtual int getConstrainVert(int sizeParent);
            virtual int getMinConstrainHorz();
            virtual int getMinConstrainVert();
            virtual int getMaxConstrainHorz();
            virtual int getMaxConstrainVert();
            virtual bool isVisible () const;
            virtual bool resizeTo(CRect& rcNewArea);
            virtual void setEnabled (bool enabled);
            virtual void setVisible (bool visible);

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            HWND m_hwndCtrl;
            int m_sizeTopExtra;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };    //! PaneCtrl end

      //! Constructor.
      ETSLayoutMgr (CWnd* pWnd) : m_pWnd(pWnd), m_RootBorders(5,5,5,5) { }

      virtual ~ETSLayoutMgr();

      virtual CRect GetRect() { CRect r; m_pWnd->GetClientRect(r); return r; };
      CWnd* m_pWnd;
      CWnd* GetWnd()    { return m_pWnd; };

      void  setRootBorders (int left, int top, int right, int bottom) { m_RootBorders.SetRect(left,top,right,bottom); }

      /**
       * Pass this for a pseudo Pane with no content
       */
      static CWnd*   paneNull;

      /**
       * Loads the current position and size from the registry using a supplied
       * key. Will be loaded with AfxGetApp()->WriteProfileXXX(). You may
       * specify a subfolder (e.g. Load( _CT("MyDialog\\Layout") ); ). Will
       * load the following keys:
       *
       * - lpstrRegKey+"SizeX";
       * - lpstrRegKey+"SizeY";
       * - lpstrRegKey+"PosX";
       * - lpstrRegKey+"PosY";
       *
       * Is automatically called during OnActivate() if key specified in
       * constructor.
       */
      bool Load(LPCTSTR lpstrRegKey);

      /**
       * Store the current position and size to the registry using a supplied
       * key. Will be stored with AfxGetApp()->WriteProfileXXX(). You may
       * specify a subfolder (e.g. Save( _CT("MyDialog\\Layout") ); ). Will
       * create the following keys:
       *
       * - lpstrRegKey+"SizeX";
       * - lpstrRegKey+"SizeY";
       * - lpstrRegKey+"PosX";
       * - lpstrRegKey+"PosY";
       *
       * Is automatically called during DestroyWindow() if key specified in
       * constructor.
       */
      bool Save(LPCTSTR lpstrRegKey);

      /**
       * Updates the layout after you specify the new
       * layout
       */
      virtual void UpdateLayout();

      virtual void UpdateLayout(CPane p) {
         if(m_RootPane.IsValid()) {
            //! free old root
            m_RootPane = 0;
            }
         m_RootPane = p;
         UpdateLayout();
         }

      /**
       * Does the actual Layout, called from OnSize()
       * Default implementation does nothing.
       */
      virtual void Layout(CRect& rcClient);

      /**
       * Erasing only the these parts of the client area where
       * there is no child window. Extra-code for group-boxes 
       * included!
       */
      void EraseBkgnd(CDC* pDC);

      /**
       * Helperfunctions for the stream-interface. For usage see sample Application
       * and/or documentation.
       */

      /**
       * Create a new Pane. You may specify the resize
       * mode for both directions. If you add modes for the secondary direction
       * (i.e. *_VERT for a HORIZONTAL pane) then sizeSecondary is used as it's
       * size. If you do not specify sizeSecondary and the mode is ABSOLUTE_VERT
       * it will be computed as the maximum Height of all SubPanes (the same is
       * true for VERTICAL panes and subpanes with *_HORZ)
       */
      CPane pane( layOrientation orientation, layResizeMode modeResize = GREEDY, int sizeBorder = nDefaultBorder, int sizeExtraBorder = 0, int sizeSecondary = 0);

      /**
       * Create one of the special control panes. Parameter are like pane(). For
       * additional information see documentation
       */
      CPane paneTab( CTabCtrl* pTab, layOrientation orientation, layResizeMode modeResize = GREEDY, int sizeBorder = nDefaultBorder, int sizeExtraBorder = 0, int sizeSecondary = 0);
      CPane paneCtrl( UINT nID, layOrientation orientation, layResizeMode modeResize = GREEDY, int sizeBorder = nDefaultBorder, int sizeExtraBorder = 0, int sizeTopExtra = 0, int sizeSecondary = 0);
      CPane paneCtrl( CWnd* pCtrl, layOrientation orientation, layResizeMode modeResize = GREEDY, int sizeBorder = nDefaultBorder, int sizeExtraBorder = 0, int sizeTopExtra = 0, int sizeSecondary = 0);

      /**
       * Creates a new PaneItem for an Control. If sizeX or sizeY are 0
       * and modeResize is ABSOLUTE will copy the current dimensions of
       * the control to m_sizeX/Y. So the appearance does not change
       * from the Dialog Editor. size*Min = -1 means: do not make smaller
       * than in Dialog Template.
       */
      CPaneBase item(UINT nID, layResizeMode modeResize = GREEDY, int sizeX =0, int sizeY =0, int sizeXMin =-1, int sizeYMin =-1);
      CPaneBase item(CWnd* pWnd, layResizeMode modeResize = GREEDY, int sizeX =0, int sizeY =0, int sizeXMin =-1, int sizeYMin =-1);

      /**
       * Add a whitespace Item (paneNull) of variable size with
       * a minimum size of 0
       */
      CPaneBase itemGrowing(layOrientation orientation);

      /**
       * Add a whitespace Item (paneNull) with fixed size
       */
      CPaneBase itemFixed(layOrientation orientation, int sizePrimary);

      /**
       * Add a whitespace Item (paneNull) of fixed size based on the
       * current layout (as in the dialog template). Based on the layout
       * of the pane vertical or horizontal spacing is considered
       *
       * First argument is the left (top) item for a HORIZONTAL (VERTICAL) pane
       */
      CPaneBase itemSpaceBetween( layOrientation orientation, CWnd* pWndFirst, CWnd* pWndSecond );
      CPaneBase itemSpaceBetween( layOrientation orientation, UINT nIDFirst, UINT nIDSecond );

      /**
       * Add a whitespace Item (paneNull) of fixed size based on the
       * size of another item
       */
      CPaneBase itemSpaceLike( layOrientation orientation, CWnd* pWnd );
      CPaneBase itemSpaceLike( layOrientation orientation, UINT nID );

   protected:

      CPane m_RootPane;                //!< Holder for root pane, set in InitDialog()
      CString m_strRegStore;           //!< Registry key for storing size
      CRect m_RootBorders;             //!< Borders around root

      //! Create a root pane
      CPane CreateRoot (
         layOrientation orientation,
         int sizeBorder = nDefaultBorder,
         int sizeExtraBorder = 0,
         bool IgnoreNonVisible = false
         ) {
         if (m_RootPane.IsValid()) {
            //! free old root
            m_RootPane = 0;
            }
         m_RootPane = new Pane(this, orientation, sizeBorder, sizeExtraBorder, IgnoreNonVisible);
         return m_RootPane;
         }

   };    //! ETSLayoutMgr end


inline ETSLayoutMgr::layResizeMode operator| (
   const ETSLayoutMgr::layResizeMode lhs, 
   const ETSLayoutMgr::layResizeMode rhs
   ) {
   return (static_cast<ETSLayoutMgr::layResizeMode>((DWORD)lhs | (DWORD)rhs));
   }

inline ETSLayoutMgr::layResizeMode& operator|= (
   ETSLayoutMgr::layResizeMode& lhs, 
   const ETSLayoutMgr::layResizeMode rhs
   ) {
   lhs = static_cast<ETSLayoutMgr::layResizeMode>((DWORD)lhs | (DWORD)rhs);
   return (lhs);
   }

inline ETSLayoutMgr::layResizeMode operator& (
   const ETSLayoutMgr::layResizeMode lhs, 
   const ETSLayoutMgr::layResizeMode rhs
   ) {
   return (static_cast<ETSLayoutMgr::layResizeMode>((DWORD)lhs & (DWORD)rhs));
   }

inline ETSLayoutMgr::layResizeMode& operator&= (
   ETSLayoutMgr::layResizeMode& lhs, 
   const ETSLayoutMgr::layResizeMode rhs
   ) {
   lhs = static_cast<ETSLayoutMgr::layResizeMode>((DWORD)lhs & (DWORD)rhs);
   return (lhs);
   }


/**
 * Base class for the Layout function. Derive your own class
 * from this or derive it from CDialog and modify _all_
 * references to CDialog to ETSLayoutDialog
 */
class ETSLayoutDialog : public CDialog, protected ETSLayoutMgr {
   public:

      //! Construction
      ETSLayoutDialog(UINT nID, CWnd* pParent = NULL, LPCTSTR strName = NULL, bool bGripper = true);   //! standard constructor

   protected:
      //! Generated message map functions
      //!{{AFX_MSG(ETSLayoutDialog)
      afx_msg void OnSize(UINT nType, int cx, int cy);
      afx_msg void OnGetMinMaxInfo(MINMAXINFO FAR* lpMMI);
      afx_msg BOOL OnEraseBkgnd(CDC* pDC);
      virtual BOOL OnInitDialog();
      afx_msg void OnDestroy();
      //!}}AFX_MSG
      DECLARE_MESSAGE_MAP()

      virtual CRect GetRect();

      bool     m_bGripper;
      CStatusBar  m_StatusBar;
   };    //! ETSLayoutDialog end


/**
 * Base class for the Layout function. Derive your own class
 * from this or derive it from CDialog and modify _all_
 * references to CFormView to ETSLayoutFormView
 */
class ETSLayoutFormView : public CFormView, public ETSLayoutMgr {
   DECLARE_DYNAMIC(ETSLayoutFormView)

   public:

      //! Constructor.
      ETSLayoutFormView(UINT nID, LPCTSTR strName = NULL);

      //! Destructor.
      virtual ~ETSLayoutFormView();

   protected:

      //! Generated message map functions
      //!{{AFX_MSG(ETSLayoutDialog)
      afx_msg void OnSize(UINT nType, int cx, int cy);
      afx_msg BOOL OnEraseBkgnd(CDC* pDC);
      afx_msg void OnGetMinMaxInfo(MINMAXINFO FAR* lpMMI);
      //!}}AFX_MSG
      DECLARE_MESSAGE_MAP()
   };    //! ETSLayoutFormView end


/**
 * Base class for the Layout function. Derive your own class
 * from this or derive it from CBCGDialogBar/CDialogBar and 
 * modify _all_  references to CBCGDialogBar/CDialogBar to 
 * ETSLayoutDialogBar
 */
class ETSLayoutDialogBar : public CDialogBar, protected ETSLayoutMgr {
   public:

      //! Constructor.
      ETSLayoutDialogBar();

      //! ClassWizard generated virtual function overrides
      //!{{AFX_VIRTUAL(ETSLayoutDialogBar)
      virtual CSize CalcDynamicLayout(int nLength, DWORD dwMode);
      //!}}AFX_VIRTUAL

      /**
       * Override this to define Layout
       */
      virtual BOOL Initialize() { return false; };

      virtual void UpdateLayout();

   protected:
      //! Generated message map functions
      //!{{AFX_MSG(ETSLayoutDialogBar)
      afx_msg void OnSize(UINT nType, int cx, int cy);
      afx_msg void OnDestroy();
      afx_msg BOOL OnEraseBkgnd(CDC* pDC);
      //!}}AFX_MSG
      LRESULT OnInitDialog(WPARAM, LPARAM);
      DECLARE_MESSAGE_MAP()

      virtual CRect GetRect();
      bool  m_bInitialized;
   };    //! ETSLayoutDialogBar end



/**************************************************
 ** ! the code is only tested for modal sheets ! **
 **************************************************/


/**
 * Resizable PropertySheet. Use this class standalone
 * or as your base class (instead CProptertySheet)
 */
class ETSLayoutPropertySheet : public CPropertySheet, protected ETSLayoutMgr {
   DECLARE_DYNAMIC(ETSLayoutPropertySheet)

   public:

      //! Default constructor.
      ETSLayoutPropertySheet();

      ETSLayoutPropertySheet(UINT nIDCaption, CWnd *pParentWnd = NULL, UINT iSelectPage = 0, LPCTSTR strName=NULL, bool bGripper=true);

      ETSLayoutPropertySheet(LPCTSTR pszCaption, CWnd *pParentWnd = NULL, UINT iSelectPage = 0, LPCTSTR strName=NULL, bool bGripper=true);

      void  SetAutoDestroy()     { m_bAutoDestroy = true; }
      void  SetAutoDestroyPages()   { m_bAutoDestroyPages = true; }
      void  ModelessWithButtons()   { m_bModelessButtons = true; }

      virtual void AddMainArea(CPane paneRoot, CPaneBase itemTab);
      virtual void AddButtons(CPane paneBottom);
       
      //! ClassWizard generated virtual function overrides
      //!{{AFX_VIRTUAL(ETSLayoutPropertySheet)
      public:
      virtual BOOL OnInitDialog();
      virtual void PostNcDestroy();
      //!}}AFX_VIRTUAL

   //! Implementation
   public:
      virtual ~ETSLayoutPropertySheet();

      //! Generated message map functions
   protected:
      //!{{AFX_MSG(ETSLayoutPropertySheet)
      afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
      afx_msg void OnSize(UINT nType, int cx, int cy);
      afx_msg void OnGetMinMaxInfo(MINMAXINFO FAR* lpMMI);
      afx_msg void OnDestroy();
      afx_msg BOOL OnEraseBkgnd(CDC* pDC);
      //!}}AFX_MSG
      DECLARE_MESSAGE_MAP()

      void Resize(int cx, int cy);


      void     Init(LPCTSTR strName, bool bGripper);
      CRect    m_rcStart;
      CRect    m_rcPage;
      bool     m_bGripper;
      CStatusBar  m_StatusBar;
      CPaneBase   m_ItemTab;
      bool     m_bAutoDestroy;
      bool     m_bAutoDestroyPages;
      bool     m_bModelessButtons;

   friend class ETSLayoutPropertyPage;
   };    //! ETSLayoutPropertySheet end


/**
 * Base class for the Layout function. Derive your own class
 * from this or derive it from CPropertyPage and 
 * modify _all_  references to CPropertyPage to 
 * ETSLayoutPropertyPage
 */
class ETSLayoutPropertyPage : public CPropertyPage, protected ETSLayoutMgr {
   friend class ETSLayoutPropertySheet;

   DECLARE_DYNCREATE(ETSLayoutPropertyPage)

   public:
      ETSLayoutPropertyPage( );
      ETSLayoutPropertyPage( UINT nIDTemplate, UINT nIDCaption = 0 );
      ETSLayoutPropertyPage( LPCTSTR lpszTemplateName, UINT nIDCaption = 0 );

      ~ETSLayoutPropertyPage();

   //! Overrides
      //! ClassWizard generated virtual function overrides
      //!{{AFX_VIRTUAL(ETSLayoutPropertyPage)
      public:
      virtual BOOL OnSetActive();
      //!}}AFX_VIRTUAL

   //! Implementation
   protected:
      //! Generated message map functions
      //!{{AFX_MSG(ETSLayoutPropertyPage)
      afx_msg void OnSize(UINT nType, int cx, int cy);
      afx_msg void OnGetMinMaxInfo(MINMAXINFO FAR* lpMMI);
      virtual BOOL OnInitDialog();
      afx_msg BOOL OnEraseBkgnd(CDC* pDC);
      afx_msg void OnWindowPosChanging( WINDOWPOS* lpwndpos );
      afx_msg void OnDestroy();
      afx_msg void OnWindowPosChanged(WINDOWPOS FAR* lpwndpos);
      //!}}AFX_MSG
      DECLARE_MESSAGE_MAP()

      virtual CRect GetRect();
      bool m_bLockMove;
      bool m_bResetBuddyOnNextTimeVisible;
   };    //! ETSLayoutPropertyPage end


}  //! End of ETSLayout namespace
using namespace ETSLayout;

#endif
#endif // GENERATING_DOXYGEN_OUTPUT


namespace MGUI {

// Forward declarations
class TOOLTIPCTRL;
class LAYOUT_PANE_ROOT;
class LAYOUT_PANE_MAIN;
class LAYOUT_PAGE;
class CTRL;

//===================================================================================================================
//! Class to contain X/Y coordinates of a point in a window, on the screen, etc.
//! Often instances of this class are passed by value since the total size is 4 bytes
//! which actually results in smaller and more efficient code in the called function
//! due to direct access on stack rather than through pointer/reference indirection.
class POINT {
   public:

      INT16 m_x;                       //!< Point X coordinate
      INT16 m_y;                       //!< Point Y coordinate

      //! Default construction, initializes to arbitrary point.
      POINT (
         ): m_x(-32768), m_y(-32768) { }

      //! Construct from X, Y values.
      POINT (
         INT16 x,
         INT16 y
         ): m_x(x), m_y(y) { }
   };

//---------------------------------------------------------------------------------------------------------


enum LAYOUT_ORIENTATION {
   LAYOUT_ORIENTATION_Horizontal =     0,    //!< Horizontal layout, automatic LtoR/RtoL based on locale
   LAYOUT_ORIENTATION_Vertical =       1,    //!< Vertical top-to-bottom layout
   LAYOUT_ORIENTATION_HorizontalLtoR = 2,    //!< Horizontal left-to-right layout
   LAYOUT_ORIENTATION_HorizontalRtoL = 3,    //!< Horizontal right-to-left layout
   };

enum LAYOUT_SIZEALIGN {
   LAYOUT_SIZEALIGN_Expand =           0x0000,     //!< Expand both horizontal and vertical to fill space
   LAYOUT_SIZEALIGN_FixedWidth =       0x0001,     //!< Fixed width, height can expand
   LAYOUT_SIZEALIGN_RelativeWidth =    0x0002,     //!< Relative width as percentage of available space
   LAYOUT_SIZEALIGN_FixedHeight =      0x0004,     //!< Fixed height, width can expand
   LAYOUT_SIZEALIGN_RelativeHeight =   0x0008,     //!< Relative height as percentage of available space
   LAYOUT_SIZEALIGN_FixedSize =        0x0005,     //!< Both width and height fixed
   LAYOUT_SIZEALIGN_AlignLeft =        0x0010,     //!< Align with left edge of available space
   LAYOUT_SIZEALIGN_AlignRight =       0x0020,     //!< Align with right edge of available space
   LAYOUT_SIZEALIGN_AlignTop =         0x0040,     //!< Align with top edge of available space
   LAYOUT_SIZEALIGN_AlignBottom =      0x0080,     //!< Align with bottom edge of available space
   LAYOUT_SIZEALIGN_CenterHorz =       0x0030,     //!< Center horizontally in available space
   LAYOUT_SIZEALIGN_CenterVert =       0x00C0,     //!< Center vertically in available space
   LAYOUT_SIZEALIGN_Center =           0x00F0,     //!< Center both horizontal and vertically
   LAYOUT_SIZEALIGN_IgnoreNonVisible = 0x4000,     //!< Ignore nonvisible items in layout
   };
DEFINE_ENUM_OPERATORS(LAYOUT_SIZEALIGN);


//---------------------------------------------------------------------------------------------------------

//! Layout pane base class, not intended to be used directly.
class LAYOUT_PANE_BASE {
   public:

   #ifdef WIN32_MFC
      //! Constructor (MFC version).
      LAYOUT_PANE_BASE (
         CWnd *RootWnd = 0
         ): m_RootPane(0) { }
   #endif

   #ifdef X_NATIVE
      //! Constructor (X version).
      LAYOUT_PANE_BASE (
         ): m_PaneWidget(0) { }
   #endif

      //! Destructor.
      virtual ~LAYOUT_PANE_BASE (
         ) = 0;

   #ifdef WIN32_MFC
      //! Cast to CWnd* so can use pane as parent for MFC Create() methods.
      operator CWnd* (
         ) { return (GetRootWnd()); }
   #endif

   #ifdef WIN32_MFC
      //! Add item to pane (MFC only).
      void AddItem (
         CWnd *ItemWnd,
         MGUI::LAYOUT_SIZEALIGN sizealign
         );
   #endif

      //! Add automatically expanding whitespace item.
      void AddSpaceExpanding (
         ) {
         #ifdef WIN32_MFC
            m_Pane->addItemGrowing();
         #else
            XmiPaneAddSpaceExpanding(m_PaneWidget);
         #endif
         }

      //! Add whitespace item of fixed size.
      void AddSpaceFixed (
         int size
         ) {
         #ifdef WIN32_MFC
            m_Pane->addItemFixed(size);
         #else
            XmiPaneAddSpaceFixed(m_PaneWidget,size);
         #endif
         }

   #ifdef WIN32_MFC
      //! Compute size rectangle for given label text as CString (MFC only).
      CRect ComputeRect (
         const CString& str,
         int xadd = 0,
         int yadd = 0
         ) const;
   #endif

   #ifdef WIN32_MFC
      //! Compute size rectangle for given text "width" (MFC only).
      CRect ComputeRect (
         int width,
         int xadd = 0,
         int yadd = 0
         ) const { return (ComputeRect(CString('M',width),xadd,yadd)); }
   #endif

      //! Compute typical size for given text width in characters.
      MGUI::POINT ComputeTextSize (
         int width                        //!< Width in characters
         ) const;

      //! Compute size of given label text from MISTRING.
      MGUI::POINT ComputeTextSize (
         const MISTRING& str              //!< String (or TEXTID)
         ) const;

      //! Compute size of given label text as UNICODE string.
      MGUI::POINT ComputeTextSize (
         const UNICODE *str               //!< String
         ) const;

   #ifdef WIN32_MFC
      //! Compute size of given label text as CString (MFC only).
      CSize ComputeTextSize (
         const CString& str
         ) const;
   #endif

      //! Get suitable parent for dialog launched from pane.
      MDLGPARENT GetDlgParent (
         ) const {
         #ifdef WIN32_MFC
            return (GetMainWnd());
         #else
            return (MxGetShell(m_PaneWidget));
         #endif
         }

   #ifdef WIN32_MFC
      //! Get pointer to layout manager (MFC only).
      inline ETSLayoutMgr* GetLayoutMgr (
         ) const;
   #endif

   #ifdef WIN32_MFC
      //! Get next available dynamically assigned control ID.
      UINT GetNextControlID (
         );
   #endif

//!      // Get pane orientation.
//!      MGUI::LAYOUT_ORIENTATION GetOrientation (
//!         ) const;

   #ifdef WIN32_MFC
      //! Get "main" window, typically for use as parent for other dialogs.
      inline CWnd* GetMainWnd (
         ) const;
   #endif

   #ifdef WIN32_MFC
      //! Get reference to layout manager pane.
      ETSLayoutMgr::CPane& GetPane (
         ) { return (m_Pane); }
   #endif

   #ifdef X_NATIVE
      //! Get pane widget (X only).
      Widget GetWidget (
         ) const { return (m_PaneWidget); }
   #endif

   #ifdef WIN32_MFC
      //! Get "root pane".
      MGUI::LAYOUT_PANE_ROOT* GetRootPane (
         ) const { return (m_RootPane); }
   #endif

   #ifdef WIN32_MFC
      //! Get root CWnd* for control creation.
      inline CWnd* GetRootWnd (
         ) const;
   #endif

      //! Determine if pane has been created.
      bool IsCreated (
         ) const {
         #ifdef WIN32_MFC
            return (m_Pane.IsValid());
         #else
            return (m_PaneWidget != 0);
         #endif
         }

   #ifdef WIN32_MFC
      //! Add CTRL to message pre-translation list.
      inline void PreTransListAddCtrl (
         CTRL* ctrl
         );
   #endif

      //! Set 'enabled' status for all controls in pane or children therof.
      void SetEnabled (
         bool enabled
         ) {
         #ifdef WIN32_MFC
            m_Pane->setEnabled(enabled);
         #else
            MxSetSensitive(m_PaneWidget,enabled);
         #endif
         }

      //! Set visibility for all controls in pane or children thereof.
      void SetVisible (
         bool visible
         ) {
      #ifdef WIN32_MFC
         m_Pane->setVisible(visible);
      #else
         MxShowWidget(m_PaneWidget,visible);
      #endif
         }

      //! Force update of layout.
      //! This may be necessary if the layout is changed after the dialog/window is initially created.
      void UpdateLayout (
         ) {
      #ifdef WIN32_MFC
         GetLayoutMgr()->UpdateLayout();
      #endif
         }

      #ifndef GENERATING_DOXYGEN_OUTPUT
      //! Function private to SML implemention of MGUI classes
      //! Used to prevent the need for ugly multiple inheritance.
      virtual SML_GUI_INTERFACE_BASE* GetSMLInterface (
         );
      #endif

   protected:

   #ifdef WIN32_MFC
      MGUI::LAYOUT_PANE_ROOT *m_RootPane;    //!< Pointer to root pane
      ETSLayoutMgr::CPane m_Pane;            //!< Actual layout manager pane
   #endif

   #ifdef X_NATIVE
      void SetPaneWidget (Widget PaneWidget);
   #endif

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

   #ifdef X_NATIVE
      Widget m_PaneWidget;
   #endif

   #ifdef X_NATIVE
      static void CB_Destroy (Widget, LAYOUT_PANE_BASE*, void*);
   #endif

      LAYOUT_PANE_BASE (const LAYOUT_PANE_BASE&);
      LAYOUT_PANE_BASE& operator= (const LAYOUT_PANE_BASE&);

      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//---------------------------------------------------------------------------------------------------------

//! Layout pane for use as root of dialog, window or page.
class LAYOUT_PANE_ROOT : public MGUI::LAYOUT_PANE_BASE {
   public:

   #ifdef WIN32_MFC
      //! Constructor (MFC version).
      LAYOUT_PANE_ROOT (
         CWnd& RootWnd
         );
   #endif

   #ifdef X_NATIVE
      //! Constructor (X version).
      LAYOUT_PANE_ROOT (
         ) { }
   #endif

      //! Destructor.
      virtual ~LAYOUT_PANE_ROOT (
         );

   #ifdef WIN32_MFC
      //! Add ToolTip item.
      void AddToolTipItem (
         CWnd& item,
         LPCTSTR string
         );
   #endif

   #ifdef WIN32_MFC
      //! Get "layout manager".
      ETSLayoutMgr* GetLayoutMgr (
         ) const { return (m_LayoutMgr); }
   #endif

   #ifdef WIN32_MFC
      //! Get "main" pane.
      MGUI::LAYOUT_PANE_MAIN* GetMainPane (
         ) const { return (m_MainPane); }
   #endif

   #ifdef WIN32_MFC
      CWnd& GetWnd (
         ) const { return (m_RootWnd); }
   #endif

   #ifdef WIN32_MFC
      //! Initialize called internally by OnInitDialog() or similar (MFC version).
      void Init (
         ETSLayoutMgr *LayoutMgr,
         ETSLayoutMgr::CPane RootPane,
         TOOLTIPCTRL *ToolTipCtrl
         );
   #endif

   #ifdef X_NATIVE
      //! Initialize called internally by OnInitDialog() or similar (X version).
      void Init (
         Widget TopPaneWidget                   //!< Topmost "Pane" widget
         ) { SetPaneWidget(TopPaneWidget); }
   #endif

   #ifdef WIN32_MFC
      //! Add CTRL to message pre-translation list.
      void PreTransListAdd (
         CTRL* ctrl
         );
   #endif

   #ifdef WIN32_MFC
      //! Process message through pretranslation list if control has focus.
      //! @return 'true' if processed, false if not.
      bool PreTransListProcess (
         const CWnd* pFocusWnd,              //!< Window which currently has focus
         MSG *pMsg                           //!< Message to process
         );
   #endif

   protected:

   #ifdef WIN32_MFC
      MGUI::LAYOUT_PANE_MAIN *m_MainPane;    //!< Pointer to "main" pane, may be 'this' pane.
   #endif

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

   #ifdef WIN32_MFC
      CWnd& m_RootWnd;
      ETSLayoutMgr *m_LayoutMgr;
      TOOLTIPCTRL *m_ToolTipCtrl;
      SIMPLE_ARRAY<CTRL*> m_PreTransCtrls;      //!< Controls that want PreTranlateMessage
   #endif

      LAYOUT_PANE_ROOT (const LAYOUT_PANE_ROOT&);
      LAYOUT_PANE_ROOT& operator= (const LAYOUT_PANE_ROOT&);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//---------------------------------------------------------------------------------------------------------

//! Main layout pane for a dialog or window.
class LAYOUT_PANE_MAIN : public MGUI::LAYOUT_PANE_ROOT {
   public:

   #ifdef WIN32_MFC
      //! Constructor (MFC version).
      LAYOUT_PANE_MAIN (
         CWnd& RootWnd
         ):
         LAYOUT_PANE_ROOT(RootWnd),
         m_NextControlID(ID_CONTROL_FIRST)
         { m_MainPane = this; }
   #endif

   #ifdef X_NATIVE
      //! Constructor (X version).
      LAYOUT_PANE_MAIN (
         ) { }
   #endif

   #ifdef WIN32_MFC
      //! Allocate next control ID.
      UINT AllocNextControlID (
         ) { return (++m_NextControlID); }
   #endif

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

   #ifdef WIN32_MFC
      UINT m_NextControlID;
   #endif

      LAYOUT_PANE_MAIN (const LAYOUT_PANE_MAIN&);
      LAYOUT_PANE_MAIN& operator= (const LAYOUT_PANE_MAIN&);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//---------------------------------------------------------------------------------------------------------

//! Layout pane intended for general use.
class LAYOUT_PANE : public MGUI::LAYOUT_PANE_BASE {
   public:

      //! Constructor, initializes only, does not create actual pane.
      LAYOUT_PANE (
         ) { }

      //! Destructor.
      virtual ~LAYOUT_PANE (
         ) { }

      //! Create the actual pane.
      void Create (
         MGUI::LAYOUT_PANE_BASE& pane,          //!< 'Parent' pane
         MGUI::LAYOUT_ORIENTATION orientation,  //!< Pane orientation
         MGUI::LAYOUT_SIZEALIGN sizealign,      //!< Sizing/alignment
         int ChildSpacing = 4,                  //!< Spacing between 'children' of pane
         int ExtraBorder = 0                    //!< Extra border around pane, in addition to ChildSpacing
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      LAYOUT_PANE (const LAYOUT_PANE&);
      LAYOUT_PANE& operator= (const LAYOUT_PANE&);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//---------------------------------------------------------------------------------------------------------

//! Layout pane for "book" of tabbed pages.
//! First Initialize the book, then create the pages and finally create the book itself.
class LAYOUT_BOOK : public MGUI::LAYOUT_PANE_BASE {
   public:

      //! Constructor.
      LAYOUT_BOOK (
         );

      //! Create the book after page creation.
      void Create (
         );

      //! Get index to 'active' page.
      //! @return Zero-based index to active page, -1 if none created.
      int GetActiveIndex (
         ) const;

      //! Initialize prior to page creation.
      void Initialize (
         MGUI::LAYOUT_PANE_BASE& ParentPane,    //!< 'Parent' pane
         MGUI::LAYOUT_SIZEALIGN sizealign = MGUI::LAYOUT_SIZEALIGN_FixedSize
         );

      //! Set active page by index.
      void SetActiveIndex (
         int index                              //!< Zero-based page index
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

   #ifdef WIN32_MFC
      ETSLayoutPropertySheet m_PropSheet;
   #endif

   #ifdef X_NATIVE
      SIMPLE_ARRAY<MxTABPAGEITEM> m_TabPageItems;
      Widget m_TabPage;
   #endif

      MGUI::LAYOUT_PANE_BASE *m_pParentPane;
      LAYOUT_SIZEALIGN m_sizealign;

   #ifdef X_NATIVE
      static void TABCB_Create (Widget, int, void*);
      static void TABCB_Activate (Widget, int, void*);
   #endif
      
      LAYOUT_BOOK (const LAYOUT_BOOK&);
      LAYOUT_BOOK& operator= (const LAYOUT_BOOK&);

      friend class LAYOUT_PAGE;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//---------------------------------------------------------------------------------------------------------

//! Layout pane for use as tab page.
class LAYOUT_PAGE : public MGUI::LAYOUT_PANE_ROOT {
   public:

      //! Constructor.
      LAYOUT_PAGE (
         );

      //! Destructor.
      virtual ~LAYOUT_PAGE (
         );

      //! Create page with tab label from resource lookup.
      //! @return Page index.
      int Create (
         MGUI::LAYOUT_BOOK& book,               //!< Book to add page to
         const char *label,                     //!< Label string for resource lookup
         MGUI::LAYOUT_ORIENTATION orientation = MGUI::LAYOUT_ORIENTATION_Vertical
         );

      //! Create page with tab label from MISTRING.
      //! @return Page index.
      int Create (
         MGUI::LAYOUT_BOOK& book,               //!< Book to add page to
         const MISTRING& label,                 //!< Label string
         MGUI::LAYOUT_ORIENTATION orientation = MGUI::LAYOUT_ORIENTATION_Vertical
         );

      //! Determine if this is the 'active' page.
      bool IsActive (
         ) const;

      //! Set whether page is 'enabled' or not.
      void SetEnabled (
         bool enabled = true
         );

   protected:

      //! Create page contents.
      //! Derived class MUST implement this.
      //! This will be called by the page creation code and thus should not be called
      //! directly.
      virtual void OnInitPage (
         ) = 0;

      //! Called when page is made active.
      //! Derived class must call base class BEFORE performing own processing.
      virtual void OnSetActive (
         );

      //! Set to ignore nonvisible items when doing layout.
      //! This must be called before Create() and is usually done in the subclass constructor.
      void SetIgnoreNonVisible (
         bool IgnoreNonVisible = true
         ) { m_IgnoreNonVisible = IgnoreNonVisible; }

      //! Set whether to not automatically add "expanding space" at end (bottom usually) of page.
      //! This must be called before Create() and is usually done in the subclass constructor.
      //! Default behavior is to add expanding space.
      void SetNoSpaceExpanding (
         bool NoSpaceExpanding = true
         ) { m_NoSpaceExpanding = NoSpaceExpanding; }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

   #ifdef WIN32_MFC
      class MYPAGE : public ETSLayoutPropertyPage {
         public:
            MYPAGE (
               LAYOUT_PAGE& page
               ): m_page(page) { }
            virtual ~MYPAGE (
               ) { }
         protected:
            virtual BOOL OnInitDialog ();
            virtual BOOL PreTranslateMessage (MSG *pMsg);
            virtual BOOL OnSetActive ();
         private:
            LAYOUT_PAGE& m_page;
            MYPAGE (const MYPAGE&);
            MYPAGE& operator= (const MYPAGE&);
         };
      friend class MYPAGE;

      MYPAGE m_Page;
      TOOLTIPCTRL *m_ToolTipCtrl;
   #else
      int m_index;
   #endif

      LAYOUT_BOOK *m_pBook;
      MGUI::LAYOUT_ORIENTATION m_Orientation;
      bool m_IgnoreNonVisible;
      bool m_NoSpaceExpanding;

      LAYOUT_PAGE (const LAYOUT_PAGE&);
      LAYOUT_PAGE& operator= (const LAYOUT_PAGE&);

      friend class LAYOUT_BOOK;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//---------------------------------------------------------------------------------------------------------

class LAYOUT_EQUALIZER {
   public:

      //! Dimension to equalize.
      enum EQUALIZE {
         EQUALIZE_Width =     1,
         EQUALIZE_Height =    2,
         EQUALIZE_Both =      3
         };

      //! Constructor.
      LAYOUT_EQUALIZER (
         EQUALIZE equalize = EQUALIZE_Width  //!< What dimension(s) to equalize
         );

      //! Destructor.
      ~LAYOUT_EQUALIZER (
         );

      //! Add MGUI::CTRL to be equalized.
      void Add (
         MGUI::CTRL& control
         );

   #ifdef WIN32_MFC
      //! Add CWnd* control to be equalized.
      void Add (
         CWnd& wnd
         );
   #endif

      //! Perform equalization.
      //! This is automatically done by destructor if not done previously.
      void Equalize (
         );

      //! Set dimensions to equali