2015-01-01 17:20:20 +01:00
|
|
|
// Copyright 2015 Hajime Hoshi
|
2014-12-24 03:04:10 +01:00
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
// you may not use this file except in compliance with the License.
|
|
|
|
// You may obtain a copy of the License at
|
|
|
|
//
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
//
|
|
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
// See the License for the specific language governing permissions and
|
|
|
|
// limitations under the License.
|
2014-12-09 15:16:04 +01:00
|
|
|
|
2022-02-08 07:42:29 +01:00
|
|
|
//go:build !android && !ios && !js && !ebitencbackend
|
|
|
|
// +build !android,!ios,!js,!ebitencbackend
|
2015-01-02 07:20:05 +01:00
|
|
|
|
2022-02-06 08:08:22 +01:00
|
|
|
package ui
|
2014-12-05 18:26:02 +01:00
|
|
|
|
|
|
|
import (
|
2019-12-07 11:28:15 +01:00
|
|
|
"fmt"
|
2017-09-22 21:12:02 +02:00
|
|
|
"image"
|
2019-11-17 11:58:41 +01:00
|
|
|
"os"
|
2014-12-14 10:57:29 +01:00
|
|
|
"runtime"
|
2016-09-03 14:14:06 +02:00
|
|
|
"sync"
|
2021-02-10 18:38:12 +01:00
|
|
|
"sync/atomic"
|
2015-01-07 17:32:37 +01:00
|
|
|
"time"
|
2015-06-20 18:33:28 +02:00
|
|
|
|
2020-10-03 19:35:13 +02:00
|
|
|
"github.com/hajimehoshi/ebiten/v2/internal/devicescale"
|
|
|
|
"github.com/hajimehoshi/ebiten/v2/internal/glfw"
|
|
|
|
"github.com/hajimehoshi/ebiten/v2/internal/hooks"
|
|
|
|
"github.com/hajimehoshi/ebiten/v2/internal/thread"
|
2014-12-05 18:26:02 +01:00
|
|
|
)
|
|
|
|
|
2022-02-06 09:43:52 +01:00
|
|
|
func driverCursorModeToGLFWCursorMode(mode CursorMode) int {
|
2021-04-14 18:59:31 +02:00
|
|
|
switch mode {
|
2022-02-06 09:43:52 +01:00
|
|
|
case CursorModeVisible:
|
2021-04-14 18:59:31 +02:00
|
|
|
return glfw.CursorNormal
|
2022-02-06 09:43:52 +01:00
|
|
|
case CursorModeHidden:
|
2021-04-14 18:59:31 +02:00
|
|
|
return glfw.CursorHidden
|
2022-02-06 09:43:52 +01:00
|
|
|
case CursorModeCaptured:
|
2021-04-14 18:59:31 +02:00
|
|
|
return glfw.CursorDisabled
|
|
|
|
default:
|
2022-02-06 09:43:52 +01:00
|
|
|
panic(fmt.Sprintf("ui: invalid CursorMode: %d", mode))
|
2021-04-14 18:59:31 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-07 03:42:55 +02:00
|
|
|
type UserInterface struct {
|
2022-02-13 08:30:33 +01:00
|
|
|
context *contextImpl
|
2020-04-02 17:06:42 +02:00
|
|
|
title string
|
|
|
|
window *glfw.Window
|
2019-12-09 18:37:10 +01:00
|
|
|
|
2021-10-10 08:38:13 +02:00
|
|
|
// windowWidthInDIP and windowHeightInDIP represents a window size.
|
2021-10-09 16:17:20 +02:00
|
|
|
// The units are device-independent pixels.
|
2021-10-10 08:38:13 +02:00
|
|
|
windowWidthInDIP int
|
|
|
|
windowHeightInDIP int
|
2021-04-16 21:43:20 +02:00
|
|
|
|
|
|
|
// The units are device-independent pixels.
|
2021-10-10 08:38:13 +02:00
|
|
|
minWindowWidthInDIP int
|
|
|
|
minWindowHeightInDIP int
|
|
|
|
maxWindowWidthInDIP int
|
|
|
|
maxWindowHeightInDIP int
|
2018-01-02 16:23:18 +01:00
|
|
|
|
2022-02-10 10:31:55 +01:00
|
|
|
running uint32
|
|
|
|
origPosX int
|
|
|
|
origPosY int
|
|
|
|
runnableOnUnfocused bool
|
2022-02-13 09:23:52 +01:00
|
|
|
fpsMode FPSModeType
|
2022-02-10 10:31:55 +01:00
|
|
|
iconImages []image.Image
|
|
|
|
cursorShape CursorShape
|
|
|
|
windowClosingHandled bool
|
|
|
|
windowBeingClosed bool
|
2021-12-29 14:08:59 +01:00
|
|
|
windowResizingMode WindowResizingMode
|
2018-01-02 16:23:18 +01:00
|
|
|
|
2021-04-18 15:07:26 +02:00
|
|
|
// setSizeCallbackEnabled must be accessed from the main thread.
|
|
|
|
setSizeCallbackEnabled bool
|
|
|
|
|
2021-01-19 18:21:51 +01:00
|
|
|
// err must be accessed from the main thread.
|
|
|
|
err error
|
|
|
|
|
2019-12-08 12:24:20 +01:00
|
|
|
lastDeviceScaleFactor float64
|
2018-08-05 14:19:22 +02:00
|
|
|
|
2021-02-10 20:00:37 +01:00
|
|
|
// These values are not changed after initialized.
|
|
|
|
// TODO: the fullscreen size should be updated when the initial window position is changed?
|
2021-10-10 08:38:13 +02:00
|
|
|
initMonitor *glfw.Monitor
|
|
|
|
initFullscreenWidthInDIP int
|
|
|
|
initFullscreenHeightInDIP int
|
|
|
|
|
2022-02-09 11:56:23 +01:00
|
|
|
initFullscreen bool
|
|
|
|
initCursorMode CursorMode
|
|
|
|
initWindowDecorated bool
|
|
|
|
initWindowPositionXInDIP int
|
|
|
|
initWindowPositionYInDIP int
|
|
|
|
initWindowWidthInDIP int
|
|
|
|
initWindowHeightInDIP int
|
|
|
|
initWindowFloating bool
|
|
|
|
initWindowMaximized bool
|
|
|
|
initScreenTransparent bool
|
|
|
|
initFocused bool
|
2018-01-02 16:23:18 +01:00
|
|
|
|
2021-07-22 16:55:26 +02:00
|
|
|
fpsModeInited bool
|
2020-06-14 04:50:58 +02:00
|
|
|
|
2020-01-03 09:32:46 +01:00
|
|
|
input Input
|
2022-02-06 12:02:03 +01:00
|
|
|
iwindow Window
|
2019-03-30 13:50:32 +01:00
|
|
|
|
2022-01-16 16:28:25 +01:00
|
|
|
sizeCallback glfw.SizeCallback
|
|
|
|
closeCallback glfw.CloseCallback
|
|
|
|
framebufferSizeCallback glfw.FramebufferSizeCallback
|
|
|
|
defaultFramebufferSizeCallback glfw.FramebufferSizeCallback
|
|
|
|
framebufferSizeCallbackCh chan struct{}
|
2021-06-13 14:43:23 +02:00
|
|
|
|
2020-10-20 19:55:17 +02:00
|
|
|
t thread.Thread
|
2019-08-18 18:01:43 +02:00
|
|
|
m sync.RWMutex
|
2016-03-24 16:38:30 +01:00
|
|
|
}
|
|
|
|
|
2019-02-24 15:31:26 +01:00
|
|
|
const (
|
|
|
|
maxInt = int(^uint(0) >> 1)
|
|
|
|
minInt = -maxInt - 1
|
2019-12-22 04:46:57 +01:00
|
|
|
invalidPos = minInt
|
2019-02-24 15:31:26 +01:00
|
|
|
)
|
|
|
|
|
2017-07-30 13:26:40 +02:00
|
|
|
var (
|
2019-04-07 03:42:55 +02:00
|
|
|
theUI = &UserInterface{
|
2021-10-10 08:38:13 +02:00
|
|
|
runnableOnUnfocused: true,
|
|
|
|
minWindowWidthInDIP: glfw.DontCare,
|
|
|
|
minWindowHeightInDIP: glfw.DontCare,
|
|
|
|
maxWindowWidthInDIP: glfw.DontCare,
|
|
|
|
maxWindowHeightInDIP: glfw.DontCare,
|
|
|
|
origPosX: invalidPos,
|
|
|
|
origPosY: invalidPos,
|
2022-02-06 09:43:52 +01:00
|
|
|
initCursorMode: CursorModeVisible,
|
2021-10-10 08:38:13 +02:00
|
|
|
initWindowDecorated: true,
|
|
|
|
initWindowPositionXInDIP: invalidPos,
|
|
|
|
initWindowPositionYInDIP: invalidPos,
|
|
|
|
initWindowWidthInDIP: 640,
|
|
|
|
initWindowHeightInDIP: 480,
|
|
|
|
initFocused: true,
|
2022-02-06 09:43:52 +01:00
|
|
|
fpsMode: FPSModeVsyncOn,
|
2017-07-30 13:26:40 +02:00
|
|
|
}
|
|
|
|
)
|
2016-03-24 16:38:30 +01:00
|
|
|
|
2019-04-07 12:27:30 +02:00
|
|
|
func init() {
|
|
|
|
theUI.input.ui = theUI
|
2019-12-24 16:05:56 +01:00
|
|
|
theUI.iwindow.ui = theUI
|
2019-04-07 12:27:30 +02:00
|
|
|
}
|
|
|
|
|
2019-04-07 03:42:55 +02:00
|
|
|
func Get() *UserInterface {
|
|
|
|
return theUI
|
|
|
|
}
|
|
|
|
|
2016-07-23 13:25:52 +02:00
|
|
|
func init() {
|
2018-12-18 17:01:16 +01:00
|
|
|
hideConsoleWindowOnWindows()
|
2018-05-04 16:55:23 +02:00
|
|
|
if err := initialize(); err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
2019-11-25 15:13:44 +01:00
|
|
|
glfw.SetMonitorCallback(func(monitor *glfw.Monitor, event glfw.PeripheralEvent) {
|
2021-09-09 04:11:56 +02:00
|
|
|
updateMonitors()
|
2018-11-07 12:54:37 +01:00
|
|
|
})
|
2021-09-09 04:11:56 +02:00
|
|
|
updateMonitors()
|
2016-07-23 13:25:52 +02:00
|
|
|
}
|
|
|
|
|
2022-02-06 09:43:52 +01:00
|
|
|
var glfwSystemCursors = map[CursorShape]*glfw.Cursor{}
|
2021-04-11 07:21:38 +02:00
|
|
|
|
2016-07-23 13:25:52 +02:00
|
|
|
func initialize() error {
|
2016-05-07 15:27:10 +02:00
|
|
|
if err := glfw.Init(); err != nil {
|
2016-07-23 13:25:52 +02:00
|
|
|
return err
|
2014-12-05 18:26:02 +01:00
|
|
|
}
|
2021-04-11 07:21:38 +02:00
|
|
|
|
2014-12-17 12:03:26 +01:00
|
|
|
glfw.WindowHint(glfw.Visible, glfw.False)
|
2020-07-05 08:00:56 +02:00
|
|
|
glfw.WindowHint(glfw.ClientAPI, glfw.NoAPI)
|
2017-09-13 20:37:38 +02:00
|
|
|
|
2022-02-07 19:10:59 +01:00
|
|
|
m, err := initialMonitorByOS()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if m == nil {
|
|
|
|
m = glfw.GetPrimaryMonitor()
|
2019-07-21 16:41:51 +02:00
|
|
|
}
|
|
|
|
|
2021-02-10 19:45:35 +01:00
|
|
|
theUI.initMonitor = m
|
2022-02-06 16:51:48 +01:00
|
|
|
// GetVideoMode must be called from the main thread, then call this here and record
|
|
|
|
// initFullscreen{Width,Height}InDIP.
|
2021-02-10 19:45:35 +01:00
|
|
|
v := m.GetVideoMode()
|
2021-10-10 08:38:13 +02:00
|
|
|
theUI.initFullscreenWidthInDIP = int(theUI.dipFromGLFWMonitorPixel(float64(v.Width), m))
|
|
|
|
theUI.initFullscreenHeightInDIP = int(theUI.dipFromGLFWMonitorPixel(float64(v.Height), m))
|
2017-08-12 08:39:41 +02:00
|
|
|
|
2021-04-11 07:21:38 +02:00
|
|
|
// Create system cursors. These cursors are destroyed at glfw.Terminate().
|
2022-02-06 09:43:52 +01:00
|
|
|
glfwSystemCursors[CursorShapeDefault] = nil
|
|
|
|
glfwSystemCursors[CursorShapeText] = glfw.CreateStandardCursor(glfw.IBeamCursor)
|
|
|
|
glfwSystemCursors[CursorShapeCrosshair] = glfw.CreateStandardCursor(glfw.CrosshairCursor)
|
|
|
|
glfwSystemCursors[CursorShapePointer] = glfw.CreateStandardCursor(glfw.HandCursor)
|
|
|
|
glfwSystemCursors[CursorShapeEWResize] = glfw.CreateStandardCursor(glfw.HResizeCursor)
|
|
|
|
glfwSystemCursors[CursorShapeNSResize] = glfw.CreateStandardCursor(glfw.VResizeCursor)
|
2021-04-11 07:21:38 +02:00
|
|
|
|
2016-07-23 13:25:52 +02:00
|
|
|
return nil
|
2014-12-17 12:03:26 +01:00
|
|
|
}
|
2014-12-10 15:52:37 +01:00
|
|
|
|
2021-09-09 04:11:56 +02:00
|
|
|
type monitor struct {
|
2018-11-07 12:54:37 +01:00
|
|
|
m *glfw.Monitor
|
|
|
|
vm *glfw.VidMode
|
|
|
|
// Pos of monitor in virtual coords
|
|
|
|
x int
|
|
|
|
y int
|
|
|
|
}
|
|
|
|
|
|
|
|
// monitors is the monitor list cache for desktop glfw compile targets.
|
2021-09-09 04:11:56 +02:00
|
|
|
// populated by 'updateMonitors' which is called on init and every
|
2018-11-07 12:54:37 +01:00
|
|
|
// monitor config change event.
|
2018-11-14 17:08:36 +01:00
|
|
|
//
|
|
|
|
// monitors must be manipulated on the main thread.
|
2021-09-09 04:11:56 +02:00
|
|
|
var monitors []*monitor
|
2018-11-07 12:54:37 +01:00
|
|
|
|
2021-09-09 04:11:56 +02:00
|
|
|
func updateMonitors() {
|
2018-11-14 17:08:36 +01:00
|
|
|
monitors = nil
|
2018-11-07 12:54:37 +01:00
|
|
|
ms := glfw.GetMonitors()
|
|
|
|
for _, m := range ms {
|
|
|
|
x, y := m.GetPos()
|
2021-09-09 04:11:56 +02:00
|
|
|
monitors = append(monitors, &monitor{
|
2018-11-07 12:54:37 +01:00
|
|
|
m: m,
|
|
|
|
vm: m.GetVideoMode(),
|
|
|
|
x: x,
|
|
|
|
y: y,
|
|
|
|
})
|
|
|
|
}
|
2021-09-15 05:47:04 +02:00
|
|
|
clearVideoModeScaleCache()
|
2021-09-15 06:04:38 +02:00
|
|
|
devicescale.ClearCache()
|
2018-11-07 12:54:37 +01:00
|
|
|
}
|
|
|
|
|
2021-09-09 04:11:56 +02:00
|
|
|
func ensureMonitors() []*monitor {
|
|
|
|
if len(monitors) == 0 {
|
|
|
|
updateMonitors()
|
|
|
|
}
|
|
|
|
return monitors
|
|
|
|
}
|
|
|
|
|
|
|
|
// getMonitorFromPosition returns a monitor for the given window x/y,
|
2020-08-23 20:05:38 +02:00
|
|
|
// or returns nil if monitor is not found.
|
2018-11-14 17:08:36 +01:00
|
|
|
//
|
2021-09-09 04:11:56 +02:00
|
|
|
// getMonitorFromPosition must be called on the main thread.
|
|
|
|
func getMonitorFromPosition(wx, wy int) *monitor {
|
|
|
|
for _, m := range ensureMonitors() {
|
2021-09-14 05:35:02 +02:00
|
|
|
// TODO: Fix incorrectness in the cases of https://github.com/glfw/glfw/issues/1961.
|
|
|
|
// See also internal/devicescale/impl_desktop.go for a maybe better way of doing this.
|
2020-03-28 15:54:55 +01:00
|
|
|
if m.x <= wx && wx < m.x+m.vm.Width && m.y <= wy && wy < m.y+m.vm.Height {
|
2020-08-23 20:05:38 +02:00
|
|
|
return m
|
2018-11-07 12:54:37 +01:00
|
|
|
}
|
|
|
|
}
|
2020-08-23 20:05:38 +02:00
|
|
|
return nil
|
2018-11-07 12:54:37 +01:00
|
|
|
}
|
|
|
|
|
2019-04-07 03:42:55 +02:00
|
|
|
func (u *UserInterface) isRunning() bool {
|
2021-02-10 18:38:12 +01:00
|
|
|
return atomic.LoadUint32(&u.running) != 0
|
2016-09-03 14:14:06 +02:00
|
|
|
}
|
|
|
|
|
2019-04-07 03:42:55 +02:00
|
|
|
func (u *UserInterface) setRunning(running bool) {
|
2021-02-10 18:38:12 +01:00
|
|
|
if running {
|
|
|
|
atomic.StoreUint32(&u.running, 1)
|
|
|
|
} else {
|
|
|
|
atomic.StoreUint32(&u.running, 0)
|
|
|
|
}
|
2017-08-02 17:19:04 +02:00
|
|
|
}
|
|
|
|
|
2021-10-10 08:38:13 +02:00
|
|
|
func (u *UserInterface) getWindowSizeLimitsInDIP() (minw, minh, maxw, maxh int) {
|
2021-04-16 19:27:04 +02:00
|
|
|
u.m.RLock()
|
|
|
|
defer u.m.RUnlock()
|
2021-10-10 08:38:13 +02:00
|
|
|
return u.minWindowWidthInDIP, u.minWindowHeightInDIP, u.maxWindowWidthInDIP, u.maxWindowHeightInDIP
|
2021-04-16 19:27:04 +02:00
|
|
|
}
|
|
|
|
|
2021-10-10 08:38:13 +02:00
|
|
|
func (u *UserInterface) setWindowSizeLimitsInDIP(minw, minh, maxw, maxh int) bool {
|
2021-04-16 19:27:04 +02:00
|
|
|
u.m.RLock()
|
|
|
|
defer u.m.RUnlock()
|
2021-10-10 08:38:13 +02:00
|
|
|
if u.minWindowWidthInDIP == minw && u.minWindowHeightInDIP == minh && u.maxWindowWidthInDIP == maxw && u.maxWindowHeightInDIP == maxh {
|
2021-04-16 19:27:04 +02:00
|
|
|
return false
|
|
|
|
}
|
2021-10-10 08:38:13 +02:00
|
|
|
u.minWindowWidthInDIP = minw
|
|
|
|
u.minWindowHeightInDIP = minh
|
|
|
|
u.maxWindowWidthInDIP = maxw
|
|
|
|
u.maxWindowHeightInDIP = maxh
|
2021-04-16 19:27:04 +02:00
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2019-04-07 03:42:55 +02:00
|
|
|
func (u *UserInterface) isInitFullscreen() bool {
|
2019-08-18 18:01:43 +02:00
|
|
|
u.m.RLock()
|
2017-08-02 17:19:04 +02:00
|
|
|
v := u.initFullscreen
|
2019-08-18 18:01:43 +02:00
|
|
|
u.m.RUnlock()
|
2017-08-02 17:19:04 +02:00
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
2019-04-07 03:42:55 +02:00
|
|
|
func (u *UserInterface) setInitFullscreen(initFullscreen bool) {
|
2017-08-02 17:19:04 +02:00
|
|
|
u.m.Lock()
|
|
|
|
u.initFullscreen = initFullscreen
|
|
|
|
u.m.Unlock()
|
2016-09-03 14:14:06 +02:00
|
|
|
}
|
|
|
|
|
2022-02-06 09:43:52 +01:00
|
|
|
func (u *UserInterface) getInitCursorMode() CursorMode {
|
2019-08-18 18:01:43 +02:00
|
|
|
u.m.RLock()
|
2019-12-14 04:30:03 +01:00
|
|
|
v := u.initCursorMode
|
2019-08-18 18:01:43 +02:00
|
|
|
u.m.RUnlock()
|
2017-08-12 08:39:41 +02:00
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
2022-02-06 09:43:52 +01:00
|
|
|
func (u *UserInterface) setInitCursorMode(mode CursorMode) {
|
2017-08-12 08:39:41 +02:00
|
|
|
u.m.Lock()
|
2019-12-14 04:30:03 +01:00
|
|
|
u.initCursorMode = mode
|
2017-08-12 08:39:41 +02:00
|
|
|
u.m.Unlock()
|
|
|
|
}
|
|
|
|
|
2022-02-06 09:43:52 +01:00
|
|
|
func (u *UserInterface) getCursorShape() CursorShape {
|
2021-04-11 07:21:38 +02:00
|
|
|
u.m.RLock()
|
|
|
|
v := u.cursorShape
|
|
|
|
u.m.RUnlock()
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
2022-02-06 09:43:52 +01:00
|
|
|
func (u *UserInterface) setCursorShape(shape CursorShape) CursorShape {
|
2021-04-11 07:21:38 +02:00
|
|
|
u.m.Lock()
|
|
|
|
old := u.cursorShape
|
|
|
|
u.cursorShape = shape
|
|
|
|
u.m.Unlock()
|
|
|
|
return old
|
|
|
|
}
|
|
|
|
|
2019-04-07 03:42:55 +02:00
|
|
|
func (u *UserInterface) isInitWindowDecorated() bool {
|
2019-08-18 18:01:43 +02:00
|
|
|
u.m.RLock()
|
2017-09-13 20:37:38 +02:00
|
|
|
v := u.initWindowDecorated
|
2019-08-18 18:01:43 +02:00
|
|
|
u.m.RUnlock()
|
2017-09-13 20:37:38 +02:00
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
2019-04-07 03:42:55 +02:00
|
|
|
func (u *UserInterface) setInitWindowDecorated(decorated bool) {
|
2017-09-13 20:37:38 +02:00
|
|
|
u.m.Lock()
|
|
|
|
u.initWindowDecorated = decorated
|
|
|
|
u.m.Unlock()
|
|
|
|
}
|
|
|
|
|
2020-03-20 16:34:12 +01:00
|
|
|
func (u *UserInterface) isRunnableOnUnfocused() bool {
|
2019-08-18 18:01:43 +02:00
|
|
|
u.m.RLock()
|
2020-03-20 16:34:12 +01:00
|
|
|
v := u.runnableOnUnfocused
|
2019-08-18 18:01:43 +02:00
|
|
|
u.m.RUnlock()
|
2017-08-02 16:37:50 +02:00
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
2020-03-20 16:34:12 +01:00
|
|
|
func (u *UserInterface) setRunnableOnUnfocused(runnableOnUnfocused bool) {
|
2017-08-02 16:37:50 +02:00
|
|
|
u.m.Lock()
|
2020-03-20 16:34:12 +01:00
|
|
|
u.runnableOnUnfocused = runnableOnUnfocused
|
2017-08-02 16:37:50 +02:00
|
|
|
u.m.Unlock()
|
|
|
|
}
|
|
|
|
|
2019-11-30 16:07:41 +01:00
|
|
|
func (u *UserInterface) isInitScreenTransparent() bool {
|
|
|
|
u.m.RLock()
|
|
|
|
v := u.initScreenTransparent
|
|
|
|
u.m.RUnlock()
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
|
|
|
func (u *UserInterface) setInitScreenTransparent(transparent bool) {
|
2022-01-16 17:29:29 +01:00
|
|
|
u.m.Lock()
|
2019-11-30 16:07:41 +01:00
|
|
|
u.initScreenTransparent = transparent
|
2022-01-16 17:29:29 +01:00
|
|
|
u.m.Unlock()
|
2019-11-30 16:07:41 +01:00
|
|
|
}
|
|
|
|
|
2021-02-07 13:16:09 +01:00
|
|
|
func (u *UserInterface) getIconImages() []image.Image {
|
2019-08-18 18:01:43 +02:00
|
|
|
u.m.RLock()
|
2021-02-07 13:16:09 +01:00
|
|
|
i := u.iconImages
|
2019-08-18 18:01:43 +02:00
|
|
|
u.m.RUnlock()
|
2017-09-22 21:12:02 +02:00
|
|
|
return i
|
|
|
|
}
|
|
|
|
|
2021-02-07 13:16:09 +01:00
|
|
|
func (u *UserInterface) setIconImages(iconImages []image.Image) {
|
2017-09-22 21:12:02 +02:00
|
|
|
u.m.Lock()
|
2021-02-07 13:16:09 +01:00
|
|
|
u.iconImages = iconImages
|
2017-09-22 21:12:02 +02:00
|
|
|
u.m.Unlock()
|
|
|
|
}
|
|
|
|
|
2021-10-10 08:38:13 +02:00
|
|
|
func (u *UserInterface) getInitWindowPositionInDIP() (int, int) {
|
2019-11-30 16:11:46 +01:00
|
|
|
u.m.RLock()
|
|
|
|
defer u.m.RUnlock()
|
2021-10-10 08:38:13 +02:00
|
|
|
if u.initWindowPositionXInDIP != invalidPos && u.initWindowPositionYInDIP != invalidPos {
|
|
|
|
return u.initWindowPositionXInDIP, u.initWindowPositionYInDIP
|
2019-11-30 16:11:46 +01:00
|
|
|
}
|
2019-12-22 04:46:57 +01:00
|
|
|
return invalidPos, invalidPos
|
2019-11-30 16:11:46 +01:00
|
|
|
}
|
|
|
|
|
2021-10-10 08:38:13 +02:00
|
|
|
func (u *UserInterface) setInitWindowPositionInDIP(x, y int) {
|
2019-11-30 16:11:46 +01:00
|
|
|
u.m.Lock()
|
|
|
|
defer u.m.Unlock()
|
|
|
|
|
2022-02-08 12:26:08 +01:00
|
|
|
// TODO: Update initMonitor if necessary (#1575).
|
2021-10-10 08:38:13 +02:00
|
|
|
u.initWindowPositionXInDIP = x
|
|
|
|
u.initWindowPositionYInDIP = y
|
2019-11-30 16:11:46 +01:00
|
|
|
}
|
|
|
|
|
2021-10-10 08:38:13 +02:00
|
|
|
func (u *UserInterface) getInitWindowSizeInDIP() (int, int) {
|
2019-12-16 02:52:53 +01:00
|
|
|
u.m.Lock()
|
2021-10-10 08:38:13 +02:00
|
|
|
w, h := u.initWindowWidthInDIP, u.initWindowHeightInDIP
|
2019-12-16 02:52:53 +01:00
|
|
|
u.m.Unlock()
|
|
|
|
return w, h
|
|
|
|
}
|
|
|
|
|
2021-10-10 08:38:13 +02:00
|
|
|
func (u *UserInterface) setInitWindowSizeInDIP(width, height int) {
|
2019-12-16 02:52:53 +01:00
|
|
|
u.m.Lock()
|
2021-10-10 08:38:13 +02:00
|
|
|
u.initWindowWidthInDIP, u.initWindowHeightInDIP = width, height
|
2019-12-16 02:52:53 +01:00
|
|
|
u.m.Unlock()
|
|
|
|
}
|
|
|
|
|
2020-03-20 13:46:23 +01:00
|
|
|
func (u *UserInterface) isInitWindowFloating() bool {
|
2022-01-16 17:29:29 +01:00
|
|
|
u.m.RLock()
|
2020-03-20 13:46:23 +01:00
|
|
|
f := u.initWindowFloating
|
2022-01-16 17:29:29 +01:00
|
|
|
u.m.RUnlock()
|
2020-03-20 13:46:23 +01:00
|
|
|
return f
|
|
|
|
}
|
|
|
|
|
|
|
|
func (u *UserInterface) setInitWindowFloating(floating bool) {
|
|
|
|
u.m.Lock()
|
|
|
|
u.initWindowFloating = floating
|
|
|
|
u.m.Unlock()
|
|
|
|
}
|
|
|
|
|
2020-03-21 11:26:28 +01:00
|
|
|
func (u *UserInterface) isInitWindowMaximized() bool {
|
2022-01-16 17:29:29 +01:00
|
|
|
u.m.RLock()
|
2021-06-13 16:25:24 +02:00
|
|
|
m := u.initWindowMaximized
|
2022-01-16 17:29:29 +01:00
|
|
|
u.m.RUnlock()
|
2021-06-13 16:25:24 +02:00
|
|
|
return m
|
2020-03-21 11:26:28 +01:00
|
|
|
}
|
|
|
|
|
2021-06-13 16:25:24 +02:00
|
|
|
func (u *UserInterface) setInitWindowMaximized(maximized bool) {
|
2020-03-21 11:26:28 +01:00
|
|
|
u.m.Lock()
|
2021-06-13 16:25:24 +02:00
|
|
|
u.initWindowMaximized = maximized
|
2020-08-23 19:55:31 +02:00
|
|
|
u.m.Unlock()
|
2020-02-09 15:03:03 +01:00
|
|
|
}
|
|
|
|
|
2021-06-13 13:52:14 +02:00
|
|
|
func (u *UserInterface) isWindowClosingHandled() bool {
|
2022-01-16 17:29:29 +01:00
|
|
|
u.m.RLock()
|
2021-06-13 13:52:14 +02:00
|
|
|
v := u.windowClosingHandled
|
2022-01-16 17:29:29 +01:00
|
|
|
u.m.RUnlock()
|
2021-06-13 13:52:14 +02:00
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
|
|
|
func (u *UserInterface) setWindowClosingHandled(handled bool) {
|
|
|
|
u.m.Lock()
|
|
|
|
u.windowClosingHandled = handled
|
|
|
|
u.m.Unlock()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (u *UserInterface) isWindowBeingClosed() bool {
|
2022-01-16 17:29:29 +01:00
|
|
|
u.m.RLock()
|
2021-06-13 13:52:14 +02:00
|
|
|
v := u.windowBeingClosed
|
2022-01-16 17:29:29 +01:00
|
|
|
u.m.RUnlock()
|
2021-06-13 13:52:14 +02:00
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
2020-02-09 15:03:03 +01:00
|
|
|
func (u *UserInterface) isInitFocused() bool {
|
2022-01-16 17:29:29 +01:00
|
|
|
u.m.RLock()
|
2020-02-09 15:03:03 +01:00
|
|
|
v := u.initFocused
|
2022-01-16 17:29:29 +01:00
|
|
|
u.m.RUnlock()
|
2020-02-09 15:03:03 +01:00
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
|
|
|
func (u *UserInterface) setInitFocused(focused bool) {
|
|
|
|
u.m.Lock()
|
|
|
|
u.initFocused = focused
|
2020-03-21 11:26:28 +01:00
|
|
|
u.m.Unlock()
|
|
|
|
}
|
|
|
|
|
2019-04-07 03:42:55 +02:00
|
|
|
func (u *UserInterface) ScreenSizeInFullscreen() (int, int) {
|
2018-12-18 17:17:59 +01:00
|
|
|
if !u.isRunning() {
|
2021-10-10 08:38:13 +02:00
|
|
|
return u.initFullscreenWidthInDIP, u.initFullscreenHeightInDIP
|
2018-12-18 17:17:59 +01:00
|
|
|
}
|
|
|
|
|
2019-12-08 13:49:42 +01:00
|
|
|
var w, h int
|
2022-01-02 19:30:29 +01:00
|
|
|
u.t.Call(func() {
|
2021-10-09 09:49:47 +02:00
|
|
|
m := u.currentMonitor()
|
2021-09-14 18:03:04 +02:00
|
|
|
v := m.GetVideoMode()
|
2021-10-10 08:38:13 +02:00
|
|
|
w = int(u.dipFromGLFWMonitorPixel(float64(v.Width), m))
|
|
|
|
h = int(u.dipFromGLFWMonitorPixel(float64(v.Height), m))
|
2018-12-18 17:17:59 +01:00
|
|
|
})
|
2019-12-08 13:49:42 +01:00
|
|
|
return w, h
|
2018-05-04 09:09:55 +02:00
|
|
|
}
|
|
|
|
|
2019-02-07 09:19:24 +01:00
|
|
|
// isFullscreen must be called from the main thread.
|
2019-04-07 03:42:55 +02:00
|
|
|
func (u *UserInterface) isFullscreen() bool {
|
2017-08-12 11:31:16 +02:00
|
|
|
if !u.isRunning() {
|
2022-02-06 08:08:22 +01:00
|
|
|
panic("ui: isFullscreen can't be called before the main loop starts")
|
2017-08-12 11:31:16 +02:00
|
|
|
}
|
2021-09-17 19:21:24 +02:00
|
|
|
return u.window.GetMonitor() != nil || u.isNativeFullscreen()
|
2017-08-12 11:31:16 +02:00
|
|
|
}
|
|
|
|
|
2019-04-07 03:42:55 +02:00
|
|
|
func (u *UserInterface) IsFullscreen() bool {
|
2017-06-29 17:35:34 +02:00
|
|
|
if !u.isRunning() {
|
2017-08-02 17:19:04 +02:00
|
|
|
return u.isInitFullscreen()
|
2017-06-29 17:35:34 +02:00
|
|
|
}
|
2018-02-24 10:10:39 +01:00
|
|
|
b := false
|
2022-01-02 19:30:29 +01:00
|
|
|
u.t.Call(func() {
|
2019-02-07 09:19:24 +01:00
|
|
|
b = u.isFullscreen()
|
2018-02-24 10:10:39 +01:00
|
|
|
})
|
|
|
|
return b
|
2017-06-29 17:35:34 +02:00
|
|
|
}
|
|
|
|
|
2019-04-07 03:42:55 +02:00
|
|
|
func (u *UserInterface) SetFullscreen(fullscreen bool) {
|
2017-08-02 18:07:04 +02:00
|
|
|
if !u.isRunning() {
|
|
|
|
u.setInitFullscreen(fullscreen)
|
|
|
|
return
|
|
|
|
}
|
2019-12-09 18:37:10 +01:00
|
|
|
|
|
|
|
var update bool
|
2022-01-02 19:30:29 +01:00
|
|
|
u.t.Call(func() {
|
2019-12-09 18:37:10 +01:00
|
|
|
update = u.isFullscreen() != fullscreen
|
|
|
|
})
|
|
|
|
if !update {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2022-01-02 19:30:29 +01:00
|
|
|
u.t.Call(func() {
|
2021-10-10 08:38:13 +02:00
|
|
|
w, h := u.windowWidthInDIP, u.windowHeightInDIP
|
|
|
|
u.setWindowSizeInDIP(w, h, fullscreen)
|
2019-12-09 18:37:10 +01:00
|
|
|
})
|
2017-08-02 18:07:04 +02:00
|
|
|
}
|
|
|
|
|
2020-03-20 16:08:40 +01:00
|
|
|
func (u *UserInterface) IsFocused() bool {
|
2020-01-16 02:47:23 +01:00
|
|
|
if !u.isRunning() {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2020-03-20 16:08:40 +01:00
|
|
|
var focused bool
|
2022-01-02 19:30:29 +01:00
|
|
|
u.t.Call(func() {
|
2020-03-20 16:08:40 +01:00
|
|
|
focused = u.window.GetAttrib(glfw.Focused) == glfw.True
|
2020-01-16 02:47:23 +01:00
|
|
|
})
|
2020-03-20 16:08:40 +01:00
|
|
|
return focused
|
2020-01-16 02:47:23 +01:00
|
|
|
}
|
|
|
|
|
2020-03-20 16:34:12 +01:00
|
|
|
func (u *UserInterface) SetRunnableOnUnfocused(runnableOnUnfocused bool) {
|
|
|
|
u.setRunnableOnUnfocused(runnableOnUnfocused)
|
2017-08-02 16:37:50 +02:00
|
|
|
}
|
|
|
|
|
2020-03-20 16:34:12 +01:00
|
|
|
func (u *UserInterface) IsRunnableOnUnfocused() bool {
|
|
|
|
return u.isRunnableOnUnfocused()
|
2017-08-02 16:37:50 +02:00
|
|
|
}
|
|
|
|
|
2022-02-13 09:23:52 +01:00
|
|
|
func (u *UserInterface) SetFPSMode(mode FPSModeType) {
|
2018-07-14 13:50:09 +02:00
|
|
|
if !u.isRunning() {
|
2019-08-18 18:47:55 +02:00
|
|
|
u.m.Lock()
|
2021-12-29 14:21:27 +01:00
|
|
|
u.fpsMode = mode
|
2019-08-18 18:47:55 +02:00
|
|
|
u.m.Unlock()
|
2018-07-14 13:50:09 +02:00
|
|
|
return
|
|
|
|
}
|
2022-01-02 19:30:29 +01:00
|
|
|
u.t.Call(func() {
|
2021-07-22 16:55:26 +02:00
|
|
|
if !u.fpsModeInited {
|
2021-12-29 14:21:27 +01:00
|
|
|
u.fpsMode = mode
|
2022-01-02 19:30:29 +01:00
|
|
|
return
|
2020-06-14 04:50:58 +02:00
|
|
|
}
|
2021-08-31 04:43:08 +02:00
|
|
|
u.setFPSMode(mode)
|
2020-06-14 04:50:58 +02:00
|
|
|
u.updateVsync()
|
2019-12-09 18:37:10 +01:00
|
|
|
})
|
2018-07-14 13:50:09 +02:00
|
|
|
}
|
|
|
|
|
2021-07-22 18:07:28 +02:00
|
|
|
func (u *UserInterface) ScheduleFrame() {
|
|
|
|
if !u.isRunning() {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// As the main thread can be blocked, do not check the current FPS mode.
|
|
|
|
// PostEmptyEvent is concurrent safe.
|
|
|
|
glfw.PostEmptyEvent()
|
|
|
|
}
|
|
|
|
|
2022-02-06 09:43:52 +01:00
|
|
|
func (u *UserInterface) CursorMode() CursorMode {
|
2017-08-12 08:39:41 +02:00
|
|
|
if !u.isRunning() {
|
2019-12-14 04:30:03 +01:00
|
|
|
return u.getInitCursorMode()
|
2017-08-12 08:39:41 +02:00
|
|
|
}
|
2022-01-02 19:30:29 +01:00
|
|
|
|
|
|
|
var mode int
|
|
|
|
u.t.Call(func() {
|
|
|
|
mode = u.window.GetInputMode(glfw.CursorMode)
|
2017-08-12 08:39:41 +02:00
|
|
|
})
|
2022-01-02 19:30:29 +01:00
|
|
|
|
2022-02-06 09:43:52 +01:00
|
|
|
var v CursorMode
|
2022-01-02 19:30:29 +01:00
|
|
|
switch mode {
|
|
|
|
case glfw.CursorNormal:
|
2022-02-06 09:43:52 +01:00
|
|
|
v = CursorModeVisible
|
2022-01-02 19:30:29 +01:00
|
|
|
case glfw.CursorHidden:
|
2022-02-06 09:43:52 +01:00
|
|
|
v = CursorModeHidden
|
2022-01-02 19:30:29 +01:00
|
|
|
case glfw.CursorDisabled:
|
2022-02-06 09:43:52 +01:00
|
|
|
v = CursorModeCaptured
|
2022-01-02 19:30:29 +01:00
|
|
|
default:
|
2022-02-06 08:08:22 +01:00
|
|
|
panic(fmt.Sprintf("ui: invalid GLFW cursor mode: %d", mode))
|
2022-01-02 19:30:29 +01:00
|
|
|
}
|
2017-08-12 08:39:41 +02:00
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
2022-02-06 09:43:52 +01:00
|
|
|
func (u *UserInterface) SetCursorMode(mode CursorMode) {
|
2017-08-12 08:39:41 +02:00
|
|
|
if !u.isRunning() {
|
2019-12-14 04:30:03 +01:00
|
|
|
u.setInitCursorMode(mode)
|
2017-08-12 08:39:41 +02:00
|
|
|
return
|
|
|
|
}
|
2022-01-02 19:30:29 +01:00
|
|
|
u.t.Call(func() {
|
2021-04-14 18:59:31 +02:00
|
|
|
u.window.SetInputMode(glfw.CursorMode, driverCursorModeToGLFWCursorMode(mode))
|
2017-08-12 08:39:41 +02:00
|
|
|
})
|
2016-09-03 10:17:54 +02:00
|
|
|
}
|
|
|
|
|
2022-02-06 09:43:52 +01:00
|
|
|
func (u *UserInterface) CursorShape() CursorShape {
|
2021-04-11 07:21:38 +02:00
|
|
|
return u.getCursorShape()
|
|
|
|
}
|
|
|
|
|
2022-02-06 09:43:52 +01:00
|
|
|
func (u *UserInterface) SetCursorShape(shape CursorShape) {
|
2021-04-11 07:21:38 +02:00
|
|
|
old := u.setCursorShape(shape)
|
|
|
|
if old == shape {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if !u.isRunning() {
|
|
|
|
return
|
|
|
|
}
|
2022-01-02 19:30:29 +01:00
|
|
|
u.t.Call(func() {
|
2021-05-02 07:50:50 +02:00
|
|
|
u.setNativeCursor(shape)
|
2021-04-11 07:21:38 +02:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2019-04-07 03:42:55 +02:00
|
|
|
func (u *UserInterface) DeviceScaleFactor() float64 {
|
2018-10-07 18:11:13 +02:00
|
|
|
if !u.isRunning() {
|
2021-11-12 14:29:03 +01:00
|
|
|
return u.deviceScaleFactor(u.currentMonitor())
|
2018-10-07 18:11:13 +02:00
|
|
|
}
|
|
|
|
|
2019-12-08 12:24:20 +01:00
|
|
|
f := 0.0
|
2022-01-02 19:30:29 +01:00
|
|
|
u.t.Call(func() {
|
2021-11-12 14:29:03 +01:00
|
|
|
f = u.deviceScaleFactor(u.currentMonitor())
|
2018-10-07 18:11:13 +02:00
|
|
|
})
|
|
|
|
return f
|
|
|
|
}
|
|
|
|
|
2019-12-08 12:24:20 +01:00
|
|
|
// deviceScaleFactor must be called from the main thread.
|
2021-11-12 14:29:03 +01:00
|
|
|
func (u *UserInterface) deviceScaleFactor(monitor *glfw.Monitor) float64 {
|
2021-11-24 14:35:08 +01:00
|
|
|
// It is rare, but monitor can be nil when glfw.GetPrimaryMonitor returns nil.
|
|
|
|
// In this case, return 1 as a tentative scale (#1878).
|
|
|
|
if monitor == nil {
|
|
|
|
return 1
|
|
|
|
}
|
|
|
|
|
2021-11-12 14:29:03 +01:00
|
|
|
mx, my := monitor.GetPos()
|
2021-09-14 18:03:04 +02:00
|
|
|
return devicescale.GetAt(mx, my)
|
2019-12-08 12:24:20 +01:00
|
|
|
}
|
|
|
|
|
2019-06-05 17:05:53 +02:00
|
|
|
func init() {
|
|
|
|
// Lock the main thread.
|
|
|
|
runtime.LockOSThread()
|
|
|
|
}
|
|
|
|
|
2022-02-06 09:43:52 +01:00
|
|
|
func (u *UserInterface) RunWithoutMainLoop(context Context) {
|
2022-02-06 08:08:22 +01:00
|
|
|
panic("ui: RunWithoutMainLoop is not implemented")
|
2019-04-10 03:44:02 +02:00
|
|
|
}
|
|
|
|
|
2019-12-07 11:28:15 +01:00
|
|
|
// createWindow creates a GLFW window.
|
|
|
|
//
|
2022-02-08 11:35:51 +01:00
|
|
|
// width and height are in GLFW pixels (not device-independent pixels).
|
|
|
|
//
|
2019-12-07 11:28:15 +01:00
|
|
|
// createWindow must be called from the main thread.
|
|
|
|
//
|
|
|
|
// createWindow does not set the position or size so far.
|
2022-02-08 11:35:51 +01:00
|
|
|
func (u *UserInterface) createWindow(width, height int) error {
|
2019-12-07 11:28:15 +01:00
|
|
|
if u.window != nil {
|
2022-02-06 08:08:22 +01:00
|
|
|
panic("ui: u.window must not exist at createWindow")
|
2019-12-07 11:28:15 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// As a start, create a window with temporary size to create OpenGL context thread.
|
2022-02-08 11:35:51 +01:00
|
|
|
window, err := glfw.CreateWindow(width, height, "", nil, nil)
|
2019-12-07 11:28:15 +01:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2021-09-24 19:46:18 +02:00
|
|
|
initializeWindowAfterCreation(window)
|
2019-12-07 11:28:15 +01:00
|
|
|
u.window = window
|
|
|
|
|
2021-10-12 16:29:15 +02:00
|
|
|
// Even just after a window creation, FramebufferSize callback might be invoked (#1847).
|
|
|
|
// Ensure to consume this callback.
|
2021-10-12 17:15:32 +02:00
|
|
|
u.waitForFramebufferSizeCallback(u.window, nil)
|
2021-10-12 16:29:15 +02:00
|
|
|
|
2022-02-12 20:15:06 +01:00
|
|
|
if graphics().IsGL() {
|
2019-12-07 11:28:15 +01:00
|
|
|
u.window.MakeContextCurrent()
|
|
|
|
}
|
|
|
|
|
2021-04-14 18:59:31 +02:00
|
|
|
u.window.SetInputMode(glfw.CursorMode, driverCursorModeToGLFWCursorMode(u.getInitCursorMode()))
|
2021-04-11 07:21:38 +02:00
|
|
|
u.window.SetCursor(glfwSystemCursors[u.getCursorShape()])
|
2019-12-07 11:28:15 +01:00
|
|
|
u.window.SetTitle(u.title)
|
2022-02-08 11:23:38 +01:00
|
|
|
// Icons are set after every frame. They don't have to be cared here.
|
2019-12-07 11:28:15 +01:00
|
|
|
|
2021-04-18 18:28:56 +02:00
|
|
|
u.registerWindowSetSizeCallback()
|
2021-06-13 13:52:14 +02:00
|
|
|
u.registerWindowCloseCallback()
|
2022-02-02 17:00:05 +01:00
|
|
|
u.registerWindowFramebufferSizeCallback()
|
2021-04-18 18:28:56 +02:00
|
|
|
|
2022-02-08 08:06:12 +01:00
|
|
|
u.updateWindowSizeLimits()
|
|
|
|
|
2021-03-05 17:39:20 +01:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// registerWindowSetSizeCallback must be called from the main thread.
|
|
|
|
func (u *UserInterface) registerWindowSetSizeCallback() {
|
2021-06-13 14:43:23 +02:00
|
|
|
if u.sizeCallback == 0 {
|
|
|
|
u.sizeCallback = glfw.ToSizeCallback(func(_ *glfw.Window, width, height int) {
|
|
|
|
if !u.setSizeCallbackEnabled {
|
|
|
|
return
|
|
|
|
}
|
2021-01-19 18:21:51 +01:00
|
|
|
|
2021-09-18 15:11:26 +02:00
|
|
|
u.adjustViewSize()
|
|
|
|
|
2021-06-13 14:43:23 +02:00
|
|
|
if u.window.GetAttrib(glfw.Resizable) == glfw.False {
|
|
|
|
return
|
2021-01-19 18:21:51 +01:00
|
|
|
}
|
2021-09-17 19:21:24 +02:00
|
|
|
if u.isFullscreen() && !u.isNativeFullscreen() {
|
2021-06-13 14:43:23 +02:00
|
|
|
return
|
2021-01-19 18:21:51 +01:00
|
|
|
}
|
2021-06-13 14:43:23 +02:00
|
|
|
|
|
|
|
if err := u.runOnAnotherThreadFromMainThread(func() error {
|
|
|
|
var outsideWidth, outsideHeight float64
|
2022-02-13 10:31:28 +01:00
|
|
|
var deviceScaleFactor float64
|
2021-06-13 14:43:23 +02:00
|
|
|
|
2022-01-02 19:30:29 +01:00
|
|
|
u.t.Call(func() {
|
2021-06-13 14:43:23 +02:00
|
|
|
if width != 0 || height != 0 {
|
2021-10-10 08:38:13 +02:00
|
|
|
w := int(u.dipFromGLFWPixel(float64(width), u.currentMonitor()))
|
|
|
|
h := int(u.dipFromGLFWPixel(float64(height), u.currentMonitor()))
|
|
|
|
u.setWindowSizeInDIP(w, h, u.isFullscreen())
|
2021-06-13 14:43:23 +02:00
|
|
|
}
|
|
|
|
|
2021-11-27 09:51:40 +01:00
|
|
|
outsideWidth, outsideHeight = u.updateSize()
|
2022-02-13 10:31:28 +01:00
|
|
|
deviceScaleFactor = u.deviceScaleFactor(u.currentMonitor())
|
2021-01-19 18:21:51 +01:00
|
|
|
})
|
2022-02-13 08:30:33 +01:00
|
|
|
u.context.layout(outsideWidth, outsideHeight)
|
2022-02-13 10:31:28 +01:00
|
|
|
if err := u.context.forceUpdateFrame(deviceScaleFactor); err != nil {
|
2021-06-13 14:43:23 +02:00
|
|
|
return err
|
|
|
|
}
|
2022-02-12 20:15:06 +01:00
|
|
|
if graphics().IsGL() {
|
2022-01-02 19:30:29 +01:00
|
|
|
u.t.Call(func() {
|
2021-06-13 14:43:23 +02:00
|
|
|
u.swapBuffers()
|
|
|
|
})
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}); err != nil {
|
|
|
|
u.err = err
|
2021-01-19 18:21:51 +01:00
|
|
|
}
|
2021-06-13 14:43:23 +02:00
|
|
|
})
|
|
|
|
}
|
|
|
|
u.window.SetSizeCallback(u.sizeCallback)
|
2019-12-07 11:28:15 +01:00
|
|
|
}
|
|
|
|
|
2021-06-13 13:52:14 +02:00
|
|
|
// registerWindowCloseCallback must be called from the main thread.
|
|
|
|
func (u *UserInterface) registerWindowCloseCallback() {
|
|
|
|
if u.closeCallback == 0 {
|
|
|
|
u.closeCallback = glfw.ToCloseCallback(func(_ *glfw.Window) {
|
|
|
|
u.m.Lock()
|
|
|
|
u.windowBeingClosed = true
|
|
|
|
u.m.Unlock()
|
|
|
|
|
|
|
|
if !u.isWindowClosingHandled() {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
u.window.SetShouldClose(false)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
u.window.SetCloseCallback(u.closeCallback)
|
|
|
|
}
|
|
|
|
|
2022-02-02 17:00:05 +01:00
|
|
|
// registerWindowFramebufferSizeCallback must be called from the main thread.
|
|
|
|
func (u *UserInterface) registerWindowFramebufferSizeCallback() {
|
|
|
|
if u.defaultFramebufferSizeCallback == 0 {
|
|
|
|
// When the window gets resized (either by manual window resize or a window
|
|
|
|
// manager), glfw sends a framebuffer size callback which we need to handle (#1960).
|
|
|
|
// This event is the only way to handle the size change at least on i3 window manager.
|
|
|
|
u.defaultFramebufferSizeCallback = glfw.ToFramebufferSizeCallback(func(_ *glfw.Window, w, h int) {
|
|
|
|
if u.isFullscreen() {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// The framebuffer size is always scaled by the device scale factor (#1975).
|
|
|
|
// See also the implementation in uiContext.updateOffscreen.
|
|
|
|
s := u.deviceScaleFactor(u.currentMonitor())
|
|
|
|
ww := int(float64(w) / s)
|
|
|
|
wh := int(float64(h) / s)
|
|
|
|
u.setWindowSizeInDIP(ww, wh, u.isFullscreen())
|
|
|
|
})
|
|
|
|
}
|
|
|
|
u.window.SetFramebufferSizeCallback(u.defaultFramebufferSizeCallback)
|
|
|
|
}
|
|
|
|
|
2021-10-12 16:29:15 +02:00
|
|
|
// waitForFramebufferSizeCallback waits for GLFW's FramebufferSize callback.
|
|
|
|
// f is a process executed after registering the callback.
|
|
|
|
// If the callback is not invoked for a while, waitForFramebufferSizeCallback times out and return.
|
|
|
|
//
|
|
|
|
// waitForFramebufferSizeCallback must be called from the main thread.
|
2021-10-12 17:15:32 +02:00
|
|
|
func (u *UserInterface) waitForFramebufferSizeCallback(window *glfw.Window, f func()) {
|
2021-10-12 16:29:15 +02:00
|
|
|
u.framebufferSizeCallbackCh = make(chan struct{}, 1)
|
|
|
|
|
|
|
|
if u.framebufferSizeCallback == 0 {
|
2021-10-12 17:15:32 +02:00
|
|
|
u.framebufferSizeCallback = glfw.ToFramebufferSizeCallback(func(_ *glfw.Window, _, _ int) {
|
2021-10-12 16:29:15 +02:00
|
|
|
// This callback can be invoked multiple times by one PollEvents in theory (#1618).
|
|
|
|
// Allow the case when the channel is full.
|
|
|
|
select {
|
|
|
|
case u.framebufferSizeCallbackCh <- struct{}{}:
|
|
|
|
default:
|
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|
2021-10-12 17:15:32 +02:00
|
|
|
window.SetFramebufferSizeCallback(u.framebufferSizeCallback)
|
2021-10-12 16:29:15 +02:00
|
|
|
|
|
|
|
if f != nil {
|
|
|
|
f()
|
|
|
|
}
|
|
|
|
|
|
|
|
// Use the timeout as FramebufferSize event might not be fired (#1618).
|
2022-02-02 16:28:11 +01:00
|
|
|
t := time.NewTimer(100 * time.Millisecond)
|
2021-10-12 16:29:15 +02:00
|
|
|
defer t.Stop()
|
|
|
|
|
|
|
|
event:
|
|
|
|
for {
|
|
|
|
glfw.PollEvents()
|
|
|
|
select {
|
|
|
|
case <-u.framebufferSizeCallbackCh:
|
|
|
|
break event
|
|
|
|
case <-t.C:
|
|
|
|
break event
|
|
|
|
default:
|
|
|
|
time.Sleep(time.Millisecond)
|
|
|
|
}
|
|
|
|
}
|
2022-01-16 16:28:25 +01:00
|
|
|
window.SetFramebufferSizeCallback(u.defaultFramebufferSizeCallback)
|
|
|
|
|
2021-10-12 16:29:15 +02:00
|
|
|
close(u.framebufferSizeCallbackCh)
|
|
|
|
u.framebufferSizeCallbackCh = nil
|
|
|
|
}
|
|
|
|
|
2020-10-16 21:21:07 +02:00
|
|
|
func (u *UserInterface) init() error {
|
2022-02-12 20:15:06 +01:00
|
|
|
if graphics().IsGL() {
|
2020-10-16 21:21:07 +02:00
|
|
|
glfw.WindowHint(glfw.ClientAPI, glfw.OpenGLAPI)
|
|
|
|
glfw.WindowHint(glfw.ContextVersionMajor, 2)
|
|
|
|
glfw.WindowHint(glfw.ContextVersionMinor, 1)
|
|
|
|
} else {
|
|
|
|
glfw.WindowHint(glfw.ClientAPI, glfw.NoAPI)
|
|
|
|
}
|
2018-12-18 17:01:16 +01:00
|
|
|
|
2021-09-18 13:39:24 +02:00
|
|
|
glfw.WindowHint(glfw.AutoIconify, glfw.False)
|
2021-09-16 19:38:00 +02:00
|
|
|
|
2020-10-16 21:21:07 +02:00
|
|
|
decorated := glfw.False
|
|
|
|
if u.isInitWindowDecorated() {
|
|
|
|
decorated = glfw.True
|
|
|
|
}
|
|
|
|
glfw.WindowHint(glfw.Decorated, decorated)
|
2019-11-30 16:07:41 +01:00
|
|
|
|
2020-10-16 21:21:07 +02:00
|
|
|
transparent := glfw.False
|
|
|
|
if u.isInitScreenTransparent() {
|
|
|
|
transparent = glfw.True
|
|
|
|
}
|
|
|
|
glfw.WindowHint(glfw.TransparentFramebuffer, transparent)
|
2022-02-12 20:15:06 +01:00
|
|
|
graphics().SetTransparent(u.isInitScreenTransparent())
|
2019-01-06 16:21:59 +01:00
|
|
|
|
2022-02-09 16:53:18 +01:00
|
|
|
// Before creating a window, set it unresizable no matter what u.isInitWindowResizable() is (#1987).
|
|
|
|
// Making the window resizable here doesn't work correctly when switching to enable resizing.
|
2021-12-29 14:08:59 +01:00
|
|
|
resizable := glfw.False
|
|
|
|
if u.windowResizingMode == WindowResizingModeEnabled {
|
|
|
|
resizable = glfw.True
|
|
|
|
}
|
|
|
|
glfw.WindowHint(glfw.Resizable, resizable)
|
2020-03-20 13:46:23 +01:00
|
|
|
|
2020-10-16 21:21:07 +02:00
|
|
|
floating := glfw.False
|
|
|
|
if u.isInitWindowFloating() {
|
|
|
|
floating = glfw.True
|
|
|
|
}
|
|
|
|
glfw.WindowHint(glfw.Floating, floating)
|
2020-02-09 15:03:03 +01:00
|
|
|
|
2020-10-16 21:21:07 +02:00
|
|
|
focused := glfw.False
|
|
|
|
if u.isInitFocused() {
|
|
|
|
focused = glfw.True
|
|
|
|
}
|
|
|
|
glfw.WindowHint(glfw.FocusOnShow, focused)
|
2019-11-10 11:26:46 +01:00
|
|
|
|
2020-10-16 21:21:07 +02:00
|
|
|
// Set the window visible explicitly or the application freezes on Wayland (#974).
|
|
|
|
if os.Getenv("WAYLAND_DISPLAY") != "" {
|
|
|
|
glfw.WindowHint(glfw.Visible, glfw.True)
|
|
|
|
}
|
2018-12-17 19:07:13 +01:00
|
|
|
|
2022-02-08 11:35:51 +01:00
|
|
|
ww, wh := u.getInitWindowSizeInDIP()
|
|
|
|
initW := int(u.dipToGLFWPixel(float64(ww), u.initMonitor))
|
|
|
|
initH := int(u.dipToGLFWPixel(float64(wh), u.initMonitor))
|
|
|
|
if err := u.createWindow(initW, initH); err != nil {
|
2019-12-07 11:28:15 +01:00
|
|
|
return err
|
|
|
|
}
|
2021-09-24 19:46:18 +02:00
|
|
|
|
2021-04-20 16:01:02 +02:00
|
|
|
u.setSizeCallbackEnabled = true
|
2019-12-07 11:28:15 +01:00
|
|
|
|
2022-02-07 17:29:20 +01:00
|
|
|
// The position must be set before the size is set (#1982).
|
|
|
|
// setWindowSize refers the current monitor's device scale.
|
2022-02-08 11:35:51 +01:00
|
|
|
// TODO: currentMonitor is very hard to use correctly. Refactor this.
|
2021-10-10 08:38:13 +02:00
|
|
|
wx, wy := u.getInitWindowPositionInDIP()
|
2022-02-07 17:29:20 +01:00
|
|
|
u.setWindowPositionInDIP(wx, wy, u.initMonitor)
|
|
|
|
u.setWindowSizeInDIP(ww, wh, u.isFullscreen())
|
2019-12-07 11:28:15 +01:00
|
|
|
|
2020-03-28 14:33:58 +01:00
|
|
|
// Maximizing a window requires a proper size and position. Call Maximize here (#1117).
|
|
|
|
if u.isInitWindowMaximized() {
|
2020-10-16 21:21:07 +02:00
|
|
|
u.window.Maximize()
|
2020-03-28 14:33:58 +01:00
|
|
|
}
|
|
|
|
|
2021-12-29 14:08:59 +01:00
|
|
|
u.setWindowResizingModeForOS(u.windowResizingMode)
|
|
|
|
|
2020-10-16 21:21:07 +02:00
|
|
|
u.window.Show()
|
2018-12-28 06:08:44 +01:00
|
|
|
|
2022-02-12 20:15:06 +01:00
|
|
|
if g, ok := graphics().(interface{ SetWindow(uintptr) }); ok {
|
2020-10-16 21:21:07 +02:00
|
|
|
g.SetWindow(u.nativeWindow())
|
2020-01-03 10:53:37 +01:00
|
|
|
}
|
2020-10-16 21:21:07 +02:00
|
|
|
|
|
|
|
return nil
|
2016-02-25 19:09:23 +01:00
|
|
|
}
|
|
|
|
|
2021-11-27 09:51:40 +01:00
|
|
|
func (u *UserInterface) updateSize() (float64, float64) {
|
2021-10-10 08:38:13 +02:00
|
|
|
ww, wh := u.windowWidthInDIP, u.windowHeightInDIP
|
|
|
|
u.setWindowSizeInDIP(ww, wh, u.isFullscreen())
|
2019-12-07 11:28:15 +01:00
|
|
|
|
2020-10-16 22:53:15 +02:00
|
|
|
var w, h float64
|
2021-09-18 17:13:53 +02:00
|
|
|
if u.isFullscreen() && !u.isNativeFullscreen() {
|
|
|
|
// On Linux, the window size is not reliable just after making the window
|
|
|
|
// fullscreened. Use the monitor size.
|
|
|
|
// On macOS's native fullscreen, the window's size returns a more precise size
|
|
|
|
// reflecting the adjustment of the view size (#1745).
|
2021-10-09 09:49:47 +02:00
|
|
|
m := u.currentMonitor()
|
2021-09-14 18:03:04 +02:00
|
|
|
v := m.GetVideoMode()
|
2020-10-16 22:53:15 +02:00
|
|
|
ww, wh := v.Width, v.Height
|
2021-10-10 08:38:13 +02:00
|
|
|
w = u.dipFromGLFWMonitorPixel(float64(ww), m)
|
|
|
|
h = u.dipFromGLFWMonitorPixel(float64(wh), m)
|
2020-10-16 22:53:15 +02:00
|
|
|
} else {
|
2021-10-10 08:38:13 +02:00
|
|
|
// Instead of u.windowWidthInDIP and u.windowHeightInDIP, use the actual window size
|
2021-10-09 16:17:20 +02:00
|
|
|
// here. On Windows, the specified size at SetSize and the actual window size might
|
|
|
|
// not match (#1163).
|
2020-10-16 22:53:15 +02:00
|
|
|
ww, wh := u.window.GetSize()
|
2021-10-10 08:38:13 +02:00
|
|
|
w = u.dipFromGLFWPixel(float64(ww), u.currentMonitor())
|
|
|
|
h = u.dipFromGLFWPixel(float64(wh), u.currentMonitor())
|
2018-02-01 18:08:03 +01:00
|
|
|
}
|
2020-10-16 22:53:15 +02:00
|
|
|
|
2021-11-27 09:51:40 +01:00
|
|
|
return w, h
|
2018-02-01 18:08:03 +01:00
|
|
|
}
|
|
|
|
|
2021-08-31 04:43:08 +02:00
|
|
|
// setFPSMode must be called from the main thread.
|
2022-02-13 09:23:52 +01:00
|
|
|
func (u *UserInterface) setFPSMode(fpsMode FPSModeType) {
|
2021-12-29 14:21:27 +01:00
|
|
|
needUpdate := u.fpsMode != fpsMode || !u.fpsModeInited
|
2021-08-31 04:43:08 +02:00
|
|
|
u.fpsMode = fpsMode
|
|
|
|
u.fpsModeInited = true
|
|
|
|
|
2021-12-29 14:21:27 +01:00
|
|
|
if !needUpdate {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-08-31 04:43:08 +02:00
|
|
|
sticky := glfw.True
|
2022-02-06 09:43:52 +01:00
|
|
|
if fpsMode == FPSModeVsyncOffMinimum {
|
2021-08-31 04:43:08 +02:00
|
|
|
sticky = glfw.False
|
|
|
|
}
|
|
|
|
u.window.SetInputMode(glfw.StickyMouseButtonsMode, sticky)
|
|
|
|
u.window.SetInputMode(glfw.StickyKeysMode, sticky)
|
|
|
|
}
|
|
|
|
|
2020-10-16 23:01:05 +02:00
|
|
|
// update must be called from the main thread.
|
2021-11-27 09:51:40 +01:00
|
|
|
func (u *UserInterface) update() (float64, float64, error) {
|
2021-01-19 18:21:51 +01:00
|
|
|
if u.err != nil {
|
2021-11-27 09:51:40 +01:00
|
|
|
return 0, 0, u.err
|
2021-01-19 18:21:51 +01:00
|
|
|
}
|
|
|
|
|
2020-10-17 08:09:12 +02:00
|
|
|
if u.window.ShouldClose() {
|
2022-02-06 09:43:52 +01:00
|
|
|
return 0, 0, RegularTermination
|
2020-10-16 23:01:05 +02:00
|
|
|
}
|
2020-10-16 21:37:38 +02:00
|
|
|
|
2020-10-16 23:01:05 +02:00
|
|
|
if u.isInitFullscreen() {
|
|
|
|
w, h := u.window.GetSize()
|
2021-10-10 08:38:13 +02:00
|
|
|
ww := int(u.dipFromGLFWPixel(float64(w), u.currentMonitor()))
|
|
|
|
wh := int(u.dipFromGLFWPixel(float64(h), u.currentMonitor()))
|
|
|
|
u.setWindowSizeInDIP(ww, wh, true)
|
2020-10-16 23:01:05 +02:00
|
|
|
u.setInitFullscreen(false)
|
|
|
|
}
|
2020-10-16 22:31:21 +02:00
|
|
|
|
2020-10-16 23:01:05 +02:00
|
|
|
// Initialize vsync after SetMonitor is called. See the comment in updateVsync.
|
|
|
|
// Calling this inside setWindowSize didn't work (#1363).
|
2021-07-22 16:55:26 +02:00
|
|
|
if !u.fpsModeInited {
|
2021-12-29 14:21:27 +01:00
|
|
|
u.setFPSMode(u.fpsMode)
|
2020-10-16 21:37:38 +02:00
|
|
|
}
|
2020-09-22 11:40:52 +02:00
|
|
|
|
2021-08-05 20:08:01 +02:00
|
|
|
// Call updateVsync even though fpsMode is not updated.
|
|
|
|
// The vsync state might be changed in other places (e.g., the SetSizeCallback).
|
2021-08-25 19:05:25 +02:00
|
|
|
// Also, when toggling to fullscreen, vsync state might be reset unexpectedly (#1787).
|
2021-08-05 20:08:01 +02:00
|
|
|
u.updateVsync()
|
|
|
|
|
2021-11-27 09:51:40 +01:00
|
|
|
outsideWidth, outsideHeight := u.updateSize()
|
2020-10-16 22:53:15 +02:00
|
|
|
|
2022-02-06 09:43:52 +01:00
|
|
|
if u.fpsMode != FPSModeVsyncOffMinimum {
|
2021-07-22 18:07:28 +02:00
|
|
|
// TODO: Updating the input can be skipped when clock.Update returns 0 (#1367).
|
|
|
|
glfw.PollEvents()
|
|
|
|
} else {
|
|
|
|
glfw.WaitEvents()
|
|
|
|
}
|
2022-01-22 20:20:54 +01:00
|
|
|
if err := u.input.update(u.window, u.context); err != nil {
|
|
|
|
return 0, 0, err
|
|
|
|
}
|
2016-05-18 04:56:43 +02:00
|
|
|
|
2020-10-16 23:01:05 +02:00
|
|
|
for !u.isRunnableOnUnfocused() && u.window.GetAttrib(glfw.Focused) == 0 && !u.window.ShouldClose() {
|
2021-05-04 15:24:31 +02:00
|
|
|
if err := hooks.SuspendAudio(); err != nil {
|
2021-11-27 09:51:40 +01:00
|
|
|
return 0, 0, err
|
2021-05-04 15:24:31 +02:00
|
|
|
}
|
2020-10-16 23:01:05 +02:00
|
|
|
// Wait for an arbitrary period to avoid busy loop.
|
|
|
|
time.Sleep(time.Second / 60)
|
2019-03-31 12:51:53 +02:00
|
|
|
glfw.PollEvents()
|
2020-10-16 23:01:05 +02:00
|
|
|
}
|
2021-05-04 15:24:31 +02:00
|
|
|
if err := hooks.ResumeAudio(); err != nil {
|
2021-11-27 09:51:40 +01:00
|
|
|
return 0, 0, err
|
2021-05-04 15:24:31 +02:00
|
|
|
}
|
2019-01-06 16:21:59 +01:00
|
|
|
|
2021-11-27 09:51:40 +01:00
|
|
|
return outsideWidth, outsideHeight, nil
|
2015-01-07 17:32:37 +01:00
|
|
|
}
|
|
|
|
|
2020-04-02 17:06:42 +02:00
|
|
|
func (u *UserInterface) loop() error {
|
2022-01-02 19:30:29 +01:00
|
|
|
defer u.t.Call(glfw.Terminate)
|
2021-02-07 13:16:09 +01:00
|
|
|
|
2016-08-31 19:38:47 +02:00
|
|
|
for {
|
2019-11-17 06:10:35 +01:00
|
|
|
var unfocused bool
|
|
|
|
|
|
|
|
// On Windows, the focusing state might be always false (#987).
|
|
|
|
// On Windows, even if a window is in another workspace, vsync seems to work.
|
2020-01-01 15:59:56 +01:00
|
|
|
// Then let's assume the window is always 'focused' as a workaround.
|
2019-11-17 06:10:35 +01:00
|
|
|
if runtime.GOOS != "windows" {
|
|
|
|
unfocused = u.window.GetAttrib(glfw.Focused) == glfw.False
|
|
|
|
}
|
2019-11-14 05:07:10 +01:00
|
|
|
|
|
|
|
var t1, t2 time.Time
|
|
|
|
|
|
|
|
if unfocused {
|
|
|
|
t1 = time.Now()
|
|
|
|
}
|
2020-10-16 23:01:05 +02:00
|
|
|
|
|
|
|
var outsideWidth, outsideHeight float64
|
2022-02-13 10:31:28 +01:00
|
|
|
var deviceScaleFactor float64
|
2022-01-02 19:30:29 +01:00
|
|
|
var err error
|
|
|
|
if u.t.Call(func() {
|
2021-11-27 09:51:40 +01:00
|
|
|
outsideWidth, outsideHeight, err = u.update()
|
2022-02-13 10:31:28 +01:00
|
|
|
deviceScaleFactor = u.deviceScaleFactor(u.currentMonitor())
|
2020-10-16 23:01:05 +02:00
|
|
|
}); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2022-02-13 08:30:33 +01:00
|
|
|
u.context.layout(outsideWidth, outsideHeight)
|
2020-10-16 23:01:05 +02:00
|
|
|
|
2022-02-13 10:31:28 +01:00
|
|
|
if err := u.context.updateFrame(deviceScaleFactor); err != nil {
|
2020-10-16 22:31:21 +02:00
|
|
|
return err
|
|
|
|
}
|
2020-10-16 23:08:13 +02:00
|
|
|
|
2021-04-18 15:13:34 +02:00
|
|
|
// Create icon images in a different goroutine (#1478).
|
2021-04-21 15:50:00 +02:00
|
|
|
// In the fullscreen mode, SetIcon fails (#1578).
|
2021-04-24 17:57:06 +02:00
|
|
|
if imgs := u.getIconImages(); len(imgs) > 0 && !u.isFullscreen() {
|
2021-09-09 19:17:19 +02:00
|
|
|
u.setIconImages(nil)
|
2021-02-07 13:16:09 +01:00
|
|
|
|
|
|
|
// Convert the icons in the different goroutine, as (*ebiten.Image).At cannot be invoked
|
|
|
|
// from this goroutine. At works only in between BeginFrame and EndFrame.
|
|
|
|
go func() {
|
|
|
|
newImgs := make([]image.Image, len(imgs))
|
|
|
|
for i, img := range imgs {
|
|
|
|
// TODO: If img is not *ebiten.Image, this converting is not necessary.
|
|
|
|
// However, this package cannot refer *ebiten.Image due to the package
|
|
|
|
// dependencies.
|
|
|
|
|
|
|
|
b := img.Bounds()
|
|
|
|
rgba := image.NewRGBA(b)
|
|
|
|
for j := b.Min.Y; j < b.Max.Y; j++ {
|
|
|
|
for i := b.Min.X; i < b.Max.X; i++ {
|
|
|
|
rgba.Set(i, j, img.At(i, j))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
newImgs[i] = rgba
|
|
|
|
}
|
|
|
|
|
2022-01-02 19:30:29 +01:00
|
|
|
u.t.Call(func() {
|
2021-04-21 15:50:00 +02:00
|
|
|
// In the fullscreen mode, reset the icon images and try again later.
|
2021-04-18 15:13:34 +02:00
|
|
|
if u.isFullscreen() {
|
|
|
|
u.setIconImages(imgs)
|
2022-01-02 19:30:29 +01:00
|
|
|
return
|
2021-04-18 15:13:34 +02:00
|
|
|
}
|
2021-02-07 13:16:09 +01:00
|
|
|
u.window.SetIcon(newImgs)
|
|
|
|
})
|
|
|
|
}()
|
|
|
|
}
|
|
|
|
|
2020-10-16 23:08:13 +02:00
|
|
|
// swapBuffers also checks IsGL, so this condition is redundant.
|
|
|
|
// However, (*thread).Call is not good for performance due to channels.
|
|
|
|
// Let's avoid this whenever possible (#1367).
|
2022-02-12 20:15:06 +01:00
|
|
|
if graphics().IsGL() {
|
2022-01-02 19:30:29 +01:00
|
|
|
u.t.Call(u.swapBuffers)
|
2020-10-16 23:08:13 +02:00
|
|
|
}
|
2020-10-16 22:31:21 +02:00
|
|
|
|
2019-11-14 05:07:10 +01:00
|
|
|
if unfocused {
|
|
|
|
t2 = time.Now()
|
|
|
|
}
|
|
|
|
|
|
|
|
// When a window is not focused, SwapBuffers might return immediately and CPU might be busy.
|
|
|
|
// Mitigate this by sleeping (#982).
|
|
|
|
if unfocused {
|
|
|
|
d := t2.Sub(t1)
|
|
|
|
const wait = time.Second / 60
|
|
|
|
if d < wait {
|
|
|
|
time.Sleep(wait - d)
|
|
|
|
}
|
|
|
|
}
|
2016-07-23 14:01:30 +02:00
|
|
|
}
|
2016-03-26 09:24:40 +01:00
|
|
|
}
|
|
|
|
|
2018-02-24 16:00:59 +01:00
|
|
|
// swapBuffers must be called from the main thread.
|
2019-04-07 03:42:55 +02:00
|
|
|
func (u *UserInterface) swapBuffers() {
|
2022-02-12 20:15:06 +01:00
|
|
|
if graphics().IsGL() {
|
2018-11-12 16:00:10 +01:00
|
|
|
u.window.SwapBuffers()
|
|
|
|
}
|
2014-12-14 10:57:29 +01:00
|
|
|
}
|
2015-02-09 02:25:00 +01:00
|
|
|
|
2021-04-16 19:27:04 +02:00
|
|
|
// updateWindowSizeLimits must be called from the main thread.
|
|
|
|
func (u *UserInterface) updateWindowSizeLimits() {
|
2021-10-09 09:49:47 +02:00
|
|
|
m := u.currentMonitor()
|
2021-10-10 08:38:13 +02:00
|
|
|
minw, minh, maxw, maxh := u.getWindowSizeLimitsInDIP()
|
2022-02-09 14:58:31 +01:00
|
|
|
|
2021-04-16 19:27:04 +02:00
|
|
|
if minw < 0 {
|
2022-02-09 14:58:31 +01:00
|
|
|
// Always set the minimum window width.
|
|
|
|
minw = int(u.dipToGLFWPixel(float64(u.minimumWindowWidth()), m))
|
2021-04-16 21:43:20 +02:00
|
|
|
} else {
|
2021-10-10 08:38:13 +02:00
|
|
|
minw = int(u.dipToGLFWPixel(float64(minw), m))
|
2021-04-16 19:27:04 +02:00
|
|
|
}
|
|
|
|
if minh < 0 {
|
2022-02-10 10:31:55 +01:00
|
|
|
minh = glfw.DontCare
|
2021-04-16 21:43:20 +02:00
|
|
|
} else {
|
2021-10-10 08:38:13 +02:00
|
|
|
minh = int(u.dipToGLFWPixel(float64(minh), m))
|
2021-04-16 19:27:04 +02:00
|
|
|
}
|
|
|
|
if maxw < 0 {
|
|
|
|
maxw = glfw.DontCare
|
2021-04-16 21:43:20 +02:00
|
|
|
} else {
|
2021-10-10 08:38:13 +02:00
|
|
|
maxw = int(u.dipToGLFWPixel(float64(maxw), m))
|
2021-04-16 19:27:04 +02:00
|
|
|
}
|
|
|
|
if maxh < 0 {
|
|
|
|
maxh = glfw.DontCare
|
2021-04-16 21:43:20 +02:00
|
|
|
} else {
|
2021-10-10 08:38:13 +02:00
|
|
|
maxh = int(u.dipToGLFWPixel(float64(maxh), m))
|
2021-04-16 19:27:04 +02:00
|
|
|
}
|
|
|
|
u.window.SetSizeLimits(minw, minh, maxw, maxh)
|
|
|
|
}
|
|
|
|
|
2021-10-10 08:38:13 +02:00
|
|
|
// adjustWindowSizeBasedOnSizeLimitsInDIP adjust the size based on the window size limits.
|
2021-04-16 21:43:20 +02:00
|
|
|
// width and height are in device-independent pixels.
|
2021-10-10 08:38:13 +02:00
|
|
|
func (u *UserInterface) adjustWindowSizeBasedOnSizeLimitsInDIP(width, height int) (int, int) {
|
|
|
|
minw, minh, maxw, maxh := u.getWindowSizeLimitsInDIP()
|
2021-04-16 19:27:04 +02:00
|
|
|
if minw >= 0 && width < minw {
|
|
|
|
width = minw
|
|
|
|
}
|
|
|
|
if minh >= 0 && height < minh {
|
|
|
|
height = minh
|
|
|
|
}
|
|
|
|
if maxw >= 0 && width > maxw {
|
|
|
|
width = maxw
|
|
|
|
}
|
|
|
|
if maxh >= 0 && height > maxh {
|
|
|
|
height = maxh
|
|
|
|
}
|
|
|
|
return width, height
|
|
|
|
}
|
|
|
|
|
2020-10-16 21:21:07 +02:00
|
|
|
// setWindowSize must be called from the main thread.
|
2021-10-10 08:38:13 +02:00
|
|
|
func (u *UserInterface) setWindowSizeInDIP(width, height int, fullscreen bool) {
|
|
|
|
width, height = u.adjustWindowSizeBasedOnSizeLimitsInDIP(width, height)
|
2021-04-16 19:27:04 +02:00
|
|
|
|
2022-02-12 20:15:06 +01:00
|
|
|
graphics().SetFullscreen(fullscreen)
|
2021-08-08 08:38:41 +02:00
|
|
|
|
2021-11-12 14:29:03 +01:00
|
|
|
scale := u.deviceScaleFactor(u.currentMonitor())
|
2021-10-10 08:38:13 +02:00
|
|
|
if u.windowWidthInDIP == width && u.windowHeightInDIP == height && u.isFullscreen() == fullscreen && u.lastDeviceScaleFactor == scale {
|
2020-10-16 21:21:07 +02:00
|
|
|
return
|
|
|
|
}
|
2016-03-22 03:56:40 +01:00
|
|
|
|
2020-10-16 21:21:07 +02:00
|
|
|
if width < 1 {
|
|
|
|
width = 1
|
|
|
|
}
|
|
|
|
if height < 1 {
|
|
|
|
height = 1
|
|
|
|
}
|
2017-10-19 20:25:21 +02:00
|
|
|
|
2021-10-09 16:17:20 +02:00
|
|
|
u.lastDeviceScaleFactor = scale
|
2017-10-19 20:25:21 +02:00
|
|
|
|
2020-10-16 21:21:07 +02:00
|
|
|
// To make sure the current existing framebuffers are rendered,
|
|
|
|
// swap buffers here before SetSize is called.
|
|
|
|
u.swapBuffers()
|
2019-12-07 11:28:15 +01:00
|
|
|
|
2021-04-18 15:07:26 +02:00
|
|
|
// Disable the callback of SetSize. This callback can be invoked by SetMonitor or SetSize.
|
2021-08-04 18:29:45 +02:00
|
|
|
// ForceUpdateFrame is called from the callback.
|
|
|
|
// While setWindowSize can be called from UpdateFrame,
|
|
|
|
// calling ForceUpdateFrame inside UpdateFrame is illegal (#1505).
|
2021-04-18 15:07:26 +02:00
|
|
|
if u.setSizeCallbackEnabled {
|
|
|
|
u.setSizeCallbackEnabled = false
|
|
|
|
defer func() {
|
|
|
|
u.setSizeCallbackEnabled = true
|
|
|
|
}()
|
2021-04-17 16:57:17 +02:00
|
|
|
}
|
2021-02-23 08:52:09 +01:00
|
|
|
|
2022-02-09 14:22:14 +01:00
|
|
|
u.setWindowSizeInDIPImpl(width, height, fullscreen)
|
2021-09-17 19:21:24 +02:00
|
|
|
|
2022-02-09 14:58:31 +01:00
|
|
|
u.updateWindowSizeLimits()
|
|
|
|
|
2021-09-18 15:11:26 +02:00
|
|
|
u.adjustViewSize()
|
|
|
|
|
2021-09-17 19:21:24 +02:00
|
|
|
// As width might be updated, update windowWidth/Height here.
|
2021-10-10 08:38:13 +02:00
|
|
|
u.windowWidthInDIP = width
|
|
|
|
u.windowHeightInDIP = height
|
2021-09-17 19:21:24 +02:00
|
|
|
}
|
|
|
|
|
2022-02-09 14:58:31 +01:00
|
|
|
func (u *UserInterface) minimumWindowWidth() int {
|
|
|
|
if u.window.GetAttrib(glfw.Decorated) == glfw.False {
|
|
|
|
return 1
|
|
|
|
}
|
|
|
|
|
2022-02-09 15:29:00 +01:00
|
|
|
// On Windows, giving a too small width doesn't call a callback (#165).
|
|
|
|
// To prevent hanging up, return asap if the width is too small.
|
|
|
|
// 126 is an arbitrary number and I guess this is small enough .
|
|
|
|
if runtime.GOOS == "windows" {
|
|
|
|
return 126
|
|
|
|
}
|
|
|
|
|
|
|
|
// On macOS, resizing the window by cursor sometimes ignores the minimum size.
|
|
|
|
// To avoid the flaky behavior, do not add a limitation.
|
|
|
|
return 1
|
2022-02-09 14:58:31 +01:00
|
|
|
}
|
|
|
|
|
2022-02-09 14:22:14 +01:00
|
|
|
func (u *UserInterface) setWindowSizeInDIPImpl(width, height int, fullscreen bool) {
|
2020-10-16 21:21:07 +02:00
|
|
|
if fullscreen {
|
2021-09-17 19:21:24 +02:00
|
|
|
if x, y := u.origPos(); x == invalidPos || y == invalidPos {
|
|
|
|
u.setOrigPos(u.window.GetPos())
|
2020-10-16 21:21:07 +02:00
|
|
|
}
|
|
|
|
|
2021-09-17 19:21:24 +02:00
|
|
|
if u.isNativeFullscreenAvailable() {
|
|
|
|
u.setNativeFullscreen(fullscreen)
|
|
|
|
} else {
|
2021-10-09 09:49:47 +02:00
|
|
|
m := u.currentMonitor()
|
2021-09-17 19:21:24 +02:00
|
|
|
v := m.GetVideoMode()
|
|
|
|
u.window.SetMonitor(m, 0, 0, v.Width, v.Height, v.RefreshRate)
|
|
|
|
|
|
|
|
// Swapping buffer is necesary to prevent the image lag (#1004).
|
|
|
|
// TODO: This might not work when vsync is disabled.
|
2022-02-12 20:15:06 +01:00
|
|
|
if graphics().IsGL() {
|
2021-09-17 19:21:24 +02:00
|
|
|
glfw.PollEvents()
|
|
|
|
u.swapBuffers()
|
|
|
|
}
|
2020-10-16 21:21:07 +02:00
|
|
|
}
|
|
|
|
} else {
|
2022-02-09 14:58:31 +01:00
|
|
|
if mw := u.minimumWindowWidth(); width < mw {
|
|
|
|
width = mw
|
2020-10-16 21:21:07 +02:00
|
|
|
}
|
2021-09-17 19:21:24 +02:00
|
|
|
if u.isNativeFullscreenAvailable() && u.isNativeFullscreen() {
|
|
|
|
u.setNativeFullscreen(false)
|
|
|
|
} else if !u.isNativeFullscreenAvailable() && u.window.GetMonitor() != nil {
|
2022-02-08 11:41:00 +01:00
|
|
|
ww := int(u.dipToGLFWPixel(float64(width), u.currentMonitor()))
|
|
|
|
wh := int(u.dipToGLFWPixel(float64(height), u.currentMonitor()))
|
|
|
|
u.window.SetMonitor(nil, 0, 0, ww, wh, 0)
|
|
|
|
glfw.PollEvents()
|
|
|
|
u.swapBuffers()
|
2020-10-16 21:21:07 +02:00
|
|
|
}
|
2018-10-05 20:53:34 +02:00
|
|
|
|
2021-09-17 19:21:24 +02:00
|
|
|
if x, y := u.origPos(); x != invalidPos && y != invalidPos {
|
2020-10-16 21:21:07 +02:00
|
|
|
u.window.SetPos(x, y)
|
|
|
|
// Dirty hack for macOS (#703). Rendering doesn't work correctly with one SetPos, but
|
|
|
|
// work with two or more SetPos.
|
|
|
|
if runtime.GOOS == "darwin" {
|
|
|
|
u.window.SetPos(x+1, y)
|
2019-12-09 18:37:10 +01:00
|
|
|
u.window.SetPos(x, y)
|
2019-12-08 17:06:25 +01:00
|
|
|
}
|
2021-09-17 19:21:24 +02:00
|
|
|
u.setOrigPos(invalidPos, invalidPos)
|
2020-10-16 21:21:07 +02:00
|
|
|
}
|
2019-12-08 17:06:25 +01:00
|
|
|
|
2020-10-16 21:21:07 +02:00
|
|
|
// Set the window size after the position. The order matters.
|
|
|
|
// In the opposite order, the window size might not be correct when going back from fullscreen with multi monitors.
|
|
|
|
oldW, oldH := u.window.GetSize()
|
2021-10-10 08:38:13 +02:00
|
|
|
newW := int(u.dipToGLFWPixel(float64(width), u.currentMonitor()))
|
|
|
|
newH := int(u.dipToGLFWPixel(float64(height), u.currentMonitor()))
|
2020-10-16 21:21:07 +02:00
|
|
|
if oldW != newW || oldH != newH {
|
2021-04-22 20:28:09 +02:00
|
|
|
// Just after SetSize, GetSize is not reliable especially on Linux/UNIX.
|
2021-04-22 20:02:06 +02:00
|
|
|
// Let's wait for FramebufferSize callback in any cases.
|
2021-10-12 17:15:32 +02:00
|
|
|
u.waitForFramebufferSizeCallback(u.window, func() {
|
2021-10-12 16:29:15 +02:00
|
|
|
u.window.SetSize(newW, newH)
|
|
|
|
})
|
2019-12-07 11:28:15 +01:00
|
|
|
}
|
2020-10-16 21:21:07 +02:00
|
|
|
}
|
2015-02-09 02:25:00 +01:00
|
|
|
}
|
2018-10-05 16:59:30 +02:00
|
|
|
|
2020-06-14 04:50:58 +02:00
|
|
|
// updateVsync must be called on the main thread.
|
|
|
|
func (u *UserInterface) updateVsync() {
|
2022-02-12 20:15:06 +01:00
|
|
|
if graphics().IsGL() {
|
2020-06-14 04:50:58 +02:00
|
|
|
// SwapInterval is affected by the current monitor of the window.
|
|
|
|
// This needs to be called at least after SetMonitor.
|
|
|
|
// Without SwapInterval after SetMonitor, vsynch doesn't work (#375).
|
|
|
|
//
|
|
|
|
// TODO: (#405) If triple buffering is needed, SwapInterval(0) should be called,
|
|
|
|
// but is this correct? If glfw.SwapInterval(0) and the driver doesn't support triple
|
|
|
|
// buffering, what will happen?
|
2022-02-06 09:43:52 +01:00
|
|
|
if u.fpsMode == FPSModeVsyncOn {
|
2020-06-14 04:50:58 +02:00
|
|
|
glfw.SwapInterval(1)
|
|
|
|
} else {
|
|
|
|
glfw.SwapInterval(0)
|
|
|
|
}
|
|
|
|
}
|
2022-02-12 20:15:06 +01:00
|
|
|
graphics().SetVsyncEnabled(u.fpsMode == FPSModeVsyncOn)
|
2020-06-14 04:50:58 +02:00
|
|
|
}
|
|
|
|
|
2020-08-23 20:27:38 +02:00
|
|
|
// currentMonitor returns the current active monitor.
|
|
|
|
//
|
2021-10-09 09:49:47 +02:00
|
|
|
// currentMonitor must be called on the main thread.
|
|
|
|
func (u *UserInterface) currentMonitor() *glfw.Monitor {
|
2022-02-08 16:26:49 +01:00
|
|
|
if u.window == nil {
|
2021-10-09 09:49:47 +02:00
|
|
|
return u.initMonitor
|
|
|
|
}
|
2022-02-08 16:26:49 +01:00
|
|
|
if m := monitorFromWindow(u.window); m != nil {
|
|
|
|
return m
|
|
|
|
}
|
|
|
|
return glfw.GetPrimaryMonitor()
|
2021-10-09 09:49:47 +02:00
|
|
|
}
|
|
|
|
|
2022-02-08 16:26:49 +01:00
|
|
|
// monitorFromWindow returns the monitor from the given window.
|
2021-10-09 09:49:47 +02:00
|
|
|
//
|
2022-02-08 16:26:49 +01:00
|
|
|
// monitorFromWindow must be called on the main thread.
|
|
|
|
func monitorFromWindow(window *glfw.Window) *glfw.Monitor {
|
2021-04-21 15:50:00 +02:00
|
|
|
// GetMonitor is available only in fullscreen.
|
2020-08-23 20:27:38 +02:00
|
|
|
if m := window.GetMonitor(); m != nil {
|
2020-08-23 16:37:58 +02:00
|
|
|
return m
|
2018-10-05 16:59:30 +02:00
|
|
|
}
|
2020-08-23 16:37:58 +02:00
|
|
|
|
|
|
|
// Getting a monitor from a window position is not reliable in general (e.g., when a window is put across
|
2020-08-23 17:57:48 +02:00
|
|
|
// multiple monitors, or, before SetWindowPosition is called.).
|
2018-10-06 15:42:28 +02:00
|
|
|
// Get the monitor which the current window belongs to. This requires OS API.
|
2022-02-08 16:26:49 +01:00
|
|
|
if m := monitorFromWindowByOS(window); m != nil {
|
2020-08-23 20:27:38 +02:00
|
|
|
return m
|
|
|
|
}
|
|
|
|
|
|
|
|
// As the fallback, detect the monitor from the window.
|
2021-09-09 04:11:56 +02:00
|
|
|
if m := getMonitorFromPosition(window.GetPos()); m != nil {
|
2020-08-23 20:27:38 +02:00
|
|
|
return m.m
|
|
|
|
}
|
2022-02-08 16:26:49 +01:00
|
|
|
|
|
|
|
return nil
|
2018-10-05 16:59:30 +02:00
|
|
|
}
|
2019-04-07 11:28:50 +02:00
|
|
|
|
2019-11-30 16:07:41 +01:00
|
|
|
func (u *UserInterface) SetScreenTransparent(transparent bool) {
|
|
|
|
if !u.isRunning() {
|
|
|
|
u.setInitScreenTransparent(transparent)
|
|
|
|
return
|
|
|
|
}
|
2022-02-06 08:08:22 +01:00
|
|
|
panic("ui: SetScreenTransparent can't be called after the main loop starts")
|
2019-11-30 16:07:41 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
func (u *UserInterface) IsScreenTransparent() bool {
|
|
|
|
if !u.isRunning() {
|
|
|
|
return u.isInitScreenTransparent()
|
|
|
|
}
|
|
|
|
val := false
|
2022-01-02 19:30:29 +01:00
|
|
|
u.t.Call(func() {
|
2019-11-30 16:07:41 +01:00
|
|
|
val = u.window.GetAttrib(glfw.TransparentFramebuffer) == glfw.True
|
|
|
|
})
|
|
|
|
return val
|
|
|
|
}
|
|
|
|
|
2022-02-13 11:54:38 +01:00
|
|
|
func (u *UserInterface) ResetForTick() {
|
|
|
|
u.input.resetForTick()
|
2021-06-13 13:52:14 +02:00
|
|
|
|
|
|
|
u.m.Lock()
|
|
|
|
u.windowBeingClosed = false
|
|
|
|
u.m.Unlock()
|
2020-04-02 17:06:42 +02:00
|
|
|
}
|
|
|
|
|
2020-02-09 15:03:03 +01:00
|
|
|
func (u *UserInterface) SetInitFocused(focused bool) {
|
|
|
|
if u.isRunning() {
|
|
|
|
panic("ui: SetInitFocused must be called before the main loop")
|
|
|
|
}
|
|
|
|
u.setInitFocused(focused)
|
|
|
|
}
|
|
|
|
|
2022-02-06 10:30:31 +01:00
|
|
|
func (u *UserInterface) Input() *Input {
|
2019-04-07 11:55:56 +02:00
|
|
|
return &u.input
|
2019-04-07 11:28:50 +02:00
|
|
|
}
|
2019-12-24 16:05:56 +01:00
|
|
|
|
2022-02-06 12:02:03 +01:00
|
|
|
func (u *UserInterface) Window() *Window {
|
2019-12-24 16:05:56 +01:00
|
|
|
return &u.iwindow
|
|
|
|
}
|
2021-04-17 16:57:17 +02:00
|
|
|
|
2021-04-20 11:16:41 +02:00
|
|
|
// GLFW's functions to manipulate a window can invoke the SetSize callback (#1576, #1585, #1606).
|
|
|
|
// As the callback must not be called in the frame (between BeginFrame and EndFrame),
|
|
|
|
// disable the callback temporarily.
|
|
|
|
|
|
|
|
// maximizeWindow must be called from the main thread.
|
|
|
|
func (u *UserInterface) maximizeWindow() {
|
2021-09-12 16:38:38 +02:00
|
|
|
if u.isNativeFullscreen() {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-04-18 15:07:26 +02:00
|
|
|
if u.setSizeCallbackEnabled {
|
|
|
|
u.setSizeCallbackEnabled = false
|
|
|
|
defer func() {
|
|
|
|
u.setSizeCallbackEnabled = true
|
|
|
|
}()
|
2021-04-17 16:57:17 +02:00
|
|
|
}
|
|
|
|
u.window.Maximize()
|
|
|
|
|
2021-04-20 13:09:04 +02:00
|
|
|
if !u.isFullscreen() {
|
2021-04-21 15:25:10 +02:00
|
|
|
// On Linux/UNIX, maximizing might not finish even though Maximize returns. Just wait for its finish.
|
2021-04-21 15:50:00 +02:00
|
|
|
// Do not check this in the fullscreen since apparently the condition can never be true.
|
2021-04-21 15:25:10 +02:00
|
|
|
for u.window.GetAttrib(glfw.Maximized) != glfw.True {
|
|
|
|
glfw.PollEvents()
|
|
|
|
}
|
|
|
|
|
|
|
|
// Call setWindowSize explicitly in order to update the rendering since the callback is disabled now.
|
2021-04-21 15:50:00 +02:00
|
|
|
// Do not call setWindowSize in the fullscreen mode since setWindowSize requires the window size
|
|
|
|
// before the fullscreen, while window.GetSize() returns the desktop screen size in the fullscreen mode.
|
2021-04-20 13:09:04 +02:00
|
|
|
w, h := u.window.GetSize()
|
2021-10-10 08:38:13 +02:00
|
|
|
ww := int(u.dipFromGLFWPixel(float64(w), u.currentMonitor()))
|
|
|
|
wh := int(u.dipFromGLFWPixel(float64(h), u.currentMonitor()))
|
|
|
|
u.setWindowSizeInDIP(ww, wh, u.isFullscreen())
|
2021-04-20 13:09:04 +02:00
|
|
|
}
|
2021-04-17 16:57:17 +02:00
|
|
|
}
|
2021-04-17 17:10:37 +02:00
|
|
|
|
2021-04-20 11:16:41 +02:00
|
|
|
// iconifyWindow must be called from the main thread.
|
|
|
|
func (u *UserInterface) iconifyWindow() {
|
2021-09-12 16:38:38 +02:00
|
|
|
if u.isNativeFullscreen() {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-04-18 15:07:26 +02:00
|
|
|
if u.setSizeCallbackEnabled {
|
|
|
|
u.setSizeCallbackEnabled = false
|
|
|
|
defer func() {
|
|
|
|
u.setSizeCallbackEnabled = true
|
|
|
|
}()
|
2021-04-17 18:03:06 +02:00
|
|
|
}
|
|
|
|
u.window.Iconify()
|
|
|
|
|
2021-04-20 17:52:04 +02:00
|
|
|
// On Linux/UNIX, iconifying might not finish even though Iconify returns. Just wait for its finish.
|
|
|
|
for u.window.GetAttrib(glfw.Iconified) != glfw.True {
|
|
|
|
glfw.PollEvents()
|
|
|
|
}
|
|
|
|
|
2021-04-18 14:06:02 +02:00
|
|
|
// After iconifiying, the window is invisible and setWindowSize doesn't have to be called.
|
|
|
|
// Rather, the window size might be (0, 0) and it might be impossible to call setWindowSize (#1585).
|
2021-04-17 18:03:06 +02:00
|
|
|
}
|
|
|
|
|
2021-04-20 11:16:41 +02:00
|
|
|
// restoreWindow must be called from the main thread.
|
|
|
|
func (u *UserInterface) restoreWindow() {
|
2021-04-18 15:07:26 +02:00
|
|
|
if u.setSizeCallbackEnabled {
|
|
|
|
u.setSizeCallbackEnabled = false
|
|
|
|
defer func() {
|
|
|
|
u.setSizeCallbackEnabled = true
|
|
|
|
}()
|
2021-04-17 17:10:37 +02:00
|
|
|
}
|
2021-04-20 17:52:04 +02:00
|
|
|
|
2021-04-17 17:10:37 +02:00
|
|
|
u.window.Restore()
|
|
|
|
|
2021-04-20 17:52:04 +02:00
|
|
|
// On Linux/UNIX, restoring might not finish even though Restore returns (#1608). Just wait for its finish.
|
|
|
|
// On macOS, the restoring state might be the same as the maximized state. Skip this.
|
|
|
|
if runtime.GOOS != "darwin" {
|
|
|
|
for u.window.GetAttrib(glfw.Maximized) == glfw.True || u.window.GetAttrib(glfw.Iconified) == glfw.True {
|
|
|
|
glfw.PollEvents()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-18 15:07:26 +02:00
|
|
|
// Call setWindowSize explicitly in order to update the rendering since the callback is disabled now.
|
2021-04-21 15:50:00 +02:00
|
|
|
// Do not call setWindowSize in the fullscreen mode since setWindowSize requires the window size
|
|
|
|
// before the fullscreen, while window.GetSize() returns the desktop screen size in the fullscreen mode.
|
2021-04-20 13:09:04 +02:00
|
|
|
if !u.isFullscreen() {
|
|
|
|
w, h := u.window.GetSize()
|
2021-10-10 08:38:13 +02:00
|
|
|
ww := int(u.dipFromGLFWPixel(float64(w), u.currentMonitor()))
|
|
|
|
wh := int(u.dipFromGLFWPixel(float64(h), u.currentMonitor()))
|
|
|
|
u.setWindowSizeInDIP(ww, wh, u.isFullscreen())
|
2021-04-20 13:09:04 +02:00
|
|
|
}
|
2021-04-17 17:10:37 +02:00
|
|
|
}
|
2021-04-18 14:23:59 +02:00
|
|
|
|
2021-04-20 11:16:41 +02:00
|
|
|
// setWindowDecorated must be called from the main thread.
|
|
|
|
func (u *UserInterface) setWindowDecorated(decorated bool) {
|
2021-04-18 15:07:26 +02:00
|
|
|
if u.setSizeCallbackEnabled {
|
|
|
|
u.setSizeCallbackEnabled = false
|
|
|
|
defer func() {
|
|
|
|
u.setSizeCallbackEnabled = true
|
|
|
|
}()
|
2021-04-18 14:23:59 +02:00
|
|
|
}
|
|
|
|
v := glfw.False
|
|
|
|
if decorated {
|
|
|
|
v = glfw.True
|
|
|
|
}
|
|
|
|
u.window.SetAttrib(glfw.Decorated, v)
|
|
|
|
|
2021-04-20 11:16:41 +02:00
|
|
|
// The title can be lost when the decoration is gone. Recover this.
|
|
|
|
if decorated {
|
|
|
|
u.window.SetTitle(u.title)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// setWindowFloating must be called from the main thread.
|
|
|
|
func (u *UserInterface) setWindowFloating(floating bool) {
|
|
|
|
if u.setSizeCallbackEnabled {
|
|
|
|
u.setSizeCallbackEnabled = false
|
|
|
|
defer func() {
|
|
|
|
u.setSizeCallbackEnabled = true
|
|
|
|
}()
|
|
|
|
}
|
|
|
|
v := glfw.False
|
|
|
|
if floating {
|
|
|
|
v = glfw.True
|
|
|
|
}
|
|
|
|
u.window.SetAttrib(glfw.Floating, v)
|
|
|
|
}
|
|
|
|
|
2021-12-29 14:08:59 +01:00
|
|
|
// setWindowResizingMode must be called from the main thread.
|
|
|
|
func (u *UserInterface) setWindowResizingMode(mode WindowResizingMode) {
|
|
|
|
if u.windowResizingMode == mode {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-04-20 11:16:41 +02:00
|
|
|
if u.setSizeCallbackEnabled {
|
|
|
|
u.setSizeCallbackEnabled = false
|
|
|
|
defer func() {
|
|
|
|
u.setSizeCallbackEnabled = true
|
|
|
|
}()
|
|
|
|
}
|
|
|
|
|
2021-12-29 14:08:59 +01:00
|
|
|
u.windowResizingMode = mode
|
|
|
|
|
2021-04-20 11:16:41 +02:00
|
|
|
v := glfw.False
|
2021-12-29 14:08:59 +01:00
|
|
|
if mode == WindowResizingModeEnabled {
|
2021-04-20 11:16:41 +02:00
|
|
|
v = glfw.True
|
|
|
|
}
|
|
|
|
u.window.SetAttrib(glfw.Resizable, v)
|
2021-12-29 14:08:59 +01:00
|
|
|
u.setWindowResizingModeForOS(mode)
|
2021-04-20 11:16:41 +02:00
|
|
|
}
|
|
|
|
|
2021-10-10 08:50:12 +02:00
|
|
|
// setWindowPositionInDIP sets the window position.
|
2021-10-10 08:38:13 +02:00
|
|
|
//
|
|
|
|
// x and y are the position in device-independent pixels.
|
|
|
|
//
|
2021-10-10 08:50:12 +02:00
|
|
|
// setWindowPositionInDIP must be called from the main thread.
|
|
|
|
func (u *UserInterface) setWindowPositionInDIP(x, y int, monitor *glfw.Monitor) {
|
2021-04-20 11:16:41 +02:00
|
|
|
if u.setSizeCallbackEnabled {
|
|
|
|
u.setSizeCallbackEnabled = false
|
|
|
|
defer func() {
|
|
|
|
u.setSizeCallbackEnabled = true
|
|
|
|
}()
|
|
|
|
}
|
|
|
|
|
2021-10-09 09:49:47 +02:00
|
|
|
mx, my := monitor.GetPos()
|
2021-10-10 08:38:13 +02:00
|
|
|
xf := u.dipToGLFWPixel(float64(x), monitor)
|
|
|
|
yf := u.dipToGLFWPixel(float64(y), monitor)
|
2022-02-07 15:51:40 +01:00
|
|
|
if x, y := u.adjustWindowPosition(mx+int(xf), my+int(yf), monitor); u.isFullscreen() {
|
2021-09-17 19:21:24 +02:00
|
|
|
u.setOrigPos(x, y)
|
2021-04-20 11:16:41 +02:00
|
|
|
} else {
|
|
|
|
u.window.SetPos(x, y)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Call setWindowSize explicitly in order to update the rendering since the callback is disabled now.
|
2021-04-20 16:38:34 +02:00
|
|
|
//
|
|
|
|
// There are cases when setWindowSize should be called (#1606) and should not be called (#1609).
|
|
|
|
// For the former, macOS seems enough so far.
|
|
|
|
//
|
2021-04-21 15:50:00 +02:00
|
|
|
// Do not call setWindowSize in the fullscreen mode since setWindowSize requires the window size
|
|
|
|
// before the fullscreen, while window.GetSize() returns the desktop screen size in the fullscreen mode.
|
2021-04-20 16:38:34 +02:00
|
|
|
if !u.isFullscreen() && runtime.GOOS == "darwin" {
|
2021-04-20 13:09:04 +02:00
|
|
|
w, h := u.window.GetSize()
|
2022-02-08 12:20:36 +01:00
|
|
|
ww := int(u.dipFromGLFWPixel(float64(w), monitor))
|
|
|
|
wh := int(u.dipFromGLFWPixel(float64(h), monitor))
|
2021-10-10 08:38:13 +02:00
|
|
|
u.setWindowSizeInDIP(ww, wh, u.isFullscreen())
|
2021-04-20 13:09:04 +02:00
|
|
|
}
|
2021-04-20 11:16:41 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// setWindowTitle must be called from the main thread.
|
|
|
|
func (u *UserInterface) setWindowTitle(title string) {
|
|
|
|
if u.setSizeCallbackEnabled {
|
|
|
|
u.setSizeCallbackEnabled = false
|
|
|
|
defer func() {
|
|
|
|
u.setSizeCallbackEnabled = true
|
|
|
|
}()
|
|
|
|
}
|
|
|
|
|
|
|
|
u.window.SetTitle(title)
|
2021-04-18 14:23:59 +02:00
|
|
|
}
|
2021-09-17 19:21:24 +02:00
|
|
|
|
|
|
|
func (u *UserInterface) origPos() (int, int) {
|
|
|
|
// On macOS, the window can be fullscreened without calling an Ebiten function.
|
|
|
|
// Then, an original position might not be available by u.window.GetPos().
|
|
|
|
// Do not rely on the window position.
|
|
|
|
if u.isNativeFullscreenAvailable() {
|
|
|
|
return invalidPos, invalidPos
|
|
|
|
}
|
|
|
|
return u.origPosX, u.origPosY
|
|
|
|
}
|
|
|
|
|
|
|
|
func (u *UserInterface) setOrigPos(x, y int) {
|
|
|
|
// TODO: The original position should be updated at a 'PosCallback'.
|
|
|
|
|
|
|
|
// On macOS, the window can be fullscreened without calling an Ebiten function.
|
|
|
|
// Then, an original position might not be available by u.window.GetPos().
|
|
|
|
// Do not rely on the window position.
|
|
|
|
if u.isNativeFullscreenAvailable() {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
u.origPosX = x
|
|
|
|
u.origPosY = y
|
|
|
|
}
|