]>
Commit | Line | Data |
---|---|---|
1 | /////////////////////////////////////////////////////////////////////////////// | |
2 | // Name: wx/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$ | |
8 | // Copyright: (c) Vadim Zeitlin | |
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 | #include "wx/defs.h" | |
20 | ||
21 | #if wxUSE_TEXTCTRL | |
22 | ||
23 | #include "wx/control.h" // the base class | |
24 | #include "wx/dynarray.h" // wxArrayInt | |
25 | #include "wx/gdicmn.h" // wxPoint | |
26 | ||
27 | // Open Watcom 1.3 does allow only ios::rdbuf() while | |
28 | // we want something with streambuf parameter | |
29 | // Also, can't use streambuf if making or using a DLL :-( | |
30 | ||
31 | #if defined(__WATCOMC__) || \ | |
32 | defined(__MWERKS__) || \ | |
33 | (defined(__WINDOWS__) && (defined(WXUSINGDLL) || defined(WXMAKINGDLL))) | |
34 | #define wxHAS_TEXT_WINDOW_STREAM 0 | |
35 | #elif wxUSE_STD_IOSTREAM | |
36 | #include "wx/ioswrap.h" | |
37 | #define wxHAS_TEXT_WINDOW_STREAM 1 | |
38 | #else | |
39 | #define wxHAS_TEXT_WINDOW_STREAM 0 | |
40 | #endif | |
41 | ||
42 | #if WXWIN_COMPATIBILITY_2_4 && !wxHAS_TEXT_WINDOW_STREAM | |
43 | // define old flag if one could use it somewhere | |
44 | #define NO_TEXT_WINDOW_STREAM | |
45 | #endif | |
46 | ||
47 | class WXDLLEXPORT wxTextCtrl; | |
48 | class WXDLLEXPORT wxTextCtrlBase; | |
49 | ||
50 | // ---------------------------------------------------------------------------- | |
51 | // wxTextCtrl types | |
52 | // ---------------------------------------------------------------------------- | |
53 | ||
54 | // wxTextPos is the position in the text | |
55 | typedef long wxTextPos; | |
56 | ||
57 | // wxTextCoord is the line or row number (which should have been unsigned but | |
58 | // is long for backwards compatibility) | |
59 | typedef long wxTextCoord; | |
60 | ||
61 | // ---------------------------------------------------------------------------- | |
62 | // constants | |
63 | // ---------------------------------------------------------------------------- | |
64 | ||
65 | extern WXDLLEXPORT_DATA(const wxChar) wxTextCtrlNameStr[]; | |
66 | ||
67 | // this is intentionally not enum to avoid warning fixes with | |
68 | // typecasting from enum type to wxTextCoord | |
69 | const wxTextCoord wxOutOfRangeTextCoord = -1; | |
70 | const wxTextCoord wxInvalidTextCoord = -2; | |
71 | ||
72 | // ---------------------------------------------------------------------------- | |
73 | // wxTextCtrl style flags | |
74 | // ---------------------------------------------------------------------------- | |
75 | ||
76 | // the flag bit 0x0001 s free but should be used only for the things which | |
77 | // don't make sense for a text control used by wxTextEntryDialog because they | |
78 | // would otherwise conflict with wxOK, wxCANCEL, wxCENTRE | |
79 | ||
80 | #define wxTE_NO_VSCROLL 0x0002 | |
81 | #define wxTE_AUTO_SCROLL 0x0008 | |
82 | ||
83 | #define wxTE_READONLY 0x0010 | |
84 | #define wxTE_MULTILINE 0x0020 | |
85 | #define wxTE_PROCESS_TAB 0x0040 | |
86 | ||
87 | // alignment flags | |
88 | #define wxTE_LEFT 0x0000 // 0x0000 | |
89 | #define wxTE_CENTER wxALIGN_CENTER_HORIZONTAL // 0x0100 | |
90 | #define wxTE_RIGHT wxALIGN_RIGHT // 0x0200 | |
91 | #define wxTE_CENTRE wxTE_CENTER | |
92 | ||
93 | // this style means to use RICHEDIT control and does something only under wxMSW | |
94 | // and Win32 and is silently ignored under all other platforms | |
95 | #define wxTE_RICH 0x0080 | |
96 | ||
97 | #define wxTE_PROCESS_ENTER 0x0400 | |
98 | #define wxTE_PASSWORD 0x0800 | |
99 | ||
100 | // automatically detect the URLs and generate the events when mouse is | |
101 | // moved/clicked over an URL | |
102 | // | |
103 | // this is for Win32 richedit and wxGTK2 multiline controls only so far | |
104 | #define wxTE_AUTO_URL 0x1000 | |
105 | ||
106 | // by default, the Windows text control doesn't show the selection when it | |
107 | // doesn't have focus - use this style to force it to always show it | |
108 | #define wxTE_NOHIDESEL 0x2000 | |
109 | ||
110 | // use wxHSCROLL to not wrap text at all, wxTE_CHARWRAP to wrap it at any | |
111 | // position and wxTE_WORDWRAP to wrap at words boundary | |
112 | // | |
113 | // if no wrapping style is given at all, the control wraps at word boundary | |
114 | #define wxTE_DONTWRAP wxHSCROLL | |
115 | #define wxTE_CHARWRAP 0x4000 // wrap at any position | |
116 | #define wxTE_WORDWRAP 0x0001 // wrap only at words boundaries | |
117 | #define wxTE_BESTWRAP 0x0000 // this is the default | |
118 | ||
119 | #if WXWIN_COMPATIBILITY_2_6 | |
120 | // obsolete synonym | |
121 | #define wxTE_LINEWRAP wxTE_CHARWRAP | |
122 | #endif // WXWIN_COMPATIBILITY_2_6 | |
123 | ||
124 | // force using RichEdit version 2.0 or 3.0 instead of 1.0 (default) for | |
125 | // wxTE_RICH controls - can be used together with or instead of wxTE_RICH | |
126 | #define wxTE_RICH2 0x8000 | |
127 | ||
128 | // reuse wxTE_RICH2's value for CAPEDIT control on Windows CE | |
129 | #if defined(__SMARTPHONE__) || defined(__POCKETPC__) | |
130 | #define wxTE_CAPITALIZE wxTE_RICH2 | |
131 | #else | |
132 | #define wxTE_CAPITALIZE 0 | |
133 | #endif | |
134 | ||
135 | // ---------------------------------------------------------------------------- | |
136 | // wxTextCtrl::HitTest return values | |
137 | // ---------------------------------------------------------------------------- | |
138 | ||
139 | // the point asked is ... | |
140 | enum wxTextCtrlHitTestResult | |
141 | { | |
142 | wxTE_HT_UNKNOWN = -2, // this means HitTest() is simply not implemented | |
143 | wxTE_HT_BEFORE, // either to the left or upper | |
144 | wxTE_HT_ON_TEXT, // directly on | |
145 | wxTE_HT_BELOW, // below [the last line] | |
146 | wxTE_HT_BEYOND // after [the end of line] | |
147 | }; | |
148 | // ... the character returned | |
149 | ||
150 | // ---------------------------------------------------------------------------- | |
151 | // Types for wxTextAttr | |
152 | // ---------------------------------------------------------------------------- | |
153 | ||
154 | // Alignment | |
155 | ||
156 | enum wxTextAttrAlignment | |
157 | { | |
158 | wxTEXT_ALIGNMENT_DEFAULT, | |
159 | wxTEXT_ALIGNMENT_LEFT, | |
160 | wxTEXT_ALIGNMENT_CENTRE, | |
161 | wxTEXT_ALIGNMENT_CENTER = wxTEXT_ALIGNMENT_CENTRE, | |
162 | wxTEXT_ALIGNMENT_RIGHT, | |
163 | wxTEXT_ALIGNMENT_JUSTIFIED | |
164 | }; | |
165 | ||
166 | // Flags to indicate which attributes are being applied | |
167 | ||
168 | #define wxTEXT_ATTR_TEXT_COLOUR 0x0001 | |
169 | #define wxTEXT_ATTR_BACKGROUND_COLOUR 0x0002 | |
170 | #define wxTEXT_ATTR_FONT_FACE 0x0004 | |
171 | #define wxTEXT_ATTR_FONT_SIZE 0x0008 | |
172 | #define wxTEXT_ATTR_FONT_WEIGHT 0x0010 | |
173 | #define wxTEXT_ATTR_FONT_ITALIC 0x0020 | |
174 | #define wxTEXT_ATTR_FONT_UNDERLINE 0x0040 | |
175 | #define wxTEXT_ATTR_FONT \ | |
176 | ( wxTEXT_ATTR_FONT_FACE | wxTEXT_ATTR_FONT_SIZE | wxTEXT_ATTR_FONT_WEIGHT | \ | |
177 | wxTEXT_ATTR_FONT_ITALIC | wxTEXT_ATTR_FONT_UNDERLINE ) | |
178 | #define wxTEXT_ATTR_ALIGNMENT 0x0080 | |
179 | #define wxTEXT_ATTR_LEFT_INDENT 0x0100 | |
180 | #define wxTEXT_ATTR_RIGHT_INDENT 0x0200 | |
181 | #define wxTEXT_ATTR_TABS 0x0400 | |
182 | ||
183 | // ---------------------------------------------------------------------------- | |
184 | // wxTextAttr: a structure containing the visual attributes of a text | |
185 | // ---------------------------------------------------------------------------- | |
186 | ||
187 | class WXDLLEXPORT wxTextAttr | |
188 | { | |
189 | public: | |
190 | // ctors | |
191 | wxTextAttr() { Init(); } | |
192 | wxTextAttr(const wxColour& colText, | |
193 | const wxColour& colBack = wxNullColour, | |
194 | const wxFont& font = wxNullFont, | |
195 | wxTextAttrAlignment alignment = wxTEXT_ALIGNMENT_DEFAULT); | |
196 | ||
197 | // operations | |
198 | void Init(); | |
199 | ||
200 | // merges the attributes of the base and the overlay objects and returns | |
201 | // the result; the parameter attributes take precedence | |
202 | // | |
203 | // WARNING: the order of arguments is the opposite of Combine() | |
204 | static wxTextAttr Merge(const wxTextAttr& base, const wxTextAttr& overlay) | |
205 | { | |
206 | return Combine(overlay, base, NULL); | |
207 | } | |
208 | ||
209 | // merges the attributes of this object and overlay | |
210 | void Merge(const wxTextAttr& overlay) | |
211 | { | |
212 | *this = Merge(*this, overlay); | |
213 | } | |
214 | ||
215 | ||
216 | // operators | |
217 | void operator= (const wxTextAttr& attr); | |
218 | ||
219 | // setters | |
220 | void SetTextColour(const wxColour& colText) { m_colText = colText; m_flags |= wxTEXT_ATTR_TEXT_COLOUR; } | |
221 | void SetBackgroundColour(const wxColour& colBack) { m_colBack = colBack; m_flags |= wxTEXT_ATTR_BACKGROUND_COLOUR; } | |
222 | void SetFont(const wxFont& font, long flags = wxTEXT_ATTR_FONT) { m_font = font; m_flags |= flags; } | |
223 | void SetAlignment(wxTextAttrAlignment alignment) { m_textAlignment = alignment; m_flags |= wxTEXT_ATTR_ALIGNMENT; } | |
224 | void SetTabs(const wxArrayInt& tabs) { m_tabs = tabs; m_flags |= wxTEXT_ATTR_TABS; } | |
225 | void SetLeftIndent(int indent, int subIndent = 0) { m_leftIndent = indent; m_leftSubIndent = subIndent; m_flags |= wxTEXT_ATTR_LEFT_INDENT; } | |
226 | void SetRightIndent(int indent) { m_rightIndent = indent; m_flags |= wxTEXT_ATTR_RIGHT_INDENT; } | |
227 | void SetFlags(long flags) { m_flags = flags; } | |
228 | ||
229 | // accessors | |
230 | bool HasTextColour() const { return m_colText.Ok() && HasFlag(wxTEXT_ATTR_TEXT_COLOUR) ; } | |
231 | bool HasBackgroundColour() const { return m_colBack.Ok() && HasFlag(wxTEXT_ATTR_BACKGROUND_COLOUR) ; } | |
232 | bool HasFont() const { return m_font.Ok() && HasFlag(wxTEXT_ATTR_FONT) ; } | |
233 | bool HasAlignment() const { return (m_textAlignment != wxTEXT_ALIGNMENT_DEFAULT) || ((m_flags & wxTEXT_ATTR_ALIGNMENT) != 0) ; } | |
234 | bool HasTabs() const { return (m_flags & wxTEXT_ATTR_TABS) != 0 ; } | |
235 | bool HasLeftIndent() const { return (m_flags & wxTEXT_ATTR_LEFT_INDENT) != 0 ; } | |
236 | bool HasRightIndent() const { return (m_flags & wxTEXT_ATTR_RIGHT_INDENT) != 0 ; } | |
237 | bool HasFlag(long flag) const { return (m_flags & flag) != 0; } | |
238 | ||
239 | const wxColour& GetTextColour() const { return m_colText; } | |
240 | const wxColour& GetBackgroundColour() const { return m_colBack; } | |
241 | const wxFont& GetFont() const { return m_font; } | |
242 | wxTextAttrAlignment GetAlignment() const { return m_textAlignment; } | |
243 | const wxArrayInt& GetTabs() const { return m_tabs; } | |
244 | long GetLeftIndent() const { return m_leftIndent; } | |
245 | long GetLeftSubIndent() const { return m_leftSubIndent; } | |
246 | long GetRightIndent() const { return m_rightIndent; } | |
247 | long GetFlags() const { return m_flags; } | |
248 | ||
249 | // returns false if we have any attributes set, true otherwise | |
250 | bool IsDefault() const | |
251 | { | |
252 | return !HasTextColour() && !HasBackgroundColour() && !HasFont() && !HasAlignment() && | |
253 | !HasTabs() && !HasLeftIndent() && !HasRightIndent() ; | |
254 | } | |
255 | ||
256 | // return the attribute having the valid font and colours: it uses the | |
257 | // attributes set in attr and falls back first to attrDefault and then to | |
258 | // the text control font/colours for those attributes which are not set | |
259 | static wxTextAttr Combine(const wxTextAttr& attr, | |
260 | const wxTextAttr& attrDef, | |
261 | const wxTextCtrlBase *text); | |
262 | ||
263 | private: | |
264 | long m_flags; | |
265 | wxColour m_colText, | |
266 | m_colBack; | |
267 | wxFont m_font; | |
268 | wxTextAttrAlignment m_textAlignment; | |
269 | wxArrayInt m_tabs; // array of int: tab stops in 1/10 mm | |
270 | int m_leftIndent; // left indent in 1/10 mm | |
271 | int m_leftSubIndent; // left indent for all but the first | |
272 | // line in a paragraph relative to the | |
273 | // first line, in 1/10 mm | |
274 | int m_rightIndent; // right indent in 1/10 mm | |
275 | }; | |
276 | ||
277 | // ---------------------------------------------------------------------------- | |
278 | // wxTextCtrl: a single or multiple line text zone where user can enter and | |
279 | // edit text | |
280 | // ---------------------------------------------------------------------------- | |
281 | ||
282 | class WXDLLEXPORT wxTextCtrlBase : public wxControl | |
283 | #if wxHAS_TEXT_WINDOW_STREAM | |
284 | , public wxSTD streambuf | |
285 | #endif | |
286 | ||
287 | { | |
288 | public: | |
289 | // creation | |
290 | // -------- | |
291 | ||
292 | wxTextCtrlBase(){} | |
293 | ~wxTextCtrlBase(){} | |
294 | ||
295 | // accessors | |
296 | // --------- | |
297 | ||
298 | virtual wxString GetValue() const = 0; | |
299 | virtual void SetValue(const wxString& value) = 0; | |
300 | ||
301 | virtual wxString GetRange(long from, long to) const; | |
302 | ||
303 | virtual int GetLineLength(long lineNo) const = 0; | |
304 | virtual wxString GetLineText(long lineNo) const = 0; | |
305 | virtual int GetNumberOfLines() const = 0; | |
306 | ||
307 | virtual bool IsModified() const = 0; | |
308 | virtual bool IsEditable() const = 0; | |
309 | ||
310 | // more readable flag testing methods | |
311 | bool IsSingleLine() const { return !HasFlag(wxTE_MULTILINE); } | |
312 | bool IsMultiLine() const { return !IsSingleLine(); } | |
313 | ||
314 | // If the return values from and to are the same, there is no selection. | |
315 | virtual void GetSelection(long* from, long* to) const = 0; | |
316 | ||
317 | virtual wxString GetStringSelection() const; | |
318 | ||
319 | // operations | |
320 | // ---------- | |
321 | ||
322 | // editing | |
323 | virtual void Clear() = 0; | |
324 | virtual void Replace(long from, long to, const wxString& value) = 0; | |
325 | virtual void Remove(long from, long to) = 0; | |
326 | ||
327 | // load/save the controls contents from/to the file | |
328 | virtual bool LoadFile(const wxString& file); | |
329 | virtual bool SaveFile(const wxString& file = wxEmptyString); | |
330 | ||
331 | // sets/clears the dirty flag | |
332 | virtual void MarkDirty() = 0; | |
333 | virtual void DiscardEdits() = 0; | |
334 | void SetModified(bool modified) | |
335 | { | |
336 | if ( modified ) | |
337 | MarkDirty(); | |
338 | else | |
339 | DiscardEdits(); | |
340 | } | |
341 | ||
342 | // set the max number of characters which may be entered in a single line | |
343 | // text control | |
344 | virtual void SetMaxLength(unsigned long WXUNUSED(len)) { } | |
345 | ||
346 | // writing text inserts it at the current position, appending always | |
347 | // inserts it at the end | |
348 | virtual void WriteText(const wxString& text) = 0; | |
349 | virtual void AppendText(const wxString& text) = 0; | |
350 | ||
351 | // insert the character which would have resulted from this key event, | |
352 | // return true if anything has been inserted | |
353 | virtual bool EmulateKeyPress(const wxKeyEvent& event); | |
354 | ||
355 | // text control under some platforms supports the text styles: these | |
356 | // methods allow to apply the given text style to the given selection or to | |
357 | // set/get the style which will be used for all appended text | |
358 | virtual bool SetStyle(long start, long end, const wxTextAttr& style); | |
359 | virtual bool GetStyle(long position, wxTextAttr& style); | |
360 | virtual bool SetDefaultStyle(const wxTextAttr& style); | |
361 | virtual const wxTextAttr& GetDefaultStyle() const; | |
362 | ||
363 | // translate between the position (which is just an index in the text ctrl | |
364 | // considering all its contents as a single strings) and (x, y) coordinates | |
365 | // which represent column and line. | |
366 | virtual long XYToPosition(long x, long y) const = 0; | |
367 | virtual bool PositionToXY(long pos, long *x, long *y) const = 0; | |
368 | ||
369 | virtual void ShowPosition(long pos) = 0; | |
370 | ||
371 | // find the character at position given in pixels | |
372 | // | |
373 | // NB: pt is in device coords (not adjusted for the client area origin nor | |
374 | // scrolling) | |
375 | virtual wxTextCtrlHitTestResult HitTest(const wxPoint& pt, long *pos) const; | |
376 | virtual wxTextCtrlHitTestResult HitTest(const wxPoint& pt, | |
377 | wxTextCoord *col, | |
378 | wxTextCoord *row) const; | |
379 | ||
380 | // Clipboard operations | |
381 | virtual void Copy() = 0; | |
382 | virtual void Cut() = 0; | |
383 | virtual void Paste() = 0; | |
384 | ||
385 | virtual bool CanCopy() const; | |
386 | virtual bool CanCut() const; | |
387 | virtual bool CanPaste() const; | |
388 | ||
389 | // Undo/redo | |
390 | virtual void Undo() = 0; | |
391 | virtual void Redo() = 0; | |
392 | ||
393 | virtual bool CanUndo() const = 0; | |
394 | virtual bool CanRedo() const = 0; | |
395 | ||
396 | // Insertion point | |
397 | virtual void SetInsertionPoint(long pos) = 0; | |
398 | virtual void SetInsertionPointEnd() = 0; | |
399 | virtual long GetInsertionPoint() const = 0; | |
400 | virtual wxTextPos GetLastPosition() const = 0; | |
401 | ||
402 | virtual void SetSelection(long from, long to) = 0; | |
403 | virtual void SelectAll(); | |
404 | virtual void SetEditable(bool editable) = 0; | |
405 | ||
406 | // stream-like insertion operators: these are always available, whether we | |
407 | // were, or not, compiled with streambuf support | |
408 | wxTextCtrl& operator<<(const wxString& s); | |
409 | wxTextCtrl& operator<<(int i); | |
410 | wxTextCtrl& operator<<(long i); | |
411 | wxTextCtrl& operator<<(float f); | |
412 | wxTextCtrl& operator<<(double d); | |
413 | wxTextCtrl& operator<<(const wxChar c); | |
414 | ||
415 | // do the window-specific processing after processing the update event | |
416 | virtual void DoUpdateWindowUI(wxUpdateUIEvent& event); | |
417 | ||
418 | virtual bool ShouldInheritColours() const { return false; } | |
419 | ||
420 | protected: | |
421 | // override streambuf method | |
422 | #if wxHAS_TEXT_WINDOW_STREAM | |
423 | int overflow(int i); | |
424 | #endif // wxHAS_TEXT_WINDOW_STREAM | |
425 | ||
426 | // the name of the last file loaded with LoadFile() which will be used by | |
427 | // SaveFile() by default | |
428 | wxString m_filename; | |
429 | ||
430 | // the text style which will be used for any new text added to the control | |
431 | wxTextAttr m_defaultStyle; | |
432 | ||
433 | DECLARE_NO_COPY_CLASS(wxTextCtrlBase) | |
434 | DECLARE_ABSTRACT_CLASS(wxTextCtrlBase) | |
435 | }; | |
436 | ||
437 | // ---------------------------------------------------------------------------- | |
438 | // include the platform-dependent class definition | |
439 | // ---------------------------------------------------------------------------- | |
440 | ||
441 | #if defined(__WXX11__) | |
442 | #include "wx/x11/textctrl.h" | |
443 | #elif defined(__WXUNIVERSAL__) | |
444 | #include "wx/univ/textctrl.h" | |
445 | #elif defined(__SMARTPHONE__) && defined(__WXWINCE__) | |
446 | #include "wx/msw/wince/textctrlce.h" | |
447 | #elif defined(__WXMSW__) | |
448 | #include "wx/msw/textctrl.h" | |
449 | #elif defined(__WXMOTIF__) | |
450 | #include "wx/motif/textctrl.h" | |
451 | #elif defined(__WXGTK20__) | |
452 | #include "wx/gtk/textctrl.h" | |
453 | #elif defined(__WXGTK__) | |
454 | #include "wx/gtk1/textctrl.h" | |
455 | #elif defined(__WXMAC__) | |
456 | #include "wx/mac/textctrl.h" | |
457 | #elif defined(__WXCOCOA__) | |
458 | #include "wx/cocoa/textctrl.h" | |
459 | #elif defined(__WXPM__) | |
460 | #include "wx/os2/textctrl.h" | |
461 | #endif | |
462 | ||
463 | // ---------------------------------------------------------------------------- | |
464 | // wxTextCtrl events | |
465 | // ---------------------------------------------------------------------------- | |
466 | ||
467 | #if !WXWIN_COMPATIBILITY_EVENT_TYPES | |
468 | ||
469 | BEGIN_DECLARE_EVENT_TYPES() | |
470 | DECLARE_EVENT_TYPE(wxEVT_COMMAND_TEXT_UPDATED, 7) | |
471 | DECLARE_EVENT_TYPE(wxEVT_COMMAND_TEXT_ENTER, 8) | |
472 | DECLARE_EVENT_TYPE(wxEVT_COMMAND_TEXT_URL, 13) | |
473 | DECLARE_EVENT_TYPE(wxEVT_COMMAND_TEXT_MAXLEN, 14) | |
474 | END_DECLARE_EVENT_TYPES() | |
475 | ||
476 | #endif // !WXWIN_COMPATIBILITY_EVENT_TYPES | |
477 | ||
478 | class WXDLLEXPORT wxTextUrlEvent : public wxCommandEvent | |
479 | { | |
480 | public: | |
481 | wxTextUrlEvent(int winid, const wxMouseEvent& evtMouse, | |
482 | long start, long end) | |
483 | : wxCommandEvent(wxEVT_COMMAND_TEXT_URL, winid) | |
484 | , m_evtMouse(evtMouse), m_start(start), m_end(end) | |
485 | { } | |
486 | ||
487 | // get the mouse event which happend over the URL | |
488 | const wxMouseEvent& GetMouseEvent() const { return m_evtMouse; } | |
489 | ||
490 | // get the start of the URL | |
491 | long GetURLStart() const { return m_start; } | |
492 | ||
493 | // get the end of the URL | |
494 | long GetURLEnd() const { return m_end; } | |
495 | ||
496 | protected: | |
497 | // the corresponding mouse event | |
498 | wxMouseEvent m_evtMouse; | |
499 | ||
500 | // the start and end indices of the URL in the text control | |
501 | long m_start, | |
502 | m_end; | |
503 | ||
504 | private: | |
505 | DECLARE_DYNAMIC_CLASS_NO_COPY(wxTextUrlEvent) | |
506 | ||
507 | public: | |
508 | // for wxWin RTTI only, don't use | |
509 | wxTextUrlEvent() : m_evtMouse(), m_start(0), m_end(0) { } | |
510 | }; | |
511 | ||
512 | typedef void (wxEvtHandler::*wxTextUrlEventFunction)(wxTextUrlEvent&); | |
513 | ||
514 | #define wxTextEventHandler(func) wxCommandEventHandler(func) | |
515 | #define wxTextUrlEventHandler(func) \ | |
516 | (wxObjectEventFunction)(wxEventFunction)wxStaticCastEvent(wxTextUrlEventFunction, &func) | |
517 | ||
518 | #define wx__DECLARE_TEXTEVT(evt, id, fn) \ | |
519 | wx__DECLARE_EVT1(wxEVT_COMMAND_TEXT_ ## evt, id, wxTextEventHandler(fn)) | |
520 | ||
521 | #define wx__DECLARE_TEXTURLEVT(evt, id, fn) \ | |
522 | wx__DECLARE_EVT1(wxEVT_COMMAND_TEXT_ ## evt, id, wxTextUrlEventHandler(fn)) | |
523 | ||
524 | #define EVT_TEXT(id, fn) wx__DECLARE_TEXTEVT(UPDATED, id, fn) | |
525 | #define EVT_TEXT_ENTER(id, fn) wx__DECLARE_TEXTEVT(ENTER, id, fn) | |
526 | #define EVT_TEXT_URL(id, fn) wx__DECLARE_TEXTURLEVT(URL, id, fn) | |
527 | #define EVT_TEXT_MAXLEN(id, fn) wx__DECLARE_TEXTEVT(MAXLEN, id, fn) | |
528 | ||
529 | #if wxHAS_TEXT_WINDOW_STREAM | |
530 | ||
531 | // ---------------------------------------------------------------------------- | |
532 | // wxStreamToTextRedirector: this class redirects all data sent to the given | |
533 | // C++ stream to the wxTextCtrl given to its ctor during its lifetime. | |
534 | // ---------------------------------------------------------------------------- | |
535 | ||
536 | class WXDLLEXPORT wxStreamToTextRedirector | |
537 | { | |
538 | private: | |
539 | void Init(wxTextCtrl *text) | |
540 | { | |
541 | m_sbufOld = m_ostr.rdbuf(); | |
542 | m_ostr.rdbuf(text); | |
543 | } | |
544 | ||
545 | public: | |
546 | wxStreamToTextRedirector(wxTextCtrl *text) | |
547 | : m_ostr(wxSTD cout) | |
548 | { | |
549 | Init(text); | |
550 | } | |
551 | ||
552 | wxStreamToTextRedirector(wxTextCtrl *text, wxSTD ostream *ostr) | |
553 | : m_ostr(*ostr) | |
554 | { | |
555 | Init(text); | |
556 | } | |
557 | ||
558 | ~wxStreamToTextRedirector() | |
559 | { | |
560 | m_ostr.rdbuf(m_sbufOld); | |
561 | } | |
562 | ||
563 | private: | |
564 | // the stream we're redirecting | |
565 | wxSTD ostream& m_ostr; | |
566 | ||
567 | // the old streambuf (before we changed it) | |
568 | wxSTD streambuf *m_sbufOld; | |
569 | }; | |
570 | ||
571 | #endif // wxHAS_TEXT_WINDOW_STREAM | |
572 | ||
573 | #endif // wxUSE_TEXTCTRL | |
574 | ||
575 | #endif | |
576 | // _WX_TEXTCTRL_H_BASE_ |