PDA UI refactor and cartridges (#11335)

* Work on cartridges

* Work on PDA UI

* Work on PDA UIs program list

* Work on PDA UI borders

* Add DeviceNetworkingComponent to the pda base prototype

* Fix submodule version

* Fix cartridge loader ui key

* Fix pda menu xaml

* Implement relaying ui messages

* Finish implementing the notekeeper cartridge

* Fix submodule version

* Fix errors from merging master

* Fix test failing

* Implement setting preinstalled programs

* Add some documentation to CartridgeLoaderSystem

* Add more doc comments

* Add localization to program names

* Implement review suggestions

* Fix background programs receiving events twice when active

Content.Client/CartridgeLoader/CartridgeLoaderBoundUserInterface.cs

@@ -0,0 +1,136 @@
+using Content.Shared.CartridgeLoader;
+using Robust.Client.GameObjects;
+using Robust.Client.UserInterface;
+
+namespace Content.Client.CartridgeLoader;
+
+
+public abstract class CartridgeLoaderBoundUserInterface : BoundUserInterface
+{
+    [Dependency] private readonly IEntityManager? _entityManager = default!;
+
+    private EntityUid? _activeProgram;
+    private CartridgeUI? _activeCartridgeUI;
+    private Control? _activeUiFragment;
+
+    protected CartridgeLoaderBoundUserInterface(ClientUserInterfaceComponent owner, Enum uiKey) : base(owner, uiKey)
+    {
+        IoCManager.InjectDependencies(this);
+    }
+
+    protected override void UpdateState(BoundUserInterfaceState state)
+    {
+        base.UpdateState(state);
+
+        if (state is not CartridgeLoaderUiState loaderUiState)
+        {
+            _activeCartridgeUI?.UpdateState(state);
+            return;
+        }
+
+        var programs = GetCartridgeComponents(loaderUiState.Programs);
+        UpdateAvailablePrograms(programs);
+
+        _activeProgram = loaderUiState.ActiveUI;
+
+        var ui = RetrieveCartridgeUI(loaderUiState.ActiveUI);
+        var comp = RetrieveCartridgeComponent(loaderUiState.ActiveUI);
+        var control = ui?.GetUIFragmentRoot();
+
+        //Prevent the same UI fragment from getting disposed and attached multiple times
+        if (_activeUiFragment?.GetType() == control?.GetType())
+            return;
+
+        if (_activeUiFragment is not null)
+            DetachCartridgeUI(_activeUiFragment);
+
+        if (control is not null && _activeProgram.HasValue)
+        {
+            AttachCartridgeUI(control, Loc.GetString(comp?.ProgramName ?? "default-program-name"));
+            SendCartridgeUiReadyEvent(_activeProgram.Value);
+        }
+
+        _activeCartridgeUI = ui;
+        _activeUiFragment?.Dispose();
+        _activeUiFragment = control;
+    }
+
+    protected void ActivateCartridge(EntityUid cartridgeUid)
+    {
+        var message = new CartridgeLoaderUiMessage(cartridgeUid, CartridgeUiMessageAction.Activate);
+        SendMessage(message);
+    }
+
+    protected void DeactivateActiveCartridge()
+    {
+        if (!_activeProgram.HasValue)
+            return;
+
+        var message = new CartridgeLoaderUiMessage(_activeProgram.Value, CartridgeUiMessageAction.Deactivate);
+        SendMessage(message);
+    }
+
+    protected void InstallCartridge(EntityUid cartridgeUid)
+    {
+        var message = new CartridgeLoaderUiMessage(cartridgeUid, CartridgeUiMessageAction.Install);
+        SendMessage(message);
+    }
+
+    protected void UninstallCartridge(EntityUid cartridgeUid)
+    {
+        var message = new CartridgeLoaderUiMessage(cartridgeUid, CartridgeUiMessageAction.Uninstall);
+        SendMessage(message);
+    }
+
+    private List<(EntityUid, CartridgeComponent)> GetCartridgeComponents(List<EntityUid> programs)
+    {
+        var components = new List<(EntityUid, CartridgeComponent)>();
+
+        foreach (var program in programs)
+        {
+            var component = RetrieveCartridgeComponent(program);
+            if (component is not null)
+                components.Add((program, component));
+        }
+
+        return components;
+    }
+
+    /// <summary>
+    /// The implementing ui needs to add the passed ui fragment as a child to itself
+    /// </summary>
+    protected abstract void AttachCartridgeUI(Control cartridgeUIFragment, string? title);
+
+    /// <summary>
+    /// The implementing ui needs to remove the passed ui from itself
+    /// </summary>
+    protected abstract void DetachCartridgeUI(Control cartridgeUIFragment);
+
+    protected abstract void UpdateAvailablePrograms(List<(EntityUid, CartridgeComponent)> programs);
+
+    protected override void Dispose(bool disposing)
+    {
+        base.Dispose(disposing);
+
+        if (disposing)
+            _activeUiFragment?.Dispose();
+    }
+
+    protected CartridgeComponent? RetrieveCartridgeComponent(EntityUid? cartridgeUid)
+    {
+        return _entityManager?.GetComponentOrNull<CartridgeComponent>(cartridgeUid);
+    }
+
+    private void SendCartridgeUiReadyEvent(EntityUid cartridgeUid)
+    {
+        var message = new CartridgeLoaderUiMessage(cartridgeUid, CartridgeUiMessageAction.UIReady);
+        SendMessage(message);
+    }
+
+    private CartridgeUI? RetrieveCartridgeUI(EntityUid? cartridgeUid)
+    {
+        var component = _entityManager?.GetComponentOrNull<CartridgeUiComponent>(cartridgeUid);
+        component?.Ui?.Setup(this);
+        return component?.Ui;
+    }
+}

Content.Client/CartridgeLoader/CartridgeLoaderSystem.cs

@@ -0,0 +1,15 @@
+using Content.Shared.CartridgeLoader;
+
+namespace Content.Client.CartridgeLoader;
+
+public sealed class CartridgeLoaderSystem : SharedCartridgeLoaderSystem
+{
+    //Empty client system for component replication
+}
+
+[RegisterComponent]
+[ComponentReference(typeof(SharedCartridgeLoaderComponent))]
+public sealed class CartridgeLoaderComponent : SharedCartridgeLoaderComponent
+{
+
+}

Content.Client/CartridgeLoader/CartridgeUI.cs

@@ -0,0 +1,25 @@
+using Robust.Client.GameObjects;
+using Robust.Client.UserInterface;
+
+namespace Content.Client.CartridgeLoader;
+
+/// <summary>
+/// Cartridge ui fragments need to inherit this class. The subclass is then used in yaml to tell the cartridge loader ui to use it as the cartridges ui fragment.
+/// </summary>
+/// <example>
+/// This is an example from the yaml definition from the notekeeper ui
+/// <code>
+/// - type: CartridgeUi
+///     ui: !type:NotekeeperUi
+/// </code>
+/// </example>
+[ImplicitDataDefinitionForInheritors]
+public abstract class CartridgeUI
+{
+    public abstract Control GetUIFragmentRoot();
+
+    public abstract void Setup(BoundUserInterface userInterface);
+
+    public abstract void UpdateState(BoundUserInterfaceState state);
+
+}

Content.Client/CartridgeLoader/CartridgeUISerializer.cs

@@ -0,0 +1,44 @@
+using Robust.Shared.Serialization.Manager;
+using Robust.Shared.Serialization.Markdown;
+using Robust.Shared.Serialization.Markdown.Validation;
+using Robust.Shared.Serialization.Markdown.Value;
+using Robust.Shared.Serialization.TypeSerializers.Interfaces;
+
+namespace Content.Client.CartridgeLoader;
+
+/// <summary>
+/// Boilerplate serializer for defining the ui fragment used for a cartridge in yaml
+/// </summary>
+/// <example>
+/// This is an example from the yaml definition from the notekeeper ui
+/// <code>
+/// - type: CartridgeUi
+///     ui: !type:NotekeeperUi
+/// </code>
+/// </example>
+public sealed class CartridgeUISerializer : ITypeSerializer<CartridgeUI, ValueDataNode>
+{
+    public ValidationNode Validate(ISerializationManager serializationManager, ValueDataNode node,
+        IDependencyCollection dependencies, ISerializationContext? context = null)
+    {
+        return serializationManager.ValidateNode<CartridgeUI>(node, context);
+    }
+
+    public CartridgeUI Read(ISerializationManager serializationManager, ValueDataNode node, IDependencyCollection dependencies,
+        bool skipHook, ISerializationContext? context = null, CartridgeUI? value = default)
+    {
+        return serializationManager.Read(node, context, skipHook, value);
+    }
+
+    public CartridgeUI Copy(ISerializationManager serializationManager, CartridgeUI source, CartridgeUI target, bool skipHook,
+        ISerializationContext? context = null)
+    {
+        return serializationManager.Copy(source, context, skipHook);
+    }
+
+    public DataNode Write(ISerializationManager serializationManager, CartridgeUI value, IDependencyCollection dependencies,
+        bool alwaysWrite = false, ISerializationContext? context = null)
+    {
+        return serializationManager.WriteValue(value, alwaysWrite, context);
+    }
+}

Content.Client/CartridgeLoader/CartridgeUiComponent.cs

@@ -0,0 +1,14 @@
+
+namespace Content.Client.CartridgeLoader;
+
+/// <summary>
+/// The component used for defining which ui fragment to use for a cartridge
+/// </summary>
+/// <seealso cref="CartridgeUI"/>
+/// <seealso cref="CartridgeUISerializer"/>
+[RegisterComponent]
+public sealed class CartridgeUiComponent : Component
+{
+    [DataField("ui", true, customTypeSerializer: typeof(CartridgeUISerializer))]
+    public CartridgeUI? Ui = default;
+}

Content.Client/CartridgeLoader/Cartridges/NotekeeperUi.cs

@@ -0,0 +1,39 @@
+using Content.Shared.CartridgeLoader;
+using Content.Shared.CartridgeLoader.Cartridges;
+using Robust.Client.GameObjects;
+using Robust.Client.UserInterface;
+
+namespace Content.Client.CartridgeLoader.Cartridges;
+
+public sealed class NotekeeperUi : CartridgeUI
+{
+    private NotekeeperUiFragment? _fragment;
+
+
+    public override Control GetUIFragmentRoot()
+    {
+        return _fragment!;
+    }
+
+    public override void Setup(BoundUserInterface userInterface)
+    {
+        _fragment = new NotekeeperUiFragment();
+        _fragment.OnNoteRemoved += note => SendNotekeeperMessage(NotekeeperUiAction.Remove, note, userInterface);
+        _fragment.OnNoteAdded += note => SendNotekeeperMessage(NotekeeperUiAction.Add, note, userInterface);
+    }
+
+    public override void UpdateState(BoundUserInterfaceState state)
+    {
+        if (state is not NotekeeperUiState notekeepeerState)
+            return;
+
+        _fragment?.UpdateState(notekeepeerState.Notes);
+    }
+
+    private void SendNotekeeperMessage(NotekeeperUiAction action, string note, BoundUserInterface userInterface)
+    {
+        var notekeeperMessage = new NotekeeperUiMessageEvent(action, note);
+        var message = new CartridgeUiMessage(notekeeperMessage);
+        userInterface.SendMessage(message);
+    }
+}

Content.Client/CartridgeLoader/Cartridges/NotekeeperUiFragment.xaml

@@ -0,0 +1,10 @@
+<cartridges:NotekeeperUiFragment xmlns:cartridges="clr-namespace:Content.Client.CartridgeLoader.Cartridges"
+                                 xmlns="https://spacestation14.io" Margin="1 0 2 0">
+    <PanelContainer StyleClasses="BackgroundDark"></PanelContainer>
+    <BoxContainer Orientation="Vertical" HorizontalExpand="True" VerticalExpand="True">
+        <ScrollContainer HorizontalExpand="True" VerticalExpand="True" HScrollEnabled="True">
+            <BoxContainer Orientation="Vertical" Name="MessageContainer" HorizontalExpand="True" VerticalExpand="True"/>
+        </ScrollContainer>
+        <LineEdit Name="Input" HorizontalExpand="True" SetHeight="32"/>
+    </BoxContainer>
+</cartridges:NotekeeperUiFragment>

Content.Client/CartridgeLoader/Cartridges/NotekeeperUiFragment.xaml.cs

@@ -0,0 +1,62 @@
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.XAML;
+
+namespace Content.Client.CartridgeLoader.Cartridges;
+
+[GenerateTypedNameReferences]
+public sealed partial class NotekeeperUiFragment : BoxContainer
+{
+
+    public event Action<string>? OnNoteAdded;
+    public event Action<string>? OnNoteRemoved;
+
+    public NotekeeperUiFragment()
+    {
+        RobustXamlLoader.Load(this);
+        Orientation = LayoutOrientation.Vertical;
+        HorizontalExpand = true;
+        VerticalExpand = true;
+
+        Input.OnTextEntered += _ =>
+        {
+            AddNote(Input.Text);
+            OnNoteAdded?.Invoke(Input.Text);
+            Input.Clear();
+        };
+
+        UpdateState(new List<string>());
+    }
+
+    public void UpdateState(List<string> notes)
+    {
+        MessageContainer.RemoveAllChildren();
+
+        foreach (var note in notes)
+        {
+           AddNote(note);
+        }
+    }
+
+    private void AddNote(string note)
+    {
+        var row = new BoxContainer();
+        row.HorizontalExpand = true;
+        row.Orientation = LayoutOrientation.Horizontal;
+        row.Margin = new Thickness(4);
+
+        var label = new Label();
+        label.Text = note;
+        label.HorizontalExpand = true;
+        label.ClipText = true;
+
+        var removeButton = new TextureButton();
+        removeButton.AddStyleClass("windowCloseButton");
+        removeButton.OnPressed += _ => OnNoteRemoved?.Invoke(label.Text);
+
+        row.AddChild(label);
+        row.AddChild(removeButton);
+
+        MessageContainer.AddChild(row);
+    }
+}