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