private void DrawHtmlAttributeChange(XmlWriter writer, XmlDiffViewAttribute attr, string localName, string prefix, string value) { if (prefix != string.Empty) { XmlDiffView.HtmlWriteString(writer, _ignorePrefixes ? XmlDiffViewOperation.Ignore : (attr._prefix == attr._changeInfo._prefix) ? XmlDiffViewOperation.Match : XmlDiffViewOperation.Change, prefix + ":"); } XmlDiffView.HtmlWriteString(writer, (attr._localName == attr._changeInfo._localName) ? XmlDiffViewOperation.Match : XmlDiffViewOperation.Change, localName); if (attr._value != attr._changeInfo._value) { XmlDiffView.HtmlWriteString(writer, "=\""); XmlDiffView.HtmlWriteString(writer, XmlDiffViewOperation.Change, value); XmlDiffView.HtmlWriteString(writer, "\""); } else { XmlDiffView.HtmlWriteString(writer, "=\"" + value + "\""); } }
private void AnnotateNode(XmlDiffViewNode node, XmlDiffViewOperation op, int opid, bool bSubtree) { node._op = op; node._opid = opid; if (node._nodeType == XmlNodeType.Element) { XmlDiffViewAttribute attr = ((XmlDiffViewElement)node)._attributes; while (attr != null) { attr._op = op; attr._opid = opid; attr = (XmlDiffViewAttribute)attr._nextSibbling; } } if (bSubtree) { XmlDiffViewNode childNode = node.FirstChildNode; while (childNode != null) { AnnotateNode(childNode, op, opid, true); childNode = childNode._nextSibbling; } } }
private void DrawHtmlAttributes(XmlWriter writer, int paneNo) { if (_attributes == null) { return; } string attrIndent = string.Empty; if (_attributes._nextSibbling != null) { attrIndent = XmlDiffView.GetIndent(_name.Length + 2); } XmlDiffViewAttribute curAttr = _attributes; while (curAttr != null) { if (XmlDiffView.HtmlWriteToPane[(int)curAttr._op, paneNo]) { if (curAttr == _attributes) { writer.WriteString(" "); } else { writer.WriteRaw(attrIndent); } if (curAttr._op == XmlDiffViewOperation.Change) { if (paneNo == 0) { DrawHtmlAttributeChange(writer, curAttr, curAttr._localName, curAttr._prefix, curAttr._value); } else { DrawHtmlAttributeChange(writer, curAttr, curAttr._changeInfo._localName, curAttr._changeInfo._prefix, curAttr._changeInfo._value); } } else { DrawHtmlAttribute(writer, curAttr, curAttr._op); } } else { XmlDiffView.HtmlWriteEmptyString(writer); } curAttr = (XmlDiffViewAttribute)curAttr._nextSibbling; if (curAttr != null) { XmlDiffView.HtmlBr(writer); } } }
static XmlDiffPathNodeList SelectAttributes(XmlDiffViewElement parentElement, string path) { Debug.Assert(path[0] == '@'); int pos = 1; XmlDiffPathNodeList nodeList = null; //NCOVER DOESN'T LIKE: for (;;) while (true) { string name = ReadAttrName(path, ref pos); if (nodeList == null) { if (pos == path.Length) { nodeList = new XmlDiffPathSingleNodeList(); } else { nodeList = new XmlDiffPathMultiNodeList(); } } XmlDiffViewAttribute attr = parentElement.GetAttribute(name); if (attr == null) { OnNoMatchingNode(path); } nodeList.AddNode(attr); if (pos == path.Length) { break; } else if (path[pos] == '|') { pos++; if (path[pos] != '@') { OnInvalidExpression(path); } pos++; } else { OnInvalidExpression(path); } } return(nodeList); }
private XmlDiffViewNode ImportNode(XmlNode node) { XmlDiffViewNode newNode = null; switch (node.NodeType) { case XmlNodeType.Element: XmlElement el = (XmlElement)node; XmlDiffViewElement newElement = new XmlDiffViewElement(el.LocalName, el.Prefix, el.NamespaceURI, _bIgnorePrefixes); // attributes IEnumerator attributes = node.Attributes.GetEnumerator(); XmlDiffViewAttribute lastNewAttr = null; while (attributes.MoveNext()) { XmlAttribute at = (XmlAttribute)attributes.Current; XmlDiffViewAttribute newAttr = new XmlDiffViewAttribute(at.LocalName, at.Prefix, at.NamespaceURI, at.Value); newElement.InsertAttributeAfter(newAttr, lastNewAttr); lastNewAttr = newAttr; } // children IEnumerator childNodes = node.ChildNodes.GetEnumerator(); XmlDiffViewNode lastNewChildNode = null; while (childNodes.MoveNext()) { XmlDiffViewNode newChildNode = ImportNode((XmlNode)childNodes.Current); newElement.InsertChildAfter(newChildNode, lastNewChildNode, false); lastNewChildNode = newChildNode; } newNode = newElement; break; case XmlNodeType.Text: case XmlNodeType.CDATA: case XmlNodeType.Comment: newNode = new XmlDiffViewCharData(node.Value, node.NodeType); break; case XmlNodeType.ProcessingInstruction: newNode = new XmlDiffViewPI(node.Name, node.Value); break; case XmlNodeType.EntityReference: newNode = new XmlDiffViewER(node.Name); break; default: Debug.Assert(false, "Invalid node type."); break; } Debug.Assert(newNode != null); return(newNode); }
internal XmlDiffViewAttribute GetAttribute(string name) { XmlDiffViewAttribute curAttr = _attributes; while (curAttr != null) { if (curAttr._name == name && curAttr._op == XmlDiffViewOperation.Match) { return(curAttr); } curAttr = (XmlDiffViewAttribute)curAttr._nextSibbling; } return(null); }
internal void InsertAttributeAfter(XmlDiffViewAttribute newAttr, XmlDiffViewAttribute refAttr) { Debug.Assert(newAttr != null); if (refAttr == null) { newAttr._nextSibbling = _attributes; _attributes = newAttr; } else { newAttr._nextSibbling = refAttr._nextSibbling; refAttr._nextSibbling = newAttr; } newAttr._parent = this; }
private void DrawHtmlAttribute(XmlWriter writer, XmlDiffViewAttribute attr, XmlDiffViewOperation opForColor) { if (_ignorePrefixes) { if (attr._prefix == "xmlns" || (attr._localName == "xmlns" && attr._prefix == string.Empty)) { XmlDiffView.HtmlWriteString(writer, XmlDiffViewOperation.Ignore, attr._name); XmlDiffView.HtmlWriteString(writer, opForColor, "=\"" + attr._value + "\""); return; } else if (attr._prefix != string.Empty) { XmlDiffView.HtmlWriteString(writer, XmlDiffViewOperation.Ignore, attr._prefix + ":"); XmlDiffView.HtmlWriteString(writer, opForColor, attr._localName + "=\"" + attr._value + "\""); return; } } XmlDiffView.HtmlWriteString(writer, opForColor, attr._name + "=\"" + attr._value + "\""); }
internal override XmlDiffViewNode Clone(bool bDeep) { XmlDiffViewElement newElement = new XmlDiffViewElement(_localName, _prefix, _ns, _ignorePrefixes); // attributes { XmlDiffViewAttribute curAttr = _attributes; XmlDiffViewAttribute lastNewAtt = null; while (curAttr != null) { XmlDiffViewAttribute newAttr = (XmlDiffViewAttribute)curAttr.Clone(true); newElement.InsertAttributeAfter(newAttr, lastNewAtt); lastNewAtt = newAttr; curAttr = (XmlDiffViewAttribute)curAttr._nextSibbling; } } if (!bDeep) { return(newElement); } // child nodes { XmlDiffViewNode curChild = _childNodes; XmlDiffViewNode lastNewChild = null; while (curChild != null) { XmlDiffViewNode newChild = curChild.Clone(true); newElement.InsertChildAfter(newChild, lastNewChild, false); lastNewChild = newChild; curChild = curChild._nextSibbling; } } return(newElement); }
static XmlDiffPathNodeList SelectAllAttributes(XmlDiffViewElement parentElement) { if (parentElement._attributes == null) { OnNoMatchingNode("@*"); return(null); } else if (parentElement._attributes._nextSibbling == null) { XmlDiffPathNodeList nodeList = new XmlDiffPathSingleNodeList(); nodeList.AddNode(parentElement._attributes); return(nodeList); } else { XmlDiffPathNodeList nodeList = new XmlDiffPathMultiNodeList(); XmlDiffViewAttribute curAttr = parentElement._attributes; while (curAttr != null) { nodeList.AddNode(curAttr); } return(nodeList); } }
public void Reset() { _curLastChild = null; _curLastAttribute = null; }
private void OnAddNode(XmlElement diffgramElement, string nodeTypeAttr, XmlDiffViewParentNode sourceParent, ref XmlDiffViewNode currentPosition) { XmlNodeType nodeType = (XmlNodeType)int.Parse(nodeTypeAttr); string name = diffgramElement.GetAttribute("name"); string prefix = diffgramElement.GetAttribute("prefix"); string ns = diffgramElement.GetAttribute("ns"); string opidAttr = diffgramElement.GetAttribute("opid"); int opid = (opidAttr == string.Empty) ? 0 : int.Parse(opidAttr); if (nodeType == XmlNodeType.Attribute) { Debug.Assert(name != string.Empty); XmlDiffViewAttribute newAttr = new XmlDiffViewAttribute(name, prefix, ns, diffgramElement.InnerText); newAttr._op = XmlDiffViewOperation.Add; newAttr._opid = opid; ((XmlDiffViewElement)sourceParent).InsertAttributeAfter(newAttr, null); } else { XmlDiffViewNode newNode = null; switch (nodeType) { case XmlNodeType.Element: Debug.Assert(name != string.Empty); newNode = new XmlDiffViewElement(name, prefix, ns, _bIgnorePrefixes); ApplyDiffgram(diffgramElement, (XmlDiffViewParentNode)newNode); break; case XmlNodeType.Text: case XmlNodeType.CDATA: case XmlNodeType.Comment: Debug.Assert(diffgramElement.InnerText != string.Empty); newNode = new XmlDiffViewCharData(diffgramElement.InnerText, nodeType); break; case XmlNodeType.ProcessingInstruction: Debug.Assert(diffgramElement.InnerText != string.Empty); Debug.Assert(name != string.Empty); newNode = new XmlDiffViewPI(name, diffgramElement.InnerText); break; case XmlNodeType.EntityReference: Debug.Assert(name != string.Empty); newNode = new XmlDiffViewER(name); break; case XmlNodeType.XmlDeclaration: Debug.Assert(diffgramElement.InnerText != string.Empty); newNode = new XmlDiffViewXmlDeclaration(diffgramElement.InnerText); break; case XmlNodeType.DocumentType: newNode = new XmlDiffViewDocumentType(diffgramElement.GetAttribute("name"), diffgramElement.GetAttribute("publicId"), diffgramElement.GetAttribute("systemId"), diffgramElement.InnerText); break; default: Debug.Assert(false, "Invalid node type."); break; } Debug.Assert(newNode != null); newNode._op = XmlDiffViewOperation.Add; newNode._opid = opid; sourceParent.InsertChildAfter(newNode, currentPosition, false); currentPosition = newNode; } }
private void LoadSourceChildNodes(XmlDiffViewParentNode parent, XmlReader reader, bool bEmptyElement) { LoadState savedLoadState = _loadState; _loadState.Reset(); // load attributes while (reader.MoveToNextAttribute()) { XmlDiffViewAttribute attr; if (reader.Prefix == "xmlns" || (reader.Prefix == string.Empty && reader.LocalName == "xmlns")) { attr = new XmlDiffViewAttribute(reader.LocalName, reader.Prefix, reader.NamespaceURI, reader.Value); if (_bIgnoreNamespaces) { attr._op = XmlDiffViewOperation.Ignore; } } else { string attrValue = _bIgnoreWhitespace ? NormalizeText(reader.Value) : reader.Value; attr = new XmlDiffViewAttribute(reader.LocalName, reader.Prefix, reader.NamespaceURI, attrValue); } ((XmlDiffViewElement)parent).InsertAttributeAfter(attr, _loadState._curLastAttribute); _loadState._curLastAttribute = attr; } // empty element -> return, do not load chilren if (bEmptyElement) { goto End; } // load children while (reader.Read()) { // ignore whitespaces between nodes if (reader.NodeType == XmlNodeType.Whitespace) { continue; } XmlDiffViewNode child = null; switch (reader.NodeType) { case XmlNodeType.Element: bool bEmptyEl = reader.IsEmptyElement; XmlDiffViewElement elem = new XmlDiffViewElement(reader.LocalName, reader.Prefix, reader.NamespaceURI, _bIgnorePrefixes); LoadSourceChildNodes(elem, reader, bEmptyEl); child = elem; break; case XmlNodeType.Attribute: Debug.Assert(false, "We should never get to this point, attributes should be read at the beginning of thid method."); break; case XmlNodeType.Text: child = new XmlDiffViewCharData((_bIgnoreWhitespace) ? NormalizeText(reader.Value) : reader.Value, XmlNodeType.Text); break; case XmlNodeType.CDATA: child = new XmlDiffViewCharData(reader.Value, XmlNodeType.CDATA); break; case XmlNodeType.EntityReference: child = new XmlDiffViewER(reader.Name); break; case XmlNodeType.Comment: child = new XmlDiffViewCharData(reader.Value, XmlNodeType.Comment); if (_bIgnoreComments) { child._op = XmlDiffViewOperation.Ignore; } break; case XmlNodeType.ProcessingInstruction: child = new XmlDiffViewPI(reader.Name, reader.Value); if (_bIgnorePI) { child._op = XmlDiffViewOperation.Ignore; } break; case XmlNodeType.SignificantWhitespace: if (reader.XmlSpace == XmlSpace.Preserve) { child = new XmlDiffViewCharData(reader.Value, XmlNodeType.SignificantWhitespace); if (_bIgnoreWhitespace) { child._op = XmlDiffViewOperation.Ignore; } } break; case XmlNodeType.XmlDeclaration: child = new XmlDiffViewXmlDeclaration(NormalizeText(reader.Value)); if (_bIgnoreXmlDecl) { child._op = XmlDiffViewOperation.Ignore; } break; case XmlNodeType.EndElement: goto End; case XmlNodeType.DocumentType: child = new XmlDiffViewDocumentType(reader.Name, reader.GetAttribute("PUBLIC"), reader.GetAttribute("SYSTEM"), reader.Value); if (_bIgnoreDtd) { child._op = XmlDiffViewOperation.Ignore; } break; default: Debug.Assert(false, "Invalid node type"); break; } parent.InsertChildAfter(child, _loadState._curLastChild, true); _loadState._curLastChild = child; } End: _loadState = savedLoadState; }