public void ReadXml(System.Xml.XmlReader reader)
{
reader.ReadStartElement("PathRule");
reader.ReadStartElement();
this.Disabled = reader.ReadContentAsBoolean();
reader.ReadEndElement();
reader.ReadStartElement();
this.Path = reader.ReadContentAsString();
reader.ReadEndElement();
}
private bool DeterminVisible(System.Xml.XmlReader reader)
{
bool result = true;
if (reader.MoveToAttribute("visible"))
{
if (reader.HasValue)
{
result = reader.ReadContentAsBoolean();
}
}
return(result);
}
public override bool ReadContentAsBoolean()
{
CheckAsync();
return(_coreReader.ReadContentAsBoolean());
}
public void Load(XmlReader x)
{
while (x.Read())
{
switch (x.LocalName)
{
case "BracketHightlighting":
if (x.MoveToAttribute("value"))
EnableMatchingBracketHighlighting = x.ReadContentAsBoolean();
break;
case "UseMethodInsight":
if (x.MoveToAttribute("value"))
UseMethodInsight = x.ReadContentAsBoolean();
break;
case "UseCodeCompletion":
if (x.MoveToAttribute("value"))
UseCodeCompletion = x.ReadContentAsBoolean();
break;
case "ForceCodeCompetionPopupCommit":
if (x.MoveToAttribute("value"))
ForceCodeCompetionPopupCommit = x.ReadContentAsBoolean();
break;
case "UseSemanticErrorHighlighting":
if (x.MoveToAttribute("value"))
UseSemanticErrorHighlighting = x.ReadContentAsBoolean();
break;
case "UseSemanticHighlighting":
if (x.MoveToAttribute("value"))
UseSemanticHighlighting = x.ReadContentAsBoolean();
break;
case "SmartIndentation":
if (x.MoveToAttribute("value"))
EnableSmartIndentation = x.ReadContentAsBoolean();
break;
case "CompletionOptions":
CompletionOptions.Instance.Load(x.ReadSubtree());
break;
case "cv2pdb":
cv2pdb_exe = x.ReadString();
break;
case "dmd":
var config = new DMDConfig();
config.Load(x);
if (config.Version == DVersion.D1)
dmd1 = config;
else
dmd2 = config;
break;
}
}
}
/// <summary>
/// This method is a custom deserialization with an <see cref="XmlSerializer"/>
/// to read the contents of the <see cref="SlideshowTreeNode"/> that
/// are exposed in this override.
/// It deserializes recursively.
/// </summary>
/// <param name="reader">The <see cref="XmlReader"/> to use.</param>
/// <param name="node">The <see cref="SlideshowTreeNode"/> to deserialize.</param>
public override void DeserializeNode(XmlReader reader, SlideshowTreeNode node)
{
var slideSerializer = new XmlSerializer(typeof(Slide));
var dictionarySerializer = new XmlSerializer(typeof(XMLSerializableDictionary<string, int>));
var browserTreeNode = node as BrowserTreeNode;
reader.ReadStartElement("BrowserTreeNode");
reader.ReadStartElement("Name");
browserTreeNode.Name = reader.ReadString();
reader.ReadEndElement();
if (reader.Name == "XMLSerializableDictionaryOfStringInt32")
{
browserTreeNode.UrlToID = (XMLSerializableDictionary<string, int>)dictionarySerializer.Deserialize(reader);
}
reader.ReadStartElement("OriginURL");
browserTreeNode.OriginURL = reader.ReadString();
reader.ReadEndElement();
reader.ReadStartElement("Category");
browserTreeNode.Category = reader.ReadString();
reader.ReadEndElement();
reader.ReadStartElement("BrowseDepth");
browserTreeNode.BrowseDepth = reader.ReadContentAsInt();
reader.ReadEndElement();
reader.ReadStartElement("Randomize");
browserTreeNode.Randomize = reader.ReadContentAsBoolean();
reader.ReadEndElement();
reader.ReadStartElement("NumberOfItemsToUse");
browserTreeNode.NumberOfItemsToUse = reader.ReadContentAsInt();
reader.ReadEndElement();
if (reader.Name == "Slide")
{
browserTreeNode.Slide = (Slide)slideSerializer.Deserialize(reader);
}
reader.ReadStartElement("Tag");
if (reader.Value != string.Empty)
{
browserTreeNode.Tag = reader.ReadContentAsString();
reader.ReadEndElement();
}
reader.ReadStartElement("Text");
node.Text = reader.ReadContentAsString();
reader.ReadEndElement();
while (reader.Name == "SlideshowTreeNode" && reader.NodeType == XmlNodeType.Element)
{
SlideshowTreeNode newNode = new SlideshowTreeNode();
base.DeserializeNode(reader, newNode);
this.SetTreeNodeImageKey(newNode);
node.Nodes.Add(newNode);
}
reader.ReadEndElement();
reader.MoveToContent();
}
/// <summary>
/// Metodo che legge il sistema solare da XML
/// </summary>
/// <param name="xr">Lettore XML</param>
/// <returns>Istanza del SistemaSolare</returns>
static SolarSystem ReadSystem(XmlReader xr)
{
List<Planet> planets = new List<Planet>();
Planet actualPlanet = null;
//Attributi del sistema
string name = "", starType = "";
bool discovered = false, inhabited = false;
Vector3 position = new Vector3();
while(xr.MoveToNextAttribute())
{
switch(xr.Name)
{//NAME="Mestu" POSITION="{X:-64 Y:0 Z:-32}" TYPE="Red" DISCOVERED="True" INHABITED="True"
case "NAME":
name = xr.Value;
break;
case "POSITION":
position = NewVector3FromString(xr.Value);
break;
case "TYPE":
starType = xr.Value;
break;
case "DISCOVERED":
discovered = xr.ReadContentAsBoolean();
break;
case "INHABITED":
inhabited = xr.ReadContentAsBoolean();
break;
}
}
while (xr.Read() && !(xr.Name == "SYSTEM" && xr.NodeType == XmlNodeType.EndElement))
{
if (xr.NodeType == XmlNodeType.EndElement)
continue;
switch (xr.Name)
{
case "PLANET":
actualPlanet = ReadPlanet(xr, position);
planets.Add(actualPlanet);
break;
case "SETTLEMENT":
actualPlanet.CreateSettlement(ReadSettlement(xr));
break;
case "PRODUCTS":
actualPlanet.PlanetSettlement.SetProducts(ReadProducts(xr));
break;
}
}
SolarSystem ss = new SolarSystem(name, position, starType, discovered, inhabited, planets);
return ss;
}
/// <summary>
/// Metodo che legge il pianeta da XML
/// </summary>
/// <param name="xr">Istanza XML reader</param>
/// <param name="StarPosition">Posizione della stella cui si riferisce</param>
/// <returns></returns>
static Planet ReadPlanet(XmlReader xr, Vector3 StarPosition)
{
//PLANET NAME="Ghipisu" POSITION="{X:173,6179 Y:0 Z:366,2257}" TYPE="Gas6" HABITABLE="False" TERRASCORE="0" RESOURCES="2504679350"
string name = "", type = "";
bool habitable = false;
int terrascore = 0;
uint resources = 0;
Vector3 position = new Vector3();
while (xr.MoveToNextAttribute())
{
switch(xr.Name)
{
case "NAME":
name = xr.Value;
break;
case "POSITION":
position = NewVector3FromString(xr.Value);
break;
case "TYPE":
type = xr.Value;
break;
case "HABITABLE":
habitable = xr.ReadContentAsBoolean();
break;
case "TERRASCORE":
terrascore = xr.ReadContentAsInt();
break;
case "RESOURCES":
resources = Convert.ToUInt32(xr.Value);
break;
}
}
return new Planet(name, position, StarPosition, type, habitable, terrascore, resources);
}
public static Computer load(XmlReader reader, OS os)
{
while (reader.Name != "computer")
reader.Read();
reader.MoveToAttribute("name");
var compName = reader.ReadContentAsString();
reader.MoveToAttribute("ip");
var compIP = reader.ReadContentAsString();
reader.MoveToAttribute("type");
var compType = (byte) reader.ReadContentAsInt();
reader.MoveToAttribute("spec");
var str1 = reader.ReadContentAsString();
reader.MoveToAttribute("id");
var str2 = reader.ReadContentAsString();
string str3 = null;
if (reader.MoveToAttribute("devices"))
str3 = reader.ReadContentAsString();
string str4 = null;
if (reader.MoveToAttribute("icon"))
str4 = reader.ReadContentAsString();
while (reader.Name != "location")
reader.Read();
reader.MoveToAttribute("x");
var x = reader.ReadContentAsFloat();
reader.MoveToAttribute("y");
var y = reader.ReadContentAsFloat();
while (reader.Name != "security")
reader.Read();
reader.MoveToAttribute("level");
var seclevel = reader.ReadContentAsInt();
reader.MoveToAttribute("traceTime");
var num1 = reader.ReadContentAsFloat();
reader.MoveToAttribute("portsToCrack");
var num2 = reader.ReadContentAsInt();
reader.MoveToAttribute("adminIP");
var str5 = reader.ReadContentAsString();
var time = -1f;
if (reader.MoveToAttribute("proxyTime"))
time = reader.ReadContentAsFloat();
while (reader.Name != "admin")
reader.Read();
reader.MoveToAttribute("type");
var str6 = reader.ReadContentAsString();
reader.MoveToAttribute("resetPass");
var flag1 = reader.ReadContentAsBoolean();
reader.MoveToAttribute("isSuper");
var flag2 = reader.ReadContentAsBoolean();
Administrator administrator = null;
switch (str6)
{
case "fast":
administrator = new FastBasicAdministrator();
break;
case "basic":
administrator = new BasicAdministrator();
break;
}
if (administrator != null)
administrator.ResetsPassword = flag1;
if (administrator != null)
administrator.IsSuper = flag2;
while (reader.Name != "links")
reader.Read();
var strArray = reader.ReadElementContentAsString().Split();
Firewall firewall = null;
while (reader.Name != "portsOpen" && reader.Name != "firewall")
reader.Read();
if (reader.Name == "firewall")
firewall = Firewall.load(reader);
while (reader.Name != "portsOpen")
reader.Read();
var portsList = reader.ReadElementContentAsString();
var computer = new Computer(compName, compIP, new Vector2(x, y), seclevel, compType, os);
computer.firewall = firewall;
computer.admin = administrator;
if (time > 0.0)
{
computer.addProxy(time);
}
else
{
computer.hasProxy = false;
computer.proxyActive = false;
}
while (reader.Name != "users")
reader.Read();
computer.users.Clear();
while (!(reader.Name == "users") || reader.NodeType != XmlNodeType.EndElement)
{
if (reader.Name == "user")
{
var userDetail = UserDetail.loadUserDetail(reader);
if (userDetail.name.ToLower() == "admin")
computer.adminPass = userDetail.pass;
computer.users.Add(userDetail);
}
reader.Read();
}
while (reader.Name != "daemons")
reader.Read();
reader.Read();
while (!(reader.Name == "daemons") || reader.NodeType != XmlNodeType.EndElement)
{
if (reader.Name == "MailServer")
{
reader.MoveToAttribute("name");
var name = reader.ReadContentAsString();
var mailServer = new MailServer(computer, name, os);
computer.daemons.Add(mailServer);
if (reader.MoveToAttribute("color"))
{
var newThemeColor = Utils.convertStringToColor(reader.ReadContentAsString());
mailServer.setThemeColor(newThemeColor);
}
}
else if (reader.Name == "MissionListingServer")
{
reader.MoveToAttribute("name");
var serviceName = reader.ReadContentAsString();
reader.MoveToAttribute("group");
var group = reader.ReadContentAsString();
reader.MoveToAttribute("public");
var _isPublic = reader.ReadContentAsString().ToLower().Equals("true");
reader.MoveToAttribute("assign");
var _isAssigner = reader.ReadContentAsString().ToLower().Equals("true");
var missionListingServer = new MissionListingServer(computer, serviceName, group, os, _isPublic,
_isAssigner);
computer.daemons.Add(missionListingServer);
}
else if (reader.Name == "AddEmailServer")
{
reader.MoveToAttribute("name");
var serviceName = reader.ReadContentAsString();
var addEmailDaemon = new AddEmailDaemon(computer, serviceName, os);
computer.daemons.Add(addEmailDaemon);
}
else if (reader.Name == "MessageBoard")
{
reader.MoveToAttribute("name");
var str7 = reader.ReadContentAsString();
var messageBoardDaemon = new MessageBoardDaemon(computer, os);
messageBoardDaemon.name = str7;
computer.daemons.Add(messageBoardDaemon);
}
else if (reader.Name == "WebServer")
{
reader.MoveToAttribute("name");
var serviceName = reader.ReadContentAsString();
reader.MoveToAttribute("url");
var pageFileLocation = reader.ReadContentAsString();
var webServerDaemon = new WebServerDaemon(computer, serviceName, os, pageFileLocation);
computer.daemons.Add(webServerDaemon);
}
else if (reader.Name == "OnlineWebServer")
{
reader.MoveToAttribute("name");
var serviceName = reader.ReadContentAsString();
reader.MoveToAttribute("url");
var url = reader.ReadContentAsString();
var onlineWebServerDaemon = new OnlineWebServerDaemon(computer, serviceName, os);
onlineWebServerDaemon.setURL(url);
computer.daemons.Add(onlineWebServerDaemon);
}
else if (reader.Name == "AcademicDatabse")
{
reader.MoveToAttribute("name");
var serviceName = reader.ReadContentAsString();
var academicDatabaseDaemon = new AcademicDatabaseDaemon(computer, serviceName, os);
computer.daemons.Add(academicDatabaseDaemon);
}
else if (reader.Name == "MissionHubServer")
{
var missionHubServer = new MissionHubServer(computer, "unknown", "unknown", os);
computer.daemons.Add(missionHubServer);
}
else if (reader.Name == "DeathRowDatabase")
{
var rowDatabaseDaemon = new DeathRowDatabaseDaemon(computer, "Death Row Database", os);
computer.daemons.Add(rowDatabaseDaemon);
}
else if (reader.Name == "MedicalDatabase")
{
var medicalDatabaseDaemon = new MedicalDatabaseDaemon(computer, os);
computer.daemons.Add(medicalDatabaseDaemon);
}
else if (reader.Name == "HeartMonitor")
{
var str7 = "UNKNOWN";
if (reader.MoveToAttribute("patient"))
str7 = reader.ReadContentAsString();
computer.daemons.Add(new HeartMonitorDaemon(computer, os)
{
PatientID = str7
});
}
else if (reader.Name.Equals("PointClicker"))
{
var pointClickerDaemon = new PointClickerDaemon(computer, "Point Clicker!", os);
computer.daemons.Add(pointClickerDaemon);
}
else if (reader.Name.Equals("ispSystem"))
{
var ispDaemon = new ISPDaemon(computer, os);
computer.daemons.Add(ispDaemon);
}
else if (reader.Name.Equals("porthackheart"))
{
var porthackHeartDaemon = new PorthackHeartDaemon(computer, os);
computer.daemons.Add(porthackHeartDaemon);
}
else if (reader.Name.Equals("SongChangerDaemon"))
{
var songChangerDaemon = new SongChangerDaemon(computer, os);
computer.daemons.Add(songChangerDaemon);
}
else if (reader.Name == "UploadServerDaemon")
{
string str7;
var input = str7 = "";
var foldername = str7;
var serviceName = str7;
if (reader.MoveToAttribute("name"))
serviceName = reader.ReadContentAsString();
if (reader.MoveToAttribute("foldername"))
foldername = reader.ReadContentAsString();
if (reader.MoveToAttribute("color"))
input = reader.ReadContentAsString();
var needsAuthentication = false;
if (reader.MoveToAttribute("needsAuh"))
needsAuthentication = reader.ReadContentAsBoolean();
var themeColor = Color.White;
if (input != "")
themeColor = Utils.convertStringToColor(input);
var uploadServerDaemon = new UploadServerDaemon(computer, serviceName, themeColor, os, foldername,
needsAuthentication);
computer.daemons.Add(uploadServerDaemon);
}
reader.Read();
}
computer.files = FileSystem.load(reader);
computer.traceTime = num1;
computer.portsNeededForCrack = num2;
computer.adminIP = str5;
computer.idName = str2;
computer.icon = str4;
computer.attatchedDeviceIDs = str3;
for (var index = 0; index < strArray.Length; ++index)
{
if (strArray[index] != "")
computer.links.Add(Convert.ToInt32(strArray[index]));
}
if (portsList.Length > 0)
ComputerLoader.loadPortsIntoComputer(portsList, computer);
if (str1 == "mail")
os.netMap.mailServer = computer;
else if (str1 == "player")
os.thisComputer = computer;
return computer;
}
/// <summary>
/// This method is a custom deserialization with an <see cref="XmlSerializer"/>
/// to read the contents of the <see cref="SlideshowTreeNode"/> that
/// are exposed in this override.
/// It deserializes recursively.
/// </summary>
/// <param name="reader">The <see cref="XmlReader"/> to use.</param>
/// <param name="node">The <see cref="SlideshowTreeNode"/> to deserialize.</param>
public virtual void DeserializeNode(XmlReader reader, SlideshowTreeNode node)
{
var slideSerializer = new XmlSerializer(typeof(Slide));
// Check for older versions of Ogama 1.X
if (reader.Name == "Slides")
{
// A List<Slide> instead of SlideshowTreeNodes
// in the slideshow node
reader.ReadStartElement("Slides");
this.ParseOgamaV1Slideshow(reader, slideSerializer);
reader.ReadEndElement();
}
else if (reader.Name == "Slide")
{
// Directly the slides in the slideshow node
this.ParseOgamaV1Slideshow(reader, slideSerializer);
}
else
{
// Ogama V2 format
reader.ReadStartElement("SlideshowTreeNode");
reader.ReadStartElement("Name");
node.Name = reader.ReadString();
reader.ReadEndElement();
reader.ReadStartElement("Randomize");
node.Randomize = reader.ReadContentAsBoolean();
reader.ReadEndElement();
reader.ReadStartElement("NumberOfItemsToUse");
node.NumberOfItemsToUse = reader.ReadContentAsInt();
reader.ReadEndElement();
if (reader.Name == "Slide")
{
node.Slide = (Slide)slideSerializer.Deserialize(reader);
}
reader.ReadStartElement("Tag");
if (reader.Value != string.Empty)
{
node.Tag = reader.ReadContentAsString();
reader.ReadEndElement();
}
reader.ReadStartElement("Text");
node.Text = reader.ReadContentAsString();
reader.ReadEndElement();
while ((reader.Name == "SlideshowTreeNode" && reader.NodeType == XmlNodeType.Element) ||
(reader.Name == "BrowserTreeNode" && reader.NodeType == XmlNodeType.Element))
{
if (reader.Name == "SlideshowTreeNode")
{
var newNode = new SlideshowTreeNode();
newNode.DeserializeNode(reader, newNode);
this.SetTreeNodeImageKey(newNode);
node.Nodes.Add(newNode);
}
else if (reader.Name == "BrowserTreeNode")
{
var newNode = new BrowserTreeNode();
newNode.DeserializeNode(reader, newNode);
this.SetTreeNodeImageKey(newNode);
node.Nodes.Add(newNode);
}
}
reader.ReadEndElement();
reader.MoveToContent();
}
}
void PolicyProperties(XmlReader reader)
{
reader.Read();
//Set the Security Assertion XML attributes onto the binding properties
while (reader.MoveToNextAttribute())
{
if (reader.Name == "establishSecurityContext")
EstablishSecurityContext = reader.ReadContentAsBoolean();
if (reader.Name == "requireSignatureConfirmation")
RequireSignatureConfirmation = reader.ReadContentAsBoolean();
if (reader.Name == "requireDerivedKeys")
RequireDerivedKeys = reader.ReadContentAsBoolean();
if (reader.Name == "messageProtectionOrder")
{
String protectionOrder = reader.Value;
switch (protectionOrder)
{
case "SignBeforeEncrypt":
MessageProtectionOrder = MessageProtectionOrder.SignBeforeEncrypt;
break;
case "EncryptBeforeSign":
MessageProtectionOrder = MessageProtectionOrder.EncryptBeforeSign;
break;
case "SignBeforeEncryptAndEncryptSignature":
MessageProtectionOrder = MessageProtectionOrder.SignBeforeEncryptAndEncryptSignature;
break;
}
}
}
}
/// <summary>
/// Generates an object from its XML representation.
/// </summary>
/// <param name="reader">The <see cref="T:System.Xml.XmlReader"></see> stream from which the object is deserialized.</param>
/// <remarks>Documented by Dev05, 2007-08-08</remarks>
public void ReadXml(XmlReader reader)
{
bool wasEmpty = reader.IsEmptyElement;
reader.Read();
if (wasEmpty)
{
return;
}
while (reader.NodeType != XmlNodeType.EndElement)
{
switch (reader.Name)
{
case "ForeColor":
reader.ReadStartElement("ForeColor");
ForeColor = (Color)GetValue(typeof(Color), reader.ReadContentAsString());
reader.ReadEndElement();
break;
case "BackColor":
reader.ReadStartElement("BackColor");
BackColor = (Color)GetValue(typeof(Color), reader.ReadContentAsString());
reader.ReadEndElement();
break;
case "Font":
reader.ReadStartElement("Font");
Font = (Font)GetValue(typeof(Font), reader.ReadContentAsString());
reader.ReadEndElement();
break;
default:
string propertyname = reader.Name;
string typestring = reader.GetAttribute("Type");
reader.ReadStartElement(propertyname);
if (!string.IsNullOrEmpty(typestring))
{
object value = null;
try
{
if (typestring == "Font")
{
string valuestring = reader.ReadContentAsString();
value = (Font)GetValue(typeof(Font), valuestring);
}
else if (typestring == "Color")
{
string valuestring = reader.ReadContentAsString();
value = (Color)GetValue(typeof(Color), valuestring);
}
else if (typestring == "Gradient")
{
XmlSerializer gradientSerializer = new XmlSerializer(typeof(PanelGradient));
value = (PanelGradient)gradientSerializer.Deserialize(reader);
}
else if (typestring == "BorderStyle")
{
try
{
value = Enum.Parse(typeof(BorderStyle), reader.ReadContentAsString());
}
catch (Exception e) { Trace.WriteLine(e.ToString()); }
}
else if (typestring == "String")
{
value = reader.ReadContentAsString();
}
else if (typestring == "Boolean")
{
value = reader.ReadContentAsBoolean();
}
else if (typestring == "SpecialSymbols")
{
try
{
value = Enum.Parse(typeof(MLifter.Components.GlassButton.SpecialSymbols), reader.ReadContentAsString());
}
catch (Exception e) { Trace.WriteLine(e.ToString()); }
}
else if (typestring == "Image")
{
try
{
string filePath = Path.Combine(Directory.GetCurrentDirectory(), reader.ReadContentAsString());
value = Image.FromFile(filePath) as Image;
}
catch (Exception e) { Trace.WriteLine(e.ToString()); }
}
else if (typestring == "ImageLayout")
{
try
{
value = Enum.Parse(typeof(ImageLayout), reader.ReadContentAsString());
}
catch (Exception e) { Trace.WriteLine(e.ToString()); }
}
}
catch
{
}
if (value != null)
CustomProperties.Add(propertyname, value);
}
reader.ReadEndElement();
break;
}
}
reader.ReadEndElement();
}
/// <summary>
/// This method is a custom deserialization with an <see cref="XmlSerializer"/>
/// to read the contents of the <see cref="Slideshow"/> that
/// are exposed in this override. It deserializes recursively.
/// </summary>
/// <param name="reader">The <see cref="XmlReader"/> to use.</param>
/// <param name="node">The <see cref="SlideshowTreeNode"/> to deserialize.</param>
public override void DeserializeNode(XmlReader reader, SlideshowTreeNode node)
{
var shuffleSerializer = new XmlSerializer(typeof(CustomShuffling));
// Check for Versions < Ogama 4.3
if (reader.Name == "SlideshowTreeNode")
{
base.DeserializeNode(reader, node);
return;
}
reader.ReadStartElement("IsModified");
this.IsModified = reader.ReadContentAsBoolean();
reader.ReadEndElement();
if (reader.Name == "CustomShuffling")
{
this.shuffling = (CustomShuffling)shuffleSerializer.Deserialize(reader);
}
while ((reader.Name == "SlideshowTreeNode" && reader.NodeType == XmlNodeType.Element) ||
(reader.Name == "BrowserTreeNode" && reader.NodeType == XmlNodeType.Element))
{
if (reader.Name == "SlideshowTreeNode")
{
var newNode = new SlideshowTreeNode();
newNode.DeserializeNode(reader, newNode);
this.SetTreeNodeImageKey(newNode);
node.Nodes.Add(newNode);
}
else if (reader.Name == "BrowserTreeNode")
{
var newNode = new BrowserTreeNode();
newNode.DeserializeNode(reader, newNode);
this.SetTreeNodeImageKey(newNode);
node.Nodes.Add(newNode);
}
}
}
public virtual void ReadXml(System.Xml.XmlReader reader)
{
if (reader.ReadToDescendant("LotsOfData") == false)
{
throw new Exception("could not find the start of element LotsOfData");
}
if (reader.ReadToDescendant("Boolean") == false)
{
throw new Exception("could not find the start of element Boolean");
}
reader.Read();
if (reader.ReadContentAsBoolean() == false)
{
throw new Exception("did not find the correct value in Boolean");
}
//DateTime
if (reader.ReadToNextSibling("DateTime") == false)
{
throw new Exception("could not find the start of element DateTime");
}
reader.Read();
DateTime now = reader.ReadContentAsDateTime();
if (now != Now)
{
TimeSpan diff = new TimeSpan((now.Ticks - Now.Ticks));
if (diff.TotalMilliseconds > 1000)
{
// seconds are lost in Xml
throw new Exception(String.Format("Dates differ {0} {1} Ticks {2}", now, Now, (now.Ticks - Now.Ticks)));
}
}
//DecimalValue
if (reader.ReadToNextSibling("DecimalValue") == false)
{
throw new Exception("could not find the start of element DecimalValue");
}
// reader.Read();
decimal decimalValue = (decimal)reader.ReadElementContentAs(typeof(decimal), null);
if (decimalValue != CommonUtilities.DecimalValue)
{
string msg = String.Format("different decimal Values {0} {1}", decimalValue, CommonUtilities.DecimalValue);
throw new Exception(msg);
}
//DoubleValue
if (reader.NodeType != System.Xml.XmlNodeType.Element && reader.Name != "DoubleValue")
{
if (reader.ReadToNextSibling("DoubleValue") == false)
{
throw new Exception("could not find the start of element DoubleValue");
}
}
//reader.Read();
double doubleValue = (double)reader.ReadElementContentAsDouble();
if (doubleValue != CommonUtilities.DoubleValue)
{
string msg = String.Format("different double Values {0} {1}", doubleValue, CommonUtilities.DoubleValue);
throw new Exception(msg);
}
//FloatValue
if (reader.NodeType != System.Xml.XmlNodeType.Element && reader.Name != "FloatValue")
{
if (reader.ReadToNextSibling("FloatValue") == false)
{
throw new Exception("could not find the start of element FloatValue");
}
}
//reader.Read();
float floatValue = (float)reader.ReadElementContentAs(typeof(float), null);
if (floatValue != CommonUtilities.FloatValue)
{
string msg = String.Format("different floatValue Values {0} {1}", floatValue, CommonUtilities.FloatValue);
throw new MyException(msg);
}
//IntValue
if (reader.NodeType != System.Xml.XmlNodeType.Element && reader.Name != "IntValue")
{
if (reader.ReadToNextSibling("IntValue") == false)
{
throw new Exception("could not find the start of element IntValue");
}
}
// reader.Read();
int intValue = reader.ReadElementContentAsInt();
if (intValue != CommonUtilities.IntValue)
{
string msg = String.Format("different intValue Values {0} {1}", intValue, CommonUtilities.IntValue);
throw new MyException(msg);
}
//LongValue
if (reader.NodeType != System.Xml.XmlNodeType.Element && reader.Name != "LongValue")
{
if (reader.ReadToNextSibling("LongValue") == false)
{
throw new Exception("could not find the start of element LongValue");
}
}
//reader.Read();
long longValue = (long)reader.ReadElementContentAs(typeof(long), null);
if (longValue != CommonUtilities.LongValue)
{
string msg = String.Format("different longValue Values {0} {1}", longValue, CommonUtilities.LongValue);
throw new MyException(msg);
}
//Object
if (reader.NodeType != System.Xml.XmlNodeType.Element && reader.Name != "Object")
{
if (reader.ReadToNextSibling("Object") == false)
{
throw new MyException("could not find the start of element Object");
}
}
//reader.Read();
TimeSpan objectValue = (TimeSpan)reader.ReadElementContentAs(typeof(TimeSpan), null);
if (objectValue != CommonUtilities.TimeSpanValue)
{
string msg = String.Format("different objectValue Values {0} {1}", objectValue, CommonUtilities.TimeSpanValue);
throw new MyException(msg);
}
//StringValue
if (reader.NodeType != System.Xml.XmlNodeType.Element && reader.Name != "StringValue")
{
if (reader.ReadToNextSibling("StringValue") == false)
{
throw new MyException("could not find the start of element StringValue");
}
}
//reader.Read();
string stringValue = reader.ReadElementContentAsString();
if (stringValue == null || stringValue.Equals(CommonUtilities.XmlStringForAttributes) == false)
{
string msg = String.Format("different stringValue Values {0} {1}", stringValue, CommonUtilities.XmlStringForAttributes);
throw new MyException(msg);
}
int counter = 0;
const int NODES_AT_END = 1;
while (reader.Read())
{
counter++;
}
if (counter != NODES_AT_END)
{
throw new MyException(String.Format("expected {0} nodes, but found {1}", NODES_AT_END, counter));
}
}
public static bool IsNull(XmlReader reader)
{
bool result = reader.MoveToAttribute("null", UPnPConsts.NS_XSI) && reader.ReadContentAsBoolean();
reader.MoveToElement();
return result;
}
public static bool GetBool(Schema schema, XmlReader reader, out bool value)
{
DebugCheck.NotNull(schema);
DebugCheck.NotNull(reader);
if (reader.SchemaInfo.Validity
== XmlSchemaValidity.Invalid)
{
value = true; // we have to set the value to something before returning.
return false;
}
// do this in a try catch, just in case the attribute wasn't validated against an xsd:boolean
try
{
value = reader.ReadContentAsBoolean();
return true;
}
catch (XmlException)
{
// we already handled the valid and invalid cases, so it must be NotKnown now.
Debug.Assert(reader.SchemaInfo.Validity == XmlSchemaValidity.NotKnown, "The schema validity must be NotKnown at this point");
schema.AddError(
ErrorCode.BoolValueExpected, EdmSchemaErrorSeverity.Error, reader,
Strings.ValueNotUnderstood(reader.Value, reader.Name));
}
value = true; // we have to set the value to something before returning.
return false;
}
private void LoadLevel(XmlReader reader, ContentManager content)
{
string aCurrentElement = string.Empty;
int aPositionX = 0;
int aPositionY = 0;
//vars for the spawning of objects
float aSpawnPosX = 0;
float aSpawnPosY = 0;
string formation = string.Empty;
bool mirrored = false;
while (reader.Read())
{
if(reader.NodeType == XmlNodeType.EndElement &&
reader.Name.Equals("level", StringComparison.OrdinalIgnoreCase))
{
break;
}
else if (reader.NodeType == XmlNodeType.Element)
{
aCurrentElement = reader.Name;
switch (aCurrentElement)
{
case "name":
{
levelName = reader.ReadElementContentAsString();
break;
}
case "nextlevel":
{
nextLevel = reader.ReadElementContentAsString();
break;
}
case "description":
{
description = reader.ReadElementContentAsString();
break;
}
case "tileset":
{
var texfilelocation = reader.ReadElementContentAsString();
LoadTile(texfilelocation, content);
break;
}
}
}
else if (reader.NodeType == XmlNodeType.EndElement)
{
if (aCurrentElement == "row")
{
aPositionY += 1;
aPositionX = 0;
}
}
else if (reader.NodeType == XmlNodeType.Text)
{
if (aCurrentElement == "row")
{
string aRow = reader.Value;
nrOfRows += 1;
for (int counter = 0; counter < aRow.Length; counter++)
{
var tempChar = aRow[counter].ToString().ToCharArray()[0];
mapList.Add(new Tile(new Vector2(aPositionX, aPositionY), tempChar));
aPositionX += 1;
}
}
else if (aCurrentElement == "positionX")
{
aSpawnPosX = reader.ReadContentAsFloat();
aSpawnPosX *= tilesize;
}
else if (aCurrentElement == "positionY")
{
aSpawnPosY = reader.ReadContentAsFloat();
aSpawnPosY *= tilesize;
aSpawnPosY = -aSpawnPosY;
}
else if (aCurrentElement == "formation")
{
formation = reader.Value;
}
else if (aCurrentElement == "mirrored")
{
mirrored = reader.ReadContentAsBoolean();
mapSpawnList.Add(new LevelSpawnObj(new Vector2(aSpawnPosX, aSpawnPosY), formation, mirrored));
}
}
}
StartingCameraPos();
}
private static TableStorageField ToObject(XmlReader reader, string edmType, bool isNull, string propertyName)
{
object value;
Type dataType;
string formatString;
if(edmType == TableStorageConstants.Edm.TYPE_BINARY)
{
if(isNull)
{
value = DBNull.Value;
}
else
{
using(Stream stream = new MemoryStream())
{
const int size = 256;
byte[] buffer = new byte[size];
int count;
while((count = reader.ReadContentAsBase64(buffer, 0, size)) > 0)
{
stream.Write(buffer, 0, count);
}
stream.Seek(0, SeekOrigin.Begin);
value = stream;
}
}
dataType = typeof(byte[]);
formatString = "{0}";
}
else if(edmType == TableStorageConstants.Edm.TYPE_BOOLEAN)
{
if(isNull)
{
value = DBNull.Value;
}
else
{
value = reader.ReadContentAsBoolean();
}
dataType = typeof(bool);
formatString = "{0}";
}
else if(edmType == TableStorageConstants.Edm.TYPE_DATETIME)
{
if(isNull)
{
value = DBNull.Value;
}
else
{
value = reader.ReadContentAsDateTime();
}
dataType = typeof(DateTime);
formatString = TableStorageConstants.Edm.DATE_TIME_FORMAT;
}
else if(edmType == TableStorageConstants.Edm.TYPE_DOUBLE)
{
if(isNull)
{
value = DBNull.Value;
}
else
{
value = reader.ReadContentAsDouble();
}
dataType = typeof(double);
formatString = "{0}";
}
else if(edmType == TableStorageConstants.Edm.TYPE_GUID)
{
if(isNull)
{
value = DBNull.Value;
}
else
{
value = Guid.Parse(reader.ReadContentAsString());
}
dataType = typeof(Guid);
formatString = "{0:D}";
}
else if(edmType == TableStorageConstants.Edm.TYPE_INT)
{
if(isNull)
{
value = DBNull.Value;
}
else
{
value = reader.ReadContentAsInt();
}
dataType = typeof(int);
formatString = "{0}";
}
else if(edmType == TableStorageConstants.Edm.TYPE_LONG)
{
if(isNull)
{
value = DBNull.Value;
}
else
{
value = reader.ReadContentAsLong();
}
dataType = typeof(long);
formatString = "{0}";
}
else if(StringComparer.OrdinalIgnoreCase.Equals(TableStorageConstants.Edm.TYPE_STRING, edmType))
{
if(isNull)
{
value = DBNull.Value;
}
else
{
value = reader.ReadContentAsString();
}
dataType = typeof(string);
formatString = "{0}";
}
else
{
throw new TableStorageException(string.Format("The type, '{0},' is not supported.", edmType));
}
return new TableStorageField(value, edmType, propertyName, isNull, dataType, formatString);
}
