private async void Screen_Dismissed(SplashScreen sender, object args)
{
try
{
bool IsFileAccessible = await CheckAccessAuthorityAsync();
if (IsFileAccessible)
{
await DismissExtendedSplashAsync();
}
else
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Display.Text = Globalization.GetString("ExtendedSplash_Access_Tips");
PermissionArea.Visibility = Visibility.Visible;
LoadingBingArea.Visibility = Visibility.Collapsed;
});
}
}
catch (Exception ex)
{
LogTracer.Log(ex, "An error was threw when dismissing extendedsplash ");
}
}
private async Task DismissExtendedSplashAsync()
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
try
{
if (BackgroundController.Current.CurrentType == BackgroundBrushType.BingPicture)
{
LoadingBingArea.Visibility = Visibility.Visible;
}
await BackgroundController.Current.InitializeAsync();
Frame RootFrame = new Frame();
Window.Current.Content = RootFrame;
if ((Parameter?.Count).GetValueOrDefault() == 0)
{
MainPage Main = new MainPage(Splash.ImageLocation);
RootFrame.Content = Main;
}
else
{
MainPage Main = new MainPage(Splash.ImageLocation, Parameter);
RootFrame.Content = Main;
}
}
catch (Exception ex)
{
LogTracer.Log(ex, "An error was threw when dismissing extendedsplash ");
}
});
}
private async Task LoadTextFromFileWithEncoding(FileSystemStorageFile File, Encoding Enco)
{
LoadingControl.IsLoading = true;
await Task.Delay(500);
try
{
using (FileStream Stream = await File.GetFileStreamFromFileAsync(AccessMode.Read))
using (StreamReader Reader = new StreamReader(Stream, Enco, false))
{
EditText.Text = await Reader.ReadToEndAsync();
}
}
catch (Exception ex)
{
LogTracer.Log(ex, "Could not load the content in file");
QueueContentDialog Dialog = new QueueContentDialog
{
Title = Globalization.GetString("Common_Dialog_ErrorTitle"),
Content = Globalization.GetString("QueueDialog_CouldReadWriteFile_Content"),
CloseButtonText = Globalization.GetString("Common_Dialog_CloseButton")
};
await Dialog.ShowAsync();
}
await Task.Delay(500);
LoadingControl.IsLoading = false;
}
private async void ContentDialog_PrimaryButtonClick(ContentDialog sender, ContentDialogButtonClickEventArgs args)
{
var Deferral = args.GetDeferral();
try
{
if (CurrentEncoding == null)
{
args.Cancel = true;
InvalidTip.IsOpen = true;
}
else if (await FileSystemStorageItemBase.OpenAsync(ExtractLocation) is not FileSystemStorageFolder)
{
if (await FileSystemStorageItemBase.CheckExistAsync(ExtractLocation) == false)
{
await FileSystemStorageItemBase.CreateAsync(ExtractLocation, StorageItemTypes.Folder, CreateOption.OpenIfExist).ConfigureAwait(false);
}
else
{
args.Cancel = true;
}
}
}
catch (Exception ex)
{
LogTracer.Log(ex);
}
finally
{
Deferral.Complete();
}
}
private async void Save_Click(object sender, RoutedEventArgs e)
{
try
{
if (await FileSystemStorageItemBase.CreateAsync(TextFile.Path, StorageItemTypes.File, CreateOption.ReplaceExisting) is FileSystemStorageFile File)
{
using (FileStream Stream = await File.GetFileStreamFromFileAsync(AccessMode.Write))
using (StreamWriter Writer = new StreamWriter(Stream, SaveEncoding))
{
await Writer.WriteAsync(EditText.Text);
}
}
else
{
throw new FileNotFoundException();
}
}
catch (Exception ex)
{
LogTracer.Log(ex, "Could not save the content to file");
QueueContentDialog Dialog = new QueueContentDialog
{
Title = Globalization.GetString("Common_Dialog_ErrorTitle"),
Content = Globalization.GetString("QueueDialog_CouldReadWriteFile_Content"),
CloseButtonText = Globalization.GetString("Common_Dialog_CloseButton")
};
await Dialog.ShowAsync();
}
finally
{
Frame.GoBack();
}
}
public async Task OpenTargetFolder(StorageFolder Folder)
{
if (Folder == null)
{
throw new ArgumentNullException(nameof(Folder), "Argument could not be null");
}
try
{
if (string.IsNullOrEmpty(Folder.Path))
{
QueueContentDialog Dialog = new QueueContentDialog
{
Title = Globalization.GetString("Common_Dialog_TipTitle"),
Content = Globalization.GetString("QueueDialog_CouldNotAccess_Content"),
CloseButtonText = Globalization.GetString("Common_Dialog_CloseButton")
};
await Dialog.ShowAsync();
}
else
{
EnterActionRequested?.Invoke(this, Folder.Path);
}
}
catch (Exception ex)
{
LogTracer.Log(ex, "An error was threw when entering device");
}
}
private async void QueueContentDialog_PrimaryButtonClick(ContentDialog sender, ContentDialogButtonClickEventArgs args)
{
ContentDialogButtonClickDeferral Deferral = args.GetDeferral();
try
{
if (CurrentUseProgramList.SelectedItem is ProgramPickerItem CurrentItem)
{
SelectedProgram = CurrentItem;
}
else if (OtherProgramList.SelectedItem is ProgramPickerItem OtherItem)
{
SelectedProgram = OtherItem;
if (UseAsAdmin.IsChecked.GetValueOrDefault() || OpenFromPropertiesWindow)
{
await SQLite.Current.SetDefaultProgramPickerRecordAsync(OpenFile.Type, OtherItem.Path);
}
}
else
{
args.Cancel = true;
}
}
catch (Exception ex)
{
LogTracer.Log(ex);
}
finally
{
Deferral.Complete();
}
}
private void DecompressDialog_Loading(FrameworkElement sender, object args)
{
try
{
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
foreach (EncodingInfo Enco in Encoding.GetEncodings())
{
if (Enco.CodePage == Encoding.Default.CodePage)
{
AvailableEncoding.Insert(0, Enco.GetEncoding());
}
else
{
AvailableEncoding.Add(Enco.GetEncoding());
}
}
AvailableEncoding.Add(Encoding.GetEncoding(936));
EncodingOption.SelectedIndex = 0;
}
catch (Exception ex)
{
LogTracer.Log(ex);
}
}
private async void Screen_Dismissed(SplashScreen sender, object args)
{
try
{
if (!ApplicationData.Current.LocalSettings.Values.ContainsKey("QuickStartInitialFinished1"))
{
SQLite.Current.ClearTable("QuickStart");
SQLite.Current.SetQuickStartItem(Globalization.GetString("ExtendedSplash_QuickStartItem_Name_1"), "ms-appx:///QuickStartImage/MicrosoftStore.png", "ms-windows-store://home", QuickStartType.Application);
SQLite.Current.SetQuickStartItem(Globalization.GetString("ExtendedSplash_QuickStartItem_Name_2"), "ms-appx:///QuickStartImage/Calculator.png", "calculator:", QuickStartType.Application);
SQLite.Current.SetQuickStartItem(Globalization.GetString("ExtendedSplash_QuickStartItem_Name_3"), "ms-appx:///QuickStartImage/Setting.png", "ms-settings:", QuickStartType.Application);
SQLite.Current.SetQuickStartItem(Globalization.GetString("ExtendedSplash_QuickStartItem_Name_4"), "ms-appx:///QuickStartImage/Email.png", "mailto:", QuickStartType.Application);
SQLite.Current.SetQuickStartItem(Globalization.GetString("ExtendedSplash_QuickStartItem_Name_5"), "ms-appx:///QuickStartImage/Calendar.png", "outlookcal:", QuickStartType.Application);
SQLite.Current.SetQuickStartItem(Globalization.GetString("ExtendedSplash_QuickStartItem_Name_6"), "ms-appx:///QuickStartImage/Photos.png", "ms-photos:", QuickStartType.Application);
SQLite.Current.SetQuickStartItem(Globalization.GetString("ExtendedSplash_QuickStartItem_Name_7"), "ms-appx:///QuickStartImage/Weather.png", "msnweather:", QuickStartType.Application);
SQLite.Current.SetQuickStartItem(Globalization.GetString("ExtendedSplash_QuickStartItem_Name_9"), "ms-appx:///HotWebImage/Facebook.png", "https://www.facebook.com/", QuickStartType.WebSite);
SQLite.Current.SetQuickStartItem(Globalization.GetString("ExtendedSplash_QuickStartItem_Name_10"), "ms-appx:///HotWebImage/Instagram.png", "https://www.instagram.com/", QuickStartType.WebSite);
SQLite.Current.SetQuickStartItem(Globalization.GetString("ExtendedSplash_QuickStartItem_Name_11"), "ms-appx:///HotWebImage/Twitter.png", "https://twitter.com", QuickStartType.WebSite);
ApplicationData.Current.LocalSettings.Values["QuickStartInitialFinished1"] = true;
}
if (ApplicationData.Current.LocalSettings.Values.ContainsKey("RefreshQuickStart"))
{
SQLite.Current.UpdateQuickStartItem("ms-appx:///QuickStartImage/MicrosoftStore.png", Globalization.GetString("ExtendedSplash_QuickStartItem_Name_1"), QuickStartType.Application);
SQLite.Current.UpdateQuickStartItem("ms-appx:///QuickStartImage/Calculator.png", Globalization.GetString("ExtendedSplash_QuickStartItem_Name_2"), QuickStartType.Application);
SQLite.Current.UpdateQuickStartItem("ms-appx:///QuickStartImage/Setting.png", Globalization.GetString("ExtendedSplash_QuickStartItem_Name_3"), QuickStartType.Application);
SQLite.Current.UpdateQuickStartItem("ms-appx:///QuickStartImage/Email.png", Globalization.GetString("ExtendedSplash_QuickStartItem_Name_4"), QuickStartType.Application);
SQLite.Current.UpdateQuickStartItem("ms-appx:///QuickStartImage/Calendar.png", Globalization.GetString("ExtendedSplash_QuickStartItem_Name_5"), QuickStartType.Application);
SQLite.Current.UpdateQuickStartItem("ms-appx:///QuickStartImage/Photos.png", Globalization.GetString("ExtendedSplash_QuickStartItem_Name_6"), QuickStartType.Application);
SQLite.Current.UpdateQuickStartItem("ms-appx:///QuickStartImage/Weather.png", Globalization.GetString("ExtendedSplash_QuickStartItem_Name_7"), QuickStartType.Application);
SQLite.Current.UpdateQuickStartItem("ms-appx:///HotWebImage/Facebook.png", Globalization.GetString("ExtendedSplash_QuickStartItem_Name_9"), QuickStartType.WebSite);
SQLite.Current.UpdateQuickStartItem("ms-appx:///HotWebImage/Instagram.png", Globalization.GetString("ExtendedSplash_QuickStartItem_Name_10"), QuickStartType.WebSite);
SQLite.Current.UpdateQuickStartItem("ms-appx:///HotWebImage/Twitter.png", Globalization.GetString("ExtendedSplash_QuickStartItem_Name_11"), QuickStartType.WebSite);
ApplicationData.Current.LocalSettings.Values.Remove("RefreshQuickStart");
}
bool IsFileAccessible = await CheckAccessAuthority();
if (IsFileAccessible)
{
await DismissExtendedSplashAsync();
}
else
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Display.Text = Globalization.GetString("ExtendedSplash_Access_Tips");
PermissionArea.Visibility = Visibility.Visible;
LoadingBingArea.Visibility = Visibility.Collapsed;
});
}
}
catch (Exception ex)
{
LogTracer.Log(ex, "An error was threw when dismissing extendedsplash ");
}
}
private async void CustomPairInfo_PairingRequested(DeviceInformationCustomPairing sender, DevicePairingRequestedEventArgs args)
{
Deferral PairDeferral = args.GetDeferral();
try
{
PairConfirmaion = new TaskCompletionSource <bool>();
switch (args.PairingKind)
{
case DevicePairingKinds.ConfirmPinMatch:
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Tips.Text = $"{Globalization.GetString("BluetoothUI_Tips_Text_5")}{Environment.NewLine}{args.Pin}";
Tips.Visibility = Visibility.Visible;
PinConfirm.Visibility = Visibility.Visible;
PinRefuse.Visibility = Visibility.Visible;
});
if (await PairConfirmaion.Task)
{
args.Accept(args.Pin);
}
break;
}
case DevicePairingKinds.ConfirmOnly:
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Tips.Text = Globalization.GetString("BluetoothUI_Tips_Text_6");
Tips.Visibility = Visibility.Visible;
PinConfirm.Visibility = Visibility.Visible;
PinRefuse.Visibility = Visibility.Visible;
});
if (await PairConfirmaion.Task)
{
args.Accept();
}
break;
}
}
}
catch (Exception ex)
{
LogTracer.Log(ex, $"An exception was threw in {nameof(CustomPairInfo_PairingRequested)}, pair with bluetooth failed");
}
finally
{
PairDeferral.Complete();
}
}
private async Task Initialize(bool SearchShallow)
{
HasItem.Visibility = Visibility.Collapsed;
LoadingControl.IsLoading = true;
MainPage.ThisPage.IsAnyTaskRunning = true;
try
{
Cancellation = new CancellationTokenSource();
if (WeakToFileControl.TryGetTarget(out FileControl Control))
{
string CurrentPath = Control.CurrentFolder.Path;
string SearchTarget = Control.GlobeSearch.Text;
List <FileSystemStorageItemBase> SearchItems = await Task.Run(() => WIN_Native_API.Search(CurrentPath, SearchTarget, !SearchShallow, SettingControl.IsDisplayHiddenItem, Cancellation.Token)).ConfigureAwait(true);
await Task.Delay(500).ConfigureAwait(true);
LoadingControl.IsLoading = false;
if (Cancellation.IsCancellationRequested)
{
HasItem.Visibility = Visibility.Visible;
SearchResultList.Visibility = Visibility.Collapsed;
}
else
{
if (SearchItems.Count == 0)
{
HasItem.Visibility = Visibility.Visible;
}
else
{
foreach (FileSystemStorageItemBase Item in SortCollectionGenerator.Current.GetSortedCollection(SearchItems))
{
SearchResult.Add(Item);
}
}
}
}
}
catch (Exception ex)
{
LogTracer.Log(ex, $"An error was threw in {nameof(Initialize)}");
}
finally
{
MainPage.ThisPage.IsAnyTaskRunning = false;
Cancellation.Dispose();
Cancellation = null;
}
}
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 QueueContentDialog_PrimaryButtonClick(ContentDialog sender, ContentDialogButtonClickEventArgs args)
{
ContentDialogButtonClickDeferral Deferral = args.GetDeferral();
try
{
if (CurrentUseProgramList.SelectedItem is ProgramPickerItem CurrentItem)
{
SelectedProgram = CurrentItem;
}
else if (OtherProgramList.SelectedItem is ProgramPickerItem OtherItem)
{
SelectedProgram = OtherItem;
}
else
{
args.Cancel = true;
}
if (SelectedProgram != null && UseAsAdmin.IsChecked.GetValueOrDefault() || OpenFromPropertiesWindow)
{
string ExecutablePath = SelectedProgram.Path;
if (Path.IsPathRooted(ExecutablePath) && Path.GetExtension(ExecutablePath).Equals(".lnk", StringComparison.OrdinalIgnoreCase))
{
if (await FileSystemStorageItemBase.OpenAsync(ExecutablePath) is LinkStorageFile LinkFile)
{
if (await LinkFile.GetRawDataAsync() is LinkDataPackage Package && !string.IsNullOrEmpty(Package.LinkTargetPath))
{
ExecutablePath = Package.LinkTargetPath;
}
}
}
SQLite.Current.SetDefaultProgramPickerRecord(OpenFile.Type, ExecutablePath);
}
}
catch (Exception ex)
{
LogTracer.Log(ex);
}
finally
{
Deferral.Complete();
}
}
public async void Refresh_Click(object sender, RoutedEventArgs e)
{
if (Interlocked.Exchange(ref LockResource, 1) == 0)
{
try
{
CommonAccessCollection.DriveList.Clear();
foreach (DriveInfo Drive in DriveInfo.GetDrives().Where((Drives) => Drives.DriveType == DriveType.Fixed || Drives.DriveType == DriveType.Removable || Drives.DriveType == DriveType.Network)
.Where((NewItem) => CommonAccessCollection.DriveList.All((Item) => Item.Folder.Path != NewItem.RootDirectory.FullName)))
{
try
{
StorageFolder DriveFolder = await StorageFolder.GetFolderFromPathAsync(Drive.RootDirectory.FullName);
CommonAccessCollection.DriveList.Add(await DriveRelatedData.CreateAsync(DriveFolder, Drive.DriveType));
}
catch (Exception ex)
{
LogTracer.Log(ex, $"Hide the device \"{Drive.RootDirectory.FullName}\" for error");
}
}
foreach (DeviceInformation Device in await DeviceInformation.FindAllAsync(StorageDevice.GetDeviceSelector()))
{
try
{
StorageFolder DriveFolder = StorageDevice.FromId(Device.Id);
if (CommonAccessCollection.DriveList.All((Item) => (string.IsNullOrEmpty(Item.Folder.Path) || string.IsNullOrEmpty(DriveFolder.Path)) ? Item.Folder.Name != DriveFolder.Name : Item.Folder.Path != DriveFolder.Path))
{
CommonAccessCollection.DriveList.Add(await DriveRelatedData.CreateAsync(DriveFolder, DriveType.Removable));
}
}
catch (Exception ex)
{
LogTracer.Log(ex, $"Hide the device \"{Device.Name}\" for error");
}
}
}
finally
{
_ = Interlocked.Exchange(ref LockResource, 0);
}
}
}
private void Adjust_Click(object sender, RoutedEventArgs e)
{
try
{
if (AnimationController.Current.IsEnableAnimation)
{
Frame.Navigate(typeof(CropperPage), Flip.SelectedItem, new DrillInNavigationTransitionInfo());
}
else
{
Frame.Navigate(typeof(CropperPage), Flip.SelectedItem, new SuppressNavigationTransitionInfo());
}
}
catch (Exception ex)
{
LogTracer.Log(ex, "An error was threw when navigating to CropperPage");
}
}
private async void PortalDeviceWatcher_Removed(DeviceWatcher sender, DeviceInformationUpdate args)
{
try
{
List <string> AllBaseDevice = DriveInfo.GetDrives().Where((Drives) => Drives.DriveType == DriveType.Fixed)
.Select((Info) => Info.RootDirectory.FullName).ToList();
List <StorageFolder> PortableDevice = new List <StorageFolder>();
foreach (DeviceInformation Device in await DeviceInformation.FindAllAsync(StorageDevice.GetDeviceSelector()))
{
try
{
PortableDevice.Add(StorageDevice.FromId(Device.Id));
}
catch (Exception ex)
{
LogTracer.Log(ex, $"Error happened when get storagefolder from {Device.Name}");
}
}
foreach (string PortDevice in AllBaseDevice.Where((Path) => PortableDevice.Any((Item) => Item.Path.Equals(Path, StringComparison.OrdinalIgnoreCase))))
{
AllBaseDevice.Remove(PortDevice);
}
List <HardDeviceInfo> OneStepDeviceList = CommonAccessCollection.HardDeviceList.Where((Item) => !AllBaseDevice.Contains(Item.Folder.Path)).ToList();
List <HardDeviceInfo> TwoStepDeviceList = OneStepDeviceList.Where((RemoveItem) => PortableDevice.All((Item) => Item.Name != RemoveItem.Folder.Name)).ToList();
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
foreach (HardDeviceInfo Device in TwoStepDeviceList)
{
foreach (TabViewItem Tab in TabViewControl.TabItems.OfType <TabViewItem>().Where((Tab) => Tab.Content is Frame frame && CommonAccessCollection.FrameFileControlDic.TryGetValue(frame, out FileControl Value) && Path.GetPathRoot(Value.CurrentFolder?.Path) == Device.Folder?.Path).ToArray())
{
await CleanUpAndRemoveTabItem(Tab).ConfigureAwait(true);
}
CommonAccessCollection.HardDeviceList.Remove(Device);
}
});
}
private void ShowEjectNotification()
{
try
{
ToastNotificationManager.History.Remove("MergeVideoNotification");
ToastContentBuilder Builder = new ToastContentBuilder()
.SetToastScenario(ToastScenario.Default)
.AddToastActivationInfo("Transcode", ToastActivationType.Foreground)
.AddText(Globalization.GetString("Eject_Toast_Text_1"))
.AddText(Globalization.GetString("Eject_Toast_Text_2"))
.AddText(Globalization.GetString("Eject_Toast_Text_3"));
ToastNotificationManager.CreateToastNotifier().Show(new ToastNotification(Builder.GetToastContent().GetXml()));
}
catch (Exception ex)
{
LogTracer.Log(ex, "Toast notification could not be sent");
}
}
public async Task OpenTargetFolder(StorageFolder Folder)
{
if (Folder == null)
{
throw new ArgumentNullException(nameof(Folder), "Argument could not be null");
}
try
{
if (string.IsNullOrEmpty(Folder.Path))
{
QueueContentDialog Dialog = new QueueContentDialog
{
Title = Globalization.GetString("Common_Dialog_TipTitle"),
Content = Globalization.GetString("QueueDialog_MTP_CouldNotAccess_Content"),
PrimaryButtonText = Globalization.GetString("Common_Dialog_ContinueButton"),
CloseButtonText = Globalization.GetString("Common_Dialog_CancelButton")
};
if ((await Dialog.ShowAsync().ConfigureAwait(true)) == ContentDialogResult.Primary)
{
await Launcher.LaunchFolderAsync(Folder);
}
}
else
{
if (AnimationController.Current.IsEnableAnimation)
{
Frame.Navigate(typeof(FileControl), new Tuple <WeakReference <TabViewItem>, StorageFolder>(WeakToTabItem, Folder), new DrillInNavigationTransitionInfo());
}
else
{
Frame.Navigate(typeof(FileControl), new Tuple <WeakReference <TabViewItem>, StorageFolder>(WeakToTabItem, Folder), new SuppressNavigationTransitionInfo());
}
}
}
catch (Exception ex)
{
LogTracer.Log(ex, "An error was threw when entering device");
}
}
public void Execute(string[] args)
{
switch (args.Length)
{
case 0:
{
var current_dir_path = Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar;
var current_dir = new Uri(current_dir_path, UriKind.Absolute);
var proj = PackageProjectFile.LoadFromFile(current_dir.OriginalString);
var creater = new PackageCreater();
LogTracer.Log("[INFO] Started building package ...");
var info = creater.Build(current_dir, proj);
info.SaveInfo();
LogTracer.Log("[INFO] Finished building package");
}
break;
}
}
private async void SearchResultList_DoubleTapped(object sender, Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs e)
{
if ((e.OriginalSource as FrameworkElement).DataContext is FileSystemStorageItemBase Item)
{
try
{
string ParentFolderPath = Path.GetDirectoryName(Item.Path);
if (WeakToFileControl.TryGetTarget(out FileControl Control))
{
Frame.GoBack();
await Control.CurrentPresenter.DisplayItemsInFolder(ParentFolderPath).ConfigureAwait(true);
await JumpListController.Current.AddItemAsync(JumpListGroup.Recent, ParentFolderPath).ConfigureAwait(true);
if (Control.CurrentPresenter.FileCollection.FirstOrDefault((SItem) => SItem == Item) is FileSystemStorageItemBase Target)
{
Control.CurrentPresenter.ItemPresenter.ScrollIntoView(Target);
Control.CurrentPresenter.SelectedItem = Target;
}
}
}
catch (Exception ex)
{
LogTracer.Log(ex, $"An error was threw in {nameof(Location_Click)}");
QueueContentDialog dialog = new QueueContentDialog
{
Title = Globalization.GetString("Common_Dialog_ErrorTitle"),
Content = Globalization.GetString("QueueDialog_LocateFolderFailure_Content"),
CloseButtonText = Globalization.GetString("Common_Dialog_CloseButton")
};
_ = await dialog.ShowAsync().ConfigureAwait(true);
}
}
}
private async void Location_Click(object sender, RoutedEventArgs e)
{
if (SearchResultList.SelectedItem is FileSystemStorageItemBase Item)
{
try
{
StorageFolder ParentFolder = await StorageFolder.GetFolderFromPathAsync(Path.GetDirectoryName(Item.Path));
if (WeakToFileControl.TryGetTarget(out FileControl Control))
{
Frame.GoBack();
await Control.OpenTargetFolder(ParentFolder).ConfigureAwait(true);
await JumpListController.Current.AddItem(JumpListGroup.Recent, ParentFolder).ConfigureAwait(true);
if (Control.Presenter.FileCollection.FirstOrDefault((SItem) => SItem.Path == Item.Path) is FileSystemStorageItemBase Target)
{
Control.Presenter.ItemPresenter.ScrollIntoView(Target);
Control.Presenter.SelectedItem = Target;
}
}
}
catch (Exception ex)
{
LogTracer.Log(ex, $"An error was threw in {nameof(Location_Click)}");
QueueContentDialog dialog = new QueueContentDialog
{
Title = Globalization.GetString("Common_Dialog_ErrorTitle"),
Content = Globalization.GetString("QueueDialog_LocateFolderFailure_Content"),
CloseButtonText = Globalization.GetString("Common_Dialog_CloseButton")
};
_ = await dialog.ShowAsync().ConfigureAwait(true);
}
}
}
public TextViewer()
{
InitializeComponent();
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
Loaded += TextViewer_Loaded;
try
{
if (Globalization.CurrentLanguage == LanguageEnum.Chinese_Simplified)
{
AvailableEncoding.Add(Encoding.GetEncoding("GBK"));
}
}
catch (Exception ex)
{
LogTracer.Log(ex, "Could not load GBK encoding");
}
foreach (Encoding Coding in Encoding.GetEncodings().Select((Info) => Info.GetEncoding()))
{
AvailableEncoding.Add(Coding);
}
}
private async Task <Encoding> DetectEncodingFromFileAsync()
{
try
{
using (FileStream DetectStream = await TextFile.GetFileStreamFromFileAsync(AccessMode.Read))
{
return(await Task.Run(() =>
{
using (StreamReader Reader = new StreamReader(DetectStream, Encoding.Default, true))
{
Reader.Read();
return Reader.CurrentEncoding;
}
}));
}
}
catch (Exception ex)
{
LogTracer.Log(ex, "Could not detect the encoding of file");
return(null);
}
}
private async void DeleteFile_Click(object sender, RoutedEventArgs e)
{
QueueContentDialog Dialog = new QueueContentDialog
{
Title = Globalization.GetString("Common_Dialog_WarningTitle"),
PrimaryButtonText = Globalization.GetString("Common_Dialog_ContinueButton"),
Content = Globalization.GetString("QueueDialog_DeleteFile_Content"),
CloseButtonText = Globalization.GetString("Common_Dialog_CancelButton")
};
if ((await Dialog.ShowAsync().ConfigureAwait(true)) == ContentDialogResult.Primary)
{
foreach (SecureAreaStorageItem Item in SecureGridView.SelectedItems.ToArray())
{
SecureCollection.Remove(Item);
if (!Item.PermanentDelete())
{
LogTracer.Log(new Win32Exception(Marshal.GetLastWin32Error()), "Delete encrypted file failed");
}
}
}
}
public void CreateNewTabAndOpenTargetFolder(string Path, int?InsertIndex = null)
{
int Index = InsertIndex ?? (TabViewControl?.TabItems.Count ?? 0);
try
{
if (string.IsNullOrWhiteSpace(Path))
{
if (CreateNewTab() is TabViewItem Item)
{
TabViewControl.TabItems.Insert(Index, Item);
TabViewControl.UpdateLayout();
TabViewControl.SelectedItem = Item;
}
}
else
{
if (CreateNewTab(Path) is TabViewItem Item)
{
TabViewControl.TabItems.Insert(Index, Item);
TabViewControl.UpdateLayout();
TabViewControl.SelectedItem = Item;
}
}
}
catch (Exception ex)
{
if (CreateNewTab() is TabViewItem Item)
{
TabViewControl.TabItems.Insert(Index, Item);
TabViewControl.UpdateLayout();
TabViewControl.SelectedItem = Item;
}
LogTracer.Log(ex, "Error happened when try to create a new tab");
}
}
/// <summary>
/// 异步启动蓝牙的配对过程
/// </summary>
/// <param name="DeviceInfo"></param>
/// <returns></returns>
private async Task PairAsync(BluetoothDeivceData Device)
{
try
{
if (Device.DeviceInfo.Pairing.CanPair)
{
DeviceInformationCustomPairing CustomPairing = Device.DeviceInfo.Pairing.Custom;
CustomPairing.PairingRequested += CustomPairInfo_PairingRequested;
DevicePairingResult PairResult = await CustomPairing.PairAsync(DevicePairingKinds.ConfirmOnly | DevicePairingKinds.ConfirmPinMatch, DevicePairingProtectionLevel.EncryptionAndAuthentication);
CustomPairing.PairingRequested -= CustomPairInfo_PairingRequested;
if (PairResult.Status == DevicePairingResultStatus.Paired)
{
Device.Update();
}
else
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Tips.Text = Globalization.GetString("BluetoothUI_Tips_Text_4");
Tips.Visibility = Visibility.Visible;
});
}
}
else
{
LogTracer.Log($"Unable pair with Bluetooth device: \"{Device.Name}\", reason: CanPair property return false");
}
}
catch (Exception ex)
{
LogTracer.Log(ex, $"Unable pair with Bluetooth device: \"{Device.Name}\"");
}
}
private async void NavigationButton_Click(object sender, RoutedEventArgs e)
{
await Launcher.LaunchUriAsync(new Uri("ms-settings:privacy-broadfilesystemaccess"));
try
{
ToastContentBuilder Builder = new ToastContentBuilder()
.SetToastScenario(ToastScenario.Reminder)
.AddText(Globalization.GetString("Toast_BroadFileSystemAccess_Text_1"))
.AddText(Globalization.GetString("Toast_BroadFileSystemAccess_Text_2"))
.AddButton(Globalization.GetString("Toast_BroadFileSystemAccess_ActionButton_1"), ToastActivationType.Foreground, "Restart")
.AddButton(new ToastButtonDismiss(Globalization.GetString("Toast_BroadFileSystemAccess_ActionButton_2")));
ToastNotificationManager.CreateToastNotifier().Show(new ToastNotification(Builder.GetToastContent().GetXml()));
}
catch (Exception ex)
{
LogTracer.Log(ex, "Toast notification could not be sent");
}
finally
{
await ApplicationView.GetForCurrentView().TryConsolidateAsync();
}
}
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
try
{
if (e?.Parameter is PhotoDisplaySupport Item)
{
OriginFile = (await Item.PhotoFile.GetStorageItem().ConfigureAwait(true)) as StorageFile;
OriginImage = await Item.GenerateImageWithRotation().ConfigureAwait(true);
OriginBackupImage = SoftwareBitmap.Copy(OriginImage);
WriteableBitmap WBitmap = new WriteableBitmap(OriginImage.PixelWidth, OriginImage.PixelHeight);
OriginImage.CopyToBuffer(WBitmap.PixelBuffer);
Cropper.Source = WBitmap;
UnchangeRegion = Cropper.CroppedRegion;
await AddEffectsToPane().ConfigureAwait(false);
}
}
catch (Exception ex)
{
LogTracer.Log(ex, "An error was threw when initializing CropperPage");
}
}
private async Task Initialize()
{
try
{
ExitLocker = new ManualResetEvent(false);
Cancellation = new CancellationTokenSource();
LoadQueue = new Queue <int>();
MainPage.ThisPage.IsAnyTaskRunning = true;
Behavior.Attach(Flip);
List <FileSystemStorageItemBase> FileList = FileSystemStorageItemBase.Open(Path.GetDirectoryName(SelectedPhotoPath), ItemFilters.Folder).GetChildrenItems(SettingControl.IsDisplayHiddenItem, ItemFilters.File).Where((Item) => Item.Type.Equals(".png", StringComparison.OrdinalIgnoreCase) || Item.Type.Equals(".jpg", StringComparison.OrdinalIgnoreCase) || Item.Type.Equals(".bmp", StringComparison.OrdinalIgnoreCase)).ToList();
if (FileList.Count == 0)
{
QueueContentDialog Dialog = new QueueContentDialog
{
Title = Globalization.GetString("Common_Dialog_ErrorTitle"),
Content = Globalization.GetString("Queue_Dialog_ImageReadError_Content"),
CloseButtonText = Globalization.GetString("Common_Dialog_GoBack")
};
_ = await Dialog.ShowAsync().ConfigureAwait(true);
Frame.GoBack();
}
else
{
int LastSelectIndex = FileList.FindIndex((Photo) => Photo.Path.Equals(SelectedPhotoPath, StringComparison.OrdinalIgnoreCase));
if (LastSelectIndex < 0 || LastSelectIndex >= FileList.Count)
{
LastSelectIndex = 0;
}
PhotoCollection = new ObservableCollection <PhotoDisplaySupport>(FileList.Select((Item) => new PhotoDisplaySupport(Item)));
Flip.ItemsSource = PhotoCollection;
if (!await PhotoCollection[LastSelectIndex].ReplaceThumbnailBitmapAsync().ConfigureAwait(true))
{
CouldnotLoadTip.Visibility = Visibility.Visible;
}
for (int i = LastSelectIndex - 5 > 0 ? LastSelectIndex - 5 : 0; i <= (LastSelectIndex + 5 < PhotoCollection.Count - 1 ? LastSelectIndex + 5 : PhotoCollection.Count - 1) && !Cancellation.IsCancellationRequested; i++)
{
await PhotoCollection[i].GenerateThumbnailAsync().ConfigureAwait(true);
}
if (!Cancellation.IsCancellationRequested)
{
Flip.SelectedIndex = LastSelectIndex;
Flip.SelectionChanged += Flip_SelectionChanged;
Flip.SelectionChanged += Flip_SelectionChanged1;
await EnterAnimation.BeginAsync().ConfigureAwait(true);
}
}
}
catch (Exception ex)
{
CouldnotLoadTip.Visibility = Visibility.Visible;
LogTracer.Log(ex, "An error was threw when initialize PhotoViewer");
}
finally
{
MainPage.ThisPage.IsAnyTaskRunning = false;
ExitLocker.Set();
}
}
private async void QueueContentDialog_PrimaryButtonClick(ContentDialog sender, ContentDialogButtonClickEventArgs args)
{
ContentDialogButtonClickDeferral Deferral = args.GetDeferral();
try
{
if ((Type == QuickStartType.Application && CommonAccessCollection.QuickStartList.Any((Item) => Item.DisplayName == DisplayName.Text)) ||
(Type == QuickStartType.WebSite && CommonAccessCollection.WebLinkList.Any((Item) => Item.DisplayName == DisplayName.Text)))
{
ExistTip.IsOpen = true;
args.Cancel = true;
}
else if (Icon.Source == null || (Icon.Source as BitmapImage)?.UriSource?.OriginalString == "ms-appx:///Assets/AddImage.png")
{
EmptyTip.Target = Icon;
EmptyTip.IsOpen = true;
args.Cancel = true;
}
else if (string.IsNullOrWhiteSpace(Protocol.Text))
{
EmptyTip.Target = Protocol;
EmptyTip.IsOpen = true;
args.Cancel = true;
}
else if (string.IsNullOrWhiteSpace(DisplayName.Text))
{
EmptyTip.Target = DisplayName;
EmptyTip.IsOpen = true;
args.Cancel = true;
}
else
{
switch (Type)
{
case QuickStartType.Application:
{
if (Uri.TryCreate(Protocol.Text, UriKind.Absolute, out _))
{
if (!FileSystemItemNameChecker.IsValid(DisplayName.Text))
{
args.Cancel = true;
InvalidCharTip.IsOpen = true;
Deferral.Complete();
return;
}
if (IsUpdate)
{
if (ImageFile == null)
{
SQLite.Current.UpdateQuickStartItem(QuickItem.DisplayName, DisplayName.Text, null, Protocol.Text, QuickStartType.Application);
QuickItem.Update(Icon.Source as BitmapImage, Protocol.Text, null, DisplayName.Text);
}
else
{
StorageFile NewFile = await ImageFile.CopyAsync(await ApplicationData.Current.LocalFolder.CreateFolderAsync("QuickStartImage", CreationCollisionOption.OpenIfExists), DisplayName.Text + Path.GetExtension(ImageFile.Path), NameCollisionOption.GenerateUniqueName);
SQLite.Current.UpdateQuickStartItem(QuickItem.DisplayName, DisplayName.Text, $"QuickStartImage\\{NewFile.Name}", Protocol.Text, QuickStartType.Application);
QuickItem.Update(Icon.Source as BitmapImage, Protocol.Text, $"QuickStartImage\\{NewFile.Name}", DisplayName.Text);
}
}
else
{
StorageFile NewFile = await ImageFile.CopyAsync(await ApplicationData.Current.LocalFolder.CreateFolderAsync("QuickStartImage", CreationCollisionOption.OpenIfExists), DisplayName.Text + Path.GetExtension(ImageFile.Path), NameCollisionOption.GenerateUniqueName);
CommonAccessCollection.QuickStartList.Insert(CommonAccessCollection.QuickStartList.Count - 1, new QuickStartItem(QuickStartType.Application, Icon.Source as BitmapImage, Protocol.Text, $"QuickStartImage\\{NewFile.Name}", DisplayName.Text));
SQLite.Current.SetQuickStartItem(DisplayName.Text, $"QuickStartImage\\{NewFile.Name}", Protocol.Text, QuickStartType.Application);
}
}
else
{
using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController())
{
if (await Exclusive.Controller.CheckIfPackageFamilyNameExist(Protocol.Text))
{
if (IsUpdate)
{
if (ImageFile == null)
{
SQLite.Current.UpdateQuickStartItem(QuickItem.DisplayName, DisplayName.Text, null, Protocol.Text, QuickStartType.Application);
QuickItem.Update(Icon.Source as BitmapImage, Protocol.Text, null, DisplayName.Text);
}
else
{
StorageFile NewFile = await ImageFile.CopyAsync(await ApplicationData.Current.LocalFolder.CreateFolderAsync("QuickStartImage", CreationCollisionOption.OpenIfExists), DisplayName.Text + Path.GetExtension(ImageFile.Path), NameCollisionOption.GenerateUniqueName);
SQLite.Current.UpdateQuickStartItem(QuickItem.DisplayName, DisplayName.Text, $"QuickStartImage\\{NewFile.Name}", Protocol.Text, QuickStartType.Application);
QuickItem.Update(Icon.Source as BitmapImage, Protocol.Text, $"QuickStartImage\\{NewFile.Name}", DisplayName.Text);
}
}
else
{
StorageFile NewFile = await ImageFile.CopyAsync(await ApplicationData.Current.LocalFolder.CreateFolderAsync("QuickStartImage", CreationCollisionOption.OpenIfExists), DisplayName.Text + Path.GetExtension(ImageFile.Path), NameCollisionOption.GenerateUniqueName);
CommonAccessCollection.QuickStartList.Insert(CommonAccessCollection.QuickStartList.Count - 1, new QuickStartItem(QuickStartType.Application, Icon.Source as BitmapImage, Protocol.Text, $"QuickStartImage\\{NewFile.Name}", DisplayName.Text));
SQLite.Current.SetQuickStartItem(DisplayName.Text, $"QuickStartImage\\{NewFile.Name}", Protocol.Text, QuickStartType.Application);
}
}
else
{
FormatErrorTip.IsOpen = true;
args.Cancel = true;
}
}
}
break;
}
case QuickStartType.WebSite:
{
if (Uri.TryCreate(Protocol.Text, UriKind.Absolute, out Uri Result) && !Result.IsFile)
{
if (!FileSystemItemNameChecker.IsValid(DisplayName.Text))
{
args.Cancel = true;
InvalidCharTip.IsOpen = true;
Deferral.Complete();
return;
}
if (IsUpdate)
{
if (ImageFile == null)
{
SQLite.Current.UpdateQuickStartItem(QuickItem.DisplayName, DisplayName.Text, null, Protocol.Text, QuickStartType.WebSite);
QuickItem.Update(Icon.Source as BitmapImage, Protocol.Text, null, DisplayName.Text);
}
else
{
StorageFile NewFile = await ImageFile.CopyAsync(await ApplicationData.Current.LocalFolder.CreateFolderAsync("HotWebImage", CreationCollisionOption.OpenIfExists), DisplayName.Text + Path.GetExtension(ImageFile.Path), NameCollisionOption.GenerateUniqueName);
SQLite.Current.UpdateQuickStartItem(QuickItem.DisplayName, DisplayName.Text, $"HotWebImage\\{NewFile.Name}", Protocol.Text, QuickStartType.WebSite);
QuickItem.Update(Icon.Source as BitmapImage, Protocol.Text, $"HotWebImage\\{NewFile.Name}", DisplayName.Text);
}
}
else
{
StorageFile NewFile = await ImageFile.CopyAsync(await ApplicationData.Current.LocalFolder.CreateFolderAsync("HotWebImage", CreationCollisionOption.OpenIfExists), DisplayName.Text + Path.GetExtension(ImageFile.Path), NameCollisionOption.GenerateUniqueName);
CommonAccessCollection.WebLinkList.Insert(CommonAccessCollection.WebLinkList.Count - 1, new QuickStartItem(QuickStartType.WebSite, Icon.Source as BitmapImage, Protocol.Text, $"HotWebImage\\{NewFile.Name}", DisplayName.Text));
SQLite.Current.SetQuickStartItem(DisplayName.Text, $"HotWebImage\\{NewFile.Name}", Protocol.Text, QuickStartType.WebSite);
}
}
else
{
FormatErrorTip.IsOpen = true;
args.Cancel = true;
}
break;
}
}
}
}
catch (Exception ex)
{
LogTracer.Log(ex);
}
finally
{
Deferral.Complete();
}
}
