Added wxRichTextCtrl

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@35949 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

include/wx/richtext/richtextctrl.h

@@ -0,0 +1,756 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        richtextctrl.h
+// Purpose:     A rich edit control
+// Author:      Julian Smart
+// Modified by: 
+// Created:     2005-09-30
+// RCS-ID:      
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_RICHTEXTCTRL_H_
+#define _WX_RICHTEXTCTRL_H_
+
+#include "wx/textctrl.h"
+
+#if wxUSE_RICHTEXT
+
+#include "wx/scrolwin.h"
+#include "wx/caret.h"
+
+#include "wx/richtext/richtextbuffer.h"
+
+#if wxCHECK_VERSION(2,7,0)
+#define wxRICHTEXT_DERIVES_FROM_TEXTCTRLBASE 0
+#else
+#define wxRICHTEXT_DERIVES_FROM_TEXTCTRLBASE 0
+#endif
+
+/*!
+ * Styles and flags
+ */
+
+/* Styles
+ */
+
+#define wxRE_READONLY          0x0010
+#define wxRE_MULTILINE         0x0020
+
+/* Flags
+ */
+
+#define wxRICHTEXT_SHIFT_DOWN  0x01
+#define wxRICHTEXT_CTRL_DOWN   0x02
+#define wxRICHTEXT_ALT_DOWN    0x04
+
+/* Defaults
+ */
+
+#define wxRICHTEXT_DEFAULT_OVERALL_SIZE wxSize(-1, -1)
+#define wxRICHTEXT_DEFAULT_IMAGE_SIZE wxSize(80, 80)
+#define wxRICHTEXT_DEFAULT_SPACING 3
+#define wxRICHTEXT_DEFAULT_MARGIN 3
+#define wxRICHTEXT_DEFAULT_UNFOCUSSED_BACKGROUND wxColour(175, 175, 175)
+#define wxRICHTEXT_DEFAULT_FOCUSSED_BACKGROUND wxColour(140, 140, 140)
+#define wxRICHTEXT_DEFAULT_UNSELECTED_BACKGROUND wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE)
+#define wxRICHTEXT_DEFAULT_TYPE_COLOUR wxColour(0, 0, 200)
+#define wxRICHTEXT_DEFAULT_FOCUS_RECT_COLOUR wxColour(100, 80, 80)
+#define wxRICHTEXT_DEFAULT_CARET_WIDTH 2
+
+/*!
+ * Forward declarations
+ */
+
+/*!
+ * wxRichTextItem class declaration
+ */
+
+// Drawing styles/states
+#define wxRICHTEXT_SELECTED    0x01
+#define wxRICHTEXT_TAGGED      0x02
+// The control is focussed
+#define wxRICHTEXT_FOCUSSED    0x04
+// The item itself has the focus
+#define wxRICHTEXT_IS_FOCUS    0x08
+
+/*!
+ * wxRichTextCtrl class declaration
+ */
+
+class WXDLLIMPEXP_ADV wxRichTextCtrl:
+#if wxRICHTEXT_DERIVES_FROM_TEXTCTRLBASE
+ public wxTextCtrlBase, wxScrollHelper
+#else
+ public wxScrolledWindow
+#endif
+{    
+    DECLARE_CLASS( wxRichTextCtrl )
+    DECLARE_EVENT_TABLE()
+
+public:
+// Constructors
+
+    wxRichTextCtrl( );
+    wxRichTextCtrl( wxWindow* parent, wxWindowID id = -1, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
+        long style = wxRE_MULTILINE );
+    ~wxRichTextCtrl( );
+
+// Operations
+
+    /// Creation
+    bool Create( wxWindow* parent, wxWindowID id = -1, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
+        long style = wxRE_MULTILINE );
+
+    /// Member initialisation
+    void Init();
+
+///// wxTextCtrl compatibility
+
+// Accessors
+
+    virtual wxString GetValue() const;
+    virtual void SetValue(const wxString& value);
+
+    virtual wxString GetRange(long from, long to) const;
+
+    virtual int GetLineLength(long lineNo) const ;
+    virtual wxString GetLineText(long lineNo) const ;
+    virtual int GetNumberOfLines() const ;
+
+    virtual bool IsModified() const ;
+    virtual bool IsEditable() const ;
+
+    // more readable flag testing methods
+    bool IsSingleLine() const { return !HasFlag(wxRE_MULTILINE); }
+    bool IsMultiLine() const { return !IsSingleLine(); }
+
+    // If the return values from and to are the same, there is no selection.
+    virtual void GetSelection(long* from, long* to) const;
+
+    virtual wxString GetStringSelection() const;
+
+    /// Get filename
+    wxString GetFilename() const { return m_filename; }
+
+    /// Set filename
+    void SetFilename(const wxString& filename) { m_filename = filename; }
+
+// Operations
+
+    // editing
+    virtual void Clear();
+    virtual void Replace(long from, long to, const wxString& value);
+    virtual void Remove(long from, long to);
+
+    // load/save the controls contents from/to the file
+    virtual bool LoadFile(const wxString& file, int type = wxRICHTEXT_TYPE_ANY);
+    virtual bool SaveFile(const wxString& file = wxEmptyString, int type = wxRICHTEXT_TYPE_ANY);
+
+    // sets/clears the dirty flag
+    virtual void MarkDirty();
+    virtual void DiscardEdits();
+
+    // set the max number of characters which may be entered in a single line
+    // text control
+    virtual void SetMaxLength(unsigned long WXUNUSED(len)) { }
+
+    // writing text inserts it at the current position, appending always
+    // inserts it at the end
+    virtual void WriteText(const wxString& text);
+    virtual void AppendText(const wxString& text);
+
+    // text control under some platforms supports the text styles: these
+    // methods allow to apply the given text style to the given selection or to
+    // set/get the style which will be used for all appended text
+    virtual bool SetStyle(long start, long end, const wxTextAttrEx& style);
+    virtual bool SetStyle(const wxRichTextRange& range, const wxRichTextAttr& style);
+    virtual bool GetStyle(long position, wxTextAttrEx& style) const;
+    virtual bool GetStyle(long position, wxRichTextAttr& style) const;
+    virtual bool SetDefaultStyle(const wxTextAttrEx& style);
+
+    // TODO: change to GetDefaultStyle if we merge wxTextAttr and wxTextAttrEx
+    virtual const wxTextAttrEx& GetDefaultStyleEx() const;
+
+    // translate between the position (which is just an index in the text ctrl
+    // considering all its contents as a single strings) and (x, y) coordinates
+    // which represent column and line.
+    virtual long XYToPosition(long x, long y) const;
+    virtual bool PositionToXY(long pos, long *x, long *y) const;
+
+    virtual void ShowPosition(long pos);
+
+    // find the character at position given in pixels
+    //
+    // NB: pt is in device coords (not adjusted for the client area origin nor
+    //     scrolling)
+    virtual wxTextCtrlHitTestResult HitTest(const wxPoint& pt, long *pos) const;
+    virtual wxTextCtrlHitTestResult HitTest(const wxPoint& pt,
+                                            wxTextCoord *col,
+                                            wxTextCoord *row) const;
+
+    // Clipboard operations
+    virtual void Copy();
+    virtual void Cut();
+    virtual void Paste();
+    virtual void DeleteSelection();
+
+    virtual bool CanCopy() const;
+    virtual bool CanCut() const;
+    virtual bool CanPaste() const;
+    virtual bool CanDeleteSelection() const;
+
+    // Undo/redo
+    virtual void Undo();
+    virtual void Redo();
+
+    virtual bool CanUndo() const;
+    virtual bool CanRedo() const;
+
+    // Insertion point
+    virtual void SetInsertionPoint(long pos);
+    virtual void SetInsertionPointEnd();
+    virtual long GetInsertionPoint() const;
+    virtual wxTextPos GetLastPosition() const;
+
+    virtual void SetSelection(long from, long to);
+    virtual void SelectAll();
+    virtual void SetEditable(bool editable);
+
+    /// Call Freeze to prevent refresh
+    virtual void Freeze();
+
+    /// Call Thaw to refresh
+    virtual void Thaw(bool refresh = true);
+
+    /// Call Thaw to refresh
+    virtual bool IsFrozen() const { return m_freezeCount > 0; }
+
+    virtual bool HasSelection() const;
+
+///// Functionality specific to wxRichTextCtrl
+
+    /// Write an image at the current insertion point. Supply optional type to use
+    /// for internal and file storage of the raw data.
+    virtual bool WriteImage(const wxImage& image, int bitmapType = wxBITMAP_TYPE_PNG);
+
+    /// Write a bitmap at the current insertion point. Supply optional type to use
+    /// for internal and file storage of the raw data.
+    virtual bool WriteImage(const wxBitmap& bitmap, int bitmapType = wxBITMAP_TYPE_PNG);
+
+    /// Load an image from file and write at the current insertion point.
+    virtual bool WriteImage(const wxString& filename, int bitmapType);
+
+    /// Write an image block at the current insertion point.
+    virtual bool WriteImage(const wxRichTextImageBlock& imageBlock);
+
+    /// Insert a newline (actually paragraph) at the current insertion point.
+    virtual bool Newline();
+
+    /// Set basic (overall) style
+    virtual void SetBasicStyle(const wxTextAttrEx& style) { GetBuffer().SetBasicStyle(style); }
+    virtual void SetBasicStyle(const wxRichTextAttr& style) { GetBuffer().SetBasicStyle(style); }
+
+    /// Get basic (overall) style
+    virtual const wxTextAttrEx& GetBasicStyle() const { return GetBuffer().GetBasicStyle(); }
+
+    /// Begin using a style
+    virtual bool BeginStyle(const wxTextAttrEx& style) { return GetBuffer().BeginStyle(style); }
+
+    /// End the style
+    virtual bool EndStyle() { return GetBuffer().EndStyle(); }
+
+    /// End all styles
+    virtual bool EndAllStyles() { return GetBuffer().EndAllStyles(); }
+
+    /// Begin using bold
+    bool BeginBold() { return GetBuffer().BeginBold(); }
+
+    /// End using bold
+    bool EndBold()  { return GetBuffer().EndBold(); }
+
+    /// Begin using italic
+    bool BeginItalic() { return GetBuffer().BeginItalic(); }
+
+    /// End using italic
+    bool EndItalic() { return GetBuffer().EndItalic(); }
+
+    /// Begin using underline
+    bool BeginUnderline() { return GetBuffer().BeginUnderline(); }
+
+    /// End using underline
+    bool EndUnderline() { return GetBuffer().EndUnderline(); }
+
+    /// Begin using point size
+    bool BeginFontSize(int pointSize) { return GetBuffer().BeginFontSize(pointSize); }
+
+    /// End using point size
+    bool EndFontSize() { return GetBuffer().EndFontSize(); }
+
+    /// Begin using this font
+    bool BeginFont(const wxFont& font) { return GetBuffer().BeginFont(font); }
+
+    /// End using a font
+    bool EndFont() { return GetBuffer().EndFont(); }
+
+    /// Begin using this colour
+    bool BeginTextColour(const wxColour& colour) { return GetBuffer().BeginTextColour(colour); }
+
+    /// End using a colour
+    bool EndTextColour() { return GetBuffer().EndTextColour(); }
+
+    /// Begin using alignment
+    bool BeginAlignment(wxTextAttrAlignment alignment) { return GetBuffer().BeginAlignment(alignment); }
+
+    /// End alignment
+    bool EndAlignment() { return GetBuffer().EndAlignment(); }
+
+    /// Begin left indent
+    bool BeginLeftIndent(int leftIndent, int leftSubIndent = 0) { return GetBuffer().BeginLeftIndent(leftIndent, leftSubIndent); }
+
+    /// End left indent
+    bool EndLeftIndent() { return GetBuffer().EndLeftIndent(); }
+
+    /// Begin right indent
+    bool BeginRightIndent(int rightIndent) { return GetBuffer().BeginRightIndent(rightIndent); }
+
+    /// End right indent
+    bool EndRightIndent() { return GetBuffer().EndRightIndent(); }
+
+    /// Begin paragraph spacing
+    bool BeginParagraphSpacing(int before, int after) { return GetBuffer().BeginParagraphSpacing(before, after); }
+
+    /// End paragraph spacing
+    bool EndParagraphSpacing() { return GetBuffer().EndParagraphSpacing(); }
+
+    /// Begin line spacing
+    bool BeginLineSpacing(int lineSpacing) { return GetBuffer().BeginLineSpacing(lineSpacing); }
+
+    /// End line spacing
+    bool EndLineSpacing() { return GetBuffer().EndLineSpacing(); }
+
+    /// Begin numbered bullet
+    bool BeginNumberedBullet(int bulletNumber, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_ARABIC|wxTEXT_ATTR_BULLET_STYLE_PERIOD)
+    { return GetBuffer().BeginNumberedBullet(bulletNumber, leftIndent, leftSubIndent, bulletStyle); }
+
+    /// End numbered bullet
+    bool EndNumberedBullet() { return GetBuffer().EndNumberedBullet(); }
+
+    /// Begin symbol bullet
+    bool BeginSymbolBullet(wxChar symbol, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_SYMBOL)
+    { return GetBuffer().BeginSymbolBullet(symbol, leftIndent, leftSubIndent, bulletStyle); }
+
+    /// End symbol bullet
+    bool EndSymbolBullet() { return GetBuffer().EndSymbolBullet(); }
+
+    /// Begin named character style
+    bool BeginCharacterStyle(const wxString& characterStyle) { return GetBuffer().BeginCharacterStyle(characterStyle); }
+
+    /// End named character style
+    bool EndCharacterStyle() { return GetBuffer().EndCharacterStyle(); }
+
+    /// Begin named paragraph style
+    bool BeginParagraphStyle(const wxString& paragraphStyle) { return GetBuffer().BeginParagraphStyle(paragraphStyle); }
+
+    /// End named character style
+    bool EndParagraphStyle() { return GetBuffer().EndParagraphStyle(); }
+
+    /// Sets the default style to the style under the cursor
+    bool SetDefaultStyleToCursorStyle();
+
+    /// Clear the selection
+    virtual void SelectNone();
+
+    /// Get/set the selection range in character positions. -1, -1 means no selection.
+    const wxRichTextRange& GetSelectionRange() const { return m_selectionRange; }
+    void SetSelectionRange(const wxRichTextRange& range) { m_selectionRange = range; }
+
+    /// Add a new paragraph of text to the end of the buffer
+    virtual wxRichTextRange AddParagraph(const wxString& text);
+
+    /// Add an image
+    virtual wxRichTextRange AddImage(const wxImage& image);
+
+    /// Layout the buffer: which we must do before certain operations, such as
+    /// setting the caret position.
+    virtual bool Layout();
+
+    /// Move the caret to the given character position
+    virtual bool MoveCaret(long pos, bool showAtLineStart = false);
+
+    /// Move right
+    virtual bool MoveRight(int noPositions = 1, int flags = 0);
+
+    /// Move left
+    virtual bool MoveLeft(int noPositions = 1, int flags = 0);
+
+    /// Move up
+    virtual bool MoveUp(int noLines = 1, int flags = 0);
+
+    /// Move up
+    virtual bool MoveDown(int noLines = 1, int flags = 0);
+
+    /// Move to the end of the line
+    virtual bool MoveToLineEnd(int flags = 0);
+
+    /// Move to the start of the line
+    virtual bool MoveToLineStart(int flags = 0);
+
+    /// Move to the end of the paragraph
+    virtual bool MoveToParagraphEnd(int flags = 0);
+
+    /// Move to the start of the paragraph
+    virtual bool MoveToParagraphStart(int flags = 0);
+
+    /// Move to the start of the buffer
+    virtual bool MoveHome(int flags = 0);
+
+    /// Move to the end of the buffer
+    virtual bool MoveEnd(int flags = 0);
+
+    /// Move n pages up
+    virtual bool PageUp(int noPages = 1, int flags = 0);
+
+    /// Move n pages down
+    virtual bool PageDown(int noPages = 1, int flags = 0);
+
+    /// Move n words left
+    virtual bool WordLeft(int noPages = 1, int flags = 0);
+
+    /// Move n words right
+    virtual bool WordRight(int noPages = 1, int flags = 0);
+
+    /// Returns the buffer associated with the control.
+    wxRichTextBuffer& GetBuffer() { return m_buffer; }
+    const wxRichTextBuffer& GetBuffer() const { return m_buffer; }
+
+    /// Start batching undo history for commands.
+    virtual bool BeginBatchUndo(const wxString& cmdName) { return m_buffer.BeginBatchUndo(cmdName); }
+
+    /// End batching undo history for commands.
+    virtual bool EndBatchUndo() { return m_buffer.EndBatchUndo(); }
+
+    /// Are we batching undo history for commands?
+    virtual bool BatchingUndo() const { return m_buffer.BatchingUndo(); }
+
+    /// Start suppressing undo history for commands.
+    virtual bool BeginSuppressUndo() { return m_buffer.BeginSuppressUndo(); }
+
+    /// End suppressing undo history for commands.
+    virtual bool EndSuppressUndo() { return m_buffer.EndSuppressUndo(); }
+
+    /// Are we suppressing undo history for commands?
+    virtual bool SuppressingUndo() const { return m_buffer.SuppressingUndo(); }
+
+    /// Test if this whole range has character attributes of the specified kind. If any
+    /// of the attributes are different within the range, the test fails. You
+    /// can use this to implement, for example, bold button updating. style must have
+    /// flags indicating which attributes are of interest.
+    virtual bool HasCharacterAttributes(const wxRichTextRange& range, const wxTextAttrEx& style) const
+    {
+        return GetBuffer().HasCharacterAttributes(range, style);
+    }
+    virtual bool HasCharacterAttributes(const wxRichTextRange& range, const wxRichTextAttr& style) const
+    {
+        return GetBuffer().HasCharacterAttributes(range, style);
+    }
+
+    /// Test if this whole range has paragraph attributes of the specified kind. If any
+    /// of the attributes are different within the range, the test fails. You
+    /// can use this to implement, for example, centering button updating. style must have
+    /// flags indicating which attributes are of interest.
+    virtual bool HasParagraphAttributes(const wxRichTextRange& range, const wxTextAttrEx& style) const
+    {
+        return GetBuffer().HasParagraphAttributes(range, style);
+    }
+    virtual bool HasParagraphAttributes(const wxRichTextRange& range, const wxRichTextAttr& style) const
+    {
+        return GetBuffer().HasParagraphAttributes(range, style);
+    }
+
+    /// Is all of the selection bold?
+    virtual bool IsSelectionBold() const;
+
+    /// Is all of the selection italics?
+    virtual bool IsSelectionItalics() const;
+
+    /// Is all of the selection underlined?
+    virtual bool IsSelectionUnderlined() const;
+
+    /// Is all of the selection aligned according to the specified flag?
+    virtual bool IsSelectionAligned(wxTextAttrAlignment alignment) const;
+
+    /// Apply bold to the selection
+    virtual bool ApplyBoldToSelection();
+
+    /// Apply italic to the selection
+    virtual bool ApplyItalicToSelection();
+
+    /// Apply underline to the selection
+    virtual bool ApplyUnderlineToSelection();
+
+    /// Apply alignment to the selection
+    virtual bool ApplyAlignmentToSelection(wxTextAttrAlignment alignment);
+
+    /// Set style sheet, if any.
+    void SetStyleSheet(wxRichTextStyleSheet* styleSheet) { GetBuffer().SetStyleSheet(styleSheet); }
+    wxRichTextStyleSheet* GetStyleSheet() const { return GetBuffer().GetStyleSheet(); }
+
+// Command handlers
+
+    void Command(wxCommandEvent & event);
+    void OnDropFiles(wxDropFilesEvent& event);
+
+    void OnCut(wxCommandEvent& event);
+    void OnCopy(wxCommandEvent& event);
+    void OnPaste(wxCommandEvent& event);
+    void OnUndo(wxCommandEvent& event);
+    void OnRedo(wxCommandEvent& event);
+    void OnSelectAll(wxCommandEvent& event);
+    void OnClear(wxCommandEvent& event);
+
+    void OnUpdateCut(wxUpdateUIEvent& event);
+    void OnUpdateCopy(wxUpdateUIEvent& event);
+    void OnUpdatePaste(wxUpdateUIEvent& event);
+    void OnUpdateUndo(wxUpdateUIEvent& event);
+    void OnUpdateRedo(wxUpdateUIEvent& event);
+    void OnUpdateSelectAll(wxUpdateUIEvent& event);
+    void OnUpdateClear(wxUpdateUIEvent& event);
+
+    // Show a context menu for Rich Edit controls (the standard
+    // EDIT control has one already)
+    void OnContextMenu(wxContextMenuEvent& event);
+    
+// Event handlers
+
+    /// Painting
+    void OnPaint(wxPaintEvent& event);
+    void OnEraseBackground(wxEraseEvent& event);
+
+    /// Left-click
+    void OnLeftClick(wxMouseEvent& event);
+
+    /// Left-up
+    void OnLeftUp(wxMouseEvent& event);
+
+    /// Motion
+    void OnMoveMouse(wxMouseEvent& event);
+
+    /// Left-double-click
+    void OnLeftDClick(wxMouseEvent& event);
+
+    /// Middle-click
+    void OnMiddleClick(wxMouseEvent& event);
+
+    /// Right-click
+    void OnRightClick(wxMouseEvent& event);
+
+    /// Key press
+    void OnChar(wxKeyEvent& event);
+
+    /// Sizing
+    void OnSize(wxSizeEvent& event);
+
+    /// Setting/losing focus
+    void OnSetFocus(wxFocusEvent& event);
+    void OnKillFocus(wxFocusEvent& event);
+
+// Implementation
+
+    /// Set font, and also default attributes
+    virtual bool SetFont(const wxFont& font);
+
+    /// Set up scrollbars, e.g. after a resize
+    virtual void SetupScrollbars();
+
+    /// Keyboard navigation
+    virtual bool Navigate(int keyCode, int flags);
+
+    /// Paint the background
+    virtual void PaintBackground(wxDC& dc);
+    
+    /// Recreate buffer bitmap if necessary
+    virtual bool RecreateBuffer(const wxSize& size = wxDefaultSize);
+
+    /// Set the selection
+    virtual void DoSetSelection(long from, long to, bool scrollCaret = true);
+
+    /// Write text
+    virtual void DoWriteText(const wxString& value, bool selectionOnly = true);
+
+    /// Send an update event
+    virtual bool SendUpdateEvent();
+
+    /// Init command event
+    void InitCommandEvent(wxCommandEvent& event) const;
+
+    /// do the window-specific processing after processing the update event
+    virtual void DoUpdateWindowUI(wxUpdateUIEvent& event);
+
+    /// Should we inherit colours?
+    virtual bool ShouldInheritColours() const { return false; }
+
+    /// Position the caret
+    virtual void PositionCaret();
+
+    /// Extend the selection, returning true if the selection was
+    /// changed. Selections are in caret positions.
+    virtual bool ExtendSelection(long oldPosition, long newPosition, int flags);
+
+    /// Scroll into view. This takes a _caret_ position.
+    virtual bool ScrollIntoView(long position, int keyCode);
+
+    /// The caret position is the character position just before the caret.
+    /// A value of -1 means the caret is at the start of the buffer.
+    void SetCaretPosition(long position, bool showAtLineStart = false) ;
+    long GetCaretPosition() const { return m_caretPosition; }
+
+    /// Move caret one visual step forward: this may mean setting a flag
+    /// and keeping the same position if we're going from the end of one line
+    /// to the start of the next, which may be the exact same caret position.
+    void MoveCaretForward(long oldPosition) ;
+
+    /// Move caret one visual step forward: this may mean setting a flag
+    /// and keeping the same position if we're going from the end of one line
+    /// to the start of the next, which may be the exact same caret position.
+    void MoveCaretBack(long oldPosition) ;
+
+    /// Get the caret height and position for the given character position
+    bool GetCaretPositionForIndex(long position, wxRect& rect);
+
+    /// Gets the line for the visible caret position. If the caret is
+    /// shown at the very end of the line, it means the next character is actually
+    /// on the following line. So let's get the line we're expecting to find
+    /// if this is the case.
+    wxRichTextLine* GetVisibleLineForCaretPosition(long caretPosition) const;
+
+    /// Gets the command processor
+    wxCommandProcessor* GetCommandProcessor() const { return GetBuffer().GetCommandProcessor(); }
+
+    /// Delete content if there is a selection, e.g. when pressing a key.
+    /// Returns the new caret position in newPos, or leaves it if there
+    /// was no action.
+    bool DeleteSelectedContent(long* newPos= NULL);
+
+    /// Transform logical to physical
+    wxPoint GetPhysicalPoint(const wxPoint& ptLogical);
+
+    /// Transform physical to logical
+    wxPoint GetLogicalPoint(const wxPoint& ptPhysical);
+
+    /// Finds the caret position for the next word. Direction
+    /// is 1 (forward) or -1 (backwards).
+    virtual long FindNextWordPosition(int direction = 1) const;
+
+    /// Is the given position visible on the screen?
+    bool IsPositionVisible(long pos) const;
+
+// Overrides
+
+    virtual wxSize DoGetBestSize() const ;
+
+// Data members
+private:
+
+	/// Allows nested Freeze/Thaw
+    int                     m_freezeCount;
+
+    /// Buffer bitmap
+    wxBitmap                m_bufferBitmap;
+
+    /// Text buffer
+    wxRichTextBuffer        m_buffer;
+
+    /// Filename
+    wxString                m_filename;
+
+    wxMenu*                 m_contextMenu;
+
+    /// Caret position (1 less than the character position, so -1 is the
+    /// first caret position).
+    long                    m_caretPosition;
+
+    /// Selection range in character positions. -2, -2 means no selection.
+    wxRichTextRange         m_selectionRange;
+
+    /// Anchor so we know how to extend the selection
+    /// It's a caret position since it's between two characters.
+    long                    m_selectionAnchor;
+
+    /// Are we editable?
+    bool                    m_editable;
+
+    /// Are we showing the caret position at the start of a line
+    /// instead of at the end of the previous one?
+    bool                    m_caretAtLineStart;
+
+    /// Are we dragging a selection?
+    bool                    m_dragging;
+
+    /// Start position for drag
+    wxPoint                 m_dragStart;
+};
+
+/*!
+ * wxRichTextEvent - the event class for wxRichTextCtrl notifications
+ */
+
+class WXDLLIMPEXP_ADV wxRichTextEvent : public wxNotifyEvent
+{
+public:
+    wxRichTextEvent(wxEventType commandType = wxEVT_NULL, int winid = 0)
+        : wxNotifyEvent(commandType, winid),
+        m_itemIndex(-1), m_flags(0)
+        { }
+
+    wxRichTextEvent(const wxRichTextEvent& event)
+        : wxNotifyEvent(event),
+        m_itemIndex(event.m_itemIndex), m_flags(event.m_flags)
+        { }
+
+    int GetIndex() const { return m_itemIndex; }
+    void SetIndex(int n) { m_itemIndex = n; }
+
+    int GetFlags() const { return m_flags; }
+    void SetFlags(int flags) { m_flags = flags; }
+
+    virtual wxEvent *Clone() const { return new wxRichTextEvent(*this); }
+
+protected:
+    int                 m_itemIndex;
+    int                 m_flags;
+
+private:
+    DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxRichTextEvent)
+};
+
+/*!
+ * wxRichTextCtrl event macros
+ */
+
+BEGIN_DECLARE_EVENT_TYPES()
+    DECLARE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_ITEM_SELECTED, 2600)
+    DECLARE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_ITEM_DESELECTED, 2601)
+    DECLARE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_LEFT_CLICK, 2602)
+    DECLARE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_RIGHT_CLICK, 2603)
+    DECLARE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_MIDDLE_CLICK, 2604)
+    DECLARE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_LEFT_DCLICK, 2605)
+    DECLARE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_RETURN, 2606)
+END_DECLARE_EVENT_TYPES()
+
+typedef void (wxEvtHandler::*wxRichTextEventFunction)(wxRichTextEvent&);
+
+#define EVT_RICHTEXT_ITEM_SELECTED(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_ITEM_SELECTED, id, -1, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxRichTextEventFunction, & fn ), NULL ),
+#define EVT_RICHTEXT_ITEM_DESELECTED(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_ITEM_DESELECTED, id, -1, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxRichTextEventFunction, & fn ), NULL ),
+#define EVT_RICHTEXT_LEFT_CLICK(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_LEFT_CLICK, id, -1, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxRichTextEventFunction, & fn ), NULL ),
+#define EVT_RICHTEXT_RIGHT_CLICK(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_RIGHT_CLICK, id, -1, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxRichTextEventFunction, & fn ), NULL ),
+#define EVT_RICHTEXT_MIDDLE_CLICK(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_MIDDLE_CLICK, id, -1, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxRichTextEventFunction, & fn ), NULL ),
+#define EVT_RICHTEXT_LEFT_DCLICK(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_LEFT_DCLICK, id, -1, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxRichTextEventFunction, & fn ), NULL ),
+#define EVT_RICHTEXT_RETURN(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_RICHTEXT_RETURN, id, -1, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxRichTextEventFunction, & fn ), NULL ),
+
+#endif
+    // wxUSE_RICHTEXT
+
+#endif
+    // _WX_RICHTEXTCTRL_H_
+

include/wx/richtext/richtextstyles.h

@@ -0,0 +1,242 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        richtextstyles.h
+// Purpose:     Style management for wxRichTextCtrl
+// Author:      Julian Smart
+// Modified by: 
+// Created:     2005-09-30
+// RCS-ID:      
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_RICHTEXTSTYLES_H_
+#define _WX_RICHTEXTSTYLES_H_
+
+/*!
+ * Includes
+ */
+
+#include "wx/defs.h"
+
+#if wxUSE_RICHTEXT
+
+#include "wx/richtext/richtextbuffer.h"
+
+#if wxUSE_HTML
+#include "wx/htmllbox.h"
+#endif
+
+/*!
+ * Forward declarations
+ */
+
+class WXDLLIMPEXP_ADV wxRichTextCtrl;
+class WXDLLIMPEXP_ADV wxRichTextBuffer;
+
+/*!
+ * wxRichTextStyleDefinition class declaration
+ * A base class for paragraph and character styles.
+ */
+
+class WXDLLIMPEXP_ADV wxRichTextStyleDefinition: public wxObject
+{
+    DECLARE_CLASS(wxRichTextStyleDefinition)
+public:
+
+// Constructors
+
+    wxRichTextStyleDefinition(const wxString& name = wxEmptyString) { Init(); m_name = name; }
+    ~wxRichTextStyleDefinition() {}
+
+    void Init() {}
+
+    /// The name of the style.
+    void SetName(const wxString& name) { m_name = name; }
+    const wxString& GetName() const { return m_name; }
+
+    /// The name of the style that this style is based on.
+    void SetBaseStyle(const wxString& name) { m_baseStyle = name; }
+    const wxString& GetBaseStyle() const { return m_baseStyle; }
+
+    /// The style.
+    void SetStyle(const wxRichTextAttr& style) { m_style = style; }
+    const wxRichTextAttr& GetStyle() const { return m_style; }
+    wxRichTextAttr& GetStyle() { return m_style; }
+
+protected:
+    wxString        m_name;
+    wxString        m_baseStyle;
+    wxRichTextAttr  m_style;
+};
+
+/*!
+ * wxRichTextCharacterStyleDefinition class declaration
+ */
+
+class WXDLLIMPEXP_ADV wxRichTextCharacterStyleDefinition: public wxRichTextStyleDefinition
+{
+    DECLARE_DYNAMIC_CLASS(wxRichTextCharacterStyleDefinition)
+public:
+
+// Constructors
+
+    wxRichTextCharacterStyleDefinition(const wxString& name = wxEmptyString):
+        wxRichTextStyleDefinition(name) {}
+    ~wxRichTextCharacterStyleDefinition() {}
+
+protected:
+};
+
+/*!
+ * wxRichTextParagraphStyleDefinition class declaration
+ */
+
+class WXDLLIMPEXP_ADV wxRichTextParagraphStyleDefinition: public wxRichTextStyleDefinition
+{
+    DECLARE_DYNAMIC_CLASS(wxRichTextParagraphStyleDefinition)
+public:
+
+// Constructors
+
+    wxRichTextParagraphStyleDefinition(const wxString& name = wxEmptyString):
+        wxRichTextStyleDefinition(name) {}
+    ~wxRichTextParagraphStyleDefinition() {}
+
+    /// The next style.
+    void SetNextStyle(const wxString& name) { m_nextStyle = name; }
+    const wxString& GetNextStyle() const { return m_nextStyle; }
+
+protected:
+
+    /// The next style to use when adding a paragraph after this style.
+    wxString    m_nextStyle;
+};
+
+/*!
+ * The style sheet
+ */
+
+class WXDLLIMPEXP_ADV wxRichTextStyleSheet: public wxObject
+{
+    DECLARE_CLASS( wxRichTextStyleSheet )
+
+public:
+    /// Constructors
+    wxRichTextStyleSheet() { Init(); }
+    ~wxRichTextStyleSheet() { DeleteStyles(); }
+
+    /// Initialisation
+    void Init();
+
+    /// Add a definition to the character style list
+    bool AddCharacterStyle(wxRichTextCharacterStyleDefinition* def) { return AddStyle(m_characterStyleDefinitions, def); }
+
+    /// Add a definition to the paragraph style list
+    bool AddParagraphStyle(wxRichTextParagraphStyleDefinition* def) { return AddStyle(m_paragraphStyleDefinitions, def); }
+
+    /// Remove a character style
+    bool RemoveCharacterStyle(wxRichTextStyleDefinition* def, bool deleteStyle = false) { return RemoveStyle(m_characterStyleDefinitions, def, deleteStyle); }
+
+    /// Remove a paragraph style
+    bool RemoveParagraphStyle(wxRichTextStyleDefinition* def, bool deleteStyle = false) { return RemoveStyle(m_characterStyleDefinitions, def, deleteStyle); }
+
+    /// Find a character definition by name
+    wxRichTextCharacterStyleDefinition* FindCharacterStyle(const wxString& name) const { return (wxRichTextCharacterStyleDefinition*) FindStyle(m_characterStyleDefinitions, name); }
+
+    /// Find a paragraph definition by name
+    wxRichTextParagraphStyleDefinition* FindParagraphStyle(const wxString& name) const { return (wxRichTextParagraphStyleDefinition*) FindStyle(m_characterStyleDefinitions, name); }
+
+    /// Return the number of character styes.
+    size_t GetCharacterStyleCount() const { return m_characterStyleDefinitions.GetCount(); }
+
+    /// Return the number of paragraph styes.
+    size_t GetParagraphStyleCount() const { return m_paragraphStyleDefinitions.GetCount(); }
+
+    /// Return the nth character style
+    wxRichTextCharacterStyleDefinition* GetCharacterStyle(size_t n) const { return (wxRichTextCharacterStyleDefinition*) m_characterStyleDefinitions.Item(n)->GetData(); }
+
+    /// Return the nth paragraph style
+    wxRichTextParagraphStyleDefinition* GetParagraphStyle(size_t n) const { return (wxRichTextParagraphStyleDefinition*) m_paragraphStyleDefinitions.Item(n)->GetData(); }
+
+    /// Delete all styles
+    void DeleteStyles();
+
+/// Implementation
+
+    /// Add a definition to one of the style lists
+    bool AddStyle(wxList& list, wxRichTextStyleDefinition* def);
+
+    /// Remove a style
+    bool RemoveStyle(wxList& list, wxRichTextStyleDefinition* def, bool deleteStyle);
+
+    /// Find a definition by name
+    wxRichTextStyleDefinition* FindStyle(const wxList& list, const wxString& name) const;
+
+protected:
+
+    wxList  m_characterStyleDefinitions;
+    wxList  m_paragraphStyleDefinitions;
+};
+
+#if wxUSE_HTML
+/*!
+ * wxRichTextStyleListBox class declaration
+ * A listbox to display styles.
+ */
+
+class WXDLLIMPEXP_ADV wxRichTextStyleListBox: public wxHtmlListBox
+{
+    DECLARE_CLASS(wxRichTextStyleListBox)
+    DECLARE_EVENT_TABLE()
+
+public:
+    wxRichTextStyleListBox(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition,
+        const wxSize& size = wxDefaultSize, long style = 0);
+    ~wxRichTextStyleListBox();
+
+    /// Returns the HTML for this item
+    virtual wxString OnGetItem(size_t n) const;
+
+    /// Creates a suitable HTML fragment for a definition
+    wxString CreateHTML(wxRichTextStyleDefinition* def) const;
+
+    /// Associates the control with a style manager
+    void SetStyleSheet(wxRichTextStyleSheet* styleSheet) { m_styleSheet = styleSheet; }
+    wxRichTextStyleSheet* GetStyleSheet() const { return m_styleSheet; }
+
+    /// Associates the control with a wxRichTextCtrl
+    void SetRichTextCtrl(wxRichTextCtrl* ctrl) { m_richTextCtrl = ctrl; }
+    wxRichTextCtrl* GetRichTextCtrl() const { return m_richTextCtrl; }
+
+    // Get style for index
+    wxRichTextStyleDefinition* GetStyle(size_t i) const ;
+
+    /// Updates the list
+    void UpdateStyles();
+
+    /// React to selection
+    void OnSelect(wxCommandEvent& event);
+
+    /// Left click
+    void OnLeftDown(wxMouseEvent& event);
+
+#if 0
+    virtual wxColour GetSelectedTextColour(const wxColour& colFg) const;
+    virtual wxColour GetSelectedTextBgColour(const wxColour& colBg) const;
+#endif
+
+    // Convert units in tends of a millimetre to device units
+    int ConvertTenthsMMToPixels(wxDC& dc, int units) const;
+
+private:
+
+    wxRichTextStyleSheet*   m_styleSheet;
+    wxRichTextCtrl*         m_richTextCtrl;
+};
+#endif
+
+#endif
+    // wxUSE_RICHTEXT
+
+#endif
+    // _WX_RICHTEXTSTYLES_H_

include/wx/richtext/richtextxml.h

@@ -0,0 +1,114 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        richeditxml.h
+// Purpose:     XML and HTML I/O for wxRichTextCtrl
+// Author:      Julian Smart
+// Modified by: 
+// Created:     2005-09-30
+// RCS-ID:      
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_RICHTEXTXML_H_
+#define _WX_RICHTEXTXML_H_
+
+/*!
+ * Includes
+ */
+
+#include "wx/defs.h"
+
+#if wxUSE_RICHTEXT
+
+#include "wx/richtext/richtextbuffer.h"
+
+/*!
+ * wxRichTextXMLHandler
+ */
+
+class WXDLLIMPEXP_XML wxXmlNode;
+
+class WXDLLIMPEXP_ADV wxRichTextXMLHandler: public wxRichTextFileHandler
+{
+    DECLARE_CLASS(wxRichTextXMLHandler)
+public:
+    wxRichTextXMLHandler(const wxString& name = wxT("XML"), const wxString& ext = wxT("xml"), int type = wxRICHTEXT_TYPE_XML)
+        : wxRichTextFileHandler(name, ext, type)
+        { }
+
+#if wxUSE_STREAMS
+    virtual bool LoadFile(wxRichTextBuffer *buffer, wxInputStream& stream);
+    virtual bool SaveFile(wxRichTextBuffer *buffer, wxOutputStream& stream);
+
+    /// Recursively export an object
+    bool ExportXML(wxOutputStream& stream, wxMBConv* convMem, wxMBConv* convFile, wxRichTextObject& obj, int level);
+
+    /// Recursively import an object
+    bool ImportXML(wxRichTextBuffer* buffer, wxXmlNode* node);
+
+    /// Create style parameters
+    wxString CreateStyle(const wxTextAttrEx& attr, bool isPara = false);
+
+    /// Get style parameters
+    bool GetStyle(wxTextAttrEx& attr, wxXmlNode* node, bool isPara = false);
+#endif
+
+    /// Can we save using this handler?
+    virtual bool CanSave() const { return true; }
+
+    /// Can we load using this handler?
+    virtual bool CanLoad() const { return true; }
+
+// Implementation
+
+    bool HasParam(wxXmlNode* node, const wxString& param);
+    wxXmlNode *GetParamNode(wxXmlNode* node, const wxString& param);
+    wxString GetNodeContent(wxXmlNode *node);
+    wxString GetParamValue(wxXmlNode *node, const wxString& param);
+    wxString GetText(wxXmlNode *node, const wxString& param = wxEmptyString, bool translate = false);
+
+protected:
+
+};
+
+/*!
+ * wxRichTextHTMLHandler
+ */
+
+class WXDLLIMPEXP_ADV wxRichTextHTMLHandler: public wxRichTextFileHandler
+{
+    DECLARE_CLASS(wxRichTextHTMLHandler)
+public:
+    wxRichTextHTMLHandler(const wxString& name = wxT("HTML"), const wxString& ext = wxT("html"), int type = wxRICHTEXT_TYPE_HTML)
+        : wxRichTextFileHandler(name, ext, type)
+        { }
+
+#if wxUSE_STREAMS
+    virtual bool LoadFile(wxRichTextBuffer *buffer, wxInputStream& stream);
+    virtual bool SaveFile(wxRichTextBuffer *buffer, wxOutputStream& stream);
+#endif
+
+    /// Can we save using this handler?
+    virtual bool CanSave() const { return true; }
+
+    /// Can we load using this handler?
+    virtual bool CanLoad() const { return false; }
+
+    /// Can we handle this filename (if using files)? By default, checks the extension.
+    virtual bool CanHandle(const wxString& filename) const;
+
+    /// Output character formatting
+    virtual void OutputCharacterFormatting(const wxTextAttrEx& currentStyle, const wxTextAttrEx& thisStyle, wxOutputStream& stream, bool start);
+
+    /// Output paragraph formatting
+    virtual void OutputParagraphFormatting(const wxTextAttrEx& currentStyle, const wxTextAttrEx& thisStyle, wxOutputStream& stream, bool start);
+
+protected:
+
+};
+
+#endif
+    // wxUSE_RICHTEXT
+
+#endif
+    // _WX_RICHTEXTXML_H_