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


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