bool Window::eventFilter(QObject *object, QEvent *event)
{
if(!mouseOn || object != this) return false;
if (event->type() == QEvent::MouseButtonPress) {
QMouseEvent *mouseEvent = static_cast<QMouseEvent *>(event);
if (mouseEvent->buttons() & Qt::LeftButton) {
mouse[0] = true;
return true;
}
if (mouseEvent->buttons() & Qt::RightButton) {
mouse[1] = true;
return true;
}
}
if (event->type() == QEvent::MouseButtonRelease) {
QMouseEvent *mouseEvent = static_cast<QMouseEvent *>(event);
if (mouseEvent->buttons() & Qt::LeftButton) {
mouse[0] = false;
return true;
}
if (mouseEvent->buttons() & Qt::RightButton) {
mouse[1] = false;
return true;
}
}
return false;
}
MouseEvent::MouseEvent(const QMouseEvent& event, const unsigned int deviceID) :
x(event.x()),
y(event.y()),
deviceID(deviceID),
isLeftButton(event.buttons().testFlag(Qt::LeftButton)),
isRightButton(event.buttons().testFlag(Qt::RightButton)),
isMiddleButton(event.buttons().testFlag(Qt::MiddleButton)),
isShifted(event.modifiers().testFlag(Qt::ShiftModifier)),
isControl(event.modifiers().testFlag(Qt::ControlModifier)),
isMeta(event.modifiers().testFlag(Qt::MetaModifier)),
isAlt(event.modifiers().testFlag(Qt::AltModifier))
{
// single button that caused the event
switch (event.button()) {
case Qt::LeftButton:
button = "LEFT";
isLeftButton = true;
break;
case Qt::RightButton:
button = "RIGHT";
isRightButton = true;
break;
case Qt::MiddleButton:
button = "MIDDLE";
isMiddleButton = true;
break;
default:
button = "NONE";
break;
}
}
bool MouseEventFilter::eventFilter(QObject *obj, QEvent *event)
{
if(event->type() == QEvent::MouseMove)
{
QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
if(mouseEvent)
{
ApplicationManager::singleton()->setMouseX(mouseEvent->pos().x());
ApplicationManager::singleton()->setMouseY(mouseEvent->pos().y());
if(mouseEvent->buttons() && Qt::LeftButton && ApplicationManager::singleton()->grabbingWindowMoveHandle() &&
ApplicationManager::singleton()->windowControlButtonsEnabled())
{
QPoint diffPosition = mouseEvent->pos() - mousePos.toPoint();
QPoint newPosition = ApplicationManager::singleton()->window()->position() + diffPosition;
int oldWindowWidth = ApplicationManager::singleton()->window()->width();
if(ApplicationManager::singleton()->showNormal())
{
int windowWidth = ApplicationManager::singleton()->window()->width();
ApplicationManager::singleton()->window()->setPosition(newPosition.x() + (oldWindowWidth - windowWidth) * (mousePos.x() / oldWindowWidth), newPosition.y());
mousePos.setX(mousePos.x() - (oldWindowWidth - windowWidth) * (mousePos.x() / oldWindowWidth));
}
else
{
ApplicationManager::singleton()->window()->setPosition(newPosition);
}
}
else if(mouseEvent->buttons() && Qt::LeftButton && ApplicationManager::singleton()->grabbingWindowResizeHandle() &&
ApplicationManager::singleton()->windowControlButtonsEnabled())
{
QPoint diffPosition = mouseEvent->pos() - mousePos.toPoint();
mousePos = mouseEvent->pos();
QWindow *window = ApplicationManager::singleton()->window();
int newWidth = window->width() + diffPosition.x();
int newHeight = window->height() + diffPosition.y();
if(newWidth < 1024) newWidth = 1024;
if(newHeight < 600) newHeight = 600;
window->setGeometry(window->position().x(), window->position().y(), newWidth, newHeight);
}
}
}
else if(event->type() == QEvent::MouseButtonPress)
{
QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
if(mouseEvent)
{
mousePos = mouseEvent->pos();
}
}
return QObject::eventFilter(obj, event);
}
PlatformMouseEvent::PlatformMouseEvent(QInputEvent* event, int clickCount)
{
m_timestamp = WTF::currentTime();
QMouseEvent* me = 0;
switch (event->type()) {
case QEvent::MouseMove:
m_eventType = MouseEventMoved;
me = static_cast<QMouseEvent *>(event);
break;
case QEvent::MouseButtonDblClick:
case QEvent::MouseButtonPress:
m_eventType = MouseEventPressed;
me = static_cast<QMouseEvent *>(event);
break;
case QEvent::MouseButtonRelease:
m_eventType = MouseEventReleased;
me = static_cast<QMouseEvent *>(event);
break;
#ifndef QT_NO_CONTEXTMENU
case QEvent::ContextMenu: {
m_eventType = MouseEventPressed;
QContextMenuEvent* ce = static_cast<QContextMenuEvent*>(event);
m_position = IntPoint(ce->pos());
m_globalPosition = IntPoint(ce->globalPos());
m_button = RightButton;
break;
}
#endif // QT_NO_CONTEXTMENU
default:
m_eventType = MouseEventMoved;
}
if (me) {
m_position = IntPoint(me->pos());
m_globalPosition = IntPoint(me->globalPos());
if (me->button() == Qt::LeftButton || (me->buttons() & Qt::LeftButton))
m_button = LeftButton;
else if (me->button() == Qt::RightButton || (me->buttons() & Qt::RightButton))
m_button = RightButton;
else if (me->button() == Qt::MidButton || (me->buttons() & Qt::MidButton))
m_button = MiddleButton;
else
m_button = NoButton;
}
m_clickCount = clickCount;
m_shiftKey = (event->modifiers() & Qt::ShiftModifier);
m_ctrlKey = (event->modifiers() & Qt::ControlModifier);
m_altKey = (event->modifiers() & Qt::AltModifier);
m_metaKey = (event->modifiers() & Qt::MetaModifier);
}
void QtEventConsumer::handleMouseDoubleEvent ( QObject *obj, QEvent *event )
{
// check the object
QWidget *widget = isValidWidget(obj);
if (!widget){
DEBUG(D_CONSUMER,"(QtEventConsumer::handleMouseDoubleEvent) No widget to handle");
return;
}
DEBUG(D_CONSUMER,"(QtEventConsumer::handleMouseDoubleEvent)");
QMouseEvent *me = dynamic_cast< QMouseEvent*> ( event );
//create the event
QOE::QOE_MouseDouble qoe;
qoe.timestamp(_timer.restart());
completeBasicData(qoe,widget,me);
qoe.button(me->button());
qoe.buttons(me->buttons());
qoe.modifiers(me->modifiers());
///sensitive value
completeSensitiveData(qoe, widget);
//send event if qoe is valid
if (isValidQOE(qoe) && isValidQOEMouse(qoe))
sendNewTestItem(qoe);
}
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 DialogFunction::eventFilter(QObject* pWatched, QEvent* pEvent)
{
QwtPlotCanvas* pPlotCanvas = static_cast<QwtPlotCanvas*>(pWatched);
switch (pEvent->type())
{
case QEvent::MouseButtonPress:
{
QMouseEvent* pMouseEvent = static_cast<QMouseEvent*>(pEvent);
Qt::MouseButtons buttons = pMouseEvent->buttons();
if (buttons & Qt::RightButton)
{
QMenu menu;
// Insert point action
QAction* pActionInsertPoint = new QAction(tr("Insert point"), &menu);
pActionInsertPoint->setData(pMouseEvent->pos());
connect(pActionInsertPoint, SIGNAL(triggered(bool)), this, SLOT(onInsertPoint()));
menu.addAction(pActionInsertPoint);
// Remove point action
if (_indexSelectedPoint>=0)
{
QAction* pActionRemovePoint = new QAction(tr("Remove point"), &menu);
pActionRemovePoint->setData(pMouseEvent->pos());
connect(pActionRemovePoint, SIGNAL(triggered(bool)), this, SLOT(onRemovePoint()));
menu.addAction(pActionRemovePoint);
}
menu.exec(QCursor::pos());
}
else if (buttons & Qt::LeftButton && _indexSelectedPoint >=0)
bool HScrollArea::eventFilter(QObject *obj, QEvent *event)
{
if (event->type() == QEvent::MouseMove) {
QMouseEvent* me = (QMouseEvent*) event;
if ((me->buttons() & Qt::LeftButton)) {
if (!mMoveStart) {
mMoveStart = true;
mContinousMove =false;
mMousePoint = me->globalPos();
}
else {
scrollBar = horizontalScrollBar();
QPoint p = me->globalPos();
int offset = p.x() - mMousePoint.x();
if( !mContinousMove && ( offset > -10 && offset < 10 ) )
return false;
mContinousMove = true;
scrollBar->setValue(scrollBar->value() - offset);
mMousePoint = p;
}
return true;
}
}
else if (event->type() == QEvent::MouseButtonRelease) {
mMoveStart = false;
}
return QObject::eventFilter(obj, event);
}
void mouseMoveEvent (State& state, const QMouseEvent& event) {
if (event.buttons () == Qt::MiddleButton) {
Camera& cam = state.camera ();
const glm::uvec2& resolution = cam.resolution ();
glm::ivec2 newPos = ViewUtil::toIVec2 (event);
glm::ivec2 delta = newPos - oldPos;
if (event.modifiers () == Qt::NoModifier) {
if (delta.x != 0) {
cam.verticalRotation ( 2.0f * glm::pi <float> ()
* this->rotationFactor
* float (-delta.x) / float (resolution.x));
}
if (delta.y != 0) {
cam.horizontalRotation ( 2.0f * glm::pi <float> ()
* this->rotationFactor
* float (-delta.y) / float (resolution.y));
}
}
else if (event.modifiers () == Qt::ShiftModifier) {
cam.setGaze ( cam.gazePoint ()
+ (this->movementFactor * float ( delta.x) * cam.right ())
+ (this->movementFactor * float (-delta.y) * cam.up ())
);
}
this->oldPos = newPos;
state.mainWindow ().mainWidget ().glWidget ().update ();
}
}
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;
}
// 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 FileViewFloatItem::eventFilter(QObject *object, QEvent *e)
{
if ( !enabled() || !visible() ) {
return false;
}
MarbleWidget *widget = dynamic_cast<MarbleWidget*> (object);
if ( !widget ) {
return AbstractFloatItem::eventFilter(object, e);
}
if ( m_marbleWidget != widget ) {
// Delayed initialization
m_marbleWidget = widget;
}
Q_ASSERT( m_marbleWidget );
// Mouse events are forwarded to the underlying widget
QMouseEvent *event = static_cast<QMouseEvent*> (e);
QRectF floatItemRect = QRectF( positivePosition(), size() );
QPoint shiftedPos = event->pos() - floatItemRect.topLeft().toPoint()
- QPoint( padding(), padding() );
if( e->type() == QEvent::MouseMove ) {
m_itemPosition = event->globalPos();
}
if( floatItemRect.contains( event->pos() ) ) {
QWidget *child = m_fileViewParent->childAt( shiftedPos );
if( child ) {
m_marbleWidget->setCursor( Qt::ArrowCursor );
// there needs to be some extra handling for the scrollbars
// these need some special treatment due to them not forwarding
// their mouseevents to their scrollbars.
if( reinterpret_cast<QScrollBar*>( child ) == m_fileView->horizontalScrollBar() ) {
shiftedPos -= QPoint( 0, m_fileView->viewport()->size().height() );
} else if( reinterpret_cast<QScrollBar*>( child ) == m_fileView->verticalScrollBar() ) {
shiftedPos -= QPoint( m_fileView->viewport()->size().width(), 0 );
}
QMouseEvent shiftedEvent( e->type(), shiftedPos,
event->globalPos(), event->button(), event->buttons(),
event->modifiers() );
if( QApplication::sendEvent(child, &shiftedEvent) ) {
if( e->type() == QEvent::MouseButtonPress ||
e->type() == QEvent::MouseButtonRelease ||
e->type() == QEvent::MouseButtonDblClick ||
e->type() == QEvent::MouseMove )
updateFileView();
return true;
}
}
}
return AbstractFloatItem::eventFilter(object, e);
}
bool WidgetGraphicsItem::eventFilter( QObject *object, QEvent *e )
{
if ( !visible() || d->m_widget == 0 ) {
return false;
}
MarbleWidget *widget = dynamic_cast<MarbleWidget*> (object);
if ( !widget ) {
return ScreenGraphicsItem::eventFilter(object, e);
}
if ( d->m_marbleWidget != widget ) {
// Delayed initialization
d->m_marbleWidget = widget;
}
Q_ASSERT(d->m_marbleWidget);
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 );
QList<QPointF> widgetPositions = absolutePositions();
QRectF widgetItemRect;
QPoint shiftedPos;
QList<QPointF>::iterator it = widgetPositions.begin();
bool foundRightPosition = false;
while( it != widgetPositions.end() && !foundRightPosition ) {
widgetItemRect = QRectF( *it, size() );
if ( widgetItemRect.contains( event->pos() ) ) {
foundRightPosition = true;
shiftedPos = event->pos() - widgetItemRect.topLeft().toPoint();
}
}
if ( foundRightPosition ) {
QWidget *child = d->m_widget->childAt( shiftedPos );
if ( child ) {
d->m_marbleWidget->setCursor( Qt::ArrowCursor );
shiftedPos -= child->pos(); // transform to children's coordinates
QMouseEvent shiftedEvent = QMouseEvent( e->type(), shiftedPos,
event->globalPos(), event->button(), event->buttons(),
event->modifiers() );
if ( QApplication::sendEvent( child, &shiftedEvent ) ) {
return true;
}
}
}
}
return ScreenGraphicsItem::eventFilter(object, e);
}
void GAllEvents::storeMouseState(QEvent *event)
{
QMouseEvent *mouseEvent = static_cast<QMouseEvent *>(event);
this->nX = mouseEvent->x();
this->nY = mouseEvent->y();
this->nGlobalX = mouseEvent->globalX();
this->nGlobalY = mouseEvent->globalY();
this->nButton = mouseEvent->button();
this->nButtons = mouseEvent->buttons();
}
bool MainWindow::eventFilter(QObject *obj, QEvent *event)
{
QPushButton *pBut = (QPushButton*)obj;
QString objName = pBut->objectName();
int index = 0;
if ( objName.compare("pushButton_0") == 0 ) index = DISPLAYTYPE;
else if( objName.compare("pushButton_1") == 0 ) index = DISPLAYTYPE1;
else if( objName.compare("pushButton_2") == 0 ) index = DISPLAYTYPE2;
else if( objName.compare("pushButton_3") == 0 ) index = DISPLAYTYPE3;
else if( objName.compare("pushButton_4") == 0 ) index = DISPLAYTYPE4;
else if( objName.compare("pushButton_5") == 0 ) index = DISPLAYTYPE5;
else if( objName.compare("pushButton_6") == 0 ) index = DISPLAYTYPE6;
else if( objName.compare("pushButton_7") == 0 ) index = DISPLAYTYPE7;
else if( objName.compare("pushButton_8") == 0 ) index = DISPLAYTYPE8;
else if( objName.compare("pushButton_9") == 0 ) index = DISPLAYTYPE9;
else if( objName.compare("pushButton_10") == 0 ) index = DISPLAYTYPE10;
else if( objName.compare("pushButton_11") == 0 ) index = DISPLAYTYPE11;
else if( objName.compare("pushButton_12") == 0 ) index = DISPLAYTYPE12;
else if( objName.compare("pushButton_13") == 0 ) index = DISPLAYTYPE13;
else if( objName.compare("pushButton_14") == 0 ) index = DISPLAYTYPE14;
else if( objName.compare("pushButton_15") == 0 ) index = DISPLAYTYPE15;
else if( objName.compare("pushButton_16") == 0 ) index = DISPLAYTYPE16;
else if( objName.compare("pushButton_17") == 0 ) index = DISPLAYTYPE17;
else index = -1;
QString passwd = passWord.at(index);
if(event->type()==QEvent::MouseButtonPress && pBut -> isEnabled() && (index < DISPLAYTOT || index >= DISPLAYTYPE))
{
QMouseEvent *mouseEvent = static_cast<QMouseEvent *>(event);
if (mouseEvent->buttons() & Qt::LeftButton)
{
if(passwd.compare("") != 0)
{
//qDebug("Password: %s", passwd.toStdString().c_str());
#if 0
Password pword(passwd, new QWidget());
if(pword.getStatus()== true) displayDockWidget(index, pBut);
#endif
#if 1
displayDockWidget(index, pBut);
#endif
}
else
{
displayDockWidget(index, pBut);
}
return true;
}
return false;
}
return QMainWindow::eventFilter(obj, event);
}
void compare_mouse_event(QSignalSpy& spy,
const QMouseEvent& expected_event) const
{
spy.wait(_wait_ms);
BOOST_CHECK_EQUAL(spy.count(), 1);
QList<QVariant> arguments = spy.takeFirst();
BOOST_CHECK_EQUAL(arguments.at(0).toInt(), expected_event.x());
BOOST_CHECK_EQUAL(arguments.at(1).toInt(), expected_event.y());
BOOST_CHECK_EQUAL(arguments.at(2).value<Qt::MouseButtons>(),
expected_event.buttons());
}
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);
}
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 );
}
}
bool PopupEventFilterObject::eventFilter(QObject *object, QEvent *event)
{
if(event->type() == QEvent::MouseButtonPress) {
// Handle popup menus only if one button is pressed
QMouseEvent *mouseEvent = static_cast<QMouseEvent *>(event);
Qt::MouseButtons buttons = mouseEvent->buttons();
if(buttons == Qt::LeftButton || buttons == Qt::MidButton || buttons == Qt::RightButton) {
return KxQtHelper::handlePopupMenu(object, event);
}
}
// If not handled, pass for default processing
return false;
}
void CPrivateInfo::mousePressEvent(QMouseEvent * ev)
{
QMouseEvent *mv = (QMouseEvent*) ev;
if(mv->buttons() & Qt::LeftButton)
{
QRect labelrect = QRect(ui->lb_top->pos() + this->pos(), ui->lb_top->size());
if(labelrect.contains(mv->globalPos()))
{
m_Ptbefore = mv->globalPos();
m_Ptcur = mv->pos();
}
}
}
bool OverwriteWidget::event(QEvent *ev)
{
if(ev->type() == QEvent::MouseButtonPress) {
QMouseEvent *e = static_cast<QMouseEvent*>(ev);
if((e->buttons() & Qt::LeftButton) == Qt::LeftButton) {
qWarning("mousePressEvent()");
changeOverwriteMode();
return true;
}
}
return QLabel::event(ev);
}
bool MainTabs::eventFilter(QObject *receiver, QEvent *event)
{
bool result = QObject::eventFilter(receiver, event);
if (receiver == tabBarRef) {
if (event->type() == QEvent::MouseButtonDblClick) {
QMouseEvent* me = dynamic_cast<QMouseEvent*>(event);
if (me == nullptr) {
qCritical() << "[MainTabs::eventFilter] nullptr MouseEvent";
return true; // not supposed to happen anyway ..
} else {
// checking if we can locate the tab
int clickedTabId = tabBarRef->tabAt(me->pos());
if (clickedTabId == -1)
return result;
//renaming
askForRenaming(clickedTabId);
return true; //no further handling of this event is required
}
}
} else if (receiver == this) {
if (event->type() == QEvent::MouseButtonDblClick) {
QRect clickable = tabBarRef->geometry();
clickable.setRight(geometry().right());
QMouseEvent* me = dynamic_cast<QMouseEvent*>(event);
if (me == nullptr) {
qCritical() << "[MainTabs::eventFilter] nullptr MouseEvent";
return true; // not supposed to happen anyway ..
} else if (clickable.contains(me->pos())){ // only in the tabbar area
newPreTab(guiHelper->getDefaultNewTab());
return true;
}
} else if (event->type() == QEvent::MouseButtonPress) {
QMouseEvent* me = dynamic_cast<QMouseEvent*>(event);
if (me == nullptr) {
qCritical() << "[MainTabs::eventFilter] nullptr MouseEvent";
return true; // not supposed to happen anyway ..
} else if (me->buttons() == Qt::RightButton){ // only in the tabbar area
QRect clickable = tabBarRef->geometry();
clickable.setRight(geometry().right());
if (clickable.contains(me->pos())) {
tabHeaderContextMenu->exec(this->mapToGlobal(me->pos()));
return true;
}
}
}
}
return result;
}
bool Manual::eventFilter(QObject *obj, QEvent *evt) {
if ((evt->type() == QEvent::MouseButtonPress) || (evt->type() == QEvent::MouseMove)) {
QMouseEvent *qme = dynamic_cast<QMouseEvent *>(evt);
if (qme) {
if (qme->buttons() & Qt::LeftButton) {
QPointF qpf = qgvPosition->mapToScene(qme->pos());
qdsbX->setValue(-qpf.x());
qdsbZ->setValue(-qpf.y());
qgiPosition->setPos(qpf);
}
}
}
return QDialog::eventFilter(obj, evt);
}
bool EWASitesListModelDelegate::editorEvent( QEvent *event,
QAbstractItemModel *model, const QStyleOptionViewItem &option, const QModelIndex &index )
{
if( event->type() == QEvent::MouseButtonPress )
{
QMouseEvent *pMouseEvent = static_cast<QMouseEvent *>( event );
if( pMouseEvent && pMouseEvent->buttons() == Qt::RightButton )
{
EWASiteDelegateBase::requestContextMenuForSite( pMouseEvent->globalPos(), index );
}
}
return QStyledItemDelegate::editorEvent( event, model, option, index );
}
bool calibrationtestwidget::eventFilter ( QObject * watched, QEvent * event ){
if(watched!=frame)
return false;
if(event->type()==QEvent::MouseButtonPress){
QMouseEvent *mevent = static_cast<QMouseEvent *>(event);
if(mevent->button() ==Qt::LeftButton){
oldpoint = mevent->pos();
paintpath.moveTo(oldpoint.x(),oldpoint.y());
candrawline = TRUE;
return TRUE;
}
}
if(candrawline&&(event->type()==QEvent::MouseMove)){
QMouseEvent *mevent = static_cast<QMouseEvent *>(event);
if(mevent->buttons() ==Qt::LeftButton){
newpoint = mevent->pos();
frame->update();
return TRUE;
}
}
if(event->type()==QEvent::MouseButtonRelease){
QMouseEvent *mevent = static_cast<QMouseEvent *>(event);
if(mevent->buttons() ==Qt::LeftButton){
candrawline = FALSE;
return TRUE;
}
}
if(event->type()==QEvent::Paint){
//QPaintEvent *pevent = static_cast<QPaintEvent *>(event);
QPainter painter(frame);
//painter.setClipRect(oldpoint.x(),oldpoint.y(),newpoint.x(),newpoint.y());
paintpath.lineTo(newpoint);
painter.drawPath(paintpath);
return FALSE;
}
return FALSE;
}
bool AdjustButton::eventFilter (QObject* obj, QEvent* event)
{
if (this->isEnabled()) {
if (event->type() == QEvent::MouseButtonPress) {
QMouseEvent* mevent = static_cast<QMouseEvent*> (event);
if (mevent->button() == mevent->buttons()) {
previous_y = deadzone_y = mevent->y();
deadzone_value = value();
}
}
else if (event->type() == QEvent::MouseButtonRelease) {
if (static_cast<QMouseEvent*> (event)->buttons() == Qt::NoButton) {
deadzone_y = -1;
deadzone_value = NAN;
}
}
else if (event->type() == QEvent::MouseMove) {
QMouseEvent* mevent = static_cast<QMouseEvent*> (event);
if (mevent->buttons() != Qt::NoButton) {
if (std::abs (mevent->y() - deadzone_y) < ADJUST_BUTTON_DEADZONE_SIZE) {
if (value() != deadzone_value) {
setValue (deadzone_value);
emit valueChanged();
emit valueChanged(value());
}
} else if (mevent->y() != previous_y) {
setValue (value() - rate * (mevent->y() - previous_y));
emit valueChanged();
emit valueChanged(value());
}
previous_y = mevent->y();
return true;
}
}
}
return QObject::eventFilter (obj, event);
}
dmz::V8Value
dmz::JsModuleUiV8QtBasic::_mouse_event_buttons (const v8::Arguments &Args) {
v8::HandleScope scope;
V8Value result = v8::Undefined ();
JsModuleUiV8QtBasic *self = _to_self (Args);
if (self) {
QMouseEvent *event = (QMouseEvent *)self->_to_qevent (Args.This ());
if (event) { result = v8::Integer::New (event->buttons ()); }
}
return scope.Close (result);
}
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 ParallelCoordsElementDeleter::eventFilter(QObject *, QEvent *e) {
if (e->type() == QEvent::MouseButtonPress) {
QMouseEvent *me = dynamic_cast<QMouseEvent *>(e);
if (me->buttons()==Qt::LeftButton) {
ParallelCoordinatesView *parallelView = dynamic_cast<ParallelCoordinatesView *>(view());
Observable::holdObservers();
parallelView->deleteDataUnderPointer(me->x(), me->y());
Observable::unholdObservers();
return true;
}
}
return false;
}
bool FullScreenBar::eventFilter(QObject* object, QEvent* event)
{
if (event->type() == QEvent::MouseMove) {
QApplication::restoreOverrideCursor();
d->mAutoHideCursorTimer->start();
if (y() == 0) {
if (d->shouldHide()) {
slideOut();
}
} else {
QMouseEvent* mouseEvent = static_cast<QMouseEvent *>(event);
if (mouseEvent->buttons() == 0 && d->slideInTriggerRect().contains(QCursor::pos())) {
slideIn();
}
}
return false;
}
if (event->type() == QEvent::MouseButtonRelease) {
// This can happen if user released the mouse after using a scrollbar
// in the content (the bar does not hide while a button is down)
if (y() == 0 && d->shouldHide()) {
slideOut();
}
return false;
}
// Filtering message on tooltip text for CJK to remove accelerators.
// Quoting ktoolbar.cpp:
// """
// CJK languages use more verbose accelerator marker: they add a Latin
// letter in parenthesis, and put accelerator on that. Hence, the default
// removal of ampersand only may not be enough there, instead the whole
// parenthesis construct should be removed. Use KLocale's method to do this.
// """
if (event->type() == QEvent::Show || event->type() == QEvent::Paint) {
QToolButton* button = qobject_cast<QToolButton*>(object);
if (button && !button->actions().isEmpty()) {
QAction* action = button->actions().first();
QString toolTip = KGlobal::locale()->removeAcceleratorMarker(action->toolTip());
// Filtering message requested by translators (scripting).
button->setToolTip(i18nc("@info:tooltip of custom toolbar button", "%1", toolTip));
}
}
return false;
}
