mgui/ctrl.h

Go to the documentation of this file.

#ifndef INC_MGUI_CTRL_H
#define  INC_MGUI_CTRL_H

#ifndef INC_MGUI_FORM_H
#include <mgui/form.h>
#endif

#ifndef INC_MGUI_KEYSTATE_H
#include <mgui/keystate.h>
#endif

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

#ifndef  INC_MI32_ICONID_H
#include <mi32/iconid.h>
#endif

#ifndef INC_MI32_XBASE_H
#include <mi32/xbase.h>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward declarations.
struct COLOR;
namespace MGUI {
   class CTRL_TOOLBAR;
   class CTRL_TOOLTIP;
   class SHELL;
   class ICON;
   }
#endif


namespace MGUI {

//===================================================================================================================
class CTRL : public MGUI::FORM {
   public:

      enum SHADOW {
         SHADOW_None =     0,
         SHADOW_Black,
         SHADOW_White,
         SHADOW_In,
         SHADOW_Out
         };

      typedef fastdelegate::FastDelegate<void(int, int)> DELEGATE_ONSIZE;

      static const COLOR& GetBackgroundColor (
         );

      static void ProcessWidgetEvents (
         Widget widget
         );

      static void SetWidgetShadow (
         Widget widget,
         SHADOW shadow
         );

      virtual ~CTRL (
         ) = 0;

      void GetBackgroundColor (
         COLOR& color
         ) const;

      void GetDimensions (
         MGUI::POINT& dimensions    
         ) const;

      MDLGPARENT GetDlgParent (
         ) const;

      SHELL* GetShell (
         ) const;

      CTRL_TOOLTIP* GetToolTip (
         ) const;

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

      void Invalidate (
         bool erase = true
         );

      virtual bool IsCreated (
         ) const;

      virtual bool IsEnabled (
         ) const;

      bool IsVisible (
         ) const;

      void SetBackgroundColor (
         const COLOR& color
         );

      void SetDimensions (
         MGUI::POINT dimensions     
         );

      virtual void SetEnabled (
         bool enabled = true
         );

      void SetForegroundColor (
         const COLOR& color
         );

      void SetMinimumSize (
         int width,                 
         int height                 
         );

      void SetSizeByKey (
         const char *SizeKey
         );

      void SetToolTipString (
         const MISTRING& string        
         );

      virtual void SetVisible (
         bool visible = true
         );

      void UpdateWindow (
         );

   protected:

      // Set shadow values in XTARGS.
      static void SetShadowArgs (XTARGS& args, SHADOW shadow);

      Widget m_widget;

      CTRL (
         ): m_widget(0) { }

      void AddDestroyCallback (
         );

      virtual void v_OnDestroyWidget (
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

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

      // MGUI::FORM overrides.
      virtual void v_SetFocus () const;

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


//===================================================================================================================
class CTRL_LABEL : public MGUI::CTRL {
   public:

      enum STYLE {
         STYLE_LeftNoWrap,                      
         STYLE_Left,                            
         STYLE_Center,                          
         STYLE_Right                            
         };

      CTRL_LABEL ();

      ~CTRL_LABEL ();

      void Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane,    
         const MISTRING& label,                 
         MGUI::LAYOUT_SIZEALIGN sizealign = MGUI::LAYOUT_SIZEALIGN_FixedSize,
         STYLE style = STYLE_LeftNoWrap
         );

      void Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane,    
         const MGUI::ICON& icon,                
         const MISTRING& tooltip                
         );

      void Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane,    
         ICONID iconid,                         
         const MISTRING& tooltip,               
         UINT16 iconsize = 0
         );

      void SetIcon (
         const MGUI::ICON& icon                 
         );

      void SetIcon (
         ICONID iconid,                         
         UINT16 iconsize = 0
         );

      void SetLabel (
         const MISTRING& string
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      Pixmap m_PixmapNormal;
      Pixmap m_PixmapDisabled;

      void CreateIconX (
         MGUI::LAYOUT_PANE_BASE& ParentPane,
         const MGUI::ICON& icon
         );

      void CreateX (
         MGUI::LAYOUT_PANE_BASE& ParentPane,
         XTARGS& args,
         const char *name,
         MGUI::LAYOUT_SIZEALIGN sizealign,
         STYLE style
         );

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


//===================================================================================================================
class CTRL_GROUPBOX : public MGUI::CTRL {
   public:

      enum BOXSTYLE {
         BOXSTYLE_EtchedIn,
         BOXSTYLE_EtchedOut,
         BOXSTYLE_ShadowIn,
         BOXSTYLE_ShadowOut
         };

      CTRL_GROUPBOX (
         );

      virtual ~CTRL_GROUPBOX (
         );

      operator MGUI::LAYOUT_PANE_BASE& (
         ) { return (m_GroupBoxPane); }

      void Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane, 
         MGUI::LAYOUT_ORIENTATION orientation = MGUI::LAYOUT_ORIENTATION_Vertical,
         MGUI::LAYOUT_SIZEALIGN sizealign = MGUI::LAYOUT_SIZEALIGN_FixedSize,
         int ChildSpacing = 4,               
         int ExtraBorder = 0,                
         BOXSTYLE BoxStyle = BOXSTYLE_EtchedIn
         );

      void Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane, 
         const MISTRING& string,             
         MGUI::LAYOUT_ORIENTATION orientation = MGUI::LAYOUT_ORIENTATION_Vertical,
         MGUI::LAYOUT_SIZEALIGN sizealign = MGUI::LAYOUT_SIZEALIGN_FixedSize,
         int ChildSpacing = 4,               
         int ExtraBorder = 0                 
         );

      MGUI::LAYOUT_PANE_BASE& GetPane (
         ) { return (m_GroupBoxPane); }

      void SetLabelText (
         const MISTRING& label
         );

   private:

      #ifndef GENERATING_DOXYGEN_OUTPUT
      class LAYOUT_PANE : public MGUI::LAYOUT_PANE_BASE {
         public:
            LAYOUT_PANE (
               ) { }
            virtual ~LAYOUT_PANE (
               ) { }
            void Create (
               Widget FrameWidget,
               MGUI::LAYOUT_ORIENTATION orientation,
               MGUI::LAYOUT_SIZEALIGN sizealign,
               int ChildSpacing,
               int ExtraBorder,
               int TopExtra
               );
         private:
            LAYOUT_PANE (const LAYOUT_PANE&);
            LAYOUT_PANE& operator= (const LAYOUT_PANE&);
         };

      LAYOUT_PANE m_GroupBoxPane;

      Widget m_label;
      void CreateX (
         MGUI::LAYOUT_PANE_BASE& ParentPane,
         MGUI::LAYOUT_ORIENTATION orientation,
         MGUI::LAYOUT_SIZEALIGN sizealign,
         int ChildSpacing,
         int ExtraBorder,
         BOXSTYLE BoxStyle = BOXSTYLE_EtchedIn
         );

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


//===================================================================================================================
class CTRL_PUSHBUTTON : public MGUI::CTRL {
   public:

      enum STYLE {
         STYLE_Default =               0,
         STYLE_NoFrame =               0x01,    
         STYLE_NoMargin =              0x02,    
         STYLE_SetCursor =             0x04,    
         STYLE_WideMargins =           0x08,    
         STYLE_HighlightOnMouseOver =  0x10,    
         STYLE_ShadowOnMouseOver =     0x20,    
         STYLE_TextAtLeft =            0x40,    
         };

      CTRL_PUSHBUTTON ();

      virtual ~CTRL_PUSHBUTTON ();

      void Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane,    
         const MISTRING& label,                 
         STYLE style = STYLE_Default,           
         MGUI::LAYOUT_SIZEALIGN sizealign = MGUI::LAYOUT_SIZEALIGN_FixedSize
         );

      void Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane,    
         const MGUI::ICON& icon,                
         const MISTRING& tooltip,               
         STYLE style = STYLE_Default,           
         MGUI::LAYOUT_SIZEALIGN sizealign = MGUI::LAYOUT_SIZEALIGN_FixedSize
         );

      void Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane,    
         const MGUI::ICON& iconNormal,          
         const MGUI::ICON& iconMouseOver,       
         const MISTRING& tooltip,               
         STYLE style = STYLE_Default,           
         MGUI::LAYOUT_SIZEALIGN sizealign = MGUI::LAYOUT_SIZEALIGN_FixedSize
         );

      void Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane,    
         ICONID iconid,                         
         const MISTRING& tooltip,               
         UINT16 iconsize = 0,                   
         STYLE style = STYLE_Default,           
         MGUI::LAYOUT_SIZEALIGN sizealign = MGUI::LAYOUT_SIZEALIGN_FixedSize
         );

      void SetDelegateOnPressed (
         DELEGATE_VOID_NOPARMS delegate
         ) { m_DelegateOnPressed = delegate; }

      void UpdateIcon (
         const MGUI::ICON& icon                 
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      DELEGATE_VOID_NOPARMS m_DelegateOnPressed;

      static void CB_PushButton (Widget, CTRL_PUSHBUTTON*, void*);
      static void XEH_Icon (Widget, CTRL_PUSHBUTTON*, XEvent*, void*);
      static void XEH_Text (Widget, CTRL_PUSHBUTTON*, XEvent*, void*);

      Pixmap m_PixmapUnarmed;
      Pixmap m_PixmapDisabled;
      Pixmap m_PixmapArmed;
      Pixmap m_PixmapMouseOver;
      STYLE m_style;

      void CreateIconX (
         LAYOUT_PANE_BASE& ParentPane,
         const MGUI::ICON& Icon,
         const MGUI::ICON *pIconMouseOver,
         const MISTRING& tooltip,
         STYLE style,
         MGUI::LAYOUT_SIZEALIGN sizealign
         );

      void CreateWidget (
         LAYOUT_PANE_BASE& ParentPane,
         XTARGS& args,
         const char *name
         );

      CTRL_PUSHBUTTON (const CTRL_PUSHBUTTON&);
      CTRL_PUSHBUTTON& operator= (const CTRL_PUSHBUTTON&);
      #endif // GENERATING_DOXYGEN_OUTPUT

      // Overridables.

      virtual void OnPressed ();

   };
#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(CTRL_PUSHBUTTON::STYLE)
#endif


//===================================================================================================================
class CTRL_TOGGLEBUTTON : public MGUI::CTRL {
   public:

      enum STYLE {
         STYLE_Check =        0x00,             
         STYLE_Radio =        0x01,             
         STYLE_NoMargin =     0x04,             
         STYLE_NoFrame =      0x08,             
         };

      CTRL_TOGGLEBUTTON ();

      virtual ~CTRL_TOGGLEBUTTON ();

      void Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane,    
         const MISTRING& label,                 
         STYLE style = STYLE_Check,             
         bool dftvalue = false,                 
         MGUI::LAYOUT_SIZEALIGN sizealign = MGUI::LAYOUT_SIZEALIGN_FixedSize
         );

      void Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane,    
         const MGUI::ICON& icon,                
         const MISTRING& tooltip,               
         STYLE style = STYLE_Check,             
         bool dftvalue = false                  
         );

      void Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane,    
         const MGUI::ICON& IconOff,             
         const MGUI::ICON& IconOn,              
         const MISTRING& tooltip,               
         STYLE style = STYLE_Check,             
         bool dftvalue = false                  
         );

      void Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane,    
         ICONID iconid,                         
         const MISTRING& tooltip,               
         STYLE style = STYLE_Check,             
         bool dftvalue = false,                 
         UINT16 iconsize = 0                    
         );

      bool GetValue () const
         { return (m_value); }

      void SetDelegateOnPressed (
         DELEGATE_VOID_NOPARMS delegate
         ) { m_DelegateOnPressed = delegate; }

      void SetValue (
         bool value,                            
         bool notify = true                     
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      DELEGATE_VOID_NOPARMS m_DelegateOnPressed;

      bool m_value;

      static void CB_ToggleButton (Widget, CTRL_TOGGLEBUTTON*, void*);
      static void XT_EventHandler (Widget, CTRL_TOGGLEBUTTON*, XEvent*, void*);

      Pixmap m_PixmapOffNormal;
      Pixmap m_PixmapOffDisabled;
      Pixmap m_PixmapOffMouseOver;
      Pixmap m_PixmapOnNormal;
      Pixmap m_PixmapOnDisabled;
      Pixmap m_PixmapOnMouseOver;

      void CreateIconX (
         MGUI::LAYOUT_PANE_BASE& ParentPane,
         const MGUI::ICON& IconOff,
         const MGUI::ICON& IconOn,
         const MISTRING& tooltip,
         STYLE style,
         bool dftvalue
         );

      void CreateWidget (
         MGUI::LAYOUT_PANE_BASE& ParentPane,
         XTARGS& args,
         const char* label,
         STYLE style,
         bool dftvalue
         );

      CTRL_TOGGLEBUTTON (const CTRL_TOGGLEBUTTON&);
      CTRL_TOGGLEBUTTON& operator= (const CTRL_TOGGLEBUTTON&);
      #endif // GENERATING_DOXYGEN_OUTPUT

      // Overridables.

      virtual void OnPressed ();

   };
#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(CTRL_TOGGLEBUTTON::STYLE)
#endif


//===================================================================================================================
class CTRL_TEXT : public MGUI::CTRL {
   public:

      enum STYLE {
         STYLE_NoScrollBars =    0x0000,
         STYLE_ScrollH =         0x0001,
         STYLE_ScrollV =         0x0002,
         STYLE_ScrollBoth =      (STYLE_ScrollH|STYLE_ScrollV),
         STYLE_WidthInPixels =   0x0004,
         STYLE_NoFrame =         0x0008,     
         STYLE_NoMargin =        0x0010,     
         };

      CTRL_TEXT ()
         { }

      void Clear (
         );

      void ClearSelection ();

      void Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane,    
         int width = 40,                        
         int height = 10,                       
         STYLE style = STYLE_NoScrollBars,      
         MGUI::LAYOUT_SIZEALIGN sizealign = MGUI::LAYOUT_SIZEALIGN_Expand
         );

      void SetSelection (
         int StartChar = 0,                  
         int EndChar = -1,                   
         bool NoScroll = true                
         );

      void SetString (
         const MISTRING& string                 
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      CTRL_TEXT (const CTRL_TEXT&);
      CTRL_TEXT& operator= (const CTRL_TEXT&);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(CTRL_TEXT::STYLE)
#endif

//===================================================================================================================
class CTRL_SEPARATOR : public MGUI::CTRL {
   public:

      enum CTRLSTYLE {
         CTRLSTYLE_Solid,                       
         CTRLSTYLE_Dashed,                      
         CTRLSTYLE_ShadowEtchedIn,              
         CTRLSTYLE_ShadowEtchedOut              
         };

      enum ORIENTATION {
         ORIENTATION_Automatic,                 
         ORIENTATION_Horizontal,
         ORIENTATION_Vertical
         };

      CTRL_SEPARATOR ();

      ~CTRL_SEPARATOR ();

      void Create (
         LAYOUT_PANE_BASE& ParentPane,          
         CTRLSTYLE type = CTRLSTYLE_ShadowEtchedIn,
         UINT8 thickness = 1,                   
         int length = 0,                        
         ORIENTATION orientation = ORIENTATION_Automatic
         );

      void Create (
         LAYOUT_PANE_BASE& ParentPane,          
         const MISTRING& label,                 
         CTRLSTYLE type = CTRLSTYLE_ShadowEtchedIn,
         UINT8 thickness = 1                    
         );

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

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

}  // End of MGUI namespace

#endif   // INC_MGUI_CTRL_H

---