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