Merge pull request #4439 from tig/v2_4431-MainLoop

Tests/UnitTestsParallelizable/Application/IApplicationScreenChangedTests.cs

@@ -383,7 +383,7 @@ public class IApplicationScreenChangedTests (ITestOutputHelper output)
     }
 
     [Fact]
-    public void Screen_Property_Setting_Does_Not_Fire_ScreenChanged_Event ()
+    public void Screen_Property_Setting_Raises_ScreenChanged_Event ()
     {
         // Arrange
         using IApplication app = Application.Create ();
@@ -397,11 +397,10 @@ public class IApplicationScreenChangedTests (ITestOutputHelper output)
 
         try
         {
-            // Act - Manually set Screen property (not via driver resize)
+            // Act - Manually set Screen property 
             app.Screen = new (0, 0, 100, 50);
 
-            // Assert - Event should not fire for manual property setting
-            Assert.False (eventFired);
+            Assert.True (eventFired);
             Assert.Equal (new (0, 0, 100, 50), app.Screen);
         }
         finally

Tests/UnitTestsParallelizable/Drawing/Lines/StraightLineExtensionsTests.cs

@@ -1,7 +1,7 @@
 using UnitTests;
 using Xunit.Abstractions;
 
-namespace UnitTests.Parallelizable.Drawing.Lines;
+namespace DrawingTests.Lines;
 
 public class StraightLineExtensionsTests (ITestOutputHelper output)
 {

Tests/UnitTestsParallelizable/Drawing/Lines/StraightLineTests.cs

@@ -1,6 +1,6 @@
 using Xunit.Abstractions;
 
-namespace UnitTests.Parallelizable.Drawing.Lines;
+namespace DrawingTests.Lines;
 
 public class StraightLineTests (ITestOutputHelper output)
 {

Tests/UnitTestsParallelizable/ViewBase/Adornment/AdornmentTests.cs

@@ -10,7 +10,7 @@ public class AdornmentTests
     //    public bool PaddingDrawn { get; set; }
 
     //    /// <inheritdoc />
-    //    protected override bool OnDrawingContent () 
+    //    protected override bool OnDrawingContent (DrawContext? context) 
     //    {
     //        if (Border is { } && Border.Thickness != Thickness.Empty)
     //        {

Tests/UnitTestsParallelizable/ViewBase/Draw/ClearViewportTests.cs

@@ -0,0 +1,339 @@
+using Moq;
+using UnitTests;
+using Xunit.Abstractions;
+
+namespace ViewBaseTests.Viewport;
+
+[Trait ("Category", "Output")]
+public class ClearViewportTests (ITestOutputHelper output)
+{
+    public class TestableView : View
+    {
+        public TestableView ()
+        {
+            Frame = new Rectangle (0, 0, 10, 10);
+        }
+
+        public bool TestOnClearingViewport () { return OnClearingViewport (); }
+
+        public int OnClearingViewportCalled { get; set; }
+        public bool CancelOnClearingViewport { get; set; }
+
+        protected override bool OnClearingViewport ()
+        {
+            OnClearingViewportCalled++;
+
+            return CancelOnClearingViewport;
+        }
+
+        public int OnClearedViewportCalled { get; set; }
+        protected override void OnClearedViewport () { OnClearedViewportCalled++; }
+    }
+
+    [Fact]
+    public void DoClearViewport_ViewportIsTransparent_DoesNotClear ()
+    {
+        // Arrange
+        Mock<TestableView> view = new () { CallBase = true };
+        view.Object.ViewportSettings = ViewportSettingsFlags.Transparent;
+
+        // Act
+        view.Object.DoClearViewport ();
+
+        // Assert
+        Assert.Equal (0, view.Object.OnClearingViewportCalled);
+        Assert.Equal (0, view.Object.OnClearedViewportCalled);
+    }
+
+    [Fact]
+    public void DoClearViewport_OnClearingViewportReturnsTrue_DoesNotClear ()
+    {
+        // Arrange
+        Mock<TestableView> view = new () { CallBase = true };
+        view.Object.CancelOnClearingViewport = true;
+
+        // Act
+        view.Object.DoClearViewport ();
+
+        // Assert
+        Assert.Equal (0, view.Object.OnClearedViewportCalled);
+    }
+
+    [Fact]
+    public void DoClearViewport_ClearingViewportEventCancelled_DoesNotClear ()
+    {
+        // Arrange
+        Mock<TestableView> view = new () { CallBase = true };
+        view.Object.ClearingViewport += (sender, e) => e.Cancel = true;
+
+        // Act
+        view.Object.DoClearViewport ();
+
+        // Assert
+        Assert.Equal (0, view.Object.OnClearedViewportCalled);
+    }
+
+    [Fact]
+    public void DoClearViewport_ClearsViewport ()
+    {
+        // Arrange
+        Mock<TestableView> view = new () { CallBase = true };
+
+        // Act
+        view.Object.SetNeedsDraw ();
+        view.Object.DoClearViewport ();
+
+        // Assert
+        Assert.Equal (1, view.Object.OnClearedViewportCalled);
+    }
+
+    [Fact]
+    public void DoClearViewport_RaisesClearingViewportEvent ()
+    {
+        // Arrange
+        Mock<TestableView> view = new () { CallBase = true };
+        var eventRaised = false;
+        view.Object.ClearingViewport += (sender, e) => eventRaised = true;
+
+        // Act
+        view.Object.SetNeedsDraw ();
+        view.Object.DoClearViewport ();
+
+        // Assert
+        Assert.True (eventRaised);
+    }
+
+    [Fact]
+    public void Clear_ClearsEntireViewport ()
+    {
+        using IApplication? app = Application.Create ();
+        app.Init ("Fake");
+
+        var superView = new Runnable
+        {
+            Width = Dim.Fill (), Height = Dim.Fill ()
+        };
+
+        var view = new View
+        {
+            Text = "X",
+            X = 1, Y = 1,
+            Width = 3, Height = 3,
+            BorderStyle = LineStyle.Single
+        };
+        superView.Add (view);
+        app.Begin (superView);
+        superView.LayoutSubViews ();
+        superView.Draw ();
+
+        DriverAssert.AssertDriverContentsWithFrameAre (
+                                                       @"
+ ┌─┐
+ │X│
+ └─┘",
+                                                       output,
+                                                       app.Driver);
+
+        // On Draw exit the view is excluded from the clip, so this will do nothing.
+        view.ClearViewport ();
+
+        DriverAssert.AssertDriverContentsWithFrameAre (
+                                                       @"
+ ┌─┐
+ │X│
+ └─┘",
+                                                       output,
+                                                       app.Driver);
+
+
+        view.SetClipToScreen ();
+
+        view.ClearViewport ();
+
+        DriverAssert.AssertDriverContentsWithFrameAre (
+                                                       @"
+ ┌─┐
+ │ │
+ └─┘",
+                                                       output,
+                                                       app.Driver);
+    }
+
+    [Fact]
+    public void Clear_WithClearVisibleContentOnly_ClearsVisibleContentOnly ()
+    {
+        using IApplication? app = Application.Create ();
+        app.Init ("Fake");
+
+        var superView = new Runnable
+        {
+            Width = Dim.Fill (), Height = Dim.Fill ()
+        };
+
+        var view = new View
+        {
+            Text = "X",
+            X = 1, Y = 1,
+            Width = 3, Height = 3,
+            BorderStyle = LineStyle.Single,
+            ViewportSettings = ViewportSettingsFlags.ClearContentOnly
+        };
+        superView.Add (view);
+        app.Begin (superView);
+        superView.LayoutSubViews ();
+
+        superView.Draw ();
+
+        DriverAssert.AssertDriverContentsWithFrameAre (
+                                                       @"
+ ┌─┐
+ │X│
+ └─┘",
+                                                       output,
+                                                       app.Driver);
+        view.SetClipToScreen ();
+        view.ClearViewport ();
+
+        DriverAssert.AssertDriverContentsWithFrameAre (
+                                                       @"
+ ┌─┐
+ │ │
+ └─┘",
+                                                       output,
+                                                       app.Driver);
+    }
+
+    [Fact]
+    public void Clear_Viewport_Can_Use_Driver_AddRune_Or_AddStr_Methods ()
+    {
+        using IApplication? app = Application.Create ();
+        app.Init ("Fake");
+        var view = new FrameView {  Width = Dim.Fill (), Height = Dim.Fill (), BorderStyle = LineStyle.Single };
+
+        view.DrawingContent += (s, e) =>
+                               {
+                                   Region? savedClip = view.AddViewportToClip ();
+
+                                   for (var row = 0; row < view.Viewport.Height; row++)
+                                   {
+                                       app.Driver?.Move (1, row + 1);
+
+                                       for (var col = 0; col < view.Viewport.Width; col++)
+                                       {
+                                           app.Driver?.AddStr ($"{col}");
+                                       }
+                                   }
+
+                                   view.SetClip (savedClip);
+                                   e.Cancel = true;
+                               };
+        var top = new Runnable ();
+        top.Add (view);
+        app.Begin (top);
+        app.Driver!.SetScreenSize (20, 10);
+        app.LayoutAndDraw ();
+
+        var expected = @"
+┌──────────────────┐
+│012345678910111213│
+│012345678910111213│
+│012345678910111213│
+│012345678910111213│
+│012345678910111213│
+│012345678910111213│
+│012345678910111213│
+│012345678910111213│
+└──────────────────┘
+"
+            ;
+
+        Rectangle pos = DriverAssert.AssertDriverContentsWithFrameAre (expected, output, app.Driver);
+        Assert.Equal (new (0, 0, 20, 10), pos);
+
+        view.FillRect (view.Viewport);
+
+        expected = @"
+┌──────────────────┐
+│                  │
+│                  │
+│                  │
+│                  │
+│                  │
+│                  │
+│                  │
+│                  │
+└──────────────────┘
+"
+            ;
+
+        pos = DriverAssert.AssertDriverContentsWithFrameAre (expected, output, app.Driver);
+        top.Dispose ();
+    }
+
+    [Fact]
+    public void Clear_Can_Use_Driver_AddRune_Or_AddStr_Methods ()
+    {
+        using IApplication? app = Application.Create ();
+        app.Init ("Fake");
+        var view = new FrameView { Width = Dim.Fill (), Height = Dim.Fill (), BorderStyle = LineStyle.Single };
+
+        view.DrawingContent += (s, e) =>
+                               {
+                                   Region? savedClip = view.AddViewportToClip ();
+
+                                   for (var row = 0; row < view.Viewport.Height; row++)
+                                   {
+                                       app.Driver?.Move (1, row + 1);
+
+                                       for (var col = 0; col < view.Viewport.Width; col++)
+                                       {
+                                           app.Driver?.AddStr ($"{col}");
+                                       }
+                                   }
+
+                                   view.SetClip (savedClip);
+                                   e.Cancel = true;
+                               };
+        var top = new Runnable ();
+        top.Add (view);
+        app.Begin (top);
+        app.Driver!.SetScreenSize (20, 10);
+        app.LayoutAndDraw ();
+
+        var expected = @"
+┌──────────────────┐
+│012345678910111213│
+│012345678910111213│
+│012345678910111213│
+│012345678910111213│
+│012345678910111213│
+│012345678910111213│
+│012345678910111213│
+│012345678910111213│
+└──────────────────┘
+"
+            ;
+
+        Rectangle pos = DriverAssert.AssertDriverContentsWithFrameAre (expected, output, app.Driver);
+        Assert.Equal (new (0, 0, 20, 10), pos);
+
+        view.FillRect (view.Viewport);
+
+        expected = @"
+┌──────────────────┐
+│                  │
+│                  │
+│                  │
+│                  │
+│                  │
+│                  │
+│                  │
+│                  │
+└──────────────────┘
+";
+
+        pos = DriverAssert.AssertDriverContentsWithFrameAre (expected, output, app.Driver);
+
+        top.Dispose ();
+    }
+}

Tests/UnitTestsParallelizable/ViewBase/Draw/NeedsDrawTests.cs

@@ -69,7 +69,7 @@ public class NeedsDrawTests : FakeDriverBase
         view.BeginInit ();
         Assert.True (view.NeedsDraw);
 
-        view.NeedsDraw = false;
+        view.ClearNeedsDraw ();
 
         view.BeginInit ();
         Assert.False (view.NeedsDraw); // Because layout is still needed
@@ -94,7 +94,7 @@ public class NeedsDrawTests : FakeDriverBase
 
         view = new () { Width = 2, Height = 2, BorderStyle = LineStyle.Single };
         view.BeginInit ();
-        view.NeedsDraw = false;
+        view.ClearNeedsDraw ();
         view.EndInit ();
         Assert.True (view.NeedsDraw);
     }
@@ -145,7 +145,7 @@ public class NeedsDrawTests : FakeDriverBase
         Assert.True (view.NeedsDraw);
         Assert.False (view.NeedsLayout);
 
-        view.NeedsDraw = false;
+        view.ClearNeedsDraw ();
 
         // SRL won't change anything since the view frame wasn't changed. However, Layout has not been called
         view.SetRelativeLayout (new (10, 10));
@@ -199,7 +199,7 @@ public class NeedsDrawTests : FakeDriverBase
         superView.Layout ();
         Assert.True (superView.NeedsDraw);
 
-        superView.NeedsDraw = false;
+        superView.ClearNeedsDraw ();
         superView.SetRelativeLayout (new (10, 10));
         Assert.True (superView.NeedsDraw);
     }
@@ -311,4 +311,378 @@ public class NeedsDrawTests : FakeDriverBase
         Assert.Equal (new (1, 1, 5, 5), view.Viewport);
         Assert.Equal (new (1, 1, 5, 5), view.NeedsDrawRect);
     }
+
+    [Fact]
+    public void ClearNeedsDraw_ClearsOwnFlags ()
+    {
+        // Verify that ClearNeedsDraw properly clears the view's own flags
+        IDriver driver = CreateFakeDriver (80, 25);
+        driver.Clip = new Region (driver.Screen);
+
+        var view = new View
+        {
+            X = 0,
+            Y = 0,
+            Width = 20,
+            Height = 20,
+            Driver = driver
+        };
+        view.BeginInit ();
+        view.EndInit ();
+        view.LayoutSubViews ();
+
+        Assert.True (view.NeedsDraw);
+        Assert.Equal (view.Viewport, view.NeedsDrawRect);
+
+        view.Draw ();
+
+        Assert.False (view.NeedsDraw);
+        Assert.Equal (Rectangle.Empty, view.NeedsDrawRect);
+        Assert.False (view.SubViewNeedsDraw);
+    }
+
+    [Fact]
+    public void ClearNeedsDraw_ClearsAdornments ()
+    {
+        // Verify that ClearNeedsDraw clears adornment flags
+        IDriver driver = CreateFakeDriver (80, 25);
+        driver.Clip = new Region (driver.Screen);
+
+        var view = new View
+        {
+            X = 0,
+            Y = 0,
+            Width = 20,
+            Height = 20,
+            Driver = driver
+        };
+        view.Border!.Thickness = new Thickness (1);
+        view.Padding!.Thickness = new Thickness (1);
+        view.BeginInit ();
+        view.EndInit ();
+        view.LayoutSubViews ();
+
+        Assert.True (view.Border!.NeedsDraw);
+        Assert.True (view.Padding!.NeedsDraw);
+
+        view.Draw ();
+
+        Assert.False (view.Border!.NeedsDraw);
+        Assert.False (view.Padding!.NeedsDraw);
+    }
+
+    [Fact]
+    public void ClearNeedsDraw_PropagatesDownToAllSubViews ()
+    {
+        // Verify that ClearNeedsDraw clears flags on all descendants
+        IDriver driver = CreateFakeDriver (80, 25);
+        driver.Clip = new Region (driver.Screen);
+
+        var topView = new View
+        {
+            X = 0,
+            Y = 0,
+            Width = 100,
+            Height = 100,
+            Driver = driver
+        };
+
+        var middleView = new View { X = 10, Y = 10, Width = 50, Height = 50 };
+        var bottomView = new View { X = 5, Y = 5, Width = 20, Height = 20 };
+
+        topView.Add (middleView);
+        middleView.Add (bottomView);
+        topView.BeginInit ();
+        topView.EndInit ();
+        topView.LayoutSubViews ();
+
+        Assert.True (topView.NeedsDraw);
+        Assert.True (middleView.NeedsDraw);
+        Assert.True (bottomView.NeedsDraw);
+
+        topView.Draw ();
+
+        Assert.False (topView.NeedsDraw);
+        Assert.False (topView.SubViewNeedsDraw);
+        Assert.False (middleView.NeedsDraw);
+        Assert.False (middleView.SubViewNeedsDraw);
+        Assert.False (bottomView.NeedsDraw);
+    }
+
+    #region NeedsDraw Tests
+
+    [Fact]
+    public void NeedsDraw_InitiallyFalse_WhenNotVisible ()
+    {
+        var view = new View { Visible = false };
+        view.BeginInit ();
+        view.EndInit ();
+
+        Assert.False (view.NeedsDraw);
+    }
+
+    [Fact]
+    public void NeedsDraw_TrueAfterSetNeedsDraw ()
+    {
+        var view = new View { X = 0, Y = 0, Width = 10, Height = 10 };
+        view.BeginInit ();
+        view.EndInit ();
+        view.LayoutSubViews ();
+
+        view.SetNeedsDraw ();
+
+        Assert.True (view.NeedsDraw);
+    }
+
+    [Fact]
+    public void NeedsDraw_ClearedAfterDraw ()
+    {
+        IDriver driver = CreateFakeDriver (80, 25);
+        driver.Clip = new Region (driver.Screen);
+
+        var view = new View
+        {
+            X = 0,
+            Y = 0,
+            Width = 10,
+            Height = 10,
+            Driver = driver
+        };
+        view.BeginInit ();
+        view.EndInit ();
+        view.LayoutSubViews ();
+
+        view.SetNeedsDraw ();
+        Assert.True (view.NeedsDraw);
+
+        view.Draw ();
+
+        Assert.False (view.NeedsDraw);
+    }
+
+    [Fact]
+    public void SetNeedsDraw_WithRectangle_UpdatesNeedsDrawRect ()
+    {
+        var view = new View { Driver = CreateFakeDriver (), X = 0, Y = 0, Width = 20, Height = 20 };
+        view.BeginInit ();
+        view.EndInit ();
+        view.LayoutSubViews ();
+
+        // After layout, view will have NeedsDrawRect set to the viewport
+        // We need to clear it first
+        view.Draw ();
+        Assert.False (view.NeedsDraw);
+        Assert.Equal (Rectangle.Empty, view.NeedsDrawRect);
+
+        var rect = new Rectangle (5, 5, 10, 10);
+        view.SetNeedsDraw (rect);
+
+        Assert.True (view.NeedsDraw);
+        Assert.Equal (rect, view.NeedsDrawRect);
+    }
+
+    [Fact]
+    public void SetNeedsDraw_MultipleRectangles_Expands ()
+    {
+        IDriver driver = CreateFakeDriver (80, 25);
+        driver.Clip = new Region (driver.Screen);
+
+        var view = new View { X = 0, Y = 0, Width = 30, Height = 30, Driver = driver };
+        view.BeginInit ();
+        view.EndInit ();
+        view.LayoutSubViews ();
+
+        // After layout, clear NeedsDraw
+        view.Draw ();
+        Assert.False (view.NeedsDraw);
+
+        view.SetNeedsDraw (new Rectangle (5, 5, 10, 10));
+        view.SetNeedsDraw (new Rectangle (15, 15, 10, 10));
+
+        // Should expand to cover the entire viewport when we have overlapping regions
+        // The current implementation expands to viewport size
+        Rectangle expected = new Rectangle (0, 0, 30, 30);
+        Assert.Equal (expected, view.NeedsDrawRect);
+    }
+
+    [Fact]
+    public void SetNeedsDraw_NotVisible_DoesNotSet ()
+    {
+        var view = new View
+        {
+            X = 0,
+            Y = 0,
+            Width = 10,
+            Height = 10,
+            Visible = false
+        };
+        view.BeginInit ();
+        view.EndInit ();
+
+        view.SetNeedsDraw ();
+
+        Assert.False (view.NeedsDraw);
+    }
+
+    [Fact]
+    public void SetNeedsDraw_PropagatesToSuperView ()
+    {
+        var parent = new View { X = 0, Y = 0, Width = 50, Height = 50 };
+        var child = new View { X = 10, Y = 10, Width = 20, Height = 20 };
+        parent.Add (child);
+        parent.BeginInit ();
+        parent.EndInit ();
+        parent.LayoutSubViews ();
+
+        child.SetNeedsDraw ();
+
+        Assert.True (child.NeedsDraw);
+        Assert.True (parent.SubViewNeedsDraw);
+    }
+
+    [Fact]
+    public void SetNeedsDraw_SetsAdornmentsNeedsDraw ()
+    {
+        var view = new View { X = 0, Y = 0, Width = 20, Height = 20 };
+        view.Border!.Thickness = new Thickness (1);
+        view.Padding!.Thickness = new Thickness (1);
+        view.BeginInit ();
+        view.EndInit ();
+        view.LayoutSubViews ();
+
+        view.SetNeedsDraw ();
+
+        Assert.True (view.Border!.NeedsDraw);
+        Assert.True (view.Padding!.NeedsDraw);
+    }
+
+
+    [Fact]
+    public void IndividualViewDraw_DoesNotClearSuperViewSubViewNeedsDraw ()
+    {
+        // This test validates that individual view Draw() calls should NOT clear the superview's
+        // SubViewNeedsDraw flag when sibling subviews still need drawing.
+        //
+        // This is the core behavior that enables the fix in the static Draw method.
+        IDriver driver = CreateFakeDriver ();
+        driver.Clip = new (driver.Screen);
+
+        View superview = new ()
+        {
+            X = 0,
+            Y = 0,
+            Width = 50,
+            Height = 50,
+            Driver = driver,
+            Id = "SuperView"
+        };
+
+        View subview1 = new () { X = 0, Y = 0, Width = 10, Height = 10, Id = "SubView1" };
+        View subview2 = new () { X = 0, Y = 10, Width = 10, Height = 10, Id = "SubView2" };
+
+        superview.Add (subview1, subview2);
+        superview.BeginInit ();
+        superview.EndInit ();
+        superview.LayoutSubViews ();
+
+        Assert.True (superview.SubViewNeedsDraw);
+        Assert.True (subview1.NeedsDraw);
+        Assert.True (subview2.NeedsDraw);
+
+        // Draw only subview1 (NOT using the static Draw method)
+        subview1.Draw ();
+
+        // SubView1 should be cleared
+        Assert.False (subview1.NeedsDraw);
+
+        // SubView2 still needs drawing
+        Assert.True (subview2.NeedsDraw);
+
+        // THE KEY ASSERTION: SuperView's SubViewNeedsDraw should STILL be true
+        // because subview2 still needs drawing
+        //
+        // This behavior is REQUIRED for the static Draw fix to work properly.
+        // ClearNeedsDraw() does NOT clear SuperView.SubViewNeedsDraw anymore.
+        Assert.True (superview.SubViewNeedsDraw,
+            "SuperView's SubViewNeedsDraw must remain true when subview2 still needs drawing");
+
+        // Now draw subview2
+        subview2.Draw ();
+        Assert.False (subview2.NeedsDraw);
+
+        // SuperView's SubViewNeedsDraw should STILL be true because only the superview
+        // itself (or the static Draw method on all subviews) should clear it
+        Assert.True (superview.SubViewNeedsDraw,
+            "SuperView's SubViewNeedsDraw should only be cleared by superview.Draw() or static Draw() on all subviews");
+    }
+
+    #endregion
+
+    #region SubViewNeedsDraw Tests
+
+    [Fact]
+    public void SubViewNeedsDraw_InitiallyFalse ()
+    {
+        IDriver driver = CreateFakeDriver (80, 25);
+        driver.Clip = new Region (driver.Screen);
+
+        var view = new View { Width = 10, Height = 10, Driver = driver };
+        view.BeginInit ();
+        view.EndInit ();
+        view.Draw (); // Draw once to clear initial NeedsDraw
+
+        Assert.False (view.SubViewNeedsDraw);
+    }
+
+    [Fact]
+    public void SetSubViewNeedsDraw_PropagatesUp ()
+    {
+        var grandparent = new View { X = 0, Y = 0, Width = 100, Height = 100 };
+        var parent = new View { X = 10, Y = 10, Width = 50, Height = 50 };
+        var child = new View { X = 5, Y = 5, Width = 20, Height = 20 };
+
+        grandparent.Add (parent);
+        parent.Add (child);
+        grandparent.BeginInit ();
+        grandparent.EndInit ();
+        grandparent.LayoutSubViews ();
+
+        child.SetSubViewNeedsDrawDownHierarchy ();
+
+        Assert.True (child.SubViewNeedsDraw);
+        Assert.True (parent.SubViewNeedsDraw);
+        Assert.True (grandparent.SubViewNeedsDraw);
+    }
+
+    [Fact]
+    public void SubViewNeedsDraw_ClearedAfterDraw ()
+    {
+        IDriver driver = CreateFakeDriver (80, 25);
+        driver.Clip = new Region (driver.Screen);
+
+        var parent = new View
+        {
+            X = 0,
+            Y = 0,
+            Width = 50,
+            Height = 50,
+            Driver = driver
+        };
+        var child = new View { X = 10, Y = 10, Width = 20, Height = 20 };
+        parent.Add (child);
+        parent.BeginInit ();
+        parent.EndInit ();
+        parent.LayoutSubViews ();
+
+        child.SetNeedsDraw ();
+        Assert.True (parent.SubViewNeedsDraw);
+
+        parent.Draw ();
+
+        Assert.False (parent.SubViewNeedsDraw);
+        Assert.False (child.SubViewNeedsDraw);
+    }
+
+    #endregion
+
 }

Tests/UnitTestsParallelizable/ViewBase/Draw/StaticDrawTests.cs

@@ -0,0 +1,201 @@
+#nullable enable
+using UnitTests;
+
+namespace ViewBaseTests.Drawing;
+
+/// <summary>
+/// Tests for the static View.Draw(IEnumerable&lt;View&gt;, bool) method
+/// </summary>
+[Trait ("Category", "Output")]
+public class StaticDrawTests : FakeDriverBase
+{
+    [Fact]
+    public void StaticDraw_ClearsSubViewNeedsDraw_AfterMarginDrawMargins ()
+    {
+        // This test validates the fix where the static Draw method calls ClearNeedsDraw()
+        // on all peer views after drawing them AND after calling Margin.DrawMargins().
+        //
+        // THE BUG (before the fix):
+        // Margin.DrawMargins() can cause SubViewNeedsDraw to be set on views in the hierarchy.
+        // This would leave SubViewNeedsDraw = true even after drawing completed.
+        //
+        // THE FIX (current code):
+        // The static Draw() method explicitly calls ClearNeedsDraw() on all peer views
+        // at the very end, AFTER Margin.DrawMargins(), clearing any SubViewNeedsDraw flags
+        // that were set during margin drawing.
+
+        IDriver driver = CreateFakeDriver ();
+        driver.Clip = new (driver.Screen);
+
+        // Create a view hierarchy where a subview's subview has a margin
+        // This reproduces the scenario where Margin.DrawMargins sets SubViewNeedsDraw
+        View superview = new ()
+        {
+            X = 0,
+            Y = 0,
+            Width = 60,
+            Height = 60,
+            Driver = driver,
+            Id = "SuperView"
+        };
+
+        View subview1 = new () { X = 0, Y = 0, Width = 40, Height = 40, Id = "SubView1" };
+        View subview2 = new () { X = 0, Y = 20, Width = 20, Height = 20, Id = "SubView2" };
+
+        // Add a subview to subview1 that has a margin with shadow
+        // This is key to reproducing the bug
+        View subSubView = new ()
+        {
+            X = 5,
+            Y = 5,
+            Width = 20,
+            Height = 20,
+            Id = "SubSubView"
+        };
+        subSubView.Margin!.Thickness = new (1);
+        subSubView.Margin.ShadowStyle = ShadowStyle.Transparent;
+
+        subview1.Add (subSubView);
+        superview.Add (subview1, subview2);
+
+        superview.BeginInit ();
+        superview.EndInit ();
+        superview.LayoutSubViews ();
+
+        // All views initially need drawing
+        Assert.True (superview.NeedsDraw);
+        Assert.True (superview.SubViewNeedsDraw);
+        Assert.True (subview1.NeedsDraw);
+        Assert.True (subview1.SubViewNeedsDraw);
+        Assert.True (subview2.NeedsDraw);
+        Assert.True (subSubView.NeedsDraw);
+        Assert.True (subSubView.Margin.NeedsDraw);
+
+        // Call the static Draw method on the subviews
+        // This will:
+        // 1. Call view.Draw() on each subview
+        // 2. Call Margin.DrawMargins() which may set SubViewNeedsDraw in the hierarchy
+        // 3. Call ClearNeedsDraw() on each subview to clean up
+        View.Draw (superview.InternalSubViews, force: false);
+
+        // After the static Draw completes:
+        // All subviews should have NeedsDraw = false
+        Assert.False (subview1.NeedsDraw, "SubView1 should not need drawing after Draw()");
+        Assert.False (subview2.NeedsDraw, "SubView2 should not need drawing after Draw()");
+        Assert.False (subSubView.NeedsDraw, "SubSubView should not need drawing after Draw()");
+        Assert.False (subSubView.Margin.NeedsDraw, "SubSubView's Margin should not need drawing after Draw()");
+
+        // SuperView's SubViewNeedsDraw should be false because the static Draw() method
+        // calls ClearNeedsDraw() on all the subviews at the end, AFTER Margin.DrawMargins()
+        // 
+        // BEFORE THE FIX: This would be TRUE because Margin.DrawMargins() would
+        //                 set SubViewNeedsDraw somewhere in the hierarchy and it
+        //                 wouldn't be cleared
+        // AFTER THE FIX: This is FALSE because the static Draw() calls ClearNeedsDraw()
+        //                at the very end, cleaning up any SubViewNeedsDraw flags set
+        //                by Margin.DrawMargins()
+        Assert.False (superview.SubViewNeedsDraw,
+                      "superview's SubViewNeedsDraw should be false after static Draw(). All subviews were drawn in the call to View.Draw");
+        Assert.False (subview1.SubViewNeedsDraw,
+                      "SubView1's SubViewNeedsDraw should be false after its subviews are drawn and cleared");
+    }
+
+    [Fact]
+    public void StaticDraw_WithForceTrue_SetsNeedsDrawOnAllViews ()
+    {
+        // Verify that when force=true, all views get SetNeedsDraw() called before drawing
+        IDriver driver = CreateFakeDriver ();
+        driver.Clip = new (driver.Screen);
+
+        View view1 = new () { X = 0, Y = 0, Width = 10, Height = 10, Driver = driver, Id = "View1" };
+        View view2 = new () { X = 10, Y = 0, Width = 10, Height = 10, Driver = driver, Id = "View2" };
+
+        view1.BeginInit ();
+        view1.EndInit ();
+        view2.BeginInit ();
+        view2.EndInit ();
+
+        // Manually clear their NeedsDraw flags
+        view1.Draw ();
+        view2.Draw ();
+        Assert.False (view1.NeedsDraw);
+        Assert.False (view2.NeedsDraw);
+
+        // Now call static Draw with force=true
+        View.Draw ([view1, view2], force: true);
+
+        // After drawing with force=true, they should be cleared again
+        Assert.False (view1.NeedsDraw);
+        Assert.False (view2.NeedsDraw);
+    }
+
+    [Fact]
+    public void StaticDraw_HandlesEmptyCollection ()
+    {
+        // Verify that calling Draw with an empty collection doesn't crash
+        View.Draw ([], force: false);
+        View.Draw ([], force: true);
+    }
+
+
+    [Fact]
+    public void StaticDraw_ClearsNestedSubViewNeedsDraw ()
+    {
+        // This test verifies that the static Draw method properly clears SubViewNeedsDraw
+        // flags throughout a nested view hierarchy after Margin.DrawMargins
+        IDriver driver = CreateFakeDriver ();
+        driver.Clip = new (driver.Screen);
+
+        View topView = new ()
+        {
+            X = 0,
+            Y = 0,
+            Width = 60,
+            Height = 60,
+            Driver = driver,
+            Id = "TopView"
+        };
+
+        View middleView1 = new () { X = 0, Y = 0, Width = 30, Height = 30, Id = "MiddleView1" };
+        View middleView2 = new () { X = 30, Y = 0, Width = 30, Height = 30, Id = "MiddleView2" };
+
+        View bottomView = new ()
+        {
+            X = 5,
+            Y = 5,
+            Width = 15,
+            Height = 15,
+            Id = "BottomView"
+        };
+
+        // Give the bottom view a margin to trigger the Margin.DrawMargins behavior
+        bottomView.Margin!.Thickness = new (1);
+        bottomView.Margin.ShadowStyle = ShadowStyle.Transparent;
+
+        middleView1.Add (bottomView);
+        topView.Add (middleView1, middleView2);
+
+        topView.BeginInit ();
+        topView.EndInit ();
+        topView.LayoutSubViews ();
+
+        Assert.True (topView.SubViewNeedsDraw);
+        Assert.True (middleView1.SubViewNeedsDraw);
+        Assert.True (bottomView.NeedsDraw);
+
+        // Draw the middle views using static Draw
+        View.Draw (topView.InternalSubViews, force: false);
+
+        // All SubViewNeedsDraw flags should be cleared after the static Draw
+        Assert.False (topView.SubViewNeedsDraw,
+            "TopView's SubViewNeedsDraw should be false after static Draw(). All subviews were drawn in the call to View.Draw");
+        Assert.False (middleView1.SubViewNeedsDraw,
+            "MiddleView1's SubViewNeedsDraw should be false after its subviews are drawn");
+        Assert.False (middleView2.SubViewNeedsDraw,
+            "MiddleView2's SubViewNeedsDraw should be false");
+        Assert.False (bottomView.NeedsDraw,
+            "BottomView should not need drawing after Draw()");
+        Assert.False (bottomView.Margin.NeedsDraw,
+            "BottomView's Margin should not need drawing after Draw()");
+    }
+}

Tests/UnitTestsParallelizable/ViewBase/Draw/ViewDrawTextAndLineCanvasTests.cs

@@ -205,34 +205,6 @@ public class ViewDrawTextAndLineCanvasTests () : FakeDriverBase
         Assert.True (eventRaised);
     }
 
-    [Fact]
-    public void DrewText_Event_Raised ()
-    {
-        IDriver driver = CreateFakeDriver (80, 25);
-        driver.Clip = new Region (driver.Screen);
-
-        bool eventRaised = false;
-
-        var view = new View
-        {
-            X = 10,
-            Y = 10,
-            Width = 20,
-            Height = 20,
-            Driver = driver,
-            Text = "Test"
-        };
-        view.BeginInit ();
-        view.EndInit ();
-        view.LayoutSubViews ();
-
-        view.DrewText += (s, e) => eventRaised = true;
-
-        view.Draw ();
-
-        Assert.True (eventRaised);
-    }
-
     #endregion
 
     #region LineCanvas Tests

Tests/UnitTestsParallelizable/ViewBase/Draw/ViewDrawingFlowTests.cs

@@ -6,222 +6,7 @@ namespace ViewBaseTests.Drawing;
 
 public class ViewDrawingFlowTests () : FakeDriverBase
 {
-    #region NeedsDraw Tests
-
-    [Fact]
-    public void NeedsDraw_InitiallyFalse_WhenNotVisible ()
-    {
-        var view = new View { Visible = false };
-        view.BeginInit ();
-        view.EndInit ();
-
-        Assert.False (view.NeedsDraw);
-    }
-
-    [Fact]
-    public void NeedsDraw_TrueAfterSetNeedsDraw ()
-    {
-        var view = new View { X = 0, Y = 0, Width = 10, Height = 10 };
-        view.BeginInit ();
-        view.EndInit ();
-        view.LayoutSubViews ();
-
-        view.SetNeedsDraw ();
-
-        Assert.True (view.NeedsDraw);
-    }
-
-    [Fact]
-    public void NeedsDraw_ClearedAfterDraw ()
-    {
-        IDriver driver = CreateFakeDriver (80, 25);
-        driver.Clip = new Region (driver.Screen);
-
-        var view = new View
-        {
-            X = 0,
-            Y = 0,
-            Width = 10,
-            Height = 10,
-            Driver = driver
-        };
-        view.BeginInit ();
-        view.EndInit ();
-        view.LayoutSubViews ();
-
-        view.SetNeedsDraw ();
-        Assert.True (view.NeedsDraw);
-
-        view.Draw ();
-
-        Assert.False (view.NeedsDraw);
-    }
-
-    [Fact]
-    public void SetNeedsDraw_WithRectangle_UpdatesNeedsDrawRect ()
-    {
-        var view = new View { Driver = CreateFakeDriver (), X = 0, Y = 0, Width = 20, Height = 20 };
-        view.BeginInit ();
-        view.EndInit ();
-        view.LayoutSubViews ();
-
-        // After layout, view will have NeedsDrawRect set to the viewport
-        // We need to clear it first
-        view.Draw ();
-        Assert.False (view.NeedsDraw);
-        Assert.Equal (Rectangle.Empty, view.NeedsDrawRect);
-
-        var rect = new Rectangle (5, 5, 10, 10);
-        view.SetNeedsDraw (rect);
-
-        Assert.True (view.NeedsDraw);
-        Assert.Equal (rect, view.NeedsDrawRect);
-    }
-
-    [Fact]
-    public void SetNeedsDraw_MultipleRectangles_Expands ()
-    {
-        IDriver driver = CreateFakeDriver (80, 25);
-        driver.Clip = new Region (driver.Screen);
-
-        var view = new View { X = 0, Y = 0, Width = 30, Height = 30, Driver = driver };
-        view.BeginInit ();
-        view.EndInit ();
-        view.LayoutSubViews ();
-
-        // After layout, clear NeedsDraw
-        view.Draw ();
-        Assert.False (view.NeedsDraw);
-
-        view.SetNeedsDraw (new Rectangle (5, 5, 10, 10));
-        view.SetNeedsDraw (new Rectangle (15, 15, 10, 10));
-
-        // Should expand to cover the entire viewport when we have overlapping regions
-        // The current implementation expands to viewport size
-        Rectangle expected = new Rectangle (0, 0, 30, 30);
-        Assert.Equal (expected, view.NeedsDrawRect);
-    }
-
-    [Fact]
-    public void SetNeedsDraw_NotVisible_DoesNotSet ()
-    {
-        var view = new View
-        {
-            X = 0,
-            Y = 0,
-            Width = 10,
-            Height = 10,
-            Visible = false
-        };
-        view.BeginInit ();
-        view.EndInit ();
-
-        view.SetNeedsDraw ();
-
-        Assert.False (view.NeedsDraw);
-    }
-
-    [Fact]
-    public void SetNeedsDraw_PropagatesToSuperView ()
-    {
-        var parent = new View { X = 0, Y = 0, Width = 50, Height = 50 };
-        var child = new View { X = 10, Y = 10, Width = 20, Height = 20 };
-        parent.Add (child);
-        parent.BeginInit ();
-        parent.EndInit ();
-        parent.LayoutSubViews ();
-
-        child.SetNeedsDraw ();
-
-        Assert.True (child.NeedsDraw);
-        Assert.True (parent.SubViewNeedsDraw);
-    }
-
-    [Fact]
-    public void SetNeedsDraw_SetsAdornmentsNeedsDraw ()
-    {
-        var view = new View { X = 0, Y = 0, Width = 20, Height = 20 };
-        view.Border!.Thickness = new Thickness (1);
-        view.Padding!.Thickness = new Thickness (1);
-        view.BeginInit ();
-        view.EndInit ();
-        view.LayoutSubViews ();
-
-        view.SetNeedsDraw ();
-
-        Assert.True (view.Border!.NeedsDraw);
-        Assert.True (view.Padding!.NeedsDraw);
-    }
-
-    #endregion
-
-    #region SubViewNeedsDraw Tests
-
-    [Fact]
-    public void SubViewNeedsDraw_InitiallyFalse ()
-    {
-        IDriver driver = CreateFakeDriver (80, 25);
-        driver.Clip = new Region (driver.Screen);
-
-        var view = new View { Width = 10, Height = 10, Driver = driver };
-        view.BeginInit ();
-        view.EndInit ();
-        view.Draw (); // Draw once to clear initial NeedsDraw
-
-        Assert.False (view.SubViewNeedsDraw);
-    }
-
-    [Fact]
-    public void SetSubViewNeedsDraw_PropagatesUp ()
-    {
-        var grandparent = new View { X = 0, Y = 0, Width = 100, Height = 100 };
-        var parent = new View { X = 10, Y = 10, Width = 50, Height = 50 };
-        var child = new View { X = 5, Y = 5, Width = 20, Height = 20 };
-
-        grandparent.Add (parent);
-        parent.Add (child);
-        grandparent.BeginInit ();
-        grandparent.EndInit ();
-        grandparent.LayoutSubViews ();
-
-        child.SetSubViewNeedsDraw ();
-
-        Assert.True (child.SubViewNeedsDraw);
-        Assert.True (parent.SubViewNeedsDraw);
-        Assert.True (grandparent.SubViewNeedsDraw);
-    }
-
-    [Fact]
-    public void SubViewNeedsDraw_ClearedAfterDraw ()
-    {
-        IDriver driver = CreateFakeDriver (80, 25);
-        driver.Clip = new Region (driver.Screen);
-
-        var parent = new View
-        {
-            X = 0,
-            Y = 0,
-            Width = 50,
-            Height = 50,
-            Driver = driver
-        };
-        var child = new View { X = 10, Y = 10, Width = 20, Height = 20 };
-        parent.Add (child);
-        parent.BeginInit ();
-        parent.EndInit ();
-        parent.LayoutSubViews ();
-
-        child.SetNeedsDraw ();
-        Assert.True (parent.SubViewNeedsDraw);
-
-        parent.Draw ();
-
-        Assert.False (parent.SubViewNeedsDraw);
-        Assert.False (child.SubViewNeedsDraw);
-    }
-
-    #endregion
-
+    
     #region Draw Visibility Tests
 
     [Fact]