Spike/virtual methods

Generator/Gir/GClass.cs

@@ -20,6 +20,9 @@ public class GClass : GInterface
         [XmlElement ("field")]
         public List<GField> Fields { get; set; } = default!;
 
+        [XmlElement("virtual-method")] 
+        public List<GVirtualMethod> VirtualMethods { get; set; } = default!;
+
         [XmlAttribute("parent")]
         public string? Parent { get; set; }
 

Generator/Gir/GVirtualMethod.cs

@@ -0,0 +1,16 @@
+using System.Xml.Serialization;
+
+namespace Gir
+{
+    public class GVirtualMethod : GMethod
+    {
+        #region Properties
+
+        [XmlAttribute("invoker")]
+        public string? Invoker { get; set; }
+
+        public bool HasInvoker => Invoker is not null;
+
+        #endregion
+    }
+}

Generator/Resolver/TypeResolver.cs

@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using Gir;
 
 namespace Generator
@@ -29,8 +31,6 @@ public ResolvedType(string type, Direction dir = Direction.Value, string attribu
 
         public override string ToString() => GetTypeString();
 
-        // public string GetTypeString() => Attribute + (IsRef ? "ref " : string.Empty) + Type;
-
         public string GetTypeString() => Attribute + Direction switch
         {
             Direction.Value => Type,
@@ -42,7 +42,6 @@ public ResolvedType(string type, Direction dir = Direction.Value, string attribu
         };
 
         public string GetFieldString() => Direction == Direction.Value ? Type : "IntPtr";
-
         #endregion
 
         #region IEquatable<ResolvedType> Implementation
@@ -125,7 +124,7 @@ public TypeResolver(AliasResolver resolver)
 
         public ResolvedType Resolve(IType typeInfo) => typeInfo switch
         {
-            GField f when f.Callback is { } => new ResolvedType("IntPtr"),
+            GField f when f.Callback is { } c => ResolveCallback(c),
             { Array: { CType: { } n } } when n.EndsWith("**") => new ResolvedType("IntPtr", Direction.InOut),
             { Type: { } gtype } => GetTypeName(ConvertGType(gtype, typeInfo is GParameter, typeInfo)),
             { Array: { Length: { } length, Type: { CType: { } } gtype } } => GetTypeName(ResolveArrayType(gtype, typeInfo is GParameter, length)),
@@ -134,6 +133,17 @@ public TypeResolver(AliasResolver resolver)
             { Array: { } } => new ResolvedType("IntPtr"),
             _ => throw new NotSupportedException("Type is missing supported Type information")
         };
+
+        private ResolvedType ResolveCallback(GCallback callback)
+        {
+            ResolvedType returntype = Resolve(callback.ReturnValue ?? throw new Exception("Missing return for callback"));
+
+            List<ResolvedType> parameters = callback.Parameters?.AllParameters.Select(Resolve).ToList() ?? new ();
+            parameters.Add(returntype);
+
+            var parametersString = string.Join(", ", parameters.Select(x => x.GetFieldString()));
+            return new ResolvedType($"unsafe delegate* unmanaged<{parametersString}>");
+        }
 
         private MyType StringArray(string length, bool isParameter) => new MyType("byte")
         {

Generator/Templates/Shared/struct.sbntxt

@@ -9,7 +9,7 @@ namespace {{ namespace }}
 
     {{ include 'header.sbntxt' this ~}}
     [StructLayout(LayoutKind.Sequential)]
-    public partial struct {{ name }}
+    public unsafe partial struct {{ name }}
     {
         #region Fields
         {{~ for field in fields }}

Libs/Directory.Build.props

@@ -11,6 +11,7 @@
     <RepositoryUrl>https://github.com/GirCore/gir.core</RepositoryUrl>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
     <SymbolPackageFormat>snupkg</SymbolPackageFormat>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
 
   <PropertyGroup Condition="$(GirComments) == 'True'">

Libs/GObject/Classes/Global.cs

@@ -0,0 +1,8 @@
+namespace GObject
+{
+    public static partial class Global
+    {
+        public static Type GetParentType(Type t)
+            => new Type(Native.type_parent(t.Value));
+    }
+}

Libs/GObject/Classes/Object.cs

@@ -106,7 +106,7 @@ public Object(params ConstructParameter[] properties)
         }
 
         /// <summary>
-        /// Initializes a wrapper for an existing object
+        /// Initializes a wrapper for an existing objectTypedes
         /// </summary>
         /// <param name="handle"></param>
         protected Object(IntPtr handle)

Libs/Gtk3/Classes/Button.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Runtime.InteropServices;
 using GLib;
 using GObject;
 
@@ -128,5 +129,7 @@ public bool UseActionAppearance
         }
 
         #endregion
+
+
     }
 }

Samples/Gtk3/QuickStart/Program.cs

@@ -1,4 +1,7 @@
-using Gtk;
+using System;
+using System.Runtime.InteropServices;
+using GObject;
+using Gtk;
 using Global = Gtk.Global;
 
 namespace GtkDemo
@@ -46,7 +49,7 @@ public static void Main(string[] args)
 
                     // Add some widgets to the notebook
                     ["Page1"] = new Label("Hello C#"),
-                    ["Page2"] = new Button("Open")
+                    ["Page2"] = new MyButton("Open")
                     {
                         // Register a callback for the button
                         [Button.ClickedSignal] = OnOpenButtonClick,
@@ -131,4 +134,48 @@ public static void OnCloseButtonClick(Button sender, System.EventArgs args)
 
         #endregion
     }
+
+    public class MyButton : Button
+    {
+        private unsafe static ButtonClass* buttonClass;
+
+        private static unsafe void ClassInit(GObject.Type gClass, System.Type type, IntPtr classData)
+        {
+            var myButtonClass = (ButtonClass*) TypeHelper.GetClassPointer(gClass);
+            myButtonClass->pressed = &StaticPressed;
+
+            var buttonType = GObject.Global.GetParentType(gClass);
+            buttonClass = (ButtonClass*) TypeHelper.GetClassPointer(buttonType);
+        }
+
+        public MyButton(string label) : base(label)
+        {
+
+        }
+
+        [UnmanagedCallersOnly]
+        private static void StaticPressed(nint instance)
+        {
+            if (TryWrapHandle<MyButton>(instance, out var obj))
+            {
+                obj.Pressed();
+            }
+        }
+
+        private void BasePressed()
+        {
+            unsafe
+            {
+                buttonClass->pressed(Handle);   
+            }
+        }
+
+        //This could be a potential attribute to trigger code generation for virtual methods
+        //[Overrides(VirtualMethod.Pressed)]
+        public void Pressed()
+        {
+            BasePressed();
+            Console.WriteLine("TestTest");
+        }
+    }
 }

Samples/Gtk3/QuickStart/QuickStart.csproj

@@ -5,6 +5,7 @@
   </ItemGroup>
 
   <PropertyGroup>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <OutputType>Exe</OutputType>
     <TargetFramework>net5.0</TargetFramework>
     <Nullable>enable</Nullable>