include/wx/richtext/richtextctrl.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/richtext/richtextctrl.h
   3 // Purpose:     A rich edit control
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     2005-09-30
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifndef _WX_RICHTEXTCTRL_H_
  13 #define _WX_RICHTEXTCTRL_H_
  14
  15 #include "wx/richtext/richtextbuffer.h"
  16
  17 #if wxUSE_RICHTEXT
  18
  19 #include "wx/scrolwin.h"
  20 #include "wx/caret.h"
  21
  22 #if wxCHECK_VERSION(2,7,0)
  23 #define wxRICHTEXT_DERIVES_FROM_TEXTCTRLBASE 1
  24 #else
  25 #define wxRICHTEXT_DERIVES_FROM_TEXTCTRLBASE 0
  26 #endif
  27
  28 #if wxRICHTEXT_DERIVES_FROM_TEXTCTRLBASE
  29 #include "wx/textctrl.h"
  30 #endif
  31
  32 class WXDLLIMPEXP_RICHTEXT wxRichTextStyleDefinition;
  33
  34 /*!
  35  * Styles and flags
  36  */
  37
  38 /* Styles
  39  */
  40
  41 #define wxRE_READONLY          0x0010
  42 #define wxRE_MULTILINE         0x0020
  43
  44 /* Flags
  45  */
  46
  47 #define wxRICHTEXT_SHIFT_DOWN  0x01
  48 #define wxRICHTEXT_CTRL_DOWN   0x02
  49 #define wxRICHTEXT_ALT_DOWN    0x04
  50
  51 /* Defaults
  52  */
  53
  54 #define wxRICHTEXT_DEFAULT_OVERALL_SIZE wxSize(-1, -1)
  55 #define wxRICHTEXT_DEFAULT_IMAGE_SIZE wxSize(80, 80)
  56 #define wxRICHTEXT_DEFAULT_SPACING 3
  57 #define wxRICHTEXT_DEFAULT_MARGIN 3
  58 #define wxRICHTEXT_DEFAULT_UNFOCUSSED_BACKGROUND wxColour(175, 175, 175)
  59 #define wxRICHTEXT_DEFAULT_FOCUSSED_BACKGROUND wxColour(140, 140, 140)
  60 #define wxRICHTEXT_DEFAULT_UNSELECTED_BACKGROUND wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE)
  61 #define wxRICHTEXT_DEFAULT_TYPE_COLOUR wxColour(0, 0, 200)
  62 #define wxRICHTEXT_DEFAULT_FOCUS_RECT_COLOUR wxColour(100, 80, 80)
  63 #define wxRICHTEXT_DEFAULT_CARET_WIDTH 2
  64 // Minimum buffer size before delayed layout kicks in
  65 #define wxRICHTEXT_DEFAULT_DELAYED_LAYOUT_THRESHOLD 20000
  66 // Milliseconds before layout occurs after resize
  67 #define wxRICHTEXT_DEFAULT_LAYOUT_INTERVAL 50
  68
  69 /*!
  70  * Forward declarations
  71  */
  72
  73 /*!
  74  * wxRichTextItem class declaration
  75  */
  76
  77 // Drawing styles/states
  78 #define wxRICHTEXT_SELECTED    0x01
  79 #define wxRICHTEXT_TAGGED      0x02
  80 // The control is focussed
  81 #define wxRICHTEXT_FOCUSSED    0x04
  82 // The item itself has the focus
  83 #define wxRICHTEXT_IS_FOCUS    0x08
  84
  85 /*!
  86  * wxRichTextCtrl class declaration
  87  */
  88
  89 class WXDLLIMPEXP_RICHTEXT wxRichTextCtrl:
  90 #if wxRICHTEXT_DERIVES_FROM_TEXTCTRLBASE
  91  public wxTextCtrlBase, public wxScrollHelper
  92 #else
  93  public wxScrolledWindow
  94 #endif
  95 {
  96     DECLARE_CLASS( wxRichTextCtrl )
  97     DECLARE_EVENT_TABLE()
  98
  99 public:
 100 // Constructors
 101
 102     wxRichTextCtrl( );
 103     wxRichTextCtrl( wxWindow* parent, wxWindowID id = -1, const wxString& value = wxEmptyString, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
 104         long style = wxRE_MULTILINE );
 105     virtual ~wxRichTextCtrl( );
 106
 107 // Operations
 108
 109     /// Creation
 110     bool Create( wxWindow* parent, wxWindowID id = -1, const wxString& value = wxEmptyString, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
 111         long style = wxRE_MULTILINE );
 112
 113     /// Member initialisation
 114     void Init();
 115
 116 ///// wxTextCtrl compatibility
 117
 118 // Accessors
 119
 120     virtual wxString GetValue() const;
 121     virtual void SetValue(const wxString& value);
 122
 123     virtual wxString GetRange(long from, long to) const;
 124
 125     virtual int GetLineLength(long lineNo) const ;
 126     virtual wxString GetLineText(long lineNo) const ;
 127     virtual int GetNumberOfLines() const ;
 128
 129     virtual bool IsModified() const ;
 130     virtual bool IsEditable() const ;
 131
 132     // more readable flag testing methods
 133     bool IsSingleLine() const { return !HasFlag(wxRE_MULTILINE); }
 134     bool IsMultiLine() const { return !IsSingleLine(); }
 135
 136     // If the return values from and to are the same, there is no selection.
 137     virtual void GetSelection(long* from, long* to) const;
 138
 139     virtual wxString GetStringSelection() const;
 140
 141     /// Get filename
 142     wxString GetFilename() const { return m_filename; }
 143
 144     /// Set filename
 145     void SetFilename(const wxString& filename) { m_filename = filename; }
 146
 147     /// Set the threshold in character positions for doing layout optimization during sizing
 148     void SetDelayedLayoutThreshold(long threshold) { m_delayedLayoutThreshold = threshold; }
 149
 150     /// Get the threshold in character positions for doing layout optimization during sizing
 151     long GetDelayedLayoutThreshold() const { return m_delayedLayoutThreshold; }
 152
 153 // Operations
 154
 155     // editing
 156     virtual void Clear();
 157     virtual void Replace(long from, long to, const wxString& value);
 158     virtual void Remove(long from, long to);
 159
 160 #if !wxRICHTEXT_DERIVES_FROM_TEXTCTRLBASE
 161     bool LoadFile(const wxString& file, int fileType = wxRICHTEXT_TYPE_ANY);
 162     bool SaveFile(const wxString& file = wxEmptyString, int fileType = wxRICHTEXT_TYPE_ANY);
 163 #endif
 164
 165     // load/save the controls contents from/to the file
 166     virtual bool DoLoadFile(const wxString& file, int fileType);
 167     virtual bool DoSaveFile(const wxString& file = wxEmptyString, int fileType = wxRICHTEXT_TYPE_ANY);
 168
 169     // sets/clears the dirty flag
 170     virtual void MarkDirty();
 171     virtual void DiscardEdits();
 172
 173     // set the max number of characters which may be entered in a single line
 174     // text control
 175     virtual void SetMaxLength(unsigned long WXUNUSED(len)) { }
 176
 177     // writing text inserts it at the current position, appending always
 178     // inserts it at the end
 179     virtual void WriteText(const wxString& text);
 180     virtual void AppendText(const wxString& text);
 181
 182     // text control under some platforms supports the text styles: these
 183     // methods allow to apply the given text style to the given selection or to
 184     // set/get the style which will be used for all appended text
 185     virtual bool SetStyle(long start, long end, const wxTextAttr& style);
 186     virtual bool SetStyle(long start, long end, const wxTextAttrEx& style);
 187     virtual bool SetStyle(const wxRichTextRange& range, const wxRichTextAttr& style);
 188     virtual bool GetStyle(long position, wxTextAttr& style);
 189     virtual bool GetStyle(long position, wxTextAttrEx& style);
 190     virtual bool GetStyle(long position, wxRichTextAttr& style);
 191     virtual bool SetDefaultStyle(const wxTextAttrEx& style);
 192     virtual bool SetDefaultStyle(const wxTextAttr& style);
 193
 194     // TODO: change to GetDefaultStyle if we merge wxTextAttr and wxTextAttrEx
 195     virtual const wxTextAttrEx& GetDefaultStyleEx() const;
 196     virtual const wxTextAttr& GetDefaultStyle() const;
 197
 198     // translate between the position (which is just an index in the text ctrl
 199     // considering all its contents as a single strings) and (x, y) coordinates
 200     // which represent column and line.
 201     virtual long XYToPosition(long x, long y) const;
 202     virtual bool PositionToXY(long pos, long *x, long *y) const;
 203
 204     virtual void ShowPosition(long pos);
 205
 206     // find the character at position given in pixels
 207     //
 208     // NB: pt is in device coords (not adjusted for the client area origin nor
 209     //     scrolling)
 210     virtual wxTextCtrlHitTestResult HitTest(const wxPoint& pt, long *pos) const;
 211     virtual wxTextCtrlHitTestResult HitTest(const wxPoint& pt,
 212                                             wxTextCoord *col,
 213                                             wxTextCoord *row) const;
 214
 215     // Clipboard operations
 216     virtual void Copy();
 217     virtual void Cut();
 218     virtual void Paste();
 219     virtual void DeleteSelection();
 220
 221     virtual bool CanCopy() const;
 222     virtual bool CanCut() const;
 223     virtual bool CanPaste() const;
 224     virtual bool CanDeleteSelection() const;
 225
 226     // Undo/redo
 227     virtual void Undo();
 228     virtual void Redo();
 229
 230     virtual bool CanUndo() const;
 231     virtual bool CanRedo() const;
 232
 233     // Insertion point
 234     virtual void SetInsertionPoint(long pos);
 235     virtual void SetInsertionPointEnd();
 236     virtual long GetInsertionPoint() const;
 237     virtual wxTextPos GetLastPosition() const;
 238
 239     virtual void SetSelection(long from, long to);
 240     virtual void SelectAll();
 241     virtual void SetEditable(bool editable);
 242
 243     /// Call Freeze to prevent refresh
 244     virtual void Freeze();
 245
 246     /// Call Thaw to refresh
 247     virtual void Thaw();
 248
 249     /// Call Thaw to refresh
 250     virtual bool IsFrozen() const { return m_freezeCount > 0; }
 251
 252     virtual bool HasSelection() const;
 253
 254 ///// Functionality specific to wxRichTextCtrl
 255
 256     /// Write an image at the current insertion point. Supply optional type to use
 257     /// for internal and file storage of the raw data.
 258     virtual bool WriteImage(const wxImage& image, int bitmapType = wxBITMAP_TYPE_PNG);
 259
 260     /// Write a bitmap at the current insertion point. Supply optional type to use
 261     /// for internal and file storage of the raw data.
 262     virtual bool WriteImage(const wxBitmap& bitmap, int bitmapType = wxBITMAP_TYPE_PNG);
 263
 264     /// Load an image from file and write at the current insertion point.
 265     virtual bool WriteImage(const wxString& filename, int bitmapType);
 266
 267     /// Write an image block at the current insertion point.
 268     virtual bool WriteImage(const wxRichTextImageBlock& imageBlock);
 269
 270     /// Insert a newline (actually paragraph) at the current insertion point.
 271     virtual bool Newline();
 272
 273     /// Set basic (overall) style
 274     virtual void SetBasicStyle(const wxTextAttrEx& style) { GetBuffer().SetBasicStyle(style); }
 275     virtual void SetBasicStyle(const wxRichTextAttr& style) { GetBuffer().SetBasicStyle(style); }
 276
 277     /// Get basic (overall) style
 278     virtual const wxTextAttrEx& GetBasicStyle() const { return GetBuffer().GetBasicStyle(); }
 279
 280     /// Begin using a style
 281     virtual bool BeginStyle(const wxTextAttrEx& style) { return GetBuffer().BeginStyle(style); }
 282
 283     /// End the style
 284     virtual bool EndStyle() { return GetBuffer().EndStyle(); }
 285
 286     /// End all styles
 287     virtual bool EndAllStyles() { return GetBuffer().EndAllStyles(); }
 288
 289     /// Begin using bold
 290     bool BeginBold() { return GetBuffer().BeginBold(); }
 291
 292     /// End using bold
 293     bool EndBold()  { return GetBuffer().EndBold(); }
 294
 295     /// Begin using italic
 296     bool BeginItalic() { return GetBuffer().BeginItalic(); }
 297
 298     /// End using italic
 299     bool EndItalic() { return GetBuffer().EndItalic(); }
 300
 301     /// Begin using underline
 302     bool BeginUnderline() { return GetBuffer().BeginUnderline(); }
 303
 304     /// End using underline
 305     bool EndUnderline() { return GetBuffer().EndUnderline(); }
 306
 307     /// Begin using point size
 308     bool BeginFontSize(int pointSize) { return GetBuffer().BeginFontSize(pointSize); }
 309
 310     /// End using point size
 311     bool EndFontSize() { return GetBuffer().EndFontSize(); }
 312
 313     /// Begin using this font
 314     bool BeginFont(const wxFont& font) { return GetBuffer().BeginFont(font); }
 315
 316     /// End using a font
 317     bool EndFont() { return GetBuffer().EndFont(); }
 318
 319     /// Begin using this colour
 320     bool BeginTextColour(const wxColour& colour) { return GetBuffer().BeginTextColour(colour); }
 321
 322     /// End using a colour
 323     bool EndTextColour() { return GetBuffer().EndTextColour(); }
 324
 325     /// Begin using alignment
 326     bool BeginAlignment(wxTextAttrAlignment alignment) { return GetBuffer().BeginAlignment(alignment); }
 327
 328     /// End alignment
 329     bool EndAlignment() { return GetBuffer().EndAlignment(); }
 330
 331     /// Begin left indent
 332     bool BeginLeftIndent(int leftIndent, int leftSubIndent = 0) { return GetBuffer().BeginLeftIndent(leftIndent, leftSubIndent); }
 333
 334     /// End left indent
 335     bool EndLeftIndent() { return GetBuffer().EndLeftIndent(); }
 336
 337     /// Begin right indent
 338     bool BeginRightIndent(int rightIndent) { return GetBuffer().BeginRightIndent(rightIndent); }
 339
 340     /// End right indent
 341     bool EndRightIndent() { return GetBuffer().EndRightIndent(); }
 342
 343     /// Begin paragraph spacing
 344     bool BeginParagraphSpacing(int before, int after) { return GetBuffer().BeginParagraphSpacing(before, after); }
 345
 346     /// End paragraph spacing
 347     bool EndParagraphSpacing() { return GetBuffer().EndParagraphSpacing(); }
 348
 349     /// Begin line spacing
 350     bool BeginLineSpacing(int lineSpacing) { return GetBuffer().BeginLineSpacing(lineSpacing); }
 351
 352     /// End line spacing
 353     bool EndLineSpacing() { return GetBuffer().EndLineSpacing(); }
 354
 355     /// Begin numbered bullet
 356     bool BeginNumberedBullet(int bulletNumber, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_ARABIC|wxTEXT_ATTR_BULLET_STYLE_PERIOD)
 357     { return GetBuffer().BeginNumberedBullet(bulletNumber, leftIndent, leftSubIndent, bulletStyle); }
 358
 359     /// End numbered bullet
 360     bool EndNumberedBullet() { return GetBuffer().EndNumberedBullet(); }
 361
 362     /// Begin symbol bullet
 363     bool BeginSymbolBullet(wxChar symbol, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_SYMBOL)
 364     { return GetBuffer().BeginSymbolBullet(symbol, leftIndent, leftSubIndent, bulletStyle); }
 365
 366     /// End symbol bullet
 367     bool EndSymbolBullet() { return GetBuffer().EndSymbolBullet(); }
 368
 369     /// Begin named character style
 370     bool BeginCharacterStyle(const wxString& characterStyle) { return GetBuffer().BeginCharacterStyle(characterStyle); }
 371
 372     /// End named character style
 373     bool EndCharacterStyle() { return GetBuffer().EndCharacterStyle(); }
 374
 375     /// Begin named paragraph style
 376     bool BeginParagraphStyle(const wxString& paragraphStyle) { return GetBuffer().BeginParagraphStyle(paragraphStyle); }
 377
 378     /// End named character style
 379     bool EndParagraphStyle() { return GetBuffer().EndParagraphStyle(); }
 380
 381     /// Sets the default style to the style under the cursor
 382     bool SetDefaultStyleToCursorStyle();
 383
 384     /// Clear the selection
 385     virtual void SelectNone();
 386
 387     /// Get/set the selection range in character positions. -1, -1 means no selection.
 388     /// The range is in API convention, i.e. a single character selection is denoted
 389     /// by (n, n+1)
 390     wxRichTextRange GetSelectionRange() const;
 391     void SetSelectionRange(const wxRichTextRange& range);
 392
 393     /// Get/set the selection range in character positions. -1, -1 means no selection.
 394     /// The range is in internal format, i.e. a single character selection is denoted
 395     /// by (n, n)
 396     const wxRichTextRange& GetInternalSelectionRange() const { return m_selectionRange; }
 397     void SetInternalSelectionRange(const wxRichTextRange& range) { m_selectionRange = range; }
 398
 399     /// Add a new paragraph of text to the end of the buffer
 400     virtual wxRichTextRange AddParagraph(const wxString& text);
 401
 402     /// Add an image
 403     virtual wxRichTextRange AddImage(const wxImage& image);
 404
 405     /// Layout the buffer: which we must do before certain operations, such as
 406     /// setting the caret position.
 407     virtual bool LayoutContent(bool onlyVisibleRect = false);
 408
 409     /// Move the caret to the given character position
 410     virtual bool MoveCaret(long pos, bool showAtLineStart = false);
 411
 412     /// Move right
 413     virtual bool MoveRight(int noPositions = 1, int flags = 0);
 414
 415     /// Move left
 416     virtual bool MoveLeft(int noPositions = 1, int flags = 0);
 417
 418     /// Move up
 419     virtual bool MoveUp(int noLines = 1, int flags = 0);
 420
 421     /// Move up
 422     virtual bool MoveDown(int noLines = 1, int flags = 0);
 423
 424     /// Move to the end of the line
 425     virtual bool MoveToLineEnd(int flags = 0);
 426
 427     /// Move to the start of the line
 428     virtual bool MoveToLineStart(int flags = 0);
 429
 430     /// Move to the end of the paragraph
 431     virtual bool MoveToParagraphEnd(int flags = 0);
 432
 433     /// Move to the start of the paragraph
 434     virtual bool MoveToParagraphStart(int flags = 0);
 435
 436     /// Move to the start of the buffer
 437     virtual bool MoveHome(int flags = 0);
 438
 439     /// Move to the end of the buffer
 440     virtual bool MoveEnd(int flags = 0);
 441
 442     /// Move n pages up
 443     virtual bool PageUp(int noPages = 1, int flags = 0);
 444
 445     /// Move n pages down
 446     virtual bool PageDown(int noPages = 1, int flags = 0);
 447
 448     /// Move n words left
 449     virtual bool WordLeft(int noPages = 1, int flags = 0);
 450
 451     /// Move n words right
 452     virtual bool WordRight(int noPages = 1, int flags = 0);
 453
 454     /// Returns the buffer associated with the control.
 455     wxRichTextBuffer& GetBuffer() { return m_buffer; }
 456     const wxRichTextBuffer& GetBuffer() const { return m_buffer; }
 457
 458     /// Start batching undo history for commands.
 459     virtual bool BeginBatchUndo(const wxString& cmdName) { return m_buffer.BeginBatchUndo(cmdName); }
 460
 461     /// End batching undo history for commands.
 462     virtual bool EndBatchUndo() { return m_buffer.EndBatchUndo(); }
 463
 464     /// Are we batching undo history for commands?
 465     virtual bool BatchingUndo() const { return m_buffer.BatchingUndo(); }
 466
 467     /// Start suppressing undo history for commands.
 468     virtual bool BeginSuppressUndo() { return m_buffer.BeginSuppressUndo(); }
 469
 470     /// End suppressing undo history for commands.
 471     virtual bool EndSuppressUndo() { return m_buffer.EndSuppressUndo(); }
 472
 473     /// Are we suppressing undo history for commands?
 474     virtual bool SuppressingUndo() const { return m_buffer.SuppressingUndo(); }
 475
 476     /// Test if this whole range has character attributes of the specified kind. If any
 477     /// of the attributes are different within the range, the test fails. You
 478     /// can use this to implement, for example, bold button updating. style must have
 479     /// flags indicating which attributes are of interest.
 480     virtual bool HasCharacterAttributes(const wxRichTextRange& range, const wxTextAttrEx& style) const
 481     {
 482         return GetBuffer().HasCharacterAttributes(range, style);
 483     }
 484     virtual bool HasCharacterAttributes(const wxRichTextRange& range, const wxRichTextAttr& style) const
 485     {
 486         return GetBuffer().HasCharacterAttributes(range, style);
 487     }
 488
 489     /// Test if this whole range has paragraph attributes of the specified kind. If any
 490     /// of the attributes are different within the range, the test fails. You
 491     /// can use this to implement, for example, centering button updating. style must have
 492     /// flags indicating which attributes are of interest.
 493     virtual bool HasParagraphAttributes(const wxRichTextRange& range, const wxTextAttrEx& style) const
 494     {
 495         return GetBuffer().HasParagraphAttributes(range, style);
 496     }
 497     virtual bool HasParagraphAttributes(const wxRichTextRange& range, const wxRichTextAttr& style) const
 498     {
 499         return GetBuffer().HasParagraphAttributes(range, style);
 500     }
 501
 502     /// Is all of the selection bold?
 503     virtual bool IsSelectionBold();
 504
 505     /// Is all of the selection italics?
 506     virtual bool IsSelectionItalics();
 507
 508     /// Is all of the selection underlined?
 509     virtual bool IsSelectionUnderlined();
 510
 511     /// Is all of the selection aligned according to the specified flag?
 512     virtual bool IsSelectionAligned(wxTextAttrAlignment alignment);
 513
 514     /// Apply bold to the selection
 515     virtual bool ApplyBoldToSelection();
 516
 517     /// Apply italic to the selection
 518     virtual bool ApplyItalicToSelection();
 519
 520     /// Apply underline to the selection
 521     virtual bool ApplyUnderlineToSelection();
 522
 523     /// Apply alignment to the selection
 524     virtual bool ApplyAlignmentToSelection(wxTextAttrAlignment alignment);
 525
 526     /// Apply a named style to the selection
 527     virtual void ApplyStyle(wxRichTextStyleDefinition* def);
 528
 529     /// Set style sheet, if any.
 530     void SetStyleSheet(wxRichTextStyleSheet* styleSheet) { GetBuffer().SetStyleSheet(styleSheet); }
 531     wxRichTextStyleSheet* GetStyleSheet() const { return GetBuffer().GetStyleSheet(); }
 532
 533 // Command handlers
 534
 535     void Command(wxCommandEvent& event);
 536     void OnDropFiles(wxDropFilesEvent& event);
 537
 538     void OnCut(wxCommandEvent& event);
 539     void OnCopy(wxCommandEvent& event);
 540     void OnPaste(wxCommandEvent& event);
 541     void OnUndo(wxCommandEvent& event);
 542     void OnRedo(wxCommandEvent& event);
 543     void OnSelectAll(wxCommandEvent& event);
 544     void OnClear(wxCommandEvent& event);
 545
 546     void OnUpdateCut(wxUpdateUIEvent& event);
 547     void OnUpdateCopy(wxUpdateUIEvent& event);
 548     void OnUpdatePaste(wxUpdateUIEvent& event);
 549     void OnUpdateUndo(wxUpdateUIEvent& event);
 550     void OnUpdateRedo(wxUpdateUIEvent& event);
 551     void OnUpdateSelectAll(wxUpdateUIEvent& event);
 552     void OnUpdateClear(wxUpdateUIEvent& event);
 553
 554     // Show a context menu for Rich Edit controls (the standard
 555     // EDIT control has one already)
 556     void OnContextMenu(wxContextMenuEvent& event);
 557
 558 // Event handlers
 559
 560     /// Painting
 561     void OnPaint(wxPaintEvent& event);
 562     void OnEraseBackground(wxEraseEvent& event);
 563
 564     /// Left-click
 565     void OnLeftClick(wxMouseEvent& event);
 566
 567     /// Left-up
 568     void OnLeftUp(wxMouseEvent& event);
 569
 570     /// Motion
 571     void OnMoveMouse(wxMouseEvent& event);
 572
 573     /// Left-double-click
 574     void OnLeftDClick(wxMouseEvent& event);
 575
 576     /// Middle-click
 577     void OnMiddleClick(wxMouseEvent& event);
 578
 579     /// Right-click
 580     void OnRightClick(wxMouseEvent& event);
 581
 582     /// Key press
 583     void OnChar(wxKeyEvent& event);
 584
 585     /// Sizing
 586     void OnSize(wxSizeEvent& event);
 587
 588     /// Setting/losing focus
 589     void OnSetFocus(wxFocusEvent& event);
 590     void OnKillFocus(wxFocusEvent& event);
 591
 592     /// Idle-time processing
 593     void OnIdle(wxIdleEvent& event);
 594
 595     /// Scrolling
 596     void OnScroll(wxScrollWinEvent& event);
 597
 598 // Implementation
 599
 600     /// Set font, and also default attributes
 601     virtual bool SetFont(const wxFont& font);
 602
 603     /// Set up scrollbars, e.g. after a resize
 604     virtual void SetupScrollbars(bool atTop = false);
 605
 606     /// Keyboard navigation
 607     virtual bool KeyboardNavigate(int keyCode, int flags);
 608
 609     /// Paint the background
 610     virtual void PaintBackground(wxDC& dc);
 611
 612     /// Recreate buffer bitmap if necessary
 613     virtual bool RecreateBuffer(const wxSize& size = wxDefaultSize);
 614
 615     /// Set the selection
 616     virtual void DoSetSelection(long from, long to, bool scrollCaret = true);
 617
 618     /// Write text
 619     virtual void DoWriteText(const wxString& value, bool selectionOnly = true);
 620
 621     /// Send an update event
 622     virtual bool SendUpdateEvent();
 623
 624     /// Init command event
 625     void InitCommandEvent(wxCommandEvent& event) const;
 626
 627     /// do the window-specific processing after processing the update event
 628     //  (duplicated code from wxTextCtrlBase)
 629 #if !wxRICHTEXT_DERIVES_FROM_TEXTCTRLBASE
 630     virtual void DoUpdateWindowUI(wxUpdateUIEvent& event);
 631 #endif
 632
 633     /// Should we inherit colours?
 634     virtual bool ShouldInheritColours() const { return false; }
 635
 636     /// Position the caret
 637     virtual void PositionCaret();
 638
 639     /// Extend the selection, returning true if the selection was
 640     /// changed. Selections are in caret positions.
 641     virtual bool ExtendSelection(long oldPosition, long newPosition, int flags);
 642
 643     /// Scroll into view. This takes a _caret_ position.
 644     virtual bool ScrollIntoView(long position, int keyCode);
 645
 646     /// The caret position is the character position just before the caret.
 647     /// A value of -1 means the caret is at the start of the buffer.
 648     void SetCaretPosition(long position, bool showAtLineStart = false) ;
 649     long GetCaretPosition() const { return m_caretPosition; }
 650
 651     /// The adjusted caret position is the character position adjusted to take
 652     /// into account whether we're at the start of a paragraph, in which case
 653     /// style information should be taken from the next position, not current one.
 654     long GetAdjustedCaretPosition(long caretPos) const;
 655
 656     /// Move caret one visual step forward: this may mean setting a flag
 657     /// and keeping the same position if we're going from the end of one line
 658     /// to the start of the next, which may be the exact same caret position.
 659     void MoveCaretForward(long oldPosition) ;
 660
 661     /// Move caret one visual step forward: this may mean setting a flag
 662     /// and keeping the same position if we're going from the end of one line
 663     /// to the start of the next, which may be the exact same caret position.
 664     void MoveCaretBack(long oldPosition) ;
 665
 666     /// Get the caret height and position for the given character position
 667     bool GetCaretPositionForIndex(long position, wxRect& rect);
 668
 669     /// Gets the line for the visible caret position. If the caret is
 670     /// shown at the very end of the line, it means the next character is actually
 671     /// on the following line. So let's get the line we're expecting to find
 672     /// if this is the case.
 673     wxRichTextLine* GetVisibleLineForCaretPosition(long caretPosition) const;
 674
 675     /// Gets the command processor
 676     wxCommandProcessor* GetCommandProcessor() const { return GetBuffer().GetCommandProcessor(); }
 677
 678     /// Delete content if there is a selection, e.g. when pressing a key.
 679     /// Returns the new caret position in newPos, or leaves it if there
 680     /// was no action.
 681     bool DeleteSelectedContent(long* newPos= NULL);
 682
 683     /// Transform logical to physical
 684     wxPoint GetPhysicalPoint(const wxPoint& ptLogical) const;
 685
 686     /// Transform physical to logical
 687     wxPoint GetLogicalPoint(const wxPoint& ptPhysical) const;
 688
 689     /// Finds the caret position for the next word. Direction
 690     /// is 1 (forward) or -1 (backwards).
 691     virtual long FindNextWordPosition(int direction = 1) const;
 692
 693     /// Is the given position visible on the screen?
 694     bool IsPositionVisible(long pos) const;
 695
 696     /// Returns the first visible position in the current view
 697     long GetFirstVisiblePosition() const;
 698
 699     /// Returns the caret position since the default formatting was changed. As
 700     /// soon as this position changes, we no longer reflect the default style
 701     /// in the UI. A value of -2 means that we should only reflect the style of the
 702     /// content under the caret.
 703     long GetCaretPositionForDefaultStyle() const { return m_caretPositionForDefaultStyle; }
 704
 705     /// Set the caret position for the default style that the user is selecting.
 706     void SetCaretPositionForDefaultStyle(long pos) { m_caretPositionForDefaultStyle = pos; }
 707
 708     /// Should the UI reflect the default style chosen by the user, rather than the style under
 709     /// the caret?
 710     bool IsDefaultStyleShowing() const { return m_caretPositionForDefaultStyle != -2; }
 711
 712     /// Convenience function that tells the control to start reflecting the default
 713     /// style, since the user is changing it.
 714     void SetAndShowDefaultStyle(const wxRichTextAttr& attr)
 715     {
 716         SetDefaultStyle(attr);
 717         SetCaretPositionForDefaultStyle(GetCaretPosition());
 718     }
 719
 720 #if wxRICHTEXT_DERIVES_FROM_TEXTCTRLBASE
 721      WX_FORWARD_TO_SCROLL_HELPER()
 722 #endif
 723
 724 // Overrides
 725 protected:
 726
 727     virtual wxSize DoGetBestSize() const ;
 728
 729 // Data members
 730 private:
 731
 732     /// Allows nested Freeze/Thaw
 733     int                     m_freezeCount;
 734
 735     /// Buffer bitmap
 736     wxBitmap                m_bufferBitmap;
 737
 738     /// Text buffer
 739     wxRichTextBuffer        m_buffer;
 740
 741 #if !wxRICHTEXT_DERIVES_FROM_TEXTCTRLBASE
 742     /// Filename
 743     wxString                m_filename;
 744 #endif
 745
 746     wxMenu*                 m_contextMenu;
 747
 748     /// Caret position (1 less than the character position, so -1 is the
 749     /// first caret position).
 750     long                    m_caretPosition;
 751
 752     /// Caret position when the default formatting has been changed. As
 753     /// soon as this position changes, we no longer reflect the default style
 754     /// in the UI.
 755     long                    m_caretPositionForDefaultStyle;
 756
 757     /// Selection range in character positions. -2, -2 means no selection.
 758     wxRichTextRange         m_selectionRange;
 759
 760     /// Anchor so we know how to extend the selection
 761     /// It's a caret position since it's between two characters.
 762     long                    m_selectionAnchor;
 763
 764     /// Are we editable?
 765     bool                    m_editable;
 766
 767     /// Are we showing the caret position at the start of a line
 768     /// instead of at the end of the previous one?
 769     bool                    m_caretAtLineStart;
 770
 771     /// Are we dragging a selection?
 772     bool                    m_dragging;
 773
 774     /// Start position for drag
 775     wxPoint                 m_dragStart;
 776
 777     /// Do we need full layout in idle?
 778     bool                    m_fullLayoutRequired;
 779     wxLongLong              m_fullLayoutTime;
 780     long                    m_fullLayoutSavedPosition;
 781
 782     /// Threshold for doing delayed layout
 783     long                    m_delayedLayoutThreshold;
 784 };
 785
 786 /*!
 787  * wxRichTextEvent - the event class for wxRichTextCtrl notifications
 788  */
 789
 790 class WXDLLIMPEXP_RICHTEXT wxRichTextEvent : public wxNotifyEvent
 791 {
 792 public:
 793     wxRichTextEvent(wxEventType commandType = wxEVT_NULL, int winid = 0)
 794         : wxNotifyEvent(commandType, winid),
 795         m_itemIndex(-1), m_flags(0)
 796         { }
 797
 798     wxRichTextEvent(const wxRichTextEvent& event)
 799         : wxNotifyEvent(event),
 800         m_itemIndex(event.m_itemIndex), m_flags(event.m_flags)
 801         { }
 802
 803     int GetIndex() const { return m_itemIndex; }
 804     void SetIndex(int n) { m_itemIndex = n; }
 805
 806     int GetFlags() const { return m_flags; }
 807     void SetFlags(int flags) { m_flags = flags; }
 808
 809     virtual wxEvent *Clone() const { return new wxRichTextEvent(*this); }
 810
 811 protected:
 812     int                 m_itemIndex;
 813     int                 m_flags;
 814
 815 private:
 816     DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxRichTextEvent)
 817 };
 818
 819 /*!
 820  * wxRichTextCtrl event macros
 821  */
 822
 823 BEGIN_DECLARE_EVENT_TYPES()
 824     DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_ITEM_SELECTED, 2600)
 825     DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_ITEM_DESELECTED, 2601)
 826     DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_LEFT_CLICK, 2602)
 827     DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_RIGHT_CLICK, 2603)
 828     DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_MIDDLE_CLICK, 2604)
 829     DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_LEFT_DCLICK, 2605)
 830     DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_RICHTEXT, wxEVT_COMMAND_RICHTEXT_RETURN, 2606)
 831 END_DECLARE_EVENT_TYPES()
 832
 833 typedef void (wxEvtHandler::*wxRichTextEventFunction)(wxRichTextEvent&);
 834
 835 #define EVT_RICHTEXT_ITEM_SELECTED(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_ITEM_SELECTED, id, -1, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxRichTextEventFunction, & fn ), NULL ),
 836 #define EVT_RICHTEXT_ITEM_DESELECTED(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_ITEM_DESELECTED, id, -1, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxRichTextEventFunction, & fn ), NULL ),
 837 #define EVT_RICHTEXT_LEFT_CLICK(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_LEFT_CLICK, id, -1, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxRichTextEventFunction, & fn ), NULL ),
 838 #define EVT_RICHTEXT_RIGHT_CLICK(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_RIGHT_CLICK, id, -1, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxRichTextEventFunction, & fn ), NULL ),
 839 #define EVT_RICHTEXT_MIDDLE_CLICK(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_MIDDLE_CLICK, id, -1, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxRichTextEventFunction, & fn ), NULL ),
 840 #define EVT_RICHTEXT_LEFT_DCLICK(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_LEFT_DCLICK, id, -1, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxRichTextEventFunction, & fn ), NULL ),
 841 #define EVT_RICHTEXT_RETURN(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_RETURN, id, -1, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxRichTextEventFunction, & fn ), NULL ),
 842
 843 #endif
 844     // wxUSE_RICHTEXT
 845
 846 #endif
 847     // _WX_RICHTEXTCTRL_H_
 848