def apply(self, restartApproved):
if self._settings:
LOG_DEBUG('Applying video settings: ', self._settings)
cWindowSize = g_monitorSettings.currentWindowSize
windowSizeWidth, windowSizeHeight = self.windowSize
cIsFullScreen = g_monitorSettings.isFullscreen
isFullscreen = self.fullscreen
cVideoMode = g_monitorSettings.currentVideoMode
videoMode = self.videoMode
monitor = self.monitor
cMonitor = g_monitorSettings.activeMonitor
windowSizeChanged = cWindowSize is not None and windowSizeWidth is not None and windowSizeHeight is not None and (
windowSizeWidth != cWindowSize.width
or windowSizeHeight != cWindowSize.height)
monitorChanged = monitor != cMonitor
videModeChanged = cVideoMode is not None and videoMode is not None and videoMode.index != cVideoMode.index
fullScreenChanged = isFullscreen != cIsFullScreen
deviseRecreated = False
if monitorChanged:
g_monitorSettings.changeMonitor(monitor)
deviseRecreated = isFullscreen or cIsFullScreen
if windowSizeChanged and not isFullscreen:
deviseRecreated = True
g_monitorSettings.changeWindowSize(windowSizeWidth,
windowSizeHeight)
elif (not monitorChanged or
restartApproved) and (videModeChanged or fullScreenChanged):
deviseRecreated = True
BigWorld.changeVideoMode(videoMode.index, not isFullscreen)
self.clear()
self._core.isDeviseRecreated = deviseRecreated
if deviseRecreated:
def wrapper(monitorChanged, windowSizeChanged, cMonitor,
cWindowSize, cVideoMode, cIsFullScreen):
def revert():
if monitorChanged:
g_monitorSettings.changeMonitor(cMonitor)
if windowSizeChanged and not cIsFullScreen:
g_monitorSettings.changeWindowSize(
cWindowSize.width, cWindowSize.height)
elif not monitorChanged and (videModeChanged
or fullScreenChanged):
BigWorld.changeVideoMode(cVideoMode.index,
not cIsFullScreen)
return revert
@async
def confirmator(callback=None):
BigWorld.callback(
0.0, lambda: DialogsInterface.showI18nConfirmDialog(
'graphicsChangeConfirmation', callback,
TimerConfirmDialogMeta(
'graphicsChangeConfirmation', timer=15)))
return (confirmator,
wrapper(monitorChanged, windowSizeChanged, cMonitor,
cWindowSize, cVideoMode, cIsFullScreen))
return super(VideoSettingsStorage, self).apply(restartApproved)
def revert():
if monitorChanged:
g_monitorSettings.changeMonitor(cMonitor)
if windowSizeChanged and not cIsFullScreen:
g_monitorSettings.changeWindowSize(cWindowSize.width, cWindowSize.height)
elif not monitorChanged and (videModeChanged or fullScreenChanged):
BigWorld.changeVideoMode(cVideoMode.index, not cIsFullScreen)
def revert():
if monitorChanged:
g_monitorSettings.changeMonitor(cMonitor)
if windowSizeChanged and not cIsFullScreen:
g_monitorSettings.changeWindowSize(cWindowSize.width, cWindowSize.height)
elif not monitorChanged and (videModeChanged or fullScreenChanged):
BigWorld.changeVideoMode(cVideoMode.index, not cIsFullScreen)
def apply(self):
cvm = g_monitorSettings.currentVideoMode
isFullscreen = self.fullscreen
videoMode = self.videoMode
if not g_monitorSettings.isMonitorChanged and cvm is not None and (videoMode.index != cvm.index or isFullscreen != g_monitorSettings.isFullscreen):
BigWorld.changeVideoMode(videoMode.index, not isFullscreen)
if 'monitor' in self._settings:
g_monitorSettings.changeMonitor(self.monitor)
return
def revert():
if monitorChanged:
g_monitorSettings.changeMonitor(cMonitor)
if windowSizeChanged and cWindowMode == BigWorld.WindowModeWindowed:
g_monitorSettings.changeWindowSize(
cWindowSize.width, cWindowSize.height)
elif not monitorChanged and (videModeChanged
or windowModeChanged):
BigWorld.changeVideoMode(cVideoMode.index,
cWindowMode)
def apply(self):
cvm = g_monitorSettings.currentVideoMode
isFullscreen = self.fullscreen
videoMode = self.videoMode
if not g_monitorSettings.isMonitorChanged and cvm is not None and (
videoMode.index != cvm.index
or isFullscreen != g_monitorSettings.isFullscreen):
BigWorld.changeVideoMode(videoMode.index, not isFullscreen)
if 'monitor' in self._settings:
g_monitorSettings.changeMonitor(self.monitor)
return
def apply(self, restartApproved):
if self._settings:
LOG_DEBUG('Applying video settings: ', self._settings)
cWindowSize = g_monitorSettings.currentWindowSize
windowSizeWidth, windowSizeHeight = self.windowSize
cIsFullScreen = g_monitorSettings.isFullscreen
isFullscreen = self.fullscreen
cVideoMode = g_monitorSettings.currentVideoMode
videoMode = self.videoMode
monitor = self.monitor
cMonitor = g_monitorSettings.activeMonitor
windowSizeChanged = cWindowSize is not None and windowSizeWidth is not None and windowSizeHeight is not None and (windowSizeWidth != cWindowSize.width or windowSizeHeight != cWindowSize.height)
monitorChanged = monitor != cMonitor
videModeChanged = cVideoMode is not None and videoMode is not None and videoMode.index != cVideoMode.index
fullScreenChanged = isFullscreen != cIsFullScreen
deviseRecreated = False
if monitorChanged:
g_monitorSettings.changeMonitor(monitor)
deviseRecreated = isFullscreen or cIsFullScreen
if windowSizeChanged and not isFullscreen:
deviseRecreated = True
g_monitorSettings.changeWindowSize(windowSizeWidth, windowSizeHeight)
elif (not monitorChanged or restartApproved) and (videModeChanged or fullScreenChanged):
deviseRecreated = True
BigWorld.changeVideoMode(videoMode.index, not isFullscreen)
self.clear()
self._core.isDeviseRecreated = deviseRecreated
if deviseRecreated:
def wrapper(monitorChanged, windowSizeChanged, cMonitor, cWindowSize, cVideoMode, cIsFullScreen):
def revert():
if monitorChanged:
g_monitorSettings.changeMonitor(cMonitor)
if windowSizeChanged and not cIsFullScreen:
g_monitorSettings.changeWindowSize(cWindowSize.width, cWindowSize.height)
elif not monitorChanged and (videModeChanged or fullScreenChanged):
BigWorld.changeVideoMode(cVideoMode.index, not cIsFullScreen)
return revert
if isPlayerAccount():
@async
def confirmator(callback = None):
BigWorld.callback(0.0, lambda : DialogsInterface.showI18nConfirmDialog('graphicsChangeConfirmation', callback, TimerConfirmDialogMeta('graphicsChangeConfirmation', timer=15)))
else:
confirmator = 'graphicsChangeConfirmation'
return (confirmator, wrapper(monitorChanged, windowSizeChanged, cMonitor, cWindowSize, cVideoMode, cIsFullScreen))
return super(VideoSettingsStorage, self).apply(restartApproved)
def revert():
if monitorChanged:
g_monitorSettings.changeMonitor(cMonitor)
if borderlessSizeChanged and cWindowMode == BigWorld.WindowModeBorderless:
g_monitorSettings.changeBorderlessSize(
cBorderlessSize.width, cBorderlessSize.height)
elif windowSizeChanged and cWindowMode == BigWorld.WindowModeWindowed:
g_monitorSettings.changeWindowSize(
cWindowSize.width, cWindowSize.height)
elif not monitorChanged and (videModeChanged
or windowModeChanged):
BigWorld.changeVideoMode(cVideoMode.index,
cWindowMode)
BigWorld.changeFullScreenAspectRatio(cAspectRation)
def applyChanges(self, isFullScreen, isVideoVSync, isTripleBuffered,
sizeIndex, aspectRatioIndex, multisamplingIndex,
customAAIndex, gamma, monitorIndex):
if self.__curentMonitorIndex != monitorIndex:
self.__monitorChanged = True
self.__curentMonitorIndex = monitorIndex
BigWorld.wg_setActiveMonitorIndex(monitorIndex)
if self.isVideoVSync != isVideoVSync:
BigWorld.setVideoVSync(isVideoVSync)
if self.isTripleBuffered != isTripleBuffered:
BigWorld.setTripleBuffering(isTripleBuffered)
if self.gamma != gamma:
gamma = max(gamma, 0.5)
gamma = min(gamma, 2.0)
BigWorld.setGammaCorrection(gamma)
aspectRatio = self.getAspectRatioByIndex(aspectRatioIndex)
if aspectRatio is not None and aspectRatio != self.__aspectRatio:
BigWorld.changeFullScreenAspectRatio(aspectRatio)
multisamplingType = self.getMultisamplingTypeByIndex(
multisamplingIndex)
if self.__multisamplingType != multisamplingType:
BigWorld.setMultisamplingType(multisamplingType)
customAAMode = self.getCustomAAModeByIndex(customAAIndex)
if self.__customAAMode != customAAMode:
BigWorld.setCustomAAMode(customAAMode)
if isFullScreen:
videoMode = self.getVideoModeByIndex(sizeIndex)
if not self.__monitorChanged and (videoMode != self.__videoMode
or self.isVideoWindowed):
BigWorld.changeVideoMode(videoMode, False)
windowSize = self.getWindowSizeByIndex(sizeIndex)
self.__lastIsWindowed = False
self.__lastFullscreenSize = (windowSize[0], windowSize[1])
else:
if not self.__monitorChanged and not self.isVideoWindowed:
BigWorld.changeVideoMode(self.getVideoModeByIndex(sizeIndex),
True)
windowSize = self.getWindowSizeByIndex(sizeIndex)
oldResolution = BigWorld.wg_getCurrentResolution(True)
if windowSize is not None and (oldResolution[0] != windowSize[0] or
oldResolution[1] != windowSize[1]):
BigWorld.resizeWindow(windowSize[0], windowSize[1])
self.__lastIsWindowed = True
self.__lastWindowedSize = (windowSize[0], windowSize[1])
return
def applyChanges(self, isFullScreen, isVideoVSync, isTripleBuffered, sizeIndex, aspectRatioIndex, multisamplingIndex, customAAIndex, gamma, monitorIndex):
if self.__curentMonitorIndex != monitorIndex:
self.__monitorChanged = True
self.__curentMonitorIndex = monitorIndex
BigWorld.wg_setActiveMonitorIndex(monitorIndex)
if self.isVideoVSync != isVideoVSync:
BigWorld.setVideoVSync(isVideoVSync)
if self.isTripleBuffered != isTripleBuffered:
BigWorld.setTripleBuffering(isTripleBuffered)
if self.gamma != gamma:
gamma = max(gamma, 0.5)
gamma = min(gamma, 2.0)
BigWorld.setGammaCorrection(gamma)
aspectRatio = self.getAspectRatioByIndex(aspectRatioIndex)
if aspectRatio is not None and aspectRatio != self.__aspectRatio:
BigWorld.changeFullScreenAspectRatio(aspectRatio)
multisamplingType = self.getMultisamplingTypeByIndex(multisamplingIndex)
if self.__multisamplingType != multisamplingType:
BigWorld.setMultisamplingType(multisamplingType)
customAAMode = self.getCustomAAModeByIndex(customAAIndex)
if self.__customAAMode != customAAMode:
BigWorld.setCustomAAMode(customAAMode)
if isFullScreen:
videoMode = self.getVideoModeByIndex(sizeIndex)
if not self.__monitorChanged and (videoMode != self.__videoMode or self.isVideoWindowed):
BigWorld.changeVideoMode(videoMode, False)
windowSize = self.getWindowSizeByIndex(sizeIndex)
self.__lastIsWindowed = False
self.__lastFullscreenSize = (windowSize[0], windowSize[1])
else:
if not self.__monitorChanged and not self.isVideoWindowed:
BigWorld.changeVideoMode(self.getVideoModeByIndex(sizeIndex), True)
windowSize = self.getWindowSizeByIndex(sizeIndex)
oldResolution = BigWorld.wg_getCurrentResolution(True)
if windowSize is not None and (oldResolution[0] != windowSize[0] or oldResolution[1] != windowSize[1]):
BigWorld.resizeWindow(windowSize[0], windowSize[1])
self.__lastIsWindowed = True
self.__lastWindowedSize = (windowSize[0], windowSize[1])
return
def setFullscreen(self, isFullscreen):
vm = self.currentVideoMode
if vm is not None and isFullscreen != self.isFullscreen:
BigWorld.changeVideoMode(vm.index, not isFullscreen)
return
def changeBorderlessSize(self, width, height):
curBorderlessSize = self.currentBorderlessSize
if curBorderlessSize.width != width or curBorderlessSize.height != height:
BigWorld.setBorderlessFixedSize(width, height)
BigWorld.changeVideoMode(-1, BigWorld.WindowModeBorderless)
def setBorderless(self):
if self.windowMode != BigWorld.WindowModeBorderless:
BigWorld.changeVideoMode(-1, BigWorld.WindowModeBorderless)
def setWindowed(self):
if self.windowMode != BigWorld.WindowModeWindowed:
BigWorld.changeVideoMode(-1, BigWorld.WindowModeWindowed)
def apply(self, restartApproved):
if self._settings:
LOG_DEBUG('Applying video settings: ', self._settings)
cWindowSize = g_monitorSettings.currentWindowSize
windowSizeWidth, windowSizeHeight = self.windowSize
cBorderlessSize = g_monitorSettings.currentBorderlessSize
borderlessSizeWidth, borderlessSizeHeight = self.borderlessSize
cWindowMode = g_monitorSettings.windowMode
windowMode = self.windowMode
cMonitor = g_monitorSettings.activeMonitor
monitor = self.monitor
exclusiveFullscreenMonitorIndex = g_monitorSettings.noRestartExclusiveFullscreenMonitorIndex
restartNeeded = windowMode == BigWorld.WindowModeExclusiveFullscreen and monitor != exclusiveFullscreenMonitorIndex
cVideoMode = g_monitorSettings.currentVideoMode
cAspectRation = float(cVideoMode.width) / cVideoMode.height
videoMode = self.videoModeForAdapterOutputIndex(monitor)
aspectRation = float(videoMode.width) / videoMode.height
windowSizeChanged = cWindowSize is not None and windowSizeWidth is not None and windowSizeHeight is not None and (
windowSizeWidth != cWindowSize.width
or windowSizeHeight != cWindowSize.height)
borderlessSizeChanged = cBorderlessSize is not None and borderlessSizeWidth is not None and borderlessSizeHeight is not None and (
borderlessSizeWidth != cBorderlessSize.width
or borderlessSizeHeight != cBorderlessSize.height)
monitorChanged = monitor != cMonitor
videModeChanged = cVideoMode is not None and videoMode is not None and videoMode.index != cVideoMode.index
windowModeChanged = windowMode != cWindowMode
deviseRecreated = False
if monitorChanged:
g_monitorSettings.changeMonitor(monitor)
deviseRecreated = windowMode == BigWorld.WindowModeExclusiveFullscreen or cWindowMode == BigWorld.WindowModeExclusiveFullscreen
if restartNeeded:
deviseRecreated = False
LOG_DEBUG(
"VideoSettingsStorage apply is expecting a restart so it didn't invoke changeVideoMode."
)
elif windowSizeChanged and windowMode == BigWorld.WindowModeWindowed:
deviseRecreated = True
g_monitorSettings.changeWindowSize(windowSizeWidth,
windowSizeHeight)
elif borderlessSizeChanged and windowMode == BigWorld.WindowModeBorderless:
deviseRecreated = True
g_monitorSettings.changeBorderlessSize(borderlessSizeWidth,
borderlessSizeHeight)
elif (not monitorChanged or
restartApproved) and (videModeChanged or windowModeChanged):
deviseRecreated = True
BigWorld.changeVideoMode(videoMode.index, windowMode)
BigWorld.changeFullScreenAspectRatio(aspectRation)
self.clear()
self._core.isDeviseRecreated = deviseRecreated
if deviseRecreated:
def wrapper(monitorChanged, windowSizeChanged,
borderlessSizeChanged, cMonitor, cWindowSize,
cVideoMode, cWindowMode, cAspectRation):
def revert():
if monitorChanged:
g_monitorSettings.changeMonitor(cMonitor)
if borderlessSizeChanged and cWindowMode == BigWorld.WindowModeBorderless:
g_monitorSettings.changeBorderlessSize(
cBorderlessSize.width, cBorderlessSize.height)
elif windowSizeChanged and cWindowMode == BigWorld.WindowModeWindowed:
g_monitorSettings.changeWindowSize(
cWindowSize.width, cWindowSize.height)
elif not monitorChanged and (videModeChanged
or windowModeChanged):
BigWorld.changeVideoMode(cVideoMode.index,
cWindowMode)
BigWorld.changeFullScreenAspectRatio(cAspectRation)
return revert
@async
def confirmator(callback=None):
BigWorld.callback(
0.0, lambda: DialogsInterface.showI18nConfirmDialog(
'graphicsChangeConfirmation', callback,
TimerConfirmDialogMeta(
'graphicsChangeConfirmation', timer=15)))
return (confirmator,
wrapper(monitorChanged, windowSizeChanged,
borderlessSizeChanged, cMonitor, cWindowSize,
cVideoMode, cWindowMode, cAspectRation))
return super(VideoSettingsStorage, self).apply(restartApproved)
def changeVideoMode(self, videoMode):
cvm = self.currentVideoMode
if not self.isMonitorChanged and cvm is not None and (videoMode.index != cvm or not self.isFullscreen):
BigWorld.changeVideoMode(videoMode.index, False)
return
def setWindowed(self):
vm = self.currentVideoMode
if vm is not None and self.windowMode != BigWorld.WindowModeWindowed:
BigWorld.changeVideoMode(vm.index, BigWorld.WindowModeWindowed)
return
def setFullscreen(self, isFullscreen):
vm = self.currentVideoMode
if vm is not None and isFullscreen != self.isFullscreen:
BigWorld.changeVideoMode(vm.index, not isFullscreen)
return
def changeVideoMode(self, videoMode):
cvm = self.currentVideoMode
if not self.isMonitorChanged and cvm is not None and (
videoMode.index != cvm or not self.isFullscreen):
BigWorld.changeVideoMode(videoMode.index, False)
return
