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