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;
}
}
}
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 QXlibWindow::handleMouseEvent(QEvent::Type type, XButtonEvent *e)
{
static QPoint mousePoint;
Qt::MouseButton button = Qt::NoButton;
Qt::MouseButtons buttons = translateMouseButtons(e->state);
Qt::KeyboardModifiers modifiers = mScreen->keyboard()->translateModifiers(e->state);
if (type != QEvent::MouseMove) {
switch (e->button) {
case Button1:
button = Qt::LeftButton;
break;
case Button2:
button = Qt::MidButton;
break;
case Button3:
button = Qt::RightButton;
break;
case Button4:
case Button5:
case 6:
case 7: {
//mouse wheel
if (type == QEvent::MouseButtonPress) {
//logic borrowed from qapplication_x11.cpp
int delta = 120 * ((e->button == Button4 || e->button == 6) ? 1 : -1);
bool hor = (((e->button == Button4 || e->button == Button5)
&& (modifiers & Qt::AltModifier))
|| (e->button == 6 || e->button == 7));
QWindowSystemInterface::handleWheelEvent(widget(), e->time,
QPoint(e->x, e->y),
QPoint(e->x_root, e->y_root),
delta, hor ? Qt::Horizontal : Qt::Vertical);
}
return;
}
default:
break;
}
}
buttons ^= button; // X event uses state *before*, Qt uses state *after*
QWindowSystemInterface::handleMouseEvent(widget(), e->time, QPoint(e->x, e->y),
QPoint(e->x_root, e->y_root),
buttons);
mousePoint = QPoint(e->x_root, e->y_root);
}
void SDLMouse::update()
{
SDL_Event event;
SDL_PumpEvents();
while ( SDL_PeepEvents(&event, 1, SDL_GETEVENT, ( SDL_EVENTMASK(SDL_MOUSEBUTTONDOWN) | SDL_EVENTMASK(SDL_MOUSEBUTTONUP) | SDL_EVENTMASK(SDL_MOUSEMOTION) ) ) > 0 )
{
if ( event.type == SDL_MOUSEBUTTONDOWN ) {
cout << endl << " [EE] Mouse Pressed";
if ( gui() != NULL ) {
cout << " gui";
gui()->mousePressed( event.button.x, event.button.y, translateMouseButtons( event.button.button ) );
}
cout << endl;
onMousePressed( event.button.x, event.button.y, translateMouseButtons( event.button.button ) );
} else if ( event.type == SDL_MOUSEBUTTONUP ) {
cout << " [EE] Mouse Released" << endl << endl;
if ( gui() != NULL ) {
cout << " gui";
gui()->mouseReleased( event.button.x, event.button.y, translateMouseButtons( event.button.button ) );
}
cout << endl;
onMouseReleased( event.button.x, event.button.y, translateMouseButtons( event.button.button ) );
} else if ( event.type == SDL_MOUSEMOTION ) {
if ( gui() != NULL )
gui()->mouseMove( event.button.x, event.button.y, translateMouseButtons( event.button.button ) );
onMouseMove( event.button.x, event.button.y, translateMouseButtons( event.button.button ) );
}
}
if ( gui() != NULL ) {
Widget* w = gui()->lastMouseOverWidget();
if ( w != NULL ) {
int x, y;
mousePos( x, y );
MouseCursor* mc = w->getCursor( x - w->absoluteXPos(), y - w->absoluteYPos() );
if ( mc != (MouseCursor*)pCursor ) {
setCursor( mc );
}
}
/* if ( gui()->lastMouseOverWidget() != pLastMouseOver ) {
pLastMouseOver = gui()->lastMouseOverWidget();
if ( pLastMouseOver != NULL ) {
if ( (MouseCursor*)pCursor != pLastMouseOver->cursor() )
setCursor( pLastMouseOver->cursor() );
}
}*/
}
}
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();
}
MouseButtons SDLMouse::mouseButtons()
{
SDL_PumpEvents();
int x, y;
return translateMouseButtons( SDL_GetRelativeMouseState( &x, &y ) );
}
