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 caf::CeetronPlusNavigation::handleInputEvent(QInputEvent* inputEvent)
{
if (! inputEvent) return false;
bool isEventHandled = false;
switch (inputEvent->type())
{
case QEvent::MouseButtonPress:
{
QMouseEvent * me = static_cast<QMouseEvent*>( inputEvent);
int translatedMousePosX = me->x();
int translatedMousePosY = m_viewer->height() - me->y();
if (me->button() == Qt::RightButton)
{
cvf::HitItemCollection hic;
bool hitSomething = m_viewer->rayPick(me->x(), me->y(), &hic);
if (hitSomething)
{
cvf::Vec3d pointOfInterest = hic.firstItem()->intersectionPoint();
this->setPointOfInterest(pointOfInterest);
}
else
{
initializeRotationCenter();
}
m_trackball->startNavigation(cvf::ManipulatorTrackball::ROTATE, translatedMousePosX, translatedMousePosY);
//m_viewer->setCursor(RICursors::get(RICursors::ROTATE));
m_isNavigating = true;
m_hasMovedMouseDuringNavigation = false;
isEventHandled = true;
}
else if (me->button() == Qt::LeftButton)
{
if (me->modifiers() == Qt::NoModifier)
{
m_trackball->startNavigation(cvf::ManipulatorTrackball::PAN, translatedMousePosX, translatedMousePosY);
m_isNavigating = true;
m_hasMovedMouseDuringNavigation = false;
isEventHandled = true;
}
}
else if (me->button() == Qt::MidButton)
{
if (me->modifiers() == Qt::NoModifier)
{
QMouseEvent* we = static_cast<QMouseEvent*> ( inputEvent);
m_lastPosX = we->x();
m_lastPosY = we->y();
m_zoomRay = m_viewer->mainCamera()->rayFromWindowCoordinates(translatedMousePosX, translatedMousePosY);
m_isNavigating = true;
m_hasMovedMouseDuringNavigation = false;
isEventHandled = true;
m_isZooming = true;
}
}
}
break;
case QEvent::MouseButtonRelease:
{
if (m_isNavigating)
{
QMouseEvent * me = static_cast<QMouseEvent*>( inputEvent);
if (me->button() == Qt::RightButton || me->button() == Qt::LeftButton )
{
m_trackball->endNavigation();
m_isNavigating = false;
if (m_hasMovedMouseDuringNavigation) isEventHandled = true;
m_hasMovedMouseDuringNavigation = false;
}
else if ( me->button() == Qt::MidButton )
{
m_isZooming = false;
m_isNavigating = false;
if (m_hasMovedMouseDuringNavigation) isEventHandled = true;
m_hasMovedMouseDuringNavigation = false;
}
}
}
break;
case QEvent::MouseMove:
{
initializeRotationCenter();
if (m_isRotCenterInitialized)
{
QMouseEvent * me = static_cast<QMouseEvent*>( inputEvent);
int translatedMousePosX = me->x();
int translatedMousePosY = m_viewer->height() - me->y();
if (m_isNavigating)
{
if (m_isZooming)
{
int delta = 3*(m_lastPosY - me->y());
this->zoomAlongRay(m_zoomRay.p(), delta);
m_lastPosX = me->x();
m_lastPosY = me->y();
}
else
{
bool needRedraw = m_trackball->updateNavigation(translatedMousePosX, translatedMousePosY);
if (needRedraw)
{
m_viewer->navigationPolicyUpdate();
}
}
isEventHandled = true;
m_hasMovedMouseDuringNavigation = true;
}
}
}
break;
case QEvent::Wheel:
{
if (inputEvent->modifiers() == Qt::NoModifier)
{
initializeRotationCenter();
if (m_isRotCenterInitialized)
{
QWheelEvent* we = static_cast<QWheelEvent*> ( inputEvent);
int translatedMousePosX = we->x();
int translatedMousePosY = m_viewer->height() - we->y();
int delta = we->delta();
cvf::ref<cvf::Ray> ray;
if (delta < 0)
ray = m_viewer->mainCamera()->rayFromWindowCoordinates(translatedMousePosX, translatedMousePosY);
else
ray = m_viewer->mainCamera()->rayFromWindowCoordinates((int)(1.0*translatedMousePosX), (int)(1.0*translatedMousePosY));
zoomAlongRay(ray.p(), delta);
}
isEventHandled = true;
}
}
break;
}
if (isSupposedToConsumeEvents())
return isEventHandled;
else
return false;
}
bool InputManager::eventFilter( QObject* object, QEvent* event )
{
if( object != m_filteredObj.data() )
return false;
// Emit a signal with the QEvent argument so that others can handle it
emit eventFiltered( event );
switch( event->type() )
{
case QEvent::KeyPress:
{
QKeyEvent* keyEvent = static_cast<QKeyEvent*>( event );
keyboard( 0 )->setButtonState( keyEvent->key(), 1 );
emit keyPressed( keyEvent->key() );
return true;
}
case QEvent::KeyRelease:
{
QKeyEvent* keyEvent = static_cast<QKeyEvent*>( event );
keyboard( 0 )->setButtonState( keyEvent->key(), 0 );
emit keyReleased( keyEvent->key() );
return true;
}
case QEvent::MouseMove:
{
QMouseEvent* mouseEvent = static_cast<QMouseEvent*>( event );
mouse( 0 )->setPosition( mouseEvent->pos( ) );
emit mouseMoved( mouseEvent->pos( ) );
return true;
}
case QEvent::Wheel:
{
QWheelEvent* wheelEvent = static_cast<QWheelEvent*>( event );
mouse( 0 )->setHWheelPosition( wheelEvent->x( ) );
mouse( 0 )->setHWheelPosition( wheelEvent->y( ) );
emit mouseWheeled( wheelEvent->x( ), wheelEvent->y( ) );
return true;
}
case QEvent::MouseButtonPress:
{
if( !m_filteredObj.isNull() && !qobject_cast<QWidget*>( filteredObject() )->hasFocus() )
qobject_cast<QWidget*>( filteredObject() )->setFocus();
QMouseEvent* mouseEvent = static_cast<QMouseEvent*>( event );
mouse( 0 )->setButtonState( mapMouseButton( mouseEvent->button() ), 1 );
emit keyPressed( mapMouseButton( mouseEvent->button() ) );
return true;
}
case QEvent::MouseButtonRelease:
{
QMouseEvent* mouseEvent = static_cast<QMouseEvent*>( event );
mouse( 0 )->setButtonState( mapMouseButton( mouseEvent->button() ), 0 );
emit keyReleased( mapMouseButton( mouseEvent->button() ) );
return true;
}
case QEvent::Gesture:
{
QGestureEvent* gestureEvent = static_cast<QGestureEvent*>( event );
if( QGesture* swipe = gestureEvent->gesture( Qt::SwipeGesture ) )
swipeTriggered( static_cast<QSwipeGesture*>( swipe ) );
else if( QGesture* pan = gestureEvent->gesture( Qt::PanGesture ) )
panTriggered( static_cast<QPanGesture*>( pan ) );
if( QGesture* pinch = gestureEvent->gesture( Qt::PinchGesture ) )
pinchTriggered( static_cast<QPinchGesture*>( pinch ) );
return true;
}
case QEvent::GestureOverride:
{
QGestureEvent* gestureEvent = static_cast<QGestureEvent*>( event );
if( QGesture* swipe = gestureEvent->gesture( Qt::SwipeGesture ) )
swipeTriggered( static_cast<QSwipeGesture*>( swipe ) );
else if( QGesture* pan = gestureEvent->gesture( Qt::PanGesture ) )
panTriggered( static_cast<QPanGesture*>( pan ) );
if( QGesture* pinch = gestureEvent->gesture( Qt::PinchGesture ) )
pinchTriggered( static_cast<QPinchGesture*>( pinch ) );
return true;
}
default:
return false;
}
return false;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool caf::CadNavigation::handleInputEvent(QInputEvent* inputEvent)
{
if (! inputEvent) return false;
bool isEventHandled = false;
switch (inputEvent->type())
{
case QEvent::MouseButtonPress:
{
QMouseEvent * me = static_cast<QMouseEvent*>( inputEvent);
int translatedMousePosX = me->x();
int translatedMousePosY = m_viewer->height() - me->y();
if (me->button() == Qt::MidButton)
{
if (me->modifiers() & Qt::ShiftModifier)
{
m_trackball->startNavigation(cvf::ManipulatorTrackball::PAN, translatedMousePosX, translatedMousePosY);
m_isRotating = true;
isEventHandled = true;
}
else if (me->modifiers() == Qt::NoModifier)
{
cvf::HitItemCollection hic;
bool hitSomething = m_viewer->rayPick( me->x(), me->y(), &hic);
if (hitSomething)
{
cvf::Vec3d pointOfInterest = hic.firstItem()->intersectionPoint();
m_trackball->setRotationPoint(pointOfInterest);
m_pointOfInterest = pointOfInterest;
}
else
{
initializeRotationCenter();
}
m_trackball->startNavigation(cvf::ManipulatorTrackball::ROTATE, translatedMousePosX, translatedMousePosY);
//m_viewer->setCursor(RiuCursors::get(RiuCursors::ROTATE));
m_isRotating = true;
isEventHandled = true;
}
}
}
break;
case QEvent::MouseButtonRelease:
{
if (m_isRotating)
{
QMouseEvent * me = static_cast<QMouseEvent*>( inputEvent);
if (me->button() == Qt::MidButton)
{
m_trackball->endNavigation();
//m_viewer->setCursor(RiuCursors::get(RiuCursors::PICK));
m_isRotating = false;
isEventHandled = true;
}
}
}
break;
case QEvent::MouseMove:
{
initializeRotationCenter();
if (m_isRotCenterInitialized)
{
QMouseEvent * me = static_cast<QMouseEvent*>( inputEvent);
int translatedMousePosX = me->x();
int translatedMousePosY = m_viewer->height() - me->y();
if (m_isRotating)
{
bool needRedraw = m_trackball->updateNavigation(translatedMousePosX, translatedMousePosY);
if (needRedraw)
{
m_viewer->update();
}
isEventHandled = true;
}
}
}
break;
case QEvent::Wheel:
{
if (inputEvent->modifiers() == Qt::NoModifier)
{
initializeRotationCenter();
if (m_isRotCenterInitialized)
{
QWheelEvent* we = static_cast<QWheelEvent*>(inputEvent);
int translatedMousePosX = we->x();
int translatedMousePosY = m_viewer->height() - we->y();
cvf::ref<cvf::Ray> ray;
if (we->delta() > 0)
ray = m_viewer->mainCamera()->rayFromWindowCoordinates(translatedMousePosX, translatedMousePosY);
else
ray = m_viewer->mainCamera()->rayFromWindowCoordinates((int)(1.0*translatedMousePosX), (int)(1.0*translatedMousePosY));
if (ray.notNull() && abs(we->delta()) > 0)
{
cvf::Vec3d pos, vrp, up;
m_viewer->mainCamera()->toLookAt(&pos, &vrp, &up);
double scale = -we->delta()/8.0 * 1.0/150 * (pos - m_pointOfInterest).length();
cvf::Vec3d trans = scale * ray->direction();
cvf::Vec3d newPos = pos + trans;
cvf::Vec3d newVrp = vrp + trans;
m_viewer->mainCamera()->setFromLookAt(newPos,newVrp, up );
m_viewer->update();
}
}
isEventHandled = true;
}
}
break;
}
return isEventHandled;
}
bool QtInputService::eventFilter(QObject *obj, QEvent *event)
{
switch(event->type())
{
case QEvent::KeyPress:
{
QKeyEvent *e = static_cast<QKeyEvent*>(event);
KeyEvent keyEvent;
keyEvent.keyCode = StripModifiersFromKey(e->key());
keyEvent.keyPressCount = 1;
keyEvent.modifiers = e->modifiers();
keyEvent.text = e->text();
keyEvent.sequence = QKeySequence(e->key() | e->modifiers()); ///\todo Track multi-key sequences.
keyEvent.eventType = KeyEvent::KeyPressed;
// keyEvent.otherHeldKeys = heldKeys; ///\todo
keyEvent.handled = false;
current_modifiers_ = e->modifiers(); // local tracking for mouse events
// We only take key events from the main QGraphicsView.
if (obj != qobject_cast<QObject*>(mainView))
return false;
std::map<Qt::Key, KeyPressInformation>::iterator keyRecord = heldKeys.find(keyEvent.keyCode);
if (keyRecord != heldKeys.end())
{
if (e->isAutoRepeat()) // If this is a repeat, track the proper keyPressCount.
{
keyEvent.keyPressCount = ++keyRecord->second.keyPressCount;
keyEvent.sequence = QKeySequence(); // Repeated keys do not trigger keysequences.
}
}
else
{
KeyPressInformation info;
info.keyPressCount = 1;
info.keyState = KeyEvent::KeyPressed;
// info.firstPressTime = now; ///\todo
heldKeys[keyEvent.keyCode] = info;
}
// Queue up the press event for the polling API, independent of whether any Qt widget has keyboard focus.
if (keyEvent.keyPressCount == 1) /// \todo The polling API does not get key repeats at all. Should it?
newKeysPressedQueue.push_back(StripModifiersFromKey(e->key()));
TriggerKeyEvent(keyEvent);
return keyEvent.handled; // If we got true here, need to suppress this event from going to Qt.
}
case QEvent::KeyRelease:
{
// We only take key events from the main window.
if (obj != qobject_cast<QObject*>(mainWindow))
return false;
QKeyEvent *e = static_cast<QKeyEvent *>(event);
// Our input system policy: Key releases on repeated keys are not transmitted. This means
// that the client gets always a sequences like "press (first), press(1st repeat), press(2nd repeat), release",
// instead of "press(first), release, press(1st repeat), release, press(2nd repeat), release".
if (e->isAutoRepeat())
return false;
HeldKeysMap::iterator existingKey = heldKeys.find(StripModifiersFromKey(e->key()));
// If we received a release on an unknown key we haven't received a press for, don't pass it to the scene,
// since we didn't pass the press to the scene either (or we've already passed the release before, so don't
// pass duplicate releases).
if (existingKey == heldKeys.end())
return false;
KeyEvent keyEvent;
keyEvent.keyCode = StripModifiersFromKey(e->key());
keyEvent.keyPressCount = existingKey->second.keyPressCount;
keyEvent.modifiers = e->modifiers();
keyEvent.text = e->text();
keyEvent.eventType = KeyEvent::KeyReleased;
// keyEvent.otherHeldKeys = heldKeys; ///\todo
keyEvent.handled = false;
heldKeys.erase(existingKey);
current_modifiers_ = e->modifiers(); // local tracking for mouse events
// Queue up the release event for the polling API, independent of whether any Qt widget has keyboard focus.
if (keyEvent.keyPressCount == 1) /// \todo The polling API does not get key repeats at all. Should it?
newKeysReleasedQueue.push_back(StripModifiersFromKey(e->key()));
TriggerKeyEvent(keyEvent);
return keyEvent.handled; // Suppress this event from going forward.
}
case QEvent::MouseButtonPress:
case QEvent::MouseButtonRelease:
{
// We only take mouse button press and release events from the main QGraphicsView viewport.
if (obj != qobject_cast<QObject*>(mainView->viewport()))
return false;
QMouseEvent *e = static_cast<QMouseEvent *>(event);
// QGraphicsItem *itemUnderMouse = GetVisibleItemAtCoords(e->x(), e->y());
/*
// Update the flag that tracks whether the inworld scene or QGraphicsScene is grabbing mouse movement.
if (event->type() == QEvent::MouseButtonPress)
sceneMouseCapture = (itemUnderMouse ? QtMouseCapture : SceneMouseCapture);
else // event type == MouseButtonRelease
sceneMouseCapture = NoMouseCapture;
*/
// We always update the global polled input states, independent of whether any the mouse cursor is
// on top of any Qt widget.
if (event->type() == QEvent::MouseButtonPress)
{
heldMouseButtons |= (MouseEvent::MouseButton)e->button();
newMouseButtonsPressedQueue |= (MouseEvent::MouseButton)e->button();
}
else
{
if (lastMouseButtonReleaseTime.msecsTo(QTime::currentTime()) < 300)
{
doubleClickDetected = true;
}
heldMouseButtons &= ~(MouseEvent::MouseButton)e->button();
newMouseButtonsReleasedQueue |= (MouseEvent::MouseButton)e->button();
lastMouseButtonReleaseTime = QTime::currentTime();
}
// If there's a visible QGraphicsItem under the mouse and mouse is not in FPS mode,
// the click's supposed to go there - don't send it at all to inworld scene.
// if (itemUnderMouse && mouseCursorVisible)
// return false;
// The mouse coordinates we receive can come from different widgets, and we are interested only in the coordinates
// in the QGraphicsView client area, so we need to remap them.
QPoint mousePos = MapPointToMainGraphicsView(obj, e->pos());
MouseEvent mouseEvent;
mouseEvent.itemUnderMouse = GetVisibleItemAtCoords(e->x(), e->y());
mouseEvent.origin = mouseEvent.itemUnderMouse ? MouseEvent::PressOriginQtWidget : MouseEvent::PressOriginScene;
if ( !doubleClickDetected)
{
mouseEvent.eventType = (event->type() == QEvent::MouseButtonPress) ? MouseEvent::MousePressed : MouseEvent::MouseReleased;
} else
{
mouseEvent.eventType = MouseEvent::MouseDoubleClicked;
}
mouseEvent.button = (MouseEvent::MouseButton)e->button();
mouseEvent.x = mousePos.x();
mouseEvent.y = mousePos.y();
mouseEvent.z = 0;
mouseEvent.relativeX = mouseEvent.x - lastMouseX;
mouseEvent.relativeY = mouseEvent.y - lastMouseY;
mouseEvent.modifiers = current_modifiers_;
lastMouseX = mouseEvent.x;
lastMouseY = mouseEvent.y;
mouseEvent.globalX = e->globalX();
mouseEvent.globalY = e->globalY();
mouseEvent.otherButtons = e->buttons();
// mouseEvent.heldKeys = heldKeys; ///\todo
mouseEvent.handled = false;
// The mouse press is going to the inworld scene - clear keyboard focus from the QGraphicsScene widget, if any had it so key events also go to inworld scene.
if (event->type() == QEvent::MouseButtonPress && !mouseEvent.itemUnderMouse && mouseCursorVisible)
mainView->scene()->clearFocus();
TriggerMouseEvent(mouseEvent);
return mouseEvent.handled;
}
case QEvent::MouseMove:
{
// If a mouse button is held down, we get the mouse drag events from the viewport widget.
// If a mouse button is not held down, the application main window will get the events.
// Duplicate events are not received, so no need to worry about filtering them here.
QMouseEvent *e = static_cast<QMouseEvent *>(event);
//QGraphicsItem *itemUnderMouse = GetVisibleItemAtCoords(e->x(), e->y());
// If there is a graphicsItem under the mouse, don't pass the move message to the inworld scene, unless the inworld scene has captured it.
// if (mouseCursorVisible)
// if ((itemUnderMouse && sceneMouseCapture != SceneMouseCapture) || sceneMouseCapture == QtMouseCapture)
// return false;
// if (mouseCursorVisible && itemUnderMouse)
// return false;
MouseEvent mouseEvent;
mouseEvent.eventType = MouseEvent::MouseMove;
mouseEvent.button = (MouseEvent::MouseButton)e->button();
mouseEvent.itemUnderMouse = GetVisibleItemAtCoords(e->x(), e->y());
///\todo Set whether the previous press originated over a Qt widget or scene.
mouseEvent.origin = mouseEvent.itemUnderMouse ? MouseEvent::PressOriginQtWidget : MouseEvent::PressOriginScene;
QWidget *sender = qobject_cast<QWidget*>(obj);
assert(sender);
// The mouse coordinates we receive can come from different widgets, and we are interested only in the coordinates
// in the QGraphicsView client area, so we need to remap them.
QPoint mousePos = MapPointToMainGraphicsView(obj, e->pos());
if (mouseCursorVisible)
{
mouseEvent.x = mousePos.x();
mouseEvent.y = mousePos.y();
}
else
{
// If mouse cursor is hidden, we're in relative "crosshair" mode. In this mode,
// the mouse absolute coordinates are restricted to stay in the center of the screen.
mouseEvent.x = mainView->size().width()/2;
mouseEvent.y = mainView->size().height()/2;
}
mouseEvent.z = 0;
mouseEvent.relativeX = mousePos.x() - lastMouseX;
mouseEvent.relativeY = mousePos.y() - lastMouseY;
// If there wasn't any change to the mouse relative coords in FPS mode, ignore this event.
if (!mouseCursorVisible && mouseEvent.relativeX == 0 && mouseEvent.relativeY == 0)
return true;
mouseEvent.globalX = e->globalX(); // Note that these may "jitter" when mouse is in relative movement mode.
mouseEvent.globalY = e->globalY();
mouseEvent.otherButtons = e->buttons();
// mouseEvent.heldKeys = heldKeys; ///\todo
mouseEvent.handled = false;
// Save the absolute coordinates to be able to compute the proper relative movement values in the next
// mouse event.
lastMouseX = mouseEvent.x;
lastMouseY = mouseEvent.y;
TriggerMouseEvent(mouseEvent);
// In relative mouse movement mode, keep the mouse cursor hidden at screen center at all times.
if (!mouseCursorVisible)
{
RecenterMouse();
return true; // In relative mouse movement mode, the QGraphicsScene does not receive mouse movement at all.
}
return mouseEvent.handled;
}
case QEvent::Wheel:
{
// If this event did not originate from the application main window, we are not interested in it.
if (obj != qobject_cast<QObject*>(mainWindow))
return false;
QObject *mv = qobject_cast<QObject*>(mainView);
QObject *mw = qobject_cast<QObject*>(mainWindow);
QWheelEvent *e = static_cast<QWheelEvent *>(event);
// QGraphicsItem *itemUnderMouse = GetVisibleItemAtCoords(e->x(), e->y());
// if (itemUnderMouse)
// return false;
MouseEvent mouseEvent;
mouseEvent.eventType = MouseEvent::MouseScroll;
mouseEvent.itemUnderMouse = GetVisibleItemAtCoords(e->x(), e->y());
mouseEvent.origin = mouseEvent.itemUnderMouse ? MouseEvent::PressOriginQtWidget : MouseEvent::PressOriginScene;
mouseEvent.button = MouseEvent::NoButton;
mouseEvent.otherButtons = e->buttons();
mouseEvent.x = e->x();
mouseEvent.y = e->y();
mouseEvent.z = 0; // Mouse wheel does not have an absolute z position, only relative.
mouseEvent.relativeX = 0;
mouseEvent.relativeY = 0;
mouseEvent.relativeZ = e->delta();
mouseEvent.globalX = e->globalX();
mouseEvent.globalY = e->globalY();
mouseEvent.otherButtons = e->buttons(); ///\todo Can this be trusted?
// mouseEvent.heldKeys = heldKeys; ///\todo
mouseEvent.handled = false;
TriggerMouseEvent(mouseEvent);
return mouseEvent.handled;
}
} // ~switch
return QObject::eventFilter(obj, event);
}
