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