bool Human::eventFilter( QObject * watched, QEvent * event )
{
chessVisialization::Display* disp = dynamic_cast<chessVisialization::Display*>( watched );
QMouseEvent* mouseEvent = dynamic_cast< QMouseEvent* >( event );
if ( mouseEvent )
{
if ( mouseEvent->type() == QEvent::MouseButtonPress )
{
if ( mouseEvent->button() == Qt::LeftButton )
{
emit signalCellPressed( _cellOverCursor.first, _cellOverCursor.second );
//disp->boardChanged();
return true;
}
}
else if ( mouseEvent->type() == QEvent::MouseMove )
{
if ( mouseEvent->button() == Qt::NoButton )
{
//! Update cursor's position
QRect r( 0, 0, disp->displayImage().width(), disp->displayImage().height() );
QPoint p = mouseEvent->pos();
if ( r.contains( p ) )
{
_cellOverCursor.first = p.x() / ( r.width() / HORIZONTAL_SIZE );
_cellOverCursor.second = p.y() / ( r.height() / VERTICAL_SIZE );
emit signalEventFiltered();
return true;
}
}
}
}
return false;
}
bool AppInit::eventFilter(QObject *obj, QEvent *evt)
{
QWidget *w = (QWidget *)obj;
if (!w->property("CanMove").toBool()) {
return QObject::eventFilter(obj, evt);
}
QMouseEvent *event = static_cast<QMouseEvent *>(evt);
if (event->type() == QEvent::MouseButtonPress) {
if (event->button() == Qt::LeftButton) {
mousePressed = true;
mousePoint = event->globalPos() - w->pos();
return true;
}
} else if (event->type() == QEvent::MouseButtonRelease) {
mousePressed = false;
return true;
} else if (event->type() == QEvent::MouseMove) {
if (mousePressed && (event->buttons() && Qt::LeftButton)) {
w->move(event->globalPos() - mousePoint);
return true;
}
}
return QObject::eventFilter(obj, evt);
}
bool KisToolProxy::forwardEvent(ActionState state, KisTool::ToolAction action, QEvent *event, QEvent *originalEvent, QTabletEvent *lastTabletEvent, const QPoint &canvasOriginWorkaround)
{
bool retval = true;
QTabletEvent *tabletEvent = dynamic_cast<QTabletEvent*>(event);
QTouchEvent *touchEvent = dynamic_cast<QTouchEvent*>(event);
QMouseEvent *mouseEvent = dynamic_cast<QMouseEvent*>(event);
if (tabletEvent) {
QPointF docPoint = tabletToDocument(tabletEvent->hiResGlobalPos(), canvasOriginWorkaround);
tabletEvent->accept();
this->tabletEvent(tabletEvent, docPoint);
forwardToTool(state, action, tabletEvent, docPoint);
retval = tabletEvent->isAccepted();
} else if (touchEvent) {
if (state == END && touchEvent->type() != QEvent::TouchEnd) {
//Fake a touch end if we are "upgrading" a single-touch gesture to a multi-touch gesture.
QTouchEvent fakeEvent(QEvent::TouchEnd, touchEvent->deviceType(), touchEvent->modifiers(), touchEvent->touchPointStates(), touchEvent->touchPoints());
this->touchEvent(&fakeEvent);
} else {
this->touchEvent(touchEvent);
}
} else if (mouseEvent) {
if (lastTabletEvent) {
QPointF docPoint = tabletToDocument(lastTabletEvent->hiResGlobalPos(), canvasOriginWorkaround);
lastTabletEvent->accept();
this->tabletEvent(lastTabletEvent, docPoint);
forwardToTool(state, action, lastTabletEvent, docPoint);
retval = lastTabletEvent->isAccepted();
} else {
QPointF docPoint = widgetToDocument(mouseEvent->posF());
mouseEvent->accept();
if (mouseEvent->type() == QEvent::MouseButtonPress) {
mousePressEvent(mouseEvent, docPoint);
} else if (mouseEvent->type() == QEvent::MouseButtonDblClick) {
mouseDoubleClickEvent(mouseEvent, docPoint);
} else if (mouseEvent->type() == QEvent::MouseButtonRelease) {
mouseReleaseEvent(mouseEvent, docPoint);
} else if (mouseEvent->type() == QEvent::MouseMove) {
mouseMoveEvent(mouseEvent, docPoint);
}
forwardToTool(state, action, originalEvent, docPoint);
retval = mouseEvent->isAccepted();
}
} else if(event->type() == QEvent::KeyPress) {
QKeyEvent* kevent = static_cast<QKeyEvent*>(event);
keyPressEvent(kevent);
} else if(event->type() == QEvent::KeyRelease) {
QKeyEvent* kevent = static_cast<QKeyEvent*>(event);
keyReleaseEvent(kevent);
}
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());
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 QEglFSCursor::pointerEvent(const QMouseEvent &event)
{
if (event.type() != QEvent::MouseMove)
return;
const QRect oldCursorRect = cursorRect();
m_cursor.pos = event.pos();
update(oldCursorRect | cursorRect());
}
bool RobotManualPlacementLayer::handleEvent(QObject *, QEvent *e)
{
if (!mVisible || !mReferenceCoords.isValid())
return false;
if (e->type() == QEvent::MouseButtonPress
|| e->type() == QEvent::MouseMove
|| e->type() == QEvent::MouseButtonRelease)
{
QMouseEvent *event = static_cast<QMouseEvent*>(e);
qreal mouseLon, mouseLat;
bool isAboveMap = mMap->geoCoordinates(event->x(), event->y(),
mouseLon, mouseLat, GeoDataCoordinates::Radian);
if (!isAboveMap)
{
mMouseCoords = GeoDataCoordinates();
mTracking = false;
return false;
}
bool consumed = false;
if (event->type() == QEvent::MouseButtonPress && event->button() == Qt::LeftButton)
{
mTracking = true;
consumed = true;
}
if (mTracking)
{
mMouseCoords.setLongitude(mouseLon);
mMouseCoords.setLatitude(mouseLat);
emit orientationUpdate(MapLibraryHelpers::transformCoords(mMouseCoords));
}
if (event->type() == QEvent::MouseButtonRelease && event->button() == Qt::LeftButton)
{
mMouseCoords = GeoDataCoordinates();
mTracking = false;
return true;
}
return consumed;
}
return false;
}
void QEGLPlatformCursor::pointerEvent(const QMouseEvent &event)
{
if (event.type() != QEvent::MouseMove)
return;
const QRect oldCursorRect = cursorRect();
m_cursor.pos = event.screenPos().toPoint();
update(oldCursorRect | cursorRect());
m_screen->handleCursorMove(m_cursor.pos);
}
void wl_input_wait(struct wl_input_event *ev, int sleep)
{
WikiDisplay *display = window->display;
QWaitCondition *w = display->waitCondition;
QMutex mutex;
ev->type = -1;
do {
mutex.lock();
if (sleep && display->keyEventQueue->isEmpty() && display->mouseEventQueue->isEmpty()) {
w->wait(&mutex);
}
if (!display->keyEventQueue->isEmpty()) {
display->keyQueueMutex->lock();
QKeyEvent keyEvent = display->keyEventQueue->dequeue();
display->keyQueueMutex->unlock();
ev->type = WL_INPUT_EV_TYPE_KEYBOARD;
/* determine key type */
if (keyEvent.key() == Qt::Key_Down) {
ev->key_event.keycode = WL_INPUT_KEY_CURSOR_DOWN;
ev->type = WL_INPUT_EV_TYPE_CURSOR;
} else if (keyEvent.key() == Qt::Key_Up) {
ev->key_event.keycode = WL_INPUT_KEY_CURSOR_UP;
ev->type = WL_INPUT_EV_TYPE_CURSOR;
} else if (keyEvent.text().length() > 0) {
ev->key_event.keycode = keyEvent.text().at(0).unicode();
} else {
ev->key_event.keycode = keyEvent.key();
}
switch (keyEvent.type()) {
case QEvent::KeyPress:
ev->key_event.value = 1;
break;
case QEvent::KeyRelease:
ev->key_event.value = 0;
break;
default:
break;
}
}
if (!display->mouseEventQueue->isEmpty()) {
display->mouseQueueMutex->lock();
QMouseEvent mouseEvent = display->mouseEventQueue->dequeue();
display->mouseQueueMutex->unlock();
ev->type = WL_INPUT_EV_TYPE_TOUCH;
ev->touch_event.x = mouseEvent.x();
ev->touch_event.y = mouseEvent.y();
ev->touch_event.value = (mouseEvent.type() == QEvent::MouseButtonPress) ? 1 : 0;
}
mutex.unlock();
} while (ev->type == -1 && sleep);
}
bool GraphLabel::eventFilter(QObject *target, QEvent* e)
{
if (target == text || target == image) {
QMouseEvent *me = static_cast<QMouseEvent*>(e);
CHECK(me != NULL, false);
if(me->type() == QEvent::MouseButtonPress && me->button() == Qt::LeftButton) {
emit si_onHintDeleted(this);
return true;
}
}
return QObject::eventFilter(target, e);
}
void EWAUserAction::execute( QWebView *webViewPtr ) const
{
if( !webViewPtr )
{
return;
}
//EWAWebView *pEwaWebView = qobject_cast<EWAWebView*>( webViewPtr );
//bool bNeedSetFocus = false;
QEvent *pEventCopy = 0;
if( isMouseEvent( m_pEvent->type() ) )
{
QMouseEvent *pSrcMouseEvent = static_cast<QMouseEvent *>( m_pEvent );
QPoint clickCoords = pSrcMouseEvent->pos();
pEventCopy = new QMouseEvent(
pSrcMouseEvent->type(),
clickCoords,
webViewPtr->mapToGlobal( clickCoords ),
pSrcMouseEvent->button(),
pSrcMouseEvent->buttons(),
pSrcMouseEvent->modifiers() );
}
else if( isKeyEvent( m_pEvent->type() ) )
{
QKeyEvent *pSrcKeyEvent = static_cast<QKeyEvent*>( m_pEvent );
pEventCopy = new QKeyEvent(
pSrcKeyEvent->type(),
pSrcKeyEvent->key(),
pSrcKeyEvent->modifiers(),
pSrcKeyEvent->text(),
pSrcKeyEvent->isAutoRepeat(),
pSrcKeyEvent->count() );
}
if( pEventCopy )
{
QSize dstSz = getWebViewSize();
if( webViewPtr->page()->preferredContentsSize() != dstSz )
{
webViewPtr->page()->setPreferredContentsSize( dstSz );
}
EWAApplication::postEvent( webViewPtr, pEventCopy );
}
}
/*!
* Method to emulate QGraphicsView::ScrollHandDrag option for both mouse buttons
* Therefore, user can navigate using right mouse button
*/
bool BaseViewer::scrollOnMouse(QEvent *e)
{
// !!! DO NOT SCROLL ON RIGHT BUTTON BECAUSE OF CONTEXT MENU
QMouseEvent * mouseEvent = static_cast<QMouseEvent*>(e);
if (mouseEvent)
{
if (mouseEvent->type() == QEvent::MouseButtonPress &&
mouseEvent->button() == Qt::LeftButton)
{
_handScrolling = true;
_ui->_view->viewport()->setCursor(Qt::ClosedHandCursor);
_lastMouseEvent = storeMouseEvent(mouseEvent);
return true;
}
else if (mouseEvent->type() == QEvent::MouseMove)
{
if (_handScrolling)
{
QScrollBar *hBar = _ui->_view->horizontalScrollBar();
QScrollBar *vBar = _ui->_view->verticalScrollBar();
QPoint delta = mouseEvent->pos() - _lastMouseEvent.pos();
hBar->setValue(hBar->value() + (_ui->_view->isRightToLeft() ? delta.x() : -delta.x()));
vBar->setValue(vBar->value() - delta.y());
_lastMouseEvent = storeMouseEvent(mouseEvent);
return true;
}
}
else if (mouseEvent->type() == QEvent::MouseButtonRelease &&
mouseEvent->button() == Qt::LeftButton)
{
_handScrolling = false;
_ui->_view->viewport()->setCursor(_cursor);
centerOnAtZoom(_zoomLevel);
return true;
}
}
return false;
}
bool CursorWindow::handleMouseEvent(QEvent *ev)
{
bool handledEvent = false;
static int inhere=0;
if ( !inhere ) {
inhere++;
if ( m_view ) {
if ( ev->type() >= QEvent::MouseButtonPress && ev->type() <= QEvent::MouseMove ) {
QMouseEvent *e = (QMouseEvent*)ev;
QPoint gp = e->globalPos();
QPoint vp = m_view->mapFromGlobal(gp);
QPoint sp = skin->mapFromGlobal(gp);
if ( e->type() == QEvent::MouseButtonPress || e->type() == QEvent::MouseButtonDblClick ) {
if ( m_view->rect().contains(vp) )
mouseRecipient = m_view;
else if ( skin->parentWidget()->geometry().contains(gp) )
mouseRecipient = skin;
else
mouseRecipient = 0;
}
if ( mouseRecipient ) {
setPos(gp);
QMouseEvent me(e->type(),mouseRecipient==skin ? sp : vp,gp,e->button(),e->buttons(),e->modifiers());
QApplication::sendEvent(mouseRecipient, &me);
} else if ( !skin->parentWidget()->geometry().contains(gp) ) {
hide();
} else {
setPos(gp);
}
if ( e->type() == QEvent::MouseButtonRelease )
mouseRecipient = 0;
handledEvent = true;
}
}
inhere--;
}
return handledEvent;
}
void UXInfoPlugin::processEvent(QObject *obj, QEvent *e)
{
QMouseEvent *mouseEvent = dynamic_cast<QMouseEvent*>(e);
QWidget *widget = dynamic_cast<QWidget*>(obj);
QPoint pos;
if (mouseEvent && widget && mouseEvent->type() == QMouseEvent::MouseButtonPress) {
pos = widget->pos();
for (; widget; widget = dynamic_cast<QWidget*>(widget->parent())) {
pos += widget->pos();
}
UXInfo::reportMouseClick(mouseEvent->pos() + pos);
}
}
void EWAUserAction::setClickCoords( const QPoint& pnt )
{
QMouseEvent *pOldEvent = static_cast<QMouseEvent *>( m_pEvent );
if( pOldEvent )
{
QMouseEvent *pNewEvent = new QMouseEvent( pOldEvent->type()
,pnt
,pOldEvent->button()
,pOldEvent->buttons()
,pOldEvent->modifiers() );
delete m_pEvent;
m_pEvent = pNewEvent;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RiuSummaryQwtPlot::eventFilter(QObject* watched, QEvent* event)
{
if(watched == canvas())
{
QMouseEvent* mouseEvent = dynamic_cast<QMouseEvent*>(event);
if(mouseEvent)
{
if(mouseEvent->button() == Qt::LeftButton && mouseEvent->type() == QMouseEvent::MouseButtonRelease)
{
selectClosestCurve(mouseEvent->pos());
}
}
}
return QwtPlot::eventFilter(watched, event);
}
bool TabletWidget::eventFilter(QObject *, QEvent *ev)
{
switch (ev->type()) {
case QEvent::TabletEnterProximity:
case QEvent::TabletLeaveProximity:
case QEvent::TabletMove:
case QEvent::TabletPress:
case QEvent::TabletRelease:
{
QTabletEvent *event = static_cast<QTabletEvent*>(ev);
mType = event->type();
mPos = event->pos();
mGPos = event->globalPos();
mHiResGlobalPos = event->hiResGlobalPos();
mDev = event->device();
mPointerType = event->pointerType();
mUnique = event->uniqueId();
mXT = event->xTilt();
mYT = event->yTilt();
mZ = event->z();
mPress = event->pressure();
mTangential = event->tangentialPressure();
mRot = event->rotation();
mButton = event->button();
mButtons = event->buttons();
if (isVisible())
update();
break;
}
case QEvent::MouseMove:
if (mMouseToo) {
resetAttributes();
QMouseEvent *event = static_cast<QMouseEvent*>(ev);
mType = event->type();
mPos = event->pos();
mGPos = event->globalPos();
}
default:
break;
}
return false;
}
//====================================
// Event filter for application...
//------------------------------------
bool XInputEvent::eventFilter ( QObject*, QEvent* event ) {
QMouseEvent* mouse = (QMouseEvent*)event;
QWheelEvent* wheel = (QWheelEvent*)event;
if ((! mouse) && (! wheel)) {
return (false);
}
switch (mouse->type()) {
case QEvent::MouseButtonDblClick:
timer->stop();
doubleClick = TRUE;
mouseReleased = FALSE;
mBtn = mouse->button();
doubleClickEvent (mBtn);
break;
case QEvent::MouseButtonPress:
mBtn = mouse->button();
pressEvent (mBtn);
mouseReleased = FALSE;
timer->start ( 300, TRUE );
doubleClick = FALSE;
break;
case QEvent::MouseButtonRelease:
if (! doubleClick) {
mouseReleased = TRUE;
mBtn = mouse->button();
releaseEvent (mBtn);
}
break;
case QEvent::Wheel:
wheelEvent ( wheel->delta()/WHEEL_DELTA );
break;
case QEvent::MouseMove:
moveEvent (mouse->x(),mouse->y());
break;
default:
break;
}
return (false);
}
bool BehaviorNotification::eventFilter(QObject* object, QEvent* event)
{
if (object == ui->label_widget_)
{
QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
if(mouseEvent->button() == 1 && mouseEvent->type() == QEvent::MouseButtonPress)
{
if(ui->confirm_button_->isVisible())
{
ui->confirmation_widget_->setVisible(false);
}
else
{
ui->confirmation_widget_->setVisible(true);
}
return true;
}
}
//propagate
return QWidget::eventFilter(object, event);
}
bool QmitkDoseColorDelegate::editorEvent(QEvent *event, QAbstractItemModel *model, const QStyleOptionViewItem &option,
const QModelIndex &index)
{
Q_ASSERT(event);
Q_ASSERT(model);
// make sure that the item is checkable
Qt::ItemFlags flags = model->flags(index);
if (!(flags & Qt::ItemIsEditable) || !(flags & Qt::ItemIsEnabled))
{
return false;
}
// make sure that we have the right event type
QMouseEvent* mouseEvent = dynamic_cast<QMouseEvent*>(event);
if (!mouseEvent)
{
return false;
}
else
{
if (mouseEvent->type() != QEvent::MouseButtonRelease || mouseEvent->button() != Qt::LeftButton)
{
return false;
}
}
QColor oldcolor = index.data(Qt::EditRole).value<QColor>();
QColor newColor = QColorDialog::getColor(oldcolor, NULL);
if (newColor.isValid())
{
return model->setData(index, QVariant(newColor), Qt::EditRole);
}
return false;
};
bool QMeeGoOverlayWidget::eventFilter(QObject *, QEvent *event)
{
if (event->spontaneous() == false)
return false;
switch(event->type()) {
case QEvent::MouseButtonPress:
case QEvent::MouseButtonRelease:
{
QMouseEvent *e = static_cast <QMouseEvent *>(event);
QMouseEvent newEvent = QMouseEvent(e->type(),
convertPoint(e->pos()),
convertPoint(e->globalPos()),
e->button(),
e->buttons(),
e->modifiers());
QCoreApplication::sendEvent(this, &newEvent);
return true;
}
default:
return false;
}
}
bool CustomerView::eventFilter(QObject* label, QEvent* vt)
{
if(label==m_ui->m_scrollAreaVisual)
{
/*if(vt->type() == QEvent::Resize)
{
resizeLabel();
}*/
}
else if((label == m_label)&&
((vt->type() == QEvent::MouseButtonPress)||(vt->type() == QEvent::MouseButtonRelease)||(vt->type() == QEvent::MouseMove)))
{
QMouseEvent* evt = static_cast<QMouseEvent*>(vt);
QPoint posOnLabel= evt->pos();
int w = m_label->geometry().width();
int h = m_label->geometry().height();
qreal ratioW = static_cast<qreal>(m_window->width())/ static_cast<qreal>(w);
qreal ratioH = static_cast<qreal>(m_window->height())/static_cast<qreal>(h);
qreal x = (posOnLabel.x()) * ratioW;
qreal y = (posOnLabel.y()) * ratioH;
QPointF posOnQML(x,y);
QMouseEvent* event = new QMouseEvent(evt->type(),posOnQML.toPoint(),evt->button(),evt->buttons(),evt->modifiers());
QObject* root = m_engine->rootObjects().first();
//QCoreApplication::sendEvent(m_window,event);
QCoreApplication::sendEvent(root,event);
//m_window->sendEvent(m_window->contentItem(),event);
return true;
}
return false;
}
bool QISplitter::eventFilter(QObject *pWatched, QEvent *pEvent)
{
if (pWatched == handle(1))
{
switch (pEvent->type())
{
case QEvent::MouseButtonDblClick:
restoreState(m_baseState);
break;
default:
break;
}
}
#ifdef Q_WS_MAC
/* Special handling on the Mac. Cause there the horizontal handle is only 1
* pixel wide, its hard to catch. Therefor we make some invisible area
* around the handle and forwarding the mouse events to the handle, if the
* user presses the left mouse button. */
else if ( m_type == Native
&& orientation() == Qt::Horizontal
&& count() > 1
&& qApp->activeWindow() == window())
{
switch (pEvent->type())
{
case QEvent::MouseButtonPress:
case QEvent::MouseMove:
{
const int margin = 3;
QMouseEvent *pMouseEvent = static_cast<QMouseEvent*>(pEvent);
for (int i=1; i < count(); ++i)
{
QWidget *pHandle = handle(i);
if ( pHandle
&& pHandle != pWatched)
{
/* Create new mouse event with translated mouse positions. */
QMouseEvent newME(pMouseEvent->type(),
pHandle->mapFromGlobal(pMouseEvent->globalPos()),
pMouseEvent->button(),
pMouseEvent->buttons(),
pMouseEvent->modifiers());
/* Check if we hit the handle */
bool fMarginHit = QRect(pHandle->mapToGlobal(QPoint(0, 0)), pHandle->size()).adjusted(-margin, 0, margin, 0).contains(pMouseEvent->globalPos());
if (pEvent->type() == QEvent::MouseButtonPress)
{
/* If we have a handle position hit and the left
* button is pressed, start the grabbing. */
if ( fMarginHit
&& pMouseEvent->buttons().testFlag(Qt::LeftButton))
{
m_fHandleGrabbed = true;
setCursor(Qt::SplitHCursor);
qApp->postEvent(pHandle, new QMouseEvent(newME));
return true;
}
}
else if(pEvent->type() == QEvent::MouseMove)
{
/* If we are in the near of the handle or currently
* dragging, forward the mouse event. */
if ( fMarginHit
|| ( m_fHandleGrabbed
&& pMouseEvent->buttons().testFlag(Qt::LeftButton)))
{
setCursor(Qt::SplitHCursor);
qApp->postEvent(pHandle, new QMouseEvent(newME));
return true;
}
else
{
/* If not, reset the state. */
m_fHandleGrabbed = false;
setCursor(Qt::ArrowCursor);
}
}
}
}
break;
}
case QEvent::WindowDeactivate:
case QEvent::MouseButtonRelease:
{
m_fHandleGrabbed = false;
setCursor(Qt::ArrowCursor);
break;
}
default:
break;
}
}
#endif /* Q_WS_MAC */
return QSplitter::eventFilter(pWatched, pEvent);
}
/// <summary>
/// Event filter for taking special action on double click events.
/// </summary>
/// <param name="o">The object</param>
/// <param name="e">The eevent</param>
/// <returns>false</returns>
bool SpinBox::eventFilter(QObject* o, QEvent* e)
{
QMouseEvent* me = dynamic_cast<QMouseEvent*>(e);
if (isEnabled() &&
me &&
me->type() == QMouseEvent::MouseButtonPress &&
me->button() == Qt::RightButton)
{
m_MouseDownPoint = m_MouseMovePoint = me->pos();
StartTimer();
//qDebug() << "Right mouse down";
// QPoint pt;
//
// if (QMouseEvent* me = (QMouseEvent*)e)
// pt = me->localPos().toPoint();
//
// int pos = lineEdit()->cursorPositionAt(pt);
//
// if (lineEdit()->selectedText() != "")
// {
// lineEdit()->deselect();
// lineEdit()->setCursorPosition(pos);
// return true;
// }
// else if (m_Select)
// {
// lineEdit()->setCursorPosition(pos);
// selectAll();
// m_Select = false;
// return true;
// }
}
else if (isEnabled() &&
me &&
me->type() == QMouseEvent::MouseButtonRelease &&
me->button() == Qt::RightButton)
{
StopTimer();
m_MouseDownPoint = m_MouseMovePoint = me->pos();
//qDebug() << "Right mouse up";
}
else if (isEnabled() &&
me &&
me->type() == QMouseEvent::MouseMove &&
QGuiApplication::mouseButtons() & Qt::RightButton)
{
m_MouseMovePoint = me->pos();
qDebug() << "Mouse move while right down. Pt = " << me->pos() << ", global: " << mapToGlobal(me->pos());
}
else if (m_DoubleClick && e->type() == QMouseEvent::MouseButtonDblClick && isEnabled())
{
if (value() == 0)
setValue(m_DoubleClickZero);
else
setValue(m_DoubleClickNonZero);
}
else
{
if (e->type() == QEvent::Wheel)
{
//Take special action for shift to reduce the scroll amount. Control already
//increases it automatically.
if (QWheelEvent* wev = dynamic_cast<QWheelEvent*>(e))
{
Qt::KeyboardModifiers mod = wev->modifiers();
if (mod.testFlag(Qt::ShiftModifier))
setSingleStep(m_SmallStep);
else
setSingleStep(m_Step);
}
}
}
return QSpinBox::eventFilter(o, e);
}
//事件过滤器, 现在用于响应标题栏的鼠标事件,目的在于拖动窗口和双击窗口最大化的功能
bool WidgetMain::eventFilter(QObject *target, QEvent *event)
{
if(target == widgetMove
|| target == labelLogo
|| pushButtonInfor == target)
{
QMouseEvent *mouseEvent = static_cast<QMouseEvent *>(event);
switch(event->type())
{
case QEvent::MouseButtonPress:
{
if(Qt::LeftButton == mouseEvent->button())
{
//获取屏幕左上角坐标与软件左上角坐标的偏移
offset_ = mouseEvent->globalPos() - frameGeometry().topLeft();
return true;
}
else
{
return false;
}
break;
}
case QEvent::MouseMove:
{
if (Qt::LeftButton == mouseEvent->buttons() )
{
move(mouseEvent->globalPos() - offset_);
return true;
}
else
{
return false;
}
break;
}
case QEvent::MouseButtonDblClick:
{
if (Qt::LeftButton == mouseEvent->button() && mouseEvent->y() <= widgetMove->height())
{
if(windowState() != Qt::WindowFullScreen)
{
this->setWindowState(Qt::WindowFullScreen);
}
else
{
this->setWindowState(Qt::WindowNoState);
}
return true;
}
else
{
return false;
}
break;
}
default:
{
//...
break;
}
return true;
}
}
else if(pDustbin_ == target)
{
if(QEvent::MouseButtonPress == event->type())
{
//在这里进行删除处理
if(FOCUS_GROUP == type_)
{
if(!groupName_.isEmpty())
{
Q_EMIT signalDeleteGroup(groupName_);
clearDustbinData();
}
}
else if(FOCUS_LINE == type_)
{
if(pFlowLine_
&& !startName_.isEmpty()
&& !endName_.isEmpty())
{
pFlowLine_->deleteLine();
clearDustbinData();
}
}
else
{
qDebug() << "没有要删除的类型, 哪里赋值错了么?" << type_;
}
event->accept();
return true;
}
else
{
event->ignore();
return false;
}
}
else if(widgetLeft == target)
{
if(QEvent::Resize == event->type()
|| QEvent::Show)
{
//这里move
if(NULL != pSerialSetting_)
{
pSerialSetting_->move(widgetLeft->width()+5, widgetTitle->height()+3);
}
if(NULL != pFunctionArea_)
{
pFunctionArea_->move(splitter->sizes().at(0) + (widgetOption->width()-pFunctionArea_->width())/2, 31);
}
event->accept();
return true;
}
else
{
event->ignore();
return false;
}
}
else if(pBackStart_ == target)
{
QMouseEvent *mouseEvent = static_cast<QMouseEvent *>(event);
if(QEvent::MouseButtonPress == mouseEvent->type())
{
qDebug() << "啊被按住了~~";
pEditScene_->backStart();
event->accept();
pBackStart_->hide();
return true;
}
return QWidget::eventFilter(target, event);
}
else
{
return QWidget::eventFilter(target, event);
}
}
bool QWidgetResizeHandler::eventFilter(QObject *o, QEvent *ee)
{
if (!isActive()
|| (ee->type() != QEvent::MouseButtonPress
&& ee->type() != QEvent::MouseButtonRelease
&& ee->type() != QEvent::MouseMove
&& ee->type() != QEvent::KeyPress
&& ee->type() != QEvent::ShortcutOverride)
)
return false;
Q_ASSERT(o == widget);
QWidget *w = widget;
if (QApplication::activePopupWidget()) {
if (buttonDown && ee->type() == QEvent::MouseButtonRelease)
buttonDown = false;
return false;
}
QMouseEvent *e = (QMouseEvent*)ee;
switch (e->type()) {
case QEvent::MouseButtonPress: {
if (w->isMaximized())
break;
if (!widget->rect().contains(widget->mapFromGlobal(e->globalPos())))
return false;
if (e->button() == Qt::LeftButton) {
#if defined(Q_WS_X11)
/*
Implicit grabs do not stop the X server from changing
the cursor in children, which looks *really* bad when
doing resizingk, so we grab the cursor. Note that we do
not do this on Windows since double clicks are lost due
to the grab (see change 198463).
*/
if (e->spontaneous())
# if !defined(QT_NO_CURSOR)
widget->grabMouse(widget->cursor());
# else
widget->grabMouse();
# endif // QT_NO_CURSOR
#endif // Q_WS_X11
buttonDown = false;
emit activate();
bool me = movingEnabled;
movingEnabled = (me && o == widget);
mouseMoveEvent(e);
movingEnabled = me;
buttonDown = true;
moveOffset = widget->mapFromGlobal(e->globalPos());
invertedMoveOffset = widget->rect().bottomRight() - moveOffset;
if (mode == Center) {
if (movingEnabled)
return true;
} else {
return true;
}
}
} break;
case QEvent::MouseButtonRelease:
if (w->isMaximized())
break;
if (e->button() == Qt::LeftButton) {
moveResizeMode = false;
buttonDown = false;
widget->releaseMouse();
widget->releaseKeyboard();
if (mode == Center) {
if (movingEnabled)
return true;
} else {
return true;
}
}
break;
case QEvent::MouseMove: {
if (w->isMaximized())
break;
buttonDown = buttonDown && (e->buttons() & Qt::LeftButton); // safety, state machine broken!
bool me = movingEnabled;
movingEnabled = (me && o == widget && (buttonDown || moveResizeMode));
mouseMoveEvent(e);
movingEnabled = me;
if (mode == Center) {
if (movingEnabled)
return true;
} else {
return true;
}
} break;
case QEvent::KeyPress:
keyPressEvent((QKeyEvent*)e);
break;
case QEvent::ShortcutOverride:
if (buttonDown) {
((QKeyEvent*)ee)->accept();
return true;
}
break;
default:
break;
}
return false;
}
bool FlickScroll::eventFilter(QObject *object, QEvent *event)
{
if(!object->isWidgetType())
return false;
QEvent::Type type = event->type();
if(type != QEvent::MouseButtonPress &&
type != QEvent::MouseButtonRelease &&
type != QEvent::MouseMove)
return false;
//dynamic_cast ensures that event is only a derived event of type QMouseEvent
QMouseEvent *mouseEvent = dynamic_cast<QMouseEvent *> (event);
if(!mouseEvent || mouseEvent->modifiers() != Qt::NoModifier)
return false;
//check if QObject is a QWebView, get flickdata,
//return if there are ignored events
QWebView *webView = dynamic_cast<QWebView *>(object);
FlickData * data = flickScroll_pm->flickData.value(webView);
if(!webView || !data || data->ignored.removeAll(event))
return false;
//go through the mouse event state machine
bool consumed = false; // mouse events consumed
switch(data->state)
{
//if mouse is pressed during steady state, goto pressed, cache the position
// cache the offset.
case FlickData::Steady:
if (mouseEvent->type() == QEvent::MouseButtonPress && mouseEvent->buttons() == Qt::LeftButton)
{
printf("State = Steady, MouseButtonPress\n");
consumed = true;
data->state = FlickData::Pressed;
data->pressPos = mouseEvent->pos();
data->offset = scrollOffset(webView);
data->extJS_offset = mouseEvent->pos().y();
}
break;
case FlickData::Pressed:
//if the mouse is released during pressed state, goto steady state,
//add button press and release to ignored events to restimulate button push/release
if(mouseEvent->type() == QEvent::MouseButtonRelease)
{
printf("State = Pressed, MouseButtonRelease\n");
consumed = true;
data->state = FlickData::Steady;
fakeMouseEvent(mouseEvent, data, object);
}
//user is manually scrolling.
//set the state, set the drag position. if ticker is not active, start it.
else if(mouseEvent->type() == QEvent::MouseMove)
{
printf("State = Pressed, MouseMove\n");
consumed = true;
data->state = FlickData::ManualScroll;
data->dragPos = QCursor::pos(); //from cursor for accuracy
if(!flickScroll_pm->ticker.isActive())
flickScroll_pm->ticker.start(20, this);
}
break;
//if manually scrolling, update the delta
// set the new scrolloffset, by adjusting the previous one with delta
//if the mouse is released, let it auto scroll
case FlickData::ManualScroll:
if(mouseEvent->type() == QEvent::MouseMove)
{
printf("State = ManualScroll, MouseMove\n");
consumed = true;
QPoint delta = mouseEvent->pos() - data->pressPos;
setScrollOffSet(data->widget, data->offset - delta);
scrollCustom(webView, mouseEvent->pos().y() - data->extJS_offset);
data->extJS_offset = mouseEvent->pos().y();
}
if(mouseEvent->type() == QEvent::MouseButtonRelease && !checkMouseSteadiness(mouseEvent->pos(), data->pressPos ))
{
printf("State = ManualScroll, MouseButtonRelease\n");
consumed = true;
data->state = FlickData::AutoScroll;
}
else if(mouseEvent->type() == QEvent::MouseButtonRelease)
{
printf("State = ManualScroll, MouseButtonRelease, reverting to steady\n");
consumed = true;
data->state = FlickData::Steady;
fakeMouseEvent(mouseEvent, data, object);
}
break;
case FlickData::AutoScroll:
/*
if the mouse is clicked while auto scrolling, we want to stop.
reset all states.
*/
if(mouseEvent->type() == QEvent::MouseButtonPress)
{
printf("State = AutoScroll, MouseButtonPress\n");
consumed=true;
data->state = FlickData::Stop;
data->speed = QPoint(0,0);
data->extJS_offset = 0;
data->pressPos = mouseEvent->pos();
data->offset = scrollOffset(data->widget);
}
if(mouseEvent->type() == QEvent::MouseButtonRelease)
{
printf("State = AutoScroll, MouseButtonRelease\n");
consumed = true;
data->state = FlickData::Steady;
data->speed = QPoint(0,0);
}
break;
case FlickData::Stop:
if(mouseEvent->type() == QEvent::MouseButtonRelease)
{
printf("State = Stop, MouseButtonRelease\n");
consumed = true;
data->state = FlickData::Steady;
}
if(mouseEvent->type() == QEvent::MouseMove)
{
printf("State = Stop, MouseMove\n");
consumed = true;
data->state = FlickData::ManualScroll;
data->dragPos = QCursor::pos();
if(!flickScroll_pm->ticker.isActive())
flickScroll_pm->ticker.start(20, this);
}
break;
default:
break;
}
return consumed;
}
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 MouseLassoNodesSelectorInteractorComponent::eventFilter(QObject *obj, QEvent *e) {
GlMainWidget *glWidget=static_cast<GlMainWidget *>(obj);
if (!glWidget->hasMouseTracking()) {
glWidget->setMouseTracking(true);
}
QMouseEvent *me = dynamic_cast<QMouseEvent *>(e);
if (!me) return false;
camera = &glWidget->getScene()->getLayer("Main")->getCamera();
graph = glWidget->getScene()->getGlGraphComposite()->getInputData()->getGraph();
viewSelection = graph->getProperty<BooleanProperty>("viewSelection");
currentPointerScreenCoord = Coord(me->x(), glWidget->height() - me->y());
if (me->type() == QEvent::MouseMove) {
if (dragStarted) {
polygon.push_back(glWidget->screenToViewport(currentPointerScreenCoord));
drawInteractor = true;
glWidget->redraw();
}
return true;
}
else if (me->type() == QEvent::MouseButtonPress) {
if (me->button() == Qt::LeftButton) {
dragStarted = true;
polygon.push_back(glWidget->screenToViewport(currentPointerScreenCoord));
}
else if (me->button() == Qt::RightButton) {
dragStarted = false;
if (!polygon.empty()) {
polygon.clear();
drawInteractor = true;
glWidget->redraw();
}
else {
Observable::holdObservers();
SelectedEntity selectedEntity;
bool result = glWidget->pickNodesEdges(me->x(), me->y(), selectedEntity);
if (result && selectedEntity.getEntityType() == SelectedEntity::NODE_SELECTED) {
bool sel = viewSelection->getNodeValue(node(selectedEntity.getComplexEntityId()));
viewSelection->setNodeValue(node(selectedEntity.getComplexEntityId()), !sel);
}
Observable::unholdObservers();
}
}
return true;
}
else if (me->type() == QEvent::MouseButtonRelease) {
dragStarted = false;
if (me->button() == Qt::LeftButton && polygon.size() > 10) {
Observable::holdObservers();
if (me->modifiers() != Qt::ControlModifier) {
viewSelection->setAllNodeValue(false);
viewSelection->setAllEdgeValue(false);
}
selectGraphElementsUnderPolygon(glWidget);
Observable::unholdObservers();
}
polygon.clear();
}
return false;
}
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 ScreenShoter::eventFilter(QObject *o, QEvent *e)
{
if (o != fullScreenLabel)
{
return ScreenShoter::eventFilter(o, e);
}
QMouseEvent *mouseEvent = static_cast<QMouseEvent*> (e);
//true 鼠标左键按下且按键还未弹起
if ((mouseEvent->button() == Qt::LeftButton)
&& (mouseEvent->type() == QEvent::MouseButtonPress))
{
//鼠标左键标志位按下
leftMousePress = true;
//获取鼠标点
origin = mouseEvent->pos();
if (!rubberBand)
{
rubberBand = new QRubberBand(QRubberBand::Rectangle, fullScreenLabel);
}
rubberBand->setGeometry(QRect(origin,QSize()));
rubberBand->show();
return true;
}
//true 鼠标左键按下并拖动
if ((mouseEvent->type() == QEvent::MouseMove)
&& (leftMousePress))
{
if (rubberBand)
{
rubberBand->setGeometry(QRect(origin, mouseEvent->pos()).normalized());
}
return true;
}
//鼠标左键松开
if ((mouseEvent->button() == Qt::LeftButton)
&& (mouseEvent->type() == QEvent::MouseButtonRelease))
{
//鼠标标志位弹起
leftMousePress = false;
if (rubberBand)
{
//获取橡皮筋框的终止坐标
termination = mouseEvent->pos();
QRect rect = QRect(origin, termination);
//根据橡皮筋框截取全屏上的信息，并将其放入shotScreenLabel
shotScreenLabel->setPixmap(fullScreenPixmap.grabWidget(fullScreenLabel,
rect.x(),
rect.y(),
rect.width(),
rect.height()));
//将shotScreenLabel的用户区大小固定为所截图片大小
shotScreenLabel->setFixedSize(rect.width(), rect.height());
// shotScreenLabel->show();
rubberBand->hide();
fullScreenLabel->hide();
saveShotPixmap() ;
}
return true;
}
return false;
}
