public static async void CreateAlbumXml()
{
//String _dropboxURL = MAIN + "&token=" + Uri.EscapeDataString(Token);
//HttpResponseMessage _response = null;
//HttpClient httpClient = new HttpClient();
StorageFile _template = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///appdata/templateCreateAlbum.xml"));
XmlLoadSettings _settings = new XmlLoadSettings();
XmlLoadSettings loadSettings = new XmlLoadSettings();
loadSettings.ProhibitDtd = false;
loadSettings.ResolveExternals = false;
XmlDocument doc = await XmlDocument.LoadFromFileAsync(_template);
var _section = doc.CreateAttribute("test2");
// set location
IXmlNode _group = doc.GetElementsByTagName("gphoto:location").Item(0);
_group.ChildNodes.First <IXmlNode>().NodeValue = "NZ";
StorageFile file_out = await ApplicationData.Current.LocalFolder.CreateFileAsync("test.xml", CreationCollisionOption.ReplaceExisting);
await doc.SaveToFileAsync(file_out);
}
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
rootPage = MainPage.Current;
file = "status.xml";
StorageFile storageFile = await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFileAsync(file);
XmlLoadSettings loadSettings = new XmlLoadSettings();
loadSettings.ProhibitDtd = false;
loadSettings.ResolveExternals = false;
doc = await XmlDocument.LoadFromFileAsync(storageFile, loadSettings);
try
{
var results = doc.SelectNodes("descendant::result");
int num_results = 1;
foreach (var result in results)
{
String id = results[num_results - 1].SelectSingleNode("descendant::id").FirstChild.NodeValue.ToString();
String status = results[num_results - 1].SelectSingleNode("descendant::status").FirstChild.NodeValue.ToString();
listBox.Items.Add("ID: " + id + " " + status);
num_results += 1;
}
if (num_results == 1)
{
listBox.Items.Add("You don't have pending jobs.");
}
}
catch (Exception)
{
listBox.Items.Add("You don't have pending jobs.");
}
}
/// <summary>
/// 选取Xml文件
/// </summary>
public static async Task <XmlDocument> LoadXmlFile(string folder, string file)
{
StorageFolder storageFolder = await ApplicationData.Current.LocalFolder.GetFolderAsync(folder);
StorageFile storageFile = await storageFolder.GetFileAsync(file);
XmlLoadSettings loadSettings = new XmlLoadSettings();
loadSettings.ProhibitDtd = false;
loadSettings.ResolveExternals = false;
return(await XmlDocument.LoadFromFileAsync(storageFile, loadSettings));
}
public async Task <XmlDocument> LoadDatabase()
{
var loadSettings = new XmlLoadSettings
{
ProhibitDtd = false,
ResolveExternals = true
};
var folder = await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFolderAsync("Database");
var file = await folder.GetFileAsync("database.xml");
return(await Windows.Data.Xml.Dom.XmlDocument.LoadFromFileAsync(file, loadSettings));
}
public IAsyncOperation <IList <ItemKey> > NewRawAsync(string xml)
{
// For new items there should not be any item keys,
// created, or updated dates because these will be new items
var loadSettings = new XmlLoadSettings {
ProhibitDtd = true
};
var xmlDoc = new XmlDocument();
xmlDoc.LoadXml(xml, loadSettings);
// Do not convert these to a foreach loop since the collection
// is modified by the remove
XmlNodeList nodes = xmlDoc.GetElementsByTagName("thing-id");
for (int i = (int)nodes.Length - 1; i >= 0; i--)
{
IXmlNode node = nodes[i];
node.ParentNode.RemoveChild(node);
}
nodes = xmlDoc.GetElementsByTagName("updated");
for (int i = (int)nodes.Length - 1; i >= 0; i--)
{
IXmlNode node = nodes[i];
node.ParentNode.RemoveChild(node);
}
nodes = xmlDoc.GetElementsByTagName("created");
for (int i = (int)nodes.Length - 1; i >= 0; i--)
{
IXmlNode node = nodes[i];
node.ParentNode.RemoveChild(node);
}
// Our put things xml does not support <things> or <ArrayOfThings>
// We just want to serialize <thing> repeatedly
nodes = xmlDoc.GetElementsByTagName("thing");
var parsedXml = new StringBuilder();
for (int i = 0; i < nodes.Length; i++)
{
parsedXml.Append(nodes[i].GetXml());
}
return(PutRawAsync(parsedXml.ToString()));
}
// Stub function for testing
public static async Task <XDocument> LoadTestRssXml()
{
StorageFolder storageFolder = await Package.Current.InstalledLocation.GetFolderAsync("Test");
StorageFile storageFile = await storageFolder.GetFileAsync("TestRss.xml");
XmlLoadSettings loadSettings = new XmlLoadSettings();
loadSettings.ProhibitDtd = false;
loadSettings.ResolveExternals = false;
XmlDocument xmlDoc = await XmlDocument.LoadFromFileAsync(storageFile, loadSettings);
XDocument doc = XDocument.Parse(xmlDoc.GetXml());
var rtnTask = Task.Factory.StartNew(() => doc);
return(await rtnTask);
}
private async Task ReadFB2FileStreamAsync(Stream stream)
{
// setup
var readerSettings = new XmlReaderSettings
{
DtdProcessing = DtdProcessing.Ignore
};
var loadSettings = new XmlLoadSettings(readerSettings);
try
{
// reading
FB2File file = await new FB2Reader().ReadAsync(stream, loadSettings);
}
catch (Exception ex)
{
Debug.WriteLine(string.Format("Error loading file : {0}", ex.Message));
}
}
/// <summary>
/// Opens file storage.
/// </summary>
private async void OpenFileStorage()
{
await _threadSemaphore.WaitAsync();
try
{
try
{
_storageFile = await ApplicationData.Current.LocalFolder.GetFileAsync(_fileName);
var xmlSettings = new XmlLoadSettings();
xmlSettings.ElementContentWhiteSpace = true;
_xmlDoc = await XmlDocument.LoadFromFileAsync(_storageFile, xmlSettings);
}
catch (FileNotFoundException)
{
_storageFile = null;
}
catch // If file exists in incorrect format then LoadFromFileAsync throws System.Exception
{
_xmlDoc = null;
}
if (_storageFile == null)
{
_storageFile = await ApplicationData.Current.LocalFolder.CreateFileAsync(_fileName, CreationCollisionOption.OpenIfExists);
}
if (_xmlDoc == null)
{
_xmlDoc = new XmlDocument();
_xmlDoc.AppendChild(_xmlDoc.CreateElement("root"));
}
await _xmlDoc.SaveToFileAsync(_storageFile);
}
finally
{
_threadSemaphore.Release();
}
}
//Prepare book to open
public async Task <FB2File> ReadFb2FileStreamAsync(Stream stream)
{
// setup
var readerSettings = new XmlReaderSettings
{
DtdProcessing = DtdProcessing.Ignore
};
var loadSettings = new XmlLoadSettings(readerSettings);
var file = new FB2File();
try
{
// reading
file = await new FB2Reader().ReadAsync(stream, loadSettings);
}
catch (Exception ex)
{
MessageBox.Show($"Error loading file : {ex.Message}");
}
return(file);
}
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
rootPage = MainPage.Current;
listBox.Items.Add("Index");
StorageFile storageFile;
file = "history.xml";
storageFile = await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFileAsync(file);
XmlLoadSettings loadSettings = new XmlLoadSettings();
loadSettings.ProhibitDtd = false;
loadSettings.ResolveExternals = false;
doc = await XmlDocument.LoadFromFileAsync(storageFile, loadSettings);
var results = doc.SelectNodes("descendant::result");
int num_results = 1;
foreach (var result in results)
{
listBox.Items.Add(num_results.ToString());
num_results += 1;
}
if (num_results > 1) //show the first history result
{
listBox.SelectedIndex = 1;
select_item(0);
}
//rootPage.NotifyUser(doc.InnerText.ToString(), NotifyType.StatusMessage);
}
async private void capture_Click(object sender, RoutedEventArgs e)
{
XmlDocument doc; //doc is history doc
string history_file_xml;
ImageEncodingProperties imgFormat = ImageEncodingProperties.CreateJpeg();
StorageFile file = await KnownFolders.PicturesLibrary.CreateFileAsync("Photo.jpg", CreationCollisionOption.ReplaceExisting);
await captureManager.CapturePhotoToStorageFileAsync(imgFormat, file);
bt_capture.IsEnabled = false;
rootPage.NotifyUser("Done saving images, connecting...", NotifyType.StatusMessage);
StreamSocket socket = new StreamSocket();
HostName hostName = new HostName("rs1008linux01.cloudapp.net");
try {
await socket.ConnectAsync(hostName, "12346");
}
catch (Exception)
{
rootPage.NotifyUser("Error: Host server not available.", NotifyType.ErrorMessage);
return;
}
rootPage.NotifyUser("Connected", NotifyType.StatusMessage);
DataWriter writer = new DataWriter(socket.OutputStream);
rootPage.NotifyUser("Uploading...", NotifyType.StatusMessage);
byte[] data = new byte[1024];
Stream x = await file.OpenStreamForReadAsync();
long file_length = x.Length;
long tail = file_length % 1024;
double offset = 0;
string progress;
try
{
while (file_length > offset)
{
await x.ReadAsync(data, 0, 1024);
offset = offset + 1024;
if (file_length < offset)
{
byte[] temp = new byte[tail];
Array.Copy(data, temp, (int)tail);
writer.WriteBytes(temp);
}
else
{
writer.WriteBytes(data);
}
progress = "Progress: " + (Math.Round(offset / x.Length * 100, 0)).ToString() + "%";
rootPage.NotifyUser(progress, NotifyType.StatusMessage);
await writer.StoreAsync();
await writer.FlushAsync();
}
}
catch (Exception ex)
{
rootPage.NotifyUser(ex.Message, NotifyType.StatusMessage);
return;
}
writer.DetachStream();
x.Dispose();
rootPage.NotifyUser("Uploading finished.", NotifyType.StatusMessage);
byte[] buffer = new byte[128];
Stream results = socket.InputStream.AsStreamForRead();
var memoryStream = new MemoryStream();
results.CopyTo(memoryStream);
buffer = memoryStream.ToArray();
//await socket.InputStream.ReadAsync(buffer.AsBuffer(), 128,InputStreamOptions.ReadAhead);
socket.Dispose();
bt_capture.IsEnabled = true;
concentration = Encoding.UTF8.GetString(buffer) + " nm"; //get concentration result
geolocation.Text = concentration;
rootPage.NotifyUser("Data generated.", NotifyType.StatusMessage);
history_file_xml = "history.xml";
StorageFile storageFile = await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFileAsync(history_file_xml);
XmlLoadSettings loadSettings = new XmlLoadSettings();
loadSettings.ProhibitDtd = false;
loadSettings.ResolveExternals = false;
doc = await XmlDocument.LoadFromFileAsync(storageFile, loadSettings);
var rootnode = doc.SelectSingleNode("results");
IXmlNode child = doc.CreateElement("result");
rootnode.AppendChild(child);
IXmlNode xml_id = doc.CreateElement("id");
xml_id.InnerText = "5";
child.AppendChild(xml_id);
IXmlNode xml_date = doc.CreateElement("date");
xml_date.InnerText = "2016-2-19 4:12:12";
child.AppendChild(xml_date);
IXmlNode xml_location = doc.CreateElement("location");
xml_location.InnerText = cityname;
child.AppendChild(xml_location);
IXmlNode xml_concentration = doc.CreateElement("concentration");
xml_concentration.InnerText = geolocation.Text;
child.AppendChild(xml_concentration);
IXmlNode xml_model = doc.CreateElement("model");
xml_model.InnerText = "Fluoride Ion";
child.AppendChild(xml_model);
//rootPage.NotifyUser(doc.GetXml(), NotifyType.StatusMessage);
await doc.SaveToFileAsync(storageFile);
}
private async Task <bool> GetPackagedFile(string folderName, string fileName, UIElement rootFrame)
{
StorageFolder installFolder = Windows.ApplicationModel.Package.Current.InstalledLocation;
StorageFile file = null;
if (folderName != null)
{
StorageFolder subFolder = await installFolder.GetFolderAsync(folderName);
file = await subFolder.GetFileAsync(fileName);
}
else
{
file = await installFolder.GetFileAsync(fileName);
}
//string text = await Windows.Storage.FileIO.ReadTextAsync(file);
//datafile df = new datafile();
//df = Newtonsoft.Json.JsonConvert.DeserializeObject<datafile>(text);
XmlLoadSettings settings = new XmlLoadSettings()
{
ValidateOnParse = false
};
XmlDocument xmlDoc = await XmlDocument.LoadFromFileAsync(file, settings);
foreach (IXmlNode xmlNode in xmlDoc.GetElementsByTagName("card"))
{
CardMini c = new CardMini();
foreach (XmlAttribute xa in xmlNode.Attributes)
{
if (xa.Value == null)
{
continue; //skip bad/blank entries
}
if (xa.Value == "")
{
continue;
}
switch (xa.Name.ToLower())
{
case "id":
c.Hero.EntryId = xa.Value;
break;
case "life":
c.Hero.Life = Convert.ToInt32(xa.Value);
break;
case "world":
c.Hero.World = xa.Value;
break;
case "set":
c.Hero.Set = xa.Value;
break;
case "collectornumber":
c.Hero.CollectorNumber = xa.Value;
break;
case "name":
c.Hero.Name = xa.Value;
break;
case "valkyrie":
c.Hero.Valkyrie = xa.Value;
break;
case "species":
c.Hero.Species = xa.Value;
break;
case "herotype":
c.Hero.HeroType = xa.Value;
break;
case "class":
c.Hero.ClassType = xa.Value;
break;
case "personality":
c.Hero.Personality = xa.Value;
break;
case "size":
c.Hero.Size = xa.Value;
break;
case "move":
c.Hero.Move = Convert.ToInt32(xa.Value);
break;
case "range":
c.Hero.Range = Convert.ToInt32(xa.Value);
break;
case "attack":
c.Hero.Attack = Convert.ToInt32(xa.Value);
break;
case "defense":
c.Hero.Defense = Convert.ToInt32(xa.Value);
break;
case "points":
c.Hero.Points = Convert.ToInt32(xa.Value);
break;
case "bmove":
c.Hero.BasicMove = Convert.ToInt32(xa.Value);
break;
case "brange":
c.Hero.BasicRange = Convert.ToInt32(xa.Value);
break;
case "battack":
c.Hero.BasicAttack = Convert.ToInt32(xa.Value);
break;
case "bdefense":
c.Hero.BasicDefense = Convert.ToInt32(xa.Value);
break;
case "armysize":
c.Hero.ArmySize = Convert.ToInt32(xa.Value);
break;
}
}
c.Hero.Image = string.Format("/Assets/Cards/{0}.png", c.Hero.EntryId);
c.Hero.Thumb = string.Format("/Assets/Cards/_t/{0}.png", c.Hero.EntryId);
//c.CardSource = ImageFromRelativePath(rootFrame, c.Hero.Thumb);
c.CardName = c.Hero.Name;
c.CardPoints = string.Format("{0} PTS", c.Hero.Points);
c.UpdateData();
CardDataset.Add(c);
}
foreach (IXmlNode xmlNode in xmlDoc.GetElementsByTagName("glyph"))
{
GlyphControl g = new GlyphControl();
foreach (XmlAttribute xa in xmlNode.Attributes)
{
switch (xa.Name.ToLower())
{
case "id":
g.EntryId = xa.Value;
break;
case "description":
g.Description = xa.Value;
break;
}
}
g.ImageFileName = string.Format("/Assets/Glyphs/{0}.png", g.EntryId);
// g.GlyphSource = ImageFromRelativePath(rootFrame, g.ImageFileName);
glyphdataset.Add(g);
}
GameSetting.DataLoaded = true;
return(true);
}
