internal static RectangleF RectFAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
return(variant?.RectF ?? default(RectangleF));
}
}
internal static PointF PointFAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
return(variant?.PointF ?? default(PointF));
}
}
internal static SizeF SizeFAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
return(variant?.SizeF ?? default(SizeF));
}
}
internal static long LongAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
return(variant?.Long ?? default(long));
}
}
internal static int IntAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
return(variant?.Int ?? default(int));
}
}
internal static Vector4 Vector4DAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
return(variant?.Vector4D ?? default(Vector4));
}
}
public void Can_store_variant_list()
{
using (var variant = new NetVariant())
using (var variantList = new NetVariantList())
{
using (var value1 = NetVariant.From(3))
{
variantList.Add(value1);
}
variant.VariantType.Should().Be(NetVariantType.Invalid);
variant.NetVariantList = variantList;
variant.VariantType.Should().Be(NetVariantType.NetVariantList);
using (var resultVariantList = variant.NetVariantList)
{
resultVariantList.Should().NotBeNull();
resultVariantList.Count.Should().Be(variantList.Count);
using (var value1 = resultVariantList.Get(0))
using (var value2 = variantList.Get(0))
{
value1.Int.Should().Be(3);
value2.Int.Should().Be(3);
}
}
}
}
private static object ObjectAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
return(variant?.AsObject());
}
}
private static char CharAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
return(variant?.Char ?? default(char));
}
}
public bool ActivateSignal(string signalName, params object[] parameters)
{
QmlNetConfig.EnsureUIThread();
if (parameters != null && parameters.Length > 0)
{
using (var list = new NetVariantList())
{
foreach (var parameter in parameters)
{
using (var variant = new NetVariant())
{
Helpers.PackValue(parameter, variant);
list.Add(variant);
}
}
return(Interop.NetReference.ActivateSignal(Handle, signalName, list.Handle) == 1);
}
}
else
{
return(Interop.NetReference.ActivateSignal(Handle, signalName, IntPtr.Zero) == 1);
}
}
internal static Quaternion QuaternionAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
return(variant?.Quaternion ?? default(Quaternion));
}
}
private static DateTimeOffset DateTimeAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
return(variant?.DateTime ?? default(DateTimeOffset));
}
}
private static uint UIntAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
return(variant?.UInt ?? default(uint));
}
}
private static float FloatAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
return(variant?.Float ?? default(float));
}
}
private static double DoubleAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
return(variant?.Double ?? default(double));
}
}
private static ulong ULongAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
return(variant?.ULong ?? default(long));
}
}
public void InvokeMethod(IntPtr m, IntPtr t, IntPtr p, IntPtr r)
{
using (var method = new NetMethodInfo(m))
using (var target = new NetReference(t))
using (var parameters = new NetVariantList(p))
using (var result = r != IntPtr.Zero ? new NetVariant(r) : null)
{
CodeGen.CodeGen.InvokeMethodDelegate del;
if (!_cachedInvokeMethods.TryGetValue(method.Id, out del))
{
del = CodeGen.CodeGen.BuildInvokeMethodDelegate(method);
_cachedInvokeMethods[method.Id] = del;
}
Task resultTask = null;
del(target, parameters, result, ref resultTask);
if (QmlNetConfig.ListenForExceptionsWhenInvokingTasks)
{
resultTask?.ContinueWith(
task =>
{
QmlNetConfig.RaiseUnhandledTaskException(task.Exception);
},
TaskContinuationOptions.OnlyOnFaulted);
}
}
}
internal static Matrix4x4 Matrix4x4At(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
return(variant?.Matrix4x4 ?? default(Matrix4x4));
}
}
private static bool BoolAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
return(variant != null && variant.Bool);
}
}
public void WriteProperty(IntPtr p, IntPtr t, IntPtr ip, IntPtr v)
{
using (var property = new NetPropertyInfo(p))
using (var target = new NetReference(t))
using (var indexParameter = ip != IntPtr.Zero ? new NetVariant(ip) : null)
using (var value = new NetVariant(v))
{
CodeGen.CodeGen.InvokeMethodDelegate del;
if (!_cachedSetProperties.TryGetValue(property.Id, out del))
{
del = CodeGen.CodeGen.BuildSetPropertyDelegate(property);
_cachedSetProperties[property.Id] = del;
}
using (var list = new NetVariantList())
{
if (indexParameter != null)
{
list.Add(indexParameter);
}
list.Add(value);
Task resultTask = null;
del(target, list, null, ref resultTask);
}
}
}
public void Can_create_net_variant_list()
{
using (var list = new NetVariantList())
{
list.Count.Should().Be(0);
}
}
private static IntPtr Create(List <string> args)
{
if (args == null)
{
args = new List <string>();
}
// By default, the argv[0] should be the process name.
// .NET doesn't pass that name, but Qt should get it
// since it does in a normal Qt environment.
args.Insert(0, System.Diagnostics.Process.GetCurrentProcess().ProcessName);
using (var strings = new NetVariantList())
{
foreach (var arg in args)
{
using (var variant = new NetVariant())
{
variant.String = arg;
strings.Add(variant);
}
}
return(Interop.QGuiApplication.Create(strings.Handle, IntPtr.Zero));
}
}
internal static System.Drawing.Color ColorAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
if (variant == null || variant.VariantType == NetVariantType.Invalid)
{
return(default);
private static string StringAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
if (variant == null || variant.VariantType == NetVariantType.Invalid)
{
return(null);
}
return(variant.String);
}
}
private static double?DoubleNullableAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
if (variant == null || variant.VariantType == NetVariantType.Invalid)
{
return(null);
}
return(variant.Double);
}
}
private static ulong?ULongNullableAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
if (variant == null || variant.VariantType == NetVariantType.Invalid)
{
return(null);
}
return(variant.ULong);
}
}
private static DateTimeOffset?DateTimeNullableAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
if (variant == null || variant.VariantType == NetVariantType.Invalid)
{
return(null);
}
return(variant.DateTime);
}
}
internal static Matrix4x4?Matrix4x4NullableAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
if (variant == null || variant.VariantType == NetVariantType.Invalid)
{
return(null);
}
return(variant.Matrix4x4);
}
}
internal static Vector4?Vector4DNullableAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
if (variant == null || variant.VariantType == NetVariantType.Invalid)
{
return(null);
}
return(variant.Vector4D);
}
}
internal static Quaternion?QuaternionNullableAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
if (variant == null || variant.VariantType == NetVariantType.Invalid)
{
return(null);
}
return(variant.Quaternion);
}
}
