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