]> git.saurik.com Git - wxWidgets.git/blob - src/xrc/xmlres.cpp
projects / wxWidgets.git / blob
? search:


090d7da5f2c8cbbf54b7af9f3a2e839cd68e3c2f
[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/dir.h"
48 #include "wx/xml/xml.h"
49
50
51 class wxXmlResourceDataRecord
52 {
53 public:
54 wxXmlResourceDataRecord() : Doc(NULL) {
55 #if wxUSE_DATETIME
56 Time = wxDateTime::Now();
57 #endif
58 }
59 ~wxXmlResourceDataRecord() {delete Doc;}
60
61 wxString File;
62 wxXmlDocument *Doc;
63 #if wxUSE_DATETIME
64 wxDateTime Time;
65 #endif
66 };
67
68 class wxXmlResourceDataRecords : public wxVector<wxXmlResourceDataRecord*>
69 {
70 // this is a class so that it can be forward-declared
71 };
72
73 namespace
74 {
75
76 // helper used by DoFindResource() and elsewhere: returns true if this is an
77 // object or object_ref node
78 //
79 // node must be non-NULL
80 inline bool IsObjectNode(wxXmlNode *node)
81 {
82 return node->GetType() == wxXML_ELEMENT_NODE &&
83 (node->GetName() == wxS("object") ||
84 node->GetName() == wxS("object_ref"));
85 }
86
87 // special XML attribute with name of input file, see GetFileNameFromNode()
88 const char *ATTR_INPUT_FILENAME = "__wx:filename";
89
90 // helper to get filename corresponding to an XML node
91 wxString
92 GetFileNameFromNode(wxXmlNode *node, const wxXmlResourceDataRecords& files)
93 {
94 // this loop does two things: it looks for ATTR_INPUT_FILENAME among
95 // parents and if it isn't used, it finds the root of the XML tree 'node'
96 // is in
97 for ( ;; )
98 {
99 // in some rare cases (specifically, when an <object_ref> is used, see
100 // wxXmlResource::CreateResFromNode() and MergeNodesOver()), we work
101 // with XML nodes that are not rooted in any document from 'files'
102 // (because a new node was created by CreateResFromNode() to merge the
103 // content of <object_ref> and the referenced <object>); in that case,
104 // we hack around the problem by putting the information about input
105 // file into a custom attribute
106 if ( node->HasAttribute(ATTR_INPUT_FILENAME) )
107 return node->GetAttribute(ATTR_INPUT_FILENAME);
108
109 if ( !node->GetParent() )
110 break; // we found the root of this XML tree
111
112 node = node->GetParent();
113 }
114
115 // NB: 'node' now points to the root of XML document
116
117 for ( wxXmlResourceDataRecords::const_iterator i = files.begin();
118 i != files.end(); ++i )
119 {
120 if ( (*i)->Doc->GetRoot() == node )
121 {
122 return (*i)->File;
123 }
124 }
125
126 return wxEmptyString; // not found
127 }
128
129 } // anonymous namespace
130
131
132 wxXmlResource *wxXmlResource::ms_instance = NULL;
133
134 /*static*/ wxXmlResource *wxXmlResource::Get()
135 {
136 if ( !ms_instance )
137 ms_instance = new wxXmlResource;
138 return ms_instance;
139 }
140
141 /*static*/ wxXmlResource *wxXmlResource::Set(wxXmlResource *res)
142 {
143 wxXmlResource *old = ms_instance;
144 ms_instance = res;
145 return old;
146 }
147
148 wxXmlResource::wxXmlResource(int flags, const wxString& domain)
149 {
150 m_flags = flags;
151 m_version = -1;
152 m_data = new wxXmlResourceDataRecords;
153 SetDomain(domain);
154 }
155
156 wxXmlResource::wxXmlResource(const wxString& filemask, int flags, const wxString& domain)
157 {
158 m_flags = flags;
159 m_version = -1;
160 m_data = new wxXmlResourceDataRecords;
161 SetDomain(domain);
162 Load(filemask);
163 }
164
165 wxXmlResource::~wxXmlResource()
166 {
167 ClearHandlers();
168
169 for ( wxXmlResourceDataRecords::iterator i = m_data->begin();
170 i != m_data->end(); ++i )
171 {
172 delete *i;
173 }
174 delete m_data;
175 }
176
177 void wxXmlResource::SetDomain(const wxString& domain)
178 {
179 m_domain = domain;
180 }
181
182
183 /* static */
184 wxString wxXmlResource::ConvertFileNameToURL(const wxString& filename)
185 {
186 wxString fnd(filename);
187
188 // NB: as Load() and Unload() accept both filenames and URLs (should
189 // probably be changed to filenames only, but embedded resources
190 // currently rely on its ability to handle URLs - FIXME) we need to
191 // determine whether found name is filename and not URL and this is the
192 // fastest/simplest way to do it
193 if (wxFileName::FileExists(fnd))
194 {
195 // Make the name absolute filename, because the app may
196 // change working directory later:
197 wxFileName fn(fnd);
198 if (fn.IsRelative())
199 {
200 fn.MakeAbsolute();
201 fnd = fn.GetFullPath();
202 }
203 #if wxUSE_FILESYSTEM
204 fnd = wxFileSystem::FileNameToURL(fnd);
205 #endif
206 }
207
208 return fnd;
209 }
210
211 #if wxUSE_FILESYSTEM
212
213 /* static */
214 bool wxXmlResource::IsArchive(const wxString& filename)
215 {
216 const wxString fnd = filename.Lower();
217
218 return fnd.Matches(wxT("*.zip")) || fnd.Matches(wxT("*.xrs"));
219 }
220
221 #endif // wxUSE_FILESYSTEM
222
223 bool wxXmlResource::LoadFile(const wxFileName& file)
224 {
225 #if wxUSE_FILESYSTEM
226 return Load(wxFileSystem::FileNameToURL(file));
227 #else
228 return Load(file.GetFullPath());
229 #endif
230 }
231
232 bool wxXmlResource::LoadAllFiles(const wxString& dirname)
233 {
234 bool ok = true;
235 wxArrayString files;
236
237 wxDir::GetAllFiles(dirname, &files, "*.xrc");
238
239 for ( wxArrayString::const_iterator i = files.begin(); i != files.end(); ++i )
240 {
241 if ( !LoadFile(*i) )
242 ok = false;
243 }
244
245 return ok;
246 }
247
248 bool wxXmlResource::Load(const wxString& filemask_)
249 {
250 wxString filemask = ConvertFileNameToURL(filemask_);
251
252 #if wxUSE_FILESYSTEM
253 wxFileSystem fsys;
254 # define wxXmlFindFirst fsys.FindFirst(filemask, wxFILE)
255 # define wxXmlFindNext fsys.FindNext()
256 #else
257 # define wxXmlFindFirst wxFindFirstFile(filemask, wxFILE)
258 # define wxXmlFindNext wxFindNextFile()
259 #endif
260 wxString fnd = wxXmlFindFirst;
261 if ( fnd.empty() )
262 {
263 wxLogError(_("Cannot load resources from '%s'."), filemask);
264 return false;
265 }
266
267 while (!fnd.empty())
268 {
269 #if wxUSE_FILESYSTEM
270 if ( IsArchive(fnd) )
271 {
272 if ( !Load(fnd + wxT("#zip:*.xrc")) )
273 return false;
274 }
275 else // a single resource URL
276 #endif // wxUSE_FILESYSTEM
277 {
278 wxXmlResourceDataRecord *drec = new wxXmlResourceDataRecord;
279 drec->File = fnd;
280 Data().push_back(drec);
281 }
282
283 fnd = wxXmlFindNext;
284 }
285 # undef wxXmlFindFirst
286 # undef wxXmlFindNext
287
288 return UpdateResources();
289 }
290
291 bool wxXmlResource::Unload(const wxString& filename)
292 {
293 wxASSERT_MSG( !wxIsWild(filename),
294 _T("wildcards not supported by wxXmlResource::Unload()") );
295
296 wxString fnd = ConvertFileNameToURL(filename);
297 #if wxUSE_FILESYSTEM
298 const bool isArchive = IsArchive(fnd);
299 if ( isArchive )
300 fnd += _T("#zip:");
301 #endif // wxUSE_FILESYSTEM
302
303 bool unloaded = false;
304 for ( wxXmlResourceDataRecords::iterator i = Data().begin();
305 i != Data().end(); ++i )
306 {
307 #if wxUSE_FILESYSTEM
308 if ( isArchive )
309 {
310 if ( (*i)->File.StartsWith(fnd) )
311 unloaded = true;
312 // don't break from the loop, we can have other matching files
313 }
314 else // a single resource URL
315 #endif // wxUSE_FILESYSTEM
316 {
317 if ( (*i)->File == fnd )
318 {
319 delete *i;
320 Data().erase(i);
321 unloaded = true;
322
323 // no sense in continuing, there is only one file with this URL
324 break;
325 }
326 }
327 }
328
329 return unloaded;
330 }
331
332
333 IMPLEMENT_ABSTRACT_CLASS(wxXmlResourceHandler, wxObject)
334
335 void wxXmlResource::AddHandler(wxXmlResourceHandler *handler)
336 {
337 m_handlers.push_back(handler);
338 handler->SetParentResource(this);
339 }
340
341 void wxXmlResource::InsertHandler(wxXmlResourceHandler *handler)
342 {
343 m_handlers.insert(m_handlers.begin(), handler);
344 handler->SetParentResource(this);
345 }
346
347
348
349 void wxXmlResource::ClearHandlers()
350 {
351 for ( wxVector<wxXmlResourceHandler*>::iterator i = m_handlers.begin();
352 i != m_handlers.end(); ++i )
353 delete *i;
354 m_handlers.clear();
355 }
356
357
358 wxMenu *wxXmlResource::LoadMenu(const wxString& name)
359 {
360 return (wxMenu*)CreateResFromNode(FindResource(name, wxT("wxMenu")), NULL, NULL);
361 }
362
363
364
365 wxMenuBar *wxXmlResource::LoadMenuBar(wxWindow *parent, const wxString& name)
366 {
367 return (wxMenuBar*)CreateResFromNode(FindResource(name, wxT("wxMenuBar")), parent, NULL);
368 }
369
370
371
372 #if wxUSE_TOOLBAR
373 wxToolBar *wxXmlResource::LoadToolBar(wxWindow *parent, const wxString& name)
374 {
375 return (wxToolBar*)CreateResFromNode(FindResource(name, wxT("wxToolBar")), parent, NULL);
376 }
377 #endif
378
379
380 wxDialog *wxXmlResource::LoadDialog(wxWindow *parent, const wxString& name)
381 {
382 return (wxDialog*)CreateResFromNode(FindResource(name, wxT("wxDialog")), parent, NULL);
383 }
384
385 bool wxXmlResource::LoadDialog(wxDialog *dlg, wxWindow *parent, const wxString& name)
386 {
387 return CreateResFromNode(FindResource(name, wxT("wxDialog")), parent, dlg) != NULL;
388 }
389
390
391
392 wxPanel *wxXmlResource::LoadPanel(wxWindow *parent, const wxString& name)
393 {
394 return (wxPanel*)CreateResFromNode(FindResource(name, wxT("wxPanel")), parent, NULL);
395 }
396
397 bool wxXmlResource::LoadPanel(wxPanel *panel, wxWindow *parent, const wxString& name)
398 {
399 return CreateResFromNode(FindResource(name, wxT("wxPanel")), parent, panel) != NULL;
400 }
401
402 wxFrame *wxXmlResource::LoadFrame(wxWindow* parent, const wxString& name)
403 {
404 return (wxFrame*)CreateResFromNode(FindResource(name, wxT("wxFrame")), parent, NULL);
405 }
406
407 bool wxXmlResource::LoadFrame(wxFrame* frame, wxWindow *parent, const wxString& name)
408 {
409 return CreateResFromNode(FindResource(name, wxT("wxFrame")), parent, frame) != NULL;
410 }
411
412 wxBitmap wxXmlResource::LoadBitmap(const wxString& name)
413 {
414 wxBitmap *bmp = (wxBitmap*)CreateResFromNode(
415 FindResource(name, wxT("wxBitmap")), NULL, NULL);
416 wxBitmap rt;
417
418 if (bmp) { rt = *bmp; delete bmp; }
419 return rt;
420 }
421
422 wxIcon wxXmlResource::LoadIcon(const wxString& name)
423 {
424 wxIcon *icon = (wxIcon*)CreateResFromNode(
425 FindResource(name, wxT("wxIcon")), NULL, NULL);
426 wxIcon rt;
427
428 if (icon) { rt = *icon; delete icon; }
429 return rt;
430 }
431
432
433 wxObject *wxXmlResource::LoadObject(wxWindow *parent, const wxString& name, const wxString& classname)
434 {
435 return CreateResFromNode(FindResource(name, classname), parent, NULL);
436 }
437
438 bool wxXmlResource::LoadObject(wxObject *instance, wxWindow *parent, const wxString& name, const wxString& classname)
439 {
440 return CreateResFromNode(FindResource(name, classname), parent, instance) != NULL;
441 }
442
443
444 bool wxXmlResource::AttachUnknownControl(const wxString& name,
445 wxWindow *control, wxWindow *parent)
446 {
447 if (parent == NULL)
448 parent = control->GetParent();
449 wxWindow *container = parent->FindWindow(name + wxT("_container"));
450 if (!container)
451 {
452 wxLogError("Cannot find container for unknown control '%s'.", name);
453 return false;
454 }
455 return control->Reparent(container);
456 }
457
458
459 static void ProcessPlatformProperty(wxXmlNode *node)
460 {
461 wxString s;
462 bool isok;
463
464 wxXmlNode *c = node->GetChildren();
465 while (c)
466 {
467 isok = false;
468 if (!c->GetAttribute(wxT("platform"), &s))
469 isok = true;
470 else
471 {
472 wxStringTokenizer tkn(s, wxT(" |"));
473
474 while (tkn.HasMoreTokens())
475 {
476 s = tkn.GetNextToken();
477 #ifdef __WINDOWS__
478 if (s == wxT("win")) isok = true;
479 #endif
480 #if defined(__MAC__) || defined(__APPLE__)
481 if (s == wxT("mac")) isok = true;
482 #elif defined(__UNIX__)
483 if (s == wxT("unix")) isok = true;
484 #endif
485 #ifdef __OS2__
486 if (s == wxT("os2")) isok = true;
487 #endif
488
489 if (isok)
490 break;
491 }
492 }
493
494 if (isok)
495 {
496 ProcessPlatformProperty(c);
497 c = c->GetNext();
498 }
499 else
500 {
501 wxXmlNode *c2 = c->GetNext();
502 node->RemoveChild(c);
503 delete c;
504 c = c2;
505 }
506 }
507 }
508
509
510
511 bool wxXmlResource::UpdateResources()
512 {
513 bool rt = true;
514 bool modif;
515 # if wxUSE_FILESYSTEM
516 wxFSFile *file = NULL;
517 wxUnusedVar(file);
518 wxFileSystem fsys;
519 # endif
520
521 wxString encoding(wxT("UTF-8"));
522 #if !wxUSE_UNICODE && wxUSE_INTL
523 if ( (GetFlags() & wxXRC_USE_LOCALE) == 0 )
524 {
525 // In case we are not using wxLocale to translate strings, convert the
526 // strings GUI's charset. This must not be done when wxXRC_USE_LOCALE
527 // is on, because it could break wxGetTranslation lookup.
528 encoding = wxLocale::GetSystemEncodingName();
529 }
530 #endif
531
532 for ( wxXmlResourceDataRecords::iterator i = Data().begin();
533 i != Data().end(); ++i )
534 {
535 wxXmlResourceDataRecord* const rec = *i;
536
537 modif = (rec->Doc == NULL);
538
539 if (!modif && !(m_flags & wxXRC_NO_RELOADING))
540 {
541 # if wxUSE_FILESYSTEM
542 file = fsys.OpenFile(rec->File);
543 # if wxUSE_DATETIME
544 modif = file && file->GetModificationTime() > rec->Time;
545 # else // wxUSE_DATETIME
546 modif = true;
547 # endif // wxUSE_DATETIME
548 if (!file)
549 {
550 wxLogError(_("Cannot open file '%s'."), rec->File);
551 rt = false;
552 }
553 wxDELETE(file);
554 wxUnusedVar(file);
555 # else // wxUSE_FILESYSTEM
556 # if wxUSE_DATETIME
557 modif = wxDateTime(wxFileModificationTime(rec->File)) > rec->Time;
558 # else // wxUSE_DATETIME
559 modif = true;
560 # endif // wxUSE_DATETIME
561 # endif // wxUSE_FILESYSTEM
562 }
563
564 if (modif)
565 {
566 wxLogTrace(_T("xrc"), _T("opening file '%s'"), rec->File);
567
568 wxInputStream *stream = NULL;
569
570 # if wxUSE_FILESYSTEM
571 file = fsys.OpenFile(rec->File);
572 if (file)
573 stream = file->GetStream();
574 # else
575 stream = new wxFileInputStream(rec->File);
576 # endif
577
578 if (stream)
579 {
580 delete rec->Doc;
581 rec->Doc = new wxXmlDocument;
582 }
583 if (!stream || !stream->IsOk() || !rec->Doc->Load(*stream, encoding))
584 {
585 wxLogError(_("Cannot load resources from file '%s'."),
586 rec->File);
587 wxDELETE(rec->Doc);
588 rt = false;
589 }
590 else if (rec->Doc->GetRoot()->GetName() != wxT("resource"))
591 {
592 ReportError
593 (
594 rec->Doc->GetRoot(),
595 "invalid XRC resource, doesn't have root node <resource>"
596 );
597 wxDELETE(rec->Doc);
598 rt = false;
599 }
600 else
601 {
602 long version;
603 int v1, v2, v3, v4;
604 wxString verstr = rec->Doc->GetRoot()->GetAttribute(
605 wxT("version"), wxT("0.0.0.0"));
606 if (wxSscanf(verstr.c_str(), wxT("%i.%i.%i.%i"),
607 &v1, &v2, &v3, &v4) == 4)
608 version = v1*256*256*256+v2*256*256+v3*256+v4;
609 else
610 version = 0;
611 if (m_version == -1)
612 m_version = version;
613 if (m_version != version)
614 {
615 wxLogError("Resource files must have same version number.");
616 rt = false;
617 }
618
619 ProcessPlatformProperty(rec->Doc->GetRoot());
620 #if wxUSE_DATETIME
621 #if wxUSE_FILESYSTEM
622 rec->Time = file->GetModificationTime();
623 #else // wxUSE_FILESYSTEM
624 rec->Time = wxDateTime(wxFileModificationTime(rec->File));
625 #endif // wxUSE_FILESYSTEM
626 #endif // wxUSE_DATETIME
627 }
628
629 # if wxUSE_FILESYSTEM
630 wxDELETE(file);
631 wxUnusedVar(file);
632 # else
633 wxDELETE(stream);
634 # endif
635 }
636 }
637
638 return rt;
639 }
640
641 wxXmlNode *wxXmlResource::DoFindResource(wxXmlNode *parent,
642 const wxString& name,
643 const wxString& classname,
644 bool recursive) const
645 {
646 wxXmlNode *node;
647
648 // first search for match at the top-level nodes (as this is
649 // where the resource is most commonly looked for):
650 for (node = parent->GetChildren(); node; node = node->GetNext())
651 {
652 if ( IsObjectNode(node) && node->GetAttribute(wxS("name")) == name )
653 {
654 // empty class name matches everything
655 if ( classname.empty() )
656 return node;
657
658 wxString cls(node->GetAttribute(wxS("class")));
659
660 // object_ref may not have 'class' attribute:
661 if (cls.empty() && node->GetName() == wxS("object_ref"))
662 {
663 wxString refName = node->GetAttribute(wxS("ref"));
664 if (refName.empty())
665 continue;
666
667 const wxXmlNode * const refNode = GetResourceNode(refName);
668 if ( refNode )
669 cls = refNode->GetAttribute(wxS("class"));
670 }
671
672 if ( cls == classname )
673 return node;
674 }
675 }
676
677 // then recurse in child nodes
678 if ( recursive )
679 {
680 for (node = parent->GetChildren(); node; node = node->GetNext())
681 {
682 if ( IsObjectNode(node) )
683 {
684 wxXmlNode* found = DoFindResource(node, name, classname, true);
685 if ( found )
686 return found;
687 }
688 }
689 }
690
691 return NULL;
692 }
693
694 wxXmlNode *wxXmlResource::FindResource(const wxString& name,
695 const wxString& classname,
696 bool recursive)
697 {
698 wxString path;
699 wxXmlNode * const
700 node = GetResourceNodeAndLocation(name, classname, recursive, &path);
701
702 if ( !node )
703 {
704 ReportError
705 (
706 NULL,
707 wxString::Format
708 (
709 "XRC resource \"%s\" (class \"%s\") not found",
710 name, classname
711 )
712 );
713 }
714 #if wxUSE_FILESYSTEM
715 else // node was found
716 {
717 // ensure that relative paths work correctly when loading this node
718 // (which should happen as soon as we return as FindResource() result
719 // is always passed to CreateResFromNode())
720 m_curFileSystem.ChangePathTo(path);
721 }
722 #endif // wxUSE_FILESYSTEM
723
724 return node;
725 }
726
727 wxXmlNode *
728 wxXmlResource::GetResourceNodeAndLocation(const wxString& name,
729 const wxString& classname,
730 bool recursive,
731 wxString *path) const
732 {
733 // ensure everything is up-to-date: this is needed to support on-remand
734 // reloading of XRC files
735 const_cast<wxXmlResource *>(this)->UpdateResources();
736
737 for ( wxXmlResourceDataRecords::const_iterator f = Data().begin();
738 f != Data().end(); ++f )
739 {
740 wxXmlResourceDataRecord *const rec = *f;
741 wxXmlDocument * const doc = rec->Doc;
742 if ( !doc || !doc->GetRoot() )
743 continue;
744
745 wxXmlNode * const
746 found = DoFindResource(doc->GetRoot(), name, classname, recursive);
747 if ( found )
748 {
749 if ( path )
750 *path = rec->File;
751
752 return found;
753 }
754 }
755
756 return NULL;
757 }
758
759 static void MergeNodesOver(wxXmlNode& dest, wxXmlNode& overwriteWith,
760 const wxString& overwriteFilename)
761 {
762 // Merge attributes:
763 for ( wxXmlAttribute *attr = overwriteWith.GetAttributes();
764 attr; attr = attr->GetNext() )
765 {
766 wxXmlAttribute *dattr;
767 for (dattr = dest.GetAttributes(); dattr; dattr = dattr->GetNext())
768 {
769
770 if ( dattr->GetName() == attr->GetName() )
771 {
772 dattr->SetValue(attr->GetValue());
773 break;
774 }
775 }
776
777 if ( !dattr )
778 dest.AddAttribute(attr->GetName(), attr->GetValue());
779 }
780
781 // Merge child nodes:
782 for (wxXmlNode* node = overwriteWith.GetChildren(); node; node = node->GetNext())
783 {
784 wxString name = node->GetAttribute(wxT("name"), wxEmptyString);
785 wxXmlNode *dnode;
786
787 for (dnode = dest.GetChildren(); dnode; dnode = dnode->GetNext() )
788 {
789 if ( dnode->GetName() == node->GetName() &&
790 dnode->GetAttribute(wxT("name"), wxEmptyString) == name &&
791 dnode->GetType() == node->GetType() )
792 {
793 MergeNodesOver(*dnode, *node, overwriteFilename);
794 break;
795 }
796 }
797
798 if ( !dnode )
799 {
800 wxXmlNode *copyOfNode = new wxXmlNode(*node);
801 // remember referenced object's file, see GetFileNameFromNode()
802 copyOfNode->AddAttribute(ATTR_INPUT_FILENAME, overwriteFilename);
803
804 static const wxChar *AT_END = wxT("end");
805 wxString insert_pos = node->GetAttribute(wxT("insert_at"), AT_END);
806 if ( insert_pos == AT_END )
807 {
808 dest.AddChild(copyOfNode);
809 }
810 else if ( insert_pos == wxT("begin") )
811 {
812 dest.InsertChild(copyOfNode, dest.GetChildren());
813 }
814 }
815 }
816
817 if ( dest.GetType() == wxXML_TEXT_NODE && overwriteWith.GetContent().length() )
818 dest.SetContent(overwriteWith.GetContent());
819 }
820
821 wxObject *wxXmlResource::CreateResFromNode(wxXmlNode *node, wxObject *parent,
822 wxObject *instance,
823 wxXmlResourceHandler *handlerToUse)
824 {
825 if (node == NULL) return NULL;
826
827 // handling of referenced resource
828 if ( node->GetName() == wxT("object_ref") )
829 {
830 wxString refName = node->GetAttribute(wxT("ref"), wxEmptyString);
831 wxXmlNode* refNode = FindResource(refName, wxEmptyString, true);
832
833 if ( !refNode )
834 {
835 ReportError
836 (
837 node,
838 wxString::Format
839 (
840 "referenced object node with ref=\"%s\" not found",
841 refName
842 )
843 );
844 return NULL;
845 }
846
847 wxXmlNode copy(*refNode);
848 MergeNodesOver(copy, *node, GetFileNameFromNode(node, Data()));
849
850 // remember referenced object's file, see GetFileNameFromNode()
851 copy.AddAttribute(ATTR_INPUT_FILENAME,
852 GetFileNameFromNode(refNode, Data()));
853
854 return CreateResFromNode(&copy, parent, instance);
855 }
856
857 if (handlerToUse)
858 {
859 if (handlerToUse->CanHandle(node))
860 {
861 return handlerToUse->CreateResource(node, parent, instance);
862 }
863 }
864 else if (node->GetName() == wxT("object"))
865 {
866 for ( wxVector<wxXmlResourceHandler*>::iterator h = m_handlers.begin();
867 h != m_handlers.end(); ++h )
868 {
869 wxXmlResourceHandler *handler = *h;
870 if (handler->CanHandle(node))
871 return handler->CreateResource(node, parent, instance);
872 }
873 }
874
875 ReportError
876 (
877 node,
878 wxString::Format
879 (
880 "no handler found for XML node \"%s\" (class \"%s\")",
881 node->GetName(),
882 node->GetAttribute("class", wxEmptyString)
883 )
884 );
885 return NULL;
886 }
887
888
889 class wxXmlSubclassFactories : public wxVector<wxXmlSubclassFactory*>
890 {
891 // this is a class so that it can be forward-declared
892 };
893
894 wxXmlSubclassFactories *wxXmlResource::ms_subclassFactories = NULL;
895
896 /*static*/ void wxXmlResource::AddSubclassFactory(wxXmlSubclassFactory *factory)
897 {
898 if (!ms_subclassFactories)
899 {
900 ms_subclassFactories = new wxXmlSubclassFactories;
901 }
902 ms_subclassFactories->push_back(factory);
903 }
904
905 class wxXmlSubclassFactoryCXX : public wxXmlSubclassFactory
906 {
907 public:
908 ~wxXmlSubclassFactoryCXX() {}
909
910 wxObject *Create(const wxString& className)
911 {
912 wxClassInfo* classInfo = wxClassInfo::FindClass(className);
913
914 if (classInfo)
915 return classInfo->CreateObject();
916 else
917 return NULL;
918 }
919 };
920
921
922
923
924 wxXmlResourceHandler::wxXmlResourceHandler()
925 : m_node(NULL), m_parent(NULL), m_instance(NULL),
926 m_parentAsWindow(NULL)
927 {}
928
929
930
931 wxObject *wxXmlResourceHandler::CreateResource(wxXmlNode *node, wxObject *parent, wxObject *instance)
932 {
933 wxXmlNode *myNode = m_node;
934 wxString myClass = m_class;
935 wxObject *myParent = m_parent, *myInstance = m_instance;
936 wxWindow *myParentAW = m_parentAsWindow;
937
938 m_instance = instance;
939 if (!m_instance && node->HasAttribute(wxT("subclass")) &&
940 !(m_resource->GetFlags() & wxXRC_NO_SUBCLASSING))
941 {
942 wxString subclass = node->GetAttribute(wxT("subclass"), wxEmptyString);
943 if (!subclass.empty())
944 {
945 for (wxXmlSubclassFactories::iterator i = wxXmlResource::ms_subclassFactories->begin();
946 i != wxXmlResource::ms_subclassFactories->end(); ++i)
947 {
948 m_instance = (*i)->Create(subclass);
949 if (m_instance)
950 break;
951 }
952
953 if (!m_instance)
954 {
955 wxString name = node->GetAttribute(wxT("name"), wxEmptyString);
956 ReportError
957 (
958 node,
959 wxString::Format
960 (
961 "subclass \"%s\" not found for resource \"%s\", not subclassing",
962 subclass, name
963 )
964 );
965 }
966 }
967 }
968
969 m_node = node;
970 m_class = node->GetAttribute(wxT("class"), wxEmptyString);
971 m_parent = parent;
972 m_parentAsWindow = wxDynamicCast(m_parent, wxWindow);
973
974 wxObject *returned = DoCreateResource();
975
976 m_node = myNode;
977 m_class = myClass;
978 m_parent = myParent; m_parentAsWindow = myParentAW;
979 m_instance = myInstance;
980
981 return returned;
982 }
983
984
985 void wxXmlResourceHandler::AddStyle(const wxString& name, int value)
986 {
987 m_styleNames.Add(name);
988 m_styleValues.Add(value);
989 }
990
991
992
993 void wxXmlResourceHandler::AddWindowStyles()
994 {
995 XRC_ADD_STYLE(wxCLIP_CHILDREN);
996
997 // the border styles all have the old and new names, recognize both for now
998 XRC_ADD_STYLE(wxSIMPLE_BORDER); XRC_ADD_STYLE(wxBORDER_SIMPLE);
999 XRC_ADD_STYLE(wxSUNKEN_BORDER); XRC_ADD_STYLE(wxBORDER_SUNKEN);
1000 XRC_ADD_STYLE(wxDOUBLE_BORDER); XRC_ADD_STYLE(wxBORDER_DOUBLE);
1001 XRC_ADD_STYLE(wxRAISED_BORDER); XRC_ADD_STYLE(wxBORDER_RAISED);
1002 XRC_ADD_STYLE(wxSTATIC_BORDER); XRC_ADD_STYLE(wxBORDER_STATIC);
1003 XRC_ADD_STYLE(wxNO_BORDER); XRC_ADD_STYLE(wxBORDER_NONE);
1004
1005 XRC_ADD_STYLE(wxTRANSPARENT_WINDOW);
1006 XRC_ADD_STYLE(wxWANTS_CHARS);
1007 XRC_ADD_STYLE(wxTAB_TRAVERSAL);
1008 XRC_ADD_STYLE(wxNO_FULL_REPAINT_ON_RESIZE);
1009 XRC_ADD_STYLE(wxFULL_REPAINT_ON_RESIZE);
1010 XRC_ADD_STYLE(wxALWAYS_SHOW_SB);
1011 XRC_ADD_STYLE(wxWS_EX_BLOCK_EVENTS);
1012 XRC_ADD_STYLE(wxWS_EX_VALIDATE_RECURSIVELY);
1013 }
1014
1015
1016
1017 bool wxXmlResourceHandler::HasParam(const wxString& param)
1018 {
1019 return (GetParamNode(param) != NULL);
1020 }
1021
1022
1023 int wxXmlResourceHandler::GetStyle(const wxString& param, int defaults)
1024 {
1025 wxString s = GetParamValue(param);
1026
1027 if (!s) return defaults;
1028
1029 wxStringTokenizer tkn(s, wxT("| \t\n"), wxTOKEN_STRTOK);
1030 int style = 0;
1031 int index;
1032 wxString fl;
1033 while (tkn.HasMoreTokens())
1034 {
1035 fl = tkn.GetNextToken();
1036 index = m_styleNames.Index(fl);
1037 if (index != wxNOT_FOUND)
1038 {
1039 style |= m_styleValues[index];
1040 }
1041 else
1042 {
1043 ReportParamError
1044 (
1045 param,
1046 wxString::Format("unknown style flag \"%s\"", fl)
1047 );
1048 }
1049 }
1050 return style;
1051 }
1052
1053
1054
1055 wxString wxXmlResourceHandler::GetText(const wxString& param, bool translate)
1056 {
1057 wxXmlNode *parNode = GetParamNode(param);
1058 wxString str1(GetNodeContent(parNode));
1059 wxString str2;
1060
1061 // "\\" wasn't translated to "\" prior to 2.5.3.0:
1062 const bool escapeBackslash = (m_resource->CompareVersion(2,5,3,0) >= 0);
1063
1064 // VS: First version of XRC resources used $ instead of & (which is
1065 // illegal in XML), but later I realized that '_' fits this purpose
1066 // much better (because &File means "File with F underlined").
1067 const wxChar amp_char = (m_resource->CompareVersion(2,3,0,1) < 0)
1068 ? '$' : '_';
1069
1070 for ( wxString::const_iterator dt = str1.begin(); dt != str1.end(); ++dt )
1071 {
1072 // Remap amp_char to &, map double amp_char to amp_char (for things
1073 // like "&File..." -- this is illegal in XML, so we use "_File..."):
1074 if ( *dt == amp_char )
1075 {
1076 if ( *(++dt) == amp_char )
1077 str2 << amp_char;
1078 else
1079 str2 << wxT('&') << *dt;
1080 }
1081 // Remap \n to CR, \r to LF, \t to TAB, \\ to \:
1082 else if ( *dt == wxT('\\') )
1083 {
1084 switch ( (*(++dt)).GetValue() )
1085 {
1086 case wxT('n'):
1087 str2 << wxT('\n');
1088 break;
1089
1090 case wxT('t'):
1091 str2 << wxT('\t');
1092 break;
1093
1094 case wxT('r'):
1095 str2 << wxT('\r');
1096 break;
1097
1098 case wxT('\\') :
1099 // "\\" wasn't translated to "\" prior to 2.5.3.0:
1100 if ( escapeBackslash )
1101 {
1102 str2 << wxT('\\');
1103 break;
1104 }
1105 // else fall-through to default: branch below
1106
1107 default:
1108 str2 << wxT('\\') << *dt;
1109 break;
1110 }
1111 }
1112 else
1113 {
1114 str2 << *dt;
1115 }
1116 }
1117
1118 if (m_resource->GetFlags() & wxXRC_USE_LOCALE)
1119 {
1120 if (translate && parNode &&
1121 parNode->GetAttribute(wxT("translate"), wxEmptyString) != wxT("0"))
1122 {
1123 return wxGetTranslation(str2, m_resource->GetDomain());
1124 }
1125 else
1126 {
1127 #if wxUSE_UNICODE
1128 return str2;
1129 #else
1130 // The string is internally stored as UTF-8, we have to convert
1131 // it into system's default encoding so that it can be displayed:
1132 return wxString(str2.wc_str(wxConvUTF8), wxConvLocal);
1133 #endif
1134 }
1135 }
1136
1137 // If wxXRC_USE_LOCALE is not set, then the string is already in
1138 // system's default encoding in ANSI build, so we don't have to
1139 // do anything special here.
1140 return str2;
1141 }
1142
1143
1144
1145 long wxXmlResourceHandler::GetLong(const wxString& param, long defaultv)
1146 {
1147 long value;
1148 wxString str1 = GetParamValue(param);
1149
1150 if (!str1.ToLong(&value))
1151 value = defaultv;
1152
1153 return value;
1154 }
1155
1156 float wxXmlResourceHandler::GetFloat(const wxString& param, float defaultv)
1157 {
1158 wxString str = GetParamValue(param);
1159
1160 #if wxUSE_INTL
1161 // strings in XRC always use C locale but wxString::ToDouble() uses the
1162 // current one, so transform the string to it supposing that the only
1163 // difference between them is the decimal separator
1164 //
1165 // TODO: use wxString::ToCDouble() when we have it
1166 str.Replace(wxT("."), wxLocale::GetInfo(wxLOCALE_DECIMAL_POINT,
1167 wxLOCALE_CAT_NUMBER));
1168 #endif // wxUSE_INTL
1169
1170 double value;
1171 if (!str.ToDouble(&value))
1172 value = defaultv;
1173
1174 return wx_truncate_cast(float, value);
1175 }
1176
1177
1178 int wxXmlResourceHandler::GetID()
1179 {
1180 return wxXmlResource::GetXRCID(GetName());
1181 }
1182
1183
1184
1185 wxString wxXmlResourceHandler::GetName()
1186 {
1187 return m_node->GetAttribute(wxT("name"), wxT("-1"));
1188 }
1189
1190
1191
1192 bool wxXmlResourceHandler::GetBoolAttr(const wxString& attr, bool defaultv)
1193 {
1194 wxString v;
1195 return m_node->GetAttribute(attr, &v) ? v == '1' : defaultv;
1196 }
1197
1198 bool wxXmlResourceHandler::GetBool(const wxString& param, bool defaultv)
1199 {
1200 const wxString v = GetParamValue(param);
1201
1202 return v.empty() ? defaultv : (v == '1');
1203 }
1204
1205
1206 static wxColour GetSystemColour(const wxString& name)
1207 {
1208 if (!name.empty())
1209 {
1210 #define SYSCLR(clr) \
1211 if (name == _T(#clr)) return wxSystemSettings::GetColour(clr);
1212 SYSCLR(wxSYS_COLOUR_SCROLLBAR)
1213 SYSCLR(wxSYS_COLOUR_BACKGROUND)
1214 SYSCLR(wxSYS_COLOUR_DESKTOP)
1215 SYSCLR(wxSYS_COLOUR_ACTIVECAPTION)
1216 SYSCLR(wxSYS_COLOUR_INACTIVECAPTION)
1217 SYSCLR(wxSYS_COLOUR_MENU)
1218 SYSCLR(wxSYS_COLOUR_WINDOW)
1219 SYSCLR(wxSYS_COLOUR_WINDOWFRAME)
1220 SYSCLR(wxSYS_COLOUR_MENUTEXT)
1221 SYSCLR(wxSYS_COLOUR_WINDOWTEXT)
1222 SYSCLR(wxSYS_COLOUR_CAPTIONTEXT)
1223 SYSCLR(wxSYS_COLOUR_ACTIVEBORDER)
1224 SYSCLR(wxSYS_COLOUR_INACTIVEBORDER)
1225 SYSCLR(wxSYS_COLOUR_APPWORKSPACE)
1226 SYSCLR(wxSYS_COLOUR_HIGHLIGHT)
1227 SYSCLR(wxSYS_COLOUR_HIGHLIGHTTEXT)
1228 SYSCLR(wxSYS_COLOUR_BTNFACE)
1229 SYSCLR(wxSYS_COLOUR_3DFACE)
1230 SYSCLR(wxSYS_COLOUR_BTNSHADOW)
1231 SYSCLR(wxSYS_COLOUR_3DSHADOW)
1232 SYSCLR(wxSYS_COLOUR_GRAYTEXT)
1233 SYSCLR(wxSYS_COLOUR_BTNTEXT)
1234 SYSCLR(wxSYS_COLOUR_INACTIVECAPTIONTEXT)
1235 SYSCLR(wxSYS_COLOUR_BTNHIGHLIGHT)
1236 SYSCLR(wxSYS_COLOUR_BTNHILIGHT)
1237 SYSCLR(wxSYS_COLOUR_3DHIGHLIGHT)
1238 SYSCLR(wxSYS_COLOUR_3DHILIGHT)
1239 SYSCLR(wxSYS_COLOUR_3DDKSHADOW)
1240 SYSCLR(wxSYS_COLOUR_3DLIGHT)
1241 SYSCLR(wxSYS_COLOUR_INFOTEXT)
1242 SYSCLR(wxSYS_COLOUR_INFOBK)
1243 SYSCLR(wxSYS_COLOUR_LISTBOX)
1244 SYSCLR(wxSYS_COLOUR_HOTLIGHT)
1245 SYSCLR(wxSYS_COLOUR_GRADIENTACTIVECAPTION)
1246 SYSCLR(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)
1247 SYSCLR(wxSYS_COLOUR_MENUHILIGHT)
1248 SYSCLR(wxSYS_COLOUR_MENUBAR)
1249 #undef SYSCLR
1250 }
1251
1252 return wxNullColour;
1253 }
1254
1255 wxColour wxXmlResourceHandler::GetColour(const wxString& param, const wxColour& defaultv)
1256 {
1257 wxString v = GetParamValue(param);
1258
1259 if ( v.empty() )
1260 return defaultv;
1261
1262 wxColour clr;
1263
1264 // wxString -> wxColour conversion
1265 if (!clr.Set(v))
1266 {
1267 // the colour doesn't use #RRGGBB format, check if it is symbolic
1268 // colour name:
1269 clr = GetSystemColour(v);
1270 if (clr.Ok())
1271 return clr;
1272
1273 ReportParamError
1274 (
1275 param,
1276 wxString::Format("incorrect colour specification \"%s\"", v)
1277 );
1278 return wxNullColour;
1279 }
1280
1281 return clr;
1282 }
1283
1284 namespace
1285 {
1286
1287 // if 'param' has stock_id/stock_client, extracts them and returns true
1288 bool GetStockArtAttrs(const wxXmlNode *paramNode,
1289 const wxString& defaultArtClient,
1290 wxString& art_id, wxString& art_client)
1291 {
1292 if ( paramNode )
1293 {
1294 art_id = paramNode->GetAttribute("stock_id", "");
1295
1296 if ( !art_id.empty() )
1297 {
1298 art_id = wxART_MAKE_ART_ID_FROM_STR(art_id);
1299
1300 art_client = paramNode->GetAttribute("stock_client", "");
1301 if ( art_client.empty() )
1302 art_client = defaultArtClient;
1303 else
1304 art_client = wxART_MAKE_CLIENT_ID_FROM_STR(art_client);
1305
1306 return true;
1307 }
1308 }
1309
1310 return false;
1311 }
1312
1313 } // anonymous namespace
1314
1315 wxBitmap wxXmlResourceHandler::GetBitmap(const wxString& param,
1316 const wxArtClient& defaultArtClient,
1317 wxSize size)
1318 {
1319 /* If the bitmap is specified as stock item, query wxArtProvider for it: */
1320 wxString art_id, art_client;
1321 if ( GetStockArtAttrs(GetParamNode(param), defaultArtClient,
1322 art_id, art_client) )
1323 {
1324 wxBitmap stockArt(wxArtProvider::GetBitmap(art_id, art_client, size));
1325 if ( stockArt.Ok() )
1326 return stockArt;
1327 }
1328
1329 /* ...or load the bitmap from file: */
1330 wxString name = GetParamValue(param);
1331 if (name.empty()) return wxNullBitmap;
1332 #if wxUSE_FILESYSTEM
1333 wxFSFile *fsfile = GetCurFileSystem().OpenFile(name, wxFS_READ | wxFS_SEEKABLE);
1334 if (fsfile == NULL)
1335 {
1336 ReportParamError
1337 (
1338 param,
1339 wxString::Format("cannot open bitmap resource \"%s\"", name)
1340 );
1341 return wxNullBitmap;
1342 }
1343 wxImage img(*(fsfile->GetStream()));
1344 delete fsfile;
1345 #else
1346 wxImage img(name);
1347 #endif
1348
1349 if (!img.Ok())
1350 {
1351 ReportParamError
1352 (
1353 param,
1354 wxString::Format("cannot create bitmap from \"%s\"", name)
1355 );
1356 return wxNullBitmap;
1357 }
1358 if (!(size == wxDefaultSize)) img.Rescale(size.x, size.y);
1359 return wxBitmap(img);
1360 }
1361
1362
1363 wxIcon wxXmlResourceHandler::GetIcon(const wxString& param,
1364 const wxArtClient& defaultArtClient,
1365 wxSize size)
1366 {
1367 wxIcon icon;
1368 icon.CopyFromBitmap(GetBitmap(param, defaultArtClient, size));
1369 return icon;
1370 }
1371
1372 wxIconBundle wxXmlResourceHandler::GetIconBundle(const wxString& param,
1373 const wxArtClient& defaultArtClient)
1374 {
1375 wxString art_id, art_client;
1376 if ( GetStockArtAttrs(GetParamNode(param), defaultArtClient,
1377 art_id, art_client) )
1378 {
1379 wxIconBundle stockArt(wxArtProvider::GetIconBundle(art_id, art_client));
1380 if ( stockArt.IsOk() )
1381 return stockArt;
1382 }
1383
1384 const wxString name = GetParamValue(param);
1385 if ( name.empty() )
1386 return wxNullIconBundle;
1387
1388 #if wxUSE_FILESYSTEM
1389 wxFSFile *fsfile = GetCurFileSystem().OpenFile(name, wxFS_READ | wxFS_SEEKABLE);
1390 if ( fsfile == NULL )
1391 {
1392 ReportParamError
1393 (
1394 param,
1395 wxString::Format("cannot open icon resource \"%s\"", name)
1396 );
1397 return wxNullIconBundle;
1398 }
1399
1400 wxIconBundle bundle(*(fsfile->GetStream()));
1401 delete fsfile;
1402 #else
1403 wxIconBundle bundle(name);
1404 #endif
1405
1406 if ( !bundle.IsOk() )
1407 {
1408 ReportParamError
1409 (
1410 param,
1411 wxString::Format("cannot create icon from \"%s\"", name)
1412 );
1413 return wxNullIconBundle;
1414 }
1415
1416 return bundle;
1417 }
1418
1419
1420 wxXmlNode *wxXmlResourceHandler::GetParamNode(const wxString& param)
1421 {
1422 wxCHECK_MSG(m_node, NULL, wxT("You can't access handler data before it was initialized!"));
1423
1424 wxXmlNode *n = m_node->GetChildren();
1425
1426 while (n)
1427 {
1428 if (n->GetType() == wxXML_ELEMENT_NODE && n->GetName() == param)
1429 {
1430 // TODO: check that there are no other properties/parameters with
1431 // the same name and log an error if there are (can't do this
1432 // right now as I'm not sure if it's not going to break code
1433 // using this function in unintentional way (i.e. for
1434 // accessing other things than properties), for example
1435 // wxBitmapComboBoxXmlHandler almost surely does
1436 return n;
1437 }
1438 n = n->GetNext();
1439 }
1440 return NULL;
1441 }
1442
1443 bool wxXmlResourceHandler::IsOfClass(wxXmlNode *node, const wxString& classname)
1444 {
1445 return node->GetAttribute(wxT("class"), wxEmptyString) == classname;
1446 }
1447
1448
1449
1450 wxString wxXmlResourceHandler::GetNodeContent(wxXmlNode *node)
1451 {
1452 wxXmlNode *n = node;
1453 if (n == NULL) return wxEmptyString;
1454 n = n->GetChildren();
1455
1456 while (n)
1457 {
1458 if (n->GetType() == wxXML_TEXT_NODE ||
1459 n->GetType() == wxXML_CDATA_SECTION_NODE)
1460 return n->GetContent();
1461 n = n->GetNext();
1462 }
1463 return wxEmptyString;
1464 }
1465
1466
1467
1468 wxString wxXmlResourceHandler::GetParamValue(const wxString& param)
1469 {
1470 if (param.empty())
1471 return GetNodeContent(m_node);
1472 else
1473 return GetNodeContent(GetParamNode(param));
1474 }
1475
1476
1477
1478 wxSize wxXmlResourceHandler::GetSize(const wxString& param,
1479 wxWindow *windowToUse)
1480 {
1481 wxString s = GetParamValue(param);
1482 if (s.empty()) s = wxT("-1,-1");
1483 bool is_dlg;
1484 long sx, sy = 0;
1485
1486 is_dlg = s[s.length()-1] == wxT('d');
1487 if (is_dlg) s.RemoveLast();
1488
1489 if (!s.BeforeFirst(wxT(',')).ToLong(&sx) ||
1490 !s.AfterLast(wxT(',')).ToLong(&sy))
1491 {
1492 ReportParamError
1493 (
1494 param,
1495 wxString::Format("cannot parse coordinates value \"%s\"", s)
1496 );
1497 return wxDefaultSize;
1498 }
1499
1500 if (is_dlg)
1501 {
1502 if (windowToUse)
1503 {
1504 return wxDLG_UNIT(windowToUse, wxSize(sx, sy));
1505 }
1506 else if (m_parentAsWindow)
1507 {
1508 return wxDLG_UNIT(m_parentAsWindow, wxSize(sx, sy));
1509 }
1510 else
1511 {
1512 ReportParamError
1513 (
1514 param,
1515 "cannot convert dialog units: dialog unknown"
1516 );
1517 return wxDefaultSize;
1518 }
1519 }
1520
1521 return wxSize(sx, sy);
1522 }
1523
1524
1525
1526 wxPoint wxXmlResourceHandler::GetPosition(const wxString& param)
1527 {
1528 wxSize sz = GetSize(param);
1529 return wxPoint(sz.x, sz.y);
1530 }
1531
1532
1533
1534 wxCoord wxXmlResourceHandler::GetDimension(const wxString& param,
1535 wxCoord defaultv,
1536 wxWindow *windowToUse)
1537 {
1538 wxString s = GetParamValue(param);
1539 if (s.empty()) return defaultv;
1540 bool is_dlg;
1541 long sx;
1542
1543 is_dlg = s[s.length()-1] == wxT('d');
1544 if (is_dlg) s.RemoveLast();
1545
1546 if (!s.ToLong(&sx))
1547 {
1548 ReportParamError
1549 (
1550 param,
1551 wxString::Format("cannot parse dimension value \"%s\"", s)
1552 );
1553 return defaultv;
1554 }
1555
1556 if (is_dlg)
1557 {
1558 if (windowToUse)
1559 {
1560 return wxDLG_UNIT(windowToUse, wxSize(sx, 0)).x;
1561 }
1562 else if (m_parentAsWindow)
1563 {
1564 return wxDLG_UNIT(m_parentAsWindow, wxSize(sx, 0)).x;
1565 }
1566 else
1567 {
1568 ReportParamError
1569 (
1570 param,
1571 "cannot convert dialog units: dialog unknown"
1572 );
1573 return defaultv;
1574 }
1575 }
1576
1577 return sx;
1578 }
1579
1580
1581 // Get system font index using indexname
1582 static wxFont GetSystemFont(const wxString& name)
1583 {
1584 if (!name.empty())
1585 {
1586 #define SYSFNT(fnt) \
1587 if (name == _T(#fnt)) return wxSystemSettings::GetFont(fnt);
1588 SYSFNT(wxSYS_OEM_FIXED_FONT)
1589 SYSFNT(wxSYS_ANSI_FIXED_FONT)
1590 SYSFNT(wxSYS_ANSI_VAR_FONT)
1591 SYSFNT(wxSYS_SYSTEM_FONT)
1592 SYSFNT(wxSYS_DEVICE_DEFAULT_FONT)
1593 SYSFNT(wxSYS_SYSTEM_FIXED_FONT)
1594 SYSFNT(wxSYS_DEFAULT_GUI_FONT)
1595 #undef SYSFNT
1596 }
1597
1598 return wxNullFont;
1599 }
1600
1601 wxFont wxXmlResourceHandler::GetFont(const wxString& param)
1602 {
1603 wxXmlNode *font_node = GetParamNode(param);
1604 if (font_node == NULL)
1605 {
1606 ReportError(
1607 wxString::Format("cannot find font node \"%s\"", param));
1608 return wxNullFont;
1609 }
1610
1611 wxXmlNode *oldnode = m_node;
1612 m_node = font_node;
1613
1614 // font attributes:
1615
1616 // size
1617 int isize = -1;
1618 bool hasSize = HasParam(wxT("size"));
1619 if (hasSize)
1620 isize = GetLong(wxT("size"), -1);
1621
1622 // style
1623 int istyle = wxNORMAL;
1624 bool hasStyle = HasParam(wxT("style"));
1625 if (hasStyle)
1626 {
1627 wxString style = GetParamValue(wxT("style"));
1628 if (style == wxT("italic"))
1629 istyle = wxITALIC;
1630 else if (style == wxT("slant"))
1631 istyle = wxSLANT;
1632 }
1633
1634 // weight
1635 int iweight = wxNORMAL;
1636 bool hasWeight = HasParam(wxT("weight"));
1637 if (hasWeight)
1638 {
1639 wxString weight = GetParamValue(wxT("weight"));
1640 if (weight == wxT("bold"))
1641 iweight = wxBOLD;
1642 else if (weight == wxT("light"))
1643 iweight = wxLIGHT;
1644 }
1645
1646 // underline
1647 bool hasUnderlined = HasParam(wxT("underlined"));
1648 bool underlined = hasUnderlined ? GetBool(wxT("underlined"), false) : false;
1649
1650 // family and facename
1651 int ifamily = wxDEFAULT;
1652 bool hasFamily = HasParam(wxT("family"));
1653 if (hasFamily)
1654 {
1655 wxString family = GetParamValue(wxT("family"));
1656 if (family == wxT("decorative")) ifamily = wxDECORATIVE;
1657 else if (family == wxT("roman")) ifamily = wxROMAN;
1658 else if (family == wxT("script")) ifamily = wxSCRIPT;
1659 else if (family == wxT("swiss")) ifamily = wxSWISS;
1660 else if (family == wxT("modern")) ifamily = wxMODERN;
1661 else if (family == wxT("teletype")) ifamily = wxTELETYPE;
1662 }
1663
1664
1665 wxString facename;
1666 bool hasFacename = HasParam(wxT("face"));
1667 if (hasFacename)
1668 {
1669 wxString faces = GetParamValue(wxT("face"));
1670 wxStringTokenizer tk(faces, wxT(","));
1671 #if wxUSE_FONTENUM
1672 wxArrayString facenames(wxFontEnumerator::GetFacenames());
1673 while (tk.HasMoreTokens())
1674 {
1675 int index = facenames.Index(tk.GetNextToken(), false);
1676 if (index != wxNOT_FOUND)
1677 {
1678 facename = facenames[index];
1679 break;
1680 }
1681 }
1682 #else // !wxUSE_FONTENUM
1683 // just use the first face name if we can't check its availability:
1684 if (tk.HasMoreTokens())
1685 facename = tk.GetNextToken();
1686 #endif // wxUSE_FONTENUM/!wxUSE_FONTENUM
1687 }
1688
1689 // encoding
1690 wxFontEncoding enc = wxFONTENCODING_DEFAULT;
1691 bool hasEncoding = HasParam(wxT("encoding"));
1692 if (hasEncoding)
1693 {
1694 wxString encoding = GetParamValue(wxT("encoding"));
1695 wxFontMapper mapper;
1696 if (!encoding.empty())
1697 enc = mapper.CharsetToEncoding(encoding);
1698 if (enc == wxFONTENCODING_SYSTEM)
1699 enc = wxFONTENCODING_DEFAULT;
1700 }
1701
1702 // is this font based on a system font?
1703 wxFont font = GetSystemFont(GetParamValue(wxT("sysfont")));
1704
1705 if (font.Ok())
1706 {
1707 if (hasSize && isize != -1)
1708 font.SetPointSize(isize);
1709 else if (HasParam(wxT("relativesize")))
1710 font.SetPointSize(int(font.GetPointSize() *
1711 GetFloat(wxT("relativesize"))));
1712
1713 if (hasStyle)
1714 font.SetStyle(istyle);
1715 if (hasWeight)
1716 font.SetWeight(iweight);
1717 if (hasUnderlined)
1718 font.SetUnderlined(underlined);
1719 if (hasFamily)
1720 font.SetFamily(ifamily);
1721 if (hasFacename)
1722 font.SetFaceName(facename);
1723 if (hasEncoding)
1724 font.SetDefaultEncoding(enc);
1725 }
1726 else // not based on system font
1727 {
1728 font = wxFont(isize == -1 ? wxNORMAL_FONT->GetPointSize() : isize,
1729 ifamily, istyle, iweight,
1730 underlined, facename, enc);
1731 }
1732
1733 m_node = oldnode;
1734 return font;
1735 }
1736
1737
1738 void wxXmlResourceHandler::SetupWindow(wxWindow *wnd)
1739 {
1740 //FIXME : add cursor
1741
1742 if (HasParam(wxT("exstyle")))
1743 // Have to OR it with existing style, since
1744 // some implementations (e.g. wxGTK) use the extra style
1745 // during creation
1746 wnd->SetExtraStyle(wnd->GetExtraStyle() | GetStyle(wxT("exstyle")));
1747 if (HasParam(wxT("bg")))
1748 wnd->SetBackgroundColour(GetColour(wxT("bg")));
1749 if (HasParam(wxT("fg")))
1750 wnd->SetForegroundColour(GetColour(wxT("fg")));
1751 if (GetBool(wxT("enabled"), 1) == 0)
1752 wnd->Enable(false);
1753 if (GetBool(wxT("focused"), 0) == 1)
1754 wnd->SetFocus();
1755 if (GetBool(wxT("hidden"), 0) == 1)
1756 wnd->Show(false);
1757 #if wxUSE_TOOLTIPS
1758 if (HasParam(wxT("tooltip")))
1759 wnd->SetToolTip(GetText(wxT("tooltip")));
1760 #endif
1761 if (HasParam(wxT("font")))
1762 wnd->SetFont(GetFont());
1763 if (HasParam(wxT("help")))
1764 wnd->SetHelpText(GetText(wxT("help")));
1765 }
1766
1767
1768 void wxXmlResourceHandler::CreateChildren(wxObject *parent, bool this_hnd_only)
1769 {
1770 for ( wxXmlNode *n = m_node->GetChildren(); n; n = n->GetNext() )
1771 {
1772 if ( IsObjectNode(n) )
1773 {
1774 m_resource->CreateResFromNode(n, parent, NULL,
1775 this_hnd_only ? this : NULL);
1776 }
1777 }
1778 }
1779
1780
1781 void wxXmlResourceHandler::CreateChildrenPrivately(wxObject *parent, wxXmlNode *rootnode)
1782 {
1783 wxXmlNode *root;
1784 if (rootnode == NULL) root = m_node; else root = rootnode;
1785 wxXmlNode *n = root->GetChildren();
1786
1787 while (n)
1788 {
1789 if (n->GetType() == wxXML_ELEMENT_NODE && CanHandle(n))
1790 {
1791 CreateResource(n, parent, NULL);
1792 }
1793 n = n->GetNext();
1794 }
1795 }
1796
1797
1798 //-----------------------------------------------------------------------------
1799 // errors reporting
1800 //-----------------------------------------------------------------------------
1801
1802 void wxXmlResourceHandler::ReportError(const wxString& message)
1803 {
1804 m_resource->ReportError(m_node, message);
1805 }
1806
1807 void wxXmlResourceHandler::ReportError(wxXmlNode *context,
1808 const wxString& message)
1809 {
1810 m_resource->ReportError(context ? context : m_node, message);
1811 }
1812
1813 void wxXmlResourceHandler::ReportParamError(const wxString& param,
1814 const wxString& message)
1815 {
1816 m_resource->ReportError(GetParamNode(param), message);
1817 }
1818
1819 void wxXmlResource::ReportError(wxXmlNode *context, const wxString& message)
1820 {
1821 if ( !context )
1822 {
1823 DoReportError("", NULL, message);
1824 return;
1825 }
1826
1827 // We need to find out the file that 'context' is part of. Performance of
1828 // this code is not critical, so we simply find the root XML node and
1829 // compare it with all loaded XRC files.
1830 const wxString filename = GetFileNameFromNode(context, Data());
1831
1832 DoReportError(filename, context, message);
1833 }
1834
1835 void wxXmlResource::DoReportError(const wxString& xrcFile, wxXmlNode *position,
1836 const wxString& message)
1837 {
1838 const int line = position ? position->GetLineNumber() : -1;
1839
1840 wxString loc;
1841 if ( !xrcFile.empty() )
1842 loc = xrcFile + ':';
1843 if ( line != -1 )
1844 loc += wxString::Format("%d:", line);
1845 if ( !loc.empty() )
1846 loc += ' ';
1847
1848 wxLogError("XRC error: %s%s", loc, message);
1849 }
1850
1851
1852 //-----------------------------------------------------------------------------
1853 // XRCID implementation
1854 //-----------------------------------------------------------------------------
1855
1856 #define XRCID_TABLE_SIZE 1024
1857
1858
1859 struct XRCID_record
1860 {
1861 /* Hold the id so that once an id is allocated for a name, it
1862 does not get created again by NewControlId at least
1863 until we are done with it */
1864 wxWindowIDRef id;
1865 char *key;
1866 XRCID_record *next;
1867 };
1868
1869 static XRCID_record *XRCID_Records[XRCID_TABLE_SIZE] = {NULL};
1870
1871 static int XRCID_Lookup(const char *str_id, int value_if_not_found = wxID_NONE)
1872 {
1873 int index = 0;
1874
1875 for (const char *c = str_id; *c != '\0'; c++) index += (int)*c;
1876 index %= XRCID_TABLE_SIZE;
1877
1878 XRCID_record *oldrec = NULL;
1879 for (XRCID_record *rec = XRCID_Records[index]; rec; rec = rec->next)
1880 {
1881 if (wxStrcmp(rec->key, str_id) == 0)
1882 {
1883 return rec->id;
1884 }
1885 oldrec = rec;
1886 }
1887
1888 XRCID_record **rec_var = (oldrec == NULL) ?
1889 &XRCID_Records[index] : &oldrec->next;
1890 *rec_var = new XRCID_record;
1891 (*rec_var)->key = wxStrdup(str_id);
1892 (*rec_var)->next = NULL;
1893
1894 char *end;
1895 if (value_if_not_found != wxID_NONE)
1896 (*rec_var)->id = value_if_not_found;
1897 else
1898 {
1899 int asint = wxStrtol(str_id, &end, 10);
1900 if (*str_id && *end == 0)
1901 {
1902 // if str_id was integer, keep it verbosely:
1903 (*rec_var)->id = asint;
1904 }
1905 else
1906 {
1907 (*rec_var)->id = wxWindowBase::NewControlId();
1908 }
1909 }
1910
1911 return (*rec_var)->id;
1912 }
1913
1914 static void AddStdXRCID_Records();
1915
1916 /*static*/
1917 int wxXmlResource::DoGetXRCID(const char *str_id, int value_if_not_found)
1918 {
1919 static bool s_stdIDsAdded = false;
1920
1921 if ( !s_stdIDsAdded )
1922 {
1923 s_stdIDsAdded = true;
1924 AddStdXRCID_Records();
1925 }
1926
1927 return XRCID_Lookup(str_id, value_if_not_found);
1928 }
1929
1930 /* static */
1931 wxString wxXmlResource::FindXRCIDById(int numId)
1932 {
1933 for ( int i = 0; i < XRCID_TABLE_SIZE; i++ )
1934 {
1935 for ( XRCID_record *rec = XRCID_Records[i]; rec; rec = rec->next )
1936 {
1937 if ( rec->id == numId )
1938 return wxString(rec->key);
1939 }
1940 }
1941
1942 return wxString();
1943 }
1944
1945 static void CleanXRCID_Record(XRCID_record *rec)
1946 {
1947 if (rec)
1948 {
1949 CleanXRCID_Record(rec->next);
1950
1951 free(rec->key);
1952 delete rec;
1953 }
1954 }
1955
1956 static void CleanXRCID_Records()
1957 {
1958 for (int i = 0; i < XRCID_TABLE_SIZE; i++)
1959 {
1960 CleanXRCID_Record(XRCID_Records[i]);
1961 XRCID_Records[i] = NULL;
1962 }
1963 }
1964
1965 static void AddStdXRCID_Records()
1966 {
1967 #define stdID(id) XRCID_Lookup(#id, id)
1968 stdID(-1);
1969
1970 stdID(wxID_ANY);
1971 stdID(wxID_SEPARATOR);
1972
1973 stdID(wxID_OPEN);
1974 stdID(wxID_CLOSE);
1975 stdID(wxID_NEW);
1976 stdID(wxID_SAVE);
1977 stdID(wxID_SAVEAS);
1978 stdID(wxID_REVERT);
1979 stdID(wxID_EXIT);
1980 stdID(wxID_UNDO);
1981 stdID(wxID_REDO);
1982 stdID(wxID_HELP);
1983 stdID(wxID_PRINT);
1984 stdID(wxID_PRINT_SETUP);
1985 stdID(wxID_PAGE_SETUP);
1986 stdID(wxID_PREVIEW);
1987 stdID(wxID_ABOUT);
1988 stdID(wxID_HELP_CONTENTS);
1989 stdID(wxID_HELP_COMMANDS);
1990 stdID(wxID_HELP_PROCEDURES);
1991 stdID(wxID_HELP_CONTEXT);
1992 stdID(wxID_CLOSE_ALL);
1993 stdID(wxID_PREFERENCES);
1994 stdID(wxID_EDIT);
1995 stdID(wxID_CUT);
1996 stdID(wxID_COPY);
1997 stdID(wxID_PASTE);
1998 stdID(wxID_CLEAR);
1999 stdID(wxID_FIND);
2000 stdID(wxID_DUPLICATE);
2001 stdID(wxID_SELECTALL);
2002 stdID(wxID_DELETE);
2003 stdID(wxID_REPLACE);
2004 stdID(wxID_REPLACE_ALL);
2005 stdID(wxID_PROPERTIES);
2006 stdID(wxID_VIEW_DETAILS);
2007 stdID(wxID_VIEW_LARGEICONS);
2008 stdID(wxID_VIEW_SMALLICONS);
2009 stdID(wxID_VIEW_LIST);
2010 stdID(wxID_VIEW_SORTDATE);
2011 stdID(wxID_VIEW_SORTNAME);
2012 stdID(wxID_VIEW_SORTSIZE);
2013 stdID(wxID_VIEW_SORTTYPE);
2014 stdID(wxID_FILE1);
2015 stdID(wxID_FILE2);
2016 stdID(wxID_FILE3);
2017 stdID(wxID_FILE4);
2018 stdID(wxID_FILE5);
2019 stdID(wxID_FILE6);
2020 stdID(wxID_FILE7);
2021 stdID(wxID_FILE8);
2022 stdID(wxID_FILE9);
2023 stdID(wxID_OK);
2024 stdID(wxID_CANCEL);
2025 stdID(wxID_APPLY);
2026 stdID(wxID_YES);
2027 stdID(wxID_NO);
2028 stdID(wxID_STATIC);
2029 stdID(wxID_FORWARD);
2030 stdID(wxID_BACKWARD);
2031 stdID(wxID_DEFAULT);
2032 stdID(wxID_MORE);
2033 stdID(wxID_SETUP);
2034 stdID(wxID_RESET);
2035 stdID(wxID_CONTEXT_HELP);
2036 stdID(wxID_YESTOALL);
2037 stdID(wxID_NOTOALL);
2038 stdID(wxID_ABORT);
2039 stdID(wxID_RETRY);
2040 stdID(wxID_IGNORE);
2041 stdID(wxID_ADD);
2042 stdID(wxID_REMOVE);
2043 stdID(wxID_UP);
2044 stdID(wxID_DOWN);
2045 stdID(wxID_HOME);
2046 stdID(wxID_REFRESH);
2047 stdID(wxID_STOP);
2048 stdID(wxID_INDEX);
2049 stdID(wxID_BOLD);
2050 stdID(wxID_ITALIC);
2051 stdID(wxID_JUSTIFY_CENTER);
2052 stdID(wxID_JUSTIFY_FILL);
2053 stdID(wxID_JUSTIFY_RIGHT);
2054 stdID(wxID_JUSTIFY_LEFT);
2055 stdID(wxID_UNDERLINE);
2056 stdID(wxID_INDENT);
2057 stdID(wxID_UNINDENT);
2058 stdID(wxID_ZOOM_100);
2059 stdID(wxID_ZOOM_FIT);
2060 stdID(wxID_ZOOM_IN);
2061 stdID(wxID_ZOOM_OUT);
2062 stdID(wxID_UNDELETE);
2063 stdID(wxID_REVERT_TO_SAVED);
2064 stdID(wxID_SYSTEM_MENU);
2065 stdID(wxID_CLOSE_FRAME);
2066 stdID(wxID_MOVE_FRAME);
2067 stdID(wxID_RESIZE_FRAME);
2068 stdID(wxID_MAXIMIZE_FRAME);
2069 stdID(wxID_ICONIZE_FRAME);
2070 stdID(wxID_RESTORE_FRAME);
2071 stdID(wxID_CDROM);
2072 stdID(wxID_CONVERT);
2073 stdID(wxID_EXECUTE);
2074 stdID(wxID_FLOPPY);
2075 stdID(wxID_HARDDISK);
2076 stdID(wxID_BOTTOM);
2077 stdID(wxID_FIRST);
2078 stdID(wxID_LAST);
2079 stdID(wxID_TOP);
2080 stdID(wxID_INFO);
2081 stdID(wxID_JUMP_TO);
2082 stdID(wxID_NETWORK);
2083 stdID(wxID_SELECT_COLOR);
2084 stdID(wxID_SELECT_FONT);
2085 stdID(wxID_SORT_ASCENDING);
2086 stdID(wxID_SORT_DESCENDING);
2087 stdID(wxID_SPELL_CHECK);
2088 stdID(wxID_STRIKETHROUGH);
2089
2090 #undef stdID
2091 }
2092
2093
2094
2095
2096
2097 //-----------------------------------------------------------------------------
2098 // module and globals
2099 //-----------------------------------------------------------------------------
2100
2101 // normally we would do the cleanup from wxXmlResourceModule::OnExit() but it
2102 // can happen that some XRC records have been created because of the use of
2103 // XRCID() in event tables, which happens during static objects initialization,
2104 // but then the application initialization failed and so the wx modules were
2105 // neither initialized nor cleaned up -- this static object does the cleanup in
2106 // this case
2107 static struct wxXRCStaticCleanup
2108 {
2109 ~wxXRCStaticCleanup() { CleanXRCID_Records(); }
2110 } s_staticCleanup;
2111
2112 class wxXmlResourceModule: public wxModule
2113 {
2114 DECLARE_DYNAMIC_CLASS(wxXmlResourceModule)
2115 public:
2116 wxXmlResourceModule() {}
2117 bool OnInit()
2118 {
2119 wxXmlResource::AddSubclassFactory(new wxXmlSubclassFactoryCXX);
2120 return true;
2121 }
2122 void OnExit()
2123 {
2124 delete wxXmlResource::Set(NULL);
2125 if(wxXmlResource::ms_subclassFactories)
2126 {
2127 for ( wxXmlSubclassFactories::iterator i = wxXmlResource::ms_subclassFactories->begin();
2128 i != wxXmlResource::ms_subclassFactories->end(); ++i )
2129 {
2130 delete *i;
2131 }
2132 wxDELETE(wxXmlResource::ms_subclassFactories);
2133 }
2134 CleanXRCID_Records();
2135 }
2136 };
2137
2138 IMPLEMENT_DYNAMIC_CLASS(wxXmlResourceModule, wxModule)
2139
2140
2141 // When wxXml is loaded dynamically after the application is already running
2142 // then the built-in module system won't pick this one up. Add it manually.
2143 void wxXmlInitResourceModule()
2144 {
2145 wxModule* module = new wxXmlResourceModule;
2146 module->Init();
2147 wxModule::RegisterModule(module);
2148 }
2149
2150 #endif // wxUSE_XRC
wxWidgets (Impactor)