public void TestParamSpecObject() { var param = TestParamSpec(GType.Object, (name, nick, blurb, flags) => new ParamSpecObject(name, nick, blurb, GType.TypeOf <GISharp.GObject.Object> (), flags)); Assert.That(param.GetGType().Name, Is.EqualTo("GParamObject")); Utility.AssertNoGLibLog(); }
public void TestParamSpecBoxed() { var gtype = GType.TypeOf <object> (); Assume.That(gtype.IsA(GType.Boxed)); var param = TestParamSpec(gtype, (name, nick, blurb, flags) => new ParamSpecBoxed(name, nick, blurb, gtype, flags)); Assert.That(param.GetGType().Name, Is.EqualTo("GParamBoxed")); Utility.AssertNoGLibLog(); }
public void TestParamSpecParam() { var gtype = GType.TypeOf <ParamSpecBoolean> (); Assume.That(gtype.IsA(GType.Param)); var param = TestParamSpec(gtype, (name, nick, blurb, flags) => new ParamSpecParam(name, nick, blurb, gtype, flags)); Assert.That(param.GetGType().Name, Is.EqualTo("GParamParam")); Utility.AssertNoGLibLog(); }
public void TestParamSpecFlags() { const TestFlags defaultValue = TestFlags.Two; var gtype = GType.TypeOf <TestFlags> (); Assume.That(gtype.IsA(GType.Flags)); var param = TestParamSpec(gtype, (name, nick, blurb, flags) => new ParamSpecFlags(name, nick, blurb, gtype, defaultValue, flags)); Assert.That(param.FlagsType, Is.EqualTo(typeof(TestFlags))); Assert.That(param.DefaultValue, Is.EqualTo(defaultValue)); Assert.That(param.GetGType().Name, Is.EqualTo("GParamFlags")); Utility.AssertNoGLibLog(); }
/// <summary> /// Gets a managed proxy for a an unmanged GParamSpec. /// </summary> /// <param name="handle"> /// The pointer to the unmanaged instance /// </param> /// <param name="ownership"> /// Indicates if we already have a reference to the unmanged instance /// or not. /// </param> /// <returns> /// A managed proxy instance /// </returns> /// <remarks> /// This method tries to get an existing managed proxy instance by /// looking for a GC handle attached to the unmanaged instance (using /// QData). If one is found, it returns the existing managed instance, /// otherwise a new instance is created. /// </remarks> public static new T GetInstance <T>(IntPtr handle, Transfer ownership) where T : ParamSpec { if (handle == IntPtr.Zero) { return(null); } // see if the unmanaged object has a managed GC handle var ptr = g_param_spec_get_qdata(handle, managedProxyGCHandleQuark); if (ptr != IntPtr.Zero) { var gcHandle = (GCHandle)ptr; if (gcHandle.IsAllocated) { // the GC handle looks good, so we should have the managed // proxy for the unmanged object here var target = (ParamSpec)gcHandle.Target; // make sure the managed object has not been disposed if (target.handle == handle) { // release the extra reference, if there is one if (ownership != Transfer.None) { g_param_spec_unref(handle); } // return the existing managed proxy return((T)(object)target); } } } // if we get here, that means that there wasn't a viable existing // proxy, so we need to create a new managed instance // get the exact type of the object ptr = Marshal.ReadIntPtr(handle); var gtype = Marshal.PtrToStructure <GType>(ptr); var type = GType.TypeOf(gtype); return((T)Activator.CreateInstance(type, handle, ownership)); }
/// <summary> /// Invokes the closure, i.e. executes the callback represented by this closure. /// </summary> /// <param name="paramValues"> /// an array of #GValues holding the arguments on which to /// invoke the callback of this closure /// </param> /// <returns>The return value of the closure invocation</returns> public T Invoke <T>(params object[] paramValues) { AssertNotDisposed(); if (paramValues == null) { throw new ArgumentNullException(nameof(paramValues)); } var returnValue = new Value(GType.TypeOf <T>()); var values = paramValues.Select(p => new Value(p?.GetType(), p)).ToArray(); g_closure_invoke(handle, ref returnValue, (uint)values.Length, values, IntPtr.Zero); foreach (var v in values) { v.Unset(); } var ret = returnValue.Get(); returnValue.Unset(); return((T)ret); }
public void TestTypeOfUnregisteredManagedType() { // This tests that if a GType is received from unmanged code // that has never been initialized in managed code. const string testName = "TestTypeOfUnregisteredManagedType"; // first we register the type in unmanged code and make sure that // it throws an exception because there is no matching type in // managed code. var gtype = GetDummyGType(); // TODO: Need more specific type of exception Assert.That(() => GType.TypeOf(gtype), Throws.Exception); // then we dynamically generate a matching managed type var asmBuilder = AssemblyBuilder.DefineDynamicAssembly( new AssemblyName(testName + "_assembly"), AssemblyBuilderAccess.Run); var modBuilder = asmBuilder.DefineDynamicModule(testName + "_module"); var typeBuilder = modBuilder.DefineType(testName + "_type", TypeAttributes.Public); var gtypeAttribute = typeof(GTypeAttribute); typeBuilder.SetCustomAttribute(new CustomAttributeBuilder( gtypeAttribute.GetConstructors().Single(), new object [] { dummyTypeName }, new [] { gtypeAttribute.GetProperty("IsProxyForUnmanagedType"), }, new object [] { true, // IsProxyForUnmanagedType })); var gtypeStructAttribute = typeof(GTypeStructAttribute); typeBuilder.SetCustomAttribute(new CustomAttributeBuilder( gtypeStructAttribute.GetConstructors().Single(), new object[] { typeof(ObjectClass) }, new FieldInfo[0], new object[0])); var getTypeMethod = typeBuilder.DefineMethod("getGType", MethodAttributes.Private | MethodAttributes.Static); getTypeMethod.SetReturnType(typeof(GType)); var getDummyGType = GetType().GetMethod(nameof(GetDummyGType)); var generator = getTypeMethod.GetILGenerator(); generator.Emit(OpCodes.Call, getDummyGType); generator.Emit(OpCodes.Ret); var expectedType = typeBuilder.CreateType(); // and try the test again var actualType = GType.TypeOf(gtype); Assert.That(actualType, Is.EqualTo(expectedType)); Utility.AssertNoGLibLog(); }