]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/xml/xml.cpp
fixed handling of dst offset in wxAlphaBlend()
[wxWidgets.git] / src / xml / xml.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: xml.cpp
3// Purpose: wxXmlDocument - XML parser & data holder class
4// Author: Vaclav Slavik
5// Created: 2000/03/05
6// RCS-ID: $Id$
7// Copyright: (c) 2000 Vaclav Slavik
8// Licence: wxWindows licence
9/////////////////////////////////////////////////////////////////////////////
10
11// For compilers that support precompilation, includes "wx.h".
12#include "wx/wxprec.h"
13
14#ifdef __BORLANDC__
15 #pragma hdrstop
16#endif
17
18#include "wx/xml/xml.h"
19
20#if wxUSE_XML
21
22#include "wx/wfstream.h"
23#include "wx/datstrm.h"
24#include "wx/zstream.h"
25#include "wx/log.h"
26#include "wx/intl.h"
27#include "wx/strconv.h"
28
29#include "expat.h" // from Expat
30
31// DLL options compatibility check:
32#include "wx/app.h"
33WX_CHECK_BUILD_OPTIONS("wxXML")
34
35//-----------------------------------------------------------------------------
36// wxXmlNode
37//-----------------------------------------------------------------------------
38
39wxXmlNode::wxXmlNode(wxXmlNode *parent,wxXmlNodeType type,
40 const wxString& name, const wxString& content,
41 wxXmlProperty *props, wxXmlNode *next)
42 : m_type(type), m_name(name), m_content(content),
43 m_properties(props), m_parent(parent),
44 m_children(NULL), m_next(next)
45{
46 if (m_parent)
47 {
48 if (m_parent->m_children)
49 {
50 m_next = m_parent->m_children;
51 m_parent->m_children = this;
52 }
53 else
54 m_parent->m_children = this;
55 }
56}
57
58wxXmlNode::wxXmlNode(wxXmlNodeType type, const wxString& name,
59 const wxString& content)
60 : m_type(type), m_name(name), m_content(content),
61 m_properties(NULL), m_parent(NULL),
62 m_children(NULL), m_next(NULL)
63{}
64
65wxXmlNode::wxXmlNode(const wxXmlNode& node)
66{
67 m_next = NULL;
68 m_parent = NULL;
69 DoCopy(node);
70}
71
72wxXmlNode::~wxXmlNode()
73{
74 wxXmlNode *c, *c2;
75 for (c = m_children; c; c = c2)
76 {
77 c2 = c->m_next;
78 delete c;
79 }
80
81 wxXmlProperty *p, *p2;
82 for (p = m_properties; p; p = p2)
83 {
84 p2 = p->GetNext();
85 delete p;
86 }
87}
88
89wxXmlNode& wxXmlNode::operator=(const wxXmlNode& node)
90{
91 wxDELETE(m_properties);
92 wxDELETE(m_children);
93 DoCopy(node);
94 return *this;
95}
96
97void wxXmlNode::DoCopy(const wxXmlNode& node)
98{
99 m_type = node.m_type;
100 m_name = node.m_name;
101 m_content = node.m_content;
102 m_children = NULL;
103
104 wxXmlNode *n = node.m_children;
105 while (n)
106 {
107 AddChild(new wxXmlNode(*n));
108 n = n->GetNext();
109 }
110
111 m_properties = NULL;
112 wxXmlProperty *p = node.m_properties;
113 while (p)
114 {
115 AddProperty(p->GetName(), p->GetValue());
116 p = p->GetNext();
117 }
118}
119
120bool wxXmlNode::HasProp(const wxString& propName) const
121{
122 wxXmlProperty *prop = GetProperties();
123
124 while (prop)
125 {
126 if (prop->GetName() == propName) return true;
127 prop = prop->GetNext();
128 }
129
130 return false;
131}
132
133bool wxXmlNode::GetPropVal(const wxString& propName, wxString *value) const
134{
135 wxXmlProperty *prop = GetProperties();
136
137 while (prop)
138 {
139 if (prop->GetName() == propName)
140 {
141 *value = prop->GetValue();
142 return true;
143 }
144 prop = prop->GetNext();
145 }
146
147 return false;
148}
149
150wxString wxXmlNode::GetPropVal(const wxString& propName, const wxString& defaultVal) const
151{
152 wxString tmp;
153 if (GetPropVal(propName, &tmp))
154 return tmp;
155
156 return defaultVal;
157}
158
159void wxXmlNode::AddChild(wxXmlNode *child)
160{
161 if (m_children == NULL)
162 m_children = child;
163 else
164 {
165 wxXmlNode *ch = m_children;
166 while (ch->m_next) ch = ch->m_next;
167 ch->m_next = child;
168 }
169 child->m_next = NULL;
170 child->m_parent = this;
171}
172
173void wxXmlNode::InsertChild(wxXmlNode *child, wxXmlNode *before_node)
174{
175 wxASSERT_MSG(before_node->GetParent() == this, wxT("wxXmlNode::InsertChild - the node has incorrect parent"));
176
177 if (m_children == before_node)
178 m_children = child;
179 else
180 {
181 wxXmlNode *ch = m_children;
182 while (ch->m_next != before_node) ch = ch->m_next;
183 ch->m_next = child;
184 }
185
186 child->m_parent = this;
187 child->m_next = before_node;
188}
189
190bool wxXmlNode::RemoveChild(wxXmlNode *child)
191{
192 if (m_children == NULL)
193 return false;
194 else if (m_children == child)
195 {
196 m_children = child->m_next;
197 child->m_parent = NULL;
198 child->m_next = NULL;
199 return true;
200 }
201 else
202 {
203 wxXmlNode *ch = m_children;
204 while (ch->m_next)
205 {
206 if (ch->m_next == child)
207 {
208 ch->m_next = child->m_next;
209 child->m_parent = NULL;
210 child->m_next = NULL;
211 return true;
212 }
213 ch = ch->m_next;
214 }
215 return false;
216 }
217}
218
219void wxXmlNode::AddProperty(const wxString& name, const wxString& value)
220{
221 AddProperty(new wxXmlProperty(name, value, NULL));
222}
223
224void wxXmlNode::AddProperty(wxXmlProperty *prop)
225{
226 if (m_properties == NULL)
227 m_properties = prop;
228 else
229 {
230 wxXmlProperty *p = m_properties;
231 while (p->GetNext()) p = p->GetNext();
232 p->SetNext(prop);
233 }
234}
235
236bool wxXmlNode::DeleteProperty(const wxString& name)
237{
238 wxXmlProperty *prop;
239
240 if (m_properties == NULL)
241 return false;
242
243 else if (m_properties->GetName() == name)
244 {
245 prop = m_properties;
246 m_properties = prop->GetNext();
247 prop->SetNext(NULL);
248 delete prop;
249 return true;
250 }
251
252 else
253 {
254 wxXmlProperty *p = m_properties;
255 while (p->GetNext())
256 {
257 if (p->GetNext()->GetName() == name)
258 {
259 prop = p->GetNext();
260 p->SetNext(prop->GetNext());
261 prop->SetNext(NULL);
262 delete prop;
263 return true;
264 }
265 p = p->GetNext();
266 }
267 return false;
268 }
269}
270
271
272
273//-----------------------------------------------------------------------------
274// wxXmlDocument
275//-----------------------------------------------------------------------------
276
277wxXmlDocument::wxXmlDocument()
278 : m_version(wxT("1.0")), m_fileEncoding(wxT("utf-8")), m_root(NULL)
279{
280#if !wxUSE_UNICODE
281 m_encoding = wxT("UTF-8");
282#endif
283}
284
285wxXmlDocument::wxXmlDocument(const wxString& filename, const wxString& encoding)
286 :wxObject(), m_root(NULL)
287{
288 if ( !Load(filename, encoding) )
289 {
290 wxDELETE(m_root);
291 }
292}
293
294wxXmlDocument::wxXmlDocument(wxInputStream& stream, const wxString& encoding)
295 :wxObject(), m_root(NULL)
296{
297 if ( !Load(stream, encoding) )
298 {
299 wxDELETE(m_root);
300 }
301}
302
303wxXmlDocument::wxXmlDocument(const wxXmlDocument& doc)
304 :wxObject()
305{
306 DoCopy(doc);
307}
308
309wxXmlDocument& wxXmlDocument::operator=(const wxXmlDocument& doc)
310{
311 wxDELETE(m_root);
312 DoCopy(doc);
313 return *this;
314}
315
316void wxXmlDocument::DoCopy(const wxXmlDocument& doc)
317{
318 m_version = doc.m_version;
319#if !wxUSE_UNICODE
320 m_encoding = doc.m_encoding;
321#endif
322 m_fileEncoding = doc.m_fileEncoding;
323 m_root = new wxXmlNode(*doc.m_root);
324}
325
326bool wxXmlDocument::Load(const wxString& filename, const wxString& encoding)
327{
328 wxFileInputStream stream(filename);
329 return Load(stream, encoding);
330}
331
332bool wxXmlDocument::Save(const wxString& filename) const
333{
334 wxFileOutputStream stream(filename);
335 return Save(stream);
336}
337
338
339
340//-----------------------------------------------------------------------------
341// wxXmlDocument loading routines
342//-----------------------------------------------------------------------------
343
344/*
345 FIXME:
346 - process all elements, including CDATA
347 */
348
349// converts Expat-produced string in UTF-8 into wxString.
350inline static wxString CharToString(wxMBConv *conv,
351 const char *s, size_t len = wxSTRING_MAXLEN)
352{
353#if wxUSE_UNICODE
354 (void)conv;
355 return wxString(s, wxConvUTF8, len);
356#else
357 if ( conv )
358 {
359 size_t nLen = (len != wxSTRING_MAXLEN) ? len :
360 wxConvUTF8.MB2WC((wchar_t*) NULL, s, 0);
361
362 wchar_t *buf = new wchar_t[nLen+1];
363 wxConvUTF8.MB2WC(buf, s, nLen);
364 buf[nLen] = 0;
365 wxString str(buf, *conv, len);
366 delete[] buf;
367 return str;
368 }
369 else
370 return wxString(s, len != wxSTRING_MAXLEN ? len : strlen(s));
371#endif
372}
373
374struct wxXmlParsingContext
375{
376 wxMBConv *conv;
377 wxXmlNode *root;
378 wxXmlNode *node;
379 wxXmlNode *lastAsText;
380 wxString encoding;
381 wxString version;
382};
383
384extern "C" {
385static void StartElementHnd(void *userData, const char *name, const char **atts)
386{
387 wxXmlParsingContext *ctx = (wxXmlParsingContext*)userData;
388 wxXmlNode *node = new wxXmlNode(wxXML_ELEMENT_NODE, CharToString(ctx->conv, name));
389 const char **a = atts;
390 while (*a)
391 {
392 node->AddProperty(CharToString(ctx->conv, a[0]), CharToString(ctx->conv, a[1]));
393 a += 2;
394 }
395 if (ctx->root == NULL)
396 ctx->root = node;
397 else
398 ctx->node->AddChild(node);
399 ctx->node = node;
400 ctx->lastAsText = NULL;
401}
402}
403
404extern "C" {
405static void EndElementHnd(void *userData, const char* WXUNUSED(name))
406{
407 wxXmlParsingContext *ctx = (wxXmlParsingContext*)userData;
408
409 ctx->node = ctx->node->GetParent();
410 ctx->lastAsText = NULL;
411}
412}
413
414extern "C" {
415static void TextHnd(void *userData, const char *s, int len)
416{
417 wxXmlParsingContext *ctx = (wxXmlParsingContext*)userData;
418 char *buf = new char[len + 1];
419
420 buf[len] = '\0';
421 memcpy(buf, s, (size_t)len);
422
423 if (ctx->lastAsText)
424 {
425 ctx->lastAsText->SetContent(ctx->lastAsText->GetContent() +
426 CharToString(ctx->conv, buf));
427 }
428 else
429 {
430 bool whiteOnly = true;
431 for (char *c = buf; *c != '\0'; c++)
432 if (*c != ' ' && *c != '\t' && *c != '\n' && *c != '\r')
433 {
434 whiteOnly = false;
435 break;
436 }
437 if (!whiteOnly)
438 {
439 ctx->lastAsText = new wxXmlNode(wxXML_TEXT_NODE, wxT("text"),
440 CharToString(ctx->conv, buf));
441 ctx->node->AddChild(ctx->lastAsText);
442 }
443 }
444
445 delete[] buf;
446}
447}
448
449extern "C" {
450static void CommentHnd(void *userData, const char *data)
451{
452 wxXmlParsingContext *ctx = (wxXmlParsingContext*)userData;
453
454 if (ctx->node)
455 {
456 // VS: ctx->node == NULL happens if there is a comment before
457 // the root element (e.g. wxDesigner's output). We ignore such
458 // comments, no big deal...
459 ctx->node->AddChild(new wxXmlNode(wxXML_COMMENT_NODE,
460 wxT("comment"), CharToString(ctx->conv, data)));
461 }
462 ctx->lastAsText = NULL;
463}
464}
465
466extern "C" {
467static void DefaultHnd(void *userData, const char *s, int len)
468{
469 // XML header:
470 if (len > 6 && memcmp(s, "<?xml ", 6) == 0)
471 {
472 wxXmlParsingContext *ctx = (wxXmlParsingContext*)userData;
473
474 wxString buf = CharToString(ctx->conv, s, (size_t)len);
475 int pos;
476 pos = buf.Find(wxT("encoding="));
477 if (pos != wxNOT_FOUND)
478 ctx->encoding = buf.Mid(pos + 10).BeforeFirst(buf[(size_t)pos+9]);
479 pos = buf.Find(wxT("version="));
480 if (pos != wxNOT_FOUND)
481 ctx->version = buf.Mid(pos + 9).BeforeFirst(buf[(size_t)pos+8]);
482 }
483}
484}
485
486extern "C" {
487static int UnknownEncodingHnd(void * WXUNUSED(encodingHandlerData),
488 const XML_Char *name, XML_Encoding *info)
489{
490 // We must build conversion table for expat. The easiest way to do so
491 // is to let wxCSConv convert as string containing all characters to
492 // wide character representation:
493 wxString str(name, wxConvLibc);
494 wxCSConv conv(str);
495 char mbBuf[2];
496 wchar_t wcBuf[10];
497 size_t i;
498
499 mbBuf[1] = 0;
500 info->map[0] = 0;
501 for (i = 0; i < 255; i++)
502 {
503 mbBuf[0] = (char)(i+1);
504 if (conv.MB2WC(wcBuf, mbBuf, 2) == (size_t)-1)
505 {
506 // invalid/undefined byte in the encoding:
507 info->map[i+1] = -1;
508 }
509 info->map[i+1] = (int)wcBuf[0];
510 }
511
512 info->data = NULL;
513 info->convert = NULL;
514 info->release = NULL;
515
516 return 1;
517}
518}
519
520bool wxXmlDocument::Load(wxInputStream& stream, const wxString& encoding)
521{
522#if wxUSE_UNICODE
523 (void)encoding;
524#else
525 m_encoding = encoding;
526#endif
527
528 const size_t BUFSIZE = 1024;
529 char buf[BUFSIZE];
530 wxXmlParsingContext ctx;
531 bool done;
532 XML_Parser parser = XML_ParserCreate(NULL);
533
534 ctx.root = ctx.node = NULL;
535 ctx.encoding = wxT("UTF-8"); // default in absence of encoding=""
536 ctx.conv = NULL;
537#if !wxUSE_UNICODE
538 if ( encoding != wxT("UTF-8") && encoding != wxT("utf-8") )
539 ctx.conv = new wxCSConv(encoding);
540#endif
541
542 XML_SetUserData(parser, (void*)&ctx);
543 XML_SetElementHandler(parser, StartElementHnd, EndElementHnd);
544 XML_SetCharacterDataHandler(parser, TextHnd);
545 XML_SetCommentHandler(parser, CommentHnd);
546 XML_SetDefaultHandler(parser, DefaultHnd);
547 XML_SetUnknownEncodingHandler(parser, UnknownEncodingHnd, NULL);
548
549 bool ok = true;
550 do
551 {
552 size_t len = stream.Read(buf, BUFSIZE).LastRead();
553 done = (len < BUFSIZE);
554 if (!XML_Parse(parser, buf, len, done))
555 {
556 wxString error(XML_ErrorString(XML_GetErrorCode(parser)),
557 *wxConvCurrent);
558 wxLogError(_("XML parsing error: '%s' at line %d"),
559 error.c_str(),
560 XML_GetCurrentLineNumber(parser));
561 ok = false;
562 break;
563 }
564 } while (!done);
565
566 if (ok)
567 {
568 if (!ctx.version.empty())
569 SetVersion(ctx.version);
570 if (!ctx.encoding.empty())
571 SetFileEncoding(ctx.encoding);
572 SetRoot(ctx.root);
573 }
574 else
575 {
576 delete ctx.root;
577 }
578
579 XML_ParserFree(parser);
580#if !wxUSE_UNICODE
581 if ( ctx.conv )
582 delete ctx.conv;
583#endif
584
585 return ok;
586
587}
588
589
590
591//-----------------------------------------------------------------------------
592// wxXmlDocument saving routines
593//-----------------------------------------------------------------------------
594
595// write string to output:
596inline static void OutputString(wxOutputStream& stream, const wxString& str,
597#if wxUSE_UNICODE
598 wxMBConv * WXUNUSED(convMem),
599#else
600 wxMBConv *convMem,
601#endif
602 wxMBConv *convFile)
603{
604 if (str.empty()) return;
605#if wxUSE_UNICODE
606 const wxWX2MBbuf buf(str.mb_str(*(convFile ? convFile : &wxConvUTF8)));
607 stream.Write((const char*)buf, strlen((const char*)buf));
608#else
609 if ( convFile == NULL )
610 stream.Write(str.mb_str(), str.Len());
611 else
612 {
613 wxString str2(str.wc_str(*convMem), *convFile);
614 stream.Write(str2.mb_str(), str2.Len());
615 }
616#endif
617}
618
619// Same as above, but create entities first.
620// Translates '<' to "&lt;", '>' to "&gt;" and '&' to "&amp;"
621static void OutputStringEnt(wxOutputStream& stream, const wxString& str,
622 wxMBConv *convMem, wxMBConv *convFile,
623 bool escapeQuotes = false)
624{
625 wxString buf;
626 size_t i, last, len;
627 wxChar c;
628
629 len = str.Len();
630 last = 0;
631 for (i = 0; i < len; i++)
632 {
633 c = str.GetChar(i);
634 if (c == wxT('<') || c == wxT('>') ||
635 (c == wxT('&') && str.Mid(i+1, 4) != wxT("amp;")) ||
636 (escapeQuotes && c == wxT('"')))
637 {
638 OutputString(stream, str.Mid(last, i - last), convMem, convFile);
639 switch (c)
640 {
641 case wxT('<'):
642 OutputString(stream, wxT("&lt;"), NULL, NULL);
643 break;
644 case wxT('>'):
645 OutputString(stream, wxT("&gt;"), NULL, NULL);
646 break;
647 case wxT('&'):
648 OutputString(stream, wxT("&amp;"), NULL, NULL);
649 break;
650 case wxT('"'):
651 OutputString(stream, wxT("&quot;"), NULL, NULL);
652 break;
653 default: break;
654 }
655 last = i + 1;
656 }
657 }
658 OutputString(stream, str.Mid(last, i - last), convMem, convFile);
659}
660
661inline static void OutputIndentation(wxOutputStream& stream, int indent)
662{
663 wxString str = wxT("\n");
664 for (int i = 0; i < indent; i++)
665 str << wxT(' ') << wxT(' ');
666 OutputString(stream, str, NULL, NULL);
667}
668
669static void OutputNode(wxOutputStream& stream, wxXmlNode *node, int indent,
670 wxMBConv *convMem, wxMBConv *convFile)
671{
672 wxXmlNode *n, *prev;
673 wxXmlProperty *prop;
674
675 switch (node->GetType())
676 {
677 case wxXML_TEXT_NODE:
678 OutputStringEnt(stream, node->GetContent(), convMem, convFile);
679 break;
680
681 case wxXML_ELEMENT_NODE:
682 OutputString(stream, wxT("<"), NULL, NULL);
683 OutputString(stream, node->GetName(), NULL, NULL);
684
685 prop = node->GetProperties();
686 while (prop)
687 {
688 OutputString(stream, wxT(" ") + prop->GetName() + wxT("=\""),
689 NULL, NULL);
690 OutputStringEnt(stream, prop->GetValue(), NULL, NULL,
691 true/*escapeQuotes*/);
692 OutputString(stream, wxT("\""), NULL, NULL);
693 prop = prop->GetNext();
694 }
695
696 if (node->GetChildren())
697 {
698 OutputString(stream, wxT(">"), NULL, NULL);
699 prev = NULL;
700 n = node->GetChildren();
701 while (n)
702 {
703 if (n && n->GetType() != wxXML_TEXT_NODE)
704 OutputIndentation(stream, indent + 1);
705 OutputNode(stream, n, indent + 1, convMem, convFile);
706 prev = n;
707 n = n->GetNext();
708 }
709 if (prev && prev->GetType() != wxXML_TEXT_NODE)
710 OutputIndentation(stream, indent);
711 OutputString(stream, wxT("</"), NULL, NULL);
712 OutputString(stream, node->GetName(), NULL, NULL);
713 OutputString(stream, wxT(">"), NULL, NULL);
714 }
715 else
716 OutputString(stream, wxT("/>"), NULL, NULL);
717 break;
718
719 case wxXML_COMMENT_NODE:
720 OutputString(stream, wxT("<!--"), NULL, NULL);
721 OutputString(stream, node->GetContent(), convMem, convFile);
722 OutputString(stream, wxT("-->"), NULL, NULL);
723 break;
724
725 default:
726 wxFAIL_MSG(wxT("unsupported node type"));
727 }
728}
729
730bool wxXmlDocument::Save(wxOutputStream& stream) const
731{
732 if ( !IsOk() )
733 return false;
734
735 wxString s;
736
737 wxMBConv *convMem = NULL;
738
739#if wxUSE_UNICODE
740 wxMBConv *convFile = new wxCSConv(GetFileEncoding());
741#else
742 wxMBConv *convFile = NULL;
743 if ( GetFileEncoding() != GetEncoding() )
744 {
745 convFile = new wxCSConv(GetFileEncoding());
746 convMem = new wxCSConv(GetEncoding());
747 }
748#endif
749
750 s.Printf(wxT("<?xml version=\"%s\" encoding=\"%s\"?>\n"),
751 GetVersion().c_str(), GetFileEncoding().c_str());
752 OutputString(stream, s, NULL, NULL);
753
754 OutputNode(stream, GetRoot(), 0, convMem, convFile);
755 OutputString(stream, wxT("\n"), NULL, NULL);
756
757 if ( convFile )
758 delete convFile;
759 if ( convMem )
760 delete convMem;
761
762 return true;
763}
764
765#endif // wxUSE_XML