Add property viewer to DrawVisualiser

osu.Framework/Audio/AudioManager.cs

@@ -371,5 +371,7 @@ private void checkAudioDeviceChanged()
             {
             }
         }
+
+        public override string ToString() => $@"AudioManager ({currentAudioDevice})";
     }
 }

osu.Framework/Graphics/Colour/ColourInfo.cs

@@ -197,6 +197,14 @@ public float MaxAlpha
             }
         }
 
+        public override string ToString()
+        {
+            if (HasSingleColour)
+                return $@"{TopLeft} (Single)";
+
+            else return $@"{TopLeft}, {TopRight}, {BottomLeft}, {BottomRight}";
+        }
+
         public static implicit operator ColourInfo(SRGBColour colour) => SingleColour(colour);
         public static implicit operator ColourInfo(Color4 colour) => (SRGBColour)colour;
     }

osu.Framework/Graphics/Colour/SRGBColour.cs

@@ -45,5 +45,6 @@ public struct SRGBColour : IEquatable<SRGBColour>
         public void MultiplyAlpha(float alpha) => Linear.A *= alpha;
 
         public bool Equals(SRGBColour other) => Linear.Equals(other.Linear);
+        public override string ToString() => Linear.ToString();
     }
 }

osu.Framework/Graphics/Containers/ContainerDrawNode.cs

@@ -67,6 +67,8 @@ public struct EdgeEffect : IEquatable<EdgeEffect>
             Type == other.Type &&
             Roundness == other.Roundness &&
             Radius == other.Radius;
+
+        public override string ToString() => $@"{Radius} {Type}EdgeEffect";
     }
 
     /// <summary>

osu.Framework/Graphics/DrawInfo.cs

@@ -77,5 +77,7 @@ public bool Equals(DrawInfo other)
         {
             return Matrix.Equals(other.Matrix) && Colour.Equals(other.Colour) && Blending.Equals(other.Blending);
         }
+
+        public override string ToString() => $@"{GetType().Name.Replace(@"DrawInfo", string.Empty)} DrawInfo";
     }
 }

osu.Framework/Graphics/MarginPadding.cs

@@ -43,6 +43,8 @@ public bool Equals(MarginPadding other)
             return Top == other.Top && Left == other.Left && Bottom == other.Bottom && Right == other.Right;
         }
 
+        public override string ToString() => $@"({Top}, {Left}, {Bottom}, {Right})";
+
         public static MarginPadding operator -(MarginPadding mp)
         {
             return new MarginPadding

osu.Framework/Graphics/Shaders/Shader.cs

@@ -168,6 +168,8 @@ public void Unbind()
             IsBound = false;
         }
 
+        public override string ToString() => $@"{name} Shader (Compiled: {programID != -1})";
+
         /// <summary>
         /// Returns a uniform from the shader.
         /// </summary>

osu.Framework/Graphics/Textures/Texture.cs

@@ -202,6 +202,8 @@ public void DrawQuad(Quad vertexQuad, ColourInfo colour, RectangleF? textureRect
 
             TextureGL.DrawQuad(vertexQuad, TextureBounds(textureRect), colour, vertexAction, inflationPercentage);
         }
+
+        public override string ToString() => $@"{AssetName} ({Width}, {Height})";
     }
 
     public class TextureWhitePixel : Texture

osu.Framework/Graphics/Visualisation/DrawVisualiser.cs

@@ -8,12 +8,20 @@
 using osu.Framework.Input;
 using osu.Framework.Threading;
 using osu.Framework.Lists;
+using System;
+using System.Reflection;
+using System.Collections.Generic;
+using OpenTK.Graphics;
 
 namespace osu.Framework.Graphics.Visualisation
 {
     public class DrawVisualiser : OverlayContainer
     {
-        private readonly TreeContainer treeContainer;
+        internal readonly TreeContainer treeContainer;
+        internal readonly PropertyDisplay propertyDisplay;
+
+        internal VisualisedDrawable highlighted;
+        private Box highlightMarker;
 
         private readonly InfoOverlay overlay;
         private ScheduledDelegate task;
@@ -26,17 +34,26 @@ public DrawVisualiser()
             RelativeSizeAxes = Axes.Both;
             Children = new Drawable[]
             {
-                overlay = new InfoOverlay(),
+                overlay = new InfoOverlay()
+                {
+                    Depth = float.MaxValue
+                },
+                propertyDisplay = new PropertyDisplay
+                {
+                    Depth = float.MinValue
+                },
                 treeContainer = new TreeContainer
                 {
-                    Depth = float.MinValue,
+                    Depth = 0f,                         // Below property display
                     ChooseTarget = chooseTarget,
                     GoUpOneParent = delegate
                     {
                         var parent = Target?.Parent;
                         if (parent?.Parent != null)
                             Target = Target?.Parent;
-                    }
+                    },
+                    ToggleProperties = propertyDisplay.ToggleVisibility,
+
                 },
                 new CursorContainer()
             };
@@ -72,12 +89,15 @@ private void chooseTarget()
         {
             Target = null;
             targetSearching = true;
+
+            propertyDisplay.State = Visibility.Hidden;
         }
 
         private Drawable findTargetIn(Drawable d, InputState state)
         {
             if (d is DrawVisualiser) return null;
             if (d is CursorContainer) return null;
+            if (d is PropertyDisplay) return null;
 
             if (!d.IsPresent) return null;
 
@@ -131,7 +151,12 @@ private void createRootVisualisedDrawable()
                 treeContainer.Add(targetDrawable);
 
                 runUpdate(); // run an initial update to immediately show the selected hierarchy.
+
+                // Update property viewer
+                setHighlight(targetDrawable);
             }
+
+            propertyDisplay.State = Visibility.Visible;
         }
 
         private IDrawable target;
@@ -152,6 +177,21 @@ private void runUpdate()
 
             visualise(Target, targetDrawable);
         }
+        private void updatePropertyDisplay(IDrawable d)
+        {
+            propertyDisplay.Clear(true);
+
+            if (d == null)
+                return;
+
+            Type type = d.GetType();
+
+            propertyDisplay.Add(
+                ((IEnumerable<MemberInfo>)type.GetProperties(BindingFlags.Instance | BindingFlags.Public))      // Get all properties
+                .Concat(type.GetFields(BindingFlags.Instance | BindingFlags.Public))                            // And all fields
+                .OrderBy(member => member.Name)
+                .Select(member => new PropertyItem(member, d)));
+        }
 
         private void updateHoveredDrawable()
         {
@@ -160,9 +200,10 @@ private void updateHoveredDrawable()
 
         private VisualisedDrawable createVisualisedDrawable(VisualisedDrawable parent, Drawable target)
         {
-            var vis = new VisualisedDrawable(parent, target, treeContainer)
+            var vis = new VisualisedDrawable(parent, target, this)
             {
-                RequestTarget = delegate { Target = target; }
+                RequestTarget = delegate { Target = target; },
+                HighlightTarget = setHighlight
             };
 
             vis.HoverGained = delegate
@@ -179,6 +220,25 @@ private VisualisedDrawable createVisualisedDrawable(VisualisedDrawable parent, D
 
             return vis;
         }
+        private void setHighlight(VisualisedDrawable newHighlight)
+        {
+            // Remove marker from previous highlight
+            if (highlightMarker != null && highlightMarker.Parent != null)
+                ((IContainerCollection<Drawable>)highlightMarker.Parent).Remove(highlightMarker);
+
+            highlightMarker = new Box()
+            {
+                RelativeSizeAxes = Axes.Both,
+                Alpha = 0.1f,
+                Colour = Color4.Khaki
+            };
+            newHighlight.Add(highlightMarker);
+
+            newHighlight.Expand();
+
+            highlighted = newHighlight;
+            updatePropertyDisplay(newHighlight.Target);
+        }
 
         private void visualise(IDrawable d, VisualisedDrawable vis)
         {

osu.Framework/Graphics/Visualisation/PropertyDisplay.cs

@@ -0,0 +1,163 @@
+using OpenTK;
+using OpenTK.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Input;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace osu.Framework.Graphics.Visualisation
+{
+    internal class PropertyDisplay : OverlayContainer
+    {
+        private readonly FillFlowContainer flow;
+
+        private const float width = 600;
+        private const float height = 400;
+
+        private readonly Box titleBar;
+
+        protected override Container<Drawable> Content => flow;
+
+        public PropertyDisplay()
+        {
+            Masking = true;
+            CornerRadius = 5;
+            Anchor = Origin = Anchor.BottomRight;
+            Position = new Vector2(-20);
+            Size = new Vector2(width, height);
+            AddInternal(new Drawable[]
+            {
+                new Box
+                {
+                    Colour = new Color4(30, 30, 30, 240),
+                    RelativeSizeAxes = Axes.Both,
+                    Depth = 0
+                },
+                titleBar = new Box //title decoration
+                {
+                    Colour = Color4.DarkBlue,
+                    RelativeSizeAxes = Axes.X,
+                    Size = new Vector2(1, 20),
+                },
+                new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding { Top = 20 },
+                    Children = new[]
+                    {
+                        new ScrollContainer
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            ScrollbarOverlapsContent = false,
+                            Children = new[]
+                            {
+                                flow = new FillFlowContainer()
+                                {
+                                    RelativeSizeAxes = Axes.X,
+                                    AutoSizeAxes = Axes.Y,
+                                    Direction = FillDirection.Vertical
+                                }
+                            },
+                        }
+                    }
+                },
+            });
+        }
+
+        protected override bool OnDragStart(InputState state) => titleBar.Contains(state.Mouse.NativeState.Position);
+
+        protected override bool OnDrag(InputState state)
+        {
+            Position += state.Mouse.Delta;
+            return base.OnDrag(state);
+        }
+
+        protected override void PopIn()
+        {
+            FadeTo(0.7f, 100);
+        }
+        protected override void PopOut()
+        {
+            FadeOut(100);
+        }
+    }
+
+    internal class PropertyItem : ClickableContainer
+    {
+        private readonly SpriteText nameText;
+        private readonly SpriteText valueText;
+
+        private readonly Box box;
+
+        private readonly Func<string> getValue;     // Use delegate for performance
+
+        public PropertyItem(MemberInfo info, IDrawable d)
+        {
+            try
+            {
+                switch (info.MemberType)
+                {
+                    case MemberTypes.Property:
+                        getValue = ((PropertyInfo)info).GetValue(d).ToString;
+                        break;
+
+                    case MemberTypes.Field:
+                        getValue = ((FieldInfo)info).GetValue(d).ToString;
+                        break;
+                }
+            }
+            catch
+            {
+                getValue = () => @"<Cannot evaluate>";
+            }
+
+            RelativeSizeAxes = Axes.X;
+            Height = 20f;
+            AddInternal(new Drawable[]
+            {
+                box = new Box()
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = Color4.White,
+                    Alpha = 0f
+                },
+                nameText = new SpriteText()
+                {
+                    Text = info.Name,
+                    TextSize = Height
+                },
+                valueText = new SpriteText()
+                {
+                    Anchor = Anchor.TopRight,
+                    Origin = Anchor.TopRight,
+                    TextSize = Height
+                }
+            });
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            // Update value
+            valueText.Text = getValue();
+        }
+
+        protected override bool OnHover(InputState state)
+        {
+            box.FadeTo(0.2f, 100);
+
+            return true;
+        }
+        protected override void OnHoverLost(InputState state)
+        {
+            box.FadeOut(100);
+        }
+    }
+}