mgui/layout.h

Go to the documentation of this file.

#ifndef  INC_MGUI_LAYOUT_H
#define  INC_MGUI_LAYOUT_H

#ifndef  INC_MGUI_BASE_H
#include <mgui/base.h>
#endif

#ifndef INC_MI32_XTABPAGE_H
#include <mi32/xtabpage.h>
#endif

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


#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward declarations.
class MISTRING;
struct COLOR;
class SML_GUI_INTERFACE_BASE;
namespace MGUI {
   class LAYOUT_PANE_ROOT;
   class LAYOUT_PANE_SHELL;
   class LAYOUT_PAGE;
   }
#endif


namespace MGUI {

//=====================================================================================================================

class LAYOUT_PANE_BASE {
   public:

      LAYOUT_PANE_BASE (
         ):
         m_PaneWidget(0)
         { }

      virtual ~LAYOUT_PANE_BASE () = 0;

      void AddSpaceExpanding ();

      void AddSpaceFixed (
         int size
         );

      int ComputeNumFittingCharacters (
         const MISTRING& str,
         int width
         ) const;

      MGUI::POINT ComputeTextSize (
         int width                        
         ) const;

      MGUI::POINT ComputeTextSize (
         const MISTRING& str              
         ) const;

      MGUI::POINT ComputeTextSize (
         TEXTID textid                    
         ) const;

      MGUI::POINT ComputeTextSize (
         const MIUNICODE *str             
         ) const;

      void GetBackgroundColor (
         COLOR& color
         ) const;

      MGUI::POINT GetDimensions () const;

      MDLGPARENT GetDlgParent (
         ) const;

      int GetTextMaxHeight ();

      Widget GetWidget (
         ) const { return (m_PaneWidget); }

      void Invalidate (
         bool erase = true
         );

      bool IsCreated () const
         { return (m_PaneWidget != 0); }

      bool IsVisible (
         ) const;

      void SetBackgroundColor (
         const COLOR& color
         );

      void SetDimensions (
         MGUI::POINT dim
         );

      void SetEnabled (
         bool enabled
         );

      void SetMinimumSize (
         int width,                 
         int height                 
         );

      void SetVisible (
         bool visible
         );

      void UpdateLayout (
         ) { }

      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual SML_GUI_INTERFACE_BASE* GetSMLInterface (
         );
      #endif

   protected:

      void SetPaneWidget (Widget PaneWidget);

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      Widget m_PaneWidget;

      static void CB_Destroy (Widget, LAYOUT_PANE_BASE*, void*);

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

      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================

class LAYOUT_PANE_ROOT : public MGUI::LAYOUT_PANE_BASE {
   public:

      LAYOUT_PANE_ROOT (
         ) { }

      virtual ~LAYOUT_PANE_ROOT ();

      void Init (
         Widget TopPaneWidget                   
         ) { SetPaneWidget(TopPaneWidget); }

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

//=====================================================================================================================

class LAYOUT_PANE_SHELL : public MGUI::LAYOUT_PANE_ROOT {
   public:

      LAYOUT_PANE_SHELL (
         ) { }

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

//=====================================================================================================================

class LAYOUT_PANE : public MGUI::LAYOUT_PANE_BASE {
   public:

      LAYOUT_PANE (
         ) { }

      virtual ~LAYOUT_PANE (
         ) { }

      void Create (
         MGUI::LAYOUT_PANE_BASE& pane,          
         MGUI::LAYOUT_ORIENTATION orientation,  
         MGUI::LAYOUT_SIZEALIGN sizealign,      
         int ChildSpacing = 4,                  
         int ExtraBorder = 0                    
         );

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

//=====================================================================================================================

class LAYOUT_PANE_SASH : public MGUI::LAYOUT_PANE_BASE {
   public:

      LAYOUT_PANE_SASH (
         );

      virtual ~LAYOUT_PANE_SASH (
         );

      void Create (
         MGUI::LAYOUT_PANE_BASE& pane,          
         int Thickness = 4,                     
         int ChildSpacing = 4,                  
         int ExtraBorder = 0                    
         );

      void SetDelegateOnMoved (
         DELEGATE_VOID_NOPARMS delegate
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      class PRIV;
      PRIV *m_pPriv;

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

//=====================================================================================================================

class LAYOUT_BOOK : public MGUI::LAYOUT_PANE_BASE {
   public:

      LAYOUT_BOOK (
         );

      void Create (
         );

      int GetActiveIndex (
         ) const;

      MGUI::LAYOUT_PANE_BASE* GetParentPane (
         ) { return (m_pParentPane); }
      
      void Initialize (
         MGUI::LAYOUT_PANE_BASE& ParentPane,    
         MGUI::LAYOUT_SIZEALIGN sizealign = MGUI::LAYOUT_SIZEALIGN_FixedSize
         );

      void SetActiveIndex (
         int index                              
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      SIMPLE_ARRAY<MxTABPAGEITEM> m_TabPageItems;
      Widget m_TabPage;
      MGUI::LAYOUT_PANE_BASE *m_pParentPane;
      LAYOUT_SIZEALIGN m_sizealign;

      static void TABCB_Create (Widget, int, void*);
      static void TABCB_Activate (Widget, int, void*);
      static void TABCB_Deactivate (Widget, int, void*);
      
      LAYOUT_BOOK (const LAYOUT_BOOK&);
      LAYOUT_BOOK& operator= (const LAYOUT_BOOK&);

      friend class LAYOUT_PAGE;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================

class LAYOUT_PAGE : public MGUI::LAYOUT_PANE_ROOT {
   public:

      typedef fastdelegate::FastDelegate<void(LAYOUT_PAGE&)> DELEGATE;

      LAYOUT_PAGE (
         );

      virtual ~LAYOUT_PAGE (
         );

      int Create (
         MGUI::LAYOUT_BOOK& book,               
         const MISTRING& label,                 
         MGUI::LAYOUT_ORIENTATION orientation = MGUI::LAYOUT_ORIENTATION_Vertical
         );

      int Create (
         MGUI::LAYOUT_BOOK& book,               
         const MISTRING& label,                 
         DELEGATE DelegateOnInitPage,           
         MGUI::LAYOUT_ORIENTATION orientation = MGUI::LAYOUT_ORIENTATION_Vertical,
         bool IgnoreNonVisible = false,         
         bool AddSpaceAtEnd = true              
         );

      bool IsActive (
         ) const;

      void SetDelegateOnInitPage (
         DELEGATE delegate
         ) { m_DelegateOnInitPage = delegate; }

      void SetDelegateOnSetActive (
         DELEGATE delegate
         ) { m_DelegateOnSetActive = delegate; }

      void SetDelegateOnSetInactive (
         DELEGATE delegate
         ) { m_DelegateOnSetInactive = delegate; }

      void SetEnabled (
         bool enabled = true
         );

      void SetIgnoreNonVisible (
         bool IgnoreNonVisible = true
         ) { m_IgnoreNonVisible = IgnoreNonVisible; }

      void SetNoSpaceExpanding (
         bool NoSpaceExpanding = true
         ) { m_NoSpaceExpanding = NoSpaceExpanding; }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      int m_index;
      LAYOUT_BOOK *m_pBook;
      MGUI::LAYOUT_ORIENTATION m_Orientation;
      bool m_IgnoreNonVisible;
      bool m_NoSpaceExpanding;
      DELEGATE m_DelegateOnInitPage;
      DELEGATE m_DelegateOnSetActive;
      DELEGATE m_DelegateOnSetInactive;

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

      friend class LAYOUT_BOOK;
      #endif // GENERATING_DOXYGEN_OUTPUT

      // Overridables.

      virtual void OnInitPage (
         );

      virtual void v_OnSetActive (
         );

      virtual void v_OnSetInactive (
         );

   };

//=====================================================================================================================

class LAYOUT_EQUALIZER {
   public:

      enum EQUALIZE {
         EQUALIZE_Width =     1,
         EQUALIZE_Height =    2,
         EQUALIZE_Both =      3
         };

      LAYOUT_EQUALIZER (
         EQUALIZE equalize = EQUALIZE_Width  
         );

      ~LAYOUT_EQUALIZER (
         );

      void Add (
         MGUI::CTRL& control
         );

      void Equalize ();

      void SetEqualize (
         EQUALIZE equalize
         ) { m_equalize = equalize; }

      void SetMinimumSize (
         int minwidth,
         int minheight = 0
         ) { m_minwidth = minwidth; m_minheight = minheight; }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      class WLIST;

      EQUALIZE m_equalize;
      WLIST *m_plist;
      int m_minwidth;
      int m_minheight;

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

//=====================================================================================================================

}  // End of MGUI namespace

#endif   // INC_MGUI_LAYOUT_H

---