bool MixxxKeyboard::eventFilter(QObject*, QEvent* e) {
if (e->type() == QEvent::FocusOut) {
// If we lose focus, we need to clear out the active key list
// because we might not get Key Release events.
m_qActiveKeyList.clear();
} else if (e->type() == QEvent::KeyPress) {
QKeyEvent* ke = (QKeyEvent *)e;
#ifdef __APPLE__
// On Mac OSX the nativeScanCode is empty (const 1) http://doc.qt.nokia.com/4.7/qkeyevent.html#nativeScanCode
// We may loose the release event if a the shift key is pressed later
// and there is character shift like "1" -> "!"
int keyId = ke->key();
#else
int keyId = ke->nativeScanCode();
#endif
//qDebug() << "KeyPress event =" << ke->key() << "KeyId =" << keyId;
// Run through list of active keys to see if the pressed key is already active
// Just for returning true if we are consuming this key event
foreach (const KeyDownInformation& keyDownInfo, m_qActiveKeyList) {
if (keyDownInfo.keyId == keyId) {
return true;
}
}
QKeySequence ks = getKeySeq(ke);
if (!ks.isEmpty()) {
ConfigValueKbd ksv(ks);
// Check if a shortcut is defined
bool result = false;
// using const_iterator here is faster than QMultiHash::values()
for (QMultiHash<ConfigValueKbd, ConfigKey>::const_iterator it =
m_keySequenceToControlHash.find(ksv);
it != m_keySequenceToControlHash.end() && it.key() == ksv; ++it) {
const ConfigKey& configKey = it.value();
if (configKey.group != "[KeyboardShortcuts]") {
ControlObject* control = ControlObject::getControl(configKey);
if (control) {
//qDebug() << configKey << "MIDI_NOTE_ON" << 1;
// Add key to active key list
m_qActiveKeyList.append(KeyDownInformation(
keyId, ke->modifiers(), control));
// Since setting the value might cause us to go down
// a route that would eventually clear the active
// key list, do that last.
control->setValueFromMidi(MIDI_NOTE_ON, 1);
result = true;
} else {
qDebug() << "Warning: Keyboard key is configured for nonexistent control:"
<< configKey.group << configKey.item;
}
}
}
return result;
}
} else if (e->type()==QEvent::KeyRelease) {
bool QtKeyEventProvider::eventFilter(QObject * obj, QEvent * event)
{
if (event->type() == QEvent::KeyPress ||
event->type() == QEvent::KeyRelease)
{
QKeyEvent * qKeyEvent = dynamic_cast<QKeyEvent*>(event);
if (qKeyEvent) {
auto eventType = QtEventTransformer::keyboardTypeFromQtType(qKeyEvent->type());
auto key = QtEventTransformer::fromQtKeyCode(qKeyEvent->key(), qKeyEvent->modifiers());
KeyboardEvent * keyEvent = new KeyboardEvent(eventType
, key, qKeyEvent->nativeScanCode(), qKeyEvent->modifiers());
passEvent(keyEvent);
return false;
}
}
return QObject::eventFilter(obj, event);
}
bool MixxxKeyboard::eventFilter(QObject*, QEvent* e) {
if (e->type() == QEvent::KeyPress) {
QKeyEvent* ke = (QKeyEvent *)e;
#ifdef __APPLE__
// On Mac OSX the nativeScanCode is empty (const 1) http://doc.qt.nokia.com/4.7/qkeyevent.html#nativeScanCode
// We may loose the release event if a the shift key is pressed later
// and there is character shift like "1" -> "!"
int keyId = ke->key();
#else
int keyId = ke->nativeScanCode();
#endif
//qDebug() << "KeyPress event =" << ke->key() << "KeyId =" << keyId;
// Run through list of active keys to see if the pressed key is already active
// Just for returning true if we are consuming this key event
foreach (const KeyDownInformation& keyDownInfo, m_qActiveKeyList) {
if (keyDownInfo.keyId == keyId) {
return true;
}
}
QKeySequence ks = getKeySeq(ke);
if (!ks.isEmpty()) {
// Check if a shortcut is defined
ConfigKey* pConfigKey = m_pKbdConfigObject->get(ConfigValueKbd(ks));
if (pConfigKey && pConfigKey->group != "[KeyboardShortcuts]") {
ControlObject* control = ControlObject::getControl(*pConfigKey);
if (control) {
//qDebug() << pConfigKey->group << pConfigKey->item << "MIDI_NOTE_ON" << 1;
control->setValueFromMidi(MIDI_NOTE_ON, 1);
// Add key to active key list
m_qActiveKeyList.append(KeyDownInformation(
keyId, ke->modifiers(), pConfigKey));
return true;
} else {
qDebug() << "Warning: Keyboard key is configured for nonexistent control: "
<< pConfigKey->group << " " << pConfigKey->item;
return false;
}
}
}
} else if (e->type()==QEvent::KeyRelease) {
void setXKeyEventSpecificFields(XEvent& xEvent, KeyboardEvent* event)
{
QKeyEvent* qKeyEvent = event->keyEvent()->qtEvent();
xEvent.xkey.root = QX11Info::appRootWindow();
xEvent.xkey.subwindow = 0; // we have no child window
xEvent.xkey.time = event->timeStamp();
xEvent.xkey.state = qKeyEvent->nativeModifiers();
xEvent.xkey.keycode = qKeyEvent->nativeScanCode();
xEvent.xkey.same_screen = true;
// NOTE: As the XEvents sent to the plug-in are synthesized and there is not a native window
// corresponding to the plug-in rectangle, some of the members of the XEvent structures are not
// set to their normal Xserver values. e.g. Key events don't have a position.
// source: https://developer.mozilla.org/en/NPEvent
xEvent.xkey.x = 0;
xEvent.xkey.y = 0;
xEvent.xkey.x_root = 0;
xEvent.xkey.y_root = 0;
}
//------------------------------------------------------------------------------
bool IgnoreUndoRedo::eventFilter(QObject* watched, QEvent* event)
{
if (event->type() == QEvent::KeyPress)
{
QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
if (keyEvent->matches(QKeySequence::Undo)
|| keyEvent->matches(QKeySequence::Redo))
{
QCoreApplication::postEvent(recipient, new QKeyEvent(
keyEvent->type(), keyEvent->key(), keyEvent->modifiers(),
keyEvent->nativeScanCode(), keyEvent->nativeVirtualKey(),
keyEvent->nativeModifiers(), keyEvent->text(),
keyEvent->isAutoRepeat(), keyEvent->count()
));
return true;
}
else
{
return false;
}
}
else
return QObject::eventFilter(watched, event);
}
bool QWindowCompositor::eventFilter(QObject *obj, QEvent *event)
{
if (obj != m_window)
return false;
QWaylandInputDevice *input = defaultInputDevice();
switch (event->type()) {
case QEvent::Expose:
m_renderScheduler.start(0);
if (m_window->isExposed()) {
// Alt-tabbing away normally results in the alt remaining in
// pressed state in the clients xkb state. Prevent this by sending
// a release. This is not an issue in a "real" compositor but
// is very annoying when running in a regular window on xcb.
Qt::KeyboardModifiers mods = QGuiApplication::queryKeyboardModifiers();
if (m_modifiers != mods && input->keyboardFocus()) {
Qt::KeyboardModifiers stuckMods = m_modifiers ^ mods;
if (stuckMods & Qt::AltModifier)
input->sendKeyReleaseEvent(64); // native scancode for left alt
m_modifiers = mods;
}
}
break;
case QEvent::MouseButtonPress: {
QPointF local;
QMouseEvent *me = static_cast<QMouseEvent *>(event);
QWaylandSurface *targetSurface = surfaceAt(me->localPos(), &local);
if (m_dragKeyIsPressed && targetSurface) {
m_draggingWindow = targetSurface;
m_drag_diff = local;
} else {
if (targetSurface && input->keyboardFocus() != targetSurface) {
input->setKeyboardFocus(targetSurface);
m_surfaces.removeOne(targetSurface);
m_surfaces.append(targetSurface);
m_renderScheduler.start(0);
}
input->sendMousePressEvent(me->button(), local, me->localPos());
}
return true;
}
case QEvent::MouseButtonRelease: {
QWaylandSurface *targetSurface = input->mouseFocus();
if (m_draggingWindow) {
m_draggingWindow = 0;
m_drag_diff = QPointF();
} else {
QMouseEvent *me = static_cast<QMouseEvent *>(event);
QPointF localPos;
if (targetSurface)
localPos = toSurface(targetSurface, me->localPos());
input->sendMouseReleaseEvent(me->button(), localPos, me->localPos());
}
return true;
}
case QEvent::MouseMove: {
QMouseEvent *me = static_cast<QMouseEvent *>(event);
if (m_draggingWindow) {
m_draggingWindow->setPos(me->localPos() - m_drag_diff);
m_renderScheduler.start(0);
} else {
QPointF local;
QWaylandSurface *targetSurface = surfaceAt(me->localPos(), &local);
input->sendMouseMoveEvent(targetSurface, local, me->localPos());
}
break;
}
case QEvent::Wheel: {
QWheelEvent *we = static_cast<QWheelEvent *>(event);
input->sendMouseWheelEvent(we->orientation(), we->delta());
break;
}
case QEvent::KeyPress: {
QKeyEvent *ke = static_cast<QKeyEvent *>(event);
if (ke->key() == Qt::Key_Meta || ke->key() == Qt::Key_Super_L) {
m_dragKeyIsPressed = true;
}
m_modifiers = ke->modifiers();
QWaylandSurface *targetSurface = input->keyboardFocus();
if (targetSurface)
input->sendKeyPressEvent(ke->nativeScanCode());
break;
}
case QEvent::KeyRelease: {
QKeyEvent *ke = static_cast<QKeyEvent *>(event);
if (ke->key() == Qt::Key_Meta || ke->key() == Qt::Key_Super_L) {
m_dragKeyIsPressed = false;
}
m_modifiers = ke->modifiers();
QWaylandSurface *targetSurface = input->keyboardFocus();
if (targetSurface)
input->sendKeyReleaseEvent(ke->nativeScanCode());
break;
}
case QEvent::TouchBegin:
case QEvent::TouchUpdate:
case QEvent::TouchEnd:
{
QWaylandSurface *targetSurface = 0;
QTouchEvent *te = static_cast<QTouchEvent *>(event);
QList<QTouchEvent::TouchPoint> points = te->touchPoints();
QPoint pointPos;
if (!points.isEmpty()) {
pointPos = points.at(0).pos().toPoint();
targetSurface = surfaceAt(pointPos);
}
if (targetSurface && targetSurface != input->mouseFocus())
input->setMouseFocus(targetSurface, pointPos, pointPos);
if (input->mouseFocus())
input->sendFullTouchEvent(te);
break;
}
default:
break;
}
return false;
}
bool ChatTextEdit::eventFilter(QObject *obj, QEvent *event)
{
if (event->type() == QEvent::KeyPress)
{
QKeyEvent *keyEvent = (QKeyEvent *) event;
if (keyEvent->key() == Qt::Key_Up)
{
// Key up
QTextCursor cursor = textCursor();
int pos = cursor.position();
bool sel = keyEvent->modifiers() == Qt::ShiftModifier;
cursor.movePosition(QTextCursor::Up, (sel ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor));
if (pos == cursor.position())
cursor.movePosition(QTextCursor::Start, (sel ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor));
setTextCursor(cursor);
return true;
}
else if (keyEvent->key() == Qt::Key_Down)
{
// Key down
QTextCursor cursor = textCursor();
int pos = cursor.position();
bool sel = keyEvent->modifiers() == Qt::ShiftModifier;
cursor.movePosition(QTextCursor::Down, (sel ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor));
if (pos == cursor.position())
cursor.movePosition(QTextCursor::End, (sel ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor));
setTextCursor(cursor);
return true;
}
else if (keyEvent->nativeScanCode() == 36)
{
// Return pressed
if (Client::enterIsSend && !(keyEvent->modifiers() & Qt::ShiftModifier))
{
isComposing = false;
emit returnPressed();
return true;
}
}
else if (keyEvent->nativeScanCode() == 54 &&
keyEvent->modifiers() == Qt::ControlModifier)
{
// Copy
QTextCursor cursor = textCursor();
if (cursor.hasSelection())
{
QTextDocumentFragment selection = cursor.selection();
QClipboard *clipboard = QApplication::clipboard();
clipboard->setText(Utilities::htmlToWAText(selection.toHtml()));
QMaemo5InformationBox::information(this,"Copied");
return true;
}
}
else if (keyEvent->nativeScanCode() == 55 &&
keyEvent->modifiers() == Qt::ControlModifier)
{
// Paste event
QTextCursor cursor = textCursor();
QClipboard *clipboard = QApplication::clipboard();
cursor.insertHtml(Utilities::WATextToHtml(clipboard->text(),32,false));
return true;
}
else if (!isComposing)
{
isComposing = true;
emit composing();
}
else
{
lastKeyPressed = QDateTime::currentMSecsSinceEpoch();
composingTimer.start(2000);
}
}
else if (event->type() == QEvent::InputMethod)
{
QInputMethodEvent *inputEvent = (QInputMethodEvent *) event;
//Utilities::logData("Commit String: '" + inputEvent->commitString() + "'");
if (inputEvent->commitString() == "\n" && Client::enterIsSend)
{
// Let's hide the keyboard if it was shown
QTimer::singleShot(0,this,SLOT(closeKB()));
isComposing = false;
emit returnPressed();
return true;
}
}
return QTextEdit::eventFilter(obj,event);
}
bool QtEvent::eventFilter(QObject *target, QEvent *event)
{
int type = event->type();
void *func = m_hash.value(type);
if (func != 0) {
int accept = event->isAccepted() ? 1 : 0;
switch(type) {
case QEvent::Create:
case QEvent::Close:
case QEvent::Show:
case QEvent::Hide:
case QEvent::Enter:
case QEvent::Leave: {
base_event ev = {accept};
drv_callback(func,&ev,0,0,0);
event->setAccepted(ev.accept != 0);
break;
}
case QEvent::FocusIn:
case QEvent::FocusOut: {
QFocusEvent *e = (QFocusEvent*)event;
focus_event ev = {accept,e->reason()};
drv_callback(func,&ev,0,0,0);
event->setAccepted(ev.accept != 0);
break;
}
case QEvent::Timer: {
QTimerEvent *e = (QTimerEvent*)event;
timer_event ev = {accept,e->timerId()};
drv_callback(func,&ev,0,0,0);
event->setAccepted(ev.accept != 0);
break;
}
case QEvent::HoverEnter:
case QEvent::HoverLeave:
case QEvent::HoverMove: {
QHoverEvent *e = (QHoverEvent*)event;
const QPoint &pt = e->pos();
const QPoint &opt = e->oldPos();
hover_event ev = {accept,pt.x(),pt.y(),opt.x(),opt.y()};
drv_callback(func,&ev,0,0,0);
event->setAccepted(ev.accept != 0);
break;
}
case QEvent::KeyPress:
case QEvent::KeyRelease: {
QKeyEvent *e = (QKeyEvent*)event;
string_head sh;
drvSetString(&sh,e->text());
key_event ev = {accept,e->modifiers(),e->count(),e->isAutoRepeat()?1:0,e->key(),e->nativeModifiers(),e->nativeScanCode(),e->nativeVirtualKey(),&sh};
drv_callback(func,&ev,0,0,0);
event->setAccepted(ev.accept != 0);
break;
}
case QEvent::MouseButtonPress:
case QEvent::MouseButtonRelease:
case QEvent::MouseButtonDblClick:
case QEvent::MouseMove: {
QMouseEvent *e = (QMouseEvent*)event;
const QPoint &gpt = e->globalPos();
const QPoint &pt = e->pos();
mouse_event ev = {accept,e->modifiers(),e->button(),e->buttons(),gpt.x(),gpt.y(),pt.x(),pt.y()};
drv_callback(func,&ev,0,0,0);
event->setAccepted(ev.accept != 0);
break;
}
case QEvent::Move: {
QMoveEvent *e = (QMoveEvent*)event;
const QPoint &pt = e->pos();
const QPoint &opt = e->oldPos();
move_event ev = {accept,pt.x(),pt.y(),opt.x(),opt.y()};
drv_callback(func,&ev,0,0,0);
event->setAccepted(ev.accept != 0);
break;
}
case QEvent::Resize: {
QResizeEvent *e = (QResizeEvent*)event;
const QSize &sz = e->size();
const QSize &osz = e->oldSize();
resize_event ev = {accept,sz.width(),sz.height(),osz.width(),osz.height()};
drv_callback(func,&ev,0,0,0);
event->setAccepted(ev.accept != 0);
break;
}
case QEvent::Paint: {
QPaintEvent *e = (QPaintEvent*)event;
const QRect &rc = e->rect();
paint_event ev = {accept,rc.x(),rc.y(),rc.width(),rc.height()};
drv_callback(func,&ev,0,0,0);
event->setAccepted(ev.accept != 0);
break;
}
default: {
return QObject::eventFilter(target,event);
}
}
return true;
}
return QObject::eventFilter(target,event);
}
bool QSpiApplicationAdaptor::eventFilter(QObject *target, QEvent *event)
{
if (!event->spontaneous())
return false;
switch (event->type()) {
case QEvent::WindowActivate:
emit windowActivated(target, true);
break;
case QEvent::WindowDeactivate:
emit windowActivated(target, false);
break;
case QEvent::KeyPress:
case QEvent::KeyRelease: {
QKeyEvent *keyEvent = static_cast <QKeyEvent *>(event);
QSpiDeviceEvent de;
if (event->type() == QEvent::KeyPress)
de.type = QSPI_KEY_EVENT_PRESS;
else
de.type = QSPI_KEY_EVENT_RELEASE;
de.id = keyEvent->nativeVirtualKey();
de.hardwareCode = keyEvent->nativeScanCode();
de.modifiers = keyEvent->nativeModifiers();
de.timestamp = QDateTime::currentMSecsSinceEpoch();
if (keyEvent->key() == Qt::Key_Tab)
de.text = QStringLiteral("Tab");
else if (keyEvent->key() == Qt::Key_Backtab)
de.text = QStringLiteral("Backtab");
else if (keyEvent->key() == Qt::Key_Left)
de.text = (keyEvent->modifiers() & Qt::KeypadModifier) ? QStringLiteral("KP_Left") : QStringLiteral("Left");
else if (keyEvent->key() == Qt::Key_Right)
de.text = (keyEvent->modifiers() & Qt::KeypadModifier) ? QStringLiteral("KP_Right") : QStringLiteral("Right");
else if (keyEvent->key() == Qt::Key_Up)
de.text = (keyEvent->modifiers() & Qt::KeypadModifier) ? QStringLiteral("KP_Up") : QStringLiteral("Up");
else if (keyEvent->key() == Qt::Key_Down)
de.text = (keyEvent->modifiers() & Qt::KeypadModifier) ? QStringLiteral("KP_Down") : QStringLiteral("Down");
else if (keyEvent->key() == Qt::Key_Enter || keyEvent->key() == Qt::Key_Return)
de.text = QStringLiteral("Return");
else if (keyEvent->key() == Qt::Key_Backspace)
de.text = QStringLiteral("BackSpace");
else if (keyEvent->key() == Qt::Key_Delete)
de.text = QStringLiteral("Delete");
else if (keyEvent->key() == Qt::Key_PageUp)
de.text = (keyEvent->modifiers() & Qt::KeypadModifier) ? QStringLiteral("KP_Page_Up") : QStringLiteral("Page_Up");
else if (keyEvent->key() == Qt::Key_PageDown)
de.text = (keyEvent->modifiers() & Qt::KeypadModifier) ? QStringLiteral("KP_Page_Up") : QStringLiteral("Page_Down");
else if (keyEvent->key() == Qt::Key_Home)
de.text = (keyEvent->modifiers() & Qt::KeypadModifier) ? QStringLiteral("KP_Home") : QStringLiteral("Home");
else if (keyEvent->key() == Qt::Key_End)
de.text = (keyEvent->modifiers() & Qt::KeypadModifier) ? QStringLiteral("KP_End") : QStringLiteral("End");
else if (keyEvent->key() == Qt::Key_Clear && (keyEvent->modifiers() & Qt::KeypadModifier))
de.text = QStringLiteral("KP_Begin"); // Key pad 5
else if (keyEvent->key() == Qt::Key_Escape)
de.text = QStringLiteral("Escape");
else if (keyEvent->key() == Qt::Key_Space)
de.text = QStringLiteral("space");
else if (keyEvent->key() == Qt::Key_CapsLock)
de.text = QStringLiteral("Caps_Lock");
else if (keyEvent->key() == Qt::Key_NumLock)
de.text = QStringLiteral("Num_Lock");
else if (keyEvent->key() == Qt::Key_Insert)
de.text = QStringLiteral("Insert");
else
de.text = keyEvent->text();
// This is a bit dubious, Gnome uses some gtk function here.
// Long term the spec will hopefully change to just use keycodes.
de.isText = !de.text.isEmpty();
#ifdef KEYBOARD_DEBUG
qDebug() << QStringLiteral("Key event text: ") << event->type() << de.isText << QStringLiteral(" ") << de.text
<< QStringLiteral(" hardware code: ") << de.hardwareCode
<< QStringLiteral(" native sc: ") << keyEvent->nativeScanCode()
<< QStringLiteral(" native mod: ") << keyEvent->nativeModifiers()
<< QStringLiteral("native virt: ") << keyEvent->nativeVirtualKey();
#endif
QDBusMessage m = QDBusMessage::createMethodCall(QStringLiteral("org.a11y.atspi.Registry"),
QStringLiteral("/org/a11y/atspi/registry/deviceeventcontroller"),
QStringLiteral("org.a11y.atspi.DeviceEventController"), QStringLiteral("NotifyListenersSync"));
m.setArguments(QVariantList() <<QVariant::fromValue(de));
// FIXME: this is critical, the timeout should probably be pretty low to allow normal processing
int timeout = 100;
bool sent = dbusConnection.callWithCallback(m, this, SLOT(notifyKeyboardListenerCallback(QDBusMessage)),
SLOT(notifyKeyboardListenerError(QDBusError, QDBusMessage)), timeout);
if (sent) {
//queue the event and send it after callback
keyEvents.enqueue(QPair<QObject*, QKeyEvent*> (target, copyKeyEvent(keyEvent)));
#ifdef KEYBOARD_DEBUG
qDebug() << QStringLiteral("Sent key: ") << de.text;
#endif
return true;
}
}
default:
break;
}
return false;
}
bool QtWaylandMotorcarCompositor::eventFilter(QObject *obj, QEvent *event)
{
if (obj != m_glData->m_window)
return false;
QWaylandInputDevice *input = defaultInputDevice();
switch (event->type()) {
case QEvent::Expose:
m_renderScheduler.start(0);
if (m_glData->m_window->isExposed()) {
// Alt-tabbing away normally results in the alt remaining in
// pressed state in the clients xkb state. Prevent this by sending
// a release. This is not an issue in a "real" compositor but
// is very annoying when running in a regular window on xcb.
Qt::KeyboardModifiers mods = QGuiApplication::queryKeyboardModifiers();
if (m_modifiers != mods && input->keyboardFocus()) {
Qt::KeyboardModifiers stuckMods = m_modifiers ^ mods;
if (stuckMods & Qt::AltModifier)
input->sendKeyReleaseEvent(64); // native scancode for left alt
m_modifiers = mods;
}
}
break;
// case QEvent::MouseButtonPress: {
// QPointF local;
// QMouseEvent *me = static_cast<QMouseEvent *>(event);
// QWaylandSurface *targetSurface = surfaceAt(me->localPos(), &local);
// if (m_dragKeyIsPressed && targetSurface) {
// m_draggingWindow = targetSurface;
// m_drag_diff = local;
// } else {
// if (targetSurface && input->keyboardFocus() != targetSurface) {
// input->setKeyboardFocus(targetSurface);
// // m_surfaces.removeOne(targetSurface);
// // m_surfaces.append(targetSurface);
// //m_renderScheduler.start(0);
// }
// input->sendMousePressEvent(me->button(), local, me->localPos());
// }
// return true;
// }
// case QEvent::MouseButtonRelease: {
// QWaylandSurface *targetSurface = input->mouseFocus();
// if (m_draggingWindow) {
// m_draggingWindow = 0;
// m_drag_diff = QPointF();
// } else {
// QMouseEvent *me = static_cast<QMouseEvent *>(event);
// QPointF localPos;
// if (targetSurface)
// localPos = toSurface(targetSurface, me->localPos());
// input->sendMouseReleaseEvent(me->button(), localPos, me->localPos());
// }
// return true;
// }
// case QEvent::MouseMove: {
// QMouseEvent *me = static_cast<QMouseEvent *>(event);
// if (m_draggingWindow) {
// m_draggingWindow->setPos(me->localPos() - m_drag_diff);
// //m_renderScheduler.start(0);
// } else {
// QPointF local;
// QWaylandSurface *targetSurface = surfaceAt(me->localPos(), &local);
// input->sendMouseMoveEvent(targetSurface, local, me->localPos());
// }
// break;
// }
// case QEvent::Wheel: {
// QWheelEvent *we = static_cast<QWheelEvent *>(event);
// input->sendMouseWheelEvent(we->orientation(), we->delta());
// break;
// }
case QEvent::KeyPress: {
QKeyEvent *ke = static_cast<QKeyEvent *>(event);
// if (ke->key() == Qt::Key_Meta || ke->key() == Qt::Key_Super_L) {
// m_dragKeyIsPressed = true;
// }/*else if(ke->key() == Qt::Key_Up){
// m_glData->m_cameraNode->setTransform(glm::translate(glm::mat4(1), glm::vec3(0,0,0.001f)) * m_glData->m_cameraNode->transform());
// }else if(ke->key() == Qt::Key_Down){
// m_glData->m_cameraNode->setTransform(glm::translate(glm::mat4(1), glm::vec3(0,0,-0.001f)) * m_glData->m_cameraNode->transform());
// }*/
// m_modifiers = ke->modifiers();
// QWaylandSurface *targetSurface = input->keyboardFocus();
// if (targetSurface)
// input->sendKeyPressEvent(ke->nativeScanCode());
this->scene()->windowManager()->sendEvent(motorcar::KeyboardEvent(motorcar::KeyboardEvent::Event::KEY_PRESS, ke->nativeScanCode(), defaultSeat()));
break;
}
case QEvent::KeyRelease: {
QKeyEvent *ke = static_cast<QKeyEvent *>(event);
// if (ke->key() == Qt::Key_Meta || ke->key() == Qt::Key_Super_L) {
// m_dragKeyIsPressed = false;
// }
// m_modifiers = ke->modifiers();
// QWaylandSurface *targetSurface = input->keyboardFocus();
// if (targetSurface)
// input->sendKeyReleaseEvent(ke->nativeScanCode());
this->scene()->windowManager()->sendEvent(motorcar::KeyboardEvent(motorcar::KeyboardEvent::Event::KEY_RELEASE, ke->nativeScanCode(), defaultSeat()));
break;
}
// case QEvent::TouchBegin:
// case QEvent::TouchUpdate:
// case QEvent::TouchEnd:
// {
// QWaylandSurface *targetSurface = 0;
// QTouchEvent *te = static_cast<QTouchEvent *>(event);
// QList<QTouchEvent::TouchPoint> points = te->touchPoints();
// QPoint pointPos;
// if (!points.isEmpty()) {
// pointPos = points.at(0).pos().toPoint();
// targetSurface = surfaceAt(pointPos);
// }
// if (targetSurface && targetSurface != input->mouseFocus())
// input->setMouseFocus(targetSurface, pointPos, pointPos);
// if (input->mouseFocus())
// input->sendFullTouchEvent(te);
// break;
// }
default:
break;
}
return false;
}
// Обработчик нажатия/отпускания клавиши Ctrl или Shift
void QWheelZoomSvc::switchWheel(QEvent *event)
{
// читаем режим масштабирования
QwtChartZoom::QConvType ct = zoom->regim();
// создаем указатель на событие от клавиатуры
QKeyEvent *kEvent = static_cast<QKeyEvent *>(event);
// переключаем режим в зависимости от клавиши
switch (kEvent->key())
{
// клавиша Ctrl
case Qt::Key_Control:
// в зависимости от события
switch (event->type())
{
// клавиша нажата
case QEvent::KeyPress:
// если не включен никакой другой режим,
if (ct == QwtChartZoom::ctNone)
// то включаем режим Wheel
zoom->setRegim(QwtChartZoom::ctWheel);
// клавиша отпущена
case QEvent::KeyRelease:
// если включен режим Wheel,
if (ct == QwtChartZoom::ctWheel)
// то выключаем его
zoom->setRegim(QwtChartZoom::ctNone);
break;
// иначе ничего не делаем
default: ;
}
break;
// клавиша Shift
case Qt::Key_Shift:
// в зависимости от события
switch (event->type())
{
// клавиша нажата
case QEvent::KeyPress:
#ifdef R_SHIFT
// платформа Win или X11
// если не включен никакой другой режим, то
if (ct == QwtChartZoom::ctNone)
{
// если нажат правый Shift,
if (kEvent->nativeScanCode() == R_SHIFT)
// то включаем режим ctHorWheel
zoom->setRegim(QwtChartZoom::ctHorWheel);
// иначе (нажат левый Shift) включаем режим ctVerWheel
else zoom->setRegim(QwtChartZoom::ctVerWheel);
}
#else
// неизвестная платформа
// если не включен никакой другой режим,
if (ct == QwtChartZoom::ctNone)
// то включаем режим ctVerWheel
zoom->setRegim(QwtChartZoom::ctVerWheel);
#endif
break;
// клавиша отпущена
case QEvent::KeyRelease:
#ifdef R_SHIFT
// платформа Win или X11
// если отпущен правый Shift,
if (kEvent->nativeScanCode() == R_SHIFT)
{
// если включен режим ctHorWheel,
if (ct == QwtChartZoom::ctHorWheel)
// то выключаем его
zoom->setRegim(QwtChartZoom::ctNone);
}
// иначе (отпущен левый Shift)
// если включен режим ctVerWheel,
else if (ct == QwtChartZoom::ctVerWheel)
// то выключаем его
zoom->setRegim(QwtChartZoom::ctNone);
#else
// неизвестная платформа
// если включен режим ctVerWheel,
if (ct == QwtChartZoom::ctVerWheel)
// то выключаем его
zoom->setRegim(QwtChartZoom::ctNone);
#endif
break;
// иначе ничего не делаем
default: ;
}
break;
// для остальных ничего не делаем
default: ;
}
}
bool SimpleKeyGrabberButton::eventFilter(QObject *obj, QEvent *event)
{
Q_UNUSED(obj);
int controlcode = 0;
if (grabNextAction && event->type() == QEvent::MouseButtonRelease)
{
QMouseEvent *mouseEve = (QMouseEvent*) event;
if (mouseEve->button() == Qt::RightButton)
{
controlcode = 3;
}
else if (mouseEve->button() == Qt::MiddleButton)
{
controlcode = 2;
}
else {
controlcode = mouseEve->button();
}
setText(QString(tr("Mouse")).append(" ").append(QString::number(controlcode)));
buttonslot.setSlotCode(controlcode);
buttonslot.setSlotMode(JoyButtonSlot::JoyMouseButton);
releaseMouse();
releaseKeyboard();
grabNextAction = grabbingWheel = false;
emit buttonCodeChanged(controlcode);
}
else if (grabNextAction && event->type() == QEvent::KeyRelease)
{
QKeyEvent *keyEve = (QKeyEvent*) event;
int tempcode = keyEve->nativeScanCode();
int virtualactual = keyEve->nativeVirtualKey();
#ifdef Q_OS_WIN
// Find more specific virtual key (VK_SHIFT -> VK_LSHIFT)
// by checking for extended bit in scan code.
int finalvirtual = WinInfo::correctVirtualKey(tempcode, virtualactual);
int checkalias = AntKeyMapper::returnQtKey(virtualactual, tempcode);
#else
// Obtain group 1 X11 keysym. Removes effects from modifiers.
int finalvirtual = X11KeyCodeToX11KeySym(tempcode);
// Check for alias against group 1 keysym.
int checkalias = AntKeyMapper::returnQtKey(finalvirtual);
#endif
controlcode = tempcode;
if ((keyEve->modifiers() & Qt::ControlModifier) && keyEve->key() == Qt::Key_X)
{
controlcode = 0;
setText("");
}
else if (controlcode <= 0)
{
controlcode = 0;
setText("");
}
else
{
if (checkalias > 0)
{
buttonslot.setSlotCode(finalvirtual, checkalias);
buttonslot.setSlotMode(JoyButtonSlot::JoyKeyboard);
setText(keysymToKey(finalvirtual, checkalias).toUpper());
}
else
{
buttonslot.setSlotCode(virtualactual);
buttonslot.setSlotMode(JoyButtonSlot::JoyKeyboard);
setText(keysymToKey(finalvirtual).toUpper());
}
}
grabNextAction = false;
grabbingWheel = false;
releaseMouse();
releaseKeyboard();
emit buttonCodeChanged(controlcode);
}
else if (grabNextAction && event->type() == QEvent::Wheel && !grabbingWheel)
{
grabbingWheel = true;
}
else if (grabNextAction && event->type() == QEvent::Wheel)
{
QWheelEvent *wheelEve = (QWheelEvent*) event;
QString text = QString(tr("Mouse")).append(" ");
if (wheelEve->orientation() == Qt::Vertical && wheelEve->delta() >= 120)
{
controlcode = 4;
}
else if (wheelEve->orientation() == Qt::Vertical && wheelEve->delta() <= -120)
{
controlcode = 5;
}
else if (wheelEve->orientation() == Qt::Horizontal && wheelEve->delta() >= 120)
{
controlcode = 6;
}
else if (wheelEve->orientation() == Qt::Horizontal && wheelEve->delta() <= -120)
{
controlcode = 7;
}
if (controlcode > 0)
{
text = text.append(QString::number(controlcode));
setText(text);
grabNextAction = false;
grabbingWheel = false;
releaseMouse();
releaseKeyboard();
buttonslot.setSlotCode(controlcode);
buttonslot.setSlotMode(JoyButtonSlot::JoyMouseButton);
emit buttonCodeChanged(controlcode);
}
}
else if (event->type() == QEvent::MouseButtonRelease)
{
QMouseEvent *mouseEve = (QMouseEvent*) event;
if (mouseEve->button() == Qt::LeftButton)
{
grabNextAction = true;
setText("...");
setFocus();
grabKeyboard();
grabMouse();
}
}
return false;
}
bool QSpiApplicationAdaptor::eventFilter(QObject *target, QEvent *event)
{
if (!event->spontaneous())
return false;
switch (event->type()) {
case QEvent::WindowActivate: {
emit windowActivated(target, true);
break;
case QEvent::WindowDeactivate:
emit windowActivated(target, false);
break;
}
case QEvent::KeyPress:
case QEvent::KeyRelease: {
QKeyEvent *keyEvent = static_cast <QKeyEvent *>(event);
QSpiDeviceEvent de;
if (event->type() == QEvent::KeyPress)
de.type = QSPI_KEY_EVENT_PRESS;
else
de.type = QSPI_KEY_EVENT_RELEASE;
de.id = keyEvent->nativeVirtualKey();
de.hardwareCode = keyEvent->nativeScanCode();
de.modifiers = keyEvent->nativeModifiers();
de.timestamp = QDateTime::currentMSecsSinceEpoch();
// FIXME: how to generate key strings?
// FIXME: localize?
if (keyEvent->key() == Qt::Key_Tab) {
de.text = "Tab";
} else if (keyEvent->key() == Qt::Key_Backtab) {
de.text = "Backtab";
} else if (keyEvent->key() == Qt::Key_Left) {
de.text = (keyEvent->modifiers() & Qt::KeypadModifier) ? "KP_Left" : "Left";
} else if (keyEvent->key() == Qt::Key_Right) {
de.text = (keyEvent->modifiers() & Qt::KeypadModifier) ? "KP_Right" : "Right";
} else if (keyEvent->key() == Qt::Key_Up) {
de.text = (keyEvent->modifiers() & Qt::KeypadModifier) ? "KP_Up" : "Up";
} else if (keyEvent->key() == Qt::Key_Down) {
de.text = (keyEvent->modifiers() & Qt::KeypadModifier) ? "KP_Down" : "Down";
} else if (keyEvent->key() == Qt::Key_Enter || keyEvent->key() == Qt::Key_Return) {
de.text = "Return";
} else if (keyEvent->key() == Qt::Key_Backspace) {
de.text = "BackSpace";
} else if (keyEvent->key() == Qt::Key_Delete) {
de.text = "Delete";
} else if (keyEvent->key() == Qt::Key_PageUp) {
de.text = (keyEvent->modifiers() & Qt::KeypadModifier) ? "KP_Page_Up" : "Page_Up";
} else if (keyEvent->key() == Qt::Key_PageDown) {
de.text = (keyEvent->modifiers() & Qt::KeypadModifier) ? "KP_Page_Up" : "Page_Down";
} else if (keyEvent->key() == Qt::Key_Home) {
de.text = (keyEvent->modifiers() & Qt::KeypadModifier) ? "KP_Home" : "Home";
} else if (keyEvent->key() == Qt::Key_End) {
de.text = (keyEvent->modifiers() & Qt::KeypadModifier) ? "KP_End" : "End";
} else if (keyEvent->key() == Qt::Key_Clear && (keyEvent->modifiers() & Qt::KeypadModifier)) {
de.text = "KP_Begin"; // Key pad 5
} else if (keyEvent->key() == Qt::Key_Escape) {
de.text = "Escape";
} else if (keyEvent->key() == Qt::Key_Space) {
de.text = "space";
} else if (keyEvent->key() == Qt::Key_CapsLock) {
de.text = "Caps_Lock";
} else if (keyEvent->key() == Qt::Key_NumLock) {
de.text = "Num_Lock";
} else if (keyEvent->key() == Qt::Key_Insert) {
de.text = "Insert";
} else {
de.text = keyEvent->text();
}
// "F1", "F2", "F3", "F4", "F5", "F6",
// "F7", "F8", "F9", "F10", "F11", "F12"
// FIXME
de.isText = !de.text.isEmpty();
#ifdef KEYBOARD_DEBUG
qDebug() << "Key event text: " << event->type() << de.isText << " " << de.text
<< " hardware code: " << de.hardwareCode
<< " native sc: " << keyEvent->nativeScanCode()
<< " native mod: " << keyEvent->nativeModifiers()
<< "native virt: " << keyEvent->nativeVirtualKey();
#endif
QDBusMessage m = QDBusMessage::createMethodCall("org.a11y.atspi.Registry",
"/org/a11y/atspi/registry/deviceeventcontroller",
"org.a11y.atspi.DeviceEventController", "NotifyListenersSync");
m.setArguments(QVariantList() <<QVariant::fromValue(de));
// FIXME: this is critical, the timeout should probably be pretty low to allow normal processing
int timeout = 300;
bool sent = dbusConnection.callWithCallback(m, this, SLOT(notifyKeyboardListenerCallback(QDBusMessage)),
SLOT(notifyKeyboardListenerError(QDBusError, QDBusMessage)), timeout);
if (sent) {
//queue the event and send it after callback
keyEvents.enqueue(QPair<QObject*, QKeyEvent*> (target, copyKeyEvent(keyEvent)));
return true;
}
}
default:
break;
}
return false;
}
