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);
}
}
}
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));
}
}
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);
}
}
}
}
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);
}
}
public void Can_clear_variants()
{
using (var list = new NetVariantList())
{
using (var variant1 = new NetVariant())
using (var variant2 = new NetVariant())
{
variant1.String = "test1";
variant2.String = "test2";
list.Add(variant1);
list.Add(variant2);
list.Count.Should().Be(2);
list.Clear();
list.Count.Should().Be(0);
}
}
}
public void Can_remove_variants()
{
using (var list = new NetVariantList())
{
using (var variant1 = new NetVariant())
using (var variant2 = new NetVariant())
{
variant1.String = "test1";
variant2.String = "test2";
list.Add(variant1);
list.Add(variant2);
list.Count.Should().Be(2);
list.Remove(0);
list.Count.Should().Be(1);
list.Get(0).String.Should().Be("test2");
}
}
}
public void Can_add_variants()
{
using (var list = new NetVariantList())
{
using (var variant = new NetVariant())
{
variant.String = "test";
list.Add(variant);
list.Count.Should().Be(1);
list.Get(0).String.Should().Be("test");
}
}
}
public void Can_invoke_method()
{
var o = new TestObject();
var type = NetTypeManager.GetTypeInfo <TestObject>();
type.EnsureLoaded();
var method = type.GetMethod(0);
var instance = NetReference.CreateForObject(o);
// This will jump to native, to then call the .NET delegate (round trip).
// The purpose is to simulate Qml invoking a method, sending .NET instance back.
// We will inspect the returned instance that it got back to verify that it
using (var parameter = new NetVariant())
using (var list = new NetVariantList())
{
parameter.Instance = instance;
list.Add(parameter);
Interop.Callbacks.InvokeMethod(method.Handle, instance.Handle, list.Handle, IntPtr.Zero);
}
o.Object.Should().NotBeNull();
ReferenceEquals(o.Object, o).Should().BeTrue();
}