v2.0.0-alpha.12

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.4"
+var version = "v2.0.0-alpha.12"

v2/go.mod

@@ -1,6 +1,6 @@
 module github.com/wailsapp/wails/v2
 
-go 1.13
+go 1.15
 
 require (
 	github.com/davecgh/go-spew v1.1.1

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/ffenestri/common.c

@@ -0,0 +1,95 @@
+//
+// 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 = "";
+    if ( node != NULL && node->tag == JSON_STRING) {
+        result = node->string_;
+    }
+    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 *node, const char* key) {
+    const char* result = getJSONString(node, key);
+    if ( result == NULL ) {
+        ABORT_JSON(node, key);
+    }
+    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 *item, const char* key, bool *result) {
+    JsonNode *node = json_find_member(item, key);
+    if ( node != NULL && node->tag == JSON_BOOL) {
+        *result = node->bool_;
+        return true;
+    }
+    return false;
+}
+
+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,40 @@
+//
+// 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(a) concat(a, "")
+#define STR_HAS_CHARS(input) input != NULL && strlen(input) > 0
+#define MEMFREE(input) free((void*)input); input = NULL;
+#define FREE_AND_SET(variable, value) if( variable != NULL ) { MEMFREE(variable); } variable = value
+
+// Credit: https://stackoverflow.com/a/8465083
+char* concat(const char *string1, const char *string2);
+void ABORT(const char *message, ...);
+int freeHashmapItem(void *const context, struct hashmap_element_s *const e);
+const char* getJSONString(JsonNode *item, const char* key);
+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 *result);
+bool getJSONInt(JsonNode *item, const char* key, int *result);
+
+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) {
+    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->parentData = result;
+    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*, 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(struct Application*, char *callbackID, char *title, char *filters, char *defaultFilename, char *defaultDir, int showHiddenFiles, int canCreateDirectories, int treatPackagesAsDirectories);
+extern void MessageDialog(struct Application*, 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(struct Application*, 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*, char *contextMenuJSON);
+extern void UpdateContextMenu(struct Application*, 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 {
 
@@ -63,54 +59,32 @@ func (a *Application) processPlatformSettings() error {
 	}
 
 	// 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)))
+	//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.GetTrayMenus()
+	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)
+	contextMenus, err := a.menuManager.GetContextMenus()
+	if err != nil {
+		return err
+	}
 	if contextMenus != nil {
-		contextMenusJSON, err := json.Marshal(contextMenus)
-		fmt.Printf("\n\nCONTEXT MENUS:\n %+v\n\n", string(contextMenusJSON))
-		if err != nil {
-			return err
+		for _, contextMenu := range contextMenus {
+			C.AddContextMenu(a.app, a.string2CString(contextMenu))
 		}
-		C.SetContextMenus(a.app, a.string2CString(string(contextMenusJSON)))
 	}
 
 	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 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 *);
+void AddTrayMenu(struct Application* app, const char *);
 
 #endif

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_darwin.c

@@ -0,0 +1,816 @@
+//
+// Created by Lea Anthony on 6/1/21.
+//
+
+#include "ffenestri_darwin.h"
+#include "menu_darwin.h"
+#include "contextmenus_darwin.h"
+
+// NewMenu creates a new Menu struct, saving the given menu structure as JSON
+Menu* NewMenu(JsonNode *menuData) {
+
+    Menu *result = malloc(sizeof(Menu));
+
+    result->processedMenu = menuData;
+
+    // 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->parentData = NULL;
+
+    return result;
+}
+
+Menu* NewApplicationMenu(const char *menuAsJSON) {
+
+    // Parse the menu json
+    JsonNode *processedMenu = json_decode(menuAsJSON);
+    if( processedMenu == NULL ) {
+        // Parse error!
+        ABORT("Unable to parse Menu JSON: %s", menuAsJSON);
+    }
+
+    Menu *result = NewMenu(processedMenu);
+    result->menuType = ApplicationMenuType;
+    return result;
+}
+
+MenuItemCallbackData* CreateMenuItemCallbackData(Menu *menu, id menuItem, const char *menuID, enum MenuItemType menuItemType) {
+    MenuItemCallbackData* result = malloc(sizeof(MenuItemCallbackData));
+
+    result->menu = menu;
+    result->menuID = menuID;
+    result->menuItem = menuItem;
+    result->menuItemType = menuItemType;
+
+    // Store reference to this so we can destroy later
+    vec_push(&menu->callbackDataCache, result);
+
+    return result;
+}
+
+void DeleteMenu(Menu *menu) {
+
+    // 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);
+
+    // Free up the processed menu memory
+    if (menu->processedMenu != NULL) {
+        json_delete(menu->processedMenu);
+        menu->processedMenu = NULL;
+    }
+
+    // Release the vector memory
+    vec_deinit(&menu->callbackDataCache);
+
+    // Free nsmenu if we have it
+    if ( menu->menu != NULL ) {
+        msg(menu->menu, s("release"));
+    }
+
+    free(menu);
+}
+
+// Creates a JSON message for the given menuItemID and data
+const char* createMenuClickedMessage(const char *menuItemID, const char *data, enum MenuType menuType, const char *parentID) {
+
+    JsonNode *jsonObject = json_mkobject();
+    if (menuItemID == NULL ) {
+        ABORT("Item ID NULL for menu!!\n");
+    }
+    json_append_member(jsonObject, "menuItemID", json_mkstring(menuItemID));
+    json_append_member(jsonObject, "menuType", json_mkstring(MenuTypeAsString[(int)menuType]));
+    if (data != NULL) {
+        json_append_member(jsonObject, "data", json_mkstring(data));
+    }
+    if (parentID != NULL) {
+        json_append_member(jsonObject, "parentID", json_mkstring(parentID));
+    }
+    const char *payload = json_encode(jsonObject);
+    json_delete(jsonObject);
+    const char *result = concat("MC", payload);
+    MEMFREE(payload);
+    return result;
+}
+
+// Callback for text menu items
+void menuItemCallback(id self, SEL cmd, id sender) {
+    MenuItemCallbackData *callbackData = (MenuItemCallbackData *)msg(msg(sender, s("representedObject")), s("pointerValue"));
+    const char *message;
+
+    // Update checkbox / radio item
+    if( callbackData->menuItemType == Checkbox) {
+        // Toggle state
+        bool state = msg(callbackData->menuItem, s("state"));
+        msg(callbackData->menuItem, s("setState:"), (state? NSControlStateValueOff : NSControlStateValueOn));
+    } else if( callbackData->menuItemType == Radio ) {
+        // Check the menu items' current state
+        bool selected = msg(callbackData->menuItem, 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->menuID, strlen(callbackData->menuID));
+
+        // 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(callbackData->menuItem, s("setState:"), NSControlStateValueOn);
+    }
+
+    const char *menuID = callbackData->menuID;
+    const char *data = NULL;
+    enum MenuType menuType = callbackData->menu->menuType;
+    const char *parentID = NULL;
+
+    // Generate message to send to backend
+    if( menuType == ContextMenuType ) {
+        // Get the context menu data from the menu
+        ContextMenu* contextMenu = (ContextMenu*) callbackData->menu->parentData;
+        data = contextMenu->contextMenuData;
+        parentID = contextMenu->ID;
+    } else if ( menuType == TrayMenuType ) {
+        parentID = (const char*) callbackData->menu->parentData;
+    }
+
+    message = createMenuClickedMessage(menuID, data, menuType, parentID);
+
+    // Notify the backend
+    messageFromWindowCallback(message);
+    MEMFREE(message);
+}
+
+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);
+}
+
+
+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;
+    }
+
+}
+
+// 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;
+}
+
+id processRadioMenuItem(Menu *menu, id parentmenu, const char *title, const char *menuid, bool disabled, bool checked, const char *acceleratorkey) {
+    id item = ALLOC("NSMenuItem");
+
+    // Store the item in the menu item map
+    hashmap_put(&menu->menuItemMap, (char*)menuid, strlen(menuid), item);
+
+    // Create a MenuItemCallbackData
+    MenuItemCallbackData *callback = CreateMenuItemCallbackData(menu, item, menuid, 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 *menuid, bool disabled, bool checked, const char *key) {
+
+    id item = ALLOC("NSMenuItem");
+
+    // Store the item in the menu item map
+    hashmap_put(&menu->menuItemMap, (char*)menuid, strlen(menuid), item);
+
+    // Create a MenuItemCallbackData
+    MenuItemCallbackData *callback = CreateMenuItemCallbackData(menu, item, menuid, 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 *menuid, bool disabled, const char *acceleratorkey, const char **modifiers, const char* tooltip) {
+    id item = ALLOC("NSMenuItem");
+
+    // Create a MenuItemCallbackData
+    MenuItemCallbackData *callback = CreateMenuItemCallbackData(menu, item, menuid, 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);
+
+    if( tooltip != NULL ) {
+        msg(item, s("setToolTip:"), str(tooltip));
+    }
+
+    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 = false;
+    getJSONBool(item, "Hidden", &hidden);
+    if( hidden ) {
+        return;
+    }
+
+    // Get the role
+    JsonNode *role = json_find_member(item, "Role");
+    if( role != NULL ) {
+        processMenuRole(menu, parentMenu, role);
+        return;
+    }
+
+    // Check if this is a submenu
+    JsonNode *submenu = json_find_member(item, "SubMenu");
+    if( submenu != NULL ) {
+        // Get the label
+        JsonNode *menuNameNode = json_find_member(item, "Label");
+        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, "Items");
+        // 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, "Label");
+    if ( label == NULL) {
+        label = "(empty)";
+    }
+
+    const char *menuid = getJSONString(item, "ID");
+    if ( menuid == NULL) {
+        menuid = "";
+    }
+
+    bool disabled = false;
+    getJSONBool(item, "Disabled", &disabled);
+
+    // Get the Accelerator
+    JsonNode *accelerator = json_find_member(item, "Accelerator");
+    const char *acceleratorkey = NULL;
+    const char **modifiers = NULL;
+
+    const char *tooltip = getJSONString(item, "Tooltip");
+
+    // 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;
+            }
+        }
+    }
+
+    // Get the Type
+    JsonNode *type = json_find_member(item, "Type");
+    if( type != NULL ) {
+
+        if( STREQ(type->string_, "Text")) {
+            processTextMenuItem(menu, parentMenu, label, menuid, disabled, acceleratorkey, modifiers, tooltip);
+        }
+        else if ( STREQ(type->string_, "Separator")) {
+            addSeparator(parentMenu);
+        }
+        else if ( STREQ(type->string_, "Checkbox")) {
+            // Get checked state
+            bool checked = false;
+            getJSONBool(item, "Checked", &checked);
+
+            processCheckboxMenuItem(menu, parentMenu, label, menuid, disabled, checked, "");
+        }
+        else if ( STREQ(type->string_, "Radio")) {
+            // Get checked state
+            bool checked = false;
+            getJSONBool(item, "Checked", &checked);
+
+            processRadioMenuItem(menu, parentMenu, label, menuid, disabled, checked, "");
+        }
+
+    }
+
+    if ( modifiers != NULL ) {
+        free(modifiers);
+    }
+
+    return;
+}
+
+void processMenuData(Menu *menu, JsonNode *menuData) {
+    JsonNode *items = json_find_member(menuData, "Items");
+    if( items == NULL ) {
+        // Parse error!
+        ABORT("Unable to find 'Items' in menu JSON!");
+    }
+
+    // Iterate items
+    JsonNode *item;
+    json_foreach(item, items) {
+        // 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 GetMenu(Menu *menu) {
+
+    // Pull out the menu data
+    JsonNode *menuData = json_find_member(menu->processedMenu, "Menu");
+    if( menuData == NULL ) {
+        ABORT("Unable to find Menu data: %s", menu->processedMenu);
+    }
+
+    menu->menu = createMenu(str(""));
+
+    // Process the menu data
+    processMenuData(menu, menuData);
+
+    // Create the radiogroup cache
+    JsonNode *radioGroups = json_find_member(menu->processedMenu, "RadioGroups");
+    if( radioGroups == NULL ) {
+        // Parse error!
+        ABORT("Unable to find RadioGroups data: %s", menu->processedMenu);
+    }
+
+    // Iterate radio groups
+    JsonNode *radioGroup;
+    json_foreach(radioGroup, radioGroups) {
+        // Get item label
+        processRadioGroupJSON(menu, radioGroup);
+    }
+
+    return menu->menu;
+}
+

v2/internal/ffenestri/menu_darwin.h

@@ -0,0 +1,100 @@
+//
+// 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 *);
+
+typedef struct {
+
+    const char *title;
+
+    /*** Internal ***/
+
+    // The decoded version of the Menu JSON
+    JsonNode *processedMenu;
+
+    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;
+
+    // The parent data, eg ContextMenuStore or Tray
+    void *parentData;
+
+    // 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 {
+    id menuItem;
+    Menu *menu;
+    const char *menuID;
+    enum MenuItemType menuItemType;
+} MenuItemCallbackData;
+
+
+
+// NewMenu creates a new Menu struct, saving the given menu structure as JSON
+Menu* NewMenu(JsonNode *menuData);
+
+Menu* NewApplicationMenu(const char *menuAsJSON);
+MenuItemCallbackData* CreateMenuItemCallbackData(Menu *menu, id menuItem, const char *menuID, 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, enum MenuType menuType, const char *parentID);
+// 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);
+
+id processCheckboxMenuItem(Menu *menu, id parentmenu, const char *title, const char *menuid, bool disabled, bool checked, const char *key);
+
+id processTextMenuItem(Menu *menu, id parentMenu, const char *title, const char *menuid, bool disabled, const char *acceleratorkey, const char **modifiers, const char* tooltip);
+
+void processMenuItem(Menu *menu, id parentMenu, JsonNode *item);
+void processMenuData(Menu *menu, JsonNode *menuData);
+
+void processRadioGroupJSON(Menu *menu, JsonNode *radioGroup) ;
+id GetMenu(Menu *menu);
+#endif //ASSETS_C_MENU_DARWIN_H

v2/internal/ffenestri/traymenu_darwin.c

@@ -0,0 +1,202 @@
+//
+// 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) {
+    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);
+    }
+
+    // Save reference to this json
+    result->processedJSON = processedJSON;
+
+    // TODO: Make this configurable
+    result->trayIconPosition = NSImageLeft;
+
+    result->ID = mustJSONString(processedJSON, "ID");
+    result->label = mustJSONString(processedJSON, "Label");
+    result->icon = mustJSONString(processedJSON, "Icon");
+    JsonNode* processedMenu = mustJSONObject(processedJSON, "ProcessedMenu");
+
+    // Create the menu
+    result->menu = NewMenu(processedMenu);
+
+    // Init tray status bar item
+    result->statusbaritem = NULL;
+
+    // Set the menu type and store the tray ID in the parent data
+    result->menu->menuType = TrayMenuType;
+    result->menu->parentData = (void*) result->ID;
+
+    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 UpdateTrayLabel(TrayMenu *trayMenu, const char *label) {
+
+    // Exit early if NULL
+    if( trayMenu->label == NULL ) {
+        return;
+    }
+    // Update button label
+    id statusBarButton = msg(trayMenu->statusbaritem, s("button"));
+    msg(statusBarButton, s("setTitle:"), str(label));
+}
+
+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
+    id menu = GetMenu(trayMenu->menu);
+    msg(trayMenu->statusbaritem, s("setMenu:"), 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;
+
+    // Delete the old JSON
+    json_delete(currentMenu->processedJSON);
+
+    // Set the new JSON
+    currentMenu->processedJSON = newMenu->processedJSON;
+
+    // Copy the other data
+    currentMenu->ID = newMenu->ID;
+    currentMenu->label = newMenu->label;
+    currentMenu->trayIconPosition = newMenu->trayIconPosition;
+    currentMenu->icon = newMenu->icon;
+
+}
+
+void DeleteTrayMenu(TrayMenu* trayMenu) {
+
+//    printf("Freeing TrayMenu:\n");
+//    DumpTrayMenu(trayMenu);
+
+    // Delete the menu
+    DeleteMenu(trayMenu->menu);
+
+    // Free JSON
+    if (trayMenu->processedJSON != NULL ) {
+        json_delete(trayMenu->processedJSON);
+    }
+
+    // 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);
+    }
+}
+
+void UnloadTrayIcons() {
+    // Release the tray cache images
+    if( hashmap_num_entries(&trayIconCache) > 0 ) {
+        if (0!=hashmap_iterate_pairs(&trayIconCache, releaseNSObject, NULL)) {
+            ABORT("failed to release hashmap entries!");
+        }
+    }
+
+    //Free radio groups hashmap
+    hashmap_destroy(&trayIconCache);
+}

v2/internal/ffenestri/traymenu_darwin.h

@@ -0,0 +1,38 @@
+//
+// Created by Lea Anthony on 12/1/21.
+//
+
+#ifndef TRAYMENU_DARWIN_H
+#define TRAYMENU_DARWIN_H
+
+#include "common.h"
+#include "menu_darwin.h"
+
+typedef struct {
+
+    const char *label;
+    const char *icon;
+    const char *ID;
+
+    Menu* menu;
+
+    id statusbaritem;
+    int trayIconPosition;
+
+    JsonNode* processedJSON;
+
+} TrayMenu;
+
+TrayMenu* NewTrayMenu(const char *trayJSON);
+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,134 @@
+//
+// 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!");
+    }
+
+    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);
+
+    //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);
+}
+
+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;
+}
+
+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);
+
+}
+
+void UpdateTrayMenuInStore(TrayMenuStore* store, const char* menuJSON) {
+    TrayMenu* newMenu = NewTrayMenu(menuJSON);
+    DumpTrayMenu(newMenu);
+
+    // Get the current menu
+    TrayMenu *currentMenu = GetTrayMenuFromStore(store, newMenu->ID);
+
+    // If we don't have a menu, we create one
+    if ( currentMenu == NULL ) {
+        printf("  currentMenu = NULL\n");
+        // Store the new menu
+        hashmap_put(&store->trayMenuMap, newMenu->ID, strlen(newMenu->ID), newMenu);
+
+        // Show it
+        ShowTrayMenu(newMenu);
+        return;
+    }
+    DumpTrayMenu(currentMenu);
+
+    // 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);
+
+    // Show the updated menu
+    ShowTrayMenu(newMenu);
+
+}

v2/internal/ffenestri/traymenustore_darwin.h

@@ -0,0 +1,27 @@
+//
+// Created by Lea Anthony on 7/1/21.
+//
+
+#ifndef TRAYMENUSTORE_DARWIN_H
+#define TRAYMENUSTORE_DARWIN_H
+
+typedef struct {
+
+	int dummy;
+
+    // This is our tray menu map
+    // It maps tray IDs to TrayMenu*
+    struct hashmap_s trayMenuMap;
+
+} TrayMenuStore;
+
+TrayMenuStore* NewTrayMenuStore();
+
+void AddTrayMenuToStore(TrayMenuStore* store, const char* menuJSON);
+void UpdateTrayMenuInStore(TrayMenuStore* store, const char* menuJSON);
+void ShowTrayMenusInStore(TrayMenuStore* store);
+void DeleteTrayMenuStore(TrayMenuStore* store);
+
+void UpdateTrayMenuLabelInStore(TrayMenuStore* store, const char* JSON);
+
+#endif //TRAYMENUSTORE_DARWIN_H

v2/internal/menumanager/applicationmenu.go

@@ -0,0 +1,46 @@
+package menumanager
+
+import "github.com/wailsapp/wails/v2/pkg/menu"
+
+func (m *Manager) SetApplicationMenu(applicationMenu *menu.Menu) error {
+
+	if applicationMenu == nil {
+		return nil
+	}
+
+	m.applicationMenu = applicationMenu
+
+	// Reset the menu map
+	m.applicationMenuItemMap = NewMenuItemMap()
+
+	// Add the menu to the menu map
+	m.applicationMenuItemMap.AddMenu(applicationMenu)
+
+	return m.processApplicationMenu()
+}
+
+func (m *Manager) GetApplicationMenuJSON() string {
+	return m.applicationMenuJSON
+}
+
+// UpdateApplicationMenu reprocesses the application menu to pick up structure
+// changes etc
+// Returns the JSON representation of the updated menu
+func (m *Manager) UpdateApplicationMenu() (string, error) {
+	m.applicationMenuItemMap = NewMenuItemMap()
+	m.applicationMenuItemMap.AddMenu(m.applicationMenu)
+	err := m.processApplicationMenu()
+	return m.applicationMenuJSON, err
+}
+
+func (m *Manager) processApplicationMenu() error {
+
+	// Process the menu
+	processedApplicationMenu := NewWailsMenu(m.applicationMenuItemMap, m.applicationMenu)
+	applicationMenuJSON, err := processedApplicationMenu.AsJSON()
+	if err != nil {
+		return err
+	}
+	m.applicationMenuJSON = applicationMenuJSON
+	return nil
+}

v2/internal/menumanager/contextmenu.go

@@ -0,0 +1,60 @@
+package menumanager
+
+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 NewContextMenu(contextMenu *menu.ContextMenu) *ContextMenu {
+
+	result := &ContextMenu{
+		ID:          contextMenu.ID,
+		menu:        contextMenu.Menu,
+		menuItemMap: NewMenuItemMap(),
+	}
+
+	result.menuItemMap.AddMenu(contextMenu.Menu)
+	result.ProcessedMenu = NewWailsMenu(result.menuItemMap, result.menu)
+
+	return result
+}
+
+func (m *Manager) AddContextMenu(contextMenu *menu.ContextMenu) {
+
+	newContextMenu := 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 := NewContextMenu(contextMenu)
+
+	// Save the reference
+	m.contextMenus[contextMenuID] = updatedContextMenu
+
+	return updatedContextMenu.AsJSON()
+}

v2/internal/menumanager/menuitemmap.go

@@ -0,0 +1,75 @@
+package menumanager
+
+import (
+	"fmt"
+	"github.com/wailsapp/wails/v2/pkg/menu"
+	"sync"
+)
+
+// MenuItemMap holds a mapping between menuIDs and menu items
+type MenuItemMap struct {
+	idToMenuItemMap map[string]*menu.MenuItem
+	menuItemToIDMap map[*menu.MenuItem]string
+
+	// We use a simple counter to keep track of unique menu IDs
+	menuIDCounter      int64
+	menuIDCounterMutex sync.Mutex
+}
+
+func NewMenuItemMap() *MenuItemMap {
+	result := &MenuItemMap{
+		idToMenuItemMap: make(map[string]*menu.MenuItem),
+		menuItemToIDMap: make(map[*menu.MenuItem]string),
+	}
+
+	return result
+}
+
+func (m *MenuItemMap) AddMenu(menu *menu.Menu) {
+	if menu == nil {
+		return
+	}
+	for _, item := range menu.Items {
+		m.processMenuItem(item)
+	}
+}
+
+func (m *MenuItemMap) Dump() {
+	println("idToMenuItemMap:")
+	for key, value := range m.idToMenuItemMap {
+		fmt.Printf("  %s\t%p\n", key, value)
+	}
+	println("\nmenuItemToIDMap")
+	for key, value := range m.menuItemToIDMap {
+		fmt.Printf("  %p\t%s\n", key, value)
+	}
+}
+
+// GenerateMenuID returns a unique string ID for a menu item
+func (m *MenuItemMap) generateMenuID() string {
+	m.menuIDCounterMutex.Lock()
+	result := fmt.Sprintf("%d", m.menuIDCounter)
+	m.menuIDCounter++
+	m.menuIDCounterMutex.Unlock()
+	return result
+}
+
+func (m *MenuItemMap) processMenuItem(item *menu.MenuItem) {
+
+	if item.SubMenu != nil {
+		for _, submenuitem := range item.SubMenu.Items {
+			m.processMenuItem(submenuitem)
+		}
+	}
+
+	// Create a unique ID for this menu item
+	menuID := m.generateMenuID()
+
+	// Store references
+	m.idToMenuItemMap[menuID] = item
+	m.menuItemToIDMap[item] = menuID
+}
+
+func (m *MenuItemMap) getMenuItemByID(menuId string) *menu.MenuItem {
+	return m.idToMenuItemMap[menuId]
+}

v2/internal/menumanager/menumanager.go

@@ -0,0 +1,90 @@
+package menumanager
+
+import (
+	"fmt"
+	"github.com/wailsapp/wails/v2/pkg/menu"
+)
+
+type Manager struct {
+
+	// The application menu.
+	applicationMenu     *menu.Menu
+	applicationMenuJSON string
+
+	// Our application menu mappings
+	applicationMenuItemMap *MenuItemMap
+
+	// Context menus
+	contextMenus        map[string]*ContextMenu
+	contextMenuPointers map[*menu.ContextMenu]string
+
+	// Tray menu stores
+	trayMenus        map[string]*TrayMenu
+	trayMenuPointers map[*menu.TrayMenu]string
+}
+
+func NewManager() *Manager {
+	return &Manager{
+		applicationMenuItemMap: NewMenuItemMap(),
+		contextMenus:           make(map[string]*ContextMenu),
+		contextMenuPointers:    make(map[*menu.ContextMenu]string),
+		trayMenus:              make(map[string]*TrayMenu),
+		trayMenuPointers:       make(map[*menu.TrayMenu]string),
+	}
+}
+
+func (m *Manager) getMenuItemByID(menuMap *MenuItemMap, menuId string) *menu.MenuItem {
+	return menuMap.idToMenuItemMap[menuId]
+}
+
+func (m *Manager) ProcessClick(menuID string, data string, menuType string, parentID string) error {
+
+	var menuItemMap *MenuItemMap
+
+	switch menuType {
+	case "ApplicationMenu":
+		menuItemMap = m.applicationMenuItemMap
+	case "ContextMenu":
+		contextMenu := m.contextMenus[parentID]
+		if contextMenu == nil {
+			return fmt.Errorf("unknown context menu: %s", parentID)
+		}
+		menuItemMap = contextMenu.menuItemMap
+	case "TrayMenu":
+		trayMenu := m.trayMenus[parentID]
+		if trayMenu == nil {
+			return fmt.Errorf("unknown tray menu: %s", parentID)
+		}
+		menuItemMap = trayMenu.menuItemMap
+	default:
+		return fmt.Errorf("unknown menutype: %s", menuType)
+	}
+
+	// Get the menu item
+	menuItem := menuItemMap.getMenuItemByID(menuID)
+	if menuItem == nil {
+		return fmt.Errorf("Cannot process menuid %s - unknown", menuID)
+	}
+
+	// Is the menu item a checkbox?
+	if menuItem.Type == menu.CheckboxType {
+		// Toggle state
+		menuItem.Checked = !menuItem.Checked
+	}
+
+	if menuItem.Click == nil {
+		// No callback
+		return fmt.Errorf("No callback for menu '%s'", menuItem.Label)
+	}
+
+	// Create new Callback struct
+	callbackData := &menu.CallbackData{
+		MenuItem:    menuItem,
+		ContextData: data,
+	}
+
+	// Call back!
+	go menuItem.Click(callbackData)
+
+	return nil
+}

v2/internal/menumanager/processedMenu.go

@@ -0,0 +1,169 @@
+package menumanager
+
+import (
+	"encoding/json"
+	"github.com/wailsapp/wails/v2/pkg/menu"
+	"github.com/wailsapp/wails/v2/pkg/menu/keys"
+)
+
+type ProcessedMenuItem struct {
+	ID string
+	// Label is what appears as the menu text
+	Label string `json:",omitempty"`
+	// Role is a predefined menu type
+	Role menu.Role `json:",omitempty"`
+	// Accelerator holds a representation of a key binding
+	Accelerator *keys.Accelerator `json:",omitempty"`
+	// Type of MenuItem, EG: Checkbox, Text, Separator, Radio, Submenu
+	Type menu.Type
+	// Disabled makes the item unselectable
+	Disabled bool `json:",omitempty"`
+	// Hidden ensures that the item is not shown in the menu
+	Hidden bool `json:",omitempty"`
+	// Checked indicates if the item is selected (used by Checkbox and Radio types only)
+	Checked bool `json:",omitempty"`
+	// Submenu contains a list of menu items that will be shown as a submenu
+	//SubMenu []*MenuItem `json:"SubMenu,omitempty"`
+	SubMenu *ProcessedMenu `json:",omitempty"`
+
+	// Colour
+	RGBA string `json:",omitempty"`
+
+	// Font
+	FontSize int    `json:",omitempty"`
+	FontName string `json:",omitempty"`
+
+	// Image - base64 image data
+	Image string `json:",omitempty"`
+
+	// Tooltip
+	Tooltip string `json:",omitempty"`
+}
+
+func NewProcessedMenuItem(menuItemMap *MenuItemMap, menuItem *menu.MenuItem) *ProcessedMenuItem {
+
+	ID := menuItemMap.menuItemToIDMap[menuItem]
+	result := &ProcessedMenuItem{
+		ID:          ID,
+		Label:       menuItem.Label,
+		Role:        menuItem.Role,
+		Accelerator: menuItem.Accelerator,
+		Type:        menuItem.Type,
+		Disabled:    menuItem.Disabled,
+		Hidden:      menuItem.Hidden,
+		Checked:     menuItem.Checked,
+		SubMenu:     nil,
+		RGBA:        menuItem.RGBA,
+		FontSize:    menuItem.FontSize,
+		FontName:    menuItem.FontName,
+		Image:       menuItem.Image,
+		Tooltip:     menuItem.Tooltip,
+	}
+
+	if menuItem.SubMenu != nil {
+		result.SubMenu = NewProcessedMenu(menuItemMap, menuItem.SubMenu)
+	}
+
+	return result
+}
+
+type ProcessedMenu struct {
+	Items []*ProcessedMenuItem
+}
+
+func NewProcessedMenu(menuItemMap *MenuItemMap, menu *menu.Menu) *ProcessedMenu {
+
+	result := &ProcessedMenu{}
+	if menu != nil {
+		for _, item := range menu.Items {
+			processedMenuItem := NewProcessedMenuItem(menuItemMap, item)
+			result.Items = append(result.Items, processedMenuItem)
+		}
+	}
+
+	return result
+}
+
+// WailsMenu is the original menu with the addition
+// of radio groups extracted from the menu data
+type WailsMenu struct {
+	Menu              *ProcessedMenu
+	RadioGroups       []*RadioGroup
+	currentRadioGroup []string
+}
+
+// RadioGroup holds all the members of the same radio group
+type RadioGroup struct {
+	Members []string
+	Length  int
+}
+
+func NewWailsMenu(menuItemMap *MenuItemMap, menu *menu.Menu) *WailsMenu {
+	result := &WailsMenu{}
+
+	// Process the menus
+	result.Menu = NewProcessedMenu(menuItemMap, 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) processRadioGroups() {
+	// Loop over top level menus
+	for _, item := range w.Menu.Items {
+		// Process MenuItem
+		w.processMenuItem(item)
+	}
+
+	w.finaliseRadioGroup()
+}
+
+func (w *WailsMenu) processMenuItem(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.Items {
+			w.processMenuItem(subitem)
+		}
+	case menu.RadioType:
+		// Add the item to the radio group
+		w.currentRadioGroup = append(w.currentRadioGroup, item.ID)
+	default:
+		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,134 @@
+package menumanager
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/pkg/errors"
+	"github.com/wailsapp/wails/v2/pkg/menu"
+	"sync"
+)
+
+var trayMenuID int
+var trayMenuIDMutex sync.Mutex
+
+func generateTrayID() string {
+	trayMenuIDMutex.Lock()
+	result := fmt.Sprintf("%d", trayMenuID)
+	trayMenuID++
+	trayMenuIDMutex.Unlock()
+	return result
+}
+
+type TrayMenu struct {
+	ID            string
+	Label         string
+	Icon          string
+	menuItemMap   *MenuItemMap
+	menu          *menu.Menu
+	ProcessedMenu *WailsMenu
+}
+
+func (t *TrayMenu) AsJSON() (string, error) {
+	data, err := json.Marshal(t)
+	if err != nil {
+		return "", err
+	}
+	return string(data), nil
+}
+
+func NewTrayMenu(trayMenu *menu.TrayMenu) *TrayMenu {
+
+	result := &TrayMenu{
+		Label:       trayMenu.Label,
+		Icon:        trayMenu.Icon,
+		menu:        trayMenu.Menu,
+		menuItemMap: NewMenuItemMap(),
+	}
+
+	result.menuItemMap.AddMenu(trayMenu.Menu)
+	result.ProcessedMenu = NewWailsMenu(result.menuItemMap, result.menu)
+
+	return result
+}
+
+func (m *Manager) AddTrayMenu(trayMenu *menu.TrayMenu) (string, error) {
+	newTrayMenu := NewTrayMenu(trayMenu)
+
+	// Hook up a new ID
+	trayID := generateTrayID()
+	newTrayMenu.ID = trayID
+
+	// Save the references
+	m.trayMenus[trayID] = newTrayMenu
+	m.trayMenuPointers[trayMenu] = trayID
+
+	return newTrayMenu.AsJSON()
+}
+
+// SetTrayMenu updates or creates a menu
+func (m *Manager) SetTrayMenu(trayMenu *menu.TrayMenu) (string, error) {
+	trayID, trayMenuKnown := m.trayMenuPointers[trayMenu]
+	if !trayMenuKnown {
+		return m.AddTrayMenu(trayMenu)
+	}
+
+	// Create the updated tray menu
+	updatedTrayMenu := NewTrayMenu(trayMenu)
+	updatedTrayMenu.ID = trayID
+
+	// Save the reference
+	m.trayMenus[trayID] = updatedTrayMenu
+
+	return updatedTrayMenu.AsJSON()
+}
+
+func (m *Manager) GetTrayMenus() ([]string, error) {
+	result := []string{}
+	for _, trayMenu := range m.trayMenus {
+		JSON, err := trayMenu.AsJSON()
+		if err != nil {
+			return nil, err
+		}
+		result = append(result, JSON)
+	}
+
+	return result, nil
+}
+
+func (m *Manager) UpdateTrayMenuLabel(trayMenu *menu.TrayMenu) (string, error) {
+	trayID, trayMenuKnown := m.trayMenuPointers[trayMenu]
+	if !trayMenuKnown {
+		return "", fmt.Errorf("[UpdateTrayMenuLabel] unknown tray id for tray %s", trayMenu.Label)
+	}
+
+	type LabelUpdate struct {
+		ID    string
+		Label string
+	}
+
+	update := &LabelUpdate{
+		ID:    trayID,
+		Label: trayMenu.Label,
+	}
+
+	data, err := json.Marshal(update)
+	if err != nil {
+		return "", errors.Wrap(err, "[UpdateTrayMenuLabel] ")
+	}
+
+	return string(data), nil
+
+}
+
+func (m *Manager) GetContextMenus() ([]string, error) {
+	result := []string{}
+	for _, contextMenu := range m.contextMenus {
+		JSON, err := contextMenu.AsJSON()
+		if err != nil {
+			return nil, err
+		}
+		result = append(result, JSON)
+	}
+
+	return result, nil
+}

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/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,70 @@ 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"`
+						MenuType   string `json:"menuType"`
+						Data       string `json:"data"`
+						ParentID   string `json:"parentID"`
+					}
+
+					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, callbackData.MenuType, callbackData.ParentID)
+					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 +155,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,19 @@ 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
+	// potentially try and see if the assets have changed but will
+	// this take as much time as a `-a` build?
+	commands.Add("-a")
+
 	var tags slicer.StringSlicer
 	tags.Add(options.OutputType)
 

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,11 +1,12 @@
 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
 	// Role is a predefined menu type
@@ -21,16 +22,30 @@ type MenuItem struct {
 	// Checked indicates if the item is selected (used by Checkbox and Radio types only)
 	Checked bool
 	// 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"`
 
-	// Foreground colour in hex RGBA format EG: 0xFF0000FF = #FF0000FF = red
-	Foreground int
+	// Callback function when menu clicked
+	Click Callback `json:"-"`
 
-	// Background colour
-	Background int
+	// Colour
+	RGBA string
+
+	// Font
+	FontSize int
+	FontName string
+
+	// Image - base64 image data
+	Image string
+
+	// Tooltip
+	Tooltip string
 
 	// 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 +63,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 +76,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 +176,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 +191,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 +199,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 +227,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/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,