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