Steven Kirk
9 years ago
committed by
GitHub
GitHub
92 changed files with 1339 additions and 563 deletions
@ -1,6 +1,4 @@ |
|||
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> |
|||
<ItemGroup> |
|||
<PackageReference Include="System.Threading.ThreadPool" Version="4.3.0" /> |
|||
<PackageReference Include="Microsoft.Extensions.DependencyModel" Version="1.1.0" /> |
|||
</ItemGroup> |
|||
</Project> |
|||
|
|||
|
Before Width: | Height: | Size: 1.1 KiB After Width: | Height: | Size: 172 KiB |
@ -0,0 +1,24 @@ |
|||
<UserControl xmlns="https://github.com/avaloniaui"> |
|||
<StackPanel Orientation="Vertical" Gap="4"> |
|||
<TextBlock Classes="h1">ProgressBar</TextBlock> |
|||
<TextBlock Classes="h2">A progress bar control</TextBlock> |
|||
|
|||
<StackPanel> |
|||
<StackPanel Orientation="Horizontal" |
|||
Margin="0,16,0,0" |
|||
HorizontalAlignment="Center" |
|||
Gap="16"> |
|||
<StackPanel Gap="16"> |
|||
<ProgressBar Value="{Binding #hprogress.Value}" /> |
|||
<ProgressBar IsIndeterminate="True"/> |
|||
</StackPanel> |
|||
<ProgressBar Value="{Binding #vprogress.Value}" Orientation="Vertical" /> |
|||
<ProgressBar Orientation="Vertical" IsIndeterminate="True" /> |
|||
</StackPanel> |
|||
<StackPanel Margin="16"> |
|||
<Slider Name="hprogress" Maximum="100" Value="40"/> |
|||
<Slider Name="vprogress" Maximum="100" Value="60"/> |
|||
</StackPanel> |
|||
</StackPanel> |
|||
</StackPanel> |
|||
</UserControl> |
|||
@ -0,0 +1,18 @@ |
|||
using Avalonia.Controls; |
|||
using Avalonia.Markup.Xaml; |
|||
|
|||
namespace ControlCatalog.Pages |
|||
{ |
|||
public class ProgressBarPage : UserControl |
|||
{ |
|||
public ProgressBarPage() |
|||
{ |
|||
this.InitializeComponent(); |
|||
} |
|||
|
|||
private void InitializeComponent() |
|||
{ |
|||
AvaloniaXamlLoader.Load(this); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,21 @@ |
|||
// Copyright (c) The Avalonia Project. All rights reserved.
|
|||
// Licensed under the MIT license. See licence.md file in the project root for full license information.
|
|||
|
|||
namespace Avalonia.Controls |
|||
{ |
|||
/// <summary>
|
|||
/// Defines vertical or horizontal orientation.
|
|||
/// </summary>
|
|||
public enum Orientation |
|||
{ |
|||
/// <summary>
|
|||
/// Horizontal orientation.
|
|||
/// </summary>
|
|||
Horizontal, |
|||
|
|||
/// <summary>
|
|||
/// Vertical orientation.
|
|||
/// </summary>
|
|||
Vertical, |
|||
} |
|||
} |
|||
@ -1,42 +0,0 @@ |
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Diagnostics; |
|||
using System.Linq; |
|||
using System.Reflection; |
|||
using System.Text; |
|||
using System.Threading.Tasks; |
|||
using Microsoft.DotNet.PlatformAbstractions; |
|||
using Microsoft.Extensions.DependencyModel; |
|||
|
|||
namespace Avalonia.Shared.PlatformSupport |
|||
{ |
|||
internal partial class StandardRuntimePlatform |
|||
{ |
|||
private static readonly Lazy<Assembly[]> Assemblies = new Lazy<Assembly[]>(LoadAssemblies); |
|||
public Assembly[] GetLoadedAssemblies() => Assemblies.Value; |
|||
|
|||
static Assembly[] LoadAssemblies() |
|||
{ |
|||
var assemblies = new List<Assembly>(); |
|||
// Mostly copy-pasted from (MIT):
|
|||
// https://github.com/StefH/System.AppDomain.Core/blob/0b35e676c2721aa367b96e62eb52c97ee0b43a70/src/System.AppDomain.NetCoreApp/AppDomain.cs
|
|||
|
|||
foreach (var assemblyName in |
|||
DependencyContext.Default.GetRuntimeAssemblyNames(RuntimeEnvironment.GetRuntimeIdentifier())) |
|||
{ |
|||
try |
|||
{ |
|||
var assembly = Assembly.Load(assemblyName); |
|||
// just load all types and skip this assembly if one or more types cannot be resolved
|
|||
assembly.DefinedTypes.ToArray(); |
|||
assemblies.Add(assembly); |
|||
} |
|||
catch (Exception ex) |
|||
{ |
|||
Debug.Write(ex.Message); |
|||
} |
|||
} |
|||
return assemblies.ToArray(); |
|||
} |
|||
} |
|||
} |
|||
@ -1,34 +0,0 @@ |
|||
using System; |
|||
using Avalonia.Platform; |
|||
using Avalonia.VisualTree; |
|||
|
|||
namespace Avalonia.Rendering |
|||
{ |
|||
public class DefaultRenderLayerFactory : IRenderLayerFactory |
|||
{ |
|||
private IPlatformRenderInterface _renderInterface; |
|||
|
|||
public DefaultRenderLayerFactory() |
|||
: this(AvaloniaLocator.Current.GetService<IPlatformRenderInterface>()) |
|||
{ |
|||
} |
|||
|
|||
public DefaultRenderLayerFactory(IPlatformRenderInterface renderInterface) |
|||
{ |
|||
_renderInterface = renderInterface; |
|||
} |
|||
|
|||
public IRenderTargetBitmapImpl CreateLayer( |
|||
IVisual layerRoot, |
|||
Size size, |
|||
double dpiX, |
|||
double dpiY) |
|||
{ |
|||
return _renderInterface.CreateRenderTargetBitmap( |
|||
(int)Math.Ceiling(size.Width), |
|||
(int)Math.Ceiling(size.Height), |
|||
dpiX, |
|||
dpiY); |
|||
} |
|||
} |
|||
} |
|||
@ -1,11 +0,0 @@ |
|||
using System; |
|||
using Avalonia.Platform; |
|||
using Avalonia.VisualTree; |
|||
|
|||
namespace Avalonia.Rendering |
|||
{ |
|||
public interface IRenderLayerFactory |
|||
{ |
|||
IRenderTargetBitmapImpl CreateLayer(IVisual layerRoot, Size size, double dpiX, double dpiY); |
|||
} |
|||
} |
|||
@ -0,0 +1,26 @@ |
|||
using System; |
|||
using Avalonia.Media; |
|||
using Avalonia.Platform; |
|||
|
|||
namespace Avalonia.Rendering.SceneGraph |
|||
{ |
|||
/// <summary>
|
|||
/// Base class for draw operations that have bounds.
|
|||
/// </summary>
|
|||
internal abstract class DrawOperation : IDrawOperation |
|||
{ |
|||
public DrawOperation(Rect bounds, Matrix transform, Pen pen) |
|||
{ |
|||
bounds = bounds.Inflate((pen?.Thickness ?? 0) / 2).TransformToAABB(transform); |
|||
Bounds = new Rect( |
|||
new Point(Math.Floor(bounds.X), Math.Floor(bounds.Y)), |
|||
new Point(Math.Ceiling(bounds.Right), Math.Ceiling(bounds.Bottom))); |
|||
} |
|||
|
|||
public Rect Bounds { get; } |
|||
|
|||
public abstract bool HitTest(Point p); |
|||
|
|||
public abstract void Render(IDrawingContextImpl context); |
|||
} |
|||
} |
|||
@ -0,0 +1,38 @@ |
|||
using System; |
|||
using System.Runtime.InteropServices; |
|||
using Avalonia.Platform; |
|||
|
|||
namespace Avalonia.Gtk3.Interop |
|||
{ |
|||
class ManagedCairoSurface : IDisposable |
|||
{ |
|||
public IntPtr Buffer { get; private set; } |
|||
public CairoSurface Surface { get; private set; } |
|||
public int Stride { get; private set; } |
|||
private int _size; |
|||
private IRuntimePlatform _plat; |
|||
private IUnmanagedBlob _blob; |
|||
|
|||
public ManagedCairoSurface(int width, int height) |
|||
{ |
|||
_plat = AvaloniaLocator.Current.GetService<IRuntimePlatform>(); |
|||
Stride = width * 4; |
|||
_size = height * Stride; |
|||
_blob = _plat.AllocBlob(_size * 2); |
|||
Buffer = _blob.Address; |
|||
Surface = Native.CairoImageSurfaceCreateForData(Buffer, 1, width, height, Stride); |
|||
} |
|||
|
|||
public void Dispose() |
|||
{ |
|||
|
|||
if (Buffer != IntPtr.Zero) |
|||
{ |
|||
Surface.Dispose(); |
|||
_blob.Dispose(); |
|||
Buffer = IntPtr.Zero; |
|||
} |
|||
} |
|||
|
|||
} |
|||
} |
|||
@ -0,0 +1,54 @@ |
|||
using System; |
|||
using System.Runtime.InteropServices; |
|||
|
|||
namespace Avalonia.Gtk3 |
|||
{ |
|||
class X11 |
|||
{ |
|||
[DllImport("libX11.so.6")] |
|||
public static extern IntPtr XOpenDisplay(IntPtr name); |
|||
|
|||
[DllImport("libX11.so.6")] |
|||
public static extern IntPtr XFreeGC(IntPtr display, IntPtr gc); |
|||
|
|||
[DllImport("libX11.so.6")] |
|||
public static extern IntPtr XCreateGC(IntPtr display, IntPtr drawable, ulong valuemask, IntPtr values); |
|||
|
|||
[DllImport("libX11.so.6")] |
|||
public static extern int XInitImage(ref XImage image); |
|||
|
|||
[DllImport("libX11.so.6")] |
|||
public static extern int XDestroyImage(ref XImage image); |
|||
|
|||
[DllImport("libX11.so.6")] |
|||
public static extern IntPtr XSetErrorHandler(XErrorHandler handler); |
|||
|
|||
public delegate int XErrorHandler(IntPtr display, IntPtr error); |
|||
|
|||
[DllImport("libX11.so.6")] |
|||
public static extern int XPutImage(IntPtr display, IntPtr drawable, IntPtr gc, ref XImage image, |
|||
int srcx, int srcy, int destx, int desty, uint width, uint height); |
|||
|
|||
|
|||
public unsafe struct XImage |
|||
{ |
|||
public int width, height; /* size of image */ |
|||
public int xoffset; /* number of pixels offset in X direction */ |
|||
public int format; /* XYBitmap, XYPixmap, ZPixmap */ |
|||
public IntPtr data; /* pointer to image data */ |
|||
public int byte_order; /* data byte order, LSBFirst, MSBFirst */ |
|||
public int bitmap_unit; /* quant. of scanline 8, 16, 32 */ |
|||
public int bitmap_bit_order; /* LSBFirst, MSBFirst */ |
|||
public int bitmap_pad; /* 8, 16, 32 either XY or ZPixmap */ |
|||
public int depth; /* depth of image */ |
|||
public int bytes_per_line; /* accelerator to next scanline */ |
|||
public int bits_per_pixel; /* bits per pixel (ZPixmap) */ |
|||
public ulong red_mask; /* bits in z arrangement */ |
|||
public ulong green_mask; |
|||
public ulong blue_mask; |
|||
private fixed byte funcs[128]; |
|||
} |
|||
|
|||
|
|||
} |
|||
} |
|||
@ -0,0 +1,55 @@ |
|||
using System; |
|||
using System.Runtime.InteropServices; |
|||
using Avalonia.Platform; |
|||
|
|||
namespace Avalonia.Gtk3 |
|||
{ |
|||
class X11Framebuffer : ILockedFramebuffer |
|||
{ |
|||
private readonly IntPtr _display; |
|||
private readonly IntPtr _xid; |
|||
private IUnmanagedBlob _blob; |
|||
|
|||
public X11Framebuffer(IntPtr display, IntPtr xid, int width, int height, int factor) |
|||
{ |
|||
_display = display; |
|||
_xid = xid; |
|||
Width = width*factor; |
|||
Height = height*factor; |
|||
RowBytes = Width * 4; |
|||
Dpi = new Vector(96, 96) * factor; |
|||
Format = PixelFormat.Bgra8888; |
|||
_blob = AvaloniaLocator.Current.GetService<IRuntimePlatform>().AllocBlob(RowBytes * Height); |
|||
Address = _blob.Address; |
|||
} |
|||
|
|||
public void Dispose() |
|||
{ |
|||
var image = new X11.XImage(); |
|||
int bitsPerPixel = 32; |
|||
image.width = Width; |
|||
image.height = Height; |
|||
image.format = 2; //ZPixmap;
|
|||
image.data = Address; |
|||
image.byte_order = 0;// LSBFirst;
|
|||
image.bitmap_unit = bitsPerPixel; |
|||
image.bitmap_bit_order = 0;// LSBFirst;
|
|||
image.bitmap_pad = bitsPerPixel; |
|||
image.depth = 24; |
|||
image.bytes_per_line = RowBytes - Width * 4; |
|||
image.bits_per_pixel = bitsPerPixel; |
|||
X11.XInitImage(ref image); |
|||
var gc = X11.XCreateGC(_display, _xid, 0, IntPtr.Zero); |
|||
X11.XPutImage(_display, _xid, gc, ref image, 0, 0, 0, 0, (uint) Width, (uint) Height); |
|||
X11.XFreeGC(_display, gc); |
|||
_blob.Dispose(); |
|||
} |
|||
|
|||
public IntPtr Address { get; } |
|||
public int Width { get; } |
|||
public int Height { get; } |
|||
public int RowBytes { get; } |
|||
public Vector Dpi { get; } |
|||
public PixelFormat Format { get; } |
|||
} |
|||
} |
|||
@ -0,0 +1,84 @@ |
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Text; |
|||
using Avalonia.Controls.Platform.Surfaces; |
|||
using Avalonia.Direct2D1.Media; |
|||
using Avalonia.Direct2D1.Media.Imaging; |
|||
using Avalonia.Platform; |
|||
using Avalonia.Rendering; |
|||
using Avalonia.Win32.Interop; |
|||
using SharpDX.Direct2D1; |
|||
using SharpDX.WIC; |
|||
using PixelFormat = Avalonia.Platform.PixelFormat; |
|||
|
|||
namespace Avalonia.Direct2D1 |
|||
{ |
|||
class FramebufferShimRenderTarget : IRenderTarget |
|||
{ |
|||
private readonly IFramebufferPlatformSurface _surface; |
|||
private readonly ImagingFactory _imagingFactory; |
|||
private readonly Factory _d2DFactory; |
|||
private readonly SharpDX.DirectWrite.Factory _dwriteFactory; |
|||
|
|||
public FramebufferShimRenderTarget(IFramebufferPlatformSurface surface, |
|||
ImagingFactory imagingFactory, Factory d2dFactory, SharpDX.DirectWrite.Factory dwriteFactory) |
|||
{ |
|||
_surface = surface; |
|||
_imagingFactory = imagingFactory; |
|||
_d2DFactory = d2dFactory; |
|||
_dwriteFactory = dwriteFactory; |
|||
} |
|||
|
|||
public void Dispose() |
|||
{ |
|||
|
|||
} |
|||
|
|||
public IDrawingContextImpl CreateDrawingContext(IVisualBrushRenderer visualBrushRenderer) |
|||
{ |
|||
var locked = _surface.Lock(); |
|||
if (locked.Format == PixelFormat.Rgb565) |
|||
{ |
|||
locked.Dispose(); |
|||
throw new ArgumentException("Unsupported pixel format: " + locked.Format); |
|||
} |
|||
|
|||
return new FramebufferShim(locked, _imagingFactory, _d2DFactory, _dwriteFactory) |
|||
.CreateDrawingContext(visualBrushRenderer); |
|||
} |
|||
|
|||
class FramebufferShim : WicRenderTargetBitmapImpl |
|||
{ |
|||
private readonly ILockedFramebuffer _target; |
|||
|
|||
public FramebufferShim(ILockedFramebuffer target, |
|||
ImagingFactory imagingFactory, Factory d2dFactory, SharpDX.DirectWrite.Factory dwriteFactory |
|||
) : base(imagingFactory, d2dFactory, dwriteFactory, |
|||
target.Width, target.Height, target.Dpi.X, target.Dpi.Y, target.Format) |
|||
{ |
|||
_target = target; |
|||
} |
|||
|
|||
public override IDrawingContextImpl CreateDrawingContext(IVisualBrushRenderer visualBrushRenderer) |
|||
{ |
|||
return base.CreateDrawingContext(visualBrushRenderer, () => |
|||
{ |
|||
using (var l = WicImpl.Lock(BitmapLockFlags.Read)) |
|||
{ |
|||
for (var y = 0; y < _target.Height; y++) |
|||
{ |
|||
UnmanagedMethods.CopyMemory( |
|||
_target.Address + _target.RowBytes * y, |
|||
l.Data.DataPointer + l.Stride * y, |
|||
(uint) Math.Min(l.Stride, _target.RowBytes)); |
|||
} |
|||
} |
|||
Dispose(); |
|||
_target.Dispose(); |
|||
|
|||
}); |
|||
} |
|||
} |
|||
|
|||
} |
|||
} |
|||
@ -0,0 +1,10 @@ |
|||
using System; |
|||
using Avalonia.Platform; |
|||
|
|||
namespace Avalonia.Direct2D1 |
|||
{ |
|||
public interface ILayerFactory |
|||
{ |
|||
IRenderTargetBitmapImpl CreateLayer(Size size); |
|||
} |
|||
} |
|||
@ -0,0 +1,68 @@ |
|||
using System; |
|||
using Avalonia.Platform; |
|||
using Avalonia.Rendering; |
|||
using SharpDX; |
|||
using SharpDX.Direct2D1; |
|||
using SharpDX.WIC; |
|||
using D2DBitmap = SharpDX.Direct2D1.Bitmap; |
|||
using DirectWriteFactory = SharpDX.DirectWrite.Factory; |
|||
|
|||
namespace Avalonia.Direct2D1.Media.Imaging |
|||
{ |
|||
public class D2DRenderTargetBitmapImpl : D2DBitmapImpl, IRenderTargetBitmapImpl, ILayerFactory |
|||
{ |
|||
private readonly DirectWriteFactory _dwriteFactory; |
|||
private readonly BitmapRenderTarget _target; |
|||
|
|||
public D2DRenderTargetBitmapImpl( |
|||
ImagingFactory imagingFactory, |
|||
DirectWriteFactory dwriteFactory, |
|||
BitmapRenderTarget target) |
|||
: base(imagingFactory, target.Bitmap) |
|||
{ |
|||
_dwriteFactory = dwriteFactory; |
|||
_target = target; |
|||
} |
|||
|
|||
public override int PixelWidth => _target.PixelSize.Width; |
|||
public override int PixelHeight => _target.PixelSize.Height; |
|||
|
|||
public static D2DRenderTargetBitmapImpl CreateCompatible( |
|||
ImagingFactory imagingFactory, |
|||
DirectWriteFactory dwriteFactory, |
|||
SharpDX.Direct2D1.RenderTarget renderTarget, |
|||
Size size) |
|||
{ |
|||
var bitmapRenderTarget = new BitmapRenderTarget( |
|||
renderTarget, |
|||
CompatibleRenderTargetOptions.None, |
|||
new Size2F((float)size.Width, (float)size.Height)); |
|||
return new D2DRenderTargetBitmapImpl(imagingFactory, dwriteFactory, bitmapRenderTarget); |
|||
} |
|||
|
|||
public IDrawingContextImpl CreateDrawingContext(IVisualBrushRenderer visualBrushRenderer) |
|||
{ |
|||
return new DrawingContextImpl( |
|||
visualBrushRenderer, |
|||
this, |
|||
_target, |
|||
_dwriteFactory, |
|||
WicImagingFactory); |
|||
} |
|||
|
|||
public IRenderTargetBitmapImpl CreateLayer(Size size) |
|||
{ |
|||
return CreateCompatible(WicImagingFactory, _dwriteFactory, _target, size); |
|||
} |
|||
|
|||
public override void Dispose() |
|||
{ |
|||
_target.Dispose(); |
|||
} |
|||
|
|||
public override OptionalDispose<D2DBitmap> GetDirect2DBitmap(SharpDX.Direct2D1.RenderTarget target) |
|||
{ |
|||
return new OptionalDispose<D2DBitmap>(_target.Bitmap, false); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,22 @@ |
|||
using System; |
|||
|
|||
namespace Avalonia.Direct2D1 |
|||
{ |
|||
public struct OptionalDispose<T> : IDisposable where T : IDisposable |
|||
{ |
|||
private readonly bool _dispose; |
|||
|
|||
public OptionalDispose(T value, bool dispose) |
|||
{ |
|||
Value = value; |
|||
_dispose = dispose; |
|||
} |
|||
|
|||
public T Value { get; } |
|||
|
|||
public void Dispose() |
|||
{ |
|||
if (_dispose) Value?.Dispose(); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,55 @@ |
|||
using System; |
|||
using Avalonia.Media; |
|||
using Avalonia.Platform; |
|||
using Avalonia.Rendering.SceneGraph; |
|||
using Xunit; |
|||
|
|||
namespace Avalonia.Visuals.UnitTests.Rendering.SceneGraph |
|||
{ |
|||
public class DrawOperationTests |
|||
{ |
|||
[Fact] |
|||
public void Empty_Bounds_Remain_Empty() |
|||
{ |
|||
var target = new TestDrawOperation(Rect.Empty, Matrix.Identity, null); |
|||
|
|||
Assert.Equal(Rect.Empty, target.Bounds); |
|||
} |
|||
|
|||
[Theory] |
|||
[InlineData(10, 10, 10, 10, 1, 1, 1, 9, 9, 12, 12)] |
|||
[InlineData(10, 10, 10, 10, 1, 1, 2, 9, 9, 12, 12)] |
|||
[InlineData(10, 10, 10, 10, 1.5, 1.5, 1, 14, 14, 17, 17)] |
|||
public void Rectangle_Bounds_Are_Snapped_To_Pixels( |
|||
double x, |
|||
double y, |
|||
double width, |
|||
double height, |
|||
double scaleX, |
|||
double scaleY, |
|||
double? penThickness, |
|||
double expectedX, |
|||
double expectedY, |
|||
double expectedWidth, |
|||
double expectedHeight) |
|||
{ |
|||
var target = new TestDrawOperation( |
|||
new Rect(x, y, width, height), |
|||
Matrix.CreateScale(scaleX, scaleY), |
|||
penThickness.HasValue ? new Pen(Brushes.Black, penThickness.Value) : null); |
|||
Assert.Equal(new Rect(expectedX, expectedY, expectedWidth, expectedHeight), target.Bounds); |
|||
} |
|||
|
|||
private class TestDrawOperation : DrawOperation |
|||
{ |
|||
public TestDrawOperation(Rect bounds, Matrix transform, Pen pen) |
|||
:base(bounds, transform, pen) |
|||
{ |
|||
} |
|||
|
|||
public override bool HitTest(Point p) => false; |
|||
|
|||
public override void Render(IDrawingContextImpl context) { } |
|||
} |
|||
} |
|||
} |
|||
|
After Width: | Height: | Size: 800 B |
|
After Width: | Height: | Size: 786 B |
|
After Width: | Height: | Size: 800 B |
Loading…
Reference in new issue