From 3c0da9fd15dd36b20baf9ccfa61fb7b3f800b828 Mon Sep 17 00:00:00 2001 From: Lea Anthony Date: Sun, 12 Sep 2021 16:32:43 +1000 Subject: [PATCH] [windows] support `runtime.WindowSetRGBA` --- v2/go.mod | 2 +- v2/go.sum | 4 +- .../frontend/desktop/windows/frontend.go | 42 ++++- v2/internal/frontend/devserver/devserver.go | 4 +- v2/internal/frontend/dispatcher/window.go | 9 ++ v2/internal/frontend/frontend.go | 3 +- .../frontend/runtime/desktop/window.js | 13 ++ .../frontend/runtime/runtime_dev_desktop.js | 148 +++++++++--------- .../frontend/runtime/runtime_prod_desktop.js | 2 +- .../frontend/runtime/wrapper/runtime.d.ts | 9 ++ .../frontend/runtime/wrapper/runtime.js | 2 +- .../frontend/runtime/wrapper/window.js | 10 ++ v2/pkg/options/default.go | 1 - v2/pkg/options/options.go | 19 ++- v2/pkg/runtime/window.go | 6 + 15 files changed, 178 insertions(+), 96 deletions(-) diff --git a/v2/go.mod b/v2/go.mod index 205a25fba..db8e7ca13 100644 --- a/v2/go.mod +++ b/v2/go.mod @@ -21,7 +21,7 @@ require ( github.com/leaanthony/debme v1.2.1 github.com/leaanthony/go-ansi-parser v1.0.1 github.com/leaanthony/go-common-file-dialog v1.0.3 - github.com/leaanthony/go-webview2 v0.0.0-20210906112707-5ca00d49e830 + github.com/leaanthony/go-webview2 v0.0.0-20210912034341-849718dc22d7 github.com/leaanthony/gosod v1.0.1 github.com/leaanthony/idgen v1.0.0 github.com/leaanthony/slicer v1.5.0 diff --git a/v2/go.sum b/v2/go.sum index ced9e4108..512ad2870 100644 --- a/v2/go.sum +++ b/v2/go.sum @@ -125,8 +125,8 @@ github.com/leaanthony/go-ansi-parser v1.0.1 h1:97v6c5kYppVsbScf4r/VZdXyQ21KQIfeQ github.com/leaanthony/go-ansi-parser v1.0.1/go.mod h1:7arTzgVI47srICYhvgUV4CGd063sGEeoSlych5yeSPM= github.com/leaanthony/go-common-file-dialog v1.0.3 h1:O0uGjKnWtdEADGrkg+TyAAbZylykMwwx/MNEXn9fp+Y= github.com/leaanthony/go-common-file-dialog v1.0.3/go.mod h1:TGhEc9eSJgRsupZ+iH1ZgAOnEo9zp05cRH2j08RPrF0= -github.com/leaanthony/go-webview2 v0.0.0-20210906112707-5ca00d49e830 h1:96/BSuQHPLQHkibP8PMs/BkSTHDL/yZoq4fGinEjb2w= -github.com/leaanthony/go-webview2 v0.0.0-20210906112707-5ca00d49e830/go.mod h1:jVGFkh5EgsmI4X5Z/XsALrCELLEqrbc4dP3EGO9UY78= +github.com/leaanthony/go-webview2 v0.0.0-20210912034341-849718dc22d7 h1:8IvKTQk33VBpncfgezD6BKutv5kCSZbDIcCNHOT9T4w= +github.com/leaanthony/go-webview2 v0.0.0-20210912034341-849718dc22d7/go.mod h1:lS5ds4bruPk9d7lzdF/OH31Z0YCerI6MmHNFGsWoUnM= 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/idgen v1.0.0 h1:IZreR+JGEzFV4yeVuBZA25gM0keUoFy+RDUldncQ+Jw= diff --git a/v2/internal/frontend/desktop/windows/frontend.go b/v2/internal/frontend/desktop/windows/frontend.go index 5f7404da6..3e8575090 100644 --- a/v2/internal/frontend/desktop/windows/frontend.go +++ b/v2/internal/frontend/desktop/windows/frontend.go @@ -165,9 +165,37 @@ func (f *Frontend) WindowSetMaxSize(width int, height int) { f.mainWindow.SetMaxSize(width, height) } -func (f *Frontend) WindowSetColour(colour int) { +func (f *Frontend) WindowSetRGBA(col *options.RGBA) { runtime.LockOSThread() - // TODO: Set webview2 background to this colour + if col == nil { + return + } + + f.mainWindow.Dispatch(func() { + controller := f.chromium.GetController() + controller2 := controller.GetICoreWebView2Controller2() + + backgroundCol := edge.COREWEBVIEW2_COLOR{ + A: col.A, + R: col.R, + G: col.G, + B: col.B, + } + + // Webview2 only has 0 and 255 as valid values. + if backgroundCol.A > 0 && backgroundCol.A < 255 { + backgroundCol.A = 255 + } + + if f.frontendOptions.Windows != nil && f.frontendOptions.Windows.WebviewIsTransparent { + backgroundCol.A = 0 + } + + err := controller2.PutDefaultBackgroundColor(backgroundCol) + if err != nil { + log.Fatal(err) + } + }) } func (f *Frontend) Quit() { @@ -176,6 +204,7 @@ func (f *Frontend) Quit() { func (f *Frontend) setupChromium() { chromium := edge.NewChromium() + f.chromium = chromium chromium.MessageCallback = f.processMessage chromium.WebResourceRequestedCallback = f.processRequest chromium.NavigationCompletedCallback = f.navigationCompleted @@ -209,14 +238,11 @@ func (f *Frontend) setupChromium() { log.Fatal(err) } - //c2, err := chromium.GetWebView2Controller2() - //err = c2.PutDefaultBackgroundColor(edge.COREWEBVIEW2_COLOR{R: 255, G: 0, B: 0, A: 255}) - //if err != nil { - // log.Fatal(err) - //} + // Set background colour + f.WindowSetRGBA(f.frontendOptions.RGBA) + chromium.AddWebResourceRequestedFilter("*", edge.COREWEBVIEW2_WEB_RESOURCE_CONTEXT_ALL) chromium.Navigate("file://wails/") - f.chromium = chromium } type EventNotify struct { diff --git a/v2/internal/frontend/devserver/devserver.go b/v2/internal/frontend/devserver/devserver.go index b903af4e4..e4ddc1014 100644 --- a/v2/internal/frontend/devserver/devserver.go +++ b/v2/internal/frontend/devserver/devserver.go @@ -226,8 +226,8 @@ func (d *DevWebServer) WindowUnFullscreen() { d.desktopFrontend.WindowUnFullscreen() } -func (d *DevWebServer) WindowSetColour(colour int) { - d.desktopFrontend.WindowSetColour(colour) +func (d *DevWebServer) WindowSetRGBA(col *options.RGBA) { + d.desktopFrontend.WindowSetRGBA(col) } func (d *DevWebServer) SetApplicationMenu(menu *menu.Menu) { diff --git a/v2/internal/frontend/dispatcher/window.go b/v2/internal/frontend/dispatcher/window.go index 3752693b1..c75f1739a 100644 --- a/v2/internal/frontend/dispatcher/window.go +++ b/v2/internal/frontend/dispatcher/window.go @@ -1,8 +1,10 @@ package dispatcher import ( + "encoding/json" "errors" "github.com/wailsapp/wails/v2/internal/frontend" + "github.com/wailsapp/wails/v2/pkg/options" "strconv" "strings" ) @@ -44,6 +46,13 @@ func (d *Dispatcher) processWindowMessage(message string, sender frontend.Fronte go sender.WindowHide() case 'S': go sender.WindowShow() + case 'r': + var rgba options.RGBA + err := json.Unmarshal([]byte(message[3:]), &rgba) + if err != nil { + return "", err + } + go sender.WindowSetRGBA(&rgba) case 'M': go sender.WindowMaximise() case 'U': diff --git a/v2/internal/frontend/frontend.go b/v2/internal/frontend/frontend.go index 8a9433e04..7f11bcae0 100644 --- a/v2/internal/frontend/frontend.go +++ b/v2/internal/frontend/frontend.go @@ -3,6 +3,7 @@ package frontend import ( "context" "github.com/wailsapp/wails/v2/pkg/menu" + "github.com/wailsapp/wails/v2/pkg/options" ) // FileFilter defines a filter for dialog boxes @@ -84,7 +85,7 @@ type Frontend interface { WindowSetMaxSize(width int, height int) WindowFullscreen() WindowUnFullscreen() - WindowSetColour(colour int) + WindowSetRGBA(col *options.RGBA) WindowReload() // Menus diff --git a/v2/internal/frontend/runtime/desktop/window.js b/v2/internal/frontend/runtime/desktop/window.js index 7939fcd67..348bb4952 100644 --- a/v2/internal/frontend/runtime/desktop/window.js +++ b/v2/internal/frontend/runtime/desktop/window.js @@ -173,6 +173,19 @@ export function WindowUnminimise() { window.WailsInvoke('Wu'); } + +/** + * Sets the background colour of the window + * + * @export + * @param {RGBA} RGBA background colour + */ +export function WindowSetRGBA(RGBA) { + let rgba = JSON.stringify(RGBA); + window.WailsInvoke('Wr:' + rgba); +} + + /** * Close the Window * diff --git a/v2/internal/frontend/runtime/runtime_dev_desktop.js b/v2/internal/frontend/runtime/runtime_dev_desktop.js index 2c92398cf..74b9395d5 100644 --- a/v2/internal/frontend/runtime/runtime_dev_desktop.js +++ b/v2/internal/frontend/runtime/runtime_dev_desktop.js @@ -1,11 +1,11 @@ (() => { var __defProp = Object.defineProperty; - var __markAsModule = (target) => __defProp(target, "__esModule", {value: true}); - var __export = (target, all) => { - __markAsModule(target); - for (var name in all) - __defProp(target, name, {get: all[name], enumerable: true}); - }; + var __markAsModule = (target) => __defProp(target, "__esModule", {value: true}); + var __export = (target, all) => { + __markAsModule(target); + for (var name in all) + __defProp(target, name, {get: all[name], enumerable: true}); + }; // desktop/log.js var log_exports = {}; @@ -138,17 +138,17 @@ if (timeout == null) { timeout = 0; } - return new Promise(function (resolve, reject) { - var callbackID; - do { - callbackID = name + "-" + randomFunc(); - } while (callbacks[callbackID]); - var timeoutHandle; - if (timeout > 0) { - timeoutHandle = setTimeout(function () { - reject(Error("Call to " + name + " timed out. Request ID: " + callbackID)); - }, timeout); - } + return new Promise(function (resolve, reject) { + var callbackID; + do { + callbackID = name + "-" + randomFunc(); + } while (callbacks[callbackID]); + var timeoutHandle; + if (timeout > 0) { + timeoutHandle = setTimeout(function () { + reject(Error("Call to " + name + " timed out. Request ID: " + callbackID)); + }, timeout); + } callbacks[callbackID] = { timeoutHandle, reject, @@ -205,20 +205,20 @@ Object.keys(bindingsMap[packageName]).forEach((structName) => { window.go[packageName][structName] = window.go[packageName][structName] || {}; Object.keys(bindingsMap[packageName][structName]).forEach((methodName) => { - window.go[packageName][structName][methodName] = function () { - let timeout = 0; + window.go[packageName][structName][methodName] = function () { + let timeout = 0; - function dynamic() { - const args = [].slice.call(arguments); - return Call([packageName, structName, methodName].join("."), args, timeout); - } + function dynamic() { + const args = [].slice.call(arguments); + return Call([packageName, structName, methodName].join("."), args, timeout); + } - dynamic.setTimeout = function (newTimeout) { - timeout = newTimeout; - }; - dynamic.getTimeout = function () { - return timeout; - }; + dynamic.setTimeout = function (newTimeout) { + timeout = newTimeout; + }; + dynamic.getTimeout = function () { + return timeout; + }; return dynamic; }(); }); @@ -231,102 +231,94 @@ __export(window_exports, { WindowCenter: () => WindowCenter, WindowClose: () => WindowClose, - WindowFullscreen: () => WindowFullscreen, - WindowGetPosition: () => WindowGetPosition, - WindowGetSize: () => WindowGetSize, - WindowHide: () => WindowHide, - WindowMaximise: () => WindowMaximise, - WindowMinimise: () => WindowMinimise, - WindowReload: () => WindowReload, - WindowSetMaxSize: () => WindowSetMaxSize, - WindowSetMinSize: () => WindowSetMinSize, - WindowSetPosition: () => WindowSetPosition, - WindowSetSize: () => WindowSetSize, - WindowSetTitle: () => WindowSetTitle, - WindowShow: () => WindowShow, - WindowUnFullscreen: () => WindowUnFullscreen, - WindowUnmaximise: () => WindowUnmaximise, - WindowUnminimise: () => WindowUnminimise + WindowFullscreen: () => WindowFullscreen, + WindowGetPosition: () => WindowGetPosition, + WindowGetSize: () => WindowGetSize, + WindowHide: () => WindowHide, + WindowMaximise: () => WindowMaximise, + WindowMinimise: () => WindowMinimise, + WindowReload: () => WindowReload, + WindowSetMaxSize: () => WindowSetMaxSize, + WindowSetMinSize: () => WindowSetMinSize, + WindowSetPosition: () => WindowSetPosition, + WindowSetRGBA: () => WindowSetRGBA, + WindowSetSize: () => WindowSetSize, + WindowSetTitle: () => WindowSetTitle, + WindowShow: () => WindowShow, + WindowUnFullscreen: () => WindowUnFullscreen, + WindowUnmaximise: () => WindowUnmaximise, + WindowUnminimise: () => WindowUnminimise }); - function WindowReload() { window.location.reload(); } - function WindowCenter() { window.WailsInvoke("Wc"); } - function WindowSetTitle(title) { window.WailsInvoke("WT" + title); } - function WindowFullscreen() { window.WailsInvoke("WF"); } - function WindowUnFullscreen() { window.WailsInvoke("Wf"); } - function WindowSetSize(width, height) { window.WailsInvoke("Ws:" + width + ":" + height); } - function WindowGetSize() { return Call(":wails:WindowGetSize"); } - function WindowSetMaxSize(width, height) { window.WailsInvoke("WZ:" + width + ":" + height); } - function WindowSetMinSize(width, height) { window.WailsInvoke("Wz:" + width + ":" + height); } - function WindowSetPosition(x, y) { window.WailsInvoke("Wp:" + x + ":" + y); } - function WindowGetPosition() { return Call(":wails:WindowGetPos"); } - function WindowHide() { window.WailsInvoke("WH"); } - function WindowShow() { window.WailsInvoke("WS"); } - function WindowMaximise() { window.WailsInvoke("WM"); } - function WindowUnmaximise() { - window.WailsInvoke("WU"); - } + function WindowUnmaximise() { + window.WailsInvoke("WU"); + } - function WindowMinimise() { - window.WailsInvoke("Wm"); - } + function WindowMinimise() { + window.WailsInvoke("Wm"); + } - function WindowUnminimise() { - window.WailsInvoke("Wu"); - } + function WindowUnminimise() { + window.WailsInvoke("Wu"); + } - function WindowClose() { - window.WailsInvoke("WC"); - } + function WindowSetRGBA(RGBA) { + let rgba = JSON.stringify(RGBA); + window.WailsInvoke("Wr:" + rgba); + } - // desktop/main.js - window.runtime = { - ...log_exports, - ...window_exports, - EventsOn, - EventsOnce, + function WindowClose() { + window.WailsInvoke("WC"); + } + + // desktop/main.js + window.runtime = { + ...log_exports, + ...window_exports, + EventsOn, + EventsOnce, EventsOnMultiple, EventsEmit, EventsOff @@ -356,4 +348,4 @@ } }); })(); -//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["desktop/log.js", "desktop/events.js", "desktop/calls.js", "desktop/bindings.js", "desktop/window.js", "desktop/main.js"],
  "sourcesContent": ["/*\r\n _       __      _ __\r\n| |     / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 6 */\r\n\r\n/**\r\n * Sends a log message to the backend with the given level + message\r\n *\r\n * @param {string} level\r\n * @param {string} message\r\n */\r\nfunction sendLogMessage(level, message) {\r\n\r\n\t// Log Message format:\r\n\t// l[type][message]\r\n\twindow.WailsInvoke('L' + level + message);\r\n}\r\n\r\n/**\r\n * Log the given trace message with the backend\r\n *\r\n * @export\r\n * @param {string} message\r\n */\r\nexport function LogTrace(message) {\r\n\tsendLogMessage('T', message);\r\n}\r\n\r\n/**\r\n * Log the given message with the backend\r\n *\r\n * @export\r\n * @param {string} message\r\n */\r\nexport function LogPrint(message) {\r\n\tsendLogMessage('P', message);\r\n}\r\n\r\n/**\r\n * Log the given debug message with the backend\r\n *\r\n * @export\r\n * @param {string} message\r\n */\r\nexport function LogDebug(message) {\r\n\tsendLogMessage('D', message);\r\n}\r\n\r\n/**\r\n * Log the given info message with the backend\r\n *\r\n * @export\r\n * @param {string} message\r\n */\r\nexport function LogInfo(message) {\r\n\tsendLogMessage('I', message);\r\n}\r\n\r\n/**\r\n * Log the given warning message with the backend\r\n *\r\n * @export\r\n * @param {string} message\r\n */\r\nexport function LogWarning(message) {\r\n\tsendLogMessage('W', message);\r\n}\r\n\r\n/**\r\n * Log the given error message with the backend\r\n *\r\n * @export\r\n * @param {string} message\r\n */\r\nexport function LogError(message) {\r\n\tsendLogMessage('E', message);\r\n}\r\n\r\n/**\r\n * Log the given fatal message with the backend\r\n *\r\n * @export\r\n * @param {string} message\r\n */\r\nexport function LogFatal(message) {\r\n\tsendLogMessage('F', message);\r\n}\r\n\r\n/**\r\n * Sets the Log level to the given log level\r\n *\r\n * @export\r\n * @param {number} loglevel\r\n */\r\nexport function SetLogLevel(loglevel) {\r\n\tsendLogMessage('S', loglevel);\r\n}\r\n\r\n// Log levels\r\nexport const LogLevel = {\r\n\tTRACE: 1,\r\n\tDEBUG: 2,\r\n\tINFO: 3,\r\n\tWARNING: 4,\r\n\tERROR: 5,\r\n};\r\n", "/*\r\n _       __      _ __\r\n| |     / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n/* jshint esversion: 6 */\r\n\r\n// Defines a single listener with a maximum number of times to callback\r\n\r\n/**\r\n * The Listener class defines a listener! :-)\r\n *\r\n * @class Listener\r\n */\r\nclass Listener {\r\n    /**\r\n     * Creates an instance of Listener.\r\n     * @param {function} callback\r\n     * @param {number} maxCallbacks\r\n     * @memberof Listener\r\n     */\r\n    constructor(callback, maxCallbacks) {\r\n        // Default of -1 means infinite\r\n        maxCallbacks = maxCallbacks || -1;\r\n        // Callback invokes the callback with the given data\r\n        // Returns true if this listener should be destroyed\r\n        this.Callback = (data) => {\r\n            callback.apply(null, data);\r\n            // If maxCallbacks is infinite, return false (do not destroy)\r\n            if (maxCallbacks === -1) {\r\n                return false;\r\n            }\r\n            // Decrement maxCallbacks. Return true if now 0, otherwise false\r\n            maxCallbacks -= 1;\r\n            return maxCallbacks === 0;\r\n        };\r\n    }\r\n}\r\n\r\nexport const eventListeners = {};\r\n\r\n/**\r\n * Registers an event listener that will be invoked `maxCallbacks` times before being destroyed\r\n *\r\n * @export\r\n * @param {string} eventName\r\n * @param {function} callback\r\n * @param {number} maxCallbacks\r\n */\r\nexport function EventsOnMultiple(eventName, callback, maxCallbacks) {\r\n    eventListeners[eventName] = eventListeners[eventName] || [];\r\n    const thisListener = new Listener(callback, maxCallbacks);\r\n    eventListeners[eventName].push(thisListener);\r\n}\r\n\r\n/**\r\n * Registers an event listener that will be invoked every time the event is emitted\r\n *\r\n * @export\r\n * @param {string} eventName\r\n * @param {function} callback\r\n */\r\nexport function EventsOn(eventName, callback) {\r\n    EventsOnMultiple(eventName, callback, -1);\r\n}\r\n\r\n/**\r\n * Registers an event listener that will be invoked once then destroyed\r\n *\r\n * @export\r\n * @param {string} eventName\r\n * @param {function} callback\r\n */\r\nexport function EventsOnce(eventName, callback) {\r\n    EventsOnMultiple(eventName, callback, 1);\r\n}\r\n\r\nfunction notifyListeners(eventData) {\r\n\r\n    // Get the event name\r\n    let eventName = eventData.name;\r\n\r\n    // Check if we have any listeners for this event\r\n    if (eventListeners[eventName]) {\r\n\r\n        // Keep a list of listener indexes to destroy\r\n        const newEventListenerList = eventListeners[eventName].slice();\r\n\r\n        // Iterate listeners\r\n        for (let count = 0; count < eventListeners[eventName].length; count += 1) {\r\n\r\n            // Get next listener\r\n            const listener = eventListeners[eventName][count];\r\n\r\n            let data = eventData.data;\r\n\r\n            // Do the callback\r\n            const destroy = listener.Callback(data);\r\n            if (destroy) {\r\n                // if the listener indicated to destroy itself, add it to the destroy list\r\n                newEventListenerList.splice(count, 1);\r\n            }\r\n        }\r\n\r\n        // Update callbacks with new list of listeners\r\n        eventListeners[eventName] = newEventListenerList;\r\n    }\r\n}\r\n\r\n/**\r\n * Notify informs frontend listeners that an event was emitted with the given data\r\n *\r\n * @export\r\n * @param {string} notifyMessage - encoded notification message\r\n\r\n */\r\nexport function EventsNotify(notifyMessage) {\r\n    // Parse the message\r\n    let message;\r\n    try {\r\n        message = JSON.parse(notifyMessage);\r\n    } catch (e) {\r\n        const error = 'Invalid JSON passed to Notify: ' + notifyMessage;\r\n        throw new Error(error);\r\n    }\r\n    notifyListeners(message);\r\n}\r\n\r\n/**\r\n * Emit an event with the given name and data\r\n *\r\n * @export\r\n * @param {string} eventName\r\n */\r\nexport function EventsEmit(eventName) {\r\n\r\n    const payload = {\r\n        name: eventName,\r\n        data: [].slice.apply(arguments).slice(1),\r\n    };\r\n\r\n    // Notify JS listeners\r\n    notifyListeners(payload);\r\n\r\n    // Notify Go listeners\r\n    window.WailsInvoke('EE' + JSON.stringify(payload));\r\n}\r\n\r\nexport function EventsOff(eventName) {\r\n    // Remove local listeners\r\n    eventListeners.delete(eventName);\r\n\r\n    // Notify Go listeners\r\n    window.WailsInvoke('EX' + eventName);\r\n}", "/*\r\n _       __      _ __\r\n| |     / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n/* jshint esversion: 6 */\r\n\r\nexport const callbacks = {};\r\n\r\n/**\r\n * Returns a number from the native browser random function\r\n *\r\n * @returns number\r\n */\r\nfunction cryptoRandom() {\r\n\tvar array = new Uint32Array(1);\r\n\treturn window.crypto.getRandomValues(array)[0];\r\n}\r\n\r\n/**\r\n * Returns a number using da old-skool Math.Random\r\n * I likes to call it LOLRandom\r\n *\r\n * @returns number\r\n */\r\nfunction basicRandom() {\r\n\treturn Math.random() * 9007199254740991;\r\n}\r\n\r\n// Pick a random number function based on browser capability\r\nvar randomFunc;\r\nif (window.crypto) {\r\n\trandomFunc = cryptoRandom;\r\n} else {\r\n\trandomFunc = basicRandom;\r\n}\r\n\r\n\r\n/**\r\n * Call sends a message to the backend to call the binding with the\r\n * given data. A promise is returned and will be completed when the\r\n * backend responds. This will be resolved when the call was successful\r\n * or rejected if an error is passed back.\r\n * There is a timeout mechanism. If the call doesn't respond in the given\r\n * time (in milliseconds) then the promise is rejected.\r\n *\r\n * @export\r\n * @param {string} name\r\n * @param {any=} args\r\n * @param {number=} timeout\r\n * @returns\r\n */\r\nexport function Call(name, args, timeout) {\r\n\r\n\t// Timeout infinite by default\r\n\tif (timeout == null) {\r\n\t\ttimeout = 0;\r\n\t}\r\n\r\n\t// Create a promise\r\n\treturn new Promise(function (resolve, reject) {\r\n\r\n\t\t// Create a unique callbackID\r\n\t\tvar callbackID;\r\n\t\tdo {\r\n\t\t\tcallbackID = name + '-' + randomFunc();\r\n\t\t} while (callbacks[callbackID]);\r\n\r\n\t\tvar timeoutHandle;\r\n\t\t// Set timeout\r\n\t\tif (timeout > 0) {\r\n\t\t\ttimeoutHandle = setTimeout(function () {\r\n\t\t\t\treject(Error('Call to ' + name + ' timed out. Request ID: ' + callbackID));\r\n\t\t\t}, timeout);\r\n\t\t}\r\n\r\n\t\t// Store callback\r\n\t\tcallbacks[callbackID] = {\r\n\t\t\ttimeoutHandle: timeoutHandle,\r\n\t\t\treject: reject,\r\n\t\t\tresolve: resolve\r\n\t\t};\r\n\r\n\t\ttry {\r\n\t\t\tconst payload = {\r\n\t\t\t\tname,\r\n\t\t\t\targs,\r\n\t\t\t\tcallbackID,\r\n\t\t\t};\r\n\r\n\t\t\t// Make the call\r\n\t\t\twindow.WailsInvoke('C' + JSON.stringify(payload));\r\n\t\t} catch (e) {\r\n\t\t\t// eslint-disable-next-line\r\n\t\t\tconsole.error(e);\r\n\t\t}\r\n\t});\r\n}\r\n\r\n\r\n\r\n/**\r\n * Called by the backend to return data to a previously called\r\n * binding invocation\r\n *\r\n * @export\r\n * @param {string} incomingMessage\r\n */\r\nexport function Callback(incomingMessage) {\r\n\t// Decode the message - Credit: https://stackoverflow.com/a/13865680\r\n\t//incomingMessage = decodeURIComponent(incomingMessage.replace(/\\s+/g, '').replace(/[0-9a-f]{2}/g, '%$&'));\r\n\r\n\t// Parse the message\r\n\tvar message;\r\n\ttry {\r\n\t\tmessage = JSON.parse(incomingMessage);\r\n\t} catch (e) {\r\n\t\tconst error = `Invalid JSON passed to callback: ${e.message}. Message: ${incomingMessage}`;\r\n\t\twails.LogDebug(error);\r\n\t\tthrow new Error(error);\r\n\t}\r\n\tvar callbackID = message.callbackid;\r\n\tvar callbackData = callbacks[callbackID];\r\n\tif (!callbackData) {\r\n\t\tconst error = `Callback '${callbackID}' not registered!!!`;\r\n\t\tconsole.error(error); // eslint-disable-line\r\n\t\tthrow new Error(error);\r\n\t}\r\n\tclearTimeout(callbackData.timeoutHandle);\r\n\r\n\tdelete callbacks[callbackID];\r\n\r\n\tif (message.error) {\r\n\t\tcallbackData.reject(message.error);\r\n\t} else {\r\n\t\tcallbackData.resolve(message.result);\r\n\t}\r\n}\r\n", "/*\r\n _       __      _ __    \r\n| |     / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  ) \r\n|__/|__/\\__,_/_/_/____/  \r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n/* jshint esversion: 6 */\r\n\r\nimport {Call} from './calls';\r\n\r\n// This is where we bind go method wrappers\r\nwindow.go = {};\r\n\r\nexport function SetBindings(bindingsMap) {\r\n\ttry {\r\n\t\tbindingsMap = JSON.parse(bindingsMap);\r\n\t} catch (e) {\r\n\t\tconsole.error(e);\r\n\t}\r\n\r\n\t// Initialise the bindings map\r\n\twindow.go = window.go || {};\r\n\r\n\t// Iterate package names\r\n\tObject.keys(bindingsMap).forEach((packageName) => {\r\n\r\n\t\t// Create inner map if it doesn't exist\r\n\t\twindow.go[packageName] = window.go[packageName] || {};\r\n\r\n\t\t// Iterate struct names\r\n\t\tObject.keys(bindingsMap[packageName]).forEach((structName) => {\r\n\r\n\t\t\t// Create inner map if it doesn't exist\r\n\t\t\twindow.go[packageName][structName] = window.go[packageName][structName] || {};\r\n\r\n\t\t\tObject.keys(bindingsMap[packageName][structName]).forEach((methodName) => {\r\n\r\n\t\t\t\twindow.go[packageName][structName][methodName] = function () {\r\n\r\n\t\t\t\t\t// No timeout by default\r\n\t\t\t\t\tlet timeout = 0;\r\n\r\n\t\t\t\t\t// Actual function\r\n\t\t\t\t\tfunction dynamic() {\r\n\t\t\t\t\t\tconst args = [].slice.call(arguments);\r\n\t\t\t\t\t\treturn Call([packageName, structName, methodName].join('.'), args, timeout);\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\t// Allow setting timeout to function\r\n\t\t\t\t\tdynamic.setTimeout = function (newTimeout) {\r\n\t\t\t\t\t\ttimeout = newTimeout;\r\n\t\t\t\t\t};\r\n\r\n\t\t\t\t\t// Allow getting timeout to function\r\n\t\t\t\t\tdynamic.getTimeout = function () {\r\n\t\t\t\t\t\treturn timeout;\r\n\t\t\t\t\t};\r\n\r\n\t\t\t\t\treturn dynamic;\r\n\t\t\t\t}();\r\n\t\t\t});\r\n\t\t});\r\n\t});\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\n\r\nimport {Call} from \"./calls\";\r\n\r\nexport function WindowReload() {\r\n    window.location.reload();\r\n}\r\n\r\n/**\r\n * Place the window in the center of the screen\r\n *\r\n * @export\r\n */\r\nexport function WindowCenter() {\r\n    window.WailsInvoke('Wc');\r\n}\r\n\r\n/**\r\n * Sets the window title\r\n *\r\n * @param {string} title\r\n * @export\r\n */\r\nexport function WindowSetTitle(title) {\r\n    window.WailsInvoke('WT' + title);\r\n}\r\n\r\n/**\r\n * Makes the window go fullscreen\r\n *\r\n * @export\r\n */\r\nexport function WindowFullscreen() {\r\n    window.WailsInvoke('WF');\r\n}\r\n\r\n/**\r\n * Reverts the window from fullscreen\r\n *\r\n * @export\r\n */\r\nexport function WindowUnFullscreen() {\r\n    window.WailsInvoke('Wf');\r\n}\r\n\r\n/**\r\n * Set the Size of the window\r\n *\r\n * @export\r\n * @param {number} width\r\n * @param {number} height\r\n */\r\nexport function WindowSetSize(width, height) {\r\n    window.WailsInvoke('Ws:' + width + ':' + height);\r\n}\r\n\r\n/**\r\n * Get the Size of the window\r\n *\r\n * @export\r\n * @return {Promise<{w: number, h: number}>} The size of the window\r\n\r\n */\r\nexport function WindowGetSize() {\r\n    return Call(\":wails:WindowGetSize\");\r\n}\r\n\r\n/**\r\n * Set the maximum size of the window\r\n *\r\n * @export\r\n * @param {number} width\r\n * @param {number} height\r\n */\r\nexport function WindowSetMaxSize(width, height) {\r\n    window.WailsInvoke('WZ:' + width + ':' + height);\r\n}\r\n/**\r\n * Set the minimum size of the window\r\n *\r\n * @export\r\n * @param {number} width\r\n * @param {number} height\r\n */\r\nexport function WindowSetMinSize(width, height) {\r\n    window.WailsInvoke('Wz:' + width + ':' + height);\r\n}\r\n\r\n/**\r\n * Set the Position of the window\r\n *\r\n * @export\r\n * @param {number} x\r\n * @param {number} y\r\n */\r\nexport function WindowSetPosition(x, y) {\r\n    window.WailsInvoke('Wp:' + x + ':' + y);\r\n}\r\n\r\n/**\r\n * Get the Position of the window\r\n *\r\n * @export\r\n * @return {Promise<{x: number, y: number}>} The position of the window\r\n */\r\nexport function WindowGetPosition() {\r\n    return Call(\":wails:WindowGetPos\");\r\n}\r\n\r\n/**\r\n * Hide the Window\r\n *\r\n * @export\r\n */\r\nexport function WindowHide() {\r\n    window.WailsInvoke('WH');\r\n}\r\n\r\n/**\r\n * Show the Window\r\n *\r\n * @export\r\n */\r\nexport function WindowShow() {\r\n    window.WailsInvoke('WS');\r\n}\r\n\r\n/**\r\n * Maximise the Window\r\n *\r\n * @export\r\n */\r\nexport function WindowMaximise() {\r\n    window.WailsInvoke('WM');\r\n}\r\n\r\n/**\r\n * Unmaximise the Window\r\n *\r\n * @export\r\n */\r\nexport function WindowUnmaximise() {\r\n    window.WailsInvoke('WU');\r\n}\r\n\r\n/**\r\n * Minimise the Window\r\n *\r\n * @export\r\n */\r\nexport function WindowMinimise() {\r\n    window.WailsInvoke('Wm');\r\n}\r\n\r\n/**\r\n * Unminimise the Window\r\n *\r\n * @export\r\n */\r\nexport function WindowUnminimise() {\r\n    window.WailsInvoke('Wu');\r\n}\r\n\r\n/**\r\n * Close the Window\r\n *\r\n * @export\r\n */\r\nexport function WindowClose() {\r\n    window.WailsInvoke('WC');\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n/* jshint esversion: 9 */\r\nimport * as Log from './log';\r\nimport {eventListeners, EventsEmit, EventsNotify, EventsOff, EventsOn, EventsOnce, EventsOnMultiple} from './events';\r\nimport {Callback, callbacks} from './calls';\r\nimport {SetBindings} from \"./bindings\";\r\nimport * as Window from \"./window\";\r\n\r\n// The JS runtime\r\nwindow.runtime = {\r\n    ...Log,\r\n    ...Window,\r\n    EventsOn,\r\n    EventsOnce,\r\n    EventsOnMultiple,\r\n    EventsEmit,\r\n    EventsOff,\r\n};\r\n\r\n// Internal wails endpoints\r\nwindow.wails = {\r\n    Callback,\r\n    EventsNotify,\r\n    SetBindings,\r\n    eventListeners,\r\n    callbacks\r\n};\r\n\r\n// Set the bindings\r\nwindow.wails.SetBindings(window.wailsbindings);\r\ndelete window.wails.SetBindings;\r\n\r\n// This is evaluated at build time in package.json\r\nif (ENV === \"production\") {\r\n    delete window.wailsbindings;\r\n}\r\n\r\n// Setup drag handler\r\n// Based on code from: https://github.com/patr0nus/DeskGap\r\nwindow.addEventListener('mousedown', (e) => {\r\n    let currentElement = e.target;\r\n    while (currentElement != null) {\r\n        if (currentElement.hasAttribute('data-wails-no-drag')) {\r\n            break;\r\n        } else if (currentElement.hasAttribute('data-wails-drag')) {\r\n            window.WailsInvoke(\"drag\");\r\n            break;\r\n        }\r\n        currentElement = currentElement.parentElement;\r\n    }\r\n});\r\n"],
  "mappings": "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",
  "names": []
}
 +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["desktop/log.js", "desktop/events.js", "desktop/calls.js", "desktop/bindings.js", "desktop/window.js", "desktop/main.js"],
  "sourcesContent": ["/*\r\n _       __      _ __\r\n| |     / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 6 */\r\n\r\n/**\r\n * Sends a log message to the backend with the given level + message\r\n *\r\n * @param {string} level\r\n * @param {string} message\r\n */\r\nfunction sendLogMessage(level, message) {\r\n\r\n\t// Log Message format:\r\n\t// l[type][message]\r\n\twindow.WailsInvoke('L' + level + message);\r\n}\r\n\r\n/**\r\n * Log the given trace message with the backend\r\n *\r\n * @export\r\n * @param {string} message\r\n */\r\nexport function LogTrace(message) {\r\n\tsendLogMessage('T', message);\r\n}\r\n\r\n/**\r\n * Log the given message with the backend\r\n *\r\n * @export\r\n * @param {string} message\r\n */\r\nexport function LogPrint(message) {\r\n\tsendLogMessage('P', message);\r\n}\r\n\r\n/**\r\n * Log the given debug message with the backend\r\n *\r\n * @export\r\n * @param {string} message\r\n */\r\nexport function LogDebug(message) {\r\n\tsendLogMessage('D', message);\r\n}\r\n\r\n/**\r\n * Log the given info message with the backend\r\n *\r\n * @export\r\n * @param {string} message\r\n */\r\nexport function LogInfo(message) {\r\n\tsendLogMessage('I', message);\r\n}\r\n\r\n/**\r\n * Log the given warning message with the backend\r\n *\r\n * @export\r\n * @param {string} message\r\n */\r\nexport function LogWarning(message) {\r\n\tsendLogMessage('W', message);\r\n}\r\n\r\n/**\r\n * Log the given error message with the backend\r\n *\r\n * @export\r\n * @param {string} message\r\n */\r\nexport function LogError(message) {\r\n\tsendLogMessage('E', message);\r\n}\r\n\r\n/**\r\n * Log the given fatal message with the backend\r\n *\r\n * @export\r\n * @param {string} message\r\n */\r\nexport function LogFatal(message) {\r\n\tsendLogMessage('F', message);\r\n}\r\n\r\n/**\r\n * Sets the Log level to the given log level\r\n *\r\n * @export\r\n * @param {number} loglevel\r\n */\r\nexport function SetLogLevel(loglevel) {\r\n\tsendLogMessage('S', loglevel);\r\n}\r\n\r\n// Log levels\r\nexport const LogLevel = {\r\n\tTRACE: 1,\r\n\tDEBUG: 2,\r\n\tINFO: 3,\r\n\tWARNING: 4,\r\n\tERROR: 5,\r\n};\r\n", "/*\r\n _       __      _ __\r\n| |     / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n/* jshint esversion: 6 */\r\n\r\n// Defines a single listener with a maximum number of times to callback\r\n\r\n/**\r\n * The Listener class defines a listener! :-)\r\n *\r\n * @class Listener\r\n */\r\nclass Listener {\r\n    /**\r\n     * Creates an instance of Listener.\r\n     * @param {function} callback\r\n     * @param {number} maxCallbacks\r\n     * @memberof Listener\r\n     */\r\n    constructor(callback, maxCallbacks) {\r\n        // Default of -1 means infinite\r\n        maxCallbacks = maxCallbacks || -1;\r\n        // Callback invokes the callback with the given data\r\n        // Returns true if this listener should be destroyed\r\n        this.Callback = (data) => {\r\n            callback.apply(null, data);\r\n            // If maxCallbacks is infinite, return false (do not destroy)\r\n            if (maxCallbacks === -1) {\r\n                return false;\r\n            }\r\n            // Decrement maxCallbacks. Return true if now 0, otherwise false\r\n            maxCallbacks -= 1;\r\n            return maxCallbacks === 0;\r\n        };\r\n    }\r\n}\r\n\r\nexport const eventListeners = {};\r\n\r\n/**\r\n * Registers an event listener that will be invoked `maxCallbacks` times before being destroyed\r\n *\r\n * @export\r\n * @param {string} eventName\r\n * @param {function} callback\r\n * @param {number} maxCallbacks\r\n */\r\nexport function EventsOnMultiple(eventName, callback, maxCallbacks) {\r\n    eventListeners[eventName] = eventListeners[eventName] || [];\r\n    const thisListener = new Listener(callback, maxCallbacks);\r\n    eventListeners[eventName].push(thisListener);\r\n}\r\n\r\n/**\r\n * Registers an event listener that will be invoked every time the event is emitted\r\n *\r\n * @export\r\n * @param {string} eventName\r\n * @param {function} callback\r\n */\r\nexport function EventsOn(eventName, callback) {\r\n    EventsOnMultiple(eventName, callback, -1);\r\n}\r\n\r\n/**\r\n * Registers an event listener that will be invoked once then destroyed\r\n *\r\n * @export\r\n * @param {string} eventName\r\n * @param {function} callback\r\n */\r\nexport function EventsOnce(eventName, callback) {\r\n    EventsOnMultiple(eventName, callback, 1);\r\n}\r\n\r\nfunction notifyListeners(eventData) {\r\n\r\n    // Get the event name\r\n    let eventName = eventData.name;\r\n\r\n    // Check if we have any listeners for this event\r\n    if (eventListeners[eventName]) {\r\n\r\n        // Keep a list of listener indexes to destroy\r\n        const newEventListenerList = eventListeners[eventName].slice();\r\n\r\n        // Iterate listeners\r\n        for (let count = 0; count < eventListeners[eventName].length; count += 1) {\r\n\r\n            // Get next listener\r\n            const listener = eventListeners[eventName][count];\r\n\r\n            let data = eventData.data;\r\n\r\n            // Do the callback\r\n            const destroy = listener.Callback(data);\r\n            if (destroy) {\r\n                // if the listener indicated to destroy itself, add it to the destroy list\r\n                newEventListenerList.splice(count, 1);\r\n            }\r\n        }\r\n\r\n        // Update callbacks with new list of listeners\r\n        eventListeners[eventName] = newEventListenerList;\r\n    }\r\n}\r\n\r\n/**\r\n * Notify informs frontend listeners that an event was emitted with the given data\r\n *\r\n * @export\r\n * @param {string} notifyMessage - encoded notification message\r\n\r\n */\r\nexport function EventsNotify(notifyMessage) {\r\n    // Parse the message\r\n    let message;\r\n    try {\r\n        message = JSON.parse(notifyMessage);\r\n    } catch (e) {\r\n        const error = 'Invalid JSON passed to Notify: ' + notifyMessage;\r\n        throw new Error(error);\r\n    }\r\n    notifyListeners(message);\r\n}\r\n\r\n/**\r\n * Emit an event with the given name and data\r\n *\r\n * @export\r\n * @param {string} eventName\r\n */\r\nexport function EventsEmit(eventName) {\r\n\r\n    const payload = {\r\n        name: eventName,\r\n        data: [].slice.apply(arguments).slice(1),\r\n    };\r\n\r\n    // Notify JS listeners\r\n    notifyListeners(payload);\r\n\r\n    // Notify Go listeners\r\n    window.WailsInvoke('EE' + JSON.stringify(payload));\r\n}\r\n\r\nexport function EventsOff(eventName) {\r\n    // Remove local listeners\r\n    eventListeners.delete(eventName);\r\n\r\n    // Notify Go listeners\r\n    window.WailsInvoke('EX' + eventName);\r\n}", "/*\r\n _       __      _ __\r\n| |     / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n/* jshint esversion: 6 */\r\n\r\nexport const callbacks = {};\r\n\r\n/**\r\n * Returns a number from the native browser random function\r\n *\r\n * @returns number\r\n */\r\nfunction cryptoRandom() {\r\n\tvar array = new Uint32Array(1);\r\n\treturn window.crypto.getRandomValues(array)[0];\r\n}\r\n\r\n/**\r\n * Returns a number using da old-skool Math.Random\r\n * I likes to call it LOLRandom\r\n *\r\n * @returns number\r\n */\r\nfunction basicRandom() {\r\n\treturn Math.random() * 9007199254740991;\r\n}\r\n\r\n// Pick a random number function based on browser capability\r\nvar randomFunc;\r\nif (window.crypto) {\r\n\trandomFunc = cryptoRandom;\r\n} else {\r\n\trandomFunc = basicRandom;\r\n}\r\n\r\n\r\n/**\r\n * Call sends a message to the backend to call the binding with the\r\n * given data. A promise is returned and will be completed when the\r\n * backend responds. This will be resolved when the call was successful\r\n * or rejected if an error is passed back.\r\n * There is a timeout mechanism. If the call doesn't respond in the given\r\n * time (in milliseconds) then the promise is rejected.\r\n *\r\n * @export\r\n * @param {string} name\r\n * @param {any=} args\r\n * @param {number=} timeout\r\n * @returns\r\n */\r\nexport function Call(name, args, timeout) {\r\n\r\n\t// Timeout infinite by default\r\n\tif (timeout == null) {\r\n\t\ttimeout = 0;\r\n\t}\r\n\r\n\t// Create a promise\r\n\treturn new Promise(function (resolve, reject) {\r\n\r\n\t\t// Create a unique callbackID\r\n\t\tvar callbackID;\r\n\t\tdo {\r\n\t\t\tcallbackID = name + '-' + randomFunc();\r\n\t\t} while (callbacks[callbackID]);\r\n\r\n\t\tvar timeoutHandle;\r\n\t\t// Set timeout\r\n\t\tif (timeout > 0) {\r\n\t\t\ttimeoutHandle = setTimeout(function () {\r\n\t\t\t\treject(Error('Call to ' + name + ' timed out. Request ID: ' + callbackID));\r\n\t\t\t}, timeout);\r\n\t\t}\r\n\r\n\t\t// Store callback\r\n\t\tcallbacks[callbackID] = {\r\n\t\t\ttimeoutHandle: timeoutHandle,\r\n\t\t\treject: reject,\r\n\t\t\tresolve: resolve\r\n\t\t};\r\n\r\n\t\ttry {\r\n\t\t\tconst payload = {\r\n\t\t\t\tname,\r\n\t\t\t\targs,\r\n\t\t\t\tcallbackID,\r\n\t\t\t};\r\n\r\n\t\t\t// Make the call\r\n\t\t\twindow.WailsInvoke('C' + JSON.stringify(payload));\r\n\t\t} catch (e) {\r\n\t\t\t// eslint-disable-next-line\r\n\t\t\tconsole.error(e);\r\n\t\t}\r\n\t});\r\n}\r\n\r\n\r\n\r\n/**\r\n * Called by the backend to return data to a previously called\r\n * binding invocation\r\n *\r\n * @export\r\n * @param {string} incomingMessage\r\n */\r\nexport function Callback(incomingMessage) {\r\n\t// Decode the message - Credit: https://stackoverflow.com/a/13865680\r\n\t//incomingMessage = decodeURIComponent(incomingMessage.replace(/\\s+/g, '').replace(/[0-9a-f]{2}/g, '%$&'));\r\n\r\n\t// Parse the message\r\n\tvar message;\r\n\ttry {\r\n\t\tmessage = JSON.parse(incomingMessage);\r\n\t} catch (e) {\r\n\t\tconst error = `Invalid JSON passed to callback: ${e.message}. Message: ${incomingMessage}`;\r\n\t\twails.LogDebug(error);\r\n\t\tthrow new Error(error);\r\n\t}\r\n\tvar callbackID = message.callbackid;\r\n\tvar callbackData = callbacks[callbackID];\r\n\tif (!callbackData) {\r\n\t\tconst error = `Callback '${callbackID}' not registered!!!`;\r\n\t\tconsole.error(error); // eslint-disable-line\r\n\t\tthrow new Error(error);\r\n\t}\r\n\tclearTimeout(callbackData.timeoutHandle);\r\n\r\n\tdelete callbacks[callbackID];\r\n\r\n\tif (message.error) {\r\n\t\tcallbackData.reject(message.error);\r\n\t} else {\r\n\t\tcallbackData.resolve(message.result);\r\n\t}\r\n}\r\n", "/*\r\n _       __      _ __    \r\n| |     / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  ) \r\n|__/|__/\\__,_/_/_/____/  \r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n/* jshint esversion: 6 */\r\n\r\nimport {Call} from './calls';\r\n\r\n// This is where we bind go method wrappers\r\nwindow.go = {};\r\n\r\nexport function SetBindings(bindingsMap) {\r\n\ttry {\r\n\t\tbindingsMap = JSON.parse(bindingsMap);\r\n\t} catch (e) {\r\n\t\tconsole.error(e);\r\n\t}\r\n\r\n\t// Initialise the bindings map\r\n\twindow.go = window.go || {};\r\n\r\n\t// Iterate package names\r\n\tObject.keys(bindingsMap).forEach((packageName) => {\r\n\r\n\t\t// Create inner map if it doesn't exist\r\n\t\twindow.go[packageName] = window.go[packageName] || {};\r\n\r\n\t\t// Iterate struct names\r\n\t\tObject.keys(bindingsMap[packageName]).forEach((structName) => {\r\n\r\n\t\t\t// Create inner map if it doesn't exist\r\n\t\t\twindow.go[packageName][structName] = window.go[packageName][structName] || {};\r\n\r\n\t\t\tObject.keys(bindingsMap[packageName][structName]).forEach((methodName) => {\r\n\r\n\t\t\t\twindow.go[packageName][structName][methodName] = function () {\r\n\r\n\t\t\t\t\t// No timeout by default\r\n\t\t\t\t\tlet timeout = 0;\r\n\r\n\t\t\t\t\t// Actual function\r\n\t\t\t\t\tfunction dynamic() {\r\n\t\t\t\t\t\tconst args = [].slice.call(arguments);\r\n\t\t\t\t\t\treturn Call([packageName, structName, methodName].join('.'), args, timeout);\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\t// Allow setting timeout to function\r\n\t\t\t\t\tdynamic.setTimeout = function (newTimeout) {\r\n\t\t\t\t\t\ttimeout = newTimeout;\r\n\t\t\t\t\t};\r\n\r\n\t\t\t\t\t// Allow getting timeout to function\r\n\t\t\t\t\tdynamic.getTimeout = function () {\r\n\t\t\t\t\t\treturn timeout;\r\n\t\t\t\t\t};\r\n\r\n\t\t\t\t\treturn dynamic;\r\n\t\t\t\t}();\r\n\t\t\t});\r\n\t\t});\r\n\t});\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\n\r\nimport {Call} from \"./calls\";\r\n\r\nexport function WindowReload() {\r\n    window.location.reload();\r\n}\r\n\r\n/**\r\n * Place the window in the center of the screen\r\n *\r\n * @export\r\n */\r\nexport function WindowCenter() {\r\n    window.WailsInvoke('Wc');\r\n}\r\n\r\n/**\r\n * Sets the window title\r\n *\r\n * @param {string} title\r\n * @export\r\n */\r\nexport function WindowSetTitle(title) {\r\n    window.WailsInvoke('WT' + title);\r\n}\r\n\r\n/**\r\n * Makes the window go fullscreen\r\n *\r\n * @export\r\n */\r\nexport function WindowFullscreen() {\r\n    window.WailsInvoke('WF');\r\n}\r\n\r\n/**\r\n * Reverts the window from fullscreen\r\n *\r\n * @export\r\n */\r\nexport function WindowUnFullscreen() {\r\n    window.WailsInvoke('Wf');\r\n}\r\n\r\n/**\r\n * Set the Size of the window\r\n *\r\n * @export\r\n * @param {number} width\r\n * @param {number} height\r\n */\r\nexport function WindowSetSize(width, height) {\r\n    window.WailsInvoke('Ws:' + width + ':' + height);\r\n}\r\n\r\n/**\r\n * Get the Size of the window\r\n *\r\n * @export\r\n * @return {Promise<{w: number, h: number}>} The size of the window\r\n\r\n */\r\nexport function WindowGetSize() {\r\n    return Call(\":wails:WindowGetSize\");\r\n}\r\n\r\n/**\r\n * Set the maximum size of the window\r\n *\r\n * @export\r\n * @param {number} width\r\n * @param {number} height\r\n */\r\nexport function WindowSetMaxSize(width, height) {\r\n    window.WailsInvoke('WZ:' + width + ':' + height);\r\n}\r\n\r\n/**\r\n * Set the minimum size of the window\r\n *\r\n * @export\r\n * @param {number} width\r\n * @param {number} height\r\n */\r\nexport function WindowSetMinSize(width, height) {\r\n    window.WailsInvoke('Wz:' + width + ':' + height);\r\n}\r\n\r\n/**\r\n * Set the Position of the window\r\n *\r\n * @export\r\n * @param {number} x\r\n * @param {number} y\r\n */\r\nexport function WindowSetPosition(x, y) {\r\n    window.WailsInvoke('Wp:' + x + ':' + y);\r\n}\r\n\r\n/**\r\n * Get the Position of the window\r\n *\r\n * @export\r\n * @return {Promise<{x: number, y: number}>} The position of the window\r\n */\r\nexport function WindowGetPosition() {\r\n    return Call(\":wails:WindowGetPos\");\r\n}\r\n\r\n/**\r\n * Hide the Window\r\n *\r\n * @export\r\n */\r\nexport function WindowHide() {\r\n    window.WailsInvoke('WH');\r\n}\r\n\r\n/**\r\n * Show the Window\r\n *\r\n * @export\r\n */\r\nexport function WindowShow() {\r\n    window.WailsInvoke('WS');\r\n}\r\n\r\n/**\r\n * Maximise the Window\r\n *\r\n * @export\r\n */\r\nexport function WindowMaximise() {\r\n    window.WailsInvoke('WM');\r\n}\r\n\r\n/**\r\n * Unmaximise the Window\r\n *\r\n * @export\r\n */\r\nexport function WindowUnmaximise() {\r\n    window.WailsInvoke('WU');\r\n}\r\n\r\n/**\r\n * Minimise the Window\r\n *\r\n * @export\r\n */\r\nexport function WindowMinimise() {\r\n    window.WailsInvoke('Wm');\r\n}\r\n\r\n/**\r\n * Unminimise the Window\r\n *\r\n * @export\r\n */\r\nexport function WindowUnminimise() {\r\n    window.WailsInvoke('Wu');\r\n}\r\n\r\n\r\n/**\r\n * Sets the background colour of the window\r\n *\r\n * @export\r\n * @param {RGBA} RGBA background colour\r\n */\r\nexport function WindowSetRGBA(RGBA) {\r\n    let rgba = JSON.stringify(RGBA);\r\n    window.WailsInvoke('Wr:' + rgba);\r\n}\r\n\r\n\r\n/**\r\n * Close the Window\r\n *\r\n * @export\r\n */\r\nexport function WindowClose() {\r\n    window.WailsInvoke('WC');\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n/* jshint esversion: 9 */\r\nimport * as Log from './log';\r\nimport {eventListeners, EventsEmit, EventsNotify, EventsOff, EventsOn, EventsOnce, EventsOnMultiple} from './events';\r\nimport {Callback, callbacks} from './calls';\r\nimport {SetBindings} from \"./bindings\";\r\nimport * as Window from \"./window\";\r\n\r\n// The JS runtime\r\nwindow.runtime = {\r\n    ...Log,\r\n    ...Window,\r\n    EventsOn,\r\n    EventsOnce,\r\n    EventsOnMultiple,\r\n    EventsEmit,\r\n    EventsOff,\r\n};\r\n\r\n// Internal wails endpoints\r\nwindow.wails = {\r\n    Callback,\r\n    EventsNotify,\r\n    SetBindings,\r\n    eventListeners,\r\n    callbacks\r\n};\r\n\r\n// Set the bindings\r\nwindow.wails.SetBindings(window.wailsbindings);\r\ndelete window.wails.SetBindings;\r\n\r\n// This is evaluated at build time in package.json\r\nif (ENV === \"production\") {\r\n    delete window.wailsbindings;\r\n}\r\n\r\n// Setup drag handler\r\n// Based on code from: https://github.com/patr0nus/DeskGap\r\nwindow.addEventListener('mousedown', (e) => {\r\n    let currentElement = e.target;\r\n    while (currentElement != null) {\r\n        if (currentElement.hasAttribute('data-wails-no-drag')) {\r\n            break;\r\n        } else if (currentElement.hasAttribute('data-wails-drag')) {\r\n            window.WailsInvoke(\"drag\");\r\n            break;\r\n        }\r\n        currentElement = currentElement.parentElement;\r\n    }\r\n});\r\n"],
  "mappings": "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",
  "names": []
}
 diff --git a/v2/internal/frontend/runtime/runtime_prod_desktop.js b/v2/internal/frontend/runtime/runtime_prod_desktop.js index cdcea5c87..7fd78506c 100644 --- a/v2/internal/frontend/runtime/runtime_prod_desktop.js +++ b/v2/internal/frontend/runtime/runtime_prod_desktop.js @@ -1 +1 @@ -(()=>{var v=Object.defineProperty;var h=o=>v(o,"__esModule",{value:!0});var x=(o,n)=>{h(o);for(var e in n)v(o,e,{get:n[e],enumerable:!0})};var f={};x(f,{LogDebug:()=>R,LogError:()=>F,LogFatal:()=>J,LogInfo:()=>T,LogLevel:()=>G,LogPrint:()=>C,LogTrace:()=>b,LogWarning:()=>D,SetLogLevel:()=>z});function l(o,n){window.WailsInvoke("L"+o+n)}function b(o){l("T",o)}function C(o){l("P",o)}function R(o){l("D",o)}function T(o){l("I",o)}function D(o){l("W",o)}function F(o){l("E",o)}function J(o){l("F",o)}function z(o){l("S",o)}var G={TRACE:1,DEBUG:2,INFO:3,WARNING:4,ERROR:5};var g=class{constructor(n,e){e=e||-1,this.Callback=t=>(n.apply(null,t),e===-1?!1:(e-=1,e===0))}},s={};function a(o,n,e){s[o]=s[o]||[];let t=new g(n,e);s[o].push(t)}function E(o,n){a(o,n,-1)}function I(o,n){a(o,n,1)}function k(o){let n=o.name;if(s[n]){let e=s[n].slice();for(let t=0;t0&&(w=setTimeout(function(){r(Error("Call to "+o+" timed out. Request ID: "+i))},e)),c[i]={timeoutHandle:w,reject:r,resolve:t};try{let u={name:o,args:n,callbackID:i};window.WailsInvoke("C"+JSON.stringify(u))}catch(u){console.error(u)}})}function L(o){var n;try{n=JSON.parse(o)}catch(r){let i=`Invalid JSON passed to callback: ${r.message}. Message: ${o}`;throw wails.LogDebug(i),new Error(i)}var e=n.callbackid,t=c[e];if(!t){let r=`Callback '${e}' not registered!!!`;throw console.error(r),new Error(r)}clearTimeout(t.timeoutHandle),delete c[e],n.error?t.reject(n.error):t.resolve(n.result)}window.go={};function O(o){try{o=JSON.parse(o)}catch(n){console.error(n)}window.go=window.go||{},Object.keys(o).forEach(n=>{window.go[n]=window.go[n]||{},Object.keys(o[n]).forEach(e=>{window.go[n][e]=window.go[n][e]||{},Object.keys(o[n][e]).forEach(t=>{window.go[n][e][t]=function(){let r=0;function i(){let w=[].slice.call(arguments);return d([n,e,t].join("."),w,r)}return i.setTimeout=function(w){r=w},i.getTimeout=function(){return r},i}()})})})}var p={};x(p,{WindowCenter:()=>A,WindowClose:()=>eo,WindowFullscreen:()=>H,WindowGetPosition:()=>K,WindowGetSize:()=>V,WindowHide:()=>N,WindowMaximise:()=>Y,WindowMinimise:()=>oo,WindowReload:()=>j,WindowSetMaxSize:()=>q,WindowSetMinSize:()=>X,WindowSetPosition:()=>Z,WindowSetSize:()=>$,WindowSetTitle:()=>B,WindowShow:()=>Q,WindowUnFullscreen:()=>M,WindowUnmaximise:()=>_,WindowUnminimise:()=>no});function j(){window.location.reload()}function A(){window.WailsInvoke("Wc")}function B(o){window.WailsInvoke("WT"+o)}function H(){window.WailsInvoke("WF")}function M(){window.WailsInvoke("Wf")}function $(o,n){window.WailsInvoke("Ws:"+o+":"+n)}function V(){return d(":wails:WindowGetSize")}function q(o,n){window.WailsInvoke("WZ:"+o+":"+n)}function X(o,n){window.WailsInvoke("Wz:"+o+":"+n)}function Z(o,n){window.WailsInvoke("Wp:"+o+":"+n)}function K(){return d(":wails:WindowGetPos")}function N(){window.WailsInvoke("WH")}function Q(){window.WailsInvoke("WS")}function Y(){window.WailsInvoke("WM")}function _(){window.WailsInvoke("WU")}function oo(){window.WailsInvoke("Wm")}function no(){window.WailsInvoke("Wu")}function eo(){window.WailsInvoke("WC")}window.runtime={...f,...p,EventsOn:E,EventsOnce:I,EventsOnMultiple:a,EventsEmit:S,EventsOff:y};window.wails={Callback:L,EventsNotify:m,SetBindings:O,eventListeners:s,callbacks:c};window.wails.SetBindings(window.wailsbindings);delete window.wails.SetBindings;delete window.wailsbindings;window.addEventListener("mousedown",o=>{let n=o.target;for(;n!=null&&!n.hasAttribute("data-wails-no-drag");){if(n.hasAttribute("data-wails-drag")){window.WailsInvoke("drag");break}n=n.parentElement}});})(); +(()=>{var v=Object.defineProperty;var h=n=>v(n,"__esModule",{value:!0});var x=(n,o)=>{h(n);for(var e in o)v(n,e,{get:o[e],enumerable:!0})};var f={};x(f,{LogDebug:()=>C,LogError:()=>D,LogFatal:()=>F,LogInfo:()=>T,LogLevel:()=>z,LogPrint:()=>R,LogTrace:()=>b,LogWarning:()=>J,SetLogLevel:()=>G});function l(n,o){window.WailsInvoke("L"+n+o)}function b(n){l("T",n)}function R(n){l("P",n)}function C(n){l("D",n)}function T(n){l("I",n)}function J(n){l("W",n)}function D(n){l("E",n)}function F(n){l("F",n)}function G(n){l("S",n)}var z={TRACE:1,DEBUG:2,INFO:3,WARNING:4,ERROR:5};var g=class{constructor(o,e){e=e||-1,this.Callback=t=>(o.apply(null,t),e===-1?!1:(e-=1,e===0))}},s={};function a(n,o,e){s[n]=s[n]||[];let t=new g(o,e);s[n].push(t)}function E(n,o){a(n,o,-1)}function I(n,o){a(n,o,1)}function k(n){let o=n.name;if(s[o]){let e=s[o].slice();for(let t=0;t0&&(w=setTimeout(function(){r(Error("Call to "+n+" timed out. Request ID: "+i))},e)),c[i]={timeoutHandle:w,reject:r,resolve:t};try{let u={name:n,args:o,callbackID:i};window.WailsInvoke("C"+JSON.stringify(u))}catch(u){console.error(u)}})}function L(n){var o;try{o=JSON.parse(n)}catch(r){let i=`Invalid JSON passed to callback: ${r.message}. Message: ${n}`;throw wails.LogDebug(i),new Error(i)}var e=o.callbackid,t=c[e];if(!t){let r=`Callback '${e}' not registered!!!`;throw console.error(r),new Error(r)}clearTimeout(t.timeoutHandle),delete c[e],o.error?t.reject(o.error):t.resolve(o.result)}window.go={};function O(n){try{n=JSON.parse(n)}catch(o){console.error(o)}window.go=window.go||{},Object.keys(n).forEach(o=>{window.go[o]=window.go[o]||{},Object.keys(n[o]).forEach(e=>{window.go[o][e]=window.go[o][e]||{},Object.keys(n[o][e]).forEach(t=>{window.go[o][e][t]=function(){let r=0;function i(){let w=[].slice.call(arguments);return d([o,e,t].join("."),w,r)}return i.setTimeout=function(w){r=w},i.getTimeout=function(){return r},i}()})})})}var p={};x(p,{WindowCenter:()=>U,WindowClose:()=>tn,WindowFullscreen:()=>H,WindowGetPosition:()=>Z,WindowGetSize:()=>V,WindowHide:()=>K,WindowMaximise:()=>Y,WindowMinimise:()=>nn,WindowReload:()=>P,WindowSetMaxSize:()=>q,WindowSetMinSize:()=>N,WindowSetPosition:()=>X,WindowSetRGBA:()=>en,WindowSetSize:()=>$,WindowSetTitle:()=>j,WindowShow:()=>Q,WindowUnFullscreen:()=>M,WindowUnmaximise:()=>_,WindowUnminimise:()=>on});function P(){window.location.reload()}function U(){window.WailsInvoke("Wc")}function j(n){window.WailsInvoke("WT"+n)}function H(){window.WailsInvoke("WF")}function M(){window.WailsInvoke("Wf")}function $(n,o){window.WailsInvoke("Ws:"+n+":"+o)}function V(){return d(":wails:WindowGetSize")}function q(n,o){window.WailsInvoke("WZ:"+n+":"+o)}function N(n,o){window.WailsInvoke("Wz:"+n+":"+o)}function X(n,o){window.WailsInvoke("Wp:"+n+":"+o)}function Z(){return d(":wails:WindowGetPos")}function K(){window.WailsInvoke("WH")}function Q(){window.WailsInvoke("WS")}function Y(){window.WailsInvoke("WM")}function _(){window.WailsInvoke("WU")}function nn(){window.WailsInvoke("Wm")}function on(){window.WailsInvoke("Wu")}function en(n){let o=JSON.stringify(n);window.WailsInvoke("Wr:"+o)}function tn(){window.WailsInvoke("WC")}window.runtime={...f,...p,EventsOn:E,EventsOnce:I,EventsOnMultiple:a,EventsEmit:m,EventsOff:y};window.wails={Callback:L,EventsNotify:S,SetBindings:O,eventListeners:s,callbacks:c};window.wails.SetBindings(window.wailsbindings);delete window.wails.SetBindings;delete window.wailsbindings;window.addEventListener("mousedown",n=>{let o=n.target;for(;o!=null&&!o.hasAttribute("data-wails-no-drag");){if(o.hasAttribute("data-wails-drag")){window.WailsInvoke("drag");break}o=o.parentElement}});})(); diff --git a/v2/internal/frontend/runtime/wrapper/runtime.d.ts b/v2/internal/frontend/runtime/wrapper/runtime.d.ts index f9b5633c5..5f82914bb 100644 --- a/v2/internal/frontend/runtime/wrapper/runtime.d.ts +++ b/v2/internal/frontend/runtime/wrapper/runtime.d.ts @@ -8,6 +8,13 @@ interface Size { h: number; } +interface RGBA { + r, + g, + b, + a: number; +} + interface runtime { EventsEmit(eventName: string, data?: any): void; @@ -64,6 +71,8 @@ interface runtime { WindowUnminimise(): void + WindowSetRGBA(rgba: RGBA): void; + WindowClose(): void } diff --git a/v2/internal/frontend/runtime/wrapper/runtime.js b/v2/internal/frontend/runtime/wrapper/runtime.js index 14a2177b0..f94b7688a 100644 --- a/v2/internal/frontend/runtime/wrapper/runtime.js +++ b/v2/internal/frontend/runtime/wrapper/runtime.js @@ -1 +1 @@ -(()=>{var d=Object.defineProperty;var u=n=>d(n,"__esModule",{value:!0});var e=(n,i)=>{u(n);for(var o in i)d(n,o,{get:i[o],enumerable:!0})};var t={};e(t,{LogDebug:()=>W,LogError:()=>x,LogFatal:()=>f,LogInfo:()=>p,LogTrace:()=>m,LogWarning:()=>c});function m(n){window.runtime.LogTrace(n)}function W(n){window.runtime.LogDebug(n)}function p(n){window.runtime.LogInfo(n)}function c(n){window.runtime.LogWarning(n)}function x(n){window.runtime.LogError(n)}function f(n){window.runtime.LogFatal(n)}var w={};e(w,{EventsEmit:()=>g,EventsOn:()=>s,EventsOnMultiple:()=>l,EventsOnce:()=>a});function l(n,i,o){window.runtime.EventsOnMultiple(n,i,o)}function s(n,i){OnMultiple(n,i,-1)}function a(n,i){OnMultiple(n,i,1)}function g(n){let i=[n].slice.call(arguments);return window.runtime.EventsEmit.apply(null,i)}var r={};e(r,{WindowCenter:()=>L,WindowClose:()=>I,WindowFullscreen:()=>E,WindowGetPosition:()=>G,WindowGetSize:()=>z,WindowHide:()=>P,WindowMaximise:()=>b,WindowMinimise:()=>D,WindowReload:()=>S,WindowSetMaxSize:()=>O,WindowSetMinSize:()=>U,WindowSetPosition:()=>C,WindowSetSize:()=>F,WindowSetTitle:()=>M,WindowShow:()=>T,WindowUnFullscreen:()=>v,WindowUnmaximise:()=>h,WindowUnminimise:()=>H});function S(){window.runtime.WindowReload()}function L(){window.runtime.WindowCenter()}function M(n){window.runtime.WindowSetTitle(n)}function E(){window.runtime.WindowFullscreen()}function v(){window.runtime.WindowUnFullscreen()}function z(){window.runtime.WindowGetSize()}function F(n,i){window.runtime.WindowSetSize(n,i)}function O(n,i){window.runtime.WindowSetMaxSize(n,i)}function U(n,i){window.runtime.WindowSetMinSize(n,i)}function C(n,i){window.runtime.WindowSetPosition(n,i)}function G(){window.runtime.WindowGetPosition()}function P(){window.runtime.WindowHide()}function T(){window.runtime.WindowShow()}function b(){window.runtime.WindowMaximise()}function h(){window.runtime.WindowUnmaximise()}function D(){window.runtime.WindowMinimise()}function H(){window.runtime.WindowUnminimise()}function I(){window.runtime.WindowClose()}var y={...t,...w,...r};})(); +(()=>{var d=Object.defineProperty;var u=n=>d(n,"__esModule",{value:!0});var t=(n,i)=>{u(n);for(var o in i)d(n,o,{get:i[o],enumerable:!0})};var e={};t(e,{LogDebug:()=>W,LogError:()=>x,LogFatal:()=>f,LogInfo:()=>p,LogTrace:()=>m,LogWarning:()=>c});function m(n){window.runtime.LogTrace(n)}function W(n){window.runtime.LogDebug(n)}function p(n){window.runtime.LogInfo(n)}function c(n){window.runtime.LogWarning(n)}function x(n){window.runtime.LogError(n)}function f(n){window.runtime.LogFatal(n)}var w={};t(w,{EventsEmit:()=>S,EventsOn:()=>s,EventsOnMultiple:()=>l,EventsOnce:()=>a});function l(n,i,o){window.runtime.EventsOnMultiple(n,i,o)}function s(n,i){OnMultiple(n,i,-1)}function a(n,i){OnMultiple(n,i,1)}function S(n){let i=[n].slice.call(arguments);return window.runtime.EventsEmit.apply(null,i)}var r={};t(r,{WindowCenter:()=>L,WindowClose:()=>D,WindowFullscreen:()=>E,WindowGetPosition:()=>C,WindowGetSize:()=>z,WindowHide:()=>P,WindowMaximise:()=>T,WindowMinimise:()=>h,WindowReload:()=>g,WindowSetMaxSize:()=>G,WindowSetMinSize:()=>O,WindowSetPosition:()=>U,WindowSetRGBA:()=>B,WindowSetSize:()=>F,WindowSetTitle:()=>M,WindowShow:()=>R,WindowUnFullscreen:()=>v,WindowUnmaximise:()=>b,WindowUnminimise:()=>A});function g(){window.runtime.WindowReload()}function L(){window.runtime.WindowCenter()}function M(n){window.runtime.WindowSetTitle(n)}function E(){window.runtime.WindowFullscreen()}function v(){window.runtime.WindowUnFullscreen()}function z(){window.runtime.WindowGetSize()}function F(n,i){window.runtime.WindowSetSize(n,i)}function G(n,i){window.runtime.WindowSetMaxSize(n,i)}function O(n,i){window.runtime.WindowSetMinSize(n,i)}function U(n,i){window.runtime.WindowSetPosition(n,i)}function C(){window.runtime.WindowGetPosition()}function P(){window.runtime.WindowHide()}function R(){window.runtime.WindowShow()}function T(){window.runtime.WindowMaximise()}function b(){window.runtime.WindowUnmaximise()}function h(){window.runtime.WindowMinimise()}function A(){window.runtime.WindowUnminimise()}function B(n){window.runtime.WindowSetRGBA(n)}function D(){window.runtime.WindowClose()}var I={...e,...w,...r};})(); diff --git a/v2/internal/frontend/runtime/wrapper/window.js b/v2/internal/frontend/runtime/wrapper/window.js index ac59114ae..8593552f8 100644 --- a/v2/internal/frontend/runtime/wrapper/window.js +++ b/v2/internal/frontend/runtime/wrapper/window.js @@ -176,6 +176,16 @@ export function WindowUnminimise() { window.runtime.WindowUnminimise(); } +/** + * Sets the background colour of the window + * + * @export + * @param {RGBA} RGBA background colour + */ +export function WindowSetRGBA(RGBA) { + window.runtime.WindowSetRGBA(RGBA); +} + /** * Close the Window * diff --git a/v2/pkg/options/default.go b/v2/pkg/options/default.go index 79165401a..df3f3d52c 100644 --- a/v2/pkg/options/default.go +++ b/v2/pkg/options/default.go @@ -8,7 +8,6 @@ import ( var Default = &App{ Width: 1024, Height: 768, - RGBA: 0xFFFFFFFF, Logger: logger.NewDefaultLogger(), LogLevel: logger.INFO, } diff --git a/v2/pkg/options/options.go b/v2/pkg/options/options.go index 497fa6cc0..5d4528898 100644 --- a/v2/pkg/options/options.go +++ b/v2/pkg/options/options.go @@ -26,7 +26,7 @@ type App struct { MaxHeight int StartHidden bool HideWindowOnClose bool - RGBA int + RGBA *RGBA Assets embed.FS Menu *menu.Menu Logger logger.Logger `json:"-"` @@ -42,6 +42,13 @@ type App struct { //Mac *mac.Options } +type RGBA struct { + R uint8 `json:"r"` + G uint8 `json:"g"` + B uint8 `json:"b"` + A uint8 `json:"a"` +} + // MergeDefaults will set the minimum default values for an application func MergeDefaults(appoptions *App) { err := mergo.Merge(appoptions, Default) @@ -49,6 +56,16 @@ func MergeDefaults(appoptions *App) { log.Fatal(err) } + // DEfault colour. Doesn't work well with mergo + if appoptions.RGBA == nil { + appoptions.RGBA = &RGBA{ + R: 255, + G: 255, + B: 255, + A: 255, + } + } + // Ensure max and min are valid if appoptions.MinWidth > 0 && appoptions.MaxWidth > 0 { if appoptions.MinWidth > appoptions.MaxWidth { diff --git a/v2/pkg/runtime/window.go b/v2/pkg/runtime/window.go index d098b474d..6dd13df11 100644 --- a/v2/pkg/runtime/window.go +++ b/v2/pkg/runtime/window.go @@ -2,6 +2,7 @@ package runtime import ( "context" + "github.com/wailsapp/wails/v2/pkg/options" ) // WindowSetTitle sets the title of the window @@ -93,3 +94,8 @@ func WindowUnminimise(ctx context.Context) { appFrontend := getFrontend(ctx) appFrontend.WindowUnminimise() } + +func WindowSetRGBA(ctx context.Context, col *options.RGBA) { + appFrontend := getFrontend(ctx) + appFrontend.WindowSetRGBA(col) +}