]> 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
osx regrouping
[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
903 // "\\" wasn't translated to "\" prior to 2.5.3.0:
904 const bool escapeBackslash = (m_resource->CompareVersion(2,5,3,0) >= 0);
905
906 // VS: First version of XRC resources used $ instead of & (which is
907 // illegal in XML), but later I realized that '_' fits this purpose
908 // much better (because &File means "File with F underlined").
909 const wxChar amp_char = (m_resource->CompareVersion(2,3,0,1) < 0)
910 ? '$' : '_';
911
912 for ( wxString::const_iterator dt = str1.begin(); dt != str1.end(); ++dt )
913 {
914 // Remap amp_char to &, map double amp_char to amp_char (for things
915 // like "&File..." -- this is illegal in XML, so we use "_File..."):
916 if ( *dt == amp_char )
917 {
918 if ( *(++dt) == amp_char )
919 str2 << amp_char;
920 else
921 str2 << wxT('&') << *dt;
922 }
923 // Remap \n to CR, \r to LF, \t to TAB, \\ to \:
924 else if ( *dt == wxT('\\') )
925 {
926 switch ( (*(++dt)).GetValue() )
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 ( escapeBackslash )
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 }
954 else
955 {
956 str2 << *dt;
957 }
958 }
959
960 if (m_resource->GetFlags() & wxXRC_USE_LOCALE)
961 {
962 if (translate && parNode &&
963 parNode->GetAttribute(wxT("translate"), wxEmptyString) != wxT("0"))
964 {
965 return wxGetTranslation(str2, m_resource->GetDomain());
966 }
967 else
968 {
969#if wxUSE_UNICODE
970 return str2;
971#else
972 // The string is internally stored as UTF-8, we have to convert
973 // it into system's default encoding so that it can be displayed:
974 return wxString(str2.wc_str(wxConvUTF8), wxConvLocal);
975#endif
976 }
977 }
978
979 // If wxXRC_USE_LOCALE is not set, then the string is already in
980 // system's default encoding in ANSI build, so we don't have to
981 // do anything special here.
982 return str2;
983}
984
985
986
987long wxXmlResourceHandler::GetLong(const wxString& param, long defaultv)
988{
989 long value;
990 wxString str1 = GetParamValue(param);
991
992 if (!str1.ToLong(&value))
993 value = defaultv;
994
995 return value;
996}
997
998float wxXmlResourceHandler::GetFloat(const wxString& param, float defaultv)
999{
1000 wxString str = GetParamValue(param);
1001
1002#if wxUSE_INTL
1003 // strings in XRC always use C locale but wxString::ToDouble() uses the
1004 // current one, so transform the string to it supposing that the only
1005 // difference between them is the decimal separator
1006 //
1007 // TODO: use wxString::ToCDouble() when we have it
1008 str.Replace(wxT("."), wxLocale::GetInfo(wxLOCALE_DECIMAL_POINT,
1009 wxLOCALE_CAT_NUMBER));
1010#endif // wxUSE_INTL
1011
1012 double value;
1013 if (!str.ToDouble(&value))
1014 value = defaultv;
1015
1016 return wx_truncate_cast(float, value);
1017}
1018
1019
1020int wxXmlResourceHandler::GetID()
1021{
1022 return wxXmlResource::GetXRCID(GetName());
1023}
1024
1025
1026
1027wxString wxXmlResourceHandler::GetName()
1028{
1029 return m_node->GetAttribute(wxT("name"), wxT("-1"));
1030}
1031
1032
1033
1034bool wxXmlResourceHandler::GetBool(const wxString& param, bool defaultv)
1035{
1036 wxString v = GetParamValue(param);
1037 v.MakeLower();
1038 if (!v) return defaultv;
1039
1040 return (v == wxT("1"));
1041}
1042
1043
1044static wxColour GetSystemColour(const wxString& name)
1045{
1046 if (!name.empty())
1047 {
1048 #define SYSCLR(clr) \
1049 if (name == _T(#clr)) return wxSystemSettings::GetColour(clr);
1050 SYSCLR(wxSYS_COLOUR_SCROLLBAR)
1051 SYSCLR(wxSYS_COLOUR_BACKGROUND)
1052 SYSCLR(wxSYS_COLOUR_DESKTOP)
1053 SYSCLR(wxSYS_COLOUR_ACTIVECAPTION)
1054 SYSCLR(wxSYS_COLOUR_INACTIVECAPTION)
1055 SYSCLR(wxSYS_COLOUR_MENU)
1056 SYSCLR(wxSYS_COLOUR_WINDOW)
1057 SYSCLR(wxSYS_COLOUR_WINDOWFRAME)
1058 SYSCLR(wxSYS_COLOUR_MENUTEXT)
1059 SYSCLR(wxSYS_COLOUR_WINDOWTEXT)
1060 SYSCLR(wxSYS_COLOUR_CAPTIONTEXT)
1061 SYSCLR(wxSYS_COLOUR_ACTIVEBORDER)
1062 SYSCLR(wxSYS_COLOUR_INACTIVEBORDER)
1063 SYSCLR(wxSYS_COLOUR_APPWORKSPACE)
1064 SYSCLR(wxSYS_COLOUR_HIGHLIGHT)
1065 SYSCLR(wxSYS_COLOUR_HIGHLIGHTTEXT)
1066 SYSCLR(wxSYS_COLOUR_BTNFACE)
1067 SYSCLR(wxSYS_COLOUR_3DFACE)
1068 SYSCLR(wxSYS_COLOUR_BTNSHADOW)
1069 SYSCLR(wxSYS_COLOUR_3DSHADOW)
1070 SYSCLR(wxSYS_COLOUR_GRAYTEXT)
1071 SYSCLR(wxSYS_COLOUR_BTNTEXT)
1072 SYSCLR(wxSYS_COLOUR_INACTIVECAPTIONTEXT)
1073 SYSCLR(wxSYS_COLOUR_BTNHIGHLIGHT)
1074 SYSCLR(wxSYS_COLOUR_BTNHILIGHT)
1075 SYSCLR(wxSYS_COLOUR_3DHIGHLIGHT)
1076 SYSCLR(wxSYS_COLOUR_3DHILIGHT)
1077 SYSCLR(wxSYS_COLOUR_3DDKSHADOW)
1078 SYSCLR(wxSYS_COLOUR_3DLIGHT)
1079 SYSCLR(wxSYS_COLOUR_INFOTEXT)
1080 SYSCLR(wxSYS_COLOUR_INFOBK)
1081 SYSCLR(wxSYS_COLOUR_LISTBOX)
1082 SYSCLR(wxSYS_COLOUR_HOTLIGHT)
1083 SYSCLR(wxSYS_COLOUR_GRADIENTACTIVECAPTION)
1084 SYSCLR(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)
1085 SYSCLR(wxSYS_COLOUR_MENUHILIGHT)
1086 SYSCLR(wxSYS_COLOUR_MENUBAR)
1087 #undef SYSCLR
1088 }
1089
1090 return wxNullColour;
1091}
1092
1093wxColour wxXmlResourceHandler::GetColour(const wxString& param, const wxColour& defaultv)
1094{
1095 wxString v = GetParamValue(param);
1096
1097 if ( v.empty() )
1098 return defaultv;
1099
1100 wxColour clr;
1101
1102 // wxString -> wxColour conversion
1103 if (!clr.Set(v))
1104 {
1105 // the colour doesn't use #RRGGBB format, check if it is symbolic
1106 // colour name:
1107 clr = GetSystemColour(v);
1108 if (clr.Ok())
1109 return clr;
1110
1111 wxLogError(_("XRC resource: Incorrect colour specification '%s' for attribute '%s'."),
1112 v.c_str(), param.c_str());
1113 return wxNullColour;
1114 }
1115
1116 return clr;
1117}
1118
1119
1120
1121wxBitmap wxXmlResourceHandler::GetBitmap(const wxString& param,
1122 const wxArtClient& defaultArtClient,
1123 wxSize size)
1124{
1125 /* If the bitmap is specified as stock item, query wxArtProvider for it: */
1126 wxXmlNode *bmpNode = GetParamNode(param);
1127 if ( bmpNode )
1128 {
1129 wxString sid = bmpNode->GetAttribute(wxT("stock_id"), wxEmptyString);
1130 if ( !sid.empty() )
1131 {
1132 wxString scl = bmpNode->GetAttribute(wxT("stock_client"), wxEmptyString);
1133 if (scl.empty())
1134 scl = defaultArtClient;
1135 else
1136 scl = wxART_MAKE_CLIENT_ID_FROM_STR(scl);
1137
1138 wxBitmap stockArt =
1139 wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(sid),
1140 scl, size);
1141 if ( stockArt.Ok() )
1142 return stockArt;
1143 }
1144 }
1145
1146 /* ...or load the bitmap from file: */
1147 wxString name = GetParamValue(param);
1148 if (name.empty()) return wxNullBitmap;
1149#if wxUSE_FILESYSTEM
1150 wxFSFile *fsfile = GetCurFileSystem().OpenFile(name, wxFS_READ | wxFS_SEEKABLE);
1151 if (fsfile == NULL)
1152 {
1153 wxLogError(_("XRC resource: Cannot create bitmap from '%s'."),
1154 name.c_str());
1155 return wxNullBitmap;
1156 }
1157 wxImage img(*(fsfile->GetStream()));
1158 delete fsfile;
1159#else
1160 wxImage img(name);
1161#endif
1162
1163 if (!img.Ok())
1164 {
1165 wxLogError(_("XRC resource: Cannot create bitmap from '%s'."),
1166 name.c_str());
1167 return wxNullBitmap;
1168 }
1169 if (!(size == wxDefaultSize)) img.Rescale(size.x, size.y);
1170 return wxBitmap(img);
1171}
1172
1173#if wxUSE_ANIMATIONCTRL
1174wxAnimation wxXmlResourceHandler::GetAnimation(const wxString& param)
1175{
1176 wxAnimation ani;
1177
1178 /* load the animation from file: */
1179 wxString name = GetParamValue(param);
1180 if (name.empty()) return wxNullAnimation;
1181#if wxUSE_FILESYSTEM
1182 wxFSFile *fsfile = GetCurFileSystem().OpenFile(name, wxFS_READ | wxFS_SEEKABLE);
1183 if (fsfile == NULL)
1184 {
1185 wxLogError(_("XRC resource: Cannot create animation from '%s'."),
1186 name.c_str());
1187 return wxNullAnimation;
1188 }
1189 ani.Load(*(fsfile->GetStream()));
1190 delete fsfile;
1191#else
1192 ani.LoadFile(name);
1193#endif
1194
1195 if (!ani.IsOk())
1196 {
1197 wxLogError(_("XRC resource: Cannot create animation from '%s'."),
1198 name.c_str());
1199 return wxNullAnimation;
1200 }
1201
1202 return ani;
1203}
1204#endif // wxUSE_ANIMATIONCTRL
1205
1206
1207
1208wxIcon wxXmlResourceHandler::GetIcon(const wxString& param,
1209 const wxArtClient& defaultArtClient,
1210 wxSize size)
1211{
1212 wxIcon icon;
1213 icon.CopyFromBitmap(GetBitmap(param, defaultArtClient, size));
1214 return icon;
1215}
1216
1217
1218
1219wxXmlNode *wxXmlResourceHandler::GetParamNode(const wxString& param)
1220{
1221 wxCHECK_MSG(m_node, NULL, wxT("You can't access handler data before it was initialized!"));
1222
1223 wxXmlNode *n = m_node->GetChildren();
1224
1225 while (n)
1226 {
1227 if (n->GetType() == wxXML_ELEMENT_NODE && n->GetName() == param)
1228 return n;
1229 n = n->GetNext();
1230 }
1231 return NULL;
1232}
1233
1234
1235
1236bool wxXmlResourceHandler::IsOfClass(wxXmlNode *node, const wxString& classname)
1237{
1238 return node->GetAttribute(wxT("class"), wxEmptyString) == classname;
1239}
1240
1241
1242
1243wxString wxXmlResourceHandler::GetNodeContent(wxXmlNode *node)
1244{
1245 wxXmlNode *n = node;
1246 if (n == NULL) return wxEmptyString;
1247 n = n->GetChildren();
1248
1249 while (n)
1250 {
1251 if (n->GetType() == wxXML_TEXT_NODE ||
1252 n->GetType() == wxXML_CDATA_SECTION_NODE)
1253 return n->GetContent();
1254 n = n->GetNext();
1255 }
1256 return wxEmptyString;
1257}
1258
1259
1260
1261wxString wxXmlResourceHandler::GetParamValue(const wxString& param)
1262{
1263 if (param.empty())
1264 return GetNodeContent(m_node);
1265 else
1266 return GetNodeContent(GetParamNode(param));
1267}
1268
1269
1270
1271wxSize wxXmlResourceHandler::GetSize(const wxString& param,
1272 wxWindow *windowToUse)
1273{
1274 wxString s = GetParamValue(param);
1275 if (s.empty()) s = wxT("-1,-1");
1276 bool is_dlg;
1277 long sx, sy = 0;
1278
1279 is_dlg = s[s.length()-1] == wxT('d');
1280 if (is_dlg) s.RemoveLast();
1281
1282 if (!s.BeforeFirst(wxT(',')).ToLong(&sx) ||
1283 !s.AfterLast(wxT(',')).ToLong(&sy))
1284 {
1285 wxLogError(_("Cannot parse coordinates from '%s'."), s.c_str());
1286 return wxDefaultSize;
1287 }
1288
1289 if (is_dlg)
1290 {
1291 if (windowToUse)
1292 {
1293 return wxDLG_UNIT(windowToUse, wxSize(sx, sy));
1294 }
1295 else if (m_parentAsWindow)
1296 {
1297 return wxDLG_UNIT(m_parentAsWindow, wxSize(sx, sy));
1298 }
1299 else
1300 {
1301 wxLogError(_("Cannot convert dialog units: dialog unknown."));
1302 return wxDefaultSize;
1303 }
1304 }
1305
1306 return wxSize(sx, sy);
1307}
1308
1309
1310
1311wxPoint wxXmlResourceHandler::GetPosition(const wxString& param)
1312{
1313 wxSize sz = GetSize(param);
1314 return wxPoint(sz.x, sz.y);
1315}
1316
1317
1318
1319wxCoord wxXmlResourceHandler::GetDimension(const wxString& param,
1320 wxCoord defaultv,
1321 wxWindow *windowToUse)
1322{
1323 wxString s = GetParamValue(param);
1324 if (s.empty()) return defaultv;
1325 bool is_dlg;
1326 long sx;
1327
1328 is_dlg = s[s.length()-1] == wxT('d');
1329 if (is_dlg) s.RemoveLast();
1330
1331 if (!s.ToLong(&sx))
1332 {
1333 wxLogError(_("Cannot parse dimension from '%s'."), s.c_str());
1334 return defaultv;
1335 }
1336
1337 if (is_dlg)
1338 {
1339 if (windowToUse)
1340 {
1341 return wxDLG_UNIT(windowToUse, wxSize(sx, 0)).x;
1342 }
1343 else if (m_parentAsWindow)
1344 {
1345 return wxDLG_UNIT(m_parentAsWindow, wxSize(sx, 0)).x;
1346 }
1347 else
1348 {
1349 wxLogError(_("Cannot convert dialog units: dialog unknown."));
1350 return defaultv;
1351 }
1352 }
1353
1354 return sx;
1355}
1356
1357
1358// Get system font index using indexname
1359static wxFont GetSystemFont(const wxString& name)
1360{
1361 if (!name.empty())
1362 {
1363 #define SYSFNT(fnt) \
1364 if (name == _T(#fnt)) return wxSystemSettings::GetFont(fnt);
1365 SYSFNT(wxSYS_OEM_FIXED_FONT)
1366 SYSFNT(wxSYS_ANSI_FIXED_FONT)
1367 SYSFNT(wxSYS_ANSI_VAR_FONT)
1368 SYSFNT(wxSYS_SYSTEM_FONT)
1369 SYSFNT(wxSYS_DEVICE_DEFAULT_FONT)
1370 SYSFNT(wxSYS_DEFAULT_PALETTE)
1371 SYSFNT(wxSYS_SYSTEM_FIXED_FONT)
1372 SYSFNT(wxSYS_DEFAULT_GUI_FONT)
1373 #undef SYSFNT
1374 }
1375
1376 return wxNullFont;
1377}
1378
1379wxFont wxXmlResourceHandler::GetFont(const wxString& param)
1380{
1381 wxXmlNode *font_node = GetParamNode(param);
1382 if (font_node == NULL)
1383 {
1384 wxLogError(_("Cannot find font node '%s'."), param.c_str());
1385 return wxNullFont;
1386 }
1387
1388 wxXmlNode *oldnode = m_node;
1389 m_node = font_node;
1390
1391 // font attributes:
1392
1393 // size
1394 int isize = -1;
1395 bool hasSize = HasParam(wxT("size"));
1396 if (hasSize)
1397 isize = GetLong(wxT("size"), -1);
1398
1399 // style
1400 int istyle = wxNORMAL;
1401 bool hasStyle = HasParam(wxT("style"));
1402 if (hasStyle)
1403 {
1404 wxString style = GetParamValue(wxT("style"));
1405 if (style == wxT("italic"))
1406 istyle = wxITALIC;
1407 else if (style == wxT("slant"))
1408 istyle = wxSLANT;
1409 }
1410
1411 // weight
1412 int iweight = wxNORMAL;
1413 bool hasWeight = HasParam(wxT("weight"));
1414 if (hasWeight)
1415 {
1416 wxString weight = GetParamValue(wxT("weight"));
1417 if (weight == wxT("bold"))
1418 iweight = wxBOLD;
1419 else if (weight == wxT("light"))
1420 iweight = wxLIGHT;
1421 }
1422
1423 // underline
1424 bool hasUnderlined = HasParam(wxT("underlined"));
1425 bool underlined = hasUnderlined ? GetBool(wxT("underlined"), false) : false;
1426
1427 // family and facename
1428 int ifamily = wxDEFAULT;
1429 bool hasFamily = HasParam(wxT("family"));
1430 if (hasFamily)
1431 {
1432 wxString family = GetParamValue(wxT("family"));
1433 if (family == wxT("decorative")) ifamily = wxDECORATIVE;
1434 else if (family == wxT("roman")) ifamily = wxROMAN;
1435 else if (family == wxT("script")) ifamily = wxSCRIPT;
1436 else if (family == wxT("swiss")) ifamily = wxSWISS;
1437 else if (family == wxT("modern")) ifamily = wxMODERN;
1438 else if (family == wxT("teletype")) ifamily = wxTELETYPE;
1439 }
1440
1441
1442 wxString facename;
1443 bool hasFacename = HasParam(wxT("face"));
1444 if (hasFacename)
1445 {
1446 wxString faces = GetParamValue(wxT("face"));
1447 wxStringTokenizer tk(faces, wxT(","));
1448#if wxUSE_FONTENUM
1449 wxArrayString facenames(wxFontEnumerator::GetFacenames());
1450 while (tk.HasMoreTokens())
1451 {
1452 int index = facenames.Index(tk.GetNextToken(), false);
1453 if (index != wxNOT_FOUND)
1454 {
1455 facename = facenames[index];
1456 break;
1457 }
1458 }
1459#else // !wxUSE_FONTENUM
1460 // just use the first face name if we can't check its availability:
1461 if (tk.HasMoreTokens())
1462 facename = tk.GetNextToken();
1463#endif // wxUSE_FONTENUM/!wxUSE_FONTENUM
1464 }
1465
1466 // encoding
1467 wxFontEncoding enc = wxFONTENCODING_DEFAULT;
1468 bool hasEncoding = HasParam(wxT("encoding"));
1469 if (hasEncoding)
1470 {
1471 wxString encoding = GetParamValue(wxT("encoding"));
1472 wxFontMapper mapper;
1473 if (!encoding.empty())
1474 enc = mapper.CharsetToEncoding(encoding);
1475 if (enc == wxFONTENCODING_SYSTEM)
1476 enc = wxFONTENCODING_DEFAULT;
1477 }
1478
1479 // is this font based on a system font?
1480 wxFont font = GetSystemFont(GetParamValue(wxT("sysfont")));
1481
1482 if (font.Ok())
1483 {
1484 if (hasSize && isize != -1)
1485 font.SetPointSize(isize);
1486 else if (HasParam(wxT("relativesize")))
1487 font.SetPointSize(int(font.GetPointSize() *
1488 GetFloat(wxT("relativesize"))));
1489
1490 if (hasStyle)
1491 font.SetStyle(istyle);
1492 if (hasWeight)
1493 font.SetWeight(iweight);
1494 if (hasUnderlined)
1495 font.SetUnderlined(underlined);
1496 if (hasFamily)
1497 font.SetFamily(ifamily);
1498 if (hasFacename)
1499 font.SetFaceName(facename);
1500 if (hasEncoding)
1501 font.SetDefaultEncoding(enc);
1502 }
1503 else // not based on system font
1504 {
1505 font = wxFont(isize == -1 ? wxNORMAL_FONT->GetPointSize() : isize,
1506 ifamily, istyle, iweight,
1507 underlined, facename, enc);
1508 }
1509
1510 m_node = oldnode;
1511 return font;
1512}
1513
1514
1515void wxXmlResourceHandler::SetupWindow(wxWindow *wnd)
1516{
1517 //FIXME : add cursor
1518
1519 if (HasParam(wxT("exstyle")))
1520 // Have to OR it with existing style, since
1521 // some implementations (e.g. wxGTK) use the extra style
1522 // during creation
1523 wnd->SetExtraStyle(wnd->GetExtraStyle() | GetStyle(wxT("exstyle")));
1524 if (HasParam(wxT("bg")))
1525 wnd->SetBackgroundColour(GetColour(wxT("bg")));
1526 if (HasParam(wxT("fg")))
1527 wnd->SetForegroundColour(GetColour(wxT("fg")));
1528 if (GetBool(wxT("enabled"), 1) == 0)
1529 wnd->Enable(false);
1530 if (GetBool(wxT("focused"), 0) == 1)
1531 wnd->SetFocus();
1532 if (GetBool(wxT("hidden"), 0) == 1)
1533 wnd->Show(false);
1534#if wxUSE_TOOLTIPS
1535 if (HasParam(wxT("tooltip")))
1536 wnd->SetToolTip(GetText(wxT("tooltip")));
1537#endif
1538 if (HasParam(wxT("font")))
1539 wnd->SetFont(GetFont());
1540 if (HasParam(wxT("help")))
1541 wnd->SetHelpText(GetText(wxT("help")));
1542}
1543
1544
1545void wxXmlResourceHandler::CreateChildren(wxObject *parent, bool this_hnd_only)
1546{
1547 wxXmlNode *n = m_node->GetChildren();
1548
1549 while (n)
1550 {
1551 if (n->GetType() == wxXML_ELEMENT_NODE &&
1552 (n->GetName() == wxT("object") || n->GetName() == wxT("object_ref")))
1553 {
1554 m_resource->CreateResFromNode(n, parent, NULL,
1555 this_hnd_only ? this : NULL);
1556 }
1557 n = n->GetNext();
1558 }
1559}
1560
1561
1562void wxXmlResourceHandler::CreateChildrenPrivately(wxObject *parent, wxXmlNode *rootnode)
1563{
1564 wxXmlNode *root;
1565 if (rootnode == NULL) root = m_node; else root = rootnode;
1566 wxXmlNode *n = root->GetChildren();
1567
1568 while (n)
1569 {
1570 if (n->GetType() == wxXML_ELEMENT_NODE && CanHandle(n))
1571 {
1572 CreateResource(n, parent, NULL);
1573 }
1574 n = n->GetNext();
1575 }
1576}
1577
1578
1579
1580
1581
1582
1583
1584// --------------- XRCID implementation -----------------------------
1585
1586#define XRCID_TABLE_SIZE 1024
1587
1588
1589struct XRCID_record
1590{
1591 /* Hold the id so that once an id is allocated for a name, it
1592 does not get created again by NewControlId at least
1593 until we are done with it */
1594 wxWindowIDRef id;
1595 char *key;
1596 XRCID_record *next;
1597};
1598
1599static XRCID_record *XRCID_Records[XRCID_TABLE_SIZE] = {NULL};
1600
1601static int XRCID_Lookup(const char *str_id, int value_if_not_found = wxID_NONE)
1602{
1603 int index = 0;
1604
1605 for (const char *c = str_id; *c != '\0'; c++) index += (int)*c;
1606 index %= XRCID_TABLE_SIZE;
1607
1608 XRCID_record *oldrec = NULL;
1609 for (XRCID_record *rec = XRCID_Records[index]; rec; rec = rec->next)
1610 {
1611 if (wxStrcmp(rec->key, str_id) == 0)
1612 {
1613 return rec->id;
1614 }
1615 oldrec = rec;
1616 }
1617
1618 XRCID_record **rec_var = (oldrec == NULL) ?
1619 &XRCID_Records[index] : &oldrec->next;
1620 *rec_var = new XRCID_record;
1621 (*rec_var)->key = wxStrdup(str_id);
1622 (*rec_var)->next = NULL;
1623
1624 char *end;
1625 if (value_if_not_found != wxID_NONE)
1626 (*rec_var)->id = value_if_not_found;
1627 else
1628 {
1629 int asint = wxStrtol(str_id, &end, 10);
1630 if (*str_id && *end == 0)
1631 {
1632 // if str_id was integer, keep it verbosely:
1633 (*rec_var)->id = asint;
1634 }
1635 else
1636 {
1637 (*rec_var)->id = wxWindowBase::NewControlId();
1638 }
1639 }
1640
1641 return (*rec_var)->id;
1642}
1643
1644static void AddStdXRCID_Records();
1645
1646/*static*/
1647int wxXmlResource::DoGetXRCID(const char *str_id, int value_if_not_found)
1648{
1649 static bool s_stdIDsAdded = false;
1650
1651 if ( !s_stdIDsAdded )
1652 {
1653 s_stdIDsAdded = true;
1654 AddStdXRCID_Records();
1655 }
1656
1657 return XRCID_Lookup(str_id, value_if_not_found);
1658}
1659
1660
1661static void CleanXRCID_Record(XRCID_record *rec)
1662{
1663 if (rec)
1664 {
1665 CleanXRCID_Record(rec->next);
1666
1667 free(rec->key);
1668 delete rec;
1669 }
1670}
1671
1672static void CleanXRCID_Records()
1673{
1674 for (int i = 0; i < XRCID_TABLE_SIZE; i++)
1675 {
1676 CleanXRCID_Record(XRCID_Records[i]);
1677 XRCID_Records[i] = NULL;
1678 }
1679}
1680
1681static void AddStdXRCID_Records()
1682{
1683#define stdID(id) XRCID_Lookup(#id, id)
1684 stdID(-1);
1685
1686 stdID(wxID_ANY);
1687 stdID(wxID_SEPARATOR);
1688
1689 stdID(wxID_OPEN);
1690 stdID(wxID_CLOSE);
1691 stdID(wxID_NEW);
1692 stdID(wxID_SAVE);
1693 stdID(wxID_SAVEAS);
1694 stdID(wxID_REVERT);
1695 stdID(wxID_EXIT);
1696 stdID(wxID_UNDO);
1697 stdID(wxID_REDO);
1698 stdID(wxID_HELP);
1699 stdID(wxID_PRINT);
1700 stdID(wxID_PRINT_SETUP);
1701 stdID(wxID_PAGE_SETUP);
1702 stdID(wxID_PREVIEW);
1703 stdID(wxID_ABOUT);
1704 stdID(wxID_HELP_CONTENTS);
1705 stdID(wxID_HELP_COMMANDS);
1706 stdID(wxID_HELP_PROCEDURES);
1707 stdID(wxID_HELP_CONTEXT);
1708 stdID(wxID_CLOSE_ALL);
1709 stdID(wxID_PREFERENCES);
1710 stdID(wxID_EDIT);
1711 stdID(wxID_CUT);
1712 stdID(wxID_COPY);
1713 stdID(wxID_PASTE);
1714 stdID(wxID_CLEAR);
1715 stdID(wxID_FIND);
1716 stdID(wxID_DUPLICATE);
1717 stdID(wxID_SELECTALL);
1718 stdID(wxID_DELETE);
1719 stdID(wxID_REPLACE);
1720 stdID(wxID_REPLACE_ALL);
1721 stdID(wxID_PROPERTIES);
1722 stdID(wxID_VIEW_DETAILS);
1723 stdID(wxID_VIEW_LARGEICONS);
1724 stdID(wxID_VIEW_SMALLICONS);
1725 stdID(wxID_VIEW_LIST);
1726 stdID(wxID_VIEW_SORTDATE);
1727 stdID(wxID_VIEW_SORTNAME);
1728 stdID(wxID_VIEW_SORTSIZE);
1729 stdID(wxID_VIEW_SORTTYPE);
1730 stdID(wxID_FILE1);
1731 stdID(wxID_FILE2);
1732 stdID(wxID_FILE3);
1733 stdID(wxID_FILE4);
1734 stdID(wxID_FILE5);
1735 stdID(wxID_FILE6);
1736 stdID(wxID_FILE7);
1737 stdID(wxID_FILE8);
1738 stdID(wxID_FILE9);
1739 stdID(wxID_OK);
1740 stdID(wxID_CANCEL);
1741 stdID(wxID_APPLY);
1742 stdID(wxID_YES);
1743 stdID(wxID_NO);
1744 stdID(wxID_STATIC);
1745 stdID(wxID_FORWARD);
1746 stdID(wxID_BACKWARD);
1747 stdID(wxID_DEFAULT);
1748 stdID(wxID_MORE);
1749 stdID(wxID_SETUP);
1750 stdID(wxID_RESET);
1751 stdID(wxID_CONTEXT_HELP);
1752 stdID(wxID_YESTOALL);
1753 stdID(wxID_NOTOALL);
1754 stdID(wxID_ABORT);
1755 stdID(wxID_RETRY);
1756 stdID(wxID_IGNORE);
1757 stdID(wxID_ADD);
1758 stdID(wxID_REMOVE);
1759 stdID(wxID_UP);
1760 stdID(wxID_DOWN);
1761 stdID(wxID_HOME);
1762 stdID(wxID_REFRESH);
1763 stdID(wxID_STOP);
1764 stdID(wxID_INDEX);
1765 stdID(wxID_BOLD);
1766 stdID(wxID_ITALIC);
1767 stdID(wxID_JUSTIFY_CENTER);
1768 stdID(wxID_JUSTIFY_FILL);
1769 stdID(wxID_JUSTIFY_RIGHT);
1770 stdID(wxID_JUSTIFY_LEFT);
1771 stdID(wxID_UNDERLINE);
1772 stdID(wxID_INDENT);
1773 stdID(wxID_UNINDENT);
1774 stdID(wxID_ZOOM_100);
1775 stdID(wxID_ZOOM_FIT);
1776 stdID(wxID_ZOOM_IN);
1777 stdID(wxID_ZOOM_OUT);
1778 stdID(wxID_UNDELETE);
1779 stdID(wxID_REVERT_TO_SAVED);
1780 stdID(wxID_SYSTEM_MENU);
1781 stdID(wxID_CLOSE_FRAME);
1782 stdID(wxID_MOVE_FRAME);
1783 stdID(wxID_RESIZE_FRAME);
1784 stdID(wxID_MAXIMIZE_FRAME);
1785 stdID(wxID_ICONIZE_FRAME);
1786 stdID(wxID_RESTORE_FRAME);
1787
1788#undef stdID
1789}
1790
1791
1792
1793
1794
1795// --------------- module and globals -----------------------------
1796
1797// normally we would do the cleanup from wxXmlResourceModule::OnExit() but it
1798// can happen that some XRC records have been created because of the use of
1799// XRCID() in event tables, which happens during static objects initialization,
1800// but then the application initialization failed and so the wx modules were
1801// neither initialized nor cleaned up -- this static object does the cleanup in
1802// this case
1803static struct wxXRCStaticCleanup
1804{
1805 ~wxXRCStaticCleanup() { CleanXRCID_Records(); }
1806} s_staticCleanup;
1807
1808class wxXmlResourceModule: public wxModule
1809{
1810DECLARE_DYNAMIC_CLASS(wxXmlResourceModule)
1811public:
1812 wxXmlResourceModule() {}
1813 bool OnInit()
1814 {
1815 wxXmlResource::AddSubclassFactory(new wxXmlSubclassFactoryCXX);
1816 return true;
1817 }
1818 void OnExit()
1819 {
1820 delete wxXmlResource::Set(NULL);
1821 if(wxXmlResource::ms_subclassFactories)
1822 {
1823 for ( wxXmlSubclassFactories::iterator i = wxXmlResource::ms_subclassFactories->begin();
1824 i != wxXmlResource::ms_subclassFactories->end(); ++i )
1825 {
1826 delete *i;
1827 }
1828 wxDELETE(wxXmlResource::ms_subclassFactories);
1829 }
1830 CleanXRCID_Records();
1831 }
1832};
1833
1834IMPLEMENT_DYNAMIC_CLASS(wxXmlResourceModule, wxModule)
1835
1836
1837// When wxXml is loaded dynamically after the application is already running
1838// then the built-in module system won't pick this one up. Add it manually.
1839void wxXmlInitResourceModule()
1840{
1841 wxModule* module = new wxXmlResourceModule;
1842 module->Init();
1843 wxModule::RegisterModule(module);
1844}
1845
1846#endif // wxUSE_XRC
wxWidgets (Impactor)