utils/dialoged/src/reseditr.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        reseditr.cpp
   3 // Purpose:     Resource editor class
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation "reseditr.h"
  14 #endif
  15
  16 // For compilers that support precompilation, includes "wx/wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #ifdef __BORLANDC__
  20 #pragma hdrstop
  21 #endif
  22
  23 #ifndef WX_PRECOMP
  24 #include "wx/wx.h"
  25
  26 #include "wx/checkbox.h"
  27 #include "wx/button.h"
  28 #include "wx/choice.h"
  29 #include "wx/listbox.h"
  30 #include "wx/radiobox.h"
  31 #include "wx/statbox.h"
  32 #include "wx/gauge.h"
  33 #include "wx/slider.h"
  34 #include "wx/textctrl.h"
  35 #include "wx/menu.h"
  36 #include "wx/toolbar.h"
  37 #endif
  38
  39 #include "wx/scrolbar.h"
  40 #include "wx/config.h"
  41
  42 #include <ctype.h>
  43 #include <stdlib.h>
  44 #include <math.h>
  45 #include <string.h>
  46
  47 #if wxUSE_IOSTREAMH
  48 #if defined(__WXMSW__) && !defined(__GNUWIN32__)
  49 #include <strstrea.h>
  50 #else
  51 #include <strstream.h>
  52 #endif
  53 #else
  54 #include <strstream>
  55 #endif
  56
  57 #ifdef __WXMSW__
  58 #include <windows.h>
  59 #endif
  60
  61 #ifdef __WXMSW__
  62 #include "wx/help.h"
  63 #endif
  64
  65 #include "reseditr.h"
  66 #include "winprop.h"
  67 #include "dlghndlr.h"
  68 #include "edtree.h"
  69 #include "edlist.h"
  70
  71 static void ObjectMenuProc(wxMenu& menu, wxCommandEvent& event);
  72 wxResourceManager *wxResourceManager::sm_currentResourceManager = NULL;
  73
  74 #ifdef __WXGTK__
  75 #include "bitmaps/load.xpm"
  76 #include "bitmaps/save.xpm"
  77 #include "bitmaps/new.xpm"
  78 #include "bitmaps/vert.xpm"
  79 #include "bitmaps/alignt.xpm"
  80 #include "bitmaps/alignb.xpm"
  81 #include "bitmaps/horiz.xpm"
  82 #include "bitmaps/alignl.xpm"
  83 #include "bitmaps/alignr.xpm"
  84 #include "bitmaps/copysize.xpm"
  85 #include "bitmaps/tofront.xpm"
  86 #include "bitmaps/toback.xpm"
  87 #include "bitmaps/help.xpm"
  88 #include "bitmaps/wxwin.xpm"
  89 #endif
  90
  91 /*
  92  * Resource manager
  93  */
  94
  95 wxResourceManager::wxResourceManager():
  96   m_imageList(16, 16, TRUE)
  97 {
  98   sm_currentResourceManager = this;
  99   m_editorFrame = NULL;
 100   m_editorPanel = NULL;
 101   m_popupMenu = NULL;
 102   m_editorResourceTree = NULL;
 103   m_editorControlList = NULL;
 104   m_nameCounter = 1;
 105   m_symbolIdCounter = 99;
 106   m_modified = FALSE;
 107   m_currentFilename = "";
 108   m_symbolFilename = "";
 109   m_editorToolBar = NULL;
 110
 111   // Default window positions
 112   m_resourceEditorWindowSize.width = 500;
 113   m_resourceEditorWindowSize.height = 450;
 114
 115   m_resourceEditorWindowSize.x = 0;
 116   m_resourceEditorWindowSize.y = 0;
 117
 118   m_propertyWindowSize.width = 300;
 119   m_propertyWindowSize.height = 300;
 120
 121 #ifdef __WXMSW__
 122   m_helpController = NULL;
 123 #endif
 124
 125   m_bitmapImage = NULL;
 126   m_rootDialogItem = 0;
 127 }
 128
 129 wxResourceManager::~wxResourceManager()
 130 {
 131   sm_currentResourceManager = NULL;
 132   SaveOptions();
 133
 134 #ifdef __WXMSW__
 135   if (m_helpController)
 136   {
 137     m_helpController->Quit();
 138     delete m_helpController;
 139     m_helpController = NULL;
 140   }
 141 #endif
 142
 143   delete m_bitmapImage;
 144   delete m_popupMenu;
 145 }
 146
 147 bool wxResourceManager::Initialize()
 148 {
 149   // Set up the resource filename for each platform.
 150 #ifdef __WXMSW__
 151   // dialoged.ini in the Windows directory
 152   char buf[256];
 153   GetWindowsDirectory(buf, 256);
 154   strcat(buf, "\\dialoged.ini");
 155   m_optionsResourceFilename = buf;
 156 #elif defined(__WXGTK__)
 157   wxGetHomeDir( &m_optionsResourceFilename );
 158   m_optionsResourceFilename += "/.dialogedrc";
 159 #else
 160 #error "Unsupported platform."
 161 #endif
 162
 163   LoadOptions();
 164
 165 #ifdef __WXMSW__
 166   m_helpController = new wxHelpController;
 167   m_helpController->Initialize("dialoged");
 168 #endif
 169
 170   m_popupMenu = new wxMenu("", (wxFunction)ObjectMenuProc);
 171   m_popupMenu->Append(OBJECT_MENU_EDIT, "Edit properties");
 172   m_popupMenu->Append(OBJECT_MENU_DELETE, "Delete object");
 173
 174   if (!m_bitmapImage)
 175   {
 176 #ifdef __WXMSW__
 177     m_bitmapImage = new wxBitmap("WXWINBMP", wxBITMAP_TYPE_BMP_RESOURCE);
 178 #endif
 179 #ifdef __WXGTK__
 180     m_bitmapImage = new wxBitmap( wxwin_xpm );
 181 #endif
 182   }
 183
 184   // Initialize the image list icons
 185 #ifdef __WXMSW__
 186   wxIcon icon1("DIALOG_ICON", wxBITMAP_TYPE_ICO_RESOURCE, 16, 16);
 187   wxIcon icon2("FOLDER1_ICON", wxBITMAP_TYPE_ICO_RESOURCE, 16, 16);
 188   wxIcon icon3("FOLDER2_ICON", wxBITMAP_TYPE_ICO_RESOURCE, 16, 16);
 189   wxIcon icon4("BUTTONSM_ICON", wxBITMAP_TYPE_ICO_RESOURCE, 16, 16);
 190   m_imageList.Add(icon1);
 191   m_imageList.Add(icon2);
 192   m_imageList.Add(icon3);
 193   m_imageList.Add(icon4);
 194 #endif
 195
 196   m_symbolTable.AddStandardSymbols();
 197
 198   return TRUE;
 199 }
 200
 201 bool wxResourceManager::LoadOptions()
 202 {
 203   wxConfig config("DialogEd", "wxWindows");
 204
 205   config.Read("editorWindowX", &m_resourceEditorWindowSize.x);
 206   config.Read("editorWindowY", &m_resourceEditorWindowSize.y);
 207   config.Read("editorWindowWidth", &m_resourceEditorWindowSize.width);
 208   config.Read("editorWindowHeight", &m_resourceEditorWindowSize.height);
 209   config.Read("propertyWindowX", &m_propertyWindowSize.x);
 210   config.Read("propertyWindowY", &m_propertyWindowSize.y);
 211   config.Read("propertyWindowWidth", &m_propertyWindowSize.width);
 212   config.Read("propertyWindowHeight", &m_propertyWindowSize.height);
 213
 214   /*
 215   wxGetResource("DialogEd", "editorWindowX", &m_resourceEditorWindowSize.x, m_optionsResourceFilename.GetData());
 216   wxGetResource("DialogEd", "editorWindowY", &m_resourceEditorWindowSize.y, m_optionsResourceFilename.GetData());
 217   wxGetResource("DialogEd", "editorWindowWidth", &m_resourceEditorWindowSize.width, m_optionsResourceFilename.GetData());
 218   wxGetResource("DialogEd", "editorWindowHeight", &m_resourceEditorWindowSize.height, m_optionsResourceFilename.GetData());
 219   wxGetResource("DialogEd", "propertyWindowX", &m_propertyWindowSize.x, m_optionsResourceFilename.GetData());
 220   wxGetResource("DialogEd", "propertyWindowY", &m_propertyWindowSize.y, m_optionsResourceFilename.GetData());
 221   wxGetResource("DialogEd", "propertyWindowWidth", &m_propertyWindowSize.width, m_optionsResourceFilename.GetData());
 222   wxGetResource("DialogEd", "propertyWindowHeight", &m_propertyWindowSize.height, m_optionsResourceFilename.GetData());
 223   */
 224   return TRUE;
 225 }
 226
 227 bool wxResourceManager::SaveOptions()
 228 {
 229   wxConfig config("DialogEd", "wxWindows");
 230
 231   config.Write("editorWindowX", m_resourceEditorWindowSize.x);
 232   config.Write("editorWindowY", m_resourceEditorWindowSize.y);
 233   config.Write("editorWindowWidth", m_resourceEditorWindowSize.width);
 234   config.Write("editorWindowHeight", m_resourceEditorWindowSize.height);
 235   config.Write("propertyWindowX", m_propertyWindowSize.x);
 236   config.Write("propertyWindowY", m_propertyWindowSize.y);
 237   config.Write("propertyWindowWidth", m_propertyWindowSize.width);
 238   config.Write("propertyWindowHeight", m_propertyWindowSize.height);
 239   /*
 240   wxWriteResource("DialogEd", "editorWindowX", m_resourceEditorWindowSize.x, m_optionsResourceFilename.GetData());
 241   wxWriteResource("DialogEd", "editorWindowY", m_resourceEditorWindowSize.y, m_optionsResourceFilename.GetData());
 242   wxWriteResource("DialogEd", "editorWindowWidth", m_resourceEditorWindowSize.width, m_optionsResourceFilename.GetData());
 243   wxWriteResource("DialogEd", "editorWindowHeight", m_resourceEditorWindowSize.height, m_optionsResourceFilename.GetData());
 244
 245   wxWriteResource("DialogEd", "propertyWindowX", m_propertyWindowSize.x, m_optionsResourceFilename.GetData());
 246   wxWriteResource("DialogEd", "propertyWindowY", m_propertyWindowSize.y, m_optionsResourceFilename.GetData());
 247   wxWriteResource("DialogEd", "propertyWindowWidth", m_propertyWindowSize.width, m_optionsResourceFilename.GetData());
 248   wxWriteResource("DialogEd", "propertyWindowHeight", m_propertyWindowSize.height, m_optionsResourceFilename.GetData());
 249   */
 250
 251   return TRUE;
 252 }
 253
 254 // Show or hide the resource editor frame, which displays a list
 255 // of resources with ability to edit them.
 256 bool wxResourceManager::ShowResourceEditor(bool show, wxWindow *WXUNUSED(parent), const char *title)
 257 {
 258   if (show)
 259   {
 260     if (m_editorFrame)
 261     {
 262       m_editorFrame->Iconize(FALSE);
 263       m_editorFrame->Show(TRUE);
 264       return TRUE;
 265     }
 266     m_editorFrame = OnCreateEditorFrame(title);
 267     SetFrameTitle("");
 268     wxMenuBar *menuBar = OnCreateEditorMenuBar(m_editorFrame);
 269     m_editorFrame->SetMenuBar(menuBar);
 270
 271     m_editorToolBar = (EditorToolBar *)OnCreateToolBar(m_editorFrame);
 272     m_editorControlList = new wxResourceEditorControlList(m_editorFrame, IDC_LISTCTRL, wxPoint(0, 0), wxSize(-1, -1));
 273     m_editorResourceTree = new wxResourceEditorProjectTree(m_editorFrame, IDC_TREECTRL, wxPoint(0, 0), wxSize(-1, -1),
 274       wxTR_HAS_BUTTONS);
 275     m_editorPanel = OnCreateEditorPanel(m_editorFrame);
 276
 277     m_editorResourceTree->SetImageList(& m_imageList);
 278
 279     // Constraints for toolbar
 280     wxLayoutConstraints *c = new wxLayoutConstraints;
 281     c->left.SameAs       (m_editorFrame, wxLeft, 0);
 282     c->top.SameAs        (m_editorFrame, wxTop, 0);
 283     c->right.SameAs      (m_editorFrame, wxRight, 0);
 284     c->bottom.Unconstrained();
 285     c->width.Unconstrained();
 286     c->height.Absolute(28);
 287     m_editorToolBar->SetConstraints(c);
 288
 289     // Constraints for listbox
 290     c = new wxLayoutConstraints;
 291     c->left.SameAs       (m_editorFrame, wxLeft, 0);
 292     c->top.SameAs        (m_editorToolBar, wxBottom, 0);
 293     c->right.Absolute    (150);
 294     c->bottom.SameAs     (m_editorControlList, wxTop, 0);
 295     c->width.Unconstrained();
 296     c->height.Unconstrained();
 297     m_editorResourceTree->SetConstraints(c);
 298
 299     // Constraints for panel
 300     c = new wxLayoutConstraints;
 301     c->left.SameAs       (m_editorResourceTree, wxRight, 0);
 302     c->top.SameAs        (m_editorToolBar, wxBottom, 0);
 303     c->right.SameAs      (m_editorFrame, wxRight, 0);
 304     c->bottom.SameAs     (m_editorControlList, wxTop, 0);
 305     c->width.Unconstrained();
 306     c->height.Unconstrained();
 307     m_editorPanel->SetConstraints(c);
 308
 309     // Constraints for control list (bottom window)
 310     c = new wxLayoutConstraints;
 311     c->left.SameAs       (m_editorFrame, wxLeft, 0);
 312     c->right.SameAs      (m_editorFrame, wxRight, 0);
 313     c->bottom.SameAs     (m_editorFrame, wxBottom, 0);
 314     c->width.Unconstrained();
 315 #ifdef __WXGTK__
 316     c->height.Absolute(105);
 317 #else
 318     c->height.Absolute(60);
 319 #endif
 320
 321     m_editorControlList->SetConstraints(c);
 322
 323     m_editorFrame->SetAutoLayout(TRUE);
 324
 325     UpdateResourceList();
 326
 327     m_editorFrame->Show(TRUE);
 328     return TRUE;
 329   }
 330   else
 331   {
 332     wxFrame *fr = m_editorFrame;
 333     if (m_editorFrame->OnClose())
 334     {
 335       fr->Show(FALSE);
 336       delete fr;
 337       m_editorFrame = NULL;
 338       m_editorPanel = NULL;
 339     }
 340   }
 341   return TRUE;
 342 }
 343
 344 void wxResourceManager::SetFrameTitle(const wxString& filename)
 345 {
 346   if (m_editorFrame)
 347   {
 348     if (filename == wxString(""))
 349       m_editorFrame->SetTitle("wxWindows Dialog Editor - untitled");
 350     else
 351     {
 352       wxString str("wxWindows Dialog Editor - ");
 353       wxString str2(wxFileNameFromPath(WXSTRINGCAST filename));
 354       str += str2;
 355       m_editorFrame->SetTitle(str);
 356     }
 357   }
 358 }
 359
 360 bool wxResourceManager::Save()
 361 {
 362   if (m_currentFilename == wxString(""))
 363     return SaveAs();
 364   else
 365     return Save(m_currentFilename);
 366 }
 367
 368 bool wxResourceManager::Save(const wxString& filename)
 369 {
 370   // Ensure all visible windows are saved to their resources
 371   m_currentFilename = filename;
 372   SetFrameTitle(m_currentFilename);
 373   InstantiateAllResourcesFromWindows();
 374   if (m_resourceTable.Save(filename))
 375   {
 376     m_symbolTable.WriteIncludeFile(m_symbolFilename);
 377     Modify(FALSE);
 378     return TRUE;
 379   }
 380   else
 381     return FALSE;
 382 }
 383
 384 bool wxResourceManager::SaveAs()
 385 {
 386   wxString s(wxFileSelector("Save resource file", wxPathOnly(WXSTRINGCAST m_currentFilename), wxFileNameFromPath(WXSTRINGCAST m_currentFilename),
 387     "wxr", "*.wxr", wxSAVE | wxOVERWRITE_PROMPT));
 388
 389   if (s.IsNull() || s == "")
 390     return FALSE;
 391
 392   m_currentFilename = s;
 393   wxStripExtension(m_currentFilename);
 394   m_currentFilename += ".wxr";
 395
 396   // Construct include filename from this file
 397   m_symbolFilename = m_currentFilename;
 398
 399   wxStripExtension(m_symbolFilename);
 400   m_symbolFilename += ".h";
 401
 402   Save(m_currentFilename);
 403   return TRUE;
 404 }
 405
 406 bool wxResourceManager::SaveIfModified()
 407 {
 408   if (Modified())
 409     return Save();
 410   else return TRUE;
 411 }
 412
 413 bool wxResourceManager::Load(const wxString& filename)
 414 {
 415   return New(TRUE, filename);
 416 }
 417
 418 bool wxResourceManager::New(bool loadFromFile, const wxString& filename)
 419 {
 420   if (!Clear(TRUE, FALSE))
 421     return FALSE;
 422
 423   m_symbolTable.AddStandardSymbols();
 424
 425   if (loadFromFile)
 426   {
 427     wxString str = filename;
 428     if (str == wxString(""))
 429     {
 430       wxString f(wxFileSelector("Open resource file", NULL, NULL, "wxr", "*.wxr", 0, NULL));
 431       if (!f.IsNull() && f != "")
 432         str = f;
 433       else
 434         return FALSE;
 435     }
 436
 437     if (!m_resourceTable.ParseResourceFile(WXSTRINGCAST str))
 438     {
 439       wxMessageBox("Could not read file.", "Resource file load error", wxOK | wxICON_EXCLAMATION);
 440       return FALSE;
 441     }
 442     m_currentFilename = str;
 443
 444     SetFrameTitle(m_currentFilename);
 445
 446     UpdateResourceList();
 447
 448     // Construct include filename from this file
 449     m_symbolFilename = m_currentFilename;
 450
 451     wxStripExtension(m_symbolFilename);
 452     m_symbolFilename += ".h";
 453
 454     if (!m_symbolTable.ReadIncludeFile(m_symbolFilename))
 455     {
 456         wxString str("Could not find include file ");
 457         str += m_symbolFilename;
 458         str += ".\nDialog Editor maintains a header file containing id symbols to be used in the application.\n";
 459         str += "The next time this .wxr file is saved, a header file will be saved also.";
 460         wxMessageBox(str, "Dialog Editor Warning", wxOK );
 461
 462         m_symbolIdCounter = 99;
 463     }
 464     else
 465     {
 466         // Set the id counter to the last known id
 467         m_symbolIdCounter = m_symbolTable.FindHighestId();
 468     }
 469
 470     // Now check in case some (or all) resources don't have resource ids, or they
 471     // don't match the .h file, or something of that nature.
 472     bool altered = RepairResourceIds();
 473     if (altered)
 474     {
 475         wxMessageBox("Some resources have had new identifiers associated with them, since they were missing.",
 476                      "Dialog Editor Warning", wxOK );
 477         Modify(TRUE);
 478     }
 479     else
 480         Modify(FALSE);
 481
 482     return TRUE;
 483   }
 484   else
 485   {
 486     SetFrameTitle("");
 487     m_currentFilename = "";
 488   }
 489   Modify(FALSE);
 490
 491   return TRUE;
 492 }
 493
 494 bool wxResourceManager::Clear(bool WXUNUSED(deleteWindows), bool force)
 495 {
 496   if (!force && Modified())
 497   {
 498     int ans = wxMessageBox("Save modified resource file?", "Dialog Editor", wxYES_NO | wxCANCEL);
 499     if (ans == wxCANCEL)
 500       return FALSE;
 501     if (ans == wxYES)
 502       if (!SaveIfModified())
 503         return FALSE;
 504     if (ans == wxNO)
 505         Modify(FALSE);
 506   }
 507
 508   ClearCurrentDialog();
 509   DisassociateWindows();
 510
 511   m_symbolTable.Clear();
 512   m_resourceTable.ClearTable();
 513   UpdateResourceList();
 514
 515   return TRUE;
 516 }
 517
 518 bool wxResourceManager::DisassociateWindows()
 519 {
 520   m_resourceTable.BeginFind();
 521   wxNode *node;
 522   while ((node = m_resourceTable.Next()))
 523   {
 524     wxItemResource *res = (wxItemResource *)node->Data();
 525     DisassociateResource(res);
 526   }
 527
 528   return TRUE;
 529 }
 530
 531 void wxResourceManager::AssociateResource(wxItemResource *resource, wxWindow *win)
 532 {
 533   if (!m_resourceAssociations.Get((long)resource))
 534     m_resourceAssociations.Put((long)resource, win);
 535
 536   wxNode *node = resource->GetChildren().First();
 537   while (node)
 538   {
 539     wxItemResource *child = (wxItemResource *)node->Data();
 540     wxWindow *childWindow = (wxWindow *)m_resourceAssociations.Get((long)child);
 541     if (!childWindow)
 542       childWindow = win->FindWindow(child->GetName());
 543     if (childWindow)
 544       AssociateResource(child, childWindow);
 545     else
 546     {
 547       char buf[200];
 548       sprintf(buf, "AssociateResource: cannot find child window %s", child->GetName() ? (const char*) child->GetName() : "(unnamed)");
 549       wxMessageBox(buf, "Dialog Editor problem", wxOK);
 550     }
 551
 552     node = node->Next();
 553   }
 554 }
 555
 556 bool wxResourceManager::DisassociateResource(wxItemResource *resource)
 557 {
 558   wxWindow *win = FindWindowForResource(resource);
 559   if (!win)
 560     return FALSE;
 561
 562   // Disassociate children of window
 563   wxNode *node = win->GetChildren().First();
 564   while (node)
 565   {
 566     wxWindow *child = (wxWindow *)node->Data();
 567     if (child->IsKindOf(CLASSINFO(wxControl)))
 568             DisassociateResource(child);
 569     node = node->Next();
 570   }
 571
 572   RemoveSelection(win);
 573   m_resourceAssociations.Delete((long)resource);
 574   return TRUE;
 575 }
 576
 577 bool wxResourceManager::DisassociateResource(wxWindow *win)
 578 {
 579   wxItemResource *res = FindResourceForWindow(win);
 580   if (res)
 581     return DisassociateResource(res);
 582   else
 583     return FALSE;
 584 }
 585
 586 // Saves the window info into the resource, and deletes the
 587 // handler. Doesn't actually disassociate the window from
 588 // the resources. Replaces OnClose.
 589 bool wxResourceManager::SaveInfoAndDeleteHandler(wxWindow* win)
 590 {
 591     wxItemResource *res = FindResourceForWindow(win);
 592
 593     if (win->IsKindOf(CLASSINFO(wxPanel)))
 594     {
 595         wxResourceEditorDialogHandler* handler = (wxResourceEditorDialogHandler*) win->GetEventHandler();
 596         win->PopEventHandler();
 597
 598         // Now reset all child event handlers
 599         wxNode *node = win->GetChildren().First();
 600         while ( node )
 601         {
 602                 wxWindow *child = (wxWindow *)node->Data();
 603                 wxEvtHandler *childHandler = child->GetEventHandler();
 604                 if ( child->IsKindOf(CLASSINFO(wxControl)) && childHandler != child )
 605                 {
 606                         child->PopEventHandler(TRUE);
 607                 }
 608                 node = node->Next();
 609         }
 610         delete handler;
 611     }
 612     else
 613     {
 614         win->PopEventHandler(TRUE);
 615     }
 616
 617     // Save the information
 618     InstantiateResourceFromWindow(res, win, TRUE);
 619
 620 //  DisassociateResource(win);
 621
 622     return TRUE;
 623 }
 624
 625 // Destroys the window. If this is the 'current' panel, NULLs the
 626 // variable.
 627 bool wxResourceManager::DeleteWindow(wxWindow* win)
 628 {
 629     bool clearDisplay = FALSE;
 630     if (m_editorPanel->m_childWindow == win)
 631     {
 632         m_editorPanel->m_childWindow = NULL;
 633         clearDisplay = TRUE;
 634     }
 635
 636     win->Destroy();
 637
 638     if (clearDisplay)
 639         m_editorPanel->Clear();
 640
 641     return TRUE;
 642 }
 643
 644 wxItemResource *wxResourceManager::FindResourceForWindow(wxWindow *win)
 645 {
 646   m_resourceAssociations.BeginFind();
 647   wxNode *node;
 648   while ((node = m_resourceAssociations.Next()))
 649   {
 650     wxWindow *w = (wxWindow *)node->Data();
 651     if (w == win)
 652     {
 653       return (wxItemResource *)node->GetKeyInteger();
 654     }
 655   }
 656   return NULL;
 657 }
 658
 659 wxWindow *wxResourceManager::FindWindowForResource(wxItemResource *resource)
 660 {
 661   return (wxWindow *)m_resourceAssociations.Get((long)resource);
 662 }
 663
 664
 665 void wxResourceManager::MakeUniqueName(char *prefix, char *buf)
 666 {
 667   while (TRUE)
 668   {
 669     sprintf(buf, "%s%d", prefix, m_nameCounter);
 670     m_nameCounter ++;
 671
 672     if (!m_resourceTable.FindResource(buf))
 673       return;
 674   }
 675 }
 676
 677 wxFrame *wxResourceManager::OnCreateEditorFrame(const char *title)
 678 {
 679   /*
 680   int frameWidth = 420;
 681   int frameHeight = 300;
 682   */
 683
 684   wxResourceEditorFrame *frame = new wxResourceEditorFrame(this, NULL, title,
 685     wxPoint(m_resourceEditorWindowSize.x, m_resourceEditorWindowSize.y),
 686     wxSize(m_resourceEditorWindowSize.width, m_resourceEditorWindowSize.height),
 687     wxDEFAULT_FRAME_STYLE);
 688
 689   frame->CreateStatusBar(1);
 690
 691   frame->SetAutoLayout(TRUE);
 692 #ifdef __WXMSW__
 693   frame->SetIcon(wxIcon("DIALOGEDICON"));
 694 #endif
 695   return frame;
 696 }
 697
 698 wxMenuBar *wxResourceManager::OnCreateEditorMenuBar(wxFrame *WXUNUSED(parent))
 699 {
 700   wxMenuBar *menuBar = new wxMenuBar;
 701
 702   wxMenu *fileMenu = new wxMenu;
 703   fileMenu->Append(RESED_NEW_DIALOG, "New &dialog", "Create a new dialog");
 704   fileMenu->AppendSeparator();
 705   fileMenu->Append(wxID_NEW, "&New project",           "Clear the current project");
 706   fileMenu->Append(wxID_OPEN, "&Open...",         "Load a resource file");
 707   fileMenu->Append(wxID_SAVE, "&Save",            "Save a resource file");
 708   fileMenu->Append(wxID_SAVEAS, "Save &As...",   "Save a resource file as...");
 709   fileMenu->Append(RESED_CLEAR, "&Clear",   "Clear current resources");
 710   fileMenu->AppendSeparator();
 711   fileMenu->Append(wxID_EXIT, "E&xit",            "Exit resource editor");
 712
 713   wxMenu *editMenu = new wxMenu;
 714   editMenu->Append(RESED_TEST, "&Test Dialog",  "Test dialog");
 715   editMenu->Append(RESED_RECREATE, "&Recreate",  "Recreate the selected resource(s)");
 716   editMenu->Append(RESED_DELETE, "&Delete",  "Delete the selected resource(s)");
 717
 718   wxMenu *helpMenu = new wxMenu;
 719   helpMenu->Append(RESED_CONTENTS, "&Help topics",          "Invokes the on-line help");
 720   helpMenu->AppendSeparator();
 721   helpMenu->Append(wxID_ABOUT, "&About",          "About wxWindows Dialog Editor");
 722
 723   menuBar->Append(fileMenu, "&File");
 724   menuBar->Append(editMenu, "&Edit");
 725   menuBar->Append(helpMenu, "&Help");
 726
 727   return menuBar;
 728 }
 729
 730 wxResourceEditorScrolledWindow *wxResourceManager::OnCreateEditorPanel(wxFrame *parent)
 731 {
 732   wxResourceEditorScrolledWindow *panel = new wxResourceEditorScrolledWindow(parent, wxDefaultPosition, wxDefaultSize,
 733 //    wxSUNKEN_BORDER|wxCLIP_CHILDREN);
 734     wxSUNKEN_BORDER);
 735
 736   panel->SetScrollbars(10, 10, 100, 100);
 737
 738   return panel;
 739 }
 740
 741 wxToolBar *wxResourceManager::OnCreateToolBar(wxFrame *parent)
 742 {
 743   // Load palette bitmaps
 744 #ifdef __WXMSW__
 745   wxBitmap ToolbarLoadBitmap("LOADTOOL");
 746   wxBitmap ToolbarSaveBitmap("SAVETOOL");
 747   wxBitmap ToolbarNewBitmap("NEWTOOL");
 748   wxBitmap ToolbarVertBitmap("VERTTOOL");
 749   wxBitmap ToolbarAlignTBitmap("ALIGNTTOOL");
 750   wxBitmap ToolbarAlignBBitmap("ALIGNBTOOL");
 751   wxBitmap ToolbarHorizBitmap("HORIZTOOL");
 752   wxBitmap ToolbarAlignLBitmap("ALIGNLTOOL");
 753   wxBitmap ToolbarAlignRBitmap("ALIGNRTOOL");
 754   wxBitmap ToolbarCopySizeBitmap("COPYSIZETOOL");
 755   wxBitmap ToolbarToBackBitmap("TOBACKTOOL");
 756   wxBitmap ToolbarToFrontBitmap("TOFRONTTOOL");
 757   wxBitmap ToolbarHelpBitmap("HELPTOOL");
 758 #endif
 759 #ifdef __WXGTK__
 760   wxBitmap ToolbarLoadBitmap( load_xpm );
 761   wxBitmap ToolbarSaveBitmap( save_xpm);
 762   wxBitmap ToolbarNewBitmap( new_xpm );
 763   wxBitmap ToolbarVertBitmap( vert_xpm );
 764   wxBitmap ToolbarAlignTBitmap( alignt_xpm );
 765   wxBitmap ToolbarAlignBBitmap( alignb_xpm );
 766   wxBitmap ToolbarHorizBitmap( horiz_xpm );
 767   wxBitmap ToolbarAlignLBitmap( alignl_xpm );
 768   wxBitmap ToolbarAlignRBitmap( alignr_xpm );
 769   wxBitmap ToolbarCopySizeBitmap( copysize_xpm );
 770   wxBitmap ToolbarToBackBitmap( toback_xpm );
 771   wxBitmap ToolbarToFrontBitmap( tofront_xpm );
 772   wxBitmap ToolbarHelpBitmap( help_xpm );
 773 #endif
 774
 775   // Create the toolbar
 776   EditorToolBar *toolbar = new EditorToolBar(parent, wxPoint(0, 0), wxSize(-1, -1), wxNO_BORDER|wxTB_HORIZONTAL);
 777   toolbar->SetMargins(2, 2);
 778
 779 #ifdef __WXMSW__
 780   int width = 24;
 781   int dx = 2;
 782   int gap = 6;
 783 #else
 784   int width = 24; // ToolbarLoadBitmap->GetWidth();  ???
 785   int dx = 2;
 786   int gap = 6;
 787 #endif
 788   int currentX = gap;
 789   toolbar->AddSeparator();
 790   toolbar->AddTool(TOOLBAR_NEW, ToolbarNewBitmap, wxNullBitmap,
 791                    FALSE, (float)currentX, -1, NULL, "New dialog");
 792   currentX += width + dx;
 793   toolbar->AddTool(TOOLBAR_LOAD_FILE, ToolbarLoadBitmap, wxNullBitmap,
 794                    FALSE, (float)currentX, -1, NULL, "Load");
 795   currentX += width + dx;
 796   toolbar->AddTool(TOOLBAR_SAVE_FILE, ToolbarSaveBitmap, wxNullBitmap,
 797                    FALSE, (float)currentX, -1, NULL, "Save");
 798   currentX += width + dx + gap;
 799   toolbar->AddSeparator();
 800   toolbar->AddTool(TOOLBAR_FORMAT_HORIZ, ToolbarVertBitmap, wxNullBitmap,
 801                    FALSE, (float)currentX, -1, NULL, "Horizontal align");
 802   currentX += width + dx;
 803   toolbar->AddTool(TOOLBAR_FORMAT_VERT_TOP_ALIGN, ToolbarAlignTBitmap, wxNullBitmap,
 804                    FALSE, (float)currentX, -1, NULL, "Top align");
 805   currentX += width + dx;
 806   toolbar->AddTool(TOOLBAR_FORMAT_VERT_BOT_ALIGN, ToolbarAlignBBitmap, wxNullBitmap,
 807                    FALSE, (float)currentX, -1, NULL, "Bottom align");
 808   currentX += width + dx;
 809   toolbar->AddTool(TOOLBAR_FORMAT_VERT, ToolbarHorizBitmap, wxNullBitmap,
 810                    FALSE, (float)currentX, -1, NULL, "Vertical align");
 811   currentX += width + dx;
 812   toolbar->AddTool(TOOLBAR_FORMAT_HORIZ_LEFT_ALIGN, ToolbarAlignLBitmap, wxNullBitmap,
 813                    FALSE, (float)currentX, -1, NULL, "Left align");
 814   currentX += width + dx;
 815   toolbar->AddTool(TOOLBAR_FORMAT_HORIZ_RIGHT_ALIGN, ToolbarAlignRBitmap, wxNullBitmap,
 816                    FALSE, (float)currentX, -1, NULL, "Right align");
 817   currentX += width + dx;
 818   toolbar->AddTool(TOOLBAR_COPY_SIZE, ToolbarCopySizeBitmap, wxNullBitmap,
 819                    FALSE, (float)currentX, -1, NULL, "Copy size");
 820   currentX += width + dx + gap;
 821   toolbar->AddSeparator();
 822   toolbar->AddTool(TOOLBAR_TO_FRONT, ToolbarToFrontBitmap, wxNullBitmap,
 823                    FALSE, (float)currentX, -1, NULL, "To front");
 824   currentX += width + dx;
 825   toolbar->AddTool(TOOLBAR_TO_BACK, ToolbarToBackBitmap, wxNullBitmap,
 826                    FALSE, (float)currentX, -1, NULL, "To back");
 827   currentX += width + dx + gap;
 828
 829   toolbar->AddSeparator();
 830   toolbar->AddTool(TOOLBAR_HELP, ToolbarHelpBitmap, wxNullBitmap,
 831                    FALSE, (float)currentX, -1, NULL, "Help");
 832   currentX += width + dx;
 833
 834   toolbar->Realize();
 835
 836   return toolbar;
 837 }
 838
 839 void wxResourceManager::UpdateResourceList()
 840 {
 841   if (!m_editorResourceTree)
 842       return;
 843
 844   m_editorResourceTree->SetInvalid(TRUE);
 845   m_editorResourceTree->DeleteAllItems();
 846
 847   long id = m_editorResourceTree->AddRoot("Dialogs", 1, 2);
 848
 849   m_resourceTable.BeginFind();
 850   wxNode *node;
 851   while ((node = m_resourceTable.Next()))
 852   {
 853     wxItemResource *res = (wxItemResource *)node->Data();
 854     wxString resType(res->GetType());
 855     if (resType == "wxDialog" || resType == "wxDialogBox" || resType == "wxPanel" || resType == "wxBitmap")
 856     {
 857       AddItemsRecursively(id, res);
 858     }
 859   }
 860   m_editorResourceTree->Expand(id);
 861   m_editorResourceTree->SetInvalid(FALSE);
 862 }
 863
 864 void wxResourceManager::AddItemsRecursively(long parent, wxItemResource *resource)
 865 {
 866   wxString theString("");
 867   theString = resource->GetName();
 868
 869   int imageId = 0;
 870   wxString resType(resource->GetType());
 871   if (resType == "wxDialog" || resType == "wxDialogBox" || resType == "wxPanel")
 872     imageId = 0;
 873   else
 874     imageId = 3;
 875
 876   long id = m_editorResourceTree->AppendItem(parent, theString, imageId );
 877
 878   m_editorResourceTree->SetItemData(id, new wxResourceTreeData(resource));
 879
 880   if (strcmp(resource->GetType(), "wxBitmap") != 0)
 881   {
 882     wxNode *node = resource->GetChildren().First();
 883     while (node)
 884     {
 885       wxItemResource *res = (wxItemResource *)node->Data();
 886       AddItemsRecursively(id, res);
 887       node = node->Next();
 888     }
 889   }
 890 //  m_editorResourceTree->ExpandItem(id, wxTREE_EXPAND_EXPAND);
 891 }
 892
 893 bool wxResourceManager::EditSelectedResource()
 894 {
 895   int sel = m_editorResourceTree->GetSelection();
 896   if (sel != 0)
 897   {
 898     wxResourceTreeData *data = (wxResourceTreeData *)m_editorResourceTree->GetItemData(sel);
 899     wxItemResource *res = data->GetResource();
 900     return Edit(res);
 901   }
 902   return FALSE;
 903 }
 904
 905 bool wxResourceManager::Edit(wxItemResource *res)
 906 {
 907   ClearCurrentDialog();
 908
 909   wxString resType(res->GetType());
 910   wxPanel *panel = (wxPanel *)FindWindowForResource(res);
 911
 912   if (panel)
 913   {
 914     wxMessageBox("Should not find panel in wxResourceManager::Edit");
 915     return FALSE;
 916   }
 917   else
 918   {
 919 //        long style = res->GetStyle();
 920 //        res->SetStyle(style|wxRAISED_BORDER);
 921         panel = new wxPanel;
 922         wxResourceEditorDialogHandler *handler = new wxResourceEditorDialogHandler(panel, res, panel->GetEventHandler(),
 923            this);
 924
 925         panel->LoadFromResource(m_editorPanel, res->GetName(), &m_resourceTable);
 926
 927         panel->PushEventHandler(handler);
 928
 929 //        res->SetStyle(style);
 930                 handler->AddChildHandlers(); // Add event handlers for all controls
 931         AssociateResource(res, panel);
 932
 933         m_editorPanel->m_childWindow = panel;
 934         panel->Move(m_editorPanel->GetMarginX(), m_editorPanel->GetMarginY());
 935         panel->Show(TRUE);
 936         panel->Refresh();
 937
 938         wxClientDC dc(m_editorPanel);
 939         m_editorPanel->DrawTitle(dc);
 940   }
 941   return FALSE;
 942 }
 943
 944 bool wxResourceManager::CreateNewPanel()
 945 {
 946   ClearCurrentDialog();
 947
 948   char buf[256];
 949   MakeUniqueName("dialog", buf);
 950
 951   wxItemResource *resource = new wxItemResource;
 952   resource->SetType("wxDialog");
 953   resource->SetName(buf);
 954   resource->SetTitle(buf);
 955   resource->SetResourceStyle(wxRESOURCE_USE_DEFAULTS);
 956   resource->SetResourceStyle(wxRESOURCE_DIALOG_UNITS);
 957
 958   wxString newIdName;
 959   int id = GenerateWindowId("ID_DIALOG", newIdName);
 960   resource->SetId(id);
 961
 962   // This is now guaranteed to be unique, so just add to symbol table
 963   m_symbolTable.AddSymbol(newIdName, id);
 964
 965   m_resourceTable.AddResource(resource);
 966
 967   wxSize size(400, 300);
 968
 969   wxPanel *panel = new wxPanel(m_editorPanel, -1,
 970      wxPoint(m_editorPanel->GetMarginX(), m_editorPanel->GetMarginY()),
 971      size, wxRAISED_BORDER|wxDEFAULT_DIALOG_STYLE, buf);
 972   m_editorPanel->m_childWindow = panel;
 973
 974   resource->SetStyle(panel->GetWindowStyleFlag());
 975
 976   // Store dialog units in resource
 977   size = panel->ConvertPixelsToDialog(size);
 978
 979   resource->SetSize(10, 10, size.x, size.y);
 980
 981   // For editing in situ we will need to use the hash table to ensure
 982   // we don't dereference invalid pointers.
 983 //  resourceWindowTable.Put((long)resource, panel);
 984
 985   wxResourceEditorDialogHandler *handler = new wxResourceEditorDialogHandler(panel, resource, panel->GetEventHandler(),
 986    this);
 987   panel->PushEventHandler(handler);
 988
 989   AssociateResource(resource, panel);
 990   UpdateResourceList();
 991
 992   Modify(TRUE);
 993   m_editorPanel->m_childWindow->Refresh();
 994
 995 //  panel->Refresh();
 996
 997   wxClientDC dc(m_editorPanel);
 998   m_editorPanel->DrawTitle(dc);
 999
1000   return TRUE;
1001 }
1002
1003 bool wxResourceManager::CreatePanelItem(wxItemResource *panelResource, wxPanel *panel, char *iType, int x, int y, bool isBitmap)
1004 {
1005   char buf[256];
1006   if (!panel->IsKindOf(CLASSINFO(wxPanel)) && !panel->IsKindOf(CLASSINFO(wxDialog)))
1007     return FALSE;
1008
1009   Modify(TRUE);
1010
1011   wxItemResource *res = new wxItemResource;
1012   wxControl *newItem = NULL;
1013
1014   if ((panelResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS) != 0)
1015   {
1016     wxPoint pt = panel->ConvertPixelsToDialog(wxPoint(x, y));
1017     res->SetSize(pt.x, pt.y, -1, -1);
1018   }
1019   else res->SetSize(x, y, -1, -1);
1020
1021   res->SetType(iType);
1022
1023   wxString prefix;
1024
1025   wxString itemType(iType);
1026
1027   if (itemType == "wxButton")
1028     {
1029       prefix = "ID_BUTTON";
1030       MakeUniqueName("button", buf);
1031       res->SetName(buf);
1032       if (isBitmap)
1033         newItem = new wxBitmapButton(panel, -1, * m_bitmapImage, wxPoint(x, y), wxSize(-1, -1), 0, wxDefaultValidator, buf);
1034       else
1035         newItem = new wxButton(panel, -1, "Button", wxPoint(x, y), wxSize(-1, -1), 0, wxDefaultValidator, buf);
1036     }
1037   if (itemType == "wxBitmapButton")
1038     {
1039       prefix = "ID_BITMAPBUTTON";
1040       MakeUniqueName("button", buf);
1041       res->SetName(buf);
1042       newItem = new wxBitmapButton(panel, -1, * m_bitmapImage, wxPoint(x, y), wxSize(-1, -1), 0, wxDefaultValidator, buf);
1043     }
1044   else if (itemType == "wxMessage" || itemType == "wxStaticText")
1045     {
1046       prefix = "ID_STATIC";
1047       MakeUniqueName("statictext", buf);
1048       res->SetName(buf);
1049       if (isBitmap)
1050         newItem = new wxStaticBitmap(panel, -1, * m_bitmapImage, wxPoint(x, y), wxSize(0, 0), 0, buf);
1051       else
1052         newItem = new wxStaticText(panel, -1, "Static", wxPoint(x, y), wxSize(-1, -1), 0, buf);
1053     }
1054   else if (itemType == "wxStaticBitmap")
1055     {
1056       prefix = "ID_STATICBITMAP";
1057       MakeUniqueName("static", buf);
1058       res->SetName(buf);
1059       newItem = new wxStaticBitmap(panel, -1, * m_bitmapImage, wxPoint(x, y), wxSize(-1, -1), 0, buf);
1060     }
1061   else if (itemType == "wxCheckBox")
1062     {
1063       prefix = "ID_CHECKBOX";
1064       MakeUniqueName("checkbox", buf);
1065       res->SetName(buf);
1066       newItem = new wxCheckBox(panel, -1, "Checkbox", wxPoint(x, y), wxSize(-1, -1), 0, wxDefaultValidator, buf);
1067     }
1068   else if (itemType == "wxListBox")
1069     {
1070       prefix = "ID_LISTBOX";
1071       MakeUniqueName("listbox", buf);
1072       res->SetName(buf);
1073       newItem = new wxListBox(panel, -1, wxPoint(x, y), wxSize(-1, -1), 0, NULL, 0, wxDefaultValidator, buf);
1074     }
1075   else if (itemType == "wxRadioBox")
1076     {
1077       prefix = "ID_RADIOBOX";
1078       MakeUniqueName("radiobox", buf);
1079       res->SetName(buf);
1080       wxString names[] = { "One", "Two" };
1081       newItem = new wxRadioBox(panel, -1, "Radiobox", wxPoint(x, y), wxSize(-1, -1), 2, names, 2,
1082              wxHORIZONTAL, wxDefaultValidator, buf);
1083       res->SetStringValues(wxStringList("One", "Two", NULL));
1084     }
1085   else if (itemType == "wxRadioButton")
1086     {
1087       prefix = "ID_RADIOBUTTON";
1088       MakeUniqueName("radiobutton", buf);
1089       res->SetName(buf);
1090       wxString names[] = { "One", "Two" };
1091       newItem = new wxRadioButton(panel, -1, "Radiobutton", wxPoint(x, y), wxSize(-1, -1),
1092              0, wxDefaultValidator, buf);
1093     }
1094   else if (itemType == "wxChoice")
1095     {
1096       prefix = "ID_CHOICE";
1097       MakeUniqueName("choice", buf);
1098       res->SetName(buf);
1099       newItem = new wxChoice(panel, -1, wxPoint(x, y), wxSize(-1, -1), 0, NULL, 0, wxDefaultValidator, buf);
1100     }
1101   else if (itemType == "wxComboBox")
1102     {
1103       prefix = "ID_COMBOBOX";
1104       MakeUniqueName("combobox", buf);
1105       res->SetName(buf);
1106       newItem = new wxComboBox(panel, -1, "", wxPoint(x, y), wxSize(-1, -1), 0, NULL, wxCB_DROPDOWN, wxDefaultValidator, buf);
1107     }
1108   else if (itemType == "wxGroupBox" || itemType == "wxStaticBox")
1109     {
1110       prefix = "ID_STATICBOX";
1111       MakeUniqueName("staticbox", buf);
1112       res->SetName(buf);
1113       newItem = new wxStaticBox(panel, -1, "Static", wxPoint(x, y), wxSize(200, 200), 0, buf);
1114     }
1115   else if (itemType == "wxGauge")
1116     {
1117       prefix = "ID_GAUGE";
1118       MakeUniqueName("gauge", buf);
1119       res->SetName(buf);
1120       newItem = new wxGauge(panel, -1, 10, wxPoint(x, y), wxSize(80, 30), wxHORIZONTAL, wxDefaultValidator, buf);
1121     }
1122   else if (itemType == "wxSlider")
1123     {
1124       prefix = "ID_SLIDER";
1125       MakeUniqueName("slider", buf);
1126       res->SetName(buf);
1127       newItem = new wxSlider(panel, -1, 1, 1, 10, wxPoint(x, y), wxSize(120, -1), wxHORIZONTAL, wxDefaultValidator, buf);
1128     }
1129   else if (itemType == "wxText" || itemType == "wxTextCtrl (single-line)")
1130     {
1131       prefix = "ID_TEXTCTRL";
1132       MakeUniqueName("textctrl", buf);
1133       res->SetName(buf);
1134       res->SetType("wxTextCtrl");
1135       newItem = new wxTextCtrl(panel, -1, "", wxPoint(x, y), wxSize(120, -1), 0, wxDefaultValidator, buf);
1136     }
1137   else if (itemType == "wxMultiText" || itemType == "wxTextCtrl (multi-line)")
1138     {
1139       prefix = "ID_TEXTCTRL";
1140       MakeUniqueName("textctrl", buf);
1141       res->SetName(buf);
1142       res->SetType("wxTextCtrl");
1143       newItem = new wxTextCtrl(panel, -1, "", wxPoint(x, y), wxSize(120, 100), wxTE_MULTILINE, wxDefaultValidator, buf);
1144     }
1145   else if (itemType == "wxScrollBar")
1146     {
1147       prefix = "ID_SCROLLBAR";
1148       MakeUniqueName("scrollbar", buf);
1149       res->SetName(buf);
1150       newItem = new wxScrollBar(panel, -1, wxPoint(x, y), wxSize(140, -1), wxHORIZONTAL, wxDefaultValidator, buf);
1151     }
1152   if (!newItem)
1153     return FALSE;
1154
1155   int actualW, actualH;
1156   newItem->GetSize(&actualW, &actualH);
1157   wxSize actualSize(actualW, actualH);
1158
1159   if ((panelResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS) != 0)
1160   {
1161     actualSize = panel->ConvertPixelsToDialog(actualSize);
1162   }
1163   res->SetSize(res->GetX(), res->GetY(), actualSize.x, actualSize.y);
1164
1165   wxString newIdName;
1166   int id = GenerateWindowId(prefix, newIdName);
1167   res->SetId(id);
1168
1169   // This is now guaranteed to be unique, so just add to symbol table
1170   m_symbolTable.AddSymbol(newIdName, id);
1171
1172   newItem->PushEventHandler(new wxResourceEditorControlHandler(newItem, newItem));
1173
1174   res->SetStyle(newItem->GetWindowStyleFlag());
1175   AssociateResource(res, newItem);
1176   panelResource->GetChildren().Append(res);
1177
1178   UpdateResourceList();
1179
1180   return TRUE;
1181 }
1182
1183 void wxResourceManager::ClearCurrentDialog()
1184 {
1185   if (m_editorPanel->m_childWindow)
1186   {
1187     SaveInfoAndDeleteHandler(m_editorPanel->m_childWindow);
1188     DisassociateResource(m_editorPanel->m_childWindow);
1189     DeleteWindow(m_editorPanel->m_childWindow);
1190     m_editorPanel->m_childWindow = NULL;
1191     m_editorPanel->Clear();
1192   }
1193 }
1194
1195 bool wxResourceManager::TestCurrentDialog(wxWindow* parent)
1196 {
1197   if (m_editorPanel->m_childWindow)
1198   {
1199     wxItemResource* item = FindResourceForWindow(m_editorPanel->m_childWindow);
1200     if (!item)
1201         return FALSE;
1202
1203     // Make sure the resources are up-to-date w.r.t. the window
1204     InstantiateResourceFromWindow(item, m_editorPanel->m_childWindow, TRUE);
1205
1206     wxDialog* dialog = new wxDialog;
1207     bool success = FALSE;
1208     if (dialog->LoadFromResource(parent, item->GetName(), & m_resourceTable))
1209     {
1210         dialog->Centre();
1211         dialog->ShowModal();
1212         success = TRUE;
1213     }
1214     return success;
1215   }
1216   return FALSE;
1217 }
1218
1219 // Find the first dialog or panel for which
1220 // there is a selected panel item.
1221 wxWindow *wxResourceManager::FindParentOfSelection()
1222 {
1223   m_resourceTable.BeginFind();
1224   wxNode *node;
1225   while ((node = m_resourceTable.Next()))
1226   {
1227     wxItemResource *res = (wxItemResource *)node->Data();
1228     wxWindow *win = FindWindowForResource(res);
1229     if (win)
1230     {
1231       wxNode *node1 = win->GetChildren().First();
1232       while (node1)
1233       {
1234         wxControl *item = (wxControl *)node1->Data();
1235             wxResourceEditorControlHandler *childHandler = (wxResourceEditorControlHandler *)item->GetEventHandler();
1236         if (item->IsKindOf(CLASSINFO(wxControl)) && childHandler->IsSelected())
1237           return win;
1238         node1 = node1->Next();
1239       }
1240     }
1241   }
1242   return NULL;
1243 }
1244
1245 // Format the panel items according to 'flag'
1246 void wxResourceManager::AlignItems(int flag)
1247 {
1248   wxWindow *win = FindParentOfSelection();
1249   if (!win)
1250     return;
1251
1252   wxNode *node = GetSelections().First();
1253   if (!node)
1254     return;
1255
1256   wxControl *firstSelection = (wxControl *)node->Data();
1257   if (firstSelection->GetParent() != win)
1258     return;
1259
1260   int firstX, firstY;
1261   int firstW, firstH;
1262   firstSelection->GetPosition(&firstX, &firstY);
1263   firstSelection->GetSize(&firstW, &firstH);
1264   int centreX = (int)(firstX + (firstW / 2));
1265   int centreY = (int)(firstY + (firstH / 2));
1266
1267   while ((node = node->Next()))
1268   {
1269     wxControl *item = (wxControl *)node->Data();
1270     if (item->GetParent() == win)
1271     {
1272       int x, y, w, h;
1273       item->GetPosition(&x, &y);
1274       item->GetSize(&w, &h);
1275
1276       int newX, newY;
1277
1278       switch (flag)
1279       {
1280         case TOOLBAR_FORMAT_HORIZ:
1281         {
1282           newX = x;
1283           newY = (int)(centreY - (h/2.0));
1284           break;
1285         }
1286         case TOOLBAR_FORMAT_VERT:
1287         {
1288           newX = (int)(centreX - (w/2.0));
1289           newY = y;
1290           break;
1291         }
1292         case TOOLBAR_FORMAT_HORIZ_LEFT_ALIGN:
1293         {
1294           newX = firstX;
1295           newY = y;
1296           break;
1297         }
1298         case TOOLBAR_FORMAT_VERT_TOP_ALIGN:
1299         {
1300           newX = x;
1301           newY = firstY;
1302           break;
1303         }
1304         case TOOLBAR_FORMAT_HORIZ_RIGHT_ALIGN:
1305         {
1306           newX = firstX + firstW - w;
1307           newY = y;
1308           break;
1309         }
1310         case TOOLBAR_FORMAT_VERT_BOT_ALIGN:
1311         {
1312           newX = x;
1313           newY = firstY + firstH - h;
1314           break;
1315         }
1316         default:
1317           newX = x; newY = y;
1318           break;
1319       }
1320
1321       wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(item);
1322       wxItemResource* parentResource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(item->GetParent());
1323
1324       item->SetSize(newX, newY, w, h);
1325
1326           // Also update the associated resource
1327           // We need to convert to dialog units if this is not a dialog or panel, but
1328           // the parent resource specifies dialog units.
1329           if (parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
1330       {
1331         wxPoint pt = item->GetParent()->ConvertPixelsToDialog(wxPoint(newX, newY));
1332         newX = pt.x; newY = pt.y;
1333         wxSize sz = item->GetParent()->ConvertPixelsToDialog(wxSize(w, h));
1334         w = sz.x; h = sz.y;
1335       }
1336       resource->SetSize(newX, newY, w, h);
1337     }
1338   }
1339   win->Refresh();
1340 }
1341
1342 // Copy the first image's size to subsequent images
1343 void wxResourceManager::CopySize()
1344 {
1345   wxWindow *win = FindParentOfSelection();
1346   if (!win)
1347     return;
1348
1349   wxNode *node = GetSelections().First();
1350   if (!node)
1351     return;
1352
1353   wxControl *firstSelection = (wxControl *)node->Data();
1354   if (firstSelection->GetParent() != win)
1355     return;
1356
1357   int firstX, firstY;
1358   int firstW, firstH;
1359   firstSelection->GetPosition(&firstX, &firstY);
1360   firstSelection->GetSize(&firstW, &firstH);
1361
1362   while ((node = node->Next()))
1363   {
1364     wxControl *item = (wxControl *)node->Data();
1365     if (item->GetParent() == win)
1366         {
1367       item->SetSize(-1, -1, firstW, firstH);
1368
1369       wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(item);
1370       wxItemResource* parentResource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(item->GetParent());
1371
1372           // Also update the associated resource
1373           // We need to convert to dialog units if this is not a dialog or panel, but
1374           // the parent resource specifies dialog units.
1375           if (parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
1376       {
1377         wxSize sz = item->GetParent()->ConvertPixelsToDialog(wxSize(firstW, firstH));
1378         firstW = sz.x; firstH = sz.y;
1379       }
1380       resource->SetSize(resource->GetX(), resource->GetY(), firstW, firstH);
1381
1382         }
1383   }
1384   win->Refresh();
1385 }
1386
1387 void wxResourceManager::ToBackOrFront(bool toBack)
1388 {
1389   wxWindow *win = FindParentOfSelection();
1390   if (!win)
1391     return;
1392   wxItemResource *winResource = FindResourceForWindow(win);
1393
1394   wxNode *node = GetSelections().First();
1395   while (node)
1396   {
1397     wxControl *item = (wxControl *)node->Data();
1398     wxItemResource *itemResource = FindResourceForWindow(item);
1399     if (item->GetParent() == win)
1400     {
1401       win->GetChildren().DeleteObject(item);
1402       if (winResource)
1403         winResource->GetChildren().DeleteObject(itemResource);
1404       if (toBack)
1405       {
1406         win->GetChildren().Insert(item);
1407         if (winResource)
1408           winResource->GetChildren().Insert(itemResource);
1409       }
1410       else
1411       {
1412         win->GetChildren().Append(item);
1413         if (winResource)
1414           winResource->GetChildren().Append(itemResource);
1415       }
1416     }
1417     node = node->Next();
1418   }
1419 //  win->Refresh();
1420 }
1421
1422 void wxResourceManager::AddSelection(wxWindow *win)
1423 {
1424   if (!m_selections.Member(win))
1425     m_selections.Append(win);
1426 }
1427
1428 void wxResourceManager::RemoveSelection(wxWindow *win)
1429 {
1430   m_selections.DeleteObject(win);
1431 }
1432
1433 // Need to search through resource table removing this from
1434 // any resource which has this as a parent.
1435 bool wxResourceManager::RemoveResourceFromParent(wxItemResource *res)
1436 {
1437   m_resourceTable.BeginFind();
1438   wxNode *node;
1439   while ((node = m_resourceTable.Next()))
1440   {
1441     wxItemResource *thisRes = (wxItemResource *)node->Data();
1442     if (thisRes->GetChildren().Member(res))
1443     {
1444       thisRes->GetChildren().DeleteObject(res);
1445       return TRUE;
1446     }
1447   }
1448   return FALSE;
1449 }
1450
1451 bool wxResourceManager::DeleteResource(wxItemResource *res)
1452 {
1453   if (!res)
1454     return FALSE;
1455
1456   RemoveResourceFromParent(res);
1457
1458   wxNode *node = res->GetChildren().First();
1459   while (node)
1460   {
1461     wxNode *next = node->Next();
1462     wxItemResource *child = (wxItemResource *)node->Data();
1463     DeleteResource(child);
1464     node = next;
1465   }
1466
1467   // If this is a button or message resource, delete the
1468   // associate bitmap resource if not being used.
1469   wxString resType(res->GetType());
1470
1471 /* shouldn't have to do this now bitmaps are ref-counted
1472   if ((resType == "wxMessage" || resType == "wxStaticBitmap" || resType == "wxButton" || resType == "wxBitmapButton") && res->GetValue4())
1473   {
1474     PossiblyDeleteBitmapResource(res->GetValue4());
1475   }
1476 */
1477
1478   // Remove symbol from table if appropriate
1479   if (!IsSymbolUsed(res, res->GetId()))
1480   {
1481     m_symbolTable.RemoveSymbol(res->GetId());
1482   }
1483
1484   m_resourceTable.Delete(res->GetName());
1485   delete res;
1486   Modify(TRUE);
1487   return TRUE;
1488 }
1489
1490 bool wxResourceManager::DeleteResource(wxWindow *win)
1491 {
1492   if (win->IsKindOf(CLASSINFO(wxControl)))
1493   {
1494     // Deselect and refresh window in case we leave selection
1495     // handles behind
1496     wxControl *item = (wxControl *)win;
1497     wxResourceEditorControlHandler *childHandler = (wxResourceEditorControlHandler *)item->GetEventHandler();
1498     if (childHandler->IsSelected())
1499     {
1500       RemoveSelection(item);
1501       childHandler->SelectItem(FALSE);
1502 #ifndef __WXGTK__
1503       item->GetParent()->Refresh();
1504 #endif
1505     }
1506   }
1507
1508   wxItemResource *res = FindResourceForWindow(win);
1509
1510   DisassociateResource(res);
1511   DeleteResource(res);
1512   UpdateResourceList();
1513
1514   return TRUE;
1515 }
1516
1517 // Will eventually have bitmap type information, for different
1518 // kinds of bitmap.
1519 wxString wxResourceManager::AddBitmapResource(const wxString& filename)
1520 {
1521   wxItemResource *resource = FindBitmapResourceByFilename(filename);
1522   if (!resource)
1523   {
1524     char buf[256];
1525     MakeUniqueName("bitmap", buf);
1526     resource = new wxItemResource;
1527     resource->SetType("wxBitmap");
1528     resource->SetName(buf);
1529
1530     // A bitmap resource has one or more children, specifying
1531     // alternative bitmaps.
1532     wxItemResource *child = new wxItemResource;
1533     child->SetType("wxBitmap");
1534     child->SetName(filename);
1535     child->SetValue1(wxBITMAP_TYPE_BMP);
1536     child->SetValue2(RESOURCE_PLATFORM_ANY);
1537     child->SetValue3(0); // Depth
1538     child->SetSize(0,0,0,0);
1539     resource->GetChildren().Append(child);
1540
1541     m_resourceTable.AddResource(resource);
1542
1543     UpdateResourceList();
1544   }
1545   if (resource)
1546     return resource->GetName();
1547   else
1548     return wxEmptyString;
1549 }
1550
1551  // Delete the bitmap resource if it isn't being used by another resource.
1552 void wxResourceManager::PossiblyDeleteBitmapResource(const wxString& resourceName)
1553 {
1554   if (!IsBitmapResourceUsed(resourceName))
1555   {
1556     wxItemResource *res = m_resourceTable.FindResource(resourceName);
1557     DeleteResource(res);
1558     UpdateResourceList();
1559   }
1560 }
1561
1562 bool wxResourceManager::IsBitmapResourceUsed(const wxString& resourceName)
1563 {
1564   m_resourceTable.BeginFind();
1565   wxNode *node;
1566   while ((node = m_resourceTable.Next()))
1567   {
1568     wxItemResource *res = (wxItemResource *)node->Data();
1569     wxString resType(res->GetType());
1570     if (resType == "wxDialog")
1571     {
1572       wxNode *node1 = res->GetChildren().First();
1573       while (node1)
1574       {
1575         wxItemResource *child = (wxItemResource *)node1->Data();
1576         wxString childResType(child->GetType());
1577
1578         if ((childResType == "wxMessage" || childResType == "wxButton") &&
1579              child->GetValue4() &&
1580             (strcmp(child->GetValue4(), resourceName) == 0))
1581           return TRUE;
1582         node1 = node1->Next();
1583       }
1584     }
1585   }
1586   return FALSE;
1587 }
1588
1589 // Given a wxButton or wxMessage, find the corresponding bitmap filename.
1590 wxString wxResourceManager::FindBitmapFilenameForResource(wxItemResource *resource)
1591 {
1592   if (!resource || (resource->GetValue4() == ""))
1593     return wxEmptyString;
1594   wxItemResource *bitmapResource = m_resourceTable.FindResource(resource->GetValue4());
1595   if (!bitmapResource)
1596     return wxEmptyString;
1597
1598   wxNode *node = bitmapResource->GetChildren().First();
1599   while (node)
1600   {
1601     // Eventually augment this to return a bitmap of the right kind or something...
1602     // Maybe the root of the filename remains the same, so it doesn't matter which we
1603     // pick up. Otherwise how do we specify multiple filenames... too boring...
1604     wxItemResource *child = (wxItemResource *)node->Data();
1605     return child->GetName();
1606
1607     node = node->Next();
1608   }
1609   return wxEmptyString;
1610 }
1611
1612 wxItemResource *wxResourceManager::FindBitmapResourceByFilename(const wxString& filename)
1613 {
1614   m_resourceTable.BeginFind();
1615   wxNode *node;
1616   while ((node = m_resourceTable.Next()))
1617   {
1618     wxItemResource *res = (wxItemResource *)node->Data();
1619     wxString resType(res->GetType());
1620     if (resType == "wxBitmap")
1621     {
1622       wxNode *node1 = res->GetChildren().First();
1623       while (node1)
1624       {
1625         wxItemResource *child = (wxItemResource *)node1->Data();
1626         if (child->GetName() && (strcmp(child->GetName(), filename) == 0))
1627           return res;
1628         node1 = node1->Next();
1629       }
1630     }
1631   }
1632   return NULL;
1633 }
1634
1635 // Is this window identifier symbol in use?
1636 // Let's assume that we can't have 2 names for the same integer id.
1637 // Therefore we can tell by the integer id whether the symbol is
1638 // in use.
1639 bool wxResourceManager::IsSymbolUsed(wxItemResource* thisResource, wxWindowID id)
1640 {
1641   m_resourceTable.BeginFind();
1642   wxNode *node;
1643   while ((node = m_resourceTable.Next()))
1644   {
1645     wxItemResource *res = (wxItemResource *)node->Data();
1646
1647     wxString resType(res->GetType());
1648     if (resType == "wxDialog" || resType == "wxDialogBox" || resType == "wxPanel")
1649     {
1650       if ((res != thisResource) && (res->GetId() == id))
1651           return TRUE;
1652
1653       wxNode *node1 = res->GetChildren().First();
1654       while (node1)
1655       {
1656         wxItemResource *child = (wxItemResource *)node1->Data();
1657         if ((child != thisResource) && (child->GetId() == id))
1658           return TRUE;
1659         node1 = node1->Next();
1660       }
1661     }
1662   }
1663   return FALSE;
1664 }
1665
1666 // Is this window identifier compatible with the given name? (i.e.
1667 // does it already exist under a different name)
1668 bool wxResourceManager::IsIdentifierOK(const wxString& name, wxWindowID id)
1669 {
1670     if (m_symbolTable.SymbolExists(name))
1671     {
1672         int foundId = m_symbolTable.GetIdForSymbol(name);
1673         if (foundId != id)
1674             return FALSE;
1675     }
1676     return TRUE;
1677 }
1678
1679 // Change all integer ids that match oldId, to newId.
1680 // This is necessary if an id is changed for one resource - all resources
1681 // must be changed.
1682 void wxResourceManager::ChangeIds(int oldId, int newId)
1683 {
1684   m_resourceTable.BeginFind();
1685   wxNode *node;
1686   while ((node = m_resourceTable.Next()))
1687   {
1688     wxItemResource *res = (wxItemResource *)node->Data();
1689
1690     wxString resType(res->GetType());
1691     if (resType == "wxDialog" || resType == "wxDialogBox" || resType == "wxPanel")
1692     {
1693       if (res->GetId() == oldId)
1694           res->SetId(newId);
1695
1696       wxNode *node1 = res->GetChildren().First();
1697       while (node1)
1698       {
1699         wxItemResource *child = (wxItemResource *)node1->Data();
1700         if (child->GetId() == oldId)
1701             child->SetId(newId);
1702
1703         node1 = node1->Next();
1704       }
1705     }
1706   }
1707 }
1708
1709 // If any resource ids were missing (or their symbol was missing),
1710 // repair them i.e. give them new ids. Returns TRUE if any resource
1711 // needed repairing.
1712 bool wxResourceManager::RepairResourceIds()
1713 {
1714   bool repaired = FALSE;
1715
1716   m_resourceTable.BeginFind();
1717   wxNode *node;
1718   while ((node = m_resourceTable.Next()))
1719   {
1720     wxItemResource *res = (wxItemResource *)node->Data();
1721     wxString resType(res->GetType());
1722     if (resType == "wxDialog" || resType == "wxDialogBox" || resType == "wxPanel")
1723     {
1724
1725       if ( (res->GetId() == 0) || ((res->GetId() > 0) && !m_symbolTable.IdExists(res->GetId())) )
1726       {
1727           wxString newSymbolName;
1728           int newId = GenerateWindowId("ID_DIALOG", newSymbolName) ;
1729
1730           if (res->GetId() == 0)
1731           {
1732               res->SetId(newId);
1733               m_symbolTable.AddSymbol(newSymbolName, newId);
1734           }
1735           else
1736           {
1737               m_symbolTable.AddSymbol(newSymbolName, res->GetId());
1738           }
1739
1740           repaired = TRUE;
1741       }
1742
1743       wxNode *node1 = res->GetChildren().First();
1744       while (node1)
1745       {
1746         wxItemResource *child = (wxItemResource *)node1->Data();
1747
1748         if ( (child->GetId() == 0) || ((child->GetId() > 0) && !m_symbolTable.IdExists(child->GetId())) )
1749         {
1750             wxString newSymbolName;
1751             int newId = GenerateWindowId("ID_CONTROL", newSymbolName) ;
1752
1753             if (child->GetId() == 0)
1754             {
1755                 child->SetId(newId);
1756                 m_symbolTable.AddSymbol(newSymbolName, newId);
1757             }
1758             else
1759             {
1760                 m_symbolTable.AddSymbol(newSymbolName, child->GetId());
1761             }
1762
1763             repaired = TRUE;
1764         }
1765
1766         node1 = node1->Next();
1767       }
1768     }
1769   }
1770   return repaired;
1771 }
1772
1773
1774  // Deletes 'win' and creates a new window from the resource that
1775  // was associated with it. E.g. if you can't change properties on the
1776  // fly, you'll need to delete the window and create it again.
1777 wxWindow *wxResourceManager::RecreateWindowFromResource(wxWindow *win, wxWindowPropertyInfo *info)
1778 {
1779   wxItemResource *resource = FindResourceForWindow(win);
1780
1781   // Put the current window properties into the wxItemResource object
1782
1783   wxWindowPropertyInfo *newInfo = NULL;
1784   if (!info)
1785   {
1786     newInfo = CreatePropertyInfoForWindow(win);
1787     info = newInfo;
1788   }
1789
1790   info->InstantiateResource(resource);
1791
1792   wxWindow *newWin = NULL;
1793   wxWindow *parent = win->GetParent();
1794   wxItemResource* parentResource = NULL;
1795   if (parent)
1796     parentResource = FindResourceForWindow(parent);
1797
1798   if (win->IsKindOf(CLASSINFO(wxPanel)))
1799   {
1800     Edit(resource);
1801     newWin = FindWindowForResource(resource);
1802   }
1803   else
1804   {
1805     DisassociateResource(resource);
1806     if (win->GetEventHandler() != win)
1807         win->PopEventHandler(TRUE);
1808
1809     DeleteWindow(win);
1810     newWin = m_resourceTable.CreateItem((wxPanel *)parent, resource, parentResource);
1811     newWin->PushEventHandler(new wxResourceEditorControlHandler((wxControl*) newWin, (wxControl*) newWin));
1812     AssociateResource(resource, newWin);
1813     UpdateResourceList();
1814   }
1815
1816   if (info)
1817     info->SetPropertyWindow(newWin);
1818
1819   if (newInfo)
1820     delete newInfo;
1821
1822   return newWin;
1823 }
1824
1825 // Delete resource highlighted in the listbox
1826 bool wxResourceManager::DeleteSelection()
1827 {
1828   int sel = m_editorResourceTree->GetSelection();
1829   if (sel != 0)
1830   {
1831     wxResourceTreeData *data = (wxResourceTreeData *)m_editorResourceTree->GetItemData(sel);
1832     wxItemResource *res = data->GetResource();
1833     wxWindow *win = FindWindowForResource(res);
1834     if (win)
1835     {
1836         DeleteResource(win);
1837         DeleteWindow(win);
1838         UpdateResourceList();
1839         Modify(TRUE);
1840     }
1841     return TRUE;
1842   }
1843
1844   return FALSE;
1845 }
1846
1847 // Delete resource highlighted in the listbox
1848 bool wxResourceManager::RecreateSelection()
1849 {
1850   wxNode *node = GetSelections().First();
1851   while (node)
1852   {
1853     wxControl *item = (wxControl *)node->Data();
1854     wxResourceEditorControlHandler *childHandler = (wxResourceEditorControlHandler *)item->GetEventHandler();
1855     wxNode *next = node->Next();
1856     childHandler->SelectItem(FALSE);
1857
1858     RemoveSelection(item);
1859
1860     RecreateWindowFromResource(item);
1861
1862     node = next;
1863   }
1864   return TRUE;
1865 }
1866
1867 bool wxResourceManager::EditDialog(wxDialog *WXUNUSED(dialog), wxWindow *WXUNUSED(parent))
1868 {
1869   return FALSE;
1870 }
1871
1872 // Ensures that all currently shown windows are saved to resources,
1873 // e.g. just before writing to a .wxr file.
1874 bool wxResourceManager::InstantiateAllResourcesFromWindows()
1875 {
1876   m_resourceTable.BeginFind();
1877   wxNode *node;
1878   while ((node = m_resourceTable.Next()))
1879   {
1880     wxItemResource *res = (wxItemResource *)node->Data();
1881     wxString resType(res->GetType());
1882
1883     if (resType == "wxDialog")
1884     {
1885       wxWindow *win = (wxWindow *)FindWindowForResource(res);
1886       if (win)
1887         InstantiateResourceFromWindow(res, win, TRUE);
1888     }
1889     else if (resType == "wxPanel")
1890     {
1891       wxWindow *win = (wxWindow *)FindWindowForResource(res);
1892       if (win)
1893         InstantiateResourceFromWindow(res, win, TRUE);
1894     }
1895   }
1896   return TRUE;
1897 }
1898
1899 bool wxResourceManager::InstantiateResourceFromWindow(wxItemResource *resource, wxWindow *window, bool recurse)
1900 {
1901   wxWindowPropertyInfo *info = CreatePropertyInfoForWindow(window);
1902   info->SetResource(resource);
1903   info->InstantiateResource(resource);
1904   delete info;
1905
1906   if (recurse)
1907   {
1908     wxNode *node = resource->GetChildren().First();
1909     while (node)
1910     {
1911       wxItemResource *child = (wxItemResource *)node->Data();
1912       wxWindow *childWindow = FindWindowForResource(child);
1913
1914       if (!childWindow)
1915       {
1916         char buf[200];
1917         sprintf(buf, "Could not find window %s", (const char*) child->GetName());
1918         wxMessageBox(buf, "Dialog Editor problem", wxOK);
1919       }
1920       else
1921         InstantiateResourceFromWindow(child, childWindow, recurse);
1922       node = node->Next();
1923     }
1924   }
1925
1926   return TRUE;
1927 }
1928
1929 // Create a window information object for the give window
1930 wxWindowPropertyInfo *wxResourceManager::CreatePropertyInfoForWindow(wxWindow *win)
1931 {
1932   wxWindowPropertyInfo *info = NULL;
1933   if (win->IsKindOf(CLASSINFO(wxScrollBar)))
1934         {
1935           info = new wxScrollBarPropertyInfo(win);
1936         }
1937   else if (win->IsKindOf(CLASSINFO(wxStaticBox)))
1938         {
1939           info = new wxGroupBoxPropertyInfo(win);
1940         }
1941   else if (win->IsKindOf(CLASSINFO(wxCheckBox)))
1942         {
1943           info = new wxCheckBoxPropertyInfo(win);
1944         }
1945   else if (win->IsKindOf(CLASSINFO(wxSlider)))
1946         {
1947           info = new wxSliderPropertyInfo(win);
1948         }
1949   else if (win->IsKindOf(CLASSINFO(wxGauge)))
1950         {
1951           info = new wxGaugePropertyInfo(win);
1952         }
1953   else if (win->IsKindOf(CLASSINFO(wxListBox)))
1954         {
1955           info = new wxListBoxPropertyInfo(win);
1956         }
1957   else if (win->IsKindOf(CLASSINFO(wxRadioBox)))
1958         {
1959           info = new wxRadioBoxPropertyInfo(win);
1960         }
1961   else if (win->IsKindOf(CLASSINFO(wxRadioButton)))
1962         {
1963           info = new wxRadioButtonPropertyInfo(win);
1964         }
1965   else if (win->IsKindOf(CLASSINFO(wxComboBox)))
1966         {
1967           info = new wxComboBoxPropertyInfo(win);
1968         }
1969   else if (win->IsKindOf(CLASSINFO(wxChoice)))
1970         {
1971           info = new wxChoicePropertyInfo(win);
1972         }
1973   else if (win->IsKindOf(CLASSINFO(wxBitmapButton)))
1974         {
1975           info = new wxBitmapButtonPropertyInfo(win);
1976         }
1977   else if (win->IsKindOf(CLASSINFO(wxButton)))
1978         {
1979           info = new wxButtonPropertyInfo(win);
1980         }
1981   else if (win->IsKindOf(CLASSINFO(wxStaticBitmap)))
1982         {
1983           info = new wxStaticBitmapPropertyInfo(win);
1984         }
1985   else if (win->IsKindOf(CLASSINFO(wxStaticText)))
1986         {
1987           info = new wxStaticTextPropertyInfo(win);
1988         }
1989   else if (win->IsKindOf(CLASSINFO(wxTextCtrl)))
1990         {
1991           info = new wxTextPropertyInfo(win);
1992         }
1993   else if (win->IsKindOf(CLASSINFO(wxPanel)))
1994         {
1995           info = new wxPanelPropertyInfo(win);
1996         }
1997   else
1998         {
1999           info = new wxWindowPropertyInfo(win);
2000         }
2001   return info;
2002 }
2003
2004 // Edit the given window
2005 void wxResourceManager::EditWindow(wxWindow *win)
2006 {
2007   wxWindowPropertyInfo *info = CreatePropertyInfoForWindow(win);
2008   if (info)
2009   {
2010     info->SetResource(FindResourceForWindow(win));
2011     wxString str("Editing ");
2012     str += win->GetClassInfo()->GetClassName();
2013     str += ": ";
2014     if (win->GetName() != "")
2015         str += win->GetName();
2016     else
2017         str += "properties";
2018     info->Edit(NULL, str);
2019   }
2020 }
2021
2022 // Generate a window id and a first stab at a name
2023 int wxResourceManager::GenerateWindowId(const wxString& prefix, wxString& idName)
2024 {
2025     m_symbolIdCounter ++;
2026     while (m_symbolTable.IdExists(m_symbolIdCounter))
2027         m_symbolIdCounter ++;
2028
2029     int nameId = m_symbolIdCounter;
2030
2031     wxString str;
2032     str.Printf("%d", nameId);
2033     idName = prefix + str;
2034
2035     while (m_symbolTable.SymbolExists(idName))
2036     {
2037         nameId ++;
2038         str.Printf("%d", nameId);
2039         idName = prefix + str;
2040     }
2041
2042     return m_symbolIdCounter;
2043 }
2044
2045
2046 /*
2047  * Resource editor frame
2048  */
2049
2050 IMPLEMENT_CLASS(wxResourceEditorFrame, wxFrame)
2051
2052 BEGIN_EVENT_TABLE(wxResourceEditorFrame, wxFrame)
2053     EVT_MENU(wxID_NEW, wxResourceEditorFrame::OnNew)
2054     EVT_MENU(RESED_NEW_DIALOG, wxResourceEditorFrame::OnNewDialog)
2055     EVT_MENU(wxID_OPEN, wxResourceEditorFrame::OnOpen)
2056     EVT_MENU(RESED_CLEAR, wxResourceEditorFrame::OnClear)
2057     EVT_MENU(wxID_SAVE, wxResourceEditorFrame::OnSave)
2058     EVT_MENU(wxID_SAVEAS, wxResourceEditorFrame::OnSaveAs)
2059     EVT_MENU(wxID_EXIT, wxResourceEditorFrame::OnExit)
2060     EVT_MENU(wxID_ABOUT, wxResourceEditorFrame::OnAbout)
2061     EVT_MENU(RESED_CONTENTS, wxResourceEditorFrame::OnContents)
2062     EVT_MENU(RESED_DELETE, wxResourceEditorFrame::OnDeleteSelection)
2063     EVT_MENU(RESED_RECREATE, wxResourceEditorFrame::OnRecreateSelection)
2064     EVT_MENU(RESED_TEST, wxResourceEditorFrame::OnTest)
2065 END_EVENT_TABLE()
2066
2067 wxResourceEditorFrame::wxResourceEditorFrame(wxResourceManager *resMan, wxFrame *parent, const wxString& title,
2068     const wxPoint& pos, const wxSize& size, long style, const wxString& name):
2069   wxFrame(parent, -1, title, pos, size, style, name)
2070 {
2071   manager = resMan;
2072 }
2073
2074 wxResourceEditorFrame::~wxResourceEditorFrame()
2075 {
2076 }
2077
2078 void wxResourceEditorFrame::OnNew(wxCommandEvent& WXUNUSED(event))
2079 {
2080       manager->New(FALSE);
2081 }
2082
2083 void wxResourceEditorFrame::OnNewDialog(wxCommandEvent& WXUNUSED(event))
2084 {
2085       manager->CreateNewPanel();
2086 }
2087
2088 void wxResourceEditorFrame::OnOpen(wxCommandEvent& WXUNUSED(event))
2089 {
2090       manager->New(TRUE);
2091 }
2092
2093 void wxResourceEditorFrame::OnClear(wxCommandEvent& WXUNUSED(event))
2094 {
2095       manager->Clear(TRUE, FALSE);
2096 }
2097
2098 void wxResourceEditorFrame::OnSave(wxCommandEvent& WXUNUSED(event))
2099 {
2100       manager->Save();
2101 }
2102
2103 void wxResourceEditorFrame::OnSaveAs(wxCommandEvent& WXUNUSED(event))
2104 {
2105       manager->SaveAs();
2106 }
2107
2108 void wxResourceEditorFrame::OnExit(wxCommandEvent& WXUNUSED(event))
2109 {
2110           manager->Clear(TRUE, FALSE) ;
2111       this->Close();
2112 }
2113
2114 void wxResourceEditorFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
2115 {
2116       char buf[300];
2117       sprintf(buf, "wxWindows Dialog Editor %.1f\nAuthor: Julian Smart J.Smart@ed.ac.uk\nJulian Smart (c) 1996", wxDIALOG_EDITOR_VERSION);
2118       wxMessageBox(buf, "About Dialog Editor", wxOK|wxCENTRE);
2119 }
2120
2121 void wxResourceEditorFrame::OnTest(wxCommandEvent& WXUNUSED(event))
2122 {
2123     manager->TestCurrentDialog(this);
2124 }
2125
2126 void wxResourceEditorFrame::OnContents(wxCommandEvent& WXUNUSED(event))
2127 {
2128 #ifdef __WXMSW__
2129       wxBeginBusyCursor();
2130       manager->GetHelpController()->LoadFile();
2131       manager->GetHelpController()->DisplayContents();
2132       wxEndBusyCursor();
2133 #endif
2134 }
2135
2136 void wxResourceEditorFrame::OnDeleteSelection(wxCommandEvent& WXUNUSED(event))
2137 {
2138       manager->DeleteSelection();
2139 }
2140
2141 void wxResourceEditorFrame::OnRecreateSelection(wxCommandEvent& WXUNUSED(event))
2142 {
2143       manager->RecreateSelection();
2144 }
2145
2146 bool wxResourceEditorFrame::OnClose()
2147 {
2148   if (manager->Modified())
2149   {
2150   if (!manager->Clear(TRUE, FALSE))
2151      return FALSE;
2152   }
2153
2154   if (!Iconized())
2155   {
2156     int w, h;
2157     GetSize(&w, &h);
2158     manager->m_resourceEditorWindowSize.width = w;
2159     manager->m_resourceEditorWindowSize.height = h;
2160
2161     int x, y;
2162     GetPosition(&x, &y);
2163
2164     manager->m_resourceEditorWindowSize.x = x;
2165     manager->m_resourceEditorWindowSize.y = y;
2166   }
2167   manager->SetEditorFrame(NULL);
2168   manager->SetEditorToolBar(NULL);
2169
2170   return TRUE;
2171 }
2172
2173 /*
2174  * Resource editor window that contains the dialog/panel being edited
2175  */
2176
2177 BEGIN_EVENT_TABLE(wxResourceEditorScrolledWindow, wxScrolledWindow)
2178     EVT_SCROLL(wxResourceEditorScrolledWindow::OnScroll)
2179     EVT_PAINT(wxResourceEditorScrolledWindow::OnPaint)
2180 END_EVENT_TABLE()
2181
2182 wxResourceEditorScrolledWindow::wxResourceEditorScrolledWindow(wxWindow *parent, const wxPoint& pos, const wxSize& size,
2183     long style):
2184   wxScrolledWindow(parent, -1, pos, size, style)
2185 {
2186     m_marginX = 10;
2187     m_marginY = 40;
2188     m_childWindow = NULL;
2189 }
2190
2191 wxResourceEditorScrolledWindow::~wxResourceEditorScrolledWindow()
2192 {
2193 }
2194
2195 void wxResourceEditorScrolledWindow::OnScroll(wxScrollEvent& event)
2196 {
2197     wxScrolledWindow::OnScroll(event);
2198
2199     int x, y;
2200     ViewStart(& x, & y);
2201
2202     if (m_childWindow)
2203         m_childWindow->Move(m_marginX + (- x * 10), m_marginY + (- y * 10));
2204 }
2205
2206 void wxResourceEditorScrolledWindow::OnPaint(wxPaintEvent& WXUNUSED(event))
2207 {
2208     wxPaintDC dc(this);
2209
2210     DrawTitle(dc);
2211 }
2212
2213 void wxResourceEditorScrolledWindow::DrawTitle(wxDC& dc)
2214 {
2215     if (m_childWindow)
2216     {
2217         wxItemResource* res = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_childWindow);
2218         if (res)
2219         {
2220             wxString str(res->GetTitle());
2221             int x, y;
2222             ViewStart(& x, & y);
2223
2224             wxFont font(10, wxSWISS, wxNORMAL, wxBOLD);
2225             dc.SetFont(font);
2226             dc.SetBackgroundMode(wxTRANSPARENT);
2227             dc.SetTextForeground(wxColour(0, 0, 0));
2228
2229             long w, h;
2230             dc.GetTextExtent(str, & w, & h);
2231
2232             dc.DrawText(str, m_marginX + (- x * 10), m_marginY + (- y * 10) - h - 5);
2233         }
2234     }
2235 }
2236
2237 // Popup menu callback
2238 void ObjectMenuProc(wxMenu& menu, wxCommandEvent& event)
2239 {
2240   wxWindow *data = (wxWindow *)menu.GetClientData();
2241   if (!data)
2242     return;
2243
2244   switch (event.GetInt())
2245   {
2246     case OBJECT_MENU_EDIT:
2247     {
2248       wxResourceManager::GetCurrentResourceManager()->EditWindow(data);
2249       break;
2250     }
2251     case OBJECT_MENU_DELETE:
2252     {
2253       wxResourceManager::GetCurrentResourceManager()->SaveInfoAndDeleteHandler(data);
2254       wxResourceManager::GetCurrentResourceManager()->DeleteResource(data);
2255       wxResourceManager::GetCurrentResourceManager()->DeleteWindow(data);
2256       break;
2257     }
2258     default:
2259       break;
2260   }
2261 }
2262
2263 /*
2264  * Main toolbar
2265  *
2266  */
2267
2268 #ifdef __WXGTK__   // I don't dare to delete it...
2269
2270 BEGIN_EVENT_TABLE(EditorToolBar, wxToolBar)
2271 END_EVENT_TABLE()
2272
2273 #else
2274
2275 BEGIN_EVENT_TABLE(EditorToolBar, wxToolBar)
2276         EVT_PAINT(EditorToolBar::OnPaint)
2277 END_EVENT_TABLE()
2278
2279 #endif
2280
2281 EditorToolBar::EditorToolBar(wxFrame *frame, const wxPoint& pos, const wxSize& size,
2282             long style):
2283   wxToolBar(frame, -1, pos, size, style)
2284 {
2285 }
2286
2287 bool EditorToolBar::OnLeftClick(int toolIndex, bool WXUNUSED(toggled))
2288 {
2289   wxResourceManager *manager = wxResourceManager::GetCurrentResourceManager();
2290
2291   switch (toolIndex)
2292   {
2293     case TOOLBAR_LOAD_FILE:
2294     {
2295       manager->New(TRUE);
2296       break;
2297     }
2298     case TOOLBAR_NEW:
2299     {
2300       manager->CreateNewPanel();
2301       break;
2302     }
2303     case TOOLBAR_SAVE_FILE:
2304     {
2305       manager->Save();
2306       break;
2307     }
2308     case TOOLBAR_HELP:
2309     {
2310 #ifdef __WXMSW__
2311       wxBeginBusyCursor();
2312       manager->GetHelpController()->LoadFile();
2313       manager->GetHelpController()->DisplayContents();
2314       wxEndBusyCursor();
2315 #endif
2316       break;
2317     }
2318     case TOOLBAR_FORMAT_HORIZ:
2319     {
2320       manager->AlignItems(TOOLBAR_FORMAT_HORIZ);
2321       break;
2322     }
2323     case TOOLBAR_FORMAT_HORIZ_LEFT_ALIGN:
2324     {
2325       manager->AlignItems(TOOLBAR_FORMAT_HORIZ_LEFT_ALIGN);
2326       break;
2327     }
2328     case TOOLBAR_FORMAT_HORIZ_RIGHT_ALIGN:
2329     {
2330       manager->AlignItems(TOOLBAR_FORMAT_HORIZ_RIGHT_ALIGN);
2331       break;
2332     }
2333     case TOOLBAR_FORMAT_VERT:
2334     {
2335       manager->AlignItems(TOOLBAR_FORMAT_VERT);
2336       break;
2337     }
2338     case TOOLBAR_FORMAT_VERT_TOP_ALIGN:
2339     {
2340       manager->AlignItems(TOOLBAR_FORMAT_VERT_TOP_ALIGN);
2341       break;
2342     }
2343     case TOOLBAR_FORMAT_VERT_BOT_ALIGN:
2344     {
2345       manager->AlignItems(TOOLBAR_FORMAT_VERT_BOT_ALIGN);
2346       break;
2347     }
2348     case TOOLBAR_COPY_SIZE:
2349     {
2350       manager->CopySize();
2351       break;
2352     }
2353     case TOOLBAR_TO_BACK:
2354     {
2355       manager->ToBackOrFront(TRUE);
2356       break;
2357     }
2358     case TOOLBAR_TO_FRONT:
2359     {
2360       manager->ToBackOrFront(FALSE);
2361       break;
2362     }
2363     default:
2364       break;
2365   }
2366   return TRUE;
2367 }
2368
2369 void EditorToolBar::OnMouseEnter(int toolIndex)
2370 {
2371   wxFrame *frame = (wxFrame *)GetParent();
2372
2373   if (!frame) return;
2374
2375   if (toolIndex > -1)
2376   {
2377       switch (toolIndex)
2378       {
2379         case TOOLBAR_LOAD_FILE:
2380           frame->SetStatusText("Load project file");
2381           break;
2382         case TOOLBAR_SAVE_FILE:
2383           frame->SetStatusText("Save project file");
2384           break;
2385         case TOOLBAR_NEW:
2386           frame->SetStatusText("Create a new resource");
2387           break;
2388         case TOOLBAR_FORMAT_HORIZ:
2389           frame->SetStatusText("Align items horizontally");
2390           break;
2391         case TOOLBAR_FORMAT_VERT:
2392           frame->SetStatusText("Align items vertically");
2393           break;
2394         case TOOLBAR_FORMAT_HORIZ_LEFT_ALIGN:
2395           frame->SetStatusText("Left-align items");
2396           break;
2397         case TOOLBAR_FORMAT_HORIZ_RIGHT_ALIGN:
2398           frame->SetStatusText("Right-align items");
2399           break;
2400         case TOOLBAR_FORMAT_VERT_TOP_ALIGN:
2401           frame->SetStatusText("Top-align items");
2402           break;
2403         case TOOLBAR_FORMAT_VERT_BOT_ALIGN:
2404           frame->SetStatusText("Bottom-align items");
2405           break;
2406         case TOOLBAR_COPY_SIZE:
2407           frame->SetStatusText("Copy size from first selection");
2408           break;
2409         case TOOLBAR_TO_FRONT:
2410           frame->SetStatusText("Put image to front");
2411           break;
2412         case TOOLBAR_TO_BACK:
2413           frame->SetStatusText("Put image to back");
2414           break;
2415         case TOOLBAR_HELP:
2416           frame->SetStatusText("Display help contents");
2417           break;
2418         default:
2419           break;
2420       }
2421   }
2422   else frame->SetStatusText("");
2423 }
2424