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;
}
