int WinPlatform::keyCode(const QKeyEvent &event)
{
const int key = event.key();
// Some keys shouldn't be translated.
if ( key == Qt::Key_Return
|| key == Qt::Key_Enter
|| key == Qt::Key_Escape
|| key == Qt::Key_Tab
|| key == Qt::Key_Backtab
|| key == Qt::Key_Backspace
)
{
return key;
}
const quint32 vk = event.nativeVirtualKey();
const UINT result = MapVirtualKeyW(vk, MAPVK_VK_TO_CHAR);
if (result != 0)
return result;
return key;
}
bool KisAbstractSliderSpinBox::eventFilter(QObject* recv, QEvent* e)
{
Q_D(KisAbstractSliderSpinBox);
if (recv == static_cast<QObject*>(d->edit) &&
e->type() == QEvent::KeyRelease) {
QKeyEvent* keyEvent = static_cast<QKeyEvent*>(e);
switch (keyEvent->key()) {
case Qt::Key_Enter:
case Qt::Key_Return:
setInternalValue(d->edit->text().toDouble()*d->factor);
hideEdit();
return true;
case Qt::Key_Escape:
hideEdit();
return true;
default:
break;
}
}
return false;
}
bool FileSystemRemoteDialog::eventFilter(QObject * o, QEvent * e)
{
if (e->type() == QEvent::KeyPress)
{
// key pressed
// transforms QEvent into QKeyEvent
QKeyEvent* pKeyEvent = static_cast<QKeyEvent*>(e);
switch (pKeyEvent->key())
{
case Qt::Key_Backspace:
case Qt::Key_Back:
{
sltClickedBack();
break;
}
}
return true;
}
else
{
return QDialog::eventFilter(o, e);
}
}
bool ColorMapEditor::eventFilter(QObject *object, QEvent *e) {
if (e->type() == QEvent::MouseMove && object == table->viewport()) {
const QMouseEvent *me = (const QMouseEvent *)e;
QPoint pos = table->viewport()->mapToParent(me->pos());
int row = table->rowAt(pos.y() - table->horizontalHeader()->height());
if (table->columnAt(pos.x()) == 1 && row >= 0 && row < table->rowCount())
setCursor(QCursor(Qt::PointingHandCursor));
else
setCursor(QCursor(Qt::ArrowCursor));
return true;
} else if (e->type() == QEvent::Leave && object == table->viewport()) {
setCursor(QCursor(Qt::ArrowCursor));
return true;
} else if (e->type() == QEvent::KeyPress && object == table) {
QKeyEvent *ke = (QKeyEvent *)e;
if (ke->key() == Qt::Key_Return && table->currentColumn() == 1) {
showColorDialog(table->currentRow(), 1);
return true;
}
return false;
}
return QObject::eventFilter(object, e);
}
bool FileTransferWindow::eventFilter( QObject *obj, QEvent *ev )
{
if( ( ev->type() == QEvent::KeyPress ) )
{
//m_pTableWidget could not have been initialized yet when FileTransferWindow
//will receive the first events.. but it will surely be on a keypress event
if(obj==m_pTableWidget)
{
QKeyEvent *keyEvent = (QKeyEvent*)ev;
switch(keyEvent->key())
{
case Qt::Key_Delete:
if(m_pTableWidget->currentItem())
{
delete m_pTableWidget->currentItem();
return true;
}
break;
}
}
}
return KviWindow::eventFilter( obj, ev );
}
bool PropertiesDock::event(QEvent *event)
{
switch (event->type()) {
case QEvent::ShortcutOverride: {
QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
if (keyEvent->matches(QKeySequence::Delete) || keyEvent->key() == Qt::Key_Backspace
|| keyEvent->matches(QKeySequence::Cut)
|| keyEvent->matches(QKeySequence::Copy)
|| keyEvent->matches(QKeySequence::Paste)) {
event->accept();
return true;
}
break;
}
case QEvent::LanguageChange:
retranslateUi();
break;
default:
break;
}
return QDockWidget::event(event);
}
bool K3bInteractionDialog::eventFilter( QObject* o, QEvent* ev )
{
if( dynamic_cast<K3bInteractionDialog*>(o) == this &&
ev->type() == QEvent::KeyPress ) {
QKeyEvent* kev = dynamic_cast<QKeyEvent*>(ev);
switch ( kev->key() ) {
case Key_Enter:
case Key_Return:
// if the process finished this closes the dialog
if( m_defaultButton == START_BUTTON ) {
if( m_buttonStart->isEnabled() )
slotStartClickedInternal();
}
else if( m_defaultButton == CANCEL_BUTTON ) {
if( m_buttonCancel->isEnabled() )
slotCancelClicked();
}
else if( m_defaultButton == SAVE_BUTTON ) {
if( m_buttonSave->isEnabled() )
slotSaveClicked();
}
return true;
case Key_Escape:
// simulate button clicks
if( m_buttonCancel ) {
if( m_buttonCancel->isEnabled() )
slotCancelClicked();
}
return true;
}
}
return KDialog::eventFilter( o, ev );
}
bool BufferWidget::eventFilter(QObject *watched, QEvent *event) {
if(event->type() != QEvent::KeyPress)
return false;
QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
MultiLineEdit *inputLine = qobject_cast<MultiLineEdit *>(watched);
if(!inputLine)
return false;
// Intercept copy key presses
if(keyEvent == QKeySequence::Copy) {
if(inputLine->hasSelectedText())
return false;
ChatView *view = qobject_cast<ChatView *>(ui.stackedWidget->currentWidget());
if(view)
view->scene()->selectionToClipboard();
return true;
}
// We don't want to steal cursor movement keys if the input line is in multiline mode
if(!inputLine->isSingleLine())
return false;
switch(keyEvent->key()) {
case Qt::Key_Up:
case Qt::Key_Down:
if(!(keyEvent->modifiers() & Qt::ShiftModifier))
return false;
case Qt::Key_PageUp:
case Qt::Key_PageDown:
// static cast to access public qobject::event
return static_cast<QObject*>(ui.stackedWidget->currentWidget())->event(event);
default:
return false;
}
}
bool TopicChooser::eventFilter(QObject *object, QEvent *event)
{
if (object == ui.lineEdit && event->type() == QEvent::KeyPress) {
QKeyEvent *ke = static_cast<QKeyEvent*>(event);
int dIndex = 0;
switch (ke->key()) {
case Qt::Key_Up:
dIndex = -1;
break;
case Qt::Key_Down:
dIndex = +1;
break;
case Qt::Key_PageUp:
dIndex = -5;
break;
case Qt::Key_PageDown:
dIndex = +5;
break;
default:
break;
}
if (dIndex != 0) {
QModelIndex idx = ui.listWidget->currentIndex();
int newIndex = qMin(m_filterModel->rowCount(idx.parent()) - 1,
qMax(0, idx.row() + dIndex));
idx = m_filterModel->index(newIndex, idx.column(), idx.parent());
if (idx.isValid())
ui.listWidget->setCurrentIndex(idx);
return true;
}
} else if (ui.lineEdit && event->type() == QEvent::FocusIn
&& static_cast<QFocusEvent *>(event)->reason() != Qt::MouseFocusReason) {
ui.lineEdit->selectAll();
ui.lineEdit->setFocus();
}
return QDialog::eventFilter(object, event);
}
bool notify(QObject* receiver, QEvent* event) {
bool flag = QApplication::notify(receiver, event);
if (event->type() == QEvent::KeyPress) {
#if QT_VERSION >= 0x050000
const QMetaObject * mo = receiver->metaObject();
bool forQWidgetWindow = false;
if (mo){
if (strcmp(mo->className(), "QWidgetWindow") == 0)
forQWidgetWindow = true;
}
if(forQWidgetWindow){
return false;
}
#endif
QKeyEvent* ke = (QKeyEvent*)event;
MusEGlobal::globalKeyState = ke->modifiers();
bool accepted = ke->isAccepted();
if (!accepted) {
int key = ke->key();
if (((QInputEvent*)ke)->modifiers() & Qt::ShiftModifier)
key += Qt::SHIFT;
if (((QInputEvent*)ke)->modifiers() & Qt::AltModifier)
key += Qt::ALT;
if (((QInputEvent*)ke)->modifiers() & Qt::ControlModifier)
key+= Qt::CTRL;
muse->kbAccel(key);
return true;
}
}
if (event->type() == QEvent::KeyRelease) {
QKeyEvent* ke = (QKeyEvent*)event;
///MusEGlobal::globalKeyState = ke->stateAfter();
MusEGlobal::globalKeyState = ke->modifiers();
}
return flag;
}
bool BookmarkDialog::eventFilter(QObject *object, QEvent *e)
{
if (object == this && e->type() == QEvent::KeyPress) {
QKeyEvent *ke = static_cast<QKeyEvent*>(e);
QModelIndex index = ui.treeView->currentIndex();
switch (ke->key()) {
case Qt::Key_F2: {
const QModelIndex &source = proxyModel->mapToSource(index);
QStandardItem *item =
bookmarkManager->treeBookmarkModel()->itemFromIndex(source);
if (item) {
item->setEditable(true);
ui.treeView->edit(index);
item->setEditable(false);
}
} break;
case Qt::Key_Delete: {
bookmarkManager->removeBookmarkItem(ui.treeView,
proxyModel->mapToSource(index));
ui.bookmarkFolders->clear();
ui.bookmarkFolders->addItems(bookmarkManager->bookmarkFolders());
QString name = tr("Bookmarks");
index = ui.treeView->currentIndex();
if (index.isValid())
name = index.data().toString();
ui.bookmarkFolders->setCurrentIndex(ui.bookmarkFolders->findText(name));
} break;
default:
break;
}
}
return QObject::eventFilter(object, e);
}
/* Event handler for prepared listener(s): */
bool UIKeyboardHandlerScale::eventFilter(QObject *pWatchedObject, QEvent *pEvent)
{
/* Check if pWatchedObject object is view: */
if (UIMachineView *pWatchedView = isItListenedView(pWatchedObject))
{
/* Get corresponding screen index: */
ulong uScreenId = m_views.key(pWatchedView);
NOREF(uScreenId);
/* Handle view events: */
switch (pEvent->type())
{
#ifndef Q_WS_MAC
/* We don't want this on the Mac, cause there the menu bar isn't within the window
* and popping up a menu there looks really ugly. */
case QEvent::KeyPress:
{
/* Get key-event: */
QKeyEvent *pKeyEvent = static_cast<QKeyEvent*>(pEvent);
/* Process Host+Home for menu popup: */
if (isHostKeyPressed() && pKeyEvent->key() == gMS->keySequence(UIMachineShortcuts::PopupMenuShortcut))
{
/* Post request to show popup-menu: */
QTimer::singleShot(0, m_windows[uScreenId], SLOT(sltPopupMainMenu()));
/* Filter-out this event: */
return true;
}
break;
}
#endif /* !Q_WS_MAC */
default:
break;
}
}
/* Else just propagate to base-class: */
return UIKeyboardHandler::eventFilter(pWatchedObject, pEvent);
}
bool DebuggerConsole::eventFilter(QObject*, QEvent* event) {
if (event->type() != QEvent::KeyPress) {
return false;
}
if (m_history.isEmpty()) {
return false;
}
QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
switch (keyEvent->key()) {
case Qt::Key_Down:
if (m_historyOffset <= 0) {
return false;
}
--m_historyOffset;
break;
case Qt::Key_Up:
if (m_historyOffset >= m_history.size()) {
return false;
}
++m_historyOffset;
break;
case Qt::Key_End:
m_historyOffset = 0;
break;
case Qt::Key_Home:
m_historyOffset = m_history.size();
break;
default:
return false;
}
if (m_historyOffset == 0) {
m_ui.prompt->clear();
} else {
m_ui.prompt->setText(m_history[m_history.size() - m_historyOffset]);
}
return true;
}
bool MultiQFileDialog::eventFilter(QObject *obj, QEvent *e)
{
if (e->type() == QEvent::KeyPress)
{
QKeyEvent* keyEvent = dynamic_cast<QKeyEvent*>(e);
Qt::KeyboardModifiers modifiers = QApplication::queryKeyboardModifiers();
if (modifiers.testFlag(Qt::ControlModifier) && keyEvent && keyEvent->key() == Qt::Key_H)
{
if (showHidden)
{
if (multiSelect)
{
setFilter(QDir::AllDirs | QDir::AllEntries | QDir::NoDotAndDotDot);
}
else
{
setFilter(QDir::AllDirs | QDir::NoDotAndDotDot);
}
}
else
{
if (multiSelect)
{
setFilter(QDir::AllDirs | QDir::AllEntries | QDir::Hidden | QDir::System | QDir::NoDotAndDotDot);
}
else
{
setFilter(QDir::AllDirs | QDir::Hidden | QDir::System | QDir::NoDotAndDotDot);
}
}
showHidden = !showHidden;
}
}
return QFileDialog::eventFilter(obj, e);
}
/**
\fn eventFilter
\brief keyboard accessibility
*/
bool filtermainWindow::eventFilter(QObject* watched, QEvent* event)
{
QKeyEvent *keyEvent;
if(event->type() == QEvent::KeyPress)
{
keyEvent = (QKeyEvent*)event;
switch (keyEvent->key())
{
#ifndef __APPLE__
case Qt::Key_Delete:
#else
case Qt::Key_Backspace:
#endif
remove(true);
return true;
case Qt::Key_Return:
if(keyEvent->modifiers() & Qt::ControlModifier)
{
accept();
return true;
}
if(ui.listFilterCategory->hasFocus())
filterFamilyClick(ui.listFilterCategory->currentRow());
else if(availableList->hasFocus())
add(true);
else if(activeList->hasFocus())
configure(true);
else
accept();
return true;
default:
return false;
}
}
return QObject::eventFilter(watched, event);
}
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);
}
}
//------------------------------------------------------------------------------
bool IgnoreUndoRedo::eventFilter(QObject* watched, QEvent* event)
{
if (event->type() == QEvent::KeyPress)
{
QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
if (keyEvent->matches(QKeySequence::Undo)
|| keyEvent->matches(QKeySequence::Redo))
{
QCoreApplication::postEvent(recipient, new QKeyEvent(
keyEvent->type(), keyEvent->key(), keyEvent->modifiers(),
keyEvent->nativeScanCode(), keyEvent->nativeVirtualKey(),
keyEvent->nativeModifiers(), keyEvent->text(),
keyEvent->isAutoRepeat(), keyEvent->count()
));
return true;
}
else
{
return false;
}
}
else
return QObject::eventFilter(watched, event);
}
bool ClipboardHistorySelector::eventFilter(QObject *obj, QEvent *event)
{
if (obj == ui.clipboardItemsTable) {
if (event->type() == QEvent::KeyPress) {
QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
int key = keyEvent->key();
int row = -1;
if (key == Qt::Key_Delete) {
int current_row = ui.clipboardItemsTable->currentRow();
if (current_row >= 0) {
m_ClipboardHistoryItems->removeAt(current_row);
SetupClipboardHistoryTable();
if (current_row >= ui.clipboardItemsTable->rowCount()) {
current_row--;
}
ui.clipboardItemsTable->selectRow(current_row);
return true;
}
}
else if ((key >= Qt::Key_0) && (key <= Qt::Key_9)) {
row = key - Qt::Key_0;
}
else if ((key >= Qt::Key_A) && (key <= Qt::Key_J)) {
row = key - Qt::Key_A + 10;
}
if (row >= 0 && row < ui.clipboardItemsTable->rowCount()) {
ui.clipboardItemsTable->selectRow(row);
accept();
return true;
}
}
}
// pass the event on to the parent class
return QDialog::eventFilter(obj, event);
}
bool
SpinField_Impl::isModifyEvent(QEvent *event)
{
switch (event->type()) {
case QEvent::KeyPress:
{
QKeyEvent *e = (QKeyEvent *)event;
switch (e->key()) {
case Qt::Key_Tab:
case Qt::Key_Backtab:
return false;
}
return true;
}
break;
case QEvent::MouseButtonPress:
case QEvent::MouseButtonDblClick:
case QEvent::Wheel:
return true;
default:
break;
}
return false;
}
bool FakeVimHandler::Private::eventFilter(QObject *ob, QEvent *ev)
{
QKeyEvent *keyEvent = static_cast<QKeyEvent *>(ev);
int key = keyEvent->key();
if (key == Key_Shift || key == Key_Alt || key == Key_Control
|| key == Key_Alt || key == Key_AltGr || key == Key_Meta)
return false;
// Fake "End of line"
m_textedit = qobject_cast<QTextEdit *>(ob);
m_plaintextedit = qobject_cast<QPlainTextEdit *>(ob);
if (!m_textedit && !m_plaintextedit)
return false;
m_tc = EDITOR(textCursor());
if (m_fakeEnd)
m_tc.movePosition(Right, MoveAnchor, 1);
if (key >= Key_A && key <= Key_Z
&& (keyEvent->modifiers() & Qt::ShiftModifier) == 0)
key += 32;
if ((keyEvent->modifiers() & Qt::ControlModifier) != 0)
key += 256;
handleKey(key, keyEvent->text());
// We fake vi-style end-of-line behaviour
m_fakeEnd = (atEol() && m_mode == CommandMode);
if (m_fakeEnd)
m_tc.movePosition(Left, MoveAnchor, 1);
EDITOR(setTextCursor(m_tc));
EDITOR(ensureCursorVisible());
return true;
}
bool QWordCompleter::eventFilter(QObject *o, QEvent *e)
{
if(widget()->inherits("QTextEdit") && e->type() == QEvent::KeyPress){
QKeyEvent* ke = static_cast<QKeyEvent*>(e);
switch (ke->key()) {
case Qt::Key_Space:
if(ke->modifiers().testFlag(Qt::ControlModifier)){
QTextEdit* textEdit = qobject_cast<QTextEdit*>(widget());
QTextCursor textCursor = textEdit->textCursor();
textCursor.movePosition(QTextCursor::StartOfWord, QTextCursor::KeepAnchor);
if(textCursor.selectedText().length() >= minCompletionPrefixLength){
setCompletionPrefix(textCursor.selectedText());
QRect rect = QRect(textEdit->cursorRect().bottomLeft(), QSize(100, 5));
complete(rect);
}
return true;
}
break;
case Qt::Key_Enter:
case Qt::Key_Return:
case Qt::Key_Tab:
if(popup()->isVisible()){
popup()->hide();
if(popup()->currentIndex().isValid()){
emit activated(popup()->currentIndex());
emit activated(popup()->currentIndex().data(completionRole()).toString());
}
return true;
}
default:
break;
}
}
return QCompleter::eventFilter(o, e);
}
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 FocusWidgetFilter::eventFilter(QObject *, QEvent *e)
{
switch (e->type()) {
case QEvent::KeyPress:
{
QKeyEvent *ke = static_cast<QKeyEvent*>(e);
switch (ke->key()) {
case Qt::Key_Return:
emit returnPressed();
return true;
case Qt::Key_Escape:
emit escapePressed();
return true;
default:
return false;
};
}
case QEvent::Enter:
emit mouseEntered();
// pass through
default:
return false;
};
}
bool History::eventFilter(QObject *target, QEvent *event)
{
if(target ==plainTextEdit)//此判断可以省略,此程序中必进入此判断，但是有此句判断让程序更加规范
{
if (event->type() == QEvent::KeyPress)
{
QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
int code=keyEvent->key();
if(code==Qt::Key_Up)
{
plainTextEdit->moveCursor(QTextCursor::Up);
return false;
}
if(code==Qt::Key_Down)
{
plainTextEdit->moveCursor(QTextCursor::Down);
return false;
}
}
else
return false;
}
return QObject::eventFilter(target, event);
}
bool ItemEditorWidget::eventFilter(QObject *object, QEvent *event)
{
if ( object == m_editor && event->type() == QEvent::KeyPress ) {
QKeyEvent *keyevent = static_cast<QKeyEvent *>(event);
int k = keyevent->key();
if (k == Qt::Key_Return || k == Qt::Key_Enter) {
Qt::KeyboardModifiers mods = keyevent->modifiers();
if ( (mods & (Qt::ShiftModifier | Qt::AltModifier | Qt::MetaModifier)) == 0 ) {
bool controlPressed = mods.testFlag(Qt::ControlModifier);
if (m_saveOnReturnKey && controlPressed ) {
keyevent->setModifiers(mods & ~Qt::ControlModifier);
return false;
}
if ( m_saveOnReturnKey || controlPressed ) {
saveAndExit();
return true;
}
}
}
}
return false;
}
// Reimplemented
bool QmvList::eventFilter( QObject *o, QEvent *e )
{
if ( !o || !e )
return TRUE;
QmvItem *i = (QmvItem*)currentItem();
if ( o != this &&e->type() == QEvent::KeyPress )
{
QKeyEvent *ke = (QKeyEvent*)e;
if ( ( ke->key() == Key_Up || ke->key() == Key_Down ) &&
( o != this || o != viewport() ) &&
!( ke->state() & ControlButton ) )
{
QApplication::sendEvent( this, (QKeyEvent*)e );
return TRUE;
} else
if ( ( !o->inherits( "QLineEdit" ) ||
( o->inherits( "QLineEdit" ) && ( (QLineEdit*)o )->isReadOnly() ) ) &&
i && i->hasSubItems() )
{
if ( !i->isOpen() &&
( ke->key() == Key_Plus ||
ke->key() == Key_Right ))
i->setOpen( TRUE );
else
if ( i->isOpen() &&
( ke->key() == Key_Minus ||
ke->key() == Key_Left ) )
i->setOpen( FALSE );
} else
if ( ( ke->key() == Key_Return || ke->key() == Key_Enter ) && o->inherits( "QComboBox" ) )
{
QKeyEvent ke2( QEvent::KeyPress, Key_Space, 0, 0 );
QApplication::sendEvent( o, &ke2 );
return TRUE;
}
}
return QListView::eventFilter( o, e );
}
bool FormWindowManager::eventFilter(QObject *o, QEvent *e)
{
if (!o->isWidgetType())
return false;
// If we don't have an active form, we only listen for WindowActivate to speed up integrations
const QEvent::Type eventType = e->type();
if (m_activeFormWindow == 0 && eventType != QEvent::WindowActivate)
return false;
switch (eventType) { // Uninteresting events
case QEvent::Create:
case QEvent::Destroy:
case QEvent::ActionAdded:
case QEvent::ActionChanged:
case QEvent::ActionRemoved:
case QEvent::ChildAdded:
case QEvent::ChildPolished:
case QEvent::ChildRemoved:
#ifndef QT_NO_CLIPBOARD
case QEvent::Clipboard:
#endif
case QEvent::ContentsRectChange:
case QEvent::DeferredDelete:
case QEvent::FileOpen:
case QEvent::LanguageChange:
case QEvent::MetaCall:
case QEvent::ModifiedChange:
case QEvent::Paint:
case QEvent::PaletteChange:
case QEvent::ParentAboutToChange:
case QEvent::ParentChange:
case QEvent::Polish:
case QEvent::PolishRequest:
case QEvent::QueryWhatsThis:
case QEvent::StatusTip:
case QEvent::StyleChange:
case QEvent::Timer:
case QEvent::ToolBarChange:
case QEvent::ToolTip:
case QEvent::WhatsThis:
case QEvent::WhatsThisClicked:
case QEvent::WinIdChange:
case QEvent::DynamicPropertyChange:
case QEvent::HoverEnter:
case QEvent::HoverLeave:
case QEvent::HoverMove:
case QEvent::AcceptDropsChange:
return false;
default:
break;
}
QWidget *widget = static_cast<QWidget*>(o);
if (qobject_cast<WidgetHandle*>(widget)) { // ### remove me
return false;
}
FormWindow *fw = FormWindow::findFormWindow(widget);
if (fw == 0) {
return false;
}
if (QWidget *managedWidget = findManagedWidget(fw, widget)) {
// Prevent MDI subwindows from being closed by clicking at the title bar
if (managedWidget != widget && eventType == QEvent::Close) {
e->ignore();
return true;
}
switch (eventType) {
case QEvent::WindowActivate: {
if (fw->parentWidget()->isWindow() && fw->isMainContainer(managedWidget) && activeFormWindow() != fw) {
setActiveFormWindow(fw);
}
} break;
case QEvent::WindowDeactivate: {
if (o == fw && o == activeFormWindow())
fw->repaintSelection();
} break;
case QEvent::KeyPress: {
QKeyEvent *ke = static_cast<QKeyEvent*>(e);
if (ke->key() == Qt::Key_Escape) {
ke->accept();
return true;
}
}
// don't break...
// Embedded Design: Drop on different form: Make sure the right form
// window/device is active before having the widget created by the factory
case QEvent::Drop:
if (activeFormWindow() != fw)
setActiveFormWindow(fw);
// don't break...
default: {
if (fw->handleEvent(widget, managedWidget, e)) {
return true;
}
} break;
} // end switch
}
return false;
}
bool ShortcutGetter::event(QEvent *e)
{
if (!capture) return QDialog::event(e);
QString key;
QStringList mods;
QKeyEvent *k = static_cast<QKeyEvent*>(e);
switch ( e->type() )
{
case QEvent::KeyPress :
if ( bStop )
{
lKeys.clear();
bStop = false;
}
key = keyToString(k->key());
mods = modToString(k->modifiers());
//qDebug("event: key.count: %d, mods.count: %d", key.count(), mods.count());
if ( key.count() || mods.count() )
{
if ( key.count() && !lKeys.contains(key) )
lKeys << key;
for ( const auto &key : mods ) {
if ( !lKeys.contains(key) )
lKeys << key;
}
} else {
key = k->text();
if ( !lKeys.contains(key) )
lKeys << key;
}
setText();
break;
case QEvent::KeyRelease :
bStop = true;
break;
/*
case QEvent::ShortcutOverride :
leKey->setText("Shortcut override");
break;
*/
default:
return QDialog::event(e);
break;
}
return true;
}
bool TocDlg::eventFilter(QObject *obj, QEvent *event)
{
if(event->type() == QEvent::KeyPress) {
QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
QString text;
switch(keyEvent->key()) {
case Qt::Key_Q:
text = "1";
break;
case Qt::Key_W:
text = "2";
break;
case Qt::Key_E:
text = "3";
break;
case Qt::Key_R:
text = "4";
break;
case Qt::Key_T:
text = "5";
break;
case Qt::Key_Y:
text = "6";
break;
case Qt::Key_U:
text = "7";
break;
case Qt::Key_I:
text = "8";
break;
case Qt::Key_O:
text = "9";
break;
case Qt::Key_P:
text = "0";
break;
case 0x2e:
text = "%";
break;
case 0x01001103:
text = "%";
break;
case Qt::Key_Up:
{
if(isPageUpdated) {
on_actionUpdatePage_triggered();
isPageUpdated = false;
}
int cur_num = getCurrentItemPosFromBegin(m_docview->getToc(),m_ui->treeWidget->currentItem(), 0);
if((cur_num<=((curPage-1)*pageStrCount)+1) && (curPage==pageCount) && (pageCount>2)){
moveUpPage();
moveDownPage();
}
moveUp();
}
break;
case Qt::Key_Down:
moveDown();
break;
case Qt::Key_Select:
qDebug() << focusWidget()->objectName().toAscii().data();
{
QString s = m_ui->treeWidget->currentIndex().data(Qt::UserRole).toString();
m_docview->goToXPointer(s);
close();
return true;
}
break;
}
if(keyEvent->key() >= Qt::Key_0 && keyEvent->key() <= Qt::Key_9) text = keyEvent->text();
if(!text.isEmpty()) {
if(m_ui->pageNumEdit->text().lastIndexOf('%')>0) return true;
if(text == QString('%')) {
if(m_ui->pageNumEdit->text().toDouble()>100) return true;
}
m_ui->pageNumEdit->setText(m_ui->pageNumEdit->text() + text);
return true;
}
}
return false;
}
void Interactor2DVolumeEdit::UpdateCursor( QEvent* event, QWidget* wnd )
{
if ( wnd->hasFocus() )
{
bool bMouseEvent = false;
if ( event->type() == QEvent::MouseButtonPress ||
event->type() == QEvent::MouseButtonRelease ||
event->type() == QEvent::MouseMove)
{
QMouseEvent* e = ( QMouseEvent* )event;
bMouseEvent = true;
if ( ( ( e->button() == Qt::MidButton || e->button() == Qt::RightButton ) && !m_bEditing ) ||
( ( e->modifiers() & CONTROL_MODIFIER) && (e->modifiers() & Qt::ShiftModifier) ) )
{
Interactor2D::UpdateCursor( event, wnd );
return;
}
}
if ( m_nAction != EM_Fill )
{
if ( event->type() == QEvent::KeyPress )
{
QKeyEvent* e = ( QKeyEvent* )event;
if ( e->key() == CONTROL_KEY && !(e->modifiers() & Qt::ShiftModifier) && !(e->modifiers() & Qt::AltModifier) )
{
wnd->setCursor( CursorFactory::CursorFill );
return;
}
}
if ( bMouseEvent && (( QMouseEvent* )event)->modifiers() & CONTROL_MODIFIER
&& !((( QMouseEvent* )event)->modifiers() & Qt::ShiftModifier)
&& !((( QMouseEvent* )event)->modifiers() & Qt::AltModifier) )
{
wnd->setCursor( CursorFactory::CursorFill );
}
else if ( m_nAction == EM_ColorPicker )
{
wnd->setCursor( CursorFactory::CursorColorPicker );
}
else //if ( bMouseEvent )
{
switch ( m_nAction )
{
case EM_Freehand:
wnd->setCursor( CursorFactory::CursorPencil );
break;
case EM_Polyline:
wnd->setCursor( CursorFactory::CursorPolyline );
break;
case EM_Contour:
wnd->setCursor( CursorFactory::CursorContour );
break;
}
}
}
else
{
wnd->setCursor( CursorFactory::CursorFill );
}
}
else
{
Interactor2D::UpdateCursor( event, wnd );
}
}
