bool NativeEnginePrivate::handleGlWidgetEvent(QEvent *event)
{
switch (event->type()) {
case QEvent::KeyPress:
{
QKeyEvent *ke = static_cast<QKeyEvent*>(event);
if (keyPressCallback) {
QScopedArrayPointer<wchar_t> text(new wchar_t[ke->text().length()]);
ke->text().toWCharArray(text.data());
keyPressCallback(ke->count(), ke->isAutoRepeat(), ke->key(), ke->modifiers(), text.data());
}
}
return true;
case QEvent::KeyRelease:
{
QKeyEvent *ke = static_cast<QKeyEvent*>(event);
if (keyReleaseCallback) {
QScopedArrayPointer<wchar_t> text(new wchar_t[ke->text().length()]);
ke->text().toWCharArray(text.data());
keyReleaseCallback(ke->count(), ke->isAutoRepeat(), ke->key(), ke->modifiers(), text.data());
}
}
return true;
case QEvent::MouseButtonDblClick:
if (mouseDoubleClickCallback)
mouseDoubleClickCallback(createMouseEvent(static_cast<QMouseEvent*>(event)));
return true;
case QEvent::MouseButtonPress:
if (mousePressCallback)
mousePressCallback(createMouseEvent(static_cast<QMouseEvent*>(event)));
return true;
case QEvent::MouseButtonRelease:
if (mouseReleaseCallback)
mouseReleaseCallback(createMouseEvent(static_cast<QMouseEvent*>(event)));
return true;
case QEvent::MouseMove:
if (mouseMoveCallback)
mouseMoveCallback(createMouseEvent(static_cast<QMouseEvent*>(event)));
return true;
case QEvent::Wheel:
if (wheelCallback)
wheelCallback(createWheelEvent(static_cast<QWheelEvent*>(event)));
return true;
case QEvent::Paint:
// Ignore all paint events, we handle this ourselves
return true;
default:
// By default pass unknown events to the widget
return false;
}
}
/*!
\fn KeyHold::eventFilter( QObject* o, QEvent* e )
\internal
*/
bool KeyHold::eventFilter( QObject*, QEvent* e )
{
static bool enabled = true;
if( enabled ) {
switch( e->type() )
{
case QEvent::KeyPress:
{
QKeyEvent *ke = (QKeyEvent*)e;
if( ke->key() == m_key ) {
if( !ke->isAutoRepeat() ) {
// Start hold countdown
m_countdown->start( m_threshold );
}
return true;
}
}
break;
case QEvent::KeyRelease:
{
QKeyEvent *ke = (QKeyEvent*)e;
if( ke->key() == m_key ) {
if( !ke->isAutoRepeat() ) {
// If countdown active, generate key press and key release
// Otherwise, generate key hold release
if( m_countdown->isActive() ) {
m_countdown->stop();
enabled = false;
QKeyEvent event = QKeyEvent( QEvent::KeyPress, m_key, Qt::NoModifier );
QCoreApplication::sendEvent( m_target, &event );
event = QKeyEvent( QEvent::KeyRelease, m_key, Qt::NoModifier );
QCoreApplication::sendEvent( m_target, &event );
enabled = true;
} else {
QKeyEvent event = QKeyEvent( QEvent::KeyRelease, m_keyHold, Qt::NoModifier );
QCoreApplication::sendEvent( m_target, &event );
}
}
return true;
}
}
break;
default:
// Ignore
break;
}
}
return false;
}
bool GlobalShortcutRegistry::eventFilter(QObject *obj, QEvent *event)
{
Q_ASSERT(m_filteredWindow);
Q_ASSERT(obj == static_cast<QObject*>(m_filteredWindow.data()));
if (event->type() == QEvent::KeyPress || event->type() == QEvent::KeyRelease) {
QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
// Make a copy of the event so we don't alter it for passing on.
QKeyEvent eCopy(keyEvent->type(),
keyEvent->key(),
keyEvent->modifiers(),
keyEvent->text(),
keyEvent->isAutoRepeat(),
keyEvent->count());
eCopy.ignore();
int seq = keyEvent->key() + keyEvent->modifiers();
if (m_shortcuts.contains(seq)) {
const auto shortcuts = m_shortcuts.value(seq);
Q_FOREACH(const auto &shortcut, shortcuts) {
if (shortcut) {
qApp->sendEvent(shortcut, &eCopy);
}
}
}
return eCopy.isAccepted();
}
void
dmz::QtModuleCanvasBasic::_handle_key_event (
const QKeyEvent &Event,
const Boolean KeyState) {
if (!Event.isAutoRepeat ()) {
UInt32 theKey (0);
switch (Event.key ()) {
case Qt::Key_F1: theKey = KeyF1; break;
case Qt::Key_F2: theKey = KeyF2; break;
case Qt::Key_F3: theKey = KeyF3; break;
case Qt::Key_F4: theKey = KeyF4; break;
case Qt::Key_F5: theKey = KeyF5; break;
case Qt::Key_F6: theKey = KeyF6; break;
case Qt::Key_F7: theKey = KeyF7; break;
case Qt::Key_F8: theKey = KeyF8; break;
case Qt::Key_F9: theKey = KeyF9; break;
case Qt::Key_F10: theKey = KeyF10; break;
case Qt::Key_F11: theKey = KeyF11; break;
case Qt::Key_F12: theKey = KeyF12; break;
case Qt::Key_Left: theKey = KeyLeftArrow; break;
case Qt::Key_Up: theKey = KeyUpArrow; break;
case Qt::Key_Right: theKey = KeyRightArrow; break;
case Qt::Key_Down: theKey = KeyDownArrow; break;
case Qt::Key_PageUp: theKey = KeyPageUp; break;
case Qt::Key_PageDown: theKey = KeyPageDown; break;
case Qt::Key_Home: theKey = KeyHome; break;
case Qt::Key_End: theKey = KeyEnd; break;
case Qt::Key_Insert: theKey = KeyInsert; break;
case Qt::Key_Space: theKey = KeySpace; break;
case Qt::Key_Escape: theKey = KeyEsc; break;
case Qt::Key_Tab: theKey = KeyTab; break;
case Qt::Key_Backspace: theKey = KeyBackspace; break;
case Qt::Key_Enter: theKey = KeyEnter; break;
case Qt::Key_Return: theKey = KeyEnter; break;
case Qt::Key_Delete: theKey = KeyDelete; break;
case Qt::Key_Shift : theKey = KeyShift; break;
case Qt::Key_Control : theKey = KeyControl; break;
case Qt::Key_Meta : theKey = KeyMeta; break;
case Qt::Key_Alt : theKey = KeyAlt; break;
default:
if (!(Event.text ().isEmpty ())) {
theKey = Event.text ().at (0).toAscii ();
}
}
_keyEvent.set_key (theKey);
_keyEvent.set_key_state (KeyState);
if (_inputModule) { _inputModule->send_key_event (_keyEvent); }
}
}
bool VideoWindow::event(QEvent* event)
{
if (event->type() == QEvent::Close)
emit closing();
if (event->type() == QEvent::Resize)
{
QResizeEvent* re = (QResizeEvent*)event;
emit resizing(re->size().width(), re->size().height());
}
if (event->type() == QEvent::FocusIn)
{
emit resizing(width(), height());
}
if (event->type() == QEvent::KeyPress)
{
QKeyEvent* ke = (QKeyEvent*)event;
if (!ke->isAutoRepeat())
{
keyMap[ke->key()] = true;
if (ke->key() == Qt::Key_Escape)
{
emit closing();
this->close();
}
}
}
if (event->type() == QEvent::KeyRelease)
{
QKeyEvent* ke = (QKeyEvent*)event;
if (!ke->isAutoRepeat())
{
keyMap[ke->key()] = false;
keyMapOnce[ke->key()] = false;
}
}
return QWindow::event(event);
}
bool QtApp::notify(QObject* object, QEvent* event) {
if (strcmp(object->metaObject()->className(), "QWidgetWindow") == 0)
if (event->type() == QEvent::KeyPress) {
QKeyEvent* Qk = static_cast<QKeyEvent*>(event);
if (!Qk->isAutoRepeat()) {
INPUT->registerPressed(Qk->key());
if (Qk->key() == Qt::Key_Tab && SFML->QWidget::hasFocus()) // No tab while drawing
return false;
}
}
else if (event->type() == QEvent::KeyRelease) {
QKeyEvent* Qk = static_cast<QKeyEvent*>(event);
if (!Qk->isAutoRepeat())
INPUT->registerReleased(Qk->key());
}
return QApplication::notify(object, event);
}
bool Application::notify(QObject *receiver, QEvent *e)
{
#ifdef BANG_EDITOR
if (receiver == focusWidget())
{
if (e->type() == QEvent::MouseButtonPress)
{
DragDropManager::HandleGlobalMousePress(receiver, e);
}
else if (e->type() == QEvent::MouseButtonRelease)
{
DragDropManager::HandleGlobalMouseRelease(receiver, e);
}
if (e->type() == QEvent::KeyPress)
{
QKeyEvent *ev = dynamic_cast<QKeyEvent*>(e);
m_lastKeyPressEvInfo.time = Time::GetNow();
m_lastKeyPressEvInfo.key = ev->key();
if (!ev->isAutoRepeat())
{
ShortcutManager::GetInstance()->OnKeyPressed( Input::Key(ev->key()) );
}
}
else if (e->type() == QEvent::KeyRelease)
{
QKeyEvent *ev = dynamic_cast<QKeyEvent*>(e);
if (!ev->isAutoRepeat())
{
ShortcutManager::GetInstance()->OnKeyReleased( Input::Key(ev->key()) );
}
}
if (e->type() == QEvent::Shortcut)
{
ShortcutManager::GetInstance()->Clear();
}
}
#endif
return QApplication::notify(receiver, e);
}
any_event make_key_press_event(QObject*, QEvent* event)
{
if (event->type() == QEvent::KeyPress)
{
QKeyEvent* e = (QKeyEvent*) event;
// if (e->isAutoRepeat() && !auto_repeat_)
// return any_event();
return key_press(qt_key_to_dige_key(e->key()), e->isAutoRepeat());
}
return any_event();
}
bool EventFilter::eventFilter(QObject* watched, QEvent* event)
{
SystemComponent& system = SystemComponent::Get();
// ignore mouse events if mouse is disabled
if (SettingsComponent::Get().value(SETTINGS_SECTION_MAIN, "disablemouse").toBool() &&
((event->type() == QEvent::MouseMove) ||
(event->type() == QEvent::MouseButtonPress) ||
(event->type() == QEvent::MouseButtonRelease) ||
(event->type() == QEvent::MouseButtonDblClick)))
{
return true;
}
if (event->type() == QEvent::KeyPress || event->type() == QEvent::KeyRelease)
{
// In konvergo we intercept all keyboard events and translate them
// into web client actions. We need to do this so that we can remap
// keyboard buttons to different events.
//
bool pressed = event->type() == QEvent::KeyPress;
QKeyEvent* kevent = dynamic_cast<QKeyEvent*>(event);
if (kevent)
{
system.setCursorVisibility(false);
if (kevent->spontaneous() && !kevent->isAutoRepeat())
{
// We ignore the KeypadModifier here since it's practically useless
QKeySequence key(kevent->key() | (kevent->modifiers() &= ~Qt::KeypadModifier));
InputKeyboard::Get().keyPress(key, pressed);
return true;
}
}
}
else if (event->type() == QEvent::MouseMove)
{
system.setCursorVisibility(true);
}
else if (event->type() == QEvent::Wheel)
{
return true;
}
else if (event->type() == QEvent::MouseButtonPress)
{
// ignore right clicks that would show context menu
QMouseEvent *mouseEvent = dynamic_cast<QMouseEvent*>(event);
if ((mouseEvent) && (mouseEvent->button() == Qt::RightButton))
return true;
}
return QObject::eventFilter(watched, event);
}
bool FApplication::eventFilter(QObject *obj, QEvent *event)
{
// check whether the space bar is down.
Q_UNUSED(obj);
switch (event->type()) {
case QEvent::MouseButtonPress:
m_mousePressed = true;
break;
case QEvent::MouseButtonRelease:
m_mousePressed = false;
break;
case QEvent::KeyPress:
{
if (!m_mousePressed) {
QKeyEvent * kevent = static_cast<QKeyEvent *>(event);
if (!kevent->isAutoRepeat() && (kevent->key() == Qt::Key_Space)) {
m_spaceBarIsPressed = true;
emit spaceBarIsPressedSignal(true);
}
}
}
break;
case QEvent::KeyRelease:
{
if (m_spaceBarIsPressed) {
QKeyEvent * kevent = static_cast<QKeyEvent *>(event);
if (!kevent->isAutoRepeat() && (kevent->key() == Qt::Key_Space)) {
m_spaceBarIsPressed = false;
emit spaceBarIsPressedSignal(false);
}
}
}
break;
default:
break;
}
return false;
}
void EWAUserAction::execute( QWebView *webViewPtr ) const
{
if( !webViewPtr )
{
return;
}
//EWAWebView *pEwaWebView = qobject_cast<EWAWebView*>( webViewPtr );
//bool bNeedSetFocus = false;
QEvent *pEventCopy = 0;
if( isMouseEvent( m_pEvent->type() ) )
{
QMouseEvent *pSrcMouseEvent = static_cast<QMouseEvent *>( m_pEvent );
QPoint clickCoords = pSrcMouseEvent->pos();
pEventCopy = new QMouseEvent(
pSrcMouseEvent->type(),
clickCoords,
webViewPtr->mapToGlobal( clickCoords ),
pSrcMouseEvent->button(),
pSrcMouseEvent->buttons(),
pSrcMouseEvent->modifiers() );
}
else if( isKeyEvent( m_pEvent->type() ) )
{
QKeyEvent *pSrcKeyEvent = static_cast<QKeyEvent*>( m_pEvent );
pEventCopy = new QKeyEvent(
pSrcKeyEvent->type(),
pSrcKeyEvent->key(),
pSrcKeyEvent->modifiers(),
pSrcKeyEvent->text(),
pSrcKeyEvent->isAutoRepeat(),
pSrcKeyEvent->count() );
}
if( pEventCopy )
{
QSize dstSz = getWebViewSize();
if( webViewPtr->page()->preferredContentsSize() != dstSz )
{
webViewPtr->page()->setPreferredContentsSize( dstSz );
}
EWAApplication::postEvent( webViewPtr, pEventCopy );
}
}
bool WebPage::event(QEvent *ev)
{
QMouseEvent* mouseEvent = NULL;
QWheelEvent* wheelEvent = NULL;
QKeyEvent* keyEvent = NULL;
QByteArray byteArray;
QBuffer buffer(&byteArray);
buffer.open(QIODevice::ReadWrite);
QDataStream out(&buffer);
out << (int) ev->type();
switch (ev->type()) {
case QEvent::MouseMove:
case QEvent::MouseButtonPress:
case QEvent::MouseButtonDblClick:
case QEvent::MouseButtonRelease:
if (OPNET::OpNetwork::instance()->isReplay() || OPNET::OpNetwork::instance()->isReplica())
return false;
mouseEvent = (static_cast<QMouseEvent*>(ev));
out << mouseEvent->pos() << mouseEvent->globalPos()
<< (int) mouseEvent->button() << (int) mouseEvent->buttons()
<< (int) mouseEvent->modifiers();
OPNET::OpNetwork::instance()->sendSysCall(MSG_LOG_USER_INPUT, (int) ev->type(), byteArray);
break;
case QEvent::Wheel:
if (OPNET::OpNetwork::instance()->isReplay() || OPNET::OpNetwork::instance()->isReplica())
return false;;
wheelEvent = (static_cast<QWheelEvent*>(ev));
out << wheelEvent->pos() << wheelEvent->globalPos()
<< wheelEvent->delta() << (int) wheelEvent->buttons()
<< (int) wheelEvent->modifiers() << (int) wheelEvent->orientation();
OPNET::OpNetwork::instance()->sendSysCall(MSG_LOG_USER_INPUT, (int) ev->type(), byteArray);
break;
case QEvent::KeyPress:
case QEvent::KeyRelease:
if (OPNET::OpNetwork::instance()->isReplay() || OPNET::OpNetwork::instance()->isReplica())
return false;
keyEvent = (static_cast<QKeyEvent*>(ev));
out << keyEvent->key() << (int) keyEvent->modifiers()
<< keyEvent->text() << keyEvent->isAutoRepeat()
<< (int) keyEvent->count();
OPNET::OpNetwork::instance()->sendSysCall(MSG_LOG_USER_INPUT, (int) ev->type(), byteArray);
break;
default:
break;
}
return QWebPage::event(ev);
}
bool KHCWidget::eventFilter(QObject* o, QEvent* e)
{
if(::strcmp(o->name(), "txtOrgKey") == 0){
if(e->type() == QEvent::KeyPress){
QKeyEvent* ke = (QKeyEvent*)e;
if(ke->isAutoRepeat() == false){
onPress_Org(ke);
}
return(true);
}
} else if(::strcmp(o->name(), "txtMapKey") == 0){
if(e->type() == QEvent::KeyPress){
QKeyEvent* ke = (QKeyEvent*)e;
if(ke->isAutoRepeat() == false){
onPress_Map(ke);
}
return(true);
}
}
return QWidget::eventFilter(o, e);
}
//intercept return key and map it to the tab key so the dialog doesnt exit
bool CEditNetDlg::eventFilter(QObject* o, QEvent* e)
{
if (e->type() == QEvent::KeyPress || e->type() == QEvent::KeyRelease)
{
QKeyEvent* ke = (QKeyEvent*)e;
if (ke->key() == Qt::Key_Return || ke->key() == Qt::Key_Enter)
{
QKeyEvent rep(ke->type(), Qt::Key_Tab, Qt::NoModifier, QString::null, ke->isAutoRepeat(), ke->count());
*ke = rep;
}
}
return QDialog::eventFilter(o, e);
}
//-----------------------------------------------------------------------------
//!
//-----------------------------------------------------------------------------
bool tApVrfCalibrationWizard::eventFilter(QObject* pObject, QEvent* pEvent)
{
if ( m_CalibrationStep == eCS_ReadyForHoldToPort || m_CalibrationStep == eCS_HoldToPort )
{
if (pEvent->type() == QEvent::KeyPress)
{
QKeyEvent* pKeyEvent = static_cast<QKeyEvent*>(pEvent);
if ( pKeyEvent->key() == Key::Left ||
pKeyEvent->key() == Key::ZoomIn )
{
if ( pKeyEvent->isAutoRepeat() == false )
{
OnTurnPortStart();
}
return true;
}
}
}
if ( m_CalibrationStep == eCS_HoldToPort )
{
if (pEvent->type() == QEvent::KeyRelease)
{
QKeyEvent* pKeyEvent = static_cast<QKeyEvent*>(pEvent);
if ( pKeyEvent->key() == Key::Left ||
pKeyEvent->key() == Key::ZoomIn )
{
if ( pKeyEvent->isAutoRepeat() == false )
{
OnTurnPortStop();
}
return true;
}
}
}
// pass the event
return QObject::eventFilter(pObject, pEvent);
}
void
DBusInputContextConnection::sendKeyEvent(const QKeyEvent &keyEvent,
Maliit::EventRequestType requestType)
{
if (activeConnection) {
MInputContextConnection::sendKeyEvent(keyEvent, requestType);
ComMeegoInputmethodInputcontext1Interface *proxy = mProxys.value(activeConnection);
if (proxy) {
proxy->keyEvent(keyEvent.type(), keyEvent.key(), keyEvent.modifiers(),
keyEvent.text(), keyEvent.isAutoRepeat(), keyEvent.count(), requestType);
}
}
}
bool KeyPressEater::eventFilter(QObject *obj, QEvent *event)
{
if (event->type() == QEvent::KeyPress) {
QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
//printf("Ate key press %d. repeat %d. mod: %d\n", keyEvent->key(),(int)keyEvent->isAutoRepeat(),(int)keyEvent->modifiers());
if(!keyEvent->isAutoRepeat() && keyEvent->modifiers()==Qt::NoModifier)
emit Key(keyEvent->key());
if(keyEvent->modifiers()==Qt::ControlModifier && keyEvent->key()==Qt::Key_C)
emit Key(0);
return true;
} else {
// standard event processing
return QObject::eventFilter(obj, event);
}
}
bool ChatInputSendFilter::eventFilter(QObject * object, QEvent * event)
{
Q_UNUSED(object);
if(event->type() == QEvent::KeyPress)
{
QKeyEvent * keyEvent = static_cast<QKeyEvent *>(event);
if(keyEvent->key() == Qt::Key_Return && !keyEvent->isAutoRepeat())
{
emit sendPressed();
return true;
}
}
return false;
}
// handle key presses for all keys in keyboard
bool EmulKbd::event(QEvent *_e)
{
switch (_e->type())
{
case QEvent::KeyPress:
case QEvent::KeyRelease:
{
QKeyEvent *e = static_cast<QKeyEvent *>(_e);
int keycode = e->key();
EmulKey *key;
// ignore repeated keys
if (!e->isAutoRepeat())
{
// scan all children
for (QObjectList::const_iterator it(children().begin()); it != children().end(); ++it)
{
// only keys, not other children!
if ((*it)->metaObject() == &EmulKey::staticMetaObject)
// if ((key = dynamic_cast<EmulKey *>(*it)))
{
key = static_cast<EmulKey *>(*it);
// same key?
if (key->keycode == keycode)
{
// yes, tell key to go down (or up)
key->setDown(_e->type() == QEvent::KeyPress);
break;
}
}
}
}
return true;
}
default:
// let superclass process this event
return QFrame::event(_e);
} // end switch(_e->type())
}
//------------------------------------------------------------------------------
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);
}
/*! \reimp */
bool QGroupBox::event(QEvent *e)
{
Q_D(QGroupBox);
#ifndef QT_NO_SHORTCUT
if (e->type() == QEvent::Shortcut) {
QShortcutEvent *se = static_cast<QShortcutEvent *>(e);
if (se->shortcutId() == d->shortcutId) {
if (!isCheckable()) {
d->_q_fixFocus(Qt::ShortcutFocusReason);
} else {
d->click();
setFocus(Qt::ShortcutFocusReason);
}
return true;
}
}
#endif
QStyleOptionGroupBox box;
initStyleOption(&box);
switch (e->type()) {
case QEvent::HoverEnter:
case QEvent::HoverMove: {
QStyle::SubControl control = style()->hitTestComplexControl(QStyle::CC_GroupBox, &box,
static_cast<QHoverEvent *>(e)->pos(),
this);
bool oldHover = d->hover;
d->hover = d->checkable && (control == QStyle::SC_GroupBoxLabel || control == QStyle::SC_GroupBoxCheckBox);
if (oldHover != d->hover) {
QRect rect = style()->subControlRect(QStyle::CC_GroupBox, &box, QStyle::SC_GroupBoxCheckBox, this)
| style()->subControlRect(QStyle::CC_GroupBox, &box, QStyle::SC_GroupBoxLabel, this);
update(rect);
}
return true;
}
case QEvent::HoverLeave:
d->hover = false;
if (d->checkable) {
QRect rect = style()->subControlRect(QStyle::CC_GroupBox, &box, QStyle::SC_GroupBoxCheckBox, this)
| style()->subControlRect(QStyle::CC_GroupBox, &box, QStyle::SC_GroupBoxLabel, this);
update(rect);
}
return true;
case QEvent::KeyPress: {
QKeyEvent *k = static_cast<QKeyEvent*>(e);
if (!k->isAutoRepeat() && (k->key() == Qt::Key_Select || k->key() == Qt::Key_Space)) {
d->pressedControl = QStyle::SC_GroupBoxCheckBox;
update(style()->subControlRect(QStyle::CC_GroupBox, &box, QStyle::SC_GroupBoxCheckBox, this));
return true;
}
break;
}
case QEvent::KeyRelease: {
QKeyEvent *k = static_cast<QKeyEvent*>(e);
if (!k->isAutoRepeat() && (k->key() == Qt::Key_Select || k->key() == Qt::Key_Space)) {
bool toggle = (d->pressedControl == QStyle::SC_GroupBoxLabel
|| d->pressedControl == QStyle::SC_GroupBoxCheckBox);
d->pressedControl = QStyle::SC_None;
if (toggle)
d->click();
return true;
}
break;
}
default:
break;
}
return QWidget::event(e);
}
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 ShortcutEditorWidget::eventFilter(QObject *object, QEvent *event)
{
if (event->type() == QEvent::MouseButtonPress || event->type() == QEvent::ContextMenu)
{
m_lineEdit->setFocus();
return true;
}
else if (event->type() == QEvent::FocusOut)
{
m_isRecording = false;
updateDisplay();
}
else if (event->type() == QEvent::KeyPress)
{
QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
int key = keyEvent->key();
if (key == -1 || keyEvent->isAutoRepeat())
{
return true;
}
if (!m_isRecording)
{
m_recordedSequence = QString();
m_isRecording = true;
}
switch (key)
{
case Qt::Key_Control:
key = Qt::CTRL;
break;
case Qt::Key_Shift:
key = Qt::SHIFT;
break;
case Qt::Key_Alt:
key = Qt::ALT;
break;
case Qt::Key_Meta:
key = Qt::META;
break;
default:
break;
}
if (m_isRecording)
{
if (!m_recordedSequence.isEmpty() && !m_recordedSequence.endsWith("+"))
{
m_recordedSequence.append("+");
}
m_recordedSequence.append(QKeySequence(key).toString());
m_keySequence = QKeySequence(m_recordedSequence);
updateDisplay();
}
}
return QObject::eventFilter(object, event);
}
bool MainWindow::eventFilter(QObject *object, QEvent *e)
{
Q_UNUSED(object);
if (e->type() == QEvent::KeyPress || e->type() == QEvent::KeyRelease)
{
QKeyEvent *keyEvent = static_cast<QKeyEvent *>(e);
bool isPress = e->type() == QEvent::KeyPress;
switch(keyEvent->key()) {
case Qt::Key_Up:
case Qt::Key_Down:
case Qt::Key_Left:
case Qt::Key_Right:
case Qt::Key_Z:
case Qt::Key_X:
if (mCopterSim.collisionOccured()) {
return false;
}
break;
default:
return false;
}
if(keyEvent->isAutoRepeat()) {
return true;
}
switch(keyEvent->key()) {
case Qt::Key_Up:
if (isPress) {
mPitchKey = -1.0;
} else {
mPitchKey = 0.0;
}
break;
case Qt::Key_Down:
if (isPress) {
mPitchKey = 1.0;
} else {
mPitchKey = 0.0;
}
break;
case Qt::Key_Left:
if (isPress) {
mRollKey = -1.0;
} else {
mRollKey = 0.0;
}
break;
case Qt::Key_Right:
if (isPress) {
mRollKey = 1.0;
} else {
mRollKey = 0.0;
}
break;
case Qt::Key_Z:
if (isPress) {
mYawKey = 1.0;
} else {
mYawKey = 0.0;
}
break;
case Qt::Key_X:
if (isPress) {
mYawKey = -1.0;
} else {
mYawKey = 0.0;
}
break;
default:
break;
}
return true;
}
return false;
}
bool twinkleTutor::eventFilter(QObject *obj, QEvent *event)
{
//if statement to trap for KeyPress event
if (event->type() == QEvent::KeyPress) {
// Create key event
QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
//Once the key is pressed, it is automatically put in a
//"pressed" state until it is released.
switch( keyEvent->key() ){
case Qt::Key_A: ui->aButton->setDown(true);
if (keyEvent->key()== Qt::Key_A)
{
//to keep sound from looping repeatedly after key press
if (keyEvent->isAutoRepeat()==true)
{
keyEvent->ignore();
}
//Sound only begins upon first key press
else
{
keyA->play();
}
}
break;
case Qt::Key_S: ui->sButton->setDown(true);
if (keyEvent->key()== Qt::Key_S)
{
if (keyEvent->isAutoRepeat()){
keyEvent->ignore();
}
else
{
keyS->play();
}
}
break;
case Qt::Key_D: ui->dButton->setDown(true);
if (keyEvent->key()== Qt::Key_D)
{
if (keyEvent->isAutoRepeat()){
keyEvent->ignore();
}
else
{
keyD->play();
}
}
break;
case Qt::Key_G: ui->gButton->setDown(true);
if (keyEvent->key()== Qt::Key_G)
{
if (keyEvent->isAutoRepeat()){
keyEvent->ignore();
}
else
{
keyG->play();
}
}
break;
case Qt::Key_H: ui->hButton->setDown(true);
if (keyEvent->key()== Qt::Key_H)
{
if (keyEvent->isAutoRepeat()){
keyEvent->ignore();
}
else
{
keyH->play();
}
}
break;
case Qt::Key_F: ui->fButton->setDown(true);
if (keyEvent->key()== Qt::Key_F)
{
if (keyEvent->isAutoRepeat()){
keyEvent->ignore();
}
else
{
keyF->play();
}
}
break;
case Qt::Key_J: ui->jButton->setDown(true);
if (keyEvent->key()== Qt::Key_J)
{
if (keyEvent->isAutoRepeat()){
keyEvent->ignore();
}
else
{
keyJ->play();
}
}
break;
case Qt::Key_K: ui->kButton->setDown(true);
if (keyEvent->key()== Qt::Key_K)
{
if (keyEvent->isAutoRepeat()){
keyEvent->ignore();
}
else
{
keyK->play();
}
}
break;
case Qt::Key_L: ui->lButton->setDown(true);
if (keyEvent->key()== Qt::Key_L)
{
if (keyEvent->isAutoRepeat()){
keyEvent->ignore();
}
else
{
keyL->play();
}
}
break;
case Qt::Key_Semicolon: ui->semiButton->setDown(true);
if (keyEvent->key()== Qt::Key_Semicolon)
{
if (keyEvent->isAutoRepeat()){
keyEvent->ignore();
}
else
{
keySemi->play();
}
}
break;
case Qt::Key_Apostrophe: ui->apostButton->setDown(true);
if (keyEvent->key()== Qt::Key_Apostrophe)
{
if (keyEvent->isAutoRepeat()){
keyEvent->ignore();
}
else
{
keyDot->play();
}
}
break;
case Qt::Key_W: ui->wButton->setDown(true);
if (keyEvent->key()== Qt::Key_W)
{
if (keyEvent->isAutoRepeat()){
keyEvent->ignore();
}
else
{
keyW->play();
}
}
break;
case Qt::Key_E: ui->eButton->setDown(true);
if (keyEvent->key()== Qt::Key_E)
{
if (keyEvent->isAutoRepeat()){
keyEvent->ignore();
}
else
{
keyE->play();
}
}
break;
case Qt::Key_T: ui->tButton->setDown(true);
if (keyEvent->key()== Qt::Key_T)
{
if (keyEvent->isAutoRepeat()){
keyEvent->ignore();
}
else
{
keyT->play();
}
}
break;
case Qt::Key_Y: ui->yButton->setDown(true);
if (keyEvent->key()== Qt::Key_Y)
{
if (keyEvent->isAutoRepeat()){
keyEvent->ignore();
}
else
{
keyY->play();
}
}
break;
case Qt::Key_U: ui->uButton->setDown(true);
if (keyEvent->key()== Qt::Key_U)
{
if (keyEvent->isAutoRepeat()){
keyEvent->ignore();
}
else
{
keyU->play();
}
}
break;
case Qt::Key_O: ui->oButton->setDown(true);
if (keyEvent->key()== Qt::Key_O)
{
if (keyEvent->isAutoRepeat()){
keyEvent->ignore();
}
else
{
keyO->play();
}
}
break;
case Qt::Key_P: ui->pButton->setDown(true);
if (keyEvent->key()== Qt::Key_P)
{
if (keyEvent->isAutoRepeat()){
keyEvent->ignore();
}
else
{
keyP->play();
}
}
break;
}
}
//if statement to trap for Key Release. Sound is stopped upon key
//release.
if (event->type() == QEvent::KeyRelease){
QKeyEvent *keyEvent2 = static_cast<QKeyEvent *>(event);
switch( keyEvent2->key() ){
case Qt::Key_A: ui->aButton->setDown(false); keyA->stop();
if (arrayCount==0 || twinkle[arrayCount-1]=='C' ){
playTutorSong(twinkle);
}
break;
case Qt::Key_S: ui->sButton->setDown(false); keyS->stop();
if (twinkle[arrayCount-1]=='D'){
playTutorSong(twinkle);
}
break;
case Qt::Key_D: ui->dButton->setDown(false); keyD->stop();
if(twinkle[arrayCount-1]=='E'){
playTutorSong(twinkle);
}
break;
case Qt::Key_G: ui->gButton->setDown(false); keyG->stop();
if(twinkle[arrayCount-1]=='G'){
playTutorSong(twinkle);
}
break;
case Qt::Key_H: ui->hButton->setDown(false); keyH->stop();
if(twinkle[arrayCount-1]=='A'){
playTutorSong(twinkle);
}
break;
case Qt::Key_F: ui->fButton->setDown(false); keyF->stop();
if(twinkle[arrayCount-1]=='F'){
playTutorSong(twinkle);
}
break;
case Qt::Key_J: ui->jButton->setDown(false); keyJ->stop();
if(twinkle[arrayCount-1]=='B'){
playTutorSong(twinkle);
}
break;
case Qt::Key_K: ui->kButton->setDown(false); keyK->stop();
if(twinkle[arrayCount-1]=='c'){
playTutorSong(twinkle);
}
break;
case Qt::Key_L: ui->lButton->setDown(false); keyL->stop();
if(twinkle[arrayCount-1]=='d'){
playTutorSong(twinkle);
}
break;
case Qt::Key_Semicolon: ui->semiButton->setDown(false); keySemi->stop();
if(twinkle[arrayCount-1]==';'){
playTutorSong(twinkle);
}
break;
case Qt::Key_Apostrophe: ui->apostButton->setDown(false); keyDot->stop();
if(twinkle[arrayCount-1]=='f'){
playTutorSong(twinkle);
}
break;
case Qt::Key_W: ui->wButton->setDown(false); keyW->stop();
if(twinkle[arrayCount-1]=='w'){
playTutorSong(twinkle);
}
break;
case Qt::Key_E: ui->eButton->setDown(false); keyE->stop();
if(twinkle[arrayCount-1]=='e'){
playTutorSong(twinkle);
}
break;
case Qt::Key_T: ui->tButton->setDown(false); keyT->stop();
if(twinkle[arrayCount-1]=='t'){
playTutorSong(twinkle);
}
break;
case Qt::Key_Y: ui->yButton->setDown(false); keyY->stop();
if(twinkle[arrayCount-1]=='y'){
playTutorSong(twinkle);
}
break;
case Qt::Key_U: ui->uButton->setDown(false); keyU->stop();
if(twinkle[arrayCount-1]=='u'){
playTutorSong(twinkle);
}
break;
case Qt::Key_O: ui->oButton->setDown(false); keyO->stop();
if(twinkle[arrayCount-1]=='o'){
playTutorSong(twinkle);
}
break;
case Qt::Key_P: ui->pButton->setDown(false); keyP->stop();
if(twinkle[arrayCount-1]=='p'){
playTutorSong(twinkle);
}
break;
}
}
// Pass to Piano
return QMainWindow::eventFilter(obj, event);
}
bool ShortcutController::eventFilter(QObject*, QEvent* event) {
if (event->type() == QEvent::KeyPress || event->type() == QEvent::KeyRelease) {
QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
if (keyEvent->isAutoRepeat()) {
return false;
}
auto item = m_heldKeys.find(keyEventToSequence(keyEvent));
if (item == m_heldKeys.end()) {
return false;
}
ShortcutItem::Functions pair = item.value()->functions();
if (event->type() == QEvent::KeyPress) {
if (pair.first) {
pair.first();
}
} else {
if (pair.second) {
pair.second();
}
}
event->accept();
return true;
}
if (event->type() == GamepadButtonEvent::Down()) {
auto item = m_buttons.find(static_cast<GamepadButtonEvent*>(event)->value());
if (item == m_buttons.end()) {
return false;
}
QAction* action = item.value()->action();
if (action && action->isEnabled()) {
action->trigger();
}
ShortcutItem::Functions pair = item.value()->functions();
if (pair.first) {
pair.first();
}
event->accept();
return true;
}
if (event->type() == GamepadButtonEvent::Up()) {
auto item = m_buttons.find(static_cast<GamepadButtonEvent*>(event)->value());
if (item == m_buttons.end()) {
return false;
}
ShortcutItem::Functions pair = item.value()->functions();
if (pair.second) {
pair.second();
}
event->accept();
return true;
}
if (event->type() == GamepadAxisEvent::Type()) {
GamepadAxisEvent* gae = static_cast<GamepadAxisEvent*>(event);
auto item = m_axes.find(qMakePair(gae->axis(), gae->direction()));
if (item == m_axes.end()) {
return false;
}
if (gae->isNew()) {
QAction* action = item.value()->action();
if (action && action->isEnabled()) {
action->trigger();
}
}
ShortcutItem::Functions pair = item.value()->functions();
if (gae->isNew()) {
if (pair.first) {
pair.first();
}
} else {
if (pair.second) {
pair.second();
}
}
event->accept();
return true;
}
return false;
}
bool CompletionListView::event(QEvent *e)
{
if (m_blockFocusOut)
return QListView::event(e);
bool forwardKeys = true;
if (e->type() == QEvent::FocusOut) {
QModelIndex index;
#if defined(Q_OS_DARWIN) && ! defined(QT_MAC_USE_COCOA)
QFocusEvent *fe = static_cast<QFocusEvent *>(e);
if (fe->reason() == Qt::OtherFocusReason) {
// Qt/carbon workaround
// focus out is received before the key press event.
index = currentIndex();
}
#endif
m_completionWidget->closeList(index);
if (m_infoFrame)
m_infoFrame->close();
return true;
} else if (e->type() == QEvent::ShortcutOverride) {
QKeyEvent *ke = static_cast<QKeyEvent *>(e);
switch (ke->key()) {
case Qt::Key_N:
case Qt::Key_P:
// select next/previous completion
if (ke->modifiers() == Qt::ControlModifier)
{
e->accept();
int change = (ke->key() == Qt::Key_N) ? 1 : -1;
int nrows = model()->rowCount();
int row = currentIndex().row();
int newRow = (row + change + nrows) % nrows;
if (newRow == row + change || !ke->isAutoRepeat())
setCurrentIndex(m_model->index(newRow));
return true;
}
}
} else if (e->type() == QEvent::KeyPress) {
QKeyEvent *ke = static_cast<QKeyEvent *>(e);
switch (ke->key()) {
case Qt::Key_N:
case Qt::Key_P:
// select next/previous completion - so don't pass on to editor
if (ke->modifiers() == Qt::ControlModifier)
forwardKeys = false;
break;
case Qt::Key_Escape:
m_completionWidget->closeList();
return true;
case Qt::Key_Right:
case Qt::Key_Left:
case Qt::Key_Home:
case Qt::Key_End:
// We want these navigation keys to work in the editor, so forward them
break;
case Qt::Key_Tab:
case Qt::Key_Return:
//independently from style, accept current entry if return is pressed
if (qApp->focusWidget() == this)
m_completionWidget->closeList(currentIndex());
return true;
case Qt::Key_Up:
m_explicitlySelected = true;
if (!ke->isAutoRepeat()
&& currentIndex().row() == 0) {
setCurrentIndex(model()->index(model()->rowCount()-1, 0));
return true;
}
forwardKeys = false;
break;
case Qt::Key_Down:
m_explicitlySelected = true;
if (!ke->isAutoRepeat()
&& currentIndex().row() == model()->rowCount()-1) {
setCurrentIndex(model()->index(0, 0));
return true;
}
forwardKeys = false;
break;
case Qt::Key_Enter:
case Qt::Key_PageDown:
case Qt::Key_PageUp:
forwardKeys = false;
break;
default:
// if a key is forwarded, completion widget is re-opened and selected item is reset to first,
// so only forward keys that insert text and refine the completed item
forwardKeys = !ke->text().isEmpty();
break;
}
const CompletionPolicy policy = m_support->policy();
if (forwardKeys && policy != QuickFixCompletion) {
if (ke->text().length() == 1 && currentIndex().isValid() && qApp->focusWidget() == this) {
QChar typedChar = ke->text().at(0);
const CompletionItem &item = m_model->itemAt(currentIndex());
if (item.collector->typedCharCompletes(item, typedChar)) {
m_typedChar = typedChar;
m_completionWidget->closeList(currentIndex());
return true;
}
}
m_blockFocusOut = true;
QApplication::sendEvent(m_editorWidget, e);
m_blockFocusOut = false;
// Have the completion support update the list of items
m_support->complete(m_editor, policy, false);
return true;
}
}
return QListView::event(e);
}
bool LipstickCompositorWindow::eventFilter(QObject *obj, QEvent *event)
{
#if QT_VERSION >= 0x050202
if (obj == window() && m_interceptingTouch) {
switch (event->type()) {
case QEvent::TouchUpdate: {
QTouchEvent *te = static_cast<QTouchEvent *>(event);
// If we get press/release, don't intercept the event, but send it through QQuickWindow.
// These are sent through to QQuickWindow so that the integrity of the touch
// handling is maintained.
if (te->touchPointStates() & (Qt::TouchPointPressed | Qt::TouchPointReleased))
return false;
handleTouchEvent(static_cast<QTouchEvent *>(event));
return true;
}
case QEvent::TouchEnd: // Intentional fall through...
case QEvent::TouchCancel:
obj->removeEventFilter(this);
m_interceptingTouch = false;
default:
break;
}
return false;
}
#else
Q_UNUSED(obj);
#endif
if (event->type() == QEvent::KeyPress || event->type() == QEvent::KeyRelease) {
QKeyEvent *ke = static_cast<QKeyEvent *>(event);
QWaylandSurface *m_surface = surface();
if (m_surface && (m_grabbedKeys.contains(ke->key()) || m_pressedGrabbedKeys.keys.contains(ke->key())) && !ke->isAutoRepeat()) {
QWaylandInputDevice *inputDevice = m_surface->compositor()->defaultInputDevice();
if (event->type() == QEvent::KeyPress) {
if (m_pressedGrabbedKeys.keys.isEmpty()) {
QWaylandSurface *old = inputDevice->keyboardFocus();
m_pressedGrabbedKeys.oldFocus = old;
inputDevice->setKeyboardFocus(m_surface);
}
m_pressedGrabbedKeys.keys << ke->key();
}
inputDevice->sendFullKeyEvent(ke);
if (event->type() == QEvent::KeyRelease) {
m_pressedGrabbedKeys.keys.removeOne(ke->key());
if (m_pressedGrabbedKeys.keys.isEmpty()) {
inputDevice->setKeyboardFocus(m_pressedGrabbedKeys.oldFocus);
if (m_grabbedKeys.isEmpty())
qApp->removeEventFilter(this);
}
}
return true;
}
}
return false;
}
bool CryptobullionAmountField::eventFilter(QObject *object, QEvent *event)
{
if (event->type() == QEvent::FocusIn)
{
// Clear invalid flag on focus
setValid(true);
}
else if (event->type() == QEvent::KeyPress || event->type() == QEvent::KeyRelease)
{
QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
if (keyEvent->key() == Qt::Key_Comma)
{
// Translate a comma into a period
QKeyEvent periodKeyEvent(event->type(), Qt::Key_Period, keyEvent->modifiers(), ".", keyEvent->isAutoRepeat(), keyEvent->count());
qApp->sendEvent(object, &periodKeyEvent);
return true;
}
}
return QWidget::eventFilter(object, event);
}
bool TEWidget::eventFilter( QObject *obj, QEvent *e )
{
#if 0
// because QT4 using QShortcut, so I diable this function
if ( (e->type() == QEvent::Accel ||
e->type() == QEvent::AccelAvailable ) && qApp->focusWidget() == this )
{
static_cast<QKeyEvent *>( e )->ignore();
return true;
}
#endif
if ( obj != this /* when embedded */ && obj != parent() /* when standalone */ )
return FALSE; // not us
if ( e->type() == QEvent::Wheel)
{
QApplication::sendEvent(scrollbar, e);
}
#ifdef FAKE_CTRL_AND_ALT
static bool control = FALSE;
static bool alt = FALSE;
// Has a keyboard with no CTRL and ALT keys, but we fake it:
bool dele=FALSE;
if ( e->type() == QEvent::KeyPress || e->type() == QEvent::KeyRelease ) {
QKeyEvent* ke = (QKeyEvent*)e;
bool keydown = e->type() == QEvent::KeyPress || ke->isAutoRepeat();
switch (ke->key()) {
case Key_F9: // let this be "Control"
control = keydown;
e = new QKeyEvent(QEvent::KeyPress, Key_Control, 0, ke->state());
dele=TRUE;
break;
case Key_F13: // let this be "Alt"
alt = keydown;
e = new QKeyEvent(QEvent::KeyPress, Key_Alt, 0, ke->state());
dele=TRUE;
break;
default:
if ( control ) {
int a = toupper(ke->ascii())-64;
if ( a >= 0 && a < ' ' ) {
e = new QKeyEvent(e->type(), ke->key(),
a, ke->state()|ControlButton, QChar(a,0));
dele=TRUE;
}
}
if ( alt ) {
e = new QKeyEvent(e->type(), ke->key(),
ke->ascii(), ke->state()|AltButton, ke->text());
dele=TRUE;
}
}
}
#endif
if ( e->type() == QEvent::KeyPress )
{
QKeyEvent* ke = (QKeyEvent*)e;
actSel=0; // Key stroke implies a screen update, so TEWidget won't
// know where the current selection is.
emit keyPressedSignal(ke); // expose
ke->accept();
#ifdef FAKE_CTRL_AND_ALT
if ( dele ) delete e;
#endif
return true; // stop the event
}
if ( e->type() == QEvent::Enter )
{
QObject::disconnect( (QObject*)cb, SIGNAL(dataChanged()),
this, SLOT(onClearSelection()) );
}
if ( e->type() == QEvent::Leave )
{
QObject::connect( (QObject*)cb, SIGNAL(dataChanged()),
this, SLOT(onClearSelection()) );
}
return QFrame::eventFilter( obj, e );
}
