Avalonia/samples/ControlCatalog/Pages/DialogsPage.xaml.cs

using System;
using System.Buffers;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;
using Avalonia;
using Avalonia.Controls;
using Avalonia.Controls.Presenters;
using Avalonia.Dialogs;
using Avalonia.Layout;
using Avalonia.Markup.Xaml;
using Avalonia.Platform.Storage;
using Avalonia.Platform.Storage.FileIO;

#pragma warning disable CS0618 // Type or member is obsolete
#nullable enable

namespace ControlCatalog.Pages
{
    public class DialogsPage : UserControl
    {
        public DialogsPage()
        {
            this.InitializeComponent();

            var results = this.Get<ItemsControl>("PickerLastResults");
            var resultsVisible = this.Get<TextBlock>("PickerLastResultsVisible");
            var bookmarkContainer = this.Get<TextBox>("BookmarkContainer");
            var openedFileContent = this.Get<TextBox>("OpenedFileContent");
            var openMultiple = this.Get<CheckBox>("OpenMultiple");

            IStorageFolder? lastSelectedDirectory = null;

            List<FileDialogFilter> GetFilters()
            {
                if (this.Get<CheckBox>("UseFilters").IsChecked != true)
                    return new List<FileDialogFilter>();
                return new List<FileDialogFilter>
                            {
                                new FileDialogFilter
                                {
                                    Name = "Text files (.txt)", Extensions = new List<string> {"txt"}
                                },
                                new FileDialogFilter
                                {
                                    Name = "All files",
                                    Extensions = new List<string> {"*"}
                                }
                            };
            }

            List<FilePickerFileType>? GetFileTypes()
            {
                if (this.Get<CheckBox>("UseFilters").IsChecked != true)
                    return null;
                return new List<FilePickerFileType>
                            {
                                FilePickerFileTypes.All,
                                FilePickerFileTypes.TextPlain
                            };
            }

            this.Get<Button>("OpenFile").Click += async delegate
            {
                // Almost guaranteed to exist
                var uri = Assembly.GetEntryAssembly()?.GetModules().FirstOrDefault()?.FullyQualifiedName;
                var initialFileName = uri == null ? null : System.IO.Path.GetFileName(uri);
                var initialDirectory = uri == null ? null : System.IO.Path.GetDirectoryName(uri);

                var result = await new OpenFileDialog()
                {
                    Title = "Open file",
                    Filters = GetFilters(),
                    Directory = initialDirectory,
                    InitialFileName = initialFileName
                }.ShowAsync(GetWindow());
                results.Items = result;
                resultsVisible.IsVisible = result?.Any() == true;
            };
            this.Get<Button>("OpenMultipleFiles").Click += async delegate
            {
                var result = await new OpenFileDialog()
                {
                    Title = "Open multiple files",
                    Filters = GetFilters(),
                    Directory = lastSelectedDirectory?.TryGetUri(out var path) == true ? path.LocalPath : null,
                    AllowMultiple = true
                }.ShowAsync(GetWindow());
                results.Items = result;
                resultsVisible.IsVisible = result?.Any() == true;
            };
            this.Get<Button>("SaveFile").Click += async delegate
            {
                var filters = GetFilters();
                var result = await new SaveFileDialog()
                {
                    Title = "Save file",
                    Filters = filters,
                    Directory = lastSelectedDirectory?.TryGetUri(out var path) == true ? path.LocalPath : null,
                    DefaultExtension = filters?.Any() == true ? "txt" : null,
                    InitialFileName = "test.txt"
                }.ShowAsync(GetWindow());
                results.Items = new[] { result };
                resultsVisible.IsVisible = result != null;
            };
            this.Get<Button>("SelectFolder").Click += async delegate
            {
                var result = await new OpenFolderDialog()
                {
                    Title = "Select folder",
                    Directory = lastSelectedDirectory?.TryGetUri(out var path) == true ? path.LocalPath : null
                }.ShowAsync(GetWindow());
                if (string.IsNullOrEmpty(result))
                {
                    resultsVisible.IsVisible = false;
                }
                else
                {
                    lastSelectedDirectory = new BclStorageFolder(new System.IO.DirectoryInfo(result));
                    results.Items = new[] { result };
                    resultsVisible.IsVisible = true;
                }
            };
            this.Get<Button>("OpenBoth").Click += async delegate
            {
                var result = await new OpenFileDialog()
                {
                    Title = "Select both",
                    Directory = lastSelectedDirectory?.TryGetUri(out var path) == true ? path.LocalPath : null,
                    AllowMultiple = true
                }.ShowManagedAsync(GetWindow(), new ManagedFileDialogOptions
                {
                    AllowDirectorySelection = true
                });
                results.Items = result;
                resultsVisible.IsVisible = result?.Any() == true;
            };
            this.Get<Button>("DecoratedWindow").Click += delegate
            {
                new DecoratedWindow().Show();
            };
            this.Get<Button>("DecoratedWindowDialog").Click += delegate
            {
                _ = new DecoratedWindow().ShowDialog(GetWindow());
            };
            this.Get<Button>("Dialog").Click += delegate
            {
                var window = CreateSampleWindow();
                window.Height = 200;
                _ = window.ShowDialog(GetWindow());
            };
            this.Get<Button>("DialogNoTaskbar").Click += delegate
            {
                var window = CreateSampleWindow();
                window.Height = 200;
                window.ShowInTaskbar = false;
                _ = window.ShowDialog(GetWindow());
            };
            this.Get<Button>("OwnedWindow").Click += delegate
            {
                var window = CreateSampleWindow();

                window.Show(GetWindow());
            };

            this.Get<Button>("OwnedWindowNoTaskbar").Click += delegate
            {
                var window = CreateSampleWindow();

                window.ShowInTaskbar = false;

                window.Show(GetWindow());
            };

            this.Get<Button>("OpenFilePicker").Click += async delegate
            {
                var result = await GetStorageProvider().OpenFilePickerAsync(new FilePickerOpenOptions()
                {
                    Title = "Open file",
                    FileTypeFilter = GetFileTypes(),
                    SuggestedStartLocation = lastSelectedDirectory,
                    AllowMultiple = openMultiple.IsChecked == true
                });

                await SetPickerResult(result);
            };
            this.Get<Button>("SaveFilePicker").Click += async delegate
            {
                var fileTypes = GetFileTypes();
                var file = await GetStorageProvider().SaveFilePickerAsync(new FilePickerSaveOptions()
                {
                    Title = "Save file",
                    FileTypeChoices = fileTypes,
                    SuggestedStartLocation = lastSelectedDirectory,
                    SuggestedFileName = "FileName",
                    DefaultExtension = fileTypes?.Any() == true ? "txt" : null,
                    ShowOverwritePrompt = false
                });

                if (file is not null && file.CanOpenWrite)
                {
                    // Sync disposal of StreamWriter is not supported on WASM
#if NET6_0_OR_GREATER
                    await using var stream = await file.OpenWriteAsync();
                    await using var reader = new System.IO.StreamWriter(stream);
#else
                                using var stream = await file.OpenWriteAsync();
                                using var reader = new System.IO.StreamWriter(stream);
#endif
                    await reader.WriteLineAsync(openedFileContent.Text);

                    lastSelectedDirectory = await file.GetParentAsync();
                }

                await SetPickerResult(file is null ? null : new[] { file });
            };
            this.Get<Button>("OpenFolderPicker").Click += async delegate
            {
                var folders = await GetStorageProvider().OpenFolderPickerAsync(new FolderPickerOpenOptions()
                {
                    Title = "Folder file",
                    SuggestedStartLocation = lastSelectedDirectory,
                    AllowMultiple = openMultiple.IsChecked == true
                });

                await SetPickerResult(folders);

                lastSelectedDirectory = folders.FirstOrDefault();
            };
            this.Get<Button>("OpenFileFromBookmark").Click += async delegate
            {
                var file = bookmarkContainer.Text is not null
                    ? await GetStorageProvider().OpenFileBookmarkAsync(bookmarkContainer.Text)
                    : null;

                await SetPickerResult(file is null ? null : new[] { file });
            };
            this.Get<Button>("OpenFolderFromBookmark").Click += async delegate
            {
                var folder = bookmarkContainer.Text is not null
                    ? await GetStorageProvider().OpenFolderBookmarkAsync(bookmarkContainer.Text)
                    : null;

                await SetPickerResult(folder is null ? null : new[] { folder });

                lastSelectedDirectory = folder;
            };

            async Task SetPickerResult(IReadOnlyCollection<IStorageItem>? items)
            {
                items ??= Array.Empty<IStorageItem>();
                bookmarkContainer.Text = items.FirstOrDefault(f => f.CanBookmark) is { } f ? await f.SaveBookmarkAsync() : "Can't bookmark";
                var mappedResults = new List<string>();

                if (items.FirstOrDefault() is IStorageItem item)
                {
                    var resultText = item is IStorageFile ? "File:" : "Folder:";
                    resultText += Environment.NewLine;

                    var props = await item.GetBasicPropertiesAsync();
                    resultText += @$"Size: {props.Size}
            DateCreated: {props.DateCreated}
            DateModified: {props.DateModified}
            CanBookmark: {item.CanBookmark}
            ";
                    if (item is IStorageFile file)
                    {
                        resultText += @$"
            CanOpenRead: {file.CanOpenRead}
            CanOpenWrite: {file.CanOpenWrite}
            Content:
            ";
                        if (file.CanOpenRead)
                        {
#if NET6_0_OR_GREATER
                            await using var stream = await file.OpenReadAsync();
#else
                                        using var stream = await file.OpenReadAsync();
#endif
                            using var reader = new System.IO.StreamReader(stream);

                            // 4GB file test, shouldn't load more than 10000 chars into a memory.
                            const int length = 10000;
                            var buffer = ArrayPool<char>.Shared.Rent(length);
                            try
                            {
                                var charsRead = await reader.ReadAsync(buffer, 0, length);
                                resultText += new string(buffer, 0, charsRead);
                            }
                            finally
                            {
                                ArrayPool<char>.Shared.Return(buffer);
                            }
                        }
                    }

                    openedFileContent.Text = resultText;

                    lastSelectedDirectory = await item.GetParentAsync();
                    if (lastSelectedDirectory is not null)
                    {
                        mappedResults.Add(FullPathOrName(lastSelectedDirectory));
                    }

                    foreach (var selectedItem in items)
                    {
                        mappedResults.Add("+> " + FullPathOrName(selectedItem));
                        if (selectedItem is IStorageFolder folder)
                        {
                            foreach (var innerItems in await folder.GetItemsAsync())
                            {
                                mappedResults.Add("++> " + FullPathOrName(innerItems));
                            }
                        }
                    }
                }

                results.Items = mappedResults;
                resultsVisible.IsVisible = mappedResults.Any();
            }
        }

        protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
        {
            base.OnAttachedToVisualTree(e);

            var openedFileContent = this.Get<TextBox>("OpenedFileContent");
            try
            {
                var storageProvider = GetStorageProvider();
                openedFileContent.Text = $@"CanOpen: {storageProvider.CanOpen}
CanSave: {storageProvider.CanSave}
CanPickFolder: {storageProvider.CanPickFolder}";
            }
            catch (Exception ex)
            {
                openedFileContent.Text = "Storage provider is not available: " + ex.Message;
            }
        }

        private Window CreateSampleWindow()
        {
            Button button;
            Button dialogButton;

            var window = new Window
            {
                Height = 200,
                Width = 200,
                Content = new StackPanel
                {
                    Spacing = 4,
                    Children =
                    {
                        new TextBlock { Text = "Hello world!" },
                        (button = new Button
                        {
                            HorizontalAlignment = HorizontalAlignment.Center,
                            Content = "Click to close",
                            IsDefault = true
                        }),
                        (dialogButton = new Button
                        {
                            HorizontalAlignment = HorizontalAlignment.Center,
                            Content = "Dialog",
                            IsDefault = false
                        })
                    }
                },
                WindowStartupLocation = WindowStartupLocation.CenterOwner
            };

            button.Click += (_, __) => window.Close();
            dialogButton.Click += (_, __) =>
            {
                var dialog = CreateSampleWindow();
                dialog.Height = 200;
                dialog.ShowDialog(window);
            };

            return window;
        }

        private IStorageProvider GetStorageProvider()
        {
            var forceManaged = this.Get<CheckBox>("ForceManaged").IsChecked ?? false;
            return forceManaged
                ? new ManagedStorageProvider<Window>(GetWindow(), null)
                : GetTopLevel().StorageProvider;
        }

        private static string FullPathOrName(IStorageItem? item)
        {
            if (item is null) return "(null)";
            return item.TryGetUri(out var uri) ? uri.ToString() : item.Name;
        }

        Window GetWindow() => TopLevel.GetTopLevel(this) as Window ?? throw new NullReferenceException("Invalid Owner");
        TopLevel GetTopLevel() => TopLevel.GetTopLevel(this) ?? throw new NullReferenceException("Invalid Owner");

        private void InitializeComponent()
        {
            AvaloniaXamlLoader.Load(this);
        }
    }
}
#pragma warning restore CS0618 // Type or member is obsolete