src/xrc/xmlres.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/xrc/xmlres.cpp
   3 // Purpose:     XRC resources
   4 // Author:      Vaclav Slavik
   5 // Created:     2000/03/05
   6 // Copyright:   (c) 2000 Vaclav Slavik
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 // For compilers that support precompilation, includes "wx.h".
  11 #include "wx/wxprec.h"
  12
  13 #ifdef __BORLANDC__
  14     #pragma hdrstop
  15 #endif
  16
  17 #if wxUSE_XRC
  18
  19 #include "wx/xrc/xmlres.h"
  20
  21 #ifndef WX_PRECOMP
  22     #include "wx/intl.h"
  23     #include "wx/log.h"
  24     #include "wx/panel.h"
  25     #include "wx/frame.h"
  26     #include "wx/dialog.h"
  27     #include "wx/settings.h"
  28     #include "wx/bitmap.h"
  29     #include "wx/image.h"
  30     #include "wx/module.h"
  31     #include "wx/wxcrtvararg.h"
  32 #endif
  33
  34 #ifndef __WXWINCE__
  35     #include <locale.h>
  36 #endif
  37
  38 #include "wx/vector.h"
  39 #include "wx/wfstream.h"
  40 #include "wx/filesys.h"
  41 #include "wx/filename.h"
  42 #include "wx/tokenzr.h"
  43 #include "wx/fontenum.h"
  44 #include "wx/fontmap.h"
  45 #include "wx/artprov.h"
  46 #include "wx/imaglist.h"
  47 #include "wx/dir.h"
  48 #include "wx/xml/xml.h"
  49 #include "wx/hashset.h"
  50 #include "wx/scopedptr.h"
  51
  52 namespace
  53 {
  54
  55 // Helper function to get modification time of either a wxFileSystem URI or
  56 // just a normal file name, depending on the build.
  57 #if wxUSE_DATETIME
  58
  59 wxDateTime GetXRCFileModTime(const wxString& filename)
  60 {
  61 #if wxUSE_FILESYSTEM
  62     wxFileSystem fsys;
  63     wxScopedPtr<wxFSFile> file(fsys.OpenFile(filename));
  64
  65     return file ? file->GetModificationTime() : wxDateTime();
  66 #else // wxUSE_FILESYSTEM
  67     return wxDateTime(wxFileModificationTime(filename));
  68 #endif // wxUSE_FILESYSTEM
  69 }
  70
  71 #endif // wxUSE_DATETIME
  72
  73 } // anonymous namespace
  74
  75 // Assign the given value to the specified entry or add a new value with this
  76 // name.
  77 static void XRCID_Assign(const wxString& str_id, int value);
  78
  79 class wxXmlResourceDataRecord
  80 {
  81 public:
  82     // Ctor takes ownership of the document pointer.
  83     wxXmlResourceDataRecord(const wxString& File_,
  84                             wxXmlDocument *Doc_
  85                            )
  86         : File(File_), Doc(Doc_)
  87     {
  88 #if wxUSE_DATETIME
  89         Time = GetXRCFileModTime(File);
  90 #endif
  91     }
  92
  93     ~wxXmlResourceDataRecord() {delete Doc;}
  94
  95     wxString File;
  96     wxXmlDocument *Doc;
  97 #if wxUSE_DATETIME
  98     wxDateTime Time;
  99 #endif
 100
 101     wxDECLARE_NO_COPY_CLASS(wxXmlResourceDataRecord);
 102 };
 103
 104 class wxXmlResourceDataRecords : public wxVector<wxXmlResourceDataRecord*>
 105 {
 106     // this is a class so that it can be forward-declared
 107 };
 108
 109 WX_DECLARE_HASH_SET_PTR(int, wxIntegerHash, wxIntegerEqual, wxHashSetInt);
 110
 111 class wxIdRange // Holds data for a particular rangename
 112 {
 113 protected:
 114     wxIdRange(const wxXmlNode* node,
 115               const wxString& rname,
 116               const wxString& startno,
 117               const wxString& rsize);
 118
 119     // Note the existence of an item within the range
 120     void NoteItem(const wxXmlNode* node, const wxString& item);
 121
 122     // The manager is telling us that it's finished adding items
 123     void Finalise(const wxXmlNode* node);
 124
 125     wxString GetName() const { return m_name; }
 126     bool IsFinalised() const { return m_finalised; }
 127
 128     const wxString m_name;
 129     int m_start;
 130     int m_end;
 131     unsigned int m_size;
 132     bool m_item_end_found;
 133     bool m_finalised;
 134     wxHashSetInt m_indices;
 135
 136     friend class wxIdRangeManager;
 137 };
 138
 139 class wxIdRangeManager
 140 {
 141 public:
 142     ~wxIdRangeManager();
 143     // Gets the global resources object or creates one if none exists.
 144     static wxIdRangeManager *Get();
 145
 146     // Sets the global resources object and returns a pointer to the previous
 147     // one (may be NULL).
 148     static wxIdRangeManager *Set(wxIdRangeManager *res);
 149
 150     // Create a new IDrange from this node
 151     void AddRange(const wxXmlNode* node);
 152     // Tell the IdRange that this item exists, and should be pre-allocated an ID
 153     void NotifyRangeOfItem(const wxXmlNode* node, const wxString& item) const;
 154     // Tells all IDranges that they're now complete, and can create their IDs
 155     void FinaliseRanges(const wxXmlNode* node) const;
 156     // Searches for a known IdRange matching 'name', returning its index or -1
 157     int Find(const wxString& rangename) const;
 158
 159 protected:
 160     wxIdRange* FindRangeForItem(const wxXmlNode* node,
 161                                 const wxString& item,
 162                                 wxString& value) const;
 163     wxVector<wxIdRange*> m_IdRanges;
 164
 165 private:
 166     static wxIdRangeManager *ms_instance;
 167 };
 168
 169 namespace
 170 {
 171
 172 // helper used by DoFindResource() and elsewhere: returns true if this is an
 173 // object or object_ref node
 174 //
 175 // node must be non-NULL
 176 inline bool IsObjectNode(wxXmlNode *node)
 177 {
 178     return node->GetType() == wxXML_ELEMENT_NODE &&
 179              (node->GetName() == wxS("object") ||
 180                 node->GetName() == wxS("object_ref"));
 181 }
 182
 183 // special XML attribute with name of input file, see GetFileNameFromNode()
 184 const char *ATTR_INPUT_FILENAME = "__wx:filename";
 185
 186 // helper to get filename corresponding to an XML node
 187 wxString
 188 GetFileNameFromNode(const wxXmlNode *node, const wxXmlResourceDataRecords& files)
 189 {
 190     // this loop does two things: it looks for ATTR_INPUT_FILENAME among
 191     // parents and if it isn't used, it finds the root of the XML tree 'node'
 192     // is in
 193     for ( ;; )
 194     {
 195         // in some rare cases (specifically, when an <object_ref> is used, see
 196         // wxXmlResource::CreateResFromNode() and MergeNodesOver()), we work
 197         // with XML nodes that are not rooted in any document from 'files'
 198         // (because a new node was created by CreateResFromNode() to merge the
 199         // content of <object_ref> and the referenced <object>); in that case,
 200         // we hack around the problem by putting the information about input
 201         // file into a custom attribute
 202         if ( node->HasAttribute(ATTR_INPUT_FILENAME) )
 203             return node->GetAttribute(ATTR_INPUT_FILENAME);
 204
 205         if ( !node->GetParent() )
 206             break; // we found the root of this XML tree
 207
 208         node = node->GetParent();
 209     }
 210
 211     // NB: 'node' now points to the root of XML document
 212
 213     for ( wxXmlResourceDataRecords::const_iterator i = files.begin();
 214           i != files.end(); ++i )
 215     {
 216         if ( (*i)->Doc->GetRoot() == node )
 217         {
 218             return (*i)->File;
 219         }
 220     }
 221
 222     return wxEmptyString; // not found
 223 }
 224
 225 } // anonymous namespace
 226
 227
 228 wxXmlResource *wxXmlResource::ms_instance = NULL;
 229
 230 /*static*/ wxXmlResource *wxXmlResource::Get()
 231 {
 232     if ( !ms_instance )
 233         ms_instance = new wxXmlResource;
 234     return ms_instance;
 235 }
 236
 237 /*static*/ wxXmlResource *wxXmlResource::Set(wxXmlResource *res)
 238 {
 239     wxXmlResource *old = ms_instance;
 240     ms_instance = res;
 241     return old;
 242 }
 243
 244 wxXmlResource::wxXmlResource(int flags, const wxString& domain)
 245 {
 246     m_flags = flags;
 247     m_version = -1;
 248     m_data = new wxXmlResourceDataRecords;
 249     SetDomain(domain);
 250 }
 251
 252 wxXmlResource::wxXmlResource(const wxString& filemask, int flags, const wxString& domain)
 253 {
 254     m_flags = flags;
 255     m_version = -1;
 256     m_data = new wxXmlResourceDataRecords;
 257     SetDomain(domain);
 258     Load(filemask);
 259 }
 260
 261 wxXmlResource::~wxXmlResource()
 262 {
 263     ClearHandlers();
 264
 265     for ( wxXmlResourceDataRecords::iterator i = m_data->begin();
 266           i != m_data->end(); ++i )
 267     {
 268         delete *i;
 269     }
 270     delete m_data;
 271 }
 272
 273 void wxXmlResource::SetDomain(const wxString& domain)
 274 {
 275     m_domain = domain;
 276 }
 277
 278
 279 /* static */
 280 wxString wxXmlResource::ConvertFileNameToURL(const wxString& filename)
 281 {
 282     wxString fnd(filename);
 283
 284     // NB: as Load() and Unload() accept both filenames and URLs (should
 285     //     probably be changed to filenames only, but embedded resources
 286     //     currently rely on its ability to handle URLs - FIXME) we need to
 287     //     determine whether found name is filename and not URL and this is the
 288     //     fastest/simplest way to do it
 289     if (wxFileName::FileExists(fnd))
 290     {
 291         // Make the name absolute filename, because the app may
 292         // change working directory later:
 293         wxFileName fn(fnd);
 294         if (fn.IsRelative())
 295         {
 296             fn.MakeAbsolute();
 297             fnd = fn.GetFullPath();
 298         }
 299 #if wxUSE_FILESYSTEM
 300         fnd = wxFileSystem::FileNameToURL(fnd);
 301 #endif
 302     }
 303
 304     return fnd;
 305 }
 306
 307 #if wxUSE_FILESYSTEM
 308
 309 /* static */
 310 bool wxXmlResource::IsArchive(const wxString& filename)
 311 {
 312     const wxString fnd = filename.Lower();
 313
 314     return fnd.Matches(wxT("*.zip")) || fnd.Matches(wxT("*.xrs"));
 315 }
 316
 317 #endif // wxUSE_FILESYSTEM
 318
 319 bool wxXmlResource::LoadFile(const wxFileName& file)
 320 {
 321 #if wxUSE_FILESYSTEM
 322     return Load(wxFileSystem::FileNameToURL(file));
 323 #else
 324     return Load(file.GetFullPath());
 325 #endif
 326 }
 327
 328 bool wxXmlResource::LoadAllFiles(const wxString& dirname)
 329 {
 330     bool ok = true;
 331     wxArrayString files;
 332
 333     wxDir::GetAllFiles(dirname, &files, "*.xrc");
 334
 335     for ( wxArrayString::const_iterator i = files.begin(); i != files.end(); ++i )
 336     {
 337         if ( !LoadFile(*i) )
 338             ok = false;
 339     }
 340
 341     return ok;
 342 }
 343
 344 bool wxXmlResource::Load(const wxString& filemask_)
 345 {
 346     wxString filemask = ConvertFileNameToURL(filemask_);
 347
 348     bool allOK = true;
 349
 350 #if wxUSE_FILESYSTEM
 351     wxFileSystem fsys;
 352 #   define wxXmlFindFirst  fsys.FindFirst(filemask, wxFILE)
 353 #   define wxXmlFindNext   fsys.FindNext()
 354 #else
 355 #   define wxXmlFindFirst  wxFindFirstFile(filemask, wxFILE)
 356 #   define wxXmlFindNext   wxFindNextFile()
 357 #endif
 358     wxString fnd = wxXmlFindFirst;
 359     if ( fnd.empty() )
 360     {
 361         wxLogError(_("Cannot load resources from '%s'."), filemask);
 362         return false;
 363     }
 364
 365     while (!fnd.empty())
 366     {
 367 #if wxUSE_FILESYSTEM
 368         if ( IsArchive(fnd) )
 369         {
 370             if ( !Load(fnd + wxT("#zip:*.xrc")) )
 371                 allOK = false;
 372         }
 373         else // a single resource URL
 374 #endif // wxUSE_FILESYSTEM
 375         {
 376             wxXmlDocument * const doc = DoLoadFile(fnd);
 377             if ( !doc )
 378                 allOK = false;
 379             else
 380                 Data().push_back(new wxXmlResourceDataRecord(fnd, doc));
 381         }
 382
 383         fnd = wxXmlFindNext;
 384     }
 385 #   undef wxXmlFindFirst
 386 #   undef wxXmlFindNext
 387
 388     return allOK;
 389 }
 390
 391 bool wxXmlResource::Unload(const wxString& filename)
 392 {
 393     wxASSERT_MSG( !wxIsWild(filename),
 394                     wxT("wildcards not supported by wxXmlResource::Unload()") );
 395
 396     wxString fnd = ConvertFileNameToURL(filename);
 397 #if wxUSE_FILESYSTEM
 398     const bool isArchive = IsArchive(fnd);
 399     if ( isArchive )
 400         fnd += wxT("#zip:");
 401 #endif // wxUSE_FILESYSTEM
 402
 403     bool unloaded = false;
 404     for ( wxXmlResourceDataRecords::iterator i = Data().begin();
 405           i != Data().end(); ++i )
 406     {
 407 #if wxUSE_FILESYSTEM
 408         if ( isArchive )
 409         {
 410             if ( (*i)->File.StartsWith(fnd) )
 411                 unloaded = true;
 412             // don't break from the loop, we can have other matching files
 413         }
 414         else // a single resource URL
 415 #endif // wxUSE_FILESYSTEM
 416         {
 417             if ( (*i)->File == fnd )
 418             {
 419                 delete *i;
 420                 Data().erase(i);
 421                 unloaded = true;
 422
 423                 // no sense in continuing, there is only one file with this URL
 424                 break;
 425             }
 426         }
 427     }
 428
 429     return unloaded;
 430 }
 431
 432
 433 void wxXmlResource::AddHandler(wxXmlResourceHandler *handler)
 434 {
 435     wxXmlResourceHandlerImpl *impl = new wxXmlResourceHandlerImpl(handler);
 436     handler->SetImpl(impl);
 437     m_handlers.push_back(handler);
 438     handler->SetParentResource(this);
 439 }
 440
 441 void wxXmlResource::InsertHandler(wxXmlResourceHandler *handler)
 442 {
 443     wxXmlResourceHandlerImpl *impl = new wxXmlResourceHandlerImpl(handler);
 444     handler->SetImpl(impl);
 445     m_handlers.insert(m_handlers.begin(), handler);
 446     handler->SetParentResource(this);
 447 }
 448
 449
 450
 451 void wxXmlResource::ClearHandlers()
 452 {
 453     for ( wxVector<wxXmlResourceHandler*>::iterator i = m_handlers.begin();
 454           i != m_handlers.end(); ++i )
 455         delete *i;
 456     m_handlers.clear();
 457 }
 458
 459
 460 wxMenu *wxXmlResource::LoadMenu(const wxString& name)
 461 {
 462     return (wxMenu*)CreateResFromNode(FindResource(name, wxT("wxMenu")), NULL, NULL);
 463 }
 464
 465
 466
 467 wxMenuBar *wxXmlResource::LoadMenuBar(wxWindow *parent, const wxString& name)
 468 {
 469     return (wxMenuBar*)CreateResFromNode(FindResource(name, wxT("wxMenuBar")), parent, NULL);
 470 }
 471
 472
 473
 474 #if wxUSE_TOOLBAR
 475 wxToolBar *wxXmlResource::LoadToolBar(wxWindow *parent, const wxString& name)
 476 {
 477     return (wxToolBar*)CreateResFromNode(FindResource(name, wxT("wxToolBar")), parent, NULL);
 478 }
 479 #endif
 480
 481
 482 wxDialog *wxXmlResource::LoadDialog(wxWindow *parent, const wxString& name)
 483 {
 484     return (wxDialog*)CreateResFromNode(FindResource(name, wxT("wxDialog")), parent, NULL);
 485 }
 486
 487 bool wxXmlResource::LoadDialog(wxDialog *dlg, wxWindow *parent, const wxString& name)
 488 {
 489     return CreateResFromNode(FindResource(name, wxT("wxDialog")), parent, dlg) != NULL;
 490 }
 491
 492
 493
 494 wxPanel *wxXmlResource::LoadPanel(wxWindow *parent, const wxString& name)
 495 {
 496     return (wxPanel*)CreateResFromNode(FindResource(name, wxT("wxPanel")), parent, NULL);
 497 }
 498
 499 bool wxXmlResource::LoadPanel(wxPanel *panel, wxWindow *parent, const wxString& name)
 500 {
 501     return CreateResFromNode(FindResource(name, wxT("wxPanel")), parent, panel) != NULL;
 502 }
 503
 504 wxFrame *wxXmlResource::LoadFrame(wxWindow* parent, const wxString& name)
 505 {
 506     return (wxFrame*)CreateResFromNode(FindResource(name, wxT("wxFrame")), parent, NULL);
 507 }
 508
 509 bool wxXmlResource::LoadFrame(wxFrame* frame, wxWindow *parent, const wxString& name)
 510 {
 511     return CreateResFromNode(FindResource(name, wxT("wxFrame")), parent, frame) != NULL;
 512 }
 513
 514 wxBitmap wxXmlResource::LoadBitmap(const wxString& name)
 515 {
 516     wxBitmap *bmp = (wxBitmap*)CreateResFromNode(
 517                                FindResource(name, wxT("wxBitmap")), NULL, NULL);
 518     wxBitmap rt;
 519
 520     if (bmp) { rt = *bmp; delete bmp; }
 521     return rt;
 522 }
 523
 524 wxIcon wxXmlResource::LoadIcon(const wxString& name)
 525 {
 526     wxIcon *icon = (wxIcon*)CreateResFromNode(
 527                             FindResource(name, wxT("wxIcon")), NULL, NULL);
 528     wxIcon rt;
 529
 530     if (icon) { rt = *icon; delete icon; }
 531     return rt;
 532 }
 533
 534
 535 wxObject *
 536 wxXmlResource::DoLoadObject(wxWindow *parent,
 537                             const wxString& name,
 538                             const wxString& classname,
 539                             bool recursive)
 540 {
 541     wxXmlNode * const node = FindResource(name, classname, recursive);
 542
 543     return node ? DoCreateResFromNode(*node, parent, NULL) : NULL;
 544 }
 545
 546 bool
 547 wxXmlResource::DoLoadObject(wxObject *instance,
 548                             wxWindow *parent,
 549                             const wxString& name,
 550                             const wxString& classname,
 551                             bool recursive)
 552 {
 553     wxXmlNode * const node = FindResource(name, classname, recursive);
 554
 555     return node && DoCreateResFromNode(*node, parent, instance) != NULL;
 556 }
 557
 558
 559 bool wxXmlResource::AttachUnknownControl(const wxString& name,
 560                                          wxWindow *control, wxWindow *parent)
 561 {
 562     if (parent == NULL)
 563         parent = control->GetParent();
 564     wxWindow *container = parent->FindWindow(name + wxT("_container"));
 565     if (!container)
 566     {
 567         wxLogError("Cannot find container for unknown control '%s'.", name);
 568         return false;
 569     }
 570     return control->Reparent(container);
 571 }
 572
 573
 574 static void ProcessPlatformProperty(wxXmlNode *node)
 575 {
 576     wxString s;
 577     bool isok;
 578
 579     wxXmlNode *c = node->GetChildren();
 580     while (c)
 581     {
 582         isok = false;
 583         if (!c->GetAttribute(wxT("platform"), &s))
 584             isok = true;
 585         else
 586         {
 587             wxStringTokenizer tkn(s, wxT(" |"));
 588
 589             while (tkn.HasMoreTokens())
 590             {
 591                 s = tkn.GetNextToken();
 592 #ifdef __WINDOWS__
 593                 if (s == wxT("win")) isok = true;
 594 #endif
 595 #if defined(__MAC__) || defined(__APPLE__)
 596                 if (s == wxT("mac")) isok = true;
 597 #elif defined(__UNIX__)
 598                 if (s == wxT("unix")) isok = true;
 599 #endif
 600 #ifdef __OS2__
 601                 if (s == wxT("os2")) isok = true;
 602 #endif
 603
 604                 if (isok)
 605                     break;
 606             }
 607         }
 608
 609         if (isok)
 610         {
 611             ProcessPlatformProperty(c);
 612             c = c->GetNext();
 613         }
 614         else
 615         {
 616             wxXmlNode *c2 = c->GetNext();
 617             node->RemoveChild(c);
 618             delete c;
 619             c = c2;
 620         }
 621     }
 622 }
 623
 624 static void PreprocessForIdRanges(wxXmlNode *rootnode)
 625 {
 626     // First go through the top level, looking for the names of ID ranges
 627     // as processing items is a lot easier if names are already known
 628     wxXmlNode *c = rootnode->GetChildren();
 629     while (c)
 630     {
 631         if (c->GetName() == wxT("ids-range"))
 632             wxIdRangeManager::Get()->AddRange(c);
 633         c = c->GetNext();
 634     }
 635
 636     // Next, examine every 'name' for the '[' that denotes an ID in a range
 637     c = rootnode->GetChildren();
 638     while (c)
 639     {
 640         wxString name = c->GetAttribute(wxT("name"));
 641         if (name.find('[') != wxString::npos)
 642             wxIdRangeManager::Get()->NotifyRangeOfItem(rootnode, name);
 643
 644         // Do any children by recursion, then proceed to the next sibling
 645         PreprocessForIdRanges(c);
 646         c = c->GetNext();
 647     }
 648 }
 649
 650 bool wxXmlResource::UpdateResources()
 651 {
 652     bool rt = true;
 653
 654     for ( wxXmlResourceDataRecords::iterator i = Data().begin();
 655           i != Data().end(); ++i )
 656     {
 657         wxXmlResourceDataRecord* const rec = *i;
 658
 659         // Check if we need to reload this one.
 660
 661         // We never do it if this flag is specified.
 662         if ( m_flags & wxXRC_NO_RELOADING )
 663             continue;
 664
 665         // Otherwise check its modification time if we can.
 666 #if wxUSE_DATETIME
 667         const wxDateTime lastModTime = GetXRCFileModTime(rec->File);
 668
 669         if ( lastModTime.IsValid() && lastModTime <= rec->Time )
 670 #else // !wxUSE_DATETIME
 671         // Never reload the file contents: we can't know whether it changed or
 672         // not in this build configuration and it would be unexpected and
 673         // counter-productive to get a performance hit (due to constant
 674         // reloading of XRC files) in a minimal wx build which is presumably
 675         // used because of resource constraints of the current platform.
 676 #endif // wxUSE_DATETIME/!wxUSE_DATETIME
 677         {
 678             // No need to reload, the file wasn't modified since we did it
 679             // last.
 680             continue;
 681         }
 682
 683         wxXmlDocument * const doc = DoLoadFile(rec->File);
 684         if ( !doc )
 685         {
 686             // Notice that we keep the old XML document: it seems better to
 687             // preserve it instead of throwing it away if we have nothing to
 688             // replace it with.
 689             rt = false;
 690             continue;
 691         }
 692
 693         // Replace the old resource contents with the new one.
 694         delete rec->Doc;
 695         rec->Doc = doc;
 696
 697         // And, now that we loaded it successfully, update the last load time.
 698 #if wxUSE_DATETIME
 699         rec->Time = lastModTime.IsValid() ? lastModTime : wxDateTime::Now();
 700 #endif // wxUSE_DATETIME
 701     }
 702
 703     return rt;
 704 }
 705
 706 wxXmlDocument *wxXmlResource::DoLoadFile(const wxString& filename)
 707 {
 708     wxLogTrace(wxT("xrc"), wxT("opening file '%s'"), filename);
 709
 710     wxInputStream *stream = NULL;
 711
 712 #if wxUSE_FILESYSTEM
 713     wxFileSystem fsys;
 714     wxScopedPtr<wxFSFile> file(fsys.OpenFile(filename));
 715     if (file)
 716     {
 717         // Notice that we don't have ownership of the stream in this case, it
 718         // remains owned by wxFSFile.
 719         stream = file->GetStream();
 720     }
 721 #else // !wxUSE_FILESYSTEM
 722     wxFileInputStream fstream(filename);
 723     stream = &fstream;
 724 #endif // wxUSE_FILESYSTEM/!wxUSE_FILESYSTEM
 725
 726     if ( !stream || !stream->IsOk() )
 727     {
 728         wxLogError(_("Cannot open resources file '%s'."), filename);
 729         return NULL;
 730     }
 731
 732     wxString encoding(wxT("UTF-8"));
 733 #if !wxUSE_UNICODE && wxUSE_INTL
 734     if ( (GetFlags() & wxXRC_USE_LOCALE) == 0 )
 735     {
 736         // In case we are not using wxLocale to translate strings, convert the
 737         // strings GUI's charset. This must not be done when wxXRC_USE_LOCALE
 738         // is on, because it could break wxGetTranslation lookup.
 739         encoding = wxLocale::GetSystemEncodingName();
 740     }
 741 #endif
 742
 743     wxScopedPtr<wxXmlDocument> doc(new wxXmlDocument);
 744     if (!doc->Load(*stream, encoding))
 745     {
 746         wxLogError(_("Cannot load resources from file '%s'."), filename);
 747         return NULL;
 748     }
 749
 750     wxXmlNode * const root = doc->GetRoot();
 751     if (root->GetName() != wxT("resource"))
 752     {
 753         ReportError
 754         (
 755             root,
 756             "invalid XRC resource, doesn't have root node <resource>"
 757         );
 758         return NULL;
 759     }
 760
 761     long version;
 762     int v1, v2, v3, v4;
 763     wxString verstr = root->GetAttribute(wxT("version"), wxT("0.0.0.0"));
 764     if (wxSscanf(verstr, wxT("%i.%i.%i.%i"), &v1, &v2, &v3, &v4) == 4)
 765         version = v1*256*256*256+v2*256*256+v3*256+v4;
 766     else
 767         version = 0;
 768     if (m_version == -1)
 769         m_version = version;
 770     if (m_version != version)
 771     {
 772         wxLogWarning("Resource files must have same version number.");
 773     }
 774
 775     ProcessPlatformProperty(root);
 776     PreprocessForIdRanges(root);
 777     wxIdRangeManager::Get()->FinaliseRanges(root);
 778
 779     return doc.release();
 780 }
 781
 782 wxXmlNode *wxXmlResource::DoFindResource(wxXmlNode *parent,
 783                                          const wxString& name,
 784                                          const wxString& classname,
 785                                          bool recursive) const
 786 {
 787     wxXmlNode *node;
 788
 789     // first search for match at the top-level nodes (as this is
 790     // where the resource is most commonly looked for):
 791     for (node = parent->GetChildren(); node; node = node->GetNext())
 792     {
 793         if ( IsObjectNode(node) && node->GetAttribute(wxS("name")) == name )
 794         {
 795             // empty class name matches everything
 796             if ( classname.empty() )
 797                 return node;
 798
 799             wxString cls(node->GetAttribute(wxS("class")));
 800
 801             // object_ref may not have 'class' attribute:
 802             if (cls.empty() && node->GetName() == wxS("object_ref"))
 803             {
 804                 wxString refName = node->GetAttribute(wxS("ref"));
 805                 if (refName.empty())
 806                     continue;
 807
 808                 const wxXmlNode * const refNode = GetResourceNode(refName);
 809                 if ( refNode )
 810                     cls = refNode->GetAttribute(wxS("class"));
 811             }
 812
 813             if ( cls == classname )
 814                 return node;
 815         }
 816     }
 817
 818     // then recurse in child nodes
 819     if ( recursive )
 820     {
 821         for (node = parent->GetChildren(); node; node = node->GetNext())
 822         {
 823             if ( IsObjectNode(node) )
 824             {
 825                 wxXmlNode* found = DoFindResource(node, name, classname, true);
 826                 if ( found )
 827                     return found;
 828             }
 829         }
 830     }
 831
 832     return NULL;
 833 }
 834
 835 wxXmlNode *wxXmlResource::FindResource(const wxString& name,
 836                                        const wxString& classname,
 837                                        bool recursive)
 838 {
 839     wxString path;
 840     wxXmlNode * const
 841         node = GetResourceNodeAndLocation(name, classname, recursive, &path);
 842
 843     if ( !node )
 844     {
 845         ReportError
 846         (
 847             NULL,
 848             wxString::Format
 849             (
 850                 "XRC resource \"%s\" (class \"%s\") not found",
 851                 name, classname
 852             )
 853         );
 854     }
 855 #if wxUSE_FILESYSTEM
 856     else // node was found
 857     {
 858         // ensure that relative paths work correctly when loading this node
 859         // (which should happen as soon as we return as FindResource() result
 860         // is always passed to CreateResFromNode())
 861         m_curFileSystem.ChangePathTo(path);
 862     }
 863 #endif // wxUSE_FILESYSTEM
 864
 865     return node;
 866 }
 867
 868 wxXmlNode *
 869 wxXmlResource::GetResourceNodeAndLocation(const wxString& name,
 870                                           const wxString& classname,
 871                                           bool recursive,
 872                                           wxString *path) const
 873 {
 874     // ensure everything is up-to-date: this is needed to support on-demand
 875     // reloading of XRC files
 876     const_cast<wxXmlResource *>(this)->UpdateResources();
 877
 878     for ( wxXmlResourceDataRecords::const_iterator f = Data().begin();
 879           f != Data().end(); ++f )
 880     {
 881         wxXmlResourceDataRecord *const rec = *f;
 882         wxXmlDocument * const doc = rec->Doc;
 883         if ( !doc || !doc->GetRoot() )
 884             continue;
 885
 886         wxXmlNode * const
 887             found = DoFindResource(doc->GetRoot(), name, classname, recursive);
 888         if ( found )
 889         {
 890             if ( path )
 891                 *path = rec->File;
 892
 893             return found;
 894         }
 895     }
 896
 897     return NULL;
 898 }
 899
 900 static void MergeNodesOver(wxXmlNode& dest, wxXmlNode& overwriteWith,
 901                            const wxString& overwriteFilename)
 902 {
 903     // Merge attributes:
 904     for ( wxXmlAttribute *attr = overwriteWith.GetAttributes();
 905           attr; attr = attr->GetNext() )
 906     {
 907         wxXmlAttribute *dattr;
 908         for (dattr = dest.GetAttributes(); dattr; dattr = dattr->GetNext())
 909         {
 910
 911             if ( dattr->GetName() == attr->GetName() )
 912             {
 913                 dattr->SetValue(attr->GetValue());
 914                 break;
 915             }
 916         }
 917
 918         if ( !dattr )
 919             dest.AddAttribute(attr->GetName(), attr->GetValue());
 920    }
 921
 922     // Merge child nodes:
 923     for (wxXmlNode* node = overwriteWith.GetChildren(); node; node = node->GetNext())
 924     {
 925         wxString name = node->GetAttribute(wxT("name"), wxEmptyString);
 926         wxXmlNode *dnode;
 927
 928         for (dnode = dest.GetChildren(); dnode; dnode = dnode->GetNext() )
 929         {
 930             if ( dnode->GetName() == node->GetName() &&
 931                  dnode->GetAttribute(wxT("name"), wxEmptyString) == name &&
 932                  dnode->GetType() == node->GetType() )
 933             {
 934                 MergeNodesOver(*dnode, *node, overwriteFilename);
 935                 break;
 936             }
 937         }
 938
 939         if ( !dnode )
 940         {
 941             wxXmlNode *copyOfNode = new wxXmlNode(*node);
 942             // remember referenced object's file, see GetFileNameFromNode()
 943             copyOfNode->AddAttribute(ATTR_INPUT_FILENAME, overwriteFilename);
 944
 945             static const wxChar *AT_END = wxT("end");
 946             wxString insert_pos = node->GetAttribute(wxT("insert_at"), AT_END);
 947             if ( insert_pos == AT_END )
 948             {
 949                 dest.AddChild(copyOfNode);
 950             }
 951             else if ( insert_pos == wxT("begin") )
 952             {
 953                 dest.InsertChild(copyOfNode, dest.GetChildren());
 954             }
 955         }
 956     }
 957
 958     if ( dest.GetType() == wxXML_TEXT_NODE && overwriteWith.GetContent().length() )
 959          dest.SetContent(overwriteWith.GetContent());
 960 }
 961
 962 wxObject *
 963 wxXmlResource::DoCreateResFromNode(wxXmlNode& node,
 964                                    wxObject *parent,
 965                                    wxObject *instance,
 966                                    wxXmlResourceHandler *handlerToUse)
 967 {
 968     // handling of referenced resource
 969     if ( node.GetName() == wxT("object_ref") )
 970     {
 971         wxString refName = node.GetAttribute(wxT("ref"), wxEmptyString);
 972         wxXmlNode* refNode = FindResource(refName, wxEmptyString, true);
 973
 974         if ( !refNode )
 975         {
 976             ReportError
 977             (
 978                 &node,
 979                 wxString::Format
 980                 (
 981                     "referenced object node with ref=\"%s\" not found",
 982                     refName
 983                 )
 984             );
 985             return NULL;
 986         }
 987
 988         const bool hasOnlyRefAttr = node.GetAttributes() != NULL &&
 989                                     node.GetAttributes()->GetNext() == NULL;
 990
 991         if ( hasOnlyRefAttr && !node.GetChildren() )
 992         {
 993             // In the typical, simple case, <object_ref> is used to link
 994             // to another node and doesn't have any content of its own that
 995             // would overwrite linked object's properties. In this case,
 996             // we can simply create the resource from linked node.
 997
 998             return DoCreateResFromNode(*refNode, parent, instance);
 999         }
1000         else
1001         {
1002             // In the more complicated (but rare) case, <object_ref> has
1003             // subnodes that partially overwrite content of the referenced
1004             // object. In this case, we need to merge both XML trees and
1005             // load the resource from result of the merge.
1006
1007             wxXmlNode copy(*refNode);
1008             MergeNodesOver(copy, node, GetFileNameFromNode(&node, Data()));
1009
1010             // remember referenced object's file, see GetFileNameFromNode()
1011             copy.AddAttribute(ATTR_INPUT_FILENAME,
1012                               GetFileNameFromNode(refNode, Data()));
1013
1014             return DoCreateResFromNode(copy, parent, instance);
1015         }
1016     }
1017
1018     if (handlerToUse)
1019     {
1020         if (handlerToUse->CanHandle(&node))
1021         {
1022             return handlerToUse->CreateResource(&node, parent, instance);
1023         }
1024     }
1025     else if (node.GetName() == wxT("object"))
1026     {
1027         for ( wxVector<wxXmlResourceHandler*>::iterator h = m_handlers.begin();
1028               h != m_handlers.end(); ++h )
1029         {
1030             wxXmlResourceHandler *handler = *h;
1031             if (handler->CanHandle(&node))
1032                 return handler->CreateResource(&node, parent, instance);
1033         }
1034     }
1035
1036     ReportError
1037     (
1038         &node,
1039         wxString::Format
1040         (
1041             "no handler found for XML node \"%s\" (class \"%s\")",
1042             node.GetName(),
1043             node.GetAttribute("class", wxEmptyString)
1044         )
1045     );
1046     return NULL;
1047 }
1048
1049 wxIdRange::wxIdRange(const wxXmlNode* node,
1050                      const wxString& rname,
1051                      const wxString& startno,
1052                      const wxString& rsize)
1053     : m_name(rname),
1054       m_start(0),
1055       m_size(0),
1056       m_item_end_found(0),
1057       m_finalised(0)
1058 {
1059     long l;
1060     if ( startno.ToLong(&l) )
1061     {
1062         if ( l >= 0 )
1063         {
1064             m_start = l;
1065         }
1066         else
1067         {
1068             wxXmlResource::Get()->ReportError
1069             (
1070                 node,
1071                 "a negative id-range start parameter was given"
1072             );
1073         }
1074     }
1075     else
1076     {
1077         wxXmlResource::Get()->ReportError
1078         (
1079             node,
1080             "the id-range start parameter was malformed"
1081         );
1082     }
1083
1084     unsigned long ul;
1085     if ( rsize.ToULong(&ul) )
1086     {
1087         m_size = ul;
1088     }
1089     else
1090     {
1091         wxXmlResource::Get()->ReportError
1092         (
1093             node,
1094             "the id-range size parameter was malformed"
1095         );
1096     }
1097 }
1098
1099 void wxIdRange::NoteItem(const wxXmlNode* node, const wxString& item)
1100 {
1101     // Nothing gets added here, but the existence of each item is noted
1102     // thus getting an accurate count. 'item' will be either an integer e.g.
1103     // [0] [123]: will eventually create an XRCID as start+integer or [start]
1104     // or [end] which are synonyms for [0] or [range_size-1] respectively.
1105     wxString content(item.Mid(1, item.length()-2));
1106
1107     // Check that basename+item wasn't foo[]
1108     if (content.empty())
1109     {
1110         wxXmlResource::Get()->ReportError(node, "an empty id-range item found");
1111         return;
1112     }
1113
1114     if (content=="start")
1115     {
1116         // "start" means [0], so store that in the set
1117         if (m_indices.count(0) == 0)
1118         {
1119             m_indices.insert(0);
1120         }
1121         else
1122         {
1123             wxXmlResource::Get()->ReportError
1124             (
1125                 node,
1126                 "duplicate id-range item found"
1127             );
1128         }
1129     }
1130     else if (content=="end")
1131     {
1132         // We can't yet be certain which XRCID this will be equivalent to, so
1133         // just note that there's an item with this name, in case we need to
1134         // inc the range size
1135         m_item_end_found = true;
1136     }
1137     else
1138     {
1139         // Anything else will be an integer, or rubbish
1140         unsigned long l;
1141         if ( content.ToULong(&l) )
1142         {
1143             if (m_indices.count(l) == 0)
1144             {
1145                 m_indices.insert(l);
1146                 // Check that this item wouldn't fall outside the current range
1147                 // extent
1148                 if (l >= m_size)
1149                 {
1150                     m_size = l + 1;
1151                 }
1152             }
1153             else
1154             {
1155                 wxXmlResource::Get()->ReportError
1156                 (
1157                     node,
1158                     "duplicate id-range item found"
1159                 );
1160             }
1161
1162         }
1163         else
1164         {
1165             wxXmlResource::Get()->ReportError
1166             (
1167                 node,
1168                 "an id-range item had a malformed index"
1169             );
1170         }
1171     }
1172 }
1173
1174 void wxIdRange::Finalise(const wxXmlNode* node)
1175 {
1176     wxCHECK_RET( !IsFinalised(),
1177                  "Trying to finalise an already-finalised range" );
1178
1179     // Now we know about all the items, we can get an accurate range size
1180     // Expand any requested range-size if there were more items than would fit
1181     m_size = wxMax(m_size, m_indices.size());
1182
1183     // If an item is explicitly called foo[end], ensure it won't clash with
1184     // another item
1185     if ( m_item_end_found && m_indices.count(m_size-1) )
1186         ++m_size;
1187     if (m_size == 0)
1188     {
1189         // This will happen if someone creates a range but no items in this xrc
1190         // file Report the error and abort, but don't finalise, in case items
1191         // appear later
1192         wxXmlResource::Get()->ReportError
1193         (
1194             node,
1195             "trying to create an empty id-range"
1196         );
1197         return;
1198     }
1199
1200     if (m_start==0)
1201     {
1202         // This is the usual case, where the user didn't specify a start ID
1203         // So get the range using NewControlId().
1204         //
1205         // NB: negative numbers, but NewControlId already returns the most
1206         //     negative
1207         m_start = wxWindow::NewControlId(m_size);
1208         wxCHECK_RET( m_start != wxID_NONE,
1209                      "insufficient IDs available to create range" );
1210         m_end = m_start + m_size - 1;
1211     }
1212     else
1213     {
1214         // The user already specified a start value, which must be positive
1215         m_end = m_start + m_size - 1;
1216     }
1217
1218     // Create the XRCIDs
1219     for (int i=m_start; i <= m_end; ++i)
1220     {
1221         // Ensure that we overwrite any existing value as otherwise
1222         // wxXmlResource::Unload() followed by Load() wouldn't work correctly.
1223         XRCID_Assign(m_name + wxString::Format("[%i]", i-m_start), i);
1224
1225         wxLogTrace("xrcrange",
1226                    "integer = %i %s now returns %i",
1227                    i,
1228                    m_name + wxString::Format("[%i]", i-m_start),
1229                    XRCID((m_name + wxString::Format("[%i]", i-m_start)).mb_str()));
1230     }
1231     // and these special ones
1232     XRCID_Assign(m_name + "[start]", m_start);
1233     XRCID_Assign(m_name + "[end]", m_end);
1234     wxLogTrace("xrcrange","%s[start] = %i  %s[end] = %i",
1235             m_name.mb_str(),XRCID(wxString(m_name+"[start]").mb_str()),
1236                 m_name.mb_str(),XRCID(wxString(m_name+"[end]").mb_str()));
1237
1238     m_finalised = true;
1239 }
1240
1241 wxIdRangeManager *wxIdRangeManager::ms_instance = NULL;
1242
1243 /*static*/ wxIdRangeManager *wxIdRangeManager::Get()
1244 {
1245     if ( !ms_instance )
1246         ms_instance = new wxIdRangeManager;
1247     return ms_instance;
1248 }
1249
1250 /*static*/ wxIdRangeManager *wxIdRangeManager::Set(wxIdRangeManager *res)
1251 {
1252     wxIdRangeManager *old = ms_instance;
1253     ms_instance = res;
1254     return old;
1255 }
1256
1257 wxIdRangeManager::~wxIdRangeManager()
1258 {
1259     for ( wxVector<wxIdRange*>::iterator i = m_IdRanges.begin();
1260           i != m_IdRanges.end(); ++i )
1261     {
1262         delete *i;
1263     }
1264     m_IdRanges.clear();
1265
1266     delete ms_instance;
1267 }
1268
1269 void wxIdRangeManager::AddRange(const wxXmlNode* node)
1270 {
1271     wxString name = node->GetAttribute("name");
1272     wxString start = node->GetAttribute("start", "0");
1273     wxString size = node->GetAttribute("size", "0");
1274     if (name.empty())
1275     {
1276         wxXmlResource::Get()->ReportError
1277         (
1278             node,
1279             "xrc file contains an id-range without a name"
1280         );
1281         return;
1282     }
1283
1284     int index = Find(name);
1285     if (index == wxNOT_FOUND)
1286     {
1287         wxLogTrace("xrcrange",
1288                    "Adding ID range, name=%s start=%s size=%s",
1289                    name, start, size);
1290
1291         m_IdRanges.push_back(new wxIdRange(node, name, start, size));
1292     }
1293     else
1294     {
1295         // There was already a range with this name. Let's hope this is
1296         // from an Unload()/(re)Load(), not an unintentional duplication
1297         wxLogTrace("xrcrange",
1298                    "Replacing ID range, name=%s start=%s size=%s",
1299                    name, start, size);
1300
1301         wxIdRange* oldrange = m_IdRanges.at(index);
1302         m_IdRanges.at(index) = new wxIdRange(node, name, start, size);
1303         delete oldrange;
1304     }
1305 }
1306
1307 wxIdRange *
1308 wxIdRangeManager::FindRangeForItem(const wxXmlNode* node,
1309                                    const wxString& item,
1310                                    wxString& value) const
1311 {
1312     wxString basename = item.BeforeFirst('[');
1313     wxCHECK_MSG( !basename.empty(), NULL,
1314                  "an id-range item without a range name" );
1315
1316     int index = Find(basename);
1317     if (index == wxNOT_FOUND)
1318     {
1319         // Don't assert just because we've found an unexpected foo[123]
1320         // Someone might just want such a name, nothing to do with ranges
1321         return NULL;
1322     }
1323
1324     value = item.Mid(basename.Len());
1325     if (value.at(value.length()-1)==']')
1326     {
1327         return m_IdRanges.at(index);
1328     }
1329     wxXmlResource::Get()->ReportError(node, "a malformed id-range item");
1330     return NULL;
1331 }
1332
1333 void
1334 wxIdRangeManager::NotifyRangeOfItem(const wxXmlNode* node,
1335                                     const wxString& item) const
1336 {
1337     wxString value;
1338     wxIdRange* range = FindRangeForItem(node, item, value);
1339     if (range)
1340         range->NoteItem(node, value);
1341 }
1342
1343 int wxIdRangeManager::Find(const wxString& rangename) const
1344 {
1345     for ( int i=0; i < (int)m_IdRanges.size(); ++i )
1346     {
1347         if (m_IdRanges.at(i)->GetName() == rangename)
1348             return i;
1349     }
1350
1351     return wxNOT_FOUND;
1352 }
1353
1354 void wxIdRangeManager::FinaliseRanges(const wxXmlNode* node) const
1355 {
1356     for ( wxVector<wxIdRange*>::const_iterator i = m_IdRanges.begin();
1357           i != m_IdRanges.end(); ++i )
1358     {
1359         // Check if this range has already been finalised. Quite possible,
1360         // as  FinaliseRanges() gets called for each .xrc file loaded
1361         if (!(*i)->IsFinalised())
1362         {
1363             wxLogTrace("xrcrange", "Finalising ID range %s", (*i)->GetName());
1364             (*i)->Finalise(node);
1365         }
1366     }
1367 }
1368
1369
1370 class wxXmlSubclassFactories : public wxVector<wxXmlSubclassFactory*>
1371 {
1372     // this is a class so that it can be forward-declared
1373 };
1374
1375 wxXmlSubclassFactories *wxXmlResource::ms_subclassFactories = NULL;
1376
1377 /*static*/ void wxXmlResource::AddSubclassFactory(wxXmlSubclassFactory *factory)
1378 {
1379     if (!ms_subclassFactories)
1380     {
1381         ms_subclassFactories = new wxXmlSubclassFactories;
1382     }
1383     ms_subclassFactories->push_back(factory);
1384 }
1385
1386 class wxXmlSubclassFactoryCXX : public wxXmlSubclassFactory
1387 {
1388 public:
1389     ~wxXmlSubclassFactoryCXX() {}
1390
1391     wxObject *Create(const wxString& className)
1392     {
1393         wxClassInfo* classInfo = wxClassInfo::FindClass(className);
1394
1395         if (classInfo)
1396             return classInfo->CreateObject();
1397         else
1398             return NULL;
1399     }
1400 };
1401
1402
1403
1404
1405 wxXmlResourceHandlerImpl::wxXmlResourceHandlerImpl(wxXmlResourceHandler *handler)
1406                          :wxXmlResourceHandlerImplBase(handler)
1407 {
1408 }
1409
1410 wxObject *wxXmlResourceHandlerImpl::CreateResFromNode(wxXmlNode *node,
1411                             wxObject *parent, wxObject *instance)
1412 {
1413     return m_handler->m_resource->CreateResFromNode(node, parent, instance);
1414 }
1415
1416 #if wxUSE_FILESYSTEM
1417 wxFileSystem& wxXmlResourceHandlerImpl::GetCurFileSystem()
1418 {
1419     return m_handler->m_resource->GetCurFileSystem();
1420 }
1421 #endif
1422
1423
1424 wxObject *wxXmlResourceHandlerImpl::CreateResource(wxXmlNode *node, wxObject *parent, wxObject *instance)
1425 {
1426     wxXmlNode *myNode = m_handler->m_node;
1427     wxString myClass = m_handler->m_class;
1428     wxObject *myParent = m_handler->m_parent, *myInstance = m_handler->m_instance;
1429     wxWindow *myParentAW = m_handler->m_parentAsWindow;
1430
1431     m_handler->m_instance = instance;
1432     if (!m_handler->m_instance && node->HasAttribute(wxT("subclass")) &&
1433         !(m_handler->m_resource->GetFlags() & wxXRC_NO_SUBCLASSING))
1434     {
1435         wxString subclass = node->GetAttribute(wxT("subclass"), wxEmptyString);
1436         if (!subclass.empty())
1437         {
1438             for (wxXmlSubclassFactories::iterator i = wxXmlResource::ms_subclassFactories->begin();
1439                  i != wxXmlResource::ms_subclassFactories->end(); ++i)
1440             {
1441                 m_handler->m_instance = (*i)->Create(subclass);
1442                 if (m_handler->m_instance)
1443                     break;
1444             }
1445
1446             if (!m_handler->m_instance)
1447             {
1448                 wxString name = node->GetAttribute(wxT("name"), wxEmptyString);
1449                 ReportError
1450                 (
1451                     node,
1452                     wxString::Format
1453                     (
1454                         "subclass \"%s\" not found for resource \"%s\", not subclassing",
1455                         subclass, name
1456                     )
1457                 );
1458             }
1459         }
1460     }
1461
1462     m_handler->m_node = node;
1463     m_handler->m_class = node->GetAttribute(wxT("class"), wxEmptyString);
1464     m_handler->m_parent = parent;
1465     m_handler->m_parentAsWindow = wxDynamicCast(m_handler->m_parent, wxWindow);
1466
1467     wxObject *returned = GetHandler()->DoCreateResource();
1468
1469     m_handler->m_node = myNode;
1470     m_handler->m_class = myClass;
1471     m_handler->m_parent = myParent; m_handler->m_parentAsWindow = myParentAW;
1472     m_handler->m_instance = myInstance;
1473
1474     return returned;
1475 }
1476
1477 bool wxXmlResourceHandlerImpl::HasParam(const wxString& param)
1478 {
1479     return (GetParamNode(param) != NULL);
1480 }
1481
1482
1483 int wxXmlResourceHandlerImpl::GetStyle(const wxString& param, int defaults)
1484 {
1485     wxString s = GetParamValue(param);
1486
1487     if (!s) return defaults;
1488
1489     wxStringTokenizer tkn(s, wxT("| \t\n"), wxTOKEN_STRTOK);
1490     int style = 0;
1491     int index;
1492     wxString fl;
1493     while (tkn.HasMoreTokens())
1494     {
1495         fl = tkn.GetNextToken();
1496         index = m_handler->m_styleNames.Index(fl);
1497         if (index != wxNOT_FOUND)
1498         {
1499             style |= m_handler->m_styleValues[index];
1500         }
1501         else
1502         {
1503             ReportParamError
1504             (
1505                 param,
1506                 wxString::Format("unknown style flag \"%s\"", fl)
1507             );
1508         }
1509     }
1510     return style;
1511 }
1512
1513
1514
1515 wxString wxXmlResourceHandlerImpl::GetText(const wxString& param, bool translate)
1516 {
1517     wxXmlNode *parNode = GetParamNode(param);
1518     wxString str1(GetNodeContent(parNode));
1519     wxString str2;
1520
1521     // "\\" wasn't translated to "\" prior to 2.5.3.0:
1522     const bool escapeBackslash = (m_handler->m_resource->CompareVersion(2,5,3,0) >= 0);
1523
1524     // VS: First version of XRC resources used $ instead of & (which is
1525     //     illegal in XML), but later I realized that '_' fits this purpose
1526     //     much better (because &File means "File with F underlined").
1527     const wxChar amp_char = (m_handler->m_resource->CompareVersion(2,3,0,1) < 0)
1528                             ? '$' : '_';
1529
1530     for ( wxString::const_iterator dt = str1.begin(); dt != str1.end(); ++dt )
1531     {
1532         // Remap amp_char to &, map double amp_char to amp_char (for things
1533         // like "&File..." -- this is illegal in XML, so we use "_File..."):
1534         if ( *dt == amp_char )
1535         {
1536             if ( dt+1 == str1.end() || *(++dt) == amp_char )
1537                 str2 << amp_char;
1538             else
1539                 str2 << wxT('&') << *dt;
1540         }
1541         // Remap \n to CR, \r to LF, \t to TAB, \\ to \:
1542         else if ( *dt == wxT('\\') )
1543         {
1544             switch ( (*(++dt)).GetValue() )
1545             {
1546                 case wxT('n'):
1547                     str2 << wxT('\n');
1548                     break;
1549
1550                 case wxT('t'):
1551                     str2 << wxT('\t');
1552                     break;
1553
1554                 case wxT('r'):
1555                     str2 << wxT('\r');
1556                     break;
1557
1558                 case wxT('\\') :
1559                     // "\\" wasn't translated to "\" prior to 2.5.3.0:
1560                     if ( escapeBackslash )
1561                     {
1562                         str2 << wxT('\\');
1563                         break;
1564                     }
1565                     // else fall-through to default: branch below
1566
1567                 default:
1568                     str2 << wxT('\\') << *dt;
1569                     break;
1570             }
1571         }
1572         else
1573         {
1574             str2 << *dt;
1575         }
1576     }
1577
1578     if (m_handler->m_resource->GetFlags() & wxXRC_USE_LOCALE)
1579     {
1580         if (translate && parNode &&
1581             parNode->GetAttribute(wxT("translate"), wxEmptyString) != wxT("0"))
1582         {
1583             return wxGetTranslation(str2, m_handler->m_resource->GetDomain());
1584         }
1585         else
1586         {
1587 #if wxUSE_UNICODE
1588             return str2;
1589 #else
1590             // The string is internally stored as UTF-8, we have to convert
1591             // it into system's default encoding so that it can be displayed:
1592             return wxString(str2.wc_str(wxConvUTF8), wxConvLocal);
1593 #endif
1594         }
1595     }
1596
1597     // If wxXRC_USE_LOCALE is not set, then the string is already in
1598     // system's default encoding in ANSI build, so we don't have to
1599     // do anything special here.
1600     return str2;
1601 }
1602
1603
1604
1605 long wxXmlResourceHandlerImpl::GetLong(const wxString& param, long defaultv)
1606 {
1607     long value = defaultv;
1608     wxString str1 = GetParamValue(param);
1609
1610     if (!str1.empty())
1611     {
1612         if (!str1.ToLong(&value))
1613         {
1614             ReportParamError
1615             (
1616                 param,
1617                 wxString::Format("invalid long specification \"%s\"", str1)
1618             );
1619         }
1620     }
1621
1622     return value;
1623 }
1624
1625 float wxXmlResourceHandlerImpl::GetFloat(const wxString& param, float defaultv)
1626 {
1627     wxString str = GetParamValue(param);
1628
1629     // strings in XRC always use C locale so make sure to use the
1630     // locale-independent wxString::ToCDouble() and not ToDouble() which uses
1631     // the current locale with a potentially different decimal point character
1632     double value = defaultv;
1633     if (!str.empty())
1634     {
1635         if (!str.ToCDouble(&value))
1636         {
1637             ReportParamError
1638             (
1639                 param,
1640                 wxString::Format("invalid float specification \"%s\"", str)
1641             );
1642         }
1643     }
1644
1645     return wx_truncate_cast(float, value);
1646 }
1647
1648
1649 int wxXmlResourceHandlerImpl::GetID()
1650 {
1651     return wxXmlResource::GetXRCID(GetName());
1652 }
1653
1654
1655
1656 wxString wxXmlResourceHandlerImpl::GetName()
1657 {
1658     return m_handler->m_node->GetAttribute(wxT("name"), wxT("-1"));
1659 }
1660
1661
1662
1663 bool wxXmlResourceHandlerImpl::GetBoolAttr(const wxString& attr, bool defaultv)
1664 {
1665     wxString v;
1666     return m_handler->m_node->GetAttribute(attr, &v) ? v == '1' : defaultv;
1667 }
1668
1669 bool wxXmlResourceHandlerImpl::GetBool(const wxString& param, bool defaultv)
1670 {
1671     const wxString v = GetParamValue(param);
1672
1673     return v.empty() ? defaultv : (v == '1');
1674 }
1675
1676
1677 static wxColour GetSystemColour(const wxString& name)
1678 {
1679     if (!name.empty())
1680     {
1681         #define SYSCLR(clr) \
1682             if (name == wxT(#clr)) return wxSystemSettings::GetColour(clr);
1683         SYSCLR(wxSYS_COLOUR_SCROLLBAR)
1684         SYSCLR(wxSYS_COLOUR_BACKGROUND)
1685         SYSCLR(wxSYS_COLOUR_DESKTOP)
1686         SYSCLR(wxSYS_COLOUR_ACTIVECAPTION)
1687         SYSCLR(wxSYS_COLOUR_INACTIVECAPTION)
1688         SYSCLR(wxSYS_COLOUR_MENU)
1689         SYSCLR(wxSYS_COLOUR_WINDOW)
1690         SYSCLR(wxSYS_COLOUR_WINDOWFRAME)
1691         SYSCLR(wxSYS_COLOUR_MENUTEXT)
1692         SYSCLR(wxSYS_COLOUR_WINDOWTEXT)
1693         SYSCLR(wxSYS_COLOUR_CAPTIONTEXT)
1694         SYSCLR(wxSYS_COLOUR_ACTIVEBORDER)
1695         SYSCLR(wxSYS_COLOUR_INACTIVEBORDER)
1696         SYSCLR(wxSYS_COLOUR_APPWORKSPACE)
1697         SYSCLR(wxSYS_COLOUR_HIGHLIGHT)
1698         SYSCLR(wxSYS_COLOUR_HIGHLIGHTTEXT)
1699         SYSCLR(wxSYS_COLOUR_BTNFACE)
1700         SYSCLR(wxSYS_COLOUR_3DFACE)
1701         SYSCLR(wxSYS_COLOUR_BTNSHADOW)
1702         SYSCLR(wxSYS_COLOUR_3DSHADOW)
1703         SYSCLR(wxSYS_COLOUR_GRAYTEXT)
1704         SYSCLR(wxSYS_COLOUR_BTNTEXT)
1705         SYSCLR(wxSYS_COLOUR_INACTIVECAPTIONTEXT)
1706         SYSCLR(wxSYS_COLOUR_BTNHIGHLIGHT)
1707         SYSCLR(wxSYS_COLOUR_BTNHILIGHT)
1708         SYSCLR(wxSYS_COLOUR_3DHIGHLIGHT)
1709         SYSCLR(wxSYS_COLOUR_3DHILIGHT)
1710         SYSCLR(wxSYS_COLOUR_3DDKSHADOW)
1711         SYSCLR(wxSYS_COLOUR_3DLIGHT)
1712         SYSCLR(wxSYS_COLOUR_INFOTEXT)
1713         SYSCLR(wxSYS_COLOUR_INFOBK)
1714         SYSCLR(wxSYS_COLOUR_LISTBOX)
1715         SYSCLR(wxSYS_COLOUR_HOTLIGHT)
1716         SYSCLR(wxSYS_COLOUR_GRADIENTACTIVECAPTION)
1717         SYSCLR(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)
1718         SYSCLR(wxSYS_COLOUR_MENUHILIGHT)
1719         SYSCLR(wxSYS_COLOUR_MENUBAR)
1720         #undef SYSCLR
1721     }
1722
1723     return wxNullColour;
1724 }
1725
1726 wxColour wxXmlResourceHandlerImpl::GetColour(const wxString& param, const wxColour& defaultv)
1727 {
1728     wxString v = GetParamValue(param);
1729
1730     if ( v.empty() )
1731         return defaultv;
1732
1733     wxColour clr;
1734
1735     // wxString -> wxColour conversion
1736     if (!clr.Set(v))
1737     {
1738         // the colour doesn't use #RRGGBB format, check if it is symbolic
1739         // colour name:
1740         clr = GetSystemColour(v);
1741         if (clr.IsOk())
1742             return clr;
1743
1744         ReportParamError
1745         (
1746             param,
1747             wxString::Format("incorrect colour specification \"%s\"", v)
1748         );
1749         return wxNullColour;
1750     }
1751
1752     return clr;
1753 }
1754
1755 namespace
1756 {
1757
1758 // if 'param' has stock_id/stock_client, extracts them and returns true
1759 bool GetStockArtAttrs(const wxXmlNode *paramNode,
1760                       const wxString& defaultArtClient,
1761                       wxString& art_id, wxString& art_client)
1762 {
1763     if ( paramNode )
1764     {
1765         art_id = paramNode->GetAttribute("stock_id", "");
1766
1767         if ( !art_id.empty() )
1768         {
1769             art_id = wxART_MAKE_ART_ID_FROM_STR(art_id);
1770
1771             art_client = paramNode->GetAttribute("stock_client", "");
1772             if ( art_client.empty() )
1773                 art_client = defaultArtClient;
1774             else
1775                 art_client = wxART_MAKE_CLIENT_ID_FROM_STR(art_client);
1776
1777             return true;
1778         }
1779     }
1780
1781     return false;
1782 }
1783
1784 } // anonymous namespace
1785
1786 wxBitmap wxXmlResourceHandlerImpl::GetBitmap(const wxString& param,
1787                                          const wxArtClient& defaultArtClient,
1788                                          wxSize size)
1789 {
1790     // it used to be possible to pass an empty string here to indicate that the
1791     // bitmap name should be read from this node itself but this is not
1792     // supported any more because GetBitmap(m_node) can be used directly
1793     // instead
1794     wxASSERT_MSG( !param.empty(), "bitmap parameter name can't be empty" );
1795
1796     const wxXmlNode* const node = GetParamNode(param);
1797
1798     if ( !node )
1799     {
1800         // this is not an error as bitmap parameter could be optional
1801         return wxNullBitmap;
1802     }
1803
1804     return GetBitmap(node, defaultArtClient, size);
1805 }
1806
1807 wxBitmap wxXmlResourceHandlerImpl::GetBitmap(const wxXmlNode* node,
1808                                          const wxArtClient& defaultArtClient,
1809                                          wxSize size)
1810 {
1811     wxCHECK_MSG( node, wxNullBitmap, "bitmap node can't be NULL" );
1812
1813     /* If the bitmap is specified as stock item, query wxArtProvider for it: */
1814     wxString art_id, art_client;
1815     if ( GetStockArtAttrs(node, defaultArtClient,
1816                           art_id, art_client) )
1817     {
1818         wxBitmap stockArt(wxArtProvider::GetBitmap(art_id, art_client, size));
1819         if ( stockArt.IsOk() )
1820             return stockArt;
1821     }
1822
1823     /* ...or load the bitmap from file: */
1824     wxString name = GetParamValue(node);
1825     if (name.empty()) return wxNullBitmap;
1826 #if wxUSE_FILESYSTEM
1827     wxFSFile *fsfile = GetCurFileSystem().OpenFile(name, wxFS_READ | wxFS_SEEKABLE);
1828     if (fsfile == NULL)
1829     {
1830         ReportParamError
1831         (
1832             node->GetName(),
1833             wxString::Format("cannot open bitmap resource \"%s\"", name)
1834         );
1835         return wxNullBitmap;
1836     }
1837     wxImage img(*(fsfile->GetStream()));
1838     delete fsfile;
1839 #else
1840     wxImage img(name);
1841 #endif
1842
1843     if (!img.IsOk())
1844     {
1845         ReportParamError
1846         (
1847             node->GetName(),
1848             wxString::Format("cannot create bitmap from \"%s\"", name)
1849         );
1850         return wxNullBitmap;
1851     }
1852     if (!(size == wxDefaultSize)) img.Rescale(size.x, size.y);
1853     return wxBitmap(img);
1854 }
1855
1856
1857 wxIcon wxXmlResourceHandlerImpl::GetIcon(const wxString& param,
1858                                      const wxArtClient& defaultArtClient,
1859                                      wxSize size)
1860 {
1861     // see comment in GetBitmap(wxString) overload
1862     wxASSERT_MSG( !param.empty(), "icon parameter name can't be empty" );
1863
1864     const wxXmlNode* const node = GetParamNode(param);
1865
1866     if ( !node )
1867     {
1868         // this is not an error as icon parameter could be optional
1869         return wxIcon();
1870     }
1871
1872     return GetIcon(node, defaultArtClient, size);
1873 }
1874
1875 wxIcon wxXmlResourceHandlerImpl::GetIcon(const wxXmlNode* node,
1876                                      const wxArtClient& defaultArtClient,
1877                                      wxSize size)
1878 {
1879     wxIcon icon;
1880     icon.CopyFromBitmap(GetBitmap(node, defaultArtClient, size));
1881     return icon;
1882 }
1883
1884
1885 wxIconBundle wxXmlResourceHandlerImpl::GetIconBundle(const wxString& param,
1886                                                  const wxArtClient& defaultArtClient)
1887 {
1888     wxString art_id, art_client;
1889     if ( GetStockArtAttrs(GetParamNode(param), defaultArtClient,
1890                           art_id, art_client) )
1891     {
1892         wxIconBundle stockArt(wxArtProvider::GetIconBundle(art_id, art_client));
1893         if ( stockArt.IsOk() )
1894             return stockArt;
1895     }
1896
1897     const wxString name = GetParamValue(param);
1898     if ( name.empty() )
1899         return wxNullIconBundle;
1900
1901 #if wxUSE_FILESYSTEM
1902     wxFSFile *fsfile = GetCurFileSystem().OpenFile(name, wxFS_READ | wxFS_SEEKABLE);
1903     if ( fsfile == NULL )
1904     {
1905         ReportParamError
1906         (
1907             param,
1908             wxString::Format("cannot open icon resource \"%s\"", name)
1909         );
1910         return wxNullIconBundle;
1911     }
1912
1913     wxIconBundle bundle(*(fsfile->GetStream()));
1914     delete fsfile;
1915 #else
1916     wxIconBundle bundle(name);
1917 #endif
1918
1919     if ( !bundle.IsOk() )
1920     {
1921         ReportParamError
1922         (
1923             param,
1924             wxString::Format("cannot create icon from \"%s\"", name)
1925         );
1926         return wxNullIconBundle;
1927     }
1928
1929     return bundle;
1930 }
1931
1932
1933 wxImageList *wxXmlResourceHandlerImpl::GetImageList(const wxString& param)
1934 {
1935     wxXmlNode * const imagelist_node = GetParamNode(param);
1936     if ( !imagelist_node )
1937         return NULL;
1938
1939     wxXmlNode * const oldnode = m_handler->m_node;
1940     m_handler->m_node = imagelist_node;
1941
1942     // Get the size if we have it, otherwise we will use the size of the first
1943     // list element.
1944     wxSize size = GetSize();
1945
1946     // Start adding images, we'll create the image list when adding the first
1947     // one.
1948     wxImageList * imagelist = NULL;
1949     wxString parambitmap = wxT("bitmap");
1950     if ( HasParam(parambitmap) )
1951     {
1952         wxXmlNode *n = m_handler->m_node->GetChildren();
1953         while (n)
1954         {
1955             if (n->GetType() == wxXML_ELEMENT_NODE && n->GetName() == parambitmap)
1956             {
1957                 wxIcon icon = GetIcon(n, wxART_OTHER, size);
1958                 if ( !imagelist )
1959                 {
1960                     // We need the real image list size to create it.
1961                     if ( size == wxDefaultSize )
1962                         size = icon.GetSize();
1963
1964                     // We use the mask by default.
1965                     bool mask = GetBool(wxS("mask"), true);
1966
1967                     imagelist = new wxImageList(size.x, size.y, mask);
1968                 }
1969
1970                 // add icon instead of bitmap to keep the bitmap mask
1971                 imagelist->Add(icon);
1972             }
1973             n = n->GetNext();
1974         }
1975     }
1976
1977     m_handler->m_node = oldnode;
1978     return imagelist;
1979 }
1980
1981 wxXmlNode *wxXmlResourceHandlerImpl::GetParamNode(const wxString& param)
1982 {
1983     wxCHECK_MSG(m_handler->m_node, NULL, wxT("You can't access handler data before it was initialized!"));
1984
1985     wxXmlNode *n = m_handler->m_node->GetChildren();
1986
1987     while (n)
1988     {
1989         if (n->GetType() == wxXML_ELEMENT_NODE && n->GetName() == param)
1990         {
1991             // TODO: check that there are no other properties/parameters with
1992             //       the same name and log an error if there are (can't do this
1993             //       right now as I'm not sure if it's not going to break code
1994             //       using this function in unintentional way (i.e. for
1995             //       accessing other things than properties), for example
1996             //       wxBitmapComboBoxXmlHandler almost surely does
1997             return n;
1998         }
1999         n = n->GetNext();
2000     }
2001     return NULL;
2002 }
2003
2004 bool wxXmlResourceHandlerImpl::IsOfClass(wxXmlNode *node, const wxString& classname) const
2005 {
2006     return node->GetAttribute(wxT("class")) == classname;
2007 }
2008
2009
2010
2011 wxString wxXmlResourceHandlerImpl::GetNodeContent(const wxXmlNode *node)
2012 {
2013     const wxXmlNode *n = node;
2014     if (n == NULL) return wxEmptyString;
2015     n = n->GetChildren();
2016
2017     while (n)
2018     {
2019         if (n->GetType() == wxXML_TEXT_NODE ||
2020             n->GetType() == wxXML_CDATA_SECTION_NODE)
2021             return n->GetContent();
2022         n = n->GetNext();
2023     }
2024     return wxEmptyString;
2025 }
2026
2027
2028
2029 wxString wxXmlResourceHandlerImpl::GetParamValue(const wxString& param)
2030 {
2031     if (param.empty())
2032         return GetNodeContent(m_handler->m_node);
2033     else
2034         return GetNodeContent(GetParamNode(param));
2035 }
2036
2037 wxString wxXmlResourceHandlerImpl::GetParamValue(const wxXmlNode* node)
2038 {
2039     return GetNodeContent(node);
2040 }
2041
2042
2043 wxSize wxXmlResourceHandlerImpl::GetSize(const wxString& param,
2044                                      wxWindow *windowToUse)
2045 {
2046     wxString s = GetParamValue(param);
2047     if (s.empty()) s = wxT("-1,-1");
2048     bool is_dlg;
2049     long sx, sy = 0;
2050
2051     is_dlg = s[s.length()-1] == wxT('d');
2052     if (is_dlg) s.RemoveLast();
2053
2054     if (!s.BeforeFirst(wxT(',')).ToLong(&sx) ||
2055         !s.AfterLast(wxT(',')).ToLong(&sy))
2056     {
2057         ReportParamError
2058         (
2059             param,
2060             wxString::Format("cannot parse coordinates value \"%s\"", s)
2061         );
2062         return wxDefaultSize;
2063     }
2064
2065     if (is_dlg)
2066     {
2067         if (windowToUse)
2068         {
2069             return wxDLG_UNIT(windowToUse, wxSize(sx, sy));
2070         }
2071         else if (m_handler->m_parentAsWindow)
2072         {
2073             return wxDLG_UNIT(m_handler->m_parentAsWindow, wxSize(sx, sy));
2074         }
2075         else
2076         {
2077             ReportParamError
2078             (
2079                 param,
2080                 "cannot convert dialog units: dialog unknown"
2081             );
2082             return wxDefaultSize;
2083         }
2084     }
2085
2086     return wxSize(sx, sy);
2087 }
2088
2089
2090
2091 wxPoint wxXmlResourceHandlerImpl::GetPosition(const wxString& param)
2092 {
2093     wxSize sz = GetSize(param);
2094     return wxPoint(sz.x, sz.y);
2095 }
2096
2097
2098
2099 wxCoord wxXmlResourceHandlerImpl::GetDimension(const wxString& param,
2100                                            wxCoord defaultv,
2101                                            wxWindow *windowToUse)
2102 {
2103     wxString s = GetParamValue(param);
2104     if (s.empty()) return defaultv;
2105     bool is_dlg;
2106     long sx;
2107
2108     is_dlg = s[s.length()-1] == wxT('d');
2109     if (is_dlg) s.RemoveLast();
2110
2111     if (!s.ToLong(&sx))
2112     {
2113         ReportParamError
2114         (
2115             param,
2116             wxString::Format("cannot parse dimension value \"%s\"", s)
2117         );
2118         return defaultv;
2119     }
2120
2121     if (is_dlg)
2122     {
2123         if (windowToUse)
2124         {
2125             return wxDLG_UNIT(windowToUse, wxSize(sx, 0)).x;
2126         }
2127         else if (m_handler->m_parentAsWindow)
2128         {
2129             return wxDLG_UNIT(m_handler->m_parentAsWindow, wxSize(sx, 0)).x;
2130         }
2131         else
2132         {
2133             ReportParamError
2134             (
2135                 param,
2136                 "cannot convert dialog units: dialog unknown"
2137             );
2138             return defaultv;
2139         }
2140     }
2141
2142     return sx;
2143 }
2144
2145 wxDirection
2146 wxXmlResourceHandlerImpl::GetDirection(const wxString& param, wxDirection dirDefault)
2147 {
2148     wxDirection dir;
2149
2150     const wxString dirstr = GetParamValue(param);
2151     if ( dirstr.empty() )
2152         dir = dirDefault;
2153     else if ( dirstr == "wxLEFT" )
2154         dir = wxLEFT;
2155     else if ( dirstr == "wxRIGHT" )
2156         dir = wxRIGHT;
2157     else if ( dirstr == "wxTOP" )
2158         dir = wxTOP;
2159     else if ( dirstr == "wxBOTTOM" )
2160         dir = wxBOTTOM;
2161     else
2162     {
2163         ReportError
2164         (
2165             GetParamNode(param),
2166             wxString::Format
2167             (
2168                 "Invalid direction \"%s\": must be one of "
2169                 "wxLEFT|wxRIGHT|wxTOP|wxBOTTOM.",
2170                 dirstr
2171             )
2172         );
2173
2174         dir = dirDefault;
2175     }
2176
2177     return dir;
2178 }
2179
2180 // Get system font index using indexname
2181 static wxFont GetSystemFont(const wxString& name)
2182 {
2183     if (!name.empty())
2184     {
2185         #define SYSFNT(fnt) \
2186             if (name == wxT(#fnt)) return wxSystemSettings::GetFont(fnt);
2187         SYSFNT(wxSYS_OEM_FIXED_FONT)
2188         SYSFNT(wxSYS_ANSI_FIXED_FONT)
2189         SYSFNT(wxSYS_ANSI_VAR_FONT)
2190         SYSFNT(wxSYS_SYSTEM_FONT)
2191         SYSFNT(wxSYS_DEVICE_DEFAULT_FONT)
2192         SYSFNT(wxSYS_SYSTEM_FIXED_FONT)
2193         SYSFNT(wxSYS_DEFAULT_GUI_FONT)
2194         #undef SYSFNT
2195     }
2196
2197     return wxNullFont;
2198 }
2199
2200 wxFont wxXmlResourceHandlerImpl::GetFont(const wxString& param, wxWindow* parent)
2201 {
2202     wxXmlNode *font_node = GetParamNode(param);
2203     if (font_node == NULL)
2204     {
2205         ReportError(
2206             wxString::Format("cannot find font node \"%s\"", param));
2207         return wxNullFont;
2208     }
2209
2210     wxXmlNode *oldnode = m_handler->m_node;
2211     m_handler->m_node = font_node;
2212
2213     // font attributes:
2214
2215     // size
2216     int isize = -1;
2217     bool hasSize = HasParam(wxT("size"));
2218     if (hasSize)
2219         isize = GetLong(wxT("size"), -1);
2220
2221     // style
2222     int istyle = wxNORMAL;
2223     bool hasStyle = HasParam(wxT("style"));
2224     if (hasStyle)
2225     {
2226         wxString style = GetParamValue(wxT("style"));
2227         if (style == wxT("italic"))
2228             istyle = wxITALIC;
2229         else if (style == wxT("slant"))
2230             istyle = wxSLANT;
2231         else if (style != wxT("normal"))
2232         {
2233             ReportParamError
2234             (
2235                 param,
2236                 wxString::Format("unknown font style \"%s\"", style)
2237             );
2238         }
2239     }
2240
2241     // weight
2242     int iweight = wxNORMAL;
2243     bool hasWeight = HasParam(wxT("weight"));
2244     if (hasWeight)
2245     {
2246         wxString weight = GetParamValue(wxT("weight"));
2247         if (weight == wxT("bold"))
2248             iweight = wxBOLD;
2249         else if (weight == wxT("light"))
2250             iweight = wxLIGHT;
2251         else if (weight != wxT("normal"))
2252         {
2253             ReportParamError
2254             (
2255                 param,
2256                 wxString::Format("unknown font weight \"%s\"", weight)
2257             );
2258         }
2259     }
2260
2261     // underline
2262     bool hasUnderlined = HasParam(wxT("underlined"));
2263     bool underlined = hasUnderlined ? GetBool(wxT("underlined"), false) : false;
2264
2265     // family and facename
2266     int ifamily = wxDEFAULT;
2267     bool hasFamily = HasParam(wxT("family"));
2268     if (hasFamily)
2269     {
2270         wxString family = GetParamValue(wxT("family"));
2271              if (family == wxT("decorative")) ifamily = wxDECORATIVE;
2272         else if (family == wxT("roman")) ifamily = wxROMAN;
2273         else if (family == wxT("script")) ifamily = wxSCRIPT;
2274         else if (family == wxT("swiss")) ifamily = wxSWISS;
2275         else if (family == wxT("modern")) ifamily = wxMODERN;
2276         else if (family == wxT("teletype")) ifamily = wxTELETYPE;
2277         else
2278         {
2279             ReportParamError
2280             (
2281                 param,
2282                 wxString::Format("unknown font family \"%s\"", family)
2283             );
2284         }
2285     }
2286
2287
2288     wxString facename;
2289     bool hasFacename = HasParam(wxT("face"));
2290     if (hasFacename)
2291     {
2292         wxString faces = GetParamValue(wxT("face"));
2293         wxStringTokenizer tk(faces, wxT(","));
2294 #if wxUSE_FONTENUM
2295         wxArrayString facenames(wxFontEnumerator::GetFacenames());
2296         while (tk.HasMoreTokens())
2297         {
2298             int index = facenames.Index(tk.GetNextToken(), false);
2299             if (index != wxNOT_FOUND)
2300             {
2301                 facename = facenames[index];
2302                 break;
2303             }
2304         }
2305 #else // !wxUSE_FONTENUM
2306         // just use the first face name if we can't check its availability:
2307         if (tk.HasMoreTokens())
2308             facename = tk.GetNextToken();
2309 #endif // wxUSE_FONTENUM/!wxUSE_FONTENUM
2310     }
2311
2312     // encoding
2313     wxFontEncoding enc = wxFONTENCODING_DEFAULT;
2314     bool hasEncoding = HasParam(wxT("encoding"));
2315 #if wxUSE_FONTMAP
2316     if (hasEncoding)
2317     {
2318         wxString encoding = GetParamValue(wxT("encoding"));
2319         wxFontMapper mapper;
2320         if (!encoding.empty())
2321             enc = mapper.CharsetToEncoding(encoding);
2322         if (enc == wxFONTENCODING_SYSTEM)
2323             enc = wxFONTENCODING_DEFAULT;
2324     }
2325 #endif // wxUSE_FONTMAP
2326
2327     wxFont font;
2328
2329     // is this font based on a system font?
2330     if (HasParam(wxT("sysfont")))
2331     {
2332         font = GetSystemFont(GetParamValue(wxT("sysfont")));
2333         if (HasParam(wxT("inherit")))
2334         {
2335             ReportParamError
2336             (
2337                 param,
2338                 "double specification of \"sysfont\" and \"inherit\""
2339             );
2340         }
2341     }
2342     // or should the font of the widget be used?
2343     else if (GetBool(wxT("inherit"), false))
2344     {
2345         if (parent)
2346             font = parent->GetFont();
2347         else
2348         {
2349             ReportParamError
2350             (
2351                 param,
2352                 "no parent window specified to derive the font from"
2353             );
2354         }
2355     }
2356
2357     if (font.IsOk())
2358     {
2359         if (hasSize && isize != -1)
2360         {
2361             font.SetPointSize(isize);
2362             if (HasParam(wxT("relativesize")))
2363             {
2364                 ReportParamError
2365                 (
2366                     param,
2367                     "double specification of \"size\" and \"relativesize\""
2368                 );
2369             }
2370         }
2371         else if (HasParam(wxT("relativesize")))
2372             font.SetPointSize(int(font.GetPointSize() *
2373                                      GetFloat(wxT("relativesize"))));
2374
2375         if (hasStyle)
2376             font.SetStyle(istyle);
2377         if (hasWeight)
2378             font.SetWeight(iweight);
2379         if (hasUnderlined)
2380             font.SetUnderlined(underlined);
2381         if (hasFamily)
2382             font.SetFamily(ifamily);
2383         if (hasFacename)
2384             font.SetFaceName(facename);
2385         if (hasEncoding)
2386             font.SetDefaultEncoding(enc);
2387     }
2388     else // not based on system font
2389     {
2390         font = wxFont(isize == -1 ? wxNORMAL_FONT->GetPointSize() : isize,
2391                       ifamily, istyle, iweight,
2392                       underlined, facename, enc);
2393     }
2394
2395     m_handler->m_node = oldnode;
2396     return font;
2397 }
2398
2399
2400 void wxXmlResourceHandlerImpl::SetupWindow(wxWindow *wnd)
2401 {
2402     //FIXME : add cursor
2403
2404     if (HasParam(wxT("exstyle")))
2405         // Have to OR it with existing style, since
2406         // some implementations (e.g. wxGTK) use the extra style
2407         // during creation
2408         wnd->SetExtraStyle(wnd->GetExtraStyle() | GetStyle(wxT("exstyle")));
2409     if (HasParam(wxT("bg")))
2410         wnd->SetBackgroundColour(GetColour(wxT("bg")));
2411     if (HasParam(wxT("ownbg")))
2412         wnd->SetOwnBackgroundColour(GetColour(wxT("ownbg")));
2413     if (HasParam(wxT("fg")))
2414         wnd->SetForegroundColour(GetColour(wxT("fg")));
2415     if (HasParam(wxT("ownfg")))
2416         wnd->SetOwnForegroundColour(GetColour(wxT("ownfg")));
2417     if (GetBool(wxT("enabled"), 1) == 0)
2418         wnd->Enable(false);
2419     if (GetBool(wxT("focused"), 0) == 1)
2420         wnd->SetFocus();
2421     if (GetBool(wxT("hidden"), 0) == 1)
2422         wnd->Show(false);
2423 #if wxUSE_TOOLTIPS
2424     if (HasParam(wxT("tooltip")))
2425         wnd->SetToolTip(GetText(wxT("tooltip")));
2426 #endif
2427     if (HasParam(wxT("font")))
2428         wnd->SetFont(GetFont(wxT("font"), wnd));
2429     if (HasParam(wxT("ownfont")))
2430         wnd->SetOwnFont(GetFont(wxT("ownfont"), wnd));
2431     if (HasParam(wxT("help")))
2432         wnd->SetHelpText(GetText(wxT("help")));
2433 }
2434
2435
2436 void wxXmlResourceHandlerImpl::CreateChildren(wxObject *parent, bool this_hnd_only)
2437 {
2438     for ( wxXmlNode *n = m_handler->m_node->GetChildren(); n; n = n->GetNext() )
2439     {
2440         if ( IsObjectNode(n) )
2441         {
2442             m_handler->m_resource->DoCreateResFromNode(*n, parent, NULL,
2443                                             this_hnd_only ? this->GetHandler() : NULL);
2444        }
2445     }
2446 }
2447
2448
2449 void wxXmlResourceHandlerImpl::CreateChildrenPrivately(wxObject *parent, wxXmlNode *rootnode)
2450 {
2451     wxXmlNode *root;
2452     if (rootnode == NULL) root = m_handler->m_node; else root = rootnode;
2453     wxXmlNode *n = root->GetChildren();
2454
2455     while (n)
2456     {
2457         if (n->GetType() == wxXML_ELEMENT_NODE && GetHandler()->CanHandle(n))
2458         {
2459             CreateResource(n, parent, NULL);
2460         }
2461         n = n->GetNext();
2462     }
2463 }
2464
2465
2466 //-----------------------------------------------------------------------------
2467 // errors reporting
2468 //-----------------------------------------------------------------------------
2469
2470 void wxXmlResourceHandlerImpl::ReportError(const wxString& message)
2471 {
2472     m_handler->m_resource->ReportError(m_handler->m_node, message);
2473 }
2474
2475 void wxXmlResourceHandlerImpl::ReportError(wxXmlNode *context,
2476                                        const wxString& message)
2477 {
2478     m_handler->m_resource->ReportError(context ? context : m_handler->m_node, message);
2479 }
2480
2481 void wxXmlResourceHandlerImpl::ReportParamError(const wxString& param,
2482                                             const wxString& message)
2483 {
2484     m_handler->m_resource->ReportError(GetParamNode(param), message);
2485 }
2486
2487 void wxXmlResource::ReportError(const wxXmlNode *context, const wxString& message)
2488 {
2489     if ( !context )
2490     {
2491         DoReportError("", NULL, message);
2492         return;
2493     }
2494
2495     // We need to find out the file that 'context' is part of. Performance of
2496     // this code is not critical, so we simply find the root XML node and
2497     // compare it with all loaded XRC files.
2498     const wxString filename = GetFileNameFromNode(context, Data());
2499
2500     DoReportError(filename, context, message);
2501 }
2502
2503 void wxXmlResource::DoReportError(const wxString& xrcFile, const wxXmlNode *position,
2504                                   const wxString& message)
2505 {
2506     const int line = position ? position->GetLineNumber() : -1;
2507
2508     wxString loc;
2509     if ( !xrcFile.empty() )
2510         loc = xrcFile + ':';
2511     if ( line != -1 )
2512         loc += wxString::Format("%d:", line);
2513     if ( !loc.empty() )
2514         loc += ' ';
2515
2516     wxLogError("XRC error: %s%s", loc, message);
2517 }
2518
2519
2520 //-----------------------------------------------------------------------------
2521 // XRCID implementation
2522 //-----------------------------------------------------------------------------
2523
2524 #define XRCID_TABLE_SIZE     1024
2525
2526
2527 struct XRCID_record
2528 {
2529     /* Hold the id so that once an id is allocated for a name, it
2530        does not get created again by NewControlId at least
2531        until we are done with it */
2532     wxWindowIDRef id;
2533     char *key;
2534     XRCID_record *next;
2535 };
2536
2537 static XRCID_record *XRCID_Records[XRCID_TABLE_SIZE] = {NULL};
2538
2539 // Extremely simplistic hash function which probably ought to be replaced with
2540 // wxStringHash::stringHash().
2541 static inline unsigned XRCIdHash(const char *str_id)
2542 {
2543     unsigned index = 0;
2544
2545     for (const char *c = str_id; *c != '\0'; c++) index += (unsigned int)*c;
2546     index %= XRCID_TABLE_SIZE;
2547
2548     return index;
2549 }
2550
2551 static void XRCID_Assign(const wxString& str_id, int value)
2552 {
2553     const wxCharBuffer buf_id(str_id.mb_str());
2554     const unsigned index = XRCIdHash(buf_id);
2555
2556
2557     XRCID_record *oldrec = NULL;
2558     for (XRCID_record *rec = XRCID_Records[index]; rec; rec = rec->next)
2559     {
2560         if (wxStrcmp(rec->key, buf_id) == 0)
2561         {
2562             rec->id = value;
2563             return;
2564         }
2565         oldrec = rec;
2566     }
2567
2568     XRCID_record **rec_var = (oldrec == NULL) ?
2569                               &XRCID_Records[index] : &oldrec->next;
2570     *rec_var = new XRCID_record;
2571     (*rec_var)->key = wxStrdup(str_id);
2572     (*rec_var)->id = value;
2573     (*rec_var)->next = NULL;
2574 }
2575
2576 static int XRCID_Lookup(const char *str_id, int value_if_not_found = wxID_NONE)
2577 {
2578     const unsigned index = XRCIdHash(str_id);
2579
2580
2581     XRCID_record *oldrec = NULL;
2582     for (XRCID_record *rec = XRCID_Records[index]; rec; rec = rec->next)
2583     {
2584         if (wxStrcmp(rec->key, str_id) == 0)
2585         {
2586             return rec->id;
2587         }
2588         oldrec = rec;
2589     }
2590
2591     XRCID_record **rec_var = (oldrec == NULL) ?
2592                               &XRCID_Records[index] : &oldrec->next;
2593     *rec_var = new XRCID_record;
2594     (*rec_var)->key = wxStrdup(str_id);
2595     (*rec_var)->next = NULL;
2596
2597     char *end;
2598     if (value_if_not_found != wxID_NONE)
2599         (*rec_var)->id = value_if_not_found;
2600     else
2601     {
2602         int asint = wxStrtol(str_id, &end, 10);
2603         if (*str_id && *end == 0)
2604         {
2605             // if str_id was integer, keep it verbosely:
2606             (*rec_var)->id = asint;
2607         }
2608         else
2609         {
2610             (*rec_var)->id = wxWindowBase::NewControlId();
2611         }
2612     }
2613
2614     return (*rec_var)->id;
2615 }
2616
2617 namespace
2618 {
2619
2620 // flag indicating whether standard XRC ids were already initialized
2621 static bool gs_stdIDsAdded = false;
2622
2623 void AddStdXRCID_Records()
2624 {
2625 #define stdID(id) XRCID_Lookup(#id, id)
2626     stdID(-1);
2627
2628     stdID(wxID_ANY);
2629     stdID(wxID_SEPARATOR);
2630
2631     stdID(wxID_OPEN);
2632     stdID(wxID_CLOSE);
2633     stdID(wxID_NEW);
2634     stdID(wxID_SAVE);
2635     stdID(wxID_SAVEAS);
2636     stdID(wxID_REVERT);
2637     stdID(wxID_EXIT);
2638     stdID(wxID_UNDO);
2639     stdID(wxID_REDO);
2640     stdID(wxID_HELP);
2641     stdID(wxID_PRINT);
2642     stdID(wxID_PRINT_SETUP);
2643     stdID(wxID_PAGE_SETUP);
2644     stdID(wxID_PREVIEW);
2645     stdID(wxID_ABOUT);
2646     stdID(wxID_HELP_CONTENTS);
2647     stdID(wxID_HELP_INDEX),
2648     stdID(wxID_HELP_SEARCH),
2649     stdID(wxID_HELP_COMMANDS);
2650     stdID(wxID_HELP_PROCEDURES);
2651     stdID(wxID_HELP_CONTEXT);
2652     stdID(wxID_CLOSE_ALL);
2653     stdID(wxID_PREFERENCES);
2654
2655     stdID(wxID_EDIT);
2656     stdID(wxID_CUT);
2657     stdID(wxID_COPY);
2658     stdID(wxID_PASTE);
2659     stdID(wxID_CLEAR);
2660     stdID(wxID_FIND);
2661     stdID(wxID_DUPLICATE);
2662     stdID(wxID_SELECTALL);
2663     stdID(wxID_DELETE);
2664     stdID(wxID_REPLACE);
2665     stdID(wxID_REPLACE_ALL);
2666     stdID(wxID_PROPERTIES);
2667
2668     stdID(wxID_VIEW_DETAILS);
2669     stdID(wxID_VIEW_LARGEICONS);
2670     stdID(wxID_VIEW_SMALLICONS);
2671     stdID(wxID_VIEW_LIST);
2672     stdID(wxID_VIEW_SORTDATE);
2673     stdID(wxID_VIEW_SORTNAME);
2674     stdID(wxID_VIEW_SORTSIZE);
2675     stdID(wxID_VIEW_SORTTYPE);
2676
2677
2678     stdID(wxID_FILE1);
2679     stdID(wxID_FILE2);
2680     stdID(wxID_FILE3);
2681     stdID(wxID_FILE4);
2682     stdID(wxID_FILE5);
2683     stdID(wxID_FILE6);
2684     stdID(wxID_FILE7);
2685     stdID(wxID_FILE8);
2686     stdID(wxID_FILE9);
2687
2688
2689     stdID(wxID_OK);
2690     stdID(wxID_CANCEL);
2691     stdID(wxID_APPLY);
2692     stdID(wxID_YES);
2693     stdID(wxID_NO);
2694     stdID(wxID_STATIC);
2695     stdID(wxID_FORWARD);
2696     stdID(wxID_BACKWARD);
2697     stdID(wxID_DEFAULT);
2698     stdID(wxID_MORE);
2699     stdID(wxID_SETUP);
2700     stdID(wxID_RESET);
2701     stdID(wxID_CONTEXT_HELP);
2702     stdID(wxID_YESTOALL);
2703     stdID(wxID_NOTOALL);
2704     stdID(wxID_ABORT);
2705     stdID(wxID_RETRY);
2706     stdID(wxID_IGNORE);
2707     stdID(wxID_ADD);
2708     stdID(wxID_REMOVE);
2709
2710     stdID(wxID_UP);
2711     stdID(wxID_DOWN);
2712     stdID(wxID_HOME);
2713     stdID(wxID_REFRESH);
2714     stdID(wxID_STOP);
2715     stdID(wxID_INDEX);
2716
2717     stdID(wxID_BOLD);
2718     stdID(wxID_ITALIC);
2719     stdID(wxID_JUSTIFY_CENTER);
2720     stdID(wxID_JUSTIFY_FILL);
2721     stdID(wxID_JUSTIFY_RIGHT);
2722     stdID(wxID_JUSTIFY_LEFT);
2723     stdID(wxID_UNDERLINE);
2724     stdID(wxID_INDENT);
2725     stdID(wxID_UNINDENT);
2726     stdID(wxID_ZOOM_100);
2727     stdID(wxID_ZOOM_FIT);
2728     stdID(wxID_ZOOM_IN);
2729     stdID(wxID_ZOOM_OUT);
2730     stdID(wxID_UNDELETE);
2731     stdID(wxID_REVERT_TO_SAVED);
2732     stdID(wxID_CDROM);
2733     stdID(wxID_CONVERT);
2734     stdID(wxID_EXECUTE);
2735     stdID(wxID_FLOPPY);
2736     stdID(wxID_HARDDISK);
2737     stdID(wxID_BOTTOM);
2738     stdID(wxID_FIRST);
2739     stdID(wxID_LAST);
2740     stdID(wxID_TOP);
2741     stdID(wxID_INFO);
2742     stdID(wxID_JUMP_TO);
2743     stdID(wxID_NETWORK);
2744     stdID(wxID_SELECT_COLOR);
2745     stdID(wxID_SELECT_FONT);
2746     stdID(wxID_SORT_ASCENDING);
2747     stdID(wxID_SORT_DESCENDING);
2748     stdID(wxID_SPELL_CHECK);
2749     stdID(wxID_STRIKETHROUGH);
2750
2751
2752     stdID(wxID_SYSTEM_MENU);
2753     stdID(wxID_CLOSE_FRAME);
2754     stdID(wxID_MOVE_FRAME);
2755     stdID(wxID_RESIZE_FRAME);
2756     stdID(wxID_MAXIMIZE_FRAME);
2757     stdID(wxID_ICONIZE_FRAME);
2758     stdID(wxID_RESTORE_FRAME);
2759
2760
2761
2762     stdID(wxID_MDI_WINDOW_CASCADE);
2763     stdID(wxID_MDI_WINDOW_TILE_HORZ);
2764     stdID(wxID_MDI_WINDOW_TILE_VERT);
2765     stdID(wxID_MDI_WINDOW_ARRANGE_ICONS);
2766     stdID(wxID_MDI_WINDOW_PREV);
2767     stdID(wxID_MDI_WINDOW_NEXT);
2768 #undef stdID
2769 }
2770
2771 } // anonymous namespace
2772
2773
2774 /*static*/
2775 int wxXmlResource::DoGetXRCID(const char *str_id, int value_if_not_found)
2776 {
2777     if ( !gs_stdIDsAdded )
2778     {
2779         gs_stdIDsAdded = true;
2780         AddStdXRCID_Records();
2781     }
2782
2783     return XRCID_Lookup(str_id, value_if_not_found);
2784 }
2785
2786 /* static */
2787 wxString wxXmlResource::FindXRCIDById(int numId)
2788 {
2789     for ( int i = 0; i < XRCID_TABLE_SIZE; i++ )
2790     {
2791         for ( XRCID_record *rec = XRCID_Records[i]; rec; rec = rec->next )
2792         {
2793             if ( rec->id == numId )
2794                 return wxString(rec->key);
2795         }
2796     }
2797
2798     return wxString();
2799 }
2800
2801 static void CleanXRCID_Record(XRCID_record *rec)
2802 {
2803     if (rec)
2804     {
2805         CleanXRCID_Record(rec->next);
2806
2807         free(rec->key);
2808         delete rec;
2809     }
2810 }
2811
2812 static void CleanXRCID_Records()
2813 {
2814     for (int i = 0; i < XRCID_TABLE_SIZE; i++)
2815     {
2816         CleanXRCID_Record(XRCID_Records[i]);
2817         XRCID_Records[i] = NULL;
2818     }
2819
2820     gs_stdIDsAdded = false;
2821 }
2822
2823
2824 //-----------------------------------------------------------------------------
2825 // module and globals
2826 //-----------------------------------------------------------------------------
2827
2828 // normally we would do the cleanup from wxXmlResourceModule::OnExit() but it
2829 // can happen that some XRC records have been created because of the use of
2830 // XRCID() in event tables, which happens during static objects initialization,
2831 // but then the application initialization failed and so the wx modules were
2832 // neither initialized nor cleaned up -- this static object does the cleanup in
2833 // this case
2834 static struct wxXRCStaticCleanup
2835 {
2836     ~wxXRCStaticCleanup() { CleanXRCID_Records(); }
2837 } s_staticCleanup;
2838
2839 class wxXmlResourceModule: public wxModule
2840 {
2841 DECLARE_DYNAMIC_CLASS(wxXmlResourceModule)
2842 public:
2843     wxXmlResourceModule() {}
2844     bool OnInit()
2845     {
2846         wxXmlResource::AddSubclassFactory(new wxXmlSubclassFactoryCXX);
2847         return true;
2848     }
2849     void OnExit()
2850     {
2851         delete wxXmlResource::Set(NULL);
2852         delete wxIdRangeManager::Set(NULL);
2853         if(wxXmlResource::ms_subclassFactories)
2854         {
2855             for ( wxXmlSubclassFactories::iterator i = wxXmlResource::ms_subclassFactories->begin();
2856                   i != wxXmlResource::ms_subclassFactories->end(); ++i )
2857             {
2858                 delete *i;
2859             }
2860             wxDELETE(wxXmlResource::ms_subclassFactories);
2861         }
2862         CleanXRCID_Records();
2863     }
2864 };
2865
2866 IMPLEMENT_DYNAMIC_CLASS(wxXmlResourceModule, wxModule)
2867
2868
2869 // When wxXml is loaded dynamically after the application is already running
2870 // then the built-in module system won't pick this one up.  Add it manually.
2871 void wxXmlInitResourceModule()
2872 {
2873     wxModule* module = new wxXmlResourceModule;
2874     wxModule::RegisterModule(module);
2875     wxModule::InitializeModules();
2876 }
2877
2878 #endif // wxUSE_XRC