bool InputManager::handleEvent(QEvent* event)
{
if (event->type() != QEvent::KeyPress && event->type() != QEvent::KeyRelease)
return false;
QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
Qt::Key key = static_cast<Qt::Key>(keyEvent->key());
const char* keyCategory = NULL;
// NOTE: We can potentially get key presses on the device before
// com.palm.keys comes up, and these won't be broadcast to subscribers
// However, we assume that we wouldn't want them to receive a collection
// of queued up key presses
// Each subset of keys must not overlap in the current handling
if (isAudioKey(key)) {
keyCategory = CATEGORY_AUDIO;
} else if (isMediaKey(key)) {
keyCategory = CATEGORY_MEDIA;
} else if (isSwitch(key)) {
keyCategory = CATEGORY_SWITCHES;
} else if (isHeadsetKey(key)) {
if (!(key == KEYS::Key_Headset || key == KEYS::Key_HeadsetMic)) {
// state machine time -- headset button
headsetStateMachine(keyEvent);
}
keyCategory = CATEGORY_HEADSET;
} else if (isBluetoothKey(key)) {
handleBluetoothKey(keyEvent);
return true;
} else {
// Not a key that we care about, so we indicate we didn't handle it
return false;
}
// first event that comes in sets the sticky state, no matter
// whether it is a real action that a user did or a generated
// "InitialState"
static int switchInitCount = 0;
if (setKeyState(key, event->type())) {
if (NULL == m_publicService && (++switchInitCount == HostBase::instance()->getNumberOfSwitches() )) {
startService();
}
}
// We don't post the "InitialState" key because it is internally
// generated in order to get initial state of a key
if (!(keyEvent->nativeModifiers() & SysMgrNativeKeyboardModifier_InitialState)) {
const char* keyString = NULL;
keyToString(key, &keyString);
(void)postKeyToSubscribers(keyEvent, keyCategory, keyString, NULL);
}
return true;
}
bool KHotkey::eventFilter( QObject *object, QEvent *event )
{
Q_UNUSED(object);
Q_D(KHotkey);
if ( d->m_isEnable)
{
if (QEvent::KeyPress == event->type())
{
QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
setHotkey(keyEvent->nativeModifiers(), keyEvent->nativeVirtualKey());
emit hotkeyChanged(d->m_modifierKey, d->m_virtualKey);
return true;
}
}
return false;
}
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 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 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;
}
