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