[WIP]

runtime/js/.eslintrc

@@ -3,12 +3,12 @@
         "browser": true,
         "es6": true,
         "amd": true,
-        "node": true,
+        "node": true
     },
     "extends": "eslint:recommended",
     "parserOptions": {
         "ecmaVersion": 2016,
-        "sourceType": "module",
+        "sourceType": "module"
     },
     "rules": {
         "indent": [

runtime/js/core/browser.js

@@ -26,7 +26,7 @@ export function OpenURL(url) {
  * Opens the given filename using the system's default file handler
  *
  * @export
- * @param {sting} filename
+ * @param {string} filename
  * @returns
  */
 export function OpenFile(filename) {

runtime/js/core/calls.js

@@ -62,7 +62,7 @@ if (window.crypto) {
 export function Call(bindingName, data, timeout) {
 
 	// Timeout infinite by default
-	if (timeout == null || timeout == undefined) {
+	if (timeout == null) {
 		timeout = 0;
 	}
 

runtime/js/core/ipc.js

@@ -45,7 +45,7 @@ function Invoke(message) {
  *
  * @export
  * @param {string} type
- * @param {string} payload
+ * @param {Object} payload
  * @param {string=} callbackID
  */
 export function SendMessage(type, payload, callbackID) {

runtime/js/runtime/.npmignore

@@ -1 +1 @@
-bridge.js
+index.js

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

@@ -1,6 +1,7 @@
 package dev
 
 import (
+	"context"
 	"fmt"
 	"io"
 	"os"
@@ -10,13 +11,18 @@ import (
 	"syscall"
 	"time"
 
-	"github.com/fsnotify/fsnotify"
-	"github.com/leaanthony/clir"
-	"github.com/leaanthony/slicer"
-	"github.com/wailsapp/wails/v2/internal/fs"
-	"github.com/wailsapp/wails/v2/internal/process"
-	"github.com/wailsapp/wails/v2/pkg/clilogger"
 	"github.com/wailsapp/wails/v2/pkg/commands/build"
+
+	"github.com/wailsapp/wails/v2/internal/process"
+
+	"github.com/wzshiming/ctc"
+
+	"github.com/wailsapp/wails/v2/internal/fs"
+
+	"github.com/fsnotify/fsnotify"
+
+	"github.com/leaanthony/clir"
+	"github.com/wailsapp/wails/v2/pkg/clilogger"
 )
 
 // AddSubcommand adds the `dev` command for the Wails application
@@ -24,14 +30,6 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 
 	command := app.NewSubCommand("dev", "Development mode")
 
-	outputType := "desktop"
-
-	validTargetTypes := slicer.String([]string{"desktop", "hybrid", "server"})
-
-	// Setup target type flag
-	description := "Type of application to develop. Valid types: " + validTargetTypes.Join(",")
-	command.StringFlag("t", description, &outputType)
-
 	// Passthrough ldflags
 	ldflags := ""
 	command.StringFlag("ldflags", "optional ldflags", &ldflags)
@@ -42,227 +40,273 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 
 	// extensions to trigger rebuilds
 	extensions := "go"
-	command.StringFlag("m", "Extensions to trigger rebuilds (comma separated) eg go,js,css,html", &extensions)
+	command.StringFlag("e", "Extensions to trigger rebuilds (comma separated) eg go,js,css,html", &extensions)
 
 	command.Action(func() error {
 
-		// Validate inputs
-		if !validTargetTypes.Contains(outputType) {
-			return fmt.Errorf("output type '%s' is not valid", outputType)
-		}
-
 		// Create logger
 		logger := clilogger.New(w)
 		app.PrintBanner()
 
 		// TODO: Check you are in a project directory
-
-		watcher, err := fsnotify.NewWatcher()
-		if err != nil {
-			return err
-		}
-		defer watcher.Close()
-
-		var debugBinaryProcess *process.Process = nil
-		var buildFrontend bool = true
 		var extensionsThatTriggerARebuild = strings.Split(extensions, ",")
 
-		// Setup signal handler
-		quitChannel := make(chan os.Signal, 1)
-		signal.Notify(quitChannel, os.Interrupt, os.Kill, syscall.SIGTERM)
-
-		debounceQuit := make(chan bool, 1)
-
-		// Do initial build
-		logger.Println("Building application for development...")
-		debugBinaryProcess = restartApp(logger, outputType, ldflags, compilerCommand, buildFrontend, debugBinaryProcess)
-
-		go debounce(100*time.Millisecond, watcher.Events, debounceQuit, func(event fsnotify.Event) {
-			// logger.Println("event: %+v", event)
-
-			// Check for new directories
-			if event.Op&fsnotify.Create == fsnotify.Create {
-				// If this is a folder, add it to our watch list
-				if fs.DirExists(event.Name) {
-					if !strings.Contains(event.Name, "node_modules") {
-						err := watcher.Add(event.Name)
-						if err != nil {
-							logger.Fatal("%s", err.Error())
-						}
-						logger.Println("Watching directory: %s", event.Name)
-					}
-				}
-				return
-			}
-
-			// Check for file writes
-			if event.Op&fsnotify.Write == fsnotify.Write {
-
-				// logger.Println("modified file: %s", event.Name)
-				var rebuild bool = false
-
-				// Iterate all file patterns
-				for _, pattern := range extensionsThatTriggerARebuild {
-					rebuild = strings.HasSuffix(event.Name, pattern)
-					if err != nil {
-						logger.Fatal(err.Error())
-					}
-					if rebuild {
-						// Only build frontend when the file isn't a Go file
-						buildFrontend = !strings.HasSuffix(event.Name, "go")
-						break
-					}
-				}
-
-				if !rebuild {
-					logger.Println("Filename change: %s did not match extension list %s", event.Name, extensions)
-					return
-				}
-
-				if buildFrontend {
-					logger.Println("Full rebuild triggered: %s updated", event.Name)
-				} else {
-					logger.Println("Partial build triggered: %s updated", event.Name)
-				}
-
-				// Do a rebuild
-
-				// Try and build the app
-				newBinaryProcess := restartApp(logger, outputType, ldflags, compilerCommand, buildFrontend, debugBinaryProcess)
-
-				// If we have a new process, save it
-				if newBinaryProcess != nil {
-					debugBinaryProcess = newBinaryProcess
-				}
-
-			}
-		})
-
-		// Get project dir
-		dir, err := os.Getwd()
+		reloader, err := NewReloader(logger, extensionsThatTriggerARebuild, ldflags, compilerCommand)
 		if err != nil {
 			return err
 		}
 
-		// Get all subdirectories
-		dirs, err := fs.GetSubdirectories(dir)
+		// Start
+		err = reloader.Start()
 		if err != nil {
-			return err
+			println("ERRRRRRRRRR: %+v", err)
 		}
 
-		// Setup a watcher for non-node_modules directories
-		dirs.Each(func(dir string) {
-			if strings.Contains(dir, "node_modules") {
-				return
-			}
-			logger.Println("Watching directory: %s", dir)
-			err = watcher.Add(dir)
-			if err != nil {
-				logger.Fatal(err.Error())
-			}
-		})
+		logger.Println("\nDevelopment mode exited")
 
-		// Wait until we get a quit signal
-		quit := false
-		for quit == false {
-			select {
-			case <-quitChannel:
-				println()
-				// Notify debouncer to quit
-				debounceQuit <- true
-				quit = true
-			}
-		}
-
-		// Kill the current program if running
-		if debugBinaryProcess != nil {
-			err := debugBinaryProcess.Kill()
-			if err != nil {
-				return err
-			}
-		}
-
-		logger.Println("Development mode exited")
-
-		return nil
+		return err
 	})
 
 	return nil
 }
 
-// Credit: https://drailing.net/2018/01/debounce-function-for-golang/
-func debounce(interval time.Duration, input chan fsnotify.Event, quitChannel chan bool, cb func(arg fsnotify.Event)) {
-	var item fsnotify.Event
-	timer := time.NewTimer(interval)
-exit:
+type Reloader struct {
+
+	// Main context
+	ctx context.Context
+
+	// Signal context
+	signalContext context.Context
+
+	// notify
+	watcher *fsnotify.Watcher
+
+	// Logger
+	logger *clilogger.CLILogger
+
+	// Extensions to listen for
+	extensionsThatTriggerARebuild []string
+
+	// The binary we are running
+	binary *process.Process
+
+	// options
+	ldflags  string
+	compiler string
+}
+
+func NewReloader(logger *clilogger.CLILogger, extensionsThatTriggerARebuild []string, ldFlags string, compiler string) (*Reloader, error) {
+	var result Reloader
+
+	// Create context
+	result.ctx = context.Background()
+
+	// Signal context (we don't need cancel)
+	signalContext, _ := signal.NotifyContext(result.ctx, os.Interrupt, os.Kill, syscall.SIGTERM)
+	result.signalContext = signalContext
+
+	// Create watcher
+	watcher, err := fsnotify.NewWatcher()
+	if err != nil {
+		return nil, err
+	}
+	result.watcher = watcher
+
+	// Logger
+	result.logger = logger
+
+	// Extensions
+	result.extensionsThatTriggerARebuild = extensionsThatTriggerARebuild
+
+	// Options
+	result.ldflags = ldFlags
+	result.compiler = compiler
+
+	return &result, nil
+}
+
+func (r *Reloader) Start() error {
+
+	err := r.rebuildBinary()
+	if err != nil {
+		return err
+	}
+
+	// Get project dir
+	dir, err := os.Getwd()
+	if err != nil {
+		return err
+	}
+
+	// Get all subdirectories
+	dirs, err := fs.GetSubdirectories(dir)
+	if err != nil {
+		return err
+	}
+
+	// Setup a watcher for non-node_modules directories
+	r.logger.Println("Watching (sub)directories: %s", dir)
+
+	dirs.Each(func(dir string) {
+		if strings.Contains(dir, "node_modules") {
+			return
+		}
+		err = r.watcher.Add(dir)
+		if err != nil {
+			r.logger.Fatal(err.Error())
+		}
+	})
+
+	// Main loop
 	for {
 		select {
-		case item = <-input:
-			timer.Reset(interval)
-		case <-timer.C:
-			if item.Name != "" {
-				cb(item)
+		case <-r.signalContext.Done():
+			if r.binary != nil {
+				println("Binary is not nil - kill")
+				return r.binary.Kill()
+			}
+			return nil
+		case event := <-r.watcher.Events:
+			err := r.processWatcherEvent(event)
+			if err != nil {
+				println("error from processWatcherEvent. Calling cancel()")
+				println("Calling kill")
+				return r.binary.Kill()
 			}
-		case <-quitChannel:
-			break exit
 		}
 	}
 }
 
-func restartApp(logger *clilogger.CLILogger, outputType string, ldflags string, compilerCommand string, buildFrontend bool, debugBinaryProcess *process.Process) *process.Process {
+func (r *Reloader) processWatcherEvent(event fsnotify.Event) error {
 
-	appBinary, err := buildApp(logger, outputType, ldflags, compilerCommand, buildFrontend)
-	println()
-	if err != nil {
-		logger.Println("[ERROR] Build Failed: %s", err.Error())
+	// Check for new directories
+	if event.Op&fsnotify.Create == fsnotify.Create {
+		// If this is a folder, add it to our watch list
+		if fs.DirExists(event.Name) {
+			if !strings.Contains(event.Name, "node_modules") {
+				err := r.watcher.Add(event.Name)
+				if err != nil {
+					return err
+				}
+				r.logger.Println("Watching directory: %s", event.Name)
+			}
+		}
 		return nil
 	}
-	logger.Println("Build new binary: %s", appBinary)
 
-	// Kill existing binary if need be
-	if debugBinaryProcess != nil {
-		killError := debugBinaryProcess.Kill()
+	// Check for file writes
+	if event.Op&fsnotify.Write == fsnotify.Write {
 
-		if killError != nil {
-			logger.Fatal("Unable to kill debug binary (PID: %d)!", debugBinaryProcess.PID())
+		var rebuild bool
+
+		// Iterate all file patterns
+		for _, pattern := range r.extensionsThatTriggerARebuild {
+			if strings.HasSuffix(event.Name, pattern) {
+				rebuild = true
+			}
 		}
 
-		debugBinaryProcess = nil
-	}
-
-	// TODO: Generate `backend.js`
-
-	// Start up new binary
-	newProcess := process.NewProcess(logger, appBinary)
-	err = newProcess.Start()
-	if err != nil {
-		// Remove binary
-		deleteError := fs.DeleteFile(appBinary)
-		if deleteError != nil {
-			logger.Fatal("Unable to delete app binary: " + appBinary)
+		if !rebuild {
+			return nil
 		}
-		logger.Fatal("Unable to start application: %s", err.Error())
-	}
 
-	return newProcess
+		r.logger.Println("\n%s[Build triggered] %s %s", ctc.ForegroundGreen|ctc.ForegroundBright, event.Name, ctc.Reset)
+
+		return r.rebuildBinary()
+	}
+	return nil
 }
 
-func buildApp(logger *clilogger.CLILogger, outputType string, ldflags string, compilerCommand string, buildFrontend bool) (string, error) {
+func (r *Reloader) rebuildBinary() error {
+
+	// rebuild binary
+	binary, err := r.buildApp()
+	if err != nil {
+		return err
+	}
+
+	// Kill current binary if running
+	if r.binary != nil {
+		err = r.binary.Kill()
+		if err != nil {
+			return err
+		}
+	}
+
+	newProcess := process.NewProcess(r.ctx, r.logger, binary)
+	err = newProcess.Start()
+	if err != nil {
+		return err
+	}
+
+	// Ensure process runs correctly
+
+	return nil
+}
+
+//func restartApp(logger *clilogger.CLILogger, outputType string, ldflags string, compilerCommand string, debugBinaryProcess *process.Process) (*process.Process, error) {
+//
+//	appBinary, err := buildApp(logger, outputType, ldflags, compilerCommand)
+//	println()
+//	if err != nil {
+//		logger.Fatal(err.Error())
+//		return nil, errors.Wrap(err, "Build Failed:")
+//	}
+//	logger.Println("Build new binary: %s", appBinary)
+//
+//	// Kill existing binary if need be
+//	if debugBinaryProcess != nil {
+//		killError := debugBinaryProcess.Kill()
+//
+//		if killError != nil {
+//			logger.Fatal("Unable to kill debug binary (PID: %d)!", debugBinaryProcess.PID())
+//		}
+//
+//		debugBinaryProcess = nil
+//	}
+//
+//	// TODO: Generate `backend.js`
+//
+//	// Start up new binary
+//	newProcess := process.NewProcess(logger, appBinary)
+//	err = newProcess.Start()
+//	if err != nil {
+//		// Remove binary
+//		deleteError := fs.DeleteFile(appBinary)
+//		if deleteError != nil {
+//			logger.Fatal("Unable to delete app binary: " + appBinary)
+//		}
+//		logger.Fatal("Unable to start application: %s", err.Error())
+//	}
+//
+//	// Check if port is open
+//	timeout := time.Second
+//	conn, err := net.DialTimeout("tcp", net.JoinHostPort("host", port), timeout)
+//	if err != nil {
+//		return
+//	}
+//	newProcess.Running
+//	return newProcess, nil
+//}
+
+// buildapp attempts to compile the application
+// It returns the path to the new binary or an error
+func (r *Reloader) buildApp() (string, error) {
 
 	// Create random output file
 	outputFile := fmt.Sprintf("debug-%d", time.Now().Unix())
 
 	// Create BuildOptions
 	buildOptions := &build.Options{
-		Logger:         logger,
-		OutputType:     outputType,
+		Logger:         r.logger,
+		OutputType:     "dev",
 		Mode:           build.Debug,
 		Pack:           false,
 		Platform:       runtime.GOOS,
-		LDFlags:        ldflags,
-		Compiler:       compilerCommand,
+		LDFlags:        r.ldflags,
+		Compiler:       r.compiler,
 		OutputFile:     outputFile,
-		IgnoreFrontend: !buildFrontend,
+		IgnoreFrontend: true,
 	}
 
 	return build.Build(buildOptions)

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

@@ -0,0 +1,164 @@
+package update
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"os"
+
+	"github.com/wailsapp/wails/v2/internal/shell"
+
+	"github.com/wailsapp/wails/v2/internal/github"
+
+	"github.com/leaanthony/clir"
+	"github.com/wailsapp/wails/v2/pkg/clilogger"
+)
+
+// AddSubcommand adds the `init` command for the Wails application
+func AddSubcommand(app *clir.Cli, w io.Writer, currentVersion string) error {
+
+	command := app.NewSubCommand("update", "Update the Wails CLI")
+	command.LongDescription(`This command allows you to update your version of Wails.`)
+
+	// Setup flags
+	var prereleaseRequired bool
+	command.BoolFlag("pre", "Update to latest Prerelease", &prereleaseRequired)
+
+	var specificVersion string
+	command.StringFlag("version", "Install a specific version (Overrides other flags)", &specificVersion)
+
+	command.Action(func() error {
+
+		// Create logger
+		logger := clilogger.New(w)
+
+		// Print banner
+		app.PrintBanner()
+		logger.Println("Checking for updates...")
+
+		var desiredVersion *github.SemanticVersion
+		var err error
+		var valid bool
+
+		if len(specificVersion) > 0 {
+			// Check if this is a valid version
+			valid, err = github.IsValidTag(specificVersion)
+			if err == nil {
+				if !valid {
+					err = fmt.Errorf("version '%s' is invalid", specificVersion)
+				} else {
+					desiredVersion, err = github.NewSemanticVersion(specificVersion)
+				}
+			}
+		} else {
+			if prereleaseRequired {
+				desiredVersion, err = github.GetLatestPreRelease()
+			} else {
+				desiredVersion, err = github.GetLatestStableRelease()
+			}
+		}
+		if err != nil {
+			return err
+		}
+		fmt.Println()
+
+		fmt.Println("    Current Version : " + currentVersion)
+
+		if len(specificVersion) > 0 {
+			fmt.Printf("    Desired Version : v%s\n", desiredVersion)
+		} else {
+			if prereleaseRequired {
+				fmt.Printf("  Latest Prerelease : v%s\n", desiredVersion)
+			} else {
+				fmt.Printf("     Latest Release : v%s\n", desiredVersion)
+			}
+		}
+
+		return updateToVersion(logger, desiredVersion, len(specificVersion) > 0, currentVersion)
+	})
+
+	return nil
+}
+
+func updateToVersion(logger *clilogger.CLILogger, targetVersion *github.SemanticVersion, force bool, currentVersion string) error {
+
+	var targetVersionString = "v" + targetVersion.String()
+
+	// Early exit
+	if targetVersionString == currentVersion {
+		logger.Println("Looks like you're up to date!")
+		return nil
+	}
+
+	var desiredVersion string
+
+	if !force {
+
+		compareVersion := currentVersion
+
+		currentVersion, err := github.NewSemanticVersion(compareVersion)
+		if err != nil {
+			return err
+		}
+
+		var success bool
+
+		// Release -> Pre-Release = Massage current version to prerelease format
+		if targetVersion.IsPreRelease() && currentVersion.IsRelease() {
+			testVersion, err := github.NewSemanticVersion(compareVersion + "-0")
+			if err != nil {
+				return err
+			}
+			success, _ = targetVersion.IsGreaterThan(testVersion)
+		}
+		// Pre-Release -> Release = Massage target version to prerelease format
+		if targetVersion.IsRelease() && currentVersion.IsPreRelease() {
+			// We are ok with greater than or equal
+			mainversion := currentVersion.MainVersion()
+			targetVersion, err = github.NewSemanticVersion(targetVersion.String())
+			if err != nil {
+				return err
+			}
+			success, _ = targetVersion.IsGreaterThanOrEqual(mainversion)
+		}
+
+		// Release -> Release = Standard check
+		if (targetVersion.IsRelease() && currentVersion.IsRelease()) ||
+			(targetVersion.IsPreRelease() && currentVersion.IsPreRelease()) {
+
+			success, _ = targetVersion.IsGreaterThan(currentVersion)
+		}
+
+		// Compare
+		if !success {
+			logger.Println("Error: The requested version is lower than the current version.")
+			logger.Println("If this is what you really want to do, use `wails update -version %s`", targetVersionString)
+			return nil
+		}
+
+		desiredVersion = "v" + targetVersion.String()
+
+	} else {
+		desiredVersion = "v" + targetVersion.String()
+	}
+
+	fmt.Println()
+	logger.Print("Installing Wails " + desiredVersion + "...")
+
+	// Run command in non module directory
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		log.Fatal("Cannot find home directory! Please file a bug report!")
+	}
+
+	sout, serr, err := shell.RunCommand(homeDir, "go", "get", "github.com/wailsapp/wails/v2/cmd/wails@"+desiredVersion)
+	if err != nil {
+		logger.Println("Failed.")
+		logger.Println(sout + `\n` + serr)
+		return err
+	}
+	fmt.Println()
+	logger.Println("Wails updated to " + desiredVersion)
+
+	return nil
+}

v2/cmd/wails/main.go

@@ -1,8 +1,13 @@
 package main
 
 import (
+	"fmt"
 	"os"
 
+	"github.com/wzshiming/ctc"
+
+	"github.com/wailsapp/wails/v2/cmd/wails/internal/commands/update"
+
 	"github.com/leaanthony/clir"
 	"github.com/wailsapp/wails/v2/cmd/wails/internal/commands/build"
 	"github.com/wailsapp/wails/v2/cmd/wails/internal/commands/debug"
@@ -17,12 +22,30 @@ func fatal(message string) {
 	os.Exit(1)
 }
 
+func col(colour ctc.Color, text string) string {
+	return fmt.Sprintf("%s%s%s", colour, text, ctc.Reset)
+}
+
+func Yellow(str string) string {
+	return col(ctc.ForegroundBrightYellow, str)
+}
+
+func Red(str string) string {
+	return col(ctc.ForegroundBrightRed, str)
+}
+
+func banner(cli *clir.Cli) string {
+	return fmt.Sprintf("%s %s - Go/HTML Application Framework", Yellow("Wails"), Red(version))
+}
+
 func main() {
 
 	var err error
 
 	app := clir.NewCli("Wails", "Go/HTML Application Framework", version)
 
+	app.SetBannerFunction(banner)
+
 	build.AddBuildSubcommand(app, os.Stdout)
 	err = initialise.AddSubcommand(app, os.Stdout)
 	if err != nil {
@@ -48,6 +71,11 @@ func main() {
 		fatal(err.Error())
 	}
 
+	err = update.AddSubcommand(app, os.Stdout, version)
+	if err != nil {
+		fatal(err.Error())
+	}
+
 	err = app.Run()
 	if err != nil {
 		println("\n\nERROR: " + err.Error())

v2/cmd/wails/version.go

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

v2/go.mod

@@ -1,11 +1,13 @@
 module github.com/wailsapp/wails/v2
 
-go 1.15
+go 1.16
 
 require (
+	github.com/Masterminds/semver v1.5.0
 	github.com/davecgh/go-spew v1.1.1
 	github.com/fatih/structtag v1.2.0
 	github.com/fsnotify/fsnotify v1.4.9
+	github.com/gorilla/websocket v1.4.1
 	github.com/imdario/mergo v0.3.11
 	github.com/jackmordaunt/icns v1.0.0
 	github.com/leaanthony/clir v1.0.4
@@ -13,16 +15,16 @@ require (
 	github.com/leaanthony/slicer v1.5.0
 	github.com/matryer/is v1.4.0
 	github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 // indirect
-	github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect
 	github.com/olekukonko/tablewriter v0.0.4
 	github.com/pkg/errors v0.9.1
 	github.com/tdewolff/minify v2.3.6+incompatible
 	github.com/tdewolff/parse v2.3.4+incompatible // indirect
 	github.com/tdewolff/test v1.0.6 // indirect
+	github.com/wzshiming/ctc v1.2.3 // indirect
 	github.com/xyproto/xpm v1.2.1
 	golang.org/x/net v0.0.0-20200822124328-c89045814202
+	golang.org/x/sync v0.0.0-20201207232520-09787c993a3a
 	golang.org/x/sys v0.0.0-20200724161237-0e2f3a69832c
 	golang.org/x/tools v0.0.0-20200902012652-d1954cc86c82
-	gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b // indirect
 	nhooyr.io/websocket v1.8.6
 )

v2/go.sum

@@ -1,3 +1,5 @@
+github.com/Masterminds/semver v1.5.0 h1:H65muMkzWKEuNDnfl9d70GUjFniHKHRbFPGBuZ3QEww=
+github.com/Masterminds/semver v1.5.0/go.mod h1:MB6lktGJrhw8PrUyiEoblNEGEQ+RzHPF078ddwwvV3Y=
 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=
@@ -9,7 +11,6 @@ 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/locales v0.13.0 h1:HyWk6mgj5qFqCT5fjGBuRArbVDfE4hi8+e8ceBS/t7Q=
 github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8=
@@ -39,9 +40,6 @@ github.com/json-iterator/go v1.1.9 h1:9yzud/Ht36ygwatGx56VwCZtlI/2AD15T1X2sjSuGn
 github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
 github.com/klauspost/compress v1.10.3 h1:OP96hzwJVBIHYU52pVTI6CczrxPvrGfgqF9N5eTO0Q8=
 github.com/klauspost/compress v1.10.3/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
-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 h1:v4hepo4IyL8E8c9qzDsvYcA0KGh7Npf8As74K5ibQpI=
@@ -62,17 +60,13 @@ github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742 h1:Esafd1046DLD
 github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 h1:zYyBkD/k9seD2A7fsi6Oo2LfFZAehjjQMERAvZLEDnQ=
 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 h1:vHD/YYe1Wolo78koG299f7V/VAS08c6IpCLn+Ejf/w8=
 github.com/olekukonko/tablewriter v0.0.4/go.mod h1:zq6QwlOf5SlnkVbMSr5EoBv3636FWnp+qbPhuoO21uA=
 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/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 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/tdewolff/minify v2.3.6+incompatible h1:2hw5/9ZvxhWLvBUnHE06gElGYz+Jv9R4Eys0XUzItYo=
 github.com/tdewolff/minify v2.3.6+incompatible/go.mod h1:9Ov578KJUmAWpS6NeZwRZyT56Uf6o3Mcz9CEsg8USYs=
@@ -84,6 +78,10 @@ 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/wzshiming/ctc v1.2.3 h1:q+hW3IQNsjIlOFBTGZZZeIXTElFM4grF4spW/errh/c=
+github.com/wzshiming/ctc v1.2.3/go.mod h1:2tVAtIY7SUyraSk0JxvwmONNPFL4ARavPuEsg5+KA28=
+github.com/wzshiming/winseq v0.0.0-20200112104235-db357dc107ae h1:tpXvBXC3hpQBDCc9OojJZCQMVRAbT3TTdUMP8WguXkY=
+github.com/wzshiming/winseq v0.0.0-20200112104235-db357dc107ae/go.mod h1:VTAq37rkGeV+WOybvZwjXiJOicICdpLCN8ifpISjK20=
 github.com/xyproto/xpm v1.2.1 h1:trdvGjjWBsOOKzBBUPT6JvaIQM3acJEEYfbxN7M96wg=
 github.com/xyproto/xpm v1.2.1/go.mod h1:cMnesLsD0PBXLgjDfTDEaKr8XyTFsnP1QycSqRw7BiY=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
@@ -98,35 +96,30 @@ golang.org/x/net v0.0.0-20200822124328-c89045814202 h1:VvcQYSHwXgi7W+TpUR6A9g6Up
 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/sync v0.0.0-20201207232520-09787c993a3a h1:DcqTD9SDLc+1P/r1EmRBwnVsrOwW+kk2vWf9n+1sGhs=
+golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/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 h1:L2auWcuQIvxz9xSEqzESnV/QN/gNRXNApHi3fYwl2w0=
 golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200107162124-548cf772de50/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd h1:xhmwyvizuTgC2qz7ZlMluP20uW+C3Rm0FD/WLDX8884=
 golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200724161237-0e2f3a69832c h1:UIcGWL6/wpCfyGuJnRFJRurA+yj8RrW7Q6x2YMCXt6c=
 golang.org/x/sys v0.0.0-20200724161237-0e2f3a69832c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e h1:FDhOuMEY4JVRztM/gsbk+IKUQ8kj74bxZrgw87eMMVc=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20200902012652-d1954cc86c82 h1:shxDsb9Dz27xzk3A0DxP0JuJnZMpKrdg8+E14eiUAX4=
 golang.org/x/tools v0.0.0-20200902012652-d1954cc86c82/go.mod h1:Cj7w3i3Rnn0Xh82ur9kSqwfTHTeVxaDqrfMjpcNT6bE=
 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 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
 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/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 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
 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=

v2/internal/app/debug.go

@@ -2,11 +2,40 @@
 
 package app
 
+import (
+	"flag"
+	"strings"
+
+	"github.com/wailsapp/wails/v2/pkg/logger"
+)
+
 // Init initialises the application for a debug environment
 func (a *App) Init() error {
 	// Indicate debug mode
 	a.debug = true
-	// Enable dev tools
-	a.options.DevTools = true
+
+	if a.appType == "desktop" {
+		// Enable dev tools
+		a.options.DevTools = true
+	}
+
+	// Set log levels
+	greeting := flag.String("loglevel", "debug", "Loglevel to use - Trace, Debug, Info, Warning, Error")
+	flag.Parse()
+	if len(*greeting) > 0 {
+		switch strings.ToLower(*greeting) {
+		case "trace":
+			a.logger.SetLogLevel(logger.TRACE)
+		case "info":
+			a.logger.SetLogLevel(logger.INFO)
+		case "warning":
+			a.logger.SetLogLevel(logger.WARNING)
+		case "error":
+			a.logger.SetLogLevel(logger.ERROR)
+		default:
+			a.logger.SetLogLevel(logger.DEBUG)
+		}
+	}
+
 	return nil
 }

v2/internal/app/default.go

@@ -1,4 +1,4 @@
-// +build !desktop,!hybrid,!server
+// +build !desktop,!hybrid,!server,!dev
 
 package app
 
@@ -8,9 +8,10 @@ package app
 // will be unknown and the application will not work as expected.
 
 import (
-	"github.com/wailsapp/wails/v2/internal/logger"
 	"os"
 
+	"github.com/wailsapp/wails/v2/internal/logger"
+
 	"github.com/wailsapp/wails/v2/pkg/options"
 )
 
@@ -38,7 +39,3 @@ func (a *App) Run() error {
 	os.Exit(1)
 	return nil
 }
-
-// Bind the dummy interface
-func (a *App) Bind(_ interface{}) {
-}

v2/internal/app/desktop.go

@@ -3,6 +3,9 @@
 package app
 
 import (
+	"context"
+	"sync"
+
 	"github.com/wailsapp/wails/v2/internal/binding"
 	"github.com/wailsapp/wails/v2/internal/ffenestri"
 	"github.com/wailsapp/wails/v2/internal/logger"
@@ -17,6 +20,8 @@ import (
 
 // App defines a Wails application structure
 type App struct {
+	appType string
+
 	window     *ffenestri.Application
 	servicebus *servicebus.ServiceBus
 	logger     *logger.Logger
@@ -24,10 +29,10 @@ type App struct {
 	options    *options.App
 
 	// Subsystems
-	log        *subsystem.Log
-	runtime    *subsystem.Runtime
-	event      *subsystem.Event
-	binding    *subsystem.Binding
+	log     *subsystem.Log
+	runtime *subsystem.Runtime
+	event   *subsystem.Event
+	//binding    *subsystem.Binding
 	call       *subsystem.Call
 	menu       *subsystem.Menu
 	dispatcher *messagedispatcher.Dispatcher
@@ -79,11 +84,15 @@ func CreateApp(appoptions *options.App) (*App, error) {
 
 	window := ffenestri.NewApplicationWithConfig(appoptions, myLogger, menuManager)
 
+	// Create binding exemptions - Ugly hack. There must be a better way
+	bindingExemptions := []interface{}{appoptions.Startup, appoptions.Shutdown}
+
 	result := &App{
+		appType:          "desktop",
 		window:           window,
 		servicebus:       servicebus.New(myLogger),
 		logger:           myLogger,
-		bindings:         binding.NewBindings(myLogger),
+		bindings:         binding.NewBindings(myLogger, appoptions.Bind, bindingExemptions),
 		menuManager:      menuManager,
 		startupCallback:  appoptions.Startup,
 		shutdownCallback: appoptions.Shutdown,
@@ -103,8 +112,13 @@ func (a *App) Run() error {
 
 	var err error
 
+	// Setup a context
+	var subsystemWaitGroup sync.WaitGroup
+	parentContext := context.WithValue(context.Background(), "waitgroup", &subsystemWaitGroup)
+	ctx, cancel := context.WithCancel(parentContext)
+
 	// Setup signal handler
-	signalsubsystem, err := signal.NewManager(a.servicebus, a.logger)
+	signalsubsystem, err := signal.NewManager(ctx, cancel, a.servicebus, a.logger, a.shutdownCallback)
 	if err != nil {
 		return err
 	}
@@ -118,7 +132,7 @@ func (a *App) Run() error {
 		return err
 	}
 
-	runtimesubsystem, err := subsystem.NewRuntime(a.servicebus, a.logger, a.startupCallback, a.shutdownCallback)
+	runtimesubsystem, err := subsystem.NewRuntime(ctx, a.servicebus, a.logger, a.startupCallback, a.shutdownCallback)
 	if err != nil {
 		return err
 	}
@@ -132,17 +146,6 @@ func (a *App) Run() error {
 	a.loglevelStore = a.runtime.GoRuntime().Store.New("wails:loglevel", a.options.LogLevel)
 	a.appconfigStore = a.runtime.GoRuntime().Store.New("wails:appconfig", a.options)
 
-	// Start the binding subsystem
-	bindingsubsystem, err := subsystem.NewBinding(a.servicebus, a.logger, a.bindings, a.runtime.GoRuntime())
-	if err != nil {
-		return err
-	}
-	a.binding = bindingsubsystem
-	err = a.binding.Start()
-	if err != nil {
-		return err
-	}
-
 	// Start the logging subsystem
 	log, err := subsystem.NewLog(a.servicebus, a.logger, a.loglevelStore)
 	if err != nil {
@@ -166,18 +169,18 @@ func (a *App) Run() error {
 	}
 
 	// Start the eventing subsystem
-	event, err := subsystem.NewEvent(a.servicebus, a.logger)
+	eventsubsystem, err := subsystem.NewEvent(ctx, a.servicebus, a.logger)
 	if err != nil {
 		return err
 	}
-	a.event = event
+	a.event = eventsubsystem
 	err = a.event.Start()
 	if err != nil {
 		return err
 	}
 
 	// Start the menu subsystem
-	menusubsystem, err := subsystem.NewMenu(a.servicebus, a.logger, a.menuManager)
+	menusubsystem, err := subsystem.NewMenu(ctx, a.servicebus, a.logger, a.menuManager)
 	if err != nil {
 		return err
 	}
@@ -188,11 +191,11 @@ func (a *App) Run() error {
 	}
 
 	// Start the call subsystem
-	call, err := subsystem.NewCall(a.servicebus, a.logger, a.bindings.DB(), a.runtime.GoRuntime())
+	callSubsystem, err := subsystem.NewCall(ctx, a.servicebus, a.logger, a.bindings.DB(), a.runtime.GoRuntime())
 	if err != nil {
 		return err
 	}
-	a.call = call
+	a.call = callSubsystem
 	err = a.call.Start()
 	if err != nil {
 		return err
@@ -204,23 +207,29 @@ func (a *App) Run() error {
 		return err
 	}
 
-	result := a.window.Run(dispatcher, bindingDump, a.debug)
+	err = a.window.Run(dispatcher, bindingDump, a.debug)
 	a.logger.Trace("Ffenestri.Run() exited")
+	if err != nil {
+		return err
+	}
+
+	// Close down all the subsystems
+	a.logger.Trace("Cancelling subsystems")
+	cancel()
+	subsystemWaitGroup.Wait()
+
+	a.logger.Trace("Cancelling dispatcher")
+	dispatcher.Close()
+
+	// Close log
+	a.logger.Trace("Stopping log")
+	log.Close()
+
+	a.logger.Trace("Stopping Service bus")
 	err = a.servicebus.Stop()
 	if err != nil {
 		return err
 	}
 
-	return result
-}
-
-// Bind a struct to the application by passing in
-// a pointer to it
-func (a *App) Bind(structPtr interface{}) {
-
-	// Add the struct to the bindings
-	err := a.bindings.Add(structPtr)
-	if err != nil {
-		a.logger.Fatal("Error during binding: " + err.Error())
-	}
+	return nil
 }

v2/internal/app/dev.go

@@ -0,0 +1,241 @@
+// +build dev
+
+package app
+
+import (
+	"context"
+	"sync"
+
+	"github.com/wailsapp/wails/v2/internal/bridge"
+	"github.com/wailsapp/wails/v2/internal/menumanager"
+
+	"github.com/wailsapp/wails/v2/pkg/options"
+
+	"github.com/wailsapp/wails/v2/internal/binding"
+	"github.com/wailsapp/wails/v2/internal/logger"
+	"github.com/wailsapp/wails/v2/internal/messagedispatcher"
+	"github.com/wailsapp/wails/v2/internal/runtime"
+	"github.com/wailsapp/wails/v2/internal/servicebus"
+	"github.com/wailsapp/wails/v2/internal/signal"
+	"github.com/wailsapp/wails/v2/internal/subsystem"
+)
+
+// App defines a Wails application structure
+type App struct {
+	appType string
+
+	servicebus *servicebus.ServiceBus
+	logger     *logger.Logger
+	signal     *signal.Manager
+	options    *options.App
+
+	// Subsystems
+	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
+
+	// This is our binding DB
+	bindings *binding.Bindings
+
+	// Application Stores
+	loglevelStore  *runtime.Store
+	appconfigStore *runtime.Store
+
+	// Startup/Shutdown
+	startupCallback  func(*runtime.Runtime)
+	shutdownCallback func()
+
+	// Bridge
+	bridge *bridge.Bridge
+}
+
+// Create App
+func CreateApp(appoptions *options.App) (*App, error) {
+
+	// Merge default options
+	options.MergeDefaults(appoptions)
+
+	// Set up logger
+	myLogger := logger.New(appoptions.Logger)
+	myLogger.SetLogLevel(appoptions.LogLevel)
+
+	// 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)
+	}
+
+	// Create binding exemptions - Ugly hack. There must be a better way
+	bindingExemptions := []interface{}{appoptions.Startup, appoptions.Shutdown}
+
+	result := &App{
+		appType:          "dev",
+		bindings:         binding.NewBindings(myLogger, appoptions.Bind, bindingExemptions),
+		logger:           myLogger,
+		servicebus:       servicebus.New(myLogger),
+		startupCallback:  appoptions.Startup,
+		shutdownCallback: appoptions.Shutdown,
+		bridge:           bridge.NewBridge(myLogger),
+		menuManager:      menuManager,
+	}
+
+	result.options = appoptions
+
+	// Initialise the app
+	err := result.Init()
+
+	return result, err
+
+}
+
+// Run the application
+func (a *App) Run() error {
+
+	var err error
+
+	// Setup a context
+	var subsystemWaitGroup sync.WaitGroup
+	parentContext := context.WithValue(context.Background(), "waitgroup", &subsystemWaitGroup)
+	ctx, cancel := context.WithCancel(parentContext)
+
+	// Setup signal handler
+	signalsubsystem, err := signal.NewManager(ctx, cancel, a.servicebus, a.logger, a.shutdownCallback)
+	if err != nil {
+		return err
+	}
+	a.signal = signalsubsystem
+	a.signal.Start()
+
+	// Start the service bus
+	a.servicebus.Debug()
+	err = a.servicebus.Start()
+	if err != nil {
+		return err
+	}
+
+	runtimesubsystem, err := subsystem.NewRuntime(ctx, a.servicebus, a.logger, a.startupCallback, a.shutdownCallback)
+	if err != nil {
+		return err
+	}
+	a.runtime = runtimesubsystem
+	err = a.runtime.Start()
+	if err != nil {
+		return err
+	}
+
+	// Application Stores
+	a.loglevelStore = a.runtime.GoRuntime().Store.New("wails:loglevel", a.options.LogLevel)
+	a.appconfigStore = a.runtime.GoRuntime().Store.New("wails:appconfig", a.options)
+
+	// Start the logging subsystem
+	log, err := subsystem.NewLog(a.servicebus, a.logger, a.loglevelStore)
+	if err != nil {
+		return err
+	}
+	a.log = log
+	err = a.log.Start()
+	if err != nil {
+		return err
+	}
+
+	// create the dispatcher
+	dispatcher, err := messagedispatcher.New(a.servicebus, a.logger)
+	if err != nil {
+		return err
+	}
+	a.dispatcher = dispatcher
+	err = dispatcher.Start()
+	if err != nil {
+		return err
+	}
+
+	// Start the eventing subsystem
+	eventsubsystem, err := subsystem.NewEvent(ctx, a.servicebus, a.logger)
+	if err != nil {
+		return err
+	}
+	a.event = eventsubsystem
+	err = a.event.Start()
+	if err != nil {
+		return err
+	}
+
+	// Start the menu subsystem
+	menusubsystem, err := subsystem.NewMenu(ctx, a.servicebus, a.logger, a.menuManager)
+	if err != nil {
+		return err
+	}
+	a.menu = menusubsystem
+	err = a.menu.Start()
+	if err != nil {
+		return err
+	}
+
+	// Start the call subsystem
+	callSubsystem, err := subsystem.NewCall(ctx, a.servicebus, a.logger, a.bindings.DB(), a.runtime.GoRuntime())
+	if err != nil {
+		return err
+	}
+	a.call = callSubsystem
+	err = a.call.Start()
+	if err != nil {
+		return err
+	}
+
+	// Dump bindings as a debug
+	bindingDump, err := a.bindings.ToJSON()
+	if err != nil {
+		return err
+	}
+
+	// Generate backend.js
+	a.bindings.GenerateBackendJS()
+
+	err = a.bridge.Run(dispatcher, a.menuManager, bindingDump, a.debug)
+	a.logger.Trace("Bridge.Run() exited")
+	if err != nil {
+		return err
+	}
+
+	// Close down all the subsystems
+	a.logger.Trace("Cancelling subsystems")
+	cancel()
+	subsystemWaitGroup.Wait()
+
+	a.logger.Trace("Cancelling dispatcher")
+	dispatcher.Close()
+
+	// Close log
+	a.logger.Trace("Stopping log")
+	log.Close()
+
+	a.logger.Trace("Stopping Service bus")
+	err = a.servicebus.Stop()
+	if err != nil {
+		return err
+	}
+
+	return nil
+
+}

v2/internal/app/hybrid.go

@@ -75,7 +75,7 @@ func CreateApp(options *Options) *App {
 		webserver:  webserver.NewWebServer(myLogger),
 		servicebus: servicebus.New(myLogger),
 		logger:     myLogger,
-		bindings:   binding.NewBindings(myLogger),
+		bindings:   binding.NewBindings(myLogger, options.Bind),
 	}
 
 	// Initialise the app
@@ -192,14 +192,3 @@ func (a *App) Run() error {
 
 	return cli.Run()
 }
-
-// Bind a struct to the application by passing in
-// a pointer to it
-func (a *App) Bind(structPtr interface{}) {
-
-	// Add the struct to the bindings
-	err := a.bindings.Add(structPtr)
-	if err != nil {
-		a.logger.Fatal("Error during binding: " + err.Error())
-	}
-}

v2/internal/app/server.go

@@ -6,10 +6,13 @@ import (
 	"os"
 	"path/filepath"
 
+	"github.com/wailsapp/wails/v2/pkg/options"
+
 	"github.com/leaanthony/clir"
 	"github.com/wailsapp/wails/v2/internal/binding"
 	"github.com/wailsapp/wails/v2/internal/logger"
 	"github.com/wailsapp/wails/v2/internal/messagedispatcher"
+	"github.com/wailsapp/wails/v2/internal/runtime"
 	"github.com/wailsapp/wails/v2/internal/servicebus"
 	"github.com/wailsapp/wails/v2/internal/subsystem"
 	"github.com/wailsapp/wails/v2/internal/webserver"
@@ -17,12 +20,16 @@ import (
 
 // App defines a Wails application structure
 type App struct {
+	appType string
+
 	binding *subsystem.Binding
 	call    *subsystem.Call
 	event   *subsystem.Event
 	log     *subsystem.Log
 	runtime *subsystem.Runtime
 
+	options *options.App
+
 	bindings   *binding.Bindings
 	logger     *logger.Logger
 	dispatcher *messagedispatcher.Dispatcher
@@ -30,28 +37,40 @@ type App struct {
 	webserver  *webserver.WebServer
 
 	debug bool
+
+	// Application Stores
+	loglevelStore  *runtime.Store
+	appconfigStore *runtime.Store
+
+	// Startup/Shutdown
+	startupCallback  func(*runtime.Runtime)
+	shutdownCallback func()
 }
 
 // Create App
-func CreateApp(options *Options) *App {
-	options.mergeDefaults()
-	// We ignore the inputs (for now)
+func CreateApp(appoptions *options.App) (*App, error) {
 
-	// TODO: Allow logger output override on CLI
-	myLogger := logger.New(os.Stdout)
-	myLogger.SetLogLevel(logger.TRACE)
+	// Merge default options
+	options.MergeDefaults(appoptions)
+
+	// Set up logger
+	myLogger := logger.New(appoptions.Logger)
+	myLogger.SetLogLevel(appoptions.LogLevel)
 
 	result := &App{
-		bindings:   binding.NewBindings(myLogger),
-		logger:     myLogger,
-		servicebus: servicebus.New(myLogger),
-		webserver:  webserver.NewWebServer(myLogger),
+		appType:          "server",
+		bindings:         binding.NewBindings(myLogger, options.Bind),
+		logger:           myLogger,
+		servicebus:       servicebus.New(myLogger),
+		webserver:        webserver.NewWebServer(myLogger),
+		startupCallback:  appoptions.Startup,
+		shutdownCallback: appoptions.Shutdown,
 	}
 
 	// Initialise app
 	result.Init()
 
-	return result
+	return result, nil
 }
 
 // Run the application
@@ -88,8 +107,21 @@ func (a *App) Run() error {
 		if debugMode {
 			a.servicebus.Debug()
 		}
+
+		// Start the runtime
+		runtime, err := subsystem.NewRuntime(a.servicebus, a.logger, a.startupCallback, a.shutdownCallback)
+		if err != nil {
+			return err
+		}
+		a.runtime = runtime
+		a.runtime.Start()
+
+		// Application Stores
+		a.loglevelStore = a.runtime.GoRuntime().Store.New("wails:loglevel", a.options.LogLevel)
+		a.appconfigStore = a.runtime.GoRuntime().Store.New("wails:appconfig", a.options)
+
 		a.servicebus.Start()
-		log, err := subsystem.NewLog(a.servicebus, a.logger)
+		log, err := subsystem.NewLog(a.servicebus, a.logger, a.loglevelStore)
 		if err != nil {
 			return err
 		}
@@ -102,14 +134,6 @@ func (a *App) Run() error {
 		a.dispatcher = dispatcher
 		a.dispatcher.Start()
 
-		// Start the runtime
-		runtime, err := subsystem.NewRuntime(a.servicebus, a.logger)
-		if err != nil {
-			return err
-		}
-		a.runtime = runtime
-		a.runtime.Start()
-
 		// Start the binding subsystem
 		binding, err := subsystem.NewBinding(a.servicebus, a.logger, a.bindings, runtime.GoRuntime())
 		if err != nil {
@@ -127,7 +151,7 @@ func (a *App) Run() error {
 		a.event.Start()
 
 		// Start the call subsystem
-		call, err := subsystem.NewCall(a.servicebus, a.logger, a.bindings.DB())
+		call, err := subsystem.NewCall(a.servicebus, a.logger, a.bindings.DB(), a.runtime.GoRuntime())
 		if err != nil {
 			return err
 		}
@@ -147,14 +171,3 @@ func (a *App) Run() error {
 
 	return cli.Run()
 }
-
-// Bind a struct to the application by passing in
-// a pointer to it
-func (a *App) Bind(structPtr interface{}) {
-
-	// Add the struct to the bindings
-	err := a.bindings.Add(structPtr)
-	if err != nil {
-		a.logger.Fatal("Error during binding: " + err.Error())
-	}
-}

v2/internal/binding/assets/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "backend",
+  "version": "1.0.0",
+  "description": "Package to wrap backend method calls",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC"
+}

v2/internal/binding/binding.go

@@ -2,28 +2,53 @@ package binding
 
 import (
 	"fmt"
+	"reflect"
+	"runtime"
 	"strings"
 
+	"github.com/leaanthony/slicer"
+
 	"github.com/wailsapp/wails/v2/internal/logger"
 )
 
 type Bindings struct {
-	db     *DB
-	logger logger.CustomLogger
+	db         *DB
+	logger     logger.CustomLogger
+	exemptions slicer.StringSlicer
 }
 
 // NewBindings returns a new Bindings object
-func NewBindings(logger *logger.Logger) *Bindings {
-	return &Bindings{
+func NewBindings(logger *logger.Logger, structPointersToBind []interface{}, exemptions []interface{}) *Bindings {
+	result := &Bindings{
 		db:     newDB(),
 		logger: logger.CustomLogger("Bindings"),
 	}
+
+	for _, exemption := range exemptions {
+		if exemptions == nil {
+			continue
+		}
+		name := runtime.FuncForPC(reflect.ValueOf(exemption).Pointer()).Name()
+		// Yuk yuk yuk! Is there a better way?
+		name = strings.TrimSuffix(name, "-fm")
+		result.exemptions.Add(name)
+	}
+
+	// Add the structs to bind
+	for _, ptr := range structPointersToBind {
+		err := result.Add(ptr)
+		if err != nil {
+			logger.Fatal("Error during binding: " + err.Error())
+		}
+	}
+
+	return result
 }
 
 // Add the given struct methods to the Bindings
 func (b *Bindings) Add(structPtr interface{}) error {
 
-	methods, err := getMethods(structPtr)
+	methods, err := b.getMethods(structPtr)
 	if err != nil {
 		return fmt.Errorf("cannot bind value to app: %s", err.Error())
 	}
@@ -36,7 +61,6 @@ func (b *Bindings) Add(structPtr interface{}) error {
 
 		// Add it as a regular method
 		b.db.AddMethod(packageName, structName, methodName, method)
-
 	}
 	return nil
 }

v2/internal/binding/boundMethod.go

@@ -30,6 +30,9 @@ func (b *BoundMethod) OutputCount() int {
 func (b *BoundMethod) ParseArgs(args []json.RawMessage) ([]interface{}, error) {
 
 	result := make([]interface{}, b.InputCount())
+	if len(args) != b.InputCount() {
+		return nil, fmt.Errorf("received %d arguments to method '%s', expected %d", len(args), b.Name, b.InputCount())
+	}
 	for index, arg := range args {
 		typ := b.Inputs[index].reflectType
 		inputValue := reflect.New(typ).Interface()

v2/internal/binding/generate.go

@@ -0,0 +1,170 @@
+package binding
+
+import (
+	"bytes"
+	_ "embed"
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/wailsapp/wails/v2/internal/fs"
+
+	"github.com/leaanthony/slicer"
+)
+
+const _comment = `
+
+const backend = {
+        main: {
+            "xbarApp": {
+                "GetCategories": () => {
+                    window.backend.main.xbarApp.GetCategories.call(arguments);
+                },
+
+                /**
+                 * @param {string} arg1
+                 */
+                "InstallPlugin": (arg1) => {
+                    window.backend.main.xbarApp.InstallPlugin.call(arguments);
+                },
+                "GetPlugins": () => {
+                    window.backend.main.xbarApp.GetPlugins.call(arguments);
+                }
+            }
+        }
+}
+
+export default backend;`
+
+//go:embed assets/package.json
+var packageJSON []byte
+
+func (b *Bindings) GenerateBackendJS() {
+
+	store := b.db.store
+	var output bytes.Buffer
+
+	output.WriteString(`// @ts-check
+// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL
+// This file is automatically generated. DO NOT EDIT
+
+const backend = {`)
+	output.WriteString("\n")
+
+	var sortedPackageNames slicer.StringSlicer
+	for packageName := range store {
+		sortedPackageNames.Add(packageName)
+	}
+	sortedPackageNames.Sort()
+	for _, packageName := range sortedPackageNames.AsSlice() {
+		packages := store[packageName]
+		output.WriteString(fmt.Sprintf("  \"%s\": {", packageName))
+		output.WriteString("\n")
+		var sortedStructNames slicer.StringSlicer
+		for structName := range packages {
+			sortedStructNames.Add(structName)
+		}
+		sortedStructNames.Sort()
+		for _, structName := range sortedStructNames.AsSlice() {
+			structs := packages[structName]
+			output.WriteString(fmt.Sprintf("    \"%s\": {", structName))
+			output.WriteString("\n")
+
+			var sortedMethodNames slicer.StringSlicer
+			for methodName := range structs {
+				sortedMethodNames.Add(methodName)
+			}
+			sortedMethodNames.Sort()
+
+			for _, methodName := range sortedMethodNames.AsSlice() {
+				methodDetails := structs[methodName]
+				output.WriteString("      /**\n")
+				output.WriteString("       * " + methodName + "\n")
+				var args slicer.StringSlicer
+				for count, input := range methodDetails.Inputs {
+					arg := fmt.Sprintf("arg%d", count+1)
+					args.Add(arg)
+					output.WriteString(fmt.Sprintf("       * @param {%s} %s - Go Type: %s\n", goTypeToJSDocType(input.TypeName), arg, input.TypeName))
+				}
+				returnType := "Promise"
+				returnTypeDetails := ""
+				if methodDetails.OutputCount() > 0 {
+					firstType := goTypeToJSDocType(methodDetails.Outputs[0].TypeName)
+					returnType += "<" + firstType
+					if methodDetails.OutputCount() == 2 {
+						secondType := goTypeToJSDocType(methodDetails.Outputs[1].TypeName)
+						returnType += "|" + secondType
+					}
+					returnType += ">"
+					returnTypeDetails = " - Go Type: " + methodDetails.Outputs[0].TypeName
+				}
+				output.WriteString("       * @returns {" + returnType + "} " + returnTypeDetails + "\n")
+				output.WriteString("       */\n")
+				argsString := args.Join(", ")
+				output.WriteString(fmt.Sprintf("      \"%s\": (%s) => {", methodName, argsString))
+				output.WriteString("\n")
+				output.WriteString(fmt.Sprintf("        return window.backend.%s.%s.%s(%s);", packageName, structName, methodName, argsString))
+				output.WriteString("\n")
+				output.WriteString(fmt.Sprintf("      },"))
+				output.WriteString("\n")
+			}
+			output.WriteString(fmt.Sprintf("    }"))
+			output.WriteString("\n")
+		}
+		output.WriteString(fmt.Sprintf("  }\n"))
+		output.WriteString("\n")
+	}
+
+	output.WriteString(`};
+export default backend;`)
+	output.WriteString("\n")
+
+	dirname, err := fs.RelativeToCwd("frontend/src/backend")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	if !fs.DirExists(dirname) {
+		err := fs.Mkdir(dirname)
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+
+	packageJsonFile := filepath.Join(dirname, "package.json")
+	if !fs.FileExists(packageJsonFile) {
+		err := os.WriteFile(packageJsonFile, packageJSON, 0755)
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+
+	filename := filepath.Join(dirname, "index.js")
+	err = os.WriteFile(filename, output.Bytes(), 0755)
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+func goTypeToJSDocType(input string) string {
+	switch true {
+	case input == "string":
+		return "string"
+	case input == "error":
+		return "Error"
+	case
+		strings.HasPrefix(input, "int"),
+		strings.HasPrefix(input, "uint"),
+		strings.HasPrefix(input, "float"):
+		return "number"
+	case input == "bool":
+		return "boolean"
+	case strings.HasPrefix(input, "[]"):
+		arrayType := goTypeToJSDocType(input[2:])
+		return "Array.<" + arrayType + ">"
+	default:
+		return "any"
+	}
+}

v2/internal/binding/reflect.go

@@ -23,7 +23,7 @@ func isStruct(value interface{}) bool {
 	return reflect.ValueOf(value).Kind() == reflect.Struct
 }
 
-func getMethods(value interface{}) ([]*BoundMethod, error) {
+func (b *Bindings) getMethods(value interface{}) ([]*BoundMethod, error) {
 
 	// Create result placeholder
 	var result []*BoundMethod
@@ -56,6 +56,11 @@ func getMethods(value interface{}) ([]*BoundMethod, error) {
 		fullMethodName := baseName + "." + methodName
 		method := structValue.MethodByName(methodName)
 
+		methodReflectName := runtime.FuncForPC(methodDef.Func.Pointer()).Name()
+		if b.exemptions.Contains(methodReflectName) {
+			continue
+		}
+
 		// Create new method
 		boundMethod := &BoundMethod{
 			Name:     fullMethodName,

v2/internal/bridge/bridge.go

@@ -0,0 +1,113 @@
+package bridge
+
+import (
+	"context"
+	"log"
+	"net/http"
+	"sync"
+
+	"github.com/wailsapp/wails/v2/internal/menumanager"
+
+	"github.com/wailsapp/wails/v2/internal/messagedispatcher"
+
+	"github.com/gorilla/websocket"
+	"github.com/wailsapp/wails/v2/internal/logger"
+)
+
+type Bridge struct {
+	upgrader websocket.Upgrader
+	server   *http.Server
+	myLogger *logger.Logger
+
+	bindings   string
+	dispatcher *messagedispatcher.Dispatcher
+
+	mu       sync.Mutex
+	sessions map[string]*session
+
+	ctx    context.Context
+	cancel context.CancelFunc
+
+	// Dialog client
+	dialog *messagedispatcher.DispatchClient
+
+	// Menus
+	menumanager *menumanager.Manager
+}
+
+func NewBridge(myLogger *logger.Logger) *Bridge {
+	result := &Bridge{
+		myLogger: myLogger,
+		upgrader: websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }},
+		sessions: make(map[string]*session),
+	}
+
+	myLogger.SetLogLevel(1)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	result.ctx = ctx
+	result.cancel = cancel
+	result.server = &http.Server{Addr: ":34115"}
+	http.HandleFunc("/bridge", result.wsBridgeHandler)
+	return result
+}
+
+func (b *Bridge) Run(dispatcher *messagedispatcher.Dispatcher, menumanager *menumanager.Manager, bindings string, debug bool) error {
+
+	// Ensure we cancel the context when we shutdown
+	defer b.cancel()
+
+	b.bindings = bindings
+	b.dispatcher = dispatcher
+	b.menumanager = menumanager
+
+	// Setup dialog handler
+	dialogClient := NewDialogClient(b.myLogger)
+	b.dialog = dispatcher.RegisterClient(dialogClient)
+	dialogClient.dispatcher = b.dialog
+
+	b.myLogger.Info("Bridge mode started.")
+
+	err := b.server.ListenAndServe()
+	if err != nil && err != http.ErrServerClosed {
+		return err
+	}
+
+	return nil
+}
+
+func (b *Bridge) wsBridgeHandler(w http.ResponseWriter, r *http.Request) {
+	c, err := b.upgrader.Upgrade(w, r, nil)
+	if err != nil {
+		log.Print("upgrade:", err)
+		return
+	}
+
+	if err != nil {
+		http.Error(w, "Could not open websocket connection", http.StatusBadRequest)
+	}
+	b.myLogger.Info("Connection from frontend accepted [%s].", c.RemoteAddr().String())
+	b.startSession(c)
+
+}
+
+func (b *Bridge) startSession(conn *websocket.Conn) {
+
+	// Create a new session for this connection
+	s := newSession(conn, b.menumanager, b.bindings, b.dispatcher, b.myLogger, b.ctx)
+
+	// Setup the close handler
+	conn.SetCloseHandler(func(int, string) error {
+		b.myLogger.Info("Connection dropped [%s].", s.Identifier())
+		b.dispatcher.RemoveClient(s.client)
+		b.mu.Lock()
+		delete(b.sessions, s.Identifier())
+		b.mu.Unlock()
+		return nil
+	})
+
+	b.mu.Lock()
+	go s.start(len(b.sessions) == 0)
+	b.sessions[s.Identifier()] = s
+	b.mu.Unlock()
+}

v2/internal/bridge/client.go

@@ -0,0 +1,130 @@
+package bridge
+
+import (
+	"github.com/wailsapp/wails/v2/pkg/options/dialog"
+)
+
+type BridgeClient struct {
+	session *session
+
+	// Tray menu cache to send to reconnecting clients
+	messageCache chan string
+}
+
+func NewBridgeClient() *BridgeClient {
+	return &BridgeClient{
+		messageCache: make(chan string, 100),
+	}
+}
+
+func (b BridgeClient) Quit() {
+	b.session.log.Info("Quit unsupported in Bridge mode")
+}
+
+func (b BridgeClient) NotifyEvent(message string) {
+	//b.session.sendMessage("n" + message)
+	b.session.log.Info("NotifyEvent: %s", message)
+	b.session.log.Info("NotifyEvent unsupported in Bridge mode")
+}
+
+func (b BridgeClient) CallResult(message string) {
+	b.session.sendMessage("c" + message)
+}
+
+func (b BridgeClient) OpenDialog(dialogOptions *dialog.OpenDialog, callbackID string) {
+	// Handled by dialog_client
+}
+
+func (b BridgeClient) SaveDialog(dialogOptions *dialog.SaveDialog, callbackID string) {
+	// Handled by dialog_client
+}
+
+func (b BridgeClient) MessageDialog(dialogOptions *dialog.MessageDialog, callbackID string) {
+	// Handled by dialog_client
+}
+
+func (b BridgeClient) WindowSetTitle(title string) {
+	b.session.log.Info("WindowSetTitle unsupported in Bridge mode")
+}
+
+func (b BridgeClient) WindowShow() {
+	b.session.log.Info("WindowShow unsupported in Bridge mode")
+}
+
+func (b BridgeClient) WindowHide() {
+	b.session.log.Info("WindowHide unsupported in Bridge mode")
+}
+
+func (b BridgeClient) WindowCenter() {
+	b.session.log.Info("WindowCenter unsupported in Bridge mode")
+}
+
+func (b BridgeClient) WindowMaximise() {
+	b.session.log.Info("WindowMaximise unsupported in Bridge mode")
+}
+
+func (b BridgeClient) WindowUnmaximise() {
+	b.session.log.Info("WindowUnmaximise unsupported in Bridge mode")
+}
+
+func (b BridgeClient) WindowMinimise() {
+	b.session.log.Info("WindowMinimise unsupported in Bridge mode")
+}
+
+func (b BridgeClient) WindowUnminimise() {
+	b.session.log.Info("WindowUnminimise unsupported in Bridge mode")
+}
+
+func (b BridgeClient) WindowPosition(x int, y int) {
+	b.session.log.Info("WindowPosition unsupported in Bridge mode")
+}
+
+func (b BridgeClient) WindowSize(width int, height int) {
+	b.session.log.Info("WindowSize unsupported in Bridge mode")
+}
+
+func (b BridgeClient) WindowSetMinSize(width int, height int) {
+	b.session.log.Info("WindowSetMinSize unsupported in Bridge mode")
+}
+
+func (b BridgeClient) WindowSetMaxSize(width int, height int) {
+	b.session.log.Info("WindowSetMaxSize unsupported in Bridge mode")
+}
+
+func (b BridgeClient) WindowFullscreen() {
+	b.session.log.Info("WindowFullscreen unsupported in Bridge mode")
+}
+
+func (b BridgeClient) WindowUnFullscreen() {
+	b.session.log.Info("WindowUnFullscreen unsupported in Bridge mode")
+}
+
+func (b BridgeClient) WindowSetColour(colour int) {
+	b.session.log.Info("WindowSetColour unsupported in Bridge mode")
+}
+
+func (b BridgeClient) DarkModeEnabled(callbackID string) {
+	b.session.log.Info("DarkModeEnabled unsupported in Bridge mode")
+}
+
+func (b BridgeClient) SetApplicationMenu(menuJSON string) {
+	b.session.log.Info("SetApplicationMenu unsupported in Bridge mode")
+}
+
+func (b BridgeClient) SetTrayMenu(trayMenuJSON string) {
+	b.session.sendMessage("TS" + trayMenuJSON)
+}
+
+func (b BridgeClient) UpdateTrayMenuLabel(trayMenuJSON string) {
+	b.session.sendMessage("TU" + trayMenuJSON)
+}
+
+func (b BridgeClient) UpdateContextMenu(contextMenuJSON string) {
+	b.session.log.Info("UpdateContextMenu unsupported in Bridge mode")
+}
+
+func newBridgeClient(session *session) *BridgeClient {
+	return &BridgeClient{
+		session: session,
+	}
+}

v2/internal/bridge/dialog_client.go

@@ -0,0 +1,141 @@
+package bridge
+
+import (
+	"fmt"
+	"os/exec"
+	"strconv"
+	"strings"
+
+	"github.com/wailsapp/wails/v2/internal/messagedispatcher"
+
+	"github.com/wailsapp/wails/v2/internal/logger"
+
+	"github.com/leaanthony/slicer"
+	"github.com/wailsapp/wails/v2/pkg/options/dialog"
+)
+
+type DialogClient struct {
+	dispatcher *messagedispatcher.DispatchClient
+	log        *logger.Logger
+}
+
+func NewDialogClient(log *logger.Logger) *DialogClient {
+	return &DialogClient{
+		log: log,
+	}
+}
+
+func (d *DialogClient) Quit() {
+}
+
+func (d *DialogClient) NotifyEvent(message string) {
+}
+
+func (d *DialogClient) CallResult(message string) {
+}
+
+func (d *DialogClient) OpenDialog(dialogOptions *dialog.OpenDialog, callbackID string) {
+}
+
+func (d *DialogClient) SaveDialog(dialogOptions *dialog.SaveDialog, callbackID string) {
+}
+
+func (d *DialogClient) MessageDialog(dialogOptions *dialog.MessageDialog, callbackID string) {
+
+	osa, err := exec.LookPath("osascript")
+	if err != nil {
+		d.log.Info("MessageDialog unavailable (osascript not found)")
+		return
+	}
+
+	var btns slicer.StringSlicer
+	defaultButton := ""
+	cancelButton := ""
+	for index, btn := range dialogOptions.Buttons {
+		btns.Add(strconv.Quote(btn))
+		if btn == dialogOptions.DefaultButton {
+			defaultButton = fmt.Sprintf("default button %d", index+1)
+		}
+		if btn == dialogOptions.CancelButton {
+			cancelButton = fmt.Sprintf("cancel button %d", index+1)
+		}
+	}
+	buttons := "{" + btns.Join(",") + "}"
+	script := fmt.Sprintf("display dialog \"%s\" buttons %s %s %s with title \"%s\"", dialogOptions.Message, buttons, defaultButton, cancelButton, dialogOptions.Title)
+	go func() {
+		out, err := exec.Command(osa, "-e", script).Output()
+		if err != nil {
+			// Assume user has pressed cancel button
+			if dialogOptions.CancelButton != "" {
+				d.dispatcher.DispatchMessage("DM" + callbackID + "|" + dialogOptions.CancelButton)
+				return
+			}
+			d.log.Error("Dialog had bad exit code. If this was a Cancel button, add 'CancelButton' to the dialog.MessageDialog struct. Error: %s", err.Error())
+			d.dispatcher.DispatchMessage("DM" + callbackID + "|error - check logs")
+			return
+		}
+
+		buttonPressed := strings.TrimSpace(strings.TrimPrefix(string(out), "button returned:"))
+		d.dispatcher.DispatchMessage("DM" + callbackID + "|" + buttonPressed)
+	}()
+}
+
+func (d *DialogClient) WindowSetTitle(title string) {
+}
+
+func (d *DialogClient) WindowShow() {
+}
+
+func (d *DialogClient) WindowHide() {
+}
+
+func (d *DialogClient) WindowCenter() {
+}
+
+func (d *DialogClient) WindowMaximise() {
+}
+
+func (d *DialogClient) WindowUnmaximise() {
+}
+
+func (d *DialogClient) WindowMinimise() {
+}
+
+func (d *DialogClient) WindowUnminimise() {
+}
+
+func (d *DialogClient) WindowPosition(x int, y int) {
+}
+
+func (d *DialogClient) WindowSize(width int, height int) {
+}
+
+func (d *DialogClient) WindowSetMinSize(width int, height int) {
+}
+
+func (d *DialogClient) WindowSetMaxSize(width int, height int) {
+}
+
+func (d *DialogClient) WindowFullscreen() {
+}
+
+func (d *DialogClient) WindowUnFullscreen() {
+}
+
+func (d *DialogClient) WindowSetColour(colour int) {
+}
+
+func (d *DialogClient) DarkModeEnabled(callbackID string) {
+}
+
+func (d *DialogClient) SetApplicationMenu(menuJSON string) {
+}
+
+func (d *DialogClient) SetTrayMenu(trayMenuJSON string) {
+}
+
+func (d *DialogClient) UpdateTrayMenuLabel(trayMenuJSON string) {
+}
+
+func (d *DialogClient) UpdateContextMenu(contextMenuJSON string) {
+}

v2/internal/bridge/session.go

@@ -0,0 +1,162 @@
+package bridge
+
+import (
+	"context"
+	_ "embed"
+	"log"
+	"runtime"
+	"time"
+
+	"github.com/wailsapp/wails/v2/internal/menumanager"
+
+	"github.com/wailsapp/wails/v2/internal/messagedispatcher"
+
+	"github.com/gorilla/websocket"
+	"github.com/wailsapp/wails/v2/internal/logger"
+)
+
+//go:embed darwin.js
+var darwinRuntime string
+
+// session represents a single websocket session
+type session struct {
+	bindings string
+	conn     *websocket.Conn
+	//eventManager interfaces.EventManager
+	log *logger.Logger
+	//ipc          interfaces.IPCManager
+
+	// Mutex for writing to the socket
+	shutdown  chan bool
+	writeChan chan []byte
+
+	done bool
+
+	// context
+	ctx context.Context
+
+	// client
+	client *messagedispatcher.DispatchClient
+
+	// Menus
+	menumanager *menumanager.Manager
+}
+
+func newSession(conn *websocket.Conn, menumanager *menumanager.Manager, bindings string, dispatcher *messagedispatcher.Dispatcher, logger *logger.Logger, ctx context.Context) *session {
+	result := &session{
+		conn:        conn,
+		bindings:    bindings,
+		log:         logger,
+		shutdown:    make(chan bool),
+		writeChan:   make(chan []byte, 100),
+		ctx:         ctx,
+		menumanager: menumanager,
+	}
+
+	result.client = dispatcher.RegisterClient(newBridgeClient(result))
+
+	return result
+
+}
+
+// Identifier returns a string identifier for the remote connection.
+// Taking the form of the client's <ip address>:<port>.
+func (s *session) Identifier() string {
+	if s.conn != nil {
+		return s.conn.RemoteAddr().String()
+	}
+	return ""
+}
+
+func (s *session) sendMessage(msg string) error {
+	if !s.done {
+		s.writeChan <- []byte(msg)
+	}
+	return nil
+}
+
+func (s *session) start(firstSession bool) {
+	s.log.SetLogLevel(1)
+	s.log.Info("Connected to frontend.")
+	go s.writePump()
+
+	var wailsRuntime string
+	switch runtime.GOOS {
+	case "darwin":
+		wailsRuntime = darwinRuntime
+	default:
+		log.Fatal("platform not supported")
+	}
+
+	bindingsMessage := "window.wailsbindings = `" + s.bindings + "`;"
+	s.log.Info(bindingsMessage)
+	bootstrapMessage := bindingsMessage + wailsRuntime
+
+	s.sendMessage("b" + bootstrapMessage)
+
+	// Send menus
+	traymenus, err := s.menumanager.GetTrayMenus()
+	if err != nil {
+		s.log.Error(err.Error())
+	}
+
+	for _, trayMenu := range traymenus {
+		s.sendMessage("TS" + trayMenu)
+	}
+
+	for {
+		messageType, buffer, err := s.conn.ReadMessage()
+		if messageType == -1 {
+			return
+		}
+		if err != nil {
+			s.log.Error("Error reading message: %v", err)
+			err = s.conn.Close()
+			return
+		}
+
+		message := string(buffer)
+
+		s.log.Debug("Got message: %#v\n", message)
+
+		// Dispatch message as normal
+		s.client.DispatchMessage(message)
+
+		if s.done {
+			break
+		}
+	}
+}
+
+// Shutdown
+func (s *session) Shutdown() {
+	s.conn.Close()
+	s.done = true
+	s.log.Info("session %v exit", s.Identifier())
+}
+
+// writePump pulls messages from the writeChan and sends them to the client
+// since it uses a channel to read the messages the socket is protected without locks
+func (s *session) writePump() {
+	s.log.Debug("Session %v - writePump start", s.Identifier())
+	defer s.log.Debug("Session %v - writePump shutdown", s.Identifier())
+	for {
+		select {
+		case <-s.ctx.Done():
+			s.Shutdown()
+			return
+		case msg, ok := <-s.writeChan:
+			s.conn.SetWriteDeadline(time.Now().Add(1 * time.Second))
+			if !ok {
+				s.log.Debug("writeChan was closed!")
+				s.conn.WriteMessage(websocket.CloseMessage, []byte{})
+				return
+			}
+
+			if err := s.conn.WriteMessage(websocket.TextMessage, msg); err != nil {
+				s.log.Debug(err.Error())
+				return
+			}
+		}
+	}
+}

v2/internal/counter/counter.go

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

v2/internal/deepcopy/LICENSE

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

v2/internal/deepcopy/deepcopy.go

@@ -0,0 +1,125 @@
+// deepcopy makes deep copies of things. A standard copy will copy the
+// pointers: deep copy copies the values pointed to.  Unexported field
+// values are not copied.
+//
+// Copyright (c)2014-2016, Joel Scoble (github.com/mohae), all rights reserved.
+// License: MIT, for more details check the included LICENSE file.
+package deepcopy
+
+import (
+	"reflect"
+	"time"
+)
+
+// Interface for delegating copy process to type
+type Interface interface {
+	DeepCopy() interface{}
+}
+
+// Iface is an alias to Copy; this exists for backwards compatibility reasons.
+func Iface(iface interface{}) interface{} {
+	return Copy(iface)
+}
+
+// Copy creates a deep copy of whatever is passed to it and returns the copy
+// in an interface{}.  The returned value will need to be asserted to the
+// correct type.
+func Copy(src interface{}) interface{} {
+	if src == nil {
+		return nil
+	}
+
+	// Make the interface a reflect.Value
+	original := reflect.ValueOf(src)
+
+	// Make a copy of the same type as the original.
+	cpy := reflect.New(original.Type()).Elem()
+
+	// Recursively copy the original.
+	copyRecursive(original, cpy)
+
+	// Return the copy as an interface.
+	return cpy.Interface()
+}
+
+// copyRecursive does the actual copying of the interface. It currently has
+// limited support for what it can handle. Add as needed.
+func copyRecursive(original, cpy reflect.Value) {
+	// check for implement deepcopy.Interface
+	if original.CanInterface() {
+		if copier, ok := original.Interface().(Interface); ok {
+			cpy.Set(reflect.ValueOf(copier.DeepCopy()))
+			return
+		}
+	}
+
+	// handle according to original's Kind
+	switch original.Kind() {
+	case reflect.Ptr:
+		// Get the actual value being pointed to.
+		originalValue := original.Elem()
+
+		// if  it isn't valid, return.
+		if !originalValue.IsValid() {
+			return
+		}
+		cpy.Set(reflect.New(originalValue.Type()))
+		copyRecursive(originalValue, cpy.Elem())
+
+	case reflect.Interface:
+		// If this is a nil, don't do anything
+		if original.IsNil() {
+			return
+		}
+		// Get the value for the interface, not the pointer.
+		originalValue := original.Elem()
+
+		// Get the value by calling Elem().
+		copyValue := reflect.New(originalValue.Type()).Elem()
+		copyRecursive(originalValue, copyValue)
+		cpy.Set(copyValue)
+
+	case reflect.Struct:
+		t, ok := original.Interface().(time.Time)
+		if ok {
+			cpy.Set(reflect.ValueOf(t))
+			return
+		}
+		// Go through each field of the struct and copy it.
+		for i := 0; i < original.NumField(); i++ {
+			// The Type's StructField for a given field is checked to see if StructField.PkgPath
+			// is set to determine if the field is exported or not because CanSet() returns false
+			// for settable fields.  I'm not sure why.  -mohae
+			if original.Type().Field(i).PkgPath != "" {
+				continue
+			}
+			copyRecursive(original.Field(i), cpy.Field(i))
+		}
+
+	case reflect.Slice:
+		if original.IsNil() {
+			return
+		}
+		// Make a new slice and copy each element.
+		cpy.Set(reflect.MakeSlice(original.Type(), original.Len(), original.Cap()))
+		for i := 0; i < original.Len(); i++ {
+			copyRecursive(original.Index(i), cpy.Index(i))
+		}
+
+	case reflect.Map:
+		if original.IsNil() {
+			return
+		}
+		cpy.Set(reflect.MakeMap(original.Type()))
+		for _, key := range original.MapKeys() {
+			originalValue := original.MapIndex(key)
+			copyValue := reflect.New(originalValue.Type()).Elem()
+			copyRecursive(originalValue, copyValue)
+			copyKey := Copy(key.Interface())
+			cpy.SetMapIndex(reflect.ValueOf(copyKey), copyValue)
+		}
+
+	default:
+		cpy.Set(original)
+	}
+}

v2/internal/ffenestri/LICENCES.md

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

v2/internal/ffenestri/common.c

@@ -38,31 +38,21 @@ int freeHashmapItem(void *const context, struct hashmap_element_s *const e) {
 const char* getJSONString(JsonNode *item, const char* key) {
     // Get key
     JsonNode *node = json_find_member(item, key);
-    const char *result = NULL;
+    const char *result = "";
     if ( node != NULL && node->tag == JSON_STRING) {
         result = node->string_;
     }
     return result;
 }
 
-const char* getJSONStringDefault(JsonNode *item, const char* key, const char* defaultValue) {
-    const char* result = getJSONString(item, key);
-    if ( result == NULL ) result = defaultValue;
-    return result;
-}
-
 void ABORT_JSON(JsonNode *node, const char* key) {
     ABORT("Unable to read required key '%s' from JSON: %s\n", key, json_encode(node));
 }
 
-const char* mustJSONString(JsonNode *item, const char* key) {
-    JsonNode *member = json_find_member(item, key);
-    if ( member == NULL ) {
-        ABORT_JSON(item, key);
-    }
-    const char *result = "";
-    if ( member != NULL && member->tag == JSON_STRING) {
-        result = member->string_;
+const char* mustJSONString(JsonNode *node, const char* key) {
+    const char* result = getJSONString(node, key);
+    if ( result == NULL ) {
+        ABORT_JSON(node, key);
     }
     return result;
 }
@@ -78,23 +68,15 @@ JsonNode* getJSONObject(JsonNode* node, const char* key) {
     return json_find_member(node, key);
 }
 
-bool getJSONBool(JsonNode *node, const char* key) {
-    JsonNode *result = json_find_member(node, key);
-    if ( result != NULL && result->tag == JSON_BOOL) {
-        return result->bool_;
+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;
 }
 
-int mustJSONInt(JsonNode *node, const char* key) {
-    JsonNode *result = json_find_member(node, key);
-    if ( result == NULL || result->tag != JSON_NUMBER) {
-        ABORT_JSON(result, key);
-    }
-
-    return (int) result->number_;
-}
-
 bool getJSONInt(JsonNode *item, const char* key, int *result) {
     JsonNode *node = json_find_member(item, key);
     if ( node != NULL && node->tag == JSON_NUMBER) {

v2/internal/ffenestri/common.h

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

v2/internal/ffenestri/contextmenus_darwin.c

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

@@ -1,33 +1,33 @@
-//////
-////// Created by Lea Anthony on 6/1/21.
-//////
 ////
-//#ifndef CONTEXTMENU_DARWIN_H
-//#define CONTEXTMENU_DARWIN_H
+//// Created by Lea Anthony on 6/1/21.
+////
 //
-//#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
+#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

@@ -1,65 +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);
-//
-//}
+
+#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

@@ -1,27 +1,27 @@
-////
-//// Created by Lea Anthony on 7/1/21.
-////
 //
-//#ifndef CONTEXTMENUSTORE_DARWIN_H
-//#define CONTEXTMENUSTORE_DARWIN_H
+// Created by Lea Anthony on 7/1/21.
 //
-//#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
+
+#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,11 +1,12 @@
 package ffenestri
 
 import (
-	"github.com/wailsapp/wails/v2/internal/menumanager"
 	"runtime"
 	"strings"
 	"unsafe"
 
+	"github.com/wailsapp/wails/v2/internal/menumanager"
+
 	"github.com/wailsapp/wails/v2/internal/logger"
 	"github.com/wailsapp/wails/v2/internal/messagedispatcher"
 	"github.com/wailsapp/wails/v2/pkg/options"
@@ -118,7 +119,8 @@ func (a *Application) Run(incomingDispatcher Dispatcher, bindings string, debug
 	fullscreen := a.bool2Cint(a.config.Fullscreen)
 	startHidden := a.bool2Cint(a.config.StartHidden)
 	logLevel := C.int(a.config.LogLevel)
-	app := C.NewApplication(title, width, height, resizable, devtools, fullscreen, startHidden, logLevel)
+	hideWindowOnClose := a.bool2Cint(a.config.HideWindowOnClose)
+	app := C.NewApplication(title, width, height, resizable, devtools, fullscreen, startHidden, logLevel, hideWindowOnClose)
 
 	// Save app reference
 	a.app = (*C.struct_Application)(app)

v2/internal/ffenestri/ffenestri.h

@@ -4,7 +4,7 @@
 #include <stdio.h>
 struct Application;
 
-extern struct Application *NewApplication(const char *title, int width, int height, int resizable, int devtools, int fullscreen, int startHidden, int logLevel);
+extern struct Application *NewApplication(const char *title, int width, int height, int resizable, int devtools, int fullscreen, int startHidden, int logLevel, int hideWindowOnClose);
 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);
@@ -30,15 +30,15 @@ extern void Fullscreen(struct Application*);
 extern void UnFullscreen(struct Application*);
 extern void ToggleFullscreen(struct Application*);
 extern void DisableFrame(struct Application*);
-extern void OpenDialog(struct Application*, const char *callbackID, const char *title, const char *filters, const char *defaultFilename, const char *defaultDir, int allowFiles, int allowDirs, int allowMultiple, int showHiddenFiles, int canCreateDirectories, int resolvesAliases, int treatPackagesAsDirectories);
-extern void SaveDialog(struct Application*, const char *callbackID, const char *title, const char *filters, const char *defaultFilename, const char *defaultDir, int showHiddenFiles, int canCreateDirectories, int treatPackagesAsDirectories);
-extern void MessageDialog(struct Application*, const char *callbackID, const char *type, const char *title, const char *message, const char *icon, const char *button1, const char *button2, const char *button3, const char *button4, const char *defaultButton, const char *cancelButton);
-extern void DarkModeEnabled(struct Application*, const char *callbackID);
+extern void 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*, const char *contextMenuJSON);
-extern void UpdateContextMenu(struct Application*, const char *contextMenuJSON);
+extern void AddContextMenu(struct Application*, char *contextMenuJSON);
+extern void UpdateContextMenu(struct Application*, char *contextMenuJSON);
 
 #endif

v2/internal/ffenestri/ffenestri_client.go

@@ -12,9 +12,10 @@ package ffenestri
 import "C"
 
 import (
-	"github.com/wailsapp/wails/v2/pkg/options/dialog"
 	"strconv"
 
+	"github.com/wailsapp/wails/v2/pkg/options/dialog"
+
 	"github.com/wailsapp/wails/v2/internal/logger"
 )
 
@@ -113,6 +114,14 @@ func (c *Client) WindowSize(width int, height int) {
 	C.SetSize(c.app.app, C.int(width), C.int(height))
 }
 
+func (c *Client) WindowSetMinSize(width int, height int) {
+	C.SetMinWindowSize(c.app.app, C.int(width), C.int(height))
+}
+
+func (c *Client) WindowSetMaxSize(width int, height int) {
+	C.SetMaxWindowSize(c.app.app, C.int(width), C.int(height))
+}
+
 // WindowSetColour sets the window colour
 func (c *Client) WindowSetColour(colour int) {
 	r, g, b, a := intToColour(colour)

v2/internal/ffenestri/ffenestri_darwin.go

@@ -2,7 +2,7 @@ package ffenestri
 
 /*
 #cgo darwin CFLAGS: -DFFENESTRI_DARWIN=1
-#cgo darwin LDFLAGS: -framework WebKit -lobjc
+#cgo darwin LDFLAGS: -framework WebKit -framework CoreFoundation -lobjc
 
 #include "ffenestri.h"
 #include "ffenestri_darwin.h"
@@ -58,15 +58,15 @@ func (a *Application) processPlatformSettings() error {
 		C.WindowBackgroundIsTranslucent(a.app)
 	}
 
-	//// Process menu
-	////applicationMenu := options.GetApplicationMenu(a.config)
-	//applicationMenu := a.menuManager.GetApplicationMenuJSON()
-	//if applicationMenu != "" {
-	//	C.SetApplicationMenu(a.app, a.string2CString(applicationMenu))
-	//}
+	// Process menu
+	//applicationMenu := options.GetApplicationMenu(a.config)
+	applicationMenu := a.menuManager.GetApplicationMenuJSON()
+	if applicationMenu != "" {
+		C.SetApplicationMenu(a.app, a.string2CString(applicationMenu))
+	}
 
 	// Process tray
-	trays, err := a.menuManager.GetTrayMenusAsJSON()
+	trays, err := a.menuManager.GetTrayMenus()
 	if err != nil {
 		return err
 	}
@@ -76,16 +76,16 @@ func (a *Application) processPlatformSettings() error {
 		}
 	}
 
-	//// Process context menus
-	//contextMenus, err := a.menuManager.GetContextMenus()
-	//if err != nil {
-	//	return err
-	//}
-	//if contextMenus != nil {
-	//	for _, contextMenu := range contextMenus {
-	//		C.AddContextMenu(a.app, a.string2CString(contextMenu))
-	//	}
-	//}
+	// Process context menus
+	contextMenus, err := a.menuManager.GetContextMenus()
+	if err != nil {
+		return err
+	}
+	if contextMenus != nil {
+		for _, contextMenu := range contextMenus {
+			C.AddContextMenu(a.app, a.string2CString(contextMenu))
+		}
+	}
 
 	return nil
 }

v2/internal/ffenestri/ffenestri_darwin.h

@@ -6,6 +6,7 @@
 #define OBJC_OLD_DISPATCH_PROTOTYPES 1
 #include <objc/objc-runtime.h>
 #include <CoreGraphics/CoreGraphics.h>
+#include <CoreFoundation/CoreFoundation.h>
 #include "json.h"
 #include "hashmap.h"
 #include "stdlib.h"
@@ -20,8 +21,6 @@
 #define strunicode(input) msg(c("NSString"), s("stringWithFormat:"), str("%C"), (unsigned short)input)
 #define cstr(input) (const char *)msg(input, s("UTF8String"))
 #define url(input) msg(c("NSURL"), s("fileURLWithPath:"), str(input))
-#define RELEASE(input) if( input != NULL ) { msg(input, s("release")); }
-
 #define ALLOC(classname) msg(c(classname), s("alloc"))
 #define ALLOC_INIT(classname) msg(msg(c(classname), s("alloc")), s("init"))
 #define GET_FRAME(receiver) ((CGRect(*)(id, SEL))objc_msgSend_stret)(receiver, s("frame"))
@@ -109,5 +108,8 @@ 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 *);
+
+void* lookupStringConstant(id constantName);
 
 #endif

v2/internal/ffenestri/menu.c

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

v2/internal/ffenestri/menu.h

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

v2/internal/ffenestri/menu_darwin.c

@@ -1,35 +1,177 @@
 //
-// Created by Lea Anthony on 18/1/21.
+// Created by Lea Anthony on 6/1/21.
 //
 
-#include "ffenestri.h"
 #include "ffenestri_darwin.h"
 #include "menu_darwin.h"
-#include "menu.h"
-#include "trayicons.h"
+#include "contextmenus_darwin.h"
+#include "common.h"
 
-// A cache for all our tray menu icons
-// Global because it's a singleton
-struct hashmap_s trayIconCache;
+// NewMenu creates a new Menu struct, saving the given menu structure as JSON
+Menu* NewMenu(JsonNode *menuData) {
 
-void SetupMenuPlatformData(Menu* menu) {
-    MacMenu* result = NEW(MacMenu);
-    result->Menu = ALLOC("NSMenu");
-    msg(result->Menu, s("initWithTitle:"), str(menu->label));
-    msg(result->Menu, s("setAutoenablesItems:"), NO);
-    menu->platformData = (void*)result;
+    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;
 }
 
-void DeleteMenuPlatformData(Menu* menu) {
+Menu* NewApplicationMenu(const char *menuAsJSON) {
 
-    // Return if null
-    if( menu == NULL || menu->platformData == NULL) return;
+    // Parse the menu json
+    JsonNode *processedMenu = json_decode(menuAsJSON);
+    if( processedMenu == NULL ) {
+        // Parse error!
+        ABORT("Unable to parse Menu JSON: %s", menuAsJSON);
+    }
 
-    MacMenu* macMenu = (MacMenu*) menu->platformData;
-    RELEASE(macMenu->Menu);
-    macMenu->Menu = NULL;
+    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) {
 
@@ -201,6 +343,161 @@ id processAcceleratorKey(const char *key) {
     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) {
@@ -233,286 +530,362 @@ unsigned long parseModifiers(const char **modifiers) {
     return result;
 }
 
-
-
-void SetupMenuItemPlatformData(MenuItem* menuItem) {
-
-    // Create the platform data
-    MacMenuItem *macMenuItem = NEW(MacMenuItem);
-
-    menuItem->platformData = macMenuItem;
-
-    // Create the NSMenuItem
+id processRadioMenuItem(Menu *menu, id parentmenu, const char *title, const char *menuid, bool disabled, bool checked, const char *acceleratorkey) {
     id item = ALLOC("NSMenuItem");
-    macMenuItem->MenuItem = item;
 
-//    // TODO: Process ROLE
-//    if( menuItem->role != NULL ) {
-//
-//    }
+    // Store the item in the menu item map
+    hashmap_put(&menu->menuItemMap, (char*)menuid, strlen(menuid), item);
 
-    id key = processAcceleratorKey(menuItem->acceleratorKey);
-    msg(item, s("initWithTitle:action:keyEquivalent:"), str(menuItem->label),
+    // 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, const char* image, const char* fontName, int fontSize, const char* RGBA, bool templateImage) {
+    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);
 
-    msg(item, s("setEnabled:"), !menuItem->disabled);
+    if( tooltip != NULL ) {
+        msg(item, s("setToolTip:"), str(tooltip));
+    }
+
+    // Process image
+    if( image != NULL && strlen(image) > 0) {
+        id data = ALLOC("NSData");
+        id imageData = msg(data, s("initWithBase64EncodedString:options:"), str(image), 0);
+        id nsimage = ALLOC("NSImage");
+        msg(nsimage, s("initWithData:"), imageData);
+        if( templateImage ) {
+            msg(nsimage, s("template"), YES);
+        }
+        msg(item, s("setImage:"), nsimage);
+    }
+
+    // Process Menu Item attributes
+    id dictionary = ALLOC_INIT("NSMutableDictionary");
+
+    // Process font
+    id font;
+    CGFloat fontSizeFloat = (CGFloat)fontSize;
+
+    // Check if valid
+    id fontNameAsNSString = str(fontName);
+    id fontsOnSystem = msg(msg(c("NSFontManager"), s("sharedFontManager")), s("availableFonts"));
+    bool valid = msg(fontsOnSystem, s("containsObject:"), fontNameAsNSString);
+    if( valid ) {
+        font = msg(c("NSFont"), s("fontWithName:size:"), fontNameAsNSString, fontSizeFloat);
+    } else {
+        bool supportsMonospacedDigitSystemFont = (bool) msg(c("NSFont"), s("respondsToSelector:"), s("monospacedDigitSystemFontOfSize:weight:"));
+        if( supportsMonospacedDigitSystemFont ) {
+            font = msg(c("NSFont"), s("monospacedDigitSystemFontOfSize:weight:"), fontSizeFloat, NSFontWeightRegular);
+        } else {
+            font = msg(c("NSFont"), s("menuFontOfSize:"), fontSizeFloat);
+        }
+    }
+
+    // Add font to dictionary
+    msg(dictionary, s("setObject:forKey:"), font, lookupStringConstant(str("NSFontAttributeName")));
+
+    // Add offset to dictionary
+    id offset = msg(c("NSNumber"), s("numberWithFloat:"), 0.0);
+    msg(dictionary, s("setObject:forKey:"), offset, lookupStringConstant(str("NSBaselineOffsetAttributeName")));
+
+    // RGBA
+    if( RGBA != NULL && strlen(RGBA) > 0) {
+        unsigned short r, g, b, a;
+
+        // white by default
+        r = g = b = a = 255;
+        int count = sscanf(RGBA, "#%02hx%02hx%02hx%02hx", &r, &g, &b, &a);
+        if (count > 0) {
+			id colour = msg(c("NSColor"), s("colorWithCalibratedRed:green:blue:alpha:"),
+								(float)r / 255.0,
+								(float)g / 255.0,
+								(float)b / 255.0,
+								(float)a / 255.0);
+            msg(dictionary, s("setObject:forKey:"), colour, lookupStringConstant(str("NSForegroundColorAttributeName")));
+            msg(colour, s("release"));
+        }
+    }
+
+    id attributedString = ALLOC("NSMutableAttributedString");
+    msg(attributedString, s("initWithString:attributes:"), str(title), dictionary);
+    msg(dictionary, s("release"));
+
+    msg(item, s("setAttributedTitle:"), attributedString);
+    msg(attributedString, s("autorelease"));
+
+    msg(item, s("setEnabled:"), !disabled);
     msg(item, s("autorelease"));
 
     // Process modifiers
-    if( menuItem->modifiers != NULL ) {
-        unsigned long modifierFlags = parseModifiers(menuItem->modifiers);
+    if( modifiers != NULL ) {
+        unsigned long modifierFlags = parseModifiers(modifiers);
         msg(item, s("setKeyEquivalentModifierMask:"), modifierFlags);
-        menuItem->modifiers = NULL;
     }
+    msg(parentMenu, s("addItem:"), item);
 
+    return item;
 }
 
-void DeleteMenuItemPlatformData(MenuItem* menuItem) {
+void processMenuItem(Menu *menu, id parentMenu, JsonNode *item) {
 
-    if( menuItem == NULL || menuItem->platformData == NULL) return;
-
-    MacMenuItem* macMenuItem = (MacMenuItem*) menuItem->platformData;
-    RELEASE(macMenuItem->MenuItem);
-
-    MEMFREE(macMenuItem);
-
-}
-
-void PlatformAddMenuItemToMenu(Menu *menu, MenuItem* menuItem, MenuManager* manager) {
-
-    // Return if null
-    if( menu == NULL || menu->platformData == NULL) return;
-    if( menuItem == NULL || menuItem->platformData == NULL) return;
-
-    // Don't add if the item is hidden
-    if( menuItem->hidden ) return;
-
-    // Setup callback
-    if( menuItem->hasCallback ) {
-        // Create a MenuItemCallbackData
-        MacMenuItem* macMenuItem = (MacMenuItem*) menuItem->platformData;
-        menuItem->callbackData = NewMenuItemCallbackData(manager, menuItem->ID, Text);
-
-        id wrappedId = msg(c("NSValue"), s("valueWithPointer:"), menuItem->callbackData);
-        msg(macMenuItem->MenuItem, s("setRepresentedObject:"), wrappedId);
-    }
-
-    MacMenu* macMenu = (MacMenu*) menu->platformData;
-    MacMenuItem* macMenuItem = (MacMenuItem*) menuItem->platformData;
-
-    msg(macMenu->Menu, s("addItem:"), macMenuItem->MenuItem);
-
-}
-
-void SetupTrayMenuPlatformData(TrayMenu* menu) {
-    MacTrayMenu* result = NEW(MacTrayMenu);
-    result->statusBarItem = NULL;
-
-    // TODO: Work out how to make this customisable
-    result->iconPosition = NSImageLeft;
-
-    menu->platformData = (void*)result;
-}
-
-void DeleteTrayMenuPlatformData(TrayMenu* menu) {
-
-    // Return if null
-    if( menu == NULL || menu->platformData == NULL) return;
-
-    MacTrayMenu* macMenu = (MacTrayMenu*) menu->platformData;
-    RELEASE(macMenu->statusBarItem);
-    macMenu->statusBarItem = NULL;
-}
-
-
-void PlatformUpdateTrayIcon(TrayMenu* trayMenu) {
-
-    MacTrayMenu* macTrayMenu = (MacTrayMenu*) trayMenu->platformData;
-
-    id statusBarButton = msg(macTrayMenu->statusBarItem, s("button"));
-
-    // Empty icon means remove it
-    if (trayMenu->Icon == NULL || strlen(trayMenu->Icon) == 0) {
-        msg(statusBarButton, s("setImage:"), NULL);
+    // Check if this item is hidden and if so, exit early!
+    bool hidden = false;
+    getJSONBool(item, "Hidden", &hidden);
+    if( hidden ) {
         return;
     }
 
-    id trayImage = HASHMAP_GET(trayIconCache, trayMenu->Icon);
-    msg(statusBarButton, s("setImagePosition:"), macTrayMenu->iconPosition);
-    msg(statusBarButton, s("setImage:"), trayImage);
-}
-
-void UpdateTrayLabel(TrayMenu *trayMenu, const char *label) {
-
-    // Exit early if NULL
-    if( trayMenu->Label == NULL ) return;
-
-    // Update button label
-    MacTrayMenu* macTrayMenu = (MacTrayMenu*) trayMenu->platformData;
-    id statusBarButton = msg(macTrayMenu->statusBarItem, s("button"));
-    msg(statusBarButton, s("setTitle:"), str(label));
-}
-
-void ShowTrayMenu(TrayMenu* trayMenu) {
-
-    if( trayMenu == NULL || trayMenu->platformData == NULL ) return;
-
-    MacTrayMenu* macTrayMenu = (MacTrayMenu*) trayMenu->platformData;
-
-    // Create a status bar item if we don't have one
-    if( macTrayMenu->statusBarItem == NULL ) {
-        id statusBar = msg( c("NSStatusBar"), s("systemStatusBar") );
-        macTrayMenu->statusBarItem = msg(statusBar, s("statusItemWithLength:"), NSVariableStatusItemLength);
-        msg(macTrayMenu->statusBarItem, s("retain"));
+    // Get the role
+    JsonNode *role = json_find_member(item, "Role");
+    if( role != NULL ) {
+        processMenuRole(menu, parentMenu, role);
+        return;
     }
 
-    id statusBarButton = msg(macTrayMenu->statusBarItem, s("button"));
-    msg(statusBarButton, s("setImagePosition:"), macTrayMenu->iconPosition);
+    // 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_;
+        }
 
-    // Update the icon if needed
-    PlatformUpdateTrayIcon(trayMenu);
+        id thisMenuItem = createMenuItemNoAutorelease(str(name), NULL, "");
+        id thisMenu = createMenu(str(name));
 
-    // Update the label if needed
-    UpdateTrayLabel(trayMenu, trayMenu->Label);
+        msg(thisMenuItem, s("setSubmenu:"), thisMenu);
+        msg(parentMenu, s("addItem:"), thisMenuItem);
 
-    // If we don't have a menu, return
-    if( trayMenu->Menu == NULL ) return;
+        JsonNode *submenuItems = json_find_member(submenu, "Items");
+        // If we have no items, just return
+        if ( submenuItems == NULL ) {
+            return;
+        }
 
-    // Update the menu
-    MacMenu* macMenu = (MacMenu*) trayMenu->Menu->platformData;
-    msg(macTrayMenu->statusBarItem, s("setMenu:"), macMenu->Menu);
-}
+        // Loop over submenu items
+        JsonNode *item;
+        json_foreach(item, submenuItems) {
+            // Get item label
+            processMenuItem(menu, thisMenu, item);
+        }
 
-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!");
+        return;
     }
 
-    unsigned int count = 0;
-    while( 1 ) {
-        const unsigned char *name = trayIcons[count++];
-        if( name == 0x00 ) {
-            break;
-        }
-        const unsigned char *lengthAsString = trayIcons[count++];
-        if( name == 0x00 ) {
-            break;
-        }
-        const unsigned char *data = trayIcons[count++];
-        if( data == 0x00 ) {
-            break;
-        }
-        char *c;
-        unsigned long length = strtol((const char *)lengthAsString, &c, 10);
+    // This is a user menu. Get the common data
+    // Get the label
+    const char *label = getJSONString(item, "Label");
+    if ( label == NULL) {
+        label = "(empty)";
+    }
 
-        // Create the icon and add to the hashmap
-        id imageData = msg(c("NSData"), s("dataWithBytes:length:"), data, length);
-        id trayImage = ALLOC("NSImage");
-        msg(trayImage, s("initWithData:"), imageData);
-        HASHMAP_PUT(trayIconCache, (const char *)name, trayImage);
+    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");
+    const char *image = getJSONString(item, "Image");
+    const char *fontName = getJSONString(item, "FontName");
+    const char *RGBA = getJSONString(item, "RGBA");
+    bool templateImage = false;
+    getJSONBool(item, "MacTemplateImage", &templateImage);
+
+    int fontSize = 12;
+    getJSONInt(item, "FontSize", &fontSize);
+
+    // 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, image, fontName, fontSize, RGBA, templateImage);
+        }
+        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 UnloadTrayIcons() {
-    // Release the tray cache images
-    HASHMAP_ITERATE(trayIconCache, releaseNSObject, NULL);
-    HASHMAP_DESTROY(trayIconCache);
-}
-//
-//// Callback for text menu items
-//void menuItemCallback(id self, SEL cmd, id sender) {
-//    MenuItemCallbackData *callbackData = (MenuItemCallbackData *)msg(msg(sender, s("representedObject")), s("pointerValue"));
-//    if( callbackData == NULL) {
-//        return;
-//    }
-//
-//    struct TrayMenuStore *store = callbackData->store;
-//    const char* menuItemID = callbackData->menuItemID;
-//    id nsmenu = GetMenuItemFromStore((TrayMenuStore *) store, menuItemID);
-//    if ( nsmenu == NULL ) {
-//        // The menu has been deleted!
-//        return;
-//    }
-//
-//    const char *message;
-//
-//    // Update checkbox / radio item
-//    if( callbackData->menuItemType == Checkbox) {
-//        // Toggle state
-//        bool state = msg(nsmenu, s("state"));
-//        msg(nsmenu, s("setState:"), (state? NSControlStateValueOff : NSControlStateValueOn));
-//    } else if( callbackData->menuItemType == Radio ) {
-//        // Check the menu items' current state
-//        bool selected = msg(nsmenu, s("state"));
-//
-//        // If it's already selected, exit early
-//        if (selected) return;
-//
-//        // Get this item's radio group members and turn them off
-//        id *members = (id*)hashmap_get(&(callbackData->menu->radioGroupMap), (char*)callbackData->menuItemID, strlen(callbackData->menuItemID));
-//
-//        // Uncheck all members of the group
-//        id thisMember = members[0];
-//        int count = 0;
-//        while(thisMember != NULL) {
-//            msg(thisMember, s("setState:"), NSControlStateValueOff);
-//            count = count + 1;
-//            thisMember = members[count];
-//        }
-//
-//        // check the selected menu item
-//        msg(nsmenu, s("setState:"), NSControlStateValueOn);
-//    }
-//
-//    message = createMenuClickedMessage(menuItemID, GetContextMenuDataFromStore((TrayMenuStore *) store));
-//
-//    // Notify the backend
-//    messageFromWindowCallback(message);
-//    MEMFREE(message);
-//}
+void processRadioGroupJSON(Menu *menu, JsonNode *radioGroup) {
 
-void PlatformMenuItemCallback(id self, SEL cmd, id sender) {
-    MenuItemCallbackData *callbackData = (MenuItemCallbackData *)msg(msg(sender, s("representedObject")), s("pointerValue"));
-    const char *message;
+    int groupLength;
+    getJSONInt(radioGroup, "Length", &groupLength);
+    JsonNode *members = json_find_member(radioGroup, "Members");
+    JsonNode *member;
 
-    MenuManager* manager = callbackData->manager;
-    MenuItem* menuItem = HASHMAP_GET(manager->menuItems, callbackData->menuItemID);
+    // Allocate array
+    size_t arrayLength = sizeof(id)*(groupLength+1);
+    id memberList[arrayLength];
 
-    if( menuItem == NULL ) return;
+    // 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;
 
-    MacMenuItem *macMenuItem = menuItem->platformData;
-    id nsMenuItem = macMenuItem->MenuItem;
-
-    // Update checkbox / radio item
-    if( callbackData->menuItemType == Checkbox) {
-        // Toggle state
-        bool state = msg(nsMenuItem, s("state"));
-        msg(nsMenuItem, s("setState:"), (state? NSControlStateValueOff : NSControlStateValueOn));
-    } else if( callbackData->menuItemType == Radio ) {
-        // Check the menu items' current state
-        bool selected = msg(nsMenuItem, s("state"));
-
-        // If it's already selected, exit early
-        if (selected) return;
-
-        int i=0; const char *groupMenuItemID;
-        vec_foreach(&menuItem->radioGroup, groupMenuItemID, i) {
-            // Get member
-            MenuItem* groupMember = HASHMAP_GET(manager->menuItems, groupMenuItemID);
-            MacMenuItem* groupMacMenuItem = (MacMenuItem*) groupMember->platformData;
-            msg(groupMacMenuItem->MenuItem, s("setState:"), NSControlStateValueOff);
-        }
-
-        // check the selected menu item
-        msg(nsMenuItem, s("setState:"), NSControlStateValueOn);
+    // 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);
     }
 
-    message = CreateMenuClickedMessage(callbackData->menuItemID, manager->contextMenuData);
-
-    // Notify the backend
-    messageFromWindowCallback(message);
-    MEMFREE(message);
 }
+
+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

@@ -1,21 +1,114 @@
 //
-// Created by Lea Anthony on 18/1/21.
+// Created by Lea Anthony on 6/1/21.
 //
 
+#ifndef MENU_DARWIN_H
+#define MENU_DARWIN_H
+
 #include "common.h"
-#include "menu.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",
+};
+
+typedef struct _NSRange {
+    unsigned long location;
+    unsigned long length;
+} NSRange;
+
+#define NSFontWeightUltraLight -0.8
+#define NSFontWeightThin -0.6
+#define NSFontWeightLight -0.4
+#define NSFontWeightRegular 0.0
+#define NSFontWeightMedium 0.23
+#define NSFontWeightSemibold 0.3
+#define NSFontWeightBold 0.4
+#define NSFontWeightHeavy 0.56
+#define NSFontWeightBlack 0.62
+
+extern void messageFromWindowCallback(const char *);
 
 typedef struct {
-    id Menu;
-} MacMenu;
+
+    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;
-} MacMenuItem;
+    id menuItem;
+    Menu *menu;
+    const char *menuID;
+    enum MenuItemType menuItemType;
+} MenuItemCallbackData;
 
-typedef struct {
-    id statusBarItem;
-    int iconPosition;
-} MacTrayMenu;
 
-void PlatformMenuItemCallback(id self, SEL cmd, id sender);
+
+// 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, const char* image, const char* fontName, int fontSize, const char* RGBA, bool templateImage);
+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/menu_darwin_old.c

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

v2/internal/ffenestri/menu_darwin_old.h

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

v2/internal/ffenestri/menu_item.c

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

v2/internal/ffenestri/menu_manager.c

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

v2/internal/ffenestri/menu_tray.c

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

v2/internal/ffenestri/test_app/CMakeLists.txt

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

v2/internal/ffenestri/test_menumanager/CMakeLists.txt

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

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

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

v2/internal/ffenestri/test_menumanager/minunit.h

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

v2/internal/ffenestri/test_menumanager/test.c

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

v2/internal/ffenestri/traymenu_darwin.c

@@ -10,7 +10,7 @@
 // Global because it's a singleton
 struct hashmap_s trayIconCache;
 
-TrayMenu* NewTrayMenu(const char* menuJSON, struct TrayMenuStore* store) {
+TrayMenu* NewTrayMenu(const char* menuJSON) {
     TrayMenu* result = malloc(sizeof(TrayMenu));
 
 /*
@@ -21,29 +21,26 @@ TrayMenu* NewTrayMenu(const char* menuJSON, struct TrayMenuStore* store) {
         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 = STRCOPY(mustJSONString(processedJSON, "I"));
-    result->label = STRCOPY(getJSONString(processedJSON, "l"));
-    result->icon = STRCOPY(getJSONString(processedJSON, "i"));
-    result->menu = NULL;
+    result->ID = mustJSONString(processedJSON, "ID");
+    result->label = mustJSONString(processedJSON, "Label");
+    result->icon = mustJSONString(processedJSON, "Icon");
+    JsonNode* processedMenu = mustJSONObject(processedJSON, "ProcessedMenu");
 
-    JsonNode* menu = getJSONObject(processedJSON, "m");
-    if( menu != NULL ) {
-
-        JsonNode* radioGroups = getJSONObject(processedJSON, "r");
-
-        // Create the menu
-        result->menu = NewMenu(menu, radioGroups, store);
-        result->menu->menuType = TrayMenuType;
-    }
+    // Create the menu
+    result->menu = NewMenu(processedMenu);
 
     // Init tray status bar item
     result->statusbaritem = NULL;
 
-    // Free JSON
-    json_delete(processedJSON);
+    // 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;
 }
@@ -53,6 +50,17 @@ void DumpTrayMenu(TrayMenu* trayMenu) {
 }
 
 
+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
@@ -96,9 +104,8 @@ void ShowTrayMenu(TrayMenu* trayMenu) {
     UpdateTrayLabel(trayMenu, trayMenu->label);
 
     // Update the menu
-    if (trayMenu->menu != NULL ) {
-        msg(trayMenu->statusbaritem, s("setMenu:"), trayMenu->menu->menu);
-    }
+    id menu = GetMenu(trayMenu->menu);
+    msg(trayMenu->statusbaritem, s("setMenu:"), menu);
 }
 
 // UpdateTrayMenuInPlace receives 2 menus. The current menu gets
@@ -111,11 +118,17 @@ void UpdateTrayMenuInPlace(TrayMenu* currentMenu, TrayMenu* newMenu) {
     // 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 = STRCOPY(newMenu->ID);
-    currentMenu->label = STRCOPY(newMenu->label);
+    currentMenu->ID = newMenu->ID;
+    currentMenu->label = newMenu->label;
     currentMenu->trayIconPosition = newMenu->trayIconPosition;
-    currentMenu->icon = STRCOPY(newMenu->icon);
+    currentMenu->icon = newMenu->icon;
 
 }
 
@@ -127,10 +140,10 @@ void DeleteTrayMenu(TrayMenu* trayMenu) {
     // Delete the menu
     DeleteMenu(trayMenu->menu);
 
-    // Free strings
-    MEMFREE(trayMenu->label);
-    MEMFREE(trayMenu->icon);
-    MEMFREE(trayMenu->ID);
+    // Free JSON
+    if (trayMenu->processedJSON != NULL ) {
+        json_delete(trayMenu->processedJSON);
+    }
 
     // Free the status item
     if ( trayMenu->statusbaritem != NULL ) {
@@ -176,3 +189,14 @@ void LoadTrayIcons() {
     }
 }
 
+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

@@ -6,7 +6,7 @@
 #define TRAYMENU_DARWIN_H
 
 #include "common.h"
-#include "menu_darwin_old.h"
+#include "menu_darwin.h"
 
 typedef struct {
 
@@ -18,9 +18,12 @@ typedef struct {
 
     id statusbaritem;
     int trayIconPosition;
+
+    JsonNode* processedJSON;
+
 } TrayMenu;
 
-TrayMenu* NewTrayMenu(const char *trayJSON, struct TrayMenuStore* store);
+TrayMenu* NewTrayMenu(const char *trayJSON);
 void DumpTrayMenu(TrayMenu* trayMenu);
 void ShowTrayMenu(TrayMenu* trayMenu);
 void UpdateTrayMenuInPlace(TrayMenu* currentMenu, TrayMenu* newMenu);

v2/internal/ffenestri/traymenustore_darwin.c

@@ -16,11 +16,6 @@ TrayMenuStore* NewTrayMenuStore() {
         ABORT("[NewTrayMenuStore] Not enough memory to allocate trayMenuMap!");
     }
 
-    // Allocate menu item store
-    if( 0 != hashmap_create((const unsigned)8, &result->menuItemMap)) {
-        ABORT("[NewTrayMenuStore] Not enough memory to allocate menuItemMap!");
-    }
-
     return result;
 }
 
@@ -34,7 +29,7 @@ void DumpTrayMenuStore(TrayMenuStore* store) {
 }
 
 void AddTrayMenuToStore(TrayMenuStore* store, const char* menuJSON) {
-    TrayMenu* newMenu = NewTrayMenu(menuJSON, (struct TrayMenuStore *) store);
+    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);
@@ -70,9 +65,6 @@ void DeleteTrayMenuStore(TrayMenuStore *store) {
 
     // Destroy tray menu map
     hashmap_destroy(&store->trayMenuMap);
-
-    // Destroy menu item map
-    hashmap_destroy(&store->menuItemMap);
 }
 
 TrayMenu* GetTrayMenuFromStore(TrayMenuStore* store, const char* menuID) {
@@ -89,15 +81,6 @@ TrayMenu* MustGetTrayMenuFromStore(TrayMenuStore* store, const char* menuID) {
     return result;
 }
 
-id GetMenuItemFromStore(TrayMenuStore* store, const char* menuItemID) {
-    return hashmap_get(&store->menuItemMap, menuItemID, strlen(menuItemID));
-}
-
-void SaveMenuItemInStore(TrayMenuStore* store, const char* menuItemID, id nsmenuitem) {
-    hashmap_put(&store->menuItemMap, menuItemID, strlen(menuItemID), nsmenuitem);
-}
-
-
 void UpdateTrayMenuLabelInStore(TrayMenuStore* store, const char* JSON) {
     // Parse the JSON
     JsonNode *parsedUpdate = mustParseJSON(JSON);
@@ -112,8 +95,9 @@ void UpdateTrayMenuLabelInStore(TrayMenuStore* store, const char* JSON) {
 
 }
 
-TrayMenu* UpdateTrayMenuInStore(TrayMenuStore* store, const char* menuJSON) {
-    TrayMenu* newMenu = NewTrayMenu(menuJSON, (struct TrayMenuStore *) store);
+void UpdateTrayMenuInStore(TrayMenuStore* store, const char* menuJSON) {
+    TrayMenu* newMenu = NewTrayMenu(menuJSON);
+//    DumpTrayMenu(newMenu);
 
     // Get the current menu
     TrayMenu *currentMenu = GetTrayMenuFromStore(store, newMenu->ID);
@@ -123,8 +107,11 @@ TrayMenu* UpdateTrayMenuInStore(TrayMenuStore* store, const char* menuJSON) {
         // Store the new menu
         hashmap_put(&store->trayMenuMap, newMenu->ID, strlen(newMenu->ID), newMenu);
 
-        return newMenu;
+        // Show it
+        ShowTrayMenu(newMenu);
+        return;
     }
+//    DumpTrayMenu(currentMenu);
 
     // Save the status bar reference
     newMenu->statusbaritem = currentMenu->statusbaritem;
@@ -140,11 +127,7 @@ TrayMenu* UpdateTrayMenuInStore(TrayMenuStore* store, const char* menuJSON) {
 
     hashmap_put(&store->trayMenuMap, newMenu->ID, strlen(newMenu->ID), newMenu);
 
-    return newMenu;
+    // Show the updated menu
+    ShowTrayMenu(newMenu);
 
 }
-
-const char* GetContextMenuDataFromStore(TrayMenuStore *store) {
-    return store->contextMenuData;
-}
-

v2/internal/ffenestri/traymenustore_darwin.h

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

v2/internal/ffenestri/vec.h

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

v2/internal/github/github.go

@@ -0,0 +1,103 @@
+package github
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"sort"
+	"strings"
+)
+
+// GetVersionTags gets the list of tags on the Wails repo
+// It returns a list of sorted tags in descending order
+func GetVersionTags() ([]*SemanticVersion, error) {
+
+	result := []*SemanticVersion{}
+	var err error
+
+	resp, err := http.Get("https://api.github.com/repos/wailsapp/wails/tags")
+	if err != nil {
+		return result, err
+	}
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return result, err
+	}
+
+	data := []map[string]interface{}{}
+	err = json.Unmarshal(body, &data)
+	if err != nil {
+		return result, err
+	}
+
+	// Convert tag data to Version structs
+	for _, tag := range data {
+		version := tag["name"].(string)
+		if !strings.HasPrefix(version, "v2") {
+			continue
+		}
+		semver, err := NewSemanticVersion(version)
+		if err != nil {
+			return result, err
+		}
+		result = append(result, semver)
+	}
+
+	// Reverse Sort
+	sort.Sort(sort.Reverse(SemverCollection(result)))
+
+	return result, err
+}
+
+// GetLatestStableRelease gets the latest stable release on GitHub
+func GetLatestStableRelease() (result *SemanticVersion, err error) {
+
+	tags, err := GetVersionTags()
+	if err != nil {
+		return nil, err
+	}
+
+	for _, tag := range tags {
+		if tag.IsRelease() {
+			return tag, nil
+		}
+	}
+
+	return nil, fmt.Errorf("no release tag found")
+}
+
+// GetLatestPreRelease gets the latest prerelease on GitHub
+func GetLatestPreRelease() (result *SemanticVersion, err error) {
+
+	tags, err := GetVersionTags()
+	if err != nil {
+		return nil, err
+	}
+
+	for _, tag := range tags {
+		if tag.IsPreRelease() {
+			return tag, nil
+		}
+	}
+
+	return nil, fmt.Errorf("no prerelease tag found")
+}
+
+// IsValidTag returns true if the given string is a valid tag
+func IsValidTag(tagVersion string) (bool, error) {
+	if tagVersion[0] == 'v' {
+		tagVersion = tagVersion[1:]
+	}
+	tags, err := GetVersionTags()
+	if err != nil {
+		return false, err
+	}
+
+	for _, tag := range tags {
+		if tag.String() == tagVersion {
+			return true, nil
+		}
+	}
+	return false, nil
+}

v2/internal/github/semver.go

@@ -0,0 +1,106 @@
+package github
+
+import (
+	"fmt"
+
+	"github.com/Masterminds/semver"
+)
+
+// SemanticVersion is a struct containing a semantic version
+type SemanticVersion struct {
+	Version *semver.Version
+}
+
+// NewSemanticVersion creates a new SemanticVersion object with the given version string
+func NewSemanticVersion(version string) (*SemanticVersion, error) {
+	semverVersion, err := semver.NewVersion(version)
+	if err != nil {
+		return nil, err
+	}
+	return &SemanticVersion{
+		Version: semverVersion,
+	}, nil
+}
+
+// IsRelease returns true if it's a release version
+func (s *SemanticVersion) IsRelease() bool {
+	// Limit to v2
+	if s.Version.Major() != 2 {
+		return false
+	}
+	return len(s.Version.Prerelease()) == 0 && len(s.Version.Metadata()) == 0
+}
+
+// IsPreRelease returns true if it's a prerelease version
+func (s *SemanticVersion) IsPreRelease() bool {
+	// Limit to v1
+	if s.Version.Major() != 2 {
+		return false
+	}
+	return len(s.Version.Prerelease()) > 0
+}
+
+func (s *SemanticVersion) String() string {
+	return s.Version.String()
+}
+
+// IsGreaterThan returns true if this version is greater than the given version
+func (s *SemanticVersion) IsGreaterThan(version *SemanticVersion) (bool, error) {
+	// Set up new constraint
+	constraint, err := semver.NewConstraint("> " + version.Version.String())
+	if err != nil {
+		return false, err
+	}
+
+	// Check if the desired one is greater than the requested on
+	success, msgs := constraint.Validate(s.Version)
+	if !success {
+		return false, msgs[0]
+	}
+	return true, nil
+}
+
+// IsGreaterThanOrEqual returns true if this version is greater than or equal the given version
+func (s *SemanticVersion) IsGreaterThanOrEqual(version *SemanticVersion) (bool, error) {
+	// Set up new constraint
+	constraint, err := semver.NewConstraint(">= " + version.Version.String())
+	if err != nil {
+		return false, err
+	}
+
+	// Check if the desired one is greater than the requested on
+	success, msgs := constraint.Validate(s.Version)
+	if !success {
+		return false, msgs[0]
+	}
+	return true, nil
+}
+
+// MainVersion returns the main version of any version+prerelease+metadata
+// EG: MainVersion("1.2.3-pre") => "1.2.3"
+func (s *SemanticVersion) MainVersion() *SemanticVersion {
+	mainVersion := fmt.Sprintf("%d.%d.%d", s.Version.Major(), s.Version.Minor(), s.Version.Patch())
+	result, _ := NewSemanticVersion(mainVersion)
+	return result
+}
+
+// SemverCollection is a collection of SemanticVersion objects
+type SemverCollection []*SemanticVersion
+
+// Len returns the length of a collection. The number of Version instances
+// on the slice.
+func (c SemverCollection) Len() int {
+	return len(c)
+}
+
+// Less is needed for the sort interface to compare two Version objects on the
+// slice. If checks if one is less than the other.
+func (c SemverCollection) Less(i, j int) bool {
+	return c[i].Version.LessThan(c[j].Version)
+}
+
+// Swap is needed for the sort interface to replace the Version objects
+// at two different positions in the slice.
+func (c SemverCollection) Swap(i, j int) {
+	c[i], c[j] = c[j], c[i]
+}

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

@@ -1,65 +1,60 @@
 package menumanager
 
-import "github.com/wailsapp/wails/v2/pkg/menu"
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/wailsapp/wails/v2/pkg/menu"
+)
+
+type ContextMenu struct {
+	ID            string
+	ProcessedMenu *WailsMenu
+	menuItemMap   *MenuItemMap
+	menu          *menu.Menu
+}
+
+func (t *ContextMenu) AsJSON() (string, error) {
+	data, err := json.Marshal(t)
+	if err != nil {
+		return "", err
+	}
+	return string(data), nil
+}
+
+func 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
+}
 
-//
-//import (
-//	"encoding/json"
-//	"fmt"
-//	"github.com/wailsapp/wails/v2/pkg/menu"
-//)
-//
-//type ContextMenu struct {
-//	ID            string
-//	ProcessedMenu *WailsMenu
-//	menuItemMap   *MenuItemMap
-//	menu          *menu.Menu
-//}
-//
-//func (t *ContextMenu) AsJSON() (string, error) {
-//	data, err := json.Marshal(t)
-//	if err != nil {
-//		return "", err
-//	}
-//	return string(data), nil
-//}
-//
-//func (m *Manager) NewContextMenu(contextMenu *menu.ContextMenu) *ContextMenu {
-//
-//	result := &ContextMenu{
-//		ID:          contextMenu.ID,
-//		menu:        contextMenu.Menu,
-//		menuItemMap: NewMenuItemMap(),
-//	}
-//
-//	result.menuItemMap.AddMenu(contextMenu.Menu)
-//	result.ProcessedMenu = m.NewWailsMenu(result.menuItemMap, result.menu)
-//
-//	return result
-//}
-//
 func (m *Manager) AddContextMenu(contextMenu *menu.ContextMenu) {
-	//
-	//	newContextMenu := m.NewContextMenu(contextMenu)
-	//
-	//	// Save the references
-	//	m.contextMenus[contextMenu.ID] = newContextMenu
-	//	m.contextMenuPointers[contextMenu] = contextMenu.ID
+
+	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 := m.NewContextMenu(contextMenu)
-	//
-	//	// Save the reference
-	//	m.contextMenus[contextMenuID] = updatedContextMenu
-	//
-	//	return updatedContextMenu.AsJSON()
-	return "", nil
+	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

@@ -2,53 +2,89 @@ package menumanager
 
 import (
 	"fmt"
-	"github.com/wailsapp/wails/v2/internal/counter"
 	"github.com/wailsapp/wails/v2/pkg/menu"
 )
 
 type Manager struct {
 
-	// MenuItemMap is a map of all menu items against a generated ID
-	menuItemMap        map[string]*menu.MenuItem
-	menuItemIDCounter  *counter.Counter
-	processedMenuItems map[*menu.MenuItem]*ProcessedMenuItem
+	// The application menu.
+	applicationMenu     *menu.Menu
+	applicationMenuJSON string
 
-	// Menus
-	menuIDCounter *counter.Counter
+	// Our application menu mappings
+	applicationMenuItemMap *MenuItemMap
 
-	// Map wails menus to internal menus
-	trayMenuMap       map[*menu.TrayMenu]*TrayMenu
-	trayMenuIDCounter *counter.Counter
+	// 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{
-		trayMenuMap:        make(map[*menu.TrayMenu]*TrayMenu),
-		trayMenuIDCounter:  counter.NewCounter(0),
-		menuIDCounter:      counter.NewCounter(0),
-		menuItemMap:        make(map[string]*menu.MenuItem),
-		menuItemIDCounter:  counter.NewCounter(0),
-		processedMenuItems: make(map[*menu.MenuItem]*ProcessedMenuItem),
+		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) ProcessClick(menuID string, data string) error {
-	// Get item from callback map
-	menuItem := m.menuItemMap[menuID]
+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("menuItem doesn't exist")
+		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 {
-		return fmt.Errorf("menuItem 'does not have a callback")
+		// No callback
+		return fmt.Errorf("No callback for menu '%s'", menuItem.Label)
 	}
 
+	// Create new Callback struct
 	callbackData := &menu.CallbackData{
 		MenuItem:    menuItem,
 		ContextData: data,
 	}
 
-	// Callback!
+	// Call back!
 	go menuItem.Click(callbackData)
+
 	return nil
 }

v2/internal/menumanager/processedMenu.go

@@ -2,165 +2,86 @@ package menumanager
 
 import (
 	"encoding/json"
-	"fmt"
+
 	"github.com/wailsapp/wails/v2/pkg/menu"
 	"github.com/wailsapp/wails/v2/pkg/menu/keys"
 )
 
-type ProcessedMenu struct {
-	ID string `json:"I"`
-
-	Items       []*ProcessedMenuItem `json:"i,omitempty"`
-	RadioGroups []*RadioGroup        `json:"r,omitempty"`
-}
-
-func (m *Manager) ProcessMenu(menu *menu.Menu) *ProcessedMenu {
-	wm := m.NewWailsMenu(menu)
-
-	if len(wm.Menu) == 0 {
-		return nil
-	}
-
-	return &ProcessedMenu{
-		ID:          m.generateMenuID(),
-		Items:       wm.Menu,
-		RadioGroups: wm.RadioGroups,
-	}
-}
-
 type ProcessedMenuItem struct {
-	// ID of the menu item
-	ID string `json:"I"`
-
+	ID string
 	// Label is what appears as the menu text
-	Label string `json:"l,omitempty"`
-
-	// AlternateLabel is a secondary label (Used by Mac)
-	AlternateLabel string `json:"L,omitempty"`
-
+	Label string `json:",omitempty"`
 	// Role is a predefined menu type
-	Role menu.Role `json:"r,omitempty"`
-
+	Role menu.Role `json:",omitempty"`
 	// Accelerator holds a representation of a key binding
-	Accelerator *keys.Accelerator `json:"a,omitempty"`
-
+	Accelerator *keys.Accelerator `json:",omitempty"`
 	// Type of MenuItem, EG: Checkbox, Text, Separator, Radio, Submenu
-	Type menu.Type `json:"t,omitempty"`
-
-	// Font to use for the menu item
-	Font string `json:"f,omitempty"`
-
-	// Font to use for the menu item
-	FontSize int `json:"F,omitempty"`
-
-	// RGBA is the colour of the menu item
-	RGBA string `json:"R,omitempty"`
-
-	// Image is an image for the menu item (base64 string)
-	Image string `json:"i,omitempty"`
-
+	Type menu.Type
 	// Disabled makes the item unselectable
-	Disabled *bool `json:"d,omitempty"`
-
+	Disabled bool `json:",omitempty"`
 	// Hidden ensures that the item is not shown in the menu
-	Hidden *bool `json:"h,omitempty"`
-
+	Hidden bool `json:",omitempty"`
 	// Checked indicates if the item is selected (used by Checkbox and Radio types only)
-	Checked *bool `json:"c,omitempty"`
-
+	Checked bool `json:",omitempty"`
 	// Submenu contains a list of menu items that will be shown as a submenu
 	//SubMenu []*MenuItem `json:"SubMenu,omitempty"`
-	SubMenu []*ProcessedMenuItem `json:"s,omitempty"`
+	SubMenu *ProcessedMenu `json:",omitempty"`
 
-	// Indicates if this item has a callback
-	HasCallback *bool `json:"C,omitempty"`
+	// Colour
+	RGBA string `json:",omitempty"`
+
+	// Font
+	FontSize int    `json:",omitempty"`
+	FontName string `json:",omitempty"`
+
+	// Image - base64 image data
+	Image            string `json:",omitempty"`
+	MacTemplateImage bool   `json:", omitempty"`
+
+	// Tooltip
+	Tooltip string `json:",omitempty"`
 }
 
-func (m *Manager) generateMenuItemID() string {
-	return fmt.Sprintf("%d", m.menuItemIDCounter.Increment())
-}
-
-func (m *Manager) generateMenuID() string {
-	return fmt.Sprintf("%d", m.menuIDCounter.Increment())
-}
-
-func (m *Manager) NewProcessedMenuItem(menuItem *menu.MenuItem) *ProcessedMenuItem {
-
-	// Check if this menu has already been processed.
-	// This is to prevent duplicates.
-	existingMenuItem := m.processedMenuItems[menuItem]
-	if existingMenuItem != nil {
-		return &ProcessedMenuItem{ID: existingMenuItem.ID}
-	}
-
-	ID := m.generateMenuItemID()
+func NewProcessedMenuItem(menuItemMap *MenuItemMap, menuItem *menu.MenuItem) *ProcessedMenuItem {
 
+	ID := menuItemMap.menuItemToIDMap[menuItem]
 	result := &ProcessedMenuItem{
-		ID:             ID,
-		Label:          menuItem.Label,
-		AlternateLabel: menuItem.AlternateLabel,
-		Role:           menuItem.Role,
-		Accelerator:    menuItem.Accelerator,
-		Type:           menuItem.Type,
-		Font:           menuItem.Font,
-		FontSize:       menuItem.FontSize,
-		RGBA:           menuItem.RGBA,
-		Image:          menuItem.Image,
-		Disabled:       nil,
-		Hidden:         nil,
-		Checked:        nil,
-		SubMenu:        nil,
-		HasCallback:    nil,
-	}
-
-	if menuItem.Hidden {
-		result.Hidden = new(bool)
-		*result.Hidden = true
-	}
-
-	if menuItem.Disabled {
-		result.Disabled = new(bool)
-		*result.Disabled = true
-	}
-
-	if menuItem.Checked {
-		result.Checked = new(bool)
-		*result.Checked = true
-	}
-
-	if menuItem.Click != nil {
-		result.HasCallback = new(bool)
-		*result.HasCallback = true
+		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,
+		MacTemplateImage: menuItem.MacTemplateImage,
+		Tooltip:          menuItem.Tooltip,
 	}
 
 	if menuItem.SubMenu != nil {
-		result.SubMenu = m.NewProcessedMenu(menuItem.SubMenu)
+		result.SubMenu = NewProcessedMenu(menuItemMap, menuItem.SubMenu)
 	}
 
-	// Add menu item to item map
-	m.menuItemMap[ID] = menuItem
-
-	// Add processed Item to processedMenuItems
-	m.processedMenuItems[menuItem] = result
-
 	return result
 }
 
-func (m *Manager) NewProcessedMenu(menu *menu.Menu) []*ProcessedMenuItem {
+type ProcessedMenu struct {
+	Items []*ProcessedMenuItem
+}
 
-	if menu == nil {
-		return nil
-	}
+func NewProcessedMenu(menuItemMap *MenuItemMap, menu *menu.Menu) *ProcessedMenu {
 
-	if menu.Items == nil {
-		return nil
-	}
-
-	var result []*ProcessedMenuItem
-
-	for _, item := range menu.Items {
-		processedMenuItem := m.NewProcessedMenuItem(item)
-		result = append(result, processedMenuItem)
+	result := &ProcessedMenu{}
+	if menu != nil {
+		for _, item := range menu.Items {
+			processedMenuItem := NewProcessedMenuItem(menuItemMap, item)
+			result.Items = append(result.Items, processedMenuItem)
+		}
 	}
 
 	return result
@@ -169,8 +90,8 @@ func (m *Manager) NewProcessedMenu(menu *menu.Menu) []*ProcessedMenuItem {
 // WailsMenu is the original menu with the addition
 // of radio groups extracted from the menu data
 type WailsMenu struct {
-	Menu              []*ProcessedMenuItem `json:",omitempty"`
-	RadioGroups       []*RadioGroup        `json:",omitempty"`
+	Menu              *ProcessedMenu
+	RadioGroups       []*RadioGroup
 	currentRadioGroup []string
 }
 
@@ -180,12 +101,11 @@ type RadioGroup struct {
 	Length  int
 }
 
-func (m *Manager) NewWailsMenu(menu *menu.Menu) *WailsMenu {
-
+func NewWailsMenu(menuItemMap *MenuItemMap, menu *menu.Menu) *WailsMenu {
 	result := &WailsMenu{}
 
 	// Process the menus
-	result.Menu = m.NewProcessedMenu(menu)
+	result.Menu = NewProcessedMenu(menuItemMap, menu)
 
 	// Process the radio groups
 	result.processRadioGroups()
@@ -202,7 +122,17 @@ func (w *WailsMenu) AsJSON() (string, error) {
 	return string(menuAsJSON), nil
 }
 
-func (w *WailsMenu) processMenuItemForRadioGroups(item *ProcessedMenuItem) {
+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 {
 
@@ -213,8 +143,8 @@ func (w *WailsMenu) processMenuItemForRadioGroups(item *ProcessedMenuItem) {
 		w.finaliseRadioGroup()
 
 		// Process each submenu item
-		for _, subitem := range item.SubMenu {
-			w.processMenuItemForRadioGroups(subitem)
+		for _, subitem := range item.SubMenu.Items {
+			w.processMenuItem(subitem)
 		}
 	case menu.RadioType:
 		// Add the item to the radio group
@@ -224,20 +154,6 @@ func (w *WailsMenu) processMenuItemForRadioGroups(item *ProcessedMenuItem) {
 	}
 }
 
-func (w *WailsMenu) processRadioGroups() {
-
-	if w.Menu == nil {
-		return
-	}
-	// Loop over top level menus
-	for _, item := range w.Menu {
-		// Process MenuItem
-		w.processMenuItemForRadioGroups(item)
-	}
-
-	w.finaliseRadioGroup()
-}
-
 func (w *WailsMenu) finaliseRadioGroup() {
 
 	// If we were processing a radio group, fix up the references

v2/internal/menumanager/traymenu.go

@@ -3,14 +3,29 @@ 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         `json:"I"`
-	Label string         `json:"l,omitempty"`
-	Icon  string         `json:"i,omitempty"`
-	Menu  *ProcessedMenu `json:"m,omitempty"`
+	ID            string
+	Label         string
+	Icon          string
+	menuItemMap   *MenuItemMap
+	menu          *menu.Menu
+	ProcessedMenu *WailsMenu
 }
 
 func (t *TrayMenu) AsJSON() (string, error) {
@@ -21,44 +36,55 @@ func (t *TrayMenu) AsJSON() (string, error) {
 	return string(data), nil
 }
 
-func (m *Manager) newTrayMenu(trayMenu *menu.TrayMenu) *TrayMenu {
+func NewTrayMenu(trayMenu *menu.TrayMenu) *TrayMenu {
 
-	result := TrayMenu{
-		ID:    m.generateTrayID(),
-		Label: trayMenu.Label,
-		Icon:  trayMenu.Icon,
-		Menu:  m.ProcessMenu(trayMenu.Menu),
+	result := &TrayMenu{
+		Label:       trayMenu.Label,
+		Icon:        trayMenu.Icon,
+		menu:        trayMenu.Menu,
+		menuItemMap: NewMenuItemMap(),
 	}
 
-	return &result
-}
-
-func (m *Manager) AddTrayMenu(trayMenu *menu.TrayMenu) *TrayMenu {
-
-	result := m.newTrayMenu(trayMenu)
-
-	// Add to map
-	m.trayMenuMap[trayMenu] = result
+	result.menuItemMap.AddMenu(trayMenu.Menu)
+	result.ProcessedMenu = NewWailsMenu(result.menuItemMap, result.menu)
 
 	return result
 }
 
-func (m *Manager) generateTrayID() string {
-	return fmt.Sprintf("T%d", m.trayMenuIDCounter.Increment())
+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()
 }
 
-func (m *Manager) GetTrayMenus() ([]*TrayMenu, error) {
-	var result []*TrayMenu
-	for _, trayMenu := range m.trayMenuMap {
-		result = append(result, trayMenu)
+// 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)
 	}
 
-	return result, nil
+	// Create the updated tray menu
+	updatedTrayMenu := NewTrayMenu(trayMenu)
+	updatedTrayMenu.ID = trayID
+
+	// Save the reference
+	m.trayMenus[trayID] = updatedTrayMenu
+
+	return updatedTrayMenu.AsJSON()
 }
 
-func (m *Manager) GetTrayMenusAsJSON() ([]string, error) {
-	var result []string
-	for _, trayMenu := range m.trayMenuMap {
+func (m *Manager) GetTrayMenus() ([]string, error) {
+	result := []string{}
+	for _, trayMenu := range m.trayMenus {
 		JSON, err := trayMenu.AsJSON()
 		if err != nil {
 			return nil, err
@@ -69,11 +95,40 @@ func (m *Manager) GetTrayMenusAsJSON() ([]string, error) {
 	return result, nil
 }
 
-// SetTrayMenu updates or creates a menu
-func (m *Manager) SetTrayMenu(trayMenu *menu.TrayMenu) (string, error) {
-	return "", nil
+func (m *Manager) UpdateTrayMenuLabel(trayMenu *menu.TrayMenu) (string, error) {
+	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) UpdateTrayMenuLabel(trayMenu *menu.TrayMenu) (string, error) {
-	return "", 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/menumanager/traymenu_test.go

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

v2/internal/messagedispatcher/dispatchclient.go

@@ -2,6 +2,7 @@ package messagedispatcher
 
 import (
 	"fmt"
+
 	"github.com/wailsapp/wails/v2/internal/logger"
 	"github.com/wailsapp/wails/v2/internal/messagedispatcher/message"
 	"github.com/wailsapp/wails/v2/internal/servicebus"
@@ -26,6 +27,8 @@ type Client interface {
 	WindowUnminimise()
 	WindowPosition(x int, y int)
 	WindowSize(width int, height int)
+	WindowSetMinSize(width int, height int)
+	WindowSetMaxSize(width int, height int)
 	WindowFullscreen()
 	WindowUnFullscreen()
 	WindowSetColour(colour int)

v2/internal/messagedispatcher/message/dialog.go

@@ -27,7 +27,7 @@ func dialogMessageParser(message string) (*parsedMessage, error) {
 		if idx < 0 {
 			return nil, fmt.Errorf("Invalid dialog response message format: %+v", message)
 		}
-		callbackID := message[:idx+1]
+		callbackID := message[:idx]
 		payloadData := message[idx+1:]
 
 		switch dialogType {

v2/internal/messagedispatcher/messagedispatcher.go

@@ -1,12 +1,14 @@
 package messagedispatcher
 
 import (
+	"context"
 	"encoding/json"
-	"github.com/wailsapp/wails/v2/pkg/options/dialog"
 	"strconv"
 	"strings"
 	"sync"
 
+	"github.com/wailsapp/wails/v2/pkg/options/dialog"
+
 	"github.com/wailsapp/wails/v2/internal/crypto"
 	"github.com/wailsapp/wails/v2/internal/logger"
 	"github.com/wailsapp/wails/v2/internal/messagedispatcher/message"
@@ -23,7 +25,6 @@ type Dispatcher struct {
 	dialogChannel <-chan *servicebus.Message
 	systemChannel <-chan *servicebus.Message
 	menuChannel   <-chan *servicebus.Message
-	running       bool
 
 	servicebus *servicebus.ServiceBus
 	logger     logger.CustomLogger
@@ -31,6 +32,13 @@ type Dispatcher struct {
 	// Clients
 	clients map[string]*DispatchClient
 	lock    sync.RWMutex
+
+	// Context for cancellation
+	ctx    context.Context
+	cancel context.CancelFunc
+
+	// internal wait group
+	wg sync.WaitGroup
 }
 
 // New dispatcher. Needs a service bus to send to.
@@ -75,6 +83,9 @@ func New(servicebus *servicebus.ServiceBus, logger *logger.Logger) (*Dispatcher,
 		return nil, err
 	}
 
+	// Create context
+	ctx, cancel := context.WithCancel(context.Background())
+
 	result := &Dispatcher{
 		servicebus:    servicebus,
 		eventChannel:  eventChannel,
@@ -86,6 +97,8 @@ func New(servicebus *servicebus.ServiceBus, logger *logger.Logger) (*Dispatcher,
 		dialogChannel: dialogChannel,
 		systemChannel: systemChannel,
 		menuChannel:   menuChannel,
+		ctx:           ctx,
+		cancel:        cancel,
 	}
 
 	return result, nil
@@ -96,15 +109,18 @@ func (d *Dispatcher) Start() error {
 
 	d.logger.Trace("Starting")
 
-	d.running = true
+	d.wg.Add(1)
 
 	// Spin off a go routine
 	go func() {
-		for d.running {
+		defer d.logger.Trace("Shutdown")
+		for {
 			select {
+			case <-d.ctx.Done():
+				d.wg.Done()
+				return
 			case <-d.quitChannel:
 				d.processQuit()
-				d.running = false
 			case resultMessage := <-d.resultChannel:
 				d.processCallResult(resultMessage)
 			case eventMessage := <-d.eventChannel:
@@ -119,9 +135,6 @@ func (d *Dispatcher) Start() error {
 				d.processMenuMessage(menuMessage)
 			}
 		}
-
-		// Call shutdown
-		d.shutdown()
 	}()
 
 	return nil
@@ -135,10 +148,6 @@ func (d *Dispatcher) processQuit() {
 	}
 }
 
-func (d *Dispatcher) shutdown() {
-	d.logger.Trace("Shutdown")
-}
-
 // RegisterClient will register the given callback with the dispatcher
 // and return a DispatchClient that the caller can use to send messages
 func (d *Dispatcher) RegisterClient(client Client) *DispatchClient {
@@ -349,6 +358,38 @@ func (d *Dispatcher) processWindowMessage(result *servicebus.Message) {
 		for _, client := range d.clients {
 			client.frontend.WindowSize(w, h)
 		}
+	case "minsize":
+		// We need 2 arguments
+		if len(splitTopic) != 4 {
+			d.logger.Error("Invalid number of parameters for 'window:minsize' : %#v", result.Data())
+			return
+		}
+		w, err1 := strconv.Atoi(splitTopic[2])
+		h, err2 := strconv.Atoi(splitTopic[3])
+		if err1 != nil || err2 != nil {
+			d.logger.Error("Invalid integer parameters for 'window:minsize' : %#v", result.Data())
+			return
+		}
+		// Notifh clients
+		for _, client := range d.clients {
+			client.frontend.WindowSetMinSize(w, h)
+		}
+	case "maxsize":
+		// We need 2 arguments
+		if len(splitTopic) != 4 {
+			d.logger.Error("Invalid number of parameters for 'window:maxsize' : %#v", result.Data())
+			return
+		}
+		w, err1 := strconv.Atoi(splitTopic[2])
+		h, err2 := strconv.Atoi(splitTopic[3])
+		if err1 != nil || err2 != nil {
+			d.logger.Error("Invalid integer parameters for 'window:maxsize' : %#v", result.Data())
+			return
+		}
+		// Notifh clients
+		for _, client := range d.clients {
+			client.frontend.WindowSetMaxSize(w, h)
+		}
 	default:
 		d.logger.Error("Unknown window command: %s", command)
 	}
@@ -491,3 +532,8 @@ func (d *Dispatcher) processMenuMessage(result *servicebus.Message) {
 		d.logger.Error("Unknown menufrontend command: %s", command)
 	}
 }
+
+func (d *Dispatcher) Close() {
+	d.cancel()
+	d.wg.Wait()
+}

v2/internal/process/process.go

@@ -1,6 +1,8 @@
 package process
 
 import (
+	"context"
+	"os"
 	"os/exec"
 
 	"github.com/wailsapp/wails/v2/pkg/clilogger"
@@ -8,54 +10,54 @@ import (
 
 // Process defines a process that can be executed
 type Process struct {
-	logger      *clilogger.CLILogger
-	cmd         *exec.Cmd
-	exitChannel chan bool
-	Running     bool
+	logger  *clilogger.CLILogger
+	cmd     *exec.Cmd
+	running bool
 }
 
 // NewProcess creates a new process struct
-func NewProcess(logger *clilogger.CLILogger, cmd string, args ...string) *Process {
-	return &Process{
-		logger:      logger,
-		cmd:         exec.Command(cmd, args...),
-		exitChannel: make(chan bool, 1),
+func NewProcess(ctx context.Context, logger *clilogger.CLILogger, cmd string, args ...string) *Process {
+	result := &Process{
+		logger: logger,
+		cmd:    exec.CommandContext(ctx, cmd, args...),
 	}
+	result.cmd.Stdout = os.Stdout
+	result.cmd.Stderr = os.Stderr
+	return result
 }
 
 // Start the process
 func (p *Process) Start() error {
 
-	p.cmd.
 	err := p.cmd.Start()
 	if err != nil {
 		return err
 	}
 
-	p.Running = true
+	p.running = true
 
-	go func(cmd *exec.Cmd, running *bool, logger *clilogger.CLILogger, exitChannel chan bool) {
-		logger.Println("Starting process (PID: %d)", cmd.Process.Pid)
-		cmd.Wait()
-		logger.Println("Exiting process (PID: %d)", cmd.Process.Pid)
-		*running = false
-		exitChannel <- true
-	}(p.cmd, &p.Running, p.logger, p.exitChannel)
+	go func(p *Process) {
+		p.logger.Println("Starting process (PID: %d)", p.cmd.Process.Pid)
+		err := p.cmd.Wait()
+		if err != nil {
+			p.running = false
+			p.logger.Println("Process failed to run: %s", err.Error())
+			return
+		}
+		p.logger.Println("Exiting process (PID: %d)", p.cmd.Process.Pid)
+	}(p)
 
 	return nil
 }
 
 // Kill the process
 func (p *Process) Kill() error {
-	if !p.Running {
-		return nil
+	if p.running {
+		println("Calling kill")
+		p.running = false
+		return p.cmd.Process.Kill()
 	}
-	err := p.cmd.Process.Kill()
-
-	// Wait for command to exit properly
-	<-p.exitChannel
-
-	return err
+	return nil
 }
 
 // PID returns the process PID

v2/internal/runtime/js/core/bindings.js

@@ -65,7 +65,7 @@ export function SetBindings(bindingsMap) {
 				window.backend[packageName][structName][methodName] = function () {
 
 					// No timeout by default
-					var timeout = 0;
+					let timeout = 0;
 
 					// Actual function
 					function dynamic() {
@@ -89,19 +89,3 @@ export function SetBindings(bindingsMap) {
 		});
 	});
 }
-// /**
-//  * Determines if the given identifier is valid Javascript
-//  *
-//  * @param {boolean} name
-//  * @returns
-//  */
-// function isValidIdentifier(name) {
-// 	// Don't xss yourself :-)
-// 	try {
-// 		new Function('var ' + name);
-// 		return true;
-// 	} catch (e) {
-// 		return false;
-// 	}
-// }
-

v2/internal/runtime/js/core/desktop.js

@@ -10,6 +10,7 @@ The lightweight framework for web-like apps
 /* jshint esversion: 6 */
 import { SetBindings } from './bindings';
 import { Init } from './main';
+import {RaiseError} from '../desktop/darwin';
 
 // Setup global error handler
 window.onerror = function (msg, url, lineNo, columnNo, error) {
@@ -21,7 +22,7 @@ window.onerror = function (msg, url, lineNo, columnNo, error) {
 		error: JSON.stringify(error),
 		stack: function() { return JSON.stringify(new Error().stack); }(),
 	};
-	window.wails.Log.Error(JSON.stringify(errorMessage));
+	RaiseError(errorMessage);
 };
 
 // Initialise the Runtime

v2/internal/runtime/js/core/events.js

@@ -13,6 +13,7 @@ import { Error } from './log';
 import { SendMessage } from 'ipc';
 
 // Defines a single listener with a maximum number of times to callback
+
 /**
  * The Listener class defines a listener! :-)
  *
@@ -43,7 +44,7 @@ class Listener {
 	}
 }
 
-var eventListeners = {};
+let eventListeners = {};
 
 /**
  * Registers an event listener that will be invoked `maxCallbacks` times before being destroyed
@@ -96,7 +97,7 @@ export function Once(eventName, callback) {
 function notifyListeners(eventData) {
 
 	// Get the event name
-	var eventName = eventData.name;
+	let eventName = eventData.name;
 
 	// Check if we have any listeners for this event
 	if (eventListeners[eventName]) {
@@ -110,7 +111,7 @@ function notifyListeners(eventData) {
 			// Get next listener
 			const listener = eventListeners[eventName][count];
 
-			var data = eventData.data;
+			let data = eventData.data;
 
 			// Do the callback
 			const destroy = listener.Callback(data);
@@ -120,7 +121,7 @@ function notifyListeners(eventData) {
 			}
 		}
 
-		// Update callbacks with new list of listners
+		// Update callbacks with new list of listeners
 		eventListeners[eventName] = newEventListenerList;
 	}
 }

v2/internal/runtime/js/core/main.js

@@ -62,6 +62,4 @@ export function Init() {
 
 	// Do platform specific Init
 	Platform.Init();
-
-	window.wailsloader.runtime = true;
 }

v2/internal/runtime/js/desktop/darwin.js

@@ -25,6 +25,10 @@ export function SendMessage(message) {
     window.webkit.messageHandlers.external.postMessage(message);
 }
 
+export function RaiseError(message) {
+    window.webkit.messageHandlers.error.postMessage(message);
+}
+
 export function Init() {
 
     // Setup drag handler

v2/internal/runtime/js/desktop/linux.js

@@ -27,7 +27,7 @@ export function Init() {
     // Setup drag handler
     // Based on code from: https://github.com/patr0nus/DeskGap
     window.addEventListener('mousedown', function (e) {
-        var currentElement = e.target;
+        let currentElement = e.target;
         while (currentElement != null) {
             if (currentElement.hasAttribute('data-wails-no-drag')) {
                 break;

v2/internal/runtime/js/runtime/.npmignore

@@ -1 +1 @@
-bridge.js
+src

v2/internal/runtime/js/runtime/init.js

@@ -9,13 +9,25 @@ The lightweight framework for web-like apps
 */
 /* jshint esversion: 6 */
 
+import bridge from './bridge';
+
 /**
- * Initialises the Wails runtime
+ * ready will execute the callback when Wails has loaded
+ * and initialised.
  *
  * @param {function} callback
  */
-function Init(callback) {
-	window.wails._.Init(callback);
+function ready(callback) {
+
+	// If window.wails exists, we are ready
+	if( window.wails ) {
+		return callback();
+	}
+
+	// If not we need to setup the bridge
+	bridge.InitBridge(callback);
 }
 
-module.exports = Init;
+module.exports = {
+	ready: ready,
+};

v2/internal/runtime/js/runtime/main.js

@@ -23,7 +23,7 @@ module.exports = {
 	Browser: Browser,
 	Dialog: Dialog,
 	Events: Events,
-	Init: Init,
+	ready: Init.ready,
 	Log: Log,
 	System: System,
 	Store: Store,

v2/internal/runtime/js/runtime/package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@wails/runtime",
-  "version": "1.2.13",
+  "version": "1.2.24",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {

v2/internal/runtime/js/runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wails/runtime",
-  "version": "1.2.22",
+  "version": "1.3.9",
   "description": "Wails V2 Javascript runtime library",
   "main": "main.js",
   "types": "runtime.d.ts",

v2/internal/runtime/js/runtime/src/Menu.svelte

@@ -0,0 +1,74 @@
+<script>
+
+    export let menu;
+
+    console.log({menu})
+
+    export let visible = false;
+
+    function click(id) {
+        console.log("MenuItem", id, "pressed")
+    }
+</script>
+
+{#if visible}
+<div class="menu">
+    {#if menu.Menu }
+        {#each menu.Menu.Items as menuItem}
+            {#if menuItem.Type === "Text" }
+            <div class="menuitem" on:click={() => click(menuItem.ID)}>
+            {#if menuItem.Image }
+                <div><img alt="" src="data:image/png;base64,{menuItem.Image}"/></div>
+            {/if}
+                <div class="menulabel">{menuItem.Label}</div>
+            </div>
+            {:else if menuItem.Type === "Separator"}
+            <div class="separator"><hr/></div>
+            {/if}
+        {/each}
+    {/if}
+</div>
+{/if}
+
+<style>
+
+    .menu {
+        padding: 5px;
+        background-color: #0008;
+        color: #EEF;
+        border-radius: 5px;
+        margin-top: 5px;
+        position: absolute;
+        backdrop-filter: blur(3px) saturate(160%) contrast(45%) brightness(140%);
+        border: 1px solid rgb(88,88,88);
+        box-shadow: 0 0 1px rgb(146,146,148) inset;
+    }
+
+    .menuitem {
+        display: flex;
+        align-items: center;
+        padding: 1px 5px;
+    }
+
+    .menuitem:hover {
+        display: flex;
+        align-items: center;
+        background-color: rgb(57,131,223);
+        padding: 1px 5px;
+        border-radius: 5px;
+    }
+
+    .menuitem img {
+        padding-right: 5px;
+    }
+
+    .separator {
+        padding-top: 5px;
+        width: 100%;
+        padding-bottom: 5px;
+    }
+    .separator:hover {
+        background-color: #0000;
+    }
+
+</style>

v2/internal/runtime/js/runtime/src/Menubar.svelte

@@ -0,0 +1,61 @@
+<script>
+
+    import {menuVisible} from './store'
+    import {fade} from 'svelte/transition';
+
+    import {trays} from './store'
+    import TrayMenu from "./TrayMenu.svelte";
+    import {onMount} from "svelte";
+
+    let time = new Date();
+    $: day = time.toLocaleString("default", { weekday: "short" })
+    $: dom = time.getDate()
+    $: mon = time.toLocaleString("default", { month: "short" })
+    $: currentTime = time.toLocaleString('en-US', { hour: 'numeric', minute: 'numeric', hour12: true }).toLowerCase()
+    $: dateTimeString = `${day} ${dom} ${mon} ${currentTime}`
+
+    onMount(() => {
+        const interval = setInterval(() => {
+            time = new Date();
+        }, 1000);
+
+        return () => {
+            clearInterval(interval);
+        };
+    });
+
+</script>
+
+{#if $menuVisible }
+    <div class="wails-menubar" transition:fade>
+    <span class="tray-menus">
+    {#each $trays as tray}
+        <TrayMenu {tray}/>
+    {/each}
+    <span class="time">{dateTimeString}</span>
+    </span>
+    </div>
+{/if}
+
+<style>
+
+    .tray-menus {
+        display: flex;
+        flex-direction: row;
+        justify-content: flex-end;
+    }
+    .wails-menubar { position: relative;
+        display: block;
+        top: 0;
+        height: 2rem;
+        width: 100%;
+        border-bottom: 1px solid #b3b3b3;
+        box-shadow: 0 0 10px 0 #33333360;
+    }
+    .time {
+        padding-left: 0.5rem;
+        padding-right: 1.5rem;
+        overflow: visible;
+        font-size: 14px;
+    }
+</style>

v2/internal/runtime/js/runtime/src/Overlay.svelte

@@ -0,0 +1,55 @@
+<script>
+
+    import { overlayVisible } from './store'
+    import { fade,  } from 'svelte/transition';
+
+</script>
+
+{#if $overlayVisible }
+<div class="wails-reconnect-overlay" transition:fade="{{ duration: 200 }}">
+    <div class="wails-reconnect-overlay-content">
+        <div class="wails-reconnect-overlay-loadingspinner"></div>
+    </div>
+</div>
+{/if}
+
+<style>
+    .wails-reconnect-overlay {
+        position: fixed;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        backdrop-filter: blur(20px) saturate(160%) contrast(45%) brightness(140%);
+        z-index: 999999
+    }
+
+    .wails-reconnect-overlay-content {
+        position: relative;
+        top: 50%;
+        transform: translateY(-50%);
+        margin: 0;
+        background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAC8AAAAuCAMAAACPpbA7AAAAflBMVEUAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQAAAAAAAAAAAABAQEEBAQAAAAAAAAEBAQAAAADAwMAAAABAQEAAAAAAAAAAAAAAAAAAAACAgICAgIBAQEAAAAAAAAAAAAAAAAAAAACAgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBQWCC3waAAAAKXRSTlMALgUMIBk0+xEqJs70Xhb3lu3EjX2EZTlv5eHXvbarQj3cdmpXSqOeUDwaqNAAAAKCSURBVEjHjZTntqsgEIUPVVCwtxg1vfD+L3hHRe8K6snZf+KKn8OewvzsSSeXLruLnz+KHs0gr6DkT3xsRkU6VVn4Ha/UxLe1Z4y64i847sykPBh/AvQ7ry3eFN70oKrfcBJYvm/tQ1qxP4T3emXPeXAkvodPUvtdjbhk+Ft4c0hslTiXVOzxOJ15NWUblQhRsdu3E1AfCjj3Gdm18zSOsiH8Lk4TB480ksy62fiqNo4OpyU8O21l6+hyRtS6z8r1pHlmle5sR1/WXS6Mq2Nl+YeKt3vr+vdH/q4O68tzXuwkiZmngYb4R8Co1jh0+Ww2UTyWxBvtyxLO7QVjO3YOD/lWZpbXDGellFG2Mws58mMnjVZSn7p+XvZ6IF4nn02OJZV0aTO22arp/DgLPtrgpVoi6TPbZm4XQBjY159w02uO0BDdYsfrOEi0M2ulRXlCIPAOuN1NOVhi+riBR3dgwQplYsZRZJLXq23Mlo5njkbY0rZFu3oiNIYG2kqsbVz67OlNuZZIOlfxHDl0UpyRX86z/OYC/3qf1A1xTrMp/PWWM4ePzf8DDp1nesQRpcFk7BlwdzN08ZIALJpCaciQXO0f6k4dnuT/Ewg4l7qSTNzm2SykdHn6GJ12mWc6aCNj/g1cTXpB8YFfr0uVc96aFkkqiIiX4nO+salKwGtIkvfB+Ja8DxMeD3hIXP5mTOYPB4eVT0+32I5ykvPZjesnkGgIREgYnmLrPb0PdV3hoLup2TjcGBPM4mgsfF5BrawZR4/GpzYQzQfrUZCf0TCWYo2DqhdhTJBQ6j4xqmmLN5LjdRIY8LWExiFUsSrza/nmFBqw3I9tEZB9h0lIQSO9if8DkISDAj8CDawAAAAASUVORK5CYII=);
+        background-repeat: no-repeat;
+        background-position: center
+    }
+
+    .wails-reconnect-overlay-loadingspinner {
+        pointer-events: none;
+        width: 2.5em;
+        height: 2.5em;
+        border: .4em solid transparent;
+        border-color: #f00 #eee0 #f00 #eee0;
+        border-radius: 50%;
+        animation: loadingspin 1s linear infinite;
+        margin: auto;
+        padding: 2.5em
+    }
+
+    @keyframes loadingspin {
+        100% {
+            transform: rotate(360deg);
+        }
+    }
+
+</style>

v2/internal/runtime/js/runtime/src/TrayMenu.svelte

@@ -0,0 +1,66 @@
+<script>
+    import Menu from "./Menu.svelte";
+    import { selectedMenu } from "./store";
+
+    export let tray = null;
+
+    $: visible = $selectedMenu === tray;
+
+    function closeMenu() {
+        selectedMenu.set(null);
+    }
+
+    function trayClicked() {
+        if ( $selectedMenu !== tray ) {
+            selectedMenu.set(tray);
+        } else {
+            selectedMenu.set(null);
+        }
+    }
+    // Source: https://svelte.dev/repl/0ace7a508bd843b798ae599940a91783?version=3.16.7
+    /** Dispatch event on click outside of node */
+    function clickOutside(node) {
+
+        const handleClick = event => {
+            if (node && !node.contains(event.target) && !event.defaultPrevented) {
+                console.log("click outside of node")
+                node.dispatchEvent(
+                    new CustomEvent('click_outside', node)
+                )
+            }
+        }
+
+        document.addEventListener('click', handleClick, true);
+
+        return {
+            destroy() {
+                document.removeEventListener('click', handleClick, true);
+            }
+        }
+    }
+</script>
+
+<span class="tray-menu" use:clickOutside on:click_outside={closeMenu}>
+    <!--{#if tray.Image && tray.Image.length > 0}-->
+    <!--    <img alt="" src="data:image/png;base64,{tray.Image}"/>-->
+    <!--{/if}-->
+    <span class="label" on:click={trayClicked}>{tray.Label}</span>
+    {#if tray.ProcessedMenu }
+        <Menu menu="{tray.ProcessedMenu}" visible="{visible}"/>
+    {/if}
+</span>
+
+<style>
+
+    .tray-menu {
+        padding-left: 0.5rem;
+        padding-right: 0.5rem;
+        overflow: visible;
+        font-size: 14px;
+    }
+
+    .label {
+        text-align: right;
+        padding-right: 10px;
+    }
+</style>

v2/internal/runtime/js/runtime/src/log.js

@@ -0,0 +1,9 @@
+
+export function log(message) {
+    // eslint-disable-next-line
+    console.log(
+        '%c wails bridge %c ' + message + ' ',
+        'background: #aa0000; color: #fff; border-radius: 3px 0px 0px 3px; padding: 1px; font-size: 0.7rem',
+        'background: #009900; color: #fff; border-radius: 0px 3px 3px 0px; padding: 1px; font-size: 0.7rem'
+    );
+}

v2/internal/runtime/js/runtime/src/main.js

@@ -0,0 +1,45 @@
+/*
+ _       __      _ __
+| |     / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+/* jshint esversion: 6 */
+
+import Overlay from './Overlay.svelte';
+import MenuBar from './Menubar.svelte';
+import {showOverlay} from "./store";
+import {StartWebsocket} from "./websocket";
+
+let components = {};
+
+function setupMenuBar() {
+	components.menubar = new MenuBar({
+		target: document.body,
+	});
+}
+
+// Sets up the overlay
+function setupOverlay() {
+	components.overlay = new Overlay({
+		target: document.body,
+		anchor: document.querySelector('#wails-bridge'),
+	});
+}
+
+export function InitBridge(callback) {
+
+	setupMenuBar()
+
+	// Setup the overlay
+	setupOverlay();
+
+	// Start by showing the overlay...
+	showOverlay();
+
+	// ...and attempt to connect
+	StartWebsocket(callback);
+}

v2/internal/runtime/js/runtime/src/package-lock.json

@@ -0,0 +1,525 @@
+{
+  "name": "bridge",
+  "version": "1.0.0",
+  "lockfileVersion": 1,
+  "requires": true,
+  "dependencies": {
+    "@babel/code-frame": {
+      "version": "7.12.13",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.12.13.tgz",
+      "integrity": "sha512-HV1Cm0Q3ZrpCR93tkWOYiuYIgLxZXZFVG2VgK+MBWjUqZTundupbfx2aXarXuw5Ko5aMcjtJgbSs4vUGBS5v6g==",
+      "dev": true,
+      "requires": {
+        "@babel/highlight": "^7.12.13"
+      }
+    },
+    "@babel/helper-validator-identifier": {
+      "version": "7.12.11",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.12.11.tgz",
+      "integrity": "sha512-np/lG3uARFybkoHokJUmf1QfEvRVCPbmQeUQpKow5cQ3xWrV9i3rUHodKDJPQfTVX61qKi+UdYk8kik84n7XOw==",
+      "dev": true
+    },
+    "@babel/highlight": {
+      "version": "7.12.13",
+      "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.12.13.tgz",
+      "integrity": "sha512-kocDQvIbgMKlWxXe9fof3TQ+gkIPOUSEYhJjqUjvKMez3krV7vbzYCDq39Oj11UAVK7JqPVGQPlgE85dPNlQww==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-validator-identifier": "^7.12.11",
+        "chalk": "^2.0.0",
+        "js-tokens": "^4.0.0"
+      }
+    },
+    "@rollup/plugin-commonjs": {
+      "version": "17.1.0",
+      "resolved": "https://registry.npmjs.org/@rollup/plugin-commonjs/-/plugin-commonjs-17.1.0.tgz",
+      "integrity": "sha512-PoMdXCw0ZyvjpCMT5aV4nkL0QywxP29sODQsSGeDpr/oI49Qq9tRtAsb/LbYbDzFlOydVEqHmmZWFtXJEAX9ew==",
+      "dev": true,
+      "requires": {
+        "@rollup/pluginutils": "^3.1.0",
+        "commondir": "^1.0.1",
+        "estree-walker": "^2.0.1",
+        "glob": "^7.1.6",
+        "is-reference": "^1.2.1",
+        "magic-string": "^0.25.7",
+        "resolve": "^1.17.0"
+      },
+      "dependencies": {
+        "estree-walker": {
+          "version": "2.0.2",
+          "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz",
+          "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==",
+          "dev": true
+        }
+      }
+    },
+    "@rollup/plugin-node-resolve": {
+      "version": "11.1.1",
+      "resolved": "https://registry.npmjs.org/@rollup/plugin-node-resolve/-/plugin-node-resolve-11.1.1.tgz",
+      "integrity": "sha512-zlBXR4eRS+2m79TsUZWhsd0slrHUYdRx4JF+aVQm+MI0wsKdlpC2vlDVjmlGvtZY1vsefOT9w3JxvmWSBei+Lg==",
+      "dev": true,
+      "requires": {
+        "@rollup/pluginutils": "^3.1.0",
+        "@types/resolve": "1.17.1",
+        "builtin-modules": "^3.1.0",
+        "deepmerge": "^4.2.2",
+        "is-module": "^1.0.0",
+        "resolve": "^1.19.0"
+      }
+    },
+    "@rollup/pluginutils": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-3.1.0.tgz",
+      "integrity": "sha512-GksZ6pr6TpIjHm8h9lSQ8pi8BE9VeubNT0OMJ3B5uZJ8pz73NPiqOtCog/x2/QzM1ENChPKxMDhiQuRHsqc+lg==",
+      "dev": true,
+      "requires": {
+        "@types/estree": "0.0.39",
+        "estree-walker": "^1.0.1",
+        "picomatch": "^2.2.2"
+      }
+    },
+    "@types/estree": {
+      "version": "0.0.39",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-0.0.39.tgz",
+      "integrity": "sha512-EYNwp3bU+98cpU4lAWYYL7Zz+2gryWH1qbdDTidVd6hkiR6weksdbMadyXKXNPEkQFhXM+hVO9ZygomHXp+AIw==",
+      "dev": true
+    },
+    "@types/node": {
+      "version": "14.14.25",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-14.14.25.tgz",
+      "integrity": "sha512-EPpXLOVqDvisVxtlbvzfyqSsFeQxltFbluZNRndIb8tr9KiBnYNLzrc1N3pyKUCww2RNrfHDViqDWWE1LCJQtQ==",
+      "dev": true
+    },
+    "@types/resolve": {
+      "version": "1.17.1",
+      "resolved": "https://registry.npmjs.org/@types/resolve/-/resolve-1.17.1.tgz",
+      "integrity": "sha512-yy7HuzQhj0dhGpD8RLXSZWEkLsV9ibvxvi6EiJ3bkqLAO1RGo0WbkWQiwpRlSFymTJRz0d3k5LM3kkx8ArDbLw==",
+      "dev": true,
+      "requires": {
+        "@types/node": "*"
+      }
+    },
+    "ansi-styles": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
+      "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
+      "dev": true,
+      "requires": {
+        "color-convert": "^1.9.0"
+      }
+    },
+    "balanced-match": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz",
+      "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=",
+      "dev": true
+    },
+    "brace-expansion": {
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
+      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "dev": true,
+      "requires": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "buffer-from": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.1.tgz",
+      "integrity": "sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A==",
+      "dev": true
+    },
+    "builtin-modules": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/builtin-modules/-/builtin-modules-3.2.0.tgz",
+      "integrity": "sha512-lGzLKcioL90C7wMczpkY0n/oART3MbBa8R9OFGE1rJxoVI86u4WAGfEk8Wjv10eKSyTHVGkSo3bvBylCEtk7LA==",
+      "dev": true
+    },
+    "chalk": {
+      "version": "2.4.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
+      "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
+      "dev": true,
+      "requires": {
+        "ansi-styles": "^3.2.1",
+        "escape-string-regexp": "^1.0.5",
+        "supports-color": "^5.3.0"
+      }
+    },
+    "color-convert": {
+      "version": "1.9.3",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
+      "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
+      "dev": true,
+      "requires": {
+        "color-name": "1.1.3"
+      }
+    },
+    "color-name": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
+      "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=",
+      "dev": true
+    },
+    "commander": {
+      "version": "2.20.3",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz",
+      "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==",
+      "dev": true
+    },
+    "commondir": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/commondir/-/commondir-1.0.1.tgz",
+      "integrity": "sha1-3dgA2gxmEnOTzKWVDqloo6rxJTs=",
+      "dev": true
+    },
+    "concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=",
+      "dev": true
+    },
+    "deepmerge": {
+      "version": "4.2.2",
+      "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.2.2.tgz",
+      "integrity": "sha512-FJ3UgI4gIl+PHZm53knsuSFpE+nESMr7M4v9QcgB7S63Kj/6WqMiFQJpBBYz1Pt+66bZpP3Q7Lye0Oo9MPKEdg==",
+      "dev": true
+    },
+    "escape-string-regexp": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
+      "integrity": "sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=",
+      "dev": true
+    },
+    "estree-walker": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-1.0.1.tgz",
+      "integrity": "sha512-1fMXF3YP4pZZVozF8j/ZLfvnR8NSIljt56UhbZ5PeeDmmGHpgpdwQt7ITlGvYaQukCvuBRMLEiKiYC+oeIg4cg==",
+      "dev": true
+    },
+    "fs.realpath": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+      "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=",
+      "dev": true
+    },
+    "fsevents": {
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz",
+      "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==",
+      "dev": true,
+      "optional": true
+    },
+    "function-bind": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz",
+      "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==",
+      "dev": true
+    },
+    "glob": {
+      "version": "7.1.6",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.6.tgz",
+      "integrity": "sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==",
+      "dev": true,
+      "requires": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^3.0.4",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
+      }
+    },
+    "has": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz",
+      "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==",
+      "dev": true,
+      "requires": {
+        "function-bind": "^1.1.1"
+      }
+    },
+    "has-flag": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
+      "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=",
+      "dev": true
+    },
+    "inflight": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+      "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=",
+      "dev": true,
+      "requires": {
+        "once": "^1.3.0",
+        "wrappy": "1"
+      }
+    },
+    "inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "dev": true
+    },
+    "is-core-module": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.2.0.tgz",
+      "integrity": "sha512-XRAfAdyyY5F5cOXn7hYQDqh2Xmii+DEfIcQGxK/uNwMHhIkPWO0g8msXcbzLe+MpGoR951MlqM/2iIlU4vKDdQ==",
+      "dev": true,
+      "requires": {
+        "has": "^1.0.3"
+      }
+    },
+    "is-module": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/is-module/-/is-module-1.0.0.tgz",
+      "integrity": "sha1-Mlj7afeMFNW4FdZkM2tM/7ZEFZE=",
+      "dev": true
+    },
+    "is-reference": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/is-reference/-/is-reference-1.2.1.tgz",
+      "integrity": "sha512-U82MsXXiFIrjCK4otLT+o2NA2Cd2g5MLoOVXUZjIOhLurrRxpEXzI8O0KZHr3IjLvlAH1kTPYSuqer5T9ZVBKQ==",
+      "dev": true,
+      "requires": {
+        "@types/estree": "*"
+      }
+    },
+    "jest-worker": {
+      "version": "26.6.2",
+      "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-26.6.2.tgz",
+      "integrity": "sha512-KWYVV1c4i+jbMpaBC+U++4Va0cp8OisU185o73T1vo99hqi7w8tSJfUXYswwqqrjzwxa6KpRK54WhPvwf5w6PQ==",
+      "dev": true,
+      "requires": {
+        "@types/node": "*",
+        "merge-stream": "^2.0.0",
+        "supports-color": "^7.0.0"
+      },
+      "dependencies": {
+        "has-flag": {
+          "version": "4.0.0",
+          "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+          "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+          "dev": true
+        },
+        "supports-color": {
+          "version": "7.2.0",
+          "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+          "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+          "dev": true,
+          "requires": {
+            "has-flag": "^4.0.0"
+          }
+        }
+      }
+    },
+    "js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "dev": true
+    },
+    "magic-string": {
+      "version": "0.25.7",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.25.7.tgz",
+      "integrity": "sha512-4CrMT5DOHTDk4HYDlzmwu4FVCcIYI8gauveasrdCu2IKIFOJ3f0v/8MDGJCDL9oD2ppz/Av1b0Nj345H9M+XIA==",
+      "dev": true,
+      "requires": {
+        "sourcemap-codec": "^1.4.4"
+      }
+    },
+    "merge-stream": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz",
+      "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==",
+      "dev": true
+    },
+    "minimatch": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
+      "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
+      "dev": true,
+      "requires": {
+        "brace-expansion": "^1.1.7"
+      }
+    },
+    "once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
+      "dev": true,
+      "requires": {
+        "wrappy": "1"
+      }
+    },
+    "path-is-absolute": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+      "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=",
+      "dev": true
+    },
+    "path-parse": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.6.tgz",
+      "integrity": "sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==",
+      "dev": true
+    },
+    "picomatch": {
+      "version": "2.2.2",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.2.2.tgz",
+      "integrity": "sha512-q0M/9eZHzmr0AulXyPwNfZjtwZ/RBZlbN3K3CErVrk50T2ASYI7Bye0EvekFY3IP1Nt2DHu0re+V2ZHIpMkuWg==",
+      "dev": true
+    },
+    "randombytes": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz",
+      "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==",
+      "dev": true,
+      "requires": {
+        "safe-buffer": "^5.1.0"
+      }
+    },
+    "require-relative": {
+      "version": "0.8.7",
+      "resolved": "https://registry.npmjs.org/require-relative/-/require-relative-0.8.7.tgz",
+      "integrity": "sha1-eZlTn8ngR6N5KPoZb44VY9q9Nt4=",
+      "dev": true
+    },
+    "resolve": {
+      "version": "1.19.0",
+      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.19.0.tgz",
+      "integrity": "sha512-rArEXAgsBG4UgRGcynxWIWKFvh/XZCcS8UJdHhwy91zwAvCZIbcs+vAbflgBnNjYMs/i/i+/Ux6IZhML1yPvxg==",
+      "dev": true,
+      "requires": {
+        "is-core-module": "^2.1.0",
+        "path-parse": "^1.0.6"
+      }
+    },
+    "rollup": {
+      "version": "2.38.5",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.38.5.tgz",
+      "integrity": "sha512-VoWt8DysFGDVRGWuHTqZzT02J0ASgjVq/hPs9QcBOGMd7B+jfTr/iqMVEyOi901rE3xq+Deq66GzIT1yt7sGwQ==",
+      "dev": true,
+      "requires": {
+        "fsevents": "~2.3.1"
+      }
+    },
+    "rollup-plugin-svelte": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/rollup-plugin-svelte/-/rollup-plugin-svelte-7.1.0.tgz",
+      "integrity": "sha512-vopCUq3G+25sKjwF5VilIbiY6KCuMNHP1PFvx2Vr3REBNMDllKHFZN2B9jwwC+MqNc3UPKkjXnceLPEjTjXGXg==",
+      "dev": true,
+      "requires": {
+        "require-relative": "^0.8.7",
+        "rollup-pluginutils": "^2.8.2"
+      }
+    },
+    "rollup-plugin-terser": {
+      "version": "7.0.2",
+      "resolved": "https://registry.npmjs.org/rollup-plugin-terser/-/rollup-plugin-terser-7.0.2.tgz",
+      "integrity": "sha512-w3iIaU4OxcF52UUXiZNsNeuXIMDvFrr+ZXK6bFZ0Q60qyVfq4uLptoS4bbq3paG3x216eQllFZX7zt6TIImguQ==",
+      "dev": true,
+      "requires": {
+        "@babel/code-frame": "^7.10.4",
+        "jest-worker": "^26.2.1",
+        "serialize-javascript": "^4.0.0",
+        "terser": "^5.0.0"
+      }
+    },
+    "rollup-pluginutils": {
+      "version": "2.8.2",
+      "resolved": "https://registry.npmjs.org/rollup-pluginutils/-/rollup-pluginutils-2.8.2.tgz",
+      "integrity": "sha512-EEp9NhnUkwY8aif6bxgovPHMoMoNr2FulJziTndpt5H9RdwC47GSGuII9XxpSdzVGM0GWrNPHV6ie1LTNJPaLQ==",
+      "dev": true,
+      "requires": {
+        "estree-walker": "^0.6.1"
+      },
+      "dependencies": {
+        "estree-walker": {
+          "version": "0.6.1",
+          "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-0.6.1.tgz",
+          "integrity": "sha512-SqmZANLWS0mnatqbSfRP5g8OXZC12Fgg1IwNtLsyHDzJizORW4khDfjPqJZsemPWBB2uqykUah5YpQ6epsqC/w==",
+          "dev": true
+        }
+      }
+    },
+    "safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "dev": true
+    },
+    "serialize-javascript": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-4.0.0.tgz",
+      "integrity": "sha512-GaNA54380uFefWghODBWEGisLZFj00nS5ACs6yHa9nLqlLpVLO8ChDGeKRjZnV4Nh4n0Qi7nhYZD/9fCPzEqkw==",
+      "dev": true,
+      "requires": {
+        "randombytes": "^2.1.0"
+      }
+    },
+    "source-map": {
+      "version": "0.7.3",
+      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.7.3.tgz",
+      "integrity": "sha512-CkCj6giN3S+n9qrYiBTX5gystlENnRW5jZeNLHpe6aue+SrHcG5VYwujhW9s4dY31mEGsxBDrHR6oI69fTXsaQ==",
+      "dev": true
+    },
+    "source-map-support": {
+      "version": "0.5.19",
+      "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.19.tgz",
+      "integrity": "sha512-Wonm7zOCIJzBGQdB+thsPar0kYuCIzYvxZwlBa87yi/Mdjv7Tip2cyVbLj5o0cFPN4EVkuTwb3GDDyUx2DGnGw==",
+      "dev": true,
+      "requires": {
+        "buffer-from": "^1.0.0",
+        "source-map": "^0.6.0"
+      },
+      "dependencies": {
+        "source-map": {
+          "version": "0.6.1",
+          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+          "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+          "dev": true
+        }
+      }
+    },
+    "sourcemap-codec": {
+      "version": "1.4.8",
+      "resolved": "https://registry.npmjs.org/sourcemap-codec/-/sourcemap-codec-1.4.8.tgz",
+      "integrity": "sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA==",
+      "dev": true
+    },
+    "supports-color": {
+      "version": "5.5.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
+      "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
+      "dev": true,
+      "requires": {
+        "has-flag": "^3.0.0"
+      }
+    },
+    "svelte": {
+      "version": "3.32.2",
+      "resolved": "https://registry.npmjs.org/svelte/-/svelte-3.32.2.tgz",
+      "integrity": "sha512-Zxh1MQQl/+vnToKbU1Per+PoMN8Jb2MeKJcGxiOsCGR677hXw7jkMfbnNXq33+dxIzV/HfA4xtoSPJrqeB0VUg==",
+      "dev": true
+    },
+    "terser": {
+      "version": "5.5.1",
+      "resolved": "https://registry.npmjs.org/terser/-/terser-5.5.1.tgz",
+      "integrity": "sha512-6VGWZNVP2KTUcltUQJ25TtNjx/XgdDsBDKGt8nN0MpydU36LmbPPcMBd2kmtZNNGVVDLg44k7GKeHHj+4zPIBQ==",
+      "dev": true,
+      "requires": {
+        "commander": "^2.20.0",
+        "source-map": "~0.7.2",
+        "source-map-support": "~0.5.19"
+      }
+    },
+    "wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=",
+      "dev": true
+    }
+  }
+}