TEMP COMMIT

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 {string} filename
+ * @param {sting} 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) {
+	if (timeout == null || timeout == undefined) {
 		timeout = 0;
 	}
 

runtime/js/core/ipc.js

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

runtime/js/runtime/.npmignore

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

scripts/build.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 
 echo "**** Checking if Wails passes unit tests ****"
-if ! go test ./lib/... ./runtime/... ./cmd/...
+if ! go test ./...
 then
     echo ""
     echo "ERROR: Unit tests failed!"

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

@@ -2,19 +2,19 @@ package build
 
 import (
 	"fmt"
-	"os"
+	"io"
 	"runtime"
 	"strings"
 	"time"
 
 	"github.com/leaanthony/clir"
 	"github.com/leaanthony/slicer"
-	"github.com/wailsapp/wails/v2/internal/logger"
+	"github.com/wailsapp/wails/v2/pkg/clilogger"
 	"github.com/wailsapp/wails/v2/pkg/commands/build"
 )
 
 // AddBuildSubcommand adds the `build` command for the Wails application
-func AddBuildSubcommand(app *clir.Cli) {
+func AddBuildSubcommand(app *clir.Cli, w io.Writer) {
 
 	outputType := "desktop"
 
@@ -32,7 +32,7 @@ func AddBuildSubcommand(app *clir.Cli) {
 
 	// Setup pack flag
 	pack := false
-	command.BoolFlag("pack", "Create a platform specific package", &pack)
+	command.BoolFlag("package", "Create a platform specific package", &pack)
 
 	compilerCommand := "go"
 	command.StringFlag("compiler", "Use a different go compiler to build, eg go1.15beta1", &compilerCommand)
@@ -43,7 +43,7 @@ func AddBuildSubcommand(app *clir.Cli) {
 
 	// Quiet Build
 	quiet := false
-	command.BoolFlag("q", "Supress output to console", &quiet)
+	command.BoolFlag("q", "Suppress output to console", &quiet)
 
 	// ldflags to pass to `go`
 	ldflags := ""
@@ -53,19 +53,19 @@ func AddBuildSubcommand(app *clir.Cli) {
 	logFile := ""
 	command.StringFlag("l", "Log to file", &logFile)
 
+	// Retain assets
+	keepAssets := false
+	command.BoolFlag("k", "Keep generated assets", &keepAssets)
+
 	command.Action(func() error {
 
 		// Create logger
-		logger := logger.New()
-
-		if !quiet {
-			logger.AddOutput(os.Stdout)
-		}
+		logger := clilogger.New(w)
+		logger.Mute(quiet)
 
 		// Validate output type
 		if !validTargetTypes.Contains(outputType) {
-			logger.Fatal(fmt.Sprintf("Output type '%s' is not valid.", outputType))
-			os.Exit(1)
+			return fmt.Errorf("output type '%s' is not valid", outputType)
 		}
 
 		if !quiet {
@@ -73,8 +73,8 @@ func AddBuildSubcommand(app *clir.Cli) {
 		}
 
 		task := fmt.Sprintf("Building %s Application", strings.Title(outputType))
-		logger.Writeln(task)
-		logger.Writeln(strings.Repeat("-", len(task)))
+		logger.Println(task)
+		logger.Println(strings.Repeat("-", len(task)))
 
 		// Setup mode
 		mode := build.Debug
@@ -91,6 +91,7 @@ func AddBuildSubcommand(app *clir.Cli) {
 			Platform:   platform,
 			LDFlags:    ldflags,
 			Compiler:   compilerCommand,
+			KeepAssets: keepAssets,
 		}
 
 		return doBuild(buildOptions)
@@ -107,11 +108,12 @@ func doBuild(buildOptions *build.Options) error {
 	if err != nil {
 		return err
 	}
+
 	// Output stats
 	elapsed := time.Since(start)
-	buildOptions.Logger.Writeln("")
-	buildOptions.Logger.Writeln(fmt.Sprintf("Built '%s' in %s.", outputFilename, elapsed.Round(time.Millisecond).String()))
-	buildOptions.Logger.Writeln("")
+	buildOptions.Logger.Println("")
+	buildOptions.Logger.Println(fmt.Sprintf("Built '%s' in %s.", outputFilename, elapsed.Round(time.Millisecond).String()))
+	buildOptions.Logger.Println("")
 
 	return nil
 }

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

@@ -2,6 +2,7 @@ package dev
 
 import (
 	"fmt"
+	"io"
 	"os"
 	"os/signal"
 	"runtime"
@@ -13,13 +14,13 @@ import (
 	"github.com/leaanthony/clir"
 	"github.com/leaanthony/slicer"
 	"github.com/wailsapp/wails/v2/internal/fs"
-	"github.com/wailsapp/wails/v2/internal/logger"
 	"github.com/wailsapp/wails/v2/internal/process"
+	"github.com/wailsapp/wails/v2/pkg/clilogger"
 	"github.com/wailsapp/wails/v2/pkg/commands/build"
 )
 
 // AddSubcommand adds the `dev` command for the Wails application
-func AddSubcommand(app *clir.Cli) error {
+func AddSubcommand(app *clir.Cli, w io.Writer) error {
 
 	command := app.NewSubCommand("dev", "Development mode")
 
@@ -51,8 +52,7 @@ func AddSubcommand(app *clir.Cli) error {
 		}
 
 		// Create logger
-		logger := logger.New()
-		logger.AddOutput(os.Stdout)
+		logger := clilogger.New(w)
 		app.PrintBanner()
 
 		// TODO: Check you are in a project directory
@@ -74,19 +74,22 @@ func AddSubcommand(app *clir.Cli) error {
 		debounceQuit := make(chan bool, 1)
 
 		// Do initial build
-		logger.Info("Building application for development...")
+		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.Info("event: %+v", 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") {
-						watcher.Add(event.Name)
-						logger.Info("Watching directory: %s", event.Name)
+						err := watcher.Add(event.Name)
+						if err != nil {
+							logger.Fatal("%s", err.Error())
+						}
+						logger.Println("Watching directory: %s", event.Name)
 					}
 				}
 				return
@@ -95,7 +98,7 @@ func AddSubcommand(app *clir.Cli) error {
 			// Check for file writes
 			if event.Op&fsnotify.Write == fsnotify.Write {
 
-				// logger.Info("modified file: %s", event.Name)
+				// logger.Println("modified file: %s", event.Name)
 				var rebuild bool = false
 
 				// Iterate all file patterns
@@ -112,14 +115,14 @@ func AddSubcommand(app *clir.Cli) error {
 				}
 
 				if !rebuild {
-					logger.Info("Filename change: %s did not match extension list %s", event.Name, extensions)
+					logger.Println("Filename change: %s did not match extension list %s", event.Name, extensions)
 					return
 				}
 
 				if buildFrontend {
-					logger.Info("Full rebuild triggered: %s updated", event.Name)
+					logger.Println("Full rebuild triggered: %s updated", event.Name)
 				} else {
-					logger.Info("Partial build triggered: %s updated", event.Name)
+					logger.Println("Partial build triggered: %s updated", event.Name)
 				}
 
 				// Do a rebuild
@@ -152,7 +155,7 @@ func AddSubcommand(app *clir.Cli) error {
 			if strings.Contains(dir, "node_modules") {
 				return
 			}
-			logger.Info("Watching directory: %s", dir)
+			logger.Println("Watching directory: %s", dir)
 			err = watcher.Add(dir)
 			if err != nil {
 				logger.Fatal(err.Error())
@@ -173,10 +176,13 @@ func AddSubcommand(app *clir.Cli) error {
 
 		// Kill the current program if running
 		if debugBinaryProcess != nil {
-			debugBinaryProcess.Kill()
+			err := debugBinaryProcess.Kill()
+			if err != nil {
+				return err
+			}
 		}
 
-		logger.Info("Development mode exited")
+		logger.Println("Development mode exited")
 
 		return nil
 	})
@@ -203,15 +209,15 @@ exit:
 	}
 }
 
-func restartApp(logger *logger.Logger, outputType string, ldflags string, compilerCommand string, buildFrontend bool, debugBinaryProcess *process.Process) *process.Process {
+func restartApp(logger *clilogger.CLILogger, outputType string, ldflags string, compilerCommand string, buildFrontend bool, debugBinaryProcess *process.Process) *process.Process {
 
 	appBinary, err := buildApp(logger, outputType, ldflags, compilerCommand, buildFrontend)
 	println()
 	if err != nil {
-		logger.Error("Build Failed: %s", err.Error())
+		logger.Println("[ERROR] Build Failed: %s", err.Error())
 		return nil
 	}
-	logger.Info("Build new binary: %s", appBinary)
+	logger.Println("Build new binary: %s", appBinary)
 
 	// Kill existing binary if need be
 	if debugBinaryProcess != nil {
@@ -231,14 +237,17 @@ func restartApp(logger *logger.Logger, outputType string, ldflags string, compil
 	err = newProcess.Start()
 	if err != nil {
 		// Remove binary
-		fs.DeleteFile(appBinary)
+		deleteError := fs.DeleteFile(appBinary)
+		if deleteError != nil {
+			logger.Fatal("Unable to delete app binary: " + appBinary)
+		}
 		logger.Fatal("Unable to start application: %s", err.Error())
 	}
 
 	return newProcess
 }
 
-func buildApp(logger *logger.Logger, outputType string, ldflags string, compilerCommand string, buildFrontend bool) (string, error) {
+func buildApp(logger *clilogger.CLILogger, outputType string, ldflags string, compilerCommand string, buildFrontend bool) (string, error) {
 
 	// Create random output file
 	outputFile := fmt.Sprintf("debug-%d", time.Now().Unix())

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

@@ -2,37 +2,37 @@ package doctor
 
 import (
 	"fmt"
+	"io"
+	"log"
 	"os"
 	"runtime"
 	"strings"
 	"text/tabwriter"
 
 	"github.com/leaanthony/clir"
-	"github.com/wailsapp/wails/v2/internal/logger"
 	"github.com/wailsapp/wails/v2/internal/system"
 	"github.com/wailsapp/wails/v2/internal/system/packagemanager"
+	"github.com/wailsapp/wails/v2/pkg/clilogger"
 )
 
 // AddSubcommand adds the `doctor` command for the Wails application
-func AddSubcommand(app *clir.Cli) error {
+func AddSubcommand(app *clir.Cli, w io.Writer) error {
 
 	command := app.NewSubCommand("doctor", "Diagnose your environment")
 
 	command.Action(func() error {
 
-		// Create logger
-		logger := logger.New()
-		logger.AddOutput(os.Stdout)
+		logger := clilogger.New(w)
 
 		app.PrintBanner()
-		print("Scanning system - please wait...")
+		logger.Print("Scanning system - please wait...")
 
 		// Get system info
 		info, err := system.GetInfo()
 		if err != nil {
 			return err
 		}
-		println("Done.")
+		logger.Println("Done.")
 
 		// Start a new tabwriter
 		w := new(tabwriter.Writer)
@@ -112,22 +112,22 @@ func AddSubcommand(app *clir.Cli) error {
 		fmt.Fprintf(w, "\n")
 		fmt.Fprintf(w, "* - Optional Dependency\n")
 		w.Flush()
-		println()
-		println("Diagnosis")
-		println("---------\n")
+		logger.Println("")
+		logger.Println("Diagnosis")
+		logger.Println("---------\n")
 
 		// Generate an appropriate diagnosis
 
 		if len(dependenciesMissing) == 0 && dependenciesAvailableRequired == 0 {
-			println("Your system is ready for Wails development!")
+			logger.Println("Your system is ready for Wails development!")
 		}
 
 		if dependenciesAvailableRequired != 0 {
-			println("Install required packages using: " + info.Dependencies.InstallAllRequiredCommand())
+			log.Println("Install required packages using: " + info.Dependencies.InstallAllRequiredCommand())
 		}
 
 		if dependenciesAvailableOptional != 0 {
-			println("Install optional packages using: " + info.Dependencies.InstallAllOptionalCommand())
+			log.Println("Install optional packages using: " + info.Dependencies.InstallAllOptionalCommand())
 		}
 
 		if len(externalPackages) > 0 {
@@ -135,18 +135,18 @@ func AddSubcommand(app *clir.Cli) error {
 				if p.Optional {
 					print("[Optional] ")
 				}
-				println("Install " + p.Name + ": " + p.InstallCommand)
+				log.Println("Install " + p.Name + ": " + p.InstallCommand)
 			}
 		}
 
 		if len(dependenciesMissing) != 0 {
 			// TODO: Check if apps are available locally and if so, adjust the diagnosis
-			println("Fatal:")
-			println("Required dependencies missing: " + strings.Join(dependenciesMissing, " "))
-			println("Please read this article on how to resolve this: https://wails.app/guides/resolving-missing-packages")
+			log.Println("Fatal:")
+			log.Println("Required dependencies missing: " + strings.Join(dependenciesMissing, " "))
+			log.Println("Please read this article on how to resolve this: https://wails.app/guides/resolving-missing-packages")
 		}
 
-		println()
+		log.Println("")
 		return nil
 	})
 

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

@@ -2,17 +2,19 @@ package initialise
 
 import (
 	"fmt"
-	"os"
+	"io"
 	"strings"
 	"time"
 
 	"github.com/leaanthony/clir"
-	"github.com/wailsapp/wails/v2/internal/logger"
+	"github.com/pkg/errors"
 	"github.com/wailsapp/wails/v2/internal/templates"
+	"github.com/wailsapp/wails/v2/pkg/clilogger"
+	"github.com/wailsapp/wails/v2/pkg/git"
 )
 
 // AddSubcommand adds the `init` command for the Wails application
-func AddSubcommand(app *clir.Cli) error {
+func AddSubcommand(app *clir.Cli, w io.Writer) error {
 
 	// Load the template shortnames
 	validShortNames, err := templates.TemplateShortNames()
@@ -32,13 +34,24 @@ func AddSubcommand(app *clir.Cli) error {
 	command.StringFlag("n", "Name of project", &projectName)
 
 	// Setup project directory
-	projectDirectory := "."
+	projectDirectory := ""
 	command.StringFlag("d", "Project directory", &projectDirectory)
 
 	// Quiet Init
 	quiet := false
 	command.BoolFlag("q", "Supress output to console", &quiet)
 
+	initGit := false
+	gitInstalled := git.IsInstalled()
+	if gitInstalled {
+		// Git Init
+		command.BoolFlag("g", "Initialise git repository", &initGit)
+	}
+
+	// VSCode project files
+	vscode := false
+	command.BoolFlag("vscode", "Generate VSCode project files", &vscode)
+
 	// List templates
 	list := false
 	command.BoolFlag("l", "List templates", &list)
@@ -46,32 +59,29 @@ func AddSubcommand(app *clir.Cli) error {
 	command.Action(func() error {
 
 		// Create logger
-		logger := logger.New()
-
-		if !quiet {
-			logger.AddOutput(os.Stdout)
-		}
+		logger := clilogger.New(w)
+		logger.Mute(quiet)
 
 		// Are we listing templates?
 		if list {
 			app.PrintBanner()
 			err := templates.OutputList(logger)
-			logger.Writeln("")
+			logger.Println("")
 			return err
 		}
 
 		// Validate output type
 		if !validShortNames.Contains(templateName) {
-			logger.Write(fmt.Sprintf("ERROR: Template '%s' is not valid", templateName))
-			logger.Writeln("")
+			logger.Print(fmt.Sprintf("[ERROR] Template '%s' is not valid", templateName))
+			logger.Println("")
 			command.PrintHelp()
 			return nil
 		}
 
 		// Validate name
 		if len(projectName) == 0 {
-			logger.Writeln("ERROR: Project name required")
-			logger.Writeln("")
+			logger.Println("ERROR: Project name required")
+			logger.Println("")
 			command.PrintHelp()
 			return nil
 		}
@@ -81,15 +91,23 @@ func AddSubcommand(app *clir.Cli) error {
 		}
 
 		task := fmt.Sprintf("Initialising Project %s", strings.Title(projectName))
-		logger.Writeln(task)
-		logger.Writeln(strings.Repeat("-", len(task)))
+		logger.Println(task)
+		logger.Println(strings.Repeat("-", len(task)))
 
 		// Create Template Options
 		options := &templates.Options{
-			ProjectName:  projectName,
-			TargetDir:    projectDirectory,
-			TemplateName: templateName,
-			Logger:       logger,
+			ProjectName:    projectName,
+			TargetDir:      projectDirectory,
+			TemplateName:   templateName,
+			Logger:         logger,
+			GenerateVSCode: vscode,
+			InitGit:        initGit,
+		}
+
+		// Try to discover author details from git config
+		err := findAuthorDetails(options)
+		if err != nil {
+			return err
 		}
 
 		return initProject(options)
@@ -110,11 +128,55 @@ func initProject(options *templates.Options) error {
 		return err
 	}
 
+	if options.InitGit {
+		err = initGit(options)
+		if err != nil {
+			return err
+		}
+	}
+
 	// Output stats
 	elapsed := time.Since(start)
-	options.Logger.Writeln("")
-	options.Logger.Writeln(fmt.Sprintf("Initialised project '%s' in %s.", options.ProjectName, elapsed.Round(time.Millisecond).String()))
-	options.Logger.Writeln("")
+	options.Logger.Println("")
+	options.Logger.Println("Project Name:      " + options.ProjectName)
+	options.Logger.Println("Project Directory: " + options.TargetDir)
+	options.Logger.Println("Project Template:  " + options.TemplateName)
+	if options.GenerateVSCode {
+		options.Logger.Println("VSCode config files generated.")
+	}
+	if options.InitGit {
+		options.Logger.Println("Git repository initialised.")
+	}
+	options.Logger.Println("")
+	options.Logger.Println(fmt.Sprintf("Initialised project '%s' in %s.", options.ProjectName, elapsed.Round(time.Millisecond).String()))
+	options.Logger.Println("")
+
+	return nil
+}
+
+func initGit(options *templates.Options) error {
+	err := git.InitRepo(options.TargetDir)
+	if err != nil {
+		return errors.Wrap(err, "Unable to initialise git repository:")
+	}
+
+	return nil
+}
+
+func findAuthorDetails(options *templates.Options) error {
+	if git.IsInstalled() {
+		name, err := git.Name()
+		if err != nil {
+			return err
+		}
+		options.AuthorName = strings.TrimSpace(name)
+
+		email, err := git.Email()
+		if err != nil {
+			return err
+		}
+		options.AuthorEmail = strings.TrimSpace(email)
+	}
 
 	return nil
 }

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

@@ -1,164 +0,0 @@
-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 the Wails CLI.`)
-
-	// Setup flags
-	var prereleaseRequired bool
-	command.BoolFlag("pre", "Update CLI to latest Prerelease", &prereleaseRequired)
-
-	var specificVersion string
-	command.StringFlag("version", "Install a specific version (Overrides other flags) of the CLI", &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 CLI " + 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 CLI updated to " + desiredVersion)
-
-	return nil
-}

v2/cmd/wails/main.go

@@ -5,7 +5,10 @@ import (
 
 	"github.com/leaanthony/clir"
 	"github.com/wailsapp/wails/v2/cmd/wails/internal/commands/build"
+	"github.com/wailsapp/wails/v2/cmd/wails/internal/commands/debug"
+	"github.com/wailsapp/wails/v2/cmd/wails/internal/commands/dev"
 	"github.com/wailsapp/wails/v2/cmd/wails/internal/commands/doctor"
+	"github.com/wailsapp/wails/v2/cmd/wails/internal/commands/generate"
 	"github.com/wailsapp/wails/v2/cmd/wails/internal/commands/initialise"
 )
 
@@ -17,16 +20,30 @@ func fatal(message string) {
 func main() {
 
 	var err error
-	version := "v2.0.0-alpha"
 
 	app := clir.NewCli("Wails", "Go/HTML Application Framework", version)
 
-	build.AddBuildSubcommand(app)
-	err = initialise.AddSubcommand(app)
+	build.AddBuildSubcommand(app, os.Stdout)
+	err = initialise.AddSubcommand(app, os.Stdout)
 	if err != nil {
 		fatal(err.Error())
 	}
-	err = doctor.AddSubcommand(app)
+
+	err = debug.AddSubcommand(app, os.Stdout)
+	if err != nil {
+		fatal(err.Error())
+	}
+	err = doctor.AddSubcommand(app, os.Stdout)
+	if err != nil {
+		fatal(err.Error())
+	}
+
+	err = dev.AddSubcommand(app, os.Stdout)
+	if err != nil {
+		fatal(err.Error())
+	}
+
+	err = generate.AddSubcommand(app, os.Stdout)
 	if err != nil {
 		fatal(err.Error())
 	}

v2/cmd/wails/version.go

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

v2/go.mod

@@ -1,14 +1,28 @@
 module github.com/wailsapp/wails/v2
 
-go 1.13
+go 1.15
 
 require (
-	github.com/leaanthony/clir v1.0.2
-	github.com/leaanthony/gosod v0.0.3
-	github.com/leaanthony/slicer v1.4.1
-	github.com/matryer/is v1.3.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/imdario/mergo v0.3.11
+	github.com/jackmordaunt/icns v1.0.0
+	github.com/leaanthony/clir v1.0.4
+	github.com/leaanthony/gosod v0.0.4
+	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/xyproto/xpm v1.2.1
-	golang.org/x/net v0.0.0-20200301022130-244492dfa37a
-	nhooyr.io/websocket v1.7.4
+	golang.org/x/net v0.0.0-20200822124328-c89045814202
+	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,57 +1,134 @@
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/fatih/structtag v1.2.0 h1:/OdNE99OxoI/PqaW/SuSK9uxxT3f/tcSZgon/ssNSx4=
+github.com/fatih/structtag v1.2.0/go.mod h1:mBJUNpUnHmRKrKlQQlmCrh5PuhftFbNv8Ys4/aAZl94=
+github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4=
+github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
+github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
+github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
+github.com/gin-gonic/gin v1.6.3 h1:ahKqKTFpO5KTPHxWZjEdPScmYaGtLo8Y4DMHoEsnp14=
+github.com/gin-gonic/gin v1.6.3/go.mod h1:75u5sXoLsGZoRN5Sgbi1eraJ4GU3++wFwWzhwvtwp4M=
+github.com/go-playground/assert/v2 v2.0.1 h1:MsBgLAaY856+nPRTKrp3/OZK38U/wa0CcBYNjji3q3A=
+github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
+github.com/go-playground/locales v0.13.0 h1:HyWk6mgj5qFqCT5fjGBuRArbVDfE4hi8+e8ceBS/t7Q=
+github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8=
+github.com/go-playground/universal-translator v0.17.0 h1:icxd5fm+REJzpZx7ZfpaD876Lmtgy7VtROAbHHXk8no=
+github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA=
+github.com/go-playground/validator/v10 v10.2.0 h1:KgJ0snyC2R9VXYN2rneOtQcw5aHQB1Vv0sFl1UcHBOY=
+github.com/go-playground/validator/v10 v10.2.0/go.mod h1:uOYAAleCW8F/7oMFd6aG0GOhaH6EGOAJShg8Id5JGkI=
 github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee h1:s+21KNqlpePfkah2I+gwHF8xmJWRjooY+5248k6m4A0=
 github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee/go.mod h1:L0fX3K22YWvt/FAX9NnzrNzcI4wNYi9Yku4O0LKYflo=
 github.com/gobwas/pool v0.2.0 h1:QEmUOlnSjWtnpRGHF3SauEiOsy82Cup83Vf2LcMlnc8=
 github.com/gobwas/pool v0.2.0/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
 github.com/gobwas/ws v1.0.2 h1:CoAavW/wd/kulfZmSIBt6p24n4j7tHgNVCjsfHVNUbo=
 github.com/gobwas/ws v1.0.2/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM=
-github.com/golang/protobuf v1.3.2 h1:6nsPYzhq5kReh6QImI3k5qWzO4PEbvbIW2cwSfR/6xs=
-github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/google/go-cmp v0.3.1 h1:Xye71clBPdm5HgqGwUkwhbynsUJZhDbS20FvLhQ2izg=
-github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.3.5 h1:F768QJ1E9tib+q5Sc8MkdJi1RxLTbRcTf8LJV56aRls=
+github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk=
+github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/gorilla/websocket v1.4.1 h1:q7AeDBpnBk8AogcD4DSag/Ukw/KV+YhzLj2bP5HvKCM=
 github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
-github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
-github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/imdario/mergo v0.3.11 h1:3tnifQM4i+fbajXKBHXWEH+KvNHqojZ778UH75j3bGA=
+github.com/imdario/mergo v0.3.11/go.mod h1:jmQim1M+e3UYxmgPu/WyfjB3N3VflVyUjjjwH0dnCYA=
+github.com/jackmordaunt/icns v1.0.0 h1:RYSxplerf/l/DUd09AHtITwckkv/mqjVv4DjYdPmAMQ=
+github.com/jackmordaunt/icns v1.0.0/go.mod h1:7TTQVEuGzVVfOPPlLNHJIkzA6CoV7aH1Dv9dW351oOo=
+github.com/json-iterator/go v1.1.9 h1:9yzud/Ht36ygwatGx56VwCZtlI/2AD15T1X2sjSuGns=
+github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/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.2 h1:Ham9Ep7NH95il0x/ci5s2ExJa/K4B2dE8L2uaSj2cxo=
-github.com/leaanthony/clir v1.0.2/go.mod h1:k/RBkdkFl18xkkACMCLt09bhiZnrGORoxmomeMvDpE0=
-github.com/leaanthony/gosod v0.0.3 h1:VlPilye0zoH4I0WihShyoiTHyiAN1v6dcBW4mMvGJao=
-github.com/leaanthony/gosod v0.0.3/go.mod h1:nGMCb1PJfXwBDbOAike78jEYlpqge+xUKFf0iBKjKxU=
-github.com/leaanthony/slicer v1.4.1 h1:X/SmRIDhkUAolP79mSTO0jTcVX1k504PJBqvV6TwP0w=
-github.com/leaanthony/slicer v1.4.1/go.mod h1:FwrApmf8gOrpzEWM2J/9Lh79tyq8KTX5AzRtwV7m4AY=
-github.com/matryer/is v1.3.0 h1:9qiso3jaJrOe6qBRJRBt2Ldht05qDiFP9le0JOIhRSI=
-github.com/matryer/is v1.3.0/go.mod h1:2fLPjFQM9rhQ15aVEtbuwhJinnOqrmgXPNdZsdwlWXA=
+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=
+github.com/leaanthony/gosod v0.0.4/go.mod h1:nGMCb1PJfXwBDbOAike78jEYlpqge+xUKFf0iBKjKxU=
+github.com/leaanthony/slicer v1.5.0 h1:aHYTN8xbCCLxJmkNKiLB6tgcMARl4eWmH9/F+S/0HtY=
+github.com/leaanthony/slicer v1.5.0/go.mod h1:FwrApmf8gOrpzEWM2J/9Lh79tyq8KTX5AzRtwV7m4AY=
+github.com/leodido/go-urn v1.2.0 h1:hpXL4XnriNwQ/ABnpepYM/1vCLWNDfUNts8dX3xTG6Y=
+github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII=
+github.com/matryer/is v1.4.0 h1:sosSmIWwkYITGrxZ25ULNDeKiMNzFSr4V/eqBQP0PeE=
+github.com/matryer/is v1.4.0/go.mod h1:8I/i5uYgLzgsgEloJE1U6xx5HkBQpAZvepWuujKwMRU=
+github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
 github.com/mattn/go-runewidth v0.0.7 h1:Ei8KR0497xHyKJPAv59M1dkC+rOZCMBJ+t3fZ+twI54=
 github.com/mattn/go-runewidth v0.0.7/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 h1:ZqeYNhU3OHLH3mGKHDcjJRFFRrJa6eAM5H+CtDdOsPc=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742 h1:Esafd1046DLDQ0W1YjYsBW+p8U2u7vzgW2SQVmlNazg=
+github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 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=
+github.com/tdewolff/parse v2.3.4+incompatible h1:x05/cnGwIMf4ceLuDMBOdQ1qGniMoxpP46ghf0Qzh38=
+github.com/tdewolff/parse v2.3.4+incompatible/go.mod h1:8oBwCsVmUkgHO8M5iCzSIDtpzXOT0WXX9cWhz+bIzJQ=
+github.com/tdewolff/test v1.0.6 h1:76mzYJQ83Op284kMT+63iCNCI7NEERsIN8dLM+RiKr4=
+github.com/tdewolff/test v1.0.6/go.mod h1:6DAvZliBAAnD7rhVgwaM7DE5/d9NMOAJ09SqYqeK4QE=
+github.com/ugorji/go v1.1.7 h1:/68gy2h+1mWMrwZFeD1kQialdSzAb432dtpeJ42ovdo=
+github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw=
+github.com/ugorji/go/codec v1.1.7 h1:2SvQaVZ1ouYrrKKwoSk2pzd4A9evlKJb9oTL+OaLUSs=
+github.com/ugorji/go/codec v1.1.7/go.mod h1:Ax+UKWsSmolVDwsd+7N3ZtXu+yMGCf907BLYF3GoBXY=
 github.com/xyproto/xpm v1.2.1 h1:trdvGjjWBsOOKzBBUPT6JvaIQM3acJEEYfbxN7M96wg=
 github.com/xyproto/xpm v1.2.1/go.mod h1:cMnesLsD0PBXLgjDfTDEaKr8XyTFsnP1QycSqRw7BiY=
-go.uber.org/atomic v1.4.0 h1:cxzIVoETapQEqDhQu3QfnvXAV4AlzcvUCxkVUFw3+EU=
-go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
-go.uber.org/multierr v1.1.0 h1:HoEmRHQPVSqub6w2z2d2EOVs2fjyFRGyofhKuyDq0QI=
-go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
+github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/net v0.0.0-20200301022130-244492dfa37a h1:GuSPYbZzB5/dcLNCwLQLsg3obCJtX9IJhpXkvY7kzk0=
-golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/mod v0.3.0 h1:RM4zey1++hCTbCVQfnWeKs9/IEsaBLA8vTkd0WVtmH4=
+golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200822124328-c89045814202 h1:VvcQYSHwXgi7W+TpUR6A9g6Up98WAHf3f/ulnJ62IyA=
+golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-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-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/time v0.0.0-20190308202827-9d24e82272b4 h1:SvFZT6jyqRaOeXpc5h/JSfZenJ2O330aBsf7JfSUXmQ=
-golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+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-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/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=
-nhooyr.io/websocket v1.7.4 h1:w/LGB2sZT0RV8lZYR7nfyaYz4PUbYZ5oF7NBon2M0NY=
-nhooyr.io/websocket v1.7.4/go.mod h1:PxYxCwFdFYQ0yRvtQz3s/dC+VEm7CSuC/4b9t8MQQxw=
+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=
+nhooyr.io/websocket v1.8.6 h1:s+C3xAMLwGmlI31Nyn/eAehUlZPwfYZu2JXM621Q5/k=
+nhooyr.io/websocket v1.8.6/go.mod h1:B70DZP8IakI65RVQ51MsWP/8jndNma26DVA/nFSCgW0=

v2/internal/app/debug.go

@@ -2,40 +2,11 @@
 
 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
-
-	if a.appType == "desktop" {
-		// Enable dev tools
-		a.options.DevTools = true
-	}
-
-	// Set log levels
-	loglevel := flag.String("loglevel", "debug", "Loglevel to use - Trace, Debug, Info, Warning, Error")
-	flag.Parse()
-	if len(*loglevel) > 0 {
-		switch strings.ToLower(*loglevel) {
-		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)
-		}
-	}
-
+	// Enable dev tools
+	a.options.DevTools = true
 	return nil
 }

v2/internal/app/default.go

@@ -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/features"
+	"github.com/wailsapp/wails/v2/pkg/options"
 )
 
 // App defines a Wails application structure
@@ -20,12 +21,15 @@ type App struct {
 	Height    int
 	Resizable bool
 
-	Features *features.Features
+	// Indicates if the app is running in debug mode
+	debug bool
+
+	logger *logger.Logger
 }
 
 // CreateApp returns a null application
-func CreateApp(options *Options) *App {
-	return &App{}
+func CreateApp(_ *options.App) (*App, error) {
+	return &App{}, nil
 }
 
 // Run the application
@@ -36,6 +40,5 @@ func (a *App) Run() error {
 }
 
 // Bind the dummy interface
-func (a *App) Bind(dummy interface{}) error {
-	return nil
+func (a *App) Bind(_ interface{}) {
 }

v2/internal/app/desktop.go

@@ -3,16 +3,16 @@
 package app
 
 import (
-	"os"
-
 	"github.com/wailsapp/wails/v2/internal/binding"
-	"github.com/wailsapp/wails/v2/internal/features"
 	"github.com/wailsapp/wails/v2/internal/ffenestri"
 	"github.com/wailsapp/wails/v2/internal/logger"
+	"github.com/wailsapp/wails/v2/internal/menumanager"
 	"github.com/wailsapp/wails/v2/internal/messagedispatcher"
+	"github.com/wailsapp/wails/v2/internal/runtime"
 	"github.com/wailsapp/wails/v2/internal/servicebus"
 	"github.com/wailsapp/wails/v2/internal/signal"
 	"github.com/wailsapp/wails/v2/internal/subsystem"
+	"github.com/wailsapp/wails/v2/pkg/options"
 )
 
 // App defines a Wails application structure
@@ -21,6 +21,7 @@ type App struct {
 	servicebus *servicebus.ServiceBus
 	logger     *logger.Logger
 	signal     *signal.Manager
+	options    *options.App
 
 	// Subsystems
 	log        *subsystem.Log
@@ -28,92 +29,130 @@ type App struct {
 	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
 
-	// Feature flags
-	Features *features.Features
+	// Application Stores
+	loglevelStore  *runtime.Store
+	appconfigStore *runtime.Store
+
+	// Startup/Shutdown
+	startupCallback  func(*runtime.Runtime)
+	shutdownCallback func()
 }
 
 // Create App
-func CreateApp(options *Options) *App {
+func CreateApp(appoptions *options.App) (*App, error) {
 
 	// Merge default options
-	options.mergeDefaults()
+	options.MergeDefaults(appoptions)
 
 	// Set up logger
-	myLogger := logger.New(os.Stdout)
-	myLogger.SetLogLevel(logger.TRACE)
+	myLogger := logger.New(appoptions.Logger)
+	myLogger.SetLogLevel(appoptions.LogLevel)
 
-	window := ffenestri.NewApplicationWithConfig(&ffenestri.Config{
-		Title:     options.Title,
-		Width:     options.Width,
-		Height:    options.Height,
-		MinWidth:  options.MinWidth,
-		MinHeight: options.MinHeight,
-		MaxWidth:  options.MaxWidth,
-		MaxHeight: options.MaxHeight,
-		Frameless: options.Frameless,
+	// Create the menu manager
+	menuManager := menumanager.NewManager()
 
-		// This should be controlled by the compile time flags...
-		DevTools: true,
+	// Process the application menu
+	menuManager.SetApplicationMenu(options.GetApplicationMenu(appoptions))
 
-		Resizable:  !options.DisableResize,
-		Fullscreen: options.Fullscreen,
-	}, myLogger)
-
-	result := &App{
-		window:     window,
-		servicebus: servicebus.New(myLogger),
-		logger:     myLogger,
-		bindings:   binding.NewBindings(myLogger),
-		Features:   features.New(),
+	// Process context menus
+	contextMenus := options.GetContextMenus(appoptions)
+	for _, contextMenu := range contextMenus {
+		menuManager.AddContextMenu(contextMenu)
 	}
 
-	return result
+	// Process tray menus
+	trayMenus := options.GetTrayMenus(appoptions)
+	for _, trayMenu := range trayMenus {
+		menuManager.AddTrayMenu(trayMenu)
+	}
+
+	window := ffenestri.NewApplicationWithConfig(appoptions, myLogger, menuManager)
+
+	result := &App{
+		window:           window,
+		servicebus:       servicebus.New(myLogger),
+		logger:           myLogger,
+		bindings:         binding.NewBindings(myLogger),
+		menuManager:      menuManager,
+		startupCallback:  appoptions.Startup,
+		shutdownCallback: appoptions.Shutdown,
+	}
+
+	result.options = appoptions
+
+	// Initialise the app
+	err := result.Init()
+
+	return result, err
 
 }
 
 // Run the application
 func (a *App) Run() error {
 
+	var err error
+
 	// Setup signal handler
-	signal, err := signal.NewManager(a.servicebus, a.logger)
+	signalsubsystem, err := signal.NewManager(a.servicebus, a.logger)
 	if err != nil {
 		return err
 	}
-	a.signal = signal
+	a.signal = signalsubsystem
 	a.signal.Start()
 
 	// Start the service bus
 	a.servicebus.Debug()
-	a.servicebus.Start()
-
-	// Start the runtime
-	runtime, err := subsystem.NewRuntime(a.servicebus, a.logger)
+	err = a.servicebus.Start()
 	if err != nil {
 		return err
 	}
-	a.runtime = runtime
-	a.runtime.Start()
+
+	runtimesubsystem, err := subsystem.NewRuntime(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 binding subsystem
-	binding, err := subsystem.NewBinding(a.servicebus, a.logger, a.bindings, a.runtime.GoRuntime())
+	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
 	}
-	a.binding = binding
-	a.binding.Start()
 
 	// Start the logging subsystem
-	log, err := subsystem.NewLog(a.servicebus, a.logger)
+	log, err := subsystem.NewLog(a.servicebus, a.logger, a.loglevelStore)
 	if err != nil {
 		return err
 	}
 	a.log = log
-	a.log.Start()
+	err = a.log.Start()
+	if err != nil {
+		return err
+	}
 
 	// create the dispatcher
 	dispatcher, err := messagedispatcher.New(a.servicebus, a.logger)
@@ -121,7 +160,10 @@ func (a *App) Run() error {
 		return err
 	}
 	a.dispatcher = dispatcher
-	dispatcher.Start()
+	err = dispatcher.Start()
+	if err != nil {
+		return err
+	}
 
 	// Start the eventing subsystem
 	event, err := subsystem.NewEvent(a.servicebus, a.logger)
@@ -129,15 +171,32 @@ func (a *App) Run() error {
 		return err
 	}
 	a.event = event
-	a.event.Start()
+	err = a.event.Start()
+	if err != nil {
+		return err
+	}
+
+	// Start the menu subsystem
+	menusubsystem, err := subsystem.NewMenu(a.servicebus, a.logger, a.menuManager)
+	if err != nil {
+		return err
+	}
+	a.menu = menusubsystem
+	err = a.menu.Start()
+	if err != nil {
+		return err
+	}
 
 	// 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
 	}
 	a.call = call
-	a.call.Start()
+	err = a.call.Start()
+	if err != nil {
+		return err
+	}
 
 	// Dump bindings as a debug
 	bindingDump, err := a.bindings.ToJSON()
@@ -145,9 +204,12 @@ func (a *App) Run() error {
 		return err
 	}
 
-	result := a.window.Run(dispatcher, bindingDump, a.Features)
+	result := a.window.Run(dispatcher, bindingDump, a.debug)
 	a.logger.Trace("Ffenestri.Run() exited")
-	a.servicebus.Stop()
+	err = a.servicebus.Stop()
+	if err != nil {
+		return err
+	}
 
 	return result
 }

v2/internal/app/dev.go

@@ -1,244 +0,0 @@
-// +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)
-
-	// 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)
-
-	// 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)
-	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()
-
-	// Setup signal handler
-	signalsubsystem, err := signal.NewManager(ctx, cancel, a.servicebus, a.logger)
-	if err != nil {
-		return err
-	}
-	a.signal = signalsubsystem
-	a.signal.Start()
-
-	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
-	}
-
-	// Shutdown callback
-	if a.shutdownCallback != nil {
-		a.shutdownCallback()
-	}
-	return nil
-
-}

v2/internal/app/hybrid.go

@@ -8,7 +8,6 @@ import (
 
 	"github.com/leaanthony/clir"
 	"github.com/wailsapp/wails/v2/internal/binding"
-	"github.com/wailsapp/wails/v2/internal/features"
 	"github.com/wailsapp/wails/v2/internal/ffenestri"
 	"github.com/wailsapp/wails/v2/internal/logger"
 	"github.com/wailsapp/wails/v2/internal/messagedispatcher"
@@ -43,8 +42,7 @@ type App struct {
 	dispatcher *messagedispatcher.Dispatcher
 	servicebus *servicebus.ServiceBus
 
-	// Feature flags
-	Features *features.Features
+	debug bool
 }
 
 // Create App
@@ -58,17 +56,15 @@ func CreateApp(options *Options) *App {
 	myLogger.SetLogLevel(logger.INFO)
 
 	window := ffenestri.NewApplicationWithConfig(&ffenestri.Config{
-		Title:     options.Title,
-		Width:     options.Width,
-		Height:    options.Height,
-		MinWidth:  options.MinWidth,
-		MinHeight: options.MinHeight,
-		MaxWidth:  options.MaxWidth,
-		MaxHeight: options.MaxHeight,
-		Frameless: options.Frameless,
-
-		// This should be controlled by the compile time flags...
-		DevTools: true,
+		Title:       options.Title,
+		Width:       options.Width,
+		Height:      options.Height,
+		MinWidth:    options.MinWidth,
+		MinHeight:   options.MinHeight,
+		MaxWidth:    options.MaxWidth,
+		MaxHeight:   options.MaxHeight,
+		StartHidden: options.StartHidden,
+		DevTools:    options.DevTools,
 
 		Resizable:  !options.DisableResize,
 		Fullscreen: options.Fullscreen,
@@ -82,6 +78,9 @@ func CreateApp(options *Options) *App {
 		bindings:   binding.NewBindings(myLogger),
 	}
 
+	// Initialise the app
+	app.Init()
+
 	return app
 }
 
@@ -185,7 +184,7 @@ func (a *App) Run() error {
 			}
 		}()
 
-		result := a.window.Run(dispatcher, bindingDump, a.Features)
+		result := a.window.Run(dispatcher, bindingDump)
 		a.servicebus.Stop()
 
 		return result

v2/internal/app/options.go

@@ -1,34 +0,0 @@
-package app
-
-// Options for creating the App
-type Options struct {
-	Title         string
-	Width         int
-	Height        int
-	DisableResize bool
-	Fullscreen    bool
-	Frameless     bool
-	MinWidth      int
-	MinHeight     int
-	MaxWidth      int
-	MaxHeight     int
-}
-
-// mergeDefaults will set the minimum default values for an application
-func (o *Options) mergeDefaults() {
-
-	// Create a default title
-	if len(o.Title) == 0 {
-		o.Title = "My Wails App"
-	}
-
-	// Default width
-	if o.Width == 0 {
-		o.Width = 1024
-	}
-
-	// Default height
-	if o.Height == 0 {
-		o.Height = 768
-	}
-}

v2/internal/app/server.go

@@ -28,6 +28,8 @@ type App struct {
 	dispatcher *messagedispatcher.Dispatcher
 	servicebus *servicebus.ServiceBus
 	webserver  *webserver.WebServer
+
+	debug bool
 }
 
 // Create App
@@ -46,6 +48,9 @@ func CreateApp(options *Options) *App {
 		webserver:  webserver.NewWebServer(myLogger),
 	}
 
+	// Initialise app
+	result.Init()
+
 	return result
 }
 

v2/internal/binding/assets/package.json

@@ -1,11 +0,0 @@
-{
-  "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

@@ -25,7 +25,7 @@ func (b *Bindings) Add(structPtr interface{}) error {
 
 	methods, err := getMethods(structPtr)
 	if err != nil {
-		return fmt.Errorf("unable to Add() - %s", err.Error())
+		return fmt.Errorf("cannot bind value to app: %s", err.Error())
 	}
 
 	for _, method := range methods {
@@ -34,26 +34,6 @@ func (b *Bindings) Add(structPtr interface{}) error {
 		structName := splitName[1]
 		methodName := splitName[2]
 
-		// Is this WailsInit?
-		if method.IsWailsInit() {
-			err := b.db.AddWailsInit(method)
-			if err != nil {
-				return err
-			}
-			b.logger.Trace("Registered WailsInit method: %s", method.Name)
-			continue
-		}
-
-		// Is this WailsShutdown?
-		if method.IsWailsShutdown() {
-			err := b.db.AddWailsShutdown(method)
-			if err != nil {
-				return err
-			}
-			b.logger.Trace("Registered WailsShutdown method: %s", method.Name)
-			continue
-		}
-
 		// Add it as a regular method
 		b.db.AddMethod(packageName, structName, methodName, method)
 

v2/internal/binding/boundMethod.go

@@ -1,9 +1,9 @@
 package binding
 
 import (
+	"encoding/json"
 	"fmt"
 	"reflect"
-	"strings"
 )
 
 // BoundMethod defines all the data related to a Go method that is
@@ -16,58 +16,6 @@ type BoundMethod struct {
 	Method   reflect.Value `json:"-"`
 }
 
-// IsWailsInit returns true if the method name is "WailsInit"
-func (b *BoundMethod) IsWailsInit() bool {
-	return strings.HasSuffix(b.Name, "WailsInit")
-}
-
-// IsWailsShutdown returns true if the method name is "WailsShutdown"
-func (b *BoundMethod) IsWailsShutdown() bool {
-	return strings.HasSuffix(b.Name, "WailsShutdown")
-}
-
-// VerifyWailsInit checks if the WailsInit signature is correct
-func (b *BoundMethod) VerifyWailsInit() error {
-	// Must only have 1 input
-	if b.InputCount() != 1 {
-		return fmt.Errorf("invalid method signature for %s: expected `WailsInit(*wails.Runtime) error`", b.Name)
-	}
-
-	// Check input type
-	if !b.Inputs[0].IsType("*goruntime.Runtime") {
-		return fmt.Errorf("invalid method signature for %s: expected `WailsInit(*wails.Runtime) error`", b.Name)
-	}
-
-	// Must only have 1 output
-	if b.OutputCount() != 1 {
-		return fmt.Errorf("invalid method signature for %s: expected `WailsInit(*wails.Runtime) error`", b.Name)
-	}
-
-	// Check output type
-	if !b.Outputs[0].IsError() {
-		return fmt.Errorf("invalid method signature for %s: expected `WailsInit(*wails.Runtime) error`", b.Name)
-	}
-
-	// Input must be of type Runtime
-	return nil
-}
-
-// VerifyWailsShutdown checks if the WailsShutdown signature is correct
-func (b *BoundMethod) VerifyWailsShutdown() error {
-	// Must have no inputs
-	if b.InputCount() != 0 {
-		return fmt.Errorf("invalid method signature for WailsShutdown: expected `WailsShutdown()`")
-	}
-
-	// Must have no outputs
-	if b.OutputCount() != 0 {
-		return fmt.Errorf("invalid method signature for WailsShutdown: expected `WailsShutdown()`")
-	}
-
-	// Input must be of type Runtime
-	return nil
-}
-
 // InputCount returns the number of inputs this bound method has
 func (b *BoundMethod) InputCount() int {
 	return len(b.Inputs)
@@ -78,6 +26,26 @@ func (b *BoundMethod) OutputCount() int {
 	return len(b.Outputs)
 }
 
+// ParseArgs method converts the input json into the types expected by the method
+func (b *BoundMethod) ParseArgs(args []json.RawMessage) ([]interface{}, error) {
+
+	result := make([]interface{}, b.InputCount())
+	for index, arg := range args {
+		typ := b.Inputs[index].reflectType
+		inputValue := reflect.New(typ).Interface()
+		err := json.Unmarshal(arg, inputValue)
+		if err != nil {
+			return nil, err
+		}
+		if inputValue == nil {
+			result[index] = reflect.Zero(typ).Interface()
+		} else {
+			result[index] = reflect.ValueOf(inputValue).Elem().Interface()
+		}
+	}
+	return result, nil
+}
+
 // Call will attempt to call this bound method with the given args
 func (b *BoundMethod) Call(args []interface{}) (interface{}, error) {
 	// Check inputs
@@ -94,17 +62,8 @@ func (b *BoundMethod) Call(args []interface{}) (interface{}, error) {
 
 	// Iterate over given arguments
 	for index, arg := range args {
-
-		// Attempt to convert the argument to the type expected by the method
-		value, err := convertArgToValue(arg, b.Inputs[index])
-
-		// If it fails, return a suitable error
-		if err != nil {
-			return nil, fmt.Errorf("%s (parameter %d): %s", b.Name, index+1, err.Error())
-		}
-
 		// Save the converted argument
-		callArgs[index] = value
+		callArgs[index] = reflect.ValueOf(arg)
 	}
 
 	// Do the call

v2/internal/binding/db.go

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

v2/internal/binding/generate.go

@@ -1,174 +0,0 @@
-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()
-	sortedPackageNames.Each(func(packageName string) {
-		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()
-
-		sortedStructNames.Each(func(structName string) {
-			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()
-
-			sortedMethodNames.Each(func(methodName string) {
-				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

@@ -3,6 +3,7 @@ package binding
 import (
 	"fmt"
 	"reflect"
+	"runtime"
 )
 
 // isStructPtr returns true if the value given is a
@@ -12,6 +13,16 @@ func isStructPtr(value interface{}) bool {
 		reflect.ValueOf(value).Elem().Kind() == reflect.Struct
 }
 
+// isFunction returns true if the given value is a function
+func isFunction(value interface{}) bool {
+	return reflect.ValueOf(value).Kind() == reflect.Func
+}
+
+// isStructPtr returns true if the value given is a struct
+func isStruct(value interface{}) bool {
+	return reflect.ValueOf(value).Kind() == reflect.Struct
+}
+
 func getMethods(value interface{}) ([]*BoundMethod, error) {
 
 	// Create result placeholder
@@ -19,7 +30,18 @@ func getMethods(value interface{}) ([]*BoundMethod, error) {
 
 	// Check type
 	if !isStructPtr(value) {
-		return nil, fmt.Errorf("not a pointer to an interface")
+
+		if isStruct(value) {
+			name := reflect.ValueOf(value).Type().Name()
+			return nil, fmt.Errorf("%s is a struct, not a pointer to a struct", name)
+		}
+
+		if isFunction(value) {
+			name := runtime.FuncForPC(reflect.ValueOf(value).Pointer()).Name()
+			return nil, fmt.Errorf("%s is a function, not a pointer to a struct. Wails v2 has deprecated the binding of functions. Please wrap your functions up in a struct and bind a pointer to that struct.", name)
+		}
+
+		return nil, fmt.Errorf("not a pointer to a struct.")
 	}
 
 	// Process Struct
@@ -56,6 +78,8 @@ func getMethods(value interface{}) ([]*BoundMethod, error) {
 		boundMethod.Inputs = inputs
 
 		// Iterate outputs
+		// TODO: Determine what to do about limiting return types
+		//       especially around errors.
 		outputParamCount := methodType.NumOut()
 		var outputs []*Parameter
 		for outputIndex := 0; outputIndex < outputParamCount; outputIndex++ {
@@ -71,39 +95,3 @@ func getMethods(value interface{}) ([]*BoundMethod, error) {
 	}
 	return result, nil
 }
-
-// convertArgToValue
-func convertArgToValue(input interface{}, target *Parameter) (result reflect.Value, err error) {
-
-	// Catch type conversion panics thrown by convert
-	defer func() {
-		if r := recover(); r != nil {
-			// Modify error
-			err = fmt.Errorf("%s", r.(string)[23:])
-		}
-	}()
-
-	// Do the conversion
-
-	// Handle nil values
-	if input == nil {
-		switch target.reflectType.Kind() {
-		case reflect.Chan,
-			reflect.Func,
-			reflect.Interface,
-			reflect.Map,
-			reflect.Ptr,
-			reflect.Slice:
-			result = reflect.ValueOf(input).Convert(target.reflectType)
-		default:
-			return reflect.Zero(target.reflectType), fmt.Errorf("Unable to use null value")
-		}
-	} else {
-		result = reflect.ValueOf(input).Convert(target.reflectType)
-	}
-
-	// We don't like doing this but it's the only way to
-	// handle recover() correctly
-	return
-
-}

v2/internal/bridge/bridge.go

@@ -1,113 +0,0 @@
-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

@@ -1,134 +0,0 @@
-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 (b BridgeClient) DeleteTrayMenuByID(id string) {
-	b.session.sendMessage("TD" + id)
-}
-
-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

@@ -1,144 +0,0 @@
-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 (d *DialogClient) DeleteTrayMenuByID(id string) {
-}
-
-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

@@ -1,162 +0,0 @@
-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/colour/colour.go

@@ -1,89 +0,0 @@
-package colour
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/wzshiming/ctc"
-)
-
-func Col(col ctc.Color, text string) string {
-	return fmt.Sprintf("%s%s%s", col, text, ctc.Reset)
-}
-
-func Yellow(text string) string {
-	return Col(ctc.ForegroundBrightYellow, text)
-}
-
-func Red(text string) string {
-	return Col(ctc.ForegroundBrightRed, text)
-}
-
-func Blue(text string) string {
-	return Col(ctc.ForegroundBrightBlue, text)
-}
-
-func Green(text string) string {
-	return Col(ctc.ForegroundBrightGreen, text)
-}
-
-func Cyan(text string) string {
-	return Col(ctc.ForegroundBrightCyan, text)
-}
-
-func Magenta(text string) string {
-	return Col(ctc.ForegroundBrightMagenta, text)
-}
-
-func White(text string) string {
-	return Col(ctc.ForegroundBrightWhite, text)
-}
-
-func Black(text string) string {
-	return Col(ctc.ForegroundBrightBlack, text)
-}
-
-func DarkYellow(text string) string {
-	return Col(ctc.ForegroundYellow, text)
-}
-
-func DarkRed(text string) string {
-	return Col(ctc.ForegroundRed, text)
-}
-
-func DarkBlue(text string) string {
-	return Col(ctc.ForegroundBlue, text)
-}
-
-func DarkGreen(text string) string {
-	return Col(ctc.ForegroundGreen, text)
-}
-
-func DarkCyan(text string) string {
-	return Col(ctc.ForegroundCyan, text)
-}
-
-func DarkMagenta(text string) string {
-	return Col(ctc.ForegroundMagenta, text)
-}
-
-func DarkWhite(text string) string {
-	return Col(ctc.ForegroundWhite, text)
-}
-
-func DarkBlack(text string) string {
-	return Col(ctc.ForegroundBlack, text)
-}
-
-var rainbowCols = []func(string) string{Red, Yellow, Green, Cyan, Blue, Magenta}
-
-func Rainbow(text string) string {
-	var builder strings.Builder
-
-	for i := 0; i < len(text); i++ {
-		fn := rainbowCols[i%len(rainbowCols)]
-		builder.WriteString(fn(text[i : i+1]))
-	}
-
-	return builder.String()
-}

v2/internal/counter/counter.go

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

v2/internal/deepcopy/LICENSE

@@ -1,21 +0,0 @@
-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

@@ -1,125 +0,0 @@
-// 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/features/features.go

@@ -1,13 +0,0 @@
-package features
-
-// Features holds generic and platform specific feature flags
-type Features struct {
-	Linux *Linux
-}
-
-// New creates a new Features object
-func New() *Features {
-	return &Features{
-		Linux: &Linux{},
-	}
-}

v2/internal/features/features_linux.go

@@ -1,5 +0,0 @@
-package features
-
-// Linux holds linux specific feature flags
-type Linux struct {
-}

v2/internal/ffenestri/LICENCES.md

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

v2/internal/ffenestri/common.c

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

v2/internal/ffenestri/common.h

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

v2/internal/ffenestri/contextmenus_darwin.c

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

v2/internal/ffenestri/contextmenus_darwin.h

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

@@ -1,23 +0,0 @@
-// +build linux
-
-package ffenestri
-
-/*
-
-#cgo linux CFLAGS: -DFFENESTRI_LINUX=1
-#cgo linux pkg-config: gtk+-3.0 webkit2gtk-4.0
-
-#include <stdlib.h>
-#include "ffenestri.h"
-
-
-*/
-import "C"
-import "github.com/wailsapp/wails/v2/internal/features"
-
-func (a *Application) processOSFeatureFlags(features *features.Features) {
-
-	// Process Linux features
-	// linux := features.Linux
-
-}

v2/internal/ffenestri/ffenestri.go

@@ -1,13 +1,14 @@
 package ffenestri
 
 import (
+	"github.com/wailsapp/wails/v2/internal/menumanager"
 	"runtime"
 	"strings"
 	"unsafe"
 
-	"github.com/wailsapp/wails/v2/internal/features"
 	"github.com/wailsapp/wails/v2/internal/logger"
 	"github.com/wailsapp/wails/v2/internal/messagedispatcher"
+	"github.com/wailsapp/wails/v2/pkg/options"
 )
 
 /*
@@ -15,6 +16,9 @@ import (
 #cgo linux CFLAGS: -DFFENESTRI_LINUX=1
 #cgo linux pkg-config: gtk+-3.0 webkit2gtk-4.0
 
+#cgo darwin CFLAGS: -DFFENESTRI_DARWIN=1
+#cgo darwin LDFLAGS: -framework WebKit -lobjc
+
 #include <stdlib.h>
 #include "ffenestri.h"
 
@@ -22,42 +26,16 @@ import (
 */
 import "C"
 
-// DEBUG is the global Ffenestri debug flag.
-// TODO: move to compile time.
-var DEBUG bool = true
-
-// Config defines how our application should be configured
-type Config struct {
-	Title      string
-	Width      int
-	Height     int
-	MinWidth   int
-	MinHeight  int
-	MaxWidth   int
-	MaxHeight  int
-	DevTools   bool
-	Resizable  bool
-	Fullscreen bool
-	Frameless  bool
-}
-
-var defaultConfig = &Config{
-	Title:      "My Wails App",
-	Width:      800,
-	Height:     600,
-	DevTools:   true,
-	Resizable:  true,
-	Fullscreen: false,
-	Frameless:  false,
-}
-
 // Application is our main application object
 type Application struct {
-	config *Config
+	config *options.App
 	memory []unsafe.Pointer
 
 	// This is the main app pointer
-	app unsafe.Pointer
+	app *C.struct_Application
+
+	// Manages menus
+	menuManager *menumanager.Manager
 
 	// Logger
 	logger logger.CustomLogger
@@ -78,17 +56,18 @@ func init() {
 }
 
 // NewApplicationWithConfig creates a new application based on the given config
-func NewApplicationWithConfig(config *Config, logger *logger.Logger) *Application {
+func NewApplicationWithConfig(config *options.App, logger *logger.Logger, menuManager *menumanager.Manager) *Application {
 	return &Application{
-		config: config,
-		logger: logger.CustomLogger("Ffenestri"),
+		config:      config,
+		logger:      logger.CustomLogger("Ffenestri"),
+		menuManager: menuManager,
 	}
 }
 
 // NewApplication creates a new Application with the default config
 func NewApplication(logger *logger.Logger) *Application {
 	return &Application{
-		config: defaultConfig,
+		config: options.Default,
 		logger: logger.CustomLogger("Ffenestri"),
 	}
 }
@@ -121,18 +100,28 @@ type DispatchClient interface {
 	SendMessage(string)
 }
 
+func intToColour(colour int) (C.int, C.int, C.int, C.int) {
+	var alpha = C.int(colour & 0xFF)
+	var blue = C.int((colour >> 8) & 0xFF)
+	var green = C.int((colour >> 16) & 0xFF)
+	var red = C.int((colour >> 24) & 0xFF)
+	return red, green, blue, alpha
+}
+
 // Run the application
-func (a *Application) Run(incomingDispatcher Dispatcher, bindings string, features *features.Features) error {
+func (a *Application) Run(incomingDispatcher Dispatcher, bindings string, debug bool) error {
 	title := a.string2CString(a.config.Title)
 	width := C.int(a.config.Width)
 	height := C.int(a.config.Height)
-	resizable := a.bool2Cint(a.config.Resizable)
+	resizable := a.bool2Cint(!a.config.DisableResize)
 	devtools := a.bool2Cint(a.config.DevTools)
 	fullscreen := a.bool2Cint(a.config.Fullscreen)
-	app := C.NewApplication(title, width, height, resizable, devtools, fullscreen)
+	startHidden := a.bool2Cint(a.config.StartHidden)
+	logLevel := C.int(a.config.LogLevel)
+	app := C.NewApplication(title, width, height, resizable, devtools, fullscreen, startHidden, logLevel)
 
 	// Save app reference
-	a.app = unsafe.Pointer(app)
+	a.app = (*C.struct_Application)(app)
 
 	// Set Min Window Size
 	minWidth := C.int(a.config.MinWidth)
@@ -145,11 +134,16 @@ func (a *Application) Run(incomingDispatcher Dispatcher, bindings string, featur
 	C.SetMaxWindowSize(a.app, maxWidth, maxHeight)
 
 	// Set debug if needed
-	C.SetDebug(app, a.bool2Cint(DEBUG))
+	C.SetDebug(app, a.bool2Cint(debug))
 
-	// Set Frameless
-	if a.config.Frameless {
-		C.DisableFrame(a.app)
+	// TODO: Move frameless to Linux options
+	// if a.config.Frameless {
+	// 	C.DisableFrame(a.app)
+	// }
+
+	if a.config.RGBA != 0 {
+		r, g, b, alpha := intToColour(a.config.RGBA)
+		C.SetColour(a.app, r, g, b, alpha)
 	}
 
 	// Escape bindings so C doesn't freak out
@@ -158,13 +152,16 @@ func (a *Application) Run(incomingDispatcher Dispatcher, bindings string, featur
 	// Set bindings
 	C.SetBindings(app, a.string2CString(bindings))
 
-	// Process feature flags
-	a.processFeatureFlags(features)
-
 	// save the dispatcher in a package variable so that the C callbacks
 	// can access it
 	dispatcher = incomingDispatcher.RegisterClient(newClient(a))
 
+	// Process platform settings
+	err := a.processPlatformSettings()
+	if err != nil {
+		return err
+	}
+
 	// Check we could initialise the application
 	if app != nil {
 		// Yes - Save memory reference and run app, cleaning up afterwards
@@ -186,11 +183,3 @@ func (a *Application) Run(incomingDispatcher Dispatcher, bindings string, featur
 func messageFromWindowCallback(data *C.char) {
 	dispatcher.DispatchMessage(C.GoString(data))
 }
-
-func (a *Application) processFeatureFlags(features *features.Features) {
-
-	// Process generic features
-
-	// Process OS Specific flags
-	a.processOSFeatureFlags(features)
-}

v2/internal/ffenestri/ffenestri.h

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

v2/internal/ffenestri/ffenestri_client.go

@@ -12,8 +12,8 @@ package ffenestri
 import "C"
 
 import (
+	"github.com/wailsapp/wails/v2/pkg/options/dialog"
 	"strconv"
-	"unsafe"
 
 	"github.com/wailsapp/wails/v2/internal/logger"
 )
@@ -66,44 +66,136 @@ func (c *Client) WindowUnFullscreen() {
 	C.UnFullscreen(c.app.app)
 }
 
+// WindowShow will show the window
+func (c *Client) WindowShow() {
+	C.Show(c.app.app)
+}
+
+// WindowHide will hide the window
+func (c *Client) WindowHide() {
+	C.Hide(c.app.app)
+}
+
+// WindowCenter will hide the window
+func (c *Client) WindowCenter() {
+	C.Center(c.app.app)
+}
+
+// WindowMaximise will maximise the window
+func (c *Client) WindowMaximise() {
+	C.Maximise(c.app.app)
+}
+
+// WindowMinimise will minimise the window
+func (c *Client) WindowMinimise() {
+	C.Minimise(c.app.app)
+}
+
+// WindowUnmaximise will unmaximise the window
+func (c *Client) WindowUnmaximise() {
+	C.Unmaximise(c.app.app)
+}
+
+// WindowUnminimise will unminimise the window
+func (c *Client) WindowUnminimise() {
+	C.Unminimise(c.app.app)
+}
+
+// WindowPosition will position the window to x,y on the
+// monitor that the window is mostly on
+func (c *Client) WindowPosition(x int, y int) {
+	C.SetPosition(c.app.app, C.int(x), C.int(y))
+}
+
+// WindowSize will resize the window to the given
+// width and height
+func (c *Client) WindowSize(width int, height int) {
+	C.SetSize(c.app.app, C.int(width), C.int(height))
+}
+
 // WindowSetColour sets the window colour
-func (c *Client) WindowSetColour(colour string) bool {
-	result := C.SetColour(c.app.app, c.app.string2CString(colour))
-	return result == 1
+func (c *Client) WindowSetColour(colour int) {
+	r, g, b, a := intToColour(colour)
+	C.SetColour(c.app.app, r, g, b, a)
 }
 
-// OpenFileDialog will open a file dialog with the given title
-func (c *Client) OpenFileDialog(title string) string {
-	cstring := C.OpenFileDialogOnMainThread(c.app.app, c.app.string2CString(title))
-	var result string
-	if cstring != nil {
-		result = C.GoString(cstring)
-		// Free the C string that was allocated by the dialog
-		C.free(unsafe.Pointer(cstring))
-	}
-	return result
+// OpenDialog will open a dialog with the given title and filter
+func (c *Client) OpenDialog(dialogOptions *dialog.OpenDialog, callbackID string) {
+	C.OpenDialog(c.app.app,
+		c.app.string2CString(callbackID),
+		c.app.string2CString(dialogOptions.Title),
+		c.app.string2CString(dialogOptions.Filters),
+		c.app.string2CString(dialogOptions.DefaultFilename),
+		c.app.string2CString(dialogOptions.DefaultDirectory),
+		c.app.bool2Cint(dialogOptions.AllowFiles),
+		c.app.bool2Cint(dialogOptions.AllowDirectories),
+		c.app.bool2Cint(dialogOptions.AllowMultiple),
+		c.app.bool2Cint(dialogOptions.ShowHiddenFiles),
+		c.app.bool2Cint(dialogOptions.CanCreateDirectories),
+		c.app.bool2Cint(dialogOptions.ResolvesAliases),
+		c.app.bool2Cint(dialogOptions.TreatPackagesAsDirectories),
+	)
 }
 
-// SaveFileDialog will open a save file dialog with the given title
-func (c *Client) SaveFileDialog(title string) string {
-	cstring := C.SaveFileDialogOnMainThread(c.app.app, c.app.string2CString(title))
-	var result string
-	if cstring != nil {
-		result = C.GoString(cstring)
-		// Free the C string that was allocated by the dialog
-		C.free(unsafe.Pointer(cstring))
-	}
-	return result
+// SaveDialog will open a dialog with the given title and filter
+func (c *Client) SaveDialog(dialogOptions *dialog.SaveDialog, callbackID string) {
+	C.SaveDialog(c.app.app,
+		c.app.string2CString(callbackID),
+		c.app.string2CString(dialogOptions.Title),
+		c.app.string2CString(dialogOptions.Filters),
+		c.app.string2CString(dialogOptions.DefaultFilename),
+		c.app.string2CString(dialogOptions.DefaultDirectory),
+		c.app.bool2Cint(dialogOptions.ShowHiddenFiles),
+		c.app.bool2Cint(dialogOptions.CanCreateDirectories),
+		c.app.bool2Cint(dialogOptions.TreatPackagesAsDirectories),
+	)
 }
 
-// OpenDirectoryDialog will open a directory dialog with the given title
-func (c *Client) OpenDirectoryDialog(title string) string {
-	cstring := C.OpenDirectoryDialogOnMainThread(c.app.app, c.app.string2CString(title))
-	var result string
-	if cstring != nil {
-		result = C.GoString(cstring)
-		// Free the C string that was allocated by the dialog
-		C.free(unsafe.Pointer(cstring))
+// MessageDialog will open a message dialog with the given options
+func (c *Client) MessageDialog(dialogOptions *dialog.MessageDialog, callbackID string) {
+
+	// Sanity check button length
+	if len(dialogOptions.Buttons) > 4 {
+		c.app.logger.Error("Given %d message dialog buttons. Maximum is 4", len(dialogOptions.Buttons))
+		return
 	}
-	return result
+
+	// Process buttons
+	buttons := []string{"", "", "", ""}
+	for i, button := range dialogOptions.Buttons {
+		buttons[i] = button
+	}
+
+	C.MessageDialog(c.app.app,
+		c.app.string2CString(callbackID),
+		c.app.string2CString(string(dialogOptions.Type)),
+		c.app.string2CString(dialogOptions.Title),
+		c.app.string2CString(dialogOptions.Message),
+		c.app.string2CString(dialogOptions.Icon),
+		c.app.string2CString(buttons[0]),
+		c.app.string2CString(buttons[1]),
+		c.app.string2CString(buttons[2]),
+		c.app.string2CString(buttons[3]),
+		c.app.string2CString(dialogOptions.DefaultButton),
+		c.app.string2CString(dialogOptions.CancelButton))
+}
+
+func (c *Client) DarkModeEnabled(callbackID string) {
+	C.DarkModeEnabled(c.app.app, c.app.string2CString(callbackID))
+}
+
+func (c *Client) SetApplicationMenu(applicationMenuJSON string) {
+	C.SetApplicationMenu(c.app.app, c.app.string2CString(applicationMenuJSON))
+}
+
+func (c *Client) SetTrayMenu(trayMenuJSON string) {
+	C.SetTrayMenu(c.app.app, c.app.string2CString(trayMenuJSON))
+}
+
+func (c *Client) UpdateTrayMenuLabel(JSON string) {
+	C.UpdateTrayMenuLabel(c.app.app, c.app.string2CString(JSON))
+}
+
+func (c *Client) UpdateContextMenu(contextMenuJSON string) {
+	C.UpdateContextMenu(c.app.app, c.app.string2CString(contextMenuJSON))
 }

v2/internal/ffenestri/ffenestri_darwin.go

@@ -2,7 +2,7 @@ package ffenestri
 
 /*
 #cgo darwin CFLAGS: -DFFENESTRI_DARWIN=1
-#cgo darwin LDFLAGS: -framework WebKit -framework CoreFoundation -lobjc
+#cgo darwin LDFLAGS: -framework WebKit -lobjc
 
 #include "ffenestri.h"
 #include "ffenestri_darwin.h"
@@ -48,9 +48,6 @@ func (a *Application) processPlatformSettings() error {
 		C.SetAppearance(a.app, a.string2CString(string(mac.Appearance)))
 	}
 
-	// Set activation policy
-	C.SetActivationPolicy(a.app, C.int(mac.ActivationPolicy))
-
 	// Check if the webview should be transparent
 	if mac.WebviewIsTransparent {
 		C.WebviewIsTransparent(a.app)
@@ -61,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.GetTrayMenus()
+	trays, err := a.menuManager.GetTrayMenusAsJSON()
 	if err != nil {
 		return err
 	}
@@ -79,21 +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 URL Handlers
-	if a.config.Mac.URLHandlers != nil {
-		C.HasURLHandlers(a.app)
-	}
+	//// 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,7 +6,6 @@
 #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"
@@ -14,10 +13,6 @@
 // Macros to make it slightly more sane
 #define msg objc_msgSend
 
-#define kInternetEventClass 'GURL'
-#define kAEGetURL 'GURL'
-#define keyDirectObject '----'
-
 #define c(str) (id)objc_getClass(str)
 #define s(str) sel_registerName(str)
 #define u(str) sel_getUid(str)
@@ -25,6 +20,8 @@
 #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"))
@@ -70,10 +67,6 @@
 #define NSControlStateValueOff 0
 #define NSControlStateValueOn 1
 
-#define NSApplicationActivationPolicyRegular    0
-#define NSApplicationActivationPolicyAccessory  1
-#define NSApplicationActivationPolicyProhibited 2
-
 // Unbelievably, if the user swaps their button preference
 // then right buttons are reported as left buttons
 #define NSEventMaskLeftMouseDown 1 << 1
@@ -116,12 +109,5 @@ 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 SetActivationPolicy(struct Application* app, int policy);
-
-void* lookupStringConstant(id constantName);
-
-void HasURLHandlers(struct Application* app);
 
 #endif

v2/internal/ffenestri/ffenestri_linux.c

@@ -80,6 +80,7 @@ struct Application
     int height;
     int resizable;
     int devtools;
+    int startHidden;
     int fullscreen;
     int minWidth;
     int minHeight;
@@ -100,7 +101,7 @@ struct Application
     int lock;
 };
 
-void *NewApplication(const char *title, int width, int height, int resizable, int devtools, int fullscreen)
+void *NewApplication(const char *title, int width, int height, int resizable, int devtools, int fullscreen, int startHidden)
 {
     // Setup main application struct
     struct Application *result = malloc(sizeof(struct Application));
@@ -115,15 +116,11 @@ void *NewApplication(const char *title, int width, int height, int resizable, in
     result->maxWidth = 0;
     result->maxHeight = 0;
     result->frame = 1;
+    result->startHidden = startHidden;
 
     // Default drag button is PRIMARY
     result->dragButton = PRIMARY_MOUSE_BUTTON;
 
-    // printf("\n\nWidth: %d\n", result->width);
-    // printf("Height: %d\n\n", result->height);
-
-    // Features
-
     result->sendMessageToBackend = (ffenestriCallback)messageFromWindowCallback;
 
     // Create a unique ID based on the current unix timestamp
@@ -139,10 +136,9 @@ void *NewApplication(const char *title, int width, int height, int resizable, in
     return (void *)result;
 }
 
-void DestroyApplication(void *appPointer)
+void DestroyApplication(struct Application *app)
 {
     Debug("Destroying Application");
-    struct Application *app = (struct Application *)appPointer;
 
     g_application_quit(G_APPLICATION(app->application));
 
@@ -171,9 +167,11 @@ void DestroyApplication(void *appPointer)
     // Disconnect signal handlers
     WebKitUserContentManager *manager = webkit_web_view_get_user_content_manager((WebKitWebView *)app->webView);
     g_signal_handler_disconnect(manager, app->signalInvoke);
-    g_signal_handler_disconnect(manager, app->signalWindowDrag);
-    g_signal_handler_disconnect(app->webView, app->signalButtonPressed);
-    g_signal_handler_disconnect(app->webView, app->signalButtonReleased);
+    if( app->frame == 0) {
+        g_signal_handler_disconnect(manager, app->signalWindowDrag);
+        g_signal_handler_disconnect(app->webView, app->signalButtonPressed);
+        g_signal_handler_disconnect(app->webView, app->signalButtonReleased);
+    }
     g_signal_handler_disconnect(app->webView, app->signalLoadChanged);
 
     // Release the main GTK Application
@@ -191,45 +189,34 @@ void DestroyApplication(void *appPointer)
 
 // Quit will stop the gtk application and free up all the memory
 // used by the application
-void Quit(void *appPointer)
+void Quit(struct Application *app)
 {
     Debug("Quit Called");
-    struct Application *app = (struct Application *)appPointer;
     gtk_window_close((GtkWindow *)app->mainWindow);
     g_application_quit((GApplication *)app->application);
-    DestroyApplication(appPointer);
+    DestroyApplication(app);
 }
 
 // SetTitle sets the main window title to the given string
-void SetTitle(void *appPointer, const char *title)
+void SetTitle(struct Application *app, const char *title)
 {
-    struct Application *app = (struct Application *)appPointer;
     gtk_window_set_title(app->mainWindow, title);
 }
 
 // Fullscreen sets the main window to be fullscreen
-void Fullscreen(void *appPointer)
+void Fullscreen(struct Application *app)
 {
-    struct Application *app = (struct Application *)appPointer;
     gtk_window_fullscreen(app->mainWindow);
 }
 
 // UnFullscreen resets the main window after a fullscreen
-void UnFullscreen(void *appPointer)
+void UnFullscreen(struct Application *app)
 {
-    struct Application *app = (struct Application *)appPointer;
     gtk_window_unfullscreen(app->mainWindow);
 }
 
-void Center(void *appPointer)
+void setMinMaxSize(struct Application *app)
 {
-    struct Application *app = (struct Application *)appPointer;
-    gtk_window_set_position(app->mainWindow, GTK_WIN_POS_CENTER);
-}
-
-void setMinMaxSize(void *appPointer)
-{
-    struct Application *app = (struct Application *)appPointer;
     GdkGeometry size;
     size.min_width = size.min_height = size.max_width = size.max_height = 0;
     int flags = 0;
@@ -245,32 +232,43 @@ void setMinMaxSize(void *appPointer)
         size.min_width = app->minWidth;
         flags |= GDK_HINT_MIN_SIZE;
     }
-    Debug("size: %dx%d", app->width, app->height);
-    Debug("min: %dx%d", size.min_width, size.min_height);
-    Debug("max: %dx%d", size.max_width, size.max_height);
     gtk_window_set_geometry_hints(app->mainWindow, NULL, &size, flags);
 }
 
-// OpenFileDialog opens a dialog to select a file
-// NOTE: The result is a string that will need to be freed!
-char *OpenFileDialog(void *appPointer, char *title)
-{
-    struct Application *app = (struct Application *)appPointer;
+char *fileDialogInternal(struct Application *app, GtkFileChooserAction chooserAction, char **args) {
     GtkFileChooserNative *native;
-    GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;
+    GtkFileChooserAction action = chooserAction;
     gint res;
     char *filename;
 
+    char *title = args[0];
+    char *filter = args[1];
+
     native = gtk_file_chooser_native_new(title,
                                          app->mainWindow,
                                          action,
                                          "_Open",
                                          "_Cancel");
 
+    GtkFileChooser *chooser = GTK_FILE_CHOOSER(native);
+
+    // If we have filters, process them
+    if (filter[0] != '\0') {
+        GtkFileFilter *file_filter = gtk_file_filter_new();
+        gchar **filters  = g_strsplit(filter, ",", -1);
+        gint i;
+        for(i = 0; filters && filters[i]; i++) {
+            gtk_file_filter_add_pattern(file_filter, filters[i]);
+            // Debug("Adding filter pattern: %s\n", filters[i]);
+        }
+        gtk_file_filter_set_name(file_filter, filter);
+        gtk_file_chooser_add_filter(chooser, file_filter);
+        g_strfreev(filters);
+    }
+
     res = gtk_native_dialog_run(GTK_NATIVE_DIALOG(native));
     if (res == GTK_RESPONSE_ACCEPT)
     {
-        GtkFileChooser *chooser = GTK_FILE_CHOOSER(native);
         filename = gtk_file_chooser_get_filename(chooser);
     }
 
@@ -279,104 +277,65 @@ char *OpenFileDialog(void *appPointer, char *title)
     return filename;
 }
 
-// SaveFileDialog opens a dialog to select a file
+// openFileDialogInternal opens a dialog to select a file
 // NOTE: The result is a string that will need to be freed!
-char *SaveFileDialog(void *appPointer, char *title)
+char *openFileDialogInternal(struct Application *app, char **args)
 {
-    struct Application *app = (struct Application *)appPointer;
-    GtkFileChooserNative *native;
-    GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_SAVE;
-    gint res;
-    char *filename;
-
-    native = gtk_file_chooser_native_new(title,
-                                         app->mainWindow,
-                                         action,
-                                         "_Save",
-                                         "_Cancel");
-
-    res = gtk_native_dialog_run(GTK_NATIVE_DIALOG(native));
-    if (res == GTK_RESPONSE_ACCEPT)
-    {
-        GtkFileChooser *chooser = GTK_FILE_CHOOSER(native);
-        filename = gtk_file_chooser_get_filename(chooser);
-    }
-
-    g_object_unref(native);
-
-    return filename;
+    return fileDialogInternal(app, GTK_FILE_CHOOSER_ACTION_OPEN, args);
 }
 
-// OpenDirectoryDialog opens a dialog to select a directory
+// saveFileDialogInternal opens a dialog to select a file
 // NOTE: The result is a string that will need to be freed!
-char *OpenDirectoryDialog(void *appPointer, char *title)
+char *saveFileDialogInternal(struct Application *app, char **args)
 {
-    struct Application *app = (struct Application *)appPointer;
-    GtkFileChooserNative *native;
-    GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER;
-    gint res;
-    char *foldername;
-
-    native = gtk_file_chooser_native_new(title,
-                                         app->mainWindow,
-                                         action,
-                                         "_Open",
-                                         "_Cancel");
-
-    res = gtk_native_dialog_run(GTK_NATIVE_DIALOG(native));
-    if (res == GTK_RESPONSE_ACCEPT)
-    {
-        GtkFileChooser *chooser = GTK_FILE_CHOOSER(native);
-        foldername = gtk_file_chooser_get_filename(chooser);
-    }
-
-    g_object_unref(native);
-
-    return foldername;
+    return fileDialogInternal(app, GTK_FILE_CHOOSER_ACTION_SAVE, args);
 }
 
-void SetMinWindowSize(void *appPointer, int minWidth, int minHeight)
+
+// openDirectoryDialogInternal opens a dialog to select a directory
+// NOTE: The result is a string that will need to be freed!
+char *openDirectoryDialogInternal(struct Application *app, char **args)
+{
+    return fileDialogInternal(app, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, args);
+}
+
+void SetMinWindowSize(struct Application *app, int minWidth, int minHeight)
 {
-    struct Application *app = (struct Application *)appPointer;
     app->minWidth = minWidth;
     app->minHeight = minHeight;
 }
 
-void SetMaxWindowSize(void *appPointer, int maxWidth, int maxHeight)
+void SetMaxWindowSize(struct Application *app, int maxWidth, int maxHeight)
 {
-    struct Application *app = (struct Application *)appPointer;
     app->maxWidth = maxWidth;
     app->maxHeight = maxHeight;
 }
 
 // SetColour sets the colour of the webview to the given colour string
-int SetColour(void *appPointer, const char *colourString)
+int SetColour(struct Application *app, const char *colourString)
 {
-    struct Application *app = (struct Application *)appPointer;
     GdkRGBA rgba;
     gboolean result = gdk_rgba_parse(&rgba, colourString);
     if (result == FALSE)
     {
         return 0;
     }
-    Debug("Setting webview colour to: %s", colourString);
+    // Debug("Setting webview colour to: %s", colourString);
     webkit_web_view_get_background_color((WebKitWebView *)(app->webView), &rgba);
     return 1;
 }
 
 // DisableFrame disables the window frame
-void DisableFrame(void *appPointer)
+void DisableFrame(struct Application *app)
 {
-    struct Application *app = (struct Application *)appPointer;
     app->frame = 0;
 }
 
 void syncCallback(GObject *source_object,
                   GAsyncResult *res,
-                  gpointer user_data)
+                  void *data)
 {
-
-    struct Application *app = (struct Application *)user_data;
+    struct Application *app = (struct Application *)data;
     app->lock = 0;
 }
 
@@ -384,8 +343,6 @@ void syncEval(struct Application *app, const gchar *script)
 {
 
     WebKitWebView *webView = (WebKitWebView *)(app->webView);
-    // Debug("[%p] webview\n", webView);
-    // Debug("[%p] Running sync\n", script);
 
     // wait for lock to free
     while (app->lock == 1)
@@ -395,18 +352,15 @@ void syncEval(struct Application *app, const gchar *script)
     // Set lock
     app->lock = 1;
 
-    //
     webkit_web_view_run_javascript(
         webView,
         script,
-        NULL, syncCallback, app);
+        NULL, syncCallback, (void*)app);
 
     while (app->lock == 1)
     {
-        // Debug("[%p] Waiting for callback\n", script);
         g_main_context_iteration(0, true);
     }
-    // Debug("[%p] Finished\n", script);
 }
 
 void asyncEval(WebKitWebView *webView, const gchar *script)
@@ -417,7 +371,7 @@ void asyncEval(WebKitWebView *webView, const gchar *script)
         NULL, NULL, NULL);
 }
 
-typedef void (*dispatchMethod)(void *app, void *);
+typedef void (*dispatchMethod)(struct Application *app, void *);
 
 struct dispatchData
 {
@@ -429,20 +383,14 @@ struct dispatchData
 gboolean executeMethod(gpointer data)
 {
     struct dispatchData *d = (struct dispatchData *)data;
-    struct Application *app = (struct Application *)(d->app);
-    // Debug("Webview %p\n", app->webView);
-    // Debug("Args %s\n", d->args);
-    // Debug("Method %p\n", (d->method));
-    (d->method)(app, d->args);
-    // Debug("Method Execute Complete. Freeing memory");
+    (d->method)(d->app, d->args);
     g_free(d);
     return FALSE;
 }
 
-void ExecJS(void *app, char *js)
+void ExecJS(struct Application *app, char *js)
 {
-    struct dispatchData *data =
-        (struct dispatchData *)g_new(struct dispatchData, 1);
+    struct dispatchData *data = (struct dispatchData *)g_new(struct dispatchData, 1);
     data->method = (dispatchMethod)syncEval;
     data->args = js;
     data->app = app;
@@ -450,13 +398,14 @@ void ExecJS(void *app, char *js)
     gdk_threads_add_idle(executeMethod, data);
 }
 
-typedef char *(*dialogMethod)(void *app, void *);
+typedef char *(*dialogMethod)(struct Application *app, void *);
 
 struct dialogCall
 {
     struct Application *app;
     dialogMethod method;
     void *args;
+    void *filter;
     char *result;
     int done;
 };
@@ -464,79 +413,70 @@ struct dialogCall
 gboolean executeMethodWithReturn(gpointer data)
 {
     struct dialogCall *d = (struct dialogCall *)data;
-    struct Application *app = (struct Application *)(d->app);
-    Debug("Webview %p\n", app->webView);
-    Debug("Args %s\n", d->args);
-    Debug("Method %p\n", (d->method));
-    d->result = (d->method)(app, d->args);
+
+    d->result = (d->method)(d->app, d->args);
     d->done = 1;
-    // Debug("Method Execute Complete. Freeing memory");
     return FALSE;
 }
 
-char *OpenFileDialogOnMainThread(void *app, char *title)
+char *OpenFileDialog(struct Application *app, char *title, char *filter)
 {
-    struct dialogCall *data =
-        (struct dialogCall *)g_new(struct dialogCall, 1);
+    struct dialogCall *data = (struct dialogCall *)g_new(struct dialogCall, 1);
     data->result = NULL;
     data->done = 0;
-    data->method = (dialogMethod)OpenFileDialog;
-    data->args = title;
+    data->method = (dialogMethod)openFileDialogInternal;
+    const char* dialogArgs[]={ title, filter };
+    data->args = dialogArgs;
+    data->app = app;
+
+    gdk_threads_add_idle(executeMethodWithReturn, data);
+
+    while (data->done == 0)
+    {
+        usleep(100000);
+    }
+    g_free(data);
+    return data->result;
+}
+
+char *SaveFileDialog(struct Application *app, char *title, char *filter)
+{
+    struct dialogCall *data = (struct dialogCall *)g_new(struct dialogCall, 1);
+    data->result = NULL;
+    data->done = 0;
+    data->method = (dialogMethod)saveFileDialogInternal;
+    const char* dialogArgs[]={ title, filter };
+    data->args = dialogArgs;
     data->app = app;
 
     gdk_threads_add_idle(executeMethodWithReturn, data);
 
     while (data->done == 0)
     {
-        // Debug("Waiting for dialog");
         usleep(100000);
     }
     Debug("Dialog done");
     Debug("Result = %s\n", data->result);
+
     g_free(data);
     // Fingers crossed this wasn't freed by g_free above
     return data->result;
 }
 
-char *SaveFileDialogOnMainThread(void *app, char *title)
+char *OpenDirectoryDialog(struct Application *app, char *title, char *filter)
 {
-    struct dialogCall *data =
-        (struct dialogCall *)g_new(struct dialogCall, 1);
+    struct dialogCall *data = (struct dialogCall *)g_new(struct dialogCall, 1);
     data->result = NULL;
     data->done = 0;
-    data->method = (dialogMethod)SaveFileDialog;
-    data->args = title;
+    data->method = (dialogMethod)openDirectoryDialogInternal;
+    const char* dialogArgs[]={ title, filter };
+    data->args = dialogArgs;
     data->app = app;
 
     gdk_threads_add_idle(executeMethodWithReturn, data);
 
     while (data->done == 0)
     {
-        // Debug("Waiting for dialog");
-        usleep(100000);
-    }
-    Debug("Dialog done");
-    Debug("Result = %s\n", data->result);
-    g_free(data);
-    // Fingers crossed this wasn't freed by g_free above
-    return data->result;
-}
-
-char *OpenDirectoryDialogOnMainThread(void *app, char *title)
-{
-    struct dialogCall *data =
-        (struct dialogCall *)g_new(struct dialogCall, 1);
-    data->result = NULL;
-    data->done = 0;
-    data->method = (dialogMethod)OpenDirectoryDialog;
-    data->args = title;
-    data->app = app;
-
-    gdk_threads_add_idle(executeMethodWithReturn, data);
-
-    while (data->done == 0)
-    {
-        // Debug("Waiting for dialog");
         usleep(100000);
     }
     Debug("Directory Dialog done");
@@ -555,10 +495,8 @@ void setIcon(struct Application *app)
 
 static void load_finished_cb(WebKitWebView *webView,
                              WebKitLoadEvent load_event,
-                             gpointer userData)
+                             struct Application *app)
 {
-    struct Application *app;
-
     switch (load_event)
     {
     // case WEBKIT_LOAD_STARTED:
@@ -580,7 +518,6 @@ static void load_finished_cb(WebKitWebView *webView,
     case WEBKIT_LOAD_FINISHED:
         /* Load finished, we can now stop the spinner */
         // printf("Finished loading: %s\n", webkit_web_view_get_uri(web_view));
-        app = (struct Application *)userData;
 
         // Bindings
         Debug("Binding Methods");
@@ -637,21 +574,23 @@ static void load_finished_cb(WebKitWebView *webView,
         setMinMaxSize(app);
 
         // Centre by default
-        Center(app);
+        gtk_window_set_position(app->mainWindow, GTK_WIN_POS_CENTER);
 
         // Show window and focus
-        gtk_widget_show_all(GTK_WIDGET(app->mainWindow));
-        gtk_widget_grab_focus(app->webView);
+        if( app->startHidden == 0) {
+            gtk_widget_show_all(GTK_WIDGET(app->mainWindow));
+            gtk_widget_grab_focus(app->webView);
+        }
         break;
     }
 }
 
-static gboolean
-disable_context_menu_cb(WebKitWebView *web_view,
-                        WebKitContextMenu *context_menu,
-                        GdkEvent *event,
-                        WebKitHitTestResult *hit_test_result,
-                        gpointer user_data)
+static gboolean disable_context_menu_cb(
+    WebKitWebView *web_view,
+    WebKitContextMenu *context_menu,
+    GdkEvent *event,
+    WebKitHitTestResult *hit_test_result,
+    gpointer user_data)
 {
     return TRUE;
 }
@@ -666,12 +605,11 @@ static void printEvent(const char *message, GdkEventButton *event)
           event->time);
 }
 
+
 static void dragWindow(WebKitUserContentManager *contentManager,
                        WebKitJavascriptResult *result,
-                       gpointer arg)
+                       struct Application *app)
 {
-    struct Application *app = (struct Application *)arg;
-
     // If we get this message erroneously, ignore
     if (app->dragButtonEvent == NULL)
     {
@@ -696,31 +634,22 @@ static void dragWindow(WebKitUserContentManager *contentManager,
     // Clear the event
     app->dragButtonEvent = NULL;
 
-    return FALSE;
+    return;
 }
 
-gboolean buttonPress(GtkWidget *widget, GdkEventButton *event, gpointer arg)
+gboolean buttonPress(GtkWidget *widget, GdkEventButton *event, struct Application *app)
 {
-    struct Application *app = (struct Application *)arg;
-    Debug("I am pressing a button");
-
     if (event->type == GDK_BUTTON_PRESS && event->button == app->dragButton)
     {
-        printEvent("Drag button event was saved", event);
         app->dragButtonEvent = event;
     }
     return FALSE;
 }
 
-gboolean buttonRelease(GtkWidget *widget, GdkEventButton *event, gpointer arg)
+gboolean buttonRelease(GtkWidget *widget, GdkEventButton *event, struct Application *app)
 {
-    struct Application *app = (struct Application *)arg;
-    Debug("I am releasing a button");
-
     if (event->type == GDK_BUTTON_RELEASE && event->button == app->dragButton)
     {
-        printEvent("Drag button event was reset", event);
-
         app->dragButtonEvent = NULL;
     }
     return FALSE;
@@ -728,9 +657,8 @@ gboolean buttonRelease(GtkWidget *widget, GdkEventButton *event, gpointer arg)
 
 static void sendMessageToBackend(WebKitUserContentManager *contentManager,
                                  WebKitJavascriptResult *result,
-                                 gpointer arg)
+                                 struct Application *app)
 {
-    struct Application *app = (struct Application *)arg;
 #if WEBKIT_MAJOR_VERSION >= 2 && WEBKIT_MINOR_VERSION >= 22
     JSCValue *value = webkit_javascript_result_get_js_value(result);
     char *message = jsc_value_to_string(value);
@@ -747,16 +675,225 @@ static void sendMessageToBackend(WebKitUserContentManager *contentManager,
     g_free(message);
 }
 
-void SetDebug(void *applicationPointer, int flag)
+void SetDebug(struct Application *app, int flag)
 {
-    struct Application *app = (struct Application *)applicationPointer;
     debug = flag;
 }
 
-void SetBindings(void *applicationPointer, const char *bindings)
-{
-    struct Application *app = (struct Application *)applicationPointer;
+// getCurrentMonitorGeometry gets the geometry of the monitor
+// that the window is mostly on.
+GdkRectangle getCurrentMonitorGeometry(GtkWindow *window) {
+    // Get the monitor that the window is currently on
+    GdkDisplay *display = gtk_widget_get_display(GTK_WIDGET(window));
+    GdkWindow *gdk_window = gtk_widget_get_window(GTK_WIDGET(window));
+    GdkMonitor *monitor = gdk_display_get_monitor_at_window (display, gdk_window);
 
+    // Get the geometry of the monitor
+    GdkRectangle result;
+    gdk_monitor_get_geometry (monitor,&result);
+
+    return result;
+}
+
+/*******************
+ * Window Position *
+ *******************/
+
+// Position holds an x/y corrdinate
+struct Position {
+    int x;
+    int y;
+};
+
+// Internal call for setting the position of the window.
+void setPositionInternal(struct Application *app, struct Position *pos) {
+
+    // Get the monitor geometry
+    GdkRectangle m = getCurrentMonitorGeometry(app->mainWindow);
+
+    // Move the window relative to the monitor
+    gtk_window_move(app->mainWindow, m.x + pos->x, m.y + pos->y);
+    
+    // Free memory
+    free(pos);
+}
+
+// SetPosition sets the position of the window to the given x/y 
+// coordinates. The x/y values are relative to the monitor 
+// the window is mostly on.
+void SetPosition(struct Application *app, int x, int y) {
+    struct dispatchData *data = (struct dispatchData *)g_new(struct dispatchData, 1);
+    data->method = (dispatchMethod)setPositionInternal;
+    struct Position *pos = malloc(sizeof(struct Position));
+    pos->x = x;
+    pos->y = y;
+    data->args = pos;
+    data->app = app;
+
+    gdk_threads_add_idle(executeMethod, data);  
+}
+
+/***************
+ * Window Size *
+ ***************/
+
+// Size holds a width/height
+struct Size {
+    int width;
+    int height;
+};
+
+// Internal call for setting the size of the window.
+void setSizeInternal(struct Application *app, struct Size *size) {
+    gtk_window_resize(app->mainWindow, size->width, size->height);
+    free(size);
+}
+
+// SetSize sets the size of the window to the given width/height
+void SetSize(struct Application *app, int width, int height) {
+    struct dispatchData *data = (struct dispatchData *)g_new(struct dispatchData, 1);
+    data->method = (dispatchMethod)setSizeInternal;
+    struct Size *size = malloc(sizeof(struct Size));
+    size->width = width;
+    size->height = height;
+    data->args = size;
+    data->app = app;
+
+    gdk_threads_add_idle(executeMethod, data);  
+}
+
+
+// centerInternal will center the main window on the monitor it is mostly in
+void centerInternal(struct Application *app)
+{
+    // Get the geometry of the monitor
+    GdkRectangle m = getCurrentMonitorGeometry(app->mainWindow);
+
+    // Get the window width/height
+    int windowWidth, windowHeight;
+    gtk_window_get_size(app->mainWindow, &windowWidth, &windowHeight);
+
+    // Place the window at the center of the monitor
+    gtk_window_move(app->mainWindow, ((m.width - windowWidth) / 2) + m.x, ((m.height - windowHeight) / 2) + m.y);
+}
+
+// Center the window
+void Center(struct Application *app) {
+
+    // Setup a call to centerInternal on the main thread
+    struct dispatchData *data = (struct dispatchData *)g_new(struct dispatchData, 1);
+    data->method = (dispatchMethod)centerInternal;
+    data->app = app;
+
+    // Add call to main thread
+    gdk_threads_add_idle(executeMethod, data);  
+}
+
+// hideInternal hides the main window
+void hideInternal(struct Application *app) {
+    gtk_widget_hide (GTK_WIDGET(app->mainWindow));
+}
+
+// Hide places the hideInternal method onto the main thread for execution
+void Hide(struct Application *app) {
+
+    // Setup a call to hideInternal on the main thread
+    struct dispatchData *data = (struct dispatchData *)g_new(struct dispatchData, 1);
+    data->method = (dispatchMethod)hideInternal;
+    data->app = app;
+
+    // Add call to main thread
+    gdk_threads_add_idle(executeMethod, data);  
+}
+
+// showInternal shows the main window 
+void showInternal(struct Application *app) {
+    gtk_widget_show_all(GTK_WIDGET(app->mainWindow));
+    gtk_widget_grab_focus(app->webView);
+}
+
+// Show places the showInternal method onto the main thread for execution
+void Show(struct Application *app) {
+    struct dispatchData *data = (struct dispatchData *)g_new(struct dispatchData, 1);
+    data->method = (dispatchMethod)showInternal;
+    data->app = app;
+
+    gdk_threads_add_idle(executeMethod, data);  
+}
+
+
+// maximiseInternal maximises the main window
+void maximiseInternal(struct Application *app) {
+    gtk_window_maximize(GTK_WIDGET(app->mainWindow));
+}
+
+// Maximise places the maximiseInternal method onto the main thread for execution
+void Maximise(struct Application *app) {
+
+    // Setup a call to maximiseInternal on the main thread
+    struct dispatchData *data = (struct dispatchData *)g_new(struct dispatchData, 1);
+    data->method = (dispatchMethod)maximiseInternal;
+    data->app = app;
+
+    // Add call to main thread
+    gdk_threads_add_idle(executeMethod, data);  
+}
+
+// unmaximiseInternal unmaximises the main window
+void unmaximiseInternal(struct Application *app) {
+    gtk_window_unmaximize(GTK_WIDGET(app->mainWindow));
+}
+
+// Unmaximise places the unmaximiseInternal method onto the main thread for execution
+void Unmaximise(struct Application *app) {
+
+    // Setup a call to unmaximiseInternal on the main thread
+    struct dispatchData *data = (struct dispatchData *)g_new(struct dispatchData, 1);
+    data->method = (dispatchMethod)unmaximiseInternal;
+    data->app = app;
+
+    // Add call to main thread
+    gdk_threads_add_idle(executeMethod, data);  
+}
+
+
+// minimiseInternal minimises the main window
+void minimiseInternal(struct Application *app) {
+    gtk_window_iconify(app->mainWindow);
+}
+
+// Minimise places the minimiseInternal method onto the main thread for execution
+void Minimise(struct Application *app) {
+
+    // Setup a call to minimiseInternal on the main thread
+    struct dispatchData *data = (struct dispatchData *)g_new(struct dispatchData, 1);
+    data->method = (dispatchMethod)minimiseInternal;
+    data->app = app;
+
+    // Add call to main thread
+    gdk_threads_add_idle(executeMethod, data);  
+}
+
+// unminimiseInternal unminimises the main window
+void unminimiseInternal(struct Application *app) {
+    gtk_window_present(app->mainWindow);
+}
+
+// Unminimise places the unminimiseInternal method onto the main thread for execution
+void Unminimise(struct Application *app) {
+
+    // Setup a call to unminimiseInternal on the main thread
+    struct dispatchData *data = (struct dispatchData *)g_new(struct dispatchData, 1);
+    data->method = (dispatchMethod)unminimiseInternal;
+    data->app = app;
+
+    // Add call to main thread
+    gdk_threads_add_idle(executeMethod, data);  
+}
+
+
+void SetBindings(struct Application *app, const char *bindings)
+{
     const char *temp = concat("window.wailsbindings = \"", bindings);
     const char *jscall = concat(temp, "\";");
     free((void *)temp);
@@ -766,18 +903,15 @@ void SetBindings(void *applicationPointer, const char *bindings)
 // This is called when the close button on the window is pressed
 gboolean close_button_pressed(GtkWidget *widget,
                               GdkEvent *event,
-                              gpointer user_data)
+                              struct Application *app)
 {
-    struct Application *app = (struct Application *)user_data;
     app->sendMessageToBackend("WC"); // Window Close
     return TRUE;
 }
 
-static void setupWindow(void *applicationPointer)
+static void setupWindow(struct Application *app)
 {
 
-    struct Application *app = (struct Application *)applicationPointer;
-
     // Create the window
     GtkWidget *mainWindow = gtk_application_window_new(app->application);
     // Save reference
@@ -796,10 +930,14 @@ static void setupWindow(void *applicationPointer)
     webkit_user_content_manager_register_script_message_handler(contentManager, "external");
     app->signalInvoke = g_signal_connect(contentManager, "script-message-received::external", G_CALLBACK(sendMessageToBackend), app);
 
-    // Setup the window drag handler
-    webkit_user_content_manager_register_script_message_handler(contentManager, "windowDrag");
-    app->signalWindowDrag = g_signal_connect(contentManager, "script-message-received::windowDrag", G_CALLBACK(dragWindow), app);
-
+    // Setup the window drag handler if this is a frameless app
+    if ( app->frame == 0 ) {
+        webkit_user_content_manager_register_script_message_handler(contentManager, "windowDrag");
+        app->signalWindowDrag = g_signal_connect(contentManager, "script-message-received::windowDrag", G_CALLBACK(dragWindow), app);
+        // Setup the mouse handlers
+        app->signalButtonPressed = g_signal_connect(app->webView, "button-press-event", G_CALLBACK(buttonPress), app);
+        app->signalButtonReleased = g_signal_connect(app->webView, "button-release-event", G_CALLBACK(buttonRelease), app);
+    }
     GtkWidget *webView = webkit_web_view_new_with_user_content_manager(contentManager);
 
     // Save reference
@@ -808,9 +946,6 @@ static void setupWindow(void *applicationPointer)
     // Add the webview to the window
     gtk_container_add(GTK_CONTAINER(mainWindow), webView);
 
-    // Setup the mouse handlers
-    app->signalButtonPressed = g_signal_connect(app->webView, "button-press-event", G_CALLBACK(buttonPress), app);
-    app->signalButtonReleased = g_signal_connect(app->webView, "button-release-event", G_CALLBACK(buttonRelease), app);
 
     // Load default HTML
     app->signalLoadChanged = g_signal_connect(G_OBJECT(webView), "load-changed", G_CALLBACK(load_finished_cb), app);
@@ -835,20 +970,13 @@ static void setupWindow(void *applicationPointer)
     g_signal_connect(GTK_WIDGET(mainWindow), "delete-event", G_CALLBACK(close_button_pressed), app);
 }
 
-static void
-activate(GtkApplication *app,
-         gpointer user_data)
+static void activate(GtkApplication* _, struct Application *app)
 {
-    struct Application *mainApp = (struct Application *)user_data;
-
-    // Main Window
-    setupWindow(mainApp);
+    setupWindow(app);
 }
 
-void Run(void *applicationPointer, int argc, char **argv)
+void Run(struct Application *app, int argc, char **argv)
 {
-    struct Application *app = (struct Application *)applicationPointer;
-
     g_signal_connect(app->application, "activate", G_CALLBACK(activate), app);
     g_application_run(G_APPLICATION(app->application), argc, argv);
 }

v2/internal/ffenestri/menu.c

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

v2/internal/ffenestri/menu.h

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

v2/internal/ffenestri/menu_darwin.h

@@ -1,116 +1,21 @@
 //
-// Created by Lea Anthony on 6/1/21.
+// Created by Lea Anthony on 18/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",
-};
-
-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 *);
+#include "menu.h"
 
 typedef struct {
-
-    const char *title;
-
-    /*** Internal ***/
-
-    // The decoded version of the Menu JSON
-    JsonNode *processedMenu;
-
-    struct hashmap_s menuItemMap;
-    struct hashmap_s radioGroupMap;
-
-    // Vector to keep track of callback data memory
-    vec_void_t callbackDataCache;
-
-    // The NSMenu for this menu
-    id menu;
-
-    // The parent data, eg ContextMenuStore or Tray
-    void *parentData;
-
-    // The commands for the menu callbacks
-    const char *callbackCommand;
-
-    // This indicates if we are an Application Menu, tray menu or context menu
-    enum MenuType menuType;
-
-
-} Menu;
-
+    id Menu;
+} MacMenu;
 
 typedef struct {
-    id menuItem;
-    Menu *menu;
-    const char *menuID;
-    enum MenuItemType menuItemType;
-} MenuItemCallbackData;
+    id MenuItem;
+} MacMenuItem;
 
+typedef struct {
+    id statusBarItem;
+    int iconPosition;
+} MacTrayMenu;
 
-
-// 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, bool alternate);
-void processMenuItem(Menu *menu, id parentMenu, JsonNode *item);
-void processMenuData(Menu *menu, JsonNode *menuData);
-
-void processRadioGroupJSON(Menu *menu, JsonNode *radioGroup);
-id GetMenu(Menu *menu);
-id createAttributedString(const char* title, const char* fontName, int fontSize, const char* RGBA);
-
-#endif //ASSETS_C_MENU_DARWIN_H
+void PlatformMenuItemCallback(id self, SEL cmd, id sender);

v2/internal/ffenestri/menu_darwin_old.c

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

v2/internal/ffenestri/menu_darwin_old.h

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

v2/internal/ffenestri/menu_item.c

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

v2/internal/ffenestri/menu_manager.c

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

v2/internal/ffenestri/menu_tray.c

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

v2/internal/ffenestri/test_app/CMakeLists.txt

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

v2/internal/ffenestri/test_menumanager/CMakeLists.txt

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

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

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

v2/internal/ffenestri/test_menumanager/minunit.h

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

v2/internal/ffenestri/test_menumanager/test.c

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

v2/internal/ffenestri/traymenu_darwin.c

@@ -6,13 +6,11 @@
 #include "traymenu_darwin.h"
 #include "trayicons.h"
 
-extern Class trayMenuDelegateClass;
-
 // A cache for all our tray menu icons
 // Global because it's a singleton
 struct hashmap_s trayIconCache;
 
-TrayMenu* NewTrayMenu(const char* menuJSON) {
+TrayMenu* NewTrayMenu(const char* menuJSON, struct TrayMenuStore* store) {
     TrayMenu* result = malloc(sizeof(TrayMenu));
 
 /*
@@ -23,37 +21,29 @@ TrayMenu* NewTrayMenu(const char* menuJSON) {
         ABORT("[NewTrayMenu] Unable to parse TrayMenu JSON: %s", menuJSON);
     }
 
-    // Save reference to this json
-    result->processedJSON = processedJSON;
-
     // TODO: Make this configurable
     result->trayIconPosition = NSImageLeft;
 
-    result->ID = mustJSONString(processedJSON, "ID");
-    result->label = mustJSONString(processedJSON, "Label");
-    result->icon = mustJSONString(processedJSON, "Image");
-    result->fontName = getJSONString(processedJSON, "FontName");
-    result->RGBA = getJSONString(processedJSON, "RGBA");
-    getJSONBool(processedJSON, "MacTemplateImage", &result->templateImage);
-    result->fontSize = 0;
-    getJSONInt(processedJSON, "FontSize", &result->fontSize);
-    result->tooltip = NULL;
-    result->tooltip = getJSONString(processedJSON, "Tooltip");
-    result->disabled = false;
-    getJSONBool(processedJSON, "Disabled", &result->disabled);
+    result->ID = STRCOPY(mustJSONString(processedJSON, "I"));
+    result->label = STRCOPY(getJSONString(processedJSON, "l"));
+    result->icon = STRCOPY(getJSONString(processedJSON, "i"));
+    result->menu = NULL;
 
-    // Create the menu
-    JsonNode* processedMenu = mustJSONObject(processedJSON, "ProcessedMenu");
-    result->menu = NewMenu(processedMenu);
+    JsonNode* menu = getJSONObject(processedJSON, "m");
+    if( menu != NULL ) {
 
-    result->delegate = NULL;
+        JsonNode* radioGroups = getJSONObject(processedJSON, "r");
+
+        // Create the menu
+        result->menu = NewMenu(menu, radioGroups, store);
+        result->menu->menuType = TrayMenuType;
+    }
 
     // Init tray status bar item
     result->statusbaritem = NULL;
 
-    // Set the menu type and store the tray ID in the parent data
-    result->menu->menuType = TrayMenuType;
-    result->menu->parentData = (void*) result->ID;
+    // Free JSON
+    json_delete(processedJSON);
 
     return result;
 }
@@ -63,25 +53,6 @@ void DumpTrayMenu(TrayMenu* trayMenu) {
 }
 
 
-void UpdateTrayLabel(TrayMenu *trayMenu, const char *label, const char *fontName, int fontSize, const char *RGBA, const char *tooltip, bool disabled) {
-
-    // Exit early if NULL
-    if( trayMenu->label == NULL ) {
-        return;
-    }
-    // Update button label
-    id statusBarButton = msg(trayMenu->statusbaritem, s("button"));
-    id attributedString = createAttributedString(label, fontName, fontSize, RGBA);
-
-    if( tooltip != NULL ) {
-        msg(statusBarButton, s("setToolTip:"), str(tooltip));
-    }
-
-    msg(statusBarButton, s("setEnabled:"), !disabled);
-
-    msg(statusBarButton, s("setAttributedTitle:"), attributedString);
-}
-
 void UpdateTrayIcon(TrayMenu *trayMenu) {
 
     // Exit early if NULL
@@ -99,24 +70,12 @@ void UpdateTrayIcon(TrayMenu *trayMenu) {
     }
 
     id trayImage = hashmap_get(&trayIconCache, trayMenu->icon, strlen(trayMenu->icon));
-
-    // If we don't have the image in the icon cache then assume it's base64 encoded image data
-    if (trayImage == NULL) {
-        id data = ALLOC("NSData");
-        id imageData = msg(data, s("initWithBase64EncodedString:options:"), str(trayMenu->icon), 0);
-        trayImage = ALLOC("NSImage");
-        msg(trayImage, s("initWithData:"), imageData);
-
-        if( trayMenu->templateImage ) {
-            msg(trayImage, s("setTemplate:"), YES);
-        }
-    }
-
     msg(statusBarButton, s("setImagePosition:"), trayMenu->trayIconPosition);
     msg(statusBarButton, s("setImage:"), trayImage);
-
 }
 
+
+
 void ShowTrayMenu(TrayMenu* trayMenu) {
 
     // Create a status bar item if we don't have one
@@ -124,6 +83,7 @@ void ShowTrayMenu(TrayMenu* trayMenu) {
         id statusBar = msg( c("NSStatusBar"), s("systemStatusBar") );
         trayMenu->statusbaritem = msg(statusBar, s("statusItemWithLength:"), NSVariableStatusItemLength);
         msg(trayMenu->statusbaritem, s("retain"));
+
     }
 
     id statusBarButton = msg(trayMenu->statusbaritem, s("button"));
@@ -133,21 +93,12 @@ void ShowTrayMenu(TrayMenu* trayMenu) {
     UpdateTrayIcon(trayMenu);
 
     // Update the label if needed
-    UpdateTrayLabel(trayMenu, trayMenu->label, trayMenu->fontName, trayMenu->fontSize, trayMenu->RGBA, trayMenu->tooltip, trayMenu->disabled);
+    UpdateTrayLabel(trayMenu, trayMenu->label);
 
     // Update the menu
-    id menu = GetMenu(trayMenu->menu);
-    objc_setAssociatedObject(menu, "trayMenuID", str(trayMenu->ID), OBJC_ASSOCIATION_ASSIGN);
-
-	// Create delegate
-	id trayMenuDelegate = msg((id)trayMenuDelegateClass, s("new"));
-	msg(menu, s("setDelegate:"), trayMenuDelegate);
-	objc_setAssociatedObject(trayMenuDelegate, "menu", menu, OBJC_ASSOCIATION_ASSIGN);
-
-    // Create menu delegate
-    trayMenu->delegate = trayMenuDelegate;
-
-    msg(trayMenu->statusbaritem, s("setMenu:"), menu);
+    if (trayMenu->menu != NULL ) {
+        msg(trayMenu->statusbaritem, s("setMenu:"), trayMenu->menu->menu);
+    }
 }
 
 // UpdateTrayMenuInPlace receives 2 menus. The current menu gets
@@ -160,17 +111,11 @@ 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 = newMenu->ID;
-    currentMenu->label = newMenu->label;
+    currentMenu->ID = STRCOPY(newMenu->ID);
+    currentMenu->label = STRCOPY(newMenu->label);
     currentMenu->trayIconPosition = newMenu->trayIconPosition;
-    currentMenu->icon = newMenu->icon;
+    currentMenu->icon = STRCOPY(newMenu->icon);
 
 }
 
@@ -182,10 +127,10 @@ void DeleteTrayMenu(TrayMenu* trayMenu) {
     // Delete the menu
     DeleteMenu(trayMenu->menu);
 
-    // Free JSON
-    if (trayMenu->processedJSON != NULL ) {
-        json_delete(trayMenu->processedJSON);
-    }
+    // Free strings
+    MEMFREE(trayMenu->label);
+    MEMFREE(trayMenu->icon);
+    MEMFREE(trayMenu->ID);
 
     // Free the status item
     if ( trayMenu->statusbaritem != NULL ) {
@@ -195,10 +140,6 @@ void DeleteTrayMenu(TrayMenu* trayMenu) {
         trayMenu->statusbaritem = NULL;
     }
 
-    if ( trayMenu->delegate != NULL ) {
-        msg(trayMenu->delegate, s("release"));
-    }
-
     // Free the tray menu memory
     MEMFREE(trayMenu);
 }
@@ -235,14 +176,3 @@ 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,39 +6,26 @@
 #define TRAYMENU_DARWIN_H
 
 #include "common.h"
-#include "menu_darwin.h"
+#include "menu_darwin_old.h"
 
 typedef struct {
 
     const char *label;
     const char *icon;
     const char *ID;
-    const char *tooltip;
-
-    bool templateImage;
-    const char *fontName;
-    int fontSize;
-    const char *RGBA;
-
-    bool disabled;
 
     Menu* menu;
 
     id statusbaritem;
     int trayIconPosition;
-
-    JsonNode* processedJSON;
-
-    id delegate;
-
 } TrayMenu;
 
-TrayMenu* NewTrayMenu(const char *trayJSON);
+TrayMenu* NewTrayMenu(const char *trayJSON, struct TrayMenuStore* store);
 void DumpTrayMenu(TrayMenu* trayMenu);
 void ShowTrayMenu(TrayMenu* trayMenu);
 void UpdateTrayMenuInPlace(TrayMenu* currentMenu, TrayMenu* newMenu);
 void UpdateTrayIcon(TrayMenu *trayMenu);
-void UpdateTrayLabel(TrayMenu *trayMenu, const char *label, const char *fontName, int fontSize, const char *RGBA, const char *tooltip, bool disabled);
+void UpdateTrayLabel(TrayMenu *trayMenu, const char*);
 
 void LoadTrayIcons();
 void UnloadTrayIcons();

v2/internal/ffenestri/traymenustore_darwin.c

@@ -16,9 +16,9 @@ TrayMenuStore* NewTrayMenuStore() {
         ABORT("[NewTrayMenuStore] Not enough memory to allocate trayMenuMap!");
     }
 
-    if (pthread_mutex_init(&result->lock, NULL) != 0) {
-        printf("\n mutex init has failed\n");
-        exit(1);
+    // Allocate menu item store
+    if( 0 != hashmap_create((const unsigned)8, &result->menuItemMap)) {
+        ABORT("[NewTrayMenuStore] Not enough memory to allocate menuItemMap!");
     }
 
     return result;
@@ -30,19 +30,15 @@ int dumpTrayMenu(void *const context, struct hashmap_element_s *const e) {
 }
 
 void DumpTrayMenuStore(TrayMenuStore* store) {
-    pthread_mutex_lock(&store->lock);
     hashmap_iterate_pairs(&store->trayMenuMap, dumpTrayMenu, NULL);
-    pthread_mutex_unlock(&store->lock);
 }
 
 void AddTrayMenuToStore(TrayMenuStore* store, const char* menuJSON) {
+    TrayMenu* newMenu = NewTrayMenu(menuJSON, (struct TrayMenuStore *) store);
 
-    TrayMenu* newMenu = NewTrayMenu(menuJSON);
-
-    pthread_mutex_lock(&store->lock);
     //TODO: check if there is already an entry for this menu
     hashmap_put(&store->trayMenuMap, newMenu->ID, strlen(newMenu->ID), newMenu);
-    pthread_mutex_unlock(&store->lock);
+
 }
 
 int showTrayMenu(void *const context, struct hashmap_element_s *const e) {
@@ -52,13 +48,12 @@ int showTrayMenu(void *const context, struct hashmap_element_s *const e) {
 }
 
 void ShowTrayMenusInStore(TrayMenuStore* store) {
-    pthread_mutex_lock(&store->lock);
     if( hashmap_num_entries(&store->trayMenuMap) > 0 ) {
         hashmap_iterate_pairs(&store->trayMenuMap, showTrayMenu, NULL);
     }
-    pthread_mutex_unlock(&store->lock);
 }
 
+
 int freeTrayMenu(void *const context, struct hashmap_element_s *const e) {
     DeleteTrayMenu(e->data);
     return -1;
@@ -76,38 +71,33 @@ void DeleteTrayMenuStore(TrayMenuStore *store) {
     // Destroy tray menu map
     hashmap_destroy(&store->trayMenuMap);
 
-    pthread_mutex_destroy(&store->lock);
+    // Destroy menu item map
+    hashmap_destroy(&store->menuItemMap);
 }
 
 TrayMenu* GetTrayMenuFromStore(TrayMenuStore* store, const char* menuID) {
     // Get the current menu
-    pthread_mutex_lock(&store->lock);
-    TrayMenu* result = hashmap_get(&store->trayMenuMap, menuID, strlen(menuID));
-    pthread_mutex_unlock(&store->lock);
-    return result;
+    return hashmap_get(&store->trayMenuMap, menuID, strlen(menuID));
 }
 
 TrayMenu* MustGetTrayMenuFromStore(TrayMenuStore* store, const char* menuID) {
     // Get the current menu
-    pthread_mutex_lock(&store->lock);
     TrayMenu* result = hashmap_get(&store->trayMenuMap, menuID, strlen(menuID));
-    pthread_mutex_unlock(&store->lock);
-
     if (result == NULL ) {
         ABORT("Unable to find TrayMenu with ID '%s' in the TrayMenuStore!", menuID);
     }
     return result;
 }
 
-void DeleteTrayMenuInStore(TrayMenuStore* store, const char* ID) {
-
-    TrayMenu *menu = MustGetTrayMenuFromStore(store, ID);
-    pthread_mutex_lock(&store->lock);
-    hashmap_remove(&store->trayMenuMap, ID, strlen(ID));
-    pthread_mutex_unlock(&store->lock);
-    DeleteTrayMenu(menu);
+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);
@@ -118,23 +108,12 @@ void UpdateTrayMenuLabelInStore(TrayMenuStore* store, const char* JSON) {
 
     // Check we have this menu
     TrayMenu *menu = MustGetTrayMenuFromStore(store, ID);
-
-    const char *fontName = getJSONString(parsedUpdate, "FontName");
-    const char *RGBA = getJSONString(parsedUpdate, "RGBA");
-    int fontSize = 0;
-    getJSONInt(parsedUpdate, "FontSize", &fontSize);
-    const char *tooltip = getJSONString(parsedUpdate, "Tooltip");
-    bool disabled = false;
-    getJSONBool(parsedUpdate, "Disabled", &disabled);
-
-    UpdateTrayLabel(menu, Label, fontName, fontSize, RGBA, tooltip, disabled);
-
+    UpdateTrayLabel(menu, Label);
 
 }
 
-void UpdateTrayMenuInStore(TrayMenuStore* store, const char* menuJSON) {
-    TrayMenu* newMenu = NewTrayMenu(menuJSON);
-//    DumpTrayMenu(newMenu);
+TrayMenu* UpdateTrayMenuInStore(TrayMenuStore* store, const char* menuJSON) {
+    TrayMenu* newMenu = NewTrayMenu(menuJSON, (struct TrayMenuStore *) store);
 
     // Get the current menu
     TrayMenu *currentMenu = GetTrayMenuFromStore(store, newMenu->ID);
@@ -142,22 +121,15 @@ void UpdateTrayMenuInStore(TrayMenuStore* store, const char* menuJSON) {
     // If we don't have a menu, we create one
     if ( currentMenu == NULL ) {
         // Store the new menu
-        pthread_mutex_lock(&store->lock);
         hashmap_put(&store->trayMenuMap, newMenu->ID, strlen(newMenu->ID), newMenu);
-        pthread_mutex_unlock(&store->lock);
 
-        // Show it
-        ShowTrayMenu(newMenu);
-        return;
+        return newMenu;
     }
-//    DumpTrayMenu(currentMenu);
 
     // Save the status bar reference
     newMenu->statusbaritem = currentMenu->statusbaritem;
 
-    pthread_mutex_lock(&store->lock);
     hashmap_remove(&store->trayMenuMap, newMenu->ID, strlen(newMenu->ID));
-    pthread_mutex_unlock(&store->lock);
 
     // Delete the current menu
     DeleteMenu(currentMenu->menu);
@@ -166,10 +138,13 @@ void UpdateTrayMenuInStore(TrayMenuStore* store, const char* menuJSON) {
     // Free the tray menu memory
     MEMFREE(currentMenu);
 
-    pthread_mutex_lock(&store->lock);
     hashmap_put(&store->trayMenuMap, newMenu->ID, strlen(newMenu->ID), newMenu);
-    pthread_mutex_unlock(&store->lock);
 
-    // Show the updated menu
-    ShowTrayMenu(newMenu);
+    return newMenu;
+
 }
+
+const char* GetContextMenuDataFromStore(TrayMenuStore *store) {
+    return store->contextMenuData;
+}
+

v2/internal/ffenestri/traymenustore_darwin.h

@@ -7,8 +7,6 @@
 
 #include "traymenu_darwin.h"
 
-#include <pthread.h>
-
 typedef struct {
 
 	int dummy;
@@ -17,20 +15,26 @@ typedef struct {
     // It maps tray IDs to TrayMenu*
     struct hashmap_s trayMenuMap;
 
-    pthread_mutex_t lock;
+    // 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);
-void UpdateTrayMenuInStore(TrayMenuStore* store, const char* menuJSON);
+TrayMenu* UpdateTrayMenuInStore(TrayMenuStore* store, const char* menuJSON);
 void ShowTrayMenusInStore(TrayMenuStore* store);
 void DeleteTrayMenuStore(TrayMenuStore* store);
 
-TrayMenu* GetTrayMenuByID(TrayMenuStore* store, const char* menuID);
+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);
-void DeleteTrayMenuInStore(TrayMenuStore* store, const char* id);
+const char* GetContextMenuDataFromStore(TrayMenuStore *store);
 
 #endif //TRAYMENUSTORE_DARWIN_H

v2/internal/ffenestri/vec.h

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

v2/internal/fs/fs.go

@@ -9,6 +9,8 @@ import (
 	"path/filepath"
 	"runtime"
 	"unsafe"
+
+	"github.com/leaanthony/slicer"
 )
 
 // LocalDirectory gets the caller's file directory
@@ -18,11 +20,45 @@ func LocalDirectory() string {
 	return filepath.Dir(thisFile)
 }
 
+// RelativeToCwd returns an absolute path based on the cwd
+// and the given relative path
+func RelativeToCwd(relativePath string) (string, error) {
+	cwd, err := os.Getwd()
+	if err != nil {
+		return "", err
+	}
+
+	return filepath.Join(cwd, relativePath), nil
+}
+
 // Mkdir will create the given directory
 func Mkdir(dirname string) error {
 	return os.Mkdir(dirname, 0755)
 }
 
+// MkDirs creates the given nested directories.
+// Returns error on failure
+func MkDirs(fullPath string, mode ...os.FileMode) error {
+	var perms os.FileMode
+	perms = 0700
+	if len(mode) == 1 {
+		perms = mode[0]
+	}
+	return os.MkdirAll(fullPath, perms)
+}
+
+// MoveFile attempts to move the source file to the target
+// Target is a fully qualified path to a file *name*, not a
+// directory
+func MoveFile(source string, target string) error {
+	return os.Rename(source, target)
+}
+
+// DeleteFile will delete the given file
+func DeleteFile(filename string) error {
+	return os.Remove(filename)
+}
+
 // CopyFile from source to target
 func CopyFile(source string, target string) error {
 	s, err := os.Open(source)
@@ -144,3 +180,100 @@ func fatal(message ...string) {
 	}
 	os.Exit(1)
 }
+
+// GetSubdirectories returns a list of subdirectories for the given root directory
+func GetSubdirectories(rootDir string) (*slicer.StringSlicer, error) {
+	var result slicer.StringSlicer
+
+	// Iterate root dir
+	err := filepath.Walk(rootDir, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		// If we have a directory, save it
+		if info.IsDir() {
+			result.Add(path)
+		}
+		return nil
+	})
+	return &result, err
+}
+
+func DirIsEmpty(dir string) (bool, error) {
+
+	if !DirExists(dir) {
+		return false, fmt.Errorf("DirIsEmpty called with a non-existant directory: %s", dir)
+	}
+
+	// CREDIT: https://stackoverflow.com/a/30708914/8325411
+	f, err := os.Open(dir)
+	if err != nil {
+		return false, err
+	}
+	defer f.Close()
+
+	_, err = f.Readdirnames(1) // Or f.Readdir(1)
+	if err == io.EOF {
+		return true, nil
+	}
+	return false, err // Either not empty or error, suits both cases
+}
+
+// Credit: https://gist.github.com/r0l1/92462b38df26839a3ca324697c8cba04
+// CopyDir recursively copies a directory tree, attempting to preserve permissions.
+// Source directory must exist, destination directory must *not* exist.
+// Symlinks are ignored and skipped.
+func CopyDir(src string, dst string) (err error) {
+	src = filepath.Clean(src)
+	dst = filepath.Clean(dst)
+
+	si, err := os.Stat(src)
+	if err != nil {
+		return err
+	}
+	if !si.IsDir() {
+		return fmt.Errorf("source is not a directory")
+	}
+
+	_, err = os.Stat(dst)
+	if err != nil && !os.IsNotExist(err) {
+		return
+	}
+	if err == nil {
+		return fmt.Errorf("destination already exists")
+	}
+
+	err = os.MkdirAll(dst, si.Mode())
+	if err != nil {
+		return
+	}
+
+	entries, err := ioutil.ReadDir(src)
+	if err != nil {
+		return
+	}
+
+	for _, entry := range entries {
+		srcPath := filepath.Join(src, entry.Name())
+		dstPath := filepath.Join(dst, entry.Name())
+
+		if entry.IsDir() {
+			err = CopyDir(srcPath, dstPath)
+			if err != nil {
+				return
+			}
+		} else {
+			// Skip symlinks.
+			if entry.Mode()&os.ModeSymlink != 0 {
+				continue
+			}
+
+			err = CopyFile(srcPath, dstPath)
+			if err != nil {
+				return
+			}
+		}
+	}
+
+	return
+}

v2/internal/github/github.go

@@ -1,103 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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/html/asset.go

@@ -3,11 +3,15 @@ package html
 import (
 	"fmt"
 	"io/ioutil"
+	"log"
 	"net/url"
 	"path/filepath"
 	"regexp"
 	"strings"
 	"unsafe"
+
+	"github.com/tdewolff/minify"
+	"github.com/tdewolff/minify/js"
 )
 
 type assetTypes struct {
@@ -63,6 +67,10 @@ func (a *Asset) AsCHexData() string {
 		result = strings.ReplaceAll(result, "\n", "")
 		result = strings.ReplaceAll(result, "\r\n", "")
 		result = strings.ReplaceAll(result, "\n", "")
+
+		// Inject wailsloader code
+		result = strings.Replace(result, `</body>`, `<script id='wailsloader'>window.wailsloader = { html: true, runtime: false, userjs: false, usercss: false };var self=document.querySelector('#wailsloader');self.parentNode.removeChild(self);</script></body>`, 1)
+
 		url := url.URL{Path: result}
 		urlString := strings.ReplaceAll(url.String(), "/", "%2f")
 
@@ -84,6 +92,16 @@ func (a *Asset) AsCHexData() string {
 		result = strings.ReplaceAll(result, ` {`, `{`)
 		result = strings.ReplaceAll(result, `: `, `:`)
 		dataString = fmt.Sprintf("window.wails._.InjectCSS(\"%s\");", result)
+
+	case AssetTypes.JS:
+		m := minify.New()
+		m.AddFunc("application/javascript", js.Minify)
+		var err error
+		dataString, err = m.String("application/javascript", a.Data+";")
+		if err != nil {
+			log.Fatal(err)
+		}
+		a.Data = dataString
 	}
 
 	// Get byte data of the string
@@ -103,6 +121,7 @@ func (a *Asset) AsCHexData() string {
 	return cdata.String()
 }
 
+// Dump will output the asset to the terminal
 func (a *Asset) Dump() {
 	fmt.Printf("{ Type: %s, Path: %s, Data: %+v }\n", a.Type, a.Path, a.Data[:10])
 }

v2/internal/html/assetbundle.go

@@ -61,6 +61,8 @@ func (a *AssetBundle) processHTML(htmldata string) error {
 	buf := bytes.NewBufferString(htmldata)
 	tokenizer := html.NewTokenizer(buf)
 
+	paths := slicer.String()
+
 	for {
 		//get the next token type
 		tokenType := tokenizer.Next()
@@ -100,19 +102,29 @@ func (a *AssetBundle) processHTML(htmldata string) error {
 					if attr.Key == "href" {
 						asset.Path = attr.Val
 					}
-					// stylesheet
+					// standard stylesheet
 					if attr.Key == "rel" && attr.Val == "stylesheet" {
 						asset.Type = AssetTypes.CSS
 					}
+					if attr.Key == "as" && attr.Val == "style" {
+						asset.Type = AssetTypes.CSS
+					}
+					if attr.Key == "as" && attr.Val == "script" {
+						asset.Type = AssetTypes.JS
+					}
 				}
-				err := asset.Load(a.basedirectory)
-				if err != nil {
-					return err
+
+				// Ensure we don't include duplicates
+				if !paths.Contains(asset.Path) {
+					err := asset.Load(a.basedirectory)
+					if err != nil {
+						return err
+					}
+					a.assets = append(a.assets, asset)
+					paths.Add(asset.Path)
 				}
-				a.assets = append(a.assets, asset)
 			}
 			if "script" == token.Data {
-
 				tokenType = tokenizer.Next()
 				//just make sure it's actually a text token
 				asset := &Asset{Type: AssetTypes.JS}
@@ -122,11 +134,14 @@ func (a *AssetBundle) processHTML(htmldata string) error {
 						break
 					}
 				}
-				err := asset.Load(a.basedirectory)
-				if err != nil {
-					return err
+				if !paths.Contains(asset.Path) {
+					err := asset.Load(a.basedirectory)
+					if err != nil {
+						return err
+					}
+					a.assets = append(a.assets, asset)
+					paths.Add(asset.Path)
 				}
-				a.assets = append(a.assets, asset)
 			}
 		}
 	}
@@ -141,7 +156,7 @@ func (a *AssetBundle) WriteToCFile(targetDir string) (string, error) {
 	var cdata strings.Builder
 
 	// Write header
-	header := `// assets.c
+	header := `// assets.h
 // Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL.
 // This file was auto-generated. DO NOT MODIFY.
 
@@ -153,6 +168,10 @@ func (a *AssetBundle) WriteToCFile(targetDir string) (string, error) {
 	assetVariables := slicer.String()
 	var variableName string
 	for index, asset := range a.assets {
+		// For desktop we ignore the favicon
+		if asset.Type == AssetTypes.FAVICON {
+			continue
+		}
 		variableName = fmt.Sprintf("%s%d", asset.Type, index)
 		assetCdata := fmt.Sprintf("const unsigned char %s[]={ %s0x00 };\n", variableName, asset.AsCHexData())
 		cdata.WriteString(assetCdata)
@@ -160,13 +179,13 @@ func (a *AssetBundle) WriteToCFile(targetDir string) (string, error) {
 	}
 
 	if assetVariables.Length() > 0 {
-		cdata.WriteString(fmt.Sprintf("\nconst char *assets[] = { %s, 0x00 };", assetVariables.Join(", ")))
+		cdata.WriteString(fmt.Sprintf("\nconst unsigned char *assets[] = { %s, 0x00 };", assetVariables.Join(", ")))
 	} else {
-		cdata.WriteString("\nconst char *assets[] = { 0x00 };")
+		cdata.WriteString("\nconst unsigned char *assets[] = { 0x00 };")
 	}
 
 	// Save file
-	assetsFile := filepath.Join(targetDir, "assets.c")
+	assetsFile := filepath.Join(targetDir, "assets.h")
 	err = ioutil.WriteFile(assetsFile, []byte(cdata.String()), 0600)
 	if err != nil {
 		return "", err
@@ -177,16 +196,17 @@ func (a *AssetBundle) WriteToCFile(targetDir string) (string, error) {
 // ConvertToAssetDB returns an assetdb.AssetDB initialized with
 // the items in the AssetBundle
 func (a *AssetBundle) ConvertToAssetDB() (*assetdb.AssetDB, error) {
-	assetdb := assetdb.NewAssetDB()
+	theassetdb := assetdb.NewAssetDB()
 
 	// Loop over the Assets
 	for _, asset := range a.assets {
-		assetdb.AddAsset(asset.Path, []byte(asset.Data))
+		theassetdb.AddAsset(asset.Path, []byte(asset.Data))
 	}
 
-	return assetdb, nil
+	return theassetdb, nil
 }
 
+// Dump will output the assets to the terminal
 func (a *AssetBundle) Dump() {
 	println("Assets:")
 	for _, asset := range a.assets {

v2/internal/logger/custom_logger.go

@@ -2,31 +2,30 @@ package logger
 
 import (
 	"fmt"
-	"os"
 )
 
 // CustomLogger defines what a user can do with a logger
 type CustomLogger interface {
 	// Writeln writes directly to the output with no log level plus line ending
-	Writeln(message string) error
+	Writeln(message string)
 
 	// Write writes directly to the output with no log level
-	Write(message string) error
+	Write(message string)
 
 	// Trace level logging. Works like Sprintf.
-	Trace(format string, args ...interface{}) error
+	Trace(format string, args ...interface{})
 
 	// Debug level logging. Works like Sprintf.
-	Debug(format string, args ...interface{}) error
+	Debug(format string, args ...interface{})
 
 	// Info level logging. Works like Sprintf.
-	Info(format string, args ...interface{}) error
+	Info(format string, args ...interface{})
 
 	// Warning level logging. Works like Sprintf.
-	Warning(format string, args ...interface{}) error
+	Warning(format string, args ...interface{})
 
 	// Error level logging. Works like Sprintf.
-	Error(format string, args ...interface{}) error
+	Error(format string, args ...interface{})
 
 	// Fatal level logging. Works like Sprintf.
 	Fatal(format string, args ...interface{})
@@ -50,49 +49,48 @@ func newcustomLogger(logger *Logger, name string) *customLogger {
 
 // Writeln writes directly to the output with no log level
 // Appends a carriage return to the message
-func (l *customLogger) Writeln(message string) error {
-	return l.logger.Writeln(message)
+func (l *customLogger) Writeln(message string) {
+	l.logger.Writeln(message)
 }
 
 // Write writes directly to the output with no log level
-func (l *customLogger) Write(message string) error {
-	return l.logger.Write(message)
+func (l *customLogger) Write(message string) {
+	l.logger.Write(message)
 }
 
 // Trace level logging. Works like Sprintf.
-func (l *customLogger) Trace(format string, args ...interface{}) error {
+func (l *customLogger) Trace(format string, args ...interface{}) {
 	format = fmt.Sprintf("%s | %s", l.name, format)
-	return l.logger.processLogMessage(TRACE, format, args...)
+	l.logger.Trace(format, args...)
 }
 
 // Debug level logging. Works like Sprintf.
-func (l *customLogger) Debug(format string, args ...interface{}) error {
+func (l *customLogger) Debug(format string, args ...interface{}) {
 	format = fmt.Sprintf("%s | %s", l.name, format)
-	return l.logger.processLogMessage(DEBUG, format, args...)
+	l.logger.Debug(format, args...)
 }
 
 // Info level logging. Works like Sprintf.
-func (l *customLogger) Info(format string, args ...interface{}) error {
+func (l *customLogger) Info(format string, args ...interface{}) {
 	format = fmt.Sprintf("%s | %s", l.name, format)
-	return l.logger.processLogMessage(INFO, format, args...)
+	l.logger.Info(format, args...)
 }
 
 // Warning level logging. Works like Sprintf.
-func (l *customLogger) Warning(format string, args ...interface{}) error {
+func (l *customLogger) Warning(format string, args ...interface{}) {
 	format = fmt.Sprintf("%s | %s", l.name, format)
-	return l.logger.processLogMessage(WARNING, format, args...)
+	l.logger.Warning(format, args...)
 }
 
 // Error level logging. Works like Sprintf.
-func (l *customLogger) Error(format string, args ...interface{}) error {
+func (l *customLogger) Error(format string, args ...interface{}) {
 	format = fmt.Sprintf("%s | %s", l.name, format)
-	return l.logger.processLogMessage(ERROR, format, args...)
+	l.logger.Error(format, args...)
 
 }
 
 // Fatal level logging. Works like Sprintf.
 func (l *customLogger) Fatal(format string, args ...interface{}) {
 	format = fmt.Sprintf("%s | %s", l.name, format)
-	l.logger.processLogMessage(FATAL, format, args...)
-	os.Exit(1)
+	l.logger.Fatal(format, args...)
 }

v2/internal/logger/default_logger.go

@@ -2,37 +2,32 @@ package logger
 
 import (
 	"fmt"
-	"io"
 	"os"
-	"sync"
+
+	"github.com/wailsapp/wails/v2/pkg/logger"
 )
 
+// LogLevel is an alias for the public LogLevel
+type LogLevel = logger.LogLevel
+
 // Logger is a utlility to log messages to a number of destinations
 type Logger struct {
-	writers        []io.Writer
-	logLevel       uint8
+	output         logger.Logger
+	logLevel       LogLevel
 	showLevelInLog bool
-	lock           sync.RWMutex
 }
 
 // New creates a new Logger. You may pass in a number of `io.Writer`s that
 // are the targets for the logs
-func New(writers ...io.Writer) *Logger {
+func New(output logger.Logger) *Logger {
 	result := &Logger{
-		logLevel:       INFO,
+		logLevel:       logger.INFO,
 		showLevelInLog: true,
-	}
-	for _, writer := range writers {
-		result.AddOutput(writer)
+		output:         output,
 	}
 	return result
 }
 
-// Writers gets the log writers
-func (l *Logger) Writers() []io.Writer {
-	return l.writers
-}
-
 // CustomLogger creates a new custom logger that prints out a name/id
 // before the messages
 func (l *Logger) CustomLogger(name string) CustomLogger {
@@ -45,99 +40,66 @@ func (l *Logger) HideLogLevel() {
 }
 
 // SetLogLevel sets the minimum level of logs that will be output
-func (l *Logger) SetLogLevel(level uint8) {
+func (l *Logger) SetLogLevel(level LogLevel) {
 	l.logLevel = level
 }
 
-// AddOutput adds the given `io.Writer` to the list of destinations
-// that get logged to
-func (l *Logger) AddOutput(writer io.Writer) {
-	l.writers = append(l.writers, writer)
-}
-
-func (l *Logger) write(loglevel uint8, message string) error {
-
-	// Don't print logs lower than the current log level
-	if loglevel < l.logLevel {
-		return nil
-	}
-
-	// Show log level text if enabled
-	if l.showLevelInLog {
-		message = mapLogLevel[loglevel] + message
-	}
-
-	// write out the logs
-	l.lock.Lock()
-	for _, writer := range l.writers {
-		_, err := writer.Write([]byte(message))
-		if err != nil {
-			l.lock.Unlock() // Because defer is slow
-			return err
-		}
-	}
-	l.lock.Unlock()
-	return nil
-}
-
-// writeln appends a newline character to the message before writing
-func (l *Logger) writeln(loglevel uint8, message string) error {
-	return l.write(loglevel, message+"\n")
-}
-
 // Writeln writes directly to the output with no log level
 // Appends a carriage return to the message
-func (l *Logger) Writeln(message string) error {
-	return l.write(BYPASS, message+"\n")
+func (l *Logger) Writeln(message string) {
+	l.output.Print(message)
 }
 
 // Write writes directly to the output with no log level
-func (l *Logger) Write(message string) error {
-	return l.write(BYPASS, message)
+func (l *Logger) Write(message string) {
+	l.output.Print(message)
 }
 
-// processLogMessage formats the given message before writing it out
-func (l *Logger) processLogMessage(loglevel uint8, format string, args ...interface{}) error {
-	message := fmt.Sprintf(format, args...)
-	return l.writeln(loglevel, message)
+// Print writes directly to the output with no log level
+// Appends a carriage return to the message
+func (l *Logger) Print(message string) {
+	l.Write(message)
 }
 
 // Trace level logging. Works like Sprintf.
-func (l *Logger) Trace(format string, args ...interface{}) error {
-	return l.processLogMessage(TRACE, format, args...)
-}
-
-// CustomTrace returns a custom Logging function that will insert the given name before the message
-func (l *Logger) CustomTrace(name string) func(format string, args ...interface{}) {
-	return func(format string, args ...interface{}) {
-		format = name + " | " + format
-		l.processLogMessage(TRACE, format, args...)
+func (l *Logger) Trace(format string, args ...interface{}) {
+	if l.logLevel <= logger.TRACE {
+		l.output.Trace(fmt.Sprintf(format, args...))
 	}
 }
 
 // Debug level logging. Works like Sprintf.
-func (l *Logger) Debug(format string, args ...interface{}) error {
-	return l.processLogMessage(DEBUG, format, args...)
+func (l *Logger) Debug(format string, args ...interface{}) {
+	if l.logLevel <= logger.DEBUG {
+		l.output.Debug(fmt.Sprintf(format, args...))
+	}
 }
 
 // Info level logging. Works like Sprintf.
-func (l *Logger) Info(format string, args ...interface{}) error {
-	return l.processLogMessage(INFO, format, args...)
+func (l *Logger) Info(format string, args ...interface{}) {
+	if l.logLevel <= logger.INFO {
+		l.output.Info(fmt.Sprintf(format, args...))
+	}
+
 }
 
 // Warning level logging. Works like Sprintf.
-func (l *Logger) Warning(format string, args ...interface{}) error {
-	return l.processLogMessage(WARNING, format, args...)
+func (l *Logger) Warning(format string, args ...interface{}) {
+	if l.logLevel <= logger.WARNING {
+		l.output.Warning(fmt.Sprintf(format, args...))
+	}
 }
 
 // Error level logging. Works like Sprintf.
-func (l *Logger) Error(format string, args ...interface{}) error {
-	return l.processLogMessage(ERROR, format, args...)
+func (l *Logger) Error(format string, args ...interface{}) {
+	if l.logLevel <= logger.ERROR {
+		l.output.Error(fmt.Sprintf(format, args...))
+	}
 
 }
 
 // Fatal level logging. Works like Sprintf.
 func (l *Logger) Fatal(format string, args ...interface{}) {
-	l.processLogMessage(FATAL, format, args...)
+	l.output.Fatal(fmt.Sprintf(format, args...))
 	os.Exit(1)
 }

v2/internal/logger/logger.go

@@ -1,34 +0,0 @@
-package logger
-
-const (
-	// TRACE level
-	TRACE uint8 = 0
-
-	// DEBUG level logging
-	DEBUG uint8 = 1
-
-	// INFO level logging
-	INFO uint8 = 2
-
-	// WARNING level logging
-	WARNING uint8 = 4
-
-	// ERROR level logging
-	ERROR uint8 = 8
-
-	// FATAL level logging
-	FATAL uint8 = 16
-
-	// BYPASS level logging - does not use a log level
-	BYPASS uint8 = 255
-)
-
-var mapLogLevel = map[uint8]string{
-	TRACE:   "TRACE | ",
-	DEBUG:   "DEBUG | ",
-	INFO:    "INFO  | ",
-	WARNING: "WARN  | ",
-	ERROR:   "ERROR | ",
-	FATAL:   "FATAL | ",
-	BYPASS:  "",
-}

v2/internal/logger/logger_test.go

@@ -1,202 +0,0 @@
-package logger
-
-import (
-	"bytes"
-	"io/ioutil"
-	"log"
-	"os"
-	"testing"
-
-	"github.com/matryer/is"
-)
-
-func TestByteBufferLogger(t *testing.T) {
-
-	is := is.New(t)
-
-	// Create new byte buffer logger
-	var buf bytes.Buffer
-
-	myLogger := New(&buf)
-	myLogger.SetLogLevel(TRACE)
-
-	tests := map[uint8]string{
-		TRACE:   "TRACE | I am a message!\n",
-		DEBUG:   "DEBUG | I am a message!\n",
-		WARNING: "WARN  | I am a message!\n",
-		INFO:    "INFO  | I am a message!\n",
-		ERROR:   "ERROR | I am a message!\n",
-	}
-
-	methods := map[uint8]func(string, ...interface{}) error{
-		TRACE:   myLogger.Trace,
-		DEBUG:   myLogger.Debug,
-		WARNING: myLogger.Warning,
-		INFO:    myLogger.Info,
-		ERROR:   myLogger.Error,
-	}
-
-	for level, expected := range tests {
-
-		buf.Reset()
-
-		method := methods[level]
-
-		// Write message
-		err := method("I am a message!")
-		if err != nil {
-			panic(err)
-		}
-		actual := buf.String()
-
-		is.Equal(actual, expected)
-	}
-
-}
-func TestCustomLogger(t *testing.T) {
-
-	is := is.New(t)
-
-	// Create new byte buffer logger
-	var buf bytes.Buffer
-
-	myLogger := New(&buf)
-	myLogger.SetLogLevel(TRACE)
-	customLogger := myLogger.CustomLogger("Test")
-
-	tests := map[uint8]string{
-		TRACE:   "TRACE | Test | I am a message!\n",
-		DEBUG:   "DEBUG | Test | I am a message!\n",
-		WARNING: "WARN  | Test | I am a message!\n",
-		INFO:    "INFO  | Test | I am a message!\n",
-		ERROR:   "ERROR | Test | I am a message!\n",
-	}
-
-	methods := map[uint8]func(string, ...interface{}) error{
-		TRACE:   customLogger.Trace,
-		DEBUG:   customLogger.Debug,
-		WARNING: customLogger.Warning,
-		INFO:    customLogger.Info,
-		ERROR:   customLogger.Error,
-	}
-
-	for level, expected := range tests {
-
-		buf.Reset()
-
-		method := methods[level]
-
-		// Write message
-		err := method("I am a message!")
-		if err != nil {
-			panic(err)
-		}
-		actual := buf.String()
-
-		is.Equal(actual, expected)
-	}
-
-}
-func TestWriteln(t *testing.T) {
-
-	is := is.New(t)
-
-	// Create new byte buffer logger
-	var buf bytes.Buffer
-
-	myLogger := New(&buf)
-	myLogger.SetLogLevel(DEBUG)
-
-	buf.Reset()
-
-	// Write message
-	err := myLogger.Writeln("I am a message!")
-	if err != nil {
-		panic(err)
-	}
-	actual := buf.String()
-
-	is.Equal(actual, "I am a message!\n")
-
-	buf.Reset()
-
-	// Write message
-	err = myLogger.Write("I am a message!")
-	if err != nil {
-		panic(err)
-	}
-	actual = buf.String()
-
-	is.Equal(actual, "I am a message!")
-
-}
-
-func TestLogLevel(t *testing.T) {
-
-	is := is.New(t)
-
-	// Create new byte buffer logger
-	var buf bytes.Buffer
-
-	myLogger := New(&buf)
-	myLogger.SetLogLevel(ERROR)
-
-	tests := map[uint8]string{
-		TRACE:   "",
-		DEBUG:   "",
-		WARNING: "",
-		INFO:    "",
-		ERROR:   "ERROR | I am a message!\n",
-	}
-
-	methods := map[uint8]func(string, ...interface{}) error{
-		TRACE:   myLogger.Trace,
-		DEBUG:   myLogger.Debug,
-		WARNING: myLogger.Warning,
-		INFO:    myLogger.Info,
-		ERROR:   myLogger.Error,
-	}
-
-	for level := range tests {
-
-		method := methods[level]
-
-		// Write message
-		err := method("I am a message!")
-		if err != nil {
-			panic(err)
-		}
-
-	}
-	actual := buf.String()
-
-	is.Equal(actual, "ERROR | I am a message!\n")
-}
-
-func TestFileLogger(t *testing.T) {
-
-	is := is.New(t)
-
-	// Create new byte buffer logger
-	file, err := ioutil.TempFile(".", "wailsv2test")
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer os.Remove(file.Name())
-
-	myLogger := New(file)
-	myLogger.SetLogLevel(DEBUG)
-
-	// Write message
-	err = myLogger.Info("I am a message!")
-	if err != nil {
-		panic(err)
-	}
-	actual, err := ioutil.ReadFile(file.Name())
-	if err != nil {
-		panic(err)
-	}
-
-	is.Equal(string(actual), "INFO  | I am a message!\n")
-
-}

v2/internal/menumanager/applicationmenu.go

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

v2/internal/menumanager/menuitemmap.go

@@ -1,75 +0,0 @@
-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,89 +2,53 @@ package menumanager
 
 import (
 	"fmt"
+	"github.com/wailsapp/wails/v2/internal/counter"
 	"github.com/wailsapp/wails/v2/pkg/menu"
 )
 
 type Manager struct {
 
-	// The application menu.
-	applicationMenu     *menu.Menu
-	applicationMenuJSON string
+	// 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
 
-	// Our application menu mappings
-	applicationMenuItemMap *MenuItemMap
+	// Menus
+	menuIDCounter *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
+	// Map wails menus to internal menus
+	trayMenuMap       map[*menu.TrayMenu]*TrayMenu
+	trayMenuIDCounter *counter.Counter
 }
 
 func NewManager() *Manager {
 	return &Manager{
-		applicationMenuItemMap: NewMenuItemMap(),
-		contextMenus:           make(map[string]*ContextMenu),
-		contextMenuPointers:    make(map[*menu.ContextMenu]string),
-		trayMenus:              make(map[string]*TrayMenu),
-		trayMenuPointers:       make(map[*menu.TrayMenu]string),
+		trayMenuMap:        make(map[*menu.TrayMenu]*TrayMenu),
+		trayMenuIDCounter:  counter.NewCounter(0),
+		menuIDCounter:      counter.NewCounter(0),
+		menuItemMap:        make(map[string]*menu.MenuItem),
+		menuItemIDCounter:  counter.NewCounter(0),
+		processedMenuItems: make(map[*menu.MenuItem]*ProcessedMenuItem),
 	}
 }
 
-func (m *Manager) 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)
+func (m *Manager) ProcessClick(menuID string, data string) error {
+	// Get item from callback map
+	menuItem := m.menuItemMap[menuID]
 	if menuItem == nil {
-		return fmt.Errorf("Cannot process menuid %s - unknown", menuID)
-	}
-
-	// Is the menu item a checkbox?
-	if menuItem.Type == menu.CheckboxType {
-		// Toggle state
-		menuItem.Checked = !menuItem.Checked
+		return fmt.Errorf("menuItem doesn't exist")
 	}
 
 	if menuItem.Click == nil {
-		// No callback
-		return fmt.Errorf("No callback for menu '%s'", menuItem.Label)
+		return fmt.Errorf("menuItem 'does not have a callback")
 	}
 
-	// Create new Callback struct
 	callbackData := &menu.CallbackData{
 		MenuItem:    menuItem,
 		ContextData: data,
 	}
 
-	// Call back!
+	// Callback!
 	go menuItem.Click(callbackData)
-
 	return nil
 }

v2/internal/menumanager/processedMenu.go

@@ -2,88 +2,165 @@ package menumanager
 
 import (
 	"encoding/json"
-
+	"fmt"
 	"github.com/wailsapp/wails/v2/pkg/menu"
 	"github.com/wailsapp/wails/v2/pkg/menu/keys"
 )
 
-type ProcessedMenuItem struct {
-	ID string
-	// Label is what appears as the menu text
-	Label string `json:",omitempty"`
-	// Role is a predefined menu type
-	Role menu.Role `json:",omitempty"`
-	// Accelerator holds a representation of a key binding
-	Accelerator *keys.Accelerator `json:",omitempty"`
-	// Type of MenuItem, EG: Checkbox, Text, Separator, Radio, Submenu
-	Type menu.Type
-	// Disabled makes the item unselectable
-	Disabled bool `json:",omitempty"`
-	// Hidden ensures that the item is not shown in the menu
-	Hidden bool `json:",omitempty"`
-	// Checked indicates if the item is selected (used by Checkbox and Radio types only)
-	Checked bool `json:",omitempty"`
-	// Submenu contains a list of menu items that will be shown as a submenu
-	//SubMenu []*MenuItem `json:"SubMenu,omitempty"`
-	SubMenu *ProcessedMenu `json:",omitempty"`
+type ProcessedMenu struct {
+	ID string `json:"I"`
 
-	// 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"`
-	MacAlternate     bool   `json:", omitempty"`
-
-	// Tooltip
-	Tooltip string `json:",omitempty"`
+	Items       []*ProcessedMenuItem `json:"i,omitempty"`
+	RadioGroups []*RadioGroup        `json:"r,omitempty"`
 }
 
-func NewProcessedMenuItem(menuItemMap *MenuItemMap, menuItem *menu.MenuItem) *ProcessedMenuItem {
+func (m *Manager) ProcessMenu(menu *menu.Menu) *ProcessedMenu {
+	wm := m.NewWailsMenu(menu)
+
+	if len(wm.Menu) == 0 {
+		return nil
+	}
+
+	return &ProcessedMenu{
+		ID:          m.generateMenuID(),
+		Items:       wm.Menu,
+		RadioGroups: wm.RadioGroups,
+	}
+}
+
+type ProcessedMenuItem struct {
+	// ID of the menu item
+	ID string `json:"I"`
+
+	// Label is what appears as the menu text
+	Label string `json:"l,omitempty"`
+
+	// AlternateLabel is a secondary label (Used by Mac)
+	AlternateLabel string `json:"L,omitempty"`
+
+	// Role is a predefined menu type
+	Role menu.Role `json:"r,omitempty"`
+
+	// Accelerator holds a representation of a key binding
+	Accelerator *keys.Accelerator `json:"a,omitempty"`
+
+	// Type of MenuItem, EG: Checkbox, Text, Separator, Radio, Submenu
+	Type menu.Type `json:"t,omitempty"`
+
+	// Font to use for the menu item
+	Font string `json:"f,omitempty"`
+
+	// Font to use for the menu item
+	FontSize int `json:"F,omitempty"`
+
+	// RGBA is the colour of the menu item
+	RGBA string `json:"R,omitempty"`
+
+	// Image is an image for the menu item (base64 string)
+	Image string `json:"i,omitempty"`
+
+	// Disabled makes the item unselectable
+	Disabled *bool `json:"d,omitempty"`
+
+	// Hidden ensures that the item is not shown in the menu
+	Hidden *bool `json:"h,omitempty"`
+
+	// Checked indicates if the item is selected (used by Checkbox and Radio types only)
+	Checked *bool `json:"c,omitempty"`
+
+	// Submenu contains a list of menu items that will be shown as a submenu
+	//SubMenu []*MenuItem `json:"SubMenu,omitempty"`
+	SubMenu []*ProcessedMenuItem `json:"s,omitempty"`
+
+	// Indicates if this item has a callback
+	HasCallback *bool `json:"C,omitempty"`
+}
+
+func (m *Manager) generateMenuItemID() string {
+	return fmt.Sprintf("%d", m.menuItemIDCounter.Increment())
+}
+
+func (m *Manager) generateMenuID() string {
+	return fmt.Sprintf("%d", m.menuIDCounter.Increment())
+}
+
+func (m *Manager) NewProcessedMenuItem(menuItem *menu.MenuItem) *ProcessedMenuItem {
+
+	// Check if this menu has already been processed.
+	// This is to prevent duplicates.
+	existingMenuItem := m.processedMenuItems[menuItem]
+	if existingMenuItem != nil {
+		return &ProcessedMenuItem{ID: existingMenuItem.ID}
+	}
+
+	ID := m.generateMenuItemID()
 
-	ID := menuItemMap.menuItemToIDMap[menuItem]
 	result := &ProcessedMenuItem{
-		ID:               ID,
-		Label:            menuItem.Label,
-		Role:             menuItem.Role,
-		Accelerator:      menuItem.Accelerator,
-		Type:             menuItem.Type,
-		Disabled:         menuItem.Disabled,
-		Hidden:           menuItem.Hidden,
-		Checked:          menuItem.Checked,
-		SubMenu:          nil,
-		RGBA:             menuItem.RGBA,
-		FontSize:         menuItem.FontSize,
-		FontName:         menuItem.FontName,
-		Image:            menuItem.Image,
-		MacTemplateImage: menuItem.MacTemplateImage,
-		MacAlternate:     menuItem.MacAlternate,
-		Tooltip:          menuItem.Tooltip,
+		ID:             ID,
+		Label:          menuItem.Label,
+		AlternateLabel: menuItem.AlternateLabel,
+		Role:           menuItem.Role,
+		Accelerator:    menuItem.Accelerator,
+		Type:           menuItem.Type,
+		Font:           menuItem.Font,
+		FontSize:       menuItem.FontSize,
+		RGBA:           menuItem.RGBA,
+		Image:          menuItem.Image,
+		Disabled:       nil,
+		Hidden:         nil,
+		Checked:        nil,
+		SubMenu:        nil,
+		HasCallback:    nil,
+	}
+
+	if menuItem.Hidden {
+		result.Hidden = new(bool)
+		*result.Hidden = true
+	}
+
+	if menuItem.Disabled {
+		result.Disabled = new(bool)
+		*result.Disabled = true
+	}
+
+	if menuItem.Checked {
+		result.Checked = new(bool)
+		*result.Checked = true
+	}
+
+	if menuItem.Click != nil {
+		result.HasCallback = new(bool)
+		*result.HasCallback = true
 	}
 
 	if menuItem.SubMenu != nil {
-		result.SubMenu = NewProcessedMenu(menuItemMap, menuItem.SubMenu)
+		result.SubMenu = m.NewProcessedMenu(menuItem.SubMenu)
 	}
 
+	// Add menu item to item map
+	m.menuItemMap[ID] = menuItem
+
+	// Add processed Item to processedMenuItems
+	m.processedMenuItems[menuItem] = result
+
 	return result
 }
 
-type ProcessedMenu struct {
-	Items []*ProcessedMenuItem
-}
+func (m *Manager) NewProcessedMenu(menu *menu.Menu) []*ProcessedMenuItem {
 
-func NewProcessedMenu(menuItemMap *MenuItemMap, menu *menu.Menu) *ProcessedMenu {
+	if menu == nil {
+		return nil
+	}
 
-	result := &ProcessedMenu{}
-	if menu != nil {
-		for _, item := range menu.Items {
-			processedMenuItem := NewProcessedMenuItem(menuItemMap, item)
-			result.Items = append(result.Items, processedMenuItem)
-		}
+	if menu.Items == nil {
+		return nil
+	}
+
+	var result []*ProcessedMenuItem
+
+	for _, item := range menu.Items {
+		processedMenuItem := m.NewProcessedMenuItem(item)
+		result = append(result, processedMenuItem)
 	}
 
 	return result
@@ -92,8 +169,8 @@ func NewProcessedMenu(menuItemMap *MenuItemMap, menu *menu.Menu) *ProcessedMenu
 // WailsMenu is the original menu with the addition
 // of radio groups extracted from the menu data
 type WailsMenu struct {
-	Menu              *ProcessedMenu
-	RadioGroups       []*RadioGroup
+	Menu              []*ProcessedMenuItem `json:",omitempty"`
+	RadioGroups       []*RadioGroup        `json:",omitempty"`
 	currentRadioGroup []string
 }
 
@@ -103,11 +180,12 @@ type RadioGroup struct {
 	Length  int
 }
 
-func NewWailsMenu(menuItemMap *MenuItemMap, menu *menu.Menu) *WailsMenu {
+func (m *Manager) NewWailsMenu(menu *menu.Menu) *WailsMenu {
+
 	result := &WailsMenu{}
 
 	// Process the menus
-	result.Menu = NewProcessedMenu(menuItemMap, menu)
+	result.Menu = m.NewProcessedMenu(menu)
 
 	// Process the radio groups
 	result.processRadioGroups()
@@ -124,17 +202,7 @@ func (w *WailsMenu) AsJSON() (string, error) {
 	return string(menuAsJSON), nil
 }
 
-func (w *WailsMenu) processRadioGroups() {
-	// Loop over top level menus
-	for _, item := range w.Menu.Items {
-		// Process MenuItem
-		w.processMenuItem(item)
-	}
-
-	w.finaliseRadioGroup()
-}
-
-func (w *WailsMenu) processMenuItem(item *ProcessedMenuItem) {
+func (w *WailsMenu) processMenuItemForRadioGroups(item *ProcessedMenuItem) {
 
 	switch item.Type {
 
@@ -145,8 +213,8 @@ func (w *WailsMenu) processMenuItem(item *ProcessedMenuItem) {
 		w.finaliseRadioGroup()
 
 		// Process each submenu item
-		for _, subitem := range item.SubMenu.Items {
-			w.processMenuItem(subitem)
+		for _, subitem := range item.SubMenu {
+			w.processMenuItemForRadioGroups(subitem)
 		}
 	case menu.RadioType:
 		// Add the item to the radio group
@@ -156,6 +224,20 @@ func (w *WailsMenu) processMenuItem(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,39 +3,14 @@ package menumanager
 import (
 	"encoding/json"
 	"fmt"
-	"strconv"
-	"sync"
-
-	"github.com/pkg/errors"
 	"github.com/wailsapp/wails/v2/pkg/menu"
 )
 
-var trayMenuID int
-var trayMenuIDMutex sync.Mutex
-
-func generateTrayID() string {
-	var idStr string
-	trayMenuIDMutex.Lock()
-	idStr = strconv.Itoa(trayMenuID)
-	trayMenuID++
-	trayMenuIDMutex.Unlock()
-	return idStr
-}
-
 type TrayMenu struct {
-	ID               string
-	Label            string
-	FontSize         int
-	FontName         string
-	Disabled         bool
-	Tooltip          string `json:",omitempty"`
-	Image            string
-	MacTemplateImage bool
-	RGBA             string
-	menuItemMap      *MenuItemMap
-	menu             *menu.Menu
-	ProcessedMenu    *WailsMenu
-	trayMenu         *menu.TrayMenu
+	ID    string         `json:"I"`
+	Label string         `json:"l,omitempty"`
+	Icon  string         `json:"i,omitempty"`
+	Menu  *ProcessedMenu `json:"m,omitempty"`
 }
 
 func (t *TrayMenu) AsJSON() (string, error) {
@@ -46,92 +21,44 @@ func (t *TrayMenu) AsJSON() (string, error) {
 	return string(data), nil
 }
 
-func NewTrayMenu(trayMenu *menu.TrayMenu) *TrayMenu {
+func (m *Manager) newTrayMenu(trayMenu *menu.TrayMenu) *TrayMenu {
 
-	result := &TrayMenu{
-		Label:            trayMenu.Label,
-		FontName:         trayMenu.FontName,
-		FontSize:         trayMenu.FontSize,
-		Disabled:         trayMenu.Disabled,
-		Tooltip:          trayMenu.Tooltip,
-		Image:            trayMenu.Image,
-		MacTemplateImage: trayMenu.MacTemplateImage,
-		menu:             trayMenu.Menu,
-		RGBA:             trayMenu.RGBA,
-		menuItemMap:      NewMenuItemMap(),
-		trayMenu:         trayMenu,
+	result := TrayMenu{
+		ID:    m.generateTrayID(),
+		Label: trayMenu.Label,
+		Icon:  trayMenu.Icon,
+		Menu:  m.ProcessMenu(trayMenu.Menu),
 	}
 
-	result.menuItemMap.AddMenu(trayMenu.Menu)
-	result.ProcessedMenu = NewWailsMenu(result.menuItemMap, result.menu)
+	return &result
+}
+
+func (m *Manager) AddTrayMenu(trayMenu *menu.TrayMenu) *TrayMenu {
+
+	result := m.newTrayMenu(trayMenu)
+
+	// Add to map
+	m.trayMenuMap[trayMenu] = result
 
 	return result
 }
 
-func (m *Manager) OnTrayMenuOpen(id string) {
-	trayMenu, ok := m.trayMenus[id]
-	if !ok {
-		return
-	}
-	if trayMenu.trayMenu.OnOpen == nil {
-		return
-	}
-	go trayMenu.trayMenu.OnOpen()
+func (m *Manager) generateTrayID() string {
+	return fmt.Sprintf("T%d", m.trayMenuIDCounter.Increment())
 }
 
-func (m *Manager) OnTrayMenuClose(id string) {
-	trayMenu, ok := m.trayMenus[id]
-	if !ok {
-		return
-	}
-	if trayMenu.trayMenu.OnClose == nil {
-		return
-	}
-	go trayMenu.trayMenu.OnClose()
-}
-
-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) GetTrayID(trayMenu *menu.TrayMenu) (string, error) {
-	trayID, exists := m.trayMenuPointers[trayMenu]
-	if !exists {
-		return "", fmt.Errorf("Unable to find menu ID for tray menu!")
-	}
-	return trayID, nil
-}
-
-// 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)
+func (m *Manager) GetTrayMenus() ([]*TrayMenu, error) {
+	var result []*TrayMenu
+	for _, trayMenu := range m.trayMenuMap {
+		result = append(result, trayMenu)
 	}
 
-	// Create the updated tray menu
-	updatedTrayMenu := NewTrayMenu(trayMenu)
-	updatedTrayMenu.ID = trayID
-
-	// Save the reference
-	m.trayMenus[trayID] = updatedTrayMenu
-
-	return updatedTrayMenu.AsJSON()
+	return result, nil
 }
 
-func (m *Manager) GetTrayMenus() ([]string, error) {
-	result := []string{}
-	for _, trayMenu := range m.trayMenus {
+func (m *Manager) GetTrayMenusAsJSON() ([]string, error) {
+	var result []string
+	for _, trayMenu := range m.trayMenuMap {
 		JSON, err := trayMenu.AsJSON()
 		if err != nil {
 			return nil, err
@@ -142,54 +69,11 @@ func (m *Manager) GetTrayMenus() ([]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
-		FontName         string
-		FontSize         int
-		RGBA             string
-		Disabled         bool
-		Tooltip          string
-		Image            string
-		MacTemplateImage bool
-	}
-
-	update := &LabelUpdate{
-		ID:               trayID,
-		Label:            trayMenu.Label,
-		FontName:         trayMenu.FontName,
-		FontSize:         trayMenu.FontSize,
-		Disabled:         trayMenu.Disabled,
-		Tooltip:          trayMenu.Tooltip,
-		Image:            trayMenu.Image,
-		MacTemplateImage: trayMenu.MacTemplateImage,
-		RGBA:             trayMenu.RGBA,
-	}
-
-	data, err := json.Marshal(update)
-	if err != nil {
-		return "", errors.Wrap(err, "[UpdateTrayMenuLabel] ")
-	}
-
-	return string(data), nil
-
-}
-
-func (m *Manager) GetContextMenus() ([]string, error) {
-	result := []string{}
-	for _, contextMenu := range m.contextMenus {
-		JSON, err := contextMenu.AsJSON()
-		if err != nil {
-			return nil, err
-		}
-		result = append(result, JSON)
-	}
-
-	return result, nil
+	return "", nil
 }

v2/internal/menumanager/traymenu_test.go

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

v2/internal/messagedispatcher/dispatchclient.go

@@ -2,23 +2,38 @@ 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"
+	"github.com/wailsapp/wails/v2/pkg/options/dialog"
 )
 
+// Client defines what a frontend client can do
 type Client interface {
 	Quit()
 	NotifyEvent(message string)
 	CallResult(message string)
-	SaveFileDialog(title string) string
-	OpenFileDialog(title string) string
-	OpenDirectoryDialog(title string) string
+	OpenDialog(dialogOptions *dialog.OpenDialog, callbackID string)
+	SaveDialog(dialogOptions *dialog.SaveDialog, callbackID string)
+	MessageDialog(dialogOptions *dialog.MessageDialog, callbackID string)
 	WindowSetTitle(title string)
+	WindowShow()
+	WindowHide()
+	WindowCenter()
+	WindowMaximise()
+	WindowUnmaximise()
+	WindowMinimise()
+	WindowUnminimise()
+	WindowPosition(x int, y int)
+	WindowSize(width int, height int)
 	WindowFullscreen()
 	WindowUnFullscreen()
-	WindowSetColour(colour string) bool
+	WindowSetColour(colour int)
+	DarkModeEnabled(callbackID string)
+	SetApplicationMenu(menuJSON string)
+	SetTrayMenu(trayMenuJSON string)
+	UpdateTrayMenuLabel(JSON string)
+	UpdateContextMenu(contextMenuJSON string)
 }
 
 // DispatchClient is what the frontends use to interface with the
@@ -53,7 +68,7 @@ func (d *DispatchClient) DispatchMessage(incomingMessage string) {
 	d.logger.Trace(fmt.Sprintf("Received message: %+v", incomingMessage))
 	parsedMessage, err := message.Parse(incomingMessage)
 	if err != nil {
-		d.logger.Trace("Error: " + err.Error())
+		d.logger.Error(err.Error())
 		return
 	}
 
@@ -62,14 +77,6 @@ func (d *DispatchClient) DispatchMessage(incomingMessage string) {
 
 	d.logger.Trace("I got a parsedMessage: %+v", parsedMessage)
 
-	// Check error
-	if err != nil {
-		d.logger.Trace("Error: " + err.Error())
-		// Hrm... what do we do with this?
-		d.bus.PublishForTarget("generic:message", incomingMessage, d.id)
-		return
-	}
-
 	// Publish the parsed message
 	d.bus.PublishForTarget(parsedMessage.Topic, parsedMessage.Data, d.id)
 

v2/internal/messagedispatcher/message/call.go

@@ -6,9 +6,9 @@ import (
 )
 
 type CallMessage struct {
-	Name       string        `json:"name"`
-	Args       []interface{} `json:"args"`
-	CallbackID string        `json:"callbackID,omitempty"`
+	Name       string            `json:"name"`
+	Args       []json.RawMessage `json:"args"`
+	CallbackID string            `json:"callbackID,omitempty"`
 }
 
 // callMessageParser does what it says on the tin!
@@ -22,6 +22,7 @@ func callMessageParser(message string) (*parsedMessage, error) {
 	callMessage := new(CallMessage)
 
 	m := message[1:]
+
 	err := json.Unmarshal([]byte(m), callMessage)
 	if err != nil {
 		println(err.Error())

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]
+		callbackID := message[:idx+1]
 		payloadData := message[idx+1:]
 
 		switch dialogType {

v2/internal/messagedispatcher/message/event.go

@@ -1,8 +1,9 @@
 package message
 
-import "fmt"
-
-import "encoding/json"
+import (
+	"encoding/json"
+	"fmt"
+)
 
 type EventMessage struct {
 	Name string        `json:"name"`
@@ -12,6 +13,7 @@ type EventMessage struct {
 type OnEventMessage struct {
 	Name     string
 	Callback func(optionalData ...interface{})
+	Counter  int
 }
 
 // eventMessageParser does what it says on the tin!
@@ -27,8 +29,6 @@ func eventMessageParser(message string) (*parsedMessage, error) {
 
 	// Switch the event type (with or without data)
 	switch message[0] {
-	case 'e':
-		eventMessage.Name = message[2:]
 	case 'E':
 		m := message[2:]
 		err := json.Unmarshal([]byte(m), eventMessage)

v2/internal/messagedispatcher/message/log.go

@@ -3,16 +3,19 @@ package message
 import "fmt"
 
 var logMessageMap = map[byte]string{
+	'P': "log:print",
+	'T': "log:trace",
 	'D': "log:debug",
 	'I': "log:info",
 	'W': "log:warning",
 	'E': "log:error",
 	'F': "log:fatal",
+	'S': "log:setlevel",
 }
 
 // logMessageParser does what it says on the tin!
 func logMessageParser(message string) (*parsedMessage, error) {
-	
+
 	// Sanity check: Log messages must be at least 2 bytes
 	if len(message) < 2 {
 		return nil, fmt.Errorf("log message was an invalid length")
@@ -23,7 +26,7 @@ func logMessageParser(message string) (*parsedMessage, error) {
 
 	// If the type is invalid, raise error
 	if messageTopic == "" {
-		return nil, fmt.Errorf("log message type '%b' invalid", message[1])
+		return nil, fmt.Errorf("log message type '%c' invalid", message[1])
 	}
 
 	// Create a new parsed message struct

v2/internal/messagedispatcher/message/menu.go

@@ -32,14 +32,6 @@ func menuMessageParser(message string) (*parsedMessage, error) {
 		callbackid := message[2:]
 		topic = "menu:clicked"
 		data = callbackid
-	case 'o':
-		callbackid := message[2:]
-		topic = "menu:ontrayopen"
-		data = callbackid
-	case 'c':
-		callbackid := message[2:]
-		topic = "menu:ontrayclose"
-		data = callbackid
 	default:
 		return nil, fmt.Errorf("invalid menu message: %s", message)
 	}