home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2240.zip / wxWindows-2.4.0 / include / wx / textctrl.h < prev    next >
C/C++ Source or Header  |  2002-09-05  |  15KB  |  406 lines
  1. ///////////////////////////////////////////////////////////////////////////////
  2. // Name:        textctrl.h
  3. // Purpose:     wxTextCtrlBase class - the interface of wxTextCtrl
  4. // Author:      Vadim Zeitlin
  5. // Modified by:
  6. // Created:     13.07.99
  7. // RCS-ID:      $Id: textctrl.h,v 1.36 2002/09/05 16:15:30 JS Exp $
  8. // Copyright:   (c) wxWindows team
  9. // Licence:     wxWindows licence
  10. ///////////////////////////////////////////////////////////////////////////////
  11.  
  12. #ifndef _WX_TEXTCTRL_H_BASE_
  13. #define _WX_TEXTCTRL_H_BASE_
  14.  
  15. // ----------------------------------------------------------------------------
  16. // headers
  17. // ----------------------------------------------------------------------------
  18.  
  19. #if defined(__GNUG__) && !defined(__APPLE__)
  20.     #pragma interface "textctrlbase.h"
  21. #endif
  22.  
  23. #include "wx/defs.h"
  24.  
  25. #if wxUSE_TEXTCTRL
  26.  
  27. #include "wx/control.h"         // the base class
  28.  
  29. // 16-bit Borland 4.0 doesn't seem to allow multiple inheritance with wxWindow
  30. // and streambuf: it complains about deriving a huge class from the huge class
  31. // streambuf. !! Also, can't use streambuf if making or using a DLL :-(
  32.  
  33. #if (defined(__BORLANDC__)) || defined(__MWERKS__) || \
  34.     defined(WXUSINGDLL) || defined(WXMAKINGDLL)
  35.     #define NO_TEXT_WINDOW_STREAM
  36. #endif
  37.  
  38. #ifndef NO_TEXT_WINDOW_STREAM
  39.     #if wxUSE_STD_IOSTREAM
  40.         #include "wx/ioswrap.h"    // for iostream classes if we need them
  41.     #else // !wxUSE_STD_IOSTREAM
  42.         // can't compile this feature in if we don't use streams at all
  43.         #define NO_TEXT_WINDOW_STREAM
  44.     #endif // wxUSE_STD_IOSTREAM/!wxUSE_STD_IOSTREAM
  45. #endif
  46.  
  47. class WXDLLEXPORT wxTextCtrl;
  48. class WXDLLEXPORT wxTextCtrlBase;
  49.  
  50. // ----------------------------------------------------------------------------
  51. // constants
  52. // ----------------------------------------------------------------------------
  53.  
  54. WXDLLEXPORT_DATA(extern const wxChar*) wxTextCtrlNameStr;
  55. WXDLLEXPORT_DATA(extern const wxChar*) wxEmptyString;
  56.  
  57. // ----------------------------------------------------------------------------
  58. // wxTextCtrl style flags
  59. // ----------------------------------------------------------------------------
  60.  
  61. // the flag bits 0x0001, and 0x0004 are free but should be used only for the
  62. // things which don't make sense for a text control used by wxTextEntryDialog
  63. // because they would otherwise conflict with wxOK, wxCANCEL, wxCENTRE
  64.  
  65. #define wxTE_NO_VSCROLL     0x0002
  66. #define wxTE_AUTO_SCROLL    0x0008
  67.  
  68. #define wxTE_READONLY       0x0010
  69. #define wxTE_MULTILINE      0x0020
  70. #define wxTE_PROCESS_TAB    0x0040
  71.  
  72. // alignment flags
  73. #define wxTE_LEFT           0x0000                    // 0x0000
  74. #define wxTE_CENTER         wxALIGN_CENTER_HORIZONTAL // 0x0100
  75. #define wxTE_RIGHT          wxALIGN_RIGHT             // 0x0200
  76. #define wxTE_CENTRE         wxTE_CENTER
  77.  
  78. // this style means to use RICHEDIT control and does something only under wxMSW
  79. // and Win32 and is silently ignored under all other platforms
  80. #define wxTE_RICH           0x0080
  81.  
  82. #define wxTE_PROCESS_ENTER  0x0400
  83. #define wxTE_PASSWORD       0x0800
  84.  
  85. // automatically detect the URLs and generate the events when mouse is
  86. // moved/clicked over an URL
  87. //
  88. // this is for Win32 richedit controls only so far
  89. #define wxTE_AUTO_URL       0x1000
  90.  
  91. // by default, the Windows text control doesn't show the selection when it
  92. // doesn't have focus - use this style to force it to always show it
  93. #define wxTE_NOHIDESEL      0x2000
  94.  
  95. // use wxHSCROLL to not wrap text at all, wxTE_LINEWRAP to wrap it at any
  96. // position and wxTE_WORDWRAP to wrap at words boundary
  97. #define wxTE_DONTWRAP       wxHSCROLL
  98. #define wxTE_LINEWRAP       0x4000
  99. #define wxTE_WORDWRAP       0x0000  // it's just == !wxHSCROLL
  100.  
  101. // force using RichEdit version 2.0 or 3.0 instead of 1.0 (default) for
  102. // wxTE_RICH controls - can be used together with or instead of wxTE_RICH
  103. #define wxTE_RICH2          0x8000
  104.  
  105. // ----------------------------------------------------------------------------
  106. // wxTextAttr: a structure containing the visual attributes of a text
  107. // ----------------------------------------------------------------------------
  108.  
  109. class WXDLLEXPORT wxTextAttr
  110. {
  111. public:
  112.     // ctors
  113.     wxTextAttr() { }
  114.     wxTextAttr(const wxColour& colText,
  115.                const wxColour& colBack = wxNullColour,
  116.                const wxFont& font = wxNullFont)
  117.         : m_colText(colText), m_colBack(colBack), m_font(font) { }
  118.  
  119.     // setters
  120.     void SetTextColour(const wxColour& colText) { m_colText = colText; }
  121.     void SetBackgroundColour(const wxColour& colBack) { m_colBack = colBack; }
  122.     void SetFont(const wxFont& font) { m_font = font; }
  123.  
  124.     // accessors
  125.     bool HasTextColour() const { return m_colText.Ok(); }
  126.     bool HasBackgroundColour() const { return m_colBack.Ok(); }
  127.     bool HasFont() const { return m_font.Ok(); }
  128.  
  129.     // setters
  130.     const wxColour& GetTextColour() const { return m_colText; }
  131.     const wxColour& GetBackgroundColour() const { return m_colBack; }
  132.     const wxFont& GetFont() const { return m_font; }
  133.  
  134.     // returns false if we have any attributes set, true otherwise
  135.     bool IsDefault() const
  136.     {
  137.         return !HasTextColour() && !HasBackgroundColour() && !HasFont();
  138.     }
  139.  
  140.     // return the attribute having the valid font and colours: it uses the
  141.     // attributes set in attr and falls back first to attrDefault and then to
  142.     // the text control font/colours for those attributes which are not set
  143.     static wxTextAttr Combine(const wxTextAttr& attr,
  144.                               const wxTextAttr& attrDef,
  145.                               const wxTextCtrlBase *text);
  146.  
  147. private:
  148.     wxColour m_colText,
  149.              m_colBack;
  150.     wxFont   m_font;
  151. };
  152.  
  153. // ----------------------------------------------------------------------------
  154. // wxTextCtrl: a single or multiple line text zone where user can enter and
  155. // edit text
  156. // ----------------------------------------------------------------------------
  157.  
  158. class WXDLLEXPORT wxTextCtrlBase : public wxControl
  159. #ifndef NO_TEXT_WINDOW_STREAM
  160.                                  , public wxSTD streambuf
  161. #endif
  162.  
  163. {
  164. public:
  165.     // creation
  166.     // --------
  167.  
  168.     wxTextCtrlBase();
  169.     ~wxTextCtrlBase();
  170.  
  171.     // accessors
  172.     // ---------
  173.  
  174.     virtual wxString GetValue() const = 0;
  175.     virtual void SetValue(const wxString& value) = 0;
  176.  
  177.     virtual wxString GetRange(long from, long to) const;
  178.  
  179.     virtual int GetLineLength(long lineNo) const = 0;
  180.     virtual wxString GetLineText(long lineNo) const = 0;
  181.     virtual int GetNumberOfLines() const = 0;
  182.  
  183.     virtual bool IsModified() const = 0;
  184.     virtual bool IsEditable() const = 0;
  185.  
  186.     // more readable flag testing methods
  187.     bool IsSingleLine() const { return !(GetWindowStyle() & wxTE_MULTILINE); }
  188.     bool IsMultiLine() const { return !IsSingleLine(); }
  189.  
  190.     // If the return values from and to are the same, there is no selection.
  191.     virtual void GetSelection(long* from, long* to) const = 0;
  192.  
  193.     virtual wxString GetStringSelection() const;
  194.  
  195.     // operations
  196.     // ----------
  197.  
  198.     // editing
  199.     virtual void Clear() = 0;
  200.     virtual void Replace(long from, long to, const wxString& value) = 0;
  201.     virtual void Remove(long from, long to) = 0;
  202.  
  203.     // load/save the controls contents from/to the file
  204.     virtual bool LoadFile(const wxString& file);
  205.     virtual bool SaveFile(const wxString& file = wxEmptyString);
  206.  
  207.     // clears the dirty flag
  208.     virtual void DiscardEdits() = 0;
  209.  
  210.     // set the max number of characters which may be entered in a single line
  211.     // text control
  212.     virtual void SetMaxLength(unsigned long WXUNUSED(len)) { }
  213.  
  214.     // writing text inserts it at the current position, appending always
  215.     // inserts it at the end
  216.     virtual void WriteText(const wxString& text) = 0;
  217.     virtual void AppendText(const wxString& text) = 0;
  218.  
  219.     // insert the character which would have resulted from this key event,
  220.     // return TRUE if anything has been inserted
  221.     virtual bool EmulateKeyPress(const wxKeyEvent& event);
  222.  
  223.     // text control under some platforms supports the text styles: these
  224.     // methods allow to apply the given text style to the given selection or to
  225.     // set/get the style which will be used for all appended text
  226.     virtual bool SetStyle(long start, long end, const wxTextAttr& style);
  227.     virtual bool SetDefaultStyle(const wxTextAttr& style);
  228.     virtual const wxTextAttr& GetDefaultStyle() const;
  229.  
  230.     // translate between the position (which is just an index in the text ctrl
  231.     // considering all its contents as a single strings) and (x, y) coordinates
  232.     // which represent column and line.
  233.     virtual long XYToPosition(long x, long y) const = 0;
  234.     virtual bool PositionToXY(long pos, long *x, long *y) const = 0;
  235.  
  236.     virtual void ShowPosition(long pos) = 0;
  237.  
  238.     // Clipboard operations
  239.     virtual void Copy() = 0;
  240.     virtual void Cut() = 0;
  241.     virtual void Paste() = 0;
  242.  
  243.     virtual bool CanCopy() const;
  244.     virtual bool CanCut() const;
  245.     virtual bool CanPaste() const;
  246.  
  247.     // Undo/redo
  248.     virtual void Undo() = 0;
  249.     virtual void Redo() = 0;
  250.  
  251.     virtual bool CanUndo() const = 0;
  252.     virtual bool CanRedo() const = 0;
  253.  
  254.     // Insertion point
  255.     virtual void SetInsertionPoint(long pos) = 0;
  256.     virtual void SetInsertionPointEnd() = 0;
  257.     virtual long GetInsertionPoint() const = 0;
  258.     virtual long GetLastPosition() const = 0;
  259.  
  260.     virtual void SetSelection(long from, long to) = 0;
  261.     virtual void SelectAll();
  262.     virtual void SetEditable(bool editable) = 0;
  263.  
  264.     // override streambuf method
  265. #ifndef NO_TEXT_WINDOW_STREAM
  266.     int overflow(int i);
  267. #endif // NO_TEXT_WINDOW_STREAM
  268.  
  269.     // stream-like insertion operators: these are always available, whether we
  270.     // were, or not, compiled with streambuf support
  271.     wxTextCtrl& operator<<(const wxString& s);
  272.     wxTextCtrl& operator<<(int i);
  273.     wxTextCtrl& operator<<(long i);
  274.     wxTextCtrl& operator<<(float f);
  275.     wxTextCtrl& operator<<(double d);
  276.     wxTextCtrl& operator<<(const wxChar c);
  277.  
  278.     // obsolete functions
  279. #if WXWIN_COMPATIBILITY
  280.     bool Modified() const { return IsModified(); }
  281. #endif
  282.  
  283. protected:
  284.     // the name of the last file loaded with LoadFile() which will be used by
  285.     // SaveFile() by default
  286.     wxString m_filename;
  287.  
  288.     // the text style which will be used for any new text added to the control
  289.     wxTextAttr m_defaultStyle;
  290. };
  291.  
  292. // ----------------------------------------------------------------------------
  293. // include the platform-dependent class definition
  294. // ----------------------------------------------------------------------------
  295.  
  296. #if defined(__WXX11__)
  297.     #include "wx/x11/textctrl.h"
  298. #elif defined(__WXUNIVERSAL__)
  299.     #include "wx/univ/textctrl.h"
  300. #elif defined(__WXMSW__)
  301.     #include "wx/msw/textctrl.h"
  302. #elif defined(__WXMOTIF__)
  303.     #include "wx/motif/textctrl.h"
  304. #elif defined(__WXGTK__)
  305.     #include "wx/gtk/textctrl.h"
  306. #elif defined(__WXMAC__)
  307.     #include "wx/mac/textctrl.h"
  308. #elif defined(__WXPM__)
  309.     #include "wx/os2/textctrl.h"
  310. #elif defined(__WXSTUBS__)
  311.     #include "wx/stubs/textctrl.h"
  312. #endif
  313.  
  314. // ----------------------------------------------------------------------------
  315. // wxTextCtrl events
  316. // ----------------------------------------------------------------------------
  317.  
  318. #if !WXWIN_COMPATIBILITY_EVENT_TYPES
  319.  
  320. BEGIN_DECLARE_EVENT_TYPES()
  321.     DECLARE_EVENT_TYPE(wxEVT_COMMAND_TEXT_UPDATED, 7)
  322.     DECLARE_EVENT_TYPE(wxEVT_COMMAND_TEXT_ENTER, 8)
  323.     DECLARE_EVENT_TYPE(wxEVT_COMMAND_TEXT_URL, 13)
  324.     DECLARE_EVENT_TYPE(wxEVT_COMMAND_TEXT_MAXLEN, 14)
  325. END_DECLARE_EVENT_TYPES()
  326.  
  327. #endif // !WXWIN_COMPATIBILITY_EVENT_TYPES
  328.  
  329. class WXDLLEXPORT wxTextUrlEvent : public wxCommandEvent
  330. {
  331. public:
  332.     wxTextUrlEvent(int id, const wxMouseEvent& evtMouse,
  333.                    long start, long end)
  334.         : wxCommandEvent(wxEVT_COMMAND_TEXT_URL, id)
  335.         , m_evtMouse(evtMouse), m_start(start), m_end(end)
  336.         { }
  337.  
  338.     // get the mouse event which happend over the URL
  339.     const wxMouseEvent& GetMouseEvent() const { return m_evtMouse; }
  340.  
  341.     // get the start of the URL
  342.     long GetURLStart() const { return m_start; }
  343.  
  344.     // get the end of the URL
  345.     long GetURLEnd() const { return m_end; }
  346.  
  347. protected:
  348.     // the corresponding mouse event
  349.     wxMouseEvent m_evtMouse;
  350.  
  351.     // the start and end indices of the URL in the text control
  352.     long m_start,
  353.          m_end;
  354.  
  355. private:
  356.     DECLARE_DYNAMIC_CLASS(wxTextUrlEvent)
  357.  
  358. public:
  359.     // for wxWin RTTI only, don't use
  360.     wxTextUrlEvent() : m_evtMouse(), m_start(0), m_end(0) { }
  361. };
  362.  
  363. typedef void (wxEvtHandler::*wxTextUrlEventFunction)(wxTextUrlEvent&);
  364.  
  365. #define EVT_TEXT(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_TEXT_UPDATED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) & fn, (wxObject *) NULL ),
  366. #define EVT_TEXT_ENTER(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_TEXT_ENTER, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) & fn, (wxObject *) NULL ),
  367. #define EVT_TEXT_URL(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_TEXT_URL, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxTextUrlEventFunction) & fn, (wxObject *) NULL ),
  368. #define EVT_TEXT_MAXLEN(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_TEXT_MAXLEN, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) & fn, (wxObject *) NULL ),
  369.  
  370. #ifndef NO_TEXT_WINDOW_STREAM
  371.  
  372. // ----------------------------------------------------------------------------
  373. // wxStreamToTextRedirector: this class redirects all data sent to the given
  374. // C++ stream to the wxTextCtrl given to its ctor during its lifetime.
  375. // ----------------------------------------------------------------------------
  376.  
  377. class WXDLLEXPORT wxStreamToTextRedirector
  378. {
  379. public:
  380.     wxStreamToTextRedirector(wxTextCtrl *text, wxSTD ostream *ostr = NULL)
  381.         : m_ostr(ostr ? *ostr : wxSTD cout)
  382.     {
  383.         m_sbufOld = m_ostr.rdbuf();
  384.         m_ostr.rdbuf(text);
  385.     }
  386.  
  387.     ~wxStreamToTextRedirector()
  388.     {
  389.         m_ostr.rdbuf(m_sbufOld);
  390.     }
  391.  
  392. private:
  393.     // the stream we're redirecting
  394.     wxSTD ostream&   m_ostr;
  395.  
  396.     // the old streambuf (before we changed it)
  397.     wxSTD streambuf *m_sbufOld;
  398. };
  399.  
  400. #endif // !NO_TEXT_WINDOW_STREAM
  401.  
  402. #endif // wxUSE_TEXTCTRL
  403.  
  404. #endif
  405.     // _WX_TEXTCTRL_H_BASE_
  406.