Apply line formatting changes in line with osu inspections

osu-framework.sln.DotSettings

···
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTLINE_TYPE_PARAMETER_CONSTRAINS/@EntryValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTLINE_TYPE_PARAMETER_LIST/@EntryValue">True</s:Boolean>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ANONYMOUS_METHOD_DECLARATION_BRACES/@EntryValue">NEXT_LINE</s:String>
+	<s:Int64 x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/BLANK_LINES_BEFORE_BLOCK_STATEMENTS/@EntryValue">1</s:Int64>
+	<s:Int64 x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/BLANK_LINES_BEFORE_CASE/@EntryValue">1</s:Int64>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/INITIALIZER_BRACES/@EntryValue">NEXT_LINE</s:String>
 	<s:Int64 x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/KEEP_BLANK_LINES_IN_CODE/@EntryValue">1</s:Int64>
 	<s:Int64 x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/KEEP_BLANK_LINES_IN_DECLARATIONS/@EntryValue">1</s:Int64>
···
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=MD/@EntryIndexedValue">MD5</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=NS/@EntryIndexedValue">NS</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=OS/@EntryIndexedValue">OS</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=PM/@EntryIndexedValue">PM</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=RGB/@EntryIndexedValue">RGB</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=RNG/@EntryIndexedValue">RNG</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=SHA/@EntryIndexedValue">SHA</s:String>

osu.Framework.Tests/Clocks/InterpolatingClockTest.cs

···
 
             // test with test clock not elapsing
             double lastValue = interpolating.CurrentTime;
+
             for (int i = 0; i < 100; i++)
             {
                 interpolating.ProcessFrame();
···
 
             // test with test clock elapsing
             lastValue = interpolating.CurrentTime;
+
             for (int i = 0; i < 100; i++)
             {
                 source.CurrentTime += 50;

osu.Framework.Tests/IO/TestDesktopStorage.cs

···
         public void TestRelativePaths()
         {
             var guid = new Guid().ToString();
+
             using (var storage = new TemporaryNativeStorage(guid))
             {
                 var basePath = storage.GetFullPath(string.Empty);

osu.Framework.Tests/IO/TestWebRequest.cs

···
             List<long> startTimes = new List<long>();
 
             List<Task> running = new List<Task>();
+
             for (int i = 0; i < request_count; i++)
             {
                 var request = new DelayedWebRequest
···
             Assert.DoesNotThrow(request.Perform);
 
             var events = request.GetType().GetEvents(BindingFlags.Instance | BindingFlags.Public);
+
             foreach (var e in events)
             {
                 var field = request.GetType().GetField(e.Name, BindingFlags.Instance | BindingFlags.Public);
···
         public void TestUnbindOnDispose([Values(true, false)] bool async)
         {
             WebRequest request;
+
             using (request = new JsonWebRequest<HttpBinGetResponse>($"{default_protocol}://{host}/get")
             {
                 Method = HttpMethod.Get,
···
             }
 
             var events = request.GetType().GetEvents(BindingFlags.Instance | BindingFlags.Public);
+
             foreach (var e in events)
             {
                 var field = request.GetType().GetField(e.Name, BindingFlags.Instance | BindingFlags.Public);

osu.Framework.Tests/Lists/TestArrayExtensions.cs

···
         public void TestNonSquareJaggedWithNullRowsToRectangular()
         {
             var jagged = new int[10][];
+
             for (int i = 1; i < 10; i += 2)
             {
                 if (i % 2 == 1)

osu.Framework.Tests/Lists/TestWeakList.cs

···
             var list = new WeakList<object> { obj, obj2, obj3 };
 
             int count = 0;
+
             foreach (var item in list)
             {
                 if (count == 1)
···
             var list = new WeakList<object> { obj, obj2, obj3 };
 
             int count = 0;
+
             foreach (var item in list)
             {
                 if (count == 0)
···
             GC.WaitForPendingFinalizers();
 
             int index = 0;
+
             foreach (var obj in list)
             {
                 if (alive[index] != obj)

osu.Framework.Tests/Localisation/LocalisationTest.cs

···
                         {
                             default:
                                 return LOCALISABLE_STRING_EN;
+
                             case "ja":
                                 return LOCALISABLE_STRING_JA;
+
                             case "ja-JP":
                                 return LOCALISABLE_STRING_JA_JP;
                         }
···
                         {
                             default:
                                 return LOCALISABLE_FORMAT_STRING_EN;
+
                             case "ja":
                                 return LOCALISABLE_FORMAT_STRING_JA;
                         }

osu.Framework.Tests/Threading/AsyncDisposalQueueTest.cs

···
             objects.ForEach(AsyncDisposalQueue.Enqueue);
 
             int attempts = 1000;
+
             while (!objects.All(o => o.IsDisposed))
             {
                 if (attempts-- == 0)

osu.Framework.Tests/Visual/Containers/TestSceneCompositeMutability.cs

···
                         case LoadState.Loading when thread != TestThread.Load:
                             container.LoadingEvent.Set();
                             break;
+
                         // Special case for the load thread: possibly active during the ready state, but the ready event is handled in the switch below
                         case LoadState.Ready when thread == TestThread.Load:
                             container.LoadingEvent.Set();
                             stateToWaitFor = LoadState.Loading; // We'll never reach the ready state before the switch below
                             break;
+
                         case LoadState.Ready:
                             container.LoadingEvent.Set();
                             container.ReadyEvent.Set();
                             break;
+
                         case LoadState.Loaded:
                             container.LoadingEvent.Set();
                             container.ReadyEvent.Set();
···
                             AddStep("bind event", () => container.OnLoading += tryThrow);
                             AddStep("set loading", () => container.LoadingEvent.Set());
                             break;
+
                         case LoadState.Ready:
                             AddStep("bind event", () => container.OnReady += tryThrow);
                             AddStep("set loading", () => container.ReadyEvent.Set());

osu.Framework.Tests/Visual/Containers/TestSceneContainerState.cs

···
         {
             bool unbound = false;
 
-            var drawableA = new Sprite().With(d =>
-            {
-                d.OnUnbindAllBindables += () => unbound = true;
-            });
+            var drawableA = new Sprite().With(d => { d.OnUnbindAllBindables += () => unbound = true; });
 
             var container = new Container { Children = new[] { drawableA } };
 
···
         {
             bool disposed = false;
 
-            var drawableA = new Sprite().With(d =>
-            {
-                d.OnDispose += () => disposed = true;
-            });
+            var drawableA = new Sprite().With(d => { d.OnDispose += () => disposed = true; });
 
             var container = new Container { Children = new[] { drawableA } };
 
···
 
             // Disposal happens asynchronously
             int iterations = 20;
+
             while (iterations-- > 0)
             {
                 if (disposed)

osu.Framework.Tests/Visual/Containers/TestSceneCoordinateSpaces.cs

···
                     h.CreateMarkerAt(1f);
                     h.CreateMarkerAt(1.1f);
                     break;
+
                 case 1:
                     h.RelativeChildSize = new Vector2(150, 1);
                     h.CreateMarkerAt(0);
···
                     h.CreateMarkerAt(200);
                     h.CreateMarkerAt(250);
                     break;
+
                 case 2:
                     h.RelativeChildOffset = new Vector2(50, 0);
                     h.RelativeChildSize = new Vector2(150, 1);
···
                     h.CreateMarkerAt(200);
                     h.CreateMarkerAt(250);
                     break;
+
                 case 3:
                     h.RelativeChildOffset = new Vector2(150, 0);
                     h.RelativeChildSize = new Vector2(-200, 1);
···
                     h.CreateMarkerAt(200);
                     h.CreateMarkerAt(250);
                     break;
+
                 case 4:
                     h.RelativeChildOffset = new Vector2(0, 0);
                     h.RelativeChildSize = new Vector2(300, 1);
···
                     h.CreateMarkerAt(200);
                     h.CreateMarkerAt(250);
                     break;
+
                 case 5:
                     h.RelativeChildOffset = new Vector2(-250, 0);
                     h.RelativeChildSize = new Vector2(500, 1);

osu.Framework.Tests/Visual/Containers/TestSceneLifetimeManagementContainer.cs

···
             AddAssert($"{numAlive} alive children", () =>
             {
                 int num = 0;
+
                 foreach (var child in container.InternalChildren)
                 {
                     num += child.IsAlive ? 1 : 0;
···
             {
                 l = rng.Next(5);
                 r = rng.Next(5);
+
                 if (l > r)
                 {
                     var l1 = l;
···
             });
 
             int count = 1;
+
             for (int i = 0; i < 1000; i++)
             {
                 switch (rng.Next(3))
···
                         }
 
                         break;
+
                     case 1:
                         AddStep("Change lifetime", changeLifetime);
                         break;
+
                     case 2:
                         AddStep("Change time", changeTime);
                         break;

osu.Framework.Tests/Visual/Containers/TestSceneSizing.cs

···
 
                     box.OnUpdate += delegate { box.Rotation += 0.05f; };
                     break;
+
                 case 1:
                     testContainer.Add(box = new InfofulBoxAutoSize
                     {
···
                         Colour = Color4.Blue,
                     });
                     break;
+
                 case 2:
                     testContainer.Add(box = new InfofulBoxAutoSize
                     {
···
                         Colour = Color4.SeaGreen,
                     });
                     break;
+
                 case 3:
                     testContainer.Add(box = new InfofulBox
                     {
···
                         Colour = Color4.SeaGreen,
                     });
                     break;
+
                 case 4:
                     testContainer.Add(box = new InfofulBoxAutoSize
                     {
···
                         Anchor = Anchor.CentreLeft
                     });
                     break;
+
                 case 5:
                     testContainer.Add(box = new InfofulBoxAutoSize
                     {
···
                         Anchor = Anchor.CentreLeft
                     });
                     break;
+
                 case 6:
                     testContainer.Add(box = new InfofulBoxAutoSize
                     {
···
                         Colour = Color4.OrangeRed,
                     });
                     break;
+
                 case 7:
                     Container shrinkContainer;
                     Container<Drawable> boxes;
···
             if (Chameleon && (int)Time.Current / 1000 != lastSwitch)
             {
                 lastSwitch = (int)Time.Current / 1000;
+
                 switch (lastSwitch % 6)
                 {
                     case 0:
                         Anchor = (Anchor)((int)Anchor + 1);
                         Origin = (Anchor)((int)Origin + 1);
                         break;
+
                     case 1:
                         this.MoveTo(new Vector2(0, 0), 800, Easing.Out);
                         break;
+
                     case 2:
                         this.MoveTo(new Vector2(200, 0), 800, Easing.Out);
                         break;
+
                     case 3:
                         this.MoveTo(new Vector2(200, 200), 800, Easing.Out);
                         break;
+
                     case 4:
                         this.MoveTo(new Vector2(0, 200), 800, Easing.Out);
                         break;
+
                     case 5:
                         this.MoveTo(new Vector2(0, 0), 800, Easing.Out);
                         break;

osu.Framework.Tests/Visual/Drawables/TestSceneProxyDrawables.cs

···
                 RelativeSizeAxes = Axes.Both;
 
                 original = proxy.Original;
+
                 while (original != (original = original.Original))
                 {
                 }

osu.Framework.Tests/Visual/Drawables/TestSceneTransformRewinding.cs

···
                 maxTimeText.Text = wrapping.MaxTime.ToString("n0");
                 maxTimeText.Colour = time > wrapping.MaxTime ? Color4.Gray : wrapping.Time.Elapsed > 0 ? Color4.Blue : Color4.Red;
                 minTimeText.Colour = time < wrapping.MinTime ? Color4.Gray : content.Time.Elapsed > 0 ? Color4.Blue : Color4.Red;
+
                 if (displayedTransforms == null || !ExaminableDrawable.Transforms.SequenceEqual(displayedTransforms))
                 {
                     transforms.Clear();

osu.Framework.Tests/Visual/Input/TestSceneInputResampler.cs

···
             {
                 NumRaw++;
                 bool foundOne = false;
+
                 foreach (Vector2 relevant in InputResampler.AddPosition(pos))
                 {
                     AddVertex(relevant);

osu.Framework.Tests/Visual/Input/TestSceneKeyBindings.cs

···
 
                         Assert.AreEqual(count.OnPressedCount, testButton.OnPressedCount, $"{testButton.Concurrency} {testButton.Action} OnPressedCount");
                         Assert.AreEqual(count.OnReleasedCount, testButton.OnReleasedCount, $"{testButton.Concurrency} {testButton.Action} OnReleasedCount");
+
                         if (testButton is ScrollTestButton scrollTestButton && scrollEntry != null)
                         {
                             Assert.AreEqual(count.OnScrollCount, scrollTestButton.OnScrollCount, $"{testButton.Concurrency} {testButton.Action} OnScrollCount");
···
                 toggleKey(key);
             foreach (var button in pressedMouseButtons.ToArray())
                 toggleMouseButton(button);
+
             foreach (var mode in new[] { none, noneExact, noneModifiers, unique, all })
             {
                 foreach (var action in Enum.GetValues(typeof(TestAction)).Cast<TestAction>())

osu.Framework.Tests/Visual/Input/TestSceneMouseStates.cs

···
                     case MouseMoveEvent mouseMove:
                         LastDelta = mouseMove.ScreenSpaceMousePosition - mouseMove.ScreenSpaceLastMousePosition;
                         break;
+
                     case ScrollEvent scroll:
                         LastScrollDelta = scroll.ScrollDelta;
                         break;
···
                 base.Update();
 
                 var inputManager = GetContainingInputManager();
+
                 if (inputManager != null)
                 {
                     var state = inputManager.CurrentState;

osu.Framework.Tests/Visual/Layout/TestSceneFillFlowContainer.cs

···
                             case 0:
                                 child.Origin = Anchor.TopLeft;
                                 break;
+
                             case 1:
                                 child.Origin = Anchor.TopCentre;
                                 break;
+
                             case 2:
                                 child.Origin = Anchor.TopRight;
                                 break;
+
                             case 3:
                                 child.Origin = Anchor.CentreLeft;
                                 break;
+
                             case 4:
                                 child.Origin = Anchor.Centre;
                                 break;
+
                             case 5:
                                 child.Origin = Anchor.CentreRight;
                                 break;
+
                             case 6:
                                 child.Origin = Anchor.BottomLeft;
                                 break;
+
                             case 7:
                                 child.Origin = Anchor.BottomCentre;
                                 break;
+
                             case 8:
                                 child.Origin = Anchor.BottomRight;
                                 break;

osu.Framework.Tests/Visual/Sprites/TestSceneSpriteIcon.cs

···
             });
 
             var weights = typeof(FontAwesome).GetNestedTypes();
+
             foreach (var w in weights)
             {
                 flow.Add(new SpriteText

osu.Framework.Tests/Visual/Sprites/TestSceneSpriteTextScenarios.cs

···
                         {
                             default:
                                 return LOCALISABLE_STRING_EN;
+
                             case "ja":
                                 return LOCALISABLE_STRING_JA;
                         }

osu.Framework.Tests/Visual/Sprites/TestSceneVideoSprite.cs

···
             if (videoSprite != null)
             {
                 var newSecond = (int)(videoSprite.PlaybackPosition / 1000.0);
+
                 if (newSecond != currentSecond)
                 {
                     currentSecond = newSecond;

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

···
             var image = new Image<Rgba32>(width, 1);
 
             gradientTextureHorizontal = new Texture(width, 1, true);
+
             for (int i = 0; i < width; ++i)
             {
                 float brightness = (float)i / (width - 1);
···
             image = new Image<Rgba32>(width, 1);
 
             gradientTextureVertical = new Texture(1, width, true);
+
             for (int i = 0; i < width; ++i)
             {
                 float brightness = (float)i / (width - 1);
···
             image = new Image<Rgba32>(width, width);
 
             gradientTextureBoth = new Texture(width, width, true);
+
             for (int i = 0; i < width; ++i)
             {
                 for (int j = 0; j < width; ++j)
···
         protected override void Update()
         {
             base.Update();
+
             switch (rotateMode)
             {
                 case 0:
                     clock.Current.Value = Time.Current % (period * 2) / period - 1;
                     break;
+
                 case 1:
                     clock.Current.Value = Time.Current % period / period;
                     break;
+
                 case 2:
                     clock.Current.Value = Time.Current % period / period - 1;
                     break;
+
                 case 3:
                     clock.Current.Value = Time.Current % transition_period / transition_period / 5 - 0.1f;
                     break;
+
                 case 4:
                     clock.Current.Value = (Time.Current % transition_period / transition_period / 5 - 0.1f + 2) % 2 - 1;
                     break;
···
                 case 0:
                     clock.Texture = Texture.WhitePixel;
                     break;
+
                 case 1:
                     clock.Texture = gradientTextureHorizontal;
                     break;
+
                 case 2:
                     clock.Texture = gradientTextureVertical;
                     break;
+
                 case 3:
                     clock.Texture = gradientTextureBoth;
                     break;
···
                 case 0:
                     clock.Colour = new Color4(255, 255, 255, 255);
                     break;
+
                 case 1:
                     clock.Colour = new Color4(255, 128, 128, 255);
                     break;
+
                 case 2:
                     clock.Colour = new ColourInfo
                     {
···
                         BottomRight = new Color4(128, 255, 128, 255),
                     };
                     break;
+
                 case 3:
                     clock.Colour = new ColourInfo
                     {
···
                         BottomRight = new Color4(128, 255, 128, 255),
                     };
                     break;
+
                 case 4:
                     clock.Colour = new ColourInfo
                     {

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

···
                 default:
                 case CountType.AsDouble:
                     return value.ToString(CultureInfo.InvariantCulture);
+
                 case CountType.AsInteger:
                     return ((int)value).ToString();
+
                 case CountType.AsIntegerCeiling:
                     return ((int)Math.Ceiling(value)).ToString();
+
                 case CountType.AsDouble2:
                     return Math.Round(value, 2).ToString(CultureInfo.InvariantCulture);
+
                 case CountType.AsDouble4:
                     return Math.Round(value, 4).ToString(CultureInfo.InvariantCulture);
             }

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

···
             protected override bool OnDrag(DragEvent e)
             {
                 Vector2 pos = e.MousePosition;
+
                 if ((pos - oldPos).Length > 10)
                 {
                     AddVertex(pos);

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

···
             AddAssert("Check closed", () =>
             {
                 int currentSubMenu = 3;
+
                 while (true)
                 {
                     var subMenu = menus.GetSubMenu(currentSubMenu);
···
             AddAssert("Check closed", () =>
             {
                 int currentSubMenu = 3;
+
                 while (true)
                 {
                     var subMenu = menus.GetSubMenu(currentSubMenu);
···
             public Menu GetSubMenu(int index)
             {
                 var currentMenu = menu;
+
                 for (int i = 0; i < index; i++)
                 {
                     if (currentMenu == null)

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

···
             for (int i = 0; i < n; i++)
             {
                 RigidBodyContainer<Drawable> d;
+
                 do
                 {
                     d = generate();

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

···
             AddStep("Setup screens", () =>
             {
                 screens = new List<TestScreen>();
+
                 for (int i = 0; i < 5; i++)
                 {
                     var screen = new TestScreen();

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

···
             testContainer.Clear();
 
             CursorContainer cursor = null;
+
             if (!cursorlessTooltip)
             {
                 cursor = new RectangleCursorContainer();

osu.Framework/Allocation/BackgroundDependencyLoaderAttribute.cs

···
             {
                 case 0:
                     return (_, __) => { };
+
                 case 1:
                     var method = loaderMethods[0];
 
···
                                 case OperationCanceledException _:
                                     // This activator is cancelled - propagate the cancellation as-is (it will be handled silently)
                                     throw exc.InnerException;
+
                                 case DependencyInjectionException die:
                                     // A nested activator has failed (multiple Invoke() calls) - propagate the original error
                                     throw die;
···
                             throw new DependencyInjectionException { DispatchInfo = ExceptionDispatchInfo.Capture(exc.InnerException) };
                         }
                     };
+
                 default:
                     throw new MultipleDependencyLoaderMethodsException(type);
             }

osu.Framework/Allocation/CachedAttribute.cs

···
                         throw new AccessModifierNotAllowedForCachedValueException(AccessModifier.None, pi);
 
                     var setMethod = pi.SetMethod;
+
                     if (setMethod != null)
                     {
                         var modifier = setMethod.GetAccessModifier();

osu.Framework/Allocation/CachedModelDependencyContainer.cs

···
                 case PropertyInfo pi:
                     action(((IBindable)pi.GetValue(targetShadowModel), (IBindable)pi.GetValue(target)));
                     break;
+
                 case FieldInfo fi:
                     action(((IBindable)fi.GetValue(targetShadowModel), (IBindable)fi.GetValue(target)));
                     break;

osu.Framework/Allocation/ObjectHandle.cs

···
             try
             {
                 var value = handle.Target;
+
                 if (value is T)
                 {
                     target = (T)value;

osu.Framework/Allocation/ResolvedAttribute.cs

···
             var activators = new List<Action<object, IReadOnlyDependencyContainer>>();
 
             var properties = type.GetProperties(activator_flags).Where(f => f.GetCustomAttribute<ResolvedAttribute>() != null);
+
             foreach (var property in properties)
             {
                 if (!property.CanWrite)
···
                 var attribute = property.GetCustomAttribute<ResolvedAttribute>();
 
                 var cacheInfo = new CacheInfo(attribute.Name);
+
                 if (attribute.Parent != null)
                 {
                     // When a parent type exists, infer the property name if one is not provided

osu.Framework/Allocation/TripleBuffer.cs

···
 
                     buffers[write].FrameId = Interlocked.Increment(ref currentFrame);
                     return buffers[write];
+
                 case UsageType.Read:
                     if (lastWrite < 0) return null;
 
···
                     lock (buffers)
                         buffers[read].Usage = UsageType.None;
                     break;
+
                 case UsageType.Write:
                     lock (buffers)
                     {

osu.Framework/Audio/AudioManager.cs

···
                 newDevice = audioDevices.Find(df => df.IsDefault).Name;
 
             bool oldDeviceValid = Bass.CurrentDevice >= 0;
+
             if (oldDeviceValid)
             {
                 DeviceInfo oldDeviceInfo = Bass.GetDeviceInfo(Bass.CurrentDevice);
···
                 {
                     // use default device
                     var device = Bass.GetDeviceInfo(Bass.CurrentDevice);
+
                     if (!device.IsDefault && !setAudioDevice())
                     {
                         if (!device.IsEnabled || !setAudioDevice(device.Name))
···
                 {
                     // use whatever is the preferred device
                     var device = Bass.GetDeviceInfo(Bass.CurrentDevice);
+
                     if (device.Name == AudioDevice.Value)
                     {
                         if (!device.IsEnabled && !setAudioDevice())
···
                     else
                     {
                         var preferredDevice = getAllDevices().SingleOrDefault(d => d.Name == AudioDevice.Value);
+
                         if (preferredDevice.Name == AudioDevice.Value && preferredDevice.IsEnabled)
                             setAudioDevice(preferredDevice.Name);
                         else if (!device.IsEnabled && !setAudioDevice())

osu.Framework/Audio/Sample/SampleStore.cs

···
             lock (sampleCache)
             {
                 SampleChannel channel = null;
+
                 if (!sampleCache.TryGetValue(name, out Sample sample))
                 {
                     byte[] data = store.Get(name);

osu.Framework/Audio/Track/Waveform.cs

···
                         // Channels are interleaved in the sample data (data[0] -> channel0, data[1] -> channel1, data[2] -> channel0, etc)
                         // samplesPerPoint assumes this interleaving behaviour
                         var point = new WaveformPoint(info.Channels);
+
                         for (int j = i; j < i + samplesPerPoint; j += info.Channels)
                         {
                             // Find the maximum amplitude for each channel in the point
···
                 float[] bins = new float[fft_bins];
                 int currentPoint = 0;
                 long currentByte = 0;
+
                 while (length > 0)
                 {
                     length = Bass.ChannelGetData(decodeStream, bins, (int)fft_samples);
···
 
                     var point = new WaveformPoint(channels);
                     float totalWeight = 0;
+
                     for (int j = startIndex; j < endIndex; j++)
                     {
                         if (j < 0 || j >= points.Count) continue;

osu.Framework/Bindables/AggregateBindable.cs

···
             lock (sourceMapping)
             {
                 var weak = findExistingWeak(bindable);
+
                 if (weak != null)
                 {
                     sourceMapping[weak].UnbindAll();

osu.Framework/Bindables/Bindable.cs

···
                 case T t:
                     Value = t;
                     break;
+
                 case string s:
                     var underlyingType = Nullable.GetUnderlyingType(typeof(T)) ?? typeof(T);
 
···
                     else
                         Value = (T)Convert.ChangeType(s, underlyingType, CultureInfo.InvariantCulture);
                     break;
+
                 default:
                     throw new ArgumentException($@"Could not parse provided {input.GetType()} ({input}) to {typeof(T)}.");
             }

osu.Framework/Bindables/BindableList.cs

···
                 case null:
                     Clear();
                     break;
+
                 case IEnumerable<T> enumerable:
                     Clear();
                     AddRange(enumerable);
                     break;
+
                 default:
                     throw new ArgumentException($@"Could not parse provided {input.GetType()} ({input}) to {typeof(T)}.");
             }

osu.Framework/Bindables/BindableMarginPadding.cs

···
                         Right = float.Parse(split[3], CultureInfo.InvariantCulture),
                     };
                     break;
+
                 default:
                     base.Parse(input);
                     break;

osu.Framework/Bindables/BindableNumber.cs

···
                     case TypeCode.UInt64:
                     case TypeCode.Int64:
                         return true;
+
                     default:
                         return false;
                 }
···
 
                     byteBindable.Value = Convert.ToByte(val);
                     break;
+
                 case TypeCode.SByte:
                     var sbyteBindable = this as BindableNumber<sbyte>;
                     if (sbyteBindable == null) throw new ArgumentNullException(nameof(sbyteBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     sbyteBindable.Value = Convert.ToSByte(val);
                     break;
+
                 case TypeCode.UInt16:
                     var ushortBindable = this as BindableNumber<ushort>;
                     if (ushortBindable == null) throw new ArgumentNullException(nameof(ushortBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     ushortBindable.Value = Convert.ToUInt16(val);
                     break;
+
                 case TypeCode.Int16:
                     var shortBindable = this as BindableNumber<short>;
                     if (shortBindable == null) throw new ArgumentNullException(nameof(shortBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     shortBindable.Value = Convert.ToInt16(val);
                     break;
+
                 case TypeCode.UInt32:
                     var uintBindable = this as BindableNumber<uint>;
                     if (uintBindable == null) throw new ArgumentNullException(nameof(uintBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     uintBindable.Value = Convert.ToUInt32(val);
                     break;
+
                 case TypeCode.Int32:
                     var intBindable = this as BindableNumber<int>;
                     if (intBindable == null) throw new ArgumentNullException(nameof(intBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     intBindable.Value = Convert.ToInt32(val);
                     break;
+
                 case TypeCode.UInt64:
                     var ulongBindable = this as BindableNumber<ulong>;
                     if (ulongBindable == null) throw new ArgumentNullException(nameof(ulongBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     ulongBindable.Value = Convert.ToUInt64(val);
                     break;
+
                 case TypeCode.Int64:
                     var longBindable = this as BindableNumber<long>;
                     if (longBindable == null) throw new ArgumentNullException(nameof(longBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     longBindable.Value = Convert.ToInt64(val);
                     break;
+
                 case TypeCode.Single:
                     var floatBindable = this as BindableNumber<float>;
                     if (floatBindable == null) throw new ArgumentNullException(nameof(floatBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     floatBindable.Value = Convert.ToSingle(val);
                     break;
+
                 case TypeCode.Double:
                     var doubleBindable = this as BindableNumber<double>;
                     if (doubleBindable == null) throw new ArgumentNullException(nameof(doubleBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
···
 
                     byteBindable.Value += Convert.ToByte(val);
                     break;
+
                 case TypeCode.SByte:
                     var sbyteBindable = this as BindableNumber<sbyte>;
                     if (sbyteBindable == null) throw new ArgumentNullException(nameof(sbyteBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     sbyteBindable.Value += Convert.ToSByte(val);
                     break;
+
                 case TypeCode.UInt16:
                     var ushortBindable = this as BindableNumber<ushort>;
                     if (ushortBindable == null) throw new ArgumentNullException(nameof(ushortBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     ushortBindable.Value += Convert.ToUInt16(val);
                     break;
+
                 case TypeCode.Int16:
                     var shortBindable = this as BindableNumber<short>;
                     if (shortBindable == null) throw new ArgumentNullException(nameof(shortBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     shortBindable.Value += Convert.ToInt16(val);
                     break;
+
                 case TypeCode.UInt32:
                     var uintBindable = this as BindableNumber<uint>;
                     if (uintBindable == null) throw new ArgumentNullException(nameof(uintBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     uintBindable.Value += Convert.ToUInt32(val);
                     break;
+
                 case TypeCode.Int32:
                     var intBindable = this as BindableNumber<int>;
                     if (intBindable == null) throw new ArgumentNullException(nameof(intBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     intBindable.Value += Convert.ToInt32(val);
                     break;
+
                 case TypeCode.UInt64:
                     var ulongBindable = this as BindableNumber<ulong>;
                     if (ulongBindable == null) throw new ArgumentNullException(nameof(ulongBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     ulongBindable.Value += Convert.ToUInt64(val);
                     break;
+
                 case TypeCode.Int64:
                     var longBindable = this as BindableNumber<long>;
                     if (longBindable == null) throw new ArgumentNullException(nameof(longBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     longBindable.Value += Convert.ToInt64(val);
                     break;
+
                 case TypeCode.Single:
                     var floatBindable = this as BindableNumber<float>;
                     if (floatBindable == null) throw new ArgumentNullException(nameof(floatBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     floatBindable.Value += Convert.ToSingle(val);
                     break;
+
                 case TypeCode.Double:
                     var doubleBindable = this as BindableNumber<double>;
                     if (doubleBindable == null) throw new ArgumentNullException(nameof(doubleBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");

osu.Framework/Bindables/BindableSize.cs

···
 
                     Value = new Size(int.Parse(split[0]), int.Parse(split[1]));
                     break;
+
                 default:
                     base.Parse(input);
                     break;

osu.Framework/Extensions/ExtensionMethods.cs

···
                 return null;
 
             var jagged = new T[rectangular.GetLength(0)][];
+
             for (int r = 0; r < rectangular.GetLength(0); r++)
             {
                 jagged[r] = new T[rectangular.GetLength(1)];
···
             var cols = rows == 0 ? 0 : jagged.Max(c => c?.Length ?? 0);
 
             var rectangular = new T[rows, cols];
+
             for (int r = 0; r < rows; r++)
             for (int c = 0; c < cols; c++)
             {

osu.Framework/Graphics/Animations/Animation.cs

···
             if (IsPlaying && frameData.Count > 0)
             {
                 currentFrameTime += Time.Elapsed;
+
                 while (currentFrameTime > frameData[currentFrameIndex].Duration)
                 {
                     currentFrameTime -= frameData[currentFrameIndex].Duration;
                     ++currentFrameIndex;
+
                     if (currentFrameIndex >= frameData.Count)
                     {
                         if (Repeat)

osu.Framework/Graphics/Audio/WaveformGraph.cs

···
                             );
                         }
                             break;
+
                         case 1:
                         {
                             quadToDraw = new Quad(

osu.Framework/Graphics/BlendingInfo.cs

···
                     SourceAlpha = BlendingFactorSrc.One;
                     DestinationAlpha = BlendingFactorDest.One;
                     break;
+
                 case BlendingMode.Additive:
                     Source = BlendingFactorSrc.SrcAlpha;
                     Destination = BlendingFactorDest.One;
                     SourceAlpha = BlendingFactorSrc.One;
                     DestinationAlpha = BlendingFactorDest.One;
                     break;
+
                 default:
                     Source = BlendingFactorSrc.One;
                     Destination = BlendingFactorDest.Zero;
···
                 case BlendingEquation.Inherit:
                 case BlendingEquation.Add:
                     return BlendEquationMode.FuncAdd;
+
                 case BlendingEquation.Min:
                     return BlendEquationMode.Min;
+
                 case BlendingEquation.Max:
                     return BlendEquationMode.Max;
+
                 case BlendingEquation.Subtract:
                     return BlendEquationMode.FuncSubtract;
+
                 case BlendingEquation.ReverseSubtract:
                     return BlendEquationMode.FuncReverseSubtract;
             }

osu.Framework/Graphics/Containers/BufferedContainer_DrawNode.cs

···
                 currentFrameBufferIndex = originalIndex;
 
                 Vector2 frameBufferSize = new Vector2((float)Math.Ceiling(screenSpaceDrawRectangle.Width), (float)Math.Ceiling(screenSpaceDrawRectangle.Height));
+
                 if (RequiresRedraw)
                 {
                     sharedData.DrawVersion = updateVersion;

osu.Framework/Graphics/Containers/CompositeDrawable.cs

···
                 return false;
 
             internalChildren.RemoveAt(index);
+
             if (drawable.IsAlive)
             {
                 aliveInternalChildren.Remove(drawable);
···
             {
                 case LoadState.NotLoaded:
                     break;
+
                 case LoadState.Loading:
                     if (Thread.CurrentThread != LoadThread)
                         throw new InvalidThreadForChildMutationException(LoadState, "not on the load thread");
 
                     break;
+
                 case LoadState.Ready:
                     // Allow mutating from the load thread since parenting containers may still be in the loading state
                     if (Thread.CurrentThread != LoadThread && !ThreadSafety.IsUpdateThread)
                         throw new InvalidThreadForChildMutationException(LoadState, "not on the load or update threads");
 
                     break;
+
                 case LoadState.Loaded:
                     if (!ThreadSafety.IsUpdateThread)
                         throw new InvalidThreadForChildMutationException(LoadState, "not on the update thread");
···
         private static void addFromComposite(ulong frame, int treeIndex, bool forceNewDrawNode, ref int j, CompositeDrawable parentComposite, List<DrawNode> target)
         {
             SortedList<Drawable> children = parentComposite.aliveInternalChildren;
+
             for (int i = 0; i < children.Count; ++i)
             {
                 Drawable drawable = children[i];
···
                         continue;
 
                     CompositeDrawable composite = drawable as CompositeDrawable;
+
                     if (composite?.CanBeFlattened == true)
                     {
                         if (!composite.IsMaskedAway)

osu.Framework/Graphics/Containers/CompositeDrawable_DrawNode.cs

···
                 base.Draw(vertexAction);
 
                 drawEdgeEffect();
+
                 if (maskingInfo != null)
                 {
                     MaskingInfo info = maskingInfo.Value;

osu.Framework/Graphics/Containers/CustomizableTextContainer.cs

···
             var sprites = new List<Drawable>();
             int index = 0;
             string str = line.Text;
+
             while (index < str.Length)
             {
                 Drawable placeholderDrawable = null;
···
                     nextPlaceholderIndex = str.IndexOf(unescaped_left, nextPlaceholderIndex + 2, StringComparison.Ordinal);
 
                 string strPiece = null;
+
                 if (nextPlaceholderIndex != -1)
                 {
                     int placeholderEnd = str.IndexOf(unescaped_right, nextPlaceholderIndex, StringComparison.Ordinal);
···
                         string placeholderName = placeholderStr;
                         string paramStr = "";
                         int parensOpen = placeholderStr.IndexOf('(');
+
                         if (parensOpen != -1)
                         {
                             placeholderName = placeholderStr.Substring(0, parensOpen).Trim();
···
                         else
                         {
                             object[] args;
+
                             if (string.IsNullOrWhiteSpace(paramStr))
                             {
                                 args = Array.Empty<object>();
···
                             {
                                 string[] argStrs = paramStr.Split(',');
                                 args = new object[argStrs.Length];
+
                                 for (int i = 0; i < argStrs.Length; ++i)
                                 {
                                     if (!int.TryParse(argStrs[i], out int argVal))

osu.Framework/Graphics/Containers/FillFlowContainer.cs

···
         protected override IEnumerable<Vector2> ComputeLayoutPositions()
         {
             var max = MaximumSize;
+
             if (max == Vector2.Zero)
             {
                 var s = ChildSize;
···
 
             // First pass, computing initial flow positions
             Vector2 size = Vector2.Zero;
+
             for (int i = 0; i < children.Length; ++i)
             {
                 Drawable c = children[i];
···
                     {
                         case FillDirection.Full:
                             return Axes.Both;
+
                         case FillDirection.Horizontal:
                             return Axes.X;
+
                         case FillDirection.Vertical:
                             return Axes.Y;
+
                         default:
                             throw new ArgumentException($"{direction.ToString()} is not defined");
                     }
···
                 rowIndices[i] = rowOffsetsToMiddle.Count - 1;
 
                 Vector2 stride = Vector2.Zero;
+
                 if (i < children.Length - 1)
                 {
                     // Compute stride. Note, that the stride depends on the origins of the drawables
···
                                 + $"Consider using multiple instances of {nameof(FillFlowContainer)} if this is intentional.");
 
                         break;
+
                     case FillDirection.Horizontal:
                         if (c.RelativeAnchorPosition.X != ourRelativeAnchor.X)
                             throw new InvalidOperationException(
···
                                 + $"Consider using multiple instances of {nameof(FillFlowContainer)} if this is intentional.");
 
                         break;
+
                     default:
                         if (c.RelativeAnchorPosition != ourRelativeAnchor)
                             throw new InvalidOperationException(

osu.Framework/Graphics/Containers/FlowContainer.cs

···
             var positions = ComputeLayoutPositions().ToArray();
 
             int i = 0;
+
             foreach (var d in FlowingChildren)
             {
                 if (i > positions.Length)

osu.Framework/Graphics/Containers/GridContainer.cs

···
 
             // Create the new cell containers and add content
             cells = new CellContainer[requiredRows, requiredColumns];
+
             for (int r = 0; r < cellRows; r++)
             for (int c = 0; c < cellColumns; c++)
             {
···
                 {
                     default:
                         throw new InvalidOperationException($"Unsupported dimension: {dimension.Mode}.");
+
                     case GridSizeMode.Distributed:
                         break;
+
                     case GridSizeMode.Relative:
                         sizes[i] = dimension.Size * spanLength;
                         break;
+
                     case GridSizeMode.Absolute:
                         sizes[i] = dimension.Size;
                         break;
+
                     case GridSizeMode.AutoSize:
                         float size = 0;
 

osu.Framework/Graphics/Containers/LifetimeManagementContainer.cs

···
             }
 
             bool aliveChildrenChanged = false;
+
             if (newState == LifetimeState.Current)
             {
                 MakeChildAlive(child);
···
         private void enqueueEvents(Drawable child, LifetimeState oldState, LifetimeState newState)
         {
             Debug.Assert(oldState != newState);
+
             switch (oldState)
             {
                 case LifetimeState.Future:
···
                     if (newState == LifetimeState.Past)
                         eventQueue.Enqueue(new LifetimeBoundaryCrossedEvent(child, LifetimeBoundaryKind.End, LifetimeBoundaryCrossingDirection.Forward));
                     break;
+
                 case LifetimeState.Current:
                     eventQueue.Enqueue(newState == LifetimeState.Past
                         ? new LifetimeBoundaryCrossedEvent(child, LifetimeBoundaryKind.End, LifetimeBoundaryCrossingDirection.Forward)
                         : new LifetimeBoundaryCrossedEvent(child, LifetimeBoundaryKind.Start, LifetimeBoundaryCrossingDirection.Backward));
                     break;
+
                 case LifetimeState.Past:
                     eventQueue.Enqueue(new LifetimeBoundaryCrossedEvent(child, LifetimeBoundaryKind.End, LifetimeBoundaryCrossingDirection.Backward));
                     if (newState == LifetimeState.Future)
···
             {
                 case LifetimeState.Future:
                     return futureChildren;
+
                 case LifetimeState.Past:
                     return pastChildren;
+
                 default:
                     return null;
             }

osu.Framework/Graphics/Containers/Markdown/MarkdownContainer.cs

···
                 case ThematicBreakBlock thematicBlock:
                     container.Add(CreateSeparator(thematicBlock));
                     break;
+
                 case HeadingBlock headingBlock:
                     container.Add(CreateHeading(headingBlock));
                     break;
+
                 case ParagraphBlock paragraphBlock:
                     container.Add(CreateParagraph(paragraphBlock, level));
                     break;
+
                 case QuoteBlock quoteBlock:
                     container.Add(CreateQuoteBlock(quoteBlock));
                     break;
+
                 case FencedCodeBlock fencedCodeBlock:
                     container.Add(CreateFencedCodeBlock(fencedCodeBlock));
                     break;
+
                 case Table table:
                     container.Add(CreateTable(table));
                     break;
+
                 case ListBlock listBlock:
                     var childContainer = CreateList(listBlock);
                     container.Add(childContainer);
                     foreach (var single in listBlock)
                         AddMarkdownComponent(single, childContainer, level + 1);
                     break;
+
                 case ListItemBlock listItemBlock:
                     foreach (var single in listItemBlock)
                         AddMarkdownComponent(single, container, level);
                     break;
+
                 case HtmlBlock _:
                     // HTML is not supported
                     break;
+
                 case LinkReferenceDefinitionGroup _:
                     // Link reference doesn't need to be displayed.
                     break;
+
                 default:
                     container.Add(CreateNotImplemented(markdownObject));
                     break;

osu.Framework/Graphics/Containers/Markdown/MarkdownHeading.cs

···
             {
                 case 1:
                     return 2.7f;
+
                 case 2:
                     return 2;
+
                 case 3:
                     return 1.5f;
+
                 case 4:
                     return 1.3f;
+
                 default:
                     return 1;
             }

osu.Framework/Graphics/Containers/Markdown/MarkdownTableCell.cs

···
                 case TableColumnAlign.Center:
                     textFlow.TextAnchor = Anchor.Centre;
                     break;
+
                 case TableColumnAlign.Right:
                     textFlow.TextAnchor = Anchor.CentreRight;
                     break;
+
                 default:
                     textFlow.TextAnchor = Anchor.CentreLeft;
                     break;

osu.Framework/Graphics/Containers/Markdown/MarkdownTextFlowContainer.cs

···
                                     addEmphasis(text, emphases);
 
                                     break;
+
                                 case LinkInline linkInline:
                                 {
                                     if (!linkInline.IsImage)
···
                         }
 
                         break;
+
                     case CodeInline codeInline:
                         AddCodeInLine(codeInline);
                         break;
+
                     case LinkInline linkInline when linkInline.IsImage:
                         AddImage(linkInline);
                         break;
+
                     case HtmlInline _:
                     case HtmlEntityInline _:
                         // Handled by the next literal
                         break;
+
                     case LineBreakInline lineBreak:
                         if (lineBreak.IsHard)
                             NewParagraph();
                         else
                             NewLine();
                         break;
+
                     case ContainerInline innerContainer:
                         AddInlineText(innerContainer);
                         break;
+
                     default:
                         AddNotImplementedInlineText(single);
                         break;
···
                     case "_":
                         hasItalic = true;
                         break;
+
                     case "**":
                     case "__":
                         hasBold = true;

osu.Framework/Graphics/Containers/ScrollContainer.cs

···
                     case Key.PageUp:
                         ScrollTo(target - displayableContent);
                         return true;
+
                     case Key.PageDown:
                         ScrollTo(target + displayableContent);
                         return true;
···
                 case PlatformActionType.LineStart:
                     ScrollToStart();
                     return true;
+
                 case PlatformActionType.LineEnd:
                     ScrollToEnd();
                     return true;
+
                 default:
                     return false;
             }

osu.Framework/Graphics/Containers/TabbableContainer.cs

···
             stack.Push(target);
 
             bool started = false;
+
             while (stack.Count > 0)
             {
                 var drawable = stack.Pop();
···
                 {
                     var newChildren = composite.InternalChildren.ToList();
                     int bound = reverse ? newChildren.Count : 0;
+
                     if (!started)
                     {
                         // Find self, to know starting point

osu.Framework/Graphics/Containers/TextFlowContainer.cs

···
         {
             bool first = true;
             var sprites = new List<Drawable>();
+
             foreach (string l in line.Text.Split('\n'))
             {
                 if (!first)
                 {
                     Drawable lastChild = Children.LastOrDefault();
+
                     if (lastChild != null)
                     {
                         var newLine = new NewLineContainer(newLineIsParagraph);
···
         {
             var childrenByLine = new List<List<Drawable>>();
             var curLine = new List<Drawable>();
+
             foreach (var c in Children)
             {
                 c.Anchor = TextAnchor;
···
 
             bool isFirstLine = true;
             float lastLineHeight = 0f;
+
             foreach (var line in childrenByLine)
             {
                 bool isFirstChild = true;

osu.Framework/Graphics/Containers/VisibilityContainer.cs

···
                 case Visibility.Hidden:
                     PopOut();
                     break;
+
                 case Visibility.Visible:
                     PopIn();
                     break;

osu.Framework/Graphics/Cursor/ContextMenuContainer.cs

···
                     relativeCursorPosition = ToSpaceOfOtherDrawable(menu.Position, menuTarget);
                     menu.Open();
                     return true;
+
                 default:
                     menu.Close();
                     return false;

osu.Framework/Graphics/Cursor/CursorEffectContainer.cs

···
                 // We keep track of all drawables we found while traversing the parent chain upwards.
                 newChildDrawables.Clear();
                 newChildDrawables.Add(candidate);
+
                 // When we encounter a drawable we already encountered before, then there is no need
                 // to keep going upward, since we already recorded it previously. At that point we know
                 // the drawables we found are in fact children of ours.

osu.Framework/Graphics/Cursor/TooltipContainer.cs

···
             base.Update();
 
             IHasTooltip target = findTooltipTarget();
+
             if (target != null && target != currentlyDisplayed)
             {
                 currentlyDisplayed = target;
···
                 return hasValidTooltip(draggedTarget) ? draggedTarget : null;
 
             IHasTooltip targetCandidate = FindTargets().Find(t => t.TooltipText != null);
+
             // check this first - if we find no target candidate we still want to clear the recorded positions and update the lastCandidate.
             if (targetCandidate != lastCandidate)
             {
···
             double appearDelay = (targetCandidate as IHasAppearDelay)?.AppearDelay ?? AppearDelay;
             // Always keep 10 positions at equally-sized time intervals that add up to AppearDelay.
             double positionRecordInterval = appearDelay / 10;
+
             if (Time.Current - lastRecordedPositionTime >= positionRecordInterval)
             {
                 lastRecordedPositionTime = Time.Current;

osu.Framework/Graphics/Drawable.cs

···
             get
             {
                 Vector2 offset = Vector2.Zero;
+
                 if (Parent != null && RelativePositionAxes != Axes.None)
                 {
                     offset = Parent.RelativeChildOffset;
···
         private void updateBypassAutoSizeAxes()
         {
             var value = RelativePositionAxes | RelativeSizeAxes | bypassAutoSizeAdditionalAxes;
+
             if (bypassAutoSizeAxes != value)
             {
                 var changedAxes = bypassAutoSizeAxes ^ value;
···
         protected InputManager GetContainingInputManager()
         {
             Drawable search = Parent;
+
             while (search != null)
             {
                 if (search is InputManager test) return test;
···
         internal virtual DrawNode GenerateDrawNodeSubtree(ulong frame, int treeIndex, bool forceNewDrawNode)
         {
             DrawNode node = drawNodes[treeIndex];
+
             if (node == null || forceNewDrawNode)
             {
                 drawNodes[treeIndex] = node = CreateDrawNode();
···
             {
                 case MouseMoveEvent mouseMove:
                     return OnMouseMove(mouseMove);
+
                 case HoverEvent hover:
                     return OnHover(hover);
+
                 case HoverLostEvent hoverLost:
                     OnHoverLost(hoverLost);
                     return false;
+
                 case MouseDownEvent mouseDown:
                     return OnMouseDown(mouseDown);
+
                 case MouseUpEvent mouseUp:
                     return OnMouseUp(mouseUp);
+
                 case ClickEvent click:
                     return OnClick(click);
+
                 case DoubleClickEvent doubleClick:
                     return OnDoubleClick(doubleClick);
+
                 case DragStartEvent dragStart:
                     return OnDragStart(dragStart);
+
                 case DragEvent drag:
                     return OnDrag(drag);
+
                 case DragEndEvent dragEnd:
                     return OnDragEnd(dragEnd);
+
                 case ScrollEvent scroll:
                     return OnScroll(scroll);
+
                 case FocusEvent focus:
                     OnFocus(focus);
                     return false;
+
                 case FocusLostEvent focusLost:
                     OnFocusLost(focusLost);
                     return false;
+
                 case KeyDownEvent keyDown:
                     return OnKeyDown(keyDown);
+
                 case KeyUpEvent keyUp:
                     return OnKeyUp(keyUp);
+
                 case JoystickPressEvent joystickPress:
                     return OnJoystickPress(joystickPress);
+
                 case JoystickReleaseEvent joystickRelease:
                     return OnJoystickRelease(joystickRelease);
+
                 default:
                     return false;
             }
···
             private static bool get(Drawable drawable, ConcurrentDictionary<Type, bool> cache, bool positional)
             {
                 var type = drawable.GetType();
+
                 if (!cache.TryGetValue(type, out var value))
                 {
                     value = compute(type, positional);
···
             private static bool compute(Type type, bool positional)
             {
                 var inputMethods = positional ? positional_input_methods : non_positional_input_methods;
+
                 foreach (var inputMethod in inputMethods)
                 {
                     // check for any input method overrides which are at a higher level than drawable.
···
                 }
 
                 var inputInterfaces = positional ? positional_input_interfaces : non_positional_input_interfaces;
+
                 foreach (var inputInterface in inputInterfaces)
                 {
                     // check if this type implements any interface which requires a drawable to handle input.

osu.Framework/Graphics/OpenGL/Buffers/FrameBuffer.cs

···
         public void Bind()
         {
             GLWrapper.BindFrameBuffer(frameBuffer);
+
             foreach (var r in attachedRenderBuffers)
             {
                 r.Size = Size;

osu.Framework/Graphics/OpenGL/Buffers/QuadVertexBuffer.cs

···
             base.Initialise();
 
             int amountIndices = amountQuads * 6;
+
             if (amountIndices > QuadIndexData.MaxAmountIndices)
             {
                 ushort[] indices = new ushort[amountIndices];

osu.Framework/Graphics/OpenGL/Buffers/RenderBuffer.cs

···
                     case RenderbufferInternalFormat.DepthComponent16:
                         GL.FramebufferRenderbuffer(FramebufferTarget.Framebuffer, FramebufferAttachment.DepthAttachment, RenderbufferTarget.Renderbuffer, info.RenderBufferID);
                         break;
+
                     case RenderbufferInternalFormat.Rgb565:
                     case RenderbufferInternalFormat.Rgb5A1:
                     case RenderbufferInternalFormat.Rgba4:
                         GL.FramebufferRenderbuffer(FramebufferTarget.Framebuffer, FramebufferAttachment.ColorAttachment0, RenderbufferTarget.Renderbuffer, info.RenderBufferID);
                         break;
+
                     case RenderbufferInternalFormat.StencilIndex8:
                         GL.FramebufferRenderbuffer(FramebufferTarget.Framebuffer, FramebufferAttachment.DepthAttachment, RenderbufferTarget.Renderbuffer, info.RenderBufferID);
                         break;

osu.Framework/Graphics/OpenGL/GLWrapper.cs

···
             GlobalPropertyManager.Set(GlobalProperty.CornerRadius, maskingInfo.CornerRadius);
 
             GlobalPropertyManager.Set(GlobalProperty.BorderThickness, maskingInfo.BorderThickness / maskingInfo.BlendRange);
+
             if (maskingInfo.BorderThickness > 0)
             {
                 GlobalPropertyManager.Set(GlobalProperty.BorderColour, new Vector4(
···
                 case IUniformWithValue<bool> b:
                     GL.Uniform1(uniform.Location, b.GetValue() ? 1 : 0);
                     break;
+
                 case IUniformWithValue<int> i:
                     GL.Uniform1(uniform.Location, i.GetValue());
                     break;
+
                 case IUniformWithValue<float> f:
                     GL.Uniform1(uniform.Location, f.GetValue());
                     break;
+
                 case IUniformWithValue<Vector2> v2:
                     GL.Uniform2(uniform.Location, ref v2.GetValueByRef());
                     break;
+
                 case IUniformWithValue<Vector3> v3:
                     GL.Uniform3(uniform.Location, ref v3.GetValueByRef());
                     break;
+
                 case IUniformWithValue<Vector4> v4:
                     GL.Uniform4(uniform.Location, ref v4.GetValueByRef());
                     break;
+
                 case IUniformWithValue<Matrix2> m2:
                     GL.UniformMatrix2(uniform.Location, false, ref m2.GetValueByRef());
                     break;
+
                 case IUniformWithValue<Matrix3> m3:
                     GL.UniformMatrix3(uniform.Location, false, ref m3.GetValueByRef());
                     break;
+
                 case IUniformWithValue<Matrix4> m4:
                     GL.UniformMatrix4(uniform.Location, false, ref m4.GetValueByRef());
                     break;

osu.Framework/Graphics/Performance/FrameStatisticsDisplay.cs

···
                         labelText.Origin = Anchor.CentreRight;
                         labelText.Rotation = 0;
                         break;
+
                     case FrameStatisticsMode.Full:
                         mainContainer.AutoSizeAxes = Axes.None;
                         mainContainer.Size = new Vector2(WIDTH, HEIGHT);
···
                 case Key.ControlLeft:
                     Expanded = true;
                     break;
+
                 case Key.ShiftLeft:
                     Running = false;
                     break;
···
                 case Key.ControlLeft:
                     Expanded = false;
                     break;
+
                 case Key.ShiftLeft:
                     Running = true;
                     break;
···
             {
                 default:
                     return Color4.YellowGreen;
+
                 case PerformanceCollectionType.SwapBuffer:
                     return Color4.Red;
 #if DEBUG
···
 #endif
                 case PerformanceCollectionType.Sleep:
                     return Color4.DarkBlue;
+
                 case PerformanceCollectionType.Scheduler:
                     return Color4.HotPink;
+
                 case PerformanceCollectionType.WndProc:
                     return Color4.GhostWhite;
+
                 case PerformanceCollectionType.GLReset:
                     return Color4.Cyan;
             }
···
             {
                 default:
                     return Color4.BlueViolet;
+
                 case 1:
                     return Color4.YellowGreen;
+
                 case 2:
                     return Color4.HotPink;
+
                 case 3:
                     return Color4.Red;
+
                 case 4:
                     return Color4.Cyan;
+
                 case 5:
                     return Color4.Yellow;
+
                 case 6:
                     return Color4.SkyBlue;
             }
···
                 bool acceptableRange = (float)currentHeight / HEIGHT > 1 - monitor.FrameAimTime / visible_ms_range;
 
                 float brightnessAdjust = 1;
+
                 if (!frameTimeType.HasValue)
                 {
                     int step = amountSteps / HEIGHT;

osu.Framework/Graphics/Performance/PerformanceOverlay.cs

···
                     case FrameStatisticsMode.None:
                         this.FadeOut(100);
                         break;
+
                     case FrameStatisticsMode.Minimal:
                     case FrameStatisticsMode.Full:
                         this.FadeIn(100);

osu.Framework/Graphics/Shaders/Shader.cs

···
                 return;
 
             programID = GL.CreateProgram();
+
             foreach (ShaderPart p in parts)
             {
                 if (!p.Compiled) p.Compile();
···
 
             Log.AppendLine(string.Format(ShaderPart.BOUNDARY, name));
             Log.AppendLine($"Linked: {linkResult == 1}");
+
             if (linkResult == 0)
             {
                 Log.AppendLine("Log:");
···
                     }
 
                     IUniform uniform;
+
                     switch (type)
                     {
                         case ActiveUniformType.Bool:
                             uniform = createUniform<bool>(uniformName);
                             break;
+
                         case ActiveUniformType.Float:
                             uniform = createUniform<float>(uniformName);
                             break;
+
                         case ActiveUniformType.Int:
                             uniform = createUniform<int>(uniformName);
                             break;
+
                         case ActiveUniformType.FloatMat3:
                             uniform = createUniform<Matrix3>(uniformName);
                             break;
+
                         case ActiveUniformType.FloatMat4:
                             uniform = createUniform<Matrix4>(uniformName);
                             break;
+
                         case ActiveUniformType.FloatVec2:
                             uniform = createUniform<Vector2>(uniformName);
                             break;
+
                         case ActiveUniformType.FloatVec3:
                             uniform = createUniform<Vector3>(uniformName);
                             break;
+
                         case ActiveUniformType.FloatVec4:
                             uniform = createUniform<Vector4>(uniformName);
                             break;
+
                         default:
                             continue;
                     }

osu.Framework/Graphics/Shaders/ShaderManager.cs

···
             {
                 case ShaderType.FragmentShader:
                     return @".fs";
+
                 case ShaderType.VertexShader:
                     return @".vs";
             }

osu.Framework/Graphics/Shaders/ShaderPart.cs

···
                     }
 
                     Match includeMatch = includeRegex.Match(line);
+
                     if (includeMatch.Success)
                     {
                         string includeName = includeMatch.Groups[1].Value.Trim();
···
                     if (Type == ShaderType.VertexShader || Type == ShaderType.VertexShaderArb)
                     {
                         Match inputMatch = shaderInputRegex.Match(line);
+
                         if (inputMatch.Success)
                         {
                             ShaderInputs.Add(new ShaderInputInfo
···
             string compileLog = GL.GetShaderInfoLog(this);
             Log.AppendLine(string.Format('\t' + BOUNDARY, Name));
             Log.AppendLine($"\tCompiled: {Compiled}");
+
             if (!Compiled)
             {
                 Log.AppendLine("\tLog:");

osu.Framework/Graphics/Textures/TextureAtlas.cs

···
             Vector2I res = new Vector2I(0, currentY);
 
             int maxY = currentY;
+
             foreach (RectangleI bounds in subTextureBounds)
             {
                 // +1 is required to prevent aliasing issues with sub-pixel positions while drawing. Bordering edged of other textures can show without it.

osu.Framework/Graphics/TransformableExtensions.cs

···
             {
                 case Direction.Horizontal:
                     return drawable.MoveToX(destination, duration, easing);
+
                 case Direction.Vertical:
                     return drawable.MoveToY(destination, duration, easing);
             }

osu.Framework/Graphics/Transforms/TransformCustom.cs

···
         private static Accessor findAccessor(Type type, string propertyOrFieldName)
         {
             PropertyInfo property = type.GetProperty(propertyOrFieldName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+
             if (property != null)
             {
                 if (property.PropertyType != typeof(TValue))
···
             }
 
             FieldInfo field = type.GetField(propertyOrFieldName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
+
             if (field != null)
             {
                 if (field.FieldType != typeof(TValue))

osu.Framework/Graphics/Transforms/TransformSequence.cs

···
                 throw new InvalidOperationException($"Can not perform {nameof(Loop)} on an endless {nameof(TransformSequence<T>)}.");
 
             var iterDuration = endTime - startTime + pause;
+
             foreach (var t in transforms)
             {
                 Action tmpOnAbort = t.OnAbort;
···
                 // inserted in the correct order such that none of them trigger abortions on
                 // each other due to instant re-sorting upon adding.
                 double currentTransformTime = t.TargetTransformable.Time.Current;
+
                 while (t.EndTime <= currentTransformTime)
                 {
                     t.StartTime += iterDuration;

osu.Framework/Graphics/Transforms/Transformable.cs

···
                 return;
 
             Transform[] toAbort;
+
             if (targetMember == null)
             {
                 toAbort = transformsLazy.Value.Where(t => t.StartTime >= time).ToArray();
···
             for (int i = insertionIndex + 1; i < transforms.Count; ++i)
             {
                 var t = transforms[i];
+
                 if (t.TargetMember == transform.TargetMember)
                 {
                     transforms.RemoveAt(i--);

osu.Framework/Graphics/UserInterface/CircularProgressDrawNode.cs

···
                 // dir is used so negative angles result in negative angularOffset.
                 float angularOffset = dir * Math.Min(i * step, dir * angle);
                 float normalisedOffset = angularOffset / MathHelper.TwoPi;
+
                 if (dir < 0)
                 {
                     normalisedOffset += 1.0f;

osu.Framework/Graphics/UserInterface/Dropdown.cs

···
             {
                 case MenuItem i:
                     return i.Text.Value;
+
                 case IHasText t:
                     return t.Text;
+
                 case Enum e:
                     return e.GetDescription();
+
                 default:
                     return item?.ToString() ?? "null";
             }

osu.Framework/Graphics/UserInterface/Menu.cs

···
                 case Direction.Horizontal:
                     ItemsContainer.AutoSizeAxes = Axes.X;
                     break;
+
                 case Direction.Vertical:
                     ItemsContainer.AutoSizeAxes = Axes.Y;
                     break;
···
                 case MenuState.Closed:
                     AnimateClose();
                     break;
+
                 case MenuState.Open:
                     AnimateOpen();
                     if (!TopLevelMenu)
···
                 case MenuState.Closed:
                     selectedItem.State = MenuItemState.NotSelected;
                     break;
+
                 case MenuState.Open:
                     selectedItem.State = MenuItemState.Selected;
                     break;

osu.Framework/Graphics/UserInterface/SliderBar.cs

···
                     currentNumberInstantaneous.Add(step);
                     onUserChange(currentNumberInstantaneous.Value);
                     return true;
+
                 case Key.Left:
                     currentNumberInstantaneous.Add(-step);
                     onUserChange(currentNumberInstantaneous.Value);
                     return true;
+
                 default:
                     return false;
             }

osu.Framework/Graphics/UserInterface/TextBox.cs

···
             pos = Parent.ToSpaceOfOtherDrawable(pos, TextFlow);
 
             int i = 0;
+
             foreach (Drawable d in TextFlow.Children)
             {
                 if (d.DrawPosition.X + d.DrawSize.X / 2 > pos.X)
···
             foreach (char c in addText)
             {
                 var ch = addCharacter(c);
+
                 if (ch == null)
                 {
                     notifyInputError();
···
                 case Key.Escape:
                     KillFocus();
                     return true;
+
                 case Key.KeypadEnter:
                 case Key.Enter:
                     Commit();
···
             for (int i = matchCount; i < s.Length; i++)
             {
                 Drawable dr = addCharacter(s[i]);
+
                 if (dr != null)
                 {
                     dr.Colour = Color4.Aqua;

osu.Framework/Graphics/Video/VideoDecoder.cs

···
                 case StdIo.SEEK_CUR:
                     videoStream.Seek(offset, SeekOrigin.Current);
                     break;
+
                 case StdIo.SEEK_END:
                     videoStream.Seek(offset, SeekOrigin.End);
                     break;
+
                 case StdIo.SEEK_SET:
                     videoStream.Seek(offset, SeekOrigin.Begin);
                     break;
+
                 case ffmpeg.AVSEEK_SIZE:
                     return videoStream.Length;
+
                 default:
                     return -1;
             }
···
                 throw new Exception("Could not find stream info.");
 
             var nStreams = formatContext->nb_streams;
+
             for (var i = 0; i < nStreams; ++i)
             {
                 stream = formatContext->streams[i];
 
                 codecParams = *stream->codecpar;
+
                 if (codecParams.codec_type == AVMediaType.AVMEDIA_TYPE_VIDEO)
                 {
                     timeBaseInSeconds = stream->time_base.GetValue();
···
                         if (readFrameResult >= 0)
                         {
                             state = DecoderState.Running;
+
                             if (packet->stream_index == stream->index)
                             {
                                 if (ffmpeg.avcodec_send_packet(stream->codec, packet) < 0)
                                     throw new Exception("Error sending packet.");
 
                                 var result = ffmpeg.avcodec_receive_frame(stream->codec, frame);
+
                                 if (result == 0)
                                 {
                                     var frameTime = (frame->best_effort_timestamp - stream->start_time) * timeBaseInSeconds * 1000;
+
                                     if (!skipOutputUntilTime.HasValue || skipOutputUntilTime.Value < frameTime)
                                     {
                                         skipOutputUntilTime = null;
 
                                         SwsContext* swsCtx = null;
+
                                         try
                                         {
                                             swsCtx = ffmpeg.sws_getContext(codecParams.width, codecParams.height, (AVPixelFormat)frame->format, codecParams.width, codecParams.height, AVPixelFormat.AV_PIX_FMT_RGBA, 0, null, null, null);

osu.Framework/Graphics/Video/VideoSprite.cs

···
                 startTime = Clock.CurrentTime;
 
             var nextFrame = availableFrames.Count > 0 ? availableFrames.Peek() : null;
+
             if (nextFrame != null)
             {
                 bool tooFarBehind = Math.Abs(PlaybackPosition - nextFrame.Time) > lenience_before_seek &&

osu.Framework/Graphics/Visualisation/DrawVisualiser.cs

···
                         Drawable lastHighlight = highlightedTarget?.Target;
 
                         var parent = Target?.Parent;
+
                         if (parent != null)
                         {
                             var lastVisualiser = targetVisualiser;
···
                         if (lastHighlight != null)
                         {
                             VisualisedDrawable visualised = targetVisualiser.FindVisualisedDrawable(lastHighlight);
+
                             if (visualised != null)
                             {
                                 propertyDisplay.State = Visibility.Visible;

osu.Framework/Graphics/Visualisation/LogOverlay.cs

···
             {
                 case LoggingTarget.Runtime:
                     return Color4.YellowGreen;
+
                 case LoggingTarget.Network:
                     return Color4.BlueViolet;
+
                 case LoggingTarget.Performance:
                     return Color4.HotPink;
+
                 case LoggingTarget.Information:
                     return Color4.CadetBlue;
+
                 default:
                     return Color4.Cyan;
             }

osu.Framework/Graphics/Visualisation/PropertyDisplay.cs

···
             public PropertyItem(MemberInfo info, IDrawable d)
             {
                 Type type;
+
                 switch (info.MemberType)
                 {
                     case MemberTypes.Property:
···
             private void updateValue()
             {
                 object value;
+
                 try
                 {
                     value = getValue() ?? "<null>";

osu.Framework/Graphics/Visualisation/TreeContainer.cs

···
                     case TreeContainerStatus.Offscreen:
                         this.Delay(500).FadeTo(0.7f, 300);
                         break;
+
                     case TreeContainerStatus.Onscreen:
                         this.FadeIn(300, Easing.OutQuint);
                         break;

osu.Framework/Graphics/Visualisation/VisualisedDrawable.cs

···
         private void updateSpecifics()
         {
             Vector2 posInTree = ToSpaceOfOtherDrawable(Vector2.Zero, tree);
+
             if (posInTree.Y < -previewBox.DrawHeight || posInTree.Y > tree.Height)
             {
                 text.Text = string.Empty;

osu.Framework/Host.cs

···
             {
                 case RuntimeInfo.Platform.MacOsx:
                     return new MacOSGameHost(gameName, bindIPC, toolkitOptions, portableInstallation);
+
                 case RuntimeInfo.Platform.Linux:
                     return new LinuxGameHost(gameName, bindIPC, toolkitOptions, portableInstallation);
+
                 case RuntimeInfo.Platform.Windows:
                     return new WindowsGameHost(gameName, bindIPC, toolkitOptions, portableInstallation);
+
                 default:
                     throw new InvalidOperationException($"Could not find a suitable host for the selected operating system ({Enum.GetName(typeof(RuntimeInfo.Platform), RuntimeInfo.OS)}).");
             }

osu.Framework/IO/AsyncBufferStream.cs

···
                 return;
 
             int last = -1;
+
             while (!isLoaded && !isClosed)
             {
                 cancellationToken.Token.ThrowIfCancellationRequested();
 
                 int curr = nextBlockToLoad;
+
                 if (curr < 0)
                 {
                     Thread.Sleep(1);
···
                 case SeekOrigin.Begin:
                     Position = offset;
                     break;
+
                 case SeekOrigin.Current:
                     Position += offset;
                     break;
+
                 case SeekOrigin.End:
                     Position = data.Length + offset;
                     break;

osu.Framework/IO/File/FileSafety.cs

···
             }
 
             string deathLocation = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+
             try
             {
                 System.IO.File.Move(filename, deathLocation);
···
             }
 
             bool didExist = Directory.Exists(newDirectory);
+
             if (!didExist)
             {
                 DirectoryInfo newDirectoryInfo = Directory.CreateDirectory(newDirectory);
+
                 try
                 {
                     if (new DirectoryInfo(oldDirectory).Attributes.HasFlag(FileAttributes.Hidden))
···
                 string newFile = Path.Combine(newDirectory, Path.GetFileName(file));
 
                 bool didMove = FileMove(file, newFile, didExist);
+
                 if (!didMove)
                 {
                     try
···
                 return string.Empty;
 
             char[] converted = new char[(encoded.Length + 1) / 2];
+
             fixed (byte* bytePtr = encoded)
             fixed (char* stringPtr = converted)
             {
                 byte* stringBytes = (byte*)stringPtr;
                 byte* stringEnd = (byte*)stringPtr + converted.Length * 2;
                 byte* bytePtr2 = bytePtr;
+
                 do
                 {
                     *stringBytes = *bytePtr2++;
···
         public static void CreateBackup(string filename)
         {
             string backupFilename = filename + @"." + DateTime.Now.Ticks + @".bak";
+
             if (System.IO.File.Exists(filename) && !System.IO.File.Exists(backupFilename))
             {
                 Debug.Print(@"Backup created: " + backupFilename);

osu.Framework/IO/Network/UrlEncoding.cs

···
         {
             int num = 0;
             int num2 = 0;
+
             for (int i = 0; i < count; i++)
             {
                 char ch = (char)bytes[offset + i];
+
                 if (paramEncode && ch == ' ')
                 {
                     num++;
···
 
             byte[] buffer = new byte[count + num2 * 2];
             int num4 = 0;
+
             for (int j = 0; j < count; j++)
             {
                 byte num6 = bytes[offset + j];
                 char ch2 = (char)num6;
+
                 if (IsSafe(ch2))
                 {
                     buffer[num4++] = num6;

osu.Framework/IO/Network/WebRequest.cs

···
         private async Task internalPerform()
         {
             var url = Url;
+
             if (!AllowInsecureRequests && !url.StartsWith(@"https://"))
             {
                 logger.Add($"Insecure request was automatically converted to https ({Url})");
···
                 {
                     // in the case we fail a request, spitting out the response in the log is quite helpful.
                     ResponseStream.Seek(0, SeekOrigin.Begin);
+
                     using (StreamReader r = new StreamReader(ResponseStream, new UTF8Encoding(false, true), true, 1024, true))
                     {
                         try

osu.Framework/IO/Stores/FontStore.cs

···
                 case FontStore fs:
                     nestedFontStores.Add(fs);
                     return;
+
                 case GlyphStore gs:
                     glyphStores.Add(gs);
                     queueLoad(gs);
···
                 case FontStore fs:
                     nestedFontStores.Remove(fs);
                     return;
+
                 case GlyphStore gs:
                     glyphStores.Remove(gs);
                     break;

osu.Framework/Input/Bindings/KeyBindingContainer.cs

···
         protected override bool Handle(UIEvent e)
         {
             var state = e.CurrentState;
+
             switch (e)
             {
                 case MouseDownEvent mouseDown:

osu.Framework/Input/Bindings/KeyCombination.cs

···
             {
                 case InputKey.None:
                     return string.Empty;
+
                 case InputKey.Shift:
                     return "Shift";
+
                 case InputKey.Control:
                     return "Ctrl";
+
                 case InputKey.Alt:
                     return "Alt";
+
                 case InputKey.Super:
                     return "Win";
+
                 case InputKey.Escape:
                     return "Esc";
+
                 case InputKey.BackSpace:
                     return "Backsp";
+
                 case InputKey.Insert:
                     return "Ins";
+
                 case InputKey.Delete:
                     return "Del";
+
                 case InputKey.PageUp:
                     return "Pgup";
+
                 case InputKey.PageDown:
                     return "Pgdn";
+
                 case InputKey.CapsLock:
                     return "Caps";
+
                 case InputKey.Number0:
                 case InputKey.Keypad0:
                     return "0";
+
                 case InputKey.Number1:
                 case InputKey.Keypad1:
                     return "1";
+
                 case InputKey.Number2:
                 case InputKey.Keypad2:
                     return "2";
+
                 case InputKey.Number3:
                 case InputKey.Keypad3:
                     return "3";
+
                 case InputKey.Number4:
                 case InputKey.Keypad4:
                     return "4";
+
                 case InputKey.Number5:
                 case InputKey.Keypad5:
                     return "5";
+
                 case InputKey.Number6:
                 case InputKey.Keypad6:
                     return "6";
+
                 case InputKey.Number7:
                 case InputKey.Keypad7:
                     return "7";
+
                 case InputKey.Number8:
                 case InputKey.Keypad8:
                     return "8";
+
                 case InputKey.Number9:
                 case InputKey.Keypad9:
                     return "9";
+
                 case InputKey.Tilde:
                     return "~";
+
                 case InputKey.Minus:
                     return "-";
+
                 case InputKey.Plus:
                     return "+";
+
                 case InputKey.BracketLeft:
                     return "(";
+
                 case InputKey.BracketRight:
                     return ")";
+
                 case InputKey.Semicolon:
                     return ";";
+
                 case InputKey.Quote:
                     return "\"";
+
                 case InputKey.Comma:
                     return ",";
+
                 case InputKey.Period:
                     return ".";
+
                 case InputKey.Slash:
                     return "/";
+
                 case InputKey.BackSlash:
                 case InputKey.NonUSBackSlash:
                     return "\\";
+
                 case InputKey.MouseLeft:
                     return "M1";
+
                 case InputKey.MouseMiddle:
                     return "M3";
+
                 case InputKey.MouseRight:
                     return "M2";
+
                 case InputKey.MouseButton1:
                     return "M4";
+
                 case InputKey.MouseButton2:
                     return "M5";
+
                 case InputKey.MouseButton3:
                     return "M6";
+
                 case InputKey.MouseButton4:
                     return "M7";
+
                 case InputKey.MouseButton5:
                     return "M8";
+
                 case InputKey.MouseButton6:
                     return "M9";
+
                 case InputKey.MouseButton7:
                     return "M10";
+
                 case InputKey.MouseButton8:
                     return "M11";
+
                 case InputKey.MouseButton9:
                     return "M12";
+
                 case InputKey.MouseWheelDown:
                     return "Wheel Down";
+
                 case InputKey.MouseWheelUp:
                     return "Wheel Up";
+
                 default:
                     return key.ToString();
             }
···
             {
                 case Key.RShift:
                     return InputKey.Shift;
+
                 case Key.RAlt:
                     return InputKey.Alt;
+
                 case Key.RControl:
                     return InputKey.Control;
+
                 case Key.RWin:
                     return InputKey.Super;
             }
···
                             if (!keys.Contains(iKey))
                                 keys.Add(iKey);
                             break;
+
                         default:
                             keys.Add(iKey);
                             break;

osu.Framework/Input/CustomInputManager.cs

···
             if (!handler.Initialize(Host)) return;
 
             int index = inputHandlers.BinarySearch(handler, new InputHandlerComparer());
+
             if (index < 0)
             {
                 index = ~index;

osu.Framework/Input/Handlers/Joystick/OsuTKJoystickHandler.cs

···
             for (int index = 0; index < rawStates.Count; index++)
             {
                 var rawState = rawStates[index];
+
                 if (index < devices.Count)
                 {
                     devices[index].UpdateRawState(rawState);

osu.Framework/Input/Handlers/Mouse/OsuTKMouseHandlerBase.cs

···
             else
             {
                 var delta = state.Position - lastState.Position;
+
                 if (delta != Vector2.Zero)
                 {
                     PendingInputs.Enqueue(new MousePositionRelativeInput { Delta = delta });
···
             if (lastState != null && state.WasActive)
             {
                 var scrollDelta = state.Scroll - lastState.Scroll;
+
                 if (scrollDelta != Vector2.Zero)
                 {
                     PendingInputs.Enqueue(new MouseScrollRelativeInput { Delta = scrollDelta, IsPrecise = state.HasPreciseScroll });

osu.Framework/Input/InputManager.cs

···
             {
                 case MouseButton.Left:
                     return new MouseLeftButtonEventManager(button);
+
                 default:
                     return new MouseMinorButtonEventManager(button);
             }
···
             if (!(keyboardRepeatKey is Key key)) return;
 
             keyboardRepeatTime -= Time.Elapsed;
+
             while (keyboardRepeatTime < 0)
             {
                 handleKeyDown(state, key, true);
···
                     }
 
                     d.IsHovered = true;
+
                     if (d.TriggerEvent(new HoverEvent(state)))
                     {
                         hoverHandledDrawable = d;
···
                 case MousePositionChangeEvent mousePositionChange:
                     HandleMousePositionChange(mousePositionChange);
                     return;
+
                 case MouseScrollChangeEvent mouseScrollChange:
                     HandleMouseScrollChange(mouseScrollChange);
                     return;
+
                 case ButtonStateChangeEvent<MouseButton> mouseButtonStateChange:
                     HandleMouseButtonStateChange(mouseButtonStateChange);
                     return;
+
                 case ButtonStateChangeEvent<Key> keyboardKeyStateChange:
                     HandleKeyboardKeyStateChange(keyboardKeyStateChange);
                     return;
+
                 case ButtonStateChangeEvent<JoystickButton> joystickButtonStateChange:
                     HandleJoystickButtonStateChange(joystickButtonStateChange);
                     return;
···
             {
                 //ensure we are visible
                 CompositeDrawable d = FocusedDrawable.Parent;
+
                 while (d != null)
                 {
                     if (!d.IsPresent || !d.IsAlive)

osu.Framework/Input/MouseButtonEventManager.cs

···
 
             // only drawables up to the one that handled mouse down should handle mouse up
             MouseDownInputQueue = positionalInputQueue;
+
             if (handledBy != null)
             {
                 var count = MouseDownInputQueue.IndexOf(handledBy) + 1;

osu.Framework/Input/StateChanges/ButtonInput.cs

···
         public void Apply(InputState state, IInputStateChangeHandler handler)
         {
             var buttonStates = GetButtonStates(state);
+
             foreach (var entry in Entries)
             {
                 if (buttonStates.SetPressed(entry.Button, entry.IsPressed))

osu.Framework/Input/StateChanges/MousePositionAbsoluteInput.cs

···
         public void Apply(InputState state, IInputStateChangeHandler handler)
         {
             var mouse = state.Mouse;
+
             if (!mouse.IsPositionValid || mouse.Position != Position)
             {
                 var lastPosition = mouse.IsPositionValid ? mouse.Position : Position;

osu.Framework/Input/StateChanges/MousePositionRelativeInput.cs

···
         public void Apply(InputState state, IInputStateChangeHandler handler)
         {
             var mouse = state.Mouse;
+
             if (mouse.IsPositionValid && Delta != Vector2.Zero)
             {
                 var lastPosition = mouse.Position;

osu.Framework/Input/StateChanges/MouseScrollRelativeInput.cs

···
         public void Apply(InputState state, IInputStateChangeHandler handler)
         {
             var mouse = state.Mouse;
+
             if (Delta != Vector2.Zero)
             {
                 var lastScroll = mouse.Scroll;

osu.Framework/Logging/Logger.cs

···
             lock (static_sync_lock)
             {
                 var nameLower = name.ToLower();
+
                 if (!static_loggers.TryGetValue(nameLower, out Logger l))
                 {
                     static_loggers[nameLower] = l = Enum.TryParse(name, true, out LoggingTarget target) ? new Logger(target) : new Logger(name);

osu.Framework/MathUtils/Interpolation.cs

···
         {
             int n = points.Length;
             double[] w = new double[n];
+
             for (int i = 0; i < n; i++)
             {
                 w[i] = 1;
···
                 case Easing.In:
                 case Easing.InQuad:
                     return time * time;
+
                 case Easing.Out:
                 case Easing.OutQuad:
                     return time * (2 - time);
+
                 case Easing.InOutQuad:
                     if (time < .5) return time * time * 2;
 
···
 
                 case Easing.InCubic:
                     return time * time * time;
+
                 case Easing.OutCubic:
                     return --time * time * time + 1;
+
                 case Easing.InOutCubic:
                     if (time < .5) return time * time * time * 4;
 
···
 
                 case Easing.InQuart:
                     return time * time * time * time;
+
                 case Easing.OutQuart:
                     return 1 - --time * time * time * time;
+
                 case Easing.InOutQuart:
                     if (time < .5) return time * time * time * time * 8;
 
···
 
                 case Easing.InQuint:
                     return time * time * time * time * time;
+
                 case Easing.OutQuint:
                     return --time * time * time * time * time + 1;
+
                 case Easing.InOutQuint:
                     if (time < .5) return time * time * time * time * time * 16;
 
···
 
                 case Easing.InSine:
                     return 1 - Math.Cos(time * Math.PI * .5);
+
                 case Easing.OutSine:
                     return Math.Sin(time * Math.PI * .5);
+
                 case Easing.InOutSine:
                     return .5 - .5 * Math.Cos(Math.PI * time);
 
                 case Easing.InExpo:
                     return Math.Pow(2, 10 * (time - 1));
+
                 case Easing.OutExpo:
                     return -Math.Pow(2, -10 * time) + 1;
+
                 case Easing.InOutExpo:
                     if (time < .5) return .5 * Math.Pow(2, 20 * time - 10);
 
···
 
                 case Easing.InCirc:
                     return 1 - Math.Sqrt(1 - time * time);
+
                 case Easing.OutCirc:
                     return Math.Sqrt(1 - --time * time);
+
                 case Easing.InOutCirc:
                     if ((time *= 2) < 1) return .5 - .5 * Math.Sqrt(1 - time * time);
 
···
 
                 case Easing.InElastic:
                     return -Math.Pow(2, -10 + 10 * time) * Math.Sin((1 - elastic_const2 - time) * elastic_const);
+
                 case Easing.OutElastic:
                     return Math.Pow(2, -10 * time) * Math.Sin((time - elastic_const2) * elastic_const) + 1;
+
                 case Easing.OutElasticHalf:
                     return Math.Pow(2, -10 * time) * Math.Sin((.5 * time - elastic_const2) * elastic_const) + 1;
+
                 case Easing.OutElasticQuarter:
                     return Math.Pow(2, -10 * time) * Math.Sin((.25 * time - elastic_const2) * elastic_const) + 1;
+
                 case Easing.InOutElastic:
                     if ((time *= 2) < 1)
                         return -.5 * Math.Pow(2, -10 + 10 * time) * Math.Sin((1 - elastic_const2 * 1.5 - time) * elastic_const / 1.5);
···
 
                 case Easing.InBack:
                     return time * time * ((back_const + 1) * time - back_const);
+
                 case Easing.OutBack:
                     return --time * time * ((back_const + 1) * time + back_const) + 1;
+
                 case Easing.InOutBack:
                     if ((time *= 2) < 1) return .5 * time * time * ((back_const2 + 1) * time - back_const2);
 
···
                         return 1 - (7.5625 * (time -= 2.25 * bounce_const) * time + .9375);
 
                     return 1 - (7.5625 * (time -= 2.625 * bounce_const) * time + .984375);
+
                 case Easing.OutBounce:
                     if (time < bounce_const)
                         return 7.5625 * time * time;
···
                         return 7.5625 * (time -= 2.25 * bounce_const) * time + .9375;
 
                     return 7.5625 * (time -= 2.625 * bounce_const) * time + .984375;
+
                 case Easing.InOutBounce:
                     if (time < .5) return .5 - .5 * ApplyEasing(Easing.OutBounce, 1 - time * 2);
 

osu.Framework/MathUtils/PathApproximator.cs

···
             while (toFlatten.Count > 0)
             {
                 Vector2[] parent = toFlatten.Pop();
+
                 if (bezierIsFlatEnough(parent))
                 {
                     // If the control points we currently operate on are sufficiently "flat", we use
···
             // AC B lies.
             Vector2 orthoAtoC = c - a;
             orthoAtoC = new Vector2(orthoAtoC.Y, -orthoAtoC.X);
+
             if (Vector2.Dot(orthoAtoC, b - a) < 0)
             {
                 dir = -dir;
···
 
             float minX = controlPoints[0].X;
             float maxX = controlPoints[0].X;
+
             for (int i = 1; i < controlPoints.Length; i++)
             {
                 minX = Math.Min(minX, controlPoints[i].X);
···
                 l[count + i] = r[i + 1];
 
             output.Add(controlPoints[0]);
+
             for (int i = 1; i < count - 1; ++i)
             {
                 int index = 2 * i;

osu.Framework/Physics/RigidBodyContainer.cs

···
                 float usableLength = Math.Max(length - 2 * cornerRadius, 0);
 
                 Vector2 normal = (b - a).PerpendicularRight.Normalized();
+
                 for (int j = 0; j < amount_side_steps; ++j)
                 {
                     Vertices.Add(a + dir * (cornerRadius + j * usableLength / (amount_side_steps - 1)));
···
             }
 
             const int amount_corner_steps = 10;
+
             if (cornerRadius > 0)
             {
                 // Rounded corners
···
                 return false;
 
             bool didCollide = false;
+
             for (int i = 0; i < Vertices.Count; ++i)
             {
                 if (other.BodyContains(Vector2Extensions.Transform(Vertices[i], SimulationToScreenSpace)))

osu.Framework/Platform/DesktopGameWindow.cs

···
                 case Input.ConfineMouseMode.Fullscreen:
                     confine = WindowMode.Value != Configuration.WindowMode.Windowed;
                     break;
+
                 case Input.ConfineMouseMode.Always:
                     confine = true;
                     break;
···
             try
             {
                 inWindowModeTransition = true;
+
                 switch (newMode)
                 {
                     case Configuration.WindowMode.Fullscreen:
···
 
                         WindowState = WindowState.Fullscreen;
                         break;
+
                     case Configuration.WindowMode.Borderless:
                         if (lastFullscreenDisplay != null)
                             RestoreResolution(lastFullscreenDisplay);
···
                         ClientSize = new Size(currentDisplay.Bounds.Width + 1, currentDisplay.Bounds.Height + 1);
                         Location = currentDisplay.Bounds.Location;
                         break;
+
                     case Configuration.WindowMode.Windowed:
                         if (lastFullscreenDisplay != null)
                             RestoreResolution(lastFullscreenDisplay);

osu.Framework/Platform/GameHost.cs

···
                     h.Dispose();
 
             AvailableInputHandlers = CreateAvailableInputHandlers();
+
             foreach (var handler in AvailableInputHandlers)
             {
                 if (!handler.Initialize(this))
···
                         drawLimiter = int.MaxValue;
                         updateLimiter *= 2;
                         break;
+
                     case FrameSync.Limit2x:
                         drawLimiter *= 2;
                         updateLimiter *= 2;
                         break;
+
                     case FrameSync.Limit4x:
                         drawLimiter *= 4;
                         updateLimiter *= 4;
                         break;
+
                     case FrameSync.Limit8x:
                         drawLimiter *= 8;
                         updateLimiter *= 8;
                         break;
+
                     case FrameSync.Unlimited:
                         drawLimiter = updateLimiter = int.MaxValue;
                         break;

osu.Framework/Platform/GameWindow.cs

···
                     case Configuration.WindowMode.Windowed:
                         currentValue = Configuration.WindowMode.Borderless;
                         break;
+
                     case Configuration.WindowMode.Borderless:
                         currentValue = Configuration.WindowMode.Fullscreen;
                         break;
+
                     case Configuration.WindowMode.Fullscreen:
                         currentValue = Configuration.WindowMode.Windowed;
                         break;

osu.Framework/Platform/Linux/Native/Library.cs

···
         public static void Load(string library, LoadFlags flags)
         {
             var paths = (string)AppContext.GetData("NATIVE_DLL_SEARCH_DIRECTORIES");
+
             foreach (var path in paths.Split(':'))
             {
                 if (dlopen(Path.Combine(path, library), flags) != IntPtr.Zero)

osu.Framework/Platform/MacOS/MacOSGameWindow.cs

···
         {
             // update the window mode if we have an update queued
             WindowMode? mode = pendingWindowMode;
+
             if (mode.HasValue)
             {
                 pendingWindowMode = null;

osu.Framework/Platform/NativeStorage.cs

···
                     if (!File.Exists(path)) return null;
 
                     return File.Open(path, FileMode.Open, access, FileShare.Read);
+
                 default:
                     return File.Open(path, mode, access);
             }

osu.Framework/Platform/TcpIpcProvider.cs

···
         public bool Bind()
         {
             listener = new TcpListener(IPAddress.Loopback, ipc_port);
+
             try
             {
                 listener.Start();
···
         public async Task StartAsync()
         {
             var token = cancelListener.Token;
+
             try
             {
                 while (!token.IsCancellationRequested)
···
             using (var client = new TcpClient())
             {
                 await client.ConnectAsync(IPAddress.Loopback, ipc_port);
+
                 using (var stream = client.GetStream())
                 {
                     var str = JsonConvert.SerializeObject(message, Formatting.None);

osu.Framework/Platform/Windows/Native/IconGroup.cs

···
         {
             int requested = Math.Min(width, height);
             int closest = -1;
+
             for (int i = 0; i < iconDir.Count; i++)
             {
                 var entry = iconDir.Entries[i];

osu.Framework/RuntimeInfo.cs

···
             if (OS == Platform.Windows)
             {
                 IntPtr hModule = GetModuleHandle(@"ntdll.dll");
+
                 if (hModule == IntPtr.Zero)
                     IsWine = false;
                 else

osu.Framework/Screens/IScreen.cs

···
                 case null:
                     onFail?.Invoke();
                     return;
+
                 case ScreenStack stack:
                     onRoot(stack);
                     break;
+
                 default:
                     runOnRoot(current.Parent, onRoot, onFail);
                     break;
···
                         return onFail.Invoke();
 
                     return default;
+
                 case ScreenStack stack:
                     return onRoot(stack);
+
                 default:
                     return runOnRoot(current.Parent, onRoot, onFail);
             }

osu.Framework/Statistics/PerformanceMonitor.cs

···
                 for (int i = 0; i < lastAmountGarbageCollects.Length; ++i)
                 {
                     int amountCollections = GC.CollectionCount(i);
+
                     if (lastAmountGarbageCollects[i] != amountCollections)
                     {
                         lastAmountGarbageCollects[i] = amountCollections;

osu.Framework/Testing/DrawFrameRecordingContainer.cs

···
                     currentFrame.Value = currentFrame.MaxValue = 0;
 
                     return base.GenerateDrawNodeSubtree(frame, treeIndex, forceNewDrawNode);
+
                 case RecordState.Recording:
                     var node = base.GenerateDrawNodeSubtree(frame, treeIndex, true);
 
···
                     currentFrame.Value = currentFrame.MaxValue = recordedFrames.Count - 1;
 
                     return node;
+
                 case RecordState.Stopped:
                     return recordedFrames[currentFrame.Value];
             }

osu.Framework/Testing/Drawables/Sections/ToolbarRecordSection.cs

···
                     recordButton.Text = "record";
                     playbackControls.Hide();
                     break;
+
                 case RecordState.Recording:
                     recordButton.Text = "stop";
                     playbackControls.Hide();
                     break;
+
                 case RecordState.Stopped:
                     recordButton.Text = "reset";
                     playbackControls.Show();

osu.Framework/Testing/Drawables/TestSceneButton.cs

···
             text.AddText(TestScene.RemovePrefix(test.Name));
 
             var description = test.GetCustomAttribute<DescriptionAttribute>()?.Description;
+
             if (description != null)
             {
                 text.NewLine();

osu.Framework/Testing/Input/ManualInputManager.cs

···
                         case MouseButton.Left:
                             left.FadeIn();
                             break;
+
                         case MouseButton.Right:
                             right.FadeIn();
                             break;
···
                         case MouseButton.Left:
                             left.FadeOut(500);
                             break;
+
                         case MouseButton.Right:
                             right.FadeOut(500);
                             break;

osu.Framework/Testing/TestBrowser.cs

···
                 backgroundCompiler.CompilationStarted += compileStarted;
                 backgroundCompiler.CompilationFinished += compileFinished;
                 backgroundCompiler.CompilationFailed += compileFailed;
+
                 try
                 {
                     backgroundCompiler.Start();
···
                     if (leftContainer.Width == 0) toggleTestList();
                     GetContainingInputManager().ChangeFocus(searchTextBox);
                     return true;
+
                 case TestBrowserAction.Reload:
                     LoadTest(CurrentTest.GetType());
                     return true;
+
                 case TestBrowserAction.ToggleTestList:
                     toggleTestList();
                     return true;

osu.Framework/Testing/TestScene.cs

···
                 throw new InvalidCastException($"The test runner must be a {nameof(Game)}.");
 
             runTask = Task.Factory.StartNew(() => host.Run(game), TaskCreationOptions.LongRunning);
+
             while (!game.IsLoaded)
             {
                 checkForErrors();