Cleanup from rebase

Added deterministic cleanup for managed VwDrawRootBuffered cached GDI buffers in VwDrawRootBuffered.cs.
Disposed capture-created VwDrawRootBuffered instances in CompositeViewCapture.cs and RenderBenchmarkHarness.cs.
Hardened DataTree render harness teardown in DataTreeRenderHarness.cs, keeping root-site quiescing on shutdown rather than altering capture semantics.
Guarded LabeledMultiStringView layout/disposal against late root-site painting/layout in LabeledMultiStringView.cs.
Removed the temporary [ROOTSITE-DRAW-ERROR] diagnostic from SimpleRootSite.cs.

Co-authored-by: Copilot <copilot@github.com>

Author: johnml1135

Src/Common/Controls/Widgets/LabeledMultiStringView.cs

@@ -150,6 +150,12 @@ protected override void Dispose(bool disposing)
 			if (IsDisposed)
 				return;
 
+			if (disposing && m_innerView != null)
+			{
+				m_innerView.AllowPainting = false;
+				m_innerView.AllowLayout = false;
+			}
+
 			base.Dispose(disposing);
 
 			if (disposing)
@@ -253,6 +259,8 @@ CoreWritingSystemDefinition WsForSoundField(ShortSoundFieldControl sc, out int w
 		protected override void OnLayout(LayoutEventArgs levent)
 		{
 			base.OnLayout(levent);
+			if (IsDisposed || Disposing || !IsHandleCreated)
+				return;
 			if (m_innerView.VC == null || m_innerView.RootBox == null) // We can come in with no rootb from a dispose call.
 				return;
 			if (Visible)

Src/Common/Controls/XMLViews/XmlBrowseRDEView.cs

@@ -12,6 +12,7 @@
 using SIL.LCModel.Core.Text;
 using SIL.LCModel.Core.KernelInterfaces;
 using SIL.FieldWorks.Common.FwUtils;
+using static SIL.FieldWorks.Common.FwUtils.FwUtils;
 using SIL.LCModel;
 using SIL.FieldWorks.Common.RootSites;
 using SIL.LCModel.Application;

Src/Common/RenderVerification/CompositeViewCapture.cs

@@ -185,6 +185,14 @@ private static void EnsureAllSlicesInitialized(DataTree dataTree)
 					// Set the slice visible (required for DrawToBitmap to include it).
 					if (!slice.Visible)
 						slice.Visible = true;
+
+					var viewSlice = slice as ViewSlice;
+					if (viewSlice != null)
+					{
+						var rootSite = viewSlice.RootSite;
+						if (rootSite != null && rootSite.RootBox != null)
+							rootSite.AllowLayout = true;
+					}
 				}
 				catch (Exception ex)
 				{
@@ -350,10 +358,12 @@ private static void OverlaySingleViewSlice(ViewSlice viewSlice, DataTree dataTre
 					IntPtr tempHdc = tempGraphics.GetHdc();
 					try
 					{
-						var vdrb = new SIL.FieldWorks.Views.VwDrawRootBuffered();
-						var localRect = new Rect(0, 0, rootSiteRect.Width, rootSiteRect.Height);
-						const uint whiteColor = 0x00FFFFFF;
-						vdrb.DrawTheRoot(rootBox, tempHdc, localRect, whiteColor, true, rootSite);
+						using (var vdrb = new SIL.FieldWorks.Views.VwDrawRootBuffered())
+						{
+							var localRect = new Rect(0, 0, rootSiteRect.Width, rootSiteRect.Height);
+							const uint whiteColor = 0x00FFFFFF;
+							vdrb.DrawTheRoot(rootBox, tempHdc, localRect, whiteColor, true, rootSite);
+						}
 					}
 					finally
 					{

Src/Common/RenderVerification/DataTreeRenderHarness.cs

@@ -12,6 +12,8 @@
 using System.Xml;
 using SIL.FieldWorks.Common.Framework.DetailControls;
 using SIL.FieldWorks.Common.FwUtils;
+using SIL.FieldWorks.Common.RootSites;
+using SIL.FieldWorks.Common.ViewsInterfaces;
 using SIL.LCModel;
 using XCore;
 
@@ -282,8 +284,10 @@ public Bitmap CaptureCompositeBitmap()
 			if (m_dataTree == null)
 				throw new InvalidOperationException("Call PopulateSlices before capturing.");
 
+			bool wasVisible = m_dataTree.Visible;
 			try
 			{
+				m_dataTree.Visible = true;
 				var bitmap = CompositeViewCapture.CaptureDataTree(m_dataTree, m_captureWidth);
 				LastCapture = bitmap;
 				return bitmap;
@@ -293,6 +297,11 @@ public Bitmap CaptureCompositeBitmap()
 				Trace.TraceWarning($"[DataTreeRenderHarness] Composite capture failed: {ex.Message}");
 				return null;
 			}
+			finally
+			{
+				if (m_dataTree != null)
+					m_dataTree.Visible = wasVisible;
+			}
 		}
 
 		/// <summary>
@@ -439,19 +448,30 @@ private void LoadTestInventories()
 
 		private void DisposeResources()
 		{
-			if (m_dataTree != null)
-			{
-				// DataTree gets disposed by form.Close since it's in Controls
-				m_dataTree = null;
-			}
-
 			if (m_hostForm != null)
 			{
+				if (m_dataTree != null)
+				{
+					m_dataTree.Enabled = false;
+					m_dataTree.Visible = false;
+					m_hostForm.Visible = false;
+					SuppressHostedRootSiteDrawing(m_dataTree);
+					DrainHostedRootBoxDrawingErrors(m_dataTree);
+					QuiesceHostedRootSites(m_dataTree);
+					m_dataTree.Reset();
+				}
+
 				m_hostForm.Close();
 				m_hostForm.Dispose();
 				m_hostForm = null;
 			}
 
+			if (m_dataTree != null)
+			{
+				// DataTree gets disposed by form.Close since it's in Controls
+				m_dataTree = null;
+			}
+
 			if (m_propertyTable != null)
 			{
 				m_propertyTable.Dispose();
@@ -465,6 +485,132 @@ private void DisposeResources()
 			}
 		}
 
+		private void QuiesceHostedRootSites(DataTree dataTree)
+		{
+			var rootSites = new HashSet<SimpleRootSite>();
+			CollectHostedRootSites(dataTree, rootSites);
+			foreach (var rootSite in rootSites)
+				QuiesceRootSite(rootSite);
+		}
+
+		private void DrainHostedRootBoxDrawingErrors(DataTree dataTree)
+		{
+			var rootSites = new HashSet<SimpleRootSite>();
+			CollectHostedRootSites(dataTree, rootSites);
+			foreach (var rootSite in rootSites)
+				DrainRootBoxDrawingErrors(rootSite);
+		}
+
+		private void SuppressHostedRootSiteDrawing(DataTree dataTree)
+		{
+			var rootSites = new HashSet<SimpleRootSite>();
+			CollectHostedRootSites(dataTree, rootSites);
+			foreach (var rootSite in rootSites)
+				SuppressRootSiteDrawing(rootSite);
+		}
+
+		private void CollectHostedRootSites(DataTree dataTree, ISet<SimpleRootSite> rootSites)
+		{
+			if (dataTree.Slices != null)
+			{
+				foreach (Slice slice in dataTree.Slices)
+				{
+					var viewSlice = slice as ViewSlice;
+					if (viewSlice == null)
+						continue;
+
+					try
+					{
+						var rootSite = viewSlice.RootSite;
+						if (rootSite != null)
+							rootSites.Add(rootSite);
+					}
+					catch
+					{
+						// Shutdown path only: slices may already be partially disposed.
+					}
+				}
+			}
+
+			CollectRootSites(dataTree, rootSites);
+		}
+
+		private void CollectRootSites(Control control, ISet<SimpleRootSite> rootSites)
+		{
+			if (control == null)
+				return;
+
+			var rootSite = control as SimpleRootSite;
+			if (rootSite != null)
+				rootSites.Add(rootSite);
+
+			foreach (Control child in control.Controls)
+				CollectRootSites(child, rootSites);
+		}
+
+		private void QuiesceRootSite(SimpleRootSite rootSite)
+		{
+			try
+			{
+				SuppressRootSiteDrawing(rootSite);
+				rootSite.AboutToDiscard();
+				rootSite.CloseRootBox();
+			}
+			catch
+			{
+				// Shutdown path only: controls may already be partially disposed.
+			}
+		}
+
+		private void SuppressRootSiteDrawing(SimpleRootSite rootSite)
+		{
+			try
+			{
+				rootSite.AllowPainting = false;
+				rootSite.AllowLayout = false;
+				rootSite.Visible = false;
+			}
+			catch
+			{
+				// Shutdown path only: controls may already be partially disposed.
+			}
+		}
+
+		private void DrainRootBoxDrawingErrors(SimpleRootSite rootSite)
+		{
+			IVwRootBox rootBox = null;
+			try
+			{
+				rootBox = rootSite.RootBox;
+			}
+			catch
+			{
+				return;
+			}
+
+			if (rootBox == null)
+				return;
+
+			IVwGraphics graphics = null;
+			try
+			{
+				Rect sourceRectangle;
+				Rect destinationRectangle;
+				rootSite.GetGraphics(rootBox, out graphics, out sourceRectangle, out destinationRectangle);
+				rootBox.DrawingErrors(graphics);
+			}
+			catch (Exception ex)
+			{
+				Trace.TraceWarning(
+					$"[DataTreeRenderHarness] Suppressed deferred drawing error for '{rootSite.Name}': {ex.Message}");
+			}
+			finally
+			{
+				if (graphics != null)
+					rootSite.ReleaseGraphics(rootBox, graphics);
+			}
+		}
+
 		/// <summary>Releases all resources used by the harness.</summary>
 		public void Dispose()
 		{

Src/Common/RootSite/RootSiteTests/RenderBenchmarkHarness.cs

@@ -272,10 +272,12 @@ public Bitmap CaptureViewBitmap()
 							IntPtr hdc = graphics.GetHdc();
 							try
 							{
-								var vdrb = new SIL.FieldWorks.Views.VwDrawRootBuffered();
-								var clientRect = new Rect(0, 0, width, height);
-								const uint whiteColor = 0x00FFFFFF;
-								vdrb.DrawTheRoot(m_view.RootBox, hdc, clientRect, whiteColor, true, m_view);
+								using (var vdrb = new SIL.FieldWorks.Views.VwDrawRootBuffered())
+								{
+									var clientRect = new Rect(0, 0, width, height);
+									const uint whiteColor = 0x00FFFFFF;
+									vdrb.DrawTheRoot(m_view.RootBox, hdc, clientRect, whiteColor, true, m_view);
+								}
 							}
 							finally
 							{

Src/Common/SimpleRootSite/SimpleRootSite.cs

@@ -533,6 +533,8 @@ protected override void Dispose(bool disposing)
 
 			if (m_vdrb != null && Marshal.IsComObject(m_vdrb))
 				Marshal.ReleaseComObject(m_vdrb);
+			else if (m_vdrb is IDisposable disposableVdrb)
+				disposableVdrb.Dispose();
 			m_vdrb = null;
 			if (m_styleSheet != null && Marshal.IsComObject(m_styleSheet))
 				Marshal.ReleaseComObject(m_styleSheet);

Src/ManagedVwDrawRootBuffered/VwDrawRootBuffered.cs

@@ -17,9 +17,10 @@ namespace SIL.FieldWorks.Views
 	/// </summary>
 	[ComVisible(true)]
 	[Guid("97199458-10C7-49da-B3AE-EA922EA64859")]
-	public class VwDrawRootBuffered : IVwDrawRootBuffered
+	public class VwDrawRootBuffered : IVwDrawRootBuffered, IDisposable
 	{
 		private GdiMemoryBuffer m_cachedBuffer;
+		private bool m_isDisposed;
 
 		private class GdiMemoryBuffer : IDisposable
 		{
@@ -105,6 +106,27 @@ private void ReplaceCachedBuffer(GdiMemoryBuffer newBuffer)
 			m_cachedBuffer = newBuffer;
 		}
 
+		public void Dispose()
+		{
+			Dispose(true);
+			GC.SuppressFinalize(this);
+		}
+
+		~VwDrawRootBuffered()
+		{
+			Dispose(false);
+		}
+
+		protected virtual void Dispose(bool disposing)
+		{
+			if (m_isDisposed)
+				return;
+
+			m_cachedBuffer?.Dispose();
+			m_cachedBuffer = null;
+			m_isDisposed = true;
+		}
+
 		/// <summary>
 		/// See C++ documentation
 		/// </summary>