X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/457814b5aa2ee5c83abc65a6aee2a3ebcb1af34f..2224580a415da12d7c453943c4ae4a1b58ecd369:/utils/dialoged/src/reseditr.cpp

diff --git a/utils/dialoged/src/reseditr.cpp b/utils/dialoged/src/reseditr.cpp
index 1aa9fea3ea..14166498d4 100644
--- a/utils/dialoged/src/reseditr.cpp
+++ b/utils/dialoged/src/reseditr.cpp
@@ -32,246 +32,303 @@
 #include "wx/gauge.h"
 #include "wx/slider.h"
 #include "wx/textctrl.h"
+#include "wx/menu.h"
+#include "wx/toolbar.h"
 #endif
 
 #include "wx/scrolbar.h"
+#include "wx/config.h"
 
 #include <ctype.h>
 #include <stdlib.h>
 #include <math.h>
 #include <string.h>
 
-#if defined(__WINDOWS__) && !defined(__GNUWIN32__)
-#include <strstrea.h>
-#else
-#include <strstream.h>
-#endif
-
-#ifdef __WINDOWS__
-#include <windows.h>
-#endif
-
+#ifdef __WXMSW__
 #include "wx/help.h"
+#endif
 
 #include "reseditr.h"
 #include "winprop.h"
-#include "editrpal.h"
 #include "dlghndlr.h"
-
-static void ObjectMenuProc(wxMenu& menu, wxCommandEvent& event);
-void wxResourceEditWindow(wxWindow *win);
-wxWindowPropertyInfo *wxCreatePropertyInfoForWindow(wxWindow *win);
-wxResourceManager *wxResourceManager::currentResourceManager = NULL;
-
-// Bitmaps for toolbar
-wxBitmap *ToolbarLoadBitmap = NULL;
-wxBitmap *ToolbarSaveBitmap = NULL;
-wxBitmap *ToolbarNewBitmap = NULL;
-wxBitmap *ToolbarVertBitmap = NULL;
-wxBitmap *ToolbarAlignTBitmap = NULL;
-wxBitmap *ToolbarAlignBBitmap = NULL;
-wxBitmap *ToolbarHorizBitmap = NULL;
-wxBitmap *ToolbarAlignLBitmap = NULL;
-wxBitmap *ToolbarAlignRBitmap = NULL;
-wxBitmap *ToolbarCopySizeBitmap = NULL;
-wxBitmap *ToolbarToFrontBitmap = NULL;
-wxBitmap *ToolbarToBackBitmap = NULL;
-wxBitmap *ToolbarHelpBitmap = NULL;
-
-wxBitmap *wxWinBitmap = NULL;
-
-#ifdef __X__
-#include "bitmaps/load.xbm"
-#include "bitmaps/save.xbm"
-#include "bitmaps/new.xbm"
-#include "bitmaps/vert.xbm"
-#include "bitmaps/alignt.xbm"
-#include "bitmaps/alignb.xbm"
-#include "bitmaps/horiz.xbm"
-#include "bitmaps/alignl.xbm"
-#include "bitmaps/alignr.xbm"
-#include "bitmaps/copysize.xbm"
-#include "bitmaps/tofront.xbm"
-#include "bitmaps/toback.xbm"
-#include "bitmaps/help.xbm"
-#include "bitmaps/wxwin.xbm"
+#include "edtree.h"
+#include "edlist.h"
+
+wxResourceManager *wxResourceManager::sm_currentResourceManager = NULL;
+
+#if defined(__WXGTK__) || defined(__WXMOTIF__)
+#include "bitmaps/load.xpm"
+#include "bitmaps/save.xpm"
+#include "bitmaps/new.xpm"
+#include "bitmaps/vert.xpm"
+#include "bitmaps/alignt.xpm"
+#include "bitmaps/alignb.xpm"
+#include "bitmaps/horiz.xpm"
+#include "bitmaps/alignl.xpm"
+#include "bitmaps/alignr.xpm"
+#include "bitmaps/copysize.xpm"
+#include "bitmaps/tofront.xpm"
+#include "bitmaps/toback.xpm"
+#include "bitmaps/help.xpm"
+#include "bitmaps/wxwin.xpm"
+
+#include "bitmaps/dialog.xpm"
+#include "bitmaps/folder1.xpm"
+#include "bitmaps/folder2.xpm"
+#include "bitmaps/buttonsm.xpm"
 #endif
 
 /*
  * Resource manager
  */
 
+wxResourceManager::wxResourceManager():
+  m_imageList(16, 16, TRUE)
+{
+  sm_currentResourceManager = this;
+  m_editorFrame = NULL;
+  m_editorPanel = NULL;
+  m_popupMenu = NULL;
+  m_editorResourceTree = NULL;
+  m_editorControlList = NULL;
+  m_nameCounter = 1;
+  m_symbolIdCounter = 99;
+  m_modified = FALSE;
+  m_currentFilename = "";
+  m_symbolFilename = "";
+  m_editorToolBar = NULL;
 
-wxResourceManager::wxResourceManager(void)
-{
-  currentResourceManager = this;
-  editorFrame = NULL;
-  editorPanel = NULL;
-  popupMenu = NULL;
-  editorResourceList = NULL;
-  editorPalette = NULL;
-  nameCounter = 1;
-  modified = FALSE;
-  currentFilename = "";
-  editMode = TRUE;
-  editorToolBar = NULL;
-  
   // Default window positions
-  resourceEditorWindowSize.width = 470;
-  resourceEditorWindowSize.height = 300;
+  m_resourceEditorWindowSize.width = 500;
+  m_resourceEditorWindowSize.height = 450;
 
-  resourceEditorWindowSize.x = 0;
-  resourceEditorWindowSize.y = 0;
-  
-  propertyWindowSize.width = 300;
-  propertyWindowSize.height = 300;
+  m_resourceEditorWindowSize.x = 0;
+  m_resourceEditorWindowSize.y = 0;
+
+  m_propertyWindowSize.width = 300;
+  m_propertyWindowSize.height = 300;
+
+#ifdef __WXMSW__
+  m_helpController = NULL;
+#endif
 
-  helpInstance = NULL;
+  m_bitmapImage = NULL;
+  m_rootDialogItem = 0;
 }
 
-wxResourceManager::~wxResourceManager(void)
+wxResourceManager::~wxResourceManager()
 {
-  currentResourceManager = NULL;
+  sm_currentResourceManager = NULL;
   SaveOptions();
 
-  helpInstance->Quit();
-  delete helpInstance;
-  helpInstance = NULL;
+#ifdef __WXMSW__
+  if (m_helpController)
+  {
+    m_helpController->Quit();
+    delete m_helpController;
+    m_helpController = NULL;
+  }
+#endif  
+  
+  delete m_bitmapImage;
+  delete m_popupMenu;
 }
 
-bool wxResourceManager::Initialize(void)
+bool wxResourceManager::Initialize()
 {
   // Set up the resource filename for each platform.
-#ifdef __WINDOWS__
+  // TODO: This shold be replaced by wxConfig usage.
+#ifdef __WXMSW__
   // dialoged.ini in the Windows directory
-  char buf[256];
-  GetWindowsDirectory(buf, 256);
-  strcat(buf, "\\dialoged.ini");
-  optionsResourceFilename = buf;
-#elif defined(__X__)
-  char buf[500];
-  (void)wxGetHomeDir(buf);
-  strcat(buf, "/.hardyrc");
-  optionsResourceFilename = buf;
+  wxString windowsDir = wxGetOSDirectory();
+  windowsDir += "\\dialoged.ini" ;
+
+  m_optionsResourceFilename = windowsDir;
+#elif defined(__WXGTK__) || defined(__WXMOTIF__)
+  wxGetHomeDir( &m_optionsResourceFilename );
+  m_optionsResourceFilename += "/.dialogedrc";
 #else
 #error "Unsupported platform."
 #endif
 
   LoadOptions();
 
-  helpInstance = new wxHelpController;
-  helpInstance->Initialize("dialoged");
+#ifdef __WXMSW__
+  m_helpController = new wxHelpController;
+  m_helpController->Initialize("dialoged");
+#endif
 
-  InitializeTools();
-  popupMenu = new wxMenu("", (wxFunction)ObjectMenuProc);
-  popupMenu->Append(OBJECT_MENU_EDIT, "Edit properties");
-  popupMenu->Append(OBJECT_MENU_DELETE, "Delete object");
-  
-  if (!wxWinBitmap)
+  m_popupMenu = new wxMenu;
+  m_popupMenu->Append(OBJECT_MENU_EDIT, "Edit properties");
+  m_popupMenu->Append(OBJECT_MENU_DELETE, "Delete object");
+
+  if (!m_bitmapImage)
   {
-#ifdef __WINDOWS__
-    wxWinBitmap = new wxBitmap("WXWINBMP", wxBITMAP_TYPE_BMP_RESOURCE);
+#ifdef __WXMSW__
+    m_bitmapImage = new wxBitmap("WXWINBMP", wxBITMAP_TYPE_BMP_RESOURCE);
 #endif
-#ifdef __X__
-    wxWinBitmap = new wxBitmap(wxwin_bits, wxwin_width, wxwin_height);
+#if defined(__WXGTK__) || defined(__WXMOTIF__)
+    m_bitmapImage = new wxBitmap( wxwin_xpm );
 #endif
   }
+
+  // Initialize the image list icons
+#ifdef __WXMSW__
+  wxIcon icon1("DIALOG_ICON", wxBITMAP_TYPE_ICO_RESOURCE, 16, 16);
+  wxIcon icon2("FOLDER1_ICON", wxBITMAP_TYPE_ICO_RESOURCE, 16, 16);
+  wxIcon icon3("FOLDER2_ICON", wxBITMAP_TYPE_ICO_RESOURCE, 16, 16);
+  wxIcon icon4("BUTTONSM_ICON", wxBITMAP_TYPE_ICO_RESOURCE, 16, 16);
+#else
+  wxIcon icon1( dialog_xpm );    
+  wxIcon icon2( folder1_xpm );    
+  wxIcon icon3( folder2_xpm );    
+  wxIcon icon4( buttonsm_xpm );    
+#endif
+  m_imageList.Add(icon1);
+  m_imageList.Add(icon2);
+  m_imageList.Add(icon3);
+  m_imageList.Add(icon4);
+
+  m_symbolTable.AddStandardSymbols();
+
   return TRUE;
 }
 
-bool wxResourceManager::LoadOptions(void)
-{
-  wxGetResource("DialogEd", "editorWindowX", &resourceEditorWindowSize.x, optionsResourceFilename.GetData());
-  wxGetResource("DialogEd", "editorWindowY", &resourceEditorWindowSize.y, optionsResourceFilename.GetData());
-  wxGetResource("DialogEd", "editorWindowWidth", &resourceEditorWindowSize.width, optionsResourceFilename.GetData());
-  wxGetResource("DialogEd", "editorWindowHeight", &resourceEditorWindowSize.height, optionsResourceFilename.GetData());
-  wxGetResource("DialogEd", "propertyWindowX", &propertyWindowSize.x, optionsResourceFilename.GetData());
-  wxGetResource("DialogEd", "propertyWindowY", &propertyWindowSize.y, optionsResourceFilename.GetData());
-  wxGetResource("DialogEd", "propertyWindowWidth", &propertyWindowSize.width, optionsResourceFilename.GetData());
-  wxGetResource("DialogEd", "propertyWindowHeight", &propertyWindowSize.height, optionsResourceFilename.GetData());
+bool wxResourceManager::LoadOptions()
+{
+  wxConfig config("DialogEd", "wxWindows");
+
+  config.Read("editorWindowX", &m_resourceEditorWindowSize.x);
+  config.Read("editorWindowY", &m_resourceEditorWindowSize.y);
+  config.Read("editorWindowWidth", &m_resourceEditorWindowSize.width);
+  config.Read("editorWindowHeight", &m_resourceEditorWindowSize.height);
+  config.Read("propertyWindowX", &m_propertyWindowSize.x);
+  config.Read("propertyWindowY", &m_propertyWindowSize.y);
+  config.Read("propertyWindowWidth", &m_propertyWindowSize.width);
+  config.Read("propertyWindowHeight", &m_propertyWindowSize.height);
+
+  /*
+  wxGetResource("DialogEd", "editorWindowX", &m_resourceEditorWindowSize.x, m_optionsResourceFilename.GetData());
+  wxGetResource("DialogEd", "editorWindowY", &m_resourceEditorWindowSize.y, m_optionsResourceFilename.GetData());
+  wxGetResource("DialogEd", "editorWindowWidth", &m_resourceEditorWindowSize.width, m_optionsResourceFilename.GetData());
+  wxGetResource("DialogEd", "editorWindowHeight", &m_resourceEditorWindowSize.height, m_optionsResourceFilename.GetData());
+  wxGetResource("DialogEd", "propertyWindowX", &m_propertyWindowSize.x, m_optionsResourceFilename.GetData());
+  wxGetResource("DialogEd", "propertyWindowY", &m_propertyWindowSize.y, m_optionsResourceFilename.GetData());
+  wxGetResource("DialogEd", "propertyWindowWidth", &m_propertyWindowSize.width, m_optionsResourceFilename.GetData());
+  wxGetResource("DialogEd", "propertyWindowHeight", &m_propertyWindowSize.height, m_optionsResourceFilename.GetData());
+  */
   return TRUE;
 }
 
-bool wxResourceManager::SaveOptions(void)
+bool wxResourceManager::SaveOptions()
 {
-  wxWriteResource("DialogEd", "editorWindowX", resourceEditorWindowSize.x, optionsResourceFilename.GetData());
-  wxWriteResource("DialogEd", "editorWindowY", resourceEditorWindowSize.y, optionsResourceFilename.GetData());
-  wxWriteResource("DialogEd", "editorWindowWidth", resourceEditorWindowSize.width, optionsResourceFilename.GetData());
-  wxWriteResource("DialogEd", "editorWindowHeight", resourceEditorWindowSize.height, optionsResourceFilename.GetData());
+  wxConfig config("DialogEd", "wxWindows");
+
+  config.Write("editorWindowX", (long) m_resourceEditorWindowSize.x);
+  config.Write("editorWindowY", (long) m_resourceEditorWindowSize.y);
+  config.Write("editorWindowWidth", (long) m_resourceEditorWindowSize.width);
+  config.Write("editorWindowHeight", (long) m_resourceEditorWindowSize.height);
+  config.Write("propertyWindowX", (long) m_propertyWindowSize.x);
+  config.Write("propertyWindowY", (long) m_propertyWindowSize.y);
+  config.Write("propertyWindowWidth", (long) m_propertyWindowSize.width);
+  config.Write("propertyWindowHeight", (long) m_propertyWindowSize.height);
+  /*
+  wxWriteResource("DialogEd", "editorWindowX", m_resourceEditorWindowSize.x, m_optionsResourceFilename.GetData());
+  wxWriteResource("DialogEd", "editorWindowY", m_resourceEditorWindowSize.y, m_optionsResourceFilename.GetData());
+  wxWriteResource("DialogEd", "editorWindowWidth", m_resourceEditorWindowSize.width, m_optionsResourceFilename.GetData());
+  wxWriteResource("DialogEd", "editorWindowHeight", m_resourceEditorWindowSize.height, m_optionsResourceFilename.GetData());
+
+  wxWriteResource("DialogEd", "propertyWindowX", m_propertyWindowSize.x, m_optionsResourceFilename.GetData());
+  wxWriteResource("DialogEd", "propertyWindowY", m_propertyWindowSize.y, m_optionsResourceFilename.GetData());
+  wxWriteResource("DialogEd", "propertyWindowWidth", m_propertyWindowSize.width, m_optionsResourceFilename.GetData());
+  wxWriteResource("DialogEd", "propertyWindowHeight", m_propertyWindowSize.height, m_optionsResourceFilename.GetData());
+  */
 
-  wxWriteResource("DialogEd", "propertyWindowX", propertyWindowSize.x, optionsResourceFilename.GetData());
-  wxWriteResource("DialogEd", "propertyWindowY", propertyWindowSize.y, optionsResourceFilename.GetData());
-  wxWriteResource("DialogEd", "propertyWindowWidth", propertyWindowSize.width, optionsResourceFilename.GetData());
-  wxWriteResource("DialogEd", "propertyWindowHeight", propertyWindowSize.height, optionsResourceFilename.GetData());
-  
   return TRUE;
 }
 
 // Show or hide the resource editor frame, which displays a list
 // of resources with ability to edit them.
-bool wxResourceManager::ShowResourceEditor(bool show, wxWindow *parent, const char *title)
+bool wxResourceManager::ShowResourceEditor(bool show, wxWindow *WXUNUSED(parent), const char *title)
 {
   if (show)
   {
-    if (editorFrame)
+    if (m_editorFrame)
     {
-      editorFrame->Iconize(FALSE);
-      editorFrame->Show(TRUE);
+      m_editorFrame->Iconize(FALSE);
+      m_editorFrame->Show(TRUE);
       return TRUE;
     }
-    editorFrame = OnCreateEditorFrame(title);
+    m_editorFrame = OnCreateEditorFrame(title);
     SetFrameTitle("");
-    wxMenuBar *menuBar = OnCreateEditorMenuBar(editorFrame);
-    editorFrame->SetMenuBar(menuBar);
-    editorPanel = OnCreateEditorPanel(editorFrame);
-    editorToolBar = (EditorToolBar *)OnCreateToolBar(editorFrame);
-    editorPalette = OnCreatePalette(editorFrame);
+    wxMenuBar *menuBar = OnCreateEditorMenuBar(m_editorFrame);
+    m_editorFrame->SetMenuBar(menuBar);
+
+    m_editorToolBar = (EditorToolBar *)OnCreateToolBar(m_editorFrame);
+    m_editorControlList = new wxResourceEditorControlList(m_editorFrame, IDC_LISTCTRL, wxPoint(0, 0), wxSize(-1, -1));
+    m_editorResourceTree = new wxResourceEditorProjectTree(m_editorFrame, IDC_TREECTRL, wxPoint(0, 0), wxSize(-1, -1),
+      wxTR_HAS_BUTTONS);
+    m_editorPanel = OnCreateEditorPanel(m_editorFrame);
+
+    m_editorResourceTree->SetImageList(& m_imageList);
 
     // Constraints for toolbar
     wxLayoutConstraints *c = new wxLayoutConstraints;
-    c->left.SameAs       (editorFrame, wxLeft, 0);
-    c->top.SameAs        (editorFrame, wxTop, 0);
-    c->right.SameAs      (editorFrame, wxRight, 0);
-    c->bottom.Unconstrained();    
+    c->left.SameAs       (m_editorFrame, wxLeft, 0);
+    c->top.SameAs        (m_editorFrame, wxTop, 0);
+    c->right.SameAs      (m_editorFrame, wxRight, 0);
+    c->bottom.Unconstrained();
     c->width.Unconstrained();
     c->height.Absolute(28);
-    editorToolBar->SetConstraints(c);
+    m_editorToolBar->SetConstraints(c);
 
-    // Constraints for palette
+    // Constraints for listbox
     c = new wxLayoutConstraints;
-    c->left.SameAs       (editorFrame, wxLeft, 0);
-    c->top.SameAs        (editorToolBar, wxBottom, 0);
-    c->right.SameAs      (editorFrame, wxRight, 0);
-    c->bottom.Unconstrained();    
+    c->left.SameAs       (m_editorFrame, wxLeft, 0);
+    c->top.SameAs        (m_editorToolBar, wxBottom, 0);
+    c->right.Absolute    (150);
+    c->bottom.SameAs     (m_editorControlList, wxTop, 0);
     c->width.Unconstrained();
-    c->height.Absolute(34);
-    editorPalette->SetConstraints(c);
+    c->height.Unconstrained();
+    m_editorResourceTree->SetConstraints(c);
 
     // Constraints for panel
     c = new wxLayoutConstraints;
-    c->left.SameAs       (editorFrame, wxLeft, 0);
-    c->top.SameAs        (editorPalette, wxBottom, 0);
-    c->right.SameAs      (editorFrame, wxRight, 0);
-    c->bottom.SameAs     (editorFrame, wxBottom, 0);    
+    c->left.SameAs       (m_editorResourceTree, wxRight, 0);
+    c->top.SameAs        (m_editorToolBar, wxBottom, 0);
+    c->right.SameAs      (m_editorFrame, wxRight, 0);
+    c->bottom.SameAs     (m_editorControlList, wxTop, 0);
     c->width.Unconstrained();
     c->height.Unconstrained();
-    editorPanel->SetConstraints(c);
+    m_editorPanel->SetConstraints(c);
+
+    // Constraints for control list (bottom window)
+    c = new wxLayoutConstraints;
+    c->left.SameAs       (m_editorFrame, wxLeft, 0);
+    c->right.SameAs      (m_editorFrame, wxRight, 0);
+    c->bottom.SameAs     (m_editorFrame, wxBottom, 0);
+    c->width.Unconstrained();
+#if defined(__WXGTK__) || defined(__WXMOTIF__)
+    c->height.Absolute(120);
+#else
+    c->height.Absolute(60);
+#endif
 
-    editorFrame->SetAutoLayout(TRUE);
+    m_editorControlList->SetConstraints(c);
+
+    m_editorFrame->SetAutoLayout(TRUE);
 
     UpdateResourceList();
-    editorFrame->Show(TRUE);
+
+    m_editorFrame->Show(TRUE);
     return TRUE;
   }
   else
   {
-    wxFrame *fr = editorFrame;
-    if (editorFrame->OnClose())
+    if (m_editorFrame->Close())
     {
-      fr->Show(FALSE);
-      delete fr;
-      editorFrame = NULL;
-      editorPanel = NULL;
+      m_editorFrame = NULL;
+      m_editorPanel = NULL;
     }
   }
   return TRUE;
@@ -279,36 +336,37 @@ bool wxResourceManager::ShowResourceEditor(bool show, wxWindow *parent, const ch
 
 void wxResourceManager::SetFrameTitle(const wxString& filename)
 {
-  if (editorFrame)
+  if (m_editorFrame)
   {
     if (filename == wxString(""))
-      editorFrame->SetTitle("wxWindows Dialog Editor - untitled");
+      m_editorFrame->SetTitle("wxWindows Dialog Editor - untitled");
     else
     {
       wxString str("wxWindows Dialog Editor - ");
       wxString str2(wxFileNameFromPath(WXSTRINGCAST filename));
       str += str2;
-      editorFrame->SetTitle(str);
+      m_editorFrame->SetTitle(str);
     }
   }
 }
 
-bool wxResourceManager::Save(void)
+bool wxResourceManager::Save()
 {
-  if (currentFilename == wxString(""))
+  if (m_currentFilename == wxString(""))
     return SaveAs();
   else
-    return Save(currentFilename);
+    return Save(m_currentFilename);
 }
 
 bool wxResourceManager::Save(const wxString& filename)
 {
   // Ensure all visible windows are saved to their resources
-  currentFilename = filename;
-  SetFrameTitle(currentFilename);
+  m_currentFilename = filename;
+  SetFrameTitle(m_currentFilename);
   InstantiateAllResourcesFromWindows();
-  if (resourceTable.Save(filename))
+  if (m_resourceTable.Save(filename))
   {
+    m_symbolTable.WriteIncludeFile(m_symbolFilename);
     Modify(FALSE);
     return TRUE;
   }
@@ -316,20 +374,29 @@ bool wxResourceManager::Save(const wxString& filename)
     return FALSE;
 }
 
-bool wxResourceManager::SaveAs(void)
+bool wxResourceManager::SaveAs()
 {
-  wxString s(wxFileSelector("Save resource file", wxPathOnly(WXSTRINGCAST currentFilename), wxFileNameFromPath(WXSTRINGCAST currentFilename),
-    "wxr", "*.wxr", wxSAVE | wxOVERWRITE_PROMPT));
+  wxString s(wxFileSelector("Save resource file", wxPathOnly(WXSTRINGCAST m_currentFilename), wxFileNameFromPath(WXSTRINGCAST m_currentFilename),
+    "wxr", "*.wxr", wxSAVE | wxOVERWRITE_PROMPT, wxTheApp->GetTopWindow()));
     
   if (s.IsNull() || s == "")
     return FALSE;
     
-  currentFilename = s;
-  Save(currentFilename);
+  m_currentFilename = s;
+  wxStripExtension(m_currentFilename);
+  m_currentFilename += ".wxr";
+
+  // Construct include filename from this file
+  m_symbolFilename = m_currentFilename;
+
+  wxStripExtension(m_symbolFilename);
+  m_symbolFilename += ".h";
+
+  Save(m_currentFilename);
   return TRUE;
 }
 
-bool wxResourceManager::SaveIfModified(void)
+bool wxResourceManager::SaveIfModified()
 {
   if (Modified())
     return Save();
@@ -346,41 +413,81 @@ bool wxResourceManager::New(bool loadFromFile, const wxString& filename)
   if (!Clear(TRUE, FALSE))
     return FALSE;
     
+  m_symbolTable.AddStandardSymbols();
+
   if (loadFromFile)
   {
     wxString str = filename;
     if (str == wxString(""))
     {
-      wxString f(wxFileSelector("Open resource file", NULL, NULL, "wxr", "*.wxr", 0, NULL));
+      wxString f(wxFileSelector("Open resource file", NULL, NULL, "wxr", "*.wxr", 0, wxTheApp->GetTopWindow()));
       if (!f.IsNull() && f != "")
         str = f;
       else
         return FALSE;
     }
     
-    if (!resourceTable.ParseResourceFile(WXSTRINGCAST str))
+    if (!m_resourceTable.ParseResourceFile(str))
     {
       wxMessageBox("Could not read file.", "Resource file load error", wxOK | wxICON_EXCLAMATION);
       return FALSE;
     }
-    currentFilename = str;
-    
-    SetFrameTitle(currentFilename);
-    
+    m_currentFilename = str;
+
+    SetFrameTitle(m_currentFilename);
+
     UpdateResourceList();
+
+    // Construct include filename from this file
+    m_symbolFilename = m_currentFilename;
+
+    wxStripExtension(m_symbolFilename);
+    m_symbolFilename += ".h";
+
+    if (!m_symbolTable.ReadIncludeFile(m_symbolFilename))
+    {
+        wxString str("Could not find include file ");
+        str += m_symbolFilename;
+        str += ".\nDialog Editor maintains a header file containing id symbols to be used in the application.\n";
+        str += "The next time this .wxr file is saved, a header file will be saved also.";
+        wxMessageBox(str, "Dialog Editor Warning", wxOK );
+
+        m_symbolIdCounter = 99;
+    }
+    else
+    {
+        // Set the id counter to the last known id
+        m_symbolIdCounter = m_symbolTable.FindHighestId();
+    }
+
+    // Now check in case some (or all) resources don't have resource ids, or they
+    // don't match the .h file, or something of that nature.
+    bool altered = RepairResourceIds();
+    if (altered)
+    {
+        wxMessageBox("Some resources have had new identifiers associated with them, since they were missing.", 
+	             "Dialog Editor Warning", wxOK );
+        Modify(TRUE);
+    }
+    else
+        Modify(FALSE);
+
+    return TRUE;
   }
   else
   {
     SetFrameTitle("");
-    currentFilename = "";
+    m_currentFilename = "";
   }
   Modify(FALSE);
   
   return TRUE;
 }
 
-bool wxResourceManager::Clear(bool deleteWindows, bool force)
+bool wxResourceManager::Clear(bool WXUNUSED(deleteWindows), bool force)
 {
+  wxPropertyInfo::CloseWindow();
+
   if (!force && Modified())
   {
     int ans = wxMessageBox("Save modified resource file?", "Dialog Editor", wxYES_NO | wxCANCEL);
@@ -393,22 +500,24 @@ bool wxResourceManager::Clear(bool deleteWindows, bool force)
         Modify(FALSE);
   }
   
-  DisassociateWindows(deleteWindows);
+  ClearCurrentDialog();
+  DisassociateWindows();
 
-  resourceTable.ClearTable();
+  m_symbolTable.Clear();
+  m_resourceTable.ClearTable();
   UpdateResourceList();
 
   return TRUE;
 }
 
-bool wxResourceManager::DisassociateWindows(bool deleteWindows)
+bool wxResourceManager::DisassociateWindows()
 {
-  resourceTable.BeginFind();
+  m_resourceTable.BeginFind();
   wxNode *node;
-  while (node = resourceTable.Next())
+  while ((node = m_resourceTable.Next()))
   {
     wxItemResource *res = (wxItemResource *)node->Data();
-    DisassociateResource(res, deleteWindows);
+    DisassociateResource(res);
   }
   
   return TRUE;
@@ -416,90 +525,153 @@ bool wxResourceManager::DisassociateWindows(bool deleteWindows)
 
 void wxResourceManager::AssociateResource(wxItemResource *resource, wxWindow *win)
 {
-  if (!resourceAssociations.Get((long)resource))
-    resourceAssociations.Put((long)resource, win);
-    
+  if (!m_resourceAssociations.Get((long)resource))
+    m_resourceAssociations.Put((long)resource, win);
+
   wxNode *node = resource->GetChildren().First();
-  while (node)
+  wxNode* node2 = win->GetChildren().First();
+  while (node && node2)
   {
     wxItemResource *child = (wxItemResource *)node->Data();
-    wxWindow *childWindow = (wxWindow *)resourceAssociations.Get((long)child);
+    wxWindow* childWindow = (wxWindow*) node2->Data();
+
+    if (child->GetId() != childWindow->GetId())
+    {
+      wxString msg;
+      msg.Printf("AssociateResource: error when associating child window %ld with resource %ld", child->GetId(), childWindow->GetId());
+      wxMessageBox(msg, "Dialog Editor problem", wxOK);
+    }
+    else if (childWindow->GetName() != child->GetName())
+    {
+      wxString msg;
+      msg.Printf("AssociateResource: error when associating child window with resource %s", child->GetName() ? (const char*) child->GetName() : "(unnamed)");
+      wxMessageBox(msg, "Dialog Editor problem", wxOK);
+    }
+    else
+    {
+      AssociateResource(child, childWindow);
+    }
+
+    // New code to avoid the problem of duplicate ids and names. We simply
+    // traverse the child windows and child resources in parallel,
+    // checking for any mismatch.
+#if 0
+    wxWindow *childWindow = (wxWindow *)m_resourceAssociations.Get((long)child);
     if (!childWindow)
-      childWindow = win->FindWindow(child->GetName());
+      // childWindow = win->FindWindow(child->GetName());
+      childWindow = win->FindWindow(child->GetId());
     if (childWindow)
       AssociateResource(child, childWindow);
     else
     {
-      char buf[200];
-      sprintf(buf, "AssociateResource: cannot find child window %s", child->GetName() ? child->GetName() : "(unnamed)");
-      wxMessageBox(buf, "Dialog Editor problem", wxOK);
+      wxString msg;
+      msg.Printf("AssociateResource: cannot find child window %s", child->GetName() ? (const char*) child->GetName() : "(unnamed)");
+      wxMessageBox(msg, "Dialog Editor problem", wxOK);
     }
-
+#endif
     node = node->Next();
+    node2 = node2->Next();
   }
 }
 
-bool wxResourceManager::DisassociateResource(wxItemResource *resource, bool deleteWindow)
+bool wxResourceManager::DisassociateResource(wxItemResource *resource)
 {
   wxWindow *win = FindWindowForResource(resource);
   if (!win)
     return FALSE;
 
-  // Disassociate children of window without deleting windows
-  // since they'll be deleted by parent.
-  if (win->GetChildren())
-  {
-    wxNode *node = win->GetChildren()->First();
-    while (node)
-    {
-      wxWindow *child = (wxWindow *)node->Data();
-      if (child->IsKindOf(CLASSINFO(wxControl)))
-      	DisassociateResource(child, FALSE);
-      node = node->Next();
-    }
-  }
-  
-  if (deleteWindow)
+  // Disassociate children of window
+  wxNode *node = win->GetChildren().First();
+  while (node)
   {
-    if (win->IsKindOf(CLASSINFO(wxPanel)) && !win->IsKindOf(CLASSINFO(wxDialog)))
-      delete win->GetParent(); // Delete frame
-    else if ( win->IsKindOf(CLASSINFO(wxControl)) )
-	{
-	  wxEvtHandler *childHandler = win->GetEventHandler();
-	  if ( childHandler != win )
-	  {
-		win->PopEventHandler();
-		delete childHandler;
-	  }
-      delete win;
-	}
-	else
-	  // Is this enough? What about event handler? TODO
-	  delete win;
+    wxWindow *child = (wxWindow *)node->Data();
+    if (child->IsKindOf(CLASSINFO(wxControl)))
+  	    DisassociateResource(child);
+    node = node->Next();
   }
+
   RemoveSelection(win);
-  resourceAssociations.Delete((long)resource);
+  m_resourceAssociations.Delete((long)resource);
   return TRUE;
 }
 
-bool wxResourceManager::DisassociateResource(wxWindow *win, bool deleteWindow)
+bool wxResourceManager::DisassociateResource(wxWindow *win)
 {
   wxItemResource *res = FindResourceForWindow(win);
   if (res)
-    return DisassociateResource(res, deleteWindow);
-  return FALSE;
+    return DisassociateResource(res);
+  else
+    return FALSE;
+}
+
+// Saves the window info into the resource, and deletes the
+// handler. Doesn't actually disassociate the window from
+// the resources. Replaces OnClose.
+bool wxResourceManager::SaveInfoAndDeleteHandler(wxWindow* win)
+{
+    wxItemResource *res = FindResourceForWindow(win);
+
+    if (win->IsKindOf(CLASSINFO(wxPanel)))
+    {
+        wxResourceEditorDialogHandler* handler = (wxResourceEditorDialogHandler*) win->GetEventHandler();
+        win->PopEventHandler();
+
+        // Now reset all child event handlers
+        wxNode *node = win->GetChildren().First();
+        while ( node )
+        {
+	        wxWindow *child = (wxWindow *)node->Data();
+	        wxEvtHandler *childHandler = child->GetEventHandler();
+	        if ( child->IsKindOf(CLASSINFO(wxControl)) && childHandler != child )
+	        {
+		        child->PopEventHandler(TRUE);
+	        }
+	        node = node->Next();
+        }
+        delete handler;
+    }
+    else
+    {
+        win->PopEventHandler(TRUE);
+    }
+  
+    // Save the information
+    InstantiateResourceFromWindow(res, win, TRUE);
+  
+//  DisassociateResource(win);
+
+    return TRUE;
+}
+
+// Destroys the window. If this is the 'current' panel, NULLs the
+// variable.
+bool wxResourceManager::DeleteWindow(wxWindow* win)
+{
+    bool clearDisplay = FALSE;
+    if (m_editorPanel->m_childWindow == win)
+    {
+        m_editorPanel->m_childWindow = NULL;
+        clearDisplay = TRUE;
+    }
+
+    win->Destroy();
+
+    if (clearDisplay)
+        m_editorPanel->Clear();
+
+    return TRUE;
 }
 
 wxItemResource *wxResourceManager::FindResourceForWindow(wxWindow *win)
 {
-  resourceAssociations.BeginFind();
+  m_resourceAssociations.BeginFind();
   wxNode *node;
-  while (node = resourceAssociations.Next())
+  while ((node = m_resourceAssociations.Next()))
   {
     wxWindow *w = (wxWindow *)node->Data();
     if (w == win)
     {
-      return (wxItemResource *)node->key.integer;
+      return (wxItemResource *)node->GetKeyInteger();
     }
   }
   return NULL;
@@ -507,7 +679,7 @@ wxItemResource *wxResourceManager::FindResourceForWindow(wxWindow *win)
 
 wxWindow *wxResourceManager::FindWindowForResource(wxItemResource *resource)
 {
-  return (wxWindow *)resourceAssociations.Get((long)resource);
+  return (wxWindow *)m_resourceAssociations.Get((long)resource);
 }
 
 
@@ -515,48 +687,41 @@ void wxResourceManager::MakeUniqueName(char *prefix, char *buf)
 {
   while (TRUE)
   {
-    sprintf(buf, "%s%d", prefix, nameCounter);
-    nameCounter ++;
-    
-    if (!resourceTable.FindResource(buf))
+    sprintf(buf, "%s%d", prefix, m_nameCounter);
+    m_nameCounter ++;
+
+    if (!m_resourceTable.FindResource(buf))
       return;
   }
 }
 
 wxFrame *wxResourceManager::OnCreateEditorFrame(const char *title)
 {
+  /*
   int frameWidth = 420;
   int frameHeight = 300;
+  */
   
-  wxResourceEditorFrame *frame = new wxResourceEditorFrame(this, NULL, (char *)title,
-
-    resourceEditorWindowSize.x, resourceEditorWindowSize.y,
-    resourceEditorWindowSize.width, resourceEditorWindowSize.height,
-
-    wxDEFAULT_FRAME);
+  wxResourceEditorFrame *frame = new wxResourceEditorFrame(this, NULL, title,
+    wxPoint(m_resourceEditorWindowSize.x, m_resourceEditorWindowSize.y),
+    wxSize(m_resourceEditorWindowSize.width, m_resourceEditorWindowSize.height),
+    wxDEFAULT_FRAME_STYLE);
 
-  wxFrame::UseNativeStatusBar(FALSE);
+  frame->CreateStatusBar(1);
 
-  frame->CreateStatusBar(2);
-
-  wxFrame::UseNativeStatusBar(TRUE);
-
-  frame->SetStatusText(editMode ? "Edit mode" : "Test mode", 1);
   frame->SetAutoLayout(TRUE);
-#ifdef __WINDOWS__
-  wxIcon *icon = new wxIcon("DIALOGEDICON");
-  frame->SetIcon(icon);
+#ifdef __WXMSW__
+  frame->SetIcon(wxIcon("DIALOGEDICON"));
 #endif
   return frame;
 }
 
-wxMenuBar *wxResourceManager::OnCreateEditorMenuBar(wxFrame *parent)
+wxMenuBar *wxResourceManager::OnCreateEditorMenuBar(wxFrame *WXUNUSED(parent))
 {
   wxMenuBar *menuBar = new wxMenuBar;
 
   wxMenu *fileMenu = new wxMenu;
   fileMenu->Append(RESED_NEW_DIALOG, "New &dialog", "Create a new dialog");
-  fileMenu->Append(RESED_NEW_PANEL, "New &panel", "Create a new panel");
   fileMenu->AppendSeparator();
   fileMenu->Append(wxID_NEW, "&New project",           "Clear the current project");
   fileMenu->Append(wxID_OPEN, "&Open...",         "Load a resource file");
@@ -567,10 +732,9 @@ wxMenuBar *wxResourceManager::OnCreateEditorMenuBar(wxFrame *parent)
   fileMenu->Append(wxID_EXIT, "E&xit",            "Exit resource editor");
 
   wxMenu *editMenu = new wxMenu;
+  editMenu->Append(RESED_TEST, "&Test Dialog",  "Test dialog");
   editMenu->Append(RESED_RECREATE, "&Recreate",  "Recreate the selected resource(s)");
   editMenu->Append(RESED_DELETE, "&Delete",  "Delete the selected resource(s)");
-  editMenu->AppendSeparator();
-  editMenu->Append(RESED_TOGGLE_TEST_MODE, "&Toggle edit/test mode",  "Toggle edit/test mode");
 
   wxMenu *helpMenu = new wxMenu;
   helpMenu->Append(RESED_CONTENTS, "&Help topics",          "Invokes the on-line help");
@@ -584,162 +748,159 @@ wxMenuBar *wxResourceManager::OnCreateEditorMenuBar(wxFrame *parent)
   return menuBar;
 }
 
-wxPanel *wxResourceManager::OnCreateEditorPanel(wxFrame *parent)
+wxResourceEditorScrolledWindow *wxResourceManager::OnCreateEditorPanel(wxFrame *parent)
 {
-  wxResourceEditorPanel *panel = new wxResourceEditorPanel(parent);
-
-  editorResourceList = new wxListBox(panel, -1, wxPoint(0, 0), wxSize(-1, -1));
+  wxResourceEditorScrolledWindow *panel = new wxResourceEditorScrolledWindow(parent, wxDefaultPosition, wxDefaultSize,
+//    wxSUNKEN_BORDER|wxCLIP_CHILDREN);
+#ifdef __WXMOTIF__
+    wxBORDER);
+#else
+    wxSUNKEN_BORDER);
+#endif
 
-  wxLayoutConstraints *c = new wxLayoutConstraints;
-  c->left.SameAs       (panel, wxLeft, 5);
-  c->top.SameAs        (panel, wxTop, 5);
-  c->right.SameAs      (panel, wxRight, 5);
-  c->bottom.SameAs     (panel, wxBottom, 5);
-  c->width.Unconstrained();
-  c->height.Unconstrained();
-  editorResourceList->SetConstraints(c);
+  panel->SetScrollbars(10, 10, 100, 100);
 
   return panel;
 }
 
-wxToolBarBase *wxResourceManager::OnCreateToolBar(wxFrame *parent)
+wxToolBar *wxResourceManager::OnCreateToolBar(wxFrame *parent)
 {
   // Load palette bitmaps
-#ifdef __WINDOWS__
-  ToolbarLoadBitmap = new wxBitmap("LOADTOOL");
-  ToolbarSaveBitmap = new wxBitmap("SAVETOOL");
-  ToolbarNewBitmap = new wxBitmap("NEWTOOL");
-  ToolbarVertBitmap = new wxBitmap("VERTTOOL");
-  ToolbarAlignTBitmap = new wxBitmap("ALIGNTTOOL");
-  ToolbarAlignBBitmap = new wxBitmap("ALIGNBTOOL");
-  ToolbarHorizBitmap = new wxBitmap("HORIZTOOL");
-  ToolbarAlignLBitmap = new wxBitmap("ALIGNLTOOL");
-  ToolbarAlignRBitmap = new wxBitmap("ALIGNRTOOL");
-  ToolbarCopySizeBitmap = new wxBitmap("COPYSIZETOOL");
-  ToolbarToBackBitmap = new wxBitmap("TOBACKTOOL");
-  ToolbarToFrontBitmap = new wxBitmap("TOFRONTTOOL");
-  ToolbarHelpBitmap = new wxBitmap("HELPTOOL");
+#ifdef __WXMSW__
+  wxBitmap ToolbarLoadBitmap("LOADTOOL");
+  wxBitmap ToolbarSaveBitmap("SAVETOOL");
+  wxBitmap ToolbarNewBitmap("NEWTOOL");
+  wxBitmap ToolbarVertBitmap("VERTTOOL");
+  wxBitmap ToolbarAlignTBitmap("ALIGNTTOOL");
+  wxBitmap ToolbarAlignBBitmap("ALIGNBTOOL");
+  wxBitmap ToolbarHorizBitmap("HORIZTOOL");
+  wxBitmap ToolbarAlignLBitmap("ALIGNLTOOL");
+  wxBitmap ToolbarAlignRBitmap("ALIGNRTOOL");
+  wxBitmap ToolbarCopySizeBitmap("COPYSIZETOOL");
+  wxBitmap ToolbarToBackBitmap("TOBACKTOOL");
+  wxBitmap ToolbarToFrontBitmap("TOFRONTTOOL");
+  wxBitmap ToolbarHelpBitmap("HELPTOOL");
 #endif
-#ifdef __X__
-  ToolbarLoadBitmap = new wxBitmap(load_bits, load_width, load_height);
-  ToolbarSaveBitmap = new wxBitmap(save_bits, save_width, save_height);
-  ToolbarNewBitmap = new wxBitmap(new_bits, save_width, save_height);
-  ToolbarVertBitmap = new wxBitmap(vert_bits, vert_width, vert_height);
-  ToolbarAlignTBitmap = new wxBitmap(alignt_bits, alignt_width, alignt_height);
-  ToolbarAlignBBitmap = new wxBitmap(alignb_bits, alignb_width, alignb_height);
-  ToolbarHorizBitmap = new wxBitmap(horiz_bits, horiz_width, horiz_height);
-  ToolbarAlignLBitmap = new wxBitmap(alignl_bits, alignl_width, alignl_height);
-  ToolbarAlignRBitmap = new wxBitmap(alignr_bits, alignr_width, alignr_height);
-  ToolbarCopySizeBitmap = new wxBitmap(copysize_bits, copysize_width, copysize_height);
-  ToolbarToBackBitmap = new wxBitmap(toback_bits, toback_width, toback_height);
-  ToolbarToFrontBitmap = new wxBitmap(tofront_bits, tofront_width, tofront_height);
-//  ToolbarCPPBitmap = new wxBitmap(cpp_bits, cpp_width, cpp_height);
-//  ToolbarTreeBitmap = new wxBitmap(tree_bits, tree_width, tree_height);
-  ToolbarHelpBitmap = new wxBitmap(help_bits, help_width, help_height);
+#if defined(__WXGTK__) || defined(__WXMOTIF__)
+  wxBitmap ToolbarLoadBitmap( load_xpm );
+  wxBitmap ToolbarSaveBitmap( save_xpm);
+  wxBitmap ToolbarNewBitmap( new_xpm );
+  wxBitmap ToolbarVertBitmap( vert_xpm );
+  wxBitmap ToolbarAlignTBitmap( alignt_xpm );
+  wxBitmap ToolbarAlignBBitmap( alignb_xpm );
+  wxBitmap ToolbarHorizBitmap( horiz_xpm );
+  wxBitmap ToolbarAlignLBitmap( alignl_xpm );
+  wxBitmap ToolbarAlignRBitmap( alignr_xpm );
+  wxBitmap ToolbarCopySizeBitmap( copysize_xpm );
+  wxBitmap ToolbarToBackBitmap( toback_xpm );
+  wxBitmap ToolbarToFrontBitmap( tofront_xpm );
+  wxBitmap ToolbarHelpBitmap( help_xpm );
 #endif
 
   // Create the toolbar
-  EditorToolBar *toolbar = new EditorToolBar(parent, 0, 0, -1, -1, wxNO_BORDER,
-                                        wxVERTICAL, 1);
+  EditorToolBar *toolbar = new EditorToolBar(parent, wxPoint(0, 0), wxSize(-1, -1), wxNO_BORDER|wxTB_HORIZONTAL);
   toolbar->SetMargins(2, 2);
-//  toolbar->GetDC()->SetBackground(wxLIGHT_GREY_BRUSH);
 
-#ifdef __WINDOWS__
+#ifdef __WXMSW__
   int width = 24;
   int dx = 2;
   int gap = 6;
 #else
-  int width = ToolbarLoadBitmap->GetWidth();
+  int width = 24; // ToolbarLoadBitmap->GetWidth();  ???
   int dx = 2;
   int gap = 6;
 #endif
   int currentX = gap;
   toolbar->AddSeparator();
-  toolbar->AddTool(TOOLBAR_NEW, ToolbarNewBitmap, (wxBitmap *)NULL,
-                   FALSE, (float)currentX, -1, NULL, "New dialog");
+  toolbar->AddTool(TOOLBAR_NEW, ToolbarNewBitmap, wxNullBitmap,
+                   FALSE, currentX, -1, NULL, "New dialog");
   currentX += width + dx;
-  toolbar->AddTool(TOOLBAR_LOAD_FILE, ToolbarLoadBitmap, (wxBitmap *)NULL,
-                   FALSE, (float)currentX, -1, NULL, "Load");
+  toolbar->AddTool(TOOLBAR_LOAD_FILE, ToolbarLoadBitmap, wxNullBitmap,
+                   FALSE, currentX, -1, NULL, "Load");
   currentX += width + dx;
-  toolbar->AddTool(TOOLBAR_SAVE_FILE, ToolbarSaveBitmap, (wxBitmap *)NULL,
-                   FALSE, (float)currentX, -1, NULL, "Save");
+  toolbar->AddTool(TOOLBAR_SAVE_FILE, ToolbarSaveBitmap, wxNullBitmap,
+                   FALSE, currentX, -1, NULL, "Save");
   currentX += width + dx + gap;
   toolbar->AddSeparator();
-  toolbar->AddTool(TOOLBAR_FORMAT_HORIZ, ToolbarVertBitmap, (wxBitmap *)NULL,
-                   FALSE, (float)currentX, -1, NULL, "Horizontal align");
+  toolbar->AddTool(TOOLBAR_FORMAT_HORIZ, ToolbarVertBitmap, wxNullBitmap,
+                   FALSE, currentX, -1, NULL, "Horizontal align");
   currentX += width + dx;
-  toolbar->AddTool(TOOLBAR_FORMAT_VERT_TOP_ALIGN, ToolbarAlignTBitmap, (wxBitmap *)NULL,
-                   FALSE, (float)currentX, -1, NULL, "Top align");
+  toolbar->AddTool(TOOLBAR_FORMAT_VERT_TOP_ALIGN, ToolbarAlignTBitmap, wxNullBitmap,
+                   FALSE, currentX, -1, NULL, "Top align");
   currentX += width + dx;
-  toolbar->AddTool(TOOLBAR_FORMAT_VERT_BOT_ALIGN, ToolbarAlignBBitmap, (wxBitmap *)NULL,
-                   FALSE, (float)currentX, -1, NULL, "Bottom align");
+  toolbar->AddTool(TOOLBAR_FORMAT_VERT_BOT_ALIGN, ToolbarAlignBBitmap, wxNullBitmap,
+                   FALSE, currentX, -1, NULL, "Bottom align");
   currentX += width + dx;
-  toolbar->AddTool(TOOLBAR_FORMAT_VERT, ToolbarHorizBitmap, (wxBitmap *)NULL,
-                   FALSE, (float)currentX, -1, NULL, "Vertical align");
+  toolbar->AddTool(TOOLBAR_FORMAT_VERT, ToolbarHorizBitmap, wxNullBitmap,
+                   FALSE, currentX, -1, NULL, "Vertical align");
   currentX += width + dx;
-  toolbar->AddTool(TOOLBAR_FORMAT_HORIZ_LEFT_ALIGN, ToolbarAlignLBitmap, (wxBitmap *)NULL,
-                   FALSE, (float)currentX, -1, NULL, "Left align");
+  toolbar->AddTool(TOOLBAR_FORMAT_HORIZ_LEFT_ALIGN, ToolbarAlignLBitmap, wxNullBitmap,
+                   FALSE, currentX, -1, NULL, "Left align");
   currentX += width + dx;
-  toolbar->AddTool(TOOLBAR_FORMAT_HORIZ_RIGHT_ALIGN, ToolbarAlignRBitmap, (wxBitmap *)NULL,
-                   FALSE, (float)currentX, -1, NULL, "Right align");
+  toolbar->AddTool(TOOLBAR_FORMAT_HORIZ_RIGHT_ALIGN, ToolbarAlignRBitmap, wxNullBitmap,
+                   FALSE, currentX, -1, NULL, "Right align");
   currentX += width + dx;
-  toolbar->AddTool(TOOLBAR_COPY_SIZE, ToolbarCopySizeBitmap, (wxBitmap *)NULL,
-                   FALSE, (float)currentX, -1, NULL, "Copy size");
+  toolbar->AddTool(TOOLBAR_COPY_SIZE, ToolbarCopySizeBitmap, wxNullBitmap,
+                   FALSE, currentX, -1, NULL, "Copy size");
   currentX += width + dx + gap;
   toolbar->AddSeparator();
-  toolbar->AddTool(TOOLBAR_TO_FRONT, ToolbarToFrontBitmap, (wxBitmap *)NULL,
-                   FALSE, (float)currentX, -1, NULL, "To front");
+  toolbar->AddTool(TOOLBAR_TO_FRONT, ToolbarToFrontBitmap, wxNullBitmap,
+                   FALSE, currentX, -1, NULL, "To front");
   currentX += width + dx;
-  toolbar->AddTool(TOOLBAR_TO_BACK, ToolbarToBackBitmap, (wxBitmap *)NULL,
-                   FALSE, (float)currentX, -1, NULL, "To back");
+  toolbar->AddTool(TOOLBAR_TO_BACK, ToolbarToBackBitmap, wxNullBitmap,
+                   FALSE, currentX, -1, NULL, "To back");
   currentX += width + dx + gap;
-/*
-  toolbar->AddTool(TOOLBAR_GEN_CPP, ToolbarCPPBitmap, (wxBitmap *)NULL,
-                   FALSE, (float)currentX, -1, NULL);
-  currentX += width + dx;
 
-  toolbar->AddTool(TOOLBAR_TREE, ToolbarTreeBitmap, (wxBitmap *)NULL,
-                   FALSE, (float)currentX, -1, NULL);
-  currentX += width + dx;
-*/
   toolbar->AddSeparator();
-  toolbar->AddTool(TOOLBAR_HELP, ToolbarHelpBitmap, (wxBitmap *)NULL,
-                   FALSE, (float)currentX, -1, NULL, "Help");
+  toolbar->AddTool(TOOLBAR_HELP, ToolbarHelpBitmap, wxNullBitmap,
+                   FALSE, currentX, -1, NULL, "Help");
   currentX += width + dx;
   
-  toolbar->CreateTools();
+  toolbar->Realize();
 
   return toolbar;
-
-//  parent->OnSize(-1, -1);
 }
 
-void wxResourceManager::UpdateResourceList(void)
+void wxResourceManager::UpdateResourceList()
 {
-  editorResourceList->Clear();
-  resourceTable.BeginFind();
+  if (!m_editorResourceTree)
+      return;
+
+  m_editorResourceTree->SetInvalid(TRUE);
+  m_editorResourceTree->DeleteAllItems();
+
+  long id = m_editorResourceTree->AddRoot("Dialogs", 1, 2);
+
+  m_resourceTable.BeginFind();
   wxNode *node;
-  while (node = resourceTable.Next())
+  while ((node = m_resourceTable.Next()))
   {
     wxItemResource *res = (wxItemResource *)node->Data();
     wxString resType(res->GetType());
-//    if (res->GetType() == wxTYPE_DIALOG_BOX || res->GetType() == wxTYPE_FRAME || res->GetType() == wxTYPE_BITMAP)
     if (resType == "wxDialog" || resType == "wxDialogBox" || resType == "wxPanel" || resType == "wxBitmap")
     {
-      AddItemsRecursively(0, res);
+      AddItemsRecursively(id, res);
     }
   }
+  m_editorResourceTree->Expand(id);
+  m_editorResourceTree->SetInvalid(FALSE);
 }
 
-void wxResourceManager::AddItemsRecursively(int level, wxItemResource *resource)
+void wxResourceManager::AddItemsRecursively(long parent, wxItemResource *resource)
 {
-  int padWidth = level*4;
-  
   wxString theString("");
-  theString.Append(' ', padWidth);
-  theString += resource->GetName();
+  theString = resource->GetName();
+
+  int imageId = 0;
+  wxString resType(resource->GetType());
+  if (resType == "wxDialog" || resType == "wxDialogBox" || resType == "wxPanel")
+    imageId = 0;
+  else
+    imageId = 3;
   
-  editorResourceList->Append(theString.GetData(), (char *)resource);
+  long id = m_editorResourceTree->AppendItem(parent, theString, imageId );
+
+  m_editorResourceTree->SetItemData(id, new wxResourceTreeData(resource));
 
   if (strcmp(resource->GetType(), "wxBitmap") != 0)
   {
@@ -747,18 +908,20 @@ void wxResourceManager::AddItemsRecursively(int level, wxItemResource *resource)
     while (node)
     {
       wxItemResource *res = (wxItemResource *)node->Data();
-      AddItemsRecursively(level+1, res);
+      AddItemsRecursively(id, res);
       node = node->Next();
     }
   }
+//  m_editorResourceTree->ExpandItem(id, wxTREE_EXPAND_EXPAND);
 }
 
-bool wxResourceManager::EditSelectedResource(void)
+bool wxResourceManager::EditSelectedResource()
 {
-  int sel = editorResourceList->GetSelection();
-  if (sel > -1)
+  int sel = m_editorResourceTree->GetSelection();
+  if (sel != 0)
   {
-    wxItemResource *res = (wxItemResource *)editorResourceList->wxListBox::GetClientData(sel);
+    wxResourceTreeData *data = (wxResourceTreeData *)m_editorResourceTree->GetItemData(sel);
+    wxItemResource *res = data->GetResource();
     return Edit(res);
   }
   return FALSE;
@@ -766,132 +929,83 @@ bool wxResourceManager::EditSelectedResource(void)
 
 bool wxResourceManager::Edit(wxItemResource *res)
 {
+  wxPropertyInfo::CloseWindow();
+
+  ClearCurrentDialog();
+
   wxString resType(res->GetType());
-  if (resType == "wxDialog" || resType == "wxDialogBox")
-    {
-      wxDialog *dialog = (wxDialog *)FindWindowForResource(res);
-      if (dialog)
-        dialog->Show(TRUE);
-      else
-      {
-        dialog = new wxDialog;
-        wxResourceEditorDialogHandler *handler = new wxResourceEditorDialogHandler(dialog, res, dialog->GetEventHandler(),
-           this);
-        dialog->PushEventHandler(handler);
+  wxPanel *panel = (wxPanel *)FindWindowForResource(res);
 
-//        dialog->SetUserEditMode(TRUE);
-          
-        dialog->LoadFromResource(GetEditorFrame(), res->GetName(), &resourceTable);
-		handler->AddChildHandlers(); // Add event handlers for all controls
-        dialog->SetModal(FALSE);
-        AssociateResource(res, dialog);
-        dialog->Show(TRUE);
-      }
-    }
-  else if (resType == "wxPanel")
-    {
-      wxPanel *panel = (wxPanel *)FindWindowForResource(res);
-      if (panel)
-        panel->GetParent()->Show(TRUE);
-      else
-      {
-        DialogEditorPanelFrame *frame = new DialogEditorPanelFrame(GetEditorFrame(), res->GetName(), 10, 10, 400, 300, wxDEFAULT_FRAME_STYLE, res->GetName());
+  if (panel)
+  {
+    wxMessageBox("Should not find panel in wxResourceManager::Edit");
+    return FALSE;
+  }
+  else
+  {
+//        long style = res->GetStyle();
+//        res->SetStyle(style|wxRAISED_BORDER);
         panel = new wxPanel;
         wxResourceEditorDialogHandler *handler = new wxResourceEditorDialogHandler(panel, res, panel->GetEventHandler(),
            this);
+
+        panel->LoadFromResource(m_editorPanel, res->GetName(), &m_resourceTable);
+
         panel->PushEventHandler(handler);
-//        panel->SetUserEditMode(TRUE);
-          
-        panel->LoadFromResource(frame, res->GetName(), &resourceTable);
+
+//        res->SetStyle(style);
 		handler->AddChildHandlers(); // Add event handlers for all controls
         AssociateResource(res, panel);
-        frame->SetClientSize(res->GetWidth(), res->GetHeight());
-        frame->Show(TRUE);
-      }
-    }
+
+        m_editorPanel->m_childWindow = panel;
+        panel->Move(m_editorPanel->GetMarginX(), m_editorPanel->GetMarginY());
+        panel->Show(TRUE);
+        panel->Refresh();
+
+        wxClientDC dc(m_editorPanel);
+        m_editorPanel->DrawTitle(dc);
+  }
   return FALSE;
 }
 
-bool wxResourceManager::CreateNewDialog(void)
+bool wxResourceManager::CreateNewPanel()
 {
+  wxPropertyInfo::CloseWindow();
+
+  ClearCurrentDialog();
+
   char buf[256];
   MakeUniqueName("dialog", buf);
   
   wxItemResource *resource = new wxItemResource;
-//  resource->SetType(wxTYPE_DIALOG_BOX);
   resource->SetType("wxDialog");
   resource->SetName(buf);
   resource->SetTitle(buf);
-  resourceTable.AddResource(resource);
-
-#ifdef __MOTIF__
-  wxDialog *dialog = new wxDialog(GetEditorFrame(), -1, buf, wxPoint(10, 10), wxSize(400, 300), wxDEFAULT_DIALOG_STYLE, buf);
-/*
-  dialog->SetBackgroundColour(*wxLIGHT_GREY);
-  dialog->GetDC()->SetBackground(wxLIGHT_GREY_BRUSH);
-  dialog->SetButtonColour(*wxBLACK);
-  dialog->SetLabelColour(*wxBLACK);
-*/
-#else
-  wxDialog *dialog = new wxDialog(GetEditorFrame(), -1, buf, wxPoint(10, 10), wxSize(400, 300), wxDEFAULT_DIALOG_STYLE, buf);
-#endif
-  
-  resource->SetValue1(FALSE); // Modeless to start with
-  resource->SetStyle(dialog->GetWindowStyleFlag());
+  resource->SetResourceStyle(wxRESOURCE_USE_DEFAULTS);
+  resource->SetResourceStyle(wxRESOURCE_DIALOG_UNITS);
 
-  // For editing in situ we will need to use the hash table to ensure
-  // we don't dereference invalid pointers.
-//  resourceWindowTable.Put((long)resource, dialog);
+  wxString newIdName;
+  int id = GenerateWindowId("ID_DIALOG", newIdName);
+  resource->SetId(id);
 
-  wxResourceEditorDialogHandler *handler = new wxResourceEditorDialogHandler(dialog, resource, dialog->GetEventHandler(),
-   this);
+  // This is now guaranteed to be unique, so just add to symbol table
+  m_symbolTable.AddSymbol(newIdName, id);
 
-  dialog->PushEventHandler(handler);
-  
-  dialog->Centre(wxBOTH);
-//  dialog->SetUserEditMode(TRUE);
-  dialog->Show(TRUE);
+  m_resourceTable.AddResource(resource);
 
-  SetEditMode(TRUE, FALSE);
+  wxSize size(400, 300);
 
-  AssociateResource(resource, dialog);
-//  SetCurrentResource(resource);
-//  SetCurrentResourceWindow(dialog);
-  UpdateResourceList();
-  
-  Modify(TRUE);
-  
-  return TRUE;
-}
+  wxPanel *panel = new wxPanel(m_editorPanel, -1,
+     wxPoint(m_editorPanel->GetMarginX(), m_editorPanel->GetMarginY()),
+     size, wxRAISED_BORDER|wxDEFAULT_DIALOG_STYLE, buf);
+  m_editorPanel->m_childWindow = panel;
 
-bool wxResourceManager::CreateNewPanel(void)
-{
-  char buf[256];
-  MakeUniqueName("panel", buf);
-  
-  wxItemResource *resource = new wxItemResource;
-//  resource->SetType(wxTYPE_PANEL);
-  resource->SetType("wxPanel");
-  resource->SetName(buf);
-  resource->SetTitle(buf);
-  resourceTable.AddResource(resource);
-  
-  DialogEditorPanelFrame *frame = new DialogEditorPanelFrame(GetEditorFrame(), buf, 10, 10, 400, 300, wxDEFAULT_FRAME_STYLE, buf);
+  resource->SetStyle(panel->GetWindowStyleFlag());
 
-#ifdef __MOTIF__
-  wxPanel *panel = new wxPanel(frame, -1, wxPoint(0, 0), wxSize(400, 300), 0, buf);
-/*
-  panel->SetBackgroundColour(*wxLIGHT_GREY);
-  panel->GetDC()->SetBackground(wxLIGHT_GREY_BRUSH);
-  panel->SetButtonColour(*wxBLACK);
-  panel->SetLabelColour(*wxBLACK);
-*/
+  // Store dialog units in resource
+  size = panel->ConvertPixelsToDialog(size);
 
-#else
-  wxPanel *panel = new wxPanel(frame, -1, wxPoint(0, 0), wxSize(400, 300), 0, buf);
-#endif
-  
-  resource->SetStyle(panel->GetWindowStyleFlag());
+  resource->SetSize(10, 10, size.x, size.y);
 
   // For editing in situ we will need to use the hash table to ensure
   // we don't dereference invalid pointers.
@@ -901,19 +1015,17 @@ bool wxResourceManager::CreateNewPanel(void)
    this);
   panel->PushEventHandler(handler);
   
-  panel->Centre(wxBOTH);
-//  panel->SetUserEditMode(TRUE);
-  frame->Show(TRUE);
-
-  SetEditMode(TRUE, FALSE);
-
   AssociateResource(resource, panel);
-//  SetCurrentResource(resource);
-//  SetCurrentResourceWindow(panel);
   UpdateResourceList();
   
   Modify(TRUE);
-  
+  m_editorPanel->m_childWindow->Refresh();
+
+//  panel->Refresh();
+
+  wxClientDC dc(m_editorPanel);
+  m_editorPanel->DrawTitle(dc);
+
   return TRUE;
 }
 
@@ -927,102 +1039,141 @@ bool wxResourceManager::CreatePanelItem(wxItemResource *panelResource, wxPanel *
   
   wxItemResource *res = new wxItemResource;
   wxControl *newItem = NULL;
-  res->SetSize(x, y, -1, -1);
+
+  if ((panelResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS) != 0)
+  {
+    wxPoint pt = panel->ConvertPixelsToDialog(wxPoint(x, y));
+    res->SetSize(pt.x, pt.y, -1, -1);
+  }
+  else res->SetSize(x, y, -1, -1);
+
   res->SetType(iType);
+
+  wxString prefix;
   
   wxString itemType(iType);
 
   if (itemType == "wxButton")
     {
+      prefix = "ID_BUTTON";
       MakeUniqueName("button", buf);
       res->SetName(buf);
       if (isBitmap)
-        newItem = new wxBitmapButton(panel, -1, wxWinBitmap, wxPoint(x, y), wxSize(-1, -1), 0, wxDefaultValidator, buf);
+        newItem = new wxBitmapButton(panel, -1, * m_bitmapImage, wxPoint(x, y), wxSize(-1, -1), 0, wxDefaultValidator, buf);
       else
         newItem = new wxButton(panel, -1, "Button", wxPoint(x, y), wxSize(-1, -1), 0, wxDefaultValidator, buf);
     }
   if (itemType == "wxBitmapButton")
     {
+      prefix = "ID_BITMAPBUTTON";
       MakeUniqueName("button", buf);
       res->SetName(buf);
-      newItem = new wxBitmapButton(panel, -1, wxWinBitmap, wxPoint(x, y), wxSize(-1, -1), 0, wxDefaultValidator, buf);
+      newItem = new wxBitmapButton(panel, -1, * m_bitmapImage, wxPoint(x, y), wxSize(-1, -1), 0, wxDefaultValidator, buf);
     }
   else if (itemType == "wxMessage" || itemType == "wxStaticText")
     {
-      MakeUniqueName("message", buf);
+      prefix = "ID_STATIC";
+      MakeUniqueName("statictext", buf);
       res->SetName(buf);
       if (isBitmap)
-        newItem = new wxStaticBitmap(panel, -1, wxWinBitmap, wxPoint(x, y), wxSize(0, 0), 0, buf);
+        newItem = new wxStaticBitmap(panel, -1, * m_bitmapImage, wxPoint(x, y), wxSize(0, 0), 0, buf);
       else
-        newItem = new wxStaticText(panel, -1, "Message", wxPoint(x, y), wxSize(-1, -1), 0, buf);
+        newItem = new wxStaticText(panel, -1, "Static", wxPoint(x, y), wxSize(-1, -1), 0, buf);
     }
   else if (itemType == "wxStaticBitmap")
     {
-      MakeUniqueName("message", buf);
+      prefix = "ID_STATICBITMAP";
+      MakeUniqueName("static", buf);
       res->SetName(buf);
-      newItem = new wxStaticBitmap(panel, -1, wxWinBitmap, wxPoint(x, y), wxSize(-1, -1), 0, buf);
+      newItem = new wxStaticBitmap(panel, -1, * m_bitmapImage, wxPoint(x, y), wxSize(-1, -1), 0, buf);
     }
   else if (itemType == "wxCheckBox")
     {
+      prefix = "ID_CHECKBOX";
       MakeUniqueName("checkbox", buf);
       res->SetName(buf);
       newItem = new wxCheckBox(panel, -1, "Checkbox", wxPoint(x, y), wxSize(-1, -1), 0, wxDefaultValidator, buf);
     }
   else if (itemType == "wxListBox")
     {
+      prefix = "ID_LISTBOX";
       MakeUniqueName("listbox", buf);
       res->SetName(buf);
       newItem = new wxListBox(panel, -1, wxPoint(x, y), wxSize(-1, -1), 0, NULL, 0, wxDefaultValidator, buf);
     }
   else if (itemType == "wxRadioBox")
     {
+      prefix = "ID_RADIOBOX";
       MakeUniqueName("radiobox", buf);
       res->SetName(buf);
       wxString names[] = { "One", "Two" };
       newItem = new wxRadioBox(panel, -1, "Radiobox", wxPoint(x, y), wxSize(-1, -1), 2, names, 2,
 	     wxHORIZONTAL, wxDefaultValidator, buf);
-      res->SetStringValues(new wxStringList("One", "Two", NULL));
+      res->SetStringValues(wxStringList("One", "Two", NULL));
+    }
+  else if (itemType == "wxRadioButton")
+    {
+      prefix = "ID_RADIOBUTTON";
+      MakeUniqueName("radiobutton", buf);
+      res->SetName(buf);
+      wxString names[] = { "One", "Two" };
+      newItem = new wxRadioButton(panel, -1, "Radiobutton", wxPoint(x, y), wxSize(-1, -1),
+	     0, wxDefaultValidator, buf);
     }
   else if (itemType == "wxChoice")
     {
+      prefix = "ID_CHOICE";
       MakeUniqueName("choice", buf);
       res->SetName(buf);
       newItem = new wxChoice(panel, -1, wxPoint(x, y), wxSize(-1, -1), 0, NULL, 0, wxDefaultValidator, buf);
     }
+  else if (itemType == "wxComboBox")
+    {
+      prefix = "ID_COMBOBOX";
+      MakeUniqueName("combobox", buf);
+      res->SetName(buf);
+      newItem = new wxComboBox(panel, -1, "", wxPoint(x, y), wxSize(-1, -1), 0, NULL, wxCB_DROPDOWN, wxDefaultValidator, buf);
+    }
   else if (itemType == "wxGroupBox" || itemType == "wxStaticBox")
     {
-      MakeUniqueName("group", buf);
+      prefix = "ID_STATICBOX";
+      MakeUniqueName("staticbox", buf);
       res->SetName(buf);
-      newItem = new wxStaticBox(panel, -1, "Groupbox", wxPoint(x, y), wxSize(200, 200), 0, buf);
+      newItem = new wxStaticBox(panel, -1, "Static", wxPoint(x, y), wxSize(200, 200), 0, buf);
     }
   else if (itemType == "wxGauge")
     {
+      prefix = "ID_GAUGE";
       MakeUniqueName("gauge", buf);
       res->SetName(buf);
       newItem = new wxGauge(panel, -1, 10, wxPoint(x, y), wxSize(80, 30), wxHORIZONTAL, wxDefaultValidator, buf);
     }
   else if (itemType == "wxSlider")
     {
+      prefix = "ID_SLIDER";
       MakeUniqueName("slider", buf);
       res->SetName(buf);
       newItem = new wxSlider(panel, -1, 1, 1, 10, wxPoint(x, y), wxSize(120, -1), wxHORIZONTAL, wxDefaultValidator, buf);
     }
-  else if (itemType == "wxText" || itemType == "wxTextCtrl")
+  else if (itemType == "wxText" || itemType == "wxTextCtrl (single-line)")
     {
-      MakeUniqueName("text", buf);
+      prefix = "ID_TEXTCTRL";
+      MakeUniqueName("textctrl", buf);
       res->SetName(buf);
+      res->SetType("wxTextCtrl");
       newItem = new wxTextCtrl(panel, -1, "", wxPoint(x, y), wxSize(120, -1), 0, wxDefaultValidator, buf);
     }
-/*
-  else if (itemType == "wxMultiText")
+  else if (itemType == "wxMultiText" || itemType == "wxTextCtrl (multi-line)")
     {
-      MakeUniqueName("multitext", buf);
+      prefix = "ID_TEXTCTRL";
+      MakeUniqueName("textctrl", buf);
       res->SetName(buf);
-      newItem = new wxMultiText(panel, (wxFunction)NULL, "Multitext", "", x, y, -1, -1, 0, wxDefaultValidator, buf);
+      res->SetType("wxTextCtrl");
+      newItem = new wxTextCtrl(panel, -1, "", wxPoint(x, y), wxSize(120, 100), wxTE_MULTILINE, wxDefaultValidator, buf);
     }
-*/
   else if (itemType == "wxScrollBar")
     {
+      prefix = "ID_SCROLLBAR";
       MakeUniqueName("scrollbar", buf);
       res->SetName(buf);
       newItem = new wxScrollBar(panel, -1, wxPoint(x, y), wxSize(140, -1), wxHORIZONTAL, wxDefaultValidator, buf);
@@ -1030,6 +1181,23 @@ bool wxResourceManager::CreatePanelItem(wxItemResource *panelResource, wxPanel *
   if (!newItem)
     return FALSE;
 
+  int actualW, actualH;
+  newItem->GetSize(&actualW, &actualH);
+  wxSize actualSize(actualW, actualH);
+
+  if ((panelResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS) != 0)
+  {
+    actualSize = panel->ConvertPixelsToDialog(actualSize);
+  }
+  res->SetSize(res->GetX(), res->GetY(), actualSize.x, actualSize.y);
+
+  wxString newIdName;
+  int id = GenerateWindowId(prefix, newIdName);
+  res->SetId(id);
+
+  // This is now guaranteed to be unique, so just add to symbol table
+  m_symbolTable.AddSymbol(newIdName, id);
+
   newItem->PushEventHandler(new wxResourceEditorControlHandler(newItem, newItem));
 
   res->SetStyle(newItem->GetWindowStyleFlag());
@@ -1041,19 +1209,55 @@ bool wxResourceManager::CreatePanelItem(wxItemResource *panelResource, wxPanel *
   return TRUE;
 }
 
+void wxResourceManager::ClearCurrentDialog()
+{
+  if (m_editorPanel->m_childWindow)
+  {
+    SaveInfoAndDeleteHandler(m_editorPanel->m_childWindow);
+    DisassociateResource(m_editorPanel->m_childWindow);
+    DeleteWindow(m_editorPanel->m_childWindow);
+    m_editorPanel->m_childWindow = NULL;
+    m_editorPanel->Clear();
+  }
+}
+
+bool wxResourceManager::TestCurrentDialog(wxWindow* parent)
+{
+  if (m_editorPanel->m_childWindow)
+  {
+    wxItemResource* item = FindResourceForWindow(m_editorPanel->m_childWindow);
+    if (!item)
+        return FALSE;
+
+    // Make sure the resources are up-to-date w.r.t. the window
+    InstantiateResourceFromWindow(item, m_editorPanel->m_childWindow, TRUE);
+
+    wxDialog* dialog = new wxDialog;
+    bool success = FALSE;
+    if (dialog->LoadFromResource(parent, item->GetName(), & m_resourceTable))
+    {
+        dialog->Centre();
+        dialog->ShowModal();
+        success = TRUE;
+    }
+    return success;
+  }
+  return FALSE;
+}
+
 // Find the first dialog or panel for which
 // there is a selected panel item.
-wxWindow *wxResourceManager::FindParentOfSelection(void)
+wxWindow *wxResourceManager::FindParentOfSelection()
 {
-  resourceTable.BeginFind();
+  m_resourceTable.BeginFind();
   wxNode *node;
-  while (node = resourceTable.Next())
+  while ((node = m_resourceTable.Next()))
   {
     wxItemResource *res = (wxItemResource *)node->Data();
     wxWindow *win = FindWindowForResource(res);
     if (win)
     {
-      wxNode *node1 = win->GetChildren()->First();
+      wxNode *node1 = win->GetChildren().First();
       while (node1)
       {
         wxControl *item = (wxControl *)node1->Data();
@@ -1089,7 +1293,7 @@ void wxResourceManager::AlignItems(int flag)
   int centreX = (int)(firstX + (firstW / 2));
   int centreY = (int)(firstY + (firstH / 2));
 
-  while (node = node->Next())
+  while ((node = node->Next()))
   {
     wxControl *item = (wxControl *)node->Data();
     if (item->GetParent() == win)
@@ -1143,14 +1347,29 @@ void wxResourceManager::AlignItems(int flag)
           break;
       }
 
+      wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(item);
+      wxItemResource* parentResource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(item->GetParent());
+
       item->SetSize(newX, newY, w, h);
+
+	  // Also update the associated resource
+	  // We need to convert to dialog units if this is not a dialog or panel, but
+	  // the parent resource specifies dialog units.
+	  if (parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
+      {
+        wxPoint pt = item->GetParent()->ConvertPixelsToDialog(wxPoint(newX, newY));
+        newX = pt.x; newY = pt.y;
+        wxSize sz = item->GetParent()->ConvertPixelsToDialog(wxSize(w, h));
+        w = sz.x; h = sz.y;
+      }
+      resource->SetSize(newX, newY, w, h);
     }
   }
   win->Refresh();
 }
 
 // Copy the first image's size to subsequent images
-void wxResourceManager::CopySize(void)
+void wxResourceManager::CopySize()
 {
   wxWindow *win = FindParentOfSelection();
   if (!win)
@@ -1168,14 +1387,31 @@ void wxResourceManager::CopySize(void)
   int firstW, firstH;
   firstSelection->GetPosition(&firstX, &firstY);
   firstSelection->GetSize(&firstW, &firstH);
-  int centreX = (int)(firstX + (firstW / 2));
-  int centreY = (int)(firstY + (firstH / 2));
 
-  while (node = node->Next())
+  while ((node = node->Next()))
   {
     wxControl *item = (wxControl *)node->Data();
     if (item->GetParent() == win)
+	{
       item->SetSize(-1, -1, firstW, firstH);
+
+      int fw = firstW;
+      int fh = firstH;
+
+      wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(item);
+      wxItemResource* parentResource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(item->GetParent());
+
+	  // Also update the associated resource
+	  // We need to convert to dialog units if this is not a dialog or panel, but
+	  // the parent resource specifies dialog units.
+	  if (parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
+      {
+        wxSize sz = item->GetParent()->ConvertPixelsToDialog(wxSize(firstW, firstH));
+        fw = sz.x; fh = sz.y;
+      }
+      resource->SetSize(resource->GetX(), resource->GetY(), fw, fh);
+
+	}
   }
   win->Refresh();
 }
@@ -1194,18 +1430,18 @@ void wxResourceManager::ToBackOrFront(bool toBack)
     wxItemResource *itemResource = FindResourceForWindow(item);
     if (item->GetParent() == win)
     {
-      win->GetChildren()->DeleteObject(item);
+      win->GetChildren().DeleteObject(item);
       if (winResource)
         winResource->GetChildren().DeleteObject(itemResource);
       if (toBack)
       {
-        win->GetChildren()->Insert(item);
+        win->GetChildren().Insert(item);
         if (winResource)
           winResource->GetChildren().Insert(itemResource);
       }
       else
       {
-        win->GetChildren()->Append(item);
+        win->GetChildren().Append(item);
         if (winResource)
           winResource->GetChildren().Append(itemResource);
       }
@@ -1217,22 +1453,41 @@ void wxResourceManager::ToBackOrFront(bool toBack)
 
 void wxResourceManager::AddSelection(wxWindow *win)
 {
-  if (!selections.Member(win))
-    selections.Append(win);
+  if (!m_selections.Member(win))
+    m_selections.Append(win);
 }
 
 void wxResourceManager::RemoveSelection(wxWindow *win)
 {
-  selections.DeleteObject(win);
+  m_selections.DeleteObject(win);
+}
+
+void wxResourceManager::DeselectItemIfNecessary(wxWindow *win)
+{
+    if (win->IsKindOf(CLASSINFO(wxControl)) && (win->GetEventHandler() != win))
+    {
+        // Deselect and refresh window in case we leave selection
+        // handles behind
+        wxControl *item = (wxControl *)win;
+        wxResourceEditorControlHandler *childHandler = (wxResourceEditorControlHandler *)item->GetEventHandler();
+        if (childHandler->IsSelected())
+        {
+            wxResourceManager::GetCurrentResourceManager()->RemoveSelection(item);
+            childHandler->SelectItem(FALSE);
+#ifndef __WXGTK__
+            item->GetParent()->Refresh();
+#endif
+        }
+    } 
 }
 
 // Need to search through resource table removing this from
 // any resource which has this as a parent.
 bool wxResourceManager::RemoveResourceFromParent(wxItemResource *res)
 {
-  resourceTable.BeginFind();
+  m_resourceTable.BeginFind();
   wxNode *node;
-  while (node = resourceTable.Next())
+  while ((node = m_resourceTable.Next()))
   {
     wxItemResource *thisRes = (wxItemResource *)node->Data();
     if (thisRes->GetChildren().Member(res))
@@ -1263,49 +1518,42 @@ bool wxResourceManager::DeleteResource(wxItemResource *res)
   // If this is a button or message resource, delete the
   // associate bitmap resource if not being used.
   wxString resType(res->GetType());
-  
-  if ((resType == "wxMessage" || resType == "wxButton") && res->GetValue4())
+
+/* shouldn't have to do this now bitmaps are ref-counted
+  if ((resType == "wxMessage" || resType == "wxStaticBitmap" || resType == "wxButton" || resType == "wxBitmapButton") && res->GetValue4())
   {
     PossiblyDeleteBitmapResource(res->GetValue4());
   }
+*/
 
-  resourceTable.Delete(res->GetName());
+  // Remove symbol from table if appropriate
+  if (!IsSymbolUsed(res, res->GetId()))
+  {
+    m_symbolTable.RemoveSymbol(res->GetId());
+  }
+
+  m_resourceTable.Delete(res->GetName());
   delete res;
   Modify(TRUE);
   return TRUE;
 }
 
-bool wxResourceManager::DeleteResource(wxWindow *win, bool deleteWindow)
+bool wxResourceManager::DeleteResource(wxWindow *win)
 {
-  if (win->IsKindOf(CLASSINFO(wxControl)))
-  {
-    // Deselect and refresh window in case we leave selection
-    // handles behind
-    wxControl *item = (wxControl *)win;
-    wxResourceEditorControlHandler *childHandler = (wxResourceEditorControlHandler *)item->GetEventHandler();
-    if (childHandler->IsSelected())
-    {
-      RemoveSelection(item);
-      childHandler->SelectItem(FALSE);
-      item->GetParent()->Refresh();
-    }
-  }
+  DeselectItemIfNecessary(win);
   
   wxItemResource *res = FindResourceForWindow(win);
   
-  DisassociateResource(res, deleteWindow);
+  DisassociateResource(res);
   DeleteResource(res);
   UpdateResourceList();
 
-  // What about associated event handler? Must clean up! BUGBUG
-//  if (win && deleteWindow)
-//    delete win;
   return TRUE;
 }
 
 // Will eventually have bitmap type information, for different
 // kinds of bitmap.
-char *wxResourceManager::AddBitmapResource(char *filename)
+wxString wxResourceManager::AddBitmapResource(const wxString& filename)
 {
   wxItemResource *resource = FindBitmapResourceByFilename(filename);
   if (!resource)
@@ -1327,32 +1575,32 @@ char *wxResourceManager::AddBitmapResource(char *filename)
     child->SetSize(0,0,0,0);
     resource->GetChildren().Append(child);
 
-    resourceTable.AddResource(resource);
+    m_resourceTable.AddResource(resource);
 
     UpdateResourceList();
   }
   if (resource)
     return resource->GetName();
   else
-    return NULL;
+    return wxEmptyString;
 }
 
  // Delete the bitmap resource if it isn't being used by another resource.
-void wxResourceManager::PossiblyDeleteBitmapResource(char *resourceName)
+void wxResourceManager::PossiblyDeleteBitmapResource(const wxString& resourceName)
 {
   if (!IsBitmapResourceUsed(resourceName))
   {
-    wxItemResource *res = resourceTable.FindResource(resourceName);
+    wxItemResource *res = m_resourceTable.FindResource(resourceName);
     DeleteResource(res);
     UpdateResourceList();
   }
 }
 
-bool wxResourceManager::IsBitmapResourceUsed(char *resourceName)
+bool wxResourceManager::IsBitmapResourceUsed(const wxString& resourceName)
 {
-  resourceTable.BeginFind();
+  m_resourceTable.BeginFind();
   wxNode *node;
-  while (node = resourceTable.Next())
+  while ((node = m_resourceTable.Next()))
   {
     wxItemResource *res = (wxItemResource *)node->Data();
     wxString resType(res->GetType());
@@ -1376,13 +1624,13 @@ bool wxResourceManager::IsBitmapResourceUsed(char *resourceName)
 }
 
 // Given a wxButton or wxMessage, find the corresponding bitmap filename.
-char *wxResourceManager::FindBitmapFilenameForResource(wxItemResource *resource)
+wxString wxResourceManager::FindBitmapFilenameForResource(wxItemResource *resource)
 {
-  if (!resource || !resource->GetValue4())
-    return NULL;
-  wxItemResource *bitmapResource = resourceTable.FindResource(resource->GetValue4());
+  if (!resource || (resource->GetValue4() == ""))
+    return wxEmptyString;
+  wxItemResource *bitmapResource = m_resourceTable.FindResource(resource->GetValue4());
   if (!bitmapResource)
-    return NULL;
+    return wxEmptyString;
 
   wxNode *node = bitmapResource->GetChildren().First();
   while (node)
@@ -1393,16 +1641,16 @@ char *wxResourceManager::FindBitmapFilenameForResource(wxItemResource *resource)
     wxItemResource *child = (wxItemResource *)node->Data();
     return child->GetName();
     
-    node = node->Next();
+    //node = node->Next();
   }
-  return NULL;
+  return wxEmptyString;
 }
 
-wxItemResource *wxResourceManager::FindBitmapResourceByFilename(char *filename)
+wxItemResource *wxResourceManager::FindBitmapResourceByFilename(const wxString& filename)
 {
-  resourceTable.BeginFind();
+  m_resourceTable.BeginFind();
   wxNode *node;
-  while (node = resourceTable.Next())
+  while ((node = m_resourceTable.Next()))
   {
     wxItemResource *res = (wxItemResource *)node->Data();
     wxString resType(res->GetType());
@@ -1421,10 +1669,149 @@ wxItemResource *wxResourceManager::FindBitmapResourceByFilename(char *filename)
   return NULL;
 }
 
+// Is this window identifier symbol in use?
+// Let's assume that we can't have 2 names for the same integer id.
+// Therefore we can tell by the integer id whether the symbol is
+// in use.
+bool wxResourceManager::IsSymbolUsed(wxItemResource* thisResource, wxWindowID id)
+{
+  m_resourceTable.BeginFind();
+  wxNode *node;
+  while ((node = m_resourceTable.Next()))
+  {
+    wxItemResource *res = (wxItemResource *)node->Data();
+
+    wxString resType(res->GetType());
+    if (resType == "wxDialog" || resType == "wxDialogBox" || resType == "wxPanel")
+    {
+      if ((res != thisResource) && (res->GetId() == id))
+          return TRUE;
+
+      wxNode *node1 = res->GetChildren().First();
+      while (node1)
+      {
+        wxItemResource *child = (wxItemResource *)node1->Data();
+        if ((child != thisResource) && (child->GetId() == id))
+          return TRUE;
+        node1 = node1->Next();
+      }
+    }
+  }
+  return FALSE;
+}
+
+// Is this window identifier compatible with the given name? (i.e.
+// does it already exist under a different name)
+bool wxResourceManager::IsIdentifierOK(const wxString& name, wxWindowID id)
+{
+    if (m_symbolTable.SymbolExists(name))
+    {
+        int foundId = m_symbolTable.GetIdForSymbol(name);
+        if (foundId != id)
+            return FALSE;
+    }
+    return TRUE;
+}
+
+// Change all integer ids that match oldId, to newId.
+// This is necessary if an id is changed for one resource - all resources
+// must be changed.
+void wxResourceManager::ChangeIds(int oldId, int newId)
+{
+  m_resourceTable.BeginFind();
+  wxNode *node;
+  while ((node = m_resourceTable.Next()))
+  {
+    wxItemResource *res = (wxItemResource *)node->Data();
+
+    wxString resType(res->GetType());
+    if (resType == "wxDialog" || resType == "wxDialogBox" || resType == "wxPanel")
+    {
+      if (res->GetId() == oldId)
+          res->SetId(newId);
+
+      wxNode *node1 = res->GetChildren().First();
+      while (node1)
+      {
+        wxItemResource *child = (wxItemResource *)node1->Data();
+        if (child->GetId() == oldId)
+            child->SetId(newId);
+
+        node1 = node1->Next();
+      }
+    }
+  }
+}
+
+// If any resource ids were missing (or their symbol was missing),
+// repair them i.e. give them new ids. Returns TRUE if any resource
+// needed repairing.
+bool wxResourceManager::RepairResourceIds()
+{
+  bool repaired = FALSE;
+
+  m_resourceTable.BeginFind();
+  wxNode *node;
+  while ((node = m_resourceTable.Next()))
+  {
+    wxItemResource *res = (wxItemResource *)node->Data();
+    wxString resType(res->GetType());
+    if (resType == "wxDialog" || resType == "wxDialogBox" || resType == "wxPanel")
+    {
+
+      if ( (res->GetId() == 0) || ((res->GetId() > 0) && !m_symbolTable.IdExists(res->GetId())) )
+      {
+          wxString newSymbolName;
+          int newId = GenerateWindowId("ID_DIALOG", newSymbolName) ;
+
+          if (res->GetId() == 0)
+          {
+              res->SetId(newId);
+              m_symbolTable.AddSymbol(newSymbolName, newId);
+          }
+          else
+          {
+              m_symbolTable.AddSymbol(newSymbolName, res->GetId());
+          }
+
+          repaired = TRUE;
+      }
+
+      wxNode *node1 = res->GetChildren().First();
+      while (node1)
+      {
+        wxItemResource *child = (wxItemResource *)node1->Data();
+
+        if ( (child->GetId() == 0) || ((child->GetId() > 0) && !m_symbolTable.IdExists(child->GetId())) )
+        {
+            wxString newSymbolName;
+            int newId = GenerateWindowId("ID_CONTROL", newSymbolName) ;
+
+            if (child->GetId() == 0)
+            {
+                child->SetId(newId);
+                m_symbolTable.AddSymbol(newSymbolName, newId);
+            }
+            else
+            {
+                m_symbolTable.AddSymbol(newSymbolName, child->GetId());
+            }
+
+            repaired = TRUE;
+        }
+
+        node1 = node1->Next();
+      }
+    }
+  }
+  return repaired;
+}
+
+
  // Deletes 'win' and creates a new window from the resource that
  // was associated with it. E.g. if you can't change properties on the
  // fly, you'll need to delete the window and create it again.
-wxWindow *wxResourceManager::RecreateWindowFromResource(wxWindow *win, wxWindowPropertyInfo *info)
+wxWindow *wxResourceManager::RecreateWindowFromResource(wxWindow *win, wxWindowPropertyInfo *info, bool instantiateFirst)
 {
   wxItemResource *resource = FindResourceForWindow(win);
 
@@ -1433,36 +1820,34 @@ wxWindow *wxResourceManager::RecreateWindowFromResource(wxWindow *win, wxWindowP
   wxWindowPropertyInfo *newInfo = NULL;
   if (!info)
   {
-    newInfo = wxCreatePropertyInfoForWindow(win);
+    newInfo = CreatePropertyInfoForWindow(win);
     info = newInfo;
   }
 
-  info->InstantiateResource(resource);
+  // May not always want to copy values back from the resource
+  if (instantiateFirst)
+    info->InstantiateResource(resource);
 
   wxWindow *newWin = NULL;
   wxWindow *parent = win->GetParent();
+  wxItemResource* parentResource = NULL;
+  if (parent)
+    parentResource = FindResourceForWindow(parent);
   
   if (win->IsKindOf(CLASSINFO(wxPanel)))
   {
-    bool isDialog = win->IsKindOf(CLASSINFO(wxDialog));
-    wxWindow *parent = win->GetParent();
-    
-    win->GetEventHandler()->OnClose();
-    
-    if (!isDialog && parent)
-    {
-      // Delete frame parent of panel if this is not a dialog box
-      parent->Close(TRUE);
-    }
-
     Edit(resource);
     newWin = FindWindowForResource(resource);
   }
   else
   {
-    DisassociateResource(resource, FALSE);
-    delete win;
-    newWin = resourceTable.CreateItem((wxPanel *)parent, resource);
+    DisassociateResource(resource);
+    if (win->GetEventHandler() != win)
+        win->PopEventHandler(TRUE);
+
+    DeleteWindow(win);
+    newWin = m_resourceTable.CreateItem((wxPanel *)parent, resource, parentResource);
+    newWin->PushEventHandler(new wxResourceEditorControlHandler((wxControl*) newWin, (wxControl*) newWin));
     AssociateResource(resource, newWin);
     UpdateResourceList();
   }
@@ -1477,39 +1862,29 @@ wxWindow *wxResourceManager::RecreateWindowFromResource(wxWindow *win, wxWindowP
 }
 
 // Delete resource highlighted in the listbox
-bool wxResourceManager::DeleteSelection(bool deleteWindow)
+bool wxResourceManager::DeleteSelection()
 {
-  int sel = editorResourceList->GetSelection();
-  if (sel > -1)
+  int sel = m_editorResourceTree->GetSelection();
+  if (sel != 0)
   {
-    wxItemResource *res = (wxItemResource *)editorResourceList->wxListBox::GetClientData(sel);
+    wxResourceTreeData *data = (wxResourceTreeData *)m_editorResourceTree->GetItemData(sel);
+    wxItemResource *res = data->GetResource();
     wxWindow *win = FindWindowForResource(res);
-/*
-    if (res == currentResource)
+    if (win)
     {
-      currentResource = NULL;
-      currentResourceWindow = NULL;
+        DeleteResource(win);
+        DeleteWindow(win);
+        UpdateResourceList();
+        Modify(TRUE);
     }
-*/
-
-    DisassociateResource(res, deleteWindow);
-    DeleteResource(res);
-    UpdateResourceList();
-
-/*
-    // What about associated event handler? Must clean up! BUGBUG
-    if (win && deleteWindow)
-      delete win;
-*/
-
-    Modify(TRUE);
+    return TRUE;
   }
 
   return FALSE;
 }
 
 // Delete resource highlighted in the listbox
-bool wxResourceManager::RecreateSelection(void)
+bool wxResourceManager::RecreateSelection()
 {
   wxNode *node = GetSelections().First();
   while (node)
@@ -1528,79 +1903,18 @@ bool wxResourceManager::RecreateSelection(void)
   return TRUE;
 }
 
-bool wxResourceManager::EditDialog(wxDialog *dialog, wxWindow *parent)
+bool wxResourceManager::EditDialog(wxDialog *WXUNUSED(dialog), wxWindow *WXUNUSED(parent))
 {
   return FALSE;
 }
 
-void wxResourceManager::SetEditMode(bool flag, bool changeCurrentResource)
-{
-  editMode = flag;
-  if (editorFrame)
-    editorFrame->SetStatusText(editMode ? "Edit mode" : "Test mode", 1);
-
-  // Switch mode for each dialog in the resource list
-  resourceTable.BeginFind();
-  wxNode *node = resourceTable.Next();
-  while (node)
-  {
-    wxItemResource *resource = (wxItemResource *)node->Data();
-    wxWindow *currentResourceWindow = FindWindowForResource(resource);
-  
-    if (changeCurrentResource && currentResourceWindow && (currentResourceWindow->IsKindOf(CLASSINFO(wxPanel))))
-    {
-      wxPanel *panel = (wxPanel *)currentResourceWindow;
-      if (editMode)
-      {
-        // If we have already installed our own handler, don't bother editing.
-        // This test will need to be changed eventually because for in-situ editing,
-        // the user might have installed a different one anyway.
-        wxEvtHandler *handler = panel->GetEventHandler();
-  	    handler->SetEvtHandlerEnabled(TRUE);
-        // Enable all children
-        wxNode *node = panel->GetChildren()->First();
-        while (node)
-        {
-          wxControl *item = (wxControl *)node->Data();
-		  if ( item->IsKindOf(CLASSINFO(wxControl)) )
-		  {
-          	wxEvtHandler *childHandler = item->GetEventHandler();
-		  	childHandler->SetEvtHandlerEnabled(TRUE);
-		  }
-          node = node->Next();
-        }
-      }
-      else
-      {
-        wxEvtHandler *handler = panel->GetEventHandler();
-		handler->SetEvtHandlerEnabled(FALSE);
-        // Deselect all items on the dialog and refresh.
-        wxNode *node = panel->GetChildren()->First();
-        while (node)
-        {
-          wxControl *item = (wxControl *)node->Data();
-          if (item->IsKindOf(CLASSINFO(wxControl)))
-	      {
-		     wxResourceEditorControlHandler *childHandler = (wxResourceEditorControlHandler *)item->GetEventHandler();
-		     childHandler->SetEvtHandlerEnabled(FALSE);
-             childHandler->SelectItem(FALSE);
- 		  }
-          node = node->Next();
-        }
-        panel->Refresh();
-      }
-    }
-    node = resourceTable.Next();
-  }
-}
-
 // Ensures that all currently shown windows are saved to resources,
 // e.g. just before writing to a .wxr file.
-bool wxResourceManager::InstantiateAllResourcesFromWindows(void)
+bool wxResourceManager::InstantiateAllResourcesFromWindows()
 {
-  resourceTable.BeginFind();
+  m_resourceTable.BeginFind();
   wxNode *node;
-  while (node = resourceTable.Next())
+  while ((node = m_resourceTable.Next()))
   {
     wxItemResource *res = (wxItemResource *)node->Data();
     wxString resType(res->GetType());
@@ -1623,7 +1937,7 @@ bool wxResourceManager::InstantiateAllResourcesFromWindows(void)
 
 bool wxResourceManager::InstantiateResourceFromWindow(wxItemResource *resource, wxWindow *window, bool recurse)
 {
-  wxWindowPropertyInfo *info = wxCreatePropertyInfoForWindow(window);
+  wxWindowPropertyInfo *info = CreatePropertyInfoForWindow(window);
   info->SetResource(resource);
   info->InstantiateResource(resource);
   delete info;
@@ -1639,7 +1953,7 @@ bool wxResourceManager::InstantiateResourceFromWindow(wxItemResource *resource,
       if (!childWindow)
       {
         char buf[200];
-        sprintf(buf, "Could not find window %s", child->GetName());
+        sprintf(buf, "Could not find window %s", (const char*) child->GetName());
         wxMessageBox(buf, "Dialog Editor problem", wxOK);
       }
       else
@@ -1651,167 +1965,313 @@ bool wxResourceManager::InstantiateResourceFromWindow(wxItemResource *resource,
   return TRUE;
 }
 
+// Create a window information object for the give window
+wxWindowPropertyInfo *wxResourceManager::CreatePropertyInfoForWindow(wxWindow *win)
+{
+  wxWindowPropertyInfo *info = NULL;
+  if (win->IsKindOf(CLASSINFO(wxScrollBar)))
+        {
+          info = new wxScrollBarPropertyInfo(win);
+        }
+  else if (win->IsKindOf(CLASSINFO(wxStaticBox)))
+        {
+          info = new wxGroupBoxPropertyInfo(win);
+        }
+  else if (win->IsKindOf(CLASSINFO(wxCheckBox)))
+        {
+          info = new wxCheckBoxPropertyInfo(win);
+        }
+  else if (win->IsKindOf(CLASSINFO(wxSlider)))
+        {
+          info = new wxSliderPropertyInfo(win);
+        }
+  else if (win->IsKindOf(CLASSINFO(wxGauge)))
+        {
+          info = new wxGaugePropertyInfo(win);
+        }
+  else if (win->IsKindOf(CLASSINFO(wxListBox)))
+        {
+          info = new wxListBoxPropertyInfo(win);
+        }
+  else if (win->IsKindOf(CLASSINFO(wxRadioBox)))
+        {
+          info = new wxRadioBoxPropertyInfo(win);
+        }
+  else if (win->IsKindOf(CLASSINFO(wxRadioButton)))
+        {
+          info = new wxRadioButtonPropertyInfo(win);
+        }
+  else if (win->IsKindOf(CLASSINFO(wxComboBox)))
+        {
+          info = new wxComboBoxPropertyInfo(win);
+        }
+  else if (win->IsKindOf(CLASSINFO(wxChoice)))
+        {
+          info = new wxChoicePropertyInfo(win);
+        }
+  else if (win->IsKindOf(CLASSINFO(wxBitmapButton)))
+        {
+          info = new wxBitmapButtonPropertyInfo(win);
+        }
+  else if (win->IsKindOf(CLASSINFO(wxButton)))
+        {
+          info = new wxButtonPropertyInfo(win);
+        }
+  else if (win->IsKindOf(CLASSINFO(wxStaticBitmap)))
+        {
+          info = new wxStaticBitmapPropertyInfo(win);
+        }
+  else if (win->IsKindOf(CLASSINFO(wxStaticText)))
+        {
+          info = new wxStaticTextPropertyInfo(win);
+        }
+  else if (win->IsKindOf(CLASSINFO(wxTextCtrl)))
+        {
+          info = new wxTextPropertyInfo(win);
+        }
+  else if (win->IsKindOf(CLASSINFO(wxPanel)))
+        {
+          info = new wxPanelPropertyInfo(win);
+        }
+  else
+        {
+          info = new wxWindowPropertyInfo(win);
+        }
+  return info;
+}
+
+// Edit the given window
+void wxResourceManager::EditWindow(wxWindow *win)
+{
+  wxWindowPropertyInfo *info = CreatePropertyInfoForWindow(win);
+  if (info)
+  {
+    info->SetResource(FindResourceForWindow(win));
+    wxString str("Editing ");
+    str += win->GetClassInfo()->GetClassName();
+    str += ": ";
+    if (win->GetName() != "")
+        str += win->GetName();
+    else
+        str += "properties";
+    info->Edit(NULL, str);
+  }
+}
+
+// Generate a window id and a first stab at a name
+int wxResourceManager::GenerateWindowId(const wxString& prefix, wxString& idName)
+{
+    m_symbolIdCounter ++;
+    while (m_symbolTable.IdExists(m_symbolIdCounter))
+        m_symbolIdCounter ++;
+
+    int nameId = m_symbolIdCounter;
+
+    wxString str;
+    str.Printf("%d", nameId);
+    idName = prefix + str;
+
+    while (m_symbolTable.SymbolExists(idName))
+    {
+        nameId ++;
+        str.Printf("%d", nameId);
+        idName = prefix + str;
+    }
+
+    return m_symbolIdCounter;
+}
+
 
 /*
  * Resource editor frame
  */
- 
-wxResourceEditorFrame::wxResourceEditorFrame(wxResourceManager *resMan, wxFrame *parent, char *title,
-    int x, int y, int width, int height, long style, char *name):
-  wxFrame(parent, -1, title, wxPoint(x, y), wxSize(width, height), style, name)
+
+IMPLEMENT_CLASS(wxResourceEditorFrame, wxFrame)
+
+BEGIN_EVENT_TABLE(wxResourceEditorFrame, wxFrame)
+    EVT_MENU(wxID_NEW, wxResourceEditorFrame::OnNew)
+    EVT_MENU(RESED_NEW_DIALOG, wxResourceEditorFrame::OnNewDialog)
+    EVT_MENU(wxID_OPEN, wxResourceEditorFrame::OnOpen)
+    EVT_MENU(RESED_CLEAR, wxResourceEditorFrame::OnClear)
+    EVT_MENU(wxID_SAVE, wxResourceEditorFrame::OnSave)
+    EVT_MENU(wxID_SAVEAS, wxResourceEditorFrame::OnSaveAs)
+    EVT_MENU(wxID_EXIT, wxResourceEditorFrame::OnExit)
+    EVT_MENU(wxID_ABOUT, wxResourceEditorFrame::OnAbout)
+    EVT_MENU(RESED_CONTENTS, wxResourceEditorFrame::OnContents)
+    EVT_MENU(RESED_DELETE, wxResourceEditorFrame::OnDeleteSelection)
+    EVT_MENU(RESED_RECREATE, wxResourceEditorFrame::OnRecreateSelection)
+    EVT_MENU(RESED_TEST, wxResourceEditorFrame::OnTest)
+    EVT_CLOSE(wxResourceEditorFrame::OnCloseWindow)
+END_EVENT_TABLE()
+
+wxResourceEditorFrame::wxResourceEditorFrame(wxResourceManager *resMan, wxFrame *parent, const wxString& title,
+    const wxPoint& pos, const wxSize& size, long style, const wxString& name):
+  wxFrame(parent, -1, title, pos, size, style, name)
 {
   manager = resMan;
 }
 
-wxResourceEditorFrame::~wxResourceEditorFrame(void)
+wxResourceEditorFrame::~wxResourceEditorFrame()
 {
 }
 
-void wxResourceEditorFrame::OldOnMenuCommand(int cmd)
+void wxResourceEditorFrame::OnNew(wxCommandEvent& WXUNUSED(event))
 {
-  switch (cmd)
-  {
-    case wxID_NEW:
-    {
       manager->New(FALSE);
-      break;
-    }
-    case RESED_NEW_DIALOG:
-    {
-      manager->CreateNewDialog();
-      break;
-    }
-    case RESED_NEW_PANEL:
-    {
+}
+
+void wxResourceEditorFrame::OnNewDialog(wxCommandEvent& WXUNUSED(event))
+{
       manager->CreateNewPanel();
-      break;
-    }
-    case wxID_OPEN:
-    {
+}
+
+void wxResourceEditorFrame::OnOpen(wxCommandEvent& WXUNUSED(event))
+{
       manager->New(TRUE);
-      break;
-    }
-    case RESED_CLEAR:
-    {
+}
+
+void wxResourceEditorFrame::OnClear(wxCommandEvent& WXUNUSED(event))
+{
       manager->Clear(TRUE, FALSE);
-      break;
-    }
-    case wxID_SAVE:
-    {
+}
+
+void wxResourceEditorFrame::OnSave(wxCommandEvent& WXUNUSED(event))
+{
       manager->Save();
-      break;
-    }
-    case wxID_SAVEAS:
-    {
+}
+
+void wxResourceEditorFrame::OnSaveAs(wxCommandEvent& WXUNUSED(event))
+{
       manager->SaveAs();
-      break;
-    }
-    case wxID_EXIT:
-    {
-	  manager->Clear(TRUE, FALSE) ;
-      this->Close();
-      break;
-    }
-    case wxID_ABOUT:
-    {
+}
+
+void wxResourceEditorFrame::OnExit(wxCommandEvent& WXUNUSED(event))
+{
+      manager->Clear(TRUE, FALSE) ;
+      this->Destroy();
+}
+
+void wxResourceEditorFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
+{
       char buf[300];
-      sprintf(buf, "wxWindows Dialog Editor %.1f\nAuthor: Julian Smart J.Smart@ed.ac.uk\nJulian Smart (c) 1996", wxDIALOG_EDITOR_VERSION);
-      (void)wxMessageBox(buf, "About Dialog Editor", wxOK|wxCENTRE);
-      break;
-    }
-    case RESED_CONTENTS:
-    {
+      sprintf(buf, "wxWindows Dialog Editor %.1f\nAuthor: Julian Smart <julian.smart@ukonline.co.uk>\nJulian Smart (c) 1996-1999", wxDIALOG_EDITOR_VERSION);
+      wxMessageBox(buf, "About Dialog Editor", wxOK|wxCENTRE);
+}
+
+void wxResourceEditorFrame::OnTest(wxCommandEvent& WXUNUSED(event))
+{
+    manager->TestCurrentDialog(this);
+}
+
+void wxResourceEditorFrame::OnContents(wxCommandEvent& WXUNUSED(event))
+{
+#ifdef __WXMSW__
       wxBeginBusyCursor();
-      manager->GetHelpInstance()->LoadFile();
-      manager->GetHelpInstance()->DisplayContents();
+      manager->GetHelpController()->LoadFile();
+      manager->GetHelpController()->DisplayContents();
       wxEndBusyCursor();
-      break;
-    }
-    case RESED_DELETE:
-    {
+#endif
+}
+
+void wxResourceEditorFrame::OnDeleteSelection(wxCommandEvent& WXUNUSED(event))
+{
       manager->DeleteSelection();
-      break;
-    }
-    case RESED_RECREATE:
-    {
+}
+
+void wxResourceEditorFrame::OnRecreateSelection(wxCommandEvent& WXUNUSED(event))
+{
       manager->RecreateSelection();
-      break;
-    }
-    case RESED_TOGGLE_TEST_MODE:
-    {
-      manager->SetEditMode(!manager->GetEditMode());
-      break;
-    }
-    default:
-      break;
-  }
 }
 
-bool wxResourceEditorFrame::OnClose(void)
+void wxResourceEditorFrame::OnCloseWindow(wxCloseEvent& event)
 {
+  wxPropertyInfo::CloseWindow();
   if (manager->Modified())
   {
-/*
-    int ans = wxMessageBox("Save modified resource file?", "Dialog Editor", wxYES_NO | wxCANCEL);
-    if (ans == wxCANCEL)
-      return FALSE;
-    if (ans == wxYES)
-      if (!manager->SaveIfModified())
-        return FALSE;
-*/
-  if (!manager->Clear(TRUE, FALSE))
-     return FALSE;
+     if (!manager->Clear(TRUE, FALSE))
+     {
+       event.Veto();
+       return;
+    }
   }
     
-  if (!Iconized())
+  if (!IsIconized())
   {
     int w, h;
     GetSize(&w, &h);
-    manager->resourceEditorWindowSize.width = w;
-    manager->resourceEditorWindowSize.height = h;
+    manager->m_resourceEditorWindowSize.width = w;
+    manager->m_resourceEditorWindowSize.height = h;
 
     int x, y;
     GetPosition(&x, &y);
 
-    manager->resourceEditorWindowSize.x = x;
-    manager->resourceEditorWindowSize.y = y;
+    manager->m_resourceEditorWindowSize.x = x;
+    manager->m_resourceEditorWindowSize.y = y;
   }
   manager->SetEditorFrame(NULL);
   manager->SetEditorToolBar(NULL);
-  manager->SetEditorPalette(NULL);
 
-  return TRUE;
+  this->Destroy();
 }
 
 /*
- * Resource editor panel
+ * Resource editor window that contains the dialog/panel being edited
  */
- 
-wxResourceEditorPanel::wxResourceEditorPanel(wxWindow *parent, int x, int y, int width, int height,
-    long style, char *name):
-  wxPanel(parent, -1, wxPoint(x, y), wxSize(width, height), style, name)
+
+BEGIN_EVENT_TABLE(wxResourceEditorScrolledWindow, wxScrolledWindow)
+    EVT_PAINT(wxResourceEditorScrolledWindow::OnPaint)
+END_EVENT_TABLE()
+
+wxResourceEditorScrolledWindow::wxResourceEditorScrolledWindow(wxWindow *parent, const wxPoint& pos, const wxSize& size,
+    long style):
+  wxScrolledWindow(parent, -1, pos, size, style)
 {
+    m_marginX = 10;
+    m_marginY = 40;
+    m_childWindow = NULL;
+
+    SetBackgroundColour(* wxWHITE);
 }
 
-wxResourceEditorPanel::~wxResourceEditorPanel(void)
+wxResourceEditorScrolledWindow::~wxResourceEditorScrolledWindow()
 {
 }
 
-void wxResourceEditorPanel::OnDefaultAction(wxControl *item)
+void wxResourceEditorScrolledWindow::OnPaint(wxPaintEvent& WXUNUSED(event))
 {
-  wxResourceEditorFrame *frame = (wxResourceEditorFrame *)GetParent();
-  wxResourceManager *manager = frame->manager;
+    wxPaintDC dc(this);
 
-  if (item == manager->GetEditorResourceList())
-  {
-    manager->EditSelectedResource();
-  }
+    DrawTitle(dc);
+}
+
+void wxResourceEditorScrolledWindow::DrawTitle(wxDC& dc)
+{
+    if (m_childWindow)
+    {
+        wxItemResource* res = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_childWindow);
+        if (res)
+        {
+            wxString str(res->GetTitle());
+            int x, y;
+            ViewStart(& x, & y);
+
+            wxFont font(10, wxSWISS, wxNORMAL, wxBOLD);
+            dc.SetFont(font);
+            dc.SetBackgroundMode(wxTRANSPARENT);
+            dc.SetTextForeground(wxColour(0, 0, 0));
+
+            long w, h;
+            dc.GetTextExtent(str, & w, & h);
+
+            dc.DrawText(str, m_marginX + (- x * 10), m_marginY + (- y * 10) - h - 5);
+        }
+    }
 }
 
 // Popup menu callback
-void ObjectMenuProc(wxMenu& menu, wxCommandEvent& event)
+void ObjectMenuProc(wxMenu *menu, wxCommandEvent& event)
 {
-  wxWindow *data = (wxWindow *)menu.GetClientData();
+  wxWindow *data = (wxWindow *)menu->GetClientData();
   if (!data)
     return;
 
@@ -1819,12 +2279,16 @@ void ObjectMenuProc(wxMenu& menu, wxCommandEvent& event)
   {
     case OBJECT_MENU_EDIT:
     {
-      wxResourceEditWindow(data);
+      wxResourceManager::GetCurrentResourceManager()->EditWindow(data);
       break;
     }
     case OBJECT_MENU_DELETE:
     {
-      wxResourceManager::currentResourceManager->DeleteResource(data);
+      wxResourceManager::GetCurrentResourceManager()->DeselectItemIfNecessary(data);
+
+      wxResourceManager::GetCurrentResourceManager()->SaveInfoAndDeleteHandler(data);
+      wxResourceManager::GetCurrentResourceManager()->DeleteResource(data);
+      wxResourceManager::GetCurrentResourceManager()->DeleteWindow(data);
       break;
     }
     default:
@@ -1832,126 +2296,25 @@ void ObjectMenuProc(wxMenu& menu, wxCommandEvent& event)
   }
 }
 
-wxWindowPropertyInfo *wxCreatePropertyInfoForWindow(wxWindow *win)
-{
-  wxWindowPropertyInfo *info = NULL;
-  if (win->IsKindOf(CLASSINFO(wxScrollBar)))
-        {
-          info = new wxScrollBarPropertyInfo(win);
-        }
-  else if (win->IsKindOf(CLASSINFO(wxStaticBox)))
-        {
-          info = new wxGroupBoxPropertyInfo(win);
-        }
-  else if (win->IsKindOf(CLASSINFO(wxCheckBox)))
-        {
-          info = new wxCheckBoxPropertyInfo(win);
-        }
-  else if (win->IsKindOf(CLASSINFO(wxSlider)))
-        {
-          info = new wxSliderPropertyInfo(win);
-        }
-  else if (win->IsKindOf(CLASSINFO(wxGauge)))
-        {
-          info = new wxGaugePropertyInfo(win);
-        }
-  else if (win->IsKindOf(CLASSINFO(wxListBox)))
-        {
-          info = new wxListBoxPropertyInfo(win);
-        }
-  else if (win->IsKindOf(CLASSINFO(wxRadioBox)))
-        {
-          info = new wxRadioBoxPropertyInfo(win);
-        }
-  else if (win->IsKindOf(CLASSINFO(wxChoice)))
-        {
-          info = new wxChoicePropertyInfo(win);
-        }
-  else if (win->IsKindOf(CLASSINFO(wxButton)))
-        {
-          info = new wxButtonPropertyInfo(win);
-/*
-          if (((wxButton *)win)->IsBitmap())
-            ((wxButtonPropertyInfo *)info)->isBitmapButton = TRUE;
-*/
-        }
-  else if (win->IsKindOf(CLASSINFO(wxStaticText)))
-        {
-          info = new wxStaticTextPropertyInfo(win);
-/*
-          if (((wxMessage *)win)->IsBitmap())
-            ((wxMessagePropertyInfo *)info)->isBitmapMessage = TRUE;
-*/
-        }
-  else if (win->IsKindOf(CLASSINFO(wxTextCtrl)))
-        {
-          info = new wxTextPropertyInfo(win);
-        }
-  else if (win->IsKindOf(CLASSINFO(wxDialog)))
-        {
-          info = new wxDialogPropertyInfo(win);
-        }
-  else if (win->IsKindOf(CLASSINFO(wxPanel)))
-        {
-          info = new wxPanelPropertyInfo(win);
-        }
-  else
-        {
-          info = new wxWindowPropertyInfo(win);
-        }
-  return info;
-}
-
-// Popup menu callback
-void wxResourceEditWindow(wxWindow *win)
-{
-  wxWindowPropertyInfo *info = wxCreatePropertyInfoForWindow(win);
-  if (info)
-  {
-    info->SetResource(wxResourceManager::currentResourceManager->FindResourceForWindow(win));
-    wxString str("Editing ");
-    str += win->GetClassInfo()->GetClassName();
-    str += ": ";
-    if (win->GetName() != "")
-        str += win->GetName();
-    else
-        str += "properties";
-    info->Edit(NULL, WXSTRINGCAST str);
-    delete info;
-  }
-}
-
 /*
  * Main toolbar
  *
  */
 
-#if defined(__WINDOWS__) && defined(__WIN95__)
-BEGIN_EVENT_TABLE(EditorToolBar, wxToolBar95)
-#elif defined(__WINDOWS__)
-BEGIN_EVENT_TABLE(EditorToolBar, wxToolBarMSW)
-#else
-BEGIN_EVENT_TABLE(EditorToolBar, wxToolBarSimple)
-#endif
-	EVT_PAINT(EditorToolBar::OnPaint)
+BEGIN_EVENT_TABLE(EditorToolBar, wxToolBar)
+//	EVT_PAINT(EditorToolBar::OnPaint)
 END_EVENT_TABLE()
 
-EditorToolBar::EditorToolBar(wxFrame *frame, int x, int y, int w, int h,
-            long style, int direction, int RowsOrColumns):
-#if defined(__WINDOWS__) && defined(__WIN95__)
-  wxToolBar95(frame, -1, wxPoint(x, y), wxSize(w, h), style, direction, RowsOrColumns)
-#elif defined(__WINDOWS__)
-  wxToolBarMSW(frame, -1, wxPoint(x, y), wxSize(w, h), style, direction, RowsOrColumns)
-#else
-  wxToolBarSimple(frame, -1, wxPoint(x, y), wxSize(w, h), style, direction, RowsOrColumns)
-#endif
+EditorToolBar::EditorToolBar(wxFrame *frame, const wxPoint& pos, const wxSize& size,
+            long style):
+  wxToolBar(frame, -1, pos, size, style)
 {
 }
 
-bool EditorToolBar::OnLeftClick(int toolIndex, bool toggled)
+bool EditorToolBar::OnLeftClick(int toolIndex, bool WXUNUSED(toggled))
 {
-  wxResourceManager *manager = wxResourceManager::currentResourceManager;
-  
+  wxResourceManager *manager = wxResourceManager::GetCurrentResourceManager();
+
   switch (toolIndex)
   {
     case TOOLBAR_LOAD_FILE:
@@ -1961,7 +2324,7 @@ bool EditorToolBar::OnLeftClick(int toolIndex, bool toggled)
     }
     case TOOLBAR_NEW:
     {
-      manager->New(FALSE);
+      manager->CreateNewPanel();
       break;
     }
     case TOOLBAR_SAVE_FILE:
@@ -1971,10 +2334,12 @@ bool EditorToolBar::OnLeftClick(int toolIndex, bool toggled)
     }
     case TOOLBAR_HELP:
     {
+#ifdef __WXMSW__
       wxBeginBusyCursor();
-      manager->GetHelpInstance()->LoadFile();
-      manager->GetHelpInstance()->DisplayContents();
+      manager->GetHelpController()->LoadFile();
+      manager->GetHelpController()->DisplayContents();
       wxEndBusyCursor();
+#endif
       break;
     }
     case TOOLBAR_FORMAT_HORIZ:
@@ -2084,31 +2449,3 @@ void EditorToolBar::OnMouseEnter(int toolIndex)
   else frame->SetStatusText("");
 }
 
-void EditorToolBar::OnPaint(wxPaintEvent& event)
-{
-#if defined(__WINDOWS__) && defined(__WIN95__)
-  wxToolBar95::OnPaint(event);
-#elif defined(__WINDOWS__)
-  wxToolBarMSW::OnPaint(event);
-#else
-  wxToolBarSimple::OnPaint(event);
-#endif
-
-  wxPaintDC dc(this);
-  int w, h;
-  GetSize(&w, &h);
-  dc.SetPen(wxBLACK_PEN);
-  dc.SetBrush(wxTRANSPARENT_BRUSH);
-  dc.DrawLine(0, h-1, w, h-1);
-}
-
-/*
- * Frame for editing a panel in
- */
- 
-bool DialogEditorPanelFrame::OnClose(void)
-{
-  wxWindow *child = (wxWindow *)GetChildren()->First()->Data();
-  wxEvtHandler *handler = child->GetEventHandler();
-  return handler->OnClose();
-}