X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/02761f6cd478e3c2c97cf6f93442747f7b029833..87bfb3969fa83ea88d811f4a7fa8a6b6de3bcee1:/src/richtext/richtextxml.cpp

diff --git a/src/richtext/richtextxml.cpp b/src/richtext/richtextxml.cpp
index b2205170ed..82170da836 100644
--- a/src/richtext/richtextxml.cpp
+++ b/src/richtext/richtextxml.cpp
@@ -30,6 +30,7 @@
 #include "wx/wfstream.h"
 #include "wx/sstream.h"
 #include "wx/txtstrm.h"
+#include "wx/tokenzr.h"
 #include "wx/xml/xml.h"
 
 IMPLEMENT_DYNAMIC_CLASS(wxRichTextXMLHandler, wxRichTextFileHandler)
@@ -40,7 +41,7 @@ bool wxRichTextXMLHandler::DoLoadFile(wxRichTextBuffer *buffer, wxInputStream& s
     if (!stream.IsOk())
         return false;
 
-    buffer->Clear();
+    buffer->ResetAndClearCommands();
 
     wxXmlDocument* xmlDoc = new wxXmlDocument;
     bool success = true;
@@ -98,6 +99,9 @@ bool wxRichTextXMLHandler::ImportXML(wxRichTextBuffer* buffer, wxXmlNode* node)
 
     if (name == wxT("paragraphlayout"))
     {
+        wxString partial = node->GetPropVal(wxT("partialparagraph"), wxEmptyString);
+        if (partial == wxT("true"))
+            buffer->SetPartialParagraph(true);
     }
     else if (name == wxT("paragraph"))
     {
@@ -140,6 +144,30 @@ bool wxRichTextXMLHandler::ImportXML(wxRichTextBuffer* buffer, wxXmlNode* node)
 
                 para->AppendChild(textObject);
             }
+            else if (childName == wxT("symbol"))
+            {
+                // This is a symbol that XML can't read in the normal way
+                wxString text;
+                wxXmlNode* textChild = child->GetChildren();
+                while (textChild)
+                {
+                    if (textChild->GetType() == wxXML_TEXT_NODE ||
+                        textChild->GetType() == wxXML_CDATA_SECTION_NODE)
+                    {
+                        wxString text2 = textChild->GetContent();
+                        text += text2;
+                    }
+                    textChild = textChild->GetNext();
+                }
+                
+                wxString actualText;
+                actualText << (wxChar) wxAtoi(text);
+
+                wxRichTextPlainText* textObject = new wxRichTextPlainText(actualText, para);
+                GetStyle(textObject->GetAttributes(), child, false);
+
+                para->AppendChild(textObject);
+            }
             else if (childName == wxT("image"))
             {
                 int imageType = wxBITMAP_TYPE_PNG;
@@ -182,6 +210,27 @@ bool wxRichTextXMLHandler::ImportXML(wxRichTextBuffer* buffer, wxXmlNode* node)
 
         doneChildren = true;
     }
+    else if (name == wxT("stylesheet"))
+    {
+        if (GetFlags() & wxRICHTEXT_HANDLER_INCLUDE_STYLESHEET)
+        {
+            wxRichTextStyleSheet* sheet = new wxRichTextStyleSheet;
+            
+            wxXmlNode* child = node->GetChildren();
+            while (child)
+            {
+                ImportStyleDefinition(sheet, child);
+                
+                child = child->GetNext();
+            }
+            
+            // Notify that styles have changed. If this is vetoed by the app,
+            // the new sheet will be deleted. If it is not vetoed, the
+            // old sheet will be deleted and replaced with the new one.
+            buffer->SetStyleSheetAndNotify(sheet);
+        }
+        doneChildren = true;
+    }
 
     if (!doneChildren)
     {
@@ -196,6 +245,94 @@ bool wxRichTextXMLHandler::ImportXML(wxRichTextBuffer* buffer, wxXmlNode* node)
     return true;
 }
 
+bool wxRichTextXMLHandler::ImportStyleDefinition(wxRichTextStyleSheet* sheet, wxXmlNode* node)
+{
+    wxString styleType = node->GetName();    
+    wxString styleName = node->GetPropVal(wxT("name"), wxEmptyString);
+    wxString baseStyleName = node->GetPropVal(wxT("basestyle"), wxEmptyString);
+    
+    if (styleName.IsEmpty())
+        return false;
+    
+    if (styleType == wxT("characterstyle"))
+    {
+        wxRichTextCharacterStyleDefinition* def = new wxRichTextCharacterStyleDefinition(styleName);
+        def->SetBaseStyle(baseStyleName);
+
+        wxXmlNode* child = node->GetChildren();
+        while (child)
+        {
+            if (child->GetName() == wxT("style"))
+            {
+                wxTextAttrEx attr;
+                GetStyle(attr, child, false);
+                def->SetStyle(attr);
+            }
+            child = child->GetNext();
+        }
+        
+        sheet->AddCharacterStyle(def);
+    }
+    else if (styleType == wxT("paragraphstyle"))
+    {
+        wxRichTextParagraphStyleDefinition* def = new wxRichTextParagraphStyleDefinition(styleName);
+
+        wxString nextStyleName = node->GetPropVal(wxT("nextstyle"), wxEmptyString);
+        def->SetNextStyle(nextStyleName);
+        def->SetBaseStyle(baseStyleName);
+
+        wxXmlNode* child = node->GetChildren();
+        while (child)
+        {
+            if (child->GetName() == wxT("style"))
+            {
+                wxTextAttrEx attr;
+                GetStyle(attr, child, false);
+                def->SetStyle(attr);
+            }
+            child = child->GetNext();
+        }
+
+        sheet->AddParagraphStyle(def);
+    }
+    else if (styleType == wxT("liststyle"))
+    {
+        wxRichTextListStyleDefinition* def = new wxRichTextListStyleDefinition(styleName);
+
+        wxString nextStyleName = node->GetPropVal(wxT("nextstyle"), wxEmptyString);
+        def->SetNextStyle(nextStyleName);
+        def->SetBaseStyle(baseStyleName);
+
+        wxXmlNode* child = node->GetChildren();
+        while (child)
+        {
+            if (child->GetName() == wxT("style"))
+            {
+                wxTextAttrEx attr;
+                GetStyle(attr, child, false);
+
+                wxString styleLevel = child->GetPropVal(wxT("level"), wxEmptyString);
+                if (styleLevel.IsEmpty())
+                {                
+                    def->SetStyle(attr);
+                }
+                else
+                {
+                    int level = wxAtoi(styleLevel);
+                    if (level > 0 && level <= 10)
+                    {
+                        def->SetLevelAttributes(level-1, attr);
+                    }
+                }
+            }
+            child = child->GetNext();
+        }
+
+        sheet->AddListStyle(def);
+    }
+    
+    return true;
+}
 
 //-----------------------------------------------------------------------------
 //  xml support routines
@@ -333,6 +470,16 @@ static void OutputStringEnt(wxOutputStream& stream, const wxString& str,
             }
             last = i + 1;
         }
+        else if (wxUChar(c) > 127)
+        {
+            OutputString(stream, str.Mid(last, i - last), convMem, convFile);
+
+            wxString s(wxT("&#"));
+            s << (int) c;
+            s << wxT(";");
+            OutputString(stream, s, NULL, NULL);
+            last = i + 1;
+        }
     }
     OutputString(stream, str.Mid(last, i - last), convMem, convFile);
 }
@@ -422,8 +569,39 @@ bool wxRichTextXMLHandler::DoSaveFile(wxRichTextBuffer *buffer, wxOutputStream&
     OutputString(stream, wxT("<richtext version=\"1.0.0.0\" xmlns=\"http://www.wxwidgets.org\">") , NULL, NULL);
 
     int level = 1;
-    bool success = ExportXML(stream, convMem, convFile, *buffer, level);
 
+    if (buffer->GetStyleSheet() && (GetFlags() & wxRICHTEXT_HANDLER_INCLUDE_STYLESHEET))
+    {
+        OutputIndentation(stream, level);
+        OutputString(stream, wxT("<stylesheet>"), convMem, convFile);
+
+        int i;
+
+        for (i = 0; i < (int) buffer->GetStyleSheet()->GetCharacterStyleCount(); i++)
+        {
+            wxRichTextCharacterStyleDefinition* def = buffer->GetStyleSheet()->GetCharacterStyle(i);
+            ExportStyleDefinition(stream, convMem, convFile, def, level + 1);
+        }
+
+        for (i = 0; i < (int) buffer->GetStyleSheet()->GetParagraphStyleCount(); i++)
+        {
+            wxRichTextParagraphStyleDefinition* def = buffer->GetStyleSheet()->GetParagraphStyle(i);
+            ExportStyleDefinition(stream, convMem, convFile, def, level + 1);
+        }
+
+        for (i = 0; i < (int) buffer->GetStyleSheet()->GetListStyleCount(); i++)
+        {
+            wxRichTextListStyleDefinition* def = buffer->GetStyleSheet()->GetListStyle(i);
+            ExportStyleDefinition(stream, convMem, convFile, def, level + 1);
+        }
+
+        OutputIndentation(stream, level);
+        OutputString(stream, wxT("</stylesheet>"), convMem, convFile);
+    }
+
+
+    bool success = ExportXML(stream, convMem, convFile, *buffer, level);
+    
     OutputString(stream, wxT("\n</richtext>") , NULL, NULL);
     OutputString(stream, wxT("\n"), NULL, NULL);
 
@@ -447,27 +625,82 @@ bool wxRichTextXMLHandler::ExportXML(wxOutputStream& stream, wxMBConv* convMem,
         objectName = wxT("image");
     else
         objectName = wxT("object");
+    
+    bool terminateTag = true;
 
     if (obj.IsKindOf(CLASSINFO(wxRichTextPlainText)))
     {
-        wxRichTextPlainText& text = (wxRichTextPlainText&) obj;
+        wxRichTextPlainText& textObj = (wxRichTextPlainText&) obj;
+        
+        wxString style = CreateStyle(obj.GetAttributes(), false);
+                
+        int i;
+        int last = 0;
+        const wxString& text = textObj.GetText();
+        int len = (int) text.Length();
+        for (i = 0; i < len; i++)
+        {
+            int c = (int) text[i];
+            if (c < 32 && c != 9 && c != 10 && c != 13)
+            {
+                if (i > 0)
+                {
+                    OutputIndentation(stream, indent);
+                    OutputString(stream, wxT("<") + objectName, convMem, convFile);
 
-        OutputIndentation(stream, indent);
-        OutputString(stream, wxT("<") + objectName, convMem, convFile);
+                    OutputString(stream, style + wxT(">"), convMem, convFile);
 
-        wxString style = CreateStyle(obj.GetAttributes(), false);
+                    wxString fragment(text.Mid(last, i-last));
+                    if (!fragment.empty() && (fragment[0] == wxT(' ') || fragment[fragment.length()-1] == wxT(' ')))
+                    {
+                        OutputString(stream, wxT("\""), convMem, convFile);
+                        OutputStringEnt(stream, fragment, convMem, convFile);
+                        OutputString(stream, wxT("\""), convMem, convFile);
+                    }
+                    else
+                        OutputStringEnt(stream, fragment, convMem, convFile);
 
-        OutputString(stream, style + wxT(">"), convMem, convFile);
+                    OutputString(stream, wxT("</text>"), convMem, convFile);
+                }                
+                
+
+                // Output this character as a number in a separate tag, because XML can't cope
+                // with entities below 32 except for 9, 10 and 13                
+                last = i + 1;
+                OutputIndentation(stream, indent);
+                OutputString(stream, wxT("<symbol"), convMem, convFile);
+
+                OutputString(stream, style + wxT(">"), convMem, convFile);
+                OutputString(stream, wxString::Format(wxT("%d"), c), convMem, convFile);                
+
+                OutputString(stream, wxT("</symbol>"), convMem, convFile);
+            }
+        }
+        
+        wxString fragment;
+        if (last == 0)
+            fragment = text;
+        else
+            fragment = text.Mid(last, i-last);
 
-        wxString str = text.GetText();
-        if (!str.empty() && (str[0] == wxT(' ') || str[str.length()-1] == wxT(' ')))
+        if (last < len)
         {
-            OutputString(stream, wxT("\""), convMem, convFile);
-            OutputStringEnt(stream, str, convMem, convFile);
-            OutputString(stream, wxT("\""), convMem, convFile);
+            OutputIndentation(stream, indent);
+            OutputString(stream, wxT("<") + objectName, convMem, convFile);
+
+            OutputString(stream, style + wxT(">"), convMem, convFile);
+
+            if (!fragment.empty() && (fragment[0] == wxT(' ') || fragment[fragment.length()-1] == wxT(' ')))
+            {
+                OutputString(stream, wxT("\""), convMem, convFile);
+                OutputStringEnt(stream, fragment, convMem, convFile);
+                OutputString(stream, wxT("\""), convMem, convFile);
+            }
+            else
+                OutputStringEnt(stream, fragment, convMem, convFile);
         }
         else
-            OutputStringEnt(stream, str, convMem, convFile);
+            terminateTag = false;
     }
     else if (obj.IsKindOf(CLASSINFO(wxRichTextImage)))
     {
@@ -505,6 +738,9 @@ bool wxRichTextXMLHandler::ExportXML(wxOutputStream& stream, wxMBConv* convMem,
             isPara = true;
 
         wxString style = CreateStyle(obj.GetAttributes(), isPara);
+        
+        if (objectName == wxT("paragraphlayout") && ((wxRichTextParagraphLayoutBox&) obj).GetPartialParagraph())
+            style << wxT(" partialparagraph=\"true\"");
 
         OutputString(stream, style + wxT(">"), convMem, convFile);
 
@@ -520,7 +756,108 @@ bool wxRichTextXMLHandler::ExportXML(wxOutputStream& stream, wxMBConv* convMem,
     if (objectName != wxT("text"))
         OutputIndentation(stream, indent);
 
-    OutputString(stream, wxT("</") + objectName + wxT(">"), convMem, convFile);
+    if (terminateTag)
+        OutputString(stream, wxT("</") + objectName + wxT(">"), convMem, convFile);
+
+    return true;
+}
+
+bool wxRichTextXMLHandler::ExportStyleDefinition(wxOutputStream& stream, wxMBConv* convMem, wxMBConv* convFile, wxRichTextStyleDefinition* def, int level)
+{
+    wxRichTextCharacterStyleDefinition* charDef = wxDynamicCast(def, wxRichTextCharacterStyleDefinition);    
+    wxRichTextParagraphStyleDefinition* paraDef = wxDynamicCast(def, wxRichTextParagraphStyleDefinition);
+    wxRichTextListStyleDefinition* listDef = wxDynamicCast(def, wxRichTextListStyleDefinition);
+    
+    wxString baseStyle = def->GetBaseStyle();
+    wxString baseStyleProp;
+    if (!baseStyle.IsEmpty())
+        baseStyleProp = wxT(" basestyle=\"") + baseStyle + wxT("\"");
+    
+    if (charDef)
+    {
+        OutputIndentation(stream, level);
+        OutputString(stream, wxT("<characterstyle") + baseStyleProp + wxT(">"), convMem, convFile);
+        
+        level ++;
+
+        wxString style = CreateStyle(def->GetStyle(), false);
+
+        OutputIndentation(stream, level);
+        OutputString(stream, wxT("<style ") + style + wxT(">"), convMem, convFile);
+        
+        OutputIndentation(stream, level);
+        OutputString(stream, wxT("</style>"), convMem, convFile);
+
+        level --;
+
+        OutputIndentation(stream, level);
+        OutputString(stream, wxT("</characterstyle>"), convMem, convFile);
+    }
+    else if (listDef)
+    {
+        OutputIndentation(stream, level);
+        
+        if (!listDef->GetNextStyle().IsEmpty())
+            baseStyleProp << wxT(" basestyle=\"") << listDef->GetNextStyle() << wxT("\"");
+        
+        OutputString(stream, wxT("<liststyle") + baseStyleProp + wxT(">"), convMem, convFile);
+        
+        level ++;
+
+        wxString style = CreateStyle(def->GetStyle(), false);
+
+        OutputIndentation(stream, level);
+        OutputString(stream, wxT("<style ") + style + wxT(">"), convMem, convFile);
+        
+        OutputIndentation(stream, level);
+        OutputString(stream, wxT("</style>"), convMem, convFile);
+
+        int i;
+        for (i = 0; i < 10; i ++)
+        {
+            wxRichTextAttr* levelAttr = listDef->GetLevelAttributes(i);
+            if (levelAttr)
+            {
+                wxString style = CreateStyle(def->GetStyle(), false);
+                wxString levelStr = wxString::Format(wxT(" level=\"%d\" "), (i+1));
+
+                OutputIndentation(stream, level);
+                OutputString(stream, wxT("<style ") + levelStr + style + wxT(">"), convMem, convFile);
+        
+                OutputIndentation(stream, level);
+                OutputString(stream, wxT("</style>"), convMem, convFile);
+            }
+        }
+
+        level --;
+
+        OutputIndentation(stream, level);
+        OutputString(stream, wxT("</liststyle>"), convMem, convFile);
+    }
+    else if (paraDef)
+    {
+        OutputIndentation(stream, level);
+        
+        if (!listDef->GetNextStyle().IsEmpty())
+            baseStyleProp << wxT(" basestyle=\"") << listDef->GetNextStyle() << wxT("\"");
+        
+        OutputString(stream, wxT("<paragraphstyle") + baseStyleProp + wxT(">"), convMem, convFile);
+        
+        level ++;
+
+        wxString style = CreateStyle(def->GetStyle(), false);
+
+        OutputIndentation(stream, level);
+        OutputString(stream, wxT("<style ") + style + wxT(">"), convMem, convFile);
+        
+        OutputIndentation(stream, level);
+        OutputString(stream, wxT("</style>"), convMem, convFile);
+        
+        level --;
+
+        OutputIndentation(stream, level);
+        OutputString(stream, wxT("</paragraphstyle>"), convMem, convFile);
+    }
 
     return true;
 }
@@ -529,43 +866,104 @@ bool wxRichTextXMLHandler::ExportXML(wxOutputStream& stream, wxMBConv* convMem,
 wxString wxRichTextXMLHandler::CreateStyle(const wxTextAttrEx& attr, bool isPara)
 {
     wxString str;
-    if (attr.GetTextColour().Ok())
+    if (attr.HasTextColour() && attr.GetTextColour().Ok())
     {
         str << wxT(" textcolor=\"#") << ColourToHexString(attr.GetTextColour()) << wxT("\"");
     }
-    if (attr.GetBackgroundColour().Ok())
+    if (attr.HasBackgroundColour() && attr.GetBackgroundColour().Ok())
     {
         str << wxT(" bgcolor=\"#") << ColourToHexString(attr.GetBackgroundColour()) << wxT("\"");
     }
 
     if (attr.GetFont().Ok())
     {
-        str << wxT(" fontsize=\"") << attr.GetFont().GetPointSize() << wxT("\"");
-        str << wxT(" fontfamily=\"") << attr.GetFont().GetFamily() << wxT("\"");
-        str << wxT(" fontstyle=\"") << attr.GetFont().GetStyle() << wxT("\"");
-        str << wxT(" fontweight=\"") << attr.GetFont().GetWeight() << wxT("\"");
-        str << wxT(" fontunderlined=\"") << (int) attr.GetFont().GetUnderlined() << wxT("\"");
-        str << wxT(" fontface=\"") << attr.GetFont().GetFaceName() << wxT("\"");
+        if (attr.HasSize())
+            str << wxT(" fontsize=\"") << attr.GetFont().GetPointSize() << wxT("\"");
+        
+        //if (attr.HasFamily())
+        //    str << wxT(" fontfamily=\"") << attr.GetFont().GetFamily() << wxT("\"");
+
+        if (attr.HasItalic())
+            str << wxT(" fontstyle=\"") << attr.GetFont().GetStyle() << wxT("\"");
+
+        if (attr.HasWeight())
+            str << wxT(" fontweight=\"") << attr.GetFont().GetWeight() << wxT("\"");
+
+        if (attr.HasUnderlined())
+            str << wxT(" fontunderlined=\"") << (int) attr.GetFont().GetUnderlined() << wxT("\"");
+
+        if (attr.HasFaceName())
+            str << wxT(" fontface=\"") << attr.GetFont().GetFaceName() << wxT("\"");
     }
 
     if (!attr.GetCharacterStyleName().empty())
-        str << wxT(" charactertyle=\"") << wxString(attr.GetCharacterStyleName()) << wxT("\"");
+        str << wxT(" characterstyle=\"") << wxString(attr.GetCharacterStyleName()) << wxT("\"");
 
     if (isPara)
     {
-        str << wxT(" alignment=\"") << (int) attr.GetAlignment() << wxT("\"");
-        str << wxT(" leftindent=\"") << (int) attr.GetLeftIndent() << wxT("\"");
-        str << wxT(" leftsubindent=\"") << (int) attr.GetLeftSubIndent() << wxT("\"");
-        str << wxT(" rightindent=\"") << (int) attr.GetRightIndent() << wxT("\"");
-        str << wxT(" parspacingafter=\"") << (int) attr.GetParagraphSpacingAfter() << wxT("\"");
-        str << wxT(" parspacingbefore=\"") << (int) attr.GetParagraphSpacingBefore() << wxT("\"");
-        str << wxT(" linespacing=\"") << (int) attr.GetLineSpacing() << wxT("\"");
-        str << wxT(" bulletstyle=\"") << (int) attr.GetBulletStyle() << wxT("\"");
-        str << wxT(" bulletnumber=\"") << (int) attr.GetBulletNumber() << wxT("\"");
-        str << wxT(" bulletsymbol=\"") << wxString(attr.GetBulletSymbol()) << wxT("\"");
+        if (attr.HasAlignment())
+            str << wxT(" alignment=\"") << (int) attr.GetAlignment() << wxT("\"");
+
+        if (attr.HasLeftIndent())
+        {
+            str << wxT(" leftindent=\"") << (int) attr.GetLeftIndent() << wxT("\"");
+            str << wxT(" leftsubindent=\"") << (int) attr.GetLeftSubIndent() << wxT("\"");
+        }
+
+        if (attr.HasRightIndent())
+            str << wxT(" rightindent=\"") << (int) attr.GetRightIndent() << wxT("\"");
 
+        if (attr.HasParagraphSpacingAfter())
+            str << wxT(" parspacingafter=\"") << (int) attr.GetParagraphSpacingAfter() << wxT("\"");
+
+        if (attr.HasParagraphSpacingBefore())
+            str << wxT(" parspacingbefore=\"") << (int) attr.GetParagraphSpacingBefore() << wxT("\"");
+
+        if (attr.HasLineSpacing())
+            str << wxT(" linespacing=\"") << (int) attr.GetLineSpacing() << wxT("\"");
+
+        if (attr.HasBulletStyle())
+            str << wxT(" bulletstyle=\"") << (int) attr.GetBulletStyle() << wxT("\"");
+
+        if (attr.HasBulletNumber())
+            str << wxT(" bulletnumber=\"") << (int) attr.GetBulletNumber() << wxT("\"");
+
+        if (attr.HasBulletText())
+        {
+            // If using a bullet symbol, convert to integer in case it's a non-XML-friendly character.
+            // Otherwise, assume it's XML-friendly text such as outline numbering, e.g. 1.2.3.1
+            if (!attr.GetBulletText().IsEmpty() && (attr.GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_SYMBOL))
+                str << wxT(" bulletsymbol=\"") << (int) (attr.GetBulletText()[0]) << wxT("\"");
+            else
+                str << wxT(" bullettext=\"") << attr.GetBulletText() << wxT("\"");
+                
+            str << wxT(" bulletfont=\"") << attr.GetBulletFont() << wxT("\"");
+        }
+
+        if (attr.HasBulletName())
+            str << wxT(" bulletname=\"") << attr.GetBulletName() << wxT("\"");
+
+        if (attr.HasURL())
+            str << wxT(" url=\"") << attr.GetURL() << wxT("\"");
+        
         if (!attr.GetParagraphStyleName().empty())
             str << wxT(" parstyle=\"") << wxString(attr.GetParagraphStyleName()) << wxT("\"");
+        
+        if (!attr.GetListStyleName().empty())
+            str << wxT(" liststyle=\"") << wxString(attr.GetListStyleName()) << wxT("\"");
+        
+        if (attr.HasTabs())
+        {
+            str << wxT(" tabs=\"");
+            size_t i;
+            for (i = 0; i < attr.GetTabs().GetCount(); i++)
+            {
+                if (i > 0)
+                    str << wxT(",");
+                str << attr.GetTabs()[i];
+            }
+            str << wxT("\"");            
+        }
     }
 
     return str;
@@ -580,31 +978,54 @@ bool wxRichTextXMLHandler::GetStyle(wxTextAttrEx& attr, wxXmlNode* node, bool is
     int fontWeight = wxNORMAL;
     int fontStyle = wxNORMAL;
     bool fontUnderlined = false;
+    
+    int fontFlags = 0;
 
     fontFacename = node->GetPropVal(wxT("fontface"), wxEmptyString);
+    if (!fontFacename.IsEmpty())
+        fontFlags |= wxTEXT_ATTR_FONT_FACE;
 
-    wxString value = node->GetPropVal(wxT("fontfamily"), wxEmptyString);
-    if (!value.empty())
-        fontFamily = wxAtoi(value);
+    wxString value;
+    //value = node->GetPropVal(wxT("fontfamily"), wxEmptyString);
+    //if (!value.empty())
+    //    fontFamily = wxAtoi(value);
 
     value = node->GetPropVal(wxT("fontstyle"), wxEmptyString);
     if (!value.empty())
+    {
         fontStyle = wxAtoi(value);
+        fontFlags |= wxTEXT_ATTR_FONT_ITALIC;
+    }
 
     value = node->GetPropVal(wxT("fontsize"), wxEmptyString);
     if (!value.empty())
+    {
         fontSize = wxAtoi(value);
+        fontFlags |= wxTEXT_ATTR_FONT_SIZE;
+    }
 
     value = node->GetPropVal(wxT("fontweight"), wxEmptyString);
     if (!value.empty())
+    {
         fontWeight = wxAtoi(value);
+        fontFlags |= wxTEXT_ATTR_FONT_WEIGHT;
+    }
 
     value = node->GetPropVal(wxT("fontunderlined"), wxEmptyString);
     if (!value.empty())
+    {
         fontUnderlined = wxAtoi(value) != 0;
-
-    attr.SetFont(* wxTheFontList->FindOrCreateFont(fontSize, fontFamily, fontStyle, fontWeight, fontUnderlined, fontFacename));
-
+        fontFlags |= wxTEXT_ATTR_FONT_UNDERLINE;
+    }
+    
+    attr.SetFlags(fontFlags);
+    
+    if (attr.HasFlag(wxTEXT_ATTR_FONT))
+        attr.SetFont(* wxTheFontList->FindOrCreateFont(fontSize, fontFamily, fontStyle, fontWeight, fontUnderlined, fontFacename));
+
+    // Restore correct font flags
+    attr.SetFlags(fontFlags);
+    
     value = node->GetPropVal(wxT("textcolor"), wxEmptyString);
     if (!value.empty())
     {
@@ -636,13 +1057,24 @@ bool wxRichTextXMLHandler::GetStyle(wxTextAttrEx& attr, wxXmlNode* node, bool is
 
         int leftSubIndent = 0;
         int leftIndent = 0;
+        bool hasLeftIndent = false;
+        
         value = node->GetPropVal(wxT("leftindent"), wxEmptyString);
         if (!value.empty())
+        {
             leftIndent = wxAtoi(value);
+            hasLeftIndent = true;
+        }
+
         value = node->GetPropVal(wxT("leftsubindent"), wxEmptyString);
         if (!value.empty())
+        {
             leftSubIndent = wxAtoi(value);
-        attr.SetLeftIndent(leftIndent, leftSubIndent);
+            hasLeftIndent = true;
+        }
+
+        if (hasLeftIndent)
+            attr.SetLeftIndent(leftIndent, leftSubIndent);
 
         value = node->GetPropVal(wxT("rightindent"), wxEmptyString);
         if (!value.empty())
@@ -670,11 +1102,49 @@ bool wxRichTextXMLHandler::GetStyle(wxTextAttrEx& attr, wxXmlNode* node, bool is
 
         value = node->GetPropVal(wxT("bulletsymbol"), wxEmptyString);
         if (!value.empty())
-            attr.SetBulletSymbol(value[0]);
+        {
+            wxChar ch = wxAtoi(value);
+            wxString s;
+            s << ch;
+            attr.SetBulletText(s);
+        }
+
+        value = node->GetPropVal(wxT("bullettext"), wxEmptyString);
+        if (!value.empty())
+            attr.SetBulletText(value);
+
+        value = node->GetPropVal(wxT("bulletfont"), wxEmptyString);
+        if (!value.empty())
+            attr.SetBulletFont(value);
+
+        value = node->GetPropVal(wxT("bulletname"), wxEmptyString);
+        if (!value.empty())
+            attr.SetBulletName(value);
+
+        value = node->GetPropVal(wxT("url"), wxEmptyString);
+        if (!value.empty())
+            attr.SetURL(value);
 
         value = node->GetPropVal(wxT("parstyle"), wxEmptyString);
         if (!value.empty())
             attr.SetParagraphStyleName(value);
+        
+        value = node->GetPropVal(wxT("liststyle"), wxEmptyString);
+        if (!value.empty())
+            attr.SetListStyleName(value);
+        
+        value = node->GetPropVal(wxT("tabs"), wxEmptyString);
+        if (!value.empty())
+        {
+            wxArrayInt tabs;
+            wxStringTokenizer tkz(value, wxT(","));
+            while (tkz.HasMoreTokens())
+            {
+                wxString token = tkz.GetNextToken();
+                tabs.Add(wxAtoi(token));
+            }
+            attr.SetTabs(tabs);
+        }
     }
 
     return true;
@@ -685,3 +1155,4 @@ bool wxRichTextXMLHandler::GetStyle(wxTextAttrEx& attr, wxXmlNode* node, bool is
 
 #endif
     // wxUSE_RICHTEXT && wxUSE_XML
+