Event passing wip

src/PixiEditor.Extensions.CommonApi/LayoutBuilding/Events/ElementEventArgs.cs

@@ -0,0 +1,11 @@
+namespace PixiEditor.Extensions.CommonApi.LayoutBuilding.Events;
+
+public class ElementEventArgs
+{
+    public static ElementEventArgs Empty { get; } = new ElementEventArgs();
+}
+
+public class ElementEventArgs<TEventArgs> : ElementEventArgs where TEventArgs : ElementEventArgs
+{
+    public static new ElementEventArgs<TEventArgs> Empty { get; } = new ElementEventArgs<TEventArgs>();
+}

src/PixiEditor.Extensions.CommonApi/LayoutBuilding/Events/ElementEventHandler.cs

@@ -0,0 +1,4 @@
+namespace PixiEditor.Extensions.CommonApi.LayoutBuilding.Events;
+
+public delegate void ElementEventHandler(ElementEventArgs args);
+public delegate void ElementEventHandler<in TEventArgs>(TEventArgs args) where TEventArgs : ElementEventArgs<TEventArgs>;

src/PixiEditor.Extensions.CommonApi/LayoutBuilding/ILayoutElement.cs

@@ -1,6 +1,11 @@
-namespace PixiEditor.Extensions.CommonApi.LayoutBuilding;
+using PixiEditor.Extensions.CommonApi.LayoutBuilding.Events;
+
+namespace PixiEditor.Extensions.CommonApi.LayoutBuilding;
 
 public interface ILayoutElement<out TBuildResult>
 {
     public TBuildResult Build();
+    public void AddEvent(string eventName, ElementEventHandler eventHandler);
+    public void RemoveEvent(string eventName, ElementEventHandler eventHandler);
+    public void RaiseEvent(string eventName, ElementEventArgs args);
 }

src/PixiEditor.Extensions.CommonApi/LayoutBuilding/LayoutElementIdGenerator.cs

@@ -0,0 +1,12 @@
+namespace PixiEditor.Extensions.CommonApi.LayoutBuilding;
+
+public static class LayoutElementIdGenerator
+{
+    private static int _lastId = -1;
+
+    public static int GetNextId()
+    {
+        _lastId++;
+        return _lastId;
+    }
+}

src/PixiEditor.Extensions.Tests/LayoutBuilderTests.cs

@@ -1,6 +1,9 @@
 using Avalonia.Controls;
+using Avalonia.Interactivity;
+using PixiEditor.Extensions.CommonApi.LayoutBuilding.Events;
 using PixiEditor.Extensions.LayoutBuilding;
 using PixiEditor.Extensions.LayoutBuilding.Elements;
+using Button = PixiEditor.Extensions.LayoutBuilding.Elements.Button;
 
 namespace PixiEditor.Extensions.Test;
 
@@ -32,4 +35,29 @@ public class LayoutBuilderTests
 
         Assert.Equal("Hello", textBlock.Text);
     }
+
+    [Fact]
+    public void TestThatButtonClickEventFiresCallback()
+    {
+        Button button = new Button();
+        bool callbackFired = false;
+
+        button.Click += (e) => callbackFired = true;
+        button.RaiseEvent(nameof(Button.Click), ElementEventArgs.Empty);
+
+        Assert.True(callbackFired);
+    }
+
+    [Fact]
+    public void TestThatAvaloniaClickEventFiresElementCallback()
+    {
+        Button button = new Button();
+        bool callbackFired = false;
+
+        button.Click += (e) => callbackFired = true;
+
+        button.Build().RaiseEvent(new RoutedEventArgs(Avalonia.Controls.Button.ClickEvent));
+
+        Assert.True(callbackFired);
+    }
 }

src/PixiEditor.Extensions.Wasm/Api/LayoutBuilding/Button.cs

@@ -1,26 +1,29 @@
 using PixiEditor.Extensions.CommonApi.LayoutBuilding;
+using PixiEditor.Extensions.CommonApi.LayoutBuilding.Events;
 
 namespace PixiEditor.Extensions.Wasm.Api.LayoutBuilding;
 
-public class Button : ISingleChildLayoutElement<NativeControl>
+public class Button : SingleChildLayoutElement
 {
-    ILayoutElement<NativeControl> ISingleChildLayoutElement<NativeControl>.Child
+    public event ElementEventHandler Click
     {
-        get => Content;
-        set => Content = value;
+        add => AddEvent(nameof(Click), value);
+        remove => RemoveEvent(nameof(Click), value);
     }
 
-    public ILayoutElement<NativeControl> Content { get; set; }
-
-    public Button(ILayoutElement<NativeControl> child = null)
+    public Button(ILayoutElement<NativeControl> child = null, ElementEventHandler onClick = null)
     {
-        Content = child;
+        Child = child;
+        if (onClick != null)
+            Click += onClick;
     }
 
-    public NativeControl Build()
+    public override NativeControl Build()
     {
         NativeControl button = new NativeControl("Button");
-        button.AddChild(Content.Build());
+        if (Child != null)
+            button.AddChild(Child.Build());
+
         return button;
     }
 }

src/PixiEditor.Extensions.Wasm/Api/LayoutBuilding/Center.cs

@@ -2,19 +2,19 @@
 
 namespace PixiEditor.Extensions.Wasm.Api.LayoutBuilding;
 
-public class Center : ISingleChildLayoutElement<NativeControl>
+public class Center : SingleChildLayoutElement
 {
-    public ILayoutElement<NativeControl> Child { get; set; }
-
     public Center(ILayoutElement<NativeControl> child)
     {
         Child = child;
     }
 
-    NativeControl ILayoutElement<NativeControl>.Build()
+    public override NativeControl Build()
     {
         NativeControl center = new NativeControl("Center");
-        center.AddChild(Child.Build());
+
+        if (Child != null)
+            center.AddChild(Child.Build());
         return center;
     }
 }

src/PixiEditor.Extensions.Wasm/Api/LayoutBuilding/Layout.cs

@@ -2,19 +2,19 @@
 
 namespace PixiEditor.Extensions.Wasm.Api.LayoutBuilding;
 
-public sealed class Layout : ISingleChildLayoutElement<NativeControl>
+public sealed class Layout : SingleChildLayoutElement
 {
-    public ILayoutElement<NativeControl> Child { get; set; }
-
     public Layout(ILayoutElement<NativeControl> body = null)
     {
         Child = body;
     }
 
-    public NativeControl Build()
+    public override NativeControl Build()
     {
         NativeControl layout = new NativeControl("Layout");
-        layout.AddChild(Child.Build());
+
+        if (Child != null)
+            layout.AddChild(Child.Build());
         return layout;
     }
 

src/PixiEditor.Extensions.Wasm/Api/LayoutBuilding/LayoutElement.cs

@@ -0,0 +1,72 @@
+using PixiEditor.Extensions.CommonApi.LayoutBuilding;
+using PixiEditor.Extensions.CommonApi.LayoutBuilding.Events;
+
+namespace PixiEditor.Extensions.Wasm.Api.LayoutBuilding;
+
+public abstract class LayoutElement : ILayoutElement<NativeControl>
+{
+    private Dictionary<string, List<ElementEventHandler>> _events;
+
+    private int InternalControlId { get; set; }
+
+    public abstract NativeControl Build();
+
+    public LayoutElement()
+    {
+        InternalControlId = LayoutElementIdGenerator.GetNextId();
+        LayoutElementsStore.AddElement(InternalControlId, this);
+    }
+
+    ~LayoutElement()
+    {
+        LayoutElementsStore.RemoveElement(InternalControlId);
+    }
+
+    public void AddEvent(string eventName, ElementEventHandler eventHandler)
+    {
+        if (_events == null)
+        {
+            _events = new Dictionary<string, List<ElementEventHandler>>();
+        }
+
+        if (!_events.ContainsKey(eventName))
+        {
+            _events.Add(eventName, new List<ElementEventHandler>());
+        }
+
+        _events[eventName].Add(eventHandler);
+    }
+
+    public void RemoveEvent(string eventName, ElementEventHandler eventHandler)
+    {
+        if (_events == null)
+        {
+            return;
+        }
+
+        if (!_events.ContainsKey(eventName))
+        {
+            return;
+        }
+
+        _events[eventName].Remove(eventHandler);
+    }
+
+    public void RaiseEvent(string eventName, ElementEventArgs args)
+    {
+        if (_events == null)
+        {
+            return;
+        }
+
+        if (!_events.ContainsKey(eventName))
+        {
+            return;
+        }
+
+        foreach (ElementEventHandler eventHandler in _events[eventName])
+        {
+            eventHandler.Invoke(args);
+        }
+    }
+}

src/PixiEditor.Extensions.Wasm/Api/LayoutBuilding/LayoutElementsStore.cs

@@ -0,0 +1,18 @@
+using PixiEditor.Extensions.CommonApi.LayoutBuilding;
+
+namespace PixiEditor.Extensions.Wasm.Api.LayoutBuilding;
+
+internal static class LayoutElementsStore
+{
+    public static Dictionary<int, ILayoutElement<NativeControl>> LayoutElements { get; } = new();
+
+    public static void AddElement(int internalId, ILayoutElement<NativeControl> element)
+    {
+        LayoutElements.Add(internalId, element);
+    }
+
+    public static void RemoveElement(int internalId)
+    {
+        LayoutElements.Remove(internalId);
+    }
+}

src/PixiEditor.Extensions.Wasm/Api/LayoutBuilding/SingleChildLayoutElement.cs

@@ -0,0 +1,9 @@
+using PixiEditor.Extensions.CommonApi.LayoutBuilding;
+
+namespace PixiEditor.Extensions.Wasm.Api.LayoutBuilding;
+
+public abstract class SingleChildLayoutElement : LayoutElement, ISingleChildLayoutElement<NativeControl>
+{
+    public ILayoutElement<NativeControl> Child { get; set; }
+    public abstract override NativeControl Build();
+}

src/PixiEditor.Extensions.Wasm/Api/LayoutBuilding/Text.cs

@@ -2,16 +2,14 @@
 
 namespace PixiEditor.Extensions.Wasm.Api.LayoutBuilding;
 
-public class Text : ITextElement<NativeControl>
+public class Text : TextElement
 {
-    public string Value { get; set; }
-
     public Text(string value)
     {
         Value = value;
     }
 
-    NativeControl ILayoutElement<NativeControl>.Build()
+    public override NativeControl Build()
     {
         NativeControl text = new NativeControl("Text");
         text.AddProperty(Value);

src/PixiEditor.Extensions.Wasm/Api/LayoutBuilding/TextElement.cs

@@ -0,0 +1,10 @@
+using PixiEditor.Extensions.CommonApi.LayoutBuilding;
+
+namespace PixiEditor.Extensions.Wasm.Api.LayoutBuilding;
+
+public abstract class TextElement(string value = "") : LayoutElement, ITextElement<NativeControl>
+{
+    public string Value { get; set; } = value;
+
+    public abstract override NativeControl Build();
+}

src/PixiEditor.Extensions.Wasm/Interop.cs

@@ -2,6 +2,9 @@
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using PixiEditor.Extensions.CommonApi.LayoutBuilding;
+using PixiEditor.Extensions.CommonApi.LayoutBuilding.Events;
+using PixiEditor.Extensions.Wasm.Api.LayoutBuilding;
 
 namespace PixiEditor.Extensions.Wasm;
 
@@ -31,4 +34,13 @@ internal class Interop
     {
         ExtensionContext.Active.OnInitialized();
     }
+
+    internal static void EventRaised(int internalControlId, string eventName) //TOOD: Args
+    {
+        WasmExtension.Api.Logger.Log($"Event raised: {eventName} on {internalControlId}");
+        if (LayoutElementsStore.LayoutElements.TryGetValue(internalControlId, out ILayoutElement<NativeControl> element))
+        {
+            element.RaiseEvent(eventName, new ElementEventArgs());
+        }
+    }
 }

src/PixiEditor.Extensions.Wasm/PixiEditor.Extensions.Wasm.csproj

@@ -11,6 +11,10 @@
       <ProjectReference Include="..\PixiEditor.Extensions.CommonApi\PixiEditor.Extensions.CommonApi.csproj" />
     </ItemGroup>
 
+    <ItemGroup>
+      <ClCompile Include="native\layout_builder_api.c" />
+    </ItemGroup>
+
   <Import Project="build\PixiEditor.Extensions.Wasm.targets"/>
   <Import Project="build\PixiEditor.Extensions.Wasm.props"/>
 

src/PixiEditor.Extensions.Wasm/native/api.h

@@ -1,3 +1,6 @@
 void attach_logger_calls();
 void attach_window_calls();
+void attach_layout_builder_calls();
 void logger_log_message(MonoString* message);
+MonoMethod* lookup_interop_method(const char* method_name);
+void invoke_interop_method(MonoMethod* method, void* params);

src/PixiEditor.Extensions.Wasm/native/api_interop.c

@@ -12,11 +12,10 @@ MonoMethod* lookup_interop_method(const char* method_name)
     return method;
 }
 
-void invoke_interop_method(MonoMethod* method)
+void invoke_interop_method(MonoMethod* method, void* params)
 {
-    void* method_params[] = {  };
     MonoObject* exception;
-    mono_wasm_invoke_method(method, NULL, method_params, &exception);
+    mono_wasm_invoke_method(method, NULL, params, &exception);
     assert(!exception);
 }
 
@@ -24,14 +23,14 @@ __attribute((export_name("load")))
 void load()
 {
     MonoMethod* metod = lookup_interop_method("Load");
-    invoke_interop_method(metod);
+    invoke_interop_method(metod, NULL);
 }
 
 __attribute((export_name("initialize")))
 void initialize()
 {
     MonoMethod* metod = lookup_interop_method("Initialize");
-    invoke_interop_method(metod);
+    invoke_interop_method(metod, NULL);
 }
 
 void attach_internal_calls()

src/PixiEditor.Extensions.Wasm/native/layout_builder_api.c

@@ -0,0 +1,19 @@
+#include <mono-wasi/driver.h>
+#include <string.h>
+#include <assert.h>
+
+#include "api.h"
+
+__attribute((export_name("raise_element_event")))
+void raise_element_event(int32_t elementId, char* eventName)
+{
+    MonoMethod* method = lookup_interop_method("EventRaised");
+    MonoString* eventNameString = mono_wasm_string_from_js (eventName);
+    void* args[] = { elementId, eventNameString };
+    invoke_interop_method(method, args);
+}
+
+void attach_layout_builder_calls()
+{
+
+}

src/PixiEditor.Extensions.WasmRuntime/MemoryUtility.cs

@@ -7,8 +7,8 @@ public static class MemoryUtility
 {
     public static string GetStringFromWasmMemory(int offset, int length, Memory memory)
     {
+        //TODO: memory.ReadString is a thing
         var span = memory.GetSpan<byte>(offset, length);
-        
         return Encoding.UTF8.GetString(span);
     }
 
@@ -17,4 +17,25 @@ public static class MemoryUtility
         var span = memory.GetSpan<T>(bodyOffset, bodyLength);
         return span;
     }
+
+    public static int WriteInt32(Instance instance, Memory memory, int value)
+    {
+        // TODO: cache malloc function
+        var malloc = instance.GetFunction<int, int>("malloc");
+
+        const int length = 4;
+        var ptr = malloc.Invoke(length);
+        memory.WriteInt32(ptr, value);
+        return ptr;
+    }
+
+    public static int WriteString(Instance instance, Memory memory, string value)
+    {
+        var malloc = instance.GetFunction<int, int>("malloc");
+
+        var length = value.Length;
+        var ptr = malloc.Invoke(length);
+        memory.WriteString(ptr, value, Encoding.UTF8);
+        return ptr;
+    }
 }

src/PixiEditor.Extensions.WasmRuntime/WasmExtensionInstance.cs

@@ -10,6 +10,8 @@ public class WasmExtensionInstance : Extension
     private Store Store { get; }
     private Module Module { get; }
 
+    private Memory memory = null!;
+
     public WasmExtensionInstance(Linker linker, Store store, Module module)
     {
         Linker = linker;
@@ -24,11 +26,18 @@ public class WasmExtensionInstance : Extension
 
         Instance = Linker.Instantiate(Store, Module);
         Instance.GetFunction("_start").Invoke();
+        memory = Instance.GetMemory("memory");
     }
 
     protected override void OnInitialized()
     {
         Instance.GetAction("initialize").Invoke();
+        int testId = 69;
+        int ptr = MemoryUtility.WriteInt32(Instance, memory, testId);
+        int pt2 = MemoryUtility.WriteString(Instance, memory, "Test event");
+
+        Instance.GetAction<int, int>("raise_element_event").Invoke(ptr, pt2);
+
         base.OnInitialized();
     }
 

src/PixiEditor.Extensions/LayoutBuilding/Elements/Button.cs

@@ -1,30 +1,32 @@
 using Avalonia.Controls;
+using Avalonia.Interactivity;
 using PixiEditor.Extensions.CommonApi.LayoutBuilding;
+using PixiEditor.Extensions.CommonApi.LayoutBuilding.Events;
 
 namespace PixiEditor.Extensions.LayoutBuilding.Elements;
 
-public class Button : ISingleChildLayoutElement<Control>
+public class Button : SingleChildLayoutElement
 {
-    ILayoutElement<Control> ISingleChildLayoutElement<Control>.Child
+    public event ElementEventHandler Click
     {
-        get => Content;
-        set => Content = value;
+        add => AddEvent(nameof(Click), value);
+        remove => RemoveEvent(nameof(Click), value);
     }
 
-    public ILayoutElement<Control> Content { get; set; }
-
-    public Button(ILayoutElement<Control> content = null)
+    public Button(ILayoutElement<Control>? child = null)
     {
-        Content = content;
+        Child = child;
     }
 
-    public Control Build()
+    public override Control Build()
     {
-        return new Avalonia.Controls.Button() { Content = Content.Build() };
-    }
+        Avalonia.Controls.Button btn = new Avalonia.Controls.Button()
+        {
+            Content = Child?.Build(),
+        };
 
-    public void DeserializeProperties(List<object> values)
-    {
+        btn.Click += (sender, args) => RaiseEvent(nameof(Click), new ElementEventArgs());
 
+        return btn;
     }
 }

src/PixiEditor.Extensions/LayoutBuilding/Elements/Center.cs

@@ -3,16 +3,14 @@ using PixiEditor.Extensions.CommonApi.LayoutBuilding;
 
 namespace PixiEditor.Extensions.LayoutBuilding.Elements;
 
-public class Center : ISingleChildLayoutElement<Control>, IPropertyDeserializable
+public class Center : SingleChildLayoutElement, IPropertyDeserializable
 {
-    public ILayoutElement<Control> Child { get; set; }
-
     public Center(ILayoutElement<Control> child = null)
     {
         Child = child;
     }
 
-    Control ILayoutElement<Control>.Build()
+    public override Control Build()
     {
         return new Panel()
         {

src/PixiEditor.Extensions/LayoutBuilding/Elements/Layout.cs

@@ -3,18 +3,22 @@ using PixiEditor.Extensions.CommonApi.LayoutBuilding;
 
 namespace PixiEditor.Extensions.LayoutBuilding.Elements;
 
-public sealed class Layout : ISingleChildLayoutElement<Control>, IPropertyDeserializable
+public sealed class Layout : SingleChildLayoutElement, IPropertyDeserializable
 {
-    public ILayoutElement<Control> Child { get; set; }
-
     public Layout(ILayoutElement<Control> body = null)
     {
         Child = body;
     }
 
-    public Control Build()
+    public override Control Build()
     {
-        return new Panel { Children = { Child.Build() } };
+        Panel panel = new Panel();
+        if (Child != null)
+        {
+            panel.Children.Add(Child.Build());
+        }
+
+        return panel;
     }
 
     void IPropertyDeserializable.DeserializeProperties(List<object> values)

src/PixiEditor.Extensions/LayoutBuilding/Elements/LayoutElement.cs

@@ -0,0 +1,59 @@
+using Avalonia.Controls;
+using PixiEditor.Extensions.CommonApi.LayoutBuilding;
+using PixiEditor.Extensions.CommonApi.LayoutBuilding.Events;
+
+namespace PixiEditor.Extensions.LayoutBuilding.Elements;
+
+public abstract class LayoutElement : ILayoutElement<Control>
+{
+    private Dictionary<string, List<ElementEventHandler>>? _events;
+    public abstract Control Build();
+
+    public void AddEvent(string eventName, ElementEventHandler eventHandler)
+    {
+        if (_events == null)
+        {
+            _events = new Dictionary<string, List<ElementEventHandler>>();
+        }
+
+        if (!_events.ContainsKey(eventName))
+        {
+            _events.Add(eventName, new List<ElementEventHandler>());
+        }
+
+        _events[eventName].Add(eventHandler);
+    }
+
+    public void RemoveEvent(string eventName, ElementEventHandler eventHandler)
+    {
+        if (_events == null)
+        {
+            return;
+        }
+
+        if (!_events.ContainsKey(eventName))
+        {
+            return;
+        }
+
+        _events[eventName].Remove(eventHandler);
+    }
+
+    public void RaiseEvent(string eventName, ElementEventArgs args)
+    {
+        if (_events == null)
+        {
+            return;
+        }
+
+        if (!_events.ContainsKey(eventName))
+        {
+            return;
+        }
+
+        foreach (ElementEventHandler eventHandler in _events[eventName])
+        {
+            eventHandler.Invoke(args);
+        }
+    }
+}

src/PixiEditor.Extensions/LayoutBuilding/Elements/SingleChildLayoutElement.cs

@@ -0,0 +1,10 @@
+using Avalonia.Controls;
+using PixiEditor.Extensions.CommonApi.LayoutBuilding;
+
+namespace PixiEditor.Extensions.LayoutBuilding.Elements;
+
+public abstract class SingleChildLayoutElement : LayoutElement, ISingleChildLayoutElement<Control>
+{
+    public ILayoutElement<Control>? Child { get; set; }
+    public abstract override Control Build();
+}

src/PixiEditor.Extensions/LayoutBuilding/Elements/Text.cs

@@ -3,16 +3,14 @@ using PixiEditor.Extensions.CommonApi.LayoutBuilding;
 
 namespace PixiEditor.Extensions.LayoutBuilding.Elements;
 
-public class Text : ITextElement<Control>, IPropertyDeserializable
+public class Text : TextElement, IPropertyDeserializable
 {
-    public string Value { get; set; }
-
     public Text(string value = "")
     {
         Value = value;
     }
 
-    Control ILayoutElement<Control>.Build()
+    public override Control Build()
     {
         return new TextBlock { Text = Value };
     }

src/PixiEditor.Extensions/LayoutBuilding/Elements/TextElement.cs

@@ -0,0 +1,10 @@
+using Avalonia.Controls;
+using PixiEditor.Extensions.CommonApi.LayoutBuilding;
+
+namespace PixiEditor.Extensions.LayoutBuilding.Elements;
+
+public abstract class TextElement(string value = "") : LayoutElement, ITextElement<Control>
+{
+    public string Value { get; set; } = value;
+    public abstract override Control Build();
+}

src/WasmSampleExtension/SampleExtension.cs

@@ -16,7 +16,12 @@ public class SampleExtension : WasmExtension
 
         Layout layout = new Layout(
             new Center(
-                child: new Button(new Text("hello sexy."))));
+                child: new Button(
+                    child: new Text("hello sexy."),
+                    onClick: _ => Api.Logger.Log("button clicked!")
+                    )
+                )
+            );
 
         Api.WindowProvider.CreatePopupWindow("WASM SampleExtension", layout.Build());
     }