bool QtKeypadBridge::eventFilter(QObject *obj, QEvent *e)
{
Q_UNUSED(obj);
if(e->type() == QEvent::KeyPress) {
keyEvent(static_cast<QKeyEvent*>(e), true);
} else if(e->type() == QEvent::KeyRelease) {
keyEvent(static_cast<QKeyEvent*>(e), false);
} else {
return false;
}
return true;
}
EXPORT_C TKeyResponse CEikFixedPointEditor::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)
{
TKeyEvent keyEvent(aKeyEvent);
TEventCode eventCode(aType);
return CAknNumericEdwin::OfferKeyEventL(keyEvent, eventCode);
}
/*!
This function handles different keyevents.
*/
bool HbInputNumericHandler::filterEvent(const QKeyEvent *event)
{
bool ret = true;
switch (event->key()) {
case Qt::Key_Backspace:
case HbInputButton::ButtonKeyCodeDelete: {
QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Backspace, Qt::NoModifier);
sendAndUpdate(keyEvent);
// return false since the event is sent forward
ret = false;
break;
}
case HbInputButton::ButtonKeyCodeEnter:
case HbInputButton::ButtonKeyCodeSpace:
case Qt::Key_Period:
case Qt::Key_Comma: {
QChar qc(event->key());
if (qc == Qt::Key_Enter || qc == Qt::Key_Return) {
qc = QChar('\n'); // Editor expects normal line feed.
}
commitAndUpdate(qc);
break;
}
case HbInputButton::ButtonKeyCodeSettings:
break;
default:
ret = HbInputModeHandler::filterEvent(event);
break;
}
return ret;
}
void VolumeBarLogic::hwKeyResourceAcquired()
{
// Disconnect from everything first
hwkeys->disconnect ();
connect(hwkeys, SIGNAL (keyEvent (MeeGo::QmKeys::Key, MeeGo::QmKeys::State)), this, SLOT (hwKeyEvent (MeeGo::QmKeys::Key, MeeGo::QmKeys::State)));
}
void EventListener::onEvent(Event* e) {
/*
since we already checked which type we have we can safely use
the faster static_cast (rl)
*/
if (typeid(*e) == typeid(MouseEvent)) {
MouseEvent* me = static_cast<MouseEvent*>(e);
if (me->action() == MouseEvent::PRESSED)
mousePressEvent(me);
else if (me->action() == MouseEvent::RELEASED)
mouseReleaseEvent(me);
else if (me->action() == MouseEvent::MOTION)
mouseMoveEvent(me);
else if (me->action() == MouseEvent::DOUBLECLICK)
mouseDoubleClickEvent(me);
else if (me->action() == MouseEvent::WHEEL)
wheelEvent(me);
}
else if (typeid(*e) == typeid(KeyEvent)) {
keyEvent(static_cast<KeyEvent*>(e));
}
else if (typeid(*e) == typeid(TimeEvent)) {
timerEvent(static_cast<TimeEvent*>(e));
}
else if (typeid(*e) == typeid(TouchEvent)) {
touchEvent(static_cast<TouchEvent*>(e));
}
}
void WinapiKeyboardContext::keyEvent(WinapiWindowContext* wc, unsigned int vkcode,
unsigned int lparam)
{
auto scancode = HIWORD(lparam);
auto keycode = winapiToKeycode(vkcode);
unsigned char state[256] {};
::GetKeyboardState(state);
std::string utf8;
wchar_t utf16[64];
auto bytes = ::ToUnicode(vkcode, scancode, state, utf16, 64, 0);
if(bytes > 0)
{
utf16[bytes] = L'\0';
auto utf16string = reinterpret_cast<char16_t*>(utf16);
utf8 = nytl::toUtf8(utf16string);
}
bool pressed = !(scancode & (1 << 15));
onKey(*this, keycode, utf8, pressed);
if(wc != focus_) warning("ny::WinapiKC::keyEvent: event handler <-> focus inconsistency");
if(wc && wc->eventHandler())
{
KeyEvent keyEvent(wc->eventHandler());
keyEvent.pressed = pressed;
keyEvent.keycode = keycode;
keyEvent.unicode = std::move(utf8);
wc->eventHandler()->handleEvent(keyEvent);
}
}
void QInputGeneratorGeneric::keyPress(Qt::Key key, Qt::KeyboardModifiers mod, bool autoRepeat)
{
QTT_TRACE_FUNCTION();
qttDebug() << "keyPress" << key << mod << autoRepeat;
Q_UNUSED(autoRepeat);
keyEvent(Press, focusWidget(), key, mod);
}
void Application::processEvents(Context& context)
{
SDL_Event event;
while (SDL_PollEvent(&event))
{
switch (event.type)
{
case SDL_KEYDOWN:
case SDL_KEYUP:
keyEvent(context, createKeyPressEvent(event.key));
break;
case SDL_TEXTINPUT:
textInputEvent(context, TextInputEvent(event.text.text));
break;
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
mouseButtonEvent(context, createMouseButtonEvent(event.button, video.getScreen().getClientHeight()));
break;
case SDL_MOUSEMOTION:
mouseMotionEvent(context, createMouseMotionEvent(event.motion, video.getScreen().getClientHeight()));
break;
case SDL_MOUSEWHEEL:
mouseWheelEvent(context, MouseWheelEvent(0, 0, event.wheel.x, event.wheel.y));
break;
case SDL_QUIT:
requestClose = true;
break;
default:
break;
}
}
}
void Skin::mousePressEvent( QMouseEvent *e )
{
if (e->button() == RightButton) {
parent->popupMenu();
} else {
buttonPressed = FALSE;
for (int i = 0; i < numberOfAreas; i++) {
QPoint p1( areas[i].x1, areas[i].y1 );
QPoint p2( areas[i].x2, areas[i].y2 );
QRect r( p1, p2 );
if ( r.contains( e->pos() ) ) {
buttonPressed = TRUE;
buttonIndex = i;
buttonCode = areas[buttonIndex].keyCode;
QKeyEvent keyEvent( QEvent::KeyPress, buttonCode, 0, 0 );
if (view)
view->skinKeyPressEvent( &keyEvent );
// Debug message to be sure we are clicking the right areas
// printf("%s clicked\n", areas[i].name);
ButtonAreas *ba = &areas[buttonIndex];
repaint( ba->x1, ba->y1, ba->x2 - ba->x1, ba->y2 - ba->y1, FALSE );
continue;
}
}
// This is handy for finding the areas to define rectangles for new skins
// printf("Clicked in %i,%i\n", e->pos().x(), e->pos().y());
clickPos = e->pos();
}
}
void MainWindow::keyPressEvent(QKeyEvent *event)
{
switch(this->mode)
{
case 0 : break;
case 1 : emit keyEvent(event); break;
case 2 : emit keyRecord(event); break;
}
}
QmKeys::QmKeys(QObject *parent) : QObject(parent) {
priv = new QmKeysPrivate();
connect(priv, SIGNAL(keyEvent(MeeGo::QmKeys::Key, MeeGo::QmKeys::State)), this, SIGNAL(keyEvent(MeeGo::QmKeys::Key, MeeGo::QmKeys::State)));
connect(priv, SIGNAL(volumeDownMoved(bool)), this, SIGNAL(volumeDownMoved(bool)));
connect(priv, SIGNAL(volumeUpMoved(bool)), this, SIGNAL(volumeUpMoved(bool)));
connect(priv, SIGNAL(cameraLauncherMoved(QmKeys::CameraKeyPosition)), this, SIGNAL(cameraLauncherMoved(QmKeys::CameraKeyPosition)));
connect(priv, SIGNAL(lensCoverMoved(QmKeys::LensCoverPosition)), this, SIGNAL(lensCoverMoved(QmKeys::LensCoverPosition)));
connect(priv, SIGNAL(keyboardSliderMoved(QmKeys::KeyboardSliderPosition)), this, SIGNAL(keyboardSliderMoved(QmKeys::KeyboardSliderPosition)));
}
CameraButtonListener::CameraButtonListener(QObject *parent) :
QObject(parent),
m_focusPressed(false),
m_shutterPressed(false)
{
m_keys = new MeeGo::QmKeys(this);
connect(m_keys, SIGNAL(keyEvent(MeeGo::QmKeys::Key, MeeGo::QmKeys::State)),
this, SLOT(handleQmKeyEvent(MeeGo::QmKeys::Key,MeeGo::QmKeys::State)));
}
bool NaClApplication::HandleInputEvent(const pp::InputEvent& event) {
/* Don't handle anything during switch from/to fullscreen */
if(flags & Flag::FullscreenSwitchInProgress) return false;
Flags tmpFlags = flags;
switch(event.GetType()) {
case PP_INPUTEVENT_TYPE_KEYDOWN:
case PP_INPUTEVENT_TYPE_KEYUP: {
pp::KeyboardInputEvent keyEvent(event);
KeyEvent e(static_cast<KeyEvent::Key>(keyEvent.GetKeyCode()), static_cast<InputEvent::Modifier>(keyEvent.GetModifiers()));
event.GetType() == PP_INPUTEVENT_TYPE_KEYDOWN ? keyPressEvent(e) : keyReleaseEvent(e);
if(!e.isAccepted()) return false;
break;
}
case PP_INPUTEVENT_TYPE_MOUSEDOWN:
case PP_INPUTEVENT_TYPE_MOUSEUP: {
pp::MouseInputEvent mouseEvent(event);
MouseEvent e(static_cast<MouseEvent::Button>(mouseEvent.GetButton()), {mouseEvent.GetPosition().x(), mouseEvent.GetPosition().y()}, static_cast<InputEvent::Modifier>(mouseEvent.GetModifiers()));
event.GetType() == PP_INPUTEVENT_TYPE_MOUSEDOWN ? mousePressEvent(e) : mouseReleaseEvent(e);
if(!e.isAccepted()) return false;
break;
}
case PP_INPUTEVENT_TYPE_WHEEL: {
pp::WheelInputEvent wheelEvent(event);
if(Math::TypeTraits<Float>::equals(wheelEvent.GetDelta().y(), 0.0f)) return false;
MouseEvent e(wheelEvent.GetDelta().y() > 0 ? MouseEvent::Button::WheelUp : MouseEvent::Button::WheelDown, {}, static_cast<InputEvent::Modifier>(wheelEvent.GetModifiers()));
mousePressEvent(e);
if(!e.isAccepted()) return false;
break;
}
case PP_INPUTEVENT_TYPE_MOUSEMOVE: {
pp::MouseInputEvent mouseEvent(event);
MouseMoveEvent e({mouseEvent.GetPosition().x(), mouseEvent.GetPosition().y()}, {mouseEvent.GetMovement().x(), mouseEvent.GetMovement().y()}, static_cast<InputEvent::Modifier>(mouseEvent.GetModifiers()));
mouseMoveEvent(e);
if(!e.isAccepted()) return false;
break;
}
default: return false;
}
/* Assume everything is properly sequential here */
CORRADE_INTERNAL_ASSERT((tmpFlags & Flag::SwapInProgress) == (flags & Flag::SwapInProgress));
/* Redraw, if it won't be handled after swap automatically */
if((flags & Flag::Redraw) && !(flags & Flag::SwapInProgress)) {
flags &= ~Flag::Redraw;
drawEvent();
}
return true;
}
void Skin::mouseReleaseEvent( QMouseEvent * )
{
if ( buttonPressed ) {
QKeyEvent keyEvent( QEvent::KeyRelease, buttonCode, 0, 0 );
if (view)
view->skinKeyReleaseEvent( &keyEvent );
buttonPressed = FALSE;
ButtonAreas *ba = &areas[buttonIndex];
repaint( ba->x1, ba->y1, ba->x2 - ba->x1, ba->y2 - ba->y1, FALSE );
}
}
void wxTLWEventHandler( Widget wid,
XtPointer WXUNUSED(client_data),
XEvent* event,
Boolean* continueToDispatch)
{
wxTopLevelWindowMotif* tlw =
(wxTopLevelWindowMotif*)wxGetWindowFromTable( wid );
if( tlw )
{
wxMouseEvent wxevent( wxEVT_NULL );
if( wxTranslateMouseEvent( wxevent, tlw, wid, event ) )
{
wxevent.SetEventObject( tlw );
wxevent.SetId( tlw->GetId() );
tlw->HandleWindowEvent( wxevent );
}
else
{
// An attempt to implement OnCharHook by calling OnCharHook first;
// if this returns true, set continueToDispatch to False
// (don't continue processing).
// Otherwise set it to True and call OnChar.
wxKeyEvent keyEvent( wxEVT_CHAR );
if( wxTranslateKeyEvent( keyEvent, tlw, wid, event ))
{
keyEvent.SetEventObject( tlw );
keyEvent.SetId( tlw->GetId() );
keyEvent.SetEventType( wxEVT_CHAR_HOOK );
if( tlw->HandleWindowEvent( keyEvent ) )
{
*continueToDispatch = False;
return;
}
else
{
// For simplicity, OnKeyDown is the same as OnChar
// TODO: filter modifier key presses from OnChar
keyEvent.SetEventType( wxEVT_KEY_DOWN );
// Only process OnChar if OnKeyDown didn't swallow it
if( !tlw->HandleWindowEvent( keyEvent ) )
{
keyEvent.SetEventType( wxEVT_CHAR );
tlw->HandleWindowEvent( keyEvent );
}
}
}
}
}
*continueToDispatch = True;
}
void KeyRepeater::autoRepeat()
{
/* key release event */
#if 0
sendKeyEvent(
m_unicode,
m_keycode,
m_modifiers,
FALSE,
TRUE);
/* key press event */
sendKeyEvent(
m_unicode,
m_keycode,
m_modifiers,
TRUE,
TRUE);
#else
emit keyEvent(
m_unicode,
m_keycode,
m_modifiers,
FALSE,
TRUE);
/* key press event */
emit keyEvent(
m_unicode,
m_keycode,
m_modifiers,
TRUE,
TRUE);
#endif
/* start auto repeat */
m_pTimer->start(m_repeatperiod);
#if 0
qDebug("autoRepeat[%x][%x][%x]",
m_unicode,
m_keycode,
m_modifiers);
#endif
}
void handleEvent(const sf::Event& event)
{
#if !(INPUT_DISABLE_KEYBOARD)
if (keyEvent(event)) return;
#endif
#if !(INPUT_DISABLE_MOUSE)
if (mouseEvent(event)) return;
#endif
#if !(INPUT_DISABLE_JOYSTICK)
if (joystickEvent(event)) return;
#endif
}
Event EventHandler::CreateKeyboardEvent( const SDL_Event &event ) const
{
Event keyEvent( EventType::Keyboard );
keyEvent.keyboard.key = event.key.keysym.sym;
if ( event.type == SDL_KEYUP )
keyEvent.keyboard.eventType = ButtonEventType::Released;
else
keyEvent.keyboard.eventType = ButtonEventType::Pressed;
return keyEvent;
}
void Ut_MInputContext::testSendKeyEvent()
{
QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Backspace, Qt::NoModifier);
m_stub->sendKeyEvent(keyEvent, MInputMethod::EventRequestBoth);
QCOMPARE(m_stub->keyEventCount(), 1);
WidgetStub widget(0);
m_subject->setFocusWidget(&widget);
m_stub->sendKeyEvent(keyEvent, MInputMethod::EventRequestBoth);
QCOMPARE(m_stub->keyEventCount(), 2);
}
void tSonar3D::OnCursorAtEdge(tCursorEngine::tCursorEdge edge, tCursorEngine::tCursorDirection /*direction*/, bool /*moving*/)
{
bool update = false;
if (edge == tCursorEngine::Top)
{
// Change camera tilt
QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Up, Qt::NoModifier);
update = m_pCameraInteractor->HandleKeyPress(&keyEvent);
}
else if (edge == tCursorEngine::Bottom)
{
QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Down, Qt::NoModifier);
update = m_pCameraInteractor->HandleKeyPress(&keyEvent);
}
else if (edge == tCursorEngine::Left)
{
// Change camera tilt
QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Left, Qt::NoModifier);
update = m_pCameraInteractor->HandleKeyPress(&keyEvent);
}
else if (edge == tCursorEngine::Right)
{
QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Right, Qt::NoModifier);
update = m_pCameraInteractor->HandleKeyPress(&keyEvent);
}
else
{
// Nothing to do -- how did we get here?
}
if (update == true)
{
UpdateScene();
}
}
bool GoForwardActionWidget::eventFilter(QObject *object, QEvent *event)
{
if (event->type() == QEvent::ContextMenu)
{
QContextMenuEvent *contextMenuEvent(dynamic_cast<QContextMenuEvent*>(event));
if (contextMenuEvent)
{
QAction *action(menu()->activeAction());
if (action && action->data().type() == QVariant::Int)
{
QMenu contextMenu(menu());
QAction *removeEntryAction(contextMenu.addAction(tr("Remove Entry"), NULL, NULL, QKeySequence(Qt::Key_Delete)));
QAction *purgeEntryAction(contextMenu.addAction(tr("Purge Entry"), NULL, NULL, QKeySequence(Qt::ShiftModifier | Qt::Key_Delete)));
QAction *selectedAction(contextMenu.exec(contextMenuEvent->globalPos()));
if (selectedAction == removeEntryAction)
{
menu()->close();
getWindow()->getContentsWidget()->removeHistoryIndex(action->data().toInt());
}
else if (selectedAction == purgeEntryAction)
{
menu()->close();
getWindow()->getContentsWidget()->removeHistoryIndex(action->data().toInt(), true);
}
}
}
}
else if (event->type() == QEvent::KeyPress)
{
QKeyEvent *keyEvent(dynamic_cast<QKeyEvent*>(event));
if (keyEvent && keyEvent->key() == Qt::Key_Delete && getWindow())
{
QAction *action(menu()->activeAction());
if (action && action->data().type() == QVariant::Int)
{
menu()->close();
getWindow()->getContentsWidget()->removeHistoryIndex(action->data().toInt(), keyEvent->modifiers().testFlag(Qt::ShiftModifier));
}
}
}
return QObject::eventFilter(object, event);
}
void gSDLDC::pumpEvent(const SDL_Event &event)
{
switch (event.type) {
case SDL_KEYDOWN:
case SDL_KEYUP:
keyEvent(event);
break;
case SDL_QUIT:
eDebug("SDL Quit");
extern void quitMainloop(int exit_code);
quitMainloop(0);
break;
}
}
void CanvasGLFW::keyboard(GLFWwindow* window, int key, int scancode, int action, int mods) {
if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS) {
// glfwSetWindowShouldClose(window, GL_TRUE);
glfwTerminate();
exit(0);
return;
}
CanvasGLFW* thisCanvas = getCanvasGLFW(window);
KeyboardEvent keyEvent(toupper(key), KeyboardEvent::MODIFIER_NONE,
KeyboardEvent::KEY_STATE_PRESS);
thisCanvas->keyPressEvent(&keyEvent);
}
void InputAPI::TriggerSceneKeyReleaseEvent(InputContextList::Iterator start, Key keyCode)
{
for(; start != registeredInputContexts.End(); ++start)
{
InputContextPtr context = start->Lock();
if (context)
context->TriggerKeyReleaseEvent(keyCode);
}
if (heldKeys.Find(keyCode) != heldKeys.End())
{
KeyEvent keyEvent(this);
keyEvent.keyCode = keyCode;
keyEvent.eventType = KeyEvent::KeyReleased;
}
}
bool IconSettings::eventFilter( QObject *object, QEvent *event )
{
// firstly, check whether the object is the QTableWidget and if it's a mouse press event
if (object == twDlls)
if (event->type() == QEvent::KeyPress)
{ // if yes, we need to cast the event
std::auto_ptr<QKeyEvent> keyEvent (static_cast<QKeyEvent*>(event));
if (keyEvent->key()==Qt::Key_Delete)
twDlls->removeRow(twDlls->currentRow());
keyEvent.release();
return true;
}
return QWidget::eventFilter(object, event);
}
void JKCharacterScreenKeyboard::buttonClicked() {
int idx=-1;
if (sender()) {
QAbstractButton* but=qobject_cast<QAbstractButton*>(sender());
if (but) {
idx=m_buttons.indexOf(but);
}
}
if ((idx>-1)&&(idx<m_characters.size())) {
QChar character=m_characters[idx];
emit characterClicked(character);
if (m_generateApplicationEvent && m_focus) {
QKeyEvent keyEvent(QEvent::KeyPress, 0, Qt::NoModifier, QString(character));
QApplication::sendEvent(m_focus->focusWidget(), &keyEvent);
}
}
}
void Menu::mouseDownEvent(int x, int y, int button)
{
for (std::map < Key, MenuText >::iterator it = options_.begin();
it != options_.end(); it++) {
MenuText & m = it->second;
int width = 300;
if (m.text_.size() == 1)
width = 30;
else
width = g_App.fonts().textWidth(m.text_.c_str(), m.size_);
if (m.visible_ && x > m.x_ - 2 && x < m.x_ + width && y >= m.y_ - 2
&& y < m.y_ + g_App.fonts().textHeight(m.size_) - 2) {
keyEvent(it->first, KMD_NONE, true);
return;
}
}
handleMouseDown(x, y, button);
}
void InputMethodManager::setInstance(Instance *instance) {
FCITX_D();
d->instance_ = instance;
d->eventWatcher_.reset(
d->instance_->watchEvent(EventType::InputContextKeyEvent, EventWatcherPhase::InputMethod, [this](Event &event) {
FCITX_D();
auto &keyEvent = static_cast<KeyEvent &>(event);
auto entry = d->instance_->inputMethodEntry(keyEvent.inputContext());
if (!entry) {
return;
}
auto engine = static_cast<InputMethodEngine *>(d->instance_->addonManager().addon(entry->addon()));
if (!engine) {
return;
}
engine->keyEvent(*entry, keyEvent);
}));
}
void UI::Menu::loop()
{
while(1)
{
if ( mExpired )
break;
if ( mLoopTill && (*mLoopTill)() )
break;
int c = getch();
if ( c != ERR )
keyEvent(c);
erase();
drawEvent();
refresh();
}
}
int NCApplication::exec()
{
clear();
refresh();
// First pass to draw the screen
for(auto window : m_windows)
{
window->redraw();
}
// Main loop
while(!m_terminated)
{
fd_set read, write, except;
FD_ZERO(&read);
FD_ZERO(&write);
FD_ZERO(&except);
FD_SET(STDIN_FILENO, &read);
int maxFd = STDIN_FILENO + 1;
struct timeval timeout = { 1, 0 };
int ret = select(maxFd, &read, &write, &except, &timeout);
if (ret > 0)
{
if (FD_ISSET(STDIN_FILENO, &read))
{
auto window = *m_windows.rbegin();
window->keyEvent(wgetch(window->m_window));
}
}
for(auto it : m_windows)
{
if (it->needRedraw())
it->redraw();
}
}
return 0;
}
