Callback support

src/Generation/Generator/Generator/Internal/OpaqueRecordHandle.cs

@@ -0,0 +1,32 @@
+using Generator.Model;
+
+namespace Generator.Generator.Internal;
+
+internal class OpaqueRecordHandle : Generator<GirModel.Record>
+{
+    private readonly Publisher _publisher;
+
+    public OpaqueRecordHandle(Publisher publisher)
+    {
+        _publisher = publisher;
+    }
+
+    public void Generate(GirModel.Record obj)
+    {
+        if (!obj.Opaque)
+            return;
+
+        if (obj.TypeFunction is null)
+            return;
+
+        var source = Renderer.Internal.OpaqueRecordHandle.Render(obj);
+        var codeUnit = new CodeUnit(
+            Project: Namespace.GetCanonicalName(obj.Namespace),
+            Name: Model.OpaqueRecord.GetInternalHandle(obj),
+            Source: source,
+            IsInternal: true
+        );
+
+        _publisher.Publish(codeUnit);
+    }
+}

src/Generation/Generator/Model/OpaqueRecord.cs

@@ -2,15 +2,36 @@
 
 internal static class OpaqueRecord
 {
-    public static string GetBoxedHandle(GirModel.Record record)
-        => $"GLib.Internal.BoxedHandle<{Namespace.GetInternalName(record.Namespace)}.{Type.GetName(record)}>";
+    public static string GetPublicClassName(GirModel.Record record)
+        => record.Name;
 
-    public static string GetOwnedBoxedHandle(GirModel.Record record)
-        => $"GLib.Internal.OwnedBoxedHandle<{Namespace.GetInternalName(record.Namespace)}.{Type.GetName(record)}>";
+    public static string GetFullyQualifiedPublicClassName(GirModel.Record record)
+        => Namespace.GetPublicName(record.Namespace) + "." + GetPublicClassName(record);
 
-    public static string GetInitiallyUnownedBoxedHandle(GirModel.Record record)
-        => $"GLib.Internal.InitiallyUnownedBoxedHandle<{Namespace.GetInternalName(record.Namespace)}.{Type.GetName(record)}>";
+    public static string GetFullyQualifiedInternalClassName(GirModel.Record record)
+        => Namespace.GetInternalName(record.Namespace) + "." + record.Name;
+
+    public static string GetInternalHandle(GirModel.Record record)
+        => $"{Type.GetName(record)}Handle";
+
+    public static string GetInternalOwnedHandle(GirModel.Record record)
+        => $"{Type.GetName(record)}OwnedHandle";
+
+    public static string GetInternalNullHandle(GirModel.Record record)
+        => $"{Type.GetName(record)}NullHandle";
+
+    public static string GetInternalInitiallyUnownedHandle(GirModel.Record record)
+        => $"{Type.GetName(record)}InitiallyUnownedHandle";
+
+    public static string GetFullyQuallifiedInternalHandle(GirModel.Record record)
+        => $"{Namespace.GetInternalName(record.Namespace)}.{GetInternalHandle(record)}";
+
+    public static string GetFullyQuallifiedOwnedHandle(GirModel.Record record)
+        => $"{Namespace.GetInternalName(record.Namespace)}.{GetInternalOwnedHandle(record)}";
+
+    public static string GetFullyQuallifiedInitiallyUnownedBoxedHandle(GirModel.Record record)
+        => $"{Namespace.GetInternalName(record.Namespace)}.{GetInternalInitiallyUnownedHandle(record)}";
 
-    public static string GetNullBoxedHandle(GirModel.Record record)
-        => $"GLib.Internal.BoxedHandle<{Namespace.GetInternalName(record.Namespace)}.{Type.GetName(record)}>.NullHandle";
+    public static string GetFullyQuallifiedNullBoxedHandle(GirModel.Record record)
+        => $"{Namespace.GetInternalName(record.Namespace)}.{Type.GetName(record)}NullHandle.Instance";
 }

src/Generation/Generator/Records.cs

@@ -14,6 +14,7 @@ public static void Generate(IEnumerable<GirModel.Record> records, string path)
         {
             //Opaque records
             new Generator.Internal.OpaqueRecord(publisher),
+            new Generator.Internal.OpaqueRecordHandle(publisher),
             new Generator.Public.OpaqueRecord(publisher),
 
             //Regular records

src/Generation/Generator/Renderer/Internal/InstanceParameter/Converter/OpaqueRecord.cs

@@ -13,7 +13,7 @@ public RenderableInstanceParameter Convert(GirModel.InstanceParameter instancePa
 
         return new RenderableInstanceParameter(
             Name: Model.InstanceParameter.GetName(instanceParameter),
-            NullableTypeName: Model.OpaqueRecord.GetBoxedHandle(type)
+            NullableTypeName: Model.OpaqueRecord.GetFullyQuallifiedInternalHandle(type)
         );
     }
 }

src/Generation/Generator/Renderer/Internal/OpaqueRecordHandle.cs

@@ -0,0 +1,67 @@
+using Generator.Model;
+
+namespace Generator.Renderer.Internal;
+
+internal static class OpaqueRecordHandle
+{
+    public static string Render(GirModel.Record record)
+    {
+        var typeName = Model.OpaqueRecord.GetInternalHandle(record);
+        var initiallyUnownedHandleTypeName = Model.OpaqueRecord.GetInternalInitiallyUnownedHandle(record);
+        var ownedHandleTypeName = Model.OpaqueRecord.GetInternalOwnedHandle(record);
+        var nullHandleTypeName = Model.OpaqueRecord.GetInternalNullHandle(record);
+        var getGType = Model.OpaqueRecord.GetFullyQualifiedInternalClassName(record) + ".GetGType()";
+
+        return $@"using System;
+using GObject;
+using System.Runtime.InteropServices;
+using System.Runtime.Versioning;
+
+#nullable enable
+
+namespace {Namespace.GetInternalName(record.Namespace)};
+
+// AUTOGENERATED FILE - DO NOT MODIFY
+
+{PlatformSupportAttribute.Render(record as GirModel.PlatformDependent)}
+public partial class {typeName} : SafeHandle
+{{    
+    public sealed override bool IsInvalid => handle == IntPtr.Zero;
+
+    protected {typeName}(bool ownsHandle) : base(IntPtr.Zero, ownsHandle) {{ }}
+    
+    protected override bool ReleaseHandle()
+    {{
+        GLib.Internal.Functions.BoxedFree({getGType}, handle);
+        return true;
+    }}
+
+    public {typeName} Copy()
+    {{
+        var ptr = GLib.Internal.Functions.BoxedCopy({getGType}, handle);
+        var obj = new {typeName}(true);
+        obj.SetHandle(ptr);
+
+        return obj;
+    }}
+}}
+
+public class {initiallyUnownedHandleTypeName} : {typeName}
+{{
+    //Constructor for PInvoke
+    private {initiallyUnownedHandleTypeName}() : base(false) {{ }}
+}}
+
+public class {ownedHandleTypeName} : {typeName}
+{{
+    //Constructor for PInvoke
+    private {ownedHandleTypeName}() : base(true) {{ }}
+}}
+
+public class {nullHandleTypeName} : {typeName}
+{{
+    public static {nullHandleTypeName} Instance = new ();
+    private {nullHandleTypeName}() : base(false) {{ }}
+}}";
+    }
+}

src/Generation/Generator/Renderer/Internal/Parameter/Converter/OpaqueRecord.cs

@@ -23,8 +23,10 @@ private static string GetNullableTypeName(GirModel.Parameter parameter)
         var type = (GirModel.Record) parameter.AnyTypeOrVarArgs.AsT0.AsT0;
         return parameter switch
         {
-            { Direction: GirModel.Direction.In, Transfer: GirModel.Transfer.None } => Model.OpaqueRecord.GetBoxedHandle(type) + Nullable.Render(parameter),
-            { Direction: GirModel.Direction.In, Transfer: GirModel.Transfer.Full } => Model.OpaqueRecord.GetBoxedHandle(type) + Nullable.Render(parameter),
+            { Direction: GirModel.Direction.In, Transfer: GirModel.Transfer.None } => Model.OpaqueRecord.GetFullyQuallifiedInternalHandle(type) + Nullable.Render(parameter),
+            { Direction: GirModel.Direction.In, Transfer: GirModel.Transfer.Full } => Model.OpaqueRecord.GetFullyQuallifiedInternalHandle(type) + Nullable.Render(parameter),
+            { Direction: GirModel.Direction.Out, Transfer: GirModel.Transfer.Full } => Model.OpaqueRecord.GetFullyQuallifiedInternalHandle(type) + Nullable.Render(parameter),
+            { Direction: GirModel.Direction.Out, Transfer: GirModel.Transfer.None } => Model.OpaqueRecord.GetFullyQuallifiedInternalHandle(type) + Nullable.Render(parameter),
             _ => throw new System.Exception($"Can't detect opaque record parameter type {parameter.Name}: CallerAllocates={parameter.CallerAllocates} Direction={parameter.Direction} Transfer={parameter.Transfer}")
         };
     }

src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/OpaqueRecord.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+
+namespace Generator.Renderer.Internal.ParameterToManagedExpressions;
+
+internal class OpaqueRecord : ToManagedParameterConverter
+{
+    public bool Supports(GirModel.AnyType type)
+        => type.Is<GirModel.Record>(out var record) && record is { Opaque: true, TypeFunction: not null };
+
+    public void Initialize(ParameterToManagedData parameterData, IEnumerable<ParameterToManagedData> parameters)
+    {
+        if (parameterData.Parameter.Direction != GirModel.Direction.In)
+            throw new NotImplementedException($"{parameterData.Parameter.AnyTypeOrVarArgs}: opaque record with direction != in not yet supported");
+
+        var record = (GirModel.Record) parameterData.Parameter.AnyTypeOrVarArgs.AsT0.AsT0;
+        var variableName = Model.Parameter.GetConvertedName(parameterData.Parameter);
+
+        var signatureName = Model.Parameter.GetName(parameterData.Parameter);
+
+        parameterData.SetSignatureName(signatureName);
+        parameterData.SetExpression($"var {variableName} = new {Model.OpaqueRecord.GetFullyQualifiedPublicClassName(record)}({signatureName});");
+        parameterData.SetCallName(variableName);
+    }
+}

src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/ParameterToManagedExpression.cs

@@ -13,6 +13,7 @@ internal static class ParameterToManagedExpression
         new ParameterToManagedExpressions.Class(),
         new ParameterToManagedExpressions.Enumeration(),
         new ParameterToManagedExpressions.Interface(),
+        new ParameterToManagedExpressions.OpaqueRecord(),
         new ParameterToManagedExpressions.Pointer(),
         new ParameterToManagedExpressions.PointerAlias(),
         new ParameterToManagedExpressions.PrimitiveValueType(),

src/Generation/Generator/Renderer/Internal/ReturnType/Converter/OpaqueRecord.cs

@@ -15,8 +15,8 @@ public RenderableReturnType Convert(GirModel.ReturnType returnType)
 
         var typeName = returnType switch
         {
-            {Transfer: Transfer.Full} => Model.OpaqueRecord.GetOwnedBoxedHandle(type),
-            _ => Model.OpaqueRecord.GetInitiallyUnownedBoxedHandle(type)
+            {Transfer: Transfer.Full} => Model.OpaqueRecord.GetFullyQuallifiedOwnedHandle(type),
+            _ => Model.OpaqueRecord.GetFullyQuallifiedInitiallyUnownedBoxedHandle(type)
         };
 
         return new RenderableReturnType(typeName + Nullable.Render(returnType));

src/Generation/Generator/Renderer/Internal/ReturnType/Converter/OpaqueRecordCallback.cs

@@ -0,0 +1,19 @@
+using GirModel;
+
+namespace Generator.Renderer.Internal.ReturnType;
+
+internal class OpaqueRecordCallback : ReturnTypeConverter
+{
+    public bool Supports(GirModel.ReturnType returnType)
+    {
+        return returnType.AnyType.Is<GirModel.Record>(out var record) && record is { Opaque: true, TypeFunction: not null };
+    }
+
+    public RenderableReturnType Convert(GirModel.ReturnType returnType)
+    {
+        var type = (GirModel.Record) returnType.AnyType.AsT0;
+        var typeName = Model.OpaqueRecord.GetFullyQuallifiedInternalHandle(type);
+
+        return new RenderableReturnType(typeName + Nullable.Render(returnType));
+    }
+}

src/Generation/Generator/Renderer/Internal/ReturnType/ReturnTypeRendererCallback.cs

@@ -12,6 +12,7 @@ internal static class ReturnTypeRendererCallback
         new ReturnType.Enumeration(),
         new ReturnType.Interface(),
         new ReturnType.InterfaceGLibPtrArray(),
+        new ReturnType.OpaqueRecordCallback(),
         new ReturnType.PlatformStringInCallback(),
         new ReturnType.Pointer(),
         new ReturnType.PrimitiveValueType(),

src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/OpaqueRecord.cs

@@ -0,0 +1,12 @@
+using GirModel;
+
+namespace Generator.Renderer.Internal.ReturnTypeToNativeExpressions;
+
+internal class OpaqueRecord : ReturnTypeConverter
+{
+    public bool Supports(AnyType type)
+        => type.Is<GirModel.Record>(out var record) && record is { Opaque: true, TypeFunction: not null };
+
+    public string GetString(GirModel.ReturnType returnType, string fromVariableName)
+        => fromVariableName + ".Handle";
+}

src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/ReturnTypeToNativeExpression.cs

@@ -10,6 +10,7 @@ internal static class ReturnTypeToNativeExpression
         new ReturnTypeToNativeExpressions.Class(),
         new ReturnTypeToNativeExpressions.Enumeration(),
         new ReturnTypeToNativeExpressions.Interface(),
+        new ReturnTypeToNativeExpressions.OpaqueRecord(),
         new ReturnTypeToNativeExpressions.Pointer(),
         new ReturnTypeToNativeExpressions.PrimitiveValueType(),
         new ReturnTypeToNativeExpressions.PrimitiveValueTypeAlias(),

src/Generation/Generator/Renderer/Public/OpaqueRecord.cs

@@ -8,11 +8,12 @@ internal static class OpaqueRecord
 {
     public static string Render(GirModel.Record record)
     {
-        var name = Record.GetPublicClassName(record);
-        var internalHandleName = $"{Namespace.GetInternalName(record.Namespace)}.{Model.Type.GetName(record)}";
+        var name = Model.OpaqueRecord.GetPublicClassName(record);
+        var internalHandleName = Model.OpaqueRecord.GetFullyQuallifiedInternalHandle(record);
 
         return $@"
 using System;
+using System.Linq;
 using System.Runtime.InteropServices;
 using System.Runtime.Versioning;
 
@@ -25,9 +26,9 @@ namespace {Namespace.GetPublicName(record.Namespace)};
 {PlatformSupportAttribute.Render(record as GirModel.PlatformDependent)}
 public partial class {name}
 {{
-    public GLib.Internal.BoxedHandle<{internalHandleName}> Handle {{ get; }}
+    public {internalHandleName} Handle {{ get; }}
 
-    public {name}(GLib.Internal.BoxedHandle<{internalHandleName}> handle)
+    public {name}({internalHandleName} handle)
     {{
         Handle = handle;
         Initialize();

src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/OpaqueRecord.cs

@@ -19,9 +19,9 @@ public void Initialize(ParameterToNativeData parameter, IEnumerable<ParameterToN
 
         var callName = parameter.Parameter switch
         {
-            { Nullable: true, Transfer: GirModel.Transfer.None } => signatureName + "?.Handle ?? " + Model.OpaqueRecord.GetNullBoxedHandle(record),
+            { Nullable: true, Transfer: GirModel.Transfer.None } => signatureName + "?.Handle ?? " + Model.OpaqueRecord.GetFullyQuallifiedNullBoxedHandle(record),
             { Nullable: false, Transfer: GirModel.Transfer.None} => signatureName + ".Handle",
-            { Nullable: true, Transfer: GirModel.Transfer.Full } => signatureName + "?.Handle.Copy() ?? " + Model.OpaqueRecord.GetNullBoxedHandle(record),
+            { Nullable: true, Transfer: GirModel.Transfer.Full } => signatureName + "?.Handle.Copy() ?? " + Model.OpaqueRecord.GetFullyQuallifiedNullBoxedHandle(record),
             { Nullable: false, Transfer: GirModel.Transfer.Full } => signatureName + ".Handle.Copy()",
             _ => throw new Exception($"Can't detect call name for parameter opaque parameter {parameter.Parameter.Name}")
         };

src/Generation/Generator/Renderer/Public/ReturnType/ReturnTypeRendererCallback.cs

@@ -10,6 +10,7 @@ internal static class ReturnTypeRendererCallback
         new ReturnType.Class(),
         new ReturnType.Enumeration(),
         new ReturnType.Interface(),
+        new ReturnType.OpaqueRecord(),
         new ReturnType.Pointer(),
         new ReturnType.PointerAlias(),
         new ReturnType.PrimitiveValueType(),

src/Libs/GLib-2.0/Internal/BoxedHandle.cs

@@ -45,12 +45,14 @@ public class InitiallyUnownedBoxedHandle<T> : BoxedHandle<T> where T : NativeGTy
 {
     public InitiallyUnownedBoxedHandle(IntPtr handle) : base(handle, false)
     {
+        throw new Exception("TEST IF CALLED");
     }
 }
 
 public class OwnedBoxedHandle<T> : BoxedHandle<T> where T : NativeGTypeProvider
 {
     public OwnedBoxedHandle(IntPtr handle) : base(handle, true)
     {
+        throw new Exception("TEST IF CALLED");
     }
 }

src/Libs/GLib-2.0/Internal/Functions.cs

@@ -9,9 +9,9 @@ namespace GLib.Internal;
 
 public partial class Functions
 {
-    [DllImport(ImportResolver.Library, EntryPoint = "g_boxed_copy")]
+    [DllImport(GObject.Internal.ImportResolver.Library, EntryPoint = "g_boxed_copy")]
     public static extern IntPtr BoxedCopy(nuint boxedType, IntPtr srcBoxed);
 
-    [DllImport(ImportResolver.Library, EntryPoint = "g_boxed_free")]
+    [DllImport(GObject.Internal.ImportResolver.Library, EntryPoint = "g_boxed_free")]
     public static extern void BoxedFree(nuint boxedType, IntPtr boxed);
 }

src/Libs/GLib-2.0/Public/Variant.cs

@@ -1,5 +1,4 @@
 using System;
-using GLib.Internal;
 
 namespace GLib;
 
@@ -42,7 +41,7 @@ public static Variant CreateEmptyDictionary(VariantType key, VariantType value)
         return new Variant(Internal.Variant.NewArray(childType, new IntPtr[0], 0));
     }
 
-    private void Init(out BoxedHandle<GLib.Internal.Variant> handle, params Variant[] children)
+    private void Init(out GLib.Internal.VariantHandle handle, params Variant[] children)
     {
         _children = children;
 

src/Libs/GLib-2.0/Public/VariantType.cs

@@ -5,30 +5,12 @@ namespace GLib;
 
 public partial class VariantType : IDisposable
 {
-    #region Static Member
-
-    public static readonly VariantType String = new VariantType("s");
-    public static readonly VariantType Variant = new VariantType("v");
-
-    #endregion
-
-    #region Constructors
-
-    public VariantType(string type) : this(Internal.VariantType.New(Internal.NonNullableUtf8StringOwnedHandle.Create(type))) { }
-
-    #endregion
-
-    #region Methods
+    public static readonly VariantType String = New("s");
+    public static readonly VariantType Variant = New("v");
 
     public override string ToString()
         => Internal.VariantType.PeekString(Handle).ConvertToString();
 
-    #endregion
-
-    #region IDisposable Implementation
-
     public void Dispose()
         => Handle.Dispose();
-
-    #endregion
 }