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