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