src/common/resource.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        resource.cpp
   3 // Purpose:     Resource system
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart and Markus Holzem
   9 // Licence:    wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation "resource.h"
  14 #endif
  15
  16 // For compilers that support precompilation, includes "wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #ifdef __BORLANDC__
  20 #pragma hdrstop
  21 #endif
  22
  23 #if wxUSE_WX_RESOURCES
  24
  25 #ifdef __VISUALC__
  26 #pragma warning(disable:4706)   // assignment within conditional expression
  27 #endif // VC++
  28
  29 #ifndef WX_PRECOMP
  30 #include "wx/defs.h"
  31 #include "wx/setup.h"
  32 #include "wx/list.h"
  33 #include "wx/hash.h"
  34 #include "wx/gdicmn.h"
  35 #include "wx/utils.h"
  36 #include "wx/types.h"
  37 #include "wx/menu.h"
  38 #include "wx/stattext.h"
  39 #include "wx/button.h"
  40 #include "wx/bmpbuttn.h"
  41 #include "wx/radiobox.h"
  42 #include "wx/listbox.h"
  43 #include "wx/choice.h"
  44 #include "wx/checkbox.h"
  45 #include "wx/settings.h"
  46 #include "wx/slider.h"
  47 #include "wx/icon.h"
  48 #include "wx/statbox.h"
  49 #include "wx/statbmp.h"
  50 #include "wx/gauge.h"
  51 #include "wx/textctrl.h"
  52 #include "wx/msgdlg.h"
  53 #include "wx/intl.h"
  54 #endif
  55
  56 #include "wx/listctrl.h"
  57
  58 #if wxUSE_RADIOBTN
  59 #include "wx/radiobut.h"
  60 #endif
  61
  62 #if wxUSE_SCROLLBAR
  63 #include "wx/scrolbar.h"
  64 #endif
  65
  66 #if wxUSE_COMBOBOX
  67 #include "wx/combobox.h"
  68 #endif
  69
  70 #include "wx/validate.h"
  71
  72 #include "wx/log.h"
  73
  74 #include <ctype.h>
  75 #include <math.h>
  76 #include <stdlib.h>
  77 #include <string.h>
  78
  79 #include "wx/resource.h"
  80 #include "wx/string.h"
  81 #include "wx/wxexpr.h"
  82
  83 #include "wx/settings.h"
  84 #include "wx/stream.h"
  85
  86 // Forward (private) declarations
  87 bool wxResourceInterpretResources(wxResourceTable& table, wxExprDatabase& db);
  88 wxItemResource *wxResourceInterpretDialog(wxResourceTable& table, wxExpr *expr, bool isPanel = FALSE);
  89 wxItemResource *wxResourceInterpretControl(wxResourceTable& table, wxExpr *expr);
  90 wxItemResource *wxResourceInterpretMenu(wxResourceTable& table, wxExpr *expr);
  91 wxItemResource *wxResourceInterpretMenuBar(wxResourceTable& table, wxExpr *expr);
  92 wxItemResource *wxResourceInterpretString(wxResourceTable& table, wxExpr *expr);
  93 wxItemResource *wxResourceInterpretBitmap(wxResourceTable& table, wxExpr *expr);
  94 wxItemResource *wxResourceInterpretIcon(wxResourceTable& table, wxExpr *expr);
  95 // Interpret list expression
  96 wxFont wxResourceInterpretFontSpec(wxExpr *expr);
  97
  98 bool wxResourceReadOneResource(FILE *fd, wxExprDatabase& db, bool *eof, wxResourceTable *table = (wxResourceTable *) NULL);
  99 bool wxResourceReadOneResource(wxInputStream *fd, wxExprDatabase& db, bool *eof, wxResourceTable *table) ;
 100 bool wxResourceParseIncludeFile(const wxString& f, wxResourceTable *table = (wxResourceTable *) NULL);
 101
 102 wxResourceTable *wxDefaultResourceTable = (wxResourceTable *) NULL;
 103
 104 char *wxResourceBuffer = (char *) NULL;
 105 long wxResourceBufferSize = 0;
 106 long wxResourceBufferCount = 0;
 107 int wxResourceStringPtr = 0;
 108
 109 void wxInitializeResourceSystem()
 110 {
 111     wxDefaultResourceTable = new wxResourceTable;
 112 }
 113
 114 void wxCleanUpResourceSystem()
 115 {
 116     delete wxDefaultResourceTable;
 117     if (wxResourceBuffer)
 118         delete[] wxResourceBuffer;
 119 }
 120
 121 void wxLogWarning(char *msg)
 122 {
 123     wxMessageBox(msg, _("Warning"), wxOK);
 124 }
 125
 126 IMPLEMENT_DYNAMIC_CLASS(wxItemResource, wxObject)
 127 IMPLEMENT_DYNAMIC_CLASS(wxResourceTable, wxHashTable)
 128
 129 wxItemResource::wxItemResource()
 130 {
 131     m_itemType = "";
 132     m_title = "";
 133     m_name = "";
 134     m_windowStyle = 0;
 135     m_x = m_y = m_width = m_height = 0;
 136     m_value1 = m_value2 = m_value3 = m_value5 = 0;
 137     m_value4 = "";
 138     m_windowId = 0;
 139     m_exStyle = 0;
 140 }
 141
 142 wxItemResource::~wxItemResource()
 143 {
 144     wxNode *node = m_children.First();
 145     while (node)
 146     {
 147         wxItemResource *item = (wxItemResource *)node->Data();
 148         delete item;
 149         delete node;
 150         node = m_children.First();
 151     }
 152 }
 153
 154 /*
 155 * Resource table
 156 */
 157
 158 wxResourceTable::wxResourceTable():wxHashTable(wxKEY_STRING), identifiers(wxKEY_STRING)
 159 {
 160 }
 161
 162 wxResourceTable::~wxResourceTable()
 163 {
 164     ClearTable();
 165 }
 166
 167 wxItemResource *wxResourceTable::FindResource(const wxString& name) const
 168 {
 169     wxItemResource *item = (wxItemResource *)Get(WXSTRINGCAST name);
 170     return item;
 171 }
 172
 173 void wxResourceTable::AddResource(wxItemResource *item)
 174 {
 175     wxString name = item->GetName();
 176     if (name == wxT(""))
 177         name = item->GetTitle();
 178     if (name == wxT(""))
 179         name = wxT("no name");
 180
 181     // Delete existing resource, if any.
 182     Delete(name);
 183
 184     Put(name, item);
 185 }
 186
 187 bool wxResourceTable::DeleteResource(const wxString& name)
 188 {
 189     wxItemResource *item = (wxItemResource *)Delete(WXSTRINGCAST name);
 190     if (item)
 191     {
 192         // See if any resource has this as its child; if so, delete from
 193         // parent's child list.
 194         BeginFind();
 195         wxNode *node = (wxNode *) NULL;
 196         node = Next();
 197         while (node != NULL)
 198         {
 199             wxItemResource *parent = (wxItemResource *)node->Data();
 200             if (parent->GetChildren().Member(item))
 201             {
 202                 parent->GetChildren().DeleteObject(item);
 203                 break;
 204             }
 205             node = Next();
 206         }
 207
 208         delete item;
 209         return TRUE;
 210     }
 211     else
 212         return FALSE;
 213 }
 214
 215 bool wxResourceTable::ParseResourceFile( wxInputStream *is )
 216 {
 217     wxExprDatabase db;
 218     int len = is->StreamSize() ;
 219
 220     bool eof = FALSE;
 221     while ( is->TellI() + 10 < len) // it's a hack because the streams dont support EOF
 222     {
 223         wxResourceReadOneResource(is, db, &eof, this) ;
 224     }
 225     return wxResourceInterpretResources(*this, db);
 226 }
 227
 228 bool wxResourceTable::ParseResourceFile(const wxString& filename)
 229 {
 230     wxExprDatabase db;
 231
 232     FILE *fd = wxFopen(filename, _T("r"));
 233     if (!fd)
 234         return FALSE;
 235     bool eof = FALSE;
 236     while (wxResourceReadOneResource(fd, db, &eof, this) && !eof)
 237     {
 238         // Loop
 239     }
 240     fclose(fd);
 241     return wxResourceInterpretResources(*this, db);
 242 }
 243
 244 bool wxResourceTable::ParseResourceData(const wxString& data)
 245 {
 246     wxExprDatabase db;
 247     if (!db.ReadFromString(data))
 248     {
 249         wxLogWarning(_("Ill-formed resource file syntax."));
 250         return FALSE;
 251     }
 252
 253     return wxResourceInterpretResources(*this, db);
 254 }
 255
 256 bool wxResourceTable::RegisterResourceBitmapData(const wxString& name, char bits[], int width, int height)
 257 {
 258     // Register pre-loaded bitmap data
 259     wxItemResource *item = new wxItemResource;
 260     //  item->SetType(wxRESOURCE_TYPE_XBM_DATA);
 261     item->SetType(wxT("wxXBMData"));
 262     item->SetName(name);
 263     item->SetValue1((long)bits);
 264     item->SetValue2((long)width);
 265     item->SetValue3((long)height);
 266     AddResource(item);
 267     return TRUE;
 268 }
 269
 270 bool wxResourceTable::RegisterResourceBitmapData(const wxString& name, char **data)
 271 {
 272     // Register pre-loaded bitmap data
 273     wxItemResource *item = new wxItemResource;
 274     //  item->SetType(wxRESOURCE_TYPE_XPM_DATA);
 275     item->SetType(wxT("wxXPMData"));
 276     item->SetName(name);
 277     item->SetValue1((long)data);
 278     AddResource(item);
 279     return TRUE;
 280 }
 281
 282 bool wxResourceTable::SaveResource(const wxString& WXUNUSED(filename))
 283 {
 284     return FALSE;
 285 }
 286
 287 void wxResourceTable::ClearTable()
 288 {
 289     BeginFind();
 290     wxNode *node = Next();
 291     while (node)
 292     {
 293         wxNode *next = Next();
 294         wxItemResource *item = (wxItemResource *)node->Data();
 295         delete item;
 296         delete node;
 297         node = next;
 298     }
 299 }
 300
 301 wxControl *wxResourceTable::CreateItem(wxWindow *parent, const wxItemResource* childResource, const wxItemResource* parentResource) const
 302 {
 303     int id = childResource->GetId();
 304     if ( id == 0 )
 305         id = -1;
 306
 307     bool dlgUnits = ((parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS) != 0);
 308
 309     wxControl *control = (wxControl *) NULL;
 310     wxString itemType(childResource->GetType());
 311
 312     wxPoint pos;
 313     wxSize size;
 314     if (dlgUnits)
 315     {
 316         pos = parent->ConvertDialogToPixels(wxPoint(childResource->GetX(), childResource->GetY()));
 317         size = parent->ConvertDialogToPixels(wxSize(childResource->GetWidth(), childResource->GetHeight()));
 318     }
 319     else
 320     {
 321         pos = wxPoint(childResource->GetX(), childResource->GetY());
 322         size = wxSize(childResource->GetWidth(), childResource->GetHeight());
 323     }
 324
 325     if (itemType == wxString(wxT("wxButton")) || itemType == wxString(wxT("wxBitmapButton")))
 326     {
 327         if (childResource->GetValue4() != wxT(""))
 328         {
 329             // Bitmap button
 330             wxBitmap bitmap = childResource->GetBitmap();
 331             if (!bitmap.Ok())
 332             {
 333                 bitmap = wxResourceCreateBitmap(childResource->GetValue4(), (wxResourceTable *)this);
 334                 ((wxItemResource*) childResource)->SetBitmap(bitmap);
 335             }
 336             if (!bitmap.Ok())
 337                 bitmap.LoadFile("cross_bmp", wxBITMAP_TYPE_BMP_RESOURCE);
 338             control = new wxBitmapButton(parent, id, bitmap, pos, size,
 339                 childResource->GetStyle() | wxBU_AUTODRAW, wxDefaultValidator, childResource->GetName());
 340         }
 341         else
 342             // Normal, text button
 343             control = new wxButton(parent, id, childResource->GetTitle(), pos, size,
 344             childResource->GetStyle(), wxDefaultValidator, childResource->GetName());
 345     }
 346     else if (itemType == wxString(wxT("wxMessage")) || itemType == wxString(wxT("wxStaticText")) ||
 347         itemType == wxString(wxT("wxStaticBitmap")))
 348     {
 349         if (childResource->GetValue4() != wxT("") || itemType == wxString(wxT("wxStaticBitmap")) )
 350         {
 351             // Bitmap message
 352             wxBitmap bitmap = childResource->GetBitmap();
 353             if (!bitmap.Ok())
 354             {
 355                 bitmap = wxResourceCreateBitmap(childResource->GetValue4(), (wxResourceTable *)this);
 356                 ((wxItemResource*) childResource)->SetBitmap(bitmap);
 357             }
 358 #if wxUSE_BITMAP_MESSAGE
 359 #ifdef __WXMSW__
 360             // Use a default bitmap
 361             if (!bitmap.Ok())
 362                 bitmap.LoadFile("cross_bmp", wxBITMAP_TYPE_BMP_RESOURCE);
 363 #endif
 364
 365             if (bitmap.Ok())
 366                 control = new wxStaticBitmap(parent, id, bitmap, pos, size,
 367                 childResource->GetStyle(), childResource->GetName());
 368 #endif
 369         }
 370         else
 371         {
 372             control = new wxStaticText(parent, id, childResource->GetTitle(), pos, size,
 373                 childResource->GetStyle(), childResource->GetName());
 374         }
 375     }
 376     else if (itemType == wxString(wxT("wxText")) || itemType == wxString(wxT("wxTextCtrl")) || itemType == wxString(wxT("wxMultiText")))
 377     {
 378         control = new wxTextCtrl(parent, id, childResource->GetValue4(), pos, size,
 379             childResource->GetStyle(), wxDefaultValidator, childResource->GetName());
 380     }
 381     else if (itemType == wxString(wxT("wxCheckBox")))
 382     {
 383         control = new wxCheckBox(parent, id, childResource->GetTitle(), pos, size,
 384             childResource->GetStyle(), wxDefaultValidator, childResource->GetName());
 385
 386         ((wxCheckBox *)control)->SetValue((childResource->GetValue1() != 0));
 387     }
 388 #if wxUSE_GAUGE
 389     else if (itemType == wxString(wxT("wxGauge")))
 390     {
 391         control = new wxGauge(parent, id, (int)childResource->GetValue2(), pos, size,
 392             childResource->GetStyle(), wxDefaultValidator, childResource->GetName());
 393
 394         ((wxGauge *)control)->SetValue((int)childResource->GetValue1());
 395     }
 396 #endif
 397 #if wxUSE_RADIOBTN
 398     else if (itemType == wxString(wxT("wxRadioButton")))
 399     {
 400         control = new wxRadioButton(parent, id, childResource->GetTitle(), // (int)childResource->GetValue1(),
 401             pos, size,
 402             childResource->GetStyle(), wxDefaultValidator, childResource->GetName());
 403     }
 404 #endif
 405 #if wxUSE_SCROLLBAR
 406     else if (itemType == wxString(wxT("wxScrollBar")))
 407     {
 408         control = new wxScrollBar(parent, id, pos, size,
 409             childResource->GetStyle(), wxDefaultValidator, childResource->GetName());
 410             /*
 411             ((wxScrollBar *)control)->SetValue((int)childResource->GetValue1());
 412             ((wxScrollBar *)control)->SetPageSize((int)childResource->GetValue2());
 413             ((wxScrollBar *)control)->SetObjectLength((int)childResource->GetValue3());
 414             ((wxScrollBar *)control)->SetViewLength((int)(long)childResource->GetValue5());
 415         */
 416         ((wxScrollBar *)control)->SetScrollbar((int)childResource->GetValue1(),(int)childResource->GetValue2(),
 417             (int)childResource->GetValue3(),(int)(long)childResource->GetValue5(),FALSE);
 418
 419     }
 420 #endif
 421     else if (itemType == wxString(wxT("wxSlider")))
 422     {
 423         control = new wxSlider(parent, id, (int)childResource->GetValue1(),
 424             (int)childResource->GetValue2(), (int)childResource->GetValue3(), pos, size,
 425             childResource->GetStyle(), wxDefaultValidator, childResource->GetName());
 426     }
 427     else if (itemType == wxString(wxT("wxGroupBox")) || itemType == wxString(wxT("wxStaticBox")))
 428     {
 429         control = new wxStaticBox(parent, id, childResource->GetTitle(), pos, size,
 430             childResource->GetStyle(), childResource->GetName());
 431     }
 432     else if (itemType == wxString(wxT("wxListBox")))
 433     {
 434         wxStringList& stringList = childResource->GetStringValues();
 435         wxString *strings = (wxString *) NULL;
 436         int noStrings = 0;
 437         if (stringList.Number() > 0)
 438         {
 439             noStrings = stringList.Number();
 440             strings = new wxString[noStrings];
 441             wxNode *node = stringList.First();
 442             int i = 0;
 443             while (node)
 444             {
 445                 strings[i] = (wxChar *)node->Data();
 446                 i ++;
 447                 node = node->Next();
 448             }
 449         }
 450         control = new wxListBox(parent, id, pos, size,
 451             noStrings, strings, childResource->GetStyle(), wxDefaultValidator, childResource->GetName());
 452
 453         if (strings)
 454             delete[] strings;
 455     }
 456     else if (itemType == wxString(wxT("wxChoice")))
 457     {
 458         wxStringList& stringList = childResource->GetStringValues();
 459         wxString *strings = (wxString *) NULL;
 460         int noStrings = 0;
 461         if (stringList.Number() > 0)
 462         {
 463             noStrings = stringList.Number();
 464             strings = new wxString[noStrings];
 465             wxNode *node = stringList.First();
 466             int i = 0;
 467             while (node)
 468             {
 469                 strings[i] = (wxChar *)node->Data();
 470                 i ++;
 471                 node = node->Next();
 472             }
 473         }
 474         control = new wxChoice(parent, id, pos, size,
 475             noStrings, strings, childResource->GetStyle(), wxDefaultValidator, childResource->GetName());
 476
 477         if (strings)
 478             delete[] strings;
 479     }
 480 #if wxUSE_COMBOBOX
 481     else if (itemType == wxString(wxT("wxComboBox")))
 482     {
 483         wxStringList& stringList = childResource->GetStringValues();
 484         wxString *strings = (wxString *) NULL;
 485         int noStrings = 0;
 486         if (stringList.Number() > 0)
 487         {
 488             noStrings = stringList.Number();
 489             strings = new wxString[noStrings];
 490             wxNode *node = stringList.First();
 491             int i = 0;
 492             while (node)
 493             {
 494                 strings[i] = (wxChar *)node->Data();
 495                 i ++;
 496                 node = node->Next();
 497             }
 498         }
 499         control = new wxComboBox(parent, id, childResource->GetValue4(), pos, size,
 500             noStrings, strings, childResource->GetStyle(), wxDefaultValidator, childResource->GetName());
 501
 502         if (strings)
 503             delete[] strings;
 504     }
 505 #endif
 506     else if (itemType == wxString(wxT("wxRadioBox")))
 507     {
 508         wxStringList& stringList = childResource->GetStringValues();
 509         wxString *strings = (wxString *) NULL;
 510         int noStrings = 0;
 511         if (stringList.Number() > 0)
 512         {
 513             noStrings = stringList.Number();
 514             strings = new wxString[noStrings];
 515             wxNode *node = stringList.First();
 516             int i = 0;
 517             while (node)
 518             {
 519                 strings[i] = (wxChar *)node->Data();
 520                 i ++;
 521                 node = node->Next();
 522             }
 523         }
 524         control = new wxRadioBox(parent, (wxWindowID) id, wxString(childResource->GetTitle()), pos, size,
 525             noStrings, strings, (int)childResource->GetValue1(), childResource->GetStyle(), wxDefaultValidator,
 526             childResource->GetName());
 527
 528         if (strings)
 529             delete[] strings;
 530     }
 531
 532     if ((parentResource->GetResourceStyle() & wxRESOURCE_USE_DEFAULTS) != 0)
 533     {
 534         // Don't set font; will be inherited from parent.
 535     }
 536     else
 537     {
 538         if (control && childResource->GetFont().Ok())
 539         {
 540             control->SetFont(childResource->GetFont());
 541
 542 #ifdef __WXMSW__
 543             // Force the layout algorithm since the size changes the layout
 544             if (control->IsKindOf(CLASSINFO(wxRadioBox)))
 545             {
 546                 control->SetSize(-1, -1, -1, -1, wxSIZE_AUTO_WIDTH|wxSIZE_AUTO_HEIGHT);
 547             }
 548 #endif
 549         }
 550     }
 551     return control;
 552 }
 553
 554 /*
 555 * Interpret database as a series of resources
 556 */
 557
 558 bool wxResourceInterpretResources(wxResourceTable& table, wxExprDatabase& db)
 559 {
 560     wxNode *node = db.First();
 561     while (node)
 562     {
 563         wxExpr *clause = (wxExpr *)node->Data();
 564         wxString functor(clause->Functor());
 565
 566         wxItemResource *item = (wxItemResource *) NULL;
 567         if (functor == wxT("dialog"))
 568             item = wxResourceInterpretDialog(table, clause);
 569         else if (functor == wxT("panel"))
 570             item = wxResourceInterpretDialog(table, clause, TRUE);
 571         else if (functor == wxT("menubar"))
 572             item = wxResourceInterpretMenuBar(table, clause);
 573         else if (functor == wxT("menu"))
 574             item = wxResourceInterpretMenu(table, clause);
 575         else if (functor == wxT("string"))
 576             item = wxResourceInterpretString(table, clause);
 577         else if (functor == wxT("bitmap"))
 578             item = wxResourceInterpretBitmap(table, clause);
 579         else if (functor == wxT("icon"))
 580             item = wxResourceInterpretIcon(table, clause);
 581
 582         if (item)
 583         {
 584             // Remove any existing resource of same name
 585             if (item->GetName() != wxT(""))
 586                 table.DeleteResource(item->GetName());
 587             table.AddResource(item);
 588         }
 589         node = node->Next();
 590     }
 591     return TRUE;
 592 }
 593
 594 static const wxChar *g_ValidControlClasses[] =
 595 {
 596     wxT("wxButton"),
 597         wxT("wxBitmapButton"),
 598         wxT("wxMessage"),
 599         wxT("wxStaticText"),
 600         wxT("wxStaticBitmap"),
 601         wxT("wxText"),
 602         wxT("wxTextCtrl"),
 603         wxT("wxMultiText"),
 604         wxT("wxListBox"),
 605         wxT("wxRadioBox"),
 606         wxT("wxRadioButton"),
 607         wxT("wxCheckBox"),
 608         wxT("wxBitmapCheckBox"),
 609         wxT("wxGroupBox"),
 610         wxT("wxStaticBox"),
 611         wxT("wxSlider"),
 612         wxT("wxGauge"),
 613         wxT("wxScrollBar"),
 614         wxT("wxChoice"),
 615         wxT("wxComboBox")
 616 };
 617
 618 static bool wxIsValidControlClass(const wxString& c)
 619 {
 620     for ( size_t i = 0; i < WXSIZEOF(g_ValidControlClasses); i++ )
 621     {
 622         if ( c == g_ValidControlClasses[i] )
 623             return TRUE;
 624     }
 625     return FALSE;
 626 }
 627
 628 wxItemResource *wxResourceInterpretDialog(wxResourceTable& table, wxExpr *expr, bool isPanel)
 629 {
 630     wxItemResource *dialogItem = new wxItemResource;
 631     if (isPanel)
 632         dialogItem->SetType(wxT("wxPanel"));
 633     else
 634         dialogItem->SetType(wxT("wxDialog"));
 635     wxString style = wxT("");
 636     wxString title = wxT("");
 637     wxString name = wxT("");
 638     wxString backColourHex = wxT("");
 639     wxString labelColourHex = wxT("");
 640     wxString buttonColourHex = wxT("");
 641
 642     long windowStyle = wxDEFAULT_DIALOG_STYLE;
 643     if (isPanel)
 644         windowStyle = 0;
 645
 646     int x = 0; int y = 0; int width = -1; int height = -1;
 647     int isModal = 0;
 648     wxExpr *labelFontExpr = (wxExpr *) NULL;
 649     wxExpr *buttonFontExpr = (wxExpr *) NULL;
 650     wxExpr *fontExpr = (wxExpr *) NULL;
 651     expr->GetAttributeValue(wxT("style"), style);
 652     expr->GetAttributeValue(wxT("name"), name);
 653     expr->GetAttributeValue(wxT("title"), title);
 654     expr->GetAttributeValue(wxT("x"), x);
 655     expr->GetAttributeValue(wxT("y"), y);
 656     expr->GetAttributeValue(wxT("width"), width);
 657     expr->GetAttributeValue(wxT("height"), height);
 658     expr->GetAttributeValue(wxT("modal"), isModal);
 659     expr->GetAttributeValue(wxT("label_font"), &labelFontExpr);
 660     expr->GetAttributeValue(wxT("button_font"), &buttonFontExpr);
 661     expr->GetAttributeValue(wxT("font"), &fontExpr);
 662     expr->GetAttributeValue(wxT("background_colour"), backColourHex);
 663     expr->GetAttributeValue(wxT("label_colour"), labelColourHex);
 664     expr->GetAttributeValue(wxT("button_colour"), buttonColourHex);
 665
 666     int useDialogUnits = 0;
 667     expr->GetAttributeValue(wxT("use_dialog_units"), useDialogUnits);
 668     if (useDialogUnits != 0)
 669         dialogItem->SetResourceStyle(dialogItem->GetResourceStyle() | wxRESOURCE_DIALOG_UNITS);
 670
 671     int useDefaults = 0;
 672     expr->GetAttributeValue(wxT("use_system_defaults"), useDefaults);
 673     if (useDefaults != 0)
 674         dialogItem->SetResourceStyle(dialogItem->GetResourceStyle() | wxRESOURCE_USE_DEFAULTS);
 675
 676     int id = 0;
 677     expr->GetAttributeValue(wxT("id"), id);
 678     dialogItem->SetId(id);
 679
 680     if (style != wxT(""))
 681     {
 682         windowStyle = wxParseWindowStyle(style);
 683     }
 684     dialogItem->SetStyle(windowStyle);
 685     dialogItem->SetValue1(isModal);
 686     if (windowStyle & wxDIALOG_MODAL) // Uses style in wxWin 2
 687         dialogItem->SetValue1(TRUE);
 688
 689     dialogItem->SetName(name);
 690     dialogItem->SetTitle(title);
 691     dialogItem->SetSize(x, y, width, height);
 692
 693     // Check for wxWin 1.68-style specifications
 694     if (style.Find(wxT("VERTICAL_LABEL")) != -1)
 695         dialogItem->SetResourceStyle(dialogItem->GetResourceStyle() | wxRESOURCE_VERTICAL_LABEL);
 696     else if (style.Find(wxT("HORIZONTAL_LABEL")) != -1)
 697         dialogItem->SetResourceStyle(dialogItem->GetResourceStyle() | wxRESOURCE_HORIZONTAL_LABEL);
 698
 699     if (backColourHex != wxT(""))
 700     {
 701         int r = 0;
 702         int g = 0;
 703         int b = 0;
 704         r = wxHexToDec(backColourHex.Mid(0, 2));
 705         g = wxHexToDec(backColourHex.Mid(2, 2));
 706         b = wxHexToDec(backColourHex.Mid(4, 2));
 707         dialogItem->SetBackgroundColour(wxColour((unsigned char)r,(unsigned char)g,(unsigned char)b));
 708     }
 709     if (labelColourHex != wxT(""))
 710     {
 711         int r = 0;
 712         int g = 0;
 713         int b = 0;
 714         r = wxHexToDec(labelColourHex.Mid(0, 2));
 715         g = wxHexToDec(labelColourHex.Mid(2, 2));
 716         b = wxHexToDec(labelColourHex.Mid(4, 2));
 717         dialogItem->SetLabelColour(wxColour((unsigned char)r,(unsigned char)g,(unsigned char)b));
 718     }
 719     if (buttonColourHex != wxT(""))
 720     {
 721         int r = 0;
 722         int g = 0;
 723         int b = 0;
 724         r = wxHexToDec(buttonColourHex.Mid(0, 2));
 725         g = wxHexToDec(buttonColourHex.Mid(2, 2));
 726         b = wxHexToDec(buttonColourHex.Mid(4, 2));
 727         dialogItem->SetButtonColour(wxColour((unsigned char)r,(unsigned char)g,(unsigned char)b));
 728     }
 729
 730     if (fontExpr)
 731         dialogItem->SetFont(wxResourceInterpretFontSpec(fontExpr));
 732     else if (buttonFontExpr)
 733         dialogItem->SetFont(wxResourceInterpretFontSpec(buttonFontExpr));
 734     else if (labelFontExpr)
 735         dialogItem->SetFont(wxResourceInterpretFontSpec(labelFontExpr));
 736
 737     // Now parse all controls
 738     wxExpr *controlExpr = expr->GetFirst();
 739     while (controlExpr)
 740     {
 741         if (controlExpr->Number() == 3)
 742         {
 743             wxString controlKeyword(controlExpr->Nth(1)->StringValue());
 744             if (controlKeyword != wxT("") && controlKeyword == wxT("control"))
 745             {
 746                 // The value part: always a list.
 747                 wxExpr *listExpr = controlExpr->Nth(2);
 748                 if (listExpr->Type() == PrologList)
 749                 {
 750                     wxItemResource *controlItem = wxResourceInterpretControl(table, listExpr);
 751                     if (controlItem)
 752                     {
 753                         dialogItem->GetChildren().Append(controlItem);
 754                     }
 755                 }
 756             }
 757         }
 758         controlExpr = controlExpr->GetNext();
 759     }
 760     return dialogItem;
 761 }
 762
 763 wxItemResource *wxResourceInterpretControl(wxResourceTable& table, wxExpr *expr)
 764 {
 765     wxItemResource *controlItem = new wxItemResource;
 766
 767     // First, find the standard features of a control definition:
 768     // [optional integer/string id], control name, title, style, name, x, y, width, height
 769
 770     wxString controlType;
 771     wxString style;
 772     wxString title;
 773     wxString name;
 774     int id = 0;
 775     long windowStyle = 0;
 776     int x = 0; int y = 0; int width = -1; int height = -1;
 777     int count = 0;
 778
 779     wxExpr *expr1 = expr->Nth(0);
 780
 781     if ( expr1->Type() == PrologString || expr1->Type() == PrologWord )
 782     {
 783         if ( wxIsValidControlClass(expr1->StringValue()) )
 784         {
 785             count = 1;
 786             controlType = expr1->StringValue();
 787         }
 788         else
 789         {
 790             wxString str(expr1->StringValue());
 791             id = wxResourceGetIdentifier(str, &table);
 792             if (id == 0)
 793             {
 794                 wxLogWarning(_("Could not resolve control class or id '%s'. Use (non-zero) integer instead\n or provide #define (see manual for caveats)"),
 795                     (const wxChar*) expr1->StringValue());
 796                 delete controlItem;
 797                 return (wxItemResource *) NULL;
 798             }
 799             else
 800             {
 801                 // Success - we have an id, so the 2nd element must be the control class.
 802                 controlType = expr->Nth(1)->StringValue();
 803                 count = 2;
 804             }
 805         }
 806     }
 807     else if (expr1->Type() == PrologInteger)
 808     {
 809         id = (int)expr1->IntegerValue();
 810         // Success - we have an id, so the 2nd element must be the control class.
 811         controlType = expr->Nth(1)->StringValue();
 812         count = 2;
 813     }
 814
 815     expr1 = expr->Nth(count);
 816     count ++;
 817     if ( expr1 )
 818         title = expr1->StringValue();
 819
 820     expr1 = expr->Nth(count);
 821     count ++;
 822     if (expr1)
 823     {
 824         style = expr1->StringValue();
 825         windowStyle = wxParseWindowStyle(style);
 826     }
 827
 828     expr1 = expr->Nth(count);
 829     count ++;
 830     if (expr1)
 831         name = expr1->StringValue();
 832
 833     expr1 = expr->Nth(count);
 834     count ++;
 835     if (expr1)
 836         x = (int)expr1->IntegerValue();
 837
 838     expr1 = expr->Nth(count);
 839     count ++;
 840     if (expr1)
 841         y = (int)expr1->IntegerValue();
 842
 843     expr1 = expr->Nth(count);
 844     count ++;
 845     if (expr1)
 846         width = (int)expr1->IntegerValue();
 847
 848     expr1 = expr->Nth(count);
 849     count ++;
 850     if (expr1)
 851         height = (int)expr1->IntegerValue();
 852
 853     controlItem->SetStyle(windowStyle);
 854     controlItem->SetName(name);
 855     controlItem->SetTitle(title);
 856     controlItem->SetSize(x, y, width, height);
 857     controlItem->SetType(controlType);
 858     controlItem->SetId(id);
 859
 860     // Check for wxWin 1.68-style specifications
 861     if (style.Find(wxT("VERTICAL_LABEL")) != -1)
 862         controlItem->SetResourceStyle(controlItem->GetResourceStyle() | wxRESOURCE_VERTICAL_LABEL);
 863     else if (style.Find(wxT("HORIZONTAL_LABEL")) != -1)
 864         controlItem->SetResourceStyle(controlItem->GetResourceStyle() | wxRESOURCE_HORIZONTAL_LABEL);
 865
 866     if (controlType == wxT("wxButton"))
 867     {
 868         // Check for bitmap resource name (in case loading old-style resource file)
 869         if (expr->Nth(count) && ((expr->Nth(count)->Type() == PrologString) || (expr->Nth(count)->Type() == PrologWord)))
 870         {
 871             wxString str(expr->Nth(count)->StringValue());
 872             count ++;
 873
 874             if (str != wxT(""))
 875             {
 876                 controlItem->SetValue4(str);
 877                 controlItem->SetType(wxT("wxBitmapButton"));
 878             }
 879         }
 880         if (expr->Nth(count) && expr->Nth(count)->Type() == PrologList)
 881             controlItem->SetFont(wxResourceInterpretFontSpec(expr->Nth(count)));
 882     }
 883     else if (controlType == wxT("wxBitmapButton"))
 884     {
 885         // Check for bitmap resource name
 886         if (expr->Nth(count) && ((expr->Nth(count)->Type() == PrologString) || (expr->Nth(count)->Type() == PrologWord)))
 887         {
 888             wxString str(expr->Nth(count)->StringValue());
 889             controlItem->SetValue4(str);
 890             count ++;
 891             if (expr->Nth(count) && expr->Nth(count)->Type() == PrologList)
 892                 controlItem->SetFont(wxResourceInterpretFontSpec(expr->Nth(count)));
 893         }
 894     }
 895     else if (controlType == wxT("wxCheckBox"))
 896     {
 897         // Check for default value
 898         if (expr->Nth(count) && (expr->Nth(count)->Type() == PrologInteger))
 899         {
 900             controlItem->SetValue1(expr->Nth(count)->IntegerValue());
 901             count ++;
 902             if (expr->Nth(count) && expr->Nth(count)->Type() == PrologList)
 903                 controlItem->SetFont(wxResourceInterpretFontSpec(expr->Nth(count)));
 904         }
 905     }
 906 #if wxUSE_RADIOBTN
 907     else if (controlType == wxT("wxRadioButton"))
 908     {
 909         // Check for default value
 910         if (expr->Nth(count) && (expr->Nth(count)->Type() == PrologInteger))
 911         {
 912             controlItem->SetValue1(expr->Nth(count)->IntegerValue());
 913             count ++;
 914             if (expr->Nth(count) && expr->Nth(count)->Type() == PrologList)
 915                 controlItem->SetFont(wxResourceInterpretFontSpec(expr->Nth(count)));
 916         }
 917     }
 918 #endif
 919     else if (controlType == wxT("wxText") || controlType == wxT("wxTextCtrl") || controlType == wxT("wxMultiText"))
 920     {
 921         // Check for default value
 922         if (expr->Nth(count) && ((expr->Nth(count)->Type() == PrologString) || (expr->Nth(count)->Type() == PrologWord)))
 923         {
 924             wxString str(expr->Nth(count)->StringValue());
 925             controlItem->SetValue4(str);
 926             count ++;
 927
 928             if (expr->Nth(count) && expr->Nth(count)->Type() == PrologList)
 929             {
 930                 // controlItem->SetLabelFont(wxResourceInterpretFontSpec(expr->Nth(count)));
 931                 // Skip past the obsolete label font spec if there are two consecutive specs
 932                 if (expr->Nth(count+1) && expr->Nth(count+1)->Type() == PrologList)
 933                     count ++;
 934                 controlItem->SetFont(wxResourceInterpretFontSpec(expr->Nth(count)));
 935             }
 936         }
 937     }
 938     else if (controlType == wxT("wxMessage") || controlType == wxT("wxStaticText"))
 939     {
 940         // Check for bitmap resource name (in case it's an old-style .wxr file)
 941         if (expr->Nth(count) && ((expr->Nth(count)->Type() == PrologString) || (expr->Nth(count)->Type() == PrologWord)))
 942         {
 943             wxString str(expr->Nth(count)->StringValue());
 944             controlItem->SetValue4(str);
 945             count ++;
 946             controlItem->SetType(wxT("wxStaticText"));
 947         }
 948         if (expr->Nth(count) && expr->Nth(count)->Type() == PrologList)
 949             controlItem->SetFont(wxResourceInterpretFontSpec(expr->Nth(count)));
 950     }
 951     else if (controlType == wxT("wxStaticBitmap"))
 952     {
 953         // Check for bitmap resource name
 954         if (expr->Nth(count) && ((expr->Nth(count)->Type() == PrologString) || (expr->Nth(count)->Type() == PrologWord)))
 955         {
 956             wxString str(expr->Nth(count)->StringValue());
 957             controlItem->SetValue4(str);
 958             count ++;
 959         }
 960         if (expr->Nth(count) && expr->Nth(count)->Type() == PrologList)
 961             controlItem->SetFont(wxResourceInterpretFontSpec(expr->Nth(count)));
 962     }
 963     else if (controlType == wxT("wxGroupBox") || controlType == wxT("wxStaticBox"))
 964     {
 965         if (expr->Nth(count) && expr->Nth(count)->Type() == PrologList)
 966             controlItem->SetFont(wxResourceInterpretFontSpec(expr->Nth(count)));
 967     }
 968     else if (controlType == wxT("wxGauge"))
 969     {
 970         // Check for default value
 971         if (expr->Nth(count) && (expr->Nth(count)->Type() == PrologInteger))
 972         {
 973             controlItem->SetValue1(expr->Nth(count)->IntegerValue());
 974             count ++;
 975
 976             // Check for range
 977             if (expr->Nth(count) && (expr->Nth(count)->Type() == PrologInteger))
 978             {
 979                 controlItem->SetValue2(expr->Nth(count)->IntegerValue());
 980                 count ++;
 981
 982                 if (expr->Nth(count) && expr->Nth(count)->Type() == PrologList)
 983                 {
 984                     // Skip past the obsolete label font spec if there are two consecutive specs
 985                     if (expr->Nth(count+1) && expr->Nth(count+1)->Type() == PrologList)
 986                         count ++;
 987                     controlItem->SetFont(wxResourceInterpretFontSpec(expr->Nth(count)));
 988                 }
 989             }
 990         }
 991     }
 992     else if (controlType == wxT("wxSlider"))
 993     {
 994         // Check for default value
 995         if (expr->Nth(count) && (expr->Nth(count)->Type() == PrologInteger))
 996         {
 997             controlItem->SetValue1(expr->Nth(count)->IntegerValue());
 998             count ++;
 999
1000             // Check for min
1001             if (expr->Nth(count) && (expr->Nth(count)->Type() == PrologInteger))
1002             {
1003                 controlItem->SetValue2(expr->Nth(count)->IntegerValue());
1004                 count ++;
1005
1006                 // Check for max
1007                 if (expr->Nth(count) && (expr->Nth(count)->Type() == PrologInteger))
1008                 {
1009                     controlItem->SetValue3(expr->Nth(count)->IntegerValue());
1010                     count ++;
1011
1012                     if (expr->Nth(count) && expr->Nth(count)->Type() == PrologList)
1013                     {
1014                         // controlItem->SetLabelFont(wxResourceInterpretFontSpec(expr->Nth(count)));
1015                         // do nothing
1016                         count ++;
1017
1018                         if (expr->Nth(count) && expr->Nth(count)->Type() == PrologList)
1019                             controlItem->SetFont(wxResourceInterpretFontSpec(expr->Nth(count)));
1020                     }
1021                 }
1022             }
1023         }
1024     }
1025     else if (controlType == wxT("wxScrollBar"))
1026     {
1027         // DEFAULT VALUE
1028         if (expr->Nth(count) && (expr->Nth(count)->Type() == PrologInteger))
1029         {
1030             controlItem->SetValue1(expr->Nth(count)->IntegerValue());
1031             count ++;
1032
1033             // PAGE LENGTH
1034             if (expr->Nth(count) && (expr->Nth(count)->Type() == PrologInteger))
1035             {
1036                 controlItem->SetValue2(expr->Nth(count)->IntegerValue());
1037                 count ++;
1038
1039                 // OBJECT LENGTH
1040                 if (expr->Nth(count) && (expr->Nth(count)->Type() == PrologInteger))
1041                 {
1042                     controlItem->SetValue3(expr->Nth(count)->IntegerValue());
1043                     count ++;
1044
1045                     // VIEW LENGTH
1046                     if (expr->Nth(count) && (expr->Nth(count)->Type() == PrologInteger))
1047                         controlItem->SetValue5(expr->Nth(count)->IntegerValue());
1048                 }
1049             }
1050         }
1051     }
1052     else if (controlType == wxT("wxListBox"))
1053     {
1054         wxExpr *valueList = (wxExpr *) NULL;
1055
1056         if (((valueList = expr->Nth(count)) != 0) && (valueList->Type() == PrologList))
1057         {
1058             wxStringList stringList;
1059             wxExpr *stringExpr = valueList->GetFirst();
1060             while (stringExpr)
1061             {
1062                 stringList.Add(stringExpr->StringValue());
1063                 stringExpr = stringExpr->GetNext();
1064             }
1065             controlItem->SetStringValues(stringList);
1066             count ++;
1067             // This is now obsolete: it's in the window style.
1068             // Check for wxSINGLE/wxMULTIPLE
1069             wxExpr *mult = (wxExpr *) NULL;
1070             /*
1071             controlItem->SetValue1(wxLB_SINGLE);
1072             */
1073             if (((mult = expr->Nth(count)) != 0) && ((mult->Type() == PrologString)||(mult->Type() == PrologWord)))
1074             {
1075             /*
1076             wxString m(mult->StringValue());
1077             if (m == "wxLB_MULTIPLE")
1078             controlItem->SetValue1(wxLB_MULTIPLE);
1079             else if (m == "wxLB_EXTENDED")
1080             controlItem->SetValue1(wxLB_EXTENDED);
1081                 */
1082                 // Ignore the value
1083                 count ++;
1084             }
1085             if (expr->Nth(count) && expr->Nth(count)->Type() == PrologList)
1086             {
1087                 // Skip past the obsolete label font spec if there are two consecutive specs
1088                 if (expr->Nth(count+1) && expr->Nth(count+1)->Type() == PrologList)
1089                     count ++;
1090                 controlItem->SetFont(wxResourceInterpretFontSpec(expr->Nth(count)));
1091             }
1092         }
1093     }
1094     else if (controlType == wxT("wxChoice"))
1095     {
1096         wxExpr *valueList = (wxExpr *) NULL;
1097         // Check for default value list
1098         if (((valueList = expr->Nth(count)) != 0) && (valueList->Type() == PrologList))
1099         {
1100             wxStringList stringList;
1101             wxExpr *stringExpr = valueList->GetFirst();
1102             while (stringExpr)
1103             {
1104                 stringList.Add(stringExpr->StringValue());
1105                 stringExpr = stringExpr->GetNext();
1106             }
1107             controlItem->SetStringValues(stringList);
1108
1109             count ++;
1110
1111             if (expr->Nth(count) && expr->Nth(count)->Type() == PrologList)
1112             {
1113                 // Skip past the obsolete label font spec if there are two consecutive specs
1114                 if (expr->Nth(count+1) && expr->Nth(count+1)->Type() == PrologList)
1115                     count ++;
1116                 controlItem->SetFont(wxResourceInterpretFontSpec(expr->Nth(count)));
1117             }
1118         }
1119     }
1120 #if wxUSE_COMBOBOX
1121     else if (controlType == wxT("wxComboBox"))
1122     {
1123         wxExpr *textValue = expr->Nth(count);
1124         if (textValue && (textValue->Type() == PrologString || textValue->Type() == PrologWord))
1125         {
1126             wxString str(textValue->StringValue());
1127             controlItem->SetValue4(str);
1128
1129             count ++;
1130
1131             wxExpr *valueList = (wxExpr *) NULL;
1132             // Check for default value list
1133             if (((valueList = expr->Nth(count)) != 0) && (valueList->Type() == PrologList))
1134             {
1135                 wxStringList stringList;
1136                 wxExpr *stringExpr = valueList->GetFirst();
1137                 while (stringExpr)
1138                 {
1139                     stringList.Add(stringExpr->StringValue());
1140                     stringExpr = stringExpr->GetNext();
1141                 }
1142                 controlItem->SetStringValues(stringList);
1143
1144                 count ++;
1145
1146                 if (expr->Nth(count) && expr->Nth(count)->Type() == PrologList)
1147                 {
1148                     // Skip past the obsolete label font spec if there are two consecutive specs
1149                     if (expr->Nth(count+1) && expr->Nth(count+1)->Type() == PrologList)
1150                         count ++;
1151                     controlItem->SetFont(wxResourceInterpretFontSpec(expr->Nth(count)));
1152                 }
1153             }
1154         }
1155     }
1156 #endif
1157 #if 1
1158     else if (controlType == wxT("wxRadioBox"))
1159     {
1160         wxExpr *valueList = (wxExpr *) NULL;
1161         // Check for default value list
1162         if (((valueList = expr->Nth(count)) != 0) && (valueList->Type() == PrologList))
1163         {
1164             wxStringList stringList;
1165             wxExpr *stringExpr = valueList->GetFirst();
1166             while (stringExpr)
1167             {
1168                 stringList.Add(stringExpr->StringValue());
1169                 stringExpr = stringExpr->GetNext();
1170             }
1171             controlItem->SetStringValues(stringList);
1172             count ++;
1173
1174             // majorDim (number of rows or cols)
1175             if (expr->Nth(count) && (expr->Nth(count)->Type() == PrologInteger))
1176             {
1177                 controlItem->SetValue1(expr->Nth(count)->IntegerValue());
1178                 count ++;
1179             }
1180             else
1181                 controlItem->SetValue1(0);
1182
1183             if (expr->Nth(count) && expr->Nth(count)->Type() == PrologList)
1184             {
1185                 // Skip past the obsolete label font spec if there are two consecutive specs
1186                 if (expr->Nth(count+1) && expr->Nth(count+1)->Type() == PrologList)
1187                     count ++;
1188                 controlItem->SetFont(wxResourceInterpretFontSpec(expr->Nth(count)));
1189             }
1190         }
1191     }
1192 #endif
1193     else
1194     {
1195         delete controlItem;
1196         return (wxItemResource *) NULL;
1197     }
1198     return controlItem;
1199 }
1200
1201 // Forward declaration
1202 wxItemResource *wxResourceInterpretMenu1(wxResourceTable& table, wxExpr *expr);
1203
1204 /*
1205 * Interpet a menu item
1206 */
1207
1208 wxItemResource *wxResourceInterpretMenuItem(wxResourceTable& table, wxExpr *expr)
1209 {
1210     wxItemResource *item = new wxItemResource;
1211
1212     wxExpr *labelExpr = expr->Nth(0);
1213     wxExpr *idExpr = expr->Nth(1);
1214     wxExpr *helpExpr = expr->Nth(2);
1215     wxExpr *checkableExpr = expr->Nth(3);
1216
1217     // Further keywords/attributes to follow sometime...
1218     if (expr->Number() == 0)
1219     {
1220         //    item->SetType(wxRESOURCE_TYPE_SEPARATOR);
1221         item->SetType(wxT("wxMenuSeparator"));
1222         return item;
1223     }
1224     else
1225     {
1226         //    item->SetType(wxTYPE_MENU); // Well, menu item, but doesn't matter.
1227         item->SetType(wxT("wxMenu")); // Well, menu item, but doesn't matter.
1228         if (labelExpr)
1229         {
1230             wxString str(labelExpr->StringValue());
1231             item->SetTitle(str);
1232         }
1233         if (idExpr)
1234         {
1235             int id = 0;
1236             // If a string or word, must look up in identifier table.
1237             if ((idExpr->Type() == PrologString) || (idExpr->Type() == PrologWord))
1238             {
1239                 wxString str(idExpr->StringValue());
1240                 id = wxResourceGetIdentifier(str, &table);
1241                 if (id == 0)
1242                 {
1243                     wxLogWarning(_("Could not resolve menu id '%s'. Use (non-zero) integer instead\nor provide #define (see manual for caveats)"),
1244                         (const wxChar*) idExpr->StringValue());
1245                 }
1246             }
1247             else if (idExpr->Type() == PrologInteger)
1248                 id = (int)idExpr->IntegerValue();
1249             item->SetValue1(id);
1250         }
1251         if (helpExpr)
1252         {
1253             wxString str(helpExpr->StringValue());
1254             item->SetValue4(str);
1255         }
1256         if (checkableExpr)
1257             item->SetValue2(checkableExpr->IntegerValue());
1258
1259         // Find the first expression that's a list, for submenu
1260         wxExpr *subMenuExpr = expr->GetFirst();
1261         while (subMenuExpr && (subMenuExpr->Type() != PrologList))
1262             subMenuExpr = subMenuExpr->GetNext();
1263
1264         while (subMenuExpr)
1265         {
1266             wxItemResource *child = wxResourceInterpretMenuItem(table, subMenuExpr);
1267             item->GetChildren().Append(child);
1268             subMenuExpr = subMenuExpr->GetNext();
1269         }
1270     }
1271     return item;
1272 }
1273
1274 /*
1275 * Interpret a nested list as a menu
1276 */
1277 /*
1278 wxItemResource *wxResourceInterpretMenu1(wxResourceTable& table, wxExpr *expr)
1279 {
1280 wxItemResource *menu = new wxItemResource;
1281 //  menu->SetType(wxTYPE_MENU);
1282 menu->SetType("wxMenu");
1283 wxExpr *element = expr->GetFirst();
1284 while (element)
1285 {
1286 wxItemResource *item = wxResourceInterpretMenuItem(table, element);
1287 if (item)
1288 menu->GetChildren().Append(item);
1289 element = element->GetNext();
1290 }
1291 return menu;
1292 }
1293 */
1294
1295 wxItemResource *wxResourceInterpretMenu(wxResourceTable& table, wxExpr *expr)
1296 {
1297     wxExpr *listExpr = (wxExpr *) NULL;
1298     expr->GetAttributeValue(wxT("menu"), &listExpr);
1299     if (!listExpr)
1300         return (wxItemResource *) NULL;
1301
1302     wxItemResource *menuResource = wxResourceInterpretMenuItem(table, listExpr);
1303
1304     if (!menuResource)
1305         return (wxItemResource *) NULL;
1306
1307     wxString name;
1308     if (expr->GetAttributeValue(wxT("name"), name))
1309     {
1310         menuResource->SetName(name);
1311     }
1312
1313     return menuResource;
1314 }
1315
1316 wxItemResource *wxResourceInterpretMenuBar(wxResourceTable& table, wxExpr *expr)
1317 {
1318     wxExpr *listExpr = (wxExpr *) NULL;
1319     expr->GetAttributeValue(wxT("menu"), &listExpr);
1320     if (!listExpr)
1321         return (wxItemResource *) NULL;
1322
1323     wxItemResource *resource = new wxItemResource;
1324     resource->SetType(wxT("wxMenu"));
1325     //  resource->SetType(wxTYPE_MENU);
1326
1327     wxExpr *element = listExpr->GetFirst();
1328     while (element)
1329     {
1330         wxItemResource *menuResource = wxResourceInterpretMenuItem(table, listExpr);
1331         resource->GetChildren().Append(menuResource);
1332         element = element->GetNext();
1333     }
1334
1335     wxString name;
1336     if (expr->GetAttributeValue(wxT("name"), name))
1337     {
1338         resource->SetName(name);
1339     }
1340
1341     return resource;
1342 }
1343
1344 wxItemResource *wxResourceInterpretString(wxResourceTable& WXUNUSED(table), wxExpr *WXUNUSED(expr))
1345 {
1346     return (wxItemResource *) NULL;
1347 }
1348
1349 wxItemResource *wxResourceInterpretBitmap(wxResourceTable& WXUNUSED(table), wxExpr *expr)
1350 {
1351     wxItemResource *bitmapItem = new wxItemResource;
1352     //  bitmapItem->SetType(wxTYPE_BITMAP);
1353     bitmapItem->SetType(wxT("wxBitmap"));
1354     wxString name;
1355     if (expr->GetAttributeValue(wxT("name"), name))
1356     {
1357         bitmapItem->SetName(name);
1358     }
1359     // Now parse all bitmap specifications
1360     wxExpr *bitmapExpr = expr->GetFirst();
1361     while (bitmapExpr)
1362     {
1363         if (bitmapExpr->Number() == 3)
1364         {
1365             wxString bitmapKeyword(bitmapExpr->Nth(1)->StringValue());
1366             if (bitmapKeyword == wxT("bitmap") || bitmapKeyword == wxT("icon"))
1367             {
1368                 // The value part: always a list.
1369                 wxExpr *listExpr = bitmapExpr->Nth(2);
1370                 if (listExpr->Type() == PrologList)
1371                 {
1372                     wxItemResource *bitmapSpec = new wxItemResource;
1373                     //          bitmapSpec->SetType(wxTYPE_BITMAP);
1374                     bitmapSpec->SetType(wxT("wxBitmap"));
1375
1376                     // List is of form: [filename, bitmaptype, platform, colours, xresolution, yresolution]
1377                     // where everything after 'filename' is optional.
1378                     wxExpr *nameExpr = listExpr->Nth(0);
1379                     wxExpr *typeExpr = listExpr->Nth(1);
1380                     wxExpr *platformExpr = listExpr->Nth(2);
1381                     wxExpr *coloursExpr = listExpr->Nth(3);
1382                     wxExpr *xresExpr = listExpr->Nth(4);
1383                     wxExpr *yresExpr = listExpr->Nth(5);
1384                     if (nameExpr && nameExpr->StringValue() != wxT(""))
1385                     {
1386                         bitmapSpec->SetName(nameExpr->StringValue());
1387                     }
1388                     if (typeExpr && typeExpr->StringValue() != wxT(""))
1389                     {
1390                         bitmapSpec->SetValue1(wxParseWindowStyle(typeExpr->StringValue()));
1391                     }
1392                     else
1393                         bitmapSpec->SetValue1(0);
1394
1395                     if (platformExpr && platformExpr->StringValue() != wxT(""))
1396                     {
1397                         wxString plat(platformExpr->StringValue());
1398                         if (plat == wxT("windows") || plat == wxT("WINDOWS"))
1399                             bitmapSpec->SetValue2(RESOURCE_PLATFORM_WINDOWS);
1400                         else if (plat == wxT("x") || plat == wxT("X"))
1401                             bitmapSpec->SetValue2(RESOURCE_PLATFORM_X);
1402                         else if (plat == wxT("mac") || plat == wxT("MAC"))
1403                             bitmapSpec->SetValue2(RESOURCE_PLATFORM_MAC);
1404                         else
1405                             bitmapSpec->SetValue2(RESOURCE_PLATFORM_ANY);
1406                     }
1407                     else
1408                         bitmapSpec->SetValue2(RESOURCE_PLATFORM_ANY);
1409
1410                     if (coloursExpr)
1411                         bitmapSpec->SetValue3(coloursExpr->IntegerValue());
1412                     int xres = 0;
1413                     int yres = 0;
1414                     if (xresExpr)
1415                         xres = (int)xresExpr->IntegerValue();
1416                     if (yresExpr)
1417                         yres = (int)yresExpr->IntegerValue();
1418                     bitmapSpec->SetSize(0, 0, xres, yres);
1419
1420                     bitmapItem->GetChildren().Append(bitmapSpec);
1421                 }
1422             }
1423         }
1424         bitmapExpr = bitmapExpr->GetNext();
1425     }
1426
1427     return bitmapItem;
1428 }
1429
1430 wxItemResource *wxResourceInterpretIcon(wxResourceTable& table, wxExpr *expr)
1431 {
1432     wxItemResource *item = wxResourceInterpretBitmap(table, expr);
1433     if (item)
1434     {
1435         //    item->SetType(wxTYPE_ICON);
1436         item->SetType(wxT("wxIcon"));
1437         return item;
1438     }
1439     else
1440         return (wxItemResource *) NULL;
1441 }
1442
1443 // Interpret list expression as a font
1444 wxFont wxResourceInterpretFontSpec(wxExpr *expr)
1445 {
1446     if (expr->Type() != PrologList)
1447         return wxNullFont;
1448
1449     int point = 10;
1450     int family = wxSWISS;
1451     int style = wxNORMAL;
1452     int weight = wxNORMAL;
1453     int underline = 0;
1454     wxString faceName(wxT(""));
1455
1456     wxExpr *pointExpr = expr->Nth(0);
1457     wxExpr *familyExpr = expr->Nth(1);
1458     wxExpr *styleExpr = expr->Nth(2);
1459     wxExpr *weightExpr = expr->Nth(3);
1460     wxExpr *underlineExpr = expr->Nth(4);
1461     wxExpr *faceNameExpr = expr->Nth(5);
1462     if (pointExpr)
1463         point = (int)pointExpr->IntegerValue();
1464
1465     wxString str;
1466     if (familyExpr)
1467     {
1468         str = familyExpr->StringValue();
1469         family = (int)wxParseWindowStyle(str);
1470     }
1471     if (styleExpr)
1472     {
1473         str = styleExpr->StringValue();
1474         style = (int)wxParseWindowStyle(str);
1475     }
1476     if (weightExpr)
1477     {
1478         str = weightExpr->StringValue();
1479         weight = (int)wxParseWindowStyle(str);
1480     }
1481     if (underlineExpr)
1482         underline = (int)underlineExpr->IntegerValue();
1483     if (faceNameExpr)
1484         faceName = faceNameExpr->StringValue();
1485
1486     wxFont font(point, family, style, weight, (underline != 0), faceName);
1487     return font;
1488 }
1489
1490 // Separate file for the remainder of this, for BC++/Win16
1491
1492 #if !((defined(__BORLANDC__) || defined(__SC__)) && defined(__WIN16__))
1493 /*
1494 * (Re)allocate buffer for reading in from resource file
1495 */
1496
1497 bool wxReallocateResourceBuffer()
1498 {
1499     if (!wxResourceBuffer)
1500     {
1501         wxResourceBufferSize = 1000;
1502         wxResourceBuffer = new char[wxResourceBufferSize];
1503         return TRUE;
1504     }
1505     if (wxResourceBuffer)
1506     {
1507         long newSize = wxResourceBufferSize + 1000;
1508         char *tmp = new char[(int)newSize];
1509         strncpy(tmp, wxResourceBuffer, (int)wxResourceBufferCount);
1510         delete[] wxResourceBuffer;
1511         wxResourceBuffer = tmp;
1512         wxResourceBufferSize = newSize;
1513     }
1514     return TRUE;
1515 }
1516
1517 static bool wxEatWhiteSpace(FILE *fd)
1518 {
1519     int ch = 0;
1520
1521     while ((ch = getc(fd)) != EOF)
1522     {
1523         switch (ch)
1524         {
1525         case ' ':
1526         case 0x0a:
1527         case 0x0d:
1528         case 0x09:
1529             break;
1530         case '/':
1531             {
1532                 int prev_ch = ch;
1533                 ch = getc(fd);
1534                 if (ch == EOF)
1535                 {
1536                     ungetc(prev_ch, fd);
1537                     return TRUE;
1538                 }
1539
1540                 if (ch == '*')
1541                 {
1542                     // Eat C comment
1543                     prev_ch = 0;
1544                     while ((ch = getc(fd)) != EOF)
1545                     {
1546                         if (ch == '/' && prev_ch == '*')
1547                             break;
1548                         prev_ch = ch;
1549                     }
1550                 }
1551                 else if (ch == '/')
1552                 {
1553                     // Eat C++ comment
1554                     static char buffer[255];
1555                     fgets(buffer, 255, fd);
1556                 }
1557                 else
1558                 {
1559                     ungetc(prev_ch, fd);
1560                     ungetc(ch, fd);
1561                     return TRUE;
1562                 }
1563             }
1564             break;
1565         default:
1566             ungetc(ch, fd);
1567             return TRUE;
1568
1569         }
1570     }
1571     return FALSE;
1572 }
1573 static bool wxEatWhiteSpace(wxInputStream *is)
1574 {
1575     int ch = is->GetC() ;
1576     if ((ch != ' ') && (ch != '/') && (ch != ' ') && (ch != 10) && (ch != 13) && (ch != 9))
1577     {
1578         is->Ungetch(ch);
1579         return TRUE;
1580     }
1581
1582     // Eat whitespace
1583     while (ch == ' ' || ch == 10 || ch == 13 || ch == 9)
1584         ch = is->GetC();
1585     // Check for comment
1586     if (ch == '/')
1587     {
1588         ch = is->GetC();
1589         if (ch == '*')
1590         {
1591             bool finished = FALSE;
1592             while (!finished)
1593             {
1594                 ch = is->GetC();
1595                 if (ch == EOF)
1596                     return FALSE;
1597                 if (ch == '*')
1598                 {
1599                     int newCh = is->GetC();
1600                     if (newCh == '/')
1601                         finished = TRUE;
1602                     else
1603                     {
1604                         is->Ungetch(ch);
1605                     }
1606                 }
1607             }
1608         }
1609         else // False alarm
1610             return FALSE;
1611     }
1612     else
1613         is->Ungetch(ch);
1614     return wxEatWhiteSpace(is);
1615 }
1616
1617 bool wxGetResourceToken(FILE *fd)
1618 {
1619     if (!wxResourceBuffer)
1620         wxReallocateResourceBuffer();
1621     wxResourceBuffer[0] = 0;
1622     wxEatWhiteSpace(fd);
1623
1624     int ch = getc(fd);
1625     if (ch == '"')
1626     {
1627         // Get string
1628         wxResourceBufferCount = 0;
1629         ch = getc(fd);
1630         while (ch != '"')
1631         {
1632             int actualCh = ch;
1633             if (ch == EOF)
1634             {
1635                 wxResourceBuffer[wxResourceBufferCount] = 0;
1636                 return FALSE;
1637             }
1638             // Escaped characters
1639             else if (ch == '\\')
1640             {
1641                 int newCh = getc(fd);
1642                 if (newCh == '"')
1643                     actualCh = '"';
1644                 else if (newCh == 10)
1645                     actualCh = 10;
1646                 else
1647                 {
1648                     ungetc(newCh, fd);
1649                 }
1650             }
1651
1652             if (wxResourceBufferCount >= wxResourceBufferSize-1)
1653                 wxReallocateResourceBuffer();
1654             wxResourceBuffer[wxResourceBufferCount] = (char)actualCh;
1655             wxResourceBufferCount ++;
1656             ch = getc(fd);
1657         }
1658         wxResourceBuffer[wxResourceBufferCount] = 0;
1659     }
1660     else
1661     {
1662         wxResourceBufferCount = 0;
1663         // Any other token
1664         while (ch != ' ' && ch != EOF && ch != ' ' && ch != 13 && ch != 9 && ch != 10)
1665         {
1666             if (wxResourceBufferCount >= wxResourceBufferSize-1)
1667                 wxReallocateResourceBuffer();
1668             wxResourceBuffer[wxResourceBufferCount] = (char)ch;
1669             wxResourceBufferCount ++;
1670
1671             ch = getc(fd);
1672         }
1673         wxResourceBuffer[wxResourceBufferCount] = 0;
1674         if (ch == EOF)
1675             return FALSE;
1676     }
1677     return TRUE;
1678 }
1679
1680 bool wxGetResourceToken(wxInputStream *is)
1681 {
1682     if (!wxResourceBuffer)
1683         wxReallocateResourceBuffer();
1684     wxResourceBuffer[0] = 0;
1685     wxEatWhiteSpace(is);
1686
1687     int ch = is->GetC() ;
1688     if (ch == '"')
1689     {
1690         // Get string
1691         wxResourceBufferCount = 0;
1692         ch = is->GetC();
1693         while (ch != '"')
1694         {
1695             int actualCh = ch;
1696             if (ch == EOF)
1697             {
1698                 wxResourceBuffer[wxResourceBufferCount] = 0;
1699                 return FALSE;
1700             }
1701             // Escaped characters
1702             else if (ch == '\\')
1703             {
1704                 int newCh = is->GetC();
1705                 if (newCh == '"')
1706                     actualCh = '"';
1707                 else if (newCh == 10)
1708                     actualCh = 10;
1709                 else if (newCh == 13) // mac
1710                     actualCh = 10;
1711                 else
1712                 {
1713                     is->Ungetch(newCh);
1714                 }
1715             }
1716
1717             if (wxResourceBufferCount >= wxResourceBufferSize-1)
1718                 wxReallocateResourceBuffer();
1719             wxResourceBuffer[wxResourceBufferCount] = (char)actualCh;
1720             wxResourceBufferCount ++;
1721             ch = is->GetC();
1722         }
1723         wxResourceBuffer[wxResourceBufferCount] = 0;
1724     }
1725     else
1726     {
1727         wxResourceBufferCount = 0;
1728         // Any other token
1729         while (ch != ' ' && ch != EOF && ch != ' ' && ch != 13 && ch != 9 && ch != 10)
1730         {
1731             if (wxResourceBufferCount >= wxResourceBufferSize-1)
1732                 wxReallocateResourceBuffer();
1733             wxResourceBuffer[wxResourceBufferCount] = (char)ch;
1734             wxResourceBufferCount ++;
1735
1736             ch = is->GetC();
1737         }
1738         wxResourceBuffer[wxResourceBufferCount] = 0;
1739         if (ch == EOF)
1740             return FALSE;
1741     }
1742     return TRUE;
1743 }
1744
1745 /*
1746 * Files are in form:
1747 static char *name = "....";
1748 with possible comments.
1749 */
1750
1751 bool wxResourceReadOneResource(FILE *fd, wxExprDatabase& db, bool *eof, wxResourceTable *table)
1752 {
1753     if (!table)
1754         table = wxDefaultResourceTable;
1755
1756     // static or #define
1757     if (!wxGetResourceToken(fd))
1758     {
1759         *eof = TRUE;
1760         return FALSE;
1761     }
1762
1763     if (strcmp(wxResourceBuffer, "#define") == 0)
1764     {
1765         wxGetResourceToken(fd);
1766         wxChar *name = copystring(wxConvCurrent->cMB2WX(wxResourceBuffer));
1767         wxGetResourceToken(fd);
1768         wxChar *value = copystring(wxConvCurrent->cMB2WX(wxResourceBuffer));
1769         if (wxIsdigit(value[0]))
1770         {
1771             int val = (int)wxAtol(value);
1772             wxResourceAddIdentifier(name, val, table);
1773         }
1774         else
1775         {
1776             wxLogWarning(_("#define %s must be an integer."), name);
1777             delete[] name;
1778             delete[] value;
1779             return FALSE;
1780         }
1781         delete[] name;
1782         delete[] value;
1783
1784         return TRUE;
1785     }
1786     else if (strcmp(wxResourceBuffer, "#include") == 0)
1787     {
1788         wxGetResourceToken(fd);
1789         wxChar *name = copystring(wxConvCurrent->cMB2WX(wxResourceBuffer));
1790         wxChar *actualName = name;
1791         if (name[0] == wxT('"'))
1792             actualName = name + 1;
1793         int len = wxStrlen(name);
1794         if ((len > 0) && (name[len-1] == wxT('"')))
1795             name[len-1] = 0;
1796         if (!wxResourceParseIncludeFile(actualName, table))
1797         {
1798             wxLogWarning(_("Could not find resource include file %s."), actualName);
1799         }
1800         delete[] name;
1801         return TRUE;
1802     }
1803     else if (strcmp(wxResourceBuffer, "static") != 0)
1804     {
1805         wxChar buf[300];
1806         wxStrcpy(buf, _("Found "));
1807         wxStrncat(buf, wxConvCurrent->cMB2WX(wxResourceBuffer), 30);
1808         wxStrcat(buf, _(", expected static, #include or #define\nwhilst parsing resource."));
1809         wxLogWarning(buf);
1810         return FALSE;
1811     }
1812
1813     // char
1814     if (!wxGetResourceToken(fd))
1815     {
1816         wxLogWarning(_("Unexpected end of file whilst parsing resource."));
1817         *eof = TRUE;
1818         return FALSE;
1819     }
1820
1821     if (strcmp(wxResourceBuffer, "char") != 0)
1822     {
1823         wxLogWarning(_("Expected 'char' whilst parsing resource."));
1824         return FALSE;
1825     }
1826
1827     // *name
1828     if (!wxGetResourceToken(fd))
1829     {
1830         wxLogWarning(_("Unexpected end of file whilst parsing resource."));
1831         *eof = TRUE;
1832         return FALSE;
1833     }
1834
1835     if (wxResourceBuffer[0] != '*')
1836     {
1837         wxLogWarning(_("Expected '*' whilst parsing resource."));
1838         return FALSE;
1839     }
1840     wxChar nameBuf[100];
1841     wxMB2WX(nameBuf, wxResourceBuffer+1, 99);
1842     nameBuf[99] = 0;
1843
1844     // =
1845     if (!wxGetResourceToken(fd))
1846     {
1847         wxLogWarning(_("Unexpected end of file whilst parsing resource."));
1848         *eof = TRUE;
1849         return FALSE;
1850     }
1851
1852     if (strcmp(wxResourceBuffer, "=") != 0)
1853     {
1854         wxLogWarning(_("Expected '=' whilst parsing resource."));
1855         return FALSE;
1856     }
1857
1858     // String
1859     if (!wxGetResourceToken(fd))
1860     {
1861         wxLogWarning(_("Unexpected end of file whilst parsing resource."));
1862         *eof = TRUE;
1863         return FALSE;
1864     }
1865     else
1866     {
1867         if (!db.ReadPrologFromString(wxResourceBuffer))
1868         {
1869             wxLogWarning(_("%s: ill-formed resource file syntax."), nameBuf);
1870             return FALSE;
1871         }
1872     }
1873     // Semicolon
1874     if (!wxGetResourceToken(fd))
1875     {
1876         *eof = TRUE;
1877     }
1878     return TRUE;
1879 }
1880
1881 bool wxResourceReadOneResource(wxInputStream *fd, wxExprDatabase& db, bool *eof, wxResourceTable *table)
1882 {
1883     if (!table)
1884         table = wxDefaultResourceTable;
1885
1886     // static or #define
1887     if (!wxGetResourceToken(fd))
1888     {
1889         *eof = TRUE;
1890         return FALSE;
1891     }
1892
1893     if (strcmp(wxResourceBuffer, "#define") == 0)
1894     {
1895         wxGetResourceToken(fd);
1896         wxChar *name = copystring(wxConvLibc.cMB2WX(wxResourceBuffer));
1897         wxGetResourceToken(fd);
1898         wxChar *value = copystring(wxConvLibc.cMB2WX(wxResourceBuffer));
1899         if (wxIsalpha(value[0]))
1900         {
1901             int val = (int)wxAtol(value);
1902             wxResourceAddIdentifier(name, val, table);
1903         }
1904         else
1905         {
1906             wxLogWarning(_("#define %s must be an integer."), name);
1907             delete[] name;
1908             delete[] value;
1909             return FALSE;
1910         }
1911         delete[] name;
1912         delete[] value;
1913
1914         return TRUE;
1915     }
1916     else if (strcmp(wxResourceBuffer, "#include") == 0)
1917     {
1918         wxGetResourceToken(fd);
1919         wxChar *name = copystring(wxConvLibc.cMB2WX(wxResourceBuffer));
1920         wxChar *actualName = name;
1921         if (name[0] == wxT('"'))
1922             actualName = name + 1;
1923         int len = wxStrlen(name);
1924         if ((len > 0) && (name[len-1] == wxT('"')))
1925             name[len-1] = 0;
1926         if (!wxResourceParseIncludeFile(actualName, table))
1927         {
1928             wxLogWarning(_("Could not find resource include file %s."), actualName);
1929         }
1930         delete[] name;
1931         return TRUE;
1932     }
1933     else if (strcmp(wxResourceBuffer, "static") != 0)
1934     {
1935         wxChar buf[300];
1936         wxStrcpy(buf, _("Found "));
1937         wxStrncat(buf, wxConvLibc.cMB2WX(wxResourceBuffer), 30);
1938         wxStrcat(buf, _(", expected static, #include or #define\nwhilst parsing resource."));
1939         wxLogWarning(buf);
1940         return FALSE;
1941     }
1942
1943     // char
1944     if (!wxGetResourceToken(fd))
1945     {
1946         wxLogWarning(_("Unexpected end of file whilst parsing resource."));
1947         *eof = TRUE;
1948         return FALSE;
1949     }
1950
1951     if (strcmp(wxResourceBuffer, "char") != 0)
1952     {
1953         wxLogWarning(_("Expected 'char' whilst parsing resource."));
1954         return FALSE;
1955     }
1956
1957     // *name
1958     if (!wxGetResourceToken(fd))
1959     {
1960         wxLogWarning(_("Unexpected end of file whilst parsing resource."));
1961         *eof = TRUE;
1962         return FALSE;
1963     }
1964
1965     if (wxResourceBuffer[0] != '*')
1966     {
1967         wxLogWarning(_("Expected '*' whilst parsing resource."));
1968         return FALSE;
1969     }
1970     char nameBuf[100];
1971     strncpy(nameBuf, wxResourceBuffer+1, 99);
1972
1973     // =
1974     if (!wxGetResourceToken(fd))
1975     {
1976         wxLogWarning(_("Unexpected end of file whilst parsing resource."));
1977         *eof = TRUE;
1978         return FALSE;
1979     }
1980
1981     if (strcmp(wxResourceBuffer, "=") != 0)
1982     {
1983         wxLogWarning(_("Expected '=' whilst parsing resource."));
1984         return FALSE;
1985     }
1986
1987     // String
1988     if (!wxGetResourceToken(fd))
1989     {
1990         wxLogWarning(_("Unexpected end of file whilst parsing resource."));
1991         *eof = TRUE;
1992         return FALSE;
1993     }
1994     else
1995     {
1996         if (!db.ReadPrologFromString(wxResourceBuffer))
1997         {
1998             wxLogWarning(_("%s: ill-formed resource file syntax."), nameBuf);
1999             return FALSE;
2000         }
2001     }
2002     // Semicolon
2003     if (!wxGetResourceToken(fd))
2004     {
2005         *eof = TRUE;
2006     }
2007     return TRUE;
2008 }
2009
2010 /*
2011 * Parses string window style into integer window style
2012 */
2013
2014 /*
2015 * Style flag parsing, e.g.
2016 * "wxSYSTEM_MENU | wxBORDER" -> integer
2017 */
2018
2019 wxChar* wxResourceParseWord(wxChar*s, int *i)
2020 {
2021     if (!s)
2022         return (wxChar*) NULL;
2023
2024     static wxChar buf[150];
2025     int len = wxStrlen(s);
2026     int j = 0;
2027     int ii = *i;
2028     while ((ii < len) && (wxIsalpha(s[ii]) || (s[ii] == wxT('_'))))
2029     {
2030         buf[j] = s[ii];
2031         j ++;
2032         ii ++;
2033     }
2034     buf[j] = 0;
2035
2036     // Eat whitespace and conjunction characters
2037     while ((ii < len) &&
2038         ((s[ii] == wxT(' ')) || (s[ii] == wxT('|')) || (s[ii] == wxT(','))))
2039     {
2040         ii ++;
2041     }
2042     *i = ii;
2043     if (j == 0)
2044         return (wxChar*) NULL;
2045     else
2046         return buf;
2047 }
2048
2049 struct wxResourceBitListStruct
2050 {
2051     wxChar *word;
2052     long bits;
2053 };
2054
2055 static wxResourceBitListStruct wxResourceBitListTable[] =
2056 {
2057     /* wxListBox */
2058     { wxT("wxSINGLE"), wxLB_SINGLE },
2059     { wxT("wxMULTIPLE"), wxLB_MULTIPLE },
2060     { wxT("wxEXTENDED"), wxLB_EXTENDED },
2061     { wxT("wxLB_SINGLE"), wxLB_SINGLE },
2062     { wxT("wxLB_MULTIPLE"), wxLB_MULTIPLE },
2063     { wxT("wxLB_EXTENDED"), wxLB_EXTENDED },
2064     { wxT("wxLB_NEEDED_SB"), wxLB_NEEDED_SB },
2065     { wxT("wxLB_ALWAYS_SB"), wxLB_ALWAYS_SB },
2066     { wxT("wxLB_SORT"), wxLB_SORT },
2067     { wxT("wxLB_OWNERDRAW"), wxLB_OWNERDRAW },
2068     { wxT("wxLB_HSCROLL"), wxLB_HSCROLL },
2069
2070     /* wxComboxBox */
2071     { wxT("wxCB_SIMPLE"), wxCB_SIMPLE },
2072     { wxT("wxCB_DROPDOWN"), wxCB_DROPDOWN },
2073     { wxT("wxCB_READONLY"), wxCB_READONLY },
2074     { wxT("wxCB_SORT"), wxCB_SORT },
2075
2076     /* wxGauge */
2077     { wxT("wxGA_PROGRESSBAR"), wxGA_PROGRESSBAR },
2078     { wxT("wxGA_HORIZONTAL"), wxGA_HORIZONTAL },
2079     { wxT("wxGA_VERTICAL"), wxGA_VERTICAL },
2080
2081     /* wxTextCtrl */
2082     { wxT("wxPASSWORD"), wxPASSWORD},
2083     { wxT("wxPROCESS_ENTER"), wxPROCESS_ENTER},
2084     { wxT("wxTE_PASSWORD"), wxTE_PASSWORD},
2085     { wxT("wxTE_READONLY"), wxTE_READONLY},
2086     { wxT("wxTE_PROCESS_ENTER"), wxTE_PROCESS_ENTER},
2087     { wxT("wxTE_MULTILINE"), wxTE_MULTILINE},
2088     { wxT("wxTE_NO_VSCROLL"), wxTE_NO_VSCROLL},
2089
2090     /* wxRadioBox/wxRadioButton */
2091     { wxT("wxRB_GROUP"), wxRB_GROUP },
2092     { wxT("wxRA_SPECIFY_COLS"), wxRA_SPECIFY_COLS },
2093     { wxT("wxRA_SPECIFY_ROWS"), wxRA_SPECIFY_ROWS },
2094     { wxT("wxRA_HORIZONTAL"), wxRA_HORIZONTAL },
2095     { wxT("wxRA_VERTICAL"), wxRA_VERTICAL },
2096
2097     /* wxSlider */
2098     { wxT("wxSL_HORIZONTAL"), wxSL_HORIZONTAL },
2099     { wxT("wxSL_VERTICAL"), wxSL_VERTICAL },
2100     { wxT("wxSL_AUTOTICKS"), wxSL_AUTOTICKS },
2101     { wxT("wxSL_LABELS"), wxSL_LABELS },
2102     { wxT("wxSL_LEFT"), wxSL_LEFT },
2103     { wxT("wxSL_TOP"), wxSL_TOP },
2104     { wxT("wxSL_RIGHT"), wxSL_RIGHT },
2105     { wxT("wxSL_BOTTOM"), wxSL_BOTTOM },
2106     { wxT("wxSL_BOTH"), wxSL_BOTH },
2107     { wxT("wxSL_SELRANGE"), wxSL_SELRANGE },
2108
2109     /* wxScrollBar */
2110     { wxT("wxSB_HORIZONTAL"), wxSB_HORIZONTAL },
2111     { wxT("wxSB_VERTICAL"), wxSB_VERTICAL },
2112
2113     /* wxButton */
2114     { wxT("wxBU_AUTODRAW"), wxBU_AUTODRAW },
2115     { wxT("wxBU_NOAUTODRAW"), wxBU_NOAUTODRAW },
2116
2117     /* wxTreeCtrl */
2118     { wxT("wxTR_HAS_BUTTONS"), wxTR_HAS_BUTTONS },
2119     { wxT("wxTR_EDIT_LABELS"), wxTR_EDIT_LABELS },
2120     { wxT("wxTR_LINES_AT_ROOT"), wxTR_LINES_AT_ROOT },
2121
2122     /* wxListCtrl */
2123     { wxT("wxLC_ICON"), wxLC_ICON },
2124     { wxT("wxLC_SMALL_ICON"), wxLC_SMALL_ICON },
2125     { wxT("wxLC_LIST"), wxLC_LIST },
2126     { wxT("wxLC_REPORT"), wxLC_REPORT },
2127     { wxT("wxLC_ALIGN_TOP"), wxLC_ALIGN_TOP },
2128     { wxT("wxLC_ALIGN_LEFT"), wxLC_ALIGN_LEFT },
2129     { wxT("wxLC_AUTOARRANGE"), wxLC_AUTOARRANGE },
2130     { wxT("wxLC_USER_TEXT"), wxLC_USER_TEXT },
2131     { wxT("wxLC_EDIT_LABELS"), wxLC_EDIT_LABELS },
2132     { wxT("wxLC_NO_HEADER"), wxLC_NO_HEADER },
2133     { wxT("wxLC_NO_SORT_HEADER"), wxLC_NO_SORT_HEADER },
2134     { wxT("wxLC_SINGLE_SEL"), wxLC_SINGLE_SEL },
2135     { wxT("wxLC_SORT_ASCENDING"), wxLC_SORT_ASCENDING },
2136     { wxT("wxLC_SORT_DESCENDING"), wxLC_SORT_DESCENDING },
2137
2138     /* wxSpinButton */
2139     { wxT("wxSP_VERTICAL"), wxSP_VERTICAL},
2140     { wxT("wxSP_HORIZONTAL"), wxSP_HORIZONTAL},
2141     { wxT("wxSP_ARROW_KEYS"), wxSP_ARROW_KEYS},
2142     { wxT("wxSP_WRAP"), wxSP_WRAP},
2143
2144     /* wxSplitterWnd */
2145     { wxT("wxSP_NOBORDER"), wxSP_NOBORDER},
2146     { wxT("wxSP_3D"), wxSP_3D},
2147     { wxT("wxSP_BORDER"), wxSP_BORDER},
2148
2149     /* wxTabCtrl */
2150     { wxT("wxTC_MULTILINE"), wxTC_MULTILINE},
2151     { wxT("wxTC_RIGHTJUSTIFY"), wxTC_RIGHTJUSTIFY},
2152     { wxT("wxTC_FIXEDWIDTH"), wxTC_FIXEDWIDTH},
2153     { wxT("wxTC_OWNERDRAW"), wxTC_OWNERDRAW},
2154
2155     /* wxStatusBar95 */
2156     { wxT("wxST_SIZEGRIP"), wxST_SIZEGRIP},
2157
2158     /* wxControl */
2159     { wxT("wxFIXED_LENGTH"), wxFIXED_LENGTH},
2160     { wxT("wxALIGN_LEFT"), wxALIGN_LEFT},
2161     { wxT("wxALIGN_CENTER"), wxALIGN_CENTER},
2162     { wxT("wxALIGN_CENTRE"), wxALIGN_CENTRE},
2163     { wxT("wxALIGN_RIGHT"), wxALIGN_RIGHT},
2164     { wxT("wxCOLOURED"), wxCOLOURED},
2165
2166     /* wxToolBar */
2167     { wxT("wxTB_3DBUTTONS"), wxTB_3DBUTTONS},
2168     { wxT("wxTB_HORIZONTAL"), wxTB_HORIZONTAL},
2169     { wxT("wxTB_VERTICAL"), wxTB_VERTICAL},
2170     { wxT("wxTB_FLAT"), wxTB_FLAT},
2171
2172     /* wxDialog */
2173     { wxT("wxDIALOG_MODAL"), wxDIALOG_MODAL },
2174
2175     /* Generic */
2176     { wxT("wxVSCROLL"), wxVSCROLL },
2177     { wxT("wxHSCROLL"), wxHSCROLL },
2178     { wxT("wxCAPTION"), wxCAPTION },
2179     { wxT("wxSTAY_ON_TOP"), wxSTAY_ON_TOP},
2180     { wxT("wxICONIZE"), wxICONIZE},
2181     { wxT("wxMINIMIZE"), wxICONIZE},
2182     { wxT("wxMAXIMIZE"), wxMAXIMIZE},
2183     { wxT("wxSDI"), 0},
2184     { wxT("wxMDI_PARENT"), 0},
2185     { wxT("wxMDI_CHILD"), 0},
2186     { wxT("wxTHICK_FRAME"), wxTHICK_FRAME},
2187     { wxT("wxRESIZE_BORDER"), wxRESIZE_BORDER},
2188     { wxT("wxSYSTEM_MENU"), wxSYSTEM_MENU},
2189     { wxT("wxMINIMIZE_BOX"), wxMINIMIZE_BOX},
2190     { wxT("wxMAXIMIZE_BOX"), wxMAXIMIZE_BOX},
2191     { wxT("wxRESIZE_BOX"), wxRESIZE_BOX},
2192     { wxT("wxDEFAULT_FRAME_STYLE"), wxDEFAULT_FRAME_STYLE},
2193     { wxT("wxDEFAULT_FRAME"), wxDEFAULT_FRAME_STYLE},
2194     { wxT("wxDEFAULT_DIALOG_STYLE"), wxDEFAULT_DIALOG_STYLE},
2195     { wxT("wxBORDER"), wxBORDER},
2196     { wxT("wxRETAINED"), wxRETAINED},
2197     { wxT("wxNATIVE_IMPL"), 0},
2198     { wxT("wxEXTENDED_IMPL"), 0},
2199     { wxT("wxBACKINGSTORE"), wxBACKINGSTORE},
2200     //  { wxT("wxFLAT"), wxFLAT},
2201     //  { wxT("wxMOTIF_RESIZE"), wxMOTIF_RESIZE},
2202     { wxT("wxFIXED_LENGTH"), 0},
2203     { wxT("wxDOUBLE_BORDER"), wxDOUBLE_BORDER},
2204     { wxT("wxSUNKEN_BORDER"), wxSUNKEN_BORDER},
2205     { wxT("wxRAISED_BORDER"), wxRAISED_BORDER},
2206     { wxT("wxSIMPLE_BORDER"), wxSIMPLE_BORDER},
2207     { wxT("wxSTATIC_BORDER"), wxSTATIC_BORDER},
2208     { wxT("wxTRANSPARENT_WINDOW"), wxTRANSPARENT_WINDOW},
2209     { wxT("wxNO_BORDER"), wxNO_BORDER},
2210     { wxT("wxCLIP_CHILDREN"), wxCLIP_CHILDREN},
2211     { wxT("wxCLIP_SIBLINGS"), wxCLIP_SIBLINGS},
2212     { wxT("wxTAB_TRAVERSAL"), 0}, // Compatibility only
2213
2214     { wxT("wxTINY_CAPTION_HORIZ"), wxTINY_CAPTION_HORIZ},
2215     { wxT("wxTINY_CAPTION_VERT"), wxTINY_CAPTION_VERT},
2216
2217     // Text font families
2218     { wxT("wxDEFAULT"), wxDEFAULT},
2219     { wxT("wxDECORATIVE"), wxDECORATIVE},
2220     { wxT("wxROMAN"), wxROMAN},
2221     { wxT("wxSCRIPT"), wxSCRIPT},
2222     { wxT("wxSWISS"), wxSWISS},
2223     { wxT("wxMODERN"), wxMODERN},
2224     { wxT("wxTELETYPE"), wxTELETYPE},
2225     { wxT("wxVARIABLE"), wxVARIABLE},
2226     { wxT("wxFIXED"), wxFIXED},
2227     { wxT("wxNORMAL"), wxNORMAL},
2228     { wxT("wxLIGHT"), wxLIGHT},
2229     { wxT("wxBOLD"), wxBOLD},
2230     { wxT("wxITALIC"), wxITALIC},
2231     { wxT("wxSLANT"), wxSLANT},
2232     { wxT("wxSOLID"), wxSOLID},
2233     { wxT("wxDOT"), wxDOT},
2234     { wxT("wxLONG_DASH"), wxLONG_DASH},
2235     { wxT("wxSHORT_DASH"), wxSHORT_DASH},
2236     { wxT("wxDOT_DASH"), wxDOT_DASH},
2237     { wxT("wxUSER_DASH"), wxUSER_DASH},
2238     { wxT("wxTRANSPARENT"), wxTRANSPARENT},
2239     { wxT("wxSTIPPLE"), wxSTIPPLE},
2240     { wxT("wxBDIAGONAL_HATCH"), wxBDIAGONAL_HATCH},
2241     { wxT("wxCROSSDIAG_HATCH"), wxCROSSDIAG_HATCH},
2242     { wxT("wxFDIAGONAL_HATCH"), wxFDIAGONAL_HATCH},
2243     { wxT("wxCROSS_HATCH"), wxCROSS_HATCH},
2244     { wxT("wxHORIZONTAL_HATCH"), wxHORIZONTAL_HATCH},
2245     { wxT("wxVERTICAL_HATCH"), wxVERTICAL_HATCH},
2246     { wxT("wxJOIN_BEVEL"), wxJOIN_BEVEL},
2247     { wxT("wxJOIN_MITER"), wxJOIN_MITER},
2248     { wxT("wxJOIN_ROUND"), wxJOIN_ROUND},
2249     { wxT("wxCAP_ROUND"), wxCAP_ROUND},
2250     { wxT("wxCAP_PROJECTING"), wxCAP_PROJECTING},
2251     { wxT("wxCAP_BUTT"), wxCAP_BUTT},
2252
2253     // Logical ops
2254     { wxT("wxCLEAR"), wxCLEAR},
2255     { wxT("wxXOR"), wxXOR},
2256     { wxT("wxINVERT"), wxINVERT},
2257     { wxT("wxOR_REVERSE"), wxOR_REVERSE},
2258     { wxT("wxAND_REVERSE"), wxAND_REVERSE},
2259     { wxT("wxCOPY"), wxCOPY},
2260     { wxT("wxAND"), wxAND},
2261     { wxT("wxAND_INVERT"), wxAND_INVERT},
2262     { wxT("wxNO_OP"), wxNO_OP},
2263     { wxT("wxNOR"), wxNOR},
2264     { wxT("wxEQUIV"), wxEQUIV},
2265     { wxT("wxSRC_INVERT"), wxSRC_INVERT},
2266     { wxT("wxOR_INVERT"), wxOR_INVERT},
2267     { wxT("wxNAND"), wxNAND},
2268     { wxT("wxOR"), wxOR},
2269     { wxT("wxSET"), wxSET},
2270
2271     { wxT("wxFLOOD_SURFACE"), wxFLOOD_SURFACE},
2272     { wxT("wxFLOOD_BORDER"), wxFLOOD_BORDER},
2273     { wxT("wxODDEVEN_RULE"), wxODDEVEN_RULE},
2274     { wxT("wxWINDING_RULE"), wxWINDING_RULE},
2275     { wxT("wxHORIZONTAL"), wxHORIZONTAL},
2276     { wxT("wxVERTICAL"), wxVERTICAL},
2277     { wxT("wxBOTH"), wxBOTH},
2278     { wxT("wxCENTER_FRAME"), wxCENTER_FRAME},
2279     { wxT("wxOK"), wxOK},
2280     { wxT("wxYES_NO"), wxYES_NO},
2281     { wxT("wxCANCEL"), wxCANCEL},
2282     { wxT("wxYES"), wxYES},
2283     { wxT("wxNO"), wxNO},
2284     { wxT("wxICON_EXCLAMATION"), wxICON_EXCLAMATION},
2285     { wxT("wxICON_HAND"), wxICON_HAND},
2286     { wxT("wxICON_QUESTION"), wxICON_QUESTION},
2287     { wxT("wxICON_INFORMATION"), wxICON_INFORMATION},
2288     { wxT("wxICON_STOP"), wxICON_STOP},
2289     { wxT("wxICON_ASTERISK"), wxICON_ASTERISK},
2290     { wxT("wxICON_MASK"), wxICON_MASK},
2291     { wxT("wxCENTRE"), wxCENTRE},
2292     { wxT("wxCENTER"), wxCENTRE},
2293     { wxT("wxUSER_COLOURS"), wxUSER_COLOURS},
2294     { wxT("wxVERTICAL_LABEL"), 0},
2295     { wxT("wxHORIZONTAL_LABEL"), 0},
2296
2297     // Bitmap types (not strictly styles)
2298     { wxT("wxBITMAP_TYPE_XPM"), wxBITMAP_TYPE_XPM},
2299     { wxT("wxBITMAP_TYPE_XBM"), wxBITMAP_TYPE_XBM},
2300     { wxT("wxBITMAP_TYPE_BMP"), wxBITMAP_TYPE_BMP},
2301     { wxT("wxBITMAP_TYPE_RESOURCE"), wxBITMAP_TYPE_BMP_RESOURCE},
2302     { wxT("wxBITMAP_TYPE_BMP_RESOURCE"), wxBITMAP_TYPE_BMP_RESOURCE},
2303     { wxT("wxBITMAP_TYPE_GIF"), wxBITMAP_TYPE_GIF},
2304     { wxT("wxBITMAP_TYPE_TIF"), wxBITMAP_TYPE_TIF},
2305     { wxT("wxBITMAP_TYPE_ICO"), wxBITMAP_TYPE_ICO},
2306     { wxT("wxBITMAP_TYPE_ICO_RESOURCE"), wxBITMAP_TYPE_ICO_RESOURCE},
2307     { wxT("wxBITMAP_TYPE_CUR"), wxBITMAP_TYPE_CUR},
2308     { wxT("wxBITMAP_TYPE_CUR_RESOURCE"), wxBITMAP_TYPE_CUR_RESOURCE},
2309     { wxT("wxBITMAP_TYPE_XBM_DATA"), wxBITMAP_TYPE_XBM_DATA},
2310     { wxT("wxBITMAP_TYPE_XPM_DATA"), wxBITMAP_TYPE_XPM_DATA},
2311     { wxT("wxBITMAP_TYPE_ANY"), wxBITMAP_TYPE_ANY}
2312 };
2313
2314 static int wxResourceBitListCount = (sizeof(wxResourceBitListTable)/sizeof(wxResourceBitListStruct));
2315
2316 long wxParseWindowStyle(const wxString& bitListString)
2317 {
2318     int i = 0;
2319     wxChar *word;
2320     long bitList = 0;
2321     word = wxResourceParseWord(WXSTRINGCAST bitListString, &i);
2322     while (word != NULL)
2323     {
2324         bool found = FALSE;
2325         int j;
2326         for (j = 0; j < wxResourceBitListCount; j++)
2327             if (wxStrcmp(wxResourceBitListTable[j].word, word) == 0)
2328             {
2329                 bitList |= wxResourceBitListTable[j].bits;
2330                 found = TRUE;
2331                 break;
2332             }
2333             if (!found)
2334             {
2335                 wxLogWarning(_("Unrecognized style %s whilst parsing resource."), word);
2336                 return 0;
2337             }
2338             word = wxResourceParseWord(WXSTRINGCAST bitListString, &i);
2339     }
2340     return bitList;
2341 }
2342
2343 /*
2344 * Load a bitmap from a wxWindows resource, choosing an optimum
2345 * depth and appropriate type.
2346 */
2347
2348 wxBitmap wxResourceCreateBitmap(const wxString& resource, wxResourceTable *table)
2349 {
2350     if (!table)
2351         table = wxDefaultResourceTable;
2352
2353     wxItemResource *item = table->FindResource(resource);
2354     if (item)
2355     {
2356         if ((item->GetType() == wxT("")) || (item->GetType() != wxT("wxBitmap")))
2357         {
2358             wxLogWarning(_("%s not a bitmap resource specification."), (const wxChar*) resource);
2359             return wxNullBitmap;
2360         }
2361         int thisDepth = wxDisplayDepth();
2362         long thisNoColours = (long)pow(2.0, (double)thisDepth);
2363
2364         wxItemResource *optResource = (wxItemResource *) NULL;
2365
2366         // Try to find optimum bitmap for this platform/colour depth
2367         wxNode *node = item->GetChildren().First();
2368         while (node)
2369         {
2370             wxItemResource *child = (wxItemResource *)node->Data();
2371             int platform = (int)child->GetValue2();
2372             int noColours = (int)child->GetValue3();
2373             /*
2374             char *name = child->GetName();
2375             int bitmapType = (int)child->GetValue1();
2376             int xRes = child->GetWidth();
2377             int yRes = child->GetHeight();
2378             */
2379
2380             switch (platform)
2381             {
2382             case RESOURCE_PLATFORM_ANY:
2383                 {
2384                     if (!optResource && ((noColours == 0) || (noColours <= thisNoColours)))
2385                         optResource = child;
2386                     else
2387                     {
2388                         // Maximise the number of colours.
2389                         // If noColours is zero (unspecified), then assume this
2390                         // is the right one.
2391                         if ((noColours == 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3())))
2392                             optResource = child;
2393                     }
2394                     break;
2395                 }
2396 #ifdef __WXMSW__
2397             case RESOURCE_PLATFORM_WINDOWS:
2398                 {
2399                     if (!optResource && ((noColours == 0) || (noColours <= thisNoColours)))
2400                         optResource = child;
2401                     else
2402                     {
2403                         // Maximise the number of colours
2404                         if ((noColours > 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3())))
2405                             optResource = child;
2406                     }
2407                     break;
2408                 }
2409 #endif
2410 #ifdef __WXGTK__
2411             case RESOURCE_PLATFORM_X:
2412                 {
2413                     if (!optResource && ((noColours == 0) || (noColours <= thisNoColours)))
2414                         optResource = child;
2415                     else
2416                     {
2417                         // Maximise the number of colours
2418                         if ((noColours == 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3())))
2419                             optResource = child;
2420                     }
2421                     break;
2422                 }
2423 #endif
2424 #ifdef wx_max
2425             case RESOURCE_PLATFORM_MAC:
2426                 {
2427                     if (!optResource && ((noColours == 0) || (noColours <= thisNoColours)))
2428                         optResource = child;
2429                     else
2430                     {
2431                         // Maximise the number of colours
2432                         if ((noColours == 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3())))
2433                             optResource = child;
2434                     }
2435                     break;
2436                 }
2437 #endif
2438             default:
2439                 break;
2440             }
2441             node = node->Next();
2442         }
2443         // If no matching resource, fail.
2444         if (!optResource)
2445             return wxNullBitmap;
2446
2447         wxString name = optResource->GetName();
2448         int bitmapType = (int)optResource->GetValue1();
2449         switch (bitmapType)
2450         {
2451         case wxBITMAP_TYPE_XBM_DATA:
2452             {
2453 #ifdef __WXGTK__
2454                 wxItemResource *item = table->FindResource(name);
2455                 if (!item)
2456                 {
2457                     wxLogWarning(_("Failed to find XBM resource %s.\n"
2458                         "Forgot to use wxResourceLoadBitmapData?"), (const wxChar*) name);
2459                     return wxNullBitmap;
2460                 }
2461                 return wxBitmap(item->GetValue1(), (int)item->GetValue2(), (int)item->GetValue3()) ;
2462 #else
2463                 wxLogWarning(_("No XBM facility available!"));
2464                 break;
2465 #endif
2466             }
2467         case wxBITMAP_TYPE_XPM_DATA:
2468             {
2469                 wxItemResource *item = table->FindResource(name);
2470                 if (!item)
2471                 {
2472                     wxLogWarning(_("Failed to find XPM resource %s.\nForgot to use wxResourceLoadBitmapData?"), (const wxChar*) name);
2473                     return wxNullBitmap;
2474                 }
2475                 return wxBitmap((char **)item->GetValue1());
2476             }
2477         default:
2478             {
2479                 return wxBitmap(name, (wxBitmapType)bitmapType);
2480             }
2481         }
2482 #ifndef __WXGTK__
2483         return wxNullBitmap;
2484 #endif
2485   }
2486   else
2487   {
2488       wxLogWarning(_("Bitmap resource specification %s not found."), (const wxChar*) resource);
2489       return wxNullBitmap;
2490   }
2491 }
2492
2493 /*
2494 * Load an icon from a wxWindows resource, choosing an optimum
2495 * depth and appropriate type.
2496 */
2497
2498 wxIcon wxResourceCreateIcon(const wxString& resource, wxResourceTable *table)
2499 {
2500     if (!table)
2501         table = wxDefaultResourceTable;
2502
2503     wxItemResource *item = table->FindResource(resource);
2504     if (item)
2505     {
2506         if ((item->GetType() == wxT("")) || wxStrcmp(item->GetType(), wxT("wxIcon")) != 0)
2507         {
2508             wxLogWarning(_("%s not an icon resource specification."), (const wxChar*) resource);
2509             return wxNullIcon;
2510         }
2511         int thisDepth = wxDisplayDepth();
2512         long thisNoColours = (long)pow(2.0, (double)thisDepth);
2513
2514         wxItemResource *optResource = (wxItemResource *) NULL;
2515
2516         // Try to find optimum icon for this platform/colour depth
2517         wxNode *node = item->GetChildren().First();
2518         while (node)
2519         {
2520             wxItemResource *child = (wxItemResource *)node->Data();
2521             int platform = (int)child->GetValue2();
2522             int noColours = (int)child->GetValue3();
2523             /*
2524             char *name = child->GetName();
2525             int bitmapType = (int)child->GetValue1();
2526             int xRes = child->GetWidth();
2527             int yRes = child->GetHeight();
2528             */
2529
2530             switch (platform)
2531             {
2532             case RESOURCE_PLATFORM_ANY:
2533                 {
2534                     if (!optResource && ((noColours == 0) || (noColours <= thisNoColours)))
2535                         optResource = child;
2536                     else
2537                     {
2538                         // Maximise the number of colours.
2539                         // If noColours is zero (unspecified), then assume this
2540                         // is the right one.
2541                         if ((noColours == 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3())))
2542                             optResource = child;
2543                     }
2544                     break;
2545                 }
2546 #ifdef __WXMSW__
2547             case RESOURCE_PLATFORM_WINDOWS:
2548                 {
2549                     if (!optResource && ((noColours == 0) || (noColours <= thisNoColours)))
2550                         optResource = child;
2551                     else
2552                     {
2553                         // Maximise the number of colours
2554                         if ((noColours > 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3())))
2555                             optResource = child;
2556                     }
2557                     break;
2558                 }
2559 #endif
2560 #ifdef __WXGTK__
2561             case RESOURCE_PLATFORM_X:
2562                 {
2563                     if (!optResource && ((noColours == 0) || (noColours <= thisNoColours)))
2564                         optResource = child;
2565                     else
2566                     {
2567                         // Maximise the number of colours
2568                         if ((noColours == 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3())))
2569                             optResource = child;
2570                     }
2571                     break;
2572                 }
2573 #endif
2574 #ifdef wx_max
2575             case RESOURCE_PLATFORM_MAC:
2576                 {
2577                     if (!optResource && ((noColours == 0) || (noColours <= thisNoColours)))
2578                         optResource = child;
2579                     else
2580                     {
2581                         // Maximise the number of colours
2582                         if ((noColours == 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3())))
2583                             optResource = child;
2584                     }
2585                     break;
2586                 }
2587 #endif
2588             default:
2589                 break;
2590             }
2591             node = node->Next();
2592         }
2593         // If no matching resource, fail.
2594         if (!optResource)
2595             return wxNullIcon;
2596
2597         wxString name = optResource->GetName();
2598         int bitmapType = (int)optResource->GetValue1();
2599         switch (bitmapType)
2600         {
2601         case wxBITMAP_TYPE_XBM_DATA:
2602             {
2603 #ifdef __WXGTK__
2604                 wxItemResource *item = table->FindResource(name);
2605                 if (!item)
2606                 {
2607                     wxLogWarning(_("Failed to find XBM resource %s.\n"
2608                         "Forgot to use wxResourceLoadIconData?"), (const wxChar*) name);
2609                     return wxNullIcon;
2610                 }
2611                 return wxIcon((const char **)item->GetValue1(), (int)item->GetValue2(), (int)item->GetValue3());
2612 #else
2613                 wxLogWarning(_("No XBM facility available!"));
2614                 break;
2615 #endif
2616             }
2617         case wxBITMAP_TYPE_XPM_DATA:
2618             {
2619                 // *** XPM ICON NOT YET IMPLEMENTED IN WXWINDOWS ***
2620                 /*
2621                 wxItemResource *item = table->FindResource(name);
2622                 if (!item)
2623                 {
2624                 char buf[400];
2625                 sprintf(buf, _("Failed to find XPM resource %s.\nForgot to use wxResourceLoadIconData?"), name);
2626                 wxLogWarning(buf);
2627                 return NULL;
2628                 }
2629                 return wxIcon((char **)item->GetValue1());
2630                 */
2631                 wxLogWarning(_("No XPM icon facility available!"));
2632                 break;
2633             }
2634         default:
2635             {
2636 #ifdef __WXGTK__
2637                 wxLogWarning(_("Icon resource specification %s not found."), (const wxChar*) resource);
2638                 break;
2639 #else
2640                 return wxIcon(name, bitmapType);
2641 #endif
2642             }
2643         }
2644         return wxNullIcon;
2645   }
2646   else
2647   {
2648       wxLogWarning(_("Icon resource specification %s not found."), (const wxChar*) resource);
2649       return wxNullIcon;
2650   }
2651 }
2652
2653 #if wxUSE_MENUS
2654
2655 wxMenu *wxResourceCreateMenu(wxItemResource *item)
2656 {
2657     wxMenu *menu = new wxMenu;
2658     wxNode *node = item->GetChildren().First();
2659     while (node)
2660     {
2661         wxItemResource *child = (wxItemResource *)node->Data();
2662         if ((child->GetType() != wxT("")) && (child->GetType() == wxT("wxMenuSeparator")))
2663             menu->AppendSeparator();
2664         else if (child->GetChildren().Number() > 0)
2665         {
2666             wxMenu *subMenu = wxResourceCreateMenu(child);
2667             if (subMenu)
2668                 menu->Append((int)child->GetValue1(), child->GetTitle(), subMenu, child->GetValue4());
2669         }
2670         else
2671         {
2672             menu->Append((int)child->GetValue1(), child->GetTitle(), child->GetValue4(), (child->GetValue2() != 0));
2673         }
2674         node = node->Next();
2675     }
2676     return menu;
2677 }
2678
2679 wxMenuBar *wxResourceCreateMenuBar(const wxString& resource, wxResourceTable *table, wxMenuBar *menuBar)
2680 {
2681     if (!table)
2682         table = wxDefaultResourceTable;
2683
2684     wxItemResource *menuResource = table->FindResource(resource);
2685     if (menuResource && (menuResource->GetType() != wxT("")) && (menuResource->GetType() == wxT("wxMenu")))
2686     {
2687         if (!menuBar)
2688             menuBar = new wxMenuBar;
2689         wxNode *node = menuResource->GetChildren().First();
2690         while (node)
2691         {
2692             wxItemResource *child = (wxItemResource *)node->Data();
2693             wxMenu *menu = wxResourceCreateMenu(child);
2694             if (menu)
2695                 menuBar->Append(menu, child->GetTitle());
2696             node = node->Next();
2697         }
2698         return menuBar;
2699     }
2700     return (wxMenuBar *) NULL;
2701 }
2702
2703 wxMenu *wxResourceCreateMenu(const wxString& resource, wxResourceTable *table)
2704 {
2705     if (!table)
2706         table = wxDefaultResourceTable;
2707
2708     wxItemResource *menuResource = table->FindResource(resource);
2709     if (menuResource && (menuResource->GetType() != wxT("")) && (menuResource->GetType() == wxT("wxMenu")))
2710         //  if (menuResource && (menuResource->GetType() == wxTYPE_MENU))
2711         return wxResourceCreateMenu(menuResource);
2712     return (wxMenu *) NULL;
2713 }
2714
2715 #endif // wxUSE_MENUS
2716
2717 // Global equivalents (so don't have to refer to default table explicitly)
2718 bool wxResourceParseData(const wxString& resource, wxResourceTable *table)
2719 {
2720     if (!table)
2721         table = wxDefaultResourceTable;
2722
2723     return table->ParseResourceData(resource);
2724 }
2725
2726 bool wxResourceParseFile(const wxString& filename, wxResourceTable *table)
2727 {
2728     if (!table)
2729         table = wxDefaultResourceTable;
2730
2731     return table->ParseResourceFile(filename);
2732 }
2733
2734 // Register XBM/XPM data
2735 bool wxResourceRegisterBitmapData(const wxString& name, char bits[], int width, int height, wxResourceTable *table)
2736 {
2737     if (!table)
2738         table = wxDefaultResourceTable;
2739
2740     return table->RegisterResourceBitmapData(name, bits, width, height);
2741 }
2742
2743 bool wxResourceRegisterBitmapData(const wxString& name, char **data, wxResourceTable *table)
2744 {
2745     if (!table)
2746         table = wxDefaultResourceTable;
2747
2748     return table->RegisterResourceBitmapData(name, data);
2749 }
2750
2751 void wxResourceClear(wxResourceTable *table)
2752 {
2753     if (!table)
2754         table = wxDefaultResourceTable;
2755
2756     table->ClearTable();
2757 }
2758
2759 /*
2760 * Identifiers
2761 */
2762
2763 bool wxResourceAddIdentifier(const wxString& name, int value, wxResourceTable *table)
2764 {
2765     if (!table)
2766         table = wxDefaultResourceTable;
2767
2768     table->identifiers.Put(name, (wxObject *)(long)value);
2769     return TRUE;
2770 }
2771
2772 int wxResourceGetIdentifier(const wxString& name, wxResourceTable *table)
2773 {
2774     if (!table)
2775         table = wxDefaultResourceTable;
2776
2777     return (int)(long)table->identifiers.Get(name);
2778 }
2779
2780 /*
2781 * Parse #include file for #defines (only)
2782 */
2783
2784 bool wxResourceParseIncludeFile(const wxString& f, wxResourceTable *table)
2785 {
2786     if (!table)
2787         table = wxDefaultResourceTable;
2788
2789     FILE *fd = wxFopen(f, _T("r"));
2790     if (!fd)
2791     {
2792         return FALSE;
2793     }
2794     while (wxGetResourceToken(fd))
2795     {
2796         if (strcmp(wxResourceBuffer, "#define") == 0)
2797         {
2798             wxGetResourceToken(fd);
2799             wxChar *name = copystring(wxConvCurrent->cMB2WX(wxResourceBuffer));
2800             wxGetResourceToken(fd);
2801             wxChar *value = copystring(wxConvCurrent->cMB2WX(wxResourceBuffer));
2802             if (wxIsdigit(value[0]))
2803             {
2804                 int val = (int)wxAtol(value);
2805                 wxResourceAddIdentifier(name, val, table);
2806             }
2807             delete[] name;
2808             delete[] value;
2809         }
2810     }
2811     fclose(fd);
2812     return TRUE;
2813 }
2814
2815 /*
2816 * Reading strings as if they were .wxr files
2817 */
2818
2819 static int getc_string(char *s)
2820 {
2821     int ch = s[wxResourceStringPtr];
2822     if (ch == 0)
2823         return EOF;
2824     else
2825     {
2826         wxResourceStringPtr ++;
2827         return ch;
2828     }
2829 }
2830
2831 static int ungetc_string()
2832 {
2833     wxResourceStringPtr --;
2834     return 0;
2835 }
2836
2837 bool wxEatWhiteSpaceString(char *s)
2838 {
2839     int ch = 0;
2840
2841     while ((ch = getc_string(s)) != EOF)
2842     {
2843         switch (ch)
2844         {
2845         case ' ':
2846         case 0x0a:
2847         case 0x0d:
2848         case 0x09:
2849             break;
2850         case '/':
2851             {
2852                 int prev_ch = ch;
2853                 ch = getc_string(s);
2854                 if (ch == EOF)
2855                 {
2856                     ungetc_string();
2857                     return TRUE;
2858                 }
2859
2860                 if (ch == '*')
2861                 {
2862                     // Eat C comment
2863                     prev_ch = 0;
2864                     while ((ch = getc_string(s)) != EOF)
2865                     {
2866                         if (ch == '/' && prev_ch == '*')
2867                             break;
2868                         prev_ch = ch;
2869                     }
2870                 }
2871                 else
2872                 {
2873                     ungetc_string();
2874                     ungetc_string();
2875                     return TRUE;
2876                 }
2877             }
2878             break;
2879         default:
2880             ungetc_string();
2881             return TRUE;
2882
2883         }
2884     }
2885     return FALSE;
2886 }
2887
2888 bool wxGetResourceTokenString(char *s)
2889 {
2890     if (!wxResourceBuffer)
2891         wxReallocateResourceBuffer();
2892     wxResourceBuffer[0] = 0;
2893     wxEatWhiteSpaceString(s);
2894
2895     int ch = getc_string(s);
2896     if (ch == '"')
2897     {
2898         // Get string
2899         wxResourceBufferCount = 0;
2900         ch = getc_string(s);
2901         while (ch != '"')
2902         {
2903             int actualCh = ch;
2904             if (ch == EOF)
2905             {
2906                 wxResourceBuffer[wxResourceBufferCount] = 0;
2907                 return FALSE;
2908             }
2909             // Escaped characters
2910             else if (ch == '\\')
2911             {
2912                 int newCh = getc_string(s);
2913                 if (newCh == '"')
2914                     actualCh = '"';
2915                 else if (newCh == 10)
2916                     actualCh = 10;
2917                 else
2918                 {
2919                     ungetc_string();
2920                 }
2921             }
2922
2923             if (wxResourceBufferCount >= wxResourceBufferSize-1)
2924                 wxReallocateResourceBuffer();
2925             wxResourceBuffer[wxResourceBufferCount] = (char)actualCh;
2926             wxResourceBufferCount ++;
2927             ch = getc_string(s);
2928         }
2929         wxResourceBuffer[wxResourceBufferCount] = 0;
2930     }
2931     else
2932     {
2933         wxResourceBufferCount = 0;
2934         // Any other token
2935         while (ch != ' ' && ch != EOF && ch != ' ' && ch != 13 && ch != 9 && ch != 10)
2936         {
2937             if (wxResourceBufferCount >= wxResourceBufferSize-1)
2938                 wxReallocateResourceBuffer();
2939             wxResourceBuffer[wxResourceBufferCount] = (char)ch;
2940             wxResourceBufferCount ++;
2941
2942             ch = getc_string(s);
2943         }
2944         wxResourceBuffer[wxResourceBufferCount] = 0;
2945         if (ch == EOF)
2946             return FALSE;
2947     }
2948     return TRUE;
2949 }
2950
2951 /*
2952 * Files are in form:
2953 static char *name = "....";
2954 with possible comments.
2955 */
2956
2957 bool wxResourceReadOneResourceString(char *s, wxExprDatabase& db, bool *eof, wxResourceTable *table)
2958 {
2959     if (!table)
2960         table = wxDefaultResourceTable;
2961
2962     // static or #define
2963     if (!wxGetResourceTokenString(s))
2964     {
2965         *eof = TRUE;
2966         return FALSE;
2967     }
2968
2969     if (strcmp(wxResourceBuffer, "#define") == 0)
2970     {
2971         wxGetResourceTokenString(s);
2972         wxChar *name = copystring(wxConvCurrent->cMB2WX(wxResourceBuffer));
2973         wxGetResourceTokenString(s);
2974         wxChar *value = copystring(wxConvCurrent->cMB2WX(wxResourceBuffer));
2975         if (wxIsdigit(value[0]))
2976         {
2977             int val = (int)wxAtol(value);
2978             wxResourceAddIdentifier(name, val, table);
2979         }
2980         else
2981         {
2982             wxLogWarning(_("#define %s must be an integer."), name);
2983             delete[] name;
2984             delete[] value;
2985             return FALSE;
2986         }
2987         delete[] name;
2988         delete[] value;
2989
2990         return TRUE;
2991     }
2992     /*
2993     else if (strcmp(wxResourceBuffer, "#include") == 0)
2994     {
2995     wxGetResourceTokenString(s);
2996     char *name = copystring(wxResourceBuffer);
2997     char *actualName = name;
2998     if (name[0] == '"')
2999     actualName = name + 1;
3000     int len = strlen(name);
3001     if ((len > 0) && (name[len-1] == '"'))
3002     name[len-1] = 0;
3003     if (!wxResourceParseIncludeFile(actualName, table))
3004     {
3005     char buf[400];
3006     sprintf(buf, _("Could not find resource include file %s."), actualName);
3007     wxLogWarning(buf);
3008     }
3009     delete[] name;
3010     return TRUE;
3011     }
3012     */
3013     else if (strcmp(wxResourceBuffer, "static") != 0)
3014     {
3015         wxChar buf[300];
3016         wxStrcpy(buf, _("Found "));
3017         wxStrncat(buf, wxConvCurrent->cMB2WX(wxResourceBuffer), 30);
3018         wxStrcat(buf, _(", expected static, #include or #define\nwhilst parsing resource."));
3019         wxLogWarning(buf);
3020         return FALSE;
3021     }
3022
3023     // char
3024     if (!wxGetResourceTokenString(s))
3025     {
3026         wxLogWarning(_("Unexpected end of file whilst parsing resource."));
3027         *eof = TRUE;
3028         return FALSE;
3029     }
3030
3031     if (strcmp(wxResourceBuffer, "char") != 0)
3032     {
3033         wxLogWarning(_("Expected 'char' whilst parsing resource."));
3034         return FALSE;
3035     }
3036
3037     // *name
3038     if (!wxGetResourceTokenString(s))
3039     {
3040         wxLogWarning(_("Unexpected end of file whilst parsing resource."));
3041         *eof = TRUE;
3042         return FALSE;
3043     }
3044
3045     if (wxResourceBuffer[0] != '*')
3046     {
3047         wxLogWarning(_("Expected '*' whilst parsing resource."));
3048         return FALSE;
3049     }
3050     wxChar nameBuf[100];
3051     wxMB2WX(nameBuf, wxResourceBuffer+1, 99);
3052     nameBuf[99] = 0;
3053
3054     // =
3055     if (!wxGetResourceTokenString(s))
3056     {
3057         wxLogWarning(_("Unexpected end of file whilst parsing resource."));
3058         *eof = TRUE;
3059         return FALSE;
3060     }
3061
3062     if (strcmp(wxResourceBuffer, "=") != 0)
3063     {
3064         wxLogWarning(_("Expected '=' whilst parsing resource."));
3065         return FALSE;
3066     }
3067
3068     // String
3069     if (!wxGetResourceTokenString(s))
3070     {
3071         wxLogWarning(_("Unexpected end of file whilst parsing resource."));
3072         *eof = TRUE;
3073         return FALSE;
3074     }
3075     else
3076     {
3077         if (!db.ReadPrologFromString(wxResourceBuffer))
3078         {
3079             wxLogWarning(_("%s: ill-formed resource file syntax."), nameBuf);
3080             return FALSE;
3081         }
3082     }
3083     // Semicolon
3084     if (!wxGetResourceTokenString(s))
3085     {
3086         *eof = TRUE;
3087     }
3088     return TRUE;
3089 }
3090
3091 bool wxResourceParseString(char *s, wxResourceTable *table)
3092 {
3093     if (!table)
3094         table = wxDefaultResourceTable;
3095
3096     if (!s)
3097         return FALSE;
3098
3099     // Turn backslashes into spaces
3100     if (s)
3101     {
3102         int len = strlen(s);
3103         int i;
3104         for (i = 0; i < len; i++)
3105             if (s[i] == 92 && s[i+1] == 13)
3106             {
3107                 s[i] = ' ';
3108                 s[i+1] = ' ';
3109             }
3110     }
3111
3112     wxExprDatabase db;
3113     wxResourceStringPtr = 0;
3114
3115     bool eof = FALSE;
3116     while (wxResourceReadOneResourceString(s, db, &eof, table) && !eof)
3117     {
3118         // Loop
3119     }
3120     return wxResourceInterpretResources(*table, db);
3121 }
3122
3123 /*
3124 * resource loading facility
3125 */
3126
3127 bool wxWindowBase::LoadFromResource(wxWindow *parent, const wxString& resourceName, const wxResourceTable *table)
3128 {
3129     if (!table)
3130         table = wxDefaultResourceTable;
3131
3132     wxItemResource *resource = table->FindResource((const wxChar *)resourceName);
3133     //  if (!resource || (resource->GetType() != wxTYPE_DIALOG_BOX))
3134     if (!resource || (resource->GetType() == wxT("")) ||
3135         ! ((resource->GetType() == wxT("wxDialog")) || (resource->GetType() == wxT("wxPanel"))))
3136         return FALSE;
3137
3138     wxString title(resource->GetTitle());
3139     long theWindowStyle = resource->GetStyle();
3140     bool isModal = (resource->GetValue1() != 0) ;
3141     int x = resource->GetX();
3142     int y = resource->GetY();
3143     int width = resource->GetWidth();
3144     int height = resource->GetHeight();
3145     wxString name = resource->GetName();
3146
3147     if (IsKindOf(CLASSINFO(wxDialog)))
3148     {
3149         wxDialog *dialogBox = (wxDialog *)this;
3150         long modalStyle = isModal ? wxDIALOG_MODAL : 0;
3151         if (!dialogBox->Create(parent, -1, title, wxPoint(x, y), wxSize(width, height), theWindowStyle|modalStyle, name))
3152             return FALSE;
3153
3154         // Only reset the client size if we know we're not going to do it again below.
3155         if ((resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS) == 0)
3156             dialogBox->SetClientSize(width, height);
3157     }
3158     else if (IsKindOf(CLASSINFO(wxPanel)))
3159     {
3160         wxPanel* panel = (wxPanel *)this;
3161         if (!panel->Create(parent, -1, wxPoint(x, y), wxSize(width, height), theWindowStyle | wxTAB_TRAVERSAL, name))
3162             return FALSE;
3163     }
3164     else
3165     {
3166         if (!((wxWindow *)this)->Create(parent, -1, wxPoint(x, y), wxSize(width, height), theWindowStyle, name))
3167             return FALSE;
3168     }
3169
3170     if ((resource->GetResourceStyle() & wxRESOURCE_USE_DEFAULTS) != 0)
3171     {
3172         // No need to do this since it's done in wxPanel or wxDialog constructor.
3173         // SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
3174     }
3175     else
3176     {
3177         if (resource->GetFont().Ok())
3178             SetFont(resource->GetFont());
3179         if (resource->GetBackgroundColour().Ok())
3180             SetBackgroundColour(resource->GetBackgroundColour());
3181     }
3182
3183     // Should have some kind of font at this point
3184     if (!GetFont().Ok())
3185         SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
3186     if (!GetBackgroundColour().Ok())
3187         SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
3188
3189     // Only when we've created the window and set the font can we set the correct size,
3190     // if based on dialog units.
3191     if ((resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS) != 0)
3192     {
3193         wxSize sz = ConvertDialogToPixels(wxSize(width, height));
3194         SetClientSize(sz.x, sz.y);
3195
3196         wxPoint pt = ConvertDialogToPixels(wxPoint(x, y));
3197         Move(pt.x, pt.y);
3198     }
3199
3200     // Now create children
3201     wxNode *node = resource->GetChildren().First();
3202     while (node)
3203     {
3204         wxItemResource *childResource = (wxItemResource *)node->Data();
3205
3206         (void) CreateItem(childResource, resource, table);
3207
3208         node = node->Next();
3209     }
3210     return TRUE;
3211 }
3212
3213 wxControl *wxWindowBase::CreateItem(const wxItemResource *resource, const wxItemResource* parentResource, const wxResourceTable *table)
3214 {
3215     if (!table)
3216         table = wxDefaultResourceTable;
3217     return table->CreateItem((wxWindow *)this, resource, parentResource);
3218 }
3219
3220 #ifdef __VISUALC__
3221 #pragma warning(default:4706)   // assignment within conditional expression
3222 #endif // VC++
3223
3224 #endif
3225 // BC++/Win16
3226
3227 #endif // wxUSE_WX_RESOURCES