public static async Task <FilesystemResult <IStorageItem> > ToStorageItemResult(this IStorageItemWithPath item, IShellPage associatedInstance = null) { var returnedItem = new FilesystemResult <IStorageItem>(null, FileSystemStatusCode.Generic); if (!string.IsNullOrEmpty(item.Path)) { returnedItem = (item.ItemType == FilesystemItemType.File) ? ToType <IStorageItem, StorageFile>(associatedInstance != null ? await associatedInstance.FilesystemViewModel.GetFileFromPathAsync(item.Path) : await FilesystemTasks.Wrap(() => StorageFileExtensions.DangerousGetFileFromPathAsync(item.Path))) : ToType <IStorageItem, StorageFolder>(associatedInstance != null ? await associatedInstance.FilesystemViewModel.GetFolderFromPathAsync(item.Path) : await FilesystemTasks.Wrap(() => StorageFileExtensions.DangerousGetFolderFromPathAsync(item.Path))); } if (returnedItem.Result == null && item.Item != null) { returnedItem = new FilesystemResult <IStorageItem>(item.Item, FileSystemStatusCode.Success); } return(returnedItem); }
public FilesystemOperations(IShellPage associatedInstance) { this.associatedInstance = associatedInstance; recycleBinHelpers = new RecycleBinHelpers(this.associatedInstance); }
private async Task <string> GetHashForFileAsync(ListedItem fileItem, string nameOfAlg, CancellationToken token, ProgressBar progress, IShellPage associatedInstance) { HashAlgorithmProvider algorithmProvider = HashAlgorithmProvider.OpenAlgorithm(nameOfAlg); StorageFile file = await StorageItemHelpers.ToStorageItem <StorageFile>((fileItem as ShortcutItem)?.TargetPath ?? fileItem.ItemPath, associatedInstance); if (file == null) { return(""); } Stream stream = await FilesystemTasks.Wrap(() => file.OpenStreamForReadAsync()); if (stream == null) { return(""); } var inputStream = stream.AsInputStream(); var str = inputStream.AsStreamForRead(); var cap = (long)(0.5 * str.Length) / 100; uint capacity; if (cap >= uint.MaxValue) { capacity = uint.MaxValue; } else { capacity = Convert.ToUInt32(cap); } Windows.Storage.Streams.Buffer buffer = new Windows.Storage.Streams.Buffer(capacity); var hash = algorithmProvider.CreateHash(); while (!token.IsCancellationRequested) { await inputStream.ReadAsync(buffer, capacity, InputStreamOptions.None); if (buffer.Length > 0) { hash.Append(buffer); } else { break; } if (progress != null) { progress.Value = (double)str.Position / str.Length * 100; } } inputStream.Dispose(); stream.Dispose(); if (token.IsCancellationRequested) { return(""); } return(CryptographicBuffer.EncodeToHexString(hash.GetValueAndReset()).ToLower()); }
/// <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); }
private static async Task <FilesystemResult> OpenFile(string path, IShellPage associatedInstance, IEnumerable <string> selectItems, ShellLinkItem shortcutInfo, bool openViaApplicationPicker = false, string args = default) { var opened = (FilesystemResult)false; bool isHiddenItem = NativeFileOperationsHelper.HasFileAttribute(path, System.IO.FileAttributes.Hidden); bool isShortcutItem = path.EndsWith(".lnk", StringComparison.Ordinal) || path.EndsWith(".url", StringComparison.Ordinal) || !string.IsNullOrEmpty(shortcutInfo.TargetPath); if (isShortcutItem) { if (string.IsNullOrEmpty(shortcutInfo.TargetPath)) { await Win32Helpers.InvokeWin32ComponentAsync(path, associatedInstance, args); } else { if (!path.EndsWith(".url", StringComparison.Ordinal)) { StorageFileWithPath childFile = await associatedInstance.FilesystemViewModel.GetFileWithPathFromPathAsync(shortcutInfo.TargetPath); if (childFile != null) { // Add location to Recent Items List if (childFile.Item is SystemStorageFile) { await App.RecentItemsManager.AddToRecentItems(childFile.Path); } } } await Win32Helpers.InvokeWin32ComponentAsync(shortcutInfo.TargetPath, associatedInstance, $"{args} {shortcutInfo.Arguments}", shortcutInfo.RunAsAdmin, shortcutInfo.WorkingDirectory); } opened = (FilesystemResult)true; } else if (isHiddenItem) { await Win32Helpers.InvokeWin32ComponentAsync(path, associatedInstance, args); } else { opened = await associatedInstance.FilesystemViewModel.GetFileWithPathFromPathAsync(path) .OnSuccess(async childFile => { // Add location to Recent Items List if (childFile.Item is SystemStorageFile) { await App.RecentItemsManager.AddToRecentItems(childFile.Path); } if (openViaApplicationPicker) { LauncherOptions options = new LauncherOptions { DisplayApplicationPicker = true }; if (!await Launcher.LaunchFileAsync(childFile.Item, options)) { var connection = await AppServiceConnectionHelper.Instance; if (connection != null) { await connection.SendMessageAsync(new ValueSet() { { "Arguments", "InvokeVerb" }, { "FilePath", path }, { "Verb", "openas" } }); } } } else { //try using launcher first bool launchSuccess = false; BaseStorageFileQueryResult fileQueryResult = null; //Get folder to create a file query (to pass to apps like Photos, Movies & TV..., needed to scroll through the folder like what Windows Explorer does) BaseStorageFolder currentFolder = await associatedInstance.FilesystemViewModel.GetFolderFromPathAsync(PathNormalization.GetParentDir(path)); if (currentFolder != null) { QueryOptions queryOptions = new QueryOptions(CommonFileQuery.DefaultQuery, null); //We can have many sort entries SortEntry sortEntry = new SortEntry() { AscendingOrder = associatedInstance.InstanceViewModel.FolderSettings.DirectorySortDirection == SortDirection.Ascending }; //Basically we tell to the launched app to follow how we sorted the files in the directory. var sortOption = associatedInstance.InstanceViewModel.FolderSettings.DirectorySortOption; switch (sortOption) { case SortOption.Name: sortEntry.PropertyName = "System.ItemNameDisplay"; queryOptions.SortOrder.Clear(); queryOptions.SortOrder.Add(sortEntry); break; case SortOption.DateModified: sortEntry.PropertyName = "System.DateModified"; queryOptions.SortOrder.Clear(); queryOptions.SortOrder.Add(sortEntry); break; case SortOption.DateCreated: sortEntry.PropertyName = "System.DateCreated"; queryOptions.SortOrder.Clear(); queryOptions.SortOrder.Add(sortEntry); break; //Unfortunately this is unsupported | Remarks: https://docs.microsoft.com/en-us/uwp/api/windows.storage.search.queryoptions.sortorder?view=winrt-19041 //case Enums.SortOption.Size: //sortEntry.PropertyName = "System.TotalFileSize"; //queryOptions.SortOrder.Clear(); //queryOptions.SortOrder.Add(sortEntry); //break; //Unfortunately this is unsupported | Remarks: https://docs.microsoft.com/en-us/uwp/api/windows.storage.search.queryoptions.sortorder?view=winrt-19041 //case Enums.SortOption.FileType: //sortEntry.PropertyName = "System.FileExtension"; //queryOptions.SortOrder.Clear(); //queryOptions.SortOrder.Add(sortEntry); //break; //Handle unsupported default: //keep the default one in SortOrder IList break; } var options = new LauncherOptions(); if (currentFolder.AreQueryOptionsSupported(queryOptions)) { fileQueryResult = currentFolder.CreateFileQueryWithOptions(queryOptions); options.NeighboringFilesQuery = fileQueryResult.ToStorageFileQueryResult(); } // Now launch file with options. var storageItem = (StorageFile)await FilesystemTasks.Wrap(() => childFile.Item.ToStorageFileAsync().AsTask()); if (storageItem != null) { launchSuccess = await Launcher.LaunchFileAsync(storageItem, options); } } if (!launchSuccess) { await Win32Helpers.InvokeWin32ComponentAsync(path, associatedInstance, args); } } }); } return(opened); }
public static async Task <TRequested> ToStorageItem <TRequested>(string path, IShellPage associatedInstance = null) where TRequested : IStorageItem { FilesystemResult <BaseStorageFile> file = null; FilesystemResult <BaseStorageFolder> folder = null; if (path.EndsWith(".lnk", StringComparison.OrdinalIgnoreCase) || path.EndsWith(".url", StringComparison.OrdinalIgnoreCase)) { // TODO: In the future, when IStorageItemWithPath will inherit from IStorageItem, // we could implement this code here for getting .lnk files // for now, we can't return(default);
public void ChangeAppInstance(IShellPage associatedInstance) { this.associatedInstance = associatedInstance; }
public LibraryProperties(SelectedItemsPropertiesViewModel viewModel, CancellationTokenSource tokenSource, CoreDispatcher coreDispatcher, LibraryItem item, IShellPage instance) { ViewModel = viewModel; TokenSource = tokenSource; Dispatcher = coreDispatcher; Library = item; AppInstance = instance; GetBaseProperties(); ViewModel.PropertyChanged += ViewModel_PropertyChanged; }
public RecycleBinHelpers(IShellPage associatedInstance) { this.associatedInstance = associatedInstance; }
public static void PostBanner_Delete(ReturnResult status, FileOperationType operation, Stopwatch sw, IShellPage associatedInstance) { if (status == ReturnResult.Failed || status == ReturnResult.UnknownException || status == ReturnResult.IntegrityCheckFailed || status == ReturnResult.AccessUnauthorized) { if (status == ReturnResult.AccessUnauthorized) { associatedInstance.StatusCenterActions.PostBanner( "AccessDeniedDeleteDialog/Title".GetLocalized(), "AccessDeniedDeleteDialog/Text".GetLocalized(), 0, status, operation); } else if (status == ReturnResult.IntegrityCheckFailed) { associatedInstance.StatusCenterActions.PostBanner( "FileNotFoundDialog/Title".GetLocalized(), "FileNotFoundDialog/Text".GetLocalized(), 0, status, operation); } else if (status == ReturnResult.Failed || status == ReturnResult.UnknownException) { associatedInstance.StatusCenterActions.PostBanner( "StatusDeletionFailed".GetLocalized(), "StatusUnknownError".GetLocalized(), 0, status, operation); } else if (sw.Elapsed.TotalSeconds >= 10) { if (operation == FileOperationType.Delete) { associatedInstance.StatusCenterActions.PostBanner( "StatusDeletionComplete".GetLocalized(), "StatusOperationCompleted".GetLocalized(), 0, ReturnResult.Success, operation); } else if (operation == FileOperationType.Recycle) { associatedInstance.StatusCenterActions.PostBanner( "StatusRecycleComplete".GetLocalized(), "StatusOperationCompleted".GetLocalized(), 0, ReturnResult.Success, operation); } } } }
public FileSystemProperties(SelectedItemsPropertiesViewModel viewModel, CancellationTokenSource tokenSource, CoreDispatcher coreDispatcher, ListedItem item, IShellPage instance) { ViewModel = viewModel; TokenSource = tokenSource; Dispatcher = coreDispatcher; Item = item; AppInstance = instance; GetBaseProperties(); ViewModel.EditOwnerCommand = new RelayCommand(() => EditOwner(), () => ViewModel.FilePermissions != null); ViewModel.AddRulesForUserCommand = new RelayCommand(() => AddRulesForUser(), () => ViewModel.FilePermissions != null && ViewModel.FilePermissions.CanReadFilePermissions); ViewModel.RemoveRulesForUserCommand = new RelayCommand(() => RemoveRulesForUser(), () => ViewModel.FilePermissions != null && ViewModel.FilePermissions.CanReadFilePermissions && ViewModel.SelectedRuleForUser != null); }
/// <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> 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) // TODO: This function reliability has not been extensively tested { string previousDir = associatedInstance.FilesystemViewModel.WorkingDirectory; bool isHiddenItem = NativeFileOperationsHelper.HasFileAttribute(path, System.IO.FileAttributes.Hidden); bool isShortcutItem = path.EndsWith(".lnk") || path.EndsWith(".url"); // Determine FilesystemResult opened = (FilesystemResult)false; // Shortcut item variables string shortcutTargetPath = null; string shortcutArguments = null; string shortcutWorkingDirectory = null; bool shortcutRunAsAdmin = false; bool shortcutIsFolder = false; if (itemType == null || isShortcutItem || isHiddenItem) { if (isShortcutItem) { if (associatedInstance.ServiceConnection == null) { return(false); } var(status, response) = await associatedInstance.ServiceConnection.SendMessageForResponseAsync(new ValueSet() { { "Arguments", "FileOperation" }, { "fileop", "ParseLink" }, { "filepath", path } }); if (status == AppServiceResponseStatus.Success) { shortcutTargetPath = response.Get("TargetPath", string.Empty); shortcutArguments = response.Get("Arguments", string.Empty); shortcutWorkingDirectory = response.Get("WorkingDirectory", string.Empty); shortcutRunAsAdmin = response.Get("RunAsAdmin", false); shortcutIsFolder = response.Get("IsFolder", false); itemType = shortcutIsFolder ? FilesystemItemType.Directory : FilesystemItemType.File; } else { return(false); } } else if (isHiddenItem) { itemType = NativeFileOperationsHelper.HasFileAttribute(path, System.IO.FileAttributes.Directory) ? FilesystemItemType.Directory : FilesystemItemType.File; } else { itemType = await StorageItemHelpers.GetTypeFromPath(path); } } var mostRecentlyUsed = Windows.Storage.AccessCache.StorageApplicationPermissions.MostRecentlyUsedList; if (itemType == FilesystemItemType.Library) // OpenLibrary { if (isHiddenItem) { associatedInstance.NavigationToolbar.PathControlDisplayText = path; associatedInstance.NavigateWithArguments(associatedInstance.InstanceViewModel.FolderSettings.GetLayoutType(path), new NavigationArguments() { NavPathParam = path, AssociatedTabInstance = associatedInstance }); return(true); } else if (App.LibraryManager.TryGetLibrary(path, out LibraryLocationItem library)) { opened = (FilesystemResult)await library.CheckDefaultSaveFolderAccess(); if (opened) { associatedInstance.NavigationToolbar.PathControlDisplayText = library.Text; associatedInstance.NavigateWithArguments(associatedInstance.InstanceViewModel.FolderSettings.GetLayoutType(path), new NavigationArguments() { NavPathParam = path, AssociatedTabInstance = associatedInstance, SelectItems = selectItems, }); } } } else if (itemType == FilesystemItemType.Directory) // OpenDirectory { if (isShortcutItem) { if (string.IsNullOrEmpty(shortcutTargetPath)) { await Win32Helpers.InvokeWin32ComponentAsync(path, associatedInstance); return(true); } else { associatedInstance.NavigationToolbar.PathControlDisplayText = shortcutTargetPath; associatedInstance.NavigateWithArguments(associatedInstance.InstanceViewModel.FolderSettings.GetLayoutType(shortcutTargetPath), new NavigationArguments() { NavPathParam = shortcutTargetPath, AssociatedTabInstance = associatedInstance, SelectItems = selectItems }); return(true); } } else if (isHiddenItem) { associatedInstance.NavigationToolbar.PathControlDisplayText = path; associatedInstance.NavigateWithArguments(associatedInstance.InstanceViewModel.FolderSettings.GetLayoutType(path), new NavigationArguments() { NavPathParam = path, AssociatedTabInstance = associatedInstance }); return(true); } else { opened = await associatedInstance.FilesystemViewModel.GetFolderWithPathFromPathAsync(path) .OnSuccess(childFolder => { // Add location to MRU List mostRecentlyUsed.Add(childFolder.Folder, childFolder.Path); }); if (!opened) { opened = (FilesystemResult)FolderHelpers.CheckFolderAccessWithWin32(path); } if (!opened) { opened = (FilesystemResult)path.StartsWith("ftp:"); } if (opened) { associatedInstance.NavigationToolbar.PathControlDisplayText = path; associatedInstance.NavigateWithArguments(associatedInstance.InstanceViewModel.FolderSettings.GetLayoutType(path), new NavigationArguments() { NavPathParam = path, AssociatedTabInstance = associatedInstance, SelectItems = selectItems }); } } } else if (itemType == FilesystemItemType.File) // OpenFile { if (isShortcutItem) { if (string.IsNullOrEmpty(shortcutTargetPath)) { await Win32Helpers.InvokeWin32ComponentAsync(path, associatedInstance, args); } else { if (!path.EndsWith(".url")) { StorageFileWithPath childFile = await associatedInstance.FilesystemViewModel.GetFileWithPathFromPathAsync(shortcutTargetPath); if (childFile != null) { // Add location to MRU List mostRecentlyUsed.Add(childFile.File, childFile.Path); } } await Win32Helpers.InvokeWin32ComponentAsync(shortcutTargetPath, associatedInstance, $"{args} {shortcutArguments}", shortcutRunAsAdmin, shortcutWorkingDirectory); } opened = (FilesystemResult)true; } else if (isHiddenItem) { await Win32Helpers.InvokeWin32ComponentAsync(path, associatedInstance, args); } else { opened = await associatedInstance.FilesystemViewModel.GetFileWithPathFromPathAsync(path) .OnSuccess(async childFile => { // Add location to MRU List mostRecentlyUsed.Add(childFile.File, childFile.Path); if (openViaApplicationPicker) { LauncherOptions options = new LauncherOptions { DisplayApplicationPicker = true }; await Launcher.LaunchFileAsync(childFile.File, options); } else { //try using launcher first bool launchSuccess = false; StorageFileQueryResult fileQueryResult = null; //Get folder to create a file query (to pass to apps like Photos, Movies & TV..., needed to scroll through the folder like what Windows Explorer does) StorageFolder currentFolder = await associatedInstance.FilesystemViewModel.GetFolderFromPathAsync(System.IO.Path.GetDirectoryName(path)); if (currentFolder != null) { QueryOptions queryOptions = new QueryOptions(CommonFileQuery.DefaultQuery, null); //We can have many sort entries SortEntry sortEntry = new SortEntry() { AscendingOrder = associatedInstance.InstanceViewModel.FolderSettings.DirectorySortDirection == Microsoft.Toolkit.Uwp.UI.SortDirection.Ascending }; //Basically we tell to the launched app to follow how we sorted the files in the directory. var sortOption = associatedInstance.InstanceViewModel.FolderSettings.DirectorySortOption; switch (sortOption) { case Enums.SortOption.Name: sortEntry.PropertyName = "System.ItemNameDisplay"; queryOptions.SortOrder.Clear(); queryOptions.SortOrder.Add(sortEntry); break; case Enums.SortOption.DateModified: sortEntry.PropertyName = "System.DateModified"; queryOptions.SortOrder.Clear(); queryOptions.SortOrder.Add(sortEntry); break; case Enums.SortOption.DateCreated: sortEntry.PropertyName = "System.DateCreated"; queryOptions.SortOrder.Clear(); queryOptions.SortOrder.Add(sortEntry); break; //Unfortunately this is unsupported | Remarks: https://docs.microsoft.com/en-us/uwp/api/windows.storage.search.queryoptions.sortorder?view=winrt-19041 //case Enums.SortOption.Size: //sortEntry.PropertyName = "System.TotalFileSize"; //queryOptions.SortOrder.Clear(); //queryOptions.SortOrder.Add(sortEntry); //break; //Unfortunately this is unsupported | Remarks: https://docs.microsoft.com/en-us/uwp/api/windows.storage.search.queryoptions.sortorder?view=winrt-19041 //case Enums.SortOption.FileType: //sortEntry.PropertyName = "System.FileExtension"; //queryOptions.SortOrder.Clear(); //queryOptions.SortOrder.Add(sortEntry); //break; //Handle unsupported default: //keep the default one in SortOrder IList break; } fileQueryResult = currentFolder.CreateFileQueryWithOptions(queryOptions); var options = new LauncherOptions { NeighboringFilesQuery = fileQueryResult }; // Now launch file with options. launchSuccess = await Launcher.LaunchFileAsync(childFile.File, options); } if (!launchSuccess) { await Win32Helpers.InvokeWin32ComponentAsync(path, associatedInstance, args); } } }); } } if (opened.ErrorCode == FileSystemStatusCode.NotFound && !openSilent) { await DialogDisplayHelper.ShowDialogAsync("FileNotFoundDialog/Title".GetLocalized(), "FileNotFoundDialog/Text".GetLocalized()); associatedInstance.NavigationToolbar.CanRefresh = false; await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { var ContentOwnedViewModelInstance = associatedInstance.FilesystemViewModel; ContentOwnedViewModelInstance?.RefreshItems(previousDir); }); } return(opened); }
public static async Task <bool> Exists(string path, IShellPage associatedInstance = null) { IStorageItem item = await ToStorageItem <IStorageItem>(path, associatedInstance); return(item != null); }
public static async Task <FilesystemItemType> GetTypeFromPath(string path, IShellPage associatedInstance = null) { IStorageItem item = await ToStorageItem <IStorageItem>(path, associatedInstance); return(item == null ? FilesystemItemType.File : (item.IsOfType(StorageItemTypes.Folder) ? FilesystemItemType.Directory : FilesystemItemType.File)); }
private async Task <string> GetHashForFileAsync(ListedItem fileItem, string nameOfAlg, CancellationToken token, IProgress <float> progress, IShellPage associatedInstance) { HashAlgorithmProvider algorithmProvider = HashAlgorithmProvider.OpenAlgorithm(nameOfAlg); BaseStorageFile file = await StorageItemHelpers.ToStorageItem <BaseStorageFile>((fileItem as ShortcutItem)?.TargetPath ?? fileItem.ItemPath, associatedInstance); if (file == null) { return(""); } Stream stream = await FilesystemTasks.Wrap(() => file.OpenStreamForReadAsync()); if (stream == null) { return(""); } uint capacity; var inputStream = stream.AsInputStream(); bool isProgressSupported = false; try { var cap = (long)(0.5 * stream.Length) / 100; if (cap >= uint.MaxValue) { capacity = uint.MaxValue; } else { capacity = Convert.ToUInt32(cap); } isProgressSupported = true; } catch (NotSupportedException) { capacity = 64 * 1024; } Windows.Storage.Streams.Buffer buffer = new Windows.Storage.Streams.Buffer(capacity); var hash = algorithmProvider.CreateHash(); while (!token.IsCancellationRequested) { await inputStream.ReadAsync(buffer, capacity, InputStreamOptions.None); if (buffer.Length > 0) { hash.Append(buffer); } else { break; } if (stream.Length > 0) { progress?.Report(isProgressSupported ? (float)stream.Position / stream.Length * 100.0f : 20); } } inputStream.Dispose(); stream.Dispose(); if (token.IsCancellationRequested) { return(""); } return(CryptographicBuffer.EncodeToHexString(hash.GetValueAndReset()).ToLower()); }
public static async void CopyItem(IShellPage associatedInstance) { DataPackage dataPackage = new DataPackage() { RequestedOperation = DataPackageOperation.Copy }; List <IStorageItem> items = new List <IStorageItem>(); string copySourcePath = associatedInstance.FilesystemViewModel.WorkingDirectory; FilesystemResult result = (FilesystemResult)false; if (associatedInstance.SlimContentPage.IsItemSelected) { foreach (ListedItem listedItem in associatedInstance.SlimContentPage.SelectedItems) { if (listedItem.PrimaryItemAttribute == StorageItemTypes.File) { result = await associatedInstance.FilesystemViewModel.GetFileFromPathAsync(listedItem.ItemPath) .OnSuccess(t => items.Add(t)); if (!result) { break; } } else { result = await associatedInstance.FilesystemViewModel.GetFolderFromPathAsync(listedItem.ItemPath) .OnSuccess(t => items.Add(t)); if (!result) { break; } } } if (result.ErrorCode == FileSystemStatusCode.Unauthorized) { // Try again with fulltrust process if (associatedInstance.ServiceConnection != null) { string filePaths = string.Join('|', associatedInstance.SlimContentPage.SelectedItems.Select(x => x.ItemPath)); await associatedInstance.ServiceConnection.SendMessageAsync(new ValueSet() { { "Arguments", "FileOperation" }, { "fileop", "Clipboard" }, { "filepath", filePaths }, { "operation", (int)DataPackageOperation.Copy } }); } return; } } if (items?.Count > 0) { dataPackage.SetStorageItems(items); try { Clipboard.SetContent(dataPackage); Clipboard.Flush(); } catch { dataPackage = null; } } }
public static async Task <IStorageItem> ToStorageItem(this IStorageItemWithPath item, IShellPage associatedInstance = null) { return((await item.ToStorageItemResult(associatedInstance)).Result); }
public static async Task <bool> RenameFileItemAsync(ListedItem item, string oldName, string newName, IShellPage associatedInstance) { if (oldName == newName) { return(true); } ReturnResult renamed = ReturnResult.InProgress; if (item.PrimaryItemAttribute == StorageItemTypes.Folder) { renamed = await associatedInstance.FilesystemHelpers.RenameAsync(StorageItemHelpers.FromPathAndType(item.ItemPath, FilesystemItemType.Directory), newName, NameCollisionOption.FailIfExists, true); } else { if (item.IsShortcutItem || !App.AppSettings.ShowFileExtensions) { newName += item.FileExtension; } renamed = await associatedInstance.FilesystemHelpers.RenameAsync(StorageItemHelpers.FromPathAndType(item.ItemPath, FilesystemItemType.File), newName, NameCollisionOption.FailIfExists, true); } if (renamed == ReturnResult.Success) { associatedInstance.NavigationToolbar.CanGoForward = false; return(true); } return(false); }
public static void PostBanner_Delete(ReturnResult status, FileOperationType operation, Stopwatch sw, IShellPage associatedInstance) { if (status == ReturnResult.Failed || status == ReturnResult.UnknownException || status == ReturnResult.IntegrityCheckFailed || status == ReturnResult.AccessUnauthorized) { if (status == ReturnResult.AccessUnauthorized) { associatedInstance.BottomStatusStripControl.OngoingTasksControl.PostBanner( "AccessDeniedDeleteDialog/Title".GetLocalized(), "AccessDeniedDeleteDialog/Text".GetLocalized(), 0, status, operation); } else if (status == ReturnResult.IntegrityCheckFailed) { associatedInstance.BottomStatusStripControl.OngoingTasksControl.PostBanner( "FileNotFoundDialog/Title".GetLocalized(), "FileNotFoundDialog/Text".GetLocalized(), 0, status, operation); } else if (status == ReturnResult.Failed || status == ReturnResult.UnknownException) { associatedInstance.BottomStatusStripControl.OngoingTasksControl.PostBanner( "Deletion Failed", "An unknown error has occured.", 0, status, operation); } else if (sw.Elapsed.TotalSeconds >= 10) { if (operation == FileOperationType.Delete) { associatedInstance.BottomStatusStripControl.OngoingTasksControl.PostBanner( "Deletion Complete", "The operation has completed.", 0, ReturnResult.Success, operation); } else if (operation == FileOperationType.Recycle) { associatedInstance.BottomStatusStripControl.OngoingTasksControl.PostBanner( "Recycle Complete", "The operation has completed.", 0, ReturnResult.Success, operation); } } } }
public static async void CutItem(IShellPage associatedInstance) { DataPackage dataPackage = new DataPackage { RequestedOperation = DataPackageOperation.Move }; List <IStorageItem> items = new List <IStorageItem>(); FilesystemResult result = (FilesystemResult)false; if (associatedInstance.SlimContentPage.IsItemSelected) { // First, reset DataGrid Rows that may be in "cut" command mode associatedInstance.SlimContentPage.ItemManipulationModel.RefreshItemsOpacity(); foreach (ListedItem listedItem in associatedInstance.SlimContentPage.SelectedItems) { // Dim opacities accordingly listedItem.Opacity = Constants.UI.DimItemOpacity; if (listedItem.PrimaryItemAttribute == StorageItemTypes.File) { result = await associatedInstance.FilesystemViewModel.GetFileFromPathAsync(listedItem.ItemPath) .OnSuccess(t => items.Add(t)); if (!result) { break; } } else { result = await associatedInstance.FilesystemViewModel.GetFolderFromPathAsync(listedItem.ItemPath) .OnSuccess(t => items.Add(t)); if (!result) { break; } } } if (result.ErrorCode == FileSystemStatusCode.NotFound) { associatedInstance.SlimContentPage.ItemManipulationModel.RefreshItemsOpacity(); return; } else if (result.ErrorCode == FileSystemStatusCode.Unauthorized) { // Try again with fulltrust process if (associatedInstance.ServiceConnection != null) { string filePaths = string.Join('|', associatedInstance.SlimContentPage.SelectedItems.Select(x => x.ItemPath)); AppServiceResponseStatus status = await associatedInstance.ServiceConnection.SendMessageAsync(new ValueSet() { { "Arguments", "FileOperation" }, { "fileop", "Clipboard" }, { "filepath", filePaths }, { "operation", (int)DataPackageOperation.Move } }); if (status == AppServiceResponseStatus.Success) { return; } } associatedInstance.SlimContentPage.ItemManipulationModel.RefreshItemsOpacity(); return; } } if (!items.Any()) { return; } dataPackage.SetStorageItems(items); try { Clipboard.SetContent(dataPackage); Clipboard.Flush(); } catch { dataPackage = null; } }
public CombinedProperties(SelectedItemsPropertiesViewModel viewModel, CancellationTokenSource tokenSource, CoreDispatcher coreDispatcher, List <ListedItem> listedItems, IShellPage instance) { ViewModel = viewModel; TokenSource = tokenSource; Dispatcher = coreDispatcher; List = listedItems; AppInstance = instance; GetBaseProperties(); ViewModel.PropertyChanged += ViewModel_PropertyChanged; }
public static async void CreateFileFromDialogResultType(AddItemType itemType, ShellNewEntry itemInfo, IShellPage associatedInstance) { _ = await CreateFileFromDialogResultTypeForResult(itemType, itemInfo, associatedInstance); }
private static async Task <FilesystemResult> OpenDirectory(string path, IShellPage associatedInstance, IEnumerable <string> selectItems, ShellLinkItem shortcutInfo, bool forceOpenInNewTab) { IUserSettingsService userSettingsService = Ioc.Default.GetService <IUserSettingsService>(); var opened = (FilesystemResult)false; bool isHiddenItem = NativeFileOperationsHelper.HasFileAttribute(path, System.IO.FileAttributes.Hidden); bool isShortcutItem = path.EndsWith(".lnk", StringComparison.Ordinal) || path.EndsWith(".url", StringComparison.Ordinal); // Determine if (isShortcutItem) { if (string.IsNullOrEmpty(shortcutInfo.TargetPath)) { await Win32Helpers.InvokeWin32ComponentAsync(path, associatedInstance); opened = (FilesystemResult)true; } else { if (forceOpenInNewTab || userSettingsService.PreferencesSettingsService.OpenFoldersInNewTab) { await OpenPathInNewTab(shortcutInfo.TargetPath); } else { associatedInstance.ToolbarViewModel.PathControlDisplayText = shortcutInfo.TargetPath; associatedInstance.NavigateWithArguments(associatedInstance.InstanceViewModel.FolderSettings.GetLayoutType(shortcutInfo.TargetPath), new NavigationArguments() { NavPathParam = shortcutInfo.TargetPath, AssociatedTabInstance = associatedInstance, SelectItems = selectItems }); } opened = (FilesystemResult)true; } } else if (isHiddenItem) { if (forceOpenInNewTab || userSettingsService.PreferencesSettingsService.OpenFoldersInNewTab) { await OpenPathInNewTab(path); } else { associatedInstance.ToolbarViewModel.PathControlDisplayText = path; associatedInstance.NavigateWithArguments(associatedInstance.InstanceViewModel.FolderSettings.GetLayoutType(path), new NavigationArguments() { NavPathParam = path, AssociatedTabInstance = associatedInstance }); } opened = (FilesystemResult)true; } else { opened = await associatedInstance.FilesystemViewModel.GetFolderWithPathFromPathAsync(path) .OnSuccess(async(childFolder) => { // Add location to Recent Items List if (childFolder.Item is SystemStorageFolder) { await App.RecentItemsManager.AddToRecentItems(childFolder.Path); } }); if (!opened) { opened = (FilesystemResult)FolderHelpers.CheckFolderAccessWithWin32(path); } if (opened) { if (forceOpenInNewTab || userSettingsService.PreferencesSettingsService.OpenFoldersInNewTab) { await OpenPathInNewTab(path); } else { associatedInstance.ToolbarViewModel.PathControlDisplayText = path; associatedInstance.NavigateWithArguments(associatedInstance.InstanceViewModel.FolderSettings.GetLayoutType(path), new NavigationArguments() { NavPathParam = path, AssociatedTabInstance = associatedInstance, SelectItems = selectItems }); } } else { await Win32Helpers.InvokeWin32ComponentAsync(path, associatedInstance); } } return(opened); }
public static async Task <IStorageItem> CreateFileFromDialogResultTypeForResult(AddItemType itemType, ShellNewEntry itemInfo, IShellPage associatedInstance) { string currentPath = null; if (associatedInstance.SlimContentPage != null) { currentPath = associatedInstance.FilesystemViewModel.WorkingDirectory; } // Show rename dialog DynamicDialog dialog = DynamicDialogFactory.GetFor_RenameDialog(); await dialog.ShowAsync(); if (dialog.DynamicResult != DynamicDialogResult.Primary) { return(null); } // Create file based on dialog result string userInput = dialog.ViewModel.AdditionalData as string; var folderRes = await associatedInstance.FilesystemViewModel.GetFolderWithPathFromPathAsync(currentPath); FilesystemResult <(ReturnResult, IStorageItem)> created = null; if (folderRes) { switch (itemType) { case AddItemType.Folder: userInput = !string.IsNullOrWhiteSpace(userInput) ? userInput : "NewFolder".GetLocalized(); created = await FilesystemTasks.Wrap(async() => { return(await associatedInstance.FilesystemHelpers.CreateAsync( StorageItemHelpers.FromPathAndType(System.IO.Path.Combine(folderRes.Result.Path, userInput), FilesystemItemType.Directory), true)); }); break; case AddItemType.File: userInput = !string.IsNullOrWhiteSpace(userInput) ? userInput : itemInfo?.Name ?? "NewFile".GetLocalized(); created = await FilesystemTasks.Wrap(async() => { return(await associatedInstance.FilesystemHelpers.CreateAsync( StorageItemHelpers.FromPathAndType(System.IO.Path.Combine(folderRes.Result.Path, userInput + itemInfo?.Extension), FilesystemItemType.File), true)); }); break; } } if (created == FileSystemStatusCode.Unauthorized) { await DialogDisplayHelper.ShowDialogAsync("AccessDeniedCreateDialog/Title".GetLocalized(), "AccessDeniedCreateDialog/Text".GetLocalized()); } return(created.Result.Item2); }
private static async Task DeleteItem(StorageDeleteOption deleteOption, IShellPage AppInstance, IProgress <uint> progress) { var deleteFromRecycleBin = AppInstance.FilesystemViewModel.WorkingDirectory.StartsWith(App.AppSettings.RecycleBinPath); List <ListedItem> selectedItems = new List <ListedItem>(); foreach (ListedItem selectedItem in AppInstance.ContentPage.SelectedItems) { selectedItems.Add(selectedItem); } if (App.AppSettings.ShowConfirmDeleteDialog == true) //check if the setting to show a confirmation dialog is on { var dialog = new ConfirmDeleteDialog(deleteFromRecycleBin, deleteOption); await dialog.ShowAsync(); if (dialog.Result != MyResult.Delete) //delete selected item(s) if the result is yes { return; //return if the result isn't delete } deleteOption = dialog.PermanentlyDelete; } int itemsDeleted = 0; foreach (ListedItem storItem in selectedItems) { uint progressValue = (uint)(itemsDeleted * 100.0 / selectedItems.Count); if (selectedItems.Count > 3) { progress.Report((uint)progressValue); } IStorageItem item; try { if (storItem.PrimaryItemAttribute == StorageItemTypes.File) { item = await ItemViewModel.GetFileFromPathAsync(storItem.ItemPath, AppInstance); } else { item = await ItemViewModel.GetFolderFromPathAsync(storItem.ItemPath, AppInstance); } await item.DeleteAsync(deleteOption); } catch (UnauthorizedAccessException) { if (deleteOption == StorageDeleteOption.Default) { // Try again with fulltrust process if (App.Connection != null) { var result = await App.Connection.SendMessageAsync(new ValueSet() { { "Arguments", "FileOperation" }, { "fileop", "MoveToBin" }, { "filepath", storItem.ItemPath } }); } } else { // Try again with DeleteFileFromApp if (!NativeDirectoryChangesHelper.DeleteFileFromApp(storItem.ItemPath)) { Debug.WriteLine(System.Runtime.InteropServices.Marshal.GetLastWin32Error()); } } } catch (FileLoadException) { // try again if (storItem.PrimaryItemAttribute == StorageItemTypes.File) { item = await ItemViewModel.GetFileFromPathAsync(storItem.ItemPath, AppInstance); } else { item = await ItemViewModel.GetFolderFromPathAsync(storItem.ItemPath, AppInstance); } await item.DeleteAsync(deleteOption); } if (deleteFromRecycleBin) { // Recycle bin also stores a file starting with $I for each item var iFilePath = Path.Combine(Path.GetDirectoryName(storItem.ItemPath), Path.GetFileName(storItem.ItemPath).Replace("$R", "$I")); await(await ItemViewModel.GetFileFromPathAsync(iFilePath)).DeleteAsync(StorageDeleteOption.PermanentDelete); } await AppInstance.FilesystemViewModel.RemoveFileOrFolder(storItem); itemsDeleted++; } }
public BaseLayoutCommandImplementationModel(IShellPage associatedInstance, ItemManipulationModel itemManipulationModel) { this.associatedInstance = associatedInstance; this.itemManipulationModel = itemManipulationModel; }
public FileProperties(SelectedItemsPropertiesViewModel viewModel, CancellationTokenSource tokenSource, CoreDispatcher coreDispatcher, ProgressBar progressBar, ListedItem item, IShellPage instance) { ViewModel = viewModel; TokenSource = tokenSource; ProgressBar = progressBar; Dispatcher = coreDispatcher; Item = item; AppInstance = instance; GetBaseProperties(); ViewModel.PropertyChanged += ViewModel_PropertyChanged; }
public FileProperties(SelectedItemsPropertiesViewModel viewModel, CancellationTokenSource tokenSource, CoreDispatcher coreDispatcher, IProgress <float> hashProgress, ListedItem item, IShellPage instance) { ViewModel = viewModel; TokenSource = tokenSource; Dispatcher = coreDispatcher; Item = item; AppInstance = instance; this.hashProgress = hashProgress; GetBaseProperties(); ViewModel.PropertyChanged += ViewModel_PropertyChanged; }
public DriveProperties(SelectedItemsPropertiesViewModel viewModel, DriveItem driveItem, IShellPage instance) { ViewModel = viewModel; Drive = driveItem; AppInstance = instance; GetBaseProperties(); }
public FolderProperties(SelectedItemsPropertiesViewModel viewModel, CancellationTokenSource tokenSource, CoreDispatcher coreDispatcher, ListedItem item, IShellPage instance) : base(viewModel, tokenSource, coreDispatcher, item, instance) { ViewModel.PropertyChanged += ViewModel_PropertyChanged; }