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/tokenzr.h"
  35 #include "wx/xml/xml.h"
  36
  37 IMPLEMENT_DYNAMIC_CLASS(wxRichTextXMLHandler, wxRichTextFileHandler)
  38
  39 #if wxUSE_STREAMS
  40 bool wxRichTextXMLHandler::DoLoadFile(wxRichTextBuffer *buffer, wxInputStream& stream)
  41 {
  42     if (!stream.IsOk())
  43         return false;
  44
  45     buffer->ResetAndClearCommands();
  46     buffer->Clear();
  47
  48     wxXmlDocument* xmlDoc = new wxXmlDocument;
  49     bool success = true;
  50
  51     // This is the encoding to convert to (memory encoding rather than file encoding)
  52     wxString encoding(wxT("UTF-8"));
  53
  54 #if !wxUSE_UNICODE && wxUSE_INTL
  55     encoding = wxLocale::GetSystemEncodingName();
  56 #endif
  57
  58     if (!xmlDoc->Load(stream, encoding))
  59     {
  60         buffer->ResetAndClearCommands();
  61         success = false;
  62     }
  63     else
  64     {
  65         if (xmlDoc->GetRoot() && xmlDoc->GetRoot()->GetType() == wxXML_ELEMENT_NODE && xmlDoc->GetRoot()->GetName() == wxT("richtext"))
  66         {
  67             wxXmlNode* child = xmlDoc->GetRoot()->GetChildren();
  68             while (child)
  69             {
  70                 if (child->GetType() == wxXML_ELEMENT_NODE)
  71                 {
  72                     wxString name = child->GetName();
  73                     if (name == wxT("richtext-version"))
  74                     {
  75                     }
  76                     else
  77                         ImportXML(buffer, child);
  78                 }
  79
  80                 child = child->GetNext();
  81             }
  82         }
  83         else
  84         {
  85             success = false;
  86         }
  87     }
  88
  89     delete xmlDoc;
  90
  91     buffer->UpdateRanges();
  92
  93     return success;
  94 }
  95
  96 /// Recursively import an object
  97 bool wxRichTextXMLHandler::ImportXML(wxRichTextBuffer* buffer, wxXmlNode* node)
  98 {
  99     wxString name = node->GetName();
 100
 101     bool doneChildren = false;
 102
 103     if (name == wxT("paragraphlayout"))
 104     {
 105         wxString partial = node->GetAttribute(wxT("partialparagraph"), wxEmptyString);
 106         if (partial == wxT("true"))
 107             buffer->SetPartialParagraph(true);
 108     }
 109     else if (name == wxT("paragraph"))
 110     {
 111         wxRichTextParagraph* para = new wxRichTextParagraph(buffer);
 112         buffer->AppendChild(para);
 113
 114         GetStyle(para->GetAttributes(), node, true);
 115
 116         wxXmlNode* child = node->GetChildren();
 117         while (child)
 118         {
 119             wxString childName = child->GetName();
 120             if (childName == wxT("text"))
 121             {
 122                 wxString text;
 123                 wxXmlNode* textChild = child->GetChildren();
 124                 while (textChild)
 125                 {
 126                     if (textChild->GetType() == wxXML_TEXT_NODE ||
 127                         textChild->GetType() == wxXML_CDATA_SECTION_NODE)
 128                     {
 129                         wxString text2 = textChild->GetContent();
 130
 131                         // Strip whitespace from end
 132                         if (!text2.empty() && text2[text2.length()-1] == wxT('\n'))
 133                             text2 = text2.Mid(0, text2.length()-1);
 134
 135                         if (!text2.empty() && text2[0] == wxT('"'))
 136                             text2 = text2.Mid(1);
 137                         if (!text2.empty() && text2[text2.length()-1] == wxT('"'))
 138                             text2 = text2.Mid(0, text2.length() - 1);
 139
 140                         text += text2;
 141                     }
 142                     textChild = textChild->GetNext();
 143                 }
 144
 145                 wxRichTextPlainText* textObject = new wxRichTextPlainText(text, para);
 146                 GetStyle(textObject->GetAttributes(), child, false);
 147
 148                 para->AppendChild(textObject);
 149             }
 150             else if (childName == wxT("symbol"))
 151             {
 152                 // This is a symbol that XML can't read in the normal way
 153                 wxString text;
 154                 wxXmlNode* textChild = child->GetChildren();
 155                 while (textChild)
 156                 {
 157                     if (textChild->GetType() == wxXML_TEXT_NODE ||
 158                         textChild->GetType() == wxXML_CDATA_SECTION_NODE)
 159                     {
 160                         wxString text2 = textChild->GetContent();
 161                         text += text2;
 162                     }
 163                     textChild = textChild->GetNext();
 164                 }
 165
 166                 wxString actualText;
 167                 actualText << (wxChar) wxAtoi(text);
 168
 169                 wxRichTextPlainText* textObject = new wxRichTextPlainText(actualText, para);
 170                 GetStyle(textObject->GetAttributes(), child, false);
 171
 172                 para->AppendChild(textObject);
 173             }
 174             else if (childName == wxT("image"))
 175             {
 176                 wxBitmapType imageType = wxBITMAP_TYPE_PNG;
 177                 wxString value = child->GetAttribute(wxT("imagetype"), wxEmptyString);
 178                 if (!value.empty())
 179                 {
 180                     int type = wxAtoi(value);
 181
 182                     // note: 0 == wxBITMAP_TYPE_INVALID
 183                     if (type <= 0 || type >= wxBITMAP_TYPE_MAX)
 184                     {
 185                         wxLogWarning("Invalid bitmap type specified for <image> tag: %d", type);
 186                     }
 187                     else
 188                     {
 189                         imageType = (wxBitmapType)type;
 190                     }
 191                 }
 192
 193                 wxString data;
 194
 195                 wxXmlNode* imageChild = child->GetChildren();
 196                 while (imageChild)
 197                 {
 198                     wxString childName = imageChild->GetName();
 199                     if (childName == wxT("data"))
 200                     {
 201                         wxXmlNode* dataChild = imageChild->GetChildren();
 202                         while (dataChild)
 203                         {
 204                             data = dataChild->GetContent();
 205                             // wxLogDebug(data);
 206                             dataChild = dataChild->GetNext();
 207                         }
 208
 209                     }
 210                     imageChild = imageChild->GetNext();
 211                 }
 212
 213                 if (!data.empty())
 214                 {
 215                     wxRichTextImage* imageObj = new wxRichTextImage(para);
 216                     GetStyle(imageObj->GetAttributes(), child, false);
 217                     para->AppendChild(imageObj);
 218
 219                     wxStringInputStream strStream(data);
 220
 221                     imageObj->GetImageBlock().ReadHex(strStream, data.length(), imageType);
 222                 }
 223             }
 224             child = child->GetNext();
 225         }
 226
 227         doneChildren = true;
 228     }
 229     else if (name == wxT("stylesheet"))
 230     {
 231         if (GetFlags() & wxRICHTEXT_HANDLER_INCLUDE_STYLESHEET)
 232         {
 233             wxRichTextStyleSheet* sheet = new wxRichTextStyleSheet;
 234             wxString sheetName = node->GetAttribute(wxT("name"), wxEmptyString);
 235             wxString sheetDescription = node->GetAttribute(wxT("description"), wxEmptyString);
 236             sheet->SetName(sheetName);
 237             sheet->SetDescription(sheetDescription);
 238
 239             wxXmlNode* child = node->GetChildren();
 240             while (child)
 241             {
 242                 ImportStyleDefinition(sheet, child);
 243
 244                 child = child->GetNext();
 245             }
 246
 247             // Notify that styles have changed. If this is vetoed by the app,
 248             // the new sheet will be deleted. If it is not vetoed, the
 249             // old sheet will be deleted and replaced with the new one.
 250             buffer->SetStyleSheetAndNotify(sheet);
 251         }
 252         doneChildren = true;
 253     }
 254
 255     if (!doneChildren)
 256     {
 257         wxXmlNode* child = node->GetChildren();
 258         while (child)
 259         {
 260             ImportXML(buffer, child);
 261             child = child->GetNext();
 262         }
 263     }
 264
 265     return true;
 266 }
 267
 268 bool wxRichTextXMLHandler::ImportStyleDefinition(wxRichTextStyleSheet* sheet, wxXmlNode* node)
 269 {
 270     wxString styleType = node->GetName();
 271     wxString styleName = node->GetAttribute(wxT("name"), wxEmptyString);
 272     wxString baseStyleName = node->GetAttribute(wxT("basestyle"), wxEmptyString);
 273
 274     if (styleName.IsEmpty())
 275         return false;
 276
 277     if (styleType == wxT("characterstyle"))
 278     {
 279         wxRichTextCharacterStyleDefinition* def = new wxRichTextCharacterStyleDefinition(styleName);
 280         def->SetBaseStyle(baseStyleName);
 281
 282         wxXmlNode* child = node->GetChildren();
 283         while (child)
 284         {
 285             if (child->GetName() == wxT("style"))
 286             {
 287                 wxTextAttr attr;
 288                 GetStyle(attr, child, false);
 289                 def->SetStyle(attr);
 290             }
 291             child = child->GetNext();
 292         }
 293
 294         sheet->AddCharacterStyle(def);
 295     }
 296     else if (styleType == wxT("paragraphstyle"))
 297     {
 298         wxRichTextParagraphStyleDefinition* def = new wxRichTextParagraphStyleDefinition(styleName);
 299
 300         wxString nextStyleName = node->GetAttribute(wxT("nextstyle"), wxEmptyString);
 301         def->SetNextStyle(nextStyleName);
 302         def->SetBaseStyle(baseStyleName);
 303
 304         wxXmlNode* child = node->GetChildren();
 305         while (child)
 306         {
 307             if (child->GetName() == wxT("style"))
 308             {
 309                 wxTextAttr attr;
 310                 GetStyle(attr, child, false);
 311                 def->SetStyle(attr);
 312             }
 313             child = child->GetNext();
 314         }
 315
 316         sheet->AddParagraphStyle(def);
 317     }
 318     else if (styleType == wxT("liststyle"))
 319     {
 320         wxRichTextListStyleDefinition* def = new wxRichTextListStyleDefinition(styleName);
 321
 322         wxString nextStyleName = node->GetAttribute(wxT("nextstyle"), wxEmptyString);
 323         def->SetNextStyle(nextStyleName);
 324         def->SetBaseStyle(baseStyleName);
 325
 326         wxXmlNode* child = node->GetChildren();
 327         while (child)
 328         {
 329             if (child->GetName() == wxT("style"))
 330             {
 331                 wxTextAttr attr;
 332                 GetStyle(attr, child, false);
 333
 334                 wxString styleLevel = child->GetAttribute(wxT("level"), wxEmptyString);
 335                 if (styleLevel.IsEmpty())
 336                 {
 337                     def->SetStyle(attr);
 338                 }
 339                 else
 340                 {
 341                     int level = wxAtoi(styleLevel);
 342                     if (level > 0 && level <= 10)
 343                     {
 344                         def->SetLevelAttributes(level-1, attr);
 345                     }
 346                 }
 347             }
 348             child = child->GetNext();
 349         }
 350
 351         sheet->AddListStyle(def);
 352     }
 353
 354     return true;
 355 }
 356
 357 //-----------------------------------------------------------------------------
 358 //  xml support routines
 359 //-----------------------------------------------------------------------------
 360
 361 bool wxRichTextXMLHandler::HasParam(wxXmlNode* node, const wxString& param)
 362 {
 363     return (GetParamNode(node, param) != NULL);
 364 }
 365
 366 wxXmlNode *wxRichTextXMLHandler::GetParamNode(wxXmlNode* node, const wxString& param)
 367 {
 368     wxCHECK_MSG(node, NULL, wxT("You can't access node data before it was initialized!"));
 369
 370     wxXmlNode *n = node->GetChildren();
 371
 372     while (n)
 373     {
 374         if (n->GetType() == wxXML_ELEMENT_NODE && n->GetName() == param)
 375             return n;
 376         n = n->GetNext();
 377     }
 378     return NULL;
 379 }
 380
 381
 382 wxString wxRichTextXMLHandler::GetNodeContent(wxXmlNode *node)
 383 {
 384     wxXmlNode *n = node;
 385     if (n == NULL) return wxEmptyString;
 386     n = n->GetChildren();
 387
 388     while (n)
 389     {
 390         if (n->GetType() == wxXML_TEXT_NODE ||
 391             n->GetType() == wxXML_CDATA_SECTION_NODE)
 392             return n->GetContent();
 393         n = n->GetNext();
 394     }
 395     return wxEmptyString;
 396 }
 397
 398
 399 wxString wxRichTextXMLHandler::GetParamValue(wxXmlNode *node, const wxString& param)
 400 {
 401     if (param.empty())
 402         return GetNodeContent(node);
 403     else
 404         return GetNodeContent(GetParamNode(node, param));
 405 }
 406
 407 wxString wxRichTextXMLHandler::GetText(wxXmlNode *node, const wxString& param, bool WXUNUSED(translate))
 408 {
 409     wxXmlNode *parNode = GetParamNode(node, param);
 410     if (!parNode)
 411         parNode = node;
 412     wxString str1(GetNodeContent(parNode));
 413     return str1;
 414 }
 415
 416 // For use with earlier versions of wxWidgets
 417 #ifndef WXUNUSED_IN_UNICODE
 418 #if wxUSE_UNICODE
 419 #define WXUNUSED_IN_UNICODE(x) WXUNUSED(x)
 420 #else
 421 #define WXUNUSED_IN_UNICODE(x) x
 422 #endif
 423 #endif
 424
 425 // write string to output:
 426 inline static void OutputString(wxOutputStream& stream, const wxString& str,
 427                                 wxMBConv *WXUNUSED_IN_UNICODE(convMem) = NULL, wxMBConv *convFile = NULL)
 428 {
 429     if (str.empty()) return;
 430 #if wxUSE_UNICODE
 431     if (convFile)
 432     {
 433         const wxWX2MBbuf buf(str.mb_str(*convFile));
 434         stream.Write((const char*)buf, strlen((const char*)buf));
 435     }
 436     else
 437     {
 438         const wxWX2MBbuf buf(str.mb_str(wxConvUTF8));
 439         stream.Write((const char*)buf, strlen((const char*)buf));
 440     }
 441 #else
 442     if ( convFile == NULL )
 443         stream.Write(str.mb_str(), str.Len());
 444     else
 445     {
 446         wxString str2(str.wc_str(*convMem), *convFile);
 447         stream.Write(str2.mb_str(), str2.Len());
 448     }
 449 #endif
 450 }
 451
 452 // Same as above, but create entities first.
 453 // Translates '<' to "&lt;", '>' to "&gt;" and '&' to "&amp;"
 454 static void OutputStringEnt(wxOutputStream& stream, const wxString& str,
 455                             wxMBConv *convMem = NULL, wxMBConv *convFile = NULL)
 456 {
 457     wxString buf;
 458     size_t i, last, len;
 459     wxChar c;
 460
 461     len = str.Len();
 462     last = 0;
 463     for (i = 0; i < len; i++)
 464     {
 465         c = str.GetChar(i);
 466
 467         // Original code excluded "&amp;" but we _do_ want to convert
 468         // the ampersand beginning &amp; because otherwise when read in,
 469         // the original "&amp;" becomes "&".
 470
 471         if (c == wxT('<') || c == wxT('>') || c == wxT('"') ||
 472             (c == wxT('&') /* && (str.Mid(i+1, 4) != wxT("amp;")) */ ))
 473         {
 474             OutputString(stream, str.Mid(last, i - last), convMem, convFile);
 475             switch (c)
 476             {
 477             case wxT('<'):
 478                 OutputString(stream, wxT("&lt;"), NULL, NULL);
 479                 break;
 480             case wxT('>'):
 481                 OutputString(stream, wxT("&gt;"), NULL, NULL);
 482                 break;
 483             case wxT('&'):
 484                 OutputString(stream, wxT("&amp;"), NULL, NULL);
 485                 break;
 486             case wxT('"'):
 487                 OutputString(stream, wxT("&quot;"), NULL, NULL);
 488                 break;
 489             default: break;
 490             }
 491             last = i + 1;
 492         }
 493         else if (wxUChar(c) > 127)
 494         {
 495             OutputString(stream, str.Mid(last, i - last), convMem, convFile);
 496
 497             wxString s(wxT("&#"));
 498 #if wxUSE_UNICODE
 499             s << (int) c;
 500 #else
 501             s << (int) wxUChar(c);
 502 #endif
 503             s << wxT(";");
 504             OutputString(stream, s, NULL, NULL);
 505             last = i + 1;
 506         }
 507     }
 508     OutputString(stream, str.Mid(last, i - last), convMem, convFile);
 509 }
 510
 511 static wxString AttributeToXML(const wxString& str)
 512 {
 513     wxString str1;
 514     size_t i, last, len;
 515     wxChar c;
 516
 517     len = str.Len();
 518     last = 0;
 519     for (i = 0; i < len; i++)
 520     {
 521         c = str.GetChar(i);
 522
 523         // Original code excluded "&amp;" but we _do_ want to convert
 524         // the ampersand beginning &amp; because otherwise when read in,
 525         // the original "&amp;" becomes "&".
 526
 527         if (c == wxT('<') || c == wxT('>') || c == wxT('"') ||
 528             (c == wxT('&') /* && (str.Mid(i+1, 4) != wxT("amp;")) */ ))
 529         {
 530             str1 += str.Mid(last, i - last);
 531             switch (c)
 532             {
 533             case wxT('<'):
 534                 str1 += wxT("&lt;");
 535                 break;
 536             case wxT('>'):
 537                 str1 += wxT("&gt;");
 538                 break;
 539             case wxT('&'):
 540                 str1 += wxT("&amp;");
 541                 break;
 542             case wxT('"'):
 543                 str1 += wxT("&quot;");
 544                 break;
 545             default: break;
 546             }
 547             last = i + 1;
 548         }
 549         else if (wxUChar(c) > 127)
 550         {
 551             str1 += str.Mid(last, i - last);
 552
 553             wxString s(wxT("&#"));
 554 #if wxUSE_UNICODE
 555             s << (int) c;
 556 #else
 557             s << (int) wxUChar(c);
 558 #endif
 559             s << wxT(";");
 560             str1 += s;
 561             last = i + 1;
 562         }
 563     }
 564     str1 += str.Mid(last, i - last);
 565     return str1;
 566 }
 567
 568 inline static void OutputIndentation(wxOutputStream& stream, int indent)
 569 {
 570     wxString str = wxT("\n");
 571     for (int i = 0; i < indent; i++)
 572         str << wxT(' ') << wxT(' ');
 573     OutputString(stream, str, NULL, NULL);
 574 }
 575
 576 // Convert a colour to a 6-digit hex string
 577 static wxString ColourToHexString(const wxColour& col)
 578 {
 579     wxString hex;
 580
 581     hex += wxDecToHex(col.Red());
 582     hex += wxDecToHex(col.Green());
 583     hex += wxDecToHex(col.Blue());
 584
 585     return hex;
 586 }
 587
 588 // Convert 6-digit hex string to a colour
 589 static wxColour HexStringToColour(const wxString& hex)
 590 {
 591     unsigned char r = (unsigned char)wxHexToDec(hex.Mid(0, 2));
 592     unsigned char g = (unsigned char)wxHexToDec(hex.Mid(2, 2));
 593     unsigned char b = (unsigned char)wxHexToDec(hex.Mid(4, 2));
 594
 595     return wxColour(r, g, b);
 596 }
 597
 598 bool wxRichTextXMLHandler::DoSaveFile(wxRichTextBuffer *buffer, wxOutputStream& stream)
 599 {
 600     if (!stream.IsOk())
 601         return false;
 602
 603     wxString version(wxT("1.0") ) ;
 604
 605     bool deleteConvFile = false;
 606     wxString fileEncoding;
 607     wxMBConv* convFile = NULL;
 608
 609 #if wxUSE_UNICODE
 610     fileEncoding = wxT("UTF-8");
 611     convFile = & wxConvUTF8;
 612 #else
 613     fileEncoding = wxT("ISO-8859-1");
 614     convFile = & wxConvISO8859_1;
 615 #endif
 616
 617     // If SetEncoding has been called, change the output encoding.
 618     if (!m_encoding.empty() && m_encoding.Lower() != fileEncoding.Lower())
 619     {
 620         if (m_encoding == wxT("<System>"))
 621         {
 622 #if wxUSE_INTL
 623             fileEncoding = wxLocale::GetSystemEncodingName();
 624             // if !wxUSE_INTL, we fall back to UTF-8 or ISO-8859-1 below
 625 #endif
 626         }
 627         else
 628         {
 629             fileEncoding = m_encoding;
 630         }
 631
 632         // GetSystemEncodingName may not have returned a name
 633         if (fileEncoding.empty())
 634 #if wxUSE_UNICODE
 635             fileEncoding = wxT("UTF-8");
 636 #else
 637             fileEncoding = wxT("ISO-8859-1");
 638 #endif
 639         convFile = new wxCSConv(fileEncoding);
 640         deleteConvFile = true;
 641     }
 642
 643 #if !wxUSE_UNICODE
 644     wxMBConv* convMem = wxConvCurrent;
 645 #else
 646     wxMBConv* convMem = NULL;
 647 #endif
 648
 649     wxString s ;
 650     s.Printf(wxT("<?xml version=\"%s\" encoding=\"%s\"?>\n"),
 651              version, fileEncoding);
 652     OutputString(stream, s, NULL, NULL);
 653     OutputString(stream, wxT("<richtext version=\"1.0.0.0\" xmlns=\"http://www.wxwidgets.org\">") , NULL, NULL);
 654
 655     int level = 1;
 656
 657     if (buffer->GetStyleSheet() && (GetFlags() & wxRICHTEXT_HANDLER_INCLUDE_STYLESHEET))
 658     {
 659         OutputIndentation(stream, level);
 660         wxString nameAndDescr;
 661         if (!buffer->GetStyleSheet()->GetName().IsEmpty())
 662             nameAndDescr << wxT(" name=\"") << buffer->GetStyleSheet()->GetName() << wxT("\"");
 663         if (!buffer->GetStyleSheet()->GetDescription().IsEmpty())
 664             nameAndDescr << wxT(" description=\"") << buffer->GetStyleSheet()->GetDescription() << wxT("\"");
 665         OutputString(stream, wxString(wxT("<stylesheet")) + nameAndDescr + wxT(">"), convMem, convFile);
 666
 667         int i;
 668
 669         for (i = 0; i < (int) buffer->GetStyleSheet()->GetCharacterStyleCount(); i++)
 670         {
 671             wxRichTextCharacterStyleDefinition* def = buffer->GetStyleSheet()->GetCharacterStyle(i);
 672             ExportStyleDefinition(stream, convMem, convFile, def, level + 1);
 673         }
 674
 675         for (i = 0; i < (int) buffer->GetStyleSheet()->GetParagraphStyleCount(); i++)
 676         {
 677             wxRichTextParagraphStyleDefinition* def = buffer->GetStyleSheet()->GetParagraphStyle(i);
 678             ExportStyleDefinition(stream, convMem, convFile, def, level + 1);
 679         }
 680
 681         for (i = 0; i < (int) buffer->GetStyleSheet()->GetListStyleCount(); i++)
 682         {
 683             wxRichTextListStyleDefinition* def = buffer->GetStyleSheet()->GetListStyle(i);
 684             ExportStyleDefinition(stream, convMem, convFile, def, level + 1);
 685         }
 686
 687         OutputIndentation(stream, level);
 688         OutputString(stream, wxT("</stylesheet>"), convMem, convFile);
 689     }
 690
 691
 692     bool success = ExportXML(stream, convMem, convFile, *buffer, level);
 693
 694     OutputString(stream, wxT("\n</richtext>") , NULL, NULL);
 695     OutputString(stream, wxT("\n"), NULL, NULL);
 696
 697     if (deleteConvFile)
 698         delete convFile;
 699
 700     return success;
 701 }
 702
 703 /// Recursively export an object
 704 bool wxRichTextXMLHandler::ExportXML(wxOutputStream& stream, wxMBConv* convMem, wxMBConv* convFile, wxRichTextObject& obj, int indent)
 705 {
 706     wxString objectName;
 707     if (obj.IsKindOf(CLASSINFO(wxRichTextParagraphLayoutBox)))
 708         objectName = wxT("paragraphlayout");
 709     else if (obj.IsKindOf(CLASSINFO(wxRichTextParagraph)))
 710         objectName = wxT("paragraph");
 711     else if (obj.IsKindOf(CLASSINFO(wxRichTextPlainText)))
 712         objectName = wxT("text");
 713     else if (obj.IsKindOf(CLASSINFO(wxRichTextImage)))
 714         objectName = wxT("image");
 715     else
 716         objectName = wxT("object");
 717
 718     bool terminateTag = true;
 719
 720     if (obj.IsKindOf(CLASSINFO(wxRichTextPlainText)))
 721     {
 722         wxRichTextPlainText& textObj = (wxRichTextPlainText&) obj;
 723
 724         wxString style = CreateStyle(obj.GetAttributes(), false);
 725
 726         int i;
 727         int last = 0;
 728         const wxString& text = textObj.GetText();
 729         int len = (int) text.Length();
 730
 731         if (len == 0)
 732         {
 733             i = 0;
 734             OutputIndentation(stream, indent);
 735             OutputString(stream, wxT("<") + objectName, convMem, convFile);
 736             OutputString(stream, style + wxT(">"), convMem, convFile);
 737             OutputString(stream, wxT("</text>"), convMem, convFile);
 738         }
 739         else for (i = 0; i < len; i++)
 740         {
 741 #if wxUSE_UNICODE
 742             int c = (int) text[i];
 743 #else
 744             int c = (int) wxUChar(text[i]);
 745 #endif
 746             if ((c < 32 || c == 34) && /* c != 9 && */ c != 10 && c != 13)
 747             {
 748                 if (i > 0)
 749                 {
 750                     wxString fragment(text.Mid(last, i-last));
 751                     if (!fragment.IsEmpty())
 752                     {
 753                         OutputIndentation(stream, indent);
 754                         OutputString(stream, wxT("<") + objectName, convMem, convFile);
 755
 756                         OutputString(stream, style + wxT(">"), convMem, convFile);
 757
 758                         if (!fragment.empty() && (fragment[0] == wxT(' ') || fragment[fragment.length()-1] == wxT(' ')))
 759                         {
 760                             OutputString(stream, wxT("\""), convMem, convFile);
 761                             OutputStringEnt(stream, fragment, convMem, convFile);
 762                             OutputString(stream, wxT("\""), convMem, convFile);
 763                         }
 764                         else
 765                             OutputStringEnt(stream, fragment, convMem, convFile);
 766
 767                         OutputString(stream, wxT("</text>"), convMem, convFile);
 768                     }
 769                 }
 770
 771
 772                 // Output this character as a number in a separate tag, because XML can't cope
 773                 // with entities below 32 except for 10 and 13
 774                 last = i + 1;
 775                 OutputIndentation(stream, indent);
 776                 OutputString(stream, wxT("<symbol"), convMem, convFile);
 777
 778                 OutputString(stream, style + wxT(">"), convMem, convFile);
 779                 OutputString(stream, wxString::Format(wxT("%d"), c), convMem, convFile);
 780
 781                 OutputString(stream, wxT("</symbol>"), convMem, convFile);
 782             }
 783         }
 784
 785         wxString fragment;
 786         if (last == 0)
 787             fragment = text;
 788         else
 789             fragment = text.Mid(last, i-last);
 790
 791         if (last < len)
 792         {
 793             OutputIndentation(stream, indent);
 794             OutputString(stream, wxT("<") + objectName, convMem, convFile);
 795
 796             OutputString(stream, style + wxT(">"), convMem, convFile);
 797
 798             if (!fragment.empty() && (fragment[0] == wxT(' ') || fragment[fragment.length()-1] == wxT(' ')))
 799             {
 800                 OutputString(stream, wxT("\""), convMem, convFile);
 801                 OutputStringEnt(stream, fragment, convMem, convFile);
 802                 OutputString(stream, wxT("\""), convMem, convFile);
 803             }
 804             else
 805                 OutputStringEnt(stream, fragment, convMem, convFile);
 806         }
 807         else
 808             terminateTag = false;
 809     }
 810     else if (obj.IsKindOf(CLASSINFO(wxRichTextImage)))
 811     {
 812         wxRichTextImage& imageObj = (wxRichTextImage&) obj;
 813
 814         wxString style = CreateStyle(obj.GetAttributes(), false);
 815
 816         //if (imageObj.GetImage().Ok() && !imageObj.GetImageBlock().Ok())
 817         //    imageObj.MakeBlock();
 818
 819         OutputIndentation(stream, indent);
 820         OutputString(stream, wxT("<") + objectName, convMem, convFile);
 821         if (!imageObj.GetImageBlock().Ok())
 822         {
 823             // No data
 824             OutputString(stream, style + wxT(">"), convMem, convFile);
 825         }
 826         else
 827         {
 828             OutputString(stream, wxString::Format(wxT(" imagetype=\"%d\""), (int) imageObj.GetImageBlock().GetImageType()) + style + wxT(">"));
 829         }
 830
 831         OutputIndentation(stream, indent+1);
 832         OutputString(stream, wxT("<data>"), convMem, convFile);
 833
 834         imageObj.GetImageBlock().WriteHex(stream);
 835
 836         OutputString(stream, wxT("</data>"), convMem, convFile);
 837     }
 838     else if (obj.IsKindOf(CLASSINFO(wxRichTextCompositeObject)))
 839     {
 840         OutputIndentation(stream, indent);
 841         OutputString(stream, wxT("<") + objectName, convMem, convFile);
 842
 843         bool isPara = false;
 844         if (objectName == wxT("paragraph") || objectName == wxT("paragraphlayout"))
 845             isPara = true;
 846
 847         wxString style = CreateStyle(obj.GetAttributes(), isPara);
 848
 849         if (objectName == wxT("paragraphlayout") && ((wxRichTextParagraphLayoutBox&) obj).GetPartialParagraph())
 850             style << wxT(" partialparagraph=\"true\"");
 851
 852         OutputString(stream, style + wxT(">"), convMem, convFile);
 853
 854         wxRichTextCompositeObject& composite = (wxRichTextCompositeObject&) obj;
 855         size_t i;
 856         for (i = 0; i < composite.GetChildCount(); i++)
 857         {
 858             wxRichTextObject* child = composite.GetChild(i);
 859             ExportXML(stream, convMem, convFile, *child, indent+1);
 860         }
 861     }
 862
 863     if (objectName != wxT("text"))
 864         OutputIndentation(stream, indent);
 865
 866     if (terminateTag)
 867         OutputString(stream, wxT("</") + objectName + wxT(">"), convMem, convFile);
 868
 869     return true;
 870 }
 871
 872 bool wxRichTextXMLHandler::ExportStyleDefinition(wxOutputStream& stream, wxMBConv* convMem, wxMBConv* convFile, wxRichTextStyleDefinition* def, int level)
 873 {
 874     wxRichTextCharacterStyleDefinition* charDef = wxDynamicCast(def, wxRichTextCharacterStyleDefinition);
 875     wxRichTextParagraphStyleDefinition* paraDef = wxDynamicCast(def, wxRichTextParagraphStyleDefinition);
 876     wxRichTextListStyleDefinition* listDef = wxDynamicCast(def, wxRichTextListStyleDefinition);
 877
 878     wxString baseStyle = def->GetBaseStyle();
 879     wxString baseStyleProp;
 880     if (!baseStyle.IsEmpty())
 881         baseStyleProp = wxT(" basestyle=\"") + baseStyle + wxT("\"");
 882
 883     wxString descr = def->GetDescription();
 884     wxString descrProp;
 885     if (!descr.IsEmpty())
 886         descrProp = wxT(" description=\"") + descr + wxT("\"");
 887
 888     if (charDef)
 889     {
 890         OutputIndentation(stream, level);
 891         OutputString(stream, wxT("<characterstyle") + baseStyleProp + descrProp + wxT(">"), convMem, convFile);
 892
 893         level ++;
 894
 895         wxString style = CreateStyle(def->GetStyle(), false);
 896
 897         OutputIndentation(stream, level);
 898         OutputString(stream, wxT("<style ") + style + wxT(">"), convMem, convFile);
 899
 900         OutputIndentation(stream, level);
 901         OutputString(stream, wxT("</style>"), convMem, convFile);
 902
 903         level --;
 904
 905         OutputIndentation(stream, level);
 906         OutputString(stream, wxT("</characterstyle>"), convMem, convFile);
 907     }
 908     else if (listDef)
 909     {
 910         OutputIndentation(stream, level);
 911
 912         if (!listDef->GetNextStyle().IsEmpty())
 913             baseStyleProp << wxT(" basestyle=\"") << listDef->GetNextStyle() << wxT("\"");
 914
 915         OutputString(stream, wxT("<liststyle") + baseStyleProp + descrProp + wxT(">"), convMem, convFile);
 916
 917         level ++;
 918
 919         wxString style = CreateStyle(def->GetStyle(), false);
 920
 921         OutputIndentation(stream, level);
 922         OutputString(stream, wxT("<style ") + style + wxT(">"), convMem, convFile);
 923
 924         OutputIndentation(stream, level);
 925         OutputString(stream, wxT("</style>"), convMem, convFile);
 926
 927         int i;
 928         for (i = 0; i < 10; i ++)
 929         {
 930             wxTextAttr* levelAttr = listDef->GetLevelAttributes(i);
 931             if (levelAttr)
 932             {
 933                 wxString style = CreateStyle(def->GetStyle(), false);
 934                 wxString levelStr = wxString::Format(wxT(" level=\"%d\" "), (i+1));
 935
 936                 OutputIndentation(stream, level);
 937                 OutputString(stream, wxT("<style ") + levelStr + style + wxT(">"), convMem, convFile);
 938
 939                 OutputIndentation(stream, level);
 940                 OutputString(stream, wxT("</style>"), convMem, convFile);
 941             }
 942         }
 943
 944         level --;
 945
 946         OutputIndentation(stream, level);
 947         OutputString(stream, wxT("</liststyle>"), convMem, convFile);
 948     }
 949     else if (paraDef)
 950     {
 951         OutputIndentation(stream, level);
 952
 953         if (!paraDef->GetNextStyle().IsEmpty())
 954             baseStyleProp << wxT(" basestyle=\"") << paraDef->GetNextStyle() << wxT("\"");
 955
 956         OutputString(stream, wxT("<paragraphstyle") + baseStyleProp + descrProp + wxT(">"), convMem, convFile);
 957
 958         level ++;
 959
 960         wxString style = CreateStyle(def->GetStyle(), false);
 961
 962         OutputIndentation(stream, level);
 963         OutputString(stream, wxT("<style ") + style + wxT(">"), convMem, convFile);
 964
 965         OutputIndentation(stream, level);
 966         OutputString(stream, wxT("</style>"), convMem, convFile);
 967
 968         level --;
 969
 970         OutputIndentation(stream, level);
 971         OutputString(stream, wxT("</paragraphstyle>"), convMem, convFile);
 972     }
 973
 974     return true;
 975 }
 976
 977 /// Create style parameters
 978 wxString wxRichTextXMLHandler::CreateStyle(const wxTextAttr& attr, bool isPara)
 979 {
 980     wxString str;
 981     if (attr.HasTextColour() && attr.GetTextColour().Ok())
 982     {
 983         str << wxT(" textcolor=\"#") << ColourToHexString(attr.GetTextColour()) << wxT("\"");
 984     }
 985     if (attr.HasBackgroundColour() && attr.GetBackgroundColour().Ok())
 986     {
 987         str << wxT(" bgcolor=\"#") << ColourToHexString(attr.GetBackgroundColour()) << wxT("\"");
 988     }
 989
 990     if (attr.HasFontSize())
 991         str << wxT(" fontsize=\"") << attr.GetFontSize() << wxT("\"");
 992
 993     if (attr.HasFontFamily())
 994         str << wxT(" fontfamily=\"") << attr.GetFont().GetFamily() << wxT("\"");
 995
 996     if (attr.HasFontItalic())
 997         str << wxT(" fontstyle=\"") << attr.GetFontStyle() << wxT("\"");
 998
 999     if (attr.HasFontWeight())
1000         str << wxT(" fontweight=\"") << attr.GetFontWeight() << wxT("\"");
1001
1002     if (attr.HasFontUnderlined())
1003         str << wxT(" fontunderlined=\"") << (int) attr.GetFontUnderlined() << wxT("\"");
1004
1005     if (attr.HasFontFaceName())
1006         str << wxT(" fontface=\"") << attr.GetFontFaceName() << wxT("\"");
1007
1008     if (attr.HasTextEffects())
1009     {
1010         str << wxT(" texteffects=\"");
1011         str << attr.GetTextEffects();
1012         str << wxT("\"");
1013
1014         str << wxT(" texteffectflags=\"");
1015         str << attr.GetTextEffectFlags();
1016         str << wxT("\"");
1017     }
1018
1019     if (!attr.GetCharacterStyleName().empty())
1020         str << wxT(" characterstyle=\"") << wxString(attr.GetCharacterStyleName()) << wxT("\"");
1021
1022     if (attr.HasURL())
1023         str << wxT(" url=\"") << AttributeToXML(attr.GetURL()) << wxT("\"");
1024
1025     if (isPara)
1026     {
1027         if (attr.HasAlignment())
1028             str << wxT(" alignment=\"") << (int) attr.GetAlignment() << wxT("\"");
1029
1030         if (attr.HasLeftIndent())
1031         {
1032             str << wxT(" leftindent=\"") << (int) attr.GetLeftIndent() << wxT("\"");
1033             str << wxT(" leftsubindent=\"") << (int) attr.GetLeftSubIndent() << wxT("\"");
1034         }
1035
1036         if (attr.HasRightIndent())
1037             str << wxT(" rightindent=\"") << (int) attr.GetRightIndent() << wxT("\"");
1038
1039         if (attr.HasParagraphSpacingAfter())
1040             str << wxT(" parspacingafter=\"") << (int) attr.GetParagraphSpacingAfter() << wxT("\"");
1041
1042         if (attr.HasParagraphSpacingBefore())
1043             str << wxT(" parspacingbefore=\"") << (int) attr.GetParagraphSpacingBefore() << wxT("\"");
1044
1045         if (attr.HasLineSpacing())
1046             str << wxT(" linespacing=\"") << (int) attr.GetLineSpacing() << wxT("\"");
1047
1048         if (attr.HasBulletStyle())
1049             str << wxT(" bulletstyle=\"") << (int) attr.GetBulletStyle() << wxT("\"");
1050
1051         if (attr.HasBulletNumber())
1052             str << wxT(" bulletnumber=\"") << (int) attr.GetBulletNumber() << wxT("\"");
1053
1054         if (attr.HasBulletText())
1055         {
1056             // If using a bullet symbol, convert to integer in case it's a non-XML-friendly character.
1057             // Otherwise, assume it's XML-friendly text such as outline numbering, e.g. 1.2.3.1
1058             if (!attr.GetBulletText().IsEmpty() && (attr.GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_SYMBOL))
1059                 str << wxT(" bulletsymbol=\"") << (int) (attr.GetBulletText()[0]) << wxT("\"");
1060             else
1061                 str << wxT(" bullettext=\"") << attr.GetBulletText() << wxT("\"");
1062
1063             str << wxT(" bulletfont=\"") << attr.GetBulletFont() << wxT("\"");
1064         }
1065
1066         if (attr.HasBulletName())
1067             str << wxT(" bulletname=\"") << attr.GetBulletName() << wxT("\"");
1068
1069         if (!attr.GetParagraphStyleName().empty())
1070             str << wxT(" parstyle=\"") << wxString(attr.GetParagraphStyleName()) << wxT("\"");
1071
1072         if (!attr.GetListStyleName().empty())
1073             str << wxT(" liststyle=\"") << wxString(attr.GetListStyleName()) << wxT("\"");
1074
1075         if (attr.HasTabs())
1076         {
1077             str << wxT(" tabs=\"");
1078             size_t i;
1079             for (i = 0; i < attr.GetTabs().GetCount(); i++)
1080             {
1081                 if (i > 0)
1082                     str << wxT(",");
1083                 str << attr.GetTabs()[i];
1084             }
1085             str << wxT("\"");
1086         }
1087
1088         if (attr.HasPageBreak())
1089         {
1090             str << wxT(" pagebreak=\"1\"");
1091         }
1092
1093         if (attr.HasOutlineLevel())
1094             str << wxT(" outlinelevel=\"") << (int) attr.GetOutlineLevel() << wxT("\"");
1095
1096     }
1097
1098     return str;
1099 }
1100
1101 /// Replace face name with current name for platform.
1102 /// TODO: introduce a virtual function or settable table to
1103 /// do this comprehensively.
1104 bool wxRichTextFixFaceName(wxString& facename)
1105 {
1106     if (facename.IsEmpty())
1107         return false;
1108
1109 #ifdef __WXMSW__
1110     if (facename == wxT("Times"))
1111     {
1112         facename = wxT("Times New Roman");
1113         return true;
1114     }
1115     else if (facename == wxT("Helvetica"))
1116     {
1117         facename = wxT("Arial");
1118         return true;
1119     }
1120     else if (facename == wxT("Courier"))
1121     {
1122         facename = wxT("Courier New");
1123         return true;
1124     }
1125     else
1126         return false;
1127 #else
1128     if (facename == wxT("Times New Roman"))
1129     {
1130         facename = wxT("Times");
1131         return true;
1132     }
1133     else if (facename == wxT("Arial"))
1134     {
1135         facename = wxT("Helvetica");
1136         return true;
1137     }
1138     else if (facename == wxT("Courier New"))
1139     {
1140         facename = wxT("Courier");
1141         return true;
1142     }
1143     else
1144         return false;
1145 #endif
1146 }
1147
1148 /// Get style parameters
1149 bool wxRichTextXMLHandler::GetStyle(wxTextAttr& attr, wxXmlNode* node, bool isPara)
1150 {
1151     wxString fontFacename;
1152     int fontSize = 12;
1153     wxFontFamily fontFamily = wxFONTFAMILY_DEFAULT;
1154     wxFontWeight fontWeight = wxFONTWEIGHT_NORMAL;
1155     wxFontStyle fontStyle = wxFONTSTYLE_NORMAL;
1156     bool fontUnderlined = false;
1157     const wxString emptyString; // save a temporary string construction in GetPropVal
1158
1159     // int fontFlags = 0;
1160
1161     fontFacename = node->GetAttribute(wxT("fontface"), emptyString);
1162     if (!fontFacename.IsEmpty())
1163     {
1164         attr.SetFontFaceName(fontFacename);
1165         if (GetFlags() & wxRICHTEXT_HANDLER_CONVERT_FACENAMES)
1166             wxRichTextFixFaceName(fontFacename);
1167     }
1168
1169     wxString value;
1170     value = node->GetAttribute(wxT("fontfamily"), emptyString);
1171     if (!value.empty())
1172     {
1173         fontFamily = (wxFontFamily)wxAtoi(value);
1174         attr.SetFontFamily(fontFamily);
1175     }
1176
1177     value = node->GetAttribute(wxT("fontstyle"), emptyString);
1178     if (!value.empty())
1179     {
1180         fontStyle = (wxFontStyle)wxAtoi(value);
1181         attr.SetFontStyle(fontStyle);
1182     }
1183
1184     value = node->GetAttribute(wxT("fontsize"), emptyString);
1185     if (!value.empty())
1186     {
1187         fontSize = wxAtoi(value);
1188         attr.SetFontSize(fontSize);
1189     }
1190
1191     value = node->GetAttribute(wxT("fontweight"), emptyString);
1192     if (!value.empty())
1193     {
1194         fontWeight = (wxFontWeight)wxAtoi(value);
1195         attr.SetFontWeight(fontWeight);
1196     }
1197
1198     value = node->GetAttribute(wxT("fontunderlined"), emptyString);
1199     if (!value.empty())
1200     {
1201         fontUnderlined = wxAtoi(value) != 0;
1202         attr.SetFontUnderlined(fontUnderlined);
1203     }
1204
1205     value = node->GetAttribute(wxT("textcolor"), emptyString);
1206     if (!value.empty())
1207     {
1208         if (value[0] == wxT('#'))
1209             attr.SetTextColour(HexStringToColour(value.Mid(1)));
1210         else
1211             attr.SetTextColour(value);
1212     }
1213
1214     value = node->GetAttribute(wxT("bgcolor"), emptyString);
1215     if (!value.empty())
1216     {
1217         if (value[0] == wxT('#'))
1218             attr.SetBackgroundColour(HexStringToColour(value.Mid(1)));
1219         else
1220             attr.SetBackgroundColour(value);
1221     }
1222
1223     value = node->GetAttribute(wxT("characterstyle"), emptyString);
1224     if (!value.empty())
1225         attr.SetCharacterStyleName(value);
1226
1227     value = node->GetAttribute(wxT("texteffects"), emptyString);
1228     if (!value.IsEmpty())
1229     {
1230         attr.SetTextEffects(wxAtoi(value));
1231     }
1232
1233     value = node->GetAttribute(wxT("texteffectflags"), emptyString);
1234     if (!value.IsEmpty())
1235     {
1236         attr.SetTextEffectFlags(wxAtoi(value));
1237     }
1238
1239     value = node->GetAttribute(wxT("url"), emptyString);
1240     if (!value.empty())
1241         attr.SetURL(value);
1242
1243     // Set paragraph attributes
1244     if (isPara)
1245     {
1246         value = node->GetAttribute(wxT("alignment"), emptyString);
1247         if (!value.empty())
1248             attr.SetAlignment((wxTextAttrAlignment) wxAtoi(value));
1249
1250         int leftSubIndent = 0;
1251         int leftIndent = 0;
1252         bool hasLeftIndent = false;
1253
1254         value = node->GetAttribute(wxT("leftindent"), emptyString);
1255         if (!value.empty())
1256         {
1257             leftIndent = wxAtoi(value);
1258             hasLeftIndent = true;
1259         }
1260
1261         value = node->GetAttribute(wxT("leftsubindent"), emptyString);
1262         if (!value.empty())
1263         {
1264             leftSubIndent = wxAtoi(value);
1265             hasLeftIndent = true;
1266         }
1267
1268         if (hasLeftIndent)
1269             attr.SetLeftIndent(leftIndent, leftSubIndent);
1270
1271         value = node->GetAttribute(wxT("rightindent"), emptyString);
1272         if (!value.empty())
1273             attr.SetRightIndent(wxAtoi(value));
1274
1275         value = node->GetAttribute(wxT("parspacingbefore"), emptyString);
1276         if (!value.empty())
1277             attr.SetParagraphSpacingBefore(wxAtoi(value));
1278
1279         value = node->GetAttribute(wxT("parspacingafter"), emptyString);
1280         if (!value.empty())
1281             attr.SetParagraphSpacingAfter(wxAtoi(value));
1282
1283         value = node->GetAttribute(wxT("linespacing"), emptyString);
1284         if (!value.empty())
1285             attr.SetLineSpacing(wxAtoi(value));
1286
1287         value = node->GetAttribute(wxT("bulletstyle"), emptyString);
1288         if (!value.empty())
1289             attr.SetBulletStyle(wxAtoi(value));
1290
1291         value = node->GetAttribute(wxT("bulletnumber"), emptyString);
1292         if (!value.empty())
1293             attr.SetBulletNumber(wxAtoi(value));
1294
1295         value = node->GetAttribute(wxT("bulletsymbol"), emptyString);
1296         if (!value.empty())
1297         {
1298             wxChar ch = wxAtoi(value);
1299             wxString s;
1300             s << ch;
1301             attr.SetBulletText(s);
1302         }
1303
1304         value = node->GetAttribute(wxT("bullettext"), emptyString);
1305         if (!value.empty())
1306             attr.SetBulletText(value);
1307
1308         value = node->GetAttribute(wxT("bulletfont"), emptyString);
1309         if (!value.empty())
1310             attr.SetBulletFont(value);
1311
1312         value = node->GetAttribute(wxT("bulletname"), emptyString);
1313         if (!value.empty())
1314             attr.SetBulletName(value);
1315
1316         value = node->GetAttribute(wxT("parstyle"), emptyString);
1317         if (!value.empty())
1318             attr.SetParagraphStyleName(value);
1319
1320         value = node->GetAttribute(wxT("liststyle"), emptyString);
1321         if (!value.empty())
1322             attr.SetListStyleName(value);
1323
1324         value = node->GetAttribute(wxT("tabs"), emptyString);
1325         if (!value.empty())
1326         {
1327             wxArrayInt tabs;
1328             wxStringTokenizer tkz(value, wxT(","));
1329             while (tkz.HasMoreTokens())
1330             {
1331                 wxString token = tkz.GetNextToken();
1332                 tabs.Add(wxAtoi(token));
1333             }
1334             attr.SetTabs(tabs);
1335         }
1336
1337         value = node->GetAttribute(wxT("pagebreak"), emptyString);
1338         if (!value.IsEmpty())
1339         {
1340             attr.SetPageBreak(wxAtoi(value) != 0);
1341         }
1342
1343         value = node->GetAttribute(wxT("outlinelevel"), emptyString);
1344         if (!value.IsEmpty())
1345         {
1346             attr.SetOutlineLevel(wxAtoi(value));
1347         }
1348     }
1349
1350     return true;
1351 }
1352
1353 #endif
1354     // wxUSE_STREAMS
1355
1356 #endif
1357     // wxUSE_RICHTEXT && wxUSE_XML
1358