]> git.saurik.com Git - wxWidgets.git/blobdiff - include/wx/richtext/richtextbuffer.h
Implement GetPageText for the OSX WebKit implementation.
[wxWidgets.git] / include / wx / richtext / richtextbuffer.h
index 8009ef9fe9adcbe6a53b131ff95059867a173822..8d73233313969d7de65bfa326371640cc9e24751 100644 (file)
@@ -22,9 +22,9 @@
 
   The top of the hierarchy is the buffer, a kind of wxRichTextParagraphLayoutBox.
   These boxes will allow flexible placement of text boxes on a page, but
 
   The top of the hierarchy is the buffer, a kind of wxRichTextParagraphLayoutBox.
   These boxes will allow flexible placement of text boxes on a page, but
-  for now there will be a single box representing the document,
-  and this box will a wxRichTextParagraphLayoutBox which contains further
-  wxRichTextParagraph objects, each of which can include text and images.
+  for now there is a single box representing the document, and this box is
+  a wxRichTextParagraphLayoutBox which contains further wxRichTextParagraph
+  objects, each of which can include text and images.
 
   Each object maintains a range (start and end position) measured
   from the start of the main parent box.
 
   Each object maintains a range (start and end position) measured
   from the start of the main parent box.
   a position relative to that text box. For now, we will not be dealing with
   embedded objects but it's something to bear in mind for later.
 
   a position relative to that text box. For now, we will not be dealing with
   embedded objects but it's something to bear in mind for later.
 
+  Note that internally, a range (5,5) represents a range of one character.
+  In the public wx[Rich]TextCtrl API, this would be passed to e.g. SetSelection
+  as (5,6). A paragraph with one character might have an internal range of (0, 1)
+  since the end of the paragraph takes up one position.
+
   Layout
   ======
 
   Layout
   ======
 
   in the vertical direction. The implementation of Layout can then
   cache the calculated size and position within the parent.
 
   in the vertical direction. The implementation of Layout can then
   cache the calculated size and position within the parent.
 
-  Note that position and size should be calculated separately, because
-  for example inserting a paragraph may result in the following paragraphs
-  moving down, but not changing in size.
-
-  Need to determine how objects specify their position. Absolute coordinates,
-  or relative to last object? May be hard to determine that. So should probably
-  be in absolute coordinates, in which case we'll need a Move virtual function
-  that allows quick movement of all elements without layout.
-
-  Let's work through a simple example of layout. Say we're laying out
-  a document with the buffer as the top box, with a wxRichTextParagraphLayoutBox
-  inside that that consists of wxRichTextParagraph objects.
-
-  We're in a mode whereby changes of window size change the width of the
-  page (useful for text editors, as opposed to word processors). The
-  window width is 600.
-
-  We pass (600, -1) to the top-level Layout (i.e. restrict size in horizontal
-  direction only). The wxRichTextBuffer box doesn't currently have
-  well-defined layout behaviour so we simply assume it has one child
-  that fills its parent (later we can define sizer-like box layout behaviour).
-  So it passes the same dimensions to the child, which is a wxRichTextParagraphLayoutBox.
-  This then looks at each child in turn (wxRichTextParagraph) and determines
-  the size the paragraph will take up, setting the cached size, and
-  splitting the paragraph into lines.
-
-  When the layout for one paragraph returns, the next paragraph is
-  fed the position of the previous, so it can position itself.
-
-  Each time Layout is called, the cached list of lines for each paragraph
-  is recreated, since it can change for example if the parent object width
-  changes.
-
-  Reporting size
-  ==============
-
-  Each object can report its size for a given range. It's important that
-  it can report a partial size, so that wrapping can be implemented,
-  hit test calculations performed, etc. So GetRangeSize must be implemented
-  for each object.
-
  */
 
 /*!
  */
 
 /*!
 #include "wx/image.h"
 #include "wx/cmdproc.h"
 #include "wx/txtstrm.h"
 #include "wx/image.h"
 #include "wx/cmdproc.h"
 #include "wx/txtstrm.h"
+#include "wx/variant.h"
 
 
-/*!
- * File types
+#if wxUSE_DATAOBJ
+#include "wx/dataobj.h"
+#endif
+
+// Compatibility
+//#define wxRichTextAttr wxTextAttr
+#define wxTextAttrEx wxTextAttr
+
+// Setting wxRICHTEXT_USE_OWN_CARET to 1 implements a
+// caret reliably without using wxClientDC in case there
+// are platform-specific problems with the generic caret.
+#if defined(__WXGTK__) || defined(__WXMAC__)
+#define wxRICHTEXT_USE_OWN_CARET 1
+#else
+#define wxRICHTEXT_USE_OWN_CARET 0
+#endif
+
+// Switch off for binary compatibility, on for faster drawing
+// Note: this seems to be buggy (overzealous use of extents) so
+// don't use for now
+#define wxRICHTEXT_USE_OPTIMIZED_LINE_DRAWING 0
+
+// The following two symbols determine whether an output implementation
+// is present. To switch the relevant one on, set wxRICHTEXT_USE_XMLDOCUMENT_OUTPUT in
+// richtextxml.cpp. By default, the faster direct output implementation is used.
+
+// Include the wxXmlDocument implementation for output
+#define wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT 1
+
+// Include the faster, direct implementation for output
+#define wxRICHTEXT_HAVE_DIRECT_OUTPUT 1
+
+/**
+    The line break character that can be embedded in content.
  */
 
  */
 
-#define wxRICHTEXT_TYPE_ANY             0
-#define wxRICHTEXT_TYPE_TEXT            1
-#define wxRICHTEXT_TYPE_XML             2
-#define wxRICHTEXT_TYPE_HTML            3
-#define wxRICHTEXT_TYPE_RTF             4
-#define wxRICHTEXT_TYPE_PDF             5
+extern WXDLLIMPEXP_RICHTEXT const wxChar wxRichTextLineBreakChar;
 
 
-/*!
- * Forward declarations
+/**
+    File types in wxRichText context.
  */
  */
+enum wxRichTextFileType
+{
+    wxRICHTEXT_TYPE_ANY = 0,
+    wxRICHTEXT_TYPE_TEXT,
+    wxRICHTEXT_TYPE_XML,
+    wxRICHTEXT_TYPE_HTML,
+    wxRICHTEXT_TYPE_RTF,
+    wxRICHTEXT_TYPE_PDF
+};
 
 
-class WXDLLIMPEXP_RICHTEXT wxRichTextCtrl;
-class WXDLLIMPEXP_RICHTEXT wxRichTextObject;
-class WXDLLIMPEXP_RICHTEXT wxRichTextCacheObject;
-class WXDLLIMPEXP_RICHTEXT wxRichTextObjectList;
-class WXDLLIMPEXP_RICHTEXT wxRichTextLine;
-class WXDLLIMPEXP_RICHTEXT wxRichTextParagraph;
-class WXDLLIMPEXP_RICHTEXT wxRichTextFragment;
-class WXDLLIMPEXP_RICHTEXT wxRichTextFileHandler;
-class WXDLLIMPEXP_RICHTEXT wxRichTextStyleSheet;
-class WXDLLIMPEXP_RICHTEXT wxTextAttrEx;
+/*
+ * Forward declarations
+ */
 
 
-/*!
- * Flags determining the available space, passed to Layout
+class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextCtrl;
+class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextObject;
+class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextImage;
+class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextCacheObject;
+class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextObjectList;
+class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextLine;
+class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextParagraph;
+class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextFileHandler;
+class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextStyleSheet;
+class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextListStyleDefinition;
+class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextEvent;
+class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextRenderer;
+class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextBuffer;
+class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextXMLHandler;
+class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextParagraphLayoutBox;
+class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextImageBlock;
+class WXDLLIMPEXP_FWD_XML      wxXmlNode;
+class                          wxRichTextFloatCollector;
+class WXDLLIMPEXP_FWD_BASE wxDataInputStream;
+class WXDLLIMPEXP_FWD_BASE wxDataOutputStream;
+
+/**
+    Flags determining the available space, passed to Layout.
  */
 
 #define wxRICHTEXT_FIXED_WIDTH      0x01
  */
 
 #define wxRICHTEXT_FIXED_WIDTH      0x01
@@ -141,543 +156,2369 @@ class WXDLLIMPEXP_RICHTEXT wxTextAttrEx;
 // the rect passed to Layout.
 #define wxRICHTEXT_LAYOUT_SPECIFIED_RECT 0x10
 
 // the rect passed to Layout.
 #define wxRICHTEXT_LAYOUT_SPECIFIED_RECT 0x10
 
-/*!
- * Flags returned from hit-testing
+/**
+    Flags to pass to Draw
  */
 
  */
 
-// The point was not on this object
-#define wxRICHTEXT_HITTEST_NONE     0x01
-// The point was before the position returned from HitTest
-#define wxRICHTEXT_HITTEST_BEFORE   0x02
-// The point was after the position returned from HitTest
-#define wxRICHTEXT_HITTEST_AFTER    0x04
-// The point was on the position returned from HitTest
-#define wxRICHTEXT_HITTEST_ON       0x08
+// Ignore paragraph cache optimization, e.g. for printing purposes
+// where one line may be drawn higher (on the next page) compared
+// with the previous line
+#define wxRICHTEXT_DRAW_IGNORE_CACHE    0x01
+#define wxRICHTEXT_DRAW_SELECTED        0x02
+#define wxRICHTEXT_DRAW_PRINT           0x04
+#define wxRICHTEXT_DRAW_GUIDELINES      0x08
 
 
-/*!
- * Flags for GetRangeSize
+/**
+    Flags returned from hit-testing, or passed to hit-test function.
+ */
+enum wxRichTextHitTestFlags
+{
+    // The point was not on this object
+    wxRICHTEXT_HITTEST_NONE =    0x01,
+
+    // The point was before the position returned from HitTest
+    wxRICHTEXT_HITTEST_BEFORE =  0x02,
+
+    // The point was after the position returned from HitTest
+    wxRICHTEXT_HITTEST_AFTER =   0x04,
+
+    // The point was on the position returned from HitTest
+    wxRICHTEXT_HITTEST_ON =      0x08,
+
+    // The point was on space outside content
+    wxRICHTEXT_HITTEST_OUTSIDE = 0x10,
+
+    // Only do hit-testing at the current level (don't traverse into top-level objects)
+    wxRICHTEXT_HITTEST_NO_NESTED_OBJECTS = 0x20,
+
+    // Ignore floating objects
+    wxRICHTEXT_HITTEST_NO_FLOATING_OBJECTS = 0x40
+};
+
+/**
+    Flags for GetRangeSize.
  */
 
 #define wxRICHTEXT_FORMATTED        0x01
 #define wxRICHTEXT_UNFORMATTED      0x02
  */
 
 #define wxRICHTEXT_FORMATTED        0x01
 #define wxRICHTEXT_UNFORMATTED      0x02
+#define wxRICHTEXT_CACHE_SIZE       0x04
+#define wxRICHTEXT_HEIGHT_ONLY      0x08
 
 
-/*!
- * Extra formatting flags not in wxTextAttr
+/**
+    Flags for SetStyle/SetListStyle.
  */
 
  */
 
-#define wxTEXT_ATTR_PARA_SPACING_AFTER      0x00000800
-#define wxTEXT_ATTR_PARA_SPACING_BEFORE     0x00001000
-#define wxTEXT_ATTR_LINE_SPACING            0x00002000
-#define wxTEXT_ATTR_CHARACTER_STYLE_NAME    0x00004000
-#define wxTEXT_ATTR_PARAGRAPH_STYLE_NAME    0x00008000
-#define wxTEXT_ATTR_BULLET_STYLE            0x00010000
-#define wxTEXT_ATTR_BULLET_NUMBER           0x00020000
-#define wxTEXT_ATTR_BULLET_SYMBOL           0x00040000
+#define wxRICHTEXT_SETSTYLE_NONE            0x00
 
 
-/*!
- * Styles for wxTextAttrEx::SetBulletStyle
+// Specifies that this operation should be undoable
+#define wxRICHTEXT_SETSTYLE_WITH_UNDO       0x01
+
+// Specifies that the style should not be applied if the
+// combined style at this point is already the style in question.
+#define wxRICHTEXT_SETSTYLE_OPTIMIZE        0x02
+
+// Specifies that the style should only be applied to paragraphs,
+// and not the content. This allows content styling to be
+// preserved independently from that of e.g. a named paragraph style.
+#define wxRICHTEXT_SETSTYLE_PARAGRAPHS_ONLY 0x04
+
+// Specifies that the style should only be applied to characters,
+// and not the paragraph. This allows content styling to be
+// preserved independently from that of e.g. a named paragraph style.
+#define wxRICHTEXT_SETSTYLE_CHARACTERS_ONLY 0x08
+
+// For SetListStyle only: specifies starting from the given number, otherwise
+// deduces number from existing attributes
+#define wxRICHTEXT_SETSTYLE_RENUMBER        0x10
+
+// For SetListStyle only: specifies the list level for all paragraphs, otherwise
+// the current indentation will be used
+#define wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL   0x20
+
+// Resets the existing style before applying the new style
+#define wxRICHTEXT_SETSTYLE_RESET           0x40
+
+// Removes the given style instead of applying it
+#define wxRICHTEXT_SETSTYLE_REMOVE          0x80
+
+/**
+    Flags for object insertion.
  */
 
  */
 
-#define wxTEXT_ATTR_BULLET_STYLE_NONE           0x0000
-#define wxTEXT_ATTR_BULLET_STYLE_ARABIC         0x0001
-#define wxTEXT_ATTR_BULLET_STYLE_LETTERS_UPPER  0x0002
-#define wxTEXT_ATTR_BULLET_STYLE_LETTERS_LOWER  0x0004
-#define wxTEXT_ATTR_BULLET_STYLE_ROMAN_UPPER    0x0008
-#define wxTEXT_ATTR_BULLET_STYLE_ROMAN_LOWER    0x0010
-#define wxTEXT_ATTR_BULLET_STYLE_SYMBOL         0x0020
-#define wxTEXT_ATTR_BULLET_STYLE_BITMAP         0x0040
-#define wxTEXT_ATTR_BULLET_STYLE_PARENTHESES    0x0080
-#define wxTEXT_ATTR_BULLET_STYLE_PERIOD         0x0100
+#define wxRICHTEXT_INSERT_NONE                              0x00
+#define wxRICHTEXT_INSERT_WITH_PREVIOUS_PARAGRAPH_STYLE     0x01
+#define wxRICHTEXT_INSERT_INTERACTIVE                       0x02
 
 
-/*!
- * Line spacing values
+// A special flag telling the buffer to keep the first paragraph style
+// as-is, when deleting a paragraph marker. In future we might pass a
+// flag to InsertFragment and DeleteRange to indicate the appropriate mode.
+#define wxTEXT_ATTR_KEEP_FIRST_PARA_STYLE   0x10000000
+
+/**
+    Default superscript/subscript font multiplication factor.
  */
 
  */
 
-#define wxTEXT_ATTR_LINE_SPACING_NORMAL         10
-#define wxTEXT_ATTR_LINE_SPACING_HALF           15
-#define wxTEXT_ATTR_LINE_SPACING_TWICE          20
+#define wxSCRIPT_MUL_FACTOR             1.5
 
 
-/*!
- * wxRichTextRange class declaration
- * This stores beginning and end positions for a range of data.
+/**
+    The type for wxTextAttrDimension flags.
+ */
+typedef unsigned short wxTextAttrDimensionFlags;
+
+/**
+    Miscellaneous text box flags
+ */
+enum wxTextBoxAttrFlags
+{
+    wxTEXT_BOX_ATTR_FLOAT                   = 0x00000001,
+    wxTEXT_BOX_ATTR_CLEAR                   = 0x00000002,
+    wxTEXT_BOX_ATTR_COLLAPSE_BORDERS        = 0x00000004,
+    wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT      = 0x00000008
+};
+
+/**
+    Whether a value is present, used in dimension flags.
+ */
+enum wxTextAttrValueFlags
+{
+    wxTEXT_ATTR_VALUE_VALID               = 0x1000,
+    wxTEXT_ATTR_VALUE_VALID_MASK          = 0x1000
+};
+
+/**
+    Units, included in the dimension value.
+ */
+enum wxTextAttrUnits
+{
+    wxTEXT_ATTR_UNITS_TENTHS_MM             = 0x0001,
+    wxTEXT_ATTR_UNITS_PIXELS                = 0x0002,
+    wxTEXT_ATTR_UNITS_PERCENTAGE            = 0x0004,
+    wxTEXT_ATTR_UNITS_POINTS                = 0x0008,
+
+    wxTEXT_ATTR_UNITS_MASK                  = 0x000F
+};
+
+/**
+    Position alternatives, included in the dimension flags.
+ */
+enum wxTextBoxAttrPosition
+{
+    wxTEXT_BOX_ATTR_POSITION_STATIC         = 0x0000, // Default is static, i.e. as per normal layout
+    wxTEXT_BOX_ATTR_POSITION_RELATIVE       = 0x0010, // Relative to the relevant edge
+    wxTEXT_BOX_ATTR_POSITION_ABSOLUTE       = 0x0020,
+
+    wxTEXT_BOX_ATTR_POSITION_MASK           = 0x00F0
+};
+
+/**
+    @class wxTextAttrDimension
+
+    A class representing a rich text dimension, including units and position.
+
+    @library{wxrichtext}
+    @category{richtext}
+
+    @see wxRichTextAttr, wxRichTextCtrl,  wxTextAttrDimensions
+*/
+
+class WXDLLIMPEXP_RICHTEXT wxTextAttrDimension
+{
+public:
+    /**
+        Default constructor.
+    */
+    wxTextAttrDimension() { Reset(); }
+    /**
+        Constructor taking value and units flag.
+    */
+    wxTextAttrDimension(int value, wxTextAttrUnits units = wxTEXT_ATTR_UNITS_TENTHS_MM) { m_value = value; m_flags = units|wxTEXT_ATTR_VALUE_VALID; }
+
+    /**
+        Resets the dimension value and flags.
+    */
+    void Reset() { m_value = 0; m_flags = 0; }
+
+    /**
+        Partial equality test.
+    */
+    bool EqPartial(const wxTextAttrDimension& dim) const;
+
+    /** Apply the dimension, but not those identical to @a compareWith if present.
+    */
+    bool Apply(const wxTextAttrDimension& dim, const wxTextAttrDimension* compareWith = NULL);
+
+    /** Collects the attributes that are common to a range of content, building up a note of
+        which attributes are absent in some objects and which clash in some objects.
+    */
+    void CollectCommonAttributes(const wxTextAttrDimension& attr, wxTextAttrDimension& clashingAttr, wxTextAttrDimension& absentAttr);
+
+    /**
+        Equality operator.
+    */
+    bool operator==(const wxTextAttrDimension& dim) const { return m_value == dim.m_value && m_flags == dim.m_flags; }
+
+    /**
+        Returns the integer value of the dimension.
+    */
+    int GetValue() const { return m_value; }
+
+    /**
+        Returns the floating-pointing value of the dimension in mm.
+
+    */
+    float GetValueMM() const { return float(m_value) / 10.0; }
+
+    /**
+        Sets the value of the dimension in mm.
+    */
+    void SetValueMM(float value) { m_value = (int) ((value * 10.0) + 0.5); m_flags |= wxTEXT_ATTR_VALUE_VALID; }
+
+    /**
+        Sets the integer value of the dimension.
+    */
+    void SetValue(int value) { m_value = value; m_flags |= wxTEXT_ATTR_VALUE_VALID; }
+
+    /**
+        Sets the integer value of the dimension, passing dimension flags.
+    */
+    void SetValue(int value, wxTextAttrDimensionFlags flags) { SetValue(value); m_flags = flags; }
+
+    /**
+        Sets the integer value and units.
+    */
+    void SetValue(int value, wxTextAttrUnits units) { m_value = value; m_flags = units | wxTEXT_ATTR_VALUE_VALID; }
+
+    /**
+        Sets the dimension.
+    */
+    void SetValue(const wxTextAttrDimension& dim) { (*this) = dim; }
+
+    /**
+        Gets the units of the dimension.
+    */
+    wxTextAttrUnits GetUnits() const { return (wxTextAttrUnits) (m_flags & wxTEXT_ATTR_UNITS_MASK); }
+
+    /**
+        Sets the units of the dimension.
+    */
+    void SetUnits(wxTextAttrUnits units) { m_flags &= ~wxTEXT_ATTR_UNITS_MASK; m_flags |= units; }
+
+    /**
+        Gets the position flags.
+    */
+    wxTextBoxAttrPosition GetPosition() const { return (wxTextBoxAttrPosition) (m_flags & wxTEXT_BOX_ATTR_POSITION_MASK); }
+
+    /**
+        Sets the position flags.
+    */
+    void SetPosition(wxTextBoxAttrPosition pos) { m_flags &= ~wxTEXT_BOX_ATTR_POSITION_MASK; m_flags |= pos; }
+
+    /**
+        Returns @true if the dimension is valid.
+    */
+    bool IsValid() const { return (m_flags & wxTEXT_ATTR_VALUE_VALID) != 0; }
+
+    /**
+        Sets the valid flag.
+    */
+    void SetValid(bool b) { m_flags &= ~wxTEXT_ATTR_VALUE_VALID_MASK; m_flags |= (b ? wxTEXT_ATTR_VALUE_VALID : 0); }
+
+    /**
+        Gets the dimension flags.
+    */
+    wxTextAttrDimensionFlags GetFlags() const { return m_flags; }
+
+    /**
+        Sets the dimension flags.
+    */
+    void SetFlags(wxTextAttrDimensionFlags flags) { m_flags = flags; }
+
+    int                         m_value;
+    wxTextAttrDimensionFlags    m_flags;
+};
+
+/**
+    @class wxTextAttrDimensions
+    A class for left, right, top and bottom dimensions.
+
+    @library{wxrichtext}
+    @category{richtext}
+
+    @see wxRichTextAttr, wxRichTextCtrl, wxTextAttrDimension
+*/
+
+class WXDLLIMPEXP_RICHTEXT wxTextAttrDimensions
+{
+public:
+    /**
+        Default constructor.
+    */
+    wxTextAttrDimensions() {}
+
+    /**
+        Resets the value and flags for all dimensions.
+    */
+    void Reset() { m_left.Reset(); m_top.Reset(); m_right.Reset(); m_bottom.Reset(); }
+
+    /**
+        Equality operator.
+    */
+    bool operator==(const wxTextAttrDimensions& dims) const { return m_left == dims.m_left && m_top == dims.m_top && m_right == dims.m_right && m_bottom == dims.m_bottom; }
+
+    /**
+        Partial equality test.
+
+    */
+    bool EqPartial(const wxTextAttrDimensions& dims) const;
+
+    /**
+        Apply border to 'this', but not if the same as @a compareWith.
+
+    */
+    bool Apply(const wxTextAttrDimensions& dims, const wxTextAttrDimensions* compareWith = NULL);
+
+    /**
+        Collects the attributes that are common to a range of content, building up a note of
+        which attributes are absent in some objects and which clash in some objects.
+
+    */
+    void CollectCommonAttributes(const wxTextAttrDimensions& attr, wxTextAttrDimensions& clashingAttr, wxTextAttrDimensions& absentAttr);
+
+    /**
+        Remove specified attributes from this object.
+    */
+    bool RemoveStyle(const wxTextAttrDimensions& attr);
+
+    /**
+        Gets the left dimension.
+    */
+    const wxTextAttrDimension& GetLeft() const { return m_left; }
+    wxTextAttrDimension& GetLeft() { return m_left; }
+
+    /**
+        Gets the right dimension.
+
+    */
+    const wxTextAttrDimension& GetRight() const { return m_right; }
+    wxTextAttrDimension& GetRight() { return m_right; }
+
+    /**
+        Gets the top dimension.
+
+    */
+    const wxTextAttrDimension& GetTop() const { return m_top; }
+    wxTextAttrDimension& GetTop() { return m_top; }
+
+    /**
+        Gets the bottom dimension.
+
+    */
+    const wxTextAttrDimension& GetBottom() const { return m_bottom; }
+    wxTextAttrDimension& GetBottom() { return m_bottom; }
+
+    wxTextAttrDimension         m_left;
+    wxTextAttrDimension         m_top;
+    wxTextAttrDimension         m_right;
+    wxTextAttrDimension         m_bottom;
+};
+
+/**
+    @class wxTextAttrSize
+    A class for representing width and height.
+
+    @library{wxrichtext}
+    @category{richtext}
+
+    @see wxRichTextAttr, wxRichTextCtrl, wxTextAttrDimension
+*/
+
+class WXDLLIMPEXP_RICHTEXT wxTextAttrSize
+{
+public:
+    /**
+        Default constructor.
+    */
+    wxTextAttrSize() {}
+
+    /**
+        Resets the width and height dimensions.
+    */
+    void Reset() { m_width.Reset(); m_height.Reset(); }
+
+    /**
+        Equality operator.
+    */
+    bool operator==(const wxTextAttrSize& size) const { return m_width == size.m_width && m_height == size.m_height ; }
+
+    /**
+        Partial equality test.
+    */
+    bool EqPartial(const wxTextAttrSize& dims) const;
+
+    /**
+        Apply border to this object, but not if the same as @a compareWith.
+    */
+    bool Apply(const wxTextAttrSize& dims, const wxTextAttrSize* compareWith = NULL);
+
+    /**
+        Collects the attributes that are common to a range of content, building up a note of
+        which attributes are absent in some objects and which clash in some objects.
+    */
+    void CollectCommonAttributes(const wxTextAttrSize& attr, wxTextAttrSize& clashingAttr, wxTextAttrSize& absentAttr);
+
+    /**
+        Removes the specified attributes from this object.
+    */
+    bool RemoveStyle(const wxTextAttrSize& attr);
+
+    /**
+        Returns the width.
+    */
+    wxTextAttrDimension& GetWidth() { return m_width; }
+    const wxTextAttrDimension& GetWidth() const { return m_width; }
+
+    /**
+        Sets the width.
+    */
+    void SetWidth(int value, wxTextAttrDimensionFlags flags) { m_width.SetValue(value, flags); }
+    /**
+        Sets the width.
+    */
+    void SetWidth(int value, wxTextAttrUnits units) { m_width.SetValue(value, units); }
+    /**
+        Sets the width.
+    */
+    void SetWidth(const wxTextAttrDimension& dim) { m_width.SetValue(dim); }
+
+    /**
+        Gets the height.
+    */
+    wxTextAttrDimension& GetHeight() { return m_height; }
+    const wxTextAttrDimension& GetHeight() const { return m_height; }
+
+    /**
+        Sets the height.
+    */
+    void SetHeight(int value, wxTextAttrDimensionFlags flags) { m_height.SetValue(value, flags); }
+    /**
+        Sets the height.
+    */
+    void SetHeight(int value, wxTextAttrUnits units) { m_height.SetValue(value, units); }
+    /**
+        Sets the height.
+    */
+    void SetHeight(const wxTextAttrDimension& dim) { m_height.SetValue(dim); }
+
+    wxTextAttrDimension         m_width;
+    wxTextAttrDimension         m_height;
+};
+
+/**
+    @class wxTextAttrDimensionConverter
+    A class to make it easier to convert dimensions.
+
+    @library{wxrichtext}
+    @category{richtext}
+
+    @see wxRichTextAttr, wxRichTextCtrl, wxTextAttrDimension
+*/
+
+class WXDLLIMPEXP_RICHTEXT wxTextAttrDimensionConverter
+{
+public:
+    /**
+        Constructor.
+    */
+    wxTextAttrDimensionConverter(wxDC& dc, double scale = 1.0, const wxSize& parentSize = wxDefaultSize);
+    /**
+        Constructor.
+    */
+    wxTextAttrDimensionConverter(int ppi, double scale = 1.0, const wxSize& parentSize = wxDefaultSize);
+
+    /**
+        Gets the pixel size for the given dimension.
+    */
+    int GetPixels(const wxTextAttrDimension& dim, int direction = wxHORIZONTAL) const;
+    /**
+        Gets the mm size for the given dimension.
+    */
+    int GetTenthsMM(const wxTextAttrDimension& dim) const;
+
+    /**
+        Converts tenths of a mm to pixels.
+    */
+    int ConvertTenthsMMToPixels(int units) const;
+    /**
+        Converts pixels to tenths of a mm.
+    */
+    int ConvertPixelsToTenthsMM(int pixels) const;
+
+    int     m_ppi;
+    double  m_scale;
+    wxSize  m_parentSize;
+};
+
+/**
+    Border styles, used with wxTextAttrBorder.
+ */
+enum wxTextAttrBorderStyle
+{
+    wxTEXT_BOX_ATTR_BORDER_NONE             = 0,
+    wxTEXT_BOX_ATTR_BORDER_SOLID            = 1,
+    wxTEXT_BOX_ATTR_BORDER_DOTTED           = 2,
+    wxTEXT_BOX_ATTR_BORDER_DASHED           = 3,
+    wxTEXT_BOX_ATTR_BORDER_DOUBLE           = 4,
+    wxTEXT_BOX_ATTR_BORDER_GROOVE           = 5,
+    wxTEXT_BOX_ATTR_BORDER_RIDGE            = 6,
+    wxTEXT_BOX_ATTR_BORDER_INSET            = 7,
+    wxTEXT_BOX_ATTR_BORDER_OUTSET           = 8
+};
+
+/**
+    Border style presence flags, used with wxTextAttrBorder.
+ */
+enum wxTextAttrBorderFlags
+{
+    wxTEXT_BOX_ATTR_BORDER_STYLE            = 0x0001,
+    wxTEXT_BOX_ATTR_BORDER_COLOUR           = 0x0002
+};
+
+/**
+    Border width symbols for qualitative widths, used with wxTextAttrBorder.
+ */
+enum wxTextAttrBorderWidth
+{
+    wxTEXT_BOX_ATTR_BORDER_THIN             = -1,
+    wxTEXT_BOX_ATTR_BORDER_MEDIUM           = -2,
+    wxTEXT_BOX_ATTR_BORDER_THICK            = -3
+};
+
+/**
+    Float styles.
+ */
+enum wxTextBoxAttrFloatStyle
+{
+    wxTEXT_BOX_ATTR_FLOAT_NONE              = 0,
+    wxTEXT_BOX_ATTR_FLOAT_LEFT              = 1,
+    wxTEXT_BOX_ATTR_FLOAT_RIGHT             = 2
+};
+
+/**
+    Clear styles.
+ */
+enum wxTextBoxAttrClearStyle
+{
+    wxTEXT_BOX_ATTR_CLEAR_NONE              = 0,
+    wxTEXT_BOX_ATTR_CLEAR_LEFT              = 1,
+    wxTEXT_BOX_ATTR_CLEAR_RIGHT             = 2,
+    wxTEXT_BOX_ATTR_CLEAR_BOTH              = 3
+};
+
+/**
+    Collapse mode styles. TODO: can they be switched on per side?
+ */
+enum wxTextBoxAttrCollapseMode
+{
+    wxTEXT_BOX_ATTR_COLLAPSE_NONE           = 0,
+    wxTEXT_BOX_ATTR_COLLAPSE_FULL           = 1
+};
+
+/**
+    Vertical alignment values.
  */
  */
+enum wxTextBoxAttrVerticalAlignment
+{
+    wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_NONE =       0,
+    wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_TOP  =       1,
+    wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_CENTRE =     2,
+    wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_BOTTOM  =    3
+};
+
+/**
+    @class wxTextAttrBorder
+    A class representing a rich text object border.
+
+    @library{wxrichtext}
+    @category{richtext}
+
+    @see wxRichTextAttr, wxRichTextCtrl, wxRichTextAttrBorders
+*/
+
+class WXDLLIMPEXP_RICHTEXT wxTextAttrBorder
+{
+public:
+    /**
+        Default constructor.
+    */
+    wxTextAttrBorder() { Reset(); }
+
+    /**
+        Equality operator.
+    */
+    bool operator==(const wxTextAttrBorder& border) const
+    {
+        return m_flags == border.m_flags && m_borderStyle == border.m_borderStyle &&
+               m_borderColour == border.m_borderColour && m_borderWidth == border.m_borderWidth;
+    }
+
+    /**
+        Resets the border style, colour, width and flags.
+    */
+    void Reset() { m_borderStyle = 0; m_borderColour = 0; m_flags = 0; m_borderWidth.Reset(); }
+
+    /**
+        Partial equality test.
+    */
+    bool EqPartial(const wxTextAttrBorder& border) const;
+
+    /**
+        Applies the border to this object, but not if the same as @a compareWith.
+
+    */
+    bool Apply(const wxTextAttrBorder& border, const wxTextAttrBorder* compareWith = NULL);
+
+    /**
+        Removes the specified attributes from this object.
+    */
+    bool RemoveStyle(const wxTextAttrBorder& attr);
+
+    /**
+        Collects the attributes that are common to a range of content, building up a note of
+        which attributes are absent in some objects and which clash in some objects.
+    */
+    void CollectCommonAttributes(const wxTextAttrBorder& attr, wxTextAttrBorder& clashingAttr, wxTextAttrBorder& absentAttr);
+
+    /**
+        Sets the border style.
+    */
+    void SetStyle(int style) { m_borderStyle = style; m_flags |= wxTEXT_BOX_ATTR_BORDER_STYLE; }
+
+    /**
+        Gets the border style.
+
+    */
+    int GetStyle() const { return m_borderStyle; }
+
+    /**
+        Sets the border colour.
+    */
+    void SetColour(unsigned long colour) { m_borderColour = colour; m_flags |= wxTEXT_BOX_ATTR_BORDER_COLOUR; }
+
+    /**
+        Sets the border colour.
+    */
+    void SetColour(const wxColour& colour) { m_borderColour = colour.GetRGB(); m_flags |= wxTEXT_BOX_ATTR_BORDER_COLOUR; }
+
+    /**
+        Gets the colour as a long.
+    */
+    unsigned long GetColourLong() const { return m_borderColour; }
+
+    /**
+        Gets the colour.
+    */
+    wxColour GetColour() const { return wxColour(m_borderColour); }
+
+    /**
+        Gets the border width.
+    */
+    wxTextAttrDimension& GetWidth() { return m_borderWidth; }
+    const wxTextAttrDimension& GetWidth() const { return m_borderWidth; }
+
+    /**
+        Sets the border width.
+    */
+    void SetWidth(const wxTextAttrDimension& width) { m_borderWidth = width; }
+    /**
+        Sets the border width.
+    */
+    void SetWidth(int value, wxTextAttrUnits units = wxTEXT_ATTR_UNITS_TENTHS_MM) { SetWidth(wxTextAttrDimension(value, units)); }
+
+    /**
+        True if the border has a valid style.
+    */
+    bool HasStyle() const { return (m_flags & wxTEXT_BOX_ATTR_BORDER_STYLE) != 0; }
+
+    /**
+        True if the border has a valid colour.
+    */
+    bool HasColour() const { return (m_flags & wxTEXT_BOX_ATTR_BORDER_COLOUR) != 0; }
+
+    /**
+        True if the border has a valid width.
+    */
+    bool HasWidth() const { return m_borderWidth.IsValid(); }
+
+    /**
+        True if the border is valid.
+    */
+    bool IsValid() const { return HasWidth(); }
+
+    /**
+        Set the valid flag for this border.
+    */
+    void MakeValid() { m_borderWidth.SetValid(true); }
+
+    /**
+        Returns the border flags.
+    */
+    int GetFlags() const { return m_flags; }
+
+    /**
+        Sets the border flags.
+    */
+    void SetFlags(int flags) { m_flags = flags; }
+
+    /**
+        Adds a border flag.
+    */
+    void AddFlag(int flag) { m_flags |= flag; }
+
+    /**
+        Removes a border flag.
+    */
+    void RemoveFlag(int flag) { m_flags &= ~flag; }
+
+    int                         m_borderStyle;
+    unsigned long               m_borderColour;
+    wxTextAttrDimension         m_borderWidth;
+    int                         m_flags;
+};
+
+/**
+    @class wxTextAttrBorders
+    A class representing a rich text object's borders.
+
+    @library{wxrichtext}
+    @category{richtext}
+
+    @see wxRichTextAttr, wxRichTextCtrl, wxRichTextAttrBorder
+*/
+
+class WXDLLIMPEXP_RICHTEXT wxTextAttrBorders
+{
+public:
+    /**
+        Default constructor.
+    */
+    wxTextAttrBorders() { }
+
+    /**
+        Equality operator.
+    */
+    bool operator==(const wxTextAttrBorders& borders) const
+    {
+        return m_left == borders.m_left && m_right == borders.m_right &&
+               m_top == borders.m_top && m_bottom == borders.m_bottom;
+    }
+
+    /**
+        Sets the style of all borders.
+    */
+    void SetStyle(int style);
+
+    /**
+        Sets colour of all borders.
+    */
+    void SetColour(unsigned long colour);
+
+    /**
+        Sets the colour for all borders.
+    */
+    void SetColour(const wxColour& colour);
+
+    /**
+        Sets the width of all borders.
+    */
+    void SetWidth(const wxTextAttrDimension& width);
+
+    /**
+        Sets the width of all borders.
+    */
+    void SetWidth(int value, wxTextAttrUnits units = wxTEXT_ATTR_UNITS_TENTHS_MM) { SetWidth(wxTextAttrDimension(value, units)); }
+
+    /**
+        Resets all borders.
+    */
+    void Reset() { m_left.Reset(); m_right.Reset(); m_top.Reset(); m_bottom.Reset(); }
+
+    /**
+        Partial equality test.
+    */
+    bool EqPartial(const wxTextAttrBorders& borders) const;
+
+    /**
+        Applies border to this object, but not if the same as @a compareWith.
+    */
+    bool Apply(const wxTextAttrBorders& borders, const wxTextAttrBorders* compareWith = NULL);
+
+    /**
+        Removes the specified attributes from this object.
+    */
+    bool RemoveStyle(const wxTextAttrBorders& attr);
+
+    /**
+        Collects the attributes that are common to a range of content, building up a note of
+        which attributes are absent in some objects and which clash in some objects.
+    */
+    void CollectCommonAttributes(const wxTextAttrBorders& attr, wxTextAttrBorders& clashingAttr, wxTextAttrBorders& absentAttr);
+
+    /**
+        Returns @true if all borders are valid.
+    */
+    bool IsValid() const { return m_left.IsValid() || m_right.IsValid() || m_top.IsValid() || m_bottom.IsValid(); }
+
+    /**
+        Returns the left border.
+    */
+    const wxTextAttrBorder& GetLeft() const { return m_left; }
+    wxTextAttrBorder& GetLeft() { return m_left; }
+
+    /**
+        Returns the right border.
+    */
+    const wxTextAttrBorder& GetRight() const { return m_right; }
+    wxTextAttrBorder& GetRight() { return m_right; }
+
+    /**
+        Returns the top border.
+    */
+    const wxTextAttrBorder& GetTop() const { return m_top; }
+    wxTextAttrBorder& GetTop() { return m_top; }
+
+    /**
+        Returns the bottom border.
+    */
+    const wxTextAttrBorder& GetBottom() const { return m_bottom; }
+    wxTextAttrBorder& GetBottom() { return m_bottom; }
+
+    wxTextAttrBorder m_left, m_right, m_top, m_bottom;
+
+};
+
+/**
+    @class wxTextBoxAttr
+    A class representing the box attributes of a rich text object.
+
+    @library{wxrichtext}
+    @category{richtext}
+
+    @see wxRichTextAttr, wxRichTextCtrl
+*/
+
+class WXDLLIMPEXP_RICHTEXT wxTextBoxAttr
+{
+public:
+    /**
+        Default constructor.
+    */
+    wxTextBoxAttr() { Init(); }
+
+    /**
+        Copy constructor.
+    */
+    wxTextBoxAttr(const wxTextBoxAttr& attr) { Init(); (*this) = attr; }
+
+    /**
+        Initialises this object.
+    */
+    void Init() { Reset(); }
+
+    /**
+        Resets this object.
+    */
+    void Reset();
+
+    // Copy. Unnecessary since we let it do a binary copy
+    //void Copy(const wxTextBoxAttr& attr);
+
+    // Assignment
+    //void operator= (const wxTextBoxAttr& attr);
+
+    /**
+        Equality test.
+    */
+    bool operator== (const wxTextBoxAttr& attr) const;
+
+    /**
+        Partial equality test, ignoring unset attributes.
+
+    */
+    bool EqPartial(const wxTextBoxAttr& attr) const;
+
+    /**
+        Merges the given attributes. If @a compareWith is non-NULL, then it will be used
+        to mask out those attributes that are the same in style and @a compareWith, for
+        situations where we don't want to explicitly set inherited attributes.
+    */
+    bool Apply(const wxTextBoxAttr& style, const wxTextBoxAttr* compareWith = NULL);
+
+    /**
+        Collects the attributes that are common to a range of content, building up a note of
+        which attributes are absent in some objects and which clash in some objects.
+    */
+    void CollectCommonAttributes(const wxTextBoxAttr& attr, wxTextBoxAttr& clashingAttr, wxTextBoxAttr& absentAttr);
+
+    /**
+        Removes the specified attributes from this object.
+    */
+    bool RemoveStyle(const wxTextBoxAttr& attr);
+
+    /**
+        Sets the flags.
+    */
+    void SetFlags(int flags) { m_flags = flags; }
+
+    /**
+        Returns the flags.
+    */
+    int GetFlags() const { return m_flags; }
+
+    /**
+        Is this flag present?
+    */
+    bool HasFlag(wxTextBoxAttrFlags flag) const { return (m_flags & flag) != 0; }
+
+    /**
+        Removes this flag.
+    */
+    void RemoveFlag(wxTextBoxAttrFlags flag) { m_flags &= ~flag; }
+
+    /**
+        Adds this flag.
+    */
+    void AddFlag(wxTextBoxAttrFlags flag) { m_flags |= flag; }
+
+    /**
+        Returns @true if no attributes are set.
+    */
+    bool IsDefault() const;
+
+    /**
+        Returns the float mode.
+    */
+    wxTextBoxAttrFloatStyle GetFloatMode() const { return m_floatMode; }
+
+    /**
+        Sets the float mode.
+    */
+    void SetFloatMode(wxTextBoxAttrFloatStyle mode) { m_floatMode = mode; m_flags |= wxTEXT_BOX_ATTR_FLOAT; }
+
+    /**
+        Returns @true if float mode is active.
+    */
+    bool HasFloatMode() const { return HasFlag(wxTEXT_BOX_ATTR_FLOAT); }
+
+    /**
+        Returns @true if this object is floating.
+    */
+    bool IsFloating() const { return HasFloatMode() && GetFloatMode() != wxTEXT_BOX_ATTR_FLOAT_NONE; }
+
+    /**
+        Returns the clear mode - whether to wrap text after object. Currently unimplemented.
+    */
+    wxTextBoxAttrClearStyle GetClearMode() const { return m_clearMode; }
+
+    /**
+        Set the clear mode. Currently unimplemented.
+    */
+    void SetClearMode(wxTextBoxAttrClearStyle mode) { m_clearMode = mode; m_flags |= wxTEXT_BOX_ATTR_CLEAR; }
+
+    /**
+        Returns @true if we have a clear flag.
+    */
+    bool HasClearMode() const { return HasFlag(wxTEXT_BOX_ATTR_CLEAR); }
+
+    /**
+        Returns the collapse mode - whether to collapse borders. Currently unimplemented.
+    */
+    wxTextBoxAttrCollapseMode GetCollapseBorders() const { return m_collapseMode; }
+
+    /**
+        Sets the collapse mode - whether to collapse borders. Currently unimplemented.
+    */
+    void SetCollapseBorders(wxTextBoxAttrCollapseMode collapse) { m_collapseMode = collapse; m_flags |= wxTEXT_BOX_ATTR_COLLAPSE_BORDERS; }
+
+    /**
+        Returns @true if the collapse borders flag is present.
+    */
+    bool HasCollapseBorders() const { return HasFlag(wxTEXT_BOX_ATTR_COLLAPSE_BORDERS); }
+
+    /**
+        Returns the vertical alignment.
+    */
+    wxTextBoxAttrVerticalAlignment GetVerticalAlignment() const { return m_verticalAlignment; }
+
+    /**
+        Sets the vertical alignment.
+    */
+    void SetVerticalAlignment(wxTextBoxAttrVerticalAlignment verticalAlignment) { m_verticalAlignment = verticalAlignment; m_flags |= wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT; }
+
+    /**
+        Returns @true if a vertical alignment flag is present.
+    */
+    bool HasVerticalAlignment() const { return HasFlag(wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT); }
+
+    /**
+        Returns the margin values.
+    */
+    wxTextAttrDimensions& GetMargins() { return m_margins; }
+    const wxTextAttrDimensions& GetMargins() const { return m_margins; }
+
+    /**
+        Returns the left margin.
+    */
+    wxTextAttrDimension& GetLeftMargin() { return m_margins.m_left; }
+    const wxTextAttrDimension& GetLeftMargin() const { return m_margins.m_left; }
+
+    /**
+        Returns the right margin.
+    */
+    wxTextAttrDimension& GetRightMargin() { return m_margins.m_right; }
+    const wxTextAttrDimension& GetRightMargin() const { return m_margins.m_right; }
+
+    /**
+        Returns the top margin.
+    */
+    wxTextAttrDimension& GetTopMargin() { return m_margins.m_top; }
+    const wxTextAttrDimension& GetTopMargin() const { return m_margins.m_top; }
+
+    /**
+        Returns the bottom margin.
+    */
+    wxTextAttrDimension& GetBottomMargin() { return m_margins.m_bottom; }
+    const wxTextAttrDimension& GetBottomMargin() const { return m_margins.m_bottom; }
+
+    /**
+        Returns the position.
+    */
+    wxTextAttrDimensions& GetPosition() { return m_position; }
+    const wxTextAttrDimensions& GetPosition() const { return m_position; }
+
+    /**
+        Returns the left position.
+    */
+    wxTextAttrDimension& GetLeft() { return m_position.m_left; }
+    const wxTextAttrDimension& GetLeft() const { return m_position.m_left; }
+
+    /**
+        Returns the right position.
+    */
+    wxTextAttrDimension& GetRight() { return m_position.m_right; }
+    const wxTextAttrDimension& GetRight() const { return m_position.m_right; }
+
+    /**
+        Returns the top position.
+    */
+    wxTextAttrDimension& GetTop() { return m_position.m_top; }
+    const wxTextAttrDimension& GetTop() const { return m_position.m_top; }
+
+    /**
+        Returns the bottom position.
+    */
+    wxTextAttrDimension& GetBottom() { return m_position.m_bottom; }
+    const wxTextAttrDimension& GetBottom() const { return m_position.m_bottom; }
+
+    /**
+        Returns the padding values.
+    */
+    wxTextAttrDimensions& GetPadding() { return m_padding; }
+    const wxTextAttrDimensions& GetPadding() const { return m_padding; }
+
+    /**
+        Returns the left padding value.
+    */
+    wxTextAttrDimension& GetLeftPadding() { return m_padding.m_left; }
+    const wxTextAttrDimension& GetLeftPadding() const { return m_padding.m_left; }
+
+    /**
+        Returns the right padding value.
+    */
+    wxTextAttrDimension& GetRightPadding() { return m_padding.m_right; }
+    const wxTextAttrDimension& GetRightPadding() const { return m_padding.m_right; }
+
+    /**
+        Returns the top padding value.
+    */
+    wxTextAttrDimension& GetTopPadding() { return m_padding.m_top; }
+    const wxTextAttrDimension& GetTopPadding() const { return m_padding.m_top; }
+
+    /**
+        Returns the bottom padding value.
+    */
+    wxTextAttrDimension& GetBottomPadding() { return m_padding.m_bottom; }
+    const wxTextAttrDimension& GetBottomPadding() const { return m_padding.m_bottom; }
+
+    /**
+        Returns the borders.
+    */
+    wxTextAttrBorders& GetBorder() { return m_border; }
+    const wxTextAttrBorders& GetBorder() const { return m_border; }
+
+    /**
+        Returns the left border.
+    */
+    wxTextAttrBorder& GetLeftBorder() { return m_border.m_left; }
+    const wxTextAttrBorder& GetLeftBorder() const { return m_border.m_left; }
+
+    /**
+        Returns the top border.
+    */
+    wxTextAttrBorder& GetTopBorder() { return m_border.m_top; }
+    const wxTextAttrBorder& GetTopBorder() const { return m_border.m_top; }
+
+    /**
+        Returns the right border.
+    */
+    wxTextAttrBorder& GetRightBorder() { return m_border.m_right; }
+    const wxTextAttrBorder& GetRightBorder() const { return m_border.m_right; }
+
+    /**
+        Returns the bottom border.
+    */
+    wxTextAttrBorder& GetBottomBorder() { return m_border.m_bottom; }
+    const wxTextAttrBorder& GetBottomBorder() const { return m_border.m_bottom; }
+
+    /**
+        Returns the outline.
+    */
+    wxTextAttrBorders& GetOutline() { return m_outline; }
+    const wxTextAttrBorders& GetOutline() const { return m_outline; }
+
+    /**
+        Returns the left outline.
+    */
+    wxTextAttrBorder& GetLeftOutline() { return m_outline.m_left; }
+    const wxTextAttrBorder& GetLeftOutline() const { return m_outline.m_left; }
+
+    /**
+        Returns the top outline.
+    */
+    wxTextAttrBorder& GetTopOutline() { return m_outline.m_top; }
+    const wxTextAttrBorder& GetTopOutline() const { return m_outline.m_top; }
+
+    /**
+        Returns the right outline.
+    */
+    wxTextAttrBorder& GetRightOutline() { return m_outline.m_right; }
+    const wxTextAttrBorder& GetRightOutline() const { return m_outline.m_right; }
+
+    /**
+        Returns the bottom outline.
+    */
+    wxTextAttrBorder& GetBottomOutline() { return m_outline.m_bottom; }
+    const wxTextAttrBorder& GetBottomOutline() const { return m_outline.m_bottom; }
+
+    /**
+        Returns the object size.
+    */
+    wxTextAttrSize& GetSize() { return m_size; }
+    const wxTextAttrSize& GetSize() const { return m_size; }
+
+    /**
+        Sets the object size.
+    */
+    void SetSize(const wxTextAttrSize& sz) { m_size = sz; }
+
+    /**
+        Returns the object width.
+    */
+    wxTextAttrDimension& GetWidth() { return m_size.m_width; }
+    const wxTextAttrDimension& GetWidth() const { return m_size.m_width; }
+
+    /**
+        Returns the object height.
+    */
+    wxTextAttrDimension& GetHeight() { return m_size.m_height; }
+    const wxTextAttrDimension& GetHeight() const { return m_size.m_height; }
+
+public:
+
+    int                             m_flags;
+
+    wxTextAttrDimensions            m_margins;
+    wxTextAttrDimensions            m_padding;
+    wxTextAttrDimensions            m_position;
+
+    wxTextAttrSize                  m_size;
+
+    wxTextAttrBorders               m_border;
+    wxTextAttrBorders               m_outline;
+
+    wxTextBoxAttrFloatStyle         m_floatMode;
+    wxTextBoxAttrClearStyle         m_clearMode;
+    wxTextBoxAttrCollapseMode       m_collapseMode;
+    wxTextBoxAttrVerticalAlignment  m_verticalAlignment;
+};
+
+/**
+    @class wxRichTextAttr
+    A class representing enhanced attributes for rich text objects.
+    This adds a wxTextBoxAttr member to the basic wxTextAttr class.
+
+    @library{wxrichtext}
+    @category{richtext}
+
+    @see wxRichTextAttr, wxTextBoxAttr, wxRichTextCtrl
+*/
+
+class WXDLLIMPEXP_RICHTEXT wxRichTextAttr: public wxTextAttr
+{
+public:
+    /**
+        Constructor taking a wxTextAttr.
+    */
+    wxRichTextAttr(const wxTextAttr& attr) { wxTextAttr::Copy(attr); }
+
+    /**
+        Copy constructor.
+    */
+    wxRichTextAttr(const wxRichTextAttr& attr): wxTextAttr() { Copy(attr); }
+
+    /**
+        Default constructor.
+    */
+    wxRichTextAttr() {}
+
+    /**
+        Copy function.
+    */
+    void Copy(const wxRichTextAttr& attr);
+
+    /**
+        Assignment operator.
+    */
+    void operator=(const wxRichTextAttr& attr) { Copy(attr); }
+
+    /**
+        Assignment operator.
+    */
+    void operator=(const wxTextAttr& attr) { wxTextAttr::Copy(attr); }
+
+    /**
+        Equality test.
+    */
+    bool operator==(const wxRichTextAttr& attr) const;
+
+    /**
+        Partial equality test taking comparison object into account.
+    */
+    bool EqPartial(const wxRichTextAttr& attr) const;
+
+    /**
+        Merges the given attributes. If @a compareWith
+        is non-NULL, then it will be used to mask out those attributes that are the same in style
+        and @a compareWith, for situations where we don't want to explicitly set inherited attributes.
+    */
+    bool Apply(const wxRichTextAttr& style, const wxRichTextAttr* compareWith = NULL);
+
+    /**
+        Collects the attributes that are common to a range of content, building up a note of
+        which attributes are absent in some objects and which clash in some objects.
+    */
+    void CollectCommonAttributes(const wxRichTextAttr& attr, wxRichTextAttr& clashingAttr, wxRichTextAttr& absentAttr);
+
+    /**
+        Removes the specified attributes from this object.
+    */
+    bool RemoveStyle(const wxRichTextAttr& attr);
+
+    /**
+        Returns the text box attributes.
+    */
+    wxTextBoxAttr& GetTextBoxAttr() { return m_textBoxAttr; }
+    const wxTextBoxAttr& GetTextBoxAttr() const { return m_textBoxAttr; }
+
+    /**
+        Set the text box attributes.
+    */
+    void SetTextBoxAttr(const wxTextBoxAttr& attr) { m_textBoxAttr = attr; }
+
+    wxTextBoxAttr    m_textBoxAttr;
+};
+
+WX_DECLARE_USER_EXPORTED_OBJARRAY(wxVariant, wxRichTextVariantArray, WXDLLIMPEXP_RICHTEXT);
+
+/**
+    @class wxRichTextProperties
+    A simple property class using wxVariants. This is used to give each rich text object the
+    ability to store custom properties that can be used by the application.
+
+    @library{wxrichtext}
+    @category{richtext}
+
+    @see wxRichTextBuffer, wxRichTextObject, wxRichTextCtrl
+*/
+
+class WXDLLIMPEXP_RICHTEXT wxRichTextProperties: public wxObject
+{
+DECLARE_DYNAMIC_CLASS(wxRichTextProperties)
+public:
+
+    /**
+        Default constructor.
+    */
+    wxRichTextProperties() {}
+
+    /**
+        Copy constructor.
+    */
+    wxRichTextProperties(const wxRichTextProperties& props): wxObject() { Copy(props); }
+
+    /**
+        Assignment operator.
+    */
+    void operator=(const wxRichTextProperties& props) { Copy(props); }
+
+    /**
+        Equality operator.
+    */
+    bool operator==(const wxRichTextProperties& props) const;
+
+    /**
+        Copies from @a props.
+    */
+    void Copy(const wxRichTextProperties& props) { m_properties = props.m_properties; }
+
+    /**
+        Returns the variant at the given index.
+    */
+    const wxVariant& operator[](size_t idx) const { return m_properties[idx]; }
+
+    /**
+        Returns the variant at the given index.
+    */
+    wxVariant& operator[](size_t idx) { return m_properties[idx]; }
+
+    /**
+        Clears the properties.
+    */
+    void Clear() { m_properties.Clear(); }
+
+    /**
+        Returns the array of variants implementing the properties.
+    */
+    const wxRichTextVariantArray& GetProperties() const { return m_properties; }
+
+    /**
+        Returns the array of variants implementing the properties.
+    */
+    wxRichTextVariantArray& GetProperties() { return m_properties; }
+
+    /**
+        Sets the array of variants.
+    */
+    void SetProperties(const wxRichTextVariantArray& props) { m_properties = props; }
+
+    /**
+        Returns all the property names.
+    */
+    wxArrayString GetPropertyNames() const;
+
+    /**
+        Returns a count of the properties.
+    */
+    size_t GetCount() const { return m_properties.GetCount(); }
+
+    /**
+        Returns @true if the given property is found.
+    */
+    bool HasProperty(const wxString& name) const { return Find(name) != -1; }
+
+    /**
+        Finds the given property.
+    */
+    int Find(const wxString& name) const;
+
+    /**
+        Gets the property variant by name.
+    */
+    const wxVariant& GetProperty(const wxString& name) const;
+
+    /**
+        Finds or creates a property with the given name, returning a pointer to the variant.
+    */
+    wxVariant* FindOrCreateProperty(const wxString& name);
+
+    /**
+        Gets the value of the named property as a string.
+    */
+    wxString GetPropertyString(const wxString& name) const;
+
+    /**
+        Gets the value of the named property as a long integer.
+    */
+    long GetPropertyLong(const wxString& name) const;
+
+    /**
+        Gets the value of the named property as a boolean.
+    */
+    bool GetPropertyBool(const wxString& name) const;
+
+    /**
+        Gets the value of the named property as a double.
+    */
+    double GetPropertyDouble(const wxString& name) const;
+
+    /**
+        Sets the property by passing a variant which contains a name and value.
+    */
+    void SetProperty(const wxVariant& variant);
+
+    /**
+        Sets a property by name and variant.
+    */
+    void SetProperty(const wxString& name, const wxVariant& variant);
+
+    /**
+        Sets a property by name and string value.
+    */
+    void SetProperty(const wxString& name, const wxString& value);
+
+    /**
+        Sets  property by name and long integer value.
+    */
+    void SetProperty(const wxString& name, long value);
+
+    /**
+        Sets  property by name and double value.
+    */
+    void SetProperty(const wxString& name, double value);
+
+    /**
+        Sets  property by name and boolean value.
+    */
+    void SetProperty(const wxString& name, bool value);
+
+protected:
+    wxRichTextVariantArray  m_properties;
+};
+
+
+/**
+    @class wxRichTextFontTable
+    Manages quick access to a pool of fonts for rendering rich text.
+
+    @library{wxrichtext}
+    @category{richtext}
+
+    @see wxRichTextBuffer, wxRichTextCtrl
+*/
+
+class WXDLLIMPEXP_RICHTEXT wxRichTextFontTable: public wxObject
+{
+public:
+    /**
+        Default constructor.
+    */
+    wxRichTextFontTable();
+
+    /**
+        Copy constructor.
+    */
+    wxRichTextFontTable(const wxRichTextFontTable& table);
+    virtual ~wxRichTextFontTable();
+
+    /**
+        Returns @true if the font table is valid.
+    */
+    bool IsOk() const { return m_refData != NULL; }
+
+    /**
+        Finds a font for the given attribute object.
+    */
+    wxFont FindFont(const wxRichTextAttr& fontSpec);
+
+    /**
+        Clears the font table.
+    */
+    void Clear();
+
+    /**
+        Assignment operator.
+    */
+    void operator= (const wxRichTextFontTable& table);
+
+    /**
+        Equality operator.
+    */
+    bool operator == (const wxRichTextFontTable& table) const;
+
+    /**
+        Inequality operator.
+    */
+    bool operator != (const wxRichTextFontTable& table) const { return !(*this == table); }
+
+protected:
+
+    DECLARE_DYNAMIC_CLASS(wxRichTextFontTable)
+};
+
+/**
+    @class wxRichTextRange
+
+    This stores beginning and end positions for a range of data.
+
+    @library{wxrichtext}
+    @category{richtext}
+
+    @see wxRichTextBuffer, wxRichTextCtrl
+*/
 
 class WXDLLIMPEXP_RICHTEXT wxRichTextRange
 {
 public:
 // Constructors
 
 
 class WXDLLIMPEXP_RICHTEXT wxRichTextRange
 {
 public:
 // Constructors
 
+    /**
+        Default constructor.
+    */
     wxRichTextRange() { m_start = 0; m_end = 0; }
     wxRichTextRange() { m_start = 0; m_end = 0; }
+
+    /**
+        Constructor taking start and end positions.
+    */
     wxRichTextRange(long start, long end) { m_start = start; m_end = end; }
     wxRichTextRange(long start, long end) { m_start = start; m_end = end; }
+
+    /**
+        Copy constructor.
+    */
     wxRichTextRange(const wxRichTextRange& range) { m_start = range.m_start; m_end = range.m_end; }
     ~wxRichTextRange() {}
 
     wxRichTextRange(const wxRichTextRange& range) { m_start = range.m_start; m_end = range.m_end; }
     ~wxRichTextRange() {}
 
+    /**
+        Assigns @a range to this range.
+    */
     void operator =(const wxRichTextRange& range) { m_start = range.m_start; m_end = range.m_end; }
     void operator =(const wxRichTextRange& range) { m_start = range.m_start; m_end = range.m_end; }
+
+    /**
+        Equality operator. Returns @true if @a range is the same as this range.
+    */
     bool operator ==(const wxRichTextRange& range) const { return (m_start == range.m_start && m_end == range.m_end); }
     bool operator ==(const wxRichTextRange& range) const { return (m_start == range.m_start && m_end == range.m_end); }
+
+    /**
+        Inequality operator.
+    */
+    bool operator !=(const wxRichTextRange& range) const { return (m_start != range.m_start || m_end != range.m_end); }
+
+    /**
+        Subtracts a range from this range.
+    */
     wxRichTextRange operator -(const wxRichTextRange& range) const { return wxRichTextRange(m_start - range.m_start, m_end - range.m_end); }
     wxRichTextRange operator -(const wxRichTextRange& range) const { return wxRichTextRange(m_start - range.m_start, m_end - range.m_end); }
+
+    /**
+        Adds a range to this range.
+    */
     wxRichTextRange operator +(const wxRichTextRange& range) const { return wxRichTextRange(m_start + range.m_start, m_end + range.m_end); }
 
     wxRichTextRange operator +(const wxRichTextRange& range) const { return wxRichTextRange(m_start + range.m_start, m_end + range.m_end); }
 
+    /**
+        Sets the range start and end positions.
+    */
     void SetRange(long start, long end) { m_start = start; m_end = end; }
 
     void SetRange(long start, long end) { m_start = start; m_end = end; }
 
+    /**
+        Sets the start position.
+    */
     void SetStart(long start) { m_start = start; }
     void SetStart(long start) { m_start = start; }
+
+    /**
+        Returns the start position.
+    */
     long GetStart() const { return m_start; }
 
     long GetStart() const { return m_start; }
 
+    /**
+        Sets the end position.
+    */
     void SetEnd(long end) { m_end = end; }
     void SetEnd(long end) { m_end = end; }
+
+    /**
+        Gets the end position.
+    */
     long GetEnd() const { return m_end; }
 
     long GetEnd() const { return m_end; }
 
-    /// Returns true if this range is completely outside 'range'
+    /**
+        Returns true if this range is completely outside @a range.
+    */
     bool IsOutside(const wxRichTextRange& range) const { return range.m_start > m_end || range.m_end < m_start; }
 
     bool IsOutside(const wxRichTextRange& range) const { return range.m_start > m_end || range.m_end < m_start; }
 
-    /// Returns true if this range is completely within 'range'
+    /**
+        Returns true if this range is completely within @a range.
+    */
     bool IsWithin(const wxRichTextRange& range) const { return m_start >= range.m_start && m_end <= range.m_end; }
 
     bool IsWithin(const wxRichTextRange& range) const { return m_start >= range.m_start && m_end <= range.m_end; }
 
-    /// Returns true if the given position is within this range. Allow
-    /// for the possibility of an empty range - assume the position
-    /// is within this empty range. NO, I think we should not match with an empty range.
-    // bool Contains(long pos) const { return pos >= m_start && (pos <= m_end || GetLength() == 0); }
+    /**
+        Returns true if @a pos was within the range. Does not match if the range is empty.
+    */
     bool Contains(long pos) const { return pos >= m_start && pos <= m_end ; }
 
     bool Contains(long pos) const { return pos >= m_start && pos <= m_end ; }
 
-    /// Limit this range to be within 'range'
+    /**
+        Limit this range to be within @a range.
+    */
     bool LimitTo(const wxRichTextRange& range) ;
 
     bool LimitTo(const wxRichTextRange& range) ;
 
-    /// Gets the length of the range
+    /**
+        Gets the length of the range.
+    */
     long GetLength() const { return m_end - m_start + 1; }
 
     long GetLength() const { return m_end - m_start + 1; }
 
-    /// Swaps the start and end
+    /**
+        Swaps the start and end.
+    */
     void Swap() { long tmp = m_start; m_start = m_end; m_end = tmp; }
 
     void Swap() { long tmp = m_start; m_start = m_end; m_end = tmp; }
 
+    /**
+        Converts the API-standard range, whose end is one past the last character in
+        the range, to the internal form, which uses the first and last character
+        positions of the range. In other words, one is subtracted from the end position.
+        (n, n) is the range of a single character.
+    */
+    wxRichTextRange ToInternal() const { return wxRichTextRange(m_start, m_end-1); }
+
+    /**
+        Converts the internal range, which uses the first and last character positions
+        of the range, to the API-standard range, whose end is one past the last
+        character in the range. In other words, one is added to the end position.
+        (n, n+1) is the range of a single character.
+    */
+    wxRichTextRange FromInternal() const { return wxRichTextRange(m_start, m_end+1); }
+
 protected:
     long m_start;
     long m_end;
 };
 
 protected:
     long m_start;
     long m_end;
 };
 
+WX_DECLARE_USER_EXPORTED_OBJARRAY(wxRichTextRange, wxRichTextRangeArray, WXDLLIMPEXP_RICHTEXT);
+
 #define wxRICHTEXT_ALL  wxRichTextRange(-2, -2)
 #define wxRICHTEXT_NONE  wxRichTextRange(-1, -1)
 
 #define wxRICHTEXT_ALL  wxRichTextRange(-2, -2)
 #define wxRICHTEXT_NONE  wxRichTextRange(-1, -1)
 
-/*!
- * wxTextAttrEx is an extended version of wxTextAttr with more paragraph attributes.
- */
-
-class WXDLLIMPEXP_RICHTEXT wxTextAttrEx: public wxTextAttr
-{
-public:
-    // ctors
-    wxTextAttrEx(const wxTextAttrEx& attr);
-    wxTextAttrEx(const wxTextAttr& attr) { Init(); (*this) = attr; }
-    wxTextAttrEx() { Init(); }
+#define wxRICHTEXT_NO_SELECTION wxRichTextRange(-2, -2)
 
 
-    // Initialise this object.
-    void Init();
+/**
+    @class wxRichTextSelection
 
 
-    // Assignment from a wxTextAttrEx object
-    void operator= (const wxTextAttrEx& attr);
-
-    // Assignment from a wxTextAttr object.
-    void operator= (const wxTextAttr& attr);
-
-    // setters
-    void SetCharacterStyleName(const wxString& name) { m_characterStyleName = name; SetFlags(GetFlags() | wxTEXT_ATTR_CHARACTER_STYLE_NAME); }
-    void SetParagraphStyleName(const wxString& name) { m_paragraphStyleName = name; SetFlags(GetFlags() | wxTEXT_ATTR_PARAGRAPH_STYLE_NAME); }
-    void SetParagraphSpacingAfter(int spacing) { m_paragraphSpacingAfter = spacing; SetFlags(GetFlags() | wxTEXT_ATTR_PARA_SPACING_AFTER); }
-    void SetParagraphSpacingBefore(int spacing) { m_paragraphSpacingBefore = spacing; SetFlags(GetFlags() | wxTEXT_ATTR_PARA_SPACING_BEFORE); }
-    void SetLineSpacing(int spacing) { m_lineSpacing = spacing; SetFlags(GetFlags() | wxTEXT_ATTR_LINE_SPACING); }
-    void SetBulletStyle(int style) { m_bulletStyle = style; SetFlags(GetFlags() | wxTEXT_ATTR_BULLET_STYLE); }
-    void SetBulletNumber(int n) { m_bulletNumber = n; SetFlags(GetFlags() | wxTEXT_ATTR_BULLET_NUMBER); }
-    void SetBulletSymbol(wxChar symbol) { m_bulletSymbol = symbol; SetFlags(GetFlags() | wxTEXT_ATTR_BULLET_SYMBOL); }
-
-    const wxString& GetCharacterStyleName() const { return m_characterStyleName; }
-    const wxString& GetParagraphStyleName() const { return m_paragraphStyleName; }
-    int GetParagraphSpacingAfter() const { return m_paragraphSpacingAfter; }
-    int GetParagraphSpacingBefore() const { return m_paragraphSpacingBefore; }
-    int GetLineSpacing() const { return m_lineSpacing; }
-    int GetBulletStyle() const { return m_bulletStyle; }
-    int GetBulletNumber() const { return m_bulletNumber; }
-    wxChar GetBulletSymbol() const { return m_bulletSymbol; }
-
-    bool HasWeight() const { return (GetFlags() & wxTEXT_ATTR_FONT_WEIGHT) != 0; }
-    bool HasSize() const { return (GetFlags() & wxTEXT_ATTR_FONT_SIZE) != 0; }
-    bool HasItalic() const { return (GetFlags() & wxTEXT_ATTR_FONT_ITALIC) != 0; }
-    bool HasUnderlined() const { return (GetFlags() & wxTEXT_ATTR_FONT_UNDERLINE) != 0; }
-    bool HasFaceName() const { return (GetFlags() & wxTEXT_ATTR_FONT_FACE) != 0; }
-
-    bool HasParagraphSpacingAfter() const { return HasFlag(wxTEXT_ATTR_PARA_SPACING_AFTER); }
-    bool HasParagraphSpacingBefore() const { return HasFlag(wxTEXT_ATTR_PARA_SPACING_BEFORE); }
-    bool HasLineSpacing() const { return HasFlag(wxTEXT_ATTR_LINE_SPACING); }
-    bool HasCharacterStyleName() const { return HasFlag(wxTEXT_ATTR_CHARACTER_STYLE_NAME); }
-    bool HasParagraphStyleName() const { return HasFlag(wxTEXT_ATTR_PARAGRAPH_STYLE_NAME); }
-    bool HasBulletStyle() const { return HasFlag(wxTEXT_ATTR_BULLET_STYLE); }
-    bool HasBulletNumber() const { return HasFlag(wxTEXT_ATTR_BULLET_NUMBER); }
-    bool HasBulletSymbol() const { return HasFlag(wxTEXT_ATTR_BULLET_SYMBOL); }
-
-    // Is this a character style?
-    bool IsCharacterStyle() const { return (0 != (GetFlags() & (wxTEXT_ATTR_FONT | wxTEXT_ATTR_BACKGROUND_COLOUR | wxTEXT_ATTR_TEXT_COLOUR))); }
-    bool IsParagraphStyle() const { return (0 != (GetFlags() & (wxTEXT_ATTR_ALIGNMENT|wxTEXT_ATTR_LEFT_INDENT|wxTEXT_ATTR_RIGHT_INDENT|wxTEXT_ATTR_TABS|
-                            wxTEXT_ATTR_PARA_SPACING_BEFORE|wxTEXT_ATTR_PARA_SPACING_AFTER|wxTEXT_ATTR_LINE_SPACING|
-                            wxTEXT_ATTR_BULLET_STYLE|wxTEXT_ATTR_BULLET_NUMBER))); }
-
-    // returns false if we have any attributes set, true otherwise
-    bool IsDefault() const
-    {
-        return !HasTextColour() && !HasBackgroundColour() && !HasFont() && !HasAlignment() &&
-               !HasTabs() && !HasLeftIndent() && !HasRightIndent() &&
-               !HasParagraphSpacingAfter() && !HasParagraphSpacingBefore() && !HasLineSpacing() &&
-               !HasCharacterStyleName() && !HasParagraphStyleName() && !HasBulletNumber() && !HasBulletStyle() && !HasBulletSymbol();
-    }
+    Stores selection information. The selection does not have to be contiguous, though currently non-contiguous
+    selections are only supported for a range of table cells (a geometric block of cells can consist
+    of a set of non-contiguous positions).
 
 
-    // return the attribute having the valid font and colours: it uses the
-    // attributes set in attr and falls back first to attrDefault and then to
-    // the text control font/colours for those attributes which are not set
-    static wxTextAttrEx CombineEx(const wxTextAttrEx& attr,
-                              const wxTextAttrEx& attrDef,
-                              const wxTextCtrlBase *text);
+    The selection consists of an array of ranges, and the container that is the context for the selection. It
+    follows that a single selection object can only represent ranges with the same parent container.
 
 
-private:
-    // Paragraph styles
-    int                 m_paragraphSpacingAfter;
-    int                 m_paragraphSpacingBefore;
-    int                 m_lineSpacing;
-    int                 m_bulletStyle;
-    int                 m_bulletNumber;
-    wxChar              m_bulletSymbol;
-
-    // Character style
-    wxString            m_characterStyleName;
-
-    // Paragraph style
-    wxString            m_paragraphStyleName;
-};
+    @library{wxrichtext}
+    @category{richtext}
 
 
-/*!
- * wxRichTextAttr stores attributes without a wxFont object, so is a much more
- * efficient way to query styles.
- */
+    @see wxRichTextBuffer, wxRichTextCtrl
+*/
 
 
-class WXDLLIMPEXP_RICHTEXT wxRichTextAttr
+class WXDLLIMPEXP_RICHTEXT wxRichTextSelection
 {
 public:
 {
 public:
-    // ctors
-    wxRichTextAttr(const wxTextAttrEx& attr);
-    wxRichTextAttr() { Init(); }
-    wxRichTextAttr(const wxColour& colText,
-               const wxColour& colBack = wxNullColour,
-               wxTextAttrAlignment alignment = wxTEXT_ALIGNMENT_DEFAULT);
-
-    // Initialise this object.
-    void Init();
-
-    // Assignment from a wxRichTextAttr object.
-    void operator= (const wxRichTextAttr& attr);
-
-    // Assignment from a wxTextAttrEx object.
-    void operator= (const wxTextAttrEx& attr);
-
-    // Making a wxTextAttrEx object.
-    operator wxTextAttrEx () const ;
-
-    // Copy to a wxTextAttr
-    void CopyTo(wxTextAttrEx& attr) const;
-
-    // Create font from font attributes.
-    wxFont CreateFont() const;
-
-    // Get attributes from font.
-    bool GetFontAttributes(const wxFont& font);
-
-    // setters
-    void SetTextColour(const wxColour& colText) { m_colText = colText; m_flags |= wxTEXT_ATTR_TEXT_COLOUR; }
-    void SetBackgroundColour(const wxColour& colBack) { m_colBack = colBack; m_flags |= wxTEXT_ATTR_BACKGROUND_COLOUR; }
-    void SetAlignment(wxTextAttrAlignment alignment) { m_textAlignment = alignment; m_flags |= wxTEXT_ATTR_ALIGNMENT; }
-    void SetTabs(const wxArrayInt& tabs) { m_tabs = tabs; m_flags |= wxTEXT_ATTR_TABS; }
-    void SetLeftIndent(int indent, int subIndent = 0) { m_leftIndent = indent; m_leftSubIndent = subIndent; m_flags |= wxTEXT_ATTR_LEFT_INDENT; }
-    void SetRightIndent(int indent) { m_rightIndent = indent; m_flags |= wxTEXT_ATTR_RIGHT_INDENT; }
-
-    void SetFontSize(int pointSize) { m_fontSize = pointSize; m_flags |= wxTEXT_ATTR_FONT_SIZE; }
-    void SetFontStyle(int fontStyle) { m_fontStyle = fontStyle; m_flags |= wxTEXT_ATTR_FONT_ITALIC; }
-    void SetFontWeight(int fontWeight) { m_fontWeight = fontWeight; m_flags |= wxTEXT_ATTR_FONT_WEIGHT; }
-    void SetFontFaceName(const wxString& faceName) { m_fontFaceName = faceName; m_flags |= wxTEXT_ATTR_FONT_FACE; }
-    void SetFontUnderlined(bool underlined) { m_fontUnderlined = underlined; m_flags |= wxTEXT_ATTR_FONT_UNDERLINE; }
-
-    void SetFlags(long flags) { m_flags = flags; }
-
-    void SetCharacterStyleName(const wxString& name) { m_characterStyleName = name; }
-    void SetParagraphStyleName(const wxString& name) { m_paragraphStyleName = name; }
-    void SetParagraphSpacingAfter(int spacing) { m_paragraphSpacingAfter = spacing; }
-    void SetParagraphSpacingBefore(int spacing) { m_paragraphSpacingBefore = spacing; }
-    void SetLineSpacing(int spacing) { m_lineSpacing = spacing; }
-    void SetBulletStyle(int style) { m_bulletStyle = style; }
-    void SetBulletNumber(int n) { m_bulletNumber = n; }
-    void SetBulletSymbol(wxChar symbol) { m_bulletSymbol = symbol; }
-
-    const wxColour& GetTextColour() const { return m_colText; }
-    const wxColour& GetBackgroundColour() const { return m_colBack; }
-    wxTextAttrAlignment GetAlignment() const { return m_textAlignment; }
-    const wxArrayInt& GetTabs() const { return m_tabs; }
-    long GetLeftIndent() const { return m_leftIndent; }
-    long GetLeftSubIndent() const { return m_leftSubIndent; }
-    long GetRightIndent() const { return m_rightIndent; }
-    long GetFlags() const { return m_flags; }
-
-    int GetFontSize() const { return m_fontSize; }
-    int GetFontStyle() const { return m_fontStyle; }
-    int GetFontWeight() const { return m_fontWeight; }
-    bool GetFontUnderlined() const { return m_fontUnderlined; }
-    const wxString& GetFontFaceName() const { return m_fontFaceName; }
-
-    const wxString& GetCharacterStyleName() const { return m_characterStyleName; }
-    const wxString& GetParagraphStyleName() const { return m_paragraphStyleName; }
-    int GetParagraphSpacingAfter() const { return m_paragraphSpacingAfter; }
-    int GetParagraphSpacingBefore() const { return m_paragraphSpacingBefore; }
-    int GetLineSpacing() const { return m_lineSpacing; }
-    int GetBulletStyle() const { return m_bulletStyle; }
-    int GetBulletNumber() const { return m_bulletNumber; }
-    wxChar GetBulletSymbol() const { return m_bulletSymbol; }
-
-    // accessors
-    bool HasTextColour() const { return m_colText.Ok() && HasFlag(wxTEXT_ATTR_TEXT_COLOUR) ; }
-    bool HasBackgroundColour() const { return m_colBack.Ok() && HasFlag(wxTEXT_ATTR_BACKGROUND_COLOUR) ; }
-    bool HasAlignment() const { return (m_textAlignment != wxTEXT_ALIGNMENT_DEFAULT) || ((m_flags & wxTEXT_ATTR_ALIGNMENT) != 0) ; }
-    bool HasTabs() const { return (m_flags & wxTEXT_ATTR_TABS) != 0 ; }
-    bool HasLeftIndent() const { return (m_flags & wxTEXT_ATTR_LEFT_INDENT) != 0 ; }
-    bool HasRightIndent() const { return (m_flags & wxTEXT_ATTR_RIGHT_INDENT) != 0 ; }
-    bool HasWeight() const { return (m_flags & wxTEXT_ATTR_FONT_WEIGHT) != 0; }
-    bool HasSize() const { return (m_flags & wxTEXT_ATTR_FONT_SIZE) != 0; }
-    bool HasItalic() const { return (m_flags & wxTEXT_ATTR_FONT_ITALIC) != 0; }
-    bool HasUnderlined() const { return (m_flags & wxTEXT_ATTR_FONT_UNDERLINE) != 0; }
-    bool HasFaceName() const { return (m_flags & wxTEXT_ATTR_FONT_FACE) != 0; }
-    bool HasFont() const { return (m_flags & (wxTEXT_ATTR_FONT)) != 0; }
-
-    bool HasParagraphSpacingAfter() const { return (m_flags & wxTEXT_ATTR_PARA_SPACING_AFTER) != 0; }
-    bool HasParagraphSpacingBefore() const { return (m_flags & wxTEXT_ATTR_PARA_SPACING_BEFORE) != 0; }
-    bool HasLineSpacing() const { return (m_flags & wxTEXT_ATTR_LINE_SPACING) != 0; }
-    bool HasCharacterStyleName() const { return (m_flags & wxTEXT_ATTR_CHARACTER_STYLE_NAME) != 0; }
-    bool HasParagraphStyleName() const { return (m_flags & wxTEXT_ATTR_PARAGRAPH_STYLE_NAME) != 0; }
-    bool HasBulletStyle() const { return (m_flags & wxTEXT_ATTR_BULLET_STYLE) != 0; }
-    bool HasBulletNumber() const { return (m_flags & wxTEXT_ATTR_BULLET_NUMBER) != 0; }
-    bool HasBulletSymbol() const { return (m_flags & wxTEXT_ATTR_BULLET_SYMBOL) != 0; }
-
-    bool HasFlag(long flag) const { return (m_flags & flag) != 0; }
-
-    // Is this a character style?
-    bool IsCharacterStyle() const { return (0 != (GetFlags() & (wxTEXT_ATTR_FONT | wxTEXT_ATTR_BACKGROUND_COLOUR | wxTEXT_ATTR_TEXT_COLOUR))); }
-    bool IsParagraphStyle() const { return (0 != (GetFlags() & (wxTEXT_ATTR_ALIGNMENT|wxTEXT_ATTR_LEFT_INDENT|wxTEXT_ATTR_RIGHT_INDENT|wxTEXT_ATTR_TABS|
-                            wxTEXT_ATTR_PARA_SPACING_BEFORE|wxTEXT_ATTR_PARA_SPACING_AFTER|wxTEXT_ATTR_LINE_SPACING|
-                            wxTEXT_ATTR_BULLET_STYLE|wxTEXT_ATTR_BULLET_NUMBER))); }
-
-    // returns false if we have any attributes set, true otherwise
-    bool IsDefault() const
-    {
-        return !HasTextColour() && !HasBackgroundColour() && !HasFont() && !HasAlignment() &&
-               !HasTabs() && !HasLeftIndent() && !HasRightIndent() &&
-               !HasParagraphSpacingAfter() && !HasParagraphSpacingBefore() && !HasLineSpacing() &&
-               !HasCharacterStyleName() && !HasParagraphStyleName() && !HasBulletNumber() && !HasBulletStyle() && !HasBulletSymbol();
-    }
-
-    // return the attribute having the valid font and colours: it uses the
-    // attributes set in attr and falls back first to attrDefault and then to
-    // the text control font/colours for those attributes which are not set
-    static wxRichTextAttr Combine(const wxRichTextAttr& attr,
-                              const wxRichTextAttr& attrDef,
-                              const wxTextCtrlBase *text);
-private:
-    long                m_flags;
-
-    // Paragraph styles
-    wxArrayInt          m_tabs; // array of int: tab stops in 1/10 mm
-    int                 m_leftIndent; // left indent in 1/10 mm
-    int                 m_leftSubIndent; // left indent for all but the first
-                                         // line in a paragraph relative to the
-                                         // first line, in 1/10 mm
-    int                 m_rightIndent; // right indent in 1/10 mm
-    wxTextAttrAlignment m_textAlignment;
-
-    int                 m_paragraphSpacingAfter;
-    int                 m_paragraphSpacingBefore;
-    int                 m_lineSpacing;
-    int                 m_bulletStyle;
-    int                 m_bulletNumber;
-    wxChar              m_bulletSymbol;
-
-    // Character styles
-    wxColour            m_colText,
-                        m_colBack;
-    int                 m_fontSize;
-    int                 m_fontStyle;
-    int                 m_fontWeight;
-    bool                m_fontUnderlined;
-    wxString            m_fontFaceName;
-
-    // Character style
-    wxString            m_characterStyleName;
-
-    // Paragraph style
-    wxString            m_paragraphStyleName;
+    /**
+        Copy constructor.
+    */
+    wxRichTextSelection(const wxRichTextSelection& sel) { Copy(sel); }
+
+    /**
+        Creates a selection from a range and a container.
+    */
+    wxRichTextSelection(const wxRichTextRange& range, wxRichTextParagraphLayoutBox* container) { m_ranges.Add(range); m_container = container; }
+
+    /**
+        Default constructor.
+    */
+    wxRichTextSelection() { Reset(); }
+
+    /**
+        Resets the selection.
+    */
+    void Reset() { m_ranges.Clear(); m_container = NULL; }
+
+    /**
+        Sets the selection.
+    */
+
+    void Set(const wxRichTextRange& range, wxRichTextParagraphLayoutBox* container)
+    { m_ranges.Clear(); m_ranges.Add(range); m_container = container; }
+
+    /**
+        Adds a range to the selection.
+    */
+    void Add(const wxRichTextRange& range)
+    { m_ranges.Add(range); }
+
+    /**
+        Sets the selections from an array of ranges and a container object.
+    */
+    void Set(const wxRichTextRangeArray& ranges, wxRichTextParagraphLayoutBox* container)
+    { m_ranges = ranges; m_container = container; }
+
+    /**
+        Copies from @a sel.
+    */
+    void Copy(const wxRichTextSelection& sel)
+    { m_ranges = sel.m_ranges; m_container = sel.m_container; }
+
+    /**
+        Assignment operator.
+    */
+    void operator=(const wxRichTextSelection& sel) { Copy(sel); }
+
+    /**
+        Equality operator.
+    */
+    bool operator==(const wxRichTextSelection& sel) const;
+
+    /**
+        Index operator.
+    */
+    wxRichTextRange operator[](size_t i) const { return GetRange(i); }
+
+    /**
+        Returns the selection ranges.
+    */
+    wxRichTextRangeArray& GetRanges() { return m_ranges; }
+
+    /**
+        Returns the selection ranges.
+    */
+    const wxRichTextRangeArray& GetRanges() const { return m_ranges; }
+
+    /**
+        Sets the selection ranges.
+    */
+    void SetRanges(const wxRichTextRangeArray& ranges) { m_ranges = ranges; }
+
+    /**
+        Returns the number of ranges in the selection.
+    */
+    size_t GetCount() const { return m_ranges.GetCount(); }
+
+    /**
+        Returns the range at the given index.
+
+    */
+    wxRichTextRange GetRange(size_t i) const { return m_ranges[i]; }
+
+    /**
+        Returns the first range if there is one, otherwise wxRICHTEXT_NO_SELECTION.
+    */
+    wxRichTextRange GetRange() const { return (m_ranges.GetCount() > 0) ? (m_ranges[0]) : wxRICHTEXT_NO_SELECTION; }
+
+    /**
+        Sets a single range.
+    */
+    void SetRange(const wxRichTextRange& range) { m_ranges.Clear(); m_ranges.Add(range); }
+
+    /**
+        Returns the container for which the selection is valid.
+    */
+    wxRichTextParagraphLayoutBox* GetContainer() const { return m_container; }
+
+    /**
+        Sets the container for which the selection is valid.
+    */
+    void SetContainer(wxRichTextParagraphLayoutBox* container) { m_container = container; }
+
+    /**
+        Returns @true if the selection is valid.
+    */
+    bool IsValid() const { return m_ranges.GetCount() > 0 && GetContainer(); }
+
+    /**
+        Returns the selection appropriate to the specified object, if any; returns an empty array if none
+        at the level of the object's container.
+    */
+    wxRichTextRangeArray GetSelectionForObject(wxRichTextObject* obj) const;
+
+    /**
+        Returns @true if the given position is within the selection.
+    */
+    bool WithinSelection(long pos, wxRichTextObject* obj) const;
+
+    /**
+        Returns @true if the given position is within the selection.
+
+    */
+    bool WithinSelection(long pos) const { return WithinSelection(pos, m_ranges); }
+
+    /**
+        Returns @true if the given position is within the selection range.
+    */
+    static bool WithinSelection(long pos, const wxRichTextRangeArray& ranges);
+
+    /**
+        Returns @true if the given range is within the selection range.
+    */
+    static bool WithinSelection(const wxRichTextRange& range, const wxRichTextRangeArray& ranges);
+
+    wxRichTextRangeArray            m_ranges;
+    wxRichTextParagraphLayoutBox*   m_container;
 };
 
 };
 
-#define wxTEXT_ATTR_CHARACTER (wxTEXT_ATTR_FONT | wxTEXT_ATTR_BACKGROUND_COLOUR | wxTEXT_ATTR_TEXT_COLOUR)
+/**
+    @class wxRichTextObject
 
 
-#define wxTEXT_ATTR_PARAGRAPH (wxTEXT_ATTR_ALIGNMENT|wxTEXT_ATTR_LEFT_INDENT|wxTEXT_ATTR_RIGHT_INDENT|wxTEXT_ATTR_TABS|\
-    wxTEXT_ATTR_PARA_SPACING_BEFORE|wxTEXT_ATTR_PARA_SPACING_AFTER|wxTEXT_ATTR_LINE_SPACING|\
-    wxTEXT_ATTR_BULLET_STYLE|wxTEXT_ATTR_BULLET_NUMBER|wxTEXT_ATTR_BULLET_SYMBOL)
+    This is the base for drawable rich text objects.
 
 
-#define wxTEXT_ATTR_ALL (wxTEXT_ATTR_CHARACTER|wxTEXT_ATTR_PARAGRAPH)
+    @library{wxrichtext}
+    @category{richtext}
 
 
-/*!
- * wxRichTextObject class declaration
- * This is the base for drawable objects.
- */
+    @see wxRichTextBuffer, wxRichTextCtrl
+*/
 
 class WXDLLIMPEXP_RICHTEXT wxRichTextObject: public wxObject
 {
     DECLARE_CLASS(wxRichTextObject)
 public:
 
 class WXDLLIMPEXP_RICHTEXT wxRichTextObject: public wxObject
 {
     DECLARE_CLASS(wxRichTextObject)
 public:
-// Constructors
-
+    /**
+        Constructor, taking an optional parent pointer.
+    */
     wxRichTextObject(wxRichTextObject* parent = NULL);
     wxRichTextObject(wxRichTextObject* parent = NULL);
+
     virtual ~wxRichTextObject();
 
     virtual ~wxRichTextObject();
 
-// Overrideables
+// Overridables
 
 
-    /// Draw the item, within the given range. Some objects may ignore the range (for
-    /// example paragraphs) while others must obey it (lines, to implement wrapping)
-    virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextRange& selectionRange, const wxRect& rect, int descent, int style) = 0;
+    /**
+        Draw the item, within the given range. Some objects may ignore the range (for
+        example paragraphs) while others must obey it (lines, to implement wrapping)
+    */
+    virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style) = 0;
 
 
-    /// Lay the item out at the specified position with the given size constraint.
-    /// Layout must set the cached size.
+    /**
+        Lay the item out at the specified position with the given size constraint.
+        Layout must set the cached size.
+    */
     virtual bool Layout(wxDC& dc, const wxRect& rect, int style) = 0;
 
     virtual bool Layout(wxDC& dc, const wxRect& rect, int style) = 0;
 
-    /// Hit-testing: returns a flag indicating hit test details, plus
-    /// information about position
-    virtual int HitTest(wxDC& WXUNUSED(dc), const wxPoint& WXUNUSED(pt), long& WXUNUSED(textPosition)) { return false; }
+    /**
+        Hit-testing: returns a flag indicating hit test details, plus
+        information about position. @a contextObj is returned to specify what object
+        position is relevant to, since otherwise there's an ambiguity.
+        @ obj might not be a child of @a contextObj, since we may be referring to the container itself
+        if we have no hit on a child - for example if we click outside an object.
+
+        The function puts the position in @a textPosition if one is found.
+        @a pt is in logical units (a zero y position is at the beginning of the buffer).
 
 
-    /// Finds the absolute position and row height for the given character position
+        Pass wxRICHTEXT_HITTEST_NO_NESTED_OBJECTS if you only want to consider objects
+        directly under the object you are calling HitTest on. Otherwise, it will recurse
+        and potentially find a nested object.
+
+        @return One of the ::wxRichTextHitTestFlags values.
+    */
+
+    virtual int HitTest(wxDC& dc, const wxPoint& pt, long& textPosition, wxRichTextObject** obj, wxRichTextObject** contextObj, int flags = 0);
+
+    /**
+        Finds the absolute position and row height for the given character position.
+    */
     virtual bool FindPosition(wxDC& WXUNUSED(dc), long WXUNUSED(index), wxPoint& WXUNUSED(pt), int* WXUNUSED(height), bool WXUNUSED(forceLineStart)) { return false; }
 
     virtual bool FindPosition(wxDC& WXUNUSED(dc), long WXUNUSED(index), wxPoint& WXUNUSED(pt), int* WXUNUSED(height), bool WXUNUSED(forceLineStart)) { return false; }
 
-    /// Get the best size, i.e. the ideal starting size for this object irrespective
-    /// of available space. For a short text string, it will be the size that exactly encloses
-    /// the text. For a longer string, it might use the parent width for example.
+    /**
+        Returns the best size, i.e. the ideal starting size for this object irrespective
+        of available space. For a short text string, it will be the size that exactly encloses
+        the text. For a longer string, it might use the parent width for example.
+    */
     virtual wxSize GetBestSize() const { return m_size; }
 
     virtual wxSize GetBestSize() const { return m_size; }
 
-    /// Get the object size for the given range. Returns false if the range
-    /// is invalid for this object.
-    virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position = wxPoint(0,0)) const  = 0;
+    /**
+        Returns the object size for the given range. Returns @false if the range
+        is invalid for this object.
+    */
+
+    virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position = wxPoint(0,0), wxArrayInt* partialExtents = NULL) const  = 0;
 
 
-    /// Do a split, returning an object containing the second part, and setting
-    /// the first part in 'this'.
+    /**
+        Do a split from @a pos, returning an object containing the second part, and setting
+        the first part in 'this'.
+    */
     virtual wxRichTextObject* DoSplit(long WXUNUSED(pos)) { return NULL; }
 
     virtual wxRichTextObject* DoSplit(long WXUNUSED(pos)) { return NULL; }
 
-    /// Calculate range. By default, guess that the object is 1 unit long.
+    /**
+        Calculates the range of the object. By default, guess that the object is 1 unit long.
+    */
     virtual void CalculateRange(long start, long& end) { end = start ; m_range.SetRange(start, end); }
 
     virtual void CalculateRange(long start, long& end) { end = start ; m_range.SetRange(start, end); }
 
-    /// Delete range
+    /**
+        Deletes the given range.
+    */
     virtual bool DeleteRange(const wxRichTextRange& WXUNUSED(range)) { return false; }
 
     virtual bool DeleteRange(const wxRichTextRange& WXUNUSED(range)) { return false; }
 
-    /// Returns true if the object is empty
+    /**
+        Returns @true if the object is empty.
+    */
     virtual bool IsEmpty() const { return false; }
 
     virtual bool IsEmpty() const { return false; }
 
-    /// Get any text in this object for the given range
+    /**
+        Returns @true if this class of object is floatable.
+    */
+    virtual bool IsFloatable() const { return false; }
+
+    /**
+        Returns @true if this object is currently floating.
+    */
+    virtual bool IsFloating() const { return GetAttributes().GetTextBoxAttr().IsFloating(); }
+
+    /**
+        Returns the floating direction.
+    */
+    virtual int GetFloatDirection() const { return GetAttributes().GetTextBoxAttr().GetFloatMode(); }
+
+    /**
+        Returns any text in this object for the given range.
+    */
     virtual wxString GetTextForRange(const wxRichTextRange& WXUNUSED(range)) const { return wxEmptyString; }
 
     virtual wxString GetTextForRange(const wxRichTextRange& WXUNUSED(range)) const { return wxEmptyString; }
 
-    /// Returns true if this object can merge itself with the given one.
+    /**
+        Returns @true if this object can merge itself with the given one.
+    */
     virtual bool CanMerge(wxRichTextObject* WXUNUSED(object)) const { return false; }
 
     virtual bool CanMerge(wxRichTextObject* WXUNUSED(object)) const { return false; }
 
-    /// Returns true if this object merged itself with the given one.
-    /// The calling code will then delete the given object.
+    /**
+        Returns @true if this object merged itself with the given one.
+        The calling code will then delete the given object.
+    */
     virtual bool Merge(wxRichTextObject* WXUNUSED(object)) { return false; }
 
     virtual bool Merge(wxRichTextObject* WXUNUSED(object)) { return false; }
 
-    /// Dump to output stream for debugging
+    /**
+        Dump object data to the given output stream for debugging.
+    */
     virtual void Dump(wxTextOutputStream& stream);
 
     virtual void Dump(wxTextOutputStream& stream);
 
+    /**
+        Returns @true if we can edit the object's properties via a GUI.
+    */
+    virtual bool CanEditProperties() const { return false; }
+
+    /**
+        Edits the object's properties via a GUI.
+    */
+    virtual bool EditProperties(wxWindow* WXUNUSED(parent), wxRichTextBuffer* WXUNUSED(buffer)) { return false; }
+
+    /**
+        Returns the label to be used for the properties context menu item.
+    */
+    virtual wxString GetPropertiesMenuLabel() const { return wxEmptyString; }
+
+    /**
+        Returns @true if objects of this class can accept the focus, i.e. a call to SetFocusObject
+        is possible. For example, containers supporting text, such as a text box object, can accept the focus,
+        but a table can't (set the focus to individual cells instead).
+    */
+    virtual bool AcceptsFocus() const { return false; }
+
+#if wxUSE_XML
+    /**
+        Imports this object from XML.
+    */
+    virtual bool ImportFromXML(wxRichTextBuffer* buffer, wxXmlNode* node, wxRichTextXMLHandler* handler, bool* recurse);
+#endif
+
+#if wxRICHTEXT_HAVE_DIRECT_OUTPUT
+    /**
+        Exports this object directly to the given stream, bypassing the creation of a wxXmlNode hierarchy.
+        This method is considerably faster than creating a tree first. However, both versions of ExportXML must be
+        implemented so that if the tree method is made efficient in the future, we can deprecate the
+        more verbose direct output method. Compiled only if wxRICHTEXT_HAVE_DIRECT_OUTPUT is defined (on by default).
+    */
+    virtual bool ExportXML(wxOutputStream& stream, int indent, wxRichTextXMLHandler* handler);
+#endif
+
+#if wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT
+    /**
+        Exports this object to the given parent node, usually creating at least one child node.
+        This method is less efficient than the direct-to-stream method but is retained to allow for
+        switching to this method if we make it more efficient. Compiled only if wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT is defined
+        (on by default).
+    */
+    virtual bool ExportXML(wxXmlNode* parent, wxRichTextXMLHandler* handler);
+#endif
+
+    /**
+        Returns @true if this object takes note of paragraph attributes (text and image objects don't).
+    */
+    virtual bool UsesParagraphAttributes() const { return true; }
+
+    /**
+        Returns the XML node name of this object. This must be overridden for wxXmlNode-base XML export to work.
+    */
+    virtual wxString GetXMLNodeName() const { return wxT("unknown"); }
+
+    /**
+        Invalidates the object at the given range. With no argument, invalidates the whole object.
+    */
+    virtual void Invalidate(const wxRichTextRange& invalidRange = wxRICHTEXT_ALL);
+
+    /**
+        Returns @true if this object can handle the selections of its children, fOr example a table.
+        Required for composite selection handling to work.
+    */
+    virtual bool HandlesChildSelections() const { return false; }
+
+    /**
+        Returns a selection object specifying the selections between start and end character positions.
+        For example, a table would deduce what cells (of range length 1) are selected when dragging across the table.
+    */
+    virtual wxRichTextSelection GetSelection(long WXUNUSED(start), long WXUNUSED(end)) const { return wxRichTextSelection(); }
+
 // Accessors
 
 // Accessors
 
-    /// Get/set the cached object size as calculated by Layout.
+    /**
+        Gets the cached object size as calculated by Layout.
+    */
     virtual wxSize GetCachedSize() const { return m_size; }
     virtual wxSize GetCachedSize() const { return m_size; }
+
+    /**
+        Sets the cached object size as calculated by Layout.
+    */
     virtual void SetCachedSize(const wxSize& sz) { m_size = sz; }
 
     virtual void SetCachedSize(const wxSize& sz) { m_size = sz; }
 
-    /// Get/set the object position
+    /**
+        Gets the maximum object size as calculated by Layout. This allows
+        us to fit an object to its contents or allocate extra space if required.
+    */
+    virtual wxSize GetMaxSize() const { return m_maxSize; }
+
+    /**
+        Sets the maximum object size as calculated by Layout. This allows
+        us to fit an object to its contents or allocate extra space if required.
+    */
+    virtual void SetMaxSize(const wxSize& sz) { m_maxSize = sz; }
+
+    /**
+        Gets the minimum object size as calculated by Layout. This allows
+        us to constrain an object to its absolute minimum size if necessary.
+    */
+    virtual wxSize GetMinSize() const { return m_minSize; }
+
+    /**
+        Sets the minimum object size as calculated by Layout. This allows
+        us to constrain an object to its absolute minimum size if necessary.
+    */
+    virtual void SetMinSize(const wxSize& sz) { m_minSize = sz; }
+
+    /**
+        Gets the 'natural' size for an object. For an image, it would be the
+        image size.
+    */
+    virtual wxTextAttrSize GetNaturalSize() const { return wxTextAttrSize(); }
+
+    /**
+        Returns the object position in pixels.
+    */
     virtual wxPoint GetPosition() const { return m_pos; }
     virtual wxPoint GetPosition() const { return m_pos; }
+
+    /**
+        Sets the object position in pixels.
+    */
     virtual void SetPosition(const wxPoint& pos) { m_pos = pos; }
 
     virtual void SetPosition(const wxPoint& pos) { m_pos = pos; }
 
-    /// Get the rectangle enclosing the object
+    /**
+        Returns the absolute object position, by traversing up the child/parent hierarchy.
+        TODO: may not be needed, if all object positions are in fact relative to the
+        top of the coordinate space.
+    */
+    virtual wxPoint GetAbsolutePosition() const;
+
+    /**
+        Returns the rectangle enclosing the object.
+    */
     virtual wxRect GetRect() const { return wxRect(GetPosition(), GetCachedSize()); }
 
     virtual wxRect GetRect() const { return wxRect(GetPosition(), GetCachedSize()); }
 
-    /// Set the range
+    /**
+        Sets the object's range within its container.
+    */
     void SetRange(const wxRichTextRange& range) { m_range = range; }
 
     void SetRange(const wxRichTextRange& range) { m_range = range; }
 
-    /// Get the range
+    /**
+        Returns the object's range.
+    */
     const wxRichTextRange& GetRange() const { return m_range; }
     const wxRichTextRange& GetRange() const { return m_range; }
-    wxRichTextRange& GetRange() { return m_range; }
 
 
-    /// Get/set dirty flag (whether the object needs Layout to be called)
-    virtual bool GetDirty() const { return m_dirty; }
-    virtual void SetDirty(bool dirty) { m_dirty = dirty; }
+    /**
+        Returns the object's range.
+    */
+    wxRichTextRange& GetRange() { return m_range; }
 
 
-    /// Is this composite?
+    /**
+        Set the object's own range, for a top-level object with its own position space.
+    */
+    void SetOwnRange(const wxRichTextRange& range) { m_ownRange = range; }
+
+    /**
+        Returns the object's own range (valid if top-level).
+    */
+    const wxRichTextRange& GetOwnRange() const { return m_ownRange; }
+
+    /**
+        Returns the object's own range (valid if top-level).
+    */
+    wxRichTextRange& GetOwnRange() { return m_ownRange; }
+
+    /**
+        Returns the object's own range only if a top-level object.
+    */
+    wxRichTextRange GetOwnRangeIfTopLevel() const { return IsTopLevel() ? m_ownRange : m_range; }
+
+    /**
+        Returns @true if this object this composite.
+    */
     virtual bool IsComposite() const { return false; }
 
     virtual bool IsComposite() const { return false; }
 
-    /// Get/set the parent.
+    /**
+        Returns a pointer to the parent object.
+    */
     virtual wxRichTextObject* GetParent() const { return m_parent; }
     virtual wxRichTextObject* GetParent() const { return m_parent; }
+
+    /**
+        Sets the pointer to the parent object.
+    */
     virtual void SetParent(wxRichTextObject* parent) { m_parent = parent; }
 
     virtual void SetParent(wxRichTextObject* parent) { m_parent = parent; }
 
-    /// Set the margin around the object
+    /**
+        Returns the top-level container of this object.
+        May return itself if it's a container; use GetParentContainer to return
+        a different container.
+    */
+    virtual wxRichTextParagraphLayoutBox* GetContainer() const;
+
+    /**
+        Returns the top-level container of this object.
+        Returns a different container than itself, unless there's no parent, in which case it will return NULL.
+    */
+    virtual wxRichTextParagraphLayoutBox* GetParentContainer() const { return GetParent() ? GetParent()->GetContainer() : GetContainer(); }
+
+    /**
+        Set the margin around the object, in pixels.
+    */
     virtual void SetMargins(int margin);
     virtual void SetMargins(int margin);
-    virtual void SetMargins(int leftMargin, int rightMargin, int topMargin, int bottomMargin);
-    virtual int GetLeftMargin() const { return m_leftMargin; }
-    virtual int GetRightMargin() const { return m_rightMargin; }
-    virtual int GetTopMargin() const { return m_topMargin; }
-    virtual int GetBottomMargin() const { return m_bottomMargin; }
 
 
-    /// Set attributes object
-    void SetAttributes(const wxTextAttrEx& attr) { m_attributes = attr; }
-    const wxTextAttrEx& GetAttributes() const { return m_attributes; }
-    wxTextAttrEx& GetAttributes() { return m_attributes; }
+    /**
+        Set the margin around the object, in pixels.
+    */
+    virtual void SetMargins(int leftMargin, int rightMargin, int topMargin, int bottomMargin);
 
 
-    /// Set/get stored descent
+    /**
+        Returns the left margin of the object, in pixels.
+    */
+    virtual int GetLeftMargin() const;
+
+    /**
+        Returns the right margin of the object, in pixels.
+    */
+    virtual int GetRightMargin() const;
+
+    /**
+        Returns the top margin of the object, in pixels.
+    */
+    virtual int GetTopMargin() const;
+
+    /**
+        Returns the bottom margin of the object, in pixels.
+    */
+    virtual int GetBottomMargin() const;
+
+    /**
+        Calculates the available content space in the given rectangle, given the
+        margins, border and padding specified in the object's attributes.
+    */
+    virtual wxRect GetAvailableContentArea(wxDC& dc, const wxRect& outerRect) const;
+
+    /**
+        Lays out the object first with a given amount of space, and then if no width was specified in attr,
+        lays out the object again using the minimum size
+    */
+    virtual bool LayoutToBestSize(wxDC& dc, wxRichTextBuffer* buffer,
+                    const wxRichTextAttr& parentAttr, const wxRichTextAttr& attr, const wxRect& availableParentSpace, int style);
+
+    /**
+        Sets the object's attributes.
+    */
+    void SetAttributes(const wxRichTextAttr& attr) { m_attributes = attr; }
+
+    /**
+        Returns the object's attributes.
+    */
+    const wxRichTextAttr& GetAttributes() const { return m_attributes; }
+
+    /**
+        Returns the object's attributes.
+    */
+    wxRichTextAttr& GetAttributes() { return m_attributes; }
+
+    /**
+        Sets the object's properties.
+    */
+    wxRichTextProperties& GetProperties() { return m_properties; }
+
+    /**
+        Returns the object's properties.
+    */
+    const wxRichTextProperties& GetProperties() const { return m_properties; }
+
+    /**
+        Returns the object's properties.
+    */
+    void SetProperties(const wxRichTextProperties& props) { m_properties = props; }
+
+    /**
+        Sets the stored descent value.
+    */
     void SetDescent(int descent) { m_descent = descent; }
     void SetDescent(int descent) { m_descent = descent; }
+
+    /**
+        Returns the stored descent value.
+    */
     int GetDescent() const { return m_descent; }
 
     int GetDescent() const { return m_descent; }
 
+    /**
+        Returns the containing buffer.
+    */
+    wxRichTextBuffer* GetBuffer() const;
+
+    /**
+        Sets the identifying name for this object as a property using the "name" key.
+    */
+    void SetName(const wxString& name) { m_properties.SetProperty(wxT("name"), name); }
+
+    /**
+        Returns the identifying name for this object from the properties, using the "name" key.
+    */
+    wxString GetName() const { return m_properties.GetPropertyString(wxT("name")); }
+
+    /**
+        Returns @true if this object is top-level, i.e. contains its own paragraphs, such as a text box.
+    */
+    virtual bool IsTopLevel() const { return false; }
+
+    /**
+        Returns @true if the object will be shown, @false otherwise.
+    */
+    bool IsShown() const { return m_show; }
+
 // Operations
 
 // Operations
 
-    /// Clone the object
+    /**
+        Call to show or hide this object. This function does not cause the content to be
+        laid out or redrawn.
+    */
+    virtual void Show(bool show) { m_show = show; }
+
+    /**
+        Clones the object.
+    */
     virtual wxRichTextObject* Clone() const { return NULL; }
 
     virtual wxRichTextObject* Clone() const { return NULL; }
 
-    /// Copy
+    /**
+        Copies the object.
+    */
     void Copy(const wxRichTextObject& obj);
 
     void Copy(const wxRichTextObject& obj);
 
-    /// Reference-counting allows us to use the same object in multiple
-    /// lists (not yet used)
+    /**
+        Reference-counting allows us to use the same object in multiple
+        lists (not yet used).
+    */
+
     void Reference() { m_refCount ++; }
     void Reference() { m_refCount ++; }
+
+    /**
+        Reference-counting allows us to use the same object in multiple
+        lists (not yet used).
+    */
     void Dereference();
 
     void Dereference();
 
-    /// Convert units in tends of a millimetre to device units
-    int ConvertTenthsMMToPixels(wxDC& dc, int units);
+    /**
+        Moves the object recursively, by adding the offset from old to new.
+    */
+    virtual void Move(const wxPoint& pt);
+
+    /**
+        Converts units in tenths of a millimetre to device units.
+    */
+    int ConvertTenthsMMToPixels(wxDC& dc, int units) const;
+
+    /**
+        Converts units in tenths of a millimetre to device units.
+    */
+    static int ConvertTenthsMMToPixels(int ppi, int units, double scale = 1.0);
+
+    /**
+        Convert units in pixels to tenths of a millimetre.
+    */
+    int ConvertPixelsToTenthsMM(wxDC& dc, int pixels) const;
+
+    /**
+        Convert units in pixels to tenths of a millimetre.
+    */
+    static int ConvertPixelsToTenthsMM(int ppi, int pixels, double scale = 1.0);
+
+    /**
+        Draws the borders and background for the given rectangle and attributes.
+        @a boxRect is taken to be the outer margin box, not the box around the content.
+    */
+    static bool DrawBoxAttributes(wxDC& dc, wxRichTextBuffer* buffer, const wxRichTextAttr& attr, const wxRect& boxRect, int flags = 0);
+
+    /**
+        Draws a border.
+    */
+    static bool DrawBorder(wxDC& dc, wxRichTextBuffer* buffer, const wxTextAttrBorders& attr, const wxRect& rect, int flags = 0);
+
+    /**
+        Returns the various rectangles of the box model in pixels. You can either specify @a contentRect (inner)
+        or @a marginRect (outer), and the other must be the default rectangle (no width or height).
+        Note that the outline doesn't affect the position of the rectangle, it's drawn in whatever space
+        is available.
+    */
+    static bool GetBoxRects(wxDC& dc, wxRichTextBuffer* buffer, const wxRichTextAttr& attr, wxRect& marginRect, wxRect& borderRect, wxRect& contentRect, wxRect& paddingRect, wxRect& outlineRect);
+
+    /**
+        Returns the total margin for the object in pixels, taking into account margin, padding and border size.
+    */
+    static bool GetTotalMargin(wxDC& dc, wxRichTextBuffer* buffer, const wxRichTextAttr& attr, int& leftMargin, int& rightMargin,
+        int& topMargin, int& bottomMargin);
+
+    /**
+        Returns the rectangle which the child has available to it given restrictions specified in the
+        child attribute, e.g. 50% width of the parent, 400 pixels, x position 20% of the parent, etc.
+    */
+    static wxRect AdjustAvailableSpace(wxDC& dc, wxRichTextBuffer* buffer, const wxRichTextAttr& parentAttr, const wxRichTextAttr& childAttr, const wxRect& availableParentSpace);
 
 protected:
     wxSize                  m_size;
 
 protected:
     wxSize                  m_size;
+    wxSize                  m_maxSize;
+    wxSize                  m_minSize;
     wxPoint                 m_pos;
     int                     m_descent; // Descent for this object (if any)
     wxPoint                 m_pos;
     int                     m_descent; // Descent for this object (if any)
-    bool                    m_dirty;
     int                     m_refCount;
     int                     m_refCount;
+    bool                    m_show;
     wxRichTextObject*       m_parent;
 
     wxRichTextObject*       m_parent;
 
-    /// The range of this object (start position to end position)
+    // The range of this object (start position to end position)
     wxRichTextRange         m_range;
 
     wxRichTextRange         m_range;
 
-    /// Margins
-    int                     m_leftMargin;
-    int                     m_rightMargin;
-    int                     m_topMargin;
-    int                     m_bottomMargin;
+    // The internal range of this object, if it's a top-level object with its own range space
+    wxRichTextRange         m_ownRange;
 
 
-    /// Attributes
-    wxTextAttrEx            m_attributes;
+    // Attributes
+    wxRichTextAttr          m_attributes;
+
+    // Properties
+    wxRichTextProperties    m_properties;
 };
 
 WX_DECLARE_LIST_WITH_DECL( wxRichTextObject, wxRichTextObjectList, class WXDLLIMPEXP_RICHTEXT );
 
 };
 
 WX_DECLARE_LIST_WITH_DECL( wxRichTextObject, wxRichTextObjectList, class WXDLLIMPEXP_RICHTEXT );
 
-/*!
- * wxRichTextCompositeObject class declaration
- * Objects of this class can contain other objects.
- */
+/**
+    @class wxRichTextCompositeObject
+
+    Objects of this class can contain other objects.
+
+    @library{wxrichtext}
+    @category{richtext}
+
+    @see wxRichTextObject, wxRichTextBuffer, wxRichTextCtrl
+*/
 
 class WXDLLIMPEXP_RICHTEXT wxRichTextCompositeObject: public wxRichTextObject
 {
 
 class WXDLLIMPEXP_RICHTEXT wxRichTextCompositeObject: public wxRichTextObject
 {
@@ -688,339 +2529,727 @@ public:
     wxRichTextCompositeObject(wxRichTextObject* parent = NULL);
     virtual ~wxRichTextCompositeObject();
 
     wxRichTextCompositeObject(wxRichTextObject* parent = NULL);
     virtual ~wxRichTextCompositeObject();
 
-// Overrideables
+// Overridables
 
 
-    /// Hit-testing: returns a flag indicating hit test details, plus
-    /// information about position
-    virtual int HitTest(wxDC& dc, const wxPoint& pt, long& textPosition);
+    virtual int HitTest(wxDC& dc, const wxPoint& pt, long& textPosition, wxRichTextObject** obj, wxRichTextObject** contextObj, int flags = 0);
 
 
-    /// Finds the absolute position and row height for the given character position
     virtual bool FindPosition(wxDC& dc, long index, wxPoint& pt, int* height, bool forceLineStart);
 
     virtual bool FindPosition(wxDC& dc, long index, wxPoint& pt, int* height, bool forceLineStart);
 
-    /// Calculate range
     virtual void CalculateRange(long start, long& end);
 
     virtual void CalculateRange(long start, long& end);
 
-    /// Delete range
     virtual bool DeleteRange(const wxRichTextRange& range);
 
     virtual bool DeleteRange(const wxRichTextRange& range);
 
-    /// Get any text in this object for the given range
     virtual wxString GetTextForRange(const wxRichTextRange& range) const;
 
     virtual wxString GetTextForRange(const wxRichTextRange& range) const;
 
-    /// Dump to output stream for debugging
+    virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position = wxPoint(0,0), wxArrayInt* partialExtents = NULL) const;
+
     virtual void Dump(wxTextOutputStream& stream);
 
     virtual void Dump(wxTextOutputStream& stream);
 
+    virtual void Invalidate(const wxRichTextRange& invalidRange = wxRICHTEXT_ALL);
+
 // Accessors
 
 // Accessors
 
-    /// Get the children
+    /**
+        Returns the children.
+    */
     wxRichTextObjectList& GetChildren() { return m_children; }
     wxRichTextObjectList& GetChildren() { return m_children; }
+    /**
+        Returns the children.
+    */
     const wxRichTextObjectList& GetChildren() const { return m_children; }
 
     const wxRichTextObjectList& GetChildren() const { return m_children; }
 
-    /// Get the child count
+    /**
+        Returns the number of children.
+    */
     size_t GetChildCount() const ;
 
     size_t GetChildCount() const ;
 
-    /// Get the nth child
+    /**
+        Returns the nth child.
+    */
     wxRichTextObject* GetChild(size_t n) const ;
 
     wxRichTextObject* GetChild(size_t n) const ;
 
-    /// Get/set dirty flag
-    virtual bool GetDirty() const { return m_dirty; }
-    virtual void SetDirty(bool dirty) { m_dirty = dirty; }
-
-    /// Is this composite?
+    /**
+        Returns @true if this object is composite.
+    */
     virtual bool IsComposite() const { return true; }
 
     virtual bool IsComposite() const { return true; }
 
-    /// Returns true if the buffer is empty
+    /**
+        Returns true if the buffer is empty.
+    */
     virtual bool IsEmpty() const { return GetChildCount() == 0; }
 
     virtual bool IsEmpty() const { return GetChildCount() == 0; }
 
+    /**
+        Returns the child object at the given character position.
+    */
+    virtual wxRichTextObject* GetChildAtPosition(long pos) const;
+
 // Operations
 
 // Operations
 
-    /// Copy
     void Copy(const wxRichTextCompositeObject& obj);
 
     void Copy(const wxRichTextCompositeObject& obj);
 
-    /// Append a child, returning the position
+    void operator= (const wxRichTextCompositeObject& obj) { Copy(obj); }
+
+    /**
+        Appends a child, returning the position.
+    */
     size_t AppendChild(wxRichTextObject* child) ;
 
     size_t AppendChild(wxRichTextObject* child) ;
 
-    /// Insert the child in front of the given object, or at the beginning
+    /**
+        Inserts the child in front of the given object, or at the beginning.
+    */
     bool InsertChild(wxRichTextObject* child, wxRichTextObject* inFrontOf) ;
 
     bool InsertChild(wxRichTextObject* child, wxRichTextObject* inFrontOf) ;
 
-    /// Delete the child
+    /**
+        Removes and optionally deletes the specified child.
+    */
     bool RemoveChild(wxRichTextObject* child, bool deleteChild = false) ;
 
     bool RemoveChild(wxRichTextObject* child, bool deleteChild = false) ;
 
-    /// Delete all children
+    /**
+        Deletes all the children.
+    */
     bool DeleteChildren() ;
 
     bool DeleteChildren() ;
 
-    /// Recursively merge all pieces that can be merged.
-    bool Defragment();
+    /**
+        Recursively merges all pieces that can be merged.
+    */
+    bool Defragment(const wxRichTextRange& range = wxRICHTEXT_ALL);
+
+    /**
+        Moves the object recursively, by adding the offset from old to new.
+    */
+    virtual void Move(const wxPoint& pt);
 
 protected:
     wxRichTextObjectList    m_children;
 };
 
 
 protected:
     wxRichTextObjectList    m_children;
 };
 
-/*!
- * wxRichTextBox class declaration
- * This defines a 2D space to lay out objects
- */
-
-class WXDLLIMPEXP_RICHTEXT wxRichTextBox: public wxRichTextCompositeObject
-{
-    DECLARE_DYNAMIC_CLASS(wxRichTextBox)
-public:
-// Constructors
-
-    wxRichTextBox(wxRichTextObject* parent = NULL);
-    wxRichTextBox(const wxRichTextBox& obj): wxRichTextCompositeObject() { Copy(obj); }
+/**
+    @class wxRichTextParagraphBox
 
 
-// Overrideables
+    This class knows how to lay out paragraphs.
 
 
-    /// Draw the item
-    virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextRange& selectionRange, const wxRect& rect, int descent, int style);
+    @library{wxrichtext}
+    @category{richtext}
 
 
-    /// Lay the item out
-    virtual bool Layout(wxDC& dc, const wxRect& rect, int style);
-
-    /// Get/set the object size for the given range. Returns false if the range
-    /// is invalid for this object.
-    virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position = wxPoint(0,0)) const;
+    @see wxRichTextCompositeObject, wxRichTextObject, wxRichTextBuffer, wxRichTextCtrl
+*/
 
 
-// Accessors
-
-// Operations
-
-    /// Clone
-    virtual wxRichTextObject* Clone() const { return new wxRichTextBox(*this); }
-
-    /// Copy
-    void Copy(const wxRichTextBox& obj);
-
-protected:
-};
-
-/*!
- * wxRichTextParagraphBox class declaration
- * This box knows how to lay out paragraphs.
- */
-
-class WXDLLIMPEXP_RICHTEXT wxRichTextParagraphLayoutBox: public wxRichTextBox
+class WXDLLIMPEXP_RICHTEXT wxRichTextParagraphLayoutBox: public wxRichTextCompositeObject
 {
     DECLARE_DYNAMIC_CLASS(wxRichTextParagraphLayoutBox)
 public:
 // Constructors
 
     wxRichTextParagraphLayoutBox(wxRichTextObject* parent = NULL);
 {
     DECLARE_DYNAMIC_CLASS(wxRichTextParagraphLayoutBox)
 public:
 // Constructors
 
     wxRichTextParagraphLayoutBox(wxRichTextObject* parent = NULL);
-    wxRichTextParagraphLayoutBox(const wxRichTextParagraphLayoutBox& obj):wxRichTextBox() { Init(); Copy(obj); }
+    wxRichTextParagraphLayoutBox(const wxRichTextParagraphLayoutBox& obj): wxRichTextCompositeObject() { Init(); Copy(obj); }
+    ~wxRichTextParagraphLayoutBox();
+
+// Overridables
 
 
-// Overrideables
+    virtual int HitTest(wxDC& dc, const wxPoint& pt, long& textPosition, wxRichTextObject** obj, wxRichTextObject** contextObj, int flags = 0);
 
 
-    /// Draw the item
-    virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextRange& selectionRange, const wxRect& rect, int descent, int style);
+    virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
 
 
-    /// Lay the item out
     virtual bool Layout(wxDC& dc, const wxRect& rect, int style);
 
     virtual bool Layout(wxDC& dc, const wxRect& rect, int style);
 
-    /// Get/set the object size for the given range. Returns false if the range
-    /// is invalid for this object.
-    virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position = wxPoint(0,0)) const;
+    virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position = wxPoint(0,0), wxArrayInt* partialExtents = NULL) const;
 
 
-    /// Delete range
     virtual bool DeleteRange(const wxRichTextRange& range);
 
     virtual bool DeleteRange(const wxRichTextRange& range);
 
-    /// Get any text in this object for the given range
     virtual wxString GetTextForRange(const wxRichTextRange& range) const;
 
     virtual wxString GetTextForRange(const wxRichTextRange& range) const;
 
+#if wxUSE_XML
+    virtual bool ImportFromXML(wxRichTextBuffer* buffer, wxXmlNode* node, wxRichTextXMLHandler* handler, bool* recurse);
+#endif
+
+#if wxRICHTEXT_HAVE_DIRECT_OUTPUT
+    virtual bool ExportXML(wxOutputStream& stream, int indent, wxRichTextXMLHandler* handler);
+#endif
+
+#if wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT
+    virtual bool ExportXML(wxXmlNode* parent, wxRichTextXMLHandler* handler);
+#endif
+
+    virtual wxString GetXMLNodeName() const { return wxT("paragraphlayout"); }
+
+    virtual bool AcceptsFocus() const { return true; }
+
 // Accessors
 
 // Accessors
 
-    /// Associate a control with the buffer, for operations that for example require refreshing the window.
+    /**
+        Associates a control with the buffer, for operations that for example require refreshing the window.
+    */
     void SetRichTextCtrl(wxRichTextCtrl* ctrl) { m_ctrl = ctrl; }
 
     void SetRichTextCtrl(wxRichTextCtrl* ctrl) { m_ctrl = ctrl; }
 
-    /// Get the associated control.
+    /**
+        Returns the associated control.
+    */
     wxRichTextCtrl* GetRichTextCtrl() const { return m_ctrl; }
 
     wxRichTextCtrl* GetRichTextCtrl() const { return m_ctrl; }
 
+    /**
+        Sets a flag indicating whether the last paragraph is partial or complete.
+    */
+    void SetPartialParagraph(bool partialPara) { m_partialParagraph = partialPara; }
+
+    /**
+        Returns a flag indicating whether the last paragraph is partial or complete.
+    */
+    bool GetPartialParagraph() const { return m_partialParagraph; }
+
+    /**
+        Returns the style sheet associated with the overall buffer.
+    */
+    virtual wxRichTextStyleSheet* GetStyleSheet() const;
+
+    virtual bool IsTopLevel() const { return true; }
+
 // Operations
 
 // Operations
 
-    /// Initialize the object.
+    /**
+        Submits a command to insert paragraphs.
+    */
+    bool InsertParagraphsWithUndo(long pos, const wxRichTextParagraphLayoutBox& paragraphs, wxRichTextCtrl* ctrl, wxRichTextBuffer* buffer, int flags = 0);
+
+    /**
+        Submits a command to insert the given text.
+    */
+    bool InsertTextWithUndo(long pos, const wxString& text, wxRichTextCtrl* ctrl, wxRichTextBuffer* buffer, int flags = 0);
+
+    /**
+        Submits a command to insert the given text.
+    */
+    bool InsertNewlineWithUndo(long pos, wxRichTextCtrl* ctrl, wxRichTextBuffer* buffer, int flags = 0);
+
+    /**
+        Submits a command to insert the given image.
+    */
+    bool InsertImageWithUndo(long pos, const wxRichTextImageBlock& imageBlock,
+                                                        wxRichTextCtrl* ctrl, wxRichTextBuffer* buffer, int flags,
+                                                        const wxRichTextAttr& textAttr);
+
+    /**
+        Returns the style that is appropriate for a new paragraph at this position.
+        If the previous paragraph has a paragraph style name, looks up the next-paragraph
+        style.
+    */
+    wxRichTextAttr GetStyleForNewParagraph(wxRichTextBuffer* buffer, long pos, bool caretPosition = false, bool lookUpNewParaStyle=false) const;
+
+    /**
+        Inserts an object.
+    */
+    wxRichTextObject* InsertObjectWithUndo(long pos, wxRichTextObject *object, wxRichTextCtrl* ctrl, wxRichTextBuffer* buffer, int flags = 0);
+
+    /**
+        Submits a command to delete this range.
+    */
+    bool DeleteRangeWithUndo(const wxRichTextRange& range, wxRichTextCtrl* ctrl, wxRichTextBuffer* buffer);
+
+    /**
+        Draws the floating objects in this buffer.
+    */
+    void DrawFloats(wxDC& dc, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
+
+    /**
+        Moves an anchored object to another paragraph.
+    */
+    void MoveAnchoredObjectToParagraph(wxRichTextParagraph* from, wxRichTextParagraph* to, wxRichTextObject* obj);
+
+    /**
+        Initializes the object.
+    */
     void Init();
 
     void Init();
 
-    /// Clear all children
+    /**
+        Clears all the children.
+    */
     virtual void Clear();
 
     virtual void Clear();
 
-    /// Clear and initialize with one blank paragraph
+    /**
+        Clears and initializes with one blank paragraph.
+    */
     virtual void Reset();
 
     virtual void Reset();
 
-    /// Convenience function to add a paragraph of text
-    virtual wxRichTextRange AddParagraph(const wxString& text);
-
-    /// Convenience function to add an image
-    virtual wxRichTextRange AddImage(const wxImage& image);
-
-    /// Adds multiple paragraphs, based on newlines.
-    virtual wxRichTextRange AddParagraphs(const wxString& text);
-
-    /// Get the line at the given position. If caretPosition is true, the position is
-    /// a caret position, which is normally a smaller number.
+    /**
+        Convenience function to add a paragraph of text.
+    */
+    virtual wxRichTextRange AddParagraph(const wxString& text, wxRichTextAttr* paraStyle = NULL);
+
+    /**
+        Convenience function to add an image.
+    */
+    virtual wxRichTextRange AddImage(const wxImage& image, wxRichTextAttr* paraStyle = NULL);
+
+    /**
+        Adds multiple paragraphs, based on newlines.
+    */
+    virtual wxRichTextRange AddParagraphs(const wxString& text, wxRichTextAttr* paraStyle = NULL);
+
+    /**
+        Returns the line at the given position. If @a caretPosition is true, the position is
+        a caret position, which is normally a smaller number.
+    */
     virtual wxRichTextLine* GetLineAtPosition(long pos, bool caretPosition = false) const;
 
     virtual wxRichTextLine* GetLineAtPosition(long pos, bool caretPosition = false) const;
 
-    /// Get the line at the given y pixel position, or the last line.
+    /**
+        Returns the line at the given y pixel position, or the last line.
+    */
     virtual wxRichTextLine* GetLineAtYPosition(int y) const;
 
     virtual wxRichTextLine* GetLineAtYPosition(int y) const;
 
-    /// Get the paragraph at the given character or caret position
+    /**
+        Returns the paragraph at the given character or caret position.
+    */
     virtual wxRichTextParagraph* GetParagraphAtPosition(long pos, bool caretPosition = false) const;
 
     virtual wxRichTextParagraph* GetParagraphAtPosition(long pos, bool caretPosition = false) const;
 
-    /// Get the line size at the given position
+    /**
+        Returns the line size at the given position.
+    */
     virtual wxSize GetLineSizeAtPosition(long pos, bool caretPosition = false) const;
 
     virtual wxSize GetLineSizeAtPosition(long pos, bool caretPosition = false) const;
 
-    /// Given a position, get the number of the visible line (potentially many to a paragraph),
-    /// starting from zero at the start of the buffer. We also have to pass a bool (startOfLine)
-    /// that indicates whether the caret is being shown at the end of the previous line or at the start
-    /// of the next, since the caret can be shown at 2 visible positions for the same underlying
-    /// position.
+    /**
+        Given a position, returns the number of the visible line (potentially many to a paragraph),
+        starting from zero at the start of the buffer. We also have to pass a bool (@a startOfLine)
+        that indicates whether the caret is being shown at the end of the previous line or at the start
+        of the next, since the caret can be shown at two visible positions for the same underlying
+        position.
+    */
     virtual long GetVisibleLineNumber(long pos, bool caretPosition = false, bool startOfLine = false) const;
 
     virtual long GetVisibleLineNumber(long pos, bool caretPosition = false, bool startOfLine = false) const;
 
-    /// Given a line number, get the corresponding wxRichTextLine object.
+    /**
+        Given a line number, returns the corresponding wxRichTextLine object.
+    */
     virtual wxRichTextLine* GetLineForVisibleLineNumber(long lineNumber) const;
 
     virtual wxRichTextLine* GetLineForVisibleLineNumber(long lineNumber) const;
 
-    /// Get the leaf object in a paragraph at this position.
-    /// Given a line number, get the corresponding wxRichTextLine object.
+    /**
+        Returns the leaf object in a paragraph at this position.
+    */
     virtual wxRichTextObject* GetLeafObjectAtPosition(long position) const;
 
     virtual wxRichTextObject* GetLeafObjectAtPosition(long position) const;
 
-    /// Get the paragraph by number
+    /**
+        Returns the paragraph by number.
+    */
     virtual wxRichTextParagraph* GetParagraphAtLine(long paragraphNumber) const;
 
     virtual wxRichTextParagraph* GetParagraphAtLine(long paragraphNumber) const;
 
-    /// Get the paragraph for a given line
+    /**
+        Returns the paragraph for a given line.
+    */
     virtual wxRichTextParagraph* GetParagraphForLine(wxRichTextLine* line) const;
 
     virtual wxRichTextParagraph* GetParagraphForLine(wxRichTextLine* line) const;
 
-    /// Get the length of the paragraph
+    /**
+        Returns the length of the paragraph.
+    */
     virtual int GetParagraphLength(long paragraphNumber) const;
 
     virtual int GetParagraphLength(long paragraphNumber) const;
 
-    /// Get the number of paragraphs
-    virtual int GetParagraphCount() const { return GetChildCount(); }
+    /**
+        Returns the number of paragraphs.
+    */
+    virtual int GetParagraphCount() const { return static_cast<int>(GetChildCount()); }
 
 
-    /// Get the number of visible lines
+    /**
+        Returns the number of visible lines.
+    */
     virtual int GetLineCount() const;
 
     virtual int GetLineCount() const;
 
-    /// Get the text of the paragraph
+    /**
+        Returns the text of the paragraph.
+    */
     virtual wxString GetParagraphText(long paragraphNumber) const;
 
     virtual wxString GetParagraphText(long paragraphNumber) const;
 
-    /// Convert zero-based line column and paragraph number to a position.
+    /**
+        Converts zero-based line column and paragraph number to a position.
+    */
     virtual long XYToPosition(long x, long y) const;
 
     virtual long XYToPosition(long x, long y) const;
 
-    /// Convert zero-based position to line column and paragraph number
+    /**
+        Converts a zero-based position to line column and paragraph number.
+    */
     virtual bool PositionToXY(long pos, long* x, long* y) const;
 
     virtual bool PositionToXY(long pos, long* x, long* y) const;
 
-    /// Set text attributes: character and/or paragraph styles.
-    virtual bool SetStyle(const wxRichTextRange& range, const wxRichTextAttr& style, bool withUndo = true);
-    virtual bool SetStyle(const wxRichTextRange& range, const wxTextAttrEx& style, bool withUndo = true);
-
-    /// Get the text attributes for this position.
-    virtual bool GetStyle(long position, wxTextAttrEx& style) const;
-    virtual bool GetStyle(long position, wxRichTextAttr& style) const;
-
-    /// 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;
+    /**
+        Sets the attributes for the given range. Pass flags to determine how the
+        attributes are set.
+
+        The end point of range is specified as the last character position of the span
+        of text. So, for example, to set the style for a character at position 5,
+        use the range (5,5).
+        This differs from the wxRichTextCtrl API, where you would specify (5,6).
+
+        @a flags may contain a bit list of the following values:
+        - wxRICHTEXT_SETSTYLE_NONE: no style flag.
+        - wxRICHTEXT_SETSTYLE_WITH_UNDO: specifies that this operation should be
+          undoable.
+        - wxRICHTEXT_SETSTYLE_OPTIMIZE: specifies that the style should not be applied
+          if the combined style at this point is already the style in question.
+        - wxRICHTEXT_SETSTYLE_PARAGRAPHS_ONLY: specifies that the style should only be
+          applied to paragraphs, and not the content.
+          This allows content styling to be preserved independently from that
+          of e.g. a named paragraph style.
+        - wxRICHTEXT_SETSTYLE_CHARACTERS_ONLY: specifies that the style should only be
+          applied to characters, and not the paragraph.
+          This allows content styling to be preserved independently from that
+          of e.g. a named paragraph style.
+        - wxRICHTEXT_SETSTYLE_RESET: resets (clears) the existing style before applying
+          the new style.
+        - wxRICHTEXT_SETSTYLE_REMOVE: removes the specified style.
+          Only the style flags are used in this operation.
+    */
+    virtual bool SetStyle(const wxRichTextRange& range, const wxRichTextAttr& style, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO);
+
+    /**
+        Sets the attributes for the given object only, for example the box attributes for a text box.
+    */
+    virtual void SetStyle(wxRichTextObject *obj, const wxRichTextAttr& textAttr, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO);
+
+    /**
+        Returns the combined text attributes for this position.
+
+        This function gets the @e uncombined style - that is, the attributes associated
+        with the paragraph or character content, and not necessarily the combined
+        attributes you see on the screen. To get the combined attributes, use GetStyle().
+        If you specify (any) paragraph attribute in @e style's flags, this function
+        will fetch the paragraph attributes.
+        Otherwise, it will return the character attributes.
+    */
+    virtual bool GetStyle(long position, wxRichTextAttr& style);
+
+    /**
+        Returns the content (uncombined) attributes for this position.
+    */
+    virtual bool GetUncombinedStyle(long position, wxRichTextAttr& style);
+
+    /**
+        Implementation helper for GetStyle. If combineStyles is true, combine base, paragraph and
+        context attributes.
+    */
+    virtual bool DoGetStyle(long position, wxRichTextAttr& style, bool combineStyles = true);
+
+    /**
+        This function gets a style representing the common, combined attributes in the
+        given range.
+        Attributes which have different values within the specified range will not be
+        included the style flags.
+
+        The function is used to get the attributes to display in the formatting dialog:
+        the user can edit the attributes common to the selection, and optionally specify the
+        values of further attributes to be applied uniformly.
+
+        To apply the edited attributes, you can use SetStyle() specifying
+        the wxRICHTEXT_SETSTYLE_OPTIMIZE flag, which will only apply attributes that
+        are different from the @e combined attributes within the range.
+        So, the user edits the effective, displayed attributes for the range,
+        but his choice won't be applied unnecessarily to content. As an example,
+        say the style for a paragraph specifies bold, but the paragraph text doesn't
+        specify a weight.
+        The combined style is bold, and this is what the user will see on-screen and
+        in the formatting dialog. The user now specifies red text, in addition to bold.
+        When applying with SetStyle(), the content font weight attributes won't be
+        changed to bold because this is already specified by the paragraph.
+        However the text colour attributes @e will be changed to show red.
+    */
+    virtual bool GetStyleForRange(const wxRichTextRange& range, wxRichTextAttr& style);
+
+    /**
+        Combines @a style with @a currentStyle for the purpose of summarising the attributes of a range of
+        content.
+    */
+    bool CollectStyle(wxRichTextAttr& currentStyle, const wxRichTextAttr& style, wxRichTextAttr& clashingAttr, wxRichTextAttr& absentAttr);
+
+    //@{
+    /**
+        Sets the list attributes for the given range, passing flags to determine how
+        the attributes are set.
+        Either the style definition or the name of the style definition (in the current
+        sheet) can be passed.
+
+        @a flags is a bit list of the following:
+        - wxRICHTEXT_SETSTYLE_WITH_UNDO: specifies that this command will be undoable.
+        - wxRICHTEXT_SETSTYLE_RENUMBER: specifies that numbering should start from
+          @a startFrom, otherwise existing attributes are used.
+        - wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL: specifies that @a listLevel should be used
+          as the level for all paragraphs, otherwise the current indentation will be used.
+
+        @see NumberList(), PromoteList(), ClearListStyle().
+    */
+    virtual bool SetListStyle(const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
+    virtual bool SetListStyle(const wxRichTextRange& range, const wxString& defName, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
+    //@}
+
+    /**
+        Clears the list style from the given range, clearing list-related attributes
+        and applying any named paragraph style associated with each paragraph.
+
+        @a flags is a bit list of the following:
+        - wxRICHTEXT_SETSTYLE_WITH_UNDO: specifies that this command will be undoable.
+
+        @see SetListStyle(), PromoteList(), NumberList()
+    */
+    virtual bool ClearListStyle(const wxRichTextRange& range, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO);
+
+    //@{
+    /**
+        Numbers the paragraphs in the given range.
+
+        Pass flags to determine how the attributes are set.
+        Either the style definition or the name of the style definition (in the current
+        sheet) can be passed.
+
+        @a flags is a bit list of the following:
+        - wxRICHTEXT_SETSTYLE_WITH_UNDO: specifies that this command will be undoable.
+        - wxRICHTEXT_SETSTYLE_RENUMBER: specifies that numbering should start from
+          @a startFrom, otherwise existing attributes are used.
+        - wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL: specifies that @a listLevel should be used
+          as the level for all paragraphs, otherwise the current indentation will be used.
+
+        @a def can be NULL to indicate that the existing list style should be used.
+
+        @see SetListStyle(), PromoteList(), ClearListStyle()
+    */
+    virtual bool NumberList(const wxRichTextRange& range, wxRichTextListStyleDefinition* def = NULL, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
+    virtual bool NumberList(const wxRichTextRange& range, const wxString& defName, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
+    //@}
+
+    //@{
+    /**
+        Promotes the list items within the given range.
+        A positive @a promoteBy produces a smaller indent, and a negative number
+        produces a larger indent. Pass flags to determine how the attributes are set.
+        Either the style definition or the name of the style definition (in the current
+        sheet) can be passed.
+
+        @a flags is a bit list of the following:
+        - wxRICHTEXT_SETSTYLE_WITH_UNDO: specifies that this command will be undoable.
+        - wxRICHTEXT_SETSTYLE_RENUMBER: specifies that numbering should start from
+          @a startFrom, otherwise existing attributes are used.
+        - wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL: specifies that @a listLevel should be used
+          as the level for all paragraphs, otherwise the current indentation will be used.
+
+        @see SetListStyle(), SetListStyle(), ClearListStyle()
+    */
+    virtual bool PromoteList(int promoteBy, const wxRichTextRange& range, wxRichTextListStyleDefinition* def = NULL, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int specifiedLevel = -1);
+    virtual bool PromoteList(int promoteBy, const wxRichTextRange& range, const wxString& defName, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int specifiedLevel = -1);
+    //@}
+
+    /**
+        Helper for NumberList and PromoteList, that does renumbering and promotion simultaneously
+        @a def can be NULL/empty to indicate that the existing list style should be used.
+    */
+    virtual bool DoNumberList(const wxRichTextRange& range, const wxRichTextRange& promotionRange, int promoteBy, wxRichTextListStyleDefinition* def, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
+
+    /**
+        Fills in the attributes for numbering a paragraph after previousParagraph.
+    */
+    virtual bool FindNextParagraphNumber(wxRichTextParagraph* previousParagraph, wxRichTextAttr& attr) const;
+
+    /**
+        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 wxRichTextAttr& style) const;
 
     virtual bool HasCharacterAttributes(const wxRichTextRange& range, const wxRichTextAttr& style) const;
 
-    /// 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;
+    /**
+        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 wxRichTextAttr& style) const;
 
     virtual bool HasParagraphAttributes(const wxRichTextRange& range, const wxRichTextAttr& style) const;
 
-    /// Clone
     virtual wxRichTextObject* Clone() const { return new wxRichTextParagraphLayoutBox(*this); }
 
     virtual wxRichTextObject* Clone() const { return new wxRichTextParagraphLayoutBox(*this); }
 
-    /// Insert fragment into this box at the given position. If partialParagraph is true,
-    /// it is assumed that the last (or only) paragraph is just a piece of data with no paragraph
-    /// marker.
-    virtual bool InsertFragment(long position, wxRichTextFragment& fragment);
+    /**
+        Insert fragment into this box at the given position. If partialParagraph is true,
+        it is assumed that the last (or only) paragraph is just a piece of data with no paragraph
+        marker.
+    */
+    virtual bool InsertFragment(long position, wxRichTextParagraphLayoutBox& fragment);
+
+    /**
+        Make a copy of the fragment corresponding to the given range, putting it in @a fragment.
+    */
+    virtual bool CopyFragment(const wxRichTextRange& range, wxRichTextParagraphLayoutBox& fragment);
 
 
-    /// Make a copy of the fragment corresponding to the given range, putting it in 'fragment'.
-    virtual bool CopyFragment(const wxRichTextRange& range, wxRichTextFragment& fragment);
+    /**
+        Apply the style sheet to the buffer, for example if the styles have changed.
+    */
+    virtual bool ApplyStyleSheet(wxRichTextStyleSheet* styleSheet);
 
 
-    /// Copy
     void Copy(const wxRichTextParagraphLayoutBox& obj);
 
     void Copy(const wxRichTextParagraphLayoutBox& obj);
 
-    /// Calculate ranges
-    virtual void UpdateRanges() { long end; CalculateRange(0, end); }
+    void operator= (const wxRichTextParagraphLayoutBox& obj) { Copy(obj); }
 
 
-    /// Get all the text
-    virtual wxString GetText() const;
+    /**
+        Calculate ranges.
+    */
+    virtual void UpdateRanges();
 
 
-    /// Set default style for new content. Setting it to a default attribute
-    /// makes new content take on the 'basic' style.
-    virtual bool SetDefaultStyle(const wxTextAttrEx& style);
+    /**
+        Get all the text.
+    */
+    virtual wxString GetText() const;
 
 
-    /// Get default style
-    virtual const wxTextAttrEx& GetDefaultStyle() const { return m_defaultAttributes; }
+    /**
+        Sets the default style, affecting the style currently being applied
+        (for example, setting the default style to bold will cause subsequently
+        inserted text to be bold).
+
+        This is not cumulative - setting the default style will replace the previous
+        default style.
+
+        Setting it to a default attribute object makes new content take on the 'basic' style.
+    */
+    virtual bool SetDefaultStyle(const wxRichTextAttr& style);
+
+    /**
+        Returns the current default style, affecting the style currently being applied
+        (for example, setting the default style to bold will cause subsequently
+        inserted text to be bold).
+    */
+    virtual const wxRichTextAttr& GetDefaultStyle() const { return m_defaultAttributes; }
+
+    /**
+        Sets the basic (overall) style. This is the style of the whole
+        buffer before further styles are applied, unlike the default style, which
+        only affects the style currently being applied (for example, setting the default
+        style to bold will cause subsequently inserted text to be bold).
+    */
+    virtual void SetBasicStyle(const wxRichTextAttr& style) { m_attributes = style; }
+
+    /**
+        Returns the basic (overall) style.
+
+        This is the style of the whole buffer before further styles are applied,
+        unlike the default style, which only affects the style currently being
+        applied (for example, setting the default style to bold will cause
+        subsequently inserted text to be bold).
+    */
+    virtual const wxRichTextAttr& GetBasicStyle() const { return m_attributes; }
+
+    /**
+        Invalidates the buffer. With no argument, invalidates whole buffer.
+    */
+    virtual void Invalidate(const wxRichTextRange& invalidRange = wxRICHTEXT_ALL);
+
+    /**
+        Do the (in)validation for this object only.
+    */
+    virtual void DoInvalidate(const wxRichTextRange& invalidRange);
+
+    /**
+        Do the (in)validation both up and down the hierarchy.
+    */
+    virtual void InvalidateHierarchy(const wxRichTextRange& invalidRange = wxRICHTEXT_ALL);
+
+    /**
+        Gather information about floating objects. If untilObj is non-NULL,
+        will stop getting information if the current object is this, since we
+        will collect the rest later.
+    */
+    virtual bool UpdateFloatingObjects(const wxRect& availableRect, wxRichTextObject* untilObj = NULL);
+
+    /**
+        Get invalid range, rounding to entire paragraphs if argument is true.
+    */
+    wxRichTextRange GetInvalidRange(bool wholeParagraphs = false) const;
 
 
-    /// Set basic (overall) style
-    virtual void SetBasicStyle(const wxTextAttrEx& style) { m_attributes = style; }
-    virtual void SetBasicStyle(const wxRichTextAttr& style) { style.CopyTo(m_attributes); }
+    /**
+        Returns @true if this object needs layout.
+    */
+    bool IsDirty() const { return m_invalidRange != wxRICHTEXT_NONE; }
 
 
-    /// Get basic (overall) style
-    virtual const wxTextAttrEx& GetBasicStyle() const { return m_attributes; }
+    /**
+        Returns the wxRichTextFloatCollector of this object.
+    */
+    wxRichTextFloatCollector* GetFloatCollector() { return m_floatCollector; }
 
 
-    /// Invalidate the buffer. With no argument, invalidates whole buffer.
-    void Invalidate(const wxRichTextRange& invalidRange = wxRICHTEXT_ALL);
+    /**
+        Returns the number of floating objects at this level.
+    */
+    int GetFloatingObjectCount() const;
 
 
-    /// Get invalid range, rounding to entire paragraphs if argument is true.
-    wxRichTextRange GetInvalidRange(bool wholeParagraphs = false) const;
+    /**
+        Returns a list of floating objects.
+    */
+    bool GetFloatingObjects(wxRichTextObjectList& objects) const;
 
 protected:
     wxRichTextCtrl* m_ctrl;
 
 protected:
     wxRichTextCtrl* m_ctrl;
-    wxTextAttrEx    m_defaultAttributes;
+    wxRichTextAttr  m_defaultAttributes;
+
+    // The invalidated range that will need full layout
+    wxRichTextRange m_invalidRange;
+
+    // Is the last paragraph partial or complete?
+    bool            m_partialParagraph;
 
 
-    /// The invalidated range that will need full layout
-    wxRichTextRange         m_invalidRange;
+    // The floating layout state
+    wxRichTextFloatCollector* m_floatCollector;
 };
 
 };
 
-/*!
- * wxRichTextFragment class declaration
- * This is a lind of paragraph layout box used for storing
- * paragraphs for Undo/Redo, for example.
- */
+/**
+    @class wxRichTextBox
+
+    This class implements a floating or inline text box, containing paragraphs.
+
+    @library{wxrichtext}
+    @category{richtext}
 
 
-class WXDLLIMPEXP_RICHTEXT wxRichTextFragment: public wxRichTextParagraphLayoutBox
+    @see wxRichTextParagraphLayoutBox, wxRichTextObject, wxRichTextBuffer, wxRichTextCtrl
+*/
+
+class WXDLLIMPEXP_RICHTEXT wxRichTextBox: public wxRichTextParagraphLayoutBox
 {
 {
-    DECLARE_DYNAMIC_CLASS(wxRichTextFragment)
+    DECLARE_DYNAMIC_CLASS(wxRichTextBox)
 public:
 // Constructors
 
 public:
 // Constructors
 
-    wxRichTextFragment() { Init(); }
-    wxRichTextFragment(const wxRichTextFragment& obj):wxRichTextParagraphLayoutBox() { Init(); Copy(obj); }
+    /**
+        Default constructor; optionally pass the parent object.
+    */
 
 
-// Accessors
+    wxRichTextBox(wxRichTextObject* parent = NULL);
 
 
-    /// Get/set whether the last paragraph is partial or complete
-    void SetPartialParagraph(bool partialPara) { m_partialParagraph = partialPara; }
-    bool GetPartialParagraph() const { return m_partialParagraph; }
+    /**
+        Copy constructor.
+    */
 
 
-// Overrideables
+    wxRichTextBox(const wxRichTextBox& obj): wxRichTextParagraphLayoutBox() { Copy(obj); }
 
 
-// Operations
+// Overridables
 
 
-    /// Initialise
-    void Init();
+    virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
 
 
-    /// Copy
-    void Copy(const wxRichTextFragment& obj);
+    virtual wxString GetXMLNodeName() const { return wxT("textbox"); }
 
 
-    /// Clone
-    virtual wxRichTextObject* Clone() const { return new wxRichTextFragment(*this); }
+    virtual bool CanEditProperties() const { return true; }
 
 
-protected:
+    virtual bool EditProperties(wxWindow* parent, wxRichTextBuffer* buffer);
 
 
-    // Is the last paragraph partial or complete?
-    bool        m_partialParagraph;
+    virtual wxString GetPropertiesMenuLabel() const { return _("&Box"); }
+
+// Accessors
+
+// Operations
+
+    virtual wxRichTextObject* Clone() const { return new wxRichTextBox(*this); }
+
+    void Copy(const wxRichTextBox& obj);
+
+protected:
 };
 
 };
 
-/*!
- * wxRichTextLine class declaration
- * This object represents a line in a paragraph, and stores
- * offsets from the start of the paragraph representing the
- * start and end positions of the line.
- */
+/**
+    @class wxRichTextLine
+
+    This object represents a line in a paragraph, and stores
+    offsets from the start of the paragraph representing the
+    start and end positions of the line.
+
+    @library{wxrichtext}
+    @category{richtext}
+
+    @see wxRichTextBuffer, wxRichTextCtrl
+*/
 
 class WXDLLIMPEXP_RICHTEXT wxRichTextLine
 {
 
 class WXDLLIMPEXP_RICHTEXT wxRichTextLine
 {
@@ -1031,173 +3260,302 @@ public:
     wxRichTextLine(const wxRichTextLine& obj) { Init( NULL); Copy(obj); }
     virtual ~wxRichTextLine() {}
 
     wxRichTextLine(const wxRichTextLine& obj) { Init( NULL); Copy(obj); }
     virtual ~wxRichTextLine() {}
 
-// Overrideables
+// Overridables
 
 // Accessors
 
 
 // Accessors
 
-    /// Set the range
+    /**
+        Sets the range associated with this line.
+    */
     void SetRange(const wxRichTextRange& range) { m_range = range; }
     void SetRange(const wxRichTextRange& range) { m_range = range; }
+    /**
+        Sets the range associated with this line.
+    */
     void SetRange(long from, long to) { m_range = wxRichTextRange(from, to); }
 
     void SetRange(long from, long to) { m_range = wxRichTextRange(from, to); }
 
-    /// Get the parent paragraph
+    /**
+        Returns the parent paragraph.
+    */
     wxRichTextParagraph* GetParent() { return m_parent; }
 
     wxRichTextParagraph* GetParent() { return m_parent; }
 
-    /// Get the range
+    /**
+        Returns the range.
+    */
     const wxRichTextRange& GetRange() const { return m_range; }
     const wxRichTextRange& GetRange() const { return m_range; }
+    /**
+        Returns the range.
+    */
     wxRichTextRange& GetRange() { return m_range; }
 
     wxRichTextRange& GetRange() { return m_range; }
 
-    /// Get the absolute range
+    /**
+        Returns the absolute range.
+    */
     wxRichTextRange GetAbsoluteRange() const;
 
     wxRichTextRange GetAbsoluteRange() const;
 
-    /// Get/set the line size as calculated by Layout.
+    /**
+        Returns the line size as calculated by Layout.
+    */
     virtual wxSize GetSize() const { return m_size; }
     virtual wxSize GetSize() const { return m_size; }
+
+    /**
+        Sets the line size as calculated by Layout.
+    */
     virtual void SetSize(const wxSize& sz) { m_size = sz; }
 
     virtual void SetSize(const wxSize& sz) { m_size = sz; }
 
-    /// Get/set the object position relative to the parent
+    /**
+        Returns the object position relative to the parent.
+    */
     virtual wxPoint GetPosition() const { return m_pos; }
     virtual wxPoint GetPosition() const { return m_pos; }
+
+    /**
+        Sets the object position relative to the parent.
+    */
     virtual void SetPosition(const wxPoint& pos) { m_pos = pos; }
 
     virtual void SetPosition(const wxPoint& pos) { m_pos = pos; }
 
-    /// Get the absolute object position
+    /**
+        Returns the absolute object position.
+    */
     virtual wxPoint GetAbsolutePosition() const;
 
     virtual wxPoint GetAbsolutePosition() const;
 
-    /// Get the rectangle enclosing the line
+    /**
+        Returns the rectangle enclosing the line.
+    */
     virtual wxRect GetRect() const { return wxRect(GetAbsolutePosition(), GetSize()); }
 
     virtual wxRect GetRect() const { return wxRect(GetAbsolutePosition(), GetSize()); }
 
-    /// Set/get stored descent
+    /**
+        Sets the stored descent.
+    */
     void SetDescent(int descent) { m_descent = descent; }
     void SetDescent(int descent) { m_descent = descent; }
+
+    /**
+        Returns the stored descent.
+    */
     int GetDescent() const { return m_descent; }
 
     int GetDescent() const { return m_descent; }
 
+#if wxRICHTEXT_USE_OPTIMIZED_LINE_DRAWING
+    wxArrayInt& GetObjectSizes() { return m_objectSizes; }
+    const wxArrayInt& GetObjectSizes() const { return m_objectSizes; }
+#endif
+
 // Operations
 
 // Operations
 
-    /// Initialisation
+    /**
+        Initialises the object.
+    */
     void Init(wxRichTextParagraph* parent);
 
     void Init(wxRichTextParagraph* parent);
 
-    /// Copy
+    /**
+        Copies from @a obj.
+    */
     void Copy(const wxRichTextLine& obj);
 
     void Copy(const wxRichTextLine& obj);
 
-    /// Clone
     virtual wxRichTextLine* Clone() const { return new wxRichTextLine(*this); }
 
 protected:
 
     virtual wxRichTextLine* Clone() const { return new wxRichTextLine(*this); }
 
 protected:
 
-    /// The range of the line (start position to end position)
-    /// This is relative to the parent paragraph.
+    // The range of the line (start position to end position)
+    // This is relative to the parent paragraph.
     wxRichTextRange     m_range;
 
     wxRichTextRange     m_range;
 
-    /// Size and position measured relative to top of paragraph
+    // Size and position measured relative to top of paragraph
     wxPoint             m_pos;
     wxSize              m_size;
 
     wxPoint             m_pos;
     wxSize              m_size;
 
-    /// Maximum descent for this line (location of text baseline)
+    // Maximum descent for this line (location of text baseline)
     int                 m_descent;
 
     // The parent object
     wxRichTextParagraph* m_parent;
     int                 m_descent;
 
     // The parent object
     wxRichTextParagraph* m_parent;
+
+#if wxRICHTEXT_USE_OPTIMIZED_LINE_DRAWING
+    wxArrayInt          m_objectSizes;
+#endif
 };
 
 WX_DECLARE_LIST_WITH_DECL( wxRichTextLine, wxRichTextLineList , class WXDLLIMPEXP_RICHTEXT );
 
 };
 
 WX_DECLARE_LIST_WITH_DECL( wxRichTextLine, wxRichTextLineList , class WXDLLIMPEXP_RICHTEXT );
 
-/*!
- * wxRichTextParagraph class declaration
- * This object represents a single paragraph (or in a straight text editor, a line).
- */
+/**
+    @class wxRichTextParagraph
+
+    This object represents a single paragraph containing various objects such as text content, images, and further paragraph layout objects.
+
+    @library{wxrichtext}
+    @category{richtext}
+
+    @see wxRichTextBuffer, wxRichTextCtrl
+*/
 
 
-class WXDLLIMPEXP_RICHTEXT wxRichTextParagraph: public wxRichTextBox
+class WXDLLIMPEXP_RICHTEXT wxRichTextParagraph: public wxRichTextCompositeObject
 {
     DECLARE_DYNAMIC_CLASS(wxRichTextParagraph)
 public:
 // Constructors
 
 {
     DECLARE_DYNAMIC_CLASS(wxRichTextParagraph)
 public:
 // Constructors
 
-    wxRichTextParagraph(wxRichTextObject* parent = NULL, wxTextAttrEx* style = NULL);
-    wxRichTextParagraph(const wxString& text, wxRichTextObject* parent = NULL, wxTextAttrEx* style = NULL);
+    /**
+        Constructor taking a parent and style.
+    */
+    wxRichTextParagraph(wxRichTextObject* parent = NULL, wxRichTextAttr* style = NULL);
+    /**
+        Constructor taking a text string, a parent and paragraph and character attributes.
+    */
+    wxRichTextParagraph(const wxString& text, wxRichTextObject* parent = NULL, wxRichTextAttr* paraStyle = NULL, wxRichTextAttr* charStyle = NULL);
     virtual ~wxRichTextParagraph();
     virtual ~wxRichTextParagraph();
-    wxRichTextParagraph(const wxRichTextParagraph& obj):wxRichTextBox() { Copy(obj); }
+    wxRichTextParagraph(const wxRichTextParagraph& obj): wxRichTextCompositeObject() { Copy(obj); }
 
 
-// Overrideables
+// Overridables
 
 
-    /// Draw the item
-    virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextRange& selectionRange, const wxRect& rect, int descent, int style);
+    virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
 
 
-    /// Lay the item out
     virtual bool Layout(wxDC& dc, const wxRect& rect, int style);
 
     virtual bool Layout(wxDC& dc, const wxRect& rect, int style);
 
-    /// Get/set the object size for the given range. Returns false if the range
-    /// is invalid for this object.
-    virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position = wxPoint(0,0)) const;
+    virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position = wxPoint(0,0), wxArrayInt* partialExtents = NULL) const;
 
 
-    /// Finds the absolute position and row height for the given character position
     virtual bool FindPosition(wxDC& dc, long index, wxPoint& pt, int* height, bool forceLineStart);
 
     virtual bool FindPosition(wxDC& dc, long index, wxPoint& pt, int* height, bool forceLineStart);
 
-    /// Hit-testing: returns a flag indicating hit test details, plus
-    /// information about position
-    virtual int HitTest(wxDC& dc, const wxPoint& pt, long& textPosition);
+    virtual int HitTest(wxDC& dc, const wxPoint& pt, long& textPosition, wxRichTextObject** obj, wxRichTextObject** contextObj, int flags = 0);
 
 
-    /// Calculate range
     virtual void CalculateRange(long start, long& end);
 
     virtual void CalculateRange(long start, long& end);
 
+    virtual wxString GetXMLNodeName() const { return wxT("paragraph"); }
+
 // Accessors
 
 // Accessors
 
-    /// Get the cached lines
+    /**
+        Returns the cached lines.
+    */
     wxRichTextLineList& GetLines() { return m_cachedLines; }
 
 // Operations
 
     wxRichTextLineList& GetLines() { return m_cachedLines; }
 
 // Operations
 
-    /// Copy
+    /**
+        Copies the object.
+    */
     void Copy(const wxRichTextParagraph& obj);
 
     void Copy(const wxRichTextParagraph& obj);
 
-    /// Clone
     virtual wxRichTextObject* Clone() const { return new wxRichTextParagraph(*this); }
 
     virtual wxRichTextObject* Clone() const { return new wxRichTextParagraph(*this); }
 
-    /// Clear the cached lines
+    /**
+        Clears the cached lines.
+    */
     void ClearLines();
 
 // Implementation
 
     void ClearLines();
 
 // Implementation
 
-    /// Apply paragraph styles such as centering to the wrapped lines
-    virtual void ApplyParagraphStyle(const wxRect& rect);
+    /**
+        Applies paragraph styles such as centering to the wrapped lines.
+    */
+    virtual void ApplyParagraphStyle(wxRichTextLine* line, const wxRichTextAttr& attr, const wxRect& rect, wxDC& dc);
 
 
-    /// Insert text at the given position
+    /**
+        Inserts text at the given position.
+    */
     virtual bool InsertText(long pos, const wxString& text);
 
     virtual bool InsertText(long pos, const wxString& text);
 
-    /// Split an object at this position if necessary, and return
-    /// the previous object, or NULL if inserting at beginning.
+    /**
+        Splits an object at this position if necessary, and returns
+        the previous object, or NULL if inserting at the beginning.
+    */
     virtual wxRichTextObject* SplitAt(long pos, wxRichTextObject** previousObject = NULL);
 
     virtual wxRichTextObject* SplitAt(long pos, wxRichTextObject** previousObject = NULL);
 
-    /// Move content to a list from this point
+    /**
+        Moves content to a list from this point.
+    */
     virtual void MoveToList(wxRichTextObject* obj, wxList& list);
 
     virtual void MoveToList(wxRichTextObject* obj, wxList& list);
 
-    /// Add content back from list
+    /**
+        Adds content back from a list.
+    */
     virtual void MoveFromList(wxList& list);
 
     virtual void MoveFromList(wxList& list);
 
-    /// Get the plain text searching from the start or end of the range.
-    /// The resulting string may be shorter than the range given.
+    /**
+        Returns the plain text searching from the start or end of the range.
+        The resulting string may be shorter than the range given.
+    */
     bool GetContiguousPlainText(wxString& text, const wxRichTextRange& range, bool fromStart = true);
 
     bool GetContiguousPlainText(wxString& text, const wxRichTextRange& range, bool fromStart = true);
 
-    /// Find a suitable wrap position. wrapPosition is the last position in the line to the left
-    /// of the split.
-    bool FindWrapPosition(const wxRichTextRange& range, wxDC& dc, int availableSpace, long& wrapPosition);
+    /**
+        Finds a suitable wrap position. @a wrapPosition is the last position in the line to the left
+        of the split.
+    */
+    bool FindWrapPosition(const wxRichTextRange& range, wxDC& dc, int availableSpace, long& wrapPosition, wxArrayInt* partialExtents);
 
 
-    /// Find the object at the given position
+    /**
+        Finds the object at the given position.
+    */
     wxRichTextObject* FindObjectAtPosition(long position);
 
     wxRichTextObject* FindObjectAtPosition(long position);
 
-    /// Get the bullet text for this paragraph.
+    /**
+        Returns the bullet text for this paragraph.
+    */
     wxString GetBulletText();
 
     wxString GetBulletText();
 
-    /// Allocate or reuse a line object
+    /**
+        Allocates or reuses a line object.
+    */
     wxRichTextLine* AllocateLine(int pos);
 
     wxRichTextLine* AllocateLine(int pos);
 
-    /// Clear remaining unused line objects, if any
+    /**
+        Clears remaining unused line objects, if any.
+    */
     bool ClearUnusedLines(int lineCount);
 
     bool ClearUnusedLines(int lineCount);
 
+    /**
+        Returns combined attributes of the base style, paragraph style and character style. We use this to dynamically
+        retrieve the actual style.
+    */
+    wxRichTextAttr GetCombinedAttributes(const wxRichTextAttr& contentStyle, bool includingBoxAttr = false) const;
+
+    /**
+        Returns the combined attributes of the base style and paragraph style.
+    */
+    wxRichTextAttr GetCombinedAttributes(bool includingBoxAttr = false) const;
+
+    /**
+        Returns the first position from pos that has a line break character.
+    */
+    long GetFirstLineBreakPosition(long pos);
+
+    /**
+        Creates a default tabstop array.
+    */
+    static void InitDefaultTabs();
+
+    /**
+        Clears the default tabstop array.
+    */
+    static void ClearDefaultTabs();
+
+    /**
+        Returns the default tabstop array.
+    */
+    static const wxArrayInt& GetDefaultTabs() { return sm_defaultTabs; }
+
+    /**
+        Lays out the floating objects.
+    */
+    void LayoutFloat(wxDC& dc, const wxRect& rect, int style, wxRichTextFloatCollector* floatCollector);
+
 protected:
 protected:
-    /// The lines that make up the wrapped paragraph
+
+    // The lines that make up the wrapped paragraph
     wxRichTextLineList m_cachedLines;
     wxRichTextLineList m_cachedLines;
+
+    // Default tabstops
+    static wxArrayInt  sm_defaultTabs;
+
+friend class wxRichTextFloatCollector;
 };
 
 };
 
-/*!
- * wxRichTextPlainText class declaration
- * This object represents a single piece of text.
- */
+/**
+    @class wxRichTextPlainText
+
+    This object represents a single piece of text.
+
+    @library{wxrichtext}
+    @category{richtext}
+
+    @see wxRichTextBuffer, wxRichTextCtrl
+*/
 
 class WXDLLIMPEXP_RICHTEXT wxRichTextPlainText: public wxRichTextObject
 {
 
 class WXDLLIMPEXP_RICHTEXT wxRichTextPlainText: public wxRichTextObject
 {
@@ -1205,137 +3563,245 @@ class WXDLLIMPEXP_RICHTEXT wxRichTextPlainText: public wxRichTextObject
 public:
 // Constructors
 
 public:
 // Constructors
 
-    wxRichTextPlainText(const wxString& text = wxEmptyString, wxRichTextObject* parent = NULL, wxTextAttrEx* style = NULL);
-    wxRichTextPlainText(const wxRichTextPlainText& obj):wxRichTextObject() { Copy(obj); }
+    /**
+        Constructor.
+    */
+    wxRichTextPlainText(const wxString& text = wxEmptyString, wxRichTextObject* parent = NULL, wxRichTextAttr* style = NULL);
+
+    /**
+        Copy constructor.
+    */
+    wxRichTextPlainText(const wxRichTextPlainText& obj): wxRichTextObject() { Copy(obj); }
 
 
-// Overrideables
+// Overridables
 
 
-    /// Draw the item
-    virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextRange& selectionRange, const wxRect& rect, int descent, int style);
+    virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
 
 
-    /// Lay the item out
     virtual bool Layout(wxDC& dc, const wxRect& rect, int style);
 
     virtual bool Layout(wxDC& dc, const wxRect& rect, int style);
 
-    /// Get/set the object size for the given range. Returns false if the range
-    /// is invalid for this object.
-    virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position/* = wxPoint(0,0)*/) const;
+    virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position = wxPoint(0,0), wxArrayInt* partialExtents = NULL) const;
 
 
-    /// Get any text in this object for the given range
     virtual wxString GetTextForRange(const wxRichTextRange& range) const;
 
     virtual wxString GetTextForRange(const wxRichTextRange& range) const;
 
-    /// Do a split, returning an object containing the second part, and setting
-    /// the first part in 'this'.
     virtual wxRichTextObject* DoSplit(long pos);
 
     virtual wxRichTextObject* DoSplit(long pos);
 
-    /// Calculate range
     virtual void CalculateRange(long start, long& end);
 
     virtual void CalculateRange(long start, long& end);
 
-    /// Delete range
     virtual bool DeleteRange(const wxRichTextRange& range);
 
     virtual bool DeleteRange(const wxRichTextRange& range);
 
-    /// Returns true if the object is empty
     virtual bool IsEmpty() const { return m_text.empty(); }
 
     virtual bool IsEmpty() const { return m_text.empty(); }
 
-    /// Returns true if this object can merge itself with the given one.
     virtual bool CanMerge(wxRichTextObject* object) const;
 
     virtual bool CanMerge(wxRichTextObject* object) const;
 
-    /// Returns true if this object merged itself with the given one.
-    /// The calling code will then delete the given object.
     virtual bool Merge(wxRichTextObject* object);
 
     virtual bool Merge(wxRichTextObject* object);
 
-    /// Dump to output stream for debugging
     virtual void Dump(wxTextOutputStream& stream);
 
     virtual void Dump(wxTextOutputStream& stream);
 
+    /**
+        Get the first position from pos that has a line break character.
+    */
+    long GetFirstLineBreakPosition(long pos);
+
+    /// Does this object take note of paragraph attributes? Text and image objects don't.
+    virtual bool UsesParagraphAttributes() const { return false; }
+
+#if wxUSE_XML
+    virtual bool ImportFromXML(wxRichTextBuffer* buffer, wxXmlNode* node, wxRichTextXMLHandler* handler, bool* recurse);
+#endif
+
+#if wxRICHTEXT_HAVE_DIRECT_OUTPUT
+    virtual bool ExportXML(wxOutputStream& stream, int indent, wxRichTextXMLHandler* handler);
+#endif
+
+#if wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT
+    virtual bool ExportXML(wxXmlNode* parent, wxRichTextXMLHandler* handler);
+#endif
+
+    virtual wxString GetXMLNodeName() const { return wxT("text"); }
+
 // Accessors
 
 // Accessors
 
-    /// Get the text
+    /**
+        Returns the text.
+    */
     const wxString& GetText() const { return m_text; }
 
     const wxString& GetText() const { return m_text; }
 
-    /// Set the text
+    /**
+        Sets the text.
+    */
     void SetText(const wxString& text) { m_text = text; }
 
 // Operations
 
     void SetText(const wxString& text) { m_text = text; }
 
 // Operations
 
-    /// Copy
+    // Copies the text object,
     void Copy(const wxRichTextPlainText& obj);
 
     void Copy(const wxRichTextPlainText& obj);
 
-    /// Clone
+    // Clones the text object.
     virtual wxRichTextObject* Clone() const { return new wxRichTextPlainText(*this); }
     virtual wxRichTextObject* Clone() const { return new wxRichTextPlainText(*this); }
+
 private:
 private:
-    bool DrawTabbedString(wxDC& dc,const wxRect& rect,wxString& str, wxCoord& x, wxCoord& y, bool selected);
+    bool DrawTabbedString(wxDC& dc, const wxRichTextAttr& attr, const wxRect& rect, wxString& str, wxCoord& x, wxCoord& y, bool selected);
 
 protected:
     wxString    m_text;
 };
 
 
 protected:
     wxString    m_text;
 };
 
-/*!
- * wxRichTextImageBlock stores information about an image, in binary in-memory form
- */
+/**
+    @class wxRichTextImageBlock
+
+    This class stores information about an image, in binary in-memory form.
+
+    @library{wxrichtext}
+    @category{richtext}
 
 
-class WXDLLIMPEXP_BASE wxDataInputStream;
-class WXDLLIMPEXP_BASE wxDataOutputStream;
+    @see wxRichTextBuffer, wxRichTextCtrl
+*/
 
 class WXDLLIMPEXP_RICHTEXT wxRichTextImageBlock: public wxObject
 {
 public:
 
 class WXDLLIMPEXP_RICHTEXT wxRichTextImageBlock: public wxObject
 {
 public:
+    /**
+        Constructor.
+    */
     wxRichTextImageBlock();
     wxRichTextImageBlock();
+
+    /**
+        Copy constructor.
+    */
     wxRichTextImageBlock(const wxRichTextImageBlock& block);
     virtual ~wxRichTextImageBlock();
 
     wxRichTextImageBlock(const wxRichTextImageBlock& block);
     virtual ~wxRichTextImageBlock();
 
+    /**
+        Initialises the block.
+    */
     void Init();
     void Init();
-    void Clear();
 
 
-    // Load the original image into a memory block.
-    // If the image is not a JPEG, we must convert it into a JPEG
-    // to conserve space.
-    // If it's not a JPEG we can make use of 'image', already scaled, so we don't have to
-    // load the image a 2nd time.
-    virtual bool MakeImageBlock(const wxString& filename, int imageType, wxImage& image, bool convertToJPEG = true);
+    /**
+        Clears the block.
+    */
 
 
-    // Make an image block from the wxImage in the given
-    // format.
-    virtual bool MakeImageBlock(wxImage& image, int imageType, int quality = 80);
+    void Clear();
 
 
-    // Write to a file
+    /**
+        Load the original image into a memory block.
+        If the image is not a JPEG, we must convert it into a JPEG
+        to conserve space.
+        If it's not a JPEG we can make use of @a image, already scaled, so we don't have to
+        load the image a second time.
+    */
+    virtual bool MakeImageBlock(const wxString& filename, wxBitmapType imageType,
+                                wxImage& image, bool convertToJPEG = true);
+
+    /**
+        Make an image block from the wxImage in the given
+        format.
+    */
+    virtual bool MakeImageBlock(wxImage& image, wxBitmapType imageType, int quality = 80);
+
+    /**
+        Uses a const wxImage for efficiency, but can't set quality (only relevant for JPEG)
+    */
+    virtual bool MakeImageBlockDefaultQuality(const wxImage& image, wxBitmapType imageType);
+
+    /**
+        Makes the image block.
+    */
+    virtual bool DoMakeImageBlock(const wxImage& image, wxBitmapType imageType);
+
+    /**
+        Writes the block to a file.
+    */
     bool Write(const wxString& filename);
 
     bool Write(const wxString& filename);
 
-    // Write data in hex to a stream
+    /**
+        Writes the data in hex to a stream.
+    */
     bool WriteHex(wxOutputStream& stream);
 
     bool WriteHex(wxOutputStream& stream);
 
-    // Read data in hex from a stream
-    bool ReadHex(wxInputStream& stream, int length, int imageType);
+    /**
+        Reads the data in hex from a stream.
+    */
+    bool ReadHex(wxInputStream& stream, int length, wxBitmapType imageType);
 
 
-    // Copy from 'block'
+    /**
+        Copy from @a block.
+    */
     void Copy(const wxRichTextImageBlock& block);
 
     // Load a wxImage from the block
     void Copy(const wxRichTextImageBlock& block);
 
     // Load a wxImage from the block
+    /**
+    */
     bool Load(wxImage& image);
 
     bool Load(wxImage& image);
 
-//// Operators
+// Operators
+
+    /**
+        Assignment operation.
+    */
     void operator=(const wxRichTextImageBlock& block);
 
     void operator=(const wxRichTextImageBlock& block);
 
-//// Accessors
+// Accessors
 
 
+    /**
+        Returns the raw data.
+    */
     unsigned char* GetData() const { return m_data; }
     unsigned char* GetData() const { return m_data; }
+
+    /**
+        Returns the data size in bytes.
+    */
     size_t GetDataSize() const { return m_dataSize; }
     size_t GetDataSize() const { return m_dataSize; }
-    int GetImageType() const { return m_imageType; }
 
 
+    /**
+        Returns the image type.
+    */
+    wxBitmapType GetImageType() const { return m_imageType; }
+
+    /**
+    */
     void SetData(unsigned char* image) { m_data = image; }
     void SetData(unsigned char* image) { m_data = image; }
+
+    /**
+        Sets the data size.
+    */
     void SetDataSize(size_t size) { m_dataSize = size; }
     void SetDataSize(size_t size) { m_dataSize = size; }
-    void SetImageType(int imageType) { m_imageType = imageType; }
 
 
-    bool Ok() const { return GetData() != NULL; }
+    /**
+        Sets the image type.
+    */
+    void SetImageType(wxBitmapType imageType) { m_imageType = imageType; }
+
+    /**
+        Returns @true if the data is non-NULL.
+    */
+    bool IsOk() const { return GetData() != NULL; }
+    bool Ok() const { return IsOk(); }
+
+    /**
+        Gets the extension for the block's type.
+    */
+    wxString GetExtension() const;
 
 /// Implementation
 
 
 /// Implementation
 
-    /// Allocate and read from stream as a block of memory
+    /**
+        Allocates and reads from a stream as a block of memory.
+    */
     static unsigned char* ReadBlock(wxInputStream& stream, size_t size);
     static unsigned char* ReadBlock(wxInputStream& stream, size_t size);
+
+    /**
+        Allocates and reads from a file as a block of memory.
+    */
     static unsigned char* ReadBlock(const wxString& filename, size_t size);
 
     static unsigned char* ReadBlock(const wxString& filename, size_t size);
 
-    // Write memory block to stream
+    /**
+        Writes a memory block to stream.
+    */
     static bool WriteBlock(wxOutputStream& stream, unsigned char* block, size_t size);
 
     static bool WriteBlock(wxOutputStream& stream, unsigned char* block, size_t size);
 
-    // Write memory block to file
+    /**
+        Writes a memory block to a file.
+    */
     static bool WriteBlock(const wxString& filename, unsigned char* block, size_t size);
 
 protected:
     static bool WriteBlock(const wxString& filename, unsigned char* block, size_t size);
 
 protected:
@@ -1343,14 +3809,19 @@ protected:
     // This is in the raw, original form such as a JPEG file.
     unsigned char*      m_data;
     size_t              m_dataSize;
     // This is in the raw, original form such as a JPEG file.
     unsigned char*      m_data;
     size_t              m_dataSize;
-    int                 m_imageType; // wxWin type id
+    wxBitmapType        m_imageType;
 };
 
 };
 
+/**
+    @class wxRichTextImage
 
 
-/*!
- * wxRichTextImage class declaration
- * This object represents an image.
- */
+    This class implements a graphic object.
+
+    @library{wxrichtext}
+    @category{richtext}
+
+    @see wxRichTextBuffer, wxRichTextCtrl, wxRichTextImageBlock
+*/
 
 class WXDLLIMPEXP_RICHTEXT wxRichTextImage: public wxRichTextObject
 {
 
 class WXDLLIMPEXP_RICHTEXT wxRichTextImage: public wxRichTextObject
 {
@@ -1358,66 +3829,123 @@ class WXDLLIMPEXP_RICHTEXT wxRichTextImage: public wxRichTextObject
 public:
 // Constructors
 
 public:
 // Constructors
 
-    wxRichTextImage(wxRichTextObject* parent = NULL):wxRichTextObject(parent) { }
-    wxRichTextImage(const wxImage& image, wxRichTextObject* parent = NULL);
-    wxRichTextImage(const wxRichTextImageBlock& imageBlock, wxRichTextObject* parent = NULL);
-    wxRichTextImage(const wxRichTextImage& obj):wxRichTextObject() { Copy(obj); }
+    /**
+        Default constructor.
+    */
+    wxRichTextImage(wxRichTextObject* parent = NULL): wxRichTextObject(parent) { }
+
+    /**
+        Creates a wxRichTextImage from a wxImage.
+    */
+    wxRichTextImage(const wxImage& image, wxRichTextObject* parent = NULL, wxRichTextAttr* charStyle = NULL);
+
+    /**
+        Creates a wxRichTextImage from an image block.
+    */
+    wxRichTextImage(const wxRichTextImageBlock& imageBlock, wxRichTextObject* parent = NULL, wxRichTextAttr* charStyle = NULL);
 
 
-// Overrideables
+    /**
+        Copy constructor.
+    */
+    wxRichTextImage(const wxRichTextImage& obj): wxRichTextObject(obj) { Copy(obj); }
 
 
-    /// Draw the item
-    virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextRange& selectionRange, const wxRect& rect, int descent, int style);
+// Overridables
+
+    virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
 
 
-    /// Lay the item out
     virtual bool Layout(wxDC& dc, const wxRect& rect, int style);
 
     virtual bool Layout(wxDC& dc, const wxRect& rect, int style);
 
-    /// Get the object size for the given range. Returns false if the range
-    /// is invalid for this object.
-    virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position = wxPoint(0,0)) const;
+    virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position = wxPoint(0,0), wxArrayInt* partialExtents = NULL) const;
+
+    /**
+        Returns the 'natural' size for this object - the image size.
+    */
+    virtual wxTextAttrSize GetNaturalSize() const;
+
+    virtual bool IsEmpty() const { return false; /* !m_imageBlock.IsOk(); */ }
+
+    virtual bool CanEditProperties() const { return true; }
+
+    virtual bool EditProperties(wxWindow* parent, wxRichTextBuffer* buffer);
+
+    virtual wxString GetPropertiesMenuLabel() const { return _("&Picture"); }
+
+    virtual bool UsesParagraphAttributes() const { return false; }
+
+#if wxUSE_XML
+    virtual bool ImportFromXML(wxRichTextBuffer* buffer, wxXmlNode* node, wxRichTextXMLHandler* handler, bool* recurse);
+#endif
+
+#if wxRICHTEXT_HAVE_DIRECT_OUTPUT
+    virtual bool ExportXML(wxOutputStream& stream, int indent, wxRichTextXMLHandler* handler);
+#endif
+
+#if wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT
+    virtual bool ExportXML(wxXmlNode* parent, wxRichTextXMLHandler* handler);
+#endif
+
+    // Images can be floatable (optionally).
+    virtual bool IsFloatable() const { return true; }
 
 
-    /// Returns true if the object is empty
-    virtual bool IsEmpty() const { return !m_image.Ok(); }
+    virtual wxString GetXMLNodeName() const { return wxT("image"); }
 
 // Accessors
 
 
 // Accessors
 
-    /// Get the image
-    const wxImage& GetImage() const { return m_image; }
+    /**
+        Returns the image cache (a scaled bitmap).
+    */
+    const wxBitmap& GetImageCache() const { return m_imageCache; }
+
+    /**
+        Sets the image cache.
+    */
+    void SetImageCache(const wxBitmap& bitmap) { m_imageCache = bitmap; }
 
 
-    /// Set the image
-    void SetImage(const wxImage& image) { m_image = image; }
+    /**
+        Resets the image cache.
+    */
+    void ResetImageCache() { m_imageCache = wxNullBitmap; }
 
 
-    /// Get the image block containing the raw data
+    /**
+        Returns the image block containing the raw data.
+    */
     wxRichTextImageBlock& GetImageBlock() { return m_imageBlock; }
 
 // Operations
 
     wxRichTextImageBlock& GetImageBlock() { return m_imageBlock; }
 
 // Operations
 
-    /// Copy
+    /**
+        Copies the image object.
+    */
     void Copy(const wxRichTextImage& obj);
 
     void Copy(const wxRichTextImage& obj);
 
-    /// Clone
+    /**
+        Clones the image object.
+    */
     virtual wxRichTextObject* Clone() const { return new wxRichTextImage(*this); }
 
     virtual wxRichTextObject* Clone() const { return new wxRichTextImage(*this); }
 
-    /// Load wxImage from the block
-    virtual bool LoadFromBlock();
-
-    /// Make block from the wxImage
-    virtual bool MakeBlock();
+    /**
+        Creates a cached image at the required size.
+    */
+    virtual bool LoadImageCache(wxDC& dc, bool resetCache = false);
 
 protected:
 
 protected:
-    // TODO: reduce the multiple representations of data
-    wxImage                 m_image;
-    wxBitmap                m_bitmap;
     wxRichTextImageBlock    m_imageBlock;
     wxRichTextImageBlock    m_imageBlock;
+    wxBitmap                m_imageCache;
 };
 
 };
 
+class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextCommand;
+class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextAction;
 
 
-/*!
- * wxRichTextBuffer class declaration
- * This is a kind of box, used to represent the whole buffer
- */
+/**
+    @class wxRichTextBuffer
+
+    This is a kind of paragraph layout box, used to represent the whole buffer.
 
 
-class WXDLLIMPEXP_RICHTEXT wxRichTextCommand;
-class WXDLLIMPEXP_RICHTEXT wxRichTextAction;
+    @library{wxrichtext}
+    @category{richtext}
+
+    @see wxRichTextParagraphLayoutBox, wxRichTextCtrl
+*/
 
 class WXDLLIMPEXP_RICHTEXT wxRichTextBuffer: public wxRichTextParagraphLayoutBox
 {
 
 class WXDLLIMPEXP_RICHTEXT wxRichTextBuffer: public wxRichTextParagraphLayoutBox
 {
@@ -1425,256 +3953,630 @@ class WXDLLIMPEXP_RICHTEXT wxRichTextBuffer: public wxRichTextParagraphLayoutBox
 public:
 // Constructors
 
 public:
 // Constructors
 
+    /**
+        Default constructor.
+    */
     wxRichTextBuffer() { Init(); }
     wxRichTextBuffer() { Init(); }
-    wxRichTextBuffer(const wxRichTextBuffer& obj):wxRichTextParagraphLayoutBox() { Init(); Copy(obj); }
+
+    /**
+        Copy constructor.
+    */
+    wxRichTextBuffer(const wxRichTextBuffer& obj): wxRichTextParagraphLayoutBox() { Init(); Copy(obj); }
+
     virtual ~wxRichTextBuffer() ;
 
 // Accessors
 
     virtual ~wxRichTextBuffer() ;
 
 // Accessors
 
-    /// Gets the command processor
+    /**
+        Returns the command processor.
+        A text buffer always creates its own command processor when it is initialized.
+    */
     wxCommandProcessor* GetCommandProcessor() const { return m_commandProcessor; }
 
     wxCommandProcessor* GetCommandProcessor() const { return m_commandProcessor; }
 
-    /// Set style sheet, if any.
+    /**
+        Sets style sheet, if any. This will allow the application to use named character and paragraph
+        styles found in the style sheet.
+
+        Neither the buffer nor the control owns the style sheet so must be deleted by the application.
+    */
     void SetStyleSheet(wxRichTextStyleSheet* styleSheet) { m_styleSheet = styleSheet; }
     void SetStyleSheet(wxRichTextStyleSheet* styleSheet) { m_styleSheet = styleSheet; }
-    wxRichTextStyleSheet* GetStyleSheet() const { return m_styleSheet; }
+
+    /**
+        Returns the style sheet.
+    */
+    virtual wxRichTextStyleSheet* GetStyleSheet() const { return m_styleSheet; }
+
+    /**
+        Sets the style sheet and sends a notification of the change.
+    */
+    bool SetStyleSheetAndNotify(wxRichTextStyleSheet* sheet);
+
+    /**
+        Pushes the style sheet to the top of the style sheet stack.
+    */
+    bool PushStyleSheet(wxRichTextStyleSheet* styleSheet);
+
+    /**
+        Pops the style sheet from the top of the style sheet stack.
+    */
+    wxRichTextStyleSheet* PopStyleSheet();
+
+    /**
+        Returns the table storing fonts, for quick access and font reuse.
+    */
+    wxRichTextFontTable& GetFontTable() { return m_fontTable; }
+
+    /**
+        Returns the table storing fonts, for quick access and font reuse.
+    */
+    const wxRichTextFontTable& GetFontTable() const { return m_fontTable; }
+
+    /**
+        Sets table storing fonts, for quick access and font reuse.
+    */
+    void SetFontTable(const wxRichTextFontTable& table) { m_fontTable = table; }
 
 // Operations
 
 
 // Operations
 
-    /// Initialisation
+    /**
+        Initialisation.
+    */
     void Init();
 
     void Init();
 
-    /// Clears the buffer and resets the command processor
-    virtual void Clear();
-
-    /// The same as Clear, and adds an empty paragraph.
-    virtual void Reset();
-
-    /// Load a file
-    virtual bool LoadFile(const wxString& filename, int type = wxRICHTEXT_TYPE_ANY);
-
-    /// Save a file
-    virtual bool SaveFile(const wxString& filename, int type = wxRICHTEXT_TYPE_ANY);
-
-    /// Load from a stream
-    virtual bool LoadFile(wxInputStream& stream, int type = wxRICHTEXT_TYPE_ANY);
-
-    /// Save to a stream
-    virtual bool SaveFile(wxOutputStream& stream, int type = wxRICHTEXT_TYPE_ANY);
-
-    /// Convenience function to add a paragraph of text
-    virtual wxRichTextRange AddParagraph(const wxString& text) { Modify(); return wxRichTextParagraphLayoutBox::AddParagraph(text); }
-
-    /// Begin collapsing undo/redo commands. Note that this may not work properly
-    /// if combining commands that delete or insert content, changing ranges for
-    /// subsequent actions.
+    /**
+        Clears the buffer, adds an empty paragraph, and clears the command processor.
+    */
+    virtual void ResetAndClearCommands();
+
+    //@{
+    /**
+        Loads content from a stream or file.
+        Not all handlers will implement file loading.
+    */
+    virtual bool LoadFile(const wxString& filename, wxRichTextFileType type = wxRICHTEXT_TYPE_ANY);
+    virtual bool LoadFile(wxInputStream& stream, wxRichTextFileType type = wxRICHTEXT_TYPE_ANY);
+    //@}
+
+    //@{
+    /**
+        Saves content to a stream or file.
+        Not all handlers will implement file saving.
+    */
+    virtual bool SaveFile(const wxString& filename, wxRichTextFileType type = wxRICHTEXT_TYPE_ANY);
+    virtual bool SaveFile(wxOutputStream& stream, wxRichTextFileType type = wxRICHTEXT_TYPE_ANY);
+    //@}
+
+    /**
+        Sets the handler flags, controlling loading and saving.
+    */
+    void SetHandlerFlags(int flags) { m_handlerFlags = flags; }
+
+    /**
+        Gets the handler flags, controlling loading and saving.
+    */
+    int GetHandlerFlags() const { return m_handlerFlags; }
+
+    /**
+        Convenience function to add a paragraph of text.
+    */
+    virtual wxRichTextRange AddParagraph(const wxString& text, wxRichTextAttr* paraStyle = NULL) { Modify(); return wxRichTextParagraphLayoutBox::AddParagraph(text, paraStyle); }
+
+    /**
+        Begin collapsing undo/redo commands. Note that this may not work properly
+        if combining commands that delete or insert content, changing ranges for
+        subsequent actions.
+
+        @a cmdName should be the name of the combined command that will appear
+        next to Undo and Redo in the edit menu.
+    */
     virtual bool BeginBatchUndo(const wxString& cmdName);
 
     virtual bool BeginBatchUndo(const wxString& cmdName);
 
-    /// End collapsing undo/redo commands
+    /**
+        End collapsing undo/redo commands.
+    */
     virtual bool EndBatchUndo();
 
     virtual bool EndBatchUndo();
 
-    /// Collapsing commands?
+    /**
+        Returns @true if we are collapsing commands.
+    */
     virtual bool BatchingUndo() const { return m_batchedCommandDepth > 0; }
 
     virtual bool BatchingUndo() const { return m_batchedCommandDepth > 0; }
 
-    /// Submit immediately, or delay according to whether collapsing is on
+    /**
+        Submit the action immediately, or delay according to whether collapsing is on.
+    */
     virtual bool SubmitAction(wxRichTextAction* action);
 
     virtual bool SubmitAction(wxRichTextAction* action);
 
-    /// Get collapsed command
+    /**
+        Returns the collapsed command.
+    */
     virtual wxRichTextCommand* GetBatchedCommand() const { return m_batchedCommand; }
 
     virtual wxRichTextCommand* GetBatchedCommand() const { return m_batchedCommand; }
 
-    /// Begin suppressing undo/redo commands. The way undo is suppressed may be implemented
-    /// differently by each command. If not dealt with by a command implementation, then
-    /// it will be implemented automatically by not storing the command in the undo history
-    /// when the action is submitted to the command processor.
+    /**
+        Begin suppressing undo/redo commands. The way undo is suppressed may be implemented
+        differently by each command. If not dealt with by a command implementation, then
+        it will be implemented automatically by not storing the command in the undo history
+        when the action is submitted to the command processor.
+    */
     virtual bool BeginSuppressUndo();
 
     virtual bool BeginSuppressUndo();
 
-    /// End suppressing undo/redo commands.
+    /**
+        End suppressing undo/redo commands.
+    */
     virtual bool EndSuppressUndo();
 
     virtual bool EndSuppressUndo();
 
-    /// Collapsing commands?
+    /**
+        Are we suppressing undo??
+    */
     virtual bool SuppressingUndo() const { return m_suppressUndo > 0; }
 
     virtual bool SuppressingUndo() const { return m_suppressUndo > 0; }
 
-    /// Copy the range to the clipboard
+    /**
+        Copy the range to the clipboard.
+    */
     virtual bool CopyToClipboard(const wxRichTextRange& range);
 
     virtual bool CopyToClipboard(const wxRichTextRange& range);
 
-    /// Paste the clipboard content to the buffer
+    /**
+        Paste the clipboard content to the buffer.
+    */
     virtual bool PasteFromClipboard(long position);
 
     virtual bool PasteFromClipboard(long position);
 
-    /// Can we paste from the clipboard?
+    /**
+        Returns @true if we can paste from the clipboard.
+    */
     virtual bool CanPasteFromClipboard() const;
 
     virtual bool CanPasteFromClipboard() const;
 
-    /// Begin using a style
-    virtual bool BeginStyle(const wxTextAttrEx& style);
+    /**
+        Begin using a style.
+    */
+    virtual bool BeginStyle(const wxRichTextAttr& style);
 
 
-    /// End the style
+    /**
+        End the style.
+    */
     virtual bool EndStyle();
 
     virtual bool EndStyle();
 
-    /// End all styles
+    /**
+        End all styles.
+    */
     virtual bool EndAllStyles();
 
     virtual bool EndAllStyles();
 
-    /// Clear the style stack
+    /**
+        Clears the style stack.
+    */
     virtual void ClearStyleStack();
 
     virtual void ClearStyleStack();
 
-    /// Get the size of the style stack, for example to check correct nesting
+    /**
+        Returns the size of the style stack, for example to check correct nesting.
+    */
     virtual size_t GetStyleStackSize() const { return m_attributeStack.GetCount(); }
 
     virtual size_t GetStyleStackSize() const { return m_attributeStack.GetCount(); }
 
-    /// Begin using bold
+    /**
+        Begins using bold.
+    */
     bool BeginBold();
 
     bool BeginBold();
 
-    /// End using bold
+    /**
+        Ends using bold.
+    */
     bool EndBold() { return EndStyle(); }
 
     bool EndBold() { return EndStyle(); }
 
-    /// Begin using italic
+    /**
+        Begins using italic.
+    */
     bool BeginItalic();
 
     bool BeginItalic();
 
-    /// End using italic
+    /**
+        Ends using italic.
+    */
     bool EndItalic() { return EndStyle(); }
 
     bool EndItalic() { return EndStyle(); }
 
-    /// Begin using underline
+    /**
+        Begins using underline.
+    */
     bool BeginUnderline();
 
     bool BeginUnderline();
 
-    /// End using underline
+    /**
+        Ends using underline.
+    */
     bool EndUnderline() { return EndStyle(); }
 
     bool EndUnderline() { return EndStyle(); }
 
-    /// Begin using point size
+    /**
+        Begins using point size.
+    */
     bool BeginFontSize(int pointSize);
 
     bool BeginFontSize(int pointSize);
 
-    /// End using point size
+    /**
+        Ends using point size.
+    */
     bool EndFontSize() { return EndStyle(); }
 
     bool EndFontSize() { return EndStyle(); }
 
-    /// Begin using this font
+    /**
+        Begins using this font.
+    */
     bool BeginFont(const wxFont& font);
 
     bool BeginFont(const wxFont& font);
 
-    /// End using a font
+    /**
+        Ends using a font.
+    */
     bool EndFont() { return EndStyle(); }
 
     bool EndFont() { return EndStyle(); }
 
-    /// Begin using this colour
+    /**
+        Begins using this colour.
+    */
     bool BeginTextColour(const wxColour& colour);
 
     bool BeginTextColour(const wxColour& colour);
 
-    /// End using a colour
+    /**
+        Ends using a colour.
+    */
     bool EndTextColour() { return EndStyle(); }
 
     bool EndTextColour() { return EndStyle(); }
 
-    /// Begin using alignment
+    /**
+        Begins using alignment.
+    */
     bool BeginAlignment(wxTextAttrAlignment alignment);
 
     bool BeginAlignment(wxTextAttrAlignment alignment);
 
-    /// End alignment
+    /**
+        Ends alignment.
+    */
     bool EndAlignment() { return EndStyle(); }
 
     bool EndAlignment() { return EndStyle(); }
 
-    /// Begin left indent
+    /**
+        Begins using @a leftIndent for the left indent, and optionally @a leftSubIndent for
+        the sub-indent. Both are expressed in tenths of a millimetre.
+
+        The sub-indent is an offset from the left of the paragraph, and is used for all
+        but the first line in a paragraph. A positive value will cause the first line to appear
+        to the left of the subsequent lines, and a negative value will cause the first line to be
+        indented relative to the subsequent lines.
+    */
     bool BeginLeftIndent(int leftIndent, int leftSubIndent = 0);
 
     bool BeginLeftIndent(int leftIndent, int leftSubIndent = 0);
 
-    /// End left indent
+    /**
+        Ends left indent.
+    */
     bool EndLeftIndent() { return EndStyle(); }
 
     bool EndLeftIndent() { return EndStyle(); }
 
-    /// Begin right indent
+    /**
+        Begins a right indent, specified in tenths of a millimetre.
+    */
     bool BeginRightIndent(int rightIndent);
 
     bool BeginRightIndent(int rightIndent);
 
-    /// End right indent
+    /**
+        Ends right indent.
+    */
     bool EndRightIndent() { return EndStyle(); }
 
     bool EndRightIndent() { return EndStyle(); }
 
-    /// Begin paragraph spacing
+    /**
+        Begins paragraph spacing; pass the before-paragraph and after-paragraph spacing
+        in tenths of a millimetre.
+    */
     bool BeginParagraphSpacing(int before, int after);
 
     bool BeginParagraphSpacing(int before, int after);
 
-    /// End paragraph spacing
+    /**
+        Ends paragraph spacing.
+    */
     bool EndParagraphSpacing() { return EndStyle(); }
 
     bool EndParagraphSpacing() { return EndStyle(); }
 
-    /// Begin line spacing
+    /**
+        Begins line spacing using the specified value. @e spacing is a multiple, where
+        10 means single-spacing, 15 means 1.5 spacing, and 20 means double spacing.
+
+        The ::wxTextAttrLineSpacing enumeration values are defined for convenience.
+    */
     bool BeginLineSpacing(int lineSpacing);
 
     bool BeginLineSpacing(int lineSpacing);
 
-    /// End line spacing
+    /**
+        Ends line spacing.
+    */
     bool EndLineSpacing() { return EndStyle(); }
 
     bool EndLineSpacing() { return EndStyle(); }
 
-    /// Begin numbered bullet
+    /**
+        Begins numbered bullet.
+
+        This call will be needed for each item in the list, and the
+        application should take care of incrementing the numbering.
+
+        @a bulletNumber is a number, usually starting with 1.
+        @a leftIndent and @a leftSubIndent are values in tenths of a millimetre.
+        @a bulletStyle is a bitlist of the following values:
+
+        wxRichTextBuffer uses indentation to render a bulleted item.
+        The left indent is the distance between the margin and the bullet.
+        The content of the paragraph, including the first line, starts
+        at leftMargin + leftSubIndent.
+        So the distance between the left edge of the bullet and the
+        left of the actual paragraph is leftSubIndent.
+    */
     bool BeginNumberedBullet(int bulletNumber, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_ARABIC|wxTEXT_ATTR_BULLET_STYLE_PERIOD);
 
     bool BeginNumberedBullet(int bulletNumber, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_ARABIC|wxTEXT_ATTR_BULLET_STYLE_PERIOD);
 
-    /// End numbered bullet
+    /**
+        Ends numbered bullet.
+    */
     bool EndNumberedBullet() { return EndStyle(); }
 
     bool EndNumberedBullet() { return EndStyle(); }
 
-    /// Begin symbol bullet
-    bool BeginSymbolBullet(wxChar symbol, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_SYMBOL);
+    /**
+        Begins applying a symbol bullet, using a character from the current font.
+
+        See BeginNumberedBullet() for an explanation of how indentation is used
+        to render the bulleted paragraph.
+    */
+    bool BeginSymbolBullet(const wxString& symbol, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_SYMBOL);
 
 
-    /// End symbol bullet
+    /**
+        Ends symbol bullet.
+    */
     bool EndSymbolBullet() { return EndStyle(); }
 
     bool EndSymbolBullet() { return EndStyle(); }
 
-    /// Begin named character style
+    /**
+        Begins applying a standard bullet, using one of the standard bullet names
+        (currently @c standard/circle or @c standard/square.
+
+        See BeginNumberedBullet() for an explanation of how indentation is used to
+        render the bulleted paragraph.
+    */
+    bool BeginStandardBullet(const wxString& bulletName, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_STANDARD);
+
+    /**
+        Ends standard bullet.
+    */
+    bool EndStandardBullet() { return EndStyle(); }
+
+    /**
+        Begins named character style.
+    */
     bool BeginCharacterStyle(const wxString& characterStyle);
 
     bool BeginCharacterStyle(const wxString& characterStyle);
 
-    /// End named character style
+    /**
+        Ends named character style.
+    */
     bool EndCharacterStyle() { return EndStyle(); }
 
     bool EndCharacterStyle() { return EndStyle(); }
 
-    /// Begin named paragraph style
+    /**
+        Begins named paragraph style.
+    */
     bool BeginParagraphStyle(const wxString& paragraphStyle);
 
     bool BeginParagraphStyle(const wxString& paragraphStyle);
 
-    /// End named character style
+    /**
+        Ends named character style.
+    */
     bool EndParagraphStyle() { return EndStyle(); }
 
     bool EndParagraphStyle() { return EndStyle(); }
 
-// Implementation
+    /**
+        Begins named list style.
 
 
-    /// Copy
-    void Copy(const wxRichTextBuffer& obj) { wxRichTextBox::Copy(obj); }
+        Optionally, you can also pass a level and a number.
+    */
+    bool BeginListStyle(const wxString& listStyle, int level = 1, int number = 1);
 
 
-    /// Clone
-    virtual wxRichTextObject* Clone() const { return new wxRichTextBuffer(*this); }
+    /**
+        Ends named character style.
+    */
+    bool EndListStyle() { return EndStyle(); }
+
+    /**
+        Begins applying wxTEXT_ATTR_URL to the content.
 
 
-    /// Submit command to insert the given text
-    bool InsertTextWithUndo(long pos, const wxString& text, wxRichTextCtrl* ctrl);
+        Pass a URL and optionally, a character style to apply, since it is common
+        to mark a URL with a familiar style such as blue text with underlining.
+    */
+    bool BeginURL(const wxString& url, const wxString& characterStyle = wxEmptyString);
 
 
-    /// Submit command to insert a newline
-    bool InsertNewlineWithUndo(long pos, wxRichTextCtrl* ctrl);
+    /**
+        Ends URL.
+    */
+    bool EndURL() { return EndStyle(); }
 
 
-    /// Submit command to insert the given image
-    bool InsertImageWithUndo(long pos, const wxRichTextImageBlock& imageBlock, wxRichTextCtrl* ctrl);
+// Event handling
 
 
-    /// Submit command to delete this range
-    bool DeleteRangeWithUndo(const wxRichTextRange& range, long initialCaretPosition, long newCaretPositon, wxRichTextCtrl* ctrl);
+    /**
+        Adds an event handler.
 
 
-    /// Mark modified
+        A buffer associated with a control has the control as the only event handler,
+        but the application is free to add more if further notification is required.
+        All handlers are notified of an event originating from the buffer, such as
+        the replacement of a style sheet during loading.
+
+        The buffer never deletes any of the event handlers, unless RemoveEventHandler()
+        is called with @true as the second argument.
+    */
+    bool AddEventHandler(wxEvtHandler* handler);
+
+    /**
+        Removes an event handler from the buffer's list of handlers, deleting the
+        object if @a deleteHandler is @true.
+    */
+    bool RemoveEventHandler(wxEvtHandler* handler, bool deleteHandler = false);
+
+    /**
+        Clear event handlers.
+    */
+    void ClearEventHandlers();
+
+    /**
+        Send event to event handlers. If sendToAll is true, will send to all event handlers,
+        otherwise will stop at the first successful one.
+    */
+    bool SendEvent(wxEvent& event, bool sendToAll = true);
+
+// Implementation
+
+    virtual int HitTest(wxDC& dc, const wxPoint& pt, long& textPosition, wxRichTextObject** obj, wxRichTextObject** contextObj, int flags = 0);
+
+    /**
+        Copies the buffer.
+    */
+    void Copy(const wxRichTextBuffer& obj);
+
+    /**
+        Assignment operator.
+    */
+    void operator= (const wxRichTextBuffer& obj) { Copy(obj); }
+
+    /**
+        Clones the buffer.
+    */
+    virtual wxRichTextObject* Clone() const { return new wxRichTextBuffer(*this); }
+
+    /**
+        Submits a command to insert paragraphs.
+    */
+    bool InsertParagraphsWithUndo(long pos, const wxRichTextParagraphLayoutBox& paragraphs, wxRichTextCtrl* ctrl, int flags = 0);
+
+    /**
+        Submits a command to insert the given text.
+    */
+    bool InsertTextWithUndo(long pos, const wxString& text, wxRichTextCtrl* ctrl, int flags = 0);
+
+    /**
+        Submits a command to insert a newline.
+    */
+    bool InsertNewlineWithUndo(long pos, wxRichTextCtrl* ctrl, int flags = 0);
+
+    /**
+        Submits a command to insert the given image.
+    */
+    bool InsertImageWithUndo(long pos, const wxRichTextImageBlock& imageBlock, wxRichTextCtrl* ctrl, int flags = 0,
+            const wxRichTextAttr& textAttr = wxRichTextAttr());
+
+    /**
+        Submits a command to insert an object.
+    */
+    wxRichTextObject* InsertObjectWithUndo(long pos, wxRichTextObject *object, wxRichTextCtrl* ctrl, int flags);
+
+    /**
+        Submits a command to delete this range.
+    */
+    bool DeleteRangeWithUndo(const wxRichTextRange& range, wxRichTextCtrl* ctrl);
+
+    /**
+        Mark modified.
+    */
     void Modify(bool modify = true) { m_modified = modify; }
     void Modify(bool modify = true) { m_modified = modify; }
+
+    /**
+        Returns @true if the buffer was modified.
+    */
     bool IsModified() const { return m_modified; }
 
     bool IsModified() const { return m_modified; }
 
-    /// Dumps contents of buffer for debugging purposes
+    //@{
+    /**
+        Dumps contents of buffer for debugging purposes.
+    */
     virtual void Dump();
     virtual void Dump(wxTextOutputStream& stream) { wxRichTextParagraphLayoutBox::Dump(stream); }
     virtual void Dump();
     virtual void Dump(wxTextOutputStream& stream) { wxRichTextParagraphLayoutBox::Dump(stream); }
+    //@}
 
 
-    /// Returns the file handlers
+    /**
+        Returns the file handlers.
+    */
     static wxList& GetHandlers() { return sm_handlers; }
 
     static wxList& GetHandlers() { return sm_handlers; }
 
-    /// Adds a handler to the end
+    /**
+        Adds a file handler to the end.
+    */
     static void AddHandler(wxRichTextFileHandler *handler);
 
     static void AddHandler(wxRichTextFileHandler *handler);
 
-    /// Inserts a handler at the front
+    /**
+        Inserts a file handler at the front.
+    */
     static void InsertHandler(wxRichTextFileHandler *handler);
 
     static void InsertHandler(wxRichTextFileHandler *handler);
 
-    /// Removes a handler
+    /**
+        Removes a file handler.
+    */
     static bool RemoveHandler(const wxString& name);
 
     static bool RemoveHandler(const wxString& name);
 
-    /// Finds a handler by name
+    /**
+        Finds a file handler by name.
+    */
     static wxRichTextFileHandler *FindHandler(const wxString& name);
 
     static wxRichTextFileHandler *FindHandler(const wxString& name);
 
-    /// Finds a handler by extension and type
-    static wxRichTextFileHandler *FindHandler(const wxString& extension, int imageType);
-
-    /// Finds a handler by filename or, if supplied, type
-    static wxRichTextFileHandler *FindHandlerFilenameOrType(const wxString& filename, int imageType);
-
-    /// Finds a handler by type
-    static wxRichTextFileHandler *FindHandler(int imageType);
-
-    /// Gets a wildcard incorporating all visible handlers. If 'types' is present,
-    /// will be filled with the file type corresponding to each filter. This can be
-    /// used to determine the type to pass to LoadFile given a selected filter.
+    /**
+        Finds a file handler by extension and type.
+    */
+    static wxRichTextFileHandler *FindHandler(const wxString& extension, wxRichTextFileType imageType);
+
+    /**
+        Finds a handler by filename or, if supplied, type.
+    */
+    static wxRichTextFileHandler *FindHandlerFilenameOrType(const wxString& filename,
+                                                            wxRichTextFileType imageType);
+
+    /**
+        Finds a handler by type.
+    */
+    static wxRichTextFileHandler *FindHandler(wxRichTextFileType imageType);
+
+    /**
+        Gets a wildcard incorporating all visible handlers. If @a types is present,
+        it will be filled with the file type corresponding to each filter. This can be
+        used to determine the type to pass to LoadFile given a selected filter.
+    */
     static wxString GetExtWildcard(bool combine = false, bool save = false, wxArrayInt* types = NULL);
 
     static wxString GetExtWildcard(bool combine = false, bool save = false, wxArrayInt* types = NULL);
 
-    /// Clean up handlers
+    /**
+        Clean up file handlers.
+    */
     static void CleanUpHandlers();
 
     static void CleanUpHandlers();
 
-    /// Initialise the standard handlers
+    /**
+        Initialise the standard file handlers.
+        Currently, only the plain text loading/saving handler is initialised by default.
+    */
     static void InitStandardHandlers();
 
     static void InitStandardHandlers();
 
+    /**
+        Returns the renderer object.
+    */
+    static wxRichTextRenderer* GetRenderer() { return sm_renderer; }
+
+    /**
+        Sets @a renderer as the object to be used to render certain aspects of the
+        content, such as bullets.
+
+        You can override default rendering by deriving a new class from
+        wxRichTextRenderer or wxRichTextStdRenderer, overriding one or more
+        virtual functions, and setting an instance of the class using this function.
+    */
+    static void SetRenderer(wxRichTextRenderer* renderer);
+
+    /**
+        Returns the minimum margin between bullet and paragraph in 10ths of a mm.
+    */
+    static int GetBulletRightMargin() { return sm_bulletRightMargin; }
+
+    /**
+        Sets the minimum margin between bullet and paragraph in 10ths of a mm.
+    */
+    static void SetBulletRightMargin(int margin) { sm_bulletRightMargin = margin; }
+
+    /**
+        Returns the factor to multiply by character height to get a reasonable bullet size.
+    */
+    static float GetBulletProportion() { return sm_bulletProportion; }
+
+    /**
+        Sets the factor to multiply by character height to get a reasonable bullet size.
+    */
+    static void SetBulletProportion(float prop) { sm_bulletProportion = prop; }
+
+    /**
+        Returns the scale factor for calculating dimensions.
+    */
+    double GetScale() const { return m_scale; }
+
+    /**
+        Sets the scale factor for calculating dimensions.
+    */
+    void SetScale(double scale) { m_scale = scale; }
+
 protected:
 
     /// Command processor
     wxCommandProcessor*     m_commandProcessor;
 
 protected:
 
     /// Command processor
     wxCommandProcessor*     m_commandProcessor;
 
+    /// Table storing fonts
+    wxRichTextFontTable     m_fontTable;
+
     /// Has been modified?
     bool                    m_modified;
 
     /// Has been modified?
     bool                    m_modified;
 
@@ -1693,49 +4595,395 @@ protected:
     /// Style sheet, if any
     wxRichTextStyleSheet*   m_styleSheet;
 
     /// Style sheet, if any
     wxRichTextStyleSheet*   m_styleSheet;
 
+    /// List of event handlers that will be notified of events
+    wxList                  m_eventHandlers;
+
     /// Stack of attributes for convenience functions
     wxList                  m_attributeStack;
 
     /// Stack of attributes for convenience functions
     wxList                  m_attributeStack;
 
+    /// Flags to be passed to handlers
+    int                     m_handlerFlags;
+
     /// File handlers
     static wxList           sm_handlers;
     /// File handlers
     static wxList           sm_handlers;
+
+    /// Renderer
+    static wxRichTextRenderer* sm_renderer;
+
+    /// Minimum margin between bullet and paragraph in 10ths of a mm
+    static int              sm_bulletRightMargin;
+
+    /// Factor to multiply by character height to get a reasonable bullet size
+    static float            sm_bulletProportion;
+
+    /// Scaling factor in use: needed to calculate correct dimensions when printing
+    double                  m_scale;
 };
 
 };
 
-/*!
- * The command identifiers
- *
+/**
+    @class wxRichTextCell
+
+    wxRichTextCell is the cell in a table.
+ */
+
+class WXDLLIMPEXP_RICHTEXT wxRichTextCell: public wxRichTextBox
+{
+    DECLARE_DYNAMIC_CLASS(wxRichTextCell)
+public:
+// Constructors
+
+    /**
+        Default constructor; optionally pass the parent object.
+    */
+
+    wxRichTextCell(wxRichTextObject* parent = NULL);
+
+    /**
+        Copy constructor.
+    */
+
+    wxRichTextCell(const wxRichTextCell& obj): wxRichTextBox() { Copy(obj); }
+
+// Overridables
+
+    virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
+
+    virtual wxString GetXMLNodeName() const { return wxT("cell"); }
+
+    virtual bool CanEditProperties() const { return true; }
+
+    virtual bool EditProperties(wxWindow* parent, wxRichTextBuffer* buffer);
+
+    virtual wxString GetPropertiesMenuLabel() const { return _("&Cell"); }
+
+// Accessors
+
+// Operations
+
+    virtual wxRichTextObject* Clone() const { return new wxRichTextCell(*this); }
+
+    void Copy(const wxRichTextCell& obj);
+
+protected:
+};
+
+/**
+    @class wxRichTextTable
+
+    wxRichTextTable represents a table with arbitrary columns and rows.
  */
 
  */
 
+WX_DEFINE_ARRAY_PTR(wxRichTextObject*, wxRichTextObjectPtrArray);
+WX_DECLARE_OBJARRAY(wxRichTextObjectPtrArray, wxRichTextObjectPtrArrayArray);
+
+class WXDLLIMPEXP_RICHTEXT wxRichTextTable: public wxRichTextBox
+{
+    DECLARE_DYNAMIC_CLASS(wxRichTextTable)
+public:
+
+// Constructors
+
+    /**
+        Default constructor; optionally pass the parent object.
+    */
+
+    wxRichTextTable(wxRichTextObject* parent = NULL);
+
+    /**
+        Copy constructor.
+    */
+
+    wxRichTextTable(const wxRichTextTable& obj): wxRichTextBox() { Copy(obj); }
+
+// Overridables
+
+    virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
+
+    virtual wxString GetXMLNodeName() const { return wxT("table"); }
+
+    virtual bool Layout(wxDC& dc, const wxRect& rect, int style);
+
+    virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position = wxPoint(0,0), wxArrayInt* partialExtents = NULL) const;
+
+    virtual bool DeleteRange(const wxRichTextRange& range);
+
+    virtual wxString GetTextForRange(const wxRichTextRange& range) const;
+
+#if wxUSE_XML
+    virtual bool ImportFromXML(wxRichTextBuffer* buffer, wxXmlNode* node, wxRichTextXMLHandler* handler, bool* recurse);
+#endif
+
+#if wxRICHTEXT_HAVE_DIRECT_OUTPUT
+    virtual bool ExportXML(wxOutputStream& stream, int indent, wxRichTextXMLHandler* handler);
+#endif
+
+#if wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT
+    virtual bool ExportXML(wxXmlNode* parent, wxRichTextXMLHandler* handler);
+#endif
+
+    virtual bool FindPosition(wxDC& dc, long index, wxPoint& pt, int* height, bool forceLineStart);
+
+    virtual void CalculateRange(long start, long& end);
+
+    // Can this object handle the selections of its children? FOr example, a table.
+    virtual bool HandlesChildSelections() const { return true; }
+
+    /// Returns a selection object specifying the selections between start and end character positions.
+    /// For example, a table would deduce what cells (of range length 1) are selected when dragging across the table.
+    virtual wxRichTextSelection GetSelection(long start, long end) const;
+
+    virtual bool CanEditProperties() const { return true; }
+
+    virtual bool EditProperties(wxWindow* parent, wxRichTextBuffer* buffer);
+
+    virtual wxString GetPropertiesMenuLabel() const { return _("&Table"); }
+
+    // Returns true if objects of this class can accept the focus, i.e. a call to SetFocusObject
+    // is possible. For example, containers supporting text, such as a text box object, can accept the focus,
+    // but a table can't (set the focus to individual cells instead).
+    virtual bool AcceptsFocus() const { return false; }
+
+// Accessors
+
+    /**
+        Returns the cells array.
+    */
+    const wxRichTextObjectPtrArrayArray& GetCells() const { return m_cells; }
+
+    /**
+        Returns the cells array.
+    */
+    wxRichTextObjectPtrArrayArray& GetCells() { return m_cells; }
+
+    /**
+        Returns the row count.
+    */
+    int GetRowCount() const { return m_rowCount; }
+
+    /**
+        Returns the column count.
+    */
+    int GetColumnCount() const { return m_colCount; }
+
+    /**
+        Returns the cell at the given row/column position.
+    */
+    virtual wxRichTextCell* GetCell(int row, int col) const;
+
+    /**
+        Returns the cell at the given character position (in the range of the table).
+    */
+    virtual wxRichTextCell* GetCell(long pos) const;
+
+    /**
+        Returns the row/column for a given character position.
+    */
+    virtual bool GetCellRowColumnPosition(long pos, int& row, int& col) const;
+
+// Operations
+
+    /**
+        Clears the table.
+    */
+
+    virtual void ClearTable();
+
+    /**
+        Creates a table of the given dimensions.
+    */
+
+    virtual bool CreateTable(int rows, int cols);
+
+    /**
+        Sets the attributes for the cells specified by the selection.
+    */
+
+    virtual bool SetCellStyle(const wxRichTextSelection& selection, const wxRichTextAttr& style, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO);
+
+    /**
+        Deletes rows from the given row position.
+    */
+
+    virtual bool DeleteRows(int startRow, int noRows = 1);
+
+    /**
+        Deletes columns from the given column position.
+    */
+
+    virtual bool DeleteColumns(int startCol, int noCols = 1);
+
+    /**
+        Adds rows from the given row position.
+    */
+
+    virtual bool AddRows(int startRow, int noRows = 1, const wxRichTextAttr& attr = wxRichTextAttr());
+
+    /**
+        Adds columns from the given column position.
+    */
+
+    virtual bool AddColumns(int startCol, int noCols = 1, const wxRichTextAttr& attr = wxRichTextAttr());
+
+    // Makes a clone of this object.
+    virtual wxRichTextObject* Clone() const { return new wxRichTextTable(*this); }
+
+    // Copies this object.
+    void Copy(const wxRichTextTable& obj);
+
+protected:
+
+    int m_rowCount;
+    int m_colCount;
+
+    // An array of rows, each of which is a wxRichTextObjectPtrArray containing
+    // the cell objects. The cell objects are also children of this object.
+    // Problem: if boxes are immediate children of a box, this will cause problems
+    // with wxRichTextParagraphLayoutBox functions (and functions elsewhere) that
+    // expect to find just paragraphs. May have to adjust the way we handle the
+    // hierarchy to accept non-paragraph objects in a paragraph layout box.
+    // We'll be overriding much wxRichTextParagraphLayoutBox functionality so this
+    // may not be such a problem. Perhaps the table should derive from a different
+    // class?
+    wxRichTextObjectPtrArrayArray   m_cells;
+};
+
+
+/**
+    The command identifiers for Do/Undo.
+*/
+
 enum wxRichTextCommandId
 {
     wxRICHTEXT_INSERT,
     wxRICHTEXT_DELETE,
 enum wxRichTextCommandId
 {
     wxRICHTEXT_INSERT,
     wxRICHTEXT_DELETE,
-    wxRICHTEXT_CHANGE_STYLE
+    wxRICHTEXT_CHANGE_ATTRIBUTES,
+    wxRICHTEXT_CHANGE_STYLE,
+    wxRICHTEXT_CHANGE_OBJECT
 };
 
 };
 
-/*!
- * Command classes for undo/redo
- *
- */
+/**
+    @class wxRichTextObjectAddress
+
+    A class for specifying an object anywhere in an object hierarchy,
+    without using a pointer, necessary since wxRTC commands may delete
+    and recreate sub-objects so physical object addresses change. An array
+    of positions (one per hierarchy level) is used.
+
+    @library{wxrichtext}
+    @category{richtext}
+
+    @see wxRichTextCommand
+*/
+
+class WXDLLIMPEXP_RICHTEXT wxRichTextObjectAddress
+{
+public:
+    /**
+        Creates the address given a container and an object.
+    */
+    wxRichTextObjectAddress(wxRichTextParagraphLayoutBox* topLevelContainer, wxRichTextObject* obj) { Create(topLevelContainer, obj); }
+    /**
+    */
+    wxRichTextObjectAddress() { Init(); }
+    /**
+    */
+    wxRichTextObjectAddress(const wxRichTextObjectAddress& address) { Copy(address); }
+
+    void Init() {}
+
+    /**
+        Copies the address.
+    */
+    void Copy(const wxRichTextObjectAddress& address) { m_address = address.m_address; }
+
+    /**
+        Assignment operator.
+    */
+    void operator=(const wxRichTextObjectAddress& address) { Copy(address); }
+
+    /**
+        Returns the object specified by the address, given a top level container.
+    */
+    wxRichTextObject* GetObject(wxRichTextParagraphLayoutBox* topLevelContainer) const;
+
+    /**
+        Creates the address given a container and an object.
+    */
+    bool Create(wxRichTextParagraphLayoutBox* topLevelContainer, wxRichTextObject* obj);
+
+    /**
+        Returns the array of integers representing the object address.
+    */
+    wxArrayInt& GetAddress() { return m_address; }
+
+    /**
+        Returns the array of integers representing the object address.
+    */
+    const wxArrayInt& GetAddress() const { return m_address; }
+
+    /**
+        Sets the address from an array of integers.
+    */
+    void SetAddress(const wxArrayInt& address) { m_address = address; }
+
+protected:
+
+    wxArrayInt  m_address;
+};
+
+class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextAction;
+
+/**
+    @class wxRichTextCommand
+
+    Implements a command on the undo/redo stack. A wxRichTextCommand object contains one or more wxRichTextAction
+    objects, allowing aggregation of a number of operations into one command.
+
+    @library{wxrichtext}
+    @category{richtext}
+
+    @see wxRichTextAction
+*/
 
 
-class WXDLLIMPEXP_RICHTEXT wxRichTextAction;
 class WXDLLIMPEXP_RICHTEXT wxRichTextCommand: public wxCommand
 {
 public:
 class WXDLLIMPEXP_RICHTEXT wxRichTextCommand: public wxCommand
 {
 public:
-    // Ctor for one action
+    /**
+        Constructor for one action.
+    */
     wxRichTextCommand(const wxString& name, wxRichTextCommandId id, wxRichTextBuffer* buffer,
     wxRichTextCommand(const wxString& name, wxRichTextCommandId id, wxRichTextBuffer* buffer,
-        wxRichTextCtrl* ctrl, bool ignoreFirstTime = false);
+        wxRichTextParagraphLayoutBox* container, wxRichTextCtrl* ctrl, bool ignoreFirstTime = false);
 
 
-    // Ctor for multiple actions
+    /**
+        Constructor for multiple actions.
+    */
     wxRichTextCommand(const wxString& name);
 
     virtual ~wxRichTextCommand();
 
     wxRichTextCommand(const wxString& name);
 
     virtual ~wxRichTextCommand();
 
+    /**
+        Performs the command.
+    */
     bool Do();
     bool Do();
+
+    /**
+        Undoes the command.
+    */
     bool Undo();
 
     bool Undo();
 
+    /**
+        Adds an action to the action list.
+    */
     void AddAction(wxRichTextAction* action);
     void AddAction(wxRichTextAction* action);
+
+    /**
+        Clears the action list.
+    */
     void ClearActions();
 
     void ClearActions();
 
+    /**
+        Returns the action list.
+    */
     wxList& GetActions() { return m_actions; }
 
 protected:
     wxList& GetActions() { return m_actions; }
 
 protected:
@@ -1743,41 +4991,136 @@ protected:
     wxList  m_actions;
 };
 
     wxList  m_actions;
 };
 
-/*!
- * wxRichTextAction class declaration
- * There can be more than one action in a command.
- */
+/**
+    @class wxRichTextAction
+
+    Implements a part of a command.
+
+    @library{wxrichtext}
+    @category{richtext}
+
+    @see wxRichTextCommand
+*/
 
 class WXDLLIMPEXP_RICHTEXT wxRichTextAction: public wxObject
 {
 public:
 
 class WXDLLIMPEXP_RICHTEXT wxRichTextAction: public wxObject
 {
 public:
-    wxRichTextAction(wxRichTextCommand* cmd, const wxString& name, wxRichTextCommandId id, wxRichTextBuffer* buffer,
+    /**
+        Constructor. @a buffer is the top-level buffer, while @a container is the object within
+        which the action is taking place. In the simplest case, they are the same.
+    */
+    wxRichTextAction(wxRichTextCommand* cmd, const wxString& name, wxRichTextCommandId id,
+        wxRichTextBuffer* buffer, wxRichTextParagraphLayoutBox* container,
         wxRichTextCtrl* ctrl, bool ignoreFirstTime = false);
 
     virtual ~wxRichTextAction();
 
         wxRichTextCtrl* ctrl, bool ignoreFirstTime = false);
 
     virtual ~wxRichTextAction();
 
+    /**
+        Performs the action.
+    */
     bool Do();
     bool Do();
-    bool Undo();
-
-    /// Update the control appearance
-    void UpdateAppearance(long caretPosition, bool sendUpdateEvent = false);
 
 
-    /// Replace the buffer paragraphs with the given fragment.
-    void ApplyParagraphs(const wxRichTextFragment& fragment);
-
-    /// Get the fragments
-    wxRichTextFragment& GetNewParagraphs() { return m_newParagraphs; }
-    wxRichTextFragment& GetOldParagraphs() { return m_oldParagraphs; }
+    /**
+        Undoes the action.
+    */
+    bool Undo();
 
 
-    /// Set/get the position used for e.g. insertion
+    /**
+        Updates the control appearance, optimizing if possible given information from the call to Layout.
+    */
+    void UpdateAppearance(long caretPosition, bool sendUpdateEvent = false,
+                            wxArrayInt* optimizationLineCharPositions = NULL, wxArrayInt* optimizationLineYPositions = NULL, bool isDoCmd = true);
+
+    /**
+        Replaces the buffer paragraphs with the given fragment.
+    */
+    void ApplyParagraphs(const wxRichTextParagraphLayoutBox& fragment);
+
+    /**
+        Returns the new fragments.
+    */
+    wxRichTextParagraphLayoutBox& GetNewParagraphs() { return m_newParagraphs; }
+
+    /**
+        Returns the old fragments.
+    */
+    wxRichTextParagraphLayoutBox& GetOldParagraphs() { return m_oldParagraphs; }
+
+    /**
+        Returns the attributes, for single-object commands.
+    */
+    wxRichTextAttr& GetAttributes() { return m_attributes; }
+
+    /**
+        Returns the object to replace the one at the position defined by the container address
+        and the action's range start position.
+    */
+    wxRichTextObject* GetObject() const { return m_object; }
+
+    /**
+        Sets the object to replace the one at the position defined by the container address
+        and the action's range start position.
+    */
+    void SetObject(wxRichTextObject* obj) { m_object = obj; m_objectAddress.Create(m_buffer, m_object); }
+
+    /**
+        Makes an address from the given object.
+    */
+    void MakeObject(wxRichTextObject* obj) { m_objectAddress.Create(m_buffer, obj); }
+
+    /**
+        Calculate arrays for refresh optimization.
+    */
+    void CalculateRefreshOptimizations(wxArrayInt& optimizationLineCharPositions, wxArrayInt& optimizationLineYPositions);
+
+    /**
+        Sets the position used for e.g. insertion.
+    */
     void SetPosition(long pos) { m_position = pos; }
     void SetPosition(long pos) { m_position = pos; }
+
+    /**
+        Returns the position used for e.g. insertion.
+    */
     long GetPosition() const { return m_position; }
 
     long GetPosition() const { return m_position; }
 
-    /// Set/get the range for e.g. deletion
+    /**
+        Sets the range for e.g. deletion.
+    */
     void SetRange(const wxRichTextRange& range) { m_range = range; }
     void SetRange(const wxRichTextRange& range) { m_range = range; }
+
+    /**
+        Returns the range for e.g. deletion.
+    */
     const wxRichTextRange& GetRange() const { return m_range; }
 
     const wxRichTextRange& GetRange() const { return m_range; }
 
-    /// Get name
+    /**
+        Returns the address (nested position) of the container within the buffer being manipulated.
+    */
+    wxRichTextObjectAddress& GetContainerAddress() { return m_containerAddress; }
+
+    /**
+        Returns the address (nested position) of the container within the buffer being manipulated.
+    */
+    const wxRichTextObjectAddress& GetContainerAddress() const { return m_containerAddress; }
+
+    /**
+        Sets the address (nested position) of the container within the buffer being manipulated.
+    */
+    void SetContainerAddress(const wxRichTextObjectAddress& address) { m_containerAddress = address; }
+
+    /**
+        Sets the address (nested position) of the container within the buffer being manipulated.
+    */
+    void SetContainerAddress(wxRichTextParagraphLayoutBox* container, wxRichTextObject* obj) { m_containerAddress.Create(container, obj); }
+
+    /**
+        Returns the container that this action refers to, using the container address and top-level buffer.
+    */
+    wxRichTextParagraphLayoutBox* GetContainer() const;
+
+    /**
+        Returns the action name.
+    */
     const wxString& GetName() const { return m_name; }
 
 protected:
     const wxString& GetName() const { return m_name; }
 
 protected:
@@ -1787,14 +5130,32 @@ protected:
     // Buffer
     wxRichTextBuffer*               m_buffer;
 
     // Buffer
     wxRichTextBuffer*               m_buffer;
 
+    // The address (nested position) of the container being manipulated.
+    // This is necessary because objects are deleted, and we can't
+    // therefore store actual pointers.
+    wxRichTextObjectAddress         m_containerAddress;
+
     // Control
     wxRichTextCtrl*                 m_ctrl;
 
     // Stores the new paragraphs
     // Control
     wxRichTextCtrl*                 m_ctrl;
 
     // Stores the new paragraphs
-    wxRichTextFragment              m_newParagraphs;
+    wxRichTextParagraphLayoutBox    m_newParagraphs;
 
     // Stores the old paragraphs
 
     // Stores the old paragraphs
-    wxRichTextFragment              m_oldParagraphs;
+    wxRichTextParagraphLayoutBox    m_oldParagraphs;
+
+    // Stores an object to replace the one at the position
+    // defined by the container address and the action's range start position.
+    wxRichTextObject*               m_object;
+
+    // Stores the attributes
+    wxRichTextAttr                  m_attributes;
+
+    // The address of the object being manipulated (used for changing an individual object or its attributes)
+    wxRichTextObjectAddress         m_objectAddress;
+
+    // Stores the old attributes
+    // wxRichTextAttr                  m_oldAttributes;
 
     // The affected range
     wxRichTextRange                 m_range;
 
     // The affected range
     wxRichTextRange                 m_range;
@@ -1810,61 +5171,173 @@ protected:
 };
 
 /*!
 };
 
 /*!
- * wxRichTextFileHandler
- * Base class for file handlers
+ * Handler flags
  */
 
  */
 
+// Include style sheet when loading and saving
+#define wxRICHTEXT_HANDLER_INCLUDE_STYLESHEET       0x0001
+
+// Save images to memory file system in HTML handler
+#define wxRICHTEXT_HANDLER_SAVE_IMAGES_TO_MEMORY    0x0010
+
+// Save images to files in HTML handler
+#define wxRICHTEXT_HANDLER_SAVE_IMAGES_TO_FILES     0x0020
+
+// Save images as inline base64 data in HTML handler
+#define wxRICHTEXT_HANDLER_SAVE_IMAGES_TO_BASE64    0x0040
+
+// Don't write header and footer (or BODY), so we can include the fragment
+// in a larger document
+#define wxRICHTEXT_HANDLER_NO_HEADER_FOOTER         0x0080
+
+// Convert the more common face names to names that will work on the current platform
+// in a larger document
+#define wxRICHTEXT_HANDLER_CONVERT_FACENAMES        0x0100
+
+/**
+    @class wxRichTextFileHandler
+
+    The base class for file handlers.
+
+    @library{wxrichtext}
+    @category{richtext}
+
+    @see wxRichTextBuffer, wxRichTextCtrl
+*/
+
 class WXDLLIMPEXP_RICHTEXT wxRichTextFileHandler: public wxObject
 {
     DECLARE_CLASS(wxRichTextFileHandler)
 public:
 class WXDLLIMPEXP_RICHTEXT wxRichTextFileHandler: public wxObject
 {
     DECLARE_CLASS(wxRichTextFileHandler)
 public:
+    /**
+        Creates a file handler object.
+    */
     wxRichTextFileHandler(const wxString& name = wxEmptyString, const wxString& ext = wxEmptyString, int type = 0)
     wxRichTextFileHandler(const wxString& name = wxEmptyString, const wxString& ext = wxEmptyString, int type = 0)
-        : m_name(name), m_extension(ext), m_type(type), m_visible(true)
+        : m_name(name), m_extension(ext), m_type(type), m_flags(0), m_visible(true)
         { }
 
 #if wxUSE_STREAMS
         { }
 
 #if wxUSE_STREAMS
+    /**
+        Loads the buffer from a stream.
+        Not all handlers will implement file loading.
+    */
     bool LoadFile(wxRichTextBuffer *buffer, wxInputStream& stream)
     { return DoLoadFile(buffer, stream); }
     bool LoadFile(wxRichTextBuffer *buffer, wxInputStream& stream)
     { return DoLoadFile(buffer, stream); }
+
+    /**
+        Saves the buffer to a stream.
+        Not all handlers will implement file saving.
+    */
     bool SaveFile(wxRichTextBuffer *buffer, wxOutputStream& stream)
     { return DoSaveFile(buffer, stream); }
 #endif
 
     bool SaveFile(wxRichTextBuffer *buffer, wxOutputStream& stream)
     { return DoSaveFile(buffer, stream); }
 #endif
 
-    bool LoadFile(wxRichTextBuffer *buffer, const wxString& filename);
-    bool SaveFile(wxRichTextBuffer *buffer, const wxString& filename);
-
-    /// Can we handle this filename (if using files)? By default, checks the extension.
+#if wxUSE_FFILE && wxUSE_STREAMS
+    /**
+        Loads the buffer from a file.
+    */
+    virtual bool LoadFile(wxRichTextBuffer *buffer, const wxString& filename);
+
+    /**
+        Saves the buffer to a file.
+    */
+    virtual bool SaveFile(wxRichTextBuffer *buffer, const wxString& filename);
+#endif // wxUSE_STREAMS && wxUSE_STREAMS
+
+    /**
+        Returns @true if we handle this filename (if using files). By default, checks the extension.
+    */
     virtual bool CanHandle(const wxString& filename) const;
 
     virtual bool CanHandle(const wxString& filename) const;
 
-    /// Can we save using this handler?
+    /**
+        Returns @true if we can save using this handler.
+    */
     virtual bool CanSave() const { return false; }
 
     virtual bool CanSave() const { return false; }
 
-    /// Can we load using this handler?
+    /**
+        Returns @true if we can load using this handler.
+    */
     virtual bool CanLoad() const { return false; }
 
     virtual bool CanLoad() const { return false; }
 
-    /// Should this handler be visible to the user?
+    /**
+        Returns @true if this handler should be visible to the user.
+    */
     virtual bool IsVisible() const { return m_visible; }
     virtual bool IsVisible() const { return m_visible; }
+
+    /**
+        Sets whether the handler should be visible to the user (via the application's
+        load and save dialogs).
+    */
     virtual void SetVisible(bool visible) { m_visible = visible; }
 
     virtual void SetVisible(bool visible) { m_visible = visible; }
 
-    /// The name of the nandler
+    /**
+        Sets the name of the nandler.
+    */
     void SetName(const wxString& name) { m_name = name; }
     void SetName(const wxString& name) { m_name = name; }
+
+    /**
+        Returns the name of the nandler.
+    */
     wxString GetName() const { return m_name; }
 
     wxString GetName() const { return m_name; }
 
-    /// The default extension to recognise
+    /**
+        Sets the default extension to recognise.
+    */
     void SetExtension(const wxString& ext) { m_extension = ext; }
     void SetExtension(const wxString& ext) { m_extension = ext; }
+
+    /**
+        Returns the default extension to recognise.
+    */
     wxString GetExtension() const { return m_extension; }
 
     wxString GetExtension() const { return m_extension; }
 
-    /// The handler type
+    /**
+        Sets the handler type.
+    */
     void SetType(int type) { m_type = type; }
     void SetType(int type) { m_type = type; }
+
+    /**
+        Returns the handler type.
+    */
     int GetType() const { return m_type; }
 
     int GetType() const { return m_type; }
 
-    /// Encoding to use when saving a file. If empty, a suitable encoding is chosen
+    /**
+        Sets flags that change the behaviour of loading or saving.
+        See the documentation for each handler class to see what flags are relevant
+        for each handler.
+
+        You call this function directly if you are using a file handler explicitly
+        (without going through the text control or buffer LoadFile/SaveFile API).
+        Or, you can call the control or buffer's SetHandlerFlags function to set
+        the flags that will be used for subsequent load and save operations.
+    */
+    void SetFlags(int flags) { m_flags = flags; }
+
+    /**
+        Returns flags controlling how loading and saving is done.
+    */
+    int GetFlags() const { return m_flags; }
+
+    /**
+        Sets the encoding to use when saving a file. If empty, a suitable encoding is chosen.
+    */
     void SetEncoding(const wxString& encoding) { m_encoding = encoding; }
     void SetEncoding(const wxString& encoding) { m_encoding = encoding; }
+
+    /**
+        Returns the encoding to use when saving a file. If empty, a suitable encoding is chosen.
+    */
     const wxString& GetEncoding() const { return m_encoding; }
 
 protected:
 
 #if wxUSE_STREAMS
     const wxString& GetEncoding() const { return m_encoding; }
 
 protected:
 
 #if wxUSE_STREAMS
+    /**
+        Override to load content from @a stream into @a buffer.
+    */
     virtual bool DoLoadFile(wxRichTextBuffer *buffer, wxInputStream& stream) = 0;
     virtual bool DoLoadFile(wxRichTextBuffer *buffer, wxInputStream& stream) = 0;
+
+    /**
+        Override to save content to @a stream from @a buffer.
+    */
     virtual bool DoSaveFile(wxRichTextBuffer *buffer, wxOutputStream& stream) = 0;
 #endif
 
     virtual bool DoSaveFile(wxRichTextBuffer *buffer, wxOutputStream& stream) = 0;
 #endif
 
@@ -1872,26 +5345,35 @@ protected:
     wxString  m_encoding;
     wxString  m_extension;
     int       m_type;
     wxString  m_encoding;
     wxString  m_extension;
     int       m_type;
+    int       m_flags;
     bool      m_visible;
 };
 
     bool      m_visible;
 };
 
-/*!
- * wxRichTextPlainTextHandler
- * Plain text handler
- */
+/**
+    @class wxRichTextPlainTextHandler
+
+    Implements saving a buffer to plain text.
+
+    @library{wxrichtext}
+    @category{richtext}
+
+    @see wxRichTextFileHandler, wxRichTextBuffer, wxRichTextCtrl
+*/
 
 class WXDLLIMPEXP_RICHTEXT wxRichTextPlainTextHandler: public wxRichTextFileHandler
 {
     DECLARE_CLASS(wxRichTextPlainTextHandler)
 public:
 
 class WXDLLIMPEXP_RICHTEXT wxRichTextPlainTextHandler: public wxRichTextFileHandler
 {
     DECLARE_CLASS(wxRichTextPlainTextHandler)
 public:
-    wxRichTextPlainTextHandler(const wxString& name = wxT("Text"), const wxString& ext = wxT("txt"), int type = wxRICHTEXT_TYPE_TEXT)
+    wxRichTextPlainTextHandler(const wxString& name = wxT("Text"),
+                               const wxString& ext = wxT("txt"),
+                               wxRichTextFileType type = wxRICHTEXT_TYPE_TEXT)
         : wxRichTextFileHandler(name, ext, type)
         { }
 
         : wxRichTextFileHandler(name, ext, type)
         { }
 
-    /// Can we save using this handler?
+    // Can we save using this handler?
     virtual bool CanSave() const { return true; }
 
     virtual bool CanSave() const { return true; }
 
-    /// Can we load using this handler?
+    // Can we load using this handler?
     virtual bool CanLoad() const { return true; }
 
 protected:
     virtual bool CanLoad() const { return true; }
 
 protected:
@@ -1903,6 +5385,134 @@ protected:
 
 };
 
 
 };
 
+#if wxUSE_DATAOBJ
+
+/**
+    @class wxRichTextBufferDataObject
+
+    Implements a rich text data object for clipboard transfer.
+
+    @library{wxrichtext}
+    @category{richtext}
+
+    @see wxDataObjectSimple, wxRichTextBuffer, wxRichTextCtrl
+*/
+
+class WXDLLIMPEXP_RICHTEXT wxRichTextBufferDataObject: public wxDataObjectSimple
+{
+public:
+    /**
+        The constructor doesn't copy the pointer, so it shouldn't go away while this object
+        is alive.
+    */
+    wxRichTextBufferDataObject(wxRichTextBuffer* richTextBuffer = NULL);
+    virtual ~wxRichTextBufferDataObject();
+
+    /**
+        After a call to this function, the buffer is owned by the caller and it
+        is responsible for deleting it.
+    */
+    wxRichTextBuffer* GetRichTextBuffer();
+
+    /**
+        Returns the id for the new data format.
+    */
+    static const wxChar* GetRichTextBufferFormatId() { return ms_richTextBufferFormatId; }
+
+    // base class pure virtuals
+
+    virtual wxDataFormat GetPreferredFormat(Direction dir) const;
+    virtual size_t GetDataSize() const;
+    virtual bool GetDataHere(void *pBuf) const;
+    virtual bool SetData(size_t len, const void *buf);
+
+    // prevent warnings
+
+    virtual size_t GetDataSize(const wxDataFormat&) const { return GetDataSize(); }
+    virtual bool GetDataHere(const wxDataFormat&, void *buf) const { return GetDataHere(buf); }
+    virtual bool SetData(const wxDataFormat&, size_t len, const void *buf) { return SetData(len, buf); }
+
+private:
+    wxDataFormat            m_formatRichTextBuffer;     // our custom format
+    wxRichTextBuffer*       m_richTextBuffer;           // our data
+    static const wxChar*    ms_richTextBufferFormatId;  // our format id
+};
+
+#endif
+
+/**
+    @class wxRichTextRenderer
+
+    This class isolates some common drawing functionality.
+
+    @library{wxrichtext}
+    @category{richtext}
+
+    @see wxRichTextBuffer, wxRichTextCtrl
+*/
+
+class WXDLLIMPEXP_RICHTEXT wxRichTextRenderer: public wxObject
+{
+public:
+    /**
+        Constructor.
+    */
+    wxRichTextRenderer() {}
+    virtual ~wxRichTextRenderer() {}
+
+    /**
+        Draws a standard bullet, as specified by the value of GetBulletName. This function should be overridden.
+    */
+    virtual bool DrawStandardBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxRichTextAttr& attr, const wxRect& rect) = 0;
+
+    /**
+        Draws a bullet that can be described by text, such as numbered or symbol bullets. This function should be overridden.
+    */
+    virtual bool DrawTextBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxRichTextAttr& attr, const wxRect& rect, const wxString& text) = 0;
+
+    /**
+        Draws a bitmap bullet, where the bullet bitmap is specified by the value of GetBulletName. This function should be overridden.
+    */
+    virtual bool DrawBitmapBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxRichTextAttr& attr, const wxRect& rect) = 0;
+
+    /**
+        Enumerate the standard bullet names currently supported. This function should be overridden.
+    */
+    virtual bool EnumerateStandardBulletNames(wxArrayString& bulletNames) = 0;
+};
+
+/**
+    @class wxRichTextStdRenderer
+
+    The standard renderer for drawing bullets.
+
+    @library{wxrichtext}
+    @category{richtext}
+
+    @see wxRichTextRenderer, wxRichTextBuffer, wxRichTextCtrl
+*/
+
+class WXDLLIMPEXP_RICHTEXT wxRichTextStdRenderer: public wxRichTextRenderer
+{
+public:
+    /**
+        Constructor.
+    */
+    wxRichTextStdRenderer() {}
+
+    // Draw a standard bullet, as specified by the value of GetBulletName
+    virtual bool DrawStandardBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxRichTextAttr& attr, const wxRect& rect);
+
+    // Draw a bullet that can be described by text, such as numbered or symbol bullets
+    virtual bool DrawTextBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxRichTextAttr& attr, const wxRect& rect, const wxString& text);
+
+    // Draw a bitmap bullet, where the bullet bitmap is specified by the value of GetBulletName
+    virtual bool DrawBitmapBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxRichTextAttr& attr, const wxRect& rect);
+
+    // Enumerate the standard bullet names currently supported
+    virtual bool EnumerateStandardBulletNames(wxArrayString& bulletNames);
+};
+
 /*!
  * Utilities
  *
 /*!
  * Utilities
  *
@@ -1914,21 +5524,43 @@ inline bool wxRichTextHasStyle(int flags, int style)
 }
 
 /// Compare two attribute objects
 }
 
 /// Compare two attribute objects
-bool wxTextAttrEq(const wxTextAttrEx& attr1, const wxTextAttrEx& attr2);
-bool wxTextAttrEq(const wxTextAttr& attr1, const wxRichTextAttr& attr2);
+WXDLLIMPEXP_RICHTEXT bool wxTextAttrEq(const wxRichTextAttr& attr1, const wxRichTextAttr& attr2);
+WXDLLIMPEXP_RICHTEXT bool wxTextAttrEq(const wxRichTextAttr& attr1, const wxRichTextAttr& attr2);
 
 /// Compare two attribute objects, but take into account the flags
 /// specifying attributes of interest.
 
 /// Compare two attribute objects, but take into account the flags
 /// specifying attributes of interest.
-bool wxTextAttrEqPartial(const wxTextAttrEx& attr1, const wxTextAttrEx& attr2, int flags);
-bool wxTextAttrEqPartial(const wxTextAttrEx& attr1, const wxRichTextAttr& attr2, int flags);
+WXDLLIMPEXP_RICHTEXT bool wxTextAttrEqPartial(const wxRichTextAttr& attr1, const wxRichTextAttr& attr2);
 
 /// Apply one style to another
 
 /// Apply one style to another
-bool wxRichTextApplyStyle(wxTextAttrEx& destStyle, const wxTextAttrEx& style);
-bool wxRichTextApplyStyle(wxRichTextAttr& destStyle, const wxTextAttrEx& style);
-bool wxRichTextApplyStyle(wxTextAttrEx& destStyle, const wxRichTextAttr& style);
+WXDLLIMPEXP_RICHTEXT bool wxRichTextApplyStyle(wxRichTextAttr& destStyle, const wxRichTextAttr& style, wxRichTextAttr* compareWith = NULL);
+
+// Remove attributes
+WXDLLIMPEXP_RICHTEXT bool wxRichTextRemoveStyle(wxRichTextAttr& destStyle, const wxRichTextAttr& style);
+
+/// Combine two bitlists
+WXDLLIMPEXP_RICHTEXT bool wxRichTextCombineBitlists(int& valueA, int valueB, int& flagsA, int flagsB);
+
+/// Compare two bitlists
+WXDLLIMPEXP_RICHTEXT bool wxRichTextBitlistsEqPartial(int valueA, int valueB, int flags);
+
+/// Split into paragraph and character styles
+WXDLLIMPEXP_RICHTEXT bool wxRichTextSplitParaCharStyles(const wxRichTextAttr& style, wxRichTextAttr& parStyle, wxRichTextAttr& charStyle);
+
+/// Compare tabs
+WXDLLIMPEXP_RICHTEXT bool wxRichTextTabsEq(const wxArrayInt& tabs1, const wxArrayInt& tabs2);
+
+/// Convert a decimal to Roman numerals
+WXDLLIMPEXP_RICHTEXT wxString wxRichTextDecimalToRoman(long n);
+
+// Collects the attributes that are common to a range of content, building up a note of
+// which attributes are absent in some objects and which clash in some objects.
+WXDLLIMPEXP_RICHTEXT void wxTextAttrCollectCommonAttributes(wxTextAttr& currentStyle, const wxTextAttr& attr, wxTextAttr& clashingAttr, wxTextAttr& absentAttr);
+
+WXDLLIMPEXP_RICHTEXT void wxRichTextModuleInit();
 
 #endif
     // wxUSE_RICHTEXT
 
 #endif
     // _WX_RICHTEXTBUFFER_H_
 
 #endif
     // wxUSE_RICHTEXT
 
 #endif
     // _WX_RICHTEXTBUFFER_H_
+