TEMP COMMIT

TODO: UpdateContextMenu()

v2/cmd/wails/internal/commands/debug/debug.go

@@ -0,0 +1,123 @@
+package debug
+
+import (
+	"fmt"
+	"github.com/wailsapp/wails/v2/internal/shell"
+	"io"
+	"os"
+	"runtime"
+	"strings"
+	"time"
+
+	"github.com/leaanthony/clir"
+	"github.com/leaanthony/slicer"
+	"github.com/wailsapp/wails/v2/pkg/clilogger"
+	"github.com/wailsapp/wails/v2/pkg/commands/build"
+)
+
+// AddSubcommand adds the `debug` command for the Wails application
+func AddSubcommand(app *clir.Cli, w io.Writer) error {
+
+	outputType := "desktop"
+
+	validTargetTypes := slicer.String([]string{"desktop", "hybrid", "server"})
+
+	command := app.NewSubCommand("debug", "Builds the application then runs delve on the binary")
+
+	// Setup target type flag
+	description := "Type of application to build. Valid types: " + validTargetTypes.Join(",")
+	command.StringFlag("t", description, &outputType)
+
+	compilerCommand := "go"
+	command.StringFlag("compiler", "Use a different go compiler to build, eg go1.15beta1", &compilerCommand)
+
+	quiet := false
+	command.BoolFlag("q", "Suppress output to console", &quiet)
+
+	// ldflags to pass to `go`
+	ldflags := ""
+	command.StringFlag("ldflags", "optional ldflags", &ldflags)
+
+	// Log to file
+	logFile := ""
+	command.StringFlag("l", "Log to file", &logFile)
+
+	command.Action(func() error {
+
+		// Create logger
+		logger := clilogger.New(w)
+		logger.Mute(quiet)
+
+		// Validate output type
+		if !validTargetTypes.Contains(outputType) {
+			return fmt.Errorf("output type '%s' is not valid", outputType)
+		}
+
+		if !quiet {
+			app.PrintBanner()
+		}
+
+		task := fmt.Sprintf("Building %s Application", strings.Title(outputType))
+		logger.Println(task)
+		logger.Println(strings.Repeat("-", len(task)))
+
+		// Setup mode
+		mode := build.Debug
+
+		// Create BuildOptions
+		buildOptions := &build.Options{
+			Logger:     logger,
+			OutputType: outputType,
+			Mode:       mode,
+			Pack:       false,
+			Platform:   runtime.GOOS,
+			LDFlags:    ldflags,
+			Compiler:   compilerCommand,
+			KeepAssets: false,
+		}
+
+		outputFilename, err := doDebugBuild(buildOptions)
+		if err != nil {
+			return err
+		}
+
+		// Check delve exists
+		delveExists := shell.CommandExists("dlv")
+		if !delveExists {
+			return fmt.Errorf("cannot launch delve (Is it installed?)")
+		}
+
+		// Get cwd
+		cwd, err := os.Getwd()
+		if err != nil {
+			return err
+		}
+
+		// Launch delve
+		println("Launching Delve on port 2345...")
+		command := shell.CreateCommand(cwd, "dlv", "--listen=:2345", "--headless=true", "--api-version=2", "--accept-multiclient", "exec", outputFilename)
+		return command.Run()
+	})
+
+	return nil
+}
+
+// doDebugBuild is our main build command
+func doDebugBuild(buildOptions *build.Options) (string, error) {
+
+	// Start Time
+	start := time.Now()
+
+	outputFilename, err := build.Build(buildOptions)
+	if err != nil {
+		return "", err
+	}
+
+	// Output stats
+	elapsed := time.Since(start)
+	buildOptions.Logger.Println("")
+	buildOptions.Logger.Println(fmt.Sprintf("Built '%s' in %s.", outputFilename, elapsed.Round(time.Millisecond).String()))
+	buildOptions.Logger.Println("")
+
+	return outputFilename, nil
+}

v2/cmd/wails/internal/commands/dev/dev.go

@@ -85,7 +85,10 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 				// If this is a folder, add it to our watch list
 				if fs.DirExists(event.Name) {
 					if !strings.Contains(event.Name, "node_modules") {
-						watcher.Add(event.Name)
+						err := watcher.Add(event.Name)
+						if err != nil {
+							logger.Fatal("%s", err.Error())
+						}
 						logger.Println("Watching directory: %s", event.Name)
 					}
 				}
@@ -173,7 +176,10 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 
 		// Kill the current program if running
 		if debugBinaryProcess != nil {
-			debugBinaryProcess.Kill()
+			err := debugBinaryProcess.Kill()
+			if err != nil {
+				return err
+			}
 		}
 
 		logger.Println("Development mode exited")
@@ -231,7 +237,10 @@ func restartApp(logger *clilogger.CLILogger, outputType string, ldflags string,
 	err = newProcess.Start()
 	if err != nil {
 		// Remove binary
-		fs.DeleteFile(appBinary)
+		deleteError := fs.DeleteFile(appBinary)
+		if deleteError != nil {
+			logger.Fatal("Unable to delete app binary: " + appBinary)
+		}
 		logger.Fatal("Unable to start application: %s", err.Error())
 	}
 

v2/cmd/wails/main.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/leaanthony/clir"
 	"github.com/wailsapp/wails/v2/cmd/wails/internal/commands/build"
+	"github.com/wailsapp/wails/v2/cmd/wails/internal/commands/debug"
 	"github.com/wailsapp/wails/v2/cmd/wails/internal/commands/dev"
 	"github.com/wailsapp/wails/v2/cmd/wails/internal/commands/doctor"
 	"github.com/wailsapp/wails/v2/cmd/wails/internal/commands/generate"
@@ -27,6 +28,11 @@ func main() {
 	if err != nil {
 		fatal(err.Error())
 	}
+
+	err = debug.AddSubcommand(app, os.Stdout)
+	if err != nil {
+		fatal(err.Error())
+	}
 	err = doctor.AddSubcommand(app, os.Stdout)
 	if err != nil {
 		fatal(err.Error())

v2/cmd/wails/version.go

@@ -1,3 +1,3 @@
 package main
 
-var version = "v2.0.0-alpha.5"
+var version = "v2.0.0-alpha.10"

v2/internal/app/desktop.go

@@ -6,6 +6,7 @@ import (
 	"github.com/wailsapp/wails/v2/internal/binding"
 	"github.com/wailsapp/wails/v2/internal/ffenestri"
 	"github.com/wailsapp/wails/v2/internal/logger"
+	"github.com/wailsapp/wails/v2/internal/menumanager"
 	"github.com/wailsapp/wails/v2/internal/messagedispatcher"
 	"github.com/wailsapp/wails/v2/internal/runtime"
 	"github.com/wailsapp/wails/v2/internal/servicebus"
@@ -23,15 +24,15 @@ type App struct {
 	options    *options.App
 
 	// Subsystems
-	log          *subsystem.Log
-	runtime      *subsystem.Runtime
-	event        *subsystem.Event
-	binding      *subsystem.Binding
-	call         *subsystem.Call
-	menu         *subsystem.Menu
-	tray         *subsystem.Tray
-	contextmenus *subsystem.ContextMenus
-	dispatcher   *messagedispatcher.Dispatcher
+	log        *subsystem.Log
+	runtime    *subsystem.Runtime
+	event      *subsystem.Event
+	binding    *subsystem.Binding
+	call       *subsystem.Call
+	menu       *subsystem.Menu
+	dispatcher *messagedispatcher.Dispatcher
+
+	menuManager *menumanager.Manager
 
 	// Indicates if the app is in debug mode
 	debug bool
@@ -42,6 +43,10 @@ type App struct {
 	// Application Stores
 	loglevelStore  *runtime.Store
 	appconfigStore *runtime.Store
+
+	// Startup/Shutdown
+	startupCallback  func(*runtime.Runtime)
+	shutdownCallback func()
 }
 
 // Create App
@@ -54,13 +59,34 @@ func CreateApp(appoptions *options.App) (*App, error) {
 	myLogger := logger.New(appoptions.Logger)
 	myLogger.SetLogLevel(appoptions.LogLevel)
 
-	window := ffenestri.NewApplicationWithConfig(appoptions, myLogger)
+	// Create the menu manager
+	menuManager := menumanager.NewManager()
+
+	// Process the application menu
+	menuManager.SetApplicationMenu(options.GetApplicationMenu(appoptions))
+
+	// Process context menus
+	contextMenus := options.GetContextMenus(appoptions)
+	for _, contextMenu := range contextMenus {
+		menuManager.AddContextMenu(contextMenu)
+	}
+
+	// Process tray menus
+	trayMenus := options.GetTrayMenus(appoptions)
+	for _, trayMenu := range trayMenus {
+		menuManager.AddTrayMenu(trayMenu)
+	}
+
+	window := ffenestri.NewApplicationWithConfig(appoptions, myLogger, menuManager)
 
 	result := &App{
-		window:     window,
-		servicebus: servicebus.New(myLogger),
-		logger:     myLogger,
-		bindings:   binding.NewBindings(myLogger),
+		window:           window,
+		servicebus:       servicebus.New(myLogger),
+		logger:           myLogger,
+		bindings:         binding.NewBindings(myLogger),
+		menuManager:      menuManager,
+		startupCallback:  appoptions.Startup,
+		shutdownCallback: appoptions.Shutdown,
 	}
 
 	result.options = appoptions
@@ -92,12 +118,7 @@ func (a *App) Run() error {
 		return err
 	}
 
-	// Start the runtime
-	applicationMenu := options.GetApplicationMenu(a.options)
-	trayMenu := options.GetTray(a.options)
-	contextMenus := options.GetContextMenus(a.options)
-
-	runtimesubsystem, err := subsystem.NewRuntime(a.servicebus, a.logger, applicationMenu, trayMenu, contextMenus)
+	runtimesubsystem, err := subsystem.NewRuntime(a.servicebus, a.logger, a.startupCallback, a.shutdownCallback)
 	if err != nil {
 		return err
 	}
@@ -155,43 +176,15 @@ func (a *App) Run() error {
 		return err
 	}
 
-	// Optionally start the menu subsystem
-	if applicationMenu != nil {
-		menusubsystem, err := subsystem.NewMenu(applicationMenu, a.servicebus, a.logger)
-		if err != nil {
-			return err
-		}
-		a.menu = menusubsystem
-		err = a.menu.Start()
-		if err != nil {
-			return err
-		}
+	// Start the menu subsystem
+	menusubsystem, err := subsystem.NewMenu(a.servicebus, a.logger, a.menuManager)
+	if err != nil {
+		return err
 	}
-
-	// Optionally start the tray subsystem
-	if trayMenu != nil {
-		traysubsystem, err := subsystem.NewTray(trayMenu, a.servicebus, a.logger)
-		if err != nil {
-			return err
-		}
-		a.tray = traysubsystem
-		err = a.tray.Start()
-		if err != nil {
-			return err
-		}
-	}
-
-	// Optionally start the context menu subsystem
-	if contextMenus != nil {
-		contextmenussubsystem, err := subsystem.NewContextMenus(contextMenus, a.servicebus, a.logger)
-		if err != nil {
-			return err
-		}
-		a.contextmenus = contextmenussubsystem
-		err = a.contextmenus.Start()
-		if err != nil {
-			return err
-		}
+	a.menu = menusubsystem
+	err = a.menu.Start()
+	if err != nil {
+		return err
 	}
 
 	// Start the call subsystem

v2/internal/binding/binding.go

@@ -34,26 +34,6 @@ func (b *Bindings) Add(structPtr interface{}) error {
 		structName := splitName[1]
 		methodName := splitName[2]
 
-		// Is this WailsInit?
-		if method.IsWailsInit() {
-			err := b.db.AddWailsInit(method)
-			if err != nil {
-				return err
-			}
-			b.logger.Trace("Registered WailsInit method: %s", method.Name)
-			continue
-		}
-
-		// Is this WailsShutdown?
-		if method.IsWailsShutdown() {
-			err := b.db.AddWailsShutdown(method)
-			if err != nil {
-				return err
-			}
-			b.logger.Trace("Registered WailsShutdown method: %s", method.Name)
-			continue
-		}
-
 		// Add it as a regular method
 		b.db.AddMethod(packageName, structName, methodName, method)
 

v2/internal/binding/boundMethod.go

@@ -4,7 +4,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"reflect"
-	"strings"
 )
 
 // BoundMethod defines all the data related to a Go method that is
@@ -17,58 +16,6 @@ type BoundMethod struct {
 	Method   reflect.Value `json:"-"`
 }
 
-// IsWailsInit returns true if the method name is "WailsInit"
-func (b *BoundMethod) IsWailsInit() bool {
-	return strings.HasSuffix(b.Name, "WailsInit")
-}
-
-// IsWailsShutdown returns true if the method name is "WailsShutdown"
-func (b *BoundMethod) IsWailsShutdown() bool {
-	return strings.HasSuffix(b.Name, "WailsShutdown")
-}
-
-// VerifyWailsInit checks if the WailsInit signature is correct
-func (b *BoundMethod) VerifyWailsInit() error {
-	// Must only have 1 input
-	if b.InputCount() != 1 {
-		return fmt.Errorf("invalid method signature for %s: expected `WailsInit(*wails.Runtime) error`", b.Name)
-	}
-
-	// Check input type
-	if !b.Inputs[0].IsType("*runtime.Runtime") {
-		return fmt.Errorf("invalid method signature for %s: expected `WailsInit(*wails.Runtime) error`", b.Name)
-	}
-
-	// Must only have 1 output
-	if b.OutputCount() != 1 {
-		return fmt.Errorf("invalid method signature for %s: expected `WailsInit(*wails.Runtime) error`", b.Name)
-	}
-
-	// Check output type
-	if !b.Outputs[0].IsError() {
-		return fmt.Errorf("invalid method signature for %s: expected `WailsInit(*wails.Runtime) error`", b.Name)
-	}
-
-	// Input must be of type Runtime
-	return nil
-}
-
-// VerifyWailsShutdown checks if the WailsShutdown signature is correct
-func (b *BoundMethod) VerifyWailsShutdown() error {
-	// Must have no inputs
-	if b.InputCount() != 0 {
-		return fmt.Errorf("invalid method signature for WailsShutdown: expected `WailsShutdown()`")
-	}
-
-	// Must have no outputs
-	if b.OutputCount() != 0 {
-		return fmt.Errorf("invalid method signature for WailsShutdown: expected `WailsShutdown()`")
-	}
-
-	// Input must be of type Runtime
-	return nil
-}
-
 // InputCount returns the number of inputs this bound method has
 func (b *BoundMethod) InputCount() int {
 	return len(b.Inputs)

v2/internal/binding/db.go

@@ -15,10 +15,6 @@ type DB struct {
 	// It used for performance gains at runtime
 	methodMap map[string]*BoundMethod
 
-	// These are slices of methods registered using WailsInit and WailsShutdown
-	wailsInitMethods     []*BoundMethod
-	wailsShutdownMethods []*BoundMethod
-
 	// Lock to ensure sync access to the data
 	lock sync.RWMutex
 }
@@ -94,38 +90,6 @@ func (d *DB) AddMethod(packageName string, structName string, methodName string,
 
 }
 
-// AddWailsInit checks the given method is a WailsInit method and if it
-// is, adds it to the list of WailsInit methods
-func (d *DB) AddWailsInit(method *BoundMethod) error {
-	err := method.VerifyWailsInit()
-	if err != nil {
-		return err
-	}
-
-	// Lock the db whilst processing and unlock on return
-	d.lock.Lock()
-	defer d.lock.Unlock()
-
-	d.wailsInitMethods = append(d.wailsInitMethods, method)
-	return nil
-}
-
-// AddWailsShutdown checks the given method is a WailsInit method and if it
-// is, adds it to the list of WailsShutdown methods
-func (d *DB) AddWailsShutdown(method *BoundMethod) error {
-	err := method.VerifyWailsShutdown()
-	if err != nil {
-		return err
-	}
-
-	// Lock the db whilst processing and unlock on return
-	d.lock.Lock()
-	defer d.lock.Unlock()
-
-	d.wailsShutdownMethods = append(d.wailsShutdownMethods, method)
-	return nil
-}
-
 // ToJSON converts the method map to JSON
 func (d *DB) ToJSON() (string, error) {
 
@@ -138,13 +102,3 @@ func (d *DB) ToJSON() (string, error) {
 	// Return zero copy string as this string will be read only
 	return *(*string)(unsafe.Pointer(&bytes)), err
 }
-
-// WailsInitMethods returns the list of registered WailsInit methods
-func (d *DB) WailsInitMethods() []*BoundMethod {
-	return d.wailsInitMethods
-}
-
-// WailsShutdownMethods returns the list of registered WailsInit methods
-func (d *DB) WailsShutdownMethods() []*BoundMethod {
-	return d.wailsShutdownMethods
-}

v2/internal/counter/counter.go

@@ -0,0 +1,40 @@
+package counter
+
+import "sync"
+
+type Counter struct {
+	initialValue uint64
+	value        uint64
+	lock         sync.Mutex
+}
+
+func NewCounter(initialValue uint64) *Counter {
+	return &Counter{
+		initialValue: initialValue,
+		value:        initialValue,
+	}
+}
+
+// SetValue sets the value to the given value
+func (c *Counter) SetValue(value uint64) {
+	c.lock.Lock()
+	c.value = value
+	c.lock.Unlock()
+}
+
+// Increment adds 1 to the counter and returns its value
+func (c *Counter) Increment() uint64 {
+	var result uint64
+	c.lock.Lock()
+	c.value++
+	result = c.value
+	c.lock.Unlock()
+	return result
+}
+
+// Reset the value to the initial value
+func (c *Counter) Reset() {
+	c.lock.Lock()
+	c.value = c.initialValue
+	c.lock.Unlock()
+}

v2/internal/ffenestri/LICENCES.md

@@ -10,4 +10,8 @@ License: http://git.ozlabs.org/?p=ccan;a=blob;f=licenses/BSD-MIT;h=89de354795ec7
 
 ## hashmap
 Homepage: https://github.com/sheredom/hashmap.h
-License: https://github.com/sheredom/hashmap.h/blob/master/LICENSE
+License: https://github.com/sheredom/hashmap.h/blob/master/LICENSE
+
+## utf8.h
+Homepage: https://github.com/sheredom/utf8.h
+License: https://github.com/sheredom/utf8.h/blob/master/LICENSE

v2/internal/ffenestri/common.c

@@ -0,0 +1,113 @@
+//
+// Created by Lea Anthony on 6/1/21.
+//
+
+#include "common.h"
+
+// Credit: https://stackoverflow.com/a/8465083
+char* concat(const char *string1, const char *string2)
+{
+    const size_t len1 = strlen(string1);
+    const size_t len2 = strlen(string2);
+    char *result = malloc(len1 + len2 + 1);
+    strcpy(result, string1);
+    memcpy(result + len1, string2, len2 + 1);
+    return result;
+}
+
+// 10k is more than enough for a log message
+#define MAXMESSAGE 1024*10
+char abortbuffer[MAXMESSAGE];
+
+void ABORT(const char *message, ...) {
+    const char *temp = concat("FATAL: ", message);
+    va_list args;
+    va_start(args, message);
+    vsnprintf(abortbuffer, MAXMESSAGE, temp, args);
+    printf("%s\n", &abortbuffer[0]);
+    MEMFREE(temp);
+    va_end(args);
+    exit(1);
+}
+
+int freeHashmapItem(void *const context, struct hashmap_element_s *const e) {
+    free(e->data);
+    return -1;
+}
+
+const char* getJSONString(JsonNode *item, const char* key) {
+    // Get key
+    JsonNode *node = json_find_member(item, key);
+    const char *result = NULL;
+    if ( node != NULL && node->tag == JSON_STRING) {
+        result = node->string_;
+    }
+    return result;
+}
+
+const char* getJSONStringDefault(JsonNode *item, const char* key, const char* defaultValue) {
+    const char* result = getJSONString(item, key);
+    if ( result == NULL ) result = defaultValue;
+    return result;
+}
+
+void ABORT_JSON(JsonNode *node, const char* key) {
+    ABORT("Unable to read required key '%s' from JSON: %s\n", key, json_encode(node));
+}
+
+const char* mustJSONString(JsonNode *item, const char* key) {
+    JsonNode *member = json_find_member(item, key);
+    if ( member == NULL ) {
+        ABORT_JSON(item, key);
+    }
+    const char *result = "";
+    if ( member != NULL && member->tag == JSON_STRING) {
+        result = member->string_;
+    }
+    return result;
+}
+JsonNode* mustJSONObject(JsonNode *node, const char* key) {
+    struct JsonNode* result = getJSONObject(node, key);
+    if ( result == NULL ) {
+        ABORT_JSON(node, key);
+    }
+    return result;
+}
+
+JsonNode* getJSONObject(JsonNode* node, const char* key) {
+    return json_find_member(node, key);
+}
+
+bool getJSONBool(JsonNode *node, const char* key) {
+    JsonNode *result = json_find_member(node, key);
+    if ( result != NULL && result->tag == JSON_BOOL) {
+        return result->bool_;
+    }
+    return false;
+}
+
+int mustJSONInt(JsonNode *node, const char* key) {
+    JsonNode *result = json_find_member(node, key);
+    if ( result == NULL || result->tag != JSON_NUMBER) {
+        ABORT_JSON(result, key);
+    }
+
+    return (int) result->number_;
+}
+
+bool getJSONInt(JsonNode *item, const char* key, int *result) {
+    JsonNode *node = json_find_member(item, key);
+    if ( node != NULL && node->tag == JSON_NUMBER) {
+        *result = (int) node->number_;
+        return true;
+    }
+    return false;
+}
+
+JsonNode* mustParseJSON(const char* JSON) {
+    JsonNode* parsedUpdate = json_decode(JSON);
+    if ( parsedUpdate == NULL ) {
+        ABORT("Unable to decode JSON: %s\n", JSON);
+    }
+    return parsedUpdate;
+}

v2/internal/ffenestri/common.h

@@ -0,0 +1,62 @@
+//
+// Created by Lea Anthony on 6/1/21.
+//
+
+#ifndef COMMON_H
+#define COMMON_H
+
+#define OBJC_OLD_DISPATCH_PROTOTYPES 1
+#include <objc/objc-runtime.h>
+#include <CoreGraphics/CoreGraphics.h>
+
+#include <stdio.h>
+#include <stdarg.h>
+#include "string.h"
+#include "hashmap.h"
+#include "vec.h"
+#include "json.h"
+
+#define STREQ(a,b) strcmp(a, b) == 0
+#define STREMPTY(string) strlen(string) == 0
+#define STRCOPY(str) (str == NULL ? NULL : concat(str, ""))
+#define STR_HAS_CHARS(input) input != NULL && strlen(input) > 0
+#define MEMFREE(input) if(input != NULL) { free((void*)input); input = NULL; }
+#define FREE_AND_SET(variable, value) if( variable != NULL ) { MEMFREE(variable); } variable = value
+#define NEW(struct) malloc(sizeof(struct));
+
+#define HASHMAP_INIT(hashmap, initialSize, name) \
+    if( 0 != hashmap_create((const unsigned)initialSize, &hashmap)) { \
+        ABORT("Not enough memory to allocate %s!\n", name);          \
+    }
+
+#define HASHMAP_PUT(hashmap, key, value) hashmap_put(&hashmap, key, strlen(key), value);
+#define HASHMAP_GET(hashmap, key) hashmap_get(&hashmap, key, strlen(key));
+#define HASHMAP_DESTROY(hashmap) hashmap_destroy(&hashmap);
+#define HASHMAP_SIZE(hashmap) hashmap_num_entries(&hashmap)
+#define HASHMAP_ITERATE(hashmap, function, context) if( hashmap_num_entries(&hashmap) > 0 ) { \
+        if (0!=hashmap_iterate_pairs(&hashmap, function, context)) { \
+            ABORT("failed to iterate hashmap entries!"); \
+        } \
+    }
+#define JSON_ADD_STRING(jsonObject, key, value) if( value != NULL ) { json_append_member(jsonObject, (char*)key, json_mkstring(value)); }
+#define JSON_ADD_NUMBER(jsonObject, key, value) json_append_member(jsonObject, (char*)key, json_mknumber(value));
+#define JSON_ADD_OBJECT(jsonObject, key, value) if( value != NULL ) { json_append_member(jsonObject, (char*)key, value); }
+#define JSON_ADD_BOOL(jsonObject, key, value) json_append_member(jsonObject, (char*)key, json_mkbool(value));
+#define JSON_ADD_ELEMENT(jsonObject, value) json_append_element(jsonObject, value);
+
+// Credit: https://stackoverflow.com/a/8465083
+char* concat(const char *string1, const char *string2);
+void ABORT(const char *message, ...);
+int freeHashmapItem(void *context, struct hashmap_element_s *e);
+const char* getJSONString(JsonNode *item, const char* key);
+const char* getJSONStringDefault(JsonNode *item, const char* key, const char* defaultValue);
+const char* mustJSONString(JsonNode *node, const char* key);
+JsonNode* getJSONObject(JsonNode* node, const char* key);
+JsonNode* mustJSONObject(JsonNode *node, const char* key);
+
+bool getJSONBool(JsonNode *item, const char* key);
+bool getJSONInt(JsonNode *item, const char* key, int *result);
+int mustJSONInt(JsonNode *node, const char* key);
+JsonNode* mustParseJSON(const char* JSON);
+
+#endif //ASSETS_C_COMMON_H

v2/internal/ffenestri/contextmenus_darwin.c

@@ -0,0 +1,99 @@
+//////
+////// Created by Lea Anthony on 6/1/21.
+//////
+////
+//
+//#include "ffenestri_darwin.h"
+//#include "common.h"
+//#include "contextmenus_darwin.h"
+//#include "menu_darwin.h"
+//
+//ContextMenu* NewContextMenu(const char* contextMenuJSON, struct TrayMenuStore *store) {
+//    ContextMenu* result = malloc(sizeof(ContextMenu));
+//
+//    JsonNode* processedJSON = json_decode(contextMenuJSON);
+//    if( processedJSON == NULL ) {
+//        ABORT("[NewTrayMenu] Unable to parse TrayMenu JSON: %s", contextMenuJSON);
+//    }
+//    // Save reference to this json
+//    result->processedJSON = processedJSON;
+//
+//    result->ID = mustJSONString(processedJSON, "ID");
+//    JsonNode* processedMenu = mustJSONObject(processedJSON, "ProcessedMenu");
+//
+////    result->menu = NewMenu(processedMenu);
+//    result->nsmenu = NULL;
+//    result->menu->menuType = ContextMenuType;
+//    result->menu->store = store;
+//    result->contextMenuData = NULL;
+//    return result;
+//}
+//
+//ContextMenu* GetContextMenuByID(ContextMenuStore* store, const char *contextMenuID) {
+//    return (ContextMenu*)hashmap_get(&store->contextMenuMap, (char*)contextMenuID, strlen(contextMenuID));
+//}
+//
+//void DeleteContextMenu(ContextMenu* contextMenu) {
+//    // Free Menu
+//    DeleteMenu(contextMenu->menu);
+//
+//    // Delete any context menu data we may have stored
+//    if( contextMenu->contextMenuData != NULL ) {
+//        MEMFREE(contextMenu->contextMenuData);
+//    }
+//
+//    // Free JSON
+//    if (contextMenu->processedJSON != NULL ) {
+//        json_delete(contextMenu->processedJSON);
+//        contextMenu->processedJSON = NULL;
+//    }
+//
+//    // Free context menu
+//    free(contextMenu);
+//}
+//
+//int freeContextMenu(void *const context, struct hashmap_element_s *const e) {
+//    DeleteContextMenu(e->data);
+//    return -1;
+//}
+//
+//void ShowContextMenu(ContextMenuStore* store, id mainWindow, const char *contextMenuID, const char *contextMenuData) {
+//
+//	// If no context menu ID was given, abort
+//	if( contextMenuID == NULL ) {
+//		return;
+//	}
+//
+//	ContextMenu* contextMenu = GetContextMenuByID(store, contextMenuID);
+//
+//	// We don't need the ID now
+//    MEMFREE(contextMenuID);
+//
+//    if( contextMenu == NULL ) {
+//        // Free context menu data
+//        if( contextMenuData != NULL ) {
+//	        MEMFREE(contextMenuData);
+//			return;
+//		}
+//	}
+//
+//    // We need to store the context menu data. Free existing data if we have it
+//    // and set to the new value.
+//    FREE_AND_SET(contextMenu->contextMenuData, contextMenuData);
+//
+//	// Grab the content view and show the menu
+//	id contentView = msg(mainWindow, s("contentView"));
+//
+//	// Get the triggering event
+//	id menuEvent = msg(mainWindow, s("currentEvent"));
+//
+////	if( contextMenu->nsmenu == NULL ) {
+////        // GetMenu creates the NSMenu
+////        contextMenu->nsmenu = GetMenu(contextMenu->menu);
+////	}
+//
+//	// Show popup
+//	msg(c("NSMenu"), s("popUpContextMenu:withEvent:forView:"), contextMenu->nsmenu, menuEvent, contentView);
+//
+//}
+//

v2/internal/ffenestri/contextmenus_darwin.h

@@ -0,0 +1,33 @@
+//////
+////// Created by Lea Anthony on 6/1/21.
+//////
+////
+//#ifndef CONTEXTMENU_DARWIN_H
+//#define CONTEXTMENU_DARWIN_H
+//
+//#include "json.h"
+//#include "menu_darwin.h"
+//#include "contextmenustore_darwin.h"
+//
+//typedef struct {
+//    const char* ID;
+//    id nsmenu;
+//    Menu* menu;
+//
+//    JsonNode* processedJSON;
+//
+//    // Context menu data is given by the frontend when clicking a context menu.
+//    // We send this to the backend when an item is selected
+//	const char* contextMenuData;
+//} ContextMenu;
+//
+//
+//ContextMenu* NewContextMenu(const char* contextMenuJSON);
+//
+//ContextMenu* GetContextMenuByID( ContextMenuStore* store, const char *contextMenuID);
+//void DeleteContextMenu(ContextMenu* contextMenu);
+//int freeContextMenu(void *const context, struct hashmap_element_s *const e);
+//
+//void ShowContextMenu(ContextMenuStore* store, id mainWindow, const char *contextMenuID, const char *contextMenuData);
+//
+//#endif //CONTEXTMENU_DARWIN_H

v2/internal/ffenestri/contextmenustore_darwin.c

@@ -0,0 +1,65 @@
+//
+//#include "contextmenus_darwin.h"
+//#include "contextmenustore_darwin.h"
+//
+//ContextMenuStore* NewContextMenuStore() {
+//
+//    ContextMenuStore* result = malloc(sizeof(ContextMenuStore));
+//
+//    // Allocate Context Menu Store
+//    if( 0 != hashmap_create((const unsigned)4, &result->contextMenuMap)) {
+//        ABORT("[NewContextMenus] Not enough memory to allocate contextMenuStore!");
+//    }
+//
+//    return result;
+//}
+//
+//void AddContextMenuToStore(ContextMenuStore* store, const char* contextMenuJSON) {
+//    ContextMenu* newMenu = NewContextMenu(contextMenuJSON);
+//
+//    //TODO: check if there is already an entry for this menu
+//    hashmap_put(&store->contextMenuMap, newMenu->ID, strlen(newMenu->ID), newMenu);
+//}
+//
+//ContextMenu* GetContextMenuFromStore(ContextMenuStore* store, const char* menuID) {
+//    // Get the current menu
+//    return hashmap_get(&store->contextMenuMap, menuID, strlen(menuID));
+//}
+//
+//void UpdateContextMenuInStore(ContextMenuStore* store, const char* menuJSON) {
+//    ContextMenu* newContextMenu = NewContextMenu(menuJSON);
+//
+//    // Get the current menu
+//    ContextMenu *currentMenu = GetContextMenuFromStore(store, newContextMenu->ID);
+//    if ( currentMenu == NULL ) {
+//        ABORT("Attempted to update unknown context menu with ID '%s'.", newContextMenu->ID);
+//    }
+//
+//    hashmap_remove(&store->contextMenuMap, newContextMenu->ID, strlen(newContextMenu->ID));
+//
+//    // Save the status bar reference
+//    DeleteContextMenu(currentMenu);
+//
+//    hashmap_put(&store->contextMenuMap, newContextMenu->ID, strlen(newContextMenu->ID), newContextMenu);
+//
+//}
+//
+//
+//void DeleteContextMenuStore(ContextMenuStore* store) {
+//
+//    // Guard against NULLs
+//    if( store == NULL ) {
+//        return;
+//    }
+//
+//    // Delete context menus
+//    if( hashmap_num_entries(&store->contextMenuMap) > 0 ) {
+//        if (0 != hashmap_iterate_pairs(&store->contextMenuMap, freeContextMenu, NULL)) {
+//            ABORT("[DeleteContextMenuStore] Failed to release contextMenuStore entries!");
+//        }
+//    }
+//
+//    // Free context menu hashmap
+//    hashmap_destroy(&store->contextMenuMap);
+//
+//}

v2/internal/ffenestri/contextmenustore_darwin.h

@@ -0,0 +1,27 @@
+////
+//// Created by Lea Anthony on 7/1/21.
+////
+//
+//#ifndef CONTEXTMENUSTORE_DARWIN_H
+//#define CONTEXTMENUSTORE_DARWIN_H
+//
+//#include "common.h"
+//
+//typedef struct {
+//
+//    int dummy;
+//
+//    // This is our context menu store which keeps track
+//    // of all instances of ContextMenus
+//    struct hashmap_s contextMenuMap;
+//
+//} ContextMenuStore;
+//
+//ContextMenuStore* NewContextMenuStore();
+//
+//void DeleteContextMenuStore(ContextMenuStore* store);
+//void UpdateContextMenuInStore(ContextMenuStore* store, const char* menuJSON);
+//
+//void AddContextMenuToStore(ContextMenuStore* store, const char* contextMenuJSON);
+//
+//#endif //CONTEXTMENUSTORE_DARWIN_H

v2/internal/ffenestri/ffenestri.go

@@ -1,6 +1,7 @@
 package ffenestri
 
 import (
+	"github.com/wailsapp/wails/v2/internal/menumanager"
 	"runtime"
 	"strings"
 	"unsafe"
@@ -31,7 +32,10 @@ type Application struct {
 	memory []unsafe.Pointer
 
 	// This is the main app pointer
-	app unsafe.Pointer
+	app *C.struct_Application
+
+	// Manages menus
+	menuManager *menumanager.Manager
 
 	// Logger
 	logger logger.CustomLogger
@@ -52,10 +56,11 @@ func init() {
 }
 
 // NewApplicationWithConfig creates a new application based on the given config
-func NewApplicationWithConfig(config *options.App, logger *logger.Logger) *Application {
+func NewApplicationWithConfig(config *options.App, logger *logger.Logger, menuManager *menumanager.Manager) *Application {
 	return &Application{
-		config: config,
-		logger: logger.CustomLogger("Ffenestri"),
+		config:      config,
+		logger:      logger.CustomLogger("Ffenestri"),
+		menuManager: menuManager,
 	}
 }
 
@@ -116,7 +121,7 @@ func (a *Application) Run(incomingDispatcher Dispatcher, bindings string, debug
 	app := C.NewApplication(title, width, height, resizable, devtools, fullscreen, startHidden, logLevel)
 
 	// Save app reference
-	a.app = unsafe.Pointer(app)
+	a.app = (*C.struct_Application)(app)
 
 	// Set Min Window Size
 	minWidth := C.int(a.config.MinWidth)
@@ -152,7 +157,10 @@ func (a *Application) Run(incomingDispatcher Dispatcher, bindings string, debug
 	dispatcher = incomingDispatcher.RegisterClient(newClient(a))
 
 	// Process platform settings
-	a.processPlatformSettings()
+	err := a.processPlatformSettings()
+	if err != nil {
+		return err
+	}
 
 	// Check we could initialise the application
 	if app != nil {

v2/internal/ffenestri/ffenestri.h

@@ -2,41 +2,43 @@
 #define __FFENESTRI_H__
 
 #include <stdio.h>
+struct Application;
 
-extern void *NewApplication(const char *title, int width, int height, int resizable, int devtools, int fullscreen, int startHidden, int logLevel);
-extern void SetMinWindowSize(void *app, int minWidth, int minHeight);
-extern void SetMaxWindowSize(void *app, int maxWidth, int maxHeight);
-extern void Run(void *app, int argc, char **argv);
-extern void DestroyApplication(void *app);
-extern void SetDebug(void *app, int flag);
-extern void SetBindings(void *app, const char *bindings);
-extern void ExecJS(void *app, const char *script);
-extern void Hide(void *app);
-extern void Show(void *app);
-extern void Center(void *app);
-extern void Maximise(void *app);
-extern void Unmaximise(void *app);
-extern void ToggleMaximise(void *app);
-extern void Minimise(void *app);
-extern void Unminimise(void *app);
-extern void ToggleMinimise(void *app);
-extern void SetColour(void *app, int red, int green, int blue, int alpha);
-extern void SetSize(void *app, int width, int height);
-extern void SetPosition(void *app, int x, int y);
-extern void Quit(void *app);
-extern void SetTitle(void *app, const char *title);
-extern void Fullscreen(void *app);
-extern void UnFullscreen(void *app);
-extern void ToggleFullscreen(void *app);
-extern void DisableFrame(void *app);
-extern void OpenDialog(void *appPointer, char *callbackID, char *title, char *filters, char *defaultFilename, char *defaultDir, int allowFiles, int allowDirs, int allowMultiple, int showHiddenFiles, int canCreateDirectories, int resolvesAliases, int treatPackagesAsDirectories);
-extern void SaveDialog(void *appPointer, char *callbackID, char *title, char *filters, char *defaultFilename, char *defaultDir, int showHiddenFiles, int canCreateDirectories, int treatPackagesAsDirectories);
-extern void MessageDialog(void *appPointer, char *callbackID, char *type, char *title, char *message, char *icon, char *button1, char *button2, char *button3, char *button4, char *defaultButton, char *cancelButton);
-extern void DarkModeEnabled(void *appPointer, char *callbackID);
-extern void UpdateMenu(void *app, char *menuAsJSON);
-extern void UpdateTray(void *app, char *menuAsJSON);
-extern void UpdateContextMenus(void *app, char *contextMenusAsJSON);
-extern void UpdateTrayLabel(void *app, const char *label);
-extern void UpdateTrayIcon(void *app, const char *label);
+extern struct Application *NewApplication(const char *title, int width, int height, int resizable, int devtools, int fullscreen, int startHidden, int logLevel);
+extern void SetMinWindowSize(struct Application*, int minWidth, int minHeight);
+extern void SetMaxWindowSize(struct Application*, int maxWidth, int maxHeight);
+extern void Run(struct Application*, int argc, char **argv);
+extern void DestroyApplication(struct Application*);
+extern void SetDebug(struct Application*, int flag);
+extern void SetBindings(struct Application*, const char *bindings);
+extern void ExecJS(struct Application*, const char *script);
+extern void Hide(struct Application*);
+extern void Show(struct Application*);
+extern void Center(struct Application*);
+extern void Maximise(struct Application*);
+extern void Unmaximise(struct Application*);
+extern void ToggleMaximise(struct Application*);
+extern void Minimise(struct Application*);
+extern void Unminimise(struct Application*);
+extern void ToggleMinimise(struct Application*);
+extern void SetColour(struct Application*, int red, int green, int blue, int alpha);
+extern void SetSize(struct Application*, int width, int height);
+extern void SetPosition(struct Application*, int x, int y);
+extern void Quit(struct Application*);
+extern void SetTitle(struct Application*, const char *title);
+extern void Fullscreen(struct Application*);
+extern void UnFullscreen(struct Application*);
+extern void ToggleFullscreen(struct Application*);
+extern void DisableFrame(struct Application*);
+extern void OpenDialog(struct Application*, const char *callbackID, const char *title, const char *filters, const char *defaultFilename, const char *defaultDir, int allowFiles, int allowDirs, int allowMultiple, int showHiddenFiles, int canCreateDirectories, int resolvesAliases, int treatPackagesAsDirectories);
+extern void SaveDialog(struct Application*, const char *callbackID, const char *title, const char *filters, const char *defaultFilename, const char *defaultDir, int showHiddenFiles, int canCreateDirectories, int treatPackagesAsDirectories);
+extern void MessageDialog(struct Application*, const char *callbackID, const char *type, const char *title, const char *message, const char *icon, const char *button1, const char *button2, const char *button3, const char *button4, const char *defaultButton, const char *cancelButton);
+extern void DarkModeEnabled(struct Application*, const char *callbackID);
+extern void SetApplicationMenu(struct Application*, const char *);
+extern void AddTrayMenu(struct Application*, const char *menuTrayJSON);
+extern void SetTrayMenu(struct Application*, const char *menuTrayJSON);
+extern void UpdateTrayMenuLabel(struct Application*, const char* JSON);
+extern void AddContextMenu(struct Application*, const char *contextMenuJSON);
+extern void UpdateContextMenu(struct Application*, const char *contextMenuJSON);
 
 #endif

v2/internal/ffenestri/ffenestri_client.go

@@ -12,12 +12,10 @@ package ffenestri
 import "C"
 
 import (
-	"encoding/json"
-	"github.com/wailsapp/wails/v2/pkg/menu"
+	"github.com/wailsapp/wails/v2/pkg/options/dialog"
 	"strconv"
 
 	"github.com/wailsapp/wails/v2/internal/logger"
-	"github.com/wailsapp/wails/v2/pkg/options"
 )
 
 // Client is our implentation of messageDispatcher.Client
@@ -122,7 +120,7 @@ func (c *Client) WindowSetColour(colour int) {
 }
 
 // OpenDialog will open a dialog with the given title and filter
-func (c *Client) OpenDialog(dialogOptions *options.OpenDialog, callbackID string) {
+func (c *Client) OpenDialog(dialogOptions *dialog.OpenDialog, callbackID string) {
 	C.OpenDialog(c.app.app,
 		c.app.string2CString(callbackID),
 		c.app.string2CString(dialogOptions.Title),
@@ -140,7 +138,7 @@ func (c *Client) OpenDialog(dialogOptions *options.OpenDialog, callbackID string
 }
 
 // SaveDialog will open a dialog with the given title and filter
-func (c *Client) SaveDialog(dialogOptions *options.SaveDialog, callbackID string) {
+func (c *Client) SaveDialog(dialogOptions *dialog.SaveDialog, callbackID string) {
 	C.SaveDialog(c.app.app,
 		c.app.string2CString(callbackID),
 		c.app.string2CString(dialogOptions.Title),
@@ -154,7 +152,7 @@ func (c *Client) SaveDialog(dialogOptions *options.SaveDialog, callbackID string
 }
 
 // MessageDialog will open a message dialog with the given options
-func (c *Client) MessageDialog(dialogOptions *options.MessageDialog, callbackID string) {
+func (c *Client) MessageDialog(dialogOptions *dialog.MessageDialog, callbackID string) {
 
 	// Sanity check button length
 	if len(dialogOptions.Buttons) > 4 {
@@ -186,57 +184,18 @@ func (c *Client) DarkModeEnabled(callbackID string) {
 	C.DarkModeEnabled(c.app.app, c.app.string2CString(callbackID))
 }
 
-func (c *Client) UpdateMenu(menu *menu.Menu) {
-
-	// Guard against nil menus
-	if menu == nil {
-		return
-	}
-	// Process the menu
-	processedMenu := NewProcessedMenu(menu)
-	menuJSON, err := json.Marshal(processedMenu)
-	if err != nil {
-		c.app.logger.Error("Error processing updated Menu: %s", err.Error())
-		return
-	}
-	C.UpdateMenu(c.app.app, c.app.string2CString(string(menuJSON)))
+func (c *Client) SetApplicationMenu(applicationMenuJSON string) {
+	C.SetApplicationMenu(c.app.app, c.app.string2CString(applicationMenuJSON))
 }
 
-func (c *Client) UpdateTray(menu *menu.Menu) {
-
-	// Guard against nil menus
-	if menu == nil {
-		return
-	}
-	// Process the menu
-	processedMenu := NewProcessedMenu(menu)
-	trayMenuJSON, err := json.Marshal(processedMenu)
-	if err != nil {
-		c.app.logger.Error("Error processing updated Tray: %s", err.Error())
-		return
-	}
-	C.UpdateTray(c.app.app, c.app.string2CString(string(trayMenuJSON)))
+func (c *Client) SetTrayMenu(trayMenuJSON string) {
+	C.SetTrayMenu(c.app.app, c.app.string2CString(trayMenuJSON))
 }
 
-func (c *Client) UpdateTrayLabel(label string) {
-	C.UpdateTrayLabel(c.app.app, c.app.string2CString(label))
+func (c *Client) UpdateTrayMenuLabel(JSON string) {
+	C.UpdateTrayMenuLabel(c.app.app, c.app.string2CString(JSON))
 }
 
-func (c *Client) UpdateTrayIcon(name string) {
-	C.UpdateTrayIcon(c.app.app, c.app.string2CString(name))
-}
-
-func (c *Client) UpdateContextMenus(contextMenus *menu.ContextMenus) {
-
-	// Guard against nil contextMenus
-	if contextMenus == nil {
-		return
-	}
-	// Process the menu
-	contextMenusJSON, err := json.Marshal(contextMenus)
-	if err != nil {
-		c.app.logger.Error("Error processing updated Context Menus: %s", err.Error())
-		return
-	}
-	C.UpdateContextMenus(c.app.app, c.app.string2CString(string(contextMenusJSON)))
+func (c *Client) UpdateContextMenu(contextMenuJSON string) {
+	C.UpdateContextMenu(c.app.app, c.app.string2CString(contextMenuJSON))
 }

v2/internal/ffenestri/ffenestri_darwin.go

@@ -4,15 +4,11 @@ package ffenestri
 #cgo darwin CFLAGS: -DFFENESTRI_DARWIN=1
 #cgo darwin LDFLAGS: -framework WebKit -lobjc
 
+#include "ffenestri.h"
 #include "ffenestri_darwin.h"
 
 */
 import "C"
-import (
-	"encoding/json"
-	"fmt"
-	"github.com/wailsapp/wails/v2/pkg/options"
-)
 
 func (a *Application) processPlatformSettings() error {
 
@@ -62,56 +58,34 @@ func (a *Application) processPlatformSettings() error {
 		C.WindowBackgroundIsTranslucent(a.app)
 	}
 
-	// Process menu
-	applicationMenu := options.GetApplicationMenu(a.config)
-	if applicationMenu != nil {
-
-		/*
-			As radio groups need to be manually managed on OSX,
-			we preprocess the menu to determine the radio groups.
-			This is defined as any adjacent menu item of type "RadioType".
-			We keep a record of every radio group member we discover by saving
-			a list of all members of the group and the number of members
-			in the group (this last one is for optimisation at the C layer).
-		*/
-		processedMenu := NewProcessedMenu(applicationMenu)
-		applicationMenuJSON, err := json.Marshal(processedMenu)
-		if err != nil {
-			return err
-		}
-		C.SetMenu(a.app, a.string2CString(string(applicationMenuJSON)))
-	}
+	//// Process menu
+	////applicationMenu := options.GetApplicationMenu(a.config)
+	//applicationMenu := a.menuManager.GetApplicationMenuJSON()
+	//if applicationMenu != "" {
+	//	C.SetApplicationMenu(a.app, a.string2CString(applicationMenu))
+	//}
 
 	// Process tray
-	tray := options.GetTray(a.config)
-	if tray != nil {
-
-		/*
-			As radio groups need to be manually managed on OSX,
-			we preprocess the menu to determine the radio groups.
-			This is defined as any adjacent menu item of type "RadioType".
-			We keep a record of every radio group member we discover by saving
-			a list of all members of the group and the number of members
-			in the group (this last one is for optimisation at the C layer).
-		*/
-		processedMenu := NewProcessedMenu(tray.Menu)
-		trayMenuJSON, err := json.Marshal(processedMenu)
-		if err != nil {
-			return err
+	trays, err := a.menuManager.GetTrayMenusAsJSON()
+	if err != nil {
+		return err
+	}
+	if trays != nil {
+		for _, tray := range trays {
+			C.AddTrayMenu(a.app, a.string2CString(tray))
 		}
-		C.SetTray(a.app, a.string2CString(string(trayMenuJSON)), a.string2CString(tray.Label), a.string2CString(tray.Icon))
 	}
 
-	// Process context menus
-	contextMenus := options.GetContextMenus(a.config)
-	if contextMenus != nil {
-		contextMenusJSON, err := json.Marshal(contextMenus)
-		fmt.Printf("\n\nCONTEXT MENUS:\n %+v\n\n", string(contextMenusJSON))
-		if err != nil {
-			return err
-		}
-		C.SetContextMenus(a.app, a.string2CString(string(contextMenusJSON)))
-	}
+	//// Process context menus
+	//contextMenus, err := a.menuManager.GetContextMenus()
+	//if err != nil {
+	//	return err
+	//}
+	//if contextMenus != nil {
+	//	for _, contextMenu := range contextMenus {
+	//		C.AddContextMenu(a.app, a.string2CString(contextMenu))
+	//	}
+	//}
 
 	return nil
 }

v2/internal/ffenestri/ffenestri_darwin.h

@@ -2,18 +2,112 @@
 #ifndef FFENESTRI_DARWIN_H
 #define FFENESTRI_DARWIN_H
 
-extern void TitlebarAppearsTransparent(void *);
-extern void HideTitle(void *);
-extern void HideTitleBar(void *);
-extern void FullSizeContent(void *);
-extern void UseToolbar(void *);
-extern void HideToolbarSeparator(void *);
-extern void DisableFrame(void *);
-extern void SetAppearance(void *, const char *);
-extern void WebviewIsTransparent(void *);
-extern void WindowBackgroundIsTranslucent(void *);
-extern void SetMenu(void *, const char *);
-extern void SetTray(void *, const char *, const char *, const char *);
-extern void SetContextMenus(void *, const char *);
+
+#define OBJC_OLD_DISPATCH_PROTOTYPES 1
+#include <objc/objc-runtime.h>
+#include <CoreGraphics/CoreGraphics.h>
+#include "json.h"
+#include "hashmap.h"
+#include "stdlib.h"
+
+// Macros to make it slightly more sane
+#define msg objc_msgSend
+
+#define c(str) (id)objc_getClass(str)
+#define s(str) sel_registerName(str)
+#define u(str) sel_getUid(str)
+#define str(input) msg(c("NSString"), s("stringWithUTF8String:"), input)
+#define strunicode(input) msg(c("NSString"), s("stringWithFormat:"), str("%C"), (unsigned short)input)
+#define cstr(input) (const char *)msg(input, s("UTF8String"))
+#define url(input) msg(c("NSURL"), s("fileURLWithPath:"), str(input))
+#define RELEASE(input) if( input != NULL ) { msg(input, s("release")); }
+
+#define ALLOC(classname) msg(c(classname), s("alloc"))
+#define ALLOC_INIT(classname) msg(msg(c(classname), s("alloc")), s("init"))
+#define GET_FRAME(receiver) ((CGRect(*)(id, SEL))objc_msgSend_stret)(receiver, s("frame"))
+#define GET_BOUNDS(receiver) ((CGRect(*)(id, SEL))objc_msgSend_stret)(receiver, s("bounds"))
+#define GET_BACKINGSCALEFACTOR(receiver) ((CGFloat(*)(id, SEL))msg)(receiver, s("backingScaleFactor"))
+
+#define ON_MAIN_THREAD(str) dispatch( ^{ str; } )
+#define MAIN_WINDOW_CALL(str) msg(app->mainWindow, s((str)))
+
+#define NSBackingStoreBuffered 2
+
+#define NSWindowStyleMaskBorderless 0
+#define NSWindowStyleMaskTitled 1
+#define NSWindowStyleMaskClosable 2
+#define NSWindowStyleMaskMiniaturizable 4
+#define NSWindowStyleMaskResizable 8
+#define NSWindowStyleMaskFullscreen 1 << 14
+
+#define NSVisualEffectMaterialWindowBackground 12
+#define NSVisualEffectBlendingModeBehindWindow 0
+#define NSVisualEffectStateFollowsWindowActiveState 0
+#define NSVisualEffectStateActive 1
+#define NSVisualEffectStateInactive 2
+
+#define NSViewWidthSizable 2
+#define NSViewHeightSizable 16
+
+#define NSWindowBelow -1
+#define NSWindowAbove 1
+
+#define NSSquareStatusItemLength   -2.0
+#define NSVariableStatusItemLength -1.0
+
+#define NSWindowTitleHidden 1
+#define NSWindowStyleMaskFullSizeContentView 1 << 15
+
+#define NSEventModifierFlagCommand 1 << 20
+#define NSEventModifierFlagOption 1 << 19
+#define NSEventModifierFlagControl 1 << 18
+#define NSEventModifierFlagShift 1 << 17
+
+#define NSControlStateValueMixed -1
+#define NSControlStateValueOff 0
+#define NSControlStateValueOn 1
+
+// Unbelievably, if the user swaps their button preference
+// then right buttons are reported as left buttons
+#define NSEventMaskLeftMouseDown 1 << 1
+#define NSEventMaskLeftMouseUp 1 << 2
+#define NSEventMaskRightMouseDown 1 << 3
+#define NSEventMaskRightMouseUp 1 << 4
+
+#define NSEventTypeLeftMouseDown 1
+#define NSEventTypeLeftMouseUp 2
+#define NSEventTypeRightMouseDown 3
+#define NSEventTypeRightMouseUp 4
+
+#define NSNoImage       0
+#define NSImageOnly     1
+#define NSImageLeft     2
+#define NSImageRight    3
+#define NSImageBelow    4
+#define NSImageAbove    5
+#define NSImageOverlaps 6
+
+#define NSAlertStyleWarning 0
+#define NSAlertStyleInformational 1
+#define NSAlertStyleCritical 2
+
+#define NSAlertFirstButtonReturn   1000
+#define NSAlertSecondButtonReturn  1001
+#define NSAlertThirdButtonReturn   1002
+
+struct Application;
+int releaseNSObject(void *const context, struct hashmap_element_s *const e);
+void TitlebarAppearsTransparent(struct Application* app);
+void HideTitle(struct Application* app);
+void HideTitleBar(struct Application* app);
+void FullSizeContent(struct Application* app);
+void UseToolbar(struct Application* app);
+void HideToolbarSeparator(struct Application* app);
+void DisableFrame(struct Application* app);
+void SetAppearance(struct Application* app, const char *);
+void WebviewIsTransparent(struct Application* app);
+void WindowBackgroundIsTranslucent(struct Application* app);
+void SetTray(struct Application* app, const char *, const char *, const char *);
+//void SetContextMenus(struct Application* app, const char *);
 
 #endif

v2/internal/ffenestri/menu.c

@@ -0,0 +1,276 @@
+//
+// Created by Lea Anthony on 18/1/21.
+//
+
+#include "menu.h"
+
+Menu* NewMenu(struct JsonNode* menuData, struct JsonNode* radioData, MenuManager* manager) {
+
+    if( menuData == NULL ) return NULL;
+    if( manager == NULL ) return NULL;
+
+    Menu *result = NEW(Menu);
+
+    // No label by default
+    result->label = STRCOPY(getJSONStringDefault(menuData, "l", ""));
+
+    // Setup platform specific menu data
+    SetupMenuPlatformData(result);
+
+    // Init menu item list
+    vec_init(&result->menuItems);
+
+    // Get the menu items
+    JsonNode* items = getJSONObject(menuData, "i");
+    if( items != NULL ) {
+
+        // Process the menu data
+        JsonNode *item;
+        json_foreach(item, items) {
+            const char *ID = mustJSONString(item, "I");
+            MenuItem *menuItem = HASHMAP_GET(manager->menuItems, ID);
+            if (menuItem == NULL) {
+                // Process each menu item
+                menuItem = processMenuItem(result, item, manager);
+
+                // Filter out separators
+                if (menuItem->ID != NULL) {
+                    HASHMAP_PUT(manager->menuItems, menuItem->ID, menuItem);
+                }
+            }
+            AddMenuItemToMenu(result, menuItem, manager);
+        }
+
+        if (radioData != NULL) {
+            // Iterate radio groups
+            JsonNode *radioGroup;
+            json_foreach(radioGroup, radioData) {
+                // Get item label
+                processRadioGroup(result, radioGroup, manager);
+            }
+        }
+    }
+
+    return result;
+}
+
+MenuItem* processMenuItem(Menu *menu, JsonNode *item, MenuManager *manager) {
+
+
+    // Get the role
+    const char *role = getJSONString(item, "r");
+    if( role != NULL ) {
+        // Roles override everything else
+//        return NewMenuItemForRole(role, menu, item, manager);
+    }
+
+    Menu* submenu = NULL;
+
+    // Check if this is a submenu
+//    JsonNode *submenuData = json_find_member(item, "S");
+//    if( submenuData != NULL ) {
+//        submenu = NewMenu(submenuData)
+//        // Get the label
+//        JsonNode *menuNameNode = json_find_member(item, "l");
+//        const char *name = "";
+//        if ( menuNameNode != NULL) {
+//            name = menuNameNode->string_;
+//        }
+//
+//        id thisMenuItem = createMenuItemNoAutorelease(str(name), NULL, "");
+//        id thisMenu = createMenu(str(name));
+//
+//        msg(thisMenuItem, s("setSubmenu:"), thisMenu);
+//        msg(parentMenu, s("addItem:"), thisMenuItem);
+//
+//        JsonNode *submenuItems = json_find_member(submenu, "i");
+//        // If we have no items, just return
+//        if ( submenuItems == NULL ) {
+//            return;
+//        }
+//
+//        // Loop over submenu items
+//        JsonNode *item;
+//        json_foreach(item, submenuItems) {
+//            // Get item label
+//            processMenuItem(menu, thisMenu, item);
+//        }
+//
+//        return;
+//    }
+
+
+    // Get the ID
+    const char *menuItemID = mustJSONString(item, "I");
+
+    // Get the label(s)
+    const char* label = getJSONStringDefault(item, "l", "");
+    const char* alternateLabel = getJSONString(item, "L");
+
+    bool checked = getJSONBool(item, "c");
+    bool hidden = getJSONBool(item, "h");
+    bool disabled = getJSONBool(item, "d");
+    const char* RGBA = getJSONString(item, "R");
+    const char* font = getJSONString(item, "F");
+    const char* image = getJSONString(item, "i");
+
+    int fontSize = 0;
+    getJSONInt(item, "F", &fontSize);
+
+    // Get the Accelerator
+    JsonNode *accelerator = json_find_member(item, "a");
+    const char *acceleratorKey = NULL;
+    const char **modifiers = NULL;
+
+    // If we have an accelerator
+    if( accelerator != NULL ) {
+        // Get the key
+        acceleratorKey = getJSONString(accelerator, "Key");
+        // Check if there are modifiers
+        JsonNode *modifiersList = json_find_member(accelerator, "Modifiers");
+        if ( modifiersList != NULL ) {
+            // Allocate an array of strings
+            int noOfModifiers = json_array_length(modifiersList);
+
+            // Do we have any?
+            if (noOfModifiers > 0) {
+                modifiers = malloc(sizeof(const char *) * (noOfModifiers + 1));
+                JsonNode *modifier;
+                int count = 0;
+                // Iterate the modifiers and save a reference to them in our new array
+                json_foreach(modifier, modifiersList) {
+                    // Get modifier name
+                    modifiers[count] = STRCOPY(modifier->string_);
+                    count++;
+                }
+                // Null terminate the modifier list
+                modifiers[count] = NULL;
+            }
+        }
+    }
+
+    // has callback?
+    bool hasCallback = getJSONBool(item, "C");
+
+    // Get the Type
+    const char *type = mustJSONString(item, "t");
+
+    MenuItem* menuItem;
+    enum MenuItemType menuItemType;
+    if( STREQ(type, "t")) {
+        menuItemType = Text;
+    }
+    else if ( STREQ(type, "s")) {
+        menuItemType = Separator;
+    }
+    else if ( STREQ(type, "c")) {
+        menuItemType = Checkbox;
+    }
+    else if ( STREQ(type, "r")) {
+        menuItemType = Radio;
+    } else {
+        menuItemType = -1;
+        ABORT("Unknown Menu Item type '%s'!", type);
+    }
+    menuItem = NewMenuItem(menuItemType, menuItemID, label, alternateLabel, disabled, hidden, checked, RGBA, font, fontSize, image, acceleratorKey, modifiers, hasCallback, submenu);
+    return menuItem;
+}
+
+void DeleteMenu(Menu* menu) {
+
+    // NULL guard
+    if( menu == NULL ) return;
+
+    // Delete the platform specific menu data
+    DeleteMenuPlatformData(menu);
+
+    // Clean up other data
+    MEMFREE(menu->label);
+
+    // Clear the menu items vector
+    vec_deinit(&menu->menuItems);
+}
+
+const char* MenuAsJSON(Menu* menu) {
+
+    if( menu == NULL ) return NULL;
+
+    JsonNode *jsonObject = json_mkobject();
+    JSON_ADD_STRING(jsonObject, "Label", menu->label);
+    return json_encode(jsonObject);
+}
+
+JsonNode* MenuAsJSONObject(Menu* menu) {
+
+    if( menu == NULL ) return NULL;
+
+    JsonNode *jsonObject = json_mkobject();
+    JSON_ADD_STRING(jsonObject, "Label", menu->label);
+    if( vec_size(&menu->menuItems) > 0 ) {
+        JsonNode* items = json_mkarray();
+        int i; MenuItem *menuItem;
+        vec_foreach(&menu->menuItems, menuItem, i) {
+            JSON_ADD_ELEMENT(items, MenuItemAsJSONObject(menuItem));
+        }
+        JSON_ADD_OBJECT(jsonObject, "Items", items);
+    }
+    return jsonObject;
+}
+
+
+void processRadioGroup(Menu *menu, JsonNode *radioGroup, MenuManager* manager) {
+
+    JsonNode *members = json_find_member(radioGroup, "Members");
+    JsonNode *member;
+
+    int groupLength = json_array_length(radioGroup);
+    // Allocate array
+    size_t arrayLength = sizeof(id)*(groupLength+1);
+    MenuItem* memberList[arrayLength];
+
+    // Build the radio group items
+    int count=0;
+    json_foreach(member, members) {
+        // Get menu by id
+        MenuItem* menuItem = HASHMAP_GET(manager->menuItems, (char*)member->string_);
+        // Save Member
+        memberList[count] = menuItem;
+        count = count + 1;
+    }
+    // Null terminate array
+    memberList[groupLength] = 0;
+
+    // Store the members
+    json_foreach(member, members) {
+        // Copy the memberList
+        char *newMemberList = (char *)malloc(arrayLength);
+        memcpy(newMemberList, memberList, arrayLength);
+        // add group to each member of group
+        HASHMAP_PUT(menu->radioGroups, member->string_, newMemberList);
+
+    }
+
+}
+
+void AddMenuItemToMenu(Menu* menu, MenuItem* menuItem, MenuManager* manager) {
+    vec_push(&menu->menuItems, menuItem);
+    PlatformAddMenuItemToMenu(menu, menuItem, manager);
+}
+
+// Creates a JSON message for the given menuItemID and data
+const char* CreateMenuClickedMessage(const char *menuItemID, const char *data) {
+
+    JsonNode *jsonObject = json_mkobject();
+    if (menuItemID == NULL ) {
+        ABORT("Item ID NULL for menu!!\n");
+    }
+    json_append_member(jsonObject, "i", json_mkstring(menuItemID));
+    if (data != NULL) {
+        json_append_member(jsonObject, "data", json_mkstring(data));
+    }
+    const char *payload = json_encode(jsonObject);
+    json_delete(jsonObject);
+    const char *result = concat("MC", payload);
+    MEMFREE(payload);
+    return result;
+}

v2/internal/ffenestri/menu.go

@@ -1,80 +0,0 @@
-package ffenestri
-
-import "github.com/wailsapp/wails/v2/pkg/menu"
-
-// ProcessedMenu is the original menu with the addition
-// of radio groups extracted from the menu data
-type ProcessedMenu struct {
-	Menu              *menu.Menu
-	RadioGroups       []*RadioGroup
-	currentRadioGroup []string
-}
-
-// RadioGroup holds all the members of the same radio group
-type RadioGroup struct {
-	Members []string
-	Length  int
-}
-
-// NewProcessedMenu processed the given menu and returns
-// the original menu with the extracted radio groups
-func NewProcessedMenu(menu *menu.Menu) *ProcessedMenu {
-	result := &ProcessedMenu{
-		Menu:              menu,
-		RadioGroups:       []*RadioGroup{},
-		currentRadioGroup: []string{},
-	}
-
-	result.processMenu()
-
-	return result
-}
-
-func (p *ProcessedMenu) processMenu() {
-	// Loop over top level menus
-	for _, item := range p.Menu.Items {
-		// Process MenuItem
-		p.processMenuItem(item)
-	}
-
-	p.finaliseRadioGroup()
-}
-
-func (p *ProcessedMenu) processMenuItem(item *menu.MenuItem) {
-
-	switch item.Type {
-
-	// We need to recurse submenus
-	case menu.SubmenuType:
-
-		// Finalise any current radio groups as they don't trickle down to submenus
-		p.finaliseRadioGroup()
-
-		// Process each submenu item
-		for _, subitem := range item.SubMenu {
-			p.processMenuItem(subitem)
-		}
-	case menu.RadioType:
-		// Add the item to the radio group
-		p.currentRadioGroup = append(p.currentRadioGroup, item.ID)
-	default:
-		p.finaliseRadioGroup()
-	}
-}
-
-func (p *ProcessedMenu) finaliseRadioGroup() {
-
-	// If we were processing a radio group, fix up the references
-	if len(p.currentRadioGroup) > 0 {
-
-		// Create new radiogroup
-		group := &RadioGroup{
-			Members: p.currentRadioGroup,
-			Length:  len(p.currentRadioGroup),
-		}
-		p.RadioGroups = append(p.RadioGroups, group)
-
-		// Empty the radio group
-		p.currentRadioGroup = []string{}
-	}
-}

v2/internal/ffenestri/menu.h

@@ -0,0 +1,178 @@
+//
+// Created by Lea Anthony on 18/1/21.
+//
+
+#ifndef MENU_H
+#define MENU_H
+
+#include "common.h"
+
+enum MenuItemType {Text = 0, Checkbox = 1, Radio = 2, Separator = 3};
+static const char *MenuItemTypeAsString[] = {
+        "Text", "Checkbox", "Radio", "Separator",
+};
+
+enum MenuType {ApplicationMenuType = 0, ContextMenuType = 1, TrayMenuType = 2};
+static const char *MenuTypeAsString[] = {
+        "ApplicationMenu", "ContextMenu", "TrayMenu",
+};
+
+
+
+typedef struct {
+
+    // Menu label
+    const char *label;
+
+    // A list of menuItem IDs that make up this menu
+    vec_void_t menuItems;
+
+    // The platform specific menu data
+    void *platformData;
+
+} Menu;
+
+typedef struct {
+
+    // ID of the tray
+    const char *ID;
+
+    // The tray label
+    const char *Label;
+
+    // The icon name
+    const char *Icon;
+
+    // The menu
+    Menu* Menu;
+
+    // Platform specific data
+    void* platformData;
+
+} TrayMenu;
+
+typedef struct {
+
+    Menu* menu;
+
+} ApplicationMenu;
+
+typedef struct {
+
+    const char* ID;
+
+    Menu* menu;
+
+} ContextMenu;
+
+typedef struct {
+
+    // This is our menu item map using the menuItem ID as a key
+    // map[string]*MenuItem
+    struct hashmap_s menuItems;
+
+    // This is our context menu map using the context menu ID as a key
+    // map[string]*ContextMenu
+    struct hashmap_s contextMenus;
+
+    // This is our tray menu map using the tray menu ID as a key
+    // map[string]*TrayMenu
+    struct hashmap_s trayMenus;
+
+    // Application Menu
+    Menu* applicationMenu;
+
+    // Context menu data
+    const char* contextMenuData;
+
+} MenuManager;
+
+
+typedef struct {
+    MenuManager* manager;
+    const char *menuItemID;
+    enum MenuItemType menuItemType;
+} MenuItemCallbackData;
+
+typedef struct {
+    const char *ID;
+    const char* label;
+    const char* alternateLabel;
+    bool disabled;
+    bool hidden;
+    const char* colour;
+    const char* font;
+    int fontSize;
+    const char* image;
+    bool checked;
+
+    // Keyboard shortcut
+    const char* acceleratorKey;
+    const char** modifiers;
+
+    // Type of menuItem
+    enum MenuItemType type;
+
+    // Indicates if the menuItem has a callback
+    bool hasCallback;
+
+    // The platform specific menu data
+    void* platformData;
+
+    // Submenu
+    Menu* submenu;
+
+    // Radio group for this item
+    vec_void_t radioGroup;
+
+    // Data for handling callbacks
+    MenuItemCallbackData *callbackData;
+
+} MenuItem;
+
+// MenuItem
+MenuItem* NewMenuItem(enum MenuItemType type, const char* ID, const char* label, const char* alternateLabel, bool disabled, bool hidden, bool checked, const char* colour, const char* font, int fontsize, const char* image, const char* acceleratorKey, const char** modifiers, bool hasCallback, Menu* submenu);
+void DeleteMenuItem(MenuItem* menuItem);
+JsonNode* MenuItemAsJSONObject(MenuItem* menuItem);
+
+// Menu
+Menu* NewMenu(JsonNode* menuData, JsonNode* radioData, MenuManager* menuManager);
+void DeleteMenu(Menu* menu);
+const char* MenuAsJSON(Menu* menu);
+JsonNode* MenuAsJSONObject(Menu* menu);
+void AddMenuItemToMenu(Menu* menu, MenuItem* menuItem, MenuManager* manager);
+MenuItem* processMenuItem(Menu *menu, JsonNode *item, MenuManager *manager);
+void processRadioGroup(Menu *menu, JsonNode *radioGroup, MenuManager* manager);
+
+// Tray
+TrayMenu* NewTrayMenu(JsonNode* trayJSON, MenuManager *manager);
+void DeleteTrayMenu(TrayMenu *trayMenu);
+const char* TrayMenuAsJSON(TrayMenu* menu);
+
+// MenuManager
+MenuManager* NewMenuManager();
+void DeleteMenuManager(MenuManager* manager);
+TrayMenu* AddTrayMenuToManager(MenuManager* manager, const char* trayMenuJSON);
+void ShowTrayMenus(MenuManager* manager);
+
+// Callbacks
+MenuItemCallbackData* NewMenuItemCallbackData(MenuManager *manager, const char* menuItemID, enum MenuItemType menuItemType);
+void DeleteMenuItemCallbackData(MenuItemCallbackData* callbackData);
+const char* CreateMenuClickedMessage(const char *menuItemID, const char *data);
+
+// Platform
+void SetupMenuPlatformData(Menu* menu);
+void DeleteMenuPlatformData(Menu* menu);
+void SetupMenuItemPlatformData(MenuItem* menuItem);
+void DeleteMenuItemPlatformData(MenuItem* menuItem);
+void SetupTrayMenuPlatformData(TrayMenu* menu);
+void DeleteTrayMenuPlatformData(TrayMenu* menu);
+void PlatformAddMenuItemToMenu(Menu *menu, MenuItem* menuItem, MenuManager* manager);
+void PlatformUpdateTrayIcon(TrayMenu *menu);
+
+// Platform specific methods
+void UnloadTrayIcons();
+void LoadTrayIcons();
+void ShowTrayMenu(TrayMenu* trayMenu);
+
+#endif //MENU_H

v2/internal/ffenestri/menu_darwin.c

@@ -0,0 +1,518 @@
+//
+// Created by Lea Anthony on 18/1/21.
+//
+
+#include "ffenestri.h"
+#include "ffenestri_darwin.h"
+#include "menu_darwin.h"
+#include "menu.h"
+#include "trayicons.h"
+
+// A cache for all our tray menu icons
+// Global because it's a singleton
+struct hashmap_s trayIconCache;
+
+void SetupMenuPlatformData(Menu* menu) {
+    MacMenu* result = NEW(MacMenu);
+    result->Menu = ALLOC("NSMenu");
+    msg(result->Menu, s("initWithTitle:"), str(menu->label));
+    msg(result->Menu, s("setAutoenablesItems:"), NO);
+    menu->platformData = (void*)result;
+}
+
+void DeleteMenuPlatformData(Menu* menu) {
+
+    // Return if null
+    if( menu == NULL || menu->platformData == NULL) return;
+
+    MacMenu* macMenu = (MacMenu*) menu->platformData;
+    RELEASE(macMenu->Menu);
+    macMenu->Menu = NULL;
+}
+
+
+id processAcceleratorKey(const char *key) {
+
+    // Guard against no accelerator key
+    if( key == NULL ) {
+        return str("");
+    }
+
+    if( STREQ(key, "Backspace") ) {
+        return strunicode(0x0008);
+    }
+    if( STREQ(key, "Tab") ) {
+        return strunicode(0x0009);
+    }
+    if( STREQ(key, "Return") ) {
+        return strunicode(0x000d);
+    }
+    if( STREQ(key, "Escape") ) {
+        return strunicode(0x001b);
+    }
+    if( STREQ(key, "Left") ) {
+        return strunicode(0x001c);
+    }
+    if( STREQ(key, "Right") ) {
+        return strunicode(0x001d);
+    }
+    if( STREQ(key, "Up") ) {
+        return strunicode(0x001e);
+    }
+    if( STREQ(key, "Down") ) {
+        return strunicode(0x001f);
+    }
+    if( STREQ(key, "Space") ) {
+        return strunicode(0x0020);
+    }
+    if( STREQ(key, "Delete") ) {
+        return strunicode(0x007f);
+    }
+    if( STREQ(key, "Home") ) {
+        return strunicode(0x2196);
+    }
+    if( STREQ(key, "End") ) {
+        return strunicode(0x2198);
+    }
+    if( STREQ(key, "Page Up") ) {
+        return strunicode(0x21de);
+    }
+    if( STREQ(key, "Page Down") ) {
+        return strunicode(0x21df);
+    }
+    if( STREQ(key, "F1") ) {
+        return strunicode(0xf704);
+    }
+    if( STREQ(key, "F2") ) {
+        return strunicode(0xf705);
+    }
+    if( STREQ(key, "F3") ) {
+        return strunicode(0xf706);
+    }
+    if( STREQ(key, "F4") ) {
+        return strunicode(0xf707);
+    }
+    if( STREQ(key, "F5") ) {
+        return strunicode(0xf708);
+    }
+    if( STREQ(key, "F6") ) {
+        return strunicode(0xf709);
+    }
+    if( STREQ(key, "F7") ) {
+        return strunicode(0xf70a);
+    }
+    if( STREQ(key, "F8") ) {
+        return strunicode(0xf70b);
+    }
+    if( STREQ(key, "F9") ) {
+        return strunicode(0xf70c);
+    }
+    if( STREQ(key, "F10") ) {
+        return strunicode(0xf70d);
+    }
+    if( STREQ(key, "F11") ) {
+        return strunicode(0xf70e);
+    }
+    if( STREQ(key, "F12") ) {
+        return strunicode(0xf70f);
+    }
+    if( STREQ(key, "F13") ) {
+        return strunicode(0xf710);
+    }
+    if( STREQ(key, "F14") ) {
+        return strunicode(0xf711);
+    }
+    if( STREQ(key, "F15") ) {
+        return strunicode(0xf712);
+    }
+    if( STREQ(key, "F16") ) {
+        return strunicode(0xf713);
+    }
+    if( STREQ(key, "F17") ) {
+        return strunicode(0xf714);
+    }
+    if( STREQ(key, "F18") ) {
+        return strunicode(0xf715);
+    }
+    if( STREQ(key, "F19") ) {
+        return strunicode(0xf716);
+    }
+    if( STREQ(key, "F20") ) {
+        return strunicode(0xf717);
+    }
+    if( STREQ(key, "F21") ) {
+        return strunicode(0xf718);
+    }
+    if( STREQ(key, "F22") ) {
+        return strunicode(0xf719);
+    }
+    if( STREQ(key, "F23") ) {
+        return strunicode(0xf71a);
+    }
+    if( STREQ(key, "F24") ) {
+        return strunicode(0xf71b);
+    }
+    if( STREQ(key, "F25") ) {
+        return strunicode(0xf71c);
+    }
+    if( STREQ(key, "F26") ) {
+        return strunicode(0xf71d);
+    }
+    if( STREQ(key, "F27") ) {
+        return strunicode(0xf71e);
+    }
+    if( STREQ(key, "F28") ) {
+        return strunicode(0xf71f);
+    }
+    if( STREQ(key, "F29") ) {
+        return strunicode(0xf720);
+    }
+    if( STREQ(key, "F30") ) {
+        return strunicode(0xf721);
+    }
+    if( STREQ(key, "F31") ) {
+        return strunicode(0xf722);
+    }
+    if( STREQ(key, "F32") ) {
+        return strunicode(0xf723);
+    }
+    if( STREQ(key, "F33") ) {
+        return strunicode(0xf724);
+    }
+    if( STREQ(key, "F34") ) {
+        return strunicode(0xf725);
+    }
+    if( STREQ(key, "F35") ) {
+        return strunicode(0xf726);
+    }
+//  if( STREQ(key, "Insert") ) {
+//	return strunicode(0xf727);
+//  }
+//  if( STREQ(key, "PrintScreen") ) {
+//	return strunicode(0xf72e);
+//  }
+//  if( STREQ(key, "ScrollLock") ) {
+//	return strunicode(0xf72f);
+//  }
+    if( STREQ(key, "NumLock") ) {
+        return strunicode(0xf739);
+    }
+
+    return str(key);
+}
+
+// This converts a string array of modifiers into the
+// equivalent MacOS Modifier Flags
+unsigned long parseModifiers(const char **modifiers) {
+
+    // Our result is a modifier flag list
+    unsigned long result = 0;
+
+    const char *thisModifier = modifiers[0];
+    int count = 0;
+    while( thisModifier != NULL ) {
+        // Determine flags
+        if( STREQ(thisModifier, "CmdOrCtrl") ) {
+            result |= NSEventModifierFlagCommand;
+        }
+        if( STREQ(thisModifier, "OptionOrAlt") ) {
+            result |= NSEventModifierFlagOption;
+        }
+        if( STREQ(thisModifier, "Shift") ) {
+            result |= NSEventModifierFlagShift;
+        }
+        if( STREQ(thisModifier, "Super") ) {
+            result |= NSEventModifierFlagCommand;
+        }
+        if( STREQ(thisModifier, "Control") ) {
+            result |= NSEventModifierFlagControl;
+        }
+        count++;
+        thisModifier = modifiers[count];
+    }
+    return result;
+}
+
+
+
+void SetupMenuItemPlatformData(MenuItem* menuItem) {
+
+    // Create the platform data
+    MacMenuItem *macMenuItem = NEW(MacMenuItem);
+
+    menuItem->platformData = macMenuItem;
+
+    // Create the NSMenuItem
+    id item = ALLOC("NSMenuItem");
+    macMenuItem->MenuItem = item;
+
+//    // TODO: Process ROLE
+//    if( menuItem->role != NULL ) {
+//
+//    }
+
+    id key = processAcceleratorKey(menuItem->acceleratorKey);
+    msg(item, s("initWithTitle:action:keyEquivalent:"), str(menuItem->label),
+        s("menuItemCallback:"), key);
+
+    msg(item, s("setEnabled:"), !menuItem->disabled);
+    msg(item, s("autorelease"));
+
+    // Process modifiers
+    if( menuItem->modifiers != NULL ) {
+        unsigned long modifierFlags = parseModifiers(menuItem->modifiers);
+        msg(item, s("setKeyEquivalentModifierMask:"), modifierFlags);
+        menuItem->modifiers = NULL;
+    }
+
+}
+
+void DeleteMenuItemPlatformData(MenuItem* menuItem) {
+
+    if( menuItem == NULL || menuItem->platformData == NULL) return;
+
+    MacMenuItem* macMenuItem = (MacMenuItem*) menuItem->platformData;
+    RELEASE(macMenuItem->MenuItem);
+
+    MEMFREE(macMenuItem);
+
+}
+
+void PlatformAddMenuItemToMenu(Menu *menu, MenuItem* menuItem, MenuManager* manager) {
+
+    // Return if null
+    if( menu == NULL || menu->platformData == NULL) return;
+    if( menuItem == NULL || menuItem->platformData == NULL) return;
+
+    // Don't add if the item is hidden
+    if( menuItem->hidden ) return;
+
+    // Setup callback
+    if( menuItem->hasCallback ) {
+        // Create a MenuItemCallbackData
+        MacMenuItem* macMenuItem = (MacMenuItem*) menuItem->platformData;
+        menuItem->callbackData = NewMenuItemCallbackData(manager, menuItem->ID, Text);
+
+        id wrappedId = msg(c("NSValue"), s("valueWithPointer:"), menuItem->callbackData);
+        msg(macMenuItem->MenuItem, s("setRepresentedObject:"), wrappedId);
+    }
+
+    MacMenu* macMenu = (MacMenu*) menu->platformData;
+    MacMenuItem* macMenuItem = (MacMenuItem*) menuItem->platformData;
+
+    msg(macMenu->Menu, s("addItem:"), macMenuItem->MenuItem);
+
+}
+
+void SetupTrayMenuPlatformData(TrayMenu* menu) {
+    MacTrayMenu* result = NEW(MacTrayMenu);
+    result->statusBarItem = NULL;
+
+    // TODO: Work out how to make this customisable
+    result->iconPosition = NSImageLeft;
+
+    menu->platformData = (void*)result;
+}
+
+void DeleteTrayMenuPlatformData(TrayMenu* menu) {
+
+    // Return if null
+    if( menu == NULL || menu->platformData == NULL) return;
+
+    MacTrayMenu* macMenu = (MacTrayMenu*) menu->platformData;
+    RELEASE(macMenu->statusBarItem);
+    macMenu->statusBarItem = NULL;
+}
+
+
+void PlatformUpdateTrayIcon(TrayMenu* trayMenu) {
+
+    MacTrayMenu* macTrayMenu = (MacTrayMenu*) trayMenu->platformData;
+
+    id statusBarButton = msg(macTrayMenu->statusBarItem, s("button"));
+
+    // Empty icon means remove it
+    if (trayMenu->Icon == NULL || strlen(trayMenu->Icon) == 0) {
+        msg(statusBarButton, s("setImage:"), NULL);
+        return;
+    }
+
+    id trayImage = HASHMAP_GET(trayIconCache, trayMenu->Icon);
+    msg(statusBarButton, s("setImagePosition:"), macTrayMenu->iconPosition);
+    msg(statusBarButton, s("setImage:"), trayImage);
+}
+
+void UpdateTrayLabel(TrayMenu *trayMenu, const char *label) {
+
+    // Exit early if NULL
+    if( trayMenu->Label == NULL ) return;
+
+    // Update button label
+    MacTrayMenu* macTrayMenu = (MacTrayMenu*) trayMenu->platformData;
+    id statusBarButton = msg(macTrayMenu->statusBarItem, s("button"));
+    msg(statusBarButton, s("setTitle:"), str(label));
+}
+
+void ShowTrayMenu(TrayMenu* trayMenu) {
+
+    if( trayMenu == NULL || trayMenu->platformData == NULL ) return;
+
+    MacTrayMenu* macTrayMenu = (MacTrayMenu*) trayMenu->platformData;
+
+    // Create a status bar item if we don't have one
+    if( macTrayMenu->statusBarItem == NULL ) {
+        id statusBar = msg( c("NSStatusBar"), s("systemStatusBar") );
+        macTrayMenu->statusBarItem = msg(statusBar, s("statusItemWithLength:"), NSVariableStatusItemLength);
+        msg(macTrayMenu->statusBarItem, s("retain"));
+    }
+
+    id statusBarButton = msg(macTrayMenu->statusBarItem, s("button"));
+    msg(statusBarButton, s("setImagePosition:"), macTrayMenu->iconPosition);
+
+    // Update the icon if needed
+    PlatformUpdateTrayIcon(trayMenu);
+
+    // Update the label if needed
+    UpdateTrayLabel(trayMenu, trayMenu->Label);
+
+    // If we don't have a menu, return
+    if( trayMenu->Menu == NULL ) return;
+
+    // Update the menu
+    MacMenu* macMenu = (MacMenu*) trayMenu->Menu->platformData;
+    msg(macTrayMenu->statusBarItem, s("setMenu:"), macMenu->Menu);
+}
+
+void LoadTrayIcons() {
+
+    // Allocate the Tray Icons
+    if( 0 != hashmap_create((const unsigned)4, &trayIconCache)) {
+        // Couldn't allocate map
+        ABORT("Not enough memory to allocate trayIconCache!");
+    }
+
+    unsigned int count = 0;
+    while( 1 ) {
+        const unsigned char *name = trayIcons[count++];
+        if( name == 0x00 ) {
+            break;
+        }
+        const unsigned char *lengthAsString = trayIcons[count++];
+        if( name == 0x00 ) {
+            break;
+        }
+        const unsigned char *data = trayIcons[count++];
+        if( data == 0x00 ) {
+            break;
+        }
+        char *c;
+        unsigned long length = strtol((const char *)lengthAsString, &c, 10);
+
+        // Create the icon and add to the hashmap
+        id imageData = msg(c("NSData"), s("dataWithBytes:length:"), data, length);
+        id trayImage = ALLOC("NSImage");
+        msg(trayImage, s("initWithData:"), imageData);
+        HASHMAP_PUT(trayIconCache, (const char *)name, trayImage);
+    }
+}
+
+void UnloadTrayIcons() {
+    // Release the tray cache images
+    HASHMAP_ITERATE(trayIconCache, releaseNSObject, NULL);
+    HASHMAP_DESTROY(trayIconCache);
+}
+//
+//// Callback for text menu items
+//void menuItemCallback(id self, SEL cmd, id sender) {
+//    MenuItemCallbackData *callbackData = (MenuItemCallbackData *)msg(msg(sender, s("representedObject")), s("pointerValue"));
+//    if( callbackData == NULL) {
+//        return;
+//    }
+//
+//    struct TrayMenuStore *store = callbackData->store;
+//    const char* menuItemID = callbackData->menuItemID;
+//    id nsmenu = GetMenuItemFromStore((TrayMenuStore *) store, menuItemID);
+//    if ( nsmenu == NULL ) {
+//        // The menu has been deleted!
+//        return;
+//    }
+//
+//    const char *message;
+//
+//    // Update checkbox / radio item
+//    if( callbackData->menuItemType == Checkbox) {
+//        // Toggle state
+//        bool state = msg(nsmenu, s("state"));
+//        msg(nsmenu, s("setState:"), (state? NSControlStateValueOff : NSControlStateValueOn));
+//    } else if( callbackData->menuItemType == Radio ) {
+//        // Check the menu items' current state
+//        bool selected = msg(nsmenu, s("state"));
+//
+//        // If it's already selected, exit early
+//        if (selected) return;
+//
+//        // Get this item's radio group members and turn them off
+//        id *members = (id*)hashmap_get(&(callbackData->menu->radioGroupMap), (char*)callbackData->menuItemID, strlen(callbackData->menuItemID));
+//
+//        // Uncheck all members of the group
+//        id thisMember = members[0];
+//        int count = 0;
+//        while(thisMember != NULL) {
+//            msg(thisMember, s("setState:"), NSControlStateValueOff);
+//            count = count + 1;
+//            thisMember = members[count];
+//        }
+//
+//        // check the selected menu item
+//        msg(nsmenu, s("setState:"), NSControlStateValueOn);
+//    }
+//
+//    message = createMenuClickedMessage(menuItemID, GetContextMenuDataFromStore((TrayMenuStore *) store));
+//
+//    // Notify the backend
+//    messageFromWindowCallback(message);
+//    MEMFREE(message);
+//}
+
+void PlatformMenuItemCallback(id self, SEL cmd, id sender) {
+    MenuItemCallbackData *callbackData = (MenuItemCallbackData *)msg(msg(sender, s("representedObject")), s("pointerValue"));
+    const char *message;
+
+    MenuManager* manager = callbackData->manager;
+    MenuItem* menuItem = HASHMAP_GET(manager->menuItems, callbackData->menuItemID);
+
+    if( menuItem == NULL ) return;
+
+    MacMenuItem *macMenuItem = menuItem->platformData;
+    id nsMenuItem = macMenuItem->MenuItem;
+
+    // Update checkbox / radio item
+    if( callbackData->menuItemType == Checkbox) {
+        // Toggle state
+        bool state = msg(nsMenuItem, s("state"));
+        msg(nsMenuItem, s("setState:"), (state? NSControlStateValueOff : NSControlStateValueOn));
+    } else if( callbackData->menuItemType == Radio ) {
+        // Check the menu items' current state
+        bool selected = msg(nsMenuItem, s("state"));
+
+        // If it's already selected, exit early
+        if (selected) return;
+
+        int i=0; const char *groupMenuItemID;
+        vec_foreach(&menuItem->radioGroup, groupMenuItemID, i) {
+            // Get member
+            MenuItem* groupMember = HASHMAP_GET(manager->menuItems, groupMenuItemID);
+            MacMenuItem* groupMacMenuItem = (MacMenuItem*) groupMember->platformData;
+            msg(groupMacMenuItem->MenuItem, s("setState:"), NSControlStateValueOff);
+        }
+
+        // check the selected menu item
+        msg(nsMenuItem, s("setState:"), NSControlStateValueOn);
+    }
+
+    message = CreateMenuClickedMessage(callbackData->menuItemID, manager->contextMenuData);
+
+    // Notify the backend
+    messageFromWindowCallback(message);
+    MEMFREE(message);
+}

v2/internal/ffenestri/menu_darwin.h

@@ -0,0 +1,21 @@
+//
+// Created by Lea Anthony on 18/1/21.
+//
+
+#include "common.h"
+#include "menu.h"
+
+typedef struct {
+    id Menu;
+} MacMenu;
+
+typedef struct {
+    id MenuItem;
+} MacMenuItem;
+
+typedef struct {
+    id statusBarItem;
+    int iconPosition;
+} MacTrayMenu;
+
+void PlatformMenuItemCallback(id self, SEL cmd, id sender);

v2/internal/ffenestri/menu_darwin_old.c

@@ -0,0 +1,542 @@
+//
+// Created by Lea Anthony on 6/1/21.
+//
+
+#include "ffenestri_darwin.h"
+#include "menu_darwin_old.h"
+#include "contextmenus_darwin.h"
+#include "traymenustore_darwin.h"
+
+// NewMenu creates a new Menu struct, saving the given menu structure as JSON
+Menu* NewMenu(JsonNode *menuData, JsonNode *radioGroups, struct TrayMenuStore *store) {
+
+    Menu *result = malloc(sizeof(Menu));
+
+    // No title by default
+    result->title = "";
+
+    // Initialise menuCallbackDataCache
+    vec_init(&result->callbackDataCache);
+
+    // Allocate MenuItem Map
+    if( 0 != hashmap_create((const unsigned)16, &result->menuItemMap)) {
+        ABORT("[NewMenu] Not enough memory to allocate menuItemMap!");
+    }
+    // Allocate the Radio Group Map
+    if( 0 != hashmap_create((const unsigned)4, &result->radioGroupMap)) {
+        ABORT("[NewMenu] Not enough memory to allocate radioGroupMap!");
+    }
+
+    // Init other members
+    result->menu = NULL;
+    result->store = store;
+
+    // Process the menu
+    ProcessMenu(result, menuData, radioGroups);
+
+    return result;
+}
+
+Menu* NewApplicationMenu(const char *menuAsJSON, struct TrayMenuStore *store) {
+
+    // Parse the menu json
+    JsonNode *processedMenu = json_decode(menuAsJSON);
+    if( processedMenu == NULL ) {
+        // Parse error!
+        ABORT("Unable to parse Menu JSON: %s", menuAsJSON);
+    }
+
+    // TODO - fixup
+    Menu *result = NewMenu(processedMenu, NULL, store);
+    result->menuType = ApplicationMenuType;
+    return result;
+}
+
+//TODO: Put traymenu store in callback instead of menu as it'll never be null
+MenuItemCallbackData* CreateMenuItemCallbackData(Menu *menu, const char *menuItemID, enum MenuItemType menuItemType) {
+    MenuItemCallbackData* result = malloc(sizeof(MenuItemCallbackData));
+
+    result->store = menu->store;
+    result->menuItemID = STRCOPY(menuItemID);
+    result->menuItemType = menuItemType;
+
+    // Store reference to this so we can destroy later
+    vec_push(&menu->callbackDataCache, result);
+
+    return result;
+}
+
+
+
+void DeleteMenu(Menu *menu) {
+
+    if( menu == NULL ) {
+        return;
+    }
+
+    // Free menu item hashmap
+    hashmap_destroy(&menu->menuItemMap);
+
+    // Free radio group members
+    if( hashmap_num_entries(&menu->radioGroupMap) > 0 ) {
+        if (0 != hashmap_iterate_pairs(&menu->radioGroupMap, freeHashmapItem, NULL)) {
+            ABORT("[DeleteMenu] Failed to release radioGroupMap entries!");
+        }
+    }
+
+    // Free radio groups hashmap
+    hashmap_destroy(&menu->radioGroupMap);
+
+    // Release the callback cache memory
+    int i; MenuItemCallbackData *callback;
+    vec_foreach(&menu->callbackDataCache, callback, i) {
+            MEMFREE(callback->menuItemID);
+    }
+    vec_deinit(&menu->callbackDataCache);
+
+    // Free nsmenu if we have it
+    if ( menu->menu != NULL ) {
+        msg(menu->menu, s("release"));
+    }
+
+    free(menu);
+}
+
+
+
+
+
+
+void addSeparator(id menu) {
+    id item = msg(c("NSMenuItem"), s("separatorItem"));
+    msg(menu, s("addItem:"), item);
+}
+
+id createMenuItemNoAutorelease( id title, const char *action, const char *key) {
+    id item = ALLOC("NSMenuItem");
+    msg(item, s("initWithTitle:action:keyEquivalent:"), title, s(action), str(key));
+    return item;
+}
+
+id createMenuItem(id title, const char *action, const char *key) {
+    id item = ALLOC("NSMenuItem");
+    msg(item, s("initWithTitle:action:keyEquivalent:"), title, s(action), str(key));
+    msg(item, s("autorelease"));
+    return item;
+}
+
+id addMenuItem(id menu, const char *title, const char *action, const char *key, bool disabled) {
+    id item = createMenuItem(str(title), action, key);
+    msg(item, s("setEnabled:"), !disabled);
+    msg(menu, s("addItem:"), item);
+    return item;
+}
+
+id createMenu(id title) {
+    id menu = ALLOC("NSMenu");
+    msg(menu, s("initWithTitle:"), title);
+    msg(menu, s("setAutoenablesItems:"), NO);
+//  msg(menu, s("autorelease"));
+    return menu;
+}
+
+void createDefaultAppMenu(id parentMenu) {
+// App Menu
+    id appName = msg(msg(c("NSProcessInfo"), s("processInfo")), s("processName"));
+    id appMenuItem = createMenuItemNoAutorelease(appName, NULL, "");
+    id appMenu = createMenu(appName);
+
+    msg(appMenuItem, s("setSubmenu:"), appMenu);
+    msg(parentMenu, s("addItem:"), appMenuItem);
+
+    id title = msg(str("Hide "), s("stringByAppendingString:"), appName);
+    id item = createMenuItem(title, "hide:", "h");
+    msg(appMenu, s("addItem:"), item);
+
+    id hideOthers = addMenuItem(appMenu, "Hide Others", "hideOtherApplications:", "h", FALSE);
+    msg(hideOthers, s("setKeyEquivalentModifierMask:"), (NSEventModifierFlagOption | NSEventModifierFlagCommand));
+
+    addMenuItem(appMenu, "Show All", "unhideAllApplications:", "", FALSE);
+
+    addSeparator(appMenu);
+
+    title = msg(str("Quit "), s("stringByAppendingString:"), appName);
+    item = createMenuItem(title, "terminate:", "q");
+    msg(appMenu, s("addItem:"), item);
+}
+
+void createDefaultEditMenu(id parentMenu) {
+    // Edit Menu
+    id editMenuItem = createMenuItemNoAutorelease(str("Edit"), NULL, "");
+    id editMenu = createMenu(str("Edit"));
+
+    msg(editMenuItem, s("setSubmenu:"), editMenu);
+    msg(parentMenu, s("addItem:"), editMenuItem);
+
+    addMenuItem(editMenu, "Undo", "undo:", "z", FALSE);
+    addMenuItem(editMenu, "Redo", "redo:", "y", FALSE);
+    addSeparator(editMenu);
+    addMenuItem(editMenu, "Cut", "cut:", "x", FALSE);
+    addMenuItem(editMenu, "Copy", "copy:", "c", FALSE);
+    addMenuItem(editMenu, "Paste", "paste:", "v", FALSE);
+    addMenuItem(editMenu, "Select All", "selectAll:", "a", FALSE);
+}
+
+void processMenuRole(Menu *menu, id parentMenu, JsonNode *item) {
+    const char *roleName = item->string_;
+
+    if ( STREQ(roleName, "appMenu") ) {
+        createDefaultAppMenu(parentMenu);
+        return;
+    }
+    if ( STREQ(roleName, "editMenu")) {
+        createDefaultEditMenu(parentMenu);
+        return;
+    }
+    if ( STREQ(roleName, "hide")) {
+        addMenuItem(parentMenu, "Hide Window", "hide:", "h", FALSE);
+        return;
+    }
+    if ( STREQ(roleName, "hideothers")) {
+        id hideOthers = addMenuItem(parentMenu, "Hide Others", "hideOtherApplications:", "h", FALSE);
+        msg(hideOthers, s("setKeyEquivalentModifierMask:"), (NSEventModifierFlagOption | NSEventModifierFlagCommand));
+        return;
+    }
+    if ( STREQ(roleName, "unhide")) {
+        addMenuItem(parentMenu, "Show All", "unhideAllApplications:", "", FALSE);
+        return;
+    }
+    if ( STREQ(roleName, "front")) {
+        addMenuItem(parentMenu, "Bring All to Front", "arrangeInFront:", "", FALSE);
+        return;
+    }
+    if ( STREQ(roleName, "undo")) {
+        addMenuItem(parentMenu, "Undo", "undo:", "z", FALSE);
+        return;
+    }
+    if ( STREQ(roleName, "redo")) {
+        addMenuItem(parentMenu, "Redo", "redo:", "y", FALSE);
+        return;
+    }
+    if ( STREQ(roleName, "cut")) {
+        addMenuItem(parentMenu, "Cut", "cut:", "x", FALSE);
+        return;
+    }
+    if ( STREQ(roleName, "copy")) {
+        addMenuItem(parentMenu, "Copy", "copy:", "c", FALSE);
+        return;
+    }
+    if ( STREQ(roleName, "paste")) {
+        addMenuItem(parentMenu, "Paste", "paste:", "v", FALSE);
+        return;
+    }
+    if ( STREQ(roleName, "delete")) {
+        addMenuItem(parentMenu, "Delete", "delete:", "", FALSE);
+        return;
+    }
+    if( STREQ(roleName, "pasteandmatchstyle")) {
+        id pasteandmatchstyle = addMenuItem(parentMenu, "Paste and Match Style", "pasteandmatchstyle:", "v", FALSE);
+        msg(pasteandmatchstyle, s("setKeyEquivalentModifierMask:"), (NSEventModifierFlagOption | NSEventModifierFlagShift | NSEventModifierFlagCommand));
+    }
+    if ( STREQ(roleName, "selectall")) {
+        addMenuItem(parentMenu, "Select All", "selectAll:", "a", FALSE);
+        return;
+    }
+    if ( STREQ(roleName, "minimize")) {
+        addMenuItem(parentMenu, "Minimize", "miniaturize:", "m", FALSE);
+        return;
+    }
+    if ( STREQ(roleName, "zoom")) {
+        addMenuItem(parentMenu, "Zoom", "performZoom:", "", FALSE);
+        return;
+    }
+    if ( STREQ(roleName, "quit")) {
+        addMenuItem(parentMenu, "Quit (More work TBD)", "terminate:", "q", FALSE);
+        return;
+    }
+    if ( STREQ(roleName, "togglefullscreen")) {
+        addMenuItem(parentMenu, "Toggle Full Screen", "toggleFullScreen:", "f", FALSE);
+        return;
+    }
+
+}
+
+
+
+id processRadioMenuItem(Menu *menu, id parentmenu, const char *title, const char *menuItemID, bool disabled, bool checked, const char *acceleratorkey, bool hascallback) {
+    id item = ALLOC("NSMenuItem");
+
+    // Store the item in the menu item map
+//    hashmap_put(&menu->menuItemMap, (char*)menuItemID, strlen(menuItemID), item);
+
+    SaveMenuItemInStore((TrayMenuStore *) menu->store, menuItemID, item);
+
+    if( hascallback ) {
+        // Create a MenuItemCallbackData
+        MenuItemCallbackData *callback = CreateMenuItemCallbackData(menu, menuItemID, Radio);
+
+        id wrappedId = msg(c("NSValue"), s("valueWithPointer:"), callback);
+        msg(item, s("setRepresentedObject:"), wrappedId);
+    }
+
+
+    id key = processAcceleratorKey(acceleratorkey);
+
+    msg(item, s("initWithTitle:action:keyEquivalent:"), str(title), s("menuItemCallback:"), key);
+
+    msg(item, s("setEnabled:"), !disabled);
+    msg(item, s("autorelease"));
+    msg(item, s("setState:"), (checked ? NSControlStateValueOn : NSControlStateValueOff));
+
+    msg(parentmenu, s("addItem:"), item);
+    return item;
+
+}
+
+id processCheckboxMenuItem(Menu *menu, id parentmenu, const char *title, const char *menuItemID, bool disabled, bool checked, const char *key, bool hascallback) {
+
+    id item = ALLOC("NSMenuItem");
+
+    // Store the item in the menu item map
+//    hashmap_put(&menu->menuItemMap, (char*)menuItemID, strlen(menuItemID), item);
+    SaveMenuItemInStore((TrayMenuStore *) menu->store, menuItemID, item);
+
+    if( hascallback ) {
+        // Create a MenuItemCallbackData
+        MenuItemCallbackData *callback = CreateMenuItemCallbackData(menu, menuItemID, Checkbox);
+
+        id wrappedId = msg(c("NSValue"), s("valueWithPointer:"), callback);
+        msg(item, s("setRepresentedObject:"), wrappedId);
+    }
+
+    msg(item, s("initWithTitle:action:keyEquivalent:"), str(title), s("menuItemCallback:"), str(key));
+    msg(item, s("setEnabled:"), !disabled);
+    msg(item, s("autorelease"));
+    msg(item, s("setState:"), (checked ? NSControlStateValueOn : NSControlStateValueOff));
+    msg(parentmenu, s("addItem:"), item);
+    return item;
+}
+
+id processTextMenuItem(Menu *menu, id parentMenu, const char *title, const char *menuItemID, bool disabled, const char *acceleratorkey, const char **modifiers, bool hascallback) {
+    id item = ALLOC("NSMenuItem");
+
+    SaveMenuItemInStore((TrayMenuStore *) menu->store, menuItemID, item);
+
+    if( hascallback ) {
+        // Create a MenuItemCallbackData
+        MenuItemCallbackData *callback = CreateMenuItemCallbackData(menu, menuItemID, Text);
+
+        id wrappedId = msg(c("NSValue"), s("valueWithPointer:"), callback);
+        msg(item, s("setRepresentedObject:"), wrappedId);
+    }
+
+    id key = processAcceleratorKey(acceleratorkey);
+    msg(item, s("initWithTitle:action:keyEquivalent:"), str(title),
+        s("menuItemCallback:"), key);
+
+    msg(item, s("setEnabled:"), !disabled);
+    msg(item, s("autorelease"));
+
+    // Process modifiers
+    if( modifiers != NULL ) {
+        unsigned long modifierFlags = parseModifiers(modifiers);
+        msg(item, s("setKeyEquivalentModifierMask:"), modifierFlags);
+    }
+    msg(parentMenu, s("addItem:"), item);
+
+    return item;
+}
+
+void processMenuItem(Menu *menu, id parentMenu, JsonNode *item) {
+
+    // Check if this item is hidden and if so, exit early!
+    bool hidden = getJSONBool(item, "h");
+    if( hidden ) {
+        return;
+    }
+
+    // Get the role
+    JsonNode *role = json_find_member(item, "r");
+    if( role != NULL ) {
+        processMenuRole(menu, parentMenu, role);
+        return;
+    }
+
+    // Check if this is a submenu
+    JsonNode *submenu = json_find_member(item, "S");
+    if( submenu != NULL ) {
+        // Get the label
+        JsonNode *menuNameNode = json_find_member(item, "l");
+        const char *name = "";
+        if ( menuNameNode != NULL) {
+            name = menuNameNode->string_;
+        }
+
+        id thisMenuItem = createMenuItemNoAutorelease(str(name), NULL, "");
+        id thisMenu = createMenu(str(name));
+
+        msg(thisMenuItem, s("setSubmenu:"), thisMenu);
+        msg(parentMenu, s("addItem:"), thisMenuItem);
+
+        JsonNode *submenuItems = json_find_member(submenu, "i");
+        // If we have no items, just return
+        if ( submenuItems == NULL ) {
+            return;
+        }
+
+        // Loop over submenu items
+        JsonNode *item;
+        json_foreach(item, submenuItems) {
+            // Get item label
+            processMenuItem(menu, thisMenu, item);
+        }
+
+        return;
+    }
+
+    // This is a user menu. Get the common data
+    // Get the label
+    const char *label = getJSONString(item, "l");
+    if ( label == NULL) {
+        label = "(empty)";
+    }
+
+    const char *menuItemID = getJSONString(item, "I");
+    if ( menuItemID == NULL) {
+        menuItemID = "";
+    }
+
+    bool disabled = getJSONBool(item, "d");
+
+    // Get the Accelerator
+    JsonNode *accelerator = json_find_member(item, "a");
+    const char *acceleratorkey = NULL;
+    const char **modifiers = NULL;
+
+    // If we have an accelerator
+    if( accelerator != NULL ) {
+        // Get the key
+        acceleratorkey = getJSONString(accelerator, "Key");
+        // Check if there are modifiers
+        JsonNode *modifiersList = json_find_member(accelerator, "Modifiers");
+        if ( modifiersList != NULL ) {
+            // Allocate an array of strings
+            int noOfModifiers = json_array_length(modifiersList);
+
+            // Do we have any?
+            if (noOfModifiers > 0) {
+                modifiers = malloc(sizeof(const char *) * (noOfModifiers + 1));
+                JsonNode *modifier;
+                int count = 0;
+                // Iterate the modifiers and save a reference to them in our new array
+                json_foreach(modifier, modifiersList) {
+                    // Get modifier name
+                    modifiers[count] = modifier->string_;
+                    count++;
+                }
+                // Null terminate the modifier list
+                modifiers[count] = NULL;
+            }
+        }
+    }
+
+    // has callback?
+    bool hascallback = getJSONBool(item, "C");
+
+    // Get the Type
+    const char *type = mustJSONString(item, "t");
+
+    if( STREQ(type, "t")) {
+        processTextMenuItem(menu, parentMenu, label, menuItemID, disabled, acceleratorkey, modifiers, hascallback);
+    }
+    else if ( STREQ(type, "s")) {
+        addSeparator(parentMenu);
+    }
+    else if ( STREQ(type, "c")) {
+        // Get checked state
+        bool checked = getJSONBool(item, "c");
+
+        processCheckboxMenuItem(menu, parentMenu, label, menuItemID, disabled, checked, "", hascallback);
+    }
+    else if ( STREQ(type, "r")) {
+        // Get checked state
+        bool checked = getJSONBool(item, "c");
+
+        processRadioMenuItem(menu, parentMenu, label, menuItemID, disabled, checked, "", hascallback);
+    }
+
+
+    if ( modifiers != NULL ) {
+        free(modifiers);
+    }
+
+    return;
+}
+
+void processMenuData(Menu *menu, JsonNode *menuData) {
+    // Iterate items
+    JsonNode *item;
+    json_foreach(item, menuData) {
+        // Process each menu item
+        processMenuItem(menu, menu->menu, item);
+    }
+}
+
+void processRadioGroupJSON(Menu *menu, JsonNode *radioGroup) {
+
+    int groupLength;
+    getJSONInt(radioGroup, "Length", &groupLength);
+    JsonNode *members = json_find_member(radioGroup, "Members");
+    JsonNode *member;
+
+    // Allocate array
+    size_t arrayLength = sizeof(id)*(groupLength+1);
+    id memberList[arrayLength];
+
+    // Build the radio group items
+    int count=0;
+    json_foreach(member, members) {
+        // Get menu by id
+        id menuItem = (id)hashmap_get(&menu->menuItemMap, (char*)member->string_, strlen(member->string_));
+        // Save Member
+        memberList[count] = menuItem;
+        count = count + 1;
+    }
+    // Null terminate array
+    memberList[groupLength] = 0;
+
+    // Store the members
+    json_foreach(member, members) {
+        // Copy the memberList
+        char *newMemberList = (char *)malloc(arrayLength);
+        memcpy(newMemberList, memberList, arrayLength);
+        // add group to each member of group
+        hashmap_put(&menu->radioGroupMap, member->string_, strlen(member->string_), newMemberList);
+    }
+
+}
+
+id ProcessMenu(Menu *menu, JsonNode *menuData, JsonNode *radioGroups) {
+
+    // exit if we have no meny
+    if( menuData == NULL ) {
+        return NULL;
+    }
+
+    menu->menu = createMenu(str(""));
+
+    // Process the menu data
+    processMenuData(menu, menuData);
+
+    if( radioGroups != NULL ) {
+        // Iterate radio groups
+        JsonNode *radioGroup;
+        json_foreach(radioGroup, radioGroups) {
+            // Get item label
+            processRadioGroupJSON(menu, radioGroup);
+        }
+    }
+
+    return menu->menu;
+}
+

v2/internal/ffenestri/menu_darwin_old.h

@@ -0,0 +1,97 @@
+//
+// Created by Lea Anthony on 6/1/21.
+//
+
+#ifndef MENU_DARWIN_H
+#define MENU_DARWIN_H
+
+#include "common.h"
+#include "ffenestri_darwin.h"
+
+enum MenuItemType {Text = 0, Checkbox = 1, Radio = 2};
+enum MenuType {ApplicationMenuType = 0, ContextMenuType = 1, TrayMenuType = 2};
+static const char *MenuTypeAsString[] = {
+        "ApplicationMenu", "ContextMenu", "TrayMenu",
+};
+
+extern void messageFromWindowCallback(const char *);
+
+struct TrayMenuStore;
+
+typedef struct {
+
+    const char *title;
+
+    /*** Internal ***/
+
+    struct hashmap_s menuItemMap;
+    struct hashmap_s radioGroupMap;
+
+    // Vector to keep track of callback data memory
+    vec_void_t callbackDataCache;
+
+    // The NSMenu for this menu
+    id menu;
+
+    // A reference to the Menu store
+    struct TrayMenuStore *store;
+
+    // The commands for the menu callbacks
+    const char *callbackCommand;
+
+    // This indicates if we are an Application Menu, tray menu or context menu
+    enum MenuType menuType;
+
+
+} Menu;
+
+typedef struct {
+    struct TrayMenuStore *store;
+    Menu *menu;
+    const char *menuItemID;
+    enum MenuItemType menuItemType;
+} MenuItemCallbackData;
+
+// NewMenu creates a new Menu struct, saving the given menu structure as JSON
+Menu* NewMenu(JsonNode *menuData, JsonNode *radioGroups, struct TrayMenuStore *store);
+
+Menu* NewApplicationMenu(const char *menuAsJSON, struct TrayMenuStore *store);
+MenuItemCallbackData* CreateMenuItemCallbackData(Menu *menu, const char *menuItemID, enum MenuItemType menuItemType);
+
+void DeleteMenu(Menu *menu);
+
+// Creates a JSON message for the given menuItemID and data
+const char* createMenuClickedMessage(const char *menuItemID, const char *data);
+
+// Callback for text menu items
+void menuItemCallback(id self, SEL cmd, id sender);
+id processAcceleratorKey(const char *key);
+
+
+void addSeparator(id menu);
+id createMenuItemNoAutorelease( id title, const char *action, const char *key);
+
+id createMenuItem(id title, const char *action, const char *key);
+
+id addMenuItem(id menu, const char *title, const char *action, const char *key, bool disabled);
+
+id createMenu(id title);
+void createDefaultAppMenu(id parentMenu);
+void createDefaultEditMenu(id parentMenu);
+
+void processMenuRole(Menu *menu, id parentMenu, JsonNode *item);
+// This converts a string array of modifiers into the
+// equivalent MacOS Modifier Flags
+unsigned long parseModifiers(const char **modifiers);
+id processRadioMenuItem(Menu *menu, id parentmenu, const char *title, const char *menuid, bool disabled, bool checked, const char *acceleratorkey, bool hasCallback);
+
+id processCheckboxMenuItem(Menu *menu, id parentmenu, const char *title, const char *menuid, bool disabled, bool checked, const char *key, bool hasCallback);
+
+id processTextMenuItem(Menu *menu, id parentMenu, const char *title, const char *menuid, bool disabled, const char *acceleratorkey, const char **modifiers, bool hasCallback);
+
+void processMenuItem(Menu *menu, id parentMenu, JsonNode *item);
+void processMenuData(Menu *menu, JsonNode *menuData);
+
+void processRadioGroupJSON(Menu *menu, JsonNode *radioGroup) ;
+id ProcessMenu(Menu *menu, JsonNode *menuData, JsonNode *radioGroup);
+#endif //ASSETS_C_MENU_DARWIN_H

v2/internal/ffenestri/menu_item.c

@@ -0,0 +1,101 @@
+//
+// Created by Lea Anthony on 18/1/21.
+//
+
+#include "menu.h"
+
+MenuItem* NewMenuItem(enum MenuItemType type, const char* ID, const char* label, const char* alternateLabel, bool disabled, bool hidden, bool checked, const char* colour, const char* font, int fontsize, const char* image, const char* acceleratorKey, const char** modifiers, bool hasCallback, Menu* submenu) {
+
+    MenuItem *result = NEW(MenuItem);
+
+    // Setup
+    result->ID = STRCOPY(ID);
+    result->label = STRCOPY(label);
+    result->alternateLabel = STRCOPY(alternateLabel);
+    result->disabled = disabled;
+    result->hidden = hidden;
+    result->colour = STRCOPY(colour);
+    result->font = STRCOPY(font);
+    result->fontSize = fontsize;
+    result->image = STRCOPY(image);
+    result->acceleratorKey = STRCOPY(acceleratorKey);
+    result->modifiers = modifiers;
+    result->hasCallback = hasCallback;
+    result->type = type;
+    result->checked = checked;
+    result->submenu = submenu;
+
+    result->callbackData = NULL;
+
+    vec_init(&result->radioGroup);
+
+    SetupMenuItemPlatformData(result);
+
+    return result;
+}
+
+void DeleteMenuItem(MenuItem* menuItem) {
+
+    MEMFREE(menuItem->ID);
+    MEMFREE(menuItem->label);
+    MEMFREE(menuItem->alternateLabel);
+    MEMFREE(menuItem->colour);
+    MEMFREE(menuItem->font);
+    MEMFREE(menuItem->image);
+    MEMFREE(menuItem->acceleratorKey);
+
+    // Iterate the modifiers and free elements
+    if( menuItem->modifiers != NULL ) {
+        int i = 0;
+        const char *nextItem = menuItem->modifiers[0];
+        while (nextItem != NULL) {
+            MEMFREE(nextItem);
+            i++;
+            nextItem = menuItem->modifiers[i];
+        }
+        MEMFREE(menuItem->modifiers);
+    }
+
+    DeleteMenuItemCallbackData(menuItem->callbackData);
+
+    DeleteMenuItemPlatformData(menuItem);
+
+    MEMFREE(menuItem);
+}
+
+JsonNode* MenuItemAsJSONObject(MenuItem* menuItem) {
+
+    JsonNode* result = json_mkobject();
+    JSON_ADD_STRING(result, "ID", menuItem->ID);
+    JSON_ADD_STRING(result, "label", menuItem->label);
+    JSON_ADD_STRING(result, "alternateLabel", menuItem->alternateLabel);
+    JSON_ADD_BOOL(result, "disabled", menuItem->disabled);
+    JSON_ADD_BOOL(result, "hidden", menuItem->hidden);
+    JSON_ADD_STRING(result, "colour", menuItem->colour);
+    JSON_ADD_STRING(result, "font", menuItem->font);
+    JSON_ADD_NUMBER(result, "fontsize", menuItem->fontSize);
+    JSON_ADD_STRING(result, "image", menuItem->image);
+    JSON_ADD_STRING(result, "acceleratorKey", menuItem->acceleratorKey);
+    JSON_ADD_BOOL(result, "hasCallback", menuItem->hasCallback);
+    JSON_ADD_STRING(result, "type", MenuItemTypeAsString[menuItem->type]);
+    JSON_ADD_BOOL(result, "checked", menuItem->checked);
+    return result;
+}
+
+MenuItemCallbackData* NewMenuItemCallbackData(MenuManager *manager, const char* menuItemID, enum MenuItemType menuItemType) {
+    MenuItemCallbackData* result = NEW(MenuItemCallbackData);
+
+    result->manager = manager;
+    result->menuItemID = STRCOPY(menuItemID);
+    result->menuItemType = menuItemType;
+
+    return result;
+}
+
+void DeleteMenuItemCallbackData(MenuItemCallbackData* callbackData) {
+
+    if( callbackData == NULL ) return;
+
+    MEMFREE(callbackData->menuItemID);
+    MEMFREE(callbackData);
+}

v2/internal/ffenestri/menu_manager.c

@@ -0,0 +1,81 @@
+//
+// Created by Lea Anthony on 18/1/21.
+//
+
+#include "menu.h"
+
+MenuManager* NewMenuManager() {
+
+    MenuManager* result = malloc(sizeof(MenuManager));
+
+    // Allocate Hashmaps
+    HASHMAP_INIT(result->menuItems, 32, "menuItems");
+    HASHMAP_INIT(result->contextMenus, 4, "contextMenus");
+    HASHMAP_INIT(result->trayMenus, 4, "trayMenus");
+
+    // Initialise other data
+    result->applicationMenu = NULL;
+    result->contextMenuData = NULL;
+
+    return result;
+}
+
+int deleteTrayMenu(void *const context, struct hashmap_element_s *const e) {
+    DeleteTrayMenu(e->data);
+    return -1; // Remove from hashmap
+}
+
+int deleteMenuItem(void *const context, struct hashmap_element_s *const e) {
+    DeleteMenuItem(e->data);
+    return -1; // Remove from hashmap
+}
+
+void DeleteMenuManager(MenuManager* manager) {
+
+    // Iterate hashmaps and delete items
+    HASHMAP_ITERATE(manager->trayMenus, deleteTrayMenu, NULL);
+    HASHMAP_ITERATE(manager->menuItems, deleteMenuItem, NULL);
+
+    // Delete applicationMenu
+    DeleteMenu(manager->applicationMenu);
+
+    // Delete Hashmaps
+    HASHMAP_DESTROY(manager->trayMenus);
+    HASHMAP_DESTROY(manager->contextMenus);
+    HASHMAP_DESTROY(manager->menuItems);
+
+    // Delete context menu data
+    MEMFREE(manager->contextMenuData);
+}
+
+TrayMenu* AddTrayMenuToManager(MenuManager* manager, const char* trayMenuJSON) {
+
+    // Parse JSON
+    struct JsonNode* parsedJSON = mustParseJSON(trayMenuJSON);
+
+    // Get the ID
+    const char *ID = mustJSONString(parsedJSON, "I");
+
+    // Check if there is already an entry for this menu
+    TrayMenu* existingTrayMenu = HASHMAP_GET(manager->trayMenus, ID);
+    if ( existingTrayMenu != NULL ) {
+        json_delete(parsedJSON);
+        return existingTrayMenu;
+    }
+
+    // Create new menu
+    TrayMenu* newMenu = NewTrayMenu(parsedJSON, manager);
+    HASHMAP_PUT(manager->trayMenus, newMenu->ID, newMenu);
+
+    return newMenu;
+}
+
+int showTrayMenu(void *const context, struct hashmap_element_s *const e) {
+    ShowTrayMenu(e->data);
+    // 0 to retain element, -1 to delete.
+    return 0;
+}
+void ShowTrayMenus(MenuManager* manager) {
+    HASHMAP_ITERATE(manager->trayMenus, showTrayMenu, NULL);
+}
+

v2/internal/ffenestri/menu_tray.c

@@ -0,0 +1,69 @@
+//
+// Created by Lea Anthony on 18/1/21.
+//
+
+#include "menu.h"
+
+TrayMenu* NewTrayMenu(JsonNode* parsedJSON, MenuManager *manager) {
+
+    // NULL GUARD
+    if(parsedJSON == NULL) ABORT("[NewTrayMenu] parsedJSON == NULL");
+
+    // Create new tray menu
+    TrayMenu* result = NEW(TrayMenu);
+
+    // Initialise other data
+    result->ID = STRCOPY(mustJSONString(parsedJSON, "I"));
+    result->Label = STRCOPY(getJSONString(parsedJSON, "l"));
+    result->Icon = STRCOPY(getJSONString(parsedJSON, "i"));
+
+    // Process menu
+    struct JsonNode* menuJSON = getJSONObject(parsedJSON, "m");
+    struct JsonNode* radioJSON = getJSONObject(parsedJSON, "r");
+    result->Menu = NewMenu(menuJSON, radioJSON, manager);
+
+    // Setup platform data
+    SetupTrayMenuPlatformData(result);
+
+    return result;
+}
+
+void DeleteTrayMenu(TrayMenu *trayMenu) {
+
+    // NULL guard
+    if( trayMenu == NULL ) return;
+
+    // Free the strings
+    MEMFREE(trayMenu->ID);
+    MEMFREE(trayMenu->Label);
+    MEMFREE(trayMenu->Icon);
+
+    // Delete the menu
+    DeleteMenu(trayMenu->Menu);
+
+    // Delete the platform data
+    DeleteTrayMenuPlatformData(trayMenu);
+
+    // Free tray menu
+    MEMFREE(trayMenu);
+}
+
+const char* TrayMenuAsJSON(TrayMenu* menu) {
+
+    JsonNode *jsonObject = json_mkobject();
+    JSON_ADD_STRING(jsonObject, "ID", menu->ID);
+    JSON_ADD_STRING(jsonObject, "Label", menu->Label);
+    JSON_ADD_STRING(jsonObject, "Icon", menu->Icon);
+    JSON_ADD_OBJECT(jsonObject, "Menu", MenuAsJSONObject(menu->Menu));
+    return json_encode(jsonObject);
+}
+
+void UpdateTrayIcon(TrayMenu *trayMenu) {
+
+    // Exit early if NULL
+    if( trayMenu->Icon == NULL ) {
+        return;
+    }
+
+    PlatformUpdateTrayIcon(trayMenu);
+}

v2/internal/ffenestri/test_app/CMakeLists.txt

@@ -0,0 +1,25 @@
+cmake_minimum_required(VERSION 3.17)
+project(test_app)
+
+set(CMAKE_CXX_STANDARD 14)
+set (CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -fno-omit-frame-pointer -fsanitize=address -g")
+set (CMAKE_LINKER_FLAGS_DEBUG "${CMAKE_LINKER_FLAGS_DEBUG} -fno-omit-frame-pointer -fsanitize=address -fsanitize=leak -g")
+
+add_executable(test_app test.c)
+add_library(menus STATIC ../menu_manager.c ../menu.c ../menu_tray.c ../menu_item.c )
+add_library(common STATIC ../common.c ../utf8.h)
+add_library(json STATIC ../json.c)
+add_library(vec STATIC ../vec.c)
+
+if( CMAKE_HOST_APPLE )
+    find_library(WEBKIT WebKit)
+    add_library(runtime STATIC ../runtime_darwin.c)
+    add_library(ffenestri STATIC ../ffenestri_darwin.c)
+    add_library(defaulticons STATIC ../defaultdialogicons_darwin.c)
+    add_library(platform STATIC ../menu_darwin.c)
+    target_link_libraries(test_app objc ${WEBKIT} ffenestri platform runtime)
+endif()
+
+target_link_libraries(test_app vec json common menus)
+include_directories(..)
+include_directories(.)

v2/internal/ffenestri/test_menumanager/CMakeLists.txt

@@ -0,0 +1,21 @@
+cmake_minimum_required(VERSION 3.17)
+project(test_menumanager)
+
+set(CMAKE_CXX_STANDARD 14)
+set (CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -fno-omit-frame-pointer -fsanitize=address -g")
+set (CMAKE_LINKER_FLAGS_DEBUG "${CMAKE_LINKER_FLAGS_DEBUG} -fno-omit-frame-pointer -fsanitize=address -fsanitize=leak -g")
+
+add_executable(test_menumanager test.c minunit.h)
+add_library(menus STATIC ../menu_manager.c ../menu.c ../menu_tray.c ../menu_item.c)
+add_library(common STATIC ../common.c ../utf8.h)
+add_library(json STATIC ../json.c)
+add_library(vec STATIC ../vec.c)
+
+if( CMAKE_HOST_APPLE )
+    add_library(platform STATIC ../menu_darwin.c)
+    target_link_libraries(test_menumanager objc)
+endif()
+
+target_link_libraries(test_menumanager vec json common menus platform)
+include_directories(..)
+include_directories(.)

v2/internal/ffenestri/test_menumanager/minunit.LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 David Siñuela Pastor, siu.4coders@gmail.com
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

v2/internal/ffenestri/test_menumanager/minunit.h

@@ -0,0 +1,391 @@
+/*
+ * Copyright (c) 2012 David Siñuela Pastor, siu.4coders@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef MINUNIT_MINUNIT_H
+#define MINUNIT_MINUNIT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(_WIN32)
+#include <Windows.h>
+#if defined(_MSC_VER) && _MSC_VER < 1900
+  #define snprintf _snprintf
+  #define __func__ __FUNCTION__
+#endif
+
+#elif defined(__unix__) || defined(__unix) || defined(unix) || (defined(__APPLE__) && defined(__MACH__))
+
+/* Change POSIX C SOURCE version for pure c99 compilers */
+#if !defined(_POSIX_C_SOURCE) || _POSIX_C_SOURCE < 200112L
+#undef _POSIX_C_SOURCE
+#define _POSIX_C_SOURCE 200112L
+#endif
+
+#include <unistd.h>	/* POSIX flags */
+#include <time.h>	/* clock_gettime(), time() */
+#include <sys/time.h>	/* gethrtime(), gettimeofday() */
+#include <sys/resource.h>
+#include <sys/times.h>
+#include <string.h>
+
+#if defined(__MACH__) && defined(__APPLE__)
+#include <mach/mach.h>
+#include <mach/mach_time.h>
+#endif
+
+#if __GNUC__ >= 5 && !defined(__STDC_VERSION__)
+#define __func__ __extension__ __FUNCTION__
+#endif
+
+#else
+#error "Unable to define timers for an unknown OS."
+#endif
+
+#include <stdio.h>
+#include <math.h>
+
+/*  Maximum length of last message */
+#define MINUNIT_MESSAGE_LEN 1024
+/*  Accuracy with which floats are compared */
+#define MINUNIT_EPSILON 1E-12
+
+/*  Misc. counters */
+static int minunit_run = 0;
+static int minunit_assert = 0;
+static int minunit_fail = 0;
+static int minunit_status = 0;
+
+/*  Timers */
+static double minunit_real_timer = 0;
+static double minunit_proc_timer = 0;
+
+/*  Last message */
+static char minunit_last_message[MINUNIT_MESSAGE_LEN];
+
+/*  Test setup and teardown function pointers */
+static void (*minunit_setup)(void) = NULL;
+static void (*minunit_teardown)(void) = NULL;
+
+/*  Definitions */
+#define MU_TEST(method_name) static void method_name(void)
+#define MU_TEST_SUITE(suite_name) static void suite_name(void)
+
+#define MU__SAFE_BLOCK(block) do {\
+	block\
+} while(0)
+
+/*  Run test suite and unset setup and teardown functions */
+#define MU_RUN_SUITE(suite_name) MU__SAFE_BLOCK(\
+	suite_name();\
+	minunit_setup = NULL;\
+	minunit_teardown = NULL;\
+)
+
+/*  Configure setup and teardown functions */
+#define MU_SUITE_CONFIGURE(setup_fun, teardown_fun) MU__SAFE_BLOCK(\
+	minunit_setup = setup_fun;\
+	minunit_teardown = teardown_fun;\
+)
+
+/*  Test runner */
+#define MU_RUN_TEST(test) MU__SAFE_BLOCK(\
+	if (minunit_real_timer==0 && minunit_proc_timer==0) {\
+		minunit_real_timer = mu_timer_real();\
+		minunit_proc_timer = mu_timer_cpu();\
+	}\
+	if (minunit_setup) (*minunit_setup)();\
+	minunit_status = 0;\
+	test();\
+	minunit_run++;\
+	if (minunit_status) {\
+		minunit_fail++;\
+		printf("F");\
+		printf("\n%s\n", minunit_last_message);\
+	}\
+	fflush(stdout);\
+	if (minunit_teardown) (*minunit_teardown)();\
+)
+
+/*  Report */
+#define MU_REPORT() MU__SAFE_BLOCK(\
+	double minunit_end_real_timer;\
+	double minunit_end_proc_timer;\
+	printf("\n\n%d tests, %d assertions, %d failures\n", minunit_run, minunit_assert, minunit_fail);\
+	minunit_end_real_timer = mu_timer_real();\
+	minunit_end_proc_timer = mu_timer_cpu();\
+	printf("\nFinished in %.8f seconds (real) %.8f seconds (proc)\n\n",\
+		minunit_end_real_timer - minunit_real_timer,\
+		minunit_end_proc_timer - minunit_proc_timer);\
+)
+#define MU_EXIT_CODE minunit_fail
+
+/*  Assertions */
+#define mu_check(test) MU__SAFE_BLOCK(\
+	minunit_assert++;\
+	if (!(test)) {\
+		snprintf(minunit_last_message, MINUNIT_MESSAGE_LEN, "%s failed:\n\t%s:%d: %s", __func__, __FILE__, __LINE__, #test);\
+		minunit_status = 1;\
+		return;\
+	} else {\
+		printf(".");\
+	}\
+)
+
+#define mu_fail(message) MU__SAFE_BLOCK(\
+	minunit_assert++;\
+	snprintf(minunit_last_message, MINUNIT_MESSAGE_LEN, "%s failed:\n\t%s:%d: %s", __func__, __FILE__, __LINE__, message);\
+	minunit_status = 1;\
+	return;\
+)
+
+#define mu_assert(test, message) MU__SAFE_BLOCK(\
+	minunit_assert++;\
+	if (!(test)) {\
+		snprintf(minunit_last_message, MINUNIT_MESSAGE_LEN, "%s failed:\n\t%s:%d: %s", __func__, __FILE__, __LINE__, message);\
+		minunit_status = 1;\
+		return;\
+	} else {\
+		printf(".");\
+	}\
+)
+
+#define mu_assert_int_eq(expected, result) MU__SAFE_BLOCK(\
+	int minunit_tmp_e;\
+	int minunit_tmp_r;\
+	minunit_assert++;\
+	minunit_tmp_e = (expected);\
+	minunit_tmp_r = (result);\
+	if (minunit_tmp_e != minunit_tmp_r) {\
+		snprintf(minunit_last_message, MINUNIT_MESSAGE_LEN, "%s failed:\n\t%s:%d: %d expected but was %d", __func__, __FILE__, __LINE__, minunit_tmp_e, minunit_tmp_r);\
+		minunit_status = 1;\
+		return;\
+	} else {\
+		printf(".");\
+	}\
+)
+
+#define mu_assert_double_eq(expected, result) MU__SAFE_BLOCK(\
+	double minunit_tmp_e;\
+	double minunit_tmp_r;\
+	minunit_assert++;\
+	minunit_tmp_e = (expected);\
+	minunit_tmp_r = (result);\
+	if (fabs(minunit_tmp_e-minunit_tmp_r) > MINUNIT_EPSILON) {\
+		int minunit_significant_figures = 1 - log10(MINUNIT_EPSILON);\
+		snprintf(minunit_last_message, MINUNIT_MESSAGE_LEN, "%s failed:\n\t%s:%d: %.*g expected but was %.*g", __func__, __FILE__, __LINE__, minunit_significant_figures, minunit_tmp_e, minunit_significant_figures, minunit_tmp_r);\
+		minunit_status = 1;\
+		return;\
+	} else {\
+		printf(".");\
+	}\
+)
+
+#define mu_assert_string_eq(expected, result) MU__SAFE_BLOCK(\
+	const char* minunit_tmp_e = expected;\
+	const char* minunit_tmp_r = result;\
+	minunit_assert++;\
+	if (!minunit_tmp_e) {\
+		minunit_tmp_e = "<null pointer>";\
+	}\
+	if (!minunit_tmp_r) {\
+		minunit_tmp_r = "<null pointer>";\
+	}\
+	if(strcmp(minunit_tmp_e, minunit_tmp_r) != 0) {\
+		snprintf(minunit_last_message, MINUNIT_MESSAGE_LEN, "%s failed:\n\t%s:%d: '%s' expected but was '%s'", __func__, __FILE__, __LINE__, minunit_tmp_e, minunit_tmp_r);\
+		minunit_status = 1;\
+		return;\
+	} else {\
+		printf(".");\
+	}\
+)
+
+/*
+ * The following two functions were written by David Robert Nadeau
+ * from http://NadeauSoftware.com/ and distributed under the
+ * Creative Commons Attribution 3.0 Unported License
+ */
+
+/**
+ * Returns the real time, in seconds, or -1.0 if an error occurred.
+ *
+ * Time is measured since an arbitrary and OS-dependent start time.
+ * The returned real time is only useful for computing an elapsed time
+ * between two calls to this function.
+ */
+static double mu_timer_real(void)
+{
+#if defined(_WIN32)
+    /* Windows 2000 and later. ---------------------------------- */
+	LARGE_INTEGER Time;
+	LARGE_INTEGER Frequency;
+
+	QueryPerformanceFrequency(&Frequency);
+	QueryPerformanceCounter(&Time);
+
+	Time.QuadPart *= 1000000;
+	Time.QuadPart /= Frequency.QuadPart;
+
+	return (double)Time.QuadPart / 1000000.0;
+
+#elif (defined(__hpux) || defined(hpux)) || ((defined(__sun__) || defined(__sun) || defined(sun)) && (defined(__SVR4) || defined(__svr4__)))
+    /* HP-UX, Solaris. ------------------------------------------ */
+	return (double)gethrtime( ) / 1000000000.0;
+
+#elif defined(__MACH__) && defined(__APPLE__)
+    /* OSX. ----------------------------------------------------- */
+    static double timeConvert = 0.0;
+    if ( timeConvert == 0.0 )
+    {
+        mach_timebase_info_data_t timeBase;
+        (void)mach_timebase_info( &timeBase );
+        timeConvert = (double)timeBase.numer /
+                      (double)timeBase.denom /
+                      1000000000.0;
+    }
+    return (double)mach_absolute_time( ) * timeConvert;
+
+#elif defined(_POSIX_VERSION)
+    /* POSIX. --------------------------------------------------- */
+	struct timeval tm;
+#if defined(_POSIX_TIMERS) && (_POSIX_TIMERS > 0)
+	{
+		struct timespec ts;
+#if defined(CLOCK_MONOTONIC_PRECISE)
+		/* BSD. --------------------------------------------- */
+		const clockid_t id = CLOCK_MONOTONIC_PRECISE;
+#elif defined(CLOCK_MONOTONIC_RAW)
+		/* Linux. ------------------------------------------- */
+		const clockid_t id = CLOCK_MONOTONIC_RAW;
+#elif defined(CLOCK_HIGHRES)
+		/* Solaris. ----------------------------------------- */
+		const clockid_t id = CLOCK_HIGHRES;
+#elif defined(CLOCK_MONOTONIC)
+		/* AIX, BSD, Linux, POSIX, Solaris. ----------------- */
+		const clockid_t id = CLOCK_MONOTONIC;
+#elif defined(CLOCK_REALTIME)
+		/* AIX, BSD, HP-UX, Linux, POSIX. ------------------- */
+		const clockid_t id = CLOCK_REALTIME;
+#else
+		const clockid_t id = (clockid_t)-1;	/* Unknown. */
+#endif /* CLOCK_* */
+		if ( id != (clockid_t)-1 && clock_gettime( id, &ts ) != -1 )
+			return (double)ts.tv_sec +
+				(double)ts.tv_nsec / 1000000000.0;
+		/* Fall thru. */
+	}
+#endif /* _POSIX_TIMERS */
+
+	/* AIX, BSD, Cygwin, HP-UX, Linux, OSX, POSIX, Solaris. ----- */
+	gettimeofday( &tm, NULL );
+	return (double)tm.tv_sec + (double)tm.tv_usec / 1000000.0;
+#else
+	return -1.0;		/* Failed. */
+#endif
+}
+
+/**
+ * Returns the amount of CPU time used by the current process,
+ * in seconds, or -1.0 if an error occurred.
+ */
+static double mu_timer_cpu(void)
+{
+#if defined(_WIN32)
+    /* Windows -------------------------------------------------- */
+	FILETIME createTime;
+	FILETIME exitTime;
+	FILETIME kernelTime;
+	FILETIME userTime;
+
+	/* This approach has a resolution of 1/64 second. Unfortunately, Windows' API does not offer better */
+	if ( GetProcessTimes( GetCurrentProcess( ),
+		&createTime, &exitTime, &kernelTime, &userTime ) != 0 )
+	{
+		ULARGE_INTEGER userSystemTime;
+		memcpy(&userSystemTime, &userTime, sizeof(ULARGE_INTEGER));
+		return (double)userSystemTime.QuadPart / 10000000.0;
+	}
+
+#elif defined(__unix__) || defined(__unix) || defined(unix) || (defined(__APPLE__) && defined(__MACH__))
+    /* AIX, BSD, Cygwin, HP-UX, Linux, OSX, and Solaris --------- */
+
+#if defined(_POSIX_TIMERS) && (_POSIX_TIMERS > 0)
+    /* Prefer high-res POSIX timers, when available. */
+	{
+		clockid_t id;
+		struct timespec ts;
+#if _POSIX_CPUTIME > 0
+		/* Clock ids vary by OS.  Query the id, if possible. */
+		if ( clock_getcpuclockid( 0, &id ) == -1 )
+#endif
+#if defined(CLOCK_PROCESS_CPUTIME_ID)
+			/* Use known clock id for AIX, Linux, or Solaris. */
+			id = CLOCK_PROCESS_CPUTIME_ID;
+#elif defined(CLOCK_VIRTUAL)
+			/* Use known clock id for BSD or HP-UX. */
+			id = CLOCK_VIRTUAL;
+#else
+			id = (clockid_t)-1;
+#endif
+		if ( id != (clockid_t)-1 && clock_gettime( id, &ts ) != -1 )
+			return (double)ts.tv_sec +
+				(double)ts.tv_nsec / 1000000000.0;
+	}
+#endif
+
+#if defined(RUSAGE_SELF)
+    {
+        struct rusage rusage;
+        if ( getrusage( RUSAGE_SELF, &rusage ) != -1 )
+            return (double)rusage.ru_utime.tv_sec +
+                   (double)rusage.ru_utime.tv_usec / 1000000.0;
+    }
+#endif
+
+#if defined(_SC_CLK_TCK)
+    {
+        const double ticks = (double)sysconf( _SC_CLK_TCK );
+        struct tms tms;
+        if ( times( &tms ) != (clock_t)-1 )
+            return (double)tms.tms_utime / ticks;
+    }
+#endif
+
+#if defined(CLOCKS_PER_SEC)
+    {
+        clock_t cl = clock( );
+        if ( cl != (clock_t)-1 )
+            return (double)cl / (double)CLOCKS_PER_SEC;
+    }
+#endif
+
+#endif
+
+    return -1;		/* Failed. */
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* MINUNIT_MINUNIT_H */

v2/internal/ffenestri/test_menumanager/test.c

@@ -0,0 +1,71 @@
+//
+// Created by Lea Anthony on 12/1/21.
+//
+
+#include "minunit.h"
+#include "menu.h"
+
+#define empty "{\"I\":\"T1\"}"
+#define emptyExpected "{\"ID\":\"T1\",\"Label\":null,\"Icon\":null,\"Menu\":null}"
+#define labelOnly "{\"I\":\"T1\",\"l\":\"test\"}"
+#define labelOnlyExpected "{\"ID\":\"T1\",\"Label\":\"test\",\"Icon\":null,\"Menu\":null}"
+#define iconOnly "{\"I\":\"T1\",\"i\":\"svelte\"}"
+#define iconOnlyExpected "{\"ID\":\"T1\",\"Label\":null,\"Icon\":\"svelte\",\"Menu\":null}"
+#define iconLabel "{\"I\":\"T1\",\"l\":\"test\",\"i\":\"svelte\"}"
+#define iconLabelExpected "{\"ID\":\"T1\",\"Label\":\"test\",\"Icon\":\"svelte\",\"Menu\":null}"
+#define blankLabel "{\"I\":\"T1\"}"
+#define blankLabelExpected "{\"ID\":\"T1\",\"Label\":null,\"Icon\":null,\"Menu\":null}"
+#define blankMenu "{\"I\":\"T1\"}"
+#define blankMenuExpected "{\"ID\":\"T1\",\"Label\":null,\"Icon\":null,\"Menu\":null}"
+#define menuTextItem "{\"I\":\"T1\",\"l\":\"test\",\"m\":[{\"I\":\"1\",\"l\":\"test\",\"t\":\"t\"}]}"
+#define menuTextItemExpected "{\"ID\":\"T1\",\"Label\":\"test\",\"Icon\":null,\"Menu\":{\"Label\":\"\",\"Items\":[{\"ID\":\"1\",\"label\":\"test\",\"alternateLabel\":null,\"disabled\":false,\"hidden\":false,\"colour\":null,\"font\":null,\"fontsize\":0,\"image\":null,\"acceleratorKey\":null,\"hasCallback\":false,\"type\":\"Text\",\"checked\":false}]}}"
+#define checkboxItem "{\"I\":\"T1\",\"m\":[{\"I\":\"1\",\"l\":\"test\",\"t\":\"c\",\"c\":true}]}"
+#define checkboxItemExpected "{\"ID\":\"T1\",\"Label\":null,\"Icon\":null,\"Menu\":{\"Label\":\"\",\"Items\":[{\"ID\":\"1\",\"label\":\"test\",\"alternateLabel\":null,\"disabled\":false,\"hidden\":false,\"colour\":null,\"font\":null,\"fontsize\":0,\"image\":null,\"acceleratorKey\":null,\"hasCallback\":false,\"type\":\"Checkbox\",\"checked\":true}]}}"
+#define radioGroupItems "{\"I\":\"T1\",\"m\":[{\"I\":\"1\",\"l\":\"option 1\",\"t\":\"r\",\"c\":true},{\"I\":\"2\",\"l\":\"option 2\",\"t\":\"r\"},{\"I\":\"3\",\"l\":\"option 3\",\"t\":\"r\"}],\"r\":[{\"Members\":[\"1\",\"2\",\"3\"],\"Length\":3}]}"
+#define radioGroupItemsExpected ""
+#define callbackItem "{\"I\":\"T1\",\"m\":[{\"I\":\"1\",\"l\":\"Preferences\",\"t\":\"t\",\"C\":true}]}"
+#define callbackItemExpected ""
+
+const char* tests[] = {
+        empty, emptyExpected,
+        labelOnly, labelOnlyExpected,
+        iconOnly, iconOnlyExpected,
+        iconLabel, iconLabelExpected,
+        blankLabel, blankLabelExpected,
+        blankMenu, blankMenuExpected,
+        menuTextItem, menuTextItemExpected,
+        checkboxItem, checkboxItemExpected,
+        radioGroupItems, radioGroupItemsExpected,
+        callbackItem, callbackItemExpected,
+};
+
+MU_TEST(manager_creation) {
+    MenuManager* manager = NewMenuManager();
+    mu_assert(manager->applicationMenu == NULL, "app menu");
+    mu_assert(manager->contextMenuData == NULL, "context menu data");
+    mu_assert_int_eq(hashmap_num_entries(&manager->contextMenus), 0);
+    mu_assert_int_eq(hashmap_num_entries(&manager->trayMenus), 0);
+    mu_assert_int_eq(hashmap_num_entries(&manager->menuItems), 0);
+    DeleteMenuManager(manager);
+}
+
+MU_TEST(add_tray) {
+    for( int count = 0; count < sizeof(tests) / sizeof(tests[0]); count += 2 ) {
+        MenuManager* manager = NewMenuManager();
+        TrayMenu* tray = AddTrayMenu(manager, tests[count]);
+        const char* trayJSON = TrayMenuAsJSON(tray);
+        mu_assert_string_eq(tests[count+1], trayJSON);
+        DeleteMenuManager(manager);
+    }
+}
+
+MU_TEST_SUITE(test_suite) {
+    MU_RUN_TEST(manager_creation);
+    MU_RUN_TEST(add_tray);
+}
+
+int main(int argc, char *argv[]) {
+    MU_RUN_SUITE(test_suite);
+    MU_REPORT();
+    return MU_EXIT_CODE;
+}

v2/internal/ffenestri/traymenu_darwin.c

@@ -0,0 +1,178 @@
+//
+// Created by Lea Anthony on 12/1/21.
+//
+
+#include "common.h"
+#include "traymenu_darwin.h"
+#include "trayicons.h"
+
+// A cache for all our tray menu icons
+// Global because it's a singleton
+struct hashmap_s trayIconCache;
+
+TrayMenu* NewTrayMenu(const char* menuJSON, struct TrayMenuStore* store) {
+    TrayMenu* result = malloc(sizeof(TrayMenu));
+
+/*
+ {"ID":"0","Label":"Test Tray Label","Icon":"","ProcessedMenu":{"Menu":{"Items":[{"ID":"0","Label":"Show Window","Type":"Text","Disabled":false,"Hidden":false,"Checked":false,"Foreground":0,"Background":0},{"ID":"1","Label":"Hide Window","Type":"Text","Disabled":false,"Hidden":false,"Checked":false,"Foreground":0,"Background":0},{"ID":"2","Label":"Minimise Window","Type":"Text","Disabled":false,"Hidden":false,"Checked":false,"Foreground":0,"Background":0},{"ID":"3","Label":"Unminimise Window","Type":"Text","Disabled":false,"Hidden":false,"Checked":false,"Foreground":0,"Background":0}]},"RadioGroups":null}}
+*/
+    JsonNode* processedJSON = json_decode(menuJSON);
+    if( processedJSON == NULL ) {
+        ABORT("[NewTrayMenu] Unable to parse TrayMenu JSON: %s", menuJSON);
+    }
+
+    // TODO: Make this configurable
+    result->trayIconPosition = NSImageLeft;
+
+    result->ID = STRCOPY(mustJSONString(processedJSON, "I"));
+    result->label = STRCOPY(getJSONString(processedJSON, "l"));
+    result->icon = STRCOPY(getJSONString(processedJSON, "i"));
+    result->menu = NULL;
+
+    JsonNode* menu = getJSONObject(processedJSON, "m");
+    if( menu != NULL ) {
+
+        JsonNode* radioGroups = getJSONObject(processedJSON, "r");
+
+        // Create the menu
+        result->menu = NewMenu(menu, radioGroups, store);
+        result->menu->menuType = TrayMenuType;
+    }
+
+    // Init tray status bar item
+    result->statusbaritem = NULL;
+
+    // Free JSON
+    json_delete(processedJSON);
+
+    return result;
+}
+
+void DumpTrayMenu(TrayMenu* trayMenu) {
+    printf("    ['%s':%p] = { label: '%s', icon: '%s', menu: %p, statusbar: %p  }\n", trayMenu->ID, trayMenu, trayMenu->label, trayMenu->icon, trayMenu->menu, trayMenu->statusbaritem );
+}
+
+
+void UpdateTrayIcon(TrayMenu *trayMenu) {
+
+    // Exit early if NULL
+    if( trayMenu->icon == NULL ) {
+        return;
+    }
+
+    id statusBarButton = msg(trayMenu->statusbaritem, s("button"));
+
+    // Empty icon means remove it
+    if( STREMPTY(trayMenu->icon) ) {
+        // Remove image
+        msg(statusBarButton, s("setImage:"), NULL);
+        return;
+    }
+
+    id trayImage = hashmap_get(&trayIconCache, trayMenu->icon, strlen(trayMenu->icon));
+    msg(statusBarButton, s("setImagePosition:"), trayMenu->trayIconPosition);
+    msg(statusBarButton, s("setImage:"), trayImage);
+}
+
+
+
+void ShowTrayMenu(TrayMenu* trayMenu) {
+
+    // Create a status bar item if we don't have one
+    if( trayMenu->statusbaritem == NULL ) {
+        id statusBar = msg( c("NSStatusBar"), s("systemStatusBar") );
+        trayMenu->statusbaritem = msg(statusBar, s("statusItemWithLength:"), NSVariableStatusItemLength);
+        msg(trayMenu->statusbaritem, s("retain"));
+
+    }
+
+    id statusBarButton = msg(trayMenu->statusbaritem, s("button"));
+    msg(statusBarButton, s("setImagePosition:"), trayMenu->trayIconPosition);
+
+    // Update the icon if needed
+    UpdateTrayIcon(trayMenu);
+
+    // Update the label if needed
+    UpdateTrayLabel(trayMenu, trayMenu->label);
+
+    // Update the menu
+    if (trayMenu->menu != NULL ) {
+        msg(trayMenu->statusbaritem, s("setMenu:"), trayMenu->menu->menu);
+    }
+}
+
+// UpdateTrayMenuInPlace receives 2 menus. The current menu gets
+// updated with the data from the new menu.
+void UpdateTrayMenuInPlace(TrayMenu* currentMenu, TrayMenu* newMenu) {
+
+    // Delete the old menu
+    DeleteMenu(currentMenu->menu);
+
+    // Set the new one
+    currentMenu->menu = newMenu->menu;
+
+    // Copy the other data
+    currentMenu->ID = STRCOPY(newMenu->ID);
+    currentMenu->label = STRCOPY(newMenu->label);
+    currentMenu->trayIconPosition = newMenu->trayIconPosition;
+    currentMenu->icon = STRCOPY(newMenu->icon);
+
+}
+
+void DeleteTrayMenu(TrayMenu* trayMenu) {
+
+//    printf("Freeing TrayMenu:\n");
+//    DumpTrayMenu(trayMenu);
+
+    // Delete the menu
+    DeleteMenu(trayMenu->menu);
+
+    // Free strings
+    MEMFREE(trayMenu->label);
+    MEMFREE(trayMenu->icon);
+    MEMFREE(trayMenu->ID);
+
+    // Free the status item
+    if ( trayMenu->statusbaritem != NULL ) {
+        id statusBar = msg( c("NSStatusBar"), s("systemStatusBar") );
+        msg(statusBar, s("removeStatusItem:"), trayMenu->statusbaritem);
+        msg(trayMenu->statusbaritem, s("release"));
+        trayMenu->statusbaritem = NULL;
+    }
+
+    // Free the tray menu memory
+    MEMFREE(trayMenu);
+}
+
+void LoadTrayIcons() {
+
+    // Allocate the Tray Icons
+    if( 0 != hashmap_create((const unsigned)4, &trayIconCache)) {
+        // Couldn't allocate map
+        ABORT("Not enough memory to allocate trayIconCache!");
+    }
+
+    unsigned int count = 0;
+    while( 1 ) {
+        const unsigned char *name = trayIcons[count++];
+        if( name == 0x00 ) {
+            break;
+        }
+        const unsigned char *lengthAsString = trayIcons[count++];
+        if( name == 0x00 ) {
+            break;
+        }
+        const unsigned char *data = trayIcons[count++];
+        if( data == 0x00 ) {
+            break;
+        }
+        int length = atoi((const char *)lengthAsString);
+
+        // Create the icon and add to the hashmap
+        id imageData = msg(c("NSData"), s("dataWithBytes:length:"), data, length);
+        id trayImage = ALLOC("NSImage");
+        msg(trayImage, s("initWithData:"), imageData);
+        hashmap_put(&trayIconCache, (const char *)name, strlen((const char *)name), trayImage);
+    }
+}
+

v2/internal/ffenestri/traymenu_darwin.h

@@ -0,0 +1,35 @@
+//
+// Created by Lea Anthony on 12/1/21.
+//
+
+#ifndef TRAYMENU_DARWIN_H
+#define TRAYMENU_DARWIN_H
+
+#include "common.h"
+#include "menu_darwin_old.h"
+
+typedef struct {
+
+    const char *label;
+    const char *icon;
+    const char *ID;
+
+    Menu* menu;
+
+    id statusbaritem;
+    int trayIconPosition;
+} TrayMenu;
+
+TrayMenu* NewTrayMenu(const char *trayJSON, struct TrayMenuStore* store);
+void DumpTrayMenu(TrayMenu* trayMenu);
+void ShowTrayMenu(TrayMenu* trayMenu);
+void UpdateTrayMenuInPlace(TrayMenu* currentMenu, TrayMenu* newMenu);
+void UpdateTrayIcon(TrayMenu *trayMenu);
+void UpdateTrayLabel(TrayMenu *trayMenu, const char*);
+
+void LoadTrayIcons();
+void UnloadTrayIcons();
+
+void DeleteTrayMenu(TrayMenu* trayMenu);
+
+#endif //TRAYMENU_DARWIN_H

v2/internal/ffenestri/traymenustore_darwin.c

@@ -0,0 +1,150 @@
+//
+// Created by Lea Anthony on 12/1/21.
+//
+
+#include "common.h"
+#include "traymenustore_darwin.h"
+#include "traymenu_darwin.h"
+#include <stdlib.h>
+
+TrayMenuStore* NewTrayMenuStore() {
+
+    TrayMenuStore* result = malloc(sizeof(TrayMenuStore));
+
+    // Allocate Tray Menu Store
+    if( 0 != hashmap_create((const unsigned)4, &result->trayMenuMap)) {
+        ABORT("[NewTrayMenuStore] Not enough memory to allocate trayMenuMap!");
+    }
+
+    // Allocate menu item store
+    if( 0 != hashmap_create((const unsigned)8, &result->menuItemMap)) {
+        ABORT("[NewTrayMenuStore] Not enough memory to allocate menuItemMap!");
+    }
+
+    return result;
+}
+
+int dumpTrayMenu(void *const context, struct hashmap_element_s *const e) {
+    DumpTrayMenu(e->data);
+    return 0;
+}
+
+void DumpTrayMenuStore(TrayMenuStore* store) {
+    hashmap_iterate_pairs(&store->trayMenuMap, dumpTrayMenu, NULL);
+}
+
+void AddTrayMenuToStore(TrayMenuStore* store, const char* menuJSON) {
+    TrayMenu* newMenu = NewTrayMenu(menuJSON, (struct TrayMenuStore *) store);
+
+    //TODO: check if there is already an entry for this menu
+    hashmap_put(&store->trayMenuMap, newMenu->ID, strlen(newMenu->ID), newMenu);
+
+}
+
+int showTrayMenu(void *const context, struct hashmap_element_s *const e) {
+    ShowTrayMenu(e->data);
+    // 0 to retain element, -1 to delete.
+    return 0;
+}
+
+void ShowTrayMenusInStore(TrayMenuStore* store) {
+    if( hashmap_num_entries(&store->trayMenuMap) > 0 ) {
+        hashmap_iterate_pairs(&store->trayMenuMap, showTrayMenu, NULL);
+    }
+}
+
+
+int freeTrayMenu(void *const context, struct hashmap_element_s *const e) {
+    DeleteTrayMenu(e->data);
+    return -1;
+}
+
+void DeleteTrayMenuStore(TrayMenuStore *store) {
+
+    // Delete context menus
+    if (hashmap_num_entries(&store->trayMenuMap) > 0) {
+        if (0 != hashmap_iterate_pairs(&store->trayMenuMap, freeTrayMenu, NULL)) {
+            ABORT("[DeleteContextMenuStore] Failed to release contextMenuStore entries!");
+        }
+    }
+
+    // Destroy tray menu map
+    hashmap_destroy(&store->trayMenuMap);
+
+    // Destroy menu item map
+    hashmap_destroy(&store->menuItemMap);
+}
+
+TrayMenu* GetTrayMenuFromStore(TrayMenuStore* store, const char* menuID) {
+    // Get the current menu
+    return hashmap_get(&store->trayMenuMap, menuID, strlen(menuID));
+}
+
+TrayMenu* MustGetTrayMenuFromStore(TrayMenuStore* store, const char* menuID) {
+    // Get the current menu
+    TrayMenu* result = hashmap_get(&store->trayMenuMap, menuID, strlen(menuID));
+    if (result == NULL ) {
+        ABORT("Unable to find TrayMenu with ID '%s' in the TrayMenuStore!", menuID);
+    }
+    return result;
+}
+
+id GetMenuItemFromStore(TrayMenuStore* store, const char* menuItemID) {
+    return hashmap_get(&store->menuItemMap, menuItemID, strlen(menuItemID));
+}
+
+void SaveMenuItemInStore(TrayMenuStore* store, const char* menuItemID, id nsmenuitem) {
+    hashmap_put(&store->menuItemMap, menuItemID, strlen(menuItemID), nsmenuitem);
+}
+
+
+void UpdateTrayMenuLabelInStore(TrayMenuStore* store, const char* JSON) {
+    // Parse the JSON
+    JsonNode *parsedUpdate = mustParseJSON(JSON);
+
+    // Get the data out
+    const char* ID = mustJSONString(parsedUpdate, "ID");
+    const char* Label = mustJSONString(parsedUpdate, "Label");
+
+    // Check we have this menu
+    TrayMenu *menu = MustGetTrayMenuFromStore(store, ID);
+    UpdateTrayLabel(menu, Label);
+
+}
+
+TrayMenu* UpdateTrayMenuInStore(TrayMenuStore* store, const char* menuJSON) {
+    TrayMenu* newMenu = NewTrayMenu(menuJSON, (struct TrayMenuStore *) store);
+
+    // Get the current menu
+    TrayMenu *currentMenu = GetTrayMenuFromStore(store, newMenu->ID);
+
+    // If we don't have a menu, we create one
+    if ( currentMenu == NULL ) {
+        // Store the new menu
+        hashmap_put(&store->trayMenuMap, newMenu->ID, strlen(newMenu->ID), newMenu);
+
+        return newMenu;
+    }
+
+    // Save the status bar reference
+    newMenu->statusbaritem = currentMenu->statusbaritem;
+
+    hashmap_remove(&store->trayMenuMap, newMenu->ID, strlen(newMenu->ID));
+
+    // Delete the current menu
+    DeleteMenu(currentMenu->menu);
+    currentMenu->menu = NULL;
+
+    // Free the tray menu memory
+    MEMFREE(currentMenu);
+
+    hashmap_put(&store->trayMenuMap, newMenu->ID, strlen(newMenu->ID), newMenu);
+
+    return newMenu;
+
+}
+
+const char* GetContextMenuDataFromStore(TrayMenuStore *store) {
+    return store->contextMenuData;
+}
+

v2/internal/ffenestri/traymenustore_darwin.h

@@ -0,0 +1,40 @@
+//
+// Created by Lea Anthony on 7/1/21.
+//
+
+#ifndef TRAYMENUSTORE_DARWIN_H
+#define TRAYMENUSTORE_DARWIN_H
+
+#include "traymenu_darwin.h"
+
+typedef struct {
+
+	int dummy;
+
+    // This is our tray menu map
+    // It maps tray IDs to TrayMenu*
+    struct hashmap_s trayMenuMap;
+
+    // This is our menu item map
+    // It maps menu Item IDs to NSMenuItems
+    struct hashmap_s menuItemMap;
+
+    const char* contextMenuData;
+
+} TrayMenuStore;
+
+TrayMenuStore* NewTrayMenuStore();
+
+void AddTrayMenuToStore(TrayMenuStore* store, const char* menuJSON);
+TrayMenu* UpdateTrayMenuInStore(TrayMenuStore* store, const char* menuJSON);
+void ShowTrayMenusInStore(TrayMenuStore* store);
+void DeleteTrayMenuStore(TrayMenuStore* store);
+
+void SaveMenuItemInStore(TrayMenuStore* store, const char* menuItemID, id nsmenuitem);
+
+TrayMenu* GetTrayMenuFromStore(TrayMenuStore* store, const char* menuID);
+id GetMenuItemFromStore(TrayMenuStore* store, const char* menuItemID);
+void UpdateTrayMenuLabelInStore(TrayMenuStore* store, const char* JSON);
+const char* GetContextMenuDataFromStore(TrayMenuStore *store);
+
+#endif //TRAYMENUSTORE_DARWIN_H

v2/internal/ffenestri/vec.h

@@ -44,6 +44,8 @@
   ( vec_splice_(vec_unpack_(v), start, count),\
     (v)->length -= (count) )
 
+#define vec_size(v) \
+    (v)->length
 
 #define vec_swapsplice(v, start, count)\
   ( vec_swapsplice_(vec_unpack_(v), start, count),\

v2/internal/menumanager/contextmenu.go

@@ -0,0 +1,65 @@
+package menumanager
+
+import "github.com/wailsapp/wails/v2/pkg/menu"
+
+//
+//import (
+//	"encoding/json"
+//	"fmt"
+//	"github.com/wailsapp/wails/v2/pkg/menu"
+//)
+//
+//type ContextMenu struct {
+//	ID            string
+//	ProcessedMenu *WailsMenu
+//	menuItemMap   *MenuItemMap
+//	menu          *menu.Menu
+//}
+//
+//func (t *ContextMenu) AsJSON() (string, error) {
+//	data, err := json.Marshal(t)
+//	if err != nil {
+//		return "", err
+//	}
+//	return string(data), nil
+//}
+//
+//func (m *Manager) NewContextMenu(contextMenu *menu.ContextMenu) *ContextMenu {
+//
+//	result := &ContextMenu{
+//		ID:          contextMenu.ID,
+//		menu:        contextMenu.Menu,
+//		menuItemMap: NewMenuItemMap(),
+//	}
+//
+//	result.menuItemMap.AddMenu(contextMenu.Menu)
+//	result.ProcessedMenu = m.NewWailsMenu(result.menuItemMap, result.menu)
+//
+//	return result
+//}
+//
+func (m *Manager) AddContextMenu(contextMenu *menu.ContextMenu) {
+	//
+	//	newContextMenu := m.NewContextMenu(contextMenu)
+	//
+	//	// Save the references
+	//	m.contextMenus[contextMenu.ID] = newContextMenu
+	//	m.contextMenuPointers[contextMenu] = contextMenu.ID
+}
+
+//
+func (m *Manager) UpdateContextMenu(contextMenu *menu.ContextMenu) (string, error) {
+	//	contextMenuID, contextMenuKnown := m.contextMenuPointers[contextMenu]
+	//	if !contextMenuKnown {
+	//		return "", fmt.Errorf("unknown Context Menu '%s'. Please add the context menu using AddContextMenu()", contextMenu.ID)
+	//	}
+	//
+	//	// Create the updated context menu
+	//	updatedContextMenu := m.NewContextMenu(contextMenu)
+	//
+	//	// Save the reference
+	//	m.contextMenus[contextMenuID] = updatedContextMenu
+	//
+	//	return updatedContextMenu.AsJSON()
+	return "", nil
+}

v2/internal/menumanager/menumanager.go

@@ -0,0 +1,54 @@
+package menumanager
+
+import (
+	"fmt"
+	"github.com/wailsapp/wails/v2/internal/counter"
+	"github.com/wailsapp/wails/v2/pkg/menu"
+)
+
+type Manager struct {
+
+	// MenuItemMap is a map of all menu items against a generated ID
+	menuItemMap        map[string]*menu.MenuItem
+	menuItemIDCounter  *counter.Counter
+	processedMenuItems map[*menu.MenuItem]*ProcessedMenuItem
+
+	// Menus
+	menuIDCounter *counter.Counter
+
+	// Map wails menus to internal menus
+	trayMenuMap       map[*menu.TrayMenu]*TrayMenu
+	trayMenuIDCounter *counter.Counter
+}
+
+func NewManager() *Manager {
+	return &Manager{
+		trayMenuMap:        make(map[*menu.TrayMenu]*TrayMenu),
+		trayMenuIDCounter:  counter.NewCounter(0),
+		menuIDCounter:      counter.NewCounter(0),
+		menuItemMap:        make(map[string]*menu.MenuItem),
+		menuItemIDCounter:  counter.NewCounter(0),
+		processedMenuItems: make(map[*menu.MenuItem]*ProcessedMenuItem),
+	}
+}
+
+func (m *Manager) ProcessClick(menuID string, data string) error {
+	// Get item from callback map
+	menuItem := m.menuItemMap[menuID]
+	if menuItem == nil {
+		return fmt.Errorf("menuItem doesn't exist")
+	}
+
+	if menuItem.Click == nil {
+		return fmt.Errorf("menuItem 'does not have a callback")
+	}
+
+	callbackData := &menu.CallbackData{
+		MenuItem:    menuItem,
+		ContextData: data,
+	}
+
+	// Callback!
+	go menuItem.Click(callbackData)
+	return nil
+}

v2/internal/menumanager/processedMenu.go

@@ -0,0 +1,256 @@
+package menumanager
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/wailsapp/wails/v2/pkg/menu"
+	"github.com/wailsapp/wails/v2/pkg/menu/keys"
+)
+
+type ProcessedMenu struct {
+	ID string `json:"I"`
+
+	Items       []*ProcessedMenuItem `json:"i,omitempty"`
+	RadioGroups []*RadioGroup        `json:"r,omitempty"`
+}
+
+func (m *Manager) ProcessMenu(menu *menu.Menu) *ProcessedMenu {
+	wm := m.NewWailsMenu(menu)
+
+	if len(wm.Menu) == 0 {
+		return nil
+	}
+
+	return &ProcessedMenu{
+		ID:          m.generateMenuID(),
+		Items:       wm.Menu,
+		RadioGroups: wm.RadioGroups,
+	}
+}
+
+type ProcessedMenuItem struct {
+	// ID of the menu item
+	ID string `json:"I"`
+
+	// Label is what appears as the menu text
+	Label string `json:"l,omitempty"`
+
+	// AlternateLabel is a secondary label (Used by Mac)
+	AlternateLabel string `json:"L,omitempty"`
+
+	// Role is a predefined menu type
+	Role menu.Role `json:"r,omitempty"`
+
+	// Accelerator holds a representation of a key binding
+	Accelerator *keys.Accelerator `json:"a,omitempty"`
+
+	// Type of MenuItem, EG: Checkbox, Text, Separator, Radio, Submenu
+	Type menu.Type `json:"t,omitempty"`
+
+	// Font to use for the menu item
+	Font string `json:"f,omitempty"`
+
+	// Font to use for the menu item
+	FontSize int `json:"F,omitempty"`
+
+	// RGBA is the colour of the menu item
+	RGBA string `json:"R,omitempty"`
+
+	// Image is an image for the menu item (base64 string)
+	Image string `json:"i,omitempty"`
+
+	// Disabled makes the item unselectable
+	Disabled *bool `json:"d,omitempty"`
+
+	// Hidden ensures that the item is not shown in the menu
+	Hidden *bool `json:"h,omitempty"`
+
+	// Checked indicates if the item is selected (used by Checkbox and Radio types only)
+	Checked *bool `json:"c,omitempty"`
+
+	// Submenu contains a list of menu items that will be shown as a submenu
+	//SubMenu []*MenuItem `json:"SubMenu,omitempty"`
+	SubMenu []*ProcessedMenuItem `json:"s,omitempty"`
+
+	// Indicates if this item has a callback
+	HasCallback *bool `json:"C,omitempty"`
+}
+
+func (m *Manager) generateMenuItemID() string {
+	return fmt.Sprintf("%d", m.menuItemIDCounter.Increment())
+}
+
+func (m *Manager) generateMenuID() string {
+	return fmt.Sprintf("%d", m.menuIDCounter.Increment())
+}
+
+func (m *Manager) NewProcessedMenuItem(menuItem *menu.MenuItem) *ProcessedMenuItem {
+
+	// Check if this menu has already been processed.
+	// This is to prevent duplicates.
+	existingMenuItem := m.processedMenuItems[menuItem]
+	if existingMenuItem != nil {
+		return &ProcessedMenuItem{ID: existingMenuItem.ID}
+	}
+
+	ID := m.generateMenuItemID()
+
+	result := &ProcessedMenuItem{
+		ID:             ID,
+		Label:          menuItem.Label,
+		AlternateLabel: menuItem.AlternateLabel,
+		Role:           menuItem.Role,
+		Accelerator:    menuItem.Accelerator,
+		Type:           menuItem.Type,
+		Font:           menuItem.Font,
+		FontSize:       menuItem.FontSize,
+		RGBA:           menuItem.RGBA,
+		Image:          menuItem.Image,
+		Disabled:       nil,
+		Hidden:         nil,
+		Checked:        nil,
+		SubMenu:        nil,
+		HasCallback:    nil,
+	}
+
+	if menuItem.Hidden {
+		result.Hidden = new(bool)
+		*result.Hidden = true
+	}
+
+	if menuItem.Disabled {
+		result.Disabled = new(bool)
+		*result.Disabled = true
+	}
+
+	if menuItem.Checked {
+		result.Checked = new(bool)
+		*result.Checked = true
+	}
+
+	if menuItem.Click != nil {
+		result.HasCallback = new(bool)
+		*result.HasCallback = true
+	}
+
+	if menuItem.SubMenu != nil {
+		result.SubMenu = m.NewProcessedMenu(menuItem.SubMenu)
+	}
+
+	// Add menu item to item map
+	m.menuItemMap[ID] = menuItem
+
+	// Add processed Item to processedMenuItems
+	m.processedMenuItems[menuItem] = result
+
+	return result
+}
+
+func (m *Manager) NewProcessedMenu(menu *menu.Menu) []*ProcessedMenuItem {
+
+	if menu == nil {
+		return nil
+	}
+
+	if menu.Items == nil {
+		return nil
+	}
+
+	var result []*ProcessedMenuItem
+
+	for _, item := range menu.Items {
+		processedMenuItem := m.NewProcessedMenuItem(item)
+		result = append(result, processedMenuItem)
+	}
+
+	return result
+}
+
+// WailsMenu is the original menu with the addition
+// of radio groups extracted from the menu data
+type WailsMenu struct {
+	Menu              []*ProcessedMenuItem `json:",omitempty"`
+	RadioGroups       []*RadioGroup        `json:",omitempty"`
+	currentRadioGroup []string
+}
+
+// RadioGroup holds all the members of the same radio group
+type RadioGroup struct {
+	Members []string
+	Length  int
+}
+
+func (m *Manager) NewWailsMenu(menu *menu.Menu) *WailsMenu {
+
+	result := &WailsMenu{}
+
+	// Process the menus
+	result.Menu = m.NewProcessedMenu(menu)
+
+	// Process the radio groups
+	result.processRadioGroups()
+
+	return result
+}
+
+func (w *WailsMenu) AsJSON() (string, error) {
+
+	menuAsJSON, err := json.Marshal(w)
+	if err != nil {
+		return "", err
+	}
+	return string(menuAsJSON), nil
+}
+
+func (w *WailsMenu) processMenuItemForRadioGroups(item *ProcessedMenuItem) {
+
+	switch item.Type {
+
+	// We need to recurse submenus
+	case menu.SubmenuType:
+
+		// Finalise any current radio groups as they don't trickle down to submenus
+		w.finaliseRadioGroup()
+
+		// Process each submenu item
+		for _, subitem := range item.SubMenu {
+			w.processMenuItemForRadioGroups(subitem)
+		}
+	case menu.RadioType:
+		// Add the item to the radio group
+		w.currentRadioGroup = append(w.currentRadioGroup, item.ID)
+	default:
+		w.finaliseRadioGroup()
+	}
+}
+
+func (w *WailsMenu) processRadioGroups() {
+
+	if w.Menu == nil {
+		return
+	}
+	// Loop over top level menus
+	for _, item := range w.Menu {
+		// Process MenuItem
+		w.processMenuItemForRadioGroups(item)
+	}
+
+	w.finaliseRadioGroup()
+}
+
+func (w *WailsMenu) finaliseRadioGroup() {
+
+	// If we were processing a radio group, fix up the references
+	if len(w.currentRadioGroup) > 0 {
+
+		// Create new radiogroup
+		group := &RadioGroup{
+			Members: w.currentRadioGroup,
+			Length:  len(w.currentRadioGroup),
+		}
+		w.RadioGroups = append(w.RadioGroups, group)
+
+		// Empty the radio group
+		w.currentRadioGroup = []string{}
+	}
+}

v2/internal/menumanager/traymenu.go

@@ -0,0 +1,79 @@
+package menumanager
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/wailsapp/wails/v2/pkg/menu"
+)
+
+type TrayMenu struct {
+	ID    string         `json:"I"`
+	Label string         `json:"l,omitempty"`
+	Icon  string         `json:"i,omitempty"`
+	Menu  *ProcessedMenu `json:"m,omitempty"`
+}
+
+func (t *TrayMenu) AsJSON() (string, error) {
+	data, err := json.Marshal(t)
+	if err != nil {
+		return "", err
+	}
+	return string(data), nil
+}
+
+func (m *Manager) newTrayMenu(trayMenu *menu.TrayMenu) *TrayMenu {
+
+	result := TrayMenu{
+		ID:    m.generateTrayID(),
+		Label: trayMenu.Label,
+		Icon:  trayMenu.Icon,
+		Menu:  m.ProcessMenu(trayMenu.Menu),
+	}
+
+	return &result
+}
+
+func (m *Manager) AddTrayMenu(trayMenu *menu.TrayMenu) *TrayMenu {
+
+	result := m.newTrayMenu(trayMenu)
+
+	// Add to map
+	m.trayMenuMap[trayMenu] = result
+
+	return result
+}
+
+func (m *Manager) generateTrayID() string {
+	return fmt.Sprintf("T%d", m.trayMenuIDCounter.Increment())
+}
+
+func (m *Manager) GetTrayMenus() ([]*TrayMenu, error) {
+	var result []*TrayMenu
+	for _, trayMenu := range m.trayMenuMap {
+		result = append(result, trayMenu)
+	}
+
+	return result, nil
+}
+
+func (m *Manager) GetTrayMenusAsJSON() ([]string, error) {
+	var result []string
+	for _, trayMenu := range m.trayMenuMap {
+		JSON, err := trayMenu.AsJSON()
+		if err != nil {
+			return nil, err
+		}
+		result = append(result, JSON)
+	}
+
+	return result, nil
+}
+
+// SetTrayMenu updates or creates a menu
+func (m *Manager) SetTrayMenu(trayMenu *menu.TrayMenu) (string, error) {
+	return "", nil
+}
+
+func (m *Manager) UpdateTrayMenuLabel(trayMenu *menu.TrayMenu) (string, error) {
+	return "", nil
+}

v2/internal/menumanager/traymenu_test.go

@@ -0,0 +1,99 @@
+package menumanager
+
+import (
+	"github.com/matryer/is"
+	"github.com/wailsapp/wails/v2/pkg/menu"
+	"testing"
+)
+
+func TestManager_AddTrayMenu(t *testing.T) {
+
+	is := is.New(t)
+
+	simpleLabel := menu.Text("test", nil, nil)
+	checkbox := menu.Checkbox("test", true, nil, nil)
+	radioGroup1 := menu.Radio("option 1", true, nil, nil)
+	radioGroup2 := menu.Radio("option 2", false, nil, nil)
+	radioGroup3 := menu.Radio("option 3", false, nil, nil)
+	callback := menu.Text("Preferences", nil, func(_ *menu.CallbackData) {})
+
+	empty := &menu.TrayMenu{}
+	labelOnly := &menu.TrayMenu{Label: "test"}
+	iconOnly := &menu.TrayMenu{Icon: "svelte"}
+	iconLabel := &menu.TrayMenu{Icon: "svelte", Label: "test"}
+	blankLabel := &menu.TrayMenu{Label: ""}
+	blankMenu := &menu.TrayMenu{Menu: menu.NewMenu()}
+	menuTextItem := &menu.TrayMenu{Menu: menu.NewMenuFromItems(simpleLabel)}
+	checkboxItem := &menu.TrayMenu{Menu: menu.NewMenuFromItems(checkbox)}
+	radioGroupItems := &menu.TrayMenu{Menu: menu.NewMenuFromItems(radioGroup1, radioGroup2, radioGroup3)}
+	callbackItem := &menu.TrayMenu{Menu: menu.NewMenuFromItems(callback)}
+
+	tests := []struct {
+		trayMenu *menu.TrayMenu
+		want     string
+	}{
+		{empty, "{\"I\":\"T1\"}"},
+		{labelOnly, "{\"I\":\"T1\",\"l\":\"test\"}"},
+		{iconOnly, "{\"I\":\"T1\",\"i\":\"svelte\"}"},
+		{iconLabel, "{\"I\":\"T1\",\"l\":\"test\",\"i\":\"svelte\"}"},
+		{blankLabel, "{\"I\":\"T1\"}"},
+		{blankMenu, "{\"I\":\"T1\"}"},
+		{menuTextItem, "{\"I\":\"T1\",\"m\":{\"I\":\"1\",\"i\":[{\"I\":\"1\",\"l\":\"test\",\"t\":\"t\"}]}}"},
+		{checkboxItem, "{\"I\":\"T1\",\"m\":{\"I\":\"1\",\"i\":[{\"I\":\"1\",\"l\":\"test\",\"t\":\"c\",\"c\":true}]}}"},
+		{radioGroupItems, "{\"I\":\"T1\",\"m\":[{\"I\":\"1\",\"l\":\"option 1\",\"t\":\"r\",\"c\":true},{\"I\":\"2\",\"l\":\"option 2\",\"t\":\"r\"},{\"I\":\"3\",\"l\":\"option 3\",\"t\":\"r\"}],\"r\":[{\"Members\":[\"1\",\"2\",\"3\"],\"Length\":3}]}"},
+		{callbackItem, "{\"I\":\"T1\",\"m\":[{\"I\":\"1\",\"l\":\"Preferences\",\"t\":\"t\",\"C\":true}]}"},
+	}
+	for _, tt := range tests {
+		m := NewManager()
+		got := m.AddTrayMenu(tt.trayMenu)
+		JSON, err := got.AsJSON()
+		is.NoErr(err)
+		is.Equal(JSON, tt.want)
+	}
+
+}
+
+func TestManager_CallbackMap(t *testing.T) {
+
+	is := is.New(t)
+
+	simpleLabel := menu.Text("test", nil, nil)
+	simpleLabelWithCallback := menu.Text("test", nil, func(_ *menu.CallbackData) {})
+	checkboxWithCallback := menu.Checkbox("test", true, nil, func(_ *menu.CallbackData) {})
+	submenu := menu.SubMenu("test", menu.NewMenuFromItems(checkboxWithCallback))
+
+	blankMenu := &menu.TrayMenu{Menu: menu.NewMenu()}
+	noCallback := &menu.TrayMenu{Menu: menu.NewMenuFromItems(simpleLabel)}
+	oneMenuWithCallback := &menu.TrayMenu{Menu: menu.NewMenuFromItems(simpleLabelWithCallback)}
+	duplicateCallbacks := &menu.TrayMenu{Menu: menu.NewMenuFromItems(simpleLabelWithCallback, simpleLabelWithCallback)}
+	twoMenusWithCallbacks := &menu.TrayMenu{Menu: menu.NewMenuFromItems(simpleLabelWithCallback, checkboxWithCallback)}
+	duplicateMenusWithCallbacks := &menu.TrayMenu{Menu: menu.NewMenuFromItems(simpleLabelWithCallback, checkboxWithCallback, simpleLabelWithCallback, checkboxWithCallback)}
+	submenuWithCallback := &menu.TrayMenu{Menu: menu.NewMenuFromItems(submenu)}
+	duplicateSubmenus := &menu.TrayMenu{Menu: menu.NewMenuFromItems(submenu, submenu)}
+
+	tests := []struct {
+		trayMenu  *menu.TrayMenu
+		trays     int
+		menuItems int
+		JSON      string
+	}{
+		{blankMenu, 1, 0, "{\"I\":\"T1\"}"},
+		{noCallback, 1, 1, "{\"I\":\"T1\",\"m\":[{\"I\":\"1\",\"l\":\"test\",\"t\":\"t\"}]}"},
+		{oneMenuWithCallback, 1, 1, "{\"I\":\"T1\",\"m\":[{\"I\":\"1\",\"l\":\"test\",\"t\":\"t\",\"C\":true}]}"},
+		{duplicateCallbacks, 1, 1, "{\"I\":\"T1\",\"m\":[{\"I\":\"1\",\"l\":\"test\",\"t\":\"t\",\"C\":true},{\"I\":\"1\"}]}"},
+		{twoMenusWithCallbacks, 1, 2, "{\"I\":\"T1\",\"m\":[{\"I\":\"1\",\"l\":\"test\",\"t\":\"t\",\"C\":true},{\"I\":\"2\",\"l\":\"test\",\"t\":\"c\",\"c\":true,\"C\":true}]}"},
+		{duplicateMenusWithCallbacks, 1, 2, "{\"I\":\"T1\",\"m\":[{\"I\":\"1\",\"l\":\"test\",\"t\":\"t\",\"C\":true},{\"I\":\"2\",\"l\":\"test\",\"t\":\"c\",\"c\":true,\"C\":true},{\"I\":\"1\"},{\"I\":\"2\"}]}"},
+		{submenuWithCallback, 1, 2, "{\"I\":\"T1\",\"m\":[{\"I\":\"1\",\"l\":\"test\",\"t\":\"S\",\"s\":[{\"I\":\"2\",\"l\":\"test\",\"t\":\"c\",\"c\":true,\"C\":true}]}]}"},
+		{duplicateSubmenus, 1, 2, "{\"I\":\"T1\",\"m\":[{\"I\":\"1\",\"l\":\"test\",\"t\":\"S\",\"s\":[{\"I\":\"2\",\"l\":\"test\",\"t\":\"c\",\"c\":true,\"C\":true}]},{\"I\":\"1\"}]}"},
+	}
+	for _, test := range tests {
+		m := NewManager()
+		tm := m.AddTrayMenu(test.trayMenu)
+		is.Equal(len(m.trayMenuMap), test.trays)
+		is.Equal(len(m.menuItemMap), test.menuItems)
+		JSON, err := tm.AsJSON()
+		is.NoErr(err)
+		is.Equal(JSON, test.JSON)
+	}
+
+}

v2/internal/messagedispatcher/dispatchclient.go

@@ -2,12 +2,10 @@ package messagedispatcher
 
 import (
 	"fmt"
-	"github.com/wailsapp/wails/v2/pkg/menu"
-
 	"github.com/wailsapp/wails/v2/internal/logger"
 	"github.com/wailsapp/wails/v2/internal/messagedispatcher/message"
 	"github.com/wailsapp/wails/v2/internal/servicebus"
-	"github.com/wailsapp/wails/v2/pkg/options"
+	"github.com/wailsapp/wails/v2/pkg/options/dialog"
 )
 
 // Client defines what a frontend client can do
@@ -15,9 +13,9 @@ type Client interface {
 	Quit()
 	NotifyEvent(message string)
 	CallResult(message string)
-	OpenDialog(dialogOptions *options.OpenDialog, callbackID string)
-	SaveDialog(dialogOptions *options.SaveDialog, callbackID string)
-	MessageDialog(dialogOptions *options.MessageDialog, callbackID string)
+	OpenDialog(dialogOptions *dialog.OpenDialog, callbackID string)
+	SaveDialog(dialogOptions *dialog.SaveDialog, callbackID string)
+	MessageDialog(dialogOptions *dialog.MessageDialog, callbackID string)
 	WindowSetTitle(title string)
 	WindowShow()
 	WindowHide()
@@ -32,11 +30,10 @@ type Client interface {
 	WindowUnFullscreen()
 	WindowSetColour(colour int)
 	DarkModeEnabled(callbackID string)
-	UpdateMenu(menu *menu.Menu)
-	UpdateTray(menu *menu.Menu)
-	UpdateTrayLabel(label string)
-	UpdateTrayIcon(name string)
-	UpdateContextMenus(contextMenus *menu.ContextMenus)
+	SetApplicationMenu(menuJSON string)
+	SetTrayMenu(trayMenuJSON string)
+	UpdateTrayMenuLabel(JSON string)
+	UpdateContextMenu(contextMenuJSON string)
 }
 
 // DispatchClient is what the frontends use to interface with the

v2/internal/messagedispatcher/message/messageparser.go

@@ -26,6 +26,10 @@ var messageParsers = map[byte]func(string) (*parsedMessage, error){
 // Parse will attempt to parse the given message
 func Parse(message string) (*parsedMessage, error) {
 
+	if len(message) == 0 {
+		return nil, fmt.Errorf("MessageParser received blank message");
+	}
+
 	parseMethod := messageParsers[message[0]]
 	if parseMethod == nil {
 		return nil, fmt.Errorf("message type '%c' invalid", message[0])

v2/internal/messagedispatcher/message/system.go

@@ -8,8 +8,8 @@ import (
 // systemMessageParser does what it says on the tin!
 func systemMessageParser(message string) (*parsedMessage, error) {
 
-	// Sanity check: system messages must be at least 4 bytes
-	if len(message) < 4 {
+	// Sanity check: system messages must be at least 2 bytes
+	if len(message) < 2 {
 		return nil, fmt.Errorf("system message was an invalid length")
 	}
 
@@ -23,6 +23,9 @@ func systemMessageParser(message string) (*parsedMessage, error) {
 	// Format of system response messages: S<command><callbackID>|<payload>
 	// DarkModeEnabled
 	case 'D':
+		if len(message) < 4 {
+			return nil, fmt.Errorf("system message was an invalid length")
+		}
 		message = message[1:]
 		idx := strings.IndexByte(message, '|')
 		if idx < 0 {
@@ -34,6 +37,10 @@ func systemMessageParser(message string) (*parsedMessage, error) {
 		topic := "systemresponse:" + callbackID
 		responseMessage = &parsedMessage{Topic: topic, Data: payloadData == "T"}
 
+		// This is our startup hook - the frontend is now ready
+	case 'S':
+		topic := "hooks:startup"
+		responseMessage = &parsedMessage{Topic: topic, Data: nil}
 	default:
 		return nil, fmt.Errorf("Invalid message to systemMessageParser()")
 	}

v2/internal/messagedispatcher/messagedispatcher.go

@@ -2,7 +2,7 @@ package messagedispatcher
 
 import (
 	"encoding/json"
-	"github.com/wailsapp/wails/v2/pkg/menu"
+	"github.com/wailsapp/wails/v2/pkg/options/dialog"
 	"strconv"
 	"strings"
 	"sync"
@@ -11,22 +11,19 @@ import (
 	"github.com/wailsapp/wails/v2/internal/logger"
 	"github.com/wailsapp/wails/v2/internal/messagedispatcher/message"
 	"github.com/wailsapp/wails/v2/internal/servicebus"
-	"github.com/wailsapp/wails/v2/pkg/options"
 )
 
 // Dispatcher translates messages received from the frontend
 // and publishes them onto the service bus
 type Dispatcher struct {
-	quitChannel        <-chan *servicebus.Message
-	resultChannel      <-chan *servicebus.Message
-	eventChannel       <-chan *servicebus.Message
-	windowChannel      <-chan *servicebus.Message
-	dialogChannel      <-chan *servicebus.Message
-	systemChannel      <-chan *servicebus.Message
-	menuChannel        <-chan *servicebus.Message
-	contextMenuChannel <-chan *servicebus.Message
-	trayChannel        <-chan *servicebus.Message
-	running            bool
+	quitChannel   <-chan *servicebus.Message
+	resultChannel <-chan *servicebus.Message
+	eventChannel  <-chan *servicebus.Message
+	windowChannel <-chan *servicebus.Message
+	dialogChannel <-chan *servicebus.Message
+	systemChannel <-chan *servicebus.Message
+	menuChannel   <-chan *servicebus.Message
+	running       bool
 
 	servicebus *servicebus.ServiceBus
 	logger     logger.CustomLogger
@@ -78,29 +75,17 @@ func New(servicebus *servicebus.ServiceBus, logger *logger.Logger) (*Dispatcher,
 		return nil, err
 	}
 
-	contextMenuChannel, err := servicebus.Subscribe("contextmenufrontend:")
-	if err != nil {
-		return nil, err
-	}
-
-	trayChannel, err := servicebus.Subscribe("trayfrontend:")
-	if err != nil {
-		return nil, err
-	}
-
 	result := &Dispatcher{
-		servicebus:         servicebus,
-		eventChannel:       eventChannel,
-		logger:             logger.CustomLogger("Message Dispatcher"),
-		clients:            make(map[string]*DispatchClient),
-		resultChannel:      resultChannel,
-		quitChannel:        quitChannel,
-		windowChannel:      windowChannel,
-		dialogChannel:      dialogChannel,
-		systemChannel:      systemChannel,
-		menuChannel:        menuChannel,
-		trayChannel:        trayChannel,
-		contextMenuChannel: contextMenuChannel,
+		servicebus:    servicebus,
+		eventChannel:  eventChannel,
+		logger:        logger.CustomLogger("Message Dispatcher"),
+		clients:       make(map[string]*DispatchClient),
+		resultChannel: resultChannel,
+		quitChannel:   quitChannel,
+		windowChannel: windowChannel,
+		dialogChannel: dialogChannel,
+		systemChannel: systemChannel,
+		menuChannel:   menuChannel,
 	}
 
 	return result, nil
@@ -132,10 +117,6 @@ func (d *Dispatcher) Start() error {
 				d.processSystemMessage(systemMessage)
 			case menuMessage := <-d.menuChannel:
 				d.processMenuMessage(menuMessage)
-			case contextMenuMessage := <-d.contextMenuChannel:
-				d.processContextMenuMessage(contextMenuMessage)
-			case trayMessage := <-d.trayChannel:
-				d.processTrayMessage(trayMessage)
 			}
 		}
 
@@ -389,7 +370,7 @@ func (d *Dispatcher) processDialogMessage(result *servicebus.Message) {
 		dialogType := splitTopic[2]
 		switch dialogType {
 		case "open":
-			dialogOptions, ok := result.Data().(*options.OpenDialog)
+			dialogOptions, ok := result.Data().(*dialog.OpenDialog)
 			if !ok {
 				d.logger.Error("Invalid data for 'dialog:select:open' : %#v", result.Data())
 				return
@@ -403,7 +384,7 @@ func (d *Dispatcher) processDialogMessage(result *servicebus.Message) {
 				client.frontend.OpenDialog(dialogOptions, callbackID)
 			}
 		case "save":
-			dialogOptions, ok := result.Data().(*options.SaveDialog)
+			dialogOptions, ok := result.Data().(*dialog.SaveDialog)
 			if !ok {
 				d.logger.Error("Invalid data for 'dialog:select:save' : %#v", result.Data())
 				return
@@ -417,7 +398,7 @@ func (d *Dispatcher) processDialogMessage(result *servicebus.Message) {
 				client.frontend.SaveDialog(dialogOptions, callbackID)
 			}
 		case "message":
-			dialogOptions, ok := result.Data().(*options.MessageDialog)
+			dialogOptions, ok := result.Data().(*dialog.MessageDialog)
 			if !ok {
 				d.logger.Error("Invalid data for 'dialog:select:message' : %#v", result.Data())
 				return
@@ -449,11 +430,11 @@ func (d *Dispatcher) processMenuMessage(result *servicebus.Message) {
 
 	command := splitTopic[1]
 	switch command {
-	case "update":
+	case "updateappmenu":
 
-		updatedMenu, ok := result.Data().(*menu.Menu)
+		updatedMenu, ok := result.Data().(string)
 		if !ok {
-			d.logger.Error("Invalid data for 'menufrontend:update' : %#v",
+			d.logger.Error("Invalid data for 'menufrontend:updateappmenu' : %#v",
 				result.Data())
 			return
 		}
@@ -461,94 +442,49 @@ func (d *Dispatcher) processMenuMessage(result *servicebus.Message) {
 		// TODO: Work out what we mean in a multi window environment...
 		// For now we will just pick the first one
 		for _, client := range d.clients {
-			client.frontend.UpdateMenu(updatedMenu)
-		}
-
-	default:
-		d.logger.Error("Unknown menufrontend command: %s", command)
-	}
-}
-func (d *Dispatcher) processContextMenuMessage(result *servicebus.Message) {
-	splitTopic := strings.Split(result.Topic(), ":")
-	if len(splitTopic) < 2 {
-		d.logger.Error("Invalid contextmenu message : %#v", result.Data())
-		return
-	}
-
-	command := splitTopic[1]
-	switch command {
-	case "update":
-
-		updatedContextMenus, ok := result.Data().(*menu.ContextMenus)
-		if !ok {
-			d.logger.Error("Invalid data for 'contextmenufrontend:update' : %#v",
-				result.Data())
-			return
-		}
-
-		// TODO: Work out what we mean in a multi window environment...
-		// For now we will just pick the first one
-		for _, client := range d.clients {
-			client.frontend.UpdateContextMenus(updatedContextMenus)
-		}
-
-	default:
-		d.logger.Error("Unknown contextmenufrontend command: %s", command)
-	}
-}
-
-func (d *Dispatcher) processTrayMessage(result *servicebus.Message) {
-	splitTopic := strings.Split(result.Topic(), ":")
-	if len(splitTopic) < 2 {
-		d.logger.Error("Invalid tray message : %#v", result.Data())
-		return
-	}
-
-	command := splitTopic[1]
-	switch command {
-	case "update":
-
-		updatedMenu, ok := result.Data().(*menu.Menu)
-		if !ok {
-			d.logger.Error("Invalid data for 'trayfrontend:update' : %#v",
-				result.Data())
-			return
-		}
-
-		// TODO: Work out what we mean in a multi window environment...
-		// For now we will just pick the first one
-		for _, client := range d.clients {
-			client.frontend.UpdateTray(updatedMenu)
-		}
-
-	case "setlabel":
-
-		updatedLabel, ok := result.Data().(string)
-		if !ok {
-			d.logger.Error("Invalid data for 'trayfrontend:setlabel' : %#v",
-				result.Data())
-			return
-		}
-
-		// TODO: Work out what we mean in a multi window environment...
-		// For now we will just pick the first one
-		for _, client := range d.clients {
-			client.frontend.UpdateTrayLabel(updatedLabel)
-		}
-
-	case "seticon":
-
-		iconname, ok := result.Data().(string)
-		if !ok {
-			d.logger.Error("Invalid data for 'trayfrontend:seticon' : %#v",
-				result.Data())
-			return
-		}
-
-		// TODO: Work out what we mean in a multi window environment...
-		// For now we will just pick the first one
-		for _, client := range d.clients {
-			client.frontend.UpdateTrayIcon(iconname)
+			client.frontend.SetApplicationMenu(updatedMenu)
+		}
+
+	case "settraymenu":
+		trayMenuJSON, ok := result.Data().(string)
+		if !ok {
+			d.logger.Error("Invalid data for 'menufrontend:settraymenu' : %#v",
+				result.Data())
+			return
+		}
+
+		// TODO: Work out what we mean in a multi window environment...
+		// For now we will just pick the first one
+		for _, client := range d.clients {
+			client.frontend.SetTrayMenu(trayMenuJSON)
+		}
+
+	case "updatecontextmenu":
+		updatedContextMenu, ok := result.Data().(string)
+		if !ok {
+			d.logger.Error("Invalid data for 'menufrontend:updatecontextmenu' : %#v",
+				result.Data())
+			return
+		}
+
+		// TODO: Work out what we mean in a multi window environment...
+		// For now we will just pick the first one
+		for _, client := range d.clients {
+			client.frontend.UpdateContextMenu(updatedContextMenu)
+		}
+
+	case "updatetraymenulabel":
+		updatedTrayMenuLabel, ok := result.Data().(string)
+		if !ok {
+			d.logger.Error("Invalid data for 'menufrontend:updatetraymenulabel' : %#v",
+				result.Data())
+			return
+		}
+
+		// TODO: Work out what we mean in a multi window environment...
+		// For now we will just pick the first one
+		for _, client := range d.clients {
+			client.frontend.UpdateTrayMenuLabel(updatedTrayMenuLabel)
 		}
 
 	default:

v2/internal/parse/parse.go

@@ -10,8 +10,6 @@ import (
 	"golang.org/x/tools/go/packages"
 )
 
-var internalMethods = slicer.String([]string{"WailsInit", "Wails Shutdown"})
-
 var structCache = make(map[string]*ParsedStruct)
 var boundStructs = make(map[string]*ParsedStruct)
 var boundMethods = []string{}
@@ -49,7 +47,7 @@ func ParseProject(projectPath string) (BoundStructs, error) {
 	cfg := &packages.Config{Mode: packages.NeedFiles | packages.NeedSyntax | packages.NeedTypesInfo}
 	pkgs, err := packages.Load(cfg, projectPath)
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "load: %v\n", err)
+		_, _ = fmt.Fprintf(os.Stderr, "load: %v\n", err)
 		os.Exit(1)
 	}
 	if packages.PrintErrors(pkgs) > 0 {
@@ -203,10 +201,6 @@ func ParseProject(projectPath string) (BoundStructs, error) {
 								// This is a struct pointer method
 								i, ok := se.X.(*ast.Ident)
 								if ok {
-									// We want to ignore Internal functions
-									if internalMethods.Contains(x.Name.Name) {
-										continue
-									}
 									// If we haven't already found this struct,
 									// Create a placeholder in the cache
 									parsedStruct := structCache[i.Name]
@@ -437,4 +431,6 @@ func ParseProject(projectPath string) (BoundStructs, error) {
 	println()
 	println("}")
 	println()
+
+	return nil, nil
 }

v2/internal/process/process.go

@@ -26,6 +26,7 @@ func NewProcess(logger *clilogger.CLILogger, cmd string, args ...string) *Proces
 // Start the process
 func (p *Process) Start() error {
 
+	p.cmd.
 	err := p.cmd.Start()
 	if err != nil {
 		return err

v2/internal/runtime/contextmenus.go

@@ -1,48 +0,0 @@
-package runtime
-
-import (
-	"github.com/wailsapp/wails/v2/internal/messagedispatcher/message"
-	"github.com/wailsapp/wails/v2/internal/servicebus"
-	"github.com/wailsapp/wails/v2/pkg/menu"
-)
-
-// ContextMenus defines all ContextMenu related operations
-type ContextMenus interface {
-	On(menuID string, callback func(*menu.MenuItem, string))
-	Update()
-	GetByID(menuID string) *menu.MenuItem
-	RemoveByID(id string) bool
-}
-
-type contextMenus struct {
-	bus          *servicebus.ServiceBus
-	contextmenus *menu.ContextMenus
-}
-
-// newContextMenus creates a new ContextMenu struct
-func newContextMenus(bus *servicebus.ServiceBus, contextmenus *menu.ContextMenus) ContextMenus {
-	return &contextMenus{
-		bus:          bus,
-		contextmenus: contextmenus,
-	}
-}
-
-// On registers a listener for a particular event
-func (t *contextMenus) On(menuID string, callback func(*menu.MenuItem, string)) {
-	t.bus.Publish("contextmenus:on", &message.ContextMenusOnMessage{
-		MenuID:   menuID,
-		Callback: callback,
-	})
-}
-
-func (t *contextMenus) Update() {
-	t.bus.Publish("contextmenus:update", t.contextmenus)
-}
-
-func (t *contextMenus) GetByID(menuItemID string) *menu.MenuItem {
-	return t.contextmenus.GetByID(menuItemID)
-}
-
-func (t *contextMenus) RemoveByID(menuItemID string) bool {
-	return t.contextmenus.RemoveByID(menuItemID)
-}

v2/internal/runtime/dialog.go

@@ -5,14 +5,14 @@ import (
 
 	"github.com/wailsapp/wails/v2/internal/crypto"
 	"github.com/wailsapp/wails/v2/internal/servicebus"
-	"github.com/wailsapp/wails/v2/pkg/options"
+	dialogoptions "github.com/wailsapp/wails/v2/pkg/options/dialog"
 )
 
 // Dialog defines all Dialog related operations
 type Dialog interface {
-	Open(dialogOptions *options.OpenDialog) []string
-	Save(dialogOptions *options.SaveDialog) string
-	Message(dialogOptions *options.MessageDialog) string
+	Open(dialogOptions *dialogoptions.OpenDialog) []string
+	Save(dialogOptions *dialogoptions.SaveDialog) string
+	Message(dialogOptions *dialogoptions.MessageDialog) string
 }
 
 // dialog exposes the Dialog interface
@@ -45,7 +45,7 @@ func (r *dialog) processTitleAndFilter(params ...string) (string, string) {
 }
 
 // Open prompts the user to select a file
-func (r *dialog) Open(dialogOptions *options.OpenDialog) []string {
+func (r *dialog) Open(dialogOptions *dialogoptions.OpenDialog) []string {
 
 	// Create unique dialog callback
 	uniqueCallback := crypto.RandomID()
@@ -70,7 +70,7 @@ func (r *dialog) Open(dialogOptions *options.OpenDialog) []string {
 }
 
 // Save prompts the user to select a file
-func (r *dialog) Save(dialogOptions *options.SaveDialog) string {
+func (r *dialog) Save(dialogOptions *dialogoptions.SaveDialog) string {
 
 	// Create unique dialog callback
 	uniqueCallback := crypto.RandomID()
@@ -95,7 +95,7 @@ func (r *dialog) Save(dialogOptions *options.SaveDialog) string {
 }
 
 // Message show a message to the user
-func (r *dialog) Message(dialogOptions *options.MessageDialog) string {
+func (r *dialog) Message(dialogOptions *dialogoptions.MessageDialog) string {
 
 	// Create unique dialog callback
 	uniqueCallback := crypto.RandomID()

v2/internal/runtime/menu.go

@@ -1,48 +1,41 @@
 package runtime
 
 import (
-	"github.com/wailsapp/wails/v2/internal/messagedispatcher/message"
 	"github.com/wailsapp/wails/v2/internal/servicebus"
 	"github.com/wailsapp/wails/v2/pkg/menu"
 )
 
 // Menu defines all Menu related operations
 type Menu interface {
-	On(menuID string, callback func(*menu.MenuItem))
-	Update()
-	GetByID(menuID string) *menu.MenuItem
-	RemoveByID(id string) bool
+	UpdateApplicationMenu()
+	UpdateContextMenu(contextMenu *menu.ContextMenu)
+	SetTrayMenu(trayMenu *menu.TrayMenu)
+	UpdateTrayMenuLabel(trayMenu *menu.TrayMenu)
 }
 
 type menuRuntime struct {
-	bus  *servicebus.ServiceBus
-	menu *menu.Menu
+	bus *servicebus.ServiceBus
 }
 
 // newMenu creates a new Menu struct
-func newMenu(bus *servicebus.ServiceBus, menu *menu.Menu) Menu {
+func newMenu(bus *servicebus.ServiceBus) Menu {
 	return &menuRuntime{
-		bus:  bus,
-		menu: menu,
+		bus: bus,
 	}
 }
 
-// On registers a listener for a particular event
-func (m *menuRuntime) On(menuID string, callback func(*menu.MenuItem)) {
-	m.bus.Publish("menu:on", &message.MenuOnMessage{
-		MenuID:   menuID,
-		Callback: callback,
-	})
+func (m *menuRuntime) UpdateApplicationMenu() {
+	m.bus.Publish("menu:updateappmenu", nil)
 }
 
-func (m *menuRuntime) Update() {
-	m.bus.Publish("menu:update", m.menu)
+func (m *menuRuntime) UpdateContextMenu(contextMenu *menu.ContextMenu) {
+	m.bus.Publish("menu:updatecontextmenu", contextMenu)
 }
 
-func (m *menuRuntime) GetByID(menuID string) *menu.MenuItem {
-	return m.menu.GetByID(menuID)
+func (m *menuRuntime) SetTrayMenu(trayMenu *menu.TrayMenu) {
+	m.bus.Publish("menu:settraymenu", trayMenu)
 }
 
-func (m *menuRuntime) RemoveByID(id string) bool {
-	return m.menu.RemoveByID(id)
+func (m *menuRuntime) UpdateTrayMenuLabel(trayMenu *menu.TrayMenu) {
+	m.bus.Publish("menu:updatetraymenulabel", trayMenu)
 }

v2/internal/runtime/runtime.go

@@ -2,37 +2,32 @@ package runtime
 
 import (
 	"github.com/wailsapp/wails/v2/internal/servicebus"
-	"github.com/wailsapp/wails/v2/pkg/menu"
 )
 
 // Runtime is a means for the user to interact with the application at runtime
 type Runtime struct {
-	Browser     Browser
-	Events      Events
-	Window      Window
-	Dialog      Dialog
-	System      System
-	Menu        Menu
-	ContextMenu ContextMenus
-	Tray        Tray
-	Store       *StoreProvider
-	Log         Log
-	bus         *servicebus.ServiceBus
+	Browser Browser
+	Events  Events
+	Window  Window
+	Dialog  Dialog
+	System  System
+	Menu    Menu
+	Store   *StoreProvider
+	Log     Log
+	bus     *servicebus.ServiceBus
 }
 
 // New creates a new runtime
-func New(serviceBus *servicebus.ServiceBus, menu *menu.Menu, trayMenu *menu.Tray, contextMenus *menu.ContextMenus) *Runtime {
+func New(serviceBus *servicebus.ServiceBus) *Runtime {
 	result := &Runtime{
-		Browser:     newBrowser(),
-		Events:      newEvents(serviceBus),
-		Window:      newWindow(serviceBus),
-		Dialog:      newDialog(serviceBus),
-		System:      newSystem(serviceBus),
-		Menu:        newMenu(serviceBus, menu),
-		Tray:        newTray(serviceBus, trayMenu),
-		ContextMenu: newContextMenus(serviceBus, contextMenus),
-		Log:         newLog(serviceBus),
-		bus:         serviceBus,
+		Browser: newBrowser(),
+		Events:  newEvents(serviceBus),
+		Window:  newWindow(serviceBus),
+		Dialog:  newDialog(serviceBus),
+		System:  newSystem(serviceBus),
+		Menu:    newMenu(serviceBus),
+		Log:     newLog(serviceBus),
+		bus:     serviceBus,
 	}
 	result.Store = newStore(result)
 	return result

v2/internal/runtime/system.go

@@ -44,6 +44,7 @@ func (r *system) IsDarkMode() bool {
 	systemResponseChannel, err := r.bus.Subscribe(responseTopic)
 	if err != nil {
 		fmt.Printf("ERROR: Cannot subscribe to bus topic: %+v\n", err.Error())
+		return false
 	}
 
 	message := "system:isdarkmode:" + uniqueCallback

v2/internal/runtime/tray.go

@@ -1,67 +0,0 @@
-package runtime
-
-import (
-	"github.com/wailsapp/wails/v2/internal/messagedispatcher/message"
-	"github.com/wailsapp/wails/v2/internal/servicebus"
-	"github.com/wailsapp/wails/v2/pkg/menu"
-)
-
-// Tray defines all Tray related operations
-type Tray interface {
-	NewTray(id string) *menu.Tray
-	On(menuID string, callback func(*menu.MenuItem))
-	Update(tray ...*menu.Tray)
-	GetByID(menuID string) *menu.MenuItem
-	RemoveByID(id string) bool
-	SetLabel(label string)
-	SetIcon(name string)
-}
-
-type trayRuntime struct {
-	bus      *servicebus.ServiceBus
-	trayMenu *menu.Tray
-}
-
-// newTray creates a new Menu struct
-func newTray(bus *servicebus.ServiceBus, menu *menu.Tray) Tray {
-	return &trayRuntime{
-		bus:      bus,
-		trayMenu: menu,
-	}
-}
-
-// On registers a listener for a particular event
-func (t *trayRuntime) On(menuID string, callback func(*menu.MenuItem)) {
-	t.bus.Publish("tray:on", &message.TrayOnMessage{
-		MenuID:   menuID,
-		Callback: callback,
-	})
-}
-
-// NewTray creates a new Tray item
-func (t *trayRuntime) NewTray(trayID string) *menu.Tray {
-	return &menu.Tray{
-		ID: trayID,
-	}
-}
-
-func (t *trayRuntime) Update(tray ...*menu.Tray) {
-
-	//trayToUpdate := t.trayMenu
-	t.bus.Publish("tray:update", t.trayMenu)
-}
-
-func (t *trayRuntime) SetLabel(label string) {
-	t.bus.Publish("tray:setlabel", label)
-}
-func (t *trayRuntime) SetIcon(name string) {
-	t.bus.Publish("tray:seticon", name)
-}
-
-func (t *trayRuntime) GetByID(menuID string) *menu.MenuItem {
-	return t.trayMenu.Menu.GetByID(menuID)
-}
-
-func (t *trayRuntime) RemoveByID(id string) bool {
-	return t.trayMenu.Menu.RemoveByID(id)
-}

v2/internal/subsystem/binding.go

@@ -5,8 +5,6 @@ import (
 	"github.com/wailsapp/wails/v2/internal/logger"
 	"github.com/wailsapp/wails/v2/internal/runtime"
 	"github.com/wailsapp/wails/v2/internal/servicebus"
-	"os"
-	"time"
 )
 
 // Binding is the Binding subsystem. It manages all service bus messages
@@ -26,13 +24,6 @@ type Binding struct {
 	runtime *runtime.Runtime
 }
 
-func showError(err error) {
-	// Add a slight delay so log buffer clears
-	time.Sleep(1 * time.Second)
-	println("\n\n\n\n\n\n")
-	println("Fatal Error in WailsInit(): " + err.Error())
-}
-
 // NewBinding creates a new binding subsystem. Uses the given bindings db for reference.
 func NewBinding(bus *servicebus.ServiceBus, logger *logger.Logger, bindings *binding.Bindings, runtime *runtime.Runtime) (*Binding, error) {
 
@@ -56,16 +47,6 @@ func NewBinding(bus *servicebus.ServiceBus, logger *logger.Logger, bindings *bin
 		runtime:        runtime,
 	}
 
-	// Call WailsInit methods once the frontend is loaded
-	runtime.Events.On("wails:loaded", func(...interface{}) {
-		result.logger.Trace("Calling WailsInit() methods")
-		err := result.CallWailsInit()
-		if err != nil {
-			showError(err)
-			os.Exit(1)
-		}
-	})
-
 	return result, nil
 }
 
@@ -94,34 +75,6 @@ func (b *Binding) Start() error {
 	return nil
 }
 
-// CallWailsInit will callback to the registered WailsInit
-// methods with the runtime object
-func (b *Binding) CallWailsInit() error {
-	for _, wailsinit := range b.bindings.DB().WailsInitMethods() {
-		_, err := wailsinit.Call([]interface{}{b.runtime})
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// CallWailsShutdown will callback to the registered WailsShutdown
-// methods with the runtime object
-func (b *Binding) CallWailsShutdown() error {
-	for _, wailsshutdown := range b.bindings.DB().WailsShutdownMethods() {
-		_, err := wailsshutdown.Call([]interface{}{})
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
 func (b *Binding) shutdown() {
-	err := b.CallWailsShutdown()
-	if err != nil {
-		showError(err)
-	}
 	b.logger.Trace("Shutdown")
 }

v2/internal/subsystem/call.go

@@ -3,6 +3,7 @@ package subsystem
 import (
 	"encoding/json"
 	"fmt"
+	"github.com/wailsapp/wails/v2/pkg/options/dialog"
 	"strings"
 
 	"github.com/wailsapp/wails/v2/internal/binding"
@@ -10,7 +11,6 @@ import (
 	"github.com/wailsapp/wails/v2/internal/messagedispatcher/message"
 	"github.com/wailsapp/wails/v2/internal/runtime"
 	"github.com/wailsapp/wails/v2/internal/servicebus"
-	"github.com/wailsapp/wails/v2/pkg/options"
 )
 
 // Call is the Call subsystem. It manages all service bus messages
@@ -131,7 +131,7 @@ func (c *Call) processSystemCall(payload *message.CallMessage, clientID string)
 		darkModeEnabled := c.runtime.System.IsDarkMode()
 		c.sendResult(darkModeEnabled, payload, clientID)
 	case "Dialog.Open":
-		dialogOptions := new(options.OpenDialog)
+		dialogOptions := new(dialog.OpenDialog)
 		err := json.Unmarshal(payload.Args[0], dialogOptions)
 		if err != nil {
 			c.logger.Error("Error decoding: %s", err)
@@ -139,7 +139,7 @@ func (c *Call) processSystemCall(payload *message.CallMessage, clientID string)
 		result := c.runtime.Dialog.Open(dialogOptions)
 		c.sendResult(result, payload, clientID)
 	case "Dialog.Save":
-		dialogOptions := new(options.SaveDialog)
+		dialogOptions := new(dialog.SaveDialog)
 		err := json.Unmarshal(payload.Args[0], dialogOptions)
 		if err != nil {
 			c.logger.Error("Error decoding: %s", err)
@@ -147,7 +147,7 @@ func (c *Call) processSystemCall(payload *message.CallMessage, clientID string)
 		result := c.runtime.Dialog.Save(dialogOptions)
 		c.sendResult(result, payload, clientID)
 	case "Dialog.Message":
-		dialogOptions := new(options.MessageDialog)
+		dialogOptions := new(dialog.MessageDialog)
 		err := json.Unmarshal(payload.Args[0], dialogOptions)
 		if err != nil {
 			c.logger.Error("Error decoding: %s", err)

v2/internal/subsystem/contextmenus.go

@@ -1,200 +0,0 @@
-package subsystem
-
-import (
-	"encoding/json"
-	"strings"
-	"sync"
-
-	"github.com/wailsapp/wails/v2/internal/logger"
-	"github.com/wailsapp/wails/v2/internal/messagedispatcher/message"
-	"github.com/wailsapp/wails/v2/internal/servicebus"
-	"github.com/wailsapp/wails/v2/pkg/menu"
-)
-
-// ContextMenus is the subsystem that handles the operation of context menus. It manages all service bus messages
-// starting with "contextmenus".
-type ContextMenus struct {
-	quitChannel <-chan *servicebus.Message
-	menuChannel <-chan *servicebus.Message
-	running     bool
-
-	// Event listeners
-	listeners  map[string][]func(*menu.MenuItem, string)
-	menuItems  map[string]*menu.MenuItem
-	notifyLock sync.RWMutex
-
-	// logger
-	logger logger.CustomLogger
-
-	// The context menus
-	contextMenus *menu.ContextMenus
-
-	// Service Bus
-	bus *servicebus.ServiceBus
-}
-
-// NewContextMenus creates a new context menu subsystem
-func NewContextMenus(contextMenus *menu.ContextMenus, bus *servicebus.ServiceBus, logger *logger.Logger) (*ContextMenus, error) {
-
-	// Register quit channel
-	quitChannel, err := bus.Subscribe("quit")
-	if err != nil {
-		return nil, err
-	}
-
-	// Subscribe to menu messages
-	menuChannel, err := bus.Subscribe("contextmenus:")
-	if err != nil {
-		return nil, err
-	}
-
-	result := &ContextMenus{
-		quitChannel:  quitChannel,
-		menuChannel:  menuChannel,
-		logger:       logger.CustomLogger("Context Menu Subsystem"),
-		listeners:    make(map[string][]func(*menu.MenuItem, string)),
-		menuItems:    make(map[string]*menu.MenuItem),
-		contextMenus: contextMenus,
-		bus:          bus,
-	}
-
-	// Build up list of item/id pairs
-	result.processContextMenus(contextMenus)
-
-	return result, nil
-}
-
-type contextMenuData struct {
-	MenuItemID string `json:"menuItemID"`
-	Data       string `json:"data"`
-}
-
-// Start the subsystem
-func (c *ContextMenus) Start() error {
-
-	c.logger.Trace("Starting")
-
-	c.running = true
-
-	// Spin off a go routine
-	go func() {
-		for c.running {
-			select {
-			case <-c.quitChannel:
-				c.running = false
-				break
-			case menuMessage := <-c.menuChannel:
-				splitTopic := strings.Split(menuMessage.Topic(), ":")
-				menuMessageType := splitTopic[1]
-				switch menuMessageType {
-				case "clicked":
-					if len(splitTopic) != 2 {
-						c.logger.Error("Received clicked message with invalid topic format. Expected 2 sections in topic, got %s", splitTopic)
-						continue
-					}
-					c.logger.Trace("Got Context Menu clicked Message: %s %+v", menuMessage.Topic(), menuMessage.Data())
-					contextMenuDataJSON := menuMessage.Data().(string)
-
-					var data contextMenuData
-					err := json.Unmarshal([]byte(contextMenuDataJSON), &data)
-					if err != nil {
-						c.logger.Trace("Cannot process contextMenuDataJSON %s", string(contextMenuDataJSON))
-						return
-					}
-
-					// Get the menu item
-					menuItem := c.menuItems[data.MenuItemID]
-					if menuItem == nil {
-						c.logger.Trace("Cannot process menuitem id %s - unknown", data.MenuItemID)
-						return
-					}
-
-					// Is the menu item a checkbox?
-					if menuItem.Type == menu.CheckboxType {
-						// Toggle state
-						menuItem.Checked = !menuItem.Checked
-					}
-
-					// Notify listeners
-					c.notifyListeners(data, menuItem)
-				case "on":
-					listenerDetails := menuMessage.Data().(*message.ContextMenusOnMessage)
-					id := listenerDetails.MenuID
-					c.listeners[id] = append(c.listeners[id], listenerDetails.Callback)
-
-				// Make sure we catch any menu updates
-				case "update":
-					updatedMenu := menuMessage.Data().(*menu.ContextMenus)
-					c.processContextMenus(updatedMenu)
-
-					// Notify frontend of menu change
-					c.bus.Publish("contextmenufrontend:update", updatedMenu)
-
-				default:
-					c.logger.Error("unknown context menu message: %+v", menuMessage)
-				}
-			}
-		}
-
-		// Call shutdown
-		c.shutdown()
-	}()
-
-	return nil
-}
-
-func (c *ContextMenus) processContextMenus(contextMenus *menu.ContextMenus) {
-	// Initialise the variables
-	c.menuItems = make(map[string]*menu.MenuItem)
-	c.contextMenus = contextMenus
-
-	for _, contextMenu := range contextMenus.Items {
-		for _, item := range contextMenu.Items {
-			c.processMenuItem(item)
-		}
-	}
-}
-
-func (c *ContextMenus) processMenuItem(item *menu.MenuItem) {
-
-	if item.SubMenu != nil {
-		for _, submenuitem := range item.SubMenu {
-			c.processMenuItem(submenuitem)
-		}
-		return
-	}
-
-	if item.ID != "" {
-		if c.menuItems[item.ID] != nil {
-			c.logger.Error("Context Menu id '%s' is used by multiple menu items: %s %s", c.menuItems[item.ID].Label, item.Label)
-			return
-		}
-		c.menuItems[item.ID] = item
-	}
-}
-
-// Notifies listeners that the given menu was clicked
-func (c *ContextMenus) notifyListeners(contextData contextMenuData, menuItem *menu.MenuItem) {
-
-	// Get list of menu listeners
-	listeners := c.listeners[contextData.MenuItemID]
-	if listeners == nil {
-		c.logger.Trace("No listeners for MenuItem with ID '%s'", contextData.MenuItemID)
-		return
-	}
-
-	// Lock the listeners
-	c.notifyLock.Lock()
-
-	// Callback in goroutine
-	for _, listener := range listeners {
-		go listener(menuItem, contextData.Data)
-	}
-
-	// Unlock
-	c.notifyLock.Unlock()
-}
-
-func (c *ContextMenus) shutdown() {
-	c.logger.Trace("Shutdown")
-}

v2/internal/subsystem/menu.go

@@ -1,25 +1,15 @@
 package subsystem
 
 import (
+	"encoding/json"
+	"github.com/wailsapp/wails/v2/pkg/menu"
 	"strings"
-	"sync"
 
 	"github.com/wailsapp/wails/v2/internal/logger"
-	"github.com/wailsapp/wails/v2/internal/messagedispatcher/message"
+	"github.com/wailsapp/wails/v2/internal/menumanager"
 	"github.com/wailsapp/wails/v2/internal/servicebus"
-	"github.com/wailsapp/wails/v2/pkg/menu"
 )
 
-// eventListener holds a callback function which is invoked when
-// the event listened for is emitted. It has a counter which indicates
-// how the total number of events it is interested in. A value of zero
-// means it does not expire (default).
-// type eventListener struct {
-// 	callback func(...interface{}) // Function to call with emitted event data
-// 	counter  int                  // The number of times this callback may be called. -1 = infinite
-// 	delete   bool                 // Flag to indicate that this listener should be deleted
-// }
-
 // Menu is the subsystem that handles the operation of menus. It manages all service bus messages
 // starting with "menu".
 type Menu struct {
@@ -27,23 +17,18 @@ type Menu struct {
 	menuChannel <-chan *servicebus.Message
 	running     bool
 
-	// Event listeners
-	listeners  map[string][]func(*menu.MenuItem)
-	menuItems  map[string]*menu.MenuItem
-	notifyLock sync.RWMutex
-
 	// logger
 	logger logger.CustomLogger
 
-	// The application menu
-	applicationMenu *menu.Menu
-
 	// Service Bus
 	bus *servicebus.ServiceBus
+
+	// Menu Manager
+	menuManager *menumanager.Manager
 }
 
 // NewMenu creates a new menu subsystem
-func NewMenu(applicationMenu *menu.Menu, bus *servicebus.ServiceBus, logger *logger.Logger) (*Menu, error) {
+func NewMenu(bus *servicebus.ServiceBus, logger *logger.Logger, menuManager *menumanager.Manager) (*Menu, error) {
 
 	// Register quit channel
 	quitChannel, err := bus.Subscribe("quit")
@@ -58,18 +43,13 @@ func NewMenu(applicationMenu *menu.Menu, bus *servicebus.ServiceBus, logger *log
 	}
 
 	result := &Menu{
-		quitChannel:     quitChannel,
-		menuChannel:     menuChannel,
-		logger:          logger.CustomLogger("Menu Subsystem"),
-		listeners:       make(map[string][]func(*menu.MenuItem)),
-		menuItems:       make(map[string]*menu.MenuItem),
-		applicationMenu: applicationMenu,
-		bus:             bus,
+		quitChannel: quitChannel,
+		menuChannel: menuChannel,
+		logger:      logger.CustomLogger("Menu Subsystem"),
+		bus:         bus,
+		menuManager: menuManager,
 	}
 
-	// Build up list of item/id pairs
-	result.processMenu(applicationMenu)
-
 	return result, nil
 }
 
@@ -97,35 +77,68 @@ func (m *Menu) Start() error {
 						continue
 					}
 					m.logger.Trace("Got Menu clicked Message: %s %+v", menuMessage.Topic(), menuMessage.Data())
-					menuid := menuMessage.Data().(string)
 
-					// Get the menu item
-					menuItem := m.menuItems[menuid]
-					if menuItem == nil {
-						m.logger.Trace("Cannot process menuid %s - unknown", menuid)
+					type ClickCallbackMessage struct {
+						MenuItemID string `json:"menuItemID"`
+						Data       string `json:"data"`
+					}
+
+					var callbackData ClickCallbackMessage
+					payload := []byte(menuMessage.Data().(string))
+					err := json.Unmarshal(payload, &callbackData)
+					if err != nil {
+						m.logger.Error("%s", err.Error())
 						return
 					}
 
-					// Is the menu item a checkbox?
-					if menuItem.Type == menu.CheckboxType {
-						// Toggle state
-						menuItem.Checked = !menuItem.Checked
+					err = m.menuManager.ProcessClick(callbackData.MenuItemID, callbackData.Data)
+					if err != nil {
+						m.logger.Trace("%s", err.Error())
 					}
 
-					// Notify listeners
-					m.notifyListeners(menuid, menuItem)
-				case "on":
-					listenerDetails := menuMessage.Data().(*message.MenuOnMessage)
-					id := listenerDetails.MenuID
-					m.listeners[id] = append(m.listeners[id], listenerDetails.Callback)
-
 				// Make sure we catch any menu updates
-				case "update":
-					updatedMenu := menuMessage.Data().(*menu.Menu)
-					m.processMenu(updatedMenu)
+				case "updateappmenu":
+					updatedMenu, err := m.menuManager.UpdateApplicationMenu()
+					if err != nil {
+						m.logger.Trace("%s", err.Error())
+						return
+					}
 
 					// Notify frontend of menu change
-					m.bus.Publish("menufrontend:update", updatedMenu)
+					m.bus.Publish("menufrontend:updateappmenu", updatedMenu)
+
+				case "updatecontextmenu":
+					contextMenu := menuMessage.Data().(*menu.ContextMenu)
+					updatedMenu, err := m.menuManager.UpdateContextMenu(contextMenu)
+					if err != nil {
+						m.logger.Trace("%s", err.Error())
+						return
+					}
+
+					// Notify frontend of menu change
+					m.bus.Publish("menufrontend:updatecontextmenu", updatedMenu)
+
+				case "settraymenu":
+					trayMenu := menuMessage.Data().(*menu.TrayMenu)
+					updatedMenu, err := m.menuManager.SetTrayMenu(trayMenu)
+					if err != nil {
+						m.logger.Trace("%s", err.Error())
+						return
+					}
+
+					// Notify frontend of menu change
+					m.bus.Publish("menufrontend:settraymenu", updatedMenu)
+
+				case "updatetraymenulabel":
+					trayMenu := menuMessage.Data().(*menu.TrayMenu)
+					updatedLabel, err := m.menuManager.UpdateTrayMenuLabel(trayMenu)
+					if err != nil {
+						m.logger.Trace("%s", err.Error())
+						return
+					}
+
+					// Notify frontend of menu change
+					m.bus.Publish("menufrontend:updatetraymenulabel", updatedLabel)
 
 				default:
 					m.logger.Error("unknown menu message: %+v", menuMessage)
@@ -140,56 +153,6 @@ func (m *Menu) Start() error {
 	return nil
 }
 
-func (m *Menu) processMenu(applicationMenu *menu.Menu) {
-	// Initialise the variables
-	m.menuItems = make(map[string]*menu.MenuItem)
-	m.applicationMenu = applicationMenu
-
-	for _, item := range applicationMenu.Items {
-		m.processMenuItem(item)
-	}
-}
-
-func (m *Menu) processMenuItem(item *menu.MenuItem) {
-
-	if item.SubMenu != nil {
-		for _, submenuitem := range item.SubMenu {
-			m.processMenuItem(submenuitem)
-		}
-		return
-	}
-
-	if item.ID != "" {
-		if m.menuItems[item.ID] != nil {
-			m.logger.Error("Menu id '%s' is used by multiple menu items: %s %s", m.menuItems[item.ID].Label, item.Label)
-			return
-		}
-		m.menuItems[item.ID] = item
-	}
-}
-
-// Notifies listeners that the given menu was clicked
-func (m *Menu) notifyListeners(menuid string, menuItem *menu.MenuItem) {
-
-	// Get list of menu listeners
-	listeners := m.listeners[menuid]
-	if listeners == nil {
-		m.logger.Trace("No listeners for MenuItem with ID '%s'", menuid)
-		return
-	}
-
-	// Lock the listeners
-	m.notifyLock.Lock()
-
-	// Callback in goroutine
-	for _, listener := range listeners {
-		go listener(menuItem)
-	}
-
-	// Unlock
-	m.notifyLock.Unlock()
-}
-
 func (m *Menu) shutdown() {
 	m.logger.Trace("Shutdown")
 }

v2/internal/subsystem/runtime.go

@@ -2,7 +2,6 @@ package subsystem
 
 import (
 	"fmt"
-	"github.com/wailsapp/wails/v2/pkg/menu"
 	"strings"
 
 	"github.com/wailsapp/wails/v2/internal/logger"
@@ -15,7 +14,13 @@ import (
 type Runtime struct {
 	quitChannel    <-chan *servicebus.Message
 	runtimeChannel <-chan *servicebus.Message
-	running        bool
+
+	// The hooks channel allows us to hook into frontend startup
+	hooksChannel     <-chan *servicebus.Message
+	startupCallback  func(*runtime.Runtime)
+	shutdownCallback func()
+
+	running bool
 
 	logger logger.CustomLogger
 
@@ -24,7 +29,7 @@ type Runtime struct {
 }
 
 // NewRuntime creates a new runtime subsystem
-func NewRuntime(bus *servicebus.ServiceBus, logger *logger.Logger, menu *menu.Menu, trayMenu *menu.Tray, contextMenus *menu.ContextMenus) (*Runtime, error) {
+func NewRuntime(bus *servicebus.ServiceBus, logger *logger.Logger, startupCallback func(*runtime.Runtime), shutdownCallback func()) (*Runtime, error) {
 
 	// Register quit channel
 	quitChannel, err := bus.Subscribe("quit")
@@ -38,11 +43,20 @@ func NewRuntime(bus *servicebus.ServiceBus, logger *logger.Logger, menu *menu.Me
 		return nil, err
 	}
 
+	// Subscribe to log messages
+	hooksChannel, err := bus.Subscribe("hooks:")
+	if err != nil {
+		return nil, err
+	}
+
 	result := &Runtime{
-		quitChannel:    quitChannel,
-		runtimeChannel: runtimeChannel,
-		logger:         logger.CustomLogger("Runtime Subsystem"),
-		runtime:        runtime.New(bus, menu, trayMenu, contextMenus),
+		quitChannel:      quitChannel,
+		runtimeChannel:   runtimeChannel,
+		hooksChannel:     hooksChannel,
+		logger:           logger.CustomLogger("Runtime Subsystem"),
+		runtime:          runtime.New(bus),
+		startupCallback:  startupCallback,
+		shutdownCallback: shutdownCallback,
 	}
 
 	return result, nil
@@ -60,6 +74,21 @@ func (r *Runtime) Start() error {
 			case <-r.quitChannel:
 				r.running = false
 				break
+			case hooksMessage := <-r.hooksChannel:
+				r.logger.Trace(fmt.Sprintf("Received hooksmessage: %+v", hooksMessage))
+				messageSlice := strings.Split(hooksMessage.Topic(), ":")
+				hook := messageSlice[1]
+				switch hook {
+				case "startup":
+					if r.startupCallback != nil {
+						go r.startupCallback(r.runtime)
+					} else {
+						r.logger.Error("no startup callback registered!")
+					}
+				default:
+					r.logger.Error("unknown hook message: %+v", hooksMessage)
+					continue
+				}
 			case runtimeMessage := <-r.runtimeChannel:
 				r.logger.Trace(fmt.Sprintf("Received message: %+v", runtimeMessage))
 				// Topics have the format: "runtime:category:call"
@@ -100,6 +129,9 @@ func (r *Runtime) GoRuntime() *runtime.Runtime {
 }
 
 func (r *Runtime) shutdown() {
+	if r.shutdownCallback != nil {
+		go r.shutdownCallback()
+	}
 	r.logger.Trace("Shutdown")
 }
 

v2/internal/subsystem/tray.go

@@ -1,202 +0,0 @@
-package subsystem
-
-import (
-	"strings"
-	"sync"
-
-	"github.com/wailsapp/wails/v2/internal/logger"
-	"github.com/wailsapp/wails/v2/internal/messagedispatcher/message"
-	"github.com/wailsapp/wails/v2/internal/servicebus"
-	"github.com/wailsapp/wails/v2/pkg/menu"
-)
-
-// Tray is the subsystem that handles the operation of the tray menu.
-// It manages all service bus messages starting with "tray".
-type Tray struct {
-	quitChannel <-chan *servicebus.Message
-	trayChannel <-chan *servicebus.Message
-	running     bool
-
-	// Event listeners
-	listeners  map[string][]func(*menu.MenuItem)
-	menuItems  map[string]*menu.MenuItem
-	notifyLock sync.RWMutex
-
-	// logger
-	logger logger.CustomLogger
-
-	// The tray menu
-	trayMenu *menu.Tray
-
-	// Service Bus
-	bus *servicebus.ServiceBus
-}
-
-// NewTray creates a new menu subsystem
-func NewTray(trayMenu *menu.Tray, bus *servicebus.ServiceBus,
-	logger *logger.Logger) (*Tray, error) {
-
-	// Register quit channel
-	quitChannel, err := bus.Subscribe("quit")
-	if err != nil {
-		return nil, err
-	}
-
-	// Subscribe to menu messages
-	trayChannel, err := bus.Subscribe("tray:")
-	if err != nil {
-		return nil, err
-	}
-
-	result := &Tray{
-		quitChannel: quitChannel,
-		trayChannel: trayChannel,
-		logger:      logger.CustomLogger("Tray Subsystem"),
-		listeners:   make(map[string][]func(*menu.MenuItem)),
-		menuItems:   make(map[string]*menu.MenuItem),
-		trayMenu:    trayMenu,
-		bus:         bus,
-	}
-
-	// Build up list of item/id pairs
-	result.processMenu(trayMenu.Menu)
-
-	return result, nil
-}
-
-// Start the subsystem
-func (t *Tray) Start() error {
-
-	t.logger.Trace("Starting")
-
-	t.running = true
-
-	// Spin off a go routine
-	go func() {
-		for t.running {
-			select {
-			case <-t.quitChannel:
-				t.running = false
-				break
-			case menuMessage := <-t.trayChannel:
-				splitTopic := strings.Split(menuMessage.Topic(), ":")
-				menuMessageType := splitTopic[1]
-				switch menuMessageType {
-				case "clicked":
-					if len(splitTopic) != 2 {
-						t.logger.Error("Received clicked message with invalid topic format. Expected 2 sections in topic, got %s", splitTopic)
-						continue
-					}
-					t.logger.Trace("Got Tray Menu clicked Message: %s %+v", menuMessage.Topic(), menuMessage.Data())
-					menuid := menuMessage.Data().(string)
-
-					// Get the menu item
-					menuItem := t.menuItems[menuid]
-					if menuItem == nil {
-						t.logger.Trace("Cannot process menuid %s - unknown", menuid)
-						return
-					}
-
-					// Is the menu item a checkbox?
-					if menuItem.Type == menu.CheckboxType {
-						// Toggle state
-						menuItem.Checked = !menuItem.Checked
-					}
-
-					// Notify listeners
-					t.notifyListeners(menuid, menuItem)
-				case "on":
-					listenerDetails := menuMessage.Data().(*message.TrayOnMessage)
-					id := listenerDetails.MenuID
-					t.listeners[id] = append(t.listeners[id], listenerDetails.Callback)
-
-				// Make sure we catch any menu updates
-				case "update":
-					updatedMenu := menuMessage.Data().(*menu.Menu)
-					t.processMenu(updatedMenu)
-
-					// Notify frontend of menu change
-					t.bus.Publish("trayfrontend:update", updatedMenu)
-
-				// Make sure we catch any menu updates
-				case "setlabel":
-					updatedLabel := menuMessage.Data().(string)
-					t.trayMenu.Label = updatedLabel
-
-					// Notify frontend of menu change
-					t.bus.Publish("trayfrontend:setlabel", updatedLabel)
-
-				// Make sure we catch any icon updates
-				case "seticon":
-					iconname := menuMessage.Data().(string)
-					t.trayMenu.Label = iconname
-
-					// Notify frontend of menu change
-					t.bus.Publish("trayfrontend:seticon", iconname)
-
-				default:
-					t.logger.Error("unknown tray message: %+v", menuMessage)
-				}
-			}
-		}
-
-		// Call shutdown
-		t.shutdown()
-	}()
-
-	return nil
-}
-
-func (t *Tray) processMenu(trayMenu *menu.Menu) {
-	// Initialise the variables
-	t.menuItems = make(map[string]*menu.MenuItem)
-	t.trayMenu.Menu = trayMenu
-
-	for _, item := range trayMenu.Items {
-		t.processMenuItem(item)
-	}
-}
-
-func (t *Tray) processMenuItem(item *menu.MenuItem) {
-
-	if item.SubMenu != nil {
-		for _, submenuitem := range item.SubMenu {
-			t.processMenuItem(submenuitem)
-		}
-		return
-	}
-
-	if item.ID != "" {
-		if t.menuItems[item.ID] != nil {
-			t.logger.Error("Menu id '%s' is used by multiple menu items: %s %s", t.menuItems[item.ID].Label, item.Label)
-			return
-		}
-		t.menuItems[item.ID] = item
-	}
-}
-
-// Notifies listeners that the given menu was clicked
-func (t *Tray) notifyListeners(menuid string, menuItem *menu.MenuItem) {
-
-	// Get list of menu listeners
-	listeners := t.listeners[menuid]
-	if listeners == nil {
-		t.logger.Trace("No listeners for MenuItem with ID '%s'", menuid)
-		return
-	}
-
-	// Lock the listeners
-	t.notifyLock.Lock()
-
-	// Callback in goroutine
-	for _, listener := range listeners {
-		go listener(menuItem)
-	}
-
-	// Unlock
-	t.notifyLock.Unlock()
-}
-
-func (t *Tray) shutdown() {
-	t.logger.Trace("Shutdown")
-}

v2/internal/webserver/websockets.go

@@ -3,7 +3,7 @@ package webserver
 import (
 	"context"
 	"github.com/wailsapp/wails/v2/pkg/menu"
-	"github.com/wailsapp/wails/v2/pkg/options"
+	"github.com/wailsapp/wails/v2/pkg/options/dialog"
 	"net/http"
 	"strings"
 
@@ -20,11 +20,27 @@ type WebClient struct {
 	running    bool
 }
 
-func (wc *WebClient) OpenDialog(dialogOptions *options.OpenDialog, callbackID string) {
+func (wc *WebClient) MessageDialog(dialogOptions *dialog.MessageDialog, callbackID string) {
 	wc.logger.Info("Not implemented in server build")
 }
 
-func (wc *WebClient) SaveDialog(dialogOptions *options.SaveDialog, callbackID string) {
+func (wc *WebClient) SetApplicationMenu(menuJSON string) {
+	wc.logger.Info("Not implemented in server build")
+}
+
+func (wc *WebClient) UpdateTrayMenu(trayMenuJSON string) {
+	wc.logger.Info("Not implemented in server build")
+}
+
+func (wc *WebClient) UpdateContextMenu(contextMenuJSON string) {
+	wc.logger.Info("Not implemented in server build")
+}
+
+func (wc *WebClient) OpenDialog(dialogOptions *dialog.OpenDialog, callbackID string) {
+	wc.logger.Info("Not implemented in server build")
+}
+
+func (wc *WebClient) SaveDialog(dialogOptions *dialog.SaveDialog, callbackID string) {
 	wc.logger.Info("Not implemented in server build")
 }
 
@@ -84,10 +100,6 @@ func (wc *WebClient) UpdateTrayIcon(name string) {
 	wc.logger.Info("Not implemented in server build")
 }
 
-func (wc *WebClient) UpdateContextMenus(contextMenus *menu.ContextMenus) {
-	wc.logger.Info("Not implemented in server build")
-}
-
 // Quit terminates the webclient session
 func (wc *WebClient) Quit() {
 	wc.running = false

v2/pkg/commands/build/base.go

@@ -148,6 +148,12 @@ func (b *BaseBuilder) CompileProject(options *Options) error {
 	// Default go build command
 	commands := slicer.String([]string{"build"})
 
+	// Add better debugging flags
+	if options.Mode == Debug {
+		commands.Add("-gcflags")
+		commands.Add(`"all=-N -l"`)
+	}
+
 	// TODO: Work out if we can make this more efficient
 	// We need to do a full build as CGO doesn't detect updates
 	// to .h files, and we package assets into .h file. We could
@@ -205,6 +211,7 @@ func (b *BaseBuilder) CompileProject(options *Options) error {
 	options.CompiledBinary = compiledBinary
 
 	// Create the command
+	fmt.Printf("Compile command: %+v", commands.AsSlice())
 	cmd := exec.Command(options.Compiler, commands.AsSlice()...)
 
 	// Set the directory

v2/pkg/commands/build/desktop.go

@@ -47,12 +47,6 @@ func (d *DesktopBuilder) BuildAssets(options *Options) error {
 		return err
 	}
 
-	// Build static assets
-	err = d.buildCustomAssets(d.projectData)
-	if err != nil {
-		return err
-	}
-
 	return nil
 }
 
@@ -69,6 +63,14 @@ func (d *DesktopBuilder) BuildBaseAssets(assets *html.AssetBundle, options *Opti
 		return err
 	}
 
+	// Make dir if it doesn't exist
+	if !fs.DirExists(assetDir) {
+		err := fs.Mkdir(assetDir)
+		if err != nil {
+			return err
+		}
+	}
+
 	// Dump assets as C
 	assetsFile, err := assets.WriteToCFile(assetDir)
 	if err != nil {

v2/pkg/commands/build/internal/assets/README.md

@@ -6,7 +6,6 @@ The structure is:
 
   * dialog - Icons for dialogs
   * tray - Icons for the system tray
-  * custom - A place for assets you wish to bundle in the application
   * mac - MacOS specific files
   * linux - Linux specific files
   * windows - Windows specific files
@@ -48,16 +47,6 @@ Example:
 
 * `mypic.png` - May be referenced using `runtime.Tray.SetIcon("mypic")` 
 
-## Custom
-
-Any file in this directory will be embedded into the app using the Wails asset bundler.
-Assets can be retrieved using the following methods:
-
-* `wails.Assets().Read(filename string) ([]byte, error)`  
-* `wails.Assets().String(filename string) (string, error)`
-
-The filename should include the path to the file relative to the `custom` directory.
-
 ## Mac
 
 The `mac` directory holds files specific to Mac builds, such as `info.plist`. These may be edited and used as part of the build.

v2/pkg/menu/callback.go

@@ -0,0 +1,8 @@
+package menu
+
+type CallbackData struct {
+	MenuItem    *MenuItem
+	ContextData string
+}
+
+type Callback func(*CallbackData)

v2/pkg/menu/contextmenu.go

@@ -1,38 +1,13 @@
 package menu
 
-type ContextMenus struct {
-	Items map[string]*Menu
+type ContextMenu struct {
+	ID   string
+	Menu *Menu
 }
 
-func NewContextMenus() *ContextMenus {
-	return &ContextMenus{
-		Items: make(map[string]*Menu),
+func NewContextMenu(ID string, menu *Menu) *ContextMenu {
+	return &ContextMenu{
+		ID:   ID,
+		Menu: menu,
 	}
 }
-
-func (c *ContextMenus) AddMenu(ID string, menu *Menu) {
-	c.Items[ID] = menu
-}
-
-func (c *ContextMenus) GetByID(menuID string) *MenuItem {
-
-	// Loop over menu items
-	for _, item := range c.Items {
-		result := item.GetByID(menuID)
-		if result != nil {
-			return result
-		}
-	}
-	return nil
-}
-
-func (c *ContextMenus) RemoveByID(id string) bool {
-	// Loop over menu items
-	for _, item := range c.Items {
-		result := item.RemoveByID(id)
-		if result == true {
-			return result
-		}
-	}
-	return false
-}

v2/pkg/menu/menu.go

@@ -12,6 +12,18 @@ func (m *Menu) Append(item *MenuItem) {
 	m.Items = append(m.Items, item)
 }
 
+// Merge will append the items in the given menu
+// into this menu
+func (m *Menu) Merge(menu *Menu) {
+	for _, item := range menu.Items {
+		m.Items = append(m.Items, item)
+	}
+}
+
+func (m *Menu) Prepend(item *MenuItem) {
+	m.Items = append([]*MenuItem{item}, m.Items...)
+}
+
 func NewMenuFromItems(first *MenuItem, rest ...*MenuItem) *Menu {
 
 	var result = NewMenu()
@@ -23,29 +35,8 @@ func NewMenuFromItems(first *MenuItem, rest ...*MenuItem) *Menu {
 	return result
 }
 
-func (m *Menu) GetByID(menuID string) *MenuItem {
-
-	// Loop over menu items
+func (m *Menu) setParent(menuItem *MenuItem) {
 	for _, item := range m.Items {
-		result := item.getByID(menuID)
-		if result != nil {
-			return result
-		}
+		item.parent = menuItem
 	}
-	return nil
-}
-
-func (m *Menu) RemoveByID(id string) bool {
-	// Loop over menu items
-	for index, item := range m.Items {
-		if item.ID == id {
-			m.Items = append(m.Items[:index], m.Items[index+1:]...)
-			return true
-		}
-		result := item.removeByID(id)
-		if result == true {
-			return result
-		}
-	}
-	return false
 }

v2/pkg/menu/menuitem.go

@@ -1,13 +1,16 @@
 package menu
 
-import "github.com/wailsapp/wails/v2/pkg/menu/keys"
+import (
+	"github.com/wailsapp/wails/v2/pkg/menu/keys"
+	"sync"
+)
 
 // MenuItem represents a menuitem contained in a menu
 type MenuItem struct {
-	// The unique identifier of this menu item
-	ID string `json:"ID,omitempty"`
 	// Label is what appears as the menu text
 	Label string
+	// AlternateLabel is a secondary label (Used by Mac)
+	AlternateLabel string
 	// Role is a predefined menu type
 	Role Role `json:"Role,omitempty"`
 	// Accelerator holds a representation of a key binding
@@ -20,8 +23,20 @@ type MenuItem struct {
 	Hidden bool
 	// Checked indicates if the item is selected (used by Checkbox and Radio types only)
 	Checked bool
+	// Font to use for the menu item
+	Font string
+	// Font to use for the menu item
+	FontSize int
+	// RGBA is the colour of the menu item
+	RGBA string
+	// Image is an image for the menu item (base64 string)
+	Image string
 	// Submenu contains a list of menu items that will be shown as a submenu
-	SubMenu []*MenuItem `json:"SubMenu,omitempty"`
+	//SubMenu []*MenuItem `json:"SubMenu,omitempty"`
+	SubMenu *Menu `json:"SubMenu,omitempty"`
+
+	// Callback function when menu clicked
+	Click Callback `json:"-"`
 
 	// Foreground colour in hex RGBA format EG: 0xFF0000FF = #FF0000FF = red
 	Foreground int
@@ -31,6 +46,9 @@ type MenuItem struct {
 
 	// This holds the menu item's parent.
 	parent *MenuItem
+
+	// Used for locking when removing elements
+	removeLock sync.Mutex
 }
 
 // Parent returns the parent of the menu item.
@@ -48,7 +66,7 @@ func (m *MenuItem) Append(item *MenuItem) bool {
 		return false
 	}
 	item.parent = m
-	m.SubMenu = append(m.SubMenu, item)
+	m.SubMenu.Append(item)
 	return true
 }
 
@@ -61,43 +79,23 @@ func (m *MenuItem) Prepend(item *MenuItem) bool {
 		return false
 	}
 	item.parent = m
-	m.SubMenu = append([]*MenuItem{item}, m.SubMenu...)
+	m.SubMenu.Prepend(item)
 	return true
 }
 
-func (m *MenuItem) getByID(id string) *MenuItem {
-
-	// If I have the ID return me!
-	if m.ID == id {
-		return m
-	}
-
-	// Check submenus
-	for _, submenu := range m.SubMenu {
-		result := submenu.getByID(id)
-		if result != nil {
-			return result
-		}
-	}
-
-	return nil
+func (m *MenuItem) Remove() {
+	// Iterate my parent's children
+	m.Parent().removeChild(m)
 }
 
-func (m *MenuItem) removeByID(id string) bool {
-
-	for index, item := range m.SubMenu {
-		if item.ID == id {
-			m.SubMenu = append(m.SubMenu[:index], m.SubMenu[index+1:]...)
-			return true
-		}
-		if item.isSubMenu() {
-			result := item.removeByID(id)
-			if result == true {
-				return result
-			}
+func (m *MenuItem) removeChild(item *MenuItem) {
+	m.removeLock.Lock()
+	for index, child := range m.SubMenu.Items {
+		if item == child {
+			m.SubMenu.Items = append(m.SubMenu.Items[:index], m.SubMenu.Items[index+1:]...)
 		}
 	}
-	return false
+	m.removeLock.Unlock()
 }
 
 // InsertAfter attempts to add the given item after this item in the parent
@@ -181,7 +179,7 @@ func (m *MenuItem) getItemIndex(target *MenuItem) int {
 	}
 
 	// hunt down that bad boy
-	for index, item := range m.SubMenu {
+	for index, item := range m.SubMenu.Items {
 		if item == target {
 			return index
 		}
@@ -196,7 +194,7 @@ func (m *MenuItem) getItemIndex(target *MenuItem) int {
 func (m *MenuItem) insertItemAtIndex(index int, target *MenuItem) bool {
 
 	// If index is OOB, return false
-	if index > len(m.SubMenu) {
+	if index > len(m.SubMenu.Items) {
 		return false
 	}
 
@@ -204,23 +202,23 @@ func (m *MenuItem) insertItemAtIndex(index int, target *MenuItem) bool {
 	target.parent = m
 
 	// If index is last item, then just regular append
-	if index == len(m.SubMenu) {
-		m.SubMenu = append(m.SubMenu, target)
+	if index == len(m.SubMenu.Items) {
+		m.SubMenu.Items = append(m.SubMenu.Items, target)
 		return true
 	}
 
-	m.SubMenu = append(m.SubMenu[:index+1], m.SubMenu[index:]...)
-	m.SubMenu[index] = target
+	m.SubMenu.Items = append(m.SubMenu.Items[:index+1], m.SubMenu.Items[index:]...)
+	m.SubMenu.Items[index] = target
 	return true
 }
 
 // Text is a helper to create basic Text menu items
-func Text(label string, id string, accelerator *keys.Accelerator) *MenuItem {
+func Text(label string, accelerator *keys.Accelerator, click Callback) *MenuItem {
 	return &MenuItem{
-		ID:          id,
 		Label:       label,
 		Type:        TextType,
 		Accelerator: accelerator,
+		Click:       click,
 	}
 }
 
@@ -232,56 +230,49 @@ func Separator() *MenuItem {
 }
 
 // Radio is a helper to create basic Radio menu items with an accelerator
-func Radio(label string, id string, selected bool, accelerator *keys.Accelerator) *MenuItem {
+func Radio(label string, selected bool, accelerator *keys.Accelerator, click Callback) *MenuItem {
 	return &MenuItem{
-		ID:          id,
 		Label:       label,
 		Type:        RadioType,
 		Checked:     selected,
 		Accelerator: accelerator,
+		Click:       click,
 	}
 }
 
 // Checkbox is a helper to create basic Checkbox menu items
-func Checkbox(label string, id string, checked bool, accelerator *keys.Accelerator) *MenuItem {
+func Checkbox(label string, checked bool, accelerator *keys.Accelerator, click Callback) *MenuItem {
 	return &MenuItem{
-		ID:          id,
 		Label:       label,
 		Type:        CheckboxType,
 		Checked:     checked,
 		Accelerator: accelerator,
+		Click:       click,
 	}
 }
 
 // SubMenu is a helper to create Submenus
-func SubMenu(label string, items []*MenuItem) *MenuItem {
+func SubMenu(label string, menu *Menu) *MenuItem {
 	result := &MenuItem{
 		Label:   label,
-		SubMenu: items,
+		SubMenu: menu,
 		Type:    SubmenuType,
 	}
 
-	// Fix up parent pointers
-	for _, item := range items {
-		item.parent = result
-	}
+	menu.setParent(result)
 
 	return result
 }
 
 // SubMenuWithID is a helper to create Submenus with an ID
-func SubMenuWithID(label string, id string, items []*MenuItem) *MenuItem {
+func SubMenuWithID(label string, menu *Menu) *MenuItem {
 	result := &MenuItem{
 		Label:   label,
-		SubMenu: items,
-		ID:      id,
+		SubMenu: menu,
 		Type:    SubmenuType,
 	}
 
-	// Fix up parent pointers
-	for _, item := range items {
-		item.parent = result
-	}
+	menu.setParent(result)
 
 	return result
 }

v2/pkg/menu/tray.go

@@ -1,10 +1,7 @@
 package menu
 
-// Tray are the options
-type Tray struct {
-
-	// The ID of this tray
-	ID string
+// TrayMenu are the options
+type TrayMenu struct {
 
 	// Label is the text we wish to display in the tray
 	Label string

v2/pkg/menu/type.go

@@ -5,13 +5,13 @@ type Type string
 
 const (
 	// TextType is the text menuitem type
-	TextType Type = "Text"
+	TextType Type = "t"
 	// SeparatorType is the Separator menuitem type
-	SeparatorType Type = "Separator"
+	SeparatorType Type = "s"
 	// SubmenuType is the Submenu menuitem type
-	SubmenuType Type = "Submenu"
+	SubmenuType Type = "S"
 	// CheckboxType is the Checkbox menuitem type
-	CheckboxType Type = "Checkbox"
+	CheckboxType Type = "c"
 	// RadioType is the Radio menuitem type
-	RadioType Type = "Radio"
+	RadioType Type = "r"
 )

v2/pkg/options/default.go

@@ -13,10 +13,8 @@ var Default = &App{
 	DevTools: false,
 	RGBA:     0xFFFFFFFF,
 	Mac: &mac.Options{
-		TitleBar:                      mac.TitleBarDefault(),
-		Appearance:                    mac.DefaultAppearance,
-		WebviewIsTransparent:          false,
-		WindowBackgroundIsTranslucent: false,
+		TitleBar:   mac.TitleBarDefault(),
+		Appearance: mac.DefaultAppearance,
 	},
 	Logger:   logger.NewDefaultLogger(),
 	LogLevel: logger.INFO,

v2/pkg/options/dialog/dialog.go

@@ -1,4 +1,4 @@
-package options
+package dialog
 
 // OpenDialog contains the options for the OpenDialog runtime method
 type OpenDialog struct {

v2/pkg/options/mac/mac.go

@@ -9,6 +9,6 @@ type Options struct {
 	WebviewIsTransparent          bool
 	WindowBackgroundIsTranslucent bool
 	Menu                          *menu.Menu
-	Tray                          *menu.Tray
-	ContextMenus                  *menu.ContextMenus
+	TrayMenus                     []*menu.TrayMenu
+	ContextMenus                  []*menu.ContextMenu
 }

v2/pkg/options/options.go

@@ -1,6 +1,7 @@
 package options
 
 import (
+	wailsruntime "github.com/wailsapp/wails/v2/internal/runtime"
 	"github.com/wailsapp/wails/v2/pkg/menu"
 	"log"
 	"runtime"
@@ -24,12 +25,14 @@ type App struct {
 	StartHidden   bool
 	DevTools      bool
 	RGBA          int
-	ContextMenus  *menu.ContextMenus
-	Tray          *menu.Tray
+	ContextMenus  []*menu.ContextMenu
+	TrayMenus     []*menu.TrayMenu
 	Menu          *menu.Menu
 	Mac           *mac.Options
 	Logger        logger.Logger `json:"-"`
 	LogLevel      logger.LogLevel
+	Startup       func(*wailsruntime.Runtime) `json:"-"`
+	Shutdown      func()                      `json:"-"`
 }
 
 // MergeDefaults will set the minimum default values for an application
@@ -41,25 +44,25 @@ func MergeDefaults(appoptions *App) {
 
 }
 
-func GetTray(appoptions *App) *menu.Tray {
-	var result *menu.Tray
+func GetTrayMenus(appoptions *App) []*menu.TrayMenu {
+	var result []*menu.TrayMenu
 	switch runtime.GOOS {
 	case "darwin":
 		if appoptions.Mac != nil {
-			result = appoptions.Mac.Tray
+			result = appoptions.Mac.TrayMenus
 		}
 		//case "linux":
 		//	if appoptions.Linux != nil {
-		//		result = appoptions.Linux.Tray
+		//		result = appoptions.Linux.TrayMenu
 		//	}
 		//case "windows":
 		//	if appoptions.Windows != nil {
-		//		result = appoptions.Windows.Tray
+		//		result = appoptions.Windows.TrayMenu
 		//	}
 	}
 
 	if result == nil {
-		result = appoptions.Tray
+		result = appoptions.TrayMenus
 	}
 
 	return result
@@ -74,11 +77,11 @@ func GetApplicationMenu(appoptions *App) *menu.Menu {
 		}
 		//case "linux":
 		//	if appoptions.Linux != nil {
-		//		result = appoptions.Linux.Tray
+		//		result = appoptions.Linux.TrayMenu
 		//	}
 		//case "windows":
 		//	if appoptions.Windows != nil {
-		//		result = appoptions.Windows.Tray
+		//		result = appoptions.Windows.TrayMenu
 		//	}
 	}
 
@@ -89,31 +92,26 @@ func GetApplicationMenu(appoptions *App) *menu.Menu {
 	return result
 }
 
-func GetContextMenus(appoptions *App) *menu.ContextMenus {
-	var result *menu.ContextMenus
+func GetContextMenus(appoptions *App) []*menu.ContextMenu {
+	var result []*menu.ContextMenu
 
-	result = appoptions.ContextMenus
-	var contextMenuOverrides *menu.ContextMenus
 	switch runtime.GOOS {
 	case "darwin":
 		if appoptions.Mac != nil {
-			contextMenuOverrides = appoptions.Mac.ContextMenus
+			result = appoptions.Mac.ContextMenus
 		}
 		//case "linux":
 		//	if appoptions.Linux != nil {
-		//		result = appoptions.Linux.Tray
+		//		result = appoptions.Linux.TrayMenu
 		//	}
 		//case "windows":
 		//	if appoptions.Windows != nil {
-		//		result = appoptions.Windows.Tray
+		//		result = appoptions.Windows.TrayMenu
 		//	}
 	}
 
-	// Overwrite defaults with OS Specific context menus
-	if contextMenuOverrides != nil {
-		for id, contextMenu := range contextMenuOverrides.Items {
-			result.AddMenu(id, contextMenu)
-		}
+	if result == nil {
+		result = appoptions.ContextMenus
 	}
 
 	return result

v2/pkg/parser/method.go

@@ -44,11 +44,6 @@ func (p *Parser) parseStructMethods(boundStruct *Struct) error {
 							continue
 						}
 
-						// We want to ignore Internal functions
-						if funcDecl.Name.Name == "WailsInit" || funcDecl.Name.Name == "WailsShutdown" {
-							continue
-						}
-
 						// If this method is not Public, ignore
 						if string(funcDecl.Name.Name[0]) != strings.ToUpper((string(funcDecl.Name.Name[0]))) {
 							continue

v2/pkg/str/str.go

@@ -0,0 +1,10 @@
+package str
+
+import (
+	"fmt"
+	"time"
+)
+
+func UnixNow() string {
+	return fmt.Sprintf("%+v", time.Now().Unix())
+}

v2/test/kitchensink/contextmenus.go

@@ -10,9 +10,11 @@ import (
 
 // ContextMenu struct
 type ContextMenu struct {
-	runtime *wails.Runtime
-	counter int
-	lock    sync.Mutex
+	runtime         *wails.Runtime
+	counter         int
+	lock            sync.Mutex
+	testContextMenu *menu.ContextMenu
+	clickedMenu     *menu.MenuItem
 }
 
 // WailsInit is called at application startup
@@ -20,21 +22,34 @@ func (c *ContextMenu) WailsInit(runtime *wails.Runtime) error {
 	// Perform your setup here
 	c.runtime = runtime
 
-	// Setup Menu Listeners
-	c.runtime.ContextMenu.On("Test Context Menu", func(mi *menu.MenuItem, contextData string) {
-		fmt.Printf("\n\nContext Data = '%s'\n\n", contextData)
-		c.lock.Lock()
-		c.counter++
-		mi.Label = fmt.Sprintf("Clicked %d times", c.counter)
-		c.lock.Unlock()
-		c.runtime.ContextMenu.Update()
-	})
-
 	return nil
 }
 
-func createContextMenus() *menu.ContextMenus {
-	result := menu.NewContextMenus()
-	result.AddMenu("test", menu.NewMenuFromItems(menu.Text("Clicked 0 times", "Test Context Menu", nil)))
-	return result
+// Setup Menu Listeners
+func (c *ContextMenu) updateContextMenu(_ *menu.CallbackData) {
+	c.lock.Lock()
+	c.counter++
+	c.clickedMenu.Label = fmt.Sprintf("Clicked %d times", c.counter)
+	c.lock.Unlock()
+	c.runtime.Menu.UpdateContextMenu(c.testContextMenu)
+}
+
+func (c *ContextMenu) createContextMenus() []*menu.ContextMenu {
+	c.clickedMenu = menu.Text("Clicked 0 times", nil, c.updateContextMenu)
+	c.testContextMenu = menu.NewContextMenu("test", menu.NewMenuFromItems(
+		c.clickedMenu,
+		menu.Separator(),
+		menu.Checkbox("I am a checkbox", false, nil, nil),
+		menu.Separator(),
+		menu.Radio("Radio Option 1", true, nil, nil),
+		menu.Radio("Radio Option 2", false, nil, nil),
+		menu.Radio("Radio Option 3", false, nil, nil),
+		menu.Separator(),
+		menu.SubMenu("A Submenu", menu.NewMenuFromItems(
+			menu.Text("Hello", nil, nil),
+		)),
+	))
+	return []*menu.ContextMenu{
+		c.testContextMenu,
+	}
 }

v2/test/kitchensink/dialog.go

@@ -2,7 +2,7 @@ package main
 
 import (
 	"github.com/wailsapp/wails/v2"
-	"github.com/wailsapp/wails/v2/pkg/options"
+	"github.com/wailsapp/wails/v2/pkg/options/dialog"
 )
 
 // Dialog struct
@@ -18,16 +18,16 @@ func (l *Dialog) WailsInit(runtime *wails.Runtime) error {
 }
 
 // Open Dialog
-func (l *Dialog) Open(options *options.OpenDialog) []string {
+func (l *Dialog) Open(options *dialog.OpenDialog) []string {
 	return l.runtime.Dialog.Open(options)
 }
 
 // Save Dialog
-func (l *Dialog) Save(options *options.SaveDialog) string {
+func (l *Dialog) Save(options *dialog.SaveDialog) string {
 	return l.runtime.Dialog.Save(options)
 }
 
 // Message Dialog
-func (l *Dialog) Message(options *options.MessageDialog) string {
+func (l *Dialog) Message(options *dialog.MessageDialog) string {
 	return l.runtime.Dialog.Message(options)
 }

v2/test/kitchensink/frontend/src/pages/Dialog/Message/code.go

@@ -1,10 +1,10 @@
 package main
 
 import (
+	"github.com/wailsapp/wails/v2/pkg/options/dialog"
 	"io/ioutil"
 
 	"github.com/wailsapp/wails/v2"
-	"github.com/wailsapp/wails/v2/pkg/options"
 )
 
 type Notepad struct {
@@ -21,7 +21,7 @@ func (n *Notepad) WailsInit(runtime *wails.Runtime) error {
 // successful save.
 func (n *Notepad) SaveNotes(notes string) (bool, error) {
 
-	selectedFile := n.runtime.Dialog.Save(&options.SaveDialog{
+	selectedFile := n.runtime.Dialog.Save(&dialog.SaveDialog{
 		DefaultFilename: "notes.md",
 		Filters:         "*.md",
 	})

v2/test/kitchensink/frontend/src/pages/Dialog/Open/code.go

@@ -1,10 +1,10 @@
 package main
 
 import (
+	"github.com/wailsapp/wails/v2/pkg/options/dialog"
 	"io/ioutil"
 
 	"github.com/wailsapp/wails/v2"
-	"github.com/wailsapp/wails/v2/pkg/options"
 )
 
 type Notepad struct {
@@ -18,7 +18,7 @@ func (n *Notepad) WailsInit(runtime *wails.Runtime) error {
 
 func (n *Notepad) LoadNotes() (string, error) {
 
-	selectedFiles := n.runtime.Dialog.Open(&options.OpenDialog{
+	selectedFiles := n.runtime.Dialog.Open(&dialog.OpenDialog{
 		DefaultFilename: "notes.md",
 		Filters:         "*.md",
 		AllowFiles:      true,

v2/test/kitchensink/frontend/src/pages/Dialog/Save/code.go

@@ -1,10 +1,10 @@
 package main
 
 import (
+	"github.com/wailsapp/wails/v2/pkg/options/dialog"
 	"io/ioutil"
 
 	"github.com/wailsapp/wails/v2"
-	"github.com/wailsapp/wails/v2/pkg/options"
 )
 
 type Notepad struct {
@@ -21,7 +21,7 @@ func (n *Notepad) WailsInit(runtime *wails.Runtime) error {
 // successful save.
 func (n *Notepad) SaveNotes(notes string) (bool, error) {
 
-	selectedFile := n.runtime.Dialog.Save(&options.SaveDialog{
+	selectedFile := n.runtime.Dialog.Save(&dialog.SaveDialog{
 		DefaultFilename: "notes.md",
 		Filters:         "*.md",
 	})

v2/test/kitchensink/go.mod

@@ -2,8 +2,6 @@ module test
 
 go 1.13
 
-require (
-	github.com/wailsapp/wails/v2 v2.0.0-alpha
-)
+require github.com/wailsapp/wails/v2 v2.0.0-alpha
 
 replace github.com/wailsapp/wails/v2 v2.0.0-alpha => ../../../v2

v2/test/kitchensink/go.sum

@@ -1,112 +1,90 @@
-github.com/Masterminds/semver v1.4.2/go.mod h1:MB6lktGJrhw8PrUyiEoblNEGEQ+RzHPF078ddwwvV3Y=
-github.com/Netflix/go-expect v0.0.0-20180615182759-c93bf25de8e8/go.mod h1:oX5x61PbNXchhh0oikYAH+4Pcfw5LKv21+Jnpr6r6Pc=
-github.com/abadojack/whatlanggo v1.0.1 h1:19N6YogDnf71CTHm3Mp2qhYfkRdyvbgwWdd2EPxJRG4=
-github.com/abadojack/whatlanggo v1.0.1/go.mod h1:66WiQbSbJBIlOZMsvbKe5m6pzQovxCH9B/K8tQB2uoc=
-github.com/cheekybits/is v0.0.0-20150225183255-68e9c0620927/go.mod h1:h/aW8ynjgkuj+NQRlZcDbAbM1ORAbXjXX77sX7T289U=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
-github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
 github.com/fatih/structtag v1.2.0/go.mod h1:mBJUNpUnHmRKrKlQQlmCrh5PuhftFbNv8Ys4/aAZl94=
 github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
+github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
 github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
+github.com/gin-gonic/gin v1.6.3 h1:ahKqKTFpO5KTPHxWZjEdPScmYaGtLo8Y4DMHoEsnp14=
 github.com/gin-gonic/gin v1.6.3/go.mod h1:75u5sXoLsGZoRN5Sgbi1eraJ4GU3++wFwWzhwvtwp4M=
+github.com/go-playground/assert/v2 v2.0.1 h1:MsBgLAaY856+nPRTKrp3/OZK38U/wa0CcBYNjji3q3A=
 github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
-github.com/go-playground/colors v1.2.0/go.mod h1:miw1R2JIE19cclPxsXqNdzLZsk4DP4iF+m88bRc7kfM=
+github.com/go-playground/locales v0.13.0 h1:HyWk6mgj5qFqCT5fjGBuRArbVDfE4hi8+e8ceBS/t7Q=
 github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8=
+github.com/go-playground/universal-translator v0.17.0 h1:icxd5fm+REJzpZx7ZfpaD876Lmtgy7VtROAbHHXk8no=
 github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA=
+github.com/go-playground/validator/v10 v10.2.0 h1:KgJ0snyC2R9VXYN2rneOtQcw5aHQB1Vv0sFl1UcHBOY=
 github.com/go-playground/validator/v10 v10.2.0/go.mod h1:uOYAAleCW8F/7oMFd6aG0GOhaH6EGOAJShg8Id5JGkI=
+github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee h1:s+21KNqlpePfkah2I+gwHF8xmJWRjooY+5248k6m4A0=
 github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee/go.mod h1:L0fX3K22YWvt/FAX9NnzrNzcI4wNYi9Yku4O0LKYflo=
+github.com/gobwas/pool v0.2.0 h1:QEmUOlnSjWtnpRGHF3SauEiOsy82Cup83Vf2LcMlnc8=
 github.com/gobwas/pool v0.2.0/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
+github.com/gobwas/ws v1.0.2 h1:CoAavW/wd/kulfZmSIBt6p24n4j7tHgNVCjsfHVNUbo=
 github.com/gobwas/ws v1.0.2/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM=
 github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.3.5 h1:F768QJ1E9tib+q5Sc8MkdJi1RxLTbRcTf8LJV56aRls=
 github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk=
+github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
 github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
-github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
+github.com/gorilla/websocket v1.4.1 h1:q7AeDBpnBk8AogcD4DSag/Ukw/KV+YhzLj2bP5HvKCM=
 github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
-github.com/hinshun/vt10x v0.0.0-20180616224451-1954e6464174/go.mod h1:DqJ97dSdRW1W22yXSB90986pcOyQ7r45iio1KN2ez1A=
 github.com/imdario/mergo v0.3.11 h1:3tnifQM4i+fbajXKBHXWEH+KvNHqojZ778UH75j3bGA=
 github.com/imdario/mergo v0.3.11/go.mod h1:jmQim1M+e3UYxmgPu/WyfjB3N3VflVyUjjjwH0dnCYA=
 github.com/jackmordaunt/icns v1.0.0/go.mod h1:7TTQVEuGzVVfOPPlLNHJIkzA6CoV7aH1Dv9dW351oOo=
+github.com/json-iterator/go v1.1.9 h1:9yzud/Ht36ygwatGx56VwCZtlI/2AD15T1X2sjSuGns=
 github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
-github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51/go.mod h1:CzGEWj7cYgsdH8dAjBGEr58BoE7ScuLd+fwFZ44+/x8=
-github.com/kennygrant/sanitize v1.2.4/go.mod h1:LGsjYYtgxbetdg5owWB2mpgUL6e2nfw2eObZ0u0qvak=
+github.com/klauspost/compress v1.10.3 h1:OP96hzwJVBIHYU52pVTI6CczrxPvrGfgqF9N5eTO0Q8=
 github.com/klauspost/compress v1.10.3/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
-github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
-github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/leaanthony/clir v1.0.4 h1:Dov2y9zWJmZr7CjaCe86lKa4b5CSxskGAt2yBkoDyiU=
 github.com/leaanthony/clir v1.0.4/go.mod h1:k/RBkdkFl18xkkACMCLt09bhiZnrGORoxmomeMvDpE0=
 github.com/leaanthony/gosod v0.0.4/go.mod h1:nGMCb1PJfXwBDbOAike78jEYlpqge+xUKFf0iBKjKxU=
-github.com/leaanthony/mewn v0.10.7/go.mod h1:CRkTx8unLiSSilu/Sd7i1LwrdaAL+3eQ3ses99qGMEQ=
-github.com/leaanthony/slicer v1.4.0/go.mod h1:FwrApmf8gOrpzEWM2J/9Lh79tyq8KTX5AzRtwV7m4AY=
-github.com/leaanthony/slicer v1.4.1/go.mod h1:FwrApmf8gOrpzEWM2J/9Lh79tyq8KTX5AzRtwV7m4AY=
 github.com/leaanthony/slicer v1.5.0/go.mod h1:FwrApmf8gOrpzEWM2J/9Lh79tyq8KTX5AzRtwV7m4AY=
-github.com/leaanthony/spinner v0.5.3/go.mod h1:oHlrvWicr++CVV7ALWYi+qHk/XNA91D9IJ48IqmpVUo=
-github.com/leaanthony/synx v0.1.0/go.mod h1:Iz7eybeeG8bdq640iR+CwYb8p+9EOsgMWghkSRyZcqs=
-github.com/leaanthony/wincursor v0.1.0/go.mod h1:7TVwwrzSH/2Y9gLOGH+VhA+bZhoWXBRgbGNTMk+yimE=
+github.com/leodido/go-urn v1.2.0 h1:hpXL4XnriNwQ/ABnpepYM/1vCLWNDfUNts8dX3xTG6Y=
 github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII=
+github.com/matryer/is v1.4.0 h1:sosSmIWwkYITGrxZ25ULNDeKiMNzFSr4V/eqBQP0PeE=
 github.com/matryer/is v1.4.0/go.mod h1:8I/i5uYgLzgsgEloJE1U6xx5HkBQpAZvepWuujKwMRU=
-github.com/matryer/try v0.0.0-20161228173917-9ac251b645a2/go.mod h1:0KeJpeMD6o+O4hW7qJOT7vyQPKrWmj26uf5wMc/IiIs=
-github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
-github.com/mattn/go-colorable v0.1.1/go.mod h1:FuOcm+DKB9mbwrcAfNl7/TZVBZ6rcnceauSikq3lYCQ=
-github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
-github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
-github.com/mattn/go-isatty v0.0.5/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
-github.com/mattn/go-isatty v0.0.7/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
+github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
 github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
 github.com/mattn/go-runewidth v0.0.7/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
-github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b/go.mod h1:01TrycV0kFyexm33Z7vhZRXopbI8J3TDReVlkTgMUxE=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 h1:ZqeYNhU3OHLH3mGKHDcjJRFFRrJa6eAM5H+CtDdOsPc=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742 h1:Esafd1046DLDQ0W1YjYsBW+p8U2u7vzgW2SQVmlNazg=
 github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646/go.mod h1:jpp1/29i3P1S/RLdc7JQKbRpFeM1dOBd8T9ki5s+AY8=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs=
 github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
 github.com/olekukonko/tablewriter v0.0.4/go.mod h1:zq6QwlOf5SlnkVbMSr5EoBv3636FWnp+qbPhuoO21uA=
-github.com/pkg/browser v0.0.0-20180916011732-0a3d74bf9ce4 h1:49lOXmGaUpV9Fz3gd7TFZY106KVlPVa5jcYD1gaQf98=
-github.com/pkg/browser v0.0.0-20180916011732-0a3d74bf9ce4/go.mod h1:4OwLy04Bl9Ef3GJJCoec+30X3LQs/0/m4HFRt/2LUSA=
-github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/sirupsen/logrus v1.4.1 h1:GL2rEmy6nsikmW0r8opw9JIRScdMF5hA8cOYLH7In1k=
-github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q=
-github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.2.1/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/syossan27/tebata v0.0.0-20180602121909-b283fe4bc5ba/go.mod h1:iLnlXG2Pakcii2CU0cbY07DRCSvpWNa7nFxtevhOChk=
 github.com/tdewolff/minify v2.3.6+incompatible/go.mod h1:9Ov578KJUmAWpS6NeZwRZyT56Uf6o3Mcz9CEsg8USYs=
-github.com/tdewolff/minify/v2 v2.9.5/go.mod h1:jshtBj/uUJH6JX1fuxTLnnHOA1RVJhF5MM+leJzDKb4=
 github.com/tdewolff/parse v2.3.4+incompatible/go.mod h1:8oBwCsVmUkgHO8M5iCzSIDtpzXOT0WXX9cWhz+bIzJQ=
-github.com/tdewolff/parse/v2 v2.5.3/go.mod h1:WzaJpRSbwq++EIQHYIRTpbYKNA3gn9it1Ik++q4zyho=
 github.com/tdewolff/test v1.0.6/go.mod h1:6DAvZliBAAnD7rhVgwaM7DE5/d9NMOAJ09SqYqeK4QE=
+github.com/ugorji/go v1.1.7 h1:/68gy2h+1mWMrwZFeD1kQialdSzAb432dtpeJ42ovdo=
 github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw=
+github.com/ugorji/go/codec v1.1.7 h1:2SvQaVZ1ouYrrKKwoSk2pzd4A9evlKJb9oTL+OaLUSs=
 github.com/ugorji/go/codec v1.1.7/go.mod h1:Ax+UKWsSmolVDwsd+7N3ZtXu+yMGCf907BLYF3GoBXY=
-github.com/wailsapp/wails v1.8.0 h1:gnQhpwoGM8s2GD5PZrgMKU1PO3pQ9cdKKJgwtkNz2f4=
-github.com/wailsapp/wails v1.8.0/go.mod h1:XFZunea+USOCMMgBlz0A0JHLL3oWrRhnOl4baZlRpxo=
-github.com/wailsapp/wails v1.9.1 h1:ez/TK8YpU9lvOZ9nkgzUXsWu+xOPFVO57zTy0n5w3hc=
 github.com/xyproto/xpm v1.2.1/go.mod h1:cMnesLsD0PBXLgjDfTDEaKr8XyTFsnP1QycSqRw7BiY=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-golang.org/x/crypto v0.0.0-20190123085648-057139ce5d2b/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/image v0.0.0-20200430140353-33d19683fad8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
 golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20180606202747-9527bec2660b/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20181228144115-9a3f9b0469bb/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -123,12 +101,14 @@ golang.org/x/tools v0.0.0-20200902012652-d1954cc86c82/go.mod h1:Cj7w3i3Rnn0Xh82u
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-gopkg.in/AlecAivazis/survey.v1 v1.8.4/go.mod h1:iBNOmqKz/NUbZx3bA+4hAGLRC7fSK7tgtVDT4tB22XA=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b h1:QRR6H1YWRnHb4Y/HeNFCTJLFVxaq6wH4YuVdsUOr75U=
 gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
 gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v3 v3.0.0-20190709130402-674ba3eaed22/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+nhooyr.io/websocket v1.8.6 h1:s+C3xAMLwGmlI31Nyn/eAehUlZPwfYZu2JXM621Q5/k=
 nhooyr.io/websocket v1.8.6/go.mod h1:B70DZP8IakI65RVQ51MsWP/8jndNma26DVA/nFSCgW0=

v2/test/kitchensink/main.go

@@ -3,7 +3,6 @@ package main
 import (
 	"github.com/wailsapp/wails/v2"
 	"github.com/wailsapp/wails/v2/pkg/logger"
-	"github.com/wailsapp/wails/v2/pkg/menu"
 	"github.com/wailsapp/wails/v2/pkg/options"
 	"github.com/wailsapp/wails/v2/pkg/options/mac"
 	"log"
@@ -11,6 +10,10 @@ import (
 
 func main() {
 
+	Menu := &Menu{}
+	Tray := &Tray{}
+	ContextMenu := &ContextMenu{}
+
 	// Create application with options
 	app, err := wails.CreateAppWithOptions(&options.App{
 		Title:     "Kitchen Sink",
@@ -21,19 +24,18 @@ func main() {
 		//Tray:      menu.NewMenuFromItems(menu.AppMenu()),
 		//Menu:      menu.NewMenuFromItems(menu.AppMenu()),
 		//StartHidden:  true,
-		ContextMenus: createContextMenus(),
+		ContextMenus: ContextMenu.createContextMenus(),
 		Mac: &mac.Options{
 			WebviewIsTransparent:          true,
 			WindowBackgroundIsTranslucent: true,
 			// Comment out line below to see Window.SetTitle() work
-			TitleBar: mac.TitleBarHiddenInset(),
-			Menu:     createApplicationMenu(),
-			Tray: &menu.Tray{
-				Icon: "light",
-				Menu: createApplicationTray(),
-			},
+			TitleBar:  mac.TitleBarHiddenInset(),
+			Menu:      Menu.createApplicationMenu(),
+			TrayMenus: Tray.createTrayMenus(),
 		},
 		LogLevel: logger.TRACE,
+		Startup:  Tray.start,
+		Shutdown: Tray.shutdown,
 	})
 
 	if err != nil {
@@ -46,9 +48,9 @@ func main() {
 	app.Bind(&System{})
 	app.Bind(&Dialog{})
 	app.Bind(&Window{})
-	app.Bind(&Menu{})
-	app.Bind(&Tray{})
-	app.Bind(&ContextMenu{})
+	app.Bind(Menu)
+	app.Bind(Tray)
+	app.Bind(ContextMenu)
 
 	err = app.Run()
 	if err != nil {

v2/test/kitchensink/menu.go

@@ -3,7 +3,6 @@ package main
 import (
 	"fmt"
 	"github.com/wailsapp/wails/v2/pkg/menu/keys"
-	"math/rand"
 	"strconv"
 	"sync"
 
@@ -16,9 +15,14 @@ type Menu struct {
 	runtime *wails.Runtime
 
 	dynamicMenuCounter        int
+	dynamicMenuOneItems       []*menu.MenuItem
 	lock                      sync.Mutex
 	dynamicMenuItems          map[string]*menu.MenuItem
 	anotherDynamicMenuCounter int
+
+	// Menus
+	removeMenuItem        *menu.MenuItem
+	dynamicMenuOneSubmenu *menu.MenuItem
 }
 
 // WailsInit is called at application startup
@@ -26,26 +30,6 @@ func (m *Menu) WailsInit(runtime *wails.Runtime) error {
 	// Perform your setup here
 	m.runtime = runtime
 
-	// Setup Menu Listeners
-	m.runtime.Menu.On("hello", func(mi *menu.MenuItem) {
-		fmt.Printf("The '%s' menu was clicked\n", mi.Label)
-	})
-	m.runtime.Menu.On("checkbox-menu", func(mi *menu.MenuItem) {
-		fmt.Printf("The '%s' menu was clicked\n", mi.Label)
-		fmt.Printf("It is now %v\n", mi.Checked)
-	})
-	m.runtime.Menu.On("😀option-1", func(mi *menu.MenuItem) {
-		fmt.Printf("We can use UTF-8 IDs: %s\n", mi.Label)
-	})
-
-	m.runtime.Menu.On("show-dynamic-menus-2", func(mi *menu.MenuItem) {
-		mi.Hidden = true
-		// Create dynamic menu items 2 submenu
-		m.createDynamicMenuTwo()
-	})
-
-	// Setup dynamic menus
-	m.runtime.Menu.On("Add Menu Item", m.addMenu)
 	return nil
 }
 
@@ -59,177 +43,164 @@ func (m *Menu) decrementcounter() int {
 	return m.dynamicMenuCounter
 }
 
-func (m *Menu) addMenu(mi *menu.MenuItem) {
+func (m *Menu) addDynamicMenusOneMenu(data *menu.CallbackData) {
 
 	// Lock because this method will be called in a gorouting
 	m.lock.Lock()
 	defer m.lock.Unlock()
 
 	// Get this menu's parent
+	mi := data.MenuItem
 	parent := mi.Parent()
 	counter := m.incrementcounter()
 	menuText := "Dynamic Menu Item " + strconv.Itoa(counter)
-	parent.Append(menu.Text(menuText, menuText, nil))
-	// 	parent.Append(menu.Text(menuText, menuText, menu.Key("[")))
+	newDynamicMenu := menu.Text(menuText, nil, nil)
+	m.dynamicMenuOneItems = append(m.dynamicMenuOneItems, newDynamicMenu)
+	parent.Append(newDynamicMenu)
 
 	// If this is the first dynamic menu added, let's add a remove menu item
 	if counter == 1 {
-		removeMenu := menu.Text("Remove "+menuText,
-			"Remove Last Item", keys.CmdOrCtrl("-"))
-		parent.Prepend(removeMenu)
-		m.runtime.Menu.On("Remove Last Item", m.removeMenu)
+		m.removeMenuItem = menu.Text("Remove "+menuText, keys.CmdOrCtrl("-"), m.removeDynamicMenuOneMenu)
+		parent.Prepend(m.removeMenuItem)
 	} else {
-		removeMenu := m.runtime.Menu.GetByID("Remove Last Item")
 		// Test if the remove menu hasn't already been removed in another thread
-		if removeMenu != nil {
-			removeMenu.Label = "Remove " + menuText
+		if m.removeMenuItem != nil {
+			m.removeMenuItem.Label = "Remove " + menuText
 		}
 	}
-	m.runtime.Menu.Update()
+	m.runtime.Menu.UpdateApplicationMenu()
 }
 
-func (m *Menu) removeMenu(_ *menu.MenuItem) {
-
+func (m *Menu) removeDynamicMenuOneMenu(_ *menu.CallbackData) {
+	//
 	// Lock because this method will be called in a goroutine
 	m.lock.Lock()
 	defer m.lock.Unlock()
 
-	// Get the id of the last dynamic menu
-	menuID := "Dynamic Menu Item " + strconv.Itoa(m.dynamicMenuCounter)
+	// Get the last menu we added
+	lastItemIndex := len(m.dynamicMenuOneItems) - 1
+	lastMenuAdded := m.dynamicMenuOneItems[lastItemIndex]
 
-	// Remove the last menu item by ID
-	m.runtime.Menu.RemoveByID(menuID)
+	// Remove from slice
+	m.dynamicMenuOneItems = m.dynamicMenuOneItems[:lastItemIndex]
+
+	// Remove the item from the menu
+	lastMenuAdded.Remove()
 
 	// Update the counter
 	counter := m.decrementcounter()
 
 	// If we deleted the last dynamic menu, remove the "Remove Last Item" menu
 	if counter == 0 {
-		m.runtime.Menu.RemoveByID("Remove Last Item")
+		// Remove it!
+		m.removeMenuItem.Remove()
 	} else {
 		// Update label
 		menuText := "Dynamic Menu Item " + strconv.Itoa(counter)
-		removeMenu := m.runtime.Menu.GetByID("Remove Last Item")
-		// Test if the remove menu hasn't already been removed in another thread
-		if removeMenu == nil {
-			return
-		}
-		removeMenu.Label = "Remove " + menuText
+		m.removeMenuItem.Label = "Remove " + menuText
 	}
 
 	// 	parent.Append(menu.Text(menuText, menuText, menu.Key("[")))
-	m.runtime.Menu.Update()
+	m.runtime.Menu.UpdateApplicationMenu()
 }
 
-func (m *Menu) createDynamicMenuTwo() {
+func (m *Menu) createDynamicMenuTwo(data *menu.CallbackData) {
+
+	// Hide this menu
+	data.MenuItem.Hidden = true
 
 	// Create our submenu
-	dm2 := menu.SubMenu("Dynamic Menus 2", []*menu.MenuItem{
-		menu.Text("Insert Before Random Menu Item",
-			"Insert Before Random", keys.CmdOrCtrl("]")),
-		menu.Text("Insert After Random Menu Item",
-			"Insert After Random", keys.CmdOrCtrl("[")),
+	dm2 := menu.SubMenu("Dynamic Menus 2", menu.NewMenuFromItems(
+		menu.Text("Insert Before Random Menu Item", keys.CmdOrCtrl("]"), m.insertBeforeRandom),
+		menu.Text("Insert After Random Menu Item", keys.CmdOrCtrl("["), m.insertAfterRandom),
 		menu.Separator(),
-	})
+	))
 
-	m.runtime.Menu.On("Insert Before Random", m.insertBeforeRandom)
-	m.runtime.Menu.On("Insert After Random", m.insertAfterRandom)
+	//m.runtime.Menu.On("Insert Before Random", m.insertBeforeRandom)
+	//m.runtime.Menu.On("Insert After Random", m.insertAfterRandom)
 
-	// Initialise out map
+	// Initialise dynamicMenuItems
 	m.dynamicMenuItems = make(map[string]*menu.MenuItem)
 
 	// Create some random menu items
 	m.anotherDynamicMenuCounter = 5
 	for index := 0; index < m.anotherDynamicMenuCounter; index++ {
 		text := "Other Dynamic Menu Item " + strconv.Itoa(index+1)
-		item := menu.Text(text, text, nil)
+		item := menu.Text(text, nil, nil)
 		m.dynamicMenuItems[text] = item
 		dm2.Append(item)
 	}
 
-	// Insert this menu after Dynamic Menu Item 1
-	dm1 := m.runtime.Menu.GetByID("Dynamic Menus 1")
-	if dm1 == nil {
-		return
-	}
-
-	dm1.InsertAfter(dm2)
-	m.runtime.Menu.Update()
+	m.dynamicMenuOneSubmenu.InsertAfter(dm2)
+	m.runtime.Menu.UpdateApplicationMenu()
 }
 
-func (m *Menu) insertBeforeRandom(_ *menu.MenuItem) {
+func (m *Menu) insertBeforeRandom(_ *menu.CallbackData) {
 
 	// Lock because this method will be called in a goroutine
 	m.lock.Lock()
 	defer m.lock.Unlock()
 
 	// Pick a random menu
-	var randomItemID string
-	var count int
-	var random = rand.Intn(len(m.dynamicMenuItems))
-	for randomItemID = range m.dynamicMenuItems {
-		if count == random {
-			break
-		}
-		count++
+	var randomMenuItem *menu.MenuItem
+	for _, randomMenuItem = range m.dynamicMenuItems {
+		break
 	}
-	m.anotherDynamicMenuCounter++
-	text := "Other Dynamic Menu Item " + strconv.Itoa(
-		m.anotherDynamicMenuCounter+1)
-	newItem := menu.Text(text, text, nil)
-	m.dynamicMenuItems[text] = newItem
 
-	item := m.runtime.Menu.GetByID(randomItemID)
-	if item == nil {
+	if randomMenuItem == nil {
 		return
 	}
 
-	m.runtime.Log.Info(fmt.Sprintf(
-		"Inserting menu item '%s' before menu item '%s'", newItem.Label,
-		item.Label))
-
-	item.InsertBefore(newItem)
-	m.runtime.Menu.Update()
-}
-
-func (m *Menu) insertAfterRandom(_ *menu.MenuItem) {
-
-	// Lock because this method will be called in a goroutine
-	m.lock.Lock()
-	defer m.lock.Unlock()
-
-	// Pick a random menu
-	var randomItemID string
-	var count int
-	var random = rand.Intn(len(m.dynamicMenuItems))
-	for randomItemID = range m.dynamicMenuItems {
-		if count == random {
-			break
-		}
-		count++
-	}
 	m.anotherDynamicMenuCounter++
-	text := "Other Dynamic Menu Item " + strconv.Itoa(
-		m.anotherDynamicMenuCounter+1)
-	newItem := menu.Text(text, text, nil)
-
-	item := m.runtime.Menu.GetByID(randomItemID)
+	text := "Other Dynamic Menu Item " + strconv.Itoa(m.anotherDynamicMenuCounter)
+	newItem := menu.Text(text, nil, nil)
 	m.dynamicMenuItems[text] = newItem
 
-	m.runtime.Log.Info(fmt.Sprintf(
-		"Inserting menu item '%s' after menu item '%s'", newItem.Label,
-		item.Label))
+	m.runtime.Log.Info(fmt.Sprintf("Inserting menu item '%s' before menu item '%s'", newItem.Label, randomMenuItem.Label))
 
-	item.InsertAfter(newItem)
-	m.runtime.Menu.Update()
+	randomMenuItem.InsertBefore(newItem)
+	m.runtime.Menu.UpdateApplicationMenu()
 }
 
-func createApplicationMenu() *menu.Menu {
+func (m *Menu) insertAfterRandom(_ *menu.CallbackData) {
+
+	// Pick a random menu
+	var randomMenuItem *menu.MenuItem
+	for _, randomMenuItem = range m.dynamicMenuItems {
+		break
+	}
+
+	if randomMenuItem == nil {
+		return
+	}
+
+	m.anotherDynamicMenuCounter++
+	text := "Other Dynamic Menu Item " + strconv.Itoa(m.anotherDynamicMenuCounter)
+	newItem := menu.Text(text, nil, nil)
+	m.dynamicMenuItems[text] = newItem
+
+	m.runtime.Log.Info(fmt.Sprintf("Inserting menu item '%s' after menu item '%s'", newItem.Label, randomMenuItem.Label))
+
+	randomMenuItem.InsertBefore(newItem)
+	m.runtime.Menu.UpdateApplicationMenu()
+}
+
+func (m *Menu) processPlainText(callbackData *menu.CallbackData) {
+	label := callbackData.MenuItem.Label
+	fmt.Printf("\n\n\n\n\n\n\nMenu Item label = `%s`\n\n\n\n\n", label)
+}
+
+func (m *Menu) createApplicationMenu() *menu.Menu {
+
+	m.dynamicMenuOneSubmenu = menu.SubMenuWithID("Dynamic Menus 1", menu.NewMenuFromItems(
+		menu.Text("Add Menu Item", keys.CmdOrCtrl("+"), m.addDynamicMenusOneMenu),
+		menu.Separator(),
+	))
 
 	// Create menu
 	myMenu := menu.DefaultMacMenu()
 
-	windowMenu := menu.SubMenu("Test", []*menu.MenuItem{
+	windowMenu := menu.SubMenu("Test", menu.NewMenuFromItems(
 		menu.Togglefullscreen(),
 		menu.Minimize(),
 		menu.Zoom(),
@@ -244,89 +215,90 @@ func createApplicationMenu() *menu.Menu {
 
 		menu.Front(),
 
-		menu.SubMenu("Test Submenu", []*menu.MenuItem{
-			menu.Text("Plain text", "plain text", nil),
-			menu.Text("Show Dynamic Menus 2 Submenu", "show-dynamic-menus-2", nil),
-			menu.SubMenu("Accelerators", []*menu.MenuItem{
-				menu.SubMenu("Modifiers", []*menu.MenuItem{
-					menu.Text("Shift accelerator", "Shift", keys.Shift("o")),
-					menu.Text("Control accelerator", "Control", keys.Control("o")),
-					menu.Text("Command accelerator", "Command", keys.CmdOrCtrl("o")),
-					menu.Text("Option accelerator", "Option", keys.OptionOrAlt("o")),
-				}),
-				menu.SubMenu("System Keys", []*menu.MenuItem{
-					menu.Text("Backspace", "Backspace", keys.Key("Backspace")),
-					menu.Text("Tab", "Tab", keys.Key("Tab")),
-					menu.Text("Return", "Return", keys.Key("Return")),
-					menu.Text("Escape", "Escape", keys.Key("Escape")),
-					menu.Text("Left", "Left", keys.Key("Left")),
-					menu.Text("Right", "Right", keys.Key("Right")),
-					menu.Text("Up", "Up", keys.Key("Up")),
-					menu.Text("Down", "Down", keys.Key("Down")),
-					menu.Text("Space", "Space", keys.Key("Space")),
-					menu.Text("Delete", "Delete", keys.Key("Delete")),
-					menu.Text("Home", "Home", keys.Key("Home")),
-					menu.Text("End", "End", keys.Key("End")),
-					menu.Text("Page Up", "Page Up", keys.Key("Page Up")),
-					menu.Text("Page Down", "Page Down", keys.Key("Page Down")),
-					menu.Text("NumLock", "NumLock", keys.Key("NumLock")),
-				}),
-				menu.SubMenu("Function Keys", []*menu.MenuItem{
-					menu.Text("F1", "F1", keys.Key("F1")),
-					menu.Text("F2", "F2", keys.Key("F2")),
-					menu.Text("F3", "F3", keys.Key("F3")),
-					menu.Text("F4", "F4", keys.Key("F4")),
-					menu.Text("F5", "F5", keys.Key("F5")),
-					menu.Text("F6", "F6", keys.Key("F6")),
-					menu.Text("F7", "F7", keys.Key("F7")),
-					menu.Text("F8", "F8", keys.Key("F8")),
-					menu.Text("F9", "F9", keys.Key("F9")),
-					menu.Text("F10", "F10", keys.Key("F10")),
-					menu.Text("F11", "F11", keys.Key("F11")),
-					menu.Text("F12", "F12", keys.Key("F12")),
-					menu.Text("F13", "F13", keys.Key("F13")),
-					menu.Text("F14", "F14", keys.Key("F14")),
-					menu.Text("F15", "F15", keys.Key("F15")),
-					menu.Text("F16", "F16", keys.Key("F16")),
-					menu.Text("F17", "F17", keys.Key("F17")),
-					menu.Text("F18", "F18", keys.Key("F18")),
-					menu.Text("F19", "F19", keys.Key("F19")),
-					menu.Text("F20", "F20", keys.Key("F20")),
-				}),
-				menu.SubMenu("Standard Keys", []*menu.MenuItem{
-					menu.Text("Backtick", "Backtick", keys.Key("`")),
-					menu.Text("Plus", "Plus", keys.Key("+")),
-				}),
-			}),
-			menu.SubMenuWithID("Dynamic Menus 1", "Dynamic Menus 1", []*menu.MenuItem{
-				menu.Text("Add Menu Item", "Add Menu Item", keys.CmdOrCtrl("+")),
-				menu.Separator(),
-			}),
-			{
+		menu.SubMenu("Test Submenu", menu.NewMenuFromItems(
+			menu.Text("Plain text", nil, m.processPlainText),
+			menu.Text("Show Dynamic Menus 2 Submenu", nil, m.createDynamicMenuTwo),
+			menu.SubMenu("Accelerators", menu.NewMenuFromItems(
+				menu.SubMenu("Modifiers", menu.NewMenuFromItems(
+					menu.Text("Shift accelerator", keys.Shift("o"), nil),
+					menu.Text("Control accelerator", keys.Control("o"), nil),
+					menu.Text("Command accelerator", keys.CmdOrCtrl("o"), nil),
+					menu.Text("Option accelerator", keys.OptionOrAlt("o"), nil),
+					menu.Text("Combo accelerator", keys.Combo("o", keys.CmdOrCtrlKey, keys.ShiftKey), nil),
+				)),
+				menu.SubMenu("System Keys", menu.NewMenuFromItems(
+					menu.Text("Backspace", keys.Key("Backspace"), nil),
+					menu.Text("Tab", keys.Key("Tab"), nil),
+					menu.Text("Return", keys.Key("Return"), nil),
+					menu.Text("Escape", keys.Key("Escape"), nil),
+					menu.Text("Left", keys.Key("Left"), nil),
+					menu.Text("Right", keys.Key("Right"), nil),
+					menu.Text("Up", keys.Key("Up"), nil),
+					menu.Text("Down", keys.Key("Down"), nil),
+					menu.Text("Space", keys.Key("Space"), nil),
+					menu.Text("Delete", keys.Key("Delete"), nil),
+					menu.Text("Home", keys.Key("Home"), nil),
+					menu.Text("End", keys.Key("End"), nil),
+					menu.Text("Page Up", keys.Key("Page Up"), nil),
+					menu.Text("Page Down", keys.Key("Page Down"), nil),
+					menu.Text("NumLock", keys.Key("NumLock"), nil),
+				)),
+				menu.SubMenu("Function Keys", menu.NewMenuFromItems(
+					menu.Text("F1", keys.Key("F1"), nil),
+					menu.Text("F2", keys.Key("F2"), nil),
+					menu.Text("F3", keys.Key("F3"), nil),
+					menu.Text("F4", keys.Key("F4"), nil),
+					menu.Text("F5", keys.Key("F5"), nil),
+					menu.Text("F6", keys.Key("F6"), nil),
+					menu.Text("F7", keys.Key("F7"), nil),
+					menu.Text("F8", keys.Key("F8"), nil),
+					menu.Text("F9", keys.Key("F9"), nil),
+					menu.Text("F10", keys.Key("F10"), nil),
+					menu.Text("F11", keys.Key("F11"), nil),
+					menu.Text("F12", keys.Key("F12"), nil),
+					menu.Text("F13", keys.Key("F13"), nil),
+					menu.Text("F14", keys.Key("F14"), nil),
+					menu.Text("F15", keys.Key("F15"), nil),
+					menu.Text("F16", keys.Key("F16"), nil),
+					menu.Text("F17", keys.Key("F17"), nil),
+					menu.Text("F18", keys.Key("F18"), nil),
+					menu.Text("F19", keys.Key("F19"), nil),
+					menu.Text("F20", keys.Key("F20"), nil),
+				)),
+				menu.SubMenu("Standard Keys", menu.NewMenuFromItems(
+					menu.Text("Backtick", keys.Key("`"), nil),
+					menu.Text("Plus", keys.Key("+"), nil),
+				)),
+			)),
+			m.dynamicMenuOneSubmenu,
+			&menu.MenuItem{
 				Label:       "Disabled Menu",
 				Type:        menu.TextType,
 				Accelerator: keys.Combo("p", keys.CmdOrCtrlKey, keys.ShiftKey),
 				Disabled:    true,
 			},
-			{
+			&menu.MenuItem{
 				Label:  "Hidden Menu",
 				Type:   menu.TextType,
 				Hidden: true,
 			},
-			{
-				ID:          "checkbox-menu 1",
+			&menu.MenuItem{
 				Label:       "Checkbox Menu 1",
 				Type:        menu.CheckboxType,
 				Accelerator: keys.CmdOrCtrl("l"),
 				Checked:     true,
+				Click: func(data *menu.CallbackData) {
+					fmt.Printf("The '%s' menu was clicked\n", data.MenuItem.Label)
+					fmt.Printf("It is now %v\n", data.MenuItem.Checked)
+				},
 			},
-			menu.Checkbox("Checkbox Menu 2", "checkbox-menu 2", false, nil),
+			menu.Checkbox("Checkbox Menu 2", false, nil, nil),
 			menu.Separator(),
-			menu.Radio("😀 Option 1", "😀option-1", true, nil),
-			menu.Radio("😺 Option 2", "option-2", false, nil),
-			menu.Radio("❤️ Option 3", "option-3", false, nil),
-		}),
-	})
+			menu.Radio("😀 Option 1", true, nil, nil),
+			menu.Radio("😺 Option 2", false, nil, nil),
+			menu.Radio("❤️ Option 3", false, nil, nil),
+		)),
+	))
 
 	myMenu.Append(windowMenu)
 	return myMenu

v2/test/kitchensink/tray.go

@@ -3,7 +3,6 @@ package main
 import (
 	"github.com/wailsapp/wails/v2"
 	"github.com/wailsapp/wails/v2/pkg/menu"
-	"github.com/wailsapp/wails/v2/pkg/menu/keys"
 	"strconv"
 	"sync"
 )
@@ -12,49 +11,50 @@ import (
 type Tray struct {
 	runtime *wails.Runtime
 
-	dynamicMenuCounter        int
-	lock                      sync.Mutex
-	dynamicMenuItems          map[string]*menu.MenuItem
-	anotherDynamicMenuCounter int
+	dynamicMenuCounter int
+	lock               sync.Mutex
+	dynamicMenuItems   map[string]*menu.MenuItem
+
+	trayMenu       *menu.TrayMenu
+	secondTrayMenu *menu.TrayMenu
 
 	done bool
 }
 
-// WailsInit is called at application startup
-func (t *Tray) WailsInit(runtime *wails.Runtime) error {
+// This is called at application startup
+func (t *Tray) start(runtime *wails.Runtime) {
 	// Perform your setup here
 	t.runtime = runtime
 
-	// Setup Menu Listeners
-	t.runtime.Tray.On("Show Window", func(mi *menu.MenuItem) {
-		t.runtime.Window.Show()
-	})
-	t.runtime.Tray.On("Hide Window", func(mi *menu.MenuItem) {
-		t.runtime.Window.Hide()
-	})
+	//// Auto switch between light / dark tray icons
+	//t.runtime.Events.OnThemeChange(func(darkMode bool) {
+	//	if darkMode {
+	//		t.runtime.Tray.SetIcon("light")
+	//		return
+	//	}
+	//
+	//	t.runtime.Tray.SetIcon("dark")
+	//})
 
-	t.runtime.Tray.On("Minimise Window", func(mi *menu.MenuItem) {
-		t.runtime.Window.Minimise()
-	})
-
-	t.runtime.Tray.On("Unminimise Window", func(mi *menu.MenuItem) {
-		t.runtime.Window.Unminimise()
-	})
-
-	// Auto switch between light / dark tray icons
-	t.runtime.Events.OnThemeChange(func(darkMode bool) {
-		if darkMode {
-			t.runtime.Tray.SetIcon("light")
-			return
-		}
-
-		t.runtime.Tray.SetIcon("dark")
-	})
-
-	return nil
 }
 
-func (t *Tray) WailsShutdown() {
+func (t *Tray) showWindow(_ *menu.CallbackData) {
+	t.runtime.Window.Show()
+}
+
+func (t *Tray) hideWindow(_ *menu.CallbackData) {
+	t.runtime.Window.Hide()
+}
+
+func (t *Tray) unminimiseWindow(_ *menu.CallbackData) {
+	t.runtime.Window.Unminimise()
+}
+
+func (t *Tray) minimiseWindow(_ *menu.CallbackData) {
+	t.runtime.Window.Minimise()
+}
+
+func (t *Tray) shutdown() {
 	t.done = true
 }
 
@@ -68,77 +68,95 @@ func (t *Tray) decrementcounter() int {
 	return t.dynamicMenuCounter
 }
 
-func (t *Tray) addMenu(mi *menu.MenuItem) {
+func (t *Tray) SvelteIcon(_ *menu.CallbackData) {
+	t.secondTrayMenu.Icon = "svelte"
+	t.runtime.Menu.SetTrayMenu(t.secondTrayMenu)
+}
+func (t *Tray) NoIcon(_ *menu.CallbackData) {
+	t.secondTrayMenu.Icon = ""
+	t.runtime.Menu.SetTrayMenu(t.secondTrayMenu)
+}
+func (t *Tray) LightIcon(_ *menu.CallbackData) {
+	t.secondTrayMenu.Icon = "light"
+	t.runtime.Menu.SetTrayMenu(t.secondTrayMenu)
+}
+func (t *Tray) DarkIcon(_ *menu.CallbackData) {
+	t.secondTrayMenu.Icon = "dark"
+	t.runtime.Menu.SetTrayMenu(t.secondTrayMenu)
+}
 
-	// Lock because this method will be called in a gorouting
-	t.lock.Lock()
-	defer t.lock.Unlock()
+//func (t *Tray) removeMenu(_ *menu.MenuItem) {
+//
+//	// Lock because this method will be called in a goroutine
+//	t.lock.Lock()
+//	defer t.lock.Unlock()
+//
+//	// Get the id of the last dynamic menu
+//	menuID := "Dynamic Menu Item " + strconv.Itoa(t.dynamicMenuCounter)
+//
+//	// Remove the last menu item by ID
+//	t.runtime.Tray.RemoveByID(menuID)
+//
+//	// Update the counter
+//	counter := t.decrementcounter()
+//
+//	// If we deleted the last dynamic menu, remove the "Remove Last Item" menu
+//	if counter == 0 {
+//		t.runtime.Tray.RemoveByID("Remove Last Item")
+//	} else {
+//		// Update label
+//		menuText := "Dynamic Menu Item " + strconv.Itoa(counter)
+//		removeMenu := t.runtime.Tray.GetByID("Remove Last Item")
+//		// Test if the remove menu hasn't already been removed in another thread
+//		if removeMenu == nil {
+//			return
+//		}
+//		removeMenu.Label = "Remove " + menuText
+//	}
+//
+//	// 	parent.Append(menu.Text(menuText, menuText, menu.Key("[")))
+//	t.runtime.Tray.Update()
+//}
 
-	// Get this menu's parent
-	parent := mi.Parent()
-	counter := t.incrementcounter()
-	menuText := "Dynamic Menu Item " + strconv.Itoa(counter)
-	parent.Append(menu.Text(menuText, menuText, nil))
-	// 	parent.Append(menu.Text(menuText, menuText, menu.Key("[")))
+//func (t *Tray) SetIcon(trayIconID string) {
+//	t.runtime.Tray.SetIcon(trayIconID)
+//}
 
-	// If this is the first dynamic menu added, let's add a remove menu item
-	if counter == 1 {
-		removeMenu := menu.Text("Remove "+menuText,
-			"Remove Last Item", keys.CmdOrCtrl("-"))
-		parent.Prepend(removeMenu)
-		t.runtime.Tray.On("Remove Last Item", t.removeMenu)
-	} else {
-		removeMenu := t.runtime.Tray.GetByID("Remove Last Item")
-		// Test if the remove menu hasn't already been removed in another thread
-		if removeMenu != nil {
-			removeMenu.Label = "Remove " + menuText
-		}
+func (t *Tray) createTrayMenus() []*menu.TrayMenu {
+	trayMenu := &menu.TrayMenu{}
+	trayMenu.Label = "Test Tray Label"
+	trayMenu.Menu = menu.NewMenuFromItems(
+		menu.Text("Show Window", nil, t.showWindow),
+		menu.Text("Hide Window", nil, t.hideWindow),
+		menu.Text("Minimise Window", nil, t.minimiseWindow),
+		menu.Text("Unminimise Window", nil, t.unminimiseWindow),
+	)
+	t.trayMenu = trayMenu
+
+	secondTrayMenu := &menu.TrayMenu{}
+	secondTrayMenu.Label = "Another tray label"
+	secondTrayMenu.Icon = "svelte"
+	secondTrayMenu.Menu = menu.NewMenuFromItems(
+		menu.Text("Update Label", nil, func(_ *menu.CallbackData) {
+			// Lock because this method will be called in a goroutine
+			t.lock.Lock()
+			defer t.lock.Unlock()
+
+			counter := t.incrementcounter()
+			trayLabel := "Updated Label " + strconv.Itoa(counter)
+			secondTrayMenu.Label = trayLabel
+			t.runtime.Menu.SetTrayMenu(t.secondTrayMenu)
+		}),
+		menu.SubMenu("Select Icon", menu.NewMenuFromItems(
+			menu.Text("Svelte", nil, t.SvelteIcon),
+			menu.Text("Light", nil, t.LightIcon),
+			menu.Text("Dark", nil, t.DarkIcon),
+			menu.Text("None", nil, t.NoIcon),
+		)),
+	)
+	t.secondTrayMenu = secondTrayMenu
+	return []*menu.TrayMenu{
+		trayMenu,
+		secondTrayMenu,
 	}
-	t.runtime.Tray.Update()
-}
-
-func (t *Tray) removeMenu(_ *menu.MenuItem) {
-
-	// Lock because this method will be called in a goroutine
-	t.lock.Lock()
-	defer t.lock.Unlock()
-
-	// Get the id of the last dynamic menu
-	menuID := "Dynamic Menu Item " + strconv.Itoa(t.dynamicMenuCounter)
-
-	// Remove the last menu item by ID
-	t.runtime.Tray.RemoveByID(menuID)
-
-	// Update the counter
-	counter := t.decrementcounter()
-
-	// If we deleted the last dynamic menu, remove the "Remove Last Item" menu
-	if counter == 0 {
-		t.runtime.Tray.RemoveByID("Remove Last Item")
-	} else {
-		// Update label
-		menuText := "Dynamic Menu Item " + strconv.Itoa(counter)
-		removeMenu := t.runtime.Tray.GetByID("Remove Last Item")
-		// Test if the remove menu hasn't already been removed in another thread
-		if removeMenu == nil {
-			return
-		}
-		removeMenu.Label = "Remove " + menuText
-	}
-
-	// 	parent.Append(menu.Text(menuText, menuText, menu.Key("[")))
-	t.runtime.Tray.Update()
-}
-
-func (t *Tray) SetIcon(trayIconID string) {
-	t.runtime.Tray.SetIcon(trayIconID)
-}
-
-func createApplicationTray() *menu.Menu {
-	trayMenu := &menu.Menu{}
-	trayMenu.Append(menu.Text("Show Window", "Show Window", nil))
-	trayMenu.Append(menu.Text("Hide Window", "Hide Window", nil))
-	trayMenu.Append(menu.Text("Minimise Window", "Minimise Window", nil))
-	trayMenu.Append(menu.Text("Unminimise Window", "Unminimise Window", nil))
-	return trayMenu
 }

v2/test/runtime/runtime.go

@@ -1,10 +1,10 @@
 package main
 
 import (
+	"github.com/wailsapp/wails/v2/pkg/options/dialog"
 	"time"
 
 	"github.com/wailsapp/wails/v2"
-	"github.com/wailsapp/wails/v2/pkg/options"
 )
 
 // RuntimeTest to test the runtimes
@@ -75,7 +75,7 @@ func (r *RuntimeTest) SetColour(colour int) {
 
 // OpenFileDialog will call the Runtime.Dialog.OpenDialog method requesting File selection
 func (r *RuntimeTest) OpenFileDialog(title string, filter string) []string {
-	dialogOptions := &options.OpenDialog{
+	dialogOptions := &dialog.OpenDialog{
 		Title:      title,
 		Filters:    filter,
 		AllowFiles: true,
@@ -85,7 +85,7 @@ func (r *RuntimeTest) OpenFileDialog(title string, filter string) []string {
 
 // OpenDirectoryDialog will call the Runtime.Dialog.OpenDialog method requesting File selection
 func (r *RuntimeTest) OpenDirectoryDialog(title string, filter string) []string {
-	dialogOptions := &options.OpenDialog{
+	dialogOptions := &dialog.OpenDialog{
 		Title:            title,
 		Filters:          filter,
 		AllowDirectories: true,
@@ -95,7 +95,7 @@ func (r *RuntimeTest) OpenDirectoryDialog(title string, filter string) []string
 
 // OpenDialog will call the Runtime.Dialog.OpenDialog method requesting both Files and Directories
 func (r *RuntimeTest) OpenDialog(title string, filter string) []string {
-	dialogOptions := &options.OpenDialog{
+	dialogOptions := &dialog.OpenDialog{
 		Title:            title,
 		Filters:          filter,
 		AllowDirectories: true,
@@ -106,7 +106,7 @@ func (r *RuntimeTest) OpenDialog(title string, filter string) []string {
 
 // OpenDialogMultiple will call the Runtime.Dialog.OpenDialog method allowing multiple selection
 func (r *RuntimeTest) OpenDialogMultiple(title string, filter string) []string {
-	dialogOptions := &options.OpenDialog{
+	dialogOptions := &dialog.OpenDialog{
 		Title:            title,
 		Filters:          filter,
 		AllowDirectories: true,
@@ -118,7 +118,7 @@ func (r *RuntimeTest) OpenDialogMultiple(title string, filter string) []string {
 
 // OpenDialogAllOptions will call the Runtime.Dialog.OpenDialog method allowing multiple selection
 func (r *RuntimeTest) OpenDialogAllOptions(filter string, defaultDir string, defaultFilename string) []string {
-	dialogOptions := &options.OpenDialog{
+	dialogOptions := &dialog.OpenDialog{
 		DefaultDirectory:           defaultDir,
 		DefaultFilename:            defaultFilename,
 		Filters:                    filter,
@@ -134,7 +134,7 @@ func (r *RuntimeTest) OpenDialogAllOptions(filter string, defaultDir string, def
 
 // SaveFileDialog will call the Runtime.Dialog.SaveDialog method requesting a File selection
 func (r *RuntimeTest) SaveFileDialog(title string, filter string) string {
-	dialogOptions := &options.SaveDialog{
+	dialogOptions := &dialog.SaveDialog{
 		Title:   title,
 		Filters: filter,
 	}
@@ -143,7 +143,7 @@ func (r *RuntimeTest) SaveFileDialog(title string, filter string) string {
 
 // SaveDialogAllOptions will call the Runtime.Dialog.SaveDialog method allowing multiple selection
 func (r *RuntimeTest) SaveDialogAllOptions(filter string, defaultDir string, defaultFilename string) string {
-	dialogOptions := &options.SaveDialog{
+	dialogOptions := &dialog.SaveDialog{
 		DefaultDirectory:           defaultDir,
 		DefaultFilename:            defaultFilename,
 		Filters:                    filter,