corrected off by 1 error in cMB2WC() call (thanks valgrind)

[wxWidgets.git] / src / richtext / richtextxml.cpp

diff --git a/src/richtext/richtextxml.cpp b/src/richtext/richtextxml.cpp
index 2e171c5d07dac9a1420f9f05f30bafd0a1181aa9..c5759c78cc03cc1bfe1044602cabdfc4a2f4abef 100644 (file)
--- a/src/richtext/richtextxml.cpp
+++ b/src/richtext/richtextxml.cpp
@@ -1,10 +1,10 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        richtextxml.cpp
+// Name:        src/richtext/richtextxml.cpp

 // Purpose:     XML and HTML I/O for wxRichTextCtrl
 // Author:      Julian Smart
 // Purpose:     XML and HTML I/O for wxRichTextCtrl
 // Author:      Julian Smart

-// Modified by: 
+// Modified by:

 // Created:     2005-09-30
 // Created:     2005-09-30

-// RCS-ID:      
+// RCS-ID:      $Id$

 // Copyright:   (c) Julian Smart
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 // Copyright:   (c) Julian Smart
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////


@@ -13,42 +13,50 @@
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__

-  #pragma hdrstop
+    #pragma hdrstop

 #endif
 
 #endif
 

-#ifndef WX_PRECOMP
-  #include "wx/wx.h"
-#endif
+#if wxUSE_RICHTEXT && wxUSE_XML

 
 

-#include "wx/image.h"
+#include "wx/richtext/richtextxml.h"

 
 

-#if wxUSE_RICHTEXT
+#ifndef WX_PRECOMP
+    #include "wx/intl.h"
+    #include "wx/module.h"
+#endif

 
 #include "wx/filename.h"
 #include "wx/clipbrd.h"
 #include "wx/wfstream.h"
 #include "wx/sstream.h"
 
 #include "wx/filename.h"
 #include "wx/clipbrd.h"
 #include "wx/wfstream.h"
 #include "wx/sstream.h"

-#include "wx/module.h"

 #include "wx/txtstrm.h"
 #include "wx/txtstrm.h"

+#include "wx/tokenzr.h"

 #include "wx/xml/xml.h"
 
 #include "wx/xml/xml.h"
 

-#include "wx/richtext/richtextxml.h"
-

 IMPLEMENT_DYNAMIC_CLASS(wxRichTextXMLHandler, wxRichTextFileHandler)
 
 #if wxUSE_STREAMS
 IMPLEMENT_DYNAMIC_CLASS(wxRichTextXMLHandler, wxRichTextFileHandler)
 
 #if wxUSE_STREAMS

-bool wxRichTextXMLHandler::LoadFile(wxRichTextBuffer *buffer, wxInputStream& stream)
+bool wxRichTextXMLHandler::DoLoadFile(wxRichTextBuffer *buffer, wxInputStream& stream)

 {
     if (!stream.IsOk())
         return false;
 
 {
     if (!stream.IsOk())
         return false;
 

+    buffer->ResetAndClearCommands();

     buffer->Clear();
 
     wxXmlDocument* xmlDoc = new wxXmlDocument;
     bool success = true;
 
     buffer->Clear();
 
     wxXmlDocument* xmlDoc = new wxXmlDocument;
     bool success = true;
 

-    if (!xmlDoc->Load(stream, wxT("ISO-8859-1")))
+    // This is the encoding to convert to (memory encoding rather than file encoding)
+    wxString encoding(wxT("UTF-8"));
+
+#if !wxUSE_UNICODE && wxUSE_INTL
+    encoding = wxLocale::GetSystemEncodingName();
+#endif
+
+    if (!xmlDoc->Load(stream, encoding))

     {
     {

+        buffer->ResetAndClearCommands();

         success = false;
     }
     else
         success = false;
     }
     else


@@ -67,7 +75,7 @@ bool wxRichTextXMLHandler::LoadFile(wxRichTextBuffer *buffer, wxInputStream& str
                     else
                         ImportXML(buffer, child);
                 }
                     else
                         ImportXML(buffer, child);
                 }

-                
+

                 child = child->GetNext();
             }
         }
                 child = child->GetNext();
             }
         }


@@ -76,7 +84,7 @@ bool wxRichTextXMLHandler::LoadFile(wxRichTextBuffer *buffer, wxInputStream& str
             success = false;
         }
     }
             success = false;
         }
     }

-    
+

     delete xmlDoc;
 
     buffer->UpdateRanges();
     delete xmlDoc;
 
     buffer->UpdateRanges();


@@ -93,6 +101,9 @@ bool wxRichTextXMLHandler::ImportXML(wxRichTextBuffer* buffer, wxXmlNode* node)
 
     if (name == wxT("paragraphlayout"))
     {
 
     if (name == wxT("paragraphlayout"))
     {

+        wxString partial = node->GetAttribute(wxT("partialparagraph"), wxEmptyString);
+        if (partial == wxT("true"))
+            buffer->SetPartialParagraph(true);

     }
     else if (name == wxT("paragraph"))
     {
     }
     else if (name == wxT("paragraph"))
     {


@@ -117,19 +128,13 @@ bool wxRichTextXMLHandler::ImportXML(wxRichTextBuffer* buffer, wxXmlNode* node)
                         wxString text2 = textChild->GetContent();
 
                         // Strip whitespace from end
                         wxString text2 = textChild->GetContent();
 
                         // Strip whitespace from end

-                        if (text2.Length() > 0 && text2[text2.Length()-1] == wxT('\n'))
-                            text2 = text2.Mid(0, text2.Length()-1);
+                        if (!text2.empty() && text2[text2.length()-1] == wxT('\n'))
+                            text2 = text2.Mid(0, text2.length()-1);

 
 

-                        if (text2.Length() > 0 && text2[0] == wxT('"'))
+                        if (!text2.empty() && text2[0] == wxT('"'))

                             text2 = text2.Mid(1);
                             text2 = text2.Mid(1);

-                        if (text2.Length() > 0 && text2[text2.Length()-1] == wxT('"'))
-                            text2 = text2.Mid(0, text2.Length() - 1);
-
-                        // TODO: further entity translation
-                        text2.Replace(wxT("&lt;"), wxT("<"));
-                        text2.Replace(wxT("&gt;"), wxT(">"));
-                        text2.Replace(wxT("&amp;"), wxT("&"));
-                        text2.Replace(wxT("&quot;"), wxT("\""));
+                        if (!text2.empty() && text2[text2.length()-1] == wxT('"'))
+                            text2 = text2.Mid(0, text2.length() - 1);

 
                         text += text2;
                     }
 
                         text += text2;
                     }


@@ -141,11 +146,35 @@ bool wxRichTextXMLHandler::ImportXML(wxRichTextBuffer* buffer, wxXmlNode* node)
 
                 para->AppendChild(textObject);
             }
 
                 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;
             else if (childName == wxT("image"))
             {
                 int imageType = wxBITMAP_TYPE_PNG;

-                wxString value = node->GetPropVal(wxT("imagetype"), wxEmptyString);
-                if (!value.IsEmpty())
+                wxString value = node->GetAttribute(wxT("imagetype"), wxEmptyString);
+                if (!value.empty())

                     imageType = wxAtoi(value);
 
                 wxString data;
                     imageType = wxAtoi(value);
 
                 wxString data;


@@ -163,19 +192,19 @@ bool wxRichTextXMLHandler::ImportXML(wxRichTextBuffer* buffer, wxXmlNode* node)
                             // wxLogDebug(data);
                             dataChild = dataChild->GetNext();
                         }
                             // wxLogDebug(data);
                             dataChild = dataChild->GetNext();
                         }

-                        
+

                     }
                     imageChild = imageChild->GetNext();
                 }
 
                     }
                     imageChild = imageChild->GetNext();
                 }
 

-                if (!data.IsEmpty())
+                if (!data.empty())

                 {
                     wxRichTextImage* imageObj = new wxRichTextImage(para);
                     para->AppendChild(imageObj);
 
                     wxStringInputStream strStream(data);
 
                 {
                     wxRichTextImage* imageObj = new wxRichTextImage(para);
                     para->AppendChild(imageObj);
 
                     wxStringInputStream strStream(data);
 

-                    imageObj->GetImageBlock().ReadHex(strStream, data.Length(), imageType);
+                    imageObj->GetImageBlock().ReadHex(strStream, data.length(), imageType);

                 }
             }
             child = child->GetNext();
                 }
             }
             child = child->GetNext();


@@ -183,6 +212,31 @@ bool wxRichTextXMLHandler::ImportXML(wxRichTextBuffer* buffer, wxXmlNode* node)
 
         doneChildren = true;
     }
 
         doneChildren = true;
     }

+    else if (name == wxT("stylesheet"))
+    {
+        if (GetFlags() & wxRICHTEXT_HANDLER_INCLUDE_STYLESHEET)
+        {
+            wxRichTextStyleSheet* sheet = new wxRichTextStyleSheet;
+            wxString sheetName = node->GetAttribute(wxT("name"), wxEmptyString);
+            wxString sheetDescription = node->GetAttribute(wxT("description"), wxEmptyString);
+            sheet->SetName(sheetName);
+            sheet->SetDescription(sheetDescription);
+
+            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)
     {
 
     if (!doneChildren)
     {


@@ -192,11 +246,99 @@ bool wxRichTextXMLHandler::ImportXML(wxRichTextBuffer* buffer, wxXmlNode* node)
             ImportXML(buffer, child);
             child = child->GetNext();
         }
             ImportXML(buffer, child);
             child = child->GetNext();
         }

-    }    
+    }

 
     return true;
 }
 
 
     return true;
 }
 

+bool wxRichTextXMLHandler::ImportStyleDefinition(wxRichTextStyleSheet* sheet, wxXmlNode* node)
+{
+    wxString styleType = node->GetName();
+    wxString styleName = node->GetAttribute(wxT("name"), wxEmptyString);
+    wxString baseStyleName = node->GetAttribute(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->GetAttribute(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->GetAttribute(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->GetAttribute(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
 
 //-----------------------------------------------------------------------------
 //  xml support routines


@@ -242,7 +384,7 @@ wxString wxRichTextXMLHandler::GetNodeContent(wxXmlNode *node)
 
 wxString wxRichTextXMLHandler::GetParamValue(wxXmlNode *node, const wxString& param)
 {
 
 wxString wxRichTextXMLHandler::GetParamValue(wxXmlNode *node, const wxString& param)
 {

-    if (param.IsEmpty())
+    if (param.empty())

         return GetNodeContent(node);
     else
         return GetNodeContent(GetParamNode(node, param));
         return GetNodeContent(node);
     else
         return GetNodeContent(GetParamNode(node, param));


@@ -257,14 +399,31 @@ wxString wxRichTextXMLHandler::GetText(wxXmlNode *node, const wxString& param, b
     return str1;
 }
 
     return str1;
 }
 

+// For use with earlier versions of wxWidgets
+#ifndef WXUNUSED_IN_UNICODE
+#if wxUSE_UNICODE
+#define WXUNUSED_IN_UNICODE(x) WXUNUSED(x)
+#else
+#define WXUNUSED_IN_UNICODE(x) x
+#endif
+#endif
+

 // write string to output:
 inline static void OutputString(wxOutputStream& stream, const wxString& str,
 // write string to output:
 inline static void OutputString(wxOutputStream& stream, const wxString& str,

-                                wxMBConv *convMem = NULL, wxMBConv *convFile = NULL)
+                                wxMBConv *WXUNUSED_IN_UNICODE(convMem) = NULL, wxMBConv *convFile = NULL)

 {
 {

-    if (str.IsEmpty()) return;
+    if (str.empty()) return;

 #if wxUSE_UNICODE
 #if wxUSE_UNICODE

-    const wxWX2MBbuf buf(str.mb_str(convFile ? *convFile : wxConvUTF8));
-    stream.Write((const char*)buf, strlen((const char*)buf));
+    if (convFile)
+    {
+        const wxWX2MBbuf buf(str.mb_str(*convFile));
+        stream.Write((const char*)buf, strlen((const char*)buf));
+    }
+    else
+    {
+        const wxWX2MBbuf buf(str.mb_str(wxConvUTF8));
+        stream.Write((const char*)buf, strlen((const char*)buf));
+    }

 #else
     if ( convFile == NULL )
         stream.Write(str.mb_str(), str.Len());
 #else
     if ( convFile == NULL )
         stream.Write(str.mb_str(), str.Len());


@@ -284,14 +443,19 @@ static void OutputStringEnt(wxOutputStream& stream, const wxString& str,
     wxString buf;
     size_t i, last, len;
     wxChar c;
     wxString buf;
     size_t i, last, len;
     wxChar c;

-    
+

     len = str.Len();
     last = 0;
     for (i = 0; i < len; i++)
     {
         c = str.GetChar(i);
     len = str.Len();
     last = 0;
     for (i = 0; i < len; i++)
     {
         c = str.GetChar(i);

+
+        // Original code excluded "&amp;" but we _do_ want to convert
+        // the ampersand beginning &amp; because otherwise when read in,
+        // the original "&amp;" becomes "&".
+

         if (c == wxT('<') || c == wxT('>') || c == wxT('"') ||
         if (c == wxT('<') || c == wxT('>') || c == wxT('"') ||

-            (c == wxT('&') && (str.Mid(i+1, 4) != wxT("amp;"))))
+            (c == wxT('&') /* && (str.Mid(i+1, 4) != wxT("amp;")) */ ))

         {
             OutputString(stream, str.Mid(last, i - last), convMem, convFile);
             switch (c)
         {
             OutputString(stream, str.Mid(last, i - last), convMem, convFile);
             switch (c)


@@ -312,6 +476,16 @@ static void OutputStringEnt(wxOutputStream& stream, const wxString& str,
             }
             last = i + 1;
         }
             }
             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);
 }
     }
     OutputString(stream, str.Mid(last, i - last), convMem, convFile);
 }


@@ -324,26 +498,6 @@ inline static void OutputIndentation(wxOutputStream& stream, int indent)
     OutputString(stream, str, NULL, NULL);
 }
 
     OutputString(stream, str, NULL, NULL);
 }
 

-static wxOutputStream& operator <<(wxOutputStream& stream, const wxString& s)
-{
-    stream.Write(s, s.Length());
-    return stream;
-}
-
-static wxOutputStream& operator <<(wxOutputStream& stream, long l)
-{
-    wxString str;
-    str.Printf(wxT("%ld"), l);
-    return stream << str;
-}
-
-static wxOutputStream& operator <<(wxOutputStream& stream, const char c)
-{
-    wxString str;
-    str.Printf(wxT("%c"), c);
-    return stream << str;
-}
-

 // Convert a colour to a 6-digit hex string
 static wxString ColourToHexString(const wxColour& col)
 {
 // Convert a colour to a 6-digit hex string
 static wxString ColourToHexString(const wxColour& col)
 {


@@ -357,59 +511,118 @@ static wxString ColourToHexString(const wxColour& col)
 }
 
 // Convert 6-digit hex string to a colour
 }
 
 // Convert 6-digit hex string to a colour

-wxColour HexStringToColour(const wxString& hex)
+static wxColour HexStringToColour(const wxString& hex)

 {
 {

-    unsigned int r = 0;
-    unsigned int g = 0;
-    unsigned int b = 0;
-    r = wxHexToDec(hex.Mid(0, 2));
-    g = wxHexToDec(hex.Mid(2, 2));
-    b = wxHexToDec(hex.Mid(4, 2));
+    unsigned char r = (unsigned char)wxHexToDec(hex.Mid(0, 2));
+    unsigned char g = (unsigned char)wxHexToDec(hex.Mid(2, 2));
+    unsigned char b = (unsigned char)wxHexToDec(hex.Mid(4, 2));

 
     return wxColour(r, g, b);
 }
 
 
     return wxColour(r, g, b);
 }
 

-bool wxRichTextXMLHandler::SaveFile(wxRichTextBuffer *buffer, wxOutputStream& stream)
+bool wxRichTextXMLHandler::DoSaveFile(wxRichTextBuffer *buffer, wxOutputStream& stream)

 {
     if (!stream.IsOk())
         return false;
 
     wxString version(wxT("1.0") ) ;
 {
     if (!stream.IsOk())
         return false;
 
     wxString version(wxT("1.0") ) ;

+
+    bool deleteConvFile = false;
+    wxString fileEncoding;
+    wxMBConv* convFile = NULL;
+

 #if wxUSE_UNICODE
 #if wxUSE_UNICODE

-    wxString fileencoding(wxT("UTF-8")) ;
-    wxString memencoding(wxT("UTF-8")) ;
+    fileEncoding = wxT("UTF-8");
+    convFile = & wxConvUTF8;

 #else
 #else

-    wxString fileencoding(wxT("ISO-8859-1")) ;
-    wxString memencoding(wxT("ISO-8859-1")) ;
+    fileEncoding = wxT("ISO-8859-1");
+    convFile = & wxConvISO8859_1;

 #endif
 #endif

-    wxString s ;
-    
-    wxMBConv *convMem = NULL, *convFile = NULL;
+
+    // If SetEncoding has been called, change the output encoding.
+    if (!m_encoding.empty() && m_encoding.Lower() != fileEncoding.Lower())
+    {
+        if (m_encoding == wxT("<System>"))
+        {
+#if wxUSE_INTL
+            fileEncoding = wxLocale::GetSystemEncodingName();
+            // if !wxUSE_INTL, we fall back to UTF-8 or ISO-8859-1 below
+#endif
+        }
+        else
+        {
+            fileEncoding = m_encoding;
+        }
+
+        // GetSystemEncodingName may not have returned a name
+        if (fileEncoding.empty())

 #if wxUSE_UNICODE
 #if wxUSE_UNICODE

-    convFile = new wxCSConv(fileencoding);
+            fileEncoding = wxT("UTF-8");

 #else
 #else

-    if ( fileencoding != memencoding )
-    {
-        convFile = new wxCSConv(fileencoding);
-        convMem = new wxCSConv(memencoding);
+            fileEncoding = wxT("ISO-8859-1");
+#endif
+        convFile = new wxCSConv(fileEncoding);
+        deleteConvFile = true;

     }
     }

+
+#if !wxUSE_UNICODE
+    wxMBConv* convMem = wxConvCurrent;
+#else
+    wxMBConv* convMem = NULL;

 #endif
 #endif

-    
+
+    wxString s ;

     s.Printf(wxT("<?xml version=\"%s\" encoding=\"%s\"?>\n"),
     s.Printf(wxT("<?xml version=\"%s\" encoding=\"%s\"?>\n"),

-        (const wxChar*) version, (const wxChar*) fileencoding );
+             version, fileEncoding);

     OutputString(stream, s, NULL, NULL);
     OutputString(stream, wxT("<richtext version=\"1.0.0.0\" xmlns=\"http://www.wxwidgets.org\">") , NULL, NULL);
 
     int level = 1;
     OutputString(stream, s, NULL, NULL);
     OutputString(stream, wxT("<richtext version=\"1.0.0.0\" xmlns=\"http://www.wxwidgets.org\">") , NULL, NULL);
 
     int level = 1;

-    ExportXML(stream, convMem, convFile, *buffer, level);
+
+    if (buffer->GetStyleSheet() && (GetFlags() & wxRICHTEXT_HANDLER_INCLUDE_STYLESHEET))
+    {
+        OutputIndentation(stream, level);
+        wxString nameAndDescr;
+        if (!buffer->GetStyleSheet()->GetName().IsEmpty())
+            nameAndDescr << wxT(" name=\"") << buffer->GetStyleSheet()->GetName() << wxT("\"");
+        if (!buffer->GetStyleSheet()->GetDescription().IsEmpty())
+            nameAndDescr << wxT(" description=\"") << buffer->GetStyleSheet()->GetDescription() << wxT("\"");
+        OutputString(stream, wxString(wxT("<stylesheet")) + nameAndDescr + wxT(">"), 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);
 
     OutputString(stream, wxT("\n</richtext>") , NULL, NULL);
     OutputString(stream, wxT("\n"), NULL, NULL);

-    
-    delete convFile;
-    delete convMem;

 
 

-    return true;
+    if (deleteConvFile)
+        delete convFile;
+
+    return success;

 }
 
 /// Recursively export an object
 }
 
 /// Recursively export an object


@@ -427,26 +640,81 @@ bool wxRichTextXMLHandler::ExportXML(wxOutputStream& stream, wxMBConv* convMem,
     else
         objectName = wxT("object");
 
     else
         objectName = wxT("object");
 

+    bool terminateTag = true;
+

     if (obj.IsKindOf(CLASSINFO(wxRichTextPlainText)))
     {
     if (obj.IsKindOf(CLASSINFO(wxRichTextPlainText)))
     {

-        wxRichTextPlainText& text = (wxRichTextPlainText&) obj;
+        wxRichTextPlainText& textObj = (wxRichTextPlainText&) obj;

 
 

-        OutputIndentation(stream, indent);
-        stream << wxT("<") << objectName;
-        

         wxString style = CreateStyle(obj.GetAttributes(), false);
         wxString style = CreateStyle(obj.GetAttributes(), false);

-        
-        stream << style << wxT(">");
-        
-        wxString str = text.GetText();
-        if (str.Length() > 0 && (str[0] == wxT(' ') || str[str.Length()-1] == wxT(' ')))
+
+        int i;
+        int last = 0;
+        const wxString& text = textObj.GetText();
+        int len = (int) text.Length();
+        for (i = 0; i < len; i++)

         {
         {

-            stream << wxT("\"");
-            OutputStringEnt(stream, str, convMem, convFile);
-            stream << wxT("\"");
+            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);
+
+                    OutputString(stream, style + wxT(">"), convMem, convFile);
+
+                    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, 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
         else

-            OutputStringEnt(stream, str, convMem, convFile);
+            fragment = text.Mid(last, i-last);
+
+        if (last < len)
+        {
+            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
+            terminateTag = false;

     }
     else if (obj.IsKindOf(CLASSINFO(wxRichTextImage)))
     {
     }
     else if (obj.IsKindOf(CLASSINFO(wxRichTextImage)))
     {


@@ -456,37 +724,40 @@ bool wxRichTextXMLHandler::ExportXML(wxOutputStream& stream, wxMBConv* convMem,
             imageObj.MakeBlock();
 
         OutputIndentation(stream, indent);
             imageObj.MakeBlock();
 
         OutputIndentation(stream, indent);

-        stream << wxT("<") << objectName;
+        OutputString(stream, wxT("<") + objectName, convMem, convFile);

         if (!imageObj.GetImageBlock().Ok())
         {
             // No data
         if (!imageObj.GetImageBlock().Ok())
         {
             // No data

-            stream << wxT(">");
+            OutputString(stream, wxT(">"), convMem, convFile);

         }
         else
         {
         }
         else
         {

-            stream << wxString::Format(wxT(" imagetype=\"%d\""), (int) imageObj.GetImageBlock().GetImageType()) << wxT(">");
+            OutputString(stream, wxString::Format(wxT(" imagetype=\"%d\">"), (int) imageObj.GetImageBlock().GetImageType()));

         }
 
         OutputIndentation(stream, indent+1);
         }
 
         OutputIndentation(stream, indent+1);

-        stream << wxT("<data>");
+        OutputString(stream, wxT("<data>"), convMem, convFile);

 
         imageObj.GetImageBlock().WriteHex(stream);
 
 
         imageObj.GetImageBlock().WriteHex(stream);
 

-        stream << wxT("</data>");
+        OutputString(stream, wxT("</data>"), convMem, convFile);

     }
     else if (obj.IsKindOf(CLASSINFO(wxRichTextCompositeObject)))
     {
         OutputIndentation(stream, indent);
     }
     else if (obj.IsKindOf(CLASSINFO(wxRichTextCompositeObject)))
     {
         OutputIndentation(stream, indent);

-        stream << wxT("<") << objectName;
-     
+        OutputString(stream, wxT("<") + objectName, convMem, convFile);
+

         bool isPara = false;
         if (objectName == wxT("paragraph") || objectName == wxT("paragraphlayout"))
             isPara = true;
 
         wxString style = CreateStyle(obj.GetAttributes(), isPara);
         bool isPara = false;
         if (objectName == wxT("paragraph") || objectName == wxT("paragraphlayout"))
             isPara = true;
 
         wxString style = CreateStyle(obj.GetAttributes(), isPara);

-        
-        stream << style << wxT(">");
-        
+
+        if (objectName == wxT("paragraphlayout") && ((wxRichTextParagraphLayoutBox&) obj).GetPartialParagraph())
+            style << wxT(" partialparagraph=\"true\"");
+
+        OutputString(stream, style + wxT(">"), convMem, convFile);
+

         wxRichTextCompositeObject& composite = (wxRichTextCompositeObject&) obj;
         size_t i;
         for (i = 0; i < composite.GetChildCount(); i++)
         wxRichTextCompositeObject& composite = (wxRichTextCompositeObject&) obj;
         size_t i;
         for (i = 0; i < composite.GetChildCount(); i++)


@@ -499,7 +770,113 @@ bool wxRichTextXMLHandler::ExportXML(wxOutputStream& stream, wxMBConv* convMem,
     if (objectName != wxT("text"))
         OutputIndentation(stream, indent);
 
     if (objectName != wxT("text"))
         OutputIndentation(stream, indent);
 

-    stream << wxT("</") << objectName << wxT(">");
+    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("\"");
+
+    wxString descr = def->GetDescription();
+    wxString descrProp;
+    if (!descr.IsEmpty())
+        descrProp = wxT(" description=\"") + descr + wxT("\"");
+
+    if (charDef)
+    {
+        OutputIndentation(stream, level);
+        OutputString(stream, wxT("<characterstyle") + baseStyleProp + descrProp + 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 + descrProp + 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 (!paraDef->GetNextStyle().IsEmpty())
+            baseStyleProp << wxT(" basestyle=\"") << paraDef->GetNextStyle() << wxT("\"");
+
+        OutputString(stream, wxT("<paragraphstyle") + baseStyleProp + descrProp + 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;
 }
 
     return true;
 }


@@ -508,43 +885,124 @@ bool wxRichTextXMLHandler::ExportXML(wxOutputStream& stream, wxMBConv* convMem,
 wxString wxRichTextXMLHandler::CreateStyle(const wxTextAttrEx& attr, bool isPara)
 {
     wxString str;
 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("\"");
     }
     {
         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(" 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.HasFontSize())
+            str << wxT(" fontsize=\"") << attr.GetFont().GetPointSize() << wxT("\"");
+
+        //if (attr.HasFontFamily())
+        //    str << wxT(" fontfamily=\"") << attr.GetFont().GetFamily() << wxT("\"");
+
+        if (attr.HasFontItalic())
+            str << wxT(" fontstyle=\"") << attr.GetFont().GetStyle() << wxT("\"");
+
+        if (attr.HasFontWeight())
+            str << wxT(" fontweight=\"") << attr.GetFont().GetWeight() << wxT("\"");
+
+        if (attr.HasFontUnderlined())
+            str << wxT(" fontunderlined=\"") << (int) attr.GetFont().GetUnderlined() << wxT("\"");
+
+        if (attr.HasFontFaceName())
+            str << wxT(" fontface=\"") << attr.GetFont().GetFaceName() << wxT("\"");
+    }
+
+    if (attr.HasTextEffects())
+    {
+        str << wxT(" texteffects=\"");
+        str << attr.GetTextEffects();
+        str << wxT("\"");
+
+        str << wxT(" texteffectflags=\"");
+        str << attr.GetTextEffectFlags();
+        str << wxT("\"");

     }
 
     }
 

-    if (!attr.GetCharacterStyleName().IsEmpty())
-        str << wxT(" charactertyle=\"") << wxString(attr.GetCharacterStyleName()) << wxT("\"");
+    if (!attr.GetCharacterStyleName().empty())
+        str << wxT(" characterstyle=\"") << wxString(attr.GetCharacterStyleName()) << wxT("\"");

 
     if (isPara)
     {
 
     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.GetParagraphStyleName().IsEmpty())
+        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("\"");
             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("\"");
+        }
+
+        if (attr.HasPageBreak())
+        {
+            str << wxT(" pagebreak=\"1\"");
+        }
+
+        if (attr.HasOutlineLevel())
+            str << wxT(" outlinelevel=\"") << (int) attr.GetOutlineLevel() << wxT("\"");
+

     }
 
     return str;
     }
 
     return str;


@@ -560,32 +1018,55 @@ bool wxRichTextXMLHandler::GetStyle(wxTextAttrEx& attr, wxXmlNode* node, bool is
     int fontStyle = wxNORMAL;
     bool fontUnderlined = false;
 
     int fontStyle = wxNORMAL;
     bool fontUnderlined = false;
 

-    fontFacename = node->GetPropVal(wxT("fontface"), wxEmptyString);
+    int fontFlags = 0;

 
 

-    wxString value = node->GetPropVal(wxT("fontfamily"), wxEmptyString);
-    if (!value.IsEmpty())
-        fontFamily = wxAtoi(value);
+    fontFacename = node->GetAttribute(wxT("fontface"), wxEmptyString);
+    if (!fontFacename.IsEmpty())
+        fontFlags |= wxTEXT_ATTR_FONT_FACE;

 
 

-    value = node->GetPropVal(wxT("fontstyle"), wxEmptyString);
-    if (!value.IsEmpty())
+    wxString value;
+    //value = node->GetAttribute(wxT("fontfamily"), wxEmptyString);
+    //if (!value.empty())
+    //    fontFamily = wxAtoi(value);
+
+    value = node->GetAttribute(wxT("fontstyle"), wxEmptyString);
+    if (!value.empty())
+    {

         fontStyle = wxAtoi(value);
         fontStyle = wxAtoi(value);

+        fontFlags |= wxTEXT_ATTR_FONT_ITALIC;
+    }

 
 

-    value = node->GetPropVal(wxT("fontsize"), wxEmptyString);
-    if (!value.IsEmpty())
+    value = node->GetAttribute(wxT("fontsize"), wxEmptyString);
+    if (!value.empty())
+    {

         fontSize = wxAtoi(value);
         fontSize = wxAtoi(value);

+        fontFlags |= wxTEXT_ATTR_FONT_SIZE;
+    }

 
 

-    value = node->GetPropVal(wxT("fontweight"), wxEmptyString);
-    if (!value.IsEmpty())
+    value = node->GetAttribute(wxT("fontweight"), wxEmptyString);
+    if (!value.empty())
+    {

         fontWeight = wxAtoi(value);
         fontWeight = wxAtoi(value);

+        fontFlags |= wxTEXT_ATTR_FONT_WEIGHT;
+    }

 
 

-    value = node->GetPropVal(wxT("fontunderlined"), wxEmptyString);
-    if (!value.IsEmpty())
+    value = node->GetAttribute(wxT("fontunderlined"), wxEmptyString);
+    if (!value.empty())
+    {

         fontUnderlined = wxAtoi(value) != 0;
         fontUnderlined = wxAtoi(value) != 0;

+        fontFlags |= wxTEXT_ATTR_FONT_UNDERLINE;
+    }

 
 

-    attr.SetFont(* wxTheFontList->FindOrCreateFont(fontSize, fontFamily, fontStyle, fontWeight, fontUnderlined, fontFacename));
+    attr.SetFlags(fontFlags);

 
 

-    value = node->GetPropVal(wxT("textcolor"), wxEmptyString);
-    if (!value.IsEmpty())
+    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->GetAttribute(wxT("textcolor"), wxEmptyString);
+    if (!value.empty())

     {
         if (value[0] == wxT('#'))
             attr.SetTextColour(HexStringToColour(value.Mid(1)));
     {
         if (value[0] == wxT('#'))
             attr.SetTextColour(HexStringToColour(value.Mid(1)));


@@ -593,8 +1074,8 @@ bool wxRichTextXMLHandler::GetStyle(wxTextAttrEx& attr, wxXmlNode* node, bool is
             attr.SetTextColour(value);
     }
 
             attr.SetTextColour(value);
     }
 

-    value = node->GetPropVal(wxT("backgroundcolor"), wxEmptyString);
-    if (!value.IsEmpty())
+    value = node->GetAttribute(wxT("backgroundcolor"), wxEmptyString);
+    if (!value.empty())

     {
         if (value[0] == wxT('#'))
             attr.SetBackgroundColour(HexStringToColour(value.Mid(1)));
     {
         if (value[0] == wxT('#'))
             attr.SetBackgroundColour(HexStringToColour(value.Mid(1)));


@@ -602,207 +1083,139 @@ bool wxRichTextXMLHandler::GetStyle(wxTextAttrEx& attr, wxXmlNode* node, bool is
             attr.SetBackgroundColour(value);
     }
 
             attr.SetBackgroundColour(value);
     }
 

-    value = node->GetPropVal(wxT("characterstyle"), wxEmptyString);
-    if (!value.IsEmpty())
+    value = node->GetAttribute(wxT("characterstyle"), wxEmptyString);
+    if (!value.empty())

         attr.SetCharacterStyleName(value);
 
         attr.SetCharacterStyleName(value);
 

+    value = node->GetAttribute(wxT("texteffects"), wxEmptyString);
+    if (!value.IsEmpty())
+    {
+        attr.SetTextEffects(wxAtoi(value));
+    }
+
+    value = node->GetAttribute(wxT("texteffectflags"), wxEmptyString);
+    if (!value.IsEmpty())
+    {
+        attr.SetTextEffectFlags(wxAtoi(value));
+    }
+

     // Set paragraph attributes
     if (isPara)
     {
     // Set paragraph attributes
     if (isPara)
     {

-        value = node->GetPropVal(wxT("alignment"), wxEmptyString);
-        if (!value.IsEmpty())
+        value = node->GetAttribute(wxT("alignment"), wxEmptyString);
+        if (!value.empty())

             attr.SetAlignment((wxTextAttrAlignment) wxAtoi(value));
 
         int leftSubIndent = 0;
         int leftIndent = 0;
             attr.SetAlignment((wxTextAttrAlignment) wxAtoi(value));
 
         int leftSubIndent = 0;
         int leftIndent = 0;

-        value = node->GetPropVal(wxT("leftindent"), wxEmptyString);
-        if (!value.IsEmpty())
+        bool hasLeftIndent = false;
+
+        value = node->GetAttribute(wxT("leftindent"), wxEmptyString);
+        if (!value.empty())
+        {

             leftIndent = wxAtoi(value);
             leftIndent = wxAtoi(value);

-        value = node->GetPropVal(wxT("leftsubindent"), wxEmptyString);
-        if (!value.IsEmpty())
+            hasLeftIndent = true;
+        }
+
+        value = node->GetAttribute(wxT("leftsubindent"), wxEmptyString);
+        if (!value.empty())
+        {

             leftSubIndent = wxAtoi(value);
             leftSubIndent = wxAtoi(value);

-        attr.SetLeftIndent(leftIndent, leftSubIndent);
+            hasLeftIndent = true;
+        }

 
 

-        value = node->GetPropVal(wxT("rightindent"), wxEmptyString);
-        if (!value.IsEmpty())
+        if (hasLeftIndent)
+            attr.SetLeftIndent(leftIndent, leftSubIndent);
+
+        value = node->GetAttribute(wxT("rightindent"), wxEmptyString);
+        if (!value.empty())

             attr.SetRightIndent(wxAtoi(value));
 
             attr.SetRightIndent(wxAtoi(value));
 

-        value = node->GetPropVal(wxT("parspacingbefore"), wxEmptyString);
-        if (!value.IsEmpty())
+        value = node->GetAttribute(wxT("parspacingbefore"), wxEmptyString);
+        if (!value.empty())

             attr.SetParagraphSpacingBefore(wxAtoi(value));
 
             attr.SetParagraphSpacingBefore(wxAtoi(value));
 

-        value = node->GetPropVal(wxT("parspacingafter"), wxEmptyString);
-        if (!value.IsEmpty())
+        value = node->GetAttribute(wxT("parspacingafter"), wxEmptyString);
+        if (!value.empty())

             attr.SetParagraphSpacingAfter(wxAtoi(value));
 
             attr.SetParagraphSpacingAfter(wxAtoi(value));
 

-        value = node->GetPropVal(wxT("linespacing"), wxEmptyString);
-        if (!value.IsEmpty())
+        value = node->GetAttribute(wxT("linespacing"), wxEmptyString);
+        if (!value.empty())

             attr.SetLineSpacing(wxAtoi(value));
 
             attr.SetLineSpacing(wxAtoi(value));
 

-        value = node->GetPropVal(wxT("bulletstyle"), wxEmptyString);
-        if (!value.IsEmpty())
+        value = node->GetAttribute(wxT("bulletstyle"), wxEmptyString);
+        if (!value.empty())

             attr.SetBulletStyle(wxAtoi(value));
 
             attr.SetBulletStyle(wxAtoi(value));
 

-        value = node->GetPropVal(wxT("bulletnumber"), wxEmptyString);
-        if (!value.IsEmpty())
+        value = node->GetAttribute(wxT("bulletnumber"), wxEmptyString);
+        if (!value.empty())

             attr.SetBulletNumber(wxAtoi(value));
 
             attr.SetBulletNumber(wxAtoi(value));
 

-        value = node->GetPropVal(wxT("bulletsymbol"), wxEmptyString);
-        if (!value.IsEmpty())
-            attr.SetBulletSymbol(value[0]);
-
-        value = node->GetPropVal(wxT("parstyle"), wxEmptyString);
-        if (!value.IsEmpty())
-            attr.SetParagraphStyleName(value);
-    }
-
-    return true;
-}
-
-#endif
-
-IMPLEMENT_DYNAMIC_CLASS(wxRichTextHTMLHandler, wxRichTextFileHandler)
-
-/// Can we handle this filename (if using files)? By default, checks the extension.
-bool wxRichTextHTMLHandler::CanHandle(const wxString& filename) const
-{
-    wxString path, file, ext;
-    wxSplitPath(filename, & path, & file, & ext);
-
-    return (ext.Lower() == wxT("html") || ext.Lower() == wxT("htm"));
-}
-
-
-#if wxUSE_STREAMS
-bool wxRichTextHTMLHandler::LoadFile(wxRichTextBuffer *WXUNUSED(buffer), wxInputStream& WXUNUSED(stream))
-{
-    return false;
-}
+        value = node->GetAttribute(wxT("bulletsymbol"), wxEmptyString);
+        if (!value.empty())
+        {
+            wxChar ch = wxAtoi(value);
+            wxString s;
+            s << ch;
+            attr.SetBulletText(s);
+        }

 
 

-/*
- * We need to output only _changes_ in character formatting.
- */
+        value = node->GetAttribute(wxT("bullettext"), wxEmptyString);
+        if (!value.empty())
+            attr.SetBulletText(value);

 
 

-bool wxRichTextHTMLHandler::SaveFile(wxRichTextBuffer *buffer, wxOutputStream& stream)
-{
-    buffer->Defragment();
+        value = node->GetAttribute(wxT("bulletfont"), wxEmptyString);
+        if (!value.empty())
+            attr.SetBulletFont(value);

 
 

-    wxTextOutputStream str(stream);
+        value = node->GetAttribute(wxT("bulletname"), wxEmptyString);
+        if (!value.empty())
+            attr.SetBulletName(value);

 
 

-    wxTextAttrEx currentParaStyle = buffer->GetAttributes();
-    wxTextAttrEx currentCharStyle = buffer->GetAttributes();
+        value = node->GetAttribute(wxT("url"), wxEmptyString);
+        if (!value.empty())
+            attr.SetURL(value);

 
 

-    str << wxT("<html><head></head><body>\n");
+        value = node->GetAttribute(wxT("parstyle"), wxEmptyString);
+        if (!value.empty())
+            attr.SetParagraphStyleName(value);

 
 

-    wxRichTextObjectList::compatibility_iterator node = buffer->GetChildren().GetFirst();
-    while (node)
-    {
-        wxRichTextParagraph* para = wxDynamicCast(node->GetData(), wxRichTextParagraph);
-        wxASSERT (para != NULL);
+        value = node->GetAttribute(wxT("liststyle"), wxEmptyString);
+        if (!value.empty())
+            attr.SetListStyleName(value);

 
 

-        if (para)
+        value = node->GetAttribute(wxT("tabs"), wxEmptyString);
+        if (!value.empty())

         {
         {

-            OutputParagraphFormatting(currentParaStyle, para->GetAttributes(), stream, true);
-
-            wxRichTextObjectList::compatibility_iterator node2 = para->GetChildren().GetFirst();
-            while (node2)
+            wxArrayInt tabs;
+            wxStringTokenizer tkz(value, wxT(","));
+            while (tkz.HasMoreTokens())

             {
             {

-                wxRichTextObject* obj = node2->GetData();
-                wxRichTextPlainText* textObj = wxDynamicCast(obj, wxRichTextPlainText);
-                if (textObj && !textObj->IsEmpty())
-                {
-                    OutputCharacterFormatting(currentCharStyle, obj->GetAttributes(), stream, true);
-
-                    str << textObj->GetText();
-
-                    OutputCharacterFormatting(currentCharStyle, obj->GetAttributes(), stream, false);
-                }
-
-                node2 = node2->GetNext();
-            }            
-
-            OutputParagraphFormatting(currentParaStyle, para->GetAttributes(), stream, false);
+                wxString token = tkz.GetNextToken();
+                tabs.Add(wxAtoi(token));
+            }
+            attr.SetTabs(tabs);
+        }

 
 

-            str << wxT("<P>\n");
+        value = node->GetAttribute(wxT("pagebreak"), wxEmptyString);
+        if (!value.IsEmpty())
+        {
+            attr.SetPageBreak(wxAtoi(value) != 0);

         }
 
         }
 

-        node = node->GetNext();
+        value = node->GetAttribute(wxT("outlinelevel"), wxEmptyString);
+        if (!value.IsEmpty())
+        {
+            attr.SetOutlineLevel(wxAtoi(value) != 0);
+        }

     }
 
     }
 

-    str << wxT("</body></html>\n");
-

     return true;
 }
 
     return true;
 }
 

-/// Output character formatting
-void wxRichTextHTMLHandler::OutputCharacterFormatting(const wxTextAttrEx& WXUNUSED(currentStyle), const wxTextAttrEx& thisStyle, wxOutputStream& stream, bool start)
-{
-    wxTextOutputStream str(stream);
-
-    bool isBold = false;
-    bool isItalic = false;
-    bool isUnderline = false;
-    wxString faceName;
-
-    if (thisStyle.GetFont().Ok())
-    {
-        if (thisStyle.GetFont().GetWeight() == wxBOLD)
-            isBold = true;
-        if (thisStyle.GetFont().GetStyle() == wxITALIC)
-            isItalic = true;
-        if (thisStyle.GetFont().GetUnderlined())
-            isUnderline = true;
-
-        faceName = thisStyle.GetFont().GetFaceName();
-    }
-
-    if (start)
-    {
-        if (isBold)
-            str << wxT("<b>");
-        if (isItalic)
-            str << wxT("<i>");
-        if (isUnderline)
-            str << wxT("<u>");
-    }
-    else
-    {
-        if (isUnderline)
-            str << wxT("</u>");
-        if (isItalic)
-            str << wxT("</i>");
-        if (isBold)
-            str << wxT("</b>");
-    }
-}
-
-/// Output paragraph formatting
-void wxRichTextHTMLHandler::OutputParagraphFormatting(const wxTextAttrEx& WXUNUSED(currentStyle), const wxTextAttrEx& thisStyle, wxOutputStream& stream, bool start)
-{
-    // TODO: lists, indentation (using tables), fonts, right-align, ...
-
-    wxTextOutputStream str(stream);
-    bool isCentered = false;
-
-    if (thisStyle.GetAlignment() == wxTEXT_ALIGNMENT_CENTRE)
-    {
-        isCentered = true;
-    }
-
-    if (start)
-    {
-        if (isCentered)
-            str << wxT("<center>");
-    }
-    else
-    {
-        if (isCentered)
-            str << wxT("</center>");
-    }
-}
-

 #endif
 #endif

+    // wxUSE_STREAMS

 
 #endif
 
 #endif

-    // wxUSE_RICHTEXT
+    // wxUSE_RICHTEXT && wxUSE_XML