private void expandDelegate(object startObj)
{
ViewerNode node = (ViewerNode)startObj;
var all = node.AsDepthFirstEnumerable(x => x.ChildNodes); //this enumerable will only enumerate when accessed
foreach (var viewerNode in all)
{
//call ChildNodes to expand them
var ignore = viewerNode.ChildNodes;
if (_thread != Thread.CurrentThread)
{
break;
}
}
// SystemSounds.Beep.Play();
// foreach (var viewerNode in all)
// {
// var ignore = viewerNode.LineInfo;
//call LineInfo to calculate them
// if (_thread != Thread.CurrentThread)
// {
// break;
// }
// }
// SystemSounds.Beep.Play();
}
/// <summary>
/// Generates a test case
/// </summary>
/// <param name="inputFile">Path to input file to generate test case from</param>
/// <param name="doc">XmlDocument containing data to generate test case from</param>
/// <param name="schemaPath">Path to schema file</param>
/// <returns>A StreamReader containing the test case</returns>
public StreamReader GenerateTestCase(string inputFile, XmlDocument doc, string schemaPath)
{
ViewerNode rootNode = new ViewerNode(doc.DocumentElement);
// Call the method overload
return(GenerateTestCase(inputFile, rootNode, schemaPath));
}
protected override void Execute(EditorFrame ef, TreeViewItem parameter, ViewerNode selectedNode, XmlDocument xmldoc, XmlNode node, XmlNode parentNode)
{
var comment = xmldoc.CreateComment(node.OuterXml);
parentNode.ReplaceChild(comment, node);
ef.XmlEditor.Text = xmldoc.ToUTF8String();
}
protected override void Execute(EditorFrame ef)
{
TreeViewItem selected = ((TreeViewItem)ef._editorTree.tree.SelectedItem);
ViewerNode node = (ViewerNode)selected.Tag;
ef.SetSchemaInfo(node.SchemaInfo);
}
private void treeResult_SelectedItemChanged(object sender, RoutedPropertyChangedEventArgs <object> e)
{
if (_treeResult.SelectedItem as TreeViewItem == null)
{
return;
}
TreeViewItem selected = ((TreeViewItem)_treeResult.SelectedItem);
//expand on click
selected.IsExpanded = true;
if (selected.Tag != null)
{
if (selected.Tag is ViewerNode)
{
ViewerNode vn = (ViewerNode)selected.Tag;
setCursor(vn.LineInfo, vn.Name);
}
else if (selected.Tag is XPathNavigator)
{
XPathNavigator xpn = (XPathNavigator)selected.Tag;
IXmlLineInfo li = xpn as IXmlLineInfo;
if (li != null)
{
setCursor(li, xpn.Name);
}
}
else
{
Debug.Fail("");
}
}
}
protected override bool CanExecute(EditorFrame ef)
{
if (ef.XmlEditor == null)
{
return(false);
}
TreeViewItem selected = ((TreeViewItem)ef._editorTree.tree.SelectedItem);
if (selected == null)
{
return(false);
}
if (selected.Tag == null)
{
return(false);
}
ViewerNode selectedNode = (ViewerNode)selected.Tag;
XmlNode node = selectedNode.OriginalNode;
if (node == null)
{
return(false);
}
if (node.OwnerDocument == null)
{
return(false);
}
return(true);
}
public void SetNodeToExpand(ViewerNode node)
{
_thread = new Thread(expandDelegate)
{
IsBackground = true
};
_thread.Start(node);
}
void tree_SelectionChanged(ViewerNode obj)
{
if (obj == null)
{
return;
}
highlightFragment(obj);
}
protected override void Execute(EditorFrame ef, TreeViewItem parameter, ViewerNode selectedNode, XmlDocument xmldoc, XmlNode node, XmlNode parentNode)
{
string newName = InputBox.Show(Application.Current.MainWindow, "Rename", "New name of the node", node.Name);
if (newName != null)
{
RenameNode(xmldoc, node, node.NamespaceURI, newName);
ef.XmlEditor.Text = xmldoc.ToUTF8String();
}
}
public TreeViewItem SelectNodeBasedOnCursor(TextLocation loc)
{
ItemCollection items = _tree.Items;
Debug.Assert(items.Count <= 1);
if (items.Count != 1)
{
return(null);
}
LazyTreeViewItem root = (LazyTreeViewItem)_tree.Items[0];
IEnumerable <LazyTreeViewItem> allChilds = root.AsDepthFirstEnumerable(
x => {
x.Expand();
return(x.Items.Cast <LazyTreeViewItem>());
}
);
TreeViewItem match = null;
foreach (LazyTreeViewItem child in allChilds)
{
if (child.Tag != null)
{
ViewerNode node = (ViewerNode)child.Tag;
IXmlLineInfo lineInfo = node.LineInfo;
if (lineInfo != null)
{
if (lineInfo.LineNumber == loc.Line && lineInfo.LinePosition <= loc.Column)
{
//last one counts
match = child;
}
if (lineInfo.LineNumber > loc.Line || (lineInfo.LineNumber == loc.Line && lineInfo.LinePosition > loc.Column))
{
break;
}
}
}
}
if (match != null)
{
_tree.SelectedItemChanged -= tree_SelectedItemChanged;
match.IsSelected = true;
match.BringIntoView();
_tree.SelectedItemChanged += tree_SelectedItemChanged;
}
return(match);
}
protected override void Execute(EditorFrame ef)
{
TreeViewItem selected = ((TreeViewItem)ef._editorTree.tree.SelectedItem);
if (selected == null)
{
return;
}
if (selected.Tag != null)
{
ViewerNode selectedNode = (ViewerNode)selected.Tag;
Clipboard.SetText(selectedNode.XPath);
}
}
private void highlightFragment(ViewerNode selectedNode)
{
if (SelectionChanged == null)
{
return;
}
//show fragment in fragment view
if (selectedNode == null)
{
SelectionChanged(null);
}
else
{
SelectionChanged(selectedNode);
}
}
private void tree_SelectedItemChanged(object sender, RoutedPropertyChangedEventArgs <object> e)
{
if (_tree.SelectedItem == null)
{
return;
}
TreeViewItem selected = ((TreeViewItem)_tree.SelectedItem);
//expand on click
selected.IsExpanded = true;
if (selected.Tag != null)
{
ViewerNode selectedNode = (ViewerNode)((TreeViewItem)_tree.SelectedItem).Tag;
highlightFragment(selectedNode);
}
}
private void highlightFragment(ViewerNode selectedNode)
{
if (_editor == null)
{
return;
}
//show fragment in fragment view
if (selectedNode == null)
{
_editor.SetFragmentText("");
}
else
{
StringBuilder sb = new StringBuilder();
XmlWriterSettings settings = new XmlWriterSettings
{
ConformanceLevel = ConformanceLevel.Auto,
Indent = true
};
using (XmlWriter w = XmlWriter.Create(sb, settings))
{
selectedNode.OriginalNode.WriteTo(w);
}
_editor.SetFragmentText(sb.ToString());
}
//select node in editor
if (selectedNode != null)
{
IXmlLineInfo lineInfo = selectedNode.LineInfo;
if (lineInfo != null)
{
var offset = _editor.XmlEditor.Document.GetOffset(lineInfo.LineNumber, lineInfo.LinePosition);
_editor.XmlEditor.Select(offset, selectedNode.Name.Length);
Debug.Assert(_editor.XmlEditor.SelectedText == selectedNode.Name);
_editor.XmlEditor.ScrollTo(lineInfo.LineNumber, lineInfo.LinePosition);
}
}
}
private void selectNodeBasedOnCursor()
{
_updateSelectedBasedOnCursorNeccessary = false;
try
{
Cursor = Cursors.Wait;
var loc = _editor.XmlEditor.TextArea.Caret.Location;
TreeViewItem selectedItem = tree.SelectNodeBasedOnCursor(loc);
if (selectedItem != null)
{
ViewerNode node = (ViewerNode)selectedItem.Tag;
_editor.SetSchemaInfo(node.SchemaInfo);
}
}
finally
{
Cursor = null;
}
}
public void Update(XSDocument xsdoc)
{
_lastXmlUsedInUpdate = new XSDocument(xsdoc.Xml, xsdoc.XsdFile);
_tree.Items.Clear();
Cursor = Cursors.Wait;
_lblUpdateInProgress.Visibility = Visibility.Visible;
_tree.Visibility = Visibility.Collapsed;
try
{
_rootNode = new ViewerNode(xsdoc);
_backgroundExpander.SetNodeToExpand(_rootNode);
if (_filter != null)
{
_tree.Background = Brushes.LightYellow;
_tree.Items.Add(TreeViewHelper.BuildTreeView(_rootNode,
x =>
!((ViewerNode)x.Tag).OriginalNode.OuterXml.Contains(_filter, StringComparison.CurrentCultureIgnoreCase)));
}
else
{
_tree.Background = Brushes.White;
_tree.Items.Add(TreeViewHelper.BuildTreeView(_rootNode));
}
((TreeViewItem)_tree.Items[0]).IsExpanded = true;
}
catch (Exception)
{
_tree.Items.Clear();
}
finally
{
_lblUpdateInProgress.Visibility = Visibility.Collapsed;
_tree.Visibility = Visibility.Visible;
Cursor = null;
}
}
protected override void Execute(EditorFrame ef)
{
try
{
TreeViewItem selected = ((TreeViewItem)ef._editorTree.tree.SelectedItem);
if (selected.Tag != null)
{
ViewerNode selectedNode = (ViewerNode)selected.Tag;
XmlDocument xmldoc = selectedNode.OriginalNode.OwnerDocument;
XmlNode node = selectedNode.OriginalNode;
Debug.Assert(xmldoc != null, "Checked in CanExecute");
Execute(ef, xmldoc, node);
}
}
catch (Exception e)
{
MessageBox.Show(Application.Current.MainWindow, "Error: " + e.Message, "Error", MessageBoxButton.OK,
MessageBoxImage.Error);
}
}
protected override bool CanExecute(EditorFrame ef)
{
if (ef.XmlEditor == null)
{
return(false);
}
TreeViewItem selected = ((TreeViewItem)ef._editorTree.tree.SelectedItem);
if (selected == null)
{
return(false);
}
if (selected.Tag == null)
{
return(false);
}
ViewerNode selectedNode = (ViewerNode)selected.Tag;
XmlNode node = selectedNode.OriginalNode;
if (node == null)
{
return(false);
}
if (node.OwnerDocument == null)
{
return(false);
}
if (node.ParentNode == null)
{
//info: there are no correct Linepositions for attributes
return(false);
}
return(true);
}
protected override void Execute(EditorFrame ef)
{
TreeViewItem selected = ((TreeViewItem)ef._editorTree.tree.SelectedItem);
ViewerNode node = (ViewerNode)selected.Tag;
IXmlLineInfo lineInfo = node.LineInfo;
if (lineInfo != null)
{
int lineNum = lineInfo.LineNumber;
int linePos = lineInfo.LinePosition;
string outerXml = node.OriginalNode.OuterXml;
int offset = ef.XmlEditor.Document.GetOffset(lineNum, linePos);
offset -= 1;
outerXml = outerXml.Replace("\n", "\r\n");
int length = Math.Min(outerXml.Length, ef.XmlEditor.Text.Length);
ef.XmlEditor.Select(offset, length);
ef.XmlEditor.Focus();
}
}
protected abstract void Execute(EditorFrame ef, TreeViewItem treeViewItem, ViewerNode selectedNode, XmlDocument xmldoc, XmlNode node, XmlNode parentNode);
/// <summary>
/// Generates a test case
/// </summary>
/// <param name="inputFile">Path to input file to generate test case from</param>
/// <param name="rootNode">RootNode to generate test case data from</param>
/// <param name="schemaPath">Path to schema file</param>
/// <returns>A StreamReader containing the test case</returns>
public StreamReader GenerateTestCase(string fileName, ViewerNode rootNode, string schemaPath)
{
try
{
_xpathIndex = 0;
FileInfo currentFile = new FileInfo(fileName);
MemoryStream stream = new MemoryStream();
XmlTextWriter xWriter = new XmlTextWriter(stream, Encoding.UTF8);
xWriter.Formatting = Formatting.Indented;
string testName = currentFile.Name.Replace(" ", "_");
if (testName.ToLower().EndsWith(".xml"))
{
testName = testName.Substring(0, testName.Length - 4);
}
testName += "_Test";
// Write the XML Header
xWriter.WriteStartDocument();
// Write version/date and url comment
xWriter.WriteComment(string.Format("Generated with DanSharp XmlViewer v{0}.{1}.{2} on {3} {4}", Assembly.GetEntryAssembly().GetName().Version.Major, Assembly.GetEntryAssembly().GetName().Version.Minor, Assembly.GetEntryAssembly().GetName().Version.Build, DateTime.Now.ToShortDateString(), DateTime.Now.ToShortTimeString()));
xWriter.WriteComment("http://dansharpxmlviewer.codeplex.com");
// Write original filename comment
xWriter.WriteComment(string.Format("Original Xml file: {0}", fileName));
// Open the TestCase element
xWriter.WriteStartElement("TestCase");
// Write attributes for TestCase
xWriter.WriteAttributeString("testName", testName);
// Write an empty TestSetup element
xWriter.WriteStartElement("TestSetup");
xWriter.WriteEndElement();
// Open the TestExecution element
xWriter.WriteStartElement("TestExecution");
xWriter.WriteComment("Start: Test " + testName);
// Open the TestStep element for file copying
xWriter.WriteStartElement("TestStep");
// Write attributes for TestStep
xWriter.WriteAttributeString("assemblyPath", "");
xWriter.WriteAttributeString("typeName", "Microsoft.Services.BizTalkApplicationFramework.BizUnit.FileCreateStep");
// Open the SourcePath element
xWriter.WriteStartElement("SourcePath");
// Write the current file path as the source file
xWriter.WriteValue(fileName);
// Close the SourcePath element
xWriter.WriteEndElement();
// Open the CreationPath element
xWriter.WriteStartElement("CreationPath");
// Write the current file path (with "Copy_" at the front of th file name) as the creation file
xWriter.WriteValue(currentFile.DirectoryName + "\\Copy_" + currentFile.Name);
// Close the CreationPath element
xWriter.WriteEndElement();
// Close the TestStep element for file copying
xWriter.WriteEndElement();
// Open the TestStep element for validation
xWriter.WriteStartElement("TestStep");
// Write attributes for TestStep
xWriter.WriteAttributeString("assemblyPath", "");
xWriter.WriteAttributeString("typeName", "Microsoft.Services.BizTalkApplicationFramework.BizUnit.FileValidateStep");
// Open the Timeout element
xWriter.WriteStartElement("Timeout");
// Write 10000 as the value
xWriter.WriteValue("10000");
// Close the Timeout element
xWriter.WriteEndElement();
// Open the Directory element
xWriter.WriteStartElement("Directory");
// Write the current file path
xWriter.WriteValue(currentFile.DirectoryName);
// Close the Directory element
xWriter.WriteEndElement();
// Open the SearchPattern element
xWriter.WriteStartElement("SearchPattern");
// Write "Copy_*.xml" as the value
xWriter.WriteValue("Out_Copy_" + currentFile.Name);
// Close the SearchPattern element
xWriter.WriteEndElement();
// Open the DeleteFile element
xWriter.WriteStartElement("DeleteFile");
// Write true as the value
xWriter.WriteValue("true");
// Close the DeleteFile element
xWriter.WriteEndElement();
// Open the ValidationStep element
xWriter.WriteStartElement("ValidationStep");
// Write attributes for ValidationStep
xWriter.WriteAttributeString("assemblyPath", "");
xWriter.WriteAttributeString("typeName", "Microsoft.Services.BizTalkApplicationFramework.BizUnit.XmlValidationStepEx");
// Open the XmlSchemaPath element
xWriter.WriteStartElement("XmlSchemaPath");
// Write a schema name as the value
if (string.IsNullOrEmpty(schemaPath))
{
schemaPath = fileName.Replace(".xml", ".xsd");
}
xWriter.WriteValue(schemaPath);
// Close the XmlSchemaPath element
xWriter.WriteEndElement();
// Open the XmlSchemaNameSpace element
xWriter.WriteStartElement("XmlSchemaNameSpace");
// Write the namespace of the root node
xWriter.WriteValue(rootNode.Namespace);
// Close the XmlSchemaNameSpace element
xWriter.WriteEndElement();
// Open the XPathList element
xWriter.WriteStartElement("XPathList");
// Write a list of XPaths generated from the current ViewerNode
WriteXPathListItems(xWriter, rootNode);
// Close the XPathList element
xWriter.WriteEndElement();
// Close the ValidationStep element
xWriter.WriteEndElement();
// Close the TestStep element for validation
xWriter.WriteEndElement();
xWriter.WriteComment("End: Test " + testName);
// Close the TestExecution element
xWriter.WriteEndElement();
// Write an empty TestCleanup element
xWriter.WriteComment("Test cleanup: test cases should always leave the system in the state they found it");
xWriter.WriteStartElement("TestCleanup");
xWriter.WriteEndElement();
// Close the TestCase element
xWriter.WriteEndElement();
// Close the document
xWriter.WriteEndDocument();
// Flush what's written to the stream
xWriter.Flush();
// Reset the stream for reading
stream.Position = 0;
// Convert the stream to a string and store in the text box
return(new StreamReader(stream, Encoding.UTF8));
}
catch (Exception ex)
{
throw new ApplicationException("An error occurred creating the Test Case: " + ex.Message, ex);
}
}
/// <summary>
/// Writes tests for all nodes under the given root node
/// </summary>
/// <param name="xWriter">XmlWriter to write tests to</param>
/// <param name="rootNode">RootNode to start writing from</param>
private void WriteXPathListItems(XmlTextWriter xWriter, ViewerNode rootNode)
{
// Find all elements and attributes in the document which have a value, and write them
_xpathIndex = 0;
WriteXPathListItemsRec(xWriter, rootNode);
}
/// <summary>
/// Writes out a test for the current node
/// </summary>
/// <param name="xWriter">XmlWriter to write test to</param>
/// <param name="node">Node to write test for</param>
private void WriteXPathListItemsRec(XmlTextWriter xWriter, ViewerNode node)
{
// Check if this node has a value
if (!string.IsNullOrEmpty(node.Value))
{
// Check the type of node
if (node.NodeType == NodeType.Element)
{
// Add comment
xWriter.WriteComment(string.Format(CultureInfo.CurrentUICulture, " {0}: Element {1} must equal '{2}'", ++_xpathIndex, node.LocalName, node.Value));
// Open the XPathList element
xWriter.WriteStartElement("XPathValidation");
// Write attributes for XPathValidation
xWriter.WriteAttributeString("query", node.XPath);
// Write node value
xWriter.WriteValue(node.Value);
// Close the XPathList element
xWriter.WriteEndElement();
}
else if ((node.NodeType == NodeType.Attribute) && (node.AttributeType == AttributeType.None))
{
// Add comment
xWriter.WriteComment(string.Format(CultureInfo.CurrentUICulture, " {0}: Attribute {1} must equal '{2}'", ++_xpathIndex, node.LocalName, node.Value));
// Open the XPathList element
xWriter.WriteStartElement("XPathValidation");
// Write attributes for XPathValidation
xWriter.WriteAttributeString("query", node.XPath);
// Write node value
xWriter.WriteValue(node.Value);
// Close the XPathList element
xWriter.WriteEndElement();
}
}
// Process attributes for this node
for (int attrIndex = 0; attrIndex < node.Attributes.Count; attrIndex++)
{
WriteXPathListItemsRec(xWriter, node.Attributes[attrIndex]);
}
List <string> processedChildNodes = new List <string>();
List <XPathQuery> nodeCountXPathQuery = new List <XPathQuery>();
// Process child elements for this node
for (int childIndex = 0; childIndex < node.ChildNodes.Count; childIndex++)
{
WriteXPathListItemsRec(xWriter, node.ChildNodes[childIndex]);
// Check if we've processed this node as a repeatign node
if (!processedChildNodes.Contains(node.ChildNodes[childIndex].Name))
{
// Check if this node is a repeating node
if (node.ChildNodes[childIndex].OccurrenceIndex > -1)
{
// Get the count of the number of times this node repeats
int nodeCount = node.GetCountOfRepeatingChildNodes(node.ChildNodes[childIndex]);
if (nodeCount > 0)
{
// Create an xpath statement to verify the count of these nodes
string nodeCountXPath = string.Format(CultureInfo.CurrentUICulture, "count({0}{1})", node.XPath, node.ChildNodes[childIndex].NonRecurringNodePath, nodeCount);
XPathQuery query = new XPathQuery(node.ChildNodes[childIndex].LocalName, nodeCountXPath, nodeCount.ToString());
// Add the xpath query to a list
nodeCountXPathQuery.Add(query);
}
}
// Add the node to the list of processed nodes
processedChildNodes.Add(node.ChildNodes[childIndex].Name);
}
}
// Process any Node Count statements
if (nodeCountXPathQuery.Count > 0)
{
for (int queryIndex = 0; queryIndex < nodeCountXPathQuery.Count; queryIndex++)
{
// Add comment
xWriter.WriteComment(string.Format(CultureInfo.CurrentUICulture, " {0}: Count of Element {1} must equal '{2}'", ++_xpathIndex, nodeCountXPathQuery[queryIndex].Name, nodeCountXPathQuery[queryIndex].Value));
// Open the XPathList element
xWriter.WriteStartElement("XPathValidation");
// Write attributes for XPathValidation
xWriter.WriteAttributeString("query", nodeCountXPathQuery[queryIndex].Query);
// Write node value
xWriter.WriteValue(nodeCountXPathQuery[queryIndex].Value);
// Close the XPathList element
xWriter.WriteEndElement();
}
}
}
private void displayNavigator(XPathNodeIterator xpi)
{
if ((xpi != null) && (xpi.Count > 0))
{
for (bool hasNext = xpi.MoveNext(); hasNext; hasNext = xpi.MoveNext())
{
// IXmlLineInfo lineInfo = xpi.Current as IXmlLineInfo;
switch (xpi.Current.NodeType)
{
case XPathNodeType.Text:
{
TreeViewItem node = new TreeViewItem();
node.Header = xpi.Current.Value;
node.Foreground = Brushes.Brown;
node.ToolTip = "(Nodeset/Text)";
_treeResult.Items.Add(node);
break;
}
case XPathNodeType.Attribute:
{
TreeViewItem node = new TreeViewItem();
node.Header = "@" + xpi.Current.Name + ": " + xpi.Current.Value;
node.Foreground = Brushes.Brown;
node.ToolTip = "(Nodeset/Attribute)";
node.Tag = xpi.Current.Clone();
_treeResult.Items.Add(node);
break;
}
case XPathNodeType.Element:
{
var document = new XSDocument(xpi.Current.OuterXml);
ViewerNode vNode = new ViewerNode(document);
TreeViewItem tvi = TreeViewHelper.BuildTreeView(vNode);
//expand all to lazy-load all subitems
tvi.ExpandSubtree();
//now we can change the tags of all subitems
setTag(tvi, xpi.Current.Clone());
//collapse them again
var allChilds = tvi.AsDepthFirstEnumerable(
x => x.Items.Cast <TreeViewItem>());
foreach (TreeViewItem treeViewItem in allChilds)
{
treeViewItem.IsExpanded = false;
}
_treeResult.Items.Add(tvi);
break;
}
}
if (string.IsNullOrEmpty(_editorUserControl1.Text))
{
_editorUserControl1.Text = xpi.Current.OuterXml;
}
else
{
_editorUserControl1.Text = _editorUserControl1.Text + "\r\n" + xpi.Current.OuterXml;
}
}
}
else
{
_treeResult.Items.Add("Nothing found.");
_editorUserControl1.Text = "";
}
}
protected override void Execute(EditorFrame ef, TreeViewItem parameter, ViewerNode selectedNode, XmlDocument xmldoc, XmlNode node, XmlNode parentNode)
{
ef.XmlEditor.Text = NodeMover.MoveUp(node);
ef._editorTree.Update();
ef._editorTree.tree.ExpandAll();
}
private void moveItem(TreeViewItem sourceItem, TreeViewItem targetItem)
{
ViewerNode source = (ViewerNode)sourceItem.Tag;
ViewerNode target = (ViewerNode)targetItem.Tag;
if (source == target)
{
return;
}
TaskDialogResult res = TaskDialog.Show(
new TaskDialogOptions
{
AllowDialogCancellation = true,
Owner = Application.Current.MainWindow,
Title = "Move node",
MainInstruction = "Where do you like to drop to source node?",
Content = "Source: " + source + "\nTarget: " + target,
CommandButtons = new[] { "Make child", "Insert before", "Insert after", "Cancel" },
MainIcon = VistaTaskDialogIcon.Information,
ExpandedInfo = "Source: " + source.XPath + "\nTarget: " + target.XPath
});
try
{
string newXml = null;
switch (res.CommandButtonResult)
{
case 0: //make child
newXml = NodeMover.Move(source.OriginalNode, target.OriginalNode);
break;
case 1: //insert before
newXml = NodeMover.InsertBefore(source.OriginalNode, target.OriginalNode);
break;
case 2: //insert after
newXml = NodeMover.InsertAfter(source.OriginalNode, target.OriginalNode);
break;
case 3: //cancel
break;
case null: //cancel by closing window
break;
default:
Debug.Fail("");
break;
}
if (newXml != null)
{
Update(new XSDocument(newXml));
if (XmlChanged != null)
{
XmlChanged(newXml);
}
}
}
catch (Exception e)
{
MessageBox.Show(Application.Current.MainWindow, e.Message, "Error",
MessageBoxButton.OK, MessageBoxImage.Error);
}
}
