X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/fee9bb24d90c96e2756646a790042cf896f10c94..29131e8a54a8bb08ce6ea0bdb0d4093c20aebf68:/src/richtext/richtextbuffer.cpp

diff --git a/src/richtext/richtextbuffer.cpp b/src/richtext/richtextbuffer.cpp
index d9d78dcb84..9cdcf263c4 100644
--- a/src/richtext/richtextbuffer.cpp
+++ b/src/richtext/richtextbuffer.cpp
@@ -1556,7 +1556,7 @@ wxRichTextObject* wxRichTextParagraphLayoutBox::GetLeafObjectAtPosition(long pos
 }
 
 /// Set character or paragraph text attributes: apply character styles only to immediate text nodes
-bool wxRichTextParagraphLayoutBox::SetStyle(const wxRichTextRange& range, const wxRichTextAttr& style, bool withUndo)
+bool wxRichTextParagraphLayoutBox::SetStyle(const wxRichTextRange& range, const wxRichTextAttr& style, int flags)
 {
     bool characterStyle = false;
     bool paragraphStyle = false;
@@ -1566,6 +1566,15 @@ bool wxRichTextParagraphLayoutBox::SetStyle(const wxRichTextRange& range, const
     if (style.IsParagraphStyle())
         paragraphStyle = true;
 
+    bool withUndo = ((flags & wxRICHTEXT_SETSTYLE_WITH_UNDO) != 0);
+    bool applyMinimal = ((flags & wxRICHTEXT_SETSTYLE_OPTIMIZE) != 0);
+    bool parasOnly = ((flags & wxRICHTEXT_SETSTYLE_PARAGRAPHS_ONLY) != 0);
+    bool charactersOnly = ((flags & wxRICHTEXT_SETSTYLE_CHARACTERS_ONLY) != 0);
+
+    // Limit the attributes to be set to the content to only character attributes.
+    wxRichTextAttr characterAttributes(style);
+    characterAttributes.SetFlags(characterAttributes.GetFlags() & (wxTEXT_ATTR_CHARACTER));
+
     // If we are associated with a control, make undoable; otherwise, apply immediately
     // to the data.
 
@@ -1608,16 +1617,33 @@ bool wxRichTextParagraphLayoutBox::SetStyle(const wxRichTextRange& range, const
                 }
                 else
                     newPara = para;
-
-                if (paragraphStyle)
-                    wxRichTextApplyStyle(newPara->GetAttributes(), style);
+                
+                if (paragraphStyle && !charactersOnly)
+                {
+                    if (applyMinimal)
+                    {
+                        // Only apply attributes that will make a difference to the combined
+                        // style as seen on the display
+                        wxRichTextAttr combinedAttr(para->GetCombinedAttributes());
+                        wxRichTextApplyStyle(newPara->GetAttributes(), style, & combinedAttr);
+                    }
+                    else
+                        wxRichTextApplyStyle(newPara->GetAttributes(), style);
+                }
 
 #if wxRICHTEXT_USE_DYNAMIC_STYLES
                 // If applying paragraph styles dynamically, don't change the text objects' attributes
                 // since they will computed as needed. Only apply the character styling if it's _only_
                 // character styling. This policy is subject to change and might be put under user control.
 
-                if (!paragraphStyle && characterStyle && range.GetStart() != newPara->GetRange().GetEnd())
+                // Hm. we might well be applying a mix of paragraph and character styles, in which
+                // case we _do_ want to apply character styles regardless of what para styles are set.
+                // But if we're applying a paragraph style, which has some character attributes, but
+                // we only want the paragraphs to hold this character style, then we _don't_ want to
+                // apply the character style. So we need to be able to choose.
+
+                // if (!paragraphStyle && characterStyle && range.GetStart() != newPara->GetRange().GetEnd())
+                if (!parasOnly && characterStyle && range.GetStart() != newPara->GetRange().GetEnd())
 #else
                 if (characterStyle && range.GetStart() != newPara->GetRange().GetEnd())
 #endif
@@ -1668,7 +1694,16 @@ bool wxRichTextParagraphLayoutBox::SetStyle(const wxRichTextRange& range, const
                     {
                         wxRichTextObject* child = node2->GetData();
 
-                        wxRichTextApplyStyle(child->GetAttributes(), style);
+                        if (applyMinimal)
+                        {
+                            // Only apply attributes that will make a difference to the combined
+                            // style as seen on the display
+                            wxRichTextAttr combinedAttr(newPara->GetCombinedAttributes(child->GetAttributes()));
+                            wxRichTextApplyStyle(child->GetAttributes(), characterAttributes, & combinedAttr);
+                        }
+                        else
+                            wxRichTextApplyStyle(child->GetAttributes(), characterAttributes);
+
                         if (node2 == lastNode)
                             break;
 
@@ -1689,10 +1724,10 @@ bool wxRichTextParagraphLayoutBox::SetStyle(const wxRichTextRange& range, const
 }
 
 /// Set text attributes
-bool wxRichTextParagraphLayoutBox::SetStyle(const wxRichTextRange& range, const wxTextAttrEx& style, bool withUndo)
+bool wxRichTextParagraphLayoutBox::SetStyle(const wxRichTextRange& range, const wxTextAttrEx& style, int flags)
 {
     wxRichTextAttr richStyle = style;
-    return SetStyle(range, richStyle, withUndo);
+    return SetStyle(range, richStyle, flags);
 }
 
 /// Get the text attributes for this position.
@@ -1782,6 +1817,420 @@ bool wxRichTextParagraphLayoutBox::DoGetStyle(long position, wxTextAttrEx& style
     return false;
 }
 
+static bool wxHasStyle(long flags, long style)
+{
+    return (flags & style) != 0;
+}
+
+/// Combines 'style' with 'currentStyle' for the purpose of summarising the attributes of a range of
+/// content.
+bool wxRichTextParagraphLayoutBox::CollectStyle(wxTextAttrEx& currentStyle, const wxTextAttrEx& style, long& multipleStyleAttributes)
+{
+    if (style.HasFont())
+    {
+        if (style.HasSize() && !wxHasStyle(multipleStyleAttributes, wxTEXT_ATTR_FONT_SIZE))
+        {
+            if (currentStyle.GetFont().Ok() && currentStyle.HasSize())
+            {
+                if (currentStyle.GetFont().GetPointSize() != style.GetFont().GetPointSize())
+                {
+                    // Clash of style - mark as such
+                    multipleStyleAttributes |= wxTEXT_ATTR_FONT_SIZE;
+                    currentStyle.SetFlags(currentStyle.GetFlags() & ~wxTEXT_ATTR_FONT_SIZE);
+                }
+            }
+            else
+            {
+                if (!currentStyle.GetFont().Ok())
+                    wxSetFontPreservingStyles(currentStyle, *wxNORMAL_FONT);
+                wxFont font(currentStyle.GetFont());
+                font.SetPointSize(style.GetFont().GetPointSize());
+
+                wxSetFontPreservingStyles(currentStyle, font);
+                currentStyle.SetFlags(currentStyle.GetFlags() | wxTEXT_ATTR_FONT_SIZE);
+            }
+        }
+
+        if (style.HasItalic() && !wxHasStyle(multipleStyleAttributes, wxTEXT_ATTR_FONT_ITALIC))
+        {
+            if (currentStyle.GetFont().Ok() && currentStyle.HasItalic())
+            {
+                if (currentStyle.GetFont().GetStyle() != style.GetFont().GetStyle())
+                {
+                    // Clash of style - mark as such
+                    multipleStyleAttributes |= wxTEXT_ATTR_FONT_ITALIC;
+                    currentStyle.SetFlags(currentStyle.GetFlags() & ~wxTEXT_ATTR_FONT_ITALIC);
+                }
+            }
+            else
+            {
+                if (!currentStyle.GetFont().Ok())
+                    wxSetFontPreservingStyles(currentStyle, *wxNORMAL_FONT);
+                wxFont font(currentStyle.GetFont());
+                font.SetStyle(style.GetFont().GetStyle());
+                wxSetFontPreservingStyles(currentStyle, font);
+                currentStyle.SetFlags(currentStyle.GetFlags() | wxTEXT_ATTR_FONT_ITALIC);
+            }
+        }
+
+        if (style.HasWeight() && !wxHasStyle(multipleStyleAttributes, wxTEXT_ATTR_FONT_WEIGHT))
+        {
+            if (currentStyle.GetFont().Ok() && currentStyle.HasWeight())
+            {
+                if (currentStyle.GetFont().GetWeight() != style.GetFont().GetWeight())
+                {
+                    // Clash of style - mark as such
+                    multipleStyleAttributes |= wxTEXT_ATTR_FONT_WEIGHT;
+                    currentStyle.SetFlags(currentStyle.GetFlags() & ~wxTEXT_ATTR_FONT_WEIGHT);
+                }
+            }
+            else
+            {
+                if (!currentStyle.GetFont().Ok())
+                    wxSetFontPreservingStyles(currentStyle, *wxNORMAL_FONT);
+                wxFont font(currentStyle.GetFont());
+                font.SetWeight(style.GetFont().GetWeight());
+                wxSetFontPreservingStyles(currentStyle, font);
+                currentStyle.SetFlags(currentStyle.GetFlags() | wxTEXT_ATTR_FONT_WEIGHT);
+            }
+        }
+
+        if (style.HasFaceName() && !wxHasStyle(multipleStyleAttributes, wxTEXT_ATTR_FONT_FACE))
+        {
+            if (currentStyle.GetFont().Ok() && currentStyle.HasFaceName())
+            {
+                wxString faceName1(currentStyle.GetFont().GetFaceName());
+                wxString faceName2(style.GetFont().GetFaceName());
+
+                if (faceName1 != faceName2)
+                {
+                    // Clash of style - mark as such
+                    multipleStyleAttributes |= wxTEXT_ATTR_FONT_FACE;
+                    currentStyle.SetFlags(currentStyle.GetFlags() & ~wxTEXT_ATTR_FONT_FACE);
+                }
+            }
+            else
+            {
+                if (!currentStyle.GetFont().Ok())
+                    wxSetFontPreservingStyles(currentStyle, *wxNORMAL_FONT);
+                wxFont font(currentStyle.GetFont());
+                font.SetFaceName(style.GetFont().GetFaceName());
+                wxSetFontPreservingStyles(currentStyle, font);
+                currentStyle.SetFlags(currentStyle.GetFlags() | wxTEXT_ATTR_FONT_FACE);
+            }
+        }
+
+        if (style.HasUnderlined() && !wxHasStyle(multipleStyleAttributes, wxTEXT_ATTR_FONT_UNDERLINE))
+        {
+            if (currentStyle.GetFont().Ok() && currentStyle.HasUnderlined())
+            {
+                if (currentStyle.GetFont().GetUnderlined() != style.GetFont().GetUnderlined())
+                {
+                    // Clash of style - mark as such
+                    multipleStyleAttributes |= wxTEXT_ATTR_FONT_UNDERLINE;
+                    currentStyle.SetFlags(currentStyle.GetFlags() & ~wxTEXT_ATTR_FONT_UNDERLINE);
+                }
+            }
+            else
+            {
+                if (!currentStyle.GetFont().Ok())
+                    wxSetFontPreservingStyles(currentStyle, *wxNORMAL_FONT);
+                wxFont font(currentStyle.GetFont());
+                font.SetUnderlined(style.GetFont().GetUnderlined());
+                wxSetFontPreservingStyles(currentStyle, font);
+                currentStyle.SetFlags(currentStyle.GetFlags() | wxTEXT_ATTR_FONT_UNDERLINE);
+            }
+        }
+    }
+
+    if (style.HasTextColour() && !wxHasStyle(multipleStyleAttributes, wxTEXT_ATTR_TEXT_COLOUR))
+    {
+        if (currentStyle.HasTextColour())
+        {
+            if (currentStyle.GetTextColour() != style.GetTextColour())
+            {
+                // Clash of style - mark as such
+                multipleStyleAttributes |= wxTEXT_ATTR_TEXT_COLOUR;
+                currentStyle.SetFlags(currentStyle.GetFlags() & ~wxTEXT_ATTR_TEXT_COLOUR);
+            }
+        }
+        else
+            currentStyle.SetTextColour(style.GetTextColour());
+    }
+
+    if (style.HasBackgroundColour() && !wxHasStyle(multipleStyleAttributes, wxTEXT_ATTR_BACKGROUND_COLOUR))
+    {
+        if (currentStyle.HasBackgroundColour())
+        {
+            if (currentStyle.GetBackgroundColour() != style.GetBackgroundColour())
+            {
+                // Clash of style - mark as such
+                multipleStyleAttributes |= wxTEXT_ATTR_BACKGROUND_COLOUR;
+                currentStyle.SetFlags(currentStyle.GetFlags() & ~wxTEXT_ATTR_BACKGROUND_COLOUR);
+            }
+        }
+        else
+            currentStyle.SetBackgroundColour(style.GetBackgroundColour());
+    }
+
+    if (style.HasAlignment() && !wxHasStyle(multipleStyleAttributes, wxTEXT_ATTR_ALIGNMENT))
+    {
+        if (currentStyle.HasAlignment())
+        {
+            if (currentStyle.GetAlignment() != style.GetAlignment())
+            {
+                // Clash of style - mark as such
+                multipleStyleAttributes |= wxTEXT_ATTR_ALIGNMENT;
+                currentStyle.SetFlags(currentStyle.GetFlags() & ~wxTEXT_ATTR_ALIGNMENT);
+            }
+        }
+        else
+            currentStyle.SetAlignment(style.GetAlignment());
+    }
+
+    if (style.HasTabs() && !wxHasStyle(multipleStyleAttributes, wxTEXT_ATTR_TABS))
+    {
+        if (currentStyle.HasTabs())
+        {
+            if (!wxRichTextTabsEq(currentStyle.GetTabs(), style.GetTabs()))
+            {
+                // Clash of style - mark as such
+                multipleStyleAttributes |= wxTEXT_ATTR_TABS;
+                currentStyle.SetFlags(currentStyle.GetFlags() & ~wxTEXT_ATTR_TABS);
+            }
+        }
+        else
+            currentStyle.SetTabs(style.GetTabs());
+    }
+
+    if (style.HasLeftIndent() && !wxHasStyle(multipleStyleAttributes, wxTEXT_ATTR_LEFT_INDENT))
+    {
+        if (currentStyle.HasLeftIndent())
+        {
+            if (currentStyle.GetLeftIndent() != style.GetLeftIndent() || currentStyle.GetLeftSubIndent() != style.GetLeftSubIndent())
+            {
+                // Clash of style - mark as such
+                multipleStyleAttributes |= wxTEXT_ATTR_LEFT_INDENT;
+                currentStyle.SetFlags(currentStyle.GetFlags() & ~wxTEXT_ATTR_LEFT_INDENT);
+            }
+        }
+        else
+            currentStyle.SetLeftIndent(style.GetLeftIndent(), style.GetLeftSubIndent());
+    }
+
+    if (style.HasRightIndent() && !wxHasStyle(multipleStyleAttributes, wxTEXT_ATTR_RIGHT_INDENT))
+    {
+        if (currentStyle.HasRightIndent())
+        {
+            if (currentStyle.GetRightIndent() != style.GetRightIndent())
+            {
+                // Clash of style - mark as such
+                multipleStyleAttributes |= wxTEXT_ATTR_RIGHT_INDENT;
+                currentStyle.SetFlags(currentStyle.GetFlags() & ~wxTEXT_ATTR_RIGHT_INDENT);
+            }
+        }
+        else
+            currentStyle.SetRightIndent(style.GetRightIndent());
+    }
+
+    if (style.HasParagraphSpacingAfter() && !wxHasStyle(multipleStyleAttributes, wxTEXT_ATTR_PARA_SPACING_AFTER))
+    {
+        if (currentStyle.HasParagraphSpacingAfter())
+        {
+            if (currentStyle.HasParagraphSpacingAfter() != style.HasParagraphSpacingAfter())
+            {
+                // Clash of style - mark as such
+                multipleStyleAttributes |= wxTEXT_ATTR_PARA_SPACING_AFTER;
+                currentStyle.SetFlags(currentStyle.GetFlags() & ~wxTEXT_ATTR_PARA_SPACING_AFTER);
+            }
+        }
+        else
+            currentStyle.SetParagraphSpacingAfter(style.GetParagraphSpacingAfter());
+    }
+
+    if (style.HasParagraphSpacingBefore() && !wxHasStyle(multipleStyleAttributes, wxTEXT_ATTR_PARA_SPACING_BEFORE))
+    {
+        if (currentStyle.HasParagraphSpacingBefore())
+        {
+            if (currentStyle.HasParagraphSpacingBefore() != style.HasParagraphSpacingBefore())
+            {
+                // Clash of style - mark as such
+                multipleStyleAttributes |= wxTEXT_ATTR_PARA_SPACING_BEFORE;
+                currentStyle.SetFlags(currentStyle.GetFlags() & ~wxTEXT_ATTR_PARA_SPACING_BEFORE);
+            }
+        }
+        else
+            currentStyle.SetParagraphSpacingBefore(style.GetParagraphSpacingBefore());
+    }
+
+    if (style.HasLineSpacing() && !wxHasStyle(multipleStyleAttributes, wxTEXT_ATTR_LINE_SPACING))
+    {
+        if (currentStyle.HasLineSpacing())
+        {
+            if (currentStyle.HasLineSpacing() != style.HasLineSpacing())
+            {
+                // Clash of style - mark as such
+                multipleStyleAttributes |= wxTEXT_ATTR_LINE_SPACING;
+                currentStyle.SetFlags(currentStyle.GetFlags() & ~wxTEXT_ATTR_LINE_SPACING);
+            }
+        }
+        else
+            currentStyle.SetLineSpacing(style.GetLineSpacing());
+    }
+
+    if (style.HasCharacterStyleName() && !wxHasStyle(multipleStyleAttributes, wxTEXT_ATTR_CHARACTER_STYLE_NAME))
+    {
+        if (currentStyle.HasCharacterStyleName())
+        {
+            if (currentStyle.HasCharacterStyleName() != style.HasCharacterStyleName())
+            {
+                // Clash of style - mark as such
+                multipleStyleAttributes |= wxTEXT_ATTR_CHARACTER_STYLE_NAME;
+                currentStyle.SetFlags(currentStyle.GetFlags() & ~wxTEXT_ATTR_CHARACTER_STYLE_NAME);
+            }
+        }
+        else
+            currentStyle.SetCharacterStyleName(style.GetCharacterStyleName());
+    }
+
+    if (style.HasParagraphStyleName() && !wxHasStyle(multipleStyleAttributes, wxTEXT_ATTR_PARAGRAPH_STYLE_NAME))
+    {
+        if (currentStyle.HasParagraphStyleName())
+        {
+            if (currentStyle.HasParagraphStyleName() != style.HasParagraphStyleName())
+            {
+                // Clash of style - mark as such
+                multipleStyleAttributes |= wxTEXT_ATTR_PARAGRAPH_STYLE_NAME;
+                currentStyle.SetFlags(currentStyle.GetFlags() & ~wxTEXT_ATTR_PARAGRAPH_STYLE_NAME);
+            }
+        }
+        else
+            currentStyle.SetParagraphStyleName(style.GetParagraphStyleName());
+    }
+
+    if (style.HasListStyleName() && !wxHasStyle(multipleStyleAttributes, wxTEXT_ATTR_LIST_STYLE_NAME))
+    {
+        if (currentStyle.HasListStyleName())
+        {
+            if (currentStyle.HasListStyleName() != style.HasListStyleName())
+            {
+                // Clash of style - mark as such
+                multipleStyleAttributes |= wxTEXT_ATTR_LIST_STYLE_NAME;
+                currentStyle.SetFlags(currentStyle.GetFlags() & ~wxTEXT_ATTR_LIST_STYLE_NAME);
+            }
+        }
+        else
+            currentStyle.SetListStyleName(style.GetListStyleName());
+    }
+
+    if (style.HasBulletStyle() && !wxHasStyle(multipleStyleAttributes, wxTEXT_ATTR_BULLET_STYLE))
+    {
+        if (currentStyle.HasBulletStyle())
+        {
+            if (currentStyle.HasBulletStyle() != style.HasBulletStyle())
+            {
+                // Clash of style - mark as such
+                multipleStyleAttributes |= wxTEXT_ATTR_BULLET_STYLE;
+                currentStyle.SetFlags(currentStyle.GetFlags() & ~wxTEXT_ATTR_BULLET_STYLE);
+            }
+        }
+        else
+            currentStyle.SetBulletStyle(style.GetBulletStyle());
+    }
+
+    if (style.HasBulletNumber() && !wxHasStyle(multipleStyleAttributes, wxTEXT_ATTR_BULLET_NUMBER))
+    {
+        if (currentStyle.HasBulletNumber())
+        {
+            if (currentStyle.HasBulletNumber() != style.HasBulletNumber())
+            {
+                // Clash of style - mark as such
+                multipleStyleAttributes |= wxTEXT_ATTR_BULLET_NUMBER;
+                currentStyle.SetFlags(currentStyle.GetFlags() & ~wxTEXT_ATTR_BULLET_NUMBER);
+            }
+        }
+        else
+            currentStyle.SetBulletNumber(style.GetBulletNumber());
+    }
+
+    if (style.HasBulletSymbol() && !wxHasStyle(multipleStyleAttributes, wxTEXT_ATTR_BULLET_SYMBOL))
+    {
+        if (currentStyle.HasBulletSymbol())
+        {
+            if (currentStyle.HasBulletSymbol() != style.HasBulletSymbol())
+            {
+                // Clash of style - mark as such
+                multipleStyleAttributes |= wxTEXT_ATTR_BULLET_SYMBOL;
+                currentStyle.SetFlags(currentStyle.GetFlags() & ~wxTEXT_ATTR_BULLET_SYMBOL);
+            }
+        }
+        else
+        {
+            currentStyle.SetBulletSymbol(style.GetBulletSymbol());
+            currentStyle.SetBulletFont(style.GetBulletFont());
+        }
+    }
+
+    return true;
+}
+
+/// Get the combined style for a range - if any attribute is different within the range,
+/// that attribute is not present within the flags.
+/// *** Note that this is not recursive, and so assumes that content inside a paragraph is not itself
+/// nested.
+bool wxRichTextParagraphLayoutBox::GetStyleForRange(const wxRichTextRange& range, wxTextAttrEx& style)
+{
+    style = wxTextAttrEx();
+
+    // The attributes that aren't valid because of multiple styles within the range
+    long multipleStyleAttributes = 0;
+
+    wxRichTextObjectList::compatibility_iterator node = GetChildren().GetFirst();
+    while (node)
+    {
+        wxRichTextParagraph* para = (wxRichTextParagraph*) node->GetData();
+        if (!(para->GetRange().GetStart() > range.GetEnd() || para->GetRange().GetEnd() < range.GetStart()))
+        {
+            if (para->GetChildren().GetCount() == 0)
+            {
+                wxTextAttrEx paraStyle = para->GetCombinedAttributes();
+
+                CollectStyle(style, paraStyle, multipleStyleAttributes);
+            }
+            else
+            {
+                wxRichTextRange paraRange(para->GetRange());
+                paraRange.LimitTo(range);
+
+                // First collect paragraph attributes only
+                wxTextAttrEx paraStyle = para->GetCombinedAttributes();
+                paraStyle.SetFlags(paraStyle.GetFlags() & wxTEXT_ATTR_PARAGRAPH);
+                CollectStyle(style, paraStyle, multipleStyleAttributes);
+
+                wxRichTextObjectList::compatibility_iterator childNode = para->GetChildren().GetFirst();
+
+                while (childNode)
+                {
+                    wxRichTextObject* child = childNode->GetData();
+                    if (!(child->GetRange().GetStart() > range.GetEnd() || child->GetRange().GetEnd() < range.GetStart()))
+                    {
+                        wxTextAttrEx childStyle = para->GetCombinedAttributes(child->GetAttributes());
+
+                        // Now collect character attributes only
+                        childStyle.SetFlags(childStyle.GetFlags() & wxTEXT_ATTR_CHARACTER);
+
+                        CollectStyle(style, childStyle, multipleStyleAttributes);
+                    }
+
+                    childNode = childNode->GetNext();
+                }
+            }
+        }
+        node = node->GetNext();
+    }
+    return true;
+}
+
 /// Set default style
 bool wxRichTextParagraphLayoutBox::SetDefaultStyle(const wxTextAttrEx& style)
 {
@@ -1974,22 +2423,410 @@ bool wxRichTextParagraphLayoutBox::ApplyStyleSheet(wxRichTextStyleSheet* styleSh
         wxRichTextParagraph* para = wxDynamicCast(node->GetData(), wxRichTextParagraph);
         wxASSERT (para != NULL);
 
-        if (para)
-        {
-            if (!para->GetAttributes().GetParagraphStyleName().IsEmpty())
-            {
-                wxRichTextParagraphStyleDefinition* def = styleSheet->FindParagraphStyle(para->GetAttributes().GetParagraphStyleName());
-                if (def)
-                {
-                    para->GetAttributes() = def->GetStyle();
-                    foundCount ++;
+        if (para)
+        {
+            // Combine paragraph and list styles. If there is a list style in the original attributes,
+            // the current indentation overrides anything else and is used to find the item indentation.
+            // Also, for applying paragraph styles, consider having 2 modes: (1) we merge with what we have,
+            // thereby taking into account all user changes, (2) reset the style completely (except for indentation/list
+            // exception as above).
+            // Problem: when changing from one list style to another, there's a danger that the level info will get lost.
+            // So when changing a list style interactively, could retrieve level based on current style, then
+            // set appropriate indent and apply new style.
+            
+            if (!para->GetAttributes().GetParagraphStyleName().IsEmpty() && !para->GetAttributes().GetListStyleName().IsEmpty())
+            {
+                int currentIndent = para->GetAttributes().GetLeftIndent();
+
+                wxRichTextParagraphStyleDefinition* paraDef = styleSheet->FindParagraphStyle(para->GetAttributes().GetParagraphStyleName());
+                wxRichTextListStyleDefinition* listDef = styleSheet->FindListStyle(para->GetAttributes().GetListStyleName());
+                if (paraDef && !listDef)
+                {
+                    para->GetAttributes() = paraDef->GetStyle();
+                    foundCount ++;
+                }
+                else if (listDef && !paraDef)
+                {
+                    // Set overall style defined for the list style definition
+                    para->GetAttributes() = listDef->GetStyle();
+
+                    // Apply the style for this level
+                    wxRichTextApplyStyle(para->GetAttributes(), * listDef->GetLevelAttributes(listDef->FindLevelForIndent(currentIndent)));
+                    foundCount ++;
+                }
+                else if (listDef && paraDef)
+                {
+                    // Combines overall list style, style for level, and paragraph style
+                    para->GetAttributes() = listDef->CombineWithParagraphStyle(currentIndent, paraDef->GetStyle());
+                    foundCount ++;
+                }
+            }
+            else if (para->GetAttributes().GetParagraphStyleName().IsEmpty() && !para->GetAttributes().GetListStyleName().IsEmpty())
+            {
+                int currentIndent = para->GetAttributes().GetLeftIndent();
+
+                wxRichTextListStyleDefinition* listDef = styleSheet->FindListStyle(para->GetAttributes().GetListStyleName());
+
+                // Overall list definition style                
+                para->GetAttributes() = listDef->GetStyle();
+                
+                // Style for this level
+                wxRichTextApplyStyle(para->GetAttributes(), * listDef->GetLevelAttributes(listDef->FindLevelForIndent(currentIndent)));
+
+                foundCount ++;
+            }
+            else if (!para->GetAttributes().GetParagraphStyleName().IsEmpty() && para->GetAttributes().GetListStyleName().IsEmpty())
+            {
+                wxRichTextParagraphStyleDefinition* def = styleSheet->FindParagraphStyle(para->GetAttributes().GetParagraphStyleName());
+                if (def)
+                {
+                    para->GetAttributes() = def->GetStyle();
+                    foundCount ++;
+                }
+            }
+        }
+
+        node = node->GetNext();
+    }
+    return foundCount != 0;
+}
+
+/// Set list style
+bool wxRichTextParagraphLayoutBox::SetListStyle(const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags, int startFrom, int specifiedLevel)
+{
+    bool withUndo = ((flags & wxRICHTEXT_SETSTYLE_WITH_UNDO) != 0);
+    // bool applyMinimal = ((flags & wxRICHTEXT_SETSTYLE_OPTIMIZE) != 0);
+    bool specifyLevel = ((flags & wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL) != 0);
+    bool renumber = ((flags & wxRICHTEXT_SETSTYLE_RENUMBER) != 0);
+    
+    // Current number, if numbering
+    int n = startFrom;
+    
+    wxASSERT (!specifyLevel || (specifyLevel && (specifiedLevel >= 0)));
+
+    // If we are associated with a control, make undoable; otherwise, apply immediately
+    // to the data.
+
+    bool haveControl = (GetRichTextCtrl() != NULL);
+
+    wxRichTextAction* action = NULL;
+
+    if (haveControl && withUndo)
+    {
+        action = new wxRichTextAction(NULL, _("Change List Style"), wxRICHTEXT_CHANGE_STYLE, & GetRichTextCtrl()->GetBuffer(), GetRichTextCtrl());
+        action->SetRange(range);
+        action->SetPosition(GetRichTextCtrl()->GetCaretPosition());
+    }
+
+    wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+    while (node)
+    {
+        wxRichTextParagraph* para = wxDynamicCast(node->GetData(), wxRichTextParagraph);
+        wxASSERT (para != NULL);
+
+        if (para && para->GetChildCount() > 0)
+        {
+            // Stop searching if we're beyond the range of interest
+            if (para->GetRange().GetStart() > range.GetEnd())
+                break;
+
+            if (!para->GetRange().IsOutside(range))
+            {
+                // We'll be using a copy of the paragraph to make style changes,
+                // not updating the buffer directly.
+                wxRichTextParagraph* newPara wxDUMMY_INITIALIZE(NULL);
+
+                if (haveControl && withUndo)
+                {
+                    newPara = new wxRichTextParagraph(*para);
+                    action->GetNewParagraphs().AppendChild(newPara);
+
+                    // Also store the old ones for Undo
+                    action->GetOldParagraphs().AppendChild(new wxRichTextParagraph(*para));
+                }
+                else
+                    newPara = para;
+                
+                if (def)
+                {
+                    int thisIndent = newPara->GetAttributes().GetLeftIndent();
+                    int thisLevel = specifyLevel ? specifiedLevel : def->FindLevelForIndent(thisIndent);
+                
+                    // How is numbering going to work?
+                    // If we are renumbering, or numbering for the first time, we need to keep
+                    // track of the number for each level. But we might be simply applying a different
+                    // list style.
+                    // In Word, applying a style to several paragraphs, even if at different levels,
+                    // reverts the level back to the same one. So we could do the same here.
+                    // Renumbering will need to be done when we promote/demote a paragraph.
+
+                    // Apply the overall list style, and item style for this level
+                    wxTextAttrEx listStyle(def->GetCombinedStyleForLevel(thisLevel));
+                    wxRichTextApplyStyle(newPara->GetAttributes(), listStyle);
+                
+                    // Now we need to check numbering
+                    if (renumber)
+                    {
+                        newPara->GetAttributes().SetBulletNumber(n);
+                    }
+                
+                    n ++;
+                }
+                else if (!newPara->GetAttributes().GetListStyleName().IsEmpty())
+                {
+                    // if def is NULL, remove list style, applying any associated paragraph style
+                    // to restore the attributes
+
+                    newPara->GetAttributes().SetListStyleName(wxEmptyString);
+                    newPara->GetAttributes().SetLeftIndent(0, 0);
+                    
+                    // Eliminate the main list-related attributes
+                    newPara->GetAttributes().SetFlags(newPara->GetAttributes().GetFlags() & ~wxTEXT_ATTR_LEFT_INDENT & ~wxTEXT_ATTR_BULLET_STYLE & ~wxTEXT_ATTR_BULLET_NUMBER & ~wxTEXT_ATTR_BULLET_SYMBOL & wxTEXT_ATTR_LIST_STYLE_NAME);
+                    
+                    wxRichTextStyleSheet* styleSheet = GetStyleSheet();
+                    if (styleSheet && !newPara->GetAttributes().GetParagraphStyleName().IsEmpty())
+                    {
+                        wxRichTextParagraphStyleDefinition* def = styleSheet->FindParagraphStyle(newPara->GetAttributes().GetParagraphStyleName());
+                        if (def)
+                        {
+                            newPara->GetAttributes() = def->GetStyle();
+                        }
+                    }
+                }
+            }
+        }
+
+        node = node->GetNext();
+    }
+
+    // Do action, or delay it until end of batch.
+    if (haveControl && withUndo)
+        GetRichTextCtrl()->GetBuffer().SubmitAction(action);
+
+    return true;
+}
+
+bool wxRichTextParagraphLayoutBox::SetListStyle(const wxRichTextRange& range, const wxString& defName, int flags, int startFrom, int specifiedLevel)
+{
+    if (GetStyleSheet())
+    {
+        wxRichTextListStyleDefinition* def = GetStyleSheet()->FindListStyle(defName);
+        if (def)
+            return SetListStyle(range, def, flags, startFrom, specifiedLevel);
+    }
+    return false;
+}
+
+/// Clear list for given range
+bool wxRichTextParagraphLayoutBox::ClearListStyle(const wxRichTextRange& range, int flags)
+{
+    return SetListStyle(range, NULL, flags);
+}
+
+/// Number/renumber any list elements in the given range
+bool wxRichTextParagraphLayoutBox::NumberList(const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags, int startFrom, int specifiedLevel)
+{
+    return DoNumberList(range, range, 0, def, flags, startFrom, specifiedLevel);
+}
+
+/// Number/renumber any list elements in the given range. Also do promotion or demotion of items, if specified
+bool wxRichTextParagraphLayoutBox::DoNumberList(const wxRichTextRange& range, const wxRichTextRange& promotionRange, int promoteBy,
+                                                wxRichTextListStyleDefinition* def, int flags, int startFrom, int specifiedLevel)
+{
+    bool withUndo = ((flags & wxRICHTEXT_SETSTYLE_WITH_UNDO) != 0);
+    // bool applyMinimal = ((flags & wxRICHTEXT_SETSTYLE_OPTIMIZE) != 0);
+    bool specifyLevel = ((flags & wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL) != 0);
+
+    bool renumber = ((flags & wxRICHTEXT_SETSTYLE_RENUMBER) != 0);
+    
+    // Max number of levels
+    const int maxLevels = 10;
+    
+    // The level we're looking at now
+    int currentLevel = -1;
+    
+    // The item number for each level
+    int levels[maxLevels];
+    int i;
+    
+    // Reset all numbering
+    for (i = 0; i < maxLevels; i++)
+    {
+        if (startFrom != -1)
+            levels[i] = startFrom;
+        else if (renumber) // start again
+            levels[i] = 1;
+        else
+            levels[i] = -1; // start from the number we found, if any
+    }
+    
+    wxASSERT(!specifyLevel || (specifyLevel && (specifiedLevel >= 0)));
+
+    // If we are associated with a control, make undoable; otherwise, apply immediately
+    // to the data.
+
+    bool haveControl = (GetRichTextCtrl() != NULL);
+
+    wxRichTextAction* action = NULL;
+
+    if (haveControl && withUndo)
+    {
+        action = new wxRichTextAction(NULL, _("Renumber List"), wxRICHTEXT_CHANGE_STYLE, & GetRichTextCtrl()->GetBuffer(), GetRichTextCtrl());
+        action->SetRange(range);
+        action->SetPosition(GetRichTextCtrl()->GetCaretPosition());
+    }
+
+    wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+    while (node)
+    {
+        wxRichTextParagraph* para = wxDynamicCast(node->GetData(), wxRichTextParagraph);
+        wxASSERT (para != NULL);
+
+        if (para && para->GetChildCount() > 0)
+        {
+            // Stop searching if we're beyond the range of interest
+            if (para->GetRange().GetStart() > range.GetEnd())
+                break;
+
+            if (!para->GetRange().IsOutside(range))
+            {
+                // We'll be using a copy of the paragraph to make style changes,
+                // not updating the buffer directly.
+                wxRichTextParagraph* newPara wxDUMMY_INITIALIZE(NULL);
+
+                if (haveControl && withUndo)
+                {
+                    newPara = new wxRichTextParagraph(*para);
+                    action->GetNewParagraphs().AppendChild(newPara);
+
+                    // Also store the old ones for Undo
+                    action->GetOldParagraphs().AppendChild(new wxRichTextParagraph(*para));
+                }
+                else
+                    newPara = para;
+                
+                wxRichTextListStyleDefinition* defToUse = def;
+                if (!defToUse)
+                {
+                    wxRichTextStyleSheet* sheet = GetStyleSheet();
+                    
+                    if (sheet && !newPara->GetAttributes().GetListStyleName().IsEmpty())
+                        defToUse = sheet->FindListStyle(newPara->GetAttributes().GetListStyleName());
+                }
+                
+                if (defToUse)
+                {
+                    int thisIndent = newPara->GetAttributes().GetLeftIndent();
+                    int thisLevel = defToUse->FindLevelForIndent(thisIndent);
+
+                    // If the paragraph doesn't have an indent, or we've specified a level to apply to all,
+                    // change the level.
+                    if (thisIndent == 0 || specifiedLevel != -1)
+                        thisLevel = specifiedLevel;
+                        
+                    // Do promotion if specified
+                    if ((promoteBy != 0) && !para->GetRange().IsOutside(promotionRange))
+                    {
+                        thisLevel = thisLevel - promoteBy;
+                        if (thisLevel < 0)
+                            thisLevel = 0;
+                        if (thisLevel > 9)
+                            thisLevel = 9;
+                    }
+                    
+                    // Apply the overall list style, and item style for this level
+                    wxTextAttrEx listStyle(defToUse->GetCombinedStyleForLevel(thisLevel));
+                    wxRichTextApplyStyle(newPara->GetAttributes(), listStyle);
+                    
+                    // OK, we've (re)applied the style, now let's get the numbering right.
+                    
+                    if (currentLevel == -1)
+                        currentLevel = thisLevel;
+                    
+                    // Same level as before, do nothing except increment level's number afterwards
+                    if (currentLevel == thisLevel)
+                    {
+                    }
+                    // A deeper level: start renumbering all levels after current level
+                    else if (thisLevel > currentLevel)
+                    {
+                        for (i = currentLevel+1; i <= thisLevel; i++)
+                        {
+                            levels[i] = 1;
+                        }
+                        currentLevel = thisLevel;
+                    }
+                    else if (thisLevel < currentLevel)
+                    {
+                        currentLevel = thisLevel;
+                    }                    
+
+                    // Use the current numbering if -1 and we have a bullet number already
+                    if (levels[currentLevel] == -1)
+                    {
+                        if (newPara->GetAttributes().HasBulletNumber())
+                            levels[currentLevel] = newPara->GetAttributes().GetBulletNumber();
+                        else
+                            levels[currentLevel] = 1;
+                    }
+                    
+                    newPara->GetAttributes().SetBulletNumber(levels[currentLevel]);
+
+                    levels[currentLevel] ++;                        
                 }
             }
         }
 
         node = node->GetNext();
     }
-    return foundCount != 0;
+
+    // Do action, or delay it until end of batch.
+    if (haveControl && withUndo)
+        GetRichTextCtrl()->GetBuffer().SubmitAction(action);
+
+    return true;
+}
+
+bool wxRichTextParagraphLayoutBox::NumberList(const wxRichTextRange& range, const wxString& defName, int flags, int startFrom, int specifiedLevel)
+{
+    if (GetStyleSheet())
+    {
+        wxRichTextListStyleDefinition* def = NULL;
+        if (!defName.IsEmpty())
+            def = GetStyleSheet()->FindListStyle(defName);
+        return NumberList(range, def, flags, startFrom, specifiedLevel);
+    }
+    return false;
+}
+
+/// Promote the list items within the given range. promoteBy can be a positive or negative number, e.g. 1 or -1
+bool wxRichTextParagraphLayoutBox::PromoteList(int promoteBy, const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags, int specifiedLevel)
+{
+    // TODO
+    // One strategy is to first work out the range within which renumbering must occur. Then could pass these two ranges
+    // to NumberList with a flag indicating promotion is required within one of the ranges.
+    // Find first and last paragraphs in range. Then for first, calculate new indentation and look back until we find
+    // a paragraph that either has no list style, or has one that is different or whose indentation is less.
+    // We start renumbering from the para after that different para we found. We specify that the numbering of that
+    // list position will start from 1.
+    // Similarly, we look after the last para in the promote range for an indentation that is less (or no list style).
+    // We can end the renumbering at this point.
+    
+    // For now, only renumber within the promotion range.
+    
+    return DoNumberList(range, range, promoteBy, def, flags, 1, specifiedLevel);
+}
+
+bool wxRichTextParagraphLayoutBox::PromoteList(int promoteBy, const wxRichTextRange& range, const wxString& defName, int flags, int specifiedLevel)
+{
+    if (GetStyleSheet())
+    {
+        wxRichTextListStyleDefinition* def = NULL;
+        if (!defName.IsEmpty())
+            def = GetStyleSheet()->FindListStyle(defName);
+        return PromoteList(promoteBy, range, def, flags, specifiedLevel);
+    }
+    return false;
 }
 
 /*!
@@ -1999,6 +2836,8 @@ bool wxRichTextParagraphLayoutBox::ApplyStyleSheet(wxRichTextStyleSheet* styleSh
 
 IMPLEMENT_DYNAMIC_CLASS(wxRichTextParagraph, wxRichTextBox)
 
+wxArrayInt wxRichTextParagraph::sm_defaultTabs;
+
 wxRichTextParagraph::wxRichTextParagraph(wxRichTextObject* parent, wxTextAttrEx* style):
     wxRichTextBox(parent)
 {
@@ -2039,10 +2878,7 @@ bool wxRichTextParagraph::Draw(wxDC& dc, const wxRichTextRange& WXUNUSED(range),
         if (attr.GetLeftSubIndent() != 0)
         {
             int spaceBeforePara = ConvertTenthsMMToPixels(dc, attr.GetParagraphSpacingBefore());
-            // int spaceAfterPara = ConvertTenthsMMToPixels(dc, attr.GetParagraphSpacingAfter());
             int leftIndent = ConvertTenthsMMToPixels(dc, attr.GetLeftIndent());
-            // int leftSubIndent = ConvertTenthsMMToPixels(dc, attr.GetLeftSubIndent());
-            // int rightIndent = ConvertTenthsMMToPixels(dc, attr.GetRightIndent());
 
             if (attr.GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_BITMAP)
             {
@@ -2053,11 +2889,26 @@ bool wxRichTextParagraph::Draw(wxDC& dc, const wxRichTextRange& WXUNUSED(range),
                 wxString bulletText = GetBulletText();
                 if (!bulletText.empty())
                 {
-                    if (attr.GetFont().Ok())
-                        dc.SetFont(attr.GetFont());
+                    // Get the combined font, or if a font is specified for a symbol bullet,
+                    // create the font
+
+                    wxTextAttrEx bulletAttr(GetCombinedAttributes());
+                    wxFont font;
+                    if ((attr.GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_SYMBOL) && !attr.GetBulletFont().IsEmpty() && bulletAttr.GetFont().Ok())
+                    {
+                        font = (*wxTheFontList->FindOrCreateFont(bulletAttr.GetFont().GetPointSize(), bulletAttr.GetFont().GetFamily(),
+                                                bulletAttr.GetFont().GetStyle(), bulletAttr.GetFont().GetWeight(), bulletAttr.GetFont().GetUnderlined(),
+                                                attr.GetBulletFont()));
+                    }
+                    else if (bulletAttr.GetFont().Ok())
+                        font = bulletAttr.GetFont();
+                    else
+                        font = (*wxNORMAL_FONT);
+
+                    dc.SetFont(font);
 
-                    if (attr.GetTextColour().Ok())
-                        dc.SetTextForeground(attr.GetTextColour());
+                    if (bulletAttr.GetTextColour().Ok())
+                        dc.SetTextForeground(bulletAttr.GetTextColour());
 
                     dc.SetBackgroundMode(wxTRANSPARENT);
 
@@ -2183,9 +3034,6 @@ bool wxRichTextParagraph::Layout(wxDC& dc, const wxRect& rect, int style)
     if (attr.GetBulletStyle() != wxTEXT_ATTR_BULLET_STYLE_NONE)
         startPositionFirstLine = startPositionSubsequentLines;
 
-    //bool restrictWidth = wxRichTextHasStyle(style, wxRICHTEXT_FIXED_WIDTH);
-    //bool restrictHeight = wxRichTextHasStyle(style, wxRICHTEXT_FIXED_HEIGHT);
-
     long lastEndPos = GetRange().GetStart()-1;
     long lastCompletedEndPos = lastEndPos;
 
@@ -2947,31 +3795,12 @@ wxString wxRichTextParagraph::GetBulletText()
     }
     else if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_ROMAN_UPPER)
     {
-        // TODO: convert from number to roman numeral
-        if (number == 1)
-            text = wxT("I");
-        else if (number == 2)
-            text = wxT("II");
-        else if (number == 3)
-            text = wxT("III");
-        else if (number == 4)
-            text = wxT("IV");
-        else
-            text = wxT("TODO");
+        text = wxRichTextDecimalToRoman(number);
     }
     else if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_ROMAN_LOWER)
     {
-        // TODO: convert from number to roman numeral
-        if (number == 1)
-            text = wxT("i");
-        else if (number == 2)
-            text = wxT("ii");
-        else if (number == 3)
-            text = wxT("iii");
-        else if (number == 4)
-            text = wxT("iv");
-        else
-            text = wxT("TODO");
+        text = wxRichTextDecimalToRoman(number);
+        text.MakeLower();
     }
     else if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_SYMBOL)
     {
@@ -3026,7 +3855,7 @@ bool wxRichTextParagraph::ClearUnusedLines(int lineCount)
 
 /// Get combined attributes of the base style, paragraph style and character style. We use this to dynamically
 /// retrieve the actual style.
-wxTextAttrEx wxRichTextParagraph::GetCombinedAttributes(const wxTextAttr& contentStyle) const
+wxTextAttrEx wxRichTextParagraph::GetCombinedAttributes(const wxTextAttrEx& contentStyle) const
 {
     wxTextAttrEx attr;
     wxRichTextBuffer* buf = wxDynamicCast(GetParent(), wxRichTextBuffer);
@@ -3058,6 +3887,23 @@ wxTextAttrEx wxRichTextParagraph::GetCombinedAttributes() const
     return attr;
 }
 
+/// Create default tabstop array
+void wxRichTextParagraph::InitDefaultTabs()
+{
+    // create a default tab list at 10 mm each.
+    for (int i = 0; i < 20; ++i)
+    {
+        sm_defaultTabs.Add(i*100);
+    }
+}
+
+/// Clear default tabstop array
+void wxRichTextParagraph::ClearDefaultTabs()
+{
+    sm_defaultTabs.Clear();
+}
+
+
 /*!
  * wxRichTextLine
  * This object represents a line in a paragraph, and stores
@@ -3118,6 +3964,8 @@ wxRichTextPlainText::wxRichTextPlainText(const wxString& text, wxRichTextObject*
     m_text = text;
 }
 
+#define USE_KERNING_FIX 1
+
 /// Draw the item
 bool wxRichTextPlainText::Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextRange& selectionRange, const wxRect& rect, int descent, int WXUNUSED(style))
 {
@@ -3175,6 +4023,23 @@ bool wxRichTextPlainText::Draw(wxDC& dc, const wxRichTextRange& range, const wxR
             wxString stringFragment = m_text.Mid(r1 - offset, fragmentLen);
 
             DrawTabbedString(dc, textAttr, rect, stringFragment, x, y, false);
+
+#if USE_KERNING_FIX
+            if (stringChunk.Find(wxT("\t")) == wxNOT_FOUND)
+            {
+                // Compensate for kerning difference
+                wxString stringFragment2(m_text.Mid(r1 - offset, fragmentLen+1));
+                wxString stringFragment3(m_text.Mid(r1 - offset + fragmentLen, 1));
+                
+                wxCoord w1, h1, w2, h2, w3, h3;
+                dc.GetTextExtent(stringFragment,  & w1, & h1);
+                dc.GetTextExtent(stringFragment2, & w2, & h2);
+                dc.GetTextExtent(stringFragment3, & w3, & h3);
+                
+                int kerningDiff = (w1 + w3) - w2;
+                x = x - kerningDiff;
+            }
+#endif
         }
 
         // 2. Selected chunk, if any.
@@ -3189,6 +4054,23 @@ bool wxRichTextPlainText::Draw(wxDC& dc, const wxRichTextRange& range, const wxR
             wxString stringFragment = m_text.Mid(s1 - offset, fragmentLen);
 
             DrawTabbedString(dc, textAttr, rect, stringFragment, x, y, true);
+
+#if USE_KERNING_FIX
+            if (stringChunk.Find(wxT("\t")) == wxNOT_FOUND)
+            {
+                // Compensate for kerning difference
+                wxString stringFragment2(m_text.Mid(s1 - offset, fragmentLen+1));
+                wxString stringFragment3(m_text.Mid(s1 - offset + fragmentLen, 1));
+                
+                wxCoord w1, h1, w2, h2, w3, h3;
+                dc.GetTextExtent(stringFragment,  & w1, & h1);
+                dc.GetTextExtent(stringFragment2, & w2, & h2);
+                dc.GetTextExtent(stringFragment3, & w3, & h3);
+                
+                int kerningDiff = (w1 + w3) - w2;
+                x = x - kerningDiff;
+            }
+#endif
         }
 
         // 3. Remaining unselected chunk, if any
@@ -3211,29 +4093,33 @@ bool wxRichTextPlainText::Draw(wxDC& dc, const wxRichTextRange& range, const wxR
 
 bool wxRichTextPlainText::DrawTabbedString(wxDC& dc, const wxTextAttrEx& attr, const wxRect& rect,wxString& str, wxCoord& x, wxCoord& y, bool selected)
 {
-    wxArrayInt tab_array =  attr.GetTabs();
-    if (tab_array.IsEmpty())
+    bool hasTabs = (str.Find(wxT('\t')) != wxNOT_FOUND);
+
+    wxArrayInt tabArray;
+    int tabCount;
+    if (hasTabs)
     {
-        // create a default tab list at 10 mm each.
-        for (int i = 0; i < 20; ++i)
+        if (attr.GetTabs().IsEmpty())
+            tabArray = wxRichTextParagraph::GetDefaultTabs();
+        else
+            tabArray = attr.GetTabs();
+        tabCount = tabArray.GetCount();
+
+        for (int i = 0; i < tabCount; ++i)
         {
-            tab_array.Add(i*100);
+            int pos = tabArray[i];
+            pos = ConvertTenthsMMToPixels(dc, pos);
+            tabArray[i] = pos;
         }
     }
-    int map_mode = dc.GetMapMode();
-    dc.SetMapMode(wxMM_LOMETRIC );
-    int num_tabs = tab_array.GetCount();
-    for (int i = 0; i < num_tabs; ++i)
-    {
-       tab_array[i] = dc.LogicalToDeviceXRel(tab_array[i]);
-    }
+    else
+        tabCount = 0;
 
-    dc.SetMapMode(map_mode );
-    int next_tab_pos = -1;
-    int tab_pos = -1;
+    int nextTabPos = -1;
+    int tabPos = -1;
     wxCoord w, h;
 
-    if(selected)
+    if (selected)
     {
         dc.SetBrush(*wxBLACK_BRUSH);
         dc.SetPen(*wxBLACK_PEN);
@@ -3246,41 +4132,45 @@ bool wxRichTextPlainText::DrawTabbedString(wxDC& dc, const wxTextAttrEx& attr, c
         dc.SetBackgroundMode(wxTRANSPARENT);
     }
 
-    while (str.Find(wxT('\t')) >= 0)
+    while (hasTabs)
     {
         // the string has a tab
         // break up the string at the Tab
         wxString stringChunk = str.BeforeFirst(wxT('\t'));
         str = str.AfterFirst(wxT('\t'));
         dc.GetTextExtent(stringChunk, & w, & h);
-        tab_pos = x + w;
+        tabPos = x + w;
         bool not_found = true;
-        for (int i = 0; i < num_tabs && not_found; ++i)
+        for (int i = 0; i < tabCount && not_found; ++i)
         {
-            next_tab_pos = tab_array.Item(i);
-            if (next_tab_pos > tab_pos)
+            nextTabPos = tabArray.Item(i);
+            if (nextTabPos > tabPos)
             {
                 not_found = false;
                 if (selected)
                 {
-                    w = next_tab_pos - x;
+                    w = nextTabPos - x;
                     wxRect selRect(x, rect.y, w, rect.GetHeight());
                     dc.DrawRectangle(selRect);
                 }
                 dc.DrawText(stringChunk, x, y);
-                x = next_tab_pos;
+                x = nextTabPos;
             }
         }
+        hasTabs = (str.Find(wxT('\t')) != wxNOT_FOUND);
     }
 
-    dc.GetTextExtent(str, & w, & h);
-    if (selected)
+    if (!str.IsEmpty())
     {
-        wxRect selRect(x, rect.y, w, rect.GetHeight());
-        dc.DrawRectangle(selRect);
+        dc.GetTextExtent(str, & w, & h);
+        if (selected)
+        {
+            wxRect selRect(x, rect.y, w, rect.GetHeight());
+            dc.DrawRectangle(selRect);
+        }
+        dc.DrawText(str, x, y);
+        x += w;
     }
-    dc.DrawText(str, x, y);
-    x += w;
     return true;
 
 }
@@ -3343,29 +4233,25 @@ bool wxRichTextPlainText::GetRangeSize(const wxRichTextRange& range, wxSize& siz
     wxString stringChunk = m_text.Mid(startPos, (size_t) len);
     wxCoord w, h;
     int width = 0;
-    if (stringChunk.Find(wxT('\t')) >= 0)
+    if (stringChunk.Find(wxT('\t')) != wxNOT_FOUND)
     {
         // the string has a tab
-        wxArrayInt tab_array =  textAttr.GetTabs();
-        if (tab_array.IsEmpty())
-        {
-            // create a default tab list at 10 mm each.
-            for (int i = 0; i < 20; ++i)
-            {
-                tab_array.Add(i*100);
-            }
-        }
-
-        int map_mode = dc.GetMapMode();
-        dc.SetMapMode(wxMM_LOMETRIC );
-        int num_tabs = tab_array.GetCount();
+        wxArrayInt tabArray;
+        if (textAttr.GetTabs().IsEmpty())
+            tabArray = wxRichTextParagraph::GetDefaultTabs();
+        else
+            tabArray = textAttr.GetTabs();
 
-        for (int i = 0; i < num_tabs; ++i)
+        int tabCount = tabArray.GetCount();
+        
+        for (int i = 0; i < tabCount; ++i)
         {
-            tab_array[i] = dc.LogicalToDeviceXRel(tab_array[i]);
+            int pos = tabArray[i];
+            pos = ((wxRichTextPlainText*) this)->ConvertTenthsMMToPixels(dc, pos);
+            tabArray[i] = pos;
         }
-        dc.SetMapMode(map_mode );
-        int next_tab_pos = -1;
+        
+        int nextTabPos = -1;
 
         while (stringChunk.Find(wxT('\t')) >= 0)
         {
@@ -3375,15 +4261,15 @@ bool wxRichTextPlainText::GetRangeSize(const wxRichTextRange& range, wxSize& siz
             stringChunk = stringChunk.AfterFirst(wxT('\t'));
             dc.GetTextExtent(stringFragment, & w, & h);
             width += w;
-            int absolute_width = width + position.x;
-            bool not_found = true;
-            for (int i = 0; i < num_tabs && not_found; ++i)
+            int absoluteWidth = width + position.x;
+            bool notFound = true;
+            for (int i = 0; i < tabCount && notFound; ++i)
             {
-                next_tab_pos = tab_array.Item(i);
-                if (next_tab_pos > absolute_width)
+                nextTabPos = tabArray.Item(i);
+                if (nextTabPos > absoluteWidth)
                 {
-                    not_found = false;
-                    width = next_tab_pos - position.x;
+                    notFound = false;
+                    width = nextTabPos - position.x;
                 }
             }
         }
@@ -3544,6 +4430,32 @@ void wxRichTextBuffer::Copy(const wxRichTextBuffer& obj)
     m_suppressUndo = obj.m_suppressUndo;
 }
 
+/// Push style sheet to top of stack
+bool wxRichTextBuffer::PushStyleSheet(wxRichTextStyleSheet* styleSheet)
+{
+    if (m_styleSheet)
+        styleSheet->InsertSheet(m_styleSheet);
+
+    SetStyleSheet(styleSheet);
+    
+    return true;
+}
+
+/// Pop style sheet from top of stack
+wxRichTextStyleSheet* wxRichTextBuffer::PopStyleSheet()
+{
+    if (m_styleSheet)
+    {
+        wxRichTextStyleSheet* oldSheet = m_styleSheet;
+        m_styleSheet = oldSheet->GetNextSheet();
+        oldSheet->Unlink();
+        
+        return oldSheet;
+    }
+    else
+        return NULL;
+}
+
 /// Submit command to insert paragraphs
 bool wxRichTextBuffer::InsertParagraphsWithUndo(long pos, const wxRichTextParagraphLayoutBox& paragraphs, wxRichTextCtrl* ctrl, int flags)
 {
@@ -3566,6 +4478,18 @@ bool wxRichTextBuffer::InsertParagraphsWithUndo(long pos, const wxRichTextParagr
 #endif
 
     action->GetNewParagraphs() = paragraphs;
+
+    if (p)
+    {
+        wxRichTextObjectList::compatibility_iterator node = m_children.GetLast();
+        while (node)
+        {
+            wxRichTextParagraph* obj = (wxRichTextParagraph*) node->GetData();
+            obj->SetAttributes(*p);
+            node = node->GetPrevious();
+        }
+    }
+
     action->SetPosition(pos);
 
     // Set the range we'll need to delete in Undo
@@ -4422,13 +5346,35 @@ class wxRichTextModule: public wxModule
 DECLARE_DYNAMIC_CLASS(wxRichTextModule)
 public:
     wxRichTextModule() {}
-    bool OnInit() { wxRichTextBuffer::InitStandardHandlers(); return true; };
-    void OnExit() { wxRichTextBuffer::CleanUpHandlers(); };
+    bool OnInit()
+    {
+        wxRichTextBuffer::InitStandardHandlers();
+        wxRichTextParagraph::InitDefaultTabs();
+        return true;
+    };
+    void OnExit()
+    {
+        wxRichTextBuffer::CleanUpHandlers();
+        wxRichTextDecimalToRoman(-1);
+        wxRichTextParagraph::ClearDefaultTabs();
+        wxRichTextCtrl::ClearAvailableFontNames();
+    };
 };
 
 IMPLEMENT_DYNAMIC_CLASS(wxRichTextModule, wxModule)
 
 
+// If the richtext lib is dynamically loaded after the app has already started
+// (such as from wxPython) then the built-in module system will not init this
+// module.  Provide this function to do it manually.
+void wxRichTextModuleInit()
+{
+    wxModule* module = new wxRichTextModule;
+    module->Init();
+    wxModule::RegisterModule(module);
+}
+
+
 /*!
  * Commands for undo/redo
  *
@@ -4618,7 +5564,7 @@ void wxRichTextAction::UpdateAppearance(long caretPosition, bool sendUpdateEvent
             m_ctrl->Refresh(false);
 
             if (sendUpdateEvent)
-                m_ctrl->SendUpdateEvent();
+                m_ctrl->SendTextUpdatedEvent();
         }
     }
 }
@@ -4774,6 +5720,8 @@ bool wxRichTextImage::GetRangeSize(const wxRichTextRange& range, wxSize& size, i
 /// Copy
 void wxRichTextImage::Copy(const wxRichTextImage& obj)
 {
+    wxRichTextObject::Copy(obj);
+
     m_image = obj.m_image;
     m_imageBlock = obj.m_imageBlock;
 }
@@ -4786,23 +5734,7 @@ void wxRichTextImage::Copy(const wxRichTextImage& obj)
 /// Compare two attribute objects
 bool wxTextAttrEq(const wxTextAttrEx& attr1, const wxTextAttrEx& attr2)
 {
-    return (
-        attr1.GetTextColour() == attr2.GetTextColour() &&
-        attr1.GetBackgroundColour() == attr2.GetBackgroundColour() &&
-        attr1.GetFont() == attr2.GetFont() &&
-        attr1.GetAlignment() == attr2.GetAlignment() &&
-        attr1.GetLeftIndent() == attr2.GetLeftIndent() &&
-        attr1.GetRightIndent() == attr2.GetRightIndent() &&
-        attr1.GetLeftSubIndent() == attr2.GetLeftSubIndent() &&
-        attr1.GetTabs().GetCount() == attr2.GetTabs().GetCount() && // heuristic
-        attr1.GetLineSpacing() == attr2.GetLineSpacing() &&
-        attr1.GetParagraphSpacingAfter() == attr2.GetParagraphSpacingAfter() &&
-        attr1.GetParagraphSpacingBefore() == attr2.GetParagraphSpacingBefore() &&
-        attr1.GetBulletStyle() == attr2.GetBulletStyle() &&
-        attr1.GetBulletNumber() == attr2.GetBulletNumber() &&
-        attr1.GetBulletSymbol() == attr2.GetBulletSymbol() &&
-        attr1.GetCharacterStyleName() == attr2.GetCharacterStyleName() &&
-        attr1.GetParagraphStyleName() == attr2.GetParagraphStyleName());
+    return (attr1 == attr2);
 }
 
 bool wxTextAttrEq(const wxTextAttrEx& attr1, const wxRichTextAttr& attr2)
@@ -4819,15 +5751,17 @@ bool wxTextAttrEq(const wxTextAttrEx& attr1, const wxRichTextAttr& attr2)
         attr1.GetLeftIndent() == attr2.GetLeftIndent() &&
         attr1.GetRightIndent() == attr2.GetRightIndent() &&
         attr1.GetLeftSubIndent() == attr2.GetLeftSubIndent() &&
-        attr1.GetTabs().GetCount() == attr2.GetTabs().GetCount() && // heuristic
+        wxRichTextTabsEq(attr1.GetTabs(), attr2.GetTabs()) &&
         attr1.GetLineSpacing() == attr2.GetLineSpacing() &&
         attr1.GetParagraphSpacingAfter() == attr2.GetParagraphSpacingAfter() &&
         attr1.GetParagraphSpacingBefore() == attr2.GetParagraphSpacingBefore() &&
         attr1.GetBulletStyle() == attr2.GetBulletStyle() &&
         attr1.GetBulletNumber() == attr2.GetBulletNumber() &&
         attr1.GetBulletSymbol() == attr2.GetBulletSymbol() &&
+        attr1.GetBulletFont() == attr2.GetBulletFont() &&
         attr1.GetCharacterStyleName() == attr2.GetCharacterStyleName() &&
-        attr1.GetParagraphStyleName() == attr2.GetParagraphStyleName());
+        attr1.GetParagraphStyleName() == attr2.GetParagraphStyleName() &&
+        attr1.GetListStyleName() == attr2.GetListStyleName());
 }
 
 /// Compare two attribute objects, but take into account the flags
@@ -4891,6 +5825,10 @@ bool wxTextAttrEqPartial(const wxTextAttrEx& attr1, const wxTextAttrEx& attr2, i
         (attr1.GetParagraphStyleName() != attr2.GetParagraphStyleName()))
         return false;
 
+    if ((flags & wxTEXT_ATTR_LIST_STYLE_NAME) &&
+        (attr1.GetListStyleName() != attr2.GetListStyleName()))
+        return false;
+
     if ((flags & wxTEXT_ATTR_BULLET_STYLE) &&
         (attr1.GetBulletStyle() != attr2.GetBulletStyle()))
          return false;
@@ -4903,10 +5841,13 @@ bool wxTextAttrEqPartial(const wxTextAttrEx& attr1, const wxTextAttrEx& attr2, i
         (attr1.GetBulletSymbol() != attr2.GetBulletSymbol()))
          return false;
 
-/* TODO
+    if ((flags & wxTEXT_ATTR_BULLET_SYMBOL) &&
+        (attr1.GetBulletFont() != attr2.GetBulletFont()))
+         return false;
+
     if ((flags & wxTEXT_ATTR_TABS) &&
+        !wxRichTextTabsEq(attr1.GetTabs(), attr2.GetTabs()))
         return false;
-*/
 
     return true;
 }
@@ -4973,6 +5914,10 @@ bool wxTextAttrEqPartial(const wxTextAttrEx& attr1, const wxRichTextAttr& attr2,
         (attr1.GetParagraphStyleName() != attr2.GetParagraphStyleName()))
         return false;
 
+    if ((flags & wxTEXT_ATTR_LIST_STYLE_NAME) &&
+        (attr1.GetListStyleName() != attr2.GetListStyleName()))
+        return false;
+
     if ((flags & wxTEXT_ATTR_BULLET_STYLE) &&
         (attr1.GetBulletStyle() != attr2.GetBulletStyle()))
          return false;
@@ -4985,11 +5930,29 @@ bool wxTextAttrEqPartial(const wxTextAttrEx& attr1, const wxRichTextAttr& attr2,
         (attr1.GetBulletSymbol() != attr2.GetBulletSymbol()))
          return false;
 
-/* TODO
+    if ((flags & wxTEXT_ATTR_BULLET_SYMBOL) &&
+        (attr1.GetBulletFont() != attr2.GetBulletFont()))
+         return false;
+
     if ((flags & wxTEXT_ATTR_TABS) &&
+        !wxRichTextTabsEq(attr1.GetTabs(), attr2.GetTabs()))
+        return false;
+
+    return true;
+}
+
+/// Compare tabs
+bool wxRichTextTabsEq(const wxArrayInt& tabs1, const wxArrayInt& tabs2)
+{
+    if (tabs1.GetCount() != tabs2.GetCount())
         return false;
-*/
 
+    size_t i;
+    for (i = 0; i < tabs1.GetCount(); i++)
+    {
+        if (tabs1[i] != tabs2[i])
+            return false;
+    }
     return true;
 }
 
@@ -5077,10 +6040,14 @@ bool wxRichTextApplyStyle(wxTextAttrEx& destStyle, const wxTextAttrEx& style)
     if (style.HasParagraphStyleName())
         destStyle.SetParagraphStyleName(style.GetParagraphStyleName());
 
+    if (style.HasListStyleName())
+        destStyle.SetListStyleName(style.GetListStyleName());
+
     if (style.HasBulletStyle())
     {
         destStyle.SetBulletStyle(style.GetBulletStyle());
         destStyle.SetBulletSymbol(style.GetBulletSymbol());
+        destStyle.SetBulletFont(style.GetBulletFont());
     }
 
     if (style.HasBulletNumber())
@@ -5098,11 +6065,11 @@ bool wxRichTextApplyStyle(wxRichTextAttr& destStyle, const wxTextAttrEx& style)
     return true;
 }
 
-bool wxRichTextApplyStyle(wxTextAttrEx& destStyle, const wxRichTextAttr& style)
+bool wxRichTextApplyStyle(wxTextAttrEx& destStyle, const wxRichTextAttr& style, wxRichTextAttr* compareWith)
 {
     // Whole font. Avoiding setting individual attributes if possible, since
     // it recreates the font each time.
-    if ((style.GetFlags() & (wxTEXT_ATTR_FONT)) == (wxTEXT_ATTR_FONT))
+    if (((style.GetFlags() & (wxTEXT_ATTR_FONT)) == (wxTEXT_ATTR_FONT)) && !compareWith)
     {
         destStyle.SetFont(wxFont(style.GetFontSize(), destStyle.GetFont().Ok() ? destStyle.GetFont().GetFamily() : wxDEFAULT,
             style.GetFontStyle(), style.GetFontWeight(), style.GetFontUnderlined(), style.GetFontFaceName()));
@@ -5113,32 +6080,67 @@ bool wxRichTextApplyStyle(wxTextAttrEx& destStyle, const wxRichTextAttr& style)
 
         if (style.GetFlags() & wxTEXT_ATTR_FONT_FACE)
         {
-            destStyle.SetFlags(destStyle.GetFlags() | wxTEXT_ATTR_FONT_FACE);
-            font.SetFaceName(style.GetFontFaceName());
+            if (compareWith && compareWith->HasFaceName() && compareWith->GetFontFaceName() == style.GetFontFaceName())
+            {
+                // The same as currently displayed, so don't set
+            }
+            else
+            {
+                destStyle.SetFlags(destStyle.GetFlags() | wxTEXT_ATTR_FONT_FACE);
+                font.SetFaceName(style.GetFontFaceName());
+            }
         }
 
         if (style.GetFlags() & wxTEXT_ATTR_FONT_SIZE)
         {
-            destStyle.SetFlags(destStyle.GetFlags() | wxTEXT_ATTR_FONT_SIZE);
-            font.SetPointSize(style.GetFontSize());
+            if (compareWith && compareWith->HasSize() && compareWith->GetFontSize() == style.GetFontSize())
+            {
+                // The same as currently displayed, so don't set
+            }
+            else
+            {
+                destStyle.SetFlags(destStyle.GetFlags() | wxTEXT_ATTR_FONT_SIZE);
+                font.SetPointSize(style.GetFontSize());
+            }
         }
 
         if (style.GetFlags() & wxTEXT_ATTR_FONT_ITALIC)
         {
-            destStyle.SetFlags(destStyle.GetFlags() | wxTEXT_ATTR_FONT_ITALIC);
-            font.SetStyle(style.GetFontStyle());
+            if (compareWith && compareWith->HasItalic() && compareWith->GetFontStyle() == style.GetFontStyle())
+            {
+                // The same as currently displayed, so don't set
+            }
+            else
+            {
+                destStyle.SetFlags(destStyle.GetFlags() | wxTEXT_ATTR_FONT_ITALIC);
+                font.SetStyle(style.GetFontStyle());
+            }
         }
 
         if (style.GetFlags() & wxTEXT_ATTR_FONT_WEIGHT)
         {
-            destStyle.SetFlags(destStyle.GetFlags() | wxTEXT_ATTR_FONT_WEIGHT);
-            font.SetWeight(style.GetFontWeight());
+            if (compareWith && compareWith->HasWeight() && compareWith->GetFontWeight() == style.GetFontWeight())
+            {
+                // The same as currently displayed, so don't set
+            }
+            else
+            {
+                destStyle.SetFlags(destStyle.GetFlags() | wxTEXT_ATTR_FONT_WEIGHT);
+                font.SetWeight(style.GetFontWeight());
+            }
         }
 
         if (style.GetFlags() & wxTEXT_ATTR_FONT_UNDERLINE)
         {
-            destStyle.SetFlags(destStyle.GetFlags() | wxTEXT_ATTR_FONT_UNDERLINE);
-            font.SetUnderlined(style.GetFontUnderlined());
+            if (compareWith && compareWith->HasUnderlined() && compareWith->GetFontUnderlined() == style.GetFontUnderlined())
+            {
+                // The same as currently displayed, so don't set
+            }
+            else
+            {
+                destStyle.SetFlags(destStyle.GetFlags() | wxTEXT_ATTR_FONT_UNDERLINE);
+                font.SetUnderlined(style.GetFontUnderlined());
+            }
         }
 
         if (font != destStyle.GetFont())
@@ -5151,51 +6153,163 @@ bool wxRichTextApplyStyle(wxTextAttrEx& destStyle, const wxRichTextAttr& style)
         }
     }
 
-    if ( style.GetTextColour().Ok() && style.HasTextColour())
-        destStyle.SetTextColour(style.GetTextColour());
+    if (style.GetTextColour().Ok() && style.HasTextColour())
+    {
+        if (!(compareWith && compareWith->HasTextColour() && compareWith->GetTextColour() == style.GetTextColour()))
+            destStyle.SetTextColour(style.GetTextColour());
+    }
 
-    if ( style.GetBackgroundColour().Ok() && style.HasBackgroundColour())
-        destStyle.SetBackgroundColour(style.GetBackgroundColour());
+    if (style.GetBackgroundColour().Ok() && style.HasBackgroundColour())
+    {
+        if (!(compareWith && compareWith->HasBackgroundColour() && compareWith->GetBackgroundColour() == style.GetBackgroundColour()))
+            destStyle.SetBackgroundColour(style.GetBackgroundColour());
+    }
 
     if (style.HasAlignment())
-        destStyle.SetAlignment(style.GetAlignment());
+    {
+        if (!(compareWith && compareWith->HasAlignment() && compareWith->GetAlignment() == style.GetAlignment()))
+            destStyle.SetAlignment(style.GetAlignment());
+    }
 
     if (style.HasTabs())
-        destStyle.SetTabs(style.GetTabs());
+    {
+        if (!(compareWith && compareWith->HasTabs() && wxRichTextTabsEq(compareWith->GetTabs(), style.GetTabs())))
+            destStyle.SetTabs(style.GetTabs());
+    }
 
     if (style.HasLeftIndent())
-        destStyle.SetLeftIndent(style.GetLeftIndent(), style.GetLeftSubIndent());
+    {
+        if (!(compareWith && compareWith->HasLeftIndent() && compareWith->GetLeftIndent() == style.GetLeftIndent()
+                          && compareWith->GetLeftSubIndent() == style.GetLeftSubIndent()))
+            destStyle.SetLeftIndent(style.GetLeftIndent(), style.GetLeftSubIndent());
+    }
 
     if (style.HasRightIndent())
-        destStyle.SetRightIndent(style.GetRightIndent());
+    {
+        if (!(compareWith && compareWith->HasRightIndent() && compareWith->GetRightIndent() == style.GetRightIndent()))
+            destStyle.SetRightIndent(style.GetRightIndent());
+    }
 
     if (style.HasParagraphSpacingAfter())
-        destStyle.SetParagraphSpacingAfter(style.GetParagraphSpacingAfter());
+    {
+        if (!(compareWith && compareWith->HasParagraphSpacingAfter() && compareWith->GetParagraphSpacingAfter() == style.GetParagraphSpacingAfter()))
+            destStyle.SetParagraphSpacingAfter(style.GetParagraphSpacingAfter());
+    }
 
     if (style.HasParagraphSpacingBefore())
-        destStyle.SetParagraphSpacingBefore(style.GetParagraphSpacingBefore());
+    {
+        if (!(compareWith && compareWith->HasParagraphSpacingBefore() && compareWith->GetParagraphSpacingBefore() == style.GetParagraphSpacingBefore()))
+            destStyle.SetParagraphSpacingBefore(style.GetParagraphSpacingBefore());
+    }
 
     if (style.HasLineSpacing())
-        destStyle.SetLineSpacing(style.GetLineSpacing());
+    {
+        if (!(compareWith && compareWith->HasLineSpacing() && compareWith->GetLineSpacing() == style.GetLineSpacing()))
+            destStyle.SetLineSpacing(style.GetLineSpacing());
+    }
 
     if (style.HasCharacterStyleName())
-        destStyle.SetCharacterStyleName(style.GetCharacterStyleName());
+    {
+        if (!(compareWith && compareWith->HasCharacterStyleName() && compareWith->GetCharacterStyleName() == style.GetCharacterStyleName()))
+            destStyle.SetCharacterStyleName(style.GetCharacterStyleName());
+    }
 
     if (style.HasParagraphStyleName())
-        destStyle.SetParagraphStyleName(style.GetParagraphStyleName());
+    {
+        if (!(compareWith && compareWith->HasParagraphStyleName() && compareWith->GetParagraphStyleName() == style.GetParagraphStyleName()))
+            destStyle.SetParagraphStyleName(style.GetParagraphStyleName());
+    }
+
+    if (style.HasListStyleName())
+    {
+        if (!(compareWith && compareWith->HasListStyleName() && compareWith->GetListStyleName() == style.GetListStyleName()))
+            destStyle.SetListStyleName(style.GetListStyleName());
+    }
 
     if (style.HasBulletStyle())
     {
-        destStyle.SetBulletStyle(style.GetBulletStyle());
-        destStyle.SetBulletSymbol(style.GetBulletSymbol());
+        if (!(compareWith && compareWith->HasBulletStyle() && compareWith->GetBulletStyle() == style.GetBulletStyle()))
+            destStyle.SetBulletStyle(style.GetBulletStyle());
+    }
+
+    if (style.HasBulletSymbol())
+    {
+        if (!(compareWith && compareWith->HasBulletSymbol() && compareWith->GetBulletSymbol() == style.GetBulletSymbol()))
+        {
+            destStyle.SetBulletSymbol(style.GetBulletSymbol());
+            destStyle.SetBulletFont(style.GetBulletFont());
+        }
     }
 
     if (style.HasBulletNumber())
-        destStyle.SetBulletNumber(style.GetBulletNumber());
+    {
+        if (!(compareWith && compareWith->HasBulletNumber() && compareWith->GetBulletNumber() == style.GetBulletNumber()))
+            destStyle.SetBulletNumber(style.GetBulletNumber());
+    }
 
     return true;
 }
 
+void wxSetFontPreservingStyles(wxTextAttr& attr, const wxFont& font)
+{
+    long flags = attr.GetFlags();
+    attr.SetFont(font);
+    attr.SetFlags(flags);
+}
+
+/// Convert a decimal to Roman numerals
+wxString wxRichTextDecimalToRoman(long n)
+{
+    static wxArrayInt decimalNumbers;
+    static wxArrayString romanNumbers;
+
+    // Clean up arrays
+    if (n == -1)
+    {
+        decimalNumbers.Clear();
+        romanNumbers.Clear();
+        return wxEmptyString;
+    }
+
+    if (decimalNumbers.GetCount() == 0)
+    {
+        #define wxRichTextAddDecRom(n, r) decimalNumbers.Add(n); romanNumbers.Add(r);
+
+        wxRichTextAddDecRom(1000, wxT("M"));
+        wxRichTextAddDecRom(900, wxT("CM"));
+        wxRichTextAddDecRom(500, wxT("D"));
+        wxRichTextAddDecRom(400, wxT("CD"));
+        wxRichTextAddDecRom(100, wxT("C"));
+        wxRichTextAddDecRom(90, wxT("XC"));
+        wxRichTextAddDecRom(50, wxT("L"));
+        wxRichTextAddDecRom(40, wxT("XL"));
+        wxRichTextAddDecRom(10, wxT("X"));
+        wxRichTextAddDecRom(9, wxT("IX"));
+        wxRichTextAddDecRom(5, wxT("V"));
+        wxRichTextAddDecRom(4, wxT("IV"));
+        wxRichTextAddDecRom(1, wxT("I"));
+    }
+
+    int i = 0;
+    wxString roman;
+
+    while (n > 0 && i < 13)
+    {
+        if (n >= decimalNumbers[i])
+        {
+            n -= decimalNumbers[i];
+            roman += romanNumbers[i];
+        }
+        else
+        {
+            i ++;
+        }
+    }
+    if (roman.IsEmpty())
+        roman = wxT("0");
+    return roman;
+}
+
 
 /*!
  * wxRichTextAttr stores attributes without a wxFont object, so is a much more
@@ -5267,9 +6381,11 @@ void wxRichTextAttr::operator= (const wxRichTextAttr& attr)
     m_lineSpacing = attr.m_lineSpacing;
     m_characterStyleName = attr.m_characterStyleName;
     m_paragraphStyleName = attr.m_paragraphStyleName;
+    m_listStyleName = attr.m_listStyleName;
     m_bulletStyle = attr.m_bulletStyle;
     m_bulletNumber = attr.m_bulletNumber;
     m_bulletSymbol = attr.m_bulletSymbol;
+    m_bulletFont = attr.m_bulletFont;
 }
 
 // operators
@@ -5289,6 +6405,11 @@ void wxRichTextAttr::operator= (const wxTextAttrEx& attr)
     m_lineSpacing = attr.GetLineSpacing();
     m_characterStyleName = attr.GetCharacterStyleName();
     m_paragraphStyleName = attr.GetParagraphStyleName();
+    m_listStyleName = attr.GetListStyleName();
+    m_bulletStyle = attr.GetBulletStyle();
+    m_bulletNumber = attr.GetBulletNumber();
+    m_bulletSymbol = attr.GetBulletSymbol();
+    m_bulletFont = attr.GetBulletFont();
 
     if (attr.GetFont().Ok())
         GetFontAttributes(attr.GetFont());
@@ -5314,13 +6435,19 @@ bool wxRichTextAttr::operator== (const wxRichTextAttr& attr) const
             GetLeftIndent() == attr.GetLeftIndent() &&
             GetLeftSubIndent() == attr.GetLeftSubIndent() &&
             GetRightIndent() == attr.GetRightIndent() &&
-            //GetTabs() == attr.GetTabs() &&
+            wxRichTextTabsEq(GetTabs(), attr.GetTabs()) &&
 
             GetParagraphSpacingAfter() == attr.GetParagraphSpacingAfter() &&
             GetParagraphSpacingBefore() == attr.GetParagraphSpacingBefore() &&
             GetLineSpacing() == attr.GetLineSpacing() &&
             GetCharacterStyleName() == attr.GetCharacterStyleName() &&
             GetParagraphStyleName() == attr.GetParagraphStyleName() &&
+            GetListStyleName() == attr.GetListStyleName() &&
+
+            GetBulletStyle() == attr.GetBulletStyle() &&
+            GetBulletSymbol() == attr.GetBulletSymbol() &&
+            GetBulletNumber() == attr.GetBulletNumber() &&
+            GetBulletFont() == attr.GetBulletFont() &&
 
             m_fontSize == attr.m_fontSize &&
             m_fontStyle == attr.m_fontStyle &&
@@ -5346,8 +6473,10 @@ void wxRichTextAttr::CopyTo(wxTextAttrEx& attr) const
     attr.SetBulletStyle(m_bulletStyle);
     attr.SetBulletNumber(m_bulletNumber);
     attr.SetBulletSymbol(m_bulletSymbol);
+    attr.SetBulletFont(m_bulletFont);
     attr.SetCharacterStyleName(m_characterStyleName);
     attr.SetParagraphStyleName(m_paragraphStyleName);
+    attr.SetListStyleName(m_listStyleName);
 
     attr.SetFlags(GetFlags()); // Important: set after SetFont and others, since they set flags
 }
@@ -5453,6 +6582,9 @@ wxRichTextAttr wxRichTextAttr::Combine(const wxRichTextAttr& attr,
     if (attr.HasParagraphStyleName())
         newAttr.SetParagraphStyleName(attr.GetParagraphStyleName());
 
+    if (attr.HasListStyleName())
+        newAttr.SetListStyleName(attr.GetListStyleName());
+
     if (attr.HasBulletStyle())
         newAttr.SetBulletStyle(attr.GetBulletStyle());
 
@@ -5460,7 +6592,10 @@ wxRichTextAttr wxRichTextAttr::Combine(const wxRichTextAttr& attr,
         newAttr.SetBulletNumber(attr.GetBulletNumber());
 
     if (attr.HasBulletSymbol())
+    {
         newAttr.SetBulletSymbol(attr.GetBulletSymbol());
+        newAttr.SetBulletFont(attr.GetBulletFont());
+    }
 
     return newAttr;
 }
@@ -5476,9 +6611,11 @@ wxTextAttrEx::wxTextAttrEx(const wxTextAttrEx& attr): wxTextAttr(attr)
     m_lineSpacing = attr.m_lineSpacing;
     m_paragraphStyleName = attr.m_paragraphStyleName;
     m_characterStyleName = attr.m_characterStyleName;
+    m_listStyleName = attr.m_listStyleName;
     m_bulletStyle = attr.m_bulletStyle;
     m_bulletNumber = attr.m_bulletNumber;
     m_bulletSymbol = attr.m_bulletSymbol;
+    m_bulletFont = attr.m_bulletFont;
 }
 
 // Initialise this object.
@@ -5503,9 +6640,11 @@ void wxTextAttrEx::operator= (const wxTextAttrEx& attr)
     m_lineSpacing = attr.m_lineSpacing;
     m_characterStyleName = attr.m_characterStyleName;
     m_paragraphStyleName = attr.m_paragraphStyleName;
+    m_listStyleName = attr.m_listStyleName;
     m_bulletStyle = attr.m_bulletStyle;
     m_bulletNumber = attr.m_bulletNumber;
     m_bulletSymbol = attr.m_bulletSymbol;
+    m_bulletFont = attr.m_bulletFont;
 }
 
 // Assignment from a wxTextAttr object.
@@ -5514,6 +6653,30 @@ void wxTextAttrEx::operator= (const wxTextAttr& attr)
     wxTextAttr::operator= (attr);
 }
 
+// Equality test
+bool wxTextAttrEx::operator== (const wxTextAttrEx& attr) const
+{
+    return (
+        GetTextColour() == attr.GetTextColour() &&
+        GetBackgroundColour() == attr.GetBackgroundColour() &&
+        GetFont() == attr.GetFont() &&
+        GetAlignment() == attr.GetAlignment() &&
+        GetLeftIndent() == attr.GetLeftIndent() &&
+        GetRightIndent() == attr.GetRightIndent() &&
+        GetLeftSubIndent() == attr.GetLeftSubIndent() &&
+        wxRichTextTabsEq(GetTabs(), attr.GetTabs()) &&
+        GetLineSpacing() == attr.GetLineSpacing() &&
+        GetParagraphSpacingAfter() == attr.GetParagraphSpacingAfter() &&
+        GetParagraphSpacingBefore() == attr.GetParagraphSpacingBefore() &&
+        GetBulletStyle() == attr.GetBulletStyle() &&
+        GetBulletNumber() == attr.GetBulletNumber() &&
+        GetBulletSymbol() == attr.GetBulletSymbol() &&
+        GetBulletFont() == attr.GetBulletFont() &&
+        GetCharacterStyleName() == attr.GetCharacterStyleName() &&
+        GetParagraphStyleName() == attr.GetParagraphStyleName() &&
+        GetListStyleName() == attr.GetListStyleName());
+}
+
 wxTextAttrEx wxTextAttrEx::CombineEx(const wxTextAttrEx& attr,
                                const wxTextAttrEx& attrDef,
                                const wxTextCtrlBase *text)
@@ -5546,7 +6709,7 @@ wxTextAttrEx wxTextAttrEx::CombineEx(const wxTextAttrEx& attr,
             font = *wxNORMAL_FONT;
 
         // Otherwise, if there are font attributes in attr, apply them
-        if (attr.HasFont())
+        if (attr.GetFlags() & wxTEXT_ATTR_FONT)
         {
             if (attr.HasSize())
             {
@@ -5641,6 +6804,9 @@ wxTextAttrEx wxTextAttrEx::CombineEx(const wxTextAttrEx& attr,
     if (attr.HasParagraphStyleName())
         newAttr.SetParagraphStyleName(attr.GetParagraphStyleName());
 
+    if (attr.HasListStyleName())
+        newAttr.SetListStyleName(attr.GetListStyleName());
+
     if (attr.HasBulletStyle())
         newAttr.SetBulletStyle(attr.GetBulletStyle());
 
@@ -5648,7 +6814,10 @@ wxTextAttrEx wxTextAttrEx::CombineEx(const wxTextAttrEx& attr,
         newAttr.SetBulletNumber(attr.GetBulletNumber());
 
     if (attr.HasBulletSymbol())
+    {
         newAttr.SetBulletSymbol(attr.GetBulletSymbol());
+        newAttr.SetBulletFont(attr.GetBulletFont());
+    }
 
     return newAttr;
 }
@@ -6127,3 +7296,4 @@ bool wxRichTextBufferDataObject::SetData(size_t WXUNUSED(len), const void *buf)
 
 #endif
     // wxUSE_RICHTEXT
+