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