void PopupWindow::showEvent(QShowEvent* ev)
{
QQuickWindow::showEvent(ev);
// In XCB, we are only guaranteed to grab the mouse if there's a platformWindow
// created. This happens right after this event is sent.
QTimer::singleShot(0, this, SLOT(setMouseGrab()));
}
void Input::pollMouse(float secondsSinceLast)
{
int mouseX, mouseY;
mMouseState = SDL_GetMouseState(&mouseX, &mouseY);
//has the mouse moved?
Uint8 appState = SDL_GetAppState();
if (appState & SDL_APPMOUSEFOCUS) {
//Wait with grabbing the mouse until the app has input focus.
if (mMouseGrabbingRequested && (appState & SDL_APPINPUTFOCUS)) {
setMouseGrab(true);
}
if (mMousePosition.xPixelPosition != mouseX || mMousePosition.yPixelPosition != mouseY) {
//we'll calculate the mouse movement difference and send the values to those
//listening to the MouseMoved event
float diffX, diffY;
diffX = (mMousePosition.xPixelPosition - mouseX) / mScreenWidth;
diffY = (mMousePosition.yPixelPosition - mouseY) / mScreenHeight;
MouseMotion motion;
motion.xPosition = mouseX;
motion.yPosition = mouseY;
motion.xRelativeMovement = diffX;
motion.yRelativeMovement = diffY;
motion.xRelativeMovementInPixels = mMousePosition.xPixelPosition - mouseX;
motion.yRelativeMovementInPixels = mMousePosition.yPixelPosition - mouseY;
motion.timeSinceLastMovement = secondsSinceLast;
EventMouseMoved.emit(motion, mCurrentInputMode);
bool freezeMouse = false;
//if we're in gui mode, we'll just send the mouse movement on to CEGUI
if (mCurrentInputMode == IM_GUI) {
for (IInputAdapterStore::const_iterator I = mAdapters.begin(); I != mAdapters.end();) {
IInputAdapter* adapter = *I;
++I;
if (!(adapter)->injectMouseMove(motion, freezeMouse))
break;
}
} else {
freezeMouse = true;
}
if (freezeMouse) {
SDL_WarpMouse(mMousePosition.xPixelPosition, mMousePosition.yPixelPosition);
} else {
mMousePosition.xPixelPosition = mouseX;
mMousePosition.yPixelPosition = mouseY;
mMousePosition.xRelativePosition = mouseX / mScreenWidth;
mMousePosition.yRelativePosition = mouseY / mScreenHeight;
}
}
}
}
void Input::Config_CatchMouse(const std::string& section, const std::string& key, varconf::Variable& variable)
{
try {
if (variable.is_bool()) {
bool enabled = static_cast<bool> (variable);
if (enabled) {
mMouseGrabbingRequested = true;
} else {
setMouseGrab(false);
}
}
} catch (const std::exception& ex) {
S_LOG_FAILURE("Error when changing mouse grabbing." << ex);
}
}
bool Window::setWindow(int width, int height, WindowSettings *settings)
{
if (!graphics.get())
graphics.set(Module::getInstance<graphics::Graphics>(Module::M_GRAPHICS));
if (graphics.get() && graphics->isCanvasActive())
throw love::Exception("love.window.setMode cannot be called while a Canvas is active in love.graphics.");
WindowSettings f;
if (settings)
f = *settings;
f.minwidth = std::max(f.minwidth, 1);
f.minheight = std::max(f.minheight, 1);
f.display = std::min(std::max(f.display, 0), getDisplayCount() - 1);
// Use the desktop resolution if a width or height of 0 is specified.
if (width == 0 || height == 0)
{
SDL_DisplayMode mode = {};
SDL_GetDesktopDisplayMode(f.display, &mode);
width = mode.w;
height = mode.h;
}
Uint32 sdlflags = SDL_WINDOW_OPENGL;
// On Android we always must have fullscreen type FULLSCREEN_TYPE_DESKTOP
#ifdef LOVE_ANDROID
f.fstype = FULLSCREEN_DESKTOP;
#endif
if (f.fullscreen)
{
if (f.fstype == FULLSCREEN_DESKTOP)
sdlflags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
else
{
sdlflags |= SDL_WINDOW_FULLSCREEN;
SDL_DisplayMode mode = {0, width, height, 0, nullptr};
// Fullscreen window creation will bug out if no mode can be used.
if (SDL_GetClosestDisplayMode(f.display, &mode, &mode) == nullptr)
{
// GetClosestDisplayMode will fail if we request a size larger
// than the largest available display mode, so we'll try to use
// the largest (first) mode in that case.
if (SDL_GetDisplayMode(f.display, 0, &mode) < 0)
return false;
}
width = mode.w;
height = mode.h;
}
}
if (f.resizable)
sdlflags |= SDL_WINDOW_RESIZABLE;
if (f.borderless)
sdlflags |= SDL_WINDOW_BORDERLESS;
if (f.highdpi)
sdlflags |= SDL_WINDOW_ALLOW_HIGHDPI;
int x = f.x;
int y = f.y;
if (f.useposition && !f.fullscreen)
{
// The position needs to be in the global coordinate space.
SDL_Rect displaybounds = {};
SDL_GetDisplayBounds(f.display, &displaybounds);
x += displaybounds.x;
y += displaybounds.y;
}
else
{
if (f.centered)
x = y = SDL_WINDOWPOS_CENTERED_DISPLAY(f.display);
else
x = y = SDL_WINDOWPOS_UNDEFINED_DISPLAY(f.display);
}
close();
if (!createWindowAndContext(x, y, width, height, sdlflags, f.msaa, f.stencil, f.depth))
return false;
// Make sure the window keeps any previously set icon.
setIcon(icon.get());
// Make sure the mouse keeps its previous grab setting.
setMouseGrab(mouseGrabbed);
// Enforce minimum window dimensions.
SDL_SetWindowMinimumSize(window, f.minwidth, f.minheight);
if ((f.useposition || f.centered) && !f.fullscreen)
SDL_SetWindowPosition(window, x, y);
SDL_RaiseWindow(window);
SDL_GL_SetSwapInterval(f.vsync);
// Check if adaptive vsync was requested but not supported, and fall back
// to regular vsync if so.
if (f.vsync == -1 && SDL_GL_GetSwapInterval() != -1)
SDL_GL_SetSwapInterval(1);
updateSettings(f, false);
if (graphics.get())
{
double scaledw, scaledh;
fromPixels((double) pixelWidth, (double) pixelHeight, scaledw, scaledh);
graphics->setMode((int) scaledw, (int) scaledh, pixelWidth, pixelHeight, f.stencil);
}
#ifdef LOVE_ANDROID
love::android::setImmersive(f.fullscreen);
#endif
return true;
}
