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