interface/wx/richtext/richtextctrl.h

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