/////////////////////////////////////////////////////////////////////////////
-// Name: xmlres.cpp
+// Name: src/xrc/xmlres.cpp
// Purpose: XRC resources
// Author: Vaclav Slavik
// Created: 2000/03/05
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-#ifdef __GNUG__
-#pragma implementation "xmlres.h"
-#endif
-
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#if wxUSE_XRC
-#include "wx/dialog.h"
-#include "wx/panel.h"
-#include "wx/frame.h"
+#include "wx/xrc/xmlres.h"
+
+#ifndef WX_PRECOMP
+ #include "wx/intl.h"
+ #include "wx/log.h"
+ #include "wx/panel.h"
+ #include "wx/frame.h"
+ #include "wx/dialog.h"
+ #include "wx/settings.h"
+ #include "wx/bitmap.h"
+ #include "wx/image.h"
+ #include "wx/module.h"
+#endif
+
+#ifndef __WXWINCE__
+ #include <locale.h>
+#endif
+
#include "wx/wfstream.h"
#include "wx/filesys.h"
#include "wx/filename.h"
-#include "wx/log.h"
-#include "wx/intl.h"
#include "wx/tokenzr.h"
#include "wx/fontenum.h"
-#include "wx/module.h"
-#include "wx/bitmap.h"
-#include "wx/image.h"
#include "wx/fontmap.h"
#include "wx/artprov.h"
#include "wx/xml/xml.h"
-#include "wx/xrc/xmlres.h"
#include "wx/arrimpl.cpp"
-WX_DEFINE_OBJARRAY(wxXmlResourceDataRecords);
+WX_DEFINE_OBJARRAY(wxXmlResourceDataRecords)
wxXmlResource *wxXmlResource::ms_instance = NULL;
return old;
}
-wxXmlResource::wxXmlResource(int flags)
+wxXmlResource::wxXmlResource(int flags, const wxString& domain)
{
m_flags = flags;
m_version = -1;
+ m_domain = NULL;
+ if (! domain.empty() )
+ SetDomain(domain);
}
-wxXmlResource::wxXmlResource(const wxString& filemask, int flags)
+wxXmlResource::wxXmlResource(const wxString& filemask, int flags, const wxString& domain)
{
m_flags = flags;
m_version = -1;
+ m_domain = NULL;
+ if (! domain.empty() )
+ SetDomain(domain);
Load(filemask);
}
wxXmlResource::~wxXmlResource()
{
+ if (m_domain)
+ free(m_domain);
ClearHandlers();
}
+void wxXmlResource::SetDomain(const wxChar* domain)
+{
+ if (m_domain)
+ free(m_domain);
+ m_domain = NULL;
+ if (domain && wxStrlen(domain))
+ m_domain = wxStrdup(domain);
+}
+
+
+/* static */
+wxString wxXmlResource::ConvertFileNameToURL(const wxString& filename)
+{
+ wxString fnd(filename);
+
+ // NB: as Load() and Unload() accept both filenames and URLs (should
+ // probably be changed to filenames only, but embedded resources
+ // currently rely on its ability to handle URLs - FIXME) we need to
+ // determine whether found name is filename and not URL and this is the
+ // fastest/simplest way to do it
+ if (wxFileName::FileExists(fnd))
+ {
+ // Make the name absolute filename, because the app may
+ // change working directory later:
+ wxFileName fn(fnd);
+ if (fn.IsRelative())
+ {
+ fn.MakeAbsolute();
+ fnd = fn.GetFullPath();
+ }
+#if wxUSE_FILESYSTEM
+ fnd = wxFileSystem::FileNameToURL(fnd);
+#endif
+ }
+
+ return fnd;
+}
+
+#if wxUSE_FILESYSTEM
+
+/* static */
+bool wxXmlResource::IsArchive(const wxString& filename)
+{
+ const wxString fnd = filename.Lower();
+
+ return fnd.Matches(wxT("*.zip")) || fnd.Matches(wxT("*.xrs"));
+}
+
+#endif // wxUSE_FILESYSTEM
bool wxXmlResource::Load(const wxString& filemask)
{
fnd = wxXmlFindFirst;
else
fnd = filemask;
- while (!!fnd)
+ while (!fnd.empty())
{
- // NB: Load() accepts both filenames and URLs (should probably be
- // changed to filenames only, but embedded resources currently
- // rely on its ability to handle URLs - FIXME). This check
- // serves as a quick way to determine whether found name is
- // filename and not URL:
- if (wxFileName::FileExists(fnd))
- {
- // Make the name absolute filename, because the app may
- // change working directory later:
- wxFileName fn(fnd);
- if (fn.IsRelative())
- {
- fn.MakeAbsolute();
- fnd = fn.GetFullPath();
- }
-#if wxUSE_FILESYSTEM
- fnd = wxFileSystem::FileNameToURL(fnd);
-#endif
- }
+ fnd = ConvertFileNameToURL(fnd);
#if wxUSE_FILESYSTEM
- if (fnd.Lower().Matches(wxT("*.zip")) ||
- fnd.Lower().Matches(wxT("*.xrs")))
+ if ( IsArchive(fnd) )
{
rt = rt && Load(fnd + wxT("#zip:*.xrc"));
}
- else
-#endif
+ else // a single resource URL
+#endif // wxUSE_FILESYSTEM
{
drec = new wxXmlResourceDataRecord;
drec->File = fnd;
return rt && UpdateResources();
}
+bool wxXmlResource::Unload(const wxString& filename)
+{
+ wxASSERT_MSG( !wxIsWild(filename),
+ _T("wildcards not supported by wxXmlResource::Unload()") );
+
+ wxString fnd = ConvertFileNameToURL(filename);
+#if wxUSE_FILESYSTEM
+ const bool isArchive = IsArchive(fnd);
+ if ( isArchive )
+ fnd += _T("#zip:");
+#endif // wxUSE_FILESYSTEM
+
+ bool unloaded = false;
+ const size_t count = m_data.GetCount();
+ for ( size_t i = 0; i < count; i++ )
+ {
+#if wxUSE_FILESYSTEM
+ if ( isArchive )
+ {
+ if ( m_data[i].File.StartsWith(fnd) )
+ unloaded = true;
+ // don't break from the loop, we can have other matching files
+ }
+ else // a single resource URL
+#endif // wxUSE_FILESYSTEM
+ {
+ if ( m_data[i].File == fnd )
+ {
+ m_data.RemoveAt(i);
+ unloaded = true;
+
+ // no sense in continuing, there is only one file with this URL
+ break;
+ }
+ }
+ }
+
+ return unloaded;
+}
+
IMPLEMENT_ABSTRACT_CLASS(wxXmlResourceHandler, wxObject)
{
# if wxUSE_FILESYSTEM
file = fsys.OpenFile(m_data[i].File);
+# if wxUSE_DATETIME
modif = file && file->GetModificationTime() > m_data[i].Time;
+# else // wxUSE_DATETIME
+ modif = true;
+# endif // wxUSE_DATETIME
if (!file)
{
wxLogError(_("Cannot open file '%s'."), m_data[i].File.c_str());
}
wxDELETE(file);
wxUnusedVar(file);
-# else
+# else // wxUSE_FILESYSTEM
+# if wxUSE_DATETIME
modif = wxDateTime(wxFileModificationTime(m_data[i].File)) > m_data[i].Time;
-# endif
+# else // wxUSE_DATETIME
+ modif = true;
+# endif // wxUSE_DATETIME
+# endif // wxUSE_FILESYSTEM
}
if (modif)
}
ProcessPlatformProperty(m_data[i].Doc->GetRoot());
+#if wxUSE_DATETIME
#if wxUSE_FILESYSTEM
m_data[i].Time = file->GetModificationTime();
-#else
+#else // wxUSE_FILESYSTEM
m_data[i].Time = wxDateTime(wxFileModificationTime(m_data[i].File));
-#endif
+#endif // wxUSE_FILESYSTEM
+#endif // wxUSE_DATETIME
}
# if wxUSE_FILESYSTEM
}
if ( !dnode )
- dest.AddChild(new wxXmlNode(*node));
+ {
+ static const wxChar *AT_END = wxT("end");
+ wxString insert_pos = node->GetPropVal(wxT("insert_at"), AT_END);
+ if ( insert_pos == AT_END )
+ {
+ dest.AddChild(new wxXmlNode(*node));
+ }
+ else if ( insert_pos == wxT("begin") )
+ {
+ dest.InsertChild(new wxXmlNode(*node), dest.GetChildren());
+ }
+ }
}
- if ( dest.GetType() == wxXML_TEXT_NODE && with.GetContent().Length() )
+ if ( dest.GetType() == wxXML_TEXT_NODE && with.GetContent().length() )
dest.SetContent(with.GetContent());
}
#include "wx/listimpl.cpp"
WX_DECLARE_LIST(wxXmlSubclassFactory, wxXmlSubclassFactoriesList);
-WX_DEFINE_LIST(wxXmlSubclassFactoriesList);
+WX_DEFINE_LIST(wxXmlSubclassFactoriesList)
wxXmlSubclassFactoriesList *wxXmlResource::ms_subclassFactories = NULL;
-
wxXmlResourceHandler::wxXmlResourceHandler()
: m_node(NULL), m_parent(NULL), m_instance(NULL),
- m_parentAsWindow(NULL), m_instanceAsWindow(NULL)
+ m_parentAsWindow(NULL)
{}
wxXmlNode *myNode = m_node;
wxString myClass = m_class;
wxObject *myParent = m_parent, *myInstance = m_instance;
- wxWindow *myParentAW = m_parentAsWindow, *myInstanceAW = m_instanceAsWindow;
+ wxWindow *myParentAW = m_parentAsWindow;
m_instance = instance;
if (!m_instance && node->HasProp(wxT("subclass")) &&
m_class = node->GetPropVal(wxT("class"), wxEmptyString);
m_parent = parent;
m_parentAsWindow = wxDynamicCast(m_parent, wxWindow);
- m_instanceAsWindow = wxDynamicCast(m_instance, wxWindow);
wxObject *returned = DoCreateResource();
m_node = myNode;
m_class = myClass;
m_parent = myParent; m_parentAsWindow = myParentAW;
- m_instance = myInstance; m_instanceAsWindow = myInstanceAW;
+ m_instance = myInstance;
return returned;
}
void wxXmlResourceHandler::AddWindowStyles()
{
XRC_ADD_STYLE(wxCLIP_CHILDREN);
- XRC_ADD_STYLE(wxSIMPLE_BORDER);
- XRC_ADD_STYLE(wxSUNKEN_BORDER);
- XRC_ADD_STYLE(wxDOUBLE_BORDER);
- XRC_ADD_STYLE(wxRAISED_BORDER);
- XRC_ADD_STYLE(wxSTATIC_BORDER);
- XRC_ADD_STYLE(wxNO_BORDER);
+
+ // the border styles all have the old and new names, recognize both for now
+ XRC_ADD_STYLE(wxSIMPLE_BORDER); XRC_ADD_STYLE(wxBORDER_SIMPLE);
+ XRC_ADD_STYLE(wxSUNKEN_BORDER); XRC_ADD_STYLE(wxBORDER_SUNKEN);
+ XRC_ADD_STYLE(wxDOUBLE_BORDER); XRC_ADD_STYLE(wxBORDER_DOUBLE);
+ XRC_ADD_STYLE(wxRAISED_BORDER); XRC_ADD_STYLE(wxBORDER_RAISED);
+ XRC_ADD_STYLE(wxSTATIC_BORDER); XRC_ADD_STYLE(wxBORDER_STATIC);
+ XRC_ADD_STYLE(wxNO_BORDER); XRC_ADD_STYLE(wxBORDER_NONE);
+
XRC_ADD_STYLE(wxTRANSPARENT_WINDOW);
XRC_ADD_STYLE(wxWANTS_CHARS);
+ XRC_ADD_STYLE(wxTAB_TRAVERSAL);
XRC_ADD_STYLE(wxNO_FULL_REPAINT_ON_RESIZE);
XRC_ADD_STYLE(wxFULL_REPAINT_ON_RESIZE);
+ XRC_ADD_STYLE(wxALWAYS_SHOW_SB);
XRC_ADD_STYLE(wxWS_EX_BLOCK_EVENTS);
+ XRC_ADD_STYLE(wxWS_EX_VALIDATE_RECURSIVELY);
}
case wxT('n'):
str2 << wxT('\n');
break;
-
+
case wxT('t'):
str2 << wxT('\t');
break;
-
+
case wxT('r'):
str2 << wxT('\r');
break;
break;
}
// else fall-through to default: branch below
-
+
default:
str2 << wxT('\\') << *dt;
break;
if (translate && parNode &&
parNode->GetPropVal(wxT("translate"), wxEmptyString) != wxT("0"))
{
- return wxGetTranslation(str2);
+ return wxGetTranslation(str2, m_resource->GetDomain());
}
else
{
#endif
}
}
- else
- {
- // If wxXRC_USE_LOCALE is not set, then the string is already in
- // system's default encoding in ANSI build, so we don't have to
- // do anything special here.
- return str2;
- }
+
+ // If wxXRC_USE_LOCALE is not set, then the string is already in
+ // system's default encoding in ANSI build, so we don't have to
+ // do anything special here.
+ return str2;
}
return value;
}
+float wxXmlResourceHandler::GetFloat(const wxString& param, float defaultv)
+{
+ double value;
+ wxString str1 = GetParamValue(param);
+
+#ifndef __WXWINCE__
+ const char *prevlocale = setlocale(LC_NUMERIC, "C");
+#endif
+
+ if (!str1.ToDouble(&value))
+ value = defaultv;
+
+#ifndef __WXWINCE__
+ setlocale(LC_NUMERIC, prevlocale);
+#endif
+
+ return wx_truncate_cast(float, value);
+}
int wxXmlResourceHandler::GetID()
wxString v = GetParamValue(param);
v.MakeLower();
if (!v) return defaultv;
- else return (v == wxT("1"));
+
+ return (v == wxT("1"));
}
+static wxColour GetSystemColour(const wxString& name)
+{
+ if (!name.empty())
+ {
+ #define SYSCLR(clr) \
+ if (name == _T(#clr)) return wxSystemSettings::GetColour(clr);
+ SYSCLR(wxSYS_COLOUR_SCROLLBAR)
+ SYSCLR(wxSYS_COLOUR_BACKGROUND)
+ SYSCLR(wxSYS_COLOUR_DESKTOP)
+ SYSCLR(wxSYS_COLOUR_ACTIVECAPTION)
+ SYSCLR(wxSYS_COLOUR_INACTIVECAPTION)
+ SYSCLR(wxSYS_COLOUR_MENU)
+ SYSCLR(wxSYS_COLOUR_WINDOW)
+ SYSCLR(wxSYS_COLOUR_WINDOWFRAME)
+ SYSCLR(wxSYS_COLOUR_MENUTEXT)
+ SYSCLR(wxSYS_COLOUR_WINDOWTEXT)
+ SYSCLR(wxSYS_COLOUR_CAPTIONTEXT)
+ SYSCLR(wxSYS_COLOUR_ACTIVEBORDER)
+ SYSCLR(wxSYS_COLOUR_INACTIVEBORDER)
+ SYSCLR(wxSYS_COLOUR_APPWORKSPACE)
+ SYSCLR(wxSYS_COLOUR_HIGHLIGHT)
+ SYSCLR(wxSYS_COLOUR_HIGHLIGHTTEXT)
+ SYSCLR(wxSYS_COLOUR_BTNFACE)
+ SYSCLR(wxSYS_COLOUR_3DFACE)
+ SYSCLR(wxSYS_COLOUR_BTNSHADOW)
+ SYSCLR(wxSYS_COLOUR_3DSHADOW)
+ SYSCLR(wxSYS_COLOUR_GRAYTEXT)
+ SYSCLR(wxSYS_COLOUR_BTNTEXT)
+ SYSCLR(wxSYS_COLOUR_INACTIVECAPTIONTEXT)
+ SYSCLR(wxSYS_COLOUR_BTNHIGHLIGHT)
+ SYSCLR(wxSYS_COLOUR_BTNHILIGHT)
+ SYSCLR(wxSYS_COLOUR_3DHIGHLIGHT)
+ SYSCLR(wxSYS_COLOUR_3DHILIGHT)
+ SYSCLR(wxSYS_COLOUR_3DDKSHADOW)
+ SYSCLR(wxSYS_COLOUR_3DLIGHT)
+ SYSCLR(wxSYS_COLOUR_INFOTEXT)
+ SYSCLR(wxSYS_COLOUR_INFOBK)
+ SYSCLR(wxSYS_COLOUR_LISTBOX)
+ SYSCLR(wxSYS_COLOUR_HOTLIGHT)
+ SYSCLR(wxSYS_COLOUR_GRADIENTACTIVECAPTION)
+ SYSCLR(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)
+ SYSCLR(wxSYS_COLOUR_MENUHILIGHT)
+ SYSCLR(wxSYS_COLOUR_MENUBAR)
+ #undef SYSCLR
+ }
+
+ return wxNullColour;
+}
-wxColour wxXmlResourceHandler::GetColour(const wxString& param)
+wxColour wxXmlResourceHandler::GetColour(const wxString& param, const wxColour& defaultv)
{
wxString v = GetParamValue(param);
- unsigned long tmp = 0;
- if (v.Length() != 7 || v[0u] != wxT('#') ||
- wxSscanf(v.c_str(), wxT("#%lX"), &tmp) != 1)
+ if ( v.empty() )
+ return defaultv;
+
+ wxColour clr;
+
+ // wxString -> wxColour conversion
+ if (!clr.Set(v))
{
+ // the colour doesn't use #RRGGBB format, check if it is symbolic
+ // colour name:
+ clr = GetSystemColour(v);
+ if (clr.Ok())
+ return clr;
+
wxLogError(_("XRC resource: Incorrect colour specification '%s' for property '%s'."),
v.c_str(), param.c_str());
return wxNullColour;
}
- return wxColour((unsigned char) ((tmp & 0xFF0000) >> 16) ,
- (unsigned char) ((tmp & 0x00FF00) >> 8),
- (unsigned char) ((tmp & 0x0000FF)));
+ return clr;
}
scl = defaultArtClient;
else
scl = wxART_MAKE_CLIENT_ID_FROM_STR(scl);
-
+
wxBitmap stockArt =
wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(sid),
scl, size);
/* ...or load the bitmap from file: */
wxString name = GetParamValue(param);
- if (name.IsEmpty()) return wxNullBitmap;
+ if (name.empty()) return wxNullBitmap;
#if wxUSE_FILESYSTEM
wxFSFile *fsfile = GetCurFileSystem().OpenFile(name);
if (fsfile == NULL)
wxImage img(*(fsfile->GetStream()));
delete fsfile;
#else
- wxImage img(GetParamValue(wxT("bitmap")));
+ wxImage img(name);
#endif
if (!img.Ok())
{
- wxLogError(_("XRC resource: Cannot create bitmap from '%s'."), param.c_str());
+ wxLogError(_("XRC resource: Cannot create bitmap from '%s'."),
+ name.c_str());
return wxNullBitmap;
}
if (!(size == wxDefaultSize)) img.Rescale(size.x, size.y);
return wxBitmap(img);
-
}
}
+
+bool wxXmlResourceHandler::IsOfClass(wxXmlNode *node, const wxString& classname)
+{
+ return node->GetPropVal(wxT("class"), wxEmptyString) == classname;
+}
+
+
+
wxString wxXmlResourceHandler::GetNodeContent(wxXmlNode *node)
{
wxXmlNode *n = node;
wxString wxXmlResourceHandler::GetParamValue(const wxString& param)
{
- if (param.IsEmpty())
+ if (param.empty())
return GetNodeContent(m_node);
else
return GetNodeContent(GetParamNode(param));
-wxSize wxXmlResourceHandler::GetSize(const wxString& param)
+wxSize wxXmlResourceHandler::GetSize(const wxString& param,
+ wxWindow *windowToUse)
{
wxString s = GetParamValue(param);
- if (s.IsEmpty()) s = wxT("-1,-1");
+ if (s.empty()) s = wxT("-1,-1");
bool is_dlg;
long sx, sy = 0;
- is_dlg = s[s.Length()-1] == wxT('d');
+ is_dlg = s[s.length()-1] == wxT('d');
if (is_dlg) s.RemoveLast();
if (!s.BeforeFirst(wxT(',')).ToLong(&sx) ||
if (is_dlg)
{
- if (m_instanceAsWindow)
- return wxDLG_UNIT(m_instanceAsWindow, wxSize(sx, sy));
+ if (windowToUse)
+ {
+ return wxDLG_UNIT(windowToUse, wxSize(sx, sy));
+ }
else if (m_parentAsWindow)
+ {
return wxDLG_UNIT(m_parentAsWindow, wxSize(sx, sy));
+ }
else
{
wxLogError(_("Cannot convert dialog units: dialog unknown."));
return wxDefaultSize;
}
}
- else return wxSize(sx, sy);
+
+ return wxSize(sx, sy);
}
-wxCoord wxXmlResourceHandler::GetDimension(const wxString& param, wxCoord defaultv)
+wxCoord wxXmlResourceHandler::GetDimension(const wxString& param,
+ wxCoord defaultv,
+ wxWindow *windowToUse)
{
wxString s = GetParamValue(param);
- if (s.IsEmpty()) return defaultv;
+ if (s.empty()) return defaultv;
bool is_dlg;
long sx;
- is_dlg = s[s.Length()-1] == wxT('d');
+ is_dlg = s[s.length()-1] == wxT('d');
if (is_dlg) s.RemoveLast();
if (!s.ToLong(&sx))
if (is_dlg)
{
- if (m_instanceAsWindow)
- return wxDLG_UNIT(m_instanceAsWindow, wxSize(sx, 0)).x;
+ if (windowToUse)
+ {
+ return wxDLG_UNIT(windowToUse, wxSize(sx, 0)).x;
+ }
else if (m_parentAsWindow)
+ {
return wxDLG_UNIT(m_parentAsWindow, wxSize(sx, 0)).x;
+ }
else
{
wxLogError(_("Cannot convert dialog units: dialog unknown."));
return defaultv;
}
}
- else return sx;
+
+ return sx;
}
+// Get system font index using indexname
+static wxFont GetSystemFont(const wxString& name)
+{
+ if (!name.empty())
+ {
+ #define SYSFNT(fnt) \
+ if (name == _T(#fnt)) return wxSystemSettings::GetFont(fnt);
+ SYSFNT(wxSYS_OEM_FIXED_FONT)
+ SYSFNT(wxSYS_ANSI_FIXED_FONT)
+ SYSFNT(wxSYS_ANSI_VAR_FONT)
+ SYSFNT(wxSYS_SYSTEM_FONT)
+ SYSFNT(wxSYS_DEVICE_DEFAULT_FONT)
+ SYSFNT(wxSYS_DEFAULT_PALETTE)
+ SYSFNT(wxSYS_SYSTEM_FIXED_FONT)
+ SYSFNT(wxSYS_DEFAULT_GUI_FONT)
+ #undef SYSFNT
+ }
+
+ return wxNullFont;
+}
wxFont wxXmlResourceHandler::GetFont(const wxString& param)
{
wxXmlNode *oldnode = m_node;
m_node = font_node;
- long size = GetLong(wxT("size"), 12);
+ // font attributes:
+
+ // size
+ int isize = -1;
+ bool hasSize = HasParam(wxT("size"));
+ if (hasSize)
+ isize = GetLong(wxT("size"), -1);
- wxString style = GetParamValue(wxT("style"));
- wxString weight = GetParamValue(wxT("weight"));
- int istyle = wxNORMAL, iweight = wxNORMAL;
- if (style == wxT("italic")) istyle = wxITALIC;
- else if (style == wxT("slant")) istyle = wxSLANT;
- if (weight == wxT("bold")) iweight = wxBOLD;
- else if (weight == wxT("light")) iweight = wxLIGHT;
+ // style
+ int istyle = wxNORMAL;
+ bool hasStyle = HasParam(wxT("style"));
+ if (hasStyle)
+ {
+ wxString style = GetParamValue(wxT("style"));
+ if (style == wxT("italic"))
+ istyle = wxITALIC;
+ else if (style == wxT("slant"))
+ istyle = wxSLANT;
+ }
+
+ // weight
+ int iweight = wxNORMAL;
+ bool hasWeight = HasParam(wxT("weight"));
+ if (hasWeight)
+ {
+ wxString weight = GetParamValue(wxT("weight"));
+ if (weight == wxT("bold"))
+ iweight = wxBOLD;
+ else if (weight == wxT("light"))
+ iweight = wxLIGHT;
+ }
- wxString family = GetParamValue(wxT("family"));
+ // underline
+ bool hasUnderlined = HasParam(wxT("underlined"));
+ bool underlined = hasUnderlined ? GetBool(wxT("underlined"), false) : false;
+
+ // family and facename
int ifamily = wxDEFAULT;
- if (family == wxT("decorative")) ifamily = wxDECORATIVE;
- else if (family == wxT("roman")) ifamily = wxROMAN;
- else if (family == wxT("script")) ifamily = wxSCRIPT;
- else if (family == wxT("swiss")) ifamily = wxSWISS;
- else if (family == wxT("modern")) ifamily = wxMODERN;
+ bool hasFamily = HasParam(wxT("family"));
+ if (hasFamily)
+ {
+ wxString family = GetParamValue(wxT("family"));
+ if (family == wxT("decorative")) ifamily = wxDECORATIVE;
+ else if (family == wxT("roman")) ifamily = wxROMAN;
+ else if (family == wxT("script")) ifamily = wxSCRIPT;
+ else if (family == wxT("swiss")) ifamily = wxSWISS;
+ else if (family == wxT("modern")) ifamily = wxMODERN;
+ else if (family == wxT("teletype")) ifamily = wxTELETYPE;
+ }
- bool underlined = GetBool(wxT("underlined"), false);
- wxString encoding = GetParamValue(wxT("encoding"));
- wxFontMapper mapper;
- wxFontEncoding enc = wxFONTENCODING_DEFAULT;
- if (!encoding.IsEmpty())
- enc = mapper.CharsetToEncoding(encoding);
- if (enc == wxFONTENCODING_SYSTEM)
- enc = wxFONTENCODING_DEFAULT;
-
- wxString faces = GetParamValue(wxT("face"));
- wxString facename = wxEmptyString;
- wxFontEnumerator enu;
- enu.EnumerateFacenames();
- wxStringTokenizer tk(faces, wxT(","));
- while (tk.HasMoreTokens())
+ wxString facename;
+ bool hasFacename = HasParam(wxT("face"));
+ if (hasFacename)
{
- int index = enu.GetFacenames()->Index(tk.GetNextToken(), false);
- if (index != wxNOT_FOUND)
+ wxString faces = GetParamValue(wxT("face"));
+ wxArrayString facenames(wxFontEnumerator::GetFacenames());
+ wxStringTokenizer tk(faces, wxT(","));
+ while (tk.HasMoreTokens())
{
- facename = (*enu.GetFacenames())[index];
- break;
+ int index = facenames.Index(tk.GetNextToken(), false);
+ if (index != wxNOT_FOUND)
+ {
+ facename = facenames[index];
+ break;
+ }
}
}
- m_node = oldnode;
+ // encoding
+ wxFontEncoding enc = wxFONTENCODING_DEFAULT;
+ bool hasEncoding = HasParam(wxT("encoding"));
+ if (hasEncoding)
+ {
+ wxString encoding = GetParamValue(wxT("encoding"));
+ wxFontMapper mapper;
+ if (!encoding.empty())
+ enc = mapper.CharsetToEncoding(encoding);
+ if (enc == wxFONTENCODING_SYSTEM)
+ enc = wxFONTENCODING_DEFAULT;
+ }
+
+ // is this font based on a system font?
+ wxFont font = GetSystemFont(GetParamValue(wxT("sysfont")));
+
+ if (font.Ok())
+ {
+ if (hasSize && isize != -1)
+ font.SetPointSize(isize);
+ else if (HasParam(wxT("relativesize")))
+ font.SetPointSize(int(font.GetPointSize() *
+ GetFloat(wxT("relativesize"))));
+
+ if (hasStyle)
+ font.SetStyle(istyle);
+ if (hasWeight)
+ font.SetWeight(iweight);
+ if (hasUnderlined)
+ font.SetUnderlined(underlined);
+ if (hasFamily)
+ font.SetFamily(ifamily);
+ if (hasFacename)
+ font.SetFaceName(facename);
+ if (hasEncoding)
+ font.SetDefaultEncoding(enc);
+ }
+ else // not based on system font
+ {
+ font = wxFont(isize == -1 ? wxNORMAL_FONT->GetPointSize() : isize,
+ ifamily, istyle, iweight,
+ underlined, facename, enc);
+ }
- wxFont font(size, ifamily, istyle, iweight, underlined, facename, enc);
+ m_node = oldnode;
return font;
}
#endif
if (HasParam(wxT("font")))
wnd->SetFont(GetFont());
+ if (HasParam(wxT("help")))
+ wnd->SetHelpText(GetText(wxT("help")));
}
static XRCID_record *XRCID_Records[XRCID_TABLE_SIZE] = {NULL};
-static int XRCID_Lookup(const wxChar *str_id, int value_if_not_found = -2)
+static int XRCID_Lookup(const wxChar *str_id, int value_if_not_found = wxID_NONE)
{
- static int XRCID_LastID = wxID_HIGHEST;
-
int index = 0;
for (const wxChar *c = str_id; *c != wxT('\0'); c++) index += (int)*c;
(*rec_var)->next = NULL;
wxChar *end;
- if (value_if_not_found != -2)
+ if (value_if_not_found != wxID_NONE)
(*rec_var)->id = value_if_not_found;
else
{
}
else
{
- (*rec_var)->id = ++XRCID_LastID;
+ (*rec_var)->id = wxNewId();
}
}
return (*rec_var)->id;
}
-/*static*/ int wxXmlResource::GetXRCID(const wxChar *str_id)
+static void AddStdXRCID_Records();
+
+/*static*/
+int wxXmlResource::GetXRCID(const wxChar *str_id, int value_if_not_found)
{
- return XRCID_Lookup(str_id);
+ static bool s_stdIDsAdded = false;
+
+ if ( !s_stdIDsAdded )
+ {
+ s_stdIDsAdded = true;
+ AddStdXRCID_Records();
+ }
+
+ return XRCID_Lookup(str_id, value_if_not_found);
}
stdID(wxID_ANY);
stdID(wxID_SEPARATOR);
-
+
stdID(wxID_OPEN);
stdID(wxID_CLOSE);
stdID(wxID_NEW);
stdID(wxID_HELP);
stdID(wxID_PRINT);
stdID(wxID_PRINT_SETUP);
+ stdID(wxID_PAGE_SETUP);
stdID(wxID_PREVIEW);
stdID(wxID_ABOUT);
stdID(wxID_HELP_CONTENTS);
wxXmlResourceModule() {}
bool OnInit()
{
- AddStdXRCID_Records();
wxXmlResource::AddSubclassFactory(new wxXmlSubclassFactoryCXX);
return true;
}
projects / wxWidgets.git / blobdiff