// Check the properties on an XmlDocumentType node.
private void CheckProperties(String msg, XmlDocumentType type,
String name, String publicId,
String systemId, String internalSubset,
String xml)
{
AssertNull(msg + " [1]", type.Attributes);
AssertEquals(msg + " [2]", String.Empty, type.BaseURI);
AssertNotNull(msg + " [3]", type.ChildNodes);
AssertNull(msg + " [4]", type.FirstChild);
Assert(msg + " [5]", !type.HasChildNodes);
Assert(msg + " [6]", type.IsReadOnly);
AssertEquals(msg + " [7]", name, type.LocalName);
AssertEquals(msg + " [8]", name, type.Name);
AssertEquals(msg + " [9]", publicId, type.PublicId);
AssertEquals(msg + " [10]", systemId, type.SystemId);
AssertEquals(msg + " [11]",
internalSubset, type.InternalSubset);
AssertEquals(msg + " [12]", String.Empty, type.NamespaceURI);
AssertNull(msg + " [13]", type.NextSibling);
AssertEquals(msg + " [14]",
XmlNodeType.DocumentType, type.NodeType);
AssertEquals(msg + " [15]", doc, type.OwnerDocument);
AssertNull(msg + " [16]", type.ParentNode);
AssertEquals(msg + " [17]", String.Empty, type.Prefix);
AssertNull(msg + " [18]", type.PreviousSibling);
AssertEquals(msg + " [19]", String.Empty, type.Value);
AssertEquals(msg + " [20]", String.Empty, type.InnerXml);
AssertEquals(msg + " [21]", xml, type.OuterXml);
}
internal XmlDiffNode LoadNode(XmlNode node, ref int childPosition)
{
switch (node.NodeType)
{
case XmlNodeType.Element:
XmlDiffElement elem = new XmlDiffElement(++childPosition, node.LocalName, node.Prefix, node.NamespaceURI);
LoadChildNodes(elem, node);
elem.ComputeHashValue(_xmlHash);
return(elem);
case XmlNodeType.Attribute:
Debug.Assert(false, "Attributes cannot be loaded by this method.");
return(null);
case XmlNodeType.Text:
string textValue = (_XmlDiff.IgnoreWhitespace) ? XmlDiff.NormalizeText(node.Value) : node.Value;
XmlDiffCharData text = new XmlDiffCharData(++childPosition, textValue, XmlDiffNodeType.Text);
text.ComputeHashValue(_xmlHash);
return(text);
case XmlNodeType.CDATA:
XmlDiffCharData cdata = new XmlDiffCharData(++childPosition, node.Value, XmlDiffNodeType.CDATA);
cdata.ComputeHashValue(_xmlHash);
return(cdata);
case XmlNodeType.EntityReference:
XmlDiffER er = new XmlDiffER(++childPosition, node.Name);
er.ComputeHashValue(_xmlHash);
return(er);
case XmlNodeType.Comment:
++childPosition;
if (_XmlDiff.IgnoreComments)
{
return(null);
}
XmlDiffCharData comment = new XmlDiffCharData(childPosition, node.Value, XmlDiffNodeType.Comment);
comment.ComputeHashValue(_xmlHash);
return(comment);
case XmlNodeType.ProcessingInstruction:
++childPosition;
if (_XmlDiff.IgnorePI)
{
return(null);
}
XmlDiffPI pi = new XmlDiffPI(childPosition, node.Name, node.Value);
pi.ComputeHashValue(_xmlHash);
return(pi);
case XmlNodeType.SignificantWhitespace:
++childPosition;
if (_XmlDiff.IgnoreWhitespace)
{
return(null);
}
XmlDiffCharData ws = new XmlDiffCharData(childPosition, node.Value, XmlDiffNodeType.SignificantWhitespace);
ws.ComputeHashValue(_xmlHash);
return(ws);
case XmlNodeType.XmlDeclaration:
++childPosition;
if (_XmlDiff.IgnoreXmlDecl)
{
return(null);
}
XmlDiffXmlDeclaration xmlDecl = new XmlDiffXmlDeclaration(childPosition, XmlDiff.NormalizeXmlDeclaration(node.Value));
xmlDecl.ComputeHashValue(_xmlHash);
return(xmlDecl);
case XmlNodeType.EndElement:
return(null);
case XmlNodeType.DocumentType:
childPosition++;
if (_XmlDiff.IgnoreDtd)
{
return(null);
}
XmlDocumentType docType = (XmlDocumentType)node;
XmlDiffDocumentType diffDocType = new XmlDiffDocumentType(childPosition, docType.Name, docType.PublicId, docType.SystemId, docType.InternalSubset);
diffDocType.ComputeHashValue(_xmlHash);
return(diffDocType);
default:
Debug.Assert(false);
return(null);
}
}
public XmlDocumentTypeWrapper(XmlDocumentType documentType)
{
Class6.yDnXvgqzyB5jw();
base(documentType);
this._documentType = documentType;
}
/// <summary>
/// Return a string representation for GetShortString that
/// describes the "thing" that has been compared so users know
/// how to locate it.
/// </summary>
/// <remarks>
/// <para>
/// Examples are "<bar ...> at /foo[1]/bar[1]" for a
/// comparison of elements or "<!-- Comment Text --> at
/// /foo[2]/comment()[1]" for a comment.
/// </para>
/// <para>
/// This implementation dispatches to several AppendX methods
/// based on the comparison type or the type of the node.
/// </para>
/// </remarks>
/// <param name="node">the node to describe</param>
/// <param name="xpath">xpath of the node if applicable</param>
/// <param name="type">the comparison type</param>
/// <return>the formatted result</return>
/// since XMLUnit 2.4.0
protected virtual string GetShortString(XmlNode node, string xpath, ComparisonType type)
{
StringBuilder sb = new StringBuilder();
if (type == ComparisonType.HAS_DOCTYPE_DECLARATION)
{
XmlDocument doc = node as XmlDocument;
AppendDocumentType(sb, doc.DocumentType);
AppendDocumentElementIndication(sb, doc);
}
else if (node is XmlDocument)
{
XmlDocument doc = node as XmlDocument;
AppendDocumentXmlDeclaration(sb, doc.FirstChild as XmlDeclaration);
AppendDocumentElementIndication(sb, doc);
}
else if (node is XmlDeclaration)
{
XmlDeclaration dec = node as XmlDeclaration;
AppendDocumentXmlDeclaration(sb, dec);
AppendDocumentElementIndication(sb, dec.OwnerDocument);
}
else if (node is XmlDocumentType)
{
XmlDocumentType docType = node as XmlDocumentType;
AppendDocumentType(sb, docType);
AppendDocumentElementIndication(sb, docType.OwnerDocument);
}
else if (node is XmlAttribute)
{
AppendAttribute(sb, node as XmlAttribute);
}
else if (node is XmlElement)
{
AppendElement(sb, node as XmlElement);
}
else if (node is XmlComment)
{
AppendComment(sb, node as XmlComment);
}
else if (node is XmlCharacterData)
{
AppendText(sb, node as XmlCharacterData);
}
else if (node is XmlProcessingInstruction)
{
AppendProcessingInstruction(sb, node as XmlProcessingInstruction);
}
else if (node == null)
{
sb.Append("<NULL>");
}
else
{
sb.Append("<!--NodeType ").Append(node.NodeType)
.Append(' ').Append(node.Name)
.Append('/').Append(node.Value)
.Append("-->");
}
AppendXPath(sb, xpath);
return(sb.ToString());
}
public XmlDocumentTypeWrapper(XmlDocumentType documentType)
: base((XmlNode)documentType)
{
this._documentType = documentType;
}
private void UpdateSmilFile(string smilFullPath, List <string> smilIDs)
{
XmlDocument smilXmlDoc = CommonFunctions.CreateXmlDocument(smilFullPath);
smilXmlDoc.RemoveChild(smilXmlDoc.DocumentType);
XmlDocumentType type = smilXmlDoc.CreateDocumentType("smil",
"-//W3C//DTD SMIL 1.0//EN",
"http://www.w3.org/TR/REC-smil/SMIL10.dtd",
null);
smilXmlDoc.InsertBefore(type, smilXmlDoc.DocumentElement);
XmlNodeList metaList = smilXmlDoc.GetElementsByTagName("meta");
foreach (XmlNode n in metaList)
{
if (n.Attributes.GetNamedItem("name").Value == "dtb:uid")
{
n.Attributes.GetNamedItem("name").Value = "dc:identifier";
}
if (n.Attributes.GetNamedItem("name").Value.Contains(":totalElapsedTime"))
{
TimeSpan t = CommonFunctions.GetTimeSpan(n.Attributes.GetNamedItem("content").Value);
n.Attributes.GetNamedItem("content").Value = t.ToString();
}
string name = n.Attributes.GetNamedItem("name").Value;
n.Attributes.GetNamedItem("name").Value = name.Replace("dtb:", "ncc:");
}
// add format
XmlNode formatNode = smilXmlDoc.CreateElement(null, "meta", metaList[0].ParentNode.NamespaceURI);
metaList[0].ParentNode.AppendChild(formatNode);
formatNode.Attributes.Append(smilXmlDoc.CreateAttribute("name"));
formatNode.Attributes.Append(smilXmlDoc.CreateAttribute("content"));
formatNode.Attributes.GetNamedItem("name").Value = "dc:format";
formatNode.Attributes.GetNamedItem("content").Value = "Daisy 2.02";
// add layout
XmlNode headNode = smilXmlDoc.GetElementsByTagName("head")[0];
XmlNode layoutNode = smilXmlDoc.CreateElement(null, "layout", headNode.NamespaceURI);
headNode.AppendChild(layoutNode);
XmlNode regionNode = smilXmlDoc.CreateElement(null, "region", headNode.NamespaceURI);
layoutNode.AppendChild(regionNode);
regionNode.Attributes.Append(
smilXmlDoc.CreateAttribute("id"));
regionNode.Attributes.GetNamedItem("id").Value = "textView";
// change audio attributes and find total duration
TimeSpan duration = new TimeSpan(0);
XmlNodeList audioNodeList = smilXmlDoc.GetElementsByTagName("audio");
int audioId = 0;
foreach (XmlNode n in audioNodeList)
{
duration = duration.Add(
CalculateTimeDifference(
n.Attributes.GetNamedItem("clipBegin").Value,
n.Attributes.GetNamedItem("clipEnd").Value));
XmlAttribute beginAtt = smilXmlDoc.CreateAttribute("clip-begin");
beginAtt.Value = n.Attributes.GetNamedItem("clipBegin").Value;
n.Attributes.RemoveNamedItem("clipBegin");
XmlAttribute endAtt = smilXmlDoc.CreateAttribute("clip-end");
endAtt.Value = n.Attributes.GetNamedItem("clipEnd").Value;
n.Attributes.RemoveNamedItem("clipEnd");
n.Attributes.Append(beginAtt);
n.Attributes.Append(endAtt);
n.Attributes.Append(smilXmlDoc.CreateAttribute("id"));
n.Attributes.GetNamedItem("id").Value = "a" + m_DAISY3Info.Identifier + "audio" + audioId;
audioId++;
}
// add dur to seq.
XmlNode seqNode = smilXmlDoc.GetElementsByTagName("body")[0].FirstChild;
if (seqNode.LocalName == "seq")
{
seqNode.Attributes.RemoveNamedItem("fill");
XmlAttribute att = smilXmlDoc.CreateAttribute("dur");
att.Value = duration.ToString();
seqNode.Attributes.Append(att);
}
// add par node, text node and seq around pars
XmlNodeList seqChildList = seqNode.ChildNodes;
MessageBox.Show("SmilID :" + smilIDs.Count.ToString());
for (int i = 0; i < seqChildList.Count; i++)
{
XmlNode parNode = seqChildList[i];
if (parNode.Attributes.GetNamedItem("id") != null &&
smilIDs.Contains(parNode.Attributes.GetNamedItem("id").Value))
{
string strID = parNode.Attributes.GetNamedItem("id").Value;
XmlNode seqParNode = smilXmlDoc.CreateElement(null, "par", seqNode.NamespaceURI);
seqNode.AppendChild(seqParNode);
XmlNode textNode = smilXmlDoc.CreateElement(null, "text", seqNode.NamespaceURI);
seqParNode.AppendChild(textNode);
textNode.Attributes.Append(smilXmlDoc.CreateAttribute("src"));
textNode.Attributes.GetNamedItem("src").Value = "ncc.html#" + m_SmilNccIDMap[strID];
textNode.Attributes.Append(smilXmlDoc.CreateAttribute("id"));
textNode.Attributes.GetNamedItem("id").Value = strID;
XmlNode seqNode_FirstParChild = smilXmlDoc.CreateElement(null, "seq", seqNode.NamespaceURI);
seqParNode.AppendChild(seqNode_FirstParChild);
// copy all pars from primary seq to child seq
for (int j = i; j < seqChildList.Count; j++)
{
//MessageBox.Show ( j.ToString () );
XmlNode n = seqNode.ChildNodes[j];
if (n != null && n.LocalName == "par" &&
n.Attributes.GetNamedItem("id") != null &&
(n.Attributes.GetNamedItem("id").Value == strID ||
!smilIDs.Contains(n.Attributes.GetNamedItem("id").Value)))
{
XmlNode par_internal = n.CloneNode(true);
if (par_internal.LocalName == "par" &&
par_internal.FirstChild.LocalName == "audio")
{
seqNode_FirstParChild.AppendChild(par_internal.FirstChild);
//MessageBox.Show ( n.LocalName );
}
else
{
MessageBox.Show(n.FirstChild.Attributes.GetNamedItem("clip-begin").Value);
break;
}
}
}
}
} //foreach id ends
for (int i = seqNode.ChildNodes.Count - 1; i >= 0; i--)
{
if (seqNode.ChildNodes[i].LocalName == "par" &&
seqNode.ChildNodes[i].FirstChild.LocalName == "audio")
{
seqNode.RemoveChild(seqNode.ChildNodes[i]);
System.Media.SystemSounds.Asterisk.Play();
}
else
{
MessageBox.Show(seqNode.ChildNodes[i].LocalName + " : " + seqNode.ChildNodes[i].FirstChild.LocalName + " : not removed");
}
}
//seqNode.RemoveAll ();
//seqNode.AppendChild ( ParqNodeClone );
// add endsync attribute to par
XmlNodeList parList = smilXmlDoc.GetElementsByTagName("par");
foreach (XmlNode n in parList)
{
if (n.Attributes.GetNamedItem("endsync") == null)
{
n.Attributes.Append(smilXmlDoc.CreateAttribute("endsync"));
n.Attributes.GetNamedItem("endsync").Value = "last";
}
}
CommonFunctions.WriteXmlDocumentToFile(smilXmlDoc, smilFullPath);
smilXmlDoc = null;
RemoveSmilSmlns(smilFullPath);
}
public void GetReady()
{
document = new XmlDocument();
docType = document.CreateDocumentType("book", null, null, "<!ELEMENT book ANY>");
document.AppendChild(docType);
}
// Test adding an XML declaration to the document.
public void TestXmlDocumentAddXmlDeclaration()
{
XmlDocument doc = new XmlDocument();
// Add the declaration.
XmlDeclaration decl =
doc.CreateXmlDeclaration("1.0", null, null);
AssertNull("XmlDeclaration (1)", decl.ParentNode);
AssertEquals("XmlDeclaration (2)", doc, decl.OwnerDocument);
doc.AppendChild(decl);
AssertEquals("XmlDeclaration (3)", doc, decl.ParentNode);
AssertEquals("XmlDeclaration (4)", doc, decl.OwnerDocument);
// Try to add it again, which should fail this time.
try
{
doc.AppendChild(decl);
Fail("adding XmlDeclaration node twice");
}
catch (InvalidOperationException)
{
// Success
}
try
{
doc.PrependChild(decl);
Fail("prepending XmlDeclaration node twice");
}
catch (InvalidOperationException)
{
// Success
}
// Adding a document type before should fail.
XmlDocumentType type =
doc.CreateDocumentType("foo", null, null, null);
try
{
doc.PrependChild(type);
Fail("prepending XmlDocumentType");
}
catch (InvalidOperationException)
{
// Success
}
// Adding a document type after should succeed.
doc.AppendChild(type);
// Adding an element before should fail.
XmlElement element = doc.CreateElement("foo");
try
{
doc.PrependChild(element);
Fail("prepending XmlElement");
}
catch (InvalidOperationException)
{
// Success
}
// Adding the element between decl and type should fail.
try
{
doc.InsertAfter(element, decl);
Fail("inserting XmlElement between XmlDeclaration " +
"and XmlDocumentType");
}
catch (InvalidOperationException)
{
// Success
}
try
{
doc.InsertBefore(element, type);
Fail("inserting XmlElement between XmlDeclaration " +
"and XmlDocumentType (2)");
}
catch (InvalidOperationException)
{
// Success
}
// Adding an element after should succeed.
doc.AppendChild(element);
}
static void ExportX3D()
{
ClearConsole();
try
{
// grab the selected objects
Transform[] trs = Selection.GetTransforms(SelectionMode.TopLevel);
// get a path to save the file
string file = EditorUtility.SaveFilePanel("Save X3D file as", "${HOME}/Desktop", "", "x3d");
outputPath = Path.GetDirectoryName(file);
if (file.Length == 0)
{
// TODO output error
return;
}
xml = new XmlDocument();
defNamesInUse = new List <string>();
XmlNode xmlHeader = xml.CreateXmlDeclaration("1.0", "UTF-8", null);
xml.AppendChild(xmlHeader);
XmlDocumentType docType = xml.CreateDocumentType("X3D", "http://www.web3d.org/specifications/x3d-3.3.dtd", null, null);
xml.AppendChild(docType);
X3DNode = CreateNode("X3D");
xml.AppendChild(X3DNode);
XmlNamespaceManager nms = new XmlNamespaceManager(xml.NameTable);
nms.AddNamespace("slm", "http://www.v-slam.org");
sceneNode = CreateNode("Scene");
X3DNode.AppendChild(sceneNode);
ExportRenderSettings();
XmlNode lhToRh = CreateNode("Transform");
AddXmlAttribute(lhToRh, "scale", "1 1 -1");
sceneNode.AppendChild(lhToRh);
sceneNode = lhToRh;
currentNodeIndex = 0;
numNodesToExport = 0;
// Count number of nodes for progress bar
foreach (Transform tr in trs)
{
numNodesToExport += CountNodes(tr);
}
foreach (Transform tr in trs)
{
sceneNode.AppendChild(TransformToX3D(tr));
}
xml.Save(file);
}
catch (System.Exception e)
{
Debug.LogError(e.ToString());
}
EditorUtility.ClearProgressBar();
}
/**
* Writes the daventure data into the given file.
*
* @param folderName
* Folder where to write the data
* @param adventureData
* Adventure data to write in the file
* @param valid
* True if the adventure is valid (can be executed in the
* engine), false otherwise
* @return True if the operation was succesfully completed, false otherwise
*/
public static bool writeData(string folderName, AdventureDataControl adventureData, bool valid)
{
bool dataSaved = false;
// Create the necessary elements for building the DOM
doc = new XmlDocument();
// Delete the previous XML files in the root of the project dir
//DirectoryInfo projectFolder = new DirectoryInfo(folderName);
//if (projectFolder.Exists)
//{
// foreach (FileInfo file in projectFolder.GetFiles())
// {
// file.Delete();
// }
// foreach (DirectoryInfo dir in projectFolder.GetDirectories())
// {
// dir.Delete(true);
// }
//}
// Add the special asset files
// TODO AssetsController.addSpecialAssets();
/** ******* START WRITING THE DESCRIPTOR ********* */
// Pick the main node for the descriptor
XmlDeclaration declaration = doc.CreateXmlDeclaration("1.0", "UTF-8", "no");
XmlDocumentType typeDescriptor = doc.CreateDocumentType("game-descriptor", "SYSTEM", "descriptor.dtd", null);
doc.AppendChild(declaration);
doc.AppendChild(typeDescriptor);
if (!valid)
{
DOMWriterUtility.DOMWrite(doc, adventureData, new DescriptorDOMWriter.InvalidAdventureDataControlParam());
}
else
{
DOMWriterUtility.DOMWrite(doc, adventureData);
}
doc.Save(folderName + "/descriptor.xml");
/** ******** END WRITING THE DESCRIPTOR ********** */
/** ******* START WRITING THE CHAPTERS ********* */
// Write every chapter
XmlDocumentType typeChapter;
int chapterIndex = 1;
foreach (Chapter chapter in adventureData.getChapters())
{
doc = new XmlDocument();
declaration = doc.CreateXmlDeclaration("1.0", "UTF-8", "no");
typeChapter = doc.CreateDocumentType("eAdventure", "SYSTEM", "eadventure.dtd", null);
doc.AppendChild(declaration);
doc.AppendChild(typeChapter);
DOMWriterUtility.DOMWrite(doc, chapter);
doc.Save(folderName + "/chapter" + chapterIndex++ + ".xml");
}
/** ******** END WRITING THE CHAPTERS ********** */
dataSaved = true;
return(dataSaved);
}
public static bool writeAnimation(string filename, Animation animation)
{
bool dataSaved = false;
XmlDocument doc = doc = new XmlDocument();
XmlDeclaration declaration = doc.CreateXmlDeclaration("1.0", "UTF-8", "no");
XmlDocumentType typeDescriptor = doc.CreateDocumentType("animation", "SYSTEM", "animation.dtd", null);
doc.AppendChild(declaration);
doc.AppendChild(typeDescriptor);
XmlElement mainNode = doc.CreateElement("animation");
//mainNode.AppendChild(doc.createAttribute("id").setNodeValue(animation.getId()));
mainNode.SetAttribute("id", animation.getId());
mainNode.SetAttribute("usetransitions", animation.isUseTransitions() ? "yes" : "no");
mainNode.SetAttribute("slides", animation.isSlides() ? "yes" : "no");
XmlElement documentation = doc.CreateElement("documentation");
if (animation.getDocumentation() != null && animation.getDocumentation().Length > 0)
{
documentation.InnerText = animation.getDocumentation();
}
mainNode.AppendChild(documentation);
foreach (ResourcesUni resources in animation.getResources())
{
XmlNode resourcesNode = ResourcesDOMWriter.buildDOM(resources, ResourcesDOMWriter.RESOURCES_ANIMATION);
doc.ImportNode(resourcesNode, true);
mainNode.AppendChild(resourcesNode);
}
for (int i = 0; i < animation.getFrames().Count; i++)
{
mainNode.AppendChild(createTransitionElement(animation.getTransitions()[i], doc));
mainNode.AppendChild(createFrameElement(animation.getFrames()[i], doc));
}
mainNode.AppendChild(createTransitionElement(animation.getEndTransition(), doc));
doc.ImportNode(mainNode, true);
doc.AppendChild(mainNode);
string name = "Assets/Resources/" + filename;
if (!name.EndsWith(".eaa"))
{
name += ".eaa";
}
doc.Save(name);
//TODO: implementation?
//transformer = tf.newTransformer();
//transformer.setOutputProperty(OutputKeys.DOCTYPE_SYSTEM, "animation.dtd");
//try
//{
// fout = new FileOutputStream(filename);
//}
//catch (FileNotFoundException e)
//{
// fout = new FileOutputStream(Controller.getInstance().getProjectFolder() + "/" + filename);
//}
//writeFile = new OutputStreamWriter(fout, "UTF-8");
//transformer.transform(new DOMSource(doc), new StreamResult(writeFile));
//writeFile.close();
//fout.close();
dataSaved = true;
return(dataSaved);
}
public async Task <object> WriteXmlFile(string fullName, XmlDocument document, XmlDocumentType documentType = null)
{
if (string.IsNullOrWhiteSpace(fullName))
{
throw new ArgumentNullException(nameof(fullName));
}
if (document == null)
{
throw new ArgumentNullException(nameof(document));
}
return(await this.writer.Write(fullName : fullName, document : document, documentType : documentType));
}
/// <summary>
/// Internal method which generates the RDF/Json Output for a Graph
/// </summary>
/// <param name="context">Writer Context</param>
private void GenerateOutput(RdfXmlWriterContext context)
{
context.UseDtd = this._useDTD;
//Create required variables
int nextNamespaceID = 0;
List <String> tempNamespaces = new List <String>();
//Always force RDF Namespace to be correctly defined
context.Graph.NamespaceMap.AddNamespace("rdf", UriFactory.Create(NamespaceMapper.RDF));
//Create an XML Document
XmlDocument doc = new XmlDocument();
XmlDeclaration decl = doc.CreateXmlDeclaration("1.0", "UTF-8", null);
doc.AppendChild(decl);
//Create the DOCTYPE declaration and the rdf:RDF element
StringBuilder entities = new StringBuilder();
XmlElement rdf = doc.CreateElement("rdf:RDF", NamespaceMapper.RDF);
if (context.Graph.BaseUri != null)
{
XmlAttribute baseUri = doc.CreateAttribute("xml:base");
baseUri.Value = Uri.EscapeUriString(context.Graph.BaseUri.ToString());
rdf.Attributes.Append(baseUri);
}
XmlAttribute ns;
String uri;
entities.Append('\n');
foreach (String prefix in context.Graph.NamespaceMap.Prefixes)
{
uri = context.Graph.NamespaceMap.GetNamespaceUri(prefix).ToString();
if (!prefix.Equals(String.Empty))
{
entities.AppendLine("\t<!ENTITY " + prefix + " '" + uri + "'>");
ns = doc.CreateAttribute("xmlns:" + prefix);
ns.Value = Uri.EscapeUriString(uri.Replace("'", "'"));
}
else
{
ns = doc.CreateAttribute("xmlns");
ns.Value = Uri.EscapeUriString(uri);
}
rdf.Attributes.Append(ns);
}
if (context.UseDtd)
{
XmlDocumentType doctype = doc.CreateDocumentType("rdf:RDF", null, null, entities.ToString());
doc.AppendChild(doctype);
}
doc.AppendChild(rdf);
//Find the Collections
if (this._compressionLevel >= WriterCompressionLevel.More)
{
WriterHelper.FindCollections(context);
}
//Find the Type References
Dictionary <INode, String> typerefs = this.FindTypeReferences(context, ref nextNamespaceID, tempNamespaces, doc);
//Get the Triples as a Sorted List
List <Triple> ts = context.Graph.Triples.Where(t => !context.TriplesDone.Contains(t)).ToList();
ts.Sort();
//Variables we need to track our writing
INode lastSubj, lastPred;
lastSubj = lastPred = null;
XmlElement subj, pred;
//Initialise stuff to keep the compiler happy
subj = doc.CreateElement("rdf:Description", NamespaceMapper.RDF);
pred = doc.CreateElement("temp");
for (int i = 0; i < ts.Count; i++)
{
Triple t = ts[i];
if (context.TriplesDone.Contains(t))
{
continue; //Skip if already done
}
if (lastSubj == null || !t.Subject.Equals(lastSubj))
{
//Start a new set of Triples
//Validate Subject
//Use a Type Reference if applicable
if (typerefs.ContainsKey(t.Subject))
{
String tref = typerefs[t.Subject];
String tprefix;
if (tref.StartsWith(":"))
{
tprefix = String.Empty;
}
else if (tref.Contains(":"))
{
tprefix = tref.Substring(0, tref.IndexOf(':'));
}
else
{
tprefix = String.Empty;
}
subj = doc.CreateElement(tref, context.Graph.NamespaceMap.GetNamespaceUri(tprefix).ToString());
}
else
{
subj = doc.CreateElement("rdf:Description", NamespaceMapper.RDF);
}
//Write out the Subject
doc.DocumentElement.AppendChild(subj);
lastSubj = t.Subject;
//Apply appropriate attributes
switch (t.Subject.NodeType)
{
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("RDF/XML"));
case NodeType.Literal:
throw new RdfOutputException(WriterErrorMessages.LiteralSubjectsUnserializable("RDF/XML"));
case NodeType.Blank:
if (context.Collections.ContainsKey(t.Subject))
{
this.GenerateCollectionOutput(context, t.Subject, subj, ref nextNamespaceID, tempNamespaces, doc);
}
else
{
XmlAttribute nodeID = doc.CreateAttribute("rdf:nodeID", NamespaceMapper.RDF);
nodeID.Value = context.BlankNodeMapper.GetOutputID(((IBlankNode)t.Subject).InternalID);
subj.Attributes.Append(nodeID);
}
break;
case NodeType.Uri:
this.GenerateUriOutput(context, (IUriNode)t.Subject, "rdf:about", tempNamespaces, subj, doc);
break;
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("RDF/XML"));
}
//Write the Predicate
pred = this.GeneratePredicateNode(context, t.Predicate, ref nextNamespaceID, tempNamespaces, doc, subj);
subj.AppendChild(pred);
lastPred = t.Predicate;
}
else if (lastPred == null || !t.Predicate.Equals(lastPred))
{
//Write the Predicate
pred = this.GeneratePredicateNode(context, t.Predicate, ref nextNamespaceID, tempNamespaces, doc, subj);
subj.AppendChild(pred);
lastPred = t.Predicate;
}
//Write the Object
//Create an Object for the Object
switch (t.Object.NodeType)
{
case NodeType.Blank:
if (pred.HasChildNodes || pred.HasAttributes)
{
//Require a new Predicate
pred = this.GeneratePredicateNode(context, t.Predicate, ref nextNamespaceID, tempNamespaces, doc, subj);
subj.AppendChild(pred);
}
if (context.Collections.ContainsKey(t.Object))
{
//Output a Collection
this.GenerateCollectionOutput(context, t.Object, pred, ref nextNamespaceID, tempNamespaces, doc);
}
else
{
//Terminate the Blank Node triple by adding a rdf:nodeID attribute
XmlAttribute nodeID = doc.CreateAttribute("rdf:nodeID", NamespaceMapper.RDF);
nodeID.Value = context.BlankNodeMapper.GetOutputID(((IBlankNode)t.Object).InternalID);
pred.Attributes.Append(nodeID);
}
//Force a new Predicate after Blank Nodes
lastPred = null;
break;
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("RDF/XML"));
case NodeType.Literal:
ILiteralNode lit = (ILiteralNode)t.Object;
if (pred.HasChildNodes || pred.HasAttributes)
{
//Require a new Predicate
pred = this.GeneratePredicateNode(context, t.Predicate, ref nextNamespaceID, tempNamespaces, doc, subj);
subj.AppendChild(pred);
}
this.GenerateLiteralOutput(context, lit, pred, doc);
//Force a new Predicate Node after Literals
lastPred = null;
break;
case NodeType.Uri:
this.GenerateUriOutput(context, (IUriNode)t.Object, "rdf:resource", tempNamespaces, pred, doc);
//Force a new Predicate Node after URIs
lastPred = null;
break;
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("RDF/XML"));
}
context.TriplesDone.Add(t);
}
//Check we haven't failed to output any collections
foreach (KeyValuePair <INode, OutputRdfCollection> pair in context.Collections)
{
if (!pair.Value.HasBeenWritten)
{
if (typerefs.ContainsKey(pair.Key))
{
String tref = typerefs[pair.Key];
String tprefix;
if (tref.StartsWith(":"))
{
tref = tref.Substring(1);
tprefix = String.Empty;
}
else if (tref.Contains(":"))
{
tprefix = tref.Substring(0, tref.IndexOf(':'));
}
else
{
tprefix = String.Empty;
}
subj = doc.CreateElement(tref, context.Graph.NamespaceMap.GetNamespaceUri(tprefix).ToString());
doc.DocumentElement.AppendChild(subj);
this.GenerateCollectionOutput(context, pair.Key, subj, ref nextNamespaceID, tempNamespaces, doc);
}
else
{
//Generate an rdf:Description Node with a rdf:nodeID on it
XmlElement colNode = doc.CreateElement("rdf:Description");
XmlAttribute nodeID = doc.CreateAttribute("rdf:nodeID");
nodeID.Value = context.BlankNodeMapper.GetOutputID(((IBlankNode)pair.Key).InternalID);
colNode.Attributes.Append(nodeID);
doc.DocumentElement.AppendChild(colNode);
this.GenerateCollectionOutput(context, pair.Key, colNode, ref nextNamespaceID, tempNamespaces, doc);
//throw new RdfOutputException("Failed to output a Collection due to an unknown error");
}
}
}
//Save to the Output Stream
InternalXmlWriter writer = new InternalXmlWriter();
writer.Save(context.Output, doc);
//Get rid of the Temporary Namespace
foreach (String tempPrefix in tempNamespaces)
{
context.Graph.NamespaceMap.RemoveNamespace(tempPrefix);
}
}
// Test adding an element to the document.
public void TestXmlDocumentAddElement()
{
XmlDocument doc = new XmlDocument();
// Add an element to the document.
XmlElement element = doc.CreateElement("foo");
AssertNull("XmlElement (1)", element.ParentNode);
AssertEquals("XmlElement (2)", doc, element.OwnerDocument);
doc.AppendChild(element);
AssertEquals("XmlElement (3)", doc, element.ParentNode);
AssertEquals("XmlElement (4)", doc, element.OwnerDocument);
// Try to add it again, which should fail this time.
try
{
doc.AppendChild(element);
Fail("adding XmlElement node twice");
}
catch (InvalidOperationException)
{
// Success
}
try
{
doc.PrependChild(element);
Fail("prepending XmlElement node twice");
}
catch (InvalidOperationException)
{
// Success
}
// Adding an XmlDeclaration after should fail.
XmlDeclaration decl =
doc.CreateXmlDeclaration("1.0", null, null);
try
{
doc.AppendChild(decl);
Fail("appending XmlDeclaration after XmlElement");
}
catch (InvalidOperationException)
{
// Success
}
// But adding XmlDeclaration before should succeed.
doc.PrependChild(decl);
// Adding a document type after should fail.
XmlDocumentType type =
doc.CreateDocumentType("foo", null, null, null);
try
{
doc.AppendChild(type);
Fail("appending XmlDocumentType");
}
catch (InvalidOperationException)
{
// Success
}
// Adding a document type before should succeed.
doc.InsertBefore(type, element);
}
// Token: 0x06000FAF RID: 4015 RVA: 0x0000D53E File Offset: 0x0000B73E
public Class178(XmlDocumentType xmlDocumentType_0)
{
Class202.ofdixO4zTbIfy();
base..ctor(xmlDocumentType_0);
this.object_0 = xmlDocumentType_0;
}
/**
* Writes the daventure data into the given file.
*
* @param folderName
* Folder where to write the data
* @param adventureData
* Adventure data to write in the file
* @param valid
* True if the adventure is valid (can be executed in the
* engine), false otherwise
* @return True if the operation was succesfully completed, false otherwise
*/
public static bool writeData(string folderName, AdventureDataControl adventureData, bool valid)
{
bool dataSaved = false;
// Create the necessary elements for building the DOM
doc = new XmlDocument();
// Delete the previous XML files in the root of the project dir
//DirectoryInfo projectFolder = new DirectoryInfo(folderName);
//if (projectFolder.Exists)
//{
// foreach (FileInfo file in projectFolder.GetFiles())
// {
// file.Delete();
// }
// foreach (DirectoryInfo dir in projectFolder.GetDirectories())
// {
// dir.Delete(true);
// }
//}
// Add the special asset files
// TODO AssetsController.addSpecialAssets();
/** ******* START WRITING THE DESCRIPTOR ********* */
// Pick the main node for the descriptor
XmlDeclaration declaration = doc.CreateXmlDeclaration("1.0", "UTF-8", "no");
XmlDocumentType typeDescriptor = doc.CreateDocumentType("game-descriptor", "SYSTEM", "descriptor.dtd", null);
doc.AppendChild(declaration);
doc.AppendChild(typeDescriptor);
if (!valid)
{
DOMWriterUtility.DOMWrite(doc, adventureData, new DescriptorDOMWriter.InvalidAdventureDataControlParam());
}
else
{
DOMWriterUtility.DOMWrite(doc, adventureData);
}
// TODO re-add indentation
//indentDOM(mainNode, 0);
// Create the necessary elements for export the DOM into a XML file
//transformer = tFactory.newTransformer();
//transformer.setOutputProperty(OutputKeys.DOCTYPE_SYSTEM, "descriptor.dtd");
// Create the output buffer, write the DOM and close it
//fout = new FileOutputStream(folderName + "/descriptor.xml");
//writeFile = new OutputStreamWriter(fout, "UTF-8");
//transformer.transform(new DOMSource(doc), new StreamResult(writeFile));
//writeFile.close();
//fout.close();
doc.Save(folderName + "/descriptor.xml");
/** ******** END WRITING THE DESCRIPTOR ********** */
/** ******* START WRITING THE CHAPTERS ********* */
// Write every chapter
XmlDocumentType typeChapter;
int chapterIndex = 1;
foreach (Chapter chapter in adventureData.getChapters())
{
doc = new XmlDocument();
declaration = doc.CreateXmlDeclaration("1.0", "UTF-8", "no");
typeChapter = doc.CreateDocumentType("eAdventure", "SYSTEM", "eadventure.dtd", null);
doc.AppendChild(declaration);
doc.AppendChild(typeChapter);
// Pick the main node of the chapter
// TODO FIX THIS and use normal domwriter
var chapterwriter = new ChapterDOMWriter();
DOMWriterUtility.DOMWrite(doc, chapter);
// TODO re-add indentation
//indentDOM(mainNode, 0);
//TODO: testing
//doc = new XmlDocument();
// Create the necessary elements for export the DOM into a XML file
//transformer = tFactory.newTransformer();
//transformer.setOutputProperty(OutputKeys.DOCTYPE_SYSTEM, "eadventure.dtd");
// Create the output buffer, write the DOM and close it
//fout = new FileOutputStream(folderName + "/chapter" + chapterIndex++ + ".xml");
//writeFile = new OutputStreamWriter(fout, "UTF-8");
//transformer.transform(new DOMSource(doc), new StreamResult(writeFile));
//writeFile.close();
//fout.close();
doc.Save(folderName + "/chapter" + chapterIndex++ + ".xml");
}
/** ******** END WRITING THE CHAPTERS ********** */
// Update the zip files
//File.umount( );
dataSaved = true;
return(dataSaved);
}
} // SetOutput(java.io.Writer)
/** Writes the specified node, recursively. */
public void Write(XmlNode node)
{
// is there anything to do?
if (node == null)
{
return;
}
XmlNodeType type = node.NodeType;
switch (type)
{
case XmlNodeType.Document: {
XmlDocument document = (XmlDocument)node;
fXML11 = false; //"1.1".Equals(GetVersion(document));
if (!fCanonical)
{
if (fXML11)
{
fOut.WriteLine("<?xml version=\"1.1\" encoding=\"UTF-8\"?>");
}
else
{
fOut.WriteLine("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
}
fOut.Flush();
Write(document.DocumentType);
}
Write(document.DocumentElement);
break;
}
case XmlNodeType.DocumentType: {
XmlDocumentType doctype = (XmlDocumentType)node;
fOut.Write("<!DOCTYPE ");
fOut.Write(doctype.Name);
String publicId = doctype.PublicId;
String systemId = doctype.SystemId;
if (publicId != null)
{
fOut.Write(" PUBLIC '");
fOut.Write(publicId);
fOut.Write("' '");
fOut.Write(systemId);
fOut.Write('\'');
}
else if (systemId != null)
{
fOut.Write(" SYSTEM '");
fOut.Write(systemId);
fOut.Write('\'');
}
String internalSubset = doctype.InternalSubset;
if (internalSubset != null)
{
fOut.WriteLine(" [");
fOut.Write(internalSubset);
fOut.Write(']');
}
fOut.WriteLine('>');
break;
}
case XmlNodeType.Element: {
fOut.Write('<');
fOut.Write(node.Name);
XmlAttribute[] attrs = SortAttributes(node.Attributes);
for (int i = 0; i < attrs.Length; i++)
{
XmlAttribute attr = attrs[i];
fOut.Write(' ');
fOut.Write(attr.Name);
fOut.Write("=\"");
NormalizeAndPrint(attr.Value, true);
fOut.Write('"');
}
fOut.Write('>');
fOut.Flush();
XmlNode child = node.FirstChild;
while (child != null)
{
Write(child);
child = child.NextSibling;
}
break;
}
case XmlNodeType.EntityReference: {
if (fCanonical)
{
XmlNode child = node.FirstChild;
while (child != null)
{
Write(child);
child = child.NextSibling;
}
}
else
{
fOut.Write('&');
fOut.Write(node.Name);
fOut.Write(';');
fOut.Flush();
}
break;
}
case XmlNodeType.CDATA: {
if (fCanonical)
{
NormalizeAndPrint(node.Value, false);
}
else
{
fOut.Write("<![CDATA[");
fOut.Write(node.Value);
fOut.Write("]]>");
}
fOut.Flush();
break;
}
case XmlNodeType.SignificantWhitespace:
case XmlNodeType.Whitespace:
case XmlNodeType.Text: {
NormalizeAndPrint(node.Value, false);
fOut.Flush();
break;
}
case XmlNodeType.ProcessingInstruction: {
fOut.Write("<?");
fOut.Write(node.Name);
String data = node.Value;
if (data != null && data.Length > 0)
{
fOut.Write(' ');
fOut.Write(data);
}
fOut.Write("?>");
fOut.Flush();
break;
}
case XmlNodeType.Comment: {
if (!fCanonical)
{
fOut.Write("<!--");
String comment = node.Value;
if (comment != null && comment.Length > 0)
{
fOut.Write(comment);
}
fOut.Write("-->");
fOut.Flush();
}
break;
}
}
if (type == XmlNodeType.Element)
{
fOut.Write("</");
fOut.Write(node.Name);
fOut.Write('>');
fOut.Flush();
}
} // Write(Node)