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     /**
1012         Selects all the text in the buffer.
1013     */
1014     virtual void SelectAll();
1015
1016     /**
1017         Makes the control editable, or not.
1018     */
1019     virtual void SetEditable(bool editable);
1020
1021     /**
1022         Returns @true if there is a selection and the object containing the selection
1023         was the same as the current focus object.
1024     */
1025     virtual bool HasSelection() const;
1026
1027     /**
1028         Returns @true if there was a selection, whether or not the current focus object
1029         is the same as the selection's container object.
1030     */
1031     virtual bool HasUnfocusedSelection() const;
1032
1033     //@{
1034     /**
1035         Write a bitmap or image at the current insertion point.
1036         Supply an optional type to use for internal and file storage of the raw data.
1037     */
1038     virtual bool WriteImage(const wxImage& image, wxBitmapType bitmapType = wxBITMAP_TYPE_PNG,
1039                             const wxRichTextAttr& textAttr = wxRichTextAttr());
1040
1041     virtual bool WriteImage(const wxBitmap& bitmap, wxBitmapType bitmapType = wxBITMAP_TYPE_PNG,
1042                             const wxRichTextAttr& textAttr = wxRichTextAttr());
1043     //@}
1044
1045     /**
1046         Loads an image from a file and writes it at the current insertion point.
1047     */
1048     virtual bool WriteImage(const wxString& filename, wxBitmapType bitmapType,
1049                             const wxRichTextAttr& textAttr = wxRichTextAttr());
1050
1051     /**
1052         Writes an image block at the current insertion point.
1053     */
1054     virtual bool WriteImage(const wxRichTextImageBlock& imageBlock,
1055                             const wxRichTextAttr& textAttr = wxRichTextAttr());
1056
1057     /**
1058         Write a text box at the current insertion point, returning the text box.
1059         You can then call SetFocusObject() to set the focus to the new object.
1060     */
1061     virtual wxRichTextBox* WriteTextBox(const wxRichTextAttr& textAttr = wxRichTextAttr());
1062
1063     /**
1064         Writes a field at the current insertion point.
1065
1066         @param fieldType
1067             The field type, matching an existing field type definition.
1068         @param properties
1069             Extra data for the field.
1070         @param textAttr
1071             Optional attributes.
1072
1073         @see wxRichTextField, wxRichTextFieldType, wxRichTextFieldTypeStandard
1074     */
1075     virtual wxRichTextField* WriteField(const wxString& fieldType, const wxRichTextProperties& properties,
1076                             const wxRichTextAttr& textAttr = wxRichTextAttr());
1077
1078     /**
1079         Write a table at the current insertion point, returning the table.
1080         You can then call SetFocusObject() to set the focus to the new object.
1081     */
1082     virtual wxRichTextTable* WriteTable(int rows, int cols, const wxRichTextAttr& tableAttr = wxRichTextAttr(), const wxRichTextAttr& cellAttr = wxRichTextAttr());
1083
1084     /**
1085         Inserts a new paragraph at the current insertion point. @see LineBreak().
1086     */
1087     virtual bool Newline();
1088
1089     /**
1090         Inserts a line break at the current insertion point.
1091
1092         A line break forces wrapping within a paragraph, and can be introduced by
1093         using this function, by appending the wxChar value @b  wxRichTextLineBreakChar
1094         to text content, or by typing Shift-Return.
1095     */
1096     virtual bool LineBreak();
1097
1098     /**
1099         Sets the basic (overall) style.
1100
1101         This is the style of the whole buffer before further styles are applied,
1102         unlike the default style, which only affects the style currently being
1103         applied (for example, setting the default style to bold will cause
1104         subsequently inserted text to be bold).
1105     */
1106     virtual void SetBasicStyle(const wxRichTextAttr& style) { GetBuffer().SetBasicStyle(style); }
1107
1108     /**
1109         Gets the basic (overall) style.
1110
1111         This is the style of the whole buffer before further styles are applied,
1112         unlike the default style, which only affects the style currently being
1113         applied (for example, setting the default style to bold will cause
1114         subsequently inserted text to be bold).
1115     */
1116     virtual const wxRichTextAttr& GetBasicStyle() const { return GetBuffer().GetBasicStyle(); }
1117
1118     /**
1119         Begins applying a style.
1120     */
1121     virtual bool BeginStyle(const wxRichTextAttr& style) { return GetBuffer().BeginStyle(style); }
1122
1123     /**
1124         Ends the current style.
1125     */
1126     virtual bool EndStyle() { return GetBuffer().EndStyle(); }
1127
1128     /**
1129         Ends application of all styles in the current style stack.
1130     */
1131     virtual bool EndAllStyles() { return GetBuffer().EndAllStyles(); }
1132
1133     /**
1134         Begins using bold.
1135     */
1136     bool BeginBold() { return GetBuffer().BeginBold(); }
1137
1138     /**
1139         Ends using bold.
1140     */
1141     bool EndBold()  { return GetBuffer().EndBold(); }
1142
1143     /**
1144         Begins using italic.
1145     */
1146     bool BeginItalic() { return GetBuffer().BeginItalic(); }
1147
1148     /**
1149         Ends using italic.
1150     */
1151     bool EndItalic() { return GetBuffer().EndItalic(); }
1152
1153     /**
1154         Begins using underlining.
1155     */
1156     bool BeginUnderline() { return GetBuffer().BeginUnderline(); }
1157
1158     /**
1159         End applying underlining.
1160     */
1161     bool EndUnderline() { return GetBuffer().EndUnderline(); }
1162
1163     /**
1164         Begins using the given point size.
1165     */
1166     bool BeginFontSize(int pointSize) { return GetBuffer().BeginFontSize(pointSize); }
1167
1168     /**
1169         Ends using a point size.
1170     */
1171     bool EndFontSize() { return GetBuffer().EndFontSize(); }
1172
1173     /**
1174         Begins using this font.
1175     */
1176     bool BeginFont(const wxFont& font) { return GetBuffer().BeginFont(font); }
1177
1178     /**
1179         Ends using a font.
1180     */
1181     bool EndFont() { return GetBuffer().EndFont(); }
1182
1183     /**
1184         Begins using this colour.
1185     */
1186     bool BeginTextColour(const wxColour& colour) { return GetBuffer().BeginTextColour(colour); }
1187
1188     /**
1189         Ends applying a text colour.
1190     */
1191     bool EndTextColour() { return GetBuffer().EndTextColour(); }
1192
1193     /**
1194         Begins using alignment.
1195         For alignment values, see wxTextAttr.
1196     */
1197     bool BeginAlignment(wxTextAttrAlignment alignment) { return GetBuffer().BeginAlignment(alignment); }
1198
1199     /**
1200         Ends alignment.
1201     */
1202     bool EndAlignment() { return GetBuffer().EndAlignment(); }
1203
1204     /**
1205         Begins applying a left indent and subindent in tenths of a millimetre.
1206         The subindent is an offset from the left edge of the paragraph, and is
1207         used for all but the first line in a paragraph. A positive value will
1208         cause the first line to appear to the left of the subsequent lines, and
1209         a negative value will cause the first line to be indented to the right
1210         of the subsequent lines.
1211
1212         wxRichTextBuffer uses indentation to render a bulleted item. The
1213         content of the paragraph, including the first line, starts at the
1214         @a leftIndent plus the @a leftSubIndent.
1215
1216         @param leftIndent
1217             The distance between the margin and the bullet.
1218         @param leftSubIndent
1219              The distance between the left edge of the bullet and the left edge
1220              of the actual paragraph.
1221     */
1222     bool BeginLeftIndent(int leftIndent, int leftSubIndent = 0) { return GetBuffer().BeginLeftIndent(leftIndent, leftSubIndent); }
1223
1224     /**
1225         Ends left indent.
1226     */
1227     bool EndLeftIndent() { return GetBuffer().EndLeftIndent(); }
1228
1229     /**
1230         Begins a right indent, specified in tenths of a millimetre.
1231     */
1232     bool BeginRightIndent(int rightIndent) { return GetBuffer().BeginRightIndent(rightIndent); }
1233
1234     /**
1235         Ends right indent.
1236     */
1237     bool EndRightIndent() { return GetBuffer().EndRightIndent(); }
1238
1239     /**
1240         Begins paragraph spacing; pass the before-paragraph and after-paragraph spacing
1241         in tenths of a millimetre.
1242     */
1243     bool BeginParagraphSpacing(int before, int after) { return GetBuffer().BeginParagraphSpacing(before, after); }
1244
1245     /**
1246         Ends paragraph spacing.
1247     */
1248     bool EndParagraphSpacing() { return GetBuffer().EndParagraphSpacing(); }
1249
1250     /**
1251         Begins appling line spacing. @e spacing is a multiple, where 10 means
1252         single-spacing, 15 means 1.5 spacing, and 20 means double spacing.
1253
1254         The ::wxTextAttrLineSpacing constants are defined for convenience.
1255     */
1256     bool BeginLineSpacing(int lineSpacing) { return GetBuffer().BeginLineSpacing(lineSpacing); }
1257
1258     /**
1259         Ends line spacing.
1260     */
1261     bool EndLineSpacing() { return GetBuffer().EndLineSpacing(); }
1262
1263     /**
1264         Begins a numbered bullet.
1265
1266         This call will be needed for each item in the list, and the
1267         application should take care of incrementing the numbering.
1268
1269         @a bulletNumber is a number, usually starting with 1.
1270         @a leftIndent and @a leftSubIndent are values in tenths of a millimetre.
1271         @a bulletStyle is a bitlist of the  ::wxTextAttrBulletStyle values.
1272
1273         wxRichTextBuffer uses indentation to render a bulleted item.
1274         The left indent is the distance between the margin and the bullet.
1275         The content of the paragraph, including the first line, starts
1276         at leftMargin + leftSubIndent.
1277         So the distance between the left edge of the bullet and the
1278         left of the actual paragraph is leftSubIndent.
1279     */
1280     bool BeginNumberedBullet(int bulletNumber, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_ARABIC|wxTEXT_ATTR_BULLET_STYLE_PERIOD)
1281     { return GetBuffer().BeginNumberedBullet(bulletNumber, leftIndent, leftSubIndent, bulletStyle); }
1282
1283     /**
1284         Ends application of a numbered bullet.
1285     */
1286     bool EndNumberedBullet() { return GetBuffer().EndNumberedBullet(); }
1287
1288     /**
1289         Begins applying a symbol bullet, using a character from the current font.
1290         See BeginNumberedBullet() for an explanation of how indentation is used
1291         to render the bulleted paragraph.
1292     */
1293     bool BeginSymbolBullet(const wxString& symbol, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_SYMBOL)
1294     { return GetBuffer().BeginSymbolBullet(symbol, leftIndent, leftSubIndent, bulletStyle); }
1295
1296     /**
1297         Ends applying a symbol bullet.
1298     */
1299     bool EndSymbolBullet() { return GetBuffer().EndSymbolBullet(); }
1300
1301     /**
1302         Begins applying a symbol bullet.
1303     */
1304     bool BeginStandardBullet(const wxString& bulletName, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_STANDARD)
1305     { return GetBuffer().BeginStandardBullet(bulletName, leftIndent, leftSubIndent, bulletStyle); }
1306
1307     /**
1308         Begins applying a standard bullet.
1309     */
1310     bool EndStandardBullet() { return GetBuffer().EndStandardBullet(); }
1311
1312     /**
1313         Begins using the named character style.
1314     */
1315     bool BeginCharacterStyle(const wxString& characterStyle) { return GetBuffer().BeginCharacterStyle(characterStyle); }
1316
1317     /**
1318         Ends application of a named character style.
1319     */
1320     bool EndCharacterStyle() { return GetBuffer().EndCharacterStyle(); }
1321
1322     /**
1323         Begins applying the named paragraph style.
1324     */
1325     bool BeginParagraphStyle(const wxString& paragraphStyle) { return GetBuffer().BeginParagraphStyle(paragraphStyle); }
1326
1327     /**
1328         Ends application of a named paragraph style.
1329     */
1330     bool EndParagraphStyle() { return GetBuffer().EndParagraphStyle(); }
1331
1332     /**
1333         Begins using a specified list style.
1334         Optionally, you can also pass a level and a number.
1335     */
1336     bool BeginListStyle(const wxString& listStyle, int level = 1, int number = 1) { return GetBuffer().BeginListStyle(listStyle, level, number); }
1337
1338     /**
1339         Ends using a specified list style.
1340     */
1341     bool EndListStyle() { return GetBuffer().EndListStyle(); }
1342
1343     /**
1344         Begins applying wxTEXT_ATTR_URL to the content.
1345
1346         Pass a URL and optionally, a character style to apply, since it is common
1347         to mark a URL with a familiar style such as blue text with underlining.
1348     */
1349     bool BeginURL(const wxString& url, const wxString& characterStyle = wxEmptyString) { return GetBuffer().BeginURL(url, characterStyle); }
1350
1351     /**
1352         Ends applying a URL.
1353     */
1354     bool EndURL() { return GetBuffer().EndURL(); }
1355
1356     /**
1357         Sets the default style to the style under the cursor.
1358     */
1359     bool SetDefaultStyleToCursorStyle();
1360
1361     /**
1362         Cancels any selection.
1363     */
1364     virtual void SelectNone();
1365
1366     /**
1367         Selects the word at the given character position.
1368     */
1369     virtual bool SelectWord(long position);
1370
1371     /**
1372         Returns the selection range in character positions. -1, -1 means no selection.
1373
1374         The range is in API convention, i.e. a single character selection is denoted
1375         by (n, n+1)
1376     */
1377     wxRichTextRange GetSelectionRange() const;
1378
1379     /**
1380         Sets the selection to the given range.
1381         The end point of range is specified as the last character position of the span
1382         of text, plus one.
1383
1384         So, for example, to set the selection for a character at position 5, use the
1385         range (5,6).
1386     */
1387     void SetSelectionRange(const wxRichTextRange& range);
1388
1389     /**
1390         Returns the selection range in character positions. -2, -2 means no selection
1391         -1, -1 means select everything.
1392         The range is in internal format, i.e. a single character selection is denoted
1393         by (n, n)
1394     */
1395     wxRichTextRange GetInternalSelectionRange() const { return m_selection.GetRange(); }
1396
1397     /**
1398         Sets the selection range in character positions. -2, -2 means no selection
1399         -1, -1 means select everything.
1400         The range is in internal format, i.e. a single character selection is denoted
1401         by (n, n)
1402     */
1403     void SetInternalSelectionRange(const wxRichTextRange& range) { m_selection.Set(range, GetFocusObject()); }
1404
1405     /**
1406         Adds a new paragraph of text to the end of the buffer.
1407     */
1408     virtual wxRichTextRange AddParagraph(const wxString& text);
1409
1410     /**
1411         Adds an image to the control's buffer.
1412     */
1413     virtual wxRichTextRange AddImage(const wxImage& image);
1414
1415     /**
1416         Lays out the buffer, which must be done before certain operations, such as
1417         setting the caret position.
1418         This function should not normally be required by the application.
1419     */
1420     virtual bool LayoutContent(bool onlyVisibleRect = false);
1421
1422     /**
1423         Move the caret to the given character position.
1424
1425         Please note that this does not update the current editing style
1426         from the new position; to do that, call wxRichTextCtrl::SetInsertionPoint instead.
1427     */
1428     virtual bool MoveCaret(long pos, bool showAtLineStart = false, wxRichTextParagraphLayoutBox* container = NULL);
1429
1430     /**
1431         Moves right.
1432     */
1433     virtual bool MoveRight(int noPositions = 1, int flags = 0);
1434
1435     /**
1436         Moves left.
1437     */
1438     virtual bool MoveLeft(int noPositions = 1, int flags = 0);
1439
1440     /**
1441         Moves to the start of the paragraph.
1442     */
1443     virtual bool MoveUp(int noLines = 1, int flags = 0);
1444
1445     /**
1446         Moves the caret down.
1447     */
1448     virtual bool MoveDown(int noLines = 1, int flags = 0);
1449
1450     /**
1451         Moves to the end of the line.
1452     */
1453     virtual bool MoveToLineEnd(int flags = 0);
1454
1455     /**
1456         Moves to the start of the line.
1457     */
1458     virtual bool MoveToLineStart(int flags = 0);
1459
1460     /**
1461         Moves to the end of the paragraph.
1462     */
1463     virtual bool MoveToParagraphEnd(int flags = 0);
1464
1465     /**
1466         Moves to the start of the paragraph.
1467     */
1468     virtual bool MoveToParagraphStart(int flags = 0);
1469
1470     /**
1471         Moves to the start of the buffer.
1472     */
1473     virtual bool MoveHome(int flags = 0);
1474
1475     /**
1476         Moves to the end of the buffer.
1477     */
1478     virtual bool MoveEnd(int flags = 0);
1479
1480     /**
1481         Moves one or more pages up.
1482     */
1483     virtual bool PageUp(int noPages = 1, int flags = 0);
1484
1485     /**
1486         Moves one or more pages down.
1487     */
1488     virtual bool PageDown(int noPages = 1, int flags = 0);
1489
1490     /**
1491         Moves a number of words to the left.
1492     */
1493     virtual bool WordLeft(int noPages = 1, int flags = 0);
1494
1495     /**
1496         Move a nuber of words to the right.
1497     */
1498     virtual bool WordRight(int noPages = 1, int flags = 0);
1499
1500     //@{
1501     /**
1502         Returns the buffer associated with the control.
1503     */
1504     wxRichTextBuffer& GetBuffer() { return m_buffer; }
1505     const wxRichTextBuffer& GetBuffer() const { return m_buffer; }
1506     //@}
1507
1508     /**
1509         Starts batching undo history for commands.
1510     */
1511     virtual bool BeginBatchUndo(const wxString& cmdName) { return m_buffer.BeginBatchUndo(cmdName); }
1512
1513     /**
1514         Ends batching undo command history.
1515     */
1516     virtual bool EndBatchUndo() { return m_buffer.EndBatchUndo(); }
1517
1518     /**
1519         Returns @true if undo commands are being batched.
1520     */
1521     virtual bool BatchingUndo() const { return m_buffer.BatchingUndo(); }
1522
1523     /**
1524         Starts suppressing undo history for commands.
1525     */
1526     virtual bool BeginSuppressUndo() { return m_buffer.BeginSuppressUndo(); }
1527
1528     /**
1529         Ends suppressing undo command history.
1530     */
1531     virtual bool EndSuppressUndo() { return m_buffer.EndSuppressUndo(); }
1532
1533     /**
1534         Returns @true if undo history suppression is on.
1535     */
1536     virtual bool SuppressingUndo() const { return m_buffer.SuppressingUndo(); }
1537
1538     /**
1539         Test if this whole range has character attributes of the specified kind.
1540         If any of the attributes are different within the range, the test fails.
1541
1542         You can use this to implement, for example, bold button updating.
1543         @a style must have flags indicating which attributes are of interest.
1544     */
1545     virtual bool HasCharacterAttributes(const wxRichTextRange& range, const wxRichTextAttr& style) const
1546     {
1547         return GetBuffer().HasCharacterAttributes(range.ToInternal(), style);
1548     }
1549
1550     /**
1551         Test if this whole range has paragraph attributes of the specified kind.
1552         If any of the attributes are different within the range, the test fails.
1553         You can use this to implement, for example, centering button updating.
1554         @a style must have flags indicating which attributes are of interest.
1555     */
1556     virtual bool HasParagraphAttributes(const wxRichTextRange& range, const wxRichTextAttr& style) const
1557     {
1558         return GetBuffer().HasParagraphAttributes(range.ToInternal(), style);
1559     }
1560
1561     /**
1562         Returns @true if all of the selection, or the content at the caret position, is bold.
1563     */
1564     virtual bool IsSelectionBold();
1565
1566     /**
1567         Returns @true if all of the selection, or the content at the caret position, is italic.
1568     */
1569     virtual bool IsSelectionItalics();
1570
1571     /**
1572         Returns @true if all of the selection, or the content at the caret position, is underlined.
1573     */
1574     virtual bool IsSelectionUnderlined();
1575
1576     /**
1577         Returns @true if all of the selection, or the content at the current caret position, has the supplied wxTextAttrEffects flag(s).
1578     */
1579     virtual bool DoesSelectionHaveTextEffectFlag(int flag);
1580
1581     /**
1582         Returns @true if all of the selection, or the content at the caret position, is aligned according to the specified flag.
1583     */
1584     virtual bool IsSelectionAligned(wxTextAttrAlignment alignment);
1585
1586     /**
1587         Apples bold to the selection or default style (undoable).
1588     */
1589     virtual bool ApplyBoldToSelection();
1590
1591     /**
1592         Applies italic to the selection or default style (undoable).
1593     */
1594     virtual bool ApplyItalicToSelection();
1595
1596     /**
1597         Applies underline to the selection or default style (undoable).
1598     */
1599     virtual bool ApplyUnderlineToSelection();
1600
1601     /**
1602         Applies one or more wxTextAttrEffects flags to the selection (undoable).
1603         If there is no selection, it is applied to the default style.
1604     */
1605     virtual bool ApplyTextEffectToSelection(int flags);
1606
1607     /**
1608         Applies the given alignment to the selection or the default style (undoable).
1609         For alignment values, see wxTextAttr.
1610     */
1611     virtual bool ApplyAlignmentToSelection(wxTextAttrAlignment alignment);
1612
1613     /**
1614         Applies the style sheet to the buffer, matching paragraph styles in the sheet
1615         against named styles in the buffer.
1616
1617         This might be useful if the styles have changed.
1618         If @a sheet is @NULL, the sheet set with SetStyleSheet() is used.
1619         Currently this applies paragraph styles only.
1620     */
1621     virtual bool ApplyStyle(wxRichTextStyleDefinition* def);
1622
1623     /**
1624         Sets the style sheet associated with the control.
1625         A style sheet allows named character and paragraph styles to be applied.
1626     */
1627     void SetStyleSheet(wxRichTextStyleSheet* styleSheet) { GetBuffer().SetStyleSheet(styleSheet); }
1628
1629     /**
1630         Returns the style sheet associated with the control, if any.
1631         A style sheet allows named character and paragraph styles to be applied.
1632     */
1633     wxRichTextStyleSheet* GetStyleSheet() const { return GetBuffer().GetStyleSheet(); }
1634
1635     /**
1636         Push the style sheet to top of stack.
1637     */
1638     bool PushStyleSheet(wxRichTextStyleSheet* styleSheet) { return GetBuffer().PushStyleSheet(styleSheet); }
1639
1640     /**
1641         Pops the style sheet from top of stack.
1642     */
1643     wxRichTextStyleSheet* PopStyleSheet() { return GetBuffer().PopStyleSheet(); }
1644
1645     /**
1646         Applies the style sheet to the buffer, for example if the styles have changed.
1647     */
1648     bool ApplyStyleSheet(wxRichTextStyleSheet* styleSheet = NULL);
1649
1650     /**
1651         Shows the given context menu, optionally adding appropriate property-editing commands for the current position in the object hierarchy.
1652     */
1653     virtual bool ShowContextMenu(wxMenu* menu, const wxPoint& pt, bool addPropertyCommands = true);
1654
1655     /**
1656         Prepares the context menu, optionally adding appropriate property-editing commands.
1657         Returns the number of property commands added.
1658     */
1659     virtual int PrepareContextMenu(wxMenu* menu, const wxPoint& pt, bool addPropertyCommands = true);
1660
1661     /**
1662         Returns @true if we can edit the object's properties via a GUI.
1663     */
1664     virtual bool CanEditProperties(wxRichTextObject* obj) const { return obj->CanEditProperties(); }
1665
1666     /**
1667         Edits the object's properties via a GUI.
1668     */
1669     virtual bool EditProperties(wxRichTextObject* obj, wxWindow* parent) { return obj->EditProperties(parent, & GetBuffer()); }
1670
1671     /**
1672         Gets the object's properties menu label.
1673     */
1674     virtual wxString GetPropertiesMenuLabel(wxRichTextObject* obj) { return obj->GetPropertiesMenuLabel(); }
1675
1676     /**
1677         Prepares the content just before insertion (or after buffer reset). Called by the same function in wxRichTextBuffer.
1678         Currently is only called if undo mode is on.
1679     */
1680     virtual void PrepareContent(wxRichTextParagraphLayoutBox& WXUNUSED(container)) {}
1681
1682     /**
1683         Can we delete this range?
1684         Sends an event to the control.
1685     */
1686     virtual bool CanDeleteRange(wxRichTextParagraphLayoutBox& container, const wxRichTextRange& range) const;
1687
1688     /**
1689         Can we insert content at this position?
1690         Sends an event to the control.
1691     */
1692     virtual bool CanInsertContent(wxRichTextParagraphLayoutBox& container, long pos) const;
1693
1694     /**
1695         Enable or disable the vertical scrollbar.
1696     */
1697     virtual void EnableVerticalScrollbar(bool enable);
1698
1699     /**
1700         Returns @true if the vertical scrollbar is enabled.
1701     */
1702     virtual bool GetVerticalScrollbarEnabled() const { return m_verticalScrollbarEnabled; }
1703
1704     /**
1705         Sets the scale factor for displaying fonts, for example for more comfortable
1706         editing.
1707     */
1708     void SetFontScale(double fontScale, bool refresh = false);
1709
1710     /**
1711         Returns the scale factor for displaying fonts, for example for more comfortable
1712         editing.
1713     */
1714     double GetFontScale() const { return GetBuffer().GetFontScale(); }
1715
1716     /**
1717         Sets the scale factor for displaying certain dimensions such as indentation and
1718         inter-paragraph spacing. This can be useful when editing in a small control
1719         where you still want legible text, but a minimum of wasted white space.
1720     */
1721     void SetDimensionScale(double dimScale, bool refresh = false);
1722
1723     /**
1724         Returns the scale factor for displaying certain dimensions such as indentation
1725         and inter-paragraph spacing.
1726     */
1727     double GetDimensionScale() const { return GetBuffer().GetDimensionScale(); }
1728
1729     /**
1730         Sets an overall scale factor for displaying and editing the content.
1731     */
1732     void SetScale(double scale, bool refresh = false);
1733
1734     /**
1735         Returns an overall scale factor for displaying and editing the content.
1736     */
1737     double GetScale() const { return m_scale; }
1738
1739     /**
1740         Returns an unscaled point.
1741     */
1742     wxPoint GetUnscaledPoint(const wxPoint& pt) const;
1743
1744     /**
1745         Returns a scaled point.
1746     */
1747     wxPoint GetScaledPoint(const wxPoint& pt) const;
1748
1749     /**
1750         Returns an unscaled size.
1751     */
1752     wxSize GetUnscaledSize(const wxSize& sz) const;
1753
1754     /**
1755         Returns a scaled size.
1756     */
1757     wxSize GetScaledSize(const wxSize& sz) const;
1758
1759     /**
1760         Returns an unscaled rectangle.
1761     */
1762     wxRect GetUnscaledRect(const wxRect& rect) const;
1763
1764     /**
1765         Returns a scaled rectangle.
1766     */
1767     wxRect GetScaledRect(const wxRect& rect) const;
1768
1769 // Command handlers
1770
1771     /**
1772         Sends the event to the control.
1773     */
1774     void Command(wxCommandEvent& event);
1775
1776     /**
1777         Loads the first dropped file.
1778     */
1779     void OnDropFiles(wxDropFilesEvent& event);
1780
1781     void OnCaptureLost(wxMouseCaptureLostEvent& event);
1782     void OnSysColourChanged(wxSysColourChangedEvent& event);
1783
1784     /**
1785         Standard handler for the wxID_CUT command.
1786     */
1787     void OnCut(wxCommandEvent& event);
1788
1789     /**
1790         Standard handler for the wxID_COPY command.
1791     */
1792     void OnCopy(wxCommandEvent& event);
1793
1794     /**
1795         Standard handler for the wxID_PASTE command.
1796     */
1797     void OnPaste(wxCommandEvent& event);
1798
1799     /**
1800         Standard handler for the wxID_UNDO command.
1801     */
1802     void OnUndo(wxCommandEvent& event);
1803
1804     /**
1805         Standard handler for the wxID_REDO command.
1806     */
1807     void OnRedo(wxCommandEvent& event);
1808
1809     /**
1810         Standard handler for the wxID_SELECTALL command.
1811     */
1812     void OnSelectAll(wxCommandEvent& event);
1813
1814     /**
1815         Standard handler for property commands.
1816     */
1817     void OnProperties(wxCommandEvent& event);
1818
1819     /**
1820         Standard handler for the wxID_CLEAR command.
1821     */
1822     void OnClear(wxCommandEvent& event);
1823
1824     /**
1825         Standard update handler for the wxID_CUT command.
1826     */
1827     void OnUpdateCut(wxUpdateUIEvent& event);
1828
1829     /**
1830         Standard update handler for the wxID_COPY command.
1831     */
1832     void OnUpdateCopy(wxUpdateUIEvent& event);
1833
1834     /**
1835         Standard update handler for the wxID_PASTE command.
1836     */
1837     void OnUpdatePaste(wxUpdateUIEvent& event);
1838
1839     /**
1840         Standard update handler for the wxID_UNDO command.
1841     */
1842     void OnUpdateUndo(wxUpdateUIEvent& event);
1843
1844     /**
1845         Standard update handler for the wxID_REDO command.
1846     */
1847     void OnUpdateRedo(wxUpdateUIEvent& event);
1848
1849     /**
1850         Standard update handler for the wxID_SELECTALL command.
1851     */
1852     void OnUpdateSelectAll(wxUpdateUIEvent& event);
1853
1854     /**
1855         Standard update handler for property commands.
1856     */
1857
1858     void OnUpdateProperties(wxUpdateUIEvent& event);
1859
1860     /**
1861         Standard update handler for the wxID_CLEAR command.
1862     */
1863     void OnUpdateClear(wxUpdateUIEvent& event);
1864
1865     /**
1866         Shows a standard context menu with undo, redo, cut, copy, paste, clear, and
1867         select all commands.
1868     */
1869     void OnContextMenu(wxContextMenuEvent& event);
1870
1871 // Event handlers
1872
1873     // Painting
1874     void OnPaint(wxPaintEvent& event);
1875     void OnEraseBackground(wxEraseEvent& event);
1876
1877     // Left-click
1878     void OnLeftClick(wxMouseEvent& event);
1879
1880     // Left-up
1881     void OnLeftUp(wxMouseEvent& event);
1882
1883     // Motion
1884     void OnMoveMouse(wxMouseEvent& event);
1885
1886     // Left-double-click
1887     void OnLeftDClick(wxMouseEvent& event);
1888
1889     // Middle-click
1890     void OnMiddleClick(wxMouseEvent& event);
1891
1892     // Right-click
1893     void OnRightClick(wxMouseEvent& event);
1894
1895     // Key press
1896     void OnChar(wxKeyEvent& event);
1897
1898     // Sizing
1899     void OnSize(wxSizeEvent& event);
1900
1901     // Setting/losing focus
1902     void OnSetFocus(wxFocusEvent& event);
1903     void OnKillFocus(wxFocusEvent& event);
1904
1905     // Idle-time processing
1906     void OnIdle(wxIdleEvent& event);
1907
1908     // Scrolling
1909     void OnScroll(wxScrollWinEvent& event);
1910
1911     /**
1912         Sets the font, and also the basic and default attributes
1913         (see wxRichTextCtrl::SetDefaultStyle).
1914     */
1915     virtual bool SetFont(const wxFont& font);
1916
1917     /**
1918         A helper function setting up scrollbars, for example after a resize.
1919     */
1920     virtual void SetupScrollbars(bool atTop = false);
1921
1922     /**
1923         Helper function implementing keyboard navigation.
1924     */
1925     virtual bool KeyboardNavigate(int keyCode, int flags);
1926
1927     /**
1928         Paints the background.
1929     */
1930     virtual void PaintBackground(wxDC& dc);
1931
1932     /**
1933         Other user defined painting after everything else (i.e. all text) is painted.
1934
1935         @since 2.9.1
1936     */
1937     virtual void PaintAboveContent(wxDC& WXUNUSED(dc)) {}
1938
1939 #if wxRICHTEXT_BUFFERED_PAINTING
1940     /**
1941         Recreates the buffer bitmap if necessary.
1942     */
1943     virtual bool RecreateBuffer(const wxSize& size = wxDefaultSize);
1944 #endif
1945
1946     // Write text
1947     virtual void DoWriteText(const wxString& value, int flags = 0);
1948
1949     // Should we inherit colours?
1950     virtual bool ShouldInheritColours() const { return false; }
1951
1952     /**
1953         Internal function to position the visible caret according to the current caret
1954         position.
1955     */
1956     virtual void PositionCaret(wxRichTextParagraphLayoutBox* container = NULL);
1957
1958     /**
1959         Helper function for extending the selection, returning @true if the selection
1960         was changed. Selections are in caret positions.
1961     */
1962     virtual bool ExtendSelection(long oldPosition, long newPosition, int flags);
1963
1964     /**
1965         Scrolls @a position into view. This function takes a caret position.
1966     */
1967     virtual bool ScrollIntoView(long position, int keyCode);
1968
1969     /**
1970         Refreshes the area affected by a selection change.
1971     */
1972     bool RefreshForSelectionChange(const wxRichTextSelection& oldSelection, const wxRichTextSelection& newSelection);
1973
1974     /**
1975         Sets the caret position.
1976
1977         The caret position is the character position just before the caret.
1978         A value of -1 means the caret is at the start of the buffer.
1979         Please note that this does not update the current editing style
1980         from the new position or cause the actual caret to be refreshed; to do that,
1981         call wxRichTextCtrl::SetInsertionPoint instead.
1982     */
1983     void SetCaretPosition(long position, bool showAtLineStart = false) ;
1984
1985     /**
1986         Returns the current caret position.
1987     */
1988     long GetCaretPosition() const { return m_caretPosition; }
1989
1990     /**
1991         The adjusted caret position is the character position adjusted to take
1992         into account whether we're at the start of a paragraph, in which case
1993         style information should be taken from the next position, not current one.
1994     */
1995     long GetAdjustedCaretPosition(long caretPos) const;
1996
1997     /**
1998         Move the caret one visual step forward: this may mean setting a flag
1999         and keeping the same position if we're going from the end of one line
2000         to the start of the next, which may be the exact same caret position.
2001     */
2002     void MoveCaretForward(long oldPosition) ;
2003
2004     /**
2005         Move the caret one visual step forward: this may mean setting a flag
2006         and keeping the same position if we're going from the end of one line
2007         to the start of the next, which may be the exact same caret position.
2008     */
2009     void MoveCaretBack(long oldPosition) ;
2010
2011     /**
2012         Returns the caret height and position for the given character position.
2013         If container is null, the current focus object will be used.
2014
2015         @beginWxPerlOnly
2016         In wxPerl this method is implemented as
2017         GetCaretPositionForIndex(@a position) returning a
2018         2-element list (ok, rect).
2019         @endWxPerlOnly
2020     */
2021     bool GetCaretPositionForIndex(long position, wxRect& rect, wxRichTextParagraphLayoutBox* container = NULL);
2022
2023     /**
2024         Internal helper function returning the line for the visible caret position.
2025         If the caret is shown at the very end of the line, it means the next character
2026         is actually on the following line.
2027         So this function gets the line we're expecting to find if this is the case.
2028     */
2029     wxRichTextLine* GetVisibleLineForCaretPosition(long caretPosition) const;
2030
2031     /**
2032         Gets the command processor associated with the control's buffer.
2033     */
2034     wxCommandProcessor* GetCommandProcessor() const { return GetBuffer().GetCommandProcessor(); }
2035
2036     /**
2037         Deletes content if there is a selection, e.g. when pressing a key.
2038         Returns the new caret position in @e newPos, or leaves it if there
2039         was no action. This is undoable.
2040
2041         @beginWxPerlOnly
2042         In wxPerl this method takes no arguments and returns a 2-element
2043         list (ok, newPos).
2044         @endWxPerlOnly
2045     */
2046     bool DeleteSelectedContent(long* newPos= NULL);
2047
2048     /**
2049         Transforms logical (unscrolled) position to physical window position.
2050     */
2051     wxPoint GetPhysicalPoint(const wxPoint& ptLogical) const;
2052
2053     /**
2054         Transforms physical window position to logical (unscrolled) position.
2055     */
2056     wxPoint GetLogicalPoint(const wxPoint& ptPhysical) const;
2057
2058     /**
2059         Helper function for finding the caret position for the next word.
2060         Direction is 1 (forward) or -1 (backwards).
2061     */
2062     virtual long FindNextWordPosition(int direction = 1) const;
2063
2064     /**
2065         Returns @true if the given position is visible on the screen.
2066     */
2067     bool IsPositionVisible(long pos) const;
2068
2069     /**
2070         Returns the first visible position in the current view.
2071     */
2072     long GetFirstVisiblePosition() const;
2073
2074     /**
2075         Returns the caret position since the default formatting was changed. As
2076         soon as this position changes, we no longer reflect the default style
2077         in the UI. A value of -2 means that we should only reflect the style of the
2078         content under the caret.
2079     */
2080     long GetCaretPositionForDefaultStyle() const { return m_caretPositionForDefaultStyle; }
2081
2082     /**
2083         Set the caret position for the default style that the user is selecting.
2084     */
2085     void SetCaretPositionForDefaultStyle(long pos) { m_caretPositionForDefaultStyle = pos; }
2086
2087     /**
2088         Returns @true if the user has recently set the default style without moving
2089         the caret, and therefore the UI needs to reflect the default style and not
2090         the style at the caret.
2091
2092         Below is an example of code that uses this function to determine whether the UI
2093         should show that the current style is bold.
2094
2095         @see SetAndShowDefaultStyle().
2096     */
2097     bool IsDefaultStyleShowing() const { return m_caretPositionForDefaultStyle != -2; }
2098
2099     /**
2100         Sets @a attr as the default style and tells the control that the UI should
2101         reflect this attribute until the user moves the caret.
2102
2103         @see IsDefaultStyleShowing().
2104     */
2105     void SetAndShowDefaultStyle(const wxRichTextAttr& attr)
2106     {
2107         SetDefaultStyle(attr);
2108         SetCaretPositionForDefaultStyle(GetCaretPosition());
2109     }
2110
2111     /**
2112         Returns the first visible point in the window.
2113     */
2114     wxPoint GetFirstVisiblePoint() const;
2115
2116 #ifdef DOXYGEN
2117     /**
2118         Returns the content of the entire control as a string.
2119     */
2120     virtual wxString GetValue() const;
2121
2122     /**
2123         Replaces existing content with the given text.
2124     */
2125     virtual void SetValue(const wxString& value);
2126
2127     /**
2128         Call this function to prevent refresh and allow fast updates, and then Thaw() to
2129         refresh the control.
2130     */
2131     void Freeze();
2132
2133     /**
2134         Call this function to end a Freeze and refresh the display.
2135     */
2136     void Thaw();
2137
2138     /**
2139         Returns @true if Freeze has been called without a Thaw.
2140     */
2141     bool IsFrozen() const;
2142
2143 #endif
2144
2145 // Implementation
2146
2147     /**
2148         Sets up the caret for the given position and container, after a mouse click.
2149     */
2150     bool SetCaretPositionAfterClick(wxRichTextParagraphLayoutBox* container, long position, int hitTestFlags, bool extendSelection = false);
2151
2152     /**
2153         Find the caret position for the combination of hit-test flags and character position.
2154         Returns the caret position and also an indication of where to place the caret (caretLineStart)
2155         since this is ambiguous (same position used for end of line and start of next).
2156     */
2157     long FindCaretPositionForCharacterPosition(long position, int hitTestFlags, wxRichTextParagraphLayoutBox* container,
2158                                                    bool& caretLineStart);
2159
2160     /**
2161         Processes mouse movement in order to change the cursor
2162     */
2163     virtual bool ProcessMouseMovement(wxRichTextParagraphLayoutBox* container, wxRichTextObject* obj, long position, const wxPoint& pos);
2164
2165     /**
2166         Font names take a long time to retrieve, so cache them (on demand).
2167     */
2168     static const wxArrayString& GetAvailableFontNames();
2169
2170     /**
2171         Clears the cache of available font names.
2172     */
2173     static void ClearAvailableFontNames();
2174
2175     WX_FORWARD_TO_SCROLL_HELPER()
2176
2177     // implement wxTextEntry methods
2178     virtual wxString DoGetValue() const;
2179
2180 protected:
2181     // implement the wxTextEntry pure virtual method
2182     virtual wxWindow *GetEditableWindow() { return this; }
2183
2184     // margins functions
2185     virtual bool DoSetMargins(const wxPoint& pt);
2186     virtual wxPoint DoGetMargins() const;
2187
2188      // FIXME: this does not work, it allows this code to compile but will fail
2189      //        during run-time
2190 #ifndef __WXUNIVERSAL__
2191 #ifdef __WXMSW__
2192     virtual WXHWND GetEditHWND() const { return GetHWND(); }
2193 #endif
2194 #ifdef __WXMOTIF__
2195     virtual WXWidget GetTextWidget() const { return NULL; }
2196 #endif
2197 #ifdef __WXGTK20__
2198     virtual GtkEditable *GetEditable() const { return NULL; }
2199     virtual GtkEntry *GetEntry() const { return NULL; }
2200 #endif
2201 #endif // !__WXUNIVERSAL__
2202
2203 // Overrides
2204 protected:
2205
2206     /**
2207         Currently this simply returns @c wxSize(10, 10).
2208     */
2209     virtual wxSize DoGetBestSize() const ;
2210
2211     virtual void DoSetValue(const wxString& value, int flags = 0);
2212
2213     virtual void DoThaw();
2214
2215
2216 // Data members
2217 protected:
2218 #if wxRICHTEXT_BUFFERED_PAINTING
2219     /// Buffer bitmap
2220     wxBitmap                m_bufferBitmap;
2221 #endif
2222
2223     /// Text buffer
2224     wxRichTextBuffer        m_buffer;
2225
2226     wxMenu*                 m_contextMenu;
2227
2228     /// Caret position (1 less than the character position, so -1 is the
2229     /// first caret position).
2230     long                    m_caretPosition;
2231
2232     /// Caret position when the default formatting has been changed. As
2233     /// soon as this position changes, we no longer reflect the default style
2234     /// in the UI.
2235     long                    m_caretPositionForDefaultStyle;
2236
2237     /// Selection range in character positions. -2, -2 means no selection.
2238     wxRichTextSelection     m_selection;
2239
2240     wxRichTextCtrlSelectionState m_selectionState;
2241
2242     /// Anchor so we know how to extend the selection
2243     /// It's a caret position since it's between two characters.
2244     long                    m_selectionAnchor;
2245
2246     /// Anchor object if selecting multiple container objects, such as grid cells.
2247     wxRichTextObject*       m_selectionAnchorObject;
2248
2249     /// Are we editable?
2250     bool                    m_editable;
2251
2252     /// Is the vertical scrollbar enabled?
2253     bool                    m_verticalScrollbarEnabled;
2254
2255     /// Are we showing the caret position at the start of a line
2256     /// instead of at the end of the previous one?
2257     bool                    m_caretAtLineStart;
2258
2259     /// Are we dragging (i.e. extending) a selection?
2260     bool                    m_dragging;
2261
2262 #if wxUSE_DRAG_AND_DROP
2263     /// Are we trying to start Drag'n'Drop?
2264     bool m_preDrag;
2265
2266     /// Initial position when starting Drag'n'Drop
2267     wxPoint m_dragStartPoint;
2268
2269 #if wxUSE_DATETIME
2270     /// Initial time when starting Drag'n'Drop
2271   wxDateTime m_dragStartTime;
2272 #endif // wxUSE_DATETIME
2273 #endif // wxUSE_DRAG_AND_DROP
2274
2275     /// Do we need full layout in idle?
2276     bool                    m_fullLayoutRequired;
2277     wxLongLong              m_fullLayoutTime;
2278     long                    m_fullLayoutSavedPosition;
2279
2280     /// Threshold for doing delayed layout
2281     long                    m_delayedLayoutThreshold;
2282
2283     /// Cursors
2284     wxCursor                m_textCursor;
2285     wxCursor                m_urlCursor;
2286
2287     static wxArrayString    sm_availableFontNames;
2288
2289     wxRichTextContextMenuPropertiesInfo m_contextMenuPropertiesInfo;
2290
2291     /// The object that currently has the editing focus
2292     wxRichTextParagraphLayoutBox* m_focusObject;
2293
2294     /// An overall scale factor
2295     double                  m_scale;
2296 };
2297
2298 #if wxUSE_DRAG_AND_DROP
2299 class WXDLLIMPEXP_RICHTEXT wxRichTextDropSource : public wxDropSource
2300 {
2301 public:
2302     wxRichTextDropSource(wxDataObject& data, wxRichTextCtrl* tc)
2303         : wxDropSource(data, tc), m_rtc(tc) {}
2304
2305 protected:
2306     bool GiveFeedback(wxDragResult effect);
2307
2308     wxRichTextCtrl* m_rtc;
2309 };
2310
2311 class WXDLLIMPEXP_RICHTEXT wxRichTextDropTarget : public wxDropTarget
2312 {
2313 public:
2314   wxRichTextDropTarget(wxRichTextCtrl* tc)
2315     : wxDropTarget(new wxRichTextBufferDataObject(new wxRichTextBuffer)), m_rtc(tc) {}
2316
2317     virtual wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def)
2318     {
2319         if ( !GetData() )
2320             return wxDragNone;
2321         m_rtc->OnDrop(x, y, def, m_dataObject);
2322         return def;
2323     }
2324
2325 protected:
2326     wxRichTextCtrl* m_rtc;
2327 };
2328 #endif // wxUSE_DRAG_AND_DROP
2329
2330 /**
2331     @class wxRichTextEvent
2332
2333     This is the event class for wxRichTextCtrl notifications.
2334
2335     @beginEventTable{wxRichTextEvent}
2336     @event{EVT_RICHTEXT_LEFT_CLICK(id, func)}
2337         Process a @c wxEVT_COMMAND_RICHTEXT_LEFT_CLICK event, generated when the user
2338         releases the left mouse button over an object.
2339     @event{EVT_RICHTEXT_RIGHT_CLICK(id, func)}
2340         Process a @c wxEVT_COMMAND_RICHTEXT_RIGHT_CLICK event, generated when the user
2341         releases the right mouse button over an object.
2342     @event{EVT_RICHTEXT_MIDDLE_CLICK(id, func)}
2343         Process a @c wxEVT_COMMAND_RICHTEXT_MIDDLE_CLICK event, generated when the user
2344         releases the middle mouse button over an object.
2345     @event{EVT_RICHTEXT_LEFT_DCLICK(id, func)}
2346         Process a @c wxEVT_COMMAND_RICHTEXT_LEFT_DCLICK event, generated when the user
2347         double-clicks an object.
2348     @event{EVT_RICHTEXT_RETURN(id, func)}
2349         Process a @c wxEVT_COMMAND_RICHTEXT_RETURN event, generated when the user
2350         presses the return key. Valid event functions: GetFlags, GetPosition.
2351     @event{EVT_RICHTEXT_CHARACTER(id, func)}
2352         Process a @c wxEVT_COMMAND_RICHTEXT_CHARACTER event, generated when the user
2353         presses a character key. Valid event functions: GetFlags, GetPosition, GetCharacter.
2354     @event{EVT_RICHTEXT_DELETE(id, func)}
2355         Process a @c wxEVT_COMMAND_RICHTEXT_DELETE event, generated when the user
2356         presses the backspace or delete key. Valid event functions: GetFlags, GetPosition.
2357     @event{EVT_RICHTEXT_RETURN(id, func)}
2358         Process a @c wxEVT_COMMAND_RICHTEXT_RETURN event, generated when the user
2359         presses the return key. Valid event functions: GetFlags, GetPosition.
2360     @event{EVT_RICHTEXT_STYLE_CHANGED(id, func)}
2361         Process a @c wxEVT_COMMAND_RICHTEXT_STYLE_CHANGED event, generated when
2362         styling has been applied to the control. Valid event functions: GetPosition, GetRange.
2363     @event{EVT_RICHTEXT_STYLESHEET_CHANGED(id, func)}
2364         Process a @c wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGING event, generated
2365         when the control's stylesheet has changed, for example the user added,
2366         edited or deleted a style. Valid event functions: GetRange, GetPosition.
2367     @event{EVT_RICHTEXT_STYLESHEET_REPLACING(id, func)}
2368         Process a @c wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACING event, generated
2369         when the control's stylesheet is about to be replaced, for example when
2370         a file is loaded into the control.
2371         Valid event functions: Veto, GetOldStyleSheet, GetNewStyleSheet.
2372     @event{EVT_RICHTEXT_STYLESHEET_REPLACED(id, func)}
2373         Process a @c wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACED event, generated
2374         when the control's stylesheet has been replaced, for example when a file
2375         is loaded into the control.
2376         Valid event functions: GetOldStyleSheet, GetNewStyleSheet.
2377     @event{EVT_RICHTEXT_PROPERTIES_CHANGED(id, func)}
2378         Process a @c wxEVT_COMMAND_RICHTEXT_PROPERTIES_CHANGED event, generated when
2379         properties have been applied to the control. Valid event functions: GetPosition, GetRange.
2380     @event{EVT_RICHTEXT_CONTENT_INSERTED(id, func)}
2381         Process a @c wxEVT_COMMAND_RICHTEXT_CONTENT_INSERTED event, generated when
2382         content has been inserted into the control.
2383         Valid event functions: GetPosition, GetRange.
2384     @event{EVT_RICHTEXT_CONTENT_DELETED(id, func)}
2385         Process a @c wxEVT_COMMAND_RICHTEXT_CONTENT_DELETED event, generated when
2386         content has been deleted from the control.
2387         Valid event functions: GetPosition, GetRange.
2388     @event{EVT_RICHTEXT_BUFFER_RESET(id, func)}
2389         Process a @c wxEVT_COMMAND_RICHTEXT_BUFFER_RESET event, generated when the
2390         buffer has been reset by deleting all content.
2391         You can use this to set a default style for the first new paragraph.
2392     @event{EVT_RICHTEXT_SELECTION_CHANGED(id, func)}
2393         Process a @c wxEVT_COMMAND_RICHTEXT_SELECTION_CHANGED event, generated when the
2394         selection range has changed.
2395     @event{EVT_RICHTEXT_FOCUS_OBJECT_CHANGED(id, func)}
2396         Process a @c wxEVT_COMMAND_RICHTEXT_FOCUS_OBJECT_CHANGED event, generated when the
2397         current focus object has changed.
2398     @endEventTable
2399
2400     @library{wxrichtext}
2401     @category{events,richtext}
2402 */
2403
2404 class WXDLLIMPEXP_RICHTEXT wxRichTextEvent : public wxNotifyEvent
2405 {
2406 public:
2407     /**
2408         Constructor.
2409
2410         @param commandType
2411             The type of the event.
2412         @param id
2413             Window identifier. The value @c wxID_ANY indicates a default value.
2414     */
2415     wxRichTextEvent(wxEventType commandType = wxEVT_NULL, int winid = 0)
2416         : wxNotifyEvent(commandType, winid),
2417         m_flags(0), m_position(-1), m_oldStyleSheet(NULL), m_newStyleSheet(NULL),
2418         m_char((wxChar) 0), m_container(NULL), m_oldContainer(NULL)
2419         { }
2420
2421     /**
2422         Copy constructor.
2423     */
2424     wxRichTextEvent(const wxRichTextEvent& event)
2425         : wxNotifyEvent(event),
2426         m_flags(event.m_flags), m_position(-1),
2427         m_oldStyleSheet(event.m_oldStyleSheet), m_newStyleSheet(event.m_newStyleSheet),
2428         m_char((wxChar) 0), m_container(event.m_container), m_oldContainer(event.m_oldContainer)
2429         { }
2430
2431     /**
2432         Returns the buffer position at which the event occured.
2433     */
2434     long GetPosition() const { return m_position; }
2435
2436     /**
2437         Sets the buffer position variable.
2438     */
2439     void SetPosition(long pos) { m_position = pos; }
2440
2441     /**
2442         Returns flags indicating modifier keys pressed.
2443
2444         Possible values are @c wxRICHTEXT_CTRL_DOWN, @c wxRICHTEXT_SHIFT_DOWN, and @c wxRICHTEXT_ALT_DOWN.
2445     */
2446     int GetFlags() const { return m_flags; }
2447
2448     /**
2449         Sets flags indicating modifier keys pressed.
2450
2451         Possible values are @c wxRICHTEXT_CTRL_DOWN, @c wxRICHTEXT_SHIFT_DOWN, and @c wxRICHTEXT_ALT_DOWN.
2452     */
2453     void SetFlags(int flags) { m_flags = flags; }
2454
2455     /**
2456         Returns the old style sheet.
2457
2458         Can be used in a @c wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGING or
2459         @c wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGED event handler.
2460     */
2461     wxRichTextStyleSheet* GetOldStyleSheet() const { return m_oldStyleSheet; }
2462
2463     /**
2464         Sets the old style sheet variable.
2465     */
2466     void SetOldStyleSheet(wxRichTextStyleSheet* sheet) { m_oldStyleSheet = sheet; }
2467
2468     /**
2469         Returns the new style sheet.
2470
2471         Can be used in a @c wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGING or
2472         @c wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGED event handler.
2473     */
2474     wxRichTextStyleSheet* GetNewStyleSheet() const { return m_newStyleSheet; }
2475
2476     /**
2477         Sets the new style sheet variable.
2478     */
2479     void SetNewStyleSheet(wxRichTextStyleSheet* sheet) { m_newStyleSheet = sheet; }
2480
2481     /**
2482         Gets the range for the current operation.
2483     */
2484     const wxRichTextRange& GetRange() const { return m_range; }
2485
2486     /**
2487         Sets the range variable.
2488     */
2489     void SetRange(const wxRichTextRange& range) { m_range = range; }
2490
2491     /**
2492         Returns the character pressed, within a @c wxEVT_COMMAND_RICHTEXT_CHARACTER event.
2493     */
2494     wxChar GetCharacter() const { return m_char; }
2495
2496     /**
2497         Sets the character variable.
2498     */
2499     void SetCharacter(wxChar ch) { m_char = ch; }
2500
2501     /**
2502         Returns the container for which the event is relevant.
2503     */
2504     wxRichTextParagraphLayoutBox* GetContainer() const { return m_container; }
2505
2506     /**
2507         Sets the container for which the event is relevant.
2508     */
2509     void SetContainer(wxRichTextParagraphLayoutBox* container) { m_container = container; }
2510
2511     /**
2512         Returns the old container, for a focus change event.
2513     */
2514     wxRichTextParagraphLayoutBox* GetOldContainer() const { return m_oldContainer; }
2515
2516     /**
2517         Sets the old container, for a focus change event.
2518     */
2519     void SetOldContainer(wxRichTextParagraphLayoutBox* container) { m_oldContainer = container; }
2520
2521     virtual wxEvent *Clone() const { return new wxRichTextEvent(*this); }
2522
2523 protected:
2524     int                             m_flags;
2525     long                            m_position;
2526     wxRichTextStyleSheet*           m_oldStyleSheet;
2527     wxRichTextStyleSheet*           m_newStyleSheet;
2528     wxRichTextRange                 m_range;
2529     wxChar                          m_char;
2530     wxRichTextParagraphLayoutBox*   m_container;
2531     wxRichTextParagraphLayoutBox*   m_oldContainer;
2532
2533 private:
2534     DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxRichTextEvent)
2535 };
2536
2537 /*!
2538  * wxRichTextCtrl events
2539  */
2540 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_LEFT_CLICK, wxRichTextEvent );
2541 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_RIGHT_CLICK, wxRichTextEvent );
2542 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_MIDDLE_CLICK, wxRichTextEvent );
2543 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_LEFT_DCLICK, wxRichTextEvent );
2544 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_RETURN, wxRichTextEvent );
2545 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_CHARACTER, wxRichTextEvent );
2546 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_DELETE, wxRichTextEvent );
2547
2548 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGING, wxRichTextEvent );
2549 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGED, wxRichTextEvent );
2550 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACING, wxRichTextEvent );
2551 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACED, wxRichTextEvent );
2552
2553 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_CONTENT_INSERTED, wxRichTextEvent );
2554 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_CONTENT_DELETED, wxRichTextEvent );
2555 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_STYLE_CHANGED, wxRichTextEvent );
2556 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_PROPERTIES_CHANGED, wxRichTextEvent );
2557 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_SELECTION_CHANGED, wxRichTextEvent );
2558 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_BUFFER_RESET, wxRichTextEvent );
2559 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_FOCUS_OBJECT_CHANGED, wxRichTextEvent );
2560
2561 typedef void (wxEvtHandler::*wxRichTextEventFunction)(wxRichTextEvent&);
2562
2563 #define wxRichTextEventHandler(func) \
2564     wxEVENT_HANDLER_CAST(wxRichTextEventFunction, func)
2565
2566 #define EVT_RICHTEXT_LEFT_CLICK(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_LEFT_CLICK, id, -1, wxRichTextEventHandler( fn ), NULL ),
2567 #define EVT_RICHTEXT_RIGHT_CLICK(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_RIGHT_CLICK, id, -1, wxRichTextEventHandler( fn ), NULL ),
2568 #define EVT_RICHTEXT_MIDDLE_CLICK(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_MIDDLE_CLICK, id, -1, wxRichTextEventHandler( fn ), NULL ),
2569 #define EVT_RICHTEXT_LEFT_DCLICK(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_LEFT_DCLICK, id, -1, wxRichTextEventHandler( fn ), NULL ),
2570 #define EVT_RICHTEXT_RETURN(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_RETURN, id, -1, wxRichTextEventHandler( fn ), NULL ),
2571 #define EVT_RICHTEXT_CHARACTER(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_CHARACTER, id, -1, wxRichTextEventHandler( fn ), NULL ),
2572 #define EVT_RICHTEXT_DELETE(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_DELETE, id, -1, wxRichTextEventHandler( fn ), NULL ),
2573
2574 #define EVT_RICHTEXT_STYLESHEET_CHANGING(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGING, id, -1, wxRichTextEventHandler( fn ), NULL ),
2575 #define EVT_RICHTEXT_STYLESHEET_CHANGED(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGED, id, -1, wxRichTextEventHandler( fn ), NULL ),
2576 #define EVT_RICHTEXT_STYLESHEET_REPLACING(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACING, id, -1, wxRichTextEventHandler( fn ), NULL ),
2577 #define EVT_RICHTEXT_STYLESHEET_REPLACED(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACED, id, -1, wxRichTextEventHandler( fn ), NULL ),
2578
2579 #define EVT_RICHTEXT_CONTENT_INSERTED(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_CONTENT_INSERTED, id, -1, wxRichTextEventHandler( fn ), NULL ),
2580 #define EVT_RICHTEXT_CONTENT_DELETED(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_CONTENT_DELETED, id, -1, wxRichTextEventHandler( fn ), NULL ),
2581 #define EVT_RICHTEXT_STYLE_CHANGED(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_STYLE_CHANGED, id, -1, wxRichTextEventHandler( fn ), NULL ),
2582 #define EVT_RICHTEXT_PROPERTIES_CHANGED(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_PROPERTIES_CHANGED, id, -1, wxRichTextEventHandler( fn ), NULL ),
2583 #define EVT_RICHTEXT_SELECTION_CHANGED(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_SELECTION_CHANGED, id, -1, wxRichTextEventHandler( fn ), NULL ),
2584 #define EVT_RICHTEXT_BUFFER_RESET(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_BUFFER_RESET, id, -1, wxRichTextEventHandler( fn ), NULL ),
2585 #define EVT_RICHTEXT_FOCUS_OBJECT_CHANGED(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_FOCUS_OBJECT_CHANGED, id, -1, wxRichTextEventHandler( fn ), NULL ),
2586
2587 #endif
2588     // wxUSE_RICHTEXT
2589
2590 #endif
2591     // _WX_RICHTEXTCTRL_H_