void Mouse::releaseButton(MouseButton button)
{
INIT_INPUT(input);
input.mi.dwFlags = translateMouseButton(button) << 1;
SendInput(1, &input, sizeof(INPUT));
}
void QXcbWindow::handleMouseEvent(xcb_button_t detail, uint16_t state, xcb_timestamp_t time, const QPoint &local, const QPoint &global)
{
Qt::MouseButtons buttons = translateMouseButtons(state);
Qt::MouseButton button = translateMouseButton(detail);
buttons ^= button; // X event uses state *before*, Qt uses state *after*
QWindowSystemInterface::handleMouseEvent(widget(), time, local, global, buttons);
}
void mouseReleaseEvent(QMouseEvent *event) {
WindowHandle handle = s_ctx.findHandle(this);
const bool down = false;
s_ctx.m_pos = QPoint(event->x(), event->y());
s_ctx.m_eventQueue.postMouseEvent(handle
, (int32_t) event->x()
, (int32_t) event->y()
, (int32_t) s_ctx.m_scroll
, translateMouseButton(event->button())
, down
);
}
void EventReader::run()
{
Qt::MouseButtons buttons;
xcb_generic_event_t *event;
while (running.load() && (event = xcb_wait_for_event(m_hooks->connection()))) {
uint response_type = event->response_type & ~0x80;
switch (response_type) {
case XCB_BUTTON_PRESS: {
xcb_button_press_event_t *press = (xcb_button_press_event_t *)event;
QPoint p(press->event_x, press->event_y);
buttons = (buttons & ~0x7) | translateMouseButtons(press->state);
buttons |= translateMouseButton(press->detail);
QWindowSystemInterface::handleMouseEvent(0, press->time, p, p, buttons);
break;
}
case XCB_BUTTON_RELEASE: {
xcb_button_release_event_t *release = (xcb_button_release_event_t *)event;
QPoint p(release->event_x, release->event_y);
buttons = (buttons & ~0x7) | translateMouseButtons(release->state);
buttons &= ~translateMouseButton(release->detail);
QWindowSystemInterface::handleMouseEvent(0, release->time, p, p, buttons);
break;
}
case XCB_MOTION_NOTIFY: {
xcb_motion_notify_event_t *motion = (xcb_motion_notify_event_t *)event;
QPoint p(motion->event_x, motion->event_y);
QWindowSystemInterface::handleMouseEvent(0, motion->time, p, p, buttons);
break;
}
case XCB_CLIENT_MESSAGE: {
xcb_client_message_event_t *client = (xcb_client_message_event_t *) event;
const xcb_atom_t *atoms = m_hooks->atoms();
if (client->format == 32
&& client->type == atoms[Atoms::WM_PROTOCOLS]
&& client->data.data32[0] == atoms[Atoms::WM_DELETE_WINDOW]) {
QWindow *window = m_hooks->platformWindow() ? m_hooks->platformWindow()->window() : 0;
if (window)
QWindowSystemInterface::handleCloseEvent(window);
}
break;
}
default:
break;
}
}
}
bool translateXinputEvent(const XEvent *ev, QTabletDeviceData *tablet, QWidget *defaultWidget)
{
Q_ASSERT(defaultWidget);
#if defined (Q_OS_IRIX)
#endif
Q_ASSERT(tablet != 0);
QWidget *w = defaultWidget;
QPoint global,
curr;
QPointF hiRes;
qreal pressure = 0;
int xTilt = 0,
yTilt = 0,
z = 0;
qreal tangentialPressure = 0;
qreal rotation = 0;
int deviceType = QTabletEvent::NoDevice;
int pointerType = QTabletEvent::UnknownPointer;
const XDeviceMotionEvent *motion = 0;
XDeviceButtonEvent *button = 0;
KisTabletEvent::ExtraEventType t = KisTabletEvent::TabletMoveEx;
Qt::KeyboardModifiers modifiers = 0;
modifiers = QApplication::queryKeyboardModifiers();
#if !defined (Q_OS_IRIX)
XID device_id = 0;
#endif
if (ev->type == tablet->xinput_motion) {
motion = reinterpret_cast<const XDeviceMotionEvent*>(ev);
t = KisTabletEvent::TabletMoveEx;
global = QPoint(motion->x_root, motion->y_root);
curr = QPoint(motion->x, motion->y);
#if !defined (Q_OS_IRIX)
device_id = motion->deviceid;
#endif
} else if (ev->type == tablet->xinput_button_press || ev->type == tablet->xinput_button_release) {
if (ev->type == tablet->xinput_button_press) {
t = KisTabletEvent::TabletPressEx;
} else {
t = KisTabletEvent::TabletReleaseEx;
}
button = (XDeviceButtonEvent*)ev;
global = QPoint(button->x_root, button->y_root);
curr = QPoint(button->x, button->y);
#if !defined (Q_OS_IRIX)
device_id = button->deviceid;
#endif
} else {
qFatal("Unknown event type! Probably, 'proximity', "
"but we don't handle it here, so this is a bug");
}
qint64 wacomSerialId = 0;
qint64 wacomDeviceId = 0;
#if defined (Q_OS_IRIX)
#else
// We've been passed in data for a tablet device that handles this type
// of event, but it isn't necessarily the tablet device that originated
// the event. Use the device id to find the originating device if we
// have it.
QTabletDeviceDataList *tablet_list = qt_tablet_devices();
for (int i = 0; i < tablet_list->size(); ++i) {
QTabletDeviceData &tab = tablet_list->operator[](i);
if (device_id == static_cast<XDevice *>(tab.device)->device_id) {
// Replace the tablet passed in with this one.
tablet = &tab;
deviceType = tab.deviceType;
if (tab.deviceType == QTabletEvent::XFreeEraser) {
deviceType = QTabletEvent::Stylus;
pointerType = QTabletEvent::Eraser;
} else if (tab.deviceType == QTabletEvent::Stylus) {
pointerType = QTabletEvent::Pen;
}
break;
}
}
/**
* Touch events from Wacom tablets should not be sent as real
* tablet events
*/
if (tablet->isTouchWacomTablet) return false;
fetchWacomToolId(wacomSerialId, wacomDeviceId, tablet);
if (wacomDeviceId && deviceType == QTabletEvent::Stylus) {
deviceType = parseWacomDeviceId(wacomDeviceId);
}
QRect screenArea = qApp->desktop()->rect();
/**
* Some 'nice' tablet drivers (evdev) do not return the value
* of all the axes each time. Instead they tell about the
* recenty changed axes only, so we have to keep the state of
* all the axes internally and update the relevant part only.
*/
bool hasSaneData = false;
if (motion) {
hasSaneData =
tablet->savedAxesData.updateAxesData(motion->first_axis,
motion->axes_count,
motion->axis_data);
} else if (button) {
hasSaneData =
tablet->savedAxesData.updateAxesData(button->first_axis,
button->axes_count,
button->axis_data);
}
if (!hasSaneData) return false;
hiRes = tablet->savedAxesData.position(tablet, screenArea);
pressure = tablet->savedAxesData.pressure();
xTilt = tablet->savedAxesData.xTilt();
yTilt = tablet->savedAxesData.yTilt();
if (deviceType == QTabletEvent::Airbrush) {
tangentialPressure =
std::fmod(qreal(tablet->savedAxesData.rotation() - tablet->minRotation) /
(tablet->maxRotation - tablet->minRotation) , 2.0);
} else {
rotation =
std::fmod(qreal(tablet->savedAxesData.rotation() - tablet->minRotation) /
(tablet->maxRotation - tablet->minRotation) + 0.5, 1.0) * 360.0;
}
#endif
if (tablet->widgetToGetPress) {
w = tablet->widgetToGetPress;
} else {
QWidget *child = w->childAt(curr);
if (child)
w = child;
}
curr = w->mapFromGlobal(global);
if (t == KisTabletEvent::TabletPressEx) {
tablet->widgetToGetPress = w;
} else if (t == KisTabletEvent::TabletReleaseEx && tablet->widgetToGetPress) {
w = tablet->widgetToGetPress;
curr = w->mapFromGlobal(global);
tablet->widgetToGetPress = 0;
}
Qt::MouseButton qtbutton = Qt::NoButton;
Qt::MouseButtons qtbuttons;
if (motion) {
qtbuttons = translateMouseButtons(motion->state);
} else if (button) {
qtbuttons = translateMouseButtons(button->state);
qtbutton = translateMouseButton(button->button);
}
KisTabletEvent e(t, curr, global, hiRes,
deviceType, pointerType,
qreal(pressure / qreal(tablet->maxPressure - tablet->minPressure)),
xTilt, yTilt, tangentialPressure, rotation, z, modifiers, wacomSerialId,
qtbutton, qtbuttons);
e.ignore();
QApplication::sendEvent(w, &e);
return e.isAccepted();
}
bool
DecafSDL::run(const std::string &gamePath)
{
auto shouldQuit = false;
// Setup some basic window stuff
auto window = mGraphicsDriver->getWindow();
setWindowIcon(window);
if (config::display::mode == config::display::Fullscreen) {
SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
}
// Setup OpenGL graphics driver
auto graphicsDriver = mGraphicsDriver->getDecafDriver();
decaf::setGraphicsDriver(graphicsDriver);
auto debugUiRenderer = mGraphicsDriver->getDecafDebugUiRenderer();
decaf::setDebugUiRenderer(debugUiRenderer);
// Set input provider
decaf::setInputDriver(this);
decaf::addEventListener(this);
openInputDevices();
// Set sound driver
decaf::setSoundDriver(mSoundDriver);
decaf::setClipboardTextCallbacks(
[](void *context) -> const char * {
return SDL_GetClipboardText();
},
[](void *context, const char *text) {
SDL_SetClipboardText(text);
});
// Initialise emulator
if (!decaf::initialise(gamePath)) {
return false;
}
// Start emulator
decaf::start();
while (!shouldQuit && !decaf::hasExited()) {
if (mVpad0Controller) {
SDL_GameControllerUpdate();
}
SDL_Event event;
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_WINDOWEVENT:
if (event.window.event == SDL_WINDOWEVENT_CLOSE) {
shouldQuit = true;
}
break;
case SDL_MOUSEBUTTONDOWN:
decaf::injectMouseButtonInput(translateMouseButton(event.button.button), decaf::input::MouseAction::Press);
break;
case SDL_MOUSEBUTTONUP:
decaf::injectMouseButtonInput(translateMouseButton(event.button.button), decaf::input::MouseAction::Release);
break;
case SDL_MOUSEWHEEL:
decaf::injectScrollInput(static_cast<float>(event.wheel.x), static_cast<float>(event.wheel.y));
break;
case SDL_MOUSEMOTION:
decaf::injectMousePos(static_cast<float>(event.motion.x), static_cast<float>(event.motion.y));
break;
case SDL_KEYDOWN:
decaf::injectKeyInput(translateKeyCode(event.key.keysym), decaf::input::KeyboardAction::Press);
break;
case SDL_KEYUP:
if (event.key.keysym.sym == SDLK_TAB) {
mToggleDRC = !mToggleDRC;
}
if (event.key.keysym.sym == SDLK_ESCAPE) {
shouldQuit = true;
}
decaf::injectKeyInput(translateKeyCode(event.key.keysym), decaf::input::KeyboardAction::Release);
break;
case SDL_TEXTINPUT:
decaf::injectTextInput(event.text.text);
break;
case SDL_QUIT:
shouldQuit = true;
break;
}
}
Viewport tvViewport, drcViewport;
calculateScreenViewports(tvViewport, drcViewport);
mGraphicsDriver->renderFrame(tvViewport, drcViewport);
}
// Shut down decaf
decaf::shutdown();
// Shut down graphics
mGraphicsDriver->shutdown();
return true;
}
