void Interactor2DNavigate::UpdateCursor( QEvent* event, QWidget* wnd )
{
if ( wnd->hasFocus() )
{
if ( event->type() == QEvent::MouseButtonPress ||
event->type() == QEvent::MouseButtonRelease ||
event->type() == QEvent::MouseMove)
{
QMouseEvent* e = ( QMouseEvent* )event;
if ( e->button() == Qt::MidButton || e->button() == Qt::RightButton ||
( ( e->modifiers() & CONTROL_MODIFIER) && (e->modifiers() & Qt::ShiftModifier) ) )
{
Interactor2D::UpdateCursor( event, wnd );
}
else
{
// set own cursor
wnd->setCursor( QCursor() );
}
}
}
else
{
Interactor2D::UpdateCursor( event, wnd );
}
}
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;
}
}
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;
}
bool ProgressManagerPrivate::eventFilter(QObject *obj, QEvent *event)
{
if (obj == m_statusBarWidget && event->type() == QEvent::Enter) {
m_hovered = true;
updateVisibility();
} else if (obj == m_statusBarWidget && event->type() == QEvent::Leave) {
m_hovered = false;
// give the progress view the chance to get the mouse enter event
updateVisibilityWithDelay();
} else if (obj == m_statusBarWidget && event->type() == QEvent::MouseButtonPress
&& !m_taskList.isEmpty()) {
QMouseEvent *me = static_cast<QMouseEvent *>(event);
if (me->button() == Qt::LeftButton && !me->modifiers()) {
FutureProgress *progress = m_currentStatusDetailsProgress;
if (!progress)
progress = m_taskList.last();
// don't send signal directly from an event filter, event filters should
// do as little a possible
QTimer::singleShot(0, progress, &FutureProgress::clicked);
event->accept();
return true;
}
}
return false;
}
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 BookmarkWidget::eventFilter(QObject *object, QEvent *e)
{
if ((object == this) || (object == treeView->viewport())) {
QModelIndex index = treeView->currentIndex();
if (e->type() == QEvent::KeyPress) {
QKeyEvent *ke = static_cast<QKeyEvent*>(e);
if (index.isValid() && searchField->text().isEmpty()) {
const QModelIndex &src = filterBookmarkModel->mapToSource(index);
if (ke->key() == Qt::Key_F2) {
QStandardItem *item =
bookmarkManager->treeBookmarkModel()->itemFromIndex(src);
if (item) {
item->setEditable(true);
treeView->edit(index);
item->setEditable(false);
}
} else if (ke->key() == Qt::Key_Delete) {
bookmarkManager->removeBookmarkItem(treeView, src);
}
}
switch (ke->key()) {
default: break;
case Qt::Key_Up: {
case Qt::Key_Down:
treeView->subclassKeyPressEvent(ke);
} break;
case Qt::Key_Enter: {
case Qt::Key_Return:
index = treeView->selectionModel()->currentIndex();
if (index.isValid()) {
QString data = index.data(Qt::UserRole + 10).toString();
if (!data.isEmpty() && data != QLatin1String("Folder"))
emit requestShowLink(data);
}
} break;
case Qt::Key_Escape: {
emit escapePressed();
} break;
}
} else if (e->type() == QEvent::MouseButtonRelease) {
if (index.isValid()) {
QMouseEvent *me = static_cast<QMouseEvent*>(e);
bool controlPressed = me->modifiers() & Qt::ControlModifier;
if(((me->button() == Qt::LeftButton) && controlPressed)
|| (me->button() == Qt::MidButton)) {
QString data = index.data(Qt::UserRole + 10).toString();
if (!data.isEmpty() && data != QLatin1String("Folder"))
{
//CentralWidget::instance()->setSourceInNewTab(data);
emit requestShowLinkInNewTab(data);
}
}
}
}
}
return QWidget::eventFilter(object, e);
}
bool ContentWindow::eventFilter(QObject *o, QEvent *e)
{
if (m_contentWidget && o == m_contentWidget->viewport()
&& e->type() == QEvent::MouseButtonRelease) {
QMouseEvent *me = static_cast<QMouseEvent*>(e);
QItemSelectionModel *sm = m_contentWidget->selectionModel();
if (!me || !sm)
return QWidget::eventFilter(o, e);
Qt::MouseButtons button = me->button();
const QModelIndex &index = m_contentWidget->indexAt(me->pos());
if (index.isValid() && sm->isSelected(index)) {
if ((button == Qt::LeftButton && (me->modifiers() & Qt::ControlModifier))
|| (button == Qt::MidButton)) {
QHelpContentModel *contentModel =
qobject_cast<QHelpContentModel*>(m_contentWidget->model());
if (contentModel) {
QHelpContentItem *itm = contentModel->contentItemAt(index);
if (itm && HelpViewer::canOpenPage(itm->url().path()))
OpenPagesManager::instance().createPage(itm->url());
}
} else if (button == Qt::LeftButton) {
itemClicked(index);
}
}
}
return QWidget::eventFilter(o, e);
}
bool ContentWindow::eventFilter(QObject *o, QEvent *e)
{
if (m_contentWidget && o == m_contentWidget->viewport()
&& e->type() == QEvent::MouseButtonRelease) {
QMouseEvent *me = static_cast<QMouseEvent*>(e);
QModelIndex index = m_contentWidget->indexAt(me->pos());
QItemSelectionModel *sm = m_contentWidget->selectionModel();
Qt::MouseButtons button = me->button();
if (index.isValid() && (sm && sm->isSelected(index))) {
if ((button == Qt::LeftButton && (me->modifiers() & Qt::ControlModifier))
|| (button == Qt::MidButton)) {
QHelpContentModel *contentModel =
qobject_cast<QHelpContentModel*>(m_contentWidget->model());
if (contentModel) {
QHelpContentItem *itm = contentModel->contentItemAt(index);
if (itm && !isPdfFile(itm))
CentralWidget::instance()->setSourceInNewTab(itm->url());
}
} else if (button == Qt::LeftButton) {
itemClicked(index);
}
}
}
return QWidget::eventFilter(o, e);
}
// 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);
}
bool GooeyDoubleSpinBox::eventFilter(QObject* object, QEvent* event)
{
QMouseEvent* mouseEvent = static_cast<QMouseEvent*>(event);
switch(event->type())
{
case QEvent::MouseButtonPress:
if(mouseEvent->button() == Qt::LeftButton)
{
_lastMousePos = mouseEvent->globalPos();
}
break;
case QEvent::MouseButtonRelease:
if(mouseEvent->button() == Qt::LeftButton)
{
_lastMousePos = QPoint(); // Reset the point !
}
break;
case QEvent::MouseMove:
if(mouseEvent->buttons() & Qt::LeftButton)
{
QPoint pos = mouseEvent->globalPos();
double dx = _spinBox->singleStep() * (pos.x() - _lastMousePos.x());
if(mouseEvent->modifiers() & Qt::CTRL)
{
dx *= 2.0;
}
else if(mouseEvent->modifiers() & Qt::SHIFT)
{
dx *= 0.5;
}
_spinBox->setValue( _spinBox->value() + dx );
// Update position !
_lastMousePos = pos;
}
break;
default:
break;
}
return false;
}
bool MainWindow::eventFilter(QObject *, QEvent *e){
if(e->type() == QEvent::MouseButtonRelease){
QMouseEvent *me = static_cast<QMouseEvent*>(e);
if(me->modifiers() == Qt::ControlModifier){
qDebug() << "Ctrl+Left Click";
editFlag = true;
}
}
return false;
}
void Interactor2DMeasure::UpdateCursor( QEvent* event, QWidget* wnd )
{
RenderView2D* view = ( RenderView2D* )wnd;
if ( wnd->hasFocus() )
{
if ( event->type() == QEvent::MouseButtonPress ||
event->type() == QEvent::MouseButtonRelease ||
event->type() == QEvent::MouseMove)
{
QMouseEvent* e = ( QMouseEvent* )event;
if ( ( ( e->button() == Qt::MidButton || e->button() == Qt::RightButton ) && !m_bEditing ) ||
( ( e->modifiers() & CONTROL_MODIFIER) && (e->modifiers() & Qt::ShiftModifier) ) )
{
Interactor2D::UpdateCursor( event, wnd );
return;
}
else if ( ( !m_bEditing && !m_bDrawing && view->GetRegion( e->x(), e->y() ) ) ||
( m_bEditing && m_nPointIndex < 0 ) )
{
wnd->setCursor( CursorFactory::CursorGrab );
}
else
{
if ( m_nAction == MM_Line )
{
wnd->setCursor( CursorFactory::CursorMeasureLine );
}
else if ( m_nAction == MM_Rectangle )
{
wnd->setCursor( CursorFactory::CursorMeasureRectangle );
}
else if ( m_nAction == MM_Polyline || m_nAction == MM_Spline )
{
wnd->setCursor( CursorFactory::CursorMeasurePolyline );
}
}
}
}
else
{
Interactor2D::UpdateCursor( event, wnd );
}
}
bool LeftClickWithModifiersEater::eventFilter(QObject *obj, QEvent *event)
{
if(event->type() == QEvent::MouseButtonPress || event->type() == QEvent::MouseButtonDblClick)
{
QMouseEvent *me = static_cast<QMouseEvent *>(event);
if(me->button() == Qt::LeftButton && me->modifiers() != Qt::NoModifier)
return true;
}
return QObject::eventFilter(obj, event);
}
/*!
\reimp
*/
bool QBasicMouseEventTransition::eventTest(QEvent *event)
{
Q_D(const QBasicMouseEventTransition);
if (event->type() == d->eventType) {
QMouseEvent *me = static_cast<QMouseEvent*>(event);
return (me->button() == d->button)
&& ((me->modifiers() & d->modifierMask) == d->modifierMask)
&& (d->path.isEmpty() || d->path.contains(me->pos()));
}
return false;
}
bool SimpleList::eventFilter(QObject *obj, QEvent *event)
{
if (obj == ui->tableViewFM->viewport() && event->type() == QEvent::MouseButtonPress)
{
QMouseEvent *mouseEvent = static_cast<QMouseEvent*> (event);
m_holdingShiftKey = mouseEvent->modifiers() & Qt::ShiftModifier;;
m_holdingCtrlKey = mouseEvent->modifiers() & Qt::ControlModifier;;
m_button = mouseEvent->button();
}
return QMainWindow::eventFilter(obj, event);
}
bool ShortcutsPlugin::eventFilter(QObject *o, QEvent *e)
{
unsigned button = 0;
QMouseEvent *me = NULL;
if (e->type() == QEvent::MouseButtonPress){
me = static_cast<QMouseEvent*>(e);
switch (me->button()){
case Qt::LeftButton:
button = 1;
break;
case Qt::RightButton:
button = 2;
break;
case Qt::MidButton:
button = 3;
break;
default:
break;
}
}
if (e->type() == QEvent::MouseButtonDblClick){
me = static_cast<QMouseEvent*>(e);
switch (me->button()){
case Qt::LeftButton:
button = 4;
break;
case Qt::RightButton:
button = 5;
break;
case Qt::MidButton:
button = 6;
break;
default:
break;
}
}
if (me){
button |= me->modifiers();
MAP_CMDS::iterator it = mouseCmds.find(button);
if (it != mouseCmds.end()){
CommandDef *cmd = &it->second;
EventMenuGet e(cmd);
e.process();
QMenu *popup = e.menu();
if (popup){
popup->popup(me->globalPos());
return true;
}
}
}
return QObject::eventFilter(o, e);
}
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 PopupItem::eventFilter( QObject *object, QEvent *e )
{
MarbleWidget *widget = dynamic_cast<MarbleWidget*> ( object );
if ( !widget ) {
return BillboardGraphicsItem::eventFilter( object, e );
}
if ( e->type() == QEvent::MouseButtonDblClick
|| e->type() == QEvent::MouseMove
|| e->type() == QEvent::MouseButtonPress
|| e->type() == QEvent::MouseButtonRelease )
{
// Mouse events are forwarded to the underlying widget
QMouseEvent *event = static_cast<QMouseEvent*> ( e );
QPoint const shiftedPos = transform( event->pos() );
bool const forcedMouseRelease = m_needMouseRelease && e->type() == QEvent::MouseButtonRelease;
if ( !shiftedPos.isNull() || forcedMouseRelease ) {
if ( !m_needMouseRelease && e->type() == QEvent::MouseButtonPress ) {
m_needMouseRelease = true;
} else if ( forcedMouseRelease ) {
m_needMouseRelease = false;
}
widget->setCursor( Qt::ArrowCursor );
// transform to children's coordinates
QMouseEvent shiftedEvent = QMouseEvent( e->type(), shiftedPos,
event->globalPos(), event->button(), event->buttons(),
event->modifiers() );
if ( QApplication::sendEvent( m_webView, &shiftedEvent ) ) {
widget->setCursor( m_webView->cursor() );
emit dirty();
return true;
}
}
} else if ( e->type() == QEvent::Wheel ) {
// Wheel events are forwarded to the underlying widget
QWheelEvent *event = static_cast<QWheelEvent*> ( e );
QPoint const shiftedPos = transform( event->pos() );
if ( !shiftedPos.isNull() ) {
widget->setCursor( Qt::ArrowCursor );
QWheelEvent shiftedEvent = QWheelEvent( shiftedPos,
event->globalPos(), event->delta(), event->buttons(),
event->modifiers() );
if ( QApplication::sendEvent( m_webView, &shiftedEvent ) ) {
widget->setCursor( m_webView->cursor() );
emit dirty();
return true;
}
}
}
return BillboardGraphicsItem::eventFilter( object, e );
}
bool SceneInspectorWidget::eventFilter(QObject *obj, QEvent *event)
{
Q_ASSERT(obj == ui->graphicsSceneView->view()->viewport());
if (event->type() == QEvent::Resize) {
QMetaObject::invokeMethod(this, "visibleSceneRectChanged", Qt::QueuedConnection);
} else if (event->type() == QEvent::MouseButtonRelease) {
QMouseEvent *e = static_cast<QMouseEvent *>(event);
if (e->button() == Qt::LeftButton
&& e->modifiers() == (Qt::ControlModifier | Qt::ShiftModifier))
m_interface->sceneClicked(ui->graphicsSceneView->view()->mapToScene(e->pos()));
}
return QObject::eventFilter(obj, event);
}
bool Pick::handleEvent(QObject * receiver, QEvent * event) {
if (!m_handler) {
return false;
}
if (event->type() == QEvent::MouseButtonPress) {
QMouseEvent * evt = static_cast<QMouseEvent *>(event);
if (evt->modifiers() & Qt::ShiftModifier &&
evt->modifiers() & Qt::ControlModifier) {
m_handler->handle(receiver, evt->pos());
return true;
}
}
return false;
}
bool WindowManager::mousePressEvent(QObject *object, QEvent *event)
{
// cast event and check buttons/modifiers
QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
if (!(Qt::NoModifier==mouseEvent->modifiers() && Qt::LeftButton==mouseEvent->button())) {
return false;
}
// check lock
if (isLocked()) {
return false;
} else {
setLocked(true);
}
// cast to widget
QWidget *widget = static_cast<QWidget*>(object);
// check if widget can be dragged from current position
if (isBlackListed(widget) || !canDrag(widget)) {
return false;
}
// retrieve widget's child at event position
QPoint position(mouseEvent->pos());
QWidget *child = widget->childAt(position);
if (!canDrag(widget, child, position)) {
return false;
}
// save target and drag point
_target = widget;
_dragPoint = position;
_globalDragPoint = mouseEvent->globalPos();
_dragAboutToStart = true;
// send a move event to the current child with same position
// if received, it is caught to actually start the drag
QPoint localPoint(_dragPoint);
if (child) {
localPoint = child->mapFrom(widget, localPoint);
} else {
child = widget;
}
QMouseEvent localMouseEvent(QEvent::MouseMove, localPoint, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
qApp->sendEvent(child, &localMouseEvent);
// never eat event
return false;
}
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 QuickInspector::eventFilter(QObject *receiver, QEvent *event)
{
if (event->type() == QEvent::MouseButtonRelease) {
QMouseEvent *mouseEv = static_cast<QMouseEvent*>(event);
if (mouseEv->button() == Qt::LeftButton &&
mouseEv->modifiers() == (Qt::ControlModifier | Qt::ShiftModifier)) {
QQuickWindow *window = qobject_cast<QQuickWindow*>(receiver);
if (window && window->contentItem()) {
QQuickItem *item = recursiveChiltAt(window->contentItem(), mouseEv->pos());
m_probe->selectObject(item);
}
}
}
return QObject::eventFilter(receiver, event);
}
void mousePressEvent (State& state, const QMouseEvent& event) {
if (event.button () == Qt::MiddleButton) {
this->oldPos = ViewUtil::toIVec2 (event);
if (event.modifiers () == Qt::ControlModifier) {
Camera& cam = state.camera ();
WingedFaceIntersection intersection;
if (state.scene ().intersects (cam.ray (ViewUtil::toIVec2 (event)), intersection)) {
cam.set ( intersection.position ()
, cam.position () - intersection.position ()
, cam.up () );
state.mainWindow ().mainWidget ().glWidget ().update ();
}
}
}
}
bool UBMousePressFilter::eventFilter(QObject *obj, QEvent *event)
{
const bool isMousePress = event->type() == QEvent::MouseButtonPress;
const bool isMouseRelease = event->type() == QEvent::MouseButtonRelease;
const bool isMouseMove = event->type() == QEvent::MouseMove;
if (isMousePress)
{
QMouseEvent * mouseEvent = static_cast<QMouseEvent *>(event);
if (mouseEvent)
{
if (mPendingEvent)
{
delete mPendingEvent;
}
mPendingEvent = new QMouseEvent(QEvent::MouseButtonDblClick,
mouseEvent->pos(), mouseEvent->globalPos(),
mouseEvent->button(), mouseEvent->buttons(),
mouseEvent->modifiers());
mObject = obj;
QTimer::singleShot(1000, this, SLOT(mouseDownElapsed()));
}
}
else if (isMouseRelease || isMouseMove)
{
if (mPendingEvent)
{
QTabletEvent * tabletEvent = static_cast<QTabletEvent *>(event);
QPoint point = tabletEvent->globalPos() - mPendingEvent->globalPos();
if (isMouseRelease || point.manhattanLength() > QApplication::startDragDistance())
{
delete mPendingEvent;
mPendingEvent = 0;
mObject = 0;
}
}
}
return false;
}
bool ptToolBox::eventFilter(QObject* ASender, QEvent* AEvent) {
if (ASender == FHelpIcon && AEvent->type() == QEvent::MouseButtonRelease) {
QMouseEvent* e = (QMouseEvent*)AEvent;
if (e->button() == Qt::LeftButton) {
QDesktopServices::openUrl(QUrl(FFilter->helpUri()));
return true;
} else {
return false;
}
} else if (ASender == FHeaderWidget && AEvent->type() == QEvent::MouseButtonRelease) {
QMouseEvent* hEvent = (QMouseEvent*)AEvent;
if (hEvent->button() == Qt::LeftButton && hEvent->modifiers() == Qt::NoModifier) {
toggleFolded();
return true;
} else if (hEvent->button() == Qt::LeftButton && hEvent->modifiers() == Qt::ControlModifier) {
// toggle block
createMenuActions();
FBlockAction->activate(QAction::Trigger);
return true;
} else if (hEvent->button() == Qt::RightButton) {
// context menu
execContextMenu(hEvent->globalPos());
return true;
} else {
return false;
}
} else {
return QWidget::eventFilter(ASender, AEvent);
}
}
