src/common/resource.cpp

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