1 /////////////////////////////////////////////////////////////////////////////
2 // Name: configtooldoc.h
3 // Purpose: Document class
4 // Author: Julian Smart
8 // Copyright: (c) Julian Smart
10 /////////////////////////////////////////////////////////////////////////////
12 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
13 #pragma implementation "configtooldoc.h"
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"
33 #include "configtooldoc.h"
34 #include "configtoolview.h"
35 #include "configtree.h"
36 #include "mainframe.h"
38 #include "wxconfigtool.h"
39 #include "htmlparser.h"
41 IMPLEMENT_DYNAMIC_CLASS(ctConfigToolDoc
, wxDocument
)
44 ctConfigToolDoc::ctConfigToolDoc()
47 m_clipboardItem
= NULL
;
51 ctConfigToolDoc::~ctConfigToolDoc()
55 if (GetCommandProcessor())
56 GetCommandProcessor()->SetEditMenu(NULL
);
59 // Delete all the items not already deleted
60 void ctConfigToolDoc::DeleteItems()
67 /// Clears the clipboard item.
68 void ctConfigToolDoc::ClearClipboard()
71 delete m_clipboardItem
;
72 m_clipboardItem
= NULL
;
75 /// Sets the clipboard item.
76 void ctConfigToolDoc::SetClipboardItem(ctConfigItem
* item
)
79 delete m_clipboardItem
;
80 m_clipboardItem
= item
;
84 // Closes and clears the document
85 bool ctConfigToolDoc::OnCloseDocument()
87 if (wxDocument::OnCloseDocument())
89 ctConfigToolHint
hint(NULL
, ctClear
);
90 UpdateAllViews (NULL
, & hint
);
102 bool ctConfigToolDoc::Save()
106 if (!IsModified() && m_savedYet
) return TRUE
;
107 if (m_documentFile
== wxT("") || !m_savedYet
)
110 ret
= OnSaveDocument(m_documentFile
);
112 SetDocumentSaved(TRUE
);
116 // Create the document
117 bool ctConfigToolDoc::OnCreate(const wxString
& path
, long flags
)
119 GetCommandProcessor()->SetEditMenu(wxGetApp().GetMainFrame()->GetEditMenu());
120 GetCommandProcessor()->Initialize();
121 GetCommandProcessor()->ClearCommands();
123 // wxGetApp().m_currentDoc = this;
125 if (flags
& wxDOC_NEW
)
127 ctConfigItem
* rootItem
= new ctConfigItem(NULL
, ctTypeGroup
, _T("Configuration"));
128 //rootItem->InitProperties();
129 rootItem
->GetProperties().AddProperty(
131 wxT("The item description."),
132 wxVariant(wxT(""), wxT("description")),
135 rootItem
->SetPropertyString(_T("description"),
136 _T("<B>This is the top-level configuration item.</B>"));
139 SetTopItem(rootItem
);
142 SetDocumentSaved(FALSE
);
144 wxString
rootName(wxT("untitled"));
145 wxStripExtension(rootName
);
146 SetFilename(wxGetApp().GetSettings().GenerateFilename(rootName
));
149 // Creates the view, so do any view updating after this
150 bool success
= wxDocument::OnCreate(path
, flags
);
154 if (flags
& wxDOC_NEW
)
158 ctConfigToolHint
hint(NULL
, ctInitialUpdate
);
159 UpdateAllViews (NULL
, & hint
);
161 SetFilename(GetFilename(), TRUE
);
168 bool ctConfigToolDoc::OnSaveDocument(const wxString
& filename
)
172 const wxString
strOldPath(GetFilename());
174 // Do some backing up first
176 // This is the backup filename
177 wxString
backupFilename(filename
);
178 backupFilename
+= wxT(".bak");
180 // This is the temporary copy of the backup
181 wxString
tempFilename(filename
);
182 tempFilename
+= wxT(".tmp");
183 if (wxFileExists(tempFilename
))
184 wxRemoveFile(tempFilename
);
186 bool leaveBackup
= TRUE
;
188 bool saved
= DoSave(tempFilename
);
192 // Remove the old .bak file
193 if (wxFileExists(backupFilename
))
195 wxRemoveFile(backupFilename
);
198 // Copy the old file to the .bak
202 if (wxFileExists(filename
))
204 if (!wxRenameFile(filename
, backupFilename
))
206 wxCopyFile(filename
, backupFilename
);
207 wxRemoveFile(filename
);
213 if (wxFileExists(filename
))
214 wxRemoveFile(filename
);
217 // Finally, copy the temporary file to the proper filename
218 if (!wxRenameFile(tempFilename
, filename
))
220 wxCopyFile(tempFilename
, filename
);
221 wxRemoveFile(tempFilename
);
225 ((ctConfigToolView
*)GetFirstView())->OnChangeFilename();
226 SetDocumentSaved(TRUE
);
227 SetFilename(filename
);
228 wxGetApp().GetSettings().m_lastFilename
= filename
;
231 SetFilename(strOldPath
);
233 wxGetApp().GetMainFrame()->UpdateFrameTitle();
238 bool ctConfigToolDoc::OnOpenDocument(const wxString
& filename
)
242 bool opened
= DoOpen(filename
);
246 SetFilename(filename
);
247 wxGetApp().GetSettings().m_lastFilename
= filename
;
249 ((ctConfigToolView
*)GetFirstView())->OnChangeFilename();
251 RefreshDependencies();
253 // ctConfigToolHint hint(NULL, ctFilenameChanged);
254 ctConfigToolHint
hint(NULL
, ctInitialUpdate
);
255 UpdateAllViews (NULL
, & hint
);
258 SetDocumentSaved(TRUE
); // Necessary or it will pop up the Save As dialog
263 /// Save the settings file
264 bool ctConfigToolDoc::DoSave(const wxString
& filename
)
266 wxFileOutputStream
stream(filename
);
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\">");
273 DoSave(m_topItem
, stream
, 1);
275 stream
<< wxT("\n</settings>\n");
280 inline static void OutputIndentation(wxOutputStream
& stream
, int indent
)
282 wxString str
= wxT("\n");
283 for (int i
= 0; i
< indent
; i
++)
284 str
<< wxT(' ') << wxT(' ');
288 /// Recursive helper function for file saving
289 bool ctConfigToolDoc::DoSave(ctConfigItem
* item
, wxOutputStream
& stream
, int indent
)
291 OutputIndentation(stream
, indent
*2);
293 wxString
name(item
->GetName());
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");
311 typeStr
= wxT("unknown");
313 stream
<< wxT("<setting type=\"") << typeStr
<< wxT("\">");
317 OutputIndentation(stream
, indent
*2);
318 if (item
->IsActive())
319 stream
<< wxT("<active>1</active>");
321 stream
<< wxT("<active>0</active>");
322 OutputIndentation(stream
, indent
*2);
323 if (item
->IsEnabled())
324 stream
<< wxT("<enabled>1</enabled>");
326 stream
<< wxT("<enabled>0</enabled>");
329 wxNode
* node
= item
->GetProperties().GetList().GetFirst();
332 ctProperty
* prop
= (ctProperty
*) node
->GetData();
333 OutputIndentation(stream
, indent
*2);
334 stream
<< wxT("<") << prop
->GetName() ;
336 if (prop
->IsCustom())
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)
345 ctConfigItem::ArrayToString(prop
->GetChoices(), choices
);
346 stream
<< wxT(" choices=\"") << choices
<< wxT("\"");
352 stream
<< ctEscapeHTMLCharacters(prop
->GetVariant().GetString()) ;
353 stream
<< wxT("</") << prop
->GetName() << wxT(">");
355 node
= node
->GetNext();
359 node
= item
->GetChildren().GetFirst();
362 ctConfigItem
* child
= (ctConfigItem
*) node
->GetData();
363 DoSave(child
, stream
, indent
);
365 node
= node
->GetNext();
370 OutputIndentation(stream
, indent
*2);
371 stream
<< wxT("</setting>");
376 /// Open the settings file
377 bool ctConfigToolDoc::DoOpen(const wxString
& filename
)
379 wxSimpleHtmlParser parser
;
380 if (parser
.ParseFile(filename
))
382 ctConfigToolHint
hint(NULL
, ctClear
);
383 UpdateAllViews (NULL
, & hint
);
386 if (parser
.GetTopLevelTag()->GetChildren())
388 wxSimpleHtmlTag
* settingsTag
= parser
.GetTopLevelTag()->GetChildren()->FindTag(wxT("settings"));
389 if (settingsTag
&& settingsTag
->GetChildren())
391 wxSimpleHtmlTag
* firstSettingTag
= settingsTag
->GetChildren();
393 DoOpen(firstSettingTag
, NULL
);
402 static bool GetHtmlBoolValue(const wxString
& value
)
404 if (value
== wxT("true") || value
== wxT("TRUE") || value
== wxT("1"))
410 static int GetHtmlIntegerValue(const wxString
& value
)
412 return wxAtoi(value
);
415 static double GetHtmlDoubleValue(const wxString
& value
)
417 return wxAtof(value
);
420 bool ctConfigToolDoc::DoOpen(wxSimpleHtmlTag
* tag
, ctConfigItem
* parent
)
422 ctConfigItem
* newItem
= NULL
;
423 if (tag
->NameIs(wxT("setting")))
425 wxSimpleHtmlAttribute
* attr
= tag
->FindAttribute(wxT("type"));
428 ctConfigType type
= ctTypeUnknown
;
429 wxString
typeStr(attr
->GetValue());
430 if (typeStr
== wxT("group"))
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"))
442 else if (typeStr
== wxT("integer"))
443 type
= ctTypeInteger
;
446 wxLogError(wxT("Unknown type %s"), (const wxChar
*) typeStr
);
448 if (type
!= ctTypeUnknown
)
450 newItem
= new ctConfigItem(parent
, type
, wxT(""));
451 newItem
->InitProperties();
457 wxSimpleHtmlTag
* childTag
= tag
->GetChildren();
461 if (childTag
->GetType() == wxSimpleHtmlTag_Open
)
463 if (childTag
->GetName() == wxT("setting"))
465 DoOpen(childTag
, newItem
);
467 else if (childTag
->GetName() == wxT("name"))
471 wxString
name(childTag
->GetNext()->GetTagText());
472 newItem
->SetName(name
);
475 else if (childTag
->GetName() == wxT("active"))
478 newItem
->SetActive(GetHtmlBoolValue(childTag
->GetNext()->GetTagText()));
480 else if (childTag
->GetName() == wxT("enabled"))
483 newItem
->Enable(GetHtmlBoolValue(childTag
->GetNext()->GetTagText()));
489 ctProperty
* prop
= newItem
->GetProperties().FindProperty(childTag
->GetName());
492 // A custom property, else an obsolete
493 // property that we should ignore.
495 if (childTag
->GetAttributeValue(isCustom
, wxT("custom")) &&
496 isCustom
== wxT("true"))
498 prop
= new ctProperty
;
500 wxString
name(childTag
->GetName());
501 wxString
type(wxT("string"));
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"));
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
);
517 prop
->GetVariant() = wxVariant(wxT(""), name
);
518 prop
->SetDescription(description
);
519 prop
->SetCustom(TRUE
);
520 prop
->SetEditorType(editorType
);
521 if (!choices
.IsEmpty())
524 ctConfigItem::StringToArray(choices
, arr
);
525 prop
->SetChoices(arr
);
527 newItem
->GetProperties().AddProperty(prop
);
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());
544 childTag
= childTag
->GetNext();
549 /// Clear dependencies
550 void ctConfigToolDoc::ClearDependencies(ctConfigItem
* item
)
555 item
->GetDependents().Clear();
556 for ( wxNode
* node
= item
->GetChildren().GetFirst(); node
; node
= node
->GetNext() )
558 ctConfigItem
* child
= (ctConfigItem
*) node
->GetData();
559 ClearDependencies(child
);
563 /// Refresh dependencies
564 void ctConfigToolDoc::RefreshDependencies()
566 ClearDependencies(GetTopItem());
567 RefreshDependencies(GetTopItem());
570 /// Refresh dependencies
571 void ctConfigToolDoc::RefreshDependencies(ctConfigItem
* item
)
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"));
581 if (!requires.IsEmpty())
582 item
->StringToArray(requires, requiresArr
);
584 if (!precludes
.IsEmpty())
585 item
->StringToArray(precludes
, requiresArr
);
587 if (!enabledIfNot
.IsEmpty())
588 item
->StringToArray(enabledIfNot
, requiresArr
);
590 if (!enabledIf
.IsEmpty())
591 item
->StringToArray(enabledIf
, requiresArr
);
593 if (!indeterminateIf
.IsEmpty())
594 item
->StringToArray(indeterminateIf
, requiresArr
);
596 // Add the parent to the list of dependencies, if the
597 // parent is a check or radio group.
598 ctConfigItem
* parent
= item
->GetParent();
600 (parent
->GetType() == ctTypeCheckGroup
||
601 parent
->GetType() == ctTypeRadioGroup
))
602 requiresArr
.Add(parent
->GetName());
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
);
612 for (i
= 0; i
< requiresArr
.GetCount(); i
++)
614 wxString
itemName(requiresArr
[i
]);
615 ctConfigItem
* otherItem
= GetTopItem()->FindItem(itemName
);
616 if (otherItem
&& !otherItem
->GetDependents().Member(item
))
618 otherItem
->GetDependents().Append(item
);
621 for ( wxNode
* node
= item
->GetChildren().GetFirst(); node
; node
= node
->GetNext() )
623 ctConfigItem
* child
= (ctConfigItem
*) node
->GetData();
624 RefreshDependencies(child
);
628 /// Generate the text of a setup.h
629 wxString
ctConfigToolDoc::GenerateSetup()
632 str
<< wxT("/*\n * setup.h\n * Generated by wxConfigTool\n *\n */\n\n");
634 GenerateSetup(GetTopItem(), str
);
640 void ctConfigToolDoc::GenerateSetup(ctConfigItem
* item
, wxString
& str
)
642 // Generate the setup.h entries for this item
643 wxString name
= item
->GetName();
645 // We don't process the platform choice
646 if (item
->GetName() == wxT("Target"))
649 if (item
->IsInActiveContext() &&
650 (item
->GetType() == ctTypeCheckGroup
||
651 item
->GetType() == ctTypeRadioGroup
||
652 item
->GetType() == ctTypeBoolCheck
||
653 item
->GetType() == ctTypeBoolRadio
))
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
)
661 str
<< wxT("#define ") << name
;
662 if (item
->IsEnabled())
670 for ( wxNode
* node
= item
->GetChildren().GetFirst(); node
; node
= node
->GetNext() )
672 ctConfigItem
* child
= (ctConfigItem
*) node
->GetData();
673 GenerateSetup(child
, str
);
678 /// Generate a configure command
679 wxString
ctConfigToolDoc::GenerateConfigureCommand()
682 str
<< wxT("# configurewx\n# Generated by wxConfigTool\n\n");
684 wxString path
= GetFrameworkDir(TRUE
);
685 bool makeUnix
= TRUE
;
691 path
+= wxFILE_SEP_PATH
;
694 str
<< path
<< wxT("configure");
696 // Find the target to use
697 ctConfigItem
* platformsFolder
= GetTopItem()->FindItem(wxT("Target"));
700 for ( wxNode
* node
= platformsFolder
->GetChildren().GetFirst(); node
; node
= node
->GetNext() )
702 ctConfigItem
* child
= (ctConfigItem
*) node
->GetData();
703 if (child
->GetType() == ctTypeBoolRadio
&& child
->IsEnabled())
705 wxString configureCommand
= child
->GetPropertyString(wxT("configure-command"));
706 if (!configureCommand
.IsEmpty())
707 str
<< wxT(" ") << configureCommand
;
712 GenerateConfigureCommand(GetTopItem(), str
);
717 void ctConfigToolDoc::GenerateConfigureCommand(ctConfigItem
* item
, wxString
& str
)
719 // We don't process the platform group, since we've
721 if (item
->GetName() == wxT("Target"))
724 if (item
->IsInActiveContext() &&
725 (item
->GetType() == ctTypeCheckGroup
||
726 item
->GetType() == ctTypeRadioGroup
||
727 item
->GetType() == ctTypeBoolCheck
||
728 item
->GetType() == ctTypeBoolRadio
))
730 wxString name
= item
->GetName();
731 wxString configureCommand
= item
->GetPropertyString(wxT("configure-command"));
732 if (!configureCommand
.IsEmpty())
734 if (!item
->IsEnabled())
736 // Replace 'enable' with 'disable' if this
738 configureCommand
.Replace(wxT("--enable-"), wxT("--disable-"));
739 configureCommand
.Replace(wxT("--with-"), wxT("--without-"));
741 ctProperty
* prop
= item
->GetProperties().FindProperty(wxT("builtin"));
742 if (prop
&& prop
->GetVariant().GetType() == wxT("bool"))
744 bool builtin
= prop
->GetVariant().GetBool();
745 str
<< wxT(" ") << configureCommand
;
747 str
<< wxT("=builtin");
753 ctProperty
* prop
= item
->GetProperties().FindProperty(wxT("value"));
754 if (prop
&& prop
->GetVariant().GetType() == wxT("string"))
756 wxString val
= prop
->GetVariant().GetString();
757 if (item
->IsEnabled() && !val
.IsEmpty())
759 str
<< wxT(" ") << configureCommand
;
760 str
<< wxT("=\"") << val
<< wxT("\"");
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.
768 str
<< wxT(" ") << configureCommand
;
774 for ( wxNode
* node
= item
->GetChildren().GetFirst(); node
; node
= node
->GetNext() )
776 ctConfigItem
* child
= (ctConfigItem
*) node
->GetData();
777 GenerateConfigureCommand(child
, str
);
781 /// Gets the current framework directory
782 wxString
ctConfigToolDoc::GetFrameworkDir(bool makeUnix
)
784 wxString path
= wxGetApp().GetSettings().m_frameworkDir
;
785 if (wxGetApp().GetSettings().m_useEnvironmentVariable
)
787 // Should probably allow other variables
788 // to be used, and maybe expand variables within m_frameworkDir
789 path
= wxGetenv(wxT("WXWIN"));
792 path
.Replace(wxT("\\"), wxT("/"));
798 /// Finds the next item in the tree
799 ctConfigItem
* ctConfigToolDoc::FindNextItem(ctConfigItem
* item
, bool wrap
)
804 // First, try to find the first child
805 if (item
->GetChildCount() > 0)
807 return item
->GetChild(0);
811 ctConfigItem
* p
= item
;
814 ctConfigItem
* toFind
= FindNextSibling(p
);
821 // Finally, wrap around to the root.
828 /// Finds the next sibling in the tree
829 ctConfigItem
* ctConfigToolDoc::FindNextSibling(ctConfigItem
* item
)
831 if (item
->GetParent())
833 wxNode
* node
= item
->GetParent()->GetChildren().Member(item
);
834 if (node
&& node
->GetNext())
836 ctConfigItem
* nextItem
= (ctConfigItem
*) node
->GetNext()->GetData();
845 * Implements a document editing command.
848 ctConfigCommand::ctConfigCommand(const wxString
& name
, int cmdId
,
849 ctConfigItem
* activeState
, ctConfigItem
* savedState
,
850 ctConfigItem
* parent
, ctConfigItem
* insertBefore
,
851 bool ignoreFirstTime
): wxCommand(TRUE
, name
)
853 m_activeState
= activeState
;
854 m_savedState
= savedState
;
855 m_ignoreThis
= ignoreFirstTime
;
859 m_insertBefore
= insertBefore
;
862 ctConfigCommand::ctConfigCommand(const wxString
& name
, int cmdId
,
863 ctConfigItem
* activeState
, ctProperties
* properties
,
864 bool ignoreFirstTime
): wxCommand(TRUE
, name
)
866 m_activeState
= activeState
;
868 m_properties
= properties
;
869 m_ignoreThis
= ignoreFirstTime
;
871 m_properties
= properties
;
873 m_insertBefore
= NULL
;
876 ctConfigCommand::~ctConfigCommand()
884 bool ctConfigCommand::Do()
886 return DoAndUndo(TRUE
);
889 bool ctConfigCommand::Undo()
891 return DoAndUndo(FALSE
);
894 // Combine Do and Undo into one
895 bool ctConfigCommand::DoAndUndo(bool doCmd
)
903 wxASSERT(m_savedState
== NULL
);
904 wxASSERT(m_activeState
!= NULL
);
906 ctConfigItem
* newItem
= m_activeState
->DeepClone();
907 ctConfigToolDoc
* doc
= m_activeState
->GetDocument();
909 // This will delete the old clipboard contents, if any.
910 doc
->SetClipboardItem(newItem
);
912 m_parent
= m_activeState
->GetParent();
913 m_insertBefore
= m_activeState
->FindNextSibling();
915 m_activeState
->Detach();
916 m_savedState
= m_activeState
;
917 m_activeState
= NULL
;
919 m_savedState
->GetDocument()->Modify(TRUE
);
920 ctConfigToolView
* view
= (ctConfigToolView
*) m_savedState
->GetDocument()->GetFirstView();
921 view
->OnChangeFilename();
925 wxASSERT(m_savedState
!= NULL
);
926 wxASSERT(m_activeState
== NULL
);
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
;
935 m_insertBefore
= NULL
;
936 view
->OnChangeFilename();
944 wxASSERT(m_savedState
!= NULL
);
945 wxASSERT(m_activeState
== NULL
);
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
;
954 view
->OnChangeFilename();
958 wxASSERT(m_savedState
== NULL
);
959 wxASSERT(m_activeState
!= NULL
);
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();
970 case ctCMD_NEW_ELEMENT
:
974 wxASSERT(m_savedState
!= NULL
);
975 wxASSERT(m_activeState
== NULL
);
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());
983 m_activeState
= m_savedState
;
988 wxASSERT(m_savedState
== NULL
);
989 wxASSERT(m_activeState
!= NULL
);
991 m_activeState
->GetDocument()->Modify(TRUE
);
992 m_activeState
->Detach();
993 m_savedState
= m_activeState
;
994 m_activeState
= NULL
;
998 case ctCMD_APPLY_PROPERTY
:
1000 wxASSERT(m_properties
!= NULL
);
1001 wxASSERT(m_activeState
!= NULL
);
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)
1008 // Just swap the saved and current properties.
1009 ctProperties propsTemp
= m_activeState
->GetProperties() ;
1010 m_activeState
->GetProperties() = (* m_properties
);
1011 (* m_properties
) = propsTemp
;
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();
1018 ctProperty
* prop
= (ctProperty
*) node
->GetData();
1019 ctProperty
* otherProp
= propsTemp
.FindProperty(prop
->GetName());
1020 if (otherProp
&& ((*prop
) != (*otherProp
)))
1022 m_activeState
->ApplyProperty(prop
, otherProp
->GetVariant());
1024 node
= node
->GetNext();
1026 m_activeState
->GetDocument()->Modify(TRUE
);
1027 ctConfigToolView
* view
= (ctConfigToolView
*) m_activeState
->GetDocument()->GetFirstView();
1030 ctConfigToolHint
hint(NULL
, ctValueChanged
);
1031 m_activeState
->GetDocument()->UpdateAllViews (NULL
, & hint
);
1034 m_ignoreThis
= FALSE
;
1042 IMPLEMENT_CLASS(ctConfiguration
, wxObject
)
1044 ctConfiguration::ctConfiguration()
1046 m_treeItemId
= wxTreeItemId();
1051 ctConfiguration::ctConfiguration(ctConfiguration
* parent
, const wxString
& name
)
1053 m_treeItemId
= wxTreeItemId();
1057 parent
->AddChild(this);
1060 ctConfiguration::~ctConfiguration()
1063 ctConfigTreeCtrl* treeCtrl = wxGetApp().GetMainFrame()->GetConfigTreeCtrl();
1064 if (m_treeItemId.IsOk() && treeCtrl)
1066 ctTreeItemData* data = (ctTreeItemData*) treeCtrl->GetItemData(m_treeItemId);
1068 data->SetConfigItem(NULL);
1071 GetParent()->RemoveChild(this);
1074 if (wxGetApp().GetMainFrame()->GetDocument() &&
1075 wxGetApp().GetMainFrame()->GetDocument()->GetTopItem() == this)
1076 wxGetApp().GetMainFrame()->GetDocument()->SetTopItem(NULL);
1083 /// Assignment operator.
1084 void ctConfiguration::operator= (const ctConfiguration
& configuration
)
1086 m_name
= configuration
.m_name
;
1087 m_description
= configuration
.m_description
;
1091 void ctConfiguration::Clear()
1093 wxNode
* node
= m_children
.GetFirst();
1096 wxNode
* next
= node
->GetNext();
1097 ctConfiguration
* child
= (ctConfiguration
*) node
->GetData();
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().
1109 // Get the nth child
1110 ctConfiguration
* ctConfiguration::GetChild(int n
) const
1112 wxASSERT ( n
< GetChildCount() && n
> -1 );
1114 if ( n
< GetChildCount() && n
> -1 )
1116 ctConfiguration
* child
= wxDynamicCast(m_children
.Item(n
)->GetData(), ctConfiguration
);
1123 // Get the child count
1124 int ctConfiguration::GetChildCount() const
1126 return m_children
.GetCount();
1130 void ctConfiguration::AddChild(ctConfiguration
* configuration
)
1132 m_children
.Append(configuration
);
1133 configuration
->SetParent(this);
1136 /// Remove (but don't delete) a child
1137 void ctConfiguration::RemoveChild(ctConfiguration
* configuration
)
1139 m_children
.DeleteObject(configuration
);
1140 configuration
->SetParent(NULL
);
1143 /// Get the associated document (currently, assumes
1144 /// there's only ever one document active)
1145 ctConfigToolDoc
* ctConfiguration::GetDocument()
1147 ctConfigToolDoc
* doc
= wxGetApp().GetMainFrame()->GetDocument();
1151 /// Find an item in this hierarchy
1152 // TODO: ensure that names are unique, somehow.
1153 ctConfiguration
* ctConfiguration::FindConfiguration(const wxString
& name
)
1155 if (GetName() == name
)
1158 for ( wxNode
* node
= GetChildren().GetFirst(); node
; node
= node
->GetNext() )
1160 ctConfiguration
* child
= (ctConfiguration
*) node
->GetData();
1161 ctConfiguration
* found
= child
->FindConfiguration(name
);
1168 /// Find the next sibling
1169 ctConfiguration
* ctConfiguration::FindNextSibling()
1173 wxNode
* node
= GetParent()->GetChildren().Member(this);
1174 if (node
&& node
->GetNext())
1176 return (ctConfiguration
*) node
->GetNext()->GetData();
1181 /// Find the previous sibling
1182 ctConfiguration
* ctConfiguration::FindPreviousSibling()
1186 wxNode
* node
= GetParent()->GetChildren().Member(this);
1187 if (node
&& node
->GetPrevious())
1189 return (ctConfiguration
*) node
->GetPrevious()->GetData();
1194 /// Create a clone of this and children
1195 ctConfiguration
* ctConfiguration::DeepClone()
1197 ctConfiguration
* newItem
= Clone();
1199 for ( wxNode
* node
= GetChildren().GetFirst(); node
; node
= node
->GetNext() )
1201 ctConfiguration
* child
= (ctConfiguration
*) node
->GetData();
1202 ctConfiguration
* newChild
= child
->DeepClone();
1203 newItem
->AddChild(newChild
);
1208 /// Detach: remove from parent, and remove tree items
1209 void ctConfiguration::Detach()
1213 GetParent()->RemoveChild(this);
1215 GetDocument()->SetTopItem(NULL
);
1219 wxTreeItemId treeItem = GetTreeItemId();
1223 // Will delete the branch, but not the config items.
1224 wxGetApp().GetMainFrame()->GetConfigTreeCtrl()->Delete(treeItem);
1228 /// Hide from tree: make sure tree deletions won't delete
1229 /// the config items
1230 void ctConfiguration::DetachFromTree()
1233 wxTreeItemId item = GetTreeItemId();
1236 ctTreeItemData* data = (ctTreeItemData*) wxGetApp().GetMainFrame()->GetConfigTreeCtrl()->GetItemData(item);
1237 data->SetConfigItem(NULL);
1238 m_treeItemId = wxTreeItemId();
1240 for ( wxNode* node = GetChildren().GetFirst(); node; node = node->GetNext() )
1242 ctConfiguration* child = (ctConfiguration*) node->GetData();
1243 child->DetachFromTree();