Added Book Support

MinecraftClient/Tui/BookTuiHost.cs

@@ -0,0 +1,282 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Layout;
+using Avalonia.Media;
+using Avalonia.Threading;
+using MinecraftClient.Inventory;
+
+namespace MinecraftClient.Tui;
+
+public static class BookTuiHost
+{
+    private static volatile bool isRunning;
+
+    public static bool TryOpen(McClient handler, BookHand hand, bool editable)
+    {
+        if (ConsoleIO.Backend is not TuiConsoleBackend)
+            return false;
+
+        Open(handler, hand, editable);
+        return true;
+    }
+
+    public static void OpenFromServer(McClient handler, BookHand hand)
+    {
+        if (ConsoleIO.Backend is TuiConsoleBackend)
+            Open(handler, hand, editable: BookContentHelper.IsWritableBook(handler.GetHeldBook(hand)));
+    }
+
+    private static void Open(McClient handler, BookHand hand, bool editable)
+    {
+        Dispatcher.UIThread.Post(() =>
+        {
+            if (isRunning)
+                return;
+
+            MainTuiView? view = TuiConsoleBackend.Instance?.GetView();
+            if (view is null)
+                return;
+
+            if (!handler.TryGetHeldBookContent(out BookContent content, hand))
+                return;
+
+            isRunning = true;
+            var bookView = new BookView(handler, content, editable && !content.IsSigned);
+            view.ShowOverlay(bookView, () => isRunning = false);
+        });
+    }
+}
+
+internal sealed class BookView : UserControl
+{
+    private readonly McClient handler;
+    private readonly bool editable;
+    private readonly List<string> pages;
+    private readonly TextBlock header;
+    private readonly TextBlock status;
+    private readonly TextBox pageText;
+    private readonly TextBox titleText;
+    private int pageIndex;
+
+    public BookView(McClient handler, BookContent content, bool editable)
+    {
+        this.handler = handler;
+        this.editable = editable;
+        pages = content.Pages.ToList();
+        if (pages.Count == 0)
+            pages.Add(string.Empty);
+
+        Focusable = true;
+        Background = Brushes.Black;
+
+        header = new TextBlock
+        {
+            Foreground = Brushes.Yellow,
+            Margin = new Thickness(1, 0),
+            TextWrapping = TextWrapping.Wrap
+        };
+
+        status = new TextBlock
+        {
+            Foreground = Brushes.Gray,
+            Margin = new Thickness(1, 0),
+            TextWrapping = TextWrapping.Wrap
+        };
+
+        pageText = new TextBox
+        {
+            AcceptsReturn = true,
+            TextWrapping = TextWrapping.Wrap,
+            IsReadOnly = !editable,
+            Foreground = Brushes.White,
+            Background = Brushes.Black,
+            BorderBrush = Brushes.Gray,
+            MinHeight = 12,
+            Margin = new Thickness(1)
+        };
+        pageText.TextChanged += (_, _) =>
+        {
+            if (editable && pageIndex >= 0 && pageIndex < pages.Count)
+                pages[pageIndex] = pageText.Text ?? string.Empty;
+        };
+
+        titleText = new TextBox
+        {
+            Watermark = Translations.tui_book_title_watermark,
+            IsVisible = editable,
+            Foreground = Brushes.White,
+            Background = Brushes.Black,
+            BorderBrush = Brushes.Gray,
+            Margin = new Thickness(1)
+        };
+
+        var controls = new StackPanel
+        {
+            Orientation = Orientation.Horizontal,
+            Spacing = 1,
+            Margin = new Thickness(1),
+            Children =
+            {
+                Button(Translations.tui_book_prev, (_, _) => MovePage(-1)),
+                Button(Translations.tui_book_next, (_, _) => MovePage(1)),
+                Button(Translations.tui_book_insert, (_, _) => InsertPage(), editable),
+                Button(Translations.tui_book_delete, (_, _) => DeletePage(), editable),
+                Button(Translations.tui_book_save, (_, _) => Save(), editable),
+                Button(Translations.tui_book_sign, (_, _) => Sign(), editable),
+                Button(Translations.tui_book_close, (_, _) => Close())
+            }
+        };
+
+        var panel = new DockPanel
+        {
+            Background = Brushes.Black,
+            Children =
+            {
+                DockTo(header, Dock.Top),
+                DockTo(status, Dock.Bottom),
+                DockTo(controls, Dock.Bottom),
+                DockTo(titleText, Dock.Bottom),
+                pageText
+            }
+        };
+
+        Content = panel;
+        Refresh();
+    }
+
+    protected override void OnKeyDown(KeyEventArgs e)
+    {
+        if (e.Key == Key.PageUp)
+        {
+            MovePage(-1);
+            e.Handled = true;
+            return;
+        }
+
+        if (e.Key == Key.PageDown)
+        {
+            MovePage(1);
+            e.Handled = true;
+            return;
+        }
+
+        base.OnKeyDown(e);
+    }
+
+    private static Control DockTo(Control control, Dock dock)
+    {
+        DockPanel.SetDock(control, dock);
+        return control;
+    }
+
+    private static Button Button(string text, EventHandler<Avalonia.Interactivity.RoutedEventArgs> handler, bool enabled = true)
+    {
+        var button = new Button
+        {
+            Content = text,
+            IsEnabled = enabled,
+            Padding = new Thickness(1, 0),
+            Margin = new Thickness(0)
+        };
+        button.Click += handler;
+        return button;
+    }
+
+    private void MovePage(int delta)
+    {
+        pageIndex = Math.Clamp(pageIndex + delta, 0, pages.Count - 1);
+        Refresh();
+    }
+
+    private void InsertPage()
+    {
+        pages.Insert(pageIndex + 1, string.Empty);
+        pageIndex++;
+        Refresh();
+    }
+
+    private void DeletePage()
+    {
+        if (pages.Count == 1)
+            pages[0] = string.Empty;
+        else
+        {
+            pages.RemoveAt(pageIndex);
+            pageIndex = Math.Clamp(pageIndex, 0, pages.Count - 1);
+        }
+        Refresh();
+    }
+
+    private void Save()
+    {
+        if (!Validate(out string error))
+        {
+            status.Text = error;
+            return;
+        }
+
+        status.Text = handler.SendBookEdit(pages)
+            ? Translations.tui_book_saved
+            : Translations.tui_book_save_failed;
+    }
+
+    private void Sign()
+    {
+        string title = (titleText.Text ?? string.Empty).Trim();
+        if (!Validate(out string error, title))
+        {
+            status.Text = error;
+            return;
+        }
+
+        status.Text = handler.SendBookEdit(pages, title)
+            ? Translations.tui_book_signed
+            : Translations.tui_book_save_failed;
+    }
+
+    private bool Validate(out string error, string? title = null)
+    {
+        BookLimits limits = BookLimits.ForProtocol(handler.GetProtocolVersion());
+        error = string.Empty;
+
+        if (pages.Count > limits.MaxPages)
+        {
+            error = string.Format(Translations.cmd_book_too_many_pages, pages.Count, limits.MaxPages);
+            return false;
+        }
+
+        for (int i = 0; i < pages.Count; i++)
+        {
+            if (pages[i].Length > limits.MaxPageLength)
+            {
+                error = string.Format(Translations.cmd_book_page_too_long, i + 1, pages[i].Length, limits.MaxPageLength);
+                return false;
+            }
+        }
+
+        if (title is not null && (title.Length == 0 || title.Length > limits.MaxTitleLength))
+        {
+            error = string.Format(Translations.cmd_book_title_invalid, limits.MaxTitleLength);
+            return false;
+        }
+
+        return true;
+    }
+
+    private void Close()
+    {
+        TuiConsoleBackend.Instance?.GetView()?.HideOverlay();
+    }
+
+    private void Refresh()
+    {
+        pageText.Text = pages[pageIndex];
+        header.Text = string.Format(Translations.tui_book_page_header, pageIndex + 1, pages.Count);
+        status.Text = editable ? Translations.tui_book_editing : Translations.tui_book_reading;
+        pageText.Focus();
+    }
+}