static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg) {
case WM_DESTROY:
PostQuitMessage(0);
break;
case WM_ERASEBKGND:
return 0;
case WM_PAINT:
renderFrame();
return 0;
case WM_MOUSEMOVE: return mouseEvent(lParam, 0);
case WM_LBUTTONDOWN: return mouseEvent(lParam, 1);
case WM_LBUTTONUP: return mouseEvent(lParam, -1);
case WM_RBUTTONDOWN: return mouseEvent(lParam, 2);
case WM_RBUTTONUP: return mouseEvent(lParam, -2);
case WM_SIZE:
InvalidateRect(hWnd, NULL, FALSE);
width = LOWORD(lParam);
height = HIWORD(lParam);
glViewport(0, 0, width, height);
break;
default:
break;
}
return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
bool NaClApplication::HandleInputEvent(const pp::InputEvent& event) {
/* Don't handle anything during switch from/to fullscreen */
if(flags & Flag::FullscreenSwitchInProgress) return false;
Flags tmpFlags = flags;
switch(event.GetType()) {
case PP_INPUTEVENT_TYPE_KEYDOWN:
case PP_INPUTEVENT_TYPE_KEYUP: {
pp::KeyboardInputEvent keyEvent(event);
KeyEvent e(static_cast<KeyEvent::Key>(keyEvent.GetKeyCode()), static_cast<InputEvent::Modifier>(keyEvent.GetModifiers()));
event.GetType() == PP_INPUTEVENT_TYPE_KEYDOWN ? keyPressEvent(e) : keyReleaseEvent(e);
if(!e.isAccepted()) return false;
break;
}
case PP_INPUTEVENT_TYPE_MOUSEDOWN:
case PP_INPUTEVENT_TYPE_MOUSEUP: {
pp::MouseInputEvent mouseEvent(event);
MouseEvent e(static_cast<MouseEvent::Button>(mouseEvent.GetButton()), {mouseEvent.GetPosition().x(), mouseEvent.GetPosition().y()}, static_cast<InputEvent::Modifier>(mouseEvent.GetModifiers()));
event.GetType() == PP_INPUTEVENT_TYPE_MOUSEDOWN ? mousePressEvent(e) : mouseReleaseEvent(e);
if(!e.isAccepted()) return false;
break;
}
case PP_INPUTEVENT_TYPE_WHEEL: {
pp::WheelInputEvent wheelEvent(event);
if(Math::TypeTraits<Float>::equals(wheelEvent.GetDelta().y(), 0.0f)) return false;
MouseEvent e(wheelEvent.GetDelta().y() > 0 ? MouseEvent::Button::WheelUp : MouseEvent::Button::WheelDown, {}, static_cast<InputEvent::Modifier>(wheelEvent.GetModifiers()));
mousePressEvent(e);
if(!e.isAccepted()) return false;
break;
}
case PP_INPUTEVENT_TYPE_MOUSEMOVE: {
pp::MouseInputEvent mouseEvent(event);
MouseMoveEvent e({mouseEvent.GetPosition().x(), mouseEvent.GetPosition().y()}, {mouseEvent.GetMovement().x(), mouseEvent.GetMovement().y()}, static_cast<InputEvent::Modifier>(mouseEvent.GetModifiers()));
mouseMoveEvent(e);
if(!e.isAccepted()) return false;
break;
}
default: return false;
}
/* Assume everything is properly sequential here */
CORRADE_INTERNAL_ASSERT((tmpFlags & Flag::SwapInProgress) == (flags & Flag::SwapInProgress));
/* Redraw, if it won't be handled after swap automatically */
if((flags & Flag::Redraw) && !(flags & Flag::SwapInProgress)) {
flags &= ~Flag::Redraw;
drawEvent();
}
return true;
}
static void mouseEvent(MouseAction _action, QWindow* _window, QObject* _item, Qt::MouseButton _button, Qt::KeyboardModifiers _stateKey, QPointF _pos, int _delay = -1)
{
if (_delay == -1 || _delay < 30)
_delay = 30;
if (_delay > 0)
QTest::qWait(_delay);
if (_action == MouseClick)
{
mouseEvent(MousePress, _window, _item, _button, _stateKey, _pos);
mouseEvent(MouseRelease, _window, _item, _button, _stateKey, _pos);
return;
}
QPoint pos = _pos.toPoint();
QQuickItem* sgitem = qobject_cast<QQuickItem*>(_item);
if (sgitem)
pos = sgitem->mapToScene(_pos).toPoint();
_stateKey &= static_cast<unsigned int>(Qt::KeyboardModifierMask);
QMouseEvent me(QEvent::User, QPoint(), Qt::LeftButton, _button, _stateKey);
switch (_action)
{
case MousePress:
me = QMouseEvent(QEvent::MouseButtonPress, pos, _window->mapToGlobal(pos), _button, _button, _stateKey);
break;
case MouseRelease:
me = QMouseEvent(QEvent::MouseButtonRelease, pos, _window->mapToGlobal(pos), _button, 0, _stateKey);
break;
case MouseDoubleClick:
me = QMouseEvent(QEvent::MouseButtonDblClick, pos, _window->mapToGlobal(pos), _button, _button, _stateKey);
break;
case MouseMove:
// with move event the _button is NoButton, but 'buttons' holds the currently pressed buttons
me = QMouseEvent(QEvent::MouseMove, pos, _window->mapToGlobal(pos), Qt::NoButton, _button, _stateKey);
break;
default:
break;
}
QSpontaneKeyEvent::setSpontaneous(&me);
if (!qApp->notify(_window, &me))
{
static const char* mouseActionNames[] = { "MousePress", "MouseRelease", "MouseClick", "MouseDoubleClick", "MouseMove" };
QString warning = QString::fromLatin1("Mouse event \"%1\" not accepted by receiving window");
QWARN(warning.arg(QString::fromLatin1(mouseActionNames[static_cast<int>(_action)])).toLatin1().data());
}
}
void KisColorSelector::mouseMoveEvent(QMouseEvent* e)
{
KisColorSelectorBase::mouseMoveEvent(e);
mouseEvent(e);
e->accept();
}
void InventoryTreeView::contextMenuEvent(QContextMenuEvent *event)
{
// Do mousePressEvent so that the right item gets selected before we show the menu
// (right-click doesn't do this automatically).
QMouseEvent mouseEvent(QEvent::MouseButtonPress, event->pos(), event->globalPos(),
Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
mousePressEvent(&mouseEvent);
QModelIndex index = selectionModel()->currentIndex();
if (!index.isValid())
return;
QMenu *menu = new QMenu(this);
QListIterator<QAction *> it(actions());
while(it.hasNext())
{
QAction *action = it.next();
if (action->isEnabled())
{
// This is kind of hack, but we might have case that base language is not english.
InventoryAction* act = qobject_cast<InventoryAction* >(action);
QString text = QApplication::translate("Inventory::InventoryWindow", act->GetText().toStdString().c_str());
action->setText(text);
menu->addAction(action);
}
}
if (menu->actions().size() > 1) // separator "action" is always enabled, hence the 1
menu->popup(event->globalPos());
}
nsresult
nsHTMLEditorMouseListener::MouseUp(nsIDOMEvent* aMouseEvent)
{
nsCOMPtr<nsIDOMMouseEvent> mouseEvent ( do_QueryInterface(aMouseEvent) );
if (!mouseEvent) {
//non-ui event passed in. bad things.
return NS_OK;
}
// Don't do anything special if not an HTML editor
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(mEditor);
if (htmlEditor)
{
nsCOMPtr<nsIDOMEventTarget> target;
nsresult res = aMouseEvent->GetTarget(getter_AddRefs(target));
if (NS_FAILED(res)) return res;
if (!target) return NS_ERROR_NULL_POINTER;
nsCOMPtr<nsIDOMElement> element = do_QueryInterface(target);
nsCOMPtr<nsIHTMLObjectResizer> objectResizer = do_QueryInterface(htmlEditor);
PRInt32 clientX, clientY;
mouseEvent->GetClientX(&clientX);
mouseEvent->GetClientY(&clientY);
objectResizer->MouseUp(clientX, clientY, element);
}
return nsTextEditorMouseListener::MouseUp(aMouseEvent);
}
void rspfMouseListener::processEvent(rspfEvent& event)
{
rspfMouseEvent* mEvent = PTR_CAST(rspfMouseEvent, &event);
if(mEvent)
{
mouseEvent(*mEvent);
}
else
{
rspfListener::processEvent(event);
}
// switch(event.getId())
// {
// case RSPF_MOUSE_EVENT_ID:
// {
// = static_cast<rspfMouseEvent*>(&event);
// mouseEvent(*mEvent);
// break;
// }
// default:
// {
// rspfListener::processEvent(event);
// }
// }
}
//================================================================================
void ATHInputManager::SendMouseEvent()
{
ATHKeyList m_liButtonsDown = CheckMouseButtons();
ATHKeyList::iterator itrCurr = m_liButtonsDown.begin();
ATHKeyList::iterator itrEnd = m_liButtonsDown.end();
ATHEvent mouseEvent( AET_MOUSE );
unsigned int unButtonDownIndex = 0;
while( itrCurr != itrEnd )
{
char szButton;
if( MouseButtonPressed( szButton = (*itrCurr ) ) && unButtonDownIndex < 8 )
{
mouseEvent.MSE_szMouseButtonsDown[ unButtonDownIndex ] = szButton;
unButtonDownIndex++;
}
itrCurr++;
}
if( unButtonDownIndex > 0 )
{
mouseEvent.MSE_unPosX = m_fMouseX;
mouseEvent.MSE_unPosY = m_fMouseY;
mouseEvent.m_EventID = AEI_MOUSEDOWN;
m_pEventManager->SendEvent( mouseEvent, AEP_IMMEDIATE );
}
}
void MapControl::mouseMoveEvent(QMouseEvent* evnt)
{
layermanager->mouseEvent(evnt);
emit(mouseEvent(evnt));
/*
// rotating
QMouseEvent* me = new QMouseEvent(evnt->type(), qm.map(QPoint(evnt->x(),evnt->y())), evnt->button(), evnt->buttons(), evnt->modifiers());
evnt = me;
*/
if (mousepressed && mymousemode == Panning)
{
QPoint offset = pre_click_px - QPoint(evnt->x(), evnt->y());
layermanager->scrollView(offset);
pre_click_px = QPoint(evnt->x(), evnt->y());
}
else if (mousepressed && mymousemode == Dragging)
{
current_mouse_pos = QPoint(evnt->x(), evnt->y());
}
// emit(mouseEventCoordinate(evnt, clickToWorldCoordinate(evnt->pos())));
currentWorldCoordinate = clickToWorldCoordinate(evnt->pos());
emit(mouseMoveCoordinateEvent(currentWorldCoordinate));
update();
//emit(mouseEventCoordinate(evnt, clickToWorldCoordinate(evnt->pos())));
}
void InputAPI::SceneReleaseMouseButtons()
{
for(int i = 1; i < MouseEvent::MaxButtonMask; i <<= 1)
if ((heldMouseButtons & i) != 0)
{
// Just like with key release events, we send a very bare-bone release message here as well.
MouseEvent mouseEvent(this);
mouseEvent.eventType = MouseEvent::MouseReleased;
mouseEvent.button = (MouseEvent::MouseButton)i;
mouseEvent.x = lastMouseX;
mouseEvent.y = lastMouseY;
mouseEvent.z = 0;
mouseEvent.relativeX = 0;
mouseEvent.relativeY = 0;
mouseEvent.relativeZ = 0;
mouseEvent.globalX = 0;
mouseEvent.globalY = 0;
mouseEvent.otherButtons = 0;
mouseEvent.timestamp = framework->Frame()->WallClockTime();
TriggerMouseEvent(mouseEvent);
}
}
void QInputGeneratorGeneric::mouseDClick(const QPoint& pos, Qt::MouseButtons state)
{
QTT_TRACE_FUNCTION();
const Qt::MouseButton buttons[] = {Qt::LeftButton, Qt::RightButton, Qt::MidButton, Qt::XButton1, Qt::XButton2};
QWidget *widget=QApplication::widgetAt(pos);
if (pos != currentPos) {
mouseEvent(MouseMove, widget, Qt::NoButton, currentButtons, 0, widget->mapFromGlobal(pos));
currentPos = pos;
}
for (unsigned int i=0; i<sizeof(buttons)/sizeof(Qt::MouseButton); i++) {
if (state.testFlag(buttons[i])) {
qttDebug() << "mouseClick" << pos << buttons[i];
mouseEvent(MouseDClick, widget, buttons[i], state, 0, widget->mapFromGlobal(pos));
}
}
}
/**
* Store mouse coordinates
*/
void EyeDrawWidget::mousePressEvent ( QMouseEvent * event )
{
lastPoint = matrix.map ( event->pos() );
emit mouseEvent ( lastPoint, EyeOSD::mousePress );
mousePressed = true;
//if ( img && event->pos().y() > height() - 20 ) emit pressedAtBottom(); //10 //COMMENTED OUT
}
bool WindowManager::AppEventFilter::appMouseEvent(QObject *object, QEvent *event)
{
Q_UNUSED(object);
// store target window (see later)
QWidget *window(_parent->_target.data()->window());
/*
post some mouseRelease event to the target, in order to counter balance
the mouse press that triggered the drag. Note that it triggers a resetDrag
*/
QMouseEvent mouseEvent(QEvent::MouseButtonRelease, _parent->_dragPoint, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
qApp->sendEvent(_parent->_target.data(), &mouseEvent);
if (QEvent::MouseMove==event->type()) {
/*
HACK: quickly move the main cursor out of the window and back
this is needed to get the focus right for the window children
the origin of this issue is unknown at the moment
*/
const QPoint cursor = QCursor::pos();
QCursor::setPos(window->mapToGlobal(window->rect().topRight()) + QPoint(1, 0));
QCursor::setPos(cursor);
}
return true;
}
void wxWebView::OnContextMenuEvents(wxContextMenuEvent& event)
{
m_impl->page->contextMenuController()->clearContextMenu();
wxPoint localEventPoint = ScreenToClient(event.GetPosition());
if (!m_mainFrame)
return;
WebCore::Frame* focusedFrame = m_mainFrame->GetFrame();
if (!focusedFrame->view())
return;
//Create WebCore mouse event from the wxContextMenuEvent
wxMouseEvent mouseEvent(wxEVT_RIGHT_DOWN);
mouseEvent.m_x = localEventPoint.x;
mouseEvent.m_y = localEventPoint.y;
WebCore::PlatformMouseEvent wkEvent(mouseEvent, event.GetPosition());
bool handledEvent = focusedFrame->eventHandler()->sendContextMenuEvent(wkEvent);
if (!handledEvent)
return;
WebCore::ContextMenu* coreMenu = m_impl->page->contextMenuController()->contextMenu();
if (!coreMenu)
return;
WebCore::PlatformMenuDescription menuWx = coreMenu->platformDescription();
if (!menuWx)
return;
PopupMenu(menuWx, localEventPoint);
}
NS_IMETHODIMP
nsHTMLEditorEventListener::MouseUp(nsIDOMEvent* aMouseEvent)
{
NS_ENSURE_TRUE(mEditor, NS_ERROR_NOT_AVAILABLE);
nsCOMPtr<nsIDOMMouseEvent> mouseEvent ( do_QueryInterface(aMouseEvent) );
if (!mouseEvent) {
//non-ui event passed in. bad things.
return NS_OK;
}
nsHTMLEditor* htmlEditor = GetHTMLEditor();
nsCOMPtr<nsIDOMEventTarget> target;
nsresult res = aMouseEvent->GetTarget(getter_AddRefs(target));
NS_ENSURE_SUCCESS(res, res);
NS_ENSURE_TRUE(target, NS_ERROR_NULL_POINTER);
nsCOMPtr<nsIDOMElement> element = do_QueryInterface(target);
PRInt32 clientX, clientY;
mouseEvent->GetClientX(&clientX);
mouseEvent->GetClientY(&clientY);
htmlEditor->MouseUp(clientX, clientY, element);
return nsEditorEventListener::MouseUp(aMouseEvent);
}
void CanvasQt::wheelEvent(QWheelEvent* e){
MouseEvent::MouseWheelOrientation orientation;
if (e->orientation() == Qt::Horizontal) {
orientation = MouseEvent::MOUSE_WHEEL_HORIZONTAL;
} else {
orientation = MouseEvent::MOUSE_WHEEL_VERTICAL;
}
#if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
QPoint numPixels = e->pixelDelta();
QPoint numDegrees = e->angleDelta() / 8 / 15;
#else
QPoint numPixels;
QPoint numDegrees = QPoint(0, e->delta() / 8 / 15);
#endif
int numSteps = 0;
if (!numPixels.isNull()) {
numSteps = (orientation==MouseEvent::MOUSE_WHEEL_HORIZONTAL? numPixels.x() : numPixels.y()) / 5;
} else if (!numDegrees.isNull()) {
numSteps = (orientation==MouseEvent::MOUSE_WHEEL_HORIZONTAL? numDegrees.x() : numDegrees.y());
}
ivec2 screenPos(e->pos().x(), e->pos().y());
ivec2 screenPosInvY(screenPos.x, static_cast<int>(getScreenDimensions().y) - 1 - screenPos.y);
MouseEvent mouseEvent(screenPos, numSteps,
EventConverterQt::getMouseWheelButton(e), MouseEvent::MOUSE_STATE_WHEEL, orientation,
EventConverterQt::getModifier(e), getScreenDimensions(),
getDepthValueAtCoord(screenPosInvY));
e->accept();
Canvas::mouseWheelEvent(&mouseEvent);
}
NS_IMETHODIMP
nsXULTooltipListener::MouseMove(nsIDOMEvent* aMouseEvent)
{
if (!sShowTooltips)
return NS_OK;
// stash the coordinates of the event so that we can still get back to it from within the
// timer callback. On win32, we'll get a MouseMove event even when a popup goes away --
// even when the mouse doesn't change position! To get around this, we make sure the
// mouse has really moved before proceeding.
nsCOMPtr<nsIDOMMouseEvent> mouseEvent(do_QueryInterface(aMouseEvent));
PRInt32 newMouseX, newMouseY;
mouseEvent->GetScreenX(&newMouseX);
mouseEvent->GetScreenY(&newMouseY);
if (mMouseScreenX == newMouseX && mMouseScreenY == newMouseY)
return NS_OK;
mMouseScreenX = newMouseX;
mMouseScreenY = newMouseY;
mCachedMouseEvent = aMouseEvent;
nsCOMPtr<nsIDOMEventTarget> eventTarget;
aMouseEvent->GetCurrentTarget(getter_AddRefs(eventTarget));
nsCOMPtr<nsIContent> sourceContent = do_QueryInterface(eventTarget);
mSourceNode = do_GetWeakReference(sourceContent);
#ifdef MOZ_XUL
mIsSourceTree = sourceContent->Tag() == nsGkAtoms::treechildren;
if (mIsSourceTree)
CheckTreeBodyMove(mouseEvent);
#endif
// as the mouse moves, we want to make sure we reset the timer to show it,
// so that the delay is from when the mouse stops moving, not when it enters
// the node.
KillTooltipTimer();
// If the mouse moves while the tooltip is up, don't do anything. We make it
// go away only if it times out or leaves the target node. If nothing is
// showing, though, we have to do the work.
nsCOMPtr<nsIContent> currentTooltip = do_QueryReferent(mCurrentTooltip);
if (!currentTooltip) {
mTooltipTimer = do_CreateInstance("@mozilla.org/timer;1");
if (mTooltipTimer) {
aMouseEvent->GetTarget(getter_AddRefs(eventTarget));
nsCOMPtr<nsIDOMNode> targetNode = do_QueryInterface(eventTarget);
mTargetNode = do_GetWeakReference(targetNode);
if (targetNode) {
nsresult rv = mTooltipTimer->InitWithFuncCallback(sTooltipCallback, this,
kTooltipShowTime, nsITimer::TYPE_ONE_SHOT);
if (NS_FAILED(rv)) {
mTargetNode = nsnull;
mSourceNode = nsnull;
}
}
}
}
return NS_OK;
}
bool TestService::mouseClick(QObject* _item, qreal _x, qreal _y, int _button, int _modifiers, int _delay)
{
QWindow* window = qobject_cast<QWindow*>(_item);
if (!window)
window = eventWindow(_item);
mouseEvent(MouseClick, window, _item, Qt::MouseButton(_button), Qt::KeyboardModifiers(_modifiers), QPointF(_x, _y), _delay);
return true;
}
void TouchDispatcher::dispatchAsMouse(
QTouchDevice * /*device*/,
Qt::KeyboardModifiers modifiers,
const QList<QTouchEvent::TouchPoint> &touchPoints,
ulong timestamp)
{
// TODO: Detect double clicks in order to synthesize QEvent::MouseButtonDblClick events accordingly
Q_ASSERT(!touchPoints.isEmpty());
const QTouchEvent::TouchPoint *touchMouse = nullptr;
if (m_touchMouseId != -1) {
for (int i = 0; i < touchPoints.count() && !touchMouse; ++i) {
const auto &touchPoint = touchPoints.at(i);
if (touchPoint.id() == m_touchMouseId) {
touchMouse = &touchPoint;
}
}
Q_ASSERT(touchMouse);
if (!touchMouse) {
// should not happen, but deal with it just in case.
qWarning("[TouchDispatcher] Didn't find touch with id %d, used for mouse pointer emulation.",
m_touchMouseId);
m_touchMouseId = touchPoints.at(0).id();
touchMouse = &touchPoints.at(0);
}
} else {
// Try to find a new touch for mouse emulation
for (int i = 0; i < touchPoints.count() && !touchMouse; ++i) {
const auto &touchPoint = touchPoints.at(i);
if (touchPoint.state() == Qt::TouchPointPressed) {
touchMouse = &touchPoint;
m_touchMouseId = touchMouse->id();
}
}
}
if (touchMouse) {
QEvent::Type eventType;
if (touchMouse->state() == Qt::TouchPointPressed) {
eventType = QEvent::MouseButtonPress;
} else if (touchMouse->state() == Qt::TouchPointReleased) {
eventType = QEvent::MouseButtonRelease;
m_touchMouseId = -1;
} else {
eventType = QEvent::MouseMove;
}
QScopedPointer<QMouseEvent> mouseEvent(touchToMouseEvent(eventType, *touchMouse, timestamp, modifiers,
true /* transformNeeded */));
ugDebug("dispatching " << qPrintable(mouseEventToString(mouseEvent.data()))
<< " to " << m_targetItem.data());
QCoreApplication::sendEvent(m_targetItem.data(), mouseEvent.data());
}
}
bool
QcMapItem::send_mouse_event(QMouseEvent * event)
{
qInfo() << event;
QPointF local_position = mapFromScene(event->windowPos());
QQuickWindow * _window = window();
QQuickItem * grabber = _window ? _window->mouseGrabberItem() : nullptr;
// Fixme: faster ? / duplicated
bool is_mouse_area = !grabber or QString(grabber->metaObject()->className()).startsWith(QStringLiteral("QQuickMouseArea"));
bool steal_event = m_gesture_area->is_active(); // means pan or pinch is active
// grabber is QQuickMouseArea, steal_event is false first then true
// qInfo() << event << "\ngrabber" << grabber << "\nsteal_event" << steal_event << is_mouse_area;
if (is_mouse_area and (steal_event or contains(local_position)) and (!grabber or !grabber->keepMouseGrab())) {
QScopedPointer<QMouseEvent> mouseEvent(QQuickWindowPrivate::cloneMouseEvent(event, &local_position));
mouseEvent->setAccepted(false);
switch (mouseEvent->type()) {
case QEvent::MouseMove:
m_gesture_area->handle_mouse_move_event(mouseEvent.data());
break;
case QEvent::MouseButtonPress:
m_gesture_area->handle_mouse_press_event(mouseEvent.data());
break;
case QEvent::MouseButtonRelease:
m_gesture_area->handle_mouse_release_event(mouseEvent.data());
break;
default:
break;
}
steal_event = m_gesture_area->is_active(); // recheck value
// Fixme: duplicated code ???
grabber = _window ? _window->mouseGrabberItem() : nullptr;
// qInfo() << "grabber" << grabber << "\nsteal_event" << steal_event;
if (grabber and steal_event and !grabber->keepMouseGrab() and grabber != this) {
// qInfo() << "grab mouse";
grabMouse();
}
if (steal_event) {
event->setAccepted(true);
return true; // do not deliver event
} else
return false; // deliver event
} else {
// ungrab if necessary and deliver event
if (event->type() == QEvent::MouseButtonRelease
and (_window and _window->mouseGrabberItem() == this))
// qInfo() << "ungrab mouse";
ungrabMouse();
return false; // deliver event
}
}
void KMaskImageItem::hoverMoveEvent( QGraphicsSceneHoverEvent * event )
{
bool bFilter = filterMessage(event->pos());
event->setAccepted(bFilter);
if(bFilter)
{
emit mouseEvent(event);
}
}
void KMaskImageItem::mouseDoubleClickEvent( QGraphicsSceneMouseEvent * event )
{
bool bFilter = filterMessage(event->pos());
event->setAccepted(bFilter);
if(bFilter)
{
emit mouseEvent(event);
}
}
void OctreeWindow::mouse(int button, int state, int x, int y) {
if(button == 0) {
if(state == GLUT_DOWN) {
m_lastMouseLocation = int2(x, y);
}
}
mouseEvent(button, state, x, y);
printf("mouse button %d state %d x %d y %d\n", button, state, x, y);
}
bool QDeclarativeMouseArea::sendMouseEvent(QGraphicsSceneMouseEvent *event)
{
Q_D(QDeclarativeMouseArea);
QGraphicsSceneMouseEvent mouseEvent(event->type());
QRectF myRect = mapToScene(QRectF(0, 0, width(), height())).boundingRect();
QGraphicsScene *s = scene();
QDeclarativeItem *grabber = s ? qobject_cast<QDeclarativeItem*>(s->mouseGrabberItem()) : 0;
bool stealThisEvent = d->stealMouse;
if ((stealThisEvent || myRect.contains(event->scenePos().toPoint())) && (!grabber || !grabber->keepMouseGrab())) {
mouseEvent.setAccepted(false);
for (int i = 0x1; i <= 0x10; i <<= 1) {
if (event->buttons() & i) {
Qt::MouseButton button = Qt::MouseButton(i);
mouseEvent.setButtonDownPos(button, mapFromScene(event->buttonDownPos(button)));
}
}
mouseEvent.setScenePos(event->scenePos());
mouseEvent.setLastScenePos(event->lastScenePos());
mouseEvent.setPos(mapFromScene(event->scenePos()));
mouseEvent.setLastPos(mapFromScene(event->lastScenePos()));
switch(mouseEvent.type()) {
case QEvent::GraphicsSceneMouseMove:
mouseMoveEvent(&mouseEvent);
break;
case QEvent::GraphicsSceneMousePress:
mousePressEvent(&mouseEvent);
break;
case QEvent::GraphicsSceneMouseRelease:
mouseReleaseEvent(&mouseEvent);
break;
default:
break;
}
grabber = qobject_cast<QDeclarativeItem*>(s->mouseGrabberItem());
if (grabber && stealThisEvent && !grabber->keepMouseGrab() && grabber != this)
grabMouse();
return stealThisEvent;
}
if (mouseEvent.type() == QEvent::GraphicsSceneMouseRelease) {
if (d->pressed) {
d->pressed = false;
d->stealMouse = false;
if (s && s->mouseGrabberItem() == this)
ungrabMouse();
emit canceled();
emit pressedChanged();
if (d->hovered) {
d->hovered = false;
emit hoveredChanged();
}
}
}
return false;
}
void FloatingFlickable::onDragAreaDraggingChanged(bool dragging)
{
if (dragging && !m_mousePressed) {
QMouseEvent mouseEvent(QEvent::MouseButtonPress,
QPointF(m_dragArea->touchX(),m_dragArea->touchY()),
Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
QCoreApplication::sendEvent(m_flickable, &mouseEvent);
m_mousePressed = true;
} else if (!dragging && m_mousePressed) {
QMouseEvent mouseEvent(QEvent::MouseButtonRelease,
QPointF(m_dragArea->touchX(),m_dragArea->touchY()),
Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
QCoreApplication::sendEvent(m_flickable, &mouseEvent);
m_mousePressed = false;
}
}
bool Game::mouseEventInternal(Mouse::MouseEvent evt, int x, int y, int wheelDelta)
{
if (mouseEvent(evt, x, y, wheelDelta))
return true;
if (_scriptTarget)
return _scriptTarget->fireScriptEvent<bool>(GP_GET_SCRIPT_EVENT(GameScriptTarget, mouseEvent), evt, x, y, wheelDelta);
return false;
}
void QInputGeneratorGeneric::mouseMove(const QPoint& pos)
{
QTT_TRACE_FUNCTION();
qttDebug() << "mouseMove" << pos;
QWidget *widget=QApplication::widgetAt(pos);
if (pos != currentPos) {
currentPos = pos;
}
mouseEvent(MouseMove, widget, Qt::NoButton, currentButtons, 0, widget->mapFromGlobal(pos));
}
XAbstractCanvasController::UsedFlags XAbstractCanvasController::triggerMouseEvent(MouseEventType type,
QPoint point,
Qt::MouseButton triggerButton,
Qt::MouseButtons buttonsDown,
Qt::KeyboardModifiers modifiers)
{
UsedFlags ret = mouseEvent(type, point, triggerButton, buttonsDown, modifiers);
_lastKnownMousePosition = point;
return ret;
}
/**
* Move page
*/
void EyeDrawWidget::mouseMoveEvent ( QMouseEvent *event )
{
if ( mousePressed )
{
delta = lastPoint - matrix.map ( event->pos() );
lastPoint = matrix.map ( event->pos() );
emit mouseEvent ( lastPoint, EyeOSD::mouseMove );
repaint();
}
}
bool WWidget::event(QEvent* e) {
if (e->type() == QEvent::ToolTip) {
updateTooltip();
} else if (isEnabled()) {
switch(e->type()) {
case QEvent::TouchBegin:
case QEvent::TouchUpdate:
case QEvent::TouchEnd:
{
QTouchEvent* touchEvent = dynamic_cast<QTouchEvent*>(e);
if (touchEvent->deviceType() != QTouchEvent::TouchScreen) {
break;
}
// fake a mouse event!
QEvent::Type eventType = QEvent::None;
switch (touchEvent->type()) {
case QEvent::TouchBegin:
eventType = QEvent::MouseButtonPress;
if (touchIsRightButton()) {
// touch is right click
m_activeTouchButton = Qt::RightButton;
} else {
m_activeTouchButton = Qt::LeftButton;
}
break;
case QEvent::TouchUpdate:
eventType = QEvent::MouseMove;
break;
case QEvent::TouchEnd:
eventType = QEvent::MouseButtonRelease;
break;
default:
DEBUG_ASSERT(false);
break;
}
const QTouchEvent::TouchPoint &touchPoint =
touchEvent->touchPoints().first();
QMouseEvent mouseEvent(eventType,
touchPoint.pos().toPoint(),
touchPoint.screenPos().toPoint(),
m_activeTouchButton, // Button that causes the event
Qt::NoButton, // Not used, so no need to fake a proper value.
touchEvent->modifiers());
return QWidget::event(&mouseEvent);
}
default:
break;
}
}
return QWidget::event(e);
}
