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