Fix the converter to round the value

The issue in the bug was the left margin with rounding causing the UI thread to functionally loop prevent many UI features from working properly.

MaterialDesignThemes.Wpf/Converters/FloatingHintTextBlockMarginConverter.cs

@@ -1,4 +1,4 @@
-using System.Globalization;
+using System.Globalization;
 using System.Windows.Data;
 using System.Windows.Media;
 
@@ -25,89 +25,77 @@ internal class FloatingHintTextBlockMarginConverter : IMultiValueConverter
         HorizontalAlignment alignment = restingAlignment;
         if (scale != 0)
         {
-            switch (floatingAlignment)
+            alignment = floatingAlignment switch
             {
-                case FloatingHintHorizontalAlignment.Inherit:
-                    alignment = restingAlignment;
-                    break;
-                case FloatingHintHorizontalAlignment.Left:
-                    alignment = HorizontalAlignment.Left;
-                    break;
-                case FloatingHintHorizontalAlignment.Center:
-                    alignment = HorizontalAlignment.Center;
-                    break;
-                case FloatingHintHorizontalAlignment.Right:
-                    alignment = HorizontalAlignment.Right;
-                    break;
-                case FloatingHintHorizontalAlignment.Stretch:
-                    alignment = HorizontalAlignment.Stretch;
-                    break;
-                default:
-                    throw new ArgumentOutOfRangeException();
-            }
+                FloatingHintHorizontalAlignment.Inherit => restingAlignment,
+                FloatingHintHorizontalAlignment.Left => HorizontalAlignment.Left,
+                FloatingHintHorizontalAlignment.Center => HorizontalAlignment.Center,
+                FloatingHintHorizontalAlignment.Right => HorizontalAlignment.Right,
+                FloatingHintHorizontalAlignment.Stretch => HorizontalAlignment.Stretch,
+                _ => throw new ArgumentOutOfRangeException(),
+            };
         }
-        switch (alignment)
+        double leftThickness = alignment switch
         {
-            case HorizontalAlignment.Right:
-                return FloatRight();
-            case HorizontalAlignment.Center:
-                return FloatCenter();
-            default:
-                return FloatLeft();
-        }
+            HorizontalAlignment.Right => FloatRight(),
+            HorizontalAlignment.Center => FloatCenter(),
+            _ => FloatLeft(),
+        };
+
+        return new Thickness(Math.Round(leftThickness), 0, 0, 0);
 
-        Thickness FloatLeft()
+        double FloatLeft()
         {
             if (restingAlignment == HorizontalAlignment.Center)
             {
                 // Animate from center to left
                 double offset = Math.Max(0, (availableWidth - desiredWidth) / 2);
-                return new Thickness(offset - offset * scale, 0, 0, 0);
+                return offset - offset * scale;
             }
             if (restingAlignment == HorizontalAlignment.Right)
             {
                 // Animate from right to left
                 double offset = Math.Max(0, availableWidth - desiredWidth);
-                return new Thickness(offset - offset * scale, 0, 0, 0);
+                return offset - offset * scale;
             }
-            return new Thickness(0);
+            return 0;
         }
 
-        Thickness FloatCenter()
+        double FloatCenter()
         {
             if (restingAlignment == HorizontalAlignment.Left || restingAlignment == HorizontalAlignment.Stretch)
             {
                 // Animate from left to center
                 double offset = Math.Max(0, (availableWidth - desiredWidth * scaleMultiplier) / 2);
-                return new Thickness(offset * scale, 0, 0, 0);
+                return offset * scale;
             }
             if (restingAlignment == HorizontalAlignment.Right)
             {
                 // Animate from right to center
                 double startOffset = Math.Max(0, availableWidth - desiredWidth);
                 double endOffset = Math.Max(0, (availableWidth - desiredWidth) / 2);
                 double endOffsetDelta = startOffset - endOffset;
-                return new Thickness(endOffset + endOffsetDelta * (1 - scale), 0, 0, 0);
+                return endOffset + endOffsetDelta * (1 - scale);
             }
-            return new Thickness(Math.Max(0, availableWidth - desiredWidth * scaleMultiplier) / 2, 0, 0, 0);
+            return Math.Max(0, availableWidth - desiredWidth * scaleMultiplier) / 2;
         }
 
-        Thickness FloatRight()
+        double FloatRight()
         {
             if (restingAlignment == HorizontalAlignment.Left || restingAlignment == HorizontalAlignment.Stretch)
             {
                 // Animate from left to right
                 double offset = Math.Max(0, availableWidth - desiredWidth * scaleMultiplier);
-                return new Thickness(offset * scale, 0, 0, 0);
+                return offset * scale;
             }
             if (restingAlignment == HorizontalAlignment.Center)
             {
                 // Animate from center to right
                 double startOffset = Math.Max(0, (availableWidth - desiredWidth) / 2);
                 double endOffsetDelta = Math.Max(0, availableWidth - desiredWidth * scaleMultiplier) - startOffset;
-                return new Thickness(startOffset + endOffsetDelta * scale, 0, 0, 0);
+                return startOffset + endOffsetDelta * scale;
             }
-            return new Thickness(Math.Max(0, availableWidth - desiredWidth * scaleMultiplier), 0, 0, 0);
+            return Math.Max(0, availableWidth - desiredWidth * scaleMultiplier);
         }
     }