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