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