bool QtSystemTrayIcon::eventFilter(QObject* object, QEvent* event) {
if (QObject::eventFilter(object, event)) return true;
if (object != tray_) return false;
if (event->type() == QEvent::Wheel) {
QWheelEvent* e = static_cast<QWheelEvent*>(event);
if (e->modifiers() == Qt::ShiftModifier) {
if (e->delta() > 0) {
emit SeekForward();
} else {
emit SeekBackward();
}
} else if (e->modifiers() == Qt::ControlModifier) {
if (e->delta() < 0) {
emit NextTrack();
} else {
emit PreviousTrack();
}
} else {
emit ChangeVolume(e->delta());
}
return true;
}
return false;
}
bool csFontResizer::eventFilter(QObject *watched, QEvent *event)
{
if( event->type() == QEvent::KeyPress ) {
QKeyEvent *keyEvent = dynamic_cast<QKeyEvent*>(event);
if( keyEvent->matches(QKeySequence::ZoomIn) ||
(keyEvent->modifiers() == Qt::ControlModifier &&
keyEvent->key() == Qt::Key_BracketRight) ) {
resizeFont(watched, 0, incSize);
return true;
} else if( keyEvent->matches(QKeySequence::ZoomOut) ) {
resizeFont(watched, 0, -incSize);
return true;
} else if( keyEvent->modifiers() == Qt::ControlModifier &&
keyEvent->key() == Qt::Key_0 ) {
resizeFont(watched, defSize.value(dynamic_cast<QWidget*>(watched), 0));
return true;
}
} else if( event->type() == QEvent::Wheel ) {
QWheelEvent *wheelEvent = dynamic_cast<QWheelEvent*>(event);
if( wheelEvent->modifiers() == Qt::ControlModifier &&
wheelEvent->delta() > 0 ) {
resizeFont(watched, 0, incSize);
return true;
} else if( wheelEvent->modifiers() == Qt::ControlModifier &&
wheelEvent->delta() < 0 ) {
resizeFont(watched, 0, -incSize);
return true;
}
}
return QObject::eventFilter(watched, event);
}
bool ZoomEventFilter::eventFilter (QObject *viewObj, QEvent *someEvent)
{
if (someEvent->type () != QEvent::Wheel)
return false;
QWheelEvent *e = static_cast<QWheelEvent*> (someEvent);
if (!(e->modifiers () & Qt::ControlModifier))
return false;
int degrees = e->delta () / 8;
int steps = static_cast<qreal> (degrees) / 15;
QWebView *view = qobject_cast<QWebView*> (viewObj);
if (e->modifiers () & Qt::ShiftModifier)
{
auto multiplier = view->textSizeMultiplier ();
multiplier += steps * 0.1;
view->setTextSizeMultiplier (multiplier);
}
else
{
QWebSettings *settings = view->settings ();
settings->setFontSize (QWebSettings::DefaultFontSize,
std::max (6, settings->fontSize (QWebSettings::DefaultFontSize) + steps));
auto frame = view->page ()->mainFrame ();
frame->evaluateJavaScript ("setTimeout(ScrollToBottom,0);");
}
return true;
}
bool MouseMagnifyingGlassInteractorComponent::eventFilter(QObject *, QEvent *e) {
bool updateMagnifyingGlass = false;
Coord screenCoords;
if (e->type() == QEvent::MouseMove) {
QMouseEvent *me = static_cast<QMouseEvent *>(e);
float x = glWidget->width() - me->x();
float y = me->y();
screenCoords = Coord(x, y, 0);
boxCenter = camera->viewportTo3DWorld(glWidget->screenToViewport(screenCoords));
updateMagnifyingGlass = true;
}
else if (e->type() == QEvent::Wheel) {
QWheelEvent *wheelEvent = (QWheelEvent *) e;
float x = glWidget->width() - wheelEvent->x();
float y = wheelEvent->y();
screenCoords = Coord(x, y, 0);
boxCenter = camera->viewportTo3DWorld(glWidget->screenToViewport(screenCoords));
int numDegrees = wheelEvent->delta() / 8;
int numSteps = numDegrees / 15;
if (wheelEvent->orientation() == Qt::Vertical && (wheelEvent->modifiers() == Qt::ControlModifier)) {
updateMagnifyingGlass = true;
radius += numSteps;
if (radius < 1) radius = 1;
delete fbo;
delete fbo2;
fbo = NULL;
fbo2 = NULL;
}
else if (wheelEvent->orientation() == Qt::Vertical && (wheelEvent->modifiers() == Qt::ShiftModifier)) {
updateMagnifyingGlass = true;
magnifyPower += numSteps;
if (magnifyPower < 1) magnifyPower = 1;
}
}
static bool canUseFbo = QGLFramebufferObject::hasOpenGLFramebufferObjects();
if (canUseFbo && updateMagnifyingGlass) {
generateMagnifyingGlassTexture(screenCoords);
drawInteractor = true;
glWidget->redraw();
return true;
}
return false;
}
bool FishEyeInteractorComponent::eventFilter(QObject *obj, QEvent *e) {
GlMainWidget *glWidget = (GlMainWidget*)obj;
Camera *camera=&glWidget->getScene()->getGraphCamera();
activateFishEye = false;
if (e->type() == QEvent::MouseMove ||
e->type() == QEvent::MouseButtonPress ||
e->type() == QEvent::MouseButtonRelease) {
activateFishEye = true;
QMouseEvent *me = (QMouseEvent *) e;
float x = glWidget->width() - me->x();
float y = me->y();
Coord screenCoords(x, y, 0);
fisheyeCenter = camera->viewportTo3DWorld(glWidget->screenToViewport(screenCoords));
glWidget->redraw();
return true;
}
else if (e->type() == QEvent::Wheel) {
activateFishEye = true;
QWheelEvent *wheelEvent = (QWheelEvent *) e;
int numDegrees = wheelEvent->delta() / 8;
int numSteps = numDegrees / 15;
if (wheelEvent->orientation() == Qt::Vertical && (wheelEvent->modifiers() == Qt::ControlModifier)) {
activateFishEye = true;
configWidget->setFishEyeRadius(configWidget->getFishEyeRadius() + configWidget->getFishEyeRadiusIncrementStep() * numSteps);
glWidget->redraw();
return true;
}
else if (wheelEvent->orientation() == Qt::Vertical && (wheelEvent->modifiers() == Qt::ShiftModifier)) {
activateFishEye = true;
float newHeight = configWidget->getFishEyeHeight() + configWidget->getFishEyeHeightIncrementStep() * numSteps;
if (newHeight < 0) {
newHeight = 0;
}
configWidget->setFishEyeHeight(newHeight);
glWidget->redraw();
return true;
}
return false;
}
return false;
}
bool PaletteDockerDock::eventFilter(QObject* object, QEvent* event)
{
if (object == m_wdgPaletteDock->paletteView->viewport() && event->type() == QEvent::Wheel) {
QWheelEvent* qwheel = dynamic_cast<QWheelEvent* >(event);
if (qwheel->modifiers() & Qt::ControlModifier) {
int numDegrees = qwheel->delta() / 8;
int numSteps = numDegrees / 7;
int curSize = m_wdgPaletteDock->paletteView->horizontalHeader()->sectionSize(0);
int setSize = numSteps + curSize;
if ( setSize >= 12 ) {
m_wdgPaletteDock->paletteView->horizontalHeader()->setDefaultSectionSize(setSize);
m_wdgPaletteDock->paletteView->verticalHeader()->setDefaultSectionSize(setSize);
KisConfig cfg;
cfg.setPaletteDockerPaletteViewSectionSize(setSize);
}
return true;
} else {
return false;
}
} else {
return QWidget::eventFilter(object, event);
}
}
/*!
\reimp
*/
bool QScrollBar::event(QEvent *event)
{
switch(event->type()) {
case QEvent::HoverEnter:
case QEvent::HoverLeave:
case QEvent::HoverMove:
if (const QHoverEvent *he = static_cast<const QHoverEvent *>(event))
d_func()->updateHoverControl(he->pos());
break;
#ifndef QT_NO_WHEELEVENT
case QEvent::Wheel: {
event->ignore();
// override wheel event without adding virtual function override
QWheelEvent *ev = static_cast<QWheelEvent *>(event);
int delta = ev->delta();
// scrollbar is a special case - in vertical mode it reaches minimum
// value in the upper position, however QSlider's minimum value is on
// the bottom. So we need to invert a value, but since the scrollbar is
// inverted by default, we need to inverse the delta value for the
// horizontal orientation.
if (ev->orientation() == Qt::Horizontal)
delta = -delta;
Q_D(QScrollBar);
if (d->scrollByDelta(ev->orientation(), ev->modifiers(), delta))
event->accept();
return true;
}
#endif
default:
break;
}
return QAbstractSlider::event(event);
}
bool imageCompareBase::eventFilter(QObject* watched, QEvent* event) {
// make sure we setCur on an image click
if (event->type() == QEvent::FocusIn) {
if (watched == leftScroll_) {
setCur(leftImage());
}
else {
setCur(rightImage());
}
}
else if (event->type() == QEvent::KeyPress) {
QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
return filterKeyEvent(keyEvent);
}
else if (event->type() == QEvent::Wheel) {
QWheelEvent* wheelEvent = static_cast<QWheelEvent*>(event);
// shift scroll should give a horizontal scroll
if (wheelEvent->modifiers() == Qt::ShiftModifier) {
// must check both the scroll and its viewport
if (watched == rightScroll_ || watched == rightScroll_->viewport()) {
rightScroll_->horizontalScrollBar()->event(event);
return true;
}
else if (watched == leftScroll_ || watched == leftScroll_->viewport()) {
leftScroll_->horizontalScrollBar()->event(event);
return true;
}
}
}
return imageSaverWindow::eventFilter(watched, event);
}
// Extract event-specific arguments to co::Any array
void EventHub::extractArguments( QEvent* event, co::Any* args, int maxArgs )
{
QEvent::Type ev = event->type();
switch( ev )
{
case QEvent::MouseButtonDblClick:
case QEvent::MouseButtonPress:
case QEvent::MouseButtonRelease:
case QEvent::MouseMove:
{
QMouseEvent* mouseEvent = static_cast<QMouseEvent*>( event );
// extract (x and y), button, modifiers
const QPoint& pos = mouseEvent->pos();
args[0].set( pos.x() );
args[1].set( pos.y() );
args[2].set( static_cast<co::uint32>( ev == QEvent::MouseMove ?
mouseEvent->buttons() : mouseEvent->button() ) );
fillKeyboardModifiers( mouseEvent->modifiers(), args[3] );
}
break;
case QEvent::KeyPress:
case QEvent::KeyRelease:
{
QKeyEvent* keyEvent = static_cast<QKeyEvent*>( event );
fillKeyCodeString( keyEvent->key(), args[0] );
fillKeyboardModifiers( keyEvent->modifiers(), args[1] );
}
break;
case QEvent::Wheel:
{
QWheelEvent* wheelEvent = static_cast<QWheelEvent*>( event );
// extract position (x and y ), delta, modifiers
const QPoint& pos = wheelEvent->pos();
args[0].set( pos.x() );
args[1].set( pos.x() );
args[2].set( wheelEvent->delta() );
fillKeyboardModifiers( wheelEvent->modifiers(), args[3] );
}
break;
case QEvent::Resize:
{
QResizeEvent* resizeEvent = static_cast<QResizeEvent*>( event );
// extract size (width and height) and oldSize (width and height)
const QSize& size = resizeEvent->size();
const QSize& oldSize = resizeEvent->oldSize();
args[0].set( size.width() );
args[1].set( size.height() );
args[2].set( oldSize.width() );
args[3].set( oldSize.height() );
}
break;
default:
// Close, Show and Hide require no arguments
return;
}
}
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 PopupItem::eventFilter( QObject *object, QEvent *e )
{
MarbleWidget *widget = dynamic_cast<MarbleWidget*> ( object );
if ( !widget ) {
return BillboardGraphicsItem::eventFilter( object, e );
}
if ( e->type() == QEvent::MouseButtonDblClick
|| e->type() == QEvent::MouseMove
|| e->type() == QEvent::MouseButtonPress
|| e->type() == QEvent::MouseButtonRelease )
{
// Mouse events are forwarded to the underlying widget
QMouseEvent *event = static_cast<QMouseEvent*> ( e );
QPoint const shiftedPos = transform( event->pos() );
bool const forcedMouseRelease = m_needMouseRelease && e->type() == QEvent::MouseButtonRelease;
if ( !shiftedPos.isNull() || forcedMouseRelease ) {
if ( !m_needMouseRelease && e->type() == QEvent::MouseButtonPress ) {
m_needMouseRelease = true;
} else if ( forcedMouseRelease ) {
m_needMouseRelease = false;
}
widget->setCursor( Qt::ArrowCursor );
// transform to children's coordinates
QMouseEvent shiftedEvent = QMouseEvent( e->type(), shiftedPos,
event->globalPos(), event->button(), event->buttons(),
event->modifiers() );
if ( QApplication::sendEvent( m_webView, &shiftedEvent ) ) {
widget->setCursor( m_webView->cursor() );
emit dirty();
return true;
}
}
} else if ( e->type() == QEvent::Wheel ) {
// Wheel events are forwarded to the underlying widget
QWheelEvent *event = static_cast<QWheelEvent*> ( e );
QPoint const shiftedPos = transform( event->pos() );
if ( !shiftedPos.isNull() ) {
widget->setCursor( Qt::ArrowCursor );
QWheelEvent shiftedEvent = QWheelEvent( shiftedPos,
event->globalPos(), event->delta(), event->buttons(),
event->modifiers() );
if ( QApplication::sendEvent( m_webView, &shiftedEvent ) ) {
widget->setCursor( m_webView->cursor() );
emit dirty();
return true;
}
}
}
return BillboardGraphicsItem::eventFilter( object, e );
}
ToolResponse runWheelEvent (const QWheelEvent& e) {
if (e.orientation () == Qt::Vertical && e.modifiers () == Qt::ShiftModifier) {
if (e.delta () > 0) {
this->radiusEdit.setIntValue ( this->radiusEdit.intValue ()
+ this->radiusEdit.intSingleStep () );
}
else if (e.delta () < 0) {
this->radiusEdit.setIntValue ( this->radiusEdit.intValue ()
- this->radiusEdit.intSingleStep () );
}
}
return ToolResponse::Redraw;
}
virtual bool eventFilter( QObject *object, QEvent *event )
{
if ( event->type() == QEvent::Wheel )
{
QWheelEvent *we = ( QWheelEvent * )event;
QWheelEvent wheelEvent( QPoint( 5, 5 ), we->delta(),
we->buttons(), we->modifiers(),
we->orientation() );
QApplication::sendEvent( this, &wheelEvent );
return true;
}
return QwtWheel::eventFilter( object, event );
}
bool PicFlowView::viewportEvent ( QEvent * event )
{
if ( event->type() == QEvent::ToolTip )
{
event->ignore();
return true;
}
else if ( event->type() == QEvent::Wheel )
{
QWheelEvent *wEvent = static_cast<QWheelEvent *>(event);
if( wEvent->modifiers() & Qt::ControlModifier ) {
event->ignore();
return true;
}
}
return QAbstractItemView::viewportEvent( event );
}
void WebView::mouseWheelTimerFired()
{
pMouseWheelTimer_->stop();
if (mouseWheelEvents_.empty())
return;
int totalDelta = 0;
for (int i = 0; i < mouseWheelEvents_.length(); i++)
{
totalDelta += mouseWheelEvents_.at(i).delta();
}
QWheelEvent event = mouseWheelEvents_.last();
mouseWheelEvents_.clear();
while (totalDelta != 0)
{
// If the absolute delta value exceeds 5000, Ace editor
// goes into a super fine granularity mode that we need
// to avoid
const int MAX_ABS_DELTA_VALUE = 5000;
int thisDelta = totalDelta;
if (thisDelta > MAX_ABS_DELTA_VALUE)
{
thisDelta = MAX_ABS_DELTA_VALUE;
}
else if (thisDelta < -MAX_ABS_DELTA_VALUE)
{
thisDelta = -MAX_ABS_DELTA_VALUE;
}
totalDelta -= thisDelta;
QWheelEvent totalEvent(event.pos(),
event.globalPos(),
thisDelta,
event.buttons(),
event.modifiers(),
event.orientation());
this->QWebView::wheelEvent(&totalEvent);
}
}
bool
ArtistInfoWidget::eventFilter( QObject* obj, QEvent* event )
{
if ( event->type() == QEvent::Wheel )
{
QWheelEvent* we = static_cast<QWheelEvent*>( event );
QWheelEvent* wheelEvent = new QWheelEvent(
we->pos(),
we->globalPos(),
we->delta(),
we->buttons(),
we->modifiers(),
we->orientation() );
qApp->postEvent( m_area->viewport(), wheelEvent );
event->accept();
return true;
}
else
return QObject::eventFilter( obj, event );
}
void WebView::mouseWheelTimerFired()
{
pMouseWheelTimer_->stop();
if (mouseWheelEvents_.empty())
return;
int totalDelta = 0;
for (int i = 0; i < mouseWheelEvents_.length(); i++)
{
totalDelta += mouseWheelEvents_.at(i).delta();
}
QWheelEvent event = mouseWheelEvents_.last();
mouseWheelEvents_.clear();
QWheelEvent totalEvent(event.pos(),
event.globalPos(),
totalDelta,
event.buttons(),
event.modifiers(),
event.orientation());
this->QWebView::wheelEvent(&totalEvent);
}
//get mouse move events
bool ccMouseCircle::eventFilter(QObject* obj, QEvent* event)
{
//only process events when visible
if (!ccMouseCircle::isVisible())
return false;
if (event->type() == QEvent::MouseMove)
{
if (m_owner)
{
m_owner->redraw(true, false); //redraw 2D graphics
}
}
if (event->type() == QEvent::Wheel)
{
QWheelEvent* wheelEvent = static_cast<QWheelEvent *>(event);
//is control down
if (wheelEvent->modifiers().testFlag(Qt::ControlModifier))
{
//adjust radius
ccMouseCircle::RADIUS -= ccMouseCircle::RADIUS_STEP*(wheelEvent->delta() / 100.0);
//avoid really small radius
if (ccMouseCircle::RADIUS < ccMouseCircle::RADIUS_STEP)
{
ccMouseCircle::RADIUS = ccMouseCircle::RADIUS_STEP;
}
//repaint
m_owner->redraw(true, false);
}
}
return false; //pass event to other listeners
}
bool MainWindow::eventFilter(QObject *obj, QEvent *event)
{
switch(event->type()) {
case QEvent::ToolTip:
{
if (obj != viewer) break;
QHelpEvent* e = static_cast<QHelpEvent*>(event);
if (attributeRect.contains(e->pos())){
QString attribute = viewer->attribute();
if(!attribute.isEmpty())
ToolTip::showText(e->globalPos(),
attribute.prepend("<b>").append("</b>"),
false, 0.8);
}
return true;
}
case QEvent::MouseButtonDblClick:
{
if (obj != viewer && obj != bottomFrame) break;
QMouseEvent *e = static_cast<QMouseEvent*>(event);
if(e->button() & Qt::LeftButton)
changeFullScreen();
return true;
}
case QEvent::ContextMenu:
{
QContextMenuEvent *e = static_cast<QContextMenuEvent*>(event);
showContextMenu(e->globalPos());
return true;
}
case QEvent::Wheel:
{
QWheelEvent *e = static_cast<QWheelEvent *>(event);
// if (e->delta() < 0)
// viewer->nextPic();
// else
// viewer->prePic();
qreal factor = 0.1;
switch(e->modifiers()){
case Qt::ShiftModifier:
factor = e->delta() / qreal(2400); // e->delta() is +120 or -120
break;
case Qt::ControlModifier:
factor = e->delta() / qreal(600);
break;
default:
factor = e->delta() / qreal(1200);
break;
}
viewer->zoomIn(factor, viewer->mapFromGlobal(e->globalPos()));
break;
}
default:
break;
}
return false;
}
bool QtWebKitWebWidget::eventFilter(QObject *object, QEvent *event)
{
if (object == m_webView)
{
if (event->type() == QEvent::Resize)
{
emit progressBarGeometryChanged();
}
else if (event->type() == QEvent::ToolTip && m_isLinkHovered)
{
event->accept();
return true;
}
else if (event->type() == QEvent::MouseButtonPress)
{
QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
if (mouseEvent->button() == Qt::MiddleButton)
{
QWebHitTestResult result = m_webView->page()->mainFrame()->hitTestContent(mouseEvent->pos());
if (result.linkUrl().isValid())
{
emit requestedOpenUrl(result.linkUrl(), true, false);
event->accept();
return true;
}
}
if (mouseEvent->button() == Qt::BackButton)
{
triggerAction(GoBackAction);
event->accept();
return true;
}
if (mouseEvent->button() == Qt::ForwardButton)
{
triggerAction(GoForwardAction);
event->accept();
return true;
}
}
else if (event->type() == QEvent::MouseButtonDblClick && SettingsManager::getValue(QLatin1String("Browser/ShowSelectionContextMenuOnDoubleClick")).toBool())
{
QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
if (mouseEvent && mouseEvent->button() == Qt::LeftButton)
{
QTimer::singleShot(250, this, SLOT(showContextMenu()));
}
}
else if (event->type() == QEvent::Wheel)
{
QWheelEvent *wheelEvent = static_cast<QWheelEvent*>(event);
if (wheelEvent->modifiers() & Qt::CTRL || wheelEvent->buttons() & Qt::LeftButton)
{
setZoom(getZoom() + (wheelEvent->delta() / 16));
event->accept();
return true;
}
}
}
return QObject::eventFilter(object, event);
}
bool ScrSpinBox::eventFilter( QObject* watched, QEvent* event )
{
bool retval = false;
/* Adding this to be sure that the IM* events are processed correctly i.e not intercepted by our KeyPress/Release handlers */
if (event->type() == QEvent::InputMethod)
return QDoubleSpinBox::eventFilter(watched, event);
/*
if ( event->type() == QEvent::KeyPress )
{
QKeyEvent* k = (QKeyEvent*)event;
bool shiftB=k->modifiers() & Qt::ShiftModifier;
bool controlB=k->modifiers() & Qt::ControlModifier;
if (k->key() == Qt::Key_Shift && !controlB)
{
setSingleStep(0.1);
retval = QWidget::event(event);
}
else if (k->key() == Qt::Key_Control && !shiftB)
{
setSingleStep(10.0);
retval = QWidget::event(event);
}
else if ((k->key() == Qt::Key_Control && shiftB) || (k->key() == Qt::Key_Shift && controlB))
{
qDebug("boo1");
setSingleStep(0.01);
retval = QWidget::event(event);
}
else if ((k->key() == Qt::Key_Return) || (k->key() == Qt::Key_Enter) || (k->key() == Qt::Key_Tab))
{
if (!m_tabAdvance)
{
// qDebug() << "eventFilter: interpretText";
QDoubleSpinBox::interpretText();
return true;
}
}
}
else if (event->type() == QEvent::KeyRelease )
{
QKeyEvent* k = (QKeyEvent*)event;
bool shiftB=k->modifiers() & Qt::ShiftModifier;
bool controlB=k->modifiers() & Qt::ControlModifier;
if ((k->key() == Qt::Key_Shift && !controlB) || (k->key() == Qt::Key_Control && !shiftB))
{
setSingleStep(1.0);
retval = QWidget::event(event);
}
else if (k->key() == Qt::Key_Shift && controlB)
{
setSingleStep(10.0);
retval = QWidget::event(event);
}
else if (k->key() == Qt::Key_Control && shiftB)
{
setSingleStep(0.1);
retval = QWidget::event(event);
}
}
*/
if ( event->type() == QEvent::Wheel )
{
//If read only dont spin
if (isReadOnly())
return false;
QWheelEvent* k = (QWheelEvent*)event;
bool shiftB=k->modifiers() & Qt::ShiftModifier;
bool altB=k->modifiers() & Qt::AltModifier;
if (shiftB && !altB)
{
setSingleStep(0.1);
retval=QWidget::event(event);
}
else if (!shiftB && altB)
{
setSingleStep(10.0);
retval=QWidget::event(event);
}
else if (shiftB && altB)
{
setSingleStep(0.01);
retval=QWidget::event(event);
}
else if (!shiftB && !altB)
{
setSingleStep(1.0);
retval=QWidget::event(event);
}
}
else
return QDoubleSpinBox::eventFilter(watched, event);
return retval;
}
bool OffscreenSurface::eventFilter(QObject* originalDestination, QEvent* event) {
if (!filterEnabled(originalDestination, event)) {
return false;
}
#ifdef DEBUG
// Don't intercept our own events, or we enter an infinite recursion
{
auto rootItem = _sharedObject->getRootItem();
auto quickWindow = _sharedObject->getWindow();
QObject* recurseTest = originalDestination;
while (recurseTest) {
Q_ASSERT(recurseTest != rootItem && recurseTest != quickWindow);
recurseTest = recurseTest->parent();
}
}
#endif
switch (event->type()) {
case QEvent::KeyPress:
case QEvent::KeyRelease: {
event->ignore();
if (QCoreApplication::sendEvent(_sharedObject->getWindow(), event)) {
return event->isAccepted();
}
break;
}
case QEvent::Wheel: {
QWheelEvent* wheelEvent = static_cast<QWheelEvent*>(event);
QPointF transformedPos = mapToVirtualScreen(wheelEvent->pos());
QWheelEvent mappedEvent(transformedPos, wheelEvent->delta(), wheelEvent->buttons(), wheelEvent->modifiers(),
wheelEvent->orientation());
mappedEvent.ignore();
if (QCoreApplication::sendEvent(_sharedObject->getWindow(), &mappedEvent)) {
return mappedEvent.isAccepted();
}
break;
}
case QEvent::MouseMove: {
QMouseEvent* mouseEvent = static_cast<QMouseEvent*>(event);
QPointF transformedPos = mapToVirtualScreen(mouseEvent->localPos());
QMouseEvent mappedEvent(mouseEvent->type(), transformedPos, mouseEvent->screenPos(), mouseEvent->button(),
mouseEvent->buttons(), mouseEvent->modifiers());
mappedEvent.ignore();
if (QCoreApplication::sendEvent(_sharedObject->getWindow(), &mappedEvent)) {
return mappedEvent.isAccepted();
}
break;
}
#if defined(Q_OS_ANDROID)
case QEvent::TouchBegin:
case QEvent::TouchUpdate:
case QEvent::TouchEnd: {
QTouchEvent *originalEvent = static_cast<QTouchEvent *>(event);
QEvent::Type fakeMouseEventType = QEvent::None;
Qt::MouseButton fakeMouseButton = Qt::LeftButton;
Qt::MouseButtons fakeMouseButtons = Qt::NoButton;
switch (event->type()) {
case QEvent::TouchBegin:
fakeMouseEventType = QEvent::MouseButtonPress;
fakeMouseButtons = Qt::LeftButton;
break;
case QEvent::TouchUpdate:
fakeMouseEventType = QEvent::MouseMove;
fakeMouseButtons = Qt::LeftButton;
break;
case QEvent::TouchEnd:
fakeMouseEventType = QEvent::MouseButtonRelease;
fakeMouseButtons = Qt::NoButton;
break;
}
// Same case as OffscreenUi.cpp::eventFilter: touch events are always being accepted so we now use mouse events and consider one touch, touchPoints()[0].
QMouseEvent fakeMouseEvent(fakeMouseEventType, originalEvent->touchPoints()[0].pos(), fakeMouseButton, fakeMouseButtons, Qt::NoModifier);
fakeMouseEvent.ignore();
if (QCoreApplication::sendEvent(_sharedObject->getWindow(), &fakeMouseEvent)) {
/*qInfo() << __FUNCTION__ << "sent fake touch event:" << fakeMouseEvent.type()
<< "_quickWindow handled it... accepted:" << fakeMouseEvent.isAccepted();*/
return fakeMouseEvent.isAccepted();
}
break;
}
case QEvent::InputMethod:
case QEvent::InputMethodQuery: {
auto window = getWindow();
if (window && window->activeFocusItem()) {
event->ignore();
if (QCoreApplication::sendEvent(window->activeFocusItem(), event)) {
bool eventAccepted = event->isAccepted();
if (event->type() == QEvent::InputMethodQuery) {
QInputMethodQueryEvent *imqEvent = static_cast<QInputMethodQueryEvent *>(event);
// this block disables the selection cursor in android which appears in
// the top-left corner of the screen
if (imqEvent->queries() & Qt::ImEnabled) {
imqEvent->setValue(Qt::ImEnabled, QVariant(false));
}
}
return eventAccepted;
}
return false;
}
break;
}
#endif
default:
break;
}
return false;
}
bool MainForm::eventFilter(QObject *object, QEvent *event)
{
/*if (object == scrollArea->widget()) {
if (event->type() == QEvent::KeyPress) {
QKeyEvent * e = (QKeyEvent *) event;
if (e->modifiers() & Qt::ControlModifier) {
scrollArea->widget()->setCursor(*resizeCursor);
if ((e->key() == Qt::Key_Plus)||(e->key() == Qt::Key_Equal))
scaleImage(1.05);
else
if (e->key() == Qt::Key_Minus)
scaleImage(0.95);
} else {
scrollArea->widget()->setCursor(QCursor(Qt::ArrowCursor));
}
}
else
if (event->type() == QEvent::KeyRelease) {
scrollArea->widget()->setCursor(QCursor(Qt::ArrowCursor));
}
else
if (event->type() == QEvent::Wheel) {
QWheelEvent * e = (QWheelEvent *) event;
if (e->modifiers() & Qt::ControlModifier) {
scrollArea->widget()->setFocus();
scrollArea->widget()->setCursor(*resizeCursor);
if (e->delta() > 0)
scaleImage(1.05);
else
scaleImage(0.95);
return true;
}
}
} else */
if (object == textEdit) {
if (event->type() == QEvent::KeyPress) {
QKeyEvent *e = (QKeyEvent *) event;
if (e->modifiers() & Qt::ControlModifier) {
if ((e->key() == Qt::Key_Plus) || (e->key() == Qt::Key_Equal)) {
enlargeFont();
return true;
} else if (e->key() == Qt::Key_Minus) {
decreaseFont();
return true;
}
}
} else if (event->type() == QEvent::Wheel) {
QWheelEvent *e = (QWheelEvent *) event;
if (e->modifiers() & Qt::ControlModifier) {
if (e->delta() > 0)
enlargeFont();
else
decreaseFont();
return true;
}
}
}
return QMainWindow::eventFilter(object, event);
}
bool OffscreenSurface::eventFilter(QObject* originalDestination, QEvent* event) {
if (!filterEnabled(originalDestination, event)) {
return false;
}
#ifdef DEBUG
// Don't intercept our own events, or we enter an infinite recursion
{
auto rootItem = _sharedObject->getRootItem();
auto quickWindow = _sharedObject->getWindow();
QObject* recurseTest = originalDestination;
while (recurseTest) {
Q_ASSERT(recurseTest != rootItem && recurseTest != quickWindow);
recurseTest = recurseTest->parent();
}
}
#endif
switch (event->type()) {
case QEvent::KeyPress:
case QEvent::KeyRelease: {
event->ignore();
if (QCoreApplication::sendEvent(_sharedObject->getWindow(), event)) {
return event->isAccepted();
}
break;
}
case QEvent::Wheel: {
QWheelEvent* wheelEvent = static_cast<QWheelEvent*>(event);
QPointF transformedPos = mapToVirtualScreen(wheelEvent->pos());
QWheelEvent mappedEvent(transformedPos, wheelEvent->delta(), wheelEvent->buttons(), wheelEvent->modifiers(),
wheelEvent->orientation());
mappedEvent.ignore();
if (QCoreApplication::sendEvent(_sharedObject->getWindow(), &mappedEvent)) {
return mappedEvent.isAccepted();
}
break;
}
case QEvent::MouseMove: {
QMouseEvent* mouseEvent = static_cast<QMouseEvent*>(event);
QPointF transformedPos = mapToVirtualScreen(mouseEvent->localPos());
QMouseEvent mappedEvent(mouseEvent->type(), transformedPos, mouseEvent->screenPos(), mouseEvent->button(),
mouseEvent->buttons(), mouseEvent->modifiers());
if (event->type() == QEvent::MouseMove) {
// TODO - this line necessary for the QML Tooltop to work (which is not currently being used), but it causes interface to crash on launch on a fresh install
// need to investigate into why this crash is happening.
//_qmlContext->setContextProperty("lastMousePosition", transformedPos);
}
mappedEvent.ignore();
if (QCoreApplication::sendEvent(_sharedObject->getWindow(), &mappedEvent)) {
return mappedEvent.isAccepted();
}
break;
}
default:
break;
}
return false;
}
void QtEventConsumer::handleWheelEvent ( QObject *obj, QEvent *event )
{
// check the object
QWidget *widget = isValidWidget(obj);
if (!widget){
DEBUG(D_CONSUMER,"(QtEventConsumer::handleWheelEvent) No widget to handle");
return;
}
DEBUG(D_CONSUMER,"(QtEventConsumer::handleWheelEvent)");
QWheelEvent *we = dynamic_cast<QWheelEvent*> ( event );
//create the event
QOE::QOE_MouseWheel qoe;
qoe.timestamp(_timer.restart());
completeBasicData(qoe,widget);
qoe.delta(we->delta());
qoe.orientation(we->orientation());
qoe.buttons(we->buttons());
qoe.modifiers(we->modifiers());
///sensitive value
completeSensitiveData(qoe, widget);
//send event if qoe is valid
if (isValidQOE(qoe) && isValidQOEMouse(qoe))
sendNewTestItem(qoe);
}
