//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);
}
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 Window::eventFilter(QObject*, QEvent* event) {
if (event->type() != QEvent::KeyPress) {
return false;
}
QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
if (keyEvent->key() == Qt::Key_Up || keyEvent->key() == Qt::Key_Down) {
QKeyEvent* newEvent = new QKeyEvent(
keyEvent->type(), keyEvent->key(), keyEvent->ascii(),
keyEvent->state(), keyEvent->text());
QApplication::postEvent(mView, newEvent);
return true;
}
return false;
}
bool QtKeyEventProvider::eventFilter(QObject * obj, QEvent * event)
{
if (event->type() == QEvent::KeyPress ||
event->type() == QEvent::KeyRelease)
{
QKeyEvent * qKeyEvent = dynamic_cast<QKeyEvent*>(event);
if (qKeyEvent) {
auto eventType = QtEventTransformer::keyboardTypeFromQtType(qKeyEvent->type());
auto key = QtEventTransformer::fromQtKeyCode(qKeyEvent->key(), qKeyEvent->modifiers());
KeyboardEvent * keyEvent = new KeyboardEvent(eventType
, key, qKeyEvent->nativeScanCode(), qKeyEvent->modifiers());
passEvent(keyEvent);
return false;
}
}
return QObject::eventFilter(obj, event);
}
Qt::KeyboardModifiers ShortcutDialog::getModifiers(const QKeyEvent &event)
{
int key = event.key();
Qt::KeyboardModifiers mods = event.modifiers();
if (key == Qt::Key_Meta || key == Qt::Key_Super_L || key == Qt::Key_Super_R
|| key == Qt::Key_Hyper_L || key == Qt::Key_Hyper_R)
{
m_metaPressed = (event.type() == QEvent::KeyPress);
COPYQ_LOG(QString("Shortcut \"Meta\" key %1.").arg(m_metaPressed ? "pressed" : "released"));
}
if (m_metaPressed)
mods |= Qt::MetaModifier;
else
mods &= ~Qt::MetaModifier;
return mods;
}
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;
}
void MInputContextConnection::sendKeyEvent(const QKeyEvent &keyEvent,
Maliit::EventRequestType requestType)
{
if (requestType != Maliit::EventRequestSignalOnly
&& preedit.isEmpty()
&& keyEvent.key() == Qt::Key_Backspace
&& keyEvent.type() == QEvent::KeyPress) {
QString surrString(widgetState[SurroundingTextAttribute].toString());
const int cursorPosition(widgetState[CursorPositionAttribute].toInt());
bool validAnchor(false);
if (!surrString.isEmpty()
&& cursorPosition > 0
// we don't support selections
&& anchorPosition(validAnchor) == cursorPosition
&& validAnchor) {
widgetState[SurroundingTextAttribute] = surrString.remove(cursorPosition - 1, 1);
widgetState[CursorPositionAttribute] = cursorPosition - 1;
widgetState[AnchorPositionAttribute] = cursorPosition - 1;
}
}
}
//------------------------------------------------------------------------------
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);
}
int ShortcutDialog::getModifiers(const QKeyEvent &event)
{
int key = event.key();
const Qt::KeyboardModifiers mods = event.modifiers();
int result = 0;
if (key == Qt::Key_Meta || key == Qt::Key_Super_L || key == Qt::Key_Super_R
|| key == Qt::Key_Hyper_L || key == Qt::Key_Hyper_R)
{
m_metaPressed = (event.type() == QEvent::KeyPress);
COPYQ_LOG(QString("Shortcut \"Meta\" key %1.").arg(m_metaPressed ? "pressed" : "released"));
}
if (mods & Qt::ShiftModifier)
result |= Qt::SHIFT;
if (mods & Qt::ControlModifier)
result |= Qt::CTRL;
if (mods & Qt::AltModifier)
result |= Qt::ALT;
if (m_metaPressed || mods & Qt::MetaModifier)
result |= Qt::META;
return result;
}
bool TestFramework::eventFilter(QObject* obj, QEvent* e)
{
if (test_running_)
{
// if (e == last_event_) return false;
// last_event_ = e;
bool stop = false;
if (e->type() == QEvent::KeyPress)
{
QKeyEvent* ke = dynamic_cast<QKeyEvent*>(e);
// pause macro if pause key is pressed
if (ke->key() == Qt::Key_Pause) stop = true;
else if (ke->key() == Qt::Key_X && ke->modifiers() == Qt::AltModifier)
{
// if a user presses Alt-X: quit immediately
abortTest();
getMainControl()->quit(0);
return true;
}
}
else if (e->type() == QEvent::MouseButtonPress ||
e->type() == QEvent::MouseButtonRelease)
{
// abort macro if user presses mouse button:
if (!RTTI::isKindOf<MyMouseEvent>(*e) && e->spontaneous())
{
stop = true;
}
}
else
{
return false;
}
if (stop)
{
abortTest();
qApp->installEventFilter(this);
return true;
}
return false;
}
// if test is paused and pause key is pressed->resume macro
if (!recording_ && e->type() == QEvent::KeyPress && lines_.size() > 0)
{
QKeyEvent* ke = dynamic_cast<QKeyEvent*>(e);
if (ke->key() == Qt::Key_Pause)
{
processEvent_();
timer_.reset();
timer_.start();
test_running_ = true;
thread_.start();
return true;
}
return false;
}
if (!recording_) return false;
if (!RTTI::isKindOf<QKeyEvent>(*e) &&
!RTTI::isKindOf<QMouseEvent>(*e) &&
!RTTI::isKindOf<QShortcutEvent>(*e))
{
return false;
}
if (e->type() == QEvent::ShortcutOverride) return false;
if (e->type() == QEvent::KeyRelease) return false;
QMouseEvent* me = dynamic_cast<QMouseEvent*>(e);
QKeyEvent* ke = dynamic_cast<QKeyEvent*>(e);
QShortcutEvent* se = dynamic_cast<QShortcutEvent*>(e);
if (ke != 0 &&
ke->type() == QEvent::KeyPress &&
ke->key() == Qt::Key_Pause)
{
stopTest();
return false;
}
///////////////////////////////////////////////////////
// uniquely identify the active widget:
// walk up the QObject tree and collect all names of QWidgets
///////////////////////////////////////////////////////
// take the sending object
QObject* o = obj;
QObject* parent = 0;
x_ = y_ = 0;
// for mouse events: take widget under the mouse cursor
if (me != 0)
{
widget_ = qApp->widgetAt(me->globalPos());
if (widget_ == 0) return false;
if (widget_->objectName() == "" &&
widget_->actions().size() == 0)
{
widget_ = dynamic_cast<QWidget*>(widget_->parent());
if (widget_ == 0 || widget_->objectName() == "") return false;
}
o = widget_;
QPoint global = me->globalPos();
// if we can not get local coordinates: abort
QPoint local = widget_->mapFromGlobal(global);
if (local.x() < 0 || local.y() < 0 ||
local.x() >= widget_->width() || local.y() >= widget_->height())
{
return false;
}
// for menus: take the position of the action under the cursor
QMenu* menu = dynamic_cast<QMenu*>(o);
if (menu)
{
QAction* action = menu->actionAt(local);
if (action != 0)
{
o = action;
parent = menu;
QRect rect = menu->actionGeometry(action);
local.rx() -= rect.x();
local.ry() -= rect.y();
if (rect.width() == 0 || rect.height() == 0) return false;
x_ = local.x();
y_ = local.y();
}
}
if (x_ == 0 && y_ == 0)
{
// take the position as percent of the widget's actual size
if (widget_->width() == 0 || widget_->height() == 0) return false;
x_ = local.x();
y_ = local.y();
}
}
String names;
while (o != 0)
{
String name = ascii(o->objectName());
if (name == "")
{
QWidget* widget = dynamic_cast<QWidget*>(o);
if (widget != 0)
{
QList<QAction*> actions = widget->actions();
if (actions.size() == 1)
{
name = ascii((**actions.begin()).objectName());
}
}
}
else
{
// if a parent has more childs with the same name: add a suffix with the number
if (!parent) parent = o->parent();
if (parent != 0)
{
QList<QWidget*> childs = parent->findChildren<QWidget*>(name.c_str());
if (childs.size() > 1)
{
Position pos = 0;
QList<QWidget*>::iterator wit = childs.begin();
for (; wit != childs.end(); wit++)
{
if (*wit == o)
{
name += "#";
name += String(pos);
break;
}
pos++;
}
}
}
}
if (name != "") names = name + "|" + names;
o = o->parent();
}
String event_string;
event_string += String((int)e->type()) + "|";
event_string += String(getMainControl()->isBusy()) + "|";
if (me != 0)
{
if (me->button() == Qt::NoButton &&
!switch_move->isChecked() &&
me->type() == QEvent::MouseMove &&
widget_ == last_widget_)
{
return false;
}
last_widget_ = widget_;
event_string += String((int)MOUSE) + "|";
event_string += String((int) me->modifiers()) + "|";
event_string += String((int) me->button()) + "|";
event_string += String((int) me->buttons()) + "|";
event_string += String(x_) + "|";
event_string += String(y_) + "|";
// prevent mouse move events with same position
if (event_string == last_event_string_ &&
names == last_names_)
{
return false;
}
}
else if (ke != 0)
{
// prevent accepting key events that are resend further up in the widget tree
if (timer_.getClockTime() < 0.01) return false;
int m = (int) ke->modifiers();
// sometimes Qt sends nonsense Key messages
if (m > (int)(Qt::AltModifier | Qt::ControlModifier | Qt::ShiftModifier)) return false;
event_string += String((int)KEY) + "|";
event_string += String(m);
event_string += "|";
event_string += String(ke->key()) + "|";
}
else if (se != 0)
{
event_string += String((int)SHORTCUT) + "|";
event_string += String(se->shortcutId()) + "|";
event_string += ascii(se->key().toString()) + "|";
}
float time = timer_.getClockTime();
timer_.reset();
outfile_ << "I°"
<< time << "°"
<< names << "°"
<< event_string << std::endl;
last_event_string_ = event_string;
last_names_ = names;
return false;
}
bool WindowServerLuna::processSystemShortcut(QEvent* event)
{
if (SystemUiController::instance()->bootFinished() &&
(event->type() == QEvent::KeyPress || event->type() == QEvent::KeyRelease)) {
static bool symDown = false;
QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
switch (keyEvent->key()) {
case Qt::Key_Control:
symDown = keyEvent->type() == QEvent::KeyPress;
break;
// QT5_TODO: Are these equivalent?
#if (QT_VERSION < QT_VERSION_CHECK(5, 0, 0))
case KEYS::Key_Power: {
#else
case KEYS::Key_HardPower: {
#endif
m_powerVolumeKeyComboState.powerKeyPress = (keyEvent->type() == QEvent::KeyPress);
if (!m_powerVolumeKeyComboState.powerKeyPress) {
cancelFullEraseCountdown();
}
else if (m_powerVolumeKeyComboState.msmEntryComboDown()) {
SystemService::instance()->enterMSM();
return true;
}
else if (m_powerVolumeKeyComboState.comboDown())
return true;
break;
}
case Qt::Key_VolumeDown: {
m_powerVolumeKeyComboState.volDownKeyPress = (keyEvent->type() == QEvent::KeyPress);
if (m_powerVolumeKeyComboState.msmEntryComboDown()) {
SystemService::instance()->enterMSM();
return true;
}
break;
}
case Qt::Key_VolumeUp: {
m_powerVolumeKeyComboState.volUpKeyPress = (keyEvent->type() == QEvent::KeyPress);
if (!m_powerVolumeKeyComboState.volUpKeyPress) {
cancelFullEraseCountdown();
}
else if (m_powerVolumeKeyComboState.comboDown())
return true;
break;
}
case KEYS::Key_CoreNavi_Home: {
bool ret = triggerFullEraseCountdown();
if (ret) {
// Eat up the home key event
return true;
}
break;
}
}
/*
#if !defined(TARGET_DEVICE)
KeyMapType key = getDetailsForQtKey(keyEvent->key(), keyEvent->modifiers());
switch (key.qtKey) {
case Qt::Key_D: {
// force the device into Dock Mode
if (symDown && (keyEvent->type() == QEvent::KeyPress) && (!SystemUiController::instance()->isInDockMode())) {
m_displayMgr->dock();
return true;
}
break;
}
case Qt::Key_L: {
// force the device into Dock Mode
if (symDown && (keyEvent->type() == QEvent::KeyPress) && (!m_displayMgr->isLocked())) {
m_displayMgr->lock();
return true;
}
break;
}
default:
break;
}
#endif*/
}
return WindowServer::processSystemShortcut(event);
}
QPixmap* WindowServerLuna::takeScreenShot()
{
QPixmap* pix = new QPixmap(m_screenWidth, m_screenHeight);
QPainter painter(pix);
bool visibleReticle = (m_reticle ? m_reticle->isVisible() : false);
if (visibleReticle)
m_reticle->setVisible(false);
render(&painter);
painter.end();
if(visibleReticle)
m_reticle->setVisible(true);
g_message("%s",__PRETTY_FUNCTION__);
return pix;
}
void WindowServerLuna::slotMemoryStateChanged(bool critical)
{
g_debug("%s: %s", __PRETTY_FUNCTION__, critical ? "critical" : "non-critical");
if (critical) {
createMemoryAlertWindow();
}
else {
if (m_memoryAlert) {
QmlAlertWindow* win = m_memoryAlert.data();
m_memoryAlert.clear();
win->close();
}
}
}
bool JointItem::eventFilter(QObject *obj, QEvent *event)
{
if (event->type() == QEvent::KeyPress || event->type() == QEvent::KeyRelease) {
QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
int key = keyEvent->key();
if(key == Qt::Key_Left || key == Qt::Key_Right || key == Qt::Key_Up ||
key == Qt::Key_Down || key == Qt::Key_PageUp || key == Qt::Key_PageDown) {
QSlider *slider;
QLabel *label;
if(obj == ui->sliderPositionPosition) {
motionDone = false;
slider = ui->sliderPositionPosition;
label = ui->labelPositionPosition;
if(keyEvent->type() == QEvent::KeyPress) {
onSliderPositionPressed();
}
if(keyEvent->type() == QEvent::KeyRelease) {
onSliderPositionReleased();
}
}
if(obj == ui->sliderPositionVelocity) {
motionDone = false;
slider = ui->sliderPositionVelocity;
label = ui->labelPositionVelocity;
}
if(obj == ui->sliderPositionDirect) {
motionDone = false;
slider = ui->sliderPositionDirect;
label = ui->labelPositionDirectPosition;
if(keyEvent->type() == QEvent::KeyPress) {
onSliderPositionPressed();
}
if(keyEvent->type() == QEvent::KeyRelease) {
onSliderPositionReleased();
}
}
if(obj == ui->sliderMixedPosition) {
motionDone = false;
slider = ui->sliderMixedPosition;
label = ui->labelMixedPosition;
if(keyEvent->type() == QEvent::KeyPress) {
onSliderPositionPressed();
}
if(keyEvent->type() == QEvent::KeyRelease) {
onSliderPositionReleased();
}
}
if(obj == ui->sliderMixedVelocity) {
slider = ui->sliderMixedVelocity;
label = ui->labelMixedVelocity;
}
if(obj == ui->sliderTorqueTorque) {
slider = ui->sliderTorqueTorque;
label = ui->labelTorqueTorque;
if(keyEvent->type() == QEvent::KeyPress) {
onSliderTorquePressed();
}
if(keyEvent->type() == QEvent::KeyRelease) {
onSliderTorqueReleased();
}
}
if(obj == ui->sliderOpenloopOutput) {
slider = ui->sliderOpenloopOutput;
label = ui->labelOpenLoopOutput;
if(keyEvent->type() == QEvent::KeyPress) {
onSliderOpenloopPressed();
}
if(keyEvent->type() == QEvent::KeyRelease) {
onSliderOpenloopReleased();
}
}
if(obj == ui->sliderVelocityVelocity) {
slider = ui->sliderVelocityVelocity;
label = ui->labelVelocityVelocity;
if(keyEvent->type() == QEvent::KeyPress) {
onSliderVelocityPressed();
}
if(keyEvent->type() == QEvent::KeyRelease) {
onSliderVelocityReleased();
}
}
if(keyEvent->type() == QEvent::KeyPress) {
if(key == Qt::Key_Left || key == Qt::Key_Down) {
slider->setValue(slider->value() - 1);
}
if(key == Qt::Key_Right || key == Qt::Key_Up) {
slider->setValue(slider->value() + 1);
}
if(key == Qt::Key_PageUp) {
slider->setValue(slider->value() + 10);
}
if(key == Qt::Key_PageDown) {
slider->setValue(slider->value() - 10);
}
if(obj == ui->sliderTorqueTorque) {
updateSliderTorqueLabel(slider,label,slider->value());
} else {
updateSliderLabel(slider,label,slider->value());
}
}
return true;
}
return QObject::eventFilter(obj, event);
} else {
// standard event processing
return QObject::eventFilter(obj, event);
}
}
bool CoreNaviManager::handleEvent(QEvent *event) {
if (!m_leds) {
return false;
}
QKeyEvent *keyEvent = NULL;
if (QEvent::KeyPress == event->type() || QEvent::KeyRelease == event->type()) {
keyEvent = static_cast<QKeyEvent*> (event);
}
#if (QT_VERSION < QT_VERSION_CHECK(5, 0, 0))
if (keyEvent && keyEvent->isGestureKey()) {
#else
if (keyEvent && keyEvent->type() == QEvent::Gesture) {
#endif
switch (keyEvent->key()) {
case KEYS::Key_CoreNavi_QuickLaunch:
case KEYS::Key_CoreNavi_Launcher:
case KEYS::Key_CoreNavi_Previous:
case KEYS::Key_CoreNavi_Next:
case KEYS::Key_CoreNavi_Back:
case KEYS::Key_CoreNavi_Menu:
case KEYS::Key_CoreNavi_SwipeDown:
case KEYS::Key_CoreNavi_Home:
//One shot events
if (keyEvent->type() == QEvent::KeyPress) {
if (m_hasLightBar) {
renderGestureOnLightbar(keyEvent->key());
} else {
renderGesture(keyEvent->key());
}
}
break;
case KEYS::Key_CoreNavi_Meta:
if (!m_hasLightBar) {
//continous glow
if (keyEvent->type() == QEvent::KeyPress) {
setMetaGlow(true);
} else {
setMetaGlow(false);
}
} else {
if (useLightbar()) {
if (keyEvent->type() == QEvent::KeyPress && m_systemUiController->isCardWindowMaximized()
&& !m_systemUiController->isScreenLocked()) {
// this is just finger down in the meta area, triggering hold timer
g_debug("Key down in core navi area, triggering lightbarHoldTimer");
m_metaKeyDown = true;
m_lightbarHoldTimer.start(300, true);
} else if (keyEvent->type() == QEvent::KeyRelease) {
m_lightbarHoldTimer.stop();
if (!m_systemUiController->isScreenLocked() && m_systemUiController->isCardWindowMaximized()
&& !m_allGlow && !m_lightbarSwipeLeftTimer.running()
&& !m_lightbarSwipeRightTimer.running() && !m_lightbarRestoreTimer.running()) {
m_metaKeyDown = false;
g_debug("key up, setting leds back to %d", m_brightness);
m_leds->ledSet(m_leds->All(), m_brightness);
m_allGlow = true;
}
}
}
}
break;
default:
break;
}
}
return false;
}
bool CoreNaviManager::handleEvent(sptr<Event> e)
{
return false;
}
CoreNaviManager::LedRequest::LedRequest (const std::string& appId, const std::string& requestId)
{
this->appId = appId;
this->requestId = requestId;
}
/** Filter the Keyboard events of QLineEdit composing the widget. */
bool AustrianSocialNumberEdit::eventFilter(QObject *obj, QEvent *e)
{
if (e->type()!=QEvent::KeyPress && e->type()!=QEvent::KeyRelease)
return false;
QKeyEvent *kevent = static_cast<QKeyEvent*>(e);
if (!kevent)
return false;
QLineEdit *lineEdit = static_cast<QLineEdit*>(obj);
if (!lineEdit)
return false;
int currentId = m_Edits.indexOf(lineEdit);
if (currentId==-1)
return false;
int nextTab = -1;
// only key release events
if (kevent->type()==QKeyEvent::KeyPress) {
// qWarning() << "KeyPress" << kevent;//;->text() << kevent->key();
switch (kevent->key()) {
case Qt::Key_0:
case Qt::Key_1:
case Qt::Key_2:
case Qt::Key_3:
case Qt::Key_4:
case Qt::Key_5:
case Qt::Key_6:
case Qt::Key_7:
case Qt::Key_8:
case Qt::Key_9: return false;
if(lineEdit->cursorPosition() == lineEdit->maxLength()-1) {
focusNextChild();
return false;
}
case Qt::Key_Right: // Ok
if (lineEdit->cursorPosition()==lineEdit->maxLength() // if we are at the end of the edit
&& currentId != m_Edits.count()-1) { // and it's not the last edit in the Widget
focusNextChild();
}
return true;
case Qt::Key_Left:
// Manage autoRepeat keys
if (lineEdit->cursorPosition()==0 // if we are at the beginning of the edit
&& currentId != 0) { // and it's not the first edit in the widget
focusPreviousChild(); // -> go one edit left
}
return true;
case Qt::Key_Backspace:
{
if (lineEdit->cursorPosition() == 0 // if we are at the beginning of the edit
&& currentId != 0) { // and it's not the first edit in the widget
focusPreviousChild();
return false; // process Backspace as usual
// if (kevent->isAutoRepeat()) {
// int pos = lineEdit->cursorPosition();
// removeChar(currentId, pos);
// --pos;
// if (pos==0) --pos;
// setCursorPosition(currentId, pos);
}
// e->ignore();
return false;
// break;
}
case Qt::Key_Delete:
if (kevent->isAutoRepeat()) {
int pos = lineEdit->cursorPosition();
++pos;
removeChar(currentId, pos);
setCursorPosition(currentId, pos-1);
}
e->ignore();
return true;
default: return false;
}
}
// else if (kevent->type()==QKeyEvent::KeyRelease) {
// // qWarning() << "KeyReleased" << kevent->text() << kevent->key();
// switch (kevent->key()) {
// case Qt::Key_0:
// case Qt::Key_1:
// case Qt::Key_2:
// case Qt::Key_3:
// case Qt::Key_4:
// case Qt::Key_5:
// case Qt::Key_6:
// case Qt::Key_7:
// case Qt::Key_8:
// case Qt::Key_9:
// {
// addChar(kevent->text(), currentId, lineEdit->cursorPosition());
// return true;
// break;
// }
// case Qt::Key_Home:
// nextTab = 0;
// break;
// case Qt::Key_End:
// nextTab = m_Edits.count()-2;
// break;
// case Qt::Key_Left:
//// if (l->cursorPosition()==0) {
//// setCursorPosition(currentId, -1);
// return true;
//// }
// break;
// case Qt::Key_Right:
// return true;
// break;
// case Qt::Key_Delete:
// {
// // remove char at
// int pos = lineEdit->cursorPosition();
// ++pos;
// removeChar(currentId, pos);
// setCursorPosition(currentId, pos-1);
// return true;
// }
// case Qt::Key_Backspace:
// {
// // remove char at
// int pos = lineEdit->cursorPosition();
// removeChar(currentId, pos);
// --pos;
// if (pos==0) --pos;
// setCursorPosition(currentId, pos);
// return true;
// }
// default: return false;
// }
// }
return false;
}
/** Filter the Keyboard events of QLineEdit composing the widget. */
bool FrenchSocialNumber::eventFilter(QObject *o, QEvent *e)
{
if (e->type()!=QEvent::KeyPress && e->type()!=QEvent::KeyRelease)
return false;
QKeyEvent *kevent = static_cast<QKeyEvent*>(e);
if (!kevent)
return false;
QLineEdit *l = static_cast<QLineEdit*>(o);
if (!l)
return false;
int currentId = m_Edits.indexOf(l);
if (currentId==-1)
return false;
int nextTab = -1;
// only key release events
if (kevent->type()==QKeyEvent::KeyPress) {
// qWarning() << "KeyPress" << kevent;//;->text() << kevent->key();
switch (kevent->key()) {
case Qt::Key_0:
case Qt::Key_1:
case Qt::Key_2:
case Qt::Key_3:
case Qt::Key_4:
case Qt::Key_5:
case Qt::Key_6:
case Qt::Key_7:
case Qt::Key_8:
case Qt::Key_9:
case Qt::Key_A:
case Qt::Key_B:
// no management of auto-repeat
e->ignore();
return true;
case Qt::Key_Left:
// Manage autoRepeat keys
if (l->cursorPosition()==0)
setCursorPosition(currentId, -1);
break;
case Qt::Key_Right: // Ok
if (l->cursorPosition()==m_NbChars.at(currentId)) {
nextTab = currentId+1;
if (nextTab >= m_Edits.count())
return true;
setCursorPosition(nextTab, 0);
return true;
}
break;
case Qt::Key_Backspace:
{
if (kevent->isAutoRepeat()) {
int pos = l->cursorPosition();
removeChar(currentId, pos);
--pos;
if (pos==0) --pos;
setCursorPosition(currentId, pos);
}
e->ignore();
return true;
break;
}
case Qt::Key_Delete:
if (kevent->isAutoRepeat()) {
int pos = l->cursorPosition();
++pos;
removeChar(currentId, pos);
setCursorPosition(currentId, pos-1);
}
e->ignore();
return true;
default: return false;
}
} else if (kevent->type()==QKeyEvent::KeyRelease) {
// qWarning() << "KeyReleased" << kevent->text() << kevent->key();
switch (kevent->key()) {
case Qt::Key_0:
case Qt::Key_1:
case Qt::Key_2:
case Qt::Key_3:
case Qt::Key_4:
case Qt::Key_5:
case Qt::Key_6:
case Qt::Key_7:
case Qt::Key_8:
case Qt::Key_9:
{
addChar(kevent->text(), currentId, l->cursorPosition());
return true;
break;
}
case Qt::Key_A:
case Qt::Key_B:
{
// only departement 2ndchar
if (currentId==3 && l->cursorPosition()==1) {
addChar(kevent->text(), currentId, l->cursorPosition());
return true;
}
break;
}
case Qt::Key_Home:
nextTab = 0;
break;
case Qt::Key_End:
nextTab = m_Edits.count()-2;
break;
case Qt::Key_Left:
// if (l->cursorPosition()==0) {
// setCursorPosition(currentId, -1);
return true;
// }
break;
case Qt::Key_Right:
return true;
break;
case Qt::Key_Delete:
{
// remove char at
int pos = l->cursorPosition();
++pos;
removeChar(currentId, pos);
setCursorPosition(currentId, pos-1);
return true;
}
case Qt::Key_Backspace:
{
// remove char at
int pos = l->cursorPosition();
removeChar(currentId, pos);
--pos;
if (pos==0) --pos;
setCursorPosition(currentId, pos);
return true;
}
default: return false;
}
}
return false;
}
void DashboardEditor::sendKeyEvent(const QKeyEvent &ev)
{
QKeyEvent *new_ev = new QKeyEvent(ev.type(), ev.key(), ev.modifiers(), ev.text(), ev.isAutoRepeat(), ev.count());
qApp->postEvent(m_target, new_ev);
}
