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
2012 wxProperty *wxPanelPropertyInfo::GetProperty(wxString& name)
2013 {
2014     wxPanel *panelWindow = (wxPanel *)m_propertyWindow;
2015
2016     /*
2017     wxFont *labelFont = panelWindow->GetLabelFont();
2018     wxFont *buttonFont = panelWindow->GetButtonFont();
2019
2020       if (name == "labelFontPoints" || name == "labelFontFamily" || name == "labelFontStyle" || name == "labelFontWeight" ||
2021       name == "labelFontUnderlined")
2022       return GetFontProperty(name, labelFont);
2023       else if (name == "buttonFontPoints" || name == "buttonFontFamily" || name == "buttonFontStyle" || name == "buttonFontWeight" ||
2024       name == "buttonFontUnderlined")
2025       return GetFontProperty(name, buttonFont);
2026     */
2027
2028     if (name == "no3D")
2029     {
2030         bool userColours;
2031         if (panelWindow->GetWindowStyleFlag() & wxNO_3D)
2032             userColours = TRUE;
2033         else
2034             userColours = FALSE;
2035
2036         return new wxProperty(name, (bool)userColours, "bool");
2037     }
2038     else if (name == "backgroundColour")
2039     {
2040         wxColour col(panelWindow->GetBackgroundColour());
2041         char buf[7];
2042         wxDecToHex(col.Red(), buf);
2043         wxDecToHex(col.Green(), buf+2);
2044         wxDecToHex(col.Blue(), buf+4);
2045
2046         return new wxProperty(name, buf, "string", new wxColourListValidator);
2047     }
2048     else if (name == "title")
2049     {
2050         wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
2051         if (resource)
2052             return new wxProperty(name, resource->GetTitle(), "string");
2053         else
2054             return new wxProperty(name, "Could not get title", "string");
2055     }
2056     else if (name == "caption")
2057     {
2058         return new wxProperty(name, ((panelWindow->GetWindowStyleFlag() & wxCAPTION) == wxCAPTION),
2059             "bool");
2060     }
2061     else if (name == "systemMenu")
2062     {
2063         return new wxProperty(name, ((panelWindow->GetWindowStyleFlag() & wxSYSTEM_MENU) == wxSYSTEM_MENU),
2064             "bool");
2065     }
2066     else if (name == "thickFrame")
2067     {
2068         return new wxProperty(name, ((panelWindow->GetWindowStyleFlag() & wxTHICK_FRAME) == wxTHICK_FRAME),
2069             "bool");
2070     }
2071     else if (name == "modal")
2072     {
2073         return new wxProperty(name, ((panelWindow->GetWindowStyleFlag() & wxDIALOG_MODAL) == wxDIALOG_MODAL),
2074             "bool");
2075     }
2076     else if (name == "useSystemDefaults")
2077     {
2078         wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
2079         return new wxProperty(name, ((resource->GetResourceStyle() & wxRESOURCE_USE_DEFAULTS) == wxRESOURCE_USE_DEFAULTS),
2080             "bool");
2081     }
2082     else if (name == "useDialogUnits")
2083     {
2084         wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
2085         return new wxProperty(name, ((resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS) == wxRESOURCE_DIALOG_UNITS),
2086             "bool");
2087     }
2088     else
2089         return wxWindowPropertyInfo::GetProperty(name);
2090 }
2091
2092 bool wxPanelPropertyInfo::SetProperty(wxString& name, wxProperty *property)
2093 {
2094     wxPanel *panelWindow = (wxPanel *)m_propertyWindow;
2095     /*
2096     wxFont *labelFont = panelWindow->GetLabelFont();
2097     wxFont *buttonFont = panelWindow->GetButtonFont();
2098
2099       if (labelFont && (name == "labelFontPoints" || name == "labelFontFamily" || name == "labelFontStyle" || name == "labelFontWeight" || name == "labelFontUnderlined" ))
2100       {
2101       wxFont *newFont = SetFontProperty(name, property, labelFont);
2102       if (newFont)
2103       panelWindow->SetLabelFont(* newFont);
2104       return TRUE;
2105       }
2106       else if (buttonFont && (name == "buttonFontPoints" || name == "buttonFontFamily" || name == "buttonFontStyle" || name == "buttonFontWeight" || name == "buttonFontUnderlined" ))
2107       {
2108       wxFont *newFont = SetFontProperty(name, property, buttonFont);
2109       if (newFont)
2110       panelWindow->SetButtonFont(* newFont);
2111       return TRUE;
2112       }
2113     */
2114
2115     if (name == "no3D")
2116     {
2117         bool userColours = property->GetValue().BoolValue();
2118
2119         if (userColours)
2120         {
2121             if ((panelWindow->GetWindowStyleFlag() & wxNO_3D) != wxNO_3D)
2122                 panelWindow->SetWindowStyleFlag(panelWindow->GetWindowStyleFlag() | wxNO_3D);
2123         }
2124         else
2125         {
2126             if ((panelWindow->GetWindowStyleFlag() & wxNO_3D) == wxNO_3D)
2127                 panelWindow->SetWindowStyleFlag(panelWindow->GetWindowStyleFlag() - wxNO_3D);
2128         }
2129         wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
2130         resource->SetStyle(panelWindow->GetWindowStyleFlag());
2131
2132         panelWindow = (wxPanel *)wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(panelWindow, this);
2133         return TRUE;
2134     }
2135     else if (name == "backgroundColour")
2136     {
2137         char *hex = property->GetValue().StringValue();
2138         int r = wxHexToDec(hex);
2139         int g = wxHexToDec(hex+2);
2140         int b = wxHexToDec(hex+4);
2141
2142         wxColour col(r,g,b);
2143         panelWindow->SetBackgroundColour(col);
2144         panelWindow = (wxPanel *)wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(panelWindow, this);
2145         m_propertyWindow = panelWindow;
2146         return TRUE;
2147     }
2148     else if (name == "title")
2149     {
2150         wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
2151         if (resource)
2152         {
2153             resource->SetTitle(property->GetValue().StringValue());
2154             return TRUE;
2155         }
2156         else
2157             return FALSE;
2158     }
2159     else if (name == "caption")
2160     {
2161         SetWindowStyle(panelWindow, wxCAPTION, property->GetValue().BoolValue());
2162
2163         wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
2164         resource->SetStyle(panelWindow->GetWindowStyleFlag());
2165         return TRUE;
2166     }
2167     else if (name == "thickFrame")
2168     {
2169         SetWindowStyle(panelWindow, wxTHICK_FRAME, property->GetValue().BoolValue());
2170
2171         wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
2172         resource->SetStyle(panelWindow->GetWindowStyleFlag());
2173         return TRUE;
2174     }
2175     else if (name == "systemMenu")
2176     {
2177         SetWindowStyle(panelWindow, wxSYSTEM_MENU, property->GetValue().BoolValue());
2178
2179         wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
2180         resource->SetStyle(panelWindow->GetWindowStyleFlag());
2181         return TRUE;
2182     }
2183     else if (name == "modal")
2184     {
2185         SetWindowStyle(panelWindow, wxDIALOG_MODAL, property->GetValue().BoolValue());
2186
2187         wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
2188         resource->SetStyle(panelWindow->GetWindowStyleFlag());
2189         return TRUE;
2190     }
2191     else if (name == "useSystemDefaults")
2192     {
2193         wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
2194         bool useDefaults = property->GetValue().BoolValue();
2195         long style = resource->GetResourceStyle();
2196         if (useDefaults)
2197         {
2198             if ((style & wxRESOURCE_USE_DEFAULTS) == 0)
2199                 style |= wxRESOURCE_USE_DEFAULTS;
2200         }
2201         else
2202         {
2203             if ((style & wxRESOURCE_USE_DEFAULTS) != 0)
2204                 style -= wxRESOURCE_USE_DEFAULTS;
2205         }
2206         resource->SetResourceStyle(style);
2207         panelWindow = (wxPanel *)wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(panelWindow, this);
2208         return TRUE;
2209     }
2210     else if (name == "useDialogUnits")
2211     {
2212         wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
2213         bool useDialogUnits = property->GetValue().BoolValue();
2214         long style = resource->GetResourceStyle();
2215         if (useDialogUnits)
2216         {
2217             if ((style & wxRESOURCE_DIALOG_UNITS) == 0)
2218             {
2219                 style |= wxRESOURCE_DIALOG_UNITS;
2220                 ConvertDialogUnits(TRUE); // Convert all resources
2221             }
2222         }
2223         else
2224         {
2225             if ((style & wxRESOURCE_DIALOG_UNITS) != 0)
2226             {
2227                 style -= wxRESOURCE_DIALOG_UNITS;
2228                 ConvertDialogUnits(FALSE); // Convert all resources
2229             }
2230         }
2231         resource->SetResourceStyle(style);
2232         panelWindow = (wxPanel *)wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(panelWindow, this);
2233         m_propertyWindow = panelWindow;
2234         // TODO: need to regenerate the width and height properties else they'll be inconsistent.
2235         return TRUE;
2236     }
2237     else
2238         return wxWindowPropertyInfo::SetProperty(name, property);
2239 }
2240
2241 void wxPanelPropertyInfo::GetPropertyNames(wxStringList& names)
2242 {
2243     wxWindowPropertyInfo::GetPropertyNames(names);
2244
2245     names.Add("title");
2246     names.Add("no3D");
2247     names.Add("backgroundColour");
2248     names.Add("caption");
2249     names.Add("systemMenu");
2250     names.Add("thickFrame");
2251     names.Add("useSystemDefaults");
2252     names.Add("useDialogUnits");
2253     names.Add("modal");
2254 }
2255
2256 bool wxPanelPropertyInfo::InstantiateResource(wxItemResource *resource)
2257 {
2258     wxPanel *panel = (wxPanel *)m_propertyWindow;
2259     if (panel->GetFont().Ok())
2260         resource->SetFont(* wxTheFontList->FindOrCreateFont(panel->GetFont().GetPointSize(),
2261         panel->GetFont().GetFamily(), panel->GetFont().GetStyle(), panel->GetFont().GetWeight(),
2262         panel->GetFont().GetUnderlined(), panel->GetFont().GetFaceName()));
2263
2264     resource->SetBackgroundColour(wxColour(panel->GetBackgroundColour()));
2265
2266     return wxWindowPropertyInfo::InstantiateResource(resource);
2267 }
2268
2269 // Convert this dialog, and its children, to or from dialog units
2270 void wxPanelPropertyInfo::ConvertDialogUnits(bool toDialogUnits)
2271 {
2272     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
2273
2274     wxPoint pt;
2275     wxSize sz;
2276     if (toDialogUnits)
2277     {
2278         sz = m_propertyWindow->ConvertPixelsToDialog(wxSize(resource->GetWidth(), resource->GetHeight()));
2279         pt = m_propertyWindow->ConvertPixelsToDialog(wxPoint(resource->GetX(), resource->GetY()));
2280     }
2281     else
2282     {
2283         sz = m_propertyWindow->ConvertDialogToPixels(wxSize(resource->GetWidth(), resource->GetHeight()));
2284         pt = m_propertyWindow->ConvertDialogToPixels(wxPoint(resource->GetX(), resource->GetY()));
2285     }
2286     resource->SetSize(pt.x, pt.y, sz.x, sz.y);
2287
2288     wxNode* node = m_propertyWindow->GetChildren().First();
2289     while (node)
2290     {
2291         wxWindow* child = (wxWindow*) node->Data();
2292         if (child->IsKindOf(CLASSINFO(wxControl)))
2293         {
2294             resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(child);
2295             if (toDialogUnits)
2296             {
2297                 sz = m_propertyWindow->ConvertPixelsToDialog(wxSize(resource->GetWidth(), resource->GetHeight()));
2298                 pt = m_propertyWindow->ConvertPixelsToDialog(wxPoint(resource->GetX(), resource->GetY()));
2299             }
2300             else
2301             {
2302                 sz = m_propertyWindow->ConvertDialogToPixels(wxSize(resource->GetWidth(), resource->GetHeight()));
2303                 pt = m_propertyWindow->ConvertDialogToPixels(wxPoint(resource->GetX(), resource->GetY()));
2304             }
2305             resource->SetSize(pt.x, pt.y, sz.x, sz.y);
2306         }
2307         node = node->Next();
2308     }
2309 }
2310
2311 #if 0
2312 /*
2313 * Dialog boxes
2314 */
2315
2316 wxProperty *wxDialogPropertyInfo::GetProperty(wxString& name)
2317 {
2318     wxDialog *dialogWindow = (wxDialog *)m_propertyWindow;
2319     if (name == "modal")
2320     {
2321         wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(dialogWindow);
2322         if (!resource)
2323             return NULL;
2324
2325         bool modal = (resource->GetValue1() != 0);
2326         return new wxProperty(name, modal, "bool");
2327     }
2328     else
2329         return wxPanelPropertyInfo::GetProperty(name);
2330 }
2331
2332 bool wxDialogPropertyInfo::SetProperty(wxString& name, wxProperty *property)
2333 {
2334     wxDialog *dialogWindow = (wxDialog *)m_propertyWindow;
2335
2336     if (name == "modal")
2337     {
2338         wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(dialogWindow);
2339         if (!resource)
2340             return FALSE;
2341
2342         resource->SetValue1(property->GetValue().BoolValue());
2343         return TRUE;
2344     }
2345     else
2346         return wxPanelPropertyInfo::SetProperty(name, property);
2347 }
2348
2349 void wxDialogPropertyInfo::GetPropertyNames(wxStringList& names)
2350 {
2351     wxPanelPropertyInfo::GetPropertyNames(names);
2352     names.Add("title");
2353     names.Add("modal");
2354 }
2355
2356 bool wxDialogPropertyInfo::InstantiateResource(wxItemResource *resource)
2357 {
2358     wxDialog *dialog = (wxDialog *)m_propertyWindow;
2359     wxString str(dialog->GetTitle());
2360     resource->SetTitle(str);
2361
2362     return wxPanelPropertyInfo::InstantiateResource(resource);
2363 }
2364 #endif
2365
2366 /*
2367 * Utilities
2368 */
2369
2370 int wxStringToFontWeight(wxString& val)
2371 {
2372     if (val == "wxBOLD") return wxBOLD;
2373     else if (val == "wxLIGHT") return wxLIGHT;
2374     else return wxNORMAL;
2375 }
2376
2377 int wxStringToFontStyle(wxString& val)
2378 {
2379     if (val == "wxITALIC") return wxITALIC;
2380     else if (val == "wxSLANT") return wxSLANT;
2381     else return wxNORMAL;
2382 }
2383
2384 int wxStringToFontFamily(wxString& val)
2385 {
2386     if (val == "wxDECORATIVE") return wxDECORATIVE;
2387     else if (val == "wxROMAN") return wxROMAN;
2388     else if (val == "wxSCRIPT") return wxSCRIPT;
2389     else if (val == "wxMODERN") return wxMODERN;
2390     else if (val == "wxTELETYPE") return wxTELETYPE;
2391     else return wxSWISS;
2392 }
2393
2394 ///
2395 /// Resource symbol validator
2396 ///
2397 IMPLEMENT_DYNAMIC_CLASS(wxResourceSymbolValidator, wxPropertyListValidator)
2398
2399 wxResourceSymbolValidator::wxResourceSymbolValidator(long flags):
2400 wxPropertyListValidator(flags)
2401 {
2402 }
2403
2404 wxResourceSymbolValidator::~wxResourceSymbolValidator(void)
2405 {
2406 }
2407
2408 bool wxResourceSymbolValidator::OnCheckValue(wxProperty *WXUNUSED(property), wxPropertyListView *WXUNUSED(view), wxWindow *WXUNUSED(parentWindow))
2409 {
2410     return TRUE;
2411 }
2412
2413 // Called when TICK is pressed or focus is lost or view wants to update
2414 // the property list.
2415 // Does the transferance from the property editing area to the property itself
2416 bool wxResourceSymbolValidator::OnRetrieveValue(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
2417 {
2418     if (!view->GetValueText())
2419         return FALSE;
2420     wxString value(view->GetValueText()->GetValue());
2421     property->GetValue() = value ;
2422     return TRUE;
2423 }
2424
2425 // Called when TICK is pressed or focus is lost or view wants to update
2426 // the property list.
2427 // Does the transferance from the property editing area to the property itself
2428 bool wxResourceSymbolValidator::OnDisplayValue(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
2429 {
2430     if (!view->GetValueText())
2431         return FALSE;
2432     wxString str(property->GetValue().GetStringRepresentation());
2433     view->GetValueText()->SetValue(str);
2434     return TRUE;
2435 }
2436
2437 // Called when the property is double clicked. Extra functionality can be provided,
2438 // cycling through possible values.
2439 bool wxResourceSymbolValidator::OnDoubleClick(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow)
2440 {
2441     if (!view->GetValueText())
2442         return FALSE;
2443     OnEdit(property, view, parentWindow);
2444     return TRUE;
2445 }
2446
2447 bool wxResourceSymbolValidator::OnPrepareControls(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
2448 {
2449     if (view->GetConfirmButton())
2450         view->GetConfirmButton()->Enable(TRUE);
2451     if (view->GetCancelButton())
2452         view->GetCancelButton()->Enable(TRUE);
2453     if (view->GetEditButton())
2454         view->GetEditButton()->Enable(TRUE);
2455     if (view->GetValueText())
2456         view->GetValueText()->Enable((GetFlags() & wxPROP_ALLOW_TEXT_EDITING) == wxPROP_ALLOW_TEXT_EDITING);
2457     return TRUE;
2458 }
2459
2460 void wxResourceSymbolValidator::OnEdit(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow)
2461 {
2462     if (!view->GetValueText())
2463         return;
2464
2465     wxResourceSymbolDialog* dialog = new wxResourceSymbolDialog(parentWindow, -1, "Edit Symbol");
2466
2467     // Split name/id pair e.g. "IDC_TEXT=123"
2468     wxString value(property->GetValue().StringValue());
2469
2470     wxString strName = value.Before('=');
2471     wxString strId = value.After('=');
2472
2473     dialog->SetSymbol(strName);
2474     dialog->SetId(atoi(strId));
2475
2476     dialog->Init();
2477
2478     if (dialog->ShowModal() == wxID_OK)
2479     {
2480         wxString symbolName(dialog->GetSymbol());
2481         long id = dialog->GetId();
2482
2483         wxString str;
2484         str.Printf("%d", id);
2485         property->GetValue() = symbolName + wxString("=") + str;
2486
2487         view->DisplayProperty(property);
2488         view->UpdatePropertyDisplayInList(property);
2489         view->OnPropertyChanged(property);
2490     }
2491     // Moved from the 'if' branch on suggestion of Roman Pavlov
2492     dialog->Destroy();
2493 }
2494
2495 BEGIN_EVENT_TABLE(wxResourceSymbolDialog, wxDialog)
2496 EVT_BUTTON(wxID_OK, wxResourceSymbolDialog::OnOK)
2497 EVT_COMBOBOX(ID_SYMBOLNAME_COMBOBOX, wxResourceSymbolDialog::OnComboBoxSelect)
2498 EVT_TEXT(ID_SYMBOLNAME_COMBOBOX, wxResourceSymbolDialog::OnSymbolNameUpdate)
2499 END_EVENT_TABLE()
2500
2501 wxResourceSymbolDialog::wxResourceSymbolDialog(wxWindow* parent, const wxWindowID id, const wxString& title, const wxPoint& pos,
2502                                                const wxSize& size, long style):
2503 wxDialog(parent, id, title, pos, size, style)
2504 {
2505     int x = 5;
2506     int y = 5;
2507
2508     (void) new wxStaticText(this, -1, "Name: ", wxPoint(x, y));
2509
2510     x += 80;
2511
2512     m_nameCtrl = new wxComboBox(this, ID_SYMBOLNAME_COMBOBOX, "",
2513         wxPoint(x, y), wxSize(200, -1), 0, NULL, wxCB_DROPDOWN|wxCB_SORT);
2514
2515     y += 30;
2516     x = 5;
2517
2518     (void) new wxStaticText(this, -1, "Id: ", wxPoint(x, y));
2519
2520     x += 80;
2521
2522     m_idCtrl = new wxTextCtrl(this, ID_SYMBOLID_TEXTCTRL, "",
2523         wxPoint(x, y), wxSize(200, -1));
2524
2525     y += 30;
2526     x = 5;
2527     (void) new wxButton(this, wxID_OK, "OK", wxPoint(x, y), wxSize(80, -1));
2528
2529     x += 100;
2530     (void) new wxButton(this, wxID_CANCEL, "Cancel", wxPoint(x, y), wxSize(80, -1));
2531
2532     Fit();
2533     Centre();
2534 }
2535
2536 void wxResourceSymbolDialog::Init()
2537 {
2538     wxString defaultId;
2539     defaultId.Printf("%ld", m_symbolId);
2540
2541     m_nameCtrl->SetValue(m_symbolName);
2542     m_idCtrl->SetValue(defaultId);
2543
2544     wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().FillComboBox(m_nameCtrl);
2545 }
2546
2547 void wxResourceSymbolDialog::OnOK(wxCommandEvent& event)
2548 {
2549     if (CheckValues())
2550     {
2551         wxDialog::OnOK(event);
2552     }
2553 }
2554
2555 bool wxResourceSymbolDialog::CheckValues()
2556 {
2557     wxString nameStr(m_nameCtrl->GetValue());
2558     wxString idStr(m_idCtrl->GetValue());
2559     int id = atoi(idStr);
2560
2561     if (id <= 0 )
2562     {
2563         wxMessageBox("Identifier cannot be missing or zero", "Dialog Editor", wxOK|wxICON_EXCLAMATION, this);
2564         return FALSE;
2565     }
2566     if (nameStr == "")
2567     {
2568         wxMessageBox("Please enter a symbol name", "Dialog Editor", wxOK|wxICON_EXCLAMATION, this);
2569         return FALSE;
2570     }
2571     if (nameStr.Contains(" "))
2572     {
2573         wxMessageBox("Symbol name cannot contain spaces.", "Dialog Editor", wxOK|wxICON_EXCLAMATION, this);
2574         return FALSE;
2575     }
2576     if (nameStr.Contains("="))
2577     {
2578         wxMessageBox("Symbol name cannot contain =.", "Dialog Editor", wxOK|wxICON_EXCLAMATION, this);
2579         return FALSE;
2580     }
2581     if (nameStr.IsNumber())
2582     {
2583         wxMessageBox("Symbol name cannot be a number.", "Dialog Editor", wxOK|wxICON_EXCLAMATION, this);
2584         return FALSE;
2585     }
2586     // TODO: other checks on the name syntax.
2587
2588     if (!wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().IsStandardSymbol(nameStr))
2589     {
2590         // If we change the id for an existing symbol, we need to:
2591         // 1) Check if there are any other resources currently using the original id.
2592         //    If so, will need to change their id to the new id, in SetProperty.
2593         // 2) Remove the old symbol, add the new symbol.
2594         // In this check, we don't have to do this, but we need to do it in SetProperty.
2595
2596         if (nameStr == GetSymbol() && id != GetId())
2597         {
2598             // It's OK to change the id. But we'll need to change all matching ids in all resources,
2599             // in SetProperty.
2600         }
2601
2602         // If we change the name but not the id... we'll just need to remove and
2603         // re-add the symbol/id pair, in SetProperty.
2604         if (nameStr != GetSymbol() && id == GetId())
2605         {
2606         }
2607
2608         // What if we're changing both the name and the id?
2609         // - if there's no symbol of that name, just remove the old, add the new (in SetProperty)
2610         // - if there is a symbol of that name, if id matches, do nothing. If not, veto.
2611
2612         if (nameStr != GetSymbol() && id != GetId())
2613         {
2614             if (!wxResourceManager::GetCurrentResourceManager()->IsIdentifierOK(nameStr, id))
2615             {
2616                 wxMessageBox("This integer id is already being used under a different name.\nPlease choose another.",
2617                     "Dialog Editor", wxOK|wxICON_EXCLAMATION, this);
2618                 return FALSE;
2619             }
2620         }
2621
2622     }
2623
2624     SetSymbol(nameStr);
2625     SetId(id);
2626
2627     return TRUE;
2628 }
2629
2630 void wxResourceSymbolDialog::OnComboBoxSelect(wxCommandEvent& WXUNUSED(event))
2631 {
2632     wxString str(m_nameCtrl->GetStringSelection());
2633     if (wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().IsStandardSymbol(str))
2634     {
2635         int id = wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().GetIdForSymbol(str);
2636         wxString str2;
2637         str2.Printf("%d", id);
2638         m_idCtrl->SetValue(str2);
2639         m_idCtrl->Enable(FALSE);
2640     }
2641     else
2642     {
2643         if (wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().SymbolExists(str))
2644         {
2645             int id = wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().GetIdForSymbol(str);
2646             wxString str2;
2647             str2.Printf("%d", id);
2648             m_idCtrl->SetValue(str2);
2649         }
2650         m_idCtrl->Enable(TRUE);
2651     }
2652 }
2653
2654 void wxResourceSymbolDialog::OnSymbolNameUpdate(wxCommandEvent& WXUNUSED(event))
2655 {
2656     wxString str(m_nameCtrl->GetValue());
2657     if (wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().IsStandardSymbol(str))
2658     {
2659         int id = wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().GetIdForSymbol(str);
2660         wxString str2;
2661         str2.Printf("%d", id);
2662         m_idCtrl->SetValue(str2);
2663         m_idCtrl->Enable(FALSE);
2664     }
2665     else
2666     {
2667         if (wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().SymbolExists(str))
2668         {
2669             int id = wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().GetIdForSymbol(str);
2670             wxString str2;
2671             str2.Printf("%d", id);
2672             m_idCtrl->SetValue(str2);
2673         }
2674         m_idCtrl->Enable(TRUE);
2675     }
2676 }
2677