static void MergeCData(XCData dst, XCData src)
{
if (dst.Value != src.Value)
{
dst.Value = src.Value;
}
}
private static string SerializeToXml(TransportMessage transportMessage)
{
var overrides = new XmlAttributeOverrides();
var attrs = new XmlAttributes {
XmlIgnore = true
};
// Exclude non-serializable members
overrides.Add(typeof(TransportMessage), "Body", attrs);
overrides.Add(typeof(TransportMessage), "ReplyToAddress", attrs);
overrides.Add(typeof(TransportMessage), "Headers", attrs);
var sb = new StringBuilder();
var xws = new XmlWriterSettings {
Encoding = Encoding.Unicode
};
var xw = XmlWriter.Create(sb, xws);
var xs = new XmlSerializer(typeof(TransportMessage), overrides);
xs.Serialize(xw, transportMessage);
var xdoc = XDocument.Parse(sb.ToString());
var body = new XElement("Body");
var cdata = new XCData(Encoding.UTF8.GetString(transportMessage.Body));
body.Add(cdata);
xdoc.SafeElement("TransportMessage").Add(body);
sb.Clear();
var sw = new StringWriter(sb);
xdoc.Save(sw);
return(sb.ToString());
}
public void XCDataChangeValue()
{
XCData toChange = new XCData("Original Value");
String newValue = "New Value";
XElement xElem = new XElement("root", toChange);
XElement xElemOriginal = new XElement(xElem);
using (UndoManager undo = new UndoManager(xElem))
{
undo.Group();
using (EventsHelper eHelper = new EventsHelper(xElem))
{
using (EventsHelper dataHelper = new EventsHelper(toChange))
{
toChange.Value = newValue;
Assert.True(toChange.Value.Equals(newValue), "Value did not change");
xElem.Verify();
dataHelper.Verify(XObjectChange.Value, toChange);
}
eHelper.Verify(XObjectChange.Value, toChange);
}
undo.Undo();
Assert.True(XNode.DeepEquals(xElem, xElemOriginal), "Undo did not work!");
}
}
/// <summary>
/// Tests the WriteTo method on XTest.
/// </summary>
/// <param name="contextValue"></param>
/// <returns></returns>
//[Variation(Desc = "TextWriteTo")]
public void TextWriteTo()
{
XCData c = new XCData("abcd");
// Null writer not allowed.
try
{
c.WriteTo(null);
Validate.ExpectedThrow(typeof(ArgumentNullException));
}
catch (Exception ex)
{
Validate.Catch(ex, typeof(ArgumentNullException));
}
// Test.
StringBuilder stringBuilder = new StringBuilder();
XmlWriter xmlWriter = XmlWriter.Create(stringBuilder);
xmlWriter.WriteStartElement("x");
c.WriteTo(xmlWriter);
xmlWriter.WriteEndElement();
xmlWriter.Flush();
Validate.IsEqual(
stringBuilder.ToString(),
"<?xml version=\"1.0\" encoding=\"utf-16\"?><x><![CDATA[abcd]]></x>");
}
/// <summary>
/// create node for every addin
/// store data of addin in xml
/// </summary>
/// <param name="xeAddins"></param>
private void GetAddinXml(XElement xeAddins)
{
XElement xeAddin = null;
XCData xeCdata = null;
try
{
if (m_lstAddins != null && m_lstAddins.Count > 0)
{
foreach (IWAddIn objAddin in m_lstAddins)
{
xeAddin = new XElement("addin");
xeAddin.SetAttributeValue("addinid", objAddin.InstanceId);
xeAddin.SetAttributeValue("name", objAddin.Name);
xeAddin.SetAttributeValue("type", objAddin.AddinType);
if (!string.IsNullOrEmpty(objAddin.Config))
{
xeCdata = new XCData(objAddin.Config);
if (xeCdata != null)
{
xeAddin.Add(xeCdata);
}
}
xeAddins.Add(xeAddin);
}
}
}
finally
{
xeAddin = null;
xeCdata = null;
}
}
public void SaveCurrentSyllableState(List <string[]> data, int index)
{
var xmlCurrentState = Settings.xmlConfig.Element("current-state");
if (xmlCurrentState == null)
{
xmlCurrentState = new XElement("current-state");
xmlConfig.Add(xmlCurrentState);
}
var xIndex = new XAttribute("index", index);
StringBuilder sb = new StringBuilder();
foreach (var syllables in data)
{
sb.Append(string.Join(",", syllables)).Append("|");
}
sb.Length--;
var xData = new XCData(sb.ToString());
xmlCurrentState.Element("syllables")?.Remove();
var xmlSyllables = new XElement("syllables", xIndex, xData);
xmlCurrentState.Add(xmlSyllables);
SaveXmlConfig();
}
private static string XPathResultGetValue(object xpathResult, bool acceptCData = false)
{
if (xpathResult is string)
{
return(xpathResult as string);
}
else if (xpathResult is XAttribute)
{
return((xpathResult as XAttribute).Value);
}
// modif le 09/02/2015
else if (xpathResult is XText)
{
return((xpathResult as XText).Value);
}
else if (xpathResult is XElement)
{
//value = (xpathResult as XElement).zTextOrAttribValue();
XElement xe = (XElement)xpathResult;
XAttribute attrib = xe.Attribute("value");
if (attrib != null)
{
return(attrib.Value);
}
if (acceptCData)
{
XCData cdata = GetUniqueCDataChild(xe);
if (cdata != null)
{
return(cdata.Value);
}
}
}
return(null);
}
public XText GetTextEl(XElement el)
{
XText rt = null;
IEnumerable <XNode> lst = el.Nodes();
string value_string = "";
foreach (XNode nd in lst)
{
if (nd.NodeType == XmlNodeType.Text)
{
value_string += (string)((XText)nd).Value;
}
else if (nd.NodeType == XmlNodeType.CDATA)
{
XCData xcd = (XCData)nd;
value_string += xcd.Value;
}
}
rt = new XText(value_string);
return(rt);
}
public void Save <T>(string path, T t) where T : class, new()
{
XDocument xdoc = new XDocument(new XDeclaration("1.0", "utf-8", "yes"));
XElement root = new XElement("configuration");
PropertyInfo[] pisarr = typeof(T).GetProperties();
foreach (PropertyInfo pi in pisarr)
{
XElement ele = new XElement(pi.Name);
object valObj = pi.GetValue(t, null);
if (valObj == null)
{
valObj = "";
}
if (valObj.ToString() != "")
{
if (pi.PropertyType == typeof(DateTime))
{
valObj = DateTime.Parse(valObj.ToString()).ToString("yyyy-MM-dd HH:mm:ss");
}
}
XCData cdata = new XCData(valObj.ToString());
ele.Add(cdata);
root.Add(ele);
}
if (File.Exists(path))
{
File.Delete(path);
}
root.Save(path, SaveOptions.None);
}
private Table WrapWithCitation(XElement image, string caption, XNamespace ns)
{
var table = new Table(ns);
table.AddColumn(0f); // OneNote will set width accordingly
var cdata = new XCData(caption);
var row = table.AddRow();
var cell = row.Cells.First();
cell.SetContent(
new XElement(ns + "OEChildren",
new XElement(ns + "OE",
new XAttribute("alignment", "center"),
image),
new XElement(ns + "OE",
new XAttribute("alignment", "center"),
new XAttribute("quickStyleIndex", citation.Index.ToString()),
new XElement(ns + "Meta",
new XAttribute("name", "om"),
new XAttribute("content", "caption")),
new XElement(ns + "T", cdata)
)
));
return(table);
}
public void TestBuildInput_NoIdentifier_Compression()
{
ICompressor compressor = new GZipCompressor();
Image img = _createTestImage();
JobInput i = new JobInput(img);
i.Compressor = compressor;
JobBuilderProcess p = new JobBuilderProcess();
XElement element = p.BuildInput(i);
Assert.AreEqual("input", element.Name);
Assert.IsNull(element.Attribute("identifier"));
Assert.IsNotNull(element.Attribute("compressor"));
Assert.AreEqual("gzip", element.Attribute("compressor").Value.ToLower());
XNode child = element.FirstNode;
Assert.IsTrue(child.NodeType == System.Xml.XmlNodeType.CDATA);
XCData data = (XCData)child;
string providedImage = data.Value;
string expectedImage = System.Text.Encoding.Default.GetString(CompressionAssistant.Compress(img, compressor));
Assert.AreEqual(expectedImage, providedImage);
}
public void TestBuildInput_Identifier_NoCompression()
{
object identifier = "Test";
Image img = _createTestImage();
JobInput i = new JobInput(img);
i.Identifier = identifier;
JobBuilderProcess p = new JobBuilderProcess();
XElement element = p.BuildInput(i);
Assert.AreEqual("input", element.Name);
Assert.IsNotNull(element.Attribute("identifier"));
Assert.AreEqual(identifier, element.Attribute("identifier").Value);
XNode child = element.FirstNode;
Assert.IsTrue(child.NodeType == System.Xml.XmlNodeType.CDATA);
XCData data = (XCData)child;
string providedImage = data.Value;
string expectedImage = System.Text.Encoding.Default.GetString(CompressionAssistant.ImageToBytes(img));
Assert.AreEqual(expectedImage, providedImage);
}
/// <summary>
/// Constructs Xml using the <see cref="JobInput"/>.
/// </summary>
/// <param name="input">The <see cref="JobInput"/> to be used as input
/// in a job.</param>
/// <returns>An <see cref="XElement"/> representing the
/// <see cref="JobInput"/>.</returns>
/// <exception cref="InvalidOperationException">this
/// <see cref="IBuilderProcess"/> does not support building
/// inputs.</exception>
public XElement BuildInput(JobInput input)
{
ICollection <object> content = new List <object>();
if (input.Identifier != null)
{
XAttribute id = new XAttribute("identifier", input.Identifier);
content.Add(id);
}
byte[] imgBytes = null;
if (input.Compressor != null)
{
string compressorId = CompressorFactory.ResolveIdentifier(input.Compressor);
imgBytes = CompressionAssistant.Compress(input.Input, input.Compressor);
XAttribute compressor = new XAttribute("compressor", compressorId);
content.Add(compressor);
}
else
{
imgBytes = CompressionAssistant.ImageToBytes(input.Input);
}
string bytesAsString = System.Text.Encoding.Default.GetString(imgBytes);
XCData imgNode = new XCData(bytesAsString);
content.Add(imgNode);
return(new XElement("input", content));
}
private RpcMethod(string pInterfaceName, string pFunctionName, IEnumerable <object> pParames)
{
_mElement = new XElement("CallRemoting");
XElement interfaceElement = new XElement("Interface");
interfaceElement.SetValue(pInterfaceName);
_mElement.Add(interfaceElement);
XElement methodElement = new XElement("Method");
methodElement.SetValue(pFunctionName);
_mElement.Add(methodElement);
if (pParames != null)
{
XElement paramsElement = new XElement("Params");
foreach (object param in pParames)
{
XElement paramElement = new XElement("Param");
paramElement.SetAttributeValue("Type", param.GetType().ToString());
XCData xcd = new XCData(param.ToString());
paramElement.Add(xcd);
paramsElement.Add(paramElement);
}
_mElement.Add(paramsElement);
}
}
private static XElement CreateNode(
string ns,
string elementName,
XCData value)
{
return(new XElement($"{ns}:{elementName}", value));
}
private void MakeWordBank(Page page, XNamespace ns, List <string> words)
{
var sep = page.IsRightToLeft()
? $" {AddIn.Culture.TextInfo.ListSeparator}"
: $"{AddIn.Culture.TextInfo.ListSeparator} ";
var content = $"<span style='font-weight:bold'>{string.Join(sep, words)}</span>";
var quickIndex = MakeQuickStyle(page);
var tagIndex = MakeRibbonTagDef(page, BankType);
var outline = page.Root.Elements(ns + "Outline")
.FirstOrDefault(e => e.Elements().Any(x =>
x.Name.LocalName == "Meta" &&
x.Attribute("name").Value == MetaNames.TaggingBank));
XCData cdata;
if (outline == null)
{
var tag = new XElement(ns + "Tag",
new XAttribute("index", tagIndex),
new XAttribute("completed", "true"),
new XAttribute("disabled", "false"));
cdata = new XCData(content);
outline = new XElement(ns + "Outline",
new XElement(ns + "Position",
// 245 accounts for "Wednesday, December 30, 2020 12:12pm"
new XAttribute("x", "245"),
new XAttribute("y", "43"),
new XAttribute("z", "0")),
new XElement(ns + "Size",
new XAttribute("width", "400"),
new XAttribute("height", "11"),
new XAttribute("isSetByUser", "true")),
new XElement(ns + "Meta",
new XAttribute("name", MetaNames.TaggingBank),
new XAttribute("content", "1")),
new XElement(ns + "OEChildren",
new XElement(ns + "OE",
new XAttribute("quickStyleIndex", quickIndex),
tag,
new XElement(ns + "T", cdata)
))
);
page.Root.Elements(ns + "Title").First().AddAfterSelf(outline);
}
else
{
cdata = outline.Descendants(ns + "T").FirstOrDefault().GetCData();
if (cdata != null)
{
cdata.Value = content;
}
}
}
public static XElement Javascript(string content)
{
var cdata = new XCData("*/" + content + "/*");
var begin = new XText("/*");
var end = new XText("*/");
return(E("script", A("type", "text/javascript"), begin, cdata, end));
}
public static void SerializeSimpleValueToCDATA(this IExolutioSerializable component, [NotNull] string elementName, object value, XElement parentNode, SerializationContext context)
{
XElement xmlElement = new XElement(context.ExolutioNS + elementName);
XCData xcData = new XCData(value.ToString());
xmlElement.Add(xcData);
parentNode.Add(xmlElement);
}
public static XCData WriteCData(this XElement parent, string data)
{
var cdata = new XCData(data);
parent.Add(cdata);
return(cdata);
}
public static XElement SubElement(
this XElement @this,
string elementName,
XCData value)
{
@this.Add(CreateNode(elementName, value));
return(@this);
}
/// <summary>
/// Gets the results as XML.
/// </summary>
/// <param name="results">The results.</param>
/// <returns></returns>
private static XPathNodeIterator GetResultsAsXml(ISearchResults results)
{
// create the XDocument
XDocument doc = new XDocument();
// check there are any search results
if (results.TotalItemCount > 0)
{
// create the root element
XElement root = new XElement("nodes");
// iterate through the search results
foreach (SearchResult result in results)
{
// create a new <node> element
XElement node = new XElement("node");
// create the @id attribute
XAttribute nodeId = new XAttribute("id", result.Id);
// create the @score attribute
XAttribute nodeScore = new XAttribute("score", result.Score);
// add the content
node.Add(nodeId, nodeScore);
foreach (KeyValuePair <String, String> field in result.Fields)
{
// create a new <data> element
XElement data = new XElement("data");
// create the @alias attribute
XAttribute alias = new XAttribute("alias", field.Key);
// assign the value to a CDATA section
XCData value = new XCData(field.Value);
// append the content
data.Add(alias, value);
// append the <data> element
node.Add(data);
}
// add the node
root.Add(node);
}
// add the root node
doc.Add(root);
}
else
{
doc.Add(new XElement("error", "There were no search results."));
}
return(doc.CreateNavigator().Select("/"));
}
public string SignDocument(string xml)
{
var doc = new SignedXmlDocument(xml);
CrytoProvider.SignDocument(doc);
var cdata = new XCData(doc.ToString());
return(cdata.ToString());
}
public void CreateTextSimple()
{
Assert.Throws <ArgumentNullException>(() => new XCData((string)null));
XCData c = new XCData("foo");
Assert.Equal("foo", c.Value);
Assert.Null(c.Parent);
}
public static string NormalizeNewLines(XCData data)
{
if (ExecutionConditionUtil.IsWindows)
{
return(data.Value.Replace("\n", "\r\n"));
}
return(data.Value);
}
protected VisualBasic.VisualBasicCompilation CreateVisualBasicCompilation(
XCData code,
VisualBasic.VisualBasicParseOptions parseOptions = null,
VisualBasic.VisualBasicCompilationOptions compilationOptions = null,
string assemblyName = null,
IEnumerable <MetadataReference> referencedAssemblies = null)
{
return(CreateVisualBasicCompilation(assemblyName, code, parseOptions, compilationOptions, referencedAssemblies, referencedCompilations: null));
}
protected CSharp.CSharpCompilation CreateCSharpCompilation(
XCData code,
CSharp.CSharpParseOptions parseOptions = null,
CSharp.CSharpCompilationOptions compilationOptions = null,
string assemblyName = null,
IEnumerable <MetadataReference> referencedAssemblies = null)
{
return(CreateCSharpCompilation(assemblyName, code, parseOptions, compilationOptions, referencedAssemblies, referencedCompilations: null));
}
private static XElement CreateElement(Type type, string name, object value)
{
if (type == typeof(string))
{
XCData content = new XCData(value.ToString());
return(new XElement(name, content));
}
return(new XElement(name, value));
}
protected void ParseChildNode(HtmlNode htmlNode, XElement resultElement, ParseContext parseContext, XElement baseFormattingElement)
{
if (parseContext.ParseDefinitions.IsEscapedNode(htmlNode))
{
return;
}
ParseDefinition definition = parseContext.ParseDefinitions[htmlNode];
if (definition != null)
{
Type typeInfo = ReflectionUtil.GetTypeInfo(definition.HtmlParserType);
if (typeInfo.Name == "CustomHtmlNodeParser")
{
var customParser = CustomHtmlParseHelper.GetParser <CustomHtmlNodeParser>(definition);
if (customParser == null)
{
return;
}
customParser.SpecialCharacterMapper = SpecialCharacterMapper;
customParser.ParseNode(htmlNode, resultElement, parseContext, baseFormattingElement);
}
else
{
object parser = CustomHtmlParseHelper.GetParser <HtmlNodeParser>(definition);
((HtmlNodeParser)parser)?.ParseNode(htmlNode, resultElement, parseContext, baseFormattingElement);
}
}
else if (HtmlParseHelper.IsPlainTextNode(htmlNode))
{
XCData xcData = new XCData(HtmlEntityHelper.DeEntitize(htmlNode.InnerHtml));
if (SpecialCharacterMapper != null)
{
SpecialCharacterMapper.ParseSpecialCharacters(xcData.Value, baseFormattingElement, ref resultElement);
return;
}
if (baseFormattingElement != null)
{
XElement xelement = new XElement(baseFormattingElement);
xelement.Add((object)xcData);
resultElement.Add((object)xelement);
}
else
{
resultElement.Add(xcData);
}
}
else
{
XElement formattingElement = StyleParser.GetFormattingElement(htmlNode, baseFormattingElement, true);
this.ParseChildNodes(htmlNode, resultElement, parseContext, formattingElement);
}
}
public CompilationVerifier VerifyIL(
string qualifiedMethodName,
XCData expectedIL,
bool realIL = false,
string sequencePoints = null,
[CallerFilePath] string callerPath = null,
[CallerLineNumber] int callerLine = 0)
{
return(VerifyILImpl(qualifiedMethodName, expectedIL.Value, realIL, sequencePoints, callerPath, callerLine, escapeQuotes: false));
}
public void CData(string value1, string value2, bool checkHashCode)
{
XCData t1 = new XCData(value1);
XCData t2 = new XCData(value2);
VerifyComparison(checkHashCode, t1, t2);
XElement e2 = new XElement("p2p", t2);
e2.Add(t1);
VerifyComparison(checkHashCode, t1, t2);
}
// adds a cdata element
public XElement AddCD(XElement parEl, string elName, string elValue)
{
XElement newEl = new XElement(elName);
XCData cdEl = new XCData(elValue);
newEl.Add(cdEl);
parEl.Add(newEl);
return(newEl);
}
/// <summary>
/// Copy ctor
/// </summary>
public XCData(XCData source)
: base(source)
{
}
/// <summary>
/// Initializes a new instance of the XCData class from another XCData object.
/// </summary>
/// <param name="other">Text node to copy from</param>
public XCData(XCData other) : base(other) { }
