private static void GetMatchingNodes(INode node, string[] nodePath, int cur, IList <INode> res)
{
if (cur < 0 || cur >= nodePath.Length)
{
return;
}
bool last = (cur == nodePath.Length - 1);
string name = nodePath[cur];
if (node.HasChildNodes())
{
INodeList children = node.GetChildNodes();
for (int i = 0; i < children.GetLength(); i++)
{
INode c = children.Item(i);
if (name.Equals(c.GetNodeName()))
{
if (last)
{
res.Add(c);
}
else
{
GetMatchingNodes(c, nodePath, cur + 1, res);
}
}
}
}
}
/// <summary>
/// Returns the first element within the document (using depth-first pre-order traversal
/// of the document's nodes) that matches the specified group of selectors.
/// </summary>
/// <param name="elements">The elements to take as source.</param>
/// <param name="selector">A selector object.</param>
/// <returns>An element object.</returns>
public static IElement QuerySelector(this INodeList elements, ISelector selector)
{
for (int i = 0; i < elements.Length; i++)
{
var element = elements[i] as IElement;
if (element != null)
{
if (selector.Match(element))
{
return(element);
}
if (!element.HasChildNodes)
{
continue;
}
element = QuerySelector(element.ChildNodes, selector);
if (element != null)
{
return(element);
}
}
}
return(null);
}
/// <summary>Collects all option elements that are child nodes (including inside optgroups).</summary>
public static void CollectOptions(Node parent, INodeList hoc)
{
if (parent.childNodes_ == null)
{
return;
}
// For each child node..
for (int i = 0; i < parent.childNodes_.length; i++)
{
// Get it:
Node child = parent.childNodes_[i];
// Option?
if (child is HtmlOptionElement)
{
hoc.push(child);
continue;
}
if (child.childNodes_ != null)
{
// Go recursive:
CollectOptions(child, hoc);
}
}
}
/// <summary>
/// Returns a NodeList of elements with the given tag name. The complete document is searched, including the root node.
/// </summary>
/// <param name="elements">The elements to take as source.</param>
/// <param name="tagName">A string representing the name of the elements. The special string "*" represents all elements.</param>
/// <returns>A NodeList of found elements in the order they appear in the tree.</returns>
public static HtmlElementCollection GetElementsByTagName(this INodeList elements, String tagName)
{
var result = new List <IElement>();
elements.GetElementsByTagName(tagName != "*" ? tagName : null, result);
return(new HtmlElementCollection(result));
}
/// <summary>
/// 过滤标签集合
/// </summary>
/// <param name="nodes"></param>
protected virtual void FiltersTags(INodeList nodes)
{
if (nodes == null)
{
return;
}
for (int i = 0; i < nodes.Length; i++)
{
var node = nodes[i];
if (node is IElement element)
{
FiltesTag(element);
}
else
{
if (node.NodeType == NodeType.Comment)
{
node.RemoveFromParent();
}
}
if (node.Parent == null)
{
i--;
}
}
}
/// <summary>
/// Returns a NodeList of elements with the given tag name. The complete document is searched, including the root node.
/// </summary>
/// <param name="elements">The elements to take as source.</param>
/// <param name="tagName">A string representing the name of the elements. The special string "*" represents all elements.</param>
/// <returns>A NodeList of found elements in the order they appear in the tree.</returns>
public static HtmlElementCollection GetElementsByTagName(this INodeList elements, String tagName)
{
var result = new List <IElement>();
elements.GetElementsByTagName(tagName.Is(Keywords.Asterisk) ? null : tagName, result);
return(new HtmlElementCollection(result));
}
public TypeDeclaration(string name, TypeSyntax baseType, INodeList <TypeSyntax> implements, INodeList <MemberDeclaration> members) : base(DeclarationType.Class)
{
Name = name;
BaseType = baseType;
Implements = implements;
Members = members;
}
/// <summary>
/// Returns a list of elements with the given tag name belonging to the given namespace.
/// The complete document is searched, including the root node.
/// </summary>
/// <param name="elements">The elements to take as source.</param>
/// <param name="namespaceUri">The namespace URI of elements to look for.</param>
/// <param name="localName">Either the local name of elements to look for or the special value "*", which matches all elements.</param>
/// <returns>A NodeList of found elements in the order they appear in the tree.</returns>
public static HtmlCollection <IElement> GetElementsByTagName(this INodeList elements, String namespaceUri, String localName)
{
var result = new List <IElement>();
elements.GetElementsByTagName(namespaceUri, localName.Is(Keywords.Asterisk) ? null : localName, result);
return(new HtmlCollection <IElement>(result));
}
/// <summary>Gets all inputs from the given element, adding the results to the given list.</summary>
/// <param name="results">The list that all results are added to.</param>
/// <param name="element">The element to check.</param>
public static void GetAllInputs(INodeList results, HtmlElement element, InputSearchMode mode)
{
NodeList kids = element.childNodes_;
if (kids == null)
{
return;
}
for (int i = 0; i < kids.length; i++)
{
HtmlElement child = kids[i] as HtmlElement;
if (child == null || child.Tag == "form")
{
// Don't go into child forms.
continue;
}
if (
(mode == InputSearchMode.Submittable && child.IsFormSubmittable) ||
(mode == InputSearchMode.Listed && child.IsFormListed) ||
(mode == InputSearchMode.Resettable && child.IsFormResettable)
)
{
results.push(child);
}
else
{
GetAllInputs(results, child, mode);
}
}
}
/// <summary>
/// Given a path to a file containing a list of SsurgeonPatterns, returns
/// TODO: deal with resources
/// </summary>
/// <exception cref="System.Exception"/>
public virtual IList <SsurgeonPattern> ReadFromFile(File file)
{
IList <SsurgeonPattern> retList = new List <SsurgeonPattern>();
IDocument doc = DocumentBuilderFactory.NewInstance().NewDocumentBuilder().Parse(file);
INodeList patternNodes = doc.GetElementsByTagName(SsurgeonPattern.SsurgeonElemTag);
for (int i = 0; i < patternNodes.GetLength(); i++)
{
INode node = patternNodes.Item(i);
if (node.GetNodeType() == NodeConstants.ElementNode)
{
IElement elt = (IElement)node;
SsurgeonPattern pattern = SsurgeonPatternFromXML(elt);
retList.Add(pattern);
}
}
INodeList resourceNodes = doc.GetElementsByTagName(SsurgeonPattern.ResourceTag);
for (int i_1 = 0; i_1 < resourceNodes.GetLength(); i_1++)
{
INode node = patternNodes.Item(i_1);
if (node.GetNodeType() == NodeConstants.ElementNode)
{
IElement resourceElt = (IElement)node;
SsurgeonWordlist wlRsrc = new SsurgeonWordlist(resourceElt);
AddResource(wlRsrc);
}
}
return(retList);
}
/// <summary>
/// Given the root Element for a SemgrexPattern (SSURGEON_ELEM_TAG), converts
/// it into its corresponding SemgrexPattern object.
/// </summary>
/// <exception cref="System.Exception"/>
public static SsurgeonPattern SsurgeonPatternFromXML(IElement elt)
{
string uid = GetTagText(elt, SsurgeonPattern.UidElemTag);
string notes = GetTagText(elt, SsurgeonPattern.NotesElemTag);
string semgrexString = GetTagText(elt, SsurgeonPattern.SemgrexElemTag);
SemgrexPattern semgrexPattern = SemgrexPattern.Compile(semgrexString);
SsurgeonPattern retPattern = new SsurgeonPattern(uid, semgrexPattern);
retPattern.SetNotes(notes);
INodeList editNodes = elt.GetElementsByTagName(SsurgeonPattern.EditListElemTag);
for (int i = 0; i < editNodes.GetLength(); i++)
{
INode node = editNodes.Item(i);
if (node.GetNodeType() == NodeConstants.ElementNode)
{
IElement editElt = (IElement)node;
string editVal = GetEltText(editElt);
retPattern.AddEdit(Edu.Stanford.Nlp.Semgraph.Semgrex.Ssurgeon.Ssurgeon.ParseEditLine(editVal));
}
}
// If predicate available, parse
IElement predElt = GetFirstTag(elt, SsurgeonPattern.PredicateTag);
if (predElt != null)
{
ISsurgPred pred = AssemblePredFromXML(GetFirstChildElement(predElt));
retPattern.SetPredicate(pred);
}
return(retPattern);
}
private void ConvertContentToText(INodeList node, TextWriter outText)
{
foreach (var subnode in node)
{
ConvertToText(subnode, outText);
}
}
/// <summary>
/// Returns the first element within the document (using depth-first pre-order traversal
/// of the document's nodes) that matches the specified group of selectors.
/// </summary>
/// <param name="elements">The elements to take as source.</param>
/// <param name="selectors">A string containing one or more CSS selectors separated by commas.</param>
/// <returns>An element object.</returns>
public static IElement QuerySelector(this INodeList elements, String selectors)
{
var sg = CssParser.Default.ParseSelector(selectors);
Validate(sg);
return(elements.QuerySelector(sg));
}
/// <summary>
/// Visits all elements of a list and returns either the original or a new collection if any of the elements
/// were modified.<para/>
/// If the result of visiting a given element is null, that element will be excluded from the resulting list.
/// </summary>
/// <typeparam name="T">The type of element the list contains.</typeparam>
/// <param name="list">The list of elements to visit.</param>
/// <param name="elementVisitor">A function that visits each element.</param>
/// <returns></returns>
internal static IReadOnlyList <T> VisitList <T>(INodeList <T> list, Func <T, T> elementVisitor)
{
var newItems = new List <T>(list.Count);
bool modified = false;
foreach (var item in list)
{
var newItem = elementVisitor(item);
if (!Equals(newItem, item))
{
modified = true;
if (newItem != null)
{
newItems.Add(newItem);
}
}
else
{
newItems.Add(newItem);
}
}
//If our list was modified, no point in wrapping it as INodeList<T> now; that'll happen when the list is incorporated into a TreeOrphan or TreeNode
if (modified)
{
return(newItems.ToReadOnly());
}
return(list);
}
/// <summary>
/// Returns a list of elements with the given tag name belonging to the given namespace.
/// The complete document is searched, including the root node.
/// </summary>
/// <param name="elements">The elements to take as source.</param>
/// <param name="namespaceUri">The namespace URI of elements to look for.</param>
/// <param name="localName">Either the local name of elements to look for or the special value "*", which matches all elements.</param>
/// <returns>A NodeList of found elements in the order they appear in the tree.</returns>
public static HtmlElementCollection GetElementsByTagNameNS(this INodeList elements, String namespaceUri, String localName)
{
var result = new List <IElement>();
elements.GetElementsByTagNameNS(namespaceUri, localName != "*" ? localName : null, result);
return(new HtmlElementCollection(result));
}
public void ChangeEvent()
{
var dom = TestDom("TestHtml");
INodeList list = dom["#hlinks-user > span:eq(1)"][0].ChildNodes;
IDomObject changedNode = null;
list.OnChanged += (sender, e) =>
{
changedNode = e.Node;
};
dom[".badge3"].Remove();
Assert.AreEqual(null, changedNode);
var nodeToRemove = dom[".badge2"][0];
nodeToRemove.Remove();
Assert.AreEqual(nodeToRemove, changedNode);
var nodeToAdd = dom["<div id=test />"][0];
dom["[title='2 silver badges']"].Append(nodeToAdd);
Assert.AreEqual(nodeToAdd, changedNode);
}
private static void GetMatchingNodes(INode node, Pattern[] nodePath, int cur, IList <INode> res)
{
if (cur < 0 || cur >= nodePath.Length)
{
return;
}
bool last = (cur == nodePath.Length - 1);
Pattern pattern = nodePath[cur];
INodeList children = node.GetChildNodes();
for (int i = 0; i < children.GetLength(); i++)
{
INode c = children.Item(i);
if (pattern.Matcher(c.GetNodeName()).Matches())
{
if (last)
{
res.Add(c);
}
else
{
GetMatchingNodes(c, nodePath, cur + 1, res);
}
}
}
}
/// <summary>
/// Returns a list of the elements within the document (using depth-first pre-order traversal
/// of the document's nodes) that matches the selector.
/// </summary>
/// <param name="elements">The elements to take as source.</param>
/// <param name="selector">A selector object.</param>
/// <returns>A HTMLCollection with all elements that match the selection.</returns>
public static HtmlElementCollection QuerySelectorAll(this INodeList elements, ISelector selector)
{
var result = new List <IElement>();
elements.QuerySelectorAll(selector, result);
return(new HtmlElementCollection(result));
}
private void LoadChildren(TreeNodeCollection where, INode node)
{
TreeNode t;
INodeList nodes = node.ChildNodes;
foreach (INode child in nodes)
{
string s = Enum.GetName(typeof(NodeType), child.Type);
switch (child.Type)
{
case NodeType.Attribute:
t = where.Add(nodeList.Count.ToString(), nodeList.Count.ToString() + "\t" + s + ":" + child.LocalName + "\t" + child.Value + "\t" + child.GetHashCode());
nodeList.Add(child);
break;
case NodeType.Element:
t = where.Add(nodeList.Count.ToString(), nodeList.Count.ToString() + "\t" + s + ":" + child.LocalName + "\t" + child.GetHashCode());
nodeList.Add(child as IElement);
LoadChildren(t.Nodes, child);
break;
case NodeType.Text:
t = where.Add(nodeList.Count.ToString(), nodeList.Count.ToString() + "\t" + s + ":" + child.Value + "\t" + child.GetHashCode());
nodeList.Add(child);
break;
default:
t = where.Add(nodeList.Count.ToString(), nodeList.Count.ToString() + "\t" + s + "\t" + child.GetHashCode());
nodeList.Add(child);
break;
}
t.ContextMenu = popupmenu;
}
}
/// <summary>
/// Returns a NodeList of elements with the given tag name. The complete document is searched, including the root node.
/// </summary>
/// <param name="elements">The elements to take as source.</param>
/// <param name="tagName">A string representing the name of the elements. The special string "*" represents all elements.</param>
/// <returns>A NodeList of found elements in the order they appear in the tree.</returns>
public static IHtmlCollection <IElement> GetElementsByTagName(this INodeList elements, String tagName)
{
var result = new List <IElement>();
elements.GetElementsByTagName(tagName is "*" ? null : tagName, result);
return(new HtmlCollection <IElement>(result));
}
private List <LotteryDrawResult> GetScrapeResults(LotteryDetails lotteryDetails, IHtmlDocument document)
{
List <LotteryDrawResult> lotteryDrawResultArr = new List <LotteryDrawResult>();
IEnumerable <IElement> tableElement = null;
tableElement = document.All.Where(x => x.ClassName == "Grid search-lotto-result-table" &&
x.Id == "cphContainer_cpContent_GridView1");
if (tableElement.Any())
{
IElement tbody = tableElement.First();
foreach (INode node in tbody.ChildNodes)
{
foreach (INode tr in node.ChildNodes.Skip(1))
{
INodeList tds = tr.ChildNodes;
LotteryDrawResultSetup setup = new LotteryDrawResultSetup();
if (tr.ChildNodes.Length >= 5)
{
setup.PutNumberSequence(tr.ChildNodes[2].TextContent);
setup.DrawDate = DateTime.ParseExact(tr.ChildNodes[3].TextContent, "M/d/yyyy", CultureInfo.InvariantCulture);
setup.JackpotAmt = double.Parse(tr.ChildNodes[4].TextContent);
setup.Winners = int.Parse(tr.ChildNodes[5].TextContent);
setup.GameCode = lotteryDetails.GameCode;
lotteryDrawResultArr.Add(setup);
}
}
}
}
return(lotteryDrawResultArr);
}
/// <summary>
/// Returns the first element within the document (using depth-first pre-order traversal
/// of the document's nodes) that matches the specified group of selectors.
/// </summary>
/// <param name="elements">The elements to take as source.</param>
/// <param name="selector">A selector object.</param>
/// <returns>An element object.</returns>
public static IElement?QuerySelector(this INodeList elements, ISelector selector)
{
for (var i = 0; i < elements.Length; i++)
{
if (elements[i] is IElement element)
{
if (selector.Match(element))
{
return(element);
}
if (element.HasChildNodes)
{
element = QuerySelector(element.ChildNodes, selector) !;
if (element != null)
{
return(element);
}
}
}
}
return(null);
}
/// <summary>Read parse trees from a Reader.</summary>
/// <param name="filename"/>
/// <param name="in">
/// The
/// <c>Reader</c>
/// </param>
/// <param name="simplifiedTagset">
/// If `true`, convert part-of-speech labels to a
/// simplified version of the EAGLES tagset, where the tags do not
/// include extensive morphological analysis
/// </param>
/// <param name="aggressiveNormalization">
/// Perform aggressive "normalization"
/// on the trees read from the provided corpus documents:
/// split multi-word tokens into their constituent words (and
/// infer parts of speech of the constituent words).
/// </param>
/// <param name="retainNER">
/// Retain NER information in preterminals (for later
/// use in `MultiWordPreprocessor) and add NER-specific
/// parents to single-word NE tokens
/// </param>
/// <param name="detailedAnnotations">
/// Retain detailed tree node annotations. These
/// annotations on parse tree constituents may be useful for
/// e.g. training a parser.
/// </param>
public SpanishXMLTreeReader(string filename, Reader @in, bool simplifiedTagset, bool aggressiveNormalization, bool retainNER, bool detailedAnnotations)
{
// Constituent annotations
ITreebankLanguagePack tlp = new SpanishTreebankLanguagePack();
this.simplifiedTagset = simplifiedTagset;
this.detailedAnnotations = detailedAnnotations;
stream = new ReaderInputStream(@in, tlp.GetEncoding());
treeFactory = new LabeledScoredTreeFactory();
treeNormalizer = new SpanishTreeNormalizer(simplifiedTagset, aggressiveNormalization, retainNER);
DocumentBuilder parser = XMLUtils.GetXmlParser();
try
{
IDocument xml = parser.Parse(stream);
IElement root = xml.GetDocumentElement();
sentences = root.GetElementsByTagName(NodeSent);
sentIdx = 0;
}
catch (SAXException e)
{
log.Info("Parse exception while reading " + filename);
Sharpen.Runtime.PrintStackTrace(e);
}
catch (IOException e)
{
Sharpen.Runtime.PrintStackTrace(e);
}
}
public void DepthFirstSearch(TileBoard inputBoard)
{
openNodes = new NodeStack();
Start(inputBoard);
Console.WriteLine("Depth First Search: ");
solution.Print();
Console.WriteLine("----------------------------");
}
/// <summary>
/// Returns a list of the elements within the rendered fragment or component under test,
/// (using depth-first pre-order traversal of the document's nodes) that match the specified group of selectors.
/// </summary>
/// <param name="selector">The group of selectors to use.</param>
/// <param name="nodelist">The elements to search within</param>
public static IHtmlCollection <IElement> FindAll(this INodeList nodelist, string selector)
{
if (nodelist is null)
{
throw new ArgumentNullException(nameof(nodelist));
}
return(nodelist.QuerySelectorAll(selector));
}
public void DepthLimitedSearch(TileBoard inputBoard)
{
openNodes = new NodeDepthStack(27, false);
Start(inputBoard);
Console.WriteLine("Depth Limited Search: (with a depth limit of 27)");
solution.Print();
Console.WriteLine("----------------------------");
}
public void DepthFirstSearch(TileBoard inputBoard)
{
openNodes = new NodeStack();
Start(inputBoard);
Console.WriteLine("Depth First Search: ");
solution.Print();
Console.WriteLine("----------------------------");
}
public void BreadthFirstSearch(TileBoard inputBoard)
{
openNodes = new NodeQueue();
Start(inputBoard);
Console.WriteLine("Breadth First Search: ");
solution.Print();
Console.WriteLine("----------------------------");
}
public static IList <IElement> QuerySelectorAll(this INodeList elements, ISelector selector)
{
List <IElement> list = new List <IElement>();
elements.QuerySelectorAll(selector, list);
return(list);
}
/// <summary>
/// Returns the first element within this element (using depth-first pre-order traversal
/// of the document's nodes) that matches the specified group of selectors.
/// </summary>
/// <param name="selector">The group of selectors to use.</param>
/// <param name="nodelist">The elements to search within</param>
public static IElement Find(this INodeList nodelist, string selector)
{
if (nodelist is null)
{
throw new ArgumentNullException(nameof(nodelist));
}
return(nodelist.QuerySelector(selector));
}
internal Node(XmlNode node)
{
thisNode = node;
thisAttributeList = null;
thisChildNodeList = null;
thisParentNode = null;
thisFirstChild = null;
}
public void DepthLimitedSearch(TileBoard inputBoard)
{
openNodes = new NodeDepthStack(27, false);
Start(inputBoard);
Console.WriteLine("Depth Limited Search: (with a depth limit of 27)");
solution.Print();
Console.WriteLine("----------------------------");
}
public void BreadthFirstSearch(TileBoard inputBoard)
{
openNodes = new NodeQueue();
Start(inputBoard);
Console.WriteLine("Breadth First Search: ");
solution.Print();
Console.WriteLine("----------------------------");
}
public void IterativeDeepeningSearch(TileBoard inputBoard)
{
var dataStructure = new NodeDepthStack(1, true);
openNodes = dataStructure;
Start(inputBoard);
Console.WriteLine("Iterative Deepening Search: (Final depth was " + dataStructure.Depth + " )");
solution.Print();
Console.WriteLine("----------------------------");
}
public static MutationRecord ChildList(INode target, INodeList addedNodes = null, INodeList removedNodes = null, INode previousSibling = null, INode nextSibling = null)
{
return new MutationRecord
{
Type = ChildListType,
Target = target,
Added = addedNodes,
Removed = removedNodes,
PreviousSibling = previousSibling,
NextSibling = nextSibling
};
}
public void BidirectionalSearch(TileBoard inputBoard)
{
bidirectional = true;
openNodes = new NodeQueue();
openNodesReverse = new NodeQueue();
Start(inputBoard);
Console.WriteLine("Bidirectional Search: ");
solution.Print();
Console.WriteLine("----------------------------");
bidirectional = false;
}
private void UpgradeChildren(INodeList openList,BoardNode visitedNode)
{
return;
foreach (var node in visitedNodes.Where(node => node.Value.Previous == visitedNode))
{
node.Value.Cost = visitedNode.Cost + 1;
if (openList.Upgrade(node.Value))
UpgradeChildren(openList, node.Value);
}
}
public CqXmlNodeList(XmlDocument xmlDocument, INodeList nodeList)
{
NodeList = nodeList;
XmlDocument = xmlDocument;
}
public void Concat(INodeList nodes)
{
foreach (Node n in nodes)
Add(n);
}
/// <summary>
/// Eventargs used when nodes has been added to a Node.
/// </summary>
/// <param name="addedNodes">The nodes which have been added.</param>
/// <param name="firstAddedNodeIndex">The index of the first Node added.</param>
public NodesAddedEventArgs(INodeList addedNodes, int firstAddedNodeIndex)
{
m_addedNodes = addedNodes;
m_firstAddedNodeIndex = firstAddedNodeIndex;
}
/// <summary>
/// Return the correct child from a list based on an index, and the current "FromLast" setting
/// </summary>
/// <param name="nodeList"></param>
/// <param name="index"></param>
/// <returns></returns>
private IDomObject GetEffectiveChild(INodeList nodeList, int index)
{
return GetEffectiveChild(nodeList, index, FromLast);
}
static void AssertArrayEqual(INodeList actual, INodeList expected)
{
Assert.AreEqual(expected.Length, actual.Length);
for (int i = 0; i < expected.Length; i++)
Assert.AreSame(expected[i], actual[i]);
}
/// <summary>
/// Eventargs used when nodes have been removed from a Node.
/// </summary>
/// <param name="removedNodes">The nodes which have been removed.</param>
public NodesRemovedEventArgs(INodeList removedNodes)
{
m_removedNodes = removedNodes;
}
/// <summary>
/// Gets the true index based on an effective index. (Misnomer, consider changing, should be
/// GetActualIndex)
/// </summary>
///
/// <param name="nodeList">
/// The container to obtain children from
/// </param>
/// <param name="index">
/// The index
/// </param>
/// <param name="fromLast">
/// Count from the last element instead of the first.
/// </param>
///
/// <returns>
/// The actual index.
/// </returns>
public static int GetEffectiveIndex(INodeList nodeList, int index, bool fromLast)
{
if (fromLast)
{
return nodeList.Length - index - 1;
}
else
{
return index;
}
}
// These methods are exposed because they are used elsewhere
/// <summary>
/// Return the correct child from a list based on an index, and the fromLast setting. That is, if fromLast is
/// true, just return the child at "index." If not, return the child starting from the end at "index"
/// </summary>
///
/// <param name="nodeList">
/// The container to obtain children from
/// </param>
/// <param name="index">
/// The index
/// </param>
/// <param name="fromLast">
/// Count from the last element instead of the first.
/// </param>
///
/// <returns>
/// The effective child.
/// </returns>
public static IDomObject GetEffectiveChild(INodeList nodeList, int index, bool fromLast)
{
if (fromLast)
{
return nodeList[nodeList.Count - index - 1];
}
else
{
return nodeList[index];
}
}
/// <summary>
/// Eventargs used when a Node is splitted from his parents
/// </summary>
/// <param name="originalParents">The parents before the splitting event.</param>
public NodeSplittedEventArgs(INodeList originalParents)
{
m_originalParents = originalParents;
}
