[v2] v2.0.0-alpha.66

* Fixed multi-line tags being minified incorrectly. Fixed self closing …

* Improved html whitespace minification fix.

.gitignore

@@ -27,3 +27,7 @@ v2/pkg/parser/testproject/frontend/wails
 v2/test/kitchensink/frontend/public
 v2/test/kitchensink/build/darwin/desktop/kitchensink
 v2/test/kitchensink/frontend/package.json.md5
+/v2/internal/ffenestri/windows/test/cmake-build-debug/
+!v2/internal/ffenestri/windows/x64/webview2.dll
+!v2/internal/ffenestri/windows/x64/WebView2Loader.dll
+.idea/

CONTRIBUTORS.md

@@ -40,4 +40,5 @@ Wails is what it is because of the time and effort given by these great people.
   * [Balakrishna Prasad Ganne](https://github.com/aayush420)
   * [Charaf Rezrazi](https://github.com/Rezrazi)
   * [misitebao](https://github.com/misitebao)
-  * [Elie Grenon](https://github.com/DrunkenPoney)
+  * [Elie Grenon](https://github.com/DrunkenPoney)
+  * [Amaury Tobias Quiroz](https://github.com/amaury-tobias)

runtime/js/.eslintrc

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

runtime/js/core/browser.js

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

runtime/js/core/calls.js

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

runtime/js/core/ipc.js

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

runtime/js/runtime/.npmignore

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

scripts/build.sh

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

v2/.vscode/settings.json

@@ -1,13 +0,0 @@
-{
-    "files.associations": {
-        "ios": "c",
-        "typeinfo": "c",
-        "sstream": "c",
-        "__functional_03": "c",
-        "functional": "c",
-        "__locale": "c",
-        "locale": "c",
-        "chrono": "c",
-        "system_error": "c"
-    }
-}

v2/cmd/wails/internal/commands/build/README.md

@@ -0,0 +1,54 @@
+# Build
+
+The build command processes the Wails project and generates an application binary. 
+
+## Usage
+
+`wails build <flags>`
+
+### Flags
+
+| Flag           | Details      | Default |
+| :------------- | :----------- | :------ |
+| -clean | Clean the bin directory before building   | |
+| -compiler path/to/compiler  | Use a different go compiler, eg go1.15beta1 | go |
+| -ldflags "custom ld flags" | Use given ldflags | | 
+| -o path/to/binary | Compile to given path/filename | |
+| -k | Keep generated assets | |
+| -package | Create a platform specific package | |
+| -production | Compile in production mode: -ldflags="-w -s" + "-h windows" on Windows | |
+| -tags | Build tags to pass to Go compiler (quoted and space separated) | |
+| -upx | Compress final binary with UPX (if installed) | |
+| -upxflags "custom flags" | Flags to pass to upx | |
+| -v int | Verbosity level (0 - silent, 1 - default, 2 - verbose) | 1 |
+
+## The Build Process
+
+The build process is as follows:
+
+  - The flags are processed, and an Options struct built containing the build context.
+  - The type of target is determined, and a custom build process is followed for target.
+
+### Desktop Target 
+
+  - The frontend dependencies are installed. The command is read from the project file `wails.json` under the key `frontend:install` and executed in the `frontend` directory. If this is not defined, it is ignored.
+  - The frontend is then built. This command is read from the project file `wails.json` under the key `frontend:install` and executed in the `frontend` directory. If this is not defined, it is ignored.
+  - The project directory is checked to see if the `build` directory exists. If not, it is created and default project assets are copied to it.
+  - An asset bundle is then created by reading the `html` key from `wails.json` and loading the referenced file. This is then parsed, looking for local Javascript and CSS references. Those files are in turn loaded into memory, converted to C data and saved into the asset bundle located at `build/assets.h`, which also includes the original HTML.
+  - The application icon is then processed: if there is no `build/appicon.png`, a default icon is copied. On Windows, an `app.ico` file is generated from this png. On Mac, `icons.icns` is generated.
+  - If there are icons in the `build/tray` directory, these are processed, converted to C data and saved as `build/trayicons.h`, ready for the compilation step.
+  - If there are icons in the `build/dialog` directory, these are processed, converted to C data and saved as `build/userdialogicons.h`, ready for the compilation step.
+  - If the `-package` flag is given for a Windows target, the Windows assets in the `build/windows` directory are processed: manifest + icons compiled to a `.syso` file (deleted after compilation).
+  - If we are building a universal binary for Mac, the application is compiled for both `arm64` and `amd64`. The `lipo` tool is then executed to create the universal binary.
+  - If we are not building a universal binary for Mac, the application is built using `go build`, using build tags to indicate type of application and build mode (debug/production).
+  - If the `-upx` flag was provided, `upx` is invoked to compress the binary. Custom flags may be provided using the `-upxflags` flag.
+  - If the `package` flag is given for a non Windows target, the application is bundled for the platform. On Mac, this creates a `.app` with the processed icons, the `Info.plist` in `build/darwin` and the compiled binary.
+
+### Server Target
+
+TBD
+
+### Hybrid Target
+
+TBD
+

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

@@ -3,8 +3,10 @@ package build
 import (
 	"fmt"
 	"io"
+	"os"
 	"runtime"
 	"strings"
+	"text/tabwriter"
 	"time"
 
 	"github.com/leaanthony/clir"
@@ -22,10 +24,6 @@ func AddBuildSubcommand(app *clir.Cli, w io.Writer) {
 
 	command := app.NewSubCommand("build", "Builds the application")
 
-	// Setup target type flag
-	description := "Type of application to build. Valid types: " + validTargetTypes.Join(",")
-	command.StringFlag("t", description, &outputType)
-
 	// Setup production flag
 	production := false
 	command.BoolFlag("production", "Build in production mode", &production)
@@ -37,28 +35,44 @@ func AddBuildSubcommand(app *clir.Cli, w io.Writer) {
 	compilerCommand := "go"
 	command.StringFlag("compiler", "Use a different go compiler to build, eg go1.15beta1", &compilerCommand)
 
+	compress := false
+	command.BoolFlag("upx", "Compress final binary with UPX (if installed)", &compress)
+
+	compressFlags := ""
+	command.StringFlag("upxflags", "Flags to pass to upx", &compressFlags)
+
 	// Setup Platform flag
 	platform := runtime.GOOS
 	command.StringFlag("platform", "Platform to target", &platform)
 
-	// Quiet Build
-	quiet := false
-	command.BoolFlag("q", "Suppress output to console", &quiet)
+	// Verbosity
+	verbosity := 1
+	command.IntFlag("v", "Verbosity level (0 - silent, 1 - default, 2 - verbose)", &verbosity)
 
 	// ldflags to pass to `go`
 	ldflags := ""
 	command.StringFlag("ldflags", "optional ldflags", &ldflags)
 
-	// Log to file
-	logFile := ""
-	command.StringFlag("l", "Log to file", &logFile)
+	// tags to pass to `go`
+	tags := ""
+	command.StringFlag("tags", "tags to pass to Go compiler (quoted and space separated)", &tags)
 
 	// Retain assets
 	keepAssets := false
 	command.BoolFlag("k", "Keep generated assets", &keepAssets)
 
+	// Retain assets
+	outputFilename := ""
+	command.StringFlag("o", "Output filename", &outputFilename)
+
+	// Clean build directory
+	cleanBuildDirectory := false
+	command.BoolFlag("clean", "Clean the build directory before building", &cleanBuildDirectory)
+
 	command.Action(func() error {
 
+		quiet := verbosity == 0
+
 		// Create logger
 		logger := clilogger.New(w)
 		logger.Mute(quiet)
@@ -72,28 +86,95 @@ func AddBuildSubcommand(app *clir.Cli, w io.Writer) {
 			app.PrintBanner()
 		}
 
-		task := fmt.Sprintf("Building %s Application", strings.Title(outputType))
-		logger.Println(task)
-		logger.Println(strings.Repeat("-", len(task)))
-
 		// Setup mode
 		mode := build.Debug
 		if production {
 			mode = build.Production
 		}
 
+		// Check platform
+		validPlatformArch := slicer.String([]string{
+			"darwin",
+			"darwin/amd64",
+			"darwin/arm64",
+			"darwin/universal",
+			"linux",
+			//"linux/amd64",
+			//"linux/arm-7",
+			"windows",
+			"windows/amd64",
+		})
+		if !validPlatformArch.Contains(platform) {
+			return fmt.Errorf("platform %s is not supported", platform)
+		}
+
+		if compress && platform == "darwin/universal" {
+			println("Warning: compress flag unsupported for universal binaries. Ignoring.")
+			compress = false
+		}
+
+		// Tags
+		userTags := []string{}
+		for _, tag := range strings.Split(tags, " ") {
+			thisTag := strings.TrimSpace(tag)
+			if thisTag != "" {
+				userTags = append(userTags, thisTag)
+			}
+		}
+
 		// Create BuildOptions
 		buildOptions := &build.Options{
-			Logger:     logger,
-			OutputType: outputType,
-			Mode:       mode,
-			Pack:       pack,
-			Platform:   platform,
-			LDFlags:    ldflags,
-			Compiler:   compilerCommand,
-			KeepAssets: keepAssets,
+			Logger:              logger,
+			OutputType:          outputType,
+			OutputFile:          outputFilename,
+			CleanBuildDirectory: cleanBuildDirectory,
+			Mode:                mode,
+			Pack:                pack,
+			LDFlags:             ldflags,
+			Compiler:            compilerCommand,
+			KeepAssets:          keepAssets,
+			Verbosity:           verbosity,
+			Compress:            compress,
+			CompressFlags:       compressFlags,
+			UserTags:            userTags,
 		}
 
+		// Calculate platform and arch
+		platformSplit := strings.Split(platform, "/")
+		buildOptions.Platform = platformSplit[0]
+		buildOptions.Arch = runtime.GOARCH
+		if len(platformSplit) == 2 {
+			buildOptions.Arch = platformSplit[1]
+		}
+
+		// Start a new tabwriter
+		w := new(tabwriter.Writer)
+		w.Init(os.Stdout, 8, 8, 0, '\t', 0)
+
+		buildModeText := "debug"
+		if production {
+			buildModeText = "production"
+		}
+
+		// Write out the system information
+		fmt.Fprintf(w, "\n")
+		fmt.Fprintf(w, "App Type: \t%s\n", buildOptions.OutputType)
+		fmt.Fprintf(w, "Platform: \t%s\n", buildOptions.Platform)
+		fmt.Fprintf(w, "Arch: \t%s\n", buildOptions.Arch)
+		fmt.Fprintf(w, "Compiler: \t%s\n", buildOptions.Compiler)
+		fmt.Fprintf(w, "Compress: \t%t\n", buildOptions.Compress)
+		fmt.Fprintf(w, "Build Mode: \t%s\n", buildModeText)
+		fmt.Fprintf(w, "Package: \t%t\n", buildOptions.Pack)
+		fmt.Fprintf(w, "Clean Build Dir: \t%t\n", buildOptions.CleanBuildDirectory)
+		fmt.Fprintf(w, "KeepAssets: \t%t\n", buildOptions.KeepAssets)
+		fmt.Fprintf(w, "LDFlags: \t\"%s\"\n", buildOptions.LDFlags)
+		fmt.Fprintf(w, "Tags: \t[%s]\n", strings.Join(buildOptions.UserTags, ","))
+		if len(buildOptions.OutputFile) > 0 {
+			fmt.Fprintf(w, "Output File: \t%s\n", buildOptions.OutputFile)
+		}
+		fmt.Fprintf(w, "\n")
+		w.Flush()
+
 		return doBuild(buildOptions)
 	})
 }

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

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

v2/cmd/wails/internal/commands/dev/README.md

@@ -0,0 +1,22 @@
+# Dev
+
+The dev command allows you to develop your application through a standard browser. 
+
+## Usage
+
+`wails dev <flags>`
+
+### Flags
+
+| Flag           | Details      | Default |
+| :------------- | :----------- | :------ |
+| -compiler path/to/compiler  | Use a different go compiler, eg go1.15beta1 | go |
+| -ldflags "custom ld flags" | Use given ldflags | | 
+| -e list,of,extensions | File extensions to trigger rebuilds | go |
+| -w | Show warnings | false |
+| -v int | Verbosity level (0 - silent, 1 - default, 2 - verbose) | 1 |
+| -loglevel  | Loglevel to pass to the application - Trace, Debug, Info, Warning, Error | Debug |
+
+## How it works
+
+The project is built using a special mode that starts a webserver and starts listening to port 34115. When the frontend project is run independently, so long as the JS is wrapped with the runtime method `ready`, then the frontend will connect to the backend code via websockets. The interface should be present in your browser, and you should be able to interact with the backend as you would in a desktop app.  

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

@@ -3,35 +3,45 @@ package dev
 import (
 	"fmt"
 	"io"
+	"log"
 	"os"
 	"os/signal"
+	"path/filepath"
 	"runtime"
 	"strings"
 	"syscall"
 	"time"
 
+	"github.com/wailsapp/wails/v2/internal/colour"
+
 	"github.com/fsnotify/fsnotify"
 	"github.com/leaanthony/clir"
-	"github.com/leaanthony/slicer"
 	"github.com/wailsapp/wails/v2/internal/fs"
 	"github.com/wailsapp/wails/v2/internal/process"
 	"github.com/wailsapp/wails/v2/pkg/clilogger"
 	"github.com/wailsapp/wails/v2/pkg/commands/build"
 )
 
+func LogGreen(message string, args ...interface{}) {
+	text := fmt.Sprintf(message, args...)
+	println(colour.Green(text))
+}
+
+func LogRed(message string, args ...interface{}) {
+	text := fmt.Sprintf(message, args...)
+	println(colour.Red(text))
+}
+
+func LogDarkYellow(message string, args ...interface{}) {
+	text := fmt.Sprintf(message, args...)
+	println(colour.DarkYellow(text))
+}
+
 // AddSubcommand adds the `dev` command for the Wails application
 func AddSubcommand(app *clir.Cli, w io.Writer) error {
 
 	command := app.NewSubCommand("dev", "Development mode")
 
-	outputType := "desktop"
-
-	validTargetTypes := slicer.String([]string{"desktop", "hybrid", "server"})
-
-	// Setup target type flag
-	description := "Type of application to develop. Valid types: " + validTargetTypes.Join(",")
-	command.StringFlag("t", description, &outputType)
-
 	// Passthrough ldflags
 	ldflags := ""
 	command.StringFlag("ldflags", "optional ldflags", &ldflags)
@@ -42,15 +52,21 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 
 	// extensions to trigger rebuilds
 	extensions := "go"
-	command.StringFlag("m", "Extensions to trigger rebuilds (comma separated) eg go,js,css,html", &extensions)
+	command.StringFlag("e", "Extensions to trigger rebuilds (comma separated) eg go,js,css,html", &extensions)
+
+	// extensions to trigger rebuilds
+	showWarnings := false
+	command.BoolFlag("w", "Show warnings", &showWarnings)
+
+	// Verbosity
+	verbosity := 1
+	command.IntFlag("v", "Verbosity level (0 - silent, 1 - default, 2 - verbose)", &verbosity)
+
+	loglevel := ""
+	command.StringFlag("loglevel", "Loglevel to use - Trace, Debug, Info, Warning, Error", &loglevel)
 
 	command.Action(func() error {
 
-		// Validate inputs
-		if !validTargetTypes.Contains(outputType) {
-			return fmt.Errorf("output type '%s' is not valid", outputType)
-		}
-
 		// Create logger
 		logger := clilogger.New(w)
 		app.PrintBanner()
@@ -61,10 +77,14 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 		if err != nil {
 			return err
 		}
-		defer watcher.Close()
+		defer func(watcher *fsnotify.Watcher) {
+			err := watcher.Close()
+			if err != nil {
+				log.Fatal(err)
+			}
+		}(watcher)
 
 		var debugBinaryProcess *process.Process = nil
-		var buildFrontend bool = true
 		var extensionsThatTriggerARebuild = strings.Split(extensions, ",")
 
 		// Setup signal handler
@@ -73,10 +93,22 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 
 		debounceQuit := make(chan bool, 1)
 
+		var passthruArgs []string
+		//if len(os.Args) > 2 {
+		//	passthruArgs = os.Args[2:]
+		//}
+
 		// Do initial build
 		logger.Println("Building application for development...")
-		debugBinaryProcess = restartApp(logger, outputType, ldflags, compilerCommand, buildFrontend, debugBinaryProcess)
+		newProcess, appBinary, err := restartApp(logger, ldflags, compilerCommand, debugBinaryProcess, loglevel, passthruArgs, verbosity)
+		if newProcess != nil {
+			debugBinaryProcess = newProcess
+		}
 
+		if err != nil {
+			return err
+		}
+		var newBinaryProcess *process.Process
 		go debounce(100*time.Millisecond, watcher.Events, debounceQuit, func(event fsnotify.Event) {
 			// logger.Println("event: %+v", event)
 
@@ -85,8 +117,11 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 				// If this is a folder, add it to our watch list
 				if fs.DirExists(event.Name) {
 					if !strings.Contains(event.Name, "node_modules") {
-						watcher.Add(event.Name)
-						logger.Println("Watching directory: %s", event.Name)
+						err := watcher.Add(event.Name)
+						if err != nil {
+							logger.Fatal("%s", err.Error())
+						}
+						LogGreen("[New Directory] Watching new directory: %s", event.Name)
 					}
 				}
 				return
@@ -95,38 +130,33 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 			// Check for file writes
 			if event.Op&fsnotify.Write == fsnotify.Write {
 
-				// logger.Println("modified file: %s", event.Name)
 				var rebuild bool = false
 
 				// Iterate all file patterns
 				for _, pattern := range extensionsThatTriggerARebuild {
-					rebuild = strings.HasSuffix(event.Name, pattern)
-					if err != nil {
-						logger.Fatal(err.Error())
-					}
-					if rebuild {
-						// Only build frontend when the file isn't a Go file
-						buildFrontend = !strings.HasSuffix(event.Name, "go")
+					if strings.HasSuffix(event.Name, pattern) {
+						rebuild = true
 						break
 					}
 				}
 
 				if !rebuild {
-					logger.Println("Filename change: %s did not match extension list %s", event.Name, extensions)
+					if showWarnings {
+						LogDarkYellow("[File change] %s did not match extension list (%s)", event.Name, extensions)
+					}
 					return
 				}
 
-				if buildFrontend {
-					logger.Println("Full rebuild triggered: %s updated", event.Name)
-				} else {
-					logger.Println("Partial build triggered: %s updated", event.Name)
-				}
+				LogGreen("[Attempting rebuild] %s updated", event.Name)
 
 				// Do a rebuild
 
 				// Try and build the app
-				newBinaryProcess := restartApp(logger, outputType, ldflags, compilerCommand, buildFrontend, debugBinaryProcess)
-
+				newBinaryProcess, _, err = restartApp(logger, ldflags, compilerCommand, debugBinaryProcess, loglevel, passthruArgs, verbosity)
+				if err != nil {
+					fmt.Printf("Error during build: %s", err.Error())
+					return
+				}
 				// If we have a new process, save it
 				if newBinaryProcess != nil {
 					debugBinaryProcess = newBinaryProcess
@@ -136,23 +166,28 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 		})
 
 		// Get project dir
-		dir, err := os.Getwd()
+		projectDir, err := os.Getwd()
 		if err != nil {
 			return err
 		}
 
 		// Get all subdirectories
-		dirs, err := fs.GetSubdirectories(dir)
+		dirs, err := fs.GetSubdirectories(projectDir)
 		if err != nil {
 			return err
 		}
 
+		LogGreen("Watching (sub)/directory: %s", projectDir)
+
 		// Setup a watcher for non-node_modules directories
 		dirs.Each(func(dir string) {
 			if strings.Contains(dir, "node_modules") {
 				return
 			}
-			logger.Println("Watching directory: %s", dir)
+			// Ignore build directory
+			if strings.HasPrefix(dir, filepath.Join(projectDir, "build")) {
+				return
+			}
 			err = watcher.Add(dir)
 			if err != nil {
 				logger.Fatal(err.Error())
@@ -164,7 +199,7 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 		for quit == false {
 			select {
 			case <-quitChannel:
-				println()
+				LogGreen("\nCaught quit")
 				// Notify debouncer to quit
 				debounceQuit <- true
 				quit = true
@@ -173,10 +208,19 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 
 		// Kill the current program if running
 		if debugBinaryProcess != nil {
-			debugBinaryProcess.Kill()
+			err := debugBinaryProcess.Kill()
+			if err != nil {
+				return err
+			}
 		}
 
-		logger.Println("Development mode exited")
+		// Remove dev binary
+		err = os.Remove(appBinary)
+		if err != nil {
+			return err
+		}
+
+		LogGreen("Development mode exited")
 
 		return nil
 	})
@@ -203,15 +247,15 @@ exit:
 	}
 }
 
-func restartApp(logger *clilogger.CLILogger, outputType string, ldflags string, compilerCommand string, buildFrontend bool, debugBinaryProcess *process.Process) *process.Process {
+func restartApp(logger *clilogger.CLILogger, ldflags string, compilerCommand string, debugBinaryProcess *process.Process, loglevel string, passthruArgs []string, verbosity int) (*process.Process, string, error) {
 
-	appBinary, err := buildApp(logger, outputType, ldflags, compilerCommand, buildFrontend)
+	appBinary, err := buildApp(logger, ldflags, compilerCommand, verbosity)
 	println()
 	if err != nil {
-		logger.Println("[ERROR] Build Failed: %s", err.Error())
-		return nil
+		LogRed("Build error - continuing to run current version")
+		LogDarkYellow(err.Error())
+		return nil, "", nil
 	}
-	logger.Println("Build new binary: %s", appBinary)
 
 	// Kill existing binary if need be
 	if debugBinaryProcess != nil {
@@ -226,34 +270,45 @@ func restartApp(logger *clilogger.CLILogger, outputType string, ldflags string,
 
 	// TODO: Generate `backend.js`
 
-	// Start up new binary
-	newProcess := process.NewProcess(logger, appBinary)
+	// Start up new binary with correct args
+	var args = []string{"-loglevel", loglevel}
+	if len(passthruArgs) > 0 {
+		args = append(args, passthruArgs...)
+	}
+	newProcess := process.NewProcess(logger, appBinary, args...)
 	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
+	return newProcess, appBinary, nil
 }
 
-func buildApp(logger *clilogger.CLILogger, outputType string, ldflags string, compilerCommand string, buildFrontend bool) (string, error) {
+func buildApp(logger *clilogger.CLILogger, ldflags string, compilerCommand string, verbosity int) (string, error) {
 
 	// Create random output file
-	outputFile := fmt.Sprintf("debug-%d", time.Now().Unix())
+	outputFile := "wailsdev"
+	if runtime.GOOS == "windows" {
+		outputFile += ".exe"
+	}
 
 	// Create BuildOptions
 	buildOptions := &build.Options{
 		Logger:         logger,
-		OutputType:     outputType,
+		OutputType:     "dev",
 		Mode:           build.Debug,
 		Pack:           false,
 		Platform:       runtime.GOOS,
 		LDFlags:        ldflags,
 		Compiler:       compilerCommand,
 		OutputFile:     outputFile,
-		IgnoreFrontend: !buildFrontend,
+		IgnoreFrontend: true,
+		Verbosity:      verbosity,
 	}
 
 	return build.Build(buildOptions)

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

@@ -3,7 +3,6 @@ package doctor
 import (
 	"fmt"
 	"io"
-	"log"
 	"os"
 	"runtime"
 	"strings"
@@ -25,11 +24,13 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 		logger := clilogger.New(w)
 
 		app.PrintBanner()
-		logger.Print("Scanning system - please wait...")
+
+		logger.Print("Scanning system - Please wait (this may take a long time)...")
 
 		// Get system info
 		info, err := system.GetInfo()
 		if err != nil {
+			logger.Println("Failed.")
 			return err
 		}
 		logger.Println("Done.")
@@ -39,27 +40,22 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 		w.Init(os.Stdout, 8, 8, 0, '\t', 0)
 
 		// Write out the system information
-		fmt.Fprintf(w, "\n")
 		fmt.Fprintf(w, "System\n")
 		fmt.Fprintf(w, "------\n")
 		fmt.Fprintf(w, "%s\t%s\n", "OS:", info.OS.Name)
 		fmt.Fprintf(w, "%s\t%s\n", "Version: ", info.OS.Version)
 		fmt.Fprintf(w, "%s\t%s\n", "ID:", info.OS.ID)
 
-		// Exit early if PM not found
-		if info.PM == nil {
-			fmt.Fprintf(w, "\n%s\t%s", "Package Manager:", "Not Found")
-			w.Flush()
-			println()
-			return nil
-		}
-		fmt.Fprintf(w, "%s\t%s\n", "Package Manager: ", info.PM.Name())
-
 		// Output Go Information
 		fmt.Fprintf(w, "%s\t%s\n", "Go Version:", runtime.Version())
 		fmt.Fprintf(w, "%s\t%s\n", "Platform:", runtime.GOOS)
 		fmt.Fprintf(w, "%s\t%s\n", "Architecture:", runtime.GOARCH)
 
+		// Exit early if PM not found
+		if info.PM != nil {
+			fmt.Fprintf(w, "%s\t%s\n", "Package Manager: ", info.PM.Name())
+		}
+
 		// Output Dependencies Status
 		var dependenciesMissing = []string{}
 		var externalPackages = []*packagemanager.Dependancy{}
@@ -69,12 +65,14 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 		fmt.Fprintf(w, "Dependency\tPackage Name\tStatus\tVersion\n")
 		fmt.Fprintf(w, "----------\t------------\t------\t-------\n")
 
+		hasOptionalDependencies := false
 		// Loop over dependencies
 		for _, dependency := range info.Dependencies {
 
 			name := dependency.Name
 			if dependency.Optional {
-				name += "*"
+				name = "*" + name
+				hasOptionalDependencies = true
 			}
 			packageName := "Unknown"
 			status := "Not Found"
@@ -109,44 +107,48 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 
 			fmt.Fprintf(w, "%s\t%s\t%s\t%s\n", name, packageName, status, dependency.Version)
 		}
-		fmt.Fprintf(w, "\n")
-		fmt.Fprintf(w, "* - Optional Dependency\n")
+		if hasOptionalDependencies {
+			fmt.Fprintf(w, "\n")
+			fmt.Fprintf(w, "* - Optional Dependency\n")
+		}
 		w.Flush()
 		logger.Println("")
 		logger.Println("Diagnosis")
-		logger.Println("---------\n")
+		logger.Println("---------")
 
 		// Generate an appropriate diagnosis
 
 		if len(dependenciesMissing) == 0 && dependenciesAvailableRequired == 0 {
 			logger.Println("Your system is ready for Wails development!")
+		} else {
+			logger.Println("Your system has missing dependencies!\n")
 		}
 
 		if dependenciesAvailableRequired != 0 {
-			log.Println("Install required packages using: " + info.Dependencies.InstallAllRequiredCommand())
+			logger.Println("Required package(s) installation details: \n" + info.Dependencies.InstallAllRequiredCommand())
 		}
 
 		if dependenciesAvailableOptional != 0 {
-			log.Println("Install optional packages using: " + info.Dependencies.InstallAllOptionalCommand())
-		}
-
-		if len(externalPackages) > 0 {
-			for _, p := range externalPackages {
-				if p.Optional {
-					print("[Optional] ")
-				}
-				log.Println("Install " + p.Name + ": " + p.InstallCommand)
-			}
+			logger.Println("Optional package(s) installation details: \n" + info.Dependencies.InstallAllOptionalCommand())
 		}
+		//
+		//if len(externalPackages) > 0 {
+		//	for _, p := range externalPackages {
+		//		if p.Optional {
+		//			print("[Optional] ")
+		//		}
+		//		logger.Println("Install " + p.Name + ": " + p.InstallCommand)
+		//	}
+		//}
 
 		if len(dependenciesMissing) != 0 {
 			// TODO: Check if apps are available locally and if so, adjust the diagnosis
-			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")
+			logger.Println("Fatal:")
+			logger.Println("Required dependencies missing: " + strings.Join(dependenciesMissing, " "))
+			logger.Println("Please read this article on how to resolve this: https://wails.app/guides/resolving-missing-packages")
 		}
 
-		log.Println("")
+		logger.Println("")
 		return nil
 	})
 

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

@@ -9,7 +9,7 @@ import (
 	"github.com/wailsapp/wails/v2/pkg/parser"
 )
 
-// AddSubcommand adds the `dev` command for the Wails application
+// AddSubcommand adds the `generate` command for the Wails application
 func AddSubcommand(app *clir.Cli, w io.Writer) error {
 
 	command := app.NewSubCommand("generate", "Code Generation Tools")
@@ -19,7 +19,7 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 
 	// Quiet Init
 	quiet := false
-	backendAPI.BoolFlag("q", "Supress output to console", &quiet)
+	backendAPI.BoolFlag("q", "Suppress output to console", &quiet)
 
 	backendAPI.Action(func() error {
 
@@ -85,7 +85,4 @@ func logPackage(pkg *parser.Package, logger *clilogger.CLILogger) {
 		}
 	}
 	logger.Println("")
-
-	// logger.Println("  Original Go Package Path:", pkg.Gopackage.PkgPath)
-	// logger.Println("  Original Go Package Path:", pkg.Gopackage.PkgPath)
 }

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

@@ -2,13 +2,15 @@ package initialise
 
 import (
 	"fmt"
+	"github.com/wailsapp/wails/v2/pkg/buildassets"
 	"io"
 	"strings"
 	"time"
 
+	"github.com/wailsapp/wails/v2/cmd/wails/internal/commands/initialise/templates"
+
 	"github.com/leaanthony/clir"
 	"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"
 )
@@ -39,7 +41,7 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 
 	// Quiet Init
 	quiet := false
-	command.BoolFlag("q", "Supress output to console", &quiet)
+	command.BoolFlag("q", "Suppress output to console", &quiet)
 
 	initGit := false
 	gitInstalled := git.IsInstalled()
@@ -105,10 +107,7 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 		}
 
 		// Try to discover author details from git config
-		err := findAuthorDetails(options)
-		if err != nil {
-			return err
-		}
+		findAuthorDetails(options)
 
 		return initProject(options)
 	})
@@ -128,6 +127,12 @@ func initProject(options *templates.Options) error {
 		return err
 	}
 
+	// Install the default assets
+	err = buildassets.Install(options.TargetDir, options.ProjectName)
+	if err != nil {
+		return err
+	}
+
 	if options.InitGit {
 		err = initGit(options)
 		if err != nil {
@@ -163,20 +168,18 @@ func initGit(options *templates.Options) error {
 	return nil
 }
 
-func findAuthorDetails(options *templates.Options) error {
+// findAuthorDetails tries to find the user's name and email
+// from gitconfig. If it finds them, it stores them in the project options
+func findAuthorDetails(options *templates.Options) {
 	if git.IsInstalled() {
 		name, err := git.Name()
-		if err != nil {
-			return err
+		if err == nil {
+			options.AuthorName = strings.TrimSpace(name)
 		}
-		options.AuthorName = strings.TrimSpace(name)
 
 		email, err := git.Email()
-		if err != nil {
-			return err
+		if err == nil {
+			options.AuthorEmail = strings.TrimSpace(email)
 		}
-		options.AuthorEmail = strings.TrimSpace(email)
 	}
-
-	return nil
 }

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

@@ -1,14 +1,16 @@
 package templates
 
 import (
+	"embed"
 	"encoding/json"
 	"fmt"
-	"io/ioutil"
+	gofs "io/fs"
 	"os"
 	"path/filepath"
 	"runtime"
 	"strings"
 
+	"github.com/leaanthony/debme"
 	"github.com/leaanthony/gosod"
 	"github.com/leaanthony/slicer"
 	"github.com/olekukonko/tablewriter"
@@ -16,6 +18,12 @@ import (
 	"github.com/wailsapp/wails/v2/pkg/clilogger"
 )
 
+//go:embed templates
+var templates embed.FS
+
+//go:embed ides/*
+var ides embed.FS
+
 // Cahce for the templates
 // We use this because we need different views of the same data
 var templateCache []Template = nil
@@ -59,20 +67,21 @@ type Template struct {
 	HelpURL     string `json:"helpurl"`
 
 	// Other data
-	Directory string `json:"-"`
+	FS gofs.FS `json:"-"`
 }
 
-func parseTemplate(directory string) (Template, error) {
-	templateJSON := filepath.Join(directory, "template.json")
+func parseTemplate(template gofs.FS) (Template, error) {
 	var result Template
-	data, err := ioutil.ReadFile(templateJSON)
+	data, err := gofs.ReadFile(template, "template.json")
 	if err != nil {
 		return result, err
 	}
-
-	result.Directory = directory
 	err = json.Unmarshal(data, &result)
-	return result, err
+	if err != nil {
+		return result, err
+	}
+	result.FS = template
+	return result, nil
 }
 
 // TemplateShortNames returns a slicer of short template names
@@ -134,11 +143,13 @@ func getTemplateByShortname(shortname string) (Template, error) {
 // Loads the template cache
 func loadTemplateCache() error {
 
-	// Get local template directory
-	templateDir := fs.RelativePath("templates")
+	templatesFS, err := debme.FS(templates, "templates")
+	if err != nil {
+		return err
+	}
 
 	// Get directories
-	files, err := ioutil.ReadDir(templateDir)
+	files, err := templatesFS.ReadDir(".")
 	if err != nil {
 		return err
 	}
@@ -148,8 +159,11 @@ func loadTemplateCache() error {
 
 	for _, file := range files {
 		if file.IsDir() {
-			templateDir := filepath.Join(templateDir, file.Name())
-			template, err := parseTemplate(templateDir)
+			templateFS, err := templatesFS.FS(file.Name())
+			if err != nil {
+				return err
+			}
+			template, err := parseTemplate(templateFS)
 			if err != nil {
 				// Cannot parse this template, continue
 				continue
@@ -163,7 +177,6 @@ func loadTemplateCache() error {
 
 // Install the given template
 func Install(options *Options) error {
-
 	// Get cwd
 	cwd, err := os.Getwd()
 	if err != nil {
@@ -211,19 +224,16 @@ func Install(options *Options) error {
 	}
 
 	// Use Gosod to install the template
-	installer, err := gosod.TemplateDir(template.Directory)
-	if err != nil {
-		return err
-	}
+	installer := gosod.New(template.FS)
 
 	// Ignore template.json files
-	installer.IgnoreFilename("template.json")
+	installer.IgnoreFile("template.json")
 
 	// Setup the data.
 	// We use the directory name for the binary name, like Go
 	BinaryName := filepath.Base(options.TargetDir)
 	NPMProjectName := strings.ToLower(strings.ReplaceAll(BinaryName, " ", ""))
-	localWailsDirectory := fs.RelativePath("../..")
+	localWailsDirectory := fs.RelativePath("../../../../../..")
 	templateData := &Data{
 		ProjectName:    options.ProjectName,
 		BinaryName:     filepath.Base(options.TargetDir),
@@ -295,14 +305,14 @@ func generateIDEFiles(options *Options) error {
 func generateVSCodeFiles(options *Options) error {
 
 	targetDir := filepath.Join(options.TargetDir, ".vscode")
-	sourceDir := fs.RelativePath(filepath.Join("./ides/vscode"))
-
-	// Use Gosod to install the template
-	installer, err := gosod.TemplateDir(sourceDir)
+	source, err := debme.FS(ides, "ides/vscode")
 	if err != nil {
 		return err
 	}
 
+	// Use gosod to install the template
+	installer := gosod.New(source)
+
 	binaryName := filepath.Base(options.TargetDir)
 	if runtime.GOOS == "windows" {
 		// yay windows

v2/cmd/wails/internal/commands/initialise/templates/templates/vanilla/README.md

@@ -0,0 +1,16 @@
+# README
+
+## About
+
+This template uses vanilla JS / HTML and CSS. [Rollup](https://rollupjs.org/guide/en/) is used for processing and bundling the files.
+
+## Building 
+
+To build this project in debug mode, use `wails build`. For production, use `wails build -production`.
+To generate a platform native package, add the `-package` flag.
+
+## Live Development
+
+To run in live development mode, run `wails dev` in the project directory. In another terminal, go into the `frontend` 
+directory and run `npm run dev`. The frontend dev server will run on http://localhost:5000. Connect to this
+in your browser and connect to your application. 

v2/cmd/wails/internal/commands/initialise/templates/templates/vanilla/basic.tmpl.go

@@ -11,21 +11,20 @@ type Basic struct {
 	runtime *wails.Runtime
 }
 
-// newBasic creates a new Basic application struct
-func newBasic() *Basic {
+// NewBasic creates a new Basic application struct
+func NewBasic() *Basic {
 	return &Basic{}
 }
 
-// WailsInit is called at application startup
-func (b *Basic) WailsInit(runtime *wails.Runtime) error {
+// startup is called at application startup
+func (b *Basic) startup(runtime *wails.Runtime) {
 	// Perform your setup here
 	b.runtime = runtime
 	runtime.Window.SetTitle("{{.ProjectName}}")
-	return nil
 }
 
-// WailsShutdown is called at application termination
-func (b *Basic) WailsShutdown() {
+// shutdown is called at application termination
+func (b *Basic) shutdown() {
 	// Perform your teardown here
 }
 

v2/cmd/wails/internal/commands/initialise/templates/templates/vanilla/frontend/package.tmpl.json

@@ -0,0 +1,27 @@
+{
+  "name": "vanilla",
+  "version": "1.0.0",
+  "description": "Vanilla Wails v2 template",
+  "main": "src/main.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "rollup -c",
+    "dev": "rollup -c -w",
+    "start": "sirv dist"
+  },
+  "author": "{{.AuthorName}}",
+  "license": "ISC",
+  "dependencies": {
+    "@rollup/plugin-commonjs": "^19.0.0",
+    "@rollup/plugin-image": "^2.0.6",
+    "@rollup/plugin-node-resolve": "^13.0.0",
+    "@rollup/plugin-url": "^6.0.0",
+    "@wails/runtime": "^1.3.19",
+    "rollup": "^2.50.4",
+    "rollup-plugin-copy": "^3.4.0",
+    "rollup-plugin-livereload": "^2.0.0",
+    "rollup-plugin-postcss": "^4.0.0",
+    "rollup-plugin-terser": "^7.0.2",
+    "sirv-cli": "^1.0.12"
+  }
+}

v2/cmd/wails/internal/commands/initialise/templates/templates/vanilla/frontend/rollup.config.js

@@ -0,0 +1,103 @@
+import resolve from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+import livereload from 'rollup-plugin-livereload';
+import { terser } from 'rollup-plugin-terser';
+import postcss from 'rollup-plugin-postcss';
+import image from '@rollup/plugin-image';
+import url from '@rollup/plugin-url';
+import copy from 'rollup-plugin-copy';
+
+const production = !process.env.ROLLUP_WATCH;
+
+export default {
+    input: 'src/main.js',
+    output: {
+        sourcemap: true,
+        format: 'iife',
+        name: 'app',
+        file: 'dist/main.js'
+    },
+    onwarn: handleRollupWarning,
+    plugins: [
+
+        image(),
+
+        copy({
+            targets: [
+                { src: 'src/index.html', dest: 'dist' },
+                { src: 'src/main.css', dest: 'dist' },
+            ]
+        }),
+
+        // Embed binary files
+        url({
+            include: ['**/*.woff', '**/*.woff2'],
+            limit: Infinity,
+        }),
+
+        // If you have external dependencies installed from
+        // npm, you'll most likely need these plugins. In
+        // some cases you'll need additional configuration -
+        // consult the documentation for details:
+        // https://github.com/rollup/plugins/tree/master/packages/commonjs
+        resolve({
+            browser: true,
+        }),
+        commonjs(),
+
+        // PostCSS preprocessing
+        postcss({
+            extensions: ['.css', '.scss'],
+            extract: true,
+            minimize: false,
+            use: [
+                ['sass', {
+                    includePaths: [
+                        './src',
+                        './node_modules'
+                    ]
+                }]
+            ],
+        }),
+
+        // In dev mode, call `npm run start` once
+        // the bundle has been generated
+        !production && serve(),
+
+        // Watch the `public` directory and refresh the
+        // browser on changes when not in production
+        !production && livereload('dist'),
+
+        // If we're building for production (npm run build
+        // instead of npm run dev), minify
+        production && terser()
+    ],
+    watch: {
+        clearScreen: false
+    }
+};
+
+function handleRollupWarning(warning) {
+    console.error('ERROR: ' + warning.toString());
+}
+
+function serve() {
+    let server;
+
+    function toExit() {
+        if (server) server.kill(0);
+    }
+
+    return {
+        writeBundle() {
+            if (server) return;
+            server = require('child_process').spawn('npm', ['run', 'start', '--', '--dev'], {
+                stdio: ['ignore', 'inherit', 'inherit'],
+                shell: true
+            });
+
+            process.on('SIGTERM', toExit);
+            process.on('exit', toExit);
+        }
+    };
+}

v2/cmd/wails/internal/commands/initialise/templates/templates/vanilla/frontend/src/index.html

@@ -4,7 +4,7 @@
   <link rel="stylesheet" href="/main.css">
 </head>
 
-<body>
+<body data-wails-drag>
   <div id="logo"></div>
   <div id="input">
     <input id="name" type="text"></input>

v2/cmd/wails/internal/commands/initialise/templates/templates/vanilla/frontend/src/main.js

@@ -0,0 +1,21 @@
+
+import {ready} from '@wails/runtime';
+
+ready( () => {
+  // Get input + focus
+  let nameElement = document.getElementById("name");
+  nameElement.focus();
+
+  // Setup the greet function
+  window.greet = function () {
+
+    // Get name
+    let name = nameElement.value;
+
+    // Call Basic.Greet(name)
+    window.backend.main.Basic.Greet(name).then((result) => {
+      // Update result with data back from Basic.Greet()
+      document.getElementById("result").innerText = result;
+    });
+  };
+});

v2/cmd/wails/internal/commands/initialise/templates/templates/vanilla/go.mod.tmpl

@@ -1,6 +1,6 @@
 module test
 
-go 1.13
+go 1.16
 
 require (
 	github.com/wailsapp/wails/v2 v2.0.0-alpha

v2/cmd/wails/internal/commands/initialise/templates/templates/vanilla/main.tmpl.go

@@ -0,0 +1,39 @@
+package main
+
+import (
+	"log"
+
+	"github.com/wailsapp/wails/v2"
+	"github.com/wailsapp/wails/v2/pkg/logger"
+	"github.com/wailsapp/wails/v2/pkg/menu"
+	"github.com/wailsapp/wails/v2/pkg/options"
+	"github.com/wailsapp/wails/v2/pkg/options/mac"
+)
+
+func main() {
+
+	// Create application with options
+	app := NewBasic()
+
+	err := wails.Run(&options.App{
+		Title:         "{{.ProjectName}}",
+		Width:         800,
+		Height:        600,
+		DisableResize: true,
+		Mac: &mac.Options{
+			WebviewIsTransparent:          true,
+			WindowBackgroundIsTranslucent: true,
+			TitleBar:                      mac.TitleBarHiddenInset(),
+			Menu:                          menu.DefaultMacMenu(),
+		},
+		LogLevel: logger.DEBUG,
+		Startup:  app.startup,
+		Shutdown: app.shutdown,
+		Bind: []interface{}{
+			app,
+		},
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+}

v2/cmd/wails/internal/commands/initialise/templates/templates/vanilla/wails.tmpl.json

@@ -2,12 +2,10 @@
     "name": "{{.ProjectName}}",
     "outputfilename": "{{.BinaryName}}",
     "html": "frontend/dist/index.html",
-    "js": "frontend/dist/app.js",
-    "css": "frontend/dist/app.css",
     "frontend:build": "npm run build",
-    "frontend:install": "npm install",
+    "frontend:install": "npm ci",
     "author": {
         "name": "{{.AuthorName}}",
         "email": "{{.AuthorEmail}}"
     }
-}
+}

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

@@ -0,0 +1,46 @@
+package templates
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/matryer/is"
+)
+
+func TestList(t *testing.T) {
+
+	is2 := is.New(t)
+	templates, err := List()
+	is2.NoErr(err)
+
+	println("Found these templates:")
+	for _, template := range templates {
+		fmt.Printf("%+v\n", template)
+	}
+}
+
+func TestShortname(t *testing.T) {
+
+	is2 := is.New(t)
+
+	template, err := getTemplateByShortname("vanilla")
+	is2.NoErr(err)
+
+	println("Found this template:")
+	fmt.Printf("%+v\n", template)
+}
+
+func TestInstall(t *testing.T) {
+
+	is2 := is.New(t)
+
+	options := &Options{
+		ProjectName:  "test",
+		TemplateName: "vanilla",
+		AuthorName:   "Lea Anthony",
+		AuthorEmail:  "lea.anthony@gmail.com",
+	}
+
+	err := Install(options)
+	is2.NoErr(err)
+}

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

@@ -0,0 +1,164 @@
+package update
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"os"
+
+	"github.com/wailsapp/wails/v2/internal/shell"
+
+	"github.com/wailsapp/wails/v2/internal/github"
+
+	"github.com/leaanthony/clir"
+	"github.com/wailsapp/wails/v2/pkg/clilogger"
+)
+
+// AddSubcommand adds the `init` command for the Wails application
+func AddSubcommand(app *clir.Cli, w io.Writer, currentVersion string) error {
+
+	command := app.NewSubCommand("update", "Update the Wails CLI")
+	command.LongDescription(`This command allows you to update your version of 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

@@ -1,10 +1,16 @@
 package main
 
 import (
+	"fmt"
 	"os"
 
+	"github.com/wailsapp/wails/v2/internal/colour"
+
+	"github.com/wailsapp/wails/v2/cmd/wails/internal/commands/update"
+
 	"github.com/leaanthony/clir"
 	"github.com/wailsapp/wails/v2/cmd/wails/internal/commands/build"
+	"github.com/wailsapp/wails/v2/cmd/wails/internal/commands/debug"
 	"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"
@@ -16,18 +22,28 @@ func fatal(message string) {
 	os.Exit(1)
 }
 
+func banner(_ *clir.Cli) string {
+	return fmt.Sprintf("%s %s", colour.Yellow("Wails CLI"), colour.DarkRed(version))
+}
+
 func main() {
 
 	var err error
-	version := "v2.0.0-alpha"
 
-	app := clir.NewCli("Wails", "Go/HTML Application Framework", version)
+	app := clir.NewCli("Wails", "Go/HTML Appkit", version)
+
+	app.SetBannerFunction(banner)
 
 	build.AddBuildSubcommand(app, os.Stdout)
 	err = initialise.AddSubcommand(app, os.Stdout)
 	if err != nil {
 		fatal(err.Error())
 	}
+
+	err = debug.AddSubcommand(app, os.Stdout)
+	if err != nil {
+		fatal(err.Error())
+	}
 	err = doctor.AddSubcommand(app, os.Stdout)
 	if err != nil {
 		fatal(err.Error())
@@ -43,8 +59,14 @@ func main() {
 		fatal(err.Error())
 	}
 
+	err = update.AddSubcommand(app, os.Stdout, version)
+	if err != nil {
+		fatal(err.Error())
+	}
+
 	err = app.Run()
 	if err != nil {
 		println("\n\nERROR: " + err.Error())
+		os.Exit(1)
 	}
 }

v2/cmd/wails/version.go

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

v2/go.mod

@@ -1,28 +1,31 @@
 module github.com/wailsapp/wails/v2
 
-go 1.13
+go 1.16
 
 require (
-	github.com/davecgh/go-spew v1.1.1
+	github.com/Masterminds/semver v1.5.0
 	github.com/fatih/structtag v1.2.0
 	github.com/fsnotify/fsnotify v1.4.9
+	github.com/gorilla/websocket v1.4.1
 	github.com/imdario/mergo v0.3.11
 	github.com/jackmordaunt/icns v1.0.0
 	github.com/leaanthony/clir v1.0.4
-	github.com/leaanthony/gosod v0.0.4
+	github.com/leaanthony/debme v1.2.0
+	github.com/leaanthony/go-ansi-parser v1.0.1
+	github.com/leaanthony/gosod v1.0.1
 	github.com/leaanthony/slicer v1.5.0
+	github.com/leaanthony/winicon v0.0.0-20200606125418-4419cea822a0
 	github.com/matryer/is v1.4.0
 	github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 // indirect
-	github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect
 	github.com/olekukonko/tablewriter v0.0.4
 	github.com/pkg/errors v0.9.1
 	github.com/tdewolff/minify v2.3.6+incompatible
 	github.com/tdewolff/parse v2.3.4+incompatible // indirect
 	github.com/tdewolff/test v1.0.6 // indirect
+	github.com/wzshiming/ctc v1.2.3
 	github.com/xyproto/xpm v1.2.1
 	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,5 +1,6 @@
+github.com/Masterminds/semver v1.5.0 h1:H65muMkzWKEuNDnfl9d70GUjFniHKHRbFPGBuZ3QEww=
+github.com/Masterminds/semver v1.5.0/go.mod h1:MB6lktGJrhw8PrUyiEoblNEGEQ+RzHPF078ddwwvV3Y=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 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=
@@ -9,7 +10,6 @@ github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE
 github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
 github.com/gin-gonic/gin v1.6.3 h1:ahKqKTFpO5KTPHxWZjEdPScmYaGtLo8Y4DMHoEsnp14=
 github.com/gin-gonic/gin v1.6.3/go.mod h1:75u5sXoLsGZoRN5Sgbi1eraJ4GU3++wFwWzhwvtwp4M=
-github.com/go-playground/assert/v2 v2.0.1 h1:MsBgLAaY856+nPRTKrp3/OZK38U/wa0CcBYNjji3q3A=
 github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
 github.com/go-playground/locales v0.13.0 h1:HyWk6mgj5qFqCT5fjGBuRArbVDfE4hi8+e8ceBS/t7Q=
 github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8=
@@ -39,15 +39,19 @@ github.com/json-iterator/go v1.1.9 h1:9yzud/Ht36ygwatGx56VwCZtlI/2AD15T1X2sjSuGn
 github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
 github.com/klauspost/compress v1.10.3 h1:OP96hzwJVBIHYU52pVTI6CczrxPvrGfgqF9N5eTO0Q8=
 github.com/klauspost/compress v1.10.3/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/leaanthony/clir v1.0.4 h1:Dov2y9zWJmZr7CjaCe86lKa4b5CSxskGAt2yBkoDyiU=
 github.com/leaanthony/clir v1.0.4/go.mod h1:k/RBkdkFl18xkkACMCLt09bhiZnrGORoxmomeMvDpE0=
-github.com/leaanthony/gosod v0.0.4 h1:v4hepo4IyL8E8c9qzDsvYcA0KGh7Npf8As74K5ibQpI=
-github.com/leaanthony/gosod v0.0.4/go.mod h1:nGMCb1PJfXwBDbOAike78jEYlpqge+xUKFf0iBKjKxU=
+github.com/leaanthony/debme v1.1.1/go.mod h1:3V+sCm5tYAgQymvSOfYQ5Xx2JCr+OXiD9Jkw3otUjiA=
+github.com/leaanthony/debme v1.2.0 h1:i7JUQhuv7PtJ/7qV+SIa5QARTGBcojUZ+2eCiV9begU=
+github.com/leaanthony/debme v1.2.0/go.mod h1:3V+sCm5tYAgQymvSOfYQ5Xx2JCr+OXiD9Jkw3otUjiA=
+github.com/leaanthony/go-ansi-parser v1.0.1 h1:97v6c5kYppVsbScf4r/VZdXyQ21KQIfeQOk2DgKxGG4=
+github.com/leaanthony/go-ansi-parser v1.0.1/go.mod h1:7arTzgVI47srICYhvgUV4CGd063sGEeoSlych5yeSPM=
+github.com/leaanthony/gosod v1.0.1 h1:F+4c3DmEBfigi7oAswCV2RpQ+k4DcNbhuCZUGdBHacQ=
+github.com/leaanthony/gosod v1.0.1/go.mod h1:W8RyeSFBXu7RpIxPGEJfW4moSyGGEjlJMLV25wEbAdU=
 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/leaanthony/winicon v0.0.0-20200606125418-4419cea822a0 h1:FPGYnfxuuxqCZhrGq8nKjthEcYHgHmFbyY953Xv9cNI=
+github.com/leaanthony/winicon v0.0.0-20200606125418-4419cea822a0/go.mod h1:en5xhijl92aphrJdmRPlh4NI1L6wq3gEm0LpXAPghjU=
 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=
@@ -62,17 +66,13 @@ github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742 h1:Esafd1046DLD
 github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 h1:zYyBkD/k9seD2A7fsi6Oo2LfFZAehjjQMERAvZLEDnQ=
 github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646/go.mod h1:jpp1/29i3P1S/RLdc7JQKbRpFeM1dOBd8T9ki5s+AY8=
-github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs=
-github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
 github.com/olekukonko/tablewriter v0.0.4 h1:vHD/YYe1Wolo78koG299f7V/VAS08c6IpCLn+Ejf/w8=
 github.com/olekukonko/tablewriter v0.0.4/go.mod h1:zq6QwlOf5SlnkVbMSr5EoBv3636FWnp+qbPhuoO21uA=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/tdewolff/minify v2.3.6+incompatible h1:2hw5/9ZvxhWLvBUnHE06gElGYz+Jv9R4Eys0XUzItYo=
 github.com/tdewolff/minify v2.3.6+incompatible/go.mod h1:9Ov578KJUmAWpS6NeZwRZyT56Uf6o3Mcz9CEsg8USYs=
@@ -84,12 +84,18 @@ github.com/ugorji/go v1.1.7 h1:/68gy2h+1mWMrwZFeD1kQialdSzAb432dtpeJ42ovdo=
 github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw=
 github.com/ugorji/go/codec v1.1.7 h1:2SvQaVZ1ouYrrKKwoSk2pzd4A9evlKJb9oTL+OaLUSs=
 github.com/ugorji/go/codec v1.1.7/go.mod h1:Ax+UKWsSmolVDwsd+7N3ZtXu+yMGCf907BLYF3GoBXY=
+github.com/wzshiming/ctc v1.2.3 h1:q+hW3IQNsjIlOFBTGZZZeIXTElFM4grF4spW/errh/c=
+github.com/wzshiming/ctc v1.2.3/go.mod h1:2tVAtIY7SUyraSk0JxvwmONNPFL4ARavPuEsg5+KA28=
+github.com/wzshiming/winseq v0.0.0-20200112104235-db357dc107ae h1:tpXvBXC3hpQBDCc9OojJZCQMVRAbT3TTdUMP8WguXkY=
+github.com/wzshiming/winseq v0.0.0-20200112104235-db357dc107ae/go.mod h1:VTAq37rkGeV+WOybvZwjXiJOicICdpLCN8ifpISjK20=
 github.com/xyproto/xpm v1.2.1 h1:trdvGjjWBsOOKzBBUPT6JvaIQM3acJEEYfbxN7M96wg=
 github.com/xyproto/xpm v1.2.1/go.mod h1:cMnesLsD0PBXLgjDfTDEaKr8XyTFsnP1QycSqRw7BiY=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/image v0.0.0-20200430140353-33d19683fad8 h1:6WW6V3x1P/jokJBpRQYUJnMHRP6isStQwCozxnU7XQw=
+golang.org/x/image v0.0.0-20200430140353-33d19683fad8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
 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=
@@ -100,33 +106,26 @@ golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJ
 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-20200107162124-548cf772de50/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd h1:xhmwyvizuTgC2qz7ZlMluP20uW+C3Rm0FD/WLDX8884=
 golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200724161237-0e2f3a69832c h1:UIcGWL6/wpCfyGuJnRFJRurA+yj8RrW7Q6x2YMCXt6c=
 golang.org/x/sys v0.0.0-20200724161237-0e2f3a69832c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e h1:FDhOuMEY4JVRztM/gsbk+IKUQ8kj74bxZrgw87eMMVc=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20200902012652-d1954cc86c82 h1:shxDsb9Dz27xzk3A0DxP0JuJnZMpKrdg8+E14eiUAX4=
 golang.org/x/tools v0.0.0-20200902012652-d1954cc86c82/go.mod h1:Cj7w3i3Rnn0Xh82ur9kSqwfTHTeVxaDqrfMjpcNT6bE=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b h1:QRR6H1YWRnHb4Y/HeNFCTJLFVxaq6wH4YuVdsUOr75U=
-gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
 gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
 gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

v2/init.go

@@ -0,0 +1,7 @@
+// +build !windows
+
+package wails
+
+func Init() error {
+	return nil
+}

v2/init_windows.go

@@ -0,0 +1,14 @@
+package wails
+
+import (
+	"fmt"
+	"syscall"
+)
+
+func Init() error {
+	status, r, err := syscall.NewLazyDLL("user32.dll").NewProc("SetProcessDPIAware").Call()
+	if status == 0 {
+		return fmt.Errorf("exit status %d: %v %v", status, r, err)
+	}
+	return nil
+}

v2/internal/app/debug.go

@@ -2,11 +2,40 @@
 
 package app
 
+import (
+	"flag"
+	"strings"
+
+	"github.com/wailsapp/wails/v2/pkg/logger"
+)
+
 // Init initialises the application for a debug environment
 func (a *App) Init() error {
 	// Indicate debug mode
 	a.debug = true
-	// Enable dev tools
-	a.options.DevTools = true
+
+	if a.appType == "desktop" {
+		// Enable dev tools
+		a.options.DevTools = true
+	}
+
+	// Set log levels
+	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)
+		}
+	}
+
 	return nil
 }

v2/internal/app/default.go

@@ -1,4 +1,4 @@
-// +build !desktop,!hybrid,!server
+// +build !desktop,!hybrid,!server,!dev
 
 package app
 
@@ -10,6 +10,8 @@ package app
 import (
 	"os"
 
+	"github.com/wailsapp/wails/v2/internal/logger"
+
 	"github.com/wailsapp/wails/v2/pkg/options"
 )
 
@@ -22,6 +24,8 @@ type App struct {
 
 	// Indicates if the app is running in debug mode
 	debug bool
+
+	logger *logger.Logger
 }
 
 // CreateApp returns a null application
@@ -35,7 +39,3 @@ func (a *App) Run() error {
 	os.Exit(1)
 	return nil
 }
-
-// Bind the dummy interface
-func (a *App) Bind(_ interface{}) {
-}

v2/internal/app/desktop.go

@@ -3,9 +3,13 @@
 package app
 
 import (
+	"context"
+	"sync"
+
 	"github.com/wailsapp/wails/v2/internal/binding"
 	"github.com/wailsapp/wails/v2/internal/ffenestri"
 	"github.com/wailsapp/wails/v2/internal/logger"
+	"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"
@@ -16,6 +20,8 @@ import (
 
 // App defines a Wails application structure
 type App struct {
+	appType string
+
 	window     *ffenestri.Application
 	servicebus *servicebus.ServiceBus
 	logger     *logger.Logger
@@ -23,15 +29,16 @@ type App struct {
 	options    *options.App
 
 	// Subsystems
-	log          *subsystem.Log
-	runtime      *subsystem.Runtime
-	event        *subsystem.Event
-	binding      *subsystem.Binding
-	call         *subsystem.Call
-	menu         *subsystem.Menu
-	tray         *subsystem.Tray
-	contextmenus *subsystem.ContextMenus
-	dispatcher   *messagedispatcher.Dispatcher
+	log     *subsystem.Log
+	runtime *subsystem.Runtime
+	event   *subsystem.Event
+	//binding    *subsystem.Binding
+	call       *subsystem.Call
+	menu       *subsystem.Menu
+	url        *subsystem.URL
+	dispatcher *messagedispatcher.Dispatcher
+
+	menuManager *menumanager.Manager
 
 	// Indicates if the app is in debug mode
 	debug bool
@@ -42,6 +49,10 @@ type App struct {
 	// Application Stores
 	loglevelStore  *runtime.Store
 	appconfigStore *runtime.Store
+
+	// Startup/Shutdown
+	startupCallback  func(*runtime.Runtime)
+	shutdownCallback func()
 }
 
 // Create App
@@ -54,13 +65,38 @@ func CreateApp(appoptions *options.App) (*App, error) {
 	myLogger := logger.New(appoptions.Logger)
 	myLogger.SetLogLevel(appoptions.LogLevel)
 
-	window := ffenestri.NewApplicationWithConfig(appoptions, myLogger)
+	// Create the menu manager
+	menuManager := menumanager.NewManager()
+
+	// Process the application menu
+	menuManager.SetApplicationMenu(options.GetApplicationMenu(appoptions))
+
+	// Process context menus
+	contextMenus := options.GetContextMenus(appoptions)
+	for _, contextMenu := range contextMenus {
+		menuManager.AddContextMenu(contextMenu)
+	}
+
+	// Process tray menus
+	trayMenus := options.GetTrayMenus(appoptions)
+	for _, trayMenu := range trayMenus {
+		menuManager.AddTrayMenu(trayMenu)
+	}
+
+	window := ffenestri.NewApplicationWithConfig(appoptions, myLogger, menuManager)
+
+	// Create binding exemptions - Ugly hack. There must be a better way
+	bindingExemptions := []interface{}{appoptions.Startup, appoptions.Shutdown}
 
 	result := &App{
-		window:     window,
-		servicebus: servicebus.New(myLogger),
-		logger:     myLogger,
-		bindings:   binding.NewBindings(myLogger),
+		appType:          "desktop",
+		window:           window,
+		servicebus:       servicebus.New(myLogger),
+		logger:           myLogger,
+		bindings:         binding.NewBindings(myLogger, appoptions.Bind, bindingExemptions),
+		menuManager:      menuManager,
+		startupCallback:  appoptions.Startup,
+		shutdownCallback: appoptions.Shutdown,
 	}
 
 	result.options = appoptions
@@ -77,13 +113,10 @@ func (a *App) Run() error {
 
 	var err error
 
-	// Setup signal handler
-	signalsubsystem, err := signal.NewManager(a.servicebus, a.logger)
-	if err != nil {
-		return err
-	}
-	a.signal = signalsubsystem
-	a.signal.Start()
+	// 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()
@@ -92,12 +125,7 @@ func (a *App) Run() error {
 		return err
 	}
 
-	// Start the runtime
-	applicationMenu := options.GetApplicationMenu(a.options)
-	trayMenu := options.GetTray(a.options)
-	contextMenus := options.GetContextMenus(a.options)
-
-	runtimesubsystem, err := subsystem.NewRuntime(a.servicebus, a.logger, applicationMenu, trayMenu, contextMenus)
+	runtimesubsystem, err := subsystem.NewRuntime(ctx, a.servicebus, a.logger, a.startupCallback)
 	if err != nil {
 		return err
 	}
@@ -111,17 +139,6 @@ func (a *App) Run() error {
 	a.loglevelStore = a.runtime.GoRuntime().Store.New("wails:loglevel", a.options.LogLevel)
 	a.appconfigStore = a.runtime.GoRuntime().Store.New("wails:appconfig", a.options)
 
-	// Start the binding subsystem
-	bindingsubsystem, err := subsystem.NewBinding(a.servicebus, a.logger, a.bindings, a.runtime.GoRuntime())
-	if err != nil {
-		return err
-	}
-	a.binding = bindingsubsystem
-	err = a.binding.Start()
-	if err != nil {
-		return err
-	}
-
 	// Start the logging subsystem
 	log, err := subsystem.NewLog(a.servicebus, a.logger, a.loglevelStore)
 	if err != nil {
@@ -144,62 +161,47 @@ func (a *App) Run() error {
 		return err
 	}
 
+	if a.options.Mac.URLHandlers != nil {
+		// Start the url handler subsystem
+		url, err := subsystem.NewURL(a.servicebus, a.logger, a.options.Mac.URLHandlers)
+		if err != nil {
+			return err
+		}
+		a.url = url
+		err = a.url.Start()
+		if err != nil {
+			return err
+		}
+	}
+
 	// Start the eventing subsystem
-	event, err := subsystem.NewEvent(a.servicebus, a.logger)
+	eventsubsystem, err := subsystem.NewEvent(ctx, a.servicebus, a.logger)
 	if err != nil {
 		return err
 	}
-	a.event = event
+	a.event = eventsubsystem
 	err = a.event.Start()
 	if err != nil {
 		return err
 	}
 
-	// Optionally start the menu subsystem
-	if applicationMenu != nil {
-		menusubsystem, err := subsystem.NewMenu(applicationMenu, a.servicebus, a.logger)
-		if err != nil {
-			return err
-		}
-		a.menu = menusubsystem
-		err = a.menu.Start()
-		if err != nil {
-			return err
-		}
-	}
-
-	// Optionally start the tray subsystem
-	if trayMenu != nil {
-		traysubsystem, err := subsystem.NewTray(trayMenu, a.servicebus, a.logger)
-		if err != nil {
-			return err
-		}
-		a.tray = traysubsystem
-		err = a.tray.Start()
-		if err != nil {
-			return err
-		}
-	}
-
-	// Optionally start the context menu subsystem
-	if contextMenus != nil {
-		contextmenussubsystem, err := subsystem.NewContextMenus(contextMenus, a.servicebus, a.logger)
-		if err != nil {
-			return err
-		}
-		a.contextmenus = contextmenussubsystem
-		err = a.contextmenus.Start()
-		if err != nil {
-			return err
-		}
-	}
-
-	// Start the call subsystem
-	call, err := subsystem.NewCall(a.servicebus, a.logger, a.bindings.DB(), a.runtime.GoRuntime())
+	// Start the menu subsystem
+	menusubsystem, err := subsystem.NewMenu(ctx, a.servicebus, a.logger, a.menuManager)
 	if err != nil {
 		return err
 	}
-	a.call = call
+	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
@@ -211,23 +213,42 @@ func (a *App) Run() error {
 		return err
 	}
 
-	result := a.window.Run(dispatcher, bindingDump, a.debug)
+	// 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.window.Run(dispatcher, bindingDump, a.debug)
 	a.logger.Trace("Ffenestri.Run() exited")
+	if err != nil {
+		return err
+	}
+
+	// Close down all the subsystems
+	a.logger.Trace("Cancelling subsystems")
+	cancel()
+	subsystemWaitGroup.Wait()
+
+	a.logger.Trace("Cancelling dispatcher")
+	dispatcher.Close()
+
+	// Close log
+	a.logger.Trace("Stopping log")
+	log.Close()
+
+	a.logger.Trace("Stopping Service bus")
 	err = a.servicebus.Stop()
 	if err != nil {
 		return err
 	}
 
-	return result
-}
-
-// Bind a struct to the application by passing in
-// a pointer to it
-func (a *App) Bind(structPtr interface{}) {
-
-	// Add the struct to the bindings
-	err := a.bindings.Add(structPtr)
-	if err != nil {
-		a.logger.Fatal("Error during binding: " + err.Error())
+	// Shutdown callback
+	if a.shutdownCallback != nil {
+		a.shutdownCallback()
 	}
+
+	return nil
 }

v2/internal/app/dev.go

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

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

v2/internal/app/server.go

@@ -6,10 +6,13 @@ import (
 	"os"
 	"path/filepath"
 
+	"github.com/wailsapp/wails/v2/pkg/options"
+
 	"github.com/leaanthony/clir"
 	"github.com/wailsapp/wails/v2/internal/binding"
 	"github.com/wailsapp/wails/v2/internal/logger"
 	"github.com/wailsapp/wails/v2/internal/messagedispatcher"
+	"github.com/wailsapp/wails/v2/internal/runtime"
 	"github.com/wailsapp/wails/v2/internal/servicebus"
 	"github.com/wailsapp/wails/v2/internal/subsystem"
 	"github.com/wailsapp/wails/v2/internal/webserver"
@@ -17,12 +20,16 @@ import (
 
 // App defines a Wails application structure
 type App struct {
+	appType string
+
 	binding *subsystem.Binding
 	call    *subsystem.Call
 	event   *subsystem.Event
 	log     *subsystem.Log
 	runtime *subsystem.Runtime
 
+	options *options.App
+
 	bindings   *binding.Bindings
 	logger     *logger.Logger
 	dispatcher *messagedispatcher.Dispatcher
@@ -30,28 +37,40 @@ type App struct {
 	webserver  *webserver.WebServer
 
 	debug bool
+
+	// Application Stores
+	loglevelStore  *runtime.Store
+	appconfigStore *runtime.Store
+
+	// Startup/Shutdown
+	startupCallback  func(*runtime.Runtime)
+	shutdownCallback func()
 }
 
 // Create App
-func CreateApp(options *Options) *App {
-	options.mergeDefaults()
-	// We ignore the inputs (for now)
+func CreateApp(appoptions *options.App) (*App, error) {
 
-	// TODO: Allow logger output override on CLI
-	myLogger := logger.New(os.Stdout)
-	myLogger.SetLogLevel(logger.TRACE)
+	// Merge default options
+	options.MergeDefaults(appoptions)
+
+	// Set up logger
+	myLogger := logger.New(appoptions.Logger)
+	myLogger.SetLogLevel(appoptions.LogLevel)
 
 	result := &App{
-		bindings:   binding.NewBindings(myLogger),
-		logger:     myLogger,
-		servicebus: servicebus.New(myLogger),
-		webserver:  webserver.NewWebServer(myLogger),
+		appType:          "server",
+		bindings:         binding.NewBindings(myLogger, options.Bind),
+		logger:           myLogger,
+		servicebus:       servicebus.New(myLogger),
+		webserver:        webserver.NewWebServer(myLogger),
+		startupCallback:  appoptions.Startup,
+		shutdownCallback: appoptions.Shutdown,
 	}
 
 	// Initialise app
 	result.Init()
 
-	return result
+	return result, nil
 }
 
 // Run the application
@@ -60,7 +79,7 @@ func (a *App) Run() error {
 	// Default app options
 	var port = 8080
 	var ip = "localhost"
-	var supressLogging = false
+	var SuppressLogging = false
 	var debugMode = false
 
 	// Create CLI
@@ -70,7 +89,7 @@ func (a *App) Run() error {
 	cli.IntFlag("p", "Port to serve on", &port)
 	cli.StringFlag("i", "IP to serve on", &ip)
 	cli.BoolFlag("d", "Debug mode", &debugMode)
-	cli.BoolFlag("q", "Supress logging", &supressLogging)
+	cli.BoolFlag("q", "Suppress logging", &SuppressLogging)
 
 	// Setup main action
 	cli.Action(func() error {
@@ -79,8 +98,8 @@ func (a *App) Run() error {
 		a.webserver.SetPort(port)
 		a.webserver.SetIP(ip)
 		a.webserver.SetBindings(a.bindings)
-		// Log information (if we aren't supressing it)
-		if !supressLogging {
+		// Log information (if we aren't Suppressing it)
+		if !SuppressLogging {
 			cli.PrintBanner()
 			a.logger.Info("Running server at %s", a.webserver.URL())
 		}
@@ -88,8 +107,21 @@ func (a *App) Run() error {
 		if debugMode {
 			a.servicebus.Debug()
 		}
+
+		// Start the runtime
+		runtime, err := subsystem.NewRuntime(a.servicebus, a.logger, a.startupCallback, a.shutdownCallback)
+		if err != nil {
+			return err
+		}
+		a.runtime = runtime
+		a.runtime.Start()
+
+		// Application Stores
+		a.loglevelStore = a.runtime.GoRuntime().Store.New("wails:loglevel", a.options.LogLevel)
+		a.appconfigStore = a.runtime.GoRuntime().Store.New("wails:appconfig", a.options)
+
 		a.servicebus.Start()
-		log, err := subsystem.NewLog(a.servicebus, a.logger)
+		log, err := subsystem.NewLog(a.servicebus, a.logger, a.loglevelStore)
 		if err != nil {
 			return err
 		}
@@ -102,14 +134,6 @@ func (a *App) Run() error {
 		a.dispatcher = dispatcher
 		a.dispatcher.Start()
 
-		// Start the runtime
-		runtime, err := subsystem.NewRuntime(a.servicebus, a.logger)
-		if err != nil {
-			return err
-		}
-		a.runtime = runtime
-		a.runtime.Start()
-
 		// Start the binding subsystem
 		binding, err := subsystem.NewBinding(a.servicebus, a.logger, a.bindings, runtime.GoRuntime())
 		if err != nil {
@@ -127,7 +151,7 @@ func (a *App) Run() error {
 		a.event.Start()
 
 		// Start the call subsystem
-		call, err := subsystem.NewCall(a.servicebus, a.logger, a.bindings.DB())
+		call, err := subsystem.NewCall(a.servicebus, a.logger, a.bindings.DB(), a.runtime.GoRuntime())
 		if err != nil {
 			return err
 		}
@@ -147,14 +171,3 @@ func (a *App) Run() error {
 
 	return cli.Run()
 }
-
-// Bind a struct to the application by passing in
-// a pointer to it
-func (a *App) Bind(structPtr interface{}) {
-
-	// Add the struct to the bindings
-	err := a.bindings.Add(structPtr)
-	if err != nil {
-		a.logger.Fatal("Error during binding: " + err.Error())
-	}
-}

v2/internal/binding/assets/package.json

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

v2/internal/binding/binding.go

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

v2/internal/binding/boundMethod.go

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

v2/internal/binding/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

@@ -0,0 +1,155 @@
+package binding
+
+import (
+	"bytes"
+	_ "embed"
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/wailsapp/wails/v2/internal/fs"
+
+	"github.com/leaanthony/slicer"
+)
+
+//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
+				} else {
+					returnType = "Promise<void>"
+				}
+				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")
+
+	// TODO: Make this configurable in wails.json
+	dirname, err := fs.RelativeToCwd("frontend/src/backend")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	if !fs.DirExists(dirname) {
+		err := fs.MkDirs(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 input == "[]byte":
+		return "string"
+	case strings.HasPrefix(input, "[]"):
+		arrayType := goTypeToJSDocType(input[2:])
+		return "Array.<" + arrayType + ">"
+	default:
+		return "any"
+	}
+}

v2/internal/binding/generate_test.go

@@ -0,0 +1,87 @@
+package binding
+
+import (
+	"testing"
+)
+
+func Test_goTypeToJSDocType(t *testing.T) {
+
+	tests := []struct {
+		name  string
+		input string
+		want  string
+	}{
+		{
+			name:  "string",
+			input: "string",
+			want:  "string",
+		},
+		{
+			name:  "error",
+			input: "error",
+			want:  "Error",
+		},
+		{
+			name:  "int",
+			input: "int",
+			want:  "number",
+		},
+		{
+			name:  "int32",
+			input: "int32",
+			want:  "number",
+		},
+		{
+			name:  "uint",
+			input: "uint",
+			want:  "number",
+		},
+		{
+			name:  "uint32",
+			input: "uint32",
+			want:  "number",
+		},
+		{
+			name:  "float32",
+			input: "float32",
+			want:  "number",
+		},
+		{
+			name:  "float64",
+			input: "float64",
+			want:  "number",
+		},
+		{
+			name:  "bool",
+			input: "bool",
+			want:  "boolean",
+		},
+		{
+			name:  "[]byte",
+			input: "[]byte",
+			want:  "string",
+		},
+		{
+			name:  "[]int",
+			input: "[]int",
+			want:  "Array.<number>",
+		},
+		{
+			name:  "[]bool",
+			input: "[]bool",
+			want:  "Array.<boolean>",
+		},
+		{
+			name:  "anything else",
+			input: "foo",
+			want:  "any",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := goTypeToJSDocType(tt.input); got != tt.want {
+				t.Errorf("goTypeToJSDocType() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

v2/internal/binding/reflect.go

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

v2/internal/bridge/bridge.go

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

v2/internal/bridge/client.go

@@ -0,0 +1,133 @@
+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)
+}
+
+func (b BridgeClient) CallResult(message string) {
+	b.session.sendMessage("c" + message)
+}
+
+func (b BridgeClient) OpenDialog(dialogOptions *dialog.OpenDialog, callbackID string) {
+	// Handled by dialog_client
+}
+
+func (b BridgeClient) SaveDialog(dialogOptions *dialog.SaveDialog, callbackID string) {
+	// Handled by dialog_client
+}
+
+func (b BridgeClient) MessageDialog(dialogOptions *dialog.MessageDialog, callbackID string) {
+	// Handled by dialog_client
+}
+
+func (b BridgeClient) WindowSetTitle(title string) {
+	b.session.log.Info("WindowSetTitle unsupported in Bridge mode")
+}
+
+func (b BridgeClient) WindowShow() {
+	b.session.log.Info("WindowShow unsupported in Bridge mode")
+}
+
+func (b BridgeClient) WindowHide() {
+	b.session.log.Info("WindowHide unsupported in Bridge mode")
+}
+
+func (b BridgeClient) WindowCenter() {
+	b.session.log.Info("WindowCenter unsupported in Bridge mode")
+}
+
+func (b BridgeClient) WindowMaximise() {
+	b.session.log.Info("WindowMaximise unsupported in Bridge mode")
+}
+
+func (b BridgeClient) WindowUnmaximise() {
+	b.session.log.Info("WindowUnmaximise unsupported in Bridge mode")
+}
+
+func (b BridgeClient) WindowMinimise() {
+	b.session.log.Info("WindowMinimise unsupported in Bridge mode")
+}
+
+func (b BridgeClient) WindowUnminimise() {
+	b.session.log.Info("WindowUnminimise unsupported in Bridge mode")
+}
+
+func (b BridgeClient) WindowPosition(x int, y int) {
+	b.session.log.Info("WindowPosition unsupported in Bridge mode")
+}
+
+func (b BridgeClient) WindowSize(width int, height int) {
+	b.session.log.Info("WindowSize unsupported in Bridge mode")
+}
+
+func (b BridgeClient) WindowSetMinSize(width int, height int) {
+	b.session.log.Info("WindowSetMinSize unsupported in Bridge mode")
+}
+
+func (b BridgeClient) WindowSetMaxSize(width int, height int) {
+	b.session.log.Info("WindowSetMaxSize unsupported in Bridge mode")
+}
+
+func (b BridgeClient) WindowFullscreen() {
+	b.session.log.Info("WindowFullscreen unsupported in Bridge mode")
+}
+
+func (b BridgeClient) WindowUnFullscreen() {
+	b.session.log.Info("WindowUnFullscreen unsupported in Bridge mode")
+}
+
+func (b BridgeClient) WindowSetColour(colour int) {
+	b.session.log.Info("WindowSetColour unsupported in Bridge mode")
+}
+
+func (b BridgeClient) DarkModeEnabled(callbackID string) {
+	b.session.log.Info("DarkModeEnabled unsupported in Bridge mode")
+}
+
+func (b BridgeClient) SetApplicationMenu(menuJSON string) {
+	b.session.log.Info("SetApplicationMenu unsupported in Bridge mode")
+}
+
+func (b BridgeClient) SetTrayMenu(trayMenuJSON string) {
+	b.session.sendMessage("TS" + trayMenuJSON)
+}
+
+func (b BridgeClient) UpdateTrayMenuLabel(trayMenuJSON string) {
+	b.session.sendMessage("TU" + trayMenuJSON)
+}
+
+func (b BridgeClient) UpdateContextMenu(contextMenuJSON string) {
+	b.session.log.Info("UpdateContextMenu unsupported in Bridge mode")
+}
+
+func newBridgeClient(session *session) *BridgeClient {
+	return &BridgeClient{
+		session: session,
+	}
+}

v2/internal/bridge/dialog_client.go

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

@@ -0,0 +1,187 @@
+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
+
+//go:embed windows.js
+var windowsRuntime string
+
+//go:embed linux.js
+var linuxRuntime 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
+	case "windows":
+		wailsRuntime = windowsRuntime
+	case "linux":
+		wailsRuntime = linuxRuntime
+	default:
+		log.Fatal("platform not supported")
+	}
+
+	bindingsMessage := "window.wailsbindings = `" + s.bindings + "`;"
+	s.log.Info(bindingsMessage)
+	bootstrapMessage := bindingsMessage + wailsRuntime
+
+	err := s.sendMessage("b" + bootstrapMessage)
+	if err != nil {
+		s.log.Error(err.Error())
+	}
+
+	// Send menus
+	traymenus, err := s.menumanager.GetTrayMenus()
+	if err != nil {
+		s.log.Error(err.Error())
+	}
+
+	for _, trayMenu := range traymenus {
+		err := s.sendMessage("TS" + trayMenu)
+		if err != nil {
+			s.log.Error(err.Error())
+		}
+	}
+
+	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() {
+	err := s.conn.Close()
+	if err != nil {
+		s.log.Error(err.Error())
+	}
+	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:
+			err := s.conn.SetWriteDeadline(time.Now().Add(1 * time.Second))
+			if err != nil {
+				s.log.Error(err.Error())
+			}
+			if !ok {
+				s.log.Debug("writeChan was closed!")
+				err := s.conn.WriteMessage(websocket.CloseMessage, []byte{})
+				if err != nil {
+					s.log.Error(err.Error())
+				}
+				return
+			}
+
+			if err := s.conn.WriteMessage(websocket.TextMessage, msg); err != nil {
+				s.log.Debug(err.Error())
+				return
+			}
+		}
+	}
+}

v2/internal/colour/colour.go

@@ -0,0 +1,89 @@
+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/deepcopy/LICENSE

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

v2/internal/deepcopy/deepcopy.go

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

v2/internal/ffenestri/LICENCES.md

@@ -1,5 +1,11 @@
 # 3rd Party Licenses
 
+## Webview
+Whilst not using the library directly, there is certainly some code that is inspired by or used from the webview library.
+
+Homepage: https://github.com/webview/webview
+License: https://github.com/webview/webview/blob/master/LICENSE
+
 ## vec
 Homepage: https://github.com/rxi/vec
 License: https://github.com/rxi/vec/blob/master/LICENSE

v2/internal/ffenestri/common.c

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

v2/internal/ffenestri/common.h

@@ -0,0 +1,36 @@
+//
+// Created by Lea Anthony on 6/1/21.
+//
+
+#ifndef COMMON_H
+#define COMMON_H
+
+#include <stdio.h>
+#include <stdarg.h>
+#include "string.h"
+#include "hashmap.h"
+#include "vec.h"
+#include "json.h"
+
+#define STREQ(a,b) strcmp(a, b) == 0
+#define STREMPTY(string) strlen(string) == 0
+#define STRCOPY(a) concat(a, "")
+#define STR_HAS_CHARS(input) input != NULL && strlen(input) > 0
+#define MEMFREE(input) free((void*)input); input = NULL;
+#define FREE_AND_SET(variable, value) if( variable != NULL ) { MEMFREE(variable); } variable = value
+
+// Credit: https://stackoverflow.com/a/8465083
+char* concat(const char *string1, const char *string2);
+void ABORT(const char *message, ...);
+int freeHashmapItem(void *const context, struct hashmap_element_s *const e);
+const char* getJSONString(JsonNode *item, const char* key);
+const char* mustJSONString(JsonNode *node, const char* key);
+JsonNode* getJSONObject(JsonNode* node, const char* key);
+JsonNode* mustJSONObject(JsonNode *node, const char* key);
+
+bool getJSONBool(JsonNode *item, const char* key, bool *result);
+bool getJSONInt(JsonNode *item, const char* key, int *result);
+
+JsonNode* mustParseJSON(const char* JSON);
+
+#endif //ASSETS_C_COMMON_H

v2/internal/ffenestri/contextmenus_darwin.c

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

v2/internal/ffenestri/contextmenus_darwin.h

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

v2/internal/ffenestri/contextmenustore_darwin.c

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

v2/internal/ffenestri/contextmenustore_darwin.h

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

v2/internal/ffenestri/effectstructs_windows.h

@@ -0,0 +1,64 @@
+// Credit: https://gist.github.com/ysc3839/b08d2bff1c7dacde529bed1d37e85ccf
+#pragma once
+
+typedef enum _WINDOWCOMPOSITIONATTRIB
+{
+	WCA_UNDEFINED = 0,
+	WCA_NCRENDERING_ENABLED = 1,
+	WCA_NCRENDERING_POLICY = 2,
+	WCA_TRANSITIONS_FORCEDISABLED = 3,
+	WCA_ALLOW_NCPAINT = 4,
+	WCA_CAPTION_BUTTON_BOUNDS = 5,
+	WCA_NONCLIENT_RTL_LAYOUT = 6,
+	WCA_FORCE_ICONIC_REPRESENTATION = 7,
+	WCA_EXTENDED_FRAME_BOUNDS = 8,
+	WCA_HAS_ICONIC_BITMAP = 9,
+	WCA_THEME_ATTRIBUTES = 10,
+	WCA_NCRENDERING_EXILED = 11,
+	WCA_NCADORNMENTINFO = 12,
+	WCA_EXCLUDED_FROM_LIVEPREVIEW = 13,
+	WCA_VIDEO_OVERLAY_ACTIVE = 14,
+	WCA_FORCE_ACTIVEWINDOW_APPEARANCE = 15,
+	WCA_DISALLOW_PEEK = 16,
+	WCA_CLOAK = 17,
+	WCA_CLOAKED = 18,
+	WCA_ACCENT_POLICY = 19,
+	WCA_FREEZE_REPRESENTATION = 20,
+	WCA_EVER_UNCLOAKED = 21,
+	WCA_VISUAL_OWNER = 22,
+	WCA_HOLOGRAPHIC = 23,
+	WCA_EXCLUDED_FROM_DDA = 24,
+	WCA_PASSIVEUPDATEMODE = 25,
+	WCA_USEDARKMODECOLORS = 26,
+	WCA_LAST = 27
+} WINDOWCOMPOSITIONATTRIB;
+
+typedef struct _WINDOWCOMPOSITIONATTRIBDATA
+{
+	WINDOWCOMPOSITIONATTRIB Attrib;
+	PVOID pvData;
+	SIZE_T cbData;
+} WINDOWCOMPOSITIONATTRIBDATA;
+
+typedef enum _ACCENT_STATE
+{
+	ACCENT_DISABLED = 0,
+	ACCENT_ENABLE_GRADIENT = 1,
+	ACCENT_ENABLE_TRANSPARENTGRADIENT = 2,
+	ACCENT_ENABLE_BLURBEHIND = 3,
+	ACCENT_ENABLE_ACRYLICBLURBEHIND = 4, // RS4 1803
+	ACCENT_ENABLE_HOSTBACKDROP = 5, // RS5 1809
+ 	ACCENT_INVALID_STATE = 6
+} ACCENT_STATE;
+
+typedef struct _ACCENT_POLICY
+{
+	ACCENT_STATE AccentState;
+	DWORD AccentFlags;
+	DWORD GradientColor;
+	DWORD AnimationId;
+} ACCENT_POLICY;
+
+typedef BOOL (WINAPI *pfnGetWindowCompositionAttribute)(HWND, WINDOWCOMPOSITIONATTRIBDATA*);
+
+typedef BOOL (WINAPI *pfnSetWindowCompositionAttribute)(HWND, WINDOWCOMPOSITIONATTRIBDATA*);

v2/internal/ffenestri/ffenestri.go

@@ -5,23 +5,25 @@ import (
 	"strings"
 	"unsafe"
 
+	"github.com/wailsapp/wails/v2/internal/menumanager"
+
 	"github.com/wailsapp/wails/v2/internal/logger"
 	"github.com/wailsapp/wails/v2/internal/messagedispatcher"
 	"github.com/wailsapp/wails/v2/pkg/options"
 )
 
 /*
-
 #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
 
+#cgo windows CXXFLAGS: -std=c++11
+#cgo windows,amd64 LDFLAGS: -L./windows/x64 -lwebview -lWebView2Loader -lgdi32 -lole32 -lShlwapi -luser32 -loleaut32
+
 #include <stdlib.h>
 #include "ffenestri.h"
-
-
 */
 import "C"
 
@@ -31,7 +33,10 @@ type Application struct {
 	memory []unsafe.Pointer
 
 	// This is the main app pointer
-	app unsafe.Pointer
+	app *C.struct_Application
+
+	// Manages menus
+	menuManager *menumanager.Manager
 
 	// Logger
 	logger logger.CustomLogger
@@ -52,18 +57,11 @@ func init() {
 }
 
 // NewApplicationWithConfig creates a new application based on the given config
-func NewApplicationWithConfig(config *options.App, logger *logger.Logger) *Application {
+func NewApplicationWithConfig(config *options.App, logger *logger.Logger, menuManager *menumanager.Manager) *Application {
 	return &Application{
-		config: config,
-		logger: logger.CustomLogger("Ffenestri"),
-	}
-}
-
-// NewApplication creates a new Application with the default config
-func NewApplication(logger *logger.Logger) *Application {
-	return &Application{
-		config: options.Default,
-		logger: logger.CustomLogger("Ffenestri"),
+		config:      config,
+		logger:      logger.CustomLogger("Ffenestri"),
+		menuManager: menuManager,
 	}
 }
 
@@ -113,10 +111,11 @@ func (a *Application) Run(incomingDispatcher Dispatcher, bindings string, debug
 	fullscreen := a.bool2Cint(a.config.Fullscreen)
 	startHidden := a.bool2Cint(a.config.StartHidden)
 	logLevel := C.int(a.config.LogLevel)
-	app := C.NewApplication(title, width, height, resizable, devtools, fullscreen, startHidden, logLevel)
+	hideWindowOnClose := a.bool2Cint(a.config.HideWindowOnClose)
+	app := C.NewApplication(title, width, height, resizable, devtools, fullscreen, startHidden, logLevel, hideWindowOnClose)
 
 	// Save app reference
-	a.app = unsafe.Pointer(app)
+	a.app = (*C.struct_Application)(app)
 
 	// Set Min Window Size
 	minWidth := C.int(a.config.MinWidth)
@@ -132,9 +131,9 @@ func (a *Application) Run(incomingDispatcher Dispatcher, bindings string, debug
 	C.SetDebug(app, a.bool2Cint(debug))
 
 	// TODO: Move frameless to Linux options
-	// if a.config.Frameless {
-	// 	C.DisableFrame(a.app)
-	// }
+	if a.config.Frameless {
+		C.DisableFrame(a.app)
+	}
 
 	if a.config.RGBA != 0 {
 		r, g, b, alpha := intToColour(a.config.RGBA)
@@ -152,7 +151,10 @@ func (a *Application) Run(incomingDispatcher Dispatcher, bindings string, debug
 	dispatcher = incomingDispatcher.RegisterClient(newClient(a))
 
 	// Process platform settings
-	a.processPlatformSettings()
+	err := a.processPlatformSettings()
+	if err != nil {
+		return err
+	}
 
 	// Check we could initialise the application
 	if app != nil {
@@ -163,7 +165,7 @@ func (a *Application) Run(incomingDispatcher Dispatcher, bindings string, debug
 		// Oh no! We couldn't initialise the application
 		a.logger.Fatal("Cannot initialise Application.")
 	}
-
+	//println("\n\n\n\n\n\nhererererer\n\n\n\n")
 	a.freeMemory()
 	return nil
 }

v2/internal/ffenestri/ffenestri.h

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

v2/internal/ffenestri/ffenestri_client.go

@@ -1,23 +1,16 @@
 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 (
-	"encoding/json"
-	"github.com/wailsapp/wails/v2/pkg/menu"
 	"strconv"
 
+	"github.com/wailsapp/wails/v2/pkg/options/dialog"
+
 	"github.com/wailsapp/wails/v2/internal/logger"
-	"github.com/wailsapp/wails/v2/pkg/options"
 )
 
 // Client is our implentation of messageDispatcher.Client
@@ -115,6 +108,14 @@ func (c *Client) WindowSize(width int, height int) {
 	C.SetSize(c.app.app, C.int(width), C.int(height))
 }
 
+func (c *Client) WindowSetMinSize(width int, height int) {
+	C.SetMinWindowSize(c.app.app, C.int(width), C.int(height))
+}
+
+func (c *Client) WindowSetMaxSize(width int, height int) {
+	C.SetMaxWindowSize(c.app.app, C.int(width), C.int(height))
+}
+
 // WindowSetColour sets the window colour
 func (c *Client) WindowSetColour(colour int) {
 	r, g, b, a := intToColour(colour)
@@ -122,7 +123,7 @@ func (c *Client) WindowSetColour(colour int) {
 }
 
 // OpenDialog will open a dialog with the given title and filter
-func (c *Client) OpenDialog(dialogOptions *options.OpenDialog, callbackID string) {
+func (c *Client) OpenDialog(dialogOptions *dialog.OpenDialog, callbackID string) {
 	C.OpenDialog(c.app.app,
 		c.app.string2CString(callbackID),
 		c.app.string2CString(dialogOptions.Title),
@@ -140,7 +141,7 @@ func (c *Client) OpenDialog(dialogOptions *options.OpenDialog, callbackID string
 }
 
 // SaveDialog will open a dialog with the given title and filter
-func (c *Client) SaveDialog(dialogOptions *options.SaveDialog, callbackID string) {
+func (c *Client) SaveDialog(dialogOptions *dialog.SaveDialog, callbackID string) {
 	C.SaveDialog(c.app.app,
 		c.app.string2CString(callbackID),
 		c.app.string2CString(dialogOptions.Title),
@@ -154,7 +155,7 @@ func (c *Client) SaveDialog(dialogOptions *options.SaveDialog, callbackID string
 }
 
 // MessageDialog will open a message dialog with the given options
-func (c *Client) MessageDialog(dialogOptions *options.MessageDialog, callbackID string) {
+func (c *Client) MessageDialog(dialogOptions *dialog.MessageDialog, callbackID string) {
 
 	// Sanity check button length
 	if len(dialogOptions.Buttons) > 4 {
@@ -186,57 +187,22 @@ func (c *Client) DarkModeEnabled(callbackID string) {
 	C.DarkModeEnabled(c.app.app, c.app.string2CString(callbackID))
 }
 
-func (c *Client) UpdateMenu(menu *menu.Menu) {
-
-	// Guard against nil menus
-	if menu == nil {
-		return
-	}
-	// Process the menu
-	processedMenu := NewProcessedMenu(menu)
-	menuJSON, err := json.Marshal(processedMenu)
-	if err != nil {
-		c.app.logger.Error("Error processing updated Menu: %s", err.Error())
-		return
-	}
-	C.UpdateMenu(c.app.app, c.app.string2CString(string(menuJSON)))
+func (c *Client) SetApplicationMenu(applicationMenuJSON string) {
+	C.SetApplicationMenu(c.app.app, c.app.string2CString(applicationMenuJSON))
 }
 
-func (c *Client) UpdateTray(menu *menu.Menu) {
-
-	// Guard against nil menus
-	if menu == nil {
-		return
-	}
-	// Process the menu
-	processedMenu := NewProcessedMenu(menu)
-	trayMenuJSON, err := json.Marshal(processedMenu)
-	if err != nil {
-		c.app.logger.Error("Error processing updated Tray: %s", err.Error())
-		return
-	}
-	C.UpdateTray(c.app.app, c.app.string2CString(string(trayMenuJSON)))
+func (c *Client) SetTrayMenu(trayMenuJSON string) {
+	C.SetTrayMenu(c.app.app, c.app.string2CString(trayMenuJSON))
 }
 
-func (c *Client) UpdateTrayLabel(label string) {
-	C.UpdateTrayLabel(c.app.app, c.app.string2CString(label))
+func (c *Client) UpdateTrayMenuLabel(JSON string) {
+	C.UpdateTrayMenuLabel(c.app.app, c.app.string2CString(JSON))
 }
 
-func (c *Client) UpdateTrayIcon(name string) {
-	C.UpdateTrayIcon(c.app.app, c.app.string2CString(name))
+func (c *Client) UpdateContextMenu(contextMenuJSON string) {
+	C.UpdateContextMenu(c.app.app, c.app.string2CString(contextMenuJSON))
 }
 
-func (c *Client) UpdateContextMenus(contextMenus *menu.ContextMenus) {
-
-	// Guard against nil contextMenus
-	if contextMenus == nil {
-		return
-	}
-	// Process the menu
-	contextMenusJSON, err := json.Marshal(contextMenus)
-	if err != nil {
-		c.app.logger.Error("Error processing updated Context Menus: %s", err.Error())
-		return
-	}
-	C.UpdateContextMenus(c.app.app, c.app.string2CString(string(contextMenusJSON)))
+func (c *Client) DeleteTrayMenuByID(id string) {
+	C.DeleteTrayMenuByID(c.app.app, c.app.string2CString(id))
 }

v2/internal/ffenestri/ffenestri_darwin.go

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

v2/internal/ffenestri/ffenestri_darwin.h

@@ -2,18 +2,153 @@
 #ifndef FFENESTRI_DARWIN_H
 #define FFENESTRI_DARWIN_H
 
-extern void TitlebarAppearsTransparent(void *);
-extern void HideTitle(void *);
-extern void HideTitleBar(void *);
-extern void FullSizeContent(void *);
-extern void UseToolbar(void *);
-extern void HideToolbarSeparator(void *);
-extern void DisableFrame(void *);
-extern void SetAppearance(void *, const char *);
-extern void WebviewIsTransparent(void *);
-extern void WindowBackgroundIsTranslucent(void *);
-extern void SetMenu(void *, const char *);
-extern void SetTray(void *, const char *, const char *, const char *);
-extern void SetContextMenus(void *, const char *);
+
+#define OBJC_OLD_DISPATCH_PROTOTYPES 1
+#include <objc/objc-runtime.h>
+#include <CoreGraphics/CoreGraphics.h>
+#include <CoreFoundation/CoreFoundation.h>
+#include "json.h"
+#include "hashmap.h"
+#include "stdlib.h"
+
+typedef struct {
+    long maj;
+    long min;
+    long patch;
+} OSVersion;
+
+// Macros to make it slightly more sane
+#define msg objc_msgSend
+#define msg_reg ((id(*)(id, SEL))objc_msgSend)
+#define msg_id ((id(*)(id, SEL, id))objc_msgSend)
+#define msg_id_id ((id(*)(id, SEL, id, id))objc_msgSend)
+#define msg_bool ((id(*)(id, SEL, BOOL))objc_msgSend)
+#define msg_int ((id(*)(id, SEL, int))objc_msgSend)
+#define msg_uint ((id(*)(id, SEL, unsigned int))objc_msgSend)
+#define msg_float ((id(*)(id, SEL, float))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)
+#define str(input) ((id(*)(id, SEL, const char *))objc_msgSend)(c("NSString"), s("stringWithUTF8String:"), input)
+#define strunicode(input) ((id(*)(id, SEL, id, unsigned short))objc_msgSend)(c("NSString"), s("stringWithFormat:"), str("%C"), (unsigned short)input)
+#define cstr(input) (const char *)msg_reg(input, s("UTF8String"))
+#define url(input) msg_id(c("NSURL"), s("fileURLWithPath:"), str(input))
+#define ALLOC(classname) msg_reg(c(classname), s("alloc"))
+#define ALLOC_INIT(classname) msg_reg(msg_reg(c(classname), s("alloc")), s("init"))
+
+#if defined (__aarch64__)
+#define GET_FRAME(receiver) ((CGRect(*)(id, SEL))objc_msgSend)(receiver, s("frame"))
+#define GET_BOUNDS(receiver) ((CGRect(*)(id, SEL))objc_msgSend)(receiver, s("bounds"))
+#define GET_OSVERSION(receiver) ((OSVersion(*)(id, SEL))objc_msgSend)(processInfo, s("operatingSystemVersion"));
+#endif
+
+#if defined (__x86_64__)
+#define GET_FRAME(receiver) ((CGRect(*)(id, SEL))objc_msgSend_stret)(receiver, s("frame"))
+#define GET_BOUNDS(receiver) ((CGRect(*)(id, SEL))objc_msgSend_stret)(receiver, s("bounds"))
+#define GET_OSVERSION(receiver) ((OSVersion(*)(id, SEL))objc_msgSend_stret)(processInfo, s("operatingSystemVersion"));
+#endif
+
+#define GET_BACKINGSCALEFACTOR(receiver) ((CGFloat(*)(id, SEL))objc_msgSend)(receiver, s("backingScaleFactor"))
+
+#define ON_MAIN_THREAD(str) dispatch( ^{ str; } )
+#define MAIN_WINDOW_CALL(str) msg_reg(app->mainWindow, s((str)))
+
+#define NSBackingStoreBuffered 2
+
+#define NSWindowStyleMaskBorderless 0
+#define NSWindowStyleMaskTitled 1
+#define NSWindowStyleMaskClosable 2
+#define NSWindowStyleMaskMiniaturizable 4
+#define NSWindowStyleMaskResizable 8
+#define NSWindowStyleMaskFullscreen 1 << 14
+
+#define NSVisualEffectMaterialWindowBackground 12
+#define NSVisualEffectBlendingModeBehindWindow 0
+#define NSVisualEffectStateFollowsWindowActiveState 0
+#define NSVisualEffectStateActive 1
+#define NSVisualEffectStateInactive 2
+
+#define NSViewWidthSizable 2
+#define NSViewHeightSizable 16
+
+#define NSWindowBelow -1
+#define NSWindowAbove 1
+
+#define NSSquareStatusItemLength   -2.0
+#define NSVariableStatusItemLength -1.0
+
+#define NSWindowTitleHidden 1
+#define NSWindowStyleMaskFullSizeContentView 1 << 15
+
+#define NSEventModifierFlagCommand 1 << 20
+#define NSEventModifierFlagOption 1 << 19
+#define NSEventModifierFlagControl 1 << 18
+#define NSEventModifierFlagShift 1 << 17
+
+#define NSControlStateValueMixed -1
+#define NSControlStateValueOff 0
+#define NSControlStateValueOn 1
+
+#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
+#define NSEventMaskLeftMouseUp 1 << 2
+#define NSEventMaskRightMouseDown 1 << 3
+#define NSEventMaskRightMouseUp 1 << 4
+
+#define NSEventTypeLeftMouseDown 1
+#define NSEventTypeLeftMouseUp 2
+#define NSEventTypeRightMouseDown 3
+#define NSEventTypeRightMouseUp 4
+
+#define NSNoImage       0
+#define NSImageOnly     1
+#define NSImageLeft     2
+#define NSImageRight    3
+#define NSImageBelow    4
+#define NSImageAbove    5
+#define NSImageOverlaps 6
+
+#define NSAlertStyleWarning 0
+#define NSAlertStyleInformational 1
+#define NSAlertStyleCritical 2
+
+#define NSAlertFirstButtonReturn   1000
+#define NSAlertSecondButtonReturn  1001
+#define NSAlertThirdButtonReturn   1002
+
+#define BrokenImage "iVBORw0KGgoAAAANSUhEUgAAABAAAAASCAMAAABl5a5YAAABj1BMVEWopan///+koqSWk5P9/v3///////////+AgACMiovz8/PB0fG9z+3i4+WysbGBfX1Erh80rACLiYqBxolEsDhHlDEbqQDDx+CNho7W1tj4+/bw+O3P5Mn4/f/W1tbK6sX////b2dn////////////8/Pz6+vro6Ojj4+P////G1PL////EzNydmp2cmZnd3eDF1PHs8v/o8P/Q3vrS3vfE0vCdmpqZkpr19/3N2vXI1vPH1fOgnqDg6frP3PbCytvHx8irqq6HhIZtuGtjnlZetU1Xs0NWskBNsi7w9v/d6P7w9P3S4Pzr8Pvl7PrY5PrU4PjQ3fjD1Ozo6Om30NjGzNi7ubm34K+UxKmbnaWXlJeUjpSPi4tppF1TtjxSsTf2+f7L2PTr7e3H2+3V7+q+0uXg4OPg4eLR1uG7z+Hg4ODGzODV2N7V1trP5dmxzs65vcfFxMWq0cKxxr+/vr+0s7apxbWaxrCv2qao05+dlp2Uuo2Dn4F8vIB6xnyAoHmAym9zqGpctENLryNFsgoblJpnAAAAKnRSTlP+hP7+5ZRmYgL+/f39/f39/f38/Pz8/Pv69+7j083My8GocnBPTTMWEgjxeITOAAABEklEQVQY0y3KZXuCYBiG4ceYuu7u3nyVAaKOMBBQ7O5Yd3f3fvheDnd9u8/jBkGwNxP6sjOWVQvY/ftrzfT6bd3yEhCnYZqiaYoKiwX/gXkFiHySTcUTLJMsZ9v8nQvgssWYOEKedKpcOO6CUXD5IlGEY5hLUbyDAAZ6HRf1bnkoavOsFQibg+Q4nuNYL+ON5PHD5nBaraRVyxnzGf6BJzUi2QQCQgMyk8tleL7dg1owpJ17D5IkvV100EingeOopPyo6vfAuXF+9hbDTknZCIaUoeK4efKwG4iT6xDewd7imGlid7gGwv37b6Oh9jwaTdOf/Tc1qH7UZVmuP6G5qZfBr9cAGNy4KiDd4tXIs7tS+QO9aUKvPAIKuQAAAABJRU5ErkJggg=="
+
+struct Application;
+int releaseNSObject(void *const context, struct hashmap_element_s *const e);
+void TitlebarAppearsTransparent(struct Application* app);
+void HideTitle(struct Application* app);
+void HideTitleBar(struct Application* app);
+void FullSizeContent(struct Application* app);
+void UseToolbar(struct Application* app);
+void HideToolbarSeparator(struct Application* app);
+void DisableFrame(struct Application* app);
+void SetAppearance(struct Application* app, const char *);
+void WebviewIsTransparent(struct Application* app);
+void WindowBackgroundIsTranslucent(struct Application* app);
+void SetTray(struct Application* app, const char *, const char *, const char *);
+//void SetContextMenus(struct Application* app, const char *);
+void AddTrayMenu(struct Application* app, const char *);
+
+void SetActivationPolicy(struct Application* app, int policy);
+
+void* lookupStringConstant(id constantName);
+
+void HasURLHandlers(struct Application* app);
+
+id createImageFromBase64Data(const char *data, bool isTemplateImage);
 
 #endif

v2/internal/ffenestri/ffenestri_linux.c

@@ -2,6 +2,7 @@
 #ifndef __FFENESTRI_LINUX_H__
 #define __FFENESTRI_LINUX_H__
 
+#include "common.h"
 #include "gtk/gtk.h"
 #include "webkit2/webkit2.h"
 #include <time.h>
@@ -11,9 +12,10 @@
 #include <stdarg.h>
 
 // References to assets
-extern const unsigned char *assets[];
 extern const unsigned char runtime;
-extern const char *icon[];
+
+#include "icon.h"
+#include "assets.h"
 
 // Constants
 #define PRIMARY_MOUSE_BUTTON 1
@@ -23,17 +25,6 @@ extern const char *icon[];
 // MAIN DEBUG FLAG
 int debug;
 
-// Credit: https://stackoverflow.com/a/8465083
-char *concat(const char *s1, const char *s2)
-{
-    const size_t len1 = strlen(s1);
-    const size_t len2 = strlen(s2);
-    char *result = malloc(len1 + len2 + 1);
-    memcpy(result, s1, len1);
-    memcpy(result + len1, s2, len2 + 1);
-    return result;
-}
-
 // Debug works like sprintf but mutes if the global debug flag is true
 // Credit: https://stackoverflow.com/a/20639708
 void Debug(char *message, ...)
@@ -312,17 +303,17 @@ void SetMaxWindowSize(struct Application *app, int maxWidth, int maxHeight)
 }
 
 // SetColour sets the colour of the webview to the given colour string
-int SetColour(struct Application *app, const char *colourString)
+void SetColour(struct Application *app, int red, int green, int blue, int alpha)
 {
-    GdkRGBA rgba;
-    gboolean result = gdk_rgba_parse(&rgba, colourString);
-    if (result == FALSE)
-    {
-        return 0;
-    }
-    // Debug("Setting webview colour to: %s", colourString);
-    webkit_web_view_get_background_color((WebKitWebView *)(app->webView), &rgba);
-    return 1;
+//    GdkRGBA rgba;
+//    rgba.
+//    gboolean result = gdk_rgba_parse(&rgba, colourString);
+//    if (result == FALSE)
+//    {
+//        return 0;
+//    }
+//    // Debug("Setting webview colour to: %s", colourString);
+//    webkit_web_view_get_background_color((WebKitWebView *)(app->webView), &rgba);
 }
 
 // DisableFrame disables the window frame
@@ -523,6 +514,11 @@ static void load_finished_cb(WebKitWebView *webView,
         Debug("Binding Methods");
         syncEval(app, app->bindings);
 
+        // Setup IPC commands
+        Debug("Setting up IPC methods");
+        const char *invoke = "window.wailsInvoke=function(message){window.webkit.messageHandlers.external.postMessage(message);};window.wailsDrag=function(message){window.webkit.messageHandlers.windowDrag.postMessage(message);};window.wailsContextMenuMessage=function(message){window.webkit.messageHandlers.contextMenu.postMessage(message);};";
+        syncEval(app, invoke);
+
         // Runtime
         Debug("Setting up Wails runtime");
         syncEval(app, &runtime);
@@ -824,7 +820,7 @@ void Show(struct Application *app) {
 
 // maximiseInternal maximises the main window
 void maximiseInternal(struct Application *app) {
-    gtk_window_maximize(GTK_WIDGET(app->mainWindow));
+    gtk_window_maximize(GTK_WINDOW(app->mainWindow));
 }
 
 // Maximise places the maximiseInternal method onto the main thread for execution
@@ -841,7 +837,7 @@ void Maximise(struct Application *app) {
 
 // unmaximiseInternal unmaximises the main window
 void unmaximiseInternal(struct Application *app) {
-    gtk_window_unmaximize(GTK_WIDGET(app->mainWindow));
+    gtk_window_unmaximize(GTK_WINDOW(app->mainWindow));
 }
 
 // Unmaximise places the unmaximiseInternal method onto the main thread for execution
@@ -857,6 +853,21 @@ void Unmaximise(struct Application *app) {
 }
 
 
+void DarkModeEnabled(struct Application* app, char *callbackID) {}
+void SetApplicationMenu(struct Application* app, const char *menuJSON) {}
+void AddTrayMenu(struct Application* app, const char *menuTrayJSON) {}
+void SetTrayMenu(struct Application* app, const char *menuTrayJSON) {}
+void DeleteTrayMenuByID(struct Application* app, const char *id) {}
+void UpdateTrayMenuLabel(struct Application* app, const char* JSON) {}
+void AddContextMenu(struct Application* app, char *contextMenuJSON) {}
+void UpdateContextMenu(struct Application* app, char *contextMenuJSON) {}
+void WebviewIsTransparent(struct Application* app) {}
+void WindowBackgroundIsTranslucent(struct Application* app) {}
+void OpenDialog(struct Application* app, char *callbackID, char *title, char *filters, char *defaultFilename, char *defaultDir, int allowFiles, int allowDirs, int allowMultiple, int showHiddenFiles, int canCreateDirectories, int resolvesAliases, int treatPackagesAsDirectories) {}
+void SaveDialog(struct Application* app, char *callbackID, char *title, char *filters, char *defaultFilename, char *defaultDir, int showHiddenFiles, int canCreateDirectories, int treatPackagesAsDirectories) {}
+void MessageDialog(struct Application* app, char *callbackID, char *type, char *title, char *message, char *icon, char *button1, char *button2, char *button3, char *button4, char *defaultButton, char *cancelButton) {}
+
+
 // minimiseInternal minimises the main window
 void minimiseInternal(struct Application *app) {
     gtk_window_iconify(app->mainWindow);

v2/internal/ffenestri/ffenestri_linux.go

@@ -0,0 +1,17 @@
+package ffenestri
+
+/*
+#cgo linux CFLAGS: -DFFENESTRI_LINUX=1
+#cgo linux pkg-config: gtk+-3.0 webkit2gtk-4.0
+
+
+#include "ffenestri.h"
+#include "ffenestri_linux.h"
+
+*/
+import "C"
+
+func (a *Application) processPlatformSettings() error {
+
+	return nil
+}

v2/internal/ffenestri/ffenestri_linux.h

@@ -0,0 +1,6 @@
+
+#ifndef FFENESTRI_LINUX_H
+#define FFENESTRI_LINUX_H
+
+
+#endif

v2/internal/ffenestri/ffenestri_windows.cpp

@@ -0,0 +1,622 @@
+// Some code may be inspired by or directly used from Webview (c) zserge.
+// License included in README.md
+
+#include "ffenestri_windows.h"
+#include "wv2ComHandler_windows.h"
+#include <functional>
+#include <atomic>
+#include <Shlwapi.h>
+#include <locale>
+#include <codecvt>
+#include "windows/WebView2.h"
+#include "effectstructs_windows.h"
+#include <Shlobj.h>
+
+int debug = 0;
+DWORD mainThread;
+
+// --- Assets
+extern const unsigned char runtime;
+extern const unsigned char *defaultDialogIcons[];
+
+// dispatch will execute the given `func` pointer
+void dispatch(dispatchFunction func) {
+    PostThreadMessage(mainThread, WM_APP, 0, (LPARAM) new dispatchFunction(func));
+}
+
+LPWSTR cstrToLPWSTR(const char *cstr) {
+    int wchars_num = MultiByteToWideChar( CP_UTF8 , 0 , cstr , -1, NULL , 0 );
+    wchar_t* wstr = new wchar_t[wchars_num+1];
+    MultiByteToWideChar( CP_UTF8 , 0 , cstr , -1, wstr , wchars_num );
+    return wstr;
+}
+
+// Credit: https://stackoverflow.com/a/9842450
+char* LPWSTRToCstr(LPWSTR input) {
+    int length = WideCharToMultiByte(CP_UTF8, 0, input, -1, 0, 0, NULL, NULL);
+    char* output = new char[length];
+    WideCharToMultiByte(CP_UTF8, 0, input, -1, output , length, NULL, NULL);
+    return output;
+}
+
+struct Application *NewApplication(const char *title, int width, int height, int resizable, int devtools, int fullscreen, int startHidden, int logLevel, int hideWindowOnClose) {
+
+    // Create application
+    struct Application *result = (struct Application*)malloc(sizeof(struct Application));
+
+    result->window = nullptr;
+    result->webview = nullptr;
+    result->webviewController = nullptr;
+
+    result->title = title;
+    result->width = width;
+    result->height = height;
+    result->resizable = resizable;
+    result->devtools = devtools;
+    result->fullscreen = fullscreen;
+    result->startHidden = startHidden;
+    result->logLevel = logLevel;
+    result->hideWindowOnClose = hideWindowOnClose;
+    result->webviewIsTranparent = false;
+    result->windowBackgroundIsTranslucent = false;
+
+    // Min/Max Width/Height
+    result->minWidth = 0;
+    result->minHeight = 0;
+    result->maxWidth = 0;
+    result->maxHeight = 0;
+
+    // Default colour
+    result->backgroundColour.R = 255;
+    result->backgroundColour.G = 255;
+    result->backgroundColour.B = 255;
+    result->backgroundColour.A = 255;
+
+    // Have a frame by default
+    result->frame = 1;
+
+    // Capture Main Thread
+    mainThread = GetCurrentThreadId();
+
+    // Startup url
+    result->startupURL = nullptr;
+
+    return result;
+}
+
+void SetMinWindowSize(struct Application* app, int minWidth, int minHeight) {
+    app->minWidth = (LONG)minWidth;
+    app->minHeight = (LONG)minHeight;
+}
+
+void SetMaxWindowSize(struct Application* app, int maxWidth, int maxHeight) {
+    app->maxWidth = (LONG)maxWidth;
+    app->maxHeight = (LONG)maxHeight;
+}
+
+void SetBindings(struct Application *app, const char *bindings) {
+    std::string temp = std::string("window.wailsbindings = \"") + std::string(bindings) + std::string("\";");
+    app->bindings = new char[temp.length()+1];
+	memcpy(app->bindings, temp.c_str(), temp.length()+1);
+}
+
+void performShutdown(struct Application *app) {
+    if( app->startupURL != nullptr ) {
+        delete[] app->startupURL;
+    }
+    messageFromWindowCallback("WC");
+}
+
+void enableTranslucentBackground(struct Application *app) {
+    HMODULE hUser = GetModuleHandleA("user32.dll");
+    if (hUser)
+    {
+        pfnSetWindowCompositionAttribute setWindowCompositionAttribute = (pfnSetWindowCompositionAttribute)GetProcAddress(hUser, "SetWindowCompositionAttribute");
+        if (setWindowCompositionAttribute)
+        {
+            ACCENT_POLICY accent = { ACCENT_ENABLE_BLURBEHIND, 0, 0, 0 };
+            WINDOWCOMPOSITIONATTRIBDATA data;
+            data.Attrib = WCA_ACCENT_POLICY;
+            data.pvData = &accent;
+            data.cbData = sizeof(accent);
+            setWindowCompositionAttribute(app->window, &data);
+        }
+    }
+}
+
+LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
+
+    struct Application *app = (struct Application *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
+
+    switch(msg) {
+
+        case WM_DESTROY: {
+            DestroyApplication(app);
+            break;
+        }
+        case WM_SIZE: {
+            if( app->webviewController != nullptr) {
+                RECT bounds;
+                GetClientRect(app->window, &bounds);
+                app->webviewController->put_Bounds(bounds);
+            }
+            break;
+        }
+        case WM_GETMINMAXINFO: {
+            // Exit early if this is called before the window is created.
+            if ( app == NULL ) {
+                return 0;
+            }
+
+            // get pixel density
+            HDC hDC = GetDC(NULL);
+            double DPIScaleX = GetDeviceCaps(hDC, 88)/96.0;
+            double DPIScaleY = GetDeviceCaps(hDC, 90)/96.0;
+            ReleaseDC(NULL, hDC);
+
+            RECT rcClient, rcWind;
+            POINT ptDiff;
+            GetClientRect(hwnd, &rcClient);
+            GetWindowRect(hwnd, &rcWind);
+
+            int widthExtra = (rcWind.right - rcWind.left) - rcClient.right;
+            int heightExtra = (rcWind.bottom - rcWind.top) - rcClient.bottom;
+
+            LPMINMAXINFO mmi = (LPMINMAXINFO) lParam;
+            if (app->minWidth > 0 && app->minHeight > 0) {
+                mmi->ptMinTrackSize.x = app->minWidth * DPIScaleX + widthExtra;
+                mmi->ptMinTrackSize.y = app->minHeight * DPIScaleY + heightExtra;
+            }
+            if (app->maxWidth > 0 && app->maxHeight > 0) {
+                mmi->ptMaxSize.x = app->maxWidth * DPIScaleX + widthExtra;
+                mmi->ptMaxSize.y = app->maxHeight * DPIScaleY + heightExtra;
+                mmi->ptMaxTrackSize.x = app->maxWidth * DPIScaleX + widthExtra;
+                mmi->ptMaxTrackSize.y = app->maxHeight * DPIScaleY + heightExtra;
+            }
+            return 0;
+        }
+        default:
+            return DefWindowProc(hwnd, msg, wParam, lParam);
+    }
+    return 0;
+}
+
+void init(struct Application *app, const char* js) {
+    LPCWSTR wjs = cstrToLPWSTR(js);
+    app->webview->AddScriptToExecuteOnDocumentCreated(wjs, nullptr);
+    delete[] wjs;
+}
+
+void execJS(struct Application* app, const char *script) {
+    LPWSTR s = cstrToLPWSTR(script);
+    app->webview->ExecuteScript(s, nullptr);
+    delete[] s;
+}
+
+void loadAssets(struct Application* app) {
+
+    // setup window.wailsInvoke
+    std::string initialCode = std::string("window.wailsInvoke=function(m){window.chrome.webview.postMessage(m)};");
+
+    // Load bindings
+    initialCode += std::string(app->bindings);
+    delete[] app->bindings;
+
+    // Load runtime
+    initialCode += std::string((const char*)&runtime);
+
+    int index = 1;
+    while(1) {
+        // Get next asset pointer
+        const unsigned char *asset = assets[index];
+
+        // If we have no more assets, break
+        if (asset == 0x00) {
+            break;
+        }
+
+        initialCode += std::string((const char*)asset);
+        index++;
+    };
+
+    // Disable context menu if not in debug mode
+    if( debug != 1 ) {
+        initialCode += std::string("wails._.DisableDefaultContextMenu();");
+    }
+
+    initialCode += std::string("window.wailsInvoke('completed');");
+
+    // Keep a copy of the code
+    app->initialCode = new char[initialCode.length()+1];
+	memcpy(app->initialCode, initialCode.c_str(), initialCode.length()+1);
+
+    execJS(app, app->initialCode);
+
+    // Show app if we need to
+    if( app->startHidden == false ) {
+        Show(app);
+    }
+}
+
+// This is called when all our assets are loaded into the DOM
+void completed(struct Application* app) {
+    delete[] app->initialCode;
+    app->initialCode = nullptr;
+
+    if( app->startupURL == nullptr ) {
+        messageFromWindowCallback("SS");
+        return;
+    }
+    std::string readyMessage = std::string("SS") + std::string(app->startupURL);
+    messageFromWindowCallback(readyMessage.c_str());
+}
+
+
+//
+bool initWebView2(struct Application *app, int debugEnabled, messageCallback cb) {
+
+    debug = debugEnabled;
+
+    CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED);
+
+    std::atomic_flag flag = ATOMIC_FLAG_INIT;
+    flag.test_and_set();
+
+//    char currentExePath[MAX_PATH];
+//    GetModuleFileNameA(NULL, currentExePath, MAX_PATH);
+//    char *currentExeName = PathFindFileNameA(currentExePath);
+//    std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> wideCharConverter;
+//    auto exeName = wideCharConverter.from_bytes(currentExeName);
+//
+//    PWSTR path;
+//    HRESULT appDataResult = SHGetFolderPathAndSubDir(app->window, CSIDL_LOCAL_APPDATA, nullptr, SHGFP_TYPE_CURRENT, exeName.c_str(), path);
+//    if ( appDataResult == false ) {
+//        path = nullptr;
+//    }
+//
+
+    ICoreWebView2Controller *controller;
+    ICoreWebView2* webview;
+
+    HRESULT res = CreateCoreWebView2EnvironmentWithOptions(
+            nullptr, nullptr, nullptr,
+            new wv2ComHandler(app, app->window, cb,
+                                     [&](ICoreWebView2Controller *webviewController) {
+                                         controller = webviewController;
+                                         controller->get_CoreWebView2(&webview);
+                                         webview->AddRef();
+                                         flag.clear();
+                                     }));
+    if (res != S_OK) {
+        CoUninitialize();
+        return false;
+    }
+
+    MSG msg = {};
+    while (flag.test_and_set() && GetMessage(&msg, NULL, 0, 0)) {
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+    }
+    app->webviewController = controller;
+    app->webview = webview;
+    // Resize WebView to fit the bounds of the parent window
+    RECT bounds;
+    GetClientRect(app->window, &bounds);
+    app->webviewController->put_Bounds(bounds);
+
+    // Let the backend know we have initialised
+    app->webview->AddScriptToExecuteOnDocumentCreated(L"window.chrome.webview.postMessage('initialised');", nullptr);
+    // Load the HTML
+    LPCWSTR html = (LPCWSTR) cstrToLPWSTR((char*)assets[0]);
+    app->webview->Navigate(html);
+
+	messageFromWindowCallback("Ej{\"name\":\"wails:launched\",\"data\":[]}");
+    return true;
+}
+
+void initialCallback(std::string message) {
+    printf("MESSAGE=%s\n", message);
+}
+
+void Run(struct Application* app, int argc, char **argv) {
+
+    WNDCLASSEX wc;
+    HINSTANCE hInstance = GetModuleHandle(NULL);
+    ZeroMemory(&wc, sizeof(WNDCLASSEX));
+    wc.cbSize = sizeof(WNDCLASSEX);
+    wc.style = CS_HREDRAW | CS_VREDRAW;
+    wc.hInstance = hInstance;
+    wc.lpszClassName = (LPCWSTR)"ffenestri";
+    wc.lpfnWndProc   = WndProc;
+    wc.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(100));
+    wc.hIconSm = LoadIcon(hInstance, MAKEINTRESOURCE(100));
+
+    // TODO: Menu
+//    wc.lpszMenuName = nullptr;
+
+
+    // Process window resizable
+    DWORD windowStyle = WS_OVERLAPPEDWINDOW;
+    if (app->resizable == 0) {
+        windowStyle &= ~WS_MAXIMIZEBOX;
+        windowStyle &= ~WS_THICKFRAME;
+    }
+    if ( app->frame == 0 ) {
+        windowStyle = WS_POPUP;
+    }
+
+    RegisterClassEx(&wc);
+    app->window = CreateWindow((LPCWSTR)"ffenestri", (LPCWSTR)"", windowStyle, CW_USEDEFAULT,
+                                CW_USEDEFAULT, app->width, app->height, NULL, NULL,
+                                hInstance, NULL);
+
+    // Private setTitle as we're on the main thread
+    setTitle(app, app->title);
+
+    // Store application pointer in window handle
+    SetWindowLongPtr(app->window, GWLP_USERDATA, (LONG_PTR)app);
+
+    // Process whether window should show by default
+    int startVisibility = SW_SHOWNORMAL;
+    if ( app->startHidden == 1 ) {
+        startVisibility = SW_HIDE;
+    }
+
+    // TODO: Make configurable
+//    COREWEBVIEW2_COLOR wvColor;
+//    wvColor.A = 255;
+//    std::weak_ptr<ICoreWebView2Controller2> controller2 = app->webviewController->query<ICoreWebView2Controller2>();
+//    controller2->put_DefaultBackgroundColor(wvColor);
+
+    if( app->windowBackgroundIsTranslucent ) {
+        enableTranslucentBackground(app);
+    }
+
+    // private center() as we are on main thread
+    center(app);
+    ShowWindow(app->window, startVisibility);
+    UpdateWindow(app->window);
+    SetFocus(app->window);
+
+    // Add webview2
+    initWebView2(app, 1, initialCallback);
+
+    // Main event loop
+    MSG  msg;
+    BOOL res;
+    while ((res = GetMessage(&msg, NULL, 0, 0)) != -1) {
+      if (msg.hwnd) {
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+        continue;
+      }
+      if (msg.message == WM_APP) {
+          dispatchFunction *f = (dispatchFunction*) msg.lParam;
+          (*f)();
+          delete(f);
+      } else if (msg.message == WM_QUIT) {
+        performShutdown(app);
+        return;
+      }
+    }
+}
+
+void DestroyApplication(struct Application* app) {
+    PostQuitMessage(0);
+}
+void SetDebug(struct Application* app, int flag) {
+    debug = flag;
+}
+
+void ExecJS(struct Application* app, const char *script) {
+    ON_MAIN_THREAD(
+        execJS(app, script);
+    );
+}
+
+void hide(struct Application* app) {
+    ShowWindow(app->window, SW_HIDE);
+}
+
+void Hide(struct Application* app) {
+    ON_MAIN_THREAD(
+        hide(app);
+    );
+}
+
+void show(struct Application* app) {
+    ShowWindow(app->window, SW_SHOW);
+}
+
+void Show(struct Application* app) {
+    ON_MAIN_THREAD(
+        show(app);
+    );
+}
+
+void center(struct Application* app) {
+
+    HMONITOR currentMonitor = MonitorFromWindow(app->window, MONITOR_DEFAULTTONEAREST);
+    MONITORINFO info = {0};
+    info.cbSize = sizeof(info);
+    GetMonitorInfoA(currentMonitor, &info);
+    RECT workRect = info.rcWork;
+    LONG screenMiddleW = (workRect.right - workRect.left) / 2;
+    LONG screenMiddleH = (workRect.bottom - workRect.top) / 2;
+    RECT winRect;
+    if (app->frame == 1) {
+        GetWindowRect(app->window, &winRect);
+    } else {
+        GetClientRect(app->window, &winRect);
+    }
+    LONG winWidth = winRect.right - winRect.left;
+    LONG winHeight = winRect.bottom - winRect.top;
+
+    LONG windowX = screenMiddleW - (winWidth / 2);
+    LONG windowY = screenMiddleH - (winHeight / 2);
+
+    SetWindowPos(app->window, HWND_TOP, windowX, windowY, winWidth, winHeight, SWP_NOSIZE);
+}
+
+void Center(struct Application* app) {
+    ON_MAIN_THREAD(
+        center(app);
+    );
+}
+
+UINT getWindowPlacement(struct Application* app) {
+    WINDOWPLACEMENT lpwndpl;
+    lpwndpl.length = sizeof(WINDOWPLACEMENT);
+    BOOL result = GetWindowPlacement(app->window, &lpwndpl);
+    if( result == 0 ) {
+        // TODO: Work out what this call failing means
+        return -1;
+    }
+    return lpwndpl.showCmd;
+}
+
+int isMaximised(struct Application* app) {
+    return getWindowPlacement(app) == SW_SHOWMAXIMIZED;
+}
+
+void maximise(struct Application* app) {
+    ShowWindow(app->window, SW_MAXIMIZE);
+}
+
+void Maximise(struct Application* app) {
+    ON_MAIN_THREAD(
+        maximise(app);
+    );
+}
+
+void unmaximise(struct Application* app) {
+    ShowWindow(app->window, SW_RESTORE);
+}
+
+void Unmaximise(struct Application* app) {
+    ON_MAIN_THREAD(
+        unmaximise(app);
+    );
+}
+
+
+void ToggleMaximise(struct Application* app) {
+    if(isMaximised(app)) {
+        return Unmaximise(app);
+    }
+    return Maximise(app);
+}
+
+int isMinimised(struct Application* app) {
+    return getWindowPlacement(app) == SW_SHOWMINIMIZED;
+}
+
+void minimise(struct Application* app) {
+    ShowWindow(app->window, SW_MINIMIZE);
+}
+
+void Minimise(struct Application* app) {
+    ON_MAIN_THREAD(
+        minimise(app);
+    );
+}
+
+void unminimise(struct Application* app) {
+    ShowWindow(app->window, SW_RESTORE);
+}
+
+void Unminimise(struct Application* app) {
+    ON_MAIN_THREAD(
+        unminimise(app);
+    );
+}
+
+void ToggleMinimise(struct Application* app) {
+    if(isMinimised(app)) {
+        return Unminimise(app);
+    }
+    return Minimise(app);
+}
+
+void SetColour(struct Application* app, int red, int green, int blue, int alpha) {
+// TBD
+}
+
+void SetSize(struct Application* app, int width, int height) {
+    // TBD
+}
+
+void setPosition(struct Application* app, int x, int y) {
+    // TBD
+}
+
+void SetPosition(struct Application* app, int x, int y) {
+//    ON_MAIN_THREAD(
+//        setPosition(app, x, y);
+//    );
+}
+
+void Quit(struct Application* app) {
+    DestroyWindow(app->window);
+}
+
+
+// Credit: https://stackoverflow.com/a/6693107
+void setTitle(struct Application* app, const char *title) {
+    LPCTSTR text = cstrToLPWSTR(title);
+    SetWindowText(app->window, text);
+    delete[] text;
+}
+
+void SetTitle(struct Application* app, const char *title) {
+    ON_MAIN_THREAD(
+        setTitle(app, title);
+    );
+}
+
+void Fullscreen(struct Application* app) {
+}
+
+void UnFullscreen(struct Application* app) {
+}
+
+void ToggleFullscreen(struct Application* app) {
+}
+
+void DisableFrame(struct Application* app) {
+    app->frame = 0;
+}
+
+// WebviewIsTransparent will make the webview transparent
+// revealing the window underneath
+void WebviewIsTransparent(struct Application *app) {
+	app->webviewIsTranparent = true;
+}
+
+void WindowBackgroundIsTranslucent(struct Application *app) {
+	app->windowBackgroundIsTranslucent = true;
+}
+
+
+void OpenDialog(struct Application* app, char *callbackID, char *title, char *filters, char *defaultFilename, char *defaultDir, int allowFiles, int allowDirs, int allowMultiple, int showHiddenFiles, int canCreateDirectories, int resolvesAliases, int treatPackagesAsDirectories) {
+}
+void SaveDialog(struct Application* app, char *callbackID, char *title, char *filters, char *defaultFilename, char *defaultDir, int showHiddenFiles, int canCreateDirectories, int treatPackagesAsDirectories) {
+}
+void MessageDialog(struct Application* app, char *callbackID, char *type, char *title, char *message, char *icon, char *button1, char *button2, char *button3, char *button4, char *defaultButton, char *cancelButton) {
+}
+void DarkModeEnabled(struct Application* app, char *callbackID) {
+}
+void SetApplicationMenu(struct Application* app, const char *applicationMenuJSON) {
+}
+void AddTrayMenu(struct Application* app, const char *menuTrayJSON) {
+}
+void SetTrayMenu(struct Application* app, const char *menuTrayJSON) {
+}
+void DeleteTrayMenuByID(struct Application* app, const char *id) {
+}
+void UpdateTrayMenuLabel(struct Application* app, const char* JSON) {
+}
+void AddContextMenu(struct Application* app, char *contextMenuJSON) {
+}
+void UpdateContextMenu(struct Application* app, char *contextMenuJSON) {
+}

v2/internal/ffenestri/ffenestri_windows.go

@@ -0,0 +1,66 @@
+package ffenestri
+
+import "C"
+
+/*
+
+#cgo windows CXXFLAGS: -std=c++11
+#cgo windows,amd64 LDFLAGS: -L./windows/x64 -lwebview -lWebView2Loader -lgdi32 -lole32 -lShlwapi -luser32 -loleaut32
+
+#include "ffenestri.h"
+
+*/
+import "C"
+
+func (a *Application) processPlatformSettings() error {
+
+	config := a.config.Windows
+	if config == nil {
+		return nil
+	}
+
+	// Check if the webview should be transparent
+	if config.WebviewIsTransparent {
+		C.WebviewIsTransparent(a.app)
+	}
+
+	if config.WindowBackgroundIsTranslucent {
+		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 tray
+	//trays, err := a.menuManager.GetTrayMenus()
+	//if err != nil {
+	//	return err
+	//}
+	//if trays != nil {
+	//	for _, tray := range trays {
+	//		C.AddTrayMenu(a.app, a.string2CString(tray))
+	//	}
+	//}
+	//
+	//// 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)
+	//}
+
+	return nil
+}

v2/internal/ffenestri/ffenestri_windows.h

@@ -0,0 +1,75 @@
+
+#ifndef _FFENESTRI_WINDOWS_H
+#define _FFENESTRI_WINDOWS_H
+
+#define WIN32_LEAN_AND_MEAN
+#define UNICODE 1
+
+#include "ffenestri.h"
+#include <windows.h>
+#include <wingdi.h>
+#include <functional>
+#include <codecvt>
+#include "windows/WebView2.h"
+
+#include "assets.h"
+
+// TODO:
+//#include "userdialogicons.h"
+
+
+struct Application{
+    // Window specific
+    HWND window;
+    ICoreWebView2 *webview;
+    ICoreWebView2Controller* webviewController;
+
+    // Application
+    const char *title;
+    int width;
+    int height;
+    int resizable;
+    int devtools;
+    int fullscreen;
+    int startHidden;
+    int logLevel;
+    int hideWindowOnClose;
+    int minSizeSet;
+    LONG minWidth;
+    LONG minHeight;
+    int maxSizeSet;
+    LONG maxWidth;
+    LONG maxHeight;
+    int frame;
+    char *startupURL;
+    bool webviewIsTranparent;
+    bool windowBackgroundIsTranslucent;
+    COREWEBVIEW2_COLOR backgroundColour;
+
+    // placeholders
+    char* bindings;
+    char* initialCode;
+};
+
+#define ON_MAIN_THREAD(code) dispatch( [=]{ code; } )
+
+typedef std::function<void()> dispatchFunction;
+typedef std::function<void(const std::string)> messageCallback;
+typedef std::function<void(ICoreWebView2Controller *)> comHandlerCallback;
+
+void center(struct Application*);
+void setTitle(struct Application* app, const char *title);
+char* LPWSTRToCstr(LPWSTR input);
+
+// called when the DOM is ready
+void loadAssets(struct Application* app);
+
+// called when the application assets have been loaded into the DOM
+void completed(struct Application* app);
+
+// Callback
+extern "C" {
+    void messageFromWindowCallback(const char *);
+}
+
+#endif

v2/internal/ffenestri/json.c

@@ -1,3 +1,5 @@
+// +build !windows
+
 /*
   Copyright (C) 2011 Joseph A. Adams (joeyadams3.14159@gmail.com)
   All rights reserved.

v2/internal/ffenestri/menu.go

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

v2/internal/ffenestri/menu_darwin.h

@@ -0,0 +1,117 @@
+//
+// 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",
+};
+
+typedef struct _NSRange {
+    unsigned long location;
+    unsigned long length;
+} NSRange;
+
+#define NSFontWeightUltraLight -0.8
+#define NSFontWeightThin -0.6
+#define NSFontWeightLight -0.4
+#define NSFontWeightRegular 0.0
+#define NSFontWeightMedium 0.23
+#define NSFontWeightSemibold 0.3
+#define NSFontWeightBold 0.4
+#define NSFontWeightHeavy 0.56
+#define NSFontWeightBlack 0.62
+
+extern void messageFromWindowCallback(const char *);
+
+typedef struct {
+
+    const char *title;
+
+    /*** Internal ***/
+
+    // The decoded version of the Menu JSON
+    JsonNode *processedMenu;
+
+    struct hashmap_s menuItemMap;
+    struct hashmap_s radioGroupMap;
+
+    // Vector to keep track of callback data memory
+    vec_void_t callbackDataCache;
+
+    // The NSMenu for this menu
+    id menu;
+
+    // The parent data, eg ContextMenuStore or Tray
+    void *parentData;
+
+    // The commands for the menu callbacks
+    const char *callbackCommand;
+
+    // This indicates if we are an Application Menu, tray menu or context menu
+    enum MenuType menuType;
+
+
+} Menu;
+
+
+typedef struct {
+    id menuItem;
+    Menu *menu;
+    const char *menuID;
+    enum MenuItemType menuItemType;
+} MenuItemCallbackData;
+
+
+
+// NewMenu creates a new Menu struct, saving the given menu structure as JSON
+Menu* NewMenu(JsonNode *menuData);
+
+Menu* NewApplicationMenu(const char *menuAsJSON);
+MenuItemCallbackData* CreateMenuItemCallbackData(Menu *menu, id menuItem, const char *menuID, enum MenuItemType menuItemType);
+
+void DeleteMenu(Menu *menu);
+
+// Creates a JSON message for the given menuItemID and data
+const char* createMenuClickedMessage(const char *menuItemID, const char *data, enum MenuType menuType, const char *parentID);
+// Callback for text menu items
+void menuItemCallback(id self, SEL cmd, id sender);
+id processAcceleratorKey(const char *key);
+
+
+void addSeparator(id menu);
+id createMenuItemNoAutorelease( id title, const char *action, const char *key);
+
+id createMenuItem(id title, const char *action, const char *key);
+
+id addMenuItem(id menu, const char *title, const char *action, const char *key, bool disabled);
+
+id createMenu(id title);
+void createDefaultAppMenu(id parentMenu);
+void createDefaultEditMenu(id parentMenu);
+
+void processMenuRole(Menu *menu, id parentMenu, JsonNode *item);
+// This converts a string array of modifiers into the
+// equivalent MacOS Modifier Flags
+unsigned long parseModifiers(const char **modifiers);
+id processRadioMenuItem(Menu *menu, id parentmenu, const char *title, const char *menuid, bool disabled, bool checked, const char *acceleratorkey);
+
+id processCheckboxMenuItem(Menu *menu, id parentmenu, const char *title, const char *menuid, bool disabled, bool checked, const char *key);
+
+id processTextMenuItem(Menu *menu, id parentMenu, const char *title, const char *menuid, bool disabled, const char *acceleratorkey, const char **modifiers, const char* tooltip, const char* image, const char* fontName, int fontSize, const char* RGBA, bool templateImage, bool alternate, JsonNode* styledLabel);
+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);
+id createAttributedStringFromStyledLabel(JsonNode *styledLabel, const char* fontName, int fontSize);
+
+#endif //ASSETS_C_MENU_DARWIN_H

v2/internal/ffenestri/traymenu_darwin.c

@@ -0,0 +1,248 @@
+//
+// Created by Lea Anthony on 12/1/21.
+//
+
+#include "common.h"
+#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* result = malloc(sizeof(TrayMenu));
+
+/*
+ {"ID":"0","Label":"Test Tray Label","Icon":"","ProcessedMenu":{"Menu":{"Items":[{"ID":"0","Label":"Show Window","Type":"Text","Disabled":false,"Hidden":false,"Checked":false,"Foreground":0,"Background":0},{"ID":"1","Label":"Hide Window","Type":"Text","Disabled":false,"Hidden":false,"Checked":false,"Foreground":0,"Background":0},{"ID":"2","Label":"Minimise Window","Type":"Text","Disabled":false,"Hidden":false,"Checked":false,"Foreground":0,"Background":0},{"ID":"3","Label":"Unminimise Window","Type":"Text","Disabled":false,"Hidden":false,"Checked":false,"Foreground":0,"Background":0}]},"RadioGroups":null}}
+*/
+    JsonNode* processedJSON = json_decode(menuJSON);
+    if( processedJSON == NULL ) {
+        ABORT("[NewTrayMenu] Unable to parse TrayMenu JSON: %s", menuJSON);
+    }
+
+    // Save reference to this json
+    result->processedJSON = processedJSON;
+
+    // TODO: Make this configurable
+    result->trayIconPosition = NSImageLeft;
+
+    result->ID = mustJSONString(processedJSON, "ID");
+    result->label = mustJSONString(processedJSON, "Label");
+    result->icon = mustJSONString(processedJSON, "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->styledLabel = getJSONObject(processedJSON, "StyledLabel");
+
+    // Create the menu
+    JsonNode* processedMenu = mustJSONObject(processedJSON, "ProcessedMenu");
+    result->menu = NewMenu(processedMenu);
+
+    result->delegate = NULL;
+
+    // Init tray status bar item
+    result->statusbaritem = NULL;
+
+    // Set the menu type and store the tray ID in the parent data
+    result->menu->menuType = TrayMenuType;
+    result->menu->parentData = (void*) result->ID;
+
+    return result;
+}
+
+void DumpTrayMenu(TrayMenu* trayMenu) {
+    printf("    ['%s':%p] = { label: '%s', icon: '%s', menu: %p, statusbar: %p  }\n", trayMenu->ID, trayMenu, trayMenu->label, trayMenu->icon, trayMenu->menu, trayMenu->statusbaritem );
+}
+
+
+void UpdateTrayLabel(TrayMenu *trayMenu, const char *label, const char *fontName, int fontSize, const char *RGBA, const char *tooltip, bool disabled, JsonNode *styledLabel) {
+
+    // Exit early if NULL
+    if( trayMenu->label == NULL ) {
+        return;
+    }
+    // Update button label
+    id statusBarButton = msg_reg(trayMenu->statusbaritem, s("button"));
+    id attributedString = NULL;
+    if( styledLabel != NULL) {
+        attributedString = createAttributedStringFromStyledLabel(styledLabel, fontName, fontSize);
+    } else {
+        attributedString = createAttributedString(label, fontName, fontSize, RGBA);
+    }
+
+    if( tooltip != NULL ) {
+        msg_id(statusBarButton, s("setToolTip:"), str(tooltip));
+    }
+
+    msg_bool(statusBarButton, s("setEnabled:"), !disabled);
+
+    msg_id(statusBarButton, s("setAttributedTitle:"), attributedString);
+}
+
+void UpdateTrayIcon(TrayMenu *trayMenu) {
+
+    // Exit early if NULL
+    if( trayMenu->icon == NULL ) {
+        return;
+    }
+
+    id statusBarButton = msg_reg(trayMenu->statusbaritem, s("button"));
+
+    // Empty icon means remove it
+    if( STREMPTY(trayMenu->icon) ) {
+        // Remove image
+        msg_id(statusBarButton, s("setImage:"), NULL);
+        return;
+    }
+
+    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) {
+        trayImage = createImageFromBase64Data(trayMenu->icon, trayMenu->templateImage);
+    }
+
+    msg_int(statusBarButton, s("setImagePosition:"), trayMenu->trayIconPosition);
+    msg_id(statusBarButton, s("setImage:"), trayImage);
+
+}
+
+void ShowTrayMenu(TrayMenu* trayMenu) {
+
+    // Create a status bar item if we don't have one
+    if( trayMenu->statusbaritem == NULL ) {
+        id statusBar = msg_reg( c("NSStatusBar"), s("systemStatusBar") );
+        trayMenu->statusbaritem = ((id(*)(id, SEL, CGFloat))objc_msgSend)(statusBar, s("statusItemWithLength:"), NSVariableStatusItemLength);
+        msg_reg(trayMenu->statusbaritem, s("retain"));
+    }
+
+    id statusBarButton = msg_reg(trayMenu->statusbaritem, s("button"));
+    msg_uint(statusBarButton, s("setImagePosition:"), trayMenu->trayIconPosition);
+    // Update the icon if needed
+    UpdateTrayIcon(trayMenu);
+
+    // Update the label if needed
+    UpdateTrayLabel(trayMenu, trayMenu->label, trayMenu->fontName, trayMenu->fontSize, trayMenu->RGBA, trayMenu->tooltip, trayMenu->disabled, trayMenu->styledLabel);
+
+    // Update the menu
+    id menu = GetMenu(trayMenu->menu);
+    objc_setAssociatedObject(menu, "trayMenuID", str(trayMenu->ID), OBJC_ASSOCIATION_ASSIGN);
+
+	// Create delegate
+	id trayMenuDelegate = msg_reg((id)trayMenuDelegateClass, s("new"));
+	msg_id(menu, s("setDelegate:"), trayMenuDelegate);
+    objc_setAssociatedObject(trayMenuDelegate, "menu", menu, OBJC_ASSOCIATION_ASSIGN);
+
+    // Create menu delegate
+    trayMenu->delegate = trayMenuDelegate;
+
+    msg_id(trayMenu->statusbaritem, s("setMenu:"), menu);
+}
+
+// UpdateTrayMenuInPlace receives 2 menus. The current menu gets
+// updated with the data from the new menu.
+void UpdateTrayMenuInPlace(TrayMenu* currentMenu, TrayMenu* newMenu) {
+
+    // Delete the old menu
+    DeleteMenu(currentMenu->menu);
+
+    // Set the new one
+    currentMenu->menu = newMenu->menu;
+
+    // Delete the old JSON
+    json_delete(currentMenu->processedJSON);
+
+    // Set the new JSON
+    currentMenu->processedJSON = newMenu->processedJSON;
+
+    // Copy the other data
+    currentMenu->ID = newMenu->ID;
+    currentMenu->label = newMenu->label;
+    currentMenu->styledLabel = newMenu->styledLabel;
+    currentMenu->trayIconPosition = newMenu->trayIconPosition;
+    currentMenu->icon = newMenu->icon;
+
+}
+
+void DeleteTrayMenu(TrayMenu* trayMenu) {
+
+//    printf("Freeing TrayMenu:\n");
+//    DumpTrayMenu(trayMenu);
+
+    // Delete the menu
+    DeleteMenu(trayMenu->menu);
+
+    // Free JSON
+    if (trayMenu->processedJSON != NULL ) {
+        json_delete(trayMenu->processedJSON);
+    }
+
+    // Free the status item
+    if ( trayMenu->statusbaritem != NULL ) {
+        id statusBar = msg_reg( c("NSStatusBar"), s("systemStatusBar") );
+        msg_id(statusBar, s("removeStatusItem:"), trayMenu->statusbaritem);
+        msg_reg(trayMenu->statusbaritem, s("release"));
+        trayMenu->statusbaritem = NULL;
+    }
+
+    if ( trayMenu->delegate != NULL ) {
+        msg_reg(trayMenu->delegate, s("release"));
+    }
+
+    // Free the tray menu memory
+    MEMFREE(trayMenu);
+}
+
+void LoadTrayIcons() {
+
+    // Allocate the Tray Icons
+    if( 0 != hashmap_create((const unsigned)4, &trayIconCache)) {
+        // Couldn't allocate map
+        ABORT("Not enough memory to allocate trayIconCache!");
+    }
+
+    unsigned int count = 0;
+    while( 1 ) {
+        const unsigned char *name = trayIcons[count++];
+        if( name == 0x00 ) {
+            break;
+        }
+        const unsigned char *lengthAsString = trayIcons[count++];
+        if( name == 0x00 ) {
+            break;
+        }
+        const unsigned char *data = trayIcons[count++];
+        if( data == 0x00 ) {
+            break;
+        }
+        int length = atoi((const char *)lengthAsString);
+
+        // Create the icon and add to the hashmap
+        id imageData = ((id(*)(id, SEL, id, int))objc_msgSend)(c("NSData"), s("dataWithBytes:length:"), (id)data, length);
+        id trayImage = ALLOC("NSImage");
+        msg_id(trayImage, s("initWithData:"), imageData);
+        hashmap_put(&trayIconCache, (const char *)name, strlen((const char *)name), trayImage);
+    }
+}
+
+void UnloadTrayIcons() {
+    // Release the tray cache images
+    if( hashmap_num_entries(&trayIconCache) > 0 ) {
+        if (0!=hashmap_iterate_pairs(&trayIconCache, releaseNSObject, NULL)) {
+            ABORT("failed to release hashmap entries!");
+        }
+    }
+
+    //Free radio groups hashmap
+    hashmap_destroy(&trayIconCache);
+}

v2/internal/ffenestri/traymenu_darwin.h

@@ -0,0 +1,50 @@
+//
+// Created by Lea Anthony on 12/1/21.
+//
+
+#ifndef TRAYMENU_DARWIN_H
+#define TRAYMENU_DARWIN_H
+
+#include "common.h"
+#include "menu_darwin.h"
+
+typedef struct {
+
+    const char *label;
+    const char *icon;
+    const char *ID;
+    const char *tooltip;
+
+    bool templateImage;
+    const char *fontName;
+    int fontSize;
+    const char *RGBA;
+
+    bool disabled;
+
+    Menu* menu;
+
+    id statusbaritem;
+    unsigned int trayIconPosition;
+
+    JsonNode* processedJSON;
+
+    JsonNode* styledLabel;
+
+    id delegate;
+
+} TrayMenu;
+
+TrayMenu* NewTrayMenu(const char *trayJSON);
+void DumpTrayMenu(TrayMenu* trayMenu);
+void ShowTrayMenu(TrayMenu* trayMenu);
+void UpdateTrayMenuInPlace(TrayMenu* currentMenu, TrayMenu* newMenu);
+void UpdateTrayIcon(TrayMenu *trayMenu);
+void UpdateTrayLabel(TrayMenu *trayMenu, const char *label, const char *fontName, int fontSize, const char *RGBA, const char *tooltip, bool disabled, JsonNode *styledLabel);
+
+void LoadTrayIcons();
+void UnloadTrayIcons();
+
+void DeleteTrayMenu(TrayMenu* trayMenu);
+
+#endif //TRAYMENU_DARWIN_H

v2/internal/ffenestri/traymenustore_darwin.c

@@ -0,0 +1,177 @@
+//
+// Created by Lea Anthony on 12/1/21.
+//
+
+#include "common.h"
+#include "traymenustore_darwin.h"
+#include "traymenu_darwin.h"
+#include <stdlib.h>
+
+TrayMenuStore* NewTrayMenuStore() {
+
+    TrayMenuStore* result = malloc(sizeof(TrayMenuStore));
+
+    // Allocate Tray Menu Store
+    if( 0 != hashmap_create((const unsigned)4, &result->trayMenuMap)) {
+        ABORT("[NewTrayMenuStore] Not enough memory to allocate trayMenuMap!");
+    }
+
+    if (pthread_mutex_init(&result->lock, NULL) != 0) {
+        printf("\n mutex init has failed\n");
+        exit(1);
+    }
+
+    return result;
+}
+
+int dumpTrayMenu(void *const context, struct hashmap_element_s *const e) {
+    DumpTrayMenu(e->data);
+    return 0;
+}
+
+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);
+
+    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) {
+    ShowTrayMenu(e->data);
+    // 0 to retain element, -1 to delete.
+    return 0;
+}
+
+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;
+}
+
+void DeleteTrayMenuStore(TrayMenuStore *store) {
+
+    // Delete context menus
+    if (hashmap_num_entries(&store->trayMenuMap) > 0) {
+        if (0 != hashmap_iterate_pairs(&store->trayMenuMap, freeTrayMenu, NULL)) {
+            ABORT("[DeleteContextMenuStore] Failed to release contextMenuStore entries!");
+        }
+    }
+
+    // Destroy tray menu map
+    hashmap_destroy(&store->trayMenuMap);
+
+    pthread_mutex_destroy(&store->lock);
+}
+
+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;
+}
+
+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);
+}
+
+void UpdateTrayMenuLabelInStore(TrayMenuStore* store, const char* JSON) {
+    // Parse the JSON
+    JsonNode *parsedUpdate = mustParseJSON(JSON);
+
+    // Get the data out
+    const char* ID = mustJSONString(parsedUpdate, "ID");
+    const char* Label = mustJSONString(parsedUpdate, "Label");
+
+    // Check we have this menu
+    TrayMenu *menu = MustGetTrayMenuFromStore(store, ID);
+
+    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);
+
+    JsonNode *styledLabel = getJSONObject(parsedUpdate, "StyledLabel");
+
+    UpdateTrayLabel(menu, Label, fontName, fontSize, RGBA, tooltip, disabled, styledLabel);
+
+
+}
+
+void UpdateTrayMenuInStore(TrayMenuStore* store, const char* menuJSON) {
+    TrayMenu* newMenu = NewTrayMenu(menuJSON);
+//    DumpTrayMenu(newMenu);
+
+    // Get the current menu
+    TrayMenu *currentMenu = GetTrayMenuFromStore(store, newMenu->ID);
+
+    // If we don't have a menu, we create one
+    if ( currentMenu == NULL ) {
+        // 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;
+    }
+//    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);
+    currentMenu->menu = NULL;
+
+    // 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);
+}

v2/internal/ffenestri/traymenustore_darwin.h

@@ -0,0 +1,36 @@
+//
+// Created by Lea Anthony on 7/1/21.
+//
+
+#ifndef TRAYMENUSTORE_DARWIN_H
+#define TRAYMENUSTORE_DARWIN_H
+
+#include "traymenu_darwin.h"
+
+#include <pthread.h>
+
+typedef struct {
+
+	int dummy;
+
+    // This is our tray menu map
+    // It maps tray IDs to TrayMenu*
+    struct hashmap_s trayMenuMap;
+
+    pthread_mutex_t lock;
+
+} TrayMenuStore;
+
+TrayMenuStore* NewTrayMenuStore();
+
+void AddTrayMenuToStore(TrayMenuStore* store, const char* menuJSON);
+void UpdateTrayMenuInStore(TrayMenuStore* store, const char* menuJSON);
+void ShowTrayMenusInStore(TrayMenuStore* store);
+void DeleteTrayMenuStore(TrayMenuStore* store);
+
+TrayMenu* GetTrayMenuByID(TrayMenuStore* store, const char* menuID);
+
+void UpdateTrayMenuLabelInStore(TrayMenuStore* store, const char* JSON);
+void DeleteTrayMenuInStore(TrayMenuStore* store, const char* id);
+
+#endif //TRAYMENUSTORE_DARWIN_H

v2/internal/ffenestri/vec.c

@@ -1,4 +1,6 @@
-/** 
+// +build !windows
+
+/**
  * Copyright (c) 2014 rxi
  *
  * This library is free software; you can redistribute it and/or modify it

v2/internal/ffenestri/vec.h

@@ -1,4 +1,4 @@
-/** 
+/**
  * Copyright (c) 2014 rxi
  *
  * This library is free software; you can redistribute it and/or modify it

v2/internal/ffenestri/windows/EventToken.h

@@ -0,0 +1,68 @@
+
+
+/* this ALWAYS GENERATED file contains the definitions for the interfaces */
+
+
+ /* File created by MIDL compiler version 8.01.0622 */
+/* @@MIDL_FILE_HEADING(  ) */
+
+
+
+/* verify that the <rpcndr.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCNDR_H_VERSION__
+#define __REQUIRED_RPCNDR_H_VERSION__ 500
+#endif
+
+/* verify that the <rpcsal.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCSAL_H_VERSION__
+#define __REQUIRED_RPCSAL_H_VERSION__ 100
+#endif
+
+#include "rpc.h"
+#include "rpcndr.h"
+
+#ifndef __RPCNDR_H_VERSION__
+#error this stub requires an updated version of <rpcndr.h>
+#endif /* __RPCNDR_H_VERSION__ */
+
+
+#ifndef __eventtoken_h__
+#define __eventtoken_h__
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#pragma once
+#endif
+
+/* Forward Declarations */
+
+#ifdef __cplusplus
+extern "C"{
+#endif
+
+
+/* interface __MIDL_itf_eventtoken_0000_0000 */
+/* [local] */
+
+//  Microsoft Windows
+//  Copyright (c) Microsoft Corporation. All rights reserved.
+#pragma once
+typedef struct EventRegistrationToken
+    {
+    __int64 value;
+    } 	EventRegistrationToken;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_eventtoken_0000_0000_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_eventtoken_0000_0000_v0_0_s_ifspec;
+
+/* Additional Prototypes for ALL interfaces */
+
+/* end of Additional Prototypes */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+

v2/internal/ffenestri/windows/README.md

@@ -0,0 +1 @@
+These files were generated using the scripts in the [webview](https://github.com/webview/webview) project and compressed using UPX.