Passing PhotinoWindow Through Browser Environment

[js-ahh-selector]

I demonstrate how to interact with a PhotinoWindow from the browser environment by passing method calls dynamically. The following code examples showcase both the C# and JavaScript implementation.

Program.cs:

using PhotinoNET;
using System;
using System.Drawing;
using System.IO;
using System.Text.Json;
using System.Reflection;
using System.Linq;

namespace HelloPhotinoApp
{
    class Program
    {
        [STAThread]
        static void Main(string[] args)
        {
            var window = new PhotinoWindow()

                .RegisterWebMessageReceivedHandler((sender, message) =>
                {
                    var window = (PhotinoWindow)sender;

                    try
                    {
                        using var document = JsonDocument.Parse(message);
                        var root = document.RootElement;

                        // Ensure 'method' and 'args' are in the incoming JSON
                        if (!root.TryGetProperty("method", out var methodProperty) || 
                            methodProperty.ValueKind != JsonValueKind.String)
                        {
                            // Handle invalid format: missing 'method'
                        }

                        if (!root.TryGetProperty("args", out var argsProperty) || 
                            argsProperty.ValueKind != JsonValueKind.Array)
                        {
                            // Handle invalid format: missing 'args'
                        }

                        string methodName = methodProperty.GetString();
                        object[] argsArray = argsProperty.EnumerateArray()
                            .Select(arg =>
                            {
                                if (arg.ValueKind == JsonValueKind.String)
                                {
                                    return (object)arg.GetString();
                                }
                                else if (arg.ValueKind == JsonValueKind.Number)
                                {
                                    return (object)arg.GetInt32();
                                }
                                return null;
                            })
                            .ToArray();

                        // Dynamically find and invoke the method
                        MethodInfo methodInfo = methodName == "SetSize"
                            ? window.GetType().GetMethod("SetSize", new Type[] { typeof(int), typeof(int) })
                            : window.GetType().GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public);

                        if (methodInfo != null)
                        {
                            var parameters = methodInfo.GetParameters();
                            var convertedArgs = new object[parameters.Length];

                            for (int i = 0; i < parameters.Length; i++)
                            {
                                convertedArgs[i] = Convert.ChangeType(argsArray[i], parameters[i].ParameterType);
                            }

                            methodInfo.Invoke(window, convertedArgs);
                        }
                    }
                    catch (Exception ex)
                    {
                        // Handle any exceptions that occur
                    }
                })
                .Load("wwwroot/index.html");

            window.WaitForClose();
        }
    }
}

JavaScript Code:

<script>
    const photino = new Proxy({}, {
        get: (target, prop) => (...args) => {
            const message = JSON.stringify({ method: prop.charAt(0).toUpperCase() + prop.slice(1), args: args || [] });
            window.external.sendMessage(message);
        }
    });

    // Examples of usage:
    photino.setTitle("New Dynamic Title");
    photino.setSize(800, 600);
    photino.center();
</script>

---

Let me know if this helps or if you'd like more suggestions!