private async void WriteCSVFile(string file) { try { //StorageFolder storageFolder = KnownFolders.DocumentsLibrary; //sampleFile = await storageFolder.CreateFileAsync(file, CreationCollisionOption.GenerateUniqueName); sampleFile = await DownloadsFolder.CreateFileAsync(file, CreationCollisionOption.GenerateUniqueName); if (sampleFile != null) { string loggingstring = ""; foreach (string s in _loggingData) { loggingstring = loggingstring + s + "\n"; } string userContent = loggingstring; if (!String.IsNullOrEmpty(userContent)) { await FileIO.WriteTextAsync(sampleFile, userContent); //OutputTextBlock.Text = "The following text was written to '" + file.Name + "':" + Environment.NewLine + Environment.NewLine + userContent; } else { //OutputTextBlock.Text = "The text box is empty, please write something and then click 'Write' again."; } } } catch (FileNotFoundException) { this.NotifyUserFileNotExist(); } }
private async void print() { //var success = await Windows.System.Launcher.LaunchUriAsync(uri); try { LoaderText.Text = "Generando documento PDF..."; grdLoader.Visibility = Visibility.Visible; JsonObject result = await Finances.printCC(UserId); Uri uri = new Uri(result.GetNamedString("url")); string filename = result.GetNamedString("file_name"); StorageFile destinationFile = await DownloadsFolder.CreateFileAsync(filename, CreationCollisionOption.GenerateUniqueName); BackgroundDownloader downloader = new BackgroundDownloader(); DownloadOperation download = downloader.CreateDownload(uri, destinationFile); await HandleDownloadAsync(download, true); await Windows.System.Launcher.LaunchFileAsync(download.ResultFile); grdLoader.Visibility = Visibility.Collapsed; LoaderText.Text = ""; } catch (Exception ex) { var dialog = new MessageDialog(ex.Message); await dialog.ShowAsync(); } }
public static async Task LoadFromJSONAsync() { StorageFolder storageFolder = ApplicationData.Current.LocalFolder; try { StorageFile ConfigFile = await storageFolder.GetFileAsync(App.configfilename); string configtext = await FileIO.ReadTextAsync(ConfigFile); ConfigData localdata = JsonConvert.DeserializeObject <ConfigData>(configtext); if (localdata != null) { if (localdata.HistoricalSearch != null) { App.historysearch = localdata.HistoricalSearch; } App.MyDownLoadFolder = localdata.MyDownLoadFolder; App.AutoPlay = localdata.AutoPlay; App.DeleteCache = localdata.DeleteCache; App.AutoSaveSearch = localdata.AutoSaveSearch; } } catch (Exception) // first open in user's compute { // create configdata.json await storageFolder.CreateFileAsync(App.configfilename); // init download folder, add folder in FutureAccessList with token (App.MyDownLoadFolder) StorageFolder newFolder = await DownloadsFolder.CreateFolderAsync("Music", CreationCollisionOption.GenerateUniqueName); StorageApplicationPermissions.FutureAccessList.AddOrReplace(App.MyDownLoadFolder, newFolder); } }
public async Task SaveRecordedAudio(CoreDispatcher UiDispatcher) { IRandomAccessStream audio = buffer.CloneStream(); if (audio == null) { throw new ArgumentNullException("buffer"); } //StorageFolder storageFolder = Windows.ApplicationModel.Package.Current.InstalledLocation; /* * StorageFolder storageFolder = await DownloadsFolder.; * if (!string.IsNullOrEmpty(filename)) * { * StorageFile original = await storageFolder.GetFileAsync(filename); * await original.DeleteAsync(); * } */ await UiDispatcher.RunAsync(CoreDispatcherPriority.Normal, async() => { //StorageFile storageFile = await storageFolder.CreateFileAsync(audioFile, CreationCollisionOption.GenerateUniqueName); StorageFile storageFile = await DownloadsFolder.CreateFileAsync(audioFile, CreationCollisionOption.GenerateUniqueName); filename = storageFile.Name; using (IRandomAccessStream fileStream = await storageFile.OpenAsync(FileAccessMode.ReadWrite)) { await RandomAccessStream.CopyAndCloseAsync(audio.GetInputStreamAt(0), fileStream.GetOutputStreamAt(0)); await audio.FlushAsync(); audio.Dispose(); } //IRandomAccessStream stream = await storageFile.OpenAsync(FileAccessMode.Read); LogMessage($"File {storageFile.Name} saved to {storageFile.Path}"); }); }
/* * private async void DispatcherTimer_Tick(object sender, object e) * { * //StopTimer(); * * try * { * var status = await inkRecognizer.RecognizeAsync(); * if (status == HttpStatusCode.OK) * { * var root = inkRecognizer.GetRecognizerRoot(); * if (root != null) * { * output.Text = OutputWriter.Print(root); * } * } * } * catch(Exception ex) * { * output.Text = OutputWriter.PrintError(ex.Message); * } * } */ private async void OnClickRecognize(object Sender, RoutedEventArgs e) { try { var status = await inkRecognizer.RecognizeAsync(); if (status == HttpStatusCode.OK) { var root = inkRecognizer.GetRecognizerRoot(); if (root != null) { //output.Text = OutputWriter.Print(root) + inkRecognizer.json; output.Text = OutputWriter.Print(root); Debug.Write(inkRecognizer.json); StorageFile outputFile = await DownloadsFolder.CreateFileAsync("intermediary.json"); if (outputFile != null) { // Store file permissions for future access Windows.Storage.AccessCache.StorageApplicationPermissions.FutureAccessList.Add(outputFile); // Convert to Binary Buffer var buffer = Windows.Security.Cryptography.CryptographicBuffer.ConvertStringToBinary(inkRecognizer.json, Windows.Security.Cryptography.BinaryStringEncoding.Utf8); await Windows.Storage.FileIO.WriteBufferAsync(outputFile, buffer); } } } } catch (Exception ex) { output.Text = OutputWriter.PrintError(ex.Message); } }
/// <summary> /// The download. /// </summary> /// <returns> /// The <see cref="Task"/> to run asynchronously. /// </returns> private async Task Download() { var page = DataManager.CurrentPage; var url = page.Url.ToString(); var nameOnDisk = url.Substring(url.LastIndexOf("//", StringComparison.CurrentCultureIgnoreCase) + 2) .Replace(".", "_") .Replace("/", "-"); if (nameOnDisk.EndsWith("-")) { nameOnDisk = nameOnDisk.Substring(0, nameOnDisk.Length - 1); } var filename = string.Format("{0}.txt", nameOnDisk); var download = await DownloadsFolder.CreateFileAsync(filename, CreationCollisionOption.GenerateUniqueName); // await FileIO.WriteTextAsync(download, page.Text, Windows.Storage.Streams.UnicodeEncoding.Utf8); using (IRandomAccessStream stream = await download.OpenAsync(FileAccessMode.ReadWrite)) { await stream.WriteAsync(Encoding.UTF8.GetBytes(page.Text).AsBuffer()); await stream.FlushAsync(); } var dialog = new MessageDialog( "Successfully downloaded the page as text to your Downloads folder.", download.Name); await dialog.ShowAsync(); }
private async void Selection_Click_1(object sender, RoutedEventArgs e) { copy1.Text = "Copying...."; StorageFolder storeFolder = null; try { storeFolder = await DownloadsFolder.CreateFolderAsync(storfolder.Name.ToString(), CreationCollisionOption.GenerateUniqueName); if (ItemGridView.SelectedItems.Count != 0) { foreach (Item item in ItemGridView.SelectedItems) { //Uri uri = new Uri("ms-appdata:///local/" + item.Link); String[] filepath = parseString(item.Link); StorageFolder imageFolder = await Windows.Storage.ApplicationData.Current.LocalFolder.GetFolderAsync(filepath[0].Replace("/", "\\")); StorageFile storageFile = await imageFolder.GetFileAsync(filepath[1]); //StorageFile file = await Windows.Storage.StorageFile.GetFileFromApplicationUriAsync(uri); await storageFile.CopyAsync(storeFolder, item.Title, NameCollisionOption.GenerateUniqueName); } } } catch { DisplayMsg("Error copying selected files to Downloads!!!"); } ItemGridView.SelectedItems.Clear(); copy1.Text = "Copied to Downloads/ZipX/" + storeFolder.DisplayName; }
private static async Task InitDefaultDownloadFolder() { var futureAccessList = Windows.Storage.AccessCache.StorageApplicationPermissions.FutureAccessList; if (!(await DefaultDownloadFolderExists())) { bool created = false; int i = 1; do { try { var myfolder = await DownloadsFolder.CreateFolderAsync((i == 1)? "Received" : $"Received ({i})"); FutureAccessListHelper.MakeSureFutureAccessListIsNotFull(); futureAccessList.AddOrReplace(_downloadMainFolder, myfolder); created = true; } catch { i++; } }while (!created); } }
// **************************************************************************************************** // exporting all or filtered data grid records to an Excel spreadsheet in the Users Downloads folder // the Downloads folder does not have a -- CreationCollisionOption.ReplaceExisting -- therefore it will give an error // if the file already exists, we have overcome this by giving each file a unique name // the UWP app automatically creates a folder with the app name within the destination path private async void btnExportToXLS_Click(object sender, RoutedEventArgs e) { try { var options = new ExcelExportingOptions(); string date = DateTime.Now.Year.ToString() + "-" + DateTime.Now.Month.ToString() + "-" + DateTime.Now.Day.ToString() + "-" + DateTime.Now.Hour.ToString() + "h" + DateTime.Now.Minute.ToString() + "m" + DateTime.Now.Second.ToString() + "s"; options.ExcelVersion = ExcelVersion.Excel2010; // <----- this can be changed for Vision to -----> options.ExcelVersion = ExcelVersion.Excel2016; var excelEngine = dataGrid.ExportToExcel(dataGrid.View, options); var workBook = excelEngine.Excel.Workbooks[0]; StorageFile storageFile = await DownloadsFolder.CreateFileAsync("Velog_" + date + ".xlsx"); if (storageFile != null) { await workBook.SaveAsAsync(storageFile); txtFolderName.Text = "Downloads/VeLog <--- Copy & Paste in File Explorer"; txtFileName.Text = "Velog_" + date + ".xlsx <--- File Name"; var messageDialog = new MessageDialog("File successfully exported."); await messageDialog.ShowAsync(); } } catch (Exception ex) { var messageDialog = new MessageDialog("File NOT exported!" + "\n" + "Error: " + ex.Message); await messageDialog.ShowAsync(); } }
public async Task <StorageFile> GetDidacticsItemAttachmentAsync(Content content) { string requestUri = string.Format(DIDACTICS_ATTACHMENT_URL, authResponse.UserID, content.ID); HttpContent httpContent = await SendRequestAsync(HttpMethod.Get, requestUri, null); StorageFile file; if (httpContent.Headers.ContentDisposition == null) { if (httpContent.Headers.ContentType != null) { file = await DownloadsFolder.CreateFileAsync(string.Format("{0}.{1}", content.Name, MimeTypesMap.GetExtension(httpContent.Headers.ContentType.MediaType)), CreationCollisionOption.GenerateUniqueName); } else { file = await DownloadsFolder.CreateFileAsync(content.Name); } } else { file = await DownloadsFolder.CreateFileAsync(httpContent.Headers.ContentDisposition.FileName, CreationCollisionOption.GenerateUniqueName); } await FileIO.WriteBytesAsync(file, await httpContent.ReadAsByteArrayAsync()); return(file); }
private async void Stop_Click(object sender, RoutedEventArgs e) { //Send the stop command and save sample data to a csv file Stop.IsEnabled = false; Status.Text = (await Oven.Stop()).ToString(); try { var filename = $"{DateTime.Now:yyyy-MM-dd HHmmss}.csv"; var file = await DownloadsFolder.CreateFileAsync(filename); var lines = new List <string> { "RealTime,RecipeTime (s),Temperature (°C),Ambient Temp (°C),Set Power (W)" }; foreach (var sample in SampleData) { lines.Add($"{sample.RealTime:yyyy-MM-dd HH:mm:ss},{sample.Time},{sample.Temperature},{sample.Ambient},{sample.Power}"); } await FileIO.WriteLinesAsync(file, lines); await CachedFileManager.CompleteUpdatesAsync(file); } catch (Exception x) { await ShowError($"Error saving data file:{Environment.NewLine}{x.Message}"); } Stop.IsEnabled = true; }
private async void WriteCSVFile(string file) { try { _sampleFile = await DownloadsFolder.CreateFileAsync(file, CreationCollisionOption.GenerateUniqueName); if (_sampleFile != null) { string loggingstring = ""; foreach (string s in _loggingData) { loggingstring = loggingstring + s + "\n"; } string userContent = loggingstring; if (!String.IsNullOrEmpty(userContent)) { await FileIO.WriteTextAsync(_sampleFile, userContent); } else { } } } catch (FileNotFoundException) { this.NotifyUserFileNotExist(); } }
public IAsyncOperation <TData> GetAsync <TData>(Uri uri, TData obj) where TData : class { refineUri(ref uri); return(Run(async token => { var resT = this.HttpClient.GetAsync(uri); token.Register(resT.Cancel); var resp = await resT; var str = await resp.Content.ReadAsStringAsync(); try { var file = await DownloadsFolder.CreateFileAsync(uri.PathAndQuery.Replace('/', '.'), CreationCollisionOption.FailIfExists); await FileIO.WriteTextAsync(file, str); } catch (Exception) { } var res = new Response <TData>(obj); JsonConvert.PopulateObject(str, res, jsonSettings); if (!res.Success) { throw AnitamaServerException.Create(res); } return obj; })); }
private async void Button_Click(object sender, RoutedEventArgs e) { //Generate PDF var renderer = new HtmlToPdf { PrintOptions = new PdfPrintOptions { PaperSize = PdfPrintOptions.PdfPaperSize.Letter, PaperOrientation = PdfPrintOptions.PdfPaperOrientation.Portrait, RenderDelay = 1000, Footer = new SimpleHeaderFooter { RightText = "Page {page} of {total-pages}", FontSize = 8 } } }; var pdf = await renderer.RenderUrlAsPdfAsync(new Uri("https://ironpdf.com/")); //Save PDF to file in Downloads/IronPdfUwp/ var newFile = await DownloadsFolder.CreateFileAsync("UWP-test.pdf", CreationCollisionOption.GenerateUniqueName); var fileStream = await newFile.OpenStreamForWriteAsync(); if (fileStream.CanWrite) { await fileStream.WriteAsync(pdf.BinaryData, 0, pdf.BinaryData.Length); } fileStream.Close(); }
public static IAsyncAction Download(Uri fileUri) { return(Run(async token => { var d = new BackgroundDownloader { FailureToastNotification = failedToast }; var file = await DownloadsFolder.CreateFileAsync($"{fileUri.GetHashCode():X}.TsinghuaNet.temp", CreationCollisionOption.GenerateUniqueName); var downloadOperation = d.CreateDownload(fileUri, file); downloadOperation.StartAsync().Completed = async(sender, e) => { string name = null; var resI = downloadOperation.GetResponseInformation(); if (resI != null) { if (resI.Headers.TryGetValue("Content-Disposition", out name)) { var h = HttpContentDispositionHeaderValue.Parse(name); name = h.FileName; if (string.IsNullOrWhiteSpace(name)) { name = null; } } name = name ?? getFileNameFromUri(resI.ActualUri); } name = name ?? getFileNameFromUri(fileUri); name = toValidFileName(name); await file.RenameAsync(name, NameCollisionOption.GenerateUniqueName); var fToken = StorageApplicationPermissions.MostRecentlyUsedList.Add(file); NotificationService.NotificationService.SendToastNotification(LocalizedStrings.Toast.DownloadSucceed, name, handler, fToken); }; })); }
//downloads a file given the Download file public async Task <StorageFile> DownloadFileAsync(Download download) { //initiate a blank file StorageFile file = null; //ensure that provided Download is not empty if (download != null) { //create file in downloads folder, ensure file renames if there's a duplicate file = await DownloadsFolder.CreateFileAsync(download.DownloadName, CreationCollisionOption.GenerateUniqueName); //create download operation downloadOperation = downloader.CreateDownload(download.DownloadUrl, file); //initiate cancellation token cancellationToken = new CancellationTokenSource(); try { //attempt to download file download.Status = "downloading"; await downloadOperation.StartAsync().AsTask(cancellationToken.Token); download.Status = "complete"; } catch (TaskCanceledException) { //if download fails delete file and release downloadOperation await downloadOperation.ResultFile.DeleteAsync(); downloadOperation = null; download.Status = "cancelled"; } } //if download is successful, return the downloaded file. return(file); }
public async void CreatePDFAsync(string filename) { StorageFile storage_file = await DownloadsFolder.CreateFileAsync(filename, CreationCollisionOption.GenerateUniqueName); Debug.WriteLine("Creating PDF file - " + storage_file.DisplayName); writePDFAsync(storage_file); }
public async void SaveFile(string url) { BackgroundDownloader _downloader = new BackgroundDownloader();; String fileName = Path.GetFileName(url); IStorageFile newFile = await DownloadsFolder.CreateFileAsync(fileName, CreationCollisionOption.GenerateUniqueName); var newDownload = _downloader.CreateDownload(new Uri(url), newFile); await newDownload.StartAsync(); }
private async void CreateFolder_Tapped(object sender, TappedRoutedEventArgs e) { var futureAccessList = Windows.Storage.AccessCache.StorageApplicationPermissions.FutureAccessList; var myfolder = await DownloadsFolder.CreateFolderAsync("QuickShare"); futureAccessList.Clear(); futureAccessList.AddOrReplace("downloadMainFolder", myfolder); }
private async void LoadSettings() { if (!settings.Values.ContainsKey(SavePathKey)) { var downloadFolder = await DownloadsFolder.CreateFolderAsync("SharedFiles", CreationCollisionOption.GenerateUniqueName); settings.Values.Add(SavePathKey, downloadFolder.Path); } SavePathField.Text = settings.Values[SavePathKey].ToString(); }
/// <summary> /// Method which downloads a voicemail message. /// </summary> /// <param name="message">The voicemail message to download</param> /// <returns></returns> public async Task <StorageFile> DownloadMessage(Message message) { StorageFile file = await DownloadsFolder.CreateFileAsync(string.Format("{0} {1}.wav", message.Sender, message.DateTime.Replace(':', '-')), CreationCollisionOption.GenerateUniqueName); IBuffer buffer = await _client.GetBufferAsync(message.Source); await FileIO.WriteBufferAsync(file, buffer); return(file); }
public async void Save(string url, string filename) { StorageFile file = await DownloadsFolder.CreateFileAsync(filename + ".png", CreationCollisionOption.GenerateUniqueName); HttpClient client = new HttpClient(); byte[] buffer = await client.GetByteArrayAsync(url); using (Stream stream = await file.OpenStreamForWriteAsync()) stream.Write(buffer, 0, buffer.Length); }
public async Task <StorageFile> GetNoticeboardItemAttachmentAsync(string evtCode, int pubId, int attachNum) { string requestUri = string.Format(NOTICEBOARD_ATTACHMENT_URL, authResponse.UserID, evtCode, pubId, attachNum); HttpContent httpContent = await SendRequestAsync(HttpMethod.Get, requestUri, null); StorageFile file = await DownloadsFolder.CreateFileAsync(httpContent.Headers.ContentDisposition.FileName, CreationCollisionOption.GenerateUniqueName); await FileIO.WriteBytesAsync(file, await httpContent.ReadAsByteArrayAsync()); return(file); }
// This method creates a new certificate which can be used for the UWP application. // Note that the certificate is saved at Downloads/Client.Uwp/Client.Uwp.pfx. // To take use of the certificate you may copy it to the Assets of the project and // change the "Build Action"-Property of the file (in Visual Studio) to "Content". private async void CreateCertificate() { var settings = new OpcCertificateSettings("Client.Uwp"); var certificate = OpcCertificateManager.CreateCertificate(settings); var newFile = await DownloadsFolder.CreateFileAsync("Client.Uwp.pfx"); using (var stream = await newFile.OpenStreamForWriteAsync()) { var data = certificate.Export(X509ContentType.Pfx); stream.Write(data, 0, data.Length); } }
} // Download private async Task DownLoadFromAs(string inputURL, string filename, string albumcover = "") { StorageFolder MyDownloadFolder; // 定位 folder try { MyDownloadFolder = await StorageApplicationPermissions.FutureAccessList.GetFolderAsync(App.MyDownLoadFolder); } catch (Exception) { MyDownloadFolder = await DownloadsFolder.CreateFolderAsync("Music", CreationCollisionOption.GenerateUniqueName); StorageApplicationPermissions.FutureAccessList.AddOrReplace(App.MyDownLoadFolder, MyDownloadFolder); } // check if exists music file try { StorageFile destinationFile = await MyDownloadFolder.CreateFileAsync(filename, CreationCollisionOption.FailIfExists); if (destinationFile != null) { if (PlayArea.Height >= DefaultHeight) { TextBlockStatus.Text = "0%"; DownloadBar.Value = 0; await DownloadBoard.Fade(value : 1.0f, duration : 500, delay : 0, easingType : EasingType.Default).StartAsync(); } Uri source = new Uri(inputURL); BackgroundDownloader downloader = new BackgroundDownloader(); DownloadOperation download = downloader.CreateDownload(source, destinationFile); Progress <DownloadOperation> progress = new Progress <DownloadOperation>(x => ProgressChanged(download)); cancellationToken = new CancellationTokenSource(); await download.StartAsync().AsTask(cancellationToken.Token, progress); if (DownloadBoard.Opacity == 1.0) { await DownloadBoard.Fade(value : 0.0f, duration : 1000, delay : 1000, easingType : EasingType.Default).StartAsync(); } } } catch (Exception) { // music exist FlyoutBase.ShowAttachedFlyout(DownLoadButton); } }
public async void CreateLog(string filename) { try { StorageFile logFile = await DownloadsFolder.CreateFileAsync(filename + ".csv", Windows.Storage.CreationCollisionOption.GenerateUniqueName); Log(logFile, LogText.Text); } catch (Exception e) { Debug.WriteLine(e); } }
// region Save label private async Task <bool> SaveLabel() { // Create sample file; replace if exists. if (file != null) { string filename = "label_" + file.Name.Replace(".jpg", ".txt"); StorageFile output = await DownloadsFolder.CreateFileAsync(filename); // Collect labels List <string> labels = new List <string>(); string lineLabels; for (int i = 0; i < 20; i++) { lineLabels = string.Empty; // Collect data for line for (int j = 0; j < 20; j++) { // Get rect var selected = LabelingArea.Children[20 * j + i + 1]; if (selected is Rectangle) { Rectangle rect = (Rectangle)selected; // Add label to line if ((rect.Fill as SolidColorBrush).Equals(background)) { lineLabels += "0,"; } if ((rect.Fill as SolidColorBrush).Equals(bee)) { lineLabels += "1,"; } if ((rect.Fill as SolidColorBrush).Equals(mite)) { lineLabels += "2,"; } } } labels.Add(lineLabels); } // Write line data to file await FileIO.WriteLinesAsync(output, labels); } return(true); }
private async Task <byte[]> getByteArrayFromStream(IRandomAccessStream stream, bool swap = false) { var result = new byte[stream.Size]; if (swap) { using (var output = new InMemoryRandomAccessStream()) { using (var reader = new DataReader(stream.GetInputStreamAt(0))) { //reader.ByteOrder = ByteOrder.LittleEndian; using (var writer = new DataWriter(output)) { //writer.ByteOrder = ByteOrder.BigEndian; await reader.LoadAsync((uint)stream.Size); while (0 < reader.UnconsumedBufferLength) { var number = reader.ReadUInt16(); var bytes_number = BitConverter.GetBytes(number); writer.WriteBytes(bytes_number); } await writer.StoreAsync(); await writer.FlushAsync(); writer.DetachStream(); output.Seek(0); } reader.DetachStream(); } await output.ReadAsync(result.AsBuffer(), (uint)stream.Size, InputStreamOptions.None); var folder = await DownloadsFolder.CreateFileAsync(DateTime.UtcNow.Ticks + ".out"); using (var file = await folder.OpenStreamForWriteAsync()) { await file.WriteAsync(result, 0, result.Length); await file.FlushAsync(); } } } else { await stream.ReadAsync(result.AsBuffer(), (uint)stream.Size, InputStreamOptions.None); } return(result); }
private async void csvButton_Click(object sender, RoutedEventArgs e) { StorageFile newFile = await DownloadsFolder.CreateFileAsync("graph.svg", CreationCollisionOption.GenerateUniqueName); await Task.Run(async() => { using (Stream outputStream = await newFile.OpenStreamForWriteAsync()) { var exporter = new SvgExporter { Width = 600, Height = 400 }; exporter.Export(MyModel, outputStream); } }); }
public async void CreateSurveyFolder(object sender, RoutedEventArgs e) { App.surveyFolder = await DownloadsFolder.CreateFolderAsync(SurveyNameInput.Text, CreationCollisionOption.FailIfExists); //ApplicationData.Current.LocalFolder.CreateFolderAsync(SurveyNameInput.Text, CreationCollisionOption.FailIfExists); App.surveyFile = await App.surveyFolder.CreateFileAsync(SurveyNameInput.Text + ".json", CreationCollisionOption.ReplaceExisting); App.assetsFolder = await App.surveyFolder.CreateFolderAsync("Assets", CreationCollisionOption.FailIfExists); /*folderPicker.FileTypeFilter.Add("*"); * folderPicker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.Desktop; * App.surveyFolder = await folderPicker.PickSingleFolderAsync();*/ if (App.surveyFolder != null) { CurrentPageFrame.Navigate(typeof(SurveyPages.TitlePage)); } }