]> git.saurik.com Git - wxWidgets.git/blame - src/xrc/xmlres.cpp
projects / wxWidgets.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
fixed erroneous debug error message
[wxWidgets.git] / src / xrc / xmlres.cpp
CommitLineData
78d14f80
VS		 1/////////////////////////////////////////////////////////////////////////////
2// Name: xmlres.cpp
3// Purpose: XML 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#ifdef __GNUG__
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#include "wx/dialog.h"
23#include "wx/panel.h"
24#include "wx/frame.h"
25#include "wx/wfstream.h"
26#include "wx/filesys.h"
27#include "wx/log.h"
28#include "wx/intl.h"
29#include "wx/tokenzr.h"
30#include "wx/fontenum.h"
31#include "wx/module.h"
32#include "wx/bitmap.h"
33#include "wx/image.h"
34#include "wx/fontmap.h"
35
36#include "wx/xrc/xml.h"
37#include "wx/xrc/xmlres.h"
38
39#include "wx/arrimpl.cpp"
40WX_DEFINE_OBJARRAY(wxXmlResourceDataRecords);
41
42
43wxXmlResource::wxXmlResource(bool use_locale)
44{
45 m_handlers.DeleteContents(TRUE);
46 m_useLocale = use_locale;
47 m_version = -1;
48}
49
50wxXmlResource::wxXmlResource(const wxString& filemask, bool use_locale)
51{
52 m_useLocale = use_locale;
53 m_version = -1;
54 m_handlers.DeleteContents(TRUE);
55 Load(filemask);
56}
57
58wxXmlResource::~wxXmlResource()
59{
60 ClearHandlers();
61}
62
63
64bool wxXmlResource::Load(const wxString& filemask)
65{
66 wxString fnd;
67 wxXmlResourceDataRecord *drec;
68 bool iswild = wxIsWild(filemask);
69 bool rt = TRUE;
70
71#if wxUSE_FILESYSTEM
72 wxFileSystem fsys;
73# define wxXmlFindFirst fsys.FindFirst(filemask, wxFILE)
74# define wxXmlFindNext fsys.FindNext()
75#else
76# define wxXmlFindFirst wxFindFirstFile(filemask, wxFILE)
77# define wxXmlFindNext wxFindNextFile()
78#endif
79 if (iswild)
80 fnd = wxXmlFindFirst;
81 else
82 fnd = filemask;
83 while (!!fnd)
84 {
85#if wxUSE_FILESYSTEM
00393283
VS		 86 if (filemask.Lower().Matches(wxT("*.zip")) ||
87 filemask.Lower().Matches(wxT("*.rsc")))
78d14f80
VS		 88 {
89 rt = rt && Load(fnd + wxT("#zip:*.xmb"));
90 rt = rt && Load(fnd + wxT("#zip:*.xrc"));
91 }
92 else
93#endif
94 {
95 drec = new wxXmlResourceDataRecord;
96 drec->File = fnd;
97 m_data.Add(drec);
98 }
99
100 if (iswild)
101 fnd = wxXmlFindNext;
102 else
103 fnd = wxEmptyString;
104 }
105# undef wxXmlFindFirst
106# undef wxXmlFindNext
107 return rt;
108}
109
110
111
112void wxXmlResource::AddHandler(wxXmlResourceHandler *handler)
113{
114 m_handlers.Append(handler);
115 handler->SetParentResource(this);
116}
117
118
119
120void wxXmlResource::ClearHandlers()
121{
122 m_handlers.Clear();
123}
124
125
126
127wxMenu *wxXmlResource::LoadMenu(const wxString& name)
128{
129 return (wxMenu*)CreateResFromNode(FindResource(name, wxT("wxMenu")), NULL, NULL);
130}
131
132
133
134wxMenuBar *wxXmlResource::LoadMenuBar(const wxString& name)
135{
136 return (wxMenuBar*)CreateResFromNode(FindResource(name, wxT("wxMenuBar")), NULL, NULL);
137}
138
139
140
141wxToolBar *wxXmlResource::LoadToolBar(wxWindow *parent, const wxString& name)
142{
143 return (wxToolBar*)CreateResFromNode(FindResource(name, wxT("wxToolBar")), parent, NULL);
144}
145
146
147
148wxDialog *wxXmlResource::LoadDialog(wxWindow *parent, const wxString& name)
149{
150 wxDialog *dialog = new wxDialog;
151 if (!LoadDialog(dialog, parent, name))
152 { delete dialog; return NULL; }
153 else return dialog;
154}
155
156bool wxXmlResource::LoadDialog(wxDialog *dlg, wxWindow *parent, const wxString& name)
157{
158 return CreateResFromNode(FindResource(name, wxT("wxDialog")), parent, dlg) != NULL;
159}
160
161
162
163wxPanel *wxXmlResource::LoadPanel(wxWindow *parent, const wxString& name)
164{
165 return (wxPanel*)CreateResFromNode(FindResource(name, wxT("wxPanel")), parent, NULL);
166}
167
168bool wxXmlResource::LoadPanel(wxPanel *panel, wxWindow *parent, const wxString& name)
169{
170 return CreateResFromNode(FindResource(name, wxT("wxPanel")), parent, panel) != NULL;
171}
172
173bool wxXmlResource::LoadFrame(wxFrame* frame, wxWindow *parent, const wxString& name)
174{
175 return CreateResFromNode(FindResource(name, wxT("wxFrame")), parent, frame) != NULL;
176}
177
178wxBitmap wxXmlResource::LoadBitmap(const wxString& name)
179{
180 wxBitmap *bmp = (wxBitmap*)CreateResFromNode(
181 FindResource(name, wxT("wxBitmap")), NULL, NULL);
182 wxBitmap rt;
183
184 if (bmp) { rt = *bmp; delete bmp; }
185 return rt;
186}
187
188wxIcon wxXmlResource::LoadIcon(const wxString& name)
189{
190 wxIcon *icon = (wxIcon*)CreateResFromNode(
191 FindResource(name, wxT("wxIcon")), NULL, NULL);
192 wxIcon rt;
193
194 if (icon) { rt = *icon; delete icon; }
195 return rt;
196}
197
198bool wxXmlResource::AttachUnknownControl(const wxString& name,
199 wxWindow *control, wxWindow *parent)
200{
201 if (parent == NULL)
202 parent = control->GetParent();
203 wxWindow *container = parent->FindWindow(name + wxT("_container"));
204 if (!container)
205 {
206 wxLogError(_("Cannot find container for unknown control '%s'."), name.c_str());
207 return FALSE;
208 }
209 return control->Reparent(container);
210}
211
212
77b2f9b1 213static void ProcessPlatformProperty(wxXmlNode *node)
78d14f80
VS		 214{
215 wxString s;
216 bool isok;
217
218 wxXmlNode *c = node->GetChildren();
219 while (c)
220 {
221 isok = FALSE;
222 if (!c->GetPropVal(wxT("platform"), &s))
223 isok = TRUE;
224 else
225 {
226 wxStringTokenizer tkn(s, " |");
227
228 while (tkn.HasMoreTokens())
229 {
230 s = tkn.GetNextToken();
231 if (
232#ifdef __WXMSW__
233 s == wxString(wxT("win"))
234#elif defined(__UNIX__)
235 s == wxString(wxT("unix"))
236#elif defined(__MAC__)
237 s == wxString(wxT("mac"))
238#elif defined(__OS2__)
239 s == wxString(wxT("os2"))
240#else
241 FALSE
242#endif
243 ) isok = TRUE;
244 }
245 }
246
247 if (isok)
d7b1d73c 248 {
78d14f80 249 ProcessPlatformProperty(c);
d7b1d73c
VS		 250 c = c->GetNext();
251 }
78d14f80
VS		 252 else
253 {
254 node->RemoveChild(c);
d7b1d73c 255 wxXmlNode *c2 = c->GetNext();
78d14f80 256 delete c;
d7b1d73c 257 c = c2;
78d14f80 258 }
78d14f80
VS		 259 }
260}
261
262
263
264void wxXmlResource::UpdateResources()
265{
266 bool modif;
267# if wxUSE_FILESYSTEM
268 wxFSFile *file = NULL;
269 wxFileSystem fsys;
270# endif
271
272 for (size_t i = 0; i < m_data.GetCount(); i++)
273 {
274 modif = (m_data[i].Doc == NULL);
275
276 if (!modif)
277 {
278# if wxUSE_FILESYSTEM
279 file = fsys.OpenFile(m_data[i].File);
280 modif = file && file->GetModificationTime() > m_data[i].Time;
281 if (!file)
282 wxLogError(_("Cannot open file '%s'."), m_data[i].File.c_str());
283 wxDELETE(file);
284# else
285 modif = wxDateTime(wxFileModificationTime(m_data[i].File)) > m_data[i].Time;
286# endif
287 }
288
289 if (modif)
290 {
291 wxInputStream *stream = NULL;
292
293# if wxUSE_FILESYSTEM
294 file = fsys.OpenFile(m_data[i].File);
295 if (file)
296 stream = file->GetStream();
297# else
298 stream = new wxFileInputStream(m_data[i].File);
299# endif
300
301 if (stream)
302 {
303 delete m_data[i].Doc;
304 m_data[i].Doc = new wxXmlDocument;
305 }
306 if (!stream || !m_data[i].Doc->Load(*stream))
307 {
308 wxLogError(_("Cannot load resources from file '%s'."), m_data[i].File.c_str());
309 wxDELETE(m_data[i].Doc);
310 }
311 else if (m_data[i].Doc->GetRoot()->GetName() != wxT("resource"))
312 {
313 wxLogError(_("Invalid XML resource '%s': doesn't have root node 'resource'."), m_data[i].File.c_str());
314 wxDELETE(m_data[i].Doc);
315 }
316 else
317 {
318 long version;
319 int v1, v2, v3, v4;
320 wxString verstr = m_data[i].Doc->GetRoot()->GetPropVal(
321 wxT("version"), wxT("0.0.0.0"));
322 if (wxSscanf(verstr.c_str(), wxT("%i.%i.%i.%i"),
323 &v1, &v2, &v3, &v4) == 4)
324 version = v1*256*256*256+v2*256*256+v3*256+v4;
325 else
326 version = 0;
327 if (m_version == -1)
328 m_version = version;
329 if (m_version != version)
330 wxLogError(_("Resource files must have same version number!"));
331
332 ProcessPlatformProperty(m_data[i].Doc->GetRoot());
333 m_data[i].Time = file->GetModificationTime();
334 }
335
336# if wxUSE_FILESYSTEM
337 wxDELETE(file);
338# else
339 wxDELETE(stream);
340# endif
341 }
342 }
343}
344
345
346
347wxXmlNode *wxXmlResource::FindResource(const wxString& name, const wxString& classname)
348{
349 UpdateResources(); //ensure everything is up-to-date
350
351 wxString dummy;
352 for (size_t f = 0; f < m_data.GetCount(); f++)
353 {
354 if (m_data[f].Doc == NULL || m_data[f].Doc->GetRoot() == NULL) continue;
355 for (wxXmlNode *node = m_data[f].Doc->GetRoot()->GetChildren();
356 node; node = node->GetNext())
357 if (node->GetType() == wxXML_ELEMENT_NODE &&
358 (!classname ||
359 node->GetPropVal(wxT("class"), wxEmptyString) == classname) &&
360 node->GetName() == wxT("object") &&
361 node->GetPropVal(wxT("name"), &dummy) &&
362 dummy == name)
363 {
364#if wxUSE_FILESYSTEM
365 m_curFileSystem.ChangePathTo(m_data[f].File);
366#endif
367 return node;
368 }
369 }
370
371 wxLogError(_("XML resource '%s' (class '%s') not found!"),
372 name.c_str(), classname.c_str());
373 return NULL;
374}
375
376
377
378wxObject *wxXmlResource::CreateResFromNode(wxXmlNode *node, wxObject *parent, wxObject *instance)
379{
380 if (node == NULL) return NULL;
381
382 wxXmlResourceHandler *handler;
383 wxObject *ret;
384 wxNode * ND = m_handlers.GetFirst();
385 while (ND)
386 {
387 handler = (wxXmlResourceHandler*)ND->GetData();
388 if (node->GetName() == wxT("object") && handler->CanHandle(node))
389 {
390 ret = handler->CreateResource(node, parent, instance);
391 if (ret) return ret;
392 }
393 ND = ND->GetNext();
394 }
395
396 wxLogError(_("No handler found for XML node '%s', class '%s'!"),
397 node->GetName().c_str(),
398 node->GetPropVal(wxT("class"), wxEmptyString).c_str());
399 return NULL;
400}
401
402
403
404
405
406
407
408
409
410wxXmlResourceHandler::wxXmlResourceHandler()
411 : m_node(NULL), m_parent(NULL), m_instance(NULL),
412 m_parentAsWindow(NULL), m_instanceAsWindow(NULL)
413{}
414
415
416
417wxObject *wxXmlResourceHandler::CreateResource(wxXmlNode *node, wxObject *parent, wxObject *instance)
418{
419 wxXmlNode *myNode = m_node;
420 wxString myClass = m_class;
421 wxObject *myParent = m_parent, *myInstance = m_instance;
422 wxWindow *myParentAW = m_parentAsWindow, *myInstanceAW = m_instanceAsWindow;
423
424 m_node = node;
425 m_class = node->GetPropVal(wxT("class"), wxEmptyString);
426 m_parent = parent;
427 m_instance = instance;
428 m_parentAsWindow = wxDynamicCast(m_parent, wxWindow);
429 m_instanceAsWindow = wxDynamicCast(m_instance, wxWindow);
430
431 wxObject *returned = DoCreateResource();
432
433 m_node = myNode;
434 m_class = myClass;
435 m_parent = myParent; m_parentAsWindow = myParentAW;
436 m_instance = myInstance; m_instanceAsWindow = myInstanceAW;
437
438 return returned;
439}
440
441
442void wxXmlResourceHandler::AddStyle(const wxString& name, int value)
443{
444 m_styleNames.Add(name);
445 m_styleValues.Add(value);
446}
447
448
449
450void wxXmlResourceHandler::AddWindowStyles()
451{
452 ADD_STYLE(wxSIMPLE_BORDER);
453 ADD_STYLE(wxSUNKEN_BORDER);
454 ADD_STYLE(wxDOUBLE_BORDER);
455 ADD_STYLE(wxRAISED_BORDER);
456 ADD_STYLE(wxSTATIC_BORDER);
457 ADD_STYLE(wxNO_BORDER);
458 ADD_STYLE(wxTRANSPARENT_WINDOW);
459 ADD_STYLE(wxWANTS_CHARS);
460 ADD_STYLE(wxNO_FULL_REPAINT_ON_RESIZE);
461}
462
463
464
465bool wxXmlResourceHandler::HasParam(const wxString& param)
466{
467 return (GetParamNode(param) != NULL);
468}
469
470
471int wxXmlResourceHandler::GetStyle(const wxString& param, int defaults)
472{
473 wxString s = GetParamValue(param);
474
475 if (!s) return defaults;
476
477 wxStringTokenizer tkn(s, wxT("| "), wxTOKEN_STRTOK);
478 int style = 0;
479 int index;
480 wxString fl;
481 while (tkn.HasMoreTokens())
482 {
483 fl = tkn.GetNextToken();
484 index = m_styleNames.Index(fl);
485 if (index != wxNOT_FOUND)
486 style |= m_styleValues[index];
487 else
488 wxLogError(_("Unknown style flag ") + fl);
489 }
490 return style;
491}
492
493
494
495wxString wxXmlResourceHandler::GetText(const wxString& param)
496{
497 wxString str1 = GetParamValue(param);
498 wxString str2;
499 const wxChar *dt;
500 wxChar amp_char;
501
502 // VS: First version of XML resources used $ instead of & (which is illegal in XML),
503 // but later I realized that '_' fits this purpose much better (because
504 // &File means "File with F underlined").
505 if (m_resource->CompareVersion(2,3,0,1) < 0)
506 amp_char = wxT('$');
507 else
508 amp_char = wxT('_');
509
510 for (dt = str1.c_str(); *dt; dt++)
511 {
512 // Remap amp_char to &, map double amp_char to amp_char (for things
513 // like "&File..." -- this is illegal in XML, so we use "_File..."):
514 if (*dt == amp_char)
515 {
516 if ( *(++dt) == amp_char )
517 str2 << amp_char;
518 else
519 str2 << wxT('&') << *dt;
520 }
521 // Remap \n to CR, \r to LF, \t to TAB:
522 else if (*dt == wxT('\\'))
523 switch (*(++dt))
524 {
525 case wxT('n') : str2 << wxT('\n'); break;
526 case wxT('t') : str2 << wxT('\t'); break;
527 case wxT('r') : str2 << wxT('\r'); break;
528 default : str2 << wxT('\\') << *dt; break;
529 }
530 else str2 << *dt;
531 }
532
533 if (m_resource->GetUseLocale())
534 return wxGetTranslation(str2);
535 else
536 return str2;
537}
538
539
540
541long wxXmlResourceHandler::GetLong(const wxString& param, long defaultv)
542{
543 long value;
544 wxString str1 = GetParamValue(param);
545
546 if (!str1.ToLong(&value))
547 value = defaultv;
548
549 return value;
550}
551
552
553int wxXmlResourceHandler::GetID()
554{
555 wxString sid = GetName();
556 long num;
557
558 if (sid == wxT("-1")) return -1;
559 else if (sid.IsNumber() && sid.ToLong(&num)) return num;
560#define stdID(id) else if (sid == wxT(#id)) return id
561 stdID(wxID_OPEN); stdID(wxID_CLOSE); stdID(wxID_NEW);
562 stdID(wxID_SAVE); stdID(wxID_SAVEAS); stdID(wxID_REVERT);
563 stdID(wxID_EXIT); stdID(wxID_UNDO); stdID(wxID_REDO);
564 stdID(wxID_HELP); stdID(wxID_PRINT); stdID(wxID_PRINT_SETUP);
565 stdID(wxID_PREVIEW); stdID(wxID_ABOUT); stdID(wxID_HELP_CONTENTS);
566 stdID(wxID_HELP_COMMANDS); stdID(wxID_HELP_PROCEDURES);
567 stdID(wxID_CUT); stdID(wxID_COPY); stdID(wxID_PASTE);
568 stdID(wxID_CLEAR); stdID(wxID_FIND); stdID(wxID_DUPLICATE);
569 stdID(wxID_SELECTALL); stdID(wxID_OK); stdID(wxID_CANCEL);
570 stdID(wxID_APPLY); stdID(wxID_YES); stdID(wxID_NO);
571 stdID(wxID_STATIC); stdID(wxID_FORWARD); stdID(wxID_BACKWARD);
572 stdID(wxID_DEFAULT); stdID(wxID_MORE); stdID(wxID_SETUP);
573 stdID(wxID_RESET); stdID(wxID_HELP_CONTEXT);
574#undef stdID
00393283 575 else return wxXmlResource::GetXMLID(sid);
78d14f80
VS		 576}
577
578
579wxString wxXmlResourceHandler::GetName()
580{
581 return m_node->GetPropVal(wxT("name"), wxT("-1"));
582}
583
584
585
586bool wxXmlResourceHandler::GetBool(const wxString& param, bool defaultv)
587{
588 wxString v = GetParamValue(param);
589 v.MakeLower();
590 if (!v) return defaultv;
591 else return (v == wxT("1"));
592}
593
594
595
596wxColour wxXmlResourceHandler::GetColour(const wxString& param)
597{
598 wxString v = GetParamValue(param);
599 unsigned long tmp = 0;
600
601 if (v.Length() != 7 || v[0u] != wxT('#') ||
602 wxSscanf(v.c_str(), wxT("#%lX"), &tmp) != 1)
603 {
604 wxLogError(_("XML resource: Incorrect colour specification '%s' for property '%s'."),
605 v.c_str(), param.c_str());
606 return wxNullColour;
607 }
608
609 return wxColour((unsigned char) ((tmp & 0xFF0000) >> 16) ,
610 (unsigned char) ((tmp & 0x00FF00) >> 8),
611 (unsigned char) ((tmp & 0x0000FF)));
612}
613
614
615
616wxBitmap wxXmlResourceHandler::GetBitmap(const wxString& param, wxSize size)
617{
618 wxString name = GetParamValue(param);
619 if (name.IsEmpty()) return wxNullBitmap;
620#if wxUSE_FILESYSTEM
621 wxFSFile *fsfile = GetCurFileSystem().OpenFile(name);
622 if (fsfile == NULL)
623 {
00393283 624 wxLogError(_("XML resource: Cannot create bitmap from '%s'."), param.c_str());
78d14f80
VS		 625 return wxNullBitmap;
626 }
627 wxImage img(*(fsfile->GetStream()));
628 delete fsfile;
629#else
630 wxImage img(GetParamValue(wxT("bitmap")));
631#endif
632 if (!img.Ok())
633 {
00393283 634 wxLogError(_("XML resource: Cannot create bitmap from '%s'."), param.c_str());
78d14f80
VS		 635 return wxNullBitmap;
636 }
637 if (!(size == wxDefaultSize)) img.Rescale(size.x, size.y);
638 return img.ConvertToBitmap();
639}
640
641
642
643wxIcon wxXmlResourceHandler::GetIcon(const wxString& param, wxSize size)
644{
645#if wxCHECK_VERSION(2,3,0) || defined(__WXMSW__)
646 wxIcon icon;
647 icon.CopyFromBitmap(GetBitmap(param, size));
648#else
649 wxIcon *iconpt;
650 wxBitmap bmppt = GetBitmap(param, size);
651 iconpt = (wxIcon*)(&bmppt);
652 wxIcon icon(*iconpt);
653#endif
654 return icon;
655}
656
657
658
659wxXmlNode *wxXmlResourceHandler::GetParamNode(const wxString& param)
660{
661 wxXmlNode *n = m_node->GetChildren();
662
663 while (n)
664 {
665 if (n->GetType() == wxXML_ELEMENT_NODE && n->GetName() == param)
666 return n;
667 n = n->GetNext();
668 }
669 return NULL;
670}
671
672
673wxString wxXmlResourceHandler::GetNodeContent(wxXmlNode *node)
674{
675 wxXmlNode *n = node;
676 if (n == NULL) return wxEmptyString;
677 n = n->GetChildren();
678
679 while (n)
680 {
681 if (n->GetType() == wxXML_TEXT_NODE ||
682 n->GetType() == wxXML_CDATA_SECTION_NODE)
683 return n->GetContent();
684 n = n->GetNext();
685 }
686 return wxEmptyString;
687}
688
689
690
691wxString wxXmlResourceHandler::GetParamValue(const wxString& param)
692{
693 if (param.IsEmpty())
694 return GetNodeContent(m_node);
695 else
696 return GetNodeContent(GetParamNode(param));
697}
698
699
700
701wxSize wxXmlResourceHandler::GetSize(const wxString& param)
702{
703 wxString s = GetParamValue(param);
704 if (s.IsEmpty()) s = wxT("-1,-1");
705 bool is_dlg;
706 long sx, sy;
707
708 is_dlg = s[s.Length()-1] == wxT('d');
709 if (is_dlg) s.RemoveLast();
710
711 if (!s.BeforeFirst(wxT(',')).ToLong(&sx) ||
712 !s.AfterLast(wxT(',')).ToLong(&sy))
713 {
00393283 714 wxLogError(_("Cannot parse coordinates from '%s'."), s.c_str());
78d14f80
VS		 715 return wxDefaultSize;
716 }
717
718 if (is_dlg)
719 {
720 if (m_instanceAsWindow)
721 return wxDLG_UNIT(m_instanceAsWindow, wxSize(sx, sy));
722 else if (m_parentAsWindow)
723 return wxDLG_UNIT(m_parentAsWindow, wxSize(sx, sy));
724 else
725 {
726 wxLogError(_("Cannot convert dialog units: dialog unknown."));
727 return wxDefaultSize;
728 }
729 }
730 else return wxSize(sx, sy);
731}
732
733
734
735wxPoint wxXmlResourceHandler::GetPosition(const wxString& param)
736{
737 wxSize sz = GetSize(param);
738 return wxPoint(sz.x, sz.y);
739}
740
741
742
743wxCoord wxXmlResourceHandler::GetDimension(const wxString& param, wxCoord defaultv)
744{
745 wxString s = GetParamValue(param);
746 if (s.IsEmpty()) return defaultv;
747 bool is_dlg;
748 long sx;
749
750 is_dlg = s[s.Length()-1] == wxT('d');
751 if (is_dlg) s.RemoveLast();
752
753 if (!s.ToLong(&sx))
754 {
00393283 755 wxLogError(_("Cannot parse dimension from '%s'."), s.c_str());
78d14f80
VS		 756 return defaultv;
757 }
758
759 if (is_dlg)
760 {
761 if (m_instanceAsWindow)
762 return wxDLG_UNIT(m_instanceAsWindow, wxSize(sx, 0)).x;
763 else if (m_parentAsWindow)
764 return wxDLG_UNIT(m_parentAsWindow, wxSize(sx, 0)).x;
765 else
766 {
767 wxLogError(_("Cannot convert dialog units: dialog unknown."));
768 return defaultv;
769 }
770 }
771 else return sx;
772}
773
774
775
776wxFont wxXmlResourceHandler::GetFont(const wxString& param)
777{
778 wxXmlNode *font_node = GetParamNode(param);
779 if (font_node == NULL)
780 {
00393283 781 wxLogError(_("Cannot find font node '%s'."), param.c_str());
78d14f80
VS		 782 return wxNullFont;
783 }
784
785 wxXmlNode *oldnode = m_node;
786 m_node = font_node;
787
788 long size = GetLong(wxT("size"), 12);
789
790 wxString style = GetParamValue(wxT("style"));
791 wxString weight = GetParamValue(wxT("weight"));
792 int istyle = wxNORMAL, iweight = wxNORMAL;
793 if (style == wxT("italic")) istyle = wxITALIC;
794 else if (style == wxT("slant")) istyle = wxSLANT;
795 if (weight == wxT("bold")) iweight = wxBOLD;
796 else if (weight == wxT("light")) iweight = wxLIGHT;
797
798 wxString family = GetParamValue(wxT("family"));
799 int ifamily = wxDEFAULT;
800 if (family == wxT("decorative")) ifamily = wxDECORATIVE;
801 else if (family == wxT("roman")) ifamily = wxROMAN;
802 else if (family == wxT("script")) ifamily = wxSCRIPT;
803 else if (family == wxT("swiss")) ifamily = wxSWISS;
804 else if (family == wxT("modern")) ifamily = wxMODERN;
805
806 bool underlined = GetBool(wxT("underlined"), FALSE);
807
808 wxString encoding = GetParamValue(wxT("encoding"));
809 wxFontMapper mapper;
810 wxFontEncoding enc = wxFONTENCODING_DEFAULT;
91cddacf
VS		 811 if (!encoding.IsEmpty())
812 enc = mapper.CharsetToEncoding(encoding);
813 if (enc == wxFONTENCODING_SYSTEM)
814 enc = wxFONTENCODING_DEFAULT;
78d14f80
VS		 815
816 wxString faces = GetParamValue(wxT("face"));
817 wxString facename = wxEmptyString;
818 wxFontEnumerator enu;
819 enu.EnumerateFacenames();
820 wxStringTokenizer tk(faces, wxT(","));
821 while (tk.HasMoreTokens())
822 {
823 int index = enu.GetFacenames()->Index(tk.GetNextToken(), FALSE);
824 if (index != wxNOT_FOUND)
825 {
826 facename = (*enu.GetFacenames())[index];
827 break;
828 }
829 }
830
831 m_node = oldnode;
832
833 wxFont font(size, ifamily, istyle, iweight, underlined, facename, enc);
834 return font;
835}
836
837
838void wxXmlResourceHandler::SetupWindow(wxWindow *wnd)
839{
840 //FIXME : add cursor
841
842 if (HasParam(wxT("exstyle")))
843 wnd->SetExtraStyle(GetStyle(wxT("exstyle")));
844 if (HasParam(wxT("bg")))
845 wnd->SetBackgroundColour(GetColour(wxT("bg")));
846 if (HasParam(wxT("fg")))
847 wnd->SetForegroundColour(GetColour(wxT("fg")));
848 if (GetBool(wxT("enabled"), 1) == 0)
849 wnd->Enable(FALSE);
850 if (GetBool(wxT("focused"), 0) == 1)
851 wnd->SetFocus();
852 if (GetBool(wxT("hidden"), 0) == 1)
853 wnd->Show(FALSE);
854#if wxUSE_TOOLTIPS
855 if (HasParam(wxT("tooltip")))
856 wnd->SetToolTip(GetText(wxT("tooltip")));
857#endif
858 if (HasParam(wxT("font")))
859 wnd->SetFont(GetFont());
860}
861
862
863void wxXmlResourceHandler::CreateChildren(wxObject *parent, bool this_hnd_only)
864{
865 wxXmlNode *n = m_node->GetChildren();
866
867 while (n)
868 {
869 if (n->GetType() == wxXML_ELEMENT_NODE &&
870 n->GetName() == wxT("object"))
871 {
872 if (this_hnd_only && CanHandle(n))
873 CreateResource(n, parent, NULL);
874 else
875 m_resource->CreateResFromNode(n, parent, NULL);
876 }
877 n = n->GetNext();
878 }
879}
880
881
882void wxXmlResourceHandler::CreateChildrenPrivately(wxObject *parent, wxXmlNode *rootnode)
883{
884 wxXmlNode *root;
885 if (rootnode == NULL) root = m_node; else root = rootnode;
886 wxXmlNode *n = root->GetChildren();
887
888 while (n)
889 {
890 if (n->GetType() == wxXML_ELEMENT_NODE && CanHandle(n))
891 {
892 CreateResource(n, parent, NULL);
893 }
894 n = n->GetNext();
895 }
896}
897
898
899
900
901
902
903
904// --------------- XMLID implementation -----------------------------
905
906#define XMLID_TABLE_SIZE 1024
907
908
909struct XMLID_record
910{
911 int id;
00393283 912 wxChar *key;
78d14f80
VS		 913 XMLID_record *next;
914};
915
916static XMLID_record *XMLID_Records[XMLID_TABLE_SIZE] = {NULL};
917
00393283 918/*static*/ int wxXmlResource::GetXMLID(const wxChar *str_id)
78d14f80
VS		 919{
920 static int XMLID_LastID = wxID_HIGHEST;
921
922 int index = 0;
923
00393283 924 for (const wxChar *c = str_id; *c != wxT('\0'); c++) index += (int)*c;
78d14f80
VS		 925 index %= XMLID_TABLE_SIZE;
926
927 XMLID_record *oldrec = NULL;
928 int matchcnt = 0;
929 for (XMLID_record *rec = XMLID_Records[index]; rec; rec = rec->next)
930 {
00393283 931 if (wxStrcmp(rec->key, str_id) == 0)
78d14f80
VS		 932 {
933 return rec->id;
934 }
935 matchcnt++;
936 oldrec = rec;
937 }
938
939 XMLID_record **rec_var = (oldrec == NULL) ?
940 &XMLID_Records[index] : &oldrec->next;
941 *rec_var = new XMLID_record;
942 (*rec_var)->id = ++XMLID_LastID;
00393283 943 (*rec_var)->key = wxStrdup(str_id);
78d14f80
VS		 944 (*rec_var)->next = NULL;
945
946 return (*rec_var)->id;
947}
948
949
950static void CleanXMLID_Record(XMLID_record *rec)
951{
952 if (rec)
953 {
954 CleanXMLID_Record(rec->next);
00393283 955 free(rec->key);
78d14f80
VS		 956 delete rec;
957 }
958}
959
960static void CleanXMLID_Records()
961{
962 for (int i = 0; i < XMLID_TABLE_SIZE; i++)
963 CleanXMLID_Record(XMLID_Records[i]);
964}
965
966
967
968
969
970
971
972
973// --------------- module and globals -----------------------------
974
975
976static wxXmlResource gs_XmlResource;
977
978wxXmlResource *wxTheXmlResource = &gs_XmlResource;
979
980
981class wxXmlResourceModule: public wxModule
982{
983DECLARE_DYNAMIC_CLASS(wxXmlResourceModule)
984public:
985 wxXmlResourceModule() {}
986 bool OnInit() {return TRUE;}
987 void OnExit()
988 {
989 wxTheXmlResource->ClearHandlers();
990 CleanXMLID_Records();
991 }
992};
993
994IMPLEMENT_DYNAMIC_CLASS(wxXmlResourceModule, wxModule)
995
996
997// When wxXml is loaded dynamically after the application is already running
998// then the built-in module system won't pick this one up. Add it manually.
999void wxXmlInitResourceModule()
1000{
1001 wxModule* module = new wxXmlResourceModule;
1002 module->Init();
1003 wxModule::RegisterModule(module);
1004}
1005
1006
wxWidgets (Impactor)