void changeFullscreenMode() override {
if(fullscreenMode() == FullScreenMode::FULLSCREEN_EXCLUSIVE) {
nonfs_width_ = width();
nonfs_height_ = height();
if(SDL_SetWindowFullscreen(window_.get(), SDL_WINDOW_FULLSCREEN) != 0) {
LOG_WARN("Unable to set fullscreen mode at " << width() << " x " << height());
return;
}
} else if(fullscreenMode() == FullScreenMode::FULLSCREEN_WINDOWED) {
nonfs_width_ = width();
nonfs_height_ = height();
if(SDL_SetWindowFullscreen(window_.get(), SDL_WINDOW_FULLSCREEN_DESKTOP) != 0) {
LOG_WARN("Unable to set windowed fullscreen mode at " << width() << " x " << height());
return;
}
SDL_SetWindowSize(window_.get(), SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED);
SDL_SetWindowPosition(window_.get(), 0, 0);
} else {
if(SDL_SetWindowFullscreen(window_.get(), 0) != 0) {
LOG_WARN("Unable to set windowed mode at " << width() << " x " << height());
return;
}
SDL_SetWindowSize(window_.get(), nonfs_width_, nonfs_height_);
SDL_SetWindowPosition(window_.get(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
}
int w, h;
SDL_GetWindowSize(window_.get(), &w, &h);
// update viewport
setViewPort(0, 0, w, h);
// update width_ and height_ and notify observers
updateDimensions(w, h);
}
/*
* Shuffles the window around in a circle
* PARAMS:
* iters: number of times to move in a full circle
* offset: pixel distance moved at each step
* delay: time between steps (not full circles)
*/
void CycleAround(int iters, int offset, int delay) {
int x, y;
SDL_GetWindowPosition(window, &x, &y);
int cnt;
for(cnt=0; cnt < iters; cnt++) {
SDL_SetWindowPosition(window, x+offset, y); SDL_Delay(delay);
SDL_SetWindowPosition(window, x+offset, y+offset); SDL_Delay(delay);
SDL_SetWindowPosition(window, x, y+offset); SDL_Delay(delay);
SDL_SetWindowPosition(window, x, y); SDL_Delay(delay);
}
EndDemo();
}
int
X11_ResizeWindowShape(SDL_Window* window) {
SDL_ShapeData* data = window->shaper->driverdata;
SDL_assert(data != NULL);
unsigned int bitmapsize = window->w / 8;
if(window->w % 8 > 0)
bitmapsize += 1;
bitmapsize *= window->h;
if(data->bitmapsize != bitmapsize || data->bitmap == NULL) {
data->bitmapsize = bitmapsize;
if(data->bitmap != NULL)
free(data->bitmap);
data->bitmap = malloc(data->bitmapsize);
if(data->bitmap == NULL) {
SDL_SetError("Could not allocate memory for shaped-window bitmap.");
return -1;
}
}
memset(data->bitmap,0,data->bitmapsize);
window->shaper->userx = window->x;
window->shaper->usery = window->y;
SDL_SetWindowPosition(window,-1000,-1000);
return 0;
}
void Window_UpdateVideo(void)
{
if (Video.msaa_samples != cv_video_msaasamples.iValue)
{
// TODO: Destroy window etc.
Video.msaa_samples = cv_video_msaasamples.iValue;
}
SDL_SetWindowSize(sMainWindow, Video.iWidth, Video.iHeight);
if (Video.vertical_sync != cv_video_verticlesync.bValue)
{
SDL_GL_SetSwapInterval(cv_video_verticlesync.iValue);
Video.vertical_sync = cv_video_verticlesync.bValue;
}
if (Video.fullscreen != cv_video_fullscreen.bValue)
{
if (SDL_SetWindowFullscreen(sMainWindow, (SDL_bool)cv_video_fullscreen.bValue) == -1)
{
Con_Warning("Failed to set window mode!\n%s", SDL_GetError());
// Reset the variable to the current value.
Cvar_SetValue(cv_video_fullscreen.name, Video.fullscreen);
}
else
Video.fullscreen = cv_video_fullscreen.bValue;
}
if (!cv_video_fullscreen.value)
// Center the window, to ensure it's not off screen.
SDL_SetWindowPosition(sMainWindow, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
}
void Graphics::SetWindowPosition(const IntVector2& position)
{
if (window_)
SDL_SetWindowPosition(window_, position.x_, position.y_);
else
position_ = position; // Sets as initial position for OpenWindow()
}
void KGLWindow::setPosition(const KVector2I32 &Pos){
if (_kwindow) {
DSDL_CALL(SDL_SetWindowPosition(_kwindow, Pos.x, Pos.y));
_kwinstate.xpos = Pos.x;
_kwinstate.ypos = Pos.y;
}
}
void video_set_position( const struct point *position )
{
video_options.position = *position;
if ( video_window != NULL ) {
SDL_SetWindowPosition( video_window, position->x, position->y );
}
}
void SDL2WindowBackend::setPosition(int32_t x, int32_t y)
{
if(isOpen())
{
SDL_SetWindowPosition(mWindow, x, y);
}
}
void VR::orient_window(Game &game) const
{
SDL_SetWindowSize(game.window(), m_hmd->Resolution.w, m_hmd->Resolution.h);
SDL_SetWindowPosition(game.window(),
m_hmd->WindowsPos.x, m_hmd->WindowsPos.y);
SDL_SetWindowFullscreen(game.window(), SDL_WINDOW_FULLSCREEN_DESKTOP);
}
/** Native windows should implement MoveWindowTo by relocating the platform-specific window to (X,Y). */
void FLinuxWindow::MoveWindowTo( int32 X, int32 Y )
{
// we are passed coordinates of a client area, so account for decorations
checkf(bValidNativePropertiesCache, TEXT("Attempted to use border sizes too early, native properties aren't yet cached. Review the flow"));
SDL_SetWindowPosition( HWnd, X - LeftBorderWidth, Y - TopBorderHeight );
}
bool GraphicsWindowSDL2::setWindowRectangleImplementation(int x, int y, int width, int height)
{
if(!mWindow) return false;
SDL_SetWindowPosition(mWindow, x, y);
SDL_SetWindowSize(mWindow, width, height);
return true;
}
void Window::setPosition( int x, int y ) noexcept
{
WindowInfo winfo;
getInfo( winfo );
if ( !winfo.wflags.fullscreen )
SDL_SetWindowPosition( m_wimpl->window, x, y );
}
void SDLManager::setWindowPos(int x, int y){
if(x != -1){
_windowSettings.windowPosX = x;
}
if(y != -1){
_windowSettings.windowPosY = y;
}
SDL_SetWindowPosition(_window,_windowSettings.windowPosX,_windowSettings.windowPosY);
}
bool gutCenterWindow(void) {
chkwin;
SDL_SetWindowPosition(
gut.core->window.handle,
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED
);
return true;
}
void UIInterface::setWindowPosition(int x, int y)
{
SDL_SetWindowPosition(this->m_Win, (x == NIDIUM_WINDOWPOS_UNDEFINED_MASK)
? SDL_WINDOWPOS_UNDEFINED_MASK
: x,
(y == NIDIUM_WINDOWPOS_UNDEFINED_MASK)
? SDL_WINDOWPOS_UNDEFINED_MASK
: y);
}
void BaseManager::setWindowCoord(const MyGUI::IntCoord& _value)
{
if (_value.empty())
return;
MyGUI::IntCoord coord = _value;
SDL_SetWindowPosition(mWindow, coord.left, coord.top);
}
void WindowSDL2::set_position(int x, int y) {
if(closed) {
return;
}
SDL_SetWindowPosition(window, x, y);
} //set_position
void toggleFullscreen(SDL_Window* window, SDL_Renderer* renderer, bool &isFullscreen, int &width, int &height)
{
SDL_SetWindowFullscreen(window, isFullscreen ? 0 : SDL_WINDOW_FULLSCREEN_DESKTOP);
if (!isFullscreen)
SDL_SetWindowSize(window, 800, 600); //or 1024x768
isFullscreen = !isFullscreen; //toggle isFullscreen
SDL_GetRendererOutputSize(renderer, &width, &height);
SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
}
inline Window& Window::SetPosition(int32 X, int32 Y) {
x = X;
y = Y;
if (m_window == NULL) {
return *this;
}
SDL_SetWindowPosition(m_window, X, Y);
return *this;
}
void Window::resizeWindow(int x, int y, int w, int h)
{
SDL_SetWindowSize(window, w, h);
SDL_SetWindowPosition(window, x, y);
dimensions.x = x;
dimensions.y = y;
dimensions.w = w;
dimensions.h = h;
}
bool Client::SetFullScreen (const bool want_fullscreen)
{
if (want_fullscreen == fullscreen)
return true;
if (want_fullscreen)
{
SDL_SetWindowPosition (mainWindow, 0, 0);
int x, y, w, h;
SDL_GetWindowSize (mainWindow, &w, &h);
SDL_GetMouseState (&x, &y);
// Clamp mouse position
x = std::max (0, std::min (x, w));
y = std::max (0, std::min (y, h));
SDL_WarpMouseInWindow (mainWindow, x, y);
}
Uint32 flags = want_fullscreen? SDL_WINDOW_FULLSCREEN : 0;
if (SDL_SetWindowFullscreen (mainWindow, flags) < 0)
{
SetError ("Cannot set fullscreen to %d: %s", want_fullscreen, SDL_GetError ());
return false;
}
fullscreen = want_fullscreen;
SaveSetting (settingsPath.c_str (), FULLSCREEN_SETTING, fullscreen);
// Some final adjustments
if (fullscreen)
{
SDL_SetWindowGrab (mainWindow, SDL_TRUE);
}
else
{
SDL_SetWindowGrab (mainWindow, SDL_FALSE);
SDL_SetWindowPosition (mainWindow, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
}
return true;
}
void GraphicsEngine::setWindowSize(const int &w, const int &h) {
SDL_SetWindowSize(window, w, h);
SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
#ifdef __DEBUG
debug("Set Window W", w);
debug("Set Window H", h);
#endif
Camera::instance->cameraPerspective.width = (float)w;
Camera::instance->cameraPerspective.height = (float)h;
glViewport(0, 0, w, h); // Core in version 4.4
}
void Window::forceFullscreenMode(int w, int h)
{
if (!isFullscreen())
{
fullscreen = true;
setSize(w, h);
SDL_SetWindowPosition(window, 0, 0);
SDL_SetWindowSize(window, w, h);
SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN);
}
}
void Window::forceWindowedMode()
{
if (isFullscreen())
{
fullscreen = false;
setSize(1280, 720);
SDL_SetWindowSize(window, 1280, 720);
SDL_SetWindowFullscreen(window, NULL);
SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
}
}
int Window::setWindowPosition(State & state, SDL_Window * window){
Stack * stack = state.stack;
if (stack->is<LUA_TTABLE>(1)){
stack->getField("x", 1);
stack->getField("y", 1);
if (stack->is<LUA_TNUMBER>(-2) && stack->is<LUA_TNUMBER>(-1)){
SDL_SetWindowPosition(window, stack->to<int>(-2), stack->to<int>(-1));
}
stack->pop(2);
}
return 0;
}
/*
* Vibrates the window randomly
* PARAMS:
* iters: number of times to vibrate the window
* pos_variance: pixel area size the window may move around
* delay: time between vibrations
*/
void Shake(int iters, int pos_variance, int delay) {
int half_variance = pos_variance / 2;
int x, y;
SDL_GetWindowPosition(window, &x, &y);
int x_offset, y_offset;
int cnt;
for(cnt=0; cnt < iters; cnt++) {
x_offset = rand() % pos_variance - half_variance;
y_offset = rand() % pos_variance - half_variance;
SDL_SetWindowPosition(window,
x + x_offset,
y + y_offset
);
SDL_Delay(delay);
}
SDL_SetWindowPosition(window, x, y);
EndDemo();
}
int
DirectFB_ResizeWindowShape(SDL_Window* window) {
SDL_ShapeData* data = window->shaper->driverdata;
SDL_assert(data != NULL);
if (window->x != -1000)
{
window->shaper->userx = window->x;
window->shaper->usery = window->y;
}
SDL_SetWindowPosition(window,-1000,-1000);
return 0;
}
void windowToggleFullscreen() {
SDL_SetWindowFullscreen(sdl_window,
windowIsFullscreen() ? 0 : SDL_WINDOW_FULLSCREEN_DESKTOP);
app->video.fullscreen = windowIsFullscreen();
#ifdef _WIN32
// hack for when the title bar is off screen after restoring from fullscreen
if (!app->video.fullscreen) {
int x, y;
SDL_GetWindowPosition(sdl_window, &x, &y);
if (y < 32) SDL_SetWindowPosition(sdl_window, x, 32);
}
#endif
}
static void GLimp_CreateWindow( int x, int y, int width, int height )
{
glw_state.sdl_window = SDL_CreateWindow( glw_state.applicationName,
SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, width, height, SDL_WINDOW_OPENGL );
if( !glw_state.sdl_window )
Sys_Error( "Couldn't create window: \"%s\"", SDL_GetError() );
if( glw_state.wndproc ) {
glw_state.wndproc( glw_state.sdl_window, 0, 0, 0 );
}
SDL_SetWindowPosition( glw_state.sdl_window, x, y );
GLimp_SetWindowIcon();
}
static bool SetScreenParmsWindowed( glimpParms_t parms )
{
SDL_SetWindowSize( window, parms.width, parms.height );
SDL_SetWindowPosition( window, parms.x, parms.y );
// if we're currently in fullscreen mode, we need to disable that
if( SDL_GetWindowFlags( window ) & SDL_WINDOW_FULLSCREEN )
{
if( SDL_SetWindowFullscreen( window, SDL_FALSE ) < 0 )
{
common->Warning( "Couldn't switch to windowed mode, reason: %s!", SDL_GetError() );
return false;
}
}
return true;
}
