void Window::restore() { if (window != nullptr) { SDL_RestoreWindow(window); updateSettings(settings, true); } }
void VID_Restore (void) { if (!sdl_window) return; SDL_RestoreWindow(sdl_window); SDL_RaiseWindow(sdl_window); }
bool SDLWindow::SetMinimized (bool minimized) { if (minimized) { SDL_MinimizeWindow (sdlWindow); } else { SDL_RestoreWindow (sdlWindow); } return minimized; }
void Window::SetFullScreen(bool value) { int mode = 0; if(value) { mode = SDL_WINDOW_FULLSCREEN_DESKTOP; SDL_MaximizeWindow(window); } else { SDL_RestoreWindow(window); mode = 0; } SDL_SetWindowFullscreen( window, mode); }
void GameWindow::set_state(GameWindow::WindowState state) { switch(state) { case WindowState::FULLSCREEN: SDL_SetWindowFullscreen(_handle,SDL_WINDOW_FULLSCREEN); break; case WindowState::MINIMIZED: SDL_MinimizeWindow(_handle); break; case WindowState::WINDOWED: SDL_RestoreWindow(_handle); SDL_SetWindowFullscreen(_handle,0); break; } _state = state; }
void VideoWrapper::setVideoMode(int width, int height, bool fullscreen, bool windowBorder) { SDL_SetWindowFullscreen(mWindow, 0); if (SDL_GetWindowFlags(mWindow) & SDL_WINDOW_MAXIMIZED) SDL_RestoreWindow(mWindow); if (fullscreen) { SDL_DisplayMode mode; SDL_GetWindowDisplayMode(mWindow, &mode); mode.w = width; mode.h = height; SDL_SetWindowDisplayMode(mWindow, &mode); SDL_SetWindowFullscreen(mWindow, fullscreen); } else { SDL_SetWindowSize(mWindow, width, height); SDL_SetWindowBordered(mWindow, windowBorder ? SDL_TRUE : SDL_FALSE); } }
GHOST_TSuccess GHOST_WindowSDL::setState(GHOST_TWindowState state) { switch (state) { case GHOST_kWindowStateNormal: SDL_SetWindowFullscreen(m_sdl_win, SDL_FALSE); SDL_RestoreWindow(m_sdl_win); break; case GHOST_kWindowStateMaximized: SDL_SetWindowFullscreen(m_sdl_win, SDL_FALSE); SDL_MaximizeWindow(m_sdl_win); break; case GHOST_kWindowStateMinimized: SDL_MinimizeWindow(m_sdl_win); break; case GHOST_kWindowStateFullScreen: SDL_SetWindowFullscreen(m_sdl_win, SDL_TRUE); break; default: break; } return GHOST_kSuccess; }
int DirectFB_WM_ProcessEvent(_THIS, SDL_Window * window, DFBWindowEvent * evt) { SDL_DFB_DEVICEDATA(_this); SDL_DFB_WINDOWDATA(window); DFB_WindowData *gwindata = ((devdata->grabbed_window) ? (DFB_WindowData *) ((devdata->grabbed_window)->driverdata) : NULL); IDirectFBWindow *dfbwin = windata->dfbwin; DFBWindowOptions wopts; if (!windata->is_managed) return 0; SDL_DFB_CHECK(dfbwin->GetOptions(dfbwin, &wopts)); switch (evt->type) { case DWET_BUTTONDOWN: if (evt->buttons & DIBM_LEFT) { int pos = WMPos(windata, evt->x, evt->y); switch (pos) { case WM_POS_NONE: return 0; case WM_POS_CLOSE: windata->wm_grab = WM_POS_NONE; SDL_SendWindowEvent(window, SDL_WINDOWEVENT_CLOSE, 0, 0); return 1; case WM_POS_MAX: windata->wm_grab = WM_POS_NONE; if (window->flags & SDL_WINDOW_MAXIMIZED) { SDL_RestoreWindow(window); } else { SDL_MaximizeWindow(window); } return 1; case WM_POS_CAPTION: if (!(wopts & DWOP_KEEP_STACKING)) { DirectFB_RaiseWindow(_this, window); } if (window->flags & SDL_WINDOW_MAXIMIZED) return 1; /* fall through */ default: windata->wm_grab = pos; if (gwindata != NULL) SDL_DFB_CHECK(gwindata->dfbwin->UngrabPointer(gwindata->dfbwin)); SDL_DFB_CHECK(dfbwin->GrabPointer(dfbwin)); windata->wm_lastx = evt->cx; windata->wm_lasty = evt->cy; } } return 1; case DWET_BUTTONUP: if (!windata->wm_grab) return 0; if (!(evt->buttons & DIBM_LEFT)) { if (windata->wm_grab & (WM_POS_RIGHT | WM_POS_BOTTOM)) { int dx = evt->cx - windata->wm_lastx; int dy = evt->cy - windata->wm_lasty; if (!(wopts & DWOP_KEEP_SIZE)) { int cw, ch; if ((windata->wm_grab & (WM_POS_BOTTOM | WM_POS_RIGHT)) == WM_POS_BOTTOM) dx = 0; else if ((windata->wm_grab & (WM_POS_BOTTOM | WM_POS_RIGHT)) == WM_POS_RIGHT) dy = 0; SDL_DFB_CHECK(dfbwin->GetSize(dfbwin, &cw, &ch)); /* necessary to trigger an event - ugly */ SDL_DFB_CHECK(dfbwin->DisableEvents(dfbwin, DWET_ALL)); SDL_DFB_CHECK(dfbwin->Resize(dfbwin, cw + dx + 1, ch + dy)); SDL_DFB_CHECK(dfbwin->EnableEvents(dfbwin, DWET_ALL)); SDL_DFB_CHECK(dfbwin->Resize(dfbwin, cw + dx, ch + dy)); } } SDL_DFB_CHECK(dfbwin->UngrabPointer(dfbwin)); if (gwindata != NULL) SDL_DFB_CHECK(gwindata->dfbwin->GrabPointer(gwindata->dfbwin)); windata->wm_grab = WM_POS_NONE; return 1; } break; case DWET_MOTION: if (!windata->wm_grab) return 0; if (evt->buttons & DIBM_LEFT) { int dx = evt->cx - windata->wm_lastx; int dy = evt->cy - windata->wm_lasty; if (windata->wm_grab & WM_POS_CAPTION) { if (!(wopts & DWOP_KEEP_POSITION)) SDL_DFB_CHECK(dfbwin->Move(dfbwin, dx, dy)); } if (windata->wm_grab & (WM_POS_RIGHT | WM_POS_BOTTOM)) { if (!(wopts & DWOP_KEEP_SIZE)) { int cw, ch; /* Make sure all events are disabled for this operation ! */ SDL_DFB_CHECK(dfbwin->DisableEvents(dfbwin, DWET_ALL)); if ((windata->wm_grab & (WM_POS_BOTTOM | WM_POS_RIGHT)) == WM_POS_BOTTOM) dx = 0; else if ((windata->wm_grab & (WM_POS_BOTTOM | WM_POS_RIGHT)) == WM_POS_RIGHT) dy = 0; SDL_DFB_CHECK(dfbwin->GetSize(dfbwin, &cw, &ch)); SDL_DFB_CHECK(dfbwin->Resize(dfbwin, cw + dx, ch + dy)); SDL_DFB_CHECK(dfbwin->EnableEvents(dfbwin, DWET_ALL)); } } windata->wm_lastx = evt->cx; windata->wm_lasty = evt->cy; return 1; } break; case DWET_KEYDOWN: break; case DWET_KEYUP: break; default: ; } return 0; }
void SDLTest_CommonEvent(SDLTest_CommonState * state, SDL_Event * event, int *done) { int i; if (state->verbose & VERBOSE_EVENT) { SDLTest_PrintEvent(event); } switch (event->type) { case SDL_WINDOWEVENT: switch (event->window.event) { case SDL_WINDOWEVENT_SIZE_CHANGED: { SDL_Window *window = SDL_GetWindowFromID(event->window.windowID); if (window) { for (i = 0; i < state->num_windows; ++i) { if (window == state->windows[i] && (state->window_flags & SDL_WINDOW_RESIZABLE)) { SDL_Rect viewport; viewport.x = 0; viewport.y = 0; SDL_GetWindowSize(window, &viewport.w, &viewport.h); SDL_RenderSetViewport(state->renderers[i], &viewport); } } } } break; case SDL_WINDOWEVENT_CLOSE: { SDL_Window *window = SDL_GetWindowFromID(event->window.windowID); if (window) { SDL_DestroyWindow(window); } } break; } break; case SDL_KEYDOWN: switch (event->key.keysym.sym) { /* Add hotkeys here */ case SDLK_PRINTSCREEN: { SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); if (window) { for (i = 0; i < state->num_windows; ++i) { if (window == state->windows[i]) { SDLTest_ScreenShot(state->renderers[i]); } } } } break; case SDLK_EQUALS: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrt-+ double the size of the window */ SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); if (window) { int w, h; SDL_GetWindowSize(window, &w, &h); SDL_SetWindowSize(window, w*2, h*2); } } break; case SDLK_MINUS: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrt-- double the size of the window */ SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); if (window) { int w, h; SDL_GetWindowSize(window, &w, &h); SDL_SetWindowSize(window, w/2, h/2); } } break; case SDLK_c: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-C copy awesome text! */ SDL_SetClipboardText("SDL rocks!\nYou know it!"); printf("Copied text to clipboard\n"); } break; case SDLK_v: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-V paste awesome text! */ char *text = SDL_GetClipboardText(); if (*text) { printf("Clipboard: %s\n", text); } else { printf("Clipboard is empty\n"); } SDL_free(text); } break; case SDLK_g: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-G toggle grab */ SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); if (window) { SDL_SetWindowGrab(window, !SDL_GetWindowGrab(window)); } } break; case SDLK_m: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-M maximize */ SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); if (window) { Uint32 flags = SDL_GetWindowFlags(window); if (flags & SDL_WINDOW_MAXIMIZED) { SDL_RestoreWindow(window); } else { SDL_MaximizeWindow(window); } } } break; case SDLK_r: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-R toggle mouse relative mode */ SDL_SetRelativeMouseMode(!SDL_GetRelativeMouseMode()); } break; case SDLK_z: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-Z minimize */ SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); if (window) { SDL_MinimizeWindow(window); } } break; case SDLK_RETURN: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-Enter toggle fullscreen */ SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); if (window) { Uint32 flags = SDL_GetWindowFlags(window); if (flags & SDL_WINDOW_FULLSCREEN) { SDL_SetWindowFullscreen(window, SDL_FALSE); } else { SDL_SetWindowFullscreen(window, SDL_TRUE); } } } break; case SDLK_b: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-B toggle window border */ SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); if (window) { const Uint32 flags = SDL_GetWindowFlags(window); const SDL_bool b = ((flags & SDL_WINDOW_BORDERLESS) != 0); SDL_SetWindowBordered(window, b); } } break; case SDLK_1: if (event->key.keysym.mod & KMOD_CTRL) { SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION, "Test Message", "You're awesome!", window); } break; case SDLK_ESCAPE: *done = 1; break; default: break; } break; case SDL_QUIT: *done = 1; break; } }
void twindow::restore() { SDL_RestoreWindow(window_); }
static SDL_assert_state SDL_PromptAssertion(const SDL_assert_data *data, void *userdata) { #ifdef __WIN32__ #define ENDLINE "\r\n" #else #define ENDLINE "\n" #endif const char *envr; SDL_assert_state state = SDL_ASSERTION_ABORT; SDL_Window *window; SDL_MessageBoxData messagebox; SDL_MessageBoxButtonData buttons[] = { { 0, SDL_ASSERTION_RETRY, "Retry" }, { 0, SDL_ASSERTION_BREAK, "Break" }, { 0, SDL_ASSERTION_ABORT, "Abort" }, { SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT, SDL_ASSERTION_IGNORE, "Ignore" }, { SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT, SDL_ASSERTION_ALWAYS_IGNORE, "Always Ignore" } }; char *message; int selected; (void) userdata; /* unused in default handler. */ message = SDL_stack_alloc(char, SDL_MAX_LOG_MESSAGE); if (!message) { /* Uh oh, we're in real trouble now... */ return SDL_ASSERTION_ABORT; } SDL_snprintf(message, SDL_MAX_LOG_MESSAGE, "Assertion failure at %s (%s:%d), triggered %u %s:" ENDLINE " '%s'", data->function, data->filename, data->linenum, data->trigger_count, (data->trigger_count == 1) ? "time" : "times", data->condition); debug_print("\n\n%s\n\n", message); /* let env. variable override, so unit tests won't block in a GUI. */ envr = SDL_getenv("SDL_ASSERT"); if (envr != NULL) { SDL_stack_free(message); if (SDL_strcmp(envr, "abort") == 0) { return SDL_ASSERTION_ABORT; } else if (SDL_strcmp(envr, "break") == 0) { return SDL_ASSERTION_BREAK; } else if (SDL_strcmp(envr, "retry") == 0) { return SDL_ASSERTION_RETRY; } else if (SDL_strcmp(envr, "ignore") == 0) { return SDL_ASSERTION_IGNORE; } else if (SDL_strcmp(envr, "always_ignore") == 0) { return SDL_ASSERTION_ALWAYS_IGNORE; } else { return SDL_ASSERTION_ABORT; /* oh well. */ } } /* Leave fullscreen mode, if possible (scary!) */ window = SDL_GetFocusWindow(); if (window) { if (SDL_GetWindowFlags(window) & SDL_WINDOW_FULLSCREEN) { SDL_MinimizeWindow(window); } else { /* !!! FIXME: ungrab the input if we're not fullscreen? */ /* No need to mess with the window */ window = NULL; } } /* Show a messagebox if we can, otherwise fall back to stdio */ SDL_zero(messagebox); messagebox.flags = SDL_MESSAGEBOX_WARNING; messagebox.window = window; messagebox.title = "Assertion Failed"; messagebox.message = message; messagebox.numbuttons = SDL_arraysize(buttons); messagebox.buttons = buttons; if (SDL_ShowMessageBox(&messagebox, &selected) == 0) { if (selected == -1) { state = SDL_ASSERTION_IGNORE; } else { state = (SDL_assert_state)selected; } } #ifdef HAVE_STDIO_H else { /* this is a little hacky. */ for ( ; ; ) { char buf[32]; fprintf(stderr, "Abort/Break/Retry/Ignore/AlwaysIgnore? [abriA] : "); fflush(stderr); if (fgets(buf, sizeof (buf), stdin) == NULL) { break; } if (SDL_strcmp(buf, "a") == 0) { state = SDL_ASSERTION_ABORT; break; } else if (SDL_strcmp(buf, "b") == 0) { state = SDL_ASSERTION_BREAK; break; } else if (SDL_strcmp(buf, "r") == 0) { state = SDL_ASSERTION_RETRY; break; } else if (SDL_strcmp(buf, "i") == 0) { state = SDL_ASSERTION_IGNORE; break; } else if (SDL_strcmp(buf, "A") == 0) { state = SDL_ASSERTION_ALWAYS_IGNORE; break; } } } #endif /* HAVE_STDIO_H */ /* Re-enter fullscreen mode */ if (window) { SDL_RestoreWindow(window); } SDL_stack_free(message); return state; }
void BasicWindow::Restore() { SDL_RestoreWindow(window); }
/** Native window should implement this function by performing the equivalent of the Win32 maximize operation */ void FLinuxWindow::Restore() { SDL_RestoreWindow( HWnd ); }
void restore() noexcept { SDL_RestoreWindow(ptr.get()); }
void Window::restore() { SDL_RestoreWindow(ptr); }
void CommonEvent(CommonState * state, SDL_Event * event, int *done) { int i; if (state->verbose & VERBOSE_EVENT) { PrintEvent(event); } switch (event->type) { case SDL_WINDOWEVENT: switch (event->window.event) { case SDL_WINDOWEVENT_CLOSE: *done = 1; break; } break; case SDL_KEYDOWN: switch (event->key.keysym.sym) { /* Add hotkeys here */ case SDLK_c: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-C copy awesome text! */ SDL_SetClipboardText("SDL rocks!\nYou know it!"); printf("Copied text to clipboard\n"); } break; case SDLK_v: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-V paste awesome text! */ char *text = SDL_GetClipboardText(); if (*text) { printf("Clipboard: %s\n", text); } else { printf("Clipboard is empty\n"); } SDL_free(text); } break; case SDLK_g: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-G toggle grab */ } break; case SDLK_m: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-M maximize */ /* FIXME: Which window has focus for this keyboard? */ for (i = 0; i < state->num_windows; ++i) { if (SDL_GetWindowFlags(state->windows[i]) & SDL_WINDOW_MAXIMIZED) { SDL_RestoreWindow(state->windows[i]); } else { SDL_MaximizeWindow(state->windows[i]); } } } break; case SDLK_z: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-Z minimize */ /* FIXME: Which window has focus for this keyboard? */ for (i = 0; i < state->num_windows; ++i) { SDL_MinimizeWindow(state->windows[i]); } } break; case SDLK_ESCAPE: *done = 1; break; default: break; } break; case SDL_QUIT: *done = 1; break; } }
void Window::Restore() { SDL_RestoreWindow(mWindow); }
/* **************************************** * * Event loop * **************************************** */ int PonscripterLabel::eventLoop() { SDL_Event event, tmp_event; /* Note, this rate can change if the window is dragged to a new screen or the monitor settings are changed while running. We do not handle either of these cases */ Uint32 refresh_delay = getRefreshRateDelay(); Uint32 last_refresh = 0, current_time; timer_event_flag = false; #ifdef WIN32 Uint32 win_flags; #endif queueRerender(); advancePhase(); // when we're on the first of a button-waiting frame (menu, etc), we snap mouse cursor to button when // using keyboard/gamecontroller to vastly improve the experience when using not using a mouse directly bool using_buttonbased_movement = true; // true to snap to main menu when it loads first_buttonwait_mode_frame = false; // if it's the first frame of a buttonwait (menu/choice), snap to default button SDL_GetMouseState(&last_mouse_x, &last_mouse_y); while (SDL_WaitEvent(&event)) { // ignore continous SDL_MOUSEMOTION while (event.type == SDL_MOUSEMOTION) { if (SDL_PeepEvents(&tmp_event, 1, SDL_PEEKEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT) == 0) break; // improve using keyboard/gamecontroller controls if ((last_mouse_x != ( (SDL_MouseButtonEvent *) &event)->x) || (last_mouse_y != ( (SDL_MouseButtonEvent *) &event)->y)) { using_buttonbased_movement = false; last_mouse_x = ( (SDL_MouseButtonEvent *) &event)->x; last_mouse_y = ( (SDL_MouseButtonEvent *) &event)->y; } if (tmp_event.type != SDL_MOUSEMOTION) break; SDL_PeepEvents(&tmp_event, 1, SDL_GETEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT); event = tmp_event; } switch (event.type) { case SDL_MOUSEMOTION: mouseMoveEvent((SDL_MouseMotionEvent*) &event); break; case SDL_MOUSEBUTTONDOWN: current_button_state.down_x = ( (SDL_MouseButtonEvent *) &event)->x; current_button_state.down_y = ( (SDL_MouseButtonEvent *) &event)->y; current_button_state.ignore_mouseup = false; if (!btndown_flag) break; case SDL_MOUSEBUTTONUP: mousePressEvent((SDL_MouseButtonEvent*) &event); break; case SDL_MOUSEWHEEL: mouseWheelEvent(&event.wheel); break; // NOTE: we reverse KEYUP and KEYDOWN for controller presses, because otherwise it feels really slow and junky // If necessary, we can make keyPressEvent actually interpret controller keys but this works fine for now case SDL_CONTROLLERBUTTONDOWN: using_buttonbased_movement = true; event.key.type = SDL_KEYUP; // printf("Controller button press: %s\n", SDL_GameControllerGetStringForButton((SDL_GameControllerButton)event.cbutton.button)); event.key.keysym.sym = transControllerButton(event.cbutton.button); if (event.key.keysym.sym == SDLK_UNKNOWN) break; event.key.keysym.sym = transKey(event.key.keysym.sym); keyDownEvent((SDL_KeyboardEvent*) &event); keyPressEvent((SDL_KeyboardEvent*) &event); break; case SDL_CONTROLLERBUTTONUP: using_buttonbased_movement = true; event.key.type = SDL_KEYDOWN; // printf("Controller button release: %s\n", SDL_GameControllerGetStringForButton((SDL_GameControllerButton)event.cbutton.button)); event.key.keysym.sym = transControllerButton(event.cbutton.button); if (event.key.keysym.sym == SDLK_UNKNOWN) break; event.key.keysym.sym = transKey(event.key.keysym.sym); keyUpEvent((SDL_KeyboardEvent*) &event); if (btndown_flag) keyPressEvent((SDL_KeyboardEvent*) &event); break; case SDL_JOYBUTTONDOWN: using_buttonbased_movement = true; event.key.type = SDL_KEYDOWN; event.key.keysym.sym = transJoystickButton(event.jbutton.button); if (event.key.keysym.sym == SDLK_UNKNOWN) break; case SDL_KEYDOWN: if ((event.key.keysym.sym == SDLK_UP) || (event.key.keysym.sym == SDLK_DOWN) || (event.key.keysym.sym == SDLK_LEFT) || (event.key.keysym.sym == SDLK_RIGHT)) using_buttonbased_movement = true; event.key.keysym.sym = transKey(event.key.keysym.sym); keyDownEvent((SDL_KeyboardEvent*) &event); if (btndown_flag) keyPressEvent((SDL_KeyboardEvent*) &event); break; case SDL_JOYBUTTONUP: using_buttonbased_movement = true; event.key.type = SDL_KEYUP; event.key.keysym.sym = transJoystickButton(event.jbutton.button); if (event.key.keysym.sym == SDLK_UNKNOWN) break; case SDL_KEYUP: event.key.keysym.sym = transKey(event.key.keysym.sym); keyUpEvent((SDL_KeyboardEvent*) &event); keyPressEvent((SDL_KeyboardEvent*) &event); break; case SDL_JOYAXISMOTION: { SDL_KeyboardEvent ke = transJoystickAxis(event.jaxis); if (ke.keysym.sym != SDLK_UNKNOWN) { if (ke.type == SDL_KEYDOWN) { keyDownEvent(&ke); if (btndown_flag) keyPressEvent(&ke); } else if (ke.type == SDL_KEYUP) { keyUpEvent(&ke); keyPressEvent(&ke); } } break; } case ONS_SOUND_EVENT: case ONS_FADE_EVENT: case ONS_MIDI_EVENT: case ONS_MUSIC_EVENT: flushEventSub(event); break; case INTERNAL_REDRAW_EVENT: /* Handle cursor shifting for controller/keyboard button-based movement */ if (first_buttonwait_mode_frame && using_buttonbased_movement && buttons.size() > 1) { shiftCursorOnButton(0); } if (event_mode & WAIT_BUTTON_MODE) first_buttonwait_mode_frame = true; else if (first_buttonwait_mode_frame) first_buttonwait_mode_frame = false; /* Stop rerendering while minimized; wait for the restore event + queueRerender */ if(minimized_flag) { break; } current_time = SDL_GetTicks(); if((current_time - last_refresh) >= refresh_delay || last_refresh == 0) { /* It has been longer than the refresh delay since we last started a refresh. Start another */ last_refresh = current_time; rerender(); /* Refresh time since rerender does take some odd ms */ current_time = SDL_GetTicks(); } SDL_PumpEvents(); /* Remove all pending redraw events on the queue */ while(SDL_PeepEvents(&tmp_event, 1, SDL_GETEVENT, INTERNAL_REDRAW_EVENT, INTERNAL_REDRAW_EVENT) == 1) ; /* If there are any events on the queue, re-add us and let it get those events asap. * It'll then come back to us with no events and we'll just sleep until it's time to redraw again. * If there are no events, sleep right away */ if(SDL_PeepEvents(&tmp_event, 1, SDL_PEEKEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT) == 0) { if(timer_event_flag && timer_event_time <= current_time) { timer_event_flag = false; timerEvent(); } else if(last_refresh <= current_time && refresh_delay >= (current_time - last_refresh)) { SDL_Delay(std::min(refresh_delay / 3, refresh_delay - (current_time - last_refresh))); } } tmp_event.type = INTERNAL_REDRAW_EVENT; SDL_PushEvent(&tmp_event); break; case ONS_WAVE_EVENT: flushEventSub(event); //printf("ONS_WAVE_EVENT %d: %x %d %x\n", event.user.code, wave_sample[0], automode_flag, event_mode); if (event.user.code != 0 || !(event_mode & WAIT_VOICE_MODE)) break; if (remaining_time <= 0) { event_mode &= ~WAIT_VOICE_MODE; if (automode_flag) current_button_state.button = 0; else if (usewheel_flag) current_button_state.button = -5; else current_button_state.button = -2; stopAnimation(clickstr_state); advancePhase(); } break; case SDL_WINDOWEVENT: switch(event.window.event) { case SDL_WINDOWEVENT_FOCUS_LOST: break; case SDL_WINDOWEVENT_FOCUS_GAINED: /* See comment below under RESIZED */ SDL_PumpEvents(); SDL_PeepEvents(&tmp_event, 1, SDL_GETEVENT, SDL_MOUSEBUTTONDOWN, SDL_MOUSEBUTTONDOWN); current_button_state.ignore_mouseup = true; #ifdef WIN32 win_flags = SDL_GetWindowFlags(screen); /* Work around: https://bugzilla.libsdl.org/show_bug.cgi?id=2510 * * On windows, the RESTORED event does not occur when you restore a * maximized event. The only events you get are a ton of exposes and * this one. The screen also remains black if it was maximized until * the window is "restored". */ SDL_RestoreWindow(screen); if(win_flags & SDL_WINDOW_FULLSCREEN_DESKTOP) { SDL_SetWindowFullscreen(screen, SDL_WINDOW_FULLSCREEN_DESKTOP); } else if(win_flags & SDL_WINDOW_FULLSCREEN) { SDL_SetWindowFullscreen(screen, SDL_WINDOW_FULLSCREEN); } else if(win_flags & SDL_WINDOW_MAXIMIZED) { SDL_MaximizeWindow(screen); } #endif break; case SDL_WINDOWEVENT_MAXIMIZED: case SDL_WINDOWEVENT_RESIZED: /* Due to what I suspect is an SDL bug, you get a mosuedown + * mouseup event when you maximize the window by double * clicking the titlebar in windows. These events both have * coordinates inside of the screen, and I can't see any way * to tell them apart from legitimate clicks. (it even triggers * a mouse move event). * To fix this bug, we kill any mousedown events when we maximize. * Note, we do this under RESIZED too because if you do a * "vertical maximize" (double click with the upper resize arrow) * that doesn't trigger a maximized event */ SDL_PumpEvents(); SDL_PeepEvents(&tmp_event, 1, SDL_GETEVENT, SDL_MOUSEBUTTONDOWN, SDL_MOUSEBUTTONDOWN); current_button_state.ignore_mouseup = true; case SDL_WINDOWEVENT_RESTORED: case SDL_WINDOWEVENT_SHOWN: case SDL_WINDOWEVENT_EXPOSED: /* If we weren't minimized, a rerender is already queued */ if(minimized_flag) { minimized_flag = false; queueRerender(); } break; case SDL_WINDOWEVENT_MINIMIZED: case SDL_WINDOWEVENT_HIDDEN: minimized_flag = true; break; } break; case SDL_QUIT: endCommand("end"); break; default: break; } } return -1; }
static SDL_assert_state SDL_PromptAssertion(const SDL_assert_data *data, void *userdata) { const char *envr; SDL_assert_state state = SDL_ASSERTION_ABORT; SDL_Window *window; (void) userdata; /* unused in default handler. */ debug_print("\n\n" "Assertion failure at %s (%s:%d), triggered %u time%s:\n" " '%s'\n" "\n", data->function, data->filename, data->linenum, data->trigger_count, (data->trigger_count == 1) ? "" : "s", data->condition); /* let env. variable override, so unit tests won't block in a GUI. */ envr = SDL_getenv("SDL_ASSERT"); if (envr != NULL) { if (SDL_strcmp(envr, "abort") == 0) { return SDL_ASSERTION_ABORT; } else if (SDL_strcmp(envr, "break") == 0) { return SDL_ASSERTION_BREAK; } else if (SDL_strcmp(envr, "retry") == 0) { return SDL_ASSERTION_RETRY; } else if (SDL_strcmp(envr, "ignore") == 0) { return SDL_ASSERTION_IGNORE; } else if (SDL_strcmp(envr, "always_ignore") == 0) { return SDL_ASSERTION_ALWAYS_IGNORE; } else { return SDL_ASSERTION_ABORT; /* oh well. */ } } /* Leave fullscreen mode, if possible (scary!) */ window = SDL_GetFocusWindow(); if (window) { if (SDL_GetWindowFlags(window) & SDL_WINDOW_FULLSCREEN) { SDL_MinimizeWindow(window); } else { /* !!! FIXME: ungrab the input if we're not fullscreen? */ /* No need to mess with the window */ window = 0; } } /* platform-specific UI... */ #ifdef __WIN32__ state = SDL_PromptAssertion_windows(data); #elif __MACOSX__ /* This has to be done in an Objective-C (*.m) file, so we call out. */ extern SDL_assert_state SDL_PromptAssertion_cocoa(const SDL_assert_data *); state = SDL_PromptAssertion_cocoa(data); #else /* this is a little hacky. */ for ( ; ; ) { char buf[32]; fprintf(stderr, "Abort/Break/Retry/Ignore/AlwaysIgnore? [abriA] : "); fflush(stderr); if (fgets(buf, sizeof (buf), stdin) == NULL) { break; } if (SDL_strcmp(buf, "a") == 0) { state = SDL_ASSERTION_ABORT; break; } else if (SDL_strcmp(envr, "b") == 0) { state = SDL_ASSERTION_BREAK; break; } else if (SDL_strcmp(envr, "r") == 0) { state = SDL_ASSERTION_RETRY; break; } else if (SDL_strcmp(envr, "i") == 0) { state = SDL_ASSERTION_IGNORE; break; } else if (SDL_strcmp(envr, "A") == 0) { state = SDL_ASSERTION_ALWAYS_IGNORE; break; } } #endif /* Re-enter fullscreen mode */ if (window) { SDL_RestoreWindow(window); } return state; }
void Window::restore() { SDL_RestoreWindow(this->window); }
void Window::restore() const { SDL_RestoreWindow(_wnd); }
void CommonEvent(CommonState * state, SDL_Event * event, int *done) { int i; if (state->verbose & VERBOSE_EVENT) { PrintEvent(event); } switch (event->type) { case SDL_WINDOWEVENT: switch (event->window.event) { case SDL_WINDOWEVENT_CLOSE: { SDL_Window *window = SDL_GetWindowFromID(event->window.windowID); if (window) { SDL_DestroyWindow(window); } } break; } break; case SDL_KEYDOWN: switch (event->key.keysym.sym) { /* Add hotkeys here */ case SDLK_PRINTSCREEN: { SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); if (window) { for (i = 0; i < state->num_windows; ++i) { if (window == state->windows[i]) { ScreenShot(state->renderers[i]); } } } } break; case SDLK_c: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-C copy awesome text! */ SDL_SetClipboardText("SDL rocks!\nYou know it!"); printf("Copied text to clipboard\n"); } break; case SDLK_v: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-V paste awesome text! */ char *text = SDL_GetClipboardText(); if (*text) { printf("Clipboard: %s\n", text); } else { printf("Clipboard is empty\n"); } SDL_free(text); } break; case SDLK_g: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-G toggle grab */ SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); if (window) { SDL_SetWindowGrab(window, !SDL_GetWindowGrab(window)); } } break; case SDLK_m: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-M maximize */ SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); if (window) { Uint32 flags = SDL_GetWindowFlags(window); if (flags & SDL_WINDOW_MAXIMIZED) { SDL_RestoreWindow(window); } else { SDL_MaximizeWindow(window); } } } break; case SDLK_r: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-R toggle mouse relative mode */ SDL_SetRelativeMouseMode(!SDL_GetRelativeMouseMode()); } break; case SDLK_z: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-Z minimize */ SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); if (window) { SDL_MinimizeWindow(window); } } break; case SDLK_RETURN: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-Enter toggle fullscreen */ SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); if (window) { Uint32 flags = SDL_GetWindowFlags(window); if (flags & SDL_WINDOW_FULLSCREEN) { SDL_SetWindowFullscreen(window, SDL_FALSE); } else { SDL_SetWindowFullscreen(window, SDL_TRUE); } } } break; case SDLK_ESCAPE: *done = 1; break; default: break; } break; case SDL_QUIT: *done = 1; break; } }
static void IN_ProcessEvents(void) { SDL_Event e; keyNum_t key = 0; static keyNum_t lastKeyDown = 0; if (!SDL_WasInit(SDL_INIT_VIDEO)) { return; } while (SDL_PollEvent(&e)) { switch (e.type) { case SDL_KEYDOWN: if (e.key.repeat && Key_GetCatcher() == 0) { break; } if ((key = IN_TranslateSDLToQ3Key(&e.key.keysym, qtrue))) { Com_QueueEvent(0, SE_KEY, key, qtrue, 0, NULL); if (key == K_BACKSPACE) { // This was added to keep mod comp, mods do not check K_BACKSPACE but instead use char 8 which is backspace in ascii // 8 == CTRL('h') == BS aka Backspace from ascii table Com_QueueEvent(0, SE_CHAR, CTRL('h'), 0, 0, NULL); } else if (keys[K_CTRL].down && key >= 'a' && key <= 'z') { Com_QueueEvent(0, SE_CHAR, CTRL(key), 0, 0, NULL); } } lastKeyDown = key; break; case SDL_KEYUP: if ((key = IN_TranslateSDLToQ3Key(&e.key.keysym, qfalse))) { Com_QueueEvent(0, SE_KEY, key, qfalse, 0, NULL); } lastKeyDown = 0; break; case SDL_TEXTINPUT: if (lastKeyDown != K_CONSOLE) { char *c = e.text.text; // Quick and dirty UTF-8 to UTF-32 conversion while (*c) { int utf32 = 0; if ((*c & 0x80) == 0) { utf32 = *c++; } else if ((*c & 0xE0) == 0xC0) // 110x xxxx { utf32 |= (*c++ & 0x1F) << 6; utf32 |= (*c++ & 0x3F); } else if ((*c & 0xF0) == 0xE0) // 1110 xxxx { utf32 |= (*c++ & 0x0F) << 12; utf32 |= (*c++ & 0x3F) << 6; utf32 |= (*c++ & 0x3F); } else if ((*c & 0xF8) == 0xF0) // 1111 0xxx { utf32 |= (*c++ & 0x07) << 18; utf32 |= (*c++ & 0x3F) << 12; utf32 |= (*c++ & 0x3F) << 6; utf32 |= (*c++ & 0x3F); } else { Com_DPrintf("Unrecognised UTF-8 lead byte: 0x%x\n", (unsigned int)*c); c++; } if (utf32 != 0) { if (IN_IsConsoleKey(0, utf32)) { Com_QueueEvent(0, SE_KEY, K_CONSOLE, qtrue, 0, NULL); Com_QueueEvent(0, SE_KEY, K_CONSOLE, qfalse, 0, NULL); } else { Com_QueueEvent(0, SE_CHAR, utf32, 0, 0, NULL); } } } } break; case SDL_MOUSEMOTION: if (mouseActive) { if (!e.motion.xrel && !e.motion.yrel) { break; } Com_QueueEvent(0, SE_MOUSE, e.motion.xrel, e.motion.yrel, 0, NULL); } break; case SDL_MOUSEBUTTONDOWN: case SDL_MOUSEBUTTONUP: { int b; switch (e.button.button) { case SDL_BUTTON_LEFT: b = K_MOUSE1; break; case SDL_BUTTON_MIDDLE: b = K_MOUSE3; break; case SDL_BUTTON_RIGHT: b = K_MOUSE2; break; case SDL_BUTTON_X1: b = K_MOUSE4; break; case SDL_BUTTON_X2: b = K_MOUSE5; break; default: b = K_AUX1 + (e.button.button - SDL_BUTTON_X2 + 1) % 16; break; } Com_QueueEvent(0, SE_KEY, b, (e.type == SDL_MOUSEBUTTONDOWN ? qtrue : qfalse), 0, NULL); } break; case SDL_MOUSEWHEEL: if (e.wheel.y > 0) { Com_QueueEvent(0, SE_KEY, K_MWHEELUP, qtrue, 0, NULL); Com_QueueEvent(0, SE_KEY, K_MWHEELUP, qfalse, 0, NULL); } else if (e.wheel.y < 0) { Com_QueueEvent(0, SE_KEY, K_MWHEELDOWN, qtrue, 0, NULL); Com_QueueEvent(0, SE_KEY, K_MWHEELDOWN, qfalse, 0, NULL); } break; case SDL_QUIT: Cbuf_ExecuteText(EXEC_NOW, "quit Closed window\n"); break; case SDL_WINDOWEVENT: switch (e.window.event) { case SDL_WINDOWEVENT_RESIZED: IN_WindowResize(&e); break; case SDL_WINDOWEVENT_MINIMIZED: Cvar_SetValue("com_minimized", 1); break; case SDL_WINDOWEVENT_RESTORED: case SDL_WINDOWEVENT_MAXIMIZED: Cvar_SetValue("com_minimized", 0); break; case SDL_WINDOWEVENT_FOCUS_LOST: // disabled for now (causes issues with vid_restart //IN_WindowFocusLost(); case SDL_WINDOWEVENT_LEAVE: Key_ClearStates(); Cvar_SetValue("com_unfocused", 1); break; case SDL_WINDOWEVENT_ENTER: case SDL_WINDOWEVENT_FOCUS_GAINED: { Cvar_SetValue("com_unfocused", 0); if (com_minimized->integer) { SDL_RestoreWindow(mainScreen); } #ifdef DISABLE_DINGY IN_EnableDingFilter(); #endif } break; } break; default: break; } } }
/* ================= CL_ConnectionlessPacket Responses to broadcasts, etc ================= */ void CL_ConnectionlessPacket( netadr_t from, sizebuf_t *msg ) { char *args; char *c, buf[MAX_SYSPATH]; int len = sizeof( buf ), i = 0; netadr_t servadr; BF_Clear( msg ); BF_ReadLong( msg ); // skip the -1 args = BF_ReadStringLine( msg ); Cmd_TokenizeString( args ); c = Cmd_Argv( 0 ); MsgDev( D_NOTE, "CL_ConnectionlessPacket: %s : %s\n", NET_AdrToString( from ), c ); // server connection if( !Q_strcmp( c, "client_connect" )) { if( cls.state == ca_connected ) { MsgDev( D_INFO, "Dup connect received. Ignored.\n"); return; } Netchan_Setup( NS_CLIENT, &cls.netchan, from, net_qport->integer); BF_WriteByte( &cls.netchan.message, clc_stringcmd ); BF_WriteString( &cls.netchan.message, "new" ); cls.state = ca_connected; cl.validsequence = 0; // haven't gotten a valid frame update yet cl.delta_sequence = -1; // we'll request a full delta from the baseline cls.lastoutgoingcommand = -1; // we don't have a backed up cmd history yet cls.nextcmdtime = host.realtime; // we can send a cmd right away CL_StartupDemoHeader (); } else if( !Q_strcmp( c, "info" )) { // server responding to a status broadcast CL_ParseStatusMessage( from, msg ); } else if( !Q_strcmp( c, "netinfo" )) { // server responding to a status broadcast CL_ParseNETInfoMessage( from, msg ); } else if( !Q_strcmp( c, "cmd" )) { // remote command from gui front end if( !NET_IsLocalAddress( from )) { Msg( "Command packet from remote host. Ignored.\n" ); return; } #ifdef XASH_SDL SDL_RestoreWindow( host.hWnd ); #endif args = BF_ReadString( msg ); Cbuf_AddText( args ); Cbuf_AddText( "\n" ); } else if( !Q_strcmp( c, "print" )) { // print command from somewhere Msg("remote: %s\n", BF_ReadString( msg ) ); } else if( !Q_strcmp( c, "ping" )) { // ping from somewhere Netchan_OutOfBandPrint( NS_CLIENT, from, "ack" ); } else if( !Q_strcmp( c, "challenge" )) { // challenge from the server we are connecting to cls.challenge = Q_atoi( Cmd_Argv( 1 )); CL_SendConnectPacket(); return; } else if( !Q_strcmp( c, "echo" )) { // echo request from server Netchan_OutOfBandPrint( NS_CLIENT, from, "%s", Cmd_Argv( 1 )); } else if( !Q_strcmp( c, "disconnect" )) { // a disconnect message from the server, which will happen if the server // dropped the connection but it is still getting packets from us CL_Disconnect(); CL_ClearEdicts(); } else if( !Q_strcmp( c, "f") ) { // serverlist got from masterserver while( !msg->bOverflow ) { servadr.type = NA_IP; // 4 bytes for IP BF_ReadBytes( msg, servadr.ip, sizeof( servadr.ip )); // 2 bytes for Port servadr.port = BF_ReadShort( msg ); if( !servadr.port ) break; MsgDev( D_INFO, "Found server: %s\n", NET_AdrToString( servadr )); NET_Config( true ); // allow remote Netchan_OutOfBandPrint( NS_CLIENT, servadr, "info %i", PROTOCOL_VERSION ); } // execute at next frame preventing relation on fps Cbuf_AddText("menu_resetping\n"); } else if( clgame.dllFuncs.pfnConnectionlessPacket( &from, args, buf, &len )) { // user out of band message (must be handled in CL_ConnectionlessPacket) if( len > 0 ) Netchan_OutOfBand( NS_SERVER, from, len, (byte *)buf ); } else MsgDev( D_ERROR, "Bad connectionless packet from %s:\n%s\n", NET_AdrToString( from ), args ); }
void SDLTest_CommonEvent(SDLTest_CommonState * state, SDL_Event * event, int *done) { int i; static SDL_MouseMotionEvent lastEvent; if (state->verbose & VERBOSE_EVENT) { SDLTest_PrintEvent(event); } switch (event->type) { case SDL_WINDOWEVENT: switch (event->window.event) { case SDL_WINDOWEVENT_CLOSE: { SDL_Window *window = SDL_GetWindowFromID(event->window.windowID); if (window) { SDL_DestroyWindow(window); } } break; } break; case SDL_KEYDOWN: switch (event->key.keysym.sym) { /* Add hotkeys here */ case SDLK_PRINTSCREEN: { SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); if (window) { for (i = 0; i < state->num_windows; ++i) { if (window == state->windows[i]) { SDLTest_ScreenShot(state->renderers[i]); } } } } break; case SDLK_EQUALS: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-+ double the size of the window */ SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); if (window) { int w, h; SDL_GetWindowSize(window, &w, &h); SDL_SetWindowSize(window, w*2, h*2); } } break; case SDLK_MINUS: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-- half the size of the window */ SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); if (window) { int w, h; SDL_GetWindowSize(window, &w, &h); SDL_SetWindowSize(window, w/2, h/2); } } break; case SDLK_c: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-C copy awesome text! */ SDL_SetClipboardText("SDL rocks!\nYou know it!"); printf("Copied text to clipboard\n"); } if (event->key.keysym.mod & KMOD_ALT) { /* Alt-C toggle a render clip rectangle */ for (i = 0; i < state->num_windows; ++i) { int w, h; if (state->renderers[i]) { SDL_Rect clip; SDL_GetWindowSize(state->windows[i], &w, &h); SDL_RenderGetClipRect(state->renderers[i], &clip); if (SDL_RectEmpty(&clip)) { clip.x = w/4; clip.y = h/4; clip.w = w/2; clip.h = h/2; SDL_RenderSetClipRect(state->renderers[i], &clip); } else { SDL_RenderSetClipRect(state->renderers[i], NULL); } } } } break; case SDLK_v: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-V paste awesome text! */ char *text = SDL_GetClipboardText(); if (*text) { printf("Clipboard: %s\n", text); } else { printf("Clipboard is empty\n"); } SDL_free(text); } break; case SDLK_g: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-G toggle grab */ SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); if (window) { SDL_SetWindowGrab(window, !SDL_GetWindowGrab(window) ? SDL_TRUE : SDL_FALSE); } } break; case SDLK_m: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-M maximize */ SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); if (window) { Uint32 flags = SDL_GetWindowFlags(window); if (flags & SDL_WINDOW_MAXIMIZED) { SDL_RestoreWindow(window); } else { SDL_MaximizeWindow(window); } } } break; case SDLK_r: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-R toggle mouse relative mode */ SDL_SetRelativeMouseMode(!SDL_GetRelativeMouseMode() ? SDL_TRUE : SDL_FALSE); } break; case SDLK_z: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-Z minimize */ SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); if (window) { SDL_MinimizeWindow(window); } } break; case SDLK_RETURN: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-Enter toggle fullscreen */ SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); if (window) { Uint32 flags = SDL_GetWindowFlags(window); if (flags & SDL_WINDOW_FULLSCREEN) { SDL_SetWindowFullscreen(window, SDL_FALSE); } else { SDL_SetWindowFullscreen(window, SDL_TRUE); } } } else if (event->key.keysym.mod & KMOD_ALT) { /* Alt-Enter toggle fullscreen desktop */ SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); if (window) { Uint32 flags = SDL_GetWindowFlags(window); if (flags & SDL_WINDOW_FULLSCREEN) { SDL_SetWindowFullscreen(window, SDL_FALSE); } else { SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP); } } } break; case SDLK_b: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-B toggle window border */ SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); if (window) { const Uint32 flags = SDL_GetWindowFlags(window); const SDL_bool b = ((flags & SDL_WINDOW_BORDERLESS) != 0) ? SDL_TRUE : SDL_FALSE; SDL_SetWindowBordered(window, b); } } break; case SDLK_0: if (event->key.keysym.mod & KMOD_CTRL) { SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION, "Test Message", "You're awesome!", window); } break; case SDLK_1: if (event->key.keysym.mod & KMOD_CTRL) { FullscreenTo(0, event->key.windowID); } break; case SDLK_2: if (event->key.keysym.mod & KMOD_CTRL) { FullscreenTo(1, event->key.windowID); } break; case SDLK_ESCAPE: *done = 1; break; case SDLK_SPACE: { char message[256]; SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); SDL_snprintf(message, sizeof(message), "(%i, %i), rel (%i, %i)\n", lastEvent.x, lastEvent.y, lastEvent.xrel, lastEvent.yrel); SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION, "Last mouse position", message, window); break; } default: break; } break; case SDL_QUIT: *done = 1; break; case SDL_MOUSEMOTION: lastEvent = event->motion; break; } }
int inline Window::restore(State & state, SDL_Window * window){ SDL_RestoreWindow(window); return 0; }