src/richtext/richtextxml.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/richtext/richtextxml.cpp
   3 // Purpose:     XML and HTML I/O for wxRichTextCtrl
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     2005-09-30
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // For compilers that support precompilation, includes "wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifdef __BORLANDC__
  16     #pragma hdrstop
  17 #endif
  18
  19 #if wxUSE_RICHTEXT && wxUSE_XML
  20
  21 #include "wx/richtext/richtextxml.h"
  22
  23 #ifndef WX_PRECOMP
  24     #include "wx/intl.h"
  25     #include "wx/module.h"
  26     #include "wx/log.h"
  27 #endif
  28
  29 #include "wx/filename.h"
  30 #include "wx/clipbrd.h"
  31 #include "wx/wfstream.h"
  32 #include "wx/sstream.h"
  33 #include "wx/txtstrm.h"
  34 #include "wx/mstream.h"
  35 #include "wx/tokenzr.h"
  36 #include "wx/stopwatch.h"
  37 #include "wx/xml/xml.h"
  38
  39 // Set to 1 for slower wxXmlDocument method, 0 for faster direct method.
  40 // If we make wxXmlDocument::Save more efficient, we might switch to this
  41 // method.
  42 #define wxRICHTEXT_USE_XMLDOCUMENT_OUTPUT 0
  43
  44 #if wxRICHTEXT_USE_XMLDOCUMENT_OUTPUT && !wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT
  45 #   error Must define wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT in richtextxml.h to use this method.
  46 #endif
  47
  48 #if !wxRICHTEXT_USE_XMLDOCUMENT_OUTPUT && !wxRICHTEXT_HAVE_DIRECT_OUTPUT
  49 #   error Must define wxRICHTEXT_HAVE_DIRECT_OUTPUT in richtextxml.h to use this method.
  50 #endif
  51
  52 // Set to 1 to time file saving
  53 #define wxRICHTEXT_USE_OUTPUT_TIMINGS 0
  54
  55 // Convert a colour to a 6-digit hex string
  56 static wxString ColourToHexString(const wxColour& col)
  57 {
  58     wxString hex;
  59
  60     hex += wxDecToHex(col.Red());
  61     hex += wxDecToHex(col.Green());
  62     hex += wxDecToHex(col.Blue());
  63
  64     return hex;
  65 }
  66
  67 // Convert 6-digit hex string to a colour
  68 static wxColour HexStringToColour(const wxString& hex)
  69 {
  70     unsigned char r = (unsigned char)wxHexToDec(hex.Mid(0, 2));
  71     unsigned char g = (unsigned char)wxHexToDec(hex.Mid(2, 2));
  72     unsigned char b = (unsigned char)wxHexToDec(hex.Mid(4, 2));
  73
  74     return wxColour(r, g, b);
  75 }
  76
  77 static inline wxString MakeString(const int& v) { return wxString::Format(wxT("%d"), v); }
  78 static inline wxString MakeString(const long& v) { return wxString::Format(wxT("%ld"), v); }
  79 static inline wxString MakeString(const double& v) { return wxString::Format(wxT("%.2f"), (float) v); }
  80 static inline wxString MakeString(const wxString& s) { return s; }
  81 static inline wxString MakeString(const wxColour& col) { return wxT("#") + ColourToHexString(col); }
  82
  83 static inline void AddString(wxString& str, const int& v) { str << wxString::Format(wxT("%d"), v); }
  84 static inline void AddString(wxString& str, const long& v) { str << wxString::Format(wxT("%ld"), v); }
  85 static inline void AddString(wxString& str, const double& v) { str << wxString::Format(wxT("%.2f"), (float) v); }
  86 static inline void AddString(wxString& str, const wxChar* s) { str << s; }
  87 static inline void AddString(wxString& str, const wxString& s) { str << s; }
  88 static inline void AddString(wxString& str, const wxColour& col) { str << wxT("#") << ColourToHexString(col); }
  89
  90 IMPLEMENT_DYNAMIC_CLASS(wxRichTextXMLHandler, wxRichTextFileHandler)
  91
  92 void wxRichTextXMLHandler::Init()
  93 {
  94 #if wxRICHTEXT_HAVE_DIRECT_OUTPUT
  95     // Used during saving
  96     m_convMem = NULL;
  97     m_convFile = NULL;
  98 #endif
  99 }
 100
 101 #if wxUSE_STREAMS
 102 bool wxRichTextXMLHandler::DoLoadFile(wxRichTextBuffer *buffer, wxInputStream& stream)
 103 {
 104     if (!stream.IsOk())
 105         return false;
 106
 107     buffer->ResetAndClearCommands();
 108     buffer->Clear();
 109
 110     wxXmlDocument* xmlDoc = new wxXmlDocument;
 111     bool success = true;
 112
 113     // This is the encoding to convert to (memory encoding rather than file encoding)
 114     wxString encoding(wxT("UTF-8"));
 115
 116 #if !wxUSE_UNICODE && wxUSE_INTL
 117     encoding = wxLocale::GetSystemEncodingName();
 118 #endif
 119
 120     if (!xmlDoc->Load(stream, encoding))
 121     {
 122         buffer->ResetAndClearCommands();
 123         success = false;
 124     }
 125     else
 126     {
 127         if (xmlDoc->GetRoot() && xmlDoc->GetRoot()->GetType() == wxXML_ELEMENT_NODE && xmlDoc->GetRoot()->GetName() == wxT("richtext"))
 128         {
 129             wxXmlNode* child = xmlDoc->GetRoot()->GetChildren();
 130             while (child)
 131             {
 132                 if (child->GetType() == wxXML_ELEMENT_NODE)
 133                 {
 134                     wxString name = child->GetName();
 135                     if (name == wxT("richtext-version"))
 136                     {
 137                     }
 138                     else
 139                         ImportXML(buffer, buffer, child);
 140                 }
 141
 142                 child = child->GetNext();
 143             }
 144         }
 145         else
 146         {
 147             success = false;
 148         }
 149     }
 150
 151     delete xmlDoc;
 152
 153     buffer->UpdateRanges();
 154
 155     return success;
 156 }
 157
 158 /// Creates an object given an XML element name
 159 wxRichTextObject* wxRichTextXMLHandler::CreateObjectForXMLName(wxRichTextObject* WXUNUSED(parent), const wxString& name) const
 160 {
 161     if (name == wxT("text") || name == wxT("symbol"))
 162         return new wxRichTextPlainText;
 163     else if (name == wxT("image"))
 164         return new wxRichTextImage;
 165     else if (name == wxT("paragraph"))
 166         return new wxRichTextParagraph;
 167     else if (name == wxT("paragraphlayout"))
 168         return new wxRichTextParagraphLayoutBox;
 169     else if (name == wxT("textbox"))
 170         return new wxRichTextBox;
 171     else if (name == wxT("cell"))
 172         return new wxRichTextCell;
 173     else if (name == wxT("table"))
 174         return new wxRichTextTable;
 175     else
 176         return NULL;
 177 }
 178
 179 /// Recursively import an object
 180 bool wxRichTextXMLHandler::ImportXML(wxRichTextBuffer* buffer, wxRichTextObject* obj, wxXmlNode* node)
 181 {
 182     bool recurse = false;
 183     obj->ImportFromXML(buffer, node, this, & recurse);
 184
 185     // TODO: how to control whether to import children.
 186
 187     wxRichTextCompositeObject* compositeParent = wxDynamicCast(obj, wxRichTextCompositeObject);
 188     if (recurse && compositeParent)
 189     {
 190         wxXmlNode* child = node->GetChildren();
 191         while (child)
 192         {
 193             if (child->GetName() != wxT("stylesheet"))
 194             {
 195                 wxRichTextObject* childObj = CreateObjectForXMLName(obj, child->GetName());
 196                 if (childObj)
 197                 {
 198                     compositeParent->AppendChild(childObj);
 199                     ImportXML(buffer, childObj, child);
 200                 }
 201             }
 202             child = child->GetNext();
 203         }
 204     }
 205
 206     return true;
 207 }
 208
 209 bool wxRichTextXMLHandler::ImportProperties(wxRichTextObject* obj, wxXmlNode* node)
 210 {
 211     wxXmlNode* child = node->GetChildren();
 212     while (child)
 213     {
 214         if (child->GetName() == wxT("properties"))
 215         {
 216             wxXmlNode* propertyChild = child->GetChildren();
 217             while (propertyChild)
 218             {
 219                 if (propertyChild->GetName() == wxT("property"))
 220                 {
 221                     wxString name = propertyChild->GetAttribute(wxT("name"), wxEmptyString);
 222                     wxString value = propertyChild->GetAttribute(wxT("value"), wxEmptyString);
 223                     wxString type = propertyChild->GetAttribute(wxT("type"), wxEmptyString);
 224
 225                     wxVariant var = MakePropertyFromString(name, value, type);
 226                     if (!var.IsNull())
 227                     {
 228                         obj->GetProperties().SetProperty(var);
 229                     }
 230                 }
 231                 propertyChild = propertyChild->GetNext();
 232             }
 233         }
 234         child = child->GetNext();
 235     }
 236     return true;
 237 }
 238
 239 bool wxRichTextXMLHandler::ImportStyleDefinition(wxRichTextStyleSheet* sheet, wxXmlNode* node)
 240 {
 241     wxString styleType = node->GetName();
 242     wxString styleName = node->GetAttribute(wxT("name"), wxEmptyString);
 243     wxString baseStyleName = node->GetAttribute(wxT("basestyle"), wxEmptyString);
 244
 245     if (styleName.empty())
 246         return false;
 247
 248     if (styleType == wxT("characterstyle"))
 249     {
 250         wxRichTextCharacterStyleDefinition* def = new wxRichTextCharacterStyleDefinition(styleName);
 251         def->SetBaseStyle(baseStyleName);
 252
 253         wxXmlNode* child = node->GetChildren();
 254         while (child)
 255         {
 256             if (child->GetName() == wxT("style"))
 257             {
 258                 wxRichTextAttr attr;
 259                 ImportStyle(attr, child, false);
 260                 def->SetStyle(attr);
 261             }
 262             child = child->GetNext();
 263         }
 264
 265         sheet->AddCharacterStyle(def);
 266     }
 267     else if (styleType == wxT("paragraphstyle"))
 268     {
 269         wxRichTextParagraphStyleDefinition* def = new wxRichTextParagraphStyleDefinition(styleName);
 270
 271         wxString nextStyleName = node->GetAttribute(wxT("nextstyle"), wxEmptyString);
 272         def->SetNextStyle(nextStyleName);
 273         def->SetBaseStyle(baseStyleName);
 274
 275         wxXmlNode* child = node->GetChildren();
 276         while (child)
 277         {
 278             if (child->GetName() == wxT("style"))
 279             {
 280                 wxRichTextAttr attr;
 281                 ImportStyle(attr, child, true);
 282                 def->SetStyle(attr);
 283             }
 284             child = child->GetNext();
 285         }
 286
 287         sheet->AddParagraphStyle(def);
 288     }
 289     else if (styleType == wxT("boxstyle"))
 290     {
 291         wxRichTextBoxStyleDefinition* def = new wxRichTextBoxStyleDefinition(styleName);
 292
 293         def->SetBaseStyle(baseStyleName);
 294
 295         wxXmlNode* child = node->GetChildren();
 296         while (child)
 297         {
 298             if (child->GetName() == wxT("style"))
 299             {
 300                 wxRichTextAttr attr;
 301                 ImportStyle(attr, child, true);
 302                 def->SetStyle(attr);
 303             }
 304             child = child->GetNext();
 305         }
 306
 307         sheet->AddBoxStyle(def);
 308     }
 309     else if (styleType == wxT("liststyle"))
 310     {
 311         wxRichTextListStyleDefinition* def = new wxRichTextListStyleDefinition(styleName);
 312
 313         wxString nextStyleName = node->GetAttribute(wxT("nextstyle"), wxEmptyString);
 314         def->SetNextStyle(nextStyleName);
 315         def->SetBaseStyle(baseStyleName);
 316
 317         wxXmlNode* child = node->GetChildren();
 318         while (child)
 319         {
 320             if (child->GetName() == wxT("style"))
 321             {
 322                 wxRichTextAttr attr;
 323                 ImportStyle(attr, child, true);
 324
 325                 wxString styleLevel = child->GetAttribute(wxT("level"), wxEmptyString);
 326                 if (styleLevel.empty())
 327                 {
 328                     def->SetStyle(attr);
 329                 }
 330                 else
 331                 {
 332                     int level = wxAtoi(styleLevel);
 333                     if (level > 0 && level <= 10)
 334                     {
 335                         def->SetLevelAttributes(level-1, attr);
 336                     }
 337                 }
 338             }
 339             child = child->GetNext();
 340         }
 341
 342         sheet->AddListStyle(def);
 343     }
 344
 345     return true;
 346 }
 347
 348 //-----------------------------------------------------------------------------
 349 //  xml support routines
 350 //-----------------------------------------------------------------------------
 351
 352 bool wxRichTextXMLHandler::HasParam(wxXmlNode* node, const wxString& param)
 353 {
 354     return (GetParamNode(node, param) != NULL);
 355 }
 356
 357 wxXmlNode *wxRichTextXMLHandler::GetParamNode(wxXmlNode* node, const wxString& param)
 358 {
 359     wxCHECK_MSG(node, NULL, wxT("You can't access node data before it was initialized!"));
 360
 361     wxXmlNode *n = node->GetChildren();
 362
 363     while (n)
 364     {
 365         if (n->GetType() == wxXML_ELEMENT_NODE && n->GetName() == param)
 366             return n;
 367         n = n->GetNext();
 368     }
 369     return NULL;
 370 }
 371
 372
 373 wxString wxRichTextXMLHandler::GetNodeContent(wxXmlNode *node)
 374 {
 375     wxXmlNode *n = node;
 376     if (n == NULL) return wxEmptyString;
 377     n = n->GetChildren();
 378
 379     while (n)
 380     {
 381         if (n->GetType() == wxXML_TEXT_NODE ||
 382             n->GetType() == wxXML_CDATA_SECTION_NODE)
 383             return n->GetContent();
 384         n = n->GetNext();
 385     }
 386     return wxEmptyString;
 387 }
 388
 389
 390 wxString wxRichTextXMLHandler::GetParamValue(wxXmlNode *node, const wxString& param)
 391 {
 392     if (param.empty())
 393         return GetNodeContent(node);
 394     else
 395         return GetNodeContent(GetParamNode(node, param));
 396 }
 397
 398 wxString wxRichTextXMLHandler::GetText(wxXmlNode *node, const wxString& param, bool WXUNUSED(translate))
 399 {
 400     wxXmlNode *parNode = GetParamNode(node, param);
 401     if (!parNode)
 402         parNode = node;
 403     wxString str1(GetNodeContent(parNode));
 404     return str1;
 405 }
 406
 407 wxXmlNode* wxRichTextXMLHandler::FindNode(wxXmlNode* node, const wxString& name)
 408 {
 409     if (node->GetName() == name && name == wxT("stylesheet"))
 410         return node;
 411
 412     wxXmlNode* child = node->GetChildren();
 413     while (child)
 414     {
 415         if (child->GetName() == name)
 416             return child;
 417         child = child->GetNext();
 418     }
 419     return NULL;
 420 }
 421
 422 // For use with earlier versions of wxWidgets
 423 #ifndef WXUNUSED_IN_UNICODE
 424 #if wxUSE_UNICODE
 425 #define WXUNUSED_IN_UNICODE(x) WXUNUSED(x)
 426 #else
 427 #define WXUNUSED_IN_UNICODE(x) x
 428 #endif
 429 #endif
 430
 431 // write string to output
 432 inline static void OutputString(wxOutputStream& stream, const wxString& str,
 433                                 wxMBConv *WXUNUSED_IN_UNICODE(convMem), wxMBConv *convFile)
 434 {
 435     if (str.empty()) return;
 436 #if wxUSE_UNICODE
 437     if (convFile)
 438     {
 439         const wxWX2MBbuf buf(str.mb_str(*convFile));
 440         stream.Write((const char*)buf, strlen((const char*)buf));
 441     }
 442     else
 443     {
 444         const wxWX2MBbuf buf(str.mb_str(wxConvUTF8));
 445         stream.Write((const char*)buf, strlen((const char*)buf));
 446     }
 447 #else
 448     if ( convFile == NULL )
 449         stream.Write(str.mb_str(), str.Len());
 450     else
 451     {
 452         wxString str2(str.wc_str(*convMem), *convFile);
 453         stream.Write(str2.mb_str(), str2.Len());
 454     }
 455 #endif
 456 }
 457
 458 static void OutputIndentation(wxOutputStream& stream, int indent)
 459 {
 460     wxString str = wxT("\n");
 461     for (int i = 0; i < indent; i++)
 462         str << wxT(' ') << wxT(' ');
 463     ::OutputString(stream, str, NULL, NULL);
 464 }
 465
 466 // Same as above, but create entities first.
 467 // Translates '<' to "&lt;", '>' to "&gt;" and '&' to "&amp;"
 468 static void OutputStringEnt(wxOutputStream& stream, const wxString& str,
 469                             wxMBConv *convMem = NULL, wxMBConv *convFile = NULL)
 470 {
 471     wxString buf;
 472     size_t i, last, len;
 473     wxChar c;
 474
 475     len = str.Len();
 476     last = 0;
 477     for (i = 0; i < len; i++)
 478     {
 479         c = str.GetChar(i);
 480
 481         // Original code excluded "&amp;" but we _do_ want to convert
 482         // the ampersand beginning &amp; because otherwise when read in,
 483         // the original "&amp;" becomes "&".
 484
 485         if (c == wxT('<') || c == wxT('>') || c == wxT('"') ||
 486             (c == wxT('&') /* && (str.Mid(i+1, 4) != wxT("amp;")) */ ))
 487         {
 488             OutputString(stream, str.Mid(last, i - last), convMem, convFile);
 489             switch (c)
 490             {
 491             case wxT('<'):
 492                 OutputString(stream, wxT("&lt;"), NULL, NULL);
 493                 break;
 494             case wxT('>'):
 495                 OutputString(stream, wxT("&gt;"), NULL, NULL);
 496                 break;
 497             case wxT('&'):
 498                 OutputString(stream, wxT("&amp;"), NULL, NULL);
 499                 break;
 500             case wxT('"'):
 501                 OutputString(stream, wxT("&quot;"), NULL, NULL);
 502                 break;
 503             default: break;
 504             }
 505             last = i + 1;
 506         }
 507         else if (wxUChar(c) > 127)
 508         {
 509             OutputString(stream, str.Mid(last, i - last), convMem, convFile);
 510
 511             wxString s(wxT("&#"));
 512 #if wxUSE_UNICODE
 513             s << (int) c;
 514 #else
 515             s << (int) wxUChar(c);
 516 #endif
 517             s << wxT(";");
 518             OutputString(stream, s, NULL, NULL);
 519             last = i + 1;
 520         }
 521     }
 522     OutputString(stream, str.Mid(last, i - last), convMem, convFile);
 523 }
 524
 525 void wxRichTextXMLHandler::OutputString(wxOutputStream& stream, const wxString& str)
 526 {
 527     ::OutputString(stream, str, m_convMem, m_convFile);
 528 }
 529
 530 void wxRichTextXMLHandler::OutputStringEnt(wxOutputStream& stream, const wxString& str)
 531 {
 532     ::OutputStringEnt(stream, str, m_convMem, m_convFile);
 533 }
 534
 535 void wxRichTextXMLHandler::OutputIndentation(wxOutputStream& stream, int indent)
 536 {
 537     wxString str = wxT("\n");
 538     for (int i = 0; i < indent; i++)
 539         str << wxT(' ') << wxT(' ');
 540     ::OutputString(stream, str, NULL, NULL);
 541 }
 542
 543 wxString wxRichTextXMLHandler::AttributeToXML(const wxString& str)
 544 {
 545     wxString str1;
 546     size_t i, last, len;
 547     wxChar c;
 548
 549     len = str.Len();
 550     last = 0;
 551     for (i = 0; i < len; i++)
 552     {
 553         c = str.GetChar(i);
 554
 555         // Original code excluded "&amp;" but we _do_ want to convert
 556         // the ampersand beginning &amp; because otherwise when read in,
 557         // the original "&amp;" becomes "&".
 558
 559         if (c == wxT('<') || c == wxT('>') || c == wxT('"') ||
 560             (c == wxT('&') /* && (str.Mid(i+1, 4) != wxT("amp;")) */ ))
 561         {
 562             str1 += str.Mid(last, i - last);
 563             switch (c)
 564             {
 565             case wxT('<'):
 566                 str1 += wxT("&lt;");
 567                 break;
 568             case wxT('>'):
 569                 str1 += wxT("&gt;");
 570                 break;
 571             case wxT('&'):
 572                 str1 += wxT("&amp;");
 573                 break;
 574             case wxT('"'):
 575                 str1 += wxT("&quot;");
 576                 break;
 577             default: break;
 578             }
 579             last = i + 1;
 580         }
 581         else if (wxUChar(c) > 127)
 582         {
 583             str1 += str.Mid(last, i - last);
 584
 585             wxString s(wxT("&#"));
 586 #if wxUSE_UNICODE
 587             s << (int) c;
 588 #else
 589             s << (int) wxUChar(c);
 590 #endif
 591             s << wxT(";");
 592             str1 += s;
 593             last = i + 1;
 594         }
 595     }
 596     str1 += str.Mid(last, i - last);
 597     return str1;
 598 }
 599
 600 #if wxRICHTEXT_HAVE_DIRECT_OUTPUT
 601
 602 static inline void AddAttribute(wxString& str, const wxString& name, const int& v)
 603 {
 604     str << wxT(" ") << name << wxT("=\"") << wxString::Format(wxT("%d"), v) << wxT("\"");
 605 }
 606
 607 static inline void AddAttribute(wxString& str, const wxString& name, const long& v)
 608 {
 609     str << wxT(" ") << name << wxT("=\"") << wxString::Format(wxT("%ld"), v) << wxT("\"");
 610 }
 611
 612 static inline void AddAttribute(wxString& str, const wxString& name, const double& v)
 613 {
 614     str << wxT(" ") << name << wxT("=\"") << wxString::Format(wxT("%.2f"), (float) v) << wxT("\"");
 615 }
 616
 617 static inline void AddAttribute(wxString& str, const wxString& name, const wxChar* s)
 618 {
 619     str << wxT(" ") << name << wxT("=\"") << s << wxT("\"");
 620 }
 621
 622 static inline void AddAttribute(wxString& str, const wxString& name, const wxString& s)
 623 {
 624     str << wxT(" ") << name << wxT("=\"") << s << wxT("\"");
 625 }
 626
 627 static inline void AddAttribute(wxString& str, const wxString& name, const wxColour& col)
 628 {
 629     str << wxT(" ") << name << wxT("=\"") << wxT("#") << ColourToHexString(col) << wxT("\"");
 630 }
 631
 632 static inline void AddAttribute(wxString& str, const wxString& name, const wxTextAttrDimension& dim)
 633 {
 634     if (dim.IsValid())
 635     {
 636         wxString value = MakeString(dim.GetValue()) + wxT(",") + MakeString((int) dim.GetFlags());
 637         str << wxT(" ") << name << wxT("=\"");
 638         str << value;
 639         str << wxT("\"");
 640     }
 641 }
 642
 643 static inline void AddAttribute(wxString& str, const wxString& rootName, const wxTextAttrDimensions& dims)
 644 {
 645     if (dims.GetLeft().IsValid())
 646         AddAttribute(str, rootName + wxString(wxT("-left")), dims.GetLeft());
 647     if (dims.GetRight().IsValid())
 648         AddAttribute(str, rootName + wxString(wxT("-right")), dims.GetRight());
 649     if (dims.GetTop().IsValid())
 650         AddAttribute(str, rootName + wxString(wxT("-top")), dims.GetTop());
 651     if (dims.GetBottom().IsValid())
 652         AddAttribute(str, rootName + wxString(wxT("-bottom")), dims.GetBottom());
 653 }
 654
 655 static inline void AddAttribute(wxString& str, const wxString& rootName, const wxTextAttrBorder& border)
 656 {
 657     if (border.HasStyle())
 658         AddAttribute(str, rootName + wxString(wxT("-style")), border.GetStyle());
 659     if (border.HasColour())
 660         AddAttribute(str, rootName + wxString(wxT("-color")), border.GetColour());
 661     if (border.HasWidth())
 662         AddAttribute(str, rootName + wxString(wxT("-width")), border.GetWidth());
 663 }
 664
 665 static inline void AddAttribute(wxString& str, const wxString& rootName, const wxTextAttrBorders& borders)
 666 {
 667     AddAttribute(str, rootName + wxString(wxT("-left")), borders.GetLeft());
 668     AddAttribute(str, rootName + wxString(wxT("-right")), borders.GetRight());
 669     AddAttribute(str, rootName + wxString(wxT("-top")), borders.GetTop());
 670     AddAttribute(str, rootName + wxString(wxT("-bottom")), borders.GetBottom());
 671 }
 672
 673 #endif
 674     // wxRICHTEXT_HAVE_DIRECT_OUTPUT
 675
 676 #if wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT
 677
 678 static inline void AddAttribute(wxXmlNode* node, const wxString& name, const int& v)
 679 {
 680     node->AddAttribute(name, MakeString(v));
 681 }
 682
 683 static inline void AddAttribute(wxXmlNode* node, const wxString& name, const long& v)
 684 {
 685     node->AddAttribute(name, MakeString(v));
 686 }
 687
 688 static inline void AddAttribute(wxXmlNode* node, const wxString& name, const double& v)
 689 {
 690     node->AddAttribute(name, MakeString(v));
 691 }
 692
 693 static inline void AddAttribute(wxXmlNode* node, const wxString& name, const wxString& s)
 694 {
 695     node->AddAttribute(name, s);
 696 }
 697
 698 static inline void AddAttribute(wxXmlNode* node, const wxString& name, const wxColour& col)
 699 {
 700     node->AddAttribute(name, MakeString(col));
 701 }
 702
 703 static inline void AddAttribute(wxXmlNode* node, const wxString& name, const wxTextAttrDimension& dim)
 704 {
 705     if (dim.IsValid())
 706     {
 707         wxString value = MakeString(dim.GetValue()) + wxT(",") + MakeString(dim.GetFlags());
 708         AddAttribute(node, name, value);
 709     }
 710 }
 711
 712 static inline void AddAttribute(wxXmlNode* node, const wxString& rootName, const wxTextAttrDimensions& dims)
 713 {
 714     if (dims.GetLeft().IsValid())
 715         AddAttribute(node, rootName + wxString(wxT("-left")), dims.GetLeft());
 716     if (dims.GetRight().IsValid())
 717         AddAttribute(node, rootName + wxString(wxT("-right")), dims.GetRight());
 718     if (dims.GetTop().IsValid())
 719         AddAttribute(node, rootName + wxString(wxT("-top")), dims.GetTop());
 720     if (dims.GetBottom().IsValid())
 721         AddAttribute(node, rootName + wxString(wxT("-bottom")), dims.GetBottom());
 722 }
 723
 724 static inline void AddAttribute(wxXmlNode* node, const wxString& rootName, const wxTextAttrBorder& border)
 725 {
 726     if (border.HasStyle())
 727         AddAttribute(node, rootName + wxString(wxT("-style")), border.GetStyle());
 728     if (border.HasColour())
 729         AddAttribute(node, rootName + wxString(wxT("-color")), border.GetColour());
 730     if (border.HasWidth())
 731         AddAttribute(node, rootName + wxString(wxT("-width")), border.GetWidth());
 732 }
 733
 734 static inline void AddAttribute(wxXmlNode* node, const wxString& rootName, const wxTextAttrBorders& borders)
 735 {
 736     AddAttribute(node, rootName + wxString(wxT("-left")), borders.GetLeft());
 737     AddAttribute(node, rootName + wxString(wxT("-right")), borders.GetRight());
 738     AddAttribute(node, rootName + wxString(wxT("-top")), borders.GetTop());
 739     AddAttribute(node, rootName + wxString(wxT("-bottom")), borders.GetBottom());
 740 }
 741 #endif
 742     // wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT
 743
 744 bool wxRichTextXMLHandler::DoSaveFile(wxRichTextBuffer *buffer, wxOutputStream& stream)
 745 {
 746     if (!stream.IsOk())
 747         return false;
 748
 749     wxString version(wxT("1.0") ) ;
 750
 751     bool deleteConvFile = false;
 752     wxString fileEncoding;
 753     //wxMBConv* convFile = NULL;
 754
 755 #if wxUSE_UNICODE
 756     fileEncoding = wxT("UTF-8");
 757     m_convFile = & wxConvUTF8;
 758 #else
 759     fileEncoding = wxT("ISO-8859-1");
 760     m_convFile = & wxConvISO8859_1;
 761 #endif
 762
 763     // If SetEncoding has been called, change the output encoding.
 764     if (!m_encoding.empty() && m_encoding.Lower() != fileEncoding.Lower())
 765     {
 766         if (m_encoding == wxT("<System>"))
 767         {
 768 #if wxUSE_INTL
 769             fileEncoding = wxLocale::GetSystemEncodingName();
 770             // if !wxUSE_INTL, we fall back to UTF-8 or ISO-8859-1 below
 771 #endif
 772         }
 773         else
 774         {
 775             fileEncoding = m_encoding;
 776         }
 777
 778         // GetSystemEncodingName may not have returned a name
 779         if (fileEncoding.empty())
 780 #if wxUSE_UNICODE
 781             fileEncoding = wxT("UTF-8");
 782 #else
 783             fileEncoding = wxT("ISO-8859-1");
 784 #endif
 785         m_convFile = new wxCSConv(fileEncoding);
 786         deleteConvFile = true;
 787     }
 788
 789 #if wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT && wxRICHTEXT_USE_XMLDOCUMENT_OUTPUT
 790 #if wxRICHTEXT_USE_OUTPUT_TIMINGS
 791     wxStopWatch stopwatch;
 792 #endif
 793     wxXmlDocument* doc = new wxXmlDocument;
 794     doc->SetFileEncoding(fileEncoding);
 795
 796     wxXmlNode* rootNode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("richtext"));
 797     doc->SetRoot(rootNode);
 798     rootNode->AddAttribute(wxT("version"), wxT("1.0.0.0"));
 799     rootNode->AddAttribute(wxT("xmlns"), wxT("http://www.wxwidgets.org"));
 800
 801     if (buffer->GetStyleSheet() && (GetFlags() & wxRICHTEXT_HANDLER_INCLUDE_STYLESHEET))
 802     {
 803         wxXmlNode* styleSheetNode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("stylesheet"));
 804         rootNode->AddChild(styleSheetNode);
 805
 806         wxString nameAndDescr;
 807
 808         if (!buffer->GetStyleSheet()->GetName().empty())
 809             styleSheetNode->AddAttribute(wxT("name"), buffer->GetStyleSheet()->GetName());
 810
 811         if (!buffer->GetStyleSheet()->GetDescription().empty())
 812             styleSheetNode->AddAttribute(wxT("description"), buffer->GetStyleSheet()->GetDescription());
 813
 814         int i;
 815         for (i = 0; i < (int) buffer->GetStyleSheet()->GetCharacterStyleCount(); i++)
 816         {
 817             wxRichTextCharacterStyleDefinition* def = buffer->GetStyleSheet()->GetCharacterStyle(i);
 818             ExportStyleDefinition(styleSheetNode, def);
 819         }
 820
 821         for (i = 0; i < (int) buffer->GetStyleSheet()->GetParagraphStyleCount(); i++)
 822         {
 823             wxRichTextParagraphStyleDefinition* def = buffer->GetStyleSheet()->GetParagraphStyle(i);
 824             ExportStyleDefinition(styleSheetNode, def);
 825         }
 826
 827         for (i = 0; i < (int) buffer->GetStyleSheet()->GetListStyleCount(); i++)
 828         {
 829             wxRichTextListStyleDefinition* def = buffer->GetStyleSheet()->GetListStyle(i);
 830             ExportStyleDefinition(styleSheetNode, def);
 831         }
 832
 833         for (i = 0; i < (int) buffer->GetStyleSheet()->GetBoxStyleCount(); i++)
 834         {
 835             wxRichTextBoxStyleDefinition* def = buffer->GetStyleSheet()->GetBoxStyle(i);
 836             ExportStyleDefinition(styleSheetNode, def);
 837         }
 838     }
 839     bool success = ExportXML(rootNode, *buffer);
 840 #if wxRICHTEXT_USE_OUTPUT_TIMINGS
 841     long t = stopwatch.Time();
 842     wxLogDebug(wxT("Creating the document took %ldms"), t);
 843     wxMessageBox(wxString::Format(wxT("Creating the document took %ldms"), t));
 844 #endif
 845     if (success)
 846     {
 847 #if wxRICHTEXT_USE_OUTPUT_TIMINGS
 848         wxStopWatch s2;
 849 #endif
 850         success = doc->Save(stream);
 851 #if wxRICHTEXT_USE_OUTPUT_TIMINGS
 852         long t2 = s2.Time();
 853         wxLogDebug(wxT("Save() took %ldms"), t2);
 854         wxMessageBox(wxString::Format(wxT("Save() took %ldms"), t2));
 855 #endif
 856     }
 857     delete doc;
 858     doc = NULL;
 859
 860 #else
 861     // !(wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT && wxRICHTEXT_USE_XMLDOCUMENT_OUTPUT)
 862
 863 #if !wxUSE_UNICODE
 864     m_convMem = wxConvCurrent;
 865 #else
 866     m_convMem = NULL;
 867 #endif
 868
 869     wxString s ;
 870     s.Printf(wxT("<?xml version=\"%s\" encoding=\"%s\"?>\n"),
 871              version, fileEncoding);
 872     OutputString(stream, s);
 873     OutputString(stream, wxT("<richtext version=\"1.0.0.0\" xmlns=\"http://www.wxwidgets.org\">"));
 874
 875     int level = 1;
 876
 877     if (buffer->GetStyleSheet() && (GetFlags() & wxRICHTEXT_HANDLER_INCLUDE_STYLESHEET))
 878     {
 879         OutputIndentation(stream, level);
 880         wxString nameAndDescr;
 881         if (!buffer->GetStyleSheet()->GetName().empty())
 882             nameAndDescr << wxT(" name=\"") << buffer->GetStyleSheet()->GetName() << wxT("\"");
 883         if (!buffer->GetStyleSheet()->GetDescription().empty())
 884             nameAndDescr << wxT(" description=\"") << buffer->GetStyleSheet()->GetDescription() << wxT("\"");
 885         OutputString(stream, wxString(wxT("<stylesheet")) + nameAndDescr + wxT(">"));
 886
 887         int i;
 888
 889         for (i = 0; i < (int) buffer->GetStyleSheet()->GetCharacterStyleCount(); i++)
 890         {
 891             wxRichTextCharacterStyleDefinition* def = buffer->GetStyleSheet()->GetCharacterStyle(i);
 892             ExportStyleDefinition(stream, def, level + 1);
 893         }
 894
 895         for (i = 0; i < (int) buffer->GetStyleSheet()->GetParagraphStyleCount(); i++)
 896         {
 897             wxRichTextParagraphStyleDefinition* def = buffer->GetStyleSheet()->GetParagraphStyle(i);
 898             ExportStyleDefinition(stream, def, level + 1);
 899         }
 900
 901         for (i = 0; i < (int) buffer->GetStyleSheet()->GetListStyleCount(); i++)
 902         {
 903             wxRichTextListStyleDefinition* def = buffer->GetStyleSheet()->GetListStyle(i);
 904             ExportStyleDefinition(stream, def, level + 1);
 905         }
 906
 907         for (i = 0; i < (int) buffer->GetStyleSheet()->GetBoxStyleCount(); i++)
 908         {
 909             wxRichTextBoxStyleDefinition* def = buffer->GetStyleSheet()->GetBoxStyle(i);
 910             ExportStyleDefinition(stream, def, level + 1);
 911         }
 912
 913         OutputIndentation(stream, level);
 914         OutputString(stream, wxT("</stylesheet>"));
 915     }
 916
 917
 918     bool success = ExportXML(stream, *buffer, level);
 919
 920     OutputString(stream, wxT("\n</richtext>"));
 921     OutputString(stream, wxT("\n"));
 922
 923     if (deleteConvFile)
 924         delete m_convFile;
 925     m_convFile = NULL;
 926     m_convMem = NULL;
 927 #endif
 928
 929     return success;
 930 }
 931
 932 #if wxRICHTEXT_HAVE_DIRECT_OUTPUT
 933
 934 /// Recursively export an object
 935 bool wxRichTextXMLHandler::ExportXML(wxOutputStream& stream, wxRichTextObject& obj, int indent)
 936 {
 937     obj.ExportXML(stream, indent, this);
 938
 939     return true;
 940 }
 941
 942 bool wxRichTextXMLHandler::ExportStyleDefinition(wxOutputStream& stream, wxRichTextStyleDefinition* def, int level)
 943 {
 944     wxRichTextCharacterStyleDefinition* charDef = wxDynamicCast(def, wxRichTextCharacterStyleDefinition);
 945     wxRichTextParagraphStyleDefinition* paraDef = wxDynamicCast(def, wxRichTextParagraphStyleDefinition);
 946     wxRichTextListStyleDefinition* listDef = wxDynamicCast(def, wxRichTextListStyleDefinition);
 947     wxRichTextBoxStyleDefinition* boxDef = wxDynamicCast(def, wxRichTextBoxStyleDefinition);
 948
 949     wxString name = def->GetName();
 950     wxString nameProp;
 951     if (!name.empty())
 952         nameProp = wxT(" name=\"") + AttributeToXML(name) + wxT("\"");
 953
 954     wxString baseStyle = def->GetBaseStyle();
 955     wxString baseStyleProp;
 956     if (!baseStyle.empty())
 957         baseStyleProp = wxT(" basestyle=\"") + AttributeToXML(baseStyle) + wxT("\"");
 958
 959     wxString descr = def->GetDescription();
 960     wxString descrProp;
 961     if (!descr.empty())
 962         descrProp = wxT(" description=\"") + AttributeToXML(descr) + wxT("\"");
 963
 964     if (charDef)
 965     {
 966         OutputIndentation(stream, level);
 967         OutputString(stream, wxT("<characterstyle") + nameProp + baseStyleProp + descrProp + wxT(">"));
 968
 969         level ++;
 970
 971         wxString style = AddAttributes(def->GetStyle(), false);
 972
 973         OutputIndentation(stream, level);
 974         OutputString(stream, wxT("<style ") + style + wxT(">"));
 975
 976         OutputIndentation(stream, level);
 977         OutputString(stream, wxT("</style>"));
 978
 979         level --;
 980
 981         OutputIndentation(stream, level);
 982         OutputString(stream, wxT("</characterstyle>"));
 983     }
 984     else if (listDef)
 985     {
 986         OutputIndentation(stream, level);
 987
 988         if (!listDef->GetNextStyle().empty())
 989             baseStyleProp << wxT(" nextstyle=\"") << AttributeToXML(listDef->GetNextStyle()) << wxT("\"");
 990
 991         OutputString(stream, wxT("<liststyle") + nameProp + baseStyleProp + descrProp + wxT(">"));
 992
 993         level ++;
 994
 995         wxString style = AddAttributes(def->GetStyle(), true);
 996
 997         OutputIndentation(stream, level);
 998         OutputString(stream, wxT("<style ") + style + wxT(">"));
 999
1000         OutputIndentation(stream, level);
1001         OutputString(stream, wxT("</style>"));
1002
1003         int i;
1004         for (i = 0; i < 10; i ++)
1005         {
1006             wxRichTextAttr* levelAttr = listDef->GetLevelAttributes(i);
1007             if (levelAttr)
1008             {
1009                 wxString style = AddAttributes(def->GetStyle(), true);
1010                 wxString levelStr = wxString::Format(wxT(" level=\"%d\" "), (i+1));
1011
1012                 OutputIndentation(stream, level);
1013                 OutputString(stream, wxT("<style ") + levelStr + style + wxT(">"));
1014
1015                 OutputIndentation(stream, level);
1016                 OutputString(stream, wxT("</style>"));
1017             }
1018         }
1019
1020         level --;
1021
1022         OutputIndentation(stream, level);
1023         OutputString(stream, wxT("</liststyle>"));
1024     }
1025     else if (paraDef)
1026     {
1027         OutputIndentation(stream, level);
1028
1029         if (!paraDef->GetNextStyle().empty())
1030             baseStyleProp << wxT(" nextstyle=\"") << AttributeToXML(paraDef->GetNextStyle()) << wxT("\"");
1031
1032         OutputString(stream, wxT("<paragraphstyle") + nameProp + baseStyleProp + descrProp + wxT(">"));
1033
1034         level ++;
1035
1036         wxString style = AddAttributes(def->GetStyle(), true);
1037
1038         OutputIndentation(stream, level);
1039         OutputString(stream, wxT("<style ") + style + wxT(">"));
1040
1041         OutputIndentation(stream, level);
1042         OutputString(stream, wxT("</style>"));
1043
1044         level --;
1045
1046         OutputIndentation(stream, level);
1047         OutputString(stream, wxT("</paragraphstyle>"));
1048     }
1049     else if (boxDef)
1050     {
1051         OutputIndentation(stream, level);
1052
1053         OutputString(stream, wxT("<boxstyle") + nameProp + baseStyleProp + descrProp + wxT(">"));
1054
1055         level ++;
1056
1057         wxString style = AddAttributes(def->GetStyle(), true);
1058
1059         OutputIndentation(stream, level);
1060         OutputString(stream, wxT("<style ") + style + wxT(">"));
1061
1062         OutputIndentation(stream, level);
1063         OutputString(stream, wxT("</style>"));
1064
1065         level --;
1066
1067         OutputIndentation(stream, level);
1068         OutputString(stream, wxT("</boxstyle>"));
1069     }
1070
1071
1072     return true;
1073 }
1074
1075 /// Create a string containing style attributes
1076 wxString wxRichTextXMLHandler::AddAttributes(const wxRichTextAttr& attr, bool isPara)
1077 {
1078     wxString str;
1079     if (attr.HasTextColour() && attr.GetTextColour().IsOk())
1080         AddAttribute(str, wxT("textcolor"), attr.GetTextColour());
1081
1082     if (attr.HasBackgroundColour() && attr.GetBackgroundColour().IsOk())
1083         AddAttribute(str, wxT("bgcolor"), attr.GetBackgroundColour());
1084
1085     if (attr.HasFontSize())
1086         AddAttribute(str, wxT("fontsize"), attr.GetFontSize());
1087
1088     if (attr.HasFontFamily())
1089         AddAttribute(str, wxT("fontfamily"), attr.GetFontFamily());
1090
1091     if (attr.HasFontItalic())
1092         AddAttribute(str, wxT("fontstyle"), attr.GetFontStyle());
1093
1094     if (attr.HasFontWeight())
1095         AddAttribute(str, wxT("fontweight"), attr.GetFontWeight());
1096
1097     if (attr.HasFontUnderlined())
1098         AddAttribute(str, wxT("fontunderlined"), (int) attr.GetFontUnderlined());
1099
1100     if (attr.HasFontFaceName())
1101         AddAttribute(str, wxT("fontface"), AttributeToXML(attr.GetFontFaceName()));
1102
1103     if (attr.HasTextEffects())
1104     {
1105         AddAttribute(str, wxT("texteffects"), attr.GetTextEffects());
1106         AddAttribute(str, wxT("texteffectflags"), attr.GetTextEffectFlags());
1107     }
1108
1109     if (!attr.GetCharacterStyleName().empty())
1110         AddAttribute(str, wxT("characterstyle"), AttributeToXML(attr.GetCharacterStyleName()));
1111
1112     if (attr.HasURL())
1113         AddAttribute(str, wxT("url"), AttributeToXML(attr.GetURL()));
1114
1115     if (isPara)
1116     {
1117         if (attr.HasAlignment())
1118             AddAttribute(str, wxT("alignment"), (int) attr.GetAlignment());
1119
1120         if (attr.HasLeftIndent())
1121         {
1122             AddAttribute(str, wxT("leftindent"), (int) attr.GetLeftIndent());
1123             AddAttribute(str, wxT("leftsubindent"), (int) attr.GetLeftSubIndent());
1124         }
1125
1126         if (attr.HasRightIndent())
1127             AddAttribute(str, wxT("rightindent"), (int) attr.GetRightIndent());
1128
1129         if (attr.HasParagraphSpacingAfter())
1130             AddAttribute(str, wxT("parspacingafter"), (int) attr.GetParagraphSpacingAfter());
1131
1132         if (attr.HasParagraphSpacingBefore())
1133             AddAttribute(str, wxT("parspacingbefore"), (int) attr.GetParagraphSpacingBefore());
1134
1135         if (attr.HasLineSpacing())
1136             AddAttribute(str, wxT("linespacing"), (int) attr.GetLineSpacing());
1137
1138         if (attr.HasBulletStyle())
1139             AddAttribute(str, wxT("bulletstyle"), (int) attr.GetBulletStyle());
1140
1141         if (attr.HasBulletNumber())
1142             AddAttribute(str, wxT("bulletnumber"), (int) attr.GetBulletNumber());
1143
1144         if (attr.HasBulletText())
1145         {
1146             // If using a bullet symbol, convert to integer in case it's a non-XML-friendly character.
1147             // Otherwise, assume it's XML-friendly text such as outline numbering, e.g. 1.2.3.1
1148             if (!attr.GetBulletText().empty() && (attr.GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_SYMBOL))
1149                 AddAttribute(str, wxT("bulletsymbol"), (int) (attr.GetBulletText()[0]));
1150             else
1151                 AddAttribute(str, wxT("bullettext"), AttributeToXML(attr.GetBulletText()));
1152
1153             AddAttribute(str, wxT("bulletfont"), attr.GetBulletFont());
1154         }
1155
1156         if (attr.HasBulletName())
1157             AddAttribute(str, wxT("bulletname"), AttributeToXML(attr.GetBulletName()));
1158
1159         if (!attr.GetParagraphStyleName().empty())
1160             AddAttribute(str, wxT("parstyle"), AttributeToXML(attr.GetParagraphStyleName()));
1161
1162         if (!attr.GetListStyleName().empty())
1163             AddAttribute(str, wxT("liststyle"), AttributeToXML(attr.GetListStyleName()));
1164
1165         if (!attr.GetTextBoxAttr().GetBoxStyleName().empty())
1166             AddAttribute(str, wxT("boxstyle"), AttributeToXML(attr.GetTextBoxAttr().GetBoxStyleName()));
1167
1168         if (attr.HasTabs())
1169         {
1170             wxString strTabs;
1171             size_t i;
1172             for (i = 0; i < attr.GetTabs().GetCount(); i++)
1173             {
1174                 if (i > 0) strTabs << wxT(",");
1175                 strTabs << attr.GetTabs()[i];
1176             }
1177             AddAttribute(str, wxT("tabs"), strTabs);
1178         }
1179
1180         if (attr.HasPageBreak())
1181         {
1182             AddAttribute(str, wxT("pagebreak"), 1);
1183         }
1184
1185         if (attr.HasOutlineLevel())
1186             AddAttribute(str, wxT("outlinelevel"), (int) attr.GetOutlineLevel());
1187     }
1188
1189     AddAttribute(str, wxT("margin"), attr.GetTextBoxAttr().GetMargins());
1190     AddAttribute(str, wxT("padding"), attr.GetTextBoxAttr().GetPadding());
1191     AddAttribute(str, wxT("position"), attr.GetTextBoxAttr().GetPosition());
1192     AddAttribute(str, wxT("border"), attr.GetTextBoxAttr().GetBorder());
1193     AddAttribute(str, wxT("outline"), attr.GetTextBoxAttr().GetOutline());
1194     AddAttribute(str, wxT("width"), attr.GetTextBoxAttr().GetWidth());
1195     AddAttribute(str, wxT("height"), attr.GetTextBoxAttr().GetHeight());
1196     AddAttribute(str, wxT("minwidth"), attr.GetTextBoxAttr().GetMinSize().GetWidth());
1197     AddAttribute(str, wxT("minheight"), attr.GetTextBoxAttr().GetMinSize().GetHeight());
1198     AddAttribute(str, wxT("maxwidth"), attr.GetTextBoxAttr().GetMaxSize().GetWidth());
1199     AddAttribute(str, wxT("maxheight"), attr.GetTextBoxAttr().GetMaxSize().GetHeight());
1200
1201     if (attr.GetTextBoxAttr().HasVerticalAlignment())
1202     {
1203         wxString value;
1204         if (attr.GetTextBoxAttr().GetVerticalAlignment() == wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_TOP)
1205             value = wxT("top");
1206         else if (attr.GetTextBoxAttr().GetVerticalAlignment() == wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_CENTRE)
1207             value = wxT("centre");
1208         else if (attr.GetTextBoxAttr().GetVerticalAlignment() == wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_BOTTOM)
1209             value = wxT("bottom");
1210         else
1211             value = wxT("none");
1212         AddAttribute(str, wxT("verticalalignment"), value);
1213     }
1214
1215     if (attr.GetTextBoxAttr().HasFloatMode())
1216     {
1217         wxString value;
1218         if (attr.GetTextBoxAttr().GetFloatMode() == wxTEXT_BOX_ATTR_FLOAT_LEFT)
1219             value = wxT("left");
1220         else if (attr.GetTextBoxAttr().GetFloatMode() == wxTEXT_BOX_ATTR_FLOAT_RIGHT)
1221             value = wxT("right");
1222         else
1223             value = wxT("none");
1224         AddAttribute(str, wxT("float"), value);
1225     }
1226
1227     if (attr.GetTextBoxAttr().HasClearMode())
1228     {
1229         wxString value;
1230         if (attr.GetTextBoxAttr().GetClearMode() == wxTEXT_BOX_ATTR_CLEAR_LEFT)
1231             value = wxT("left");
1232         else if (attr.GetTextBoxAttr().GetClearMode() == wxTEXT_BOX_ATTR_CLEAR_RIGHT)
1233             value = wxT("right");
1234         else if (attr.GetTextBoxAttr().GetClearMode() == wxTEXT_BOX_ATTR_CLEAR_BOTH)
1235             value = wxT("both");
1236         else
1237             value = wxT("none");
1238         AddAttribute(str, wxT("clear"), value);
1239     }
1240
1241     if (attr.GetTextBoxAttr().HasCollapseBorders())
1242         AddAttribute(str, wxT("collapse-borders"), (int) attr.GetTextBoxAttr().GetCollapseBorders());
1243
1244     return str;
1245 }
1246
1247 // Make a string from the given property. This can be overridden for custom variants.
1248 wxString wxRichTextXMLHandler::MakeStringFromProperty(const wxVariant& var)
1249 {
1250     return var.MakeString();
1251 }
1252
1253 // Create a proprty from the string read from the XML file.
1254 wxVariant wxRichTextXMLHandler::MakePropertyFromString(const wxString& name, const wxString& value, const wxString& WXUNUSED(type))
1255 {
1256     wxVariant var(value, name);
1257     // TODO: use type to create using common types
1258     return var;
1259 }
1260
1261 // Write the properties
1262 bool wxRichTextXMLHandler::WriteProperties(wxOutputStream& stream, const wxRichTextProperties& properties, int level)
1263 {
1264     if (properties.GetCount() > 0)
1265     {
1266         level ++;
1267
1268         OutputIndentation(stream, level);
1269         OutputString(stream, wxT("<properties>"));
1270
1271         level ++;
1272
1273         size_t i;
1274         for (i = 0; i < properties.GetCount(); i++)
1275         {
1276             const wxVariant& var = properties[i];
1277             if (!var.IsNull())
1278             {
1279                 const wxString& name = var.GetName();
1280                 wxString value = MakeStringFromProperty(var);
1281
1282                 OutputIndentation(stream, level);
1283                 OutputString(stream, wxT("<property name=\"") + name +
1284                     wxT("\" type=\"") + var.GetType() + wxT("\" value=\""));
1285                 OutputStringEnt(stream, value);
1286                 OutputString(stream, wxT("\"/>"));
1287             }
1288         }
1289
1290         level --;
1291
1292         OutputIndentation(stream, level);
1293         OutputString(stream, wxT("</properties>"));
1294
1295         level --;
1296     }
1297
1298     return true;
1299 }
1300
1301
1302 #endif
1303     // wxRICHTEXT_HAVE_DIRECT_OUTPUT
1304
1305 #if wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT
1306 bool wxRichTextXMLHandler::ExportXML(wxXmlNode* parent, wxRichTextObject& obj)
1307 {
1308     obj.ExportXML(parent, this);
1309
1310     return true;
1311 }
1312
1313 bool wxRichTextXMLHandler::ExportStyleDefinition(wxXmlNode* parent, wxRichTextStyleDefinition* def)
1314 {
1315     wxRichTextCharacterStyleDefinition* charDef = wxDynamicCast(def, wxRichTextCharacterStyleDefinition);
1316     wxRichTextParagraphStyleDefinition* paraDef = wxDynamicCast(def, wxRichTextParagraphStyleDefinition);
1317     wxRichTextBoxStyleDefinition* boxDef = wxDynamicCast(def, wxRichTextBoxStyleDefinition);
1318     wxRichTextListStyleDefinition* listDef = wxDynamicCast(def, wxRichTextListStyleDefinition);
1319
1320     wxString baseStyle = def->GetBaseStyle();
1321     wxString descr = def->GetDescription();
1322
1323     wxXmlNode* defNode = new wxXmlNode(wxXML_ELEMENT_NODE, wxEmptyString);
1324     parent->AddChild(defNode);
1325     if (!baseStyle.empty())
1326         defNode->AddAttribute(wxT("basestyle"), baseStyle);
1327     if (!descr.empty())
1328         defNode->AddAttribute(wxT("description"), descr);
1329
1330     wxXmlNode* styleNode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("style"));
1331     defNode->AddChild(styleNode);
1332
1333     if (charDef)
1334     {
1335         defNode->SetName(wxT("characterstyle"));
1336         AddAttributes(styleNode, def->GetStyle(), false);
1337     }
1338     else if (listDef)
1339     {
1340         defNode->SetName(wxT("liststyle"));
1341
1342         if (!listDef->GetNextStyle().empty())
1343             defNode->AddAttribute(wxT("nextstyle"), listDef->GetNextStyle());
1344
1345         AddAttributes(styleNode, def->GetStyle(), true);
1346
1347         int i;
1348         for (i = 0; i < 10; i ++)
1349         {
1350             wxRichTextAttr* levelAttr = listDef->GetLevelAttributes(i);
1351             if (levelAttr)
1352             {
1353                 wxXmlNode* levelNode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("style"));
1354                 defNode->AddChild(levelNode);
1355                 levelNode->AddAttribute(wxT("level"), MakeString(i+1));
1356                 AddAttributes(levelNode, * levelAttr, true);
1357             }
1358         }
1359     }
1360     else if (boxDef)
1361     {
1362         defNode->SetName(wxT("boxstyle"));
1363
1364         AddAttributes(styleNode, def->GetStyle(), true);
1365     }
1366     else if (paraDef)
1367     {
1368         defNode->SetName(wxT("paragraphstyle"));
1369
1370         if (!paraDef->GetNextStyle().empty())
1371             defNode->AddAttribute(wxT("nextstyle"), paraDef->GetNextStyle());
1372
1373         AddAttributes(styleNode, def->GetStyle(), true);
1374     }
1375
1376     return true;
1377 }
1378
1379 bool wxRichTextXMLHandler::AddAttributes(wxXmlNode* node, wxRichTextAttr& attr, bool isPara)
1380 {
1381     if (attr.HasTextColour() && attr.GetTextColour().IsOk())
1382         node->AddAttribute(wxT("textcolor"), MakeString(attr.GetTextColour()));
1383     if (attr.HasBackgroundColour() && attr.GetBackgroundColour().IsOk())
1384         node->AddAttribute(wxT("bgcolor"), MakeString(attr.GetBackgroundColour()));
1385
1386     if (attr.HasFontSize())
1387         node->AddAttribute(wxT("fontsize"), MakeString(attr.GetFontSize()));
1388     if (attr.HasFontFamily())
1389         node->AddAttribute(wxT("fontfamily"), MakeString(attr.GetFontFamily()));
1390     if (attr.HasFontItalic())
1391         node->AddAttribute(wxT("fontstyle"), MakeString(attr.GetFontStyle()));
1392     if (attr.HasFontWeight())
1393         node->AddAttribute(wxT("fontweight"), MakeString(attr.GetFontWeight()));
1394     if (attr.HasFontUnderlined())
1395         node->AddAttribute(wxT("fontunderlined"), MakeString((int) attr.GetFontUnderlined()));
1396     if (attr.HasFontFaceName())
1397         node->AddAttribute(wxT("fontface"), attr.GetFontFaceName());
1398
1399     if (attr.HasTextEffects())
1400     {
1401         node->AddAttribute(wxT("texteffects"), MakeString(attr.GetTextEffects()));
1402         node->AddAttribute(wxT("texteffectflags"), MakeString(attr.GetTextEffectFlags()));
1403     }
1404     if (attr.HasCharacterStyleName() && !attr.GetCharacterStyleName().empty())
1405         node->AddAttribute(wxT("characterstyle"), attr.GetCharacterStyleName());
1406
1407     if (attr.HasURL())
1408         node->AddAttribute(wxT("url"), attr.GetURL()); // TODO: do we need to wrap this in AttributeToXML?
1409
1410     if (isPara)
1411     {
1412         if (attr.HasAlignment())
1413             node->AddAttribute(wxT("alignment"), MakeString((int) attr.GetAlignment()));
1414
1415         if (attr.HasLeftIndent())
1416         {
1417             node->AddAttribute(wxT("leftindent"), MakeString((int) attr.GetLeftIndent()));
1418             node->AddAttribute(wxT("leftsubindent"), MakeString((int) attr.GetLeftSubIndent()));
1419         }
1420
1421         if (attr.HasRightIndent())
1422             node->AddAttribute(wxT("rightindent"), MakeString((int) attr.GetRightIndent()));
1423
1424         if (attr.HasParagraphSpacingAfter())
1425             node->AddAttribute(wxT("parspacingafter"), MakeString((int) attr.GetParagraphSpacingAfter()));
1426
1427         if (attr.HasParagraphSpacingBefore())
1428             node->AddAttribute(wxT("parspacingbefore"), MakeString((int) attr.GetParagraphSpacingBefore()));
1429
1430         if (attr.HasLineSpacing())
1431             node->AddAttribute(wxT("linespacing"), MakeString((int) attr.GetLineSpacing()));
1432
1433         if (attr.HasBulletStyle())
1434             node->AddAttribute(wxT("bulletstyle"), MakeString((int) attr.GetBulletStyle()));
1435
1436         if (attr.HasBulletNumber())
1437             node->AddAttribute(wxT("bulletnumber"), MakeString((int) attr.GetBulletNumber()));
1438
1439         if (attr.HasBulletText())
1440         {
1441             // If using a bullet symbol, convert to integer in case it's a non-XML-friendly character.
1442             // Otherwise, assume it's XML-friendly text such as outline numbering, e.g. 1.2.3.1
1443             if (!attr.GetBulletText().empty() && (attr.GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_SYMBOL))
1444                 node->AddAttribute(wxT("bulletsymbol"), MakeString((int) (attr.GetBulletText()[0])));
1445             else
1446                 node->AddAttribute(wxT("bullettext"), attr.GetBulletText());
1447
1448             if (!attr.GetBulletFont().empty())
1449                 node->AddAttribute(wxT("bulletfont"), attr.GetBulletFont());
1450         }
1451
1452         if (attr.HasBulletName())
1453             node->AddAttribute(wxT("bulletname"), attr.GetBulletName());
1454
1455         if (!attr.GetParagraphStyleName().empty())
1456             node->AddAttribute(wxT("parstyle"), attr.GetParagraphStyleName());
1457
1458         if (!attr.GetListStyleName().empty())
1459             node->AddAttribute(wxT("liststyle"), attr.GetListStyleName());
1460
1461         if (!attr.GetTextBoxAttr().GetBoxStyleName().empty())
1462             node->AddAttribute(wxT("boxstyle"), attr.GetTextBoxAttr().GetBoxStyleName());
1463
1464         if (attr.HasTabs())
1465         {
1466             wxString tabs;
1467             size_t i;
1468             for (i = 0; i < attr.GetTabs().GetCount(); i++)
1469             {
1470                 if (i > 0)
1471                     tabs << wxT(",");
1472                 tabs << attr.GetTabs()[i];
1473             }
1474             node->AddAttribute(wxT("tabs"), tabs);
1475         }
1476
1477         if (attr.HasPageBreak())
1478             node->AddAttribute(wxT("pagebreak"), wxT("1"));
1479
1480         if (attr.HasOutlineLevel())
1481             node->AddAttribute(wxT("outlinelevel"), MakeString((int) attr.GetOutlineLevel()));
1482     }
1483
1484     AddAttribute(node, wxT("margin"), attr.GetTextBoxAttr().GetMargins());
1485     AddAttribute(node, wxT("padding"), attr.GetTextBoxAttr().GetPadding());
1486     AddAttribute(node, wxT("position"), attr.GetTextBoxAttr().GetPosition());
1487     AddAttribute(node, wxT("border"), attr.GetTextBoxAttr().GetBorder());
1488     AddAttribute(node, wxT("outline"), attr.GetTextBoxAttr().GetOutline());
1489     AddAttribute(node, wxT("width"), attr.GetTextBoxAttr().GetWidth());
1490     AddAttribute(node, wxT("height"), attr.GetTextBoxAttr().GetHeight());
1491     AddAttribute(node, wxT("minwidth"), attr.GetTextBoxAttr().GetMinSize().GetWidth());
1492     AddAttribute(node, wxT("minheight"), attr.GetTextBoxAttr().GetMinSize().GetHeight());
1493     AddAttribute(node, wxT("maxwidth"), attr.GetTextBoxAttr().GetMaxSize().GetWidth());
1494     AddAttribute(node, wxT("maxheight"), attr.GetTextBoxAttr().GetMaxSize().GetHeight());
1495
1496     if (attr.GetTextBoxAttr().HasVerticalAlignment())
1497     {
1498         wxString value;
1499         if (attr.GetTextBoxAttr().GetVerticalAlignment() == wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_TOP)
1500             value = wxT("top");
1501         else if (attr.GetTextBoxAttr().GetVerticalAlignment() == wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_CENTRE)
1502             value = wxT("centre");
1503         else if (attr.GetTextBoxAttr().GetVerticalAlignment() == wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_BOTTOM)
1504             value = wxT("bottom");
1505         else
1506             value = wxT("none");
1507         AddAttribute(node, wxT("verticalalignment"), value);
1508     }
1509
1510     if (attr.GetTextBoxAttr().HasFloatMode())
1511     {
1512         wxString value;
1513         if (attr.GetTextBoxAttr().GetFloatMode() == wxTEXT_BOX_ATTR_FLOAT_LEFT)
1514             value = wxT("left");
1515         else if (attr.GetTextBoxAttr().GetFloatMode() == wxTEXT_BOX_ATTR_FLOAT_RIGHT)
1516             value = wxT("right");
1517         else
1518             value = wxT("none");
1519         AddAttribute(node, wxT("float"), value);
1520     }
1521
1522     if (attr.GetTextBoxAttr().HasClearMode())
1523     {
1524         wxString value;
1525         if (attr.GetTextBoxAttr().GetClearMode() == wxTEXT_BOX_ATTR_CLEAR_LEFT)
1526             value = wxT("left");
1527         else if (attr.GetTextBoxAttr().GetClearMode() == wxTEXT_BOX_ATTR_CLEAR_RIGHT)
1528             value = wxT("right");
1529         else if (attr.GetTextBoxAttr().GetClearMode() == wxTEXT_BOX_ATTR_CLEAR_BOTH)
1530             value = wxT("both");
1531         else
1532             value = wxT("none");
1533         AddAttribute(node, wxT("clear"), value);
1534     }
1535
1536     if (attr.GetTextBoxAttr().HasCollapseBorders())
1537         AddAttribute(node, wxT("collapse-borders"), (int) attr.GetTextBoxAttr().GetCollapseBorders());
1538
1539     return true;
1540 }
1541
1542 bool wxRichTextXMLHandler::WriteProperties(wxXmlNode* node, const wxRichTextProperties& properties)
1543 {
1544     if (properties.GetCount() > 0)
1545     {
1546         wxXmlNode* propertiesNode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("properties"));
1547         node->AddChild(propertiesNode);
1548         size_t i;
1549         for (i = 0; i < properties.GetCount(); i++)
1550         {
1551             const wxVariant& var = properties[i];
1552             if (!var.IsNull())
1553             {
1554                 wxXmlNode* propertyNode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("property"));
1555                 propertiesNode->AddChild(propertyNode);
1556
1557                 const wxString& name = var.GetName();
1558                 wxString value = MakeStringFromProperty(var);
1559
1560                 AddAttribute(propertyNode, wxT("name"), name);
1561                 AddAttribute(propertyNode, wxT("type"), var.GetType());
1562                 AddAttribute(propertyNode, wxT("value"), value);
1563             }
1564         }
1565     }
1566     return true;
1567 }
1568
1569 #endif
1570     // wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT
1571
1572 /// Replace face name with current name for platform.
1573 /// TODO: introduce a virtual function or settable table to
1574 /// do this comprehensively.
1575 bool wxRichTextFixFaceName(wxString& facename)
1576 {
1577     if (facename.empty())
1578         return false;
1579
1580 #ifdef __WXMSW__
1581     if (facename == wxT("Times"))
1582     {
1583         facename = wxT("Times New Roman");
1584         return true;
1585     }
1586     else if (facename == wxT("Helvetica"))
1587     {
1588         facename = wxT("Arial");
1589         return true;
1590     }
1591     else if (facename == wxT("Courier"))
1592     {
1593         facename = wxT("Courier New");
1594         return true;
1595     }
1596     else
1597         return false;
1598 #else
1599     if (facename == wxT("Times New Roman"))
1600     {
1601         facename = wxT("Times");
1602         return true;
1603     }
1604     else if (facename == wxT("Arial"))
1605     {
1606         facename = wxT("Helvetica");
1607         return true;
1608     }
1609     else if (facename == wxT("Courier New"))
1610     {
1611         facename = wxT("Courier");
1612         return true;
1613     }
1614     else
1615         return false;
1616 #endif
1617 }
1618
1619 static inline long wxRichTextColourStringToLong(const wxString& colStr)
1620 {
1621     if (!colStr.IsEmpty())
1622     {
1623         wxColour col(colStr);
1624         return col.GetRGB();
1625     }
1626     else
1627         return 0;
1628 }
1629
1630 static inline wxTextAttrDimension wxRichTextParseDimension(const wxString& dimStr)
1631 {
1632     wxString valuePart = dimStr.BeforeFirst(wxT(','));
1633     wxString flagsPart;
1634     if (dimStr.Contains(wxT(",")))
1635         flagsPart = dimStr.AfterFirst(wxT(','));
1636     wxTextAttrDimension dim;
1637     dim.SetValue(wxAtoi(valuePart));
1638     dim.SetFlags(wxAtoi(flagsPart));
1639
1640     return dim;
1641 }
1642
1643 /// Import style parameters
1644 bool wxRichTextXMLHandler::ImportStyle(wxRichTextAttr& attr, wxXmlNode* node, bool isPara)
1645 {
1646     wxXmlAttribute* xmlAttr = node->GetAttributes();
1647     bool found;
1648     while (xmlAttr)
1649     {
1650         const wxString& name = xmlAttr->GetName();
1651         const wxString& value = xmlAttr->GetValue();
1652         found = true;
1653
1654         if (name == wxT("fontface"))
1655         {
1656             if (!value.empty())
1657             {
1658                 wxString v = value;
1659                 if (GetFlags() & wxRICHTEXT_HANDLER_CONVERT_FACENAMES)
1660                     wxRichTextFixFaceName(v);
1661                 attr.SetFontFaceName(v);
1662             }
1663         }
1664         else if (name == wxT("fontfamily"))
1665         {
1666             if (!value.empty())
1667                 attr.SetFontFamily((wxFontFamily)wxAtoi(value));
1668         }
1669         else if (name == wxT("fontstyle"))
1670         {
1671             if (!value.empty())
1672                 attr.SetFontStyle((wxFontStyle)wxAtoi(value));
1673         }
1674         else if (name == wxT("fontsize"))
1675         {
1676             if (!value.empty())
1677                 attr.SetFontSize(wxAtoi(value));
1678         }
1679         else if (name == wxT("fontweight"))
1680         {
1681             if (!value.empty())
1682                 attr.SetFontWeight((wxFontWeight) wxAtoi(value));
1683         }
1684         else if (name == wxT("fontunderlined"))
1685         {
1686             if (!value.empty())
1687                 attr.SetFontUnderlined(wxAtoi(value) != 0);
1688         }
1689         else if (name == wxT("textcolor"))
1690         {
1691             if (!value.empty())
1692             {
1693                 if (value[0] == wxT('#'))
1694                     attr.SetTextColour(HexStringToColour(value.Mid(1)));
1695                 else
1696                     attr.SetTextColour(value);
1697             }
1698         }
1699         else if (name == wxT("bgcolor"))
1700         {
1701             if (!value.empty())
1702             {
1703                 if (value[0] == wxT('#'))
1704                     attr.SetBackgroundColour(HexStringToColour(value.Mid(1)));
1705                 else
1706                     attr.SetBackgroundColour(value);
1707             }
1708         }
1709         else if (name == wxT("characterstyle"))
1710         {
1711             if (!value.empty())
1712                 attr.SetCharacterStyleName(value);
1713         }
1714         else if (name == wxT("texteffects"))
1715         {
1716             if (!value.empty())
1717                 attr.SetTextEffects(wxAtoi(value));
1718         }
1719         else if (name == wxT("texteffectflags"))
1720         {
1721             if (!value.empty())
1722                 attr.SetTextEffectFlags(wxAtoi(value));
1723         }
1724         else if (name == wxT("url"))
1725         {
1726             if (!value.empty())
1727                 attr.SetURL(value);
1728         }
1729         else if (isPara)
1730         {
1731             if (name == wxT("alignment"))
1732             {
1733                 if (!value.empty())
1734                     attr.SetAlignment((wxTextAttrAlignment) wxAtoi(value));
1735             }
1736             else if (name == wxT("leftindent"))
1737             {
1738                 if (!value.empty())
1739                     attr.SetLeftIndent(wxAtoi(value), attr.GetLeftSubIndent());
1740             }
1741             else if (name == wxT("leftsubindent"))
1742             {
1743                 if (!value.empty())
1744                     attr.SetLeftIndent(attr.GetLeftIndent(), wxAtoi(value));
1745             }
1746             else if (name == wxT("rightindent"))
1747             {
1748                 if (!value.empty())
1749                     attr.SetRightIndent(wxAtoi(value));
1750             }
1751             else if (name == wxT("parspacingbefore"))
1752             {
1753                 if (!value.empty())
1754                     attr.SetParagraphSpacingBefore(wxAtoi(value));
1755             }
1756             else if (name == wxT("parspacingafter"))
1757             {
1758                 if (!value.empty())
1759                     attr.SetParagraphSpacingAfter(wxAtoi(value));
1760             }
1761             else if (name == wxT("linespacing"))
1762             {
1763                 if (!value.empty())
1764                     attr.SetLineSpacing(wxAtoi(value));
1765             }
1766             else if (name == wxT("bulletstyle"))
1767             {
1768                 if (!value.empty())
1769                     attr.SetBulletStyle(wxAtoi(value));
1770             }
1771             else if (name == wxT("bulletnumber"))
1772             {
1773                 if (!value.empty())
1774                     attr.SetBulletNumber(wxAtoi(value));
1775             }
1776             else if (name == wxT("bulletsymbol"))
1777             {
1778                 if (!value.empty())
1779                 {
1780                     wxChar ch = wxAtoi(value);
1781                     wxString s;
1782                     s << ch;
1783                     attr.SetBulletText(s);
1784                 }
1785             }
1786             else if (name == wxT("bullettext"))
1787             {
1788                 if (!value.empty())
1789                 {
1790                     attr.SetBulletText(value);
1791                 }
1792             }
1793             else if (name == wxT("bulletfont"))
1794             {
1795                 if (!value.empty())
1796                 {
1797                     attr.SetBulletFont(value);
1798                 }
1799             }
1800             else if (name == wxT("bulletname"))
1801             {
1802                 if (!value.empty())
1803                 {
1804                     attr.SetBulletName(value);
1805                 }
1806             }
1807             else if (name == wxT("parstyle"))
1808             {
1809                 if (!value.empty())
1810                 {
1811                     attr.SetParagraphStyleName(value);
1812                 }
1813             }
1814             else if (name == wxT("liststyle"))
1815             {
1816                 if (!value.empty())
1817                 {
1818                     attr.SetListStyleName(value);
1819                 }
1820             }
1821             else if (name == wxT("boxstyle"))
1822             {
1823                 if (!value.empty())
1824                 {
1825                     attr.GetTextBoxAttr().SetBoxStyleName(value);
1826                 }
1827             }
1828             else if (name == wxT("tabs"))
1829             {
1830                 if (!value.empty())
1831                 {
1832                     wxArrayInt tabs;
1833                     wxStringTokenizer tkz(value, wxT(","));
1834                     while (tkz.HasMoreTokens())
1835                     {
1836                         wxString token = tkz.GetNextToken();
1837                         tabs.Add(wxAtoi(token));
1838                     }
1839                     attr.SetTabs(tabs);
1840                 }
1841             }
1842             else if (name == wxT("pagebreak"))
1843             {
1844                 if (!value.empty())
1845                 {
1846                     attr.SetPageBreak(wxAtoi(value) != 0);
1847                 }
1848             }
1849             else if (name == wxT("outlinelevel"))
1850             {
1851                 if (!value.empty())
1852                 {
1853                     attr.SetOutlineLevel(wxAtoi(value));
1854                 }
1855             }
1856             else
1857                 found = false;
1858         }
1859         else
1860             found = false;
1861
1862         if (!found)
1863         {
1864             // Box attributes
1865
1866             if (name == wxT("width"))
1867             {
1868                 attr.GetTextBoxAttr().GetWidth().SetValue(wxRichTextParseDimension(value));
1869             }
1870             else if (name == wxT("height"))
1871             {
1872                 attr.GetTextBoxAttr().GetHeight().SetValue(wxRichTextParseDimension(value));
1873             }
1874             else if (name == wxT("minwidth"))
1875             {
1876                 attr.GetTextBoxAttr().GetMinSize().GetWidth().SetValue(wxRichTextParseDimension(value));
1877             }
1878             else if (name == wxT("minheight"))
1879             {
1880                 attr.GetTextBoxAttr().GetMinSize().GetHeight().SetValue(wxRichTextParseDimension(value));
1881             }
1882             else if (name == wxT("maxwidth"))
1883             {
1884                 attr.GetTextBoxAttr().GetMaxSize().GetWidth().SetValue(wxRichTextParseDimension(value));
1885             }
1886             else if (name == wxT("maxheight"))
1887             {
1888                 attr.GetTextBoxAttr().GetMaxSize().GetHeight().SetValue(wxRichTextParseDimension(value));
1889             }
1890
1891             else if (name == wxT("verticalalignment"))
1892             {
1893                 if (value == wxT("top"))
1894                     attr.GetTextBoxAttr().SetVerticalAlignment(wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_TOP);
1895                 else if (value == wxT("centre"))
1896                     attr.GetTextBoxAttr().SetVerticalAlignment(wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_CENTRE);
1897                 else if (value == wxT("bottom"))
1898                     attr.GetTextBoxAttr().SetVerticalAlignment(wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_BOTTOM);
1899                 else if (value == wxT("none"))
1900                     attr.GetTextBoxAttr().SetVerticalAlignment(wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_NONE);
1901             }
1902             else if (name == wxT("float"))
1903             {
1904                 if (value == wxT("left"))
1905                     attr.GetTextBoxAttr().SetFloatMode(wxTEXT_BOX_ATTR_FLOAT_LEFT);
1906                 else if (value == wxT("right"))
1907                     attr.GetTextBoxAttr().SetFloatMode(wxTEXT_BOX_ATTR_FLOAT_RIGHT);
1908                 else if (value == wxT("none"))
1909                     attr.GetTextBoxAttr().SetFloatMode(wxTEXT_BOX_ATTR_FLOAT_NONE);
1910             }
1911             else if (name == wxT("clear"))
1912             {
1913                 if (value == wxT("left"))
1914                     attr.GetTextBoxAttr().SetClearMode(wxTEXT_BOX_ATTR_CLEAR_LEFT);
1915                 else if (value == wxT("right"))
1916                     attr.GetTextBoxAttr().SetClearMode(wxTEXT_BOX_ATTR_CLEAR_RIGHT);
1917                 else if (value == wxT("both"))
1918                     attr.GetTextBoxAttr().SetClearMode(wxTEXT_BOX_ATTR_CLEAR_BOTH);
1919                 else if (value == wxT("none"))
1920                     attr.GetTextBoxAttr().SetClearMode(wxTEXT_BOX_ATTR_CLEAR_NONE);
1921             }
1922             else if (name == wxT("collapse-borders"))
1923                 attr.GetTextBoxAttr().SetCollapseBorders((wxTextBoxAttrCollapseMode) wxAtoi(value));
1924
1925             else if (name.Contains(wxT("border-")))
1926             {
1927                 if (name == wxT("border-left-style"))
1928                     attr.GetTextBoxAttr().GetBorder().GetLeft().SetStyle(wxAtoi(value));
1929                 else if (name == wxT("border-right-style"))
1930                     attr.GetTextBoxAttr().GetBorder().GetRight().SetStyle(wxAtoi(value));
1931                 else if (name == wxT("border-top-style"))
1932                     attr.GetTextBoxAttr().GetBorder().GetTop().SetStyle(wxAtoi(value));
1933                 else if (name == wxT("border-bottom-style"))
1934                     attr.GetTextBoxAttr().GetBorder().GetBottom().SetStyle(wxAtoi(value));
1935
1936                 else if (name == wxT("border-left-colour"))
1937                     attr.GetTextBoxAttr().GetBorder().GetLeft().SetColour(wxRichTextColourStringToLong(value));
1938                 else if (name == wxT("border-right-colour"))
1939                     attr.GetTextBoxAttr().GetBorder().GetRight().SetColour(wxRichTextColourStringToLong(value));
1940                 else if (name == wxT("border-top-colour"))
1941                     attr.GetTextBoxAttr().GetBorder().GetTop().SetColour(wxRichTextColourStringToLong(value));
1942                 else if (name == wxT("border-bottom-colour"))
1943                     attr.GetTextBoxAttr().GetBorder().GetBottom().SetColour(wxRichTextColourStringToLong(value));
1944
1945                 else if (name == wxT("border-left-width"))
1946                     attr.GetTextBoxAttr().GetBorder().GetLeft().SetWidth(wxRichTextParseDimension(value));
1947                 else if (name == wxT("border-right-width"))
1948                     attr.GetTextBoxAttr().GetBorder().GetRight().SetWidth(wxRichTextParseDimension(value));
1949                 else if (name == wxT("border-top-width"))
1950                     attr.GetTextBoxAttr().GetBorder().GetTop().SetWidth(wxRichTextParseDimension(value));
1951                 else if (name == wxT("border-bottom-width"))
1952                     attr.GetTextBoxAttr().GetBorder().GetBottom().SetWidth(wxRichTextParseDimension(value));
1953             }
1954             else if (name.Contains(wxT("outline-")))
1955             {
1956                 if (name == wxT("outline-left-style"))
1957                     attr.GetTextBoxAttr().GetOutline().GetLeft().SetStyle(wxAtoi(value));
1958                 else if (name == wxT("outline-right-style"))
1959                     attr.GetTextBoxAttr().GetOutline().GetRight().SetStyle(wxAtoi(value));
1960                 else if (name == wxT("outline-top-style"))
1961                     attr.GetTextBoxAttr().GetOutline().GetTop().SetStyle(wxAtoi(value));
1962                 else if (name == wxT("outline-bottom-style"))
1963                     attr.GetTextBoxAttr().GetOutline().GetBottom().SetStyle(wxAtoi(value));
1964
1965                 else if (name == wxT("outline-left-colour"))
1966                     attr.GetTextBoxAttr().GetOutline().GetLeft().SetColour(wxRichTextColourStringToLong(value));
1967                 else if (name == wxT("outline-right-colour"))
1968                     attr.GetTextBoxAttr().GetOutline().GetRight().SetColour(wxRichTextColourStringToLong(value));
1969                 else if (name == wxT("outline-top-colour"))
1970                     attr.GetTextBoxAttr().GetOutline().GetTop().SetColour(wxRichTextColourStringToLong(value));
1971                 else if (name == wxT("outline-bottom-colour"))
1972                     attr.GetTextBoxAttr().GetOutline().GetBottom().SetColour(wxRichTextColourStringToLong(value));
1973
1974                 else if (name == wxT("outline-left-width"))
1975                     attr.GetTextBoxAttr().GetOutline().GetLeft().SetWidth(wxRichTextParseDimension(value));
1976                 else if (name == wxT("outline-right-width"))
1977                     attr.GetTextBoxAttr().GetOutline().GetRight().SetWidth(wxRichTextParseDimension(value));
1978                 else if (name == wxT("outline-top-width"))
1979                     attr.GetTextBoxAttr().GetOutline().GetTop().SetWidth(wxRichTextParseDimension(value));
1980                 else if (name == wxT("outline-bottom-width"))
1981                     attr.GetTextBoxAttr().GetOutline().GetBottom().SetWidth(wxRichTextParseDimension(value));
1982             }
1983             else if (name.Contains(wxT("margin-")))
1984             {
1985                 if (name == wxT("margin-left"))
1986                     attr.GetTextBoxAttr().GetMargins().GetLeft().SetValue(wxRichTextParseDimension(value));
1987                 else if (name == wxT("margin-right"))
1988                     attr.GetTextBoxAttr().GetMargins().GetRight().SetValue(wxRichTextParseDimension(value));
1989                 else if (name == wxT("margin-top"))
1990                     attr.GetTextBoxAttr().GetMargins().GetTop().SetValue(wxRichTextParseDimension(value));
1991                 else if (name == wxT("margin-bottom"))
1992                     attr.GetTextBoxAttr().GetMargins().GetBottom().SetValue(wxRichTextParseDimension(value));
1993             }
1994             else if (name.Contains(wxT("padding-")))
1995             {
1996                 if (name == wxT("padding-left"))
1997                     attr.GetTextBoxAttr().GetPadding().GetLeft().SetValue(wxRichTextParseDimension(value));
1998                 else if (name == wxT("padding-right"))
1999                     attr.GetTextBoxAttr().GetPadding().GetRight().SetValue(wxRichTextParseDimension(value));
2000                 else if (name == wxT("padding-top"))
2001                     attr.GetTextBoxAttr().GetPadding().GetTop().SetValue(wxRichTextParseDimension(value));
2002                 else if (name == wxT("padding-bottom"))
2003                     attr.GetTextBoxAttr().GetPadding().GetBottom().SetValue(wxRichTextParseDimension(value));
2004             }
2005             else if (name.Contains(wxT("position-")))
2006             {
2007                 if (name == wxT("position-left"))
2008                     attr.GetTextBoxAttr().GetPosition().GetLeft().SetValue(wxRichTextParseDimension(value));
2009                 else if (name == wxT("position-right"))
2010                     attr.GetTextBoxAttr().GetPosition().GetRight().SetValue(wxRichTextParseDimension(value));
2011                 else if (name == wxT("position-top"))
2012                     attr.GetTextBoxAttr().GetPosition().GetTop().SetValue(wxRichTextParseDimension(value));
2013                 else if (name == wxT("position-bottom"))
2014                     attr.GetTextBoxAttr().GetPosition().GetBottom().SetValue(wxRichTextParseDimension(value));
2015             }
2016         }
2017
2018         xmlAttr = xmlAttr->GetNext();
2019     }
2020
2021     return true;
2022 }
2023
2024 #endif
2025     // wxUSE_STREAMS
2026
2027 // Import this object from XML
2028 bool wxRichTextObject::ImportFromXML(wxRichTextBuffer* WXUNUSED(buffer), wxXmlNode* node, wxRichTextXMLHandler* handler, bool* recurse)
2029 {
2030     handler->ImportProperties(this, node);
2031     handler->ImportStyle(GetAttributes(), node, UsesParagraphAttributes());
2032
2033     *recurse = true;
2034
2035     return true;
2036 }
2037
2038 #if wxRICHTEXT_HAVE_DIRECT_OUTPUT
2039 // Export this object directly to the given stream.
2040 bool wxRichTextObject::ExportXML(wxOutputStream& stream, int indent, wxRichTextXMLHandler* handler)
2041 {
2042     ::OutputIndentation(stream, indent);
2043     ::OutputString(stream, wxT("<") + GetXMLNodeName(), handler->GetConvMem(), handler->GetConvFile());
2044
2045     wxString style = handler->AddAttributes(GetAttributes(), true);
2046
2047     ::OutputString(stream, style + wxT(">"), handler->GetConvMem(), handler->GetConvFile());
2048
2049     if (GetProperties().GetCount() > 0)
2050     {
2051         handler->WriteProperties(stream, GetProperties(), indent);
2052     }
2053
2054     wxRichTextCompositeObject* composite = wxDynamicCast(this, wxRichTextCompositeObject);
2055     if (composite)
2056     {
2057         size_t i;
2058         for (i = 0; i < composite->GetChildCount(); i++)
2059         {
2060             wxRichTextObject* child = composite->GetChild(i);
2061             child->ExportXML(stream, indent+1, handler);
2062         }
2063     }
2064
2065     ::OutputIndentation(stream, indent);
2066     ::OutputString(stream, wxT("</") + GetXMLNodeName() + wxT(">"), handler->GetConvMem(), handler->GetConvFile());
2067     return true;
2068 }
2069 #endif
2070
2071 #if wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT
2072 // Export this object to the given parent node, usually creating at least one child node.
2073 bool wxRichTextObject::ExportXML(wxXmlNode* parent, wxRichTextXMLHandler* handler)
2074 {
2075     wxXmlNode* elementNode = new wxXmlNode(wxXML_ELEMENT_NODE, GetXMLNodeName());
2076     parent->AddChild(elementNode);
2077     handler->AddAttributes(elementNode, GetAttributes(), true);
2078     handler->WriteProperties(elementNode, GetProperties());
2079
2080     wxRichTextCompositeObject* composite = wxDynamicCast(this, wxRichTextCompositeObject);
2081     if (composite)
2082     {
2083         size_t i;
2084         for (i = 0; i < composite->GetChildCount(); i++)
2085         {
2086             wxRichTextObject* child = composite->GetChild(i);
2087             child->ExportXML(elementNode, handler);
2088         }
2089     }
2090     return true;
2091 }
2092 #endif
2093
2094
2095 // Import this object from XML
2096 bool wxRichTextPlainText::ImportFromXML(wxRichTextBuffer* buffer, wxXmlNode* node, wxRichTextXMLHandler* handler, bool* recurse)
2097 {
2098     wxRichTextObject::ImportFromXML(buffer, node, handler, recurse);
2099
2100     if (node->GetName() == wxT("text"))
2101     {
2102         wxString text;
2103         wxXmlNode* textChild = node->GetChildren();
2104         while (textChild)
2105         {
2106             if (textChild->GetType() == wxXML_TEXT_NODE ||
2107                 textChild->GetType() == wxXML_CDATA_SECTION_NODE)
2108             {
2109                 wxString text2 = textChild->GetContent();
2110
2111                 // Strip whitespace from end
2112                 if (!text2.empty() && text2[text2.length()-1] == wxT('\n'))
2113                     text2 = text2.Mid(0, text2.length()-1);
2114
2115                 if (!text2.empty() && text2[0] == wxT('"'))
2116                     text2 = text2.Mid(1);
2117                 if (!text2.empty() && text2[text2.length()-1] == wxT('"'))
2118                     text2 = text2.Mid(0, text2.length() - 1);
2119
2120                 text += text2;
2121             }
2122             textChild = textChild->GetNext();
2123         }
2124
2125         SetText(text);
2126     }
2127     else if (node->GetName() == wxT("symbol"))
2128     {
2129         // This is a symbol that XML can't read in the normal way
2130         wxString text;
2131         wxXmlNode* textChild = node->GetChildren();
2132         while (textChild)
2133         {
2134             if (textChild->GetType() == wxXML_TEXT_NODE ||
2135                 textChild->GetType() == wxXML_CDATA_SECTION_NODE)
2136             {
2137                 wxString text2 = textChild->GetContent();
2138                 text += text2;
2139             }
2140             textChild = textChild->GetNext();
2141         }
2142
2143         wxString actualText;
2144         actualText << (wxChar) wxAtoi(text);
2145         SetText(actualText);
2146     }
2147     else
2148         return false;
2149
2150     return true;
2151 }
2152
2153 #if wxRICHTEXT_HAVE_DIRECT_OUTPUT
2154 // Export this object directly to the given stream.
2155 bool wxRichTextPlainText::ExportXML(wxOutputStream& stream, int indent, wxRichTextXMLHandler* handler)
2156 {
2157     wxString style = handler->AddAttributes(GetAttributes(), false);
2158
2159     int i;
2160     int last = 0;
2161     const wxString& text = GetText();
2162     int len = (int) text.Length();
2163
2164     if (len == 0)
2165     {
2166         i = 0;
2167         ::OutputIndentation(stream, indent);
2168         ::OutputString(stream, wxT("<text"), handler->GetConvMem(), handler->GetConvFile());
2169         ::OutputString(stream, style + wxT(">"), handler->GetConvMem(), handler->GetConvFile());
2170         if (GetProperties().GetCount() > 0)
2171         {
2172             handler->WriteProperties(stream, GetProperties(), indent);
2173             ::OutputIndentation(stream, indent);
2174         }
2175         ::OutputString(stream, wxT("</text>"), handler->GetConvMem(), handler->GetConvFile());
2176     }
2177     else for (i = 0; i < len; i++)
2178     {
2179 #if wxUSE_UNICODE
2180         int c = (int) text[i];
2181 #else
2182         int c = (int) wxUChar(text[i]);
2183 #endif
2184         if ((c < 32 || c == 34) && /* c != 9 && */ c != 10 && c != 13)
2185         {
2186             if (i > 0)
2187             {
2188                 wxString fragment(text.Mid(last, i-last));
2189                 if (!fragment.empty())
2190                 {
2191                     ::OutputIndentation(stream, indent);
2192                     ::OutputString(stream, wxT("<text"), handler->GetConvMem(), handler->GetConvFile());
2193
2194                     ::OutputString(stream, style + wxT(">"), handler->GetConvMem(), handler->GetConvFile());
2195
2196                     if (!fragment.empty() && (fragment[0] == wxT(' ') || fragment[fragment.length()-1] == wxT(' ')))
2197                     {
2198                         ::OutputString(stream, wxT("\""), handler->GetConvMem(), handler->GetConvFile());
2199                         ::OutputStringEnt(stream, fragment, handler->GetConvMem(), handler->GetConvFile());
2200                         ::OutputString(stream, wxT("\""), handler->GetConvMem(), handler->GetConvFile());
2201                     }
2202                     else
2203                         ::OutputStringEnt(stream, fragment, handler->GetConvMem(), handler->GetConvFile());
2204
2205                     if (GetProperties().GetCount() > 0)
2206                     {
2207                         handler->WriteProperties(stream, GetProperties(), indent);
2208                         ::OutputIndentation(stream, indent);
2209                     }
2210                     ::OutputString(stream, wxT("</text>"), handler->GetConvMem(), handler->GetConvFile());
2211                 }
2212             }
2213
2214
2215             // Output this character as a number in a separate tag, because XML can't cope
2216             // with entities below 32 except for 10 and 13
2217             last = i + 1;
2218             ::OutputIndentation(stream, indent);
2219             ::OutputString(stream, wxT("<symbol"), handler->GetConvMem(), handler->GetConvFile());
2220
2221             ::OutputString(stream, style + wxT(">"), handler->GetConvMem(), handler->GetConvFile());
2222             ::OutputString(stream, wxString::Format(wxT("%d"), c), handler->GetConvMem(), handler->GetConvFile());
2223
2224             if (GetProperties().GetCount() > 0)
2225             {
2226                 handler->WriteProperties(stream, GetProperties(), indent);
2227                 ::OutputIndentation(stream, indent);
2228             }
2229             ::OutputString(stream, wxT("</symbol>"), handler->GetConvMem(), handler->GetConvFile());
2230         }
2231     }
2232
2233     wxString fragment;
2234     if (last == 0)
2235         fragment = text;
2236     else
2237         fragment = text.Mid(last, i-last);
2238
2239     if (last < len)
2240     {
2241         ::OutputIndentation(stream, indent);
2242         ::OutputString(stream, wxT("<text"), handler->GetConvMem(), handler->GetConvFile());
2243
2244         ::OutputString(stream, style + wxT(">"), handler->GetConvMem(), handler->GetConvFile());
2245
2246         if (GetProperties().GetCount() > 0)
2247         {
2248             handler->WriteProperties(stream, GetProperties(), indent);
2249             ::OutputIndentation(stream, indent);
2250         }
2251
2252         if (!fragment.empty() && (fragment[0] == wxT(' ') || fragment[fragment.length()-1] == wxT(' ')))
2253         {
2254             ::OutputString(stream, wxT("\""), handler->GetConvMem(), handler->GetConvFile());
2255             ::OutputStringEnt(stream, fragment, handler->GetConvMem(), handler->GetConvFile());
2256             ::OutputString(stream, wxT("\""), handler->GetConvMem(), handler->GetConvFile());
2257         }
2258         else
2259             ::OutputStringEnt(stream, fragment, handler->GetConvMem(), handler->GetConvFile());
2260
2261         ::OutputString(stream, wxT("</text>"), handler->GetConvMem(), handler->GetConvFile());
2262     }
2263     return true;
2264 }
2265 #endif
2266
2267 #if wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT
2268 // Export this object to the given parent node, usually creating at least one child node.
2269 bool wxRichTextPlainText::ExportXML(wxXmlNode* parent, wxRichTextXMLHandler* handler)
2270 {
2271     int i;
2272     int last = 0;
2273     const wxString& text = GetText();
2274     int len = (int) text.Length();
2275
2276     if (len == 0)
2277     {
2278         i = 0;
2279
2280         wxXmlNode* elementNode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("text"));
2281         parent->AddChild(elementNode);
2282
2283         handler->AddAttributes(elementNode, GetAttributes(), false);
2284         handler->WriteProperties(elementNode, GetProperties());
2285     }
2286     else for (i = 0; i < len; i++)
2287     {
2288 #if wxUSE_UNICODE
2289         int c = (int) text[i];
2290 #else
2291         int c = (int) wxUChar(text[i]);
2292 #endif
2293         if ((c < 32 || c == 34) && c != 10 && c != 13)
2294         {
2295             if (i > 0)
2296             {
2297                 wxString fragment(text.Mid(last, i-last));
2298                 if (!fragment.empty())
2299                 {
2300                     // TODO: I'm assuming wxXmlDocument will output quotes if necessary
2301                     wxXmlNode* elementNode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("text"));
2302                     parent->AddChild(elementNode);
2303                     handler->AddAttributes(elementNode, GetAttributes(), false);
2304                     handler->WriteProperties(elementNode, GetProperties());
2305
2306                     wxXmlNode* textNode = new wxXmlNode(wxXML_TEXT_NODE, wxT("text"));
2307                     elementNode->AddChild(textNode);
2308
2309                     if (fragment[0] == wxT(' ') || fragment[fragment.length()-1] == wxT(' '))
2310                         fragment = wxT("\"") + fragment + wxT("\"");
2311
2312                     textNode->SetContent(fragment);
2313                 }
2314             }
2315
2316
2317             // Output this character as a number in a separate tag, because XML can't cope
2318             // with entities below 32 except for 10 and 13
2319
2320             wxXmlNode* elementNode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("symbol"));
2321             parent->AddChild(elementNode);
2322
2323             handler->AddAttributes(elementNode, GetAttributes(), false);
2324             handler->WriteProperties(elementNode, GetProperties());
2325
2326             wxXmlNode* textNode = new wxXmlNode(wxXML_TEXT_NODE, wxT("text"));
2327             elementNode->AddChild(textNode);
2328             textNode->SetContent(wxString::Format(wxT("%d"), c));
2329
2330             last = i + 1;
2331         }
2332     }
2333
2334     wxString fragment;
2335     if (last == 0)
2336         fragment = text;
2337     else
2338         fragment = text.Mid(last, i-last);
2339
2340     if (last < len)
2341     {
2342         wxXmlNode* elementNode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("text"));
2343         parent->AddChild(elementNode);
2344         handler->AddAttributes(elementNode, GetAttributes(), false);
2345
2346         wxXmlNode* textNode = new wxXmlNode(wxXML_TEXT_NODE, wxT("text"));
2347         elementNode->AddChild(textNode);
2348
2349         if (fragment[0] == wxT(' ') || fragment[fragment.length()-1] == wxT(' '))
2350             fragment = wxT("\"") + fragment + wxT("\"");
2351
2352         textNode->SetContent(fragment);
2353     }
2354     return true;
2355 }
2356 #endif
2357
2358
2359 // Import this object from XML
2360 bool wxRichTextImage::ImportFromXML(wxRichTextBuffer* buffer, wxXmlNode* node, wxRichTextXMLHandler* handler, bool* recurse)
2361 {
2362     wxRichTextObject::ImportFromXML(buffer, node, handler, recurse);
2363
2364     wxBitmapType imageType = wxBITMAP_TYPE_PNG;
2365     wxString value = node->GetAttribute(wxT("imagetype"), wxEmptyString);
2366     if (!value.empty())
2367     {
2368         int type = wxAtoi(value);
2369
2370         // note: 0 == wxBITMAP_TYPE_INVALID
2371         if (type <= 0 || type >= wxBITMAP_TYPE_MAX)
2372         {
2373             wxLogWarning("Invalid bitmap type specified for <image> tag: %d", type);
2374         }
2375         else
2376         {
2377             imageType = (wxBitmapType)type;
2378         }
2379     }
2380
2381     wxString data;
2382
2383     wxXmlNode* imageChild = node->GetChildren();
2384     while (imageChild)
2385     {
2386         wxString childName = imageChild->GetName();
2387         if (childName == wxT("data"))
2388         {
2389             wxXmlNode* dataChild = imageChild->GetChildren();
2390             while (dataChild)
2391             {
2392                 data = dataChild->GetContent();
2393                 // wxLogDebug(data);
2394                 dataChild = dataChild->GetNext();
2395             }
2396
2397         }
2398         imageChild = imageChild->GetNext();
2399     }
2400
2401     if (!data.empty())
2402     {
2403         wxStringInputStream strStream(data);
2404
2405         GetImageBlock().ReadHex(strStream, data.length(), imageType);
2406
2407         return true;
2408     }
2409     else
2410         return false;
2411 }
2412
2413 #if wxRICHTEXT_HAVE_DIRECT_OUTPUT
2414 // Export this object directly to the given stream.
2415 bool wxRichTextImage::ExportXML(wxOutputStream& stream, int indent, wxRichTextXMLHandler* handler)
2416 {
2417     wxString style = handler->AddAttributes(GetAttributes(), false);
2418
2419     ::OutputIndentation(stream, indent);
2420     ::OutputString(stream, wxT("<image"), handler->GetConvMem(), handler->GetConvFile());
2421     if (!GetImageBlock().IsOk())
2422     {
2423         // No data
2424         ::OutputString(stream, style + wxT(">"), handler->GetConvMem(), handler->GetConvFile());
2425     }
2426     else
2427     {
2428         ::OutputString(stream, wxString::Format(wxT(" imagetype=\"%d\""), (int) GetImageBlock().GetImageType()) + style + wxT(">"), handler->GetConvMem(), handler->GetConvFile());
2429     }
2430     if (GetProperties().GetCount() > 0)
2431     {
2432         handler->WriteProperties(stream, GetProperties(), indent);
2433         ::OutputIndentation(stream, indent);
2434     }
2435
2436     ::OutputIndentation(stream, indent+1);
2437     ::OutputString(stream, wxT("<data>"), handler->GetConvMem(), handler->GetConvFile());
2438
2439     // wxStopWatch stopwatch;
2440
2441     GetImageBlock().WriteHex(stream);
2442
2443     // wxLogDebug(wxT("Image conversion to hex took %ldms"), stopwatch.Time());
2444
2445     ::OutputString(stream, wxT("</data>\n"), handler->GetConvMem(), handler->GetConvFile());
2446     ::OutputIndentation(stream, indent);
2447     ::OutputString(stream, wxT("</image>"), handler->GetConvMem(), handler->GetConvFile());
2448     return true;
2449 }
2450 #endif
2451
2452 #if wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT
2453 // Export this object to the given parent node, usually creating at least one child node.
2454 bool wxRichTextImage::ExportXML(wxXmlNode* parent, wxRichTextXMLHandler* handler)
2455 {
2456     wxXmlNode* elementNode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("image"));
2457     parent->AddChild(elementNode);
2458
2459     if (GetImageBlock().IsOk())
2460         elementNode->AddAttribute(wxT("imagetype"), MakeString((int) GetImageBlock().GetImageType()));
2461
2462     handler->AddAttributes(elementNode, GetAttributes(), false);
2463     handler->WriteProperties(elementNode, GetProperties());
2464
2465     wxXmlNode* dataNode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("data"));
2466     elementNode->AddChild(dataNode);
2467     wxXmlNode* textNode = new wxXmlNode(wxXML_TEXT_NODE, wxT("text"));
2468     dataNode->AddChild(textNode);
2469
2470     wxString strData;
2471 #if 1
2472     {
2473         wxMemoryOutputStream stream;
2474         if (GetImageBlock().WriteHex(stream))
2475         {
2476             if (stream.GetSize() > 0)
2477             {
2478                 int size = stream.GetSize();
2479 #ifdef __WXDEBUG__
2480                 int size2 = stream.GetOutputStreamBuffer()->GetIntPosition();
2481                 wxASSERT(size == size2);
2482 #endif
2483                 unsigned char* data = new unsigned char[size];
2484                 stream.CopyTo(data, size);
2485                 strData = wxString((const char*) data, wxConvUTF8, size);
2486                 delete[] data;
2487             }
2488             else
2489                 strData = wxEmptyString;
2490         }
2491
2492     }
2493 #else
2494     {
2495         wxStringOutputStream strStream(& strData);
2496         GetImageBlock().WriteHex(strStream);
2497     }
2498 #endif
2499
2500     textNode->SetContent(strData);
2501     textNode->SetNoConversion(true); // optimize speed
2502
2503     return true;
2504 }
2505 #endif
2506
2507
2508 // Import this object from XML
2509 bool wxRichTextParagraphLayoutBox::ImportFromXML(wxRichTextBuffer* buffer, wxXmlNode* node, wxRichTextXMLHandler* handler, bool* recurse)
2510 {
2511     wxRichTextObject::ImportFromXML(buffer, node, handler, recurse);
2512
2513     *recurse = true;
2514
2515     wxString partial = node->GetAttribute(wxT("partialparagraph"), wxEmptyString);
2516     if (partial == wxT("true"))
2517         SetPartialParagraph(true);
2518
2519     wxXmlNode* child = wxRichTextXMLHandler::FindNode(node, wxT("stylesheet"));
2520     if (child && (handler->GetFlags() & wxRICHTEXT_HANDLER_INCLUDE_STYLESHEET))
2521     {
2522         wxRichTextStyleSheet* sheet = new wxRichTextStyleSheet;
2523         wxString sheetName = child->GetAttribute(wxT("name"), wxEmptyString);
2524         wxString sheetDescription = child->GetAttribute(wxT("description"), wxEmptyString);
2525         sheet->SetName(sheetName);
2526         sheet->SetDescription(sheetDescription);
2527
2528         wxXmlNode* child2 = child->GetChildren();
2529         while (child2)
2530         {
2531             handler->ImportStyleDefinition(sheet, child2);
2532
2533             child2 = child2->GetNext();
2534         }
2535
2536         // Notify that styles have changed. If this is vetoed by the app,
2537         // the new sheet will be deleted. If it is not vetoed, the
2538         // old sheet will be deleted and replaced with the new one.
2539         buffer->SetStyleSheetAndNotify(sheet);
2540     }
2541
2542     return true;
2543 }
2544
2545 #if wxRICHTEXT_HAVE_DIRECT_OUTPUT
2546 // Export this object directly to the given stream.
2547 bool wxRichTextParagraphLayoutBox::ExportXML(wxOutputStream& stream, int indent, wxRichTextXMLHandler* handler)
2548 {
2549     ::OutputIndentation(stream, indent);
2550     wxString nodeName = GetXMLNodeName();
2551     ::OutputString(stream, wxT("<") + nodeName, handler->GetConvMem(), handler->GetConvFile());
2552
2553     wxString style = handler->AddAttributes(GetAttributes(), true);
2554
2555     if (GetPartialParagraph())
2556         style << wxT(" partialparagraph=\"true\"");
2557
2558     ::OutputString(stream, style + wxT(">"), handler->GetConvMem(), handler->GetConvFile());
2559
2560     if (GetProperties().GetCount() > 0)
2561     {
2562         handler->WriteProperties(stream, GetProperties(), indent);
2563     }
2564
2565     size_t i;
2566     for (i = 0; i < GetChildCount(); i++)
2567     {
2568         wxRichTextObject* child = GetChild(i);
2569         child->ExportXML(stream, indent+1, handler);
2570     }
2571
2572     ::OutputIndentation(stream, indent);
2573     ::OutputString(stream, wxT("</") + nodeName + wxT(">"), handler->GetConvMem(), handler->GetConvFile());
2574     return true;
2575 }
2576 #endif
2577
2578 #if wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT
2579 // Export this object to the given parent node, usually creating at least one child node.
2580 bool wxRichTextParagraphLayoutBox::ExportXML(wxXmlNode* parent, wxRichTextXMLHandler* handler)
2581 {
2582     wxXmlNode* elementNode = new wxXmlNode(wxXML_ELEMENT_NODE, GetXMLNodeName());
2583     parent->AddChild(elementNode);
2584     handler->AddAttributes(elementNode, GetAttributes(), true);
2585     handler->WriteProperties(elementNode, GetProperties());
2586
2587     if (GetPartialParagraph())
2588         elementNode->AddAttribute(wxT("partialparagraph"), wxT("true"));
2589
2590     size_t i;
2591     for (i = 0; i < GetChildCount(); i++)
2592     {
2593         wxRichTextObject* child = GetChild(i);
2594         child->ExportXML(elementNode, handler);
2595     }
2596
2597     return true;
2598 }
2599 #endif
2600
2601 // Import this object from XML
2602 bool wxRichTextTable::ImportFromXML(wxRichTextBuffer* buffer, wxXmlNode* node, wxRichTextXMLHandler* handler, bool* recurse)
2603 {
2604     wxRichTextBox::ImportFromXML(buffer, node, handler, recurse);
2605
2606     *recurse = false;
2607
2608     m_rowCount = wxAtoi(node->GetAttribute(wxT("rows"), wxEmptyString));
2609     m_colCount = wxAtoi(node->GetAttribute(wxT("cols"), wxEmptyString));
2610
2611     wxXmlNode* child = node->GetChildren();
2612     while (child)
2613     {
2614         wxRichTextObject* childObj = handler->CreateObjectForXMLName(this, child->GetName());
2615         if (childObj)
2616         {
2617             AppendChild(childObj);
2618             handler->ImportXML(buffer, childObj, child);
2619         }
2620         child = child->GetNext();
2621     }
2622
2623     m_cells.Add(wxRichTextObjectPtrArray(), m_rowCount);
2624     int i, j;
2625     for (i = 0; i < m_rowCount; i++)
2626     {
2627         wxRichTextObjectPtrArray& colArray = m_cells[i];
2628         for (j = 0; j < m_colCount; j++)
2629         {
2630             int idx = i * m_colCount + j;
2631             if (idx < (int) GetChildren().GetCount())
2632             {
2633                 wxRichTextCell* cell = wxDynamicCast(GetChildren().Item(idx)->GetData(), wxRichTextCell);
2634                 if (cell)
2635                     colArray.Add(cell);
2636             }
2637         }
2638     }
2639
2640     return true;
2641 }
2642
2643 #if wxRICHTEXT_HAVE_DIRECT_OUTPUT
2644 // Export this object directly to the given stream.
2645 bool wxRichTextTable::ExportXML(wxOutputStream& stream, int indent, wxRichTextXMLHandler* handler)
2646 {
2647     ::OutputIndentation(stream, indent);
2648     wxString nodeName = GetXMLNodeName();
2649     ::OutputString(stream, wxT("<") + nodeName, handler->GetConvMem(), handler->GetConvFile());
2650
2651     wxString style = handler->AddAttributes(GetAttributes(), true);
2652
2653     style << wxT(" rows=\"") << m_rowCount << wxT("\"");
2654     style << wxT(" cols=\"") << m_colCount << wxT("\"");
2655
2656     ::OutputString(stream, style + wxT(">"), handler->GetConvMem(), handler->GetConvFile());
2657
2658     if (GetProperties().GetCount() > 0)
2659     {
2660         handler->WriteProperties(stream, GetProperties(), indent);
2661     }
2662
2663     int i, j;
2664     for (i = 0; i < m_rowCount; i++)
2665     {
2666         for (j = 0; j < m_colCount; j ++)
2667         {
2668             wxRichTextCell* cell = GetCell(i, j);
2669             cell->ExportXML(stream, indent+1, handler);
2670         }
2671     }
2672
2673     ::OutputIndentation(stream, indent);
2674     ::OutputString(stream, wxT("</") + nodeName + wxT(">"), handler->GetConvMem(), handler->GetConvFile());
2675
2676     return true;
2677 }
2678 #endif
2679
2680 #if wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT
2681 // Export this object to the given parent node, usually creating at least one child node.
2682 bool wxRichTextTable::ExportXML(wxXmlNode* parent, wxRichTextXMLHandler* handler)
2683 {
2684     wxXmlNode* elementNode = new wxXmlNode(wxXML_ELEMENT_NODE, GetXMLNodeName());
2685     parent->AddChild(elementNode);
2686     handler->AddAttributes(elementNode, GetAttributes(), true);
2687     handler->WriteProperties(elementNode, GetProperties());
2688
2689     elementNode->AddAttribute(wxT("rows"), wxString::Format(wxT("%d"), m_rowCount));
2690     elementNode->AddAttribute(wxT("cols"), wxString::Format(wxT("%d"), m_colCount));
2691
2692     int i, j;
2693     for (i = 0; i < m_rowCount; i++)
2694     {
2695         for (j = 0; j < m_colCount; j ++)
2696         {
2697             wxRichTextCell* cell = GetCell(i, j);
2698             cell->ExportXML(elementNode, handler);
2699         }
2700     }
2701
2702     return true;
2703 }
2704 #endif
2705
2706
2707 #endif
2708     // wxUSE_RICHTEXT && wxUSE_XML
2709