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


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