utils/configtool/src/configtooldoc.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        configtooldoc.h
   3 // Purpose:     Document class
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     2003-06-04
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // For compilers that support precompilation, includes "wx/wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifdef __BORLANDC__
  16 #pragma hdrstop
  17 #endif
  18
  19 #ifndef WX_PRECOMP
  20
  21 #include "wx/process.h"
  22 #include "wx/mimetype.h"
  23 #include "wx/process.h"
  24
  25 #endif
  26
  27 #include "wx/textfile.h"
  28 #include "wx/txtstrm.h"
  29 #include "wx/wfstream.h"
  30 #include "wx/config.h"
  31 #include "configtooldoc.h"
  32 #include "configtoolview.h"
  33 #include "configtree.h"
  34 #include "mainframe.h"
  35 #include "utils.h"
  36 #include "wxconfigtool.h"
  37 #include "htmlparser.h"
  38
  39 IMPLEMENT_DYNAMIC_CLASS(ctConfigToolDoc, wxDocument)
  40
  41 // Ctor
  42 ctConfigToolDoc::ctConfigToolDoc()
  43 {
  44     m_topItem = NULL;
  45     m_clipboardItem = NULL;
  46 }
  47
  48 // Dtor
  49 ctConfigToolDoc::~ctConfigToolDoc()
  50 {
  51     DeleteItems();
  52     ClearClipboard();
  53     if (GetCommandProcessor())
  54         GetCommandProcessor()->SetEditMenu(NULL);
  55 }
  56
  57 // Delete all the items not already deleted
  58 void ctConfigToolDoc::DeleteItems()
  59 {
  60     if (m_topItem)
  61         delete m_topItem;
  62     m_topItem = NULL;
  63 }
  64
  65 /// Clears the clipboard item.
  66 void ctConfigToolDoc::ClearClipboard()
  67 {
  68     if (m_clipboardItem)
  69         delete m_clipboardItem;
  70     m_clipboardItem = NULL;
  71 }
  72
  73 /// Sets the clipboard item.
  74 void ctConfigToolDoc::SetClipboardItem(ctConfigItem* item)
  75 {
  76     if (m_clipboardItem)
  77         delete m_clipboardItem;
  78     m_clipboardItem = item;
  79 }
  80
  81
  82 // Closes and clears the document
  83 bool ctConfigToolDoc::OnCloseDocument()
  84 {
  85     if (wxDocument::OnCloseDocument())
  86     {
  87         ctConfigToolHint hint(NULL, ctClear);
  88         UpdateAllViews (NULL, & hint);
  89
  90         DeleteItems();
  91         return true;
  92     }
  93     else
  94     {
  95         return false;
  96     }
  97 }
  98
  99 // Saves the doc
 100 bool ctConfigToolDoc::Save()
 101 {
 102     if (!IsModified() && m_savedYet) return true;
 103
 104     bool ret = (m_documentFile.empty() || !m_savedYet) ?
 105                  SaveAs() :
 106                  OnSaveDocument(m_documentFile);
 107     if ( ret )
 108         SetDocumentSaved(true);
 109     return ret;
 110 }
 111
 112 // Create the document
 113 bool ctConfigToolDoc::OnCreate(const wxString& path, long flags)
 114 {
 115     GetCommandProcessor()->SetEditMenu(wxGetApp().GetMainFrame()->GetEditMenu());
 116     GetCommandProcessor()->Initialize();
 117     GetCommandProcessor()->ClearCommands();
 118
 119     // wxGetApp().m_currentDoc = this;
 120
 121     if (flags & wxDOC_NEW)
 122     {
 123         ctConfigItem* rootItem = new ctConfigItem(NULL, ctTypeGroup, _T("Configuration"));
 124         //rootItem->InitProperties();
 125         rootItem->GetProperties().AddProperty(
 126         new ctProperty(
 127             wxT("The item description."),
 128             wxVariant(wxEmptyString, wxT("description")),
 129             wxT("multiline")));
 130
 131         rootItem->SetPropertyString(_T("description"),
 132             _T("<B>This is the top-level configuration item.</B>"));
 133
 134
 135         SetTopItem(rootItem);
 136
 137         Modify(false);
 138         SetDocumentSaved(false);
 139
 140         wxString rootName(wxT("untitled"));
 141         wxStripExtension(rootName);
 142         SetFilename(wxGetApp().GetSettings().GenerateFilename(rootName));
 143     }
 144
 145     // Creates the view, so do any view updating after this
 146     bool success = wxDocument::OnCreate(path, flags);
 147
 148     if (success)
 149     {
 150         if (flags & wxDOC_NEW)
 151         {
 152             wxBusyCursor wait;
 153
 154             ctConfigToolHint hint(NULL, ctInitialUpdate);
 155             UpdateAllViews (NULL, & hint);
 156
 157             SetFilename(GetFilename(), true);
 158         }
 159     }
 160     return success;
 161 }
 162
 163 // Save the document
 164 bool ctConfigToolDoc::OnSaveDocument(const wxString& filename)
 165 {
 166     wxBusyCursor cursor;
 167
 168     const wxString strOldPath(GetFilename());
 169
 170     // Do some backing up first
 171
 172     // This is the backup filename
 173     wxString backupFilename(filename);
 174     backupFilename += wxT(".bak");
 175
 176     // This is the temporary copy of the backup
 177     wxString tempFilename(filename);
 178     tempFilename += wxT(".tmp");
 179     if (wxFileExists(tempFilename))
 180         wxRemoveFile(tempFilename);
 181
 182     bool leaveBackup = true;
 183
 184     bool saved = DoSave(tempFilename);
 185
 186     if (saved)
 187     {
 188         // Remove the old .bak file
 189         if (wxFileExists(backupFilename))
 190         {
 191             wxRemoveFile(backupFilename);
 192         }
 193
 194         // Copy the old file to the .bak
 195
 196         if (leaveBackup)
 197         {
 198             if (wxFileExists(filename))
 199             {
 200                 if (!wxRenameFile(filename, backupFilename))
 201                 {
 202                     wxCopyFile(filename, backupFilename);
 203                     wxRemoveFile(filename);
 204                 }
 205             }
 206         }
 207         else
 208         {
 209             if (wxFileExists(filename))
 210                 wxRemoveFile(filename);
 211         }
 212
 213         // Finally, copy the temporary file to the proper filename
 214         if (!wxRenameFile(tempFilename, filename))
 215         {
 216             wxCopyFile(tempFilename, filename);
 217             wxRemoveFile(tempFilename);
 218         }
 219
 220         Modify(false);
 221         ((ctConfigToolView*)GetFirstView())->OnChangeFilename();
 222         SetDocumentSaved(true);
 223         SetFilename(filename);
 224         wxGetApp().GetSettings().m_lastFilename = filename;
 225     } else
 226     {
 227         SetFilename(strOldPath);
 228     }
 229     wxGetApp().GetMainFrame()->UpdateFrameTitle();
 230     return saved;
 231 }
 232
 233 // Open the document
 234 bool ctConfigToolDoc::OnOpenDocument(const wxString& filename)
 235 {
 236     wxBusyCursor cursor;
 237
 238     bool opened = DoOpen(filename);
 239
 240     if (opened)
 241     {
 242         SetFilename(filename);
 243         wxGetApp().GetSettings().m_lastFilename = filename;
 244
 245         ((ctConfigToolView*)GetFirstView())->OnChangeFilename();
 246
 247         RefreshDependencies();
 248
 249         // ctConfigToolHint hint(NULL, ctFilenameChanged);
 250         ctConfigToolHint hint(NULL, ctInitialUpdate);
 251         UpdateAllViews (NULL, & hint);
 252     }
 253
 254     SetDocumentSaved(true); // Necessary or it will pop up the Save As dialog
 255
 256     return opened;
 257 }
 258
 259 /// Save the settings file
 260 bool ctConfigToolDoc::DoSave(const wxString& filename)
 261 {
 262     wxFileOutputStream osFile(filename);
 263     if (!osFile.Ok())
 264         return false;
 265
 266     wxTextOutputStream stream(osFile);
 267
 268     stream << wxT("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
 269     stream << wxT("<settings xmlns=\"http://www.wxwidgets.org/wxs\" version=\"2.5.0.1\">");
 270
 271     DoSave(m_topItem, osFile, 1);
 272
 273     stream << wxT("\n</settings>\n");
 274
 275     return true;
 276 }
 277
 278 inline static void OutputIndentation(wxOutputStream& osFile, int indent)
 279 {
 280     wxTextOutputStream stream(osFile);
 281     wxString str = wxT("\n");
 282     for (int i = 0; i < indent; i++)
 283         str << wxT("  ");
 284     stream << str ;
 285 }
 286
 287 /// Recursive helper function for file saving
 288 bool ctConfigToolDoc::DoSave(ctConfigItem* item, wxOutputStream& osFile, int indent)
 289 {
 290     OutputIndentation(osFile, indent*2);
 291     wxTextOutputStream stream(osFile);
 292
 293     wxString name(item->GetName());
 294     wxString s;
 295     wxString typeStr;
 296     if (item->GetType() == ctTypeGroup)
 297         typeStr = wxT("group");
 298     else if (item->GetType() == ctTypeCheckGroup)
 299         typeStr = wxT("check-group");
 300     else if (item->GetType() == ctTypeRadioGroup)
 301         typeStr = wxT("radio-group");
 302     else if (item->GetType() == ctTypeString)
 303         typeStr = wxT("string");
 304     else if (item->GetType() == ctTypeBoolCheck)
 305         typeStr = wxT("bool-check");
 306     else if (item->GetType() == ctTypeBoolRadio)
 307         typeStr = wxT("bool-radio");
 308     else if (item->GetType() == ctTypeInteger)
 309         typeStr = wxT("integer");
 310     else
 311         typeStr = wxT("unknown");
 312
 313     stream << wxT("<setting type=\"") << typeStr << wxT("\">");
 314
 315     indent ++;
 316
 317     OutputIndentation(osFile, indent*2);
 318     if (item->IsActive())
 319         stream << wxT("<active>1</active>");
 320     else
 321         stream << wxT("<active>0</active>");
 322     OutputIndentation(osFile, indent*2);
 323     if (item->IsEnabled())
 324         stream << wxT("<enabled>1</enabled>");
 325     else
 326         stream << wxT("<enabled>0</enabled>");
 327
 328     // Output properties
 329     wxObjectList::compatibility_iterator node = item->GetProperties().GetList().GetFirst();
 330     while (node)
 331     {
 332         ctProperty* prop = (ctProperty*) node->GetData();
 333         OutputIndentation(osFile, indent*2);
 334         stream << wxT("<") << prop->GetName() ;
 335
 336         if (prop->IsCustom())
 337         {
 338             stream << wxT(" custom=\"true\"");
 339             stream << wxT(" type=\"") << prop->GetVariant().GetType() << wxT("\"");
 340             stream << wxT(" editor-type=\"") << prop->GetEditorType() << wxT("\"");
 341             stream << wxT(" description=\"") << prop->GetDescription() << wxT("\"");
 342             if (prop->GetChoices().GetCount() > 0)
 343             {
 344                 wxString choices;
 345                 ctConfigItem::ArrayToString(prop->GetChoices(), choices);
 346                 stream << wxT(" choices=\"") << choices << wxT("\"");
 347             }
 348         }
 349
 350         stream << wxT(">");
 351
 352         stream << ctEscapeHTMLCharacters(prop->GetVariant().GetString()) ;
 353         stream << wxT("</") << prop->GetName() << wxT(">");
 354
 355         node = node->GetNext();
 356     }
 357
 358     // Output children
 359     node = item->GetChildren().GetFirst();
 360     while (node)
 361     {
 362         ctConfigItem* child = (ctConfigItem*) node->GetData();
 363         DoSave(child, osFile, indent);
 364
 365         node = node->GetNext();
 366     }
 367
 368     indent --;
 369
 370     OutputIndentation(osFile, indent*2);
 371     stream << wxT("</setting>");
 372
 373     return true;
 374 }
 375
 376 /// Open the settings file
 377 bool ctConfigToolDoc::DoOpen(const wxString& filename)
 378 {
 379     wxSimpleHtmlParser parser;
 380     if (parser.ParseFile(filename))
 381     {
 382         ctConfigToolHint hint(NULL, ctClear);
 383         UpdateAllViews (NULL, & hint);
 384         m_topItem = NULL;
 385
 386         if (parser.GetTopLevelTag()->GetChildren())
 387         {
 388             wxSimpleHtmlTag* settingsTag = parser.GetTopLevelTag()->GetChildren()->FindTag(wxT("settings"));
 389             if (settingsTag && settingsTag->GetChildren())
 390             {
 391                 wxSimpleHtmlTag* firstSettingTag = settingsTag->GetChildren();
 392                 if (firstSettingTag)
 393                     DoOpen(firstSettingTag, NULL);
 394                 return true;
 395             }
 396             return true;
 397         }
 398     }
 399     return false;
 400 }
 401
 402 static bool GetHtmlBoolValue(const wxString& value)
 403 {
 404     if (value.IsSameAs(wxT("true"),false) || value == wxT("1"))
 405         return true;
 406     else
 407         return false;
 408 }
 409
 410 static int GetHtmlIntegerValue(const wxString& value)
 411 {
 412     return wxAtoi(value);
 413 }
 414
 415 static double GetHtmlDoubleValue(const wxString& value)
 416 {
 417     return wxAtof(value);
 418 }
 419
 420 bool ctConfigToolDoc::DoOpen(wxSimpleHtmlTag* tag, ctConfigItem* parent)
 421 {
 422     ctConfigItem* newItem = NULL;
 423     if (tag->NameIs(wxT("setting")))
 424     {
 425         wxSimpleHtmlAttribute* attr = tag->FindAttribute(wxT("type"));
 426         if (attr)
 427         {
 428             ctConfigType type = ctTypeUnknown;
 429             wxString typeStr(attr->GetValue());
 430             if (typeStr == wxT("group"))
 431                 type = ctTypeGroup;
 432             else if (typeStr == wxT("option-group") || typeStr == wxT("check-group"))
 433                 type = ctTypeCheckGroup;
 434             else if (typeStr == wxT("radio-group"))
 435                 type = ctTypeRadioGroup;
 436             else if (typeStr == wxT("bool-check"))
 437                 type = ctTypeBoolCheck;
 438             else if (typeStr == wxT("bool-radio"))
 439                 type = ctTypeBoolRadio;
 440             else if (typeStr == wxT("string"))
 441                 type = ctTypeString;
 442             else if (typeStr == wxT("integer"))
 443                 type = ctTypeInteger;
 444             else
 445             {
 446                 wxLogError(wxT("Unknown type %s"), (const wxChar*) typeStr);
 447             }
 448             if (type != ctTypeUnknown)
 449             {
 450                 newItem = new ctConfigItem(parent, type, wxT(""));
 451                 newItem->InitProperties();
 452                 if (!parent)
 453                     SetTopItem(newItem);
 454             }
 455         }
 456     }
 457     wxSimpleHtmlTag* childTag = tag->GetChildren();
 458
 459     while (childTag)
 460     {
 461         if (childTag->GetType() == wxSimpleHtmlTag_Open)
 462         {
 463             if (childTag->GetName() == wxT("setting"))
 464             {
 465                 DoOpen(childTag, newItem);
 466             }
 467             else if (childTag->GetName() == wxT("name"))
 468             {
 469                 if (newItem)
 470                 {
 471                     wxString name(childTag->GetNext()->GetTagText());
 472                     newItem->SetName(name);
 473                 }
 474             }
 475             else if (childTag->GetName() == wxT("active"))
 476             {
 477                 if (newItem)
 478                     newItem->SetActive(GetHtmlBoolValue(childTag->GetNext()->GetTagText()));
 479             }
 480             else if (childTag->GetName() == wxT("enabled"))
 481             {
 482                 if (newItem)
 483                     newItem->Enable(GetHtmlBoolValue(childTag->GetNext()->GetTagText()));
 484             }
 485             else
 486             {
 487                 if (newItem)
 488                 {
 489                     ctProperty* prop = newItem->GetProperties().FindProperty(childTag->GetName());
 490                     if (!prop)
 491                     {
 492                         // A custom property, else an obsolete
 493                         // property that we should ignore.
 494                         wxString isCustom;
 495                         if (childTag->GetAttributeValue(isCustom, wxT("custom")) &&
 496                             isCustom == wxT("true"))
 497                         {
 498                             prop = new ctProperty;
 499
 500                             wxString name(childTag->GetName());
 501                             wxString type(wxT("string"));
 502                             wxString choices;
 503                             wxString editorType(wxT("string"));
 504                             wxString description;
 505                             childTag->GetAttributeValue(type, wxT("type"));
 506                             childTag->GetAttributeValue(type, wxT("editor-type"));
 507                             childTag->GetAttributeValue(type, wxT("choices"));
 508                             childTag->GetAttributeValue(description, wxT("description"));
 509
 510                             if (type == wxT("bool"))
 511                                 prop->GetVariant() = wxVariant(false, name);
 512                             else if (type == wxT("double"))
 513                                 prop->GetVariant() = wxVariant((double) 0.0, name);
 514                             else if (type == wxT("long"))
 515                                 prop->GetVariant() = wxVariant((long) 0, name);
 516                             else
 517                                 prop->GetVariant() = wxVariant(wxEmptyString, name);
 518                             prop->SetDescription(description);
 519                             prop->SetCustom(true);
 520                             prop->SetEditorType(editorType);
 521                             if (!choices.IsEmpty())
 522                             {
 523                                 wxArrayString arr;
 524                                 ctConfigItem::StringToArray(choices, arr);
 525                                 prop->SetChoices(arr);
 526                             }
 527                             newItem->GetProperties().AddProperty(prop);
 528                         }
 529                     }
 530                     if (prop)
 531                     {
 532                         if (prop->GetVariant().GetType() == wxT("string"))
 533                             prop->GetVariant() = childTag->GetNext()->GetTagText();
 534                         else if (prop->GetVariant().GetType() == wxT("long"))
 535                             prop->GetVariant() = (long) GetHtmlIntegerValue(childTag->GetNext()->GetTagText());
 536                         else if (prop->GetVariant().GetType() == wxT("bool"))
 537                             prop->GetVariant() = GetHtmlBoolValue(childTag->GetNext()->GetTagText());
 538                         else if (prop->GetVariant().GetType() == wxT("double"))
 539                             prop->GetVariant() = (double) GetHtmlDoubleValue(childTag->GetNext()->GetTagText());
 540                     }
 541                 }
 542             }
 543         }
 544         childTag = childTag->GetNext();
 545     }
 546     return true;
 547 }
 548
 549 /// Clear dependencies
 550 void ctConfigToolDoc::ClearDependencies(ctConfigItem* item)
 551 {
 552     if (!item) {
 553         item = GetTopItem();
 554         if (!item)
 555             return;
 556     }
 557
 558     item->GetDependents().Clear();
 559     for ( wxObjectList::compatibility_iterator node = item->GetChildren().GetFirst(); node; node = node->GetNext() )
 560     {
 561         ctConfigItem* child = (ctConfigItem*) node->GetData();
 562         ClearDependencies(child);
 563     }
 564 }
 565
 566 /// Refresh dependencies
 567 void ctConfigToolDoc::RefreshDependencies()
 568 {
 569     ClearDependencies(GetTopItem());
 570     RefreshDependencies(GetTopItem());
 571 }
 572
 573 /// Refresh dependencies
 574 void ctConfigToolDoc::RefreshDependencies(ctConfigItem* item)
 575 {
 576     if (item==NULL)
 577         return;
 578
 579     wxArrayString requiresArr;
 580     wxString requires = item->GetPropertyString(wxT("requires"));
 581     wxString precludes = item->GetPropertyString(wxT("precludes"));
 582     wxString enabledIf = item->GetPropertyString(wxT("enabled-if"));
 583     wxString enabledIfNot = item->GetPropertyString(wxT("enabled-if-not"));
 584     wxString indeterminateIf = item->GetPropertyString(wxT("indeterminate-if"));
 585     wxString context = item->GetPropertyString(wxT("context"));
 586
 587     if (!requires.IsEmpty())
 588         item->StringToArray(requires, requiresArr);
 589
 590     if (!precludes.IsEmpty())
 591         item->StringToArray(precludes, requiresArr);
 592
 593     if (!enabledIfNot.IsEmpty())
 594         item->StringToArray(enabledIfNot, requiresArr);
 595
 596     if (!enabledIf.IsEmpty())
 597         item->StringToArray(enabledIf, requiresArr);
 598
 599     if (!indeterminateIf.IsEmpty())
 600         item->StringToArray(indeterminateIf, requiresArr);
 601
 602     // Add the parent to the list of dependencies, if the
 603     // parent is a check or radio group.
 604     ctConfigItem* parent = item->GetParent();
 605     if (parent &&
 606         (parent->GetType() == ctTypeCheckGroup ||
 607         parent->GetType() == ctTypeRadioGroup))
 608         requiresArr.Add(parent->GetName());
 609
 610     // Also look in 'context' since these items
 611     // are another kind of dependency (switching to
 612     // a different platform may cause the dependencies
 613     // to be evaluated differently).
 614     if (!context.IsEmpty())
 615         item->StringToArray(context, requiresArr);
 616
 617     size_t i;
 618     for (i = 0; i < requiresArr.GetCount(); i++)
 619     {
 620         wxString itemName(requiresArr[i]);
 621         ctConfigItem* otherItem = GetTopItem()->FindItem(itemName);
 622         if (otherItem && !otherItem->GetDependents().Member(item))
 623         {
 624             otherItem->GetDependents().Append(item);
 625         }
 626     }
 627     for ( wxObjectList::compatibility_iterator node = item->GetChildren().GetFirst(); node; node = node->GetNext() )
 628     {
 629         ctConfigItem* child = (ctConfigItem*) node->GetData();
 630         RefreshDependencies(child);
 631     }
 632 }
 633
 634 /// Generate the text of a setup.h
 635 wxString ctConfigToolDoc::GenerateSetup()
 636 {
 637     wxString str;
 638     str << wxT("/*\n * setup.h\n * Generated by wxConfigTool\n *\n */\n\n");
 639
 640     GenerateSetup(GetTopItem(), str);
 641
 642     return str;
 643 }
 644
 645 /// Helper function
 646 void ctConfigToolDoc::GenerateSetup(ctConfigItem* item, wxString& str)
 647 {
 648     // Generate the setup.h entries for this item
 649     wxString name = item->GetName();
 650
 651     // We don't process the platform choice
 652     if (item->GetName() == wxT("Target"))
 653         return;
 654
 655     if (item->IsInActiveContext() &&
 656         (item->GetType() == ctTypeCheckGroup ||
 657         item->GetType() == ctTypeRadioGroup ||
 658         item->GetType() == ctTypeBoolCheck ||
 659         item->GetType() == ctTypeBoolRadio))
 660     {
 661         // TODO: write description
 662         wxString name = item->GetName();
 663         if (name.Left(6) == wxT("wxUSE_") ||
 664             name == wxT("REMOVE_UNUSED_ARG") || // Hack alert: change to wxUSE_UNUSED_ARG_REMOVAL
 665             name.Find(wxT("COMPATIBILITY")) != wxNOT_FOUND)
 666         {
 667             str << wxT("#define ") << name ;
 668             if (item->IsEnabled())
 669                 str << wxT(" 1");
 670             else
 671                 str << wxT(" 0");
 672             str << wxT("\n\n");
 673         }
 674     }
 675
 676     for ( wxObjectList::compatibility_iterator node = item->GetChildren().GetFirst(); node; node = node->GetNext() )
 677     {
 678         ctConfigItem* child = (ctConfigItem*) node->GetData();
 679         GenerateSetup(child, str);
 680     }
 681 }
 682
 683
 684 /// Generate a configure command
 685 wxString ctConfigToolDoc::GenerateConfigureCommand()
 686 {
 687     wxString str;
 688     str << wxT("# configurewx\n# Generated by wxConfigTool\n\n");
 689
 690     wxString path = GetFrameworkDir(true);
 691     bool makeUnix = true;
 692     if (!path.IsEmpty())
 693     {
 694         if (makeUnix)
 695             path += wxT("/");
 696         else
 697             path += wxFILE_SEP_PATH ;
 698     }
 699
 700     str << path << wxT("configure");
 701
 702     // Find the target to use
 703     ctConfigItem* platformsFolder = GetTopItem()->FindItem(wxT("Target"));
 704     if (platformsFolder)
 705     {
 706         for ( wxObjectList::compatibility_iterator node = platformsFolder->GetChildren().GetFirst(); node; node = node->GetNext() )
 707         {
 708             ctConfigItem* child = (ctConfigItem*) node->GetData();
 709             if (child->GetType() == ctTypeBoolRadio && child->IsEnabled())
 710             {
 711                 wxString configureCommand = child->GetPropertyString(wxT("configure-command"));
 712                 if (!configureCommand.IsEmpty())
 713                     str << wxT(" ") << configureCommand;
 714             }
 715         }
 716     }
 717
 718     GenerateConfigureCommand(GetTopItem(), str);
 719     return str;
 720 }
 721
 722 /// Helper function
 723 void ctConfigToolDoc::GenerateConfigureCommand(ctConfigItem* item, wxString& str)
 724 {
 725     // We don't process the platform group, since we've
 726     // already done so.
 727     if (item->GetName() == wxT("Target"))
 728         return;
 729
 730     if (item->IsInActiveContext() &&
 731         (item->GetType() == ctTypeCheckGroup ||
 732         item->GetType() == ctTypeRadioGroup ||
 733         item->GetType() == ctTypeBoolCheck ||
 734         item->GetType() == ctTypeBoolRadio))
 735     {
 736         wxString name = item->GetName();
 737         wxString configureCommand = item->GetPropertyString(wxT("configure-command"));
 738         if (!configureCommand.IsEmpty())
 739         {
 740             if (!item->IsEnabled())
 741             {
 742                 // Replace 'enable' with 'disable' if this
 743                 // option is off.
 744                 configureCommand.Replace(wxT("--enable-"), wxT("--disable-"));
 745                 configureCommand.Replace(wxT("--with-"), wxT("--without-"));
 746             }
 747             ctProperty* prop = item->GetProperties().FindProperty(wxT("builtin"));
 748             if (prop && prop->GetVariant().GetType() == wxT("bool"))
 749             {
 750                 bool builtin = prop->GetVariant().GetBool();
 751                 str << wxT(" ") << configureCommand;
 752                 if (builtin)
 753                     str << wxT("=builtin");
 754                 else
 755                     str << wxT("=sys");
 756             }
 757             else
 758             {
 759                 ctProperty* prop = item->GetProperties().FindProperty(wxT("value"));
 760                 if (prop && prop->GetVariant().GetType() == wxT("string"))
 761                 {
 762                     wxString val = prop->GetVariant().GetString();
 763                     if (item->IsEnabled() && !val.IsEmpty())
 764                     {
 765                         str << wxT(" ") << configureCommand;
 766                         str << wxT("=\"") << val << wxT("\"");
 767                     }
 768                     // If the string is empty, ignore this parameter,
 769                     // since it's obviously intended to be supplied
 770                     // only if there's a string to use and it's enabled.
 771                 }
 772                 else
 773                 {
 774                     str << wxT(" ") << configureCommand;
 775                 }
 776             }
 777         }
 778     }
 779
 780     for ( wxObjectList::compatibility_iterator node = item->GetChildren().GetFirst(); node; node = node->GetNext() )
 781     {
 782         ctConfigItem* child = (ctConfigItem*) node->GetData();
 783         GenerateConfigureCommand(child, str);
 784     }
 785 }
 786
 787 /// Gets the current framework directory
 788 wxString ctConfigToolDoc::GetFrameworkDir(bool makeUnix)
 789 {
 790     wxString path = wxGetApp().GetSettings().m_frameworkDir;
 791     if (wxGetApp().GetSettings().m_useEnvironmentVariable)
 792     {
 793         // Should probably allow other variables
 794         // to be used, and maybe expand variables within m_frameworkDir
 795         wxString pathEnv(wxGetenv(wxT("WXWIN")));
 796         path = pathEnv;
 797 #ifdef __WXMSW__
 798         if (makeUnix)
 799             path.Replace(wxT("\\"), wxT("/"));
 800 #else
 801         wxUnusedVar(makeUnix);
 802 #endif
 803     }
 804     return path;
 805 }
 806
 807 /// Finds the next item in the tree
 808 ctConfigItem* ctConfigToolDoc::FindNextItem(ctConfigItem* item, bool wrap)
 809 {
 810     if (!item)
 811         return GetTopItem();
 812
 813     // First, try to find the first child
 814     if (item->GetChildCount() > 0)
 815     {
 816         return item->GetChild(0);
 817     }
 818     else
 819     {
 820         ctConfigItem* p = item;
 821         while (p)
 822         {
 823             ctConfigItem* toFind = FindNextSibling(p);
 824             if (toFind)
 825                 return toFind;
 826             p = p->GetParent();
 827         }
 828     }
 829
 830     // Finally, wrap around to the root.
 831     if (wrap)
 832         return GetTopItem();
 833     else
 834         return NULL;
 835 }
 836
 837 /// Finds the next sibling in the tree
 838 ctConfigItem* ctConfigToolDoc::FindNextSibling(ctConfigItem* item)
 839 {
 840     if (item->GetParent())
 841     {
 842         wxObjectList::compatibility_iterator node = item->GetParent()->GetChildren().Member(item);
 843         if (node && node->GetNext())
 844         {
 845             ctConfigItem* nextItem = (ctConfigItem*) node->GetNext()->GetData();
 846             return nextItem;
 847         }
 848     }
 849     return NULL;
 850 }
 851
 852
 853 /*
 854  * Implements a document editing command.
 855  */
 856
 857 ctConfigCommand::ctConfigCommand(const wxString& name, int cmdId,
 858         ctConfigItem* activeState, ctConfigItem* savedState,
 859         ctConfigItem* parent, ctConfigItem* insertBefore,
 860         bool ignoreFirstTime): wxCommand(true, name)
 861 {
 862     m_activeState = activeState;
 863     m_savedState = savedState;
 864     m_ignoreThis = ignoreFirstTime;
 865     m_cmdId = cmdId;
 866     m_properties = NULL;
 867     m_parent = parent;
 868     m_insertBefore = insertBefore;
 869 }
 870
 871 ctConfigCommand::ctConfigCommand(const wxString& name, int cmdId,
 872         ctConfigItem* activeState,  ctProperties* properties,
 873         bool ignoreFirstTime): wxCommand(true, name)
 874 {
 875     m_activeState = activeState;
 876     m_savedState = NULL;
 877     m_properties = properties;
 878     m_ignoreThis = ignoreFirstTime;
 879     m_cmdId = cmdId;
 880     m_properties = properties;
 881     m_parent = NULL;
 882     m_insertBefore = NULL;
 883 }
 884
 885 ctConfigCommand::~ctConfigCommand()
 886 {
 887     if (m_savedState)
 888         delete m_savedState;
 889     if (m_properties)
 890         delete m_properties;
 891 }
 892
 893 bool ctConfigCommand::Do()
 894 {
 895     return DoAndUndo(true);
 896 }
 897
 898 bool ctConfigCommand::Undo()
 899 {
 900     return DoAndUndo(false);
 901 }
 902
 903 // Combine Do and Undo into one
 904 bool ctConfigCommand::DoAndUndo(bool doCmd)
 905 {
 906     switch (m_cmdId)
 907     {
 908     case ctCMD_CUT:
 909         {
 910             if (doCmd)
 911             {
 912                 wxASSERT(m_savedState == NULL);
 913                 wxASSERT(m_activeState != NULL);
 914
 915                 ctConfigItem* newItem = m_activeState->DeepClone();
 916                 ctConfigToolDoc* doc = m_activeState->GetDocument();
 917
 918                 // This will delete the old clipboard contents, if any.
 919                 doc->SetClipboardItem(newItem);
 920
 921                 m_parent = m_activeState->GetParent();
 922                 m_insertBefore = m_activeState->FindNextSibling();
 923
 924                 m_activeState->Detach();
 925                 m_savedState = m_activeState;
 926                 m_activeState = NULL;
 927
 928                 m_savedState->GetDocument()->Modify(true);
 929                 ctConfigToolView* view = (ctConfigToolView*) m_savedState->GetDocument()->GetFirstView();
 930                 view->OnChangeFilename();
 931             }
 932             else
 933             {
 934                 wxASSERT(m_savedState != NULL);
 935                 wxASSERT(m_activeState == NULL);
 936
 937                 m_savedState->GetDocument()->Modify(true);
 938                 m_savedState->Attach(m_parent, m_insertBefore);
 939                 ctConfigToolView* view = (ctConfigToolView*) m_savedState->GetDocument()->GetFirstView();
 940                 view->AddItems(wxGetApp().GetMainFrame()->GetConfigTreeCtrl(), m_savedState);
 941                 m_activeState = m_savedState;
 942                 m_savedState = NULL;
 943                 m_parent = NULL;
 944                 m_insertBefore = NULL;
 945                 view->OnChangeFilename();
 946             }
 947             break;
 948         }
 949     case ctCMD_PASTE:
 950         {
 951             if (doCmd)
 952             {
 953                 wxASSERT(m_savedState != NULL);
 954                 wxASSERT(m_activeState == NULL);
 955
 956                 m_savedState->GetDocument()->Modify(true);
 957                 m_savedState->Attach(m_parent, m_insertBefore);
 958                 ctConfigToolView* view = (ctConfigToolView*) m_savedState->GetDocument()->GetFirstView();
 959                 view->AddItems(wxGetApp().GetMainFrame()->GetConfigTreeCtrl(), m_savedState);
 960                 wxGetApp().GetMainFrame()->GetConfigTreeCtrl()->SelectItem(m_savedState->GetTreeItemId());
 961                 m_activeState = m_savedState;
 962                 m_savedState = NULL;
 963                 view->OnChangeFilename();
 964             }
 965             else
 966             {
 967                 wxASSERT(m_savedState == NULL);
 968                 wxASSERT(m_activeState != NULL);
 969
 970                 m_activeState->GetDocument()->Modify(true);
 971                 ctConfigToolView* view = (ctConfigToolView*) m_activeState->GetDocument()->GetFirstView();
 972                 m_activeState->Detach();
 973                 m_savedState = m_activeState;
 974                 m_activeState = NULL;
 975                 view->OnChangeFilename();
 976             }
 977             break;
 978         }
 979     case ctCMD_NEW_ELEMENT:
 980         {
 981             if (doCmd)
 982             {
 983                 wxASSERT(m_savedState != NULL);
 984                 wxASSERT(m_activeState == NULL);
 985
 986                 m_savedState->GetDocument()->Modify(true);
 987                 m_savedState->Attach(m_parent, m_insertBefore);
 988                 ctConfigToolView* view = (ctConfigToolView*) m_savedState->GetDocument()->GetFirstView();
 989                 view->AddItems(wxGetApp().GetMainFrame()->GetConfigTreeCtrl(), m_savedState);
 990                 wxGetApp().GetMainFrame()->GetConfigTreeCtrl()->SelectItem(m_savedState->GetTreeItemId());
 991
 992                 m_activeState = m_savedState;
 993                 m_savedState = NULL;
 994             }
 995             else
 996             {
 997                 wxASSERT(m_savedState == NULL);
 998                 wxASSERT(m_activeState != NULL);
 999
1000                 m_activeState->GetDocument()->Modify(true);
1001                 m_activeState->Detach();
1002                 m_savedState = m_activeState;
1003                 m_activeState = NULL;
1004             }
1005             break;
1006         }
1007     case ctCMD_APPLY_PROPERTY:
1008         {
1009             wxASSERT(m_properties != NULL);
1010             wxASSERT(m_activeState != NULL);
1011
1012             // Don't update the properties editor first time
1013             // around since it will be done one property at a time
1014             // initially (and no property editor update required)
1015             if (!m_ignoreThis)
1016             {
1017                 // Just swap the saved and current properties.
1018                 ctProperties propsTemp = m_activeState->GetProperties() ;
1019                 m_activeState->GetProperties() = (* m_properties);
1020                 (* m_properties) = propsTemp;
1021
1022                 // Apply only those that need applying
1023                 // (those properties in activeState that are not in propsTemp)
1024                 wxObjectList::compatibility_iterator node = m_activeState->GetProperties().GetList().GetFirst();
1025                 while (node)
1026                 {
1027                     ctProperty* prop = (ctProperty*) node->GetData();
1028                     ctProperty* otherProp = propsTemp.FindProperty(prop->GetName());
1029                     if (otherProp && ((*prop) != (*otherProp)))
1030                     {
1031                         m_activeState->ApplyProperty(prop, otherProp->GetVariant());
1032                     }
1033                     node = node->GetNext();
1034                 }
1035                 m_activeState->GetDocument()->Modify(true);
1036                 ctConfigToolView* view = (ctConfigToolView*) m_activeState->GetDocument()->GetFirstView();
1037                 if (view)
1038                 {
1039                     ctConfigToolHint hint(NULL, ctValueChanged);
1040                     m_activeState->GetDocument()->UpdateAllViews (NULL, & hint);
1041                 }
1042             }
1043             m_ignoreThis = false;
1044
1045             break;
1046         }
1047     }
1048     return true;
1049 }
1050
1051 IMPLEMENT_CLASS(ctConfiguration, wxObject)
1052
1053 ctConfiguration::ctConfiguration()
1054 {
1055     m_treeItemId = wxTreeItemId();
1056     m_parent = NULL;
1057     m_topItem = NULL;
1058 }
1059
1060 ctConfiguration::ctConfiguration(ctConfiguration* parent, const wxString& name)
1061 {
1062     m_treeItemId = wxTreeItemId();
1063     SetName(name);
1064     m_parent = parent;
1065     if (parent)
1066         parent->AddChild(this);
1067 }
1068
1069 ctConfiguration::~ctConfiguration()
1070 {
1071 /*
1072     ctConfigTreeCtrl* treeCtrl = wxGetApp().GetMainFrame()->GetConfigTreeCtrl();
1073     if (m_treeItemId.IsOk() && treeCtrl)
1074     {
1075         ctTreeItemData* data = (ctTreeItemData*) treeCtrl->GetItemData(m_treeItemId);
1076         if (data)
1077             data->SetConfigItem(NULL);
1078     }
1079     if (GetParent())
1080         GetParent()->RemoveChild(this);
1081     else
1082     {
1083         if (wxGetApp().GetMainFrame()->GetDocument() &&
1084             wxGetApp().GetMainFrame()->GetDocument()->GetTopItem() == this)
1085             wxGetApp().GetMainFrame()->GetDocument()->SetTopItem(NULL);
1086     }
1087 */
1088
1089     Clear();
1090 }
1091
1092 /// Assignment operator.
1093 void ctConfiguration::operator= (const ctConfiguration& configuration)
1094 {
1095     m_name = configuration.m_name;
1096     m_description = configuration.m_description;
1097 }
1098
1099 /// Clear children
1100 void ctConfiguration::Clear()
1101 {
1102     wxObjectList::compatibility_iterator node = m_children.GetFirst();
1103     while (node)
1104     {
1105         wxObjectList::compatibility_iterator next = node->GetNext();
1106         ctConfiguration* child = (ctConfiguration*) node->GetData();
1107
1108         // This should delete 'node' too, assuming
1109         // child's m_parent points to 'this'. If not,
1110         // it'll be cleaned up by m_children.Clear().
1111         delete child;
1112
1113         node = next;
1114     }
1115     m_children.Clear();
1116 }
1117
1118 // Get the nth child
1119 ctConfiguration* ctConfiguration::GetChild(int n) const
1120 {
1121     wxASSERT ( n < GetChildCount() && n > -1 );
1122
1123     if ( n < GetChildCount() && n > -1 )
1124     {
1125         ctConfiguration* child = wxDynamicCast(m_children.Item(n)->GetData(), ctConfiguration);
1126         return child;
1127     }
1128     else
1129         return NULL;
1130 }
1131
1132 // Get the child count
1133 int ctConfiguration::GetChildCount() const
1134 {
1135     return m_children.GetCount();
1136 }
1137
1138 /// Add a child
1139 void ctConfiguration::AddChild(ctConfiguration* configuration)
1140 {
1141     m_children.Append(configuration);
1142     configuration->SetParent(this);
1143 }
1144
1145 /// Remove (but don't delete) a child
1146 void ctConfiguration::RemoveChild(ctConfiguration* configuration)
1147 {
1148     m_children.DeleteObject(configuration);
1149     configuration->SetParent(NULL);
1150 }
1151
1152 /// Get the associated document (currently, assumes
1153 /// there's only ever one document active)
1154 ctConfigToolDoc* ctConfiguration::GetDocument()
1155 {
1156     ctConfigToolDoc* doc = wxGetApp().GetMainFrame()->GetDocument();
1157     return doc;
1158 }
1159
1160 /// Find an item in this hierarchy
1161 // TODO: ensure that names are unique, somehow.
1162 ctConfiguration* ctConfiguration::FindConfiguration(const wxString& name)
1163 {
1164     if (GetName() == name)
1165         return this;
1166
1167     for ( wxObjectList::compatibility_iterator node = GetChildren().GetFirst(); node; node = node->GetNext() )
1168     {
1169         ctConfiguration* child = (ctConfiguration*) node->GetData();
1170         ctConfiguration* found = child->FindConfiguration(name);
1171         if (found)
1172             return found;
1173     }
1174     return NULL;
1175 }
1176
1177 /// Find the next sibling
1178 ctConfiguration* ctConfiguration::FindNextSibling()
1179 {
1180     if (!GetParent())
1181         return NULL;
1182     wxObjectList::compatibility_iterator node = GetParent()->GetChildren().Member(this);
1183     if (node && node->GetNext())
1184     {
1185         return (ctConfiguration*) node->GetNext()->GetData();
1186     }
1187     return NULL;
1188 }
1189
1190 /// Find the previous sibling
1191 ctConfiguration* ctConfiguration::FindPreviousSibling()
1192 {
1193     if (!GetParent())
1194         return NULL;
1195     wxObjectList::compatibility_iterator node = GetParent()->GetChildren().Member(this);
1196     if (node && node->GetPrevious())
1197     {
1198         return (ctConfiguration*) node->GetPrevious()->GetData();
1199     }
1200     return NULL;
1201 }
1202
1203 /// Create a clone of this and children
1204 ctConfiguration* ctConfiguration::DeepClone()
1205 {
1206     ctConfiguration* newItem = Clone();
1207
1208     for ( wxObjectList::compatibility_iterator node = GetChildren().GetFirst(); node; node = node->GetNext() )
1209     {
1210         ctConfiguration* child = (ctConfiguration*) node->GetData();
1211         ctConfiguration* newChild = child->DeepClone();
1212         newItem->AddChild(newChild);
1213     }
1214     return newItem;
1215 }
1216
1217 /// Detach: remove from parent, and remove tree items
1218 void ctConfiguration::Detach()
1219 {
1220     // TODO
1221     if (GetParent())
1222         GetParent()->RemoveChild(this);
1223     else
1224         GetDocument()->SetTopItem(NULL);
1225     SetParent(NULL);
1226
1227 /*
1228     wxTreeItemId treeItem = GetTreeItemId();
1229
1230     DetachFromTree();
1231
1232     // Will delete the branch, but not the config items.
1233     wxGetApp().GetMainFrame()->GetConfigTreeCtrl()->Delete(treeItem);
1234 */
1235 }
1236
1237 /// Hide from tree: make sure tree deletions won't delete
1238 /// the config items
1239 void ctConfiguration::DetachFromTree()
1240 {
1241 /*
1242     wxTreeItemId item = GetTreeItemId();
1243
1244     // TODO
1245     ctTreeItemData* data = (ctTreeItemData*) wxGetApp().GetMainFrame()->GetConfigTreeCtrl()->GetItemData(item);
1246     data->SetConfigItem(NULL);
1247     m_treeItemId = wxTreeItemId();
1248
1249     for ( wxNode* node = GetChildren().GetFirst(); node; node = node->GetNext() )
1250     {
1251         ctConfiguration* child = (ctConfiguration*) node->GetData();
1252         child->DetachFromTree();
1253     }
1254 */
1255 }