]> git.saurik.com Git - wxWidgets.git/blame_incremental - include/wx/xrc/xmlres.h
Don't create multiple parent-less top level frames in layout sample.
[wxWidgets.git] / include / wx / xrc / xmlres.h
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: wx/xrc/xmlres.h
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#ifndef _WX_XMLRES_H_
12#define _WX_XMLRES_H_
13
14#include "wx/defs.h"
15
16#if wxUSE_XRC
17
18#include "wx/string.h"
19#include "wx/dynarray.h"
20#include "wx/arrstr.h"
21#include "wx/datetime.h"
22#include "wx/list.h"
23#include "wx/gdicmn.h"
24#include "wx/filesys.h"
25#include "wx/bitmap.h"
26#include "wx/icon.h"
27#include "wx/artprov.h"
28#include "wx/colour.h"
29#include "wx/vector.h"
30
31#include "wx/xrc/xmlreshandler.h"
32
33class WXDLLIMPEXP_FWD_BASE wxFileName;
34
35class WXDLLIMPEXP_FWD_CORE wxIconBundle;
36class WXDLLIMPEXP_FWD_CORE wxImageList;
37class WXDLLIMPEXP_FWD_CORE wxMenu;
38class WXDLLIMPEXP_FWD_CORE wxMenuBar;
39class WXDLLIMPEXP_FWD_CORE wxDialog;
40class WXDLLIMPEXP_FWD_CORE wxPanel;
41class WXDLLIMPEXP_FWD_CORE wxWindow;
42class WXDLLIMPEXP_FWD_CORE wxFrame;
43class WXDLLIMPEXP_FWD_CORE wxToolBar;
44
45class WXDLLIMPEXP_FWD_XML wxXmlDocument;
46class WXDLLIMPEXP_FWD_XML wxXmlNode;
47class WXDLLIMPEXP_FWD_XRC wxXmlSubclassFactory;
48class wxXmlSubclassFactories;
49class wxXmlResourceModule;
50class wxXmlResourceDataRecords;
51
52// These macros indicate current version of XML resources (this information is
53// encoded in root node of XRC file as "version" property).
54//
55// Rules for increasing version number:
56// - change it only if you made incompatible change to the format. Addition
57// of new attribute to control handler is _not_ incompatible change, because
58// older versions of the library may ignore it.
59// - if you change version number, follow these steps:
60// - set major, minor and release numbers to respective version numbers of
61// the wxWidgets library (see wx/version.h)
62// - reset revision to 0 unless the first three are same as before,
63// in which case you should increase revision by one
64#define WX_XMLRES_CURRENT_VERSION_MAJOR 2
65#define WX_XMLRES_CURRENT_VERSION_MINOR 5
66#define WX_XMLRES_CURRENT_VERSION_RELEASE 3
67#define WX_XMLRES_CURRENT_VERSION_REVISION 0
68#define WX_XMLRES_CURRENT_VERSION_STRING wxT("2.5.3.0")
69
70#define WX_XMLRES_CURRENT_VERSION \
71 (WX_XMLRES_CURRENT_VERSION_MAJOR * 256*256*256 + \
72 WX_XMLRES_CURRENT_VERSION_MINOR * 256*256 + \
73 WX_XMLRES_CURRENT_VERSION_RELEASE * 256 + \
74 WX_XMLRES_CURRENT_VERSION_REVISION)
75
76enum wxXmlResourceFlags
77{
78 wxXRC_USE_LOCALE = 1,
79 wxXRC_NO_SUBCLASSING = 2,
80 wxXRC_NO_RELOADING = 4
81};
82
83// This class holds XML resources from one or more .xml files
84// (or derived forms, either binary or zipped -- see manual for
85// details).
86class WXDLLIMPEXP_XRC wxXmlResource : public wxObject
87{
88public:
89 // Constructor.
90 // Flags: wxXRC_USE_LOCALE
91 // translatable strings will be translated via _()
92 // using the given domain if specified
93 // wxXRC_NO_SUBCLASSING
94 // subclass property of object nodes will be ignored
95 // (useful for previews in XRC editors)
96 // wxXRC_NO_RELOADING
97 // don't check the modification time of the XRC files and
98 // reload them if they have changed on disk
99 wxXmlResource(int flags = wxXRC_USE_LOCALE,
100 const wxString& domain = wxEmptyString);
101
102 // Constructor.
103 // Flags: wxXRC_USE_LOCALE
104 // translatable strings will be translated via _()
105 // using the given domain if specified
106 // wxXRC_NO_SUBCLASSING
107 // subclass property of object nodes will be ignored
108 // (useful for previews in XRC editors)
109 wxXmlResource(const wxString& filemask, int flags = wxXRC_USE_LOCALE,
110 const wxString& domain = wxEmptyString);
111
112 // Destructor.
113 virtual ~wxXmlResource();
114
115 // Loads resources from XML files that match given filemask.
116 // This method understands wxFileSystem URLs if wxUSE_FILESYS.
117 bool Load(const wxString& filemask);
118
119 // Loads resources from single XRC file.
120 bool LoadFile(const wxFileName& file);
121
122 // Loads all XRC files from a directory.
123 bool LoadAllFiles(const wxString& dirname);
124
125 // Unload resource from the given XML file (wildcards not allowed)
126 bool Unload(const wxString& filename);
127
128 // Initialize handlers for all supported controls/windows. This will
129 // make the executable quite big because it forces linking against
130 // most of the wxWidgets library.
131 void InitAllHandlers();
132
133 // Initialize only a specific handler (or custom handler). Convention says
134 // that handler name is equal to the control's name plus 'XmlHandler', for
135 // example wxTextCtrlXmlHandler, wxHtmlWindowXmlHandler. The XML resource
136 // compiler (xmlres) can create include file that contains initialization
137 // code for all controls used within the resource.
138 void AddHandler(wxXmlResourceHandler *handler);
139
140 // Add a new handler at the beginning of the handler list
141 void InsertHandler(wxXmlResourceHandler *handler);
142
143 // Removes all handlers
144 void ClearHandlers();
145
146 // Registers subclasses factory for use in XRC. This function is not meant
147 // for public use, please see the comment above wxXmlSubclassFactory
148 // definition.
149 static void AddSubclassFactory(wxXmlSubclassFactory *factory);
150
151 // Loads menu from resource. Returns NULL on failure.
152 wxMenu *LoadMenu(const wxString& name);
153
154 // Loads menubar from resource. Returns NULL on failure.
155 wxMenuBar *LoadMenuBar(wxWindow *parent, const wxString& name);
156
157 // Loads menubar from resource. Returns NULL on failure.
158 wxMenuBar *LoadMenuBar(const wxString& name) { return LoadMenuBar(NULL, name); }
159
160#if wxUSE_TOOLBAR
161 // Loads a toolbar.
162 wxToolBar *LoadToolBar(wxWindow *parent, const wxString& name);
163#endif
164
165 // Loads a dialog. dlg points to parent window (if any).
166 wxDialog *LoadDialog(wxWindow *parent, const wxString& name);
167
168 // Loads a dialog. dlg points to parent window (if any). This form
169 // is used to finish creation of already existing instance (main reason
170 // for this is that you may want to use derived class with new event table)
171 // Example (typical usage):
172 // MyDialog dlg;
173 // wxTheXmlResource->LoadDialog(&dlg, mainFrame, "my_dialog");
174 // dlg->ShowModal();
175 bool LoadDialog(wxDialog *dlg, wxWindow *parent, const wxString& name);
176
177 // Loads a panel. panel points to parent window (if any).
178 wxPanel *LoadPanel(wxWindow *parent, const wxString& name);
179
180 // Loads a panel. panel points to parent window (if any). This form
181 // is used to finish creation of already existing instance.
182 bool LoadPanel(wxPanel *panel, wxWindow *parent, const wxString& name);
183
184 // Loads a frame.
185 wxFrame *LoadFrame(wxWindow* parent, const wxString& name);
186 bool LoadFrame(wxFrame* frame, wxWindow *parent, const wxString& name);
187
188 // Load an object from the resource specifying both the resource name and
189 // the classname. This lets you load nonstandard container windows.
190 wxObject *LoadObject(wxWindow *parent, const wxString& name,
191 const wxString& classname)
192 {
193 return DoLoadObject(parent, name, classname, false /* !recursive */);
194 }
195
196 // Load an object from the resource specifying both the resource name and
197 // the classname. This form lets you finish the creation of an existing
198 // instance.
199 bool LoadObject(wxObject *instance,
200 wxWindow *parent,
201 const wxString& name,
202 const wxString& classname)
203 {
204 return DoLoadObject(instance, parent, name, classname, false);
205 }
206
207 // These versions of LoadObject() look for the object with the given name
208 // recursively (breadth first) and can be used to instantiate an individual
209 // control defined anywhere in an XRC file. No check is done that the name
210 // is unique, it's up to the caller to ensure this.
211 wxObject *LoadObjectRecursively(wxWindow *parent,
212 const wxString& name,
213 const wxString& classname)
214 {
215 return DoLoadObject(parent, name, classname, true /* recursive */);
216 }
217
218 bool LoadObjectRecursively(wxObject *instance,
219 wxWindow *parent,
220 const wxString& name,
221 const wxString& classname)
222 {
223 return DoLoadObject(instance, parent, name, classname, true);
224 }
225
226 // Loads a bitmap resource from a file.
227 wxBitmap LoadBitmap(const wxString& name);
228
229 // Loads an icon resource from a file.
230 wxIcon LoadIcon(const wxString& name);
231
232 // Attaches an unknown control to the given panel/window/dialog.
233 // Unknown controls are used in conjunction with <object class="unknown">.
234 bool AttachUnknownControl(const wxString& name, wxWindow *control,
235 wxWindow *parent = NULL);
236
237 // Returns a numeric ID that is equivalent to the string ID used in an XML
238 // resource. If an unknown str_id is requested (i.e. other than wxID_XXX
239 // or integer), a new record is created which associates the given string
240 // with a number. If value_if_not_found == wxID_NONE, the number is obtained via
241 // wxWindow::NewControlId(). Otherwise value_if_not_found is used.
242 // Macro XRCID(name) is provided for convenient use in event tables.
243 static int GetXRCID(const wxString& str_id, int value_if_not_found = wxID_NONE)
244 { return DoGetXRCID(str_id.mb_str(), value_if_not_found); }
245
246 // version for internal use only
247 static int DoGetXRCID(const char *str_id, int value_if_not_found = wxID_NONE);
248
249
250 // Find the string ID with the given numeric value, returns an empty string
251 // if no such ID is found.
252 //
253 // Notice that unlike GetXRCID(), which is fast, this operation is slow as
254 // it checks all the IDs used in XRC.
255 static wxString FindXRCIDById(int numId);
256
257
258 // Returns version information (a.b.c.d = d+ 256*c + 256^2*b + 256^3*a).
259 long GetVersion() const { return m_version; }
260
261 // Compares resources version to argument. Returns -1 if resources version
262 // is less than the argument, +1 if greater and 0 if they equal.
263 int CompareVersion(int major, int minor, int release, int revision) const
264 { return GetVersion() -
265 (major*256*256*256 + minor*256*256 + release*256 + revision); }
266
267 //// Singleton accessors.
268
269 // Gets the global resources object or creates one if none exists.
270 static wxXmlResource *Get();
271
272 // Sets the global resources object and returns a pointer to the previous one (may be NULL).
273 static wxXmlResource *Set(wxXmlResource *res);
274
275 // Returns flags, which may be a bitlist of wxXRC_USE_LOCALE and wxXRC_NO_SUBCLASSING.
276 int GetFlags() const { return m_flags; }
277 // Set flags after construction.
278 void SetFlags(int flags) { m_flags = flags; }
279
280 // Get/Set the domain to be passed to the translation functions, defaults
281 // to empty string (no domain).
282 const wxString& GetDomain() const { return m_domain; }
283 void SetDomain(const wxString& domain);
284
285
286 // This function returns the wxXmlNode containing the definition of the
287 // object with the given name or NULL.
288 //
289 // It can be used to access additional information defined in the XRC file
290 // and not used by wxXmlResource itself.
291 const wxXmlNode *GetResourceNode(const wxString& name) const
292 { return GetResourceNodeAndLocation(name, wxString(), true); }
293
294protected:
295 // reports input error at position 'context'
296 void ReportError(const wxXmlNode *context, const wxString& message);
297
298 // override this in derived class to customize errors reporting
299 virtual void DoReportError(const wxString& xrcFile, const wxXmlNode *position,
300 const wxString& message);
301
302 // Load the contents of a single file and returns its contents as a new
303 // wxXmlDocument (which will be owned by caller) on success or NULL.
304 wxXmlDocument *DoLoadFile(const wxString& file);
305
306 // Scans the resources list for unloaded files and loads them. Also reloads
307 // files that have been modified since last loading.
308 bool UpdateResources();
309
310
311 // Common implementation of GetResourceNode() and FindResource(): searches
312 // all top-level or all (if recursive == true) nodes if all loaded XRC
313 // files and returns the node, if found, as well as the path of the file it
314 // was found in if path is non-NULL
315 wxXmlNode *GetResourceNodeAndLocation(const wxString& name,
316 const wxString& classname,
317 bool recursive = false,
318 wxString *path = NULL) const;
319
320
321 // Note that these functions are used outside of wxWidgets itself, e.g.
322 // there are several known cases of inheriting from wxXmlResource just to
323 // be able to call FindResource() so we keep them for compatibility even if
324 // their names are not really consistent with GetResourceNode() public
325 // function and FindResource() is also non-const because it changes the
326 // current path of m_curFileSystem to ensure that relative paths work
327 // correctly when CreateResFromNode() is called immediately afterwards
328 // (something const public function intentionally does not do)
329
330 // Returns the node containing the resource with the given name and class
331 // name unless it's empty (then any class matches) or NULL if not found.
332 wxXmlNode *FindResource(const wxString& name, const wxString& classname,
333 bool recursive = false);
334
335 // Helper function used by FindResource() to look under the given node.
336 wxXmlNode *DoFindResource(wxXmlNode *parent, const wxString& name,
337 const wxString& classname, bool recursive) const;
338
339 // Creates a resource from information in the given node
340 // (Uses only 'handlerToUse' if != NULL)
341 wxObject *CreateResFromNode(wxXmlNode *node, wxObject *parent,
342 wxObject *instance = NULL,
343 wxXmlResourceHandler *handlerToUse = NULL)
344 {
345 return node ? DoCreateResFromNode(*node, parent, instance, handlerToUse)
346 : NULL;
347 }
348
349 // Helper of Load() and Unload(): returns the URL corresponding to the
350 // given file if it's indeed a file, otherwise returns the original string
351 // unmodified
352 static wxString ConvertFileNameToURL(const wxString& filename);
353
354 // loading resources from archives is impossible without wxFileSystem
355#if wxUSE_FILESYSTEM
356 // Another helper: detect if the filename is a ZIP or XRS file
357 static bool IsArchive(const wxString& filename);
358#endif // wxUSE_FILESYSTEM
359
360private:
361 wxXmlResourceDataRecords& Data() { return *m_data; }
362 const wxXmlResourceDataRecords& Data() const { return *m_data; }
363
364 // the real implementation of CreateResFromNode(): this should be only
365 // called if node is non-NULL
366 wxObject *DoCreateResFromNode(wxXmlNode& node,
367 wxObject *parent,
368 wxObject *instance,
369 wxXmlResourceHandler *handlerToUse = NULL);
370
371 // common part of LoadObject() and LoadObjectRecursively()
372 wxObject *DoLoadObject(wxWindow *parent,
373 const wxString& name,
374 const wxString& classname,
375 bool recursive);
376 bool DoLoadObject(wxObject *instance,
377 wxWindow *parent,
378 const wxString& name,
379 const wxString& classname,
380 bool recursive);
381
382private:
383 long m_version;
384
385 int m_flags;
386 wxVector<wxXmlResourceHandler*> m_handlers;
387 wxXmlResourceDataRecords *m_data;
388#if wxUSE_FILESYSTEM
389 wxFileSystem m_curFileSystem;
390 wxFileSystem& GetCurFileSystem() { return m_curFileSystem; }
391#endif
392
393 // domain to pass to translation functions, if any.
394 wxString m_domain;
395
396 friend class wxXmlResourceHandlerImpl;
397 friend class wxXmlResourceModule;
398 friend class wxIdRangeManager;
399 friend class wxIdRange;
400
401 static wxXmlSubclassFactories *ms_subclassFactories;
402
403 // singleton instance:
404 static wxXmlResource *ms_instance;
405};
406
407
408// This macro translates string identifier (as used in XML resource,
409// e.g. <menuitem id="my_menu">...</menuitem>) to integer id that is needed by
410// wxWidgets event tables.
411// Example:
412// BEGIN_EVENT_TABLE(MyFrame, wxFrame)
413// EVT_MENU(XRCID("quit"), MyFrame::OnQuit)
414// EVT_MENU(XRCID("about"), MyFrame::OnAbout)
415// EVT_MENU(XRCID("new"), MyFrame::OnNew)
416// EVT_MENU(XRCID("open"), MyFrame::OnOpen)
417// END_EVENT_TABLE()
418
419#define XRCID(str_id) \
420 wxXmlResource::DoGetXRCID(str_id)
421
422
423// This macro returns pointer to particular control in dialog
424// created using XML resources. You can use it to set/get values from
425// controls.
426// Example:
427// wxDialog dlg;
428// wxXmlResource::Get()->LoadDialog(&dlg, mainFrame, "my_dialog");
429// XRCCTRL(dlg, "my_textctrl", wxTextCtrl)->SetValue(wxT("default value"));
430
431#define XRCCTRL(window, id, type) \
432 (wxStaticCast((window).FindWindow(XRCID(id)), type))
433
434// This macro returns pointer to sizer item
435// Example:
436//
437// <object class="spacer" name="area">
438// <size>400, 300</size>
439// </object>
440//
441// wxSizerItem* item = XRCSIZERITEM(*this, "area")
442
443#define XRCSIZERITEM(window, id) \
444 ((window).GetSizer() ? (window).GetSizer()->GetItemById(XRCID(id)) : NULL)
445
446
447// wxXmlResourceHandlerImpl is the back-end of the wxXmlResourceHander class to
448// really implementing all its functionality. It is defined in the "xrc"
449// library unlike wxXmlResourceHandler itself which is defined in "core" to
450// allow inheriting from it in the code from the other libraries too.
451
452class WXDLLIMPEXP_XRC wxXmlResourceHandlerImpl : public wxXmlResourceHandlerImplBase
453{
454public:
455 // Constructor.
456 wxXmlResourceHandlerImpl(wxXmlResourceHandler *handler);
457
458 // Destructor.
459 virtual ~wxXmlResourceHandlerImpl() {}
460
461 // Creates an object (menu, dialog, control, ...) from an XML node.
462 // Should check for validity.
463 // parent is a higher-level object (usually window, dialog or panel)
464 // that is often necessary to create the resource.
465 // If instance is non-NULL it should not create a new instance via 'new' but
466 // should rather use this one, and call its Create method.
467 wxObject *CreateResource(wxXmlNode *node, wxObject *parent,
468 wxObject *instance);
469
470
471 // --- Handy methods:
472
473 // Returns true if the node has a property class equal to classname,
474 // e.g. <object class="wxDialog">.
475 bool IsOfClass(wxXmlNode *node, const wxString& classname) const;
476
477 // Gets node content from wxXML_ENTITY_NODE
478 // The problem is, <tag>content<tag> is represented as
479 // wxXML_ENTITY_NODE name="tag", content=""
480 // |-- wxXML_TEXT_NODE or
481 // wxXML_CDATA_SECTION_NODE name="" content="content"
482 wxString GetNodeContent(const wxXmlNode *node);
483
484 // Check to see if a parameter exists.
485 bool HasParam(const wxString& param);
486
487 // Finds the node or returns NULL.
488 wxXmlNode *GetParamNode(const wxString& param);
489
490 // Finds the parameter value or returns the empty string.
491 wxString GetParamValue(const wxString& param);
492
493 // Returns the parameter value from given node.
494 wxString GetParamValue(const wxXmlNode* node);
495
496 // Gets style flags from text in form "flag | flag2| flag3 |..."
497 // Only understands flags added with AddStyle
498 int GetStyle(const wxString& param = wxT("style"), int defaults = 0);
499
500 // Gets text from param and does some conversions:
501 // - replaces \n, \r, \t by respective chars (according to C syntax)
502 // - replaces _ by & and __ by _ (needed for _File => &File because of XML)
503 // - calls wxGetTranslations (unless disabled in wxXmlResource)
504 wxString GetText(const wxString& param, bool translate = true);
505
506 // Returns the XRCID.
507 int GetID();
508
509 // Returns the resource name.
510 wxString GetName();
511
512 // Gets a bool flag (1, t, yes, on, true are true, everything else is false).
513 bool GetBool(const wxString& param, bool defaultv = false);
514
515 // Gets an integer value from the parameter.
516 long GetLong(const wxString& param, long defaultv = 0);
517
518 // Gets a float value from the parameter.
519 float GetFloat(const wxString& param, float defaultv = 0);
520
521 // Gets colour in HTML syntax (#RRGGBB).
522 wxColour GetColour(const wxString& param, const wxColour& defaultv = wxNullColour);
523
524 // Gets the size (may be in dialog units).
525 wxSize GetSize(const wxString& param = wxT("size"),
526 wxWindow *windowToUse = NULL);
527
528 // Gets the position (may be in dialog units).
529 wxPoint GetPosition(const wxString& param = wxT("pos"));
530
531 // Gets a dimension (may be in dialog units).
532 wxCoord GetDimension(const wxString& param, wxCoord defaultv = 0,
533 wxWindow *windowToUse = NULL);
534
535 // Gets a direction, complains if the value is invalid.
536 wxDirection GetDirection(const wxString& param, wxDirection dir = wxLEFT);
537
538 // Gets a bitmap.
539 wxBitmap GetBitmap(const wxString& param = wxT("bitmap"),
540 const wxArtClient& defaultArtClient = wxART_OTHER,
541 wxSize size = wxDefaultSize);
542
543 // Gets a bitmap from an XmlNode.
544 wxBitmap GetBitmap(const wxXmlNode* node,
545 const wxArtClient& defaultArtClient = wxART_OTHER,
546 wxSize size = wxDefaultSize);
547
548 // Gets an icon.
549 wxIcon GetIcon(const wxString& param = wxT("icon"),
550 const wxArtClient& defaultArtClient = wxART_OTHER,
551 wxSize size = wxDefaultSize);
552
553 // Gets an icon from an XmlNode.
554 wxIcon GetIcon(const wxXmlNode* node,
555 const wxArtClient& defaultArtClient = wxART_OTHER,
556 wxSize size = wxDefaultSize);
557
558 // Gets an icon bundle.
559 wxIconBundle GetIconBundle(const wxString& param,
560 const wxArtClient& defaultArtClient = wxART_OTHER);
561
562 // Gets an image list.
563 wxImageList *GetImageList(const wxString& param = wxT("imagelist"));
564
565#if wxUSE_ANIMATIONCTRL
566 // Gets an animation.
567 wxAnimation* GetAnimation(const wxString& param = wxT("animation"));
568#endif
569
570 // Gets a font.
571 wxFont GetFont(const wxString& param = wxT("font"), wxWindow* parent = NULL);
572
573 // Gets the value of a boolean attribute (only "0" and "1" are valid values)
574 bool GetBoolAttr(const wxString& attr, bool defaultv);
575
576
577 // Sets common window options.
578 void SetupWindow(wxWindow *wnd);
579
580 // Creates children.
581 void CreateChildren(wxObject *parent, bool this_hnd_only = false);
582
583 // Helper function.
584 void CreateChildrenPrivately(wxObject *parent, wxXmlNode *rootnode = NULL);
585
586 // Creates a resource from a node.
587 wxObject *CreateResFromNode(wxXmlNode *node,
588 wxObject *parent, wxObject *instance = NULL);
589
590 // helper
591#if wxUSE_FILESYSTEM
592 wxFileSystem& GetCurFileSystem();
593#endif
594
595 // reports input error at position 'context'
596 void ReportError(wxXmlNode *context, const wxString& message);
597 // reports input error at m_node
598 void ReportError(const wxString& message);
599 // reports input error when parsing parameter with given name
600 void ReportParamError(const wxString& param, const wxString& message);
601};
602
603
604// Programmer-friendly macros for writing XRC handlers:
605
606#define XRC_MAKE_INSTANCE(variable, classname) \
607 classname *variable = NULL; \
608 if (m_instance) \
609 variable = wxStaticCast(m_instance, classname); \
610 if (!variable) \
611 variable = new classname;
612
613
614// FIXME -- remove this $%^#$%#$@# as soon as Ron checks his changes in!!
615WXDLLIMPEXP_XRC void wxXmlInitResourceModule();
616
617
618// This class is used to create instances of XRC "object" nodes with "subclass"
619// property. It is _not_ supposed to be used by XRC users, you should instead
620// register your subclasses via wxWidgets' RTTI mechanism. This class is useful
621// only for language bindings developer who need a way to implement subclassing
622// in wxWidgets ports that don't support wxRTTI (e.g. wxPython).
623class WXDLLIMPEXP_XRC wxXmlSubclassFactory
624{
625public:
626 // Try to create instance of given class and return it, return NULL on
627 // failure:
628 virtual wxObject *Create(const wxString& className) = 0;
629 virtual ~wxXmlSubclassFactory() {}
630};
631
632
633/* -------------------------------------------------------------------------
634 Backward compatibility macros. Do *NOT* use, they may disappear in future
635 versions of the XRC library!
636 ------------------------------------------------------------------------- */
637
638#endif // wxUSE_XRC
639
640#endif // _WX_XMLRES_H_