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 static async Task <string> GenerateUniquePath(string ItemPath, StorageItemTypes Type, IEnumerable <string> ExceptPath)
{
string UniquePath = ItemPath;
switch (Type)
{
case StorageItemTypes.File:
{
string NameWithoutExt = Path.GetFileNameWithoutExtension(ItemPath);
string Extension = Path.GetExtension(ItemPath);
string Directory = Path.GetDirectoryName(ItemPath);
for (ushort Count = 1; await FileSystemStorageItemBase.CheckExistAsync(UniquePath) || ExceptPath.Contains(UniquePath); Count++)
{
if (Regex.IsMatch(NameWithoutExt, @".*\(\d+\)"))
{
UniquePath = Path.Combine(Directory, $"{NameWithoutExt.Substring(0, NameWithoutExt.LastIndexOf("(", StringComparison.InvariantCultureIgnoreCase))}({Count}){Extension}");
}
else
{
UniquePath = Path.Combine(Directory, $"{NameWithoutExt} ({Count}){Extension}");
}
}
break;
}
case StorageItemTypes.Folder:
{
string Directory = Path.GetDirectoryName(ItemPath);
string Name = Path.GetFileName(ItemPath);
for (ushort Count = 1; await FileSystemStorageItemBase.CheckExistAsync(UniquePath) || ExceptPath.Contains(UniquePath); Count++)
{
if (Regex.IsMatch(Name, @".*\(\d+\)"))
{
UniquePath = Path.Combine(Directory, $"{Name.Substring(0, Name.LastIndexOf("(", StringComparison.InvariantCultureIgnoreCase))}({Count})");
}
else
{
UniquePath = Path.Combine(Directory, $"{Name} ({Count})");
}
}
break;
}
default:
{
break;
}
}
return(UniquePath);
}
private async void GetImageAutomatic_Click(object sender, RoutedEventArgs e)
{
if (string.IsNullOrWhiteSpace(Protocol.Text))
{
EmptyTip.Target = Protocol;
EmptyTip.IsOpen = true;
return;
}
switch (Type)
{
case QuickStartType.Application:
{
if (Uri.TryCreate(Protocol.Text, UriKind.Absolute, out Uri Result))
{
if (Result.IsFile)
{
if (await FileSystemStorageItemBase.CheckExistAsync(Protocol.Text))
{
try
{
StorageFile ExecuteFile = await StorageFile.GetFileFromPathAsync(Protocol.Text);
IDictionary <string, object> PropertiesDictionary = await ExecuteFile.Properties.RetrievePropertiesAsync(new string[] { "System.FileDescription" });
string ExtraAppName = string.Empty;
if (PropertiesDictionary.TryGetValue("System.FileDescription", out object DescriptionRaw))
{
ExtraAppName = Convert.ToString(DescriptionRaw);
}
DisplayName.Text = string.IsNullOrEmpty(ExtraAppName) ? ExecuteFile.DisplayName : ExtraAppName;
StorageFile FileThumbnail = await ApplicationData.Current.TemporaryFolder.CreateFileAsync("FileThumbnail.png", CreationCollisionOption.ReplaceExisting);
if (await ExecuteFile.GetThumbnailRawStreamAsync() is IRandomAccessStream ThumbnailStream)
{
BitmapDecoder Decoder = await BitmapDecoder.CreateAsync(ThumbnailStream);
using (SoftwareBitmap SBitmap = await Decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied))
using (SoftwareBitmap ResizeBitmap = ComputerVisionProvider.ResizeToActual(SBitmap))
using (InMemoryRandomAccessStream ResizeBitmapStream = new InMemoryRandomAccessStream())
{
BitmapEncoder Encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, ResizeBitmapStream);
Encoder.SetSoftwareBitmap(ResizeBitmap);
await Encoder.FlushAsync();
BitmapImage Image = new BitmapImage();
Icon.Source = Image;
await Image.SetSourceAsync(ResizeBitmapStream);
ResizeBitmapStream.Seek(0);
using (Stream TransformStream = ResizeBitmapStream.AsStreamForRead())
using (Stream FileStream = await FileThumbnail.OpenStreamForWriteAsync())
{
await TransformStream.CopyToAsync(FileStream);
}
}
}
else
{
Uri PageUri = AppThemeController.Current.Theme == ElementTheme.Dark ? new Uri("ms-appx:///Assets/Page_Solid_White.png") : new Uri("ms-appx:///Assets/Page_Solid_Black.png");
StorageFile PageFile = await StorageFile.GetFileFromApplicationUriAsync(PageUri);
using (IRandomAccessStream PageStream = await PageFile.OpenAsync(FileAccessMode.Read))
{
BitmapImage Image = new BitmapImage();
Icon.Source = Image;
await Image.SetSourceAsync(PageStream);
PageStream.Seek(0);
using (Stream TransformStream = PageStream.AsStreamForRead())
using (Stream FileStream = await FileThumbnail.OpenStreamForWriteAsync())
{
await TransformStream.CopyToAsync(FileStream);
}
}
}
ImageFile = FileThumbnail;
}
catch
{
FailureTips.IsOpen = true;
}
}
else
{
FailureTips.IsOpen = true;
}
}
else
{
if ((await Launcher.FindUriSchemeHandlersAsync(Result.Scheme)).FirstOrDefault() is AppInfo App)
{
DisplayName.Text = App.DisplayInfo.DisplayName;
StorageFile FileThumbnail = await ApplicationData.Current.TemporaryFolder.CreateFileAsync("FileThumbnail.png", CreationCollisionOption.ReplaceExisting);
try
{
using (IRandomAccessStreamWithContentType LogoStream = await App.DisplayInfo.GetLogo(new Windows.Foundation.Size(120, 120)).OpenReadAsync())
{
BitmapDecoder Decoder = await BitmapDecoder.CreateAsync(LogoStream);
using (SoftwareBitmap SBitmap = await Decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied))
using (SoftwareBitmap ResizeBitmap = ComputerVisionProvider.ResizeToActual(SBitmap))
using (InMemoryRandomAccessStream ResizeBitmapStream = new InMemoryRandomAccessStream())
{
BitmapEncoder Encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, ResizeBitmapStream);
Encoder.SetSoftwareBitmap(ResizeBitmap);
await Encoder.FlushAsync();
BitmapImage Source = new BitmapImage();
Icon.Source = Source;
await Source.SetSourceAsync(ResizeBitmapStream);
ResizeBitmapStream.Seek(0);
using (Stream FileStream = await FileThumbnail.OpenStreamForWriteAsync())
{
await ResizeBitmapStream.AsStreamForRead().CopyToAsync(FileStream);
}
}
}
}
catch
{
Uri PageUri = AppThemeController.Current.Theme == ElementTheme.Dark ? new Uri("ms-appx:///Assets/Page_Solid_White.png") : new Uri("ms-appx:///Assets/Page_Solid_Black.png");
StorageFile PageFile = await StorageFile.GetFileFromApplicationUriAsync(PageUri);
using (IRandomAccessStream PageStream = await PageFile.OpenAsync(FileAccessMode.Read))
{
BitmapImage Image = new BitmapImage();
Icon.Source = Image;
await Image.SetSourceAsync(PageStream);
PageStream.Seek(0);
using (Stream TransformStream = PageStream.AsStreamForRead())
using (Stream FileStream = await FileThumbnail.OpenStreamForWriteAsync())
{
await TransformStream.CopyToAsync(FileStream);
}
}
}
ImageFile = FileThumbnail;
}
else
{
FormatErrorTip.IsOpen = true;
}
}
}
else
{
using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController())
{
if (await Exclusive.Controller.GetInstalledApplicationAsync(Protocol.Text) is InstalledApplication Pack)
{
StorageFile FileThumbnail = await ApplicationData.Current.TemporaryFolder.CreateFileAsync("FileThumbnail.png", CreationCollisionOption.ReplaceExisting);
if (Pack.CreateStreamFromLogoData() is Stream LogoStream)
{
try
{
BitmapDecoder Decoder = await BitmapDecoder.CreateAsync(LogoStream.AsRandomAccessStream());
using (SoftwareBitmap SBitmap = await Decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied))
using (SoftwareBitmap ResizeBitmap = ComputerVisionProvider.ResizeToActual(SBitmap))
using (InMemoryRandomAccessStream ResizeBitmapStream = new InMemoryRandomAccessStream())
{
BitmapEncoder Encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, ResizeBitmapStream);
Encoder.SetSoftwareBitmap(ResizeBitmap);
await Encoder.FlushAsync();
BitmapImage Image = new BitmapImage();
Icon.Source = Image;
await Image.SetSourceAsync(ResizeBitmapStream);
ResizeBitmapStream.Seek(0);
using (Stream FileStream = await FileThumbnail.OpenStreamForWriteAsync())
{
await ResizeBitmapStream.AsStreamForRead().CopyToAsync(FileStream);
}
}
}
catch
{
Uri PageUri = AppThemeController.Current.Theme == ElementTheme.Dark ? new Uri("ms-appx:///Assets/Page_Solid_White.png") : new Uri("ms-appx:///Assets/Page_Solid_Black.png");
StorageFile PageFile = await StorageFile.GetFileFromApplicationUriAsync(PageUri);
using (IRandomAccessStream PageStream = await PageFile.OpenAsync(FileAccessMode.Read))
{
BitmapImage Image = new BitmapImage();
Icon.Source = Image;
await Image.SetSourceAsync(PageStream);
PageStream.Seek(0);
using (Stream TransformStream = PageStream.AsStreamForRead())
using (Stream FileStream = await FileThumbnail.OpenStreamForWriteAsync())
{
await TransformStream.CopyToAsync(FileStream);
}
}
}
finally
{
LogoStream.Dispose();
}
}
else
{
Uri PageUri = AppThemeController.Current.Theme == ElementTheme.Dark ? new Uri("ms-appx:///Assets/Page_Solid_White.png") : new Uri("ms-appx:///Assets/Page_Solid_Black.png");
StorageFile PageFile = await StorageFile.GetFileFromApplicationUriAsync(PageUri);
using (IRandomAccessStream PageStream = await PageFile.OpenAsync(FileAccessMode.Read))
{
BitmapImage Image = new BitmapImage();
Icon.Source = Image;
await Image.SetSourceAsync(PageStream);
PageStream.Seek(0);
using (Stream TransformStream = PageStream.AsStreamForRead())
using (Stream FileStream = await FileThumbnail.OpenStreamForWriteAsync())
{
await TransformStream.CopyToAsync(FileStream);
}
}
}
ImageFile = FileThumbnail;
}
else
{
FormatErrorTip.IsOpen = true;
}
}
}
break;
}
case QuickStartType.WebSite:
{
try
{
if (Uri.TryCreate(Protocol.Text, UriKind.Absolute, out Uri Result))
{
Uri ImageUri = new Uri($"{Result.Scheme}://{Result.Host}/favicon.ico");
HttpWebRequest Request = WebRequest.CreateHttp(ImageUri);
using (WebResponse Response = await Request.GetResponseAsync())
using (Stream WebImageStream = Response.GetResponseStream())
using (MemoryStream TemplateStream = new MemoryStream())
{
await WebImageStream.CopyToAsync(TemplateStream);
TemplateStream.Seek(0, SeekOrigin.Begin);
if (TemplateStream.Length > 0)
{
BitmapImage Bitmap = new BitmapImage();
Icon.Source = Bitmap;
await Bitmap.SetSourceAsync(TemplateStream.AsRandomAccessStream());
TemplateStream.Seek(0, SeekOrigin.Begin);
StorageFile DownloadImage = await ApplicationData.Current.TemporaryFolder.CreateFileAsync("DownloadFile.ico", CreationCollisionOption.ReplaceExisting);
using (Stream LocalFileStream = await DownloadImage.OpenStreamForWriteAsync())
{
await TemplateStream.CopyToAsync(LocalFileStream);
}
ImageFile = DownloadImage;
}
else
{
FailureTips.IsOpen = true;
}
}
}
else
{
FailureTips.IsOpen = true;
}
}
catch
{
try
{
Uri QueryUrl1 = new Uri($"http://statics.dnspod.cn/proxy_favicon/_/favicon?domain={new Uri(Protocol.Text).Host}");
Uri QueryUrl2 = new Uri($"http://www.google.com/s2/favicons?domain={new Uri(Protocol.Text).Host}");
WebResponse Response;
HttpWebRequest Request;
if (Globalization.CurrentLanguage == LanguageEnum.Chinese_Simplified)
{
Request = WebRequest.CreateHttp(QueryUrl1);
Response = await Request.GetResponseAsync();
}
else
{
try
{
Request = WebRequest.CreateHttp(QueryUrl2);
Response = await Request.GetResponseAsync();
}
catch
{
Request = WebRequest.CreateHttp(QueryUrl1);
Response = await Request.GetResponseAsync();
}
}
try
{
using (Stream WebImageStream = Response.GetResponseStream())
using (MemoryStream TemplateStream = new MemoryStream())
{
await WebImageStream.CopyToAsync(TemplateStream);
TemplateStream.Seek(0, SeekOrigin.Begin);
if (TemplateStream.Length > 0)
{
BitmapImage Bitmap = new BitmapImage();
Icon.Source = Bitmap;
await Bitmap.SetSourceAsync(TemplateStream.AsRandomAccessStream());
TemplateStream.Seek(0, SeekOrigin.Begin);
StorageFile DownloadImage = await ApplicationData.Current.TemporaryFolder.CreateFileAsync("DownloadFile.ico", CreationCollisionOption.ReplaceExisting);
using (Stream LocalFileStream = await DownloadImage.OpenStreamForWriteAsync())
{
await TemplateStream.CopyToAsync(LocalFileStream);
}
ImageFile = DownloadImage;
}
else
{
FailureTips.IsOpen = true;
}
}
}
finally
{
Response?.Dispose();
}
}
catch
{
FailureTips.IsOpen = true;
}
}
break;
}
}
}
private async void QuickStartGridView_ItemClick(object sender, ItemClickEventArgs e)
{
if (e.ClickedItem is QuickStartItem Item)
{
if ((sender as GridView).Name == nameof(QuickStartGridView))
{
if (Uri.TryCreate(Item.Protocol, UriKind.Absolute, out Uri Ur))
{
if (Ur.IsFile)
{
if (await FileSystemStorageItemBase.CheckExistAsync(Item.Protocol))
{
using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController())
{
try
{
if (Path.GetExtension(Item.Protocol).ToLower() == ".msc")
{
await Exclusive.Controller.RunAsync("powershell.exe", string.Empty, WindowState.Normal, false, true, false, "-Command", Item.Protocol);
}
else
{
await Exclusive.Controller.RunAsync(Item.Protocol, Path.GetDirectoryName(Item.Protocol));
}
}
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();
}
}
else
{
await Launcher.LaunchUriAsync(Ur);
}
}
else
{
using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController())
{
if (!await Exclusive.Controller.LaunchUWPLnkAsync(Item.Protocol))
{
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
{
await Launcher.LaunchUriAsync(new Uri(Item.Protocol));
}
}
}
protected override async void OnLaunched(LaunchActivatedEventArgs e)
{
Microsoft.Toolkit.Uwp.Helpers.SystemInformation.Instance.TrackAppUse(e);
ApplicationViewTitleBar TitleBar = ApplicationView.GetForCurrentView().TitleBar;
TitleBar.ButtonBackgroundColor = Colors.Transparent;
TitleBar.ButtonInactiveBackgroundColor = Colors.Transparent;
CoreApplication.GetCurrentView().TitleBar.ExtendViewIntoTitleBar = true;
if (Window.Current.Content is Frame frame)
{
if (frame.Content is MainPage Main && Main.Nav.Content is TabViewContainer TabContainer)
{
if (!string.IsNullOrWhiteSpace(e.Arguments) && await FileSystemStorageItemBase.CheckExistAsync(e.Arguments))
{
await TabContainer.CreateNewTabAsync(e.Arguments);
}
else
{
await TabContainer.CreateNewTabAsync();
}
}
}
else
{
if (!string.IsNullOrWhiteSpace(e.Arguments) && await FileSystemStorageItemBase.CheckExistAsync(e.Arguments))
{
ExtendedSplash extendedSplash = new ExtendedSplash(e.SplashScreen, new List <string[]> {
new string[] { e.Arguments }
});
Window.Current.Content = extendedSplash;
}
else
{
StartupMode Mode = StartupModeController.GetStartupMode();
switch (Mode)
{
case StartupMode.CreateNewTab:
{
ExtendedSplash extendedSplash = new ExtendedSplash(e.SplashScreen);
Window.Current.Content = extendedSplash;
break;
}
case StartupMode.LastOpenedTab:
{
List <string[]> LastOpenedPathArray = await StartupModeController.GetAllPathAsync(Mode).ToListAsync();
StartupModeController.Clear(StartupMode.LastOpenedTab);
if (LastOpenedPathArray.Count == 0)
{
ExtendedSplash extendedSplash = new ExtendedSplash(e.SplashScreen);
Window.Current.Content = extendedSplash;
}
else
{
ExtendedSplash extendedSplash = new ExtendedSplash(e.SplashScreen, LastOpenedPathArray);
Window.Current.Content = extendedSplash;
}
break;
}
case StartupMode.SpecificTab:
{
string[] SpecificPathArray = await StartupModeController.GetAllPathAsync(Mode).Select((Item) => Item.FirstOrDefault()).OfType <string>().ToArrayAsync();
if (SpecificPathArray.Length == 0)
{
ExtendedSplash extendedSplash = new ExtendedSplash(e.SplashScreen);
Window.Current.Content = extendedSplash;
}
else
{
ExtendedSplash extendedSplash = new ExtendedSplash(e.SplashScreen, SpecificPathArray);
Window.Current.Content = extendedSplash;
}
break;
}
}
}
}
Window.Current.Activate();
}
private async void ProgramPickerDialog_Loading(FrameworkElement sender, object args)
{
LoadingText.Visibility = Visibility.Visible;
WholeArea.Visibility = Visibility.Collapsed;
List <ProgramPickerItem> RecommandList = new List <ProgramPickerItem>();
try
{
using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController())
{
List <AssociationPackage> AssocList = await Exclusive.Controller.GetAssociateFromPathAsync(OpenFile.Path).ConfigureAwait(true);
List <AppInfo> AppInfoList = (await Launcher.FindFileHandlersAsync(OpenFile.Type)).ToList();
await SQLite.Current.UpdateProgramPickerRecordAsync(OpenFile.Type, AssocList.Concat(AppInfoList.Select((Info) => new AssociationPackage(OpenFile.Type, Info.PackageFamilyName, true)))).ConfigureAwait(true);
foreach (AppInfo Info in AppInfoList)
{
try
{
using (IRandomAccessStreamWithContentType LogoStream = await Info.DisplayInfo.GetLogo(new Windows.Foundation.Size(128, 128)).OpenReadAsync())
{
BitmapDecoder Decoder = await BitmapDecoder.CreateAsync(LogoStream);
using (SoftwareBitmap SBitmap = await Decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied))
using (SoftwareBitmap ResizeBitmap = ComputerVisionProvider.ResizeToActual(SBitmap))
using (InMemoryRandomAccessStream Stream = new InMemoryRandomAccessStream())
{
BitmapEncoder Encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, Stream);
Encoder.SetSoftwareBitmap(ResizeBitmap);
await Encoder.FlushAsync();
BitmapImage Image = new BitmapImage();
await Image.SetSourceAsync(Stream);
RecommandList.Add(new ProgramPickerItem(Image, Info.DisplayInfo.DisplayName, Info.DisplayInfo.Description, Info.PackageFamilyName));
}
}
}
catch (Exception ex)
{
LogTracer.Log(ex, "An exception was threw when getting or processing App Logo");
}
}
}
}
catch (Exception ex)
{
LogTracer.Log(ex, "An exception was threw when fetching association data");
}
foreach (AssociationPackage Package in await SQLite.Current.GetProgramPickerRecordAsync(OpenFile.Type, false).ConfigureAwait(true))
{
try
{
if (await FileSystemStorageItemBase.CheckExistAsync(Package.ExecutablePath).ConfigureAwait(true))
{
StorageFile ExecuteFile = await StorageFile.GetFileFromPathAsync(Package.ExecutablePath);
IDictionary <string, object> PropertiesDictionary = await ExecuteFile.Properties.RetrievePropertiesAsync(new string[] { "System.FileDescription" });
string ExtraAppName = string.Empty;
if (PropertiesDictionary.TryGetValue("System.FileDescription", out object DescriptionRaw))
{
ExtraAppName = Convert.ToString(DescriptionRaw);
}
if (await ExecuteFile.GetThumbnailRawStreamAsync().ConfigureAwait(true) is IRandomAccessStream ThumbnailStream)
{
using (ThumbnailStream)
{
BitmapDecoder Decoder = await BitmapDecoder.CreateAsync(ThumbnailStream);
using (SoftwareBitmap SBitmap = await Decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied))
using (SoftwareBitmap ResizeBitmap = ComputerVisionProvider.ResizeToActual(SBitmap))
using (InMemoryRandomAccessStream ResizeBitmapStream = new InMemoryRandomAccessStream())
{
BitmapEncoder Encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, ResizeBitmapStream);
Encoder.SetSoftwareBitmap(ResizeBitmap);
await Encoder.FlushAsync();
BitmapImage ThumbnailBitmap = new BitmapImage();
await ThumbnailBitmap.SetSourceAsync(ResizeBitmapStream);
if (Package.IsRecommanded)
{
RecommandList.Add(new ProgramPickerItem(ThumbnailBitmap, string.IsNullOrEmpty(ExtraAppName) ? ExecuteFile.DisplayName : ExtraAppName, Globalization.GetString("Application_Admin_Name"), ExecuteFile.Path));
}
else
{
NotRecommandList.Add(new ProgramPickerItem(ThumbnailBitmap, string.IsNullOrEmpty(ExtraAppName) ? ExecuteFile.DisplayName : ExtraAppName, Globalization.GetString("Application_Admin_Name"), ExecuteFile.Path));
}
}
}
}
else
{
if (Package.IsRecommanded)
{
RecommandList.Add(new ProgramPickerItem(new BitmapImage(AppThemeController.Current.Theme == ElementTheme.Dark ? new Uri("ms-appx:///Assets/Page_Solid_White.png") : new Uri("ms-appx:///Assets/Page_Solid_Black.png")), string.IsNullOrEmpty(ExtraAppName) ? ExecuteFile.DisplayName : ExtraAppName, Globalization.GetString("Application_Admin_Name"), ExecuteFile.Path));
}
else
{
NotRecommandList.Add(new ProgramPickerItem(new BitmapImage(AppThemeController.Current.Theme == ElementTheme.Dark ? new Uri("ms-appx:///Assets/Page_Solid_White.png") : new Uri("ms-appx:///Assets/Page_Solid_Black.png")), string.IsNullOrEmpty(ExtraAppName) ? ExecuteFile.DisplayName : ExtraAppName, Globalization.GetString("Application_Admin_Name"), ExecuteFile.Path));
}
}
}
else
{
await SQLite.Current.DeleteProgramPickerRecordAsync(Package).ConfigureAwait(true);
}
}
catch (Exception ex)
{
LogTracer.Log(ex, "An exception was threw trying add to ApplicationList");
}
}
string AdminExecutablePath = await SQLite.Current.GetDefaultProgramPickerRecordAsync(OpenFile.Type).ConfigureAwait(true);
if (!string.IsNullOrEmpty(AdminExecutablePath))
{
if (RecommandList.FirstOrDefault((Item) => Item.Path.Equals(AdminExecutablePath, StringComparison.OrdinalIgnoreCase)) is ProgramPickerItem RecommandItem)
{
CurrentUseProgramList.Items.Add(RecommandItem);
CurrentUseProgramList.SelectedIndex = 0;
RecommandList.Remove(RecommandItem);
}
else if (NotRecommandList.FirstOrDefault((Item) => Item.Path.Equals(AdminExecutablePath, StringComparison.OrdinalIgnoreCase)) is ProgramPickerItem NotRecommandItem)
{
CurrentUseProgramList.Items.Add(NotRecommandItem);
CurrentUseProgramList.SelectedIndex = 0;
NotRecommandList.Remove(NotRecommandItem);
}
}
if (CurrentUseProgramList.Items.Count == 0)
{
switch (OpenFile.Type.ToLower())
{
case ".jpg":
case ".png":
case ".bmp":
case ".heic":
case ".gif":
case ".tiff":
case ".mkv":
case ".mp4":
case ".mp3":
case ".flac":
case ".wma":
case ".wmv":
case ".m4a":
case ".mov":
case ".alac":
case ".txt":
case ".pdf":
case ".exe":
{
Area1.Visibility = Visibility.Visible;
CurrentUseProgramList.Visibility = Visibility.Visible;
Title1.Text = Globalization.GetString("ProgramPicker_Dialog_Title_1");
Title2.Text = Globalization.GetString("ProgramPicker_Dialog_Title_2");
CurrentUseProgramList.Items.Add(new ProgramPickerItem(new BitmapImage(new Uri("ms-appx:///Assets/RX-icon.png")), Globalization.GetString("ProgramPicker_Dialog_BuiltInViewer"), Globalization.GetString("ProgramPicker_Dialog_BuiltInViewer_Description"), Package.Current.Id.FamilyName));
CurrentUseProgramList.SelectedIndex = 0;
break;
}
default:
{
Area1.Visibility = Visibility.Collapsed;
CurrentUseProgramList.Visibility = Visibility.Collapsed;
Title2.Text = Globalization.GetString("ProgramPicker_Dialog_Title_2");
break;
}
}
}
else
{
Area1.Visibility = Visibility.Visible;
CurrentUseProgramList.Visibility = Visibility.Visible;
Title1.Text = Globalization.GetString("ProgramPicker_Dialog_Title_1");
Title2.Text = Globalization.GetString("ProgramPicker_Dialog_Title_2");
switch (OpenFile.Type.ToLower())
{
case ".jpg":
case ".png":
case ".bmp":
case ".heic":
case ".gif":
case ".tiff":
case ".mkv":
case ".mp4":
case ".mp3":
case ".flac":
case ".wma":
case ".wmv":
case ".m4a":
case ".mov":
case ".alac":
case ".txt":
case ".pdf":
case ".exe":
{
ProgramCollection.Add(new ProgramPickerItem(new BitmapImage(new Uri("ms-appx:///Assets/RX-icon.png")), Globalization.GetString("ProgramPicker_Dialog_BuiltInViewer"), Globalization.GetString("ProgramPicker_Dialog_BuiltInViewer_Description"), Package.Current.Id.FamilyName));
break;
}
}
}
if (RecommandList.Count == 0)
{
ShowMore.Visibility = Visibility.Collapsed;
foreach (ProgramPickerItem Item in NotRecommandList)
{
ProgramCollection.Add(Item);
}
OtherProgramList.MaxHeight = 300;
}
else
{
foreach (ProgramPickerItem Item in RecommandList)
{
ProgramCollection.Add(Item);
}
}
if (CurrentUseProgramList.SelectedIndex == -1)
{
OtherProgramList.SelectedIndex = 0;
}
LoadingText.Visibility = Visibility.Collapsed;
WholeArea.Visibility = Visibility.Visible;
}
private async Task LaunchSelectedItem(FileSystemStorageItemBase Item)
{
try
{
switch (Item)
{
case FileSystemStorageFile File:
{
if (!await FileSystemStorageItemBase.CheckExistAsync(File.Path))
{
QueueContentDialog Dialog = new QueueContentDialog
{
Title = Globalization.GetString("Common_Dialog_ErrorTitle"),
Content = Globalization.GetString("QueueDialog_LocateFileFailure_Content"),
CloseButtonText = Globalization.GetString("Common_Dialog_CloseButton")
};
_ = await Dialog.ShowAsync();
return;
}
switch (File.Type.ToLower())
{
case ".exe":
case ".bat":
case ".msi":
{
using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController())
{
if (!await Exclusive.Controller.RunAsync(File.Path, Path.GetDirectoryName(File.Path)))
{
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();
}
}
break;
}
case ".msc":
{
using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController())
{
if (!await Exclusive.Controller.RunAsync("powershell.exe", string.Empty, WindowState.Normal, false, true, false, "-Command", File.Path))
{
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();
}
}
break;
}
case ".lnk":
{
if (File is LinkStorageFile LinkItem)
{
if (LinkItem.LinkType == ShellLinkType.Normal)
{
switch (await FileSystemStorageItemBase.OpenAsync(LinkItem.LinkTargetPath))
{
case FileSystemStorageFolder:
{
if (WeakToFileControl.TryGetTarget(out FileControl Control))
{
Frame.GoBack();
await Control.CurrentPresenter.DisplayItemsInFolder(LinkItem.LinkTargetPath);
await JumpListController.Current.AddItemAsync(JumpListGroup.Recent, LinkItem.LinkTargetPath);
if (Control.CurrentPresenter.FileCollection.FirstOrDefault((SItem) => SItem == LinkItem) is FileSystemStorageItemBase Target)
{
Control.CurrentPresenter.ItemPresenter.ScrollIntoView(Target);
Control.CurrentPresenter.SelectedItem = Target;
}
}
break;
}
case FileSystemStorageFile:
{
await LinkItem.LaunchAsync();
break;
}
}
}
else
{
await LinkItem.LaunchAsync();
}
}
break;
}
case ".url":
{
if (File is UrlStorageFile UrlItem)
{
await UrlItem.LaunchAsync();
}
break;
}
default:
{
string AdminExecutablePath = await SQLite.Current.GetDefaultProgramPickerRecordAsync(File.Type);
if (string.IsNullOrEmpty(AdminExecutablePath) || AdminExecutablePath == Package.Current.Id.FamilyName)
{
if (!TryOpenInternally(File))
{
if (await File.GetStorageItemAsync() is StorageFile SFile)
{
if (!await Launcher.LaunchFileAsync(SFile))
{
using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController())
{
if (!await Exclusive.Controller.RunAsync(File.Path))
{
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
{
using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController())
{
if (!await Exclusive.Controller.RunAsync(File.Path))
{
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 (Path.IsPathRooted(AdminExecutablePath))
{
using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController())
{
if (!await Exclusive.Controller.RunAsync(AdminExecutablePath, Path.GetDirectoryName(AdminExecutablePath), Parameters: File.Path))
{
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 Launcher.FindFileHandlersAsync(File.Type)).FirstOrDefault((Item) => Item.PackageFamilyName == AdminExecutablePath) is AppInfo Info)
{
if (await File.GetStorageItemAsync() is StorageFile InnerFile)
{
if (!await Launcher.LaunchFileAsync(InnerFile, new LauncherOptions {
TargetApplicationPackageFamilyName = Info.PackageFamilyName, DisplayApplicationPicker = false
}))
{
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
{
QueueContentDialog Dialog = new QueueContentDialog
{
Title = Globalization.GetString("Common_Dialog_ErrorTitle"),
Content = Globalization.GetString("QueueDialog_UnableAccessFile_Content"),
CloseButtonText = Globalization.GetString("Common_Dialog_CloseButton")
};
_ = await Dialog.ShowAsync();
}
}
}
}
break;
}
}
break;
}
case FileSystemStorageFolder Folder:
{
if (await FileSystemStorageItemBase.CheckExistAsync(Folder.Path))
{
if (WeakToFileControl.TryGetTarget(out FileControl Control))
{
Frame.GoBack();
await Control.CurrentPresenter.DisplayItemsInFolder(Folder);
await JumpListController.Current.AddItemAsync(JumpListGroup.Recent, Folder.Path);
if (Control.CurrentPresenter.FileCollection.FirstOrDefault((SItem) => SItem == Folder) is FileSystemStorageItemBase Target)
{
Control.CurrentPresenter.ItemPresenter.ScrollIntoView(Target);
Control.CurrentPresenter.SelectedItem = Target;
}
}
}
else
{
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();
}
break;
}
}
}
catch (Exception ex)
{
LogTracer.Log(ex, $"An error was threw in {nameof(LaunchSelectedItem)}");
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();
}
}
private async Task OnLaunchOrOnActivate(IActivatedEventArgs args)
{
SystemInformation.Instance.TrackAppUse(args);
ApplicationViewTitleBar TitleBar = ApplicationView.GetForCurrentView().TitleBar;
TitleBar.ButtonBackgroundColor = Colors.Transparent;
TitleBar.ButtonInactiveBackgroundColor = Colors.Transparent;
TitleBar.ButtonForegroundColor = AppThemeController.Current.Theme == ElementTheme.Dark ? Colors.White : Colors.Black;
CoreApplication.GetCurrentView().TitleBar.ExtendViewIntoTitleBar = true;
switch (args)
{
case LaunchActivatedEventArgs LaunchArgs:
{
if (Window.Current.Content is Frame frame)
{
if (frame.Content is MainPage Main && Main.Nav.Content is TabViewContainer TabContainer)
{
if (!string.IsNullOrWhiteSpace(LaunchArgs.Arguments) && await FileSystemStorageItemBase.CheckExistAsync(LaunchArgs.Arguments))
{
await TabContainer.CreateNewTabAsync(LaunchArgs.Arguments);
}
else
{
await TabContainer.CreateNewTabAsync();
}
}
}
else
{
if (string.IsNullOrWhiteSpace(LaunchArgs.Arguments) || !await FileSystemStorageItemBase.CheckExistAsync(LaunchArgs.Arguments))
{
await LaunchWithStartupMode(LaunchArgs);
}
else
{
ExtendedSplash extendedSplash = new ExtendedSplash(LaunchArgs.SplashScreen, new List <string[]> {
new string[] { LaunchArgs.Arguments }
});
Window.Current.Content = extendedSplash;
}
}
break;
}
case CommandLineActivatedEventArgs CmdArgs:
{
string[] Arguments = CmdArgs.Operation.Arguments.Split(" ", StringSplitOptions.RemoveEmptyEntries);
if (Window.Current.Content is Frame frame)
{
if (frame.Content is MainPage Main && Main.Nav.Content is TabViewContainer TabContainer)
{
if (Arguments.Length > 1)
{
string Path = string.Join(" ", Arguments.Skip(1));
if (string.IsNullOrWhiteSpace(Path) || Regex.IsMatch(Path, @"::\{[0-9A-F\-]+\}", RegexOptions.IgnoreCase))
{
await TabContainer.CreateNewTabAsync();
}
else
{
await TabContainer.CreateNewTabAsync(Path == "."?CmdArgs.Operation.CurrentDirectoryPath : Path);
}
}
else
{
await TabContainer.CreateNewTabAsync();
}
}
}
else
{
string Path = string.Join(" ", Arguments.Skip(1));
if (Arguments.Length > 1)
{
if (string.IsNullOrWhiteSpace(Path) || Regex.IsMatch(Path, @"::\{[0-9A-F\-]+\}", RegexOptions.IgnoreCase))
{
await LaunchWithStartupMode(CmdArgs);
}
else
{
ExtendedSplash extendedSplash = new ExtendedSplash(CmdArgs.SplashScreen, new List <string[]> {
new string[] { Path == "." ? CmdArgs.Operation.CurrentDirectoryPath : Path }
});
Window.Current.Content = extendedSplash;
}
}
else
{
await LaunchWithStartupMode(CmdArgs);
}
}
break;
}
case ProtocolActivatedEventArgs ProtocalArgs:
{
if (!string.IsNullOrWhiteSpace(ProtocalArgs.Uri.AbsolutePath))
{
ExtendedSplash extendedSplash = new ExtendedSplash(ProtocalArgs.SplashScreen, new List <string[]> {
Uri.UnescapeDataString(ProtocalArgs.Uri.AbsolutePath).Split("||", StringSplitOptions.RemoveEmptyEntries)
});
Window.Current.Content = extendedSplash;
}
else
{
ExtendedSplash extendedSplash = new ExtendedSplash(ProtocalArgs.SplashScreen);
Window.Current.Content = extendedSplash;
}
break;
}
case not ToastNotificationActivatedEventArgs:
{
ExtendedSplash extendedSplash = new ExtendedSplash(args.SplashScreen);
Window.Current.Content = extendedSplash;
break;
}
}
Window.Current.Activate();
}
