void Window::maximize()
{
if(isLoaded())
SDL_MaximizeWindow(win);
removeInitFlags(MINIMIZED);
addInitFlags(MAXIMIZED);
}
void BaseManager::setWindowMaximized(bool _value)
{
if (mWindow != nullptr && _value)
{
SDL_MaximizeWindow(mWindow);
}
}
void Graphics::Maximize()
{
if (!window_)
return;
SDL_MaximizeWindow(window_);
}
void Window::maximize()
{
if (window != nullptr)
{
SDL_MaximizeWindow(window);
updateSettings(settings, true);
}
}
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);
}
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;
}
void Display::maximizeWindow(){
SDL_MaximizeWindow(m_window);
}
void Window::maximize()
{
SDL_MaximizeWindow(this->window);
}
void twindow::maximize()
{
SDL_MaximizeWindow(window_);
}
void Window::maximize() const {
SDL_MaximizeWindow(_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;
}
}
void maximise() noexcept {
SDL_MaximizeWindow(ptr.get());
}
// Callback function: converts (partially) decoded image/animation to a/several SDL_Texture(s),
// resizes the viewer window if needed, and calls draw_image()
// Input arguments are: quality (0..10000), current position in the .flif file
// Output is the desired minimal quality before doing the next callback
uint32_t progressive_render(int32_t quality, int64_t bytes_read) {
loading = 1;
while (drawing) {SDL_Delay(50);} // don't touch the textures until we're done drawing
printf("%lli bytes read, rendering at quality=%.2f%%\n",(long long int) bytes_read, 0.01*quality);
FLIF_IMAGE* image = flif_decoder_get_image(d, 0);
if (!image) { printf("Error: No decoded image found\n"); return 1; }
uint32_t w = flif_image_get_width(image);
uint32_t h = flif_image_get_height(image);
// set the window title and size
if (!window) { printf("Error: Could not create window\n"); return 2; }
char title[100];
sprintf(title,"FLIF image decoded at %ix%i [read %lli bytes, quality=%.2f%%]",w,h,(long long int) bytes_read, 0.01*quality);
SDL_SetWindowTitle(window,title);
if (!window_size_set) {
int ww = (w > dm.w ? dm.w : w);
int wh = (h > dm.h ? dm.h : h);
if (ww > w * wh / h) ww = wh * w / h;
else if (ww < w * wh / h) wh = ww * h / w;
if (w > dm.w*8/10 && h > dm.h*8/10) { ww = ww*8/10; wh = wh*8/10; }
SDL_SetWindowSize(window,ww,wh);
SDL_SetWindowPosition(window,SDL_WINDOWPOS_CENTERED,SDL_WINDOWPOS_CENTERED);
if (w > dm.w*8/10 && h > dm.h*8/10) { SDL_MaximizeWindow(window); }
window_size_set = 1;
}
// allocate enough room for the texture pointers and frame delays
if (!image_frame) image_frame = calloc(flif_decoder_num_images(d), sizeof(FLIF_IMAGE*));
if (!frame_delay) frame_delay = calloc(flif_decoder_num_images(d), sizeof(int));
// produce one SDL_Texture per frame
for (int f = 0; f < flif_decoder_num_images(d); f++) {
if (quit) return 0;
FLIF_IMAGE* image = flif_decoder_get_image(d, f);
if (!image) { printf("Error: No decoded image found\n"); return 1; }
frame_delay[f] = flif_image_get_frame_delay(image);
// Copy the decoded pixels to a temporary surface
if (!tmpsurf) tmpsurf = SDL_CreateRGBSurface(0,w,h,32,0x000000FF,0x0000FF00,0x00FF0000,0xFF000000);
if (!tmpsurf) { printf("Error: Could not create surface\n"); return 1; }
char* pp =(char*) tmpsurf->pixels;
for (uint32_t r=0; r<h; r++) {
flif_image_read_row_RGBA8(image, r, pp, w * sizeof(RGBA));
pp += tmpsurf->pitch;
}
// Draw checkerboard background for image/animation with alpha channel
if (flif_image_get_nb_channels(image) > 3) {
if (!bgsurf) bgsurf = SDL_CreateRGBSurface(0,w,h,32,0x000000FF,0x0000FF00,0x00FF0000,0xFF000000);
if (!bgsurf) { printf("Error: Could not create surface\n"); return 1; }
SDL_Rect sq; sq.w=20; sq.h=20;
for (sq.y=0; sq.y<h; sq.y+=sq.h) for (sq.x=0; sq.x<w; sq.x+=sq.w)
SDL_FillRect(bgsurf,&sq,((sq.y/sq.h + sq.x/sq.w)&1 ? 0xFF606060 : 0xFFA0A0A0));
// Alpha-blend decoded frame on top of checkerboard background
SDL_BlitSurface(tmpsurf,NULL,bgsurf,NULL);
SDL_FreeSurface(tmpsurf); tmpsurf = bgsurf; bgsurf = NULL;
}
if (!renderer) { printf("Error: Could not get renderer\n"); return 1; }
if (image_frame[f]) SDL_DestroyTexture(image_frame[f]);
// Convert the surface to a texture (for accelerated blitting)
image_frame[f] = SDL_CreateTextureFromSurface(renderer, tmpsurf);
if (!image_frame[f]) { printf("Could not create texture!\n"); quit=1; return 0; }
SDL_SetTextureBlendMode(image_frame[f],SDL_BLENDMODE_NONE);
}
SDL_FreeSurface(tmpsurf); tmpsurf=NULL;
loading = 0;
draw_image();
// setting nb_frames to a value > 1 will make sure the main thread keeps calling draw_image()
nb_frames = flif_decoder_num_images(d);
if (quit) return 0; // stop decoding
return quality + 1000; // call me back when you have at least 10.00% better quality
}
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 LWindow::maximize() {
if(!isMinimised()) {
SDL_MaximizeWindow(mWindow);
mMinimised = false;
}
}
void BasicWindow::Maximize()
{
SDL_MaximizeWindow(window);
}
void Engine_Maximize()
{
SDL_MaximizeWindow(window);
}
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::Maximize()
{
SDL_MaximizeWindow(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;
}
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;
}
/** Native window should implement this function by performing the equivalent of the Win32 maximize operation */
void FLinuxWindow::Maximize()
{
SDL_MaximizeWindow( HWnd );
}
void ZWindow::SetMaximize()
{
SDL_MaximizeWindow(m_win);
}
void Window::Maximize() {
SDL_MaximizeWindow(m_sdl_window);
}
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::maximize(State & state, SDL_Window * window){
SDL_MaximizeWindow(window);
return 0;
}
