void MouseHandler::sendMouseBtnRelease(const unsigned char button) {
switch (button) {
case 0:
if (!sendMouseEvent(EV_BTN_LEFT_RELEASE)) {
logger->error("12.12.2011 01:26:14 sendMouseEvent(EV_BTN_LEFT_RELEASE) error");
}
break;
case 1:
if (!sendMouseEvent(EV_BTN_RIGHT_RELEASE)) {
logger->error("12.12.2011 01:26:20 sendMouseEvent(EV_BTN_RIGHT_RELEASE) error");
}
break;
case 2:
if (!sendMouseEvent(EV_BTN_MIDDLE_RELEASE)) {
logger->error("12.12.2011 01:26:26 sendMouseEvent(EV_BTN_MIDDLE_RELEASE) error");
}
break;
default:
char tmp[128];
sprintf(tmp,"12.12.2011 01:26:44 sendMouseBtnRelease - unknown button mouse (%u)",(unsigned int)button);
logger->error(tmp);
}
}
void MouseHandler::sendMouseBtnPress(const unsigned char button) {
switch (button) {
case 0:
if (!sendMouseEvent(EV_BTN_LEFT_PRESS)) {
logger->error("12.12.2011 01:24:21 sendMouseEvent(EV_BTN_LEFT_PRESS) error");
}
break;
case 1:
if (!sendMouseEvent(EV_BTN_RIGHT_PRESS)) {
logger->error("12.12.2011 01:24:26 sendMouseEvent(EV_BTN_RIGHT_PRESS) error");
}
break;
case 2:
if (!sendMouseEvent(EV_BTN_MIDDLE_PRESS)) {
logger->error("12.12.2011 01:24:31 sendMouseEvent(EV_BTN_MIDDLE_PRESS) error");
}
break;
default:
char tmp[128];
sprintf(tmp,"12.12.2011 01:24:40 sendMouseBtnPress - unknown button mouse (%u)",(unsigned int)button);
logger->error(tmp);
}
}
bool IrrEventSender::sendEvent(QEvent* event) {
bool event_taked = false;
if (event != NULL) {
QMouseEvent* mouseEvent = dynamic_cast<QMouseEvent*>(event);
if(mouseEvent != NULL && event_taked != true) {
sendMouseEvent(mouseEvent);
event_taked = true;
}
QPaintEvent* paintEvent = dynamic_cast<QPaintEvent*>(event);
if(paintEvent != NULL && event_taked != true) {
sendPaintEvent(paintEvent);
event_taked = true;
}
QTimerEvent* timeEvent = dynamic_cast<QTimerEvent*>(event);
if(timeEvent != NULL && event_taked != true) {
sendTimeEvent(timeEvent);
event_taked = true;
}
QResizeEvent* resizeEvent = dynamic_cast<QResizeEvent*>(event);
if(resizeEvent != NULL && event_taked != true) {
sendResizeEvent(resizeEvent);
event_taked = true;
}
}
return event_taked;
}
bool QQuickMultiPointTouchArea::childMouseEventFilter(QQuickItem *receiver, QEvent *event)
{
if (!isEnabled() || !isVisible())
return QQuickItem::childMouseEventFilter(receiver, event);
switch (event->type()) {
case QEvent::MouseButtonPress:
case QEvent::MouseMove:
case QEvent::MouseButtonRelease:
return sendMouseEvent(static_cast<QMouseEvent *>(event));
break;
case QEvent::TouchBegin:
case QEvent::TouchUpdate:
if (!shouldFilter(event))
return false;
updateTouchData(event);
return _stealMouse;
case QEvent::TouchEnd: {
if (!shouldFilter(event))
return false;
updateTouchData(event);
ungrab();
}
break;
default:
break;
}
return QQuickItem::childMouseEventFilter(receiver, event);
}
bool QDeclarativePinchArea::sceneEventFilter(QGraphicsItem *i, QEvent *e)
{
Q_D(QDeclarativePinchArea);
if (!d->absorb || !isVisible())
return QDeclarativeItem::sceneEventFilter(i, e);
switch (e->type()) {
case QEvent::GraphicsSceneMousePress:
case QEvent::GraphicsSceneMouseMove:
case QEvent::GraphicsSceneMouseRelease:
return sendMouseEvent(static_cast<QGraphicsSceneMouseEvent *>(e));
break;
case QEvent::TouchBegin:
case QEvent::TouchUpdate: {
QTouchEvent *touch = static_cast<QTouchEvent*>(e);
d->touchPoints.clear();
for (int i = 0; i < touch->touchPoints().count(); ++i)
if (!(touch->touchPoints().at(i).state() & Qt::TouchPointReleased))
d->touchPoints << touch->touchPoints().at(i);
updatePinch();
}
return d->inPinch;
case QEvent::TouchEnd:
d->touchPoints.clear();
updatePinch();
break;
default:
break;
}
return QDeclarativeItem::sceneEventFilter(i, e);
}
void
BioWidget::mousePressEvent( QMouseEvent* event )
{
update();
if ( !sendMouseEvent(event) )
QTextBrowser::mousePressEvent( event );
}
void MouseHandler::sendMouseClick(const unsigned char button) {
switch (button) {
case 0:
if (!sendMouseEvent(EV_BTN_LEFT_PRESS)) {
logger->error("11.12.2011 21:54:01 sendMouseEvent(EV_BTN_LEFT_PRESS) error");
}
if (!sendMouseEvent(EV_BTN_LEFT_RELEASE)) {
logger->error("11.12.2011 21:54:07 sendMouseEvent(EV_BTN_LEFT_RELEASE) error");
}
break;
case 1:
if (!sendMouseEvent(EV_BTN_RIGHT_PRESS)) {
logger->error("11.12.2011 21:54:13 sendMouseEvent(EV_BTN_RIGHT_PRESS) error");
}
if (!sendMouseEvent(EV_BTN_RIGHT_RELEASE)) {
logger->error("11.12.2011 21:54:20 sendMouseEvent(EV_BTN_RIGHT_RELEASE) error");
}
break;
case 2:
if (!sendMouseEvent(EV_BTN_MIDDLE_PRESS)) {
logger->error("11.12.2011 21:54:25 sendMouseEvent(EV_BTN_MIDDLE_PRESS) error");
}
if (!sendMouseEvent(EV_BTN_MIDDLE_RELEASE)) {
logger->error("11.12.2011 21:54:31 sendMouseEvent(EV_BTN_MIDDLE_RELEASE) error");
}
break;
default:
char tmp[128];
sprintf(tmp,"11.12.2011 21:54:38 sendMouseClick - unknown button mouse (%u)",(unsigned int)button);
logger->error(tmp);
}
}
bool QDeclarativeMouseArea::sceneEventFilter(QGraphicsItem *i, QEvent *e)
{
Q_D(QDeclarativeMouseArea);
if (!d->absorb || !isVisible() || !d->drag || !d->drag->filterChildren())
return QDeclarativeItem::sceneEventFilter(i, e);
switch (e->type()) {
case QEvent::GraphicsSceneMousePress:
case QEvent::GraphicsSceneMouseMove:
case QEvent::GraphicsSceneMouseRelease:
return sendMouseEvent(static_cast<QGraphicsSceneMouseEvent *>(e));
default:
break;
}
return QDeclarativeItem::sceneEventFilter(i, e);
}
bool QQuickMouseArea::childMouseEventFilter(QQuickItem *i, QEvent *e)
{
Q_D(QQuickMouseArea);
if (!d->pressed &&
(!d->enabled || !isVisible()
#ifndef QT_NO_DRAGANDDROP
|| !d->drag || !d->drag->filterChildren()
#endif
)
)
return QQuickItem::childMouseEventFilter(i, e);
switch (e->type()) {
case QEvent::MouseButtonPress:
case QEvent::MouseMove:
case QEvent::MouseButtonRelease:
return sendMouseEvent(static_cast<QMouseEvent *>(e));
default:
break;
}
return QQuickItem::childMouseEventFilter(i, e);
}
void UserDesktopWidget::mouseReleaseEvent(QMouseEvent* event)
{
UserImageWidget::mouseReleaseEvent(event);
m_mousedown = false;
quint32 key_code = TT_DESKTOPINPUT_KEYCODE_IGNORE;
switch(event->button())
{
case Qt::LeftButton :
key_code = TT_DESKTOPINPUT_KEYCODE_LMOUSEBTN;
break;
case Qt::MidButton :
key_code = TT_DESKTOPINPUT_KEYCODE_MMOUSEBTN;
break;
case Qt::RightButton :
key_code = TT_DESKTOPINPUT_KEYCODE_RMOUSEBTN;
break;
default:
break;
}
sendMouseEvent(event->pos(), key_code, DESKTOPKEYSTATE_UP);
}
void UserDesktopWidget::mouseMoveEvent(QMouseEvent* event)
{
UserImageWidget::mouseMoveEvent(event);
QPoint pos = event->pos();
if(m_mousedown &&
(m_user.uPeerSubscriptions & SUBSCRIBE_DESKTOPINPUT) == SUBSCRIBE_NONE)
{
int widget_width = this->width();
int widget_height = this->height();
int x_max = imageSize().width() - widget_width - 2 * m_border_width;
int y_max = imageSize().height() - widget_height - 2 * m_border_width;
int x_diff = pos.x() - m_old_pos.x();
int y_diff = pos.y() - m_old_pos.y();
int new_x = m_img_offset.x() + x_diff * -1;
int new_y = m_img_offset.y() + y_diff * -1;
new_x = qMax(new_x, 0);
new_x = qMin(new_x, x_max);
new_y = qMax(new_y, 0);
new_y = qMin(new_y, y_max);
m_img_offset.setX(new_x);
m_img_offset.setY(new_y);
update();
}
if((m_user.uPeerSubscriptions & SUBSCRIBE_DESKTOPINPUT) == SUBSCRIBE_NONE)
m_old_pos = pos;
sendMouseEvent(event->pos(), TT_DESKTOPINPUT_KEYCODE_IGNORE,
DESKTOPKEYSTATE_NONE);
}
/*
* Class: org_xw_GobeeDisplay
* Method: _n_emit_hid_event
* Signature: (JIIII)V
*/
JNIEXPORT void
JNICALL
n_emit_hid_event
(JNIEnv *jenv, jobject jobj, jlong xoid,
jint tip, jint x, jint y, jint buttons)
{
droid_hid *hiddev;
int _dat[4];
TRACE("[GobeeHid] n_emit_hid_event(%u,%d,%dx%d,%d}\n",
tip,x,y,buttons);
if (!xoid)
return;
hiddev = (droid_hid *)(void *)xoid;
_dat[0] = tip;
_dat[1] = x;
_dat[2] = y;
_dat[3] = buttons;
TRACE("[ xwjni-touch ]::[GobeeHid] n_emit_hid_event()2: {%d::%d:%dx%d}\n",
tip,x,y,buttons);
sendMouseEvent(hiddev,_dat);
}
void TasMouseEventGenerator::doMouseMove(const TasEventTarget& target, QPoint point, Qt::MouseButton button, uint pointerNumber )
{
moveCursor(point);
QMouseEvent* eventMove = new QMouseEvent(QEvent::MouseMove, target.mapFromGlobal(point), point, button, button, 0);
sendMouseEvent(target, eventMove, pointerNumber);
}
void MouseHandler::sendMouseMove(const int Xvalue, const int Yvalue) {
if (!sendMouseEvent(EV_MOVE,Xvalue,Yvalue)) {
logger->error("11.12.2011 21:54:44 sendMouseMove() error");
}
}
void MouseHandler::sendMouseVScroll(const int Xvalue) {
if (!sendMouseEvent(EV_SCROLL_VERT,Xvalue)) {
cerr << "sendMouseVScroll() error";
}
}
// override QApplication::notify() for greatest control over event handling
bool TouchApplication::notify(QObject* receiver, QEvent* event)
{
//DebugEventFilter::printEvent(receiver, event);
QEvent::Type evtype = event->type();
// first, try to pass TabletPress/TouchBegin event and see if anyone accepts it
// In Qt, events are first sent to a QWindow, which then figures out what widget they should be sent to.
// Unfortunately, QWindow event handler always returns true and doesn't change accepted state of event (it
// sends a copy of the event and discards the accepted state of the copy), so we must save result from
// sending event to final widget (by incrementing acceptCount)
// When faking mouse events, we must send them to the QWindow instead of a widget, since some of the
// routing logic is there, e.g., for handling popup windows
if((evtype == QEvent::TabletPress || evtype == QEvent::TouchBegin) && inputState == None) {
if(receiver->isWindowType()) {
int prevacceptcount = acceptCount;
receiver = getRecvWindow(receiver);
QApplication::notify(receiver, event);
if(acceptCount > prevacceptcount) {
acceptCount = prevacceptcount;
inputState = PassThru;
return true;
}
// else, fall through and resend as mouse event
// we must send a tablet release to put QWidgetWindow in consistent state
// doesn't appear to be necessary for TouchBegin
if(evtype == QEvent::TabletPress) {
QTabletEvent* tev = static_cast<QTabletEvent*>(event);
QTabletEvent rlev(QEvent::TabletRelease, tev->posF(), tev->globalPosF(), tev->device(),
tev->pointerType(), 0, 0, 0, 0, 0, 0, tev->modifiers(), tev->uniqueId());
QApplication::notify(receiver, &rlev);
}
}
else {
event->setAccepted(false);
bool res = QApplication::notify(receiver, event);
if(event->isAccepted())
acceptCount++;
return res;
}
}
switch(evtype) {
// reject external mouse events if we are translating touch or tablet input
case QEvent::MouseButtonRelease:
case QEvent::MouseMove:
case QEvent::MouseButtonPress:
// QWidgetWindow always forwards mouse event to widget as spontaneous event (why?)
if(inputState != None && event->spontaneous() && receiver->isWindowType())
return true; // qDebug("This event should be rejected!");
break;
case QEvent::TabletRelease:
if(inputState == PassThru)
inputState = None;
case QEvent::TabletMove:
case QEvent::TabletPress:
{
// TODO: should this only be done if inputState == TabletInput?
receiver = getRecvWindow(receiver);
QTabletEvent* tabletevent = static_cast<QTabletEvent*>(event);
QEvent::Type mevtype = QEvent::MouseMove;
if(inputState == None && evtype == QEvent::TabletPress) {
mevtype = QEvent::MouseButtonPress;
inputState = TabletInput;
}
else if(inputState != TabletInput) // this covers PassThru
break;
if(evtype == QEvent::TabletRelease) {
mevtype = QEvent::MouseButtonRelease;
inputState = None;
}
return sendMouseEvent(receiver, mevtype, tabletevent->globalPos(), tabletevent->modifiers());
}
#ifdef QT_5
case QEvent::TouchCancel:
evtype = QEvent::TouchEnd;
#endif
case QEvent::TouchEnd:
if(inputState == PassThru) // && touchPoints.count() == 1)
inputState = None;
case QEvent::TouchUpdate:
case QEvent::TouchBegin:
{
receiver = getRecvWindow(receiver);
QTouchEvent* touchevent = static_cast<QTouchEvent*>(event);
QEvent::Type mevtype = QEvent::MouseMove;
if(inputState == None && evtype == QEvent::TouchBegin
&& touchevent->touchPoints().size() == 1 && touchevent->device()->type() != QTouchDevice::TouchPad) {
activeTouchId = touchevent->touchPoints().first().id();
mevtype = QEvent::MouseButtonPress;
inputState = TouchInput;
}
else if(inputState != TouchInput) // this covers PassThru
break;
if(evtype == QEvent::TouchEnd)
inputState = None;
event->setAccepted(true);
QList<QTouchEvent::TouchPoint> touchPoints = touchevent->touchPoints();
for(int ii = 0; ii < touchPoints.count(); ++ii) {
const QTouchEvent::TouchPoint& touchpt = touchPoints.at(ii);
if(touchpt.id() == activeTouchId) {
if(touchpt.state() == Qt::TouchPointReleased) {
mevtype = QEvent::MouseButtonRelease;
activeTouchId = -1;
}
return sendMouseEvent(receiver, mevtype, touchpt.screenPos().toPoint(), touchevent->modifiers());
}
}
// swallow all touch events until TouchEnd
// another option would be to propagate the touch event with the activeTouchId point removed, if >1 point
return true;
}
default:
break;
}
return QApplication::notify(receiver, event);
}
void QEvdevMouseHandler::readMouseData()
{
struct ::input_event buffer[32];
int n = 0;
bool posChanged = false, btnChanged = false;
bool pendingMouseEvent = false;
int eventCompressCount = 0;
forever {
int result = QT_READ(m_fd, reinterpret_cast<char *>(buffer) + n, sizeof(buffer) - n);
if (result == 0) {
qWarning("Got EOF from the input device.");
return;
} else if (result < 0) {
if (errno != EINTR && errno != EAGAIN) {
qWarning("Could not read from input device: %s", strerror(errno));
return;
}
} else {
n += result;
if (n % sizeof(buffer[0]) == 0)
break;
}
}
n /= sizeof(buffer[0]);
for (int i = 0; i < n; ++i) {
struct ::input_event *data = &buffer[i];
//qDebug() << ">>" << hex << data->type << data->code << dec << data->value;
if (data->type == EV_ABS) {
// Touchpads: store the absolute position for now, will calculate a relative one later.
if (data->code == ABS_X && m_x != data->value) {
m_x = data->value;
posChanged = true;
} else if (data->code == ABS_Y && m_y != data->value) {
m_y = data->value;
posChanged = true;
}
} else if (data->type == EV_REL) {
if (data->code == REL_X) {
m_x += data->value;
posChanged = true;
} else if (data->code == REL_Y) {
m_y += data->value;
posChanged = true;
} else if (data->code == ABS_WHEEL) { // vertical scroll
// data->value: 1 == up, -1 == down
const int delta = 120 * data->value;
emit handleWheelEvent(delta, Qt::Vertical);
} else if (data->code == ABS_THROTTLE) { // horizontal scroll
// data->value: 1 == right, -1 == left
const int delta = 120 * -data->value;
emit handleWheelEvent(delta, Qt::Horizontal);
}
} else if (data->type == EV_KEY && data->code == BTN_TOUCH) {
// We care about touchpads only, not touchscreens -> don't map to button press.
// Need to invalidate prevx/y however to get proper relative pos.
m_prevInvalid = true;
} else if (data->type == EV_KEY && data->code >= BTN_LEFT && data->code <= BTN_JOYSTICK) {
Qt::MouseButton button = Qt::NoButton;
// BTN_LEFT == 0x110 in kernel's input.h
// The range of possible mouse buttons ends just before BTN_JOYSTICK, value 0x120.
switch (data->code) {
case 0x110: button = Qt::LeftButton; break; // BTN_LEFT
case 0x111: button = Qt::RightButton; break;
case 0x112: button = Qt::MiddleButton; break;
case 0x113: button = Qt::ExtraButton1; break; // AKA Qt::BackButton
case 0x114: button = Qt::ExtraButton2; break; // AKA Qt::ForwardButton
case 0x115: button = Qt::ExtraButton3; break; // AKA Qt::TaskButton
case 0x116: button = Qt::ExtraButton4; break;
case 0x117: button = Qt::ExtraButton5; break;
case 0x118: button = Qt::ExtraButton6; break;
case 0x119: button = Qt::ExtraButton7; break;
case 0x11a: button = Qt::ExtraButton8; break;
case 0x11b: button = Qt::ExtraButton9; break;
case 0x11c: button = Qt::ExtraButton10; break;
case 0x11d: button = Qt::ExtraButton11; break;
case 0x11e: button = Qt::ExtraButton12; break;
case 0x11f: button = Qt::ExtraButton13; break;
}
if (data->value)
m_buttons |= button;
else
m_buttons &= ~button;
btnChanged = true;
} else if (data->type == EV_SYN && data->code == SYN_REPORT) {
if (btnChanged) {
btnChanged = posChanged = false;
sendMouseEvent();
pendingMouseEvent = false;
} else if (posChanged) {
posChanged = false;
if (m_compression) {
pendingMouseEvent = true;
eventCompressCount++;
} else {
sendMouseEvent();
}
}
} else if (data->type == EV_MSC && data->code == MSC_SCAN) {
// kernel encountered an unmapped key - just ignore it
continue;
}
}
if (m_compression && pendingMouseEvent) {
int distanceSquared = (m_x - m_prevx)*(m_x - m_prevx) + (m_y - m_prevy)*(m_y - m_prevy);
if (distanceSquared > m_jitterLimitSquared)
sendMouseEvent();
}
}
void TasMouseEventGenerator::doMousePress(const TasEventTarget& target, Qt::MouseButton button, QPoint point, uint pointerNumber)
{
QMouseEvent* eventPress = new QMouseEvent(QEvent::MouseButtonPress, target.mapFromGlobal(point), point, button, button, 0);
sendMouseEvent(target, eventPress, pointerNumber);
}
void TasMouseEventGenerator::doMouseDblClick(const TasEventTarget& target, Qt::MouseButton button, QPoint point)
{
QMouseEvent* eventDblClick = new QMouseEvent(QEvent::MouseButtonDblClick, target.mapFromGlobal(point), point, button, Qt::NoButton, 0);
sendMouseEvent(target, eventDblClick);
}
void
BioWidget::mouseMoveEvent( QMouseEvent* event )
{
if (!sendMouseEvent(event))
QTextBrowser::mouseMoveEvent( event );
}
void TasMouseEventGenerator::doMouseRelease(const TasEventTarget& target, Qt::MouseButton button, QPoint point, uint pointerNumber)
{
QMouseEvent* eventRelease = new QMouseEvent(QEvent::MouseButtonRelease, target.mapFromGlobal(point), point, button, Qt::NoButton, 0);
sendMouseEvent(target, eventRelease, pointerNumber);
}
