]> git.saurik.com Git - wxWidgets.git/blobdiff - utils/dialoged/src/winprop.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Added RTLD_GLOBAL to dlopen() flags which is needed if libraries depend
[wxWidgets.git] / utils / dialoged / src / winprop.cpp
diff --git a/utils/dialoged/src/winprop.cpp b/utils/dialoged/src/winprop.cpp
index 602c87a7635bd78fba685715f5aba6bd274fa6ea..dde79ec61c1125ee76c8f12e8fd1bb08f02f9d13 100644 (file)
--- a/utils/dialoged/src/winprop.cpp
+++ b/utils/dialoged/src/winprop.cpp
@@ -29,12 +29,6 @@
 #include <math.h>
 #include <string.h>
 
 #include <math.h>
 #include <string.h>
 
-#if defined(__WXMSW__) && !defined(__GNUWIN32__)
-#include <strstrea.h>
-#else
-#include <strstream.h>
-#endif
-
 #ifdef __WXMSW__
 #include <windows.h>
 #endif
 #ifdef __WXMSW__
 #include <windows.h>
 #endif
@@ -49,8 +43,9 @@ void wxResourcePropertyListView::OnPropertyChanged(wxProperty *property)
   // IF the property value was modified.
   if (property->GetValue().GetModified())
   {
   // IF the property value was modified.
   if (property->GetValue().GetModified())
   {
-    propertyInfo->SetProperty(property->GetName(), property);
+    m_propertyInfo->SetProperty(property->GetName(), property);
     property->GetValue().SetModified(FALSE);
     property->GetValue().SetModified(FALSE);
+    wxResourceManager::GetCurrentResourceManager()->Modify(TRUE);
   }
 }
 
   }
 }
 
@@ -74,6 +69,7 @@ wxWindow *wxPropertyInfo::sm_propertyWindow;
  * wxDialogEditorPropertyListDialog
  */
 
  * wxDialogEditorPropertyListDialog
  */
 
+ /*
 wxDialogEditorPropertyListDialog::wxDialogEditorPropertyListDialog(wxPropertyListView *v, wxWindow *parent, const wxString& title,
         const wxPoint& pos, const wxSize& size,
         long style, const wxString& name):
 wxDialogEditorPropertyListDialog::wxDialogEditorPropertyListDialog(wxPropertyListView *v, wxWindow *parent, const wxString& title,
         const wxPoint& pos, const wxSize& size,
         long style, const wxString& name):
@@ -89,6 +85,24 @@ wxDialogEditorPropertyListDialog::~wxDialogEditorPropertyListDialog()
     delete m_propInfo;
     wxPropertyInfo::sm_propertyWindow = NULL;
 }
     delete m_propInfo;
     wxPropertyInfo::sm_propertyWindow = NULL;
 }
+*/
+
+wxDialogEditorPropertyListFrame::wxDialogEditorPropertyListFrame(wxPropertyListView *v, wxFrame *parent, const wxString& title,
+        const wxPoint& pos, const wxSize& size,
+        long style, const wxString& name):
+            wxPropertyListFrame(v, parent, title, pos, size, style, name)
+{
+        m_propSheet = NULL;
+        m_propInfo = NULL;
+}
+
+wxDialogEditorPropertyListFrame::~wxDialogEditorPropertyListFrame()
+{
+    delete m_propSheet;
+    delete m_propInfo;
+    if (wxPropertyInfo::sm_propertyWindow == this)
+        wxPropertyInfo::sm_propertyWindow = NULL;
+}
 
 /*
  * wxPropertyInfo
 
 /*
  * wxPropertyInfo
@@ -96,10 +110,22 @@ wxDialogEditorPropertyListDialog::~wxDialogEditorPropertyListDialog()
 
 // Edit the information represented by this object, whatever that
 // might be.
 
 // Edit the information represented by this object, whatever that
 // might be.
-bool wxPropertyInfo::Edit(wxWindow *parent, const wxString& title)
+bool wxPropertyInfo::Edit(wxWindow *WXUNUSED(parent), const wxString& title)
 {
 {
-    if (sm_propertyWindow)
-        return FALSE;
+  if (sm_propertyWindow)
+  {
+      wxWindowPropertyInfo* thisProp = (wxWindowPropertyInfo*) this;
+      wxWindowPropertyInfo* oldProp = (wxWindowPropertyInfo*) (((wxDialogEditorPropertyListFrame *) sm_propertyWindow)->GetInfo());
+      if (oldProp->GetWindow() == thisProp->GetWindow())
+      {
+        sm_propertyWindow->Raise();
+        return TRUE;
+      }
+      else
+      {
+          CloseWindow(); // Close the window so we can open a new one
+      }
+  }
 
   int width = wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().width;
   int height = wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().height;
 
   int width = wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().width;
   int height = wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().height;
@@ -127,43 +153,68 @@ bool wxPropertyInfo::Edit(wxWindow *parent, const wxString& title)
   propSheet->SetAllModified(FALSE);
 
   wxResourcePropertyListView *view = new wxResourcePropertyListView(this, NULL,
   propSheet->SetAllModified(FALSE);
 
   wxResourcePropertyListView *view = new wxResourcePropertyListView(this, NULL,
-#ifdef __XVIEW__
-     wxPROP_BUTTON_OK | wxPROP_BUTTON_CANCEL |
-#endif
+     wxPROP_BUTTON_OK | // wxPROP_BUTTON_CANCEL |
      wxPROP_BUTTON_CHECK_CROSS|wxPROP_DYNAMIC_VALUE_FIELD|wxPROP_PULLDOWN|wxPROP_SHOWVALUES);
 
      wxPROP_BUTTON_CHECK_CROSS|wxPROP_DYNAMIC_VALUE_FIELD|wxPROP_PULLDOWN|wxPROP_SHOWVALUES);
 
-  wxDialogEditorPropertyListDialog *propDialog = new wxDialogEditorPropertyListDialog(view,
+  wxDialogEditorPropertyListFrame *propWin = new wxDialogEditorPropertyListFrame(view,
     wxResourceManager::GetCurrentResourceManager()->GetEditorFrame(), title, wxPoint(x, y),
     wxResourceManager::GetCurrentResourceManager()->GetEditorFrame(), title, wxPoint(x, y),
-    wxSize(width, height), wxDEFAULT_DIALOG_STYLE);
-  sm_propertyWindow = propDialog;
+    wxSize(width, height), wxDEFAULT_FRAME_STYLE);
+  sm_propertyWindow = propWin;
+
+  propWin->m_registry.RegisterValidator(wxString("real"), new wxRealListValidator);
+  propWin->m_registry.RegisterValidator(wxString("string"), new wxStringListValidator);
+  propWin->m_registry.RegisterValidator(wxString("integer"), new wxIntegerListValidator);
+  propWin->m_registry.RegisterValidator(wxString("bool"), new wxBoolListValidator);
+  propWin->m_registry.RegisterValidator(wxString("filename"), new wxFilenameListValidator);
+  propWin->m_registry.RegisterValidator(wxString("stringlist"), new wxListOfStringsListValidator);
+  propWin->m_registry.RegisterValidator(wxString("window_id"), new wxResourceSymbolValidator);
+
+  propWin->m_propInfo = this;
+  propWin->m_propSheet = propSheet;
 
 
-  propDialog->m_registry.RegisterValidator((wxString)"real", new wxRealListValidator);
-  propDialog->m_registry.RegisterValidator((wxString)"string", new wxStringListValidator);
-  propDialog->m_registry.RegisterValidator((wxString)"integer", new wxIntegerListValidator);
-  propDialog->m_registry.RegisterValidator((wxString)"bool", new wxBoolListValidator);
-  propDialog->m_registry.RegisterValidator((wxString)"filename", new wxFilenameListValidator);
-  propDialog->m_registry.RegisterValidator((wxString)"stringlist", new wxListOfStringsListValidator);
-  propDialog->m_registry.RegisterValidator((wxString)"window_id", new wxResourceSymbolValidator);
+//  view->m_propertyWindow = propWin;
+  view->AddRegistry(&(propWin->m_registry));
 
 
-  propDialog->m_propInfo = this;
-  propDialog->m_propSheet = propSheet;
+  propWin->Initialize();
+  view->ShowView(propSheet, propWin->GetPropertyPanel());
 
 
-//  view->propertyWindow = propDialog;
-  view->AddRegistry(&(propDialog->m_registry));
-  view->ShowView(propSheet, propDialog);
+  propWin->Show(TRUE);
+
+  // Otherwise doesn't show itself
+#ifdef __WXMOTIF__
+  wxNoOptimize noOptimize;
+  propWin->SetSize(-1, -1, width, height);
+#endif
 
 
-  propDialog->Show(TRUE);
   return TRUE;
 }
 
   return TRUE;
 }
 
+void wxPropertyInfo::CloseWindow()
+{
+  if (sm_propertyWindow)
+  {
+        int w, h, x, y;
+        sm_propertyWindow->GetSize(& w, & h);
+        sm_propertyWindow->GetPosition(& x, & y);
+
+        wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().width = w;
+        wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().height = h;
+        wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().x = x;
+        wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().y = y;
+
+        sm_propertyWindow->Destroy();
+        sm_propertyWindow = (wxDialogEditorPropertyListFrame *) NULL;
+  }
+}
+
 /*
  * wxWindowPropertyInfo
  */
 
 wxWindowPropertyInfo::wxWindowPropertyInfo(wxWindow *win, wxItemResource *res)
 {
 /*
  * wxWindowPropertyInfo
  */
 
 wxWindowPropertyInfo::wxWindowPropertyInfo(wxWindow *win, wxItemResource *res)
 {
-  propertyWindow = win;
-  propertyResource = res;
+  m_propertyWindow = win;
+  m_propertyResource = res;
 }
 
 wxWindowPropertyInfo::~wxWindowPropertyInfo(void)
 }
 
 wxWindowPropertyInfo::~wxWindowPropertyInfo(void)
@@ -258,42 +309,68 @@ wxFont *wxWindowPropertyInfo::SetFontProperty(wxString& name, wxProperty *proper
 
 wxProperty *wxWindowPropertyInfo::GetProperty(wxString& name)
 {
 
 wxProperty *wxWindowPropertyInfo::GetProperty(wxString& name)
 {
-  wxFont *font = propertyWindow->GetFont();
+  wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
+
+  wxFont *font = & m_propertyWindow->GetFont();
   if (name == "fontPoints" || name == "fontFamily" || name == "fontStyle" || name == "fontWeight" ||
       name == "fontUnderlined")
     return GetFontProperty(name, font);
   else if (name == "name")
   if (name == "fontPoints" || name == "fontFamily" || name == "fontStyle" || name == "fontWeight" ||
       name == "fontUnderlined")
     return GetFontProperty(name, font);
   else if (name == "name")
-    return new wxProperty("name", propertyWindow->GetName(), "string");
+    return new wxProperty("name", m_propertyWindow->GetName(), "string");
   else if (name == "title")
   else if (name == "title")
-    return new wxProperty("title", propertyWindow->GetTitle(), "string");
+    return new wxProperty("title", m_propertyWindow->GetTitle(), "string");
   else if (name == "x")
   {
   else if (name == "x")
   {
-    int x, y;
-    propertyWindow->GetPosition(&x, &y);
-    return new wxProperty("x", (long)x, "integer");
+    return new wxProperty("x", (long)resource->GetX(), "integer");
   }
   else if (name == "y")
   {
   }
   else if (name == "y")
   {
-    int x, y;
-    propertyWindow->GetPosition(&x, &y);
-    return new wxProperty("y", (long)y, "integer");
+    return new wxProperty("y", (long)resource->GetY(), "integer");
   }
   else if (name == "width")
   {
   }
   else if (name == "width")
   {
-    int width, height;
-    propertyWindow->GetSize(&width, &height);
-    return new wxProperty("width", (long)width, "integer");
+    return new wxProperty("width", (long)resource->GetWidth(), "integer");
   }
   else if (name == "height")
   {
   }
   else if (name == "height")
   {
-    int width, height;
-    propertyWindow->GetSize(&width, &height);
-    return new wxProperty("height", (long)height, "integer");
+    return new wxProperty("height", (long)resource->GetHeight(), "integer");
   }
   else if (name == "id")
   {
   }
   else if (name == "id")
   {
-    wxString symbolName("TODO");
-    return new wxProperty("id", symbolName, "window_id");
+    wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
+    if (resource)
+    {
+        int id = resource->GetId();
+        wxString idStr;
+        idStr.Printf("%d", id);
+        wxString symbolName = wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().GetSymbolForId(id);
+        symbolName += "=";
+        symbolName += idStr;
+        // symbolName is now e.g. "ID_PANEL21=105"
+        return new wxProperty("id", symbolName, "window_id");
+    }
+    else
+        return NULL;
+  }
+  else if (name == "border")
+  {
+    wxString border("");
+    if (m_propertyWindow->GetWindowStyleFlag() & wxSIMPLE_BORDER)
+      border = "wxSIMPLE_BORDER";
+    else if (m_propertyWindow->GetWindowStyleFlag() & wxRAISED_BORDER)
+      border = "wxRAISED_BORDER";
+    else if (m_propertyWindow->GetWindowStyleFlag() & wxSUNKEN_BORDER)
+      border = "wxSUNKEN_BORDER";
+    else if (m_propertyWindow->GetWindowStyleFlag() & wxDOUBLE_BORDER)
+      border = "wxDOUBLE_BORDER";
+    else if (m_propertyWindow->GetWindowStyleFlag() & wxSTATIC_BORDER)
+      border = "wxSTATIC_BORDER";
+    else
+      border = "wxNO_BORDER";
+
+    return new wxProperty("border", border, "string",
+       new wxStringListValidator(new wxStringList("wxSIMPLE_BORDER", "wxRAISED_BORDER",
+          "wxSUNKEN_BORDER", "wxDOUBLE_BORDER", "wxSTATIC_BORDER", "wxNO_BORDER", NULL)));
   }
   else
     return NULL;
   }
   else
     return NULL;
@@ -301,30 +378,38 @@ wxProperty *wxWindowPropertyInfo::GetProperty(wxString& name)
 
 bool wxWindowPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
 
 bool wxWindowPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
-  wxFont *font = propertyWindow->GetFont();
+  wxFont *font = & m_propertyWindow->GetFont();
   if (font && (name == "fontPoints" || name == "fontFamily" || name == "fontStyle" || name == "fontWeight" || name == "fontUnderlined" ))
   {
     wxFont *newFont = SetFontProperty(name, property, font);
     if (newFont)
   if (font && (name == "fontPoints" || name == "fontFamily" || name == "fontStyle" || name == "fontWeight" || name == "fontUnderlined" ))
   {
     wxFont *newFont = SetFontProperty(name, property, font);
     if (newFont)
-      propertyWindow->SetFont(newFont);
+    {
+      m_propertyWindow->SetFont(* newFont);
+      wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
+      if (resource)
+      {
+          resource->SetFont(* newFont);
+      }
+    }
+
     return TRUE;
   }
   else if (name == "name")
   {
     // Remove old name from resource table, if it's there.
     return TRUE;
   }
   else if (name == "name")
   {
     // Remove old name from resource table, if it's there.
-    wxItemResource *oldResource = (wxItemResource *)wxResourceManager::GetCurrentResourceManager()->GetResourceTable().Delete(propertyWindow->GetName());
+    wxItemResource *oldResource = (wxItemResource *)wxResourceManager::GetCurrentResourceManager()->GetResourceTable().Delete(m_propertyWindow->GetName());
     if (oldResource)
     {
       // It's a top-level resource
     if (oldResource)
     {
       // It's a top-level resource
-      propertyWindow->SetName(property->GetValue().StringValue());
+      m_propertyWindow->SetName(property->GetValue().StringValue());
       oldResource->SetName(property->GetValue().StringValue());
       oldResource->SetName(property->GetValue().StringValue());
-      wxResourceManager::GetCurrentResourceManager()->GetResourceTable().Put(propertyWindow->GetName(), oldResource);
+      wxResourceManager::GetCurrentResourceManager()->GetResourceTable().Put(m_propertyWindow->GetName(), oldResource);
     }
     else
     {
       // It's a child of something; just set the name of the resource and the window.
     }
     else
     {
       // It's a child of something; just set the name of the resource and the window.
-      propertyWindow->SetName(property->GetValue().StringValue());
-      propertyResource->SetName(property->GetValue().StringValue());
+      m_propertyWindow->SetName(property->GetValue().StringValue());
+      m_propertyResource->SetName(property->GetValue().StringValue());
     }
     // Refresh the resource manager list, because the name changed.
     wxResourceManager::GetCurrentResourceManager()->UpdateResourceList();
     }
     // Refresh the resource manager list, because the name changed.
     wxResourceManager::GetCurrentResourceManager()->UpdateResourceList();
@@ -332,64 +417,256 @@ bool wxWindowPropertyInfo::SetProperty(wxString& name, wxProperty *property)
   }
   else if (name == "title")
   {
   }
   else if (name == "title")
   {
-    propertyWindow->SetTitle(property->GetValue().StringValue());
+    m_propertyWindow->SetTitle(property->GetValue().StringValue());
     return TRUE;
   }
   else if (name == "x")
   {
     return TRUE;
   }
   else if (name == "x")
   {
+    wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
     int x, y;
     int x, y;
-    propertyWindow->GetPosition(&x, &y);
+    m_propertyWindow->GetPosition(&x, &y);
     int newX = (int)property->GetValue().IntegerValue();
     int newX = (int)property->GetValue().IntegerValue();
-    if (x != newX)
-      propertyWindow->Move(newX, y);
+    int pixelX = newX;
+
+    // We need to convert to pixels if this is not a dialog or panel, but
+    // the parent resource specifies dialog units.
+    if (m_propertyWindow->GetParent() && m_propertyWindow->IsKindOf(CLASSINFO(wxControl)))
+    {
+        wxItemResource* parentResource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow->GetParent());
+        if (parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
+        {
+            wxPoint pt = m_propertyWindow->GetParent()->ConvertDialogToPixels(wxPoint(newX, y));
+            pixelX = pt.x;
+        }
+    }
+    else if (m_propertyWindow->IsKindOf(CLASSINFO(wxPanel)))
+    {
+        wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
+        if (resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
+        {
+            wxPoint pt = m_propertyWindow->ConvertDialogToPixels(wxPoint(newX, y));
+            pixelX = pt.x;
+        }
+    }
+
+    if (x != pixelX)
+    {
+      m_propertyWindow->Move(pixelX, y);
+      resource->SetSize(newX, resource->GetY(), resource->GetWidth(), resource->GetHeight());
+    }
     return TRUE;
   }
   else if (name == "y")
   {
     return TRUE;
   }
   else if (name == "y")
   {
+    wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
     int x, y;
     int x, y;
-    propertyWindow->GetPosition(&x, &y);
+    m_propertyWindow->GetPosition(&x, &y);
     int newY = (int)property->GetValue().IntegerValue();
     int newY = (int)property->GetValue().IntegerValue();
-    if (y != newY)
-      propertyWindow->Move(x, newY);
+    int pixelY = newY;
+
+    // We need to convert to pixels if this is not a dialog or panel, but
+    // the parent resource specifies dialog units.
+    if (m_propertyWindow->GetParent() && m_propertyWindow->IsKindOf(CLASSINFO(wxControl)))
+    {
+        wxItemResource* parentResource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow->GetParent());
+        if (parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
+        {
+            wxPoint pt = m_propertyWindow->GetParent()->ConvertDialogToPixels(wxPoint(x, newY));
+            pixelY = pt.y;
+        }
+    }
+    else if (m_propertyWindow->IsKindOf(CLASSINFO(wxPanel)))
+    {
+        wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
+        if (resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
+        {
+            wxPoint pt = m_propertyWindow->ConvertDialogToPixels(wxPoint(x, newY));
+            pixelY = pt.y;
+        }
+    }
+
+    if (y != pixelY)
+    {
+      m_propertyWindow->Move(x, pixelY);
+      resource->SetSize(resource->GetX(), newY, resource->GetWidth(), resource->GetHeight());
+    }
     return TRUE;
   }
   else if (name == "width")
   {
     return TRUE;
   }
   else if (name == "width")
   {
+    wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
     int width, height;
     int width, height;
-    propertyWindow->GetSize(&width, &height);
+    m_propertyWindow->GetSize(&width, &height);
     int newWidth = (int)property->GetValue().IntegerValue();
     int newWidth = (int)property->GetValue().IntegerValue();
-    if (width != newWidth)
+    int pixelWidth = newWidth;
+
+    // We need to convert to pixels if this is not a dialog or panel, but
+    // the parent resource specifies dialog units.
+    if (m_propertyWindow->GetParent() && m_propertyWindow->IsKindOf(CLASSINFO(wxControl)))
     {
     {
-      propertyWindow->SetSize(newWidth, height);
-/*
-      if (propertyWindow->IsKindOf(CLASSINFO(wxPanel)) && !propertyWindow->IsKindOf(CLASSINFO(wxDialog)))
-      {
-        propertyWindow->GetParent()->SetClientSize(newWidth, height);
-      }
-*/
+        wxItemResource* parentResource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow->GetParent());
+        if (parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
+        {
+            wxSize sz = m_propertyWindow->GetParent()->ConvertDialogToPixels(wxSize(newWidth, height));
+            pixelWidth = sz.x;
+        }
+    }
+    else if (m_propertyWindow->IsKindOf(CLASSINFO(wxPanel)))
+    {
+        wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
+        if (resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
+        {
+            wxSize sz = m_propertyWindow->ConvertDialogToPixels(wxSize(newWidth, height));
+            pixelWidth = sz.x;
+        }
+    }
+
+    if (width != pixelWidth)
+    {
+      m_propertyWindow->SetSize(pixelWidth, height);
+      resource->SetSize(resource->GetX(), resource->GetY(), newWidth, resource->GetHeight());
     }
     return TRUE;
   }
   else if (name == "height")
   {
     }
     return TRUE;
   }
   else if (name == "height")
   {
+    wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
     int width, height;
     int width, height;
-    propertyWindow->GetSize(&width, &height);
+    m_propertyWindow->GetSize(&width, &height);
     int newHeight = (int)property->GetValue().IntegerValue();
     int newHeight = (int)property->GetValue().IntegerValue();
-    if (height != newHeight)
+    int pixelHeight = newHeight;
+
+    // We need to convert to pixels if this is not a dialog or panel, but
+    // the parent resource specifies dialog units.
+    if (m_propertyWindow->GetParent() && m_propertyWindow->IsKindOf(CLASSINFO(wxControl)))
     {
     {
-      propertyWindow->SetSize(width, newHeight);
-/*
-      if (propertyWindow->IsKindOf(CLASSINFO(wxPanel)) && !propertyWindow->IsKindOf(CLASSINFO(wxDialog)))
-      {
-        propertyWindow->GetParent()->SetClientSize(width, newHeight);
-      }
-*/
+        wxItemResource* parentResource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow->GetParent());
+        if (parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
+        {
+            wxSize sz = m_propertyWindow->GetParent()->ConvertDialogToPixels(wxSize(width, newHeight));
+            pixelHeight = sz.y;
+        }
+    }
+    else if (m_propertyWindow->IsKindOf(CLASSINFO(wxPanel)))
+    {
+        wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
+        if (resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
+        {
+            wxSize sz = m_propertyWindow->ConvertDialogToPixels(wxSize(width, newHeight));
+            pixelHeight = sz.y;
+        }
+    }
+
+    if (height != pixelHeight)
+    {
+      m_propertyWindow->SetSize(width, pixelHeight);
+      resource->SetSize(resource->GetX(), resource->GetY(), resource->GetWidth(), newHeight);
     }
     return TRUE;
   }
   else if (name == "id")
   {
     }
     return TRUE;
   }
   else if (name == "id")
   {
-    // TODO
+    wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
+    if (resource)
+    {
+        wxString value = property->GetValue().StringValue();
+
+        wxString strName = value.Before('=');
+        wxString strId = value.After('=');
+        int id = atoi(strId);
+
+        wxString oldSymbolName = wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().GetSymbolForId(resource->GetId());
+        int oldSymbolId = resource->GetId();
+
+        if (strName != "")
+        {
+            // If we change the id for an existing symbol, we need to:
+            // 1) Check if there are any other resources currently using the original id.
+            //    If so, will need to change their id to the new id.
+            // 2) Remove the old symbol, add the new symbol.
+            // In this check, we don't have to do this, but we need to do it in SetProperty.
+
+            if (strName == oldSymbolName && id != oldSymbolId)
+            {
+                wxASSERT( (!wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().IsStandardSymbol(oldSymbolName)) );
+
+                // It's OK to change just the id. But we'll need to change all matching ids in all resources,
+                // because ids are unique and changing one resource's id must change all identical ones.
+                wxResourceManager::GetCurrentResourceManager()->ChangeIds(oldSymbolId, id);
+
+                wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().RemoveSymbol(oldSymbolName);
+                wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().AddSymbol(strName, id);
+            }
+
+            // If we change the name but not the id, we'll just need to remove and
+            // re-add the symbol/id pair.
+            if (strName != oldSymbolName && id == oldSymbolId)
+            {
+                wxASSERT( (!wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().IsStandardSymbol(oldSymbolName)) );
+
+                wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().RemoveSymbol(oldSymbolName);
+
+                if (!wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().SymbolExists(strName))
+                {
+                    wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().AddSymbol(strName, id);
+                }
+            }
+
+            // What if we're changing both the name and the id?
+            // - if there's no symbol of that name, just remove the old, add the new (in SetProperty)
+            // - if there is a symbol of that name, if id matches, do nothing. If not, veto.
+
+            if (strName != oldSymbolName && id != oldSymbolId)
+            {
+                // Remove old symbol if it's not being used
+                if (!wxResourceManager::GetCurrentResourceManager()->IsSymbolUsed(resource, oldSymbolId) &&
+                    !wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().IsStandardSymbol(oldSymbolName))
+                {
+                    wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().RemoveSymbol(oldSymbolName);
+                }
+
+                if (!wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().SymbolExists(strName))
+                {
+                    wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().AddSymbol(strName, id);
+                }
+            }
+            resource->SetId(id);
+        }
+
+        return TRUE;
+    }
+    else
+        return FALSE;
+  }
+  else if (name == "border")
+  {
+    long borderStyle = wxNO_BORDER;
+    wxString val = property->GetValue().StringValue();
+
+    if (val == "wxSIMPLE_BORDER")
+        borderStyle = wxSIMPLE_BORDER;
+    else if (val == "wxRAISED_BORDER")
+        borderStyle = wxRAISED_BORDER;
+    else if (val == "wxSUNKEN_BORDER")
+        borderStyle = wxSUNKEN_BORDER;
+    else if (val == "wxDOUBLE_BORDER")
+        borderStyle = wxDOUBLE_BORDER;
+    else if (val == "wxSTATIC_BORDER")
+        borderStyle = wxSTATIC_BORDER;
+    else
+        borderStyle = wxNO_BORDER;
+
+    SetWindowStyle(m_propertyWindow, wxSIMPLE_BORDER, FALSE);
+    SetWindowStyle(m_propertyWindow, wxRAISED_BORDER, FALSE);
+    SetWindowStyle(m_propertyWindow, wxSUNKEN_BORDER, FALSE);
+    SetWindowStyle(m_propertyWindow, wxDOUBLE_BORDER, FALSE);
+    SetWindowStyle(m_propertyWindow, wxSTATIC_BORDER, FALSE);
+    SetWindowStyle(m_propertyWindow, wxNO_BORDER, FALSE);
+
+    SetWindowStyle(m_propertyWindow, borderStyle, TRUE);
+
+    wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
+    resource->SetStyle(m_propertyWindow->GetWindowStyleFlag());
     return TRUE;
   }
   else
     return TRUE;
   }
   else
@@ -404,7 +681,8 @@ void wxWindowPropertyInfo::GetPropertyNames(wxStringList& names)
   names.Add("y");
   names.Add("width");
   names.Add("height");
   names.Add("y");
   names.Add("width");
   names.Add("height");
-  if (!propertyWindow->IsKindOf(CLASSINFO(wxControl)))
+  names.Add("border");
+  if (!m_propertyWindow->IsKindOf(CLASSINFO(wxControl)))
   {
     names.Add("fontPoints");
     names.Add("fontFamily");
   {
     names.Add("fontPoints");
     names.Add("fontFamily");
@@ -417,19 +695,75 @@ void wxWindowPropertyInfo::GetPropertyNames(wxStringList& names)
 // Fill in the wxItemResource members to mirror the current window settings
 bool wxWindowPropertyInfo::InstantiateResource(wxItemResource *resource)
 {
 // Fill in the wxItemResource members to mirror the current window settings
 bool wxWindowPropertyInfo::InstantiateResource(wxItemResource *resource)
 {
-  resource->SetType(propertyWindow->GetClassInfo()->GetClassName());
-  
-//  resource->SetStyle(propertyWindow->GetWindowStyleFlag());
-  wxString str(propertyWindow->GetName());
-  resource->SetName(WXSTRINGCAST str);
+//  resource->SetType(m_propertyWindow->GetClassInfo()->GetClassName());
+
+//  resource->SetStyle(m_propertyWindow->GetWindowStyleFlag());
+  wxString str(m_propertyWindow->GetName());
+  resource->SetName(str);
+
+#if 0 // Why did we comment this out? Possibly because of rounding errors
+  // that will build up as the conversion is repeatedly done.
+  // so only do the conversion when a resize happens.
   int x, y, w, h;
   int x, y, w, h;
-  propertyWindow->GetSize(&w, &h);
 
 
-  propertyWindow->GetPosition(&x, &y);
+  if (m_propertyWindow->IsKindOf(CLASSINFO(wxPanel)))
+      m_propertyWindow->GetClientSize(&w, &h);
+  else
+      m_propertyWindow->GetSize(&w, &h);
+
+  m_propertyWindow->GetPosition(&x, &y);
+
+  // We need to convert to dialog units if this is not a dialog or panel, but
+  // the parent resource specifies dialog units.
+  if (m_propertyWindow->GetParent() && m_propertyWindow->IsKindOf(CLASSINFO(wxControl)))
+  {
+      wxItemResource* parentResource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow->GetParent());
+      if (parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
+      {
+          wxPoint pt = m_propertyWindow->GetParent()->ConvertPixelsToDialog(wxPoint(x, y));
+          x = pt.x; y = pt.y;
+          wxSize sz = m_propertyWindow->GetParent()->ConvertPixelsToDialog(wxSize(w, h));
+          w = sz.x; h = sz.y;
+      }
+  }
+  else if (m_propertyWindow->IsKindOf(CLASSINFO(wxPanel)))
+  {
+      if (resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
+      {
+          wxPoint pt = m_propertyWindow->ConvertPixelsToDialog(wxPoint(x, y));
+          x = pt.x; y = pt.y;
+          wxSize sz = m_propertyWindow->ConvertPixelsToDialog(wxSize(w, h));
+          w = sz.x; h = sz.y;
+      }
+  }
+
   resource->SetSize(x, y, w, h);
   resource->SetSize(x, y, w, h);
+#endif
+
   return TRUE;
 }
 
   return TRUE;
 }
 
+// Set the window style
+void wxWindowPropertyInfo::SetWindowStyle(wxWindow* win, long style, bool set)
+{
+    if (style == 0)
+        return;
+
+    if ((win->GetWindowStyleFlag() & style) == style)
+    {
+        if (!set)
+        {
+            win->SetWindowStyleFlag(win->GetWindowStyleFlag() - style);
+        }
+    }
+    else
+    {
+        if (set)
+        {
+            win->SetWindowStyleFlag(win->GetWindowStyleFlag() | style);
+        }
+    }
+}
 
 /*
  * Controls
 
 /*
  * Controls
@@ -437,31 +771,34 @@ bool wxWindowPropertyInfo::InstantiateResource(wxItemResource *resource)
 
 wxProperty *wxItemPropertyInfo::GetProperty(wxString& name)
 {
 
 wxProperty *wxItemPropertyInfo::GetProperty(wxString& name)
 {
-  wxControl *itemWindow = (wxControl *)propertyWindow; 
-  wxFont *font = itemWindow->GetFont();
+  wxControl *itemWindow = (wxControl *)m_propertyWindow; 
+  wxFont *font = & itemWindow->GetFont();
 
   if (name == "fontPoints" || name == "fontFamily" || name == "fontStyle" || name == "fontWeight" ||
       name == "fontUnderlined")
     return GetFontProperty(name, font);
   else if (name == "label" && itemWindow->GetLabel())
 
   if (name == "fontPoints" || name == "fontFamily" || name == "fontStyle" || name == "fontWeight" ||
       name == "fontUnderlined")
     return GetFontProperty(name, font);
   else if (name == "label" && itemWindow->GetLabel())
-    return new wxProperty("label", propertyWindow->GetLabel(), "string");
+    return new wxProperty("label", m_propertyWindow->GetLabel(), "string");
   else
     return wxWindowPropertyInfo::GetProperty(name);
 }
 
 bool wxItemPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
   else
     return wxWindowPropertyInfo::GetProperty(name);
 }
 
 bool wxItemPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
-  wxControl *itemWindow = (wxControl *)propertyWindow; 
-  wxFont *font = itemWindow->GetFont();
+  wxControl *itemWindow = (wxControl *)m_propertyWindow; 
+#if 0
+  wxFont *font = & itemWindow->GetFont();
 
   if (font && (name == "fontPoints" || name == "fontFamily" || name == "fontStyle" || name == "fontWeight" || name == "fontUnderlined" ))
   {
     wxFont *newFont = SetFontProperty(name, property, font);
     if (newFont)
 
   if (font && (name == "fontPoints" || name == "fontFamily" || name == "fontStyle" || name == "fontWeight" || name == "fontUnderlined" ))
   {
     wxFont *newFont = SetFontProperty(name, property, font);
     if (newFont)
-      itemWindow->SetLabelFont(newFont);
+      itemWindow->SetFont(* newFont);
     return TRUE;
   }
     return TRUE;
   }
-  else if (name == "label")
+  else
+#endif
+  if (name == "label")
   {
     itemWindow->SetLabel(property->GetValue().StringValue());
     return TRUE;
   {
     itemWindow->SetLabel(property->GetValue().StringValue());
     return TRUE;
@@ -485,13 +822,14 @@ bool wxItemPropertyInfo::InstantiateResource(wxItemResource *resource)
 {
   wxWindowPropertyInfo::InstantiateResource(resource);
   
 {
   wxWindowPropertyInfo::InstantiateResource(resource);
   
-  wxControl *item = (wxControl *)propertyWindow;
+  wxControl *item = (wxControl *)m_propertyWindow;
   wxString str(item->GetLabel());
   wxString str(item->GetLabel());
-  resource->SetTitle(WXSTRINGCAST str);
-  if (item->GetFont() && item->GetFont()->Ok())
-    resource->SetFont(wxTheFontList->FindOrCreateFont(item->GetFont()->GetPointSize(),
-               item->GetFont()->GetFamily(), item->GetFont()->GetStyle(), item->GetFont()->GetWeight(),
-               item->GetFont()->GetUnderlined(), item->GetFont()->GetFaceName()));
+  resource->SetTitle(str);
+
+  if (item->GetFont().Ok())
+    resource->SetFont(* wxTheFontList->FindOrCreateFont(item->GetFont().GetPointSize(),
+               item->GetFont().GetFamily(), item->GetFont().GetStyle(), item->GetFont().GetWeight(),
+               item->GetFont().GetUnderlined(), item->GetFont().GetFaceName()));
   return TRUE;
 }
 
   return TRUE;
 }
 
@@ -501,20 +839,18 @@ bool wxItemPropertyInfo::InstantiateResource(wxItemResource *resource)
 
 wxProperty *wxButtonPropertyInfo::GetProperty(wxString& name)
 {
 
 wxProperty *wxButtonPropertyInfo::GetProperty(wxString& name)
 {
-  wxButton *button = (wxButton *)propertyWindow;
   return wxItemPropertyInfo::GetProperty(name);
 }
 
 bool wxButtonPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
   return wxItemPropertyInfo::GetProperty(name);
 }
 
 bool wxButtonPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
-  wxButton *button = (wxButton *)propertyWindow;
   return wxItemPropertyInfo::SetProperty(name, property);
 }
 
 void wxButtonPropertyInfo::GetPropertyNames(wxStringList& names)
 {
   return wxItemPropertyInfo::SetProperty(name, property);
 }
 
 void wxButtonPropertyInfo::GetPropertyNames(wxStringList& names)
 {
-  names.Add("label");
   wxItemPropertyInfo::GetPropertyNames(names);
   wxItemPropertyInfo::GetPropertyNames(names);
+  names.Add("label");
 }
 
 bool wxButtonPropertyInfo::InstantiateResource(wxItemResource *resource)
 }
 
 bool wxButtonPropertyInfo::InstantiateResource(wxItemResource *resource)
@@ -528,19 +864,17 @@ bool wxButtonPropertyInfo::InstantiateResource(wxItemResource *resource)
 
 wxProperty *wxBitmapButtonPropertyInfo::GetProperty(wxString& name)
 {
 
 wxProperty *wxBitmapButtonPropertyInfo::GetProperty(wxString& name)
 {
-  wxBitmapButton *button = (wxBitmapButton *)propertyWindow;
-  if (name == "label")
+  wxBitmapButton *button = (wxBitmapButton *)m_propertyWindow;
+  if (name == "bitmapFilename")
   {
     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(button);
     wxString str("none.bmp");
    
     if (resource)
     {
   {
     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(button);
     wxString str("none.bmp");
    
     if (resource)
     {
-      char *filename = wxResourceManager::GetCurrentResourceManager()->FindBitmapFilenameForResource(resource);
-      if (filename)
-        str = filename;
+      str = wxResourceManager::GetCurrentResourceManager()->FindBitmapFilenameForResource(resource);
     }
     }
-    return new wxProperty("label", str.GetData(), "string", new wxFilenameListValidator("Select a bitmap file", "*.bmp"));
+    return new wxProperty("bitmapFilename", str.GetData(), "string", new wxFilenameListValidator("Select a bitmap file", "*.bmp"));
   }
   else
     return wxButtonPropertyInfo::GetProperty(name);
   }
   else
     return wxButtonPropertyInfo::GetProperty(name);
@@ -548,18 +882,17 @@ wxProperty *wxBitmapButtonPropertyInfo::GetProperty(wxString& name)
 
 bool wxBitmapButtonPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
 
 bool wxBitmapButtonPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
-  wxBitmapButton *button = (wxBitmapButton *)propertyWindow;
-  if (name == "label")
+  wxBitmapButton *button = (wxBitmapButton *)m_propertyWindow;
+  if (name == "bitmapFilename")
   {
     char *s = property->GetValue().StringValue();
     if (s && wxFileExists(s))
     {
   {
     char *s = property->GetValue().StringValue();
     if (s && wxFileExists(s))
     {
-      s = copystring(s);
-      wxBitmap *bitmap = new wxBitmap(s, wxBITMAP_TYPE_BMP);
+      wxString str(s);
+      wxBitmap *bitmap = new wxBitmap(str, wxBITMAP_TYPE_BMP);
       if (!bitmap->Ok())
       {
         delete bitmap;
       if (!bitmap->Ok())
       {
         delete bitmap;
-        delete[] s;
         return FALSE;
       }
       else
         return FALSE;
       }
       else
@@ -568,15 +901,14 @@ bool wxBitmapButtonPropertyInfo::SetProperty(wxString& name, wxProperty *propert
         if (resource)
         {
           wxString oldResource(resource->GetValue4());
         if (resource)
         {
           wxString oldResource(resource->GetValue4());
-          char *resName = wxResourceManager::GetCurrentResourceManager()->AddBitmapResource(s);
+          wxString resName = wxResourceManager::GetCurrentResourceManager()->AddBitmapResource(str);
           resource->SetValue4(resName);
           
           if (!oldResource.IsNull())
           resource->SetValue4(resName);
           
           if (!oldResource.IsNull())
-            wxResourceManager::GetCurrentResourceManager()->PossiblyDeleteBitmapResource(WXSTRINGCAST oldResource);
+            wxResourceManager::GetCurrentResourceManager()->PossiblyDeleteBitmapResource(oldResource);
         }
 
         }
 
-        button->SetLabel(bitmap);
-        delete[] s;
+        button->SetLabel(* bitmap);
         return TRUE;
       }
     }
         return TRUE;
       }
     }
@@ -588,8 +920,9 @@ bool wxBitmapButtonPropertyInfo::SetProperty(wxString& name, wxProperty *propert
 
 void wxBitmapButtonPropertyInfo::GetPropertyNames(wxStringList& names)
 {
 
 void wxBitmapButtonPropertyInfo::GetPropertyNames(wxStringList& names)
 {
-//  names.Add("label");
   wxButtonPropertyInfo::GetPropertyNames(names);
   wxButtonPropertyInfo::GetPropertyNames(names);
+  names.Delete("label");
+  names.Add("bitmapFilename");
 }
 
 bool wxBitmapButtonPropertyInfo::InstantiateResource(wxItemResource *resource)
 }
 
 bool wxBitmapButtonPropertyInfo::InstantiateResource(wxItemResource *resource)
@@ -603,20 +936,48 @@ bool wxBitmapButtonPropertyInfo::InstantiateResource(wxItemResource *resource)
 
 wxProperty *wxStaticTextPropertyInfo::GetProperty(wxString& name)
 {
 
 wxProperty *wxStaticTextPropertyInfo::GetProperty(wxString& name)
 {
-  wxStaticText *message = (wxStaticText *)propertyWindow;
   return wxItemPropertyInfo::GetProperty(name);
 }
 
 bool wxStaticTextPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
   return wxItemPropertyInfo::GetProperty(name);
 }
 
 bool wxStaticTextPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
-  wxStaticText *message = (wxStaticText *)propertyWindow;
-  return wxItemPropertyInfo::SetProperty(name, property);
+  wxStaticText* itemWindow = (wxStaticText*) m_propertyWindow;
+  if (name == "label")
+  {
+    // Because setting a wxStaticText control's label may change the
+    // size, we must get the size and instantiate the resource immediately.
+    itemWindow->SetLabel(property->GetValue().StringValue());
+    int w, h;
+
+    wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(itemWindow);
+
+    m_propertyWindow->GetSize(&w, &h);
+    // m_propertyWindow->GetPosition(&x, &y);
+
+    // We need to convert to dialog units if 
+    // the parent resource specifies dialog units.
+    if (m_propertyWindow->GetParent())
+    {
+        wxItemResource* parentResource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow->GetParent());
+        if (parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
+        {
+            // wxPoint pt = m_propertyWindow->GetParent()->ConvertPixelsToDialog(wxPoint(x, y));
+            // x = pt.x; y = pt.y;
+            wxSize sz = m_propertyWindow->GetParent()->ConvertPixelsToDialog(wxSize(w, h));
+            w = sz.x; h = sz.y;
+        }
+    }
+    resource->SetSize(resource->GetX(), resource->GetY(), w, h);
+    return TRUE;
+  }
+  else
+    return wxItemPropertyInfo::SetProperty(name, property);
 }
 
 void wxStaticTextPropertyInfo::GetPropertyNames(wxStringList& names)
 {
 }
 
 void wxStaticTextPropertyInfo::GetPropertyNames(wxStringList& names)
 {
-  names.Add("label");
   wxItemPropertyInfo::GetPropertyNames(names);
   wxItemPropertyInfo::GetPropertyNames(names);
+  names.Add("label");
 }
 
 bool wxStaticTextPropertyInfo::InstantiateResource(wxItemResource *resource)
 }
 
 bool wxStaticTextPropertyInfo::InstantiateResource(wxItemResource *resource)
@@ -630,19 +991,17 @@ bool wxStaticTextPropertyInfo::InstantiateResource(wxItemResource *resource)
 
 wxProperty *wxStaticBitmapPropertyInfo::GetProperty(wxString& name)
 {
 
 wxProperty *wxStaticBitmapPropertyInfo::GetProperty(wxString& name)
 {
-  wxStaticBitmap *message = (wxStaticBitmap *)propertyWindow;
-  if (name == "label")
+  wxStaticBitmap *message = (wxStaticBitmap *)m_propertyWindow;
+  if (name == "bitmapFilename")
   {
     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(message);
     wxString str("none.bmp");
    
     if (resource)
     {
   {
     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(message);
     wxString str("none.bmp");
    
     if (resource)
     {
-      char *filename = wxResourceManager::GetCurrentResourceManager()->FindBitmapFilenameForResource(resource);
-      if (filename)
-        str = filename;
+      str = wxResourceManager::GetCurrentResourceManager()->FindBitmapFilenameForResource(resource);
     }
     }
-    return new wxProperty("label", str.GetData(), "string", new wxFilenameListValidator("Select a bitmap file", "*.bmp"));
+    return new wxProperty("bitmapFilename", str.GetData(), "string", new wxFilenameListValidator("Select a bitmap file", "*.bmp"));
   }
   else
     return wxItemPropertyInfo::GetProperty(name);
   }
   else
     return wxItemPropertyInfo::GetProperty(name);
@@ -650,19 +1009,18 @@ wxProperty *wxStaticBitmapPropertyInfo::GetProperty(wxString& name)
 
 bool wxStaticBitmapPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
 
 bool wxStaticBitmapPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
-  wxStaticBitmap *message = (wxStaticBitmap *)propertyWindow;
-  if (name == "label")
+  wxStaticBitmap *message = (wxStaticBitmap *)m_propertyWindow;
+  if (name == "bitmapFilename")
   {
     char *s = property->GetValue().StringValue();
     if (s && wxFileExists(s))
     {
   {
     char *s = property->GetValue().StringValue();
     if (s && wxFileExists(s))
     {
-      s = copystring(s);
+      wxString str(s);
       
       
-      wxBitmap *bitmap = new wxBitmap(s, wxBITMAP_TYPE_BMP);
+      wxBitmap *bitmap = new wxBitmap(str, wxBITMAP_TYPE_BMP);
       if (!bitmap->Ok())
       {
         delete bitmap;
       if (!bitmap->Ok())
       {
         delete bitmap;
-        delete[] s;
         return FALSE;
       }
       else
         return FALSE;
       }
       else
@@ -671,15 +1029,14 @@ bool wxStaticBitmapPropertyInfo::SetProperty(wxString& name, wxProperty *propert
         if (resource)
         {
           wxString oldResource(resource->GetValue4());
         if (resource)
         {
           wxString oldResource(resource->GetValue4());
-          char *resName = wxResourceManager::GetCurrentResourceManager()->AddBitmapResource(s);
+          wxString resName = wxResourceManager::GetCurrentResourceManager()->AddBitmapResource(str);
           resource->SetValue4(resName);
           
           if (!oldResource.IsNull())
           resource->SetValue4(resName);
           
           if (!oldResource.IsNull())
-            wxResourceManager::GetCurrentResourceManager()->PossiblyDeleteBitmapResource(WXSTRINGCAST oldResource);
+            wxResourceManager::GetCurrentResourceManager()->PossiblyDeleteBitmapResource(oldResource);
         }
 
         }
 
-        message->SetBitmap(bitmap);
-        delete[] s;
+        message->SetBitmap(* bitmap);
         return TRUE;
       }
     }
         return TRUE;
       }
     }
@@ -691,8 +1048,8 @@ bool wxStaticBitmapPropertyInfo::SetProperty(wxString& name, wxProperty *propert
 
 void wxStaticBitmapPropertyInfo::GetPropertyNames(wxStringList& names)
 {
 
 void wxStaticBitmapPropertyInfo::GetPropertyNames(wxStringList& names)
 {
-  names.Add("label");
   wxItemPropertyInfo::GetPropertyNames(names);
   wxItemPropertyInfo::GetPropertyNames(names);
+  names.Add("bitmapFilename");
 }
 
 bool wxStaticBitmapPropertyInfo::InstantiateResource(wxItemResource *resource)
 }
 
 bool wxStaticBitmapPropertyInfo::InstantiateResource(wxItemResource *resource)
@@ -706,7 +1063,7 @@ bool wxStaticBitmapPropertyInfo::InstantiateResource(wxItemResource *resource)
 
 wxProperty *wxTextPropertyInfo::GetProperty(wxString& name)
 {
 
 wxProperty *wxTextPropertyInfo::GetProperty(wxString& name)
 {
-  wxTextCtrl *text = (wxTextCtrl *)propertyWindow;
+  wxTextCtrl *text = (wxTextCtrl *)m_propertyWindow;
   if (name == "value")
     return new wxProperty("value", text->GetValue(), "string");
   else if (name == "password")
   if (name == "value")
     return new wxProperty("value", text->GetValue(), "string");
   else if (name == "password")
@@ -725,7 +1082,7 @@ wxProperty *wxTextPropertyInfo::GetProperty(wxString& name)
 
 bool wxTextPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
 
 bool wxTextPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
-  wxTextCtrl *text = (wxTextCtrl *)propertyWindow;
+  wxTextCtrl *text = (wxTextCtrl *)m_propertyWindow;
   if (name == "value")
   {
     text->SetValue(property->GetValue().StringValue());
   if (name == "value")
   {
     text->SetValue(property->GetValue().StringValue());
@@ -747,7 +1104,7 @@ bool wxTextPropertyInfo::SetProperty(wxString& name, wxProperty *property)
     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(text);
     resource->SetStyle(flag);
 
     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(text);
     resource->SetStyle(flag);
 
-    wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(text, this);
+    m_propertyWindow = wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(text, this);
     return TRUE;
   }
   else if (name == "readonly")
     return TRUE;
   }
   else if (name == "readonly")
@@ -766,7 +1123,7 @@ bool wxTextPropertyInfo::SetProperty(wxString& name, wxProperty *property)
     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(text);
     resource->SetStyle(flag);
 
     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(text);
     resource->SetStyle(flag);
 
-    wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(text, this);
+    m_propertyWindow = wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(text, this);
     return TRUE;
   }
   else
     return TRUE;
   }
   else
@@ -775,17 +1132,17 @@ bool wxTextPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 
 void wxTextPropertyInfo::GetPropertyNames(wxStringList& names)
 {
 
 void wxTextPropertyInfo::GetPropertyNames(wxStringList& names)
 {
+  wxItemPropertyInfo::GetPropertyNames(names);
   names.Add("value");
   names.Add("readonly");
   names.Add("password");
   names.Add("value");
   names.Add("readonly");
   names.Add("password");
-  wxItemPropertyInfo::GetPropertyNames(names);  
 }
 
 bool wxTextPropertyInfo::InstantiateResource(wxItemResource *resource)
 {
 }
 
 bool wxTextPropertyInfo::InstantiateResource(wxItemResource *resource)
 {
-  wxTextCtrl *text = (wxTextCtrl *)propertyWindow;
+  wxTextCtrl *text = (wxTextCtrl *)m_propertyWindow;
   wxString str(text->GetValue());
   wxString str(text->GetValue());
-  resource->SetValue4(WXSTRINGCAST str);
+  resource->SetValue4(str);
     
   return wxItemPropertyInfo::InstantiateResource(resource);
 }
     
   return wxItemPropertyInfo::InstantiateResource(resource);
 }
@@ -796,7 +1153,7 @@ bool wxTextPropertyInfo::InstantiateResource(wxItemResource *resource)
 
 wxProperty *wxListBoxPropertyInfo::GetProperty(wxString& name)
 {
 
 wxProperty *wxListBoxPropertyInfo::GetProperty(wxString& name)
 {
-  wxListBox *listBox = (wxListBox *)propertyWindow;
+  wxListBox *listBox = (wxListBox *)m_propertyWindow;
   if (name == "values")
   {
     wxStringList *stringList = new wxStringList;
   if (name == "values")
   {
     wxStringList *stringList = new wxStringList;
@@ -808,26 +1165,19 @@ wxProperty *wxListBoxPropertyInfo::GetProperty(wxString& name)
   }
   else if (name == "multiple")
   {
   }
   else if (name == "multiple")
   {
-    char *pos = NULL;
     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(listBox);
     if (!resource)
       return NULL;
     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(listBox);
     if (!resource)
       return NULL;
+
+    char *mult = "wxLB_SINGLE";
       
       
-    char *mult = "wxSINGLE";
-      
-    switch (resource->GetValue1())
-    {
-      case wxLB_MULTIPLE:
+    if ((listBox->GetWindowStyleFlag() & wxLB_MULTIPLE) != 0)
         mult = "wxLB_MULTIPLE";
         mult = "wxLB_MULTIPLE";
-        break;
-      case wxLB_EXTENDED:
+    else if ((listBox->GetWindowStyleFlag() & wxLB_EXTENDED) != 0)
         mult = "wxLB_EXTENDED";
         mult = "wxLB_EXTENDED";
-        break;
-      default:
-      case wxLB_SINGLE:
+    else
         mult = "wxLB_SINGLE";
         mult = "wxLB_SINGLE";
-        break;
-    }
+
     return new wxProperty("multiple", mult, "string",
        new wxStringListValidator(new wxStringList("wxLB_SINGLE", "wxLB_MULTIPLE", "wxLB_EXTENDED",
           NULL)));
     return new wxProperty("multiple", mult, "string",
        new wxStringListValidator(new wxStringList("wxLB_SINGLE", "wxLB_MULTIPLE", "wxLB_EXTENDED",
           NULL)));
@@ -838,7 +1188,7 @@ wxProperty *wxListBoxPropertyInfo::GetProperty(wxString& name)
 
 bool wxListBoxPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
 
 bool wxListBoxPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
-  wxListBox *listBox = (wxListBox *)propertyWindow;
+  wxListBox *listBox = (wxListBox *)m_propertyWindow;
   if (name == "values")
   {
     listBox->Clear();
   if (name == "values")
   {
     listBox->Clear();
@@ -854,18 +1204,22 @@ bool wxListBoxPropertyInfo::SetProperty(wxString& name, wxProperty *property)
   }
   else if (name == "multiple")
   {
   }
   else if (name == "multiple")
   {
-    int mult = wxLB_SINGLE;
+    SetWindowStyle(m_propertyWindow, wxLB_SINGLE, FALSE);
+    SetWindowStyle(m_propertyWindow, wxLB_MULTIPLE, FALSE);
+    SetWindowStyle(m_propertyWindow, wxLB_EXTENDED, FALSE);
+
     wxString str(property->GetValue().StringValue());
     if (str == "wxLB_MULTIPLE")
     wxString str(property->GetValue().StringValue());
     if (str == "wxLB_MULTIPLE")
-      mult = wxLB_MULTIPLE;
+      SetWindowStyle(m_propertyWindow, wxLB_MULTIPLE, TRUE);
     else if (str == "wxLB_EXTENDED")
     else if (str == "wxLB_EXTENDED")
-      mult = wxLB_EXTENDED;
+      SetWindowStyle(m_propertyWindow, wxLB_EXTENDED, TRUE);
     else
     else
-      mult = wxLB_SINGLE;
+      SetWindowStyle(m_propertyWindow, wxLB_SINGLE, TRUE);
+
     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(listBox);
     if (resource)
     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(listBox);
     if (resource)
-      resource->SetValue1(mult);
-    wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(listBox, this);
+      resource->SetStyle(m_propertyWindow->GetWindowStyleFlag());
+    m_propertyWindow = wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(listBox, this);
     return TRUE;
   }
   else
     return TRUE;
   }
   else
@@ -874,14 +1228,14 @@ bool wxListBoxPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 
 void wxListBoxPropertyInfo::GetPropertyNames(wxStringList& names)
 {
 
 void wxListBoxPropertyInfo::GetPropertyNames(wxStringList& names)
 {
+  wxItemPropertyInfo::GetPropertyNames(names);
   names.Add("values");
   names.Add("multiple");
   names.Add("values");
   names.Add("multiple");
-  wxItemPropertyInfo::GetPropertyNames(names);  
 }
 
 bool wxListBoxPropertyInfo::InstantiateResource(wxItemResource *resource)
 {
 }
 
 bool wxListBoxPropertyInfo::InstantiateResource(wxItemResource *resource)
 {
-  wxListBox *lbox = (wxListBox *)propertyWindow;
+  wxListBox *lbox = (wxListBox *)m_propertyWindow;
   // This will be set for the wxItemResource on reading or in SetProperty
 //  resource->SetValue1(lbox->GetSelectionMode());
   int i;
   // This will be set for the wxItemResource on reading or in SetProperty
 //  resource->SetValue1(lbox->GetSelectionMode());
   int i;
@@ -889,10 +1243,10 @@ bool wxListBoxPropertyInfo::InstantiateResource(wxItemResource *resource)
     resource->SetStringValues(NULL);
   else
   {
     resource->SetStringValues(NULL);
   else
   {
-    wxStringList *slist = new wxStringList;
+    wxStringList slist;
     
     for (i = 0; i < lbox->Number(); i++)
     
     for (i = 0; i < lbox->Number(); i++)
-      slist->Add(lbox->GetString(i));
+      slist.Add(lbox->GetString(i));
       
     resource->SetStringValues(slist);
   }
       
     resource->SetStringValues(slist);
   }
@@ -905,10 +1259,10 @@ bool wxListBoxPropertyInfo::InstantiateResource(wxItemResource *resource)
 
 wxProperty *wxChoicePropertyInfo::GetProperty(wxString& name)
 {
 
 wxProperty *wxChoicePropertyInfo::GetProperty(wxString& name)
 {
-  wxChoice *choice = (wxChoice *)propertyWindow;
+  wxChoice *choice = (wxChoice *)m_propertyWindow;
   if (name == "values")
   {
   if (name == "values")
   {
-    wxStringList *stringList = new wxStringList;
+    wxStringList* stringList = new wxStringList;
     int i;
     for (i = 0; i < choice->Number(); i++)
       stringList->Add(choice->GetString(i));
     int i;
     for (i = 0; i < choice->Number(); i++)
       stringList->Add(choice->GetString(i));
@@ -921,7 +1275,7 @@ wxProperty *wxChoicePropertyInfo::GetProperty(wxString& name)
 
 bool wxChoicePropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
 
 bool wxChoicePropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
-  wxChoice *choice = (wxChoice *)propertyWindow;
+  wxChoice *choice = (wxChoice *)m_propertyWindow;
   if (name == "values")
   {
     choice->Clear();
   if (name == "values")
   {
     choice->Clear();
@@ -943,22 +1297,141 @@ bool wxChoicePropertyInfo::SetProperty(wxString& name, wxProperty *property)
 
 void wxChoicePropertyInfo::GetPropertyNames(wxStringList& names)
 {
 
 void wxChoicePropertyInfo::GetPropertyNames(wxStringList& names)
 {
-  names.Add("values");
   wxItemPropertyInfo::GetPropertyNames(names);
   wxItemPropertyInfo::GetPropertyNames(names);
+  names.Add("values");
 }
 
 bool wxChoicePropertyInfo::InstantiateResource(wxItemResource *resource)
 {
 }
 
 bool wxChoicePropertyInfo::InstantiateResource(wxItemResource *resource)
 {
-  wxChoice *choice = (wxChoice *)propertyWindow;
+  wxChoice *choice = (wxChoice *)m_propertyWindow;
   int i;
   if (choice->Number() == 0)
     resource->SetStringValues(NULL);
   else
   {
   int i;
   if (choice->Number() == 0)
     resource->SetStringValues(NULL);
   else
   {
-    wxStringList *slist = new wxStringList;
+    wxStringList slist;
+    
+    for (i = 0; i < choice->Number(); i++)
+      slist.Add(choice->GetString(i));
+      
+    resource->SetStringValues(slist);
+  }
+  return wxItemPropertyInfo::InstantiateResource(resource);
+}
+
+/*
+ * Choice item
+ */
+
+wxProperty *wxComboBoxPropertyInfo::GetProperty(wxString& name)
+{
+  wxComboBox *choice = (wxComboBox *)m_propertyWindow;
+  if (name == "values")
+  {
+    wxStringList *stringList = new wxStringList;
+    int i;
+    for (i = 0; i < choice->Number(); i++)
+      stringList->Add(choice->GetString(i));
+
+    return new wxProperty(name, stringList, "stringlist");
+  }
+  else if (name == "sort")
+  {
+    bool sort = ((m_propertyWindow->GetWindowStyleFlag() & wxCB_SORT) == wxCB_SORT);
+    return new wxProperty(name, sort, "bool");
+  }
+  else if (name == "style")
+  {
+    wxString styleStr("dropdown");
+    if (m_propertyWindow->GetWindowStyleFlag() & wxCB_SIMPLE)
+      styleStr = "simple";
+    else if (m_propertyWindow->GetWindowStyleFlag() & wxCB_READONLY)
+      styleStr = "readonly";
+    else
+      styleStr = "dropdown";
+
+    return new wxProperty(name, styleStr, "string",
+       new wxStringListValidator(new wxStringList("simple", "dropdown", "readonly",
+          NULL)));
+  }
+  else
+    return wxItemPropertyInfo::GetProperty(name);
+}
+
+bool wxComboBoxPropertyInfo::SetProperty(wxString& name, wxProperty *property)
+{
+  wxComboBox *choice = (wxComboBox *)m_propertyWindow;
+  if (name == "values")
+  {
+    choice->Clear();
+    wxPropertyValue *expr = property->GetValue().GetFirst();
+    while (expr)
+    {
+      char *s = expr->StringValue();
+      if (s)
+        choice->Append(s);
+      expr = expr->GetNext();
+    }
+    if (choice->Number() > 0)
+      choice->SetSelection(0);
+    return TRUE;
+  }
+  else if (name == "sort")
+  {
+    SetWindowStyle(m_propertyWindow, wxCB_SORT, property->GetValue().BoolValue());
+
+    wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
+    resource->SetStyle(m_propertyWindow->GetWindowStyleFlag());
+
+    m_propertyWindow = wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(m_propertyWindow, this);
+    return TRUE;
+  }
+  else if (name == "style")
+  {
+    SetWindowStyle(m_propertyWindow, wxCB_SIMPLE, FALSE);
+    SetWindowStyle(m_propertyWindow, wxCB_DROPDOWN, FALSE);
+    SetWindowStyle(m_propertyWindow, wxCB_READONLY, FALSE);
+
+    wxString styleStr(property->GetValue().StringValue());
+    if (styleStr == "simple")
+      SetWindowStyle(m_propertyWindow, wxCB_SIMPLE, TRUE);
+    else if (styleStr == "dropdown")
+      SetWindowStyle(m_propertyWindow, wxCB_DROPDOWN, TRUE);
+    else if (styleStr == "readonly")
+      SetWindowStyle(m_propertyWindow, wxCB_READONLY, TRUE);
+
+      // Necesary?
+    wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
+    resource->SetStyle(m_propertyWindow->GetWindowStyleFlag());
+
+    m_propertyWindow = wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(m_propertyWindow, this);
+
+    return TRUE;
+  }
+  else
+    return wxItemPropertyInfo::SetProperty(name, property);
+}
+
+void wxComboBoxPropertyInfo::GetPropertyNames(wxStringList& names)
+{
+  wxItemPropertyInfo::GetPropertyNames(names);
+  names.Add("values");
+  names.Add("style");
+  names.Add("sort");
+}
+
+bool wxComboBoxPropertyInfo::InstantiateResource(wxItemResource *resource)
+{
+  wxComboBox *choice = (wxComboBox *)m_propertyWindow;
+  int i;
+  if (choice->Number() == 0)
+    resource->SetStringValues(NULL);
+  else
+  {
+    wxStringList slist;
     
     for (i = 0; i < choice->Number(); i++)
     
     for (i = 0; i < choice->Number(); i++)
-      slist->Add(choice->GetString(i));
+      slist.Add(choice->GetString(i));
       
     resource->SetStringValues(slist);
   }
       
     resource->SetStringValues(slist);
   }
@@ -971,21 +1444,21 @@ bool wxChoicePropertyInfo::InstantiateResource(wxItemResource *resource)
 
 wxProperty *wxRadioBoxPropertyInfo::GetProperty(wxString& name)
 {
 
 wxProperty *wxRadioBoxPropertyInfo::GetProperty(wxString& name)
 {
-  wxRadioBox *radioBox = (wxRadioBox *)propertyWindow;
+  wxRadioBox *radioBox = (wxRadioBox *)m_propertyWindow;
   if (name == "numberRowsOrCols")
   {
     return new wxProperty("numberRowsOrCols", (long)radioBox->GetNumberOfRowsOrCols(), "integer");
   }
   if (name == "orientation")
   {
   if (name == "numberRowsOrCols")
   {
     return new wxProperty("numberRowsOrCols", (long)radioBox->GetNumberOfRowsOrCols(), "integer");
   }
   if (name == "orientation")
   {
-    char *pos = NULL;
-    if (propertyWindow->GetWindowStyleFlag() & wxHORIZONTAL)
-      pos = "wxHORIZONTAL";
+    wxString orient;
+    if (m_propertyWindow->GetWindowStyleFlag() & wxRA_SPECIFY_COLS)
+      orient = "wxRA_SPECIFY_COLS";
     else
     else
-      pos = "wxVERTICAL";
+      orient = "wxRA_SPECIFY_ROWS";
 
 
-    return new wxProperty("orientation", pos, "string",
-       new wxStringListValidator(new wxStringList("wxHORIZONTAL", "wxVERTICAL",
+    return new wxProperty("orientation", orient, "string",
+       new wxStringListValidator(new wxStringList("wxRA_SPECIFY_COLS", "wxRA_SPECIFY_ROWS",
           NULL)));
   }
   else if (name == "values")
           NULL)));
   }
   else if (name == "values")
@@ -1002,32 +1475,39 @@ wxProperty *wxRadioBoxPropertyInfo::GetProperty(wxString& name)
 
 bool wxRadioBoxPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
 
 bool wxRadioBoxPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
-  wxRadioBox *radioBox = (wxRadioBox *)propertyWindow;
+  wxRadioBox *radioBox = (wxRadioBox *)m_propertyWindow;
   if (name == "numberRowsOrCols")
   {
   if (name == "numberRowsOrCols")
   {
+    wxResourceManager::GetCurrentResourceManager()->DeselectItemIfNecessary(radioBox);
+
     radioBox->SetNumberOfRowsOrCols((int)property->GetValue().IntegerValue());
     radioBox->SetNumberOfRowsOrCols((int)property->GetValue().IntegerValue());
-    wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(radioBox, this);
+    m_propertyWindow = wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(radioBox, this);
     return TRUE;
   }
   else if (name == "orientation")
   {
     long windowStyle = radioBox->GetWindowStyleFlag();
     wxString val(property->GetValue().StringValue());
     return TRUE;
   }
   else if (name == "orientation")
   {
     long windowStyle = radioBox->GetWindowStyleFlag();
     wxString val(property->GetValue().StringValue());
-    if (val == "wxHORIZONTAL")
+    if (val == "wxRA_SPECIFY_COLS")
     {
     {
-      if (windowStyle & wxVERTICAL)
-        windowStyle -= wxVERTICAL;
-      windowStyle |= wxHORIZONTAL;
+      if (windowStyle & wxRA_SPECIFY_ROWS)
+        windowStyle -= wxRA_SPECIFY_ROWS;
+      windowStyle |= wxRA_SPECIFY_COLS;
     }
     else
     {
     }
     else
     {
-      if (windowStyle & wxHORIZONTAL)
-        windowStyle -= wxHORIZONTAL;
-      windowStyle |= wxVERTICAL;
+      if (windowStyle & wxRA_SPECIFY_COLS)
+        windowStyle -= wxRA_SPECIFY_COLS;
+      windowStyle |= wxRA_SPECIFY_ROWS;
     }
     }
+    wxResourceManager::GetCurrentResourceManager()->DeselectItemIfNecessary(radioBox);
+
     radioBox->SetWindowStyleFlag(windowStyle);
     radioBox->SetWindowStyleFlag(windowStyle);
+    wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(radioBox);
+    resource->SetStyle(windowStyle);
+    resource->SetSize(resource->GetX(), resource->GetY(), -1, -1); // Let it calculate it's own size
     
     
-    wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(radioBox, this);
+    m_propertyWindow = wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(radioBox, this, FALSE);
     return TRUE;
   }
   else if (name == "values")
     return TRUE;
   }
   else if (name == "values")
@@ -1035,44 +1515,61 @@ bool wxRadioBoxPropertyInfo::SetProperty(wxString& name, wxProperty *property)
     // Set property into *resource*, not wxRadioBox, and then recreate
     // the wxRadioBox. This is because we can't dynamically set the strings
     // of a wxRadioBox.
     // Set property into *resource*, not wxRadioBox, and then recreate
     // the wxRadioBox. This is because we can't dynamically set the strings
     // of a wxRadioBox.
-    wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(propertyWindow);
+    wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
     if (!resource)
       return FALSE;
       
     if (!resource)
       return FALSE;
       
-    wxStringList *stringList = resource->GetStringValues();
-    if (!stringList)
-    {
-      stringList = new wxStringList;
-      resource->SetStringValues(stringList);
-    }
-    stringList->Clear();
-      
+    wxStringList stringList;
     wxPropertyValue *expr = property->GetValue().GetFirst();
     while (expr)
     {
       char *s = expr->StringValue();
       if (s)
     wxPropertyValue *expr = property->GetValue().GetFirst();
     while (expr)
     {
       char *s = expr->StringValue();
       if (s)
-        stringList->Add(s);
+        stringList.Add(s);
       expr = expr->GetNext();
     }
       expr = expr->GetNext();
     }
-    wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(radioBox, this);
+    resource->SetStringValues(stringList);
+    resource->SetSize(resource->GetX(), resource->GetY(), -1, -1); // Let it calculate it's own size
+    m_propertyWindow = wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(radioBox, this, FALSE);
     return TRUE;
   }
     return TRUE;
   }
+  else if (name == "fontPoints" || name == "fontFamily" || name == "fontStyle" || name == "fontWeight" || name == "fontUnderlined" )
+  {
+    wxFont *font = & m_propertyWindow->GetFont();
+    if (!font)
+        return FALSE;
+    wxFont *newFont = SetFontProperty(name, property, font);
+    if (newFont)
+    {
+      wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
+      if (resource)
+      {
+          resource->SetFont(* newFont);
+      }
+
+      wxResourceManager::GetCurrentResourceManager()->DeselectItemIfNecessary(radioBox);
+
+      radioBox->SetFont(* newFont);
+      radioBox->SetSize(-1, -1, -1, -1, wxSIZE_AUTO_WIDTH | wxSIZE_AUTO_HEIGHT);
+      return TRUE;
+    }
+  }
+
   return wxItemPropertyInfo::SetProperty(name, property);
 }
 
 void wxRadioBoxPropertyInfo::GetPropertyNames(wxStringList& names)
 {
   return wxItemPropertyInfo::SetProperty(name, property);
 }
 
 void wxRadioBoxPropertyInfo::GetPropertyNames(wxStringList& names)
 {
+  wxItemPropertyInfo::GetPropertyNames(names);
   names.Add("label");
   names.Add("values");
   names.Add("orientation");
   names.Add("numberRowsOrCols");
   names.Add("label");
   names.Add("values");
   names.Add("orientation");
   names.Add("numberRowsOrCols");
-  wxItemPropertyInfo::GetPropertyNames(names);
 }
 
 bool wxRadioBoxPropertyInfo::InstantiateResource(wxItemResource *resource)
 {
 }
 
 bool wxRadioBoxPropertyInfo::InstantiateResource(wxItemResource *resource)
 {
-  wxRadioBox *rbox = (wxRadioBox *)propertyWindow;
+  wxRadioBox *rbox = (wxRadioBox *)m_propertyWindow;
   // Take strings from resource instead
 /*
   int i;
   // Take strings from resource instead
 /*
   int i;
@@ -1098,7 +1595,6 @@ bool wxRadioBoxPropertyInfo::InstantiateResource(wxItemResource *resource)
 
 wxProperty *wxGroupBoxPropertyInfo::GetProperty(wxString& name)
 {
 
 wxProperty *wxGroupBoxPropertyInfo::GetProperty(wxString& name)
 {
-  wxStaticBox *groupBox = (wxStaticBox *)propertyWindow;
   return wxItemPropertyInfo::GetProperty(name);
 }
 
   return wxItemPropertyInfo::GetProperty(name);
 }
 
@@ -1109,13 +1605,12 @@ bool wxGroupBoxPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 
 void wxGroupBoxPropertyInfo::GetPropertyNames(wxStringList& names)
 {  
 
 void wxGroupBoxPropertyInfo::GetPropertyNames(wxStringList& names)
 {  
-  names.Add("label");
   wxItemPropertyInfo::GetPropertyNames(names);
   wxItemPropertyInfo::GetPropertyNames(names);
+  names.Add("label");
 }
 
 bool wxGroupBoxPropertyInfo::InstantiateResource(wxItemResource *resource)
 {
 }
 
 bool wxGroupBoxPropertyInfo::InstantiateResource(wxItemResource *resource)
 {
-  wxStaticBox *gbox = (wxStaticBox *)propertyWindow;
   return wxItemPropertyInfo::InstantiateResource(resource);
 }
 
   return wxItemPropertyInfo::InstantiateResource(resource);
 }
 
@@ -1125,7 +1620,7 @@ bool wxGroupBoxPropertyInfo::InstantiateResource(wxItemResource *resource)
 
 wxProperty *wxCheckBoxPropertyInfo::GetProperty(wxString& name)
 {
 
 wxProperty *wxCheckBoxPropertyInfo::GetProperty(wxString& name)
 {
-  wxCheckBox *checkBox = (wxCheckBox *)propertyWindow;
+  wxCheckBox *checkBox = (wxCheckBox *)m_propertyWindow;
   if (name == "value")
     return new wxProperty("value", checkBox->GetValue(), "bool");
   else
   if (name == "value")
     return new wxProperty("value", checkBox->GetValue(), "bool");
   else
@@ -1134,7 +1629,7 @@ wxProperty *wxCheckBoxPropertyInfo::GetProperty(wxString& name)
 
 bool wxCheckBoxPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
 
 bool wxCheckBoxPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
-  wxCheckBox *checkBox = (wxCheckBox *)propertyWindow;
+  wxCheckBox *checkBox = (wxCheckBox *)m_propertyWindow;
   if (name == "value")
   {
     checkBox->SetValue((bool)property->GetValue().BoolValue());
   if (name == "value")
   {
     checkBox->SetValue((bool)property->GetValue().BoolValue());
@@ -1146,14 +1641,14 @@ bool wxCheckBoxPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 
 void wxCheckBoxPropertyInfo::GetPropertyNames(wxStringList& names)
 {
 
 void wxCheckBoxPropertyInfo::GetPropertyNames(wxStringList& names)
 {
+  wxItemPropertyInfo::GetPropertyNames(names);
   names.Add("label");
   names.Add("value");
   names.Add("label");
   names.Add("value");
-  wxItemPropertyInfo::GetPropertyNames(names);
 }
 
 bool wxCheckBoxPropertyInfo::InstantiateResource(wxItemResource *resource)
 {
 }
 
 bool wxCheckBoxPropertyInfo::InstantiateResource(wxItemResource *resource)
 {
-  wxCheckBox *cbox = (wxCheckBox *)propertyWindow;
+  wxCheckBox *cbox = (wxCheckBox *)m_propertyWindow;
   resource->SetValue1(cbox->GetValue());
   return wxItemPropertyInfo::InstantiateResource(resource);
 }
   resource->SetValue1(cbox->GetValue());
   return wxItemPropertyInfo::InstantiateResource(resource);
 }
@@ -1164,7 +1659,7 @@ bool wxCheckBoxPropertyInfo::InstantiateResource(wxItemResource *resource)
 
 wxProperty *wxRadioButtonPropertyInfo::GetProperty(wxString& name)
 {
 
 wxProperty *wxRadioButtonPropertyInfo::GetProperty(wxString& name)
 {
-  wxRadioButton *checkBox = (wxRadioButton *)propertyWindow;
+  wxRadioButton *checkBox = (wxRadioButton *)m_propertyWindow;
   if (name == "value")
     return new wxProperty("value", checkBox->GetValue(), "bool");
   else
   if (name == "value")
     return new wxProperty("value", checkBox->GetValue(), "bool");
   else
@@ -1173,7 +1668,7 @@ wxProperty *wxRadioButtonPropertyInfo::GetProperty(wxString& name)
 
 bool wxRadioButtonPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
 
 bool wxRadioButtonPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
-  wxRadioButton *checkBox = (wxRadioButton *)propertyWindow;
+  wxRadioButton *checkBox = (wxRadioButton *)m_propertyWindow;
   if (name == "value")
   {
     checkBox->SetValue((bool)property->GetValue().BoolValue());
   if (name == "value")
   {
     checkBox->SetValue((bool)property->GetValue().BoolValue());
@@ -1185,14 +1680,14 @@ bool wxRadioButtonPropertyInfo::SetProperty(wxString& name, wxProperty *property
 
 void wxRadioButtonPropertyInfo::GetPropertyNames(wxStringList& names)
 {
 
 void wxRadioButtonPropertyInfo::GetPropertyNames(wxStringList& names)
 {
+  wxItemPropertyInfo::GetPropertyNames(names);
   names.Add("label");
   names.Add("value");
   names.Add("label");
   names.Add("value");
-  wxItemPropertyInfo::GetPropertyNames(names);
 }
 
 bool wxRadioButtonPropertyInfo::InstantiateResource(wxItemResource *resource)
 {
 }
 
 bool wxRadioButtonPropertyInfo::InstantiateResource(wxItemResource *resource)
 {
-  wxRadioButton *cbox = (wxRadioButton *)propertyWindow;
+  wxRadioButton *cbox = (wxRadioButton *)m_propertyWindow;
   resource->SetValue1(cbox->GetValue());
   return wxItemPropertyInfo::InstantiateResource(resource);
 }
   resource->SetValue1(cbox->GetValue());
   return wxItemPropertyInfo::InstantiateResource(resource);
 }
@@ -1203,13 +1698,13 @@ bool wxRadioButtonPropertyInfo::InstantiateResource(wxItemResource *resource)
 
 wxProperty *wxSliderPropertyInfo::GetProperty(wxString& name)
 {
 
 wxProperty *wxSliderPropertyInfo::GetProperty(wxString& name)
 {
-  wxSlider *slider = (wxSlider *)propertyWindow;
+  wxSlider *slider = (wxSlider *)m_propertyWindow;
   if (name == "value")
     return new wxProperty("value", (long)slider->GetValue(), "integer");
   else if (name == "orientation")
   {
     char *pos = NULL;
   if (name == "value")
     return new wxProperty("value", (long)slider->GetValue(), "integer");
   else if (name == "orientation")
   {
     char *pos = NULL;
-    if (propertyWindow->GetWindowStyleFlag() & wxHORIZONTAL)
+    if (m_propertyWindow->GetWindowStyleFlag() & wxHORIZONTAL)
       pos = "wxHORIZONTAL";
     else
       pos = "wxVERTICAL";
       pos = "wxHORIZONTAL";
     else
       pos = "wxVERTICAL";
@@ -1218,17 +1713,17 @@ wxProperty *wxSliderPropertyInfo::GetProperty(wxString& name)
        new wxStringListValidator(new wxStringList("wxHORIZONTAL", "wxVERTICAL",
           NULL)));
   }
        new wxStringListValidator(new wxStringList("wxHORIZONTAL", "wxVERTICAL",
           NULL)));
   }
-  else if (name == "min_value")
-    return new wxProperty("min_value", (long)slider->GetMin(), "integer");
-  else if (name == "max_value")
-    return new wxProperty("max_value", (long)slider->GetMax(), "integer");
+  else if (name == "minValue")
+    return new wxProperty("minValue", (long)slider->GetMin(), "integer");
+  else if (name == "maxValue")
+    return new wxProperty("maxValue", (long)slider->GetMax(), "integer");
   else
     return wxItemPropertyInfo::GetProperty(name);
 }
 
 bool wxSliderPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
   else
     return wxItemPropertyInfo::GetProperty(name);
 }
 
 bool wxSliderPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
-  wxSlider *slider = (wxSlider *)propertyWindow;
+  wxSlider *slider = (wxSlider *)m_propertyWindow;
   if (name == "value")
   {
     slider->SetValue((int)property->GetValue().IntegerValue());
   if (name == "value")
   {
     slider->SetValue((int)property->GetValue().IntegerValue());
@@ -1263,15 +1758,16 @@ bool wxSliderPropertyInfo::SetProperty(wxString& name, wxProperty *property)
     
     slider = (wxSlider *)wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(slider, this);
     slider->SetSize(-1, -1, h, w);
     
     slider = (wxSlider *)wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(slider, this);
     slider->SetSize(-1, -1, h, w);
+    m_propertyWindow = slider;
     
     return TRUE;
   }
     
     return TRUE;
   }
-  else if (name == "min_value")
+  else if (name == "minValue")
   {
     slider->SetRange((int)property->GetValue().IntegerValue(), slider->GetMax());
     return TRUE;
   }
   {
     slider->SetRange((int)property->GetValue().IntegerValue(), slider->GetMax());
     return TRUE;
   }
-  else if (name == "max_value")
+  else if (name == "maxValue")
   {
     slider->SetRange(slider->GetMin(), (int)property->GetValue().IntegerValue());
     return TRUE;
   {
     slider->SetRange(slider->GetMin(), (int)property->GetValue().IntegerValue());
     return TRUE;
@@ -1282,16 +1778,16 @@ bool wxSliderPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 
 void wxSliderPropertyInfo::GetPropertyNames(wxStringList& names)
 {
 
 void wxSliderPropertyInfo::GetPropertyNames(wxStringList& names)
 {
+  wxItemPropertyInfo::GetPropertyNames(names);
   names.Add("value");
   names.Add("orientation");
   names.Add("value");
   names.Add("orientation");
-  names.Add("min_value");
-  names.Add("max_value");
-  wxItemPropertyInfo::GetPropertyNames(names);
+  names.Add("minValue");
+  names.Add("maxValue");
 }
 
 bool wxSliderPropertyInfo::InstantiateResource(wxItemResource *resource)
 {
 }
 
 bool wxSliderPropertyInfo::InstantiateResource(wxItemResource *resource)
 {
-  wxSlider *slider = (wxSlider *)propertyWindow;
+  wxSlider *slider = (wxSlider *)m_propertyWindow;
   resource->SetValue1(slider->GetValue());
   resource->SetValue2(slider->GetMin());
   resource->SetValue3(slider->GetMax());
   resource->SetValue1(slider->GetValue());
   resource->SetValue2(slider->GetMin());
   resource->SetValue3(slider->GetMax());
@@ -1304,24 +1800,24 @@ bool wxSliderPropertyInfo::InstantiateResource(wxItemResource *resource)
 
 wxProperty *wxGaugePropertyInfo::GetProperty(wxString& name)
 {
 
 wxProperty *wxGaugePropertyInfo::GetProperty(wxString& name)
 {
-  wxGauge *gauge = (wxGauge *)propertyWindow;
+  wxGauge *gauge = (wxGauge *)m_propertyWindow;
   if (name == "value")
     return new wxProperty("value", (long)gauge->GetValue(), "integer");
   if (name == "value")
     return new wxProperty("value", (long)gauge->GetValue(), "integer");
-  else if (name == "max_value")
-    return new wxProperty("max_value", (long)gauge->GetRange(), "integer");
+  else if (name == "maxValue")
+    return new wxProperty("maxValue", (long)gauge->GetRange(), "integer");
   else
     return wxItemPropertyInfo::GetProperty(name);
 }
 
 bool wxGaugePropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
   else
     return wxItemPropertyInfo::GetProperty(name);
 }
 
 bool wxGaugePropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
-  wxGauge *gauge = (wxGauge *)propertyWindow;
+  wxGauge *gauge = (wxGauge *)m_propertyWindow;
   if (name == "value")
   {
     gauge->SetValue((int)property->GetValue().IntegerValue());
     return TRUE;
   }
   if (name == "value")
   {
     gauge->SetValue((int)property->GetValue().IntegerValue());
     return TRUE;
   }
-  else if (name == "max_value")
+  else if (name == "maxValue")
   {
     gauge->SetRange((int)property->GetValue().IntegerValue());
     return TRUE;
   {
     gauge->SetRange((int)property->GetValue().IntegerValue());
     return TRUE;
@@ -1332,14 +1828,14 @@ bool wxGaugePropertyInfo::SetProperty(wxString& name, wxProperty *property)
 
 void wxGaugePropertyInfo::GetPropertyNames(wxStringList& names)
 {
 
 void wxGaugePropertyInfo::GetPropertyNames(wxStringList& names)
 {
-  names.Add("value");
-  names.Add("max_value");
   wxItemPropertyInfo::GetPropertyNames(names);
   wxItemPropertyInfo::GetPropertyNames(names);
+  names.Add("value");
+  names.Add("maxValue");
 }
 
 bool wxGaugePropertyInfo::InstantiateResource(wxItemResource *resource)
 {
 }
 
 bool wxGaugePropertyInfo::InstantiateResource(wxItemResource *resource)
 {
-  wxGauge *gauge = (wxGauge *)propertyWindow;
+  wxGauge *gauge = (wxGauge *)m_propertyWindow;
   resource->SetValue1(gauge->GetValue());
   resource->SetValue2(gauge->GetRange());
   return wxItemPropertyInfo::InstantiateResource(resource);
   resource->SetValue1(gauge->GetValue());
   resource->SetValue2(gauge->GetRange());
   return wxItemPropertyInfo::InstantiateResource(resource);
@@ -1351,13 +1847,13 @@ bool wxGaugePropertyInfo::InstantiateResource(wxItemResource *resource)
 
 wxProperty *wxScrollBarPropertyInfo::GetProperty(wxString& name)
 {
 
 wxProperty *wxScrollBarPropertyInfo::GetProperty(wxString& name)
 {
-  wxScrollBar *scrollBar = (wxScrollBar *)propertyWindow;
-  if (name == "value")
-    return new wxProperty("value", (long)scrollBar->GetValue(), "integer");
+  wxScrollBar *scrollBar = (wxScrollBar *)m_propertyWindow;
+  if (name == "thumbPosition")
+    return new wxProperty("value", (long)scrollBar->GetThumbPosition(), "integer");
   else if (name == "orientation")
   {
     char *pos = NULL;
   else if (name == "orientation")
   {
     char *pos = NULL;
-    if (propertyWindow->GetWindowStyleFlag() & wxHORIZONTAL)
+    if (m_propertyWindow->GetWindowStyleFlag() & wxHORIZONTAL)
       pos = "wxHORIZONTAL";
     else
       pos = "wxVERTICAL";
       pos = "wxHORIZONTAL";
     else
       pos = "wxVERTICAL";
@@ -1368,24 +1864,20 @@ wxProperty *wxScrollBarPropertyInfo::GetProperty(wxString& name)
   }
   else if (name == "pageSize")
   {
   }
   else if (name == "pageSize")
   {
-    int viewStart, pageLength, objectLength, viewLength;
-    scrollBar->GetValues(&viewStart, &viewLength, &objectLength, &pageLength);
+    int pageLength = scrollBar->GetPageSize();
     
     return new wxProperty("pageSize", (long)pageLength, "integer");
   }
     
     return new wxProperty("pageSize", (long)pageLength, "integer");
   }
-  else if (name == "viewLength")
+  else if (name == "thumbSize")
   {
   {
-    int viewStart, pageLength, objectLength, viewLength;
-    scrollBar->GetValues(&viewStart, &viewLength, &objectLength, &pageLength);
+    int thumbSize = scrollBar->GetThumbSize();
     
     
-    return new wxProperty("viewLength", (long)viewLength, "integer");
+    return new wxProperty("thumbSize", (long)thumbSize, "integer");
   }
   }
-  else if (name == "objectLength")
+  else if (name == "range")
   {
   {
-    int viewStart, pageLength, objectLength, viewLength;
-    scrollBar->GetValues(&viewStart, &viewLength, &objectLength, &pageLength);
-    
-    return new wxProperty("objectLength", (long)objectLength, "integer");
+    int range = scrollBar->GetRange();
+    return new wxProperty("range", (long)range, "integer");
   }
   else
     return wxItemPropertyInfo::GetProperty(name);
   }
   else
     return wxItemPropertyInfo::GetProperty(name);
@@ -1393,10 +1885,10 @@ wxProperty *wxScrollBarPropertyInfo::GetProperty(wxString& name)
 
 bool wxScrollBarPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
 
 bool wxScrollBarPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
-  wxScrollBar *scrollBar = (wxScrollBar *)propertyWindow;
-  if (name == "value")
+  wxScrollBar *scrollBar = (wxScrollBar *)m_propertyWindow;
+  if (name == "thumbPosition")
   {
   {
-    scrollBar->SetValue((int)property->GetValue().IntegerValue());
+    scrollBar->SetThumbPosition((int)property->GetValue().IntegerValue());
     return TRUE;
   }
   else if (name == "orientation")
     return TRUE;
   }
   else if (name == "orientation")
@@ -1423,27 +1915,41 @@ bool wxScrollBarPropertyInfo::SetProperty(wxString& name, wxProperty *property)
     scrollBar->SetWindowStyleFlag(windowStyle);
     
     // If the window style has changed, we swap the width and height parameters.
     scrollBar->SetWindowStyleFlag(windowStyle);
     
     // If the window style has changed, we swap the width and height parameters.
-    int w, h;
-    scrollBar->GetSize(&w, &h);
-    
+//    int w, h;
+//    scrollBar->GetSize(&w, &h);
+    wxItemResource     *item = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(scrollBar);
+       if ( item ) {
+               item->SetSize(item->GetX(), item->GetY(), item->GetHeight(), item->GetWidth());
+               item->SetStyle(windowStyle);
+       } /* IF */
+
     scrollBar = (wxScrollBar *)wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(scrollBar, this);
     scrollBar = (wxScrollBar *)wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(scrollBar, this);
-    scrollBar->SetSize(-1, -1, h, w);
-    
+    m_propertyWindow = scrollBar;
+
     return TRUE;
   }
   else if (name == "pageSize")
   {
     return TRUE;
   }
   else if (name == "pageSize")
   {
-    scrollBar->SetPageSize((int)property->GetValue().IntegerValue());
+    int pos = scrollBar->GetThumbPosition();
+    int range = scrollBar->GetRange();
+    int thumbSize = scrollBar->GetThumbSize();
+    scrollBar->SetScrollbar(pos, thumbSize, range, (int)property->GetValue().IntegerValue());
     return TRUE;
   }
     return TRUE;
   }
-  else if (name == "viewLength")
+  else if (name == "thumbSize")
   {
   {
-    scrollBar->SetViewLength((int)property->GetValue().IntegerValue());
+    int pos = scrollBar->GetThumbPosition();
+    int range = scrollBar->GetRange();
+    int pageSize = scrollBar->GetPageSize();
+    scrollBar->SetScrollbar(pos, (int)property->GetValue().IntegerValue(), range, pageSize);
     return TRUE;
   }
     return TRUE;
   }
-  else if (name == "objectLength")
+  else if (name == "range")
   {
   {
-    scrollBar->SetObjectLength((int)property->GetValue().IntegerValue());
+    int pos = scrollBar->GetThumbPosition();
+    int thumbSize = scrollBar->GetThumbSize();
+    int pageSize = scrollBar->GetPageSize();
+    scrollBar->SetScrollbar(pos, thumbSize, (int)property->GetValue().IntegerValue(), pageSize);
     return TRUE;
   }
   else
     return TRUE;
   }
   else
@@ -1452,12 +1958,12 @@ bool wxScrollBarPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 
 void wxScrollBarPropertyInfo::GetPropertyNames(wxStringList& names)
 {
 
 void wxScrollBarPropertyInfo::GetPropertyNames(wxStringList& names)
 {
+  wxItemPropertyInfo::GetPropertyNames(names);
   names.Add("orientation");
   names.Add("orientation");
-  names.Add("value");
+  names.Add("thumbPosition");
+  names.Add("thumbSize");
   names.Add("pageSize");
   names.Add("pageSize");
-  names.Add("viewLength");
-  names.Add("objectLength");
-  wxItemPropertyInfo::GetPropertyNames(names);
+  names.Add("range");
 
   // Remove some properties we don't inherit
   names.Delete("fontPoints");
 
   // Remove some properties we don't inherit
   names.Delete("fontPoints");
@@ -1469,16 +1975,17 @@ void wxScrollBarPropertyInfo::GetPropertyNames(wxStringList& names)
 
 bool wxScrollBarPropertyInfo::InstantiateResource(wxItemResource *resource)
 {
 
 bool wxScrollBarPropertyInfo::InstantiateResource(wxItemResource *resource)
 {
-  wxScrollBar *sbar = (wxScrollBar *)propertyWindow;
-  
-  resource->SetValue1(sbar->GetValue());
+  wxScrollBar *sbar = (wxScrollBar *)m_propertyWindow;
 
 
-  int viewStart, pageLength, objectLength, viewLength;
-  sbar->GetValues(&viewStart, &viewLength, &objectLength, &pageLength);
+  int thumbPosition = sbar->GetThumbPosition();
+  int thumbSize = sbar->GetThumbSize();
+  int pageSize = sbar->GetPageSize();
+  int range = sbar->GetRange();
   
   
-  resource->SetValue2(pageLength);
-  resource->SetValue3(objectLength);
-  resource->SetValue5(viewLength);
+  resource->SetValue1(thumbPosition);
+  resource->SetValue2(thumbSize);
+  resource->SetValue3(range);
+  resource->SetValue5(pageSize);
 
   return wxItemPropertyInfo::InstantiateResource(resource);
 }
 
   return wxItemPropertyInfo::InstantiateResource(resource);
 }
@@ -1489,7 +1996,9 @@ bool wxScrollBarPropertyInfo::InstantiateResource(wxItemResource *resource)
 
 wxProperty *wxPanelPropertyInfo::GetProperty(wxString& name)
 {
 
 wxProperty *wxPanelPropertyInfo::GetProperty(wxString& name)
 {
-  wxPanel *panelWindow = (wxPanel *)propertyWindow; 
+  wxPanel *panelWindow = (wxPanel *)m_propertyWindow; 
+
+/*
   wxFont *labelFont = panelWindow->GetLabelFont();
   wxFont *buttonFont = panelWindow->GetButtonFont();
   
   wxFont *labelFont = panelWindow->GetLabelFont();
   wxFont *buttonFont = panelWindow->GetButtonFont();
   
@@ -1499,7 +2008,9 @@ wxProperty *wxPanelPropertyInfo::GetProperty(wxString& name)
   else if (name == "buttonFontPoints" || name == "buttonFontFamily" || name == "buttonFontStyle" || name == "buttonFontWeight" ||
       name == "buttonFontUnderlined")
     return GetFontProperty(name, buttonFont);
   else if (name == "buttonFontPoints" || name == "buttonFontFamily" || name == "buttonFontStyle" || name == "buttonFontWeight" ||
       name == "buttonFontUnderlined")
     return GetFontProperty(name, buttonFont);
-  else if (name == "no3D")
+*/
+
+  if (name == "no3D")
   {
     bool userColours;
     if (panelWindow->GetWindowStyleFlag() & wxNO_3D)
   {
     bool userColours;
     if (panelWindow->GetWindowStyleFlag() & wxNO_3D)
@@ -1527,34 +2038,63 @@ wxProperty *wxPanelPropertyInfo::GetProperty(wxString& name)
     else
         return new wxProperty(name, "Could not get title", "string");
   }
     else
         return new wxProperty(name, "Could not get title", "string");
   }
+  else if (name == "caption")
+  {
+    return new wxProperty(name, ((panelWindow->GetWindowStyleFlag() & wxCAPTION) == wxCAPTION),
+        "bool");
+  }
+  else if (name == "systemMenu")
+  {
+    return new wxProperty(name, ((panelWindow->GetWindowStyleFlag() & wxSYSTEM_MENU) == wxSYSTEM_MENU),
+        "bool");
+  }
+  else if (name == "thickFrame")
+  {
+    return new wxProperty(name, ((panelWindow->GetWindowStyleFlag() & wxTHICK_FRAME) == wxTHICK_FRAME),
+        "bool");
+  }
+  else if (name == "useSystemDefaults")
+  {
+    wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
+    return new wxProperty(name, ((resource->GetResourceStyle() & wxRESOURCE_USE_DEFAULTS) == wxRESOURCE_USE_DEFAULTS),
+        "bool");
+  }
+  else if (name == "useDialogUnits")
+  {
+    wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
+    return new wxProperty(name, ((resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS) == wxRESOURCE_DIALOG_UNITS),
+        "bool");
+  }
   else
     return wxWindowPropertyInfo::GetProperty(name);
 }
 
 bool wxPanelPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
   else
     return wxWindowPropertyInfo::GetProperty(name);
 }
 
 bool wxPanelPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
-  wxPanel *panelWindow = (wxPanel *)propertyWindow; 
+  wxPanel *panelWindow = (wxPanel *)m_propertyWindow; 
+/*
   wxFont *labelFont = panelWindow->GetLabelFont();
   wxFont *buttonFont = panelWindow->GetButtonFont();
   wxFont *labelFont = panelWindow->GetLabelFont();
   wxFont *buttonFont = panelWindow->GetButtonFont();
-  
+
   if (labelFont && (name == "labelFontPoints" || name == "labelFontFamily" || name == "labelFontStyle" || name == "labelFontWeight" || name == "labelFontUnderlined" ))
   {
     wxFont *newFont = SetFontProperty(name, property, labelFont);
     if (newFont)
   if (labelFont && (name == "labelFontPoints" || name == "labelFontFamily" || name == "labelFontStyle" || name == "labelFontWeight" || name == "labelFontUnderlined" ))
   {
     wxFont *newFont = SetFontProperty(name, property, labelFont);
     if (newFont)
-      panelWindow->SetLabelFont(newFont);
+      panelWindow->SetLabelFont(* newFont);
     return TRUE;
   }
   else if (buttonFont && (name == "buttonFontPoints" || name == "buttonFontFamily" || name == "buttonFontStyle" || name == "buttonFontWeight" || name == "buttonFontUnderlined" ))
   {
     wxFont *newFont = SetFontProperty(name, property, buttonFont);
     if (newFont)
     return TRUE;
   }
   else if (buttonFont && (name == "buttonFontPoints" || name == "buttonFontFamily" || name == "buttonFontStyle" || name == "buttonFontWeight" || name == "buttonFontUnderlined" ))
   {
     wxFont *newFont = SetFontProperty(name, property, buttonFont);
     if (newFont)
-      panelWindow->SetButtonFont(newFont);
+      panelWindow->SetButtonFont(* newFont);
     return TRUE;
   }
     return TRUE;
   }
-  else if (name == "no3D")
+*/
+
+  if (name == "no3D")
   {
     bool userColours = property->GetValue().BoolValue();
   {
     bool userColours = property->GetValue().BoolValue();
-    long flag = panelWindow->GetWindowStyleFlag();
     
     if (userColours)
     {
     
     if (userColours)
     {
@@ -1582,6 +2122,7 @@ bool wxPanelPropertyInfo::SetProperty(wxString& name, wxProperty *property)
     wxColour col(r,g,b);
     panelWindow->SetBackgroundColour(col);
     panelWindow = (wxPanel *)wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(panelWindow, this);
     wxColour col(r,g,b);
     panelWindow->SetBackgroundColour(col);
     panelWindow = (wxPanel *)wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(panelWindow, this);
+    m_propertyWindow = panelWindow;
    return TRUE;
   }
   else if (name == "title")
    return TRUE;
   }
   else if (name == "title")
@@ -1595,6 +2136,76 @@ bool wxPanelPropertyInfo::SetProperty(wxString& name, wxProperty *property)
     else
         return FALSE;
   }
     else
         return FALSE;
   }
+  else if (name == "caption")
+  {
+    SetWindowStyle(panelWindow, wxCAPTION, property->GetValue().BoolValue());
+
+    wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
+    resource->SetStyle(panelWindow->GetWindowStyleFlag());
+    return TRUE;
+  }
+  else if (name == "thickFrame")
+  {
+    SetWindowStyle(panelWindow, wxTHICK_FRAME, property->GetValue().BoolValue());
+
+    wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
+    resource->SetStyle(panelWindow->GetWindowStyleFlag());
+    return TRUE;
+  }
+  else if (name == "systemMenu")
+  {
+    SetWindowStyle(panelWindow, wxSYSTEM_MENU, property->GetValue().BoolValue());
+
+    wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
+    resource->SetStyle(panelWindow->GetWindowStyleFlag());
+    return TRUE;
+  }
+  else if (name == "useSystemDefaults")
+  {
+    wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
+    bool useDefaults = property->GetValue().BoolValue();
+    long style = resource->GetResourceStyle();
+    if (useDefaults)
+    {
+        if ((style & wxRESOURCE_USE_DEFAULTS) == 0)
+            style |= wxRESOURCE_USE_DEFAULTS;
+    }
+    else
+    {
+        if ((style & wxRESOURCE_USE_DEFAULTS) != 0)
+            style -= wxRESOURCE_USE_DEFAULTS;
+    }
+    resource->SetResourceStyle(style);
+    panelWindow = (wxPanel *)wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(panelWindow, this);
+    return TRUE;
+  }
+  else if (name == "useDialogUnits")
+  {
+    wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
+    bool useDialogUnits = property->GetValue().BoolValue();
+    long style = resource->GetResourceStyle();
+    if (useDialogUnits)
+    {
+        if ((style & wxRESOURCE_DIALOG_UNITS) == 0)
+        {
+            style |= wxRESOURCE_DIALOG_UNITS;
+            ConvertDialogUnits(TRUE); // Convert all resources
+        }
+    }
+    else
+    {
+        if ((style & wxRESOURCE_DIALOG_UNITS) != 0)
+        {
+            style -= wxRESOURCE_DIALOG_UNITS;
+            ConvertDialogUnits(FALSE); // Convert all resources
+        }
+    }
+    resource->SetResourceStyle(style);
+    panelWindow = (wxPanel *)wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(panelWindow, this);
+    m_propertyWindow = panelWindow;
+    // TODO: need to regenerate the width and height properties else they'll be inconsistent.
+    return TRUE;
+  }
   else
     return wxWindowPropertyInfo::SetProperty(name, property);
 }
   else
     return wxWindowPropertyInfo::SetProperty(name, property);
 }
@@ -1606,21 +2217,68 @@ void wxPanelPropertyInfo::GetPropertyNames(wxStringList& names)
   names.Add("title");
   names.Add("no3D");
   names.Add("backgroundColour");
   names.Add("title");
   names.Add("no3D");
   names.Add("backgroundColour");
+  names.Add("caption");
+  names.Add("systemMenu");
+  names.Add("thickFrame");
+  names.Add("useSystemDefaults");
+  names.Add("useDialogUnits");
 }
 
 bool wxPanelPropertyInfo::InstantiateResource(wxItemResource *resource)
 {
 }
 
 bool wxPanelPropertyInfo::InstantiateResource(wxItemResource *resource)
 {
-  wxPanel *panel = (wxPanel *)propertyWindow;
-  if (panel->GetFont())
-    resource->SetFont(wxTheFontList->FindOrCreateFont(panel->GetFont()->GetPointSize(),
-               panel->GetFont()->GetFamily(), panel->GetFont()->GetStyle(), panel->GetFont()->GetWeight(),
-               panel->GetFont()->GetUnderlined(), panel->GetFont()->GetFaceName()));
+  wxPanel *panel = (wxPanel *)m_propertyWindow;
+  if (panel->GetFont().Ok())
+    resource->SetFont(* wxTheFontList->FindOrCreateFont(panel->GetFont().GetPointSize(),
+               panel->GetFont().GetFamily(), panel->GetFont().GetStyle(), panel->GetFont().GetWeight(),
+               panel->GetFont().GetUnderlined(), panel->GetFont().GetFaceName()));
 
 
-  resource->SetBackgroundColour(new wxColour(panel->GetBackgroundColour()));
+  resource->SetBackgroundColour(wxColour(panel->GetBackgroundColour()));
 
   return wxWindowPropertyInfo::InstantiateResource(resource);
 }
 
 
   return wxWindowPropertyInfo::InstantiateResource(resource);
 }
 
+// Convert this dialog, and its children, to or from dialog units
+void wxPanelPropertyInfo::ConvertDialogUnits(bool toDialogUnits)
+{
+    wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
+
+    wxPoint pt;
+    wxSize sz;
+    if (toDialogUnits)
+    {
+        sz = m_propertyWindow->ConvertPixelsToDialog(wxSize(resource->GetWidth(), resource->GetHeight()));
+        pt = m_propertyWindow->ConvertPixelsToDialog(wxPoint(resource->GetX(), resource->GetY()));
+    }
+    else
+    {
+        sz = m_propertyWindow->ConvertDialogToPixels(wxSize(resource->GetWidth(), resource->GetHeight()));
+        pt = m_propertyWindow->ConvertDialogToPixels(wxPoint(resource->GetX(), resource->GetY()));
+    }
+    resource->SetSize(pt.x, pt.y, sz.x, sz.y);
+
+    wxNode* node = m_propertyWindow->GetChildren().First();
+    while (node)
+    {
+        wxWindow* child = (wxWindow*) node->Data();
+        if (child->IsKindOf(CLASSINFO(wxControl)))
+        {
+            resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(child);
+            if (toDialogUnits)
+            {
+                sz = m_propertyWindow->ConvertPixelsToDialog(wxSize(resource->GetWidth(), resource->GetHeight()));
+                pt = m_propertyWindow->ConvertPixelsToDialog(wxPoint(resource->GetX(), resource->GetY()));
+            }
+            else
+            {
+                sz = m_propertyWindow->ConvertDialogToPixels(wxSize(resource->GetWidth(), resource->GetHeight()));
+                pt = m_propertyWindow->ConvertDialogToPixels(wxPoint(resource->GetX(), resource->GetY()));
+            }
+            resource->SetSize(pt.x, pt.y, sz.x, sz.y);
+        }
+        node = node->Next();
+    }
+}
+
 #if 0
 /*
  * Dialog boxes
 #if 0
 /*
  * Dialog boxes
@@ -1628,7 +2286,7 @@ bool wxPanelPropertyInfo::InstantiateResource(wxItemResource *resource)
 
 wxProperty *wxDialogPropertyInfo::GetProperty(wxString& name)
 {
 
 wxProperty *wxDialogPropertyInfo::GetProperty(wxString& name)
 {
-  wxDialog *dialogWindow = (wxDialog *)propertyWindow; 
+  wxDialog *dialogWindow = (wxDialog *)m_propertyWindow; 
   if (name == "modal")
   {
     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(dialogWindow);
   if (name == "modal")
   {
     wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(dialogWindow);
@@ -1644,7 +2302,7 @@ wxProperty *wxDialogPropertyInfo::GetProperty(wxString& name)
 
 bool wxDialogPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
 
 bool wxDialogPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 {
-  wxDialog *dialogWindow = (wxDialog *)propertyWindow;
+  wxDialog *dialogWindow = (wxDialog *)m_propertyWindow;
 
   if (name == "modal")
   {
 
   if (name == "modal")
   {
@@ -1661,17 +2319,16 @@ bool wxDialogPropertyInfo::SetProperty(wxString& name, wxProperty *property)
 
 void wxDialogPropertyInfo::GetPropertyNames(wxStringList& names)
 {
 
 void wxDialogPropertyInfo::GetPropertyNames(wxStringList& names)
 {
+  wxPanelPropertyInfo::GetPropertyNames(names);
   names.Add("title");
   names.Add("modal");
   names.Add("title");
   names.Add("modal");
-
-  wxPanelPropertyInfo::GetPropertyNames(names);
 }
 
 bool wxDialogPropertyInfo::InstantiateResource(wxItemResource *resource)
 {
 }
 
 bool wxDialogPropertyInfo::InstantiateResource(wxItemResource *resource)
 {
-  wxDialog *dialog = (wxDialog *)propertyWindow;
+  wxDialog *dialog = (wxDialog *)m_propertyWindow;
   wxString str(dialog->GetTitle());
   wxString str(dialog->GetTitle());
-  resource->SetTitle(WXSTRINGCAST str);
+  resource->SetTitle(str);
     
   return wxPanelPropertyInfo::InstantiateResource(resource);
 }
     
   return wxPanelPropertyInfo::InstantiateResource(resource);
 }
@@ -1719,7 +2376,7 @@ wxResourceSymbolValidator::~wxResourceSymbolValidator(void)
 {
 }
 
 {
 }
 
-bool wxResourceSymbolValidator::OnCheckValue(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow)
+bool wxResourceSymbolValidator::OnCheckValue(wxProperty *WXUNUSED(property), wxPropertyListView *WXUNUSED(view), wxWindow *WXUNUSED(parentWindow))
 {
   return TRUE;
 }
 {
   return TRUE;
 }
@@ -1727,7 +2384,7 @@ bool wxResourceSymbolValidator::OnCheckValue(wxProperty *property, wxPropertyLis
 // Called when TICK is pressed or focus is lost or view wants to update
 // the property list.
 // Does the transferance from the property editing area to the property itself
 // Called when TICK is pressed or focus is lost or view wants to update
 // the property list.
 // Does the transferance from the property editing area to the property itself
-bool wxResourceSymbolValidator::OnRetrieveValue(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow)
+bool wxResourceSymbolValidator::OnRetrieveValue(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
 {
   if (!view->GetValueText())
     return FALSE;
 {
   if (!view->GetValueText())
     return FALSE;
@@ -1739,7 +2396,7 @@ bool wxResourceSymbolValidator::OnRetrieveValue(wxProperty *property, wxProperty
 // Called when TICK is pressed or focus is lost or view wants to update
 // the property list.
 // Does the transferance from the property editing area to the property itself
 // Called when TICK is pressed or focus is lost or view wants to update
 // the property list.
 // Does the transferance from the property editing area to the property itself
-bool wxResourceSymbolValidator::OnDisplayValue(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow)
+bool wxResourceSymbolValidator::OnDisplayValue(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
 {
   if (!view->GetValueText())
     return FALSE;
 {
   if (!view->GetValueText())
     return FALSE;
@@ -1758,7 +2415,7 @@ bool wxResourceSymbolValidator::OnDoubleClick(wxProperty *property, wxPropertyLi
   return TRUE;
 }
 
   return TRUE;
 }
 
-bool wxResourceSymbolValidator::OnPrepareControls(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow)
+bool wxResourceSymbolValidator::OnPrepareControls(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
 {
   if (view->GetConfirmButton())
     view->GetConfirmButton()->Enable(TRUE);
 {
   if (view->GetConfirmButton())
     view->GetConfirmButton()->Enable(TRUE);
@@ -1778,48 +2435,38 @@ void wxResourceSymbolValidator::OnEdit(wxProperty *property, wxPropertyListView
 
   wxResourceSymbolDialog* dialog = new wxResourceSymbolDialog(parentWindow, -1, "Edit Symbol");
 
 
   wxResourceSymbolDialog* dialog = new wxResourceSymbolDialog(parentWindow, -1, "Edit Symbol");
 
-  dialog->SetSymbol(property->GetValue().StringValue());
+  // Split name/id pair e.g. "IDC_TEXT=123"
+  wxString value(property->GetValue().StringValue());
 
 
-  // TODO: split name/id pair e.g. "IDC_TEXT=123" or get from symbol table - which?
-  dialog->SetId(1234);
+  wxString strName = value.Before('=');
+  wxString strId = value.After('=');
+
+  dialog->SetSymbol(strName);
+  dialog->SetId(atoi(strId));
 
   dialog->Init();
 
 
   dialog->Init();
 
-  if (dialog->ShowModal())
+  if (dialog->ShowModal() == wxID_OK)
   {
     wxString symbolName(dialog->GetSymbol());
     long id = dialog->GetId();
   {
     wxString symbolName(dialog->GetSymbol());
     long id = dialog->GetId();
-    dialog->Destroy();
 
 
-    // TODO: set id somewhere
-    property->GetValue() = wxString(symbolName);
+    wxString str;
+    str.Printf("%d", id);
+    property->GetValue() = symbolName + wxString("=") + str;
 
     view->DisplayProperty(property);
     view->UpdatePropertyDisplayInList(property);
     view->OnPropertyChanged(property);
   }
 
     view->DisplayProperty(property);
     view->UpdatePropertyDisplayInList(property);
     view->OnPropertyChanged(property);
   }
-
-#if 0
-  char *s = wxFileSelector(
-     filenameMessage.GetData(),
-     wxPathOnly(property->GetValue().StringValue()),
-     wxFileNameFromPath(property->GetValue().StringValue()),
-     NULL,
-     filenameWildCard.GetData(),
-     0,
-     parentWindow);
-  if (s)
-  {
-    property->GetValue() = wxString(s);
-    view->DisplayProperty(property);
-    view->UpdatePropertyDisplayInList(property);
-    view->OnPropertyChanged(property);
-  }
-#endif
+  // Moved from the 'if' branch on suggestion of Roman Pavlov
+  dialog->Destroy();
 }
 
 BEGIN_EVENT_TABLE(wxResourceSymbolDialog, wxDialog)
     EVT_BUTTON(wxID_OK, wxResourceSymbolDialog::OnOK)
 }
 
 BEGIN_EVENT_TABLE(wxResourceSymbolDialog, wxDialog)
     EVT_BUTTON(wxID_OK, wxResourceSymbolDialog::OnOK)
+    EVT_COMBOBOX(ID_SYMBOLNAME_COMBOBOX, wxResourceSymbolDialog::OnComboBoxSelect)
+    EVT_TEXT(ID_SYMBOLNAME_COMBOBOX, wxResourceSymbolDialog::OnSymbolNameUpdate)
 END_EVENT_TABLE()
 
 wxResourceSymbolDialog::wxResourceSymbolDialog(wxWindow* parent, const wxWindowID id, const wxString& title, const wxPoint& pos,
 END_EVENT_TABLE()
 
 wxResourceSymbolDialog::wxResourceSymbolDialog(wxWindow* parent, const wxWindowID id, const wxString& title, const wxPoint& pos,
@@ -1834,7 +2481,7 @@ wxResourceSymbolDialog::wxResourceSymbolDialog(wxWindow* parent, const wxWindowI
     x += 80;
 
     m_nameCtrl = new wxComboBox(this, ID_SYMBOLNAME_COMBOBOX, "",
     x += 80;
 
     m_nameCtrl = new wxComboBox(this, ID_SYMBOLNAME_COMBOBOX, "",
-        wxPoint(x, y), wxSize(200, -1), 0, NULL, wxCB_DROPDOWN);
+        wxPoint(x, y), wxSize(200, -1), 0, NULL, wxCB_DROPDOWN|wxCB_SORT);
 
     y += 30;
     x = 5;
 
     y += 30;
     x = 5;
@@ -1848,10 +2495,10 @@ wxResourceSymbolDialog::wxResourceSymbolDialog(wxWindow* parent, const wxWindowI
 
     y += 30;
     x = 5;
 
     y += 30;
     x = 5;
-    (void) new wxButton(this, wxID_OK, "OK", wxPoint(x, y), wxSize(90, -1));
+    (void) new wxButton(this, wxID_OK, "OK", wxPoint(x, y), wxSize(80, -1));
 
 
-    x += 120;
-    (void) new wxButton(this, wxID_CANCEL, "Cancel", wxPoint(x, y), wxSize(90, -1));
+    x += 100;
+    (void) new wxButton(this, wxID_CANCEL, "Cancel", wxPoint(x, y), wxSize(80, -1));
 
     Fit();
     Centre();
 
     Fit();
     Centre();
@@ -1864,6 +2511,8 @@ void wxResourceSymbolDialog::Init()
 
     m_nameCtrl->SetValue(m_symbolName);
     m_idCtrl->SetValue(defaultId);
 
     m_nameCtrl->SetValue(m_symbolName);
     m_idCtrl->SetValue(defaultId);
+
+    wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().FillComboBox(m_nameCtrl);
 }
 
 void wxResourceSymbolDialog::OnOK(wxCommandEvent& event)
 }
 
 void wxResourceSymbolDialog::OnOK(wxCommandEvent& event)
@@ -1876,6 +2525,124 @@ void wxResourceSymbolDialog::OnOK(wxCommandEvent& event)
 
 bool wxResourceSymbolDialog::CheckValues()
 {
 
 bool wxResourceSymbolDialog::CheckValues()
 {
+    wxString nameStr(m_nameCtrl->GetValue());
+    wxString idStr(m_idCtrl->GetValue());
+    int id = atoi(idStr);
+
+    if (id <= 0 )
+    {
+        wxMessageBox("Identifier cannot be missing or zero", "Dialog Editor", wxOK|wxICON_EXCLAMATION, this);
+        return FALSE;
+    }
+    if (nameStr == "")
+    {
+        wxMessageBox("Please enter a symbol name", "Dialog Editor", wxOK|wxICON_EXCLAMATION, this);
+        return FALSE;
+    }
+    if (nameStr.Contains(" "))
+    {
+        wxMessageBox("Symbol name cannot contain spaces.", "Dialog Editor", wxOK|wxICON_EXCLAMATION, this);
+        return FALSE;
+    }
+    if (nameStr.Contains("="))
+    {
+        wxMessageBox("Symbol name cannot contain =.", "Dialog Editor", wxOK|wxICON_EXCLAMATION, this);
+        return FALSE;
+    }
+    if (nameStr.IsNumber())
+    {
+        wxMessageBox("Symbol name cannot be a number.", "Dialog Editor", wxOK|wxICON_EXCLAMATION, this);
+        return FALSE;
+    }
+    // TODO: other checks on the name syntax.
+
+    if (!wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().IsStandardSymbol(nameStr))
+    {
+        // If we change the id for an existing symbol, we need to:
+        // 1) Check if there are any other resources currently using the original id.
+        //    If so, will need to change their id to the new id, in SetProperty.
+        // 2) Remove the old symbol, add the new symbol.
+        // In this check, we don't have to do this, but we need to do it in SetProperty.
+
+        if (nameStr == GetSymbol() && id != GetId())
+        {
+            // It's OK to change the id. But we'll need to change all matching ids in all resources,
+            // in SetProperty.
+        }
+
+        // If we change the name but not the id... we'll just need to remove and
+        // re-add the symbol/id pair, in SetProperty.
+        if (nameStr != GetSymbol() && id == GetId())
+        {
+        }
+
+        // What if we're changing both the name and the id?
+        // - if there's no symbol of that name, just remove the old, add the new (in SetProperty)
+        // - if there is a symbol of that name, if id matches, do nothing. If not, veto.
+
+        if (nameStr != GetSymbol() && id != GetId())
+        {
+            if (!wxResourceManager::GetCurrentResourceManager()->IsIdentifierOK(nameStr, id))
+            {
+                wxMessageBox("This integer id is already being used under a different name.\nPlease choose another.",
+                    "Dialog Editor", wxOK|wxICON_EXCLAMATION, this);
+                return FALSE;
+            }
+        }
+
+    }
+
+    SetSymbol(nameStr);
+    SetId(id);
+
     return TRUE;
 }
 
     return TRUE;
 }
 
+void wxResourceSymbolDialog::OnComboBoxSelect(wxCommandEvent& WXUNUSED(event))
+{
+    wxString str(m_nameCtrl->GetStringSelection());
+    if (wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().IsStandardSymbol(str))
+    {
+        int id = wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().GetIdForSymbol(str);
+        wxString str2;
+        str2.Printf("%d", id);
+        m_idCtrl->SetValue(str2);
+        m_idCtrl->Enable(FALSE);
+    }
+    else
+    {
+        if (wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().SymbolExists(str))
+        {
+            int id = wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().GetIdForSymbol(str);
+            wxString str2;
+            str2.Printf("%d", id);
+            m_idCtrl->SetValue(str2);
+        }
+        m_idCtrl->Enable(TRUE);
+    }
+}
+
+void wxResourceSymbolDialog::OnSymbolNameUpdate(wxCommandEvent& WXUNUSED(event))
+{
+    wxString str(m_nameCtrl->GetValue());
+    if (wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().IsStandardSymbol(str))
+    {
+        int id = wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().GetIdForSymbol(str);
+        wxString str2;
+        str2.Printf("%d", id);
+        m_idCtrl->SetValue(str2);
+        m_idCtrl->Enable(FALSE);
+    }
+    else
+    {
+        if (wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().SymbolExists(str))
+        {
+            int id = wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().GetIdForSymbol(str);
+            wxString str2;
+            str2.Printf("%d", id);
+            m_idCtrl->SetValue(str2);
+        }
+        m_idCtrl->Enable(TRUE);
+    }
+}
+
wxWidgets (Impactor)