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(wxRichTextCtrl* ctrl, 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 extending a selection.
 396     */
 397     bool GetDragging() const { return m_dragging; }
 398
 399     /**
 400         Sets a flag to remember if we are extending a selection.
 401     */
 402     void SetDragging(bool dragging) { m_dragging = dragging; }
 403
 404     /**
 405         Are we trying to start Drag'n'Drop?
 406     */
 407     bool GetPreDrag() const { return m_preDrag; }
 408
 409     /**
 410         Set if we're trying to start Drag'n'Drop
 411     */
 412     void SetPreDrag(bool pd) { m_preDrag = pd; }
 413
 414     /**
 415         Get the possible Drag'n'Drop start point
 416     */
 417     const wxPoint GetDragStartPoint() const { return m_dragStartPoint; }
 418
 419     /**
 420         Set the possible Drag'n'Drop start point
 421     */
 422     void SetDragStartPoint(wxPoint sp) { m_dragStartPoint = sp; }
 423
 424     /**
 425         Get the possible Drag'n'Drop start time
 426     */
 427     const wxDateTime GetDragStartTime() const { return m_dragStartTime; }
 428
 429     /**
 430         Set the possible Drag'n'Drop start time
 431     */
 432     void SetDragStartTime(wxDateTime st) { m_dragStartTime = st; }
 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         Setter for m_focusObject.
 496     */
 497     void StoreFocusObject(wxRichTextParagraphLayoutBox* obj);
 498
 499     /**
 500         Sets the wxRichTextObject object that currently has the editing focus.
 501         @param setCaretPosition
 502             Optionally set the caret position.
 503     */
 504     bool SetFocusObject(wxRichTextParagraphLayoutBox* obj, bool setCaretPosition = true);
 505
 506 // Operations
 507
 508     /**
 509         Invalidates the whole buffer to trigger painting later.
 510     */
 511     void Invalidate() { GetBuffer().Invalidate(wxRICHTEXT_ALL); }
 512
 513     /**
 514         Clears the buffer content, leaving a single empty paragraph. Cannot be undone.
 515     */
 516     virtual void Clear();
 517
 518     /**
 519         Replaces the content in the specified range with the string specified by
 520         @a value.
 521     */
 522     virtual void Replace(long from, long to, const wxString& value);
 523
 524     /**
 525         Removes the content in the specified range.
 526     */
 527     virtual void Remove(long from, long to);
 528
 529 #ifdef DOXYGEN
 530     /**
 531         Loads content into the control's buffer using the given type.
 532
 533         If the specified type is wxRICHTEXT_TYPE_ANY, the type is deduced from
 534         the filename extension.
 535
 536         This function looks for a suitable wxRichTextFileHandler object.
 537     */
 538     bool LoadFile(const wxString& file,
 539                   int type = wxRICHTEXT_TYPE_ANY);
 540 #endif
 541
 542     /**
 543         Helper function for LoadFile(). Loads content into the control's buffer using the given type.
 544
 545         If the specified type is wxRICHTEXT_TYPE_ANY, the type is deduced from
 546         the filename extension.
 547
 548         This function looks for a suitable wxRichTextFileHandler object.
 549     */
 550     virtual bool DoLoadFile(const wxString& file, int fileType);
 551
 552 #ifdef DOXYGEN
 553     /**
 554         Saves the buffer content using the given type.
 555
 556         If the specified type is wxRICHTEXT_TYPE_ANY, the type is deduced from
 557         the filename extension.
 558
 559         This function looks for a suitable wxRichTextFileHandler object.
 560     */
 561     bool SaveFile(const wxString& file = wxEmptyString,
 562                   int type = wxRICHTEXT_TYPE_ANY);
 563 #endif
 564
 565     /**
 566         Helper function for SaveFile(). Saves the buffer content using the given type.
 567
 568         If the specified type is wxRICHTEXT_TYPE_ANY, the type is deduced from
 569         the filename extension.
 570
 571         This function looks for a suitable wxRichTextFileHandler object.
 572     */
 573     virtual bool DoSaveFile(const wxString& file = wxEmptyString,
 574                             int fileType = wxRICHTEXT_TYPE_ANY);
 575
 576     /**
 577         Sets flags that change the behaviour of loading or saving.
 578
 579         See the documentation for each handler class to see what flags are
 580         relevant for each handler.
 581     */
 582     void SetHandlerFlags(int flags) { GetBuffer().SetHandlerFlags(flags); }
 583
 584     /**
 585         Returns flags that change the behaviour of loading or saving.
 586         See the documentation for each handler class to see what flags are
 587         relevant for each handler.
 588     */
 589     int GetHandlerFlags() const { return GetBuffer().GetHandlerFlags(); }
 590
 591     /**
 592         Marks the buffer as modified.
 593     */
 594     virtual void MarkDirty();
 595
 596     /**
 597         Sets the buffer's modified status to @false, and clears the buffer's command
 598         history.
 599     */
 600     virtual void DiscardEdits();
 601
 602     /**
 603         Sets the maximum number of characters that may be entered in a single line
 604         text control. For compatibility only; currently does nothing.
 605     */
 606     virtual void SetMaxLength(unsigned long WXUNUSED(len)) { }
 607
 608     /**
 609         Writes text at the current position.
 610     */
 611     virtual void WriteText(const wxString& text);
 612
 613     /**
 614         Sets the insertion point to the end of the buffer and writes the text.
 615     */
 616     virtual void AppendText(const wxString& text);
 617
 618     //@{
 619     /**
 620         Gets the attributes at the given position.
 621         This function gets the combined style - that is, the style you see on the
 622         screen as a result of combining base style, paragraph style and character
 623         style attributes.
 624
 625         To get the character or paragraph style alone, use GetUncombinedStyle().
 626
 627         @beginWxPerlOnly
 628         In wxPerl this method is implemented as GetStyle(@a position)
 629         returning a 2-element list (ok, attr).
 630         @endWxPerlOnly
 631     */
 632     virtual bool GetStyle(long position, wxTextAttr& style);
 633     virtual bool GetStyle(long position, wxRichTextAttr& style);
 634     virtual bool GetStyle(long position, wxRichTextAttr& style, wxRichTextParagraphLayoutBox* container);
 635     //@}
 636
 637     //@{
 638     /**
 639         Sets the attributes for the given range.
 640         The end point of range is specified as the last character position of the span
 641         of text, plus one.
 642
 643         So, for example, to set the style for a character at position 5, use the range
 644         (5,6).
 645     */
 646     virtual bool SetStyle(long start, long end, const wxTextAttr& style);
 647     virtual bool SetStyle(long start, long end, const wxRichTextAttr& style);
 648     virtual bool SetStyle(const wxRichTextRange& range, const wxTextAttr& style);
 649     virtual bool SetStyle(const wxRichTextRange& range, const wxRichTextAttr& style);
 650     //@}
 651
 652     /**
 653         Sets the attributes for a single object
 654     */
 655     virtual void SetStyle(wxRichTextObject *obj, const wxRichTextAttr& textAttr, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO);
 656
 657     //@{
 658     /**
 659         Gets the attributes common to the specified range.
 660         Attributes that differ in value within the range will not be included
 661         in @a style flags.
 662
 663         @beginWxPerlOnly
 664         In wxPerl this method is implemented as GetStyleForRange(@a position)
 665         returning a 2-element list (ok, attr).
 666         @endWxPerlOnly
 667     */
 668     virtual bool GetStyleForRange(const wxRichTextRange& range, wxTextAttr& style);
 669     virtual bool GetStyleForRange(const wxRichTextRange& range, wxRichTextAttr& style);
 670     virtual bool GetStyleForRange(const wxRichTextRange& range, wxRichTextAttr& style, wxRichTextParagraphLayoutBox* container);
 671     //@}
 672
 673     /**
 674         Sets the attributes for the given range, passing flags to determine how the
 675         attributes are set.
 676
 677         The end point of range is specified as the last character position of the span
 678         of text, plus one. So, for example, to set the style for a character at
 679         position 5, use the range (5,6).
 680
 681         @a flags may contain a bit list of the following values:
 682         - wxRICHTEXT_SETSTYLE_NONE: no style flag.
 683         - wxRICHTEXT_SETSTYLE_WITH_UNDO: specifies that this operation should be
 684           undoable.
 685         - wxRICHTEXT_SETSTYLE_OPTIMIZE: specifies that the style should not be applied
 686           if the combined style at this point is already the style in question.
 687         - wxRICHTEXT_SETSTYLE_PARAGRAPHS_ONLY: specifies that the style should only be
 688           applied to paragraphs, and not the content.
 689           This allows content styling to be preserved independently from that
 690           of e.g. a named paragraph style.
 691         - wxRICHTEXT_SETSTYLE_CHARACTERS_ONLY: specifies that the style should only be
 692           applied to characters, and not the paragraph.
 693           This allows content styling to be preserved independently from that
 694           of e.g. a named paragraph style.
 695         - wxRICHTEXT_SETSTYLE_RESET: resets (clears) the existing style before applying
 696           the new style.
 697         - wxRICHTEXT_SETSTYLE_REMOVE: removes the specified style. Only the style flags
 698           are used in this operation.
 699     */
 700     virtual bool SetStyleEx(const wxRichTextRange& range, const wxRichTextAttr& style, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO);
 701
 702     //@{
 703     /**
 704         Gets the attributes at the given position.
 705         This function gets the @e uncombined style - that is, the attributes associated
 706         with the paragraph or character content, and not necessarily the combined
 707         attributes you see on the screen.
 708         To get the combined attributes, use GetStyle().
 709
 710         If you specify (any) paragraph attribute in @e style's flags, this function
 711         will fetch the paragraph attributes.
 712         Otherwise, it will return the character attributes.
 713
 714         @beginWxPerlOnly
 715         In wxPerl this method is implemented as GetUncombinedStyle(@a position)
 716         returning a 2-element list (ok, attr).
 717         @endWxPerlOnly
 718     */
 719     virtual bool GetUncombinedStyle(long position, wxRichTextAttr& style);
 720     virtual bool GetUncombinedStyle(long position, wxRichTextAttr& style, wxRichTextParagraphLayoutBox* container);
 721     //@}
 722
 723     //@{
 724     /**
 725         Sets the current default style, which can be used to change how subsequently
 726         inserted text is displayed.
 727     */
 728     virtual bool SetDefaultStyle(const wxTextAttr& style);
 729     virtual bool SetDefaultStyle(const wxRichTextAttr& style);
 730     //@}
 731
 732     /**
 733         Returns the current default style, which can be used to change how subsequently
 734         inserted text is displayed.
 735     */
 736     virtual const wxRichTextAttr& GetDefaultStyleEx() const;
 737
 738     //virtual const wxTextAttr& GetDefaultStyle() const;
 739
 740     //@{
 741     /**
 742         Sets the list attributes for the given range, passing flags to determine how
 743         the attributes are set.
 744
 745         Either the style definition or the name of the style definition (in the current
 746         sheet) can be passed.
 747         @a flags is a bit list of the following:
 748         - wxRICHTEXT_SETSTYLE_WITH_UNDO: specifies that this command will be undoable.
 749         - wxRICHTEXT_SETSTYLE_RENUMBER: specifies that numbering should start from
 750           @a startFrom, otherwise existing attributes are used.
 751         - wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL: specifies that @a listLevel should be used
 752           as the level for all paragraphs, otherwise the current indentation will be used.
 753
 754         @see NumberList(), PromoteList(), ClearListStyle().
 755     */
 756     virtual bool SetListStyle(const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
 757     virtual bool SetListStyle(const wxRichTextRange& range, const wxString& defName, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
 758     //@}
 759
 760     /**
 761         Clears the list style from the given range, clearing list-related attributes
 762         and applying any named paragraph style associated with each paragraph.
 763
 764         @a flags is a bit list of the following:
 765         - wxRICHTEXT_SETSTYLE_WITH_UNDO: specifies that this command will be undoable.
 766
 767         @see SetListStyle(), PromoteList(), NumberList().
 768     */
 769     virtual bool ClearListStyle(const wxRichTextRange& range, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO);
 770
 771     //@{
 772     /**
 773         Numbers the paragraphs in the given range.
 774         Pass flags to determine how the attributes are set.
 775
 776         Either the style definition or the name of the style definition (in the current
 777         sheet) can be passed.
 778
 779         @a flags is a bit list of the following:
 780         - wxRICHTEXT_SETSTYLE_WITH_UNDO: specifies that this command will be undoable.
 781         - wxRICHTEXT_SETSTYLE_RENUMBER: specifies that numbering should start from
 782           @a startFrom, otherwise existing attributes are used.
 783         - wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL: specifies that @a listLevel should be used
 784           as the level for all paragraphs, otherwise the current indentation will be used.
 785
 786         @see SetListStyle(), PromoteList(), ClearListStyle().
 787     */
 788     virtual bool NumberList(const wxRichTextRange& range, wxRichTextListStyleDefinition* def = NULL, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
 789     virtual bool NumberList(const wxRichTextRange& range, const wxString& defName, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
 790     //@}
 791
 792     //@{
 793     /**
 794         Promotes or demotes the paragraphs in the given range.
 795         A positive @a promoteBy produces a smaller indent, and a negative number
 796         produces a larger indent. Pass flags to determine how the attributes are set.
 797         Either the style definition or the name of the style definition (in the current
 798         sheet) can be passed.
 799
 800         @a flags is a bit list of the following:
 801         - wxRICHTEXT_SETSTYLE_WITH_UNDO: specifies that this command will be undoable.
 802         - wxRICHTEXT_SETSTYLE_RENUMBER: specifies that numbering should start from
 803           @a startFrom, otherwise existing attributes are used.
 804         - wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL: specifies that @a listLevel should be used
 805         as the level for all paragraphs, otherwise the current indentation will be used.
 806
 807         @see SetListStyle(), @see SetListStyle(), ClearListStyle().
 808     */
 809     virtual bool PromoteList(int promoteBy, const wxRichTextRange& range, wxRichTextListStyleDefinition* def = NULL, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int specifiedLevel = -1);
 810     virtual bool PromoteList(int promoteBy, const wxRichTextRange& range, const wxString& defName, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int specifiedLevel = -1);
 811     //@}
 812
 813     /**
 814         Sets the properties for the given range, passing flags to determine how the
 815         attributes are set. You can merge properties or replace them.
 816
 817         The end point of range is specified as the last character position of the span
 818         of text, plus one. So, for example, to set the properties for a character at
 819         position 5, use the range (5,6).
 820
 821         @a flags may contain a bit list of the following values:
 822         - wxRICHTEXT_SETSPROPERTIES_NONE: no flag.
 823         - wxRICHTEXT_SETPROPERTIES_WITH_UNDO: specifies that this operation should be
 824           undoable.
 825         - wxRICHTEXT_SETPROPERTIES_PARAGRAPHS_ONLY: specifies that the properties should only be
 826           applied to paragraphs, and not the content.
 827         - wxRICHTEXT_SETPROPERTIES_CHARACTERS_ONLY: specifies that the properties should only be
 828           applied to characters, and not the paragraph.
 829         - wxRICHTEXT_SETPROPERTIES_RESET: resets (clears) the existing properties before applying
 830           the new properties.
 831         - wxRICHTEXT_SETPROPERTIES_REMOVE: removes the specified properties.
 832     */
 833     virtual bool SetProperties(const wxRichTextRange& range, const wxRichTextProperties& properties, int flags = wxRICHTEXT_SETPROPERTIES_WITH_UNDO);
 834
 835     /**
 836         Deletes the content within the given range.
 837     */
 838     virtual bool Delete(const wxRichTextRange& range);
 839
 840     /**
 841         Translates from column and line number to position.
 842     */
 843     virtual long XYToPosition(long x, long y) const;
 844
 845     /**
 846         Converts a text position to zero-based column and line numbers.
 847     */
 848     virtual bool PositionToXY(long pos, long *x, long *y) const;
 849
 850     /**
 851         Scrolls the buffer so that the given position is in view.
 852     */
 853     virtual void ShowPosition(long pos);
 854
 855     //@{
 856     /**
 857         Finds the character at the given position in pixels.
 858         @a pt is in device coords (not adjusted for the client area origin nor for
 859         scrolling).
 860     */
 861     virtual wxTextCtrlHitTestResult HitTest(const wxPoint& pt, long *pos) const;
 862     virtual wxTextCtrlHitTestResult HitTest(const wxPoint& pt,
 863                                             wxTextCoord *col,
 864                                             wxTextCoord *row) const;
 865
 866     /**
 867         Finds the container at the given point, which is assumed to be in client coordinates.
 868     */
 869     wxRichTextParagraphLayoutBox* FindContainerAtPoint(const wxPoint pt, long& position, int& hit, wxRichTextObject* hitObj, int flags = 0);
 870     //@}
 871
 872 // Clipboard operations
 873
 874     /**
 875         Copies the selected content (if any) to the clipboard.
 876     */
 877     virtual void Copy();
 878
 879     /**
 880         Copies the selected content (if any) to the clipboard and deletes the selection.
 881         This is undoable.
 882     */
 883     virtual void Cut();
 884
 885     /**
 886         Pastes content from the clipboard to the buffer.
 887     */
 888     virtual void Paste();
 889
 890     /**
 891         Deletes the content in the selection, if any. This is undoable.
 892     */
 893     virtual void DeleteSelection();
 894
 895     /**
 896         Returns @true if selected content can be copied to the clipboard.
 897     */
 898     virtual bool CanCopy() const;
 899
 900     /**
 901         Returns @true if selected content can be copied to the clipboard and deleted.
 902     */
 903     virtual bool CanCut() const;
 904
 905     /**
 906         Returns @true if the clipboard content can be pasted to the buffer.
 907     */
 908     virtual bool CanPaste() const;
 909
 910     /**
 911         Returns @true if selected content can be deleted.
 912     */
 913     virtual bool CanDeleteSelection() const;
 914
 915     /**
 916         Undoes the command at the top of the command history, if there is one.
 917     */
 918     virtual void Undo();
 919
 920     /**
 921         Redoes the current command.
 922     */
 923     virtual void Redo();
 924
 925     /**
 926         Returns @true if there is a command in the command history that can be undone.
 927     */
 928     virtual bool CanUndo() const;
 929
 930     /**
 931         Returns @true if there is a command in the command history that can be redone.
 932     */
 933     virtual bool CanRedo() const;
 934
 935     /**
 936         Sets the insertion point and causes the current editing style to be taken from
 937         the new position (unlike wxRichTextCtrl::SetCaretPosition).
 938     */
 939     virtual void SetInsertionPoint(long pos);
 940
 941     /**
 942         Sets the insertion point to the end of the text control.
 943     */
 944     virtual void SetInsertionPointEnd();
 945
 946     /**
 947         Returns the current insertion point.
 948     */
 949     virtual long GetInsertionPoint() const;
 950
 951     /**
 952         Returns the last position in the buffer.
 953     */
 954     virtual wxTextPos GetLastPosition() const;
 955
 956     //@{
 957     /**
 958         Sets the selection to the given range.
 959         The end point of range is specified as the last character position of the span
 960         of text, plus one.
 961
 962         So, for example, to set the selection for a character at position 5, use the
 963         range (5,6).
 964     */
 965     virtual void SetSelection(long from, long to);
 966     void SetSelection(const wxRichTextSelection& sel) { m_selection = sel; }
 967     //@}
 968
 969
 970     /**
 971         Selects all the text in the buffer.
 972     */
 973     virtual void SelectAll();
 974
 975     /**
 976         Makes the control editable, or not.
 977     */
 978     virtual void SetEditable(bool editable);
 979
 980     /**
 981         Returns @true if there is a selection and the object containing the selection
 982         was the same as the current focus object.
 983     */
 984     virtual bool HasSelection() const;
 985
 986     /**
 987         Returns @true if there was a selection, whether or not the current focus object
 988         is the same as the selection's container object.
 989     */
 990     virtual bool HasUnfocusedSelection() const;
 991
 992     //@{
 993     /**
 994         Write a bitmap or image at the current insertion point.
 995         Supply an optional type to use for internal and file storage of the raw data.
 996     */
 997     virtual bool WriteImage(const wxImage& image, wxBitmapType bitmapType = wxBITMAP_TYPE_PNG,
 998                             const wxRichTextAttr& textAttr = wxRichTextAttr());
 999
1000     virtual bool WriteImage(const wxBitmap& bitmap, wxBitmapType bitmapType = wxBITMAP_TYPE_PNG,
1001                             const wxRichTextAttr& textAttr = wxRichTextAttr());
1002     //@}
1003
1004     /**
1005         Loads an image from a file and writes it at the current insertion point.
1006     */
1007     virtual bool WriteImage(const wxString& filename, wxBitmapType bitmapType,
1008                             const wxRichTextAttr& textAttr = wxRichTextAttr());
1009
1010     /**
1011         Writes an image block at the current insertion point.
1012     */
1013     virtual bool WriteImage(const wxRichTextImageBlock& imageBlock,
1014                             const wxRichTextAttr& textAttr = wxRichTextAttr());
1015
1016     /**
1017         Write a text box at the current insertion point, returning the text box.
1018         You can then call SetFocusObject() to set the focus to the new object.
1019     */
1020     virtual wxRichTextBox* WriteTextBox(const wxRichTextAttr& textAttr = wxRichTextAttr());
1021
1022     /**
1023         Writes a field at the current insertion point.
1024
1025         @param fieldType
1026             The field type, matching an existing field type definition.
1027         @param properties
1028             Extra data for the field.
1029         @param textAttr
1030             Optional attributes.
1031
1032         @see wxRichTextField, wxRichTextFieldType, wxRichTextFieldTypeStandard
1033     */
1034     virtual wxRichTextField* WriteField(const wxString& fieldType, const wxRichTextProperties& properties,
1035                             const wxRichTextAttr& textAttr = wxRichTextAttr());
1036
1037     /**
1038         Write a table at the current insertion point, returning the table.
1039         You can then call SetFocusObject() to set the focus to the new object.
1040     */
1041     virtual wxRichTextTable* WriteTable(int rows, int cols, const wxRichTextAttr& tableAttr = wxRichTextAttr(), const wxRichTextAttr& cellAttr = wxRichTextAttr());
1042
1043     /**
1044         Inserts a new paragraph at the current insertion point. @see LineBreak().
1045     */
1046     virtual bool Newline();
1047
1048     /**
1049         Inserts a line break at the current insertion point.
1050
1051         A line break forces wrapping within a paragraph, and can be introduced by
1052         using this function, by appending the wxChar value @b  wxRichTextLineBreakChar
1053         to text content, or by typing Shift-Return.
1054     */
1055     virtual bool LineBreak();
1056
1057     /**
1058         Sets the basic (overall) style.
1059
1060         This is the style of the whole buffer before further styles are applied,
1061         unlike the default style, which only affects the style currently being
1062         applied (for example, setting the default style to bold will cause
1063         subsequently inserted text to be bold).
1064     */
1065     virtual void SetBasicStyle(const wxRichTextAttr& style) { GetBuffer().SetBasicStyle(style); }
1066
1067     /**
1068         Gets the basic (overall) style.
1069
1070         This is the style of the whole buffer before further styles are applied,
1071         unlike the default style, which only affects the style currently being
1072         applied (for example, setting the default style to bold will cause
1073         subsequently inserted text to be bold).
1074     */
1075     virtual const wxRichTextAttr& GetBasicStyle() const { return GetBuffer().GetBasicStyle(); }
1076
1077     /**
1078         Begins applying a style.
1079     */
1080     virtual bool BeginStyle(const wxRichTextAttr& style) { return GetBuffer().BeginStyle(style); }
1081
1082     /**
1083         Ends the current style.
1084     */
1085     virtual bool EndStyle() { return GetBuffer().EndStyle(); }
1086
1087     /**
1088         Ends application of all styles in the current style stack.
1089     */
1090     virtual bool EndAllStyles() { return GetBuffer().EndAllStyles(); }
1091
1092     /**
1093         Begins using bold.
1094     */
1095     bool BeginBold() { return GetBuffer().BeginBold(); }
1096
1097     /**
1098         Ends using bold.
1099     */
1100     bool EndBold()  { return GetBuffer().EndBold(); }
1101
1102     /**
1103         Begins using italic.
1104     */
1105     bool BeginItalic() { return GetBuffer().BeginItalic(); }
1106
1107     /**
1108         Ends using italic.
1109     */
1110     bool EndItalic() { return GetBuffer().EndItalic(); }
1111
1112     /**
1113         Begins using underlining.
1114     */
1115     bool BeginUnderline() { return GetBuffer().BeginUnderline(); }
1116
1117     /**
1118         End applying underlining.
1119     */
1120     bool EndUnderline() { return GetBuffer().EndUnderline(); }
1121
1122     /**
1123         Begins using the given point size.
1124     */
1125     bool BeginFontSize(int pointSize) { return GetBuffer().BeginFontSize(pointSize); }
1126
1127     /**
1128         Ends using a point size.
1129     */
1130     bool EndFontSize() { return GetBuffer().EndFontSize(); }
1131
1132     /**
1133         Begins using this font.
1134     */
1135     bool BeginFont(const wxFont& font) { return GetBuffer().BeginFont(font); }
1136
1137     /**
1138         Ends using a font.
1139     */
1140     bool EndFont() { return GetBuffer().EndFont(); }
1141
1142     /**
1143         Begins using this colour.
1144     */
1145     bool BeginTextColour(const wxColour& colour) { return GetBuffer().BeginTextColour(colour); }
1146
1147     /**
1148         Ends applying a text colour.
1149     */
1150     bool EndTextColour() { return GetBuffer().EndTextColour(); }
1151
1152     /**
1153         Begins using alignment.
1154         For alignment values, see wxTextAttr.
1155     */
1156     bool BeginAlignment(wxTextAttrAlignment alignment) { return GetBuffer().BeginAlignment(alignment); }
1157
1158     /**
1159         Ends alignment.
1160     */
1161     bool EndAlignment() { return GetBuffer().EndAlignment(); }
1162
1163     /**
1164         Begins applying a left indent and subindent in tenths of a millimetre.
1165         The subindent is an offset from the left edge of the paragraph, and is
1166         used for all but the first line in a paragraph. A positive value will
1167         cause the first line to appear to the left of the subsequent lines, and
1168         a negative value will cause the first line to be indented to the right
1169         of the subsequent lines.
1170
1171         wxRichTextBuffer uses indentation to render a bulleted item. The
1172         content of the paragraph, including the first line, starts at the
1173         @a leftIndent plus the @a leftSubIndent.
1174
1175         @param leftIndent
1176             The distance between the margin and the bullet.
1177         @param leftSubIndent
1178              The distance between the left edge of the bullet and the left edge
1179              of the actual paragraph.
1180     */
1181     bool BeginLeftIndent(int leftIndent, int leftSubIndent = 0) { return GetBuffer().BeginLeftIndent(leftIndent, leftSubIndent); }
1182
1183     /**
1184         Ends left indent.
1185     */
1186     bool EndLeftIndent() { return GetBuffer().EndLeftIndent(); }
1187
1188     /**
1189         Begins a right indent, specified in tenths of a millimetre.
1190     */
1191     bool BeginRightIndent(int rightIndent) { return GetBuffer().BeginRightIndent(rightIndent); }
1192
1193     /**
1194         Ends right indent.
1195     */
1196     bool EndRightIndent() { return GetBuffer().EndRightIndent(); }
1197
1198     /**
1199         Begins paragraph spacing; pass the before-paragraph and after-paragraph spacing
1200         in tenths of a millimetre.
1201     */
1202     bool BeginParagraphSpacing(int before, int after) { return GetBuffer().BeginParagraphSpacing(before, after); }
1203
1204     /**
1205         Ends paragraph spacing.
1206     */
1207     bool EndParagraphSpacing() { return GetBuffer().EndParagraphSpacing(); }
1208
1209     /**
1210         Begins appling line spacing. @e spacing is a multiple, where 10 means
1211         single-spacing, 15 means 1.5 spacing, and 20 means double spacing.
1212
1213         The ::wxTextAttrLineSpacing constants are defined for convenience.
1214     */
1215     bool BeginLineSpacing(int lineSpacing) { return GetBuffer().BeginLineSpacing(lineSpacing); }
1216
1217     /**
1218         Ends line spacing.
1219     */
1220     bool EndLineSpacing() { return GetBuffer().EndLineSpacing(); }
1221
1222     /**
1223         Begins a numbered bullet.
1224
1225         This call will be needed for each item in the list, and the
1226         application should take care of incrementing the numbering.
1227
1228         @a bulletNumber is a number, usually starting with 1.
1229         @a leftIndent and @a leftSubIndent are values in tenths of a millimetre.
1230         @a bulletStyle is a bitlist of the  ::wxTextAttrBulletStyle values.
1231
1232         wxRichTextBuffer uses indentation to render a bulleted item.
1233         The left indent is the distance between the margin and the bullet.
1234         The content of the paragraph, including the first line, starts
1235         at leftMargin + leftSubIndent.
1236         So the distance between the left edge of the bullet and the
1237         left of the actual paragraph is leftSubIndent.
1238     */
1239     bool BeginNumberedBullet(int bulletNumber, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_ARABIC|wxTEXT_ATTR_BULLET_STYLE_PERIOD)
1240     { return GetBuffer().BeginNumberedBullet(bulletNumber, leftIndent, leftSubIndent, bulletStyle); }
1241
1242     /**
1243         Ends application of a numbered bullet.
1244     */
1245     bool EndNumberedBullet() { return GetBuffer().EndNumberedBullet(); }
1246
1247     /**
1248         Begins applying a symbol bullet, using a character from the current font.
1249         See BeginNumberedBullet() for an explanation of how indentation is used
1250         to render the bulleted paragraph.
1251     */
1252     bool BeginSymbolBullet(const wxString& symbol, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_SYMBOL)
1253     { return GetBuffer().BeginSymbolBullet(symbol, leftIndent, leftSubIndent, bulletStyle); }
1254
1255     /**
1256         Ends applying a symbol bullet.
1257     */
1258     bool EndSymbolBullet() { return GetBuffer().EndSymbolBullet(); }
1259
1260     /**
1261         Begins applying a symbol bullet.
1262     */
1263     bool BeginStandardBullet(const wxString& bulletName, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_STANDARD)
1264     { return GetBuffer().BeginStandardBullet(bulletName, leftIndent, leftSubIndent, bulletStyle); }
1265
1266     /**
1267         Begins applying a standard bullet.
1268     */
1269     bool EndStandardBullet() { return GetBuffer().EndStandardBullet(); }
1270
1271     /**
1272         Begins using the named character style.
1273     */
1274     bool BeginCharacterStyle(const wxString& characterStyle) { return GetBuffer().BeginCharacterStyle(characterStyle); }
1275
1276     /**
1277         Ends application of a named character style.
1278     */
1279     bool EndCharacterStyle() { return GetBuffer().EndCharacterStyle(); }
1280
1281     /**
1282         Begins applying the named paragraph style.
1283     */
1284     bool BeginParagraphStyle(const wxString& paragraphStyle) { return GetBuffer().BeginParagraphStyle(paragraphStyle); }
1285
1286     /**
1287         Ends application of a named paragraph style.
1288     */
1289     bool EndParagraphStyle() { return GetBuffer().EndParagraphStyle(); }
1290
1291     /**
1292         Begins using a specified list style.
1293         Optionally, you can also pass a level and a number.
1294     */
1295     bool BeginListStyle(const wxString& listStyle, int level = 1, int number = 1) { return GetBuffer().BeginListStyle(listStyle, level, number); }
1296
1297     /**
1298         Ends using a specified list style.
1299     */
1300     bool EndListStyle() { return GetBuffer().EndListStyle(); }
1301
1302     /**
1303         Begins applying wxTEXT_ATTR_URL to the content.
1304
1305         Pass a URL and optionally, a character style to apply, since it is common
1306         to mark a URL with a familiar style such as blue text with underlining.
1307     */
1308     bool BeginURL(const wxString& url, const wxString& characterStyle = wxEmptyString) { return GetBuffer().BeginURL(url, characterStyle); }
1309
1310     /**
1311         Ends applying a URL.
1312     */
1313     bool EndURL() { return GetBuffer().EndURL(); }
1314
1315     /**
1316         Sets the default style to the style under the cursor.
1317     */
1318     bool SetDefaultStyleToCursorStyle();
1319
1320     /**
1321         Cancels any selection.
1322     */
1323     virtual void SelectNone();
1324
1325     /**
1326         Selects the word at the given character position.
1327     */
1328     virtual bool SelectWord(long position);
1329
1330     /**
1331         Returns the selection range in character positions. -1, -1 means no selection.
1332
1333         The range is in API convention, i.e. a single character selection is denoted
1334         by (n, n+1)
1335     */
1336     wxRichTextRange GetSelectionRange() const;
1337
1338     /**
1339         Sets the selection to the given range.
1340         The end point of range is specified as the last character position of the span
1341         of text, plus one.
1342
1343         So, for example, to set the selection for a character at position 5, use the
1344         range (5,6).
1345     */
1346     void SetSelectionRange(const wxRichTextRange& range);
1347
1348     /**
1349         Returns the selection range in character positions. -2, -2 means no selection
1350         -1, -1 means select everything.
1351         The range is in internal format, i.e. a single character selection is denoted
1352         by (n, n)
1353     */
1354     wxRichTextRange GetInternalSelectionRange() const { return m_selection.GetRange(); }
1355
1356     /**
1357         Sets the selection range in character positions. -2, -2 means no selection
1358         -1, -1 means select everything.
1359         The range is in internal format, i.e. a single character selection is denoted
1360         by (n, n)
1361     */
1362     void SetInternalSelectionRange(const wxRichTextRange& range) { m_selection.Set(range, GetFocusObject()); }
1363
1364     /**
1365         Adds a new paragraph of text to the end of the buffer.
1366     */
1367     virtual wxRichTextRange AddParagraph(const wxString& text);
1368
1369     /**
1370         Adds an image to the control's buffer.
1371     */
1372     virtual wxRichTextRange AddImage(const wxImage& image);
1373
1374     /**
1375         Lays out the buffer, which must be done before certain operations, such as
1376         setting the caret position.
1377         This function should not normally be required by the application.
1378     */
1379     virtual bool LayoutContent(bool onlyVisibleRect = false);
1380
1381     /**
1382         Move the caret to the given character position.
1383
1384         Please note that this does not update the current editing style
1385         from the new position; to do that, call wxRichTextCtrl::SetInsertionPoint instead.
1386     */
1387     virtual bool MoveCaret(long pos, bool showAtLineStart = false, wxRichTextParagraphLayoutBox* container = NULL);
1388
1389     /**
1390         Moves right.
1391     */
1392     virtual bool MoveRight(int noPositions = 1, int flags = 0);
1393
1394     /**
1395         Moves left.
1396     */
1397     virtual bool MoveLeft(int noPositions = 1, int flags = 0);
1398
1399     /**
1400         Moves to the start of the paragraph.
1401     */
1402     virtual bool MoveUp(int noLines = 1, int flags = 0);
1403
1404     /**
1405         Moves the caret down.
1406     */
1407     virtual bool MoveDown(int noLines = 1, int flags = 0);
1408
1409     /**
1410         Moves to the end of the line.
1411     */
1412     virtual bool MoveToLineEnd(int flags = 0);
1413
1414     /**
1415         Moves to the start of the line.
1416     */
1417     virtual bool MoveToLineStart(int flags = 0);
1418
1419     /**
1420         Moves to the end of the paragraph.
1421     */
1422     virtual bool MoveToParagraphEnd(int flags = 0);
1423
1424     /**
1425         Moves to the start of the paragraph.
1426     */
1427     virtual bool MoveToParagraphStart(int flags = 0);
1428
1429     /**
1430         Moves to the start of the buffer.
1431     */
1432     virtual bool MoveHome(int flags = 0);
1433
1434     /**
1435         Moves to the end of the buffer.
1436     */
1437     virtual bool MoveEnd(int flags = 0);
1438
1439     /**
1440         Moves one or more pages up.
1441     */
1442     virtual bool PageUp(int noPages = 1, int flags = 0);
1443
1444     /**
1445         Moves one or more pages down.
1446     */
1447     virtual bool PageDown(int noPages = 1, int flags = 0);
1448
1449     /**
1450         Moves a number of words to the left.
1451     */
1452     virtual bool WordLeft(int noPages = 1, int flags = 0);
1453
1454     /**
1455         Move a nuber of words to the right.
1456     */
1457     virtual bool WordRight(int noPages = 1, int flags = 0);
1458
1459     //@{
1460     /**
1461         Returns the buffer associated with the control.
1462     */
1463     wxRichTextBuffer& GetBuffer() { return m_buffer; }
1464     const wxRichTextBuffer& GetBuffer() const { return m_buffer; }
1465     //@}
1466
1467     /**
1468         Starts batching undo history for commands.
1469     */
1470     virtual bool BeginBatchUndo(const wxString& cmdName) { return m_buffer.BeginBatchUndo(cmdName); }
1471
1472     /**
1473         Ends batching undo command history.
1474     */
1475     virtual bool EndBatchUndo() { return m_buffer.EndBatchUndo(); }
1476
1477     /**
1478         Returns @true if undo commands are being batched.
1479     */
1480     virtual bool BatchingUndo() const { return m_buffer.BatchingUndo(); }
1481
1482     /**
1483         Starts suppressing undo history for commands.
1484     */
1485     virtual bool BeginSuppressUndo() { return m_buffer.BeginSuppressUndo(); }
1486
1487     /**
1488         Ends suppressing undo command history.
1489     */
1490     virtual bool EndSuppressUndo() { return m_buffer.EndSuppressUndo(); }
1491
1492     /**
1493         Returns @true if undo history suppression is on.
1494     */
1495     virtual bool SuppressingUndo() const { return m_buffer.SuppressingUndo(); }
1496
1497     /**
1498         Test if this whole range has character attributes of the specified kind.
1499         If any of the attributes are different within the range, the test fails.
1500
1501         You can use this to implement, for example, bold button updating.
1502         @a style must have flags indicating which attributes are of interest.
1503     */
1504     virtual bool HasCharacterAttributes(const wxRichTextRange& range, const wxRichTextAttr& style) const
1505     {
1506         return GetBuffer().HasCharacterAttributes(range.ToInternal(), style);
1507     }
1508
1509     /**
1510         Test if this whole range has paragraph attributes of the specified kind.
1511         If any of the attributes are different within the range, the test fails.
1512         You can use this to implement, for example, centering button updating.
1513         @a style must have flags indicating which attributes are of interest.
1514     */
1515     virtual bool HasParagraphAttributes(const wxRichTextRange& range, const wxRichTextAttr& style) const
1516     {
1517         return GetBuffer().HasParagraphAttributes(range.ToInternal(), style);
1518     }
1519
1520     /**
1521         Returns @true if all of the selection, or the content at the caret position, is bold.
1522     */
1523     virtual bool IsSelectionBold();
1524
1525     /**
1526         Returns @true if all of the selection, or the content at the caret position, is italic.
1527     */
1528     virtual bool IsSelectionItalics();
1529
1530     /**
1531         Returns @true if all of the selection, or the content at the caret position, is underlined.
1532     */
1533     virtual bool IsSelectionUnderlined();
1534
1535     /**
1536         Returns @true if all of the selection, or the content at the current caret position, has the supplied wxTextAttrEffects flag(s).
1537     */
1538     virtual bool DoesSelectionHaveTextEffectFlag(int flag);
1539
1540     /**
1541         Returns @true if all of the selection is aligned according to the specified flag.
1542     */
1543     virtual bool IsSelectionAligned(wxTextAttrAlignment alignment);
1544
1545     /**
1546         Apples bold to the selection or the default style (undoable).
1547     */
1548     virtual bool ApplyBoldToSelection();
1549
1550     /**
1551         Applies italic to the selection or the default style (undoable).
1552     */
1553     virtual bool ApplyItalicToSelection();
1554
1555     /**
1556         Applies underline to the selection or the default style (undoable).
1557     */
1558     virtual bool ApplyUnderlineToSelection();
1559
1560     /**
1561         Applies one or more wxTextAttrEffects flags to the selection (undoable).
1562         If there is no selection, it is applied to the default style.
1563     */
1564     virtual bool ApplyTextEffectToSelection(int flags);
1565
1566     /**
1567         Applies the given alignment to the selection or the default style (undoable).
1568         For alignment values, see wxTextAttr.
1569     */
1570     virtual bool ApplyAlignmentToSelection(wxTextAttrAlignment alignment);
1571
1572     /**
1573         Applies the style sheet to the buffer, matching paragraph styles in the sheet
1574         against named styles in the buffer.
1575
1576         This might be useful if the styles have changed.
1577         If @a sheet is @NULL, the sheet set with SetStyleSheet() is used.
1578         Currently this applies paragraph styles only.
1579     */
1580     virtual bool ApplyStyle(wxRichTextStyleDefinition* def);
1581
1582     /**
1583         Sets the style sheet associated with the control.
1584         A style sheet allows named character and paragraph styles to be applied.
1585     */
1586     void SetStyleSheet(wxRichTextStyleSheet* styleSheet) { GetBuffer().SetStyleSheet(styleSheet); }
1587
1588     /**
1589         Returns the style sheet associated with the control, if any.
1590         A style sheet allows named character and paragraph styles to be applied.
1591     */
1592     wxRichTextStyleSheet* GetStyleSheet() const { return GetBuffer().GetStyleSheet(); }
1593
1594     /**
1595         Push the style sheet to top of stack.
1596     */
1597     bool PushStyleSheet(wxRichTextStyleSheet* styleSheet) { return GetBuffer().PushStyleSheet(styleSheet); }
1598
1599     /**
1600         Pops the style sheet from top of stack.
1601     */
1602     wxRichTextStyleSheet* PopStyleSheet() { return GetBuffer().PopStyleSheet(); }
1603
1604     /**
1605         Applies the style sheet to the buffer, for example if the styles have changed.
1606     */
1607     bool ApplyStyleSheet(wxRichTextStyleSheet* styleSheet = NULL);
1608
1609     /**
1610         Shows the given context menu, optionally adding appropriate property-editing commands for the current position in the object hierarchy.
1611     */
1612     virtual bool ShowContextMenu(wxMenu* menu, const wxPoint& pt, bool addPropertyCommands);
1613
1614     /**
1615         Prepares the context menu, optionally adding appropriate property-editing commands.
1616         Returns the number of property commands added.
1617     */
1618     virtual int PrepareContextMenu(wxMenu* menu, const wxPoint& pt, bool addPropertyCommands);
1619
1620     /**
1621         Returns @true if we can edit the object's properties via a GUI.
1622     */
1623     virtual bool CanEditProperties(wxRichTextObject* obj) const;
1624
1625     /**
1626         Edits the object's properties via a GUI.
1627     */
1628     virtual bool EditProperties(wxRichTextObject* obj, wxWindow* parent);
1629
1630     /**
1631         Gets the object's properties menu label.
1632     */
1633     virtual wxString GetPropertiesMenuLabel(wxRichTextObject* obj);
1634
1635     /**
1636         Prepares the content just before insertion (or after buffer reset). Called by the same function in wxRichTextBuffer.
1637         Currently is only called if undo mode is on.
1638     */
1639     virtual void PrepareContent(wxRichTextParagraphLayoutBox& WXUNUSED(container)) {}
1640
1641     /**
1642         Can we delete this range?
1643         Sends an event to the control.
1644     */
1645     virtual bool CanDeleteRange(wxRichTextParagraphLayoutBox& container, const wxRichTextRange& range) const;
1646
1647     /**
1648         Can we insert content at this position?
1649         Sends an event to the control.
1650     */
1651     virtual bool CanInsertContent(wxRichTextParagraphLayoutBox& container, long pos) const;
1652
1653     /**
1654         Enable or disable the vertical scrollbar.
1655     */
1656     virtual void EnableVerticalScrollbar(bool enable);
1657
1658     /**
1659         Returns @true if the vertical scrollbar is enabled.
1660     */
1661     virtual bool GetVerticalScrollbarEnabled() const;
1662
1663 // Command handlers
1664
1665     /**
1666         Sends the event to the control.
1667     */
1668     void Command(wxCommandEvent& event);
1669
1670     /**
1671         Loads the first dropped file.
1672     */
1673     void OnDropFiles(wxDropFilesEvent& event);
1674
1675     void OnCaptureLost(wxMouseCaptureLostEvent& event);
1676     void OnSysColourChanged(wxSysColourChangedEvent& event);
1677
1678     /**
1679         Standard handler for the wxID_CUT command.
1680     */
1681     void OnCut(wxCommandEvent& event);
1682
1683     /**
1684         Standard handler for the wxID_COPY command.
1685     */
1686     void OnCopy(wxCommandEvent& event);
1687
1688     /**
1689         Standard handler for the wxID_PASTE command.
1690     */
1691     void OnPaste(wxCommandEvent& event);
1692
1693     /**
1694         Standard handler for the wxID_UNDO command.
1695     */
1696     void OnUndo(wxCommandEvent& event);
1697
1698     /**
1699         Standard handler for the wxID_REDO command.
1700     */
1701     void OnRedo(wxCommandEvent& event);
1702
1703     /**
1704         Standard handler for the wxID_SELECTALL command.
1705     */
1706     void OnSelectAll(wxCommandEvent& event);
1707
1708     /**
1709         Standard handler for property commands.
1710     */
1711     void OnProperties(wxCommandEvent& event);
1712
1713     /**
1714         Standard handler for the wxID_CLEAR command.
1715     */
1716     void OnClear(wxCommandEvent& event);
1717
1718     /**
1719         Standard update handler for the wxID_CUT command.
1720     */
1721     void OnUpdateCut(wxUpdateUIEvent& event);
1722
1723     /**
1724         Standard update handler for the wxID_COPY command.
1725     */
1726     void OnUpdateCopy(wxUpdateUIEvent& event);
1727
1728     /**
1729         Standard update handler for the wxID_PASTE command.
1730     */
1731     void OnUpdatePaste(wxUpdateUIEvent& event);
1732
1733     /**
1734         Standard update handler for the wxID_UNDO command.
1735     */
1736     void OnUpdateUndo(wxUpdateUIEvent& event);
1737
1738     /**
1739         Standard update handler for the wxID_REDO command.
1740     */
1741     void OnUpdateRedo(wxUpdateUIEvent& event);
1742
1743     /**
1744         Standard update handler for the wxID_SELECTALL command.
1745     */
1746     void OnUpdateSelectAll(wxUpdateUIEvent& event);
1747
1748     /**
1749         Standard update handler for property commands.
1750     */
1751
1752     void OnUpdateProperties(wxUpdateUIEvent& event);
1753
1754     /**
1755         Standard update handler for the wxID_CLEAR command.
1756     */
1757     void OnUpdateClear(wxUpdateUIEvent& event);
1758
1759     /**
1760         Shows a standard context menu with undo, redo, cut, copy, paste, clear, and
1761         select all commands.
1762     */
1763     void OnContextMenu(wxContextMenuEvent& event);
1764
1765 // Event handlers
1766
1767     // Painting
1768     void OnPaint(wxPaintEvent& event);
1769     void OnEraseBackground(wxEraseEvent& event);
1770
1771     // Left-click
1772     void OnLeftClick(wxMouseEvent& event);
1773
1774     // Left-up
1775     void OnLeftUp(wxMouseEvent& event);
1776
1777     // Motion
1778     void OnMoveMouse(wxMouseEvent& event);
1779
1780     // Left-double-click
1781     void OnLeftDClick(wxMouseEvent& event);
1782
1783     // Middle-click
1784     void OnMiddleClick(wxMouseEvent& event);
1785
1786     // Right-click
1787     void OnRightClick(wxMouseEvent& event);
1788
1789     // Key press
1790     void OnChar(wxKeyEvent& event);
1791
1792     // Sizing
1793     void OnSize(wxSizeEvent& event);
1794
1795     // Setting/losing focus
1796     void OnSetFocus(wxFocusEvent& event);
1797     void OnKillFocus(wxFocusEvent& event);
1798
1799     // Idle-time processing
1800     void OnIdle(wxIdleEvent& event);
1801
1802     // Scrolling
1803     void OnScroll(wxScrollWinEvent& event);
1804
1805     /**
1806         Sets the font, and also the basic and default attributes
1807         (see wxRichTextCtrl::SetDefaultStyle).
1808     */
1809     virtual bool SetFont(const wxFont& font);
1810
1811     /**
1812         A helper function setting up scrollbars, for example after a resize.
1813     */
1814     virtual void SetupScrollbars(bool atTop = false);
1815
1816     /**
1817         Helper function implementing keyboard navigation.
1818     */
1819     virtual bool KeyboardNavigate(int keyCode, int flags);
1820
1821     /**
1822         Paints the background.
1823     */
1824     virtual void PaintBackground(wxDC& dc);
1825
1826     /**
1827         Other user defined painting after everything else (i.e. all text) is painted.
1828
1829         @since 2.9.1
1830     */
1831     virtual void PaintAboveContent(wxDC& WXUNUSED(dc)) {}
1832
1833 #if wxRICHTEXT_BUFFERED_PAINTING
1834     /**
1835         Recreates the buffer bitmap if necessary.
1836     */
1837     virtual bool RecreateBuffer(const wxSize& size = wxDefaultSize);
1838 #endif
1839
1840     // Write text
1841     virtual void DoWriteText(const wxString& value, int flags = 0);
1842
1843     // Should we inherit colours?
1844     virtual bool ShouldInheritColours() const { return false; }
1845
1846     /**
1847         Internal function to position the visible caret according to the current caret
1848         position.
1849     */
1850     virtual void PositionCaret(wxRichTextParagraphLayoutBox* container = NULL);
1851
1852     /**
1853         Helper function for extending the selection, returning @true if the selection
1854         was changed. Selections are in caret positions.
1855     */
1856     virtual bool ExtendSelection(long oldPosition, long newPosition, int flags);
1857
1858     /**
1859         Scrolls @a position into view. This function takes a caret position.
1860     */
1861     virtual bool ScrollIntoView(long position, int keyCode);
1862
1863     /**
1864         Refreshes the area affected by a selection change.
1865     */
1866     bool RefreshForSelectionChange(const wxRichTextSelection& oldSelection, const wxRichTextSelection& newSelection);
1867
1868     /**
1869         Sets the caret position.
1870
1871         The caret position is the character position just before the caret.
1872         A value of -1 means the caret is at the start of the buffer.
1873         Please note that this does not update the current editing style
1874         from the new position or cause the actual caret to be refreshed; to do that,
1875         call wxRichTextCtrl::SetInsertionPoint instead.
1876     */
1877     void SetCaretPosition(long position, bool showAtLineStart = false) ;
1878
1879     /**
1880         Returns the current caret position.
1881     */
1882     long GetCaretPosition() const { return m_caretPosition; }
1883
1884     /**
1885         The adjusted caret position is the character position adjusted to take
1886         into account whether we're at the start of a paragraph, in which case
1887         style information should be taken from the next position, not current one.
1888     */
1889     long GetAdjustedCaretPosition(long caretPos) const;
1890
1891     /**
1892         Move the caret one visual step forward: this may mean setting a flag
1893         and keeping the same position if we're going from the end of one line
1894         to the start of the next, which may be the exact same caret position.
1895     */
1896     void MoveCaretForward(long oldPosition) ;
1897
1898     /**
1899         Move the caret one visual step forward: this may mean setting a flag
1900         and keeping the same position if we're going from the end of one line
1901         to the start of the next, which may be the exact same caret position.
1902     */
1903     void MoveCaretBack(long oldPosition) ;
1904
1905     /**
1906         Returns the caret height and position for the given character position.
1907         If container is null, the current focus object will be used.
1908
1909         @beginWxPerlOnly
1910         In wxPerl this method is implemented as
1911         GetCaretPositionForIndex(@a position) returning a
1912         2-element list (ok, rect).
1913         @endWxPerlOnly
1914     */
1915     bool GetCaretPositionForIndex(long position, wxRect& rect, wxRichTextParagraphLayoutBox* container = NULL);
1916
1917     /**
1918         Internal helper function returning the line for the visible caret position.
1919         If the caret is shown at the very end of the line, it means the next character
1920         is actually on the following line.
1921         So this function gets the line we're expecting to find if this is the case.
1922     */
1923     wxRichTextLine* GetVisibleLineForCaretPosition(long caretPosition) const;
1924
1925     /**
1926         Gets the command processor associated with the control's buffer.
1927     */
1928     wxCommandProcessor* GetCommandProcessor() const { return GetBuffer().GetCommandProcessor(); }
1929
1930     /**
1931         Deletes content if there is a selection, e.g. when pressing a key.
1932         Returns the new caret position in @e newPos, or leaves it if there
1933         was no action. This is undoable.
1934
1935         @beginWxPerlOnly
1936         In wxPerl this method takes no arguments and returns a 2-element
1937         list (ok, newPos).
1938         @endWxPerlOnly
1939     */
1940     bool DeleteSelectedContent(long* newPos= NULL);
1941
1942     /**
1943         Transforms logical (unscrolled) position to physical window position.
1944     */
1945     wxPoint GetPhysicalPoint(const wxPoint& ptLogical) const;
1946
1947     /**
1948         Transforms physical window position to logical (unscrolled) position.
1949     */
1950     wxPoint GetLogicalPoint(const wxPoint& ptPhysical) const;
1951
1952     /**
1953         Helper function for finding the caret position for the next word.
1954         Direction is 1 (forward) or -1 (backwards).
1955     */
1956     virtual long FindNextWordPosition(int direction = 1) const;
1957
1958     /**
1959         Returns @true if the given position is visible on the screen.
1960     */
1961     bool IsPositionVisible(long pos) const;
1962
1963     /**
1964         Returns the first visible position in the current view.
1965     */
1966     long GetFirstVisiblePosition() const;
1967
1968     /**
1969         Returns the caret position since the default formatting was changed. As
1970         soon as this position changes, we no longer reflect the default style
1971         in the UI. A value of -2 means that we should only reflect the style of the
1972         content under the caret.
1973     */
1974     long GetCaretPositionForDefaultStyle() const { return m_caretPositionForDefaultStyle; }
1975
1976     /**
1977         Set the caret position for the default style that the user is selecting.
1978     */
1979     void SetCaretPositionForDefaultStyle(long pos) { m_caretPositionForDefaultStyle = pos; }
1980
1981     /**
1982         Returns @true if the user has recently set the default style without moving
1983         the caret, and therefore the UI needs to reflect the default style and not
1984         the style at the caret.
1985
1986         Below is an example of code that uses this function to determine whether the UI
1987         should show that the current style is bold.
1988
1989         @see SetAndShowDefaultStyle().
1990     */
1991     bool IsDefaultStyleShowing() const { return m_caretPositionForDefaultStyle != -2; }
1992
1993     /**
1994         Sets @a attr as the default style and tells the control that the UI should
1995         reflect this attribute until the user moves the caret.
1996
1997         @see IsDefaultStyleShowing().
1998     */
1999     void SetAndShowDefaultStyle(const wxRichTextAttr& attr)
2000     {
2001         SetDefaultStyle(attr);
2002         SetCaretPositionForDefaultStyle(GetCaretPosition());
2003     }
2004
2005     /**
2006         Returns the first visible point in the window.
2007     */
2008     wxPoint GetFirstVisiblePoint() const;
2009
2010 #ifdef DOXYGEN
2011     /**
2012         Returns the content of the entire control as a string.
2013     */
2014     virtual wxString GetValue() const;
2015
2016     /**
2017         Replaces existing content with the given text.
2018     */
2019     virtual void SetValue(const wxString& value);
2020
2021     /**
2022         Call this function to prevent refresh and allow fast updates, and then Thaw() to
2023         refresh the control.
2024     */
2025     void Freeze();
2026
2027     /**
2028         Call this function to end a Freeze and refresh the display.
2029     */
2030     void Thaw();
2031
2032     /**
2033         Returns @true if Freeze has been called without a Thaw.
2034     */
2035     bool IsFrozen() const;
2036
2037 #endif
2038
2039 // Implementation
2040
2041     /**
2042         Sets up the caret for the given position and container, after a mouse click.
2043     */
2044     bool SetCaretPositionAfterClick(wxRichTextParagraphLayoutBox* container, long position, int hitTestFlags, bool extendSelection = false);
2045
2046     /**
2047         Find the caret position for the combination of hit-test flags and character position.
2048         Returns the caret position and also an indication of where to place the caret (caretLineStart)
2049         since this is ambiguous (same position used for end of line and start of next).
2050     */
2051     long FindCaretPositionForCharacterPosition(long position, int hitTestFlags, wxRichTextParagraphLayoutBox* container,
2052                                                    bool& caretLineStart);
2053
2054     /**
2055         Processes mouse movement in order to change the cursor
2056     */
2057     virtual bool ProcessMouseMovement(wxRichTextParagraphLayoutBox* container, wxRichTextObject* obj, long position, const wxPoint& pos);
2058
2059     /**
2060         Font names take a long time to retrieve, so cache them (on demand).
2061     */
2062     static const wxArrayString& GetAvailableFontNames();
2063
2064     /**
2065         Clears the cache of available font names.
2066     */
2067     static void ClearAvailableFontNames();
2068
2069     WX_FORWARD_TO_SCROLL_HELPER()
2070
2071     // implement wxTextEntry methods
2072     virtual wxString DoGetValue() const;
2073
2074 protected:
2075     // implement the wxTextEntry pure virtual method
2076     virtual wxWindow *GetEditableWindow() { return this; }
2077
2078     // margins functions
2079     virtual bool DoSetMargins(const wxPoint& pt);
2080     virtual wxPoint DoGetMargins() const;
2081
2082      // FIXME: this does not work, it allows this code to compile but will fail
2083      //        during run-time
2084 #ifndef __WXUNIVERSAL__
2085 #ifdef __WXMSW__
2086     virtual WXHWND GetEditHWND() const { return GetHWND(); }
2087 #endif
2088 #ifdef __WXMOTIF__
2089     virtual WXWidget GetTextWidget() const { return NULL; }
2090 #endif
2091 #ifdef __WXGTK20__
2092     virtual GtkEditable *GetEditable() const { return NULL; }
2093     virtual GtkEntry *GetEntry() const { return NULL; }
2094 #endif
2095 #endif // !__WXUNIVERSAL__
2096
2097 // Overrides
2098 protected:
2099
2100     /**
2101         Currently this simply returns @c wxSize(10, 10).
2102     */
2103     virtual wxSize DoGetBestSize() const ;
2104
2105     virtual void DoSetValue(const wxString& value, int flags = 0);
2106
2107     virtual void DoThaw();
2108
2109
2110 // Data members
2111 protected:
2112 #if wxRICHTEXT_BUFFERED_PAINTING
2113     /// Buffer bitmap
2114     wxBitmap                m_bufferBitmap;
2115 #endif
2116
2117     /// Text buffer
2118     wxRichTextBuffer        m_buffer;
2119
2120     wxMenu*                 m_contextMenu;
2121
2122     /// Caret position (1 less than the character position, so -1 is the
2123     /// first caret position).
2124     long                    m_caretPosition;
2125
2126     /// Caret position when the default formatting has been changed. As
2127     /// soon as this position changes, we no longer reflect the default style
2128     /// in the UI.
2129     long                    m_caretPositionForDefaultStyle;
2130
2131     /// Selection range in character positions. -2, -2 means no selection.
2132     wxRichTextSelection     m_selection;
2133
2134     wxRichTextCtrlSelectionState m_selectionState;
2135
2136     /// Anchor so we know how to extend the selection
2137     /// It's a caret position since it's between two characters.
2138     long                    m_selectionAnchor;
2139
2140     /// Anchor object if selecting multiple container objects, such as grid cells.
2141     wxRichTextObject*       m_selectionAnchorObject;
2142
2143     /// Are we editable?
2144     bool                    m_editable;
2145
2146     /// Are we showing the caret position at the start of a line
2147     /// instead of at the end of the previous one?
2148     bool                    m_caretAtLineStart;
2149
2150     /// Are we dragging a selection?
2151     bool                    m_dragging;
2152
2153     /// Do we need full layout in idle?
2154     bool                    m_fullLayoutRequired;
2155     wxLongLong              m_fullLayoutTime;
2156     long                    m_fullLayoutSavedPosition;
2157
2158     /// Threshold for doing delayed layout
2159     long                    m_delayedLayoutThreshold;
2160
2161     /// Cursors
2162     wxCursor                m_textCursor;
2163     wxCursor                m_urlCursor;
2164
2165     static wxArrayString    sm_availableFontNames;
2166
2167     wxRichTextContextMenuPropertiesInfo m_contextMenuPropertiesInfo;
2168
2169     /// The object that currently has the editing focus
2170     wxRichTextParagraphLayoutBox* m_focusObject;
2171 };
2172
2173 /**
2174     @class wxRichTextEvent
2175
2176     This is the event class for wxRichTextCtrl notifications.
2177
2178     @beginEventTable{wxRichTextEvent}
2179     @event{EVT_RICHTEXT_LEFT_CLICK(id, func)}
2180         Process a @c wxEVT_COMMAND_RICHTEXT_LEFT_CLICK event, generated when the user
2181         releases the left mouse button over an object.
2182     @event{EVT_RICHTEXT_RIGHT_CLICK(id, func)}
2183         Process a @c wxEVT_COMMAND_RICHTEXT_RIGHT_CLICK event, generated when the user
2184         releases the right mouse button over an object.
2185     @event{EVT_RICHTEXT_MIDDLE_CLICK(id, func)}
2186         Process a @c wxEVT_COMMAND_RICHTEXT_MIDDLE_CLICK event, generated when the user
2187         releases the middle mouse button over an object.
2188     @event{EVT_RICHTEXT_LEFT_DCLICK(id, func)}
2189         Process a @c wxEVT_COMMAND_RICHTEXT_LEFT_DCLICK event, generated when the user
2190         double-clicks an object.
2191     @event{EVT_RICHTEXT_RETURN(id, func)}
2192         Process a @c wxEVT_COMMAND_RICHTEXT_RETURN event, generated when the user
2193         presses the return key. Valid event functions: GetFlags, GetPosition.
2194     @event{EVT_RICHTEXT_CHARACTER(id, func)}
2195         Process a @c wxEVT_COMMAND_RICHTEXT_CHARACTER event, generated when the user
2196         presses a character key. Valid event functions: GetFlags, GetPosition, GetCharacter.
2197     @event{EVT_RICHTEXT_DELETE(id, func)}
2198         Process a @c wxEVT_COMMAND_RICHTEXT_DELETE event, generated when the user
2199         presses the backspace or delete key. Valid event functions: GetFlags, GetPosition.
2200     @event{EVT_RICHTEXT_RETURN(id, func)}
2201         Process a @c wxEVT_COMMAND_RICHTEXT_RETURN event, generated when the user
2202         presses the return key. Valid event functions: GetFlags, GetPosition.
2203     @event{EVT_RICHTEXT_STYLE_CHANGED(id, func)}
2204         Process a @c wxEVT_COMMAND_RICHTEXT_STYLE_CHANGED event, generated when
2205         styling has been applied to the control. Valid event functions: GetPosition, GetRange.
2206     @event{EVT_RICHTEXT_STYLESHEET_CHANGED(id, func)}
2207         Process a @c wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGING event, generated
2208         when the control's stylesheet has changed, for example the user added,
2209         edited or deleted a style. Valid event functions: GetRange, GetPosition.
2210     @event{EVT_RICHTEXT_STYLESHEET_REPLACING(id, func)}
2211         Process a @c wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACING event, generated
2212         when the control's stylesheet is about to be replaced, for example when
2213         a file is loaded into the control.
2214         Valid event functions: Veto, GetOldStyleSheet, GetNewStyleSheet.
2215     @event{EVT_RICHTEXT_STYLESHEET_REPLACED(id, func)}
2216         Process a @c wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACED event, generated
2217         when the control's stylesheet has been replaced, for example when a file
2218         is loaded into the control.
2219         Valid event functions: GetOldStyleSheet, GetNewStyleSheet.
2220     @event{EVT_RICHTEXT_PROPERTIES_CHANGED(id, func)}
2221         Process a @c wxEVT_COMMAND_RICHTEXT_PROPERTIES_CHANGED event, generated when
2222         properties have been applied to the control. Valid event functions: GetPosition, GetRange.
2223     @event{EVT_RICHTEXT_CONTENT_INSERTED(id, func)}
2224         Process a @c wxEVT_COMMAND_RICHTEXT_CONTENT_INSERTED event, generated when
2225         content has been inserted into the control.
2226         Valid event functions: GetPosition, GetRange.
2227     @event{EVT_RICHTEXT_CONTENT_DELETED(id, func)}
2228         Process a @c wxEVT_COMMAND_RICHTEXT_CONTENT_DELETED event, generated when
2229         content has been deleted from the control.
2230         Valid event functions: GetPosition, GetRange.
2231     @event{EVT_RICHTEXT_BUFFER_RESET(id, func)}
2232         Process a @c wxEVT_COMMAND_RICHTEXT_BUFFER_RESET event, generated when the
2233         buffer has been reset by deleting all content.
2234         You can use this to set a default style for the first new paragraph.
2235     @event{EVT_RICHTEXT_SELECTION_CHANGED(id, func)}
2236         Process a @c wxEVT_COMMAND_RICHTEXT_SELECTION_CHANGED event, generated when the
2237         selection range has changed.
2238     @event{EVT_RICHTEXT_FOCUS_OBJECT_CHANGED(id, func)}
2239         Process a @c wxEVT_COMMAND_RICHTEXT_FOCUS_OBJECT_CHANGED event, generated when the
2240         current focus object has changed.
2241     @endEventTable
2242
2243     @library{wxrichtext}
2244     @category{events,richtext}
2245 */
2246
2247 class WXDLLIMPEXP_RICHTEXT wxRichTextEvent : public wxNotifyEvent
2248 {
2249 public:
2250     /**
2251         Constructor.
2252
2253         @param commandType
2254             The type of the event.
2255         @param id
2256             Window identifier. The value @c wxID_ANY indicates a default value.
2257     */
2258     wxRichTextEvent(wxEventType commandType = wxEVT_NULL, int winid = 0)
2259         : wxNotifyEvent(commandType, winid),
2260         m_flags(0), m_position(-1), m_oldStyleSheet(NULL), m_newStyleSheet(NULL),
2261         m_char((wxChar) 0), m_container(NULL), m_oldContainer(NULL)
2262         { }
2263
2264     /**
2265         Copy constructor.
2266     */
2267     wxRichTextEvent(const wxRichTextEvent& event)
2268         : wxNotifyEvent(event),
2269         m_flags(event.m_flags), m_position(-1),
2270         m_oldStyleSheet(event.m_oldStyleSheet), m_newStyleSheet(event.m_newStyleSheet),
2271         m_char((wxChar) 0), m_container(event.m_container), m_oldContainer(event.m_oldContainer)
2272         { }
2273
2274     /**
2275         Returns the buffer position at which the event occurred.
2276     */
2277     long GetPosition() const { return m_position; }
2278
2279     /**
2280         Sets the buffer position variable.
2281     */
2282     void SetPosition(long pos) { m_position = pos; }
2283
2284     /**
2285         Returns flags indicating modifier keys pressed.
2286
2287         Possible values are @c wxRICHTEXT_CTRL_DOWN, @c wxRICHTEXT_SHIFT_DOWN, and @c wxRICHTEXT_ALT_DOWN.
2288     */
2289     int GetFlags() const { return m_flags; }
2290
2291     /**
2292         Sets flags indicating modifier keys pressed.
2293
2294         Possible values are @c wxRICHTEXT_CTRL_DOWN, @c wxRICHTEXT_SHIFT_DOWN, and @c wxRICHTEXT_ALT_DOWN.
2295     */
2296     void SetFlags(int flags) { m_flags = flags; }
2297
2298     /**
2299         Returns the old style sheet.
2300
2301         Can be used in a @c wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGING or
2302         @c wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGED event handler.
2303     */
2304     wxRichTextStyleSheet* GetOldStyleSheet() const { return m_oldStyleSheet; }
2305
2306     /**
2307         Sets the old style sheet variable.
2308     */
2309     void SetOldStyleSheet(wxRichTextStyleSheet* sheet) { m_oldStyleSheet = sheet; }
2310
2311     /**
2312         Returns the new style sheet.
2313
2314         Can be used in a @c wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGING or
2315         @c wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGED event handler.
2316     */
2317     wxRichTextStyleSheet* GetNewStyleSheet() const { return m_newStyleSheet; }
2318
2319     /**
2320         Sets the new style sheet variable.
2321     */
2322     void SetNewStyleSheet(wxRichTextStyleSheet* sheet) { m_newStyleSheet = sheet; }
2323
2324     /**
2325         Gets the range for the current operation.
2326     */
2327     const wxRichTextRange& GetRange() const { return m_range; }
2328
2329     /**
2330         Sets the range variable.
2331     */
2332     void SetRange(const wxRichTextRange& range) { m_range = range; }
2333
2334     /**
2335         Returns the character pressed, within a @c wxEVT_COMMAND_RICHTEXT_CHARACTER event.
2336     */
2337     wxChar GetCharacter() const { return m_char; }
2338
2339     /**
2340         Sets the character variable.
2341     */
2342     void SetCharacter(wxChar ch) { m_char = ch; }
2343
2344     /**
2345         Returns the container for which the event is relevant.
2346     */
2347     wxRichTextParagraphLayoutBox* GetContainer() const { return m_container; }
2348
2349     /**
2350         Sets the container for which the event is relevant.
2351     */
2352     void SetContainer(wxRichTextParagraphLayoutBox* container) { m_container = container; }
2353
2354     /**
2355         Returns the old container, for a focus change event.
2356     */
2357     wxRichTextParagraphLayoutBox* GetOldContainer() const { return m_oldContainer; }
2358
2359     /**
2360         Sets the old container, for a focus change event.
2361     */
2362     void SetOldContainer(wxRichTextParagraphLayoutBox* container) { m_oldContainer = container; }
2363
2364     virtual wxEvent *Clone() const { return new wxRichTextEvent(*this); }
2365
2366 protected:
2367     int                             m_flags;
2368     long                            m_position;
2369     wxRichTextStyleSheet*           m_oldStyleSheet;
2370     wxRichTextStyleSheet*           m_newStyleSheet;
2371     wxRichTextRange                 m_range;
2372     wxChar                          m_char;
2373     wxRichTextParagraphLayoutBox*   m_container;
2374     wxRichTextParagraphLayoutBox*   m_oldContainer;
2375
2376 private:
2377     DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxRichTextEvent)
2378 };