Managing Window Position

In this lesson, we'll explore SDL's window positioning capabilities, from setting initial window locations to handling dynamic repositioning. We’ll cover

• How to set window positions explicitly, or use special values that dynamically position our window based on the environment our program is run on
• Retrieving the current location of our window
• Moving windows programmatically, including how to shift a window based on its current position
• Detecting when the user moves our window, so we can respond appropriately
• A preview of window IDs, which let us manage events in applications that have multiple windows

Window Position

As we’ve seen, the primary way we create windows within an SDL application is by using the SDL_CreateWindow() function. The second and third arguments to SDL_CreateWindow() define where we want the window to be positioned within the user’s screen.

These arguments represent the horizontal and vertical positions respectively. Below, we open a window 100 points from the left edge of the screen, and 200 points from the top edge:

1SDL_CreateWindow(
2  "Hello Window",
3  100, 200, 
4  700, 300, 0);

SDL_WINDOWPOS_UNDEFINED

In most use cases, we have no particular need to be this specific with the window position. Instead, we can let the platform decide the best place to open it.

To do this, we can pass SDL_WINDOWPOS_UNDEFINED to either or both of these parameters: which we can use to let the platform decide where to open the window:

1SDL_CreateWindow(
2  "Hello Window",
3  SDL_WINDOWPOS_UNDEFINED, 
4  SDL_WINDOWPOS_UNDEFINED, 
5  700, 300, 0);

This is a sensible default choice, as the platform developers will have put some thought into where to open windows such that the user experience is pleasant.

For example, they might open the window near where the user clicked the icon to run the program, or they might open the program in the same location where the user placed it the last time they ran it.

SDL_WINDOWPOS_CENTERED

Alternatively, we can pass SDL_WINDOWPOS_CENTERED to have SDL determine what position to use that would cause our window to be centered along either dimension. SDL examines the size of the monitor and the size of the window we’re creating (700x300 in this example) to determine what value would cause that window to be centered.

Below, we open a window that is centered both horizontally and vertically:

1SDL_CreateWindow(
2  "Hello Window",
3  SDL_WINDOWPOS_CENTERED, 
4  SDL_WINDOWPOS_CENTERED, 
5  700, 300, 0);

Getting the Window Position

Whilst we can specify where we want our window to be initially created, many platforms allow users to move the window elsewhere on their screen. This is typically done by, for example, dragging on the title bar.

We can get the current position of a window by passing its SDL_Window pointer to the SDL_GetWindowPosition() function. We pass two additional arguments, which should be pointers to integers:

1int x, y;
2SDL_GetWindowPosition(Window, &x, &y);

SDL_GetWindowPosition() updates these integers with the window’s horizontal and vertical position respectively:

1#include <SDL.h>
2#include <iostream>
3
4int main(int argc, char** argv) {
5  SDL_Init(SDL_INIT_VIDEO);
6
7  SDL_Window* Window{
8    SDL_CreateWindow(
9      "Hello Window",
10      SDL_WINDOWPOS_CENTERED,
11      SDL_WINDOWPOS_CENTERED,
12      700, 300, 0
13    )};
14
15  int x, y;
16  SDL_GetWindowPosition(Window, &x, &y);
17  std::cout << "Position: " << x << ", " << y;
18
19  SDL_Quit();
20  return 0;
21}

1Position: 930, 570

If we only care about the window’s position in one dimension, we can pass a nullptr to the other:

1// We only care about horizontal position
2int x;
3SDL_GetWindowPosition(Window, &x, nullptr);
4
5// We only care about vertical position
6int y;
7SDL_GetWindowPosition(Window, nullptr, &y);

SDL_WINDOWEVENT_MOVED Events

Whilst SDL_GetWindowPosition() allows us to retrieve the position of a window at any time, when our specific need is to react to a window being moved, the event loop is usually the better approach.

SDL emits an SDL_WindowEvent with an event value of SDL_WINDOWEVENT_MOVED when a window is moved. We can react to this event in the usual way:

1#include <SDL.h>
2#include <iostream>
3#include "Window.h"
4
5void HandleWindowEvent(SDL_WindowEvent& E) {
6  if (E.event == SDL_WINDOWEVENT_MOVED) {
7    std::cout << "Window Moved\n";
8  }
9}
10
11int main(int argc, char** argv) {
12  SDL_Init(SDL_INIT_VIDEO);
13  Window GameWindow;
14  SDL_Event E;
15
16  while (true) {
17    while (SDL_PollEvent(&E)) {
18      if (E.type == SDL_WINDOWEVENT) {
19        HandleWindowEvent(E.window);
20      } else if (E.type == SDL_QUIT) {
21        SDL_Quit();
22        return 0;
23      }
24    }
25    GameWindow.Update();
26    GameWindow.Render();
27  }
28}

1Window Moved

The data1 and data2 members of this event will contain the new horizontal and vertical position of the window respectively:

1#include <SDL.h>
2#include <iostream>
3#include "Window.h"
4
5void HandleWindowEvent(SDL_WindowEvent& E) {
6  if (E.event == SDL_WINDOWEVENT_MOVED) {
7    std::cout << "Window Moved: "
8      << E.data1 << ", " << E.data2 << '\n';
9  }
10}
11
main Function|Show
12int main(int argc, char** argv) {/*...*/}

1Window Moved: 506, 281

Programmatically Moving a Window

We can update the position of an SDL_Window* at any time using the SDL_SetWindowPosition() function. This function accepts the SDL_Window* as the first argument, and the window’s new horizontal and vertical positions as the second and third arguments respectively.

Let’s add this capability to our custom Window class by introducing a Move() method:

1// Window.h
2#pragma once
3#include <SDL.h>
4
5class Window {
6public:
7  // ...
8  void Move(int x, int y) {
9    SDL_SetWindowPosition(SDLWindow, x, y);
10  }
11
12  SDL_Window* SDLWindow;
13};

Just like when we initially created the window, we can pass SDL_WINDOWPOS_UNDEFINED to the positional arguments of SDL_SetWindowPosition() to let the platform decide the best values:

1#include <SDL.h>
2#include "Window.h"
3
4int main(int argc, char** argv) {
5  SDL_Init(SDL_INIT_VIDEO);
6  Window GameWindow;
7  
8  GameWindow.Move(
9    SDL_WINDOWPOS_UNDEFINED,
10    SDL_WINDOWPOS_UNDEFINED
11  );
12
13  SDL_Quit();
14  return 0;
15}

We can also use SDL_WINDOWPOS_CENTERED to let SDL calculate the value that would cause the window to be centered along either dimension. Below, we move the window to the center of the screen if the user presses their spacebar whilst our window has input focus:

1#include <SDL.h>
2#include <iostream>
3#include "Window.h"
4
5void HandleKeydownEvent(
6  SDL_KeyboardEvent& E, Window& Window
7) {
8  if (E.keysym.sym == SDLK_SPACE) {
9    Window.Move(
10      SDL_WINDOWPOS_CENTERED,
11      SDL_WINDOWPOS_CENTERED);
12  }
13}
14
15int main(int argc, char** argv) {
16  SDL_Init(SDL_INIT_VIDEO);
17  Window GameWindow;
18  SDL_Event E;
19
20  while (true) {
21    while (SDL_PollEvent(&E)) {
22      if (E.type == SDL_KEYDOWN) {
23        HandleKeydownEvent(E.key, GameWindow);
24      } else if (E.type == SDL_QUIT) {
25        SDL_Quit();
26        return 0;
27      }
28    }
29    GameWindow.Update();
30    GameWindow.Render();
31  }
32}

1HandleKeydownEvent(E.key, GameWindow);

1void HandleKeydownEvent(SDL_KeyboardEvent& E) {
2  if (E.keysym.sym == SDLK_SPACE) {
3    SDL_SetWindowPosition(
4      SDL_GetWindowFromID(E.windowID),
5      SDL_WINDOWPOS_CENTERED,
6      SDL_WINDOWPOS_CENTERED);
7  }
8}

Relative Moving

When our program needs to move a window, the position we want to move it to will often depend on its current position. Rather than setting a position relative to the top left of the screen, we want to set a position relative to where the window currently is.

To do this, we can combine the SDL_GetWindowPosition() and SDL_SetWindowPosition() functions.

1#include <SDL.h>
2#include "Window.h"
3
4int main(int argc, char** argv) {
5  SDL_Init(SDL_INIT_VIDEO);
6  Window GameWindow;
7
8  int x, y;
9  SDL_GetWindowPosition(
10    GameWindow.SDLWindow, &x, &y);
11
12  // Move the window 10 pixels right
13  SDL_SetWindowPosition(
14    GameWindow.SDLWindow, x + 10, y);
15
16  SDL_Quit();
17  return 0;
18}

Let’s update our Window class with a generalized form of this capability, in the form of a method called MoveRelative():

1// Window.h
2#pragma once
3#include <iostream>
4#include <SDL.h>
5
6class Window {
7public:
8  void MoveRelative(int DeltaX, int DeltaY) {
9    int CurrentX, CurrentY;
10    SDL_GetWindowPosition(
11      SDLWindow, &CurrentX, &CurrentY);
12
13    SDL_SetWindowPosition(
14      SDLWindow,
15      CurrentX + DeltaX,
16      CurrentY + DeltaY);
17  }
18
19  SDL_Window* SDLWindow;
20};

In the following example, we use this to let the user move their window with their arrow keys:

1#include <SDL.h>
2#include "Window.h"
3
4void HandleKeydownEvent(
5  SDL_KeyboardEvent& E, Window& GameWindow) {
6  if (E.keysym.sym == SDLK_LEFT) {
7    GameWindow.MoveRelative(-10, 0);
8  } else if (E.keysym.sym == SDLK_RIGHT) {
9    GameWindow.MoveRelative(10, 0);
10  } else if (E.keysym.sym == SDLK_UP) {
11    GameWindow.MoveRelative(0, -10);
12  } else if (E.keysym.sym == SDLK_DOWN) {
13    GameWindow.MoveRelative(0, 10);
14  }
15}
16
17int main(int argc, char** argv) {
18  SDL_Init(SDL_INIT_VIDEO);
19  Window GameWindow;
20  SDL_Event E;
21
22  while (true) {
23    while (SDL_PollEvent(&E)) {
24      if (E.type == SDL_KEYDOWN) {
25        HandleKeydownEvent(E.key, GameWindow);
26      } else if (E.type == SDL_QUIT) {
27        SDL_Quit();
28        return 0;
29      }
30    }
31    GameWindow.Update();
32    GameWindow.Render();
33  }
34}

Summary

In this lesson, we've covered the fundamentals of window positioning in SDL2. We've learned how to control window placement both at creation and during runtime, respond to window movement events, and implement relative movement. Key takeaways:

• Window positions can be specified explicitly or using special values like SDL_WINDOWPOS_UNDEFINED and SDL_WINDOWPOS_CENTERED.
• SDL_GetWindowPosition() lets us query a window's current location.
• SDL_SetWindowPosition() allows programmatic window movement.
• Window movement events (SDL_WINDOWEVENT_MOVED) help us track user-initiated window changes.
• Relative movement can be implemented by combining position getting and setting.
• Window IDs provide a reliable way to track and manage multiple windows.

Next Lesson

Window Sizing

Learn how to resize, constrain, and manage SDL2 windows

ContinueView Course