void QWaylandInputDevice::inputHandleKeyboardFocus(void *data, struct wl_input_device *input_device, uint32_t time, struct wl_surface *surface, struct wl_array *keys) { #ifndef QT_NO_WAYLAND_XKB Q_UNUSED(input_device); Q_UNUSED(time); QWaylandInputDevice *inputDevice = (QWaylandInputDevice *) data; QWaylandWindow *window; uint32_t *k, *end; uint32_t code; end = (uint32_t *) ((char *) keys->data + keys->size); inputDevice->mModifiers = 0; for (k = (uint32_t *) keys->data; k < end; k++) { code = *k + inputDevice->mXkb->min_key_code; inputDevice->mModifiers |= translateModifiers(inputDevice->mXkb->map->modmap[code]); } if (surface) { window = (QWaylandWindow *) wl_surface_get_user_data(surface); inputDevice->mKeyboardFocus = window; QWindowSystemInterface::handleWindowActivated(window->widget()); } else { inputDevice->mKeyboardFocus = NULL; QWindowSystemInterface::handleWindowActivated(0); } #endif }
void QtKeySequenceEdit::handleKeyEvent(QKeyEvent *e) { int nextKey = e->key(); if (nextKey == Qt::Key_Control || nextKey == Qt::Key_Shift || nextKey == Qt::Key_Meta || nextKey == Qt::Key_Alt || nextKey == Qt::Key_Super_L || nextKey == Qt::Key_AltGr) return; nextKey |= translateModifiers(e->modifiers(), e->text()); int k0 = m_keySequence[0]; int k1 = m_keySequence[1]; int k2 = m_keySequence[2]; int k3 = m_keySequence[3]; switch (m_num) { case 0: k0 = nextKey; k1 = 0; k2 = 0; k3 = 0; break; case 1: k1 = nextKey; k2 = 0; k3 = 0; break; case 2: k2 = nextKey; k3 = 0; break; case 3: k3 = nextKey; break; default: break; } ++m_num; if (m_num > 3) m_num = 0; m_keySequence = QKeySequence(k0, k1, k2, k3); m_lineEdit->setText(m_keySequence.toString(QKeySequence::NativeText)); e->accept(); emit keySequenceChanged(m_keySequence); }
bool ShortcutEdit::event(QEvent *event) { switch (event->type()) { case QEvent::KeyPress: { QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event); switch (keyEvent->key()) { case Qt::Key_Alt: case Qt::Key_Control: case Qt::Key_Meta: case Qt::Key_Shift: return true; default: m_key = keyEvent->key(); m_key |= translateModifiers(keyEvent->modifiers(), keyEvent->text()); setText(keySequence().toString(QKeySequence::NativeText)); } } case QEvent::ShortcutOverride: event->accept(); case QEvent::KeyRelease: case QEvent::Shortcut: return true; default: return QLineEdit::event(event); } }
void LLPluginClassMedia::scrollEvent(int x, int y, MASK modifiers) { LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "scroll_event"); message.setValueS32("x", x); message.setValueS32("y", y); message.setValue("modifiers", translateModifiers(modifiers)); sendMessage(message); }
bool LLPluginClassMedia::textInput(const std::string &text, MASK modifiers) { LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "text_event"); message.setValue("text", text); message.setValue("modifiers", translateModifiers(modifiers)); sendMessage(message); return true; }
/* \internal Matches the current intermediate key sequence + the latest keyevent, with and AccelItem. Returns Identical, PartialMatch or NoMatch, and fills \a temp with the resulting key sequence. */ Qt::SequenceMatch QAccelManager::match( QKeyEvent *e, QAccelItem* item, QKeySequence& temp ) { SequenceMatch result = Qt::NoMatch; int index = intermediate.count(); temp = intermediate; int modifier = translateModifiers( e->state() ); if ( e->key() && e->key() != Key_unknown) { int key = e->key() | modifier; if ( e->key() == Key_BackTab ) { /* In QApplication, we map shift+tab to shift+backtab. This code here reverts the mapping in a way that keeps backtab and shift+tab accelerators working, in that order, meaning backtab has priority.*/ key &= ~SHIFT; temp.setKey( key, index ); if ( Qt::NoMatch != (result = temp.matches( item->key )) ) return result; if ( e->state() & ShiftButton ) key |= SHIFT; key = Key_Tab | ( key & MODIFIER_MASK ); temp.setKey( key, index ); if ( Qt::NoMatch != (result = temp.matches( item->key )) ) return result; } else { temp.setKey( key, index ); if ( Qt::NoMatch != (result = temp.matches( item->key )) ) return result; } if ( key == Key_BackTab ) { if ( e->state() & ShiftButton ) key |= SHIFT; temp.setKey( key, index ); if ( Qt::NoMatch != (result = temp.matches( item->key )) ) return result; } } if ( !e->text().isEmpty() ) { QChar c = e->text()[0]; // be in accordance with accoQAccel::shortcutKey() if ( modifier != 0 && c.isPrint() ) c = c.upper(); temp.setKey( (int)c.unicode() | UNICODE_ACCEL | modifier, index ); result = temp.matches( item->key ); } return result; }
void QWaylandInputDevice::inputHandleKey(void *data, struct wl_input_device *input_device, uint32_t time, uint32_t key, uint32_t state) { #ifndef QT_NO_WAYLAND_XKB Q_UNUSED(input_device); QWaylandInputDevice *inputDevice = (QWaylandInputDevice *) data; QWaylandWindow *window = inputDevice->mKeyboardFocus; uint32_t code, sym, level; Qt::KeyboardModifiers modifiers; QEvent::Type type; char s[2]; if (window == NULL) { /* We destroyed the keyboard focus surface, but the server * didn't get the message yet. */ return; } code = key + inputDevice->mXkb->min_key_code; level = 0; if (inputDevice->mModifiers & Qt::ShiftModifier && XkbKeyGroupWidth(inputDevice->mXkb, code, 0) > 1) level = 1; sym = XkbKeySymEntry(inputDevice->mXkb, code, level, 0); modifiers = translateModifiers(inputDevice->mXkb->map->modmap[code]); if (state) { inputDevice->mModifiers |= modifiers; type = QEvent::KeyPress; } else { inputDevice->mModifiers &= ~modifiers; type = QEvent::KeyRelease; } sym = translateKey(sym, s, sizeof s); if (window) { QWindowSystemInterface::handleKeyEvent(window->widget(), time, type, sym, inputDevice->mModifiers, QString::fromLatin1(s)); } #endif }
void LLPluginClassMedia::mouseEvent(EMouseEventType type, int button, int x, int y, MASK modifiers) { if(type == MOUSE_EVENT_MOVE) { if(!mPlugin || !mPlugin->isRunning() || mPlugin->isBlocked()) { // Don't queue up mouse move events that can't be delivered. return; } if((x == mLastMouseX) && (y == mLastMouseY)) { // Don't spam unnecessary mouse move events. return; } mLastMouseX = x; mLastMouseY = y; } LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "mouse_event"); std::string temp; switch(type) { case MOUSE_EVENT_DOWN: temp = "down"; break; case MOUSE_EVENT_UP: temp = "up"; break; case MOUSE_EVENT_MOVE: temp = "move"; break; case MOUSE_EVENT_DOUBLE_CLICK: temp = "double_click"; break; } message.setValue("event", temp); message.setValueS32("button", button); message.setValueS32("x", x); // Incoming coordinates are OpenGL-style ((0,0) = lower left), so flip them here if the plugin has requested it. if(!mRequestedTextureCoordsOpenGL) { // TODO: Should I use mMediaHeight or mRequestedMediaHeight here? y = mMediaHeight - y; } message.setValueS32("y", y); message.setValue("modifiers", translateModifiers(modifiers)); sendMessage(message); }
Key::Enum handleKeyEvent(const EmscriptenKeyboardEvent* event, uint8_t* specialKeys, uint8_t* _pressedChar) { *_pressedChar = (uint8_t)event->keyCode; int keyCode = (int)event->keyCode; *specialKeys = translateModifiers(event); if (event->charCode == 0) { switch (keyCode) { case 112: return Key::F1; case 113: return Key::F2; case 114: return Key::F3; case 115: return Key::F4; case 116: return Key::F5; case 117: return Key::F6; case 118: return Key::F7; case 119: return Key::F8; case 120: return Key::F9; case 121: return Key::F10; case 122: return Key::F11; case 123: return Key::F12; case 37: return Key::Left; case 39: return Key::Right; case 38: return Key::Up; case 40: return Key::Down; } } // if this is a unhandled key just return None if (keyCode < 256) { return (Key::Enum)s_translateKey[keyCode]; } return Key::None; }
bool RShortcutLineEdit::eventFilter(QObject *obj, QEvent *event) { if (event->type() == QEvent::KeyPress) { QKeyEvent *keyEvent = static_cast<QKeyEvent *> (event); int nextKey = keyEvent->key(); if (m_keyNum > 3 || nextKey == Qt::Key_Control || nextKey == Qt::Key_Shift || nextKey == Qt::Key_Meta || nextKey == Qt::Key_Alt) return true; nextKey |= translateModifiers(keyEvent->modifiers(), keyEvent->text()); switch (m_keyNum) { case 0: m_key[0] = nextKey; break; case 1: m_key[1] = nextKey; break; case 2: m_key[2] = nextKey; break; case 3: m_key[3] = nextKey; break; default: break; } m_keyNum++; QKeySequence ks(m_key[0], m_key[1], m_key[2], m_key[3]); setText(ks); keyEvent->accept(); return true; } else { // standard event processing return QObject::eventFilter(obj, event); } }
/* \internal Checks for possible accelerators, if no widget ate the keypres, or we are in the middle of a partial key sequence. */ bool QAccelManager::dispatchAccelEvent( QWidget* w, QKeyEvent* e ) { #ifndef QT_NO_STATUSBAR // Needs to be declared and used here because of "goto doclash" QStatusBar* mainStatusBar = 0; #endif // Modifiers can NOT be accelerators... if ( e->key() >= Key_Shift && e->key() <= Key_Alt ) return FALSE; SequenceMatch result = Qt::NoMatch; QKeySequence tocheck, partial; QAccelPrivate* accel = 0; QAccelItem* item = 0; QAccelPrivate* firstaccel = 0; QAccelItem* firstitem = 0; QAccelPrivate* lastaccel = 0; QAccelItem* lastitem = 0; QKeyEvent pe = *e; int n = -1; int hasShift = (e->state()&Qt::ShiftButton)?1:0; bool identicalDisabled = FALSE; bool matchFound = FALSE; do { accel = accels.first(); matchFound = FALSE; while ( accel ) { if ( correctSubWindow( w, accel ) ) { if ( accel->enabled ) { item = accel->aitems.last(); while( item ) { if ( Qt::Identical == (result = match( &pe, item, tocheck )) ) { if ( item->enabled ) { if ( !firstaccel ) { firstaccel = accel; firstitem = item; } lastaccel = accel; lastitem = item; n++; matchFound = TRUE; if ( n > QMAX(clash,0) ) goto doclash; } else { identicalDisabled = TRUE; } } if ( item->enabled && Qt::PartialMatch == result ) { partial = tocheck; matchFound = TRUE; } item = accel->aitems.prev(); } } else { item = accel->aitems.last(); while( item ) { if ( Qt::Identical == match( &pe, item, tocheck ) ) identicalDisabled = TRUE; item = accel->aitems.prev(); } } } accel = accels.next(); } pe = QKeyEvent( QEvent::Accel, pe.key(), pe.ascii(), pe.state()&~Qt::ShiftButton, pe.text() ); } while ( hasShift-- && !matchFound && !identicalDisabled ); #ifndef QT_NO_STATUSBAR mainStatusBar = (QStatusBar*) w->topLevelWidget()->child( 0, "QStatusBar" ); #endif if ( n < 0 ) { // no match found currentState = partial.count() ? PartialMatch : NoMatch; #ifndef QT_NO_STATUSBAR // Only display message if we are, or were, in a partial match if ( mainStatusBar && (PartialMatch == currentState || intermediate.count() ) ) { if ( currentState == Qt::PartialMatch ) { mainStatusBar->message( (QString)partial + ", ...", 0 ); } else if (!identicalDisabled) { QString message = QAccel::tr("%1, %2 not defined"). arg( (QString)intermediate ). arg( QKeySequence::encodeString( e->key() | translateModifiers(e->state()) ) ); mainStatusBar->message( message, 2000 ); // Since we're a NoMatch, reset the clash count clash = -1; } else { mainStatusBar->clear(); } } #endif bool eatKey = (PartialMatch == currentState || intermediate.count() ); intermediate = partial; if ( eatKey ) e->accept(); return eatKey; } else if ( n == 0 ) { // found exactly one match clash = -1; // reset #ifndef QT_NO_STATUSBAR if ( currentState == Qt::PartialMatch && mainStatusBar ) mainStatusBar->clear(); #endif currentState = Qt::NoMatch; // Free sequence keylock intermediate = QKeySequence(); lastaccel->activate( lastitem ); e->accept(); return TRUE; } doclash: // found more than one match #ifndef QT_NO_STATUSBAR if ( !mainStatusBar ) // if "goto doclash", we need to get statusbar again. mainStatusBar = (QStatusBar*) w->topLevelWidget()->child( 0, "QStatusBar" ); #endif QString message = QAccel::tr( "Ambiguous \"%1\" not handled" ).arg( (QString)tocheck ); if ( clash >= 0 && n > clash ) { // pick next match intermediate = QKeySequence(); currentState = Qt::NoMatch; // Free sequence keylock clash++; #ifndef QT_NO_STATUSBAR if ( mainStatusBar && !lastitem->signal && !(lastaccel->parent->receivers( "activatedAmbiguously(int)" )) ) mainStatusBar->message( message, 2000 ); #endif lastaccel->activateAmbiguously( lastitem ); } else { // start (or wrap) with the first matching intermediate = QKeySequence(); currentState = Qt::NoMatch; // Free sequence keylock clash = 0; #ifndef QT_NO_STATUSBAR if ( mainStatusBar && !firstitem->signal && !(firstaccel->parent->receivers( "activatedAmbiguously(int)" )) ) mainStatusBar->message( message, 2000 ); #endif firstaccel->activateAmbiguously( firstitem ); } e->accept(); return TRUE; }
bool LLPluginClassMedia::keyEvent(EKeyEventType type, int key_code, MASK modifiers, LLSD native_key_data) { bool result = true; // FIXME: // HACK: we don't have an easy way to tell if the plugin is going to handle a particular keycode. // For now, return false for the ones the webkit plugin won't handle properly. switch(key_code) { case KEY_BACKSPACE: case KEY_TAB: case KEY_RETURN: case KEY_PAD_RETURN: case KEY_SHIFT: case KEY_CONTROL: case KEY_ALT: case KEY_CAPSLOCK: case KEY_ESCAPE: case KEY_PAGE_UP: case KEY_PAGE_DOWN: case KEY_END: case KEY_HOME: case KEY_LEFT: case KEY_UP: case KEY_RIGHT: case KEY_DOWN: case KEY_INSERT: case KEY_DELETE: // These will be handled break; default: // regular ASCII characters will also be handled if(key_code >= KEY_SPECIAL) { // Other "special" codes will not work properly. result = false; } break; } #if LL_DARWIN if(modifiers & MASK_ALT) { // Option-key modified characters should be handled by the unicode input path instead of this one. result = false; } #endif if(result) { LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "key_event"); std::string temp; switch(type) { case KEY_EVENT_DOWN: temp = "down"; break; case KEY_EVENT_UP: temp = "up"; break; case KEY_EVENT_REPEAT: temp = "repeat"; break; } message.setValue("event", temp); message.setValueS32("key", key_code); message.setValue("modifiers", translateModifiers(modifiers)); message.setValueLLSD("native_key_data", native_key_data); sendMessage(message); } return result; }