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