//
/// <summary>
/// Accept a List<Move> and dump them into a CSV file
/// </summary>
/// <param name="moveList">a list of moves</param>
public async void SaveGame(List <Move> moveList)
{
FileSavePicker fileSavePicker = new FileSavePicker();
fileSavePicker.DefaultFileExtension = ".csv";
fileSavePicker.FileTypeChoices.Add("game data", new List <string>()
{
".csv"
});
StorageFile targetFile = await fileSavePicker.PickSaveFileAsync();
if (targetFile != null)
{
var stream = await targetFile.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
using (var outputStream = stream.GetOutputStreamAt(0))
{
using (var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream))
{
// The first number determines how many moves should be read in the future loading
// I use this trick because I haven't found a way to empty a file
dataWriter.WriteString(moveList.Count.ToString() + System.Environment.NewLine);
foreach (Move move in moveList)
{
dataWriter.WriteString(move.ToString() + System.Environment.NewLine);
}
await dataWriter.StoreAsync();
await outputStream.FlushAsync();
}
}
stream.Dispose();
}
}
private async void C_BUTTON_GENCODE_ENTITY_Click(object sender,RoutedEventArgs e)
{
String res = m_Elements.GenFunctions();
var picker = new Windows.Storage.Pickers.FileSavePicker();
picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.DocumentsLibrary;
// Dropdown of file types the user can save the file as
picker.FileTypeChoices.Add("cs",new List <string>()
{
".cs"
});
// Default file name if the user does not type one in or select a file to replace
picker.SuggestedFileName = "gencode";
var t_storagefile = await picker.PickSaveFileAsync();
if (t_storagefile == null)
{
return;
}
using (StorageStreamTransaction transaction = await t_storagefile.OpenTransactedWriteAsync())
{
using (Windows.Storage.Streams.DataWriter dataWriter = new Windows.Storage.Streams.DataWriter(transaction.Stream))
{
dataWriter.WriteString(res);
transaction.Stream.Size = await dataWriter.StoreAsync();
await transaction.Stream.FlushAsync();
await transaction.CommitAsync();
}
}
}
private async void FileWrite_UsingStream(Windows.Storage.StorageFolder storageFolder)
{
//Windows.Storage.StorageFolder storageFolder =
// Windows.Storage.ApplicationData.Current.LocalFolder;
//Windows.Storage.StorageFolder storageFolder =
// Windows.ApplicationModel.Package.Current.InstalledLocation;
try
{
Windows.Storage.StorageFile storage = await storageFolder.GetFileAsync("StreamWrite.txt");
var stream = await storage.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
// outputStream 가져옴
using (var outputStream = stream.GetOutputStreamAt(0))
{
using (var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream))
{
dataWriter.WriteString("StreamWriteTest");
await dataWriter.StoreAsync();
}
await outputStream.FlushAsync();
}
stream.Dispose();
}
catch
{
}
}
/// <summary>
/// 動作ログを出力する.
/// </summary>
/// <param name="taskInstance"></param>
/// <returns></returns>
async Task WriteLogAsync(IBackgroundTaskInstance taskInstance, SetLockscreenResult result)
{
var log = String.Format("{0}: {1} / {2}, {3}{4}",
DateTimeOffset.Now,
taskInstance.Task.Name,
taskInstance.Task.TaskId,
result,
Environment.NewLine);
System.Diagnostics.Debug.WriteLine(log);
var logfile = await Windows.Storage.ApplicationData.Current.LocalFolder.CreateFileAsync("bgtask.log", Windows.Storage.CreationCollisionOption.OpenIfExists);
if (logfile != null)
{
System.Diagnostics.Debug.WriteLine(logfile.Path);
using (var strm = await logfile.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite))
{
strm.Seek(strm.Size);
using (var dw = new Windows.Storage.Streams.DataWriter(strm))
{
dw.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf16LE;
dw.WriteString(log);
await dw.StoreAsync();
await dw.FlushAsync();
}
}
}
}
public async Task<bool> WritePlaylistFile(Playlist play)
{
try
{
StorageFolder storageFolder = ApplicationData.Current.LocalFolder;
StorageFolder playlistsFolder = await storageFolder.CreateFolderAsync("Playlists", CreationCollisionOption.OpenIfExists);
StorageFile playlist = await playlistsFolder.CreateFileAsync(play.PlaylistName + ".m3u",
CreationCollisionOption.ReplaceExisting);
var stream = await playlist.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
using (var outputStream = stream.GetOutputStreamAt(0))
{
using (var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream))
{
dataWriter.WriteString(await PrepareM3uFile(play));
await dataWriter.StoreAsync();
await outputStream.FlushAsync();
}
}
stream.Dispose();
return true;
}
catch
{
return false;
}
}
public async void Send(string message)
{
if (_websocket != null && messageWriter != null)
{
try {
message = "\"" + message + "\"";
messageWriter.WriteString(message);
await messageWriter.StoreAsync();
//System.Diagnostics.Debug.WriteLine(":: send: " + message);
} catch {/*
* var ev = OnError;
* if (ev != null) {
* Task.Factory.StartNew(() => ev(new OrtcNotConnectedException("Unable to write to socket.")));
* }*/
}
/*
* using (var writer = new Windows.Storage.Streams.DataWriter(_websocket.OutputStream)) {
* writer.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
* writer.WriteString(message);
* writer.StoreAsync();
* //await writer.FlushAsync();
* System.Diagnostics.Debug.WriteLine(":: send: " + message);
* }
*/
}
}
public void Stop()
{
this.behaviour.StopCoroutine(this.pingCoroutine);
for (int i = 0; i < this.BroadcastEndPoint.Length; i++)
#if NETFX_CORE
{
var action = this.Client.GetOutputStreamAsync(new Windows.Networking.HostName("127.0.0.1"), this.BroadcastEndPoint[i].Port.ToString());
//var action = this.Client.GetOutputStreamAsync(this.Client.Information.LocalAddress, this.BroadcastEndPoint[i].Port.ToString());
action.AsTask().Wait();
var outputStream = action.GetResults();
var writer = new Windows.Storage.Streams.DataWriter(outputStream);
writer.WriteBytes(AutoDetectUDPClient.UDPEndMessage);
writer.StoreAsync().AsTask().Wait();
}
#else
{ this.Client.Send(AutoDetectUDPClient.UDPEndMessage, AutoDetectUDPClient.UDPEndMessage.Length, this.BroadcastEndPoint[i]); }
#endif
#if NETFX_CORE
this.Client.Dispose();
#else
this.Client.Close();
#endif
}
public async Task <Settings> WriteSettingsAsync(Settings settings)
{
var localFolder = ApplicationData.Current.LocalFolder;
StorageFile file = await localFolder.CreateFileAsync(SettingsName, CreationCollisionOption.ReplaceExisting);
//await FileIO.WriteBufferAsync(file, buffer);
var formatter = new DataContractSerializer(typeof(Settings));
var stream = await file.OpenAsync(FileAccessMode.ReadWrite);
using (var outputStream = stream.GetOutputStreamAt(0))
{
using (var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream))
{
dataWriter.WriteString(settings.FileSystemDirectory);
dataWriter.WriteBoolean(settings.IsFileSystemEnabled);
await dataWriter.StoreAsync();
await outputStream.FlushAsync();
}
}
//formatter.WriteObject(outStream, settings);
Debug.WriteLine("SavedSettings");
return(settings);
}
private async void Archive(String hourData)
{
try
{
//string tr = DateTime.Now.Ticks.ToString() + ".txt";
string tr = DateTime.Now.Ticks.ToString() + ".txt";
//StorageFolder storageFolder = ApplicationData.Current.LocalFolder;
StorageFolder storageFolder = ApplicationData.Current.TemporaryFolder;
StorageFile sampleFile = await storageFolder.CreateFileAsync(tr, CreationCollisionOption.ReplaceExisting);
var stream = await sampleFile.OpenAsync(FileAccessMode.ReadWrite);
using (var outputStream = stream.GetOutputStreamAt(0))
{
// We'll add more code here in the next step.
using (var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream))
{
dataWriter.WriteString(hourData);
await dataWriter.StoreAsync();
await outputStream.FlushAsync();
}
}
stream.Dispose();
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("Archive: " + ex);
}
}
public async void StopTimer_Tick(Object sender, object e)
{
DateTimeOffset time = DateTimeOffset.Now;
timer.Stop();
TimeSpan span = startTime - lastTime;
Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile ticketsFile = await storageFolder.CreateFileAsync("timelog.txt", Windows.Storage.CreationCollisionOption.OpenIfExists);
//Use stream to write to the file
var stream = await ticketsFile.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
using (var outputStream = stream.GetOutputStreamAt(stream.Size))
{
using (var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream))
{
dataWriter.WriteString("Time: " + span + "\n");
await dataWriter.StoreAsync();
await outputStream.FlushAsync();
}
}
stream.Dispose(); // Or use the stream variable (see previous code snippet) with a using statement as well.
string path = @"c:\temp\MyTest.txt";
// This text is added only once to the file.
}
private async void _baseWebView_ScriptNotify(object sender, NotifyEventArgs e)
{
try
{
var bmp = new BitmapImage();
var base64 = e.Value.Substring(e.Value.IndexOf(",") + 1);
var imageBytes = Convert.FromBase64String(base64);
#if WINDOWS_APP || WINDOWS_PHONE_APP
using (var ms = new Windows.Storage.Streams.InMemoryRandomAccessStream())
{
using (var writer = new Windows.Storage.Streams.DataWriter(ms.GetOutputStreamAt(0)))
{
writer.WriteBytes(imageBytes);
await writer.StoreAsync();
}
bmp.SetSource(ms);
}
#elif WINDOWS_PHONE
using (var ms = new System.IO.MemoryStream(imageBytes))
{
ms.Position = 0;
bmp.SetSource(ms);
}
#endif
imageBytes = null;
_img.Source = bmp;
_img.Visibility = Visibility.Visible;
}
catch { }
}
private IEnumerator AsyncSendPing()
{
#if !NETFX_CORE
AsyncCallback callback = new AsyncCallback(this.SendPresence);
#endif
WaitForSeconds wait = new WaitForSeconds(this.pingInterval);
while (true)
{
for (int i = 0; i < this.BroadcastEndPoint.Length; i++)
#if NETFX_CORE
{
var action = this.Client.GetOutputStreamAsync(new Windows.Networking.HostName("127.0.0.1"), this.BroadcastEndPoint[i].Port.ToString());
//var action = this.Client.GetOutputStreamAsync(this.Client.Information.LocalAddress, this.BroadcastEndPoint[i].Port.ToString());
action.AsTask().Wait();
var outputStream = action.GetResults();
var writer = new Windows.Storage.Streams.DataWriter(outputStream);
writer.WriteBytes(AutoDetectUDPClient.UDPPingMessage);
writer.StoreAsync().AsTask().Wait();
}
#else
{ this.Client.BeginSend(this.pingContent, this.pingContent.Length, this.BroadcastEndPoint[i], callback, null); }
#endif
yield return(wait);
}
}
internal async void CustomerWriteToFile(string filename, List <Customer> InputList)
{
//Hakee tiedoston kirjoitettavaksi. Kirjoittaa tiedostoon C:/users/USER/AppData.....
var file = await folder.CreateFileAsync(filename, CreationCollisionOption.OpenIfExists);
var stream = await file.OpenAsync(FileAccessMode.ReadWrite);
Type tyyppi = InputList.GetType();
int attributeCount = 0;
foreach (PropertyInfo property in tyyppi.GetProperties())
{
attributeCount += property.GetCustomAttributes(false).Count();
}
using (var outputStream = stream.GetOutputStreamAt(0))
{
using (var datawriter = new Windows.Storage.Streams.DataWriter(outputStream))
{
datawriter.WriteString("Testi");
await datawriter.StoreAsync();
}
}
stream.Dispose();
}
public static async Task <UwpSoftwareBitmap> ConvertFrom(BitmapFrame sourceBitmap)
{
// BitmapFrameをBMP形式のバイト配列に変換
byte[] bitmapBytes;
var encoder = new BmpBitmapEncoder(); // .NET用のエンコーダーを使う
encoder.Frames.Add(sourceBitmap);
using (var memoryStream = new MemoryStream())
{
encoder.Save(memoryStream);
bitmapBytes = memoryStream.ToArray();
}
// バイト配列をUWPのIRandomAccessStreamに変換
using (var randomAccessStream = new UwpInMemoryRandomAccessStream())
{
using (var outputStream = randomAccessStream.GetOutputStreamAt(0))
using (var writer = new UwpDataWriter(outputStream))
{
writer.WriteBytes(bitmapBytes);
await writer.StoreAsync();
await outputStream.FlushAsync();
}
// IRandomAccessStreamをSoftwareBitmapに変換
// （UWP APIのデコーダー）
var decoder = await UwpBitmapDecoder.CreateAsync(randomAccessStream);
var softwareBitmap
= await decoder.GetSoftwareBitmapAsync(UwpBitmapPixelFormat.Bgra8, UwpBitmapAlphaMode.Premultiplied);
return(softwareBitmap);
}
}
/// <summary>
/// Gửi một gói tin đi
/// </summary>
/// <param name="data">gói tin cần gửi</param>
/// <returns>true nếu gửi thành công, false nếu thất bại</returns>
public async Task <bool> SendAsync(byte[] data)
{
// Monitor.Enter(nstreamlock);
try
{
byte[] senddata = new byte[data.Length + sizeof(int)];
// đưa độ dài của data về dạng bytes rồi copy vào send
Buffer.BlockCopy(BitConverter.GetBytes(data.Length), 0, senddata, 0, sizeof(int));
// copy dữ liệu còn lại vào send
Buffer.BlockCopy(data, 0, senddata, sizeof(int), data.Length);
writer.WriteBytes(senddata);
await writer.StoreAsync();
// Monitor.Exit(nstreamlock);
return(true);
}
catch
{
Disconnect();
// Monitor.Exit(nstreamlock);
return(false);
}
}
/// <summary>
/// This is the click handler for the 'Copy Strings' button. Here we will parse the
/// strings contained in the ElementsToWrite text block, write them to a stream using
/// DataWriter, retrieve them using DataReader, and output the results in the
/// ElementsRead text block.
/// </summary>
/// <param name="sender">Contains information about the button that fired the event.</param>
/// <param name="e">Contains state information and event data associated with a routed event.</param>
private async void TransferData(object sender, RoutedEventArgs e)
{
// Initialize the in-memory stream where data will be stored.
using (var stream = new Windows.Storage.Streams.InMemoryRandomAccessStream())
{
// Create the data writer object backed by the in-memory stream.
using (var dataWriter = new Windows.Storage.Streams.DataWriter(stream))
{
dataWriter.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
dataWriter.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian;
// Write each element separately.
foreach (string inputElement in inputElements)
{
uint inputElementSize = dataWriter.MeasureString(inputElement);
dataWriter.WriteUInt32(inputElementSize);
dataWriter.WriteString(inputElement);
}
// Send the contents of the writer to the backing stream.
await dataWriter.StoreAsync();
// For the in-memory stream implementation we are using, the flushAsync call is superfluous,
// but other types of streams may require it.
await dataWriter.FlushAsync();
// In order to prolong the lifetime of the stream, detach it from the DataWriter so that it
// will not be closed when Dispose() is called on dataWriter. Were we to fail to detach the
// stream, the call to dataWriter.Dispose() would close the underlying stream, preventing
// its subsequent use by the DataReader below.
dataWriter.DetachStream();
}
// Create the input stream at position 0 so that the stream can be read from the beginning.
stream.Seek(0);
using (var dataReader = new Windows.Storage.Streams.DataReader(stream))
{
// The encoding and byte order need to match the settings of the writer we previously used.
dataReader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
dataReader.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian;
// Once we have written the contents successfully we load the stream.
await dataReader.LoadAsync((uint)stream.Size);
var receivedStrings = "";
// Keep reading until we consume the complete stream.
while (dataReader.UnconsumedBufferLength > 0)
{
// Note that the call to readString requires a length of "code units" to read. This
// is the reason each string is preceded by its length when "on the wire".
uint bytesToRead = dataReader.ReadUInt32();
receivedStrings += dataReader.ReadString(bytesToRead) + "\n";
}
// Populate the ElementsRead text block with the items we read from the stream.
ElementsRead.Text = receivedStrings;
}
}
}
/// <summary>
/// Writes a specified number of bytes to the serial port using data from a buffer.
/// </summary>
/// <param name="buffer">The byte array that contains the data to write to the port.</param>
/// <param name="offset">The zero-based byte offset in the buffer parameter at which to begin copying bytes to the port.</param>
/// <param name="count">The number of bytes to write.</param>
/// <remarks>
/// ArgumentException: offset plus count is greater than the length of the buffer.
/// </remarks>
public Windows.Foundation.IAsyncAction Write(
Windows.Storage.Streams.IBuffer buffer,
uint offset,
uint count
)
{
var outputStream = this.cdcData.BulkOutPipes[0].OutputStream;
var writer = new Windows.Storage.Streams.DataWriter(outputStream);
return(Task.Run(async() =>
{
// Overflow check.
if ((int)buffer.Length < (offset + count))
{
throw new System.ArgumentException("Capacity of buffer is not enough.");
}
writer.WriteBuffer(buffer, offset, count);
var written = await writer.StoreAsync();
return;
}
).AsAsyncAction());
}
/// <summary>
/// This is the click handler for the 'Copy Strings' button. Here we will parse the
/// strings contained in the ElementsToWrite text block, write them to a stream using
/// DataWriter, retrieve them using DataReader, and output the results in the
/// ElementsRead text block.
/// </summary>
/// <param name="sender">Contains information about the button that fired the event.</param>
/// <param name="e">Contains state information and event data associated with a routed event.</param>
private async void TransferData(object sender, RoutedEventArgs e)
{
// Initialize the in-memory stream where data will be stored.
using (var stream = new Windows.Storage.Streams.InMemoryRandomAccessStream())
{
// Create the data writer object backed by the in-memory stream.
using (var dataWriter = new Windows.Storage.Streams.DataWriter(stream))
{
dataWriter.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
dataWriter.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian;
// Write each element separately.
foreach (string inputElement in inputElements)
{
uint inputElementSize = dataWriter.MeasureString(inputElement);
dataWriter.WriteUInt32(inputElementSize);
dataWriter.WriteString(inputElement);
}
// Send the contents of the writer to the backing stream.
await dataWriter.StoreAsync();
// For the in-memory stream implementation we are using, the flushAsync call is superfluous,
// but other types of streams may require it.
await dataWriter.FlushAsync();
// In order to prolong the lifetime of the stream, detach it from the DataWriter so that it
// will not be closed when Dispose() is called on dataWriter. Were we to fail to detach the
// stream, the call to dataWriter.Dispose() would close the underlying stream, preventing
// its subsequent use by the DataReader below.
dataWriter.DetachStream();
}
// Create the input stream at position 0 so that the stream can be read from the beginning.
stream.Seek(0);
using (var dataReader = new Windows.Storage.Streams.DataReader(stream))
{
// The encoding and byte order need to match the settings of the writer we previously used.
dataReader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
dataReader.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian;
// Once we have written the contents successfully we load the stream.
await dataReader.LoadAsync((uint)stream.Size);
var receivedStrings = "";
// Keep reading until we consume the complete stream.
while (dataReader.UnconsumedBufferLength > 0)
{
// Note that the call to readString requires a length of "code units" to read. This
// is the reason each string is preceded by its length when "on the wire".
uint bytesToRead = dataReader.ReadUInt32();
receivedStrings += dataReader.ReadString(bytesToRead) + "\n";
}
// Populate the ElementsRead text block with the items we read from the stream.
ElementsRead.Text = receivedStrings;
}
}
}
public static async void Stringify()
{
JsonObject jsonObject = new JsonObject();
if (Player.CurrentlyPlayingFile != null && !string.IsNullOrEmpty(Player.CurrentlyPlayingFile.Path))
{
jsonObject[pathKey] = JsonValue.CreateStringValue(Player.CurrentlyPlayingFile.Path);
jsonObject[posKey] = JsonValue.CreateNumberValue(Player.Position);
}
jsonObject[shuffleKey] = JsonValue.CreateBooleanValue(ShellVM.Shuffle);
jsonObject[repeatKey] = JsonValue.CreateBooleanValue(ShellVM.Repeat);
jsonObject[volKey] = JsonValue.CreateNumberValue(Player.Volume);
StorageFile file = await ApplicationData.Current.TemporaryFolder.CreateFileAsync("lastplaying.mc", CreationCollisionOption.ReplaceExisting);
using (var stream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite))
{
using (var outputStream = stream.GetOutputStreamAt(0))
{
using (var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream))
{
dataWriter.WriteString(jsonObject.Stringify());
await dataWriter.StoreAsync();
await outputStream.FlushAsync();
}
}
}
}
public static async Task OutputSensorDataAsync()
{
// ファイルの作成 すでに存在する場合は置き換える
Windows.Storage.StorageFolder documentsLibrary = KnownFolders.DocumentsLibrary;
Windows.Storage.StorageFile file = await documentsLibrary.CreateFileAsync(sensorDataFileName, Windows.Storage.CreationCollisionOption.ReplaceExisting);
// ファイルへの書き込み
var stream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
using (var outputStream = stream.GetOutputStreamAt(0))
{
using (var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream))
{
dataWriter.WriteString("valueX valueY valueZ time\n");
if (Sensor_Values_Record_Time_List != null)
{
for (int i = 0; i < Sensor_Values_Record_Time_List.Count; i++)
{
dataWriter.WriteString($"{Math.Round(Sensor_ValueX_List[i], 3)} {Math.Round(Sensor_ValueY_List[i], 3)} {Math.Round(Sensor_ValueZ_List[i], 3)} {Math.Round(Sensor_Values_Record_Time_List[i], 2)}\n");
}
}
await dataWriter.StoreAsync();
await outputStream.FlushAsync();
}
}
stream.Dispose(); // Or use the stream variable (see previous code snippet) with a using statement as well.
}
public static async Task OutputTrialDataAsync()
{
// ファイルの作成 すでに存在する場合は置き換える
StorageFolder documentsLibrary = KnownFolders.DocumentsLibrary;
StorageFile file = await documentsLibrary.CreateFileAsync(trialDataFileName, Windows.Storage.CreationCollisionOption.ReplaceExisting);
// ファイルへの書き込み
var stream = await file.OpenAsync(FileAccessMode.ReadWrite);
using (var outputStream = stream.GetOutputStreamAt(0))
{
using (var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream))
{
dataWriter.WriteString("trial initLeftAngle initRightAngle respLeftAngle respRightAngle time\n");
if (Resp_Time_List != null)
{
for (int i = 0; i < Resp_Time_List.Count; i++)
{
dataWriter.WriteString($"{i} {Math.Round(InitLeftLineAngle[i],1)} {Math.Round(InitRightLineAngle[i], 1)} {Math.Round(RespLeftLineAngle[i], 1)} {Math.Round(RespRightLineAngle[i], 1)} {Math.Round(Resp_Time_List[i], 2)}\n");
}
}
await dataWriter.StoreAsync();
await outputStream.FlushAsync();
}
}
stream.Dispose(); // Or use the stream variable (see previous code snippet) with a using statement as well.
}
private async void Write_to_text_file_stream_Click(object sender, RoutedEventArgs e)
{
// Get the sample file
Windows.Storage.StorageFolder storageFolder =
Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile sampleFile =
await storageFolder.GetFileAsync("sample.txt");
// Open the file
var stream = await sampleFile.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
// Get an output stream
using (var outputStream = stream.GetOutputStreamAt(0))
{
// Write to the output stream
using (var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream))
{
dataWriter.WriteString("DataWriter has methods to write to various types, such as DataTimeOffset.");
// Save the stream
await dataWriter.StoreAsync();
// Close the file
await outputStream.FlushAsync();
}
}
stream.Dispose(); // Or use the stream variable (see previous code snippet) with a using statement as well.
// Test sample file
Access_sample_file();
}
public async void SavePresets()
{
String json_str = Serial.JsonHelper.ToJson(m_Presets, m_Presets.GetType());
var picker = new Windows.Storage.Pickers.FileSavePicker();
picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.DocumentsLibrary;
// Dropdown of file types the user can save the file as
picker.FileTypeChoices.Add("JSON", new List <string>()
{
".json"
});
// Default file name if the user does not type one in or select a file to replace
picker.SuggestedFileName = "GenCodePreset";
var t_storagefile = await picker.PickSaveFileAsync();
if (t_storagefile == null)
{
return;
}
using (StorageStreamTransaction transaction = await t_storagefile.OpenTransactedWriteAsync())
{
using (Windows.Storage.Streams.DataWriter dataWriter = new Windows.Storage.Streams.DataWriter(transaction.Stream))
{
dataWriter.WriteString(json_str);
transaction.Stream.Size = await dataWriter.StoreAsync();
await transaction.Stream.FlushAsync();
await transaction.CommitAsync();
}
}
}
private async void AddToIndex_Click(object sender, RoutedEventArgs e)
{
if (ItemKeyInput.Text == "")
{
rootPage.NotifyUser("You must add an item key to insert an item into the index.", NotifyType.ErrorMessage);
}
else
{
// Write the content property to a stream
var contentStream = new Windows.Storage.Streams.InMemoryRandomAccessStream();
var contentWriter = new Windows.Storage.Streams.DataWriter(contentStream);
contentWriter.WriteString(ContentInput.Text);
await contentWriter.StoreAsync();
contentStream.Seek(0);
// Get the name, keywords, and comment properties, and assign a language to them if provided
object itemNameValue = NameInput.Text;
object keywordsValue = KeywordsInput.Text;
object commentValue = CommentInput.Text;
if (LanguageInput.Text != "")
{
var itemNameValueAndLanguage = new Windows.Storage.Search.ValueAndLanguage();
itemNameValueAndLanguage.Language = LanguageInput.Text;
itemNameValueAndLanguage.Value = itemNameValue;
itemNameValue = itemNameValueAndLanguage;
var keywordsValueAndLanguage = new Windows.Storage.Search.ValueAndLanguage();
keywordsValueAndLanguage.Language = LanguageInput.Text;
keywordsValueAndLanguage.Value = keywordsValue;
keywordsValue = keywordsValueAndLanguage;
var commentValueAndLanguage = new Windows.Storage.Search.ValueAndLanguage();
commentValueAndLanguage.Language = LanguageInput.Text;
commentValueAndLanguage.Value = commentValue;
commentValue = commentValueAndLanguage;
}
// Create the item to add to the indexer
var content = new Windows.Storage.Search.IndexableContent();
content.Id = ItemKeyInput.Text;
content.Properties.Add(Windows.Storage.SystemProperties.ItemNameDisplay, itemNameValue);
content.Properties.Add(Windows.Storage.SystemProperties.Keywords, keywordsValue);
content.Properties.Add(Windows.Storage.SystemProperties.Comment, commentValue);
content.Stream = contentStream;
content.StreamContentType = "text/plain";
// Add the item to the indexer
Helpers.OnIndexerOperationBegin();
var indexer = Windows.Storage.Search.ContentIndexer.GetIndexer();
await indexer.AddAsync(content);
Helpers.OnIndexerOperationComplete(indexer);
// Retrieve the item from the indexer and output its properties
var retrievedProperties = await indexer.RetrievePropertiesAsync(ItemKeyInput.Text, content.Properties.Keys);
rootPage.NotifyUser(Helpers.CreateItemString(ItemKeyInput.Text, content.Properties.Keys, retrievedProperties), NotifyType.StatusMessage);
}
}
private async void AddToIndex_Click(object sender, RoutedEventArgs e)
{
if (ItemKeyInput.Text == "")
{
rootPage.NotifyUser("You must add an item key to insert an item into the index.", NotifyType.ErrorMessage);
}
else
{
// Write the content property to a stream
var contentStream = new Windows.Storage.Streams.InMemoryRandomAccessStream();
var contentWriter = new Windows.Storage.Streams.DataWriter(contentStream);
contentWriter.WriteString(ContentInput.Text);
await contentWriter.StoreAsync();
contentStream.Seek(0);
// Get the name, keywords, and comment properties, and assign a language to them if provided
object itemNameValue = NameInput.Text;
object keywordsValue = KeywordsInput.Text;
object commentValue = CommentInput.Text;
if (LanguageInput.Text != "")
{
var itemNameValueAndLanguage = new Windows.Storage.Search.ValueAndLanguage();
itemNameValueAndLanguage.Language = LanguageInput.Text;
itemNameValueAndLanguage.Value = itemNameValue;
itemNameValue = itemNameValueAndLanguage;
var keywordsValueAndLanguage = new Windows.Storage.Search.ValueAndLanguage();
keywordsValueAndLanguage.Language = LanguageInput.Text;
keywordsValueAndLanguage.Value = keywordsValue;
keywordsValue = keywordsValueAndLanguage;
var commentValueAndLanguage = new Windows.Storage.Search.ValueAndLanguage();
commentValueAndLanguage.Language = LanguageInput.Text;
commentValueAndLanguage.Value = commentValue;
commentValue = commentValueAndLanguage;
}
// Create the item to add to the indexer
var content = new Windows.Storage.Search.IndexableContent();
content.Id = ItemKeyInput.Text;
content.Properties.Add(Windows.Storage.SystemProperties.ItemNameDisplay, itemNameValue);
content.Properties.Add(Windows.Storage.SystemProperties.Keywords, keywordsValue);
content.Properties.Add(Windows.Storage.SystemProperties.Comment, commentValue);
content.Stream = contentStream;
content.StreamContentType = "text/plain";
// Add the item to the indexer
Helpers.OnIndexerOperationBegin();
var indexer = Windows.Storage.Search.ContentIndexer.GetIndexer();
await indexer.AddAsync(content);
Helpers.OnIndexerOperationComplete(indexer);
// Retrieve the item from the indexer and output its properties
var retrievedProperties = await indexer.RetrievePropertiesAsync(ItemKeyInput.Text, content.Properties.Keys);
rootPage.NotifyUser(Helpers.CreateItemString(ItemKeyInput.Text, content.Properties.Keys, retrievedProperties), NotifyType.StatusMessage);
}
}
public async void rubbish()
{
//string line = "\r\n";
string usingstr = string.Format("using System;{0}using System.Collections.Generic;{0}using System.Linq;{0}using System.Text;{0}using System.Threading.Tasks;{0}namespace rubbish{1}", line, left);
//string classstr = ranstr();
int count;
StringBuilder str = new StringBuilder();
for (count = 0; count < 100; count++)
{
junk.Add(ranstr() + count.ToString());
}
str.Append(usingstr);
str.Append(constructor());
for (int i = 10; i < junk.Count; i++)
{
element.Add(lajicontent(junk[i]));
}
element.Add(content1());
element.Add(content2());
for (int i = 0; i < element.Count;)
{
count = ran.Next() % element.Count;
str.Append(element[count]);
element.RemoveAt(count);
}
for (int i = 10; i < junk.Count; i++)
{
//temp = string.Format("{0}(o);{1}" , junk[i] , line);
//content.Append(temp);
str.Append(string.Format("{0}private bool _{1}_bool;{2}", space, junk[i], line));
}
for (int i = 10; i < junk.Count; i++)
{
str.Append(string.Format("{0}private int _{1}_int;{2}", space, junk[i], line));
}
str.Append("}\r\n}");
StorageFile file = await ApplicationData.Current.LocalFolder.CreateFileAsync(junk[0] + ".cs", CreationCollisionOption.ReplaceExisting);
using (StorageStreamTransaction transaction = await file.OpenTransactedWriteAsync())
{
using (Windows.Storage.Streams.DataWriter dataWriter = new Windows.Storage.Streams.DataWriter(transaction.Stream))
{
dataWriter.WriteString(str.ToString());
transaction.Stream.Size = await dataWriter.StoreAsync();
await transaction.CommitAsync();
}
}
junk.Clear();
str.Clear();
_reminder.Append(file.Path);
OnPropertyChanged("reminder");
}
public async Task SendData(byte[] data)
{
Task <UInt32> storeAsyncTask;
// Load the text from the sendText input text box to the dataWriter object
dataWriteObject.WriteBytes(data);
// Launch an async task to complete the write operation
storeAsyncTask = dataWriteObject.StoreAsync().AsTask();
UInt32 bytesWritten = await storeAsyncTask;
}
public async void StartReceiveAsync()
{
isRun = true;
while(isRun)
{
if(!isReceive)
{
System.Diagnostics.Debug.WriteLine("Start Receive");
udpSocket = new Windows.Networking.Sockets.DatagramSocket();
udpSocket.MessageReceived += UdpSocket_MessageReceived;
Windows.Networking.HostName hostName = null;
IReadOnlyList<Windows.Networking.HostName> networkinfo = Windows.Networking.Connectivity.NetworkInformation.GetHostNames();
foreach (Windows.Networking.HostName h in networkinfo)
{
if (h.IPInformation != null)
{
Windows.Networking.Connectivity.IPInformation ipinfo = h.IPInformation;
if (h.RawName == IPAddr)
{
hostName = h;
break;
}
}
}
if (hostName != null)
await udpSocket.BindEndpointAsync(hostName, Port);
else
await udpSocket.BindServiceNameAsync(Port);
outstm = await udpSocket.GetOutputStreamAsync(new Windows.Networking.HostName("255.255.255.255"), "49002");
await outstm.FlushAsync();
Windows.Storage.Streams.DataWriter dw = new Windows.Storage.Streams.DataWriter(outstm);
dw.WriteString("Start Receive");
await dw.StoreAsync();
isReceive = true;
}
else
{
if(CurrentStat.GPSStatus !=null & CurrentStat.ATTStatus != null)
{
if (onXPlaneStatReceived != null)
onXPlaneStatReceived.Invoke(this, CurrentStat);
}
System.Diagnostics.Debug.WriteLine("Try To Sleep");
isReceive = false;
await udpSocket.CancelIOAsync();
udpSocket.MessageReceived -= UdpSocket_MessageReceived;
udpSocket.Dispose();
udpSocket = null;
}
await Task.Delay(waitSeconds*1000);
}
}
/// <summary>
/// Restores the applications data using a backup from the current user's OneDrive.
/// <para>Note: Application requires restart after restoring data</para>
/// </summary>
/// <param name="itemId">Unique item identifier within a DriveItem (i.e., a folder/file facet).</param>
/// <param name="filename">Name of the datafile.</param>
/// <returns></returns>
public async Task RestoreFileAsync(string itemId, string dataFilename)
{
try
{
// Local storage folder
Windows.Storage.StorageFolder storageFolder =
Windows.Storage.ApplicationData.Current.LocalFolder;
// Our local ktdatabase.db file
Windows.Storage.StorageFile originalDataFile =
await storageFolder.GetFileAsync(dataFilename);
// Stream for the backed up data file
var backedUpFileStream = await GraphClient.Me.Drive.Items[itemId]
.ItemWithPath(dataFilename)
.Content
.Request()
.GetAsync();
// Backed up file
var backedUpFile = await storageFolder.CreateFileAsync("temp", CreationCollisionOption.ReplaceExisting);
var newStream = await backedUpFile.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
// Write data to new file
using (var outputStream = newStream.GetOutputStreamAt(0))
{
using (var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream))
{
var buffer = backedUpFileStream.ToByteArray();
dataWriter.WriteBytes(buffer);
await dataWriter.StoreAsync();
await outputStream.FlushAsync();
}
}
// Copy and replace local file
await backedUpFile.CopyAsync(storageFolder, dataFilename, NameCollisionOption.ReplaceExisting);
}
catch (ServiceException ex)
{
if (ex.StatusCode == HttpStatusCode.Forbidden)
{
Console.WriteLine($"Access Denied: {ex.Message}");
}
Console.WriteLine($"Service Exception, Error uploading file to signed-in users one drive: {ex.Message}");
// return null;
}
}
public static async void Stringify()
{
JsonObject jsonObject = new JsonObject();
if (Player.CurrentlyPlayingFile != null && !string.IsNullOrEmpty(Player.CurrentlyPlayingFile.Path))
{
jsonObject[pathKey] = JsonValue.CreateStringValue(Player.CurrentlyPlayingFile.Path);
jsonObject[posKey] = JsonValue.CreateNumberValue(Player.Position);
}
jsonObject[shuffleKey] = JsonValue.CreateBooleanValue(ShellVM.Shuffle);
jsonObject[repeatKey] = JsonValue.CreateStringValue(ShellVM.Repeat);
jsonObject[volKey] = JsonValue.CreateNumberValue(Player.Volume);
jsonObject[isplaybarKey] = JsonValue.CreateBooleanValue(ShellVM.IsPlayBarVisible);
jsonObject[sortKey] = JsonValue.CreateStringValue(LibVM.Sort);
jsonObject[timeclosedKey] = JsonValue.CreateStringValue(DateTimeOffset.Now.ToString("yyyy-MM-dd HH:mm:ss"));
if (SettingsVM.LibraryFoldersCollection.Any())
{
JsonArray array = new JsonArray();
foreach (var folder in SettingsVM.LibraryFoldersCollection)
{
array.Add(JsonValue.CreateStringValue(folder.Path));
}
jsonObject[foldersKey] = array;
}
try
{
StorageFile file = await ApplicationData.Current.TemporaryFolder.CreateFileAsync("lastplaying.mc", CreationCollisionOption.ReplaceExisting);
using (var stream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite))
{
using (var outputStream = stream.GetOutputStreamAt(0))
{
using (var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream))
{
dataWriter.WriteString(jsonObject.Stringify());
await dataWriter.StoreAsync();
await outputStream.FlushAsync();
}
}
}
}
catch (UnauthorizedAccessException ex)
{
await NotificationManager.ShowAsync("Error while saving player state!");
await Task.Delay(5000);
await NotificationManager.ShowAsync("Nothing Baking!");
}
}
private async void btnRndFile_Click(object sender, RoutedEventArgs e)
{
Random rnd = new Random(DateTime.Now.Millisecond);
double output;
StorageFolder storagefold = KnownFolders.MusicLibrary;
StorageFile randomFile = await storagefold.CreateFileAsync("EEGRnd.txt", CreationCollisionOption.ReplaceExisting);
var Stream = await randomFile.OpenAsync(FileAccessMode.ReadWrite);
using (var outEEGStream = Stream.GetOutputStreamAt(0))
{
using (var outEEG = new Windows.Storage.Streams.DataWriter(outEEGStream))
{
// create file
int count = 0;
int step = 0;
for (int index = 0; index < 512; index++)
{
count++;
for (int channel = 0; channel <= 15; channel++)
{
output = rnd.Next(-10, 9);
output += rnd.NextDouble();
if (count > 15)
{
count = 0;
step++;
}
if (step == 20)
{
step = 0;
}
if (channel < 15)
{
outEEG.WriteString(string.Format("{0:0.0000}, ", output));
}
else
{
outEEG.WriteString(string.Format("{0:0.0000}", output));
}
}
}
await outEEG.StoreAsync();
await outEEGStream.FlushAsync();
}
}
Stream.Dispose();
}
private BitmapImage GetBitmap(byte[] bytes)
{
var bmp = new BitmapImage();
using (var stream = new Windows.Storage.Streams.InMemoryRandomAccessStream())
{
using (var writer = new Windows.Storage.Streams.DataWriter(stream.GetOutputStreamAt(0)))
{
writer.WriteBytes(bytes);
writer.StoreAsync().GetResults();
bmp.SetSource(stream);
}
}
return bmp;
}
private static Windows.UI.Xaml.Media.Imaging.BitmapImage GetBitmap(byte[] bytes)
{
var bmp = new Windows.UI.Xaml.Media.Imaging.BitmapImage();
using (var stream = new Windows.Storage.Streams.InMemoryRandomAccessStream())
{
using (var writer = new Windows.Storage.Streams.DataWriter(stream.GetOutputStreamAt(0)))
{
writer.WriteBytes(bytes);
writer.StoreAsync().GetResults();
bmp.SetSource(stream);
}
}
return(bmp);
}
/// <summary>
/// Writes an array of Session objects to local storage.
/// </summary>
/// <param name="sessions">The Session objects to write. This is an array to force it to be a fixed collection by the time it gets here.</param>
/// <returns>A task that can be awaited until the storage completes.</returns>
public static async Task SerializeLocalSessions(Session[] sessions) {
var fileList = await ApplicationData.Current.LocalFolder.GetFilesAsync();
var scratchFile = await ApplicationData.Current.LocalFolder.CreateFileAsync(localScratchSessionsFileName, CreationCollisionOption.ReplaceExisting);
using (var storageTransaction = await scratchFile.OpenTransactedWriteAsync()) {
using (var dw = new Windows.Storage.Streams.DataWriter(storageTransaction.Stream)) {
dw.WriteInt32(sessions.Length);
for (int x = 0; x < sessions.Length; x++) {
sessions[x].WriteSession(dw);
}
storageTransaction.Stream.Size = await dw.StoreAsync();
await storageTransaction.CommitAsync();
}
}
await scratchFile.RenameAsync(localSessionsFileName, NameCollisionOption.ReplaceExisting);
}
private async System.Threading.Tasks.Task SendMessage(string message)
{
using (var stream = await socket.GetOutputStreamAsync(new Windows.Networking.HostName(externalIP), externalPort))
{
using (var writer = new Windows.Storage.Streams.DataWriter(stream))
{
var data = Encoding.UTF8.GetBytes(message);
writer.WriteBytes(data);
await writer.StoreAsync();
Debug.Log("Sent: " + message);
}
}
}
public async void saveFile(string content)
{
Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile dataFile = await storageFolder.CreateFileAsync("db.txt", Windows.Storage.CreationCollisionOption.ReplaceExisting);
var stream = await dataFile.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
using (var outputStream = stream.GetOutputStreamAt(0))
{
using (var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream))
{
dataWriter.WriteString(content);
await dataWriter.StoreAsync();
await outputStream.FlushAsync();
}
}
stream.Dispose();
}
private async Task WriteFileAsync(string filename, string content)
{
var folder = ApplicationData.Current.GetPublisherCacheFolder("SharedFolder");
var file = await folder.CreateFileAsync(filename, Windows.Storage.CreationCollisionOption.ReplaceExisting);
var fs = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
var outStream = fs.GetOutputStreamAt(0);
var dataWriter = new Windows.Storage.Streams.DataWriter(outStream);
dataWriter.WriteString(content);
await dataWriter.StoreAsync();
dataWriter.DetachStream();
await outStream.FlushAsync();
}
private async Task WriteFileAsync(string filename, string content)
{
var folder = ApplicationData.Current.GetPublisherCacheFolder("SharedFolder");
var file = await folder.CreateFileAsync(filename, Windows.Storage.CreationCollisionOption.ReplaceExisting);
var fs = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
var outStream = fs.GetOutputStreamAt(0);
var dataWriter = new Windows.Storage.Streams.DataWriter(outStream);
dataWriter.WriteString(content);
await dataWriter.StoreAsync();
dataWriter.DetachStream();
await outStream.FlushAsync();
}
private async void DownloadCardData()
{
string filename = "cards.txt";
Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile file = await storageFolder.CreateFileAsync(filename, Windows.Storage.CreationCollisionOption.ReplaceExisting);
file = await storageFolder.GetFileAsync(filename);
var stream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
using (var outputStream = stream.GetOutputStreamAt(0))
{
using (var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream))
{
dataWriter.WriteString("6014EAD5\nCDDCEED5");
await dataWriter.StoreAsync();
await outputStream.FlushAsync();
}
}
stream.Dispose();
LoadCardData();
}
private async void SaveDocument(IPlotModel model, String newDocument)
{
if (model == null)
{
var msg = new MessageDialog("График не создан, рассчитайте распределение", "Ошибка сохранения");
await msg.ShowAsync();
return;
}
var savePicker = new Windows.Storage.Pickers.FileSavePicker
{
SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary
};
savePicker.FileTypeChoices.Add("PDF Document", new List<string>() { ".pdf" });
savePicker.SuggestedFileName = newDocument;
StorageFile file = await savePicker.PickSaveFileAsync();
if (file != null)
{
CachedFileManager.DeferUpdates(file);
var stream = await file.OpenAsync(FileAccessMode.ReadWrite);
using (var outputStream = stream.GetOutputStreamAt(0))
{
using (var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream))
{
using (var memoryStream = new MemoryStream())
{
var pdf = new PdfExporter();
PdfExporter.Export(model, memoryStream, 1000, 400);
var bt = memoryStream.ToArray();
dataWriter.WriteBytes(bt);
await dataWriter.StoreAsync();
await outputStream.FlushAsync();
}
}
}
var status = await CachedFileManager.CompleteUpdatesAsync(file);
if (status == FileUpdateStatus.Complete)
{
var msg = new MessageDialog("По пути " + file.Path, "Файл сохранен");
await msg.ShowAsync();
}
else
{
var msg = new MessageDialog("Произошла ошибка сохранения");
await msg.ShowAsync();
}
}
}
private BitmapSource ReadDeviceIndependantBitmap(BinaryReader wmfReader, uint dibSize, out int width, out int height)
{
#if NETFX_CORE
var bmp = new BitmapImage();
var memStream = new Windows.Storage.Streams.InMemoryRandomAccessStream();
var dibBytes = wmfReader.ReadBytes((int)dibSize);
// int imageBytesOffset = 14;
//System.Runtime.InteropServices.GCHandle pinnedDib = System.Runtime.InteropServices.GCHandle.Alloc(dibBytes, System.Runtime.InteropServices.GCHandleType.Pinned);
//if (dibBytes[3] == 0x0C)
//{
// imageBytesOffset += 12;
//}
//else
//{
// var infoHeader = (BITMAPINFOHEADER)System.Runtime.InteropServices.Marshal.PtrToStructure(pinnedDib.AddrOfPinnedObject(), typeof(BITMAPINFOHEADER));
// imageBytesOffset += (int)infoHeader.biSize;
// switch ((BitCount)infoHeader.biBitCount)
// {
// case BitCount.BI_BITCOUNT_1:
// // 1 bit - Two colors
// imageBytesOffset += 4 * (colorUsed == 0 ? 2 : Math.Min(colorUsed, 2));
// break;
// case BitCount.BI_BITCOUNT_2:
// // 4 bit - 16 colors
// imageBytesOffset += 4 * (colorUsed == 0 ? 16 : Math.Min(colorUsed, 16));
// break;
// case BitCount.BI_BITCOUNT_3:
// // 8 bit - 256 colors
// imageBytesOffset += 4 * (colorUsed == 0 ? 256 : Math.Min(colorUsed, 256));
// break;
// }
// if ((Compression)infoHeader.biCompression == Compression.BI_BITFIELDS)
// {
// imageBytesOffset += 12;
// }
//}
//pinnedDib.Free();
using (Windows.Storage.Streams.DataWriter writer = new Windows.Storage.Streams.DataWriter(memStream.GetOutputStreamAt(0)))
{
writer.WriteBytes(new byte[] { 66, 77 }); // BM
writer.WriteUInt32(dibSize + 14);
writer.WriteBytes(new byte[] { 0, 0, 0, 0 }); // Reserved
writer.WriteUInt32((UInt32)0);
writer.WriteBytes(dibBytes);
var t = writer.StoreAsync();
t.GetResults();
}
// bmp.ImageFailed += bmp_ImageFailed;
// bmp.ImageOpened += bmp_ImageOpened;
bmp.SetSource(memStream);
width = bmp.PixelWidth;
height = bmp.PixelHeight;
return bmp;
#else
var bmp = new BitmapImage();
var memStream = new MemoryStream();
var dibBytes = wmfReader.ReadBytes((int)dibSize);
BinaryWriter writer = new BinaryWriter(memStream);
writer.Write(new byte[] { 66, 77 }); // BM
writer.Write(dibSize + 14);
writer.Write(new byte[] { 0, 0, 0, 0 }); // Reserved
writer.Write((UInt32)0);
writer.Write(dibBytes);
writer.Flush();
memStream.Position = 0;
try
{
bmp.BeginInit();
bmp.StreamSource = memStream;
bmp.EndInit();
width = bmp.PixelWidth;
height = bmp.PixelHeight;
return bmp;
}
catch
{
// Bad image;
width = 0;
height = 0;
return null;
}
#endif
}
/// <summary>
/// Writes a specified number of bytes to the serial port using data from a buffer.
/// </summary>
/// <param name="buffer">The byte array that contains the data to write to the port.</param>
/// <param name="offset">The zero-based byte offset in the buffer parameter at which to begin copying bytes to the port.</param>
/// <param name="count">The number of bytes to write.</param>
/// <remarks>
/// ArgumentException: offset plus count is greater than the length of the buffer.
/// </remarks>
public Windows.Foundation.IAsyncAction Write(
Windows.Storage.Streams.IBuffer buffer,
uint offset,
uint count
)
{
var outputStream = this.cdcData.BulkOutPipes[0].OutputStream;
var writer = new Windows.Storage.Streams.DataWriter(outputStream);
return Task.Run(async () =>
{
// Overflow check.
if ((int)buffer.Length < (offset + count))
{
throw new System.ArgumentException("Capacity of buffer is not enough.");
}
writer.WriteBuffer(buffer, offset, count);
var written = await writer.StoreAsync();
return;
}
).AsAsyncAction();
}
public async void SaveData() {
var fileList = await ApplicationData.Current.LocalFolder.GetFilesAsync();
System.IO.MemoryStream ms = new System.IO.MemoryStream();
var scratchFile = await ApplicationData.Current.LocalFolder.CreateFileAsync(localScratchFileName, CreationCollisionOption.ReplaceExisting);
using (var storageTransaction = await scratchFile.OpenTransactedWriteAsync()) {
using (var dw = new Windows.Storage.Streams.DataWriter(storageTransaction.Stream)) {
dw.WriteInt32(Items.Count);
for (int x = 0; x < Items.Count; x++) {
TrackItem item = Items[x];
dw.WriteDateTime(item.Start);
dw.WriteDateTime(item.End.Value);
dw.WriteInt32(item.Topic.Length);
dw.WriteString(item.Topic);
}
if (CurrentItem == null) {
dw.WriteBoolean(false);
} else {
dw.WriteBoolean(true);
dw.WriteDateTime(CurrentItem.Start);
dw.WriteInt32(CurrentItem.Topic.Length);
dw.WriteString(CurrentItem.Topic);
}
storageTransaction.Stream.Size = await dw.StoreAsync();
await storageTransaction.CommitAsync();
}
}
await scratchFile.RenameAsync(localFileName, NameCollisionOption.ReplaceExisting);
}