public async Task OpenFolderAsync(File file)
{
if (file == null || !file.Local.IsFileExisting())
{
return;
}
var cached = await _protoService.GetFileAsync(file);
if (cached == null)
{
return;
}
try
{
var folder = await cached.GetParentAsync();
var options = new FolderLauncherOptions();
options.ItemsToSelect.Add(cached);
await Launcher.LaunchFolderAsync(folder, options);
}
catch { }
}
private async void LaunchFolder_Click(object sender, RoutedEventArgs e)
{
var options = new FolderLauncherOptions();
options.DesiredRemainingView = ViewSizePreference.UseHalf;
await Launcher.LaunchFolderAsync(KnownFolders.PicturesLibrary, options);
}
public static async Task LaunchExplorerAtFolderAsync()
{
var result = await GetFolderSilentAsync();
switch (result.GetResult)
{
case GetFolderResult.Reason.NoSuchFolder:
{
var dlg = new MessageDialog("the eBook Reader folder cannot be reached. Is the eBook connected?");
await dlg.ShowAsync();
}
break;
case GetFolderResult.Reason.NotSet:
{
var dlg = new MessageDialog("No eBook Reader folder has been saved. The Send To eBook Reader command will set this value.");
await dlg.ShowAsync();
}
break;
case GetFolderResult.Reason.Ok:
var folder = result.Folder;
var launchOptions = new FolderLauncherOptions();
launchOptions.DesiredRemainingView = Windows.UI.ViewManagement.ViewSizePreference.UseMore;
await Launcher.LaunchFolderAsync(folder, launchOptions);
break;
}
}
public static async Task SavePhotoAsync(TLPhotoSize photoSize, int date, bool downloads)
{
var location = photoSize.Location;
var fileName = string.Format("{0}_{1}_{2}.jpg", location.VolumeId, location.LocalId, location.Secret);
if (File.Exists(FileUtils.GetTempFileName(fileName)))
{
var resultName = "photo_" + DateTime.Now.ToString("yyyy-MM-dd_HH-mm-ss") + ".jpg";
if (downloads)
{
var folder = await GetDownloadsAsync();
if (folder == null)
{
return;
}
StorageFile file;
if (StorageApplicationPermissions.FutureAccessList.ContainsItem(fileName))
{
file = await StorageApplicationPermissions.FutureAccessList.GetFileAsync(fileName);
}
else
{
file = await folder.CreateFileAsync(resultName, CreationCollisionOption.GenerateUniqueName);
StorageApplicationPermissions.FutureAccessList.AddOrReplace(fileName, file);
var result = await FileUtils.GetTempFileAsync(fileName);
await result.CopyAndReplaceAsync(file);
}
if (UIViewSettings.GetForCurrentView().UserInteractionMode == UserInteractionMode.Mouse)
{
var options = new FolderLauncherOptions();
options.ItemsToSelect.Add(file);
await Launcher.LaunchFolderAsync(folder, options);
}
}
else
{
var picker = new FileSavePicker();
picker.FileTypeChoices.Add("JPEG Image", new[] { ".jpg" });
picker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
picker.SuggestedFileName = resultName;
var file = await picker.PickSaveFileAsync();
if (file != null)
{
var result = await FileUtils.GetTempFileAsync(fileName);
await result.CopyAndReplaceAsync(file);
}
}
}
}
/// <summary>
/// Opens the specified folder with the specified file highlighted/selected.
/// </summary>
/// <param name="folder">The folder to launch.</param>
/// <param name="fileToSelect">The file to select in the launched folder.</param>
/// <returns>A task that resolves when the operation is completed.</returns>
public async Task LaunchFolderWithSelectionAsync(IStorageFolder folder, ITestableFile fileToSelect)
{
FolderLauncherOptions options = new FolderLauncherOptions();
options.ItemsToSelect.Add(fileToSelect.AsIStorageItem);
await Launcher.LaunchFolderAsync(folder, options);
}
public static async Task ExplorePath(StorageFolder folder, StorageFile Flie)
{
//System.Diagnostics.Process.Start(AppDomain.CurrentDomain.BaseDirectory);
var t = new FolderLauncherOptions();
t.ItemsToSelect.Add(Flie);
await Launcher.LaunchFolderAsync(folder, t);
}
internal static async Task <bool> LaunchFolderAndSelectItems(IStorageFolder folder, IEnumerable <IStorageItem> selectedItems)
{
FolderLauncherOptions options = new FolderLauncherOptions();
foreach (var item in selectedItems)
{
options.ItemsToSelect.Add(item);
}
return(await Launcher.LaunchFolderAsync(folder, options));
}
async Task <bool> PlatformLaunchFolder(IFolder folder, IEnumerable <Platform.Storage.IStorageItem> itemsToSelect)
{
var options = new FolderLauncherOptions();
foreach (var item in itemsToSelect)
{
options.ItemsToSelect.Add(item.Context as Windows.Storage.IStorageItem);
}
return(await Launcher.LaunchFolderAsync(folder.Context as IStorageFolder, options));
}
private async void MenuFlyoutRevealExplorer_Click(object sender, RoutedEventArgs e)
{
if (SongFlyout.Target is SelectorItem s)
{
string path = null;
switch (s.Content)
{
case GenericMusicItemViewModel g:
switch (g.InnerType)
{
case MediaType.Song:
if (g.IsOnline)
{
throw new InvalidOperationException("Can't open an online file");
}
path = (await g.GetSongsAsync())[0].FilePath;
break;
case MediaType.Album:
break;
case MediaType.PlayList:
break;
case MediaType.Artist:
break;
default:
break;
}
break;
case SongViewModel song:
path = song.FilePath;
break;
case AlbumViewModel album:
break;
case ArtistViewModel artist:
break;
default:
break;
}
if (!path.IsNullorEmpty())
{
var file = await StorageFile.GetFileFromPathAsync(path);
var option = new FolderLauncherOptions();
option.ItemsToSelect.Add(file);
await Launcher.LaunchFolderAsync(await file.GetParentAsync(), option);
}
}
}
private async void ExportBoard_Tapped(object sender, TappedRoutedEventArgs e)
{
// Trigger loading screen while creating the document
IsBusy = true;
string fileName = $"{SelectedBoard.BoardName}.docx";
StorageFolder localFolder = ApplicationData.Current.LocalFolder;
string filepath = $"{localFolder.Path}/{fileName}";
ApplicationDataContainer localSettings = ApplicationData.Current.LocalSettings;
string authorname = (string)localSettings.Values["AuthorName"];
// Only when prepare to write to file, update Hour in Board object
SelectedBoard.Hours = DataAccess.GetAllHourInBoard(SelectedBoard.ID);
var writer = new DataOutput(SelectedBoard, authorname, filepath);
writer.WriteToFile();
// End loading screen
IsBusy = false;
var folderPicker = new Windows.Storage.Pickers.FolderPicker
{
SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.Desktop
};
folderPicker.FileTypeFilter.Add("*");
StorageFolder folder = await folderPicker.PickSingleFolderAsync();
if (folder != null)
{
// Application now has read/write access to all contents in the picked folder
// (including other sub-folder contents)
Windows.Storage.AccessCache.StorageApplicationPermissions.FutureAccessList.AddOrReplace("PickedFolderToken", folder);
StorageFile newFile = await localFolder.GetFileAsync(fileName);
await newFile.MoveAsync(folder, fileName, NameCollisionOption.ReplaceExisting);
// Add option to make the explorer select the newly created file
var ItemToSelect = await folder.GetFileAsync(fileName);
var option = new FolderLauncherOptions();
option.ItemsToSelect.Add(ItemToSelect);
// Open system file explorer to where the user has saved the word file
await Launcher.LaunchFolderAsync(folder, option);
}
}
internal async Task FindFileAsync()
{
if (Song.IsOnline)
{
throw new InvalidOperationException("Can't open an online file");
}
var file = await StorageFile.GetFileFromPathAsync(Song.Song.FilePath);
var option = new FolderLauncherOptions();
option.ItemsToSelect.Add(file);
await Launcher.LaunchFolderAsync(await file.GetParentAsync(), option);
}
private async void OpenDirectoryButton(object sender, RoutedEventArgs e)
{
Button btn = (Button)sender;
FileDiscoveryCache cache = btn.DataContext as FileDiscoveryCache;
StorageFile file = await StorageFile.GetFileFromPathAsync(cache.FilePath);
StorageFolder folder = await file.GetParentAsync();
if (folder != null)
{
FolderLauncherOptions launchOptions = new FolderLauncherOptions();
launchOptions.ItemsToSelect.Add(file);
StorageTask.OpenFolderInExplorer(folder, launchOptions);
}
}
public async Task ShowItemInExplorer(LibraryItem item)
{
if (item == null)
{
return;
}
StorageFolder folder = await GetStorageFolderForItem(item);
IStorageItem storageItem = await folder.TryGetItemAsync(GetFileNameFromFullPath(item.FilePath));
if (storageItem != null)
{
FolderLauncherOptions options = new FolderLauncherOptions();
options.ItemsToSelect.Add(storageItem);
await Launcher.LaunchFolderAsync(folder, options);
}
}
private async void OnLaunchFolderSelectedItems(object sender, RoutedEventArgs e)
{
try
{
string imageFile1 = @"\Assets\Share\espresso_450x450.jpg";
string imageFile2 = @"\Assets\Share\AlienFile.wechat";
string installPath = Package.Current.InstalledLocation.Path;
StorageFile file1 = await StorageFile.GetFileFromPathAsync(installPath + imageFile1);
StorageFile file2 = await StorageFile.GetFileFromPathAsync(installPath + imageFile2);
StorageFolder folder = await StorageFolder.GetFolderFromPathAsync(installPath + @"\Assets\Share");
if (folder != null)
{
FolderLauncherOptions options = new FolderLauncherOptions();
options.ItemsToSelect.Add(file1);
options.ItemsToSelect.Add(file2);
bool success = await Launcher.LaunchFolderAsync(folder, options);
if (success)
{
status.Log(string.Format(CultureInfo.CurrentCulture,
LocalizableStrings.LAUNCHERS_FOLDER_SELECTED_SUCCESS, installPath));
}
else
{
status.Log(string.Format(CultureInfo.CurrentCulture,
LocalizableStrings.LAUNCHERS_FOLDER_SELECTED_SUCCESS, installPath));
}
}
else
{
status.Log(string.Format(CultureInfo.CurrentCulture,
LocalizableStrings.LAUNCHERS_OPEN_FOLDER_FAIL, installPath));
}
}
catch (Exception ex)
{
Debug.WriteLine("LaunchersPage.OnLaunchFolderSelectedItems: " + ex.ToString());
status.Log(ex.Message);
}
}
async void OpenSongLocation(object file)
{
var mp3File = file as Mediafile;
if (mp3File == null)
{
mp3File = Player.CurrentlyPlayingFile;
}
StorageFolder folder = await StorageFolder.GetFolderFromPathAsync(System.IO.Path.GetDirectoryName(mp3File.Path));
if (folder != null)
{
StorageFile storageFile = await StorageFile.GetFileFromPathAsync(mp3File.Path);
var folderOptions = new FolderLauncherOptions();
folderOptions.ItemsToSelect.Add(storageFile);
await Launcher.LaunchFolderAsync(folder, folderOptions);
}
}
public async Task OpenContainingFolder(bool checkForReference)
{
IStorageFolder folder;
IStorageFile fileToSelect;
if (checkForReference && ReferenceFile.IsReferenceFile(File))
{
ReferenceFile referenceFile = await ReferenceFile.GetFile(File);
if (referenceFile.ReferencedFile == null)
{
folder = await StorageHelpers.ToStorageItem <StorageFolder>(Path.GetDirectoryName(File.Path));
fileToSelect = File;
}
else
{
folder = await StorageHelpers.ToStorageItem <StorageFolder>(Path.GetDirectoryName(referenceFile.ReferencedFile.Path));
fileToSelect = referenceFile.ReferencedFile;
}
}
else
{
folder = await StorageHelpers.ToStorageItem <StorageFolder>(Path.GetDirectoryName(File.Path));
fileToSelect = File;
}
if (folder != null)
{
FolderLauncherOptions launcherOptions = new FolderLauncherOptions();
if (File != null)
{
launcherOptions.ItemsToSelect.Add(fileToSelect);
}
await Launcher.LaunchFolderAsync(folder, launcherOptions);
}
}
/// <summary>
/// Starts the file explorer by using the <seealso cref="fileProtocol"/>. If the <paramref name="protocol"/> contains only the
/// directory it opens the file explorer with the provided directory. If <paramref name="protocol"/> points to a file, it opens
/// the file explorer with the related directory and selects the given file.
/// </summary>
/// <param name="protocol">E.g. file:///C:\Users\user\Downloads or file:///C:\Users\user\Downloads\2020.11.23-46.26.jpg</param>
/// <returns></returns>
public async Task <bool> LaunchFileExplorerAsync(string protocol)
{
IStorageItem storageItem = await TryGetStorageItemFromProtocol(protocol);
if (storageItem is IStorageFolder storageFolder)
{
return(await Launcher.LaunchFolderAsync(storageFolder, new FolderLauncherOptions()
{
}));
}
else if (storageItem is IStorageFile storageFile)
{
FolderLauncherOptions folderLauncherOptions = new FolderLauncherOptions();
folderLauncherOptions.ItemsToSelect.Add(storageFile);
var path = System.IO.Path.GetDirectoryName(storageFile.Path);
var storagefolder = await StorageFolder.GetFolderFromPathAsync(path);
return(await Launcher.LaunchFolderAsync(storagefolder, folderLauncherOptions));
}
throw new NotImplementedException($"{nameof(TryGetStorageItemFromProtocol)} should return {nameof(IStorageFolder)} or {nameof(IStorageFile)}");
}
private async void btnOpenFloader_Click(object sender, RoutedEventArgs e)
{
//FolderPicker p = new FolderPicker();
StorageFolder savePath;
var myMusic = await Windows.Storage.StorageLibrary.GetLibraryAsync(Windows.Storage.KnownLibraryId.Music);
var root = myMusic.SaveFolder;
var list = await root.GetFoldersAsync();
if (list.Where(x => x.Name == FolderName).FirstOrDefault() != null)
{
savePath = await root.GetFolderAsync(FolderName);
}
else
{
savePath = await root.CreateFolderAsync(FolderName);
}
var t = new FolderLauncherOptions();
await Launcher.LaunchFolderAsync(savePath, t);
//await FullTrustProcessLauncher.LaunchFullTrustProcessForCurrentAppAsync("lrts");
}
public static async Task SaveDocumentAsync(TLDocument document, int date, bool downloads)
{
var fileName = document.GetFileName();
if (File.Exists(FileUtils.GetTempFileName(fileName)))
{
var extension = document.GetFileExtension();
var resultName = "document_" + DateTime.Now.ToString("yyyy-MM-dd_HH-mm-ss") + extension;
var fileNameAttribute = document.Attributes.OfType <TLDocumentAttributeFilename>().FirstOrDefault();
if (fileNameAttribute != null)
{
resultName = fileNameAttribute.FileName;
}
if (downloads)
{
var folder = await GetDownloadsAsync();
if (folder == null)
{
return;
}
StorageFile file;
if (StorageApplicationPermissions.FutureAccessList.ContainsItem(fileName))
{
file = await StorageApplicationPermissions.FutureAccessList.GetFileAsync(fileName);
}
else
{
file = await folder.CreateFileAsync(resultName, CreationCollisionOption.GenerateUniqueName);
StorageApplicationPermissions.FutureAccessList.AddOrReplace(fileName, file);
var result = await FileUtils.GetTempFileAsync(fileName);
await result.CopyAndReplaceAsync(file);
}
if (UIViewSettings.GetForCurrentView().UserInteractionMode == UserInteractionMode.Mouse)
{
var options = new FolderLauncherOptions();
options.ItemsToSelect.Add(file);
await Launcher.LaunchFolderAsync(folder, options);
}
}
else
{
var picker = new FileSavePicker();
if (!string.IsNullOrEmpty(extension))
{
picker.FileTypeChoices.Add($"{extension.TrimStart('.').ToUpper()} File", new[] { extension });
}
else
{
picker.FileTypeChoices.Add("Unknown", new[] { ".dat" });
}
picker.SuggestedStartLocation = PickerLocationId.Downloads;
picker.SuggestedFileName = resultName;
var file = await picker.PickSaveFileAsync();
if (file != null)
{
var result = await FileUtils.GetTempFileAsync(fileName);
await result.CopyAndReplaceAsync(file);
}
}
}
}
private async void openFilePath_Click(object sender, RoutedEventArgs e)
{
var t = new FolderLauncherOptions();
await Launcher.LaunchFolderAsync(folder, t);
}
public static async void OpenFolderInExplorer(StorageFolder folder, FolderLauncherOptions options)
{
await Launcher.LaunchFolderAsync(folder, options);
}
private async void LaunchFolder_Click(object sender, RoutedEventArgs e)
{
var options = new FolderLauncherOptions();
options.DesiredRemainingView = ViewSizePreference.UseHalf;
await Launcher.LaunchFolderAsync(KnownFolders.PicturesLibrary, options);
}
private async Task <bool> ExportToMusicFormat(StorageFile fileTarget, SpeechSynthesisStream synthStream)
{
bool success = false;
Debug.WriteLine(fileTarget.FileType + " selected");
// Set encoding profiles
_profile = null;
AudioEncodingQuality audioEncodingProfile = AudioEncodingQuality.High;
if (fileTarget.FileType == ".wma")
{
_profile = MediaEncodingProfile.CreateWma(audioEncodingProfile);
}
else if (fileTarget.FileType == ".mp3")
{
_profile = MediaEncodingProfile.CreateMp3(audioEncodingProfile);
}
else if (fileTarget.FileType == ".m4a")
{
_profile = MediaEncodingProfile.CreateM4a(audioEncodingProfile);
}
else
{
Debug.WriteLine("Can't select a media encoding profile");
return(success);
}
// Write temporary Wav to Temp-storage
ApplicationData appData = ApplicationData.Current;
StorageFile source = await appData.TemporaryFolder.CreateFileAsync("temporary.wav", CreationCollisionOption.ReplaceExisting);
try
{
using (var reader = new DataReader(synthStream))
{
await reader.LoadAsync((uint)synthStream.Size);
IBuffer buffer = reader.ReadBuffer((uint)synthStream.Size);
await FileIO.WriteBufferAsync(source, buffer);
}
}
catch (Exception ex)
{
Debug.WriteLine("Couldn't prepare wav for transcoding");
Debug.WriteLine(ex);
}
// Prepare transcoding files
var preparedTranscoderResult = await _transcoder.PrepareFileTranscodeAsync(source, fileTarget, _profile);
if (preparedTranscoderResult.CanTranscode)
{
// Set task for transcoding
await preparedTranscoderResult.TranscodeAsync().AsTask(_cts.Token);
// Set Music-properties
MusicProperties fileProperties = await fileTarget.Properties.GetMusicPropertiesAsync();
fileProperties.Title = fileTarget.DisplayName;
fileProperties.Artist = "Talkinator";
await fileProperties.SavePropertiesAsync();
// Prepare notification
// Add the file to app MRU and possibly system MRU
//RecentStorageItemVisibility visibility = SystemMRUCheckBox.IsChecked.Value ? RecentStorageItemVisibility.AppAndSystem : RecentStorageItemVisibility.AppOnly;
//rootPage.mruToken = StorageApplicationPermissions.MostRecentlyUsedList.Add(file, file.Name, visibility);
//RecentStorageItemVisibility visibility = RecentStorageItemVisibility.AppOnly;
//StorageApplicationPermissions.FutureAccessList.Add(fileTarget, fileTarget.DisplayName);
StorageFolder parentFolder = await fileTarget.GetParentAsync();
FolderLauncherOptions launcherOptions = new FolderLauncherOptions();
launcherOptions.ItemsToSelect.Add(fileTarget);
await Launcher.LaunchFolderAsync(parentFolder, launcherOptions);
// Report completed
success = true;
Debug.WriteLine(fileTarget.FileType + " export completed");
}
else
{
Debug.WriteLine(preparedTranscoderResult.FailureReason);
}
return(success);
}
