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