private void QueueContentDialog_PrimaryButtonClick(ContentDialog sender, ContentDialogButtonClickEventArgs args)
        {
            bool IsNameEmpty      = string.IsNullOrWhiteSpace(NewFileNameTextBox.Text);
            bool IsExtensionEmpty = string.IsNullOrWhiteSpace(Extension.Text);

            if (IsNameEmpty && IsExtensionEmpty)
            {
                args.Cancel            = true;
                InvalidNameTip.IsOpen  = true;
                InvalidInputTip.IsOpen = true;
            }
            else
            {
                if (!IsNameEmpty && !FileSystemItemNameChecker.IsValid(NewFileNameTextBox.Text))
                {
                    args.Cancel           = true;
                    InvalidNameTip.IsOpen = true;
                }
                else
                {
                    if (IsExtensionEmpty)
                    {
                        NewFileName = NewFileNameTextBox.Text;
                    }
                    else
                    {
                        NewFileName = NewFileNameTextBox.Text + Regex.Match(Extension.SelectedItem.ToString(), @"\.\w+").Value;
                    }
                }
            }
        }
Example #2
0
 private void QueueContentDialog_PrimaryButtonClick(ContentDialog sender, ContentDialogButtonClickEventArgs args)
 {
     if (!FileSystemItemNameChecker.IsValid(RenameText.Text))
     {
         args.Cancel           = true;
         InvalidNameTip.IsOpen = true;
     }
 }
Example #3
0
 private void QueueContentDialog_PrimaryButtonClick(ContentDialog sender, ContentDialogButtonClickEventArgs args)
 {
     if (!FileSystemItemNameChecker.IsValid(RenameText.Text))
     {
         args.Cancel           = true;
         InvalidNameTip.IsOpen = true;
     }
     else if (string.IsNullOrWhiteSpace(RenameText.Text))
     {
         args.Cancel           = true;
         InvalidCharTip.IsOpen = true;
     }
     else
     {
         DesireName = RenameText.Text;
     }
 }
        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();
            }
        }
        private async void QueueContentDialog_PrimaryButtonClick(ContentDialog sender, ContentDialogButtonClickEventArgs args)
        {
            ContentDialogButtonClickDeferral Deferral = args.GetDeferral();

            if ((Type == QuickStartType.Application && CommonAccessCollection.QuickStartList.Any((Item) => Item.DisplayName == DisplayName.Text)) ||
                (Type == QuickStartType.WebSite && CommonAccessCollection.HotWebList.Any((Item) => Item.DisplayName == DisplayName.Text)))
            {
                ExistTip.IsOpen = true;
                args.Cancel     = true;
            }
            else if (Icon.Source == null)
            {
                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 Uri _))
                    {
                        string      ImageName = DisplayName.Text + Path.GetExtension(ImageFile.Path);
                        StorageFile NewFile   = await ImageFile.CopyAsync(await ApplicationData.Current.LocalFolder.CreateFolderAsync("QuickStartImage", CreationCollisionOption.OpenIfExists), ImageName, NameCollisionOption.GenerateUniqueName);

                        CommonAccessCollection.QuickStartList.Insert(CommonAccessCollection.QuickStartList.Count - 1, new QuickStartItem(Icon.Source as BitmapImage, Protocol.Text, QuickStartType.Application, $"QuickStartImage\\{NewFile.Name}", DisplayName.Text));
                        await SQLite.Current.SetQuickStartItemAsync(DisplayName.Text, $"QuickStartImage\\{NewFile.Name}", Protocol.Text, QuickStartType.Application).ConfigureAwait(true);
                    }
                    else
                    {
                        FormatErrorTip.IsOpen = true;
                        args.Cancel           = true;
                    }

                    break;
                }

                case QuickStartType.WebSite:
                {
                    if (Uri.TryCreate(Protocol.Text, UriKind.Absolute, out Uri _))
                    {
                        string      ImageName = DisplayName.Text + Path.GetExtension(ImageFile.Path);
                        StorageFile NewFile   = await ImageFile.CopyAsync(await ApplicationData.Current.LocalFolder.CreateFolderAsync("HotWebImage", CreationCollisionOption.OpenIfExists), ImageName, NameCollisionOption.GenerateUniqueName);

                        CommonAccessCollection.HotWebList.Insert(CommonAccessCollection.HotWebList.Count - 1, new QuickStartItem(Icon.Source as BitmapImage, Protocol.Text, QuickStartType.WebSite, $"HotWebImage\\{NewFile.Name}", DisplayName.Text));
                        await SQLite.Current.SetQuickStartItemAsync(DisplayName.Text, $"HotWebImage\\{NewFile.Name}", Protocol.Text, QuickStartType.WebSite).ConfigureAwait(true);
                    }
                    else
                    {
                        FormatErrorTip.IsOpen = true;
                        args.Cancel           = true;
                    }

                    break;
                }

                case QuickStartType.UpdateApp:
                {
                    if (Uri.TryCreate(Protocol.Text, UriKind.Absolute, out Uri _))
                    {
                        if (!FileSystemItemNameChecker.IsValid(DisplayName.Text))
                        {
                            args.Cancel           = true;
                            InvalidCharTip.IsOpen = true;
                            Deferral.Complete();
                            return;
                        }

                        if (ImageFile != null)
                        {
                            string      ImageName = DisplayName.Text + Path.GetExtension(ImageFile.Path);
                            StorageFile NewFile   = await ImageFile.CopyAsync(await ApplicationData.Current.LocalFolder.CreateFolderAsync("QuickStartImage", CreationCollisionOption.OpenIfExists), ImageName, NameCollisionOption.GenerateUniqueName);

                            await SQLite.Current.UpdateQuickStartItemAsync(QuickItem.DisplayName, DisplayName.Text, $"QuickStartImage\\{NewFile.Name}", Protocol.Text, QuickStartType.Application).ConfigureAwait(true);

                            QuickItem.Update(Icon.Source as BitmapImage, Protocol.Text, $"QuickStartImage\\{NewFile.Name}", DisplayName.Text);
                        }
                        else
                        {
                            await SQLite.Current.UpdateQuickStartItemAsync(QuickItem.DisplayName, DisplayName.Text, null, Protocol.Text, QuickStartType.Application).ConfigureAwait(true);

                            QuickItem.Update(Icon.Source as BitmapImage, Protocol.Text, null, DisplayName.Text);
                        }
                    }
                    else
                    {
                        FormatErrorTip.IsOpen = true;
                        args.Cancel           = true;
                    }

                    break;
                }

                case QuickStartType.UpdateWeb:
                {
                    if (Uri.TryCreate(Protocol.Text, UriKind.Absolute, out Uri _))
                    {
                        if (!FileSystemItemNameChecker.IsValid(DisplayName.Text))
                        {
                            args.Cancel           = true;
                            InvalidCharTip.IsOpen = true;
                            Deferral.Complete();
                            return;
                        }

                        if (ImageFile != null)
                        {
                            string      ImageName = DisplayName.Text + Path.GetExtension(ImageFile.Path);
                            StorageFile NewFile   = await ImageFile.CopyAsync(await ApplicationData.Current.LocalFolder.CreateFolderAsync("HotWebImage", CreationCollisionOption.OpenIfExists), ImageName, NameCollisionOption.GenerateUniqueName);

                            await SQLite.Current.UpdateQuickStartItemAsync(QuickItem.DisplayName, DisplayName.Text, $"HotWebImage\\{NewFile.Name}", Protocol.Text, QuickStartType.WebSite).ConfigureAwait(true);

                            QuickItem.Update(Icon.Source as BitmapImage, Protocol.Text, $"HotWebImage\\{NewFile.Name}", DisplayName.Text);
                        }
                        else
                        {
                            await SQLite.Current.UpdateQuickStartItemAsync(QuickItem.DisplayName, DisplayName.Text, null, Protocol.Text, QuickStartType.WebSite).ConfigureAwait(true);

                            QuickItem.Update(Icon.Source as BitmapImage, Protocol.Text, null, DisplayName.Text);
                        }
                    }
                    else
                    {
                        FormatErrorTip.IsOpen = true;
                        args.Cancel           = true;
                    }

                    break;
                }

                default:
                {
                    break;
                }
                }
            }

            Deferral.Complete();
        }