Emmanuel Hansen
4 years ago
committed by
GitHub
GitHub
114 changed files with 857 additions and 958 deletions
@ -1 +1,2 @@ |
|||
github: avaloniaui |
|||
open_collective: avalonia |
|||
|
|||
@ -0,0 +1,12 @@ |
|||
using System.Runtime.CompilerServices; |
|||
|
|||
namespace System; |
|||
|
|||
#if !NET6_0_OR_GREATER
|
|||
public static class StringCompatibilityExtensions |
|||
{ |
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static bool Contains(this string str, char search) => |
|||
str.Contains(search.ToString()); |
|||
} |
|||
#endif
|
|||
@ -0,0 +1,49 @@ |
|||
using System; |
|||
using System.Globalization; |
|||
using System.Runtime.CompilerServices; |
|||
|
|||
namespace Avalonia.Utilities |
|||
{ |
|||
public static class SpanHelpers |
|||
{ |
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static bool TryParseUInt(this ReadOnlySpan<char> span, NumberStyles style, IFormatProvider provider, out uint value) |
|||
{ |
|||
#if NETSTANDARD2_0
|
|||
return uint.TryParse(span.ToString(), style, provider, out value); |
|||
#else
|
|||
return uint.TryParse(span, style, provider, out value); |
|||
#endif
|
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static bool TryParseInt(this ReadOnlySpan<char> span, out int value) |
|||
{ |
|||
#if NETSTANDARD2_0
|
|||
return int.TryParse(span.ToString(), out value); |
|||
#else
|
|||
return int.TryParse(span, out value); |
|||
#endif
|
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static bool TryParseDouble(this ReadOnlySpan<char> span, NumberStyles style, IFormatProvider provider, out double value) |
|||
{ |
|||
#if NETSTANDARD2_0
|
|||
return double.TryParse(span.ToString(), style, provider, out value); |
|||
#else
|
|||
return double.TryParse(span, style, provider, out value); |
|||
#endif
|
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static bool TryParseByte(this ReadOnlySpan<char> span, NumberStyles style, IFormatProvider provider, out byte value) |
|||
{ |
|||
#if NETSTANDARD2_0
|
|||
return byte.TryParse(span.ToString(), style, provider, out value); |
|||
#else
|
|||
return byte.TryParse(span, style, provider, out value); |
|||
#endif
|
|||
} |
|||
} |
|||
} |
|||
@ -1,53 +0,0 @@ |
|||
using System; |
|||
using System.Globalization; |
|||
using Avalonia.Data.Converters; |
|||
|
|||
namespace Avalonia.Controls.Primitives.Converters |
|||
{ |
|||
/// <summary>
|
|||
/// Gets the third <see cref="ColorComponent"/> corresponding with a given
|
|||
/// <see cref="ColorSpectrumComponents"/> that represents the other two components.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// This is a highly-specialized converter for the color picker.
|
|||
/// </remarks>
|
|||
public class ThirdComponentConverter : IValueConverter |
|||
{ |
|||
/// <inheritdoc/>
|
|||
public object? Convert( |
|||
object? value, |
|||
Type targetType, |
|||
object? parameter, |
|||
CultureInfo culture) |
|||
{ |
|||
if (value is ColorSpectrumComponents components) |
|||
{ |
|||
// Note: Alpha is not relevant here
|
|||
switch (components) |
|||
{ |
|||
case ColorSpectrumComponents.HueSaturation: |
|||
case ColorSpectrumComponents.SaturationHue: |
|||
return (ColorComponent)HsvComponent.Value; |
|||
case ColorSpectrumComponents.HueValue: |
|||
case ColorSpectrumComponents.ValueHue: |
|||
return (ColorComponent)HsvComponent.Saturation; |
|||
case ColorSpectrumComponents.SaturationValue: |
|||
case ColorSpectrumComponents.ValueSaturation: |
|||
return (ColorComponent)HsvComponent.Hue; |
|||
} |
|||
} |
|||
|
|||
return AvaloniaProperty.UnsetValue; |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
public object? ConvertBack( |
|||
object? value, |
|||
Type targetType, |
|||
object? parameter, |
|||
CultureInfo culture) |
|||
{ |
|||
return AvaloniaProperty.UnsetValue; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,71 @@ |
|||
namespace Avalonia.Controls.Primitives |
|||
{ |
|||
/// <summary>
|
|||
/// A thin wrapper over an <see cref="System.Array"/> that allows some additional list-like functionality.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// This is only for internal ColorPicker-related functionality and should not be used elsewhere.
|
|||
/// It is added for performance to enjoy the simplicity of the IList.Add() method without requiring
|
|||
/// an additional copy to turn a list into an array for bitmaps.
|
|||
/// </remarks>
|
|||
/// <typeparam name="T">The type of items in the array.</typeparam>
|
|||
internal class ArrayList<T> |
|||
{ |
|||
private int _nextIndex = 0; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="ArrayList{T}"/> class.
|
|||
/// </summary>
|
|||
public ArrayList(int capacity) |
|||
{ |
|||
Capacity = capacity; |
|||
Array = new T[capacity]; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Provides access to the underlying array by index.
|
|||
/// This exists for simplification and the <see cref="Array"/> property
|
|||
/// may also be used.
|
|||
/// </summary>
|
|||
/// <param name="i">The index of the item to get or set.</param>
|
|||
/// <returns>The item at the given index.</returns>
|
|||
public T this[int i] |
|||
{ |
|||
get => Array[i]; |
|||
set => Array[i] = value; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the underlying array.
|
|||
/// </summary>
|
|||
public T[] Array { get; private set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the fixed capacity/size of the array.
|
|||
/// This must be set during construction.
|
|||
/// </summary>
|
|||
public int Capacity { get; private set; } |
|||
|
|||
/// <summary>
|
|||
/// Adds the given item to the array at the next available index.
|
|||
/// WARNING: This must be used carefully and only once, in sequence.
|
|||
/// </summary>
|
|||
/// <param name="item">The item to add.</param>
|
|||
public void Add(T item) |
|||
{ |
|||
if (_nextIndex >= 0 && |
|||
_nextIndex < Capacity) |
|||
{ |
|||
Array[_nextIndex] = item; |
|||
_nextIndex++; |
|||
} |
|||
else |
|||
{ |
|||
// If necessary an exception could be thrown here
|
|||
// throw new IndexOutOfRangeException();
|
|||
} |
|||
|
|||
return; |
|||
} |
|||
} |
|||
} |
|||
@ -1,21 +1,64 @@ |
|||
namespace Avalonia.Platform |
|||
using System; |
|||
|
|||
namespace Avalonia.Platform |
|||
{ |
|||
/// <summary>
|
|||
/// Represents a single display screen.
|
|||
/// </summary>
|
|||
public class Screen |
|||
{ |
|||
public double PixelDensity { get; } |
|||
/// <summary>
|
|||
/// Gets the scaling factor applied to the screen by the operating system.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// Multiply this value by 100 to get a percentage.
|
|||
/// Both X and Y scaling factors are assumed uniform.
|
|||
/// </remarks>
|
|||
public double Scaling { get; } |
|||
|
|||
/// <inheritdoc cref="Scaling"/>
|
|||
[Obsolete("Use the Scaling property instead.")] |
|||
public double PixelDensity => Scaling; |
|||
|
|||
/// <summary>
|
|||
/// Gets the overall pixel-size of the screen.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// This generally is the raw pixel counts in both the X and Y direction.
|
|||
/// </remarks>
|
|||
public PixelRect Bounds { get; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the actual working-area pixel-size of the screen.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// This area may be smaller than <see href="Bounds"/> to account for notches and
|
|||
/// other block-out areas such as taskbars etc.
|
|||
/// </remarks>
|
|||
public PixelRect WorkingArea { get; } |
|||
|
|||
public bool Primary { get; } |
|||
|
|||
public Screen(double pixelDensity, PixelRect bounds, PixelRect workingArea, bool primary) |
|||
/// <summary>
|
|||
/// Gets a value indicating whether the screen is the primary one.
|
|||
/// </summary>
|
|||
public bool IsPrimary { get; } |
|||
|
|||
/// <inheritdoc cref="IsPrimary"/>
|
|||
[Obsolete("Use the IsPrimary property instead.")] |
|||
public bool Primary => IsPrimary; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="Screen"/> class.
|
|||
/// </summary>
|
|||
/// <param name="scaling">The scaling factor applied to the screen by the operating system.</param>
|
|||
/// <param name="bounds">The overall pixel-size of the screen.</param>
|
|||
/// <param name="workingArea">The actual working-area pixel-size of the screen.</param>
|
|||
/// <param name="isPrimary">Whether the screen is the primary one.</param>
|
|||
public Screen(double scaling, PixelRect bounds, PixelRect workingArea, bool isPrimary) |
|||
{ |
|||
this.PixelDensity = pixelDensity; |
|||
this.Scaling = scaling; |
|||
this.Bounds = bounds; |
|||
this.WorkingArea = workingArea; |
|||
this.Primary = primary; |
|||
this.IsPrimary = isPrimary; |
|||
} |
|||
} |
|||
} |
|||
|
|||
@ -1,9 +0,0 @@ |
|||
using System; |
|||
|
|||
namespace Avalonia.MicroCom |
|||
{ |
|||
public interface IMicroComExceptionCallback |
|||
{ |
|||
void RaiseException(Exception e); |
|||
} |
|||
} |
|||
@ -1,9 +0,0 @@ |
|||
namespace Avalonia.MicroCom |
|||
{ |
|||
public interface IMicroComShadowContainer |
|||
{ |
|||
MicroComShadow Shadow { get; set; } |
|||
void OnReferencedFromNative(); |
|||
void OnUnreferencedFromNative(); |
|||
} |
|||
} |
|||
@ -1,8 +0,0 @@ |
|||
using System; |
|||
|
|||
namespace Avalonia.MicroCom |
|||
{ |
|||
public interface IUnknown : IDisposable |
|||
{ |
|||
} |
|||
} |
|||
@ -1,17 +0,0 @@ |
|||
using System; |
|||
|
|||
namespace Avalonia.MicroCom |
|||
{ |
|||
unsafe class LocalInterop |
|||
{ |
|||
public static unsafe void CalliStdCallvoid(void* thisObject, void* methodPtr) |
|||
{ |
|||
throw null; |
|||
} |
|||
|
|||
public static unsafe int CalliStdCallint(void* thisObject, Guid* guid, IntPtr* ppv, void* methodPtr) |
|||
{ |
|||
throw null; |
|||
} |
|||
} |
|||
} |
|||
@ -1,110 +0,0 @@ |
|||
using System; |
|||
using System.Runtime.ConstrainedExecution; |
|||
using System.Runtime.InteropServices; |
|||
using System.Threading; |
|||
|
|||
namespace Avalonia.MicroCom |
|||
{ |
|||
public unsafe class MicroComProxyBase : CriticalFinalizerObject, IUnknown |
|||
{ |
|||
private IntPtr _nativePointer; |
|||
private bool _ownsHandle; |
|||
private SynchronizationContext _synchronizationContext; |
|||
|
|||
public IntPtr NativePointer |
|||
{ |
|||
get |
|||
{ |
|||
if (_nativePointer == IntPtr.Zero) |
|||
throw new ObjectDisposedException(this.GetType().FullName); |
|||
return _nativePointer; |
|||
} |
|||
} |
|||
|
|||
public void*** PPV => (void***)NativePointer; |
|||
|
|||
public MicroComProxyBase(IntPtr nativePointer, bool ownsHandle) |
|||
{ |
|||
_nativePointer = nativePointer; |
|||
_ownsHandle = ownsHandle; |
|||
_synchronizationContext = SynchronizationContext.Current; |
|||
if(!_ownsHandle) |
|||
GC.SuppressFinalize(this); |
|||
} |
|||
|
|||
protected virtual int VTableSize => 3; |
|||
|
|||
public void AddRef() |
|||
{ |
|||
LocalInterop.CalliStdCallvoid(PPV, (*PPV)[1]); |
|||
} |
|||
|
|||
public void Release() |
|||
{ |
|||
LocalInterop.CalliStdCallvoid(PPV, (*PPV)[2]); |
|||
} |
|||
|
|||
public int QueryInterface(Guid guid, out IntPtr ppv) |
|||
{ |
|||
IntPtr r = default; |
|||
var rv = LocalInterop.CalliStdCallint(PPV, &guid, &r, (*PPV)[0]); |
|||
ppv = r; |
|||
return rv; |
|||
} |
|||
|
|||
public T QueryInterface<T>() where T : IUnknown |
|||
{ |
|||
var guid = MicroComRuntime.GetGuidFor(typeof(T)); |
|||
var rv = QueryInterface(guid, out var ppv); |
|||
if (rv == 0) |
|||
return (T)MicroComRuntime.CreateProxyFor(typeof(T), ppv, true); |
|||
throw new COMException("QueryInterface failed", rv); |
|||
} |
|||
|
|||
public bool IsDisposed => _nativePointer == IntPtr.Zero; |
|||
|
|||
protected virtual void Dispose(bool disposing) |
|||
{ |
|||
if(_nativePointer == IntPtr.Zero) |
|||
return; |
|||
if (_ownsHandle) |
|||
{ |
|||
Release(); |
|||
_ownsHandle = false; |
|||
} |
|||
_nativePointer = IntPtr.Zero; |
|||
GC.SuppressFinalize(this); |
|||
} |
|||
|
|||
public void Dispose() => Dispose(true); |
|||
|
|||
public bool OwnsHandle => _ownsHandle; |
|||
|
|||
public void EnsureOwned() |
|||
{ |
|||
if (!_ownsHandle) |
|||
{ |
|||
GC.ReRegisterForFinalize(true); |
|||
AddRef(); |
|||
_ownsHandle = true; |
|||
} |
|||
} |
|||
|
|||
private static readonly SendOrPostCallback _disposeDelegate = DisposeOnContext; |
|||
|
|||
private static void DisposeOnContext(object state) |
|||
{ |
|||
(state as MicroComProxyBase)?.Dispose(false); |
|||
} |
|||
|
|||
~MicroComProxyBase() |
|||
{ |
|||
if(!_ownsHandle) |
|||
return; |
|||
if (_synchronizationContext == null) |
|||
Dispose(); |
|||
else |
|||
_synchronizationContext.Post(_disposeDelegate, this); |
|||
} |
|||
} |
|||
} |
|||
@ -1,143 +0,0 @@ |
|||
using System; |
|||
using System.Collections.Concurrent; |
|||
using System.Runtime.InteropServices; |
|||
|
|||
namespace Avalonia.MicroCom |
|||
{ |
|||
public static unsafe class MicroComRuntime |
|||
{ |
|||
private static ConcurrentDictionary<Type, IntPtr> _vtables = new ConcurrentDictionary<Type, IntPtr>(); |
|||
|
|||
private static ConcurrentDictionary<Type, Func<IntPtr, bool, object>> _factories = |
|||
new ConcurrentDictionary<Type, Func<IntPtr, bool, object>>(); |
|||
private static ConcurrentDictionary<Type, Guid> _guids = new ConcurrentDictionary<Type, Guid>(); |
|||
private static ConcurrentDictionary<Guid, Type> _guidsToTypes = new ConcurrentDictionary<Guid, Type>(); |
|||
|
|||
internal static readonly Guid ManagedObjectInterfaceGuid = Guid.Parse("cd7687c0-a9c2-4563-b08e-a399df50c633"); |
|||
|
|||
static MicroComRuntime() |
|||
{ |
|||
Register(typeof(IUnknown), new Guid("00000000-0000-0000-C000-000000000046"), |
|||
(ppv, owns) => new MicroComProxyBase(ppv, owns)); |
|||
RegisterVTable(typeof(IUnknown), MicroComVtblBase.Vtable); |
|||
} |
|||
|
|||
public static void RegisterVTable(Type t, IntPtr vtable) |
|||
{ |
|||
_vtables[t] = vtable; |
|||
} |
|||
|
|||
public static void Register(Type t, Guid guid, Func<IntPtr, bool, object> proxyFactory) |
|||
{ |
|||
_factories[t] = proxyFactory; |
|||
_guids[t] = guid; |
|||
_guidsToTypes[guid] = t; |
|||
} |
|||
|
|||
public static Guid GetGuidFor(Type type) => _guids[type]; |
|||
|
|||
public static T CreateProxyFor<T>(void* pObject, bool ownsHandle) => (T)CreateProxyFor(typeof(T), new IntPtr(pObject), ownsHandle); |
|||
public static T CreateProxyFor<T>(IntPtr pObject, bool ownsHandle) => (T)CreateProxyFor(typeof(T), pObject, ownsHandle); |
|||
|
|||
public static T CreateProxyOrNullFor<T>(void* pObject, bool ownsHandle) where T : class => |
|||
pObject == null ? null : (T)CreateProxyFor(typeof(T), new IntPtr(pObject), ownsHandle); |
|||
|
|||
public static T CreateProxyOrNullFor<T>(IntPtr pObject, bool ownsHandle) where T : class => |
|||
pObject == IntPtr.Zero ? null : (T)CreateProxyFor(typeof(T), pObject, ownsHandle); |
|||
|
|||
public static object CreateProxyFor(Type type, IntPtr pObject, bool ownsHandle) => _factories[type](pObject, ownsHandle); |
|||
|
|||
public static IntPtr GetNativeIntPtr<T>(this T obj, bool owned = false) where T : IUnknown |
|||
=> new IntPtr(GetNativePointer(obj, owned)); |
|||
public static void* GetNativePointer<T>(T obj, bool owned = false) where T : IUnknown |
|||
{ |
|||
if (obj == null) |
|||
return null; |
|||
if (obj is MicroComProxyBase proxy) |
|||
{ |
|||
if(owned) |
|||
proxy.AddRef(); |
|||
return (void*)proxy.NativePointer; |
|||
} |
|||
|
|||
if (obj is IMicroComShadowContainer container) |
|||
{ |
|||
container.Shadow ??= new MicroComShadow(container); |
|||
void* ptr = null; |
|||
var res = container.Shadow.GetOrCreateNativePointer(typeof(T), &ptr); |
|||
if (res != 0) |
|||
throw new COMException( |
|||
"Unable to create native callable wrapper for type " + typeof(T) + " for instance of type " + |
|||
obj.GetType(), |
|||
res); |
|||
if (owned) |
|||
container.Shadow.AddRef((Ccw*)ptr); |
|||
return ptr; |
|||
} |
|||
throw new ArgumentException("Unable to get a native pointer for " + obj); |
|||
} |
|||
|
|||
public static object GetObjectFromCcw(IntPtr ccw) |
|||
{ |
|||
var ptr = (Ccw*)ccw; |
|||
var shadow = (MicroComShadow)GCHandle.FromIntPtr(ptr->GcShadowHandle).Target; |
|||
return shadow.Target; |
|||
} |
|||
|
|||
public static bool IsComWrapper(IUnknown obj) => obj is MicroComProxyBase; |
|||
|
|||
public static object TryUnwrapManagedObject(IUnknown obj) |
|||
{ |
|||
if (obj is not MicroComProxyBase proxy) |
|||
return null; |
|||
if (proxy.QueryInterface(ManagedObjectInterfaceGuid, out _) != 0) |
|||
return null; |
|||
// Successful QueryInterface always increments ref counter
|
|||
proxy.Release(); |
|||
return GetObjectFromCcw(proxy.NativePointer); |
|||
} |
|||
|
|||
public static bool TryGetTypeForGuid(Guid guid, out Type t) => _guidsToTypes.TryGetValue(guid, out t); |
|||
|
|||
public static bool GetVtableFor(Type type, out IntPtr ptr) => _vtables.TryGetValue(type, out ptr); |
|||
|
|||
public static void UnhandledException(object target, Exception e) |
|||
{ |
|||
if (target is IMicroComExceptionCallback cb) |
|||
{ |
|||
try |
|||
{ |
|||
cb.RaiseException(e); |
|||
} |
|||
catch |
|||
{ |
|||
// We've tried
|
|||
} |
|||
} |
|||
|
|||
} |
|||
|
|||
public static T CloneReference<T>(this T iface) where T : IUnknown |
|||
{ |
|||
var proxy = (MicroComProxyBase)(object)iface; |
|||
var ownedPointer = GetNativePointer(iface, true); |
|||
return CreateProxyFor<T>(ownedPointer, true); |
|||
} |
|||
|
|||
public static T QueryInterface<T>(this IUnknown unknown) where T : IUnknown |
|||
{ |
|||
var proxy = (MicroComProxyBase)unknown; |
|||
return proxy.QueryInterface<T>(); |
|||
} |
|||
|
|||
public static void UnsafeAddRef(this IUnknown unknown) |
|||
{ |
|||
((MicroComProxyBase)unknown).AddRef(); |
|||
} |
|||
|
|||
public static void UnsafeRelease(this IUnknown unknown) |
|||
{ |
|||
((MicroComProxyBase)unknown).Release(); |
|||
} |
|||
} |
|||
} |
|||
@ -1,177 +0,0 @@ |
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Runtime.InteropServices; |
|||
using System.Threading; |
|||
|
|||
namespace Avalonia.MicroCom |
|||
{ |
|||
public unsafe class MicroComShadow : IDisposable |
|||
{ |
|||
private readonly object _lock = new object(); |
|||
private readonly Dictionary<Type, IntPtr> _shadows = new Dictionary<Type, IntPtr>(); |
|||
private readonly Dictionary<IntPtr, Type> _backShadows = new Dictionary<IntPtr, Type>(); |
|||
private GCHandle? _handle; |
|||
private volatile int _refCount; |
|||
internal IMicroComShadowContainer Target { get; } |
|||
internal MicroComShadow(IMicroComShadowContainer target) |
|||
{ |
|||
Target = target; |
|||
Target.Shadow = this; |
|||
} |
|||
|
|||
internal int QueryInterface(Ccw* ccw, Guid* guid, void** ppv) |
|||
{ |
|||
if (MicroComRuntime.TryGetTypeForGuid(*guid, out var type)) |
|||
return QueryInterface(type, ppv); |
|||
else if (*guid == MicroComRuntime.ManagedObjectInterfaceGuid) |
|||
{ |
|||
ccw->RefCount++; |
|||
*ppv = ccw; |
|||
return 0; |
|||
} |
|||
else |
|||
return unchecked((int)0x80004002u); |
|||
} |
|||
|
|||
internal int QueryInterface(Type type, void** ppv) |
|||
{ |
|||
if (!type.IsInstanceOfType(Target)) |
|||
return unchecked((int)0x80004002u); |
|||
|
|||
var rv = GetOrCreateNativePointer(type, ppv); |
|||
if (rv == 0) |
|||
AddRef((Ccw*)*ppv); |
|||
return rv; |
|||
} |
|||
|
|||
internal int GetOrCreateNativePointer(Type type, void** ppv) |
|||
{ |
|||
if (!MicroComRuntime.GetVtableFor(type, out var vtable)) |
|||
return unchecked((int)0x80004002u); |
|||
lock (_lock) |
|||
{ |
|||
|
|||
if (_shadows.TryGetValue(type, out var shadow)) |
|||
{ |
|||
var targetCcw = (Ccw*)shadow; |
|||
AddRef(targetCcw); |
|||
*ppv = targetCcw; |
|||
return 0; |
|||
} |
|||
else |
|||
{ |
|||
var intPtr = Marshal.AllocHGlobal(Marshal.SizeOf<Ccw>()); |
|||
var targetCcw = (Ccw*)intPtr; |
|||
*targetCcw = default; |
|||
targetCcw->RefCount = 0; |
|||
targetCcw->VTable = vtable; |
|||
if (_handle == null) |
|||
_handle = GCHandle.Alloc(this); |
|||
targetCcw->GcShadowHandle = GCHandle.ToIntPtr(_handle.Value); |
|||
_shadows[type] = intPtr; |
|||
_backShadows[intPtr] = type; |
|||
*ppv = targetCcw; |
|||
|
|||
return 0; |
|||
} |
|||
} |
|||
} |
|||
|
|||
internal int AddRef(Ccw* ccw) |
|||
{ |
|||
if (Interlocked.Increment(ref _refCount) == 1) |
|||
{ |
|||
try |
|||
{ |
|||
Target.OnReferencedFromNative(); |
|||
} |
|||
catch (Exception e) |
|||
{ |
|||
MicroComRuntime.UnhandledException(Target, e); |
|||
} |
|||
} |
|||
|
|||
return Interlocked.Increment(ref ccw->RefCount); |
|||
} |
|||
|
|||
internal int Release(Ccw* ccw) |
|||
{ |
|||
Interlocked.Decrement(ref _refCount); |
|||
var cnt = Interlocked.Decrement(ref ccw->RefCount); |
|||
if (cnt == 0) |
|||
return FreeCcw(ccw); |
|||
|
|||
return cnt; |
|||
} |
|||
|
|||
int FreeCcw(Ccw* ccw) |
|||
{ |
|||
lock (_lock) |
|||
{ |
|||
// Shadow got resurrected by a call to QueryInterface from another thread
|
|||
if (ccw->RefCount != 0) |
|||
return ccw->RefCount; |
|||
|
|||
var intPtr = new IntPtr(ccw); |
|||
var type = _backShadows[intPtr]; |
|||
_backShadows.Remove(intPtr); |
|||
_shadows.Remove(type); |
|||
Marshal.FreeHGlobal(intPtr); |
|||
if (_shadows.Count == 0) |
|||
{ |
|||
_handle?.Free(); |
|||
_handle = null; |
|||
try |
|||
{ |
|||
Target.OnUnreferencedFromNative(); |
|||
} |
|||
catch(Exception e) |
|||
{ |
|||
MicroComRuntime.UnhandledException(Target, e); |
|||
} |
|||
} |
|||
} |
|||
|
|||
return 0; |
|||
} |
|||
|
|||
/* |
|||
Needs to be called to support the following scenario: |
|||
1) Object created |
|||
2) Object passed to native code, shadow is created, CCW is created |
|||
3) Native side has never called AddRef |
|||
|
|||
In that case the GC handle to the shadow object is still alive |
|||
*/ |
|||
|
|||
public void Dispose() |
|||
{ |
|||
lock (_lock) |
|||
{ |
|||
List<IntPtr> toRemove = null; |
|||
foreach (var kv in _backShadows) |
|||
{ |
|||
var ccw = (Ccw*)kv.Key; |
|||
if (ccw->RefCount == 0) |
|||
{ |
|||
toRemove ??= new List<IntPtr>(); |
|||
toRemove.Add(kv.Key); |
|||
} |
|||
} |
|||
|
|||
if(toRemove != null) |
|||
foreach (var intPtr in toRemove) |
|||
FreeCcw((Ccw*)intPtr); |
|||
} |
|||
} |
|||
} |
|||
|
|||
[StructLayout(LayoutKind.Sequential)] |
|||
struct Ccw |
|||
{ |
|||
public IntPtr VTable; |
|||
public IntPtr GcShadowHandle; |
|||
public volatile int RefCount; |
|||
public MicroComShadow GetShadow() => (MicroComShadow)GCHandle.FromIntPtr(GcShadowHandle).Target; |
|||
} |
|||
} |
|||
@ -1,47 +0,0 @@ |
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Runtime.InteropServices; |
|||
|
|||
namespace Avalonia.MicroCom |
|||
{ |
|||
public unsafe class MicroComVtblBase |
|||
{ |
|||
private List<IntPtr> _methods = new List<IntPtr>(); |
|||
[UnmanagedFunctionPointerAttribute(CallingConvention.StdCall)] |
|||
private delegate int AddRefDelegate(Ccw* ccw); |
|||
|
|||
[UnmanagedFunctionPointerAttribute(CallingConvention.StdCall)] |
|||
private delegate int QueryInterfaceDelegate(Ccw* ccw, Guid* guid, void** ppv); |
|||
|
|||
public static IntPtr Vtable { get; } = new MicroComVtblBase().CreateVTable(); |
|||
public MicroComVtblBase() |
|||
{ |
|||
AddMethod((QueryInterfaceDelegate)QueryInterface); |
|||
AddMethod((AddRefDelegate)AddRef); |
|||
AddMethod((AddRefDelegate)Release); |
|||
} |
|||
|
|||
protected void AddMethod(void* f) |
|||
{ |
|||
_methods.Add(new IntPtr(f)); |
|||
} |
|||
|
|||
protected void AddMethod(Delegate d) |
|||
{ |
|||
GCHandle.Alloc(d); |
|||
_methods.Add(Marshal.GetFunctionPointerForDelegate(d)); |
|||
} |
|||
|
|||
protected unsafe IntPtr CreateVTable() |
|||
{ |
|||
var ptr = (IntPtr*)Marshal.AllocHGlobal((IntPtr.Size + 1) * _methods.Count); |
|||
for (var c = 0; c < _methods.Count; c++) |
|||
ptr[c] = _methods[c]; |
|||
return new IntPtr(ptr); |
|||
} |
|||
|
|||
static int QueryInterface(Ccw* ccw, Guid* guid, void** ppv) => ccw->GetShadow().QueryInterface(ccw, guid, ppv); |
|||
static int AddRef(Ccw* ccw) => ccw->GetShadow().AddRef(ccw); |
|||
static int Release(Ccw* ccw) => ccw->GetShadow().Release(ccw); |
|||
} |
|||
} |
|||
@ -1,5 +1,5 @@ |
|||
<Project> |
|||
<Project> |
|||
<PropertyGroup> |
|||
<EmccExtraLDFlags>$(EmccExtraLDFlags) --js-library="$(MSBuildThisFileDirectory)\interop.js"</EmccExtraLDFlags> |
|||
<EmccInitialHeapSize>16384000</EmccInitialHeapSize> <!-- must be a multiple of 64KiB, 1024000 * num MB, number grows --> |
|||
</PropertyGroup> |
|||
</Project> |
|||
|
|||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue