]> git.saurik.com Git - wxWidgets.git/blob - include/wx/richtext/richtextctrl.h
enum wxWebViewBackend has been removed.
[wxWidgets.git] / include / wx / richtext / richtextctrl.h
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: wx/richtext/richtextctrl.h
3 // Purpose: A rich edit control
4 // Author: Julian Smart
5 // Modified by:
6 // Created: 2005-09-30
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifndef _WX_RICHTEXTCTRL_H_
13 #define _WX_RICHTEXTCTRL_H_
14
15 #include "wx/richtext/richtextbuffer.h"
16
17 #if wxUSE_RICHTEXT
18
19 #include "wx/scrolwin.h"
20 #include "wx/caret.h"
21
22 #include "wx/textctrl.h"
23
24 #if wxUSE_DRAG_AND_DROP
25 #include "wx/dnd.h"
26 #endif
27
28 #if !defined(__WXGTK__) && !defined(__WXMAC__)
29 #define wxRICHTEXT_BUFFERED_PAINTING 1
30 #else
31 #define wxRICHTEXT_BUFFERED_PAINTING 0
32 #endif
33
34 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextStyleDefinition;
35
36 /*
37 * Styles and flags
38 */
39
40 /**
41 Styles
42 */
43
44 #define wxRE_READONLY 0x0010
45 #define wxRE_MULTILINE 0x0020
46 #define wxRE_CENTRE_CARET 0x8000
47 #define wxRE_CENTER_CARET wxRE_CENTRE_CARET
48
49 /**
50 Flags
51 */
52
53 #define wxRICHTEXT_SHIFT_DOWN 0x01
54 #define wxRICHTEXT_CTRL_DOWN 0x02
55 #define wxRICHTEXT_ALT_DOWN 0x04
56
57 /**
58 Extra flags
59 */
60
61 // Don't draw guide lines around boxes and tables
62 #define wxRICHTEXT_EX_NO_GUIDELINES 0x00000100
63
64
65 /*
66 Defaults
67 */
68
69 #define wxRICHTEXT_DEFAULT_OVERALL_SIZE wxSize(-1, -1)
70 #define wxRICHTEXT_DEFAULT_IMAGE_SIZE wxSize(80, 80)
71 #define wxRICHTEXT_DEFAULT_SPACING 3
72 #define wxRICHTEXT_DEFAULT_MARGIN 3
73 #define wxRICHTEXT_DEFAULT_UNFOCUSSED_BACKGROUND wxColour(175, 175, 175)
74 #define wxRICHTEXT_DEFAULT_FOCUSSED_BACKGROUND wxColour(140, 140, 140)
75 #define wxRICHTEXT_DEFAULT_UNSELECTED_BACKGROUND wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE)
76 #define wxRICHTEXT_DEFAULT_TYPE_COLOUR wxColour(0, 0, 200)
77 #define wxRICHTEXT_DEFAULT_FOCUS_RECT_COLOUR wxColour(100, 80, 80)
78 #define wxRICHTEXT_DEFAULT_CARET_WIDTH 2
79 // Minimum buffer size before delayed layout kicks in
80 #define wxRICHTEXT_DEFAULT_DELAYED_LAYOUT_THRESHOLD 20000
81 // Milliseconds before layout occurs after resize
82 #define wxRICHTEXT_DEFAULT_LAYOUT_INTERVAL 50
83
84 /* Identifiers
85 */
86 #define wxID_RICHTEXT_PROPERTIES1 (wxID_HIGHEST + 1)
87 #define wxID_RICHTEXT_PROPERTIES2 (wxID_HIGHEST + 2)
88 #define wxID_RICHTEXT_PROPERTIES3 (wxID_HIGHEST + 3)
89
90 /*
91 Normal selection occurs initially and as user drags within one container.
92 Common ancestor selection occurs when the user starts dragging across containers
93 that have a common ancestor, for example the cells in a table.
94 */
95
96 enum wxRichTextCtrlSelectionState
97 {
98 wxRichTextCtrlSelectionState_Normal,
99 wxRichTextCtrlSelectionState_CommonAncestor
100 };
101
102 /**
103 @class wxRichTextContextMenuPropertiesInfo
104
105 wxRichTextContextMenuPropertiesInfo keeps track of objects that appear in the context menu,
106 whose properties are available to be edited.
107 */
108
109 class WXDLLIMPEXP_RICHTEXT wxRichTextContextMenuPropertiesInfo
110 {
111 public:
112 /**
113 Constructor.
114 */
115 wxRichTextContextMenuPropertiesInfo() { Init(); }
116
117 // Operations
118
119 /**
120 Initialisation.
121 */
122 void Init() {}
123
124 /**
125 Adds an item.
126 */
127 bool AddItem(const wxString& label, wxRichTextObject* obj);
128
129 /**
130 Returns the number of menu items that were added.
131 */
132 int AddMenuItems(wxMenu* menu, int startCmd = wxID_RICHTEXT_PROPERTIES1) const;
133
134 /**
135 Adds appropriate menu items for the current container and clicked on object
136 (and container's parent, if appropriate).
137 */
138 int AddItems(wxRichTextCtrl* ctrl, wxRichTextObject* container, wxRichTextObject* obj);
139
140 /**
141 Clears the items.
142 */
143 void Clear() { m_objects.Clear(); m_labels.Clear(); }
144
145 // Accessors
146
147 /**
148 Returns the nth label.
149 */
150 wxString GetLabel(int n) const { return m_labels[n]; }
151
152 /**
153 Returns the nth object.
154 */
155 wxRichTextObject* GetObject(int n) const { return m_objects[n]; }
156
157 /**
158 Returns the array of objects.
159 */
160 wxRichTextObjectPtrArray& GetObjects() { return m_objects; }
161
162 /**
163 Returns the array of objects.
164 */
165 const wxRichTextObjectPtrArray& GetObjects() const { return m_objects; }
166
167 /**
168 Returns the array of labels.
169 */
170 wxArrayString& GetLabels() { return m_labels; }
171
172 /**
173 Returns the array of labels.
174 */
175 const wxArrayString& GetLabels() const { return m_labels; }
176
177 /**
178 Returns the number of items.
179 */
180 int GetCount() const { return m_objects.GetCount(); }
181
182 wxRichTextObjectPtrArray m_objects;
183 wxArrayString m_labels;
184 };
185
186 /**
187 @class wxRichTextCtrl
188
189 wxRichTextCtrl provides a generic, ground-up implementation of a text control
190 capable of showing multiple styles and images.
191
192 wxRichTextCtrl sends notification events: see wxRichTextEvent.
193
194 It also sends the standard wxTextCtrl events @c wxEVT_COMMAND_TEXT_ENTER and
195 @c wxEVT_COMMAND_TEXT_UPDATED, and wxTextUrlEvent when URL content is clicked.
196
197 For more information, see the @ref overview_richtextctrl.
198
199 @beginStyleTable
200 @style{wxRE_CENTRE_CARET}
201 The control will try to keep the caret line centred vertically while editing.
202 wxRE_CENTER_CARET is a synonym for this style.
203 @style{wxRE_MULTILINE}
204 The control will be multiline (mandatory).
205 @style{wxRE_READONLY}
206 The control will not be editable.
207 @endStyleTable
208
209 @library{wxrichtext}
210 @category{richtext}
211 @appearance{richtextctrl.png}
212
213 */
214
215 class WXDLLIMPEXP_RICHTEXT wxRichTextCtrl : public wxControl,
216 public wxTextCtrlIface,
217 public wxScrollHelper
218 {
219 DECLARE_DYNAMIC_CLASS( wxRichTextCtrl )
220 DECLARE_EVENT_TABLE()
221
222 public:
223 // Constructors
224
225 /**
226 Default constructor.
227 */
228 wxRichTextCtrl( );
229
230 /**
231 Constructor, creating and showing a rich text control.
232
233 @param parent
234 Parent window. Must not be @NULL.
235 @param id
236 Window identifier. The value @c wxID_ANY indicates a default value.
237 @param value
238 Default string.
239 @param pos
240 Window position.
241 @param size
242 Window size.
243 @param style
244 Window style.
245 @param validator
246 Window validator.
247 @param name
248 Window name.
249
250 @see Create(), wxValidator
251 */
252 wxRichTextCtrl( wxWindow* parent, wxWindowID id = -1, const wxString& value = wxEmptyString, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
253 long style = wxRE_MULTILINE, const wxValidator& validator = wxDefaultValidator, const wxString& name = wxTextCtrlNameStr);
254
255 /**
256 Destructor.
257 */
258 virtual ~wxRichTextCtrl( );
259
260 // Operations
261
262 /**
263 Creates the underlying window.
264 */
265 bool Create( wxWindow* parent, wxWindowID id = -1, const wxString& value = wxEmptyString, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
266 long style = wxRE_MULTILINE, const wxValidator& validator = wxDefaultValidator, const wxString& name = wxTextCtrlNameStr );
267
268 /**
269 Initialises the members of the control.
270 */
271 void Init();
272
273 // Accessors
274
275 /**
276 Gets the text for the given range.
277 The end point of range is specified as the last character position of
278 the span of text, plus one.
279 */
280 virtual wxString GetRange(long from, long to) const;
281
282 /**
283 Returns the length of the specified line in characters.
284 */
285 virtual int GetLineLength(long lineNo) const ;
286
287 /**
288 Returns the text for the given line.
289 */
290 virtual wxString GetLineText(long lineNo) const ;
291
292 /**
293 Returns the number of lines in the buffer.
294 */
295 virtual int GetNumberOfLines() const ;
296
297 /**
298 Returns @true if the buffer has been modified.
299 */
300 virtual bool IsModified() const ;
301
302 /**
303 Returns @true if the control is editable.
304 */
305 virtual bool IsEditable() const ;
306
307 /**
308 Returns @true if the control is single-line.
309 Currently wxRichTextCtrl does not support single-line editing.
310 */
311 bool IsSingleLine() const { return !HasFlag(wxRE_MULTILINE); }
312
313 /**
314 Returns @true if the control is multiline.
315 */
316 bool IsMultiLine() const { return !IsSingleLine(); }
317
318 //@{
319 /**
320 Returns the range of the current selection.
321 The end point of range is specified as the last character position of the span
322 of text, plus one.
323 If the return values @a from and @a to are the same, there is no selection.
324 */
325 virtual void GetSelection(long* from, long* to) const;
326 const wxRichTextSelection& GetSelection() const { return m_selection; }
327 wxRichTextSelection& GetSelection() { return m_selection; }
328 //@}
329
330 /**
331 Returns the text within the current selection range, if any.
332 */
333 virtual wxString GetStringSelection() const;
334
335 /**
336 Gets the current filename associated with the control.
337 */
338 wxString GetFilename() const { return m_filename; }
339
340 /**
341 Sets the current filename.
342 */
343 void SetFilename(const wxString& filename) { m_filename = filename; }
344
345 /**
346 Sets the size of the buffer beyond which layout is delayed during resizing.
347 This optimizes sizing for large buffers. The default is 20000.
348 */
349 void SetDelayedLayoutThreshold(long threshold) { m_delayedLayoutThreshold = threshold; }
350
351 /**
352 Gets the size of the buffer beyond which layout is delayed during resizing.
353 This optimizes sizing for large buffers. The default is 20000.
354 */
355 long GetDelayedLayoutThreshold() const { return m_delayedLayoutThreshold; }
356
357 /**
358 Gets the flag indicating that full layout is required.
359 */
360 bool GetFullLayoutRequired() const { return m_fullLayoutRequired; }
361
362 /**
363 Sets the flag indicating that full layout is required.
364 */
365 void SetFullLayoutRequired(bool b) { m_fullLayoutRequired = b; }
366
367 /**
368 Returns the last time full layout was performed.
369 */
370 wxLongLong GetFullLayoutTime() const { return m_fullLayoutTime; }
371
372 /**
373 Sets the last time full layout was performed.
374 */
375 void SetFullLayoutTime(wxLongLong t) { m_fullLayoutTime = t; }
376
377 /**
378 Returns the position that should be shown when full (delayed) layout is performed.
379 */
380 long GetFullLayoutSavedPosition() const { return m_fullLayoutSavedPosition; }
381
382 /**
383 Sets the position that should be shown when full (delayed) layout is performed.
384 */
385 void SetFullLayoutSavedPosition(long p) { m_fullLayoutSavedPosition = p; }
386
387 /**
388 Forces any pending layout due to delayed, partial layout when the control
389 was resized.
390 */
391 void ForceDelayedLayout();
392
393 /**
394 Sets the text (normal) cursor.
395 */
396 void SetTextCursor(const wxCursor& cursor ) { m_textCursor = cursor; }
397
398 /**
399 Returns the text (normal) cursor.
400 */
401 wxCursor GetTextCursor() const { return m_textCursor; }
402
403 /**
404 Sets the cursor to be used over URLs.
405 */
406 void SetURLCursor(const wxCursor& cursor ) { m_urlCursor = cursor; }
407
408 /**
409 Returns the cursor to be used over URLs.
410 */
411 wxCursor GetURLCursor() const { return m_urlCursor; }
412
413 /**
414 Returns @true if we are showing the caret position at the start of a line
415 instead of at the end of the previous one.
416 */
417 bool GetCaretAtLineStart() const { return m_caretAtLineStart; }
418
419 /**
420 Sets a flag to remember that we are showing the caret position at the start of a line
421 instead of at the end of the previous one.
422 */
423 void SetCaretAtLineStart(bool atStart) { m_caretAtLineStart = atStart; }
424
425 /**
426 Returns @true if we are dragging a selection.
427 */
428 bool GetDragging() const { return m_dragging; }
429
430 /**
431 Sets a flag to remember if we are dragging a selection.
432 */
433 void SetDragging(bool dragging) { m_dragging = dragging; }
434
435 #if wxUSE_DRAG_AND_DROP
436 /**
437 Are we trying to start Drag'n'Drop?
438 */
439 bool GetPreDrag() const { return m_preDrag; }
440
441 /**
442 Set if we're trying to start Drag'n'Drop
443 */
444 void SetPreDrag(bool pd) { m_preDrag = pd; }
445
446 /**
447 Get the possible Drag'n'Drop start point
448 */
449 const wxPoint GetDragStartPoint() const { return m_dragStartPoint; }
450
451 /**
452 Set the possible Drag'n'Drop start point
453 */
454 void SetDragStartPoint(wxPoint sp) { m_dragStartPoint = sp; }
455
456 #if wxUSE_DATETIME
457 /**
458 Get the possible Drag'n'Drop start time
459 */
460 const wxDateTime GetDragStartTime() const { return m_dragStartTime; }
461
462 /**
463 Set the possible Drag'n'Drop start time
464 */
465 void SetDragStartTime(wxDateTime st) { m_dragStartTime = st; }
466 #endif // wxUSE_DATETIME
467
468 #endif // wxUSE_DRAG_AND_DROP
469
470 #if wxRICHTEXT_BUFFERED_PAINTING
471 //@{
472 /**
473 Returns the buffer bitmap if using buffered painting.
474 */
475 const wxBitmap& GetBufferBitmap() const { return m_bufferBitmap; }
476 wxBitmap& GetBufferBitmap() { return m_bufferBitmap; }
477 //@}
478 #endif
479
480 /**
481 Returns the current context menu.
482 */
483 wxMenu* GetContextMenu() const { return m_contextMenu; }
484
485 /**
486 Sets the current context menu.
487 */
488 void SetContextMenu(wxMenu* menu);
489
490 /**
491 Returns an anchor so we know how to extend the selection.
492 It's a caret position since it's between two characters.
493 */
494 long GetSelectionAnchor() const { return m_selectionAnchor; }
495
496 /**
497 Sets an anchor so we know how to extend the selection.
498 It's a caret position since it's between two characters.
499 */
500 void SetSelectionAnchor(long anchor) { m_selectionAnchor = anchor; }
501
502 /**
503 Returns the anchor object if selecting multiple containers.
504 */
505 wxRichTextObject* GetSelectionAnchorObject() const { return m_selectionAnchorObject; }
506
507 /**
508 Sets the anchor object if selecting multiple containers.
509 */
510 void SetSelectionAnchorObject(wxRichTextObject* anchor) { m_selectionAnchorObject = anchor; }
511
512 //@{
513 /**
514 Returns an object that stores information about context menu property item(s),
515 in order to communicate between the context menu event handler and the code
516 that responds to it. The wxRichTextContextMenuPropertiesInfo stores one
517 item for each object that could respond to a property-editing event. If
518 objects are nested, several might be editable.
519 */
520 wxRichTextContextMenuPropertiesInfo& GetContextMenuPropertiesInfo() { return m_contextMenuPropertiesInfo; }
521 const wxRichTextContextMenuPropertiesInfo& GetContextMenuPropertiesInfo() const { return m_contextMenuPropertiesInfo; }
522 //@}
523
524 /**
525 Returns the wxRichTextObject object that currently has the editing focus.
526 If there are no composite objects, this will be the top-level buffer.
527 */
528 wxRichTextParagraphLayoutBox* GetFocusObject() const { return m_focusObject; }
529
530 /**
531 Sets m_focusObject without making any alterations.
532 */
533 void StoreFocusObject(wxRichTextParagraphLayoutBox* obj) { m_focusObject = obj; }
534
535 /**
536 Sets the wxRichTextObject object that currently has the editing focus.
537 */
538 bool SetFocusObject(wxRichTextParagraphLayoutBox* obj, bool setCaretPosition = true);
539
540 // Operations
541
542 /**
543 Invalidates the whole buffer to trigger painting later.
544 */
545 void Invalidate() { GetBuffer().Invalidate(wxRICHTEXT_ALL); }
546
547 /**
548 Clears the buffer content, leaving a single empty paragraph. Cannot be undone.
549 */
550 virtual void Clear();
551
552 /**
553 Replaces the content in the specified range with the string specified by
554 @a value.
555 */
556 virtual void Replace(long from, long to, const wxString& value);
557
558 /**
559 Removes the content in the specified range.
560 */
561 virtual void Remove(long from, long to);
562
563 #ifdef DOXYGEN
564 /**
565 Loads content into the control's buffer using the given type.
566
567 If the specified type is wxRICHTEXT_TYPE_ANY, the type is deduced from
568 the filename extension.
569
570 This function looks for a suitable wxRichTextFileHandler object.
571 */
572 bool LoadFile(const wxString& file,
573 int type = wxRICHTEXT_TYPE_ANY);
574 #endif
575
576 /**
577 Helper function for LoadFile(). Loads content into the control's buffer using the given type.
578
579 If the specified type is wxRICHTEXT_TYPE_ANY, the type is deduced from
580 the filename extension.
581
582 This function looks for a suitable wxRichTextFileHandler object.
583 */
584 virtual bool DoLoadFile(const wxString& file, int fileType);
585
586 #ifdef DOXYGEN
587 /**
588 Saves the buffer content using the given type.
589
590 If the specified type is wxRICHTEXT_TYPE_ANY, the type is deduced from
591 the filename extension.
592
593 This function looks for a suitable wxRichTextFileHandler object.
594 */
595 bool SaveFile(const wxString& file = wxEmptyString,
596 int type = wxRICHTEXT_TYPE_ANY);
597 #endif
598
599 /**
600 Helper function for SaveFile(). Saves the buffer content using the given type.
601
602 If the specified type is wxRICHTEXT_TYPE_ANY, the type is deduced from
603 the filename extension.
604
605 This function looks for a suitable wxRichTextFileHandler object.
606 */
607 virtual bool DoSaveFile(const wxString& file = wxEmptyString,
608 int fileType = wxRICHTEXT_TYPE_ANY);
609
610 /**
611 Sets flags that change the behaviour of loading or saving.
612
613 See the documentation for each handler class to see what flags are
614 relevant for each handler.
615 */
616 void SetHandlerFlags(int flags) { GetBuffer().SetHandlerFlags(flags); }
617
618 /**
619 Returns flags that change the behaviour of loading or saving.
620 See the documentation for each handler class to see what flags are
621 relevant for each handler.
622 */
623 int GetHandlerFlags() const { return GetBuffer().GetHandlerFlags(); }
624
625 /**
626 Marks the buffer as modified.
627 */
628 virtual void MarkDirty();
629
630 /**
631 Sets the buffer's modified status to @false, and clears the buffer's command
632 history.
633 */
634 virtual void DiscardEdits();
635
636 /**
637 Sets the maximum number of characters that may be entered in a single line
638 text control. For compatibility only; currently does nothing.
639 */
640 virtual void SetMaxLength(unsigned long WXUNUSED(len)) { }
641
642 /**
643 Writes text at the current position.
644 */
645 virtual void WriteText(const wxString& text);
646
647 /**
648 Sets the insertion point to the end of the buffer and writes the text.
649 */
650 virtual void AppendText(const wxString& text);
651
652 //@{
653 /**
654 Gets the attributes at the given position.
655 This function gets the combined style - that is, the style you see on the
656 screen as a result of combining base style, paragraph style and character
657 style attributes.
658
659 To get the character or paragraph style alone, use GetUncombinedStyle().
660
661 @beginWxPerlOnly
662 In wxPerl this method is implemented as GetStyle(@a position)
663 returning a 2-element list (ok, attr).
664 @endWxPerlOnly
665 */
666 virtual bool GetStyle(long position, wxTextAttr& style);
667 virtual bool GetStyle(long position, wxRichTextAttr& style);
668 virtual bool GetStyle(long position, wxRichTextAttr& style, wxRichTextParagraphLayoutBox* container);
669 //@}
670
671 //@{
672 /**
673 Sets the attributes for the given range.
674 The end point of range is specified as the last character position of the span
675 of text, plus one.
676
677 So, for example, to set the style for a character at position 5, use the range
678 (5,6).
679 */
680 virtual bool SetStyle(long start, long end, const wxTextAttr& style);
681 virtual bool SetStyle(long start, long end, const wxRichTextAttr& style);
682 virtual bool SetStyle(const wxRichTextRange& range, const wxTextAttr& style);
683 virtual bool SetStyle(const wxRichTextRange& range, const wxRichTextAttr& style);
684 //@}
685
686 /**
687 Sets the attributes for a single object
688 */
689 virtual void SetStyle(wxRichTextObject *obj, const wxRichTextAttr& textAttr, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO);
690
691 //@{
692 /**
693 Gets the attributes common to the specified range.
694 Attributes that differ in value within the range will not be included
695 in @a style flags.
696
697 @beginWxPerlOnly
698 In wxPerl this method is implemented as GetStyleForRange(@a position)
699 returning a 2-element list (ok, attr).
700 @endWxPerlOnly
701 */
702 virtual bool GetStyleForRange(const wxRichTextRange& range, wxTextAttr& style);
703 virtual bool GetStyleForRange(const wxRichTextRange& range, wxRichTextAttr& style);
704 virtual bool GetStyleForRange(const wxRichTextRange& range, wxRichTextAttr& style, wxRichTextParagraphLayoutBox* container);
705 //@}
706
707 /**
708 Sets the attributes for the given range, passing flags to determine how the
709 attributes are set.
710
711 The end point of range is specified as the last character position of the span
712 of text, plus one. So, for example, to set the style for a character at
713 position 5, use the range (5,6).
714
715 @a flags may contain a bit list of the following values:
716 - wxRICHTEXT_SETSTYLE_NONE: no style flag.
717 - wxRICHTEXT_SETSTYLE_WITH_UNDO: specifies that this operation should be
718 undoable.
719 - wxRICHTEXT_SETSTYLE_OPTIMIZE: specifies that the style should not be applied
720 if the combined style at this point is already the style in question.
721 - wxRICHTEXT_SETSTYLE_PARAGRAPHS_ONLY: specifies that the style should only be
722 applied to paragraphs, and not the content.
723 This allows content styling to be preserved independently from that
724 of e.g. a named paragraph style.
725 - wxRICHTEXT_SETSTYLE_CHARACTERS_ONLY: specifies that the style should only be
726 applied to characters, and not the paragraph.
727 This allows content styling to be preserved independently from that
728 of e.g. a named paragraph style.
729 - wxRICHTEXT_SETSTYLE_RESET: resets (clears) the existing style before applying
730 the new style.
731 - wxRICHTEXT_SETSTYLE_REMOVE: removes the specified style. Only the style flags
732 are used in this operation.
733 */
734 virtual bool SetStyleEx(const wxRichTextRange& range, const wxRichTextAttr& style, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO);
735
736 //@{
737 /**
738 Gets the attributes at the given position.
739 This function gets the @e uncombined style - that is, the attributes associated
740 with the paragraph or character content, and not necessarily the combined
741 attributes you see on the screen.
742 To get the combined attributes, use GetStyle().
743
744 If you specify (any) paragraph attribute in @e style's flags, this function
745 will fetch the paragraph attributes.
746 Otherwise, it will return the character attributes.
747
748 @beginWxPerlOnly
749 In wxPerl this method is implemented as GetUncombinedStyle(@a position)
750 returning a 2-element list (ok, attr).
751 @endWxPerlOnly
752 */
753 virtual bool GetUncombinedStyle(long position, wxRichTextAttr& style);
754 virtual bool GetUncombinedStyle(long position, wxRichTextAttr& style, wxRichTextParagraphLayoutBox* container);
755 //@}
756
757 //@{
758 /**
759 Sets the current default style, which can be used to change how subsequently
760 inserted text is displayed.
761 */
762 virtual bool SetDefaultStyle(const wxTextAttr& style);
763 virtual bool SetDefaultStyle(const wxRichTextAttr& style);
764 //@}
765
766 /**
767 Returns the current default style, which can be used to change how subsequently
768 inserted text is displayed.
769 */
770 virtual const wxRichTextAttr& GetDefaultStyleEx() const;
771
772 //virtual const wxTextAttr& GetDefaultStyle() const;
773
774 //@{
775 /**
776 Sets the list attributes for the given range, passing flags to determine how
777 the attributes are set.
778
779 Either the style definition or the name of the style definition (in the current
780 sheet) can be passed.
781 @a flags is a bit list of the following:
782 - wxRICHTEXT_SETSTYLE_WITH_UNDO: specifies that this command will be undoable.
783 - wxRICHTEXT_SETSTYLE_RENUMBER: specifies that numbering should start from
784 @a startFrom, otherwise existing attributes are used.
785 - wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL: specifies that @a listLevel should be used
786 as the level for all paragraphs, otherwise the current indentation will be used.
787
788 @see NumberList(), PromoteList(), ClearListStyle().
789 */
790 virtual bool SetListStyle(const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
791 virtual bool SetListStyle(const wxRichTextRange& range, const wxString& defName, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
792 //@}
793
794 /**
795 Clears the list style from the given range, clearing list-related attributes
796 and applying any named paragraph style associated with each paragraph.
797
798 @a flags is a bit list of the following:
799 - wxRICHTEXT_SETSTYLE_WITH_UNDO: specifies that this command will be undoable.
800
801 @see SetListStyle(), PromoteList(), NumberList().
802 */
803 virtual bool ClearListStyle(const wxRichTextRange& range, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO);
804
805 //@{
806 /**
807 Numbers the paragraphs in the given range.
808 Pass flags to determine how the attributes are set.
809
810 Either the style definition or the name of the style definition (in the current
811 sheet) can be passed.
812
813 @a flags is a bit list of the following:
814 - wxRICHTEXT_SETSTYLE_WITH_UNDO: specifies that this command will be undoable.
815 - wxRICHTEXT_SETSTYLE_RENUMBER: specifies that numbering should start from
816 @a startFrom, otherwise existing attributes are used.
817 - wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL: specifies that @a listLevel should be used
818 as the level for all paragraphs, otherwise the current indentation will be used.
819
820 @see SetListStyle(), PromoteList(), ClearListStyle().
821 */
822 virtual bool NumberList(const wxRichTextRange& range, wxRichTextListStyleDefinition* def = NULL, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
823 virtual bool NumberList(const wxRichTextRange& range, const wxString& defName, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
824 //@}
825
826 //@{
827 /**
828 Promotes or demotes the paragraphs in the given range.
829 A positive @a promoteBy produces a smaller indent, and a negative number
830 produces a larger indent. Pass flags to determine how the attributes are set.
831 Either the style definition or the name of the style definition (in the current
832 sheet) can be passed.
833
834 @a flags is a bit list of the following:
835 - wxRICHTEXT_SETSTYLE_WITH_UNDO: specifies that this command will be undoable.
836 - wxRICHTEXT_SETSTYLE_RENUMBER: specifies that numbering should start from
837 @a startFrom, otherwise existing attributes are used.
838 - wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL: specifies that @a listLevel should be used
839 as the level for all paragraphs, otherwise the current indentation will be used.
840
841 @see SetListStyle(), @see SetListStyle(), ClearListStyle().
842 */
843 virtual bool PromoteList(int promoteBy, const wxRichTextRange& range, wxRichTextListStyleDefinition* def = NULL, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int specifiedLevel = -1);
844 virtual bool PromoteList(int promoteBy, const wxRichTextRange& range, const wxString& defName, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int specifiedLevel = -1);
845 //@}
846
847 /**
848 Sets the properties for the given range, passing flags to determine how the
849 attributes are set. You can merge properties or replace them.
850
851 The end point of range is specified as the last character position of the span
852 of text, plus one. So, for example, to set the properties for a character at
853 position 5, use the range (5,6).
854
855 @a flags may contain a bit list of the following values:
856 - wxRICHTEXT_SETSPROPERTIES_NONE: no flag.
857 - wxRICHTEXT_SETPROPERTIES_WITH_UNDO: specifies that this operation should be
858 undoable.
859 - wxRICHTEXT_SETPROPERTIES_PARAGRAPHS_ONLY: specifies that the properties should only be
860 applied to paragraphs, and not the content.
861 - wxRICHTEXT_SETPROPERTIES_CHARACTERS_ONLY: specifies that the properties should only be
862 applied to characters, and not the paragraph.
863 - wxRICHTEXT_SETPROPERTIES_RESET: resets (clears) the existing properties before applying
864 the new properties.
865 - wxRICHTEXT_SETPROPERTIES_REMOVE: removes the specified properties.
866 */
867 virtual bool SetProperties(const wxRichTextRange& range, const wxRichTextProperties& properties, int flags = wxRICHTEXT_SETPROPERTIES_WITH_UNDO);
868
869 /**
870 Deletes the content within the given range.
871 */
872 virtual bool Delete(const wxRichTextRange& range);
873
874 /**
875 Translates from column and line number to position.
876 */
877 virtual long XYToPosition(long x, long y) const;
878
879 /**
880 Converts a text position to zero-based column and line numbers.
881 */
882 virtual bool PositionToXY(long pos, long *x, long *y) const;
883
884 /**
885 Scrolls the buffer so that the given position is in view.
886 */
887 virtual void ShowPosition(long pos);
888
889 //@{
890 /**
891 Finds the character at the given position in pixels.
892 @a pt is in device coords (not adjusted for the client area origin nor for
893 scrolling).
894 */
895 virtual wxTextCtrlHitTestResult HitTest(const wxPoint& pt, long *pos) const;
896 virtual wxTextCtrlHitTestResult HitTest(const wxPoint& pt,
897 wxTextCoord *col,
898 wxTextCoord *row) const;
899
900 /**
901 Finds the container at the given point, which is in screen coordinates.
902 */
903 wxRichTextParagraphLayoutBox* FindContainerAtPoint(const wxPoint pt, long& position, int& hit, wxRichTextObject* hitObj, int flags = 0);
904 //@}
905
906 #if wxUSE_DRAG_AND_DROP
907 /**
908 Does the 'drop' of Drag'n'Drop.
909 */
910 void OnDrop(wxCoord WXUNUSED(x), wxCoord WXUNUSED(y), wxDragResult def, wxDataObject* DataObj);
911 #endif
912
913 // Clipboard operations
914
915 /**
916 Copies the selected content (if any) to the clipboard.
917 */
918 virtual void Copy();
919
920 /**
921 Copies the selected content (if any) to the clipboard and deletes the selection.
922 This is undoable.
923 */
924 virtual void Cut();
925
926 /**
927 Pastes content from the clipboard to the buffer.
928 */
929 virtual void Paste();
930
931 /**
932 Deletes the content in the selection, if any. This is undoable.
933 */
934 virtual void DeleteSelection();
935
936 /**
937 Returns @true if selected content can be copied to the clipboard.
938 */
939 virtual bool CanCopy() const;
940
941 /**
942 Returns @true if selected content can be copied to the clipboard and deleted.
943 */
944 virtual bool CanCut() const;
945
946 /**
947 Returns @true if the clipboard content can be pasted to the buffer.
948 */
949 virtual bool CanPaste() const;
950
951 /**
952 Returns @true if selected content can be deleted.
953 */
954 virtual bool CanDeleteSelection() const;
955
956 /**
957 Undoes the command at the top of the command history, if there is one.
958 */
959 virtual void Undo();
960
961 /**
962 Redoes the current command.
963 */
964 virtual void Redo();
965
966 /**
967 Returns @true if there is a command in the command history that can be undone.
968 */
969 virtual bool CanUndo() const;
970
971 /**
972 Returns @true if there is a command in the command history that can be redone.
973 */
974 virtual bool CanRedo() const;
975
976 /**
977 Sets the insertion point and causes the current editing style to be taken from
978 the new position (unlike wxRichTextCtrl::SetCaretPosition).
979 */
980 virtual void SetInsertionPoint(long pos);
981
982 /**
983 Sets the insertion point to the end of the text control.
984 */
985 virtual void SetInsertionPointEnd();
986
987 /**
988 Returns the current insertion point.
989 */
990 virtual long GetInsertionPoint() const;
991
992 /**
993 Returns the last position in the buffer.
994 */
995 virtual wxTextPos GetLastPosition() const;
996
997 //@{
998 /**
999 Sets the selection to the given range.
1000 The end point of range is specified as the last character position of the span
1001 of text, plus one.
1002
1003 So, for example, to set the selection for a character at position 5, use the
1004 range (5,6).
1005 */
1006 virtual void SetSelection(long from, long to);
1007 void SetSelection(const wxRichTextSelection& sel) { m_selection = sel; }
1008 //@}
1009
1010 /**
1011 Makes the control editable, or not.
1012 */
1013 virtual void SetEditable(bool editable);
1014
1015 /**
1016 Returns @true if there is a selection and the object containing the selection
1017 was the same as the current focus object.
1018 */
1019 virtual bool HasSelection() const;
1020
1021 /**
1022 Returns @true if there was a selection, whether or not the current focus object
1023 is the same as the selection's container object.
1024 */
1025 virtual bool HasUnfocusedSelection() const;
1026
1027 //@{
1028 /**
1029 Write a bitmap or image at the current insertion point.
1030 Supply an optional type to use for internal and file storage of the raw data.
1031 */
1032 virtual bool WriteImage(const wxImage& image, wxBitmapType bitmapType = wxBITMAP_TYPE_PNG,
1033 const wxRichTextAttr& textAttr = wxRichTextAttr());
1034
1035 virtual bool WriteImage(const wxBitmap& bitmap, wxBitmapType bitmapType = wxBITMAP_TYPE_PNG,
1036 const wxRichTextAttr& textAttr = wxRichTextAttr());
1037 //@}
1038
1039 /**
1040 Loads an image from a file and writes it at the current insertion point.
1041 */
1042 virtual bool WriteImage(const wxString& filename, wxBitmapType bitmapType,
1043 const wxRichTextAttr& textAttr = wxRichTextAttr());
1044
1045 /**
1046 Writes an image block at the current insertion point.
1047 */
1048 virtual bool WriteImage(const wxRichTextImageBlock& imageBlock,
1049 const wxRichTextAttr& textAttr = wxRichTextAttr());
1050
1051 /**
1052 Write a text box at the current insertion point, returning the text box.
1053 You can then call SetFocusObject() to set the focus to the new object.
1054 */
1055 virtual wxRichTextBox* WriteTextBox(const wxRichTextAttr& textAttr = wxRichTextAttr());
1056
1057 /**
1058 Writes a field at the current insertion point.
1059
1060 @param fieldType
1061 The field type, matching an existing field type definition.
1062 @param properties
1063 Extra data for the field.
1064 @param textAttr
1065 Optional attributes.
1066
1067 @see wxRichTextField, wxRichTextFieldType, wxRichTextFieldTypeStandard
1068 */
1069 virtual wxRichTextField* WriteField(const wxString& fieldType, const wxRichTextProperties& properties,
1070 const wxRichTextAttr& textAttr = wxRichTextAttr());
1071
1072 /**
1073 Write a table at the current insertion point, returning the table.
1074 You can then call SetFocusObject() to set the focus to the new object.
1075 */
1076 virtual wxRichTextTable* WriteTable(int rows, int cols, const wxRichTextAttr& tableAttr = wxRichTextAttr(), const wxRichTextAttr& cellAttr = wxRichTextAttr());
1077
1078 /**
1079 Inserts a new paragraph at the current insertion point. @see LineBreak().
1080 */
1081 virtual bool Newline();
1082
1083 /**
1084 Inserts a line break at the current insertion point.
1085
1086 A line break forces wrapping within a paragraph, and can be introduced by
1087 using this function, by appending the wxChar value @b wxRichTextLineBreakChar
1088 to text content, or by typing Shift-Return.
1089 */
1090 virtual bool LineBreak();
1091
1092 /**
1093 Sets the basic (overall) style.
1094
1095 This is the style of the whole buffer before further styles are applied,
1096 unlike the default style, which only affects the style currently being
1097 applied (for example, setting the default style to bold will cause
1098 subsequently inserted text to be bold).
1099 */
1100 virtual void SetBasicStyle(const wxRichTextAttr& style) { GetBuffer().SetBasicStyle(style); }
1101
1102 /**
1103 Gets the basic (overall) style.
1104
1105 This is the style of the whole buffer before further styles are applied,
1106 unlike the default style, which only affects the style currently being
1107 applied (for example, setting the default style to bold will cause
1108 subsequently inserted text to be bold).
1109 */
1110 virtual const wxRichTextAttr& GetBasicStyle() const { return GetBuffer().GetBasicStyle(); }
1111
1112 /**
1113 Begins applying a style.
1114 */
1115 virtual bool BeginStyle(const wxRichTextAttr& style) { return GetBuffer().BeginStyle(style); }
1116
1117 /**
1118 Ends the current style.
1119 */
1120 virtual bool EndStyle() { return GetBuffer().EndStyle(); }
1121
1122 /**
1123 Ends application of all styles in the current style stack.
1124 */
1125 virtual bool EndAllStyles() { return GetBuffer().EndAllStyles(); }
1126
1127 /**
1128 Begins using bold.
1129 */
1130 bool BeginBold() { return GetBuffer().BeginBold(); }
1131
1132 /**
1133 Ends using bold.
1134 */
1135 bool EndBold() { return GetBuffer().EndBold(); }
1136
1137 /**
1138 Begins using italic.
1139 */
1140 bool BeginItalic() { return GetBuffer().BeginItalic(); }
1141
1142 /**
1143 Ends using italic.
1144 */
1145 bool EndItalic() { return GetBuffer().EndItalic(); }
1146
1147 /**
1148 Begins using underlining.
1149 */
1150 bool BeginUnderline() { return GetBuffer().BeginUnderline(); }
1151
1152 /**
1153 End applying underlining.
1154 */
1155 bool EndUnderline() { return GetBuffer().EndUnderline(); }
1156
1157 /**
1158 Begins using the given point size.
1159 */
1160 bool BeginFontSize(int pointSize) { return GetBuffer().BeginFontSize(pointSize); }
1161
1162 /**
1163 Ends using a point size.
1164 */
1165 bool EndFontSize() { return GetBuffer().EndFontSize(); }
1166
1167 /**
1168 Begins using this font.
1169 */
1170 bool BeginFont(const wxFont& font) { return GetBuffer().BeginFont(font); }
1171
1172 /**
1173 Ends using a font.
1174 */
1175 bool EndFont() { return GetBuffer().EndFont(); }
1176
1177 /**
1178 Begins using this colour.
1179 */
1180 bool BeginTextColour(const wxColour& colour) { return GetBuffer().BeginTextColour(colour); }
1181
1182 /**
1183 Ends applying a text colour.
1184 */
1185 bool EndTextColour() { return GetBuffer().EndTextColour(); }
1186
1187 /**
1188 Begins using alignment.
1189 For alignment values, see wxTextAttr.
1190 */
1191 bool BeginAlignment(wxTextAttrAlignment alignment) { return GetBuffer().BeginAlignment(alignment); }
1192
1193 /**
1194 Ends alignment.
1195 */
1196 bool EndAlignment() { return GetBuffer().EndAlignment(); }
1197
1198 /**
1199 Begins applying a left indent and subindent in tenths of a millimetre.
1200 The subindent is an offset from the left edge of the paragraph, and is
1201 used for all but the first line in a paragraph. A positive value will
1202 cause the first line to appear to the left of the subsequent lines, and
1203 a negative value will cause the first line to be indented to the right
1204 of the subsequent lines.
1205
1206 wxRichTextBuffer uses indentation to render a bulleted item. The
1207 content of the paragraph, including the first line, starts at the
1208 @a leftIndent plus the @a leftSubIndent.
1209
1210 @param leftIndent
1211 The distance between the margin and the bullet.
1212 @param leftSubIndent
1213 The distance between the left edge of the bullet and the left edge
1214 of the actual paragraph.
1215 */
1216 bool BeginLeftIndent(int leftIndent, int leftSubIndent = 0) { return GetBuffer().BeginLeftIndent(leftIndent, leftSubIndent); }
1217
1218 /**
1219 Ends left indent.
1220 */
1221 bool EndLeftIndent() { return GetBuffer().EndLeftIndent(); }
1222
1223 /**
1224 Begins a right indent, specified in tenths of a millimetre.
1225 */
1226 bool BeginRightIndent(int rightIndent) { return GetBuffer().BeginRightIndent(rightIndent); }
1227
1228 /**
1229 Ends right indent.
1230 */
1231 bool EndRightIndent() { return GetBuffer().EndRightIndent(); }
1232
1233 /**
1234 Begins paragraph spacing; pass the before-paragraph and after-paragraph spacing
1235 in tenths of a millimetre.
1236 */
1237 bool BeginParagraphSpacing(int before, int after) { return GetBuffer().BeginParagraphSpacing(before, after); }
1238
1239 /**
1240 Ends paragraph spacing.
1241 */
1242 bool EndParagraphSpacing() { return GetBuffer().EndParagraphSpacing(); }
1243
1244 /**
1245 Begins appling line spacing. @e spacing is a multiple, where 10 means
1246 single-spacing, 15 means 1.5 spacing, and 20 means double spacing.
1247
1248 The ::wxTextAttrLineSpacing constants are defined for convenience.
1249 */
1250 bool BeginLineSpacing(int lineSpacing) { return GetBuffer().BeginLineSpacing(lineSpacing); }
1251
1252 /**
1253 Ends line spacing.
1254 */
1255 bool EndLineSpacing() { return GetBuffer().EndLineSpacing(); }
1256
1257 /**
1258 Begins a numbered bullet.
1259
1260 This call will be needed for each item in the list, and the
1261 application should take care of incrementing the numbering.
1262
1263 @a bulletNumber is a number, usually starting with 1.
1264 @a leftIndent and @a leftSubIndent are values in tenths of a millimetre.
1265 @a bulletStyle is a bitlist of the ::wxTextAttrBulletStyle values.
1266
1267 wxRichTextBuffer uses indentation to render a bulleted item.
1268 The left indent is the distance between the margin and the bullet.
1269 The content of the paragraph, including the first line, starts
1270 at leftMargin + leftSubIndent.
1271 So the distance between the left edge of the bullet and the
1272 left of the actual paragraph is leftSubIndent.
1273 */
1274 bool BeginNumberedBullet(int bulletNumber, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_ARABIC|wxTEXT_ATTR_BULLET_STYLE_PERIOD)
1275 { return GetBuffer().BeginNumberedBullet(bulletNumber, leftIndent, leftSubIndent, bulletStyle); }
1276
1277 /**
1278 Ends application of a numbered bullet.
1279 */
1280 bool EndNumberedBullet() { return GetBuffer().EndNumberedBullet(); }
1281
1282 /**
1283 Begins applying a symbol bullet, using a character from the current font.
1284 See BeginNumberedBullet() for an explanation of how indentation is used
1285 to render the bulleted paragraph.
1286 */
1287 bool BeginSymbolBullet(const wxString& symbol, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_SYMBOL)
1288 { return GetBuffer().BeginSymbolBullet(symbol, leftIndent, leftSubIndent, bulletStyle); }
1289
1290 /**
1291 Ends applying a symbol bullet.
1292 */
1293 bool EndSymbolBullet() { return GetBuffer().EndSymbolBullet(); }
1294
1295 /**
1296 Begins applying a symbol bullet.
1297 */
1298 bool BeginStandardBullet(const wxString& bulletName, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_STANDARD)
1299 { return GetBuffer().BeginStandardBullet(bulletName, leftIndent, leftSubIndent, bulletStyle); }
1300
1301 /**
1302 Begins applying a standard bullet.
1303 */
1304 bool EndStandardBullet() { return GetBuffer().EndStandardBullet(); }
1305
1306 /**
1307 Begins using the named character style.
1308 */
1309 bool BeginCharacterStyle(const wxString& characterStyle) { return GetBuffer().BeginCharacterStyle(characterStyle); }
1310
1311 /**
1312 Ends application of a named character style.
1313 */
1314 bool EndCharacterStyle() { return GetBuffer().EndCharacterStyle(); }
1315
1316 /**
1317 Begins applying the named paragraph style.
1318 */
1319 bool BeginParagraphStyle(const wxString& paragraphStyle) { return GetBuffer().BeginParagraphStyle(paragraphStyle); }
1320
1321 /**
1322 Ends application of a named paragraph style.
1323 */
1324 bool EndParagraphStyle() { return GetBuffer().EndParagraphStyle(); }
1325
1326 /**
1327 Begins using a specified list style.
1328 Optionally, you can also pass a level and a number.
1329 */
1330 bool BeginListStyle(const wxString& listStyle, int level = 1, int number = 1) { return GetBuffer().BeginListStyle(listStyle, level, number); }
1331
1332 /**
1333 Ends using a specified list style.
1334 */
1335 bool EndListStyle() { return GetBuffer().EndListStyle(); }
1336
1337 /**
1338 Begins applying wxTEXT_ATTR_URL to the content.
1339
1340 Pass a URL and optionally, a character style to apply, since it is common
1341 to mark a URL with a familiar style such as blue text with underlining.
1342 */
1343 bool BeginURL(const wxString& url, const wxString& characterStyle = wxEmptyString) { return GetBuffer().BeginURL(url, characterStyle); }
1344
1345 /**
1346 Ends applying a URL.
1347 */
1348 bool EndURL() { return GetBuffer().EndURL(); }
1349
1350 /**
1351 Sets the default style to the style under the cursor.
1352 */
1353 bool SetDefaultStyleToCursorStyle();
1354
1355 /**
1356 Cancels any selection.
1357 */
1358 virtual void SelectNone();
1359
1360 /**
1361 Selects the word at the given character position.
1362 */
1363 virtual bool SelectWord(long position);
1364
1365 /**
1366 Returns the selection range in character positions. -1, -1 means no selection.
1367
1368 The range is in API convention, i.e. a single character selection is denoted
1369 by (n, n+1)
1370 */
1371 wxRichTextRange GetSelectionRange() const;
1372
1373 /**
1374 Sets the selection to the given range.
1375 The end point of range is specified as the last character position of the span
1376 of text, plus one.
1377
1378 So, for example, to set the selection for a character at position 5, use the
1379 range (5,6).
1380 */
1381 void SetSelectionRange(const wxRichTextRange& range);
1382
1383 /**
1384 Returns the selection range in character positions. -2, -2 means no selection
1385 -1, -1 means select everything.
1386 The range is in internal format, i.e. a single character selection is denoted
1387 by (n, n)
1388 */
1389 wxRichTextRange GetInternalSelectionRange() const { return m_selection.GetRange(); }
1390
1391 /**
1392 Sets the selection range in character positions. -2, -2 means no selection
1393 -1, -1 means select everything.
1394 The range is in internal format, i.e. a single character selection is denoted
1395 by (n, n)
1396 */
1397 void SetInternalSelectionRange(const wxRichTextRange& range) { m_selection.Set(range, GetFocusObject()); }
1398
1399 /**
1400 Adds a new paragraph of text to the end of the buffer.
1401 */
1402 virtual wxRichTextRange AddParagraph(const wxString& text);
1403
1404 /**
1405 Adds an image to the control's buffer.
1406 */
1407 virtual wxRichTextRange AddImage(const wxImage& image);
1408
1409 /**
1410 Lays out the buffer, which must be done before certain operations, such as
1411 setting the caret position.
1412 This function should not normally be required by the application.
1413 */
1414 virtual bool LayoutContent(bool onlyVisibleRect = false);
1415
1416 /**
1417 Move the caret to the given character position.
1418
1419 Please note that this does not update the current editing style
1420 from the new position; to do that, call wxRichTextCtrl::SetInsertionPoint instead.
1421 */
1422 virtual bool MoveCaret(long pos, bool showAtLineStart = false, wxRichTextParagraphLayoutBox* container = NULL);
1423
1424 /**
1425 Moves right.
1426 */
1427 virtual bool MoveRight(int noPositions = 1, int flags = 0);
1428
1429 /**
1430 Moves left.
1431 */
1432 virtual bool MoveLeft(int noPositions = 1, int flags = 0);
1433
1434 /**
1435 Moves to the start of the paragraph.
1436 */
1437 virtual bool MoveUp(int noLines = 1, int flags = 0);
1438
1439 /**
1440 Moves the caret down.
1441 */
1442 virtual bool MoveDown(int noLines = 1, int flags = 0);
1443
1444 /**
1445 Moves to the end of the line.
1446 */
1447 virtual bool MoveToLineEnd(int flags = 0);
1448
1449 /**
1450 Moves to the start of the line.
1451 */
1452 virtual bool MoveToLineStart(int flags = 0);
1453
1454 /**
1455 Moves to the end of the paragraph.
1456 */
1457 virtual bool MoveToParagraphEnd(int flags = 0);
1458
1459 /**
1460 Moves to the start of the paragraph.
1461 */
1462 virtual bool MoveToParagraphStart(int flags = 0);
1463
1464 /**
1465 Moves to the start of the buffer.
1466 */
1467 virtual bool MoveHome(int flags = 0);
1468
1469 /**
1470 Moves to the end of the buffer.
1471 */
1472 virtual bool MoveEnd(int flags = 0);
1473
1474 /**
1475 Moves one or more pages up.
1476 */
1477 virtual bool PageUp(int noPages = 1, int flags = 0);
1478
1479 /**
1480 Moves one or more pages down.
1481 */
1482 virtual bool PageDown(int noPages = 1, int flags = 0);
1483
1484 /**
1485 Moves a number of words to the left.
1486 */
1487 virtual bool WordLeft(int noPages = 1, int flags = 0);
1488
1489 /**
1490 Move a nuber of words to the right.
1491 */
1492 virtual bool WordRight(int noPages = 1, int flags = 0);
1493
1494 //@{
1495 /**
1496 Returns the buffer associated with the control.
1497 */
1498 wxRichTextBuffer& GetBuffer() { return m_buffer; }
1499 const wxRichTextBuffer& GetBuffer() const { return m_buffer; }
1500 //@}
1501
1502 /**
1503 Starts batching undo history for commands.
1504 */
1505 virtual bool BeginBatchUndo(const wxString& cmdName) { return m_buffer.BeginBatchUndo(cmdName); }
1506
1507 /**
1508 Ends batching undo command history.
1509 */
1510 virtual bool EndBatchUndo() { return m_buffer.EndBatchUndo(); }
1511
1512 /**
1513 Returns @true if undo commands are being batched.
1514 */
1515 virtual bool BatchingUndo() const { return m_buffer.BatchingUndo(); }
1516
1517 /**
1518 Starts suppressing undo history for commands.
1519 */
1520 virtual bool BeginSuppressUndo() { return m_buffer.BeginSuppressUndo(); }
1521
1522 /**
1523 Ends suppressing undo command history.
1524 */
1525 virtual bool EndSuppressUndo() { return m_buffer.EndSuppressUndo(); }
1526
1527 /**
1528 Returns @true if undo history suppression is on.
1529 */
1530 virtual bool SuppressingUndo() const { return m_buffer.SuppressingUndo(); }
1531
1532 /**
1533 Test if this whole range has character attributes of the specified kind.
1534 If any of the attributes are different within the range, the test fails.
1535
1536 You can use this to implement, for example, bold button updating.
1537 @a style must have flags indicating which attributes are of interest.
1538 */
1539 virtual bool HasCharacterAttributes(const wxRichTextRange& range, const wxRichTextAttr& style) const
1540 {
1541 return GetBuffer().HasCharacterAttributes(range.ToInternal(), style);
1542 }
1543
1544 /**
1545 Test if this whole range has paragraph attributes of the specified kind.
1546 If any of the attributes are different within the range, the test fails.
1547 You can use this to implement, for example, centering button updating.
1548 @a style must have flags indicating which attributes are of interest.
1549 */
1550 virtual bool HasParagraphAttributes(const wxRichTextRange& range, const wxRichTextAttr& style) const
1551 {
1552 return GetBuffer().HasParagraphAttributes(range.ToInternal(), style);
1553 }
1554
1555 /**
1556 Returns @true if all of the selection, or the content at the caret position, is bold.
1557 */
1558 virtual bool IsSelectionBold();
1559
1560 /**
1561 Returns @true if all of the selection, or the content at the caret position, is italic.
1562 */
1563 virtual bool IsSelectionItalics();
1564
1565 /**
1566 Returns @true if all of the selection, or the content at the caret position, is underlined.
1567 */
1568 virtual bool IsSelectionUnderlined();
1569
1570 /**
1571 Returns @true if all of the selection, or the content at the current caret position, has the supplied wxTextAttrEffects flag(s).
1572 */
1573 virtual bool DoesSelectionHaveTextEffectFlag(int flag);
1574
1575 /**
1576 Returns @true if all of the selection, or the content at the caret position, is aligned according to the specified flag.
1577 */
1578 virtual bool IsSelectionAligned(wxTextAttrAlignment alignment);
1579
1580 /**
1581 Apples bold to the selection or default style (undoable).
1582 */
1583 virtual bool ApplyBoldToSelection();
1584
1585 /**
1586 Applies italic to the selection or default style (undoable).
1587 */
1588 virtual bool ApplyItalicToSelection();
1589
1590 /**
1591 Applies underline to the selection or default style (undoable).
1592 */
1593 virtual bool ApplyUnderlineToSelection();
1594
1595 /**
1596 Applies one or more wxTextAttrEffects flags to the selection (undoable).
1597 If there is no selection, it is applied to the default style.
1598 */
1599 virtual bool ApplyTextEffectToSelection(int flags);
1600
1601 /**
1602 Applies the given alignment to the selection or the default style (undoable).
1603 For alignment values, see wxTextAttr.
1604 */
1605 virtual bool ApplyAlignmentToSelection(wxTextAttrAlignment alignment);
1606
1607 /**
1608 Applies the style sheet to the buffer, matching paragraph styles in the sheet
1609 against named styles in the buffer.
1610
1611 This might be useful if the styles have changed.
1612 If @a sheet is @NULL, the sheet set with SetStyleSheet() is used.
1613 Currently this applies paragraph styles only.
1614 */
1615 virtual bool ApplyStyle(wxRichTextStyleDefinition* def);
1616
1617 /**
1618 Sets the style sheet associated with the control.
1619 A style sheet allows named character and paragraph styles to be applied.
1620 */
1621 void SetStyleSheet(wxRichTextStyleSheet* styleSheet) { GetBuffer().SetStyleSheet(styleSheet); }
1622
1623 /**
1624 Returns the style sheet associated with the control, if any.
1625 A style sheet allows named character and paragraph styles to be applied.
1626 */
1627 wxRichTextStyleSheet* GetStyleSheet() const { return GetBuffer().GetStyleSheet(); }
1628
1629 /**
1630 Push the style sheet to top of stack.
1631 */
1632 bool PushStyleSheet(wxRichTextStyleSheet* styleSheet) { return GetBuffer().PushStyleSheet(styleSheet); }
1633
1634 /**
1635 Pops the style sheet from top of stack.
1636 */
1637 wxRichTextStyleSheet* PopStyleSheet() { return GetBuffer().PopStyleSheet(); }
1638
1639 /**
1640 Applies the style sheet to the buffer, for example if the styles have changed.
1641 */
1642 bool ApplyStyleSheet(wxRichTextStyleSheet* styleSheet = NULL);
1643
1644 /**
1645 Shows the given context menu, optionally adding appropriate property-editing commands for the current position in the object hierarchy.
1646 */
1647 virtual bool ShowContextMenu(wxMenu* menu, const wxPoint& pt, bool addPropertyCommands = true);
1648
1649 /**
1650 Prepares the context menu, optionally adding appropriate property-editing commands.
1651 Returns the number of property commands added.
1652 */
1653 virtual int PrepareContextMenu(wxMenu* menu, const wxPoint& pt, bool addPropertyCommands = true);
1654
1655 /**
1656 Returns @true if we can edit the object's properties via a GUI.
1657 */
1658 virtual bool CanEditProperties(wxRichTextObject* obj) const { return obj->CanEditProperties(); }
1659
1660 /**
1661 Edits the object's properties via a GUI.
1662 */
1663 virtual bool EditProperties(wxRichTextObject* obj, wxWindow* parent) { return obj->EditProperties(parent, & GetBuffer()); }
1664
1665 /**
1666 Gets the object's properties menu label.
1667 */
1668 virtual wxString GetPropertiesMenuLabel(wxRichTextObject* obj) { return obj->GetPropertiesMenuLabel(); }
1669
1670 /**
1671 Prepares the content just before insertion (or after buffer reset). Called by the same function in wxRichTextBuffer.
1672 Currently is only called if undo mode is on.
1673 */
1674 virtual void PrepareContent(wxRichTextParagraphLayoutBox& WXUNUSED(container)) {}
1675
1676 /**
1677 Can we delete this range?
1678 Sends an event to the control.
1679 */
1680 virtual bool CanDeleteRange(wxRichTextParagraphLayoutBox& container, const wxRichTextRange& range) const;
1681
1682 /**
1683 Can we insert content at this position?
1684 Sends an event to the control.
1685 */
1686 virtual bool CanInsertContent(wxRichTextParagraphLayoutBox& container, long pos) const;
1687
1688 /**
1689 Enable or disable the vertical scrollbar.
1690 */
1691 virtual void EnableVerticalScrollbar(bool enable);
1692
1693 /**
1694 Returns @true if the vertical scrollbar is enabled.
1695 */
1696 virtual bool GetVerticalScrollbarEnabled() const { return m_verticalScrollbarEnabled; }
1697
1698 /**
1699 Sets the scale factor for displaying fonts, for example for more comfortable
1700 editing.
1701 */
1702 void SetFontScale(double fontScale, bool refresh = false);
1703
1704 /**
1705 Returns the scale factor for displaying fonts, for example for more comfortable
1706 editing.
1707 */
1708 double GetFontScale() const { return GetBuffer().GetFontScale(); }
1709
1710 /**
1711 Sets the scale factor for displaying certain dimensions such as indentation and
1712 inter-paragraph spacing. This can be useful when editing in a small control
1713 where you still want legible text, but a minimum of wasted white space.
1714 */
1715 void SetDimensionScale(double dimScale, bool refresh = false);
1716
1717 /**
1718 Returns the scale factor for displaying certain dimensions such as indentation
1719 and inter-paragraph spacing.
1720 */
1721 double GetDimensionScale() const { return GetBuffer().GetDimensionScale(); }
1722
1723 /**
1724 Sets an overall scale factor for displaying and editing the content.
1725 */
1726 void SetScale(double scale, bool refresh = false);
1727
1728 /**
1729 Returns an overall scale factor for displaying and editing the content.
1730 */
1731 double GetScale() const { return m_scale; }
1732
1733 /**
1734 Returns an unscaled point.
1735 */
1736 wxPoint GetUnscaledPoint(const wxPoint& pt) const;
1737
1738 /**
1739 Returns a scaled point.
1740 */
1741 wxPoint GetScaledPoint(const wxPoint& pt) const;
1742
1743 /**
1744 Returns an unscaled size.
1745 */
1746 wxSize GetUnscaledSize(const wxSize& sz) const;
1747
1748 /**
1749 Returns a scaled size.
1750 */
1751 wxSize GetScaledSize(const wxSize& sz) const;
1752
1753 /**
1754 Returns an unscaled rectangle.
1755 */
1756 wxRect GetUnscaledRect(const wxRect& rect) const;
1757
1758 /**
1759 Returns a scaled rectangle.
1760 */
1761 wxRect GetScaledRect(const wxRect& rect) const;
1762
1763 // Command handlers
1764
1765 /**
1766 Sends the event to the control.
1767 */
1768 void Command(wxCommandEvent& event);
1769
1770 /**
1771 Loads the first dropped file.
1772 */
1773 void OnDropFiles(wxDropFilesEvent& event);
1774
1775 void OnCaptureLost(wxMouseCaptureLostEvent& event);
1776 void OnSysColourChanged(wxSysColourChangedEvent& event);
1777
1778 /**
1779 Standard handler for the wxID_CUT command.
1780 */
1781 void OnCut(wxCommandEvent& event);
1782
1783 /**
1784 Standard handler for the wxID_COPY command.
1785 */
1786 void OnCopy(wxCommandEvent& event);
1787
1788 /**
1789 Standard handler for the wxID_PASTE command.
1790 */
1791 void OnPaste(wxCommandEvent& event);
1792
1793 /**
1794 Standard handler for the wxID_UNDO command.
1795 */
1796 void OnUndo(wxCommandEvent& event);
1797
1798 /**
1799 Standard handler for the wxID_REDO command.
1800 */
1801 void OnRedo(wxCommandEvent& event);
1802
1803 /**
1804 Standard handler for the wxID_SELECTALL command.
1805 */
1806 void OnSelectAll(wxCommandEvent& event);
1807
1808 /**
1809 Standard handler for property commands.
1810 */
1811 void OnProperties(wxCommandEvent& event);
1812
1813 /**
1814 Standard handler for the wxID_CLEAR command.
1815 */
1816 void OnClear(wxCommandEvent& event);
1817
1818 /**
1819 Standard update handler for the wxID_CUT command.
1820 */
1821 void OnUpdateCut(wxUpdateUIEvent& event);
1822
1823 /**
1824 Standard update handler for the wxID_COPY command.
1825 */
1826 void OnUpdateCopy(wxUpdateUIEvent& event);
1827
1828 /**
1829 Standard update handler for the wxID_PASTE command.
1830 */
1831 void OnUpdatePaste(wxUpdateUIEvent& event);
1832
1833 /**
1834 Standard update handler for the wxID_UNDO command.
1835 */
1836 void OnUpdateUndo(wxUpdateUIEvent& event);
1837
1838 /**
1839 Standard update handler for the wxID_REDO command.
1840 */
1841 void OnUpdateRedo(wxUpdateUIEvent& event);
1842
1843 /**
1844 Standard update handler for the wxID_SELECTALL command.
1845 */
1846 void OnUpdateSelectAll(wxUpdateUIEvent& event);
1847
1848 /**
1849 Standard update handler for property commands.
1850 */
1851
1852 void OnUpdateProperties(wxUpdateUIEvent& event);
1853
1854 /**
1855 Standard update handler for the wxID_CLEAR command.
1856 */
1857 void OnUpdateClear(wxUpdateUIEvent& event);
1858
1859 /**
1860 Shows a standard context menu with undo, redo, cut, copy, paste, clear, and
1861 select all commands.
1862 */
1863 void OnContextMenu(wxContextMenuEvent& event);
1864
1865 // Event handlers
1866
1867 // Painting
1868 void OnPaint(wxPaintEvent& event);
1869 void OnEraseBackground(wxEraseEvent& event);
1870
1871 // Left-click
1872 void OnLeftClick(wxMouseEvent& event);
1873
1874 // Left-up
1875 void OnLeftUp(wxMouseEvent& event);
1876
1877 // Motion
1878 void OnMoveMouse(wxMouseEvent& event);
1879
1880 // Left-double-click
1881 void OnLeftDClick(wxMouseEvent& event);
1882
1883 // Middle-click
1884 void OnMiddleClick(wxMouseEvent& event);
1885
1886 // Right-click
1887 void OnRightClick(wxMouseEvent& event);
1888
1889 // Key press
1890 void OnChar(wxKeyEvent& event);
1891
1892 // Sizing
1893 void OnSize(wxSizeEvent& event);
1894
1895 // Setting/losing focus
1896 void OnSetFocus(wxFocusEvent& event);
1897 void OnKillFocus(wxFocusEvent& event);
1898
1899 // Idle-time processing
1900 void OnIdle(wxIdleEvent& event);
1901
1902 // Scrolling
1903 void OnScroll(wxScrollWinEvent& event);
1904
1905 /**
1906 Sets the font, and also the basic and default attributes
1907 (see wxRichTextCtrl::SetDefaultStyle).
1908 */
1909 virtual bool SetFont(const wxFont& font);
1910
1911 /**
1912 A helper function setting up scrollbars, for example after a resize.
1913 */
1914 virtual void SetupScrollbars(bool atTop = false);
1915
1916 /**
1917 Helper function implementing keyboard navigation.
1918 */
1919 virtual bool KeyboardNavigate(int keyCode, int flags);
1920
1921 /**
1922 Paints the background.
1923 */
1924 virtual void PaintBackground(wxDC& dc);
1925
1926 /**
1927 Other user defined painting after everything else (i.e. all text) is painted.
1928
1929 @since 2.9.1
1930 */
1931 virtual void PaintAboveContent(wxDC& WXUNUSED(dc)) {}
1932
1933 #if wxRICHTEXT_BUFFERED_PAINTING
1934 /**
1935 Recreates the buffer bitmap if necessary.
1936 */
1937 virtual bool RecreateBuffer(const wxSize& size = wxDefaultSize);
1938 #endif
1939
1940 // Write text
1941 virtual void DoWriteText(const wxString& value, int flags = 0);
1942
1943 // Should we inherit colours?
1944 virtual bool ShouldInheritColours() const { return false; }
1945
1946 /**
1947 Internal function to position the visible caret according to the current caret
1948 position.
1949 */
1950 virtual void PositionCaret(wxRichTextParagraphLayoutBox* container = NULL);
1951
1952 /**
1953 Helper function for extending the selection, returning @true if the selection
1954 was changed. Selections are in caret positions.
1955 */
1956 virtual bool ExtendSelection(long oldPosition, long newPosition, int flags);
1957
1958 /**
1959 Scrolls @a position into view. This function takes a caret position.
1960 */
1961 virtual bool ScrollIntoView(long position, int keyCode);
1962
1963 /**
1964 Refreshes the area affected by a selection change.
1965 */
1966 bool RefreshForSelectionChange(const wxRichTextSelection& oldSelection, const wxRichTextSelection& newSelection);
1967
1968 /**
1969 Sets the caret position.
1970
1971 The caret position is the character position just before the caret.
1972 A value of -1 means the caret is at the start of the buffer.
1973 Please note that this does not update the current editing style
1974 from the new position or cause the actual caret to be refreshed; to do that,
1975 call wxRichTextCtrl::SetInsertionPoint instead.
1976 */
1977 void SetCaretPosition(long position, bool showAtLineStart = false) ;
1978
1979 /**
1980 Returns the current caret position.
1981 */
1982 long GetCaretPosition() const { return m_caretPosition; }
1983
1984 /**
1985 The adjusted caret position is the character position adjusted to take
1986 into account whether we're at the start of a paragraph, in which case
1987 style information should be taken from the next position, not current one.
1988 */
1989 long GetAdjustedCaretPosition(long caretPos) const;
1990
1991 /**
1992 Move the caret one visual step forward: this may mean setting a flag
1993 and keeping the same position if we're going from the end of one line
1994 to the start of the next, which may be the exact same caret position.
1995 */
1996 void MoveCaretForward(long oldPosition) ;
1997
1998 /**
1999 Move the caret one visual step forward: this may mean setting a flag
2000 and keeping the same position if we're going from the end of one line
2001 to the start of the next, which may be the exact same caret position.
2002 */
2003 void MoveCaretBack(long oldPosition) ;
2004
2005 /**
2006 Returns the caret height and position for the given character position.
2007 If container is null, the current focus object will be used.
2008
2009 @beginWxPerlOnly
2010 In wxPerl this method is implemented as
2011 GetCaretPositionForIndex(@a position) returning a
2012 2-element list (ok, rect).
2013 @endWxPerlOnly
2014 */
2015 bool GetCaretPositionForIndex(long position, wxRect& rect, wxRichTextParagraphLayoutBox* container = NULL);
2016
2017 /**
2018 Internal helper function returning the line for the visible caret position.
2019 If the caret is shown at the very end of the line, it means the next character
2020 is actually on the following line.
2021 So this function gets the line we're expecting to find if this is the case.
2022 */
2023 wxRichTextLine* GetVisibleLineForCaretPosition(long caretPosition) const;
2024
2025 /**
2026 Gets the command processor associated with the control's buffer.
2027 */
2028 wxCommandProcessor* GetCommandProcessor() const { return GetBuffer().GetCommandProcessor(); }
2029
2030 /**
2031 Deletes content if there is a selection, e.g. when pressing a key.
2032 Returns the new caret position in @e newPos, or leaves it if there
2033 was no action. This is undoable.
2034
2035 @beginWxPerlOnly
2036 In wxPerl this method takes no arguments and returns a 2-element
2037 list (ok, newPos).
2038 @endWxPerlOnly
2039 */
2040 bool DeleteSelectedContent(long* newPos= NULL);
2041
2042 /**
2043 Transforms logical (unscrolled) position to physical window position.
2044 */
2045 wxPoint GetPhysicalPoint(const wxPoint& ptLogical) const;
2046
2047 /**
2048 Transforms physical window position to logical (unscrolled) position.
2049 */
2050 wxPoint GetLogicalPoint(const wxPoint& ptPhysical) const;
2051
2052 /**
2053 Helper function for finding the caret position for the next word.
2054 Direction is 1 (forward) or -1 (backwards).
2055 */
2056 virtual long FindNextWordPosition(int direction = 1) const;
2057
2058 /**
2059 Returns @true if the given position is visible on the screen.
2060 */
2061 bool IsPositionVisible(long pos) const;
2062
2063 /**
2064 Returns the first visible position in the current view.
2065 */
2066 long GetFirstVisiblePosition() const;
2067
2068 /**
2069 Returns the caret position since the default formatting was changed. As
2070 soon as this position changes, we no longer reflect the default style
2071 in the UI. A value of -2 means that we should only reflect the style of the
2072 content under the caret.
2073 */
2074 long GetCaretPositionForDefaultStyle() const { return m_caretPositionForDefaultStyle; }
2075
2076 /**
2077 Set the caret position for the default style that the user is selecting.
2078 */
2079 void SetCaretPositionForDefaultStyle(long pos) { m_caretPositionForDefaultStyle = pos; }
2080
2081 /**
2082 Returns @true if the user has recently set the default style without moving
2083 the caret, and therefore the UI needs to reflect the default style and not
2084 the style at the caret.
2085
2086 Below is an example of code that uses this function to determine whether the UI
2087 should show that the current style is bold.
2088
2089 @see SetAndShowDefaultStyle().
2090 */
2091 bool IsDefaultStyleShowing() const { return m_caretPositionForDefaultStyle != -2; }
2092
2093 /**
2094 Sets @a attr as the default style and tells the control that the UI should
2095 reflect this attribute until the user moves the caret.
2096
2097 @see IsDefaultStyleShowing().
2098 */
2099 void SetAndShowDefaultStyle(const wxRichTextAttr& attr)
2100 {
2101 SetDefaultStyle(attr);
2102 SetCaretPositionForDefaultStyle(GetCaretPosition());
2103 }
2104
2105 /**
2106 Returns the first visible point in the window.
2107 */
2108 wxPoint GetFirstVisiblePoint() const;
2109
2110 #ifdef DOXYGEN
2111 /**
2112 Returns the content of the entire control as a string.
2113 */
2114 virtual wxString GetValue() const;
2115
2116 /**
2117 Replaces existing content with the given text.
2118 */
2119 virtual void SetValue(const wxString& value);
2120
2121 /**
2122 Call this function to prevent refresh and allow fast updates, and then Thaw() to
2123 refresh the control.
2124 */
2125 void Freeze();
2126
2127 /**
2128 Call this function to end a Freeze and refresh the display.
2129 */
2130 void Thaw();
2131
2132 /**
2133 Returns @true if Freeze has been called without a Thaw.
2134 */
2135 bool IsFrozen() const;
2136
2137 #endif
2138
2139 // Implementation
2140
2141 /**
2142 Processes the back key.
2143 */
2144 virtual bool ProcessBackKey(wxKeyEvent& event, int flags);
2145
2146 /**
2147 Given a character position at which there is a list style, find the range
2148 encompassing the same list style by looking backwards and forwards.
2149 */
2150 virtual wxRichTextRange FindRangeForList(long pos, bool& isNumberedList);
2151
2152 /**
2153 Sets up the caret for the given position and container, after a mouse click.
2154 */
2155 bool SetCaretPositionAfterClick(wxRichTextParagraphLayoutBox* container, long position, int hitTestFlags, bool extendSelection = false);
2156
2157 /**
2158 Find the caret position for the combination of hit-test flags and character position.
2159 Returns the caret position and also an indication of where to place the caret (caretLineStart)
2160 since this is ambiguous (same position used for end of line and start of next).
2161 */
2162 long FindCaretPositionForCharacterPosition(long position, int hitTestFlags, wxRichTextParagraphLayoutBox* container,
2163 bool& caretLineStart);
2164
2165 /**
2166 Processes mouse movement in order to change the cursor
2167 */
2168 virtual bool ProcessMouseMovement(wxRichTextParagraphLayoutBox* container, wxRichTextObject* obj, long position, const wxPoint& pos);
2169
2170 /**
2171 Font names take a long time to retrieve, so cache them (on demand).
2172 */
2173 static const wxArrayString& GetAvailableFontNames();
2174
2175 /**
2176 Clears the cache of available font names.
2177 */
2178 static void ClearAvailableFontNames();
2179
2180 WX_FORWARD_TO_SCROLL_HELPER()
2181
2182 // implement wxTextEntry methods
2183 virtual wxString DoGetValue() const;
2184
2185 protected:
2186 // implement the wxTextEntry pure virtual method
2187 virtual wxWindow *GetEditableWindow() { return this; }
2188
2189 // margins functions
2190 virtual bool DoSetMargins(const wxPoint& pt);
2191 virtual wxPoint DoGetMargins() const;
2192
2193 // FIXME: this does not work, it allows this code to compile but will fail
2194 // during run-time
2195 #ifndef __WXUNIVERSAL__
2196 #ifdef __WXMSW__
2197 virtual WXHWND GetEditHWND() const { return GetHWND(); }
2198 #endif
2199 #ifdef __WXMOTIF__
2200 virtual WXWidget GetTextWidget() const { return NULL; }
2201 #endif
2202 #ifdef __WXGTK20__
2203 virtual GtkEditable *GetEditable() const { return NULL; }
2204 virtual GtkEntry *GetEntry() const { return NULL; }
2205 #endif
2206 #endif // !__WXUNIVERSAL__
2207
2208 // Overrides
2209 protected:
2210
2211 /**
2212 Currently this simply returns @c wxSize(10, 10).
2213 */
2214 virtual wxSize DoGetBestSize() const ;
2215
2216 virtual void DoSetValue(const wxString& value, int flags = 0);
2217
2218 virtual void DoThaw();
2219
2220
2221 // Data members
2222 protected:
2223 #if wxRICHTEXT_BUFFERED_PAINTING
2224 /// Buffer bitmap
2225 wxBitmap m_bufferBitmap;
2226 #endif
2227
2228 /// Text buffer
2229 wxRichTextBuffer m_buffer;
2230
2231 wxMenu* m_contextMenu;
2232
2233 /// Caret position (1 less than the character position, so -1 is the
2234 /// first caret position).
2235 long m_caretPosition;
2236
2237 /// Caret position when the default formatting has been changed. As
2238 /// soon as this position changes, we no longer reflect the default style
2239 /// in the UI.
2240 long m_caretPositionForDefaultStyle;
2241
2242 /// Selection range in character positions. -2, -2 means no selection.
2243 wxRichTextSelection m_selection;
2244
2245 wxRichTextCtrlSelectionState m_selectionState;
2246
2247 /// Anchor so we know how to extend the selection
2248 /// It's a caret position since it's between two characters.
2249 long m_selectionAnchor;
2250
2251 /// Anchor object if selecting multiple container objects, such as grid cells.
2252 wxRichTextObject* m_selectionAnchorObject;
2253
2254 /// Are we editable?
2255 bool m_editable;
2256
2257 /// Is the vertical scrollbar enabled?
2258 bool m_verticalScrollbarEnabled;
2259
2260 /// Are we showing the caret position at the start of a line
2261 /// instead of at the end of the previous one?
2262 bool m_caretAtLineStart;
2263
2264 /// Are we dragging (i.e. extending) a selection?
2265 bool m_dragging;
2266
2267 #if wxUSE_DRAG_AND_DROP
2268 /// Are we trying to start Drag'n'Drop?
2269 bool m_preDrag;
2270
2271 /// Initial position when starting Drag'n'Drop
2272 wxPoint m_dragStartPoint;
2273
2274 #if wxUSE_DATETIME
2275 /// Initial time when starting Drag'n'Drop
2276 wxDateTime m_dragStartTime;
2277 #endif // wxUSE_DATETIME
2278 #endif // wxUSE_DRAG_AND_DROP
2279
2280 /// Do we need full layout in idle?
2281 bool m_fullLayoutRequired;
2282 wxLongLong m_fullLayoutTime;
2283 long m_fullLayoutSavedPosition;
2284
2285 /// Threshold for doing delayed layout
2286 long m_delayedLayoutThreshold;
2287
2288 /// Cursors
2289 wxCursor m_textCursor;
2290 wxCursor m_urlCursor;
2291
2292 static wxArrayString sm_availableFontNames;
2293
2294 wxRichTextContextMenuPropertiesInfo m_contextMenuPropertiesInfo;
2295
2296 /// The object that currently has the editing focus
2297 wxRichTextParagraphLayoutBox* m_focusObject;
2298
2299 /// An overall scale factor
2300 double m_scale;
2301 };
2302
2303 #if wxUSE_DRAG_AND_DROP
2304 class WXDLLIMPEXP_RICHTEXT wxRichTextDropSource : public wxDropSource
2305 {
2306 public:
2307 wxRichTextDropSource(wxDataObject& data, wxRichTextCtrl* tc)
2308 : wxDropSource(data, tc), m_rtc(tc) {}
2309
2310 protected:
2311 bool GiveFeedback(wxDragResult effect);
2312
2313 wxRichTextCtrl* m_rtc;
2314 };
2315
2316 class WXDLLIMPEXP_RICHTEXT wxRichTextDropTarget : public wxDropTarget
2317 {
2318 public:
2319 wxRichTextDropTarget(wxRichTextCtrl* tc)
2320 : wxDropTarget(new wxRichTextBufferDataObject(new wxRichTextBuffer)), m_rtc(tc) {}
2321
2322 virtual wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def)
2323 {
2324 if ( !GetData() )
2325 return wxDragNone;
2326 m_rtc->OnDrop(x, y, def, m_dataObject);
2327 return def;
2328 }
2329
2330 protected:
2331 wxRichTextCtrl* m_rtc;
2332 };
2333 #endif // wxUSE_DRAG_AND_DROP
2334
2335 /**
2336 @class wxRichTextEvent
2337
2338 This is the event class for wxRichTextCtrl notifications.
2339
2340 @beginEventTable{wxRichTextEvent}
2341 @event{EVT_RICHTEXT_LEFT_CLICK(id, func)}
2342 Process a @c wxEVT_COMMAND_RICHTEXT_LEFT_CLICK event, generated when the user
2343 releases the left mouse button over an object.
2344 @event{EVT_RICHTEXT_RIGHT_CLICK(id, func)}
2345 Process a @c wxEVT_COMMAND_RICHTEXT_RIGHT_CLICK event, generated when the user
2346 releases the right mouse button over an object.
2347 @event{EVT_RICHTEXT_MIDDLE_CLICK(id, func)}
2348 Process a @c wxEVT_COMMAND_RICHTEXT_MIDDLE_CLICK event, generated when the user
2349 releases the middle mouse button over an object.
2350 @event{EVT_RICHTEXT_LEFT_DCLICK(id, func)}
2351 Process a @c wxEVT_COMMAND_RICHTEXT_LEFT_DCLICK event, generated when the user
2352 double-clicks an object.
2353 @event{EVT_RICHTEXT_RETURN(id, func)}
2354 Process a @c wxEVT_COMMAND_RICHTEXT_RETURN event, generated when the user
2355 presses the return key. Valid event functions: GetFlags, GetPosition.
2356 @event{EVT_RICHTEXT_CHARACTER(id, func)}
2357 Process a @c wxEVT_COMMAND_RICHTEXT_CHARACTER event, generated when the user
2358 presses a character key. Valid event functions: GetFlags, GetPosition, GetCharacter.
2359 @event{EVT_RICHTEXT_DELETE(id, func)}
2360 Process a @c wxEVT_COMMAND_RICHTEXT_DELETE event, generated when the user
2361 presses the backspace or delete key. Valid event functions: GetFlags, GetPosition.
2362 @event{EVT_RICHTEXT_RETURN(id, func)}
2363 Process a @c wxEVT_COMMAND_RICHTEXT_RETURN event, generated when the user
2364 presses the return key. Valid event functions: GetFlags, GetPosition.
2365 @event{EVT_RICHTEXT_STYLE_CHANGED(id, func)}
2366 Process a @c wxEVT_COMMAND_RICHTEXT_STYLE_CHANGED event, generated when
2367 styling has been applied to the control. Valid event functions: GetPosition, GetRange.
2368 @event{EVT_RICHTEXT_STYLESHEET_CHANGED(id, func)}
2369 Process a @c wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGING event, generated
2370 when the control's stylesheet has changed, for example the user added,
2371 edited or deleted a style. Valid event functions: GetRange, GetPosition.
2372 @event{EVT_RICHTEXT_STYLESHEET_REPLACING(id, func)}
2373 Process a @c wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACING event, generated
2374 when the control's stylesheet is about to be replaced, for example when
2375 a file is loaded into the control.
2376 Valid event functions: Veto, GetOldStyleSheet, GetNewStyleSheet.
2377 @event{EVT_RICHTEXT_STYLESHEET_REPLACED(id, func)}
2378 Process a @c wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACED event, generated
2379 when the control's stylesheet has been replaced, for example when a file
2380 is loaded into the control.
2381 Valid event functions: GetOldStyleSheet, GetNewStyleSheet.
2382 @event{EVT_RICHTEXT_PROPERTIES_CHANGED(id, func)}
2383 Process a @c wxEVT_COMMAND_RICHTEXT_PROPERTIES_CHANGED event, generated when
2384 properties have been applied to the control. Valid event functions: GetPosition, GetRange.
2385 @event{EVT_RICHTEXT_CONTENT_INSERTED(id, func)}
2386 Process a @c wxEVT_COMMAND_RICHTEXT_CONTENT_INSERTED event, generated when
2387 content has been inserted into the control.
2388 Valid event functions: GetPosition, GetRange.
2389 @event{EVT_RICHTEXT_CONTENT_DELETED(id, func)}
2390 Process a @c wxEVT_COMMAND_RICHTEXT_CONTENT_DELETED event, generated when
2391 content has been deleted from the control.
2392 Valid event functions: GetPosition, GetRange.
2393 @event{EVT_RICHTEXT_BUFFER_RESET(id, func)}
2394 Process a @c wxEVT_COMMAND_RICHTEXT_BUFFER_RESET event, generated when the
2395 buffer has been reset by deleting all content.
2396 You can use this to set a default style for the first new paragraph.
2397 @event{EVT_RICHTEXT_SELECTION_CHANGED(id, func)}
2398 Process a @c wxEVT_COMMAND_RICHTEXT_SELECTION_CHANGED event, generated when the
2399 selection range has changed.
2400 @event{EVT_RICHTEXT_FOCUS_OBJECT_CHANGED(id, func)}
2401 Process a @c wxEVT_COMMAND_RICHTEXT_FOCUS_OBJECT_CHANGED event, generated when the
2402 current focus object has changed.
2403 @endEventTable
2404
2405 @library{wxrichtext}
2406 @category{events,richtext}
2407 */
2408
2409 class WXDLLIMPEXP_RICHTEXT wxRichTextEvent : public wxNotifyEvent
2410 {
2411 public:
2412 /**
2413 Constructor.
2414
2415 @param commandType
2416 The type of the event.
2417 @param id
2418 Window identifier. The value @c wxID_ANY indicates a default value.
2419 */
2420 wxRichTextEvent(wxEventType commandType = wxEVT_NULL, int winid = 0)
2421 : wxNotifyEvent(commandType, winid),
2422 m_flags(0), m_position(-1), m_oldStyleSheet(NULL), m_newStyleSheet(NULL),
2423 m_char((wxChar) 0), m_container(NULL), m_oldContainer(NULL)
2424 { }
2425
2426 /**
2427 Copy constructor.
2428 */
2429 wxRichTextEvent(const wxRichTextEvent& event)
2430 : wxNotifyEvent(event),
2431 m_flags(event.m_flags), m_position(-1),
2432 m_oldStyleSheet(event.m_oldStyleSheet), m_newStyleSheet(event.m_newStyleSheet),
2433 m_char((wxChar) 0), m_container(event.m_container), m_oldContainer(event.m_oldContainer)
2434 { }
2435
2436 /**
2437 Returns the buffer position at which the event occured.
2438 */
2439 long GetPosition() const { return m_position; }
2440
2441 /**
2442 Sets the buffer position variable.
2443 */
2444 void SetPosition(long pos) { m_position = pos; }
2445
2446 /**
2447 Returns flags indicating modifier keys pressed.
2448
2449 Possible values are @c wxRICHTEXT_CTRL_DOWN, @c wxRICHTEXT_SHIFT_DOWN, and @c wxRICHTEXT_ALT_DOWN.
2450 */
2451 int GetFlags() const { return m_flags; }
2452
2453 /**
2454 Sets flags indicating modifier keys pressed.
2455
2456 Possible values are @c wxRICHTEXT_CTRL_DOWN, @c wxRICHTEXT_SHIFT_DOWN, and @c wxRICHTEXT_ALT_DOWN.
2457 */
2458 void SetFlags(int flags) { m_flags = flags; }
2459
2460 /**
2461 Returns the old style sheet.
2462
2463 Can be used in a @c wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGING or
2464 @c wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGED event handler.
2465 */
2466 wxRichTextStyleSheet* GetOldStyleSheet() const { return m_oldStyleSheet; }
2467
2468 /**
2469 Sets the old style sheet variable.
2470 */
2471 void SetOldStyleSheet(wxRichTextStyleSheet* sheet) { m_oldStyleSheet = sheet; }
2472
2473 /**
2474 Returns the new style sheet.
2475
2476 Can be used in a @c wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGING or
2477 @c wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGED event handler.
2478 */
2479 wxRichTextStyleSheet* GetNewStyleSheet() const { return m_newStyleSheet; }
2480
2481 /**
2482 Sets the new style sheet variable.
2483 */
2484 void SetNewStyleSheet(wxRichTextStyleSheet* sheet) { m_newStyleSheet = sheet; }
2485
2486 /**
2487 Gets the range for the current operation.
2488 */
2489 const wxRichTextRange& GetRange() const { return m_range; }
2490
2491 /**
2492 Sets the range variable.
2493 */
2494 void SetRange(const wxRichTextRange& range) { m_range = range; }
2495
2496 /**
2497 Returns the character pressed, within a @c wxEVT_COMMAND_RICHTEXT_CHARACTER event.
2498 */
2499 wxChar GetCharacter() const { return m_char; }
2500
2501 /**
2502 Sets the character variable.
2503 */
2504 void SetCharacter(wxChar ch) { m_char = ch; }
2505
2506 /**
2507 Returns the container for which the event is relevant.
2508 */
2509 wxRichTextParagraphLayoutBox* GetContainer() const { return m_container; }
2510
2511 /**
2512 Sets the container for which the event is relevant.
2513 */
2514 void SetContainer(wxRichTextParagraphLayoutBox* container) { m_container = container; }
2515
2516 /**
2517 Returns the old container, for a focus change event.
2518 */
2519 wxRichTextParagraphLayoutBox* GetOldContainer() const { return m_oldContainer; }
2520
2521 /**
2522 Sets the old container, for a focus change event.
2523 */
2524 void SetOldContainer(wxRichTextParagraphLayoutBox* container) { m_oldContainer = container; }
2525
2526 virtual wxEvent *Clone() const { return new wxRichTextEvent(*this); }
2527
2528 protected:
2529 int m_flags;
2530 long m_position;
2531 wxRichTextStyleSheet* m_oldStyleSheet;
2532 wxRichTextStyleSheet* m_newStyleSheet;
2533 wxRichTextRange m_range;
2534 wxChar m_char;
2535 wxRichTextParagraphLayoutBox* m_container;
2536 wxRichTextParagraphLayoutBox* m_oldContainer;
2537
2538 private:
2539 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxRichTextEvent)
2540 };
2541
2542 /*!
2543 * wxRichTextCtrl events
2544 */
2545 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_LEFT_CLICK, wxRichTextEvent );
2546 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_RIGHT_CLICK, wxRichTextEvent );
2547 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_MIDDLE_CLICK, wxRichTextEvent );
2548 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_LEFT_DCLICK, wxRichTextEvent );
2549 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_RETURN, wxRichTextEvent );
2550 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_CHARACTER, wxRichTextEvent );
2551 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_DELETE, wxRichTextEvent );
2552
2553 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGING, wxRichTextEvent );
2554 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGED, wxRichTextEvent );
2555 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACING, wxRichTextEvent );
2556 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACED, wxRichTextEvent );
2557
2558 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_CONTENT_INSERTED, wxRichTextEvent );
2559 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_CONTENT_DELETED, wxRichTextEvent );
2560 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_STYLE_CHANGED, wxRichTextEvent );
2561 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_PROPERTIES_CHANGED, wxRichTextEvent );
2562 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_SELECTION_CHANGED, wxRichTextEvent );
2563 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_BUFFER_RESET, wxRichTextEvent );
2564 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_FOCUS_OBJECT_CHANGED, wxRichTextEvent );
2565
2566 typedef void (wxEvtHandler::*wxRichTextEventFunction)(wxRichTextEvent&);
2567
2568 #define wxRichTextEventHandler(func) \
2569 wxEVENT_HANDLER_CAST(wxRichTextEventFunction, func)
2570
2571 #define EVT_RICHTEXT_LEFT_CLICK(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_LEFT_CLICK, id, -1, wxRichTextEventHandler( fn ), NULL ),
2572 #define EVT_RICHTEXT_RIGHT_CLICK(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_RIGHT_CLICK, id, -1, wxRichTextEventHandler( fn ), NULL ),
2573 #define EVT_RICHTEXT_MIDDLE_CLICK(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_MIDDLE_CLICK, id, -1, wxRichTextEventHandler( fn ), NULL ),
2574 #define EVT_RICHTEXT_LEFT_DCLICK(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_LEFT_DCLICK, id, -1, wxRichTextEventHandler( fn ), NULL ),
2575 #define EVT_RICHTEXT_RETURN(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_RETURN, id, -1, wxRichTextEventHandler( fn ), NULL ),
2576 #define EVT_RICHTEXT_CHARACTER(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_CHARACTER, id, -1, wxRichTextEventHandler( fn ), NULL ),
2577 #define EVT_RICHTEXT_DELETE(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_DELETE, id, -1, wxRichTextEventHandler( fn ), NULL ),
2578
2579 #define EVT_RICHTEXT_STYLESHEET_CHANGING(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGING, id, -1, wxRichTextEventHandler( fn ), NULL ),
2580 #define EVT_RICHTEXT_STYLESHEET_CHANGED(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGED, id, -1, wxRichTextEventHandler( fn ), NULL ),
2581 #define EVT_RICHTEXT_STYLESHEET_REPLACING(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACING, id, -1, wxRichTextEventHandler( fn ), NULL ),
2582 #define EVT_RICHTEXT_STYLESHEET_REPLACED(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACED, id, -1, wxRichTextEventHandler( fn ), NULL ),
2583
2584 #define EVT_RICHTEXT_CONTENT_INSERTED(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_CONTENT_INSERTED, id, -1, wxRichTextEventHandler( fn ), NULL ),
2585 #define EVT_RICHTEXT_CONTENT_DELETED(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_CONTENT_DELETED, id, -1, wxRichTextEventHandler( fn ), NULL ),
2586 #define EVT_RICHTEXT_STYLE_CHANGED(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_STYLE_CHANGED, id, -1, wxRichTextEventHandler( fn ), NULL ),
2587 #define EVT_RICHTEXT_PROPERTIES_CHANGED(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_PROPERTIES_CHANGED, id, -1, wxRichTextEventHandler( fn ), NULL ),
2588 #define EVT_RICHTEXT_SELECTION_CHANGED(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_SELECTION_CHANGED, id, -1, wxRichTextEventHandler( fn ), NULL ),
2589 #define EVT_RICHTEXT_BUFFER_RESET(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_BUFFER_RESET, id, -1, wxRichTextEventHandler( fn ), NULL ),
2590 #define EVT_RICHTEXT_FOCUS_OBJECT_CHANGED(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_FOCUS_OBJECT_CHANGED, id, -1, wxRichTextEventHandler( fn ), NULL ),
2591
2592 #endif
2593 // wxUSE_RICHTEXT
2594
2595 #endif
2596 // _WX_RICHTEXTCTRL_H_