mgui/edit.h

Go to the documentation of this file.

#ifndef  INC_MGUI_EDIT_H
#define  INC_MGUI_EDIT_H

#ifndef  INC_MGUI_EDITBASE_H
#include <mgui/editbase.h>
#endif

#ifndef  INC_MGUI_KEYCODE_H
#include <mgui/keycode.h>
#endif

#ifndef  INC_MI32_RANGE_H
#include <mi32/range.h>
#endif

#ifndef  INC_MI32_LATLONFM_H
#include <mi32/latlonfm.h>
#endif

#ifndef  INC_MI32_UNITCONV_H
#include <mi32/unitconv.h>
#endif


#ifndef  GENERATING_DOXYGEN_OUTPUT
struct TEXTSTYLE;
struct COLOR;
struct XeTextSyntaxParseCallbackData;
#endif


namespace MGUI {

//===================================================================================================================
class CTRL_EDIT_STRING : public MGUI::CTRL_EDIT_BASE {
   public:

      enum FLAGS {
         FLAG_Default =             CTRL_EDIT_BASE::CREATEFLAG_None,
         FLAG_RightJustify =        CTRL_EDIT_BASE::CREATEFLAG_RightAlign,          
         FLAG_ReadOnly =            CTRL_EDIT_BASE::CREATEFLAG_ReadOnly,            
         FLAG_Opaque =              CTRL_EDIT_BASE::CREATEFLAG_Opaque,              
         FLAG_WidthInPixels =       CTRL_EDIT_BASE::CREATEFLAG_WidthInPixels,       
         FLAG_UseFixedWidthFont =   CTRL_EDIT_BASE::CREATEFLAG_UseFixedWidthFont,   
         };

      CTRL_EDIT_STRING (
         );

      virtual ~CTRL_EDIT_STRING (
         );

      void ClearValue (
         bool notify = true                     
         );

      void Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane,    
         int maxlen,                            
         int width = 0,                         
         FLAGS flags = FLAG_Default,
         MGUI::LAYOUT_SIZEALIGN sizealign = MGUI::LAYOUT_SIZEALIGN_FixedHeight
         );

      const MISTRING& GetValue (
         );

      void IniRead (
         INIHANDLE IniHandle,                
         const char *IniGroup,               
         const char *IniField,               
         bool notify = true                  
         );

      void IniWrite (
         INIHANDLE IniHandle,                
         const char *IniGroup,               
         const char *IniField                
         ) const { ::IniWrite(IniHandle,IniGroup,IniField,m_value); }

      void SetCursorPos (
         int nCharIndex
         );

      void SetDelegateOnValidate (
         FastDelegate<bool(MISTRING&)> delegate
         ) { m_DelegateOnValidate = delegate; }

      void SetValue (
         const MIUNICODE* string,               
         bool notify = true                  
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      FastDelegate<bool(MISTRING&)> m_DelegateOnValidate;
      MISTRING m_value;

      bool OnValidate (MISTRING& string) const;

      virtual void v_UpdateValue (MISTRING& newvalue);

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

      virtual bool v_OnValidate (
         MISTRING& string                    
         ) const;

   };

#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(MGUI::CTRL_EDIT_STRING::FLAGS)
#endif


//===================================================================================================================
class FORM_EDIT_STRING : public MGUI::FORM_COMPOSITE {
   public:
      FORM_EDIT_STRING (
         );

      virtual ~FORM_EDIT_STRING (
         );

      void ClearValue (
         bool notify = true                     
         ) { m_editctrl.ClearValue(notify); }

      void Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane,    
         const MISTRING& label,                 
         int maxlen,                            
         int width = 0,                         
         MGUI::CTRL_EDIT_STRING::FLAGS flags = MGUI::CTRL_EDIT_STRING::FLAG_Default,
         MGUI::LAYOUT_SIZEALIGN sizealign = MGUI::LAYOUT_SIZEALIGN_FixedHeight,
         MGUI::CTRL_LABEL::STYLE labelstyle = MGUI::CTRL_LABEL::STYLE_LeftNoWrap
         );

      MGUI::CTRL_EDIT_STRING& GetEditCtrl (
         ) { return (m_editctrl); }

      MGUI::CTRL_LABEL& GetLabel (
         ) { return (m_label); }

      const MISTRING& GetValue (
         ) { return (m_editctrl.GetValue()); }

      bool HasValue (
         ) const { return (m_editctrl.HasValue()); }

      void IniRead (
         INIHANDLE IniHandle,                
         const char *IniGroup,               
         const char *IniField,               
         bool notify = true                  
         ) { m_editctrl.IniRead(IniHandle,IniGroup,IniField,notify); }

      void IniWrite (
         INIHANDLE IniHandle,                
         const char *IniGroup,               
         const char *IniField                
         ) const { m_editctrl.IniWrite(IniHandle,IniGroup,IniField); }

      void SetDelegateOnActivate (
         DELEGATE_VOID_NOPARMS delegate
         ) { m_editctrl.SetDelegateOnActivate(delegate); }

      void SetDelegateOnChangeValue (
         DELEGATE_VOID_NOPARMS delegate
         ) { m_editctrl.SetDelegateOnChangeValue(delegate); }

      void SetDelegateOnUserEdit (
         DELEGATE_VOID_NOPARMS delegate
         ) { m_editctrl.SetDelegateOnUserEdit(delegate); }

      void SetDelegateOnValidate (
         FastDelegate<bool(MISTRING&)> delegate
         ) { m_editctrl.SetDelegateOnValidate(delegate); }

      void SetLabel (
         const MISTRING& label                  
         ) { m_label.SetLabel(label); }

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

      void SetValidChars (
         const MIUNICODE* string,               
         bool invert = false                 
         ) { m_editctrl.SetValidChars(string,invert); }

      void SetValue (
         const MIUNICODE* string,               
         bool notify = true                  
         ) { m_editctrl.SetValue(string,notify); }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      CTRL_LABEL m_label;
      CTRL_EDIT_STRING m_editctrl;
      // MGUI::FORM overrides.
      virtual void v_SetFocus () const;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//===================================================================================================================
class CTRL_EDIT_NUMBER : public MGUI::CTRL_EDIT_BASE {
   public:

      enum FLAGS {
         FLAG_Default =             CTRL_EDIT_BASE::CREATEFLAG_None,
         FLAG_ReadOnly =            CTRL_EDIT_BASE::CREATEFLAG_ReadOnly,            
         FLAG_Opaque =              CTRL_EDIT_BASE::CREATEFLAG_Opaque,              
         FLAG_WidthInPixels =       CTRL_EDIT_BASE::CREATEFLAG_WidthInPixels,       
         FLAG_UseFixedWidthFont =   CTRL_EDIT_BASE::CREATEFLAG_UseFixedWidthFont,   
         FLAG_NoMin =               0x0001,  
         FLAG_NoMax =               0x0002,  
         FLAG_NoRange =             0x0003,  
         FLAG_NoDefault =           0x0004,  
         FLAG_AddOne =              0x0008,  
         FLAG_BlankZero =           0x0020,  
         FLAG_LeftJustify =         0x0080   
         };

      enum FORMAT {
         FORMAT_Decimal,
         FORMAT_Exponential,
         FORMAT_Latitude,
         FORMAT_Longitude,
         FORMAT_DegMinSec
         };

      CTRL_EDIT_NUMBER (
         );

      virtual ~CTRL_EDIT_NUMBER (
         );

      void ClearValue (
         bool notify = true                     
         );

      void Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane,    
         double dft,                            
         double min,                            
         double max,                            
         int places = 0,                        
         int width = 0,                         
         FLAGS flags = FLAG_Default,            
         FORMAT format = FORMAT_Decimal,        
         MGUI::LAYOUT_SIZEALIGN sizealign = MGUI::LAYOUT_SIZEALIGN_FixedSize
         );

      const DOUBLE_RANGE& GetRange (
         ) const { return (m_range); }

      double GetValue (
         );

      bool HasValue (
         );

      void IniRead (
         INIHANDLE IniHandle,                   
         const char *IniGroup,                  
         const char *IniField,                  
         bool notify = true                     
         );

      void IniWrite (
         INIHANDLE IniHandle,                   
         const char *IniGroup,                  
         const char *IniField                   
         ) const { ::IniWrite(IniHandle,IniGroup,IniField,m_value); }

      void SetFormat (
         FORMAT format,
         int places = -2,                       
         bool notify = true
         );
/*
      void SetLatLonFormat (
         DEGTOSTRFLAGS flags
         );
*/
      bool SetRange (
         const DOUBLE_RANGE& range,             
         bool notify = true,                    
         FLAGS flags = FLAG_Default             
         );

      bool SetRange (
         double minimum,                        
         double maximum,                        
         bool notify = true,                    
         FLAGS flags = FLAG_Default             
         );

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

      void SetUnitConversion (
         const UNITCONV& unitconv
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      CTRL_LABEL m_UnitLabel;
      FORMAT m_Format;
      FLAGS m_flags;
      DMSTYPE m_DegToStrFlags;
      INT16 m_places;
      INT16 m_dmsplaces;
      double m_value;
      DOUBLE_RANGE m_range;
      UNITCONV m_unitconv;

      bool CheckRange (double& value) const;
//    void SetDegToStrFlags (DEGTOSTRFLAGS flags);
      void UpdateText ();

      virtual void v_UpdateValue (MISTRING& newvalue);

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

#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(MGUI::CTRL_EDIT_NUMBER::FLAGS)
#endif


//===================================================================================================================
class FORM_EDIT_NUMBER_BASE : public MGUI::FORM_COMPOSITE {
   public:
      FORM_EDIT_NUMBER_BASE ();

      virtual ~FORM_EDIT_NUMBER_BASE ();

      void ClearValue (
         bool notify = true                     
         ) { m_editctrl.ClearValue(notify); }

      MGUI::CTRL_EDIT_NUMBER& GetEditCtrl (
         ) { return (m_editctrl); }

      const DOUBLE_RANGE& GetRange (
         ) const { return (m_editctrl.GetRange()); }

      double GetValue (
         ) { return (m_editctrl.GetValue()); }

      bool HasValue (
         ) { return (m_editctrl.HasValue()); }

      void IniRead (
         INIHANDLE IniHandle,                
         const char *IniGroup,               
         const char *IniField,               
         bool notify = true                  
         ) { m_editctrl.IniRead(IniHandle,IniGroup,IniField,notify); }

      void IniWrite (
         INIHANDLE IniHandle,                
         const char *IniGroup,               
         const char *IniField                
         ) const { m_editctrl.IniWrite(IniHandle,IniGroup,IniField); }

      void SetDelegateOnActivate (
         DELEGATE_VOID_NOPARMS delegate
         ) { m_editctrl.SetDelegateOnActivate(delegate); }

      void SetDelegateOnChangeValue (
         DELEGATE_VOID_NOPARMS delegate
         ) { m_editctrl.SetDelegateOnChangeValue(delegate); }

      void SetDelegateOnUserEdit (
         DELEGATE_VOID_NOPARMS delegate
         ) { m_editctrl.SetDelegateOnUserEdit(delegate); }

      void SetFormat (
         MGUI::CTRL_EDIT_NUMBER::FORMAT format,
         int places = -1,                    
         bool notify = true
         ) { m_editctrl.SetFormat(format,places,notify); }

      bool SetRange (
         const DOUBLE_RANGE& range,          
         bool notify = true,                 
         MGUI::CTRL_EDIT_NUMBER::FLAGS flags = MGUI::CTRL_EDIT_NUMBER::FLAG_Default    
         ) { return (m_editctrl.SetRange(range,notify,flags)); }

      bool SetRange (
         double minimum,                        
         double maximum,                        
         bool notify = true,                 
         MGUI::CTRL_EDIT_NUMBER::FLAGS flags = MGUI::CTRL_EDIT_NUMBER::FLAG_Default    
         ) { return (m_editctrl.SetRange(minimum,maximum,notify,flags)); }

      void SetReadOnly (
         bool ReadOnly = true                
         ) { m_editctrl.SetReadOnly(ReadOnly); }

      void SetValue (
         double value,                       
         bool notify = true                  
         ) { m_editctrl.SetValue(value,notify); }

      void SetUnitConversion (
         const UNITCONV& unitconv            
         ) { m_editctrl.SetUnitConversion(unitconv); }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      CTRL_EDIT_NUMBER m_editctrl;
      // MGUI::FORM overrides.
      virtual void v_SetFocus () const;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//===================================================================================================================
class FORM_EDIT_NUMBER : public FORM_EDIT_NUMBER_BASE {
   public:

      FORM_EDIT_NUMBER ();

      virtual ~FORM_EDIT_NUMBER ();

      void Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane, 
         const MISTRING& label,              
         double dft,                         
         double min,                         
         double max,                         
         int places = 0,                     
         int width = 0,                      
         CTRL_EDIT_NUMBER::FLAGS flags = CTRL_EDIT_NUMBER::FLAG_Default,         
         CTRL_EDIT_NUMBER::FORMAT format = CTRL_EDIT_NUMBER::FORMAT_Decimal,     
         LAYOUT_SIZEALIGN sizealign = LAYOUT_SIZEALIGN_FixedSize,
         CTRL_LABEL::STYLE labelstyle = CTRL_LABEL::STYLE_LeftNoWrap
         );

      CTRL_LABEL& GetLabel (
         ) { return (m_label); }

      void SetLabel (
         const MISTRING& label                  
         ) { m_label.SetLabel(label); }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      CTRL_LABEL m_label;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//===================================================================================================================
class FORM_EDIT_NUMBER2 : public FORM_EDIT_NUMBER_BASE {
   public:

      FORM_EDIT_NUMBER2 ();

      virtual ~FORM_EDIT_NUMBER2 ();

      void Create (
         LAYOUT_PANE_BASE& ParentPane, 
         const MISTRING& labelBefore,        
         const MISTRING& labelAfter,         
         double dft,                         
         double min,                         
         double max,                         
         int places = 0,                     
         int width = 0,                      
         CTRL_EDIT_NUMBER::FLAGS flags = CTRL_EDIT_NUMBER::FLAG_Default,         
         CTRL_EDIT_NUMBER::FORMAT format = CTRL_EDIT_NUMBER::FORMAT_Decimal,     
         LAYOUT_SIZEALIGN EditSizeAlign = LAYOUT_SIZEALIGN_FixedSize,
         LAYOUT_SIZEALIGN LabelAfterSizeAlign = LAYOUT_SIZEALIGN_FixedSize       
         );

      CTRL_LABEL& GetLabelAfter (
         ) { return (m_labelAfter); }

      void SetLabelAfter (
         const MISTRING& label                  
         ) { m_labelAfter.SetLabel(label); }

      MGUI::CTRL_LABEL& GetLabelBefore (
         ) { return (m_labelBefore); }

      void SetLabelBefore (
         const MISTRING& label                  
         ) { m_labelBefore.SetLabel(label); }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      CTRL_LABEL m_labelBefore;
      CTRL_LABEL m_labelAfter;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//===================================================================================================================
class FORM_EDIT_RANGE : public MGUI::FORM_COMPOSITE {
   public:

      FORM_EDIT_RANGE (
         );

      virtual ~FORM_EDIT_RANGE (
         );

      void ClearValue (
         bool notify = true                     
         );

      void Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane,    
         const DOUBLE_RANGE& dft,               
         double min,                            
         double max,                            
         double mininterval = 0,                
         int places = 0,                        
         int width = 0,                         
         CTRL_EDIT_NUMBER::FLAGS flags = CTRL_EDIT_NUMBER::FLAG_Default,            
         CTRL_EDIT_NUMBER::FORMAT format = CTRL_EDIT_NUMBER::FORMAT_Decimal,        
         MGUI::LAYOUT_SIZEALIGN sizealign = MGUI::LAYOUT_SIZEALIGN_FixedSize
         );

      void Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane,    
         const MISTRING& label,                 
         const DOUBLE_RANGE& dft,               
         double min,                            
         double max,                            
         double mininterval = 0,                
         int places = 0,                        
         int width = 0,                         
         CTRL_EDIT_NUMBER::FLAGS flags = CTRL_EDIT_NUMBER::FLAG_Default,            
         CTRL_EDIT_NUMBER::FORMAT format = CTRL_EDIT_NUMBER::FORMAT_Decimal,        
         MGUI::LAYOUT_SIZEALIGN sizealign = MGUI::LAYOUT_SIZEALIGN_FixedSize,
         MGUI::CTRL_LABEL::STYLE labelstyle = MGUI::CTRL_LABEL::STYLE_LeftNoWrap
         );

      MGUI::CTRL_EDIT_NUMBER& GetEditCtrlMax (
         ) { return (m_MaxEN); }

      MGUI::CTRL_EDIT_NUMBER& GetEditCtrlMin (
         ) { return (m_MinEN); }

      const DOUBLE_RANGE& GetRange (
         ) const { return (m_MinEN.GetRange()); }

      MGUI::CTRL_LABEL& GetLabel (
         ) { return (m_RangeLabel); }

      DOUBLE_RANGE GetValue (
         ) { return (DOUBLE_RANGE(m_MinEN.GetValue(),m_MaxEN.GetValue())); }

      bool HasValue (
         ) { return (m_MinEN.HasValue() && m_MaxEN.HasValue()); }

      void SetAutoSwap (
         bool AutoSwap = true
         ) { m_AutoSwap = AutoSwap; }

      void SetDelegateOnChangeValue (
         DELEGATE_VOID_NOPARMS delegate
         ) { m_DelegateOnChangeValue = delegate; }

      void SetFormat (
         CTRL_EDIT_NUMBER::FORMAT format,
         int places = -1                     
         ) {
         m_MinEN.SetFormat(format,places);
         m_MaxEN.SetFormat(format,places);
         }

      void SetLabel (
         const MISTRING& label                  
         ) { m_RangeLabel.SetLabel(label); }
/*
      void SetLatLonFormat (
         DEGTOSTRFLAGS flags
         ) {
         m_MinEN.SetLatLonFormat(flags);
         m_MaxEN.SetLatLonFormat(flags);
         }
*/
      bool SetMinInterval (
         double MinInterval,
         bool notify = true
         );

      bool SetRange (
         const DOUBLE_RANGE& range,             
         bool notify = true,                    
         CTRL_EDIT_NUMBER::FLAGS flags = CTRL_EDIT_NUMBER::FLAG_Default          
         );

      bool SetRange (
         double minimum,                        
         double maximum,                        
         bool notify = true,                    
         CTRL_EDIT_NUMBER::FLAGS flags = CTRL_EDIT_NUMBER::FLAG_Default          
         );

      void SetReadOnly (
         bool ReadOnly = true                
         ) {
         m_MinEN.SetReadOnly(ReadOnly);
         m_MaxEN.SetReadOnly(ReadOnly);
         }

      void SetUnitConversion (
         const UNITCONV& unitconv
         ) {
         m_MinEN.SetUnitConversion(unitconv);
         m_MaxEN.SetUnitConversion(unitconv);
         }

      void SetUnitLabel (
         const MISTRING& label
         );

      void SetValue (
         const DOUBLE_RANGE& value,
         bool notify = true
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      DELEGATE_VOID_NOPARMS m_DelegateOnChangeValue;
      CTRL_LABEL m_RangeLabel;
      CTRL_EDIT_NUMBER m_MinEN;
      CTRL_LABEL m_ToLabel;
      CTRL_EDIT_NUMBER m_MaxEN;
      CTRL_LABEL m_UnitLabel;
      double m_MinInterval;
      bool m_AutoSwap;

      bool AdjustForInterval (CTRL_EDIT_NUMBER *pEN = 0);

      void CreateMinToMax (
         const DOUBLE_RANGE& dft,
         double min,
         double max,
         double mininterval,
         int places,
         int width,
         CTRL_EDIT_NUMBER::FLAGS flags,
         CTRL_EDIT_NUMBER::FORMAT format,
         MGUI::LAYOUT_SIZEALIGN sizealign
         );

      void NotifyChangeValue ();
      void OnChangeValueMax ();
      void OnChangeValueMin ();

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

      #endif // GENERATING_DOXYGEN_OUTPUT

   };


//===================================================================================================================
class CTRL_EDIT_TEXT : public MGUI::CTRL_EDIT_BASE {
   public:

      enum FLAGS {
         FLAG_Default =             CTRL_EDIT_BASE::CREATEFLAG_None,
         FLAG_RightJustify =        CTRL_EDIT_BASE::CREATEFLAG_RightAlign,          
         FLAG_ReadOnly =            CTRL_EDIT_BASE::CREATEFLAG_ReadOnly,            
         FLAG_Opaque =              CTRL_EDIT_BASE::CREATEFLAG_Opaque,              
         FLAG_WidthInPixels =       CTRL_EDIT_BASE::CREATEFLAG_WidthInPixels,       
         FLAG_UseFixedWidthFont =   CTRL_EDIT_BASE::CREATEFLAG_UseFixedWidthFont,   
         FLAG_SizeInPixels =        CTRL_EDIT_BASE::CREATEFLAG_SizeInPixels,        
         FLAG_WYSIWYG =             0x0001,  
         FLAG_NoWordWrap =          0x0002,  
         };

      typedef fastdelegate::FastDelegate<void(INT32 lin, INT32 col)> DELEGATE_ONCURSORMOTION;

      CTRL_EDIT_TEXT (
         );

      virtual ~CTRL_EDIT_TEXT (
         );

      bool CanUndo (
         ) const;

      void ClearValue (
         bool notify = true                  
         );

      void Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane, 
         int width = 0,                      
         int height = 0,                     
         FLAGS flags = FLAG_Default,
         MGUI::LAYOUT_SIZEALIGN sizealign = MGUI::LAYOUT_SIZEALIGN_FixedHeight
         );

      bool Find (
         const MISTRING& SearchString,
         bool bCaseSensitive = true,
         bool bNext = false
         );

      bool GetCaretPos (
         int& caretrow,
         int& caretcolumn
         ) const;

      int GetFirstVisibleLine (
         ) const;

      int GetLineCount (
         ) const;

      int GetLineFromChar (
         int nIndex = -1
         ) const;


      int GetLineIndex (
         int nLine = -1
         );

      int GetLineLength (
         int nLine = -1
         );

      void GetStyle (
         TEXTSTYLE& style,
         int offset = -1      
         ) const;

      const MISTRING& GetValue (
         );

      void HandleKey (
         MGUI::KEYCODE keycode,
         MGUI::KEYSTATE keystate
         );

      void HideCursor (
         );

      void LineScroll (
         int nLines,       
         int nChars = 0    
         );

      void SetCursorPos (
         int nCharIndex,
         bool bScroll = true  
         );

      void SetCursorPos (
         int line,
         int col,
         bool bScroll = true  
         );

      void SetDelegateOnHyperLink (
         DELEGATE_VOID_MISTRING delegate
         ) { m_DelegateOnHyperLink = delegate; }

      void SetDelegateOnCursorMotion (
         DELEGATE_ONCURSORMOTION delegate
         ) { m_DelegateOnCursorMotion = delegate; }


#ifndef GENERATING_DOXYGEN_OUTPUT
      // Note: this is for use by FORM_SMLEDITOR.  It uses some ugly 
      //  X-specific structure
      void SetDelegateOnSyntaxHighlight (
         fastdelegate::FastDelegate<void(XeTextSyntaxParseCallbackData*)> delegate
         );
#endif

      void SetStyle (
         const TEXTSTYLE& style
         );

      void SetStyle (
         const TEXTSTYLE& style,
         int start,           
         int end              
         );

      void SetTabStops (
         int cxEachStop    
         );

      void SetValue (
         const MIUNICODE* string,               
         bool notify = true                  
         );

      void ShowCursor (
         );

      void Undo (
         );

   private:

      #ifndef GENERATING_DOXYGEN_OUTPUT
      MISTRING m_value;
      DELEGATE_VOID_MISTRING m_DelegateOnHyperLink;
      fastdelegate::FastDelegate<void(XeTextSyntaxParseCallbackData*)> m_DelegateOnSyntaxHighlight;
      DELEGATE_ONCURSORMOTION m_DelegateOnCursorMotion;
      static void CB_HyperLink (Widget, CTRL_EDIT_TEXT*, void*);
      static void CB_SyntaxHighlight (Widget, CTRL_EDIT_TEXT*, void*);
      static void CB_CursorMotion (Widget, CTRL_EDIT_TEXT*, void*);
      virtual void v_UpdateValue (MISTRING& newvalue);
      void OnEditButton(ID, bool);

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

#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(MGUI::CTRL_EDIT_TEXT::FLAGS)
#endif

//===================================================================================================================
}  // End namespace MGUI

#endif   // INC_MGUI_EDIT_H

---