Merge pull request #86 from bj-rn/feat/routed-events

BREAKING: Feat/routed events

Author: antokhio

Directory.Build.props

@@ -0,0 +1,7 @@
+<Project>
+  <PropertyGroup>
+    <VLVersion>2025.7.1-0116-gaeae322323</VLVersion>
+    <AvaloniaVersion>11.2.1</AvaloniaVersion>
+    <StrideVersion>4.2.0.2293</StrideVersion>
+  </PropertyGroup>
+</Project>

README.md

@@ -31,7 +31,14 @@ nuget install VL.Avalonia.Stride
 nuget install VL.Avalonia.Custom
 ```
 
-Works with `vvvv_gamma >= 7.0`
+## Compatibility
+
+| Version | vvvv gamma Version |
+| :--- | :--- |
+| `v0.4.X` | >= `7.1-0116` |
+| `v0.3.1` - `v0.3.16` | `7.0` |
+| `v0.3.0`| `7.0-xxxx`, `6.9` |
+
 
 ## How-to
 

VL.Avalonia.CodeGen/AvaloniaReflectionGenerator.cs

@@ -0,0 +1,34 @@
+using System;
+using Microsoft.CodeAnalysis;
+using VL.Avalonia.CodeGen.Forwards;
+
+namespace VL.Avalonia.CodeGen
+{
+    [Generator]
+    public class AvaloniaReflectionGenerator : IIncrementalGenerator
+    {
+        const string RESTRICTED_ASSEMBLY_NAME = "VL.Avalonia";
+
+        public void Initialize(IncrementalGeneratorInitializationContext context)
+        {
+            var compilationProvider = context.CompilationProvider;
+
+            context.RegisterSourceOutput(
+                compilationProvider,
+                (spc, compilation) =>
+                {
+                    // We want to generate only for VL.Avalonia assembly
+                    if (compilation.AssemblyName != RESTRICTED_ASSEMBLY_NAME)
+                        return;
+
+                    try
+                    {
+                        RoutedEventArgsGenerator.Generate(spc, compilation);
+                        RoutedEventGenerator.Generate(spc, compilation);
+                    }
+                    catch (Exception ex) { }
+                }
+            );
+        }
+    }
+}

VL.Avalonia.CodeGen/Forwards/RoutedEventArgsGenerator.cs

@@ -0,0 +1,105 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Text;
+
+namespace VL.Avalonia.CodeGen.Forwards
+{
+    public static class RoutedEventArgsGenerator
+    {
+        const string TARGET_FILENAME = "RoutedEventArgsForwards.g.cs";
+        const string TARGET_TYPE_NAME = "Avalonia.Interactivity.RoutedEventArgs";
+
+        public static void Generate(SourceProductionContext spc, Compilation compilation)
+        {
+            var routedEventArgsType = compilation.GetTypeByMetadataName(TARGET_TYPE_NAME);
+            if (routedEventArgsType == null)
+                return;
+
+            var foundTypes = new List<INamedTypeSymbol>();
+
+            foreach (var reference in compilation.SourceModule.ReferencedAssemblySymbols)
+            {
+                if (!reference.Name.StartsWith("Avalonia"))
+                    continue;
+
+                // Helper function to visit all types in the assembly
+                VisitNamespace(reference.GlobalNamespace, routedEventArgsType, foundTypes);
+            }
+
+            if (foundTypes.Count == 0)
+            {
+                return;
+            }
+
+            foundTypes.Add(routedEventArgsType);
+
+            var namespaces = foundTypes
+                .Select(t => t.ContainingNamespace.ToDisplayString())
+                .Distinct()
+                .OrderBy(n => n);
+
+            var sb = new StringBuilder();
+
+            sb.AppendLine("using System;");
+            sb.AppendLine("using VL.Core.Import;");
+
+            foreach (var ns in namespaces)
+            {
+                sb.AppendLine($"using {ns};");
+            }
+            sb.AppendLine();
+
+            var typeFormat = SymbolDisplayFormat.MinimallyQualifiedFormat;
+
+            foreach (var type in foundTypes)
+            {
+                sb.AppendLine(
+                    // csharpier-ignore
+                    $@"[assembly: ImportType(typeof({type.ToDisplayString(typeFormat)}), Category = ""{type.ContainingNamespace.ToDisplayString()}"")]"
+                );
+            }
+
+            spc.AddSource(TARGET_FILENAME, SourceText.From(sb.ToString(), Encoding.UTF8));
+        }
+
+        private static void VisitNamespace(
+            INamespaceSymbol namespaceSymbol,
+            INamedTypeSymbol baseType,
+            List<INamedTypeSymbol> foundTypes
+        )
+        {
+            foreach (var member in namespaceSymbol.GetMembers())
+            {
+                if (member is INamespaceSymbol nestedNs)
+                {
+                    VisitNamespace(nestedNs, baseType, foundTypes);
+                }
+                else if (member is INamedTypeSymbol typeSymbol)
+                {
+                    if (
+                        typeSymbol.TypeKind == TypeKind.Class
+                        && !typeSymbol.IsAbstract
+                        && InheritsFrom(typeSymbol, baseType)
+                    )
+                    {
+                        foundTypes.Add(typeSymbol);
+                    }
+                }
+            }
+        }
+
+        private static bool InheritsFrom(INamedTypeSymbol type, INamedTypeSymbol baseType)
+        {
+            var current = type.BaseType;
+            while (current != null)
+            {
+                if (SymbolEqualityComparer.Default.Equals(current, baseType))
+                    return true;
+                current = current.BaseType;
+            }
+            return false;
+        }
+    }
+}