| /* |
| * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies) |
| * Copyright (C) 2009 Torch Mobile Inc. http://www.torchmobile.com/ |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of |
| * its contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY |
| * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
| * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY |
| * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
| * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #include "config.h" |
| #include "EventSenderQt.h" |
| |
| #include <QGraphicsSceneMouseEvent> |
| #include <QtTest/QtTest> |
| |
| #define KEYCODE_DEL 127 |
| #define KEYCODE_BACKSPACE 8 |
| #define KEYCODE_LEFTARROW 0xf702 |
| #define KEYCODE_RIGHTARROW 0xf703 |
| #define KEYCODE_UPARROW 0xf700 |
| #define KEYCODE_DOWNARROW 0xf701 |
| |
| // Ports like Gtk and Windows expose a different approach for their zooming |
| // API if compared to Qt: they have specific methods for zooming in and out, |
| // as well as a settable zoom factor, while Qt has only a 'setZoomValue' method. |
| // Hence Qt DRT adopts a fixed zoom-factor (1.2) for compatibility. |
| #define ZOOM_STEP 1.2 |
| |
| #define DRT_MESSAGE_DONE (QEvent::User + 1) |
| |
| struct DRTEventQueue { |
| QEvent* m_event; |
| int m_delay; |
| }; |
| |
| static DRTEventQueue eventQueue[1024]; |
| static unsigned endOfQueue; |
| static unsigned startOfQueue; |
| |
| EventSender::EventSender(QWebPage* parent) |
| : QObject(parent) |
| { |
| m_page = parent; |
| m_mouseButtonPressed = false; |
| m_drag = false; |
| memset(eventQueue, 0, sizeof(eventQueue)); |
| endOfQueue = 0; |
| startOfQueue = 0; |
| m_eventLoop = 0; |
| m_currentButton = 0; |
| resetClickCount(); |
| m_page->view()->installEventFilter(this); |
| // So that we can match Scrollbar::pixelsPerLineStep() in WheelEventQt.cpp and |
| // pass fast/events/platform-wheelevent-in-scrolling-div.html |
| QApplication::setWheelScrollLines(2); |
| } |
| |
| void EventSender::mouseDown(int button) |
| { |
| Qt::MouseButton mouseButton; |
| switch (button) { |
| case 0: |
| mouseButton = Qt::LeftButton; |
| break; |
| case 1: |
| mouseButton = Qt::MidButton; |
| break; |
| case 2: |
| mouseButton = Qt::RightButton; |
| break; |
| case 3: |
| // fast/events/mouse-click-events expects the 4th button to be treated as the middle button |
| mouseButton = Qt::MidButton; |
| break; |
| default: |
| mouseButton = Qt::LeftButton; |
| break; |
| } |
| |
| // only consider a click to count, an event originated by the |
| // same previous button and at the same position. |
| if (m_currentButton == button |
| && m_mousePos == m_clickPos |
| && m_clickTimer.isActive()) |
| m_clickCount++; |
| else |
| m_clickCount = 1; |
| |
| m_currentButton = button; |
| m_clickPos = m_mousePos; |
| m_mouseButtons |= mouseButton; |
| |
| // qDebug() << "EventSender::mouseDown" << frame; |
| QEvent* event; |
| if (isGraphicsBased()) { |
| event = createGraphicsSceneMouseEvent((m_clickCount == 2) ? |
| QEvent::GraphicsSceneMouseDoubleClick : QEvent::GraphicsSceneMousePress, |
| m_mousePos, m_mousePos, mouseButton, m_mouseButtons, Qt::NoModifier); |
| } else { |
| event = new QMouseEvent((m_clickCount == 2) ? QEvent::MouseButtonDblClick : |
| QEvent::MouseButtonPress, m_mousePos, m_mousePos, |
| mouseButton, m_mouseButtons, Qt::NoModifier); |
| } |
| |
| sendOrQueueEvent(event); |
| |
| m_clickTimer.start(QApplication::doubleClickInterval(), this); |
| } |
| |
| void EventSender::mouseUp(int button) |
| { |
| Qt::MouseButton mouseButton; |
| switch (button) { |
| case 0: |
| mouseButton = Qt::LeftButton; |
| break; |
| case 1: |
| mouseButton = Qt::MidButton; |
| break; |
| case 2: |
| mouseButton = Qt::RightButton; |
| break; |
| case 3: |
| // fast/events/mouse-click-events expects the 4th button to be treated as the middle button |
| mouseButton = Qt::MidButton; |
| break; |
| default: |
| mouseButton = Qt::LeftButton; |
| break; |
| } |
| |
| m_mouseButtons &= ~mouseButton; |
| |
| // qDebug() << "EventSender::mouseUp" << frame; |
| QEvent* event; |
| if (isGraphicsBased()) { |
| event = createGraphicsSceneMouseEvent(QEvent::GraphicsSceneMouseRelease, |
| m_mousePos, m_mousePos, mouseButton, m_mouseButtons, Qt::NoModifier); |
| } else { |
| event = new QMouseEvent(QEvent::MouseButtonRelease, |
| m_mousePos, m_mousePos, mouseButton, m_mouseButtons, Qt::NoModifier); |
| } |
| |
| sendOrQueueEvent(event); |
| } |
| |
| void EventSender::mouseMoveTo(int x, int y) |
| { |
| // qDebug() << "EventSender::mouseMoveTo" << x << y; |
| m_mousePos = QPoint(x, y); |
| |
| QEvent* event; |
| if (isGraphicsBased()) { |
| event = createGraphicsSceneMouseEvent(QEvent::GraphicsSceneMouseMove, |
| m_mousePos, m_mousePos, Qt::NoButton, m_mouseButtons, Qt::NoModifier); |
| } else { |
| event = new QMouseEvent(QEvent::MouseMove, |
| m_mousePos, m_mousePos, Qt::NoButton, m_mouseButtons, Qt::NoModifier); |
| } |
| |
| sendOrQueueEvent(event); |
| } |
| |
| #ifndef QT_NO_WHEELEVENT |
| void EventSender::mouseScrollBy(int x, int y) |
| { |
| continuousMouseScrollBy((x*120), (y*120)); |
| } |
| |
| void EventSender::continuousMouseScrollBy(int x, int y) |
| { |
| // continuousMouseScrollBy() mimics devices that send fine-grained scroll events where the 'delta' specified is not the usual |
| // multiple of 120. See http://doc.qt.nokia.com/4.6/qwheelevent.html#delta for a good explanation of this. |
| if (x) { |
| QEvent* event; |
| if (isGraphicsBased()) { |
| event = createGraphicsSceneWheelEvent(QEvent::GraphicsSceneWheel, |
| m_mousePos, m_mousePos, x, Qt::NoModifier, Qt::Horizontal); |
| } else |
| event = new QWheelEvent(m_mousePos, m_mousePos, x, m_mouseButtons, Qt::NoModifier, Qt::Horizontal); |
| |
| sendOrQueueEvent(event); |
| } |
| if (y) { |
| QEvent* event; |
| if (isGraphicsBased()) { |
| event = createGraphicsSceneWheelEvent(QEvent::GraphicsSceneWheel, |
| m_mousePos, m_mousePos, y, Qt::NoModifier, Qt::Vertical); |
| } else |
| event = new QWheelEvent(m_mousePos, m_mousePos, y, m_mouseButtons, Qt::NoModifier, Qt::Vertical); |
| |
| sendOrQueueEvent(event); |
| } |
| } |
| #endif |
| |
| void EventSender::leapForward(int ms) |
| { |
| eventQueue[endOfQueue].m_delay = ms; |
| //qDebug() << "EventSender::leapForward" << ms; |
| } |
| |
| void EventSender::keyDown(const QString& string, const QStringList& modifiers, unsigned int location) |
| { |
| QString s = string; |
| Qt::KeyboardModifiers modifs = 0; |
| for (int i = 0; i < modifiers.size(); ++i) { |
| const QString& m = modifiers.at(i); |
| if (m == "ctrlKey") |
| modifs |= Qt::ControlModifier; |
| else if (m == "shiftKey") |
| modifs |= Qt::ShiftModifier; |
| else if (m == "altKey") |
| modifs |= Qt::AltModifier; |
| else if (m == "metaKey") |
| modifs |= Qt::MetaModifier; |
| } |
| if (location == 3) |
| modifs |= Qt::KeypadModifier; |
| int code = 0; |
| if (string.length() == 1) { |
| code = string.unicode()->unicode(); |
| //qDebug() << ">>>>>>>>> keyDown" << code << (char)code; |
| // map special keycodes used by the tests to something that works for Qt/X11 |
| if (code == '\r') { |
| code = Qt::Key_Return; |
| } else if (code == '\t') { |
| code = Qt::Key_Tab; |
| if (modifs == Qt::ShiftModifier) |
| code = Qt::Key_Backtab; |
| s = QString(); |
| } else if (code == KEYCODE_DEL || code == KEYCODE_BACKSPACE) { |
| code = Qt::Key_Backspace; |
| if (modifs == Qt::AltModifier) |
| modifs = Qt::ControlModifier; |
| s = QString(); |
| } else if (code == 'o' && modifs == Qt::ControlModifier) { |
| // Mimic the emacs ctrl-o binding on Mac by inserting a paragraph |
| // separator and then putting the cursor back to its original |
| // position. Allows us to pass emacs-ctrl-o.html |
| s = QLatin1String("\n"); |
| code = '\n'; |
| modifs = 0; |
| QKeyEvent event(QEvent::KeyPress, code, modifs, s); |
| sendEvent(m_page, &event); |
| QKeyEvent event2(QEvent::KeyRelease, code, modifs, s); |
| sendEvent(m_page, &event2); |
| s = QString(); |
| code = Qt::Key_Left; |
| } else if (code == 'y' && modifs == Qt::ControlModifier) { |
| s = QLatin1String("c"); |
| code = 'c'; |
| } else if (code == 'k' && modifs == Qt::ControlModifier) { |
| s = QLatin1String("x"); |
| code = 'x'; |
| } else if (code == 'a' && modifs == Qt::ControlModifier) { |
| s = QString(); |
| code = Qt::Key_Home; |
| modifs = 0; |
| } else if (code == KEYCODE_LEFTARROW) { |
| s = QString(); |
| code = Qt::Key_Left; |
| if (modifs & Qt::MetaModifier) { |
| code = Qt::Key_Home; |
| modifs &= ~Qt::MetaModifier; |
| } |
| } else if (code == KEYCODE_RIGHTARROW) { |
| s = QString(); |
| code = Qt::Key_Right; |
| if (modifs & Qt::MetaModifier) { |
| code = Qt::Key_End; |
| modifs &= ~Qt::MetaModifier; |
| } |
| } else if (code == KEYCODE_UPARROW) { |
| s = QString(); |
| code = Qt::Key_Up; |
| if (modifs & Qt::MetaModifier) { |
| code = Qt::Key_PageUp; |
| modifs &= ~Qt::MetaModifier; |
| } |
| } else if (code == KEYCODE_DOWNARROW) { |
| s = QString(); |
| code = Qt::Key_Down; |
| if (modifs & Qt::MetaModifier) { |
| code = Qt::Key_PageDown; |
| modifs &= ~Qt::MetaModifier; |
| } |
| } else if (code == 'a' && modifs == Qt::ControlModifier) { |
| s = QString(); |
| code = Qt::Key_Home; |
| modifs = 0; |
| } else |
| code = string.unicode()->toUpper().unicode(); |
| } else { |
| //qDebug() << ">>>>>>>>> keyDown" << string; |
| |
| if (string.startsWith(QLatin1Char('F')) && string.count() <= 3) { |
| s = s.mid(1); |
| int functionKey = s.toInt(); |
| Q_ASSERT(functionKey >= 1 && functionKey <= 35); |
| code = Qt::Key_F1 + (functionKey - 1); |
| // map special keycode strings used by the tests to something that works for Qt/X11 |
| } else if (string == QLatin1String("leftArrow")) { |
| s = QString(); |
| code = Qt::Key_Left; |
| } else if (string == QLatin1String("rightArrow")) { |
| s = QString(); |
| code = Qt::Key_Right; |
| } else if (string == QLatin1String("upArrow")) { |
| s = QString(); |
| code = Qt::Key_Up; |
| } else if (string == QLatin1String("downArrow")) { |
| s = QString(); |
| code = Qt::Key_Down; |
| } else if (string == QLatin1String("pageUp")) { |
| s = QString(); |
| code = Qt::Key_PageUp; |
| } else if (string == QLatin1String("pageDown")) { |
| s = QString(); |
| code = Qt::Key_PageDown; |
| } else if (string == QLatin1String("home")) { |
| s = QString(); |
| code = Qt::Key_Home; |
| } else if (string == QLatin1String("end")) { |
| s = QString(); |
| code = Qt::Key_End; |
| } else if (string == QLatin1String("insert")) { |
| s = QString(); |
| code = Qt::Key_Insert; |
| } else if (string == QLatin1String("delete")) { |
| s = QString(); |
| code = Qt::Key_Delete; |
| } else if (string == QLatin1String("printScreen")) { |
| s = QString(); |
| code = Qt::Key_Print; |
| } else if (string == QLatin1String("menu")) { |
| s = QString(); |
| code = Qt::Key_Menu; |
| } |
| } |
| QKeyEvent event(QEvent::KeyPress, code, modifs, s); |
| sendEvent(m_page, &event); |
| QKeyEvent event2(QEvent::KeyRelease, code, modifs, s); |
| sendEvent(m_page, &event2); |
| } |
| |
| QStringList EventSender::contextClick() |
| { |
| QMouseEvent event(QEvent::MouseButtonPress, m_mousePos, Qt::RightButton, Qt::RightButton, Qt::NoModifier); |
| sendEvent(m_page, &event); |
| QMouseEvent event2(QEvent::MouseButtonRelease, m_mousePos, Qt::RightButton, Qt::RightButton, Qt::NoModifier); |
| sendEvent(m_page, &event2); |
| |
| if (isGraphicsBased()) { |
| QGraphicsSceneContextMenuEvent ctxEvent(QEvent::GraphicsSceneContextMenu); |
| ctxEvent.setReason(QGraphicsSceneContextMenuEvent::Mouse); |
| ctxEvent.setPos(m_mousePos); |
| WebCore::WebViewGraphicsBased* view = qobject_cast<WebCore::WebViewGraphicsBased*>(m_page->view()); |
| if (view) |
| sendEvent(view->graphicsView(), &ctxEvent); |
| } else { |
| QContextMenuEvent ctxEvent(QContextMenuEvent::Mouse, m_mousePos); |
| sendEvent(m_page->view(), &ctxEvent); |
| } |
| return DumpRenderTreeSupportQt::contextMenu(m_page); |
| } |
| |
| void EventSender::scheduleAsynchronousClick() |
| { |
| QMouseEvent* event = new QMouseEvent(QEvent::MouseButtonPress, m_mousePos, Qt::LeftButton, Qt::RightButton, Qt::NoModifier); |
| postEvent(m_page, event); |
| QMouseEvent* event2 = new QMouseEvent(QEvent::MouseButtonRelease, m_mousePos, Qt::LeftButton, Qt::RightButton, Qt::NoModifier); |
| postEvent(m_page, event2); |
| } |
| |
| void EventSender::addTouchPoint(int x, int y) |
| { |
| // Use index to refer to the position in the vector that this touch |
| // is stored. We then create a unique id for the touch that will be |
| // passed into WebCore. |
| int index = m_touchPoints.count(); |
| int id = m_touchPoints.isEmpty() ? 0 : m_touchPoints.last().id() + 1; |
| QTouchEvent::TouchPoint point(id); |
| m_touchPoints.append(point); |
| updateTouchPoint(index, x, y); |
| m_touchPoints[index].setState(Qt::TouchPointPressed); |
| } |
| |
| void EventSender::updateTouchPoint(int index, int x, int y) |
| { |
| if (index < 0 || index >= m_touchPoints.count()) |
| return; |
| |
| QTouchEvent::TouchPoint &p = m_touchPoints[index]; |
| p.setPos(QPointF(x, y)); |
| p.setState(Qt::TouchPointMoved); |
| } |
| |
| void EventSender::setTouchModifier(const QString &modifier, bool enable) |
| { |
| Qt::KeyboardModifier mod = Qt::NoModifier; |
| if (!modifier.compare(QLatin1String("shift"), Qt::CaseInsensitive)) |
| mod = Qt::ShiftModifier; |
| else if (!modifier.compare(QLatin1String("alt"), Qt::CaseInsensitive)) |
| mod = Qt::AltModifier; |
| else if (!modifier.compare(QLatin1String("meta"), Qt::CaseInsensitive)) |
| mod = Qt::MetaModifier; |
| else if (!modifier.compare(QLatin1String("ctrl"), Qt::CaseInsensitive)) |
| mod = Qt::ControlModifier; |
| |
| if (enable) |
| m_touchModifiers |= mod; |
| else |
| m_touchModifiers &= ~mod; |
| } |
| |
| void EventSender::touchStart() |
| { |
| if (!m_touchActive) { |
| sendTouchEvent(QEvent::TouchBegin); |
| m_touchActive = true; |
| } else |
| sendTouchEvent(QEvent::TouchUpdate); |
| } |
| |
| void EventSender::touchMove() |
| { |
| sendTouchEvent(QEvent::TouchUpdate); |
| } |
| |
| void EventSender::touchEnd() |
| { |
| for (int i = 0; i < m_touchPoints.count(); ++i) |
| if (m_touchPoints[i].state() != Qt::TouchPointReleased) { |
| sendTouchEvent(QEvent::TouchUpdate); |
| return; |
| } |
| sendTouchEvent(QEvent::TouchEnd); |
| m_touchActive = false; |
| } |
| |
| void EventSender::clearTouchPoints() |
| { |
| m_touchPoints.clear(); |
| m_touchModifiers = Qt::KeyboardModifiers(); |
| m_touchActive = false; |
| } |
| |
| void EventSender::releaseTouchPoint(int index) |
| { |
| if (index < 0 || index >= m_touchPoints.count()) |
| return; |
| |
| m_touchPoints[index].setState(Qt::TouchPointReleased); |
| } |
| |
| void EventSender::sendTouchEvent(QEvent::Type type) |
| { |
| QTouchEvent event(type, QTouchEvent::TouchScreen, m_touchModifiers); |
| event.setTouchPoints(m_touchPoints); |
| sendEvent(m_page, &event); |
| QList<QTouchEvent::TouchPoint>::Iterator it = m_touchPoints.begin(); |
| while (it != m_touchPoints.end()) { |
| if (it->state() == Qt::TouchPointReleased) |
| it = m_touchPoints.erase(it); |
| else { |
| it->setState(Qt::TouchPointStationary); |
| ++it; |
| } |
| } |
| } |
| |
| void EventSender::zoomPageIn() |
| { |
| if (QWebFrame* frame = m_page->mainFrame()) |
| frame->setZoomFactor(frame->zoomFactor() * ZOOM_STEP); |
| } |
| |
| void EventSender::zoomPageOut() |
| { |
| if (QWebFrame* frame = m_page->mainFrame()) |
| frame->setZoomFactor(frame->zoomFactor() / ZOOM_STEP); |
| } |
| |
| void EventSender::textZoomIn() |
| { |
| if (QWebFrame* frame = m_page->mainFrame()) |
| frame->setTextSizeMultiplier(frame->textSizeMultiplier() * ZOOM_STEP); |
| } |
| |
| void EventSender::textZoomOut() |
| { |
| if (QWebFrame* frame = m_page->mainFrame()) |
| frame->setTextSizeMultiplier(frame->textSizeMultiplier() / ZOOM_STEP); |
| } |
| |
| QWebFrame* EventSender::frameUnderMouse() const |
| { |
| QWebFrame* frame = m_page->mainFrame(); |
| |
| redo: |
| QList<QWebFrame*> children = frame->childFrames(); |
| for (int i = 0; i < children.size(); ++i) { |
| if (children.at(i)->geometry().contains(m_mousePos)) { |
| frame = children.at(i); |
| goto redo; |
| } |
| } |
| if (frame->geometry().contains(m_mousePos)) |
| return frame; |
| return 0; |
| } |
| |
| void EventSender::sendOrQueueEvent(QEvent* event) |
| { |
| // Mouse move events are queued if |
| // 1. A previous event was queued. |
| // 2. A delay was set-up by leapForward(). |
| // 3. A call to mouseMoveTo while the mouse button is pressed could initiate a drag operation, and that does not return until mouseUp is processed. |
| // To be safe and avoid a deadlock, this event is queued. |
| if (endOfQueue == startOfQueue && !eventQueue[endOfQueue].m_delay && (!(m_mouseButtonPressed && (m_eventLoop && event->type() == QEvent::MouseButtonRelease)))) { |
| sendEvent(m_page->view(), event); |
| delete event; |
| return; |
| } |
| eventQueue[endOfQueue++].m_event = event; |
| eventQueue[endOfQueue].m_delay = 0; |
| replaySavedEvents(event->type() != QEvent::MouseMove); |
| } |
| |
| void EventSender::replaySavedEvents(bool flush) |
| { |
| if (startOfQueue < endOfQueue) { |
| // First send all the events that are ready to be sent |
| while (!eventQueue[startOfQueue].m_delay && startOfQueue < endOfQueue) { |
| QEvent* ev = eventQueue[startOfQueue++].m_event; |
| postEvent(m_page->view(), ev); |
| } |
| if (startOfQueue == endOfQueue) { |
| // Reset the queue |
| startOfQueue = 0; |
| endOfQueue = 0; |
| } else { |
| QTest::qWait(eventQueue[startOfQueue].m_delay); |
| eventQueue[startOfQueue].m_delay = 0; |
| } |
| } |
| if (!flush) |
| return; |
| |
| // Send a marker event, it will tell us when it is safe to exit the new event loop |
| QEvent* drtEvent = new QEvent((QEvent::Type)DRT_MESSAGE_DONE); |
| QApplication::postEvent(m_page->view(), drtEvent); |
| |
| // Start an event loop for async handling of Drag & Drop |
| m_eventLoop = new QEventLoop; |
| m_eventLoop->exec(); |
| delete m_eventLoop; |
| m_eventLoop = 0; |
| } |
| |
| bool EventSender::eventFilter(QObject* watched, QEvent* event) |
| { |
| if (watched != m_page->view()) |
| return false; |
| switch (event->type()) { |
| case QEvent::Leave: |
| return true; |
| case QEvent::MouseButtonPress: |
| case QEvent::GraphicsSceneMousePress: |
| m_mouseButtonPressed = true; |
| break; |
| case QEvent::MouseMove: |
| case QEvent::GraphicsSceneMouseMove: |
| if (m_mouseButtonPressed) |
| m_drag = true; |
| break; |
| case QEvent::MouseButtonRelease: |
| case QEvent::GraphicsSceneMouseRelease: |
| m_mouseButtonPressed = false; |
| m_drag = false; |
| break; |
| case DRT_MESSAGE_DONE: |
| m_eventLoop->exit(); |
| return true; |
| } |
| return false; |
| } |
| |
| void EventSender::timerEvent(QTimerEvent* ev) |
| { |
| m_clickTimer.stop(); |
| } |
| |
| QGraphicsSceneMouseEvent* EventSender::createGraphicsSceneMouseEvent(QEvent::Type type, const QPoint& pos, const QPoint& screenPos, Qt::MouseButton button, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers) |
| { |
| QGraphicsSceneMouseEvent* event; |
| event = new QGraphicsSceneMouseEvent(type); |
| event->setPos(pos); |
| event->setScreenPos(screenPos); |
| event->setButton(button); |
| event->setButtons(buttons); |
| event->setModifiers(modifiers); |
| |
| return event; |
| } |
| |
| QGraphicsSceneWheelEvent* EventSender::createGraphicsSceneWheelEvent(QEvent::Type type, const QPoint& pos, const QPoint& screenPos, int delta, Qt::KeyboardModifiers modifiers, Qt::Orientation orientation) |
| { |
| QGraphicsSceneWheelEvent* event; |
| event = new QGraphicsSceneWheelEvent(type); |
| event->setPos(pos); |
| event->setScreenPos(screenPos); |
| event->setDelta(delta); |
| event->setModifiers(modifiers); |
| event->setOrientation(orientation); |
| |
| return event; |
| } |
| |
| void EventSender::sendEvent(QObject* receiver, QEvent* event) |
| { |
| if (WebCore::WebViewGraphicsBased* view = qobject_cast<WebCore::WebViewGraphicsBased*>(receiver)) |
| view->scene()->sendEvent(view->graphicsView(), event); |
| else |
| QApplication::sendEvent(receiver, event); |
| } |
| |
| void EventSender::postEvent(QObject* receiver, QEvent* event) |
| { |
| // QGraphicsScene does not have a postEvent method, so send the event in this case |
| // and delete it after that. |
| if (WebCore::WebViewGraphicsBased* view = qobject_cast<WebCore::WebViewGraphicsBased*>(receiver)) { |
| view->scene()->sendEvent(view->graphicsView(), event); |
| delete event; |
| } else |
| QApplication::postEvent(receiver, event); // event deleted by the system |
| } |
