Rename RearrangeableListItem

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

···
                 string itemString = i.ToString();
 
                 AddStep($"add item \"{itemString}\"", () => list.Items.Add(itemString));
-                AddAssert($"last item is \"{itemString}\"", () => list.ChildrenOfType<DrawableRearrangeableListItem<string>>().Last().Model == itemString);
+                AddAssert($"last item is \"{itemString}\"", () => list.ChildrenOfType<RearrangeableListItem<string>>().Last().Model == itemString);
             }
         }
 
···
                 string itemString = i.ToString();
 
                 AddStep($"remove item \"{itemString}\"", () => list.Items.Remove(itemString));
-                AddAssert($"first item is not \"{itemString}\"", () => list.ChildrenOfType<DrawableRearrangeableListItem<string>>().FirstOrDefault()?.Model != itemString);
+                AddAssert($"first item is not \"{itemString}\"", () => list.ChildrenOfType<RearrangeableListItem<string>>().FirstOrDefault()?.Model != itemString);
             }
         }
 
···
 
             AddStep("clear items", () => list.Items.Clear());
 
-            AddAssert("no items contained", () => !list.ChildrenOfType<DrawableRearrangeableListItem<string>>().Any());
+            AddAssert("no items contained", () => !list.ChildrenOfType<RearrangeableListItem<string>>().Any());
         }
 
         [Test]
···
                 () => list.Items.SequenceEqual(sequence.Select(value => value.ToString())));
         }
 
-        private DrawableRearrangeableListItem<string> getItem(int index)
-            => list.ChildrenOfType<DrawableRearrangeableListItem<string>>().First(i => i.Model == index.ToString());
+        private RearrangeableListItem<string> getItem(int index)
+            => list.ChildrenOfType<RearrangeableListItem<string>>().First(i => i.Model == index.ToString());
 
-        private BasicDrawableRearrangeableListItem<string>.Button getDragger(int index)
-            => list.ChildrenOfType<BasicDrawableRearrangeableListItem<string>>().First(i => i.Model == index.ToString())
-                   .ChildrenOfType<BasicDrawableRearrangeableListItem<string>.Button>().First();
+        private BasicRearrangeableListItem<string>.Button getDragger(int index)
+            => list.ChildrenOfType<BasicRearrangeableListItem<string>>().First(i => i.Model == index.ToString())
+                   .ChildrenOfType<BasicRearrangeableListItem<string>.Button>().First();
 
         private class TestRearrangeableList : BasicRearrangeableListContainer<string>
         {
             public float ScrollPosition => ScrollContainer.Current;
 
             public void ScrollTo(string item)
-                => ScrollContainer.ScrollTo(this.ChildrenOfType<BasicDrawableRearrangeableListItem<string>>().First(i => i.Model == item), false);
+                => ScrollContainer.ScrollTo(this.ChildrenOfType<BasicRearrangeableListItem<string>>().First(i => i.Model == item), false);
         }
     }
 }

osu.Framework/Graphics/Containers/DrawableRearrangeableListItem.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 osu.Framework.Input.Events;
-using osuTK;
-
-namespace osu.Framework.Graphics.Containers
-{
-    public abstract class DrawableRearrangeableListItem<TModel> : CompositeDrawable
-    {
-        internal Action<DrawableRearrangeableListItem<TModel>, DragStartEvent> StartArrangement;
-
-        internal Action<DrawableRearrangeableListItem<TModel>, DragEvent> Arrange;
-
-        internal Action<DrawableRearrangeableListItem<TModel>, DragEndEvent> EndArrangement;
-
-        /// <summary>
-        /// The item this <see cref="DrawableRearrangeableListItem{TModel}"/> represents.
-        /// </summary>
-        public TModel Model;
-
-        /// <summary>
-        /// Creates a new <see cref="DrawableRearrangeableListItem{TModel}"/>.
-        /// </summary>
-        /// <param name="item">The item to represent.</param>
-        protected DrawableRearrangeableListItem(TModel item)
-        {
-            Model = item;
-        }
-
-        /// <summary>
-        /// Returns whether the item is currently able to be dragged.
-        /// </summary>
-        protected virtual bool IsDraggableAt(Vector2 screenSpacePos) => true;
-
-        protected override bool OnDragStart(DragStartEvent e)
-        {
-            if (IsDraggableAt(e.ScreenSpaceMouseDownPosition))
-            {
-                StartArrangement?.Invoke(this, e);
-                return true;
-            }
-
-            return false;
-        }
-
-        protected override void OnDrag(DragEvent e) => Arrange?.Invoke(this, e);
-
-        protected override void OnDragEnd(DragEndEvent e) => EndArrangement?.Invoke(this, e);
-    }
-}

osu.Framework/Graphics/Containers/RearrangeableListContainer.cs

···
         protected readonly ScrollContainer<Drawable> ScrollContainer;
 
         /// <summary>
-        /// The <see cref="FillFlowContainer"/> containing of all the <see cref="DrawableRearrangeableListItem{TModel}"/>s.
+        /// The <see cref="FillFlowContainer"/> containing of all the <see cref="RearrangeableListItem{TModel}"/>s.
         /// </summary>
-        protected readonly FillFlowContainer<DrawableRearrangeableListItem<TModel>> ListContainer;
+        protected readonly FillFlowContainer<RearrangeableListItem<TModel>> ListContainer;
 
         /// <summary>
-        /// The mapping of <see cref="TModel"/> to <see cref="DrawableRearrangeableListItem{TModel}"/>.
+        /// The mapping of <see cref="TModel"/> to <see cref="RearrangeableListItem{TModel}"/>.
         /// </summary>
-        protected IReadOnlyDictionary<TModel, DrawableRearrangeableListItem<TModel>> ItemMap => itemMap;
+        protected IReadOnlyDictionary<TModel, RearrangeableListItem<TModel>> ItemMap => itemMap;
 
-        private readonly Dictionary<TModel, DrawableRearrangeableListItem<TModel>> itemMap = new Dictionary<TModel, DrawableRearrangeableListItem<TModel>>();
-        private DrawableRearrangeableListItem<TModel> currentlyDraggedItem;
+        private readonly Dictionary<TModel, RearrangeableListItem<TModel>> itemMap = new Dictionary<TModel, RearrangeableListItem<TModel>>();
+        private RearrangeableListItem<TModel> currentlyDraggedItem;
         private Vector2 screenSpaceDragPosition;
         private bool isCurrentlyRearranging; // Will be true only for the duration that indices are being moved around
 
···
                 ListContainer.SetLayoutPosition(itemMap[Items[i]], i);
         }
 
-        private void startArrangement(DrawableRearrangeableListItem<TModel> item, DragStartEvent e)
+        private void startArrangement(RearrangeableListItem<TModel> item, DragStartEvent e)
         {
             currentlyDraggedItem = item;
             screenSpaceDragPosition = e.ScreenSpaceMousePosition;
         }
 
-        private void arrange(DrawableRearrangeableListItem<TModel> item, DragEvent e) => screenSpaceDragPosition = e.ScreenSpaceMousePosition;
+        private void arrange(RearrangeableListItem<TModel> item, DragEvent e) => screenSpaceDragPosition = e.ScreenSpaceMousePosition;
 
-        private void endArrangement(DrawableRearrangeableListItem<TModel> item, DragEndEvent e) => currentlyDraggedItem = null;
+        private void endArrangement(RearrangeableListItem<TModel> item, DragEndEvent e) => currentlyDraggedItem = null;
 
         protected override void Update()
         {
···
         /// <summary>
         /// Creates the <see cref="FillFlowContainer{DrawableRearrangeableListItem}"/> for the items.
         /// </summary>
-        protected virtual FillFlowContainer<DrawableRearrangeableListItem<TModel>> CreateListFillFlowContainer() => new FillFlowContainer<DrawableRearrangeableListItem<TModel>>();
+        protected virtual FillFlowContainer<RearrangeableListItem<TModel>> CreateListFillFlowContainer() => new FillFlowContainer<RearrangeableListItem<TModel>>();
 
         /// <summary>
         /// Creates the <see cref="ScrollContainer"/> for the list of items.
···
         /// Creates the <see cref="Drawable"/> representation of an item.
         /// </summary>
         /// <param name="item">The item to create the <see cref="Drawable"/> representation of.</param>
-        /// <returns>The <see cref="DrawableRearrangeableListItem{T}"/>.</returns>
-        protected abstract DrawableRearrangeableListItem<TModel> CreateDrawable(TModel item);
+        /// <returns>The <see cref="RearrangeableListItem{TModel}"/>.</returns>
+        protected abstract RearrangeableListItem<TModel> CreateDrawable(TModel item);
     }
 }

osu.Framework/Graphics/Containers/RearrangeableListItem.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 osu.Framework.Input.Events;
+using osuTK;
+
+namespace osu.Framework.Graphics.Containers
+{
+    /// <summary>
+    /// An item of a <see cref="RearrangeableListContainer{TModel}"/>.
+    /// </summary>
+    /// <typeparam name="TModel"></typeparam>
+    public abstract class RearrangeableListItem<TModel> : CompositeDrawable
+    {
+        /// <summary>
+        /// Invoked on drag start, if an arrangement should be started.
+        /// </summary>
+        internal Action<RearrangeableListItem<TModel>, DragStartEvent> StartArrangement;
+
+        /// <summary>
+        /// Invoked on drag, if this item is being arranged.
+        /// </summary>
+        internal Action<RearrangeableListItem<TModel>, DragEvent> Arrange;
+
+        /// <summary>
+        /// Invoked on drag end, if this item is being arranged.
+        /// </summary>
+        internal Action<RearrangeableListItem<TModel>, DragEndEvent> EndArrangement;
+
+        /// <summary>
+        /// The item this <see cref="RearrangeableListItem{TModel}"/> represents.
+        /// </summary>
+        public TModel Model;
+
+        /// <summary>
+        /// Creates a new <see cref="RearrangeableListItem{TModel}"/>.
+        /// </summary>
+        /// <param name="item">The item to represent.</param>
+        protected RearrangeableListItem(TModel item)
+        {
+            Model = item;
+        }
+
+        /// <summary>
+        /// Whether the item is able to be dragged at the given screen-space position.
+        /// </summary>
+        protected virtual bool IsDraggableAt(Vector2 screenSpacePos) => true;
+
+        protected override bool OnDragStart(DragStartEvent e)
+        {
+            if (IsDraggableAt(e.ScreenSpaceMouseDownPosition))
+            {
+                StartArrangement?.Invoke(this, e);
+                return true;
+            }
+
+            return false;
+        }
+
+        protected override void OnDrag(DragEvent e) => Arrange?.Invoke(this, e);
+
+        protected override void OnDragEnd(DragEndEvent e) => EndArrangement?.Invoke(this, e);
+    }
+}

osu.Framework/Graphics/UserInterface/BasicRearrangeableListContainer.cs

···
 {
     public class BasicRearrangeableListContainer<TModel> : RearrangeableListContainer<TModel>
     {
-        protected override FillFlowContainer<DrawableRearrangeableListItem<TModel>> CreateListFillFlowContainer() => base.CreateListFillFlowContainer().With(d =>
+        protected override FillFlowContainer<RearrangeableListItem<TModel>> CreateListFillFlowContainer() => base.CreateListFillFlowContainer().With(d =>
         {
             d.LayoutDuration = 160;
             d.LayoutEasing = Easing.OutQuint;
···
             d.Padding = new MarginPadding(5);
         });
 
-        protected sealed override DrawableRearrangeableListItem<TModel> CreateDrawable(TModel item) => CreateBasicItem(item).With(d =>
+        protected sealed override RearrangeableListItem<TModel> CreateDrawable(TModel item) => CreateBasicItem(item).With(d =>
         {
             d.RequestRemoval += _ => Items.Remove(item);
         });
 
-        protected virtual BasicDrawableRearrangeableListItem<TModel> CreateBasicItem(TModel item) => new BasicDrawableRearrangeableListItem<TModel>(item);
+        protected virtual BasicRearrangeableListItem<TModel> CreateBasicItem(TModel item) => new BasicRearrangeableListItem<TModel>(item);
     }
 
-    public class BasicDrawableRearrangeableListItem<TModel> : DrawableRearrangeableListItem<TModel>
+    public class BasicRearrangeableListItem<TModel> : RearrangeableListItem<TModel>
     {
-        internal Action<DrawableRearrangeableListItem<TModel>> RequestRemoval;
+        internal Action<RearrangeableListItem<TModel>> RequestRemoval;
 
         private readonly bool removable;
         private Drawable dragHandle;
 
-        public BasicDrawableRearrangeableListItem(TModel item, bool removable = false)
+        public BasicRearrangeableListItem(TModel item, bool removable = false)
             : base(item)
         {
             this.removable = removable;