public static async Task <IStorageItem> CreateFileFromDialogResultTypeForResult(AddItemDialogItemType itemType, ShellNewEntry itemInfo, IShellPage associatedInstance) { string currentPath = null; if (associatedInstance.SlimContentPage != null) { currentPath = associatedInstance.FilesystemViewModel.WorkingDirectory; if (App.LibraryManager.TryGetLibrary(currentPath, out var library)) { if (!library.IsEmpty && library.Folders.Count == 1) // TODO: handle libraries with multiple folders { currentPath = library.Folders.First(); } } } // Skip rename dialog when ShellNewEntry has a Command (e.g. ".accdb", ".gdoc") string userInput = null; if (itemType != AddItemDialogItemType.File || itemInfo?.Command == null) { DynamicDialog dialog = DynamicDialogFactory.GetFor_RenameDialog(); await dialog.ShowAsync(); // Show rename dialog if (dialog.DynamicResult != DynamicDialogResult.Primary) { return(null); } userInput = dialog.ViewModel.AdditionalData as string; } // Create file based on dialog result (ReturnResult Status, IStorageItem Item)created = (ReturnResult.Failed, null); switch (itemType) { case AddItemDialogItemType.Folder: userInput = !string.IsNullOrWhiteSpace(userInput) ? userInput : "NewFolder".GetLocalized(); created = await associatedInstance.FilesystemHelpers.CreateAsync( StorageHelpers.FromPathAndType(PathNormalization.Combine(currentPath, userInput), FilesystemItemType.Directory), true); break; case AddItemDialogItemType.File: userInput = !string.IsNullOrWhiteSpace(userInput) ? userInput : itemInfo?.Name ?? "NewFile".GetLocalized(); created = await associatedInstance.FilesystemHelpers.CreateAsync( StorageHelpers.FromPathAndType(PathNormalization.Combine(currentPath, userInput + itemInfo?.Extension), FilesystemItemType.File), true); break; } if (created.Status == ReturnResult.AccessUnauthorized) { await DialogDisplayHelper.ShowDialogAsync("AccessDenied".GetLocalized(), "AccessDeniedCreateDialog/Text".GetLocalized()); } return(created.Item); }
public static async Task <byte[]> LoadIconFromPathAsync(string filePath, uint thumbnailSize, ThumbnailMode thumbnailMode) { if (!filePath.EndsWith(".lnk", StringComparison.Ordinal) && !filePath.EndsWith(".url", StringComparison.Ordinal)) { var item = await StorageHelpers.ToStorageItem <IStorageItem>(filePath); if (item != null) { var iconData = await LoadIconFromStorageItemAsync(item, thumbnailSize, thumbnailMode); if (iconData != null) { return(iconData); } } } return(await LoadIconWithoutOverlayAsync(filePath, thumbnailSize)); }
public static async void SetAsBackground(WallpaperType type, string filePath) { if (UserProfilePersonalizationSettings.IsSupported()) { // Get the path of the selected file BaseStorageFile sourceFile = await StorageHelpers.ToStorageItem <BaseStorageFile>(filePath); if (sourceFile == null) { return; } // Get the app's local folder to use as the destination folder. BaseStorageFolder localFolder = ApplicationData.Current.LocalFolder; // the file to the destination folder. // Generate unique name if the file already exists. // If the file you are trying to set as the wallpaper has the same name as the current wallpaper, // the system will ignore the request and no-op the operation BaseStorageFile file = await FilesystemTasks.Wrap(() => sourceFile.CopyAsync(localFolder, sourceFile.Name, NameCollisionOption.GenerateUniqueName).AsTask()); if (file == null) { return; } UserProfilePersonalizationSettings profileSettings = UserProfilePersonalizationSettings.Current; if (type == WallpaperType.Desktop) { // Set the desktop background await profileSettings.TrySetWallpaperImageAsync(await file.ToStorageFileAsync()); } else if (type == WallpaperType.LockScreen) { // Set the lockscreen background await profileSettings.TrySetLockScreenImageAsync(await file.ToStorageFileAsync()); } } }
public static async Task <bool> RenameFileItemAsync(ListedItem item, string newName, IShellPage associatedInstance) { if (item is AlternateStreamItem ads) // For alternate streams ItemName is not a substring ItemNameRaw { newName = item.ItemNameRaw.Replace( item.ItemName.Substring(item.ItemName.LastIndexOf(":") + 1), newName.Substring(newName.LastIndexOf(":") + 1), StringComparison.Ordinal); newName = $"{ads.MainStreamName}:{newName}"; } else { newName = item.ItemNameRaw.Replace(item.ItemName, newName, StringComparison.Ordinal); } if (item.ItemNameRaw == newName || string.IsNullOrEmpty(newName)) { return(true); } ReturnResult renamed = ReturnResult.InProgress; if (item.PrimaryItemAttribute == StorageItemTypes.Folder) { renamed = await associatedInstance.FilesystemHelpers.RenameAsync(StorageHelpers.FromPathAndType(item.ItemPath, FilesystemItemType.Directory), newName, NameCollisionOption.FailIfExists, true); } else { renamed = await associatedInstance.FilesystemHelpers.RenameAsync(StorageHelpers.FromPathAndType(item.ItemPath, FilesystemItemType.File), newName, NameCollisionOption.FailIfExists, true); } if (renamed == ReturnResult.Success) { associatedInstance.ToolbarViewModel.CanGoForward = false; return(true); } return(false); }
/// <summary> /// Rotates the image at the specified file path. /// </summary> /// <param name="filePath">The file path to the image.</param> /// <param name="rotation">The rotation direction.</param> /// <remarks> /// https://docs.microsoft.com/en-us/uwp/api/windows.graphics.imaging.bitmapdecoder?view=winrt-22000 /// https://docs.microsoft.com/en-us/uwp/api/windows.graphics.imaging.bitmapencoder?view=winrt-22000 /// </remarks> public static async Task Rotate(string filePath, BitmapRotation rotation) { if (string.IsNullOrEmpty(filePath)) { return; } var file = await StorageHelpers.ToStorageItem <IStorageFile>(filePath); if (file == null) { return; } var fileStreamRes = await FilesystemTasks.Wrap(() => file.OpenAsync(FileAccessMode.ReadWrite).AsTask()); using IRandomAccessStream fileStream = fileStreamRes.Result; if (fileStream == null) { return; } BitmapDecoder decoder = await BitmapDecoder.CreateAsync(fileStream); using var memStream = new InMemoryRandomAccessStream(); BitmapEncoder encoder = await BitmapEncoder.CreateForTranscodingAsync(memStream, decoder); encoder.BitmapTransform.Rotation = rotation; await encoder.FlushAsync(); memStream.Seek(0); fileStream.Seek(0); fileStream.Size = 0; await RandomAccessStream.CopyAsync(memStream, fileStream); }
/// <summary> /// Navigates to a directory or opens file /// </summary> /// <param name="path">The path to navigate to or open</param> /// <param name="associatedInstance">The instance associated with view</param> /// <param name="itemType"></param> /// <param name="openSilent">Determines whether history of opened item is saved (... to Recent Items/Windows Timeline/opening in background)</param> /// <param name="openViaApplicationPicker">Determines whether open file using application picker</param> /// <param name="selectItems">List of filenames that are selected upon navigation</param> /// <param name="forceOpenInNewTab">Open folders in a new tab regardless of the "OpenFoldersInNewTab" option</param> public static async Task <bool> OpenPath(string path, IShellPage associatedInstance, FilesystemItemType?itemType = null, bool openSilent = false, bool openViaApplicationPicker = false, IEnumerable <string> selectItems = null, string args = default, bool forceOpenInNewTab = false) { string previousDir = associatedInstance.FilesystemViewModel.WorkingDirectory; bool isHiddenItem = NativeFileOperationsHelper.HasFileAttribute(path, System.IO.FileAttributes.Hidden); bool isDirectory = NativeFileOperationsHelper.HasFileAttribute(path, System.IO.FileAttributes.Directory); bool isReparsePoint = NativeFileOperationsHelper.HasFileAttribute(path, System.IO.FileAttributes.ReparsePoint); bool isShortcutItem = path.EndsWith(".lnk", StringComparison.Ordinal) || path.EndsWith(".url", StringComparison.Ordinal); FilesystemResult opened = (FilesystemResult)false; var shortcutInfo = new ShellLinkItem(); if (itemType == null || isShortcutItem || isHiddenItem || isReparsePoint) { if (isShortcutItem) { var connection = await AppServiceConnectionHelper.Instance; if (connection == null) { return(false); } var(status, response) = await connection.SendMessageForResponseAsync(new ValueSet() { { "Arguments", "FileOperation" }, { "fileop", "ParseLink" }, { "filepath", path } }); if (status == AppServiceResponseStatus.Success && response.ContainsKey("ShortcutInfo")) { var shInfo = JsonConvert.DeserializeObject <ShellLinkItem>((string)response["ShortcutInfo"]); if (shInfo != null) { shortcutInfo = shInfo; } itemType = shInfo != null && shInfo.IsFolder ? FilesystemItemType.Directory : FilesystemItemType.File; } else { return(false); } } else if (isReparsePoint) { if (!isDirectory) { if (NativeFindStorageItemHelper.GetWin32FindDataForPath(path, out var findData)) { if (findData.dwReserved0 == NativeFileOperationsHelper.IO_REPARSE_TAG_SYMLINK) { shortcutInfo.TargetPath = NativeFileOperationsHelper.ParseSymLink(path); } } } itemType ??= isDirectory ? FilesystemItemType.Directory : FilesystemItemType.File; } else if (isHiddenItem) { itemType = NativeFileOperationsHelper.HasFileAttribute(path, System.IO.FileAttributes.Directory) ? FilesystemItemType.Directory : FilesystemItemType.File; } else { itemType = await StorageHelpers.GetTypeFromPath(path); } } if (itemType == FilesystemItemType.Library) { opened = await OpenLibrary(path, associatedInstance, selectItems, forceOpenInNewTab); } else if (itemType == FilesystemItemType.Directory) { opened = await OpenDirectory(path, associatedInstance, selectItems, shortcutInfo, forceOpenInNewTab); } else if (itemType == FilesystemItemType.File) { opened = await OpenFile(path, associatedInstance, selectItems, shortcutInfo, openViaApplicationPicker, args); } if (opened.ErrorCode == FileSystemStatusCode.NotFound && !openSilent) { await DialogDisplayHelper.ShowDialogAsync("FileNotFoundDialog/Title".GetLocalized(), "FileNotFoundDialog/Text".GetLocalized()); associatedInstance.ToolbarViewModel.CanRefresh = false; associatedInstance.FilesystemViewModel?.RefreshItems(previousDir); } return(opened); }
public static async Task CreateFolderWithSelectionAsync(IShellPage associatedInstance) { try { var items = associatedInstance.SlimContentPage.SelectedItems.ToList().Select((item) => StorageHelpers.FromPathAndType( item.ItemPath, item.PrimaryItemAttribute == StorageItemTypes.File ? FilesystemItemType.File : FilesystemItemType.Directory)); var folder = await CreateFileFromDialogResultTypeForResult(AddItemDialogItemType.Folder, null, associatedInstance); if (folder == null) { return; } await associatedInstance.FilesystemHelpers.MoveItemsAsync(items, items.Select(x => PathNormalization.Combine(folder.Path, x.Name)), false, true); } catch (Exception ex) { App.Logger.Warn(ex); } }