1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: XRC resources
4 // Author: Vaclav Slavik
7 // Copyright: (c) 2000 Vaclav Slavik
8 // Licence: wxWindows licence
9 /////////////////////////////////////////////////////////////////////////////
11 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
12 #pragma implementation "xmlres.h"
15 // For compilers that support precompilation, includes "wx.h".
16 #include "wx/wxprec.h"
28 #include "wx/dialog.h"
31 #include "wx/wfstream.h"
32 #include "wx/filesys.h"
33 #include "wx/filename.h"
36 #include "wx/tokenzr.h"
37 #include "wx/fontenum.h"
38 #include "wx/module.h"
39 #include "wx/bitmap.h"
41 #include "wx/fontmap.h"
42 #include "wx/artprov.h"
43 #include "wx/settings.h"
45 #include "wx/xml/xml.h"
46 #include "wx/xrc/xmlres.h"
48 #include "wx/arrimpl.cpp"
49 WX_DEFINE_OBJARRAY(wxXmlResourceDataRecords
);
52 wxXmlResource
*wxXmlResource
::ms_instance
= NULL
;
54 /*static*/ wxXmlResource
*wxXmlResource
::Get()
57 ms_instance
= new wxXmlResource
;
61 /*static*/ wxXmlResource
*wxXmlResource
::Set(wxXmlResource
*res
)
63 wxXmlResource
*old
= ms_instance
;
68 wxXmlResource
::wxXmlResource(int flags
)
74 wxXmlResource
::wxXmlResource(const wxString
& filemask
, int flags
)
81 wxXmlResource
::~wxXmlResource()
87 bool wxXmlResource
::Load(const wxString
& filemask
)
90 wxXmlResourceDataRecord
*drec
;
91 bool iswild
= wxIsWild(filemask
);
96 # define wxXmlFindFirst fsys.FindFirst(filemask, wxFILE)
97 # define wxXmlFindNext fsys.FindNext()
99 # define wxXmlFindFirst wxFindFirstFile(filemask, wxFILE)
100 # define wxXmlFindNext wxFindNextFile()
103 fnd
= wxXmlFindFirst
;
108 // NB: Load() accepts both filenames and URLs (should probably be
109 // changed to filenames only, but embedded resources currently
110 // rely on its ability to handle URLs - FIXME). This check
111 // serves as a quick way to determine whether found name is
112 // filename and not URL:
113 if (wxFileName
::FileExists(fnd
))
115 // Make the name absolute filename, because the app may
116 // change working directory later:
121 fnd
= fn
.GetFullPath();
124 fnd
= wxFileSystem
::FileNameToURL(fnd
);
129 if (fnd
.Lower().Matches(wxT("*.zip")) ||
130 fnd
.Lower().Matches(wxT("*.xrs")))
132 rt
= rt
&& Load(fnd
+ wxT("#zip:*.xrc"));
137 drec
= new wxXmlResourceDataRecord
;
147 # undef wxXmlFindFirst
148 # undef wxXmlFindNext
149 return rt
&& UpdateResources();
153 IMPLEMENT_ABSTRACT_CLASS(wxXmlResourceHandler
, wxObject
)
155 void wxXmlResource
::AddHandler(wxXmlResourceHandler
*handler
)
157 m_handlers
.Append(handler
);
158 handler
->SetParentResource(this);
161 void wxXmlResource
::InsertHandler(wxXmlResourceHandler
*handler
)
163 m_handlers
.Insert(handler
);
164 handler
->SetParentResource(this);
169 void wxXmlResource
::ClearHandlers()
171 WX_CLEAR_LIST(wxList
, m_handlers
);
175 wxMenu
*wxXmlResource
::LoadMenu(const wxString
& name
)
177 return (wxMenu
*)CreateResFromNode(FindResource(name
, wxT("wxMenu")), NULL
, NULL
);
182 wxMenuBar
*wxXmlResource
::LoadMenuBar(wxWindow
*parent
, const wxString
& name
)
184 return (wxMenuBar
*)CreateResFromNode(FindResource(name
, wxT("wxMenuBar")), parent
, NULL
);
190 wxToolBar
*wxXmlResource
::LoadToolBar(wxWindow
*parent
, const wxString
& name
)
192 return (wxToolBar
*)CreateResFromNode(FindResource(name
, wxT("wxToolBar")), parent
, NULL
);
197 wxDialog
*wxXmlResource
::LoadDialog(wxWindow
*parent
, const wxString
& name
)
199 return (wxDialog
*)CreateResFromNode(FindResource(name
, wxT("wxDialog")), parent
, NULL
);
202 bool wxXmlResource
::LoadDialog(wxDialog
*dlg
, wxWindow
*parent
, const wxString
& name
)
204 return CreateResFromNode(FindResource(name
, wxT("wxDialog")), parent
, dlg
) != NULL
;
209 wxPanel
*wxXmlResource
::LoadPanel(wxWindow
*parent
, const wxString
& name
)
211 return (wxPanel
*)CreateResFromNode(FindResource(name
, wxT("wxPanel")), parent
, NULL
);
214 bool wxXmlResource
::LoadPanel(wxPanel
*panel
, wxWindow
*parent
, const wxString
& name
)
216 return CreateResFromNode(FindResource(name
, wxT("wxPanel")), parent
, panel
) != NULL
;
219 wxFrame
*wxXmlResource
::LoadFrame(wxWindow
* parent
, const wxString
& name
)
221 return (wxFrame
*)CreateResFromNode(FindResource(name
, wxT("wxFrame")), parent
, NULL
);
224 bool wxXmlResource
::LoadFrame(wxFrame
* frame
, wxWindow
*parent
, const wxString
& name
)
226 return CreateResFromNode(FindResource(name
, wxT("wxFrame")), parent
, frame
) != NULL
;
229 wxBitmap wxXmlResource
::LoadBitmap(const wxString
& name
)
231 wxBitmap
*bmp
= (wxBitmap
*)CreateResFromNode(
232 FindResource(name
, wxT("wxBitmap")), NULL
, NULL
);
235 if (bmp
) { rt
= *bmp
; delete bmp
; }
239 wxIcon wxXmlResource
::LoadIcon(const wxString
& name
)
241 wxIcon
*icon
= (wxIcon
*)CreateResFromNode(
242 FindResource(name
, wxT("wxIcon")), NULL
, NULL
);
245 if (icon
) { rt
= *icon
; delete icon
; }
250 wxObject
*wxXmlResource
::LoadObject(wxWindow
*parent
, const wxString
& name
, const wxString
& classname
)
252 return CreateResFromNode(FindResource(name
, classname
), parent
, NULL
);
255 bool wxXmlResource
::LoadObject(wxObject
*instance
, wxWindow
*parent
, const wxString
& name
, const wxString
& classname
)
257 return CreateResFromNode(FindResource(name
, classname
), parent
, instance
) != NULL
;
261 bool wxXmlResource
::AttachUnknownControl(const wxString
& name
,
262 wxWindow
*control
, wxWindow
*parent
)
265 parent
= control
->GetParent();
266 wxWindow
*container
= parent
->FindWindow(name
+ wxT("_container"));
269 wxLogError(_("Cannot find container for unknown control '%s'."), name
.c_str());
272 return control
->Reparent(container
);
276 static void ProcessPlatformProperty(wxXmlNode
*node
)
281 wxXmlNode
*c
= node
->GetChildren();
285 if (!c
->GetPropVal(wxT("platform"), &s
))
289 wxStringTokenizer
tkn(s
, wxT(" |"));
291 while (tkn
.HasMoreTokens())
293 s
= tkn
.GetNextToken();
295 if (s
== wxT("win")) isok
= true;
297 #if defined(__MAC__) || defined(__APPLE__)
298 if (s
== wxT("mac")) isok
= true;
299 #elif defined(__UNIX__)
300 if (s
== wxT("unix")) isok
= true;
303 if (s
== wxT("os2")) isok
= true;
313 ProcessPlatformProperty(c
);
318 wxXmlNode
*c2
= c
->GetNext();
319 node
->RemoveChild(c
);
328 bool wxXmlResource
::UpdateResources()
332 # if wxUSE_FILESYSTEM
333 wxFSFile
*file
= NULL
;
338 wxString
encoding(wxT("UTF-8"));
339 #if !wxUSE_UNICODE && wxUSE_INTL
340 if ( (GetFlags() & wxXRC_USE_LOCALE
) == 0 )
342 // In case we are not using wxLocale to translate strings, convert the
343 // strings GUI's charset. This must not be done when wxXRC_USE_LOCALE
344 // is on, because it could break wxGetTranslation lookup.
345 encoding
= wxLocale
::GetSystemEncodingName();
349 for (size_t i
= 0; i
< m_data
.GetCount(); i
++)
351 modif
= (m_data
[i
].Doc
== NULL
);
353 if (!modif
&& !(m_flags
& wxXRC_NO_RELOADING
))
355 # if wxUSE_FILESYSTEM
356 file
= fsys
.OpenFile(m_data
[i
].File
);
357 modif
= file
&& file
->GetModificationTime() > m_data
[i
].Time
;
360 wxLogError(_("Cannot open file '%s'."), m_data
[i
].File
.c_str());
366 modif
= wxDateTime(wxFileModificationTime(m_data
[i
].File
)) > m_data
[i
].Time
;
372 wxLogTrace(_T("xrc"),
373 _T("opening file '%s'"), m_data
[i
].File
.c_str());
375 wxInputStream
*stream
= NULL
;
377 # if wxUSE_FILESYSTEM
378 file
= fsys
.OpenFile(m_data
[i
].File
);
380 stream
= file
->GetStream();
382 stream
= new wxFileInputStream(m_data
[i
].File
);
387 delete m_data
[i
].Doc
;
388 m_data
[i
].Doc
= new wxXmlDocument
;
390 if (!stream
|| !m_data
[i
].Doc
->Load(*stream
, encoding
))
392 wxLogError(_("Cannot load resources from file '%s'."),
393 m_data
[i
].File
.c_str());
394 wxDELETE(m_data
[i
].Doc
);
397 else if (m_data
[i
].Doc
->GetRoot()->GetName() != wxT("resource"))
399 wxLogError(_("Invalid XRC resource '%s': doesn't have root node 'resource'."), m_data
[i
].File
.c_str());
400 wxDELETE(m_data
[i
].Doc
);
407 wxString verstr
= m_data
[i
].Doc
->GetRoot()->GetPropVal(
408 wxT("version"), wxT("0.0.0.0"));
409 if (wxSscanf(verstr
.c_str(), wxT("%i.%i.%i.%i"),
410 &v1
, &v2
, &v3
, &v4
) == 4)
411 version
= v1
*256*256*256+v2
*256*256+v3
*256+v4
;
416 if (m_version
!= version
)
418 wxLogError(_("Resource files must have same version number!"));
422 ProcessPlatformProperty(m_data
[i
].Doc
->GetRoot());
424 m_data
[i
].Time
= file
->GetModificationTime();
426 m_data
[i
].Time
= wxDateTime(wxFileModificationTime(m_data
[i
].File
));
430 # if wxUSE_FILESYSTEM
443 wxXmlNode
*wxXmlResource
::DoFindResource(wxXmlNode
*parent
,
444 const wxString
& name
,
445 const wxString
& classname
,
451 // first search for match at the top-level nodes (as this is
452 // where the resource is most commonly looked for):
453 for (node
= parent
->GetChildren(); node
; node
= node
->GetNext())
455 if ( node
->GetType() == wxXML_ELEMENT_NODE
&&
456 (node
->GetName() == wxT("object") ||
457 node
->GetName() == wxT("object_ref")) &&
458 node
->GetPropVal(wxT("name"), &dummy
) && dummy
== name
)
460 wxString
cls(node
->GetPropVal(wxT("class"), wxEmptyString
));
461 if (!classname
|| cls
== classname
)
463 // object_ref may not have 'class' property:
464 if (cls
.empty() && node
->GetName() == wxT("object_ref"))
466 wxString refName
= node
->GetPropVal(wxT("ref"), wxEmptyString
);
469 wxXmlNode
* refNode
= FindResource(refName
, wxEmptyString
, true);
471 refNode
->GetPropVal(wxT("class"), wxEmptyString
) == classname
)
480 for (node
= parent
->GetChildren(); node
; node
= node
->GetNext())
482 if ( node
->GetType() == wxXML_ELEMENT_NODE
&&
483 (node
->GetName() == wxT("object") ||
484 node
->GetName() == wxT("object_ref")) )
486 wxXmlNode
* found
= DoFindResource(node
, name
, classname
, true);
495 wxXmlNode
*wxXmlResource
::FindResource(const wxString
& name
,
496 const wxString
& classname
,
499 UpdateResources(); //ensure everything is up-to-date
502 for (size_t f
= 0; f
< m_data
.GetCount(); f
++)
504 if ( m_data
[f
].Doc
== NULL
|| m_data
[f
].Doc
->GetRoot() == NULL
)
507 wxXmlNode
* found
= DoFindResource(m_data
[f
].Doc
->GetRoot(),
508 name
, classname
, recursive
);
512 m_curFileSystem
.ChangePathTo(m_data
[f
].File
);
518 wxLogError(_("XRC resource '%s' (class '%s') not found!"),
519 name
.c_str(), classname
.c_str());
523 static void MergeNodes(wxXmlNode
& dest
, wxXmlNode
& with
)
526 for (wxXmlProperty
*prop
= with
.GetProperties(); prop
; prop
= prop
->GetNext())
528 wxXmlProperty
*dprop
;
529 for (dprop
= dest
.GetProperties(); dprop
; dprop
= dprop
->GetNext())
532 if ( dprop
->GetName() == prop
->GetName() )
534 dprop
->SetValue(prop
->GetValue());
540 dest
.AddProperty(prop
->GetName(), prop
->GetValue());
543 // Merge child nodes:
544 for (wxXmlNode
* node
= with
.GetChildren(); node
; node
= node
->GetNext())
546 wxString name
= node
->GetPropVal(wxT("name"), wxEmptyString
);
549 for (dnode
= dest
.GetChildren(); dnode
; dnode
= dnode
->GetNext() )
551 if ( dnode
->GetName() == node
->GetName() &&
552 dnode
->GetPropVal(wxT("name"), wxEmptyString
) == name
&&
553 dnode
->GetType() == node
->GetType() )
555 MergeNodes(*dnode
, *node
);
561 dest
.AddChild(new wxXmlNode(*node
));
564 if ( dest
.GetType() == wxXML_TEXT_NODE
&& with
.GetContent().Length() )
565 dest
.SetContent(with
.GetContent());
568 wxObject
*wxXmlResource
::CreateResFromNode(wxXmlNode
*node
, wxObject
*parent
,
570 wxXmlResourceHandler
*handlerToUse
)
572 if (node
== NULL
) return NULL
;
574 // handling of referenced resource
575 if ( node
->GetName() == wxT("object_ref") )
577 wxString refName
= node
->GetPropVal(wxT("ref"), wxEmptyString
);
578 wxXmlNode
* refNode
= FindResource(refName
, wxEmptyString
, true);
582 wxLogError(_("Referenced object node with ref=\"%s\" not found!"),
587 wxXmlNode
copy(*refNode
);
588 MergeNodes(copy
, *node
);
590 return CreateResFromNode(©
, parent
, instance
);
593 wxXmlResourceHandler
*handler
;
597 if (handlerToUse
->CanHandle(node
))
599 return handlerToUse
->CreateResource(node
, parent
, instance
);
602 else if (node
->GetName() == wxT("object"))
604 wxList
::compatibility_iterator ND
= m_handlers
.GetFirst();
607 handler
= (wxXmlResourceHandler
*)ND
->GetData();
608 if (handler
->CanHandle(node
))
610 return handler
->CreateResource(node
, parent
, instance
);
616 wxLogError(_("No handler found for XML node '%s', class '%s'!"),
617 node
->GetName().c_str(),
618 node
->GetPropVal(wxT("class"), wxEmptyString
).c_str());
623 #include "wx/listimpl.cpp"
624 WX_DECLARE_LIST(wxXmlSubclassFactory
, wxXmlSubclassFactoriesList
);
625 WX_DEFINE_LIST(wxXmlSubclassFactoriesList
);
627 wxXmlSubclassFactoriesList
*wxXmlResource
::ms_subclassFactories
= NULL
;
629 /*static*/ void wxXmlResource
::AddSubclassFactory(wxXmlSubclassFactory
*factory
)
631 if (!ms_subclassFactories
)
633 ms_subclassFactories
= new wxXmlSubclassFactoriesList
;
635 ms_subclassFactories
->Append(factory
);
638 class wxXmlSubclassFactoryCXX
: public wxXmlSubclassFactory
641 ~wxXmlSubclassFactoryCXX() {}
643 wxObject
*Create(const wxString
& className
)
645 wxClassInfo
* classInfo
= wxClassInfo
::FindClass(className
);
648 return classInfo
->CreateObject();
657 wxXmlResourceHandler
::wxXmlResourceHandler()
658 : m_node(NULL
), m_parent(NULL
), m_instance(NULL
),
659 m_parentAsWindow(NULL
)
664 wxObject
*wxXmlResourceHandler
::CreateResource(wxXmlNode
*node
, wxObject
*parent
, wxObject
*instance
)
666 wxXmlNode
*myNode
= m_node
;
667 wxString myClass
= m_class
;
668 wxObject
*myParent
= m_parent
, *myInstance
= m_instance
;
669 wxWindow
*myParentAW
= m_parentAsWindow
;
671 m_instance
= instance
;
672 if (!m_instance
&& node
->HasProp(wxT("subclass")) &&
673 !(m_resource
->GetFlags() & wxXRC_NO_SUBCLASSING
))
675 wxString subclass
= node
->GetPropVal(wxT("subclass"), wxEmptyString
);
676 if (!subclass
.empty())
678 for (wxXmlSubclassFactoriesList
::compatibility_iterator i
= wxXmlResource
::ms_subclassFactories
->GetFirst();
681 m_instance
= i
->GetData()->Create(subclass
);
688 wxString name
= node
->GetPropVal(wxT("name"), wxEmptyString
);
689 wxLogError(_("Subclass '%s' not found for resource '%s', not subclassing!"),
690 subclass
.c_str(), name
.c_str());
696 m_class
= node
->GetPropVal(wxT("class"), wxEmptyString
);
698 m_parentAsWindow
= wxDynamicCast(m_parent
, wxWindow
);
700 wxObject
*returned
= DoCreateResource();
704 m_parent
= myParent
; m_parentAsWindow
= myParentAW
;
705 m_instance
= myInstance
;
711 void wxXmlResourceHandler
::AddStyle(const wxString
& name
, int value
)
713 m_styleNames
.Add(name
);
714 m_styleValues
.Add(value
);
719 void wxXmlResourceHandler
::AddWindowStyles()
721 XRC_ADD_STYLE(wxCLIP_CHILDREN
);
722 XRC_ADD_STYLE(wxSIMPLE_BORDER
);
723 XRC_ADD_STYLE(wxSUNKEN_BORDER
);
724 XRC_ADD_STYLE(wxDOUBLE_BORDER
);
725 XRC_ADD_STYLE(wxRAISED_BORDER
);
726 XRC_ADD_STYLE(wxSTATIC_BORDER
);
727 XRC_ADD_STYLE(wxNO_BORDER
);
728 XRC_ADD_STYLE(wxTRANSPARENT_WINDOW
);
729 XRC_ADD_STYLE(wxWANTS_CHARS
);
730 XRC_ADD_STYLE(wxNO_FULL_REPAINT_ON_RESIZE
);
731 XRC_ADD_STYLE(wxFULL_REPAINT_ON_RESIZE
);
732 XRC_ADD_STYLE(wxWS_EX_BLOCK_EVENTS
);
733 XRC_ADD_STYLE(wxWS_EX_VALIDATE_RECURSIVELY
);
738 bool wxXmlResourceHandler
::HasParam(const wxString
& param
)
740 return (GetParamNode(param
) != NULL
);
744 int wxXmlResourceHandler
::GetStyle(const wxString
& param
, int defaults
)
746 wxString s
= GetParamValue(param
);
748 if (!s
) return defaults
;
750 wxStringTokenizer
tkn(s
, wxT("| \t\n"), wxTOKEN_STRTOK
);
754 while (tkn
.HasMoreTokens())
756 fl
= tkn
.GetNextToken();
757 index
= m_styleNames
.Index(fl
);
758 if (index
!= wxNOT_FOUND
)
759 style
|= m_styleValues
[index
];
761 wxLogError(_("Unknown style flag ") + fl
);
768 wxString wxXmlResourceHandler
::GetText(const wxString
& param
, bool translate
)
770 wxXmlNode
*parNode
= GetParamNode(param
);
771 wxString
str1(GetNodeContent(parNode
));
776 // VS: First version of XRC resources used $ instead of & (which is
777 // illegal in XML), but later I realized that '_' fits this purpose
778 // much better (because &File means "File with F underlined").
779 if (m_resource
->CompareVersion(2,3,0,1) < 0)
784 for (dt
= str1
.c_str(); *dt
; dt
++)
786 // Remap amp_char to &, map double amp_char to amp_char (for things
787 // like "&File..." -- this is illegal in XML, so we use "_File..."):
790 if ( *(++dt
) == amp_char
)
793 str2
<< wxT('&') << *dt
;
795 // Remap \n to CR, \r to LF, \t to TAB, \\ to \:
796 else if (*dt
== wxT('\\'))
812 // "\\" wasn't translated to "\" prior to 2.5.3.0:
813 if (m_resource
->CompareVersion(2,5,3,0) >= 0)
818 // else fall-through to default: branch below
821 str2
<< wxT('\\') << *dt
;
827 if (m_resource
->GetFlags() & wxXRC_USE_LOCALE
)
829 if (translate
&& parNode
&&
830 parNode
->GetPropVal(wxT("translate"), wxEmptyString
) != wxT("0"))
832 return wxGetTranslation(str2
);
839 // The string is internally stored as UTF-8, we have to convert
840 // it into system's default encoding so that it can be displayed:
841 return wxString(str2
.mb_str(wxConvUTF8
), wxConvLocal
);
846 // If wxXRC_USE_LOCALE is not set, then the string is already in
847 // system's default encoding in ANSI build, so we don't have to
848 // do anything special here.
854 long wxXmlResourceHandler
::GetLong(const wxString
& param
, long defaultv
)
857 wxString str1
= GetParamValue(param
);
859 if (!str1
.ToLong(&value
))
865 float wxXmlResourceHandler
::GetFloat(const wxString
& param
, float defaultv
)
868 wxString str1
= GetParamValue(param
);
871 const char *prevlocale
= setlocale(LC_NUMERIC
, "C");
874 if (!str1
.ToDouble(&value
))
878 setlocale(LC_NUMERIC
, prevlocale
);
885 int wxXmlResourceHandler
::GetID()
887 return wxXmlResource
::GetXRCID(GetName());
892 wxString wxXmlResourceHandler
::GetName()
894 return m_node
->GetPropVal(wxT("name"), wxT("-1"));
899 bool wxXmlResourceHandler
::GetBool(const wxString
& param
, bool defaultv
)
901 wxString v
= GetParamValue(param
);
903 if (!v
) return defaultv
;
905 return (v
== wxT("1"));
909 static wxColour
GetSystemColour(const wxString
& name
)
913 #define SYSCLR(clr) \
914 if (name == _T(#clr)) return wxSystemSettings::GetColour(clr);
915 SYSCLR(wxSYS_COLOUR_SCROLLBAR
)
916 SYSCLR(wxSYS_COLOUR_BACKGROUND
)
917 SYSCLR(wxSYS_COLOUR_DESKTOP
)
918 SYSCLR(wxSYS_COLOUR_ACTIVECAPTION
)
919 SYSCLR(wxSYS_COLOUR_INACTIVECAPTION
)
920 SYSCLR(wxSYS_COLOUR_MENU
)
921 SYSCLR(wxSYS_COLOUR_WINDOW
)
922 SYSCLR(wxSYS_COLOUR_WINDOWFRAME
)
923 SYSCLR(wxSYS_COLOUR_MENUTEXT
)
924 SYSCLR(wxSYS_COLOUR_WINDOWTEXT
)
925 SYSCLR(wxSYS_COLOUR_CAPTIONTEXT
)
926 SYSCLR(wxSYS_COLOUR_ACTIVEBORDER
)
927 SYSCLR(wxSYS_COLOUR_INACTIVEBORDER
)
928 SYSCLR(wxSYS_COLOUR_APPWORKSPACE
)
929 SYSCLR(wxSYS_COLOUR_HIGHLIGHT
)
930 SYSCLR(wxSYS_COLOUR_HIGHLIGHTTEXT
)
931 SYSCLR(wxSYS_COLOUR_BTNFACE
)
932 SYSCLR(wxSYS_COLOUR_3DFACE
)
933 SYSCLR(wxSYS_COLOUR_BTNSHADOW
)
934 SYSCLR(wxSYS_COLOUR_3DSHADOW
)
935 SYSCLR(wxSYS_COLOUR_GRAYTEXT
)
936 SYSCLR(wxSYS_COLOUR_BTNTEXT
)
937 SYSCLR(wxSYS_COLOUR_INACTIVECAPTIONTEXT
)
938 SYSCLR(wxSYS_COLOUR_BTNHIGHLIGHT
)
939 SYSCLR(wxSYS_COLOUR_BTNHILIGHT
)
940 SYSCLR(wxSYS_COLOUR_3DHIGHLIGHT
)
941 SYSCLR(wxSYS_COLOUR_3DHILIGHT
)
942 SYSCLR(wxSYS_COLOUR_3DDKSHADOW
)
943 SYSCLR(wxSYS_COLOUR_3DLIGHT
)
944 SYSCLR(wxSYS_COLOUR_INFOTEXT
)
945 SYSCLR(wxSYS_COLOUR_INFOBK
)
946 SYSCLR(wxSYS_COLOUR_LISTBOX
)
947 SYSCLR(wxSYS_COLOUR_HOTLIGHT
)
948 SYSCLR(wxSYS_COLOUR_GRADIENTACTIVECAPTION
)
949 SYSCLR(wxSYS_COLOUR_GRADIENTINACTIVECAPTION
)
950 SYSCLR(wxSYS_COLOUR_MENUHILIGHT
)
951 SYSCLR(wxSYS_COLOUR_MENUBAR
)
958 wxColour wxXmlResourceHandler
::GetColour(const wxString
& param
)
960 wxString v
= GetParamValue(param
);
962 // find colour using HTML syntax (#RRGGBB)
963 unsigned long tmp
= 0;
965 if (v
.Length() != 7 || v
[0u] != wxT('#') ||
966 wxSscanf(v
.c_str(), wxT("#%lX"), &tmp
) != 1)
968 // the colour doesn't use #RRGGBB format, check if it is symbolic
970 wxColour clr
= GetSystemColour(v
);
974 wxLogError(_("XRC resource: Incorrect colour specification '%s' for property '%s'."),
975 v
.c_str(), param
.c_str());
979 return wxColour((unsigned char) ((tmp
& 0xFF0000) >> 16) ,
980 (unsigned char) ((tmp
& 0x00FF00) >> 8),
981 (unsigned char) ((tmp
& 0x0000FF)));
986 wxBitmap wxXmlResourceHandler
::GetBitmap(const wxString
& param
,
987 const wxArtClient
& defaultArtClient
,
990 /* If the bitmap is specified as stock item, query wxArtProvider for it: */
991 wxXmlNode
*bmpNode
= GetParamNode(param
);
994 wxString sid
= bmpNode
->GetPropVal(wxT("stock_id"), wxEmptyString
);
997 wxString scl
= bmpNode
->GetPropVal(wxT("stock_client"), wxEmptyString
);
999 scl
= defaultArtClient
;
1001 scl
= wxART_MAKE_CLIENT_ID_FROM_STR(scl
);
1004 wxArtProvider
::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(sid
),
1006 if ( stockArt
.Ok() )
1011 /* ...or load the bitmap from file: */
1012 wxString name
= GetParamValue(param
);
1013 if (name
.empty()) return wxNullBitmap
;
1014 #if wxUSE_FILESYSTEM
1015 wxFSFile
*fsfile
= GetCurFileSystem().OpenFile(name
);
1018 wxLogError(_("XRC resource: Cannot create bitmap from '%s'."),
1020 return wxNullBitmap
;
1022 wxImage
img(*(fsfile
->GetStream()));
1025 wxImage
img(GetParamValue(wxT("bitmap")));
1030 wxLogError(_("XRC resource: Cannot create bitmap from '%s'."),
1032 return wxNullBitmap
;
1034 if (!(size
== wxDefaultSize
)) img
.Rescale(size
.x
, size
.y
);
1035 return wxBitmap(img
);
1041 wxIcon wxXmlResourceHandler
::GetIcon(const wxString
& param
,
1042 const wxArtClient
& defaultArtClient
,
1046 icon
.CopyFromBitmap(GetBitmap(param
, defaultArtClient
, size
));
1052 wxXmlNode
*wxXmlResourceHandler
::GetParamNode(const wxString
& param
)
1054 wxCHECK_MSG(m_node
, NULL
, wxT("You can't access handler data before it was initialized!"));
1056 wxXmlNode
*n
= m_node
->GetChildren();
1060 if (n
->GetType() == wxXML_ELEMENT_NODE
&& n
->GetName() == param
)
1068 wxString wxXmlResourceHandler
::GetNodeContent(wxXmlNode
*node
)
1070 wxXmlNode
*n
= node
;
1071 if (n
== NULL
) return wxEmptyString
;
1072 n
= n
->GetChildren();
1076 if (n
->GetType() == wxXML_TEXT_NODE
||
1077 n
->GetType() == wxXML_CDATA_SECTION_NODE
)
1078 return n
->GetContent();
1081 return wxEmptyString
;
1086 wxString wxXmlResourceHandler
::GetParamValue(const wxString
& param
)
1089 return GetNodeContent(m_node
);
1091 return GetNodeContent(GetParamNode(param
));
1096 wxSize wxXmlResourceHandler
::GetSize(const wxString
& param
,
1097 wxWindow
*windowToUse
)
1099 wxString s
= GetParamValue(param
);
1100 if (s
.empty()) s
= wxT("-1,-1");
1104 is_dlg
= s
[s
.Length()-1] == wxT('d');
1105 if (is_dlg
) s
.RemoveLast();
1107 if (!s
.BeforeFirst(wxT(',')).ToLong(&sx
) ||
1108 !s
.AfterLast(wxT(',')).ToLong(&sy
))
1110 wxLogError(_("Cannot parse coordinates from '%s'."), s
.c_str());
1111 return wxDefaultSize
;
1118 return wxDLG_UNIT(windowToUse
, wxSize(sx
, sy
));
1120 else if (m_parentAsWindow
)
1122 return wxDLG_UNIT(m_parentAsWindow
, wxSize(sx
, sy
));
1126 wxLogError(_("Cannot convert dialog units: dialog unknown."));
1127 return wxDefaultSize
;
1131 return wxSize(sx
, sy
);
1136 wxPoint wxXmlResourceHandler
::GetPosition(const wxString
& param
)
1138 wxSize sz
= GetSize(param
);
1139 return wxPoint(sz
.x
, sz
.y
);
1144 wxCoord wxXmlResourceHandler
::GetDimension(const wxString
& param
,
1146 wxWindow
*windowToUse
)
1148 wxString s
= GetParamValue(param
);
1149 if (s
.empty()) return defaultv
;
1153 is_dlg
= s
[s
.Length()-1] == wxT('d');
1154 if (is_dlg
) s
.RemoveLast();
1158 wxLogError(_("Cannot parse dimension from '%s'."), s
.c_str());
1166 return wxDLG_UNIT(windowToUse
, wxSize(sx
, 0)).x
;
1168 else if (m_parentAsWindow
)
1170 return wxDLG_UNIT(m_parentAsWindow
, wxSize(sx
, 0)).x
;
1174 wxLogError(_("Cannot convert dialog units: dialog unknown."));
1183 // Get system font index using indexname
1184 static wxFont
GetSystemFont(const wxString
& name
)
1188 #define SYSFNT(fnt) \
1189 if (name == _T(#fnt)) return wxSystemSettings::GetFont(fnt);
1190 SYSFNT(wxSYS_OEM_FIXED_FONT
)
1191 SYSFNT(wxSYS_ANSI_FIXED_FONT
)
1192 SYSFNT(wxSYS_ANSI_VAR_FONT
)
1193 SYSFNT(wxSYS_SYSTEM_FONT
)
1194 SYSFNT(wxSYS_DEVICE_DEFAULT_FONT
)
1195 SYSFNT(wxSYS_DEFAULT_PALETTE
)
1196 SYSFNT(wxSYS_SYSTEM_FIXED_FONT
)
1197 SYSFNT(wxSYS_DEFAULT_GUI_FONT
)
1204 wxFont wxXmlResourceHandler
::GetFont(const wxString
& param
)
1206 wxXmlNode
*font_node
= GetParamNode(param
);
1207 if (font_node
== NULL
)
1209 wxLogError(_("Cannot find font node '%s'."), param
.c_str());
1213 wxXmlNode
*oldnode
= m_node
;
1219 int isize
= wxDEFAULT
;
1220 bool hasSize
= HasParam(wxT("size"));
1222 isize
= GetLong(wxT("size"), wxDEFAULT
);
1225 int istyle
= wxNORMAL
;
1226 bool hasStyle
= HasParam(wxT("style"));
1229 wxString style
= GetParamValue(wxT("style"));
1230 if (style
== wxT("italic"))
1232 else if (style
== wxT("slant"))
1237 int iweight
= wxNORMAL
;
1238 bool hasWeight
= HasParam(wxT("weight"));
1241 wxString weight
= GetParamValue(wxT("weight"));
1242 if (weight
== wxT("bold"))
1244 else if (weight
== wxT("light"))
1249 bool hasUnderlined
= HasParam(wxT("underlined"));
1250 bool underlined
= hasUnderlined ?
GetBool(wxT("underlined"), false) : false;
1252 // family and facename
1253 int ifamily
= wxDEFAULT
;
1254 bool hasFamily
= HasParam(wxT("family"));
1257 wxString family
= GetParamValue(wxT("family"));
1258 if (family
== wxT("decorative")) ifamily
= wxDECORATIVE
;
1259 else if (family
== wxT("roman")) ifamily
= wxROMAN
;
1260 else if (family
== wxT("script")) ifamily
= wxSCRIPT
;
1261 else if (family
== wxT("swiss")) ifamily
= wxSWISS
;
1262 else if (family
== wxT("modern")) ifamily
= wxMODERN
;
1263 else if (family
== wxT("teletype")) ifamily
= wxTELETYPE
;
1268 bool hasFacename
= HasParam(wxT("face"));
1271 wxString faces
= GetParamValue(wxT("face"));
1272 wxFontEnumerator enu
;
1273 enu
.EnumerateFacenames();
1274 wxStringTokenizer
tk(faces
, wxT(","));
1275 while (tk
.HasMoreTokens())
1277 int index
= enu
.GetFacenames()->Index(tk
.GetNextToken(), false);
1278 if (index
!= wxNOT_FOUND
)
1280 facename
= (*enu
.GetFacenames())[index
];
1287 wxFontEncoding enc
= wxFONTENCODING_DEFAULT
;
1288 bool hasEncoding
= HasParam(wxT("encoding"));
1291 wxString encoding
= GetParamValue(wxT("encoding"));
1292 wxFontMapper mapper
;
1293 if (!encoding
.empty())
1294 enc
= mapper
.CharsetToEncoding(encoding
);
1295 if (enc
== wxFONTENCODING_SYSTEM
)
1296 enc
= wxFONTENCODING_DEFAULT
;
1299 // is this font based on a system font?
1300 wxFont sysfont
= GetSystemFont(GetParamValue(wxT("sysfont")));
1305 sysfont
.SetPointSize(isize
);
1306 else if (HasParam(wxT("relativesize")))
1307 sysfont
.SetPointSize(int(sysfont
.GetPointSize() *
1308 GetFloat(wxT("relativesize"))));
1311 sysfont
.SetStyle(istyle
);
1313 sysfont
.SetWeight(iweight
);
1315 sysfont
.SetUnderlined(underlined
);
1317 sysfont
.SetFamily(ifamily
);
1319 sysfont
.SetFaceName(facename
);
1321 sysfont
.SetDefaultEncoding(enc
);
1328 return wxFont(isize
, ifamily
, istyle
, iweight
,
1329 underlined
, facename
, enc
);
1333 void wxXmlResourceHandler
::SetupWindow(wxWindow
*wnd
)
1335 //FIXME : add cursor
1337 if (HasParam(wxT("exstyle")))
1338 // Have to OR it with existing style, since
1339 // some implementations (e.g. wxGTK) use the extra style
1341 wnd
->SetExtraStyle(wnd
->GetExtraStyle() | GetStyle(wxT("exstyle")));
1342 if (HasParam(wxT("bg")))
1343 wnd
->SetBackgroundColour(GetColour(wxT("bg")));
1344 if (HasParam(wxT("fg")))
1345 wnd
->SetForegroundColour(GetColour(wxT("fg")));
1346 if (GetBool(wxT("enabled"), 1) == 0)
1348 if (GetBool(wxT("focused"), 0) == 1)
1350 if (GetBool(wxT("hidden"), 0) == 1)
1353 if (HasParam(wxT("tooltip")))
1354 wnd
->SetToolTip(GetText(wxT("tooltip")));
1356 if (HasParam(wxT("font")))
1357 wnd
->SetFont(GetFont());
1361 void wxXmlResourceHandler
::CreateChildren(wxObject
*parent
, bool this_hnd_only
)
1363 wxXmlNode
*n
= m_node
->GetChildren();
1367 if (n
->GetType() == wxXML_ELEMENT_NODE
&&
1368 (n
->GetName() == wxT("object") || n
->GetName() == wxT("object_ref")))
1370 m_resource
->CreateResFromNode(n
, parent
, NULL
,
1371 this_hnd_only ?
this : NULL
);
1378 void wxXmlResourceHandler
::CreateChildrenPrivately(wxObject
*parent
, wxXmlNode
*rootnode
)
1381 if (rootnode
== NULL
) root
= m_node
; else root
= rootnode
;
1382 wxXmlNode
*n
= root
->GetChildren();
1386 if (n
->GetType() == wxXML_ELEMENT_NODE
&& CanHandle(n
))
1388 CreateResource(n
, parent
, NULL
);
1400 // --------------- XRCID implementation -----------------------------
1402 #define XRCID_TABLE_SIZE 1024
1412 static XRCID_record
*XRCID_Records
[XRCID_TABLE_SIZE
] = {NULL
};
1414 static int XRCID_Lookup(const wxChar
*str_id
, int value_if_not_found
= -2)
1418 for (const wxChar
*c
= str_id
; *c
!= wxT('\0'); c
++) index
+= (int)*c
;
1419 index
%= XRCID_TABLE_SIZE
;
1421 XRCID_record
*oldrec
= NULL
;
1422 for (XRCID_record
*rec
= XRCID_Records
[index
]; rec
; rec
= rec
->next
)
1424 if (wxStrcmp(rec
->key
, str_id
) == 0)
1431 XRCID_record
**rec_var
= (oldrec
== NULL
) ?
1432 &XRCID_Records
[index
] : &oldrec
->next
;
1433 *rec_var
= new XRCID_record
;
1434 (*rec_var
)->key
= wxStrdup(str_id
);
1435 (*rec_var
)->next
= NULL
;
1438 if (value_if_not_found
!= -2)
1439 (*rec_var
)->id
= value_if_not_found
;
1442 int asint
= wxStrtol(str_id
, &end
, 10);
1443 if (*str_id
&& *end
== 0)
1445 // if str_id was integer, keep it verbosely:
1446 (*rec_var
)->id
= asint
;
1450 (*rec_var
)->id
= wxNewId();
1454 return (*rec_var
)->id
;
1457 /*static*/ int wxXmlResource
::GetXRCID(const wxChar
*str_id
)
1459 return XRCID_Lookup(str_id
);
1463 static void CleanXRCID_Record(XRCID_record
*rec
)
1467 CleanXRCID_Record(rec
->next
);
1473 static void CleanXRCID_Records()
1475 for (int i
= 0; i
< XRCID_TABLE_SIZE
; i
++)
1477 CleanXRCID_Record(XRCID_Records
[i
]);
1478 XRCID_Records
[i
] = NULL
;
1482 static void AddStdXRCID_Records()
1484 #define stdID(id) XRCID_Lookup(wxT(#id), id)
1488 stdID(wxID_SEPARATOR
);
1501 stdID(wxID_PRINT_SETUP
);
1502 stdID(wxID_PREVIEW
);
1504 stdID(wxID_HELP_CONTENTS
);
1505 stdID(wxID_HELP_COMMANDS
);
1506 stdID(wxID_HELP_PROCEDURES
);
1507 stdID(wxID_HELP_CONTEXT
);
1508 stdID(wxID_CLOSE_ALL
);
1509 stdID(wxID_PREFERENCES
);
1515 stdID(wxID_DUPLICATE
);
1516 stdID(wxID_SELECTALL
);
1518 stdID(wxID_REPLACE
);
1519 stdID(wxID_REPLACE_ALL
);
1520 stdID(wxID_PROPERTIES
);
1521 stdID(wxID_VIEW_DETAILS
);
1522 stdID(wxID_VIEW_LARGEICONS
);
1523 stdID(wxID_VIEW_SMALLICONS
);
1524 stdID(wxID_VIEW_LIST
);
1525 stdID(wxID_VIEW_SORTDATE
);
1526 stdID(wxID_VIEW_SORTNAME
);
1527 stdID(wxID_VIEW_SORTSIZE
);
1528 stdID(wxID_VIEW_SORTTYPE
);
1544 stdID(wxID_FORWARD
);
1545 stdID(wxID_BACKWARD
);
1546 stdID(wxID_DEFAULT
);
1550 stdID(wxID_CONTEXT_HELP
);
1551 stdID(wxID_YESTOALL
);
1552 stdID(wxID_NOTOALL
);
1561 stdID(wxID_REFRESH
);
1566 stdID(wxID_JUSTIFY_CENTER
);
1567 stdID(wxID_JUSTIFY_FILL
);
1568 stdID(wxID_JUSTIFY_RIGHT
);
1569 stdID(wxID_JUSTIFY_LEFT
);
1570 stdID(wxID_UNDERLINE
);
1572 stdID(wxID_UNINDENT
);
1573 stdID(wxID_ZOOM_100
);
1574 stdID(wxID_ZOOM_FIT
);
1575 stdID(wxID_ZOOM_IN
);
1576 stdID(wxID_ZOOM_OUT
);
1577 stdID(wxID_UNDELETE
);
1578 stdID(wxID_REVERT_TO_SAVED
);
1579 stdID(wxID_SYSTEM_MENU
);
1580 stdID(wxID_CLOSE_FRAME
);
1581 stdID(wxID_MOVE_FRAME
);
1582 stdID(wxID_RESIZE_FRAME
);
1583 stdID(wxID_MAXIMIZE_FRAME
);
1584 stdID(wxID_ICONIZE_FRAME
);
1585 stdID(wxID_RESTORE_FRAME
);
1594 // --------------- module and globals -----------------------------
1596 class wxXmlResourceModule
: public wxModule
1598 DECLARE_DYNAMIC_CLASS(wxXmlResourceModule
)
1600 wxXmlResourceModule() {}
1603 AddStdXRCID_Records();
1604 wxXmlResource
::AddSubclassFactory(new wxXmlSubclassFactoryCXX
);
1609 delete wxXmlResource
::Set(NULL
);
1610 if(wxXmlResource
::ms_subclassFactories
)
1611 WX_CLEAR_LIST(wxXmlSubclassFactoriesList
, *wxXmlResource
::ms_subclassFactories
);
1612 wxDELETE(wxXmlResource
::ms_subclassFactories
);
1613 CleanXRCID_Records();
1617 IMPLEMENT_DYNAMIC_CLASS(wxXmlResourceModule
, wxModule
)
1620 // When wxXml is loaded dynamically after the application is already running
1621 // then the built-in module system won't pick this one up. Add it manually.
1622 void wxXmlInitResourceModule()
1624 wxModule
* module
= new wxXmlResourceModule
;
1626 wxModule
::RegisterModule(module
);