src/common/resource.cpp

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