Improve usability of custom tooltips

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

···
                         {
                             new TooltipSpriteText("this text has a tooltip!"),
                             new InstantTooltipSpriteText("this text has an instant tooltip!"),
-                            new TooltipSpriteText("this one too!"),
-                            new CustomTooltipSpriteText("this text has an empty tooltip!", string.Empty),
-                            new CustomTooltipSpriteText("this text has a nulled tooltip!", null),
+                            new CustomTooltipSpriteText("this one is custom!"),
+                            new TooltipSpriteText("this text has an empty tooltip!", string.Empty),
+                            new TooltipSpriteText("this text has a nulled tooltip!", null),
                             new TooltipTextbox
                             {
                                 Text = "with real time updates!",
···
             ttc.Add(makeBox(Anchor.BottomRight));
         }
 
-        private class CustomTooltipSpriteText : Container, IHasTooltip
+        private class CustomTooltipSpriteText : Container, IHasCustomTooltip
         {
-            private readonly string tooltipText;
-
-            public string TooltipText => tooltipText;
+            public object TooltipContent { get; }
 
-            public CustomTooltipSpriteText(string displayedText, string tooltipText)
+            public CustomTooltipSpriteText(string displayedContent, object tooltipContent = null)
             {
-                this.tooltipText = tooltipText;
+                TooltipContent = tooltipContent ?? displayedContent;
 
                 AutoSizeAxes = Axes.Both;
                 Children = new[]
                 {
                     new SpriteText
                     {
-                        Text = displayedText,
+                        Text = displayedContent,
                     }
                 };
             }
+
+            public ITooltip GetCustomTooltip() => new TooltipContainer.Tooltip { Colour = Color4.Blue };
         }
 
-        private class TooltipSpriteText : CustomTooltipSpriteText
+        private class TooltipSpriteText : Container, IHasTooltip
         {
-            public TooltipSpriteText(string tooltipText)
-                : base(tooltipText, tooltipText)
+            private readonly string tooltipContent;
+
+            public string TooltipText => tooltipContent;
+
+            public TooltipSpriteText(string displayedContent)
+                : this(displayedContent, displayedContent)
             {
             }
+
+            public TooltipSpriteText(string displayedContent, string tooltipContent)
+            {
+                this.tooltipContent = tooltipContent;
+
+                AutoSizeAxes = Axes.Both;
+                Children = new[]
+                {
+                    new SpriteText
+                    {
+                        Text = displayedContent,
+                    }
+                };
+            }
         }
 
-        private class InstantTooltipSpriteText : CustomTooltipSpriteText, IHasAppearDelay
+        private class InstantTooltipSpriteText : TooltipSpriteText, IHasAppearDelay
         {
-            public InstantTooltipSpriteText(string tooltipText)
-                : base(tooltipText, tooltipText)
+            public InstantTooltipSpriteText(string tooltipContent)
+                : base(tooltipContent, tooltipContent)
             {
             }
 

osu.Framework/Graphics/Cursor/IHasAppearDelay.cs

···
     /// <summary>
     /// A tooltip which provides a custom delay until it appears, override the <see cref="TooltipContainer"/>-wide default.
     /// </summary>
-    public interface IHasAppearDelay : IHasTooltip
+    public interface IHasAppearDelay : ITooltipContentProvider
     {
         /// <summary>
         /// The delay until the tooltip should be displayed.

osu.Framework/Graphics/Cursor/IHasCustomTooltip.cs

···
     /// Implementing this interface allows the implementing <see cref="Drawable"/> to display a custom tooltip if it is the child of a <see cref="TooltipContainer"/>.
     /// Keep in mind that tooltips can only be displayed by a <see cref="TooltipContainer"/> if the <see cref="Drawable"/> implementing <see cref="IHasCustomTooltip"/> has <see cref="Drawable.HandlePositionalInput"/> set to true.
     /// </summary>
-    public interface IHasCustomTooltip : IHasTooltip
+    public interface IHasCustomTooltip : ITooltipContentProvider
     {
         /// <summary>
         /// The custom tooltip that should be displayed.
         /// </summary>
         /// <returns>The custom tooltip that should be displayed.</returns>
         ITooltip GetCustomTooltip();
+
+        /// <summary>
+        /// Tooltip text that shows when hovering the drawable.
+        /// </summary>
+        object TooltipContent { get; }
     }
 }

osu.Framework/Graphics/Cursor/IHasTooltip.cs

···
     /// Implementing this interface allows the implementing <see cref="Drawable"/> to display a tooltip if it is the child of a <see cref="TooltipContainer"/>. The tooltip used is
     /// dependent on the implementation of the <see cref="TooltipContainer.CreateTooltip"/> method of the <see cref="TooltipContainer"/> containing this <see cref="Drawable"/>.
     /// </summary>
-    public interface IHasTooltip : IDrawable
+    public interface IHasTooltip : ITooltipContentProvider
     {
         /// <summary>
-        /// Tooltip that shows when hovering the drawable.
+        /// Tooltip text that shows when hovering the drawable.
         /// </summary>
         string TooltipText { get; }
     }

osu.Framework/Graphics/Cursor/ITooltip.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 osuTK;
 
 namespace osu.Framework.Graphics.Cursor
···
         /// <summary>
         /// The text to display on the tooltip.
         /// </summary>
+        [Obsolete]
         string TooltipText { set; }
+
+        /// <summary>
+        /// Set new content be displayed on this tooltip.
+        /// </summary>
+        /// <param name="content">The content to be displayed.</param>
+        /// <returns>Whether this <see cref="ITooltip"/> can display the provided content.</returns>
+        bool SetContent(object content);
 
         /// <summary>
         /// Refreshes the tooltip, updating potential non-text elements such as textures and colours.

osu.Framework/Graphics/Cursor/ITooltipContentProvider.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.
+
+namespace osu.Framework.Graphics.Cursor
+{
+    /// <summary>
+    /// Marker interface for interfaces that provide tooltip content.
+    /// </summary>
+    public interface ITooltipContentProvider : IDrawable
+    {
+    }
+}

osu.Framework/Graphics/Cursor/TooltipContainer.cs

···
     /// <summary>
     /// Displays Tooltips for all its children that inherit from the <see cref="IHasTooltip"/> or <see cref="IHasCustomTooltip"/> interfaces. Keep in mind that only children with <see cref="Drawable.HandlePositionalInput"/> set to true will be checked for their tooltips.
     /// </summary>
-    public class TooltipContainer : CursorEffectContainer<TooltipContainer, IHasTooltip>, IHandleGlobalInput
+    public class TooltipContainer : CursorEffectContainer<TooltipContainer, ITooltipContentProvider>, IHandleGlobalInput
     {
         private readonly CursorContainer cursorContainer;
         private readonly ITooltip defaultTooltip;
···
         /// </summary>
         protected virtual float AppearRadius => 20;
 
-        private IHasTooltip currentlyDisplayed;
+        private ITooltipContentProvider currentlyDisplayed;
 
         /// <summary>
         /// Creates a new tooltip. Can be overridden to supply custom subclass of <see cref="Tooltip"/>.
         /// </summary>
         protected virtual ITooltip CreateTooltip() => new Tooltip();
 
-        private bool hasValidTooltip(IHasTooltip target) => !string.IsNullOrEmpty(target?.TooltipText);
+        private bool hasValidTooltip(ITooltipContentProvider target)
+        {
+            var targetContent = getTargetContent(target);
+
+            if (targetContent is string strContent)
+                return !string.IsNullOrEmpty(strContent);
+
+            return targetContent != null;
+        }
 
         private readonly Container content;
         protected override Container<Drawable> Content => content;
···
             public Vector2 Position;
         }
 
+        private object getTargetContent(ITooltipContentProvider target) => (target as IHasCustomTooltip)?.TooltipContent ?? (target as IHasTooltip)?.TooltipText;
+
         protected override void Update()
         {
             base.Update();
 
-            IHasTooltip target = findTooltipTarget();
+            ITooltipContentProvider target = findTooltipTarget();
 
             if (target != null && target != currentlyDisplayed)
             {
                 currentlyDisplayed = target;
 
-                var newTooltip = getTooltip(target);
+                if (CurrentTooltip?.SetContent(getTargetContent(target)) != true)
+                {
+                    var newTooltip = getTooltip(target);
 
-                if (newTooltip != CurrentTooltip)
-                {
                     RemoveInternal((Drawable)CurrentTooltip);
                     CurrentTooltip = newTooltip;
                     AddInternal((Drawable)newTooltip);
···
             }
         }
 
+        protected override void UpdateAfterChildren()
+        {
+            base.UpdateAfterChildren();
+
+            RefreshTooltip(CurrentTooltip, currentlyDisplayed);
+
+            if (currentlyDisplayed != null && ShallHideTooltip(currentlyDisplayed))
+                hideTooltip();
+        }
+
         private readonly List<TimedPosition> recentMousePositions = new List<TimedPosition>();
         private double lastRecordedPositionTime;
 
-        private IHasTooltip lastCandidate;
+        private ITooltipContentProvider lastCandidate;
 
         /// <summary>
         /// Determines which drawable should currently receive a tooltip, taking into account
···
         /// target is found.
         /// </summary>
         /// <returns>The tooltip target. null if no valid one is found.</returns>
-        private IHasTooltip findTooltipTarget()
+        private ITooltipContentProvider findTooltipTarget()
         {
             // While we are dragging a tooltipped drawable we should show a tooltip for it.
             if (inputManager.DraggedDrawable is IHasTooltip draggedTarget)
                 return hasValidTooltip(draggedTarget) ? draggedTarget : null;
 
-            IHasTooltip targetCandidate = FindTargets().Find(t => t.TooltipText != null);
+            if (inputManager.DraggedDrawable is IHasCustomTooltip customDraggedTarget)
+                return customDraggedTarget;
+
+            ITooltipContentProvider targetCandidate = FindTargets().Find(hasValidTooltip);
 
             // check this first - if we find no target candidate we still want to clear the recorded positions and update the lastCandidate.
             if (targetCandidate != lastCandidate)
···
         /// </summary>
         /// <param name="tooltip">The tooltip that is refreshed.</param>
         /// <param name="tooltipTarget">The target of the tooltip.</param>
-        protected virtual void RefreshTooltip(ITooltip tooltip, IHasTooltip tooltipTarget)
+        protected virtual void RefreshTooltip(ITooltip tooltip, ITooltipContentProvider tooltipTarget)
         {
             bool isValid = tooltipTarget != null && hasValidTooltip(tooltipTarget);
 
             if (isValid)
             {
-                tooltip.TooltipText = tooltipTarget.TooltipText;
+                tooltip.SetContent(getTargetContent(tooltipTarget));
                 tooltip.Refresh();
             }
 
···
                 tooltip.Move(computeTooltipPosition());
         }
 
-        protected override void UpdateAfterChildren()
-        {
-            base.UpdateAfterChildren();
-
-            RefreshTooltip(CurrentTooltip, currentlyDisplayed);
-
-            if (currentlyDisplayed != null && ShallHideTooltip(currentlyDisplayed))
-                hideTooltip();
-        }
-
         private void hideTooltip()
         {
             CurrentTooltip.Hide();
···
         /// </summary>
         /// <param name="tooltipTarget">The target of the tooltip.</param>
         /// <returns>True if the currently visible tooltip should be hidden, false otherwise.</returns>
-        protected virtual bool ShallHideTooltip(IHasTooltip tooltipTarget) => !hasValidTooltip(tooltipTarget) || !tooltipTarget.IsHovered && !tooltipTarget.IsDragged;
+        protected virtual bool ShallHideTooltip(ITooltipContentProvider tooltipTarget) => !hasValidTooltip(tooltipTarget) || !tooltipTarget.IsHovered && !tooltipTarget.IsDragged;
 
-        private ITooltip getTooltip(IHasTooltip target) => (target as IHasCustomTooltip)?.GetCustomTooltip() ?? defaultTooltip;
+        private ITooltip getTooltip(ITooltipContentProvider target) => (target as IHasCustomTooltip)?.GetCustomTooltip() ?? defaultTooltip;
 
         /// <summary>
         /// The default tooltip. Simply displays its text on a gray background and performs no easing.
···
             /// </summary>
             public virtual string TooltipText
             {
-                set => text.Text = value;
+                set => SetContent(value);
+            }
+
+            public bool SetContent(object content)
+            {
+                text.Text = content.ToString();
+                return true;
             }
 
             private const float text_size = 16;