private void ReadElement(XmlReader reader, Bag parent) {
var name = XmlConvert.DecodeName(reader.LocalName);
var type = reader["type"];
// is it a value node ? i.e. type=""
if (type != null) {
if (type == "Array") {
// go to first item
parent.SetMember(name, ReadArray(reader));
reader.Read();
}
else {
var typeCode = (TypeCode)Enum.Parse(typeof(TypeCode), type);
var value = SConvert.XmlDecode(typeCode, reader.ReadElementString());
parent.SetMember(name, value);
}
}
else {
var grappe = new Bag();
reader.Read();
parent.SetMember(name, grappe);
while (reader.MoveToContent() == XmlNodeType.Element) {
ReadElement(reader, grappe);
}
reader.Read();
}
}
void IFlickrParsable.Load(XmlReader reader)
{
while (reader.MoveToNextAttribute())
{
switch (reader.LocalName)
{
case "usage":
Usage = reader.ReadContentAsInt();
break;
case "predicate":
PredicateName = reader.Value;
break;
case "namespace":
NamespaceName = reader.Value;
break;
}
}
reader.Read();
if (reader.NodeType == XmlNodeType.Text)
PairName = reader.ReadContentAsString();
reader.Read();
}
void IXmlSerializable.ReadXml(XmlReader reader)
{
// name start
reader.Read();
while (reader.Name == "NameValue")
{
string name;
string value;
// Name
reader.Read();
reader.Read();
name = reader.Value;
reader.Read();
// Value
reader.Read();
reader.Read();
value = reader.Value;
reader.Read();
reader.Read();
reader.Read();
Add(name, value);
}
// name end
reader.Read();
}
public string Task1()
{
reader = XmlReader.Create(FILE_NAME);
decimal in_v = 0;
decimal out_v = 0;
while (reader.Read())
{
if (reader.IsStartElement())
{
switch (reader.Name)
{
case IN_V:
if(reader.Read())
in_v += Convert.ToDecimal(reader.Value.Trim());
break;
case OUT_V:
if (reader.Read())
out_v += Convert.ToDecimal(reader.Value.Trim());
break;
}
}
}
reader.Close();
return IN_V + in_v.ToString() + "\n" + OUT_V + out_v.ToString();
}
public void ReadXml(XmlReader reader)
{
m_name = reader.Name;
while (reader.Read())
{
reader.SkipEmptyNodes();
if (reader.NodeType == XmlNodeType.EndElement)
{
// the end
break;
}
else if (reader.NodeType == XmlNodeType.Element)
{
reader.Read(); // go into ValueNode
reader.SkipEmptyNodes();
}
if (reader.NodeType != XmlNodeType.Text)
{
throw new Exception("Required NodeType: Text - Found: " + reader.NodeType);
}
var value = reader.ReadContentAsString();
Pairs.Add(new KeyValuePair<string, string>(reader.Name, value));
if (reader.NodeType == XmlNodeType.EndElement)
{
// the end
reader.ReadInnerXml();
}
}
}
public Searchers(XmlReader reader)
{
this.Choices = new List<Choice>();
this.CurrentSearch = "";
reader.Read();
if (reader.Name != "TheSearchers")
return; // bail out
reader.Read();
while (!reader.EOF)
{
if ((reader.Name == "TheSearchers") && !reader.IsStartElement())
break; // all done
if (reader.Name == "Current")
this.CurrentSearch = reader.ReadElementContentAsString();
else if (reader.Name == "Choice")
{
string url = reader.GetAttribute("URL");
if (url == null)
url = reader.GetAttribute("URL2");
else
{
// old-style URL, replace "!" with "{ShowName}+{Season}+{Episode}"
url = url.Replace("!", "{ShowName}+{Season}+{Episode}");
}
this.Add(reader.GetAttribute("Name"), url);
reader.ReadElementContentAsString();
}
else
reader.ReadOuterXml();
}
}
void IFlickrParsable.Load(XmlReader reader)
{
while (reader.NodeType != XmlNodeType.EndElement)
{
switch (reader.LocalName)
{
case "set":
ContextSet set = new ContextSet();
set.PhotosetId = reader.GetAttribute("id");
set.Title = reader.GetAttribute("title");
Sets.Add(set);
reader.Read();
break;
case "pool":
ContextGroup group = new ContextGroup();
group.GroupId = reader.GetAttribute("id");
group.Title = reader.GetAttribute("title");
Groups.Add(group);
reader.Read();
break;
default:
break;
}
}
}
public ExamQuestion(XmlReader reader)
: this()
{
QuestionIdentifier = reader.GetAttribute("identifier");
Question = reader.GetAttribute("question");
Image = reader.GetAttribute("image");
while (!reader.EOF)
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
if (reader.Name == "Answer")
Answer = reader.ReadElementContentAsString();
else if (reader.Name == "Distractor")
Distractors.Add(reader.ReadElementContentAsString());
else
reader.Read();
break;
case XmlNodeType.EndElement:
return;
default:
reader.Read();
break;
}
}
}
internal XmlNode ReadCurrentNode(XmlDocument doc, XmlReader reader)
{
_doc = doc;
_reader = reader;
// WS are optional only for loading (see XmlDocument.PreserveWhitespace)
_preserveWhitespace = true;
if (doc == null)
throw new ArgumentException(SR.Xdom_Load_NoDocument);
if (reader == null)
throw new ArgumentException(SR.Xdom_Load_NoReader);
if (reader.ReadState == ReadState.Initial)
{
reader.Read();
}
if (reader.ReadState == ReadState.Interactive)
{
XmlNode n = LoadNode(true);
// Move to the next node
if (n.NodeType != XmlNodeType.Attribute)
reader.Read();
return n;
}
return null;
}
private void ReadTerrain(XmlReader reader, string key)
{
Terrain terrain = new Terrain (key);
while (reader.Read ()) {
if ((reader.NodeType == XmlNodeType.EndElement) &&
(reader.Name == "terrain"))
break;
if (reader.NodeType != XmlNodeType.Element)
continue;
string element = reader.Name;
reader.Read ();
if (element == "name")
terrain.Name = reader.Value;
else if (element == "description")
terrain.Description = reader.Value;
else if (element == "blocks")
terrain.IsBlocking = Boolean.Parse (reader.Value);
else if (element == "tile")
terrain.Tiles.Add (reader.Value);
}
if (!terrain.IsValid)
throw new ApplicationException (String.Format
("Terrain '{0}' is missing a child element.",
key));
terrains.Add (key, terrain);
}
public void ReadFromXml(XmlReader reader)
{
reader.MoveToContent();
if (reader.IsEmptyElement) { reader.Read(); return; }
reader.Read();
while (!reader.EOF)
{
if (reader.IsStartElement())
{
if (reader.Name == "type")
{
var type = new ClassType();
type.ReadFromXml(reader);
classTypes.Add(type);
}
else
{
reader.Skip();
}
}
else
{
reader.Read();
break;
}
}
}
/// <summary>
/// Parses the WDDX element and returns the deserialized
/// content as a <see cref="Hashtable"/> object, advancing the reader to the next
/// element.
/// </summary>
/// <param name="input">The pre-initialized <see cref="System.Xml.XmlTextReader"/> pointing to the WDDX to be parsed.</param>
public object ParseElement(XmlReader input)
{
Hashtable thisTable = new Hashtable();
if (input.IsEmptyElement)
{
input.Skip();
return thisTable;
}
string elementName;
object elementValue;
IWddxElementDeserializer deserializer;
while (input.Read() && (!(input.Name == "struct" && input.NodeType == XmlNodeType.EndElement)))
{
if (input.Name == "var" && input.NodeType != XmlNodeType.EndElement)
{
elementName = input.GetAttribute("name");
input.Read(); // move to contents of <var>
deserializer = WddxElementDeserializerFactory.GetDeserializer(input.Name);
elementValue = deserializer.ParseElement(input);
thisTable.Add(elementName, elementValue);
}
}
input.ReadEndElement();
return thisTable;
}
public void readInFilepropertyElement(XmlReader reader, string dotName, Fileproperty fileproperty)
{
//while (reader.NodeType != XmlNodeType.EndElement)
//{
reader.Read();//now on text node
if (reader.NodeType == XmlNodeType.Text)
{
//Console.WriteLine(dotName + " = " + reader.Value);
switch (dotName)
{
case "Name":
fileproperty.Filename = reader.Value;
reader.Read();//now on end element like </Name>
break;
case "StartingFrame":
fileproperty.StartingFrame = Convert.ToInt32(reader.Value);
reader.Read();//now on end element like </Name>
break;
case "TotalFrames":
fileproperty.TotalFrames = Convert.ToInt32(reader.Value);
reader.Read();//now on end element like </Name>
break;
}
}
//}
reader.Read();//now on the next start element like <StartingFrame>
}
private string ConvertToJsonClass(XmlReader xmlReader, char openChar, char closeChar)
{
string result = String.Format("{0}\"{1}\" :", new string('\t', tabCount), xmlReader.Name);
++tabCount;
if (xmlReader.IsEmptyElement)
return ConvertToJsonEmptyValue(result);
if (xmlReader.HasAttributes)
{
result += string.Format(" {0}\r\n", openChar);
result += ConvertToJsonAttributes(xmlReader);
xmlReader.Read();
}
else
{
xmlReader.Read();
if (xmlReader.NodeType == XmlNodeType.Text)
{
result += ConvertToJsonText(xmlReader);
tabCount--;
return result;
}
result += string.Format(" {0}\r\n", openChar);
}
do
{
result += ConvertToJsonElement(xmlReader);
} while (xmlReader.Read() && xmlReader.NodeType != XmlNodeType.EndElement);
--tabCount;
result += string.Format("{0}{1},\r\n", new string('\t', tabCount), closeChar);
return result;
}
public static void Deserialise(this PageInfo pageInfo, XmlReader reader)
{
if (reader.NodeType == XmlNodeType.Element && reader.Name.Equals("PageInfo"))
{
while (reader.Read() && reader.NodeType == XmlNodeType.Element)
{
string elementName = reader.Name;
if (reader.Read() && reader.NodeType == XmlNodeType.Text)
{
int value;
if (int.TryParse(reader.Value, out value))
{
switch (elementName)
{
case "TotalCount":
pageInfo.TotalCount = value;
break;
case "ItemsCount":
pageInfo.ItemsCount = value;
break;
case "StartIndex":
pageInfo.StartIndex = value;
break;
}
}
}
reader.Read(); // end element
}
}
}
public override object ReadObject(XmlReader reader)
{
SimpleEventRequest SimpleEventRequestField = null;
if (IsParentStartElement(reader, false, true))
{
SimpleEventRequestField = new SimpleEventRequest();
SimpleEventRequestField.AnyAttr = ReadAnyAttribute(reader);
reader.Read();
if (IsChildStartElement(reader, "Param", true, true))
{
reader.Read();
string[] Param_List = reader.ReadString().Split();
if ((this._CompressByteArrays
|| ((Param_List.Length == 1)
&& (Param_List[0].Length > 2))))
{
SimpleEventRequestField.Param = Convert.FromBase64String(Param_List[0]);
}
else
{
SimpleEventRequestField.Param = new byte[Param_List.Length];
for (int i = 0; (i < Param_List.Length); i = (i + 1))
{
SimpleEventRequestField.Param[i] = XmlConvert.ToByte(Param_List[i]);
}
}
reader.ReadEndElement();
}
SimpleEventRequestField.Any = ReadAnyElement(reader, false);
reader.ReadEndElement();
}
return SimpleEventRequestField;
}
void NoExtensionsSetup ()
{
XmlReaderSettings xs = new XmlReaderSettings ();
xs.IgnoreWhitespace = true;
xtr = XmlTextReader.Create ("Test/System.ServiceModel.Description/dump.xml", xs);
xtr.Read ();
//FIXME: skipping Headers
while (xtr.LocalName != "Body") {
if (!xtr.Read ())
return;
}
//Move to <Metadata ..
xtr.Read ();
ms = MetadataSet.ReadFrom (xtr);
//MyWsdlImportExtension mw = new MyWsdlImportExtension ();
List<IWsdlImportExtension> list = new List<IWsdlImportExtension> ();
//list.Add (mw);
list.Add (new DataContractSerializerMessageContractImporter ());
/*list.Add (new MessageEncodingBindingElementImporter ());
list.Add (new TransportBindingElementImporter ());
list.Add (new StandardBindingImporter ());*/
wi = new WsdlImporter (ms, null, list);
}
public override object ReadObject(XmlReader reader)
{
OneWayAttachmentRequest OneWayAttachmentRequestField = null;
if (IsParentStartElement(reader, false, true))
{
OneWayAttachmentRequestField = new OneWayAttachmentRequest();
OneWayAttachmentRequestField.AnyAttr = ReadAnyAttribute(reader);
reader.Read();
if (IsChildStartElement(reader, "Param", true, true))
{
reader.Read();
if (IsAttribute(reader, "href"))
{
string contentID;
contentID = reader.Value;
reader.MoveToElement();
reader.ReadStartElement("Include", "http://www.w3.org/2004/08/xop/include");
reader.ReadEndElement();
OneWayAttachmentRequestField.Param = GetBodyPartContent(contentID, BodyParts);
}
else
{
OneWayAttachmentRequestField.Param = Convert.FromBase64String(reader.ReadString());
reader.ReadEndElement();
}
}
OneWayAttachmentRequestField.Any = ReadAnyElement(reader, false);
reader.ReadEndElement();
}
return OneWayAttachmentRequestField;
}
public override void ReadXml(XmlReader reader)
{
reader.MoveToContent();
if (reader.IsEmptyElement) { reader.Read(); return; }
while (!reader.EOF)
{
if (reader.IsStartElement())
{
switch (reader.LocalName)
{
case "Format":
Format = reader.ReadElementContentAsString();
break;
case "OnlineResource":
OnlineResource = new OnlineResource();
OnlineResource.ReadXml(reader);
break;
default:
reader.Skip();
break;
}
}
else
{
reader.Read();
}
}
}
public void MakeTaskElements(string suffix, XmlReader taskSet)
{
while (taskSet.Name != "question")
taskSet.Read();
Label myLabel = new Label();
myLabel.Name = "MyLabel" + suffix;
myLabel.Content = taskSet.GetAttribute("key");
myLabel.FontSize = 20;
taskSet.Read();
string xaml =
"<Button x:Name='MyButton' Content='F*****g button' Click=Button1_Click xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation' xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'> "
+"<Button.ToolTip> <ToolTip Background='#90004455'> </ToolTip></Button.ToolTip>"+
" </Button>";
string xaml1 =
"<Grid Margin='10' " +
"xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation' " +
"xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml' " +
"</Grid>";
StringReader stringReader = new StringReader(xaml);
XmlReader xmlReader = XmlReader.Create(stringReader);
UIElement buffer = (UIElement)XamlReader.Parse(xaml);
//(buffer as Button).Click += Button1_Click;
(buffer as Button).Content="Hello";
(pages.Last() as StackPanel).Children.Add(buffer);
}
void IFlickrParsable.Load(XmlReader reader)
{
while (reader.NodeType != XmlNodeType.EndElement)
{
switch (reader.LocalName)
{
case "set":
this.Sets.Add(new ContextSet()
{
PhotosetId = reader.GetAttribute("id"),
Title = reader.GetAttribute("title")
});
reader.Read();
continue;
case "pool":
this.Groups.Add(new ContextGroup()
{
GroupId = reader.GetAttribute("id"),
Title = reader.GetAttribute("title")
});
reader.Read();
continue;
default:
continue;
}
}
}
public static ICondition ReadComplexCondition(XmlReader reader)
{
Properties properties = Properties.ReadFromAttributes(reader);
reader.Read();
ICondition condition = null;
while (reader.Read()) {
switch (reader.NodeType) {
case XmlNodeType.Element:
switch (reader.LocalName) {
case "And":
condition = AndCondition.Read(reader);
goto exit;
case "Or":
condition = OrCondition.Read(reader);
goto exit;
case "Not":
condition = NegatedCondition.Read(reader);
goto exit;
default:
throw new AddInLoadException("Invalid element name '" + reader.LocalName
+ "', the first entry in a ComplexCondition " +
"must be <And>, <Or> or <Not>");
}
}
}
exit:
if (condition != null) {
ConditionFailedAction action = properties.Get("action", ConditionFailedAction.Exclude);
condition.Action = action;
}
return condition;
}
public void ReadFromXml(XmlReader reader)
{
reader.MoveToContent();
if (reader.IsEmptyElement) { reader.Read(); return; }
reader.Read();
while (!reader.EOF)
{
if (reader.IsStartElement())
{
if (reader.Name == "module")
{
var module = new Module();
module.ReadFromXml(reader);
modules.Add(module);
}
else
{
reader.Skip();
}
}
else
{
reader.Read();
break;
}
}
}
public static IFeed GetFeed(Uri url, XmlReader reader) {
reader.MoveToContent();
string language = string.Empty;
FeedType feedType;
string namespaceUri = reader.NamespaceURI;
if(reader.LocalName.Equals("RDF") &&
reader.NamespaceURI.Equals("http://www.w3.org/1999/02/22-rdf-syntax-ns#")) {
feedType = FeedType.Rdf;
reader.Read();
reader.MoveToContent();
} else if(reader.LocalName.Equals("rss")) {
feedType = FeedType.Rss;
do {
reader.Read();
reader.MoveToContent();
} while(!reader.LocalName.Equals("channel") && !reader.LocalName.Equals("rss"));
} else if(reader.NamespaceURI.Equals("http://purl.org/atom/ns#") && reader.LocalName.Equals("feed")) {
if(reader.MoveToAttribute("version") && reader.Value.Equals("0.3")) {
feedType = FeedType.Atom;
language = reader.XmlLang;
reader.MoveToElement();
} else {
throw new ApplicationException(string.Format("Unsupported Atom Version {0}", reader.Value));
}
} else if(reader.NamespaceURI.Equals("http://www.w3.org/2005/Atom") && reader.LocalName.Equals("feed")) {
feedType = FeedType.Atom;
language = reader.XmlLang;
} else {
throw new ApplicationException("Unknown Xml Dialect");
}
return PopulateFeed(url, reader, namespaceUri, feedType, language);
}
public virtual void ReadXml(XmlReader reader)
{
var viewSpecLists = new Dictionary<string, ViewSpecList>();
if (reader.IsEmptyElement)
{
reader.Read();
}
else
{
reader.Read();
while (true)
{
if (reader.IsStartElement("views")) // Not L10N
{
string groupName = reader.GetAttribute("name"); // Not L10N
// ReSharper disable AssignNullToNotNullAttribute
viewSpecLists.Add(groupName, ViewSpecList.Deserialize(reader));
// ReSharper restore AssignNullToNotNullAttribute
}
else if (reader.NodeType == XmlNodeType.EndElement)
{
reader.ReadEndElement();
break;
}
else
{
reader.Read();
}
}
}
_viewSpecLists = viewSpecLists;
}
void IFlickrParsable.Load(XmlReader reader)
{
reader.Read();
while (reader.LocalName != "photos")
{
switch (reader.LocalName)
{
case "firstdatetaken":
this.FirstTakenDate = UtilityMethods.ParseDateWithGranularity(reader.ReadElementContentAsString());
continue;
case "firstdate":
this.FirstDate = UtilityMethods.UnixTimestampToDate(reader.ReadElementContentAsString());
continue;
case "count":
this.PhotoCount = reader.ReadElementContentAsInt();
continue;
case "views":
this.Views = reader.ReadElementContentAsInt();
continue;
default:
reader.Skip();
continue;
}
}
reader.Read();
}
public void ReadXml(XmlReader reader)
{
//goto inner hidden
reader.Read();
Text = reader.ReadInnerXml();
reader.Read();
}
public void ReadFromXml(XmlReader reader)
{
reader.MoveToContent();
if (reader.IsEmptyElement) { reader.Read(); return; }
semesterStart = DateTime.Parse(reader.GetAttribute("semesterStart"));
reader.Read();
while (!reader.EOF)
{
if (reader.IsStartElement())
{
if (reader.Name == "weekday")
{
var weekday = new ScheduleWeekday();
weekday.ReadFromXml(reader);
weekdays.Add(weekday);
}
else
{
reader.Skip();
}
}
else
{
reader.Read();
break;
}
}
}
public void ReadFromXml(XmlReader reader)
{
reader.MoveToContent();
if (reader.IsEmptyElement) { reader.Read(); return; }
num = int.Parse(reader.GetAttribute("number"));
reader.Read();
while (!reader.EOF)
{
if (reader.IsStartElement())
{
if (reader.Name == "class")
{
var sClass = new ScheduleClass();
sClass.ReadFromXml(reader);
classes.Add(sClass);
}
else
{
reader.Skip();
}
}
else
{
reader.Read();
break;
}
}
}
public void ReadFromXml(XmlReader reader)
{
reader.MoveToContent();
if (reader.IsEmptyElement) { reader.Read(); return; }
reader.Read();
while (!reader.EOF)
{
if (reader.IsStartElement())
{
if (reader.Name == "groupContainer")
{
var groupContainer = new GroupContainer();
groupContainer.ReadFromXml(reader);
groupContainers.Add(groupContainer);
}
else
{
reader.Skip();
}
}
else
{
reader.Read();
break;
}
}
}
public void ReadXml(System.Xml.XmlReader reader)
{
XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
bool wasEmpty = reader.IsEmptyElement;
reader.Read();
if (wasEmpty)
{
return;
}
var isKeySimpleType = typeof(TKey).IsEnum || typeof(TKey).IsValueType || typeof(TKey) == typeof(string);
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
reader.ReadStartElement("item");
reader.ReadStartElement("key");
TKey key = default(TKey);
if (isKeySimpleType)
{
if (typeof(TKey) == typeof(string))
{
Object t = reader.GetAttribute("key_value");
key = (TKey)t;
}
}
else
{
key = (TKey)valueSerializer.Deserialize(reader);
}
reader.ReadEndElement();
reader.ReadStartElement("value");
TValue value = (TValue)valueSerializer.Deserialize(reader);
reader.ReadEndElement();
this.Add(key, value);
reader.ReadEndElement();
reader.MoveToContent();
}
reader.ReadEndElement();
}
public void ReadXml(System.Xml.XmlReader reader)
{
XmlSerializer x = new
XmlSerializer(typeof(System.Collections.ArrayList), new System.Type[] {
typeof(Node)
});
reader.Read();
ArrayList list = x.Deserialize(reader) as ArrayList;
if (list == null)
{
return;
}
foreach (Node node in list)
{
Add(node.key, node.val);
}
}
public void ReadXml(System.Xml.XmlReader reader)
{
XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
// XmlSerializer valueSerializer = new XmlSerializer( typeof( TValue ) );
bool wasEmpty = reader.IsEmptyElement;
reader.Read();
if (wasEmpty)
{
return;
}
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
reader.ReadStartElement("item");
reader.ReadStartElement("key");
TKey key = ( TKey )keySerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadStartElement("value");
System.Runtime.Serialization.DataContractSerializer serializer =
new System.Runtime.Serialization.DataContractSerializer(typeof(TValue), null, int.MaxValue, false, false, null, new Microsoft.Xrm.Sdk.KnownTypesResolver());
TValue value = (TValue)serializer.ReadObject(reader);
reader.ReadEndElement();
this.Add(key, value);
reader.ReadEndElement();
reader.MoveToContent();
}
reader.ReadEndElement();
}
public void ReadXml(System.Xml.XmlReader reader)
{
bool wasEmpty = reader.IsEmptyElement;
reader.Read();
if (wasEmpty)
{
return;
}
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
string key = reader.Name;
reader.ReadStartElement();
string value = reader.ReadContentAsString();
reader.ReadEndElement();
this[key] = value;
reader.MoveToContent();
}
reader.ReadEndElement();
}
public void ReadXml(System.Xml.XmlReader reader)
{
XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
bool wasEmpty = reader.IsEmptyElement;
reader.Read();
if (wasEmpty)
{
return;
}
reader.ReadStartElement("dict");
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
reader.ReadStartElement("item");
reader.ReadStartElement("key");
TKey key = (TKey)keySerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadStartElement("value");
TValue value = (TValue)valueSerializer.Deserialize(reader);
reader.ReadEndElement();
this.Add(key, value);
reader.ReadEndElement();
reader.MoveToContent();
}
reader.ReadEndElement();
}
/// <summary>
/// Updates an existing <see cref="NameValueCollection" /> object from
/// its XML representation.
/// </summary>
private static void UpcodeTo(XmlReader reader, NameValueCollection collection)
{
if (collection == null)
{
throw new ArgumentNullException("collection");
}
if (reader == null)
{
throw new ArgumentNullException("reader");
}
Debug.Assert(!reader.IsEmptyElement);
reader.Read();
//
// Add entries into the collection as <item> elements
// with child <value> elements are found.
//
while (reader.NodeType != XmlNodeType.EndElement)
{
if (reader.IsStartElement("item"))
{
string name = reader.GetAttribute("name");
bool isNull = reader.IsEmptyElement;
reader.Read(); // <item>
if (!isNull)
{
while (reader.NodeType != XmlNodeType.EndElement)
{
if (reader.IsStartElement("value")) // <value ...>
{
string value = reader.GetAttribute("string");
collection.Add(name, value);
if (reader.IsEmptyElement)
{
reader.Read();
}
else
{
reader.Read();
while (reader.NodeType != XmlNodeType.EndElement)
{
reader.Skip();
}
reader.ReadEndElement();
}
}
else
{
reader.Skip();
}
reader.MoveToContent();
}
reader.ReadEndElement(); // </item>
}
else
{
collection.Add(name, null);
}
}
else
{
reader.Skip();
}
reader.MoveToContent();
}
reader.ReadEndElement();
}
public override SMSCommunicationHistoryCBE SendSMS(SMSCommunicationHistoryCBE sms)
{
LogMessage("Using Mobiduite SMS gateway for sending message.");
#region Variables
string createdURL = "";
string mobileNumber = sms.MobileNumber;
string messageBody = sms.MessageBody;
string userName = "******";
string password = "******";
string sender = "IMS";
string dr_url = "http://103.119.145.130:5555/VaaaN/IndonesiaMLFFApi/ResponseSMS";
// Andrew Tan mobile number 082246492815 (Indonesia)
#endregion
#region Send SMS to Mobile phone
try
{
sms.ReferenceNo = Constants.SMSTranscationId(sms.EntryId);
LogMessage("Trying to send message to customer mobile number. Mobile No.:" + mobileNumber);
createdURL = "http://webapps.imitra.com:29003/sms_applications/smsb/api_mt_send_message.php?";
string data = "data=<bulk_sending>" +
"<username>" + userName + "</username>" +
"<password>" + password + "</password>" +
"<priority>high</priority>" +
"<sender>" + sender + "</sender>" +
"<dr_url>" + dr_url + "</dr_url>" +
"<allowduplicate>1</allowduplicate>" +
"<data_packet>" +
"<packet>" +
"<msisdn>" + mobileNumber + "</msisdn>" +
"<sms>" + messageBody + "</sms>" +
"<is_long_sms>N</is_long_sms>" +
"</packet>" +
"</data_packet>" +
"</bulk_sending>";
// Create request
HttpWebRequest myReq = (HttpWebRequest)WebRequest.Create(createdURL);
myReq.Method = "POST";
myReq.ContentType = "application/x-www-form-urlencoded";//important
// Send data with request
byte[] bytes = Encoding.UTF8.GetBytes(data);
myReq.ContentLength = bytes.Length;
using (Stream putStream = myReq.GetRequestStream())
{
putStream.Write(bytes, 0, bytes.Length);
}
// Get response from the SMS Gateway Server and read the answer
HttpWebResponse myResp = (HttpWebResponse)myReq.GetResponse();
System.IO.StreamReader respStreamReader = new System.IO.StreamReader(myResp.GetResponseStream());
string responseString = respStreamReader.ReadToEnd();
respStreamReader.Close();
myResp.Close();
// Check response value
System.IO.MemoryStream ms = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(responseString));
System.Xml.XmlReader reader = System.Xml.XmlReader.Create(ms);
string statusCode = "";
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.Name == "status_code")
{
reader.Read();
statusCode = Convert.ToString(reader.Value);
try
{
sms.ResponseCode = Convert.ToInt32(statusCode);
LogMessage("Response status code is " + statusCode + ".");
}
catch (Exception ex)
{
LogMessage("error in convert status code is " + statusCode + ".");
}
}
if (reader.Name == "transaction_id")
{
reader.Read();
sms.TransactionId = Convert.ToString(reader.Value);
LogMessage("Response transactionId is " + sms.TransactionId + ".");
}
}
}
if (statusCode == "2200")
{
sms.SentStatus = (int)VaaaN.MLFF.Libraries.CommonLibrary.Constants.SMSSentStatus.Sent;
}
sms.GatewayResponse = responseString;
LogMessage("Response:" + responseString);
LogMessage("Message sent successfully to mobile.");
}
catch (Exception ex)
{
//if sending request or getting response is not successful the SMS Gateway Server may do not run
LogMessage("Failed to send message to customer." + ex.Message);
}
#endregion
return(sms);
}
void IXmlSerializable.ReadXml(System.Xml.XmlReader reader)
{
LinkItem item = new LinkItem();
while (reader.IsStartElement())
{
reader.MoveToContent();
reader.Read();
if (reader.IsStartElement("Id"))
{
reader.MoveToContent();
item.Id = int.Parse(reader.ReadString());
reader.MoveToContent();
reader.ReadEndElement();
}
else
{
throw new XmlException("ExpectedElementMissing: Id element was expected.");
}
if (reader.IsStartElement("Title"))
{
reader.MoveToContent();
item.Title = reader.ReadString();
reader.MoveToContent();
reader.ReadEndElement();
}
else
{
throw new XmlException("ExpectedElementMissing: Title element was expected.");
}
if (reader.IsStartElement("Description"))
{
reader.MoveToContent();
item.Description = reader.ReadString();
reader.MoveToContent();
reader.ReadEndElement();
}
else
{
throw new XmlException("ExpectedElementMissing: Description element was expected.");
}
if (reader.IsStartElement("DateStart"))
{
reader.MoveToContent();
reader.Read();
item.DateStart = reader.ReadContentAsDateTime();
reader.MoveToContent();
reader.ReadEndElement();
}
else
{
throw new XmlException("ExpectedElementMissing: DateStart element was expected.");
}
if (reader.IsStartElement("DateEnd"))
{
reader.MoveToContent();
reader.Read();
item.DateEnd = reader.ReadContentAsDateTime();
reader.MoveToContent();
reader.ReadEndElement();
}
// optional
if (reader.IsStartElement("Url"))
{
reader.MoveToContent();
item.Url = reader.ReadString();
reader.MoveToContent();
reader.ReadEndElement();
}
else
{
throw new XmlException("ExpectedElementMissing: Url element was expected.");
}
reader.MoveToContent();
reader.ReadEndElement();
}
this.m_linkItem = item;
}
public static List <XmlReadInstructions> AnalyseXmlReader(System.Xml.XmlReader reader, bool globalUniqueColumnNames)
{
var root = new Node();
var current = root;
var resultSets = new Dictionary <string, Node>();
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
current = current.SubElement(reader.Name);
if (reader.HasAttributes)
{
reader.MoveToFirstAttribute();
do
{
current.Attribute(reader.Name);
} while (reader.MoveToNextAttribute());
reader.MoveToElement();
}
if (current.CurrentCount > 1)
{
string xpath = current.AbsXPath;
if (!resultSets.ContainsKey(xpath))
{
resultSets[xpath] = current;
current.IsRepetetive = true;
}
}
if (reader.IsEmptyElement)
{
current = current.Parent;
}
break;
case XmlNodeType.Text:
if (!String.IsNullOrWhiteSpace(reader.Value))
{
current.HasText = true;
}
break;
case XmlNodeType.XmlDeclaration:
case XmlNodeType.ProcessingInstruction:
case XmlNodeType.Comment:
continue;
case XmlNodeType.EndElement:
current = current.Parent;
break;
}
}
// remove repetetive parents. Remains only innermost repetetives
foreach (var resultSet in resultSets.Values.ToList())
{
var node = resultSet;
node = node.Parent;
while (node != null && !node.IsRepetetive)
{
node = node.Parent;
}
if (node != null)
{
resultSets.Remove(node.AbsXPath);
node.IsRepetetive = false;
}
}
if (!resultSets.Any())
{
resultSets["/"] = root;
}
var res = new List <XmlReadInstructions>();
var addedColumns = new HashSet <string>();
var collectionNames = new HashSet <string>();
foreach (var resultSet in resultSets.Values)
{
var instruction = new XmlReadInstructions();
instruction.XPath = resultSet.AbsXPath ?? "/";
string collectionName = resultSet.Name;
if (collectionNames.Contains(collectionName))
{
int index = 2;
while (collectionNames.Contains(collectionName + index))
{
index++;
}
collectionName = collectionName + index;
}
instruction.CollectionName = collectionName;
if (!globalUniqueColumnNames)
{
addedColumns.Clear();
}
CollectColumns(instruction, root, addedColumns, resultSet);
if (resultSet != root)
{
CollectColumns(instruction, resultSet, addedColumns, resultSet);
}
res.Add(instruction);
}
return(res);
}
private void ReadIntegrator(ref XmlReadState state, System.Xml.XmlReader node)
{
node.Read();
/* \todo AA sample stuff */
var boolvar = false;
var intvar = 0;
var floatvar = 0.0f;
var stringvar = "";
Utilities.Instance.get_bool(ref boolvar, node.GetAttribute("branched"));
state.Scene.Integrator.IntegratorMethod = boolvar ? IntegratorMethod.BranchedPath : IntegratorMethod.Path;
if (Utilities.Instance.get_bool(ref boolvar, node.GetAttribute("sample_all_lights_direct")))
{
state.Scene.Integrator.SampleAllLightsDirect = boolvar;
}
if (Utilities.Instance.get_bool(ref boolvar, node.GetAttribute("sample_all_lights_indirect")))
{
state.Scene.Integrator.SampleAllLightsIndirect = boolvar;
}
if (Utilities.Instance.get_int(ref intvar, node.GetAttribute("diffuse_samples")))
{
state.Scene.Integrator.DiffuseSamples = intvar;
}
if (Utilities.Instance.get_int(ref intvar, node.GetAttribute("glossy_samples")))
{
state.Scene.Integrator.GlossySamples = intvar;
}
if (Utilities.Instance.get_int(ref intvar, node.GetAttribute("transmission_samples")))
{
state.Scene.Integrator.TransmissionSamples = intvar;
}
if (Utilities.Instance.get_int(ref intvar, node.GetAttribute("ao_samples")))
{
state.Scene.Integrator.AoSamples = intvar;
}
if (Utilities.Instance.get_int(ref intvar, node.GetAttribute("mesh_light_samples")))
{
state.Scene.Integrator.MeshLightSamples = intvar;
}
if (Utilities.Instance.get_int(ref intvar, node.GetAttribute("subsurface_samples")))
{
state.Scene.Integrator.SubsurfaceSamples = intvar;
}
if (Utilities.Instance.get_int(ref intvar, node.GetAttribute("volume_samples")))
{
state.Scene.Integrator.VolumeSamples = intvar;
}
if (Utilities.Instance.get_int(ref intvar, node.GetAttribute("min_bounce")))
{
state.Scene.Integrator.MinBounce = intvar;
}
if (Utilities.Instance.get_int(ref intvar, node.GetAttribute("max_bounce")))
{
state.Scene.Integrator.MaxBounce = intvar;
}
if (Utilities.Instance.get_int(ref intvar, node.GetAttribute("max_diffuse_bounce")))
{
state.Scene.Integrator.MaxDiffuseBounce = intvar;
}
if (Utilities.Instance.get_int(ref intvar, node.GetAttribute("max_glossy_bounce")))
{
state.Scene.Integrator.MaxGlossyBounce = intvar;
}
if (Utilities.Instance.get_int(ref intvar, node.GetAttribute("max_transmission_bounce")))
{
state.Scene.Integrator.MaxTransmissionBounce = intvar;
}
if (Utilities.Instance.get_int(ref intvar, node.GetAttribute("max_volume_bounce")))
{
state.Scene.Integrator.MaxVolumeBounce = intvar;
}
if (Utilities.Instance.get_int(ref intvar, node.GetAttribute("transparent_min_bounce")))
{
state.Scene.Integrator.TransparentMinBounce = intvar;
}
if (Utilities.Instance.get_int(ref intvar, node.GetAttribute("transparent_max_bounce")))
{
state.Scene.Integrator.TransparentMaxBounce = intvar;
}
if (Utilities.Instance.get_bool(ref boolvar, node.GetAttribute("transparent_shadows")))
{
state.Scene.Integrator.TransparentShadows = boolvar;
}
if (Utilities.Instance.get_float(ref floatvar, node.GetAttribute("volume_step_size")))
{
state.Scene.Integrator.VolumeStepSize = floatvar;
}
if (Utilities.Instance.get_int(ref intvar, node.GetAttribute("volume_max_steps")))
{
state.Scene.Integrator.VolumeMaxSteps = intvar;
}
/* \todo wrap caustics form separation
*
* if (Utilities.Instance.get_bool(ref boolvar, node.GetAttribute("caustics_reflective"))) state.Scene.Integrator.DoCausticsReflective = boolvar;
* if (Utilities.Instance.get_bool(ref boolvar, node.GetAttribute("caustics_refractive"))) state.Scene.Integrator.DoCausticsRefractive = boolvar;
*/
if (Utilities.Instance.get_bool(ref boolvar, node.GetAttribute("no_caustics")))
{
state.Scene.Integrator.NoCaustics = boolvar;
}
if (Utilities.Instance.get_float(ref floatvar, node.GetAttribute("filter_glossy")))
{
state.Scene.Integrator.FilterGlossy = floatvar;
}
if (Utilities.Instance.get_int(ref intvar, node.GetAttribute("seed")))
{
state.Scene.Integrator.Seed = intvar;
}
if (Utilities.Instance.get_float(ref floatvar, node.GetAttribute("sample_clamp_direct")))
{
state.Scene.Integrator.SampleClampDirect = floatvar;
}
if (Utilities.Instance.get_float(ref floatvar, node.GetAttribute("sample_clamp_indirect")))
{
state.Scene.Integrator.SampleClampIndirect = floatvar;
}
if (Utilities.Instance.read_string(ref stringvar, node.GetAttribute("sampling_pattern")))
{
state.Scene.Integrator.SamplingPattern = stringvar.Equals("sobol") ? SamplingPattern.Sobol : SamplingPattern.CMJ;
}
state.Scene.Integrator.TagForUpdate();
}
protected override Object AnalysisData(System.Xml.XmlReader reader)
{
PlayInfos = new Dictionary <int, PlayInfo>(6);
double totalDuraiton = 0;
if (reader.ReadToFollowing("channel"))
{
totalDuraiton = double.Parse(reader["dur"]);
while (reader.Read())
{
if (reader.Name == "file" &&
reader.NodeType == XmlNodeType.Element)
{
reader.Read();
while (reader.IsStartElement("item"))
{
var info = new PlayInfo();
if (IsDrag)
{
info.Segments = new List <PlaySegmentInfo>();
}
var bitrate = reader.GetAttribute("bitrate");
var ft = reader.GetAttribute("ft");
if (bitrate == null || ft == null)
{
continue;
}
info.Bitrate = Convert.ToInt32(bitrate);
info.ft = Convert.ToInt32(ft);
info.Rid = reader.GetAttribute("rid");
info.TotalDuration = totalDuraiton;
PlayInfos.Add(info.ft, info);
reader.ReadToNextSibling("item");
}
}
if (reader.Name == "dt" &&
reader.NodeType == XmlNodeType.Element)
{
var ft = Convert.ToInt32(reader.GetAttribute("ft"));
if (PlayInfos.ContainsKey(ft))
{
var info = PlayInfos[ft];
reader.ReadToFollowing("sh");
reader.Read();
info.Sh = reader.Value;
reader.ReadToFollowing("st");
reader.Read();
var st = reader.Value;
var ci = new CultureInfo("en-US");
info.St = DateTime.ParseExact(st, "ddd MMM dd HH:mm:ss yyyy UTC", ci);
reader.ReadToFollowing("bwt");
reader.Read();
info.Bwt = Convert.ToInt32(reader.Value);
}
}
if (reader.Name == "drag" &&
reader.NodeType == XmlNodeType.Element)
{
var ft = Convert.ToInt32(reader.GetAttribute("ft"));
if (PlayInfos.ContainsKey(ft))
{
reader.Read();
var info = PlayInfos[ft];
double timestamp = 0;
while (reader.IsStartElement("sgm"))
{
var segment = new PlaySegmentInfo();
segment.No = int.Parse(reader["no"]);
segment.Duration = double.Parse(reader["dur"]);
segment.FileSize = ulong.Parse(reader["fs"]);
segment.HeadLength = ulong.Parse(reader["hl"]);
timestamp += segment.Duration;
segment.TotalDuration = timestamp;
info.Segments.Add(segment);
reader.ReadToNextSibling("sgm");
}
}
}
}
}
return(1);
}
private void ReadScene(ref XmlReadState state, System.Xml.XmlReader node)
{
while (node.Read())
{
if (!node.IsStartElement())
{
continue;
}
if (!state.Silent)
{
Console.WriteLine("XML node: {0}", node.Name);
}
switch (node.Name)
{
case "camera":
ReadCamera(ref state, node.ReadSubtree());
break;
case "background":
ReadBackground(ref state, node.ReadSubtree());
break;
case "transform":
var transform_substate = new XmlReadState(state);
var t = transform_substate.Transform;
ReadTransform(node, ref t);
transform_substate.Transform = t;
node.Read(); /* advance forward one, otherwise we'll end up in internal loop */
ReadScene(ref transform_substate, node.ReadSubtree());
break;
case "lookat":
var lookat_substate = new XmlReadState(state);
var lat = lookat_substate.Transform;
ReadLookAt(node, ref lat);
lookat_substate.Transform = lat;
node.Read(); /* advance forward one, otherwise we'll end up in internal loop */
ReadScene(ref lookat_substate, node.ReadSubtree());
break;
case "state":
var state_substate = new XmlReadState(state);
ReadState(ref state_substate, node.ReadSubtree());
node.Read(); /* advance one forward */
ReadScene(ref state_substate, node.ReadSubtree());
break;
case "integrator":
ReadIntegrator(ref state, node.ReadSubtree());
break;
case "shader":
var shader_substate = new XmlReadState(state);
ReadShader(ref shader_substate, node.ReadSubtree());
break;
case "mesh":
ReadMesh(ref state, node.ReadSubtree());
break;
case "object":
ReadObject(ref state, node.ReadSubtree());
break;
case "light":
ReadLight(ref state, node.ReadSubtree());
break;
case "include":
var src = node.GetAttribute("src");
if (!string.IsNullOrEmpty(src))
{
ReadInclude(ref state, src);
}
break;
default:
Console.WriteLine("Uknown node {0}", node.Name);
break;
}
}
}
public bool FromXml(ref System.Xml.XmlReader xr)
{
bool results = false;
try
{
while (xr.Read())
{
if (xr.IsStartElement())
{
if (!xr.IsEmptyElement)
{
switch (xr.Name)
{
case "IsNonShipping":
xr.Read();
this.IsNonShipping = bool.Parse(xr.ReadString());
break;
case "ShipSeparately":
xr.Read();
this.ShipSeparately = bool.Parse(xr.ReadString());
break;
case "ExtraShipFee":
xr.Read();
this.ExtraShipFee = decimal.Parse(xr.ReadString());
break;
case "Weight":
xr.Read();
this.Weight = decimal.Parse(xr.ReadString());
break;
case "Length":
xr.Read();
this.Length = decimal.Parse(xr.ReadString());
break;
case "Width":
xr.Read();
this.Width = decimal.Parse(xr.ReadString());
break;
case "Height":
xr.Read();
this.Height = decimal.Parse(xr.ReadString());
break;
case "ShippingScheduleId":
xr.Read();
this.ShippingScheduleId = long.Parse(xr.ReadString());
break;
case "ShippingSource":
xr.Read();
this.ShippingSource = (ShippingMode)int.Parse(xr.ReadString());
break;
case "ShippingSourceId":
xr.Read();
this.ShippingSourceId = xr.ReadString();
break;
}
}
}
}
results = true;
}
catch (XmlException XmlEx)
{
EventLog.LogEvent(XmlEx);
results = false;
}
return(results);
}
static void AddElementToList(string in_currentPathInProj, System.Xml.XmlReader in_reader, AssetType in_type, LinkedList <AkWwiseProjectData.PathElement> in_pathAndIcons, int in_wwuIndex)
{
if (in_type.RootDirectoryName == "Events" || in_type.RootDirectoryName == "Master-Mixer Hierarchy" || in_type.RootDirectoryName == "SoundBanks" || in_type.RootDirectoryName == "Game Parameters" || in_type.RootDirectoryName == "Triggers" || in_type.RootDirectoryName == "Virtual Acoustics")
{
AkWwiseProjectData.Event valueToAdd = new AkWwiseProjectData.Event();
valueToAdd.Name = in_reader.GetAttribute("Name");
valueToAdd.Guid = new System.Guid(in_reader.GetAttribute("ID")).ToByteArray();
valueToAdd.ID = (int)AkUtilities.ShortIDGenerator.Compute(valueToAdd.Name);
valueToAdd.PathAndIcons = new List <AkWwiseProjectData.PathElement>(in_pathAndIcons);
switch (in_type.RootDirectoryName)
{
case "Events":
valueToAdd.Path = System.IO.Path.Combine(in_currentPathInProj, valueToAdd.Name);
valueToAdd.PathAndIcons.Add(new AkWwiseProjectData.PathElement(valueToAdd.Name, AkWwiseProjectData.WwiseObjectType.EVENT));
AkWwiseProjectInfo.GetData().EventWwu[in_wwuIndex].List.Add(valueToAdd);
break;
case "SoundBanks":
valueToAdd.Path = System.IO.Path.Combine(in_currentPathInProj, valueToAdd.Name);
valueToAdd.PathAndIcons.Add(new AkWwiseProjectData.PathElement(valueToAdd.Name, AkWwiseProjectData.WwiseObjectType.SOUNDBANK));
AkWwiseProjectInfo.GetData().BankWwu[in_wwuIndex].List.Add(valueToAdd);
break;
case "Master-Mixer Hierarchy":
valueToAdd.Path = in_currentPathInProj;
AkWwiseProjectInfo.GetData().AuxBusWwu[in_wwuIndex].List.Add(valueToAdd);
break;
case "Game Parameters":
valueToAdd.Path = System.IO.Path.Combine(in_currentPathInProj, valueToAdd.Name);
valueToAdd.PathAndIcons.Add(new AkWwiseProjectData.PathElement(valueToAdd.Name, AkWwiseProjectData.WwiseObjectType.GAMEPARAMETER));
AkWwiseProjectInfo.GetData().RtpcWwu[in_wwuIndex].List.Add(valueToAdd);
break;
case "Triggers":
valueToAdd.Path = System.IO.Path.Combine(in_currentPathInProj, valueToAdd.Name);
valueToAdd.PathAndIcons.Add(new AkWwiseProjectData.PathElement(valueToAdd.Name, AkWwiseProjectData.WwiseObjectType.TRIGGER));
AkWwiseProjectInfo.GetData().TriggerWwu[in_wwuIndex].List.Add(valueToAdd);
break;
case "Virtual Acoustics":
valueToAdd.Path = System.IO.Path.Combine(in_currentPathInProj, valueToAdd.Name);
valueToAdd.PathAndIcons.Add(new AkWwiseProjectData.PathElement(valueToAdd.Name, AkWwiseProjectData.WwiseObjectType.ACOUSTICTEXTURE));
AkWwiseProjectInfo.GetData().AcousticTextureWwu[in_wwuIndex].List.Add(valueToAdd);
break;
}
in_reader.Read();
}
else if (in_type.RootDirectoryName == "States" || in_type.RootDirectoryName == "Switches")
{
var XmlElement = System.Xml.Linq.XNode.ReadFrom(in_reader) as System.Xml.Linq.XElement;
AkWwiseProjectData.GroupValue valueToAdd = new AkWwiseProjectData.GroupValue();
AkWwiseProjectData.WwiseObjectType SubElemIcon;
valueToAdd.Name = XmlElement.Attribute("Name").Value;
valueToAdd.Guid = new System.Guid(XmlElement.Attribute("ID").Value).ToByteArray();
valueToAdd.ID = (int)AkUtilities.ShortIDGenerator.Compute(valueToAdd.Name);
valueToAdd.Path = System.IO.Path.Combine(in_currentPathInProj, valueToAdd.Name);
valueToAdd.PathAndIcons = new List <AkWwiseProjectData.PathElement>(in_pathAndIcons);
if (in_type.RootDirectoryName == "States")
{
SubElemIcon = AkWwiseProjectData.WwiseObjectType.STATE;
valueToAdd.PathAndIcons.Add(new AkWwiseProjectData.PathElement(valueToAdd.Name, AkWwiseProjectData.WwiseObjectType.STATEGROUP));
}
else
{
SubElemIcon = AkWwiseProjectData.WwiseObjectType.SWITCH;
valueToAdd.PathAndIcons.Add(new AkWwiseProjectData.PathElement(valueToAdd.Name, AkWwiseProjectData.WwiseObjectType.SWITCHGROUP));
}
var ChildrenList = System.Xml.Linq.XName.Get("ChildrenList");
var ChildElem = System.Xml.Linq.XName.Get(in_type.ChildElementName);
var ChildrenElement = XmlElement.Element(ChildrenList);
if (ChildrenElement != null)
{
foreach (var element in ChildrenElement.Elements(ChildElem))
{
if (element.Name == in_type.ChildElementName)
{
string elementName = element.Attribute("Name").Value;
valueToAdd.values.Add(elementName);
valueToAdd.ValueGuids.Add(new AkWwiseProjectData.ByteArrayWrapper(new System.Guid(element.Attribute("ID").Value).ToByteArray()));
valueToAdd.valueIDs.Add((int)AkUtilities.ShortIDGenerator.Compute(elementName));
valueToAdd.ValueIcons.Add(new AkWwiseProjectData.PathElement(elementName, SubElemIcon));
}
}
}
if (in_type.RootDirectoryName == "States")
{
AkWwiseProjectInfo.GetData().StateWwu[in_wwuIndex].List.Add(valueToAdd);
}
else
{
AkWwiseProjectInfo.GetData().SwitchWwu[in_wwuIndex].List.Add(valueToAdd);
}
}
else
{
Debug.LogError("WwiseUnity: Unknown asset type in WWU parser");
}
}
int RecurseWorkUnit(AssetType in_type, System.IO.FileInfo in_workUnit, string in_currentPathInProj, string in_currentPhysicalPath, LinkedList <AkWwiseProjectData.PathElement> in_pathAndIcons, string in_parentPhysicalPath = "")
{
m_WwuToProcess.Remove(in_workUnit.FullName);
System.Xml.XmlReader reader = null;
int wwuIndex = -1;
try
{
//Progress bar stuff
string msg = "Parsing Work Unit " + in_workUnit.Name;
EditorUtility.DisplayProgressBar(s_progTitle, msg, (float)m_currentWwuCnt / (float)m_totWwuCnt);
m_currentWwuCnt++;
in_currentPathInProj = System.IO.Path.Combine(in_currentPathInProj, System.IO.Path.GetFileNameWithoutExtension(in_workUnit.Name));
in_pathAndIcons.AddLast(new AkWwiseProjectData.PathElement(System.IO.Path.GetFileNameWithoutExtension(in_workUnit.Name), AkWwiseProjectData.WwiseObjectType.WORKUNIT));
string WwuPhysicalPath = System.IO.Path.Combine(in_currentPhysicalPath, in_workUnit.Name);
AkWwiseProjectData.WorkUnit wwu = null;
ReplaceWwuEntry(WwuPhysicalPath, in_type, out wwu, out wwuIndex);
wwu.ParentPhysicalPath = in_parentPhysicalPath;
wwu.PhysicalPath = WwuPhysicalPath;
wwu.Guid = "";
wwu.SetLastTime(System.IO.File.GetLastWriteTime(in_workUnit.FullName));
reader = System.Xml.XmlReader.Create(in_workUnit.FullName);
reader.MoveToContent();
reader.Read();
while (!reader.EOF && reader.ReadState == System.Xml.ReadState.Interactive)
{
if (reader.NodeType == System.Xml.XmlNodeType.Element && reader.Name.Equals("WorkUnit"))
{
if (wwu.Guid.Equals(""))
{
wwu.Guid = reader.GetAttribute("ID");
}
string persistMode = reader.GetAttribute("PersistMode");
if (persistMode == "Reference")
{
// ReadFrom advances the reader
var matchedElement = System.Xml.Linq.XNode.ReadFrom(reader) as System.Xml.Linq.XElement;
string newWorkUnitPath = System.IO.Path.Combine(in_workUnit.Directory.FullName, matchedElement.Attribute("Name").Value + ".wwu");
var newWorkUnit = new System.IO.FileInfo(newWorkUnitPath);
// Parse the referenced Work Unit
if (m_WwuToProcess.Contains(newWorkUnit.FullName))
{
RecurseWorkUnit(in_type, newWorkUnit, in_currentPathInProj, in_currentPhysicalPath, in_pathAndIcons, WwuPhysicalPath);
}
}
else
{
// If the persist mode is "Standalone" or "Nested", it means the current XML tag
// is the one corresponding to the current file. We can ignore it and advance the reader
reader.Read();
}
}
else if (reader.NodeType == System.Xml.XmlNodeType.Element && reader.Name.Equals("AuxBus"))
{
in_currentPathInProj = System.IO.Path.Combine(in_currentPathInProj, reader.GetAttribute("Name"));
in_pathAndIcons.AddLast(new AkWwiseProjectData.PathElement(reader.GetAttribute("Name"), AkWwiseProjectData.WwiseObjectType.AUXBUS));
bool isEmpty = reader.IsEmptyElement;
AddElementToList(in_currentPathInProj, reader, in_type, in_pathAndIcons, wwuIndex);
if (isEmpty)
{
in_currentPathInProj = in_currentPathInProj.Remove(in_currentPathInProj.LastIndexOf(System.IO.Path.DirectorySeparatorChar));
in_pathAndIcons.RemoveLast();
}
}
// Busses and folders act the same for the Hierarchy: simply add them to the path
else if (reader.NodeType == System.Xml.XmlNodeType.Element && (reader.Name.Equals("Folder") || reader.Name.Equals("Bus")))
{
//check if node has children
if (!reader.IsEmptyElement)
{
// Add the folder/bus to the path
in_currentPathInProj = System.IO.Path.Combine(in_currentPathInProj, reader.GetAttribute("Name"));
if (reader.Name.Equals("Folder"))
{
in_pathAndIcons.AddLast(new AkWwiseProjectData.PathElement(reader.GetAttribute("Name"), AkWwiseProjectData.WwiseObjectType.FOLDER));
}
else if (reader.Name.Equals("Bus"))
{
in_pathAndIcons.AddLast(new AkWwiseProjectData.PathElement(reader.GetAttribute("Name"), AkWwiseProjectData.WwiseObjectType.BUS));
}
}
// Advance the reader
reader.Read();
}
else if (reader.NodeType == System.Xml.XmlNodeType.EndElement && (reader.Name.Equals("Folder") || reader.Name.Equals("Bus") || reader.Name.Equals("AuxBus")))
{
// Remove the folder/bus from the path
in_currentPathInProj = in_currentPathInProj.Remove(in_currentPathInProj.LastIndexOf(System.IO.Path.DirectorySeparatorChar));
in_pathAndIcons.RemoveLast();
// Advance the reader
reader.Read();
}
else if (reader.NodeType == System.Xml.XmlNodeType.Element && reader.Name.Equals(in_type.XmlElementName))
{
// Add the element to the list
AddElementToList(in_currentPathInProj, reader, in_type, in_pathAndIcons, wwuIndex);
}
else
{
reader.Read();
}
}
// Sort the newly populated Wwu alphabetically
SortWwu(in_type.RootDirectoryName, wwuIndex);
}
catch (System.Exception e)
{
Debug.LogError(e.ToString());
wwuIndex = -1;
}
if (reader != null)
{
reader.Close();
}
in_pathAndIcons.RemoveLast();
return(wwuIndex);
}
public override void ReadXml(System.Xml.XmlReader reader)
{
using (System.Xml.XmlReader subTree = reader.ReadSubtree()) {
subTree.Read();
string tmp = subTree.ReadOuterXml();
//seek for template tag
using (XmlReader xr = new XmlTextReader(tmp, XmlNodeType.Element, null)) {
xr.Read();
base.ReadXml(xr);
}
//process content
using (XmlReader xr = new XmlTextReader(tmp, XmlNodeType.Element, null)) {
xr.Read(); //skip current node
while (!xr.EOF)
{
xr.Read(); //read first child
if (!xr.IsStartElement())
{
continue;
}
if (xr.Name == "Template")
{
xr.Skip();
if (!xr.IsStartElement())
{
continue;
}
}
Type t = Type.GetType("Crow." + xr.Name);
if (t == null)
{
Assembly a = Assembly.GetEntryAssembly();
foreach (Type expT in a.GetExportedTypes())
{
if (expT.Name == xr.Name)
{
t = expT;
break;
}
}
}
if (t == null)
{
throw new Exception(xr.Name + " type not found");
}
GraphicObject go = (GraphicObject)Activator.CreateInstance(t);
(go as IXmlSerializable).ReadXml(xr);
Content = go;
xr.Read(); //closing tag
}
}
}
}
private CategoryDirectory ReadResult(System.Xml.XmlReader reader, bool securityTrimmingEnabled)
{
CategoryDirectory result = null;
if (reader.NodeType == System.Xml.XmlNodeType.Element)
{
if (reader.LocalName == "category" && reader.NamespaceURI == ns)
{
if (DeterminVisible(reader) && DeterminSecure(securityTrimmingEnabled, reader))
{
result = new CategoryDirectory();
if (reader.MoveToAttribute("name"))
{
result.Name = reader.Value;
}
if (reader.MoveToAttribute("title"))
{
result.Title = reader.Value;
}
reader.MoveToElement();
}
}
else if (reader.LocalName == "item" && reader.NamespaceURI == ns)
{
if (DeterminVisible(reader) && DeterminSecure(securityTrimmingEnabled, reader))
{
result = new CategoryLink();
if (reader.MoveToAttribute("name"))
{
result.Name = reader.Value;
}
if (reader.MoveToAttribute("title"))
{
result.Title = reader.Value;
}
if (reader.MoveToAttribute("group"))
{
((CategoryLink)result).Group = reader.ReadContentAsInt();
}
if (reader.MoveToAttribute("href"))
{
((CategoryLink)result).Url = reader.Value;
}
if (reader.MoveToAttribute("role"))
{
((CategoryLink)result).Role = reader.Value;
}
if (reader.MoveToAttribute("feature"))
{
((CategoryLink)result).Feature = reader.Value;
}
}
}
else if (reader.LocalName == "group" && reader.NamespaceURI == ns)
{
if (DeterminVisible(reader) && DeterminSecure(securityTrimmingEnabled, reader))
{
result = new CategoryGroup();
if (reader.MoveToAttribute("name"))
{
result.Name = reader.Value;
}
if (reader.MoveToAttribute("title"))
{
result.Title = reader.Value;
}
reader.MoveToElement();
ArrayList list = new ArrayList();
ReadSubItems(reader, list, securityTrimmingEnabled);
((CategoryGroup)result).Categories = (CategoryDirectory[])list.ToArray(typeof(CategoryDirectory));
}
else
{
var level = reader.Depth;
while (reader.Read() && reader.Depth > level)
{
reader.Skip(); //跳过其任何子节点
}
}
}
}
reader.MoveToElement();
return(result);
}
/// <summary>
/// Set the data of the object from its XML representation.
/// </summary>
/// <param name="reader">The <see cref="T:System.Xml.XmlReader" />-stream containing the data for ther object.</param>
public void ReadXml(System.Xml.XmlReader reader)
{
if (reader.LocalName == GetType().Name)
{
while (reader.Read())
{
switch (reader.LocalName)
{
case "Name":
Name = reader.ReadString();
break;
case "Curve":
string XmlData = reader.ReadString();
CurveTypeEnum CurveType = CurveTypeEnum.Linear;
if (Enum.TryParse(XmlData, true, out CurveType))
{
Data = BuildCurve(CurveType);
}
else
{
string[] V = XmlData.Split(new char[] { ',' });
if (V.Length == 256)
{
int Cnt = V.Count(Value => !Value.IsUInt() || Value.ToUInt() > 255);
if (Cnt == 0)
{
for (int i = 0; i < 255; i++)
{
Data[i] = (byte)V[i].ToInteger();
}
}
else
{
throw new Exception("{0} value(s) in the curve data for fading curve {1} are not numeric values between 0-255. Supplied data was {2}.".Build(Cnt, Name, XmlData));
}
}
else
{
if (V.Length > 1)
{
throw new Exception("Cant parse data for curve {0}. 256 values are required, but {1} values have been found. Supplied data was {2}.".Build(Name, V.Length, XmlData));
}
else
{
throw new Exception("Cant parse data for curve {0}. One of the values from the CurveTypeEnum or 256 values between 0-255 are expected. Supplied data was: {1}.".Build(Name, XmlData));
}
}
}
break;
default:
break;
}
}
}
}
public override int Read(System.Xml.XmlReader reader)
{
int sequence = 0;
while (reader.Read())
{
if ((reader.NodeType == XmlNodeType.Comment) ||
(reader.NodeType == XmlNodeType.Whitespace))
{
continue;
}
if (sequence == 0)
{
if ((string.Compare(reader.Name, _InnerName) != 0) ||
(reader.NodeType != XmlNodeType.Element) ||
(reader.IsEmptyElement))
{
if (string.Compare(_InnerName, "seriesAuthor") == 0)
{
if ((string.Compare(reader.Name, Name) == 0) &&
(reader.NodeType == XmlNodeType.EndElement))
{
_InnerName = null;
return(0);
}
int ret = aECGElement.ReadOne(this, reader);
if (ret != 0)
{
return((ret > 0) ? 2 + ret : ret);
}
continue;
}
else
{
return(1);
}
}
sequence++;
}
else if (sequence == 1)
{
int ret = aECGElement.ReadOne(this, reader);
if (ret != 0)
{
return((ret > 0) ? 2 + ret : ret);
}
if ((string.Compare(reader.Name, _InnerName) == 0) &&
(reader.NodeType == XmlNodeType.EndElement))
{
sequence++;
}
}
else
{
if ((string.Compare(reader.Name, Name) != 0) ||
(reader.NodeType != XmlNodeType.EndElement) ||
reader.IsEmptyElement)
{
return(2);
}
return(0);
}
}
return(-1);
}
private void ReadCamera(ref XmlReadState state, System.Xml.XmlReader node)
{
node.Read();
var width = node.GetAttribute("width");
var height = node.GetAttribute("height");
var type = node.GetAttribute("type");
var fov = node.GetAttribute("fov");
var nearclip = node.GetAttribute("nearclip");
var farclip = node.GetAttribute("farclip");
var aperturesize = node.GetAttribute("aperturesize");
var focaldistance = node.GetAttribute("focaldistance");
var shuttertime = node.GetAttribute("shuttertime");
var panorama_type = node.GetAttribute("panorama_type");
var fisheye_fov = node.GetAttribute("fisheye_fov");
var fisheye_lens = node.GetAttribute("fisheye_lens");
var sensorwidth = node.GetAttribute("sensorwidth");
var sensorheight = node.GetAttribute("sensorheight");
if (!string.IsNullOrEmpty(width) && !string.IsNullOrEmpty(height))
{
Client.Scene.Camera.Size = new Size(int.Parse(width), int.Parse(height));
}
if (!string.IsNullOrEmpty(type))
{
CameraType camera_type;
if (Enum.TryParse(type, true, out camera_type))
{
Client.Scene.Camera.Type = camera_type;
}
}
if (!string.IsNullOrEmpty(panorama_type))
{
PanoramaType panoramatype;
if (Enum.TryParse(panorama_type, true, out panoramatype))
{
Client.Scene.Camera.PanoramaType = panoramatype;
}
}
if (!string.IsNullOrEmpty(fov))
{
Client.Scene.Camera.Fov = float.Parse(fov, NumberFormatInfo);
}
if (!string.IsNullOrEmpty(nearclip))
{
Client.Scene.Camera.NearClip = float.Parse(nearclip, NumberFormatInfo);
}
if (!string.IsNullOrEmpty(farclip))
{
Client.Scene.Camera.FarClip = float.Parse(farclip, NumberFormatInfo);
}
if (!string.IsNullOrEmpty(aperturesize))
{
Client.Scene.Camera.ApertureSize = float.Parse(aperturesize, NumberFormatInfo);
}
if (!string.IsNullOrEmpty(focaldistance))
{
Client.Scene.Camera.FocalDistance = float.Parse(focaldistance, NumberFormatInfo);
}
if (!string.IsNullOrEmpty(shuttertime))
{
Client.Scene.Camera.ShutterTime = float.Parse(shuttertime, NumberFormatInfo);
}
if (!string.IsNullOrEmpty(fisheye_fov))
{
Client.Scene.Camera.FishEyeFov = float.Parse(fisheye_fov, NumberFormatInfo);
}
if (!string.IsNullOrEmpty(fisheye_lens))
{
Client.Scene.Camera.FishEyeLens = float.Parse(fisheye_lens, NumberFormatInfo);
}
if (!string.IsNullOrEmpty(sensorwidth))
{
Client.Scene.Camera.SensorWidth = float.Parse(sensorwidth, NumberFormatInfo);
}
if (!string.IsNullOrEmpty(sensorheight))
{
Client.Scene.Camera.SensorHeight = float.Parse(sensorheight, NumberFormatInfo);
}
Client.Scene.Camera.Matrix = state.Transform;
Client.Scene.Camera.ComputeAutoViewPlane();
Client.Scene.Camera.Update();
}
private void LoadAttributes(System.Xml.XmlReader reader)
{
while (reader.MoveToNextAttribute())
{
switch (reader.LocalName)
{
case "name":
Description = reader.Value;
break;
case "place_id":
PlaceId = reader.Value;
break;
case "place_url":
PlaceUrl = reader.Value;
break;
case "place_type_id":
PlaceType = (PlaceType)reader.ReadContentAsInt();
break;
case "place_type":
PlaceType = (PlaceType)Enum.Parse(typeof(PlaceType), reader.Value, true);
break;
case "woeid":
WoeId = reader.Value;
break;
case "woe_name":
WoeName = reader.Value;
break;
case "latitude":
Latitude = reader.ReadContentAsDouble();
break;
case "longitude":
Longitude = reader.ReadContentAsDouble();
break;
case "accuracy":
Accuracy = (GeoAccuracy)reader.ReadContentAsInt();
break;
case "context":
Context = (GeoContext)reader.ReadContentAsInt();
break;
case "timezone":
TimeZone = reader.Value;
break;
case "has_shapedata":
HasShapeData = reader.Value == "1";
break;
default:
UtilityMethods.CheckParsingException(reader);
break;
}
}
reader.Read();
}
public string[] ReadXML(string txt, string number)
{
string[] StrRecivedMessage = new string[2];
int i = 0;
System.Xml.XmlReader objXMLReader = System.Xml.XmlReader.Create(new System.IO.StringReader(txt));
string element = string.Empty;
string strSMS = string.Empty;
string strMessage = string.Empty;
string strTmp = string.Empty;
bool blnFindNo = false;
try
{
while (objXMLReader.Read())
{
switch (objXMLReader.NodeType)
{
case XmlNodeType.Element:
element = objXMLReader.Name;
if (objXMLReader.HasAttributes)
{
while (objXMLReader.MoveToNextAttribute())
{
if (element == "batch")
{
}
}
}
break;
case XmlNodeType.Text:
if (element == "status")
{
//i = i;
StrRecivedMessage[i] = objXMLReader.Value;
}
if (element == "time")
{
i = i + 1;
StrRecivedMessage[i] = objXMLReader.Value;
break;
}
break;
case XmlNodeType.CDATA:
if (element == "destAddr")
{
if (objXMLReader.Value != "+98" + number.Substring(1))
{
continue;
}
else
{
blnFindNo = true;
}
i = i + 1;
StrRecivedMessage[i] = objXMLReader.Value;
}
if (element == "origAddr")
{
i = i + 1;
StrRecivedMessage[i] = objXMLReader.Value;
}
else if (element == "message")
{
strTmp = objXMLReader.Value;
}
break;
}
}
;
return(StrRecivedMessage);
}
catch (Exception)
{
throw;
}
}
private void ReadLight(ref XmlReadState state, System.Xml.XmlReader node)
{
node.Read();
Light light = new Light(Client, state.Scene, state.Shader);
int intval = 0;
float floatval = 0.0f;
float4 float4val = new float4(0.0f);
bool boolval = false;
if (Utilities.Instance.get_int(ref intval, node.GetAttribute("type")))
{
light.Type = (LightType)intval;
}
if (Utilities.Instance.get_float(ref floatval, node.GetAttribute("spot_angle")))
{
light.SpotAngle = floatval;
}
if (Utilities.Instance.get_float(ref floatval, node.GetAttribute("spot_smooth")))
{
light.SpotSmooth = floatval;
}
if (Utilities.Instance.get_float(ref floatval, node.GetAttribute("sizeu")))
{
light.SizeU = floatval;
}
if (Utilities.Instance.get_float(ref floatval, node.GetAttribute("sizev")))
{
light.SizeV = floatval;
}
if (Utilities.Instance.get_float4(float4val, node.GetAttribute("axisu")))
{
light.AxisU = float4val;
}
if (Utilities.Instance.get_float4(float4val, node.GetAttribute("axisv")))
{
light.AxisV = float4val;
}
/* @todo
* if(Utilities.Instance.get_bool(ref boolval, node.GetAttribute("is_portal")))
* {
* }
*/
if (Utilities.Instance.get_float(ref floatval, node.GetAttribute("size")))
{
light.Size = floatval;
}
if (Utilities.Instance.get_float4(float4val, node.GetAttribute("dir")))
{
light.Direction = float4val;
}
if (Utilities.Instance.get_float4(float4val, node.GetAttribute("P")))
{
light.Location = state.Transform * float4val;
}
if (Utilities.Instance.get_bool(ref boolval, node.GetAttribute("cast_shadow")))
{
light.CastShadow = boolval;
}
if (Utilities.Instance.get_bool(ref boolval, node.GetAttribute("use_mis")))
{
light.UseMis = boolval;
}
if (Utilities.Instance.get_int(ref intval, node.GetAttribute("samples")))
{
light.Samples = (uint)intval;
}
if (Utilities.Instance.get_int(ref intval, node.GetAttribute("max_bounces")))
{
light.MaxBounces = (uint)intval;
}
/* @todo add ray visibility to light API
* if(Utilities.Instance.get_bool(ref boolval, node.GetAttribute("use_diffuse")))
* {
* light.UseDiffuse = boolval;
* }
* if(Utilities.Instance.get_bool(ref boolval, node.GetAttribute("use_glossy")))
* {
* light.UseGlossy = boolval;
* }
* if(Utilities.Instance.get_bool(ref boolval, node.GetAttribute("use_transmission")))
* {
* light.UseTransmission = boolval;
* }
* if(Utilities.Instance.get_bool(ref boolval, node.GetAttribute("use_scatter")))
* {
* light.UseScatter = boolval;
* }
*/
light.TagUpdate();
}
public override int Read(System.Xml.XmlReader reader)
{
int sequence = 0;
while (reader.Read())
{
if ((reader.NodeType == XmlNodeType.Comment) ||
(reader.NodeType == XmlNodeType.Whitespace))
{
continue;
}
if (sequence == 0)
{
if ((string.Compare(reader.Name, Name) == 0) ||
(reader.NodeType == XmlNodeType.EndElement))
{
return(0);
}
if ((string.Compare(reader.Name, _InnerName) != 0) ||
(reader.NodeType != XmlNodeType.Element))
{
return(1);
}
sequence += reader.IsEmptyElement ? 2 : 1;
}
else if (sequence == 1)
{
if (string.Compare(reader.Name, aECGSequence.SequenceName) == 0)
{
aECGSequence seq = new aECGSequence();
int ret = seq.Read(reader);
if (ret != 0)
{
return((ret > 0) ? 1 + ret : ret);
}
_Sets.Add(seq);
}
else if ((string.Compare(reader.Name, _InnerName) == 0) &&
(reader.NodeType == XmlNodeType.EndElement))
{
sequence--;
}
else
{
int ret = aECGElement.ReadOne(this, reader);
if (ret != 0)
{
return((ret > 0) ? 1 + ret : ret);
}
}
}
}
return(-1);
}
private void ReadMesh(ref XmlReadState state, System.Xml.XmlReader node)
{
node.Read();
var name = node.GetAttribute("name");
if (!state.Silent)
{
Console.WriteLine("Shader: {0}", node.GetAttribute("name"));
}
if (string.IsNullOrEmpty(name))
{
throw new MissingFieldException("<mesh> is missing 'name'");
}
var P = node.GetAttribute("P");
var UV = node.GetAttribute("UV");
var nverts = node.GetAttribute("nverts");
var verts = node.GetAttribute("verts");
if (!state.Silent)
{
Console.WriteLine("{0}", node);
}
var has_uv = !string.IsNullOrEmpty(UV);
float[] uvfloats = null;
if (has_uv)
{
uvfloats = Utilities.Instance.parse_floats(UV);
}
var pfloats = Utilities.Instance.parse_floats(P);
var nvertsints = Utilities.Instance.parse_ints(nverts);
var vertsints = Utilities.Instance.parse_ints(verts);
//var ob = new ccl.Object(Client) { Transform = state.Transform };
var me = new Mesh(Client, state.Shader);
//ob.Mesh = me;
meshes.Add(name, me);
me.SetVerts(ref pfloats);
var index_offset = 0;
/* count triangles */
var fc = nvertsints.Aggregate(0, (total, next) =>
next == 4 ? total + 2 : total + 1);
float[] uvs = null;
if (has_uv)
{
uvs = new float[fc * 3 * 2];
}
var uvoffs = 0;
foreach (var t in nvertsints)
{
for (var j = 0; j < t - 2; j++)
{
var v0 = vertsints[index_offset];
var v1 = vertsints[index_offset + j + 1];
var v2 = vertsints[index_offset + j + 2];
if (has_uv)
{
uvs[uvoffs] = uvfloats[index_offset * 2];
uvs[uvoffs + 1] = uvfloats[index_offset * 2 + 1];
uvs[uvoffs + 2] = uvfloats[(index_offset + j + 1) * 2];
uvs[uvoffs + 3] = uvfloats[(index_offset + j + 1) * 2 + 1];
uvs[uvoffs + 4] = uvfloats[(index_offset + j + 2) * 2];
uvs[uvoffs + 5] = uvfloats[(index_offset + j + 2) * 2 + 1];
uvoffs += 6;
}
me.AddTri((uint)v0, (uint)v1, (uint)v2, state.Shader, state.Smooth);
}
index_offset += t;
}
if (has_uv)
{
me.SetUvs(ref uvs);
}
}
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 virtual void ReadXml(System.Xml.XmlReader reader)
{
string msg = null;
reader.Read();
string value = reader.ReadContentAsString();
if (value == null || value.Length != CommonUtilities.XmlCharacterArray.Length)
{
msg = "bad write data in WriteChars ";
if (value == null)
{
msg += " value == null";
}
else
{
msg += String.Format("original size {0} output size {1}", value.Length, CommonUtilities.XmlCharacterArray.Length);
}
throw new MyException(msg);
}
int errorCount = 0;
string firstMsg = null;
for (int i = 0; i < CommonUtilities.XmlCharacterArray.Length; i++)
{
char originalChar = CommonUtilities.XmlCharacterArray[i];
if (CommonUtilities.XmlCharacterArray[i] != value[i])
{
// special case: XML reader/writer might normalize \r or \r\n to \n (http://www.w3.org/TR/REC-xml#sec-line-ends)
if (value[i] == '\n' && CommonUtilities.XmlCharacterArray[i] == '\r')
{
// do nothing
}
else
{
errorCount++;
if (firstMsg == null)
{
firstMsg = String.Format("Error in string, location = {0}, originalCharacter code = {1}, return character code {2}",
i, (int)CommonUtilities.XmlCharacterArray[i], (int)value[i]);
}
}
}
}
if (errorCount > 0)
{
throw new MyException(firstMsg);
}
int counter = 0;
const int NODES_AT_END = 0;
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 override int Read(System.Xml.XmlReader reader)
{
if (reader.IsEmptyElement)
{
return(1);
}
Type = reader.GetAttribute("xsi:type");
while (reader.Read())
{
if ((reader.NodeType == XmlNodeType.Comment) ||
(reader.NodeType == XmlNodeType.Whitespace))
{
continue;
}
if ((string.Compare(reader.Name, "digits") == 0) &&
(reader.NodeType == XmlNodeType.Element) &&
!reader.IsEmptyElement)
{
reader.Read();
int i = 0;
string[] temp = null;
try
{
temp = SplitValues(reader.Value, "-?[0-9]+");
Digits = new short[temp.Length];
for (; i < Digits.Length; i++)
{
Digits[i] = short.Parse(temp[i], System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture.NumberFormat);
}
}
catch
{
return(3);
}
reader.Read();
}
else if (reader.IsEmptyElement)
{
int ret = aECGElement.ReadOne(this, reader);
if (ret != 0)
{
return((ret > 0) ? 3 + ret : ret);
}
}
else if ((string.Compare(reader.Name, Name) == 0) &&
(reader.NodeType == XmlNodeType.EndElement))
{
return(0);
}
else
{
break;
}
}
return(2);
}
private void ReadSubElements(System.Xml.XmlReader reader, string[] parts, int i, ArrayList result, bool securityTrimmingEnabled)
{
string nextName = parts[i];
int depth = reader.Depth + 1;
while (reader.Read())
{
if (reader.Depth == depth)
{
switch (reader.NodeType)
{
case System.Xml.XmlNodeType.Attribute:
case System.Xml.XmlNodeType.CDATA:
case System.Xml.XmlNodeType.Comment:
case System.Xml.XmlNodeType.Whitespace:
continue;
case System.Xml.XmlNodeType.EndElement:
break;
case System.Xml.XmlNodeType.Element:
break;
default:
throw new System.Xml.XmlException("读取到错误的节点");
}
if (reader.NodeType == System.Xml.XmlNodeType.Element)
{
bool hit = false;
if (reader.MoveToAttribute("name"))
{
hit = reader.Value == nextName;
if (hit)
{
hit = DeterminVisible(reader);
}
reader.MoveToElement();
}
if (hit)
{
i++;
if (i < parts.Length)
{
ReadSubElements(reader, parts, i, result, securityTrimmingEnabled);
}
else
{
ReadSubItems(reader, result, securityTrimmingEnabled);
}
break;
}
else
{
//reader.Skip();
}
}
}
else if (reader.Depth > depth)
{
reader.Skip();
}
else
{
break;
}
}
}
/// <summary>
/// Serializes the XML to an instance.
/// </summary>
/// <param name="reader"></param>
void IFlickrParsable.Load(System.Xml.XmlReader reader)
{
while (reader.MoveToNextAttribute())
{
switch (reader.LocalName)
{
case "name":
Description = reader.Value;
break;
case "place_id":
PlaceId = reader.Value;
break;
case "place_url":
PlaceUrl = reader.Value;
break;
case "place_type_id":
PlaceType = (PlaceType)reader.ReadContentAsInt();
break;
case "place_type":
PlaceType = (PlaceType)Enum.Parse(typeof(PlaceType), reader.Value, true);
break;
case "woeid":
WoeId = reader.Value;
break;
case "woe_name":
WoeName = reader.Value;
break;
case "latitude":
Latitude = reader.ReadContentAsDouble();
break;
case "longitude":
Longitude = reader.ReadContentAsDouble();
break;
case "timezone":
TimeZone = reader.Value;
break;
case "photo_count":
PhotoCount = reader.ReadContentAsInt();
break;
default:
UtilityMethods.CheckParsingException(reader);
break;
}
}
reader.Read();
while (reader.NodeType != XmlNodeType.EndElement)
{
if (reader.NodeType == XmlNodeType.Text)
{
Description = reader.ReadContentAsString();
}
else
{
switch (reader.LocalName)
{
default:
UtilityMethods.CheckParsingException(reader);
break;
}
}
}
reader.Read();
}
