static void FreeResources(void) { if(g_glcontext) { SDL_GL_DeleteContext(g_glcontext); g_glcontext = NULL; } if(g_renderer) { SDL_DestroyRenderer(g_renderer); g_renderer = NULL; } if(g_texture) { SDL_DestroyTexture(g_texture); g_texture = NULL; } if(g_screen) { SDL_FreeSurface(g_screen); g_screen = NULL; } if(g_window) { SDL_GetWindowPosition(g_window, &g_lastx, &g_lasty); SDL_DestroyWindow(g_window); g_window = NULL; } }
void InputWrapper::handleWindowEvent(const SDL_Event& evt) { switch (evt.window.event) { case SDL_WINDOWEVENT_ENTER: mMouseInWindow = true; updateMouseSettings(); break; case SDL_WINDOWEVENT_LEAVE: mMouseInWindow = false; updateMouseSettings(); break; case SDL_WINDOWEVENT_MOVED: // I'm not sure what OSG is using the window position for, but I don't think it's needed, // so we ignore window moved events (improves window movement performance) break; case SDL_WINDOWEVENT_SIZE_CHANGED: int w,h; SDL_GetWindowSize(mSDLWindow, &w, &h); int x,y; SDL_GetWindowPosition(mSDLWindow, &x,&y); mViewer->getCamera()->getGraphicsContext()->resized(x,y,w,h); mViewer->getEventQueue()->windowResize(x,y,w,h); if (mWindowListener) mWindowListener->windowResized(w, h); break; case SDL_WINDOWEVENT_RESIZED: // This should also fire SIZE_CHANGED, so no need to handle break; case SDL_WINDOWEVENT_FOCUS_GAINED: mWindowHasFocus = true; updateMouseSettings(); if (mWindowListener) mWindowListener->windowFocusChange(true); break; case SDL_WINDOWEVENT_FOCUS_LOST: mWindowHasFocus = false; updateMouseSettings(); if (mWindowListener) mWindowListener->windowFocusChange(false); break; case SDL_WINDOWEVENT_CLOSE: break; case SDL_WINDOWEVENT_SHOWN: case SDL_WINDOWEVENT_RESTORED: if (mWindowListener) mWindowListener->windowVisibilityChange(true); break; case SDL_WINDOWEVENT_HIDDEN: case SDL_WINDOWEVENT_MINIMIZED: if (mWindowListener) mWindowListener->windowVisibilityChange(false); break; } }
void Window::getPosition(int &x, int &y, int &displayindex) { if (!window) { x = y = 0; displayindex = 0; return; } displayindex = std::max(SDL_GetWindowDisplayIndex(window), 0); SDL_GetWindowPosition(window, &x, &y); // In SDL <= 2.0.3, fullscreen windows are always reported as 0,0. In every // other case we need to convert the position from global coordinates to the // monitor's coordinate space. if (x != 0 || y != 0) { SDL_Rect displaybounds = {}; SDL_GetDisplayBounds(displayindex, &displaybounds); x -= displaybounds.x; y -= displaybounds.y; } }
MyGUI::IntCoord BaseManager::getWindowCoord() { int left, top, width, height; SDL_GetWindowPosition(mWindow, &left, &top); SDL_GetWindowSize(mWindow, &width, &height); return MyGUI::IntCoord(left, top, width, height); }
glm::uvec2 Window::getPosition() const { int x, y; SDL_GetWindowPosition(window_, &x, &y); return {x, y}; }
math::vector<int, 2> window::get_mouse_position() const { int x, y; SDL_GetGlobalMouseState(&x, &y); int window_x, window_y; SDL_GetWindowPosition(handle.get(), &window_x, &window_y); x -= window_x; y -= window_y; // SDL_GetGlobalMouseState and SDL_GetWindowPosition return "screen // coordinates", as in scaled values. We'll need to convert these to // pixels before we can do anything with them. // TODO: is this also the case on Windows? // TODO: seeing as get_position/set_position and get_size/set_size // operate in "screen coordinates", there might also be use for a // variant of get_mouse_position that returns "screen coordinates". x *= get_backbuffer_width() / get_width(); y *= get_backbuffer_height() / get_height(); return { x, y }; }
S32 VideoSystem::getWindowPositionCoord(bool getX) { S32 x, y; SDL_GetWindowPosition(DisplayManager::getScreenInfo()->sdlWindow, &x, &y); return getX ? x : y; }
static inline bool _gut_savebnds(GutCore *core) { if (gut.core->window.mode != GUT_MODE_WINDOWED) { // bounds undefined, use desktop bounds SDL_Rect bounds; if (!_gut_getbnds(&bounds)) return false; int x, y; x = (bounds.w - gut.window.width) / 2; if (x < 0) x = 0; y = (bounds.h - gut.window.height) / 2; if (y < 0) y = 0; core->window.windowbounds.x = x; core->window.windowbounds.y = y; core->window.windowbounds.w = gut.window.width; core->window.windowbounds.h = gut.window.height; return true; } // recycle old bounds SDL_GetWindowPosition( core->window.handle, &core->window.windowbounds.x, &core->window.windowbounds.y ); SDL_GetWindowSize( core->window.handle, &core->window.windowbounds.w, &core->window.windowbounds.h ); return true; }
/** Returns the size and location of the window when it is restored */ bool FLinuxWindow::GetRestoredDimensions(int32& X, int32& Y, int32& Width, int32& Height) { SDL_GetWindowPosition(HWnd, &X, &Y); SDL_GetWindowSize(HWnd, &Width, &Height); return true; }
void Window::updatePosition() { int x, y; SDL_GetWindowPosition(pointer, &x, &y); position.set(x, y); }
const struct point *video_get_position( ) { static struct point point; SDL_GetWindowPosition( video_window, &point.x, &point.y ); return &point; }
math::vector<int, 2> window::get_position() const { int x = 0, y = 0; SDL_GetWindowPosition(handle.get(), &x, &y); return { x, y }; }
int window::get_y() const { int y = 0; SDL_GetWindowPosition(handle.get(), nullptr, &y); return y; }
point sdl_window::mouse_position() const { int x, y; SDL_Window* mouseFocus = SDL_GetMouseFocus(); SDL_GetMouseState(&x, &y); if (mouseFocus != 0) { int mfx, mfy; SDL_GetWindowPosition(mouseFocus, &mfx, &mfy); x += mfx; y += mfy; SDL_GetWindowPosition(iHandle, &mfx, &mfy); x -= mfx; y -= mfy; } return point(static_cast<coordinate>(x), static_cast<coordinate>(y)); }
int window::get_x() const { int x = 0; SDL_GetWindowPosition(handle.get(), &x, nullptr); return x; }
void FLinuxCursor::SetPosition( const int32 X, const int32 Y ) { int WndX, WndY; SDL_HWindow WndFocus = SDL_GetMouseFocus(); SDL_GetWindowPosition( WndFocus, &WndX, &WndY ); // get top left SDL_WarpMouseInWindow( NULL, X - WndX, Y - WndY ); }
GHOST_TSuccess GHOST_SystemSDL::setCursorPosition(GHOST_TInt32 x, GHOST_TInt32 y) { int x_win, y_win; SDL_Window *win = SDL_GetMouseFocus(); SDL_GetWindowPosition(win, &x_win, &y_win); SDL_WarpMouseInWindow(win, x - x_win, y - y_win); return GHOST_kSuccess; }
int Window::getWindowPosition(State & state, SDL_Window * window){ int x, y; SDL_GetWindowPosition(window, &x, &y); Stack * stack = state.stack; stack->newTable(); stack->setField<int>("x", x, -2); stack->setField<int>("y", y, -2); return 1; }
int SDLWindow::GetY () { int x; int y; SDL_GetWindowPosition (sdlWindow, &x, &y); return y; }
void GHOST_WindowSDL::clientToScreen(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const { /* XXXSDL_WEAK_ABS_COORDS */ int x_win, y_win; SDL_GetWindowPosition(m_sdl_win, &x_win, &y_win); outX = inX + x_win; outY = inY + y_win; }
// // save the window position // void saveSettings(const char *configName, SDL_Window *window, int fontScale) { FILE *fp = openConfig(configName, "w"); if (fp) { int x, y, w, h; SDL_GetWindowPosition(window, &x, &y); SDL_GetWindowSize(window, &w, &h); fprintf(fp, "%d,%d,%d,%d,%d,%d\n", x, y, w, h, fontScale, opt_mute_audio); fclose(fp); } }
Vec2I SDL2WindowBackend::getPosition() const { Vec2I s; s.x = 0; s.y = 0; if(isOpen()) SDL_GetWindowPosition(mWindow, &s.x, &s.y); return s; }
void GHOST_WindowSDL::getClientBounds(GHOST_Rect& bounds) const { int x, y, w, h; SDL_GetWindowSize(m_sdl_win, &w, &h); SDL_GetWindowPosition(m_sdl_win, &x, &y); bounds.m_l = x; bounds.m_r = x + w; bounds.m_t = y; bounds.m_b = y + h; }
const Rect &SDLWindow::GetPosition() { int x, y, w, h; SDL_GetWindowPosition(window, &x, &y); SDL_GetWindowSize(window, &w, &h); position.x = (double)x; position.y = (double)y; position.w = (double)w; position.h = (double)h; return this->start_location; }
SDL_Rect Window::getWindowDimensions() { auto w = 0; auto h = 0; auto x = 0; auto y = 0; SDL_GetWindowSize(window, &w, &h); SDL_GetWindowPosition(window, &x, &y); return { x, y, w, h}; }
/* * Shuffles the window around in a circle * PARAMS: * iters: number of times to move in a full circle * offset: pixel distance moved at each step * delay: time between steps (not full circles) */ void CycleAround(int iters, int offset, int delay) { int x, y; SDL_GetWindowPosition(window, &x, &y); int cnt; for(cnt=0; cnt < iters; cnt++) { SDL_SetWindowPosition(window, x+offset, y); SDL_Delay(delay); SDL_SetWindowPosition(window, x+offset, y+offset); SDL_Delay(delay); SDL_SetWindowPosition(window, x, y+offset); SDL_Delay(delay); SDL_SetWindowPosition(window, x, y); SDL_Delay(delay); } EndDemo(); }
GHOST_TSuccess GHOST_SystemSDL::getCursorPosition(GHOST_TInt32 &x, GHOST_TInt32 &y) const { int x_win, y_win; SDL_Window *win = SDL_GetMouseFocus(); SDL_GetWindowPosition(win, &x_win, &y_win); int xi, yi; SDL_GetMouseState(&xi, &yi); x = xi + x_win; y = yi + x_win; return GHOST_kSuccess; }
bool gutGetWindowPosition(unsigned *x, unsigned *y) { chkwin; int xp, yp; SDL_GetWindowPosition( gut.core->window.handle, &xp, &yp ); if (xp < 0 || yp < 0) return false; if (x) *x = xp; if (y) *y = yp; return true; }
const Rect SDLGameWindow::VGetClientBounds() { if(m_fullscreen) { SDL_GetWindowPosition(m_windowHandle, &m_clientRect.x, &m_clientRect.y); SDL_GetWindowSize(m_windowHandle, &m_clientRect.w, &m_clientRect.h); } else { //we will take the requested size from config m_clientRect.w = m_parent->GetConfig()->WindowArgs().width; m_clientRect.h = m_parent->GetConfig()->WindowArgs().height; } return m_clientRect; }
void Window::getInfo( WindowInfo& info ) const noexcept { info.id = getID(); info.title = SDL_GetWindowTitle( m_wimpl->window ); info.wflags = fromSDL2Flags_( SDL_GetWindowFlags( m_wimpl->window ) ); SDL_GetWindowPosition( m_wimpl->window, &info.x, &info.y ); SDL_GetWindowSize( m_wimpl->window, &info.w, &info.h ); info.lw = getLogicalWidth(); info.lh = getLogicalHeight(); SDL_RendererInfo rinfo; SDL_GetRendererInfo( m_wimpl->renderer, &rinfo ); info.accel = ( ( rinfo.flags & SDL_RENDERER_ACCELERATED ) != 0 ); }