Merge branch 'master' into android-show-keyboard-on-click-of-focused-textbox

osu.Framework.Android/Input/AndroidTextInput.cs

···
             inputMethodManager = view.Context.GetSystemService(Context.InputMethodService) as InputMethodManager;
         }
 
-        public void Deactivate(object sender)
+        public void Deactivate()
         {
             activity.RunOnUiThread(() =>
             {
···
         public event Action<string> OnNewImeComposition;
         public event Action<string> OnNewImeResult;
 
-        public void Activate(object sender)
+        public void Activate()
         {
             activity.RunOnUiThread(() =>
             {

osu.Framework.Templates/templates/template-flappy/README.md

···
 
 * Flappy Bird artwork by [Matthias Gall](https://github.com/digitalbreed/how-to-build-a-game-like-flappy-bird-with-xcode-and-sprite-kit).
 * Number sprites by ahmadmanga, available on [opengameart.org](http://opengameart.org).
-* Arcade font by [Jakob Fischer](www.pizzadude.dk).
+* Arcade font by [Jakob Fischer](https://www.pizzadude.dk).
 * Remaining artwork + sounds are from [osu! resources](https://github.com/ppy/osu-resources).
 

osu.Framework.Tests/Localisation/LocalisationTest.cs

···
 using System.Threading.Tasks;
 using NUnit.Framework;
 using osu.Framework.Configuration;
+using osu.Framework.Extensions.LocalisationExtensions;
 using osu.Framework.Localisation;
 
 namespace osu.Framework.Tests.Localisation
···
             var dateTime = new DateTime(1);
             const string format = "MMM yyyy";
 
-            var text = manager.GetLocalisedString(new LocalisableFormattableString(dateTime, format));
+            var text = manager.GetLocalisedString(dateTime.ToLocalisableString(format));
 
             Assert.AreEqual("Jan 0001", text.Value);
 
···
             Assert.AreEqual("janv. 0001", text.Value);
         }
 
+        [Test]
+        public void TestCaseTransformableString()
+        {
+            const string localisable_string_en_title_case = "Localised EN";
+
+            config.SetValue(FrameworkSetting.Locale, "en");
+
+            var uppercasedText = manager.GetLocalisedString(new TranslatableString(FakeStorage.LOCALISABLE_STRING_EN, FakeStorage.LOCALISABLE_STRING_EN).ToUpper());
+            var titleText = manager.GetLocalisedString(new TranslatableString(FakeStorage.LOCALISABLE_STRING_EN, FakeStorage.LOCALISABLE_STRING_EN).ToTitle());
+
+            Assert.AreEqual(uppercasedText.Value, "LOCALISED EN");
+            Assert.AreEqual(titleText.Value, localisable_string_en_title_case);
+        }
+
+        [Test]
+        public void TestCaseTransformableStringNonEnglishCultureCasing()
+        {
+            manager.AddLanguage("tr", new FakeStorage("tr"));
+
+            var uppercasedText = manager.GetLocalisedString(new TranslatableString(FakeStorage.LOCALISABLE_STRING_EN, FakeStorage.LOCALISABLE_STRING_EN).ToUpper());
+            var lowercasedText = manager.GetLocalisedString(new TranslatableString(FakeStorage.LOCALISABLE_STRING_EN, FakeStorage.LOCALISABLE_STRING_EN).ToLower());
+
+            config.SetValue(FrameworkSetting.Locale, "en");
+
+            Assert.AreEqual(uppercasedText.Value, "LOCALISED EN");
+            Assert.AreEqual(lowercasedText.Value, "localised en");
+
+            config.SetValue(FrameworkSetting.Locale, "tr");
+
+            Assert.AreEqual(uppercasedText.Value, "LOCALİSED TR (İ/I)");
+            Assert.AreEqual(lowercasedText.Value, "localised tr (i/ı)");
+        }
+
+        [Test]
+        public void TestTranslatableEvaluatingLocalisableFormattableString()
+        {
+            const string key = FakeStorage.LOCALISABLE_NUMBER_FORMAT_STRING_EN;
+
+            manager.AddLanguage("fr", new FakeStorage("fr"));
+
+            var text = manager.GetLocalisedString(new TranslatableString(key, key, new LocalisableFormattableString(0.1234, "0.00%")));
+
+            Assert.AreEqual("number 12.34% EN", text.Value);
+
+            config.SetValue(FrameworkSetting.Locale, "fr");
+
+            Assert.AreEqual("number 12,34% FR", text.Value);
+        }
+
+        [Test]
+        public void TestTranslatableEvaluatingRomanisableString()
+        {
+            const string key = FakeStorage.LOCALISABLE_FORMAT_STRING_EN;
+
+            var text = manager.GetLocalisedString(new TranslatableString(key, key, new RomanisableString("unicode", "romanised")));
+
+            Assert.AreEqual("unicode localised EN", text.Value);
+
+            config.SetValue(FrameworkSetting.ShowUnicode, false);
+
+            Assert.AreEqual("romanised localised EN", text.Value);
+        }
+
+        [Test]
+        public void TestTranslatableEvaluatingTranslatableString()
+        {
+            const string key = FakeStorage.LOCALISABLE_FORMAT_STRING_EN;
+            const string nested_key = FakeStorage.LOCALISABLE_STRING_EN;
+
+            manager.AddLanguage("ja", new FakeStorage("ja"));
+
+            var text = manager.GetLocalisedString(new TranslatableString(key, key, new TranslatableString(nested_key, nested_key)));
+
+            Assert.AreEqual("localised EN localised EN", text.Value);
+
+            config.SetValue(FrameworkSetting.Locale, "ja");
+
+            Assert.AreEqual("localised JA localised JA", text.Value);
+        }
+
+        [Test]
+        public void TestTranslatableEvaluatingComplexString()
+        {
+            const string key = FakeStorage.LOCALISABLE_COMPLEX_FORMAT_STRING_EN;
+            const string nested_key = FakeStorage.LOCALISABLE_NUMBER_FORMAT_STRING_EN;
+
+            manager.AddLanguage("fr", new FakeStorage("fr"));
+
+            var text = manager.GetLocalisedString(new TranslatableString(key, key,
+                new LocalisableFormattableString(12.34, "0.00"),
+                new TranslatableString(nested_key, nested_key, new LocalisableFormattableString(0.9876, "0.00%")),
+                new TranslatableString(nested_key, nested_key, new RomanisableString("unicode", "romanised"))));
+
+            Assert.AreEqual("number 12.34 with number 98.76% EN and number unicode EN EN", text.Value);
+
+            config.SetValue(FrameworkSetting.Locale, "fr");
+
+            Assert.AreEqual("number 12,34 with number 98,76% FR and number unicode FR FR", text.Value);
+
+            config.SetValue(FrameworkSetting.ShowUnicode, false);
+
+            Assert.AreEqual("number 12,34 with number 98,76% FR and number romanised FR FR", text.Value);
+
+            config.SetValue(FrameworkSetting.Locale, "en");
+
+            Assert.AreEqual("number 12.34 with number 98.76% EN and number romanised EN EN", text.Value);
+        }
+
         private class FakeFrameworkConfigManager : FrameworkConfigManager
         {
             protected override string Filename => null;
···
             public const string LOCALISABLE_STRING_EN = "localised EN";
             public const string LOCALISABLE_STRING_JA = "localised JA";
             public const string LOCALISABLE_STRING_JA_JP = "localised JA-JP";
+            public const string LOCALISABLE_STRING_TR = "localised TR (i/I)";
             public const string LOCALISABLE_FORMAT_STRING_EN = "{0} localised EN";
             public const string LOCALISABLE_FORMAT_STRING_JA = "{0} localised JA";
             public const string LOCALISABLE_NUMBER_FORMAT_STRING_EN = "number {0} EN";
             public const string LOCALISABLE_NUMBER_FORMAT_STRING_FR = "number {0} FR";
+            public const string LOCALISABLE_COMPLEX_FORMAT_STRING_EN = "number {0} with {1} and {2} EN";
+            public const string LOCALISABLE_COMPLEX_FORMAT_STRING_FR = "number {0} with {1} and {2} FR";
 
             public CultureInfo EffectiveCulture { get; }
 
···
 
                             case "ja-JP":
                                 return LOCALISABLE_STRING_JA_JP;
+
+                            case "tr":
+                                return LOCALISABLE_STRING_TR;
                         }
 
                     case LOCALISABLE_FORMAT_STRING_EN:
···
 
                             case "fr":
                                 return LOCALISABLE_NUMBER_FORMAT_STRING_FR;
+                        }
+
+                    case LOCALISABLE_COMPLEX_FORMAT_STRING_EN:
+                        switch (locale)
+                        {
+                            default:
+                                return LOCALISABLE_COMPLEX_FORMAT_STRING_EN;
+
+                            case "fr":
+                                return LOCALISABLE_COMPLEX_FORMAT_STRING_FR;
                         }
 
                     default:

osu.Framework.Tests/Visual/UserInterface/TestSceneColourPicker.cs

···
 // Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Testing;
 
 namespace osu.Framework.Tests.Visual.UserInterface
 {
···
                 Current = { Value = Colour4.Goldenrod }
             });
             AddAssert("colour is correct", () => colourPicker.Current.Value == Colour4.Goldenrod);
+        }
+
+        [Test]
+        public void TestExternalHSVChange()
+        {
+            const float hue = 0.34f;
+            const float saturation = 0.46f;
+            const float value = 0.84f;
+
+            ColourPicker colourPicker = null;
+
+            AddStep("create picker", () => Child = colourPicker = new BasicColourPicker
+            {
+                Current = { Value = Colour4.Goldenrod }
+            });
+            AddStep("hide picker", () => colourPicker.Hide());
+            AddStep("set HSV manually", () =>
+            {
+                var saturationValueControl = this.ChildrenOfType<HSVColourPicker.SaturationValueSelector>().Single();
+
+                saturationValueControl.Hue.Value = hue;
+                saturationValueControl.Saturation.Value = saturation;
+                saturationValueControl.Value.Value = value;
+            });
+
+            AddUntilStep("colour is correct", () => colourPicker.Current.Value == Colour4.FromHSV(hue, saturation, value));
         }
     }
 }

osu.Framework.Tests/Visual/UserInterface/TestSceneHSVColourPicker.cs

···
         }
 
         [Test]
+        public void TestExternalChangeWhileNotPresent()
+        {
+            const float hue = 0.34f;
+            const float saturation = 0.46f;
+            const float value = 0.84f;
+
+            AddStep("hide picker", () => colourPicker.Hide());
+            AddStep("set HSV manually", () =>
+            {
+                colourPicker.SaturationValueControl.Hue.Value = hue;
+                colourPicker.SaturationValueControl.Saturation.Value = saturation;
+                colourPicker.SaturationValueControl.Value.Value = value;
+            });
+
+            AddUntilStep("colour is correct", () => colourPicker.Current.Value == Colour4.FromHSV(hue, saturation, value));
+        }
+
+        [Test]
         public void TestHueUnchangedIfSaturationAlmostZero()
         {
             AddStep("change colour", () => colourPicker.Current.Value = Colour4.FromHSV(0.5f, 0.5f, 0.5f));

osu.Framework.Tests/Visual/UserInterface/TestSceneTextBox.cs

···
             AddAssert("text replaced", () => textBox.FlowingText == "another" && textBox.FlowingText == textBox.Text);
         }
 
+        [Test]
+        public void TestReadOnly()
+        {
+            BasicTextBox firstTextBox = null;
+            BasicTextBox secondTextBox = null;
+
+            AddStep("add textboxes", () => textBoxes.AddRange(new[]
+            {
+                firstTextBox = new BasicTextBox
+                {
+                    Text = "Readonly textbox",
+                    Size = new Vector2(500, 30),
+                    ReadOnly = true,
+                    TabbableContentContainer = textBoxes
+                },
+                secondTextBox = new BasicTextBox
+                {
+                    Text = "Standard textbox",
+                    Size = new Vector2(500, 30),
+                    TabbableContentContainer = textBoxes
+                }
+            }));
+
+            AddStep("click first (readonly) textbox", () =>
+            {
+                InputManager.MoveMouseTo(firstTextBox);
+                InputManager.Click(MouseButton.Left);
+            });
+            AddAssert("first textbox has no focus", () => !firstTextBox.HasFocus);
+
+            AddStep("click second (editable) textbox", () =>
+            {
+                InputManager.MoveMouseTo(secondTextBox);
+                InputManager.Click(MouseButton.Left);
+            });
+            AddStep("try to tab backwards", () =>
+            {
+                InputManager.PressKey(Key.ShiftLeft);
+                InputManager.Key(Key.Tab);
+                InputManager.ReleaseKey(Key.ShiftLeft);
+            });
+            AddAssert("first (readonly) has no focus", () => !firstTextBox.HasFocus);
+
+            AddStep("drag on first (readonly) textbox", () =>
+            {
+                InputManager.MoveMouseTo(firstTextBox.ScreenSpaceDrawQuad.Centre);
+                InputManager.PressButton(MouseButton.Left);
+                InputManager.MoveMouseTo(firstTextBox.ScreenSpaceDrawQuad.TopLeft);
+                InputManager.ReleaseButton(MouseButton.Left);
+            });
+            AddAssert("first textbox has no focus", () => !firstTextBox.HasFocus);
+
+            AddStep("make first textbox non-readonly", () => firstTextBox.ReadOnly = false);
+            AddStep("click first textbox", () =>
+            {
+                InputManager.MoveMouseTo(firstTextBox);
+                InputManager.Click(MouseButton.Left);
+            });
+            AddStep("make first textbox readonly again", () => firstTextBox.ReadOnly = true);
+            AddAssert("first textbox yielded focus", () => !firstTextBox.HasFocus);
+            AddStep("delete last character", () => firstTextBox.OnPressed(new PlatformAction(PlatformActionType.CharPrevious, PlatformActionMethod.Delete)));
+            AddAssert("no text removed", () => firstTextBox.Text == "Readonly textbox");
+        }
+
         public class InsertableTextBox : BasicTextBox
         {
             /// <summary>

osu.Framework.iOS/Input/IOSTextInput.cs

···
                 pending += text;
         }
 
-        public void Deactivate(object sender)
+        public void Deactivate()
         {
             view.KeyboardTextField.HandleShouldChangeCharacters -= handleShouldChangeCharacters;
             view.KeyboardTextField.UpdateFirstResponder(false);
         }
 
-        public void Activate(object sender)
+        public void Activate()
         {
             view.KeyboardTextField.HandleShouldChangeCharacters += handleShouldChangeCharacters;
             view.KeyboardTextField.UpdateFirstResponder(true);

osu.Framework/Extensions/LocalisationExtensions/LocalisableStringExtensions.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Localisation;
+
+namespace osu.Framework.Extensions.LocalisationExtensions
+{
+    public static class LocalisableStringExtensions
+    {
+        /// <summary>
+        /// Returns a <see cref="CaseTransformableString"/> with the specified underlying localisable string uppercased.
+        /// </summary>
+        /// <param name="str">The localisable string.</param>
+        /// <returns>A case transformable string with its localisable string uppercased.</returns>
+        public static CaseTransformableString ToUpper(this LocalisableString str) => new CaseTransformableString(str, Casing.UpperCase);
+
+        /// <summary>
+        /// Returns a <see cref="CaseTransformableString"/> with the specified underlying string data uppercased.
+        /// </summary>
+        /// <param name="data">The string data.</param>
+        /// <returns>A case transformable string with its string data uppercased.</returns>
+        public static CaseTransformableString ToUpper(this ILocalisableStringData data) => new LocalisableString(data).ToUpper();
+
+        /// <summary>
+        /// Returns a <see cref="LocalisableString"/> with the specified underlying localisable string transformed to title case.
+        /// </summary>
+        /// <param name="str">The localisable string.</param>
+        /// <returns>A case transformable string with its localisable string transformed to title case.</returns>
+        public static CaseTransformableString ToTitle(this LocalisableString str) => new CaseTransformableString(str, Casing.TitleCase);
+
+        /// <summary>
+        /// Returns a <see cref="LocalisableString"/> with the specified underlying string data transformed to title case.
+        /// </summary>
+        /// <param name="data">The string data.</param>
+        /// <returns>A case transformable string with its string data transformed to title case.</returns>
+        public static CaseTransformableString ToTitle(this ILocalisableStringData data) => new LocalisableString(data).ToTitle();
+
+        /// <summary>
+        /// Returns a <see cref="LocalisableString"/> with the specified underlying localisable string lowercased.
+        /// </summary>
+        /// <param name="str">The localisable string.</param>
+        /// <returns>A case transformable string with its localisable string lowercased.</returns>
+        public static CaseTransformableString ToLower(this LocalisableString str) => new CaseTransformableString(str, Casing.LowerCase);
+
+        /// <summary>
+        /// Returns a <see cref="LocalisableString"/> with the specified underlying string data lowercased.
+        /// </summary>
+        /// <param name="data">The string data.</param>
+        /// <returns>A case transformable string with its string data lowercased.</returns>
+        public static CaseTransformableString ToLower(this ILocalisableStringData data) => new LocalisableString(data).ToLower();
+    }
+}

osu.Framework/Graphics/UserInterface/ColourPicker.cs

···
         /// </summary>
         protected abstract HexColourPicker CreateHexColourPicker();
 
+        public override bool IsPresent => base.IsPresent || hsvColourPicker.IsPresent;
+
         protected override void LoadComplete()
         {
             base.LoadComplete();

osu.Framework/Graphics/UserInterface/HSVColourPicker.cs

···
         /// </summary>
         protected abstract SaturationValueSelector CreateSaturationValueSelector();
 
+        public override bool IsPresent => base.IsPresent
+                                          || saturationValueSelector.Scheduler.HasPendingTasks
+                                          || hueSelector.Scheduler.HasPendingTasks;
+
         protected override void LoadComplete()
         {
             base.LoadComplete();

osu.Framework/Graphics/UserInterface/TextBox.cs

···
         /// <returns>Whether the character is allowed to be added.</returns>
         protected virtual bool CanAddCharacter(char character) => true;
 
-        public bool ReadOnly;
+        private bool readOnly;
+
+        public bool ReadOnly
+        {
+            get => readOnly;
+            set
+            {
+                readOnly = value;
+
+                if (readOnly)
+                    KillFocus();
+            }
+        }
 
         /// <summary>
         /// Whether the textbox should rescind focus on commit.
···
         private void killFocus()
         {
             var manager = GetContainingInputManager();
-            if (manager.FocusedDrawable == this)
+            if (manager?.FocusedDrawable == this)
                 manager.ChangeFocus(null);
         }
 
···
         protected override void OnDrag(DragEvent e)
         {
             //if (textInput?.ImeActive == true) return true;
+
+            if (ReadOnly)
+                return;
 
             if (doubleClickWord != null)
             {
···
 
         protected override bool OnMouseDown(MouseDownEvent e)
         {
-            if (textInput?.ImeActive == true) return true;
+            if (textInput?.ImeActive == true || ReadOnly) return true;
 
             selectionStart = selectionEnd = getCharacterClosestTo(e.MousePosition);
 
···
 
         private void unbindInput()
         {
-            textInput?.Deactivate(this);
+            textInput?.Deactivate();
         }
 
         private void bindInput()
         {
-            textInput?.Activate(this);
+            textInput?.Activate();
         }
 
         private void onImeResult()

osu.Framework/Input/GameWindowTextInput.cs

···
             }
         }
 
-        public void Deactivate(object sender)
+        public void Deactivate()
         {
             switch (window)
             {
···
             }
         }
 
-        public void Activate(object sender)
+        public void Activate()
         {
             switch (window)
             {

osu.Framework/Input/ITextInputSource.cs

···
 
         string GetPendingText();
 
-        void Deactivate(object sender);
+        void Deactivate();
 
-        void Activate(object sender);
+        void Activate();
 
         /// <summary>
         /// Ensures that the native implementation that retrieves user text input is activated

osu.Framework/Localisation/CaseTransformableString.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Globalization;
+
+#nullable enable
+
+namespace osu.Framework.Localisation
+{
+    /// <summary>
+    /// A string which can apply case transformations to underlying localisable string.
+    /// </summary>
+    public class CaseTransformableString : IEquatable<CaseTransformableString>, ILocalisableStringData
+    {
+        /// <summary>
+        /// The case to apply to the underlying data.
+        /// </summary>
+        public readonly Casing Casing;
+
+        /// <summary>
+        /// The underlying localisable string of this transformable string.
+        /// </summary>
+        public readonly LocalisableString String;
+
+        /// <summary>
+        /// Constructs a new transformable string with specified underlying localisable string and casing.
+        /// </summary>
+        /// <param name="str">The localisable string to apply case transformations on.</param>
+        /// <param name="casing">The casing to use on the localisable string.</param>
+        public CaseTransformableString(LocalisableString str, Casing casing)
+        {
+            String = str;
+            Casing = casing;
+        }
+
+        public string GetLocalised(LocalisationParameters parameters)
+        {
+            var stringData = getStringData(parameters);
+            var cultureText = parameters.Store?.EffectiveCulture?.TextInfo ?? CultureInfo.InvariantCulture.TextInfo;
+
+            switch (Casing)
+            {
+                case Casing.UpperCase:
+                    return cultureText.ToUpper(stringData);
+
+                case Casing.TitleCase:
+                    return cultureText.ToTitleCase(stringData);
+
+                case Casing.LowerCase:
+                    return cultureText.ToLower(stringData);
+
+                case Casing.Default:
+                default:
+                    return stringData;
+            }
+        }
+
+        public override string ToString() => GetLocalised(new LocalisationParameters(null, false));
+
+        public bool Equals(ILocalisableStringData? other) => other is CaseTransformableString transformable && Equals(transformable);
+
+        public bool Equals(CaseTransformableString? other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+
+            return Casing == other.Casing && String.Equals(other.String);
+        }
+
+        private string getStringData(LocalisationParameters localisationParameters)
+        {
+            switch (String.Data)
+            {
+                case string plain:
+                    return plain;
+
+                case ILocalisableStringData data:
+                    return data.GetLocalised(localisationParameters);
+
+                default:
+                    return string.Empty;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Case applicable to the underlying localisable string of a <see cref="CaseTransformableString"/>.
+    /// </summary>
+    public enum Casing
+    {
+        /// <summary>
+        /// Use the string data case.
+        /// </summary>
+        Default,
+
+        /// <summary>
+        /// Transform the string data to uppercase.
+        /// </summary>
+        UpperCase,
+
+        /// <summary>
+        /// Transform the string data to title case aka capitalized case
+        /// </summary>
+        TitleCase,
+
+        /// <summary>
+        /// Transform the string data to lowercase.
+        /// </summary>
+        LowerCase
+    }
+}

osu.Framework/Localisation/LocalisableString.cs

···
         public static implicit operator LocalisableString(TranslatableString translatable) => new LocalisableString(translatable);
         public static implicit operator LocalisableString(RomanisableString romanisable) => new LocalisableString(romanisable);
         public static implicit operator LocalisableString(LocalisableFormattableString formattable) => new LocalisableString(formattable);
+        public static implicit operator LocalisableString(CaseTransformableString transformable) => new LocalisableString(transformable);
 
         public static bool operator ==(LocalisableString left, LocalisableString right) => left.Equals(right);
         public static bool operator !=(LocalisableString left, LocalisableString right) => !left.Equals(right);

osu.Framework/Localisation/LocalisableStringExtensions.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+
+namespace osu.Framework.Localisation
+{
+    public static class LocalisableStringExtensions
+    {
+        /// <summary>
+        /// Returns a <see cref="LocalisableFormattableString"/> formatting the given <paramref name="value"/> with the specified <paramref name="format"/>.
+        /// </summary>
+        /// <param name="value">The value to format.</param>
+        /// <param name="format">The format string.</param>
+        public static LocalisableFormattableString ToLocalisableString(this IFormattable value, string format) => new LocalisableFormattableString(value, format);
+    }
+}

osu.Framework/Localisation/TranslatableString.cs

···
 
             try
             {
-                return string.Format(parameters.Store.EffectiveCulture, localisedFormat, Args);
+                return string.Format(parameters.Store.EffectiveCulture, localisedFormat, Args.Select(argument =>
+                {
+                    if (argument is LocalisableString localisableString)
+                        argument = localisableString.Data;
+
+                    if (argument is ILocalisableStringData localisableData)
+                        return localisableData.GetLocalised(parameters);
+
+                    return argument;
+                }).ToArray());
             }
             catch (FormatException e)
             {