interface/wx/richtext/richtextctrl.h

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