Browse Source

Fixed various invalidation and hit-testing issues

pull/8536/head
Nikita Tsukanov 4 years ago
parent
commit
4b7feeb4f4
  1. 34
      src/Avalonia.Base/Rendering/Composition/CompositingRenderer.cs
  2. 13
      src/Avalonia.Base/Rendering/Composition/CompositionDrawListVisual.cs
  3. 44
      src/Avalonia.Base/Rendering/Composition/CompositionTarget.cs
  4. 6
      src/Avalonia.Base/Rendering/Composition/ICompositionTargetDebugEvents.cs
  5. 3
      src/Avalonia.Base/Rendering/Composition/Server/ServerCompositionTarget.cs
  6. 35
      src/Avalonia.Base/Rendering/Composition/Server/ServerCompositionVisual.cs
  7. 10
      src/Avalonia.Base/Rendering/Composition/Transport/BatchStreamArrayPool.cs
  8. 2
      src/Avalonia.Base/Rendering/Composition/Visual.cs
  9. 417
      tests/Avalonia.Base.UnitTests/Rendering/CompositorHitTestingTests.cs
  10. 109
      tests/Avalonia.Base.UnitTests/Rendering/CompositorInvalidationTests.cs
  11. 208
      tests/Avalonia.Base.UnitTests/Rendering/CompositorTestsBase.cs
  12. 27
      tests/Avalonia.UnitTests/MockPlatformRenderInterface.cs

34
src/Avalonia.Base/Rendering/Composition/CompositingRenderer.cs

@ -24,11 +24,12 @@ public class CompositingRenderer : IRendererWithCompositor
DrawingContext _recordingContext; DrawingContext _recordingContext;
private HashSet<Visual> _dirty = new(); private HashSet<Visual> _dirty = new();
private HashSet<Visual> _recalculateChildren = new(); private HashSet<Visual> _recalculateChildren = new();
private readonly CompositionTarget _target;
private bool _queuedUpdate; private bool _queuedUpdate;
private Action _update; private Action _update;
private Action _invalidateScene; private Action _invalidateScene;
internal CompositionTarget CompositionTarget;
/// <summary> /// <summary>
/// Asks the renderer to only draw frames on the render thread. Makes Paint to wait until frame is rendered. /// Asks the renderer to only draw frames on the render thread. Makes Paint to wait until frame is rendered.
/// </summary> /// </summary>
@ -40,8 +41,8 @@ public class CompositingRenderer : IRendererWithCompositor
_root = root; _root = root;
_compositor = compositor; _compositor = compositor;
_recordingContext = new DrawingContext(_recorder); _recordingContext = new DrawingContext(_recorder);
_target = compositor.CreateCompositionTarget(root.CreateRenderTarget); CompositionTarget = compositor.CreateCompositionTarget(root.CreateRenderTarget);
_target.Root = ((Visual)root!.VisualRoot!).AttachToCompositor(compositor); CompositionTarget.Root = ((Visual)root!.VisualRoot!).AttachToCompositor(compositor);
_update = Update; _update = Update;
_invalidateScene = InvalidateScene; _invalidateScene = InvalidateScene;
} }
@ -49,15 +50,15 @@ public class CompositingRenderer : IRendererWithCompositor
/// <inheritdoc/> /// <inheritdoc/>
public bool DrawFps public bool DrawFps
{ {
get => _target.DrawFps; get => CompositionTarget.DrawFps;
set => _target.DrawFps = value; set => CompositionTarget.DrawFps = value;
} }
/// <inheritdoc/> /// <inheritdoc/>
public bool DrawDirtyRects public bool DrawDirtyRects
{ {
get => _target.DrawDirtyRects; get => CompositionTarget.DrawDirtyRects;
set => _target.DrawDirtyRects = value; set => CompositionTarget.DrawDirtyRects = value;
} }
/// <inheritdoc/> /// <inheritdoc/>
@ -81,12 +82,11 @@ public class CompositingRenderer : IRendererWithCompositor
/// <inheritdoc/> /// <inheritdoc/>
public IEnumerable<IVisual> HitTest(Point p, IVisual root, Func<IVisual, bool>? filter) public IEnumerable<IVisual> HitTest(Point p, IVisual root, Func<IVisual, bool>? filter)
{ {
var res = _target.TryHitTest(p, filter); var res = CompositionTarget.TryHitTest(p, filter);
if(res == null) if(res == null)
yield break; yield break;
for (var index = res.Count - 1; index >= 0; index--) foreach(var v in res)
{ {
var v = res[index];
if (v is CompositionDrawListVisual dv) if (v is CompositionDrawListVisual dv)
{ {
if (filter == null || filter(dv.Visual)) if (filter == null || filter(dv.Visual))
@ -234,8 +234,8 @@ public class CompositingRenderer : IRendererWithCompositor
SyncChildren(v); SyncChildren(v);
_dirty.Clear(); _dirty.Clear();
_recalculateChildren.Clear(); _recalculateChildren.Clear();
_target.Size = _root.ClientSize; CompositionTarget.Size = _root.ClientSize;
_target.Scaling = _root.RenderScaling; CompositionTarget.Scaling = _root.RenderScaling;
Compositor.InvokeOnNextCommit(_invalidateScene); Compositor.InvokeOnNextCommit(_invalidateScene);
} }
@ -246,24 +246,24 @@ public class CompositingRenderer : IRendererWithCompositor
public void Paint(Rect rect) public void Paint(Rect rect)
{ {
Update(); Update();
_target.RequestRedraw(); CompositionTarget.RequestRedraw();
if(RenderOnlyOnRenderThread && Compositor.Loop.RunsInBackground) if(RenderOnlyOnRenderThread && Compositor.Loop.RunsInBackground)
Compositor.RequestCommitAsync().Wait(); Compositor.RequestCommitAsync().Wait();
else else
_target.ImmediateUIThreadRender(); CompositionTarget.ImmediateUIThreadRender();
} }
public void Start() => _target.IsEnabled = true; public void Start() => CompositionTarget.IsEnabled = true;
public void Stop() public void Stop()
{ {
_target.IsEnabled = false; CompositionTarget.IsEnabled = false;
} }
public void Dispose() public void Dispose()
{ {
Stop(); Stop();
_target.Dispose(); CompositionTarget.Dispose();
// Wait for the composition batch to be applied and rendered to guarantee that // Wait for the composition batch to be applied and rendered to guarantee that
// render target is not used anymore and can be safely disposed // render target is not used anymore and can be safely disposed

13
src/Avalonia.Base/Rendering/Composition/CompositionDrawListVisual.cs

@ -54,13 +54,20 @@ internal class CompositionDrawListVisual : CompositionContainerVisual
internal override bool HitTest(Point pt, Func<IVisual, bool>? filter) internal override bool HitTest(Point pt, Func<IVisual, bool>? filter)
{ {
if (DrawList == null) var custom = Visual as ICustomHitTest;
if (DrawList == null && custom == null)
return false; return false;
if (filter != null && !filter(Visual)) if (filter != null && !filter(Visual))
return false; return false;
if (Visual is ICustomHitTest custom) if (custom != null)
{
// Simulate the old behavior
// TODO: Change behavior once legacy renderers are removed
pt += new Point(Offset.X, Offset.Y);
return custom.HitTest(pt); return custom.HitTest(pt);
foreach (var op in DrawList) }
foreach (var op in DrawList!)
if (op.Item.HitTest(pt)) if (op.Item.HitTest(pt))
return true; return true;
return false; return false;

44
src/Avalonia.Base/Rendering/Composition/CompositionTarget.cs

@ -62,7 +62,7 @@ namespace Avalonia.Rendering.Composition
bool TryGetInvertedTransform(CompositionVisual visual, out Matrix matrix) bool TryGetInvertedTransform(CompositionVisual visual, out Matrix matrix)
{ {
var m = visual.TryGetServerTransform(); var m = visual.TryGetServerGlobalTransform();
if (m == null) if (m == null)
{ {
matrix = default; matrix = default;
@ -73,52 +73,44 @@ namespace Avalonia.Rendering.Composition
return m33.TryInvert(out matrix); return m33.TryInvert(out matrix);
} }
bool TryTransformTo(CompositionVisual visual, ref Point v) bool TryTransformTo(CompositionVisual visual, Point globalPoint, out Point v)
{ {
v = default;
if (TryGetInvertedTransform(visual, out var m)) if (TryGetInvertedTransform(visual, out var m))
{ {
v = v * m; v = globalPoint * m;
return true; return true;
} }
return false; return false;
} }
bool HitTestCore(CompositionVisual visual, Point point, PooledList<CompositionVisual> result, void HitTestCore(CompositionVisual visual, Point globalPoint, PooledList<CompositionVisual> result,
Func<IVisual, bool>? filter) Func<IVisual, bool>? filter)
{ {
//TODO: Check readback too
if (visual.Visible == false) if (visual.Visible == false)
return false; return;
if (!TryTransformTo(visual, ref point)) if (!TryTransformTo(visual, globalPoint, out var point))
return false; return;
if (visual.ClipToBounds if (visual.ClipToBounds
&& (point.X < 0 || point.Y < 0 || point.X > visual.Size.X || point.Y > visual.Size.Y)) && (point.X < 0 || point.Y < 0 || point.X > visual.Size.X || point.Y > visual.Size.Y))
return false; return;
if (visual.Clip?.FillContains(point) == false)
return false;
bool success = false; if (visual.Clip?.FillContains(point) == false)
// Hit-test the current node return;
if (visual.HitTest(point, filter))
{ // Inspect children
result.Add(visual);
success = true;
}
// Inspect children too
if (visual is CompositionContainerVisual cv) if (visual is CompositionContainerVisual cv)
for (var c = cv.Children.Count - 1; c >= 0; c--) for (var c = cv.Children.Count - 1; c >= 0; c--)
{ {
var ch = cv.Children[c]; var ch = cv.Children[c];
var hit = HitTestCore(ch, point, result, filter); HitTestCore(ch, globalPoint, result, filter);
if (hit)
return true;
} }
return success; // Hit-test the current node
if (visual.HitTest(point, filter))
result.Add(visual);
} }
/// <summary> /// <summary>

6
src/Avalonia.Base/Rendering/Composition/ICompositionTargetDebugEvents.cs

@ -0,0 +1,6 @@
namespace Avalonia.Rendering.Composition;
internal interface ICompositionTargetDebugEvents
{
void RectInvalidated(Rect rc);
}

3
src/Avalonia.Base/Rendering/Composition/Server/ServerCompositionTarget.cs

@ -33,7 +33,7 @@ namespace Avalonia.Rendering.Composition.Server
private HashSet<ServerCompositionVisual> _attachedVisuals = new(); private HashSet<ServerCompositionVisual> _attachedVisuals = new();
private Queue<ServerCompositionVisual> _adornerUpdateQueue = new(); private Queue<ServerCompositionVisual> _adornerUpdateQueue = new();
public ICompositionTargetDebugEvents? DebugEvents { get; set; }
public ReadbackIndices Readback { get; } = new(); public ReadbackIndices Readback { get; } = new();
public int RenderedVisuals { get; set; } public int RenderedVisuals { get; set; }
@ -173,6 +173,7 @@ namespace Avalonia.Rendering.Composition.Server
if(rect.IsEmpty) if(rect.IsEmpty)
return; return;
var snapped = SnapToDevicePixels(rect, Scaling); var snapped = SnapToDevicePixels(rect, Scaling);
DebugEvents?.RectInvalidated(rect);
_dirtyRect = _dirtyRect.Union(snapped); _dirtyRect = _dirtyRect.Union(snapped);
_redrawRequested = true; _redrawRequested = true;
} }

35
src/Avalonia.Base/Rendering/Composition/Server/ServerCompositionVisual.cs

@ -119,14 +119,15 @@ namespace Avalonia.Rendering.Composition.Server
var oldTransformedContentBounds = TransformedOwnContentBounds; var oldTransformedContentBounds = TransformedOwnContentBounds;
var oldCombinedTransformedClipBounds = _combinedTransformedClipBounds; var oldCombinedTransformedClipBounds = _combinedTransformedClipBounds;
var dirtyOldBounds = false;
if (_parent?.IsDirtyComposition == true) if (_parent?.IsDirtyComposition == true)
{ {
IsDirtyComposition = true; IsDirtyComposition = true;
_isDirtyForUpdate = true; _isDirtyForUpdate = true;
dirtyOldBounds = true;
} }
var invalidateOldBounds = _isDirtyForUpdate;
var invalidateNewBounds = _isDirtyForUpdate;
GlobalTransformMatrix = newTransform; GlobalTransformMatrix = newTransform;
@ -157,30 +158,20 @@ namespace Avalonia.Rendering.Composition.Server
EffectiveOpacity = Opacity * (Parent?.EffectiveOpacity ?? 1); EffectiveOpacity = Opacity * (Parent?.EffectiveOpacity ?? 1);
IsVisibleInFrame = Visible && EffectiveOpacity > 0.04 && !_isBackface && IsVisibleInFrame = _parent?.IsVisibleInFrame != false && Visible && EffectiveOpacity > 0.04 && !_isBackface &&
!_combinedTransformedClipBounds.IsEmpty; !_combinedTransformedClipBounds.IsEmpty;
if (wasVisible != IsVisibleInFrame)
_isDirtyForUpdate = true;
// Invalidate previous rect and queue new rect based on visibility
if (positionChanged)
{
if (wasVisible)
dirtyOldBounds = true;
if (IsVisibleInFrame) if (wasVisible != IsVisibleInFrame || positionChanged)
_isDirtyForUpdate = true; {
invalidateOldBounds |= wasVisible;
invalidateNewBounds |= IsVisibleInFrame;
} }
// Invalidate new bounds // Invalidate new bounds
if (IsVisibleInFrame && _isDirtyForUpdate) if (invalidateNewBounds)
{
dirtyOldBounds = true;
AddDirtyRect(TransformedOwnContentBounds.Intersect(_combinedTransformedClipBounds)); AddDirtyRect(TransformedOwnContentBounds.Intersect(_combinedTransformedClipBounds));
}
if (dirtyOldBounds && wasVisible) if (invalidateOldBounds)
AddDirtyRect(oldTransformedContentBounds.Intersect(oldCombinedTransformedClipBounds)); AddDirtyRect(oldTransformedContentBounds.Intersect(oldCombinedTransformedClipBounds));
@ -190,7 +181,7 @@ namespace Avalonia.Rendering.Composition.Server
var i = Root!.Readback; var i = Root!.Readback;
ref var readback = ref GetReadback(i.WriteIndex); ref var readback = ref GetReadback(i.WriteIndex);
readback.Revision = root.Revision; readback.Revision = root.Revision;
readback.Matrix = CombinedTransformMatrix; readback.Matrix = GlobalTransformMatrix;
readback.TargetId = Root.Id; readback.TargetId = Root.Id;
readback.Visible = IsVisibleInFrame; readback.Visible = IsVisibleInFrame;
} }

10
src/Avalonia.Base/Rendering/Composition/Transport/BatchStreamArrayPool.cs

@ -1,8 +1,8 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Runtime.ConstrainedExecution;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using Avalonia.Platform;
using Avalonia.Threading; using Avalonia.Threading;
namespace Avalonia.Rendering.Composition.Transport; namespace Avalonia.Rendering.Composition.Transport;
@ -17,6 +17,7 @@ internal abstract class BatchStreamPoolBase<T> : IDisposable
int _usage; int _usage;
readonly int[] _usageStatistics = new int[10]; readonly int[] _usageStatistics = new int[10];
int _usageStatisticsSlot; int _usageStatisticsSlot;
bool _reclaimImmediately;
public int CurrentUsage => _usage; public int CurrentUsage => _usage;
public int CurrentPool => _pool.Count; public int CurrentPool => _pool.Count;
@ -27,7 +28,10 @@ internal abstract class BatchStreamPoolBase<T> : IDisposable
GC.SuppressFinalize(needsFinalize); GC.SuppressFinalize(needsFinalize);
var updateRef = new WeakReference<BatchStreamPoolBase<T>>(this); var updateRef = new WeakReference<BatchStreamPoolBase<T>>(this);
StartUpdateTimer(startTimer, updateRef); if (AvaloniaLocator.Current.GetService<IPlatformThreadingInterface>() == null)
_reclaimImmediately = true;
else
StartUpdateTimer(startTimer, updateRef);
} }
static void StartUpdateTimer(Action<Func<bool>>? startTimer, WeakReference<BatchStreamPoolBase<T>> updateRef) static void StartUpdateTimer(Action<Func<bool>>? startTimer, WeakReference<BatchStreamPoolBase<T>> updateRef)
@ -90,7 +94,7 @@ internal abstract class BatchStreamPoolBase<T> : IDisposable
lock (_pool) lock (_pool)
{ {
_usage--; _usage--;
if (!_disposed) if (!_disposed && !_reclaimImmediately)
{ {
_pool.Push(item); _pool.Push(item);
return; return;

2
src/Avalonia.Base/Rendering/Composition/Visual.cs

@ -31,7 +31,7 @@ namespace Avalonia.Rendering.Composition
} }
} }
internal Matrix4x4? TryGetServerTransform() internal Matrix4x4? TryGetServerGlobalTransform()
{ {
if (Root == null) if (Root == null)
return null; return null;

417
tests/Avalonia.Base.UnitTests/Rendering/CompositorHitTestingTests.cs

@ -0,0 +1,417 @@
using System;
using System.Linq;
using Avalonia.Controls;
using Avalonia.Controls.Presenters;
using Avalonia.Controls.Shapes;
using Avalonia.Layout;
using Avalonia.Media;
using Avalonia.Platform;
using Avalonia.Rendering;
using Avalonia.UnitTests;
using Avalonia.VisualTree;
using Moq;
using Xunit;
namespace Avalonia.Base.UnitTests.Rendering;
public class CompositorHitTestingTests : CompositorTestsBase
{
[Fact]
public void HitTest_Should_Find_Controls_At_Point()
{
using (var s = new CompositorServices(new Size(200, 200)))
{
var border = new Border
{
Width = 100,
Height = 100,
Background = Brushes.Red,
HorizontalAlignment = HorizontalAlignment.Center,
VerticalAlignment = VerticalAlignment.Center
};
s.TopLevel.Content = border;
s.AssertHitTest(new Point(100, 100), null, border);
}
}
[Fact]
public void HitTest_Should_Not_Find_Empty_Controls_At_Point()
{
using (var s = new CompositorServices(new Size(200, 200)))
{
var border = new Border
{
Width = 100,
Height = 100,
HorizontalAlignment = HorizontalAlignment.Center,
VerticalAlignment = VerticalAlignment.Center
};
s.TopLevel.Content = border;
s.AssertHitTest(new Point(100, 100), null);
}
}
[Fact]
public void HitTest_Should_Not_Find_Invisible_Controls_At_Point()
{
using (var s = new CompositorServices(new Size(200, 200)))
{
Border visible, border;
s.TopLevel.Content = border = new Border
{
Width = 100,
Height = 100,
Background = Brushes.Red,
HorizontalAlignment = HorizontalAlignment.Center,
VerticalAlignment = VerticalAlignment.Center,
IsVisible = false,
Child = visible = new Border
{
Background = Brushes.Red,
HorizontalAlignment = HorizontalAlignment.Stretch,
VerticalAlignment = VerticalAlignment.Stretch,
}
};
s.AssertHitTest(new Point(100, 100), null);
}
}
[Fact]
public void HitTest_Should_Not_Find_Control_Outside_Point()
{
using (var s = new CompositorServices(new Size(200, 200)))
{
var border = new Border
{
Width = 100,
Height = 100,
Background = Brushes.Red,
HorizontalAlignment = HorizontalAlignment.Center,
VerticalAlignment = VerticalAlignment.Center
};
s.TopLevel.Content = border;
s.AssertHitTest(new Point(10, 10), null);
}
}
[Fact]
public void HitTest_Should_Return_Top_Controls_First()
{
using (var s = new CompositorServices(new Size(200, 200)))
{
Panel container = new Panel
{
Width = 200,
Height = 200,
Children =
{
new Border
{
Width = 100,
Height = 100,
Background = Brushes.Red,
HorizontalAlignment = HorizontalAlignment.Center,
VerticalAlignment = VerticalAlignment.Center
},
new Border
{
Width = 50,
Height = 50,
Background = Brushes.Blue,
HorizontalAlignment = HorizontalAlignment.Center,
VerticalAlignment = VerticalAlignment.Center
}
}
};
s.TopLevel.Content = container;
s.AssertHitTest(new Point(100, 100), null, container.Children[1], container.Children[0]);
}
}
[Fact]
public void HitTest_Should_Return_Top_Controls_First_With_ZIndex()
{
using (var s = new CompositorServices(new Size(200, 200)))
{
Panel container = new Panel
{
Width = 200,
Height = 200,
Children =
{
new Border
{
Width = 100,
Height = 100,
ZIndex = 1,
Background = Brushes.Red,
HorizontalAlignment = HorizontalAlignment.Center,
VerticalAlignment = VerticalAlignment.Center
},
new Border
{
Width = 50,
Height = 50,
Background = Brushes.Red,
HorizontalAlignment = HorizontalAlignment.Center,
VerticalAlignment = VerticalAlignment.Center
},
new Border
{
Width = 75,
Height = 75,
ZIndex = 2,
Background = Brushes.Red,
HorizontalAlignment = HorizontalAlignment.Center,
VerticalAlignment = VerticalAlignment.Center
}
}
};
s.TopLevel.Content = container;
s.AssertHitTest(new Point(100, 100), null, new[] { container.Children[2], container.Children[0], container.Children[1] });
}
}
[Fact]
public void HitTest_Should_Find_Control_Translated_Outside_Parent_Bounds()
{
using (var s = new CompositorServices(new Size(200, 200)))
{
Border target;
Panel container = new Panel
{
Width = 200,
Height = 200,
Background = Brushes.Red,
ClipToBounds = false,
Children =
{
new Border
{
Width = 100,
Height = 100,
ZIndex = 1,
Background = Brushes.Red,
HorizontalAlignment = HorizontalAlignment.Left,
VerticalAlignment = VerticalAlignment.Top,
Child = target = new Border
{
Width = 50,
Height = 50,
Background = Brushes.Red,
HorizontalAlignment = HorizontalAlignment.Left,
VerticalAlignment = VerticalAlignment.Top,
RenderTransform = new TranslateTransform(110, 110),
}
},
}
};
s.TopLevel.Content = container;
s.AssertHitTest(new Point(120, 120), null, target, container);
}
}
[Fact]
public void HitTest_Should_Not_Find_Control_Outside_Parent_Bounds_When_Clipped()
{
using (var s = new CompositorServices(new Size(200, 200)))
{
Border target;
Panel container = new Panel
{
Width = 100,
Height = 200,
Background = Brushes.Red,
Children =
{
new Panel()
{
Width = 100,
Height = 100,
Background = Brushes.Red,
Margin = new Thickness(0, 100, 0, 0),
ClipToBounds = true,
Children =
{
(target = new Border()
{
Width = 100,
Height = 100,
Background = Brushes.Red,
Margin = new Thickness(0, -100, 0, 0)
})
}
}
}
};
s.TopLevel.Content = container;
s.AssertHitTest(new Point(50, 50), null, container);
}
}
[Fact]
public void HitTest_Should_Not_Find_Control_Outside_Scroll_Viewport()
{
using (var s = new CompositorServices(new Size(100, 200)))
{
Border target;
Border item1;
Border item2;
ScrollContentPresenter scroll;
Panel container = new Panel
{
Width = 100,
Height = 200,
Background = Brushes.Red,
Children =
{
(target = new Border()
{
Name = "b1",
Width = 100,
Height = 100,
Background = Brushes.Red,
}),
new Border()
{
Name = "b2",
Width = 100,
Height = 100,
Background = Brushes.Red,
Margin = new Thickness(0, 100, 0, 0),
Child = scroll = new ScrollContentPresenter()
{
CanHorizontallyScroll = true,
CanVerticallyScroll = true,
Content = new StackPanel()
{
Children =
{
(item1 = new Border()
{
Name = "b3",
Width = 100,
Height = 100,
Background = Brushes.Red,
}),
(item2 = new Border()
{
Name = "b4",
Width = 100,
Height = 100,
Background = Brushes.Red,
}),
}
}
}
}
}
};
s.TopLevel.Content = container;
scroll.UpdateChild();
s.AssertHitTestFirst(new Point(50, 150), null, item1);
s.AssertHitTestFirst(new Point(50,50), null, target);
scroll.Offset = new Vector(0, 100);
s.AssertHitTestFirst(new Point(50, 150), null, item2);
s.AssertHitTestFirst(new Point(50,50), null, target);
}
}
[Fact]
public void HitTest_Should_Not_Find_Path_When_Outside_Fill()
{
using (var s = new CompositorServices(new Size(200, 200)))
{
Path path = new Path
{
Width = 200,
Height = 200,
Fill = Brushes.Red,
Data = StreamGeometry.Parse("M100,0 L0,100 100,100")
};
s.TopLevel.Content = path;
s.AssertHitTest(new Point(100, 100), null, path);
s.AssertHitTest(new Point(10, 10), null);
}
}
[Fact]
public void HitTest_Should_Respect_Geometry_Clip()
{
using (var s = new CompositorServices(new Size(400, 400)))
{
Canvas canvas;
Border border = new Border
{
Background = Brushes.Red,
Clip = StreamGeometry.Parse("M100,0 L0,100 100,100"),
Width = 200,
Height = 200,
Child = canvas = new Canvas
{
Background = Brushes.Yellow,
Margin = new Thickness(10),
}
};
s.TopLevel.Content = border;
s.RunJobs();
Assert.Equal(new Rect(100, 100, 200, 200), border.Bounds);
s.AssertHitTest(new Point(200,200), null, canvas, border);
s.AssertHitTest(new Point(110, 110), null);
}
}
[Fact]
public void HitTest_Should_Accommodate_ICustomHitTest()
{
using (var s = new CompositorServices(new Size(300, 200)))
{
Border border = new CustomHitTestBorder
{
ClipToBounds = false,
Width = 100,
Height = 100,
Background = Brushes.Red,
HorizontalAlignment = HorizontalAlignment.Center,
VerticalAlignment = VerticalAlignment.Center
};
s.TopLevel.Content = border;
s.AssertHitTest(75, 100, null, border);
s.AssertHitTest(125, 100, null, border);
s.AssertHitTest(175, 100, null);
}
}
private IDisposable TestApplication()
{
return UnitTestApplication.Start(TestServices.MockPlatformRenderInterface);
}
}

109
tests/Avalonia.Base.UnitTests/Rendering/CompositorInvalidationTests.cs

@ -0,0 +1,109 @@
using Avalonia.Controls;
using Avalonia.Media;
using Xunit;
namespace Avalonia.Base.UnitTests.Rendering;
public class CompositorInvalidationTests : CompositorTestsBase
{
[Fact]
public void Control_Should_Invalidate_Own_Rect_When_Added()
{
using (var s = new CompositorCanvas())
{
var control = new Border()
{
Background = Brushes.Red, Width = 20, Height = 10,
[Canvas.LeftProperty] = 30, [Canvas.TopProperty] = 50
};
s.Canvas.Children.Add(control);
s.AssertRects(new Rect(30, 50, 20, 10));
}
}
[Fact]
public void Control_Should_Invalidate_Own_Rect_When_Removed()
{
using (var s = new CompositorCanvas())
{
var control = new Border()
{
Background = Brushes.Red, Width = 20, Height = 10,
[Canvas.LeftProperty] = 30, [Canvas.TopProperty] = 50
};
s.Canvas.Children.Add(control);
s.RunJobs();
s.Events.Rects.Clear();
s.Canvas.Children.Remove(control);
s.AssertRects(new Rect(30, 50, 20, 10));
}
}
[Fact]
public void Control_Should_Invalidate_Both_Own_Rects_When_Moved()
{
using (var s = new CompositorCanvas())
{
var control = new Border()
{
Background = Brushes.Red, Width = 20, Height = 10,
[Canvas.LeftProperty] = 30, [Canvas.TopProperty] = 50
};
s.Canvas.Children.Add(control);
s.RunJobs();
s.Events.Rects.Clear();
control[Canvas.LeftProperty] = 55;
s.AssertRects(new Rect(30, 50, 20, 10),
new Rect(55, 50, 20, 10)
);
}
}
[Fact]
public void Control_Should_Invalidate_Child_Rects_When_Moved()
{
using (var s = new CompositorCanvas())
{
var control = new Decorator()
{
[Canvas.LeftProperty] = 30, [Canvas.TopProperty] = 50,
Padding = new Thickness(10),
Child = new Border()
{
Width = 20, Height = 10,
Background = Brushes.Red
}
};
s.Canvas.Children.Add(control);
s.RunJobs();
s.Events.Rects.Clear();
control[Canvas.LeftProperty] = 55;
s.AssertRects(new Rect(40, 60, 20, 10),
new Rect(65, 60, 20, 10)
);
}
}
[Fact]
public void Control_Should_Invalidate_Child_Rects_When_Becomes_Invisible()
{
using (var s = new CompositorCanvas())
{
var control = new Decorator()
{
[Canvas.LeftProperty] = 30, [Canvas.TopProperty] = 50,
Padding = new Thickness(10),
Child = new Border()
{
Width = 20, Height = 10,
Background = Brushes.Red
}
};
s.Canvas.Children.Add(control);
s.RunJobs();
s.Events.Rects.Clear();
control.IsVisible = false;
s.AssertRects(new Rect(40, 60, 20, 10));
}
}
}

208
tests/Avalonia.Base.UnitTests/Rendering/CompositorTestsBase.cs

@ -0,0 +1,208 @@
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reactive.Disposables;
using System.Threading;
using System.Threading.Tasks;
using Avalonia.Controls;
using Avalonia.Controls.Embedding;
using Avalonia.Controls.Presenters;
using Avalonia.Controls.Templates;
using Avalonia.Data;
using Avalonia.Input;
using Avalonia.Input.Raw;
using Avalonia.Platform;
using Avalonia.Rendering;
using Avalonia.Rendering.Composition;
using Avalonia.Threading;
using Avalonia.UnitTests;
using Avalonia.VisualTree;
using JetBrains.Annotations;
using Xunit;
namespace Avalonia.Base.UnitTests.Rendering;
public class CompositorTestsBase
{
public class DebugEvents : ICompositionTargetDebugEvents
{
public List<Rect> Rects = new();
public void RectInvalidated(Rect rc)
{
Rects.Add(rc);
}
public void Reset()
{
Rects.Clear();
}
}
public class ManualRenderTimer : IRenderTimer
{
public event Action<TimeSpan> Tick;
public bool RunsInBackground => false;
public void TriggerTick() => Tick?.Invoke(TimeSpan.Zero);
public Task TriggerBackgroundTick() => Task.Run(TriggerTick);
}
class TopLevelImpl : ITopLevelImpl
{
private readonly Compositor _compositor;
public CompositingRenderer Renderer { get; private set; }
public TopLevelImpl(Compositor compositor, Size clientSize)
{
ClientSize = clientSize;
_compositor = compositor;
}
public void Dispose()
{
}
public Size ClientSize { get; }
public Size? FrameSize { get; }
public double RenderScaling => 1;
public IEnumerable<object> Surfaces { get; } = Array.Empty<object>();
public Action<RawInputEventArgs> Input { get; set; }
public Action<Rect> Paint { get; set; }
public Action<Size, PlatformResizeReason> Resized { get; set; }
public Action<double> ScalingChanged { get; set; }
public Action<WindowTransparencyLevel> TransparencyLevelChanged { get; set; }
public IRenderer CreateRenderer(IRenderRoot root)
{
return Renderer = new CompositingRenderer(root, _compositor);
}
public void Invalidate(Rect rect)
{
}
public void SetInputRoot(IInputRoot inputRoot)
{
}
public Point PointToClient(PixelPoint point) => default;
public PixelPoint PointToScreen(Point point) => new();
public void SetCursor(ICursorImpl cursor)
{
}
public Action Closed { get; set; }
public Action LostFocus { get; set; }
public IMouseDevice MouseDevice { get; } = new MouseDevice();
public IPopupImpl CreatePopup() => throw new NotImplementedException();
public void SetTransparencyLevelHint(WindowTransparencyLevel transparencyLevel)
{
}
public WindowTransparencyLevel TransparencyLevel { get; }
public AcrylicPlatformCompensationLevels AcrylicCompensationLevels { get; }
}
protected class CompositorServices : IDisposable
{
private readonly IDisposable _app;
public Compositor Compositor { get; }
public ManualRenderTimer Timer { get; } = new();
public EmbeddableControlRoot TopLevel { get; }
public CompositingRenderer Renderer { get; } = null!;
public DebugEvents Events { get; } = new();
public void Dispose()
{
TopLevel.Renderer.Stop();
TopLevel.Dispose();
_app.Dispose();
}
public CompositorServices(Size? size = null)
{
_app = UnitTestApplication.Start(TestServices.MockPlatformRenderInterface);
try
{
AvaloniaLocator.CurrentMutable.Bind<IRenderTimer>().ToConstant(Timer);
AvaloniaLocator.CurrentMutable.Bind<IRenderLoop>()
.ToConstant(new RenderLoop(Timer, Dispatcher.UIThread));
Compositor = new Compositor(AvaloniaLocator.Current.GetRequiredService<IRenderLoop>(), null);
var impl = new TopLevelImpl(Compositor, size ?? new Size(1000, 1000));
TopLevel = new EmbeddableControlRoot(impl)
{
Template = new FuncControlTemplate((parent, scope) =>
{
var presenter = new ContentPresenter
{
[~ContentPresenter.ContentProperty] = new TemplateBinding(ContentControl.ContentProperty)
};
scope.Register("PART_ContentPresenter", presenter);
return presenter;
})
};
Renderer = impl.Renderer;
TopLevel.Prepare();
TopLevel.Renderer.Start();
RunJobs();
Renderer.CompositionTarget.Server.DebugEvents = Events;
}
catch
{
_app.Dispose();
throw;
}
}
public void RunJobs()
{
Dispatcher.UIThread.RunJobs();
Timer.TriggerTick();
Dispatcher.UIThread.RunJobs();
}
public void AssertRects(params Rect[] rects)
{
RunJobs();
var toAssert = rects.Select(x => x.ToString()).Distinct().OrderBy(x => x);
var invalidated = Events.Rects.Select(x => x.ToString()).Distinct().OrderBy(x => x);
Assert.Equal(toAssert, invalidated);
Events.Rects.Clear();
}
public void AssertHitTest(double x, double y, Func<IVisual, bool> filter, params object[] expected)
=> AssertHitTest(new Point(x, y), filter, expected);
public void AssertHitTest(Point pt, Func<IVisual, bool> filter, params object[] expected)
{
RunJobs();
var tested = Renderer.HitTest(pt, TopLevel, filter);
Assert.Equal(expected, tested);
}
public void AssertHitTestFirst(Point pt, Func<IVisual, bool> filter, object expected)
{
RunJobs();
var tested = Renderer.HitTest(pt, TopLevel, filter).First();
Assert.Equal(expected, tested);
}
}
protected class CompositorCanvas : CompositorServices
{
public Canvas Canvas { get; } = new();
public CompositorCanvas()
{
TopLevel.Content = Canvas;
RunJobs();
Events.Reset();
}
}
}

27
tests/Avalonia.UnitTests/MockPlatformRenderInterface.cs

@ -4,6 +4,7 @@ using System.IO;
using Avalonia.Media; using Avalonia.Media;
using Avalonia.Platform; using Avalonia.Platform;
using Avalonia.Media.Imaging; using Avalonia.Media.Imaging;
using Avalonia.Rendering;
using Moq; using Moq;
namespace Avalonia.UnitTests namespace Avalonia.UnitTests
@ -25,9 +26,33 @@ namespace Avalonia.UnitTests
return Mock.Of<IGeometryImpl>(x => x.Bounds == rect); return Mock.Of<IGeometryImpl>(x => x.Bounds == rect);
} }
class MockRenderTarget : IRenderTarget
{
public void Dispose()
{
}
public IDrawingContextImpl CreateDrawingContext(IVisualBrushRenderer visualBrushRenderer)
{
var m = new Mock<IDrawingContextImpl>();
m.Setup(c => c.CreateLayer(It.IsAny<Size>()))
.Returns(() =>
{
var r = new Mock<IDrawingContextLayerImpl>();
r.Setup(r => r.CreateDrawingContext(It.IsAny<IVisualBrushRenderer>()))
.Returns(CreateDrawingContext(null));
return r.Object;
}
);
return m.Object;
}
}
public IRenderTarget CreateRenderTarget(IEnumerable<object> surfaces) public IRenderTarget CreateRenderTarget(IEnumerable<object> surfaces)
{ {
return Mock.Of<IRenderTarget>(); return new MockRenderTarget();
} }
public IRenderTargetBitmapImpl CreateRenderTargetBitmap(PixelSize size, Vector dpi) public IRenderTargetBitmapImpl CreateRenderTargetBitmap(PixelSize size, Vector dpi)

Loading…
Cancel
Save