Managing Window Position

Saving Window Position

How can I save the window's position so it opens in the same place next time?

Abstract art representing computer programming

Saving and restoring window positions is a common requirement for professional applications. Here's how to implement this feature using file I/O:

Basic Position Saving

First, let's create a simple system to save and load window positions:

1#include <SDL.h>
2#include <fstream>
3#include <string>
4#include "Window.h"
5
6class PersistentWindow : public Window {
7public:
8  void SavePosition(
9    const std::string& Filename) {
10    int X, Y;
11    SDL_GetWindowPosition(SDLWindow, &X, &Y);
12
13    std::ofstream File{Filename};
14    if (File) { File << X << ' ' << Y; }
15  }
16
17  bool LoadPosition(
18    const std::string& Filename) {
19    std::ifstream File{Filename};
20    int X, Y;
21
22    if (File >> X >> Y) {
23      SDL_SetWindowPosition(SDLWindow, X, Y);
24      return true;
25    }
26
27    return false;
28  }
29};

Complete Implementation with Error Handling

Here's a more robust implementation that handles multiple monitors and screen boundaries:

1#include <SDL.h>
2#include <filesystem>
3#include <fstream>
4#include <string>
5
6class PersistentWindow : public Window {
7public:
8  struct WindowState {
9    int X, Y;
10    int Width, Height;
11    bool IsMaximized;
12  };
13
14  void SaveState(const std::string& Filename) {
15    WindowState State;
16
17    // Get current state
18    SDL_GetWindowPosition(
19      SDLWindow, &State.X, &State.Y);
20    SDL_GetWindowSize(
21      SDLWindow, &State.Width, &State.Height);
22    State.IsMaximized = SDL_GetWindowFlags(
23      SDLWindow) & SDL_WINDOW_MAXIMIZED;
24
25    // Save to file
26    std::ofstream File{
27      Filename, std::ios::binary};
28    if (File) {
29      File.write(
30        reinterpret_cast<char*>(&State),
31        sizeof(WindowState)
32      );
33    }
34  }
35
36  bool RestoreState(
37    const std::string& Filename) {
38    // Check if file exists
39    if (!std::filesystem::exists(Filename)) {
40      return false;
41    }
42
43    // Read saved state
44    WindowState State;
45    std::ifstream File{
46      Filename, std::ios::binary};
47    if (!File.read(reinterpret_cast<char*>(
48                     &State),
49                   sizeof(WindowState))) {
50      return false;
51    }
52
53    // Ensure position is on screen
54    if (EnsureOnScreen(State)) {
55      // Apply state
56      SDL_SetWindowSize(
57        SDLWindow, State.Width, State.Height);
58      SDL_SetWindowPosition(
59        SDLWindow, State.X, State.Y);
60
61      if (State.IsMaximized) {
62        SDL_MaximizeWindow(SDLWindow);
63      }
64      return true;
65    }
66
67    return false;
68  }
69
70private:
71  bool EnsureOnScreen(WindowState& State) {
72    SDL_DisplayMode Display;
73    if (SDL_GetCurrentDisplayMode(
74      0, &Display) != 0) { return false; }
75
76    // Ensure window is at least partially visible
77    State.X = std::max(
78      -State.Width / 2,
79      std::min(
80        State.X,
81        Display.w - State.Width / 2
82      )
83    );
84
85    State.Y = std::max(
86      0, std::min(State.Y, Display.h - 100));
87
88    return true;
89  }
90};

Usage Example

Here's how to use the persistent window:

1#include <SDL.h>
2#include "PersistentWindow.h"
3
4int main(int argc, char** argv) {
5  SDL_Init(SDL_INIT_VIDEO);
6  PersistentWindow Window;
7
8  // Try to restore previous position
9  if (!Window.RestoreState("window.dat")) {  
10    // If no saved position, start centered
11    SDL_SetWindowPosition(
12      Window.SDLWindow,
13      SDL_WINDOWPOS_CENTERED,
14      SDL_WINDOWPOS_CENTERED
15    );
16  }
17
18  SDL_Event E;
19  while (true) {
20    while (SDL_PollEvent(&E)) {
21      if (E.type == SDL_QUIT) {
22        // Save position before exit
23        Window.SaveState("window.dat");  
24        SDL_Quit();
25        return 0;
26      }
27    }
28  }
29}

This implementation includes several important features:

Saves both position and size information
Handles maximized state
Ensures the window remains visible on screen
Uses binary file I/O for efficient storage
Includes error handling for file operations

Remember to consider multi-monitor setups and different screen resolutions when restoring window positions. A position that was valid when saved might not be valid when the application is next launched.

This Question is from the Lesson: