include/wx/richtext/richtextctrl.h

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