public async Task <UrlDataPackage> GetRawDataAsync() { using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { return(await GetRawDataAsync(Exclusive.Controller)); } }
public async Task <bool> UnlockAsync(string Password) { using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { return(await Exclusive.Controller.RunAsync("powershell.exe", string.Empty, WindowState.Normal, true, true, true, "-Command", $"$BitlockerSecureString = ConvertTo-SecureString '{Password}' -AsPlainText -Force;", $"Unlock-BitLocker -MountPoint '{DriveFolder.Path}' -Password $BitlockerSecureString")); } }
public async Task <LinkDataPackage> GetLinkDataAsync() { using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { return(await Exclusive.Controller.GetLnkDataAsync(Path).ConfigureAwait(true)); } }
public virtual async Task CopyAsync(string DirectoryPath, ProgressChangedEventHandler ProgressHandler = null) { using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { await Exclusive.Controller.CopyAsync(Path, DirectoryPath, false, ProgressHandler); } }
public static async Task <string> ReplaceVariableAndGetActualPath(string PathWithVariable) { if (string.IsNullOrWhiteSpace(PathWithVariable)) { return(string.Empty); } else { using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { string TempString = PathWithVariable; foreach (string Var in Regex.Matches(PathWithVariable, @"(?<=(%))[\s\S]+(?=(%))").Select((Item) => Item.Value).Distinct()) { string ActualPath = await Exclusive.Controller.GetVariablePathAsync(Var).ConfigureAwait(false); if (string.IsNullOrWhiteSpace(ActualPath)) { throw new System.Exception("ActualPath which get from variable is empty"); } else { TempString = TempString.Replace($"%{Var}%", ActualPath); } } return(TempString); } } }
protected async override void OnNavigatedTo(NavigationEventArgs e) { ListViewControl.AddHandler(PointerPressedEvent, PointerPressedHandler, true); CoreWindow.GetForCurrentThread().KeyDown += RecycleBin_KeyDown; SelectionExtention = new ListViewBaseSelectionExtention(ListViewControl, DrawRectangle); await ActivateLoading(true, Globalization.GetString("Progress_Tip_Loading")); using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { IReadOnlyList <IRecycleStorageItem> Result = await Exclusive.Controller.GetRecycleBinItemsAsync(); FileCollection.AddRange(SortCollectionGenerator.GetSortedCollection(Result, SortTarget.Name, SortDirection.Ascending)); } if (FileCollection.Count == 0) { HasFile.Visibility = Visibility.Visible; ClearRecycleBin.IsEnabled = false; } else { HasFile.Visibility = Visibility.Collapsed; ClearRecycleBin.IsEnabled = true; } await ActivateLoading(false); }
public virtual async Task DeleteAsync(bool PermanentDelete, ProgressChangedEventHandler ProgressHandler = null) { using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { await Exclusive.Controller.DeleteAsync(Path, PermanentDelete, ProgressHandler); } }
public async Task RefreshAsync() { try { if (await CheckExistAsync(Path)) { if (LoadMorePropertiesWithFullTrustProcess()) { using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { await LoadMorePropertiesCoreAsync(Exclusive.Controller, true); } } else { await LoadMorePropertiesCoreAsync(true); } OnPropertyChanged(nameof(Size)); OnPropertyChanged(nameof(Name)); OnPropertyChanged(nameof(ModifiedTime)); OnPropertyChanged(nameof(Thumbnail)); OnPropertyChanged(nameof(DisplayType)); } else { LogTracer.Log($"File/Folder not found or access deny when executing FileSystemStorageItemBase.Update, path: {Path}"); } } catch (Exception ex) { LogTracer.Log(ex, $"An exception was threw when executing FileSystemStorageItemBase.Update, path: {Path}"); } }
protected async override void OnNavigatedTo(NavigationEventArgs e) { ListViewControl.AddHandler(PointerPressedEvent, PointerPressedHandler, true); CoreWindow.GetForCurrentThread().KeyDown += RecycleBin_KeyDown; SelectionExtention = new ListViewBaseSelectionExtention(ListViewControl, DrawRectangle); using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { List <IRecycleStorageItem> Result = await Exclusive.Controller.GetRecycleBinItemsAsync().ConfigureAwait(true); foreach (IRecycleStorageItem Item in SortCollectionGenerator.Current.GetSortedCollection(Result, SortTarget.Name, SortDirection.Ascending)) { FileCollection.Add(Item); } } if (FileCollection.Count == 0) { HasFile.Visibility = Visibility.Visible; ClearRecycleBin.IsEnabled = false; } else { HasFile.Visibility = Visibility.Collapsed; ClearRecycleBin.IsEnabled = true; } }
public async Task <bool> InvokeAsync() { using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { return(await Exclusive.Controller.InvokeContextMenuItemAsync(DataPackage).ConfigureAwait(false)); } }
public virtual async Task MoveAsync(string DirectoryPath, ProgressChangedEventHandler ProgressHandler = null, bool IsUndoOperation = false) { using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { await Exclusive.Controller.MoveAsync(Path, DirectoryPath, IsUndoOperation, ProgressHandler); } }
public static async Task DeleteAsync(IEnumerable <string> SourcePathList, bool PermanentDelete, ProgressChangedEventHandler ProgressHandler = null, bool IsUndoOperation = false) { using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { await Exclusive.Controller.DeleteAsync(SourcePathList, PermanentDelete, IsUndoOperation, ProgressHandler).ConfigureAwait(false); } }
private async void PickUWP_Click(object sender, RoutedEventArgs e) { UWPPickerTip.IsOpen = true; UWPLoadingTip.Visibility = Visibility.Visible; PackageListView.Visibility = Visibility.Collapsed; using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { foreach (InstalledApplication Pack in await Exclusive.Controller.GetAllInstalledApplicationAsync()) { if (!UWPPickerTip.IsOpen) { break; } PackageListViewSource.Add(Pack); } } if (UWPPickerTip.IsOpen) { await Task.Delay(500); UWPLoadingTip.Visibility = Visibility.Collapsed; PackageListView.Visibility = Visibility.Visible; } else { PackageListViewSource.Clear(); } }
public static async Task <string> RenameAsync(string Path, string DesireName) { using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { return(await Exclusive.Controller.RenameAsync(Path, DesireName).ConfigureAwait(false)); } }
public static async Task CopyAsync(string SourcePath, string DirectoryPath, ProgressChangedEventHandler ProgressHandler = null, bool IsUndoOperation = false) { using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { await Exclusive.Controller.CopyAsync(SourcePath, DirectoryPath, IsUndoOperation, ProgressHandler).ConfigureAwait(false); } }
public async Task <HiddenDataPackage> GetRawDataAsync() { using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { return(await Exclusive.Controller.GetHiddenItemDataAsync(Path)); } }
public async Task <bool> RestoreAsync() { using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { return(await Exclusive.Controller.RestoreItemInRecycleBinAsync(OriginPath).ConfigureAwait(true)); } }
public virtual async Task MoveAsync(string DirectoryPath, CollisionOptions Option = CollisionOptions.None, ProgressChangedEventHandler ProgressHandler = null) { using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { await Exclusive.Controller.MoveAsync(Path, DirectoryPath, Option, false, ProgressHandler); } }
public async Task Invoke() { using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { await Exclusive.Controller.InvokeContextMenuItemAsync(this).ConfigureAwait(false); } }
public async Task <bool> DeleteAsync() { using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { return(await Exclusive.Controller.DeleteItemInRecycleBinAsync(Path)); } }
public async Task LaunchAsync() { try { using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { if (LinkType == ShellLinkType.Normal) { if (!await Exclusive.Controller.RunAsync(LinkTargetPath, WorkDirectory, WindowState, NeedRunAsAdmin, false, false, Arguments)) { await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() => { QueueContentDialog Dialog = new QueueContentDialog { Title = Globalization.GetString("Common_Dialog_ErrorTitle"), Content = Globalization.GetString("QueueDialog_LaunchFailed_Content"), CloseButtonText = Globalization.GetString("Common_Dialog_CloseButton") }; await Dialog.ShowAsync(); }); } } else { if (!await Exclusive.Controller.LaunchUWPFromPfnAsync(LinkTargetPath)) { await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() => { QueueContentDialog Dialog = new QueueContentDialog { Title = Globalization.GetString("Common_Dialog_ErrorTitle"), Content = Globalization.GetString("QueueDialog_LaunchFailed_Content"), CloseButtonText = Globalization.GetString("Common_Dialog_CloseButton") }; await Dialog.ShowAsync(); }); } } } } catch (Exception ex) { LogTracer.Log(ex); await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() => { QueueContentDialog Dialog = new QueueContentDialog { Title = Globalization.GetString("Common_Dialog_ErrorTitle"), Content = Globalization.GetString("QueueDialog_LaunchFailed_Content"), CloseButtonText = Globalization.GetString("Common_Dialog_CloseButton") }; await Dialog.ShowAsync(); }); } }
public async virtual Task <string> RenameAsync(string DesireName) { using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { string NewName = await Exclusive.Controller.RenameAsync(Path, DesireName); Path = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(Path), NewName); return(NewName); } }
private async void DeviceGrid_ItemClick(object sender, ItemClickEventArgs e) { LibraryGrid.SelectedIndex = -1; if (!SettingControl.IsDoubleClickEnable && e.ClickedItem is HardDeviceInfo Device) { if (Device.IsLockedByBitlocker) { Retry: BitlockerPasswordDialog Dialog = new BitlockerPasswordDialog(); if (await Dialog.ShowAsync().ConfigureAwait(true) == ContentDialogResult.Primary) { using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { await Exclusive.Controller.RunAsync("powershell.exe", true, true, true, "-Command", $"$BitlockerSecureString = ConvertTo-SecureString '{Dialog.Password}' -AsPlainText -Force;", $"Unlock-BitLocker -MountPoint '{Device.Folder.Path}' -Password $BitlockerSecureString").ConfigureAwait(true); } StorageFolder DeviceFolder = await StorageFolder.GetFolderFromPathAsync(Device.Folder.Path); BasicProperties Properties = await DeviceFolder.GetBasicPropertiesAsync(); IDictionary <string, object> PropertiesRetrieve = await Properties.RetrievePropertiesAsync(new string[] { "System.Capacity", "System.FreeSpace", "System.Volume.FileSystem", "System.Volume.BitLockerProtection" }); HardDeviceInfo NewDevice = new HardDeviceInfo(DeviceFolder, await DeviceFolder.GetThumbnailBitmapAsync().ConfigureAwait(true), PropertiesRetrieve, Device.DriveType); if (!NewDevice.IsLockedByBitlocker) { int Index = CommonAccessCollection.HardDeviceList.IndexOf(Device); CommonAccessCollection.HardDeviceList.Remove(Device); CommonAccessCollection.HardDeviceList.Insert(Index, NewDevice); } else { QueueContentDialog UnlockFailedDialog = new QueueContentDialog { Title = Globalization.GetString("Common_Dialog_ErrorTitle"), Content = Globalization.GetString("QueueDialog_UnlockBitlockerFailed_Content"), PrimaryButtonText = Globalization.GetString("Common_Dialog_RetryButton"), CloseButtonText = Globalization.GetString("Common_Dialog_CancelButton") }; if (await UnlockFailedDialog.ShowAsync().ConfigureAwait(true) == ContentDialogResult.Primary) { goto Retry; } } } } else { await OpenTargetFolder(Device.Folder).ConfigureAwait(false); } } }
private async void TabViewContainer_KeyDown(CoreWindow sender, KeyEventArgs args) { if (!QueueContentDialog.IsRunningOrWaiting) { CoreVirtualKeyStates CtrlState = sender.GetKeyState(VirtualKey.Control); switch (args.VirtualKey) { case VirtualKey.W when CtrlState.HasFlag(CoreVirtualKeyStates.Down): { if (TabViewControl.SelectedItem is TabViewItem Tab) { args.Handled = true; await CleanUpAndRemoveTabItem(Tab); } return; } } if (CurrentNavigationControl?.Content is ThisPC PC) { switch (args.VirtualKey) { case VirtualKey.T when CtrlState.HasFlag(CoreVirtualKeyStates.Down): { await CreateNewTabAsync(); args.Handled = true; break; } case VirtualKey.Space when SettingControl.IsQuicklookEnable: { using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { if (await Exclusive.Controller.CheckIfQuicklookIsAvaliableAsync()) { if (PC.DeviceGrid.SelectedItem is DriveRelatedData Device && !string.IsNullOrEmpty(Device.Folder.Path)) { await Exclusive.Controller.ViewWithQuicklookAsync(Device.Folder.Path); } else if (PC.LibraryGrid.SelectedItem is LibraryFolder Library && !string.IsNullOrEmpty(Library.Folder.Path)) { await Exclusive.Controller.ViewWithQuicklookAsync(Library.Folder.Path); } } } args.Handled = true; break; }
private async void EjectButton_Click(object sender, RoutedEventArgs e) { if (DeviceGrid.SelectedItem is DriveDataBase Item) { if (string.IsNullOrEmpty(Item.Path)) { QueueContentDialog Dialog = new QueueContentDialog { Title = Globalization.GetString("Common_Dialog_ErrorTitle"), Content = Globalization.GetString("QueueContentDialog_UnableToEject_Content"), CloseButtonText = Globalization.GetString("Common_Dialog_CloseButton") }; await Dialog.ShowAsync().ConfigureAwait(false); } else { foreach ((TabViewItem Tab, BladeItem[] Blades) in TabViewContainer.ThisPage.TabCollection.Where((Tab) => Tab.Tag is FileControl) .Select((Tab) => (Tab, (Tab.Tag as FileControl).BladeViewer.Items.Cast <BladeItem>().ToArray())).ToArray()) { if (Blades.Select((BItem) => (BItem.Content as FilePresenter)?.CurrentFolder?.Path) .All((BladePath) => Item.Path.Equals(Path.GetPathRoot(BladePath), StringComparison.OrdinalIgnoreCase))) { await TabViewContainer.ThisPage.CleanUpAndRemoveTabItem(Tab); } else { foreach (BladeItem BItem in Blades.Where((BItem) => Item.Path.Equals(Path.GetPathRoot((BItem.Content as FilePresenter)?.CurrentFolder?.Path)))) { await(Tab.Tag as FileControl).CloseBladeAsync(BItem); } } } using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { if (await Exclusive.Controller.EjectPortableDevice(Item.Path)) { ShowEjectNotification(); } else { QueueContentDialog Dialog = new QueueContentDialog { Title = Globalization.GetString("Common_Dialog_ErrorTitle"), Content = Globalization.GetString("QueueContentDialog_UnableToEject_Content"), CloseButtonText = Globalization.GetString("Common_Dialog_CloseButton") }; await Dialog.ShowAsync().ConfigureAwait(false); } } } } }
private async void PermanentDelete_Click(object sender, RoutedEventArgs e) { if (ListViewControl.SelectedItems.Count > 0) { await ActivateLoading(true, Globalization.GetString("RecycleBinDeleteText")).ConfigureAwait(true); QueueContentDialog QueueContenDialog = new QueueContentDialog { Title = Globalization.GetString("Common_Dialog_WarningTitle"), Content = Globalization.GetString("QueueDialog_DeleteFile_Content"), PrimaryButtonText = Globalization.GetString("Common_Dialog_ContinueButton"), CloseButtonText = Globalization.GetString("Common_Dialog_CancelButton") }; if ((await QueueContenDialog.ShowAsync().ConfigureAwait(true)) == ContentDialogResult.Primary) { List <string> ErrorList = new List <string>(); using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { foreach (RecycleStorageItem Item in ListViewControl.SelectedItems.ToList()) { if (await Exclusive.Controller.DeleteItemInRecycleBinAsync(Item.Path).ConfigureAwait(true)) { FileCollection.Remove(Item); } else { ErrorList.Add(Item.Name); } } } if (ErrorList.Count > 0) { QueueContentDialog Dialog = new QueueContentDialog { Title = Globalization.GetString("Common_Dialog_ErrorTitle"), Content = $"{Globalization.GetString("QueueDialog_RecycleBinDeleteError_Content")} {Environment.NewLine}{string.Join(Environment.NewLine, ErrorList)}", CloseButtonText = Globalization.GetString("Common_Dialog_CloseButton") }; _ = Dialog.ShowAsync().ConfigureAwait(true); } } await ActivateLoading(false).ConfigureAwait(true); if (FileCollection.Count == 0) { HasFile.Visibility = Visibility.Visible; ClearRecycleBin.IsEnabled = false; } } }
private async void QuickStartGridView_ItemClick(object sender, ItemClickEventArgs e) { if (e.ClickedItem is QuickStartItem Item) { if ((sender as GridView).Name == nameof(QuickStartGridView)) { Uri Ur = new Uri(Item.Protocol); if (Ur.IsFile) { if (WIN_Native_API.CheckExist(Item.Protocol)) { using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { try { if (Path.GetExtension(Item.Protocol).ToLower() == ".msc") { await Exclusive.Controller.RunAsync("powershell.exe", false, true, false, "-Command", Item.Protocol).ConfigureAwait(true); } else { await Exclusive.Controller.RunAsync(Item.Protocol).ConfigureAwait(true); } } catch (Exception ex) { LogTracer.Log(ex, "Could not execute program in quick start"); } } } else { QueueContentDialog Dialog = new QueueContentDialog { Title = Globalization.GetString("Common_Dialog_ErrorTitle"), Content = Globalization.GetString("QueueDialog_ApplicationNotFound_Content"), CloseButtonText = Globalization.GetString("Common_Dialog_CloseButton") }; _ = await Dialog.ShowAsync().ConfigureAwait(true); } } else { await Launcher.LaunchUriAsync(Ur); } } else { await Launcher.LaunchUriAsync(new Uri(Item.Protocol)); } } }
private async void DeviceGrid_ItemClick(object sender, ItemClickEventArgs e) { LibraryGrid.SelectedIndex = -1; if (!SettingControl.IsDoubleClickEnable && e.ClickedItem is DriveRelatedData Device) { if (Device.IsLockedByBitlocker) { Retry: BitlockerPasswordDialog Dialog = new BitlockerPasswordDialog(); if (await Dialog.ShowAsync() == ContentDialogResult.Primary) { using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { await Exclusive.Controller.RunAsync("powershell.exe", string.Empty, WindowState.Normal, true, true, true, "-Command", $"$BitlockerSecureString = ConvertTo-SecureString '{Dialog.Password}' -AsPlainText -Force;", $"Unlock-BitLocker -MountPoint '{Device.Folder.Path}' -Password $BitlockerSecureString"); } StorageFolder DriveFolder = await StorageFolder.GetFolderFromPathAsync(Device.Folder.Path); DriveRelatedData NewDevice = await DriveRelatedData.CreateAsync(DriveFolder, Device.DriveType); if (!NewDevice.IsLockedByBitlocker) { int Index = CommonAccessCollection.DriveList.IndexOf(Device); CommonAccessCollection.DriveList.Remove(Device); CommonAccessCollection.DriveList.Insert(Index, NewDevice); } else { QueueContentDialog UnlockFailedDialog = new QueueContentDialog { Title = Globalization.GetString("Common_Dialog_ErrorTitle"), Content = Globalization.GetString("QueueDialog_UnlockBitlockerFailed_Content"), PrimaryButtonText = Globalization.GetString("Common_Dialog_RetryButton"), CloseButtonText = Globalization.GetString("Common_Dialog_CancelButton") }; if (await UnlockFailedDialog.ShowAsync() == ContentDialogResult.Primary) { goto Retry; } } } } else { await OpenTargetFolder(Device.Folder).ConfigureAwait(false); } } }
public static async Task <string> TranslateVariable(string Variable) { if (string.IsNullOrWhiteSpace(Variable)) { return(string.Empty); } else { using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { return(await Exclusive.Controller.GetVariablePathAsync(Variable.Trim('%')).ConfigureAwait(false)); } } }
protected override async void OnWindowCreated(WindowCreatedEventArgs args) { MSStoreHelper.Current.PreLoadAppLicense(); using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { if (await Exclusive.Controller.CheckIfQuicklookIsAvaliableAsync().ConfigureAwait(true)) { SettingControl.IsQuicklookAvailable = true; } else { SettingControl.IsQuicklookAvailable = false; } } }