utils/dialoged/src/winprop.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        winprop.cpp
   3 // Purpose:     Window properties
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation "winprop.h"
  14 #endif
  15
  16 // For compilers that support precompilation, includes "wx/wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #ifdef __BORLANDC__
  20 #pragma hdrstop
  21 #endif
  22
  23 #ifndef WX_PRECOMP
  24 #include "wx/wx.h"
  25 #endif
  26
  27 #include <ctype.h>
  28 #include <stdlib.h>
  29 #include <math.h>
  30 #include <string.h>
  31
  32 #if wxUSE_IOSTREAMH
  33 #if defined(__WXMSW__) && !defined(__GNUWIN32__)
  34 #include <strstrea.h>
  35 #else
  36 #include <strstream.h>
  37 #endif
  38 #else
  39 #include <strstream>
  40 #endif
  41
  42 #ifdef __WXMSW__
  43 #include <windows.h>
  44 #endif
  45
  46 #include "reseditr.h"
  47 #include "winprop.h"
  48
  49 // Causes immediate feedback.
  50 void wxResourcePropertyListView::OnPropertyChanged(wxProperty *property)
  51 {
  52   // Sets the value of the property back into the actual object,
  53   // IF the property value was modified.
  54   if (property->GetValue().GetModified())
  55   {
  56     m_propertyInfo->SetProperty(property->GetName(), property);
  57     property->GetValue().SetModified(FALSE);
  58     wxResourceManager::GetCurrentResourceManager()->Modify(TRUE);
  59   }
  60 }
  61
  62 bool wxResourcePropertyListView::OnClose(void)
  63 {
  64   int w, h, x, y;
  65   GetManagedWindow()->GetSize(& w, & h);
  66   GetManagedWindow()->GetPosition(& x, & y);
  67
  68   wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().width = w;
  69   wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().height = h;
  70   wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().x = x;
  71   wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().y = y;
  72
  73   return wxPropertyListView::OnClose();
  74 }
  75
  76 wxWindow *wxPropertyInfo::sm_propertyWindow;
  77
  78 /*
  79  * wxDialogEditorPropertyListDialog
  80  */
  81
  82  /*
  83 wxDialogEditorPropertyListDialog::wxDialogEditorPropertyListDialog(wxPropertyListView *v, wxWindow *parent, const wxString& title,
  84         const wxPoint& pos, const wxSize& size,
  85         long style, const wxString& name):
  86             wxPropertyListDialog(v, parent, title, pos, size, style, name)
  87 {
  88         m_propSheet = NULL;
  89         m_propInfo = NULL;
  90 }
  91
  92 wxDialogEditorPropertyListDialog::~wxDialogEditorPropertyListDialog()
  93 {
  94     delete m_propSheet;
  95     delete m_propInfo;
  96     wxPropertyInfo::sm_propertyWindow = NULL;
  97 }
  98 */
  99
 100 wxDialogEditorPropertyListFrame::wxDialogEditorPropertyListFrame(wxPropertyListView *v, wxFrame *parent, const wxString& title,
 101         const wxPoint& pos, const wxSize& size,
 102         long style, const wxString& name):
 103             wxPropertyListFrame(v, parent, title, pos, size, style, name)
 104 {
 105         m_propSheet = NULL;
 106         m_propInfo = NULL;
 107 }
 108
 109 wxDialogEditorPropertyListFrame::~wxDialogEditorPropertyListFrame()
 110 {
 111     delete m_propSheet;
 112     delete m_propInfo;
 113     wxPropertyInfo::sm_propertyWindow = NULL;
 114 }
 115
 116 /*
 117  * wxPropertyInfo
 118  */
 119
 120 // Edit the information represented by this object, whatever that
 121 // might be.
 122 bool wxPropertyInfo::Edit(wxWindow *WXUNUSED(parent), const wxString& title)
 123 {
 124     if (sm_propertyWindow)
 125     {
 126         sm_propertyWindow->Raise();
 127         return TRUE;
 128     }
 129
 130   int width = wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().width;
 131   int height = wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().height;
 132   int x = wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().x;
 133   int y = wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().y;
 134
 135   wxPropertySheet *propSheet = new wxPropertySheet;
 136
 137   wxStringList propNames;
 138   GetPropertyNames(propNames);
 139
 140   wxNode *node = propNames.First();
 141   while (node)
 142   {
 143     wxString name((char *)node->Data());
 144     wxProperty *prop = GetProperty(name);
 145     if (prop)
 146     {
 147       propSheet->AddProperty(prop);
 148     }
 149     node = node->Next();
 150   }
 151
 152   // Reset 'modified' flags for all property values
 153   propSheet->SetAllModified(FALSE);
 154
 155   wxResourcePropertyListView *view = new wxResourcePropertyListView(this, NULL,
 156      wxPROP_BUTTON_OK | wxPROP_BUTTON_CANCEL |
 157      wxPROP_BUTTON_CHECK_CROSS|wxPROP_DYNAMIC_VALUE_FIELD|wxPROP_PULLDOWN|wxPROP_SHOWVALUES);
 158
 159   wxDialogEditorPropertyListFrame *propWin = new wxDialogEditorPropertyListFrame(view,
 160     wxResourceManager::GetCurrentResourceManager()->GetEditorFrame(), title, wxPoint(x, y),
 161     wxSize(width, height), wxDEFAULT_FRAME_STYLE);
 162   sm_propertyWindow = propWin;
 163
 164   propWin->m_registry.RegisterValidator(wxString("real"), new wxRealListValidator);
 165   propWin->m_registry.RegisterValidator(wxString("string"), new wxStringListValidator);
 166   propWin->m_registry.RegisterValidator(wxString("integer"), new wxIntegerListValidator);
 167   propWin->m_registry.RegisterValidator(wxString("bool"), new wxBoolListValidator);
 168   propWin->m_registry.RegisterValidator(wxString("filename"), new wxFilenameListValidator);
 169   propWin->m_registry.RegisterValidator(wxString("stringlist"), new wxListOfStringsListValidator);
 170   propWin->m_registry.RegisterValidator(wxString("window_id"), new wxResourceSymbolValidator);
 171
 172   propWin->m_propInfo = this;
 173   propWin->m_propSheet = propSheet;
 174
 175 //  view->m_propertyWindow = propWin;
 176   view->AddRegistry(&(propWin->m_registry));
 177
 178   propWin->Initialize();
 179   view->ShowView(propSheet, propWin->GetPropertyPanel());
 180
 181   propWin->Show(TRUE);
 182
 183   // Otherwise doesn't show itself
 184 #ifdef __WXMOTIF__
 185   wxNoOptimize noOptimize;
 186   propWin->SetSize(-1, -1, width, height);
 187 #endif
 188
 189   return TRUE;
 190 }
 191
 192 /*
 193  * wxWindowPropertyInfo
 194  */
 195
 196 wxWindowPropertyInfo::wxWindowPropertyInfo(wxWindow *win, wxItemResource *res)
 197 {
 198   m_propertyWindow = win;
 199   m_propertyResource = res;
 200 }
 201
 202 wxWindowPropertyInfo::~wxWindowPropertyInfo(void)
 203 {
 204 }
 205
 206 wxProperty *wxWindowPropertyInfo::GetFontProperty(wxString& name, wxFont *font)
 207 {
 208   if (!font)
 209     return NULL;
 210
 211   if (name.Contains("Points"))
 212     return new wxProperty(name, (long)font->GetPointSize(), "integer", new wxIntegerListValidator(1, 100));
 213   else if (name.Contains("Family"))
 214     return new wxProperty(name, font->GetFamilyString(), "string",
 215        new wxStringListValidator(new wxStringList("wxDECORATIVE", "wxROMAN", "wxSCRIPT", "wxSWISS", "wxMODERN",
 216           NULL)));
 217   else if (name.Contains("Style"))
 218     return new wxProperty(name, font->GetStyleString(), "string",
 219        new wxStringListValidator(new wxStringList("wxNORMAL", "wxITALIC", "wxSLANT", NULL)));
 220   else if (name.Contains("Weight"))
 221     return new wxProperty(name, font->GetWeightString(), "string",
 222        new wxStringListValidator(new wxStringList("wxNORMAL", "wxBOLD", "wxLIGHT", NULL)));
 223   else if (name.Contains("Underlined"))
 224     return new wxProperty(name, (bool)font->GetUnderlined(), "bool");
 225   else
 226     return NULL;
 227 }
 228
 229 wxFont *wxWindowPropertyInfo::SetFontProperty(wxString& name, wxProperty *property, wxFont *font)
 230 {
 231   int pointSize = 12;
 232   int fontFamily = wxMODERN;
 233   int fontStyle = wxNORMAL;
 234   int fontWeight = wxNORMAL;
 235   bool fontUnderlined = FALSE;
 236
 237   if (name.Contains("Points"))
 238   {
 239     pointSize = (int)property->GetValue().IntegerValue();
 240     if (font && (pointSize == font->GetPointSize()))
 241       return NULL; // No change
 242   }
 243   else if (font) pointSize = font->GetPointSize();
 244
 245   if (name.Contains("Family"))
 246   {
 247     wxString val = property->GetValue().StringValue();
 248     fontFamily = wxStringToFontFamily(val);
 249
 250     if (font && (fontFamily == font->GetFamily()))
 251       return NULL; // No change
 252   }
 253   else if (font) fontFamily = font->GetFamily();
 254
 255   if (name.Contains("Style"))
 256   {
 257     wxString val = property->GetValue().StringValue();
 258     fontStyle = wxStringToFontStyle(val);
 259
 260     if (font && (fontStyle == font->GetStyle()))
 261       return NULL; // No change
 262   }
 263   else if (font) fontStyle = font->GetStyle();
 264   if (name.Contains("Weight"))
 265   {
 266     wxString val = property->GetValue().StringValue();
 267     fontWeight = wxStringToFontWeight(val);
 268
 269     if (font && (fontWeight == font->GetWeight()))
 270       return NULL; // No change
 271   }
 272   else if (font) fontWeight = font->GetWeight();
 273
 274   if (name.Contains("Underlined"))
 275   {
 276     fontUnderlined = property->GetValue().BoolValue();
 277
 278     if (font && (fontUnderlined == font->GetUnderlined()))
 279       return NULL; // No change
 280   }
 281   else if (font) fontUnderlined = font->GetUnderlined();
 282
 283   wxFont *newFont = wxTheFontList->FindOrCreateFont(pointSize, fontFamily, fontStyle, fontWeight, fontUnderlined);
 284   if (newFont)
 285   {
 286     return newFont;
 287   }
 288   else
 289     return NULL;
 290 }
 291
 292 wxProperty *wxWindowPropertyInfo::GetProperty(wxString& name)
 293 {
 294   wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
 295
 296   wxFont *font = & m_propertyWindow->GetFont();
 297   if (name == "fontPoints" || name == "fontFamily" || name == "fontStyle" || name == "fontWeight" ||
 298       name == "fontUnderlined")
 299     return GetFontProperty(name, font);
 300   else if (name == "name")
 301     return new wxProperty("name", m_propertyWindow->GetName(), "string");
 302   else if (name == "title")
 303     return new wxProperty("title", m_propertyWindow->GetTitle(), "string");
 304   else if (name == "x")
 305   {
 306     return new wxProperty("x", (long)resource->GetX(), "integer");
 307   }
 308   else if (name == "y")
 309   {
 310     return new wxProperty("y", (long)resource->GetY(), "integer");
 311   }
 312   else if (name == "width")
 313   {
 314     return new wxProperty("width", (long)resource->GetWidth(), "integer");
 315   }
 316   else if (name == "height")
 317   {
 318     return new wxProperty("height", (long)resource->GetHeight(), "integer");
 319   }
 320   else if (name == "id")
 321   {
 322     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
 323     if (resource)
 324     {
 325         int id = resource->GetId();
 326         wxString idStr;
 327         idStr.Printf("%d", id);
 328         wxString symbolName = wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().GetSymbolForId(id);
 329         symbolName += "=";
 330         symbolName += idStr;
 331         // symbolName is now e.g. "ID_PANEL21=105"
 332         return new wxProperty("id", symbolName, "window_id");
 333     }
 334     else
 335         return NULL;
 336   }
 337   else if (name == "border")
 338   {
 339     wxString border("");
 340     if (m_propertyWindow->GetWindowStyleFlag() & wxSIMPLE_BORDER)
 341       border = "wxSIMPLE_BORDER";
 342     else if (m_propertyWindow->GetWindowStyleFlag() & wxRAISED_BORDER)
 343       border = "wxRAISED_BORDER";
 344     else if (m_propertyWindow->GetWindowStyleFlag() & wxSUNKEN_BORDER)
 345       border = "wxSUNKEN_BORDER";
 346     else if (m_propertyWindow->GetWindowStyleFlag() & wxDOUBLE_BORDER)
 347       border = "wxDOUBLE_BORDER";
 348     else if (m_propertyWindow->GetWindowStyleFlag() & wxSTATIC_BORDER)
 349       border = "wxSTATIC_BORDER";
 350     else
 351       border = "wxNO_BORDER";
 352
 353     return new wxProperty("border", border, "string",
 354        new wxStringListValidator(new wxStringList("wxSIMPLE_BORDER", "wxRAISED_BORDER",
 355           "wxSUNKEN_BORDER", "wxDOUBLE_BORDER", "wxSTATIC_BORDER", "wxNO_BORDER", NULL)));
 356   }
 357   else
 358     return NULL;
 359 }
 360
 361 bool wxWindowPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 362 {
 363   wxFont *font = & m_propertyWindow->GetFont();
 364   if (font && (name == "fontPoints" || name == "fontFamily" || name == "fontStyle" || name == "fontWeight" || name == "fontUnderlined" ))
 365   {
 366     wxFont *newFont = SetFontProperty(name, property, font);
 367     if (newFont)
 368       m_propertyWindow->SetFont(* newFont);
 369     return TRUE;
 370   }
 371   else if (name == "name")
 372   {
 373     // Remove old name from resource table, if it's there.
 374     wxItemResource *oldResource = (wxItemResource *)wxResourceManager::GetCurrentResourceManager()->GetResourceTable().Delete(m_propertyWindow->GetName());
 375     if (oldResource)
 376     {
 377       // It's a top-level resource
 378       m_propertyWindow->SetName(property->GetValue().StringValue());
 379       oldResource->SetName(property->GetValue().StringValue());
 380       wxResourceManager::GetCurrentResourceManager()->GetResourceTable().Put(m_propertyWindow->GetName(), oldResource);
 381     }
 382     else
 383     {
 384       // It's a child of something; just set the name of the resource and the window.
 385       m_propertyWindow->SetName(property->GetValue().StringValue());
 386       m_propertyResource->SetName(property->GetValue().StringValue());
 387     }
 388     // Refresh the resource manager list, because the name changed.
 389     wxResourceManager::GetCurrentResourceManager()->UpdateResourceList();
 390     return TRUE;
 391   }
 392   else if (name == "title")
 393   {
 394     m_propertyWindow->SetTitle(property->GetValue().StringValue());
 395     return TRUE;
 396   }
 397   else if (name == "x")
 398   {
 399     wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
 400     int x, y;
 401     m_propertyWindow->GetPosition(&x, &y);
 402     int newX = (int)property->GetValue().IntegerValue();
 403     int pixelX = newX;
 404
 405     // We need to convert to pixels if this is not a dialog or panel, but
 406     // the parent resource specifies dialog units.
 407     if (m_propertyWindow->GetParent() && m_propertyWindow->IsKindOf(CLASSINFO(wxControl)))
 408     {
 409         wxItemResource* parentResource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow->GetParent());
 410         if (parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
 411         {
 412             wxPoint pt = m_propertyWindow->GetParent()->ConvertDialogToPixels(wxPoint(newX, y));
 413             pixelX = pt.x;
 414         }
 415     }
 416     else if (m_propertyWindow->IsKindOf(CLASSINFO(wxPanel)))
 417     {
 418         wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
 419         if (resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
 420         {
 421             wxPoint pt = m_propertyWindow->ConvertDialogToPixels(wxPoint(newX, y));
 422             pixelX = pt.x;
 423         }
 424     }
 425
 426     if (x != pixelX)
 427     {
 428       m_propertyWindow->Move(pixelX, y);
 429       resource->SetSize(newX, resource->GetY(), resource->GetWidth(), resource->GetHeight());
 430     }
 431     return TRUE;
 432   }
 433   else if (name == "y")
 434   {
 435     wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
 436     int x, y;
 437     m_propertyWindow->GetPosition(&x, &y);
 438     int newY = (int)property->GetValue().IntegerValue();
 439     int pixelY = newY;
 440
 441     // We need to convert to pixels if this is not a dialog or panel, but
 442     // the parent resource specifies dialog units.
 443     if (m_propertyWindow->GetParent() && m_propertyWindow->IsKindOf(CLASSINFO(wxControl)))
 444     {
 445         wxItemResource* parentResource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow->GetParent());
 446         if (parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
 447         {
 448             wxPoint pt = m_propertyWindow->GetParent()->ConvertDialogToPixels(wxPoint(x, newY));
 449             pixelY = pt.y;
 450         }
 451     }
 452     else if (m_propertyWindow->IsKindOf(CLASSINFO(wxPanel)))
 453     {
 454         wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
 455         if (resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
 456         {
 457             wxPoint pt = m_propertyWindow->ConvertDialogToPixels(wxPoint(x, newY));
 458             pixelY = pt.y;
 459         }
 460     }
 461
 462     if (y != pixelY)
 463     {
 464       m_propertyWindow->Move(x, pixelY);
 465       resource->SetSize(resource->GetX(), newY, resource->GetWidth(), resource->GetHeight());
 466     }
 467     return TRUE;
 468   }
 469   else if (name == "width")
 470   {
 471     wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
 472     int width, height;
 473     m_propertyWindow->GetSize(&width, &height);
 474     int newWidth = (int)property->GetValue().IntegerValue();
 475     int pixelWidth = newWidth;
 476
 477     // We need to convert to pixels if this is not a dialog or panel, but
 478     // the parent resource specifies dialog units.
 479     if (m_propertyWindow->GetParent() && m_propertyWindow->IsKindOf(CLASSINFO(wxControl)))
 480     {
 481         wxItemResource* parentResource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow->GetParent());
 482         if (parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
 483         {
 484             wxSize sz = m_propertyWindow->GetParent()->ConvertDialogToPixels(wxSize(newWidth, height));
 485             pixelWidth = sz.x;
 486         }
 487     }
 488     else if (m_propertyWindow->IsKindOf(CLASSINFO(wxPanel)))
 489     {
 490         wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
 491         if (resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
 492         {
 493             wxSize sz = m_propertyWindow->ConvertDialogToPixels(wxSize(newWidth, height));
 494             pixelWidth = sz.x;
 495         }
 496     }
 497
 498     if (width != pixelWidth)
 499     {
 500       m_propertyWindow->SetSize(pixelWidth, height);
 501       resource->SetSize(resource->GetX(), resource->GetY(), newWidth, resource->GetHeight());
 502     }
 503     return TRUE;
 504   }
 505   else if (name == "height")
 506   {
 507     wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
 508     int width, height;
 509     m_propertyWindow->GetSize(&width, &height);
 510     int newHeight = (int)property->GetValue().IntegerValue();
 511     int pixelHeight = newHeight;
 512
 513     // We need to convert to pixels if this is not a dialog or panel, but
 514     // the parent resource specifies dialog units.
 515     if (m_propertyWindow->GetParent() && m_propertyWindow->IsKindOf(CLASSINFO(wxControl)))
 516     {
 517         wxItemResource* parentResource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow->GetParent());
 518         if (parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
 519         {
 520             wxSize sz = m_propertyWindow->GetParent()->ConvertDialogToPixels(wxSize(width, newHeight));
 521             pixelHeight = sz.y;
 522         }
 523     }
 524     else if (m_propertyWindow->IsKindOf(CLASSINFO(wxPanel)))
 525     {
 526         wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
 527         if (resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
 528         {
 529             wxSize sz = m_propertyWindow->ConvertDialogToPixels(wxSize(width, newHeight));
 530             pixelHeight = sz.y;
 531         }
 532     }
 533
 534     if (height != pixelHeight)
 535     {
 536       m_propertyWindow->SetSize(width, pixelHeight);
 537       resource->SetSize(resource->GetX(), resource->GetY(), resource->GetWidth(), newHeight);
 538     }
 539     return TRUE;
 540   }
 541   else if (name == "id")
 542   {
 543     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
 544     if (resource)
 545     {
 546         wxString value = property->GetValue().StringValue();
 547
 548         wxString strName = value.Before('=');
 549         wxString strId = value.After('=');
 550         int id = atoi(strId);
 551
 552         wxString oldSymbolName = wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().GetSymbolForId(resource->GetId());
 553         int oldSymbolId = resource->GetId();
 554
 555         if (strName != "")
 556         {
 557             // If we change the id for an existing symbol, we need to:
 558             // 1) Check if there are any other resources currently using the original id.
 559             //    If so, will need to change their id to the new id.
 560             // 2) Remove the old symbol, add the new symbol.
 561             // In this check, we don't have to do this, but we need to do it in SetProperty.
 562
 563             if (strName == oldSymbolName && id != oldSymbolId)
 564             {
 565                 wxASSERT( (!wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().IsStandardSymbol(oldSymbolName)) );
 566
 567                 // It's OK to change just the id. But we'll need to change all matching ids in all resources,
 568                 // because ids are unique and changing one resource's id must change all identical ones.
 569                 wxResourceManager::GetCurrentResourceManager()->ChangeIds(oldSymbolId, id);
 570
 571                 wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().RemoveSymbol(oldSymbolName);
 572                 wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().AddSymbol(strName, id);
 573             }
 574
 575             // If we change the name but not the id, we'll just need to remove and
 576             // re-add the symbol/id pair.
 577             if (strName != oldSymbolName && id == oldSymbolId)
 578             {
 579                 wxASSERT( (!wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().IsStandardSymbol(oldSymbolName)) );
 580
 581                 wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().RemoveSymbol(oldSymbolName);
 582
 583                 if (!wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().SymbolExists(strName))
 584                 {
 585                     wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().AddSymbol(strName, id);
 586                 }
 587             }
 588
 589             // What if we're changing both the name and the id?
 590             // - if there's no symbol of that name, just remove the old, add the new (in SetProperty)
 591             // - if there is a symbol of that name, if id matches, do nothing. If not, veto.
 592
 593             if (strName != oldSymbolName && id != oldSymbolId)
 594             {
 595                 // Remove old symbol if it's not being used
 596                 if (!wxResourceManager::GetCurrentResourceManager()->IsSymbolUsed(resource, oldSymbolId) &&
 597                     !wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().IsStandardSymbol(oldSymbolName))
 598                 {
 599                     wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().RemoveSymbol(oldSymbolName);
 600                 }
 601
 602                 if (!wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().SymbolExists(strName))
 603                 {
 604                     wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().AddSymbol(strName, id);
 605                 }
 606             }
 607             resource->SetId(id);
 608         }
 609
 610         return TRUE;
 611     }
 612     else
 613         return FALSE;
 614   }
 615   else if (name == "border")
 616   {
 617     long borderStyle = wxNO_BORDER;
 618     wxString val = property->GetValue().StringValue();
 619
 620     if (val == "wxSIMPLE_BORDER")
 621         borderStyle = wxSIMPLE_BORDER;
 622     else if (val == "wxRAISED_BORDER")
 623         borderStyle = wxRAISED_BORDER;
 624     else if (val == "wxSUNKEN_BORDER")
 625         borderStyle = wxSUNKEN_BORDER;
 626     else if (val == "wxDOUBLE_BORDER")
 627         borderStyle = wxDOUBLE_BORDER;
 628     else if (val == "wxSTATIC_BORDER")
 629         borderStyle = wxSTATIC_BORDER;
 630     else
 631         borderStyle = wxNO_BORDER;
 632
 633     SetWindowStyle(m_propertyWindow, wxSIMPLE_BORDER, FALSE);
 634     SetWindowStyle(m_propertyWindow, wxRAISED_BORDER, FALSE);
 635     SetWindowStyle(m_propertyWindow, wxSUNKEN_BORDER, FALSE);
 636     SetWindowStyle(m_propertyWindow, wxDOUBLE_BORDER, FALSE);
 637     SetWindowStyle(m_propertyWindow, wxSTATIC_BORDER, FALSE);
 638     SetWindowStyle(m_propertyWindow, wxNO_BORDER, FALSE);
 639
 640     SetWindowStyle(m_propertyWindow, borderStyle, TRUE);
 641
 642     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
 643     resource->SetStyle(m_propertyWindow->GetWindowStyleFlag());
 644     return TRUE;
 645   }
 646   else
 647     return FALSE;
 648 }
 649
 650 void wxWindowPropertyInfo::GetPropertyNames(wxStringList& names)
 651 {
 652   names.Add("id");
 653   names.Add("name");
 654   names.Add("x");
 655   names.Add("y");
 656   names.Add("width");
 657   names.Add("height");
 658   names.Add("border");
 659   if (!m_propertyWindow->IsKindOf(CLASSINFO(wxControl)))
 660   {
 661     names.Add("fontPoints");
 662     names.Add("fontFamily");
 663     names.Add("fontStyle");
 664     names.Add("fontWeight");
 665     names.Add("fontUnderlined");
 666   }
 667 }
 668
 669 // Fill in the wxItemResource members to mirror the current window settings
 670 bool wxWindowPropertyInfo::InstantiateResource(wxItemResource *resource)
 671 {
 672 //  resource->SetType(m_propertyWindow->GetClassInfo()->GetClassName());
 673
 674 //  resource->SetStyle(m_propertyWindow->GetWindowStyleFlag());
 675   wxString str(m_propertyWindow->GetName());
 676   resource->SetName(str);
 677
 678 #if 0
 679   int x, y, w, h;
 680
 681   if (m_propertyWindow->IsKindOf(CLASSINFO(wxPanel)))
 682       m_propertyWindow->GetClientSize(&w, &h);
 683   else
 684       m_propertyWindow->GetSize(&w, &h);
 685
 686   m_propertyWindow->GetPosition(&x, &y);
 687
 688   // We need to convert to dialog units if this is not a dialog or panel, but
 689   // the parent resource specifies dialog units.
 690   if (m_propertyWindow->GetParent() && m_propertyWindow->IsKindOf(CLASSINFO(wxControl)))
 691   {
 692       wxItemResource* parentResource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow->GetParent());
 693       if (parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
 694       {
 695           wxPoint pt = m_propertyWindow->GetParent()->ConvertPixelsToDialog(wxPoint(x, y));
 696           x = pt.x; y = pt.y;
 697           wxSize sz = m_propertyWindow->GetParent()->ConvertPixelsToDialog(wxSize(w, h));
 698           w = sz.x; h = sz.y;
 699       }
 700   }
 701   else if (m_propertyWindow->IsKindOf(CLASSINFO(wxPanel)))
 702   {
 703       if (resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
 704       {
 705           wxPoint pt = m_propertyWindow->ConvertPixelsToDialog(wxPoint(x, y));
 706           x = pt.x; y = pt.y;
 707           wxSize sz = m_propertyWindow->ConvertPixelsToDialog(wxSize(w, h));
 708           w = sz.x; h = sz.y;
 709       }
 710   }
 711
 712   resource->SetSize(x, y, w, h);
 713 #endif
 714
 715   return TRUE;
 716 }
 717
 718 // Set the window style
 719 void wxWindowPropertyInfo::SetWindowStyle(wxWindow* win, long style, bool set)
 720 {
 721     if (style == 0)
 722         return;
 723
 724     if ((win->GetWindowStyleFlag() & style) == style)
 725     {
 726         if (!set)
 727         {
 728             win->SetWindowStyleFlag(win->GetWindowStyleFlag() - style);
 729         }
 730     }
 731     else
 732     {
 733         if (set)
 734         {
 735             win->SetWindowStyleFlag(win->GetWindowStyleFlag() | style);
 736         }
 737     }
 738 }
 739
 740 /*
 741  * Controls
 742  */
 743
 744 wxProperty *wxItemPropertyInfo::GetProperty(wxString& name)
 745 {
 746   wxControl *itemWindow = (wxControl *)m_propertyWindow;
 747   wxFont *font = & itemWindow->GetFont();
 748
 749   if (name == "fontPoints" || name == "fontFamily" || name == "fontStyle" || name == "fontWeight" ||
 750       name == "fontUnderlined")
 751     return GetFontProperty(name, font);
 752   else if (name == "label" && itemWindow->GetLabel())
 753     return new wxProperty("label", m_propertyWindow->GetLabel(), "string");
 754   else
 755     return wxWindowPropertyInfo::GetProperty(name);
 756 }
 757
 758 bool wxItemPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 759 {
 760   wxControl *itemWindow = (wxControl *)m_propertyWindow;
 761   wxFont *font = & itemWindow->GetFont();
 762
 763   if (font && (name == "fontPoints" || name == "fontFamily" || name == "fontStyle" || name == "fontWeight" || name == "fontUnderlined" ))
 764   {
 765     wxFont *newFont = SetFontProperty(name, property, font);
 766     if (newFont)
 767       itemWindow->SetFont(* newFont);
 768     return TRUE;
 769   }
 770   else if (name == "label")
 771   {
 772     itemWindow->SetLabel(property->GetValue().StringValue());
 773     return TRUE;
 774   }
 775   else
 776     return wxWindowPropertyInfo::SetProperty(name, property);
 777 }
 778
 779 void wxItemPropertyInfo::GetPropertyNames(wxStringList& names)
 780 {
 781   wxWindowPropertyInfo::GetPropertyNames(names);
 782
 783   names.Add("fontPoints");
 784   names.Add("fontFamily");
 785   names.Add("fontStyle");
 786   names.Add("fontWeight");
 787   names.Add("fontUnderlined");
 788 }
 789
 790 bool wxItemPropertyInfo::InstantiateResource(wxItemResource *resource)
 791 {
 792   wxWindowPropertyInfo::InstantiateResource(resource);
 793
 794   wxControl *item = (wxControl *)m_propertyWindow;
 795   wxString str(item->GetLabel());
 796   resource->SetTitle(str);
 797
 798   if (item->GetFont().Ok())
 799     resource->SetFont(* wxTheFontList->FindOrCreateFont(item->GetFont().GetPointSize(),
 800                 item->GetFont().GetFamily(), item->GetFont().GetStyle(), item->GetFont().GetWeight(),
 801                 item->GetFont().GetUnderlined(), item->GetFont().GetFaceName()));
 802   return TRUE;
 803 }
 804
 805 /*
 806  * Button
 807  */
 808
 809 wxProperty *wxButtonPropertyInfo::GetProperty(wxString& name)
 810 {
 811   return wxItemPropertyInfo::GetProperty(name);
 812 }
 813
 814 bool wxButtonPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 815 {
 816   return wxItemPropertyInfo::SetProperty(name, property);
 817 }
 818
 819 void wxButtonPropertyInfo::GetPropertyNames(wxStringList& names)
 820 {
 821   wxItemPropertyInfo::GetPropertyNames(names);
 822   names.Add("label");
 823 }
 824
 825 bool wxButtonPropertyInfo::InstantiateResource(wxItemResource *resource)
 826 {
 827   return wxItemPropertyInfo::InstantiateResource(resource);
 828 }
 829
 830 /*
 831  * wxBitmapButton
 832  */
 833
 834 wxProperty *wxBitmapButtonPropertyInfo::GetProperty(wxString& name)
 835 {
 836   wxBitmapButton *button = (wxBitmapButton *)m_propertyWindow;
 837   if (name == "bitmapFilename")
 838   {
 839     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(button);
 840     wxString str("none.bmp");
 841
 842     if (resource)
 843     {
 844       str = wxResourceManager::GetCurrentResourceManager()->FindBitmapFilenameForResource(resource);
 845     }
 846     return new wxProperty("bitmapFilename", str.GetData(), "string", new wxFilenameListValidator("Select a bitmap file", "*.bmp"));
 847   }
 848   else
 849     return wxButtonPropertyInfo::GetProperty(name);
 850 }
 851
 852 bool wxBitmapButtonPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 853 {
 854   wxBitmapButton *button = (wxBitmapButton *)m_propertyWindow;
 855   if (name == "bitmapFilename")
 856   {
 857     char *s = property->GetValue().StringValue();
 858     if (s && wxFileExists(s))
 859     {
 860       wxString str(s);
 861       wxBitmap *bitmap = new wxBitmap(str, wxBITMAP_TYPE_BMP);
 862       if (!bitmap->Ok())
 863       {
 864         delete bitmap;
 865         return FALSE;
 866       }
 867       else
 868       {
 869         wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(button);
 870         if (resource)
 871         {
 872           wxString oldResource(resource->GetValue4());
 873           wxString resName = wxResourceManager::GetCurrentResourceManager()->AddBitmapResource(str);
 874           resource->SetValue4(resName);
 875
 876           if (!oldResource.IsNull())
 877             wxResourceManager::GetCurrentResourceManager()->PossiblyDeleteBitmapResource(oldResource);
 878         }
 879
 880         button->SetLabel(* bitmap);
 881         return TRUE;
 882       }
 883     }
 884     return FALSE;
 885   }
 886   else
 887     return wxButtonPropertyInfo::SetProperty(name, property);
 888 }
 889
 890 void wxBitmapButtonPropertyInfo::GetPropertyNames(wxStringList& names)
 891 {
 892   wxButtonPropertyInfo::GetPropertyNames(names);
 893   names.Delete("label");
 894   names.Add("bitmapFilename");
 895 }
 896
 897 bool wxBitmapButtonPropertyInfo::InstantiateResource(wxItemResource *resource)
 898 {
 899   return wxItemPropertyInfo::InstantiateResource(resource);
 900 }
 901
 902 /*
 903  * wxStaticText
 904  */
 905
 906 wxProperty *wxStaticTextPropertyInfo::GetProperty(wxString& name)
 907 {
 908   return wxItemPropertyInfo::GetProperty(name);
 909 }
 910
 911 bool wxStaticTextPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 912 {
 913   return wxItemPropertyInfo::SetProperty(name, property);
 914 }
 915
 916 void wxStaticTextPropertyInfo::GetPropertyNames(wxStringList& names)
 917 {
 918   wxItemPropertyInfo::GetPropertyNames(names);
 919   names.Add("label");
 920 }
 921
 922 bool wxStaticTextPropertyInfo::InstantiateResource(wxItemResource *resource)
 923 {
 924   return wxItemPropertyInfo::InstantiateResource(resource);
 925 }
 926
 927 /*
 928  * wxStaticBitmap
 929  */
 930
 931 wxProperty *wxStaticBitmapPropertyInfo::GetProperty(wxString& name)
 932 {
 933   wxStaticBitmap *message = (wxStaticBitmap *)m_propertyWindow;
 934   if (name == "bitmapFilename")
 935   {
 936     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(message);
 937     wxString str("none.bmp");
 938
 939     if (resource)
 940     {
 941       str = wxResourceManager::GetCurrentResourceManager()->FindBitmapFilenameForResource(resource);
 942     }
 943     return new wxProperty("bitmapFilename", str.GetData(), "string", new wxFilenameListValidator("Select a bitmap file", "*.bmp"));
 944   }
 945   else
 946     return wxItemPropertyInfo::GetProperty(name);
 947 }
 948
 949 bool wxStaticBitmapPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 950 {
 951   wxStaticBitmap *message = (wxStaticBitmap *)m_propertyWindow;
 952   if (name == "bitmapFilename")
 953   {
 954     char *s = property->GetValue().StringValue();
 955     if (s && wxFileExists(s))
 956     {
 957       wxString str(s);
 958
 959       wxBitmap *bitmap = new wxBitmap(str, wxBITMAP_TYPE_BMP);
 960       if (!bitmap->Ok())
 961       {
 962         delete bitmap;
 963         return FALSE;
 964       }
 965       else
 966       {
 967         wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(message);
 968         if (resource)
 969         {
 970           wxString oldResource(resource->GetValue4());
 971           wxString resName = wxResourceManager::GetCurrentResourceManager()->AddBitmapResource(str);
 972           resource->SetValue4(resName);
 973
 974           if (!oldResource.IsNull())
 975             wxResourceManager::GetCurrentResourceManager()->PossiblyDeleteBitmapResource(oldResource);
 976         }
 977
 978         message->SetBitmap(* bitmap);
 979         return TRUE;
 980       }
 981     }
 982     return FALSE;
 983   }
 984   else
 985     return wxItemPropertyInfo::SetProperty(name, property);
 986 }
 987
 988 void wxStaticBitmapPropertyInfo::GetPropertyNames(wxStringList& names)
 989 {
 990   wxItemPropertyInfo::GetPropertyNames(names);
 991   names.Add("bitmapFilename");
 992 }
 993
 994 bool wxStaticBitmapPropertyInfo::InstantiateResource(wxItemResource *resource)
 995 {
 996   return wxItemPropertyInfo::InstantiateResource(resource);
 997 }
 998
 999 /*
1000  * Text item
1001  */
1002
1003 wxProperty *wxTextPropertyInfo::GetProperty(wxString& name)
1004 {
1005   wxTextCtrl *text = (wxTextCtrl *)m_propertyWindow;
1006   if (name == "value")
1007     return new wxProperty("value", text->GetValue(), "string");
1008   else if (name == "password")
1009   {
1010     bool isPassword = ((text->GetWindowStyleFlag() & wxTE_PASSWORD) == wxTE_PASSWORD);
1011     return new wxProperty("password", isPassword, "bool");
1012   }
1013   else if (name == "readonly")
1014   {
1015     bool isReadOnly = ((text->GetWindowStyleFlag() & wxTE_READONLY) == wxTE_READONLY);
1016     return new wxProperty("readonly", isReadOnly, "bool");
1017   }
1018   else
1019     return wxItemPropertyInfo::GetProperty(name);
1020 }
1021
1022 bool wxTextPropertyInfo::SetProperty(wxString& name, wxProperty *property)
1023 {
1024   wxTextCtrl *text = (wxTextCtrl *)m_propertyWindow;
1025   if (name == "value")
1026   {
1027     text->SetValue(property->GetValue().StringValue());
1028     return TRUE;
1029   }
1030   else if (name == "password")
1031   {
1032     long flag = text->GetWindowStyleFlag();
1033     if (property->GetValue().BoolValue())
1034     {
1035       if ((flag & wxTE_PASSWORD) != wxTE_PASSWORD)
1036         flag |= wxTE_PASSWORD;
1037     }
1038     else
1039     {
1040       if ((flag & wxTE_PASSWORD) == wxTE_PASSWORD)
1041         flag -= wxTE_PASSWORD;
1042     }
1043     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(text);
1044     resource->SetStyle(flag);
1045
1046     wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(text, this);
1047     return TRUE;
1048   }
1049   else if (name == "readonly")
1050   {
1051     long flag = text->GetWindowStyleFlag();
1052     if (property->GetValue().BoolValue())
1053     {
1054       if ((flag & wxTE_READONLY) != wxTE_READONLY)
1055         flag |= wxTE_READONLY;
1056     }
1057     else
1058     {
1059       if ((flag & wxTE_READONLY) == wxTE_READONLY)
1060         flag -= wxTE_READONLY;
1061     }
1062     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(text);
1063     resource->SetStyle(flag);
1064
1065     wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(text, this);
1066     return TRUE;
1067   }
1068   else
1069     return wxItemPropertyInfo::SetProperty(name, property);
1070 }
1071
1072 void wxTextPropertyInfo::GetPropertyNames(wxStringList& names)
1073 {
1074   wxItemPropertyInfo::GetPropertyNames(names);
1075   names.Add("value");
1076   names.Add("readonly");
1077   names.Add("password");
1078 }
1079
1080 bool wxTextPropertyInfo::InstantiateResource(wxItemResource *resource)
1081 {
1082   wxTextCtrl *text = (wxTextCtrl *)m_propertyWindow;
1083   wxString str(text->GetValue());
1084   resource->SetValue4(str);
1085
1086   return wxItemPropertyInfo::InstantiateResource(resource);
1087 }
1088
1089 /*
1090  * Listbox item
1091  */
1092
1093 wxProperty *wxListBoxPropertyInfo::GetProperty(wxString& name)
1094 {
1095   wxListBox *listBox = (wxListBox *)m_propertyWindow;
1096   if (name == "values")
1097   {
1098     wxStringList *stringList = new wxStringList;
1099     int i;
1100     for (i = 0; i < listBox->Number(); i++)
1101       stringList->Add(listBox->GetString(i));
1102
1103     return new wxProperty(name, stringList, "stringlist");
1104   }
1105   else if (name == "multiple")
1106   {
1107     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(listBox);
1108     if (!resource)
1109       return NULL;
1110
1111     char *mult = "wxLB_SINGLE";
1112
1113     if ((listBox->GetWindowStyleFlag() & wxLB_MULTIPLE) != 0)
1114         mult = "wxLB_MULTIPLE";
1115     else if ((listBox->GetWindowStyleFlag() & wxLB_EXTENDED) != 0)
1116         mult = "wxLB_EXTENDED";
1117     else
1118         mult = "wxLB_SINGLE";
1119
1120     return new wxProperty("multiple", mult, "string",
1121        new wxStringListValidator(new wxStringList("wxLB_SINGLE", "wxLB_MULTIPLE", "wxLB_EXTENDED",
1122           NULL)));
1123   }
1124   else
1125     return wxItemPropertyInfo::GetProperty(name);
1126 }
1127
1128 bool wxListBoxPropertyInfo::SetProperty(wxString& name, wxProperty *property)
1129 {
1130   wxListBox *listBox = (wxListBox *)m_propertyWindow;
1131   if (name == "values")
1132   {
1133     listBox->Clear();
1134     wxPropertyValue *expr = property->GetValue().GetFirst();
1135     while (expr)
1136     {
1137       char *s = expr->StringValue();
1138       if (s)
1139         listBox->Append(s);
1140       expr = expr->GetNext();
1141     }
1142     return TRUE;
1143   }
1144   else if (name == "multiple")
1145   {
1146     SetWindowStyle(m_propertyWindow, wxLB_SINGLE, FALSE);
1147     SetWindowStyle(m_propertyWindow, wxLB_MULTIPLE, FALSE);
1148     SetWindowStyle(m_propertyWindow, wxLB_EXTENDED, FALSE);
1149
1150     wxString str(property->GetValue().StringValue());
1151     if (str == "wxLB_MULTIPLE")
1152       SetWindowStyle(m_propertyWindow, wxLB_MULTIPLE, TRUE);
1153     else if (str == "wxLB_EXTENDED")
1154       SetWindowStyle(m_propertyWindow, wxLB_EXTENDED, TRUE);
1155     else
1156       SetWindowStyle(m_propertyWindow, wxLB_SINGLE, TRUE);
1157
1158     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(listBox);
1159     if (resource)
1160       resource->SetStyle(m_propertyWindow->GetWindowStyleFlag());
1161     wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(listBox, this);
1162     return TRUE;
1163   }
1164   else
1165     return wxItemPropertyInfo::SetProperty(name, property);
1166 }
1167
1168 void wxListBoxPropertyInfo::GetPropertyNames(wxStringList& names)
1169 {
1170   wxItemPropertyInfo::GetPropertyNames(names);
1171   names.Add("values");
1172   names.Add("multiple");
1173 }
1174
1175 bool wxListBoxPropertyInfo::InstantiateResource(wxItemResource *resource)
1176 {
1177   wxListBox *lbox = (wxListBox *)m_propertyWindow;
1178   // This will be set for the wxItemResource on reading or in SetProperty
1179 //  resource->SetValue1(lbox->GetSelectionMode());
1180   int i;
1181   if (lbox->Number() == 0)
1182     resource->SetStringValues(NULL);
1183   else
1184   {
1185     wxStringList slist;
1186
1187     for (i = 0; i < lbox->Number(); i++)
1188       slist.Add(lbox->GetString(i));
1189
1190     resource->SetStringValues(slist);
1191   }
1192   return wxItemPropertyInfo::InstantiateResource(resource);
1193 }
1194
1195 /*
1196  * Choice item
1197  */
1198
1199 wxProperty *wxChoicePropertyInfo::GetProperty(wxString& name)
1200 {
1201   wxChoice *choice = (wxChoice *)m_propertyWindow;
1202   if (name == "values")
1203   {
1204     wxStringList* stringList = new wxStringList;
1205     int i;
1206     for (i = 0; i < choice->Number(); i++)
1207       stringList->Add(choice->GetString(i));
1208
1209     return new wxProperty(name, stringList, "stringlist");
1210   }
1211   else
1212     return wxItemPropertyInfo::GetProperty(name);
1213 }
1214
1215 bool wxChoicePropertyInfo::SetProperty(wxString& name, wxProperty *property)
1216 {
1217   wxChoice *choice = (wxChoice *)m_propertyWindow;
1218   if (name == "values")
1219   {
1220     choice->Clear();
1221     wxPropertyValue *expr = property->GetValue().GetFirst();
1222     while (expr)
1223     {
1224       char *s = expr->StringValue();
1225       if (s)
1226         choice->Append(s);
1227       expr = expr->GetNext();
1228     }
1229     if (choice->Number() > 0)
1230       choice->SetSelection(0);
1231     return TRUE;
1232   }
1233   else
1234     return wxItemPropertyInfo::SetProperty(name, property);
1235 }
1236
1237 void wxChoicePropertyInfo::GetPropertyNames(wxStringList& names)
1238 {
1239   wxItemPropertyInfo::GetPropertyNames(names);
1240   names.Add("values");
1241 }
1242
1243 bool wxChoicePropertyInfo::InstantiateResource(wxItemResource *resource)
1244 {
1245   wxChoice *choice = (wxChoice *)m_propertyWindow;
1246   int i;
1247   if (choice->Number() == 0)
1248     resource->SetStringValues(NULL);
1249   else
1250   {
1251     wxStringList slist;
1252
1253     for (i = 0; i < choice->Number(); i++)
1254       slist.Add(choice->GetString(i));
1255
1256     resource->SetStringValues(slist);
1257   }
1258   return wxItemPropertyInfo::InstantiateResource(resource);
1259 }
1260
1261 /*
1262  * Choice item
1263  */
1264
1265 wxProperty *wxComboBoxPropertyInfo::GetProperty(wxString& name)
1266 {
1267   wxComboBox *choice = (wxComboBox *)m_propertyWindow;
1268   if (name == "values")
1269   {
1270     wxStringList *stringList = new wxStringList;
1271     int i;
1272     for (i = 0; i < choice->Number(); i++)
1273       stringList->Add(choice->GetString(i));
1274
1275     return new wxProperty(name, stringList, "stringlist");
1276   }
1277   else if (name == "sort")
1278   {
1279     bool sort = ((m_propertyWindow->GetWindowStyleFlag() & wxCB_SORT) == wxCB_SORT);
1280     return new wxProperty(name, sort, "bool");
1281   }
1282   else if (name == "style")
1283   {
1284     wxString styleStr("dropdown");
1285     if (m_propertyWindow->GetWindowStyleFlag() & wxCB_SIMPLE)
1286       styleStr = "simple";
1287     else if (m_propertyWindow->GetWindowStyleFlag() & wxCB_READONLY)
1288       styleStr = "readonly";
1289     else
1290       styleStr = "dropdown";
1291
1292     return new wxProperty(name, styleStr, "string",
1293        new wxStringListValidator(new wxStringList("simple", "dropdown", "readonly",
1294           NULL)));
1295   }
1296   else
1297     return wxItemPropertyInfo::GetProperty(name);
1298 }
1299
1300 bool wxComboBoxPropertyInfo::SetProperty(wxString& name, wxProperty *property)
1301 {
1302   wxComboBox *choice = (wxComboBox *)m_propertyWindow;
1303   if (name == "values")
1304   {
1305     choice->Clear();
1306     wxPropertyValue *expr = property->GetValue().GetFirst();
1307     while (expr)
1308     {
1309       char *s = expr->StringValue();
1310       if (s)
1311         choice->Append(s);
1312       expr = expr->GetNext();
1313     }
1314     if (choice->Number() > 0)
1315       choice->SetSelection(0);
1316     return TRUE;
1317   }
1318   else if (name == "sort")
1319   {
1320     SetWindowStyle(m_propertyWindow, wxCB_SORT, property->GetValue().BoolValue());
1321
1322     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
1323     resource->SetStyle(m_propertyWindow->GetWindowStyleFlag());
1324
1325     wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(m_propertyWindow, this);
1326     return TRUE;
1327   }
1328   else if (name == "style")
1329   {
1330     SetWindowStyle(m_propertyWindow, wxCB_SIMPLE, FALSE);
1331     SetWindowStyle(m_propertyWindow, wxCB_DROPDOWN, FALSE);
1332     SetWindowStyle(m_propertyWindow, wxCB_READONLY, FALSE);
1333
1334     wxString styleStr(property->GetValue().StringValue());
1335     if (styleStr == "simple")
1336       SetWindowStyle(m_propertyWindow, wxCB_SIMPLE, TRUE);
1337     else if (styleStr == "dropdown")
1338       SetWindowStyle(m_propertyWindow, wxCB_DROPDOWN, TRUE);
1339     else if (styleStr == "readonly")
1340       SetWindowStyle(m_propertyWindow, wxCB_READONLY, TRUE);
1341
1342       // Necesary?
1343     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
1344     resource->SetStyle(m_propertyWindow->GetWindowStyleFlag());
1345
1346     wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(m_propertyWindow, this);
1347
1348     return TRUE;
1349   }
1350   else
1351     return wxItemPropertyInfo::SetProperty(name, property);
1352 }
1353
1354 void wxComboBoxPropertyInfo::GetPropertyNames(wxStringList& names)
1355 {
1356   wxItemPropertyInfo::GetPropertyNames(names);
1357   names.Add("values");
1358   names.Add("style");
1359   names.Add("sort");
1360 }
1361
1362 bool wxComboBoxPropertyInfo::InstantiateResource(wxItemResource *resource)
1363 {
1364   wxComboBox *choice = (wxComboBox *)m_propertyWindow;
1365   int i;
1366   if (choice->Number() == 0)
1367     resource->SetStringValues(NULL);
1368   else
1369   {
1370     wxStringList slist;
1371
1372     for (i = 0; i < choice->Number(); i++)
1373       slist.Add(choice->GetString(i));
1374
1375     resource->SetStringValues(slist);
1376   }
1377   return wxItemPropertyInfo::InstantiateResource(resource);
1378 }
1379
1380 /*
1381  * Radiobox item
1382  */
1383
1384 wxProperty *wxRadioBoxPropertyInfo::GetProperty(wxString& name)
1385 {
1386   wxRadioBox *radioBox = (wxRadioBox *)m_propertyWindow;
1387   if (name == "numberRowsOrCols")
1388   {
1389     return new wxProperty("numberRowsOrCols", (long)radioBox->GetNumberOfRowsOrCols(), "integer");
1390   }
1391   if (name == "orientation")
1392   {
1393     wxString orient;
1394     if (m_propertyWindow->GetWindowStyleFlag() & wxRA_SPECIFY_COLS)
1395       orient = "wxRA_SPECIFY_COLS";
1396     else
1397       orient = "wxRA_SPECIFY_ROWS";
1398
1399     return new wxProperty("orientation", orient, "string",
1400        new wxStringListValidator(new wxStringList("wxRA_SPECIFY_COLS", "wxRA_SPECIFY_ROWS",
1401           NULL)));
1402   }
1403   else if (name == "values")
1404   {
1405     wxStringList *stringList = new wxStringList;
1406     int i;
1407     for (i = 0; i < radioBox->Number(); i++)
1408       stringList->Add(radioBox->GetString(i));
1409
1410     return new wxProperty(name, stringList, "stringlist");
1411   }
1412   return wxItemPropertyInfo::GetProperty(name);
1413 }
1414
1415 bool wxRadioBoxPropertyInfo::SetProperty(wxString& name, wxProperty *property)
1416 {
1417   wxRadioBox *radioBox = (wxRadioBox *)m_propertyWindow;
1418   if (name == "numberRowsOrCols")
1419   {
1420     radioBox->SetNumberOfRowsOrCols((int)property->GetValue().IntegerValue());
1421     wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(radioBox, this);
1422     return TRUE;
1423   }
1424   else if (name == "orientation")
1425   {
1426     long windowStyle = radioBox->GetWindowStyleFlag();
1427     wxString val(property->GetValue().StringValue());
1428     if (val == "wxRA_SPECIFY_COLS")
1429     {
1430       if (windowStyle & wxRA_SPECIFY_ROWS)
1431         windowStyle -= wxRA_SPECIFY_ROWS;
1432       windowStyle |= wxRA_SPECIFY_COLS;
1433     }
1434     else
1435     {
1436       if (windowStyle & wxRA_SPECIFY_COLS)
1437         windowStyle -= wxRA_SPECIFY_COLS;
1438       windowStyle |= wxRA_SPECIFY_ROWS;
1439     }
1440     radioBox->SetWindowStyleFlag(windowStyle);
1441     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(radioBox);
1442     resource->SetStyle(windowStyle);
1443
1444     wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(radioBox, this);
1445     return TRUE;
1446   }
1447   else if (name == "values")
1448   {
1449     // Set property into *resource*, not wxRadioBox, and then recreate
1450     // the wxRadioBox. This is because we can't dynamically set the strings
1451     // of a wxRadioBox.
1452     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
1453     if (!resource)
1454       return FALSE;
1455
1456     wxStringList stringList;
1457     wxPropertyValue *expr = property->GetValue().GetFirst();
1458     while (expr)
1459     {
1460       char *s = expr->StringValue();
1461       if (s)
1462         stringList.Add(s);
1463       expr = expr->GetNext();
1464     }
1465     resource->SetStringValues(stringList);
1466     wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(radioBox, this);
1467     return TRUE;
1468   }
1469   return wxItemPropertyInfo::SetProperty(name, property);
1470 }
1471
1472 void wxRadioBoxPropertyInfo::GetPropertyNames(wxStringList& names)
1473 {
1474   wxItemPropertyInfo::GetPropertyNames(names);
1475   names.Add("label");
1476   names.Add("values");
1477   names.Add("orientation");
1478   names.Add("numberRowsOrCols");
1479 }
1480
1481 bool wxRadioBoxPropertyInfo::InstantiateResource(wxItemResource *resource)
1482 {
1483   wxRadioBox *rbox = (wxRadioBox *)m_propertyWindow;
1484   // Take strings from resource instead
1485 /*
1486   int i;
1487   if (rbox->Number() == 0)
1488     resource->SetStringValues(NULL);
1489   else
1490   {
1491     wxStringList *slist = new wxStringList;
1492
1493     for (i = 0; i < rbox->Number(); i++)
1494       slist->Add(rbox->GetString(i));
1495
1496     resource->SetStringValues(slist);
1497   }
1498 */
1499   resource->SetValue1(rbox->GetNumberOfRowsOrCols());
1500   return wxItemPropertyInfo::InstantiateResource(resource);
1501 }
1502
1503 /*
1504  * Groupbox item
1505  */
1506
1507 wxProperty *wxGroupBoxPropertyInfo::GetProperty(wxString& name)
1508 {
1509   return wxItemPropertyInfo::GetProperty(name);
1510 }
1511
1512 bool wxGroupBoxPropertyInfo::SetProperty(wxString& name, wxProperty *property)
1513 {
1514   return wxItemPropertyInfo::SetProperty(name, property);
1515 }
1516
1517 void wxGroupBoxPropertyInfo::GetPropertyNames(wxStringList& names)
1518 {
1519   wxItemPropertyInfo::GetPropertyNames(names);
1520   names.Add("label");
1521 }
1522
1523 bool wxGroupBoxPropertyInfo::InstantiateResource(wxItemResource *resource)
1524 {
1525   return wxItemPropertyInfo::InstantiateResource(resource);
1526 }
1527
1528 /*
1529  * Checkbox item
1530  */
1531
1532 wxProperty *wxCheckBoxPropertyInfo::GetProperty(wxString& name)
1533 {
1534   wxCheckBox *checkBox = (wxCheckBox *)m_propertyWindow;
1535   if (name == "value")
1536     return new wxProperty("value", checkBox->GetValue(), "bool");
1537   else
1538     return wxItemPropertyInfo::GetProperty(name);
1539 }
1540
1541 bool wxCheckBoxPropertyInfo::SetProperty(wxString& name, wxProperty *property)
1542 {
1543   wxCheckBox *checkBox = (wxCheckBox *)m_propertyWindow;
1544   if (name == "value")
1545   {
1546     checkBox->SetValue((bool)property->GetValue().BoolValue());
1547     return TRUE;
1548   }
1549   else
1550     return wxItemPropertyInfo::SetProperty(name, property);
1551 }
1552
1553 void wxCheckBoxPropertyInfo::GetPropertyNames(wxStringList& names)
1554 {
1555   wxItemPropertyInfo::GetPropertyNames(names);
1556   names.Add("label");
1557   names.Add("value");
1558 }
1559
1560 bool wxCheckBoxPropertyInfo::InstantiateResource(wxItemResource *resource)
1561 {
1562   wxCheckBox *cbox = (wxCheckBox *)m_propertyWindow;
1563   resource->SetValue1(cbox->GetValue());
1564   return wxItemPropertyInfo::InstantiateResource(resource);
1565 }
1566
1567 /*
1568  * Radiobutton item
1569  */
1570
1571 wxProperty *wxRadioButtonPropertyInfo::GetProperty(wxString& name)
1572 {
1573   wxRadioButton *checkBox = (wxRadioButton *)m_propertyWindow;
1574   if (name == "value")
1575     return new wxProperty("value", checkBox->GetValue(), "bool");
1576   else
1577     return wxItemPropertyInfo::GetProperty(name);
1578 }
1579
1580 bool wxRadioButtonPropertyInfo::SetProperty(wxString& name, wxProperty *property)
1581 {
1582   wxRadioButton *checkBox = (wxRadioButton *)m_propertyWindow;
1583   if (name == "value")
1584   {
1585     checkBox->SetValue((bool)property->GetValue().BoolValue());
1586     return TRUE;
1587   }
1588   else
1589     return wxItemPropertyInfo::SetProperty(name, property);
1590 }
1591
1592 void wxRadioButtonPropertyInfo::GetPropertyNames(wxStringList& names)
1593 {
1594   wxItemPropertyInfo::GetPropertyNames(names);
1595   names.Add("label");
1596   names.Add("value");
1597 }
1598
1599 bool wxRadioButtonPropertyInfo::InstantiateResource(wxItemResource *resource)
1600 {
1601   wxRadioButton *cbox = (wxRadioButton *)m_propertyWindow;
1602   resource->SetValue1(cbox->GetValue());
1603   return wxItemPropertyInfo::InstantiateResource(resource);
1604 }
1605
1606 /*
1607  * Slider item
1608  */
1609
1610 wxProperty *wxSliderPropertyInfo::GetProperty(wxString& name)
1611 {
1612   wxSlider *slider = (wxSlider *)m_propertyWindow;
1613   if (name == "value")
1614     return new wxProperty("value", (long)slider->GetValue(), "integer");
1615   else if (name == "orientation")
1616   {
1617     char *pos = NULL;
1618     if (m_propertyWindow->GetWindowStyleFlag() & wxHORIZONTAL)
1619       pos = "wxHORIZONTAL";
1620     else
1621       pos = "wxVERTICAL";
1622
1623     return new wxProperty("orientation", pos, "string",
1624        new wxStringListValidator(new wxStringList("wxHORIZONTAL", "wxVERTICAL",
1625           NULL)));
1626   }
1627   else if (name == "minValue")
1628     return new wxProperty("minValue", (long)slider->GetMin(), "integer");
1629   else if (name == "maxValue")
1630     return new wxProperty("maxValue", (long)slider->GetMax(), "integer");
1631   else
1632     return wxItemPropertyInfo::GetProperty(name);
1633 }
1634
1635 bool wxSliderPropertyInfo::SetProperty(wxString& name, wxProperty *property)
1636 {
1637   wxSlider *slider = (wxSlider *)m_propertyWindow;
1638   if (name == "value")
1639   {
1640     slider->SetValue((int)property->GetValue().IntegerValue());
1641     return TRUE;
1642   }
1643   else if (name == "orientation")
1644   {
1645     long windowStyle = slider->GetWindowStyleFlag();
1646     long oldWindowStyle = windowStyle;
1647     wxString val(property->GetValue().StringValue());
1648     if (val == "wxHORIZONTAL")
1649     {
1650       if (windowStyle & wxVERTICAL)
1651         windowStyle -= wxVERTICAL;
1652       windowStyle |= wxHORIZONTAL;
1653     }
1654     else
1655     {
1656       if (windowStyle & wxHORIZONTAL)
1657         windowStyle -= wxHORIZONTAL;
1658       windowStyle |= wxVERTICAL;
1659     }
1660
1661     if (oldWindowStyle == windowStyle)
1662       return TRUE;
1663
1664     slider->SetWindowStyleFlag(windowStyle);
1665
1666     // If the window style has changed, we swap the width and height parameters.
1667     int w, h;
1668     slider->GetSize(&w, &h);
1669
1670     slider = (wxSlider *)wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(slider, this);
1671     slider->SetSize(-1, -1, h, w);
1672
1673     return TRUE;
1674   }
1675   else if (name == "minValue")
1676   {
1677     slider->SetRange((int)property->GetValue().IntegerValue(), slider->GetMax());
1678     return TRUE;
1679   }
1680   else if (name == "maxValue")
1681   {
1682     slider->SetRange(slider->GetMin(), (int)property->GetValue().IntegerValue());
1683     return TRUE;
1684   }
1685   else
1686     return wxItemPropertyInfo::SetProperty(name, property);
1687 }
1688
1689 void wxSliderPropertyInfo::GetPropertyNames(wxStringList& names)
1690 {
1691   wxItemPropertyInfo::GetPropertyNames(names);
1692   names.Add("value");
1693   names.Add("orientation");
1694   names.Add("minValue");
1695   names.Add("maxValue");
1696 }
1697
1698 bool wxSliderPropertyInfo::InstantiateResource(wxItemResource *resource)
1699 {
1700   wxSlider *slider = (wxSlider *)m_propertyWindow;
1701   resource->SetValue1(slider->GetValue());
1702   resource->SetValue2(slider->GetMin());
1703   resource->SetValue3(slider->GetMax());
1704   return wxItemPropertyInfo::InstantiateResource(resource);
1705 }
1706
1707 /*
1708  * Gauge item
1709  */
1710
1711 wxProperty *wxGaugePropertyInfo::GetProperty(wxString& name)
1712 {
1713   wxGauge *gauge = (wxGauge *)m_propertyWindow;
1714   if (name == "value")
1715     return new wxProperty("value", (long)gauge->GetValue(), "integer");
1716   else if (name == "maxValue")
1717     return new wxProperty("maxValue", (long)gauge->GetRange(), "integer");
1718   else
1719     return wxItemPropertyInfo::GetProperty(name);
1720 }
1721
1722 bool wxGaugePropertyInfo::SetProperty(wxString& name, wxProperty *property)
1723 {
1724   wxGauge *gauge = (wxGauge *)m_propertyWindow;
1725   if (name == "value")
1726   {
1727     gauge->SetValue((int)property->GetValue().IntegerValue());
1728     return TRUE;
1729   }
1730   else if (name == "maxValue")
1731   {
1732     gauge->SetRange((int)property->GetValue().IntegerValue());
1733     return TRUE;
1734   }
1735   else
1736     return wxItemPropertyInfo::SetProperty(name, property);
1737 }
1738
1739 void wxGaugePropertyInfo::GetPropertyNames(wxStringList& names)
1740 {
1741   wxItemPropertyInfo::GetPropertyNames(names);
1742   names.Add("value");
1743   names.Add("maxValue");
1744 }
1745
1746 bool wxGaugePropertyInfo::InstantiateResource(wxItemResource *resource)
1747 {
1748   wxGauge *gauge = (wxGauge *)m_propertyWindow;
1749   resource->SetValue1(gauge->GetValue());
1750   resource->SetValue2(gauge->GetRange());
1751   return wxItemPropertyInfo::InstantiateResource(resource);
1752 }
1753
1754 /*
1755  * Scrollbar item
1756  */
1757
1758 wxProperty *wxScrollBarPropertyInfo::GetProperty(wxString& name)
1759 {
1760   wxScrollBar *scrollBar = (wxScrollBar *)m_propertyWindow;
1761   if (name == "thumbPosition")
1762     return new wxProperty("value", (long)scrollBar->GetThumbPosition(), "integer");
1763   else if (name == "orientation")
1764   {
1765     char *pos = NULL;
1766     if (m_propertyWindow->GetWindowStyleFlag() & wxHORIZONTAL)
1767       pos = "wxHORIZONTAL";
1768     else
1769       pos = "wxVERTICAL";
1770
1771     return new wxProperty("orientation", pos, "string",
1772        new wxStringListValidator(new wxStringList("wxHORIZONTAL", "wxVERTICAL",
1773           NULL)));
1774   }
1775   else if (name == "pageSize")
1776   {
1777     int pageLength = scrollBar->GetPageSize();
1778
1779     return new wxProperty("pageSize", (long)pageLength, "integer");
1780   }
1781   else if (name == "thumbSize")
1782   {
1783     int thumbSize = scrollBar->GetThumbSize();
1784
1785     return new wxProperty("thumbSize", (long)thumbSize, "integer");
1786   }
1787   else if (name == "range")
1788   {
1789     int range = scrollBar->GetRange();
1790     return new wxProperty("range", (long)range, "integer");
1791   }
1792   else
1793     return wxItemPropertyInfo::GetProperty(name);
1794 }
1795
1796 bool wxScrollBarPropertyInfo::SetProperty(wxString& name, wxProperty *property)
1797 {
1798   wxScrollBar *scrollBar = (wxScrollBar *)m_propertyWindow;
1799   if (name == "thumbPosition")
1800   {
1801     scrollBar->SetThumbPosition((int)property->GetValue().IntegerValue());
1802     return TRUE;
1803   }
1804   else if (name == "orientation")
1805   {
1806     long windowStyle = scrollBar->GetWindowStyleFlag();
1807     long oldWindowStyle = windowStyle;
1808     wxString val(property->GetValue().StringValue());
1809     if (val == "wxHORIZONTAL")
1810     {
1811       if (windowStyle & wxVERTICAL)
1812         windowStyle -= wxVERTICAL;
1813       windowStyle |= wxHORIZONTAL;
1814     }
1815     else
1816     {
1817       if (windowStyle & wxHORIZONTAL)
1818         windowStyle -= wxHORIZONTAL;
1819       windowStyle |= wxVERTICAL;
1820     }
1821
1822     if (oldWindowStyle == windowStyle)
1823       return TRUE;
1824
1825     scrollBar->SetWindowStyleFlag(windowStyle);
1826
1827     // If the window style has changed, we swap the width and height parameters.
1828 //    int w, h;
1829 //    scrollBar->GetSize(&w, &h);
1830     wxItemResource      *item = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(scrollBar);
1831         if ( item ) {
1832                 item->SetSize(item->GetX(), item->GetY(), item->GetHeight(), item->GetWidth());
1833                 item->SetStyle(windowStyle);
1834         } /* IF */
1835
1836     scrollBar = (wxScrollBar *)wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(scrollBar, this);
1837
1838     return TRUE;
1839   }
1840   else if (name == "pageSize")
1841   {
1842     int pos = scrollBar->GetThumbPosition();
1843     int range = scrollBar->GetRange();
1844     int thumbSize = scrollBar->GetThumbSize();
1845     scrollBar->SetScrollbar(pos, thumbSize, range, (int)property->GetValue().IntegerValue());
1846     return TRUE;
1847   }
1848   else if (name == "thumbSize")
1849   {
1850     int pos = scrollBar->GetThumbPosition();
1851     int range = scrollBar->GetRange();
1852     int pageSize = scrollBar->GetPageSize();
1853     scrollBar->SetScrollbar(pos, (int)property->GetValue().IntegerValue(), range, pageSize);
1854     return TRUE;
1855   }
1856   else if (name == "range")
1857   {
1858     int pos = scrollBar->GetThumbPosition();
1859     int thumbSize = scrollBar->GetThumbSize();
1860     int pageSize = scrollBar->GetPageSize();
1861     scrollBar->SetScrollbar(pos, thumbSize, (int)property->GetValue().IntegerValue(), pageSize);
1862     return TRUE;
1863   }
1864   else
1865     return wxItemPropertyInfo::SetProperty(name, property);
1866 }
1867
1868 void wxScrollBarPropertyInfo::GetPropertyNames(wxStringList& names)
1869 {
1870   wxItemPropertyInfo::GetPropertyNames(names);
1871   names.Add("orientation");
1872   names.Add("thumbPosition");
1873   names.Add("thumbSize");
1874   names.Add("pageSize");
1875   names.Add("range");
1876
1877   // Remove some properties we don't inherit
1878   names.Delete("fontPoints");
1879   names.Delete("fontFamily");
1880   names.Delete("fontStyle");
1881   names.Delete("fontWeight");
1882   names.Delete("fontUnderlined");
1883 }
1884
1885 bool wxScrollBarPropertyInfo::InstantiateResource(wxItemResource *resource)
1886 {
1887   wxScrollBar *sbar = (wxScrollBar *)m_propertyWindow;
1888
1889   int thumbPosition = sbar->GetThumbPosition();
1890   int thumbSize = sbar->GetThumbSize();
1891   int pageSize = sbar->GetPageSize();
1892   int range = sbar->GetRange();
1893
1894   resource->SetValue1(thumbPosition);
1895   resource->SetValue2(thumbSize);
1896   resource->SetValue3(range);
1897   resource->SetValue5(pageSize);
1898
1899   return wxItemPropertyInfo::InstantiateResource(resource);
1900 }
1901
1902 /*
1903  * Panels
1904  */
1905
1906 wxProperty *wxPanelPropertyInfo::GetProperty(wxString& name)
1907 {
1908   wxPanel *panelWindow = (wxPanel *)m_propertyWindow;
1909
1910 /*
1911   wxFont *labelFont = panelWindow->GetLabelFont();
1912   wxFont *buttonFont = panelWindow->GetButtonFont();
1913
1914   if (name == "labelFontPoints" || name == "labelFontFamily" || name == "labelFontStyle" || name == "labelFontWeight" ||
1915       name == "labelFontUnderlined")
1916     return GetFontProperty(name, labelFont);
1917   else if (name == "buttonFontPoints" || name == "buttonFontFamily" || name == "buttonFontStyle" || name == "buttonFontWeight" ||
1918       name == "buttonFontUnderlined")
1919     return GetFontProperty(name, buttonFont);
1920 */
1921
1922   if (name == "no3D")
1923   {
1924     bool userColours;
1925     if (panelWindow->GetWindowStyleFlag() & wxNO_3D)
1926       userColours = TRUE;
1927     else
1928       userColours = FALSE;
1929
1930     return new wxProperty(name, (bool)userColours, "bool");
1931   }
1932   else if (name == "backgroundColour")
1933   {
1934     wxColour col(panelWindow->GetBackgroundColour());
1935     char buf[7];
1936     wxDecToHex(col.Red(), buf);
1937     wxDecToHex(col.Green(), buf+2);
1938     wxDecToHex(col.Blue(), buf+4);
1939
1940     return new wxProperty(name, buf, "string", new wxColourListValidator);
1941   }
1942   else if (name == "title")
1943   {
1944     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
1945     if (resource)
1946         return new wxProperty(name, resource->GetTitle(), "string");
1947     else
1948         return new wxProperty(name, "Could not get title", "string");
1949   }
1950   else if (name == "caption")
1951   {
1952     return new wxProperty(name, ((panelWindow->GetWindowStyleFlag() & wxCAPTION) == wxCAPTION),
1953         "bool");
1954   }
1955   else if (name == "systemMenu")
1956   {
1957     return new wxProperty(name, ((panelWindow->GetWindowStyleFlag() & wxSYSTEM_MENU) == wxSYSTEM_MENU),
1958         "bool");
1959   }
1960   else if (name == "thickFrame")
1961   {
1962     return new wxProperty(name, ((panelWindow->GetWindowStyleFlag() & wxTHICK_FRAME) == wxTHICK_FRAME),
1963         "bool");
1964   }
1965   else if (name == "useSystemDefaults")
1966   {
1967     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
1968     return new wxProperty(name, ((resource->GetResourceStyle() & wxRESOURCE_USE_DEFAULTS) == wxRESOURCE_USE_DEFAULTS),
1969         "bool");
1970   }
1971   else if (name == "useDialogUnits")
1972   {
1973     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
1974     return new wxProperty(name, ((resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS) == wxRESOURCE_DIALOG_UNITS),
1975         "bool");
1976   }
1977   else
1978     return wxWindowPropertyInfo::GetProperty(name);
1979 }
1980
1981 bool wxPanelPropertyInfo::SetProperty(wxString& name, wxProperty *property)
1982 {
1983   wxPanel *panelWindow = (wxPanel *)m_propertyWindow;
1984 /*
1985   wxFont *labelFont = panelWindow->GetLabelFont();
1986   wxFont *buttonFont = panelWindow->GetButtonFont();
1987
1988   if (labelFont && (name == "labelFontPoints" || name == "labelFontFamily" || name == "labelFontStyle" || name == "labelFontWeight" || name == "labelFontUnderlined" ))
1989   {
1990     wxFont *newFont = SetFontProperty(name, property, labelFont);
1991     if (newFont)
1992       panelWindow->SetLabelFont(* newFont);
1993     return TRUE;
1994   }
1995   else if (buttonFont && (name == "buttonFontPoints" || name == "buttonFontFamily" || name == "buttonFontStyle" || name == "buttonFontWeight" || name == "buttonFontUnderlined" ))
1996   {
1997     wxFont *newFont = SetFontProperty(name, property, buttonFont);
1998     if (newFont)
1999       panelWindow->SetButtonFont(* newFont);
2000     return TRUE;
2001   }
2002 */
2003
2004   if (name == "no3D")
2005   {
2006     bool userColours = property->GetValue().BoolValue();
2007
2008     if (userColours)
2009     {
2010       if ((panelWindow->GetWindowStyleFlag() & wxNO_3D) != wxNO_3D)
2011         panelWindow->SetWindowStyleFlag(panelWindow->GetWindowStyleFlag() | wxNO_3D);
2012     }
2013     else
2014     {
2015       if ((panelWindow->GetWindowStyleFlag() & wxNO_3D) == wxNO_3D)
2016         panelWindow->SetWindowStyleFlag(panelWindow->GetWindowStyleFlag() - wxNO_3D);
2017     }
2018     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
2019     resource->SetStyle(panelWindow->GetWindowStyleFlag());
2020
2021     panelWindow = (wxPanel *)wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(panelWindow, this);
2022     return TRUE;
2023   }
2024   else if (name == "backgroundColour")
2025   {
2026     char *hex = property->GetValue().StringValue();
2027     int r = wxHexToDec(hex);
2028     int g = wxHexToDec(hex+2);
2029     int b = wxHexToDec(hex+4);
2030
2031     wxColour col(r,g,b);
2032     panelWindow->SetBackgroundColour(col);
2033     panelWindow = (wxPanel *)wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(panelWindow, this);
2034    return TRUE;
2035   }
2036   else if (name == "title")
2037   {
2038     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
2039     if (resource)
2040     {
2041         resource->SetTitle(property->GetValue().StringValue());
2042         return TRUE;
2043     }
2044     else
2045         return FALSE;
2046   }
2047   else if (name == "caption")
2048   {
2049     SetWindowStyle(panelWindow, wxCAPTION, property->GetValue().BoolValue());
2050
2051     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
2052     resource->SetStyle(panelWindow->GetWindowStyleFlag());
2053     return TRUE;
2054   }
2055   else if (name == "thickFrame")
2056   {
2057     SetWindowStyle(panelWindow, wxTHICK_FRAME, property->GetValue().BoolValue());
2058
2059     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
2060     resource->SetStyle(panelWindow->GetWindowStyleFlag());
2061     return TRUE;
2062   }
2063   else if (name == "systemMenu")
2064   {
2065     SetWindowStyle(panelWindow, wxSYSTEM_MENU, property->GetValue().BoolValue());
2066
2067     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
2068     resource->SetStyle(panelWindow->GetWindowStyleFlag());
2069     return TRUE;
2070   }
2071   else if (name == "useSystemDefaults")
2072   {
2073     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
2074     bool useDefaults = property->GetValue().BoolValue();
2075     long style = resource->GetResourceStyle();
2076     if (useDefaults)
2077     {
2078         if ((style & wxRESOURCE_USE_DEFAULTS) == 0)
2079             style |= wxRESOURCE_USE_DEFAULTS;
2080     }
2081     else
2082     {
2083         if ((style & wxRESOURCE_USE_DEFAULTS) != 0)
2084             style -= wxRESOURCE_USE_DEFAULTS;
2085     }
2086     resource->SetResourceStyle(style);
2087     panelWindow = (wxPanel *)wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(panelWindow, this);
2088     return TRUE;
2089   }
2090   else if (name == "useDialogUnits")
2091   {
2092     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
2093     bool useDialogUnits = property->GetValue().BoolValue();
2094     long style = resource->GetResourceStyle();
2095     if (useDialogUnits)
2096     {
2097         if ((style & wxRESOURCE_DIALOG_UNITS) == 0)
2098         {
2099             style |= wxRESOURCE_DIALOG_UNITS;
2100             ConvertDialogUnits(TRUE); // Convert all resources
2101         }
2102     }
2103     else
2104     {
2105         if ((style & wxRESOURCE_DIALOG_UNITS) != 0)
2106         {
2107             style -= wxRESOURCE_DIALOG_UNITS;
2108             ConvertDialogUnits(FALSE); // Convert all resources
2109         }
2110     }
2111     resource->SetResourceStyle(style);
2112     panelWindow = (wxPanel *)wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(panelWindow, this);
2113     // TODO: need to regenerate the width and height properties else they'll be inconsistent.
2114     return TRUE;
2115   }
2116   else
2117     return wxWindowPropertyInfo::SetProperty(name, property);
2118 }
2119
2120 void wxPanelPropertyInfo::GetPropertyNames(wxStringList& names)
2121 {
2122   wxWindowPropertyInfo::GetPropertyNames(names);
2123
2124   names.Add("title");
2125   names.Add("no3D");
2126   names.Add("backgroundColour");
2127   names.Add("caption");
2128   names.Add("systemMenu");
2129   names.Add("thickFrame");
2130   names.Add("useSystemDefaults");
2131   names.Add("useDialogUnits");
2132 }
2133
2134 bool wxPanelPropertyInfo::InstantiateResource(wxItemResource *resource)
2135 {
2136   wxPanel *panel = (wxPanel *)m_propertyWindow;
2137   if (panel->GetFont().Ok())
2138     resource->SetFont(* wxTheFontList->FindOrCreateFont(panel->GetFont().GetPointSize(),
2139                 panel->GetFont().GetFamily(), panel->GetFont().GetStyle(), panel->GetFont().GetWeight(),
2140                 panel->GetFont().GetUnderlined(), panel->GetFont().GetFaceName()));
2141
2142   resource->SetBackgroundColour(wxColour(panel->GetBackgroundColour()));
2143
2144   return wxWindowPropertyInfo::InstantiateResource(resource);
2145 }
2146
2147 // Convert this dialog, and its children, to or from dialog units
2148 void wxPanelPropertyInfo::ConvertDialogUnits(bool toDialogUnits)
2149 {
2150     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
2151
2152     wxPoint pt;
2153     wxSize sz;
2154     if (toDialogUnits)
2155     {
2156         sz = m_propertyWindow->ConvertPixelsToDialog(wxSize(resource->GetWidth(), resource->GetHeight()));
2157         pt = m_propertyWindow->ConvertPixelsToDialog(wxPoint(resource->GetX(), resource->GetY()));
2158     }
2159     else
2160     {
2161         sz = m_propertyWindow->ConvertDialogToPixels(wxSize(resource->GetWidth(), resource->GetHeight()));
2162         pt = m_propertyWindow->ConvertDialogToPixels(wxPoint(resource->GetX(), resource->GetY()));
2163     }
2164     resource->SetSize(pt.x, pt.y, sz.x, sz.y);
2165
2166     wxNode* node = m_propertyWindow->GetChildren().First();
2167     while (node)
2168     {
2169         wxWindow* child = (wxWindow*) node->Data();
2170         if (child->IsKindOf(CLASSINFO(wxControl)))
2171         {
2172             resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(child);
2173             if (toDialogUnits)
2174             {
2175                 sz = m_propertyWindow->ConvertPixelsToDialog(wxSize(resource->GetWidth(), resource->GetHeight()));
2176                 pt = m_propertyWindow->ConvertPixelsToDialog(wxPoint(resource->GetX(), resource->GetY()));
2177             }
2178             else
2179             {
2180                 sz = m_propertyWindow->ConvertDialogToPixels(wxSize(resource->GetWidth(), resource->GetHeight()));
2181                 pt = m_propertyWindow->ConvertDialogToPixels(wxPoint(resource->GetX(), resource->GetY()));
2182             }
2183             resource->SetSize(pt.x, pt.y, sz.x, sz.y);
2184         }
2185         node = node->Next();
2186     }
2187 }
2188
2189 #if 0
2190 /*
2191  * Dialog boxes
2192  */
2193
2194 wxProperty *wxDialogPropertyInfo::GetProperty(wxString& name)
2195 {
2196   wxDialog *dialogWindow = (wxDialog *)m_propertyWindow;
2197   if (name == "modal")
2198   {
2199     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(dialogWindow);
2200     if (!resource)
2201       return NULL;
2202
2203     bool modal = (resource->GetValue1() != 0);
2204     return new wxProperty(name, modal, "bool");
2205   }
2206   else
2207     return wxPanelPropertyInfo::GetProperty(name);
2208 }
2209
2210 bool wxDialogPropertyInfo::SetProperty(wxString& name, wxProperty *property)
2211 {
2212   wxDialog *dialogWindow = (wxDialog *)m_propertyWindow;
2213
2214   if (name == "modal")
2215   {
2216     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(dialogWindow);
2217     if (!resource)
2218       return FALSE;
2219
2220     resource->SetValue1(property->GetValue().BoolValue());
2221     return TRUE;
2222   }
2223   else
2224     return wxPanelPropertyInfo::SetProperty(name, property);
2225 }
2226
2227 void wxDialogPropertyInfo::GetPropertyNames(wxStringList& names)
2228 {
2229   wxPanelPropertyInfo::GetPropertyNames(names);
2230   names.Add("title");
2231   names.Add("modal");
2232 }
2233
2234 bool wxDialogPropertyInfo::InstantiateResource(wxItemResource *resource)
2235 {
2236   wxDialog *dialog = (wxDialog *)m_propertyWindow;
2237   wxString str(dialog->GetTitle());
2238   resource->SetTitle(str);
2239
2240   return wxPanelPropertyInfo::InstantiateResource(resource);
2241 }
2242 #endif
2243
2244 /*
2245  * Utilities
2246  */
2247
2248 int wxStringToFontWeight(wxString& val)
2249 {
2250   if (val == "wxBOLD") return wxBOLD;
2251   else if (val == "wxLIGHT") return wxLIGHT;
2252   else return wxNORMAL;
2253 }
2254
2255 int wxStringToFontStyle(wxString& val)
2256 {
2257   if (val == "wxITALIC") return wxITALIC;
2258   else if (val == "wxSLANT") return wxSLANT;
2259   else return wxNORMAL;
2260 }
2261
2262 int wxStringToFontFamily(wxString& val)
2263 {
2264   if (val == "wxDECORATIVE") return wxDECORATIVE;
2265   else if (val == "wxROMAN") return wxROMAN;
2266   else if (val == "wxSCRIPT") return wxSCRIPT;
2267   else if (val == "wxMODERN") return wxMODERN;
2268   else if (val == "wxTELETYPE") return wxTELETYPE;
2269   else return wxSWISS;
2270 }
2271
2272 ///
2273 /// Resource symbol validator
2274 ///
2275 IMPLEMENT_DYNAMIC_CLASS(wxResourceSymbolValidator, wxPropertyListValidator)
2276
2277 wxResourceSymbolValidator::wxResourceSymbolValidator(long flags):
2278   wxPropertyListValidator(flags)
2279 {
2280 }
2281
2282 wxResourceSymbolValidator::~wxResourceSymbolValidator(void)
2283 {
2284 }
2285
2286 bool wxResourceSymbolValidator::OnCheckValue(wxProperty *WXUNUSED(property), wxPropertyListView *WXUNUSED(view), wxWindow *WXUNUSED(parentWindow))
2287 {
2288   return TRUE;
2289 }
2290
2291 // Called when TICK is pressed or focus is lost or view wants to update
2292 // the property list.
2293 // Does the transferance from the property editing area to the property itself
2294 bool wxResourceSymbolValidator::OnRetrieveValue(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
2295 {
2296   if (!view->GetValueText())
2297     return FALSE;
2298   wxString value(view->GetValueText()->GetValue());
2299   property->GetValue() = value ;
2300   return TRUE;
2301 }
2302
2303 // Called when TICK is pressed or focus is lost or view wants to update
2304 // the property list.
2305 // Does the transferance from the property editing area to the property itself
2306 bool wxResourceSymbolValidator::OnDisplayValue(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
2307 {
2308   if (!view->GetValueText())
2309     return FALSE;
2310   wxString str(property->GetValue().GetStringRepresentation());
2311   view->GetValueText()->SetValue(str);
2312   return TRUE;
2313 }
2314
2315 // Called when the property is double clicked. Extra functionality can be provided,
2316 // cycling through possible values.
2317 bool wxResourceSymbolValidator::OnDoubleClick(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow)
2318 {
2319   if (!view->GetValueText())
2320     return FALSE;
2321   OnEdit(property, view, parentWindow);
2322   return TRUE;
2323 }
2324
2325 bool wxResourceSymbolValidator::OnPrepareControls(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
2326 {
2327   if (view->GetConfirmButton())
2328     view->GetConfirmButton()->Enable(TRUE);
2329   if (view->GetCancelButton())
2330     view->GetCancelButton()->Enable(TRUE);
2331   if (view->GetEditButton())
2332     view->GetEditButton()->Enable(TRUE);
2333   if (view->GetValueText())
2334     view->GetValueText()->Enable((GetFlags() & wxPROP_ALLOW_TEXT_EDITING) == wxPROP_ALLOW_TEXT_EDITING);
2335   return TRUE;
2336 }
2337
2338 void wxResourceSymbolValidator::OnEdit(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow)
2339 {
2340   if (!view->GetValueText())
2341     return;
2342
2343   wxResourceSymbolDialog* dialog = new wxResourceSymbolDialog(parentWindow, -1, "Edit Symbol");
2344
2345   // Split name/id pair e.g. "IDC_TEXT=123"
2346   wxString value(property->GetValue().StringValue());
2347
2348   wxString strName = value.Before('=');
2349   wxString strId = value.After('=');
2350
2351   dialog->SetSymbol(strName);
2352   dialog->SetId(atoi(strId));
2353
2354   dialog->Init();
2355
2356   if (dialog->ShowModal() == wxID_OK)
2357   {
2358     wxString symbolName(dialog->GetSymbol());
2359     long id = dialog->GetId();
2360     dialog->Destroy();
2361
2362     wxString str;
2363     str.Printf("%d", id);
2364     property->GetValue() = symbolName + wxString("=") + str;
2365
2366     view->DisplayProperty(property);
2367     view->UpdatePropertyDisplayInList(property);
2368     view->OnPropertyChanged(property);
2369   }
2370 }
2371
2372 BEGIN_EVENT_TABLE(wxResourceSymbolDialog, wxDialog)
2373     EVT_BUTTON(wxID_OK, wxResourceSymbolDialog::OnOK)
2374     EVT_COMBOBOX(ID_SYMBOLNAME_COMBOBOX, wxResourceSymbolDialog::OnComboBoxSelect)
2375     EVT_TEXT(ID_SYMBOLNAME_COMBOBOX, wxResourceSymbolDialog::OnSymbolNameUpdate)
2376 END_EVENT_TABLE()
2377
2378 wxResourceSymbolDialog::wxResourceSymbolDialog(wxWindow* parent, const wxWindowID id, const wxString& title, const wxPoint& pos,
2379         const wxSize& size, long style):
2380     wxDialog(parent, id, title, pos, size, style)
2381 {
2382     int x = 5;
2383     int y = 5;
2384
2385     (void) new wxStaticText(this, -1, "Name: ", wxPoint(x, y));
2386
2387     x += 80;
2388
2389     m_nameCtrl = new wxComboBox(this, ID_SYMBOLNAME_COMBOBOX, "",
2390         wxPoint(x, y), wxSize(200, -1), 0, NULL, wxCB_DROPDOWN|wxCB_SORT);
2391
2392     y += 30;
2393     x = 5;
2394
2395     (void) new wxStaticText(this, -1, "Id: ", wxPoint(x, y));
2396
2397     x += 80;
2398
2399     m_idCtrl = new wxTextCtrl(this, ID_SYMBOLID_TEXTCTRL, "",
2400         wxPoint(x, y), wxSize(200, -1));
2401
2402     y += 30;
2403     x = 5;
2404     (void) new wxButton(this, wxID_OK, "OK", wxPoint(x, y), wxSize(80, -1));
2405
2406     x += 100;
2407     (void) new wxButton(this, wxID_CANCEL, "Cancel", wxPoint(x, y), wxSize(80, -1));
2408
2409     Fit();
2410     Centre();
2411 }
2412
2413 void wxResourceSymbolDialog::Init()
2414 {
2415     wxString defaultId;
2416     defaultId.Printf("%ld", m_symbolId);
2417
2418     m_nameCtrl->SetValue(m_symbolName);
2419     m_idCtrl->SetValue(defaultId);
2420
2421     wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().FillComboBox(m_nameCtrl);
2422 }
2423
2424 void wxResourceSymbolDialog::OnOK(wxCommandEvent& event)
2425 {
2426     if (CheckValues())
2427     {
2428         wxDialog::OnOK(event);
2429     }
2430 }
2431
2432 bool wxResourceSymbolDialog::CheckValues()
2433 {
2434     wxString nameStr(m_nameCtrl->GetValue());
2435     wxString idStr(m_idCtrl->GetValue());
2436     int id = atoi(idStr);
2437
2438     if (id <= 0 )
2439     {
2440         wxMessageBox("Identifier cannot be missing or zero", "Dialog Editor", wxOK|wxICON_EXCLAMATION, this);
2441         return FALSE;
2442     }
2443     if (nameStr == "")
2444     {
2445         wxMessageBox("Please enter a symbol name", "Dialog Editor", wxOK|wxICON_EXCLAMATION, this);
2446         return FALSE;
2447     }
2448     if (nameStr.Contains(" "))
2449     {
2450         wxMessageBox("Symbol name cannot contain spaces.", "Dialog Editor", wxOK|wxICON_EXCLAMATION, this);
2451         return FALSE;
2452     }
2453     if (nameStr.Contains("="))
2454     {
2455         wxMessageBox("Symbol name cannot contain =.", "Dialog Editor", wxOK|wxICON_EXCLAMATION, this);
2456         return FALSE;
2457     }
2458     if (nameStr.IsNumber())
2459     {
2460         wxMessageBox("Symbol name cannot be a number.", "Dialog Editor", wxOK|wxICON_EXCLAMATION, this);
2461         return FALSE;
2462     }
2463     // TODO: other checks on the name syntax.
2464
2465     if (!wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().IsStandardSymbol(nameStr))
2466     {
2467         // If we change the id for an existing symbol, we need to:
2468         // 1) Check if there are any other resources currently using the original id.
2469         //    If so, will need to change their id to the new id, in SetProperty.
2470         // 2) Remove the old symbol, add the new symbol.
2471         // In this check, we don't have to do this, but we need to do it in SetProperty.
2472
2473         if (nameStr == GetSymbol() && id != GetId())
2474         {
2475             // It's OK to change the id. But we'll need to change all matching ids in all resources,
2476             // in SetProperty.
2477         }
2478
2479         // If we change the name but not the id... we'll just need to remove and
2480         // re-add the symbol/id pair, in SetProperty.
2481         if (nameStr != GetSymbol() && id == GetId())
2482         {
2483         }
2484
2485         // What if we're changing both the name and the id?
2486         // - if there's no symbol of that name, just remove the old, add the new (in SetProperty)
2487         // - if there is a symbol of that name, if id matches, do nothing. If not, veto.
2488
2489         if (nameStr != GetSymbol() && id != GetId())
2490         {
2491             if (!wxResourceManager::GetCurrentResourceManager()->IsIdentifierOK(nameStr, id))
2492             {
2493                 wxMessageBox("This integer id is already being used under a different name.\nPlease choose another.",
2494                     "Dialog Editor", wxOK|wxICON_EXCLAMATION, this);
2495                 return FALSE;
2496             }
2497         }
2498
2499     }
2500
2501     SetSymbol(nameStr);
2502     SetId(id);
2503
2504     return TRUE;
2505 }
2506
2507 void wxResourceSymbolDialog::OnComboBoxSelect(wxCommandEvent& WXUNUSED(event))
2508 {
2509     wxString str(m_nameCtrl->GetStringSelection());
2510     if (wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().IsStandardSymbol(str))
2511     {
2512         int id = wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().GetIdForSymbol(str);
2513         wxString str2;
2514         str2.Printf("%d", id);
2515         m_idCtrl->SetValue(str2);
2516         m_idCtrl->Enable(FALSE);
2517     }
2518     else
2519     {
2520         if (wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().SymbolExists(str))
2521         {
2522             int id = wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().GetIdForSymbol(str);
2523             wxString str2;
2524             str2.Printf("%d", id);
2525             m_idCtrl->SetValue(str2);
2526         }
2527         m_idCtrl->Enable(TRUE);
2528     }
2529 }
2530
2531 void wxResourceSymbolDialog::OnSymbolNameUpdate(wxCommandEvent& WXUNUSED(event))
2532 {
2533     wxString str(m_nameCtrl->GetValue());
2534     if (wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().IsStandardSymbol(str))
2535     {
2536         int id = wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().GetIdForSymbol(str);
2537         wxString str2;
2538         str2.Printf("%d", id);
2539         m_idCtrl->SetValue(str2);
2540         m_idCtrl->Enable(FALSE);
2541     }
2542     else
2543     {
2544         if (wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().SymbolExists(str))
2545         {
2546             int id = wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().GetIdForSymbol(str);
2547             wxString str2;
2548             str2.Printf("%d", id);
2549             m_idCtrl->SetValue(str2);
2550         }
2551         m_idCtrl->Enable(TRUE);
2552     }
2553 }
2554