bool View::event(QEvent* pEvent)
{
if (pEvent->type() == QEvent::KeyPress || pEvent->type() == QEvent::ShortcutOverride)
{
QKeyEvent* pKeyEvent = static_cast<QKeyEvent*>(pEvent);
std::size_t scanCode = pKeyEvent->nativeVirtualKey();
g_pModel->sendMessage(kernel->runtime(), RDOThread::Message::RUNTIME_KEY_DOWN, &scanCode);
if (pKeyEvent->key() == Qt::Key_F1)
{
QByteArray ba;
ba.append("setSource qthelp://language/doc/rdo_studio_rus/html/work_model/work_model_frame.htm\n");
g_pApp->callQtAssistant(ba);
}
return true;
}
else if (pEvent->type() == QEvent::KeyRelease)
{
QKeyEvent* pKeyEvent = static_cast<QKeyEvent*>(pEvent);
std::size_t scanCode = pKeyEvent->nativeVirtualKey();
g_pModel->sendMessage(kernel->runtime(), RDOThread::Message::RUNTIME_KEY_UP, &scanCode);
return true;
}
return parent_type::event(pEvent);
}
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;
}
bool QComposeInputContext::filterEvent(const QEvent *event)
{
// if there were errors when generating the compose table input
// context should not try to filter anything, simply return false
if ((m_tableState & TableGenerator::NoErrors) != TableGenerator::NoErrors)
return false;
QKeyEvent *keyEvent = (QKeyEvent *)event;
// should pass only the key presses
if (keyEvent->type() != QEvent::KeyPress) {
return false;
}
int keyval = keyEvent->key();
int keysym = 0;
if (ignoreKey(keyval))
return false;
QString text = keyEvent->text();
if (!composeKey(keyval) && text.isEmpty())
return false;
keysym = keyEvent->nativeVirtualKey();
int nCompose = 0;
while (m_composeBuffer[nCompose] != 0 && nCompose < QT_KEYSEQUENCE_MAX_LEN)
nCompose++;
if (nCompose == QT_KEYSEQUENCE_MAX_LEN) {
reset();
nCompose = 0;
}
m_composeBuffer[nCompose] = keysym;
// check sequence
if (checkComposeTable())
return true;
return false;
}
int WinPlatform::keyCode(const QKeyEvent &event)
{
const int key = event.key();
// Some keys shouldn't be translated.
if ( key == Qt::Key_Return
|| key == Qt::Key_Enter
|| key == Qt::Key_Escape
|| key == Qt::Key_Tab
|| key == Qt::Key_Backtab
|| key == Qt::Key_Backspace
)
{
return key;
}
const quint32 vk = event.nativeVirtualKey();
const UINT result = MapVirtualKeyW(vk, MAPVK_VK_TO_CHAR);
if (result != 0)
return result;
return key;
}
//------------------------------------------------------------------------------
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 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;
}
void KeyCaptureTestApp::processEvent(const QString &prefix, QEvent *ev)
{
TX_ENTRY_ARGS(reinterpret_cast<int>(ev));
if (ev){
if (ev->type() == QEvent::KeyPress){
QKeyEvent *keyEvent = static_cast<QKeyEvent *>(ev);
QString keyName = mappingPtr->name(static_cast<Qt::Key>(keyEvent->key()));
addTextLine(prefix + QString("KeyPress:%1\n").arg(keyName));
} else if (ev->type() == QEvent::KeyRelease){
QKeyEvent *keyEvent = static_cast<QKeyEvent *>(ev);
QString keyName = mappingPtr->name(static_cast<Qt::Key>(keyEvent->key()));
addTextLine(prefix + QString("KeyRelease:%1\n").arg(keyName));
} else if (ev->type() == XQKeyCapture::remoteEventType_KeyPress()){
QKeyEvent *keyEvent = static_cast<QKeyEvent *>(ev);
QString keyName = mappingPtr->name(static_cast<Qt::Key>(keyEvent->key()));
addTextLine(prefix + QString("KeyPress:%1 (native:%2)\n").arg(keyName).arg(static_cast<int>(keyEvent->nativeVirtualKey())));
} else if (ev->type() == XQKeyCapture::remoteEventType_KeyRelease()){
QKeyEvent *keyEvent = static_cast<QKeyEvent *>(ev);
QString keyName = mappingPtr->name(static_cast<Qt::Key>(keyEvent->key()));
addTextLine(prefix + QString("KeyRelease:%1 (native:%2)\n").arg(keyName).arg(static_cast<int>(keyEvent->nativeVirtualKey())));
}
}
TX_EXIT_ARGS(reinterpret_cast<int>(ev));
}
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;
}
