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 // RCS-ID:      $Id$
   7 // Copyright:   (c) 2000 Vaclav Slavik
   8 // Licence:     wxWindows licence
   9 /////////////////////////////////////////////////////////////////////////////
  10
  11 // For compilers that support precompilation, includes "wx.h".
  12 #include "wx/wxprec.h"
  13
  14 #ifdef __BORLANDC__
  15     #pragma hdrstop
  16 #endif
  17
  18 #if wxUSE_XRC
  19
  20 #include "wx/xrc/xmlres.h"
  21
  22 #ifndef WX_PRECOMP
  23     #include "wx/intl.h"
  24     #include "wx/log.h"
  25     #include "wx/panel.h"
  26     #include "wx/frame.h"
  27     #include "wx/dialog.h"
  28     #include "wx/settings.h"
  29     #include "wx/bitmap.h"
  30     #include "wx/image.h"
  31     #include "wx/module.h"
  32     #include "wx/wxcrtvararg.h"
  33 #endif
  34
  35 #ifndef __WXWINCE__
  36     #include <locale.h>
  37 #endif
  38
  39 #include "wx/vector.h"
  40 #include "wx/wfstream.h"
  41 #include "wx/filesys.h"
  42 #include "wx/filename.h"
  43 #include "wx/tokenzr.h"
  44 #include "wx/fontenum.h"
  45 #include "wx/fontmap.h"
  46 #include "wx/artprov.h"
  47 #include "wx/dir.h"
  48 #include "wx/xml/xml.h"
  49
  50
  51 class wxXmlResourceDataRecord
  52 {
  53 public:
  54     wxXmlResourceDataRecord() : Doc(NULL) {
  55 #if wxUSE_DATETIME
  56         Time = wxDateTime::Now();
  57 #endif
  58     }
  59     ~wxXmlResourceDataRecord() {delete Doc;}
  60
  61     wxString File;
  62     wxXmlDocument *Doc;
  63 #if wxUSE_DATETIME
  64     wxDateTime Time;
  65 #endif
  66 };
  67
  68 class wxXmlResourceDataRecords : public wxVector<wxXmlResourceDataRecord*>
  69 {
  70     // this is a class so that it can be forward-declared
  71 };
  72
  73 namespace
  74 {
  75
  76 // helper used by DoFindResource() and elsewhere: returns true if this is an
  77 // object or object_ref node
  78 //
  79 // node must be non-NULL
  80 inline bool IsObjectNode(wxXmlNode *node)
  81 {
  82     return node->GetType() == wxXML_ELEMENT_NODE &&
  83              (node->GetName() == wxS("object") ||
  84                 node->GetName() == wxS("object_ref"));
  85 }
  86
  87 // special XML attribute with name of input file, see GetFileNameFromNode()
  88 const char *ATTR_INPUT_FILENAME = "__wx:filename";
  89
  90 // helper to get filename corresponding to an XML node
  91 wxString
  92 GetFileNameFromNode(wxXmlNode *node, const wxXmlResourceDataRecords& files)
  93 {
  94     // this loop does two things: it looks for ATTR_INPUT_FILENAME among
  95     // parents and if it isn't used, it finds the root of the XML tree 'node'
  96     // is in
  97     for ( ;; )
  98     {
  99         // in some rare cases (specifically, when an <object_ref> is used, see
 100         // wxXmlResource::CreateResFromNode() and MergeNodesOver()), we work
 101         // with XML nodes that are not rooted in any document from 'files'
 102         // (because a new node was created by CreateResFromNode() to merge the
 103         // content of <object_ref> and the referenced <object>); in that case,
 104         // we hack around the problem by putting the information about input
 105         // file into a custom attribute
 106         if ( node->HasAttribute(ATTR_INPUT_FILENAME) )
 107             return node->GetAttribute(ATTR_INPUT_FILENAME);
 108
 109         if ( !node->GetParent() )
 110             break; // we found the root of this XML tree
 111
 112         node = node->GetParent();
 113     }
 114
 115     // NB: 'node' now points to the root of XML document
 116
 117     for ( wxXmlResourceDataRecords::const_iterator i = files.begin();
 118           i != files.end(); ++i )
 119     {
 120         if ( (*i)->Doc->GetRoot() == node )
 121         {
 122             return (*i)->File;
 123         }
 124     }
 125
 126     return wxEmptyString; // not found
 127 }
 128
 129 } // anonymous namespace
 130
 131
 132 wxXmlResource *wxXmlResource::ms_instance = NULL;
 133
 134 /*static*/ wxXmlResource *wxXmlResource::Get()
 135 {
 136     if ( !ms_instance )
 137         ms_instance = new wxXmlResource;
 138     return ms_instance;
 139 }
 140
 141 /*static*/ wxXmlResource *wxXmlResource::Set(wxXmlResource *res)
 142 {
 143     wxXmlResource *old = ms_instance;
 144     ms_instance = res;
 145     return old;
 146 }
 147
 148 wxXmlResource::wxXmlResource(int flags, const wxString& domain)
 149 {
 150     m_flags = flags;
 151     m_version = -1;
 152     m_data = new wxXmlResourceDataRecords;
 153     SetDomain(domain);
 154 }
 155
 156 wxXmlResource::wxXmlResource(const wxString& filemask, int flags, const wxString& domain)
 157 {
 158     m_flags = flags;
 159     m_version = -1;
 160     m_data = new wxXmlResourceDataRecords;
 161     SetDomain(domain);
 162     Load(filemask);
 163 }
 164
 165 wxXmlResource::~wxXmlResource()
 166 {
 167     ClearHandlers();
 168
 169     for ( wxXmlResourceDataRecords::iterator i = m_data->begin();
 170           i != m_data->end(); ++i )
 171     {
 172         delete *i;
 173     }
 174     delete m_data;
 175 }
 176
 177 void wxXmlResource::SetDomain(const wxString& domain)
 178 {
 179     m_domain = domain;
 180 }
 181
 182
 183 /* static */
 184 wxString wxXmlResource::ConvertFileNameToURL(const wxString& filename)
 185 {
 186     wxString fnd(filename);
 187
 188     // NB: as Load() and Unload() accept both filenames and URLs (should
 189     //     probably be changed to filenames only, but embedded resources
 190     //     currently rely on its ability to handle URLs - FIXME) we need to
 191     //     determine whether found name is filename and not URL and this is the
 192     //     fastest/simplest way to do it
 193     if (wxFileName::FileExists(fnd))
 194     {
 195         // Make the name absolute filename, because the app may
 196         // change working directory later:
 197         wxFileName fn(fnd);
 198         if (fn.IsRelative())
 199         {
 200             fn.MakeAbsolute();
 201             fnd = fn.GetFullPath();
 202         }
 203 #if wxUSE_FILESYSTEM
 204         fnd = wxFileSystem::FileNameToURL(fnd);
 205 #endif
 206     }
 207
 208     return fnd;
 209 }
 210
 211 #if wxUSE_FILESYSTEM
 212
 213 /* static */
 214 bool wxXmlResource::IsArchive(const wxString& filename)
 215 {
 216     const wxString fnd = filename.Lower();
 217
 218     return fnd.Matches(wxT("*.zip")) || fnd.Matches(wxT("*.xrs"));
 219 }
 220
 221 #endif // wxUSE_FILESYSTEM
 222
 223 bool wxXmlResource::LoadFile(const wxFileName& file)
 224 {
 225 #if wxUSE_FILESYSTEM
 226     return Load(wxFileSystem::FileNameToURL(file));
 227 #else
 228     return Load(file.GetFullPath());
 229 #endif
 230 }
 231
 232 bool wxXmlResource::LoadAllFiles(const wxString& dirname)
 233 {
 234     bool ok = true;
 235     wxArrayString files;
 236
 237     wxDir::GetAllFiles(dirname, &files, "*.xrc");
 238
 239     for ( wxArrayString::const_iterator i = files.begin(); i != files.end(); ++i )
 240     {
 241         if ( !LoadFile(*i) )
 242             ok = false;
 243     }
 244
 245     return ok;
 246 }
 247
 248 bool wxXmlResource::Load(const wxString& filemask_)
 249 {
 250     wxString filemask = ConvertFileNameToURL(filemask_);
 251
 252 #if wxUSE_FILESYSTEM
 253     wxFileSystem fsys;
 254 #   define wxXmlFindFirst  fsys.FindFirst(filemask, wxFILE)
 255 #   define wxXmlFindNext   fsys.FindNext()
 256 #else
 257 #   define wxXmlFindFirst  wxFindFirstFile(filemask, wxFILE)
 258 #   define wxXmlFindNext   wxFindNextFile()
 259 #endif
 260     wxString fnd = wxXmlFindFirst;
 261     if ( fnd.empty() )
 262     {
 263         wxLogError(_("Cannot load resources from '%s'."), filemask);
 264         return false;
 265     }
 266
 267     while (!fnd.empty())
 268     {
 269 #if wxUSE_FILESYSTEM
 270         if ( IsArchive(fnd) )
 271         {
 272             if ( !Load(fnd + wxT("#zip:*.xrc")) )
 273                 return false;
 274         }
 275         else // a single resource URL
 276 #endif // wxUSE_FILESYSTEM
 277         {
 278             wxXmlResourceDataRecord *drec = new wxXmlResourceDataRecord;
 279             drec->File = fnd;
 280             Data().push_back(drec);
 281         }
 282
 283         fnd = wxXmlFindNext;
 284     }
 285 #   undef wxXmlFindFirst
 286 #   undef wxXmlFindNext
 287
 288     return UpdateResources();
 289 }
 290
 291 bool wxXmlResource::Unload(const wxString& filename)
 292 {
 293     wxASSERT_MSG( !wxIsWild(filename),
 294                     _T("wildcards not supported by wxXmlResource::Unload()") );
 295
 296     wxString fnd = ConvertFileNameToURL(filename);
 297 #if wxUSE_FILESYSTEM
 298     const bool isArchive = IsArchive(fnd);
 299     if ( isArchive )
 300         fnd += _T("#zip:");
 301 #endif // wxUSE_FILESYSTEM
 302
 303     bool unloaded = false;
 304     for ( wxXmlResourceDataRecords::iterator i = Data().begin();
 305           i != Data().end(); ++i )
 306     {
 307 #if wxUSE_FILESYSTEM
 308         if ( isArchive )
 309         {
 310             if ( (*i)->File.StartsWith(fnd) )
 311                 unloaded = true;
 312             // don't break from the loop, we can have other matching files
 313         }
 314         else // a single resource URL
 315 #endif // wxUSE_FILESYSTEM
 316         {
 317             if ( (*i)->File == fnd )
 318             {
 319                 delete *i;
 320                 Data().erase(i);
 321                 unloaded = true;
 322
 323                 // no sense in continuing, there is only one file with this URL
 324                 break;
 325             }
 326         }
 327     }
 328
 329     return unloaded;
 330 }
 331
 332
 333 IMPLEMENT_ABSTRACT_CLASS(wxXmlResourceHandler, wxObject)
 334
 335 void wxXmlResource::AddHandler(wxXmlResourceHandler *handler)
 336 {
 337     m_handlers.push_back(handler);
 338     handler->SetParentResource(this);
 339 }
 340
 341 void wxXmlResource::InsertHandler(wxXmlResourceHandler *handler)
 342 {
 343     m_handlers.insert(m_handlers.begin(), handler);
 344     handler->SetParentResource(this);
 345 }
 346
 347
 348
 349 void wxXmlResource::ClearHandlers()
 350 {
 351     for ( wxVector<wxXmlResourceHandler*>::iterator i = m_handlers.begin();
 352           i != m_handlers.end(); ++i )
 353         delete *i;
 354     m_handlers.clear();
 355 }
 356
 357
 358 wxMenu *wxXmlResource::LoadMenu(const wxString& name)
 359 {
 360     return (wxMenu*)CreateResFromNode(FindResource(name, wxT("wxMenu")), NULL, NULL);
 361 }
 362
 363
 364
 365 wxMenuBar *wxXmlResource::LoadMenuBar(wxWindow *parent, const wxString& name)
 366 {
 367     return (wxMenuBar*)CreateResFromNode(FindResource(name, wxT("wxMenuBar")), parent, NULL);
 368 }
 369
 370
 371
 372 #if wxUSE_TOOLBAR
 373 wxToolBar *wxXmlResource::LoadToolBar(wxWindow *parent, const wxString& name)
 374 {
 375     return (wxToolBar*)CreateResFromNode(FindResource(name, wxT("wxToolBar")), parent, NULL);
 376 }
 377 #endif
 378
 379
 380 wxDialog *wxXmlResource::LoadDialog(wxWindow *parent, const wxString& name)
 381 {
 382     return (wxDialog*)CreateResFromNode(FindResource(name, wxT("wxDialog")), parent, NULL);
 383 }
 384
 385 bool wxXmlResource::LoadDialog(wxDialog *dlg, wxWindow *parent, const wxString& name)
 386 {
 387     return CreateResFromNode(FindResource(name, wxT("wxDialog")), parent, dlg) != NULL;
 388 }
 389
 390
 391
 392 wxPanel *wxXmlResource::LoadPanel(wxWindow *parent, const wxString& name)
 393 {
 394     return (wxPanel*)CreateResFromNode(FindResource(name, wxT("wxPanel")), parent, NULL);
 395 }
 396
 397 bool wxXmlResource::LoadPanel(wxPanel *panel, wxWindow *parent, const wxString& name)
 398 {
 399     return CreateResFromNode(FindResource(name, wxT("wxPanel")), parent, panel) != NULL;
 400 }
 401
 402 wxFrame *wxXmlResource::LoadFrame(wxWindow* parent, const wxString& name)
 403 {
 404     return (wxFrame*)CreateResFromNode(FindResource(name, wxT("wxFrame")), parent, NULL);
 405 }
 406
 407 bool wxXmlResource::LoadFrame(wxFrame* frame, wxWindow *parent, const wxString& name)
 408 {
 409     return CreateResFromNode(FindResource(name, wxT("wxFrame")), parent, frame) != NULL;
 410 }
 411
 412 wxBitmap wxXmlResource::LoadBitmap(const wxString& name)
 413 {
 414     wxBitmap *bmp = (wxBitmap*)CreateResFromNode(
 415                                FindResource(name, wxT("wxBitmap")), NULL, NULL);
 416     wxBitmap rt;
 417
 418     if (bmp) { rt = *bmp; delete bmp; }
 419     return rt;
 420 }
 421
 422 wxIcon wxXmlResource::LoadIcon(const wxString& name)
 423 {
 424     wxIcon *icon = (wxIcon*)CreateResFromNode(
 425                             FindResource(name, wxT("wxIcon")), NULL, NULL);
 426     wxIcon rt;
 427
 428     if (icon) { rt = *icon; delete icon; }
 429     return rt;
 430 }
 431
 432
 433 wxObject *wxXmlResource::LoadObject(wxWindow *parent, const wxString& name, const wxString& classname)
 434 {
 435     return CreateResFromNode(FindResource(name, classname), parent, NULL);
 436 }
 437
 438 bool wxXmlResource::LoadObject(wxObject *instance, wxWindow *parent, const wxString& name, const wxString& classname)
 439 {
 440     return CreateResFromNode(FindResource(name, classname), parent, instance) != NULL;
 441 }
 442
 443
 444 bool wxXmlResource::AttachUnknownControl(const wxString& name,
 445                                          wxWindow *control, wxWindow *parent)
 446 {
 447     if (parent == NULL)
 448         parent = control->GetParent();
 449     wxWindow *container = parent->FindWindow(name + wxT("_container"));
 450     if (!container)
 451     {
 452         wxLogError("Cannot find container for unknown control '%s'.", name);
 453         return false;
 454     }
 455     return control->Reparent(container);
 456 }
 457
 458
 459 static void ProcessPlatformProperty(wxXmlNode *node)
 460 {
 461     wxString s;
 462     bool isok;
 463
 464     wxXmlNode *c = node->GetChildren();
 465     while (c)
 466     {
 467         isok = false;
 468         if (!c->GetAttribute(wxT("platform"), &s))
 469             isok = true;
 470         else
 471         {
 472             wxStringTokenizer tkn(s, wxT(" |"));
 473
 474             while (tkn.HasMoreTokens())
 475             {
 476                 s = tkn.GetNextToken();
 477 #ifdef __WINDOWS__
 478                 if (s == wxT("win")) isok = true;
 479 #endif
 480 #if defined(__MAC__) || defined(__APPLE__)
 481                 if (s == wxT("mac")) isok = true;
 482 #elif defined(__UNIX__)
 483                 if (s == wxT("unix")) isok = true;
 484 #endif
 485 #ifdef __OS2__
 486                 if (s == wxT("os2")) isok = true;
 487 #endif
 488
 489                 if (isok)
 490                     break;
 491             }
 492         }
 493
 494         if (isok)
 495         {
 496             ProcessPlatformProperty(c);
 497             c = c->GetNext();
 498         }
 499         else
 500         {
 501             wxXmlNode *c2 = c->GetNext();
 502             node->RemoveChild(c);
 503             delete c;
 504             c = c2;
 505         }
 506     }
 507 }
 508
 509
 510
 511 bool wxXmlResource::UpdateResources()
 512 {
 513     bool rt = true;
 514     bool modif;
 515 #   if wxUSE_FILESYSTEM
 516     wxFSFile *file = NULL;
 517     wxUnusedVar(file);
 518     wxFileSystem fsys;
 519 #   endif
 520
 521     wxString encoding(wxT("UTF-8"));
 522 #if !wxUSE_UNICODE && wxUSE_INTL
 523     if ( (GetFlags() & wxXRC_USE_LOCALE) == 0 )
 524     {
 525         // In case we are not using wxLocale to translate strings, convert the
 526         // strings GUI's charset. This must not be done when wxXRC_USE_LOCALE
 527         // is on, because it could break wxGetTranslation lookup.
 528         encoding = wxLocale::GetSystemEncodingName();
 529     }
 530 #endif
 531
 532     for ( wxXmlResourceDataRecords::iterator i = Data().begin();
 533           i != Data().end(); ++i )
 534     {
 535         wxXmlResourceDataRecord* const rec = *i;
 536
 537         modif = (rec->Doc == NULL);
 538
 539         if (!modif && !(m_flags & wxXRC_NO_RELOADING))
 540         {
 541 #           if wxUSE_FILESYSTEM
 542             file = fsys.OpenFile(rec->File);
 543 #           if wxUSE_DATETIME
 544             modif = file && file->GetModificationTime() > rec->Time;
 545 #           else // wxUSE_DATETIME
 546             modif = true;
 547 #           endif // wxUSE_DATETIME
 548             if (!file)
 549             {
 550                 wxLogError(_("Cannot open file '%s'."), rec->File);
 551                 rt = false;
 552             }
 553             wxDELETE(file);
 554             wxUnusedVar(file);
 555 #           else // wxUSE_FILESYSTEM
 556 #           if wxUSE_DATETIME
 557             modif = wxDateTime(wxFileModificationTime(rec->File)) > rec->Time;
 558 #           else // wxUSE_DATETIME
 559             modif = true;
 560 #           endif // wxUSE_DATETIME
 561 #           endif // wxUSE_FILESYSTEM
 562         }
 563
 564         if (modif)
 565         {
 566             wxLogTrace(_T("xrc"), _T("opening file '%s'"), rec->File);
 567
 568             wxInputStream *stream = NULL;
 569
 570 #           if wxUSE_FILESYSTEM
 571             file = fsys.OpenFile(rec->File);
 572             if (file)
 573                 stream = file->GetStream();
 574 #           else
 575             stream = new wxFileInputStream(rec->File);
 576 #           endif
 577
 578             if (stream)
 579             {
 580                 delete rec->Doc;
 581                 rec->Doc = new wxXmlDocument;
 582             }
 583             if (!stream || !stream->IsOk() || !rec->Doc->Load(*stream, encoding))
 584             {
 585                 wxLogError(_("Cannot load resources from file '%s'."),
 586                            rec->File);
 587                 wxDELETE(rec->Doc);
 588                 rt = false;
 589             }
 590             else if (rec->Doc->GetRoot()->GetName() != wxT("resource"))
 591             {
 592                 ReportError
 593                 (
 594                     rec->Doc->GetRoot(),
 595                     "invalid XRC resource, doesn't have root node <resource>"
 596                 );
 597                 wxDELETE(rec->Doc);
 598                 rt = false;
 599             }
 600             else
 601             {
 602                 long version;
 603                 int v1, v2, v3, v4;
 604                 wxString verstr = rec->Doc->GetRoot()->GetAttribute(
 605                                       wxT("version"), wxT("0.0.0.0"));
 606                 if (wxSscanf(verstr.c_str(), wxT("%i.%i.%i.%i"),
 607                     &v1, &v2, &v3, &v4) == 4)
 608                     version = v1*256*256*256+v2*256*256+v3*256+v4;
 609                 else
 610                     version = 0;
 611                 if (m_version == -1)
 612                     m_version = version;
 613                 if (m_version != version)
 614                 {
 615                     wxLogError("Resource files must have same version number.");
 616                     rt = false;
 617                 }
 618
 619                 ProcessPlatformProperty(rec->Doc->GetRoot());
 620 #if wxUSE_DATETIME
 621 #if wxUSE_FILESYSTEM
 622                 rec->Time = file->GetModificationTime();
 623 #else // wxUSE_FILESYSTEM
 624                 rec->Time = wxDateTime(wxFileModificationTime(rec->File));
 625 #endif // wxUSE_FILESYSTEM
 626 #endif // wxUSE_DATETIME
 627             }
 628
 629 #           if wxUSE_FILESYSTEM
 630                 wxDELETE(file);
 631                 wxUnusedVar(file);
 632 #           else
 633                 wxDELETE(stream);
 634 #           endif
 635         }
 636     }
 637
 638     return rt;
 639 }
 640
 641 wxXmlNode *wxXmlResource::DoFindResource(wxXmlNode *parent,
 642                                          const wxString& name,
 643                                          const wxString& classname,
 644                                          bool recursive) const
 645 {
 646     wxXmlNode *node;
 647
 648     // first search for match at the top-level nodes (as this is
 649     // where the resource is most commonly looked for):
 650     for (node = parent->GetChildren(); node; node = node->GetNext())
 651     {
 652         if ( IsObjectNode(node) && node->GetAttribute(wxS("name")) == name )
 653         {
 654             // empty class name matches everything
 655             if ( classname.empty() )
 656                 return node;
 657
 658             wxString cls(node->GetAttribute(wxS("class")));
 659
 660             // object_ref may not have 'class' attribute:
 661             if (cls.empty() && node->GetName() == wxS("object_ref"))
 662             {
 663                 wxString refName = node->GetAttribute(wxS("ref"));
 664                 if (refName.empty())
 665                     continue;
 666
 667                 const wxXmlNode * const refNode = GetResourceNode(refName);
 668                 if ( refNode )
 669                     cls = refNode->GetAttribute(wxS("class"));
 670             }
 671
 672             if ( cls == classname )
 673                 return node;
 674         }
 675     }
 676
 677     // then recurse in child nodes
 678     if ( recursive )
 679     {
 680         for (node = parent->GetChildren(); node; node = node->GetNext())
 681         {
 682             if ( IsObjectNode(node) )
 683             {
 684                 wxXmlNode* found = DoFindResource(node, name, classname, true);
 685                 if ( found )
 686                     return found;
 687             }
 688         }
 689     }
 690
 691     return NULL;
 692 }
 693
 694 wxXmlNode *wxXmlResource::FindResource(const wxString& name,
 695                                        const wxString& classname,
 696                                        bool recursive)
 697 {
 698     wxString path;
 699     wxXmlNode * const
 700         node = GetResourceNodeAndLocation(name, classname, recursive, &path);
 701
 702     if ( !node )
 703     {
 704         ReportError
 705         (
 706             NULL,
 707             wxString::Format
 708             (
 709                 "XRC resource \"%s\" (class \"%s\") not found",
 710                 name, classname
 711             )
 712         );
 713     }
 714 #if wxUSE_FILESYSTEM
 715     else // node was found
 716     {
 717         // ensure that relative paths work correctly when loading this node
 718         // (which should happen as soon as we return as FindResource() result
 719         // is always passed to CreateResFromNode())
 720         m_curFileSystem.ChangePathTo(path);
 721     }
 722 #endif // wxUSE_FILESYSTEM
 723
 724     return node;
 725 }
 726
 727 wxXmlNode *
 728 wxXmlResource::GetResourceNodeAndLocation(const wxString& name,
 729                                           const wxString& classname,
 730                                           bool recursive,
 731                                           wxString *path) const
 732 {
 733     // ensure everything is up-to-date: this is needed to support on-remand
 734     // reloading of XRC files
 735     const_cast<wxXmlResource *>(this)->UpdateResources();
 736
 737     for ( wxXmlResourceDataRecords::const_iterator f = Data().begin();
 738           f != Data().end(); ++f )
 739     {
 740         wxXmlResourceDataRecord *const rec = *f;
 741         wxXmlDocument * const doc = rec->Doc;
 742         if ( !doc || !doc->GetRoot() )
 743             continue;
 744
 745         wxXmlNode * const
 746             found = DoFindResource(doc->GetRoot(), name, classname, recursive);
 747         if ( found )
 748         {
 749             if ( path )
 750                 *path = rec->File;
 751
 752             return found;
 753         }
 754     }
 755
 756     return NULL;
 757 }
 758
 759 static void MergeNodesOver(wxXmlNode& dest, wxXmlNode& overwriteWith,
 760                            const wxString& overwriteFilename)
 761 {
 762     // Merge attributes:
 763     for ( wxXmlAttribute *attr = overwriteWith.GetAttributes();
 764           attr; attr = attr->GetNext() )
 765     {
 766         wxXmlAttribute *dattr;
 767         for (dattr = dest.GetAttributes(); dattr; dattr = dattr->GetNext())
 768         {
 769
 770             if ( dattr->GetName() == attr->GetName() )
 771             {
 772                 dattr->SetValue(attr->GetValue());
 773                 break;
 774             }
 775         }
 776
 777         if ( !dattr )
 778             dest.AddAttribute(attr->GetName(), attr->GetValue());
 779    }
 780
 781     // Merge child nodes:
 782     for (wxXmlNode* node = overwriteWith.GetChildren(); node; node = node->GetNext())
 783     {
 784         wxString name = node->GetAttribute(wxT("name"), wxEmptyString);
 785         wxXmlNode *dnode;
 786
 787         for (dnode = dest.GetChildren(); dnode; dnode = dnode->GetNext() )
 788         {
 789             if ( dnode->GetName() == node->GetName() &&
 790                  dnode->GetAttribute(wxT("name"), wxEmptyString) == name &&
 791                  dnode->GetType() == node->GetType() )
 792             {
 793                 MergeNodesOver(*dnode, *node, overwriteFilename);
 794                 break;
 795             }
 796         }
 797
 798         if ( !dnode )
 799         {
 800             wxXmlNode *copyOfNode = new wxXmlNode(*node);
 801             // remember referenced object's file, see GetFileNameFromNode()
 802             copyOfNode->AddAttribute(ATTR_INPUT_FILENAME, overwriteFilename);
 803
 804             static const wxChar *AT_END = wxT("end");
 805             wxString insert_pos = node->GetAttribute(wxT("insert_at"), AT_END);
 806             if ( insert_pos == AT_END )
 807             {
 808                 dest.AddChild(copyOfNode);
 809             }
 810             else if ( insert_pos == wxT("begin") )
 811             {
 812                 dest.InsertChild(copyOfNode, dest.GetChildren());
 813             }
 814         }
 815     }
 816
 817     if ( dest.GetType() == wxXML_TEXT_NODE && overwriteWith.GetContent().length() )
 818          dest.SetContent(overwriteWith.GetContent());
 819 }
 820
 821 wxObject *wxXmlResource::CreateResFromNode(wxXmlNode *node, wxObject *parent,
 822                                            wxObject *instance,
 823                                            wxXmlResourceHandler *handlerToUse)
 824 {
 825     if (node == NULL) return NULL;
 826
 827     // handling of referenced resource
 828     if ( node->GetName() == wxT("object_ref") )
 829     {
 830         wxString refName = node->GetAttribute(wxT("ref"), wxEmptyString);
 831         wxXmlNode* refNode = FindResource(refName, wxEmptyString, true);
 832
 833         if ( !refNode )
 834         {
 835             ReportError
 836             (
 837                 node,
 838                 wxString::Format
 839                 (
 840                     "referenced object node with ref=\"%s\" not found",
 841                     refName
 842                 )
 843             );
 844             return NULL;
 845         }
 846
 847         if ( !node->GetChildren() )
 848         {
 849             // In the typical, simple case, <object_ref> is used to link
 850             // to another node and doesn't have any content of its own that
 851             // would overwrite linked object's properties. In this case,
 852             // we can simply create the resource from linked node.
 853
 854             return CreateResFromNode(refNode, parent, instance);
 855         }
 856         else
 857         {
 858             // In the more complicated (but rare) case, <object_ref> has
 859             // subnodes that partially overwrite content of the referenced
 860             // object. In this case, we need to merge both XML trees and
 861             // load the resource from result of the merge.
 862
 863             wxXmlNode copy(*refNode);
 864             MergeNodesOver(copy, *node, GetFileNameFromNode(node, Data()));
 865
 866             // remember referenced object's file, see GetFileNameFromNode()
 867             copy.AddAttribute(ATTR_INPUT_FILENAME,
 868                               GetFileNameFromNode(refNode, Data()));
 869
 870             return CreateResFromNode(&copy, parent, instance);
 871         }
 872     }
 873
 874     if (handlerToUse)
 875     {
 876         if (handlerToUse->CanHandle(node))
 877         {
 878             return handlerToUse->CreateResource(node, parent, instance);
 879         }
 880     }
 881     else if (node->GetName() == wxT("object"))
 882     {
 883         for ( wxVector<wxXmlResourceHandler*>::iterator h = m_handlers.begin();
 884               h != m_handlers.end(); ++h )
 885         {
 886             wxXmlResourceHandler *handler = *h;
 887             if (handler->CanHandle(node))
 888                 return handler->CreateResource(node, parent, instance);
 889         }
 890     }
 891
 892     ReportError
 893     (
 894         node,
 895         wxString::Format
 896         (
 897             "no handler found for XML node \"%s\" (class \"%s\")",
 898             node->GetName(),
 899             node->GetAttribute("class", wxEmptyString)
 900         )
 901     );
 902     return NULL;
 903 }
 904
 905
 906 class wxXmlSubclassFactories : public wxVector<wxXmlSubclassFactory*>
 907 {
 908     // this is a class so that it can be forward-declared
 909 };
 910
 911 wxXmlSubclassFactories *wxXmlResource::ms_subclassFactories = NULL;
 912
 913 /*static*/ void wxXmlResource::AddSubclassFactory(wxXmlSubclassFactory *factory)
 914 {
 915     if (!ms_subclassFactories)
 916     {
 917         ms_subclassFactories = new wxXmlSubclassFactories;
 918     }
 919     ms_subclassFactories->push_back(factory);
 920 }
 921
 922 class wxXmlSubclassFactoryCXX : public wxXmlSubclassFactory
 923 {
 924 public:
 925     ~wxXmlSubclassFactoryCXX() {}
 926
 927     wxObject *Create(const wxString& className)
 928     {
 929         wxClassInfo* classInfo = wxClassInfo::FindClass(className);
 930
 931         if (classInfo)
 932             return classInfo->CreateObject();
 933         else
 934             return NULL;
 935     }
 936 };
 937
 938
 939
 940
 941 wxXmlResourceHandler::wxXmlResourceHandler()
 942         : m_node(NULL), m_parent(NULL), m_instance(NULL),
 943           m_parentAsWindow(NULL)
 944 {}
 945
 946
 947
 948 wxObject *wxXmlResourceHandler::CreateResource(wxXmlNode *node, wxObject *parent, wxObject *instance)
 949 {
 950     wxXmlNode *myNode = m_node;
 951     wxString myClass = m_class;
 952     wxObject *myParent = m_parent, *myInstance = m_instance;
 953     wxWindow *myParentAW = m_parentAsWindow;
 954
 955     m_instance = instance;
 956     if (!m_instance && node->HasAttribute(wxT("subclass")) &&
 957         !(m_resource->GetFlags() & wxXRC_NO_SUBCLASSING))
 958     {
 959         wxString subclass = node->GetAttribute(wxT("subclass"), wxEmptyString);
 960         if (!subclass.empty())
 961         {
 962             for (wxXmlSubclassFactories::iterator i = wxXmlResource::ms_subclassFactories->begin();
 963                  i != wxXmlResource::ms_subclassFactories->end(); ++i)
 964             {
 965                 m_instance = (*i)->Create(subclass);
 966                 if (m_instance)
 967                     break;
 968             }
 969
 970             if (!m_instance)
 971             {
 972                 wxString name = node->GetAttribute(wxT("name"), wxEmptyString);
 973                 ReportError
 974                 (
 975                     node,
 976                     wxString::Format
 977                     (
 978                         "subclass \"%s\" not found for resource \"%s\", not subclassing",
 979                         subclass, name
 980                     )
 981                 );
 982             }
 983         }
 984     }
 985
 986     m_node = node;
 987     m_class = node->GetAttribute(wxT("class"), wxEmptyString);
 988     m_parent = parent;
 989     m_parentAsWindow = wxDynamicCast(m_parent, wxWindow);
 990
 991     wxObject *returned = DoCreateResource();
 992
 993     m_node = myNode;
 994     m_class = myClass;
 995     m_parent = myParent; m_parentAsWindow = myParentAW;
 996     m_instance = myInstance;
 997
 998     return returned;
 999 }
1000
1001
1002 void wxXmlResourceHandler::AddStyle(const wxString& name, int value)
1003 {
1004     m_styleNames.Add(name);
1005     m_styleValues.Add(value);
1006 }
1007
1008
1009
1010 void wxXmlResourceHandler::AddWindowStyles()
1011 {
1012     XRC_ADD_STYLE(wxCLIP_CHILDREN);
1013
1014     // the border styles all have the old and new names, recognize both for now
1015     XRC_ADD_STYLE(wxSIMPLE_BORDER); XRC_ADD_STYLE(wxBORDER_SIMPLE);
1016     XRC_ADD_STYLE(wxSUNKEN_BORDER); XRC_ADD_STYLE(wxBORDER_SUNKEN);
1017     XRC_ADD_STYLE(wxDOUBLE_BORDER); XRC_ADD_STYLE(wxBORDER_DOUBLE);
1018     XRC_ADD_STYLE(wxRAISED_BORDER); XRC_ADD_STYLE(wxBORDER_RAISED);
1019     XRC_ADD_STYLE(wxSTATIC_BORDER); XRC_ADD_STYLE(wxBORDER_STATIC);
1020     XRC_ADD_STYLE(wxNO_BORDER);     XRC_ADD_STYLE(wxBORDER_NONE);
1021
1022     XRC_ADD_STYLE(wxTRANSPARENT_WINDOW);
1023     XRC_ADD_STYLE(wxWANTS_CHARS);
1024     XRC_ADD_STYLE(wxTAB_TRAVERSAL);
1025     XRC_ADD_STYLE(wxNO_FULL_REPAINT_ON_RESIZE);
1026     XRC_ADD_STYLE(wxFULL_REPAINT_ON_RESIZE);
1027     XRC_ADD_STYLE(wxALWAYS_SHOW_SB);
1028     XRC_ADD_STYLE(wxWS_EX_BLOCK_EVENTS);
1029     XRC_ADD_STYLE(wxWS_EX_VALIDATE_RECURSIVELY);
1030 }
1031
1032
1033
1034 bool wxXmlResourceHandler::HasParam(const wxString& param)
1035 {
1036     return (GetParamNode(param) != NULL);
1037 }
1038
1039
1040 int wxXmlResourceHandler::GetStyle(const wxString& param, int defaults)
1041 {
1042     wxString s = GetParamValue(param);
1043
1044     if (!s) return defaults;
1045
1046     wxStringTokenizer tkn(s, wxT("| \t\n"), wxTOKEN_STRTOK);
1047     int style = 0;
1048     int index;
1049     wxString fl;
1050     while (tkn.HasMoreTokens())
1051     {
1052         fl = tkn.GetNextToken();
1053         index = m_styleNames.Index(fl);
1054         if (index != wxNOT_FOUND)
1055         {
1056             style |= m_styleValues[index];
1057         }
1058         else
1059         {
1060             ReportParamError
1061             (
1062                 param,
1063                 wxString::Format("unknown style flag \"%s\"", fl)
1064             );
1065         }
1066     }
1067     return style;
1068 }
1069
1070
1071
1072 wxString wxXmlResourceHandler::GetText(const wxString& param, bool translate)
1073 {
1074     wxXmlNode *parNode = GetParamNode(param);
1075     wxString str1(GetNodeContent(parNode));
1076     wxString str2;
1077
1078     // "\\" wasn't translated to "\" prior to 2.5.3.0:
1079     const bool escapeBackslash = (m_resource->CompareVersion(2,5,3,0) >= 0);
1080
1081     // VS: First version of XRC resources used $ instead of & (which is
1082     //     illegal in XML), but later I realized that '_' fits this purpose
1083     //     much better (because &File means "File with F underlined").
1084     const wxChar amp_char = (m_resource->CompareVersion(2,3,0,1) < 0)
1085                             ? '$' : '_';
1086
1087     for ( wxString::const_iterator dt = str1.begin(); dt != str1.end(); ++dt )
1088     {
1089         // Remap amp_char to &, map double amp_char to amp_char (for things
1090         // like "&File..." -- this is illegal in XML, so we use "_File..."):
1091         if ( *dt == amp_char )
1092         {
1093             if ( *(++dt) == amp_char )
1094                 str2 << amp_char;
1095             else
1096                 str2 << wxT('&') << *dt;
1097         }
1098         // Remap \n to CR, \r to LF, \t to TAB, \\ to \:
1099         else if ( *dt == wxT('\\') )
1100         {
1101             switch ( (*(++dt)).GetValue() )
1102             {
1103                 case wxT('n'):
1104                     str2 << wxT('\n');
1105                     break;
1106
1107                 case wxT('t'):
1108                     str2 << wxT('\t');
1109                     break;
1110
1111                 case wxT('r'):
1112                     str2 << wxT('\r');
1113                     break;
1114
1115                 case wxT('\\') :
1116                     // "\\" wasn't translated to "\" prior to 2.5.3.0:
1117                     if ( escapeBackslash )
1118                     {
1119                         str2 << wxT('\\');
1120                         break;
1121                     }
1122                     // else fall-through to default: branch below
1123
1124                 default:
1125                     str2 << wxT('\\') << *dt;
1126                     break;
1127             }
1128         }
1129         else
1130         {
1131             str2 << *dt;
1132         }
1133     }
1134
1135     if (m_resource->GetFlags() & wxXRC_USE_LOCALE)
1136     {
1137         if (translate && parNode &&
1138             parNode->GetAttribute(wxT("translate"), wxEmptyString) != wxT("0"))
1139         {
1140             return wxGetTranslation(str2, m_resource->GetDomain());
1141         }
1142         else
1143         {
1144 #if wxUSE_UNICODE
1145             return str2;
1146 #else
1147             // The string is internally stored as UTF-8, we have to convert
1148             // it into system's default encoding so that it can be displayed:
1149             return wxString(str2.wc_str(wxConvUTF8), wxConvLocal);
1150 #endif
1151         }
1152     }
1153
1154     // If wxXRC_USE_LOCALE is not set, then the string is already in
1155     // system's default encoding in ANSI build, so we don't have to
1156     // do anything special here.
1157     return str2;
1158 }
1159
1160
1161
1162 long wxXmlResourceHandler::GetLong(const wxString& param, long defaultv)
1163 {
1164     long value;
1165     wxString str1 = GetParamValue(param);
1166
1167     if (!str1.ToLong(&value))
1168         value = defaultv;
1169
1170     return value;
1171 }
1172
1173 float wxXmlResourceHandler::GetFloat(const wxString& param, float defaultv)
1174 {
1175     wxString str = GetParamValue(param);
1176
1177 #if wxUSE_INTL
1178     // strings in XRC always use C locale but wxString::ToDouble() uses the
1179     // current one, so transform the string to it supposing that the only
1180     // difference between them is the decimal separator
1181     //
1182     // TODO: use wxString::ToCDouble() when we have it
1183     str.Replace(wxT("."), wxLocale::GetInfo(wxLOCALE_DECIMAL_POINT,
1184                                             wxLOCALE_CAT_NUMBER));
1185 #endif // wxUSE_INTL
1186
1187     double value;
1188     if (!str.ToDouble(&value))
1189         value = defaultv;
1190
1191     return wx_truncate_cast(float, value);
1192 }
1193
1194
1195 int wxXmlResourceHandler::GetID()
1196 {
1197     return wxXmlResource::GetXRCID(GetName());
1198 }
1199
1200
1201
1202 wxString wxXmlResourceHandler::GetName()
1203 {
1204     return m_node->GetAttribute(wxT("name"), wxT("-1"));
1205 }
1206
1207
1208
1209 bool wxXmlResourceHandler::GetBoolAttr(const wxString& attr, bool defaultv)
1210 {
1211     wxString v;
1212     return m_node->GetAttribute(attr, &v) ? v == '1' : defaultv;
1213 }
1214
1215 bool wxXmlResourceHandler::GetBool(const wxString& param, bool defaultv)
1216 {
1217     const wxString v = GetParamValue(param);
1218
1219     return v.empty() ? defaultv : (v == '1');
1220 }
1221
1222
1223 static wxColour GetSystemColour(const wxString& name)
1224 {
1225     if (!name.empty())
1226     {
1227         #define SYSCLR(clr) \
1228             if (name == _T(#clr)) return wxSystemSettings::GetColour(clr);
1229         SYSCLR(wxSYS_COLOUR_SCROLLBAR)
1230         SYSCLR(wxSYS_COLOUR_BACKGROUND)
1231         SYSCLR(wxSYS_COLOUR_DESKTOP)
1232         SYSCLR(wxSYS_COLOUR_ACTIVECAPTION)
1233         SYSCLR(wxSYS_COLOUR_INACTIVECAPTION)
1234         SYSCLR(wxSYS_COLOUR_MENU)
1235         SYSCLR(wxSYS_COLOUR_WINDOW)
1236         SYSCLR(wxSYS_COLOUR_WINDOWFRAME)
1237         SYSCLR(wxSYS_COLOUR_MENUTEXT)
1238         SYSCLR(wxSYS_COLOUR_WINDOWTEXT)
1239         SYSCLR(wxSYS_COLOUR_CAPTIONTEXT)
1240         SYSCLR(wxSYS_COLOUR_ACTIVEBORDER)
1241         SYSCLR(wxSYS_COLOUR_INACTIVEBORDER)
1242         SYSCLR(wxSYS_COLOUR_APPWORKSPACE)
1243         SYSCLR(wxSYS_COLOUR_HIGHLIGHT)
1244         SYSCLR(wxSYS_COLOUR_HIGHLIGHTTEXT)
1245         SYSCLR(wxSYS_COLOUR_BTNFACE)
1246         SYSCLR(wxSYS_COLOUR_3DFACE)
1247         SYSCLR(wxSYS_COLOUR_BTNSHADOW)
1248         SYSCLR(wxSYS_COLOUR_3DSHADOW)
1249         SYSCLR(wxSYS_COLOUR_GRAYTEXT)
1250         SYSCLR(wxSYS_COLOUR_BTNTEXT)
1251         SYSCLR(wxSYS_COLOUR_INACTIVECAPTIONTEXT)
1252         SYSCLR(wxSYS_COLOUR_BTNHIGHLIGHT)
1253         SYSCLR(wxSYS_COLOUR_BTNHILIGHT)
1254         SYSCLR(wxSYS_COLOUR_3DHIGHLIGHT)
1255         SYSCLR(wxSYS_COLOUR_3DHILIGHT)
1256         SYSCLR(wxSYS_COLOUR_3DDKSHADOW)
1257         SYSCLR(wxSYS_COLOUR_3DLIGHT)
1258         SYSCLR(wxSYS_COLOUR_INFOTEXT)
1259         SYSCLR(wxSYS_COLOUR_INFOBK)
1260         SYSCLR(wxSYS_COLOUR_LISTBOX)
1261         SYSCLR(wxSYS_COLOUR_HOTLIGHT)
1262         SYSCLR(wxSYS_COLOUR_GRADIENTACTIVECAPTION)
1263         SYSCLR(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)
1264         SYSCLR(wxSYS_COLOUR_MENUHILIGHT)
1265         SYSCLR(wxSYS_COLOUR_MENUBAR)
1266         #undef SYSCLR
1267     }
1268
1269     return wxNullColour;
1270 }
1271
1272 wxColour wxXmlResourceHandler::GetColour(const wxString& param, const wxColour& defaultv)
1273 {
1274     wxString v = GetParamValue(param);
1275
1276     if ( v.empty() )
1277         return defaultv;
1278
1279     wxColour clr;
1280
1281     // wxString -> wxColour conversion
1282     if (!clr.Set(v))
1283     {
1284         // the colour doesn't use #RRGGBB format, check if it is symbolic
1285         // colour name:
1286         clr = GetSystemColour(v);
1287         if (clr.Ok())
1288             return clr;
1289
1290         ReportParamError
1291         (
1292             param,
1293             wxString::Format("incorrect colour specification \"%s\"", v)
1294         );
1295         return wxNullColour;
1296     }
1297
1298     return clr;
1299 }
1300
1301 namespace
1302 {
1303
1304 // if 'param' has stock_id/stock_client, extracts them and returns true
1305 bool GetStockArtAttrs(const wxXmlNode *paramNode,
1306                       const wxString& defaultArtClient,
1307                       wxString& art_id, wxString& art_client)
1308 {
1309     if ( paramNode )
1310     {
1311         art_id = paramNode->GetAttribute("stock_id", "");
1312
1313         if ( !art_id.empty() )
1314         {
1315             art_id = wxART_MAKE_ART_ID_FROM_STR(art_id);
1316
1317             art_client = paramNode->GetAttribute("stock_client", "");
1318             if ( art_client.empty() )
1319                 art_client = defaultArtClient;
1320             else
1321                 art_client = wxART_MAKE_CLIENT_ID_FROM_STR(art_client);
1322
1323             return true;
1324         }
1325     }
1326
1327     return false;
1328 }
1329
1330 } // anonymous namespace
1331
1332 wxBitmap wxXmlResourceHandler::GetBitmap(const wxString& param,
1333                                          const wxArtClient& defaultArtClient,
1334                                          wxSize size)
1335 {
1336     /* If the bitmap is specified as stock item, query wxArtProvider for it: */
1337     wxString art_id, art_client;
1338     if ( GetStockArtAttrs(GetParamNode(param), defaultArtClient,
1339                           art_id, art_client) )
1340     {
1341         wxBitmap stockArt(wxArtProvider::GetBitmap(art_id, art_client, size));
1342         if ( stockArt.Ok() )
1343             return stockArt;
1344     }
1345
1346     /* ...or load the bitmap from file: */
1347     wxString name = GetParamValue(param);
1348     if (name.empty()) return wxNullBitmap;
1349 #if wxUSE_FILESYSTEM
1350     wxFSFile *fsfile = GetCurFileSystem().OpenFile(name, wxFS_READ | wxFS_SEEKABLE);
1351     if (fsfile == NULL)
1352     {
1353         ReportParamError
1354         (
1355             param,
1356             wxString::Format("cannot open bitmap resource \"%s\"", name)
1357         );
1358         return wxNullBitmap;
1359     }
1360     wxImage img(*(fsfile->GetStream()));
1361     delete fsfile;
1362 #else
1363     wxImage img(name);
1364 #endif
1365
1366     if (!img.Ok())
1367     {
1368         ReportParamError
1369         (
1370             param,
1371             wxString::Format("cannot create bitmap from \"%s\"", name)
1372         );
1373         return wxNullBitmap;
1374     }
1375     if (!(size == wxDefaultSize)) img.Rescale(size.x, size.y);
1376     return wxBitmap(img);
1377 }
1378
1379
1380 wxIcon wxXmlResourceHandler::GetIcon(const wxString& param,
1381                                      const wxArtClient& defaultArtClient,
1382                                      wxSize size)
1383 {
1384     wxIcon icon;
1385     icon.CopyFromBitmap(GetBitmap(param, defaultArtClient, size));
1386     return icon;
1387 }
1388
1389 wxIconBundle wxXmlResourceHandler::GetIconBundle(const wxString& param,
1390                                                  const wxArtClient& defaultArtClient)
1391 {
1392     wxString art_id, art_client;
1393     if ( GetStockArtAttrs(GetParamNode(param), defaultArtClient,
1394                           art_id, art_client) )
1395     {
1396         wxIconBundle stockArt(wxArtProvider::GetIconBundle(art_id, art_client));
1397         if ( stockArt.IsOk() )
1398             return stockArt;
1399     }
1400
1401     const wxString name = GetParamValue(param);
1402     if ( name.empty() )
1403         return wxNullIconBundle;
1404
1405 #if wxUSE_FILESYSTEM
1406     wxFSFile *fsfile = GetCurFileSystem().OpenFile(name, wxFS_READ | wxFS_SEEKABLE);
1407     if ( fsfile == NULL )
1408     {
1409         ReportParamError
1410         (
1411             param,
1412             wxString::Format("cannot open icon resource \"%s\"", name)
1413         );
1414         return wxNullIconBundle;
1415     }
1416
1417     wxIconBundle bundle(*(fsfile->GetStream()));
1418     delete fsfile;
1419 #else
1420     wxIconBundle bundle(name);
1421 #endif
1422
1423     if ( !bundle.IsOk() )
1424     {
1425         ReportParamError
1426         (
1427             param,
1428             wxString::Format("cannot create icon from \"%s\"", name)
1429         );
1430         return wxNullIconBundle;
1431     }
1432
1433     return bundle;
1434 }
1435
1436
1437 wxXmlNode *wxXmlResourceHandler::GetParamNode(const wxString& param)
1438 {
1439     wxCHECK_MSG(m_node, NULL, wxT("You can't access handler data before it was initialized!"));
1440
1441     wxXmlNode *n = m_node->GetChildren();
1442
1443     while (n)
1444     {
1445         if (n->GetType() == wxXML_ELEMENT_NODE && n->GetName() == param)
1446         {
1447             // TODO: check that there are no other properties/parameters with
1448             //       the same name and log an error if there are (can't do this
1449             //       right now as I'm not sure if it's not going to break code
1450             //       using this function in unintentional way (i.e. for
1451             //       accessing other things than properties), for example
1452             //       wxBitmapComboBoxXmlHandler almost surely does
1453             return n;
1454         }
1455         n = n->GetNext();
1456     }
1457     return NULL;
1458 }
1459
1460 bool wxXmlResourceHandler::IsOfClass(wxXmlNode *node, const wxString& classname)
1461 {
1462     return node->GetAttribute(wxT("class"), wxEmptyString) == classname;
1463 }
1464
1465
1466
1467 wxString wxXmlResourceHandler::GetNodeContent(wxXmlNode *node)
1468 {
1469     wxXmlNode *n = node;
1470     if (n == NULL) return wxEmptyString;
1471     n = n->GetChildren();
1472
1473     while (n)
1474     {
1475         if (n->GetType() == wxXML_TEXT_NODE ||
1476             n->GetType() == wxXML_CDATA_SECTION_NODE)
1477             return n->GetContent();
1478         n = n->GetNext();
1479     }
1480     return wxEmptyString;
1481 }
1482
1483
1484
1485 wxString wxXmlResourceHandler::GetParamValue(const wxString& param)
1486 {
1487     if (param.empty())
1488         return GetNodeContent(m_node);
1489     else
1490         return GetNodeContent(GetParamNode(param));
1491 }
1492
1493
1494
1495 wxSize wxXmlResourceHandler::GetSize(const wxString& param,
1496                                      wxWindow *windowToUse)
1497 {
1498     wxString s = GetParamValue(param);
1499     if (s.empty()) s = wxT("-1,-1");
1500     bool is_dlg;
1501     long sx, sy = 0;
1502
1503     is_dlg = s[s.length()-1] == wxT('d');
1504     if (is_dlg) s.RemoveLast();
1505
1506     if (!s.BeforeFirst(wxT(',')).ToLong(&sx) ||
1507         !s.AfterLast(wxT(',')).ToLong(&sy))
1508     {
1509         ReportParamError
1510         (
1511             param,
1512             wxString::Format("cannot parse coordinates value \"%s\"", s)
1513         );
1514         return wxDefaultSize;
1515     }
1516
1517     if (is_dlg)
1518     {
1519         if (windowToUse)
1520         {
1521             return wxDLG_UNIT(windowToUse, wxSize(sx, sy));
1522         }
1523         else if (m_parentAsWindow)
1524         {
1525             return wxDLG_UNIT(m_parentAsWindow, wxSize(sx, sy));
1526         }
1527         else
1528         {
1529             ReportParamError
1530             (
1531                 param,
1532                 "cannot convert dialog units: dialog unknown"
1533             );
1534             return wxDefaultSize;
1535         }
1536     }
1537
1538     return wxSize(sx, sy);
1539 }
1540
1541
1542
1543 wxPoint wxXmlResourceHandler::GetPosition(const wxString& param)
1544 {
1545     wxSize sz = GetSize(param);
1546     return wxPoint(sz.x, sz.y);
1547 }
1548
1549
1550
1551 wxCoord wxXmlResourceHandler::GetDimension(const wxString& param,
1552                                            wxCoord defaultv,
1553                                            wxWindow *windowToUse)
1554 {
1555     wxString s = GetParamValue(param);
1556     if (s.empty()) return defaultv;
1557     bool is_dlg;
1558     long sx;
1559
1560     is_dlg = s[s.length()-1] == wxT('d');
1561     if (is_dlg) s.RemoveLast();
1562
1563     if (!s.ToLong(&sx))
1564     {
1565         ReportParamError
1566         (
1567             param,
1568             wxString::Format("cannot parse dimension value \"%s\"", s)
1569         );
1570         return defaultv;
1571     }
1572
1573     if (is_dlg)
1574     {
1575         if (windowToUse)
1576         {
1577             return wxDLG_UNIT(windowToUse, wxSize(sx, 0)).x;
1578         }
1579         else if (m_parentAsWindow)
1580         {
1581             return wxDLG_UNIT(m_parentAsWindow, wxSize(sx, 0)).x;
1582         }
1583         else
1584         {
1585             ReportParamError
1586             (
1587                 param,
1588                 "cannot convert dialog units: dialog unknown"
1589             );
1590             return defaultv;
1591         }
1592     }
1593
1594     return sx;
1595 }
1596
1597
1598 // Get system font index using indexname
1599 static wxFont GetSystemFont(const wxString& name)
1600 {
1601     if (!name.empty())
1602     {
1603         #define SYSFNT(fnt) \
1604             if (name == _T(#fnt)) return wxSystemSettings::GetFont(fnt);
1605         SYSFNT(wxSYS_OEM_FIXED_FONT)
1606         SYSFNT(wxSYS_ANSI_FIXED_FONT)
1607         SYSFNT(wxSYS_ANSI_VAR_FONT)
1608         SYSFNT(wxSYS_SYSTEM_FONT)
1609         SYSFNT(wxSYS_DEVICE_DEFAULT_FONT)
1610         SYSFNT(wxSYS_SYSTEM_FIXED_FONT)
1611         SYSFNT(wxSYS_DEFAULT_GUI_FONT)
1612         #undef SYSFNT
1613     }
1614
1615     return wxNullFont;
1616 }
1617
1618 wxFont wxXmlResourceHandler::GetFont(const wxString& param)
1619 {
1620     wxXmlNode *font_node = GetParamNode(param);
1621     if (font_node == NULL)
1622     {
1623         ReportError(
1624             wxString::Format("cannot find font node \"%s\"", param));
1625         return wxNullFont;
1626     }
1627
1628     wxXmlNode *oldnode = m_node;
1629     m_node = font_node;
1630
1631     // font attributes:
1632
1633     // size
1634     int isize = -1;
1635     bool hasSize = HasParam(wxT("size"));
1636     if (hasSize)
1637         isize = GetLong(wxT("size"), -1);
1638
1639     // style
1640     int istyle = wxNORMAL;
1641     bool hasStyle = HasParam(wxT("style"));
1642     if (hasStyle)
1643     {
1644         wxString style = GetParamValue(wxT("style"));
1645         if (style == wxT("italic"))
1646             istyle = wxITALIC;
1647         else if (style == wxT("slant"))
1648             istyle = wxSLANT;
1649     }
1650
1651     // weight
1652     int iweight = wxNORMAL;
1653     bool hasWeight = HasParam(wxT("weight"));
1654     if (hasWeight)
1655     {
1656         wxString weight = GetParamValue(wxT("weight"));
1657         if (weight == wxT("bold"))
1658             iweight = wxBOLD;
1659         else if (weight == wxT("light"))
1660             iweight = wxLIGHT;
1661     }
1662
1663     // underline
1664     bool hasUnderlined = HasParam(wxT("underlined"));
1665     bool underlined = hasUnderlined ? GetBool(wxT("underlined"), false) : false;
1666
1667     // family and facename
1668     int ifamily = wxDEFAULT;
1669     bool hasFamily = HasParam(wxT("family"));
1670     if (hasFamily)
1671     {
1672         wxString family = GetParamValue(wxT("family"));
1673              if (family == wxT("decorative")) ifamily = wxDECORATIVE;
1674         else if (family == wxT("roman")) ifamily = wxROMAN;
1675         else if (family == wxT("script")) ifamily = wxSCRIPT;
1676         else if (family == wxT("swiss")) ifamily = wxSWISS;
1677         else if (family == wxT("modern")) ifamily = wxMODERN;
1678         else if (family == wxT("teletype")) ifamily = wxTELETYPE;
1679     }
1680
1681
1682     wxString facename;
1683     bool hasFacename = HasParam(wxT("face"));
1684     if (hasFacename)
1685     {
1686         wxString faces = GetParamValue(wxT("face"));
1687         wxStringTokenizer tk(faces, wxT(","));
1688 #if wxUSE_FONTENUM
1689         wxArrayString facenames(wxFontEnumerator::GetFacenames());
1690         while (tk.HasMoreTokens())
1691         {
1692             int index = facenames.Index(tk.GetNextToken(), false);
1693             if (index != wxNOT_FOUND)
1694             {
1695                 facename = facenames[index];
1696                 break;
1697             }
1698         }
1699 #else // !wxUSE_FONTENUM
1700         // just use the first face name if we can't check its availability:
1701         if (tk.HasMoreTokens())
1702             facename = tk.GetNextToken();
1703 #endif // wxUSE_FONTENUM/!wxUSE_FONTENUM
1704     }
1705
1706     // encoding
1707     wxFontEncoding enc = wxFONTENCODING_DEFAULT;
1708     bool hasEncoding = HasParam(wxT("encoding"));
1709     if (hasEncoding)
1710     {
1711         wxString encoding = GetParamValue(wxT("encoding"));
1712         wxFontMapper mapper;
1713         if (!encoding.empty())
1714             enc = mapper.CharsetToEncoding(encoding);
1715         if (enc == wxFONTENCODING_SYSTEM)
1716             enc = wxFONTENCODING_DEFAULT;
1717     }
1718
1719     // is this font based on a system font?
1720     wxFont font = GetSystemFont(GetParamValue(wxT("sysfont")));
1721
1722     if (font.Ok())
1723     {
1724         if (hasSize && isize != -1)
1725             font.SetPointSize(isize);
1726         else if (HasParam(wxT("relativesize")))
1727             font.SetPointSize(int(font.GetPointSize() *
1728                                      GetFloat(wxT("relativesize"))));
1729
1730         if (hasStyle)
1731             font.SetStyle(istyle);
1732         if (hasWeight)
1733             font.SetWeight(iweight);
1734         if (hasUnderlined)
1735             font.SetUnderlined(underlined);
1736         if (hasFamily)
1737             font.SetFamily(ifamily);
1738         if (hasFacename)
1739             font.SetFaceName(facename);
1740         if (hasEncoding)
1741             font.SetDefaultEncoding(enc);
1742     }
1743     else // not based on system font
1744     {
1745         font = wxFont(isize == -1 ? wxNORMAL_FONT->GetPointSize() : isize,
1746                       ifamily, istyle, iweight,
1747                       underlined, facename, enc);
1748     }
1749
1750     m_node = oldnode;
1751     return font;
1752 }
1753
1754
1755 void wxXmlResourceHandler::SetupWindow(wxWindow *wnd)
1756 {
1757     //FIXME : add cursor
1758
1759     if (HasParam(wxT("exstyle")))
1760         // Have to OR it with existing style, since
1761         // some implementations (e.g. wxGTK) use the extra style
1762         // during creation
1763         wnd->SetExtraStyle(wnd->GetExtraStyle() | GetStyle(wxT("exstyle")));
1764     if (HasParam(wxT("bg")))
1765         wnd->SetBackgroundColour(GetColour(wxT("bg")));
1766     if (HasParam(wxT("fg")))
1767         wnd->SetForegroundColour(GetColour(wxT("fg")));
1768     if (GetBool(wxT("enabled"), 1) == 0)
1769         wnd->Enable(false);
1770     if (GetBool(wxT("focused"), 0) == 1)
1771         wnd->SetFocus();
1772     if (GetBool(wxT("hidden"), 0) == 1)
1773         wnd->Show(false);
1774 #if wxUSE_TOOLTIPS
1775     if (HasParam(wxT("tooltip")))
1776         wnd->SetToolTip(GetText(wxT("tooltip")));
1777 #endif
1778     if (HasParam(wxT("font")))
1779         wnd->SetFont(GetFont());
1780     if (HasParam(wxT("help")))
1781         wnd->SetHelpText(GetText(wxT("help")));
1782 }
1783
1784
1785 void wxXmlResourceHandler::CreateChildren(wxObject *parent, bool this_hnd_only)
1786 {
1787     for ( wxXmlNode *n = m_node->GetChildren(); n; n = n->GetNext() )
1788     {
1789         if ( IsObjectNode(n) )
1790         {
1791             m_resource->CreateResFromNode(n, parent, NULL,
1792                                           this_hnd_only ? this : NULL);
1793         }
1794     }
1795 }
1796
1797
1798 void wxXmlResourceHandler::CreateChildrenPrivately(wxObject *parent, wxXmlNode *rootnode)
1799 {
1800     wxXmlNode *root;
1801     if (rootnode == NULL) root = m_node; else root = rootnode;
1802     wxXmlNode *n = root->GetChildren();
1803
1804     while (n)
1805     {
1806         if (n->GetType() == wxXML_ELEMENT_NODE && CanHandle(n))
1807         {
1808             CreateResource(n, parent, NULL);
1809         }
1810         n = n->GetNext();
1811     }
1812 }
1813
1814
1815 //-----------------------------------------------------------------------------
1816 // errors reporting
1817 //-----------------------------------------------------------------------------
1818
1819 void wxXmlResourceHandler::ReportError(const wxString& message)
1820 {
1821     m_resource->ReportError(m_node, message);
1822 }
1823
1824 void wxXmlResourceHandler::ReportError(wxXmlNode *context,
1825                                        const wxString& message)
1826 {
1827     m_resource->ReportError(context ? context : m_node, message);
1828 }
1829
1830 void wxXmlResourceHandler::ReportParamError(const wxString& param,
1831                                             const wxString& message)
1832 {
1833     m_resource->ReportError(GetParamNode(param), message);
1834 }
1835
1836 void wxXmlResource::ReportError(wxXmlNode *context, const wxString& message)
1837 {
1838     if ( !context )
1839     {
1840         DoReportError("", NULL, message);
1841         return;
1842     }
1843
1844     // We need to find out the file that 'context' is part of. Performance of
1845     // this code is not critical, so we simply find the root XML node and
1846     // compare it with all loaded XRC files.
1847     const wxString filename = GetFileNameFromNode(context, Data());
1848
1849     DoReportError(filename, context, message);
1850 }
1851
1852 void wxXmlResource::DoReportError(const wxString& xrcFile, wxXmlNode *position,
1853                                   const wxString& message)
1854 {
1855     const int line = position ? position->GetLineNumber() : -1;
1856
1857     wxString loc;
1858     if ( !xrcFile.empty() )
1859         loc = xrcFile + ':';
1860     if ( line != -1 )
1861         loc += wxString::Format("%d:", line);
1862     if ( !loc.empty() )
1863         loc += ' ';
1864
1865     wxLogError("XRC error: %s%s", loc, message);
1866 }
1867
1868
1869 //-----------------------------------------------------------------------------
1870 // XRCID implementation
1871 //-----------------------------------------------------------------------------
1872
1873 #define XRCID_TABLE_SIZE     1024
1874
1875
1876 struct XRCID_record
1877 {
1878     /* Hold the id so that once an id is allocated for a name, it
1879        does not get created again by NewControlId at least
1880        until we are done with it */
1881     wxWindowIDRef id;
1882     char *key;
1883     XRCID_record *next;
1884 };
1885
1886 static XRCID_record *XRCID_Records[XRCID_TABLE_SIZE] = {NULL};
1887
1888 static int XRCID_Lookup(const char *str_id, int value_if_not_found = wxID_NONE)
1889 {
1890     int index = 0;
1891
1892     for (const char *c = str_id; *c != '\0'; c++) index += (int)*c;
1893     index %= XRCID_TABLE_SIZE;
1894
1895     XRCID_record *oldrec = NULL;
1896     for (XRCID_record *rec = XRCID_Records[index]; rec; rec = rec->next)
1897     {
1898         if (wxStrcmp(rec->key, str_id) == 0)
1899         {
1900             return rec->id;
1901         }
1902         oldrec = rec;
1903     }
1904
1905     XRCID_record **rec_var = (oldrec == NULL) ?
1906                               &XRCID_Records[index] : &oldrec->next;
1907     *rec_var = new XRCID_record;
1908     (*rec_var)->key = wxStrdup(str_id);
1909     (*rec_var)->next = NULL;
1910
1911     char *end;
1912     if (value_if_not_found != wxID_NONE)
1913         (*rec_var)->id = value_if_not_found;
1914     else
1915     {
1916         int asint = wxStrtol(str_id, &end, 10);
1917         if (*str_id && *end == 0)
1918         {
1919             // if str_id was integer, keep it verbosely:
1920             (*rec_var)->id = asint;
1921         }
1922         else
1923         {
1924             (*rec_var)->id = wxWindowBase::NewControlId();
1925         }
1926     }
1927
1928     return (*rec_var)->id;
1929 }
1930
1931 static void AddStdXRCID_Records();
1932
1933 /*static*/
1934 int wxXmlResource::DoGetXRCID(const char *str_id, int value_if_not_found)
1935 {
1936     static bool s_stdIDsAdded = false;
1937
1938     if ( !s_stdIDsAdded )
1939     {
1940         s_stdIDsAdded = true;
1941         AddStdXRCID_Records();
1942     }
1943
1944     return XRCID_Lookup(str_id, value_if_not_found);
1945 }
1946
1947 /* static */
1948 wxString wxXmlResource::FindXRCIDById(int numId)
1949 {
1950     for ( int i = 0; i < XRCID_TABLE_SIZE; i++ )
1951     {
1952         for ( XRCID_record *rec = XRCID_Records[i]; rec; rec = rec->next )
1953         {
1954             if ( rec->id == numId )
1955                 return wxString(rec->key);
1956         }
1957     }
1958
1959     return wxString();
1960 }
1961
1962 static void CleanXRCID_Record(XRCID_record *rec)
1963 {
1964     if (rec)
1965     {
1966         CleanXRCID_Record(rec->next);
1967
1968         free(rec->key);
1969         delete rec;
1970     }
1971 }
1972
1973 static void CleanXRCID_Records()
1974 {
1975     for (int i = 0; i < XRCID_TABLE_SIZE; i++)
1976     {
1977         CleanXRCID_Record(XRCID_Records[i]);
1978         XRCID_Records[i] = NULL;
1979     }
1980 }
1981
1982 static void AddStdXRCID_Records()
1983 {
1984 #define stdID(id) XRCID_Lookup(#id, id)
1985     stdID(-1);
1986
1987     stdID(wxID_ANY);
1988     stdID(wxID_SEPARATOR);
1989
1990     stdID(wxID_OPEN);
1991     stdID(wxID_CLOSE);
1992     stdID(wxID_NEW);
1993     stdID(wxID_SAVE);
1994     stdID(wxID_SAVEAS);
1995     stdID(wxID_REVERT);
1996     stdID(wxID_EXIT);
1997     stdID(wxID_UNDO);
1998     stdID(wxID_REDO);
1999     stdID(wxID_HELP);
2000     stdID(wxID_PRINT);
2001     stdID(wxID_PRINT_SETUP);
2002     stdID(wxID_PAGE_SETUP);
2003     stdID(wxID_PREVIEW);
2004     stdID(wxID_ABOUT);
2005     stdID(wxID_HELP_CONTENTS);
2006     stdID(wxID_HELP_COMMANDS);
2007     stdID(wxID_HELP_PROCEDURES);
2008     stdID(wxID_HELP_CONTEXT);
2009     stdID(wxID_CLOSE_ALL);
2010     stdID(wxID_PREFERENCES);
2011     stdID(wxID_EDIT);
2012     stdID(wxID_CUT);
2013     stdID(wxID_COPY);
2014     stdID(wxID_PASTE);
2015     stdID(wxID_CLEAR);
2016     stdID(wxID_FIND);
2017     stdID(wxID_DUPLICATE);
2018     stdID(wxID_SELECTALL);
2019     stdID(wxID_DELETE);
2020     stdID(wxID_REPLACE);
2021     stdID(wxID_REPLACE_ALL);
2022     stdID(wxID_PROPERTIES);
2023     stdID(wxID_VIEW_DETAILS);
2024     stdID(wxID_VIEW_LARGEICONS);
2025     stdID(wxID_VIEW_SMALLICONS);
2026     stdID(wxID_VIEW_LIST);
2027     stdID(wxID_VIEW_SORTDATE);
2028     stdID(wxID_VIEW_SORTNAME);
2029     stdID(wxID_VIEW_SORTSIZE);
2030     stdID(wxID_VIEW_SORTTYPE);
2031     stdID(wxID_FILE1);
2032     stdID(wxID_FILE2);
2033     stdID(wxID_FILE3);
2034     stdID(wxID_FILE4);
2035     stdID(wxID_FILE5);
2036     stdID(wxID_FILE6);
2037     stdID(wxID_FILE7);
2038     stdID(wxID_FILE8);
2039     stdID(wxID_FILE9);
2040     stdID(wxID_OK);
2041     stdID(wxID_CANCEL);
2042     stdID(wxID_APPLY);
2043     stdID(wxID_YES);
2044     stdID(wxID_NO);
2045     stdID(wxID_STATIC);
2046     stdID(wxID_FORWARD);
2047     stdID(wxID_BACKWARD);
2048     stdID(wxID_DEFAULT);
2049     stdID(wxID_MORE);
2050     stdID(wxID_SETUP);
2051     stdID(wxID_RESET);
2052     stdID(wxID_CONTEXT_HELP);
2053     stdID(wxID_YESTOALL);
2054     stdID(wxID_NOTOALL);
2055     stdID(wxID_ABORT);
2056     stdID(wxID_RETRY);
2057     stdID(wxID_IGNORE);
2058     stdID(wxID_ADD);
2059     stdID(wxID_REMOVE);
2060     stdID(wxID_UP);
2061     stdID(wxID_DOWN);
2062     stdID(wxID_HOME);
2063     stdID(wxID_REFRESH);
2064     stdID(wxID_STOP);
2065     stdID(wxID_INDEX);
2066     stdID(wxID_BOLD);
2067     stdID(wxID_ITALIC);
2068     stdID(wxID_JUSTIFY_CENTER);
2069     stdID(wxID_JUSTIFY_FILL);
2070     stdID(wxID_JUSTIFY_RIGHT);
2071     stdID(wxID_JUSTIFY_LEFT);
2072     stdID(wxID_UNDERLINE);
2073     stdID(wxID_INDENT);
2074     stdID(wxID_UNINDENT);
2075     stdID(wxID_ZOOM_100);
2076     stdID(wxID_ZOOM_FIT);
2077     stdID(wxID_ZOOM_IN);
2078     stdID(wxID_ZOOM_OUT);
2079     stdID(wxID_UNDELETE);
2080     stdID(wxID_REVERT_TO_SAVED);
2081     stdID(wxID_SYSTEM_MENU);
2082     stdID(wxID_CLOSE_FRAME);
2083     stdID(wxID_MOVE_FRAME);
2084     stdID(wxID_RESIZE_FRAME);
2085     stdID(wxID_MAXIMIZE_FRAME);
2086     stdID(wxID_ICONIZE_FRAME);
2087     stdID(wxID_RESTORE_FRAME);
2088     stdID(wxID_CDROM);
2089     stdID(wxID_CONVERT);
2090     stdID(wxID_EXECUTE);
2091     stdID(wxID_FLOPPY);
2092     stdID(wxID_HARDDISK);
2093     stdID(wxID_BOTTOM);
2094     stdID(wxID_FIRST);
2095     stdID(wxID_LAST);
2096     stdID(wxID_TOP);
2097     stdID(wxID_INFO);
2098     stdID(wxID_JUMP_TO);
2099     stdID(wxID_NETWORK);
2100     stdID(wxID_SELECT_COLOR);
2101     stdID(wxID_SELECT_FONT);
2102     stdID(wxID_SORT_ASCENDING);
2103     stdID(wxID_SORT_DESCENDING);
2104     stdID(wxID_SPELL_CHECK);
2105     stdID(wxID_STRIKETHROUGH);
2106
2107 #undef stdID
2108 }
2109
2110
2111
2112
2113
2114 //-----------------------------------------------------------------------------
2115 // module and globals
2116 //-----------------------------------------------------------------------------
2117
2118 // normally we would do the cleanup from wxXmlResourceModule::OnExit() but it
2119 // can happen that some XRC records have been created because of the use of
2120 // XRCID() in event tables, which happens during static objects initialization,
2121 // but then the application initialization failed and so the wx modules were
2122 // neither initialized nor cleaned up -- this static object does the cleanup in
2123 // this case
2124 static struct wxXRCStaticCleanup
2125 {
2126     ~wxXRCStaticCleanup() { CleanXRCID_Records(); }
2127 } s_staticCleanup;
2128
2129 class wxXmlResourceModule: public wxModule
2130 {
2131 DECLARE_DYNAMIC_CLASS(wxXmlResourceModule)
2132 public:
2133     wxXmlResourceModule() {}
2134     bool OnInit()
2135     {
2136         wxXmlResource::AddSubclassFactory(new wxXmlSubclassFactoryCXX);
2137         return true;
2138     }
2139     void OnExit()
2140     {
2141         delete wxXmlResource::Set(NULL);
2142         if(wxXmlResource::ms_subclassFactories)
2143         {
2144             for ( wxXmlSubclassFactories::iterator i = wxXmlResource::ms_subclassFactories->begin();
2145                   i != wxXmlResource::ms_subclassFactories->end(); ++i )
2146             {
2147                 delete *i;
2148             }
2149             wxDELETE(wxXmlResource::ms_subclassFactories);
2150         }
2151         CleanXRCID_Records();
2152     }
2153 };
2154
2155 IMPLEMENT_DYNAMIC_CLASS(wxXmlResourceModule, wxModule)
2156
2157
2158 // When wxXml is loaded dynamically after the application is already running
2159 // then the built-in module system won't pick this one up.  Add it manually.
2160 void wxXmlInitResourceModule()
2161 {
2162     wxModule* module = new wxXmlResourceModule;
2163     module->Init();
2164     wxModule::RegisterModule(module);
2165 }
2166
2167 #endif // wxUSE_XRC