private Node readArgumentUnit(XmlNodeList xnl, Node.ArgumentNodeType nt)
{
// An argument unit, composed of a proposition (a conclusion)
// followed, optionally, by a single refutation, followed,
// optionally, by premises arranged in either convergent or
// linked structures.
// <!ELEMENT AU (PROP, REFUTATION?, (CA | LA)*)>
XmlNode xn;
Node n = new Node();
n.nodeType = nt;
xn = (XmlNode)xnl[0];
while (xn != null)
{
if (xn.Name.Equals("PROP"))
{
n.EditorText = this.getAnyTag("PROPTEXT", xn.ChildNodes[0]);
}
else if (xn.Name.Equals("REFUTATION"))
{
readRefutation(xn.ChildNodes, n);
}
else if (xn.Name.Equals("CA"))
{
readConvergentArgument(xn.ChildNodes, n);
}
else if (xn.Name.Equals("LA"))
{
readLinkedArgument(xn.ChildNodes, n);
}
xn = xn.NextSibling;
}
return(n);
}
/// <summary>
/// Add a node to the node selected in the tree
/// </summary>
/// <param name="nodeType">Type of node (reason, objection or helper</param>
/// <param name="text">Text for the node</param>
public void addNodeToTree(Node.ArgumentNodeType nodeType, string text)
{
TreeNode tn;
tn = theTV.SelectedNode;
addNodeToTree(tn, nodeType, text);
}
private void addNodeToTree(TreeNode where, Node.ArgumentNodeType nt, string text)
{
TreeNode newtn;
Node n, newNode;
System.Diagnostics.Debug.Assert(nt != Node.ArgumentNodeType.premise, "Cannot add a premise");
if (where == null)
{
return;
}
n = (Node) where.Tag; // get node
if (n.nodeType == Node.ArgumentNodeType.helper & nt == Node.ArgumentNodeType.helper)
{
MessageBox.Show("Sorry, You cannot have a helper for a helper"); // Duplicated
return;
}
newtn = new TreeNode(text);
where.Nodes.Add(newtn);
newNode = new Node();
newNode.EditorText = text;
newNode.nodeType = nt;
n.addKid(newNode, true); // allow the adding of an empty node
newtn.Tag = newNode;
setImageIndex(newtn, newNode);
// newtn.EnsureVisible();
theTV.SelectedNode = newtn;
}
/// <summary>
/// Can the current node be changed to the specified node type?
/// </summary>
/// <param name="newNodeType"></param>
/// <returns></returns>
private bool canChangeNode(Node.ArgumentNodeType newNodeType)
{
bool b;
b = canChangeNodeReason(newNodeType) == null;
return(b);
}
/// <summary>
/// Change current node type
/// </summary>
/// <param name="newNodeType"></param>
/// <returns></returns>
public bool changeNodeto(Node.ArgumentNodeType newNodeType)
{
if (!this.canChangeNode(newNodeType))
{
return(false);
}
Node n = getSelectedNode(this.theTV);
n.nodeType = newNodeType;
setImageIndex(theTV.SelectedNode, n);
modifiedCount++;
return(true);
}
/// <summary>
///
/// </summary>
/// <param name="newNodeType"></param>
/// <returns>null if node can be changed</returns>
public string canChangeNodeReason(Node.ArgumentNodeType newNodeType)
{
int f;
Node kn;
string returnReason;
returnReason = I18N.getString("ChangeNode-Null", "Node not changed");
Node n = getSelectedNode(this.theTV);
if (n == null)
{
return(returnReason);
}
if (n.nodeType == newNodeType)
{
return(returnReason); // Not changed
}
if (n.nodeType == Node.ArgumentNodeType.premise) // Premise not changed so easily
{
returnReason = I18N.getString("ChangeNode-MainPremise", "Cannot change Main Premise");
return(returnReason);
}
if (newNodeType != Node.ArgumentNodeType.helper) // only keep checking if changing to a helper
{
returnReason = "";
return(null);
}
kn = (Node)this.theTV.SelectedNode.Parent.Tag; // get parent node
if (kn.nodeType == Node.ArgumentNodeType.helper) // is it a helper?
{
return(I18N.getString("ChangeNode-HelperHelper", "Cannot have a Helper for a Helper"));
}
if (n.countKids() == 0) // only keep checking
{
return(null);
}
// if any kids are helpers
for (f = 0; f < n.countKids(); f++)
{
kn = (Node)n.kids[f];
if (kn.nodeType == Node.ArgumentNodeType.helper)
{
return(I18N.getString("ChangeNode-HelperHelper", "Cannot have a Helper for a Helper"));
}
;
}
return(null);
}
// manipulation routines
/// <summary>
/// Adds a Node (element) to the argument
/// </summary>
/// <param name="argType">Node type</param>
/// <param name="text">Element text</param>
/// <param name="parent"></param>
/// <returns></returns>
public Node addNode(Node.ArgumentNodeType argType, string text, Node parent)
{
Node n = new Node();
n.EditorText = text;
n.nodeType = argType;
n.fromNode = parent;
if (parent == null)
{
System.Diagnostics.Debug.Assert(argType == Node.ArgumentNodeType.premise |
argType == Node.ArgumentNodeType.unknown,
"Incorrect node type given as " + argType.ToString());
head = n;
return(n);
}
parent.addKid(n);
return(n);
}
/// <summary>
/// Writes the argument to a TextWriter file.
/// </summary>
/// <param name="file">TextWriter file</param>
/// <param name="n">Top Argument Node</param>
/// <param name="addTags">Add tags used in XSL Transforms</param>
/// <param name="makePremise"></param>
private void writeArgumentXML(System.IO.TextWriter file, Node n, bool makePremise, bool addTags)
{
bool saveSubArgument = false;
Node.ArgumentNodeType temp = Node.ArgumentNodeType.unknown;
Options.OptionsData d = Options.OptionsData.Instance;
if (n == null)
{
n = findHead();
}
if (addTags)
{
referenceTree(); // Reference tree for <ref> tag
}
if (makePremise & (n.nodeType != Node.ArgumentNodeType.premise))
{
saveSubArgument = true;
temp = n.nodeType;
n.nodeType = Node.ArgumentNodeType.premise;
}
file.WriteLine("<argument>");
if (!(author.Equals("") & d.Author.Equals(""))) // Add author if defined
{
file.Write("<author>");
if (author.Equals("")) // does the argument not have an author
{
file.Write(d.Author);
}
else
{
file.Write(author);
}
file.WriteLine("</author>");
}
if (creationDateDefined)
{
file.Write("<created>");
file.Write(DateTimetoString(creationDate));
file.WriteLine("</created>");
}
file.Write("<modified>");
file.Write(DateTimetoString(this.modifiedDate));
file.WriteLine("</modified>");
if (addTags) // add tags used for XSLT
{
// Title
file.Write("<title>");
file.Write(Title);
file.WriteLine("</title>");
// Todays date - difficult to format with XSLT
file.Write("<day>");
file.Write(DateTime.Today.DayOfWeek.ToString());
file.Write("</day>");
file.Write("<dayNum>");
file.Write(DateTime.Today.Day.ToString());
file.Write("</dayNum>");
file.Write("<month>");
file.Write(DateTime.Today.Month.ToString());
file.Write("</month>");
file.Write("<year>");
file.Write(DateTime.Today.Year.ToString());
file.Write("</year>");
file.Write("<shortDate>");
file.Write(DateTime.Today.ToShortDateString());
file.Write("</shortDate>");
file.Write("<shortTime>");
file.Write(DateTime.Now.ToShortTimeString());
file.Write("</shortTime>");
file.Write("<longDate>");
file.Write(DateTime.Today.ToLongDateString());
file.Write("</longDate>");
file.Write("<longTime>");
file.Write(DateTime.Now.ToLongTimeString());
file.Write("</longTime>");
}
writeNode(file, n, addTags);
file.WriteLine("</argument>");
file.Close();
if (saveSubArgument)
{
n.nodeType = temp;
}
}
