/// <summary>
/// Plays some nice welcome music that goes "Giiiiiiiiiiaaaaaaaaaaaaaaant Booooooooooooomb"
/// </summary>
/// <returns></returns>
private async Task PlayBackgroundAudio()
{
Windows.Storage.Streams.IRandomAccessStream stream = null;
try
{
AudioPlayer = new MediaElement();
Windows.Storage.StorageFile file = await Windows.Storage.StorageFile.GetFileFromApplicationUriAsync(new Uri(@"ms-appx:///Assets//WelcomePageAudio.mp3"));
if ((file != null) && File.Exists(file.Path))
{
using (stream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read))
{
AudioPlayer.SetSource(stream, file.ContentType);
AudioPlayer.Play();
// Audio file is 21 seconds long
await Task.Delay(22000);
}
stream.Dispose();
}
}
catch (Exception)
{
// No need to try any risky business for something as dumb as background audio
if (stream != null)
{
stream.Dispose();
}
}
}
private async void SaveAsFileViewerCommand()
{
Stream stream = pdfViewer.Save();
stream.Position = 0;
FileSavePicker savePicker = new FileSavePicker();
savePicker.DefaultFileExtension = ".pdf";
savePicker.FileTypeChoices.Add("Adobe PDF Document", new List <string>()
{
".pdf"
});
StorageFile stFile = await savePicker.PickSaveFileAsync();
if (stFile != null)
{
Windows.Storage.Streams.IRandomAccessStream fileStream = await stFile.OpenAsync(FileAccessMode.ReadWrite);
Stream st = fileStream.AsStreamForWrite();
st.SetLength(0);
st.Write((stream as MemoryStream).ToArray(), 0, (int)stream.Length);
st.Flush();
st.Dispose();
fileStream.Dispose();
}
}
private async void SaveButton_OnClick(object sender, RoutedEventArgs e)
{
string filename = "output.pdf";
Stream stream = pdfViewerControl.Save();
stream.Position = 0;
FileSavePicker savePicker = new FileSavePicker
{
DefaultFileExtension = ".pdf",
SuggestedFileName = filename
};
savePicker.FileTypeChoices.Add("Adobe PDF Document", new List <string>()
{
".pdf"
});
StorageFile stFile = await savePicker.PickSaveFileAsync();
if (stFile != null)
{
Windows.Storage.Streams.IRandomAccessStream fileStream = await stFile.OpenAsync(FileAccessMode.ReadWrite);
Stream streamForWrite = fileStream.AsStreamForWrite();
streamForWrite.SetLength(0);
streamForWrite.Write((stream as MemoryStream).ToArray(), 0, (int)stream.Length);
streamForWrite.Flush();
streamForWrite.Dispose();
fileStream.Dispose();
MessageDialog msgDialog = new MessageDialog("File has been saved successfully.");
IUICommand cmd = await msgDialog.ShowAsync();
}
}
private async void Open_Click(object sender, RoutedEventArgs e)
{
open.IsChecked = false;
Windows.Storage.Pickers.FileOpenPicker openPicker = new Windows.Storage.Pickers.FileOpenPicker();
openPicker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary;
openPicker.FileTypeFilter.Add(".gif");
Windows.Storage.StorageFile file = await openPicker.PickSingleFileAsync();
if (file != null)
{
Windows.Storage.Streams.IRandomAccessStream stream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read);
using (var inputStream = stream.GetInputStreamAt(0))
{
await canvas.InkPresenter.StrokeContainer.LoadAsync(inputStream);
}
stream.Dispose();
alreadySaved = true;
lastFile = file;
}
}
async void Save(Stream stream, string filename)
{
stream.Position = 0;
StorageFile stFile;
if (!(Windows.Foundation.Metadata.ApiInformation.IsTypePresent("Windows.Phone.UI.Input.HardwareButtons")))
{
FileSavePicker savePicker = new FileSavePicker();
savePicker.DefaultFileExtension = ".pdf";
savePicker.SuggestedFileName = "Sample";
savePicker.FileTypeChoices.Add("Adobe PDF Document", new List <string>()
{
".pdf"
});
stFile = await savePicker.PickSaveFileAsync();
}
else
{
StorageFolder local = Windows.Storage.ApplicationData.Current.LocalFolder;
stFile = await local.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting);
}
if (stFile != null)
{
Windows.Storage.Streams.IRandomAccessStream fileStream = await stFile.OpenAsync(FileAccessMode.ReadWrite);
Stream st = fileStream.AsStreamForWrite();
st.Write((stream as MemoryStream).ToArray(), 0, (int)stream.Length);
st.Flush();
st.Dispose();
fileStream.Dispose();
}
}
private async void SaveDocx(WordDocument doc)
{
StorageFile stgFile;
if (!(Windows.Foundation.Metadata.ApiInformation.IsTypePresent("Windows.Phone.UI.Input.HardwareButtons")))
{
FileSavePicker savePicker = new FileSavePicker();
savePicker.SuggestedStartLocation = PickerLocationId.DocumentsLibrary;
// Dropdown of file types the user can save the file as
savePicker.FileTypeChoices.Add("Word Document", new List <string>()
{
".docx"
});
// Default file name if the user does not type one in or select a file to replace
savePicker.SuggestedFileName = "Sample";
stgFile = await savePicker.PickSaveFileAsync();
}
else
{
StorageFolder local = Windows.Storage.ApplicationData.Current.LocalFolder;
stgFile = await local.CreateFileAsync("WordDocument.docx", CreationCollisionOption.ReplaceExisting);
}
if (stgFile != null)
{
MemoryStream stream = new MemoryStream();
await doc.SaveAsync(stream, FormatType.Docx);
doc.Close();
stream.Position = 0;
Windows.Storage.Streams.IRandomAccessStream fileStream = await stgFile.OpenAsync(FileAccessMode.ReadWrite);
Stream st = fileStream.AsStreamForWrite();
st.SetLength(0);
st.Write((stream as MemoryStream).ToArray(), 0, (int)stream.Length);
st.Flush();
st.Dispose();
fileStream.Dispose();
//Save as Docx Format
MessageDialog msgDialog = new MessageDialog("Do you want to view the Document?", "File has been created successfully.");
UICommand yesCmd = new UICommand("Yes");
msgDialog.Commands.Add(yesCmd);
UICommand noCmd = new UICommand("No");
msgDialog.Commands.Add(noCmd);
IUICommand cmd = await msgDialog.ShowAsync();
if (cmd == yesCmd)
{
// Launch the retrieved file
bool success = await Windows.System.Launcher.LaunchFileAsync(stgFile);
}
}
}
public static async void Save(Stream stream, string filename)
{
stream.Position = 0;
StorageFile stFile;
if (!Windows.Foundation.Metadata.ApiInformation.IsTypePresent("Windows.Phone.UI.Input.HardwareButtons"))
{
FileSavePicker savePicker = new FileSavePicker {
DefaultFileExtension = ".pdf",
SuggestedFileName = filename
};
savePicker.FileTypeChoices.Add("Adobe PDF Document", new List <string>()
{
".pdf"
});
stFile = await savePicker.PickSaveFileAsync();
}
else
{
StorageFolder local = ApplicationData.Current.LocalFolder;
stFile = await local.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting);
}
if (stFile != null)
{
Windows.Storage.Streams.IRandomAccessStream fileStream = await stFile.OpenAsync(FileAccessMode.ReadWrite);
Stream st = fileStream.AsStreamForWrite();
st.SetLength(0);
st.Write((stream as MemoryStream)?.ToArray(), 0, (int)stream.Length);
st.Flush();
st.Dispose();
fileStream.Dispose();
MessageDialog msgDialog = new MessageDialog("Do you want to view the Document?", "File created.");
UICommand yesCmd = new UICommand("Yes");
msgDialog.Commands.Add(yesCmd);
UICommand noCmd = new UICommand("No");
msgDialog.Commands.Add(noCmd);
IUICommand cmd = await msgDialog.ShowAsync();
if (cmd == yesCmd)
{
// Launch the retrieved file
bool success = await Windows.System.Launcher.LaunchFileAsync(stFile);
}
}
}
private async Task <Windows.Storage.StorageFile> ReencodePhotoAsync(
Windows.Storage.StorageFile tempStorageFile,
Windows.Storage.FileProperties.PhotoOrientation photoRotation)
{
Windows.Storage.Streams.IRandomAccessStream inputStream = null;
Windows.Storage.Streams.IRandomAccessStream outputStream = null;
Windows.Storage.StorageFile photoStorage = null;
try
{
inputStream = await tempStorageFile.OpenAsync(Windows.Storage.FileAccessMode.Read);
var decoder = await Windows.Graphics.Imaging.BitmapDecoder.CreateAsync(inputStream);
photoStorage = await Windows.Storage.KnownFolders.PicturesLibrary.CreateFileAsync(PHOTO_FILE_NAME, Windows.Storage.CreationCollisionOption.GenerateUniqueName);
outputStream = await photoStorage.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
outputStream.Size = 0;
var encoder = await Windows.Graphics.Imaging.BitmapEncoder.CreateForTranscodingAsync(outputStream, decoder);
var properties = new Windows.Graphics.Imaging.BitmapPropertySet();
properties.Add("System.Photo.Orientation",
new Windows.Graphics.Imaging.BitmapTypedValue(photoRotation, Windows.Foundation.PropertyType.UInt16));
await encoder.BitmapProperties.SetPropertiesAsync(properties);
await encoder.FlushAsync();
}
finally
{
if (inputStream != null)
{
inputStream.Dispose();
}
if (outputStream != null)
{
outputStream.Dispose();
}
var asyncAction = tempStorageFile.DeleteAsync(Windows.Storage.StorageDeleteOption.PermanentDelete);
}
return(photoStorage);
}
private async void SaveAsync()
{
folder = ApplicationData.Current.LocalFolder;
file = await folder.CreateFileAsync("SavedDocument.pdf", CreationCollisionOption.ReplaceExisting);
if (file != null)
{
Windows.Storage.Streams.IRandomAccessStream fileStream = await file.OpenAsync(FileAccessMode.ReadWrite);
Stream st = fileStream.AsStreamForWrite();
st.SetLength(0);
st.Write((stream as MemoryStream).ToArray(), 0, (int)stream.Length);
st.Flush();
st.Dispose();
fileStream.Dispose();
}
}
private async void Save_Click(object sender, RoutedEventArgs e)
{
save.IsChecked = false;
StorageFile file;
if (alreadySaved)
{
file = lastFile;
}
else
{
Windows.Storage.Pickers.FileSavePicker savePicker = new Windows.Storage.Pickers.FileSavePicker();
savePicker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.DocumentsLibrary;
savePicker.FileTypeChoices.Add("GIF with embedded ISF", new List <string>()
{
".gif"
});
savePicker.DefaultFileExtension = ".gif";
savePicker.SuggestedFileName = "Sketch";
file = await savePicker.PickSaveFileAsync();
}
if (file != null)
{
Windows.Storage.CachedFileManager.DeferUpdates(file);
Windows.Storage.Streams.IRandomAccessStream stream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
using (Windows.Storage.Streams.IOutputStream outputStream = stream.GetOutputStreamAt(0))
{
await canvas.InkPresenter.StrokeContainer.SaveAsync(outputStream);
await outputStream.FlushAsync();
}
stream.Dispose();
Windows.Storage.Provider.FileUpdateStatus status = await Windows.Storage.CachedFileManager.CompleteUpdatesAsync(file);
if (!alreadySaved)
{
alreadySaved = true;
lastFile = file;
}
}
}
public static Windows.Foundation.IAsyncAction RunOnce()
{
return(Task.Run(async() =>
{
System.Diagnostics.Debug.WriteLine("Lockscreen Change Task Runned");
if ((bool)SettingHelper.GetValue("wpt_enable") && (bool)SettingHelper.GetValue("wpt_lsenable"))
{
RequestURL = BackgroundChangeTasksNetworkHelper.BuildURL(BackgroundChangeTasksNetworkHelper.BCTType.Lockscreen);
BackgroundTaskPicInfo picInfo = JsonConvert.DeserializeObject <List <BackgroundTaskPicInfo> >(await BackgroundChangeTasksNetworkHelper.SendGETAsyncAsString(RequestURL))[0];
if (picInfo != null)
{
HttpResponseMessage res = await BackgroundChangeTasksNetworkHelper.SendGETAsyncAsBinary(picInfo.file_url);
StorageFile picFile = await Helper.Methods.CreateFileInMyFolderWithID(picInfo.id.ToString(), picInfo.file_url.Substring(picInfo.file_url.Length - 4));
Windows.Storage.Streams.IRandomAccessStream writeStream = await picFile.OpenAsync(FileAccessMode.ReadWrite);
await writeStream.WriteAsync(await res.Content.ReadAsBufferAsync());
writeStream.Dispose();
await Methods.SetPicAsWallPapaer(picFile, true);
}
}
}).AsAsyncAction());
}
private async Task <StorageFolder> SaveAsync(string name)
{
FolderPicker picker = new FolderPicker {
SuggestedStartLocation = PickerLocationId.ComputerFolder
};
picker.FileTypeFilter.Add("*");
StorageFolder folder = await picker.PickSingleFolderAsync();
if (folder != null)
{
using (UserDialogs.Instance.Loading("Téléchargement du document", null, null, true))
{
file = await folder.CreateFileAsync(name, CreationCollisionOption.GenerateUniqueName);
if (file != null)
{
Windows.Storage.Streams.IRandomAccessStream fileStream = await file.OpenAsync(FileAccessMode.ReadWrite);
Stream st = fileStream.AsStreamForWrite();
st.SetLength(0);
st.Write((stream as MemoryStream).ToArray(), 0, (int)stream.Length);
st.Flush();
st.Dispose();
fileStream.Dispose();
return(folder);
}
else
{
return(null);
}
}
}
else
{
return(null);
}
}
public static async System.Threading.Tasks.Task SavePathImageAsFile(int Width, int Height, string fileName, FrameworkElement element, bool UseRenderTarget = true)
{
double oldWidth = element.Width;
double oldHeight = element.Height;
double actOldWidth = element.ActualWidth;
double actOldHeight = element.ActualHeight;
//if (!UseRenderTarget)
{
//engine takes the Ceiling so make sure its below or sometimes off by 1 rounding up from ActualWidth/Height
element.Width = !UseRenderTarget?Math.Floor((float)Math.Min(Window.Current.Bounds.Width, Width)) : (float)Math.Min(Window.Current.Bounds.Width, Width);
element.Height = !UseRenderTarget?Math.Floor((float)Math.Min(Window.Current.Bounds.Height, Height)) : (float)Math.Min(Window.Current.Bounds.Height, Height);
//bool bHasCalledUpdateLayout = false;
//should wrap into another event handler and check a bHasCalledUpdateLayout to ignore early calls and race condition
//object lockVar = new object();
//EventHandler<object> eventHandler = null;
//System.Threading.Tasks.TaskCompletionSource<object> t = new System.Threading.Tasks.TaskCompletionSource<object>();
//eventHandler = (sender, e) => { lock (lockVar) { if (bHasCalledUpdateLayout && Math.Abs(element.ActualWidth - element.Width) <= 1 && Math.Abs(element.ActualHeight - element.Height) <= 1) { lock (lockVar) { if (bHasCalledUpdateLayout) { bHasCalledUpdateLayout = false; t.SetResult(e); } } } } };
//element.LayoutUpdated += eventHandler;
//lock (lockVar) {
// element.UpdateLayout();
// bHasCalledUpdateLayout = true;
//}
////await element.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, new Windows.UI.Core.DispatchedHandler(() => element.Dispatcher.ProcessEvents(Windows.UI.Core.CoreProcessEventsOption.ProcessAllIfPresent)));
//await t.Task;
//element.LayoutUpdated -= eventHandler;
await element.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Low, () => { });
if (!UseRenderTarget && (element.ActualWidth > element.Width || element.ActualHeight > element.Height))
{
if (element.ActualWidth > element.Width)
{
element.Width -= 1;
}
if (element.ActualHeight > element.Height)
{
element.Height -= 1;
}
//bHasCalledUpdateLayout = false;
//t = new System.Threading.Tasks.TaskCompletionSource<object>();
//eventHandler = (sender, e) => { lock (lockVar) { if (bHasCalledUpdateLayout && Math.Abs(element.ActualWidth - element.Width) <= 1 && Math.Abs(element.ActualHeight - element.Height) <= 1) { lock (lockVar) { if (bHasCalledUpdateLayout) { bHasCalledUpdateLayout = false; t.SetResult(e); } } } } };
//element.LayoutUpdated += eventHandler;
//lock (lockVar)
//{
// element.UpdateLayout();
// bHasCalledUpdateLayout = true;
//}
//await t.Task;
//element.LayoutUpdated -= eventHandler;
await element.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Low, () => { });
}
}
#if WINDOWS_APP && STORETOOLKIT
if (!UseRenderTarget)
{
System.IO.MemoryStream memstream = await WinRTXamlToolkit.Composition.WriteableBitmapRenderExtensions.RenderToPngStream(element);
Windows.Storage.StorageFile file = await Windows.Storage.ApplicationData.Current.LocalFolder.CreateFileAsync(fileName + ".png", Windows.Storage.CreationCollisionOption.ReplaceExisting);
Windows.Storage.Streams.IRandomAccessStream stream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
await stream.WriteAsync(memstream.GetWindowsRuntimeBuffer());
stream.Dispose();
}
else
{
#endif
//Canvas cvs = new Canvas();
//cvs.Width = Width;
//cvs.Height = Height;
//Windows.UI.Xaml.Shapes.Path path = new Windows.UI.Xaml.Shapes.Path();
//object val;
//Resources.TryGetValue((object)"PathString", out val);
//Binding b = new Binding
//{
// Source = (string)val
//};
//BindingOperations.SetBinding(path, Windows.UI.Xaml.Shapes.Path.DataProperty, b);
//cvs.Children.Add(path);
float dpi = Windows.Graphics.Display.DisplayInformation.GetForCurrentView().LogicalDpi;
Windows.UI.Xaml.Media.Imaging.RenderTargetBitmap wb = new Windows.UI.Xaml.Media.Imaging.RenderTargetBitmap();
await wb.RenderAsync(element, (int)((float)Width * 96 / dpi), (int)((float)Height * 96 / dpi));
Windows.Storage.Streams.IBuffer buf = await wb.GetPixelsAsync();
Windows.Storage.StorageFile file = await Windows.Storage.ApplicationData.Current.LocalFolder.CreateFileAsync(fileName + ".png", Windows.Storage.CreationCollisionOption.ReplaceExisting);
Windows.Storage.Streams.IRandomAccessStream stream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
//Windows.Graphics.Imaging.BitmapPropertySet propertySet = new Windows.Graphics.Imaging.BitmapPropertySet();
//propertySet.Add("ImageQuality", new Windows.Graphics.Imaging.BitmapTypedValue(1.0, Windows.Foundation.PropertyType.Single)); // Maximum quality
Windows.Graphics.Imaging.BitmapEncoder be = await Windows.Graphics.Imaging.BitmapEncoder.CreateAsync(Windows.Graphics.Imaging.BitmapEncoder.PngEncoderId, stream); //, propertySet);
be.SetPixelData(Windows.Graphics.Imaging.BitmapPixelFormat.Bgra8, Windows.Graphics.Imaging.BitmapAlphaMode.Premultiplied, (uint)wb.PixelWidth, (uint)wb.PixelHeight, dpi, dpi, buf.ToArray());
await be.FlushAsync();
await stream.GetOutputStreamAt(0).FlushAsync();
stream.Dispose();
#if WINDOWS_APP && STORETOOLKIT
}
#endif
//if (!UseRenderTarget)
{
element.Width = oldWidth;
element.Height = oldHeight;
//bHasCalledUpdateLayout = false;
//t = new System.Threading.Tasks.TaskCompletionSource<object>();
//eventHandler = (sender, e) => { lock (lockVar) { if (bHasCalledUpdateLayout && Math.Abs(element.ActualWidth - actOldWidth) <= 1 && Math.Abs(element.ActualHeight - actOldHeight) <= 1) { lock (lockVar) { if (bHasCalledUpdateLayout) { bHasCalledUpdateLayout = false; t.SetResult(e); } } } } };
//element.LayoutUpdated += eventHandler;
//lock (lockVar)
//{
// element.UpdateLayout();
// bHasCalledUpdateLayout = true;
//}
//await t.Task;
//element.LayoutUpdated -= eventHandler;
await element.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Low, () => { });
}
}