def _toggle_fullscreen(self):
if glfw.get_window_monitor(self._window): # fullscreen to window
glfw.set_window_monitor(self._window, None, *self._window_info, 0)
else: # window to fullscreen
info = [0] * 4
info[0], info[1] = glfw.get_window_pos(self._window)
info[2], info[3] = glfw.get_window_size(self._window)
self._window_info = info
monitor = glfw.get_primary_monitor()
size = glfw.get_video_mode(monitor)[0]
glfw.set_window_monitor(self._window, monitor, 0, 0, *size, 0)
def toggle_fullscreen(self):
if self.fullscreen:
glfw.set_window_monitor(self.window, None, *self.saved_size,
util.get_opts().fps)
else:
self.saved_size = self.x, self.y, self.win_width, self.win_height
monitor = glfw.get_primary_monitor()
mode = glfw.get_video_mode(monitor)
glfw.set_window_monitor(self.window, monitor, 0, 0,
mode.size.width, mode.size.height,
mode.refresh_rate)
self.fullscreen = not self.fullscreen
def toggle_fullscreen(self):
if self.fullscreen:
glfw.set_window_monitor(self.window, None, *self.saved_size,
util.get_opts().fps)
else:
self.saved_size = self.x, self.y, self.win_width, self.win_height
monitor = glfw.get_primary_monitor()
mode = glfw.get_video_mode(monitor)
glfw.set_window_monitor(self.window, monitor, 0, 0,
mode.size.width, mode.size.height,
mode.refresh_rate)
self.fullscreen = not self.fullscreen
def open_output_window(self):
self._pause_event_loop()
# Select monitor
self._select_monitor()
# Open window
if self.monitor:
# Fullscreen
self._select_video_mode()
x, y = glfw.get_monitor_pos(self.monitor)
logger.info("Output selected : {} on {} at {},{}".format(
str(self.video_mode), glfw.get_monitor_name(self.monitor), x,
y))
w, h = self.video_mode[0]
self.pano_renderer.setViewport(w, h)
self.pano_renderer.setRefreshRate(
self._convert_rate(30), self._convert_rate(self.video_mode[2]))
if self.output_window:
glfw.set_window_monitor(self.output_window, self.monitor, x, y,
w, h, self.video_mode[2])
glfw.show_window(self.output_window)
self.pano_renderer.enableOutput(True)
else:
self._open_output_window(w, h, self.monitor, self.video_mode)
else:
# No monitor available or windowed
w = self.width / 4
h = self.height / 4
self.pano_renderer.setViewport(w, h)
monitor = glfw.get_primary_monitor()
if monitor:
rate = glfw.get_video_mode(monitor)[2]
self.pano_renderer.setRefreshRate(self._convert_rate(30),
self._convert_rate(rate))
if self.output_window:
self.pano_renderer.enableOutput(True)
glfw.show_window(self.output_window)
else:
self._open_output_window(w, h)
if not SETTINGS.display in ["window", "windowed"]:
# No monitor available
glfw.hide_window(self.output_window)
self._unpause_event_loop()
def 定位(window, p):
x = p[3] - p[2]
y = p[1] - p[0]
y1, x1 = 图.shape[:2]
if x1 / y1 < x / y:
xx = int(y / y1 * x1)
glViewport((x - xx) // 2, 0, xx, y)
else:
yy = int(x / x1 * y1)
glViewport(0, (y - yy) // 2, x, yy)
glfw.set_window_monitor(window,
None,
xpos=p[2],
ypos=p[0],
width=p[3] - p[2],
height=p[1] - p[0],
refresh_rate=glfw.DONT_CARE)
def _set_fullscreen(self, value: bool) -> None:
monitor = glfw.get_primary_monitor()
mode = glfw.get_video_mode(monitor)
refresh_rate = mode.refresh_rate if self.vsync else glfw.DONT_CARE
self.resizable = not value
glfw.window_hint(glfw.RESIZABLE, self.resizable)
if value:
# enable fullscreen
self._non_fullscreen_size = self.width, self.height
self._non_fullscreen_position = self.position
glfw.set_window_monitor(
self._window,
monitor,
0,
0,
mode.size.width,
mode.size.height,
refresh_rate,
)
glfw.window_hint(glfw.RED_BITS, mode.bits.red)
glfw.window_hint(glfw.GREEN_BITS, mode.bits.green)
glfw.window_hint(glfw.BLUE_BITS, mode.bits.blue)
glfw.window_hint(glfw.REFRESH_RATE, mode.refresh_rate)
else:
# disable fullscreen
glfw.set_window_monitor(
self._window,
None,
*self._non_fullscreen_position,
*self._non_fullscreen_size,
refresh_rate
)
if self.vsync:
glfw.swap_interval(1)
else:
glfw.swap_interval(0)
def enable_full_screen(window):
display = glfw.get_primary_monitor()
videomode = glfw.get_video_mode(display)
glfw.set_window_monitor(window, display, 0, 0, videomode[0][0],
videomode[0][1], videomode[2])
def open(
self,
gui_monitor: GUIMonitor,
title: str,
is_fullscreen: bool = False,
size: T.Tuple[int, int] = None,
position: T.Tuple[int, int] = None,
):
if self.is_open:
# TODO: Warn that the window is already open
return
if not gui_monitor.is_available:
raise ValueError(f"Window requires an available monitor.")
has_fixed_size = ((size is not None) and (len(size) == 2)
and (size[0] > 0) and (size[1] > 0))
if is_fullscreen and has_fixed_size:
raise ValueError(
f"Fullscreen is mutually exclusive to having a fixed size.")
if position is None:
if platform.system() == "Windows":
position = (8, 90)
else:
position = (0, 0)
if is_fullscreen:
size = gui_monitor.size
# NOTE: Always creating windowed window here, even if in fullscreen mode. On
# windows you might experience a black screen for up to 1 sec when creating
# a blank window directly in fullscreen mode. By creating it windowed and
# then switching to fullscreen it will stay white the entire time.
self.__gl_handle = glfw.create_window(*size, title, None,
glfw.get_current_context())
if not is_fullscreen:
glfw.set_window_pos(self.__gl_handle, *position)
# Register callbacks
glfw.set_framebuffer_size_callback(self.__gl_handle, self.on_resize)
glfw.set_key_callback(self.__gl_handle, self.on_key)
glfw.set_mouse_button_callback(self.__gl_handle, self.on_mouse_button)
self.on_resize(self.__gl_handle,
*glfw.get_framebuffer_size(self.__gl_handle))
# gl_state settings
with self._switch_to_current_context():
gl_utils.basic_gl_setup()
glfw.swap_interval(0)
if is_fullscreen:
# Switch to full screen here. See NOTE above at glfw.create_window().
glfw.set_window_monitor(
self.__gl_handle,
gui_monitor.unsafe_handle,
0,
0,
*gui_monitor.size,
gui_monitor.refresh_rate,
)
def setFullScr(self, value):
"""Sets the window to/from full-screen mode.
Parameters
----------
value : bool or int
If `True`, resize the window to be fullscreen.
"""
# convert value to correct type
value = bool(value)
# get monitor handle for the window
monitor = glfw.get_window_monitor(self.winHandle)
# get the video mode for the monitor
# get monitors, with GLFW the primary display is ALWAYS at index 0
allScrs = glfw.get_monitors()
if len(allScrs) < int(self.win.screen) + 1:
logging.warn("Requested an unavailable screen number - "
"using first available.")
self.win.screen = 0
thisScreen = allScrs[self.win.screen]
if self.win.autoLog:
logging.info('configured GLFW screen %i' % self.win.screen)
# get monitor information
nativeVidmode = glfw.get_video_mode(thisScreen)
refreshRateHz = nativeVidmode.refresh_rate
scrWidth, scrHeight = nativeVidmode.size
winWidth, winHeight = nativeVidmode.size if value else self.win.windowedSize
# set the monitor
# glfw.window_hint(glfw.DECORATED, glfw.FALSE)
glfw.set_window_monitor(
self.winHandle,
monitor if value else None, # if `None` windowed, else fullscreen
0, 0, # position keep zero and set later
nativeVidmode.size[0] if value else self.win.windowedSize[0],
nativeVidmode.size[1] if value else self.win.windowedSize[1],
refreshRateHz)
if not value: # extra stuff for non-fullscreen
# if no window position is specified, centre it on-screen
if self.win.pos is None:
self.win.pos = [
(scrWidth - winWidth) / 2.0,
(scrHeight - winHeight) / 2.0]
# get the virtual position of the monitor, apply offset to the
# window position
px, py = glfw.get_monitor_pos(thisScreen)
glfw.set_window_pos(
self.winHandle,
int(self.win.pos[0] + px),
int(self.win.pos[1] + py))
# get the reported client size
self.win.clientSize[:] = glfw.get_window_size(self.winHandle)
self.frameBufferSize[:] = glfw.get_framebuffer_size(self.winHandle)
self.win.viewport = (
0, 0,
self._frameBufferSize[0],
self._frameBufferSize[1])
self.win.scissor = (
0, 0,
self._frameBufferSize[0],
self._frameBufferSize[1])
self.win.resetEyeTransform()
