/**
* @brief Enable and disable screensaver while checking state
*/
int
video_enableDisableScreensaver(void *arg)
{
SDL_bool initialResult;
SDL_bool result;
/* Get current state and proceed according to current state */
initialResult = SDL_IsScreenSaverEnabled();
SDLTest_AssertPass("Call to SDL_IsScreenSaverEnabled()");
if (initialResult == SDL_TRUE) {
/* Currently enabled: disable first, then enable again */
/* Disable screensaver and check */
SDL_DisableScreenSaver();
SDLTest_AssertPass("Call to SDL_DisableScreenSaver()");
result = SDL_IsScreenSaverEnabled();
SDLTest_AssertPass("Call to SDL_IsScreenSaverEnabled()");
SDLTest_AssertCheck(result == SDL_FALSE, "Verify result from SDL_IsScreenSaverEnabled, expected: %i, got: %i", SDL_FALSE, result);
/* Enable screensaver and check */
SDL_EnableScreenSaver();
SDLTest_AssertPass("Call to SDL_EnableScreenSaver()");
result = SDL_IsScreenSaverEnabled();
SDLTest_AssertPass("Call to SDL_IsScreenSaverEnabled()");
SDLTest_AssertCheck(result == SDL_TRUE, "Verify result from SDL_IsScreenSaverEnabled, expected: %i, got: %i", SDL_TRUE, result);
} else {
/* Currently disabled: enable first, then disable again */
/* Enable screensaver and check */
SDL_EnableScreenSaver();
SDLTest_AssertPass("Call to SDL_EnableScreenSaver()");
result = SDL_IsScreenSaverEnabled();
SDLTest_AssertPass("Call to SDL_IsScreenSaverEnabled()");
SDLTest_AssertCheck(result == SDL_TRUE, "Verify result from SDL_IsScreenSaverEnabled, expected: %i, got: %i", SDL_TRUE, result);
/* Disable screensaver and check */
SDL_DisableScreenSaver();
SDLTest_AssertPass("Call to SDL_DisableScreenSaver()");
result = SDL_IsScreenSaverEnabled();
SDLTest_AssertPass("Call to SDL_IsScreenSaverEnabled()");
SDLTest_AssertCheck(result == SDL_FALSE, "Verify result from SDL_IsScreenSaverEnabled, expected: %i, got: %i", SDL_FALSE, result);
}
return TEST_COMPLETED;
}
void Window::setDisplaySleepEnabled(bool enable)
{
if (enable)
SDL_EnableScreenSaver();
else
SDL_DisableScreenSaver();
}
/******************************************************************************
* Fullscreen management
******************************************************************************/
void display::setFullscreen(bool fs) {
if (fs == true) {
SDL_SetWindowFullscreen(pWindow, SDL_WINDOW_FULLSCREEN);
SDL_DisableScreenSaver();
}
else {
SDL_SetWindowFullscreen(pWindow, 0);
SDL_EnableScreenSaver();
}
}
bool System::SetAllowScreenTimeout (bool allow) {
if (allow) {
SDL_EnableScreenSaver ();
} else {
SDL_DisableScreenSaver ();
}
return allow;
}
int PL_Window_End(void) {
if (s_initialized == DXFALSE) {
return -1;
}
s_initialized = DXFALSE;
PL_Draw_End();
SDL_EnableScreenSaver();
SDL_DestroyWindow(s_window);
s_window = NULL;
return 0;
}
int XForceScreenSaver(Display *display, int mode) {
// https://tronche.com/gui/x/xlib/window-and-session-manager/XForceScreenSaver.html
// https://www.libsdl.org/tmp/docs-1.3/_s_d_l__video_8h.html#6e5293ce67509a49c1ead749fc4547d9
SET_X_SERVER_REQUEST(display, X_ForceScreenSaver);
switch (mode) {
case ScreenSaverActive:
// Activate the screen saver now
SDL_EnableScreenSaver();
break;
case ScreenSaverReset:
XResetScreenSaver(display);
break;
default:
handleError(0, display, None, 0, BadValue, 0);
return 0;
}
return 1;
}
static void
SetupScreenSaver(int flags)
{
const char *env;
SDL_bool allow_screensaver;
/* Allow environment override of screensaver disable */
env = SDL_getenv("SDL_VIDEO_ALLOW_SCREENSAVER");
if (env) {
allow_screensaver = SDL_atoi(env) ? SDL_TRUE : SDL_FALSE;
} else if (flags & SDL_FULLSCREEN) {
allow_screensaver = SDL_FALSE;
} else {
allow_screensaver = SDL_TRUE;
}
if (allow_screensaver) {
SDL_EnableScreenSaver();
} else {
SDL_DisableScreenSaver();
}
}
void Window::close()
{
showMouse(true);
SDL_EnableScreenSaver();
if (m_pRenderer != NULL)
{
SDL_DestroyRenderer(m_pRenderer);
m_pRenderer = NULL;
}
if (m_pWindow != NULL)
{
SDL_GL_MakeCurrent(m_pWindow, NULL);
SDL_DestroyWindow(m_pWindow);
m_pWindow = NULL;
}
SDL_Quit();
}
// Actually put us in windowed or full screen mode. Pass true the first time this is used, false subsequently.
// This has the unfortunate side-effect of triggering a mouse move event.
void VideoSystem::actualizeScreenMode(GameSettings *settings, bool changingInterfaces, bool currentUIUsesEditorScreenMode)
{
DisplayMode displayMode = settings->getSetting<DisplayMode>(IniKey::WindowMode);
DisplayManager::getScreenInfo()->resetGameCanvasSize(); // Set GameCanvasSize vars back to their default values
DisplayManager::getScreenInfo()->setActualized();
// If old display mode is windowed or current is windowed but we change interfaces,
// save the window position
if(settings->getIniSettings()->oldDisplayMode == DISPLAY_MODE_WINDOWED ||
(changingInterfaces && displayMode == DISPLAY_MODE_WINDOWED))
{
settings->setWindowPosition(VideoSystem::getWindowPositionX(), VideoSystem::getWindowPositionY());
}
// When we're in the editor, let's take advantage of the entire screen unstretched
// We might want to disallow this when we're in split screen mode?
if(currentUIUsesEditorScreenMode &&
(displayMode == DISPLAY_MODE_FULL_SCREEN_STRETCHED || displayMode == DISPLAY_MODE_FULL_SCREEN_UNSTRETCHED))
{
// Smaller values give bigger magnification; makes small things easier to see on full screen
F32 magFactor = 0.85f;
// For screens smaller than normal, we need to readjust magFactor to make sure we get the full canvas height crammed onto
// the screen; otherwise our dock will break. Since this mode is only used in the editor, we don't really care about
// screen width; tall skinny screens will work just fine.
magFactor = max(magFactor, (F32)DisplayManager::getScreenInfo()->getGameCanvasHeight() / (F32)DisplayManager::getScreenInfo()->getPhysicalScreenHeight());
DisplayManager::getScreenInfo()->setGameCanvasSize(S32(DisplayManager::getScreenInfo()->getPhysicalScreenWidth() * magFactor), S32(DisplayManager::getScreenInfo()->getPhysicalScreenHeight() * magFactor));
displayMode = DISPLAY_MODE_FULL_SCREEN_STRETCHED;
}
// Set up video/window flags amd parameters and get ready to change the window
S32 sdlWindowWidth, sdlWindowHeight;
F64 orthoLeft, orthoRight, orthoTop, orthoBottom;
getWindowParameters(settings, displayMode, sdlWindowWidth, sdlWindowHeight, orthoLeft, orthoRight, orthoTop, orthoBottom);
// Change video modes based on selected display mode
// Note: going into fullscreen you have to do in order:
// - SDL_SetWindowSize()
// - SDL_SetWindowFullscreen()
//
// However, coming out of fullscreen mode you must do the reverse
switch (displayMode)
{
case DISPLAY_MODE_FULL_SCREEN_STRETCHED:
SDL_SetWindowSize(DisplayManager::getScreenInfo()->sdlWindow, sdlWindowWidth, sdlWindowHeight);
SDL_SetWindowFullscreen(DisplayManager::getScreenInfo()->sdlWindow, SDL_WINDOW_FULLSCREEN_DESKTOP);
break;
case DISPLAY_MODE_FULL_SCREEN_UNSTRETCHED:
SDL_SetWindowSize(DisplayManager::getScreenInfo()->sdlWindow, sdlWindowWidth, sdlWindowHeight);
SDL_SetWindowFullscreen(DisplayManager::getScreenInfo()->sdlWindow, SDL_WINDOW_FULLSCREEN_DESKTOP);
break;
case DISPLAY_MODE_WINDOWED:
default:
// Reverse order, leave fullscreen before setting size
SDL_SetWindowFullscreen(DisplayManager::getScreenInfo()->sdlWindow, 0);
SDL_SetWindowSize(DisplayManager::getScreenInfo()->sdlWindow, sdlWindowWidth, sdlWindowHeight);
break;
}
if(settings->getSetting<YesNo>(IniKey::DisableScreenSaver))
SDL_DisableScreenSaver();
else
SDL_EnableScreenSaver();
// Flush window events because SDL_SetWindowSize triggers a SDL_WINDOWEVENT_RESIZED
// event (which in turn triggers another SDL_SetWindowSize)
SDL_FlushEvent(SDL_WINDOWEVENT);
SDL_GL_SetSwapInterval(settings->getSetting<YesNo>(IniKey::Vsync) ? 1 : 0);
// Now save the new window dimensions in ScreenInfo
DisplayManager::getScreenInfo()->setWindowSize(sdlWindowWidth, sdlWindowHeight);
mGL->glClearColor(0, 0, 0, 0);
mGL->glViewport(0, 0, sdlWindowWidth, sdlWindowHeight);
mGL->glMatrixMode(GLOPT::Projection);
mGL->glLoadIdentity();
// The best understanding I can get for glOrtho is that these are the coordinates you want to appear at the four corners of the
// physical screen. If you want a "black border" down one side of the screen, you need to make left negative, so that 0 would
// appear some distance in from the left edge of the physical screen. The same applies to the other coordinates as well.
mGL->glOrtho(orthoLeft, orthoRight, orthoBottom, orthoTop, 0, 1);
mGL->glMatrixMode(GLOPT::Modelview);
mGL->glLoadIdentity();
// Do the scissoring
if(displayMode == DISPLAY_MODE_FULL_SCREEN_UNSTRETCHED)
{
mGL->glScissor(DisplayManager::getScreenInfo()->getHorizPhysicalMargin(), // x
DisplayManager::getScreenInfo()->getVertPhysicalMargin(), // y
DisplayManager::getScreenInfo()->getDrawAreaWidth(), // width
DisplayManager::getScreenInfo()->getDrawAreaHeight()); // height
}
else
{
// Enabling scissor appears to fix crashing problem switching screen mode
// in linux and "Mobile 945GME Express Integrated Graphics Controller",
// probably due to lines and points was not being clipped,
// causing some lines to wrap around the screen, or by writing other
// parts of RAM that can crash Bitfighter, graphics driver, or the entire computer.
// This is probably a bug in the Linux Intel graphics driver.
mGL->glScissor(0, 0, DisplayManager::getScreenInfo()->getWindowWidth(), DisplayManager::getScreenInfo()->getWindowHeight());
}
mGL->glEnable(GLOPT::ScissorTest); // Turn on clipping
mGL->setDefaultBlendFunction();
mGL->glLineWidth(RenderUtils::DEFAULT_LINE_WIDTH);
// Enable Line smoothing everywhere! Make sure to disable temporarily for filled polygons and such
if(settings->getSetting<YesNo>(IniKey::LineSmoothing))
{
mGL->glEnable(GLOPT::LineSmooth);
//glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
}
mGL->glEnable(GLOPT::Blend);
// Now set the window position
if(displayMode == DISPLAY_MODE_WINDOWED)
{
// Sometimes it happens to be (0,0) hiding the top title bar preventing ability to
// move the window, in this case we are not moving it unless it is not (0,0).
// Note that ini config file will default to (0,0).
if(settings->getWindowPositionX() != 0 || settings->getWindowPositionY() != 0)
setWindowPosition(settings->getWindowPositionX(), settings->getWindowPositionY());
}
else
setWindowPosition(0, 0);
// Notify all active UIs that the screen has changed mode. This will likely need some work to not do something
// horrible in split-screen mode.
const Vector<ClientGame *> *clientGames = GameManager::getClientGames();
for(S32 i = 0; i < clientGames->size(); i++)
if(clientGames->get(i)->getUIManager()->getCurrentUI())
clientGames->get(i)->getUIManager()->getCurrentUI()->onDisplayModeChange();
// Re-initialize our fonts because OpenGL textures can be lost upon screen change
FontManager::reinitialize(settings);
// This needs to happen after font re-initialization because I think fontstash interferes
// with the oglconsole font somehow...
GameManager::gameConsole->onScreenModeChanged();
}
int main (int argc, char *argv[]) {
struct RISC *risc = risc_new();
risc_set_serial(risc, &pclink);
risc_set_clipboard(risc, &sdl_clipboard);
struct RISC_LED leds = {
.write = show_leds
};
bool fullscreen = false;
double zoom = 0;
SDL_Rect risc_rect = {
.w = RISC_FRAMEBUFFER_WIDTH,
.h = RISC_FRAMEBUFFER_HEIGHT
};
bool size_option = false;
int mem_option = 0;
const char *serial_in = NULL;
const char *serial_out = NULL;
bool boot_from_serial = false;
int opt;
while ((opt = getopt_long(argc, argv, "z:fLm:s:I:O:S", long_options, NULL)) != -1) {
switch (opt) {
case 'z': {
double x = strtod(optarg, 0);
if (x > 0) {
zoom = x;
}
break;
}
case 'f': {
fullscreen = true;
break;
}
case 'L': {
risc_set_leds(risc, &leds);
break;
}
case 'm': {
if (sscanf(optarg, "%d", &mem_option) != 1) {
usage();
}
break;
}
case 's': {
int w, h;
if (sscanf(optarg, "%dx%d", &w, &h) != 2) {
usage();
}
risc_rect.w = clamp(w, 32, MAX_WIDTH) & ~31;
risc_rect.h = clamp(h, 32, MAX_HEIGHT);
size_option = true;
break;
}
case 'I': {
serial_in = optarg;
break;
}
case 'O': {
serial_out = optarg;
break;
}
case 'S': {
boot_from_serial = true;
risc_set_switches(risc, 1);
break;
}
default: {
usage();
}
}
}
if (mem_option || size_option) {
risc_configure_memory(risc, mem_option, risc_rect.w, risc_rect.h);
}
if (optind == argc - 1) {
risc_set_spi(risc, 1, disk_new(argv[optind]));
} else if (optind == argc && boot_from_serial) {
/* Allow diskless boot */
risc_set_spi(risc, 1, disk_new(NULL));
} else {
usage();
}
if (serial_in || serial_out) {
if (!serial_in) {
serial_in = "/dev/null";
}
if (!serial_out) {
serial_out = "/dev/null";
}
risc_set_serial(risc, raw_serial_new(serial_in, serial_out));
}
if (SDL_Init(SDL_INIT_VIDEO) != 0) {
fail(1, "Unable to initialize SDL: %s", SDL_GetError());
}
atexit(SDL_Quit);
SDL_EnableScreenSaver();
SDL_ShowCursor(false);
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "best");
int window_flags = SDL_WINDOW_HIDDEN;
int display = 0;
if (fullscreen) {
window_flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
display = best_display(&risc_rect);
}
if (zoom == 0) {
SDL_Rect bounds;
if (SDL_GetDisplayBounds(display, &bounds) == 0 &&
bounds.h >= risc_rect.h * 2 && bounds.w >= risc_rect.w * 2) {
zoom = 2;
} else {
zoom = 1;
}
}
SDL_Window *window = SDL_CreateWindow("Project Oberon",
SDL_WINDOWPOS_UNDEFINED_DISPLAY(display),
SDL_WINDOWPOS_UNDEFINED_DISPLAY(display),
(int)(risc_rect.w * zoom),
(int)(risc_rect.h * zoom),
window_flags);
if (window == NULL) {
fail(1, "Could not create window: %s", SDL_GetError());
}
SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, 0);
if (renderer == NULL) {
fail(1, "Could not create renderer: %s", SDL_GetError());
}
SDL_Texture *texture = SDL_CreateTexture(renderer,
SDL_PIXELFORMAT_ARGB8888,
SDL_TEXTUREACCESS_STREAMING,
risc_rect.w,
risc_rect.h);
if (texture == NULL) {
fail(1, "Could not create texture: %s", SDL_GetError());
}
SDL_Rect display_rect;
double display_scale = scale_display(window, &risc_rect, &display_rect);
update_texture(risc, texture, &risc_rect);
SDL_ShowWindow(window);
SDL_RenderClear(renderer);
SDL_RenderCopy(renderer, texture, &risc_rect, &display_rect);
SDL_RenderPresent(renderer);
bool done = false;
bool mouse_was_offscreen = false;
while (!done) {
uint32_t frame_start = SDL_GetTicks();
SDL_Event event;
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_QUIT: {
done = true;
break;
}
case SDL_WINDOWEVENT: {
if (event.window.event == SDL_WINDOWEVENT_RESIZED) {
display_scale = scale_display(window, &risc_rect, &display_rect);
}
break;
}
case SDL_MOUSEMOTION: {
int scaled_x = (int)round((event.motion.x - display_rect.x) / display_scale);
int scaled_y = (int)round((event.motion.y - display_rect.y) / display_scale);
int x = clamp(scaled_x, 0, risc_rect.w - 1);
int y = clamp(scaled_y, 0, risc_rect.h - 1);
bool mouse_is_offscreen = x != scaled_x || y != scaled_y;
if (mouse_is_offscreen != mouse_was_offscreen) {
SDL_ShowCursor(mouse_is_offscreen);
mouse_was_offscreen = mouse_is_offscreen;
}
risc_mouse_moved(risc, x, risc_rect.h - y - 1);
break;
}
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP: {
bool down = event.button.state == SDL_PRESSED;
risc_mouse_button(risc, event.button.button, down);
break;
}
case SDL_KEYDOWN:
case SDL_KEYUP: {
bool down = event.key.state == SDL_PRESSED;
switch (map_keyboard_event(&event.key)) {
case ACTION_RESET: {
risc_reset(risc);
break;
}
case ACTION_TOGGLE_FULLSCREEN: {
fullscreen ^= true;
if (fullscreen) {
SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
} else {
SDL_SetWindowFullscreen(window, 0);
}
break;
}
case ACTION_QUIT: {
SDL_PushEvent(&(SDL_Event){ .type=SDL_QUIT });
break;
}
case ACTION_FAKE_MOUSE1: {
risc_mouse_button(risc, 1, down);
break;
}
case ACTION_FAKE_MOUSE2: {
risc_mouse_button(risc, 2, down);
break;
}
case ACTION_FAKE_MOUSE3: {
risc_mouse_button(risc, 3, down);
break;
}
case ACTION_OBERON_INPUT: {
uint8_t ps2_bytes[MAX_PS2_CODE_LEN];
int len = ps2_encode(event.key.keysym.scancode, down, ps2_bytes);
risc_keyboard_input(risc, ps2_bytes, len);
break;
}
}
}
}
}
risc_set_time(risc, frame_start);
risc_run(risc, CPU_HZ / FPS);
update_texture(risc, texture, &risc_rect);
SDL_RenderClear(renderer);
SDL_RenderCopy(renderer, texture, &risc_rect, &display_rect);
SDL_RenderPresent(renderer);
uint32_t frame_end = SDL_GetTicks();
int delay = frame_start + 1000/FPS - frame_end;
if (delay > 0) {
SDL_Delay(delay);
}
}
int main (int argc, char *argv[]) {
struct RISC *risc = risc_new();
risc_set_serial(risc, &pclink);
risc_set_clipboard(risc, &sdl_clipboard);
bool fullscreen = false;
SDL_Rect risc_rect = {
.w = RISC_FRAMEBUFFER_WIDTH,
.h = RISC_FRAMEBUFFER_HEIGHT
};
int opt;
while ((opt = getopt_long(argc, argv, "fS:F:", long_options, NULL)) != -1) {
switch (opt) {
case 'f': {
fullscreen = true;
break;
}
case 's': {
int w, h;
if (sscanf(optarg, "%dx%d", &w, &h) != 2) {
usage();
}
risc_rect.w = clamp(w, 32, MAX_WIDTH) & ~31;
risc_rect.h = clamp(h, 32, MAX_HEIGHT);
risc_screen_size_hack(risc, risc_rect.w, risc_rect.h);
break;
}
case 'F': {
risc_set_serial(risc, raw_serial_new(atoi(optarg), atoi(optarg) + 1));
break;
}
default: {
usage();
}
}
}
if (optind != argc - 1) {
usage();
}
risc_set_spi(risc, 1, disk_new(argv[optind]));
sdl_error_if(SDL_Init(SDL_INIT_VIDEO) != 0, "Unable to initialize SDL");
atexit(SDL_Quit);
SDL_EnableScreenSaver();
SDL_ShowCursor(false);
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "best");
int window_flags = SDL_WINDOW_HIDDEN;
int window_pos = SDL_WINDOWPOS_UNDEFINED;
if (fullscreen) {
window_flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
window_pos = best_display(&risc_rect);
}
SDL_Window *window = SDL_CreateWindow("Project Oberon",
window_pos, window_pos,
risc_rect.w, risc_rect.h,
window_flags);
sdl_error_if(window == NULL, "Could not create window");
SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, 0);
sdl_error_if(renderer == NULL, "Could not create renderer");
SDL_Texture *texture = SDL_CreateTexture(renderer,
SDL_PIXELFORMAT_ARGB8888,
SDL_TEXTUREACCESS_STREAMING,
risc_rect.w,
risc_rect.h);
sdl_error_if(texture == NULL, "Could not create texture");
SDL_Rect display_rect;
double display_scale = scale_display(window, &risc_rect, &display_rect);
update_texture(risc, texture, &risc_rect);
SDL_ShowWindow(window);
SDL_RenderClear(renderer);
SDL_RenderCopy(renderer, texture, &risc_rect, &display_rect);
SDL_RenderPresent(renderer);
bool done = false;
bool mouse_was_offscreen = false;
while (!done) {
uint32_t frame_start = SDL_GetTicks();
SDL_Event event;
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_QUIT: {
done = true;
}
case SDL_WINDOWEVENT: {
if (event.window.event == SDL_WINDOWEVENT_RESIZED) {
display_scale = scale_display(window, &risc_rect, &display_rect);
}
break;
}
case SDL_MOUSEMOTION: {
int scaled_x = (int)round((event.motion.x - display_rect.x) / display_scale);
int scaled_y = (int)round((event.motion.y - display_rect.y) / display_scale);
int x = clamp(scaled_x, 0, risc_rect.w - 1);
int y = clamp(scaled_y, 0, risc_rect.h - 1);
bool mouse_is_offscreen = x != scaled_x || y != scaled_y;
if (mouse_is_offscreen != mouse_was_offscreen) {
SDL_ShowCursor(mouse_is_offscreen);
mouse_was_offscreen = mouse_is_offscreen;
}
risc_mouse_moved(risc, x, risc_rect.h - y - 1);
break;
}
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP: {
bool down = event.button.state == SDL_PRESSED;
risc_mouse_button(risc, event.button.button, down);
break;
}
case SDL_KEYDOWN:
case SDL_KEYUP: {
bool down = event.key.state == SDL_PRESSED;
SDL_Keysym k = event.key.keysym;
if (k.sym == SDLK_F12) {
// F12 = Oberon reset
if (down) {
risc_reset(risc);
}
} else if (k.sym == SDLK_F11 ||
(k.sym == SDLK_f && (k.mod & KMOD_GUI) && (k.mod & KMOD_SHIFT))) {
// F11 / Cmd-Shift-F = Toggle fullscreen
if (down) {
fullscreen ^= true;
if (fullscreen) {
SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
} else {
SDL_SetWindowFullscreen(window, 0);
}
}
} else if (k.sym == SDLK_F4 && (k.mod & KMOD_ALT)) {
// Alt-F4 = quit (for when we're running without windowing system)
if (down) {
SDL_PushEvent(&(SDL_Event){ .type=SDL_QUIT });
}
} else if (k.sym == SDLK_LALT) {
// Emulate middle button
risc_mouse_button(risc, 2, down);
} else {
// Pass other keys to Oberon
uint8_t scancode[MAX_PS2_CODE_LEN];
int len = ps2_encode(k.scancode, down, scancode);
risc_keyboard_input(risc, scancode, len);
}
break;
}
}
}
int XResetScreenSaver(Display *display) {
// https://tronche.com/gui/x/xlib/window-and-session-manager/XResetScreenSaver.html
SDL_DisableScreenSaver();
SDL_EnableScreenSaver();
return 1;
}
int PL_Window_ProcessMessages() {
SDL_Event event;
if (s_initialized == DXFALSE) {
return -1;
}
do {
while (SDL_PollEvent(&event)) {
switch(event.type) {
case SDL_WINDOWEVENT:
switch(event.window.event) {
case SDL_WINDOWEVENT_ENTER:
SDL_DisableScreenSaver();
s_lacksFocus &= ~1;
break;
case SDL_WINDOWEVENT_FOCUS_GAINED:
SDL_DisableScreenSaver();
s_lacksFocus &= ~2;
break;
case SDL_WINDOWEVENT_LEAVE:
SDL_EnableScreenSaver();
s_lacksFocus |= 1;
break;
case SDL_WINDOWEVENT_FOCUS_LOST:
SDL_EnableScreenSaver();
s_lacksFocus |= 2;
break;
case SDL_WINDOWEVENT_EXPOSED:
case SDL_WINDOWEVENT_RESTORED:
PL_Window_Refresh();
break;
case SDL_WINDOWEVENT_RESIZED:
PL_Window_HandleResize(event.window.data1, event.window.data2);
break;
case SDL_WINDOWEVENT_CLOSE:
PL_Window_End();
return -1;
default:
break;
}
break;
#ifndef DX_NON_INPUT
case SDL_KEYDOWN:
PL_Input_HandleKeyDown(&event.key.keysym);
break;
case SDL_KEYUP:
PL_Input_HandleKeyUp(&event.key.keysym);
break;
case SDL_JOYDEVICEADDED:
PL_Input_AddController(event.jdevice.which);
break;
case SDL_JOYDEVICEREMOVED:
PL_Input_RemoveController(event.jdevice.which);
break;
case SDL_MOUSEWHEEL:
PL_Input_HandleWheelMotion(event.wheel.x, event.wheel.y);
break;
#endif /* #ifndef DX_NON_INPUT */
case SDL_QUIT:
return -1;
}
}
if (s_lacksFocus) {
if (s_alwaysRunFlag) {
s_lacksFocus = 0;
} else {
SDL_Delay(1);
}
}
} while (s_lacksFocus);
return 0;
}
static int lua_SDL_EnableScreenSaver(lutok::state& state){
SDL_EnableScreenSaver();
return 0;
}