diff --git a/mkdocs-website/docs/en/changelog.md b/mkdocs-website/docs/en/changelog.md index ae73370b4..99231f19c 100644 --- a/mkdocs-website/docs/en/changelog.md +++ b/mkdocs-website/docs/en/changelog.md @@ -24,6 +24,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ## v3.0.0-alpha.7 - 2024-09-18 ### Added +- [windows] New DIP system for Enhanced High DPI Monitor Support by [mmghv](https://github.com/mmghv) in [#3665](https://github.com/wailsapp/wails/pull/3665) - [windows] Window class name option by [windom](https://github.com/windom/) in [#3682](https://github.com/wailsapp/wails/pull/3682) - Services have been expanded to provide plugin functionality. By [atterpac](https://github.com/atterpac) and [leaanthony](https://github.com/leaanthony) in [#3570](https://github.com/wailsapp/wails/pull/3570) diff --git a/v3/examples/screen/assets/examples.js b/v3/examples/screen/assets/examples.js new file mode 100644 index 000000000..8abe3f0ca --- /dev/null +++ b/v3/examples/screen/assets/examples.js @@ -0,0 +1,206 @@ +window.examples = [ + [ + // Normal examples (demonstrate real life scenarios) + { + name: "Single 4k monitor", + screens: [ + {id: 1, w: 3840, h: 2160, s: 163.0 / 96, name: `27" 4K UHD 163DPI`}, + ] + }, + { + name: "Two monitors", + screens: [ + {id: 1, w: 3840, h: 2160, s: 163.0 / 96, name: `27" 4K UHD 163DPI`}, + {id: 2, w: 1920, h: 1080, s: 1, parent: {id: 1, align: "r", offset: 0}, name: `23" FHD 96DPI`}, + ] + }, + { + name: "Two monitors (2)", + screens: [ + {id: 1, w: 1920, h: 1080, s: 1, name: `23" FHD 96DPI`}, + {id: 2, w: 1920, h: 1080, s: 1.25, parent: {id: 1, align: "r", offset: 0}, name: `23" FHD 96DPI (125%)`}, + ] + }, + { + name: "Three monitors", + screens: [ + {id: 1, w: 3840, h: 2160, s: 163.0 / 96, name: `27" 4K UHD 163DPI`}, + {id: 2, w: 1920, h: 1080, s: 1, parent: {id: 1, align: "r", offset: 0}, name: `23" FHD 96DPI`}, + {id: 3, w: 1920, h: 1080, s: 1.25, parent: {id: 1, align: "l", offset: 0}, name: `23" FHD 96DPI (125%)`}, + ] + }, + { + name: "Four monitors", + screens: [ + {id: 1, w: 3840, h: 2160, s: 163.0 / 96, name: `27" 4K UHD 163DPI`}, + {id: 2, w: 1920, h: 1080, s: 1, parent: {id: 1, align: "r", offset: 0}, name: `23" FHD 96DPI`}, + {id: 3, w: 1920, h: 1080, s: 1.25, parent: {id: 2, align: "b", offset: 0}, name: `23" FHD 96DPI (125%)`}, + {id: 4, w: 1080, h: 1920, s: 1, parent: {id: 1, align: "l", offset: 0}, name: `23" FHD (90deg)`}, + ] + }, + ], + [ + // Test cases examples (demonstrate the algorithm basics) + { + name: "Child scaled, Start offset", + screens: [ + {id: 1, w: 1200, h: 1200, s: 1, name: "Parent"}, + {id: 2, w: 1200, h: 1200, s: 1.5, parent: {id: 1, align: "r", offset: 600}, name: "Child"}, + ] + }, + { + name: "Child scaled, End offset", + screens: [ + {id: 1, w: 1200, h: 1200, s: 1, name: "Parent"}, + {id: 2, w: 1200, h: 1200, s: 1.5, parent: {id: 1, align: "r", offset: -600}, name: "Child"}, + ] + }, + { + name: "Parent scaled, Start offset percent", + screens: [ + {id: 1, w: 1200, h: 1200, s: 1.5, name: "Parent"}, + {id: 2, w: 1200, h: 1200, s: 1, parent: {id: 1, align: "r", offset: 600}, name: "Child"}, + ] + }, + { + name: "Parent scaled, End offset percent", + screens: [ + {id: 1, w: 1200, h: 1200, s: 1.5, name: "Parent"}, + {id: 2, w: 1200, h: 1200, s: 1, parent: {id: 1, align: "r", offset: -600}, name: "Child"}, + ] + }, + { + name: "Parent scaled, Start align", + screens: [ + {id: 1, w: 1200, h: 1200, s: 1.5, name: "Parent"}, + {id: 2, w: 1200, h: 1100, s: 1, parent: {id: 1, align: "r", offset: 0}, name: "Child"}, + ] + }, + { + name: "Parent scaled, End align", + screens: [ + {id: 1, w: 1200, h: 1200, s: 1.5, name: "Parent"}, + {id: 2, w: 1200, h: 1200, s: 1, parent: {id: 1, align: "r", offset: 0}, name: "Child"}, + ] + }, + { + name: "Parent scaled, in-between", + screens: [ + {id: 1, w: 1200, h: 1200, s: 1.5, name: "Parent"}, + {id: 2, w: 1200, h: 1500, s: 1, parent: {id: 1, align: "r", offset: -200}, name: "Child"}, + ] + }, + ], + [ + // Edge cases examples + { + name: "Parent order (5 is parent of 4)", + screens: [ + {id: 1, w: 1920, h: 1080, s: 1}, + {id: 2, w: 1024, h: 600, s: 1.25, parent: {id: 1, align: "r", offset: -200}}, + {id: 3, w: 800, h: 800, s: 1.25, parent: {id: 2, align: "b", offset: 0}}, + {id: 4, w: 800, h: 1080, s: 1.5, parent: {id: 2, align: "re", offset: 100}}, + {id: 5, w: 600, h: 600, s: 1, parent: {id: 3, align: "r", offset: 100}}, + ] + }, + { + name: "de-intersection reparent", + screens: [ + {id: 1, w: 1920, h: 1080, s: 1}, + {id: 2, w: 1680, h: 1050, s: 1.25, parent: {id: 1, align: "r", offset: 10}}, + {id: 3, w: 1440, h: 900, s: 1.5, parent: {id: 1, align: "le", offset: 150}}, + {id: 4, w: 1024, h: 768, s: 1, parent: {id: 3, align: "bc", offset: -200}}, + {id: 5, w: 1024, h: 768, s: 1.25, parent: {id: 4, align: "r", offset: 400}}, + ] + }, + { + name: "de-intersection (unattached child)", + screens: [ + {id: 1, w: 1920, h: 1080, s: 1}, + {id: 2, w: 1024, h: 768, s: 1.5, parent: {id: 1, align: "le", offset: 10}}, + {id: 3, w: 1024, h: 768, s: 1.25, parent: {id: 2, align: "b", offset: 100}}, + {id: 4, w: 1024, h: 768, s: 1, parent: {id: 3, align: "r", offset: 500}}, + ] + }, + { + name: "Multiple de-intersection", + screens: [ + {id: 1, w: 1920, h: 1080, s: 1}, + {id: 2, w: 1024, h: 768, s: 1, parent: {id: 1, align: "be", offset: 0}}, + {id: 3, w: 1024, h: 768, s: 1, parent: {id: 2, align: "b", offset: 300}}, + {id: 4, w: 1024, h: 768, s: 1.5, parent: {id: 2, align: "le", offset: 100}}, + {id: 5, w: 1024, h: 768, s: 1, parent: {id: 4, align: "be", offset: 100}}, + ] + }, + { + name: "Multiple de-intersection (left-side)", + screens: [ + {id: 1, w: 1920, h: 1080, s: 1}, + {id: 2, w: 1024, h: 768, s: 1, parent: {id: 1, align: "le", offset: 0}}, + {id: 3, w: 1024, h: 768, s: 1, parent: {id: 2, align: "b", offset: 300}}, + {id: 4, w: 1024, h: 768, s: 1.5, parent: {id: 2, align: "le", offset: 100}}, + {id: 5, w: 1024, h: 768, s: 1, parent: {id: 4, align: "be", offset: 100}}, + ] + }, + { + name: "Parent de-intersection child offset", + screens: [ + {id: 1, w: 1600, h: 1600, s: 1.5}, + {id: 2, w: 800, h: 800, s: 1, parent: {id: 1, align: "r", offset: 0}}, + {id: 3, w: 800, h: 800, s: 1, parent: {id: 1, align: "r", offset: 800}}, + {id: 4, w: 800, h: 1600, s: 1, parent: {id: 2, align: "r", offset: 0}}, + ] + }, + ], +].map(sections => sections.map(layout => { + return parseLayout(layout) +})) + +function parseLayout(layout) { + const screens = [] + + for (const screen of layout.screens) { + let x = 0, y = 0 + const {w, h} = screen + + if (screen.parent) { + const parent = screens.find(s => s.ID == screen.parent.id).Bounds + const offset = screen.parent.offset + let align = screen.parent.align + let align2 = "" + + if (align.length == 2) { + align2 = align.charAt(1) + align = align.charAt(0) + } + + x = parent.X + y = parent.Y + // t: top, b: bottom, l: left, r: right, e: edge, c: corner + if (align == "t" || align == "b") { + x += offset + (align2 == "e" || align2 == "c" ? parent.Width : 0) - (align2 == "e" ? w : 0) + y += (align == "t" ? -h : parent.Height) + } else { + y += offset + (align2 == "e" || align2 == "c" ? parent.Height : 0) - (align2 == "e" ? h : 0) + x += (align == "l" ? -w : parent.Width) + } + } + + screens.push({ + ID: `${screen.id}`, + Name: screen.name ?? `Display${screen.id}`, + ScaleFactor: Math.round(screen.s * 100) / 100, + X: x, + Y: y, + Size: {Width: w, Height: h}, + Bounds: {X: x, Y: y, Width: w, Height: h}, + PhysicalBounds: {X: x, Y: y, Width: w, Height: h}, + WorkArea: {X: x, Y: y, Width: w, Height: h-Math.round(40*screen.s)}, + PhysicalWorkArea: {X: x, Y: y, Width: w, Height: h-Math.round(40*screen.s)}, + IsPrimary: screen.id == 1, + Rotation: 0 + }) + } + + return {name: layout.name, screens} +} diff --git a/v3/examples/screen/assets/index.html b/v3/examples/screen/assets/index.html index 72c73e83f..358624411 100644 --- a/v3/examples/screen/assets/index.html +++ b/v3/examples/screen/assets/index.html @@ -4,65 +4,138 @@ Screens Demo +
+ + +
+ +  X: + + +  Width: + + +   + + +   + + +   + +   + Layers: +
+
+
+
+ Screens:  + System + +  - Examples + : +   + + +
+
+ Coordinates:  + Physical (PX) + Logical (DIP) + + +   + + + + + +
+
+ + + + + + +
- + + + diff --git a/v3/examples/screen/assets/main.js b/v3/examples/screen/assets/main.js new file mode 100644 index 000000000..316c08002 --- /dev/null +++ b/v3/examples/screen/assets/main.js @@ -0,0 +1,406 @@ +setExamplesType(document.getElementById('examples-type').value, 0) + +function setExamplesType(type, autoSelectLayout = 1) { + window.examples_type = parseInt(type) + document.getElementById('examples-list').innerHTML = examples[examples_type].map((layout, i) => { + return `${i + 1}` + }).join("\n") + if (autoSelectLayout != null) setLayout(autoSelectLayout) +} + +async function setLayout(indexOrLayout, physicalCoordinate = true) { + if (typeof indexOrLayout == 'number') { + await radioBtnClick(null, `#layout-selector [data-value="${indexOrLayout}"]`) + } else { + document.querySelectorAll('#layout-selector .active').forEach(el => el.classList.remove('active')) + window.layout = indexOrLayout + window.point = null + window.rect = null + await processLayout() + await draw() + } + + const physical = !parseInt(document.querySelector('#coordinate-selector .active').dataset.value) + if (physical != physicalCoordinate) { + await setCoordinateType(physicalCoordinate) + } +} + +async function setCoordinateType(physicalCoordinate = true) { + await radioBtnClick(null, `#coordinate-selector [data-value="${physicalCoordinate ? 0 : 1}"]`) +} + +async function radioBtnClick(e, selector) { + if (e == null) { + e = new Event("mousedown") + document.querySelector(selector).dispatchEvent(e) + } + if (!e.target.classList.contains('radio-btn')) return + const btnGroup = e.target.closest('.radio-btn-group') + btnGroup.querySelectorAll('.radio-btn.active').forEach(el => el.classList.remove('active')) + e.target.classList.add('active') + + if (btnGroup.id == 'layout-selector') { + window.point = null + window.rect = null + await processLayout() + } + + await draw() +} + +async function processLayout() { + const layoutBtn = document.querySelector('#layout-selector .active') + const i = layoutBtn ? parseInt(layoutBtn.dataset.value) : -1 + if (i == 0) { + // system screens + window.layout = { + name: '', + screens: await callBinding('main.ScreenService.GetSystemScreens'), + } + } else { + if (i > 0) { + // example layouts + window.layout = structuredClone(examples[examples_type][i - 1]) + } + layout.screens = await callBinding('main.ScreenService.ProcessExampleScreens', layout.screens) + } + document.getElementById('example-name').textContent = layout.name +} + +async function draw() { + console.log(layout) + let minX = 0, minY = 0, maxX = 0, maxY = 0; + let html = ''; + + const physical = !parseInt(document.querySelector('#coordinate-selector .active').dataset.value) + const retainViewbox = document.querySelector('#retain-viewbox').checked + + layout.screens.forEach(screen => { + const b = physical ? screen.PhysicalBounds : screen.Bounds + const wa = physical ? screen.PhysicalWorkArea : screen.WorkArea + const vbBounds = retainViewbox ? [screen.Bounds, screen.PhysicalBounds] : [b] + + minX = Math.min(minX, ...vbBounds.map(b => b.X)) + minY = Math.min(minY, ...vbBounds.map(b => b.Y)) + maxX = Math.max(maxX, ...vbBounds.map(b => b.X + b.Width)) + maxY = Math.max(maxY, ...vbBounds.map(b => b.Y + b.Height)) + + html += ` + + + + + + (${b.X}, ${b.Y}) + + ${screen.Name} + ${b.Width} x ${b.Height} + Scale factor: ${screen.ScaleFactor} + + + ` + }) + + const svg = document.getElementById('svg') + svg.innerHTML = ` + ${svg.querySelector('& > defs').outerHTML} + + ${html} + + + ` + + svg.setAttribute('viewBox', `${minX} ${minY} ${maxX - minX} ${maxY - minY}`) + + if (window.point) await probePoint() + if (window.rect) await drawRect() + + svg.onmousedown = async function(e) { + let pt = new DOMPoint(e.clientX, e.clientY) + pt = pt.matrixTransform(svg.getScreenCTM().inverse()) + pt.x = parseInt(pt.x) + pt.y = parseInt(pt.y) + if (e.buttons == 1) { + await probePoint({X: pt.x, Y: pt.y}) + } else if (e.buttons == 2) { + if (e.ctrlKey) { + if (!window.rect) { + window.rect = {X: pt.x, Y: pt.y, Width: 0, Height: 0} + } + if (!window.rectCursor) { + window.rectAnchor = {x: window.rect.X, y: window.rect.Y} + window.rectCursor = {x: window.rectAnchor.x + window.rect.Width, y: window.rectAnchor.y + window.rect.Height} + } + window.rectCursorOffset = { + x: pt.x - window.rectCursor.x, + y: pt.y - window.rectCursor.y, + } + } else { + window.rectAnchor = pt + window.rectCursorOffset = {x: 0, y: 0} + window.probing = true + drawRect({X: pt.x, Y: pt.y, Width: 0, Height: 0}) + window.probing = false + } + } else if (e.buttons == 4) { + drawRect({X: pt.x, Y: pt.y, Width: 50, Height: 50}) + } + } + svg.onmousemove = async function(e) { + if (window.probing) return + window.probing = true + if (e.buttons == 1) { + await svg.onmousedown(e) + } else if (e.buttons == 2) { + let pt = new DOMPoint(e.clientX, e.clientY) + pt = pt.matrixTransform(svg.getScreenCTM().inverse()) + if (e.ctrlKey) { + window.rectAnchor.x += pt.x - rectCursor.x - window.rectCursorOffset.x + window.rectAnchor.y += pt.y - rectCursor.y - window.rectCursorOffset.y + } + window.rectCursor = { + x: pt.x - window.rectCursorOffset.x, + y: pt.y - window.rectCursorOffset.y, + } + await drawRect({ + X: parseInt(Math.min(window.rectAnchor.x, window.rectCursor.x)), + Y: parseInt(Math.min(window.rectAnchor.y, window.rectCursor.y)), + Width: parseInt(Math.abs(window.rectCursor.x - window.rectAnchor.x)), + Height: parseInt(Math.abs(window.rectCursor.y - window.rectAnchor.y)), + }) + } + window.probing = false + } + svg.oncontextmenu = function(e) { + e.preventDefault() + } +} + +async function probePoint(p = null) { + const svg = document.getElementById('svg'); + const physical = !parseInt(document.querySelector('#coordinate-selector .active').dataset.value) + + if (p == null) { + if (window.pointIsPhysical == physical) { + p = window.point + } else { + p = (await callBinding('main.ScreenService.TransformPoint', window.point, window.pointIsPhysical))[0] + } + } + + window.point = p + window.pointIsPhysical = physical + const [ptTransformed, ptDblTransformed] = await callBinding('main.ScreenService.TransformPoint', p, physical) + + svg.getElementById('points').innerHTML = ` + + + + + ` + // await new Promise((resolve) => setTimeout(resolve, 200)) // delay + return ptDblTransformed +} + +async function drawRect(r = null) { + const svg = document.getElementById('svg'); + const physical = !parseInt(document.querySelector('#coordinate-selector .active').dataset.value) + + if (r == null) { + if (window.rectIsPhysical == physical) { + r = window.rect + } else { + r = await callBinding('main.ScreenService.TransformRect', window.rect, window.rectIsPhysical) + } + } + + if (!window.probing) { + window.rectAnchor = null + window.rectCursor = null + } + + document.getElementById('x').value = r.X + document.getElementById('y').value = r.Y + document.getElementById('w').value = r.Width + document.getElementById('h').value = r.Height + + window.rect = r + window.rectIsPhysical = physical + window.rTransformed = await callBinding('main.ScreenService.TransformRect', r, physical) + window.rDblTransformed = await callBinding('main.ScreenService.TransformRect', rTransformed, !physical) + window.rTransformed = rTransformed + + await rectLayers() + return rDblTransformed +} + +async function rectLayers() { + const s = document.getElementById('slider').value + if (window.rect == null) await test1() + + const r = await callBinding('main.ScreenService.TransformRect', rectIsPhysical ? rect : rTransformed, true) + const rShifted = {...r, X: r.X+50} + const rShiftedPhysical = await callBinding('main.ScreenService.TransformRect', rShifted, false) + + svg.getElementById('rects').innerHTML = [ + [window.rect, 'rgb(255 255 255 / 100%)'], // w + [window.rTransformed, 'rgb(0 255 0 / 25%)'], // g + [window.rDblTransformed, 'none'], // none + [rShifted, 'rgb(255 0 0 / 15%)'], // r + [rShiftedPhysical, 'rgb(0 0 255 / 15%)'], // b + ].filter((_,i) => i { + let lines = '' + if (i == 0) { + const center = {X: r.X + (r.Width-1)/2, Y: r.Y + (r.Height-1)/2} + lines += ` + + + ` + } + return `${lines}` + }).join('/n') +} + +async function updateDipRect(x, y=0, w=0, h=0) { + if (rect == null) { + await drawRect({ + X: +document.getElementById('x').value, + Y: +document.getElementById('y').value, + Width: +document.getElementById('w').value, + Height: +document.getElementById('h').value, + }) + } + // Simulate real window by first retrieving the physical bounds then transforming it to dip + // then updating the bounds and transforming it back to physical + let rPhysical = rectIsPhysical ? rect : rTransformed + const r = await callBinding('main.ScreenService.TransformRect', rPhysical, true) + r.X += x + r.Y += y + r.Width += w + r.Height += h + rPhysical = await callBinding('main.ScreenService.TransformRect', r, false) + drawRect(rectIsPhysical ? rPhysical : r) +} + +function arrowMove(e) { + let x = 0, y = 0 + if (e.key == 'ArrowLeft') x = -step.value + if (e.key == 'ArrowRight') x = +step.value + if (e.key == 'ArrowUp') y = -step.value + if (e.key == 'ArrowDown') y = +step.value + if (!(x || y)) return + e.preventDefault() + updateDipRect(x, y) +} + +async function test1() { + // Edge case 1: invalid dip rect: no physical rect can produce it + await setLayout(parseLayout({screens: [ + {id: 1, w: 1200, h: 1200, s: 1}, + {id: 2, w: 1200, h: 1100, s: 1.5, parent: {id: 1, align: "r", offset: 0}}, + ]}), false) + await drawRect({X: 1050, Y: 700, Width: 400, Height: 300}) +} + +async function test2() { + // Edge case 2: physical rect that changes when double transformed (2 physical rects produce the same dip rect) + await setLayout(parseLayout({screens: [ + {id: 1, w: 1200, h: 1200, s: 1.5}, + {id: 2, w: 1200, h: 900, s: 1, parent: {id: 1, align: "r", offset: 0}}, + ]}), true) + await drawRect({X: 1050, Y: 890, Width: 400, Height: 300}) +} + +async function probeLayout(finishup = true) { + const probeButtons = document.getElementById('probe-buttons') + const svg = document.getElementById('svg') + const threshold = 1 + + const physical = !parseInt(document.querySelector('#coordinate-selector .active').dataset.value) + window.cancelProbing = false + probeButtons.classList.add('active') + + const steps = 3 + let failed = false + for (const screen of layout.screens) { + if (window.cancelProbing) break + const b = physical ? screen.PhysicalBounds : screen.Bounds + const xStep = parseInt(b.Width / steps) || 1 + const yStep = parseInt(b.Height / steps) || 1 + let x = b.X, y = b.Y + let xDone = false, yDone = false + + while (!(yDone || window.cancelProbing)) { + if (y >= b.Y + b.Height - 1) { + y = b.Y + b.Height - 1 + yDone = true + } + x = b.X + xDone = false + while (!(xDone || window.cancelProbing)) { + if (x >= b.X + b.Width - 1) { + x = b.X + b.Width - 1 + xDone = true + } + const pt = {X: x, Y: y} + let ptDblTransformed, err + try { + ptDblTransformed = await probePoint(pt) + } catch (e) { + err = e + } + if (err || Math.abs(pt.X - ptDblTransformed.X) > threshold || Math.abs(pt.Y - ptDblTransformed.Y) > threshold) { + failed = true + console.log(pt, ptDblTransformed) + window.cancelProbing = true + setTimeout(() => { + alert(err ?? `**FAILED**\nProbing failed at point: {X: ${pt.X}, Y: ${pt.Y}}\nDouble transformed point: {X: ${ptDblTransformed.X}, Y: ${ptDblTransformed.Y}}\n(Exceeded threshold of ${threshold} pixels)`) + }, 50) + } + x += xStep + } + y += yStep + } + } + + if (finishup || window.cancelProbing) probeButtons.classList.remove('active') + if (!(failed || window.cancelProbing)) { + window.point = null + if (finishup) { + setTimeout(() => { + svg.getElementById('points').innerHTML = '' + alert(`Successfully probed all points!, All within threshold of ${threshold} pixels.`) + }, 50) + } + return true + } +} + +async function probeAllExamples() { + console.time('probeAllExamples') +loop1: + for (let typeI = 0; typeI < examples.length; typeI++) { + document.getElementById('examples-type').value = typeI + setExamplesType(typeI, null) + + for (let layoutI = (typeI ? 0 : -1); layoutI < examples[typeI].length; layoutI++) { + await radioBtnClick(null, `#layout-selector [data-value="${layoutI + 1}"]`) + for (let i = 0; i < 2; i++) { + const lastLayout = (typeI == examples.length - 1 && layoutI == examples[typeI].length - 1 && i == 1) + if (!await probeLayout(lastLayout)) break loop1 + if (i == 0) await setCoordinateType(!pointIsPhysical) + } + } + } + console.timeEnd('probeAllExamples') +} + +async function callBinding(name, ...params) { + return wails.Call.ByName(name, ...params) +} + +function showAdvanced(e) { + e.target.style.display = 'none' + document.querySelectorAll('.advanced').forEach(el => el.style.display = 'initial') +} diff --git a/v3/examples/screen/main.go b/v3/examples/screen/main.go index 1f9821d29..9207280d9 100644 --- a/v3/examples/screen/main.go +++ b/v3/examples/screen/main.go @@ -2,8 +2,12 @@ package main import ( "embed" - _ "embed" "log" + "log/slog" + "net/http" + "os" + "path/filepath" + "runtime" "github.com/wailsapp/wails/v3/pkg/application" ) @@ -25,8 +29,33 @@ func main() { WebviewUserDataPath: "", WebviewBrowserPath: "", }, + Services: []application.Service{ + application.NewService(&ScreenService{}), + }, + LogLevel: slog.LevelError, Assets: application.AssetOptions{ Handler: application.BundledAssetFileServer(assets), + Middleware: func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + // Disable caching + w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate") + w.Header().Set("Pragma", "no-cache") + w.Header().Set("Expires", "0") + + _, filename, _, _ := runtime.Caller(0) + dir := filepath.Dir(filename) + url := r.URL.Path + path := dir + "/assets" + url + + if _, err := os.Stat(path); err == nil { + // Serve file from disk to make testing easy + http.ServeFile(w, r, path) + } else { + // Passthrough to the default asset handler if file not found on disk + next.ServeHTTP(w, r) + } + }) + }, }, }) diff --git a/v3/examples/screen/screens.go b/v3/examples/screen/screens.go new file mode 100644 index 000000000..0f1f599f6 --- /dev/null +++ b/v3/examples/screen/screens.go @@ -0,0 +1,129 @@ +package main + +import ( + "runtime" + + "github.com/wailsapp/wails/v3/pkg/application" +) + +type ScreenService struct { + screenManager application.ScreenManager + isExampleLayout bool +} + +func (s *ScreenService) GetSystemScreens() []*application.Screen { + s.isExampleLayout = false + screens, _ := application.Get().GetScreens() + return screens +} + +func (s *ScreenService) ProcessExampleScreens(rawScreens []interface{}) []*application.Screen { + s.isExampleLayout = true + + parseRect := func(m map[string]interface{}) application.Rect { + return application.Rect{ + X: int(m["X"].(float64)), + Y: int(m["Y"].(float64)), + Width: int(m["Width"].(float64)), + Height: int(m["Height"].(float64)), + } + } + + screens := []*application.Screen{} + for _, s := range rawScreens { + s := s.(map[string]interface{}) + + bounds := parseRect(s["Bounds"].(map[string]interface{})) + + screens = append(screens, &application.Screen{ + ID: s["ID"].(string), + Name: s["Name"].(string), + X: bounds.X, + Y: bounds.Y, + Size: application.Size{Width: bounds.Width, Height: bounds.Height}, + Bounds: bounds, + PhysicalBounds: parseRect(s["PhysicalBounds"].(map[string]interface{})), + WorkArea: parseRect(s["WorkArea"].(map[string]interface{})), + PhysicalWorkArea: parseRect(s["PhysicalWorkArea"].(map[string]interface{})), + IsPrimary: s["IsPrimary"].(bool), + ScaleFactor: float32(s["ScaleFactor"].(float64)), + Rotation: 0, + }) + } + + s.screenManager.LayoutScreens(screens) + return s.screenManager.Screens() +} + +func (s *ScreenService) transformPoint(point application.Point, toDIP bool) application.Point { + if s.isExampleLayout { + if toDIP { + return s.screenManager.PhysicalToDipPoint(point) + } else { + return s.screenManager.DipToPhysicalPoint(point) + } + } else { + // ======================= + // TODO: remove this block when DPI is implemented in Linux & Mac + if runtime.GOOS != "windows" { + println("DPI not implemented yet!") + return point + } + // ======================= + if toDIP { + return application.PhysicalToDipPoint(point) + } else { + return application.DipToPhysicalPoint(point) + } + } +} + +func (s *ScreenService) TransformPoint(point map[string]interface{}, toDIP bool) (points [2]application.Point) { + pt := application.Point{ + X: int(point["X"].(float64)), + Y: int(point["Y"].(float64)), + } + + ptTransformed := s.transformPoint(pt, toDIP) + ptDblTransformed := s.transformPoint(ptTransformed, !toDIP) + + // double-transform multiple times to catch any double-rounding issues + for i := 0; i < 10; i++ { + ptTransformed = s.transformPoint(ptDblTransformed, toDIP) + ptDblTransformed = s.transformPoint(ptTransformed, !toDIP) + } + + points[0] = ptTransformed + points[1] = ptDblTransformed + return points +} + +func (s *ScreenService) TransformRect(rect map[string]interface{}, toDIP bool) application.Rect { + r := application.Rect{ + X: int(rect["X"].(float64)), + Y: int(rect["Y"].(float64)), + Width: int(rect["Width"].(float64)), + Height: int(rect["Height"].(float64)), + } + + if s.isExampleLayout { + if toDIP { + return s.screenManager.PhysicalToDipRect(r) + } else { + return s.screenManager.DipToPhysicalRect(r) + } + } else { + // ======================= + // TODO: remove this block when DPI is implemented in Linux & Mac + if runtime.GOOS != "windows" { + println("DPI not implemented yet!") + return r + } + // ======================= + if toDIP { + return application.PhysicalToDipRect(r) + } else { + return application.DipToPhysicalRect(r) + } + } +} diff --git a/v3/examples/systray/main.go b/v3/examples/systray/main.go index 6b3567b15..94cf3de34 100644 --- a/v3/examples/systray/main.go +++ b/v3/examples/systray/main.go @@ -23,7 +23,7 @@ func main() { _ = app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ Width: 500, - Height: 800, + Height: 500, Name: "Systray Demo Window", Frameless: true, AlwaysOnTop: true, diff --git a/v3/examples/window/assets/index.html b/v3/examples/window/assets/index.html new file mode 100644 index 000000000..16baa68ff --- /dev/null +++ b/v3/examples/window/assets/index.html @@ -0,0 +1,90 @@ + + + + + + Window Demo + + + + + +
+
+ +
+
+
+ +
+ +  X: + + +  Width: + + +   + + +
+ + + +   + + + +   + +
+ + + + + + \ No newline at end of file diff --git a/v3/examples/window/main.go b/v3/examples/window/main.go index 3ed305a3c..f062f9a0f 100644 --- a/v3/examples/window/main.go +++ b/v3/examples/window/main.go @@ -1,7 +1,7 @@ package main import ( - _ "embed" + "embed" "fmt" "log" "math/rand" @@ -20,14 +20,69 @@ var getExStyle = func() int { return 0 } +//go:embed assets/* +var assets embed.FS + +type WindowService struct{} + +// ============================================== +func (s *WindowService) SetPos(relative bool, x, y float64) { + win := application.Get().CurrentWindow() + initX, initY := win.Position() + if relative { + x += float64(initX) + y += float64(initY) + } + win.SetPosition(int(x), int(y)) + currentX, currentY := win.Position() + fmt.Printf("SetPos: %d, %d => %d, %d\n", initX, initY, currentX, currentY) +} +func (s *WindowService) SetSize(relative bool, wdt, hgt float64) { + win := application.Get().CurrentWindow() + initW, initH := win.Size() + if relative { + wdt += float64(initW) + hgt += float64(initH) + } + win.SetSize(int(wdt), int(hgt)) + currentW, currentH := win.Size() + fmt.Printf("SetSize: %d, %d => %d, %d\n", initW, initH, currentW, currentH) +} +func (s *WindowService) SetBounds(x, y, w, h float64) { + win := application.Get().CurrentWindow() + initR := win.Bounds() + win.SetBounds(application.Rect{ + X: int(x), + Y: int(y), + Width: int(w), + Height: int(h), + }) + currentR := win.Bounds() + fmt.Printf("SetBounds: %+v => %+v\n", initR, currentR) +} +func (s *WindowService) GetBounds() application.Rect { + win := application.Get().CurrentWindow() + r := win.Bounds() + mid := r.X + (r.Width-1)/2 + fmt.Printf("GetBounds: %+v: mid: %d\n", r, mid) + return r +} + +// ============================================== + func main() { app := application.New(application.Options{ Name: "WebviewWindow Demo", Description: "A demo of the WebviewWindow API", - Assets: application.AlphaAssets, + Assets: application.AssetOptions{ + Handler: application.BundledAssetFileServer(assets), + }, Mac: application.MacOptions{ ApplicationShouldTerminateAfterLastWindowClosed: false, }, + Services: []application.Service{ + application.NewService(&WindowService{}), + }, }) app.OnApplicationEvent(events.Common.ApplicationStarted, func(event *application.ApplicationEvent) { log.Println("ApplicationDidFinishLaunching") @@ -403,6 +458,12 @@ func main() { w.SetRelativePosition(0, 0) }) }) + positionMenu.Add("Set Relative Position (Corner)").OnClick(func(ctx *application.Context) { + currentWindow(func(w *application.WebviewWindow) { + screen, _ := w.GetScreen() + w.SetRelativePosition(screen.WorkArea.Width-w.Width(), screen.WorkArea.Height-w.Height()) + }) + }) positionMenu.Add("Set Relative Position (Random)").OnClick(func(ctx *application.Context) { currentWindow(func(w *application.WebviewWindow) { w.SetRelativePosition(rand.Intn(1000), rand.Intn(800)) @@ -585,6 +646,7 @@ func main() { }) app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + Title: "Window Demo", BackgroundColour: application.NewRGB(33, 37, 41), Mac: application.MacWindow{ DisableShadow: true, diff --git a/v3/internal/assetserver/bundledassets/runtime.debug.js b/v3/internal/assetserver/bundledassets/runtime.debug.js index 63e3c7fbb..f6ad3ee7b 100644 --- a/v3/internal/assetserver/bundledassets/runtime.debug.js +++ b/v3/internal/assetserver/bundledassets/runtime.debug.js @@ -1602,4 +1602,4 @@ export { wml_exports as WML, window_default as Window }; -//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../runtime/desktop/@wailsio/runtime/src/index.js", "../../runtime/desktop/@wailsio/runtime/src/wml.js", "../../runtime/desktop/@wailsio/runtime/src/browser.js", "../../runtime/node_modules/nanoid/non-secure/index.js", "../../runtime/desktop/@wailsio/runtime/src/runtime.js", "../../runtime/desktop/@wailsio/runtime/src/dialogs.js", "../../runtime/desktop/@wailsio/runtime/src/events.js", "../../runtime/desktop/@wailsio/runtime/src/event_types.js", "../../runtime/desktop/@wailsio/runtime/src/utils.js", "../../runtime/desktop/@wailsio/runtime/src/window.js", "../../runtime/desktop/compiled/main.js", "../../runtime/desktop/@wailsio/runtime/src/system.js", "../../runtime/desktop/@wailsio/runtime/src/contextmenu.js", "../../runtime/desktop/@wailsio/runtime/src/flags.js", "../../runtime/desktop/@wailsio/runtime/src/drag.js", "../../runtime/desktop/@wailsio/runtime/src/application.js", "../../runtime/desktop/@wailsio/runtime/src/calls.js", "../../runtime/desktop/@wailsio/runtime/src/clipboard.js", "../../runtime/desktop/@wailsio/runtime/src/create.js", "../../runtime/desktop/@wailsio/runtime/src/screens.js"],
  "sourcesContent": ["/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n// Setup\nwindow._wails = window._wails || {};\n\nimport \"./contextmenu\";\nimport \"./drag\";\n\n// Re-export public API\nimport * as Application from \"./application\";\nimport * as Browser from \"./browser\";\nimport * as Call from \"./calls\";\nimport * as Clipboard from \"./clipboard\";\nimport * as Create from \"./create\";\nimport * as Dialogs from \"./dialogs\";\nimport * as Events from \"./events\";\nimport * as Flags from \"./flags\";\nimport * as Screens from \"./screens\";\nimport * as System from \"./system\";\nimport Window from \"./window\";\nimport * as WML from \"./wml\";\n\nexport {\n    Application,\n    Browser,\n    Call,\n    Clipboard,\n    Create,\n    Dialogs,\n    Events,\n    Flags,\n    Screens,\n    System,\n    Window,\n    WML\n};\n\n// Notify backend\nwindow._wails.invoke = System.invoke;\nSystem.invoke(\"wails:runtime:ready\");\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport {OpenURL} from \"./browser\";\nimport {Question} from \"./dialogs\";\nimport {Emit, WailsEvent} from \"./events\";\nimport {canAbortListeners, whenReady} from \"./utils\";\nimport Window from \"./window\";\n\n/**\n * Sends an event with the given name and optional data.\n *\n * @param {string} eventName - The name of the event to send.\n * @param {any} [data=null] - Optional data to send along with the event.\n *\n * @return {void}\n */\nfunction sendEvent(eventName, data=null) {\n    Emit(new WailsEvent(eventName, data));\n}\n\n/**\n * Calls a method on a specified window.\n * @param {string} windowName - The name of the window to call the method on.\n * @param {string} methodName - The name of the method to call.\n */\nfunction callWindowMethod(windowName, methodName) {\n    const targetWindow = Window.Get(windowName);\n    const method = targetWindow[methodName];\n\n    if (typeof method !== \"function\") {\n        console.error(`Window method '${methodName}' not found`);\n        return;\n    }\n\n    try {\n        method.call(targetWindow);\n    } catch (e) {\n        console.error(`Error calling window method '${methodName}': `, e);\n    }\n}\n\n/**\n * Responds to a triggering event by running appropriate WML actions for the current target\n *\n * @param {Event} ev\n * @return {void}\n */\nfunction onWMLTriggered(ev) {\n    const element = ev.currentTarget;\n\n    function runEffect(choice = \"Yes\") {\n        if (choice !== \"Yes\")\n            return;\n\n        const eventType = element.getAttribute('wml-event');\n        const targetWindow = element.getAttribute('wml-target-window') || \"\";\n        const windowMethod = element.getAttribute('wml-window');\n        const url = element.getAttribute('wml-openurl');\n\n        if (eventType !== null)\n            sendEvent(eventType);\n        if (windowMethod !== null)\n            callWindowMethod(targetWindow, windowMethod);\n        if (url !== null)\n            void OpenURL(url);\n    }\n\n    const confirm = element.getAttribute('wml-confirm');\n\n    if (confirm) {\n        Question({\n            Title: \"Confirm\",\n            Message: confirm,\n            Detached: false,\n            Buttons: [\n                { Label: \"Yes\" },\n                { Label: \"No\", IsDefault: true }\n            ]\n        }).then(runEffect);\n    } else {\n        runEffect();\n    }\n}\n\n/**\n * @type {symbol}\n */\nconst controller = Symbol();\n\n/**\n * AbortControllerRegistry does not actually remember active event listeners: instead\n * it ties them to an AbortSignal and uses an AbortController to remove them all at once.\n */\nclass AbortControllerRegistry {\n    constructor() {\n        /**\n         * Stores the AbortController that can be used to remove all currently active listeners.\n         *\n         * @private\n         * @name {@link controller}\n         * @member {AbortController}\n         */\n        this[controller] = new AbortController();\n    }\n\n    /**\n     * Returns an options object for addEventListener that ties the listener\n     * to the AbortSignal from the current AbortController.\n     *\n     * @param {HTMLElement} element An HTML element\n     * @param {string[]} triggers The list of active WML trigger events for the specified elements\n     * @returns {AddEventListenerOptions}\n     */\n    set(element, triggers) {\n        return { signal: this[controller].signal };\n    }\n\n    /**\n     * Removes all registered event listeners.\n     *\n     * @returns {void}\n     */\n    reset() {\n        this[controller].abort();\n        this[controller] = new AbortController();\n    }\n}\n\n/**\n * @type {symbol}\n */\nconst triggerMap = Symbol();\n\n/**\n * @type {symbol}\n */\nconst elementCount = Symbol();\n\n/**\n * WeakMapRegistry maps active trigger events to each DOM element through a WeakMap.\n * This ensures that the mapping remains private to this module, while still allowing garbage\n * collection of the involved elements.\n */\nclass WeakMapRegistry {\n    constructor() {\n        /**\n         * Stores the current element-to-trigger mapping.\n         *\n         * @private\n         * @name {@link triggerMap}\n         * @member {WeakMap<HTMLElement, string[]>}\n         */\n        this[triggerMap] = new WeakMap();\n\n        /**\n         * Counts the number of elements with active WML triggers.\n         *\n         * @private\n         * @name {@link elementCount}\n         * @member {number}\n         */\n        this[elementCount] = 0;\n    }\n\n    /**\n     * Sets the active triggers for the specified element.\n     *\n     * @param {HTMLElement} element An HTML element\n     * @param {string[]} triggers The list of active WML trigger events for the specified element\n     * @returns {AddEventListenerOptions}\n     */\n    set(element, triggers) {\n        this[elementCount] += !this[triggerMap].has(element);\n        this[triggerMap].set(element, triggers);\n        return {};\n    }\n\n    /**\n     * Removes all registered event listeners.\n     *\n     * @returns {void}\n     */\n    reset() {\n        if (this[elementCount] <= 0)\n            return;\n\n        for (const element of document.body.querySelectorAll('*')) {\n            if (this[elementCount] <= 0)\n                break;\n\n            const triggers = this[triggerMap].get(element);\n            this[elementCount] -= (typeof triggers !== \"undefined\");\n\n            for (const trigger of triggers || [])\n                element.removeEventListener(trigger, onWMLTriggered);\n        }\n\n        this[triggerMap] = new WeakMap();\n        this[elementCount] = 0;\n    }\n}\n\nconst triggerRegistry = canAbortListeners() ? new AbortControllerRegistry() : new WeakMapRegistry();\n\n/**\n * Adds event listeners to the specified element.\n *\n * @param {HTMLElement} element\n * @return {void}\n */\nfunction addWMLListeners(element) {\n    const triggerRegExp = /\\S+/g;\n    const triggerAttr = (element.getAttribute('wml-trigger') || \"click\");\n    const triggers = [];\n\n    let match;\n    while ((match = triggerRegExp.exec(triggerAttr)) !== null)\n        triggers.push(match[0]);\n\n    const options = triggerRegistry.set(element, triggers);\n    for (const trigger of triggers)\n        element.addEventListener(trigger, onWMLTriggered, options);\n}\n\n/**\n * Schedules an automatic reload of WML to be performed as soon as the document is fully loaded.\n *\n * @return {void}\n */\nexport function Enable() {\n    whenReady(Reload);\n}\n\n/**\n * Reloads the WML page by adding necessary event listeners and browser listeners.\n *\n * @return {void}\n */\nexport function Reload() {\n    triggerRegistry.reset();\n    document.body.querySelectorAll('[wml-event], [wml-window], [wml-openurl]').forEach(addWMLListeners);\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\n\nconst call = newRuntimeCallerWithID(objectNames.Browser, '');\nconst BrowserOpenURL = 0;\n\n/**\n * Open a browser window to the given URL\n * @param {string} url - The URL to open\n * @returns {Promise<string>}\n */\nexport function OpenURL(url) {\n    return call(BrowserOpenURL, {url});\n}\n", "let urlAlphabet =\n  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'\nexport let customAlphabet = (alphabet, defaultSize = 21) => {\n  return (size = defaultSize) => {\n    let id = ''\n    let i = size\n    while (i--) {\n      id += alphabet[(Math.random() * alphabet.length) | 0]\n    }\n    return id\n  }\n}\nexport let nanoid = (size = 21) => {\n  let id = ''\n  let i = size\n  while (i--) {\n    id += urlAlphabet[(Math.random() * 64) | 0]\n  }\n  return id\n}\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\nimport { nanoid } from 'nanoid/non-secure';\n\nconst runtimeURL = window.location.origin + \"/wails/runtime\";\n\n// Object Names\nexport const objectNames = {\n    Call: 0,\n    Clipboard: 1,\n    Application: 2,\n    Events: 3,\n    ContextMenu: 4,\n    Dialog: 5,\n    Window: 6,\n    Screens: 7,\n    System: 8,\n    Browser: 9,\n    CancelCall: 10,\n}\nexport let clientId = nanoid();\n\n/**\n * Creates a runtime caller function that invokes a specified method on a given object within a specified window context.\n *\n * @param {Object} object - The object on which the method is to be invoked.\n * @param {string} windowName - The name of the window context in which the method should be called.\n * @returns {Function} A runtime caller function that takes the method name and optionally arguments and invokes the method within the specified window context.\n */\nexport function newRuntimeCaller(object, windowName) {\n    return function (method, args=null) {\n        return runtimeCall(object + \".\" + method, windowName, args);\n    };\n}\n\n/**\n * Creates a new runtime caller with specified ID.\n *\n * @param {object} object - The object to invoke the method on.\n * @param {string} windowName - The name of the window.\n * @return {Function} - The new runtime caller function.\n */\nexport function newRuntimeCallerWithID(object, windowName) {\n    return function (method, args=null) {\n        return runtimeCallWithID(object, method, windowName, args);\n    };\n}\n\n\nfunction runtimeCall(method, windowName, args) {\n    let url = new URL(runtimeURL);\n    if( method ) {\n        url.searchParams.append(\"method\", method);\n    }\n    let fetchOptions = {\n        headers: {},\n    };\n    if (windowName) {\n        fetchOptions.headers[\"x-wails-window-name\"] = windowName;\n    }\n    if (args) {\n        url.searchParams.append(\"args\", JSON.stringify(args));\n    }\n    fetchOptions.headers[\"x-wails-client-id\"] = clientId;\n\n    return new Promise((resolve, reject) => {\n        fetch(url, fetchOptions)\n            .then(response => {\n                if (response.ok) {\n                    // check content type\n                    if (response.headers.get(\"Content-Type\") && response.headers.get(\"Content-Type\").indexOf(\"application/json\") !== -1) {\n                        return response.json();\n                    } else {\n                        return response.text();\n                    }\n                }\n                reject(Error(response.statusText));\n            })\n            .then(data => resolve(data))\n            .catch(error => reject(error));\n    });\n}\n\nfunction runtimeCallWithID(objectID, method, windowName, args) {\n    let url = new URL(runtimeURL);\n    url.searchParams.append(\"object\", objectID);\n    url.searchParams.append(\"method\", method);\n    let fetchOptions = {\n        headers: {},\n    };\n    if (windowName) {\n        fetchOptions.headers[\"x-wails-window-name\"] = windowName;\n    }\n    if (args) {\n        url.searchParams.append(\"args\", JSON.stringify(args));\n    }\n    fetchOptions.headers[\"x-wails-client-id\"] = clientId;\n    return new Promise((resolve, reject) => {\n        fetch(url, fetchOptions)\n            .then(response => {\n                if (response.ok) {\n                    // check content type\n                    if (response.headers.get(\"Content-Type\") && response.headers.get(\"Content-Type\").indexOf(\"application/json\") !== -1) {\n                        return response.json();\n                    } else {\n                        return response.text();\n                    }\n                }\n                reject(Error(response.statusText));\n            })\n            .then(data => resolve(data))\n            .catch(error => reject(error));\n    });\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\n/**\n * @typedef {Object} OpenFileDialogOptions\n * @property {boolean} [CanChooseDirectories] - Indicates if directories can be chosen.\n * @property {boolean} [CanChooseFiles] - Indicates if files can be chosen.\n * @property {boolean} [CanCreateDirectories] - Indicates if directories can be created.\n * @property {boolean} [ShowHiddenFiles] - Indicates if hidden files should be shown.\n * @property {boolean} [ResolvesAliases] - Indicates if aliases should be resolved.\n * @property {boolean} [AllowsMultipleSelection] - Indicates if multiple selection is allowed.\n * @property {boolean} [HideExtension] - Indicates if the extension should be hidden.\n * @property {boolean} [CanSelectHiddenExtension] - Indicates if hidden extensions can be selected.\n * @property {boolean} [TreatsFilePackagesAsDirectories] - Indicates if file packages should be treated as directories.\n * @property {boolean} [AllowsOtherFiletypes] - Indicates if other file types are allowed.\n * @property {FileFilter[]} [Filters] - Array of file filters.\n * @property {string} [Title] - Title of the dialog.\n * @property {string} [Message] - Message to show in the dialog.\n * @property {string} [ButtonText] - Text to display on the button.\n * @property {string} [Directory] - Directory to open in the dialog.\n * @property {boolean} [Detached] - Indicates if the dialog should appear detached from the main window.\n */\n\n\n/**\n * @typedef {Object} SaveFileDialogOptions\n * @property {string} [Filename] - Default filename to use in the dialog.\n * @property {boolean} [CanChooseDirectories] - Indicates if directories can be chosen.\n * @property {boolean} [CanChooseFiles] - Indicates if files can be chosen.\n * @property {boolean} [CanCreateDirectories] - Indicates if directories can be created.\n * @property {boolean} [ShowHiddenFiles] - Indicates if hidden files should be shown.\n * @property {boolean} [ResolvesAliases] - Indicates if aliases should be resolved.\n * @property {boolean} [AllowsMultipleSelection] - Indicates if multiple selection is allowed.\n * @property {boolean} [HideExtension] - Indicates if the extension should be hidden.\n * @property {boolean} [CanSelectHiddenExtension] - Indicates if hidden extensions can be selected.\n * @property {boolean} [TreatsFilePackagesAsDirectories] - Indicates if file packages should be treated as directories.\n * @property {boolean} [AllowsOtherFiletypes] - Indicates if other file types are allowed.\n * @property {FileFilter[]} [Filters] - Array of file filters.\n * @property {string} [Title] - Title of the dialog.\n * @property {string} [Message] - Message to show in the dialog.\n * @property {string} [ButtonText] - Text to display on the button.\n * @property {string} [Directory] - Directory to open in the dialog.\n * @property {boolean} [Detached] - Indicates if the dialog should appear detached from the main window.\n */\n\n/**\n * @typedef {Object} MessageDialogOptions\n * @property {string} [Title] - The title of the dialog window.\n * @property {string} [Message] - The main message to show in the dialog.\n * @property {Button[]} [Buttons] - Array of button options to show in the dialog.\n * @property {boolean} [Detached] - True if the dialog should appear detached from the main window (if applicable).\n */\n\n/**\n * @typedef {Object} Button\n * @property {string} [Label] - Text that appears within the button.\n * @property {boolean} [IsCancel] - True if the button should cancel an operation when clicked.\n * @property {boolean} [IsDefault] - True if the button should be the default action when the user presses enter.\n */\n\n/**\n * @typedef {Object} FileFilter\n * @property {string} [DisplayName] - Display name for the filter, it could be \"Text Files\", \"Images\" etc.\n * @property {string} [Pattern] - Pattern to match for the filter, e.g. \"*.txt;*.md\" for text markdown files.\n */\n\n// setup\nwindow._wails = window._wails || {};\nwindow._wails.dialogErrorCallback = dialogErrorCallback;\nwindow._wails.dialogResultCallback = dialogResultCallback;\n\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\n\nimport { nanoid } from 'nanoid/non-secure';\n\n// Define constants from the `methods` object in Title Case\nconst DialogInfo = 0;\nconst DialogWarning = 1;\nconst DialogError = 2;\nconst DialogQuestion = 3;\nconst DialogOpenFile = 4;\nconst DialogSaveFile = 5;\n\nconst call = newRuntimeCallerWithID(objectNames.Dialog, '');\nconst dialogResponses = new Map();\n\n/**\n * Generates a unique id that is not present in dialogResponses.\n * @returns {string} unique id\n */\nfunction generateID() {\n    let result;\n    do {\n        result = nanoid();\n    } while (dialogResponses.has(result));\n    return result;\n}\n\n/**\n * Shows a dialog of specified type with the given options.\n * @param {number} type - type of dialog\n * @param {MessageDialogOptions|OpenFileDialogOptions|SaveFileDialogOptions} options - options for the dialog\n * @returns {Promise} promise that resolves with result of dialog\n */\nfunction dialog(type, options = {}) {\n    const id = generateID();\n    options[\"dialog-id\"] = id;\n    return new Promise((resolve, reject) => {\n        dialogResponses.set(id, {resolve, reject});\n        call(type, options).catch((error) => {\n            reject(error);\n            dialogResponses.delete(id);\n        });\n    });\n}\n\n/**\n * Handles the callback from a dialog.\n *\n * @param {string} id - The ID of the dialog response.\n * @param {string} data - The data received from the dialog.\n * @param {boolean} isJSON - Flag indicating whether the data is in JSON format.\n *\n * @return {undefined}\n */\nfunction dialogResultCallback(id, data, isJSON) {\n    let p = dialogResponses.get(id);\n    if (p) {\n        if (isJSON) {\n            p.resolve(JSON.parse(data));\n        } else {\n            p.resolve(data);\n        }\n        dialogResponses.delete(id);\n    }\n}\n\n/**\n * Callback function for handling errors in dialog.\n *\n * @param {string} id - The id of the dialog response.\n * @param {string} message - The error message.\n *\n * @return {void}\n */\nfunction dialogErrorCallback(id, message) {\n    let p = dialogResponses.get(id);\n    if (p) {\n        p.reject(message);\n        dialogResponses.delete(id);\n    }\n}\n\n\n// Replace `methods` with constants in Title Case\n\n/**\n * @param {MessageDialogOptions} options - Dialog options\n * @returns {Promise<string>} - The label of the button pressed\n */\nexport const Info = (options) => dialog(DialogInfo, options);\n\n/**\n * @param {MessageDialogOptions} options - Dialog options\n * @returns {Promise<string>} - The label of the button pressed\n */\nexport const Warning = (options) => dialog(DialogWarning, options);\n\n/**\n * @param {MessageDialogOptions} options - Dialog options\n * @returns {Promise<string>} - The label of the button pressed\n */\nexport const Error = (options) => dialog(DialogError, options);\n\n/**\n * @param {MessageDialogOptions} options - Dialog options\n * @returns {Promise<string>} - The label of the button pressed\n */\nexport const Question = (options) => dialog(DialogQuestion, options);\n\n/**\n * @param {OpenFileDialogOptions} options - Dialog options\n * @returns {Promise<string[]|string>} Returns selected file or list of files. Returns blank string if no file is selected.\n */\nexport const OpenFile = (options) => dialog(DialogOpenFile, options);\n\n/**\n * @param {SaveFileDialogOptions} options - Dialog options\n * @returns {Promise<string>} Returns the selected file. Returns blank string if no file is selected.\n */\nexport const SaveFile = (options) => dialog(DialogSaveFile, options);\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\n/**\n * @typedef {import(\"./types\").WailsEvent} WailsEvent\n */\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\n\nimport {EventTypes} from \"./event_types\";\nexport const Types = EventTypes;\n\n// Setup\nwindow._wails = window._wails || {};\nwindow._wails.dispatchWailsEvent = dispatchWailsEvent;\n\nconst call = newRuntimeCallerWithID(objectNames.Events, '');\nconst EmitMethod = 0;\nconst eventListeners = new Map();\n\nclass Listener {\n    constructor(eventName, callback, maxCallbacks) {\n        this.eventName = eventName;\n        this.maxCallbacks = maxCallbacks || -1;\n        this.Callback = (data) => {\n            callback(data);\n            if (this.maxCallbacks === -1) return false;\n            this.maxCallbacks -= 1;\n            return this.maxCallbacks === 0;\n        };\n    }\n}\n\nexport class WailsEvent {\n    constructor(name, data = null) {\n        this.name = name;\n        this.data = data;\n    }\n}\n\nexport function setup() {\n}\n\nfunction dispatchWailsEvent(event) {\n    let listeners = eventListeners.get(event.name);\n    if (listeners) {\n        let toRemove = listeners.filter(listener => {\n            let remove = listener.Callback(event);\n            if (remove) return true;\n        });\n        if (toRemove.length > 0) {\n            listeners = listeners.filter(l => !toRemove.includes(l));\n            if (listeners.length === 0) eventListeners.delete(event.name);\n            else eventListeners.set(event.name, listeners);\n        }\n    }\n}\n\n/**\n * Register a callback function to be called multiple times for a specific event.\n *\n * @param {string} eventName - The name of the event to register the callback for.\n * @param {function} callback - The callback function to be called when the event is triggered.\n * @param {number} maxCallbacks - The maximum number of times the callback can be called for the event. Once the maximum number is reached, the callback will no longer be called.\n *\n @return {function} - A function that, when called, will unregister the callback from the event.\n */\nexport function OnMultiple(eventName, callback, maxCallbacks) {\n    let listeners = eventListeners.get(eventName) || [];\n    const thisListener = new Listener(eventName, callback, maxCallbacks);\n    listeners.push(thisListener);\n    eventListeners.set(eventName, listeners);\n    return () => listenerOff(thisListener);\n}\n\n/**\n * Registers a callback function to be executed when the specified event occurs.\n *\n * @param {string} eventName - The name of the event.\n * @param {function} callback - The callback function to be executed. It takes no parameters.\n * @return {function} - A function that, when called, will unregister the callback from the event. */\nexport function On(eventName, callback) { return OnMultiple(eventName, callback, -1); }\n\n/**\n * Registers a callback function to be executed only once for the specified event.\n *\n * @param {string} eventName - The name of the event.\n * @param {function} callback - The function to be executed when the event occurs.\n * @return {function} - A function that, when called, will unregister the callback from the event.\n */\nexport function Once(eventName, callback) { return OnMultiple(eventName, callback, 1); }\n\n/**\n * Removes the specified listener from the event listeners collection.\n * If all listeners for the event are removed, the event key is deleted from the collection.\n *\n * @param {Object} listener - The listener to be removed.\n */\nfunction listenerOff(listener) {\n    const eventName = listener.eventName;\n    let listeners = eventListeners.get(eventName).filter(l => l !== listener);\n    if (listeners.length === 0) eventListeners.delete(eventName);\n    else eventListeners.set(eventName, listeners);\n}\n\n\n/**\n * Removes event listeners for the specified event names.\n *\n * @param {string} eventName - The name of the event to remove listeners for.\n * @param {...string} additionalEventNames - Additional event names to remove listeners for.\n * @return {undefined}\n */\nexport function Off(eventName, ...additionalEventNames) {\n    let eventsToRemove = [eventName, ...additionalEventNames];\n    eventsToRemove.forEach(eventName => eventListeners.delete(eventName));\n}\n/**\n * Removes all event listeners.\n *\n * @function OffAll\n * @returns {void}\n */\nexport function OffAll() { eventListeners.clear(); }\n\n/**\n * Emits an event using the given event name.\n *\n * @param {WailsEvent} event - The name of the event to emit.\n * @returns {any} - The result of the emitted event.\n */\nexport function Emit(event) { return call(EmitMethod, event); }\n", "\nexport const EventTypes = {\n\tWindows: {\n\t\tSystemThemeChanged: \"windows:SystemThemeChanged\",\n\t\tAPMPowerStatusChange: \"windows:APMPowerStatusChange\",\n\t\tAPMSuspend: \"windows:APMSuspend\",\n\t\tAPMResumeAutomatic: \"windows:APMResumeAutomatic\",\n\t\tAPMResumeSuspend: \"windows:APMResumeSuspend\",\n\t\tAPMPowerSettingChange: \"windows:APMPowerSettingChange\",\n\t\tApplicationStarted: \"windows:ApplicationStarted\",\n\t\tWebViewNavigationCompleted: \"windows:WebViewNavigationCompleted\",\n\t\tWindowInactive: \"windows:WindowInactive\",\n\t\tWindowActive: \"windows:WindowActive\",\n\t\tWindowClickActive: \"windows:WindowClickActive\",\n\t\tWindowMaximise: \"windows:WindowMaximise\",\n\t\tWindowUnMaximise: \"windows:WindowUnMaximise\",\n\t\tWindowFullscreen: \"windows:WindowFullscreen\",\n\t\tWindowUnFullscreen: \"windows:WindowUnFullscreen\",\n\t\tWindowRestore: \"windows:WindowRestore\",\n\t\tWindowMinimise: \"windows:WindowMinimise\",\n\t\tWindowUnMinimise: \"windows:WindowUnMinimise\",\n\t\tWindowClose: \"windows:WindowClose\",\n\t\tWindowSetFocus: \"windows:WindowSetFocus\",\n\t\tWindowKillFocus: \"windows:WindowKillFocus\",\n\t\tWindowDragDrop: \"windows:WindowDragDrop\",\n\t\tWindowDragEnter: \"windows:WindowDragEnter\",\n\t\tWindowDragLeave: \"windows:WindowDragLeave\",\n\t\tWindowDragOver: \"windows:WindowDragOver\",\n\t\tWindowDidMove: \"windows:WindowDidMove\",\n\t\tWindowDidResize: \"windows:WindowDidResize\",\n\t},\n\tMac: {\n\t\tApplicationDidBecomeActive: \"mac:ApplicationDidBecomeActive\",\n\t\tApplicationDidChangeBackingProperties: \"mac:ApplicationDidChangeBackingProperties\",\n\t\tApplicationDidChangeEffectiveAppearance: \"mac:ApplicationDidChangeEffectiveAppearance\",\n\t\tApplicationDidChangeIcon: \"mac:ApplicationDidChangeIcon\",\n\t\tApplicationDidChangeOcclusionState: \"mac:ApplicationDidChangeOcclusionState\",\n\t\tApplicationDidChangeScreenParameters: \"mac:ApplicationDidChangeScreenParameters\",\n\t\tApplicationDidChangeStatusBarFrame: \"mac:ApplicationDidChangeStatusBarFrame\",\n\t\tApplicationDidChangeStatusBarOrientation: \"mac:ApplicationDidChangeStatusBarOrientation\",\n\t\tApplicationDidFinishLaunching: \"mac:ApplicationDidFinishLaunching\",\n\t\tApplicationDidHide: \"mac:ApplicationDidHide\",\n\t\tApplicationDidResignActiveNotification: \"mac:ApplicationDidResignActiveNotification\",\n\t\tApplicationDidUnhide: \"mac:ApplicationDidUnhide\",\n\t\tApplicationDidUpdate: \"mac:ApplicationDidUpdate\",\n\t\tApplicationWillBecomeActive: \"mac:ApplicationWillBecomeActive\",\n\t\tApplicationWillFinishLaunching: \"mac:ApplicationWillFinishLaunching\",\n\t\tApplicationWillHide: \"mac:ApplicationWillHide\",\n\t\tApplicationWillResignActive: \"mac:ApplicationWillResignActive\",\n\t\tApplicationWillTerminate: \"mac:ApplicationWillTerminate\",\n\t\tApplicationWillUnhide: \"mac:ApplicationWillUnhide\",\n\t\tApplicationWillUpdate: \"mac:ApplicationWillUpdate\",\n\t\tApplicationDidChangeTheme: \"mac:ApplicationDidChangeTheme!\",\n\t\tApplicationShouldHandleReopen: \"mac:ApplicationShouldHandleReopen!\",\n\t\tWindowDidBecomeKey: \"mac:WindowDidBecomeKey\",\n\t\tWindowDidBecomeMain: \"mac:WindowDidBecomeMain\",\n\t\tWindowDidBeginSheet: \"mac:WindowDidBeginSheet\",\n\t\tWindowDidChangeAlpha: \"mac:WindowDidChangeAlpha\",\n\t\tWindowDidChangeBackingLocation: \"mac:WindowDidChangeBackingLocation\",\n\t\tWindowDidChangeBackingProperties: \"mac:WindowDidChangeBackingProperties\",\n\t\tWindowDidChangeCollectionBehavior: \"mac:WindowDidChangeCollectionBehavior\",\n\t\tWindowDidChangeEffectiveAppearance: \"mac:WindowDidChangeEffectiveAppearance\",\n\t\tWindowDidChangeOcclusionState: \"mac:WindowDidChangeOcclusionState\",\n\t\tWindowDidChangeOrderingMode: \"mac:WindowDidChangeOrderingMode\",\n\t\tWindowDidChangeScreen: \"mac:WindowDidChangeScreen\",\n\t\tWindowDidChangeScreenParameters: \"mac:WindowDidChangeScreenParameters\",\n\t\tWindowDidChangeScreenProfile: \"mac:WindowDidChangeScreenProfile\",\n\t\tWindowDidChangeScreenSpace: \"mac:WindowDidChangeScreenSpace\",\n\t\tWindowDidChangeScreenSpaceProperties: \"mac:WindowDidChangeScreenSpaceProperties\",\n\t\tWindowDidChangeSharingType: \"mac:WindowDidChangeSharingType\",\n\t\tWindowDidChangeSpace: \"mac:WindowDidChangeSpace\",\n\t\tWindowDidChangeSpaceOrderingMode: \"mac:WindowDidChangeSpaceOrderingMode\",\n\t\tWindowDidChangeTitle: \"mac:WindowDidChangeTitle\",\n\t\tWindowDidChangeToolbar: \"mac:WindowDidChangeToolbar\",\n\t\tWindowDidChangeVisibility: \"mac:WindowDidChangeVisibility\",\n\t\tWindowDidDeminiaturize: \"mac:WindowDidDeminiaturize\",\n\t\tWindowDidEndSheet: \"mac:WindowDidEndSheet\",\n\t\tWindowDidEnterFullScreen: \"mac:WindowDidEnterFullScreen\",\n\t\tWindowDidEnterVersionBrowser: \"mac:WindowDidEnterVersionBrowser\",\n\t\tWindowDidExitFullScreen: \"mac:WindowDidExitFullScreen\",\n\t\tWindowDidExitVersionBrowser: \"mac:WindowDidExitVersionBrowser\",\n\t\tWindowDidExpose: \"mac:WindowDidExpose\",\n\t\tWindowDidFocus: \"mac:WindowDidFocus\",\n\t\tWindowDidMiniaturize: \"mac:WindowDidMiniaturize\",\n\t\tWindowDidMove: \"mac:WindowDidMove\",\n\t\tWindowDidOrderOffScreen: \"mac:WindowDidOrderOffScreen\",\n\t\tWindowDidOrderOnScreen: \"mac:WindowDidOrderOnScreen\",\n\t\tWindowDidResignKey: \"mac:WindowDidResignKey\",\n\t\tWindowDidResignMain: \"mac:WindowDidResignMain\",\n\t\tWindowDidResize: \"mac:WindowDidResize\",\n\t\tWindowDidUpdate: \"mac:WindowDidUpdate\",\n\t\tWindowDidUpdateAlpha: \"mac:WindowDidUpdateAlpha\",\n\t\tWindowDidUpdateCollectionBehavior: \"mac:WindowDidUpdateCollectionBehavior\",\n\t\tWindowDidUpdateCollectionProperties: \"mac:WindowDidUpdateCollectionProperties\",\n\t\tWindowDidUpdateShadow: \"mac:WindowDidUpdateShadow\",\n\t\tWindowDidUpdateTitle: \"mac:WindowDidUpdateTitle\",\n\t\tWindowDidUpdateToolbar: \"mac:WindowDidUpdateToolbar\",\n\t\tWindowDidUpdateVisibility: \"mac:WindowDidUpdateVisibility\",\n\t\tWindowShouldClose: \"mac:WindowShouldClose!\",\n\t\tWindowWillBecomeKey: \"mac:WindowWillBecomeKey\",\n\t\tWindowWillBecomeMain: \"mac:WindowWillBecomeMain\",\n\t\tWindowWillBeginSheet: \"mac:WindowWillBeginSheet\",\n\t\tWindowWillChangeOrderingMode: \"mac:WindowWillChangeOrderingMode\",\n\t\tWindowWillClose: \"mac:WindowWillClose\",\n\t\tWindowWillDeminiaturize: \"mac:WindowWillDeminiaturize\",\n\t\tWindowWillEnterFullScreen: \"mac:WindowWillEnterFullScreen\",\n\t\tWindowWillEnterVersionBrowser: \"mac:WindowWillEnterVersionBrowser\",\n\t\tWindowWillExitFullScreen: \"mac:WindowWillExitFullScreen\",\n\t\tWindowWillExitVersionBrowser: \"mac:WindowWillExitVersionBrowser\",\n\t\tWindowWillFocus: \"mac:WindowWillFocus\",\n\t\tWindowWillMiniaturize: \"mac:WindowWillMiniaturize\",\n\t\tWindowWillMove: \"mac:WindowWillMove\",\n\t\tWindowWillOrderOffScreen: \"mac:WindowWillOrderOffScreen\",\n\t\tWindowWillOrderOnScreen: \"mac:WindowWillOrderOnScreen\",\n\t\tWindowWillResignMain: \"mac:WindowWillResignMain\",\n\t\tWindowWillResize: \"mac:WindowWillResize\",\n\t\tWindowWillUnfocus: \"mac:WindowWillUnfocus\",\n\t\tWindowWillUpdate: \"mac:WindowWillUpdate\",\n\t\tWindowWillUpdateAlpha: \"mac:WindowWillUpdateAlpha\",\n\t\tWindowWillUpdateCollectionBehavior: \"mac:WindowWillUpdateCollectionBehavior\",\n\t\tWindowWillUpdateCollectionProperties: \"mac:WindowWillUpdateCollectionProperties\",\n\t\tWindowWillUpdateShadow: \"mac:WindowWillUpdateShadow\",\n\t\tWindowWillUpdateTitle: \"mac:WindowWillUpdateTitle\",\n\t\tWindowWillUpdateToolbar: \"mac:WindowWillUpdateToolbar\",\n\t\tWindowWillUpdateVisibility: \"mac:WindowWillUpdateVisibility\",\n\t\tWindowWillUseStandardFrame: \"mac:WindowWillUseStandardFrame\",\n\t\tMenuWillOpen: \"mac:MenuWillOpen\",\n\t\tMenuDidOpen: \"mac:MenuDidOpen\",\n\t\tMenuDidClose: \"mac:MenuDidClose\",\n\t\tMenuWillSendAction: \"mac:MenuWillSendAction\",\n\t\tMenuDidSendAction: \"mac:MenuDidSendAction\",\n\t\tMenuWillHighlightItem: \"mac:MenuWillHighlightItem\",\n\t\tMenuDidHighlightItem: \"mac:MenuDidHighlightItem\",\n\t\tMenuWillDisplayItem: \"mac:MenuWillDisplayItem\",\n\t\tMenuDidDisplayItem: \"mac:MenuDidDisplayItem\",\n\t\tMenuWillAddItem: \"mac:MenuWillAddItem\",\n\t\tMenuDidAddItem: \"mac:MenuDidAddItem\",\n\t\tMenuWillRemoveItem: \"mac:MenuWillRemoveItem\",\n\t\tMenuDidRemoveItem: \"mac:MenuDidRemoveItem\",\n\t\tMenuWillBeginTracking: \"mac:MenuWillBeginTracking\",\n\t\tMenuDidBeginTracking: \"mac:MenuDidBeginTracking\",\n\t\tMenuWillEndTracking: \"mac:MenuWillEndTracking\",\n\t\tMenuDidEndTracking: \"mac:MenuDidEndTracking\",\n\t\tMenuWillUpdate: \"mac:MenuWillUpdate\",\n\t\tMenuDidUpdate: \"mac:MenuDidUpdate\",\n\t\tMenuWillPopUp: \"mac:MenuWillPopUp\",\n\t\tMenuDidPopUp: \"mac:MenuDidPopUp\",\n\t\tMenuWillSendActionToItem: \"mac:MenuWillSendActionToItem\",\n\t\tMenuDidSendActionToItem: \"mac:MenuDidSendActionToItem\",\n\t\tWebViewDidStartProvisionalNavigation: \"mac:WebViewDidStartProvisionalNavigation\",\n\t\tWebViewDidReceiveServerRedirectForProvisionalNavigation: \"mac:WebViewDidReceiveServerRedirectForProvisionalNavigation\",\n\t\tWebViewDidFinishNavigation: \"mac:WebViewDidFinishNavigation\",\n\t\tWebViewDidCommitNavigation: \"mac:WebViewDidCommitNavigation\",\n\t\tWindowFileDraggingEntered: \"mac:WindowFileDraggingEntered\",\n\t\tWindowFileDraggingPerformed: \"mac:WindowFileDraggingPerformed\",\n\t\tWindowFileDraggingExited: \"mac:WindowFileDraggingExited\",\n\t},\n\tLinux: {\n\t\tSystemThemeChanged: \"linux:SystemThemeChanged\",\n\t\tWindowLoadChanged: \"linux:WindowLoadChanged\",\n\t\tWindowDeleteEvent: \"linux:WindowDeleteEvent\",\n\t\tWindowDidMove: \"linux:WindowDidMove\",\n\t\tWindowDidResize: \"linux:WindowDidResize\",\n\t\tWindowFocusIn: \"linux:WindowFocusIn\",\n\t\tWindowFocusOut: \"linux:WindowFocusOut\",\n\t\tApplicationStartup: \"linux:ApplicationStartup\",\n\t},\n\tCommon: {\n\t\tApplicationStarted: \"common:ApplicationStarted\",\n\t\tWindowMaximise: \"common:WindowMaximise\",\n\t\tWindowUnMaximise: \"common:WindowUnMaximise\",\n\t\tWindowFullscreen: \"common:WindowFullscreen\",\n\t\tWindowUnFullscreen: \"common:WindowUnFullscreen\",\n\t\tWindowRestore: \"common:WindowRestore\",\n\t\tWindowMinimise: \"common:WindowMinimise\",\n\t\tWindowUnMinimise: \"common:WindowUnMinimise\",\n\t\tWindowClosing: \"common:WindowClosing\",\n\t\tWindowZoom: \"common:WindowZoom\",\n\t\tWindowZoomIn: \"common:WindowZoomIn\",\n\t\tWindowZoomOut: \"common:WindowZoomOut\",\n\t\tWindowZoomReset: \"common:WindowZoomReset\",\n\t\tWindowFocus: \"common:WindowFocus\",\n\t\tWindowLostFocus: \"common:WindowLostFocus\",\n\t\tWindowShow: \"common:WindowShow\",\n\t\tWindowHide: \"common:WindowHide\",\n\t\tWindowDPIChanged: \"common:WindowDPIChanged\",\n\t\tWindowFilesDropped: \"common:WindowFilesDropped\",\n\t\tWindowRuntimeReady: \"common:WindowRuntimeReady\",\n\t\tThemeChanged: \"common:ThemeChanged\",\n\t\tWindowDidMove: \"common:WindowDidMove\",\n\t\tWindowDidResize: \"common:WindowDidResize\",\n\t},\n};\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/**\n * Logs a message to the console with custom formatting.\n * @param {string} message - The message to be logged.\n * @return {void}\n */\nexport function debugLog(message) {\n    // eslint-disable-next-line\n    console.log(\n        '%c wails3 %c ' + message + ' ',\n        'background: #aa0000; color: #fff; border-radius: 3px 0px 0px 3px; padding: 1px; font-size: 0.7rem',\n        'background: #009900; color: #fff; border-radius: 0px 3px 3px 0px; padding: 1px; font-size: 0.7rem'\n    );\n}\n\n/**\n * Checks whether the browser supports removing listeners by triggering an AbortSignal\n * (see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#signal)\n *\n * @return {boolean}\n */\nexport function canAbortListeners() {\n    if (!EventTarget || !AbortSignal || !AbortController)\n        return false;\n\n    let result = true;\n\n    const target = new EventTarget();\n    const controller = new AbortController();\n    target.addEventListener('test', () => { result = false; }, { signal: controller.signal });\n    controller.abort();\n    target.dispatchEvent(new CustomEvent('test'));\n\n    return result;\n}\n\n/***\n This technique for proper load detection is taken from HTMX:\n\n BSD 2-Clause License\n\n Copyright (c) 2020, Big Sky Software\n All rights reserved.\n\n Redistribution and use in source and binary forms, with or without\n modification, are permitted provided that the following conditions are met:\n\n 1. Redistributions of source code must retain the above copyright notice, this\n list of conditions and the following disclaimer.\n\n 2. Redistributions in binary form must reproduce the above copyright notice,\n this list of conditions and the following disclaimer in the documentation\n and/or other materials provided with the distribution.\n\n THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n ***/\n\nlet isReady = false;\ndocument.addEventListener('DOMContentLoaded', () => isReady = true);\n\nexport function whenReady(callback) {\n    if (isReady || document.readyState === 'complete') {\n        callback();\n    } else {\n        document.addEventListener('DOMContentLoaded', callback);\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\n// Import screen jsdoc definition from ./screens.js\n/**\n * @typedef {import(\"./screens\").Screen} Screen\n */\n\n\n/**\n * A record describing the position of a window.\n *\n * @typedef {Object} Position\n * @property {number} x - The horizontal position of the window\n * @property {number} y - The vertical position of the window\n */\n\n\n/**\n * A record describing the size of a window.\n *\n * @typedef {Object} Size\n * @property {number} width - The width of the window\n * @property {number} height - The height of the window\n */\n\n\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\n\nconst PositionMethod                    = 0;\nconst CenterMethod                      = 1;\nconst CloseMethod                       = 2;\nconst DisableSizeConstraintsMethod      = 3;\nconst EnableSizeConstraintsMethod       = 4;\nconst FocusMethod                       = 5;\nconst ForceReloadMethod                 = 6;\nconst FullscreenMethod                  = 7;\nconst GetScreenMethod                   = 8;\nconst GetZoomMethod                     = 9;\nconst HeightMethod                      = 10;\nconst HideMethod                        = 11;\nconst IsFocusedMethod                   = 12;\nconst IsFullscreenMethod                = 13;\nconst IsMaximisedMethod                 = 14;\nconst IsMinimisedMethod                 = 15;\nconst MaximiseMethod                    = 16;\nconst MinimiseMethod                    = 17;\nconst NameMethod                        = 18;\nconst OpenDevToolsMethod                = 19;\nconst RelativePositionMethod            = 20;\nconst ReloadMethod                      = 21;\nconst ResizableMethod                   = 22;\nconst RestoreMethod                     = 23;\nconst SetPositionMethod                 = 24;\nconst SetAlwaysOnTopMethod              = 25;\nconst SetBackgroundColourMethod         = 26;\nconst SetFramelessMethod                = 27;\nconst SetFullscreenButtonEnabledMethod  = 28;\nconst SetMaxSizeMethod                  = 29;\nconst SetMinSizeMethod                  = 30;\nconst SetRelativePositionMethod         = 31;\nconst SetResizableMethod                = 32;\nconst SetSizeMethod                     = 33;\nconst SetTitleMethod                    = 34;\nconst SetZoomMethod                     = 35;\nconst ShowMethod                        = 36;\nconst SizeMethod                        = 37;\nconst ToggleFullscreenMethod            = 38;\nconst ToggleMaximiseMethod              = 39;\nconst UnFullscreenMethod                = 40;\nconst UnMaximiseMethod                  = 41;\nconst UnMinimiseMethod                  = 42;\nconst WidthMethod                       = 43;\nconst ZoomMethod                        = 44;\nconst ZoomInMethod                      = 45;\nconst ZoomOutMethod                     = 46;\nconst ZoomResetMethod                   = 47;\n\n/**\n * @type {symbol}\n */\nconst caller = Symbol();\n\nclass Window {\n    /**\n     * Initialises a window object with the specified name.\n     *\n     * @private\n     * @param {string} name - The name of the target window.\n     */\n    constructor(name = '') {\n        /**\n         * @private\n         * @name {@link caller}\n         * @type {(...args: any[]) => any}\n         */\n        this[caller] = newRuntimeCallerWithID(objectNames.Window, name)\n\n        // bind instance method to make them easily usable in event handlers\n        for (const method of Object.getOwnPropertyNames(Window.prototype)) {\n            if (\n                method !== \"constructor\"\n                && typeof this[method] === \"function\"\n            ) {\n                this[method] = this[method].bind(this);\n            }\n        }\n    }\n\n    /**\n     * Gets the specified window.\n     *\n     * @public\n     * @param {string} name - The name of the window to get.\n     * @return {Window} - The corresponding window object.\n     */\n    Get(name) {\n        return new Window(name);\n    }\n\n    /**\n     * Returns the absolute position of the window.\n     *\n     * @public\n     * @return {Promise<Position>} - The current absolute position of the window.\n     */\n    Position() {\n        return this[caller](PositionMethod);\n    }\n\n    /**\n     * Centers the window on the screen.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Center() {\n        return this[caller](CenterMethod);\n    }\n\n    /**\n     * Closes the window.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Close() {\n        return this[caller](CloseMethod);\n    }\n\n    /**\n     * Disables min/max size constraints.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    DisableSizeConstraints() {\n        return this[caller](DisableSizeConstraintsMethod);\n    }\n\n    /**\n     * Enables min/max size constraints.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    EnableSizeConstraints() {\n        return this[caller](EnableSizeConstraintsMethod);\n    }\n\n    /**\n     * Focuses the window.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Focus() {\n        return this[caller](FocusMethod);\n    }\n\n    /**\n     * Forces the window to reload the page assets.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    ForceReload() {\n        return this[caller](ForceReloadMethod);\n    }\n\n    /**\n     * Doc.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Fullscreen() {\n        return this[caller](FullscreenMethod);\n    }\n\n    /**\n     * Returns the screen that the window is on.\n     *\n     * @public\n     * @return {Promise<Screen>} - The screen the window is currently on\n     */\n    GetScreen() {\n        return this[caller](GetScreenMethod);\n    }\n\n    /**\n     * Returns the current zoom level of the window.\n     *\n     * @public\n     * @return {Promise<number>} - The current zoom level\n     */\n    GetZoom() {\n        return this[caller](GetZoomMethod);\n    }\n\n    /**\n     * Returns the height of the window.\n     *\n     * @public\n     * @return {Promise<number>} - The current height of the window\n     */\n    Height() {\n        return this[caller](HeightMethod);\n    }\n\n    /**\n     * Hides the window.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Hide() {\n        return this[caller](HideMethod);\n    }\n\n    /**\n     * Returns true if the window is focused.\n     *\n     * @public\n     * @return {Promise<boolean>} - Whether the window is currently focused\n     */\n    IsFocused() {\n        return this[caller](IsFocusedMethod);\n    }\n\n    /**\n     * Returns true if the window is fullscreen.\n     *\n     * @public\n     * @return {Promise<boolean>} - Whether the window is currently fullscreen\n     */\n    IsFullscreen() {\n        return this[caller](IsFullscreenMethod);\n    }\n\n    /**\n     * Returns true if the window is maximised.\n     *\n     * @public\n     * @return {Promise<boolean>} - Whether the window is currently maximised\n     */\n    IsMaximised() {\n        return this[caller](IsMaximisedMethod);\n    }\n\n    /**\n     * Returns true if the window is minimised.\n     *\n     * @public\n     * @return {Promise<boolean>} - Whether the window is currently minimised\n     */\n    IsMinimised() {\n        return this[caller](IsMinimisedMethod);\n    }\n\n    /**\n     * Maximises the window.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Maximise() {\n        return this[caller](MaximiseMethod);\n    }\n\n    /**\n     * Minimises the window.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Minimise() {\n        return this[caller](MinimiseMethod);\n    }\n\n    /**\n     * Returns the name of the window.\n     *\n     * @public\n     * @return {Promise<string>} - The name of the window\n     */\n    Name() {\n        return this[caller](NameMethod);\n    }\n\n    /**\n     * Opens the development tools pane.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    OpenDevTools() {\n        return this[caller](OpenDevToolsMethod);\n    }\n\n    /**\n     * Returns the relative position of the window to the screen.\n     *\n     * @public\n     * @return {Promise<Position>} - The current relative position of the window\n     */\n    RelativePosition() {\n        return this[caller](RelativePositionMethod);\n    }\n\n    /**\n     * Reloads the page assets.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Reload() {\n        return this[caller](ReloadMethod);\n    }\n\n    /**\n     * Returns true if the window is resizable.\n     *\n     * @public\n     * @return {Promise<boolean>} - Whether the window is currently resizable\n     */\n    Resizable() {\n        return this[caller](ResizableMethod);\n    }\n\n    /**\n     * Restores the window to its previous state if it was previously minimised, maximised or fullscreen.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Restore() {\n        return this[caller](RestoreMethod);\n    }\n\n    /**\n     * Sets the absolute position of the window.\n     *\n     * @public\n     * @param {number} x - The desired horizontal absolute position of the window\n     * @param {number} y - The desired vertical absolute position of the window\n     * @return {Promise<void>}\n     */\n    SetPosition(x, y) {\n        return this[caller](SetPositionMethod, { x, y });\n    }\n\n    /**\n     * Sets the window to be always on top.\n     *\n     * @public\n     * @param {boolean} alwaysOnTop - Whether the window should stay on top\n     * @return {Promise<void>}\n     */\n    SetAlwaysOnTop(alwaysOnTop) {\n        return this[caller](SetAlwaysOnTopMethod, { alwaysOnTop });\n    }\n\n    /**\n     * Sets the background colour of the window.\n     *\n     * @public\n     * @param {number} r - The desired red component of the window background\n     * @param {number} g - The desired green component of the window background\n     * @param {number} b - The desired blue component of the window background\n     * @param {number} a - The desired alpha component of the window background\n     * @return {Promise<void>}\n     */\n    SetBackgroundColour(r, g, b, a) {\n        return this[caller](SetBackgroundColourMethod, { r, g, b, a });\n    }\n\n    /**\n     * Removes the window frame and title bar.\n     *\n     * @public\n     * @param {boolean} frameless - Whether the window should be frameless\n     * @return {Promise<void>}\n     */\n    SetFrameless(frameless) {\n        return this[caller](SetFramelessMethod, { frameless });\n    }\n\n    /**\n     * Disables the system fullscreen button.\n     *\n     * @public\n     * @param {boolean} enabled - Whether the fullscreen button should be enabled\n     * @return {Promise<void>}\n     */\n    SetFullscreenButtonEnabled(enabled) {\n        return this[caller](SetFullscreenButtonEnabledMethod, { enabled });\n    }\n\n    /**\n     * Sets the maximum size of the window.\n     *\n     * @public\n     * @param {number} width - The desired maximum width of the window\n     * @param {number} height - The desired maximum height of the window\n     * @return {Promise<void>}\n     */\n    SetMaxSize(width, height) {\n        return this[caller](SetMaxSizeMethod, { width, height });\n    }\n\n    /**\n     * Sets the minimum size of the window.\n     *\n     * @public\n     * @param {number} width - The desired minimum width of the window\n     * @param {number} height - The desired minimum height of the window\n     * @return {Promise<void>}\n     */\n    SetMinSize(width, height) {\n        return this[caller](SetMinSizeMethod, { width, height });\n    }\n\n    /**\n     * Sets the relative position of the window to the screen.\n     *\n     * @public\n     * @param {number} x - The desired horizontal relative position of the window\n     * @param {number} y - The desired vertical relative position of the window\n     * @return {Promise<void>}\n     */\n    SetRelativePosition(x, y) {\n        return this[caller](SetRelativePositionMethod, { x, y });\n    }\n\n    /**\n     * Sets whether the window is resizable.\n     *\n     * @public\n     * @param {boolean} resizable - Whether the window should be resizable\n     * @return {Promise<void>}\n     */\n    SetResizable(resizable) {\n        return this[caller](SetResizableMethod, { resizable });\n    }\n\n    /**\n     * Sets the size of the window.\n     *\n     * @public\n     * @param {number} width - The desired width of the window\n     * @param {number} height - The desired height of the window\n     * @return {Promise<void>}\n     */\n    SetSize(width, height) {\n        return this[caller](SetSizeMethod, { width, height });\n    }\n\n    /**\n     * Sets the title of the window.\n     *\n     * @public\n     * @param {string} title - The desired title of the window\n     * @return {Promise<void>}\n     */\n    SetTitle(title) {\n        return this[caller](SetTitleMethod, { title });\n    }\n\n    /**\n     * Sets the zoom level of the window.\n     *\n     * @public\n     * @param {number} zoom - The desired zoom level\n     * @return {Promise<void>}\n     */\n    SetZoom(zoom) {\n        return this[caller](SetZoomMethod, { zoom });\n    }\n\n    /**\n     * Shows the window.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Show() {\n        return this[caller](ShowMethod);\n    }\n\n    /**\n     * Returns the size of the window.\n     *\n     * @public\n     * @return {Promise<Size>} - The current size of the window\n     */\n    Size() {\n        return this[caller](SizeMethod);\n    }\n\n    /**\n     * Toggles the window between fullscreen and normal.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    ToggleFullscreen() {\n        return this[caller](ToggleFullscreenMethod);\n    }\n\n    /**\n     * Toggles the window between maximised and normal.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    ToggleMaximise() {\n        return this[caller](ToggleMaximiseMethod);\n    }\n\n    /**\n     * Un-fullscreens the window.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    UnFullscreen() {\n        return this[caller](UnFullscreenMethod);\n    }\n\n    /**\n     * Un-maximises the window.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    UnMaximise() {\n        return this[caller](UnMaximiseMethod);\n    }\n\n    /**\n     * Un-minimises the window.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    UnMinimise() {\n        return this[caller](UnMinimiseMethod);\n    }\n\n    /**\n     * Returns the width of the window.\n     *\n     * @public\n     * @return {Promise<number>} - The current width of the window\n     */\n    Width() {\n        return this[caller](WidthMethod);\n    }\n\n    /**\n     * Zooms the window.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Zoom() {\n        return this[caller](ZoomMethod);\n    }\n\n    /**\n     * Increases the zoom level of the webview content.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    ZoomIn() {\n        return this[caller](ZoomInMethod);\n    }\n\n    /**\n     * Decreases the zoom level of the webview content.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    ZoomOut() {\n        return this[caller](ZoomOutMethod);\n    }\n\n    /**\n     * Resets the zoom level of the webview content.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    ZoomReset() {\n        return this[caller](ZoomResetMethod);\n    }\n}\n\n/**\n * The window within which the script is running.\n *\n * @type {Window}\n */\nconst thisWindow = new Window('');\n\nexport default thisWindow;\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport * as Runtime from \"../@wailsio/runtime/src\";\n\n// NOTE: the following methods MUST be imported explicitly because of how esbuild injection works\nimport {Enable as EnableWML} from \"../@wailsio/runtime/src/wml\";\nimport {debugLog} from \"../@wailsio/runtime/src/utils\";\n\nwindow.wails = Runtime;\nEnableWML();\n\nif (DEBUG) {\n    debugLog(\"Wails Runtime Loaded\")\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\nlet call = newRuntimeCallerWithID(objectNames.System, '');\nconst systemIsDarkMode = 0;\nconst environment = 1;\n\nexport function invoke(msg) {\n    if(window.chrome) {\n        return window.chrome.webview.postMessage(msg);\n    }\n    return window.webkit.messageHandlers.external.postMessage(msg);\n}\n\n/**\n * @function\n * Retrieves the system dark mode status.\n * @returns {Promise<boolean>} - A promise that resolves to a boolean value indicating if the system is in dark mode.\n */\nexport function IsDarkMode() {\n    return call(systemIsDarkMode);\n}\n\n/**\n * Fetches the capabilities of the application from the server.\n *\n * @async\n * @function Capabilities\n * @returns {Promise<Object>} A promise that resolves to an object containing the capabilities.\n */\nexport function Capabilities() {\n    let response = fetch(\"/wails/capabilities\");\n    return response.json();\n}\n\n/**\n * @typedef {Object} OSInfo\n * @property {string} Branding - The branding of the OS.\n * @property {string} ID - The ID of the OS.\n * @property {string} Name - The name of the OS.\n * @property {string} Version - The version of the OS.\n */\n\n/**\n * @typedef {Object} EnvironmentInfo\n * @property {string} Arch - The architecture of the system.\n * @property {boolean} Debug - True if the application is running in debug mode, otherwise false.\n * @property {string} OS - The operating system in use.\n * @property {OSInfo} OSInfo - Details of the operating system.\n * @property {Object} PlatformInfo - Additional platform information.\n */\n\n/**\n * @function\n * Retrieves environment details.\n * @returns {Promise<EnvironmentInfo>} - A promise that resolves to an object containing OS and system architecture.\n */\nexport function Environment() {\n    return call(environment);\n}\n\n/**\n * Checks if the current operating system is Windows.\n *\n * @return {boolean} True if the operating system is Windows, otherwise false.\n */\nexport function IsWindows() {\n    return window._wails.environment.OS === \"windows\";\n}\n\n/**\n * Checks if the current operating system is Linux.\n *\n * @returns {boolean} Returns true if the current operating system is Linux, false otherwise.\n */\nexport function IsLinux() {\n    return window._wails.environment.OS === \"linux\";\n}\n\n/**\n * Checks if the current environment is a macOS operating system.\n *\n * @returns {boolean} True if the environment is macOS, false otherwise.\n */\nexport function IsMac() {\n    return window._wails.environment.OS === \"darwin\";\n}\n\n/**\n * Checks if the current environment architecture is AMD64.\n * @returns {boolean} True if the current environment architecture is AMD64, false otherwise.\n */\nexport function IsAMD64() {\n    return window._wails.environment.Arch === \"amd64\";\n}\n\n/**\n * Checks if the current architecture is ARM.\n *\n * @returns {boolean} True if the current architecture is ARM, false otherwise.\n */\nexport function IsARM() {\n    return window._wails.environment.Arch === \"arm\";\n}\n\n/**\n * Checks if the current environment is ARM64 architecture.\n *\n * @returns {boolean} - Returns true if the environment is ARM64 architecture, otherwise returns false.\n */\nexport function IsARM64() {\n    return window._wails.environment.Arch === \"arm64\";\n}\n\nexport function IsDebug() {\n    return window._wails.environment.Debug === true;\n}\n\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\nimport {IsDebug} from \"./system\";\n\n// setup\nwindow.addEventListener('contextmenu', contextMenuHandler);\n\nconst call = newRuntimeCallerWithID(objectNames.ContextMenu, '');\nconst ContextMenuOpen = 0;\n\nfunction openContextMenu(id, x, y, data) {\n    void call(ContextMenuOpen, {id, x, y, data});\n}\n\nfunction contextMenuHandler(event) {\n    // Check for custom context menu\n    let element = event.target;\n    let customContextMenu = window.getComputedStyle(element).getPropertyValue(\"--custom-contextmenu\");\n    customContextMenu = customContextMenu ? customContextMenu.trim() : \"\";\n    if (customContextMenu) {\n        event.preventDefault();\n        let customContextMenuData = window.getComputedStyle(element).getPropertyValue(\"--custom-contextmenu-data\");\n        openContextMenu(customContextMenu, event.clientX, event.clientY, customContextMenuData);\n        return\n    }\n\n    processDefaultContextMenu(event);\n}\n\n\n/*\n--default-contextmenu: auto; (default) will show the default context menu if contentEditable is true OR text has been selected OR element is input or textarea\n--default-contextmenu: show; will always show the default context menu\n--default-contextmenu: hide; will always hide the default context menu\n\nThis rule is inherited like normal CSS rules, so nesting works as expected\n*/\nfunction processDefaultContextMenu(event) {\n\n    // Debug builds always show the menu\n    if (IsDebug()) {\n        return;\n    }\n\n    // Process default context menu\n    const element = event.target;\n    const computedStyle = window.getComputedStyle(element);\n    const defaultContextMenuAction = computedStyle.getPropertyValue(\"--default-contextmenu\").trim();\n    switch (defaultContextMenuAction) {\n        case \"show\":\n            return;\n        case \"hide\":\n            event.preventDefault();\n            return;\n        default:\n            // Check if contentEditable is true\n            if (element.isContentEditable) {\n                return;\n            }\n\n            // Check if text has been selected\n            const selection = window.getSelection();\n            const hasSelection = (selection.toString().length > 0)\n            if (hasSelection) {\n                for (let i = 0; i < selection.rangeCount; i++) {\n                    const range = selection.getRangeAt(i);\n                    const rects = range.getClientRects();\n                    for (let j = 0; j < rects.length; j++) {\n                        const rect = rects[j];\n                        if (document.elementFromPoint(rect.left, rect.top) === element) {\n                            return;\n                        }\n                    }\n                }\n            }\n            // Check if tagname is input or textarea\n            if (element.tagName === \"INPUT\" || element.tagName === \"TEXTAREA\") {\n                if (hasSelection || (!element.readOnly && !element.disabled)) {\n                    return;\n                }\n            }\n\n            // hide default context menu\n            event.preventDefault();\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\n/**\n * Retrieves the value associated with the specified key from the flag map.\n *\n * @param {string} keyString - The key to retrieve the value for.\n * @return {*} - The value associated with the specified key.\n */\nexport function GetFlag(keyString) {\n    try {\n        return window._wails.flags[keyString];\n    } catch (e) {\n        throw new Error(\"Unable to retrieve flag '\" + keyString + \"': \" + e);\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n/* jshint esversion: 9 */\nimport {invoke, IsWindows} from \"./system\";\nimport {GetFlag} from \"./flags\";\n\n// Setup\nlet shouldDrag = false;\nlet resizable = false;\nlet resizeEdge = null;\nlet defaultCursor = \"auto\";\n\nwindow._wails = window._wails || {};\n\nwindow._wails.setResizable = function(value) {\n    resizable = value;\n};\n\nwindow._wails.endDrag = function() {\n    document.body.style.cursor = 'default';\n    shouldDrag = false;\n};\n\nwindow.addEventListener('mousedown', onMouseDown);\nwindow.addEventListener('mousemove', onMouseMove);\nwindow.addEventListener('mouseup', onMouseUp);\n\n\nfunction dragTest(e) {\n    let val = window.getComputedStyle(e.target).getPropertyValue(\"--wails-draggable\");\n    let mousePressed = e.buttons !== undefined ? e.buttons : e.which;\n    if (!val || val === \"\" || val.trim() !== \"drag\" || mousePressed === 0) {\n        return false;\n    }\n    return e.detail === 1;\n}\n\nfunction onMouseDown(e) {\n\n    // Check for resizing\n    if (resizeEdge) {\n        invoke(\"wails:resize:\" + resizeEdge);\n        e.preventDefault();\n        return;\n    }\n\n    if (dragTest(e)) {\n        // This checks for clicks on the scroll bar\n        if (e.offsetX > e.target.clientWidth || e.offsetY > e.target.clientHeight) {\n            return;\n        }\n        shouldDrag = true;\n    } else {\n        shouldDrag = false;\n    }\n}\n\nfunction onMouseUp() {\n    shouldDrag = false;\n}\n\nfunction setResize(cursor) {\n    document.documentElement.style.cursor = cursor || defaultCursor;\n    resizeEdge = cursor;\n}\n\nfunction onMouseMove(e) {\n    if (shouldDrag) {\n        shouldDrag = false;\n        let mousePressed = e.buttons !== undefined ? e.buttons : e.which;\n        if (mousePressed > 0) {\n            invoke(\"wails:drag\");\n            return;\n        }\n    }\n    if (!resizable || !IsWindows()) {\n        return;\n    }\n    if (defaultCursor == null) {\n        defaultCursor = document.documentElement.style.cursor;\n    }\n    let resizeHandleHeight = GetFlag(\"system.resizeHandleHeight\") || 5;\n    let resizeHandleWidth = GetFlag(\"system.resizeHandleWidth\") || 5;\n\n    // Extra pixels for the corner areas\n    let cornerExtra = GetFlag(\"resizeCornerExtra\") || 10;\n\n    let rightBorder = window.outerWidth - e.clientX < resizeHandleWidth;\n    let leftBorder = e.clientX < resizeHandleWidth;\n    let topBorder = e.clientY < resizeHandleHeight;\n    let bottomBorder = window.outerHeight - e.clientY < resizeHandleHeight;\n\n    // Adjust for corners\n    let rightCorner = window.outerWidth - e.clientX < (resizeHandleWidth + cornerExtra);\n    let leftCorner = e.clientX < (resizeHandleWidth + cornerExtra);\n    let topCorner = e.clientY < (resizeHandleHeight + cornerExtra);\n    let bottomCorner = window.outerHeight - e.clientY < (resizeHandleHeight + cornerExtra);\n\n    // If we aren't on an edge, but were, reset the cursor to default\n    if (!leftBorder && !rightBorder && !topBorder && !bottomBorder && resizeEdge !== undefined) {\n        setResize();\n    }\n    // Adjusted for corner areas\n    else if (rightCorner && bottomCorner) setResize(\"se-resize\");\n    else if (leftCorner && bottomCorner) setResize(\"sw-resize\");\n    else if (leftCorner && topCorner) setResize(\"nw-resize\");\n    else if (topCorner && rightCorner) setResize(\"ne-resize\");\n    else if (leftBorder) setResize(\"w-resize\");\n    else if (topBorder) setResize(\"n-resize\");\n    else if (bottomBorder) setResize(\"s-resize\");\n    else if (rightBorder) setResize(\"e-resize\");\n}", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\nimport { newRuntimeCallerWithID, objectNames } from \"./runtime\";\nconst call = newRuntimeCallerWithID(objectNames.Application, '');\n\nconst HideMethod = 0;\nconst ShowMethod = 1;\nconst QuitMethod = 2;\n\n/**\n * Hides a certain method by calling the HideMethod function.\n *\n * @return {Promise<void>}\n *\n */\nexport function Hide() {\n    return call(HideMethod);\n}\n\n/**\n * Calls the ShowMethod and returns the result.\n *\n * @return {Promise<void>}\n */\nexport function Show() {\n    return call(ShowMethod);\n}\n\n/**\n * Calls the QuitMethod to terminate the program.\n *\n * @return {Promise<void>}\n */\nexport function Quit() {\n    return call(QuitMethod);\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\nimport { newRuntimeCallerWithID, objectNames } from \"./runtime\";\nimport { nanoid } from 'nanoid/non-secure';\n\n// Setup\nwindow._wails = window._wails || {};\nwindow._wails.callResultHandler = resultHandler;\nwindow._wails.callErrorHandler = errorHandler;\n\n\nconst CallBinding = 0;\nconst call = newRuntimeCallerWithID(objectNames.Call, '');\nconst cancelCall = newRuntimeCallerWithID(objectNames.CancelCall, '');\nlet callResponses = new Map();\n\n/**\n * Generates a unique ID using the nanoid library.\n *\n * @return {string} - A unique ID that does not exist in the callResponses set.\n */\nfunction generateID() {\n    let result;\n    do {\n        result = nanoid();\n    } while (callResponses.has(result));\n    return result;\n}\n\n/**\n * Handles the result of a call request.\n *\n * @param {string} id - The id of the request to handle the result for.\n * @param {string} data - The result data of the request.\n * @param {boolean} isJSON - Indicates whether the data is JSON or not.\n *\n * @return {undefined} - This method does not return any value.\n */\nfunction resultHandler(id, data, isJSON) {\n    const promiseHandler = getAndDeleteResponse(id);\n    if (promiseHandler) {\n        promiseHandler.resolve(isJSON ? JSON.parse(data) : data);\n    }\n}\n\n/**\n * Handles the error from a call request.\n *\n * @param {string} id - The id of the promise handler.\n * @param {string} message - The error message to reject the promise handler with.\n *\n * @return {void}\n */\nfunction errorHandler(id, message) {\n    const promiseHandler = getAndDeleteResponse(id);\n    if (promiseHandler) {\n        promiseHandler.reject(message);\n    }\n}\n\n/**\n * Retrieves and removes the response associated with the given ID from the callResponses map.\n *\n * @param {any} id - The ID of the response to be retrieved and removed.\n *\n * @returns {any} The response object associated with the given ID.\n */\nfunction getAndDeleteResponse(id) {\n    const response = callResponses.get(id);\n    callResponses.delete(id);\n    return response;\n}\n\n/**\n * Executes a call using the provided type and options.\n *\n * @param {string|number} type - The type of call to execute.\n * @param {Object} [options={}] - Additional options for the call.\n * @return {Promise} - A promise that will be resolved or rejected based on the result of the call. It also has a cancel method to cancel a long running request.\n */\nfunction callBinding(type, options = {}) {\n    const id = generateID();\n    const doCancel = () => { return cancelCall(type, {\"call-id\": id}) };\n    let queuedCancel = false, callRunning = false;\n    let p = new Promise((resolve, reject) => {\n        options[\"call-id\"] = id;\n        callResponses.set(id, { resolve, reject });\n        call(type, options).\n            then((_) => {\n                callRunning = true;\n                if (queuedCancel) {\n                    return doCancel();\n                }\n            }).\n            catch((error) => {\n                reject(error);\n                callResponses.delete(id);\n            });\n    });\n    p.cancel = () => {\n        if (callRunning) {\n            return doCancel();\n        } else {\n            queuedCancel = true;\n        }\n    };\n\n    return p;\n}\n\n/**\n * Call method.\n *\n * @param {Object} options - The options for the method.\n * @returns {Object} - The result of the call.\n */\nexport function Call(options) {\n    return callBinding(CallBinding, options);\n}\n\n/**\n * Executes a method by name.\n *\n * @param {string} methodName - The name of the method in the format 'package.struct.method'.\n * @param {...*} args - The arguments to pass to the method.\n * @throws {Error} If the name is not a string or is not in the correct format.\n * @returns {*} The result of the method execution.\n */\nexport function ByName(methodName, ...args) {\n    return callBinding(CallBinding, {\n        methodName,\n        args\n    });\n}\n\n/**\n * Calls a method by its ID with the specified arguments.\n *\n * @param {number} methodID - The ID of the method to call.\n * @param {...*} args - The arguments to pass to the method.\n * @return {*} - The result of the method call.\n */\nexport function ByID(methodID, ...args) {\n    return callBinding(CallBinding, {\n        methodID,\n        args\n    });\n}\n\n/**\n * Calls a method on a plugin.\n *\n * @param {string} pluginName - The name of the plugin.\n * @param {string} methodName - The name of the method to call.\n * @param {...*} args - The arguments to pass to the method.\n * @returns {*} - The result of the method call.\n */\nexport function Plugin(pluginName, methodName, ...args) {\n    return callBinding(CallBinding, {\n        packageName: \"wails-plugins\",\n        structName: pluginName,\n        methodName,\n        args\n    });\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\n\nconst call = newRuntimeCallerWithID(objectNames.Clipboard, '');\nconst ClipboardSetText = 0;\nconst ClipboardText = 1;\n\n/**\n * Sets the text to the Clipboard.\n *\n * @param {string} text - The text to be set to the Clipboard.\n * @return {Promise} - A Promise that resolves when the operation is successful.\n */\nexport function SetText(text) {\n    return call(ClipboardSetText, {text});\n}\n\n/**\n * Get the Clipboard text\n * @returns {Promise<string>} A promise that resolves with the text from the Clipboard.\n */\nexport function Text() {\n    return call(ClipboardText);\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\n/**\n * Any is a dummy creation function for simple or unknown types.\n * @template T\n * @param {any} source\n * @returns {T}\n */\nexport function Any(source) {\n    return /** @type {T} */(source);\n}\n\n/**\n * ByteSlice is a creation function that replaces\n * null strings with empty strings.\n * @param {any} source\n * @returns {string}\n */\nexport function ByteSlice(source) {\n    return /** @type {any} */((source == null) ? \"\" : source);\n}\n\n/**\n * Array takes a creation function for an arbitrary type\n * and returns an in-place creation function for an array\n * whose elements are of that type.\n * @template T\n * @param {(source: any) => T} element\n * @returns {(source: any) => T[]}\n */\nexport function Array(element) {\n    if (element === Any) {\n        return (source) => (source === null ? [] : source);\n    }\n\n    return (source) => {\n        if (source === null) {\n            return [];\n        }\n        for (let i = 0; i < source.length; i++) {\n            source[i] = element(source[i]);\n        }\n        return source;\n    };\n}\n\n/**\n * Map takes creation functions for two arbitrary types\n * and returns an in-place creation function for an object\n * whose keys and values are of those types.\n * @template K, V\n * @param {(source: any) => K} key\n * @param {(source: any) => V} value\n * @returns {(source: any) => { [_: K]: V }}\n */\nexport function Map(key, value) {\n    if (value === Any) {\n        return (source) => (source === null ? {} : source);\n    }\n\n    return (source) => {\n        if (source === null) {\n            return {};\n        }\n        for (const key in source) {\n            source[key] = value(source[key]);\n        }\n        return source;\n    };\n}\n\n/**\n * Nullable takes a creation function for an arbitrary type\n * and returns a creation function for a nullable value of that type.\n * @template T\n * @param {(source: any) => T} element\n * @returns {(source: any) => (T | null)}\n */\nexport function Nullable(element) {\n    if (element === Any) {\n        return Any;\n    }\n\n    return (source) => (source === null ? null : element(source));\n}\n\n/**\n * Struct takes an object mapping field names to creation functions\n * and returns an in-place creation function for a struct.\n * @template {{ [_: string]: ((source: any) => any) }} T\n * @template {{ [Key in keyof T]?: ReturnType<T[Key]> }} U\n * @param {T} createField\n * @returns {(source: any) => U}\n */\nexport function Struct(createField) {\n    let allAny = true;\n    for (const name in createField) {\n        if (createField[name] !== Any) {\n            allAny = false;\n            break;\n        }\n    }\n    if (allAny) {\n        return Any;\n    }\n\n    return (source) => {\n        for (const name in createField) {\n            if (name in source) {\n                source[name] = createField[name](source[name]);\n            }\n        }\n        return source;\n    };\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\n/**\n * @typedef {Object} Position\n * @property {number} X - The X coordinate.\n * @property {number} Y - The Y coordinate.\n */\n\n/**\n * @typedef {Object} Size\n * @property {number} X - The width.\n * @property {number} Y - The height.\n */\n\n\n/**\n * @typedef {Object} Rect\n * @property {number} X - The X coordinate of the top-left corner.\n * @property {number} Y - The Y coordinate of the top-left corner.\n * @property {number} Width - The width of the rectangle.\n * @property {number} Height - The height of the rectangle.\n */\n\n\n/**\n * @typedef {Object} Screen\n * @property {string} Id - Unique identifier for the screen.\n * @property {string} Name - Human readable name of the screen.\n * @property {number} Scale - The resolution scale of the screen. 1 = standard resolution, 2 = high (Retina), etc.\n * @property {Position} Position - Contains the X and Y coordinates of the screen's position.\n * @property {Size} Size - Contains the width and height of the screen.\n * @property {Rect} Bounds - Contains the bounds of the screen in terms of X, Y, Width, and Height.\n * @property {Rect} WorkArea - Contains the area of the screen that is actually usable (excluding taskbar and other system UI).\n * @property {boolean} IsPrimary - True if this is the primary monitor selected by the user in the operating system.\n * @property {number} Rotation - The rotation of the screen.\n */\n\n\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\nconst call = newRuntimeCallerWithID(objectNames.Screens, '');\n\nconst getAll = 0;\nconst getPrimary = 1;\nconst getCurrent = 2;\n\n/**\n * Gets all screens.\n * @returns {Promise<Screen[]>} A promise that resolves to an array of Screen objects.\n */\nexport function GetAll() {\n    return call(getAll);\n}\n/**\n * Gets the primary screen.\n * @returns {Promise<Screen>} A promise that resolves to the primary screen.\n */\nexport function GetPrimary() {\n    return call(getPrimary);\n}\n/**\n * Gets the current active screen.\n *\n * @returns {Promise<Screen>} A promise that resolves with the current active screen.\n */\nexport function GetCurrent() {\n    return call(getCurrent);\n}\n"],
  "mappings": "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",
  "names": ["Error", "call", "Error", "call", "eventName", "controller", "resizable", "call", "call", "call", "HideMethod", "ShowMethod", "call", "generateID", "call", "Map", "Map", "key", "call"]
}
 +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../runtime/desktop/@wailsio/runtime/src/index.js", "../../runtime/desktop/@wailsio/runtime/src/wml.js", "../../runtime/desktop/@wailsio/runtime/src/browser.js", "../../runtime/node_modules/nanoid/non-secure/index.js", "../../runtime/desktop/@wailsio/runtime/src/runtime.js", "../../runtime/desktop/@wailsio/runtime/src/dialogs.js", "../../runtime/desktop/@wailsio/runtime/src/events.js", "../../runtime/desktop/@wailsio/runtime/src/event_types.js", "../../runtime/desktop/@wailsio/runtime/src/utils.js", "../../runtime/desktop/@wailsio/runtime/src/window.js", "../../runtime/desktop/compiled/main.js", "../../runtime/desktop/@wailsio/runtime/src/system.js", "../../runtime/desktop/@wailsio/runtime/src/contextmenu.js", "../../runtime/desktop/@wailsio/runtime/src/flags.js", "../../runtime/desktop/@wailsio/runtime/src/drag.js", "../../runtime/desktop/@wailsio/runtime/src/application.js", "../../runtime/desktop/@wailsio/runtime/src/calls.js", "../../runtime/desktop/@wailsio/runtime/src/clipboard.js", "../../runtime/desktop/@wailsio/runtime/src/create.js", "../../runtime/desktop/@wailsio/runtime/src/screens.js"],
  "sourcesContent": ["/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n// Setup\nwindow._wails = window._wails || {};\n\nimport \"./contextmenu\";\nimport \"./drag\";\n\n// Re-export public API\nimport * as Application from \"./application\";\nimport * as Browser from \"./browser\";\nimport * as Call from \"./calls\";\nimport * as Clipboard from \"./clipboard\";\nimport * as Create from \"./create\";\nimport * as Dialogs from \"./dialogs\";\nimport * as Events from \"./events\";\nimport * as Flags from \"./flags\";\nimport * as Screens from \"./screens\";\nimport * as System from \"./system\";\nimport Window from \"./window\";\nimport * as WML from \"./wml\";\n\nexport {\n    Application,\n    Browser,\n    Call,\n    Clipboard,\n    Create,\n    Dialogs,\n    Events,\n    Flags,\n    Screens,\n    System,\n    Window,\n    WML\n};\n\n// Notify backend\nwindow._wails.invoke = System.invoke;\nSystem.invoke(\"wails:runtime:ready\");\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport {OpenURL} from \"./browser\";\nimport {Question} from \"./dialogs\";\nimport {Emit, WailsEvent} from \"./events\";\nimport {canAbortListeners, whenReady} from \"./utils\";\nimport Window from \"./window\";\n\n/**\n * Sends an event with the given name and optional data.\n *\n * @param {string} eventName - The name of the event to send.\n * @param {any} [data=null] - Optional data to send along with the event.\n *\n * @return {void}\n */\nfunction sendEvent(eventName, data=null) {\n    Emit(new WailsEvent(eventName, data));\n}\n\n/**\n * Calls a method on a specified window.\n * @param {string} windowName - The name of the window to call the method on.\n * @param {string} methodName - The name of the method to call.\n */\nfunction callWindowMethod(windowName, methodName) {\n    const targetWindow = Window.Get(windowName);\n    const method = targetWindow[methodName];\n\n    if (typeof method !== \"function\") {\n        console.error(`Window method '${methodName}' not found`);\n        return;\n    }\n\n    try {\n        method.call(targetWindow);\n    } catch (e) {\n        console.error(`Error calling window method '${methodName}': `, e);\n    }\n}\n\n/**\n * Responds to a triggering event by running appropriate WML actions for the current target\n *\n * @param {Event} ev\n * @return {void}\n */\nfunction onWMLTriggered(ev) {\n    const element = ev.currentTarget;\n\n    function runEffect(choice = \"Yes\") {\n        if (choice !== \"Yes\")\n            return;\n\n        const eventType = element.getAttribute('wml-event');\n        const targetWindow = element.getAttribute('wml-target-window') || \"\";\n        const windowMethod = element.getAttribute('wml-window');\n        const url = element.getAttribute('wml-openurl');\n\n        if (eventType !== null)\n            sendEvent(eventType);\n        if (windowMethod !== null)\n            callWindowMethod(targetWindow, windowMethod);\n        if (url !== null)\n            void OpenURL(url);\n    }\n\n    const confirm = element.getAttribute('wml-confirm');\n\n    if (confirm) {\n        Question({\n            Title: \"Confirm\",\n            Message: confirm,\n            Detached: false,\n            Buttons: [\n                { Label: \"Yes\" },\n                { Label: \"No\", IsDefault: true }\n            ]\n        }).then(runEffect);\n    } else {\n        runEffect();\n    }\n}\n\n/**\n * @type {symbol}\n */\nconst controller = Symbol();\n\n/**\n * AbortControllerRegistry does not actually remember active event listeners: instead\n * it ties them to an AbortSignal and uses an AbortController to remove them all at once.\n */\nclass AbortControllerRegistry {\n    constructor() {\n        /**\n         * Stores the AbortController that can be used to remove all currently active listeners.\n         *\n         * @private\n         * @name {@link controller}\n         * @member {AbortController}\n         */\n        this[controller] = new AbortController();\n    }\n\n    /**\n     * Returns an options object for addEventListener that ties the listener\n     * to the AbortSignal from the current AbortController.\n     *\n     * @param {HTMLElement} element An HTML element\n     * @param {string[]} triggers The list of active WML trigger events for the specified elements\n     * @returns {AddEventListenerOptions}\n     */\n    set(element, triggers) {\n        return { signal: this[controller].signal };\n    }\n\n    /**\n     * Removes all registered event listeners.\n     *\n     * @returns {void}\n     */\n    reset() {\n        this[controller].abort();\n        this[controller] = new AbortController();\n    }\n}\n\n/**\n * @type {symbol}\n */\nconst triggerMap = Symbol();\n\n/**\n * @type {symbol}\n */\nconst elementCount = Symbol();\n\n/**\n * WeakMapRegistry maps active trigger events to each DOM element through a WeakMap.\n * This ensures that the mapping remains private to this module, while still allowing garbage\n * collection of the involved elements.\n */\nclass WeakMapRegistry {\n    constructor() {\n        /**\n         * Stores the current element-to-trigger mapping.\n         *\n         * @private\n         * @name {@link triggerMap}\n         * @member {WeakMap<HTMLElement, string[]>}\n         */\n        this[triggerMap] = new WeakMap();\n\n        /**\n         * Counts the number of elements with active WML triggers.\n         *\n         * @private\n         * @name {@link elementCount}\n         * @member {number}\n         */\n        this[elementCount] = 0;\n    }\n\n    /**\n     * Sets the active triggers for the specified element.\n     *\n     * @param {HTMLElement} element An HTML element\n     * @param {string[]} triggers The list of active WML trigger events for the specified element\n     * @returns {AddEventListenerOptions}\n     */\n    set(element, triggers) {\n        this[elementCount] += !this[triggerMap].has(element);\n        this[triggerMap].set(element, triggers);\n        return {};\n    }\n\n    /**\n     * Removes all registered event listeners.\n     *\n     * @returns {void}\n     */\n    reset() {\n        if (this[elementCount] <= 0)\n            return;\n\n        for (const element of document.body.querySelectorAll('*')) {\n            if (this[elementCount] <= 0)\n                break;\n\n            const triggers = this[triggerMap].get(element);\n            this[elementCount] -= (typeof triggers !== \"undefined\");\n\n            for (const trigger of triggers || [])\n                element.removeEventListener(trigger, onWMLTriggered);\n        }\n\n        this[triggerMap] = new WeakMap();\n        this[elementCount] = 0;\n    }\n}\n\nconst triggerRegistry = canAbortListeners() ? new AbortControllerRegistry() : new WeakMapRegistry();\n\n/**\n * Adds event listeners to the specified element.\n *\n * @param {HTMLElement} element\n * @return {void}\n */\nfunction addWMLListeners(element) {\n    const triggerRegExp = /\\S+/g;\n    const triggerAttr = (element.getAttribute('wml-trigger') || \"click\");\n    const triggers = [];\n\n    let match;\n    while ((match = triggerRegExp.exec(triggerAttr)) !== null)\n        triggers.push(match[0]);\n\n    const options = triggerRegistry.set(element, triggers);\n    for (const trigger of triggers)\n        element.addEventListener(trigger, onWMLTriggered, options);\n}\n\n/**\n * Schedules an automatic reload of WML to be performed as soon as the document is fully loaded.\n *\n * @return {void}\n */\nexport function Enable() {\n    whenReady(Reload);\n}\n\n/**\n * Reloads the WML page by adding necessary event listeners and browser listeners.\n *\n * @return {void}\n */\nexport function Reload() {\n    triggerRegistry.reset();\n    document.body.querySelectorAll('[wml-event], [wml-window], [wml-openurl]').forEach(addWMLListeners);\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\n\nconst call = newRuntimeCallerWithID(objectNames.Browser, '');\nconst BrowserOpenURL = 0;\n\n/**\n * Open a browser window to the given URL\n * @param {string} url - The URL to open\n * @returns {Promise<string>}\n */\nexport function OpenURL(url) {\n    return call(BrowserOpenURL, {url});\n}\n", "let urlAlphabet =\n  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'\nexport let customAlphabet = (alphabet, defaultSize = 21) => {\n  return (size = defaultSize) => {\n    let id = ''\n    let i = size\n    while (i--) {\n      id += alphabet[(Math.random() * alphabet.length) | 0]\n    }\n    return id\n  }\n}\nexport let nanoid = (size = 21) => {\n  let id = ''\n  let i = size\n  while (i--) {\n    id += urlAlphabet[(Math.random() * 64) | 0]\n  }\n  return id\n}\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\nimport { nanoid } from 'nanoid/non-secure';\n\nconst runtimeURL = window.location.origin + \"/wails/runtime\";\n\n// Object Names\nexport const objectNames = {\n    Call: 0,\n    Clipboard: 1,\n    Application: 2,\n    Events: 3,\n    ContextMenu: 4,\n    Dialog: 5,\n    Window: 6,\n    Screens: 7,\n    System: 8,\n    Browser: 9,\n    CancelCall: 10,\n}\nexport let clientId = nanoid();\n\n/**\n * Creates a runtime caller function that invokes a specified method on a given object within a specified window context.\n *\n * @param {Object} object - The object on which the method is to be invoked.\n * @param {string} windowName - The name of the window context in which the method should be called.\n * @returns {Function} A runtime caller function that takes the method name and optionally arguments and invokes the method within the specified window context.\n */\nexport function newRuntimeCaller(object, windowName) {\n    return function (method, args=null) {\n        return runtimeCall(object + \".\" + method, windowName, args);\n    };\n}\n\n/**\n * Creates a new runtime caller with specified ID.\n *\n * @param {object} object - The object to invoke the method on.\n * @param {string} windowName - The name of the window.\n * @return {Function} - The new runtime caller function.\n */\nexport function newRuntimeCallerWithID(object, windowName) {\n    return function (method, args=null) {\n        return runtimeCallWithID(object, method, windowName, args);\n    };\n}\n\n\nfunction runtimeCall(method, windowName, args) {\n    let url = new URL(runtimeURL);\n    if( method ) {\n        url.searchParams.append(\"method\", method);\n    }\n    let fetchOptions = {\n        headers: {},\n    };\n    if (windowName) {\n        fetchOptions.headers[\"x-wails-window-name\"] = windowName;\n    }\n    if (args) {\n        url.searchParams.append(\"args\", JSON.stringify(args));\n    }\n    fetchOptions.headers[\"x-wails-client-id\"] = clientId;\n\n    return new Promise((resolve, reject) => {\n        fetch(url, fetchOptions)\n            .then(response => {\n                if (response.ok) {\n                    // check content type\n                    if (response.headers.get(\"Content-Type\") && response.headers.get(\"Content-Type\").indexOf(\"application/json\") !== -1) {\n                        return response.json();\n                    } else {\n                        return response.text();\n                    }\n                }\n                reject(Error(response.statusText));\n            })\n            .then(data => resolve(data))\n            .catch(error => reject(error));\n    });\n}\n\nfunction runtimeCallWithID(objectID, method, windowName, args) {\n    let url = new URL(runtimeURL);\n    url.searchParams.append(\"object\", objectID);\n    url.searchParams.append(\"method\", method);\n    let fetchOptions = {\n        headers: {},\n    };\n    if (windowName) {\n        fetchOptions.headers[\"x-wails-window-name\"] = windowName;\n    }\n    if (args) {\n        url.searchParams.append(\"args\", JSON.stringify(args));\n    }\n    fetchOptions.headers[\"x-wails-client-id\"] = clientId;\n    return new Promise((resolve, reject) => {\n        fetch(url, fetchOptions)\n            .then(response => {\n                if (response.ok) {\n                    // check content type\n                    if (response.headers.get(\"Content-Type\") && response.headers.get(\"Content-Type\").indexOf(\"application/json\") !== -1) {\n                        return response.json();\n                    } else {\n                        return response.text();\n                    }\n                }\n                reject(Error(response.statusText));\n            })\n            .then(data => resolve(data))\n            .catch(error => reject(error));\n    });\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\n/**\n * @typedef {Object} OpenFileDialogOptions\n * @property {boolean} [CanChooseDirectories] - Indicates if directories can be chosen.\n * @property {boolean} [CanChooseFiles] - Indicates if files can be chosen.\n * @property {boolean} [CanCreateDirectories] - Indicates if directories can be created.\n * @property {boolean} [ShowHiddenFiles] - Indicates if hidden files should be shown.\n * @property {boolean} [ResolvesAliases] - Indicates if aliases should be resolved.\n * @property {boolean} [AllowsMultipleSelection] - Indicates if multiple selection is allowed.\n * @property {boolean} [HideExtension] - Indicates if the extension should be hidden.\n * @property {boolean} [CanSelectHiddenExtension] - Indicates if hidden extensions can be selected.\n * @property {boolean} [TreatsFilePackagesAsDirectories] - Indicates if file packages should be treated as directories.\n * @property {boolean} [AllowsOtherFiletypes] - Indicates if other file types are allowed.\n * @property {FileFilter[]} [Filters] - Array of file filters.\n * @property {string} [Title] - Title of the dialog.\n * @property {string} [Message] - Message to show in the dialog.\n * @property {string} [ButtonText] - Text to display on the button.\n * @property {string} [Directory] - Directory to open in the dialog.\n * @property {boolean} [Detached] - Indicates if the dialog should appear detached from the main window.\n */\n\n\n/**\n * @typedef {Object} SaveFileDialogOptions\n * @property {string} [Filename] - Default filename to use in the dialog.\n * @property {boolean} [CanChooseDirectories] - Indicates if directories can be chosen.\n * @property {boolean} [CanChooseFiles] - Indicates if files can be chosen.\n * @property {boolean} [CanCreateDirectories] - Indicates if directories can be created.\n * @property {boolean} [ShowHiddenFiles] - Indicates if hidden files should be shown.\n * @property {boolean} [ResolvesAliases] - Indicates if aliases should be resolved.\n * @property {boolean} [AllowsMultipleSelection] - Indicates if multiple selection is allowed.\n * @property {boolean} [HideExtension] - Indicates if the extension should be hidden.\n * @property {boolean} [CanSelectHiddenExtension] - Indicates if hidden extensions can be selected.\n * @property {boolean} [TreatsFilePackagesAsDirectories] - Indicates if file packages should be treated as directories.\n * @property {boolean} [AllowsOtherFiletypes] - Indicates if other file types are allowed.\n * @property {FileFilter[]} [Filters] - Array of file filters.\n * @property {string} [Title] - Title of the dialog.\n * @property {string} [Message] - Message to show in the dialog.\n * @property {string} [ButtonText] - Text to display on the button.\n * @property {string} [Directory] - Directory to open in the dialog.\n * @property {boolean} [Detached] - Indicates if the dialog should appear detached from the main window.\n */\n\n/**\n * @typedef {Object} MessageDialogOptions\n * @property {string} [Title] - The title of the dialog window.\n * @property {string} [Message] - The main message to show in the dialog.\n * @property {Button[]} [Buttons] - Array of button options to show in the dialog.\n * @property {boolean} [Detached] - True if the dialog should appear detached from the main window (if applicable).\n */\n\n/**\n * @typedef {Object} Button\n * @property {string} [Label] - Text that appears within the button.\n * @property {boolean} [IsCancel] - True if the button should cancel an operation when clicked.\n * @property {boolean} [IsDefault] - True if the button should be the default action when the user presses enter.\n */\n\n/**\n * @typedef {Object} FileFilter\n * @property {string} [DisplayName] - Display name for the filter, it could be \"Text Files\", \"Images\" etc.\n * @property {string} [Pattern] - Pattern to match for the filter, e.g. \"*.txt;*.md\" for text markdown files.\n */\n\n// setup\nwindow._wails = window._wails || {};\nwindow._wails.dialogErrorCallback = dialogErrorCallback;\nwindow._wails.dialogResultCallback = dialogResultCallback;\n\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\n\nimport { nanoid } from 'nanoid/non-secure';\n\n// Define constants from the `methods` object in Title Case\nconst DialogInfo = 0;\nconst DialogWarning = 1;\nconst DialogError = 2;\nconst DialogQuestion = 3;\nconst DialogOpenFile = 4;\nconst DialogSaveFile = 5;\n\nconst call = newRuntimeCallerWithID(objectNames.Dialog, '');\nconst dialogResponses = new Map();\n\n/**\n * Generates a unique id that is not present in dialogResponses.\n * @returns {string} unique id\n */\nfunction generateID() {\n    let result;\n    do {\n        result = nanoid();\n    } while (dialogResponses.has(result));\n    return result;\n}\n\n/**\n * Shows a dialog of specified type with the given options.\n * @param {number} type - type of dialog\n * @param {MessageDialogOptions|OpenFileDialogOptions|SaveFileDialogOptions} options - options for the dialog\n * @returns {Promise} promise that resolves with result of dialog\n */\nfunction dialog(type, options = {}) {\n    const id = generateID();\n    options[\"dialog-id\"] = id;\n    return new Promise((resolve, reject) => {\n        dialogResponses.set(id, {resolve, reject});\n        call(type, options).catch((error) => {\n            reject(error);\n            dialogResponses.delete(id);\n        });\n    });\n}\n\n/**\n * Handles the callback from a dialog.\n *\n * @param {string} id - The ID of the dialog response.\n * @param {string} data - The data received from the dialog.\n * @param {boolean} isJSON - Flag indicating whether the data is in JSON format.\n *\n * @return {undefined}\n */\nfunction dialogResultCallback(id, data, isJSON) {\n    let p = dialogResponses.get(id);\n    if (p) {\n        if (isJSON) {\n            p.resolve(JSON.parse(data));\n        } else {\n            p.resolve(data);\n        }\n        dialogResponses.delete(id);\n    }\n}\n\n/**\n * Callback function for handling errors in dialog.\n *\n * @param {string} id - The id of the dialog response.\n * @param {string} message - The error message.\n *\n * @return {void}\n */\nfunction dialogErrorCallback(id, message) {\n    let p = dialogResponses.get(id);\n    if (p) {\n        p.reject(message);\n        dialogResponses.delete(id);\n    }\n}\n\n\n// Replace `methods` with constants in Title Case\n\n/**\n * @param {MessageDialogOptions} options - Dialog options\n * @returns {Promise<string>} - The label of the button pressed\n */\nexport const Info = (options) => dialog(DialogInfo, options);\n\n/**\n * @param {MessageDialogOptions} options - Dialog options\n * @returns {Promise<string>} - The label of the button pressed\n */\nexport const Warning = (options) => dialog(DialogWarning, options);\n\n/**\n * @param {MessageDialogOptions} options - Dialog options\n * @returns {Promise<string>} - The label of the button pressed\n */\nexport const Error = (options) => dialog(DialogError, options);\n\n/**\n * @param {MessageDialogOptions} options - Dialog options\n * @returns {Promise<string>} - The label of the button pressed\n */\nexport const Question = (options) => dialog(DialogQuestion, options);\n\n/**\n * @param {OpenFileDialogOptions} options - Dialog options\n * @returns {Promise<string[]|string>} Returns selected file or list of files. Returns blank string if no file is selected.\n */\nexport const OpenFile = (options) => dialog(DialogOpenFile, options);\n\n/**\n * @param {SaveFileDialogOptions} options - Dialog options\n * @returns {Promise<string>} Returns the selected file. Returns blank string if no file is selected.\n */\nexport const SaveFile = (options) => dialog(DialogSaveFile, options);\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\n/**\n * @typedef {import(\"./types\").WailsEvent} WailsEvent\n */\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\n\nimport {EventTypes} from \"./event_types\";\nexport const Types = EventTypes;\n\n// Setup\nwindow._wails = window._wails || {};\nwindow._wails.dispatchWailsEvent = dispatchWailsEvent;\n\nconst call = newRuntimeCallerWithID(objectNames.Events, '');\nconst EmitMethod = 0;\nconst eventListeners = new Map();\n\nclass Listener {\n    constructor(eventName, callback, maxCallbacks) {\n        this.eventName = eventName;\n        this.maxCallbacks = maxCallbacks || -1;\n        this.Callback = (data) => {\n            callback(data);\n            if (this.maxCallbacks === -1) return false;\n            this.maxCallbacks -= 1;\n            return this.maxCallbacks === 0;\n        };\n    }\n}\n\nexport class WailsEvent {\n    constructor(name, data = null) {\n        this.name = name;\n        this.data = data;\n    }\n}\n\nexport function setup() {\n}\n\nfunction dispatchWailsEvent(event) {\n    let listeners = eventListeners.get(event.name);\n    if (listeners) {\n        let toRemove = listeners.filter(listener => {\n            let remove = listener.Callback(event);\n            if (remove) return true;\n        });\n        if (toRemove.length > 0) {\n            listeners = listeners.filter(l => !toRemove.includes(l));\n            if (listeners.length === 0) eventListeners.delete(event.name);\n            else eventListeners.set(event.name, listeners);\n        }\n    }\n}\n\n/**\n * Register a callback function to be called multiple times for a specific event.\n *\n * @param {string} eventName - The name of the event to register the callback for.\n * @param {function} callback - The callback function to be called when the event is triggered.\n * @param {number} maxCallbacks - The maximum number of times the callback can be called for the event. Once the maximum number is reached, the callback will no longer be called.\n *\n @return {function} - A function that, when called, will unregister the callback from the event.\n */\nexport function OnMultiple(eventName, callback, maxCallbacks) {\n    let listeners = eventListeners.get(eventName) || [];\n    const thisListener = new Listener(eventName, callback, maxCallbacks);\n    listeners.push(thisListener);\n    eventListeners.set(eventName, listeners);\n    return () => listenerOff(thisListener);\n}\n\n/**\n * Registers a callback function to be executed when the specified event occurs.\n *\n * @param {string} eventName - The name of the event.\n * @param {function} callback - The callback function to be executed. It takes no parameters.\n * @return {function} - A function that, when called, will unregister the callback from the event. */\nexport function On(eventName, callback) { return OnMultiple(eventName, callback, -1); }\n\n/**\n * Registers a callback function to be executed only once for the specified event.\n *\n * @param {string} eventName - The name of the event.\n * @param {function} callback - The function to be executed when the event occurs.\n * @return {function} - A function that, when called, will unregister the callback from the event.\n */\nexport function Once(eventName, callback) { return OnMultiple(eventName, callback, 1); }\n\n/**\n * Removes the specified listener from the event listeners collection.\n * If all listeners for the event are removed, the event key is deleted from the collection.\n *\n * @param {Object} listener - The listener to be removed.\n */\nfunction listenerOff(listener) {\n    const eventName = listener.eventName;\n    let listeners = eventListeners.get(eventName).filter(l => l !== listener);\n    if (listeners.length === 0) eventListeners.delete(eventName);\n    else eventListeners.set(eventName, listeners);\n}\n\n\n/**\n * Removes event listeners for the specified event names.\n *\n * @param {string} eventName - The name of the event to remove listeners for.\n * @param {...string} additionalEventNames - Additional event names to remove listeners for.\n * @return {undefined}\n */\nexport function Off(eventName, ...additionalEventNames) {\n    let eventsToRemove = [eventName, ...additionalEventNames];\n    eventsToRemove.forEach(eventName => eventListeners.delete(eventName));\n}\n/**\n * Removes all event listeners.\n *\n * @function OffAll\n * @returns {void}\n */\nexport function OffAll() { eventListeners.clear(); }\n\n/**\n * Emits an event using the given event name.\n *\n * @param {WailsEvent} event - The name of the event to emit.\n * @returns {any} - The result of the emitted event.\n */\nexport function Emit(event) { return call(EmitMethod, event); }\n", "\nexport const EventTypes = {\n\tWindows: {\n\t\tSystemThemeChanged: \"windows:SystemThemeChanged\",\n\t\tAPMPowerStatusChange: \"windows:APMPowerStatusChange\",\n\t\tAPMSuspend: \"windows:APMSuspend\",\n\t\tAPMResumeAutomatic: \"windows:APMResumeAutomatic\",\n\t\tAPMResumeSuspend: \"windows:APMResumeSuspend\",\n\t\tAPMPowerSettingChange: \"windows:APMPowerSettingChange\",\n\t\tApplicationStarted: \"windows:ApplicationStarted\",\n\t\tWebViewNavigationCompleted: \"windows:WebViewNavigationCompleted\",\n\t\tWindowInactive: \"windows:WindowInactive\",\n\t\tWindowActive: \"windows:WindowActive\",\n\t\tWindowClickActive: \"windows:WindowClickActive\",\n\t\tWindowMaximise: \"windows:WindowMaximise\",\n\t\tWindowUnMaximise: \"windows:WindowUnMaximise\",\n\t\tWindowFullscreen: \"windows:WindowFullscreen\",\n\t\tWindowUnFullscreen: \"windows:WindowUnFullscreen\",\n\t\tWindowRestore: \"windows:WindowRestore\",\n\t\tWindowMinimise: \"windows:WindowMinimise\",\n\t\tWindowUnMinimise: \"windows:WindowUnMinimise\",\n\t\tWindowClose: \"windows:WindowClose\",\n\t\tWindowSetFocus: \"windows:WindowSetFocus\",\n\t\tWindowKillFocus: \"windows:WindowKillFocus\",\n\t\tWindowDragDrop: \"windows:WindowDragDrop\",\n\t\tWindowDragEnter: \"windows:WindowDragEnter\",\n\t\tWindowDragLeave: \"windows:WindowDragLeave\",\n\t\tWindowDragOver: \"windows:WindowDragOver\",\n\t\tWindowDidMove: \"windows:WindowDidMove\",\n\t\tWindowDidResize: \"windows:WindowDidResize\",\n\t},\n\tMac: {\n\t\tApplicationDidBecomeActive: \"mac:ApplicationDidBecomeActive\",\n\t\tApplicationDidChangeBackingProperties: \"mac:ApplicationDidChangeBackingProperties\",\n\t\tApplicationDidChangeEffectiveAppearance: \"mac:ApplicationDidChangeEffectiveAppearance\",\n\t\tApplicationDidChangeIcon: \"mac:ApplicationDidChangeIcon\",\n\t\tApplicationDidChangeOcclusionState: \"mac:ApplicationDidChangeOcclusionState\",\n\t\tApplicationDidChangeScreenParameters: \"mac:ApplicationDidChangeScreenParameters\",\n\t\tApplicationDidChangeStatusBarFrame: \"mac:ApplicationDidChangeStatusBarFrame\",\n\t\tApplicationDidChangeStatusBarOrientation: \"mac:ApplicationDidChangeStatusBarOrientation\",\n\t\tApplicationDidFinishLaunching: \"mac:ApplicationDidFinishLaunching\",\n\t\tApplicationDidHide: \"mac:ApplicationDidHide\",\n\t\tApplicationDidResignActiveNotification: \"mac:ApplicationDidResignActiveNotification\",\n\t\tApplicationDidUnhide: \"mac:ApplicationDidUnhide\",\n\t\tApplicationDidUpdate: \"mac:ApplicationDidUpdate\",\n\t\tApplicationWillBecomeActive: \"mac:ApplicationWillBecomeActive\",\n\t\tApplicationWillFinishLaunching: \"mac:ApplicationWillFinishLaunching\",\n\t\tApplicationWillHide: \"mac:ApplicationWillHide\",\n\t\tApplicationWillResignActive: \"mac:ApplicationWillResignActive\",\n\t\tApplicationWillTerminate: \"mac:ApplicationWillTerminate\",\n\t\tApplicationWillUnhide: \"mac:ApplicationWillUnhide\",\n\t\tApplicationWillUpdate: \"mac:ApplicationWillUpdate\",\n\t\tApplicationDidChangeTheme: \"mac:ApplicationDidChangeTheme!\",\n\t\tApplicationShouldHandleReopen: \"mac:ApplicationShouldHandleReopen!\",\n\t\tWindowDidBecomeKey: \"mac:WindowDidBecomeKey\",\n\t\tWindowDidBecomeMain: \"mac:WindowDidBecomeMain\",\n\t\tWindowDidBeginSheet: \"mac:WindowDidBeginSheet\",\n\t\tWindowDidChangeAlpha: \"mac:WindowDidChangeAlpha\",\n\t\tWindowDidChangeBackingLocation: \"mac:WindowDidChangeBackingLocation\",\n\t\tWindowDidChangeBackingProperties: \"mac:WindowDidChangeBackingProperties\",\n\t\tWindowDidChangeCollectionBehavior: \"mac:WindowDidChangeCollectionBehavior\",\n\t\tWindowDidChangeEffectiveAppearance: \"mac:WindowDidChangeEffectiveAppearance\",\n\t\tWindowDidChangeOcclusionState: \"mac:WindowDidChangeOcclusionState\",\n\t\tWindowDidChangeOrderingMode: \"mac:WindowDidChangeOrderingMode\",\n\t\tWindowDidChangeScreen: \"mac:WindowDidChangeScreen\",\n\t\tWindowDidChangeScreenParameters: \"mac:WindowDidChangeScreenParameters\",\n\t\tWindowDidChangeScreenProfile: \"mac:WindowDidChangeScreenProfile\",\n\t\tWindowDidChangeScreenSpace: \"mac:WindowDidChangeScreenSpace\",\n\t\tWindowDidChangeScreenSpaceProperties: \"mac:WindowDidChangeScreenSpaceProperties\",\n\t\tWindowDidChangeSharingType: \"mac:WindowDidChangeSharingType\",\n\t\tWindowDidChangeSpace: \"mac:WindowDidChangeSpace\",\n\t\tWindowDidChangeSpaceOrderingMode: \"mac:WindowDidChangeSpaceOrderingMode\",\n\t\tWindowDidChangeTitle: \"mac:WindowDidChangeTitle\",\n\t\tWindowDidChangeToolbar: \"mac:WindowDidChangeToolbar\",\n\t\tWindowDidChangeVisibility: \"mac:WindowDidChangeVisibility\",\n\t\tWindowDidDeminiaturize: \"mac:WindowDidDeminiaturize\",\n\t\tWindowDidEndSheet: \"mac:WindowDidEndSheet\",\n\t\tWindowDidEnterFullScreen: \"mac:WindowDidEnterFullScreen\",\n\t\tWindowDidEnterVersionBrowser: \"mac:WindowDidEnterVersionBrowser\",\n\t\tWindowDidExitFullScreen: \"mac:WindowDidExitFullScreen\",\n\t\tWindowDidExitVersionBrowser: \"mac:WindowDidExitVersionBrowser\",\n\t\tWindowDidExpose: \"mac:WindowDidExpose\",\n\t\tWindowDidFocus: \"mac:WindowDidFocus\",\n\t\tWindowDidMiniaturize: \"mac:WindowDidMiniaturize\",\n\t\tWindowDidMove: \"mac:WindowDidMove\",\n\t\tWindowDidOrderOffScreen: \"mac:WindowDidOrderOffScreen\",\n\t\tWindowDidOrderOnScreen: \"mac:WindowDidOrderOnScreen\",\n\t\tWindowDidResignKey: \"mac:WindowDidResignKey\",\n\t\tWindowDidResignMain: \"mac:WindowDidResignMain\",\n\t\tWindowDidResize: \"mac:WindowDidResize\",\n\t\tWindowDidUpdate: \"mac:WindowDidUpdate\",\n\t\tWindowDidUpdateAlpha: \"mac:WindowDidUpdateAlpha\",\n\t\tWindowDidUpdateCollectionBehavior: \"mac:WindowDidUpdateCollectionBehavior\",\n\t\tWindowDidUpdateCollectionProperties: \"mac:WindowDidUpdateCollectionProperties\",\n\t\tWindowDidUpdateShadow: \"mac:WindowDidUpdateShadow\",\n\t\tWindowDidUpdateTitle: \"mac:WindowDidUpdateTitle\",\n\t\tWindowDidUpdateToolbar: \"mac:WindowDidUpdateToolbar\",\n\t\tWindowDidUpdateVisibility: \"mac:WindowDidUpdateVisibility\",\n\t\tWindowShouldClose: \"mac:WindowShouldClose!\",\n\t\tWindowWillBecomeKey: \"mac:WindowWillBecomeKey\",\n\t\tWindowWillBecomeMain: \"mac:WindowWillBecomeMain\",\n\t\tWindowWillBeginSheet: \"mac:WindowWillBeginSheet\",\n\t\tWindowWillChangeOrderingMode: \"mac:WindowWillChangeOrderingMode\",\n\t\tWindowWillClose: \"mac:WindowWillClose\",\n\t\tWindowWillDeminiaturize: \"mac:WindowWillDeminiaturize\",\n\t\tWindowWillEnterFullScreen: \"mac:WindowWillEnterFullScreen\",\n\t\tWindowWillEnterVersionBrowser: \"mac:WindowWillEnterVersionBrowser\",\n\t\tWindowWillExitFullScreen: \"mac:WindowWillExitFullScreen\",\n\t\tWindowWillExitVersionBrowser: \"mac:WindowWillExitVersionBrowser\",\n\t\tWindowWillFocus: \"mac:WindowWillFocus\",\n\t\tWindowWillMiniaturize: \"mac:WindowWillMiniaturize\",\n\t\tWindowWillMove: \"mac:WindowWillMove\",\n\t\tWindowWillOrderOffScreen: \"mac:WindowWillOrderOffScreen\",\n\t\tWindowWillOrderOnScreen: \"mac:WindowWillOrderOnScreen\",\n\t\tWindowWillResignMain: \"mac:WindowWillResignMain\",\n\t\tWindowWillResize: \"mac:WindowWillResize\",\n\t\tWindowWillUnfocus: \"mac:WindowWillUnfocus\",\n\t\tWindowWillUpdate: \"mac:WindowWillUpdate\",\n\t\tWindowWillUpdateAlpha: \"mac:WindowWillUpdateAlpha\",\n\t\tWindowWillUpdateCollectionBehavior: \"mac:WindowWillUpdateCollectionBehavior\",\n\t\tWindowWillUpdateCollectionProperties: \"mac:WindowWillUpdateCollectionProperties\",\n\t\tWindowWillUpdateShadow: \"mac:WindowWillUpdateShadow\",\n\t\tWindowWillUpdateTitle: \"mac:WindowWillUpdateTitle\",\n\t\tWindowWillUpdateToolbar: \"mac:WindowWillUpdateToolbar\",\n\t\tWindowWillUpdateVisibility: \"mac:WindowWillUpdateVisibility\",\n\t\tWindowWillUseStandardFrame: \"mac:WindowWillUseStandardFrame\",\n\t\tMenuWillOpen: \"mac:MenuWillOpen\",\n\t\tMenuDidOpen: \"mac:MenuDidOpen\",\n\t\tMenuDidClose: \"mac:MenuDidClose\",\n\t\tMenuWillSendAction: \"mac:MenuWillSendAction\",\n\t\tMenuDidSendAction: \"mac:MenuDidSendAction\",\n\t\tMenuWillHighlightItem: \"mac:MenuWillHighlightItem\",\n\t\tMenuDidHighlightItem: \"mac:MenuDidHighlightItem\",\n\t\tMenuWillDisplayItem: \"mac:MenuWillDisplayItem\",\n\t\tMenuDidDisplayItem: \"mac:MenuDidDisplayItem\",\n\t\tMenuWillAddItem: \"mac:MenuWillAddItem\",\n\t\tMenuDidAddItem: \"mac:MenuDidAddItem\",\n\t\tMenuWillRemoveItem: \"mac:MenuWillRemoveItem\",\n\t\tMenuDidRemoveItem: \"mac:MenuDidRemoveItem\",\n\t\tMenuWillBeginTracking: \"mac:MenuWillBeginTracking\",\n\t\tMenuDidBeginTracking: \"mac:MenuDidBeginTracking\",\n\t\tMenuWillEndTracking: \"mac:MenuWillEndTracking\",\n\t\tMenuDidEndTracking: \"mac:MenuDidEndTracking\",\n\t\tMenuWillUpdate: \"mac:MenuWillUpdate\",\n\t\tMenuDidUpdate: \"mac:MenuDidUpdate\",\n\t\tMenuWillPopUp: \"mac:MenuWillPopUp\",\n\t\tMenuDidPopUp: \"mac:MenuDidPopUp\",\n\t\tMenuWillSendActionToItem: \"mac:MenuWillSendActionToItem\",\n\t\tMenuDidSendActionToItem: \"mac:MenuDidSendActionToItem\",\n\t\tWebViewDidStartProvisionalNavigation: \"mac:WebViewDidStartProvisionalNavigation\",\n\t\tWebViewDidReceiveServerRedirectForProvisionalNavigation: \"mac:WebViewDidReceiveServerRedirectForProvisionalNavigation\",\n\t\tWebViewDidFinishNavigation: \"mac:WebViewDidFinishNavigation\",\n\t\tWebViewDidCommitNavigation: \"mac:WebViewDidCommitNavigation\",\n\t\tWindowFileDraggingEntered: \"mac:WindowFileDraggingEntered\",\n\t\tWindowFileDraggingPerformed: \"mac:WindowFileDraggingPerformed\",\n\t\tWindowFileDraggingExited: \"mac:WindowFileDraggingExited\",\n\t},\n\tLinux: {\n\t\tSystemThemeChanged: \"linux:SystemThemeChanged\",\n\t\tWindowLoadChanged: \"linux:WindowLoadChanged\",\n\t\tWindowDeleteEvent: \"linux:WindowDeleteEvent\",\n\t\tWindowDidMove: \"linux:WindowDidMove\",\n\t\tWindowDidResize: \"linux:WindowDidResize\",\n\t\tWindowFocusIn: \"linux:WindowFocusIn\",\n\t\tWindowFocusOut: \"linux:WindowFocusOut\",\n\t\tApplicationStartup: \"linux:ApplicationStartup\",\n\t},\n\tCommon: {\n\t\tApplicationStarted: \"common:ApplicationStarted\",\n\t\tWindowMaximise: \"common:WindowMaximise\",\n\t\tWindowUnMaximise: \"common:WindowUnMaximise\",\n\t\tWindowFullscreen: \"common:WindowFullscreen\",\n\t\tWindowUnFullscreen: \"common:WindowUnFullscreen\",\n\t\tWindowRestore: \"common:WindowRestore\",\n\t\tWindowMinimise: \"common:WindowMinimise\",\n\t\tWindowUnMinimise: \"common:WindowUnMinimise\",\n\t\tWindowClosing: \"common:WindowClosing\",\n\t\tWindowZoom: \"common:WindowZoom\",\n\t\tWindowZoomIn: \"common:WindowZoomIn\",\n\t\tWindowZoomOut: \"common:WindowZoomOut\",\n\t\tWindowZoomReset: \"common:WindowZoomReset\",\n\t\tWindowFocus: \"common:WindowFocus\",\n\t\tWindowLostFocus: \"common:WindowLostFocus\",\n\t\tWindowShow: \"common:WindowShow\",\n\t\tWindowHide: \"common:WindowHide\",\n\t\tWindowDPIChanged: \"common:WindowDPIChanged\",\n\t\tWindowFilesDropped: \"common:WindowFilesDropped\",\n\t\tWindowRuntimeReady: \"common:WindowRuntimeReady\",\n\t\tThemeChanged: \"common:ThemeChanged\",\n\t\tWindowDidMove: \"common:WindowDidMove\",\n\t\tWindowDidResize: \"common:WindowDidResize\",\n\t},\n};\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/**\n * Logs a message to the console with custom formatting.\n * @param {string} message - The message to be logged.\n * @return {void}\n */\nexport function debugLog(message) {\n    // eslint-disable-next-line\n    console.log(\n        '%c wails3 %c ' + message + ' ',\n        'background: #aa0000; color: #fff; border-radius: 3px 0px 0px 3px; padding: 1px; font-size: 0.7rem',\n        'background: #009900; color: #fff; border-radius: 0px 3px 3px 0px; padding: 1px; font-size: 0.7rem'\n    );\n}\n\n/**\n * Checks whether the browser supports removing listeners by triggering an AbortSignal\n * (see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#signal)\n *\n * @return {boolean}\n */\nexport function canAbortListeners() {\n    if (!EventTarget || !AbortSignal || !AbortController)\n        return false;\n\n    let result = true;\n\n    const target = new EventTarget();\n    const controller = new AbortController();\n    target.addEventListener('test', () => { result = false; }, { signal: controller.signal });\n    controller.abort();\n    target.dispatchEvent(new CustomEvent('test'));\n\n    return result;\n}\n\n/***\n This technique for proper load detection is taken from HTMX:\n\n BSD 2-Clause License\n\n Copyright (c) 2020, Big Sky Software\n All rights reserved.\n\n Redistribution and use in source and binary forms, with or without\n modification, are permitted provided that the following conditions are met:\n\n 1. Redistributions of source code must retain the above copyright notice, this\n list of conditions and the following disclaimer.\n\n 2. Redistributions in binary form must reproduce the above copyright notice,\n this list of conditions and the following disclaimer in the documentation\n and/or other materials provided with the distribution.\n\n THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n ***/\n\nlet isReady = false;\ndocument.addEventListener('DOMContentLoaded', () => isReady = true);\n\nexport function whenReady(callback) {\n    if (isReady || document.readyState === 'complete') {\n        callback();\n    } else {\n        document.addEventListener('DOMContentLoaded', callback);\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\n// Import screen jsdoc definition from ./screens.js\n/**\n * @typedef {import(\"./screens\").Screen} Screen\n */\n\n\n/**\n * A record describing the position of a window.\n *\n * @typedef {Object} Position\n * @property {number} x - The horizontal position of the window\n * @property {number} y - The vertical position of the window\n */\n\n\n/**\n * A record describing the size of a window.\n *\n * @typedef {Object} Size\n * @property {number} width - The width of the window\n * @property {number} height - The height of the window\n */\n\n\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\n\nconst PositionMethod                    = 0;\nconst CenterMethod                      = 1;\nconst CloseMethod                       = 2;\nconst DisableSizeConstraintsMethod      = 3;\nconst EnableSizeConstraintsMethod       = 4;\nconst FocusMethod                       = 5;\nconst ForceReloadMethod                 = 6;\nconst FullscreenMethod                  = 7;\nconst GetScreenMethod                   = 8;\nconst GetZoomMethod                     = 9;\nconst HeightMethod                      = 10;\nconst HideMethod                        = 11;\nconst IsFocusedMethod                   = 12;\nconst IsFullscreenMethod                = 13;\nconst IsMaximisedMethod                 = 14;\nconst IsMinimisedMethod                 = 15;\nconst MaximiseMethod                    = 16;\nconst MinimiseMethod                    = 17;\nconst NameMethod                        = 18;\nconst OpenDevToolsMethod                = 19;\nconst RelativePositionMethod            = 20;\nconst ReloadMethod                      = 21;\nconst ResizableMethod                   = 22;\nconst RestoreMethod                     = 23;\nconst SetPositionMethod                 = 24;\nconst SetAlwaysOnTopMethod              = 25;\nconst SetBackgroundColourMethod         = 26;\nconst SetFramelessMethod                = 27;\nconst SetFullscreenButtonEnabledMethod  = 28;\nconst SetMaxSizeMethod                  = 29;\nconst SetMinSizeMethod                  = 30;\nconst SetRelativePositionMethod         = 31;\nconst SetResizableMethod                = 32;\nconst SetSizeMethod                     = 33;\nconst SetTitleMethod                    = 34;\nconst SetZoomMethod                     = 35;\nconst ShowMethod                        = 36;\nconst SizeMethod                        = 37;\nconst ToggleFullscreenMethod            = 38;\nconst ToggleMaximiseMethod              = 39;\nconst UnFullscreenMethod                = 40;\nconst UnMaximiseMethod                  = 41;\nconst UnMinimiseMethod                  = 42;\nconst WidthMethod                       = 43;\nconst ZoomMethod                        = 44;\nconst ZoomInMethod                      = 45;\nconst ZoomOutMethod                     = 46;\nconst ZoomResetMethod                   = 47;\n\n/**\n * @type {symbol}\n */\nconst caller = Symbol();\n\nclass Window {\n    /**\n     * Initialises a window object with the specified name.\n     *\n     * @private\n     * @param {string} name - The name of the target window.\n     */\n    constructor(name = '') {\n        /**\n         * @private\n         * @name {@link caller}\n         * @type {(...args: any[]) => any}\n         */\n        this[caller] = newRuntimeCallerWithID(objectNames.Window, name)\n\n        // bind instance method to make them easily usable in event handlers\n        for (const method of Object.getOwnPropertyNames(Window.prototype)) {\n            if (\n                method !== \"constructor\"\n                && typeof this[method] === \"function\"\n            ) {\n                this[method] = this[method].bind(this);\n            }\n        }\n    }\n\n    /**\n     * Gets the specified window.\n     *\n     * @public\n     * @param {string} name - The name of the window to get.\n     * @return {Window} - The corresponding window object.\n     */\n    Get(name) {\n        return new Window(name);\n    }\n\n    /**\n     * Returns the absolute position of the window.\n     *\n     * @public\n     * @return {Promise<Position>} - The current absolute position of the window.\n     */\n    Position() {\n        return this[caller](PositionMethod);\n    }\n\n    /**\n     * Centers the window on the screen.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Center() {\n        return this[caller](CenterMethod);\n    }\n\n    /**\n     * Closes the window.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Close() {\n        return this[caller](CloseMethod);\n    }\n\n    /**\n     * Disables min/max size constraints.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    DisableSizeConstraints() {\n        return this[caller](DisableSizeConstraintsMethod);\n    }\n\n    /**\n     * Enables min/max size constraints.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    EnableSizeConstraints() {\n        return this[caller](EnableSizeConstraintsMethod);\n    }\n\n    /**\n     * Focuses the window.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Focus() {\n        return this[caller](FocusMethod);\n    }\n\n    /**\n     * Forces the window to reload the page assets.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    ForceReload() {\n        return this[caller](ForceReloadMethod);\n    }\n\n    /**\n     * Doc.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Fullscreen() {\n        return this[caller](FullscreenMethod);\n    }\n\n    /**\n     * Returns the screen that the window is on.\n     *\n     * @public\n     * @return {Promise<Screen>} - The screen the window is currently on\n     */\n    GetScreen() {\n        return this[caller](GetScreenMethod);\n    }\n\n    /**\n     * Returns the current zoom level of the window.\n     *\n     * @public\n     * @return {Promise<number>} - The current zoom level\n     */\n    GetZoom() {\n        return this[caller](GetZoomMethod);\n    }\n\n    /**\n     * Returns the height of the window.\n     *\n     * @public\n     * @return {Promise<number>} - The current height of the window\n     */\n    Height() {\n        return this[caller](HeightMethod);\n    }\n\n    /**\n     * Hides the window.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Hide() {\n        return this[caller](HideMethod);\n    }\n\n    /**\n     * Returns true if the window is focused.\n     *\n     * @public\n     * @return {Promise<boolean>} - Whether the window is currently focused\n     */\n    IsFocused() {\n        return this[caller](IsFocusedMethod);\n    }\n\n    /**\n     * Returns true if the window is fullscreen.\n     *\n     * @public\n     * @return {Promise<boolean>} - Whether the window is currently fullscreen\n     */\n    IsFullscreen() {\n        return this[caller](IsFullscreenMethod);\n    }\n\n    /**\n     * Returns true if the window is maximised.\n     *\n     * @public\n     * @return {Promise<boolean>} - Whether the window is currently maximised\n     */\n    IsMaximised() {\n        return this[caller](IsMaximisedMethod);\n    }\n\n    /**\n     * Returns true if the window is minimised.\n     *\n     * @public\n     * @return {Promise<boolean>} - Whether the window is currently minimised\n     */\n    IsMinimised() {\n        return this[caller](IsMinimisedMethod);\n    }\n\n    /**\n     * Maximises the window.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Maximise() {\n        return this[caller](MaximiseMethod);\n    }\n\n    /**\n     * Minimises the window.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Minimise() {\n        return this[caller](MinimiseMethod);\n    }\n\n    /**\n     * Returns the name of the window.\n     *\n     * @public\n     * @return {Promise<string>} - The name of the window\n     */\n    Name() {\n        return this[caller](NameMethod);\n    }\n\n    /**\n     * Opens the development tools pane.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    OpenDevTools() {\n        return this[caller](OpenDevToolsMethod);\n    }\n\n    /**\n     * Returns the relative position of the window to the screen.\n     *\n     * @public\n     * @return {Promise<Position>} - The current relative position of the window\n     */\n    RelativePosition() {\n        return this[caller](RelativePositionMethod);\n    }\n\n    /**\n     * Reloads the page assets.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Reload() {\n        return this[caller](ReloadMethod);\n    }\n\n    /**\n     * Returns true if the window is resizable.\n     *\n     * @public\n     * @return {Promise<boolean>} - Whether the window is currently resizable\n     */\n    Resizable() {\n        return this[caller](ResizableMethod);\n    }\n\n    /**\n     * Restores the window to its previous state if it was previously minimised, maximised or fullscreen.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Restore() {\n        return this[caller](RestoreMethod);\n    }\n\n    /**\n     * Sets the absolute position of the window.\n     *\n     * @public\n     * @param {number} x - The desired horizontal absolute position of the window\n     * @param {number} y - The desired vertical absolute position of the window\n     * @return {Promise<void>}\n     */\n    SetPosition(x, y) {\n        return this[caller](SetPositionMethod, { x, y });\n    }\n\n    /**\n     * Sets the window to be always on top.\n     *\n     * @public\n     * @param {boolean} alwaysOnTop - Whether the window should stay on top\n     * @return {Promise<void>}\n     */\n    SetAlwaysOnTop(alwaysOnTop) {\n        return this[caller](SetAlwaysOnTopMethod, { alwaysOnTop });\n    }\n\n    /**\n     * Sets the background colour of the window.\n     *\n     * @public\n     * @param {number} r - The desired red component of the window background\n     * @param {number} g - The desired green component of the window background\n     * @param {number} b - The desired blue component of the window background\n     * @param {number} a - The desired alpha component of the window background\n     * @return {Promise<void>}\n     */\n    SetBackgroundColour(r, g, b, a) {\n        return this[caller](SetBackgroundColourMethod, { r, g, b, a });\n    }\n\n    /**\n     * Removes the window frame and title bar.\n     *\n     * @public\n     * @param {boolean} frameless - Whether the window should be frameless\n     * @return {Promise<void>}\n     */\n    SetFrameless(frameless) {\n        return this[caller](SetFramelessMethod, { frameless });\n    }\n\n    /**\n     * Disables the system fullscreen button.\n     *\n     * @public\n     * @param {boolean} enabled - Whether the fullscreen button should be enabled\n     * @return {Promise<void>}\n     */\n    SetFullscreenButtonEnabled(enabled) {\n        return this[caller](SetFullscreenButtonEnabledMethod, { enabled });\n    }\n\n    /**\n     * Sets the maximum size of the window.\n     *\n     * @public\n     * @param {number} width - The desired maximum width of the window\n     * @param {number} height - The desired maximum height of the window\n     * @return {Promise<void>}\n     */\n    SetMaxSize(width, height) {\n        return this[caller](SetMaxSizeMethod, { width, height });\n    }\n\n    /**\n     * Sets the minimum size of the window.\n     *\n     * @public\n     * @param {number} width - The desired minimum width of the window\n     * @param {number} height - The desired minimum height of the window\n     * @return {Promise<void>}\n     */\n    SetMinSize(width, height) {\n        return this[caller](SetMinSizeMethod, { width, height });\n    }\n\n    /**\n     * Sets the relative position of the window to the screen.\n     *\n     * @public\n     * @param {number} x - The desired horizontal relative position of the window\n     * @param {number} y - The desired vertical relative position of the window\n     * @return {Promise<void>}\n     */\n    SetRelativePosition(x, y) {\n        return this[caller](SetRelativePositionMethod, { x, y });\n    }\n\n    /**\n     * Sets whether the window is resizable.\n     *\n     * @public\n     * @param {boolean} resizable - Whether the window should be resizable\n     * @return {Promise<void>}\n     */\n    SetResizable(resizable) {\n        return this[caller](SetResizableMethod, { resizable });\n    }\n\n    /**\n     * Sets the size of the window.\n     *\n     * @public\n     * @param {number} width - The desired width of the window\n     * @param {number} height - The desired height of the window\n     * @return {Promise<void>}\n     */\n    SetSize(width, height) {\n        return this[caller](SetSizeMethod, { width, height });\n    }\n\n    /**\n     * Sets the title of the window.\n     *\n     * @public\n     * @param {string} title - The desired title of the window\n     * @return {Promise<void>}\n     */\n    SetTitle(title) {\n        return this[caller](SetTitleMethod, { title });\n    }\n\n    /**\n     * Sets the zoom level of the window.\n     *\n     * @public\n     * @param {number} zoom - The desired zoom level\n     * @return {Promise<void>}\n     */\n    SetZoom(zoom) {\n        return this[caller](SetZoomMethod, { zoom });\n    }\n\n    /**\n     * Shows the window.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Show() {\n        return this[caller](ShowMethod);\n    }\n\n    /**\n     * Returns the size of the window.\n     *\n     * @public\n     * @return {Promise<Size>} - The current size of the window\n     */\n    Size() {\n        return this[caller](SizeMethod);\n    }\n\n    /**\n     * Toggles the window between fullscreen and normal.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    ToggleFullscreen() {\n        return this[caller](ToggleFullscreenMethod);\n    }\n\n    /**\n     * Toggles the window between maximised and normal.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    ToggleMaximise() {\n        return this[caller](ToggleMaximiseMethod);\n    }\n\n    /**\n     * Un-fullscreens the window.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    UnFullscreen() {\n        return this[caller](UnFullscreenMethod);\n    }\n\n    /**\n     * Un-maximises the window.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    UnMaximise() {\n        return this[caller](UnMaximiseMethod);\n    }\n\n    /**\n     * Un-minimises the window.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    UnMinimise() {\n        return this[caller](UnMinimiseMethod);\n    }\n\n    /**\n     * Returns the width of the window.\n     *\n     * @public\n     * @return {Promise<number>} - The current width of the window\n     */\n    Width() {\n        return this[caller](WidthMethod);\n    }\n\n    /**\n     * Zooms the window.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Zoom() {\n        return this[caller](ZoomMethod);\n    }\n\n    /**\n     * Increases the zoom level of the webview content.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    ZoomIn() {\n        return this[caller](ZoomInMethod);\n    }\n\n    /**\n     * Decreases the zoom level of the webview content.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    ZoomOut() {\n        return this[caller](ZoomOutMethod);\n    }\n\n    /**\n     * Resets the zoom level of the webview content.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    ZoomReset() {\n        return this[caller](ZoomResetMethod);\n    }\n}\n\n/**\n * The window within which the script is running.\n *\n * @type {Window}\n */\nconst thisWindow = new Window('');\n\nexport default thisWindow;\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport * as Runtime from \"../@wailsio/runtime/src\";\n\n// NOTE: the following methods MUST be imported explicitly because of how esbuild injection works\nimport {Enable as EnableWML} from \"../@wailsio/runtime/src/wml\";\nimport {debugLog} from \"../@wailsio/runtime/src/utils\";\n\nwindow.wails = Runtime;\nEnableWML();\n\nif (DEBUG) {\n    debugLog(\"Wails Runtime Loaded\")\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\nlet call = newRuntimeCallerWithID(objectNames.System, '');\nconst systemIsDarkMode = 0;\nconst environment = 1;\n\nexport function invoke(msg) {\n    if(window.chrome) {\n        return window.chrome.webview.postMessage(msg);\n    }\n    return window.webkit.messageHandlers.external.postMessage(msg);\n}\n\n/**\n * @function\n * Retrieves the system dark mode status.\n * @returns {Promise<boolean>} - A promise that resolves to a boolean value indicating if the system is in dark mode.\n */\nexport function IsDarkMode() {\n    return call(systemIsDarkMode);\n}\n\n/**\n * Fetches the capabilities of the application from the server.\n *\n * @async\n * @function Capabilities\n * @returns {Promise<Object>} A promise that resolves to an object containing the capabilities.\n */\nexport function Capabilities() {\n    let response = fetch(\"/wails/capabilities\");\n    return response.json();\n}\n\n/**\n * @typedef {Object} OSInfo\n * @property {string} Branding - The branding of the OS.\n * @property {string} ID - The ID of the OS.\n * @property {string} Name - The name of the OS.\n * @property {string} Version - The version of the OS.\n */\n\n/**\n * @typedef {Object} EnvironmentInfo\n * @property {string} Arch - The architecture of the system.\n * @property {boolean} Debug - True if the application is running in debug mode, otherwise false.\n * @property {string} OS - The operating system in use.\n * @property {OSInfo} OSInfo - Details of the operating system.\n * @property {Object} PlatformInfo - Additional platform information.\n */\n\n/**\n * @function\n * Retrieves environment details.\n * @returns {Promise<EnvironmentInfo>} - A promise that resolves to an object containing OS and system architecture.\n */\nexport function Environment() {\n    return call(environment);\n}\n\n/**\n * Checks if the current operating system is Windows.\n *\n * @return {boolean} True if the operating system is Windows, otherwise false.\n */\nexport function IsWindows() {\n    return window._wails.environment.OS === \"windows\";\n}\n\n/**\n * Checks if the current operating system is Linux.\n *\n * @returns {boolean} Returns true if the current operating system is Linux, false otherwise.\n */\nexport function IsLinux() {\n    return window._wails.environment.OS === \"linux\";\n}\n\n/**\n * Checks if the current environment is a macOS operating system.\n *\n * @returns {boolean} True if the environment is macOS, false otherwise.\n */\nexport function IsMac() {\n    return window._wails.environment.OS === \"darwin\";\n}\n\n/**\n * Checks if the current environment architecture is AMD64.\n * @returns {boolean} True if the current environment architecture is AMD64, false otherwise.\n */\nexport function IsAMD64() {\n    return window._wails.environment.Arch === \"amd64\";\n}\n\n/**\n * Checks if the current architecture is ARM.\n *\n * @returns {boolean} True if the current architecture is ARM, false otherwise.\n */\nexport function IsARM() {\n    return window._wails.environment.Arch === \"arm\";\n}\n\n/**\n * Checks if the current environment is ARM64 architecture.\n *\n * @returns {boolean} - Returns true if the environment is ARM64 architecture, otherwise returns false.\n */\nexport function IsARM64() {\n    return window._wails.environment.Arch === \"arm64\";\n}\n\nexport function IsDebug() {\n    return window._wails.environment.Debug === true;\n}\n\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\nimport {IsDebug} from \"./system\";\n\n// setup\nwindow.addEventListener('contextmenu', contextMenuHandler);\n\nconst call = newRuntimeCallerWithID(objectNames.ContextMenu, '');\nconst ContextMenuOpen = 0;\n\nfunction openContextMenu(id, x, y, data) {\n    void call(ContextMenuOpen, {id, x, y, data});\n}\n\nfunction contextMenuHandler(event) {\n    // Check for custom context menu\n    let element = event.target;\n    let customContextMenu = window.getComputedStyle(element).getPropertyValue(\"--custom-contextmenu\");\n    customContextMenu = customContextMenu ? customContextMenu.trim() : \"\";\n    if (customContextMenu) {\n        event.preventDefault();\n        let customContextMenuData = window.getComputedStyle(element).getPropertyValue(\"--custom-contextmenu-data\");\n        openContextMenu(customContextMenu, event.clientX, event.clientY, customContextMenuData);\n        return\n    }\n\n    processDefaultContextMenu(event);\n}\n\n\n/*\n--default-contextmenu: auto; (default) will show the default context menu if contentEditable is true OR text has been selected OR element is input or textarea\n--default-contextmenu: show; will always show the default context menu\n--default-contextmenu: hide; will always hide the default context menu\n\nThis rule is inherited like normal CSS rules, so nesting works as expected\n*/\nfunction processDefaultContextMenu(event) {\n\n    // Debug builds always show the menu\n    if (IsDebug()) {\n        return;\n    }\n\n    // Process default context menu\n    const element = event.target;\n    const computedStyle = window.getComputedStyle(element);\n    const defaultContextMenuAction = computedStyle.getPropertyValue(\"--default-contextmenu\").trim();\n    switch (defaultContextMenuAction) {\n        case \"show\":\n            return;\n        case \"hide\":\n            event.preventDefault();\n            return;\n        default:\n            // Check if contentEditable is true\n            if (element.isContentEditable) {\n                return;\n            }\n\n            // Check if text has been selected\n            const selection = window.getSelection();\n            const hasSelection = (selection.toString().length > 0)\n            if (hasSelection) {\n                for (let i = 0; i < selection.rangeCount; i++) {\n                    const range = selection.getRangeAt(i);\n                    const rects = range.getClientRects();\n                    for (let j = 0; j < rects.length; j++) {\n                        const rect = rects[j];\n                        if (document.elementFromPoint(rect.left, rect.top) === element) {\n                            return;\n                        }\n                    }\n                }\n            }\n            // Check if tagname is input or textarea\n            if (element.tagName === \"INPUT\" || element.tagName === \"TEXTAREA\") {\n                if (hasSelection || (!element.readOnly && !element.disabled)) {\n                    return;\n                }\n            }\n\n            // hide default context menu\n            event.preventDefault();\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\n/**\n * Retrieves the value associated with the specified key from the flag map.\n *\n * @param {string} keyString - The key to retrieve the value for.\n * @return {*} - The value associated with the specified key.\n */\nexport function GetFlag(keyString) {\n    try {\n        return window._wails.flags[keyString];\n    } catch (e) {\n        throw new Error(\"Unable to retrieve flag '\" + keyString + \"': \" + e);\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n/* jshint esversion: 9 */\nimport {invoke, IsWindows} from \"./system\";\nimport {GetFlag} from \"./flags\";\n\n// Setup\nlet shouldDrag = false;\nlet resizable = false;\nlet resizeEdge = null;\nlet defaultCursor = \"auto\";\n\nwindow._wails = window._wails || {};\n\nwindow._wails.setResizable = function(value) {\n    resizable = value;\n};\n\nwindow._wails.endDrag = function() {\n    document.body.style.cursor = 'default';\n    shouldDrag = false;\n};\n\nwindow.addEventListener('mousedown', onMouseDown);\nwindow.addEventListener('mousemove', onMouseMove);\nwindow.addEventListener('mouseup', onMouseUp);\n\n\nfunction dragTest(e) {\n    let val = window.getComputedStyle(e.target).getPropertyValue(\"--wails-draggable\");\n    let mousePressed = e.buttons !== undefined ? e.buttons : e.which;\n    if (!val || val === \"\" || val.trim() !== \"drag\" || mousePressed === 0) {\n        return false;\n    }\n    return e.detail === 1;\n}\n\nfunction onMouseDown(e) {\n\n    // Check for resizing\n    if (resizeEdge) {\n        invoke(\"wails:resize:\" + resizeEdge);\n        e.preventDefault();\n        return;\n    }\n\n    if (dragTest(e)) {\n        // This checks for clicks on the scroll bar\n        if (e.offsetX > e.target.clientWidth || e.offsetY > e.target.clientHeight) {\n            return;\n        }\n        shouldDrag = true;\n    } else {\n        shouldDrag = false;\n    }\n}\n\nfunction onMouseUp() {\n    shouldDrag = false;\n}\n\nfunction setResize(cursor) {\n    document.documentElement.style.cursor = cursor || defaultCursor;\n    resizeEdge = cursor;\n}\n\nfunction onMouseMove(e) {\n    if (shouldDrag) {\n        shouldDrag = false;\n        let mousePressed = e.buttons !== undefined ? e.buttons : e.which;\n        if (mousePressed > 0) {\n            invoke(\"wails:drag\");\n            return;\n        }\n    }\n    if (!resizable || !IsWindows()) {\n        return;\n    }\n    if (defaultCursor == null) {\n        defaultCursor = document.documentElement.style.cursor;\n    }\n    let resizeHandleHeight = GetFlag(\"system.resizeHandleHeight\") || 5;\n    let resizeHandleWidth = GetFlag(\"system.resizeHandleWidth\") || 5;\n\n    // Extra pixels for the corner areas\n    let cornerExtra = GetFlag(\"resizeCornerExtra\") || 10;\n\n    let rightBorder = window.outerWidth - e.clientX < resizeHandleWidth;\n    let leftBorder = e.clientX < resizeHandleWidth;\n    let topBorder = e.clientY < resizeHandleHeight;\n    let bottomBorder = window.outerHeight - e.clientY < resizeHandleHeight;\n\n    // Adjust for corners\n    let rightCorner = window.outerWidth - e.clientX < (resizeHandleWidth + cornerExtra);\n    let leftCorner = e.clientX < (resizeHandleWidth + cornerExtra);\n    let topCorner = e.clientY < (resizeHandleHeight + cornerExtra);\n    let bottomCorner = window.outerHeight - e.clientY < (resizeHandleHeight + cornerExtra);\n\n    // If we aren't on an edge, but were, reset the cursor to default\n    if (!leftBorder && !rightBorder && !topBorder && !bottomBorder && resizeEdge !== undefined) {\n        setResize();\n    }\n    // Adjusted for corner areas\n    else if (rightCorner && bottomCorner) setResize(\"se-resize\");\n    else if (leftCorner && bottomCorner) setResize(\"sw-resize\");\n    else if (leftCorner && topCorner) setResize(\"nw-resize\");\n    else if (topCorner && rightCorner) setResize(\"ne-resize\");\n    else if (leftBorder) setResize(\"w-resize\");\n    else if (topBorder) setResize(\"n-resize\");\n    else if (bottomBorder) setResize(\"s-resize\");\n    else if (rightBorder) setResize(\"e-resize\");\n}", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\nimport { newRuntimeCallerWithID, objectNames } from \"./runtime\";\nconst call = newRuntimeCallerWithID(objectNames.Application, '');\n\nconst HideMethod = 0;\nconst ShowMethod = 1;\nconst QuitMethod = 2;\n\n/**\n * Hides a certain method by calling the HideMethod function.\n *\n * @return {Promise<void>}\n *\n */\nexport function Hide() {\n    return call(HideMethod);\n}\n\n/**\n * Calls the ShowMethod and returns the result.\n *\n * @return {Promise<void>}\n */\nexport function Show() {\n    return call(ShowMethod);\n}\n\n/**\n * Calls the QuitMethod to terminate the program.\n *\n * @return {Promise<void>}\n */\nexport function Quit() {\n    return call(QuitMethod);\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\nimport { newRuntimeCallerWithID, objectNames } from \"./runtime\";\nimport { nanoid } from 'nanoid/non-secure';\n\n// Setup\nwindow._wails = window._wails || {};\nwindow._wails.callResultHandler = resultHandler;\nwindow._wails.callErrorHandler = errorHandler;\n\n\nconst CallBinding = 0;\nconst call = newRuntimeCallerWithID(objectNames.Call, '');\nconst cancelCall = newRuntimeCallerWithID(objectNames.CancelCall, '');\nlet callResponses = new Map();\n\n/**\n * Generates a unique ID using the nanoid library.\n *\n * @return {string} - A unique ID that does not exist in the callResponses set.\n */\nfunction generateID() {\n    let result;\n    do {\n        result = nanoid();\n    } while (callResponses.has(result));\n    return result;\n}\n\n/**\n * Handles the result of a call request.\n *\n * @param {string} id - The id of the request to handle the result for.\n * @param {string} data - The result data of the request.\n * @param {boolean} isJSON - Indicates whether the data is JSON or not.\n *\n * @return {undefined} - This method does not return any value.\n */\nfunction resultHandler(id, data, isJSON) {\n    const promiseHandler = getAndDeleteResponse(id);\n    if (promiseHandler) {\n        promiseHandler.resolve(isJSON ? JSON.parse(data) : data);\n    }\n}\n\n/**\n * Handles the error from a call request.\n *\n * @param {string} id - The id of the promise handler.\n * @param {string} message - The error message to reject the promise handler with.\n *\n * @return {void}\n */\nfunction errorHandler(id, message) {\n    const promiseHandler = getAndDeleteResponse(id);\n    if (promiseHandler) {\n        promiseHandler.reject(message);\n    }\n}\n\n/**\n * Retrieves and removes the response associated with the given ID from the callResponses map.\n *\n * @param {any} id - The ID of the response to be retrieved and removed.\n *\n * @returns {any} The response object associated with the given ID.\n */\nfunction getAndDeleteResponse(id) {\n    const response = callResponses.get(id);\n    callResponses.delete(id);\n    return response;\n}\n\n/**\n * Executes a call using the provided type and options.\n *\n * @param {string|number} type - The type of call to execute.\n * @param {Object} [options={}] - Additional options for the call.\n * @return {Promise} - A promise that will be resolved or rejected based on the result of the call. It also has a cancel method to cancel a long running request.\n */\nfunction callBinding(type, options = {}) {\n    const id = generateID();\n    const doCancel = () => { return cancelCall(type, {\"call-id\": id}) };\n    let queuedCancel = false, callRunning = false;\n    let p = new Promise((resolve, reject) => {\n        options[\"call-id\"] = id;\n        callResponses.set(id, { resolve, reject });\n        call(type, options).\n            then((_) => {\n                callRunning = true;\n                if (queuedCancel) {\n                    return doCancel();\n                }\n            }).\n            catch((error) => {\n                reject(error);\n                callResponses.delete(id);\n            });\n    });\n    p.cancel = () => {\n        if (callRunning) {\n            return doCancel();\n        } else {\n            queuedCancel = true;\n        }\n    };\n\n    return p;\n}\n\n/**\n * Call method.\n *\n * @param {Object} options - The options for the method.\n * @returns {Object} - The result of the call.\n */\nexport function Call(options) {\n    return callBinding(CallBinding, options);\n}\n\n/**\n * Executes a method by name.\n *\n * @param {string} methodName - The name of the method in the format 'package.struct.method'.\n * @param {...*} args - The arguments to pass to the method.\n * @throws {Error} If the name is not a string or is not in the correct format.\n * @returns {*} The result of the method execution.\n */\nexport function ByName(methodName, ...args) {\n    return callBinding(CallBinding, {\n        methodName,\n        args\n    });\n}\n\n/**\n * Calls a method by its ID with the specified arguments.\n *\n * @param {number} methodID - The ID of the method to call.\n * @param {...*} args - The arguments to pass to the method.\n * @return {*} - The result of the method call.\n */\nexport function ByID(methodID, ...args) {\n    return callBinding(CallBinding, {\n        methodID,\n        args\n    });\n}\n\n/**\n * Calls a method on a plugin.\n *\n * @param {string} pluginName - The name of the plugin.\n * @param {string} methodName - The name of the method to call.\n * @param {...*} args - The arguments to pass to the method.\n * @returns {*} - The result of the method call.\n */\nexport function Plugin(pluginName, methodName, ...args) {\n    return callBinding(CallBinding, {\n        packageName: \"wails-plugins\",\n        structName: pluginName,\n        methodName,\n        args\n    });\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\n\nconst call = newRuntimeCallerWithID(objectNames.Clipboard, '');\nconst ClipboardSetText = 0;\nconst ClipboardText = 1;\n\n/**\n * Sets the text to the Clipboard.\n *\n * @param {string} text - The text to be set to the Clipboard.\n * @return {Promise} - A Promise that resolves when the operation is successful.\n */\nexport function SetText(text) {\n    return call(ClipboardSetText, {text});\n}\n\n/**\n * Get the Clipboard text\n * @returns {Promise<string>} A promise that resolves with the text from the Clipboard.\n */\nexport function Text() {\n    return call(ClipboardText);\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\n/**\n * Any is a dummy creation function for simple or unknown types.\n * @template T\n * @param {any} source\n * @returns {T}\n */\nexport function Any(source) {\n    return /** @type {T} */(source);\n}\n\n/**\n * ByteSlice is a creation function that replaces\n * null strings with empty strings.\n * @param {any} source\n * @returns {string}\n */\nexport function ByteSlice(source) {\n    return /** @type {any} */((source == null) ? \"\" : source);\n}\n\n/**\n * Array takes a creation function for an arbitrary type\n * and returns an in-place creation function for an array\n * whose elements are of that type.\n * @template T\n * @param {(source: any) => T} element\n * @returns {(source: any) => T[]}\n */\nexport function Array(element) {\n    if (element === Any) {\n        return (source) => (source === null ? [] : source);\n    }\n\n    return (source) => {\n        if (source === null) {\n            return [];\n        }\n        for (let i = 0; i < source.length; i++) {\n            source[i] = element(source[i]);\n        }\n        return source;\n    };\n}\n\n/**\n * Map takes creation functions for two arbitrary types\n * and returns an in-place creation function for an object\n * whose keys and values are of those types.\n * @template K, V\n * @param {(source: any) => K} key\n * @param {(source: any) => V} value\n * @returns {(source: any) => { [_: K]: V }}\n */\nexport function Map(key, value) {\n    if (value === Any) {\n        return (source) => (source === null ? {} : source);\n    }\n\n    return (source) => {\n        if (source === null) {\n            return {};\n        }\n        for (const key in source) {\n            source[key] = value(source[key]);\n        }\n        return source;\n    };\n}\n\n/**\n * Nullable takes a creation function for an arbitrary type\n * and returns a creation function for a nullable value of that type.\n * @template T\n * @param {(source: any) => T} element\n * @returns {(source: any) => (T | null)}\n */\nexport function Nullable(element) {\n    if (element === Any) {\n        return Any;\n    }\n\n    return (source) => (source === null ? null : element(source));\n}\n\n/**\n * Struct takes an object mapping field names to creation functions\n * and returns an in-place creation function for a struct.\n * @template {{ [_: string]: ((source: any) => any) }} T\n * @template {{ [Key in keyof T]?: ReturnType<T[Key]> }} U\n * @param {T} createField\n * @returns {(source: any) => U}\n */\nexport function Struct(createField) {\n    let allAny = true;\n    for (const name in createField) {\n        if (createField[name] !== Any) {\n            allAny = false;\n            break;\n        }\n    }\n    if (allAny) {\n        return Any;\n    }\n\n    return (source) => {\n        for (const name in createField) {\n            if (name in source) {\n                source[name] = createField[name](source[name]);\n            }\n        }\n        return source;\n    };\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\n/**\n * @typedef {Object} Size\n * @property {number} Width - The width.\n * @property {number} Height - The height.\n */\n\n\n/**\n * @typedef {Object} Rect\n * @property {number} X - The X coordinate of the origin.\n * @property {number} Y - The Y coordinate of the origin.\n * @property {number} Width - The width of the rectangle.\n * @property {number} Height - The height of the rectangle.\n */\n\n\n/**\n * @typedef {Object} Screen\n * @property {string} Id - Unique identifier for the screen.\n * @property {string} Name - Human readable name of the screen.\n * @property {number} ScaleFactor - The scale factor of the screen (DPI/96). 1 = standard DPI, 2 = HiDPI (Retina), etc.\n * @property {number} X - The X coordinate of the screen.\n * @property {number} Y - The Y coordinate of the screen.\n * @property {Size} Size - Contains the width and height of the screen.\n * @property {Rect} Bounds - Contains the bounds of the screen in terms of X, Y, Width, and Height.\n * @property {Rect} PhysicalBounds - Contains the physical bounds of the screen in terms of X, Y, Width, and Height (before scaling).\n * @property {Rect} WorkArea - Contains the area of the screen that is actually usable (excluding taskbar and other system UI).\n * @property {Rect} PhysicalWorkArea - Contains the physical WorkArea of the screen (before scaling).\n * @property {boolean} IsPrimary - True if this is the primary monitor selected by the user in the operating system.\n * @property {number} Rotation - The rotation of the screen.\n */\n\n\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\nconst call = newRuntimeCallerWithID(objectNames.Screens, '');\n\nconst getAll = 0;\nconst getPrimary = 1;\nconst getCurrent = 2;\n\n/**\n * Gets all screens.\n * @returns {Promise<Screen[]>} A promise that resolves to an array of Screen objects.\n */\nexport function GetAll() {\n    return call(getAll);\n}\n/**\n * Gets the primary screen.\n * @returns {Promise<Screen>} A promise that resolves to the primary screen.\n */\nexport function GetPrimary() {\n    return call(getPrimary);\n}\n/**\n * Gets the current active screen.\n *\n * @returns {Promise<Screen>} A promise that resolves with the current active screen.\n */\nexport function GetCurrent() {\n    return call(getCurrent);\n}\n"],
  "mappings": "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",
  "names": ["Error", "call", "Error", "call", "eventName", "controller", "resizable", "call", "call", "call", "HideMethod", "ShowMethod", "call", "generateID", "call", "Map", "Map", "key", "call"]
}
 diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/package.json b/v3/internal/runtime/desktop/@wailsio/runtime/package.json index ca822a33a..a1602cc34 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/package.json +++ b/v3/internal/runtime/desktop/@wailsio/runtime/package.json @@ -1,6 +1,6 @@ { "name": "@wailsio/runtime", - "version": "3.0.0-alpha.26", + "version": "3.0.0-alpha.27", "description": "Wails Runtime", "main": "src/index.js", "types": "types/index.d.ts", diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/src/screens.js b/v3/internal/runtime/desktop/@wailsio/runtime/src/screens.js index 88804d782..43a5dc50b 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/src/screens.js +++ b/v3/internal/runtime/desktop/@wailsio/runtime/src/screens.js @@ -10,23 +10,17 @@ The electron alternative for Go /* jshint esversion: 9 */ -/** - * @typedef {Object} Position - * @property {number} X - The X coordinate. - * @property {number} Y - The Y coordinate. - */ - /** * @typedef {Object} Size - * @property {number} X - The width. - * @property {number} Y - The height. + * @property {number} Width - The width. + * @property {number} Height - The height. */ /** * @typedef {Object} Rect - * @property {number} X - The X coordinate of the top-left corner. - * @property {number} Y - The Y coordinate of the top-left corner. + * @property {number} X - The X coordinate of the origin. + * @property {number} Y - The Y coordinate of the origin. * @property {number} Width - The width of the rectangle. * @property {number} Height - The height of the rectangle. */ @@ -36,11 +30,14 @@ The electron alternative for Go * @typedef {Object} Screen * @property {string} Id - Unique identifier for the screen. * @property {string} Name - Human readable name of the screen. - * @property {number} Scale - The resolution scale of the screen. 1 = standard resolution, 2 = high (Retina), etc. - * @property {Position} Position - Contains the X and Y coordinates of the screen's position. + * @property {number} ScaleFactor - The scale factor of the screen (DPI/96). 1 = standard DPI, 2 = HiDPI (Retina), etc. + * @property {number} X - The X coordinate of the screen. + * @property {number} Y - The Y coordinate of the screen. * @property {Size} Size - Contains the width and height of the screen. * @property {Rect} Bounds - Contains the bounds of the screen in terms of X, Y, Width, and Height. + * @property {Rect} PhysicalBounds - Contains the physical bounds of the screen in terms of X, Y, Width, and Height (before scaling). * @property {Rect} WorkArea - Contains the area of the screen that is actually usable (excluding taskbar and other system UI). + * @property {Rect} PhysicalWorkArea - Contains the physical WorkArea of the screen (before scaling). * @property {boolean} IsPrimary - True if this is the primary monitor selected by the user in the operating system. * @property {number} Rotation - The rotation of the screen. */ diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/types/screens.d.ts b/v3/internal/runtime/desktop/@wailsio/runtime/types/screens.d.ts index b91e6d045..2dcba940f 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/types/screens.d.ts +++ b/v3/internal/runtime/desktop/@wailsio/runtime/types/screens.d.ts @@ -14,33 +14,23 @@ export function GetPrimary(): Promise; * @returns {Promise} A promise that resolves with the current active screen. */ export function GetCurrent(): Promise; -export type Position = { - /** - * - The X coordinate. - */ - X: number; - /** - * - The Y coordinate. - */ - Y: number; -}; export type Size = { /** * - The width. */ - X: number; + Width: number; /** * - The height. */ - Y: number; + Height: number; }; export type Rect = { /** - * - The X coordinate of the top-left corner. + * - The X coordinate of the origin. */ X: number; /** - * - The Y coordinate of the top-left corner. + * - The Y coordinate of the origin. */ Y: number; /** @@ -62,13 +52,17 @@ export type Screen = { */ Name: string; /** - * - The resolution scale of the screen. 1 = standard resolution, 2 = high (Retina), etc. + * - The scale factor of the screen (DPI/96). 1 = standard DPI, 2 = HiDPI (Retina), etc. */ - Scale: number; + ScaleFactor: number; /** - * - Contains the X and Y coordinates of the screen's position. + * - The X coordinate of the screen. */ - Position: Position; + X: number; + /** + * - The Y coordinate of the screen. + */ + Y: number; /** * - Contains the width and height of the screen. */ @@ -77,10 +71,18 @@ export type Screen = { * - Contains the bounds of the screen in terms of X, Y, Width, and Height. */ Bounds: Rect; + /** + * - Contains the physical bounds of the screen in terms of X, Y, Width, and Height (before scaling). + */ + PhysicalBounds: Rect; /** * - Contains the area of the screen that is actually usable (excluding taskbar and other system UI). */ WorkArea: Rect; + /** + * - Contains the physical WorkArea of the screen (before scaling). + */ + PhysicalWorkArea: Rect; /** * - True if this is the primary monitor selected by the user in the operating system. */ diff --git a/v3/pkg/application/application.go b/v3/pkg/application/application.go index edbf16f7b..94a291e2b 100644 --- a/v3/pkg/application/application.go +++ b/v3/pkg/application/application.go @@ -276,6 +276,9 @@ type App struct { applicationEventHooks map[uint][]*eventHook applicationEventHooksLock sync.RWMutex + // Screens layout manager (handles DIP coordinate system) + screenManager ScreenManager + // Windows windows map[uint]Window windowsLock sync.RWMutex @@ -814,12 +817,18 @@ func SaveFileDialog() *SaveFileDialogStruct { return newSaveFileDialog() } -func (a *App) GetPrimaryScreen() (*Screen, error) { - return a.impl.getPrimaryScreen() -} - +// NOTE: should use screenManager directly after DPI is implemented in all platforms +// (should also get rid of the error return) func (a *App) GetScreens() ([]*Screen, error) { return a.impl.getScreens() + // return a.screenManager.screens, nil +} + +// NOTE: should use screenManager directly after DPI is implemented in all platforms +// (should also get rid of the error return) +func (a *App) GetPrimaryScreen() (*Screen, error) { + return a.impl.getPrimaryScreen() + // return a.screenManager.primaryScreen, nil } func (a *App) Clipboard() *Clipboard { diff --git a/v3/pkg/application/application_windows.go b/v3/pkg/application/application_windows.go index f2f486ffb..a3015af93 100644 --- a/v3/pkg/application/application_windows.go +++ b/v3/pkg/application/application_windows.go @@ -4,15 +4,12 @@ package application import ( "fmt" - "os" - "strconv" "sync" "syscall" "unsafe" "github.com/wailsapp/go-webview2/webviewloader" "github.com/wailsapp/wails/v3/internal/operatingsystem" - "golang.org/x/sys/windows" "github.com/wailsapp/wails/v3/pkg/events" "github.com/wailsapp/wails/v3/pkg/w32" @@ -71,54 +68,6 @@ func getNativeApplication() *windowsApp { return globalApplication.impl.(*windowsApp) } -func (m *windowsApp) getPrimaryScreen() (*Screen, error) { - screens, err := m.getScreens() - if err != nil { - return nil, err - } - for _, screen := range screens { - if screen.IsPrimary { - return screen, nil - } - } - return nil, fmt.Errorf("no primary screen found") -} - -func (m *windowsApp) getScreens() ([]*Screen, error) { - allScreens, err := w32.GetAllScreens() - if err != nil { - return nil, err - } - // Convert result to []*Screen - screens := make([]*Screen, len(allScreens)) - for id, screen := range allScreens { - x := int(screen.MONITORINFOEX.RcMonitor.Left) - y := int(screen.MONITORINFOEX.RcMonitor.Top) - right := int(screen.MONITORINFOEX.RcMonitor.Right) - bottom := int(screen.MONITORINFOEX.RcMonitor.Bottom) - width := right - x - height := bottom - y - screens[id] = &Screen{ - ID: strconv.Itoa(id), - Name: windows.UTF16ToString(screen.MONITORINFOEX.SzDevice[:]), - X: x, - Y: y, - Size: Size{Width: width, Height: height}, - Bounds: Rect{X: x, Y: y, Width: width, Height: height}, - WorkArea: Rect{ - X: int(screen.MONITORINFOEX.RcWork.Left), - Y: int(screen.MONITORINFOEX.RcWork.Top), - Width: int(screen.MONITORINFOEX.RcWork.Right - screen.MONITORINFOEX.RcWork.Left), - Height: int(screen.MONITORINFOEX.RcWork.Bottom - screen.MONITORINFOEX.RcWork.Top), - }, - IsPrimary: screen.IsPrimary, - Scale: screen.Scale, - Rotation: 0, - } - } - return screens, nil -} - func (m *windowsApp) hide() { // Get the current focussed window m.focusedWindow = w32.GetForegroundWindow() @@ -236,6 +185,16 @@ func (m *windowsApp) wndProc(hwnd w32.HWND, msg uint32, wParam, lParam uintptr) } } + // Reprocess and cache screens when display settings change + if hwnd == m.mainThreadWindowHWND { + if msg == w32.WM_DISPLAYCHANGE || (msg == w32.WM_SETTINGCHANGE && wParam == w32.SPI_SETWORKAREA) { + err := m.processAndCacheScreens() + if err != nil { + m.parent.error(err.Error()) + } + } + } + switch msg { case w32.WM_SETTINGCHANGE: settingChanged := w32.UTF16PtrToString((*uint16)(unsafe.Pointer(lParam))) @@ -313,11 +272,35 @@ func (m *windowsApp) unregisterWindow(w *windowsWebviewWindow) { } } +func setupDPIAwareness() error { + // https://learn.microsoft.com/en-us/windows/win32/hidpi/setting-the-default-dpi-awareness-for-a-process + // https://learn.microsoft.com/en-us/windows/win32/hidpi/high-dpi-desktop-application-development-on-windows + + if w32.HasSetProcessDpiAwarenessContextFunc() { + // This is most recent version with the best results + // supported beginning with Windows 10, version 1703 + return w32.SetProcessDpiAwarenessContext(w32.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2) + } + + if w32.HasSetProcessDpiAwarenessFunc() { + // Supported beginning with Windows 8.1 + return w32.SetProcessDpiAwareness(w32.PROCESS_PER_MONITOR_DPI_AWARE) + } + + if w32.HasSetProcessDPIAwareFunc() { + // If none of the above is supported, fallback to SetProcessDPIAware + // which is supported beginning with Windows Vista + return w32.SetProcessDPIAware() + } + + return fmt.Errorf("no DPI awareness method supported") +} + func newPlatformApp(app *App) *windowsApp { - err := w32.SetProcessDPIAware() + + err := setupDPIAwareness() if err != nil { - globalApplication.fatal("Fatal error in application initialisation: %s", err.Error()) - os.Exit(1) + app.error(err.Error()) } result := &windowsApp{ @@ -327,6 +310,11 @@ func newPlatformApp(app *App) *windowsApp { systrayMap: make(map[w32.HWND]*windowsSystemTray), } + err = result.processAndCacheScreens() + if err != nil { + app.fatal(err.Error()) + } + result.init() result.initMainLoop() diff --git a/v3/pkg/application/linux_cgo.go b/v3/pkg/application/linux_cgo.go index f2e3d924a..3541c27cc 100644 --- a/v3/pkg/application/linux_cgo.go +++ b/v3/pkg/application/linux_cgo.go @@ -145,7 +145,7 @@ typedef struct Screen { int w_height; int w_x; int w_y; - float scale; + float scaleFactor; double rotation; bool isPrimary; } Screen; @@ -744,12 +744,12 @@ func getScreenByIndex(display *C.struct__GdkDisplay, index int) *Screen { } name := C.gdk_monitor_get_model(monitor) return &Screen{ - ID: fmt.Sprintf("%d", index), - Name: C.GoString(name), - IsPrimary: primary, - Scale: float32(C.gdk_monitor_get_scale_factor(monitor)), - X: int(geometry.x), - Y: int(geometry.y), + ID: fmt.Sprintf("%d", index), + Name: C.GoString(name), + IsPrimary: primary, + ScaleFactor: float32(C.gdk_monitor_get_scale_factor(monitor)), + X: int(geometry.x), + Y: int(geometry.y), Size: Size{ Height: int(geometry.height), Width: int(geometry.width), @@ -760,6 +760,24 @@ func getScreenByIndex(display *C.struct__GdkDisplay, index int) *Screen { Height: int(geometry.height), Width: int(geometry.width), }, + PhysicalBounds: Rect{ + X: int(geometry.x), + Y: int(geometry.y), + Height: int(geometry.height), + Width: int(geometry.width), + }, + WorkArea: Rect{ + X: int(geometry.x), + Y: int(geometry.y), + Height: int(geometry.height), + Width: int(geometry.width), + }, + PhysicalWorkArea: Rect{ + X: int(geometry.x), + Y: int(geometry.y), + Height: int(geometry.height), + Width: int(geometry.width), + }, } } @@ -829,18 +847,18 @@ func getMousePosition() (int, int, *Screen) { monitor := C.gdk_display_get_monitor_at_point(defaultDisplay, x, y) geometry := C.GdkRectangle{} C.gdk_monitor_get_geometry(monitor, &geometry) - scale := int(C.gdk_monitor_get_scale_factor(monitor)) + scaleFactor := int(C.gdk_monitor_get_scale_factor(monitor)) return int(x), int(y), &Screen{ - ID: fmt.Sprintf("%d", 0), // A unique identifier for the display - Name: C.GoString(C.gdk_monitor_get_model(monitor)), // The name of the display - Scale: float32(scale), // The scale factor of the display - X: int(geometry.x), // The x-coordinate of the top-left corner of the rectangle - Y: int(geometry.y), // The y-coordinate of the top-left corner of the rectangle - Size: Size{Width: int(geometry.width), Height: int(geometry.height)}, // The size of the display - Bounds: Rect{}, // The bounds of the display - WorkArea: Rect{}, // The work area of the display - IsPrimary: false, // Whether this is the primary display - Rotation: 0.0, // The rotation of the display + ID: fmt.Sprintf("%d", 0), // A unique identifier for the display + Name: C.GoString(C.gdk_monitor_get_model(monitor)), // The name of the display + ScaleFactor: float32(scaleFactor), // The scale factor of the display + X: int(geometry.x), // The x-coordinate of the top-left corner of the rectangle + Y: int(geometry.y), // The y-coordinate of the top-left corner of the rectangle + Size: Size{Width: int(geometry.width), Height: int(geometry.height)}, // The size of the display + Bounds: Rect{}, // The bounds of the display + WorkArea: Rect{}, // The work area of the display + IsPrimary: false, // Whether this is the primary display + Rotation: 0.0, // The rotation of the display } } @@ -858,12 +876,12 @@ func (w *linuxWebviewWindow) destroy() { func (w *linuxWebviewWindow) fullscreen() { w.maximise() //w.lastWidth, w.lastHeight = w.size() - x, y, width, height, scale := w.getCurrentMonitorGeometry() + x, y, width, height, scaleFactor := w.getCurrentMonitorGeometry() if x == -1 && y == -1 && width == -1 && height == -1 { return } - w.setMinMaxSize(0, 0, width*scale, height*scale) - w.setSize(width*scale, height*scale) + w.setMinMaxSize(0, 0, width*scaleFactor, height*scaleFactor) + w.setSize(width*scaleFactor, height*scaleFactor) C.gtk_window_fullscreen(w.gtkWindow()) w.setRelativePosition(0, 0) } @@ -882,30 +900,30 @@ func (w *linuxWebviewWindow) getScreen() (*Screen, error) { // Get the current screen for the window monitor := w.getCurrentMonitor() name := C.gdk_monitor_get_model(monitor) - mx, my, width, height, scale := w.getCurrentMonitorGeometry() + mx, my, width, height, scaleFactor := w.getCurrentMonitorGeometry() return &Screen{ - ID: fmt.Sprintf("%d", w.id), // A unique identifier for the display - Name: C.GoString(name), // The name of the display - Scale: float32(scale), // The scale factor of the display - X: mx, // The x-coordinate of the top-left corner of the rectangle - Y: my, // The y-coordinate of the top-left corner of the rectangle - Size: Size{Width: width, Height: height}, // The size of the display - Bounds: Rect{}, // The bounds of the display - WorkArea: Rect{}, // The work area of the display - IsPrimary: false, // Whether this is the primary display - Rotation: 0.0, // The rotation of the display + ID: fmt.Sprintf("%d", w.id), // A unique identifier for the display + Name: C.GoString(name), // The name of the display + ScaleFactor: float32(scaleFactor), // The scale factor of the display + X: mx, // The x-coordinate of the top-left corner of the rectangle + Y: my, // The y-coordinate of the top-left corner of the rectangle + Size: Size{Width: width, Height: height}, // The size of the display + Bounds: Rect{}, // The bounds of the display + WorkArea: Rect{}, // The work area of the display + IsPrimary: false, // Whether this is the primary display + Rotation: 0.0, // The rotation of the display }, nil } -func (w *linuxWebviewWindow) getCurrentMonitorGeometry() (x int, y int, width int, height int, scale int) { +func (w *linuxWebviewWindow) getCurrentMonitorGeometry() (x int, y int, width int, height int, scaleFactor int) { monitor := w.getCurrentMonitor() if monitor == nil { return -1, -1, -1, -1, 1 } var result C.GdkRectangle C.gdk_monitor_get_geometry(monitor, &result) - scale = int(C.gdk_monitor_get_scale_factor(monitor)) - return int(result.x), int(result.y), int(result.width), int(result.height), scale + scaleFactor = int(C.gdk_monitor_get_scale_factor(monitor)) + return int(result.x), int(result.y), int(result.width), int(result.height), scaleFactor } func (w *linuxWebviewWindow) size() (int, int) { @@ -1101,7 +1119,7 @@ func getPrimaryScreen() (*Screen, error) { monitor := C.gdk_display_get_primary_monitor(display) geometry := C.GdkRectangle{} C.gdk_monitor_get_geometry(monitor, &geometry) - scale := int(C.gdk_monitor_get_scale_factor(monitor)) + scaleFactor := int(C.gdk_monitor_get_scale_factor(monitor)) // get the name for the screen name := C.gdk_monitor_get_model(monitor) return &Screen{ @@ -1120,7 +1138,7 @@ func getPrimaryScreen() (*Screen, error) { Height: int(geometry.height), Width: int(geometry.width), }, - Scale: float32(scale), + ScaleFactor: float32(scaleFactor), }, nil } diff --git a/v3/pkg/application/linux_purego.go b/v3/pkg/application/linux_purego.go index 7a0b81cdf..258eecc94 100644 --- a/v3/pkg/application/linux_purego.go +++ b/v3/pkg/application/linux_purego.go @@ -621,10 +621,10 @@ func getScreenByIndex(display pointer, index int) *Screen { } return &Screen{ - IsPrimary: primary, - Scale: 1.0, - X: int(geometry.x), - Y: int(geometry.y), + IsPrimary: primary, + ScaleFactor: 1.0, + X: int(geometry.x), + Y: int(geometry.y), Size: Size{ Height: int(geometry.height), Width: int(geometry.width), @@ -719,7 +719,7 @@ func windowGetCurrentMonitor(window pointer) pointer { return gdkDisplayGetMonitorAtWindow(display, window) } -func windowGetCurrentMonitorGeometry(window pointer) (x int, y int, width int, height int, scale int) { +func windowGetCurrentMonitorGeometry(window pointer) (x int, y int, width int, height int, scaleFactor int) { monitor := windowGetCurrentMonitor(window) if monitor == 0 { return -1, -1, -1, -1, 1 diff --git a/v3/pkg/application/screen.go b/v3/pkg/application/screen.go deleted file mode 100644 index b3712c9df..000000000 --- a/v3/pkg/application/screen.go +++ /dev/null @@ -1,26 +0,0 @@ -package application - -type Screen struct { - ID string // A unique identifier for the display - Name string // The name of the display - Scale float32 // The scale factor of the display - X int // The x-coordinate of the top-left corner of the rectangle - Y int // The y-coordinate of the top-left corner of the rectangle - Size Size // The size of the display - Bounds Rect // The bounds of the display - WorkArea Rect // The work area of the display - IsPrimary bool // Whether this is the primary display - Rotation float32 // The rotation of the display -} - -type Rect struct { - X int - Y int - Width int - Height int -} - -type Size struct { - Width int - Height int -} diff --git a/v3/pkg/application/screen_darwin.go b/v3/pkg/application/screen_darwin.go index 661c45446..ad5285e34 100644 --- a/v3/pkg/application/screen_darwin.go +++ b/v3/pkg/application/screen_darwin.go @@ -24,7 +24,7 @@ typedef struct Screen { int w_height; int w_x; int w_y; - float scale; + float scaleFactor; double rotation; bool isPrimary; } Screen; @@ -36,7 +36,7 @@ int GetNumScreens(){ Screen processScreen(NSScreen* screen){ Screen returnScreen; - returnScreen.scale = screen.backingScaleFactor; + returnScreen.scaleFactor = screen.backingScaleFactor; // screen bounds returnScreen.height = screen.frame.size.height; @@ -137,17 +137,29 @@ func cScreenToScreen(screen C.Screen) *Screen { Height: int(screen.height), Width: int(screen.width), }, + PhysicalBounds: Rect{ + X: int(screen.x), + Y: int(screen.y), + Height: int(screen.height), + Width: int(screen.width), + }, WorkArea: Rect{ X: int(screen.w_x), Y: int(screen.w_y), Height: int(screen.w_height), Width: int(screen.w_width), }, - Scale: float32(screen.scale), - ID: C.GoString(screen.id), - Name: C.GoString(screen.name), - IsPrimary: bool(screen.isPrimary), - Rotation: float32(screen.rotation), + PhysicalWorkArea: Rect{ + X: int(screen.w_x), + Y: int(screen.w_y), + Height: int(screen.w_height), + Width: int(screen.w_width), + }, + ScaleFactor: float32(screen.scaleFactor), + ID: C.GoString(screen.id), + Name: C.GoString(screen.name), + IsPrimary: bool(screen.isPrimary), + Rotation: float32(screen.rotation), } } diff --git a/v3/pkg/application/screen_windows.go b/v3/pkg/application/screen_windows.go new file mode 100644 index 000000000..45914badd --- /dev/null +++ b/v3/pkg/application/screen_windows.go @@ -0,0 +1,88 @@ +//go:build windows + +package application + +import ( + "fmt" + "strconv" + + "github.com/wailsapp/wails/v3/pkg/w32" + "golang.org/x/sys/windows" +) + +func (m *windowsApp) processAndCacheScreens() error { + allScreens, err := w32.GetAllScreens() + if err != nil { + return err + } + + // Convert result to []*Screen + var screens []*Screen + + for _, screen := range allScreens { + x := int(screen.MONITORINFOEX.RcMonitor.Left) + y := int(screen.MONITORINFOEX.RcMonitor.Top) + right := int(screen.MONITORINFOEX.RcMonitor.Right) + bottom := int(screen.MONITORINFOEX.RcMonitor.Bottom) + width := right - x + height := bottom - y + + workArea := Rect{ + X: int(screen.MONITORINFOEX.RcWork.Left), + Y: int(screen.MONITORINFOEX.RcWork.Top), + Width: int(screen.MONITORINFOEX.RcWork.Right - screen.MONITORINFOEX.RcWork.Left), + Height: int(screen.MONITORINFOEX.RcWork.Bottom - screen.MONITORINFOEX.RcWork.Top), + } + + screens = append(screens, &Screen{ + ID: hMonitorToScreenID(screen.HMonitor), + Name: windows.UTF16ToString(screen.MONITORINFOEX.SzDevice[:]), + X: x, + Y: y, + Size: Size{Width: width, Height: height}, + Bounds: Rect{X: x, Y: y, Width: width, Height: height}, + PhysicalBounds: Rect{X: x, Y: y, Width: width, Height: height}, + WorkArea: workArea, + PhysicalWorkArea: workArea, + IsPrimary: screen.IsPrimary, + ScaleFactor: screen.ScaleFactor, + Rotation: 0, + }) + } + + err = m.parent.screenManager.LayoutScreens(screens) + if err != nil { + return err + } + + return nil +} + +// NOTE: should be moved to *App after DPI is implemented in all platforms +func (m *windowsApp) getScreens() ([]*Screen, error) { + return m.parent.screenManager.screens, nil +} + +// NOTE: should be moved to *App after DPI is implemented in all platforms +func (m *windowsApp) getPrimaryScreen() (*Screen, error) { + return m.parent.screenManager.primaryScreen, nil +} + +func getScreenForWindow(window *windowsWebviewWindow) (*Screen, error) { + return ScreenNearestPhysicalRect(window.physicalBounds()), nil +} + +func getScreenForWindowHwnd(hwnd w32.HWND) (*Screen, error) { + hMonitor := w32.MonitorFromWindow(hwnd, w32.MONITOR_DEFAULTTONEAREST) + screenID := hMonitorToScreenID(hMonitor) + for _, screen := range globalApplication.screenManager.screens { + if screen.ID == screenID { + return screen, nil + } + } + return nil, fmt.Errorf("screen not found for window") +} + +func hMonitorToScreenID(hMonitor uintptr) string { + return strconv.Itoa(int(hMonitor)) +} diff --git a/v3/pkg/application/screenmanager.go b/v3/pkg/application/screenmanager.go new file mode 100644 index 000000000..9756d5ee2 --- /dev/null +++ b/v3/pkg/application/screenmanager.go @@ -0,0 +1,868 @@ +package application + +import ( + "fmt" + "math" + "sort" +) + +// Heavily inspired by the Chromium project (Copyright 2015 The Chromium Authors) +// Chromium License: https://chromium.googlesource.com/chromium/src/+/HEAD/LICENSE + +type ScreenManager struct { + screens []*Screen + primaryScreen *Screen +} + +type Screen struct { + ID string // A unique identifier for the display + Name string // The name of the display + ScaleFactor float32 // The scale factor of the display (DPI/96) + X int // The x-coordinate of the top-left corner of the rectangle + Y int // The y-coordinate of the top-left corner of the rectangle + Size Size // The size of the display + Bounds Rect // The bounds of the display + PhysicalBounds Rect // The physical bounds of the display (before scaling) + WorkArea Rect // The work area of the display + PhysicalWorkArea Rect // The physical work area of the display (before scaling) + IsPrimary bool // Whether this is the primary display + Rotation float32 // The rotation of the display +} + +type Rect struct { + X int + Y int + Width int + Height int +} + +type Point struct { + X int + Y int +} +type Size struct { + Width int + Height int +} + +type Alignment int +type OffsetReference int + +const ( + TOP Alignment = iota + RIGHT + BOTTOM + LEFT +) + +const ( + BEGIN OffsetReference = iota // TOP or LEFT + END // BOTTOM or RIGHT +) + +// ScreenPlacement specifies where the screen (S) is placed relative to +// parent (P) screen. In the following example, (S) is RIGHT aligned to (P) +// with a positive offset and a BEGIN (top) offset reference. +// +// . +------------+ + +// . | | | offset +// . | P | v +// . | +--------+ +// . | | | +// . +------------+ S | +// . | | +// . +--------+ +type ScreenPlacement struct { + screen *Screen + parent *Screen + alignment Alignment + offset int + offsetReference OffsetReference +} + +func (r Rect) Origin() Point { + return Point{ + X: r.X, + Y: r.Y, + } +} + +func (s Screen) Origin() Point { + return Point{ + X: s.X, + Y: s.Y, + } +} + +func (r Rect) Corner() Point { + return Point{ + X: r.right(), + Y: r.bottom(), + } +} + +func (r Rect) InsideCorner() Point { + return Point{ + X: r.right() - 1, + Y: r.bottom() - 1, + } +} + +func (r Rect) right() int { + return r.X + r.Width +} + +func (r Rect) bottom() int { + return r.Y + r.Height +} + +func (s Screen) right() int { + return s.Bounds.right() +} + +func (s Screen) bottom() int { + return s.Bounds.bottom() +} + +func (s Screen) scale(value int, toDip bool) int { + // Round up when scaling down and round down when scaling up. + // This mix rounding strategy prevents drift over time when applying multiple scaling back and forth. + // In addition, It has been shown that using this approach minimized rounding issues and improved overall + // precision when converting between DIP and physical coordinates. + if toDip { + return int(math.Ceil(float64(value) / float64(s.ScaleFactor))) + } else { + return int(math.Floor(float64(value) * float64(s.ScaleFactor))) + } +} + +func (r Rect) Size() Size { + return Size{ + Width: r.Width, + Height: r.Height, + } +} + +func (r Rect) IsEmpty() bool { + return r.Width <= 0 || r.Height <= 0 +} + +func (r Rect) Contains(pt Point) bool { + return pt.X >= r.X && pt.X < r.X+r.Width && pt.Y >= r.Y && pt.Y < r.Y+r.Height +} + +// Get intersection with another rect +func (r Rect) Intersect(otherRect Rect) Rect { + if r.IsEmpty() || otherRect.IsEmpty() { + return Rect{} + } + + maxLeft := max(r.X, otherRect.X) + maxTop := max(r.Y, otherRect.Y) + minRight := min(r.right(), otherRect.right()) + minBottom := min(r.bottom(), otherRect.bottom()) + + if minRight > maxLeft && minBottom > maxTop { + return Rect{ + X: maxLeft, + Y: maxTop, + Width: minRight - maxLeft, + Height: minBottom - maxTop, + } + } + return Rect{} +} + +// Check if screens intersects another screen +func (s *Screen) intersects(otherScreen *Screen) bool { + maxLeft := max(s.X, otherScreen.X) + maxTop := max(s.Y, otherScreen.Y) + minRight := min(s.right(), otherScreen.right()) + minBottom := min(s.bottom(), otherScreen.bottom()) + + return minRight > maxLeft && minBottom > maxTop +} + +// Get distance from another rect (squared) +func (r Rect) distanceFromRectSquared(otherRect Rect) int { + // If they intersect, return negative area of intersection + intersection := r.Intersect(otherRect) + if !intersection.IsEmpty() { + return -(intersection.Width * intersection.Height) + } + + dX := max(0, max(r.X-otherRect.right(), otherRect.X-r.right())) + dY := max(0, max(r.Y-otherRect.bottom(), otherRect.Y-r.bottom())) + + // Distance squared + return dX*dX + dY*dY +} + +// Apply screen placement +func (p ScreenPlacement) apply() { + parentBounds := p.parent.Bounds + screenBounds := p.screen.Bounds + + newX := parentBounds.X + newY := parentBounds.Y + offset := p.offset + + if p.alignment == TOP || p.alignment == BOTTOM { + if p.offsetReference == END { + offset = parentBounds.Width - offset - screenBounds.Width + } + offset = min(offset, parentBounds.Width) + offset = max(offset, -screenBounds.Width) + newX += offset + if p.alignment == TOP { + newY -= screenBounds.Height + } else { + newY += parentBounds.Height + } + } else { + if p.offsetReference == END { + offset = parentBounds.Height - offset - screenBounds.Height + } + offset = min(offset, parentBounds.Height) + offset = max(offset, -screenBounds.Height) + newY += offset + if p.alignment == LEFT { + newX -= screenBounds.Width + } else { + newX += parentBounds.Width + } + } + + p.screen.move(newX, newY) +} + +func (s *Screen) absoluteToRelativeDipPoint(dipPoint Point) Point { + return Point{ + X: dipPoint.X - s.Bounds.X, + Y: dipPoint.Y - s.Bounds.Y, + } +} + +func (s *Screen) relativeToAbsoluteDipPoint(dipPoint Point) Point { + return Point{ + X: dipPoint.X + s.Bounds.X, + Y: dipPoint.Y + s.Bounds.Y, + } +} + +func (s *Screen) absoluteToRelativePhysicalPoint(physicalPoint Point) Point { + return Point{ + X: physicalPoint.X - s.PhysicalBounds.X, + Y: physicalPoint.Y - s.PhysicalBounds.Y, + } +} + +func (s *Screen) relativeToAbsolutePhysicalPoint(physicalPoint Point) Point { + return Point{ + X: physicalPoint.X + s.PhysicalBounds.X, + Y: physicalPoint.Y + s.PhysicalBounds.Y, + } +} + +func (s *Screen) move(newX, newY int) { + workAreaOffsetX := s.WorkArea.X - s.X + workAreaOffsetY := s.WorkArea.Y - s.Y + + s.X = newX + s.Y = newY + s.Bounds.X = newX + s.Bounds.Y = newY + s.WorkArea.X = newX + workAreaOffsetX + s.WorkArea.Y = newY + workAreaOffsetY +} + +func (s *Screen) applyDPIScaling() { + if s.ScaleFactor == 1 { + return + } + workAreaOffsetX := s.WorkArea.X - s.Bounds.X + workAreaOffsetY := s.WorkArea.Y - s.Bounds.Y + + s.WorkArea.X = s.Bounds.X + s.scale(workAreaOffsetX, true) + s.WorkArea.Y = s.Bounds.Y + s.scale(workAreaOffsetY, true) + + s.Bounds.Width = s.scale(s.PhysicalBounds.Width, true) + s.Bounds.Height = s.scale(s.PhysicalBounds.Height, true) + s.WorkArea.Width = s.scale(s.PhysicalWorkArea.Width, true) + s.WorkArea.Height = s.scale(s.PhysicalWorkArea.Height, true) + + s.Size.Width = s.Bounds.Width + s.Size.Height = s.Bounds.Height +} + +func (s *Screen) dipToPhysicalPoint(dipPoint Point, isCorner bool) Point { + relativePoint := s.absoluteToRelativeDipPoint(dipPoint) + scaledRelativePoint := Point{ + X: s.scale(relativePoint.X, false), + Y: s.scale(relativePoint.Y, false), + } + // Align edge points (fixes rounding issues) + edgeOffset := 1 + if isCorner { + edgeOffset = 0 + } + if relativePoint.X == s.Bounds.Width-edgeOffset { + scaledRelativePoint.X = s.PhysicalBounds.Width - edgeOffset + } + if relativePoint.Y == s.Bounds.Height-edgeOffset { + scaledRelativePoint.Y = s.PhysicalBounds.Height - edgeOffset + } + return s.relativeToAbsolutePhysicalPoint(scaledRelativePoint) +} + +func (s *Screen) physicalToDipPoint(physicalPoint Point, isCorner bool) Point { + relativePoint := s.absoluteToRelativePhysicalPoint(physicalPoint) + scaledRelativePoint := Point{ + X: s.scale(relativePoint.X, true), + Y: s.scale(relativePoint.Y, true), + } + // Align edge points (fixes rounding issues) + edgeOffset := 1 + if isCorner { + edgeOffset = 0 + } + if relativePoint.X == s.PhysicalBounds.Width-edgeOffset { + scaledRelativePoint.X = s.Bounds.Width - edgeOffset + } + if relativePoint.Y == s.PhysicalBounds.Height-edgeOffset { + scaledRelativePoint.Y = s.Bounds.Height - edgeOffset + } + return s.relativeToAbsoluteDipPoint(scaledRelativePoint) +} + +func (s *Screen) dipToPhysicalRect(dipRect Rect) Rect { + origin := s.dipToPhysicalPoint(dipRect.Origin(), false) + corner := s.dipToPhysicalPoint(dipRect.Corner(), true) + + return Rect{ + X: origin.X, + Y: origin.Y, + Width: corner.X - origin.X, + Height: corner.Y - origin.Y, + } +} + +func (s *Screen) physicalToDipRect(physicalRect Rect) Rect { + origin := s.physicalToDipPoint(physicalRect.Origin(), false) + corner := s.physicalToDipPoint(physicalRect.Corner(), true) + + return Rect{ + X: origin.X, + Y: origin.Y, + Width: corner.X - origin.X, + Height: corner.Y - origin.Y, + } +} + +// Layout screens in the virtual space with DIP calculations and cache the screens +// for future coordinate transformation between the physical and logical (DIP) space +func (m *ScreenManager) LayoutScreens(screens []*Screen) error { + if screens == nil || len(screens) == 0 { + return fmt.Errorf("screens parameter is nil or empty") + } + m.screens = screens + + err := m.calculateScreensDipCoordinates() + if err != nil { + return err + } + + return nil +} +} + +func (m *ScreenManager) Screens() []*Screen { + return m.screens +} + +func (m *ScreenManager) PrimaryScreen() *Screen { + return m.primaryScreen +} + +// Reference: https://source.chromium.org/chromium/chromium/src/+/main:ui/display/win/screen_win.cc;l=317 +func (m *ScreenManager) calculateScreensDipCoordinates() error { + remainingScreens := []*Screen{} + + // Find the primary screen + m.primaryScreen = nil + for _, screen := range m.screens { + if screen.IsPrimary { + m.primaryScreen = screen + } else { + remainingScreens = append(remainingScreens, screen) + } + } + if m.primaryScreen == nil { + return fmt.Errorf("no primary screen found") + } else if len(remainingScreens) != len(m.screens)-1 { + return fmt.Errorf("invalid primary screen found") + } + + // Build screens tree using the primary screen as root + screensPlacements := []ScreenPlacement{} + availableParents := []*Screen{m.primaryScreen} + for len(availableParents) > 0 { + // Pop a parent + end := len(availableParents) - 1 + parent := availableParents[end] + availableParents = availableParents[:end] + // Find touching screens + for _, child := range m.findAndRemoveTouchingScreens(parent, &remainingScreens) { + screenPlacement := m.calculateScreenPlacement(child, parent) + screensPlacements = append(screensPlacements, screenPlacement) + availableParents = append(availableParents, child) + } + } + + // Apply screens DPI scaling and placement starting with + // the primary screen and then dependent screens + m.primaryScreen.applyDPIScaling() + for _, placement := range screensPlacements { + placement.screen.applyDPIScaling() + placement.apply() + } + + // Now that all the placements have been applied, + // we must detect and fix any overlapping screens. + m.deIntersectScreens(screensPlacements) + + return nil +} + +// Returns a ScreenPlacement for |screen| relative to |parent|. +// Note that ScreenPlacement's are always in DIPs, so this also performs the +// required scaling. +// References: +// - https://github.com/chromium/chromium/blob/main/ui/display/win/scaling_util.h#L25 +// - https://github.com/chromium/chromium/blob/main/ui/display/win/scaling_util.cc#L142 +func (m *ScreenManager) calculateScreenPlacement(screen, parent *Screen) ScreenPlacement { + // Examples (The offset is indicated by the arrow.): + // Scaled and Unscaled Coordinates + // +--------------+ + Since both screens are of the same scale + // | | | factor, relative positions remain the same. + // | Parent | V + // | 1x +----------+ + // | | | + // +--------------+ Screen | + // | 1x | + // +----------+ + // + // Unscaled Coordinates + // +--------------+ The 2x screen is offset to maintain a + // | | similar neighboring relationship with the 1x + // | Parent | parent. Screen's position is based off of the + // | 1x +----------+ percentage position along its parent. This + // | | | percentage position is preserved in the scaled + // +--------------+ Screen | coordinates. + // | 2x | + // +----------+ + // Scaled Coordinates + // +--------------+ + + // | | | + // | Parent | V + // | 1x +-----+ + // | | S 2x| + // +--------------+-----+ + // + // + // Unscaled Coordinates + // +--------------+ The parent screen has a 2x scale factor. + // | | The offset is adjusted to maintain the + // | | relative positioning of the 1x screen in + // | Parent +----------+ the scaled coordinate space. Screen's + // | 2x | | position is based off of the percentage + // | | Screen | position along its parent. This percentage + // | | 1x | position is preserved in the scaled + // +--------------+ | coordinates. + // | | + // +----------+ + // Scaled Coordinates + // +-------+ + + // | | V + // | Parent+----------+ + // | 2x | | + // +-------+ Screen | + // | 1x | + // | | + // | | + // +----------+ + // + // Unscaled Coordinates + // +----------+ In this case, parent lies between the top and + // | | bottom of parent. The roles are reversed when + // +-------+ | this occurs, and screen is placed to maintain + // | | Screen | parent's relative position along screen. + // | Parent| 1x | + // | 2x | | + // +-------+ | + // +----------+ + // Scaled Coordinates + // ^ +----------+ + // | | | + // + +----+ | + // |Prnt| Screen | + // | 2x | 1x | + // +----+ | + // | | + // +----------+ + // + // Scaled and Unscaled Coordinates + // +--------+ If the two screens are bottom aligned or + // | | right aligned, the ScreenPlacement will + // | +--------+ have an offset of 0 relative to the + // | | | end of the screen. + // | | | + // +--------+--------+ + + placement := ScreenPlacement{ + screen: screen, + parent: parent, + alignment: m.getScreenAlignment(screen, parent), + offset: 0, + offsetReference: BEGIN, + } + + screenBegin, screenEnd := 0, 0 + parentBegin, parentEnd := 0, 0 + + switch placement.alignment { + case TOP, BOTTOM: + screenBegin = screen.X + screenEnd = screen.right() + parentBegin = parent.X + parentEnd = parent.right() + case LEFT, RIGHT: + screenBegin = screen.Y + screenEnd = screen.bottom() + parentBegin = parent.Y + parentEnd = parent.bottom() + } + + // Since we're calculating offsets, make everything relative to parentBegin + parentEnd -= parentBegin + screenBegin -= parentBegin + screenEnd -= parentBegin + parentBegin = 0 + + // There are a few ways lines can intersect: + // End Aligned + // SCREEN's offset is relative to the END (BOTTOM or RIGHT). + // +-PARENT----------------+ + // +-SCREEN-------------+ + // + // Positioning based off of |screenBegin|. + // SCREEN's offset is simply a percentage of its position on PARENT. + // +-PARENT----------------+ + // ^+-SCREEN------------+ + // + // Positioning based off of |screenEnd|. + // SCREEN's offset is dependent on the percentage of its end position on PARENT. + // +-PARENT----------------+ + // +-SCREEN------------+^ + // + // Positioning based off of |parentBegin| on SCREEN. + // SCREEN's offset is dependent on the percentage of its position on PARENT. + // +-PARENT----------------+ + // ^+-SCREEN--------------------------+ + + if screenEnd == parentEnd { + placement.offsetReference = END + placement.offset = 0 + } else if screenBegin >= parentBegin { + placement.offsetReference = BEGIN + placement.offset = m.scaleOffset(parentEnd, parent.ScaleFactor, screenBegin) + } else if screenEnd <= parentEnd { + placement.offsetReference = END + placement.offset = m.scaleOffset(parentEnd, parent.ScaleFactor, parentEnd-screenEnd) + } else { + placement.offsetReference = BEGIN + placement.offset = m.scaleOffset(screenEnd-screenBegin, screen.ScaleFactor, screenBegin) + } + + return placement +} + +// Get screen alignment relative to parent (TOP, RIGHT, BOTTOM, LEFT) +func (m *ScreenManager) getScreenAlignment(screen, parent *Screen) Alignment { + maxLeft := max(screen.X, parent.X) + maxTop := max(screen.Y, parent.Y) + minRight := min(screen.right(), parent.right()) + minBottom := min(screen.bottom(), parent.bottom()) + + // Corners touching + if maxLeft == minRight && maxTop == minBottom { + if screen.Y == maxTop { + return BOTTOM + } else if parent.X == maxLeft { + return LEFT + } + return TOP + } + + // Vertical edge touching + if maxLeft == minRight { + if screen.X == maxLeft { + return RIGHT + } else { + return LEFT + } + } + + // Horizontal edge touching + if maxTop == minBottom { + if screen.Y == maxTop { + return BOTTOM + } else { + return TOP + } + } + + return -1 // Shouldn't be reached +} + +func (m *ScreenManager) deIntersectScreens(screensPlacements []ScreenPlacement) { + parentIDMap := make(map[string]string) + for _, placement := range screensPlacements { + parentIDMap[placement.screen.ID] = placement.parent.ID + } + + treeDepthMap := make(map[string]int) + for _, screen := range m.screens { + id, ok, depth := screen.ID, true, 0 + const maxDepth = 100 + for id != m.primaryScreen.ID && depth < maxDepth { + depth++ + id, ok = parentIDMap[id] + if !ok { + depth = maxDepth + } + } + treeDepthMap[screen.ID] = depth + } + + sortedScreens := make([]*Screen, len(m.screens)) + copy(sortedScreens, m.screens) + + // Sort the screens first by their depth in the screen hierarchy tree, + // and then by distance from screen origin to primary origin. This way we + // process the screens starting at the root (the primary screen), in the + // order of their descendance spanning out from the primary screen. + sort.Slice(sortedScreens, func(i, j int) bool { + s1, s2 := m.screens[i], m.screens[j] + s1_depth := treeDepthMap[s1.ID] + s2_depth := treeDepthMap[s2.ID] + + if s1_depth != s2_depth { + return s1_depth < s2_depth + } + + // Distance squared + s1_distance := s1.X*s1.X + s1.Y*s1.Y + s2_distance := s2.X*s2.X + s2.Y*s2.Y + if s1_distance != s2_distance { + return s1_distance < s2_distance + } + + return s1.ID < s2.ID + }) + + for i := 1; i < len(sortedScreens); i++ { + targetScreen := sortedScreens[i] + for j := 0; j < i; j++ { + sourceScreen := sortedScreens[j] + if targetScreen.intersects(sourceScreen) { + m.fixScreenIntersection(targetScreen, sourceScreen) + } + } + } +} + +// Offset the target screen along either X or Y axis away from the origin +// so that it removes the intersection with the source screen +// This function assume both screens already intersect. +func (m *ScreenManager) fixScreenIntersection(targetScreen, sourceScreen *Screen) { + offsetX, offsetY := 0, 0 + + if targetScreen.X >= 0 { + offsetX = sourceScreen.right() - targetScreen.X + } else { + offsetX = -(targetScreen.right() - sourceScreen.X) + } + + if targetScreen.Y >= 0 { + offsetY = sourceScreen.bottom() - targetScreen.Y + } else { + offsetY = -(targetScreen.bottom() - sourceScreen.Y) + } + + // Choose the smaller offset (X or Y) + if math.Abs(float64(offsetX)) <= math.Abs(float64(offsetY)) { + offsetY = 0 + } else { + offsetX = 0 + } + + // Apply the offset + newX := targetScreen.X + offsetX + newY := targetScreen.Y + offsetY + targetScreen.move(newX, newY) +} + +func (m *ScreenManager) findAndRemoveTouchingScreens(parent *Screen, screens *[]*Screen) []*Screen { + touchingScreens := []*Screen{} + remainingScreens := []*Screen{} + + for _, screen := range *screens { + if m.areScreensTouching(parent, screen) { + touchingScreens = append(touchingScreens, screen) + } else { + remainingScreens = append(remainingScreens, screen) + } + } + *screens = remainingScreens + return touchingScreens +} + +func (m *ScreenManager) areScreensTouching(a, b *Screen) bool { + maxLeft := max(a.X, b.X) + maxTop := max(a.Y, b.Y) + minRight := min(a.right(), b.right()) + minBottom := min(a.bottom(), b.bottom()) + return (maxLeft == minRight && maxTop <= minBottom) || (maxTop == minBottom && maxLeft <= minRight) +} + +// Scale |unscaledOffset| to the same relative position on |unscaledLength| +// based off of |unscaledLength|'s |scaleFactor| +func (m *ScreenManager) scaleOffset(unscaledLength int, scaleFactor float32, unscaledOffset int) int { + scaledLength := float32(unscaledLength) / scaleFactor + percent := float32(unscaledOffset) / float32(unscaledLength) + return int(math.Floor(float64(scaledLength * percent))) +} + +func (m *ScreenManager) screenNearestPoint(point Point, isPhysical bool) *Screen { + for _, screen := range m.screens { + if isPhysical { + if screen.PhysicalBounds.Contains(point) { + return screen + } + } else { + if screen.Bounds.Contains(point) { + return screen + } + } + } + return m.primaryScreen +} + +func (m *ScreenManager) screenNearestRect(rect Rect, isPhysical bool, excludedScreens map[string]bool) *Screen { + var nearestScreen *Screen + var distance, nearestScreenDistance int + for _, screen := range m.screens { + if excludedScreens[screen.ID] { + continue + } + if isPhysical { + distance = rect.distanceFromRectSquared(screen.PhysicalBounds) + } else { + distance = rect.distanceFromRectSquared(screen.Bounds) + } + if nearestScreen == nil || distance < nearestScreenDistance { + nearestScreen = screen + nearestScreenDistance = distance + } + } + if !isPhysical && len(excludedScreens) < len(m.screens)-1 { + // Make sure to give the same screen that would be given by the physical rect + // of this dip rect so transforming back and forth always gives the same result. + // This is important because it could happen that a dip rect intersects Screen1 + // more than Screen2 but in the physical layout Screen2 will scale up or Screen1 + // will scale down causing the intersection area to change so transforming back + // would give a different rect. + physicalRect := nearestScreen.dipToPhysicalRect(rect) + physicalRectScreen := m.screenNearestRect(physicalRect, true, nil) + if nearestScreen != physicalRectScreen { + if excludedScreens == nil { + excludedScreens = make(map[string]bool) + } + excludedScreens[nearestScreen.ID] = true + return m.screenNearestRect(rect, isPhysical, excludedScreens) + } + } + return nearestScreen +} + +func (m *ScreenManager) DipToPhysicalPoint(dipPoint Point) Point { + screen := m.ScreenNearestDipPoint(dipPoint) + return screen.dipToPhysicalPoint(dipPoint, false) +} + +func (m *ScreenManager) PhysicalToDipPoint(physicalPoint Point) Point { + screen := m.ScreenNearestPhysicalPoint(physicalPoint) + return screen.physicalToDipPoint(physicalPoint, false) +} + +func (m *ScreenManager) DipToPhysicalRect(dipRect Rect) Rect { + screen := m.ScreenNearestDipRect(dipRect) + return screen.dipToPhysicalRect(dipRect) +} + +func (m *ScreenManager) PhysicalToDipRect(physicalRect Rect) Rect { + screen := m.ScreenNearestPhysicalRect(physicalRect) + return screen.physicalToDipRect(physicalRect) +} + +func (m *ScreenManager) ScreenNearestPhysicalPoint(physicalPoint Point) *Screen { + return m.screenNearestPoint(physicalPoint, true) +} + +func (m *ScreenManager) ScreenNearestDipPoint(dipPoint Point) *Screen { + return m.screenNearestPoint(dipPoint, false) +} + +func (m *ScreenManager) ScreenNearestPhysicalRect(physicalRect Rect) *Screen { + return m.screenNearestRect(physicalRect, true, nil) +} + +func (m *ScreenManager) ScreenNearestDipRect(dipRect Rect) *Screen { + return m.screenNearestRect(dipRect, false, nil) +} + +// ================================================================================================ +// Exported application-level methods for internal convenience and availability to application devs + +func DipToPhysicalPoint(dipPoint Point) Point { + return globalApplication.screenManager.DipToPhysicalPoint(dipPoint) +} + +func PhysicalToDipPoint(physicalPoint Point) Point { + return globalApplication.screenManager.PhysicalToDipPoint(physicalPoint) +} + +func DipToPhysicalRect(dipRect Rect) Rect { + return globalApplication.screenManager.DipToPhysicalRect(dipRect) +} + +func PhysicalToDipRect(physicalRect Rect) Rect { + return globalApplication.screenManager.PhysicalToDipRect(physicalRect) +} + +func ScreenNearestPhysicalPoint(physicalPoint Point) *Screen { + return globalApplication.screenManager.ScreenNearestPhysicalPoint(physicalPoint) +} + +func ScreenNearestDipPoint(dipPoint Point) *Screen { + return globalApplication.screenManager.ScreenNearestDipPoint(dipPoint) +} + +func ScreenNearestPhysicalRect(physicalRect Rect) *Screen { + return globalApplication.screenManager.ScreenNearestPhysicalRect(physicalRect) +} + +func ScreenNearestDipRect(dipRect Rect) *Screen { + return globalApplication.screenManager.ScreenNearestDipRect(dipRect) +} diff --git a/v3/pkg/application/screenmanager_test.go b/v3/pkg/application/screenmanager_test.go new file mode 100644 index 000000000..a7f182901 --- /dev/null +++ b/v3/pkg/application/screenmanager_test.go @@ -0,0 +1,716 @@ +package application_test + +import ( + "fmt" + "math" + "slices" + "strconv" + "testing" + + "github.com/matryer/is" + "github.com/wailsapp/wails/v3/pkg/application" +) + +type ScreenDef struct { + id int + w, h int + s float32 + parent ScreenDefParent + name string +} + +type ScreenDefParent struct { + id int + align string + offset int +} + +type ScreensLayout struct { + name string + screens []ScreenDef +} + +type ParsedLayout struct { + name string + screens []*application.Screen +} + +func exampleLayouts() []ParsedLayout { + layouts := [][]ScreensLayout{ + { + // Normal examples (demonstrate real life scenarios) + { + name: "Single 4k monitor", + screens: []ScreenDef{ + {id: 1, w: 3840, h: 2160, s: 163.0 / 96, name: `27" 4K UHD 163DPI`}, + }, + }, + { + name: "Two monitors", + screens: []ScreenDef{ + {id: 1, w: 3840, h: 2160, s: 163.0 / 96, name: `27" 4K UHD 163DPI`}, + {id: 2, w: 1920, h: 1080, s: 1, parent: ScreenDefParent{id: 1, align: "r", offset: 0}, name: `23" FHD 96DPI`}, + }, + }, + { + name: "Two monitors (2)", + screens: []ScreenDef{ + {id: 1, w: 1920, h: 1080, s: 1, name: `23" FHD 96DPI`}, + {id: 2, w: 1920, h: 1080, s: 1.25, parent: ScreenDefParent{id: 1, align: "r", offset: 0}, name: `23" FHD 96DPI (125%)`}, + }, + }, + { + name: "Three monitors", + screens: []ScreenDef{ + {id: 1, w: 3840, h: 2160, s: 163.0 / 96, name: `27" 4K UHD 163DPI`}, + {id: 2, w: 1920, h: 1080, s: 1, parent: ScreenDefParent{id: 1, align: "r", offset: 0}, name: `23" FHD 96DPI`}, + {id: 3, w: 1920, h: 1080, s: 1.25, parent: ScreenDefParent{id: 1, align: "l", offset: 0}, name: `23" FHD 96DPI (125%)`}, + }, + }, + { + name: "Four monitors", + screens: []ScreenDef{ + {id: 1, w: 3840, h: 2160, s: 163.0 / 96, name: `27" 4K UHD 163DPI`}, + {id: 2, w: 1920, h: 1080, s: 1, parent: ScreenDefParent{id: 1, align: "r", offset: 0}, name: `23" FHD 96DPI`}, + {id: 3, w: 1920, h: 1080, s: 1.25, parent: ScreenDefParent{id: 2, align: "b", offset: 0}, name: `23" FHD 96DPI (125%)`}, + {id: 4, w: 1080, h: 1920, s: 1, parent: ScreenDefParent{id: 1, align: "l", offset: 0}, name: `23" FHD (90deg)`}, + }, + }, + }, + { + // Test cases examples (demonstrate the algorithm basics) + { + name: "Child scaled, Start offset", + screens: []ScreenDef{ + {id: 1, w: 1200, h: 1200, s: 1, name: "Parent"}, + {id: 2, w: 1200, h: 1200, s: 1.5, parent: ScreenDefParent{id: 1, align: "r", offset: 600}, name: "Child"}, + }, + }, + { + name: "Child scaled, End offset", + screens: []ScreenDef{ + {id: 1, w: 1200, h: 1200, s: 1, name: "Parent"}, + {id: 2, w: 1200, h: 1200, s: 1.5, parent: ScreenDefParent{id: 1, align: "r", offset: -600}, name: "Child"}, + }, + }, + { + name: "Parent scaled, Start offset percent", + screens: []ScreenDef{ + {id: 1, w: 1200, h: 1200, s: 1.5, name: "Parent"}, + {id: 2, w: 1200, h: 1200, s: 1, parent: ScreenDefParent{id: 1, align: "r", offset: 600}, name: "Child"}, + }, + }, + { + name: "Parent scaled, End offset percent", + screens: []ScreenDef{ + {id: 1, w: 1200, h: 1200, s: 1.5, name: "Parent"}, + {id: 2, w: 1200, h: 1200, s: 1, parent: ScreenDefParent{id: 1, align: "r", offset: -600}, name: "Child"}, + }, + }, + { + name: "Parent scaled, Start align", + screens: []ScreenDef{ + {id: 1, w: 1200, h: 1200, s: 1.5, name: "Parent"}, + {id: 2, w: 1200, h: 1100, s: 1, parent: ScreenDefParent{id: 1, align: "r", offset: 0}, name: "Child"}, + }, + }, + { + name: "Parent scaled, End align", + screens: []ScreenDef{ + {id: 1, w: 1200, h: 1200, s: 1.5, name: "Parent"}, + {id: 2, w: 1200, h: 1200, s: 1, parent: ScreenDefParent{id: 1, align: "r", offset: 0}, name: "Child"}, + }, + }, + { + name: "Parent scaled, in-between", + screens: []ScreenDef{ + {id: 1, w: 1200, h: 1200, s: 1.5, name: "Parent"}, + {id: 2, w: 1200, h: 1500, s: 1, parent: ScreenDefParent{id: 1, align: "r", offset: -250}, name: "Child"}, + }, + }, + }, + { + // Edge cases examples + { + name: "Parent order (5 is parent of 4)", + screens: []ScreenDef{ + {id: 1, w: 1920, h: 1080, s: 1}, + {id: 2, w: 1024, h: 600, s: 1.25, parent: ScreenDefParent{id: 1, align: "r", offset: -200}}, + {id: 3, w: 800, h: 800, s: 1.25, parent: ScreenDefParent{id: 2, align: "b", offset: 0}}, + {id: 4, w: 800, h: 1080, s: 1.5, parent: ScreenDefParent{id: 2, align: "re", offset: 100}}, + {id: 5, w: 600, h: 600, s: 1, parent: ScreenDefParent{id: 3, align: "r", offset: 100}}, + }, + }, + { + name: "de-intersection reparent", + screens: []ScreenDef{ + {id: 1, w: 1920, h: 1080, s: 1}, + {id: 2, w: 1680, h: 1050, s: 1.25, parent: ScreenDefParent{id: 1, align: "r", offset: 10}}, + {id: 3, w: 1440, h: 900, s: 1.5, parent: ScreenDefParent{id: 1, align: "le", offset: 150}}, + {id: 4, w: 1024, h: 768, s: 1, parent: ScreenDefParent{id: 3, align: "bc", offset: -200}}, + {id: 5, w: 1024, h: 768, s: 1.25, parent: ScreenDefParent{id: 4, align: "r", offset: 400}}, + }, + }, + { + name: "de-intersection (unattached child)", + screens: []ScreenDef{ + {id: 1, w: 1920, h: 1080, s: 1}, + {id: 2, w: 1024, h: 768, s: 1.5, parent: ScreenDefParent{id: 1, align: "le", offset: 10}}, + {id: 3, w: 1024, h: 768, s: 1.25, parent: ScreenDefParent{id: 2, align: "b", offset: 100}}, + {id: 4, w: 1024, h: 768, s: 1, parent: ScreenDefParent{id: 3, align: "r", offset: 500}}, + }, + }, + { + name: "Multiple de-intersection", + screens: []ScreenDef{ + {id: 1, w: 1920, h: 1080, s: 1}, + {id: 2, w: 1024, h: 768, s: 1, parent: ScreenDefParent{id: 1, align: "be", offset: 0}}, + {id: 3, w: 1024, h: 768, s: 1, parent: ScreenDefParent{id: 2, align: "b", offset: 300}}, + {id: 4, w: 1024, h: 768, s: 1.5, parent: ScreenDefParent{id: 2, align: "le", offset: 100}}, + {id: 5, w: 1024, h: 768, s: 1, parent: ScreenDefParent{id: 4, align: "be", offset: 100}}, + }, + }, + { + name: "Multiple de-intersection (left-side)", + screens: []ScreenDef{ + {id: 1, w: 1920, h: 1080, s: 1}, + {id: 2, w: 1024, h: 768, s: 1, parent: ScreenDefParent{id: 1, align: "le", offset: 0}}, + {id: 3, w: 1024, h: 768, s: 1, parent: ScreenDefParent{id: 2, align: "b", offset: 300}}, + {id: 4, w: 1024, h: 768, s: 1.5, parent: ScreenDefParent{id: 2, align: "le", offset: 100}}, + {id: 5, w: 1024, h: 768, s: 1, parent: ScreenDefParent{id: 4, align: "be", offset: 100}}, + }, + }, + { + name: "Parent de-intersection child offset", + screens: []ScreenDef{ + {id: 1, w: 1600, h: 1600, s: 1.5}, + {id: 2, w: 800, h: 800, s: 1, parent: ScreenDefParent{id: 1, align: "r", offset: 0}}, + {id: 3, w: 800, h: 800, s: 1, parent: ScreenDefParent{id: 1, align: "r", offset: 800}}, + {id: 4, w: 800, h: 1600, s: 1, parent: ScreenDefParent{id: 2, align: "r", offset: 0}}, + }, + }, + }, + } + + parsedLayouts := []ParsedLayout{} + + for _, section := range layouts { + for _, layout := range section { + parsedLayouts = append(parsedLayouts, parseLayout(layout)) + } + } + + return parsedLayouts +} + +// Parse screens layout from easy-to-define ScreenDef for testing to actual Screens layout +func parseLayout(layout ScreensLayout) ParsedLayout { + screens := []*application.Screen{} + + for _, screen := range layout.screens { + var x, y int + w := screen.w + h := screen.h + + if screen.parent.id > 0 { + idx := slices.IndexFunc(screens, func(s *application.Screen) bool { return s.ID == strconv.Itoa(screen.parent.id) }) + parent := screens[idx].Bounds + offset := screen.parent.offset + align := screen.parent.align + align2 := "" + + if len(align) == 2 { + align2 = string(align[1]) + align = string(align[0]) + } + + x = parent.X + y = parent.Y + // t: top, b: bottom, l: left, r: right, e: edge, c: corner + if align == "t" || align == "b" { + x += offset + if align2 == "e" || align2 == "c" { + x += parent.Width + } + if align2 == "e" { + x -= w + } + if align == "t" { + y -= h + } else { + y += parent.Height + } + } else { + y += offset + if align2 == "e" || align2 == "c" { + y += parent.Height + } + if align2 == "e" { + y -= h + } + if align == "l" { + x -= w + } else { + x += parent.Width + } + } + } + name := screen.name + if name == "" { + name = "Display" + strconv.Itoa(screen.id) + } + screens = append(screens, &application.Screen{ + ID: strconv.Itoa(screen.id), + Name: name, + ScaleFactor: float32(math.Round(float64(screen.s)*100) / 100), + X: x, + Y: y, + Size: application.Size{Width: w, Height: h}, + Bounds: application.Rect{X: x, Y: y, Width: w, Height: h}, + PhysicalBounds: application.Rect{X: x, Y: y, Width: w, Height: h}, + WorkArea: application.Rect{X: x, Y: y, Width: w, Height: h - int(40*screen.s)}, + PhysicalWorkArea: application.Rect{X: x, Y: y, Width: w, Height: h - int(40*screen.s)}, + IsPrimary: screen.id == 1, + Rotation: 0, + }) + } + return ParsedLayout{ + name: layout.name, + screens: screens, + } +} + +func matchRects(r1, r2 application.Rect) error { + threshold := 1.0 + if math.Abs(float64(r1.X-r2.X)) > threshold || + math.Abs(float64(r1.Y-r2.Y)) > threshold || + math.Abs(float64(r1.Width-r2.Width)) > threshold || + math.Abs(float64(r1.Height-r2.Height)) > threshold { + return fmt.Errorf("%v != %v", r1, r2) + } + return nil +} + +// Test screens layout (DPI transformation) +func TestScreenManager_ScreensLayout(t *testing.T) { + sm := application.ScreenManager{} + + t.Run("Child scaled", func(t *testing.T) { + is := is.New(t) + + layout := parseLayout(ScreensLayout{screens: []ScreenDef{ + {id: 1, w: 1200, h: 1200, s: 1}, + {id: 2, w: 1200, h: 1200, s: 1.5, parent: ScreenDefParent{id: 1, align: "r", offset: 600}}, + }}) + err := sm.LayoutScreens(layout.screens) + is.NoErr(err) + + screens := sm.Screens() + is.Equal(len(screens), 2) // 2 screens + is.Equal(screens[0].PhysicalBounds, application.Rect{X: 0, Y: 0, Width: 1200, Height: 1200}) // Parent physical bounds + is.Equal(screens[0].Bounds, screens[0].PhysicalBounds) // Parent no scaling + is.Equal(screens[1].PhysicalBounds, application.Rect{X: 1200, Y: 600, Width: 1200, Height: 1200}) // Child physical bounds + is.Equal(screens[1].Bounds, application.Rect{X: 1200, Y: 600, Width: 800, Height: 800}) // Child DIP bounds + }) + + t.Run("Parent scaled", func(t *testing.T) { + is := is.New(t) + + layout := parseLayout(ScreensLayout{screens: []ScreenDef{ + {id: 1, w: 1200, h: 1200, s: 1.5}, + {id: 2, w: 1200, h: 1200, s: 1, parent: ScreenDefParent{id: 1, align: "r", offset: 600}}, + }}) + + err := sm.LayoutScreens(layout.screens) + is.NoErr(err) + + screens := sm.Screens() + is.Equal(len(screens), 2) // 2 screens + is.Equal(screens[0].PhysicalBounds, application.Rect{X: 0, Y: 0, Width: 1200, Height: 1200}) // Parent physical bounds + is.Equal(screens[0].Bounds, application.Rect{X: 0, Y: 0, Width: 800, Height: 800}) // Parent DIP bounds + is.Equal(screens[1].PhysicalBounds, application.Rect{X: 1200, Y: 600, Width: 1200, Height: 1200}) // Child physical bounds + is.Equal(screens[1].Bounds, application.Rect{X: 800, Y: 400, Width: 1200, Height: 1200}) // Child DIP bounds + }) +} + +// Test basic transformation between physical and DIP coordinates +func TestScreenManager_BasicTranformation(t *testing.T) { + sm := application.ScreenManager{} + is := is.New(t) + layout := parseLayout(ScreensLayout{screens: []ScreenDef{ + {id: 1, w: 1200, h: 1200, s: 1}, + {id: 2, w: 1200, h: 1200, s: 1.5, parent: ScreenDefParent{id: 1, align: "r", offset: 600}}, + }}) + + err := sm.LayoutScreens(layout.screens) + is.NoErr(err) + + pt := application.Point{X: 100, Y: 100} + is.Equal(sm.DipToPhysicalPoint(pt), pt) // DipToPhysicalPoint screen1 + is.Equal(sm.PhysicalToDipPoint(pt), pt) // PhysicalToDipPoint screen1 + + ptDip := application.Point{X: 1300, Y: 700} + ptPhysical := application.Point{X: 1350, Y: 750} + is.Equal(sm.DipToPhysicalPoint(ptDip), ptPhysical) // DipToPhysicalPoint screen2 + is.Equal(sm.PhysicalToDipPoint(ptPhysical), ptDip) // PhysicalToDipPoint screen2 + + rect := application.Rect{X: 100, Y: 100, Width: 200, Height: 300} + is.Equal(sm.DipToPhysicalRect(rect), rect) // DipToPhysicalRect screen1 + is.Equal(sm.PhysicalToDipRect(rect), rect) // DipToPhysicalRect screen1 + + rectDip := application.Rect{X: 1300, Y: 700, Width: 200, Height: 300} + rectPhysical := application.Rect{X: 1350, Y: 750, Width: 300, Height: 450} + is.Equal(sm.DipToPhysicalRect(rectDip), rectPhysical) // DipToPhysicalRect screen2 + is.Equal(sm.PhysicalToDipRect(rectPhysical), rectDip) // DipToPhysicalRect screen2 + + rectDip = application.Rect{X: 2200, Y: 250, Width: 200, Height: 300} + rectPhysical = application.Rect{X: 2700, Y: 75, Width: 300, Height: 450} + is.Equal(sm.DipToPhysicalRect(rectDip), rectPhysical) // DipToPhysicalRect outside screen2 + is.Equal(sm.PhysicalToDipRect(rectPhysical), rectDip) // DipToPhysicalRect outside screen2 +} + +func TestScreenManager_PrimaryScreen(t *testing.T) { + sm := application.ScreenManager{} + is := is.New(t) + + for _, layout := range exampleLayouts() { + err := sm.LayoutScreens(layout.screens) + is.NoErr(err) + is.Equal(sm.PrimaryScreen(), layout.screens[0]) // Primary screen + } + + layout := parseLayout(ScreensLayout{screens: []ScreenDef{ + {id: 1, w: 1200, h: 1200, s: 1.5}, + {id: 2, w: 1200, h: 1200, s: 1, parent: ScreenDefParent{id: 1, align: "r", offset: 600}}, + }}) + + layout.screens[0], layout.screens[1] = layout.screens[1], layout.screens[0] + err := sm.LayoutScreens(layout.screens) + is.NoErr(err) + is.Equal(sm.PrimaryScreen(), layout.screens[1]) // Primary screen + + layout.screens[1].IsPrimary = false + err = sm.LayoutScreens(layout.screens) + is.True(err != nil) // Should error when no primary screen found +} + +// Test edge alignment between transformation +// (points and rects on the screen edge should transform to the same precise edge position) +func TestScreenManager_EdgeAlign(t *testing.T) { + sm := application.ScreenManager{} + is := is.New(t) + + for _, layout := range exampleLayouts() { + err := sm.LayoutScreens(layout.screens) + is.NoErr(err) + for _, screen := range sm.Screens() { + ptOriginDip := screen.Bounds.Origin() + ptOriginPhysical := screen.PhysicalBounds.Origin() + ptCornerDip := screen.Bounds.InsideCorner() + ptCornerPhysical := screen.PhysicalBounds.InsideCorner() + + is.Equal(sm.DipToPhysicalPoint(ptOriginDip), ptOriginPhysical) // DipToPhysicalPoint Origin + is.Equal(sm.PhysicalToDipPoint(ptOriginPhysical), ptOriginDip) // PhysicalToDipPoint Origin + is.Equal(sm.DipToPhysicalPoint(ptCornerDip), ptCornerPhysical) // DipToPhysicalPoint Corner + is.Equal(sm.PhysicalToDipPoint(ptCornerPhysical), ptCornerDip) // PhysicalToDipPoint Corner + + rectOriginDip := application.Rect{X: ptOriginDip.X, Y: ptOriginDip.Y, Width: 100, Height: 100} + rectOriginPhysical := application.Rect{X: ptOriginPhysical.X, Y: ptOriginPhysical.Y, Width: 100, Height: 100} + rectCornerDip := application.Rect{X: ptCornerDip.X - 99, Y: ptCornerDip.Y - 99, Width: 100, Height: 100} + rectCornerPhysical := application.Rect{X: ptCornerPhysical.X - 99, Y: ptCornerPhysical.Y - 99, Width: 100, Height: 100} + + is.Equal(sm.DipToPhysicalRect(rectOriginDip).Origin(), rectOriginPhysical.Origin()) // DipToPhysicalRect Origin + is.Equal(sm.PhysicalToDipRect(rectOriginPhysical).Origin(), rectOriginDip.Origin()) // PhysicalToDipRect Origin + is.Equal(sm.DipToPhysicalRect(rectCornerDip).Corner(), rectCornerPhysical.Corner()) // DipToPhysicalRect Corner + is.Equal(sm.PhysicalToDipRect(rectCornerPhysical).Corner(), rectCornerDip.Corner()) // PhysicalToDipRect Corner + } + } +} + +func TestScreenManager_ProbePoints(t *testing.T) { + sm := application.ScreenManager{} + is := is.New(t) + threshold := 1.0 + steps := 3 + + for _, layout := range exampleLayouts() { + err := sm.LayoutScreens(layout.screens) + is.NoErr(err) + for _, screen := range sm.Screens() { + for i := 0; i <= 1; i++ { + isDip := (i == 0) + + var b application.Rect + if isDip { + b = screen.Bounds + } else { + b = screen.PhysicalBounds + } + + xStep := b.Width / steps + yStep := b.Height / steps + if xStep < 1 { + xStep = 1 + } + if yStep < 1 { + yStep = 1 + } + pt := b.Origin() + xDone := false + yDone := false + + for !yDone { + if pt.Y > b.InsideCorner().Y { + pt.Y = b.InsideCorner().Y + yDone = true + } + + pt.X = b.X + xDone = false + + for !xDone { + if pt.X > b.InsideCorner().X { + pt.X = b.InsideCorner().X + xDone = true + } + var ptDblTransformed application.Point + + if isDip { + ptDblTransformed = sm.PhysicalToDipPoint(sm.DipToPhysicalPoint(pt)) + } else { + ptDblTransformed = sm.DipToPhysicalPoint(sm.PhysicalToDipPoint(pt)) + } + + is.True(math.Abs(float64(ptDblTransformed.X-pt.X)) <= threshold) + is.True(math.Abs(float64(ptDblTransformed.Y-pt.Y)) <= threshold) + pt.X += xStep + } + pt.Y += yStep + } + } + } + } +} + +// Test transformation drift over time +func TestScreenManager_TransformationDrift(t *testing.T) { + sm := application.ScreenManager{} + is := is.New(t) + + for _, layout := range exampleLayouts() { + err := sm.LayoutScreens(layout.screens) + is.NoErr(err) + for _, screen := range sm.Screens() { + rectPhysicalOriginal := application.Rect{ + X: screen.PhysicalBounds.X + 100, + Y: screen.PhysicalBounds.Y + 100, + Width: 123, + Height: 123, + } + + // Slide the position to catch any rounding errors + for i := 0; i < 10; i++ { + rectPhysicalOriginal.X++ + rectPhysicalOriginal.Y++ + rectPhysical := rectPhysicalOriginal + // Transform back and forth several times to make sure no drift is introduced over time + for j := 0; j < 10; j++ { + rectDip := sm.PhysicalToDipRect(rectPhysical) + rectPhysical = sm.DipToPhysicalRect(rectDip) + } + is.NoErr(matchRects(rectPhysical, rectPhysicalOriginal)) + } + } + } +} + +func TestScreenManager_ScreenNearestRect(t *testing.T) { + sm := application.ScreenManager{} + is := is.New(t) + + layout := parseLayout(ScreensLayout{screens: []ScreenDef{ + {id: 1, w: 3840, h: 2160, s: 163.0 / 96, name: `27" 4K UHD 163DPI`}, + {id: 2, w: 1920, h: 1080, s: 1, parent: ScreenDefParent{id: 1, align: "r", offset: 0}, name: `23" FHD 96DPI`}, + {id: 3, w: 1920, h: 1080, s: 1.25, parent: ScreenDefParent{id: 1, align: "l", offset: 0}, name: `23" FHD 96DPI (125%)`}, + }}) + err := sm.LayoutScreens(layout.screens) + is.NoErr(err) + + type Rects map[string][]application.Rect + + t.Run("DIP rects", func(t *testing.T) { + is := is.New(t) + rects := Rects{ + "1": []application.Rect{ + {X: -150, Y: 260, Width: 400, Height: 300}, + {X: -250, Y: 750, Width: 400, Height: 300}, + {X: -450, Y: 950, Width: 400, Height: 300}, + {X: 800, Y: 1350, Width: 400, Height: 300}, + {X: 2000, Y: 100, Width: 400, Height: 300}, + {X: 2100, Y: 950, Width: 400, Height: 300}, + {X: 2350, Y: 1200, Width: 400, Height: 300}, + }, + "2": []application.Rect{ + {X: 2100, Y: 50, Width: 400, Height: 300}, + {X: 2150, Y: 950, Width: 400, Height: 300}, + {X: 2450, Y: 1150, Width: 400, Height: 300}, + {X: 4300, Y: 400, Width: 400, Height: 300}, + }, + "3": []application.Rect{ + {X: -2000, Y: 100, Width: 400, Height: 300}, + {X: -220, Y: 200, Width: 400, Height: 300}, + {X: -300, Y: 750, Width: 400, Height: 300}, + {X: -500, Y: 900, Width: 400, Height: 300}, + }, + } + + for screenID, screenRects := range rects { + for _, rect := range screenRects { + screen := sm.ScreenNearestDipRect(rect) + is.Equal(screen.ID, screenID) + } + } + }) + t.Run("Physical rects", func(t *testing.T) { + is := is.New(t) + rects := Rects{ + "1": []application.Rect{ + {X: -150, Y: 100, Width: 400, Height: 300}, + {X: -250, Y: 1500, Width: 400, Height: 300}, + {X: 3600, Y: 100, Width: 400, Height: 300}, + }, + "2": []application.Rect{ + {X: 3700, Y: 100, Width: 400, Height: 300}, + {X: 4000, Y: 1150, Width: 400, Height: 300}, + }, + "3": []application.Rect{ + {X: -250, Y: 100, Width: 400, Height: 300}, + {X: -300, Y: 950, Width: 400, Height: 300}, + {X: -1000, Y: 1000, Width: 400, Height: 300}, + }, + } + + for screenID, screenRects := range rects { + for _, rect := range screenRects { + screen := sm.ScreenNearestPhysicalRect(rect) + is.Equal(screen.ID, screenID) + } + } + }) + + // DIP rect is near screen1 but when transformed becomes near screen2. + // To have a consistent transformation back & forth, screen nearest physical rect + // should be the one given by ScreenNearestDipRect + t.Run("Edge case 1", func(t *testing.T) { + is := is.New(t) + layout := parseLayout(ScreensLayout{screens: []ScreenDef{ + {id: 1, w: 1200, h: 1200, s: 1}, + {id: 2, w: 1200, h: 1300, s: 1.5, parent: ScreenDefParent{id: 1, align: "r", offset: -20}}, + }}) + err := sm.LayoutScreens(layout.screens) + is.NoErr(err) + + rectDip := application.Rect{X: 1020, Y: 800, Width: 400, Height: 300} + rectPhysical := sm.DipToPhysicalRect(rectDip) + + screenDip := sm.ScreenNearestDipRect(rectDip) + screenPhysical := sm.ScreenNearestPhysicalRect(rectPhysical) + is.Equal(screenDip.ID, "2") // screenDip + is.Equal(screenPhysical.ID, "2") // screenPhysical + + rectDblTransformed := sm.PhysicalToDipRect(rectPhysical) + is.NoErr(matchRects(rectDblTransformed, rectDip)) // double transformation + }) +} + +// Unsolved edge cases +func TestScreenManager_UnsolvedEdgeCases(t *testing.T) { + sm := application.ScreenManager{} + is := is.New(t) + + // Edge case 1: invalid DIP rect location + // there could be a setup where some dip rects locations are invalid, meaning that there's no + // physical rect that could produce that dip rect at this location + // Not sure how to solve this scenario + t.Run("Edge case 1: invalid dip rect", func(t *testing.T) { + t.Skip("Unsolved edge case") + is := is.New(t) + layout := parseLayout(ScreensLayout{screens: []ScreenDef{ + {id: 1, w: 1200, h: 1200, s: 1}, + {id: 2, w: 1200, h: 1100, s: 1.5, parent: ScreenDefParent{id: 1, align: "r", offset: 0}}, + }}) + err := sm.LayoutScreens(layout.screens) + is.NoErr(err) + + rectDip := application.Rect{X: 1050, Y: 700, Width: 400, Height: 300} + rectPhysical := sm.DipToPhysicalRect(rectDip) + + screenDip := sm.ScreenNearestDipRect(rectDip) + screenPhysical := sm.ScreenNearestPhysicalRect(rectPhysical) + is.Equal(screenDip.ID, screenPhysical.ID) + + rectDblTransformed := sm.PhysicalToDipRect(rectPhysical) + is.NoErr(matchRects(rectDblTransformed, rectDip)) // double transformation + }) + + // Edge case 2: physical rect that changes when double transformed + // there could be a setup where a dip rect at some locations could be produced by two different physical rects + // causing one of these physical rects to be changed to the other when double transformed + // Not sure how to solve this scenario + t.Run("Edge case 2: changed physical rect", func(t *testing.T) { + t.Skip("Unsolved edge case") + is := is.New(t) + layout := parseLayout(ScreensLayout{screens: []ScreenDef{ + {id: 1, w: 1200, h: 1200, s: 1.5}, + {id: 2, w: 1200, h: 900, s: 1, parent: ScreenDefParent{id: 1, align: "r", offset: 0}}, + }}) + err := sm.LayoutScreens(layout.screens) + is.NoErr(err) + + rectPhysical := application.Rect{X: 1050, Y: 890, Width: 400, Height: 300} + rectDblTransformed := sm.DipToPhysicalRect(sm.PhysicalToDipRect(rectPhysical)) + is.NoErr(matchRects(rectDblTransformed, rectPhysical)) // double transformation + }) +} + +func BenchmarkScreenManager_LayoutScreens(b *testing.B) { + sm := application.ScreenManager{} + layouts := exampleLayouts() + screens := layouts[3].screens + + b.ResetTimer() + + for i := 0; i < b.N; i++ { + sm.LayoutScreens(screens) + } +} + +func BenchmarkScreenManager_TransformPoint(b *testing.B) { + sm := application.ScreenManager{} + layouts := exampleLayouts() + screens := layouts[3].screens + sm.LayoutScreens(screens) + + pt := application.Point{X: 500, Y: 500} + + b.ResetTimer() + + for i := 0; i < b.N; i++ { + sm.DipToPhysicalPoint(pt) + } +} + +func BenchmarkScreenManager_TransformRect(b *testing.B) { + sm := application.ScreenManager{} + layouts := exampleLayouts() + screens := layouts[3].screens + sm.LayoutScreens(screens) + + rect := application.Rect{X: 500, Y: 500, Width: 800, Height: 600} + + b.ResetTimer() + + for i := 0; i < b.N; i++ { + sm.DipToPhysicalRect(rect) + } +} diff --git a/v3/pkg/application/systemtray_windows.go b/v3/pkg/application/systemtray_windows.go index 2e298921b..bb8be8880 100644 --- a/v3/pkg/application/systemtray_windows.go +++ b/v3/pkg/application/systemtray_windows.go @@ -55,9 +55,10 @@ func (s *windowsSystemTray) positionWindow(window *WebviewWindow, offset int) er } screenBounds := currentScreen.WorkArea + windowBounds := window.Bounds() - newX := screenBounds.Width - window.Width() - newY := screenBounds.Height - window.Height() + newX := screenBounds.Width - windowBounds.Width - offset + newY := screenBounds.Height - windowBounds.Height - offset // systray icons in windows can either be in the taskbar // or in a flyout menu. @@ -66,13 +67,18 @@ func (s *windowsSystemTray) positionWindow(window *WebviewWindow, offset int) er return err } - // we only need the traybounds if the icon is in the tray var trayBounds *Rect + var centerAlignX, centerAlignY int + + // we only need the traybounds if the icon is in the tray if iconIsInTrayBounds { trayBounds, err = s.bounds() if err != nil { return err } + *trayBounds = PhysicalToDipRect(*trayBounds) + centerAlignX = trayBounds.X + (trayBounds.Width / 2) - (windowBounds.Width / 2) + centerAlignY = trayBounds.Y + (trayBounds.Height / 2) - (windowBounds.Height / 2) } taskbarBounds := w32.GetTaskbarPosition() @@ -82,26 +88,28 @@ func (s *windowsSystemTray) positionWindow(window *WebviewWindow, offset int) er // to adjust the position so the window is centered on the icon switch taskbarBounds.UEdge { case w32.ABE_LEFT: - if iconIsInTrayBounds && trayBounds.Y-(window.Height()/2) >= 0 { - newY = trayBounds.Y - (window.Height() / 2) + if iconIsInTrayBounds && centerAlignY <= newY { + newY = centerAlignY } - window.SetRelativePosition(offset, newY) + newX = screenBounds.X + offset case w32.ABE_TOP: - if iconIsInTrayBounds && trayBounds.X-(window.Width()/2) <= newX { - newX = trayBounds.X - (window.Width() / 2) + if iconIsInTrayBounds && centerAlignX <= newX { + newX = centerAlignX } - window.SetRelativePosition(newX, offset) + newY = screenBounds.Y + offset case w32.ABE_RIGHT: - if iconIsInTrayBounds && trayBounds.Y-(window.Height()/2) <= newY { - newY = trayBounds.Y - (window.Height() / 2) + if iconIsInTrayBounds && centerAlignY <= newY { + newY = centerAlignY } - window.SetRelativePosition(screenBounds.Width-window.Width()-offset, newY) case w32.ABE_BOTTOM: - if iconIsInTrayBounds && trayBounds.X-(window.Width()/2) <= newX { - newX = trayBounds.X - (window.Width() / 2) + if iconIsInTrayBounds && centerAlignX <= newX { + newX = centerAlignX } - window.SetRelativePosition(newX, screenBounds.Height-window.Height()-offset) } + newPos := currentScreen.relativeToAbsoluteDipPoint(Point{X: newX, Y: newY}) + windowBounds.X = newPos.X + windowBounds.Y = newPos.Y + window.SetBounds(windowBounds) return nil } @@ -142,7 +150,7 @@ func (s *windowsSystemTray) iconIsInTrayBounds() (bool, error) { func (s *windowsSystemTray) getScreen() (*Screen, error) { // Get the screen for this systray - return getScreen(s.hwnd) + return getScreenForWindowHwnd(s.hwnd) } func (s *windowsSystemTray) setMenu(menu *Menu) { @@ -257,7 +265,6 @@ func (s *windowsSystemTray) updateIcon() { if !w32.ShellNotifyIcon(w32.NIM_MODIFY, &nid) { panic(syscall.GetLastError()) } - return } func (s *windowsSystemTray) newNotifyIconData() w32.NOTIFYICONDATA { diff --git a/v3/pkg/application/webview_window.go b/v3/pkg/application/webview_window.go index 2f71fd723..11a97ce1f 100644 --- a/v3/pkg/application/webview_window.go +++ b/v3/pkg/application/webview_window.go @@ -44,7 +44,6 @@ type ( size() (int, int) width() int height() int - relativePosition() (int, int) destroy() reload() forceReload() @@ -57,7 +56,6 @@ type ( close() zoom() setHTML(html string) - setRelativePosition(x int, y int) on(eventID uint) minimise() unminimise() @@ -82,8 +80,14 @@ type ( startResize(border string) error print() error setEnabled(enabled bool) + physicalBounds() Rect + setPhysicalBounds(physicalBounds Rect) + bounds() Rect + setBounds(bounds Rect) position() (int, int) setPosition(x int, y int) + relativePosition() (int, int) + setRelativePosition(x int, y int) flash(enabled bool) handleKeyEvent(acceleratorString string) getBorderSizes() *LRTB @@ -804,7 +808,73 @@ func (w *WebviewWindow) Height() int { return InvokeSyncWithResult(w.impl.height) } -// RelativePosition returns the relative position of the window to the screen +// PhysicalBounds returns the physical bounds of the window +func (w *WebviewWindow) PhysicalBounds() Rect { + if w.impl == nil && !w.isDestroyed() { + return Rect{} + } + var rect Rect + InvokeSync(func() { + rect = w.impl.physicalBounds() + }) + return rect +} + +// SetPhysicalBounds sets the physical bounds of the window +func (w *WebviewWindow) SetPhysicalBounds(physicalBounds Rect) { + if w.impl == nil && !w.isDestroyed() { + return + } + InvokeSync(func() { + w.impl.setPhysicalBounds(physicalBounds) + }) +} + +// Bounds returns the DIP bounds of the window +func (w *WebviewWindow) Bounds() Rect { + if w.impl == nil && !w.isDestroyed() { + return Rect{} + } + var rect Rect + InvokeSync(func() { + rect = w.impl.bounds() + }) + return rect +} + +// SetBounds sets the DIP bounds of the window +func (w *WebviewWindow) SetBounds(bounds Rect) { + if w.impl == nil && !w.isDestroyed() { + return + } + InvokeSync(func() { + w.impl.setBounds(bounds) + }) +} + +// Position returns the absolute position of the window +func (w *WebviewWindow) Position() (int, int) { + if w.impl == nil && !w.isDestroyed() { + return 0, 0 + } + var x, y int + InvokeSync(func() { + x, y = w.impl.position() + }) + return x, y +} + +// SetPosition sets the absolute position of the window. +func (w *WebviewWindow) SetPosition(x int, y int) { + if w.impl == nil && !w.isDestroyed() { + return + } + InvokeSync(func() { + w.impl.setPosition(x, y) + }) +} + +// RelativePosition returns the position of the window relative to the screen WorkArea on which it is func (w *WebviewWindow) RelativePosition() (int, int) { if w.impl == nil && !w.isDestroyed() { return 0, 0 @@ -816,16 +886,16 @@ func (w *WebviewWindow) RelativePosition() (int, int) { return x, y } -// Position returns the absolute position of the window to the screen -func (w *WebviewWindow) Position() (int, int) { - if w.impl == nil && !w.isDestroyed() { - return 0, 0 +// SetRelativePosition sets the position of the window relative to the screen WorkArea on which it is. +func (w *WebviewWindow) SetRelativePosition(x, y int) Window { + w.options.X = x + w.options.Y = y + if w.impl != nil { + InvokeSync(func() { + w.impl.setRelativePosition(x, y) + }) } - var x, y int - InvokeSync(func() { - x, y = w.impl.position() - }) - return x, y + return w } func (w *WebviewWindow) Destroy() { @@ -948,18 +1018,6 @@ func (w *WebviewWindow) SetHTML(html string) Window { return w } -// SetRelativePosition sets the position of the window. -func (w *WebviewWindow) SetRelativePosition(x, y int) Window { - w.options.X = x - w.options.Y = y - if w.impl != nil { - InvokeSync(func() { - w.impl.setRelativePosition(x, y) - }) - } - return w -} - // Minimise minimises the window. func (w *WebviewWindow) Minimise() Window { if w.impl == nil && !w.isDestroyed() { @@ -1193,16 +1251,6 @@ func (w *WebviewWindow) SetEnabled(enabled bool) { }) } -func (w *WebviewWindow) SetPosition(x int, y int) { - // set absolute position - if w.impl == nil && !w.isDestroyed() { - return - } - InvokeSync(func() { - w.impl.setPosition(x, y) - }) -} - func (w *WebviewWindow) processKeyBinding(acceleratorString string) bool { // Check menu bindings if w.menuBindings != nil { diff --git a/v3/pkg/application/webview_window_darwin.go b/v3/pkg/application/webview_window_darwin.go index dff8d4560..1971f4354 100644 --- a/v3/pkg/application/webview_window_darwin.go +++ b/v3/pkg/application/webview_window_darwin.go @@ -1312,6 +1312,38 @@ func (w *macosWebviewWindow) position() (int, int) { return int(x), int(y) } +func (w *macosWebviewWindow) bounds() Rect { + // DOTO: do it in a single step + proper DPI scaling + var x, y, width, height C.int + InvokeSync(func() { + C.windowGetPosition(w.nsWindow, &x, &y) + C.windowGetSize(w.nsWindow, &width, &height) + }) + + return Rect{ + X: int(x), + Y: int(y), + Width: int(width), + Height: int(height), + } +} + +func (w *macosWebviewWindow) setBounds(bounds Rect) { + // DOTO: do it in a single step + proper DPI scaling + C.windowSetPosition(w.nsWindow, C.int(bounds.X), C.int(bounds.Y)) + C.windowSetSize(w.nsWindow, C.int(bounds.Width), C.int(bounds.Height)) +} + +func (w *macosWebviewWindow) physicalBounds() Rect { + // TODO: proper DPI scaling + return w.bounds() +} + +func (w *macosWebviewWindow) setPhysicalBounds(physicalBounds Rect) { + // TODO: proper DPI scaling + w.setBounds(physicalBounds) +} + func (w *macosWebviewWindow) destroy() { w.parent.markAsDestroyed() C.windowDestroy(w.nsWindow) diff --git a/v3/pkg/application/webview_window_linux.go b/v3/pkg/application/webview_window_linux.go index f1b2f7449..828ece800 100644 --- a/v3/pkg/application/webview_window_linux.go +++ b/v3/pkg/application/webview_window_linux.go @@ -105,8 +105,8 @@ func (w *linuxWebviewWindow) setMaximiseButtonEnabled(enabled bool) { } func (w *linuxWebviewWindow) disableSizeConstraints() { - x, y, width, height, scale := w.getCurrentMonitorGeometry() - w.setMinMaxSize(x, y, width*scale, height*scale) + x, y, width, height, scaleFactor := w.getCurrentMonitorGeometry() + w.setMinMaxSize(x, y, width*scaleFactor, height*scaleFactor) } func (w *linuxWebviewWindow) unminimise() { @@ -204,6 +204,36 @@ func (w *linuxWebviewWindow) setPosition(x int, y int) { w.move(x, y) } +func (w *linuxWebviewWindow) bounds() Rect { + // DOTO: do it in a single step + proper DPI scaling + x, y := w.position() + width, height := w.size() + + return Rect{ + X: x, + Y: y, + Width: width, + Height: height, + } +} + +func (w *linuxWebviewWindow) setBounds(bounds Rect) { + // DOTO: do it in a single step + proper DPI scaling + w.move(bounds.X, bounds.Y) + w.setSize(bounds.Width, bounds.Height) + +} + +func (w *linuxWebviewWindow) physicalBounds() Rect { + // TODO: proper DPI scaling + return w.bounds() +} + +func (w *linuxWebviewWindow) setPhysicalBounds(physicalBounds Rect) { + // TODO: proper DPI scaling + w.setBounds(physicalBounds) +} + func (w *linuxWebviewWindow) run() { for eventId := range w.parent.eventListeners { w.on(eventId) diff --git a/v3/pkg/application/webview_window_options.go b/v3/pkg/application/webview_window_options.go index 94a1c764a..cfb381f70 100644 --- a/v3/pkg/application/webview_window_options.go +++ b/v3/pkg/application/webview_window_options.go @@ -138,19 +138,6 @@ type WebviewWindowOptions struct { IgnoreMouseEvents bool } -var WebviewWindowDefaults = &WebviewWindowOptions{ - Title: "", - Width: 800, - Height: 600, - URL: "", - BackgroundColour: RGBA{ - Red: 255, - Green: 255, - Blue: 255, - Alpha: 255, - }, -} - type RGBA struct { Red, Green, Blue, Alpha uint8 } diff --git a/v3/pkg/application/webview_window_windows.go b/v3/pkg/application/webview_window_windows.go index ab7a1670e..1fc55158d 100644 --- a/v3/pkg/application/webview_window_windows.go +++ b/v3/pkg/application/webview_window_windows.go @@ -11,7 +11,6 @@ import ( "sync" "syscall" "time" - "unicode/utf16" "unsafe" "github.com/bep/debounce" @@ -49,6 +48,7 @@ type windowsWebviewWindow struct { hwnd w32.HWND menu *Win32Menu currentlyOpenContextMenu *Win32Menu + ignoreDPIChangeResizing bool // Fullscreen flags isCurrentlyFullscreen bool @@ -103,34 +103,6 @@ func (w *windowsWebviewWindow) handleKeyEvent(_ string) { // Unused on windows } -// getBorderSizes returns the extended border size for the window -func (w *windowsWebviewWindow) getBorderSizes() *LRTB { - var result LRTB - var frame w32.RECT - w32.DwmGetWindowAttribute(w.hwnd, w32.DWMWA_EXTENDED_FRAME_BOUNDS, unsafe.Pointer(&frame), unsafe.Sizeof(frame)) - rect := w32.GetWindowRect(w.hwnd) - result.Left = int(frame.Left - rect.Left) - result.Top = int(frame.Top - rect.Top) - result.Right = int(rect.Right - frame.Right) - result.Bottom = int(rect.Bottom - frame.Bottom) - return &result -} - -func (w *windowsWebviewWindow) setPosition(x int, y int) { - // Set the window's absolute position - borderSize := w.getBorderSizes() - w32.SetWindowPos(w.hwnd, 0, x-borderSize.Left, y-borderSize.Top, 0, 0, w32.SWP_NOSIZE|w32.SWP_NOZORDER) -} - -func (w *windowsWebviewWindow) position() (int, int) { - rect := w32.GetWindowRect(w.hwnd) - borderSizes := w.getBorderSizes() - x := int(rect.Left) + borderSizes.Left - y := int(rect.Top) + borderSizes.Top - left, right := w.scaleToDefaultDPI(x, y) - return left, right -} - func (w *windowsWebviewWindow) setEnabled(enabled bool) { w32.EnableWindow(w.hwnd, enabled) } @@ -166,13 +138,6 @@ func (w *windowsWebviewWindow) setTitle(title string) { w32.SetWindowText(w.hwnd, title) } -func (w *windowsWebviewWindow) setSize(width, height int) { - rect := w32.GetWindowRect(w.hwnd) - width, height = w.scaleWithWindowDPI(width, height) - w32.MoveWindow(w.hwnd, int(rect.Left), int(rect.Top), width, height, true) - w.chromium.Resize() -} - func (w *windowsWebviewWindow) setAlwaysOnTop(alwaysOnTop bool) { w32.SetWindowPos(w.hwnd, lo.Ternary(alwaysOnTop, w32.HWND_TOPMOST, w32.HWND_NOTOPMOST), @@ -250,9 +215,21 @@ func (w *windowsWebviewWindow) run() { exStyle = options.Windows.ExStyle } - // ToDo: X, Y should also be scaled, should it be always relative to the main monitor? - var startX, _ = lo.Coalesce(options.X, w32.CW_USEDEFAULT) - var startY, _ = lo.Coalesce(options.Y, w32.CW_USEDEFAULT) + bounds := Rect{ + X: options.X, + Y: options.Y, + Width: options.Width, + Height: options.Height, + } + initialScreen := ScreenNearestDipRect(bounds) + physicalBounds := initialScreen.dipToPhysicalRect(bounds) + + // Default window position applied by the system + // TODO: provide a way to set (0,0) as an initial position? + if options.X == 0 && options.Y == 0 { + physicalBounds.X = w32.CW_USEDEFAULT + physicalBounds.Y = w32.CW_USEDEFAULT + } var appMenu w32.HMENU @@ -279,10 +256,10 @@ func (w *windowsWebviewWindow) run() { w32.MustStringToUTF16Ptr(globalApplication.options.Windows.WndClass), w32.MustStringToUTF16Ptr(options.Title), style, - startX, - startY, - w32.CW_USEDEFAULT, - w32.CW_USEDEFAULT, + physicalBounds.X, + physicalBounds.Y, + physicalBounds.Width, + physicalBounds.Height, parent, appMenu, w32.GetModuleHandle(""), @@ -292,7 +269,12 @@ func (w *windowsWebviewWindow) run() { panic("Unable to create window") } - w.setSize(options.Width, options.Height) + // Ensure correct window size in case the scale factor of current screen is different from the initial one. + // This could happen when using the default window position and the window launches on a secondary monitor. + currentScreen, _ := w.getScreen() + if currentScreen.ScaleFactor != initialScreen.ScaleFactor { + w.setSize(options.Width, options.Height) + } w.setupChromium() @@ -422,48 +404,114 @@ func (w *windowsWebviewWindow) enableSizeConstraints() { } } -func (w *windowsWebviewWindow) size() (int, int) { - rect := w32.GetWindowRect(w.hwnd) - width := int(rect.Right - rect.Left) - height := int(rect.Bottom - rect.Top) - // Scaling appears to give invalid results... - //width, height = w.scaleToDefaultDPI(width, height) - return width, height -} - func (w *windowsWebviewWindow) update() { w32.UpdateWindow(w.hwnd) } +// getBorderSizes returns the extended border size for the window +func (w *windowsWebviewWindow) getBorderSizes() *LRTB { + var result LRTB + var frame w32.RECT + w32.DwmGetWindowAttribute(w.hwnd, w32.DWMWA_EXTENDED_FRAME_BOUNDS, unsafe.Pointer(&frame), unsafe.Sizeof(frame)) + rect := w32.GetWindowRect(w.hwnd) + result.Left = int(frame.Left - rect.Left) + result.Top = int(frame.Top - rect.Top) + result.Right = int(rect.Right - frame.Right) + result.Bottom = int(rect.Bottom - frame.Bottom) + return &result +} + +func (w *windowsWebviewWindow) physicalBounds() Rect { + // var rect w32.RECT + // // Get the extended frame bounds instead of the window rect to offset the invisible borders in Windows 10 + // w32.DwmGetWindowAttribute(w.hwnd, w32.DWMWA_EXTENDED_FRAME_BOUNDS, unsafe.Pointer(&rect), unsafe.Sizeof(rect)) + rect := w32.GetWindowRect(w.hwnd) + return Rect{ + X: int(rect.Left), + Y: int(rect.Top), + Width: int(rect.Right - rect.Left), + Height: int(rect.Bottom - rect.Top), + } +} + +func (w *windowsWebviewWindow) setPhysicalBounds(physicalBounds Rect) { + // // Offset invisible borders + // borderSize := w.getBorderSizes() + // physicalBounds.X -= borderSize.Left + // physicalBounds.Y -= borderSize.Top + // physicalBounds.Width += borderSize.Left + borderSize.Right + // physicalBounds.Height += borderSize.Top + borderSize.Bottom + + // Set flag to ignore resizing the window with DPI change because we already calculated the correct size + // for the target position, this prevents double resizing issue when the window is moved between screens + previousFlag := w.ignoreDPIChangeResizing + w.ignoreDPIChangeResizing = true + w32.SetWindowPos(w.hwnd, 0, physicalBounds.X, physicalBounds.Y, physicalBounds.Width, physicalBounds.Height, w32.SWP_NOZORDER|w32.SWP_NOACTIVATE) + w.ignoreDPIChangeResizing = previousFlag +} + +// Get window dip bounds +func (w *windowsWebviewWindow) bounds() Rect { + return PhysicalToDipRect(w.physicalBounds()) +} + +// Set window dip bounds +func (w *windowsWebviewWindow) setBounds(bounds Rect) { + w.setPhysicalBounds(DipToPhysicalRect(bounds)) +} + +func (w *windowsWebviewWindow) size() (int, int) { + bounds := w.bounds() + return bounds.Width, bounds.Height +} + func (w *windowsWebviewWindow) width() int { - width, _ := w.size() - return width + return w.bounds().Width } func (w *windowsWebviewWindow) height() int { - _, height := w.size() - return height + return w.bounds().Height } +func (w *windowsWebviewWindow) setSize(width, height int) { + bounds := w.bounds() + bounds.Width = width + bounds.Height = height + + w.setBounds(bounds) +} + +func (w *windowsWebviewWindow) position() (int, int) { + bounds := w.bounds() + return bounds.X, bounds.Y +} + +func (w *windowsWebviewWindow) setPosition(x int, y int) { + bounds := w.bounds() + bounds.X = x + bounds.Y = y + + w.setBounds(bounds) +} + +// Get window position relative to the screen WorkArea on which it is func (w *windowsWebviewWindow) relativePosition() (int, int) { - // Get monitor for window - monitor := w32.MonitorFromWindow(w.hwnd, w32.MONITOR_DEFAULTTONEAREST) - var monitorInfo w32.MONITORINFO - monitorInfo.CbSize = uint32(unsafe.Sizeof(monitorInfo)) - w32.GetMonitorInfo(monitor, &monitorInfo) + screen, _ := w.getScreen() + pos := screen.absoluteToRelativeDipPoint(w.bounds().Origin()) + // Relative to WorkArea origin + pos.X -= (screen.WorkArea.X - screen.X) + pos.Y -= (screen.WorkArea.Y - screen.Y) + return pos.X, pos.Y +} - // Get window rect - rect := w32.GetWindowRect(w.hwnd) - - // Calculate relative position - x := int(rect.Left) - int(monitorInfo.RcWork.Left) - y := int(rect.Top) - int(monitorInfo.RcWork.Top) - - borderSize := w.getBorderSizes() - x += borderSize.Left - y += borderSize.Top - - return w.scaleToDefaultDPI(x, y) +// Set window position relative to the screen WorkArea on which it is +func (w *windowsWebviewWindow) setRelativePosition(x int, y int) { + screen, _ := w.getScreen() + pos := screen.relativeToAbsoluteDipPoint(Point{X: x, Y: y}) + // Relative to WorkArea origin + pos.X += (screen.WorkArea.X - screen.X) + pos.Y += (screen.WorkArea.Y - screen.Y) + w.setPosition(pos.X, pos.Y) } func (w *windowsWebviewWindow) destroy() { @@ -542,16 +590,6 @@ func (w *windowsWebviewWindow) setHTML(html string) { w.execJS(fmt.Sprintf("document.documentElement.innerHTML = %q;", html)) } -func (w *windowsWebviewWindow) setRelativePosition(x int, y int) { - //x, y = w.scaleWithWindowDPI(x, y) - info := w32.GetMonitorInfoForWindow(w.hwnd) - workRect := info.RcWork - borderSize := w.getBorderSizes() - x -= borderSize.Left - y -= borderSize.Top - w32.SetWindowPos(w.hwnd, w32.HWND_TOP, int(workRect.Left)+x, int(workRect.Top)+y, 0, 0, w32.SWP_NOSIZE) -} - // on is used to indicate that a particular event should be listened for func (w *windowsWebviewWindow) on(_ uint) { // We don't need to worry about this in Windows as we do not need @@ -840,45 +878,9 @@ func (w *windowsWebviewWindow) hide() { w32.ShowWindow(w.hwnd, w32.SW_HIDE) } -func getScreen(hwnd w32.HWND) (*Screen, error) { - hMonitor := w32.MonitorFromWindow(hwnd, w32.MONITOR_DEFAULTTONEAREST) - var mi w32.MONITORINFOEX - mi.CbSize = uint32(unsafe.Sizeof(mi)) - w32.GetMonitorInfoEx(hMonitor, &mi) - var thisScreen Screen - thisScreen.X = int(mi.RcMonitor.Left) - thisScreen.Y = int(mi.RcMonitor.Top) - thisScreen.Size = Size{ - Width: int(mi.RcMonitor.Right - mi.RcMonitor.Left), - Height: int(mi.RcMonitor.Bottom - mi.RcMonitor.Top), - } - thisScreen.Bounds = Rect{ - X: int(mi.RcMonitor.Left), - Y: int(mi.RcMonitor.Top), - Width: int(mi.RcMonitor.Right - mi.RcMonitor.Left), - Height: int(mi.RcMonitor.Bottom - mi.RcMonitor.Top), - } - thisScreen.WorkArea = Rect{ - X: int(mi.RcWork.Left), - Y: int(mi.RcWork.Top), - Width: int(mi.RcWork.Right - mi.RcWork.Left), - Height: int(mi.RcWork.Bottom - mi.RcWork.Top), - } - thisScreen.ID = strconv.Itoa(int(hMonitor)) - thisScreen.Name = string(utf16.Decode(mi.SzDevice[:])) - var xdpi, ydpi w32.UINT - w32.GetDPIForMonitor(hMonitor, w32.MDT_EFFECTIVE_DPI, &xdpi, &ydpi) - thisScreen.Scale = float32(xdpi) / 96.0 - thisScreen.IsPrimary = mi.DwFlags&w32.MONITORINFOF_PRIMARY != 0 - - // TODO: Get screen rotation - - return &thisScreen, nil -} - // Get the screen for the current window func (w *windowsWebviewWindow) getScreen() (*Screen, error) { - return getScreen(w.hwnd) + return getScreenForWindow(w) } func (w *windowsWebviewWindow) setFrameless(b bool) { @@ -1081,6 +1083,11 @@ func (w *windowsWebviewWindow) WndProc(msg uint32, wparam, lparam uintptr) uintp mmi := (*w32.MINMAXINFO)(unsafe.Pointer(lparam)) hasConstraints := false options := w.parent.options + // Using ScreenManager to get the closest screen and scale according to its DPI is problematic + // here because in multi-monitor setup, when dragging the window between monitors with the mouse + // on the side with the higher DPI, the DPI change point is offset beyond the mid point, causing + // wrong scaling and unwanted resizing when using the monitor DPI. To avoid this issue, we use + // scaleWithWindowDPI() instead which retrieves the correct DPI with GetDpiForWindow(). if options.MinWidth > 0 || options.MinHeight > 0 { hasConstraints = true @@ -1108,14 +1115,16 @@ func (w *windowsWebviewWindow) WndProc(msg uint32, wparam, lparam uintptr) uintp } case w32.WM_DPICHANGED: - newWindowSize := (*w32.RECT)(unsafe.Pointer(lparam)) - w32.SetWindowPos(w.hwnd, - uintptr(0), - int(newWindowSize.Left), - int(newWindowSize.Top), - int(newWindowSize.Right-newWindowSize.Left), - int(newWindowSize.Bottom-newWindowSize.Top), - w32.SWP_NOZORDER|w32.SWP_NOACTIVATE) + if !w.ignoreDPIChangeResizing { + newWindowRect := (*w32.RECT)(unsafe.Pointer(lparam)) + w32.SetWindowPos(w.hwnd, + uintptr(0), + int(newWindowRect.Left), + int(newWindowRect.Top), + int(newWindowRect.Right-newWindowRect.Left), + int(newWindowRect.Bottom-newWindowRect.Top), + w32.SWP_NOZORDER|w32.SWP_NOACTIVATE) + } w.parent.emit(events.Common.WindowDPIChanged) } @@ -1181,30 +1190,38 @@ func (w *windowsWebviewWindow) WndProc(msg uint32, wparam, lparam uintptr) uintp // Make sure to use the provided RECT to get the monitor, because during maximizig there might be // a wrong monitor returned in multiscreen mode when using MonitorFromWindow. // See: https://github.com/MicrosoftEdge/WebView2Feedback/issues/2549 - monitor := w32.MonitorFromRect(rgrc, w32.MONITOR_DEFAULTTONULL) + screen := ScreenNearestPhysicalRect(Rect{ + X: int(rgrc.Left), + Y: int(rgrc.Top), + Width: int(rgrc.Right - rgrc.Left), + Height: int(rgrc.Bottom - rgrc.Top), + }) - var monitorInfo w32.MONITORINFO - monitorInfo.CbSize = uint32(unsafe.Sizeof(monitorInfo)) - if monitor != 0 && w32.GetMonitorInfo(monitor, &monitorInfo) { - *rgrc = monitorInfo.RcWork + rect := screen.PhysicalWorkArea - maxWidth := options.MaxWidth - maxHeight := options.MaxHeight - if maxWidth > 0 || maxHeight > 0 { - var dpiX, dpiY uint - w32.GetDPIForMonitor(monitor, w32.MDT_EFFECTIVE_DPI, &dpiX, &dpiY) + maxWidth := options.MaxWidth + maxHeight := options.MaxHeight - maxWidth := int32(ScaleWithDPI(maxWidth, dpiX)) - if maxWidth > 0 && rgrc.Right-rgrc.Left > maxWidth { - rgrc.Right = rgrc.Left + maxWidth - } - - maxHeight := int32(ScaleWithDPI(maxHeight, dpiY)) - if maxHeight > 0 && rgrc.Bottom-rgrc.Top > maxHeight { - rgrc.Bottom = rgrc.Top + maxHeight - } + if maxWidth > 0 { + maxWidth = screen.scale(maxWidth, false) + if rect.Width > maxWidth { + rect.Width = maxWidth } } + + if maxHeight > 0 { + maxHeight = screen.scale(maxHeight, false) + if rect.Height > maxHeight { + rect.Height = maxHeight + } + } + + *rgrc = w32.RECT{ + Left: int32(rect.X), + Top: int32(rect.Y), + Right: int32(rect.X + rect.Width), + Bottom: int32(rect.Y + rect.Height), + } w.chromium.SetPadding(edge.Rect{}) } else { // This is needed to workaround the resize flickering in frameless mode with WindowDecorations @@ -1225,7 +1242,7 @@ func (w *windowsWebviewWindow) WndProc(msg uint32, wparam, lparam uintptr) uintp func (w *windowsWebviewWindow) DPI() (w32.UINT, w32.UINT) { if w32.HasGetDpiForWindowFunc() { - // GetDpiForWindow is supported beginning with Windows 10, 1607 and is the most accureate + // GetDpiForWindow is supported beginning with Windows 10, 1607 and is the most accurate // one, especially it is consistent with the WM_DPICHANGED event. dpi := w32.GetDpiForWindow(w.hwnd) return dpi, dpi @@ -1258,12 +1275,8 @@ func (w *windowsWebviewWindow) scaleWithWindowDPI(width, height int) (int, int) return scaledWidth, scaledHeight } -func (w *windowsWebviewWindow) scaleToDefaultDPI(width, height int) (int, int) { - dpix, dpiy := w.DPI() - scaledWidth := ScaleToDefaultDPI(width, dpix) - scaledHeight := ScaleToDefaultDPI(height, dpiy) - - return scaledWidth, scaledHeight +func ScaleWithDPI(pixels int, dpi uint) int { + return (pixels * int(dpi)) / 96 } func (w *windowsWebviewWindow) setWindowMask(imageData []byte) { @@ -1739,14 +1752,6 @@ func (w *windowsWebviewWindow) setMinimiseButtonEnabled(enabled bool) { w.setStyle(enabled, w32.WS_MINIMIZEBOX) } -func ScaleWithDPI(pixels int, dpi uint) int { - return (pixels * int(dpi)) / 96 -} - -func ScaleToDefaultDPI(pixels int, dpi uint) int { - return (pixels * 96) / int(dpi) -} - func NewIconFromResource(instance w32.HINSTANCE, resId uint16) (w32.HICON, error) { var err error var result w32.HICON diff --git a/v3/pkg/w32/constants.go b/v3/pkg/w32/constants.go index 254c4937f..c32c9b531 100644 --- a/v3/pkg/w32/constants.go +++ b/v3/pkg/w32/constants.go @@ -72,6 +72,23 @@ const ( IMAGE_ENHMETAFILE = 3 ) +// SetProcessDpiAwareness constants +const ( + PROCESS_DPI_UNAWARE = 0 + PROCESS_SYSTEM_DPI_AWARE = 1 + PROCESS_PER_MONITOR_DPI_AWARE = 2 +) + +// SetProcessDpiAwarenessContext constants +// Credit: https://github.com/ncruces/zenity +const ( + DPI_AWARENESS_CONTEXT_UNAWARE = ^uintptr(1) + 1 + DPI_AWARENESS_CONTEXT_SYSTEM_AWARE = ^uintptr(2) + 1 + DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE = ^uintptr(3) + 1 + DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2 = ^uintptr(4) + 1 + DPI_AWARENESS_CONTEXT_UNAWARE_GDISCALED = ^uintptr(5) + 1 +) + // ShowWindow constants const ( SW_HIDE = 0 diff --git a/v3/pkg/w32/screen.go b/v3/pkg/w32/screen.go index 0b935e3b0..312b20b6d 100644 --- a/v3/pkg/w32/screen.go +++ b/v3/pkg/w32/screen.go @@ -10,11 +10,12 @@ import ( type Screen struct { MONITORINFOEX - Name string - IsPrimary bool - IsCurrent bool - Scale float32 - Rotation float32 + HMonitor uintptr + Name string + IsPrimary bool + IsCurrent bool + ScaleFactor float32 + Rotation float32 } type DISPLAY_DEVICE struct { @@ -71,8 +72,17 @@ func GetRotationForMonitor(displayName [32]uint16) (float32, error) { } func GetAllScreens() ([]*Screen, error) { - var monitorList []MONITORINFOEX + var result []*Screen + var errMessage string + // Get cursor position to determine the current monitor + var cursor POINT + ret, _, _ := procGetCursorPos.Call(uintptr(unsafe.Pointer(&cursor))) + if ret == 0 { + return nil, fmt.Errorf("GetCursorPos failed") + } + + // Enumerate the monitors enumFunc := func(hMonitor uintptr, hdc uintptr, lprcMonitor *RECT, lParam uintptr) uintptr { monitor := MONITORINFOEX{ MONITORINFO: MONITORINFO{ @@ -82,72 +92,51 @@ func GetAllScreens() ([]*Screen, error) { } ret, _, _ := procGetMonitorInfo.Call(hMonitor, uintptr(unsafe.Pointer(&monitor))) if ret == 0 { - return 1 // Continue enumeration + errMessage = "GetMonitorInfo failed" + return 0 // Stop enumeration } - monitorList = append(monitorList, monitor) - return 1 // Continue enumeration - } - - ret, _, _ := procEnumDisplayMonitors.Call(0, 0, syscall.NewCallback(enumFunc), 0) - if ret == 0 { - return nil, fmt.Errorf("EnumDisplayMonitors failed") - } - - // Get the active screen - var pt POINT - ret, _, _ = procGetCursorPos.Call(uintptr(unsafe.Pointer(&pt))) - if ret == 0 { - return nil, fmt.Errorf("GetCursorPos failed") - } - - hMonitor, _, _ := procMonitorFromPoint.Call(uintptr(unsafe.Pointer(&pt)), MONITOR_DEFAULTTONEAREST) - if hMonitor == 0 { - return nil, fmt.Errorf("MonitorFromPoint failed") - } - - var monitorInfo MONITORINFO - monitorInfo.CbSize = uint32(unsafe.Sizeof(monitorInfo)) - ret, _, _ = procGetMonitorInfo.Call(hMonitor, uintptr(unsafe.Pointer(&monitorInfo))) - if ret == 0 { - return nil, fmt.Errorf("GetMonitorInfo failed") - } - - var result []*Screen - - // Iterate through the screens and set the active one - for _, monitor := range monitorList { - thisContainer := &Screen{ + screen := &Screen{ MONITORINFOEX: monitor, + HMonitor: hMonitor, + IsPrimary: monitor.DwFlags == MONITORINFOF_PRIMARY, + IsCurrent: rectContainsPoint(monitor.RcMonitor, cursor), } - thisContainer.IsCurrent = equalRect(monitor.RcMonitor, monitorInfo.RcMonitor) - thisContainer.IsPrimary = monitor.DwFlags == MONITORINFOF_PRIMARY + + // Get monitor name name, err := getMonitorName(syscall.UTF16ToString(monitor.SzDevice[:])) - if err != nil { - name = "" + if err == nil { + screen.Name = name } + // Get DPI for monitor var dpiX, dpiY uint ret = GetDPIForMonitor(hMonitor, MDT_EFFECTIVE_DPI, &dpiX, &dpiY) if ret != S_OK { - return nil, fmt.Errorf("GetDpiForMonitor failed") + errMessage = "GetDpiForMonitor failed" + return 0 // Stop enumeration } - // Convert to float32 - thisContainer.Scale = float32(dpiX) / 96.0 + // Convert to scale factor + screen.ScaleFactor = float32(dpiX) / 96.0 // Get rotation of monitor rot, err := GetRotationForMonitor(monitor.SzDevice) - if err != nil { - rot = 0 + if err == nil { + screen.Rotation = rot } - thisContainer.Rotation = rot - thisContainer.Name = name - result = append(result, thisContainer) + + result = append(result, screen) + return 1 // Continue enumeration + } + + ret, _, _ = procEnumDisplayMonitors.Call(0, 0, syscall.NewCallback(enumFunc), 0) + if ret == 0 { + return nil, fmt.Errorf("EnumDisplayMonitors failed: %s", errMessage) } return result, nil } -func equalRect(a RECT, b RECT) bool { - return a.Left == b.Left && a.Top == b.Top && a.Right == b.Right && a.Bottom == b.Bottom +func rectContainsPoint(r RECT, p POINT) bool { + return p.X >= r.Left && p.X < r.Right && p.Y >= r.Top && p.Y < r.Bottom } diff --git a/v3/pkg/w32/shcore.go b/v3/pkg/w32/shcore.go index 39e72b917..f2d6c5516 100644 --- a/v3/pkg/w32/shcore.go +++ b/v3/pkg/w32/shcore.go @@ -3,6 +3,7 @@ package w32 import ( + "fmt" "syscall" "unsafe" ) @@ -10,9 +11,23 @@ import ( var ( modshcore = syscall.NewLazyDLL("shcore.dll") - procGetDpiForMonitor = modshcore.NewProc("GetDpiForMonitor") + procGetDpiForMonitor = modshcore.NewProc("GetDpiForMonitor") + procSetProcessDpiAwareness = modshcore.NewProc("SetProcessDpiAwareness") ) +func HasSetProcessDpiAwarenessFunc() bool { + err := procSetProcessDpiAwareness.Find() + return err == nil +} + +func SetProcessDpiAwareness(val uint) error { + status, r, err := procSetProcessDpiAwareness.Call(uintptr(val)) + if status != S_OK { + return fmt.Errorf("procSetProcessDpiAwareness failed %d: %v %v", status, r, err) + } + return nil +} + func HasGetDPIForMonitorFunc() bool { err := procGetDpiForMonitor.Find() return err == nil diff --git a/v3/pkg/w32/typedef.go b/v3/pkg/w32/typedef.go index 433a375b3..bbd6aa9d2 100644 --- a/v3/pkg/w32/typedef.go +++ b/v3/pkg/w32/typedef.go @@ -9,8 +9,9 @@ package w32 import ( "fmt" - "golang.org/x/sys/windows" "unsafe" + + "golang.org/x/sys/windows" ) // From MSDN: Windows Data Types @@ -678,6 +679,7 @@ type NOTIFYICONDATA struct { } const SPI_GETNOTIFYWINDOWRECT = 0x0040 +const SPI_SETWORKAREA = 0x002F // Taskbar constants const ABM_GETTASKBARPOS = 0x00000005 diff --git a/v3/pkg/w32/user32.go b/v3/pkg/w32/user32.go index bf4575fbf..8136384bf 100644 --- a/v3/pkg/w32/user32.go +++ b/v3/pkg/w32/user32.go @@ -9,10 +9,11 @@ package w32 import ( "fmt" - "golang.org/x/sys/windows" "runtime" "syscall" "unsafe" + + "golang.org/x/sys/windows" ) var ( @@ -136,6 +137,7 @@ var ( procGetDpiForSystem = moduser32.NewProc("GetDpiForSystem") procGetDpiForWindow = moduser32.NewProc("GetDpiForWindow") procSetProcessDPIAware = moduser32.NewProc("SetProcessDPIAware") + procSetProcessDpiAwarenessContext = moduser32.NewProc("SetProcessDpiAwarenessContext") procEnumDisplayMonitors = moduser32.NewProc("EnumDisplayMonitors") procEnumDisplayDevices = moduser32.NewProc("EnumDisplayDevicesW") procEnumDisplaySettings = moduser32.NewProc("EnumDisplaySettingsW") @@ -360,6 +362,11 @@ func GetDpiForWindow(hwnd HWND) UINT { return uint(dpi) } +func HasSetProcessDPIAwareFunc() bool { + err := procSetProcessDPIAware.Find() + return err == nil +} + func GetClassName(hwnd HWND) string { var buf [256]uint16 procGetClassName.Call( @@ -378,6 +385,19 @@ func SetProcessDPIAware() error { return nil } +func HasSetProcessDpiAwarenessContextFunc() bool { + err := procSetProcessDpiAwarenessContext.Find() + return err == nil +} + +func SetProcessDpiAwarenessContext(ctx uintptr) error { + status, r, err := procSetProcessDpiAwarenessContext.Call(ctx) + if status == 0 { + return fmt.Errorf("SetProcessDpiAwarenessContext failed %d: %v %v", status, r, err) + } + return nil +} + func GetForegroundWindow() HWND { ret, _, _ := procGetForegroundWindow.Call() return HWND(ret)