projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix crash in XRC ID range support code.
[wxWidgets.git] / src / xrc / xmlres.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/xrc/xmlres.cpp
3 // Purpose: XRC resources
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 #if wxUSE_XRC
19
20 #include "wx/xrc/xmlres.h"
21
22 #ifndef WX_PRECOMP
23 #include "wx/intl.h"
24 #include "wx/log.h"
25 #include "wx/panel.h"
26 #include "wx/frame.h"
27 #include "wx/dialog.h"
28 #include "wx/settings.h"
29 #include "wx/bitmap.h"
30 #include "wx/image.h"
31 #include "wx/module.h"
32 #include "wx/wxcrtvararg.h"
33 #endif
34
35 #ifndef __WXWINCE__
36 #include <locale.h>
37 #endif
38
39 #include "wx/vector.h"
40 #include "wx/wfstream.h"
41 #include "wx/filesys.h"
42 #include "wx/filename.h"
43 #include "wx/tokenzr.h"
44 #include "wx/fontenum.h"
45 #include "wx/fontmap.h"
46 #include "wx/artprov.h"
47 #include "wx/imaglist.h"
48 #include "wx/dir.h"
49 #include "wx/xml/xml.h"
50 #include "wx/hashset.h"
51
52
53 class wxXmlResourceDataRecord
54 {
55 public:
56 wxXmlResourceDataRecord() : Doc(NULL) {
57 #if wxUSE_DATETIME
58 Time = wxDateTime::Now();
59 #endif
60 }
61 ~wxXmlResourceDataRecord() {delete Doc;}
62
63 wxString File;
64 wxXmlDocument *Doc;
65 #if wxUSE_DATETIME
66 wxDateTime Time;
67 #endif
68 };
69
70 class wxXmlResourceDataRecords : public wxVector<wxXmlResourceDataRecord*>
71 {
72 // this is a class so that it can be forward-declared
73 };
74
75 WX_DECLARE_HASH_SET(int, wxIntegerHash, wxIntegerEqual, wxHashSetInt);
76
77 class wxIdRange // Holds data for a particular rangename
78 {
79 protected:
80 wxIdRange(const wxXmlNode* node,
81 const wxString& rname,
82 const wxString& startno,
83 const wxString& rsize);
84
85 // Note the existence of an item within the range
86 void NoteItem(const wxXmlNode* node, const wxString& item);
87
88 // The manager is telling us that it's finished adding items
89 void Finalise(const wxXmlNode* node);
90
91 wxString GetName() const { return m_name; }
92 bool IsFinalised() const { return m_finalised; }
93
94 const wxString m_name;
95 int m_start;
96 int m_end;
97 unsigned int m_size;
98 bool m_item_end_found;
99 bool m_finalised;
100 wxHashSetInt m_indices;
101
102 friend class wxIdRangeManager;
103 };
104
105 class wxIdRangeManager
106 {
107 public:
108 ~wxIdRangeManager();
109 // Gets the global resources object or creates one if none exists.
110 static wxIdRangeManager *Get();
111
112 // Sets the global resources object and returns a pointer to the previous
113 // one (may be NULL).
114 static wxIdRangeManager *Set(wxIdRangeManager *res);
115
116 // Create a new IDrange from this node
117 void AddRange(const wxXmlNode* node);
118 // Tell the IdRange that this item exists, and should be pre-allocated an ID
119 void NotifyRangeOfItem(const wxXmlNode* node, const wxString& item) const;
120 // Tells all IDranges that they're now complete, and can create their IDs
121 void FinaliseRanges(const wxXmlNode* node) const;
122 // Searches for a known IdRange matching 'name', returning its index or -1
123 int Find(const wxString& rangename) const;
124 // Removes, if it exists, an entry from the XRCID table. Used in id-ranges
125 // to replace defunct or statically-initialised entries with current values
126 static void RemoveXRCIDEntry(const wxString& idstr);
127
128 protected:
129 wxIdRange* FindRangeForItem(const wxXmlNode* node,
130 const wxString& item,
131 wxString& value) const;
132 wxVector<wxIdRange*> m_IdRanges;
133
134 private:
135 static wxIdRangeManager *ms_instance;
136 };
137
138 namespace
139 {
140
141 // helper used by DoFindResource() and elsewhere: returns true if this is an
142 // object or object_ref node
143 //
144 // node must be non-NULL
145 inline bool IsObjectNode(wxXmlNode *node)
146 {
147 return node->GetType() == wxXML_ELEMENT_NODE &&
148 (node->GetName() == wxS("object") ||
149 node->GetName() == wxS("object_ref"));
150 }
151
152 // special XML attribute with name of input file, see GetFileNameFromNode()
153 const char *ATTR_INPUT_FILENAME = "__wx:filename";
154
155 // helper to get filename corresponding to an XML node
156 wxString
157 GetFileNameFromNode(const wxXmlNode *node, const wxXmlResourceDataRecords& files)
158 {
159 // this loop does two things: it looks for ATTR_INPUT_FILENAME among
160 // parents and if it isn't used, it finds the root of the XML tree 'node'
161 // is in
162 for ( ;; )
163 {
164 // in some rare cases (specifically, when an <object_ref> is used, see
165 // wxXmlResource::CreateResFromNode() and MergeNodesOver()), we work
166 // with XML nodes that are not rooted in any document from 'files'
167 // (because a new node was created by CreateResFromNode() to merge the
168 // content of <object_ref> and the referenced <object>); in that case,
169 // we hack around the problem by putting the information about input
170 // file into a custom attribute
171 if ( node->HasAttribute(ATTR_INPUT_FILENAME) )
172 return node->GetAttribute(ATTR_INPUT_FILENAME);
173
174 if ( !node->GetParent() )
175 break; // we found the root of this XML tree
176
177 node = node->GetParent();
178 }
179
180 // NB: 'node' now points to the root of XML document
181
182 for ( wxXmlResourceDataRecords::const_iterator i = files.begin();
183 i != files.end(); ++i )
184 {
185 if ( (*i)->Doc->GetRoot() == node )
186 {
187 return (*i)->File;
188 }
189 }
190
191 return wxEmptyString; // not found
192 }
193
194 } // anonymous namespace
195
196
197 wxXmlResource *wxXmlResource::ms_instance = NULL;
198
199 /*static*/ wxXmlResource *wxXmlResource::Get()
200 {
201 if ( !ms_instance )
202 ms_instance = new wxXmlResource;
203 return ms_instance;
204 }
205
206 /*static*/ wxXmlResource *wxXmlResource::Set(wxXmlResource *res)
207 {
208 wxXmlResource *old = ms_instance;
209 ms_instance = res;
210 return old;
211 }
212
213 wxXmlResource::wxXmlResource(int flags, const wxString& domain)
214 {
215 m_flags = flags;
216 m_version = -1;
217 m_data = new wxXmlResourceDataRecords;
218 SetDomain(domain);
219 }
220
221 wxXmlResource::wxXmlResource(const wxString& filemask, int flags, const wxString& domain)
222 {
223 m_flags = flags;
224 m_version = -1;
225 m_data = new wxXmlResourceDataRecords;
226 SetDomain(domain);
227 Load(filemask);
228 }
229
230 wxXmlResource::~wxXmlResource()
231 {
232 ClearHandlers();
233
234 for ( wxXmlResourceDataRecords::iterator i = m_data->begin();
235 i != m_data->end(); ++i )
236 {
237 delete *i;
238 }
239 delete m_data;
240 }
241
242 void wxXmlResource::SetDomain(const wxString& domain)
243 {
244 m_domain = domain;
245 }
246
247
248 /* static */
249 wxString wxXmlResource::ConvertFileNameToURL(const wxString& filename)
250 {
251 wxString fnd(filename);
252
253 // NB: as Load() and Unload() accept both filenames and URLs (should
254 // probably be changed to filenames only, but embedded resources
255 // currently rely on its ability to handle URLs - FIXME) we need to
256 // determine whether found name is filename and not URL and this is the
257 // fastest/simplest way to do it
258 if (wxFileName::FileExists(fnd))
259 {
260 // Make the name absolute filename, because the app may
261 // change working directory later:
262 wxFileName fn(fnd);
263 if (fn.IsRelative())
264 {
265 fn.MakeAbsolute();
266 fnd = fn.GetFullPath();
267 }
268 #if wxUSE_FILESYSTEM
269 fnd = wxFileSystem::FileNameToURL(fnd);
270 #endif
271 }
272
273 return fnd;
274 }
275
276 #if wxUSE_FILESYSTEM
277
278 /* static */
279 bool wxXmlResource::IsArchive(const wxString& filename)
280 {
281 const wxString fnd = filename.Lower();
282
283 return fnd.Matches(wxT("*.zip")) || fnd.Matches(wxT("*.xrs"));
284 }
285
286 #endif // wxUSE_FILESYSTEM
287
288 bool wxXmlResource::LoadFile(const wxFileName& file)
289 {
290 #if wxUSE_FILESYSTEM
291 return Load(wxFileSystem::FileNameToURL(file));
292 #else
293 return Load(file.GetFullPath());
294 #endif
295 }
296
297 bool wxXmlResource::LoadAllFiles(const wxString& dirname)
298 {
299 bool ok = true;
300 wxArrayString files;
301
302 wxDir::GetAllFiles(dirname, &files, "*.xrc");
303
304 for ( wxArrayString::const_iterator i = files.begin(); i != files.end(); ++i )
305 {
306 if ( !LoadFile(*i) )
307 ok = false;
308 }
309
310 return ok;
311 }
312
313 bool wxXmlResource::Load(const wxString& filemask_)
314 {
315 wxString filemask = ConvertFileNameToURL(filemask_);
316
317 #if wxUSE_FILESYSTEM
318 wxFileSystem fsys;
319 # define wxXmlFindFirst fsys.FindFirst(filemask, wxFILE)
320 # define wxXmlFindNext fsys.FindNext()
321 #else
322 # define wxXmlFindFirst wxFindFirstFile(filemask, wxFILE)
323 # define wxXmlFindNext wxFindNextFile()
324 #endif
325 wxString fnd = wxXmlFindFirst;
326 if ( fnd.empty() )
327 {
328 wxLogError(_("Cannot load resources from '%s'."), filemask);
329 return false;
330 }
331
332 while (!fnd.empty())
333 {
334 #if wxUSE_FILESYSTEM
335 if ( IsArchive(fnd) )
336 {
337 if ( !Load(fnd + wxT("#zip:*.xrc")) )
338 return false;
339 }
340 else // a single resource URL
341 #endif // wxUSE_FILESYSTEM
342 {
343 wxXmlResourceDataRecord *drec = new wxXmlResourceDataRecord;
344 drec->File = fnd;
345 Data().push_back(drec);
346 }
347
348 fnd = wxXmlFindNext;
349 }
350 # undef wxXmlFindFirst
351 # undef wxXmlFindNext
352
353 return UpdateResources();
354 }
355
356 bool wxXmlResource::Unload(const wxString& filename)
357 {
358 wxASSERT_MSG( !wxIsWild(filename),
359 wxT("wildcards not supported by wxXmlResource::Unload()") );
360
361 wxString fnd = ConvertFileNameToURL(filename);
362 #if wxUSE_FILESYSTEM
363 const bool isArchive = IsArchive(fnd);
364 if ( isArchive )
365 fnd += wxT("#zip:");
366 #endif // wxUSE_FILESYSTEM
367
368 bool unloaded = false;
369 for ( wxXmlResourceDataRecords::iterator i = Data().begin();
370 i != Data().end(); ++i )
371 {
372 #if wxUSE_FILESYSTEM
373 if ( isArchive )
374 {
375 if ( (*i)->File.StartsWith(fnd) )
376 unloaded = true;
377 // don't break from the loop, we can have other matching files
378 }
379 else // a single resource URL
380 #endif // wxUSE_FILESYSTEM
381 {
382 if ( (*i)->File == fnd )
383 {
384 delete *i;
385 Data().erase(i);
386 unloaded = true;
387
388 // no sense in continuing, there is only one file with this URL
389 break;
390 }
391 }
392 }
393
394 return unloaded;
395 }
396
397
398 IMPLEMENT_ABSTRACT_CLASS(wxXmlResourceHandler, wxObject)
399
400 void wxXmlResource::AddHandler(wxXmlResourceHandler *handler)
401 {
402 m_handlers.push_back(handler);
403 handler->SetParentResource(this);
404 }
405
406 void wxXmlResource::InsertHandler(wxXmlResourceHandler *handler)
407 {
408 m_handlers.insert(m_handlers.begin(), handler);
409 handler->SetParentResource(this);
410 }
411
412
413
414 void wxXmlResource::ClearHandlers()
415 {
416 for ( wxVector<wxXmlResourceHandler*>::iterator i = m_handlers.begin();
417 i != m_handlers.end(); ++i )
418 delete *i;
419 m_handlers.clear();
420 }
421
422
423 wxMenu *wxXmlResource::LoadMenu(const wxString& name)
424 {
425 return (wxMenu*)CreateResFromNode(FindResource(name, wxT("wxMenu")), NULL, NULL);
426 }
427
428
429
430 wxMenuBar *wxXmlResource::LoadMenuBar(wxWindow *parent, const wxString& name)
431 {
432 return (wxMenuBar*)CreateResFromNode(FindResource(name, wxT("wxMenuBar")), parent, NULL);
433 }
434
435
436
437 #if wxUSE_TOOLBAR
438 wxToolBar *wxXmlResource::LoadToolBar(wxWindow *parent, const wxString& name)
439 {
440 return (wxToolBar*)CreateResFromNode(FindResource(name, wxT("wxToolBar")), parent, NULL);
441 }
442 #endif
443
444
445 wxDialog *wxXmlResource::LoadDialog(wxWindow *parent, const wxString& name)
446 {
447 return (wxDialog*)CreateResFromNode(FindResource(name, wxT("wxDialog")), parent, NULL);
448 }
449
450 bool wxXmlResource::LoadDialog(wxDialog *dlg, wxWindow *parent, const wxString& name)
451 {
452 return CreateResFromNode(FindResource(name, wxT("wxDialog")), parent, dlg) != NULL;
453 }
454
455
456
457 wxPanel *wxXmlResource::LoadPanel(wxWindow *parent, const wxString& name)
458 {
459 return (wxPanel*)CreateResFromNode(FindResource(name, wxT("wxPanel")), parent, NULL);
460 }
461
462 bool wxXmlResource::LoadPanel(wxPanel *panel, wxWindow *parent, const wxString& name)
463 {
464 return CreateResFromNode(FindResource(name, wxT("wxPanel")), parent, panel) != NULL;
465 }
466
467 wxFrame *wxXmlResource::LoadFrame(wxWindow* parent, const wxString& name)
468 {
469 return (wxFrame*)CreateResFromNode(FindResource(name, wxT("wxFrame")), parent, NULL);
470 }
471
472 bool wxXmlResource::LoadFrame(wxFrame* frame, wxWindow *parent, const wxString& name)
473 {
474 return CreateResFromNode(FindResource(name, wxT("wxFrame")), parent, frame) != NULL;
475 }
476
477 wxBitmap wxXmlResource::LoadBitmap(const wxString& name)
478 {
479 wxBitmap *bmp = (wxBitmap*)CreateResFromNode(
480 FindResource(name, wxT("wxBitmap")), NULL, NULL);
481 wxBitmap rt;
482
483 if (bmp) { rt = *bmp; delete bmp; }
484 return rt;
485 }
486
487 wxIcon wxXmlResource::LoadIcon(const wxString& name)
488 {
489 wxIcon *icon = (wxIcon*)CreateResFromNode(
490 FindResource(name, wxT("wxIcon")), NULL, NULL);
491 wxIcon rt;
492
493 if (icon) { rt = *icon; delete icon; }
494 return rt;
495 }
496
497
498 wxObject *
499 wxXmlResource::DoLoadObject(wxWindow *parent,
500 const wxString& name,
501 const wxString& classname,
502 bool recursive)
503 {
504 wxXmlNode * const node = FindResource(name, classname, recursive);
505
506 return node ? DoCreateResFromNode(*node, parent, NULL) : NULL;
507 }
508
509 bool
510 wxXmlResource::DoLoadObject(wxObject *instance,
511 wxWindow *parent,
512 const wxString& name,
513 const wxString& classname,
514 bool recursive)
515 {
516 wxXmlNode * const node = FindResource(name, classname, recursive);
517
518 return node && DoCreateResFromNode(*node, parent, instance) != NULL;
519 }
520
521
522 bool wxXmlResource::AttachUnknownControl(const wxString& name,
523 wxWindow *control, wxWindow *parent)
524 {
525 if (parent == NULL)
526 parent = control->GetParent();
527 wxWindow *container = parent->FindWindow(name + wxT("_container"));
528 if (!container)
529 {
530 wxLogError("Cannot find container for unknown control '%s'.", name);
531 return false;
532 }
533 return control->Reparent(container);
534 }
535
536
537 static void ProcessPlatformProperty(wxXmlNode *node)
538 {
539 wxString s;
540 bool isok;
541
542 wxXmlNode *c = node->GetChildren();
543 while (c)
544 {
545 isok = false;
546 if (!c->GetAttribute(wxT("platform"), &s))
547 isok = true;
548 else
549 {
550 wxStringTokenizer tkn(s, wxT(" |"));
551
552 while (tkn.HasMoreTokens())
553 {
554 s = tkn.GetNextToken();
555 #ifdef __WINDOWS__
556 if (s == wxT("win")) isok = true;
557 #endif
558 #if defined(__MAC__) || defined(__APPLE__)
559 if (s == wxT("mac")) isok = true;
560 #elif defined(__UNIX__)
561 if (s == wxT("unix")) isok = true;
562 #endif
563 #ifdef __OS2__
564 if (s == wxT("os2")) isok = true;
565 #endif
566
567 if (isok)
568 break;
569 }
570 }
571
572 if (isok)
573 {
574 ProcessPlatformProperty(c);
575 c = c->GetNext();
576 }
577 else
578 {
579 wxXmlNode *c2 = c->GetNext();
580 node->RemoveChild(c);
581 delete c;
582 c = c2;
583 }
584 }
585 }
586
587 static void PreprocessForIdRanges(wxXmlNode *rootnode)
588 {
589 // First go through the top level, looking for the names of ID ranges
590 // as processing items is a lot easier if names are already known
591 wxXmlNode *c = rootnode->GetChildren();
592 while (c)
593 {
594 if (c->GetName() == wxT("ids-range"))
595 wxIdRangeManager::Get()->AddRange(c);
596 c = c->GetNext();
597 }
598
599 // Next, examine every 'name' for the '[' that denotes an ID in a range
600 c = rootnode->GetChildren();
601 while (c)
602 {
603 wxString name = c->GetAttribute(wxT("name"));
604 if (name.find('[') != wxString::npos)
605 wxIdRangeManager::Get()->NotifyRangeOfItem(rootnode, name);
606
607 // Do any children by recursion, then proceed to the next sibling
608 PreprocessForIdRanges(c);
609 c = c->GetNext();
610 }
611 }
612
613 bool wxXmlResource::UpdateResources()
614 {
615 bool rt = true;
616 bool modif;
617 # if wxUSE_FILESYSTEM
618 wxFSFile *file = NULL;
619 wxUnusedVar(file);
620 wxFileSystem fsys;
621 # endif
622
623 wxString encoding(wxT("UTF-8"));
624 #if !wxUSE_UNICODE && wxUSE_INTL
625 if ( (GetFlags() & wxXRC_USE_LOCALE) == 0 )
626 {
627 // In case we are not using wxLocale to translate strings, convert the
628 // strings GUI's charset. This must not be done when wxXRC_USE_LOCALE
629 // is on, because it could break wxGetTranslation lookup.
630 encoding = wxLocale::GetSystemEncodingName();
631 }
632 #endif
633
634 for ( wxXmlResourceDataRecords::iterator i = Data().begin();
635 i != Data().end(); ++i )
636 {
637 wxXmlResourceDataRecord* const rec = *i;
638
639 modif = (rec->Doc == NULL);
640
641 if (!modif && !(m_flags & wxXRC_NO_RELOADING))
642 {
643 # if wxUSE_FILESYSTEM
644 file = fsys.OpenFile(rec->File);
645 # if wxUSE_DATETIME
646 modif = file && file->GetModificationTime() > rec->Time;
647 # else // wxUSE_DATETIME
648 modif = true;
649 # endif // wxUSE_DATETIME
650 if (!file)
651 {
652 wxLogError(_("Cannot open file '%s'."), rec->File);
653 rt = false;
654 }
655 wxDELETE(file);
656 wxUnusedVar(file);
657 # else // wxUSE_FILESYSTEM
658 # if wxUSE_DATETIME
659 modif = wxDateTime(wxFileModificationTime(rec->File)) > rec->Time;
660 # else // wxUSE_DATETIME
661 modif = true;
662 # endif // wxUSE_DATETIME
663 # endif // wxUSE_FILESYSTEM
664 }
665
666 if (modif)
667 {
668 wxLogTrace(wxT("xrc"), wxT("opening file '%s'"), rec->File);
669
670 wxInputStream *stream = NULL;
671
672 # if wxUSE_FILESYSTEM
673 file = fsys.OpenFile(rec->File);
674 if (file)
675 stream = file->GetStream();
676 # else
677 stream = new wxFileInputStream(rec->File);
678 # endif
679
680 if (stream)
681 {
682 delete rec->Doc;
683 rec->Doc = new wxXmlDocument;
684 }
685 if (!stream || !stream->IsOk() || !rec->Doc->Load(*stream, encoding))
686 {
687 wxLogError(_("Cannot load resources from file '%s'."),
688 rec->File);
689 wxDELETE(rec->Doc);
690 rt = false;
691 }
692 else if (rec->Doc->GetRoot()->GetName() != wxT("resource"))
693 {
694 ReportError
695 (
696 rec->Doc->GetRoot(),
697 "invalid XRC resource, doesn't have root node <resource>"
698 );
699 wxDELETE(rec->Doc);
700 rt = false;
701 }
702 else
703 {
704 long version;
705 int v1, v2, v3, v4;
706 wxString verstr = rec->Doc->GetRoot()->GetAttribute(
707 wxT("version"), wxT("0.0.0.0"));
708 if (wxSscanf(verstr.c_str(), wxT("%i.%i.%i.%i"),
709 &v1, &v2, &v3, &v4) == 4)
710 version = v1*256*256*256+v2*256*256+v3*256+v4;
711 else
712 version = 0;
713 if (m_version == -1)
714 m_version = version;
715 if (m_version != version)
716 {
717 wxLogError("Resource files must have same version number.");
718 rt = false;
719 }
720
721 ProcessPlatformProperty(rec->Doc->GetRoot());
722 PreprocessForIdRanges(rec->Doc->GetRoot());
723 wxIdRangeManager::Get()->FinaliseRanges(rec->Doc->GetRoot());
724 #if wxUSE_DATETIME
725 #if wxUSE_FILESYSTEM
726 rec->Time = file->GetModificationTime();
727 #else // wxUSE_FILESYSTEM
728 rec->Time = wxDateTime(wxFileModificationTime(rec->File));
729 #endif // wxUSE_FILESYSTEM
730 #endif // wxUSE_DATETIME
731 }
732
733 # if wxUSE_FILESYSTEM
734 wxDELETE(file);
735 wxUnusedVar(file);
736 # else
737 wxDELETE(stream);
738 # endif
739 }
740 }
741
742 return rt;
743 }
744
745 wxXmlNode *wxXmlResource::DoFindResource(wxXmlNode *parent,
746 const wxString& name,
747 const wxString& classname,
748 bool recursive) const
749 {
750 wxXmlNode *node;
751
752 // first search for match at the top-level nodes (as this is
753 // where the resource is most commonly looked for):
754 for (node = parent->GetChildren(); node; node = node->GetNext())
755 {
756 if ( IsObjectNode(node) && node->GetAttribute(wxS("name")) == name )
757 {
758 // empty class name matches everything
759 if ( classname.empty() )
760 return node;
761
762 wxString cls(node->GetAttribute(wxS("class")));
763
764 // object_ref may not have 'class' attribute:
765 if (cls.empty() && node->GetName() == wxS("object_ref"))
766 {
767 wxString refName = node->GetAttribute(wxS("ref"));
768 if (refName.empty())
769 continue;
770
771 const wxXmlNode * const refNode = GetResourceNode(refName);
772 if ( refNode )
773 cls = refNode->GetAttribute(wxS("class"));
774 }
775
776 if ( cls == classname )
777 return node;
778 }
779 }
780
781 // then recurse in child nodes
782 if ( recursive )
783 {
784 for (node = parent->GetChildren(); node; node = node->GetNext())
785 {
786 if ( IsObjectNode(node) )
787 {
788 wxXmlNode* found = DoFindResource(node, name, classname, true);
789 if ( found )
790 return found;
791 }
792 }
793 }
794
795 return NULL;
796 }
797
798 wxXmlNode *wxXmlResource::FindResource(const wxString& name,
799 const wxString& classname,
800 bool recursive)
801 {
802 wxString path;
803 wxXmlNode * const
804 node = GetResourceNodeAndLocation(name, classname, recursive, &path);
805
806 if ( !node )
807 {
808 ReportError
809 (
810 NULL,
811 wxString::Format
812 (
813 "XRC resource \"%s\" (class \"%s\") not found",
814 name, classname
815 )
816 );
817 }
818 #if wxUSE_FILESYSTEM
819 else // node was found
820 {
821 // ensure that relative paths work correctly when loading this node
822 // (which should happen as soon as we return as FindResource() result
823 // is always passed to CreateResFromNode())
824 m_curFileSystem.ChangePathTo(path);
825 }
826 #endif // wxUSE_FILESYSTEM
827
828 return node;
829 }
830
831 wxXmlNode *
832 wxXmlResource::GetResourceNodeAndLocation(const wxString& name,
833 const wxString& classname,
834 bool recursive,
835 wxString *path) const
836 {
837 // ensure everything is up-to-date: this is needed to support on-demand
838 // reloading of XRC files
839 const_cast<wxXmlResource *>(this)->UpdateResources();
840
841 for ( wxXmlResourceDataRecords::const_iterator f = Data().begin();
842 f != Data().end(); ++f )
843 {
844 wxXmlResourceDataRecord *const rec = *f;
845 wxXmlDocument * const doc = rec->Doc;
846 if ( !doc || !doc->GetRoot() )
847 continue;
848
849 wxXmlNode * const
850 found = DoFindResource(doc->GetRoot(), name, classname, recursive);
851 if ( found )
852 {
853 if ( path )
854 *path = rec->File;
855
856 return found;
857 }
858 }
859
860 return NULL;
861 }
862
863 static void MergeNodesOver(wxXmlNode& dest, wxXmlNode& overwriteWith,
864 const wxString& overwriteFilename)
865 {
866 // Merge attributes:
867 for ( wxXmlAttribute *attr = overwriteWith.GetAttributes();
868 attr; attr = attr->GetNext() )
869 {
870 wxXmlAttribute *dattr;
871 for (dattr = dest.GetAttributes(); dattr; dattr = dattr->GetNext())
872 {
873
874 if ( dattr->GetName() == attr->GetName() )
875 {
876 dattr->SetValue(attr->GetValue());
877 break;
878 }
879 }
880
881 if ( !dattr )
882 dest.AddAttribute(attr->GetName(), attr->GetValue());
883 }
884
885 // Merge child nodes:
886 for (wxXmlNode* node = overwriteWith.GetChildren(); node; node = node->GetNext())
887 {
888 wxString name = node->GetAttribute(wxT("name"), wxEmptyString);
889 wxXmlNode *dnode;
890
891 for (dnode = dest.GetChildren(); dnode; dnode = dnode->GetNext() )
892 {
893 if ( dnode->GetName() == node->GetName() &&
894 dnode->GetAttribute(wxT("name"), wxEmptyString) == name &&
895 dnode->GetType() == node->GetType() )
896 {
897 MergeNodesOver(*dnode, *node, overwriteFilename);
898 break;
899 }
900 }
901
902 if ( !dnode )
903 {
904 wxXmlNode *copyOfNode = new wxXmlNode(*node);
905 // remember referenced object's file, see GetFileNameFromNode()
906 copyOfNode->AddAttribute(ATTR_INPUT_FILENAME, overwriteFilename);
907
908 static const wxChar *AT_END = wxT("end");
909 wxString insert_pos = node->GetAttribute(wxT("insert_at"), AT_END);
910 if ( insert_pos == AT_END )
911 {
912 dest.AddChild(copyOfNode);
913 }
914 else if ( insert_pos == wxT("begin") )
915 {
916 dest.InsertChild(copyOfNode, dest.GetChildren());
917 }
918 }
919 }
920
921 if ( dest.GetType() == wxXML_TEXT_NODE && overwriteWith.GetContent().length() )
922 dest.SetContent(overwriteWith.GetContent());
923 }
924
925 wxObject *
926 wxXmlResource::DoCreateResFromNode(wxXmlNode& node,
927 wxObject *parent,
928 wxObject *instance,
929 wxXmlResourceHandler *handlerToUse)
930 {
931 // handling of referenced resource
932 if ( node.GetName() == wxT("object_ref") )
933 {
934 wxString refName = node.GetAttribute(wxT("ref"), wxEmptyString);
935 wxXmlNode* refNode = FindResource(refName, wxEmptyString, true);
936
937 if ( !refNode )
938 {
939 ReportError
940 (
941 &node,
942 wxString::Format
943 (
944 "referenced object node with ref=\"%s\" not found",
945 refName
946 )
947 );
948 return NULL;
949 }
950
951 if ( !node.GetChildren() )
952 {
953 // In the typical, simple case, <object_ref> is used to link
954 // to another node and doesn't have any content of its own that
955 // would overwrite linked object's properties. In this case,
956 // we can simply create the resource from linked node.
957
958 return DoCreateResFromNode(*refNode, parent, instance);
959 }
960 else
961 {
962 // In the more complicated (but rare) case, <object_ref> has
963 // subnodes that partially overwrite content of the referenced
964 // object. In this case, we need to merge both XML trees and
965 // load the resource from result of the merge.
966
967 wxXmlNode copy(*refNode);
968 MergeNodesOver(copy, node, GetFileNameFromNode(&node, Data()));
969
970 // remember referenced object's file, see GetFileNameFromNode()
971 copy.AddAttribute(ATTR_INPUT_FILENAME,
972 GetFileNameFromNode(refNode, Data()));
973
974 return DoCreateResFromNode(copy, parent, instance);
975 }
976 }
977
978 if (handlerToUse)
979 {
980 if (handlerToUse->CanHandle(&node))
981 {
982 return handlerToUse->CreateResource(&node, parent, instance);
983 }
984 }
985 else if (node.GetName() == wxT("object"))
986 {
987 for ( wxVector<wxXmlResourceHandler*>::iterator h = m_handlers.begin();
988 h != m_handlers.end(); ++h )
989 {
990 wxXmlResourceHandler *handler = *h;
991 if (handler->CanHandle(&node))
992 return handler->CreateResource(&node, parent, instance);
993 }
994 }
995
996 ReportError
997 (
998 &node,
999 wxString::Format
1000 (
1001 "no handler found for XML node \"%s\" (class \"%s\")",
1002 node.GetName(),
1003 node.GetAttribute("class", wxEmptyString)
1004 )
1005 );
1006 return NULL;
1007 }
1008
1009 wxIdRange::wxIdRange(const wxXmlNode* node,
1010 const wxString& rname,
1011 const wxString& startno,
1012 const wxString& rsize)
1013 : m_name(rname),
1014 m_start(0),
1015 m_size(0),
1016 m_item_end_found(0),
1017 m_finalised(0)
1018 {
1019 long l;
1020 if ( startno.ToLong(&l) )
1021 {
1022 if ( l >= 0 )
1023 {
1024 m_start = l;
1025 }
1026 else
1027 {
1028 wxXmlResource::Get()->ReportError
1029 (
1030 node,
1031 "a negative id-range start parameter was given"
1032 );
1033 }
1034 }
1035 else
1036 {
1037 wxXmlResource::Get()->ReportError
1038 (
1039 node,
1040 "the id-range start parameter was malformed"
1041 );
1042 }
1043
1044 unsigned long ul;
1045 if ( rsize.ToULong(&ul) )
1046 {
1047 m_size = ul;
1048 }
1049 else
1050 {
1051 wxXmlResource::Get()->ReportError
1052 (
1053 node,
1054 "the id-range size parameter was malformed"
1055 );
1056 }
1057 }
1058
1059 void wxIdRange::NoteItem(const wxXmlNode* node, const wxString& item)
1060 {
1061 // Nothing gets added here, but the existence of each item is noted
1062 // thus getting an accurate count. 'item' will be either an integer e.g.
1063 // [0] [123]: will eventually create an XRCID as start+integer or [start]
1064 // or [end] which are synonyms for [0] or [range_size-1] respectively.
1065 wxString content(item.Mid(1, item.length()-2));
1066
1067 // Check that basename+item wasn't foo[]
1068 if (content.empty())
1069 {
1070 wxXmlResource::Get()->ReportError(node, "an empty id-range item found");
1071 return;
1072 }
1073
1074 if (content=="start")
1075 {
1076 // "start" means [0], so store that in the set
1077 if (m_indices.count(0) == 0)
1078 {
1079 m_indices.insert(0);
1080 }
1081 else
1082 {
1083 wxXmlResource::Get()->ReportError
1084 (
1085 node,
1086 "duplicate id-range item found"
1087 );
1088 }
1089 }
1090 else if (content=="end")
1091 {
1092 // We can't yet be certain which XRCID this will be equivalent to, so
1093 // just note that there's an item with this name, in case we need to
1094 // inc the range size
1095 m_item_end_found = true;
1096 }
1097 else
1098 {
1099 // Anything else will be an integer, or rubbish
1100 unsigned long l;
1101 if ( content.ToULong(&l) )
1102 {
1103 if (m_indices.count(l) == 0)
1104 {
1105 m_indices.insert(l);
1106 // Check that this item wouldn't fall outside the current range
1107 // extent
1108 if (l >= m_size)
1109 {
1110 m_size = l + 1;
1111 }
1112 }
1113 else
1114 {
1115 wxXmlResource::Get()->ReportError
1116 (
1117 node,
1118 "duplicate id-range item found"
1119 );
1120 }
1121
1122 }
1123 else
1124 {
1125 wxXmlResource::Get()->ReportError
1126 (
1127 node,
1128 "an id-range item had a malformed index"
1129 );
1130 }
1131 }
1132 }
1133
1134 void wxIdRange::Finalise(const wxXmlNode* node)
1135 {
1136 wxCHECK_RET( !IsFinalised(),
1137 "Trying to finalise an already-finalised range" );
1138
1139 // Now we know about all the items, we can get an accurate range size
1140 // Expand any requested range-size if there were more items than would fit
1141 m_size = wxMax(m_size, m_indices.size());
1142
1143 // If an item is explicitly called foo[end], ensure it won't clash with
1144 // another item
1145 if ( m_item_end_found && m_indices.count(m_size-1) )
1146 ++m_size;
1147 if (m_size == 0)
1148 {
1149 // This will happen if someone creates a range but no items in this xrc
1150 // file Report the error and abort, but don't finalise, in case items
1151 // appear later
1152 wxXmlResource::Get()->ReportError
1153 (
1154 node,
1155 "trying to create an empty id-range"
1156 );
1157 return;
1158 }
1159
1160 if (m_start==0)
1161 {
1162 // This is the usual case, where the user didn't specify a start ID
1163 // So get the range using NewControlId().
1164 //
1165 // NB: negative numbers, but NewControlId already returns the most
1166 // negative
1167 m_start = wxWindow::NewControlId(m_size);
1168 wxCHECK_RET( m_start != wxID_NONE,
1169 "insufficient IDs available to create range" );
1170 m_end = m_start + m_size - 1;
1171 }
1172 else
1173 {
1174 // The user already specified a start value, which must be positive
1175 m_end = m_start + m_size - 1;
1176 }
1177
1178 // Create the XRCIDs
1179 for (int i=m_start; i <= m_end; ++i)
1180 {
1181 // First clear any pre-existing XRCID
1182 // Necessary for wxXmlResource::Unload() followed by Load()
1183 wxIdRangeManager::RemoveXRCIDEntry(
1184 m_name + wxString::Format("[%i]", i-m_start));
1185
1186 // Use the second parameter of GetXRCID to force it to take the value i
1187 wxXmlResource::GetXRCID(m_name + wxString::Format("[%i]", i-m_start), i);
1188 wxLogTrace("xrcrange",
1189 "integer = %i %s now returns %i",
1190 i,
1191 m_name + wxString::Format("[%i]", i-m_start),
1192 XRCID((m_name + wxString::Format("[%i]", i-m_start)).mb_str()));
1193 }
1194 // and these special ones
1195 wxIdRangeManager::RemoveXRCIDEntry(m_name + "[start]");
1196 wxXmlResource::GetXRCID(m_name + "[start]", m_start);
1197 wxIdRangeManager::RemoveXRCIDEntry(m_name + "[end]");
1198 wxXmlResource::GetXRCID(m_name + "[end]", m_end);
1199 wxLogTrace("xrcrange","%s[start] = %i %s[end] = %i",
1200 m_name.mb_str(),XRCID(wxString(m_name+"[start]").mb_str()),
1201 m_name.mb_str(),XRCID(wxString(m_name+"[end]").mb_str()));
1202
1203 m_finalised = true;
1204 }
1205
1206 wxIdRangeManager *wxIdRangeManager::ms_instance = NULL;
1207
1208 /*static*/ wxIdRangeManager *wxIdRangeManager::Get()
1209 {
1210 if ( !ms_instance )
1211 ms_instance = new wxIdRangeManager;
1212 return ms_instance;
1213 }
1214
1215 /*static*/ wxIdRangeManager *wxIdRangeManager::Set(wxIdRangeManager *res)
1216 {
1217 wxIdRangeManager *old = ms_instance;
1218 ms_instance = res;
1219 return old;
1220 }
1221
1222 wxIdRangeManager::~wxIdRangeManager()
1223 {
1224 for ( wxVector<wxIdRange*>::iterator i = m_IdRanges.begin();
1225 i != m_IdRanges.end(); ++i )
1226 {
1227 delete *i;
1228 }
1229 m_IdRanges.clear();
1230
1231 delete ms_instance;
1232 }
1233
1234 void wxIdRangeManager::AddRange(const wxXmlNode* node)
1235 {
1236 wxString name = node->GetAttribute("name");
1237 wxString start = node->GetAttribute("start", "0");
1238 wxString size = node->GetAttribute("size", "0");
1239 if (name.empty())
1240 {
1241 wxXmlResource::Get()->ReportError
1242 (
1243 node,
1244 "xrc file contains an id-range without a name"
1245 );
1246 return;
1247 }
1248
1249 int index = Find(name);
1250 if (index == wxNOT_FOUND)
1251 {
1252 wxLogTrace("xrcrange",
1253 "Adding ID range, name=%s start=%s size=%s",
1254 name, start, size);
1255
1256 m_IdRanges.push_back(new wxIdRange(node, name, start, size));
1257 }
1258 else
1259 {
1260 // There was already a range with this name. Let's hope this is
1261 // from an Unload()/(re)Load(), not an unintentional duplication
1262 wxLogTrace("xrcrange",
1263 "Replacing ID range, name=%s start=%s size=%s",
1264 name, start, size);
1265
1266 wxIdRange* oldrange = m_IdRanges.at(index);
1267 m_IdRanges.at(index) = new wxIdRange(node, name, start, size);
1268 delete oldrange;
1269 }
1270 }
1271
1272 wxIdRange *
1273 wxIdRangeManager::FindRangeForItem(const wxXmlNode* node,
1274 const wxString& item,
1275 wxString& value) const
1276 {
1277 wxString basename = item.BeforeFirst('[');
1278 wxCHECK_MSG( !basename.empty(), NULL,
1279 "an id-range item without a range name" );
1280
1281 int index = Find(basename);
1282 if (index == wxNOT_FOUND)
1283 {
1284 // Don't assert just because we've found an unexpected foo[123]
1285 // Someone might just want such a name, nothing to do with ranges
1286 return NULL;
1287 }
1288
1289 value = item.Mid(basename.Len());
1290 if (value.at(value.length()-1)==']')
1291 {
1292 return m_IdRanges.at(index);
1293 }
1294 wxXmlResource::Get()->ReportError(node, "a malformed id-range item");
1295 return NULL;
1296 }
1297
1298 void
1299 wxIdRangeManager::NotifyRangeOfItem(const wxXmlNode* node,
1300 const wxString& item) const
1301 {
1302 wxString value;
1303 wxIdRange* range = FindRangeForItem(node, item, value);
1304 if (range)
1305 range->NoteItem(node, value);
1306 }
1307
1308 int wxIdRangeManager::Find(const wxString& rangename) const
1309 {
1310 for ( int i=0; i < (int)m_IdRanges.size(); ++i )
1311 {
1312 if (m_IdRanges.at(i)->GetName() == rangename)
1313 return i;
1314 }
1315
1316 return wxNOT_FOUND;
1317 }
1318
1319 void wxIdRangeManager::FinaliseRanges(const wxXmlNode* node) const
1320 {
1321 for ( wxVector<wxIdRange*>::const_iterator i = m_IdRanges.begin();
1322 i != m_IdRanges.end(); ++i )
1323 {
1324 // Check if this range has already been finalised. Quite possible,
1325 // as FinaliseRanges() gets called for each .xrc file loaded
1326 if (!(*i)->IsFinalised())
1327 {
1328 wxLogTrace("xrcrange", "Finalising ID range %s", (*i)->GetName());
1329 (*i)->Finalise(node);
1330 }
1331 }
1332 }
1333
1334
1335 class wxXmlSubclassFactories : public wxVector<wxXmlSubclassFactory*>
1336 {
1337 // this is a class so that it can be forward-declared
1338 };
1339
1340 wxXmlSubclassFactories *wxXmlResource::ms_subclassFactories = NULL;
1341
1342 /*static*/ void wxXmlResource::AddSubclassFactory(wxXmlSubclassFactory *factory)
1343 {
1344 if (!ms_subclassFactories)
1345 {
1346 ms_subclassFactories = new wxXmlSubclassFactories;
1347 }
1348 ms_subclassFactories->push_back(factory);
1349 }
1350
1351 class wxXmlSubclassFactoryCXX : public wxXmlSubclassFactory
1352 {
1353 public:
1354 ~wxXmlSubclassFactoryCXX() {}
1355
1356 wxObject *Create(const wxString& className)
1357 {
1358 wxClassInfo* classInfo = wxClassInfo::FindClass(className);
1359
1360 if (classInfo)
1361 return classInfo->CreateObject();
1362 else
1363 return NULL;
1364 }
1365 };
1366
1367
1368
1369
1370 wxXmlResourceHandler::wxXmlResourceHandler()
1371 : m_node(NULL), m_parent(NULL), m_instance(NULL),
1372 m_parentAsWindow(NULL)
1373 {}
1374
1375
1376
1377 wxObject *wxXmlResourceHandler::CreateResource(wxXmlNode *node, wxObject *parent, wxObject *instance)
1378 {
1379 wxXmlNode *myNode = m_node;
1380 wxString myClass = m_class;
1381 wxObject *myParent = m_parent, *myInstance = m_instance;
1382 wxWindow *myParentAW = m_parentAsWindow;
1383
1384 m_instance = instance;
1385 if (!m_instance && node->HasAttribute(wxT("subclass")) &&
1386 !(m_resource->GetFlags() & wxXRC_NO_SUBCLASSING))
1387 {
1388 wxString subclass = node->GetAttribute(wxT("subclass"), wxEmptyString);
1389 if (!subclass.empty())
1390 {
1391 for (wxXmlSubclassFactories::iterator i = wxXmlResource::ms_subclassFactories->begin();
1392 i != wxXmlResource::ms_subclassFactories->end(); ++i)
1393 {
1394 m_instance = (*i)->Create(subclass);
1395 if (m_instance)
1396 break;
1397 }
1398
1399 if (!m_instance)
1400 {
1401 wxString name = node->GetAttribute(wxT("name"), wxEmptyString);
1402 ReportError
1403 (
1404 node,
1405 wxString::Format
1406 (
1407 "subclass \"%s\" not found for resource \"%s\", not subclassing",
1408 subclass, name
1409 )
1410 );
1411 }
1412 }
1413 }
1414
1415 m_node = node;
1416 m_class = node->GetAttribute(wxT("class"), wxEmptyString);
1417 m_parent = parent;
1418 m_parentAsWindow = wxDynamicCast(m_parent, wxWindow);
1419
1420 wxObject *returned = DoCreateResource();
1421
1422 m_node = myNode;
1423 m_class = myClass;
1424 m_parent = myParent; m_parentAsWindow = myParentAW;
1425 m_instance = myInstance;
1426
1427 return returned;
1428 }
1429
1430
1431 void wxXmlResourceHandler::AddStyle(const wxString& name, int value)
1432 {
1433 m_styleNames.Add(name);
1434 m_styleValues.Add(value);
1435 }
1436
1437
1438
1439 void wxXmlResourceHandler::AddWindowStyles()
1440 {
1441 XRC_ADD_STYLE(wxCLIP_CHILDREN);
1442
1443 // the border styles all have the old and new names, recognize both for now
1444 XRC_ADD_STYLE(wxSIMPLE_BORDER); XRC_ADD_STYLE(wxBORDER_SIMPLE);
1445 XRC_ADD_STYLE(wxSUNKEN_BORDER); XRC_ADD_STYLE(wxBORDER_SUNKEN);
1446 XRC_ADD_STYLE(wxDOUBLE_BORDER); XRC_ADD_STYLE(wxBORDER_DOUBLE); // deprecated
1447 XRC_ADD_STYLE(wxBORDER_THEME);
1448 XRC_ADD_STYLE(wxRAISED_BORDER); XRC_ADD_STYLE(wxBORDER_RAISED);
1449 XRC_ADD_STYLE(wxSTATIC_BORDER); XRC_ADD_STYLE(wxBORDER_STATIC);
1450 XRC_ADD_STYLE(wxNO_BORDER); XRC_ADD_STYLE(wxBORDER_NONE);
1451
1452 XRC_ADD_STYLE(wxTRANSPARENT_WINDOW);
1453 XRC_ADD_STYLE(wxWANTS_CHARS);
1454 XRC_ADD_STYLE(wxTAB_TRAVERSAL);
1455 XRC_ADD_STYLE(wxNO_FULL_REPAINT_ON_RESIZE);
1456 XRC_ADD_STYLE(wxFULL_REPAINT_ON_RESIZE);
1457 XRC_ADD_STYLE(wxALWAYS_SHOW_SB);
1458 XRC_ADD_STYLE(wxWS_EX_BLOCK_EVENTS);
1459 XRC_ADD_STYLE(wxWS_EX_VALIDATE_RECURSIVELY);
1460 }
1461
1462
1463
1464 bool wxXmlResourceHandler::HasParam(const wxString& param)
1465 {
1466 return (GetParamNode(param) != NULL);
1467 }
1468
1469
1470 int wxXmlResourceHandler::GetStyle(const wxString& param, int defaults)
1471 {
1472 wxString s = GetParamValue(param);
1473
1474 if (!s) return defaults;
1475
1476 wxStringTokenizer tkn(s, wxT("| \t\n"), wxTOKEN_STRTOK);
1477 int style = 0;
1478 int index;
1479 wxString fl;
1480 while (tkn.HasMoreTokens())
1481 {
1482 fl = tkn.GetNextToken();
1483 index = m_styleNames.Index(fl);
1484 if (index != wxNOT_FOUND)
1485 {
1486 style |= m_styleValues[index];
1487 }
1488 else
1489 {
1490 ReportParamError
1491 (
1492 param,
1493 wxString::Format("unknown style flag \"%s\"", fl)
1494 );
1495 }
1496 }
1497 return style;
1498 }
1499
1500
1501
1502 wxString wxXmlResourceHandler::GetText(const wxString& param, bool translate)
1503 {
1504 wxXmlNode *parNode = GetParamNode(param);
1505 wxString str1(GetNodeContent(parNode));
1506 wxString str2;
1507
1508 // "\\" wasn't translated to "\" prior to 2.5.3.0:
1509 const bool escapeBackslash = (m_resource->CompareVersion(2,5,3,0) >= 0);
1510
1511 // VS: First version of XRC resources used $ instead of & (which is
1512 // illegal in XML), but later I realized that '_' fits this purpose
1513 // much better (because &File means "File with F underlined").
1514 const wxChar amp_char = (m_resource->CompareVersion(2,3,0,1) < 0)
1515 ? '$' : '_';
1516
1517 for ( wxString::const_iterator dt = str1.begin(); dt != str1.end(); ++dt )
1518 {
1519 // Remap amp_char to &, map double amp_char to amp_char (for things
1520 // like "&File..." -- this is illegal in XML, so we use "_File..."):
1521 if ( *dt == amp_char )
1522 {
1523 if ( *(++dt) == amp_char )
1524 str2 << amp_char;
1525 else
1526 str2 << wxT('&') << *dt;
1527 }
1528 // Remap \n to CR, \r to LF, \t to TAB, \\ to \:
1529 else if ( *dt == wxT('\\') )
1530 {
1531 switch ( (*(++dt)).GetValue() )
1532 {
1533 case wxT('n'):
1534 str2 << wxT('\n');
1535 break;
1536
1537 case wxT('t'):
1538 str2 << wxT('\t');
1539 break;
1540
1541 case wxT('r'):
1542 str2 << wxT('\r');
1543 break;
1544
1545 case wxT('\\') :
1546 // "\\" wasn't translated to "\" prior to 2.5.3.0:
1547 if ( escapeBackslash )
1548 {
1549 str2 << wxT('\\');
1550 break;
1551 }
1552 // else fall-through to default: branch below
1553
1554 default:
1555 str2 << wxT('\\') << *dt;
1556 break;
1557 }
1558 }
1559 else
1560 {
1561 str2 << *dt;
1562 }
1563 }
1564
1565 if (m_resource->GetFlags() & wxXRC_USE_LOCALE)
1566 {
1567 if (translate && parNode &&
1568 parNode->GetAttribute(wxT("translate"), wxEmptyString) != wxT("0"))
1569 {
1570 return wxGetTranslation(str2, m_resource->GetDomain());
1571 }
1572 else
1573 {
1574 #if wxUSE_UNICODE
1575 return str2;
1576 #else
1577 // The string is internally stored as UTF-8, we have to convert
1578 // it into system's default encoding so that it can be displayed:
1579 return wxString(str2.wc_str(wxConvUTF8), wxConvLocal);
1580 #endif
1581 }
1582 }
1583
1584 // If wxXRC_USE_LOCALE is not set, then the string is already in
1585 // system's default encoding in ANSI build, so we don't have to
1586 // do anything special here.
1587 return str2;
1588 }
1589
1590
1591
1592 long wxXmlResourceHandler::GetLong(const wxString& param, long defaultv)
1593 {
1594 long value;
1595 wxString str1 = GetParamValue(param);
1596
1597 if (!str1.ToLong(&value))
1598 value = defaultv;
1599
1600 return value;
1601 }
1602
1603 float wxXmlResourceHandler::GetFloat(const wxString& param, float defaultv)
1604 {
1605 wxString str = GetParamValue(param);
1606
1607 // strings in XRC always use C locale so make sure to use the
1608 // locale-independent wxString::ToCDouble() and not ToDouble() which uses
1609 // the current locale with a potentially different decimal point character
1610 double value;
1611 if (!str.ToCDouble(&value))
1612 value = defaultv;
1613
1614 return wx_truncate_cast(float, value);
1615 }
1616
1617
1618 int wxXmlResourceHandler::GetID()
1619 {
1620 return wxXmlResource::GetXRCID(GetName());
1621 }
1622
1623
1624
1625 wxString wxXmlResourceHandler::GetName()
1626 {
1627 return m_node->GetAttribute(wxT("name"), wxT("-1"));
1628 }
1629
1630
1631
1632 bool wxXmlResourceHandler::GetBoolAttr(const wxString& attr, bool defaultv)
1633 {
1634 wxString v;
1635 return m_node->GetAttribute(attr, &v) ? v == '1' : defaultv;
1636 }
1637
1638 bool wxXmlResourceHandler::GetBool(const wxString& param, bool defaultv)
1639 {
1640 const wxString v = GetParamValue(param);
1641
1642 return v.empty() ? defaultv : (v == '1');
1643 }
1644
1645
1646 static wxColour GetSystemColour(const wxString& name)
1647 {
1648 if (!name.empty())
1649 {
1650 #define SYSCLR(clr) \
1651 if (name == wxT(#clr)) return wxSystemSettings::GetColour(clr);
1652 SYSCLR(wxSYS_COLOUR_SCROLLBAR)
1653 SYSCLR(wxSYS_COLOUR_BACKGROUND)
1654 SYSCLR(wxSYS_COLOUR_DESKTOP)
1655 SYSCLR(wxSYS_COLOUR_ACTIVECAPTION)
1656 SYSCLR(wxSYS_COLOUR_INACTIVECAPTION)
1657 SYSCLR(wxSYS_COLOUR_MENU)
1658 SYSCLR(wxSYS_COLOUR_WINDOW)
1659 SYSCLR(wxSYS_COLOUR_WINDOWFRAME)
1660 SYSCLR(wxSYS_COLOUR_MENUTEXT)
1661 SYSCLR(wxSYS_COLOUR_WINDOWTEXT)
1662 SYSCLR(wxSYS_COLOUR_CAPTIONTEXT)
1663 SYSCLR(wxSYS_COLOUR_ACTIVEBORDER)
1664 SYSCLR(wxSYS_COLOUR_INACTIVEBORDER)
1665 SYSCLR(wxSYS_COLOUR_APPWORKSPACE)
1666 SYSCLR(wxSYS_COLOUR_HIGHLIGHT)
1667 SYSCLR(wxSYS_COLOUR_HIGHLIGHTTEXT)
1668 SYSCLR(wxSYS_COLOUR_BTNFACE)
1669 SYSCLR(wxSYS_COLOUR_3DFACE)
1670 SYSCLR(wxSYS_COLOUR_BTNSHADOW)
1671 SYSCLR(wxSYS_COLOUR_3DSHADOW)
1672 SYSCLR(wxSYS_COLOUR_GRAYTEXT)
1673 SYSCLR(wxSYS_COLOUR_BTNTEXT)
1674 SYSCLR(wxSYS_COLOUR_INACTIVECAPTIONTEXT)
1675 SYSCLR(wxSYS_COLOUR_BTNHIGHLIGHT)
1676 SYSCLR(wxSYS_COLOUR_BTNHILIGHT)
1677 SYSCLR(wxSYS_COLOUR_3DHIGHLIGHT)
1678 SYSCLR(wxSYS_COLOUR_3DHILIGHT)
1679 SYSCLR(wxSYS_COLOUR_3DDKSHADOW)
1680 SYSCLR(wxSYS_COLOUR_3DLIGHT)
1681 SYSCLR(wxSYS_COLOUR_INFOTEXT)
1682 SYSCLR(wxSYS_COLOUR_INFOBK)
1683 SYSCLR(wxSYS_COLOUR_LISTBOX)
1684 SYSCLR(wxSYS_COLOUR_HOTLIGHT)
1685 SYSCLR(wxSYS_COLOUR_GRADIENTACTIVECAPTION)
1686 SYSCLR(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)
1687 SYSCLR(wxSYS_COLOUR_MENUHILIGHT)
1688 SYSCLR(wxSYS_COLOUR_MENUBAR)
1689 #undef SYSCLR
1690 }
1691
1692 return wxNullColour;
1693 }
1694
1695 wxColour wxXmlResourceHandler::GetColour(const wxString& param, const wxColour& defaultv)
1696 {
1697 wxString v = GetParamValue(param);
1698
1699 if ( v.empty() )
1700 return defaultv;
1701
1702 wxColour clr;
1703
1704 // wxString -> wxColour conversion
1705 if (!clr.Set(v))
1706 {
1707 // the colour doesn't use #RRGGBB format, check if it is symbolic
1708 // colour name:
1709 clr = GetSystemColour(v);
1710 if (clr.Ok())
1711 return clr;
1712
1713 ReportParamError
1714 (
1715 param,
1716 wxString::Format("incorrect colour specification \"%s\"", v)
1717 );
1718 return wxNullColour;
1719 }
1720
1721 return clr;
1722 }
1723
1724 namespace
1725 {
1726
1727 // if 'param' has stock_id/stock_client, extracts them and returns true
1728 bool GetStockArtAttrs(const wxXmlNode *paramNode,
1729 const wxString& defaultArtClient,
1730 wxString& art_id, wxString& art_client)
1731 {
1732 if ( paramNode )
1733 {
1734 art_id = paramNode->GetAttribute("stock_id", "");
1735
1736 if ( !art_id.empty() )
1737 {
1738 art_id = wxART_MAKE_ART_ID_FROM_STR(art_id);
1739
1740 art_client = paramNode->GetAttribute("stock_client", "");
1741 if ( art_client.empty() )
1742 art_client = defaultArtClient;
1743 else
1744 art_client = wxART_MAKE_CLIENT_ID_FROM_STR(art_client);
1745
1746 return true;
1747 }
1748 }
1749
1750 return false;
1751 }
1752
1753 } // anonymous namespace
1754
1755 wxBitmap wxXmlResourceHandler::GetBitmap(const wxString& param,
1756 const wxArtClient& defaultArtClient,
1757 wxSize size)
1758 {
1759 // it used to be possible to pass an empty string here to indicate that the
1760 // bitmap name should be read from this node itself but this is not
1761 // supported any more because GetBitmap(m_node) can be used directly
1762 // instead
1763 wxASSERT_MSG( !param.empty(), "bitmap parameter name can't be empty" );
1764
1765 const wxXmlNode* const node = GetParamNode(param);
1766
1767 if ( !node )
1768 {
1769 // this is not an error as bitmap parameter could be optional
1770 return wxNullBitmap;
1771 }
1772
1773 return GetBitmap(node, defaultArtClient, size);
1774 }
1775
1776 wxBitmap wxXmlResourceHandler::GetBitmap(const wxXmlNode* node,
1777 const wxArtClient& defaultArtClient,
1778 wxSize size)
1779 {
1780 wxCHECK_MSG( node, wxNullBitmap, "bitmap node can't be NULL" );
1781
1782 /* If the bitmap is specified as stock item, query wxArtProvider for it: */
1783 wxString art_id, art_client;
1784 if ( GetStockArtAttrs(node, defaultArtClient,
1785 art_id, art_client) )
1786 {
1787 wxBitmap stockArt(wxArtProvider::GetBitmap(art_id, art_client, size));
1788 if ( stockArt.Ok() )
1789 return stockArt;
1790 }
1791
1792 /* ...or load the bitmap from file: */
1793 wxString name = GetParamValue(node);
1794 if (name.empty()) return wxNullBitmap;
1795 #if wxUSE_FILESYSTEM
1796 wxFSFile *fsfile = GetCurFileSystem().OpenFile(name, wxFS_READ | wxFS_SEEKABLE);
1797 if (fsfile == NULL)
1798 {
1799 ReportParamError
1800 (
1801 node->GetName(),
1802 wxString::Format("cannot open bitmap resource \"%s\"", name)
1803 );
1804 return wxNullBitmap;
1805 }
1806 wxImage img(*(fsfile->GetStream()));
1807 delete fsfile;
1808 #else
1809 wxImage img(name);
1810 #endif
1811
1812 if (!img.Ok())
1813 {
1814 ReportParamError
1815 (
1816 node->GetName(),
1817 wxString::Format("cannot create bitmap from \"%s\"", name)
1818 );
1819 return wxNullBitmap;
1820 }
1821 if (!(size == wxDefaultSize)) img.Rescale(size.x, size.y);
1822 return wxBitmap(img);
1823 }
1824
1825
1826 wxIcon wxXmlResourceHandler::GetIcon(const wxString& param,
1827 const wxArtClient& defaultArtClient,
1828 wxSize size)
1829 {
1830 // see comment in GetBitmap(wxString) overload
1831 wxASSERT_MSG( !param.empty(), "icon parameter name can't be empty" );
1832
1833 const wxXmlNode* const node = GetParamNode(param);
1834
1835 if ( !node )
1836 {
1837 // this is not an error as icon parameter could be optional
1838 return wxIcon();
1839 }
1840
1841 return GetIcon(node, defaultArtClient, size);
1842 }
1843
1844 wxIcon wxXmlResourceHandler::GetIcon(const wxXmlNode* node,
1845 const wxArtClient& defaultArtClient,
1846 wxSize size)
1847 {
1848 wxIcon icon;
1849 icon.CopyFromBitmap(GetBitmap(node, defaultArtClient, size));
1850 return icon;
1851 }
1852
1853
1854 wxIconBundle wxXmlResourceHandler::GetIconBundle(const wxString& param,
1855 const wxArtClient& defaultArtClient)
1856 {
1857 wxString art_id, art_client;
1858 if ( GetStockArtAttrs(GetParamNode(param), defaultArtClient,
1859 art_id, art_client) )
1860 {
1861 wxIconBundle stockArt(wxArtProvider::GetIconBundle(art_id, art_client));
1862 if ( stockArt.IsOk() )
1863 return stockArt;
1864 }
1865
1866 const wxString name = GetParamValue(param);
1867 if ( name.empty() )
1868 return wxNullIconBundle;
1869
1870 #if wxUSE_FILESYSTEM
1871 wxFSFile *fsfile = GetCurFileSystem().OpenFile(name, wxFS_READ | wxFS_SEEKABLE);
1872 if ( fsfile == NULL )
1873 {
1874 ReportParamError
1875 (
1876 param,
1877 wxString::Format("cannot open icon resource \"%s\"", name)
1878 );
1879 return wxNullIconBundle;
1880 }
1881
1882 wxIconBundle bundle(*(fsfile->GetStream()));
1883 delete fsfile;
1884 #else
1885 wxIconBundle bundle(name);
1886 #endif
1887
1888 if ( !bundle.IsOk() )
1889 {
1890 ReportParamError
1891 (
1892 param,
1893 wxString::Format("cannot create icon from \"%s\"", name)
1894 );
1895 return wxNullIconBundle;
1896 }
1897
1898 return bundle;
1899 }
1900
1901
1902 wxImageList *wxXmlResourceHandler::GetImageList(const wxString& param)
1903 {
1904 wxXmlNode * const imagelist_node = GetParamNode(param);
1905 if ( !imagelist_node )
1906 return NULL;
1907
1908 wxXmlNode * const oldnode = m_node;
1909 m_node = imagelist_node;
1910
1911 // Get the size if we have it, otherwise we will use the size of the first
1912 // list element.
1913 wxSize size = GetSize();
1914
1915 // Start adding images, we'll create the image list when adding the first
1916 // one.
1917 wxImageList * imagelist = NULL;
1918 wxString parambitmap = wxT("bitmap");
1919 if ( HasParam(parambitmap) )
1920 {
1921 wxXmlNode *n = m_node->GetChildren();
1922 while (n)
1923 {
1924 if (n->GetType() == wxXML_ELEMENT_NODE && n->GetName() == parambitmap)
1925 {
1926 wxIcon icon = GetIcon(n);
1927 if ( !imagelist )
1928 {
1929 // We need the real image list size to create it.
1930 if ( size == wxDefaultSize )
1931 size = icon.GetSize();
1932
1933 // We use the mask by default.
1934 bool mask = !HasParam(wxS("mask")) || GetBool(wxS("mask"));
1935
1936 imagelist = new wxImageList(size.x, size.y, mask);
1937 }
1938
1939 // add icon instead of bitmap to keep the bitmap mask
1940 imagelist->Add(icon);
1941 }
1942 n = n->GetNext();
1943 }
1944 }
1945
1946 m_node = oldnode;
1947 return imagelist;
1948 }
1949
1950 wxXmlNode *wxXmlResourceHandler::GetParamNode(const wxString& param)
1951 {
1952 wxCHECK_MSG(m_node, NULL, wxT("You can't access handler data before it was initialized!"));
1953
1954 wxXmlNode *n = m_node->GetChildren();
1955
1956 while (n)
1957 {
1958 if (n->GetType() == wxXML_ELEMENT_NODE && n->GetName() == param)
1959 {
1960 // TODO: check that there are no other properties/parameters with
1961 // the same name and log an error if there are (can't do this
1962 // right now as I'm not sure if it's not going to break code
1963 // using this function in unintentional way (i.e. for
1964 // accessing other things than properties), for example
1965 // wxBitmapComboBoxXmlHandler almost surely does
1966 return n;
1967 }
1968 n = n->GetNext();
1969 }
1970 return NULL;
1971 }
1972
1973 /* static */
1974 bool wxXmlResourceHandler::IsOfClass(wxXmlNode *node, const wxString& classname)
1975 {
1976 return node->GetAttribute(wxT("class")) == classname;
1977 }
1978
1979
1980
1981 wxString wxXmlResourceHandler::GetNodeContent(const wxXmlNode *node)
1982 {
1983 const wxXmlNode *n = node;
1984 if (n == NULL) return wxEmptyString;
1985 n = n->GetChildren();
1986
1987 while (n)
1988 {
1989 if (n->GetType() == wxXML_TEXT_NODE ||
1990 n->GetType() == wxXML_CDATA_SECTION_NODE)
1991 return n->GetContent();
1992 n = n->GetNext();
1993 }
1994 return wxEmptyString;
1995 }
1996
1997
1998
1999 wxString wxXmlResourceHandler::GetParamValue(const wxString& param)
2000 {
2001 if (param.empty())
2002 return GetNodeContent(m_node);
2003 else
2004 return GetNodeContent(GetParamNode(param));
2005 }
2006
2007 wxString wxXmlResourceHandler::GetParamValue(const wxXmlNode* node)
2008 {
2009 return GetNodeContent(node);
2010 }
2011
2012
2013 wxSize wxXmlResourceHandler::GetSize(const wxString& param,
2014 wxWindow *windowToUse)
2015 {
2016 wxString s = GetParamValue(param);
2017 if (s.empty()) s = wxT("-1,-1");
2018 bool is_dlg;
2019 long sx, sy = 0;
2020
2021 is_dlg = s[s.length()-1] == wxT('d');
2022 if (is_dlg) s.RemoveLast();
2023
2024 if (!s.BeforeFirst(wxT(',')).ToLong(&sx) ||
2025 !s.AfterLast(wxT(',')).ToLong(&sy))
2026 {
2027 ReportParamError
2028 (
2029 param,
2030 wxString::Format("cannot parse coordinates value \"%s\"", s)
2031 );
2032 return wxDefaultSize;
2033 }
2034
2035 if (is_dlg)
2036 {
2037 if (windowToUse)
2038 {
2039 return wxDLG_UNIT(windowToUse, wxSize(sx, sy));
2040 }
2041 else if (m_parentAsWindow)
2042 {
2043 return wxDLG_UNIT(m_parentAsWindow, wxSize(sx, sy));
2044 }
2045 else
2046 {
2047 ReportParamError
2048 (
2049 param,
2050 "cannot convert dialog units: dialog unknown"
2051 );
2052 return wxDefaultSize;
2053 }
2054 }
2055
2056 return wxSize(sx, sy);
2057 }
2058
2059
2060
2061 wxPoint wxXmlResourceHandler::GetPosition(const wxString& param)
2062 {
2063 wxSize sz = GetSize(param);
2064 return wxPoint(sz.x, sz.y);
2065 }
2066
2067
2068
2069 wxCoord wxXmlResourceHandler::GetDimension(const wxString& param,
2070 wxCoord defaultv,
2071 wxWindow *windowToUse)
2072 {
2073 wxString s = GetParamValue(param);
2074 if (s.empty()) return defaultv;
2075 bool is_dlg;
2076 long sx;
2077
2078 is_dlg = s[s.length()-1] == wxT('d');
2079 if (is_dlg) s.RemoveLast();
2080
2081 if (!s.ToLong(&sx))
2082 {
2083 ReportParamError
2084 (
2085 param,
2086 wxString::Format("cannot parse dimension value \"%s\"", s)
2087 );
2088 return defaultv;
2089 }
2090
2091 if (is_dlg)
2092 {
2093 if (windowToUse)
2094 {
2095 return wxDLG_UNIT(windowToUse, wxSize(sx, 0)).x;
2096 }
2097 else if (m_parentAsWindow)
2098 {
2099 return wxDLG_UNIT(m_parentAsWindow, wxSize(sx, 0)).x;
2100 }
2101 else
2102 {
2103 ReportParamError
2104 (
2105 param,
2106 "cannot convert dialog units: dialog unknown"
2107 );
2108 return defaultv;
2109 }
2110 }
2111
2112 return sx;
2113 }
2114
2115
2116 // Get system font index using indexname
2117 static wxFont GetSystemFont(const wxString& name)
2118 {
2119 if (!name.empty())
2120 {
2121 #define SYSFNT(fnt) \
2122 if (name == wxT(#fnt)) return wxSystemSettings::GetFont(fnt);
2123 SYSFNT(wxSYS_OEM_FIXED_FONT)
2124 SYSFNT(wxSYS_ANSI_FIXED_FONT)
2125 SYSFNT(wxSYS_ANSI_VAR_FONT)
2126 SYSFNT(wxSYS_SYSTEM_FONT)
2127 SYSFNT(wxSYS_DEVICE_DEFAULT_FONT)
2128 SYSFNT(wxSYS_SYSTEM_FIXED_FONT)
2129 SYSFNT(wxSYS_DEFAULT_GUI_FONT)
2130 #undef SYSFNT
2131 }
2132
2133 return wxNullFont;
2134 }
2135
2136 wxFont wxXmlResourceHandler::GetFont(const wxString& param)
2137 {
2138 wxXmlNode *font_node = GetParamNode(param);
2139 if (font_node == NULL)
2140 {
2141 ReportError(
2142 wxString::Format("cannot find font node \"%s\"", param));
2143 return wxNullFont;
2144 }
2145
2146 wxXmlNode *oldnode = m_node;
2147 m_node = font_node;
2148
2149 // font attributes:
2150
2151 // size
2152 int isize = -1;
2153 bool hasSize = HasParam(wxT("size"));
2154 if (hasSize)
2155 isize = GetLong(wxT("size"), -1);
2156
2157 // style
2158 int istyle = wxNORMAL;
2159 bool hasStyle = HasParam(wxT("style"));
2160 if (hasStyle)
2161 {
2162 wxString style = GetParamValue(wxT("style"));
2163 if (style == wxT("italic"))
2164 istyle = wxITALIC;
2165 else if (style == wxT("slant"))
2166 istyle = wxSLANT;
2167 }
2168
2169 // weight
2170 int iweight = wxNORMAL;
2171 bool hasWeight = HasParam(wxT("weight"));
2172 if (hasWeight)
2173 {
2174 wxString weight = GetParamValue(wxT("weight"));
2175 if (weight == wxT("bold"))
2176 iweight = wxBOLD;
2177 else if (weight == wxT("light"))
2178 iweight = wxLIGHT;
2179 }
2180
2181 // underline
2182 bool hasUnderlined = HasParam(wxT("underlined"));
2183 bool underlined = hasUnderlined ? GetBool(wxT("underlined"), false) : false;
2184
2185 // family and facename
2186 int ifamily = wxDEFAULT;
2187 bool hasFamily = HasParam(wxT("family"));
2188 if (hasFamily)
2189 {
2190 wxString family = GetParamValue(wxT("family"));
2191 if (family == wxT("decorative")) ifamily = wxDECORATIVE;
2192 else if (family == wxT("roman")) ifamily = wxROMAN;
2193 else if (family == wxT("script")) ifamily = wxSCRIPT;
2194 else if (family == wxT("swiss")) ifamily = wxSWISS;
2195 else if (family == wxT("modern")) ifamily = wxMODERN;
2196 else if (family == wxT("teletype")) ifamily = wxTELETYPE;
2197 }
2198
2199
2200 wxString facename;
2201 bool hasFacename = HasParam(wxT("face"));
2202 if (hasFacename)
2203 {
2204 wxString faces = GetParamValue(wxT("face"));
2205 wxStringTokenizer tk(faces, wxT(","));
2206 #if wxUSE_FONTENUM
2207 wxArrayString facenames(wxFontEnumerator::GetFacenames());
2208 while (tk.HasMoreTokens())
2209 {
2210 int index = facenames.Index(tk.GetNextToken(), false);
2211 if (index != wxNOT_FOUND)
2212 {
2213 facename = facenames[index];
2214 break;
2215 }
2216 }
2217 #else // !wxUSE_FONTENUM
2218 // just use the first face name if we can't check its availability:
2219 if (tk.HasMoreTokens())
2220 facename = tk.GetNextToken();
2221 #endif // wxUSE_FONTENUM/!wxUSE_FONTENUM
2222 }
2223
2224 // encoding
2225 wxFontEncoding enc = wxFONTENCODING_DEFAULT;
2226 bool hasEncoding = HasParam(wxT("encoding"));
2227 #if wxUSE_FONTMAP
2228 if (hasEncoding)
2229 {
2230 wxString encoding = GetParamValue(wxT("encoding"));
2231 wxFontMapper mapper;
2232 if (!encoding.empty())
2233 enc = mapper.CharsetToEncoding(encoding);
2234 if (enc == wxFONTENCODING_SYSTEM)
2235 enc = wxFONTENCODING_DEFAULT;
2236 }
2237 #endif // wxUSE_FONTMAP
2238
2239 // is this font based on a system font?
2240 wxFont font = GetSystemFont(GetParamValue(wxT("sysfont")));
2241
2242 if (font.Ok())
2243 {
2244 if (hasSize && isize != -1)
2245 font.SetPointSize(isize);
2246 else if (HasParam(wxT("relativesize")))
2247 font.SetPointSize(int(font.GetPointSize() *
2248 GetFloat(wxT("relativesize"))));
2249
2250 if (hasStyle)
2251 font.SetStyle(istyle);
2252 if (hasWeight)
2253 font.SetWeight(iweight);
2254 if (hasUnderlined)
2255 font.SetUnderlined(underlined);
2256 if (hasFamily)
2257 font.SetFamily(ifamily);
2258 if (hasFacename)
2259 font.SetFaceName(facename);
2260 if (hasEncoding)
2261 font.SetDefaultEncoding(enc);
2262 }
2263 else // not based on system font
2264 {
2265 font = wxFont(isize == -1 ? wxNORMAL_FONT->GetPointSize() : isize,
2266 ifamily, istyle, iweight,
2267 underlined, facename, enc);
2268 }
2269
2270 m_node = oldnode;
2271 return font;
2272 }
2273
2274
2275 void wxXmlResourceHandler::SetupWindow(wxWindow *wnd)
2276 {
2277 //FIXME : add cursor
2278
2279 if (HasParam(wxT("exstyle")))
2280 // Have to OR it with existing style, since
2281 // some implementations (e.g. wxGTK) use the extra style
2282 // during creation
2283 wnd->SetExtraStyle(wnd->GetExtraStyle() | GetStyle(wxT("exstyle")));
2284 if (HasParam(wxT("bg")))
2285 wnd->SetBackgroundColour(GetColour(wxT("bg")));
2286 if (HasParam(wxT("ownbg")))
2287 wnd->SetOwnBackgroundColour(GetColour(wxT("ownbg")));
2288 if (HasParam(wxT("fg")))
2289 wnd->SetForegroundColour(GetColour(wxT("fg")));
2290 if (HasParam(wxT("ownfg")))
2291 wnd->SetOwnForegroundColour(GetColour(wxT("ownfg")));
2292 if (GetBool(wxT("enabled"), 1) == 0)
2293 wnd->Enable(false);
2294 if (GetBool(wxT("focused"), 0) == 1)
2295 wnd->SetFocus();
2296 if (GetBool(wxT("hidden"), 0) == 1)
2297 wnd->Show(false);
2298 #if wxUSE_TOOLTIPS
2299 if (HasParam(wxT("tooltip")))
2300 wnd->SetToolTip(GetText(wxT("tooltip")));
2301 #endif
2302 if (HasParam(wxT("font")))
2303 wnd->SetFont(GetFont(wxT("font")));
2304 if (HasParam(wxT("ownfont")))
2305 wnd->SetOwnFont(GetFont(wxT("ownfont")));
2306 if (HasParam(wxT("help")))
2307 wnd->SetHelpText(GetText(wxT("help")));
2308 }
2309
2310
2311 void wxXmlResourceHandler::CreateChildren(wxObject *parent, bool this_hnd_only)
2312 {
2313 for ( wxXmlNode *n = m_node->GetChildren(); n; n = n->GetNext() )
2314 {
2315 if ( IsObjectNode(n) )
2316 {
2317 m_resource->DoCreateResFromNode(*n, parent, NULL,
2318 this_hnd_only ? this : NULL);
2319 }
2320 }
2321 }
2322
2323
2324 void wxXmlResourceHandler::CreateChildrenPrivately(wxObject *parent, wxXmlNode *rootnode)
2325 {
2326 wxXmlNode *root;
2327 if (rootnode == NULL) root = m_node; else root = rootnode;
2328 wxXmlNode *n = root->GetChildren();
2329
2330 while (n)
2331 {
2332 if (n->GetType() == wxXML_ELEMENT_NODE && CanHandle(n))
2333 {
2334 CreateResource(n, parent, NULL);
2335 }
2336 n = n->GetNext();
2337 }
2338 }
2339
2340
2341 //-----------------------------------------------------------------------------
2342 // errors reporting
2343 //-----------------------------------------------------------------------------
2344
2345 void wxXmlResourceHandler::ReportError(const wxString& message)
2346 {
2347 m_resource->ReportError(m_node, message);
2348 }
2349
2350 void wxXmlResourceHandler::ReportError(wxXmlNode *context,
2351 const wxString& message)
2352 {
2353 m_resource->ReportError(context ? context : m_node, message);
2354 }
2355
2356 void wxXmlResourceHandler::ReportParamError(const wxString& param,
2357 const wxString& message)
2358 {
2359 m_resource->ReportError(GetParamNode(param), message);
2360 }
2361
2362 void wxXmlResource::ReportError(const wxXmlNode *context, const wxString& message)
2363 {
2364 if ( !context )
2365 {
2366 DoReportError("", NULL, message);
2367 return;
2368 }
2369
2370 // We need to find out the file that 'context' is part of. Performance of
2371 // this code is not critical, so we simply find the root XML node and
2372 // compare it with all loaded XRC files.
2373 const wxString filename = GetFileNameFromNode(context, Data());
2374
2375 DoReportError(filename, context, message);
2376 }
2377
2378 void wxXmlResource::DoReportError(const wxString& xrcFile, const wxXmlNode *position,
2379 const wxString& message)
2380 {
2381 const int line = position ? position->GetLineNumber() : -1;
2382
2383 wxString loc;
2384 if ( !xrcFile.empty() )
2385 loc = xrcFile + ':';
2386 if ( line != -1 )
2387 loc += wxString::Format("%d:", line);
2388 if ( !loc.empty() )
2389 loc += ' ';
2390
2391 wxLogError("XRC error: %s%s", loc, message);
2392 }
2393
2394
2395 //-----------------------------------------------------------------------------
2396 // XRCID implementation
2397 //-----------------------------------------------------------------------------
2398
2399 #define XRCID_TABLE_SIZE 1024
2400
2401
2402 struct XRCID_record
2403 {
2404 /* Hold the id so that once an id is allocated for a name, it
2405 does not get created again by NewControlId at least
2406 until we are done with it */
2407 wxWindowIDRef id;
2408 char *key;
2409 XRCID_record *next;
2410 };
2411
2412 static XRCID_record *XRCID_Records[XRCID_TABLE_SIZE] = {NULL};
2413
2414 // Extremely simplistic hash function which probably ought to be replaced with
2415 // wxStringHash::stringHash().
2416 static inline unsigned XRCIdHash(const char *str_id)
2417 {
2418 unsigned index = 0;
2419
2420 for (const char *c = str_id; *c != '\0'; c++) index += (unsigned int)*c;
2421 index %= XRCID_TABLE_SIZE;
2422
2423 return index;
2424 }
2425
2426 static int XRCID_Lookup(const char *str_id, int value_if_not_found = wxID_NONE)
2427 {
2428 const unsigned index = XRCIdHash(str_id);
2429
2430
2431 XRCID_record *oldrec = NULL;
2432 for (XRCID_record *rec = XRCID_Records[index]; rec; rec = rec->next)
2433 {
2434 if (wxStrcmp(rec->key, str_id) == 0)
2435 {
2436 return rec->id;
2437 }
2438 oldrec = rec;
2439 }
2440
2441 XRCID_record **rec_var = (oldrec == NULL) ?
2442 &XRCID_Records[index] : &oldrec->next;
2443 *rec_var = new XRCID_record;
2444 (*rec_var)->key = wxStrdup(str_id);
2445 (*rec_var)->next = NULL;
2446
2447 char *end;
2448 if (value_if_not_found != wxID_NONE)
2449 (*rec_var)->id = value_if_not_found;
2450 else
2451 {
2452 int asint = wxStrtol(str_id, &end, 10);
2453 if (*str_id && *end == 0)
2454 {
2455 // if str_id was integer, keep it verbosely:
2456 (*rec_var)->id = asint;
2457 }
2458 else
2459 {
2460 (*rec_var)->id = wxWindowBase::NewControlId();
2461 }
2462 }
2463
2464 return (*rec_var)->id;
2465 }
2466
2467 namespace
2468 {
2469
2470 // flag indicating whether standard XRC ids were already initialized
2471 static bool gs_stdIDsAdded = false;
2472
2473 void AddStdXRCID_Records()
2474 {
2475 #define stdID(id) XRCID_Lookup(#id, id)
2476 stdID(-1);
2477
2478 stdID(wxID_ANY);
2479 stdID(wxID_SEPARATOR);
2480
2481 stdID(wxID_OPEN);
2482 stdID(wxID_CLOSE);
2483 stdID(wxID_NEW);
2484 stdID(wxID_SAVE);
2485 stdID(wxID_SAVEAS);
2486 stdID(wxID_REVERT);
2487 stdID(wxID_EXIT);
2488 stdID(wxID_UNDO);
2489 stdID(wxID_REDO);
2490 stdID(wxID_HELP);
2491 stdID(wxID_PRINT);
2492 stdID(wxID_PRINT_SETUP);
2493 stdID(wxID_PAGE_SETUP);
2494 stdID(wxID_PREVIEW);
2495 stdID(wxID_ABOUT);
2496 stdID(wxID_HELP_CONTENTS);
2497 stdID(wxID_HELP_COMMANDS);
2498 stdID(wxID_HELP_PROCEDURES);
2499 stdID(wxID_HELP_CONTEXT);
2500 stdID(wxID_CLOSE_ALL);
2501 stdID(wxID_PREFERENCES);
2502 stdID(wxID_EDIT);
2503 stdID(wxID_CUT);
2504 stdID(wxID_COPY);
2505 stdID(wxID_PASTE);
2506 stdID(wxID_CLEAR);
2507 stdID(wxID_FIND);
2508 stdID(wxID_DUPLICATE);
2509 stdID(wxID_SELECTALL);
2510 stdID(wxID_DELETE);
2511 stdID(wxID_REPLACE);
2512 stdID(wxID_REPLACE_ALL);
2513 stdID(wxID_PROPERTIES);
2514 stdID(wxID_VIEW_DETAILS);
2515 stdID(wxID_VIEW_LARGEICONS);
2516 stdID(wxID_VIEW_SMALLICONS);
2517 stdID(wxID_VIEW_LIST);
2518 stdID(wxID_VIEW_SORTDATE);
2519 stdID(wxID_VIEW_SORTNAME);
2520 stdID(wxID_VIEW_SORTSIZE);
2521 stdID(wxID_VIEW_SORTTYPE);
2522 stdID(wxID_FILE1);
2523 stdID(wxID_FILE2);
2524 stdID(wxID_FILE3);
2525 stdID(wxID_FILE4);
2526 stdID(wxID_FILE5);
2527 stdID(wxID_FILE6);
2528 stdID(wxID_FILE7);
2529 stdID(wxID_FILE8);
2530 stdID(wxID_FILE9);
2531 stdID(wxID_OK);
2532 stdID(wxID_CANCEL);
2533 stdID(wxID_APPLY);
2534 stdID(wxID_YES);
2535 stdID(wxID_NO);
2536 stdID(wxID_STATIC);
2537 stdID(wxID_FORWARD);
2538 stdID(wxID_BACKWARD);
2539 stdID(wxID_DEFAULT);
2540 stdID(wxID_MORE);
2541 stdID(wxID_SETUP);
2542 stdID(wxID_RESET);
2543 stdID(wxID_CONTEXT_HELP);
2544 stdID(wxID_YESTOALL);
2545 stdID(wxID_NOTOALL);
2546 stdID(wxID_ABORT);
2547 stdID(wxID_RETRY);
2548 stdID(wxID_IGNORE);
2549 stdID(wxID_ADD);
2550 stdID(wxID_REMOVE);
2551 stdID(wxID_UP);
2552 stdID(wxID_DOWN);
2553 stdID(wxID_HOME);
2554 stdID(wxID_REFRESH);
2555 stdID(wxID_STOP);
2556 stdID(wxID_INDEX);
2557 stdID(wxID_BOLD);
2558 stdID(wxID_ITALIC);
2559 stdID(wxID_JUSTIFY_CENTER);
2560 stdID(wxID_JUSTIFY_FILL);
2561 stdID(wxID_JUSTIFY_RIGHT);
2562 stdID(wxID_JUSTIFY_LEFT);
2563 stdID(wxID_UNDERLINE);
2564 stdID(wxID_INDENT);
2565 stdID(wxID_UNINDENT);
2566 stdID(wxID_ZOOM_100);
2567 stdID(wxID_ZOOM_FIT);
2568 stdID(wxID_ZOOM_IN);
2569 stdID(wxID_ZOOM_OUT);
2570 stdID(wxID_UNDELETE);
2571 stdID(wxID_REVERT_TO_SAVED);
2572 stdID(wxID_SYSTEM_MENU);
2573 stdID(wxID_CLOSE_FRAME);
2574 stdID(wxID_MOVE_FRAME);
2575 stdID(wxID_RESIZE_FRAME);
2576 stdID(wxID_MAXIMIZE_FRAME);
2577 stdID(wxID_ICONIZE_FRAME);
2578 stdID(wxID_RESTORE_FRAME);
2579 stdID(wxID_CDROM);
2580 stdID(wxID_CONVERT);
2581 stdID(wxID_EXECUTE);
2582 stdID(wxID_FLOPPY);
2583 stdID(wxID_HARDDISK);
2584 stdID(wxID_BOTTOM);
2585 stdID(wxID_FIRST);
2586 stdID(wxID_LAST);
2587 stdID(wxID_TOP);
2588 stdID(wxID_INFO);
2589 stdID(wxID_JUMP_TO);
2590 stdID(wxID_NETWORK);
2591 stdID(wxID_SELECT_COLOR);
2592 stdID(wxID_SELECT_FONT);
2593 stdID(wxID_SORT_ASCENDING);
2594 stdID(wxID_SORT_DESCENDING);
2595 stdID(wxID_SPELL_CHECK);
2596 stdID(wxID_STRIKETHROUGH);
2597
2598 #undef stdID
2599 }
2600
2601 } // anonymous namespace
2602
2603
2604 /*static*/
2605 int wxXmlResource::DoGetXRCID(const char *str_id, int value_if_not_found)
2606 {
2607 if ( !gs_stdIDsAdded )
2608 {
2609 gs_stdIDsAdded = true;
2610 AddStdXRCID_Records();
2611 }
2612
2613 return XRCID_Lookup(str_id, value_if_not_found);
2614 }
2615
2616 /* static */
2617 wxString wxXmlResource::FindXRCIDById(int numId)
2618 {
2619 for ( int i = 0; i < XRCID_TABLE_SIZE; i++ )
2620 {
2621 for ( XRCID_record *rec = XRCID_Records[i]; rec; rec = rec->next )
2622 {
2623 if ( rec->id == numId )
2624 return wxString(rec->key);
2625 }
2626 }
2627
2628 return wxString();
2629 }
2630
2631 /* static */
2632 void wxIdRangeManager::RemoveXRCIDEntry(const wxString& idstr)
2633 {
2634 const char *str_id = idstr.mb_str();
2635
2636 const unsigned index = XRCIdHash(str_id);
2637
2638 XRCID_record **p_previousrec = &XRCID_Records[index];
2639 for (XRCID_record *rec = XRCID_Records[index]; rec; rec = rec->next)
2640 {
2641 if (wxStrcmp(rec->key, str_id) == 0)
2642 {
2643 // Found the item to be removed so delete its record; but first
2644 // remove it from the linked list.
2645 *p_previousrec = rec->next;
2646 free(rec->key);
2647 delete rec;
2648 return;
2649 }
2650
2651 p_previousrec = &rec->next;
2652 }
2653 }
2654
2655 static void CleanXRCID_Record(XRCID_record *rec)
2656 {
2657 if (rec)
2658 {
2659 CleanXRCID_Record(rec->next);
2660
2661 free(rec->key);
2662 delete rec;
2663 }
2664 }
2665
2666 static void CleanXRCID_Records()
2667 {
2668 for (int i = 0; i < XRCID_TABLE_SIZE; i++)
2669 {
2670 CleanXRCID_Record(XRCID_Records[i]);
2671 XRCID_Records[i] = NULL;
2672 }
2673
2674 gs_stdIDsAdded = false;
2675 }
2676
2677
2678 //-----------------------------------------------------------------------------
2679 // module and globals
2680 //-----------------------------------------------------------------------------
2681
2682 // normally we would do the cleanup from wxXmlResourceModule::OnExit() but it
2683 // can happen that some XRC records have been created because of the use of
2684 // XRCID() in event tables, which happens during static objects initialization,
2685 // but then the application initialization failed and so the wx modules were
2686 // neither initialized nor cleaned up -- this static object does the cleanup in
2687 // this case
2688 static struct wxXRCStaticCleanup
2689 {
2690 ~wxXRCStaticCleanup() { CleanXRCID_Records(); }
2691 } s_staticCleanup;
2692
2693 class wxXmlResourceModule: public wxModule
2694 {
2695 DECLARE_DYNAMIC_CLASS(wxXmlResourceModule)
2696 public:
2697 wxXmlResourceModule() {}
2698 bool OnInit()
2699 {
2700 wxXmlResource::AddSubclassFactory(new wxXmlSubclassFactoryCXX);
2701 return true;
2702 }
2703 void OnExit()
2704 {
2705 delete wxXmlResource::Set(NULL);
2706 delete wxIdRangeManager::Set(NULL);
2707 if(wxXmlResource::ms_subclassFactories)
2708 {
2709 for ( wxXmlSubclassFactories::iterator i = wxXmlResource::ms_subclassFactories->begin();
2710 i != wxXmlResource::ms_subclassFactories->end(); ++i )
2711 {
2712 delete *i;
2713 }
2714 wxDELETE(wxXmlResource::ms_subclassFactories);
2715 }
2716 CleanXRCID_Records();
2717 }
2718 };
2719
2720 IMPLEMENT_DYNAMIC_CLASS(wxXmlResourceModule, wxModule)
2721
2722
2723 // When wxXml is loaded dynamically after the application is already running
2724 // then the built-in module system won't pick this one up. Add it manually.
2725 void wxXmlInitResourceModule()
2726 {
2727 wxModule* module = new wxXmlResourceModule;
2728 module->Init();
2729 wxModule::RegisterModule(module);
2730 }
2731
2732 #endif // wxUSE_XRC
wxWidgets (Impactor)