Example #1
0
void QVistaHelper::mouseEvent(QEvent *event)
{
    switch (event->type()) {
    case QEvent::MouseMove:
        mouseMoveEvent(static_cast<QMouseEvent *>(event));
        break;
    case QEvent::MouseButtonPress:
        mousePressEvent(static_cast<QMouseEvent *>(event));
        break;
    case QEvent::MouseButtonRelease:
        mouseReleaseEvent(static_cast<QMouseEvent *>(event));
        break;
    default:
        break;
    }
}
Example #2
0
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) {
        d->stealMouse = false;
        ungrabMouse();
    }
    return false;
}
Example #3
0
bool SelectionTool::dispatch(QEvent * e, QGraphicsScene * scene)
{
    if (e->type() == QEvent::GraphicsSceneMousePress)
    {
        return mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(e), scene);
    }
    else if (e->type() == QEvent::GraphicsSceneMouseMove)
    {
        return mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(e), scene);
    }
    else if (e->type() == QEvent::GraphicsSceneMouseRelease)
    {
        return mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(e), scene);
    }

    return false;
}
Example #4
0
int QMyButton::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QPushButton::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: keyClick((*reinterpret_cast< uint(*)>(_a[1]))); break;
        case 1: sendKey(); break;
        case 2: mousePressEvent((*reinterpret_cast< QMouseEvent*(*)>(_a[1]))); break;
        case 3: mouseReleaseEvent((*reinterpret_cast< QMouseEvent*(*)>(_a[1]))); break;
        default: ;
        }
        _id -= 4;
    }
    return _id;
}
Example #5
0
bool TopBarWidget::eventFilter(QObject *obj, QEvent *e) {
	if (obj == _membersShowArea) {
		switch (e->type()) {
		case QEvent::MouseButtonPress:
			mousePressEvent(static_cast<QMouseEvent*>(e));
			return true;

		case QEvent::Enter:
			main()->setMembersShowAreaActive(true);
			break;

		case QEvent::Leave:
			main()->setMembersShowAreaActive(false);
			break;
		}
	}
	return TWidget::eventFilter(obj, e);
}
Example #6
0
int ZoneDeDessin::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QWidget::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: setColor((*reinterpret_cast< QColor(*)>(_a[1]))); break;
        case 1: mousePressEvent((*reinterpret_cast< QMouseEvent*(*)>(_a[1]))); break;
        case 2: mouseReleaseEvent((*reinterpret_cast< QMouseEvent*(*)>(_a[1]))); break;
        case 3: mouseMoveEvent((*reinterpret_cast< QMouseEvent*(*)>(_a[1]))); break;
        case 4: mouseDoubleClickEvent((*reinterpret_cast< QMouseEvent*(*)>(_a[1]))); break;
        default: ;
        }
        _id -= 5;
    }
    return _id;
}
Example #7
0
bool DrawRectangleTool::mouseReleaseEvent(QMouseEvent* event, MapCoordF map_coord, MapWidget* widget)
{
	cur_pos = event->pos();
	cur_pos_map = map_coord;
	if (shift_pressed)
		cur_pos_map = MapCoordF(snap_helper->snapToObject(cur_pos_map, widget));
	constrained_pos_map = cur_pos_map;
	
	if (no_more_effect_on_click)
	{
		no_more_effect_on_click = false;
		return true;
	}
	
	if (ctrl_pressed && event->button() == Qt::LeftButton && !editingInProgress())
	{
		pickDirection(cur_pos_map, widget);
		return true;
	}
	
	bool result = false;
	if (editingInProgress())
	{
		if (isDrawingButton(event->button()) && dragging)
		{
			dragging = false;
			result = mousePressEvent(event, cur_pos_map, widget);
		}
		
		if (event->button() == Qt::RightButton && drawOnRightClickEnabled())
		{
			if (!dragging)
			{
				constrained_pos_map = MapCoordF(preview_path->getCoordinate(angles.size() - 1));
				undoLastPoint();
			}
			if (editingInProgress()) // despite undoLastPoint()
				finishDrawing();
			return true;
		}
	}
	return result;
}
Example #8
0
bool RenderWidget::eventFilter(QObject* obj, QEvent* event)
{
    // handle event in this widget, is there a better way to do this?
    if (event->type() == QEvent::MouseButtonPress)
        mousePressEvent(static_cast<QMouseEvent*>(event));
    if (event->type() == QEvent::MouseButtonRelease)
        mouseReleaseEvent(static_cast<QMouseEvent*>(event));
    if (event->type() == QEvent::MouseMove)
        mouseMoveEvent(static_cast<QMouseEvent*>(event));
    if (event->type() == QEvent::KeyPress)
        keyPressEvent(static_cast<QKeyEvent*>(event));
    if (event->type() == QEvent::KeyRelease)
        keyReleaseEvent(static_cast<QKeyEvent*>(event));
    if (event->type() == QEvent::Wheel)
        wheelEvent(static_cast<QWheelEvent *>(event));

    // Always pass the event on to GLWidget, i.e. to OSG event queue
    return QObject::eventFilter(obj, event);
}
Example #9
0
int ZoneDessin::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QWidget::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: mousePressEvent((*reinterpret_cast< QMouseEvent*(*)>(_a[1]))); break;
        case 1: mouseReleaseEvent((*reinterpret_cast< QMouseEvent*(*)>(_a[1]))); break;
        case 2: mouseMoveEvent((*reinterpret_cast< QMouseEvent*(*)>(_a[1]))); break;
        case 3: paintEvent((*reinterpret_cast< QPaintEvent*(*)>(_a[1]))); break;
        case 4: resizeEvent((*reinterpret_cast< QResizeEvent*(*)>(_a[1]))); break;
        case 5: clearImage(); break;
        default: ;
        }
        _id -= 6;
    }
    return _id;
}
Example #10
0
bool QQuickMultiPointTouchArea::sendMouseEvent(QMouseEvent *event)
{
    QPointF localPos = mapFromScene(event->windowPos());

    QQuickWindow *c = window();
    QQuickItem *grabber = c ? c->mouseGrabberItem() : 0;
    bool stealThisEvent = _stealMouse;
    if ((stealThisEvent || contains(localPos)) && (!grabber || !grabber->keepMouseGrab())) {
        QMouseEvent mouseEvent(event->type(), localPos, event->windowPos(), event->screenPos(),
                               event->button(), event->buttons(), event->modifiers());
        mouseEvent.setAccepted(false);
        QGuiApplicationPrivate::setMouseEventCapsAndVelocity(&mouseEvent,
                                                             QGuiApplicationPrivate::mouseEventCaps(event),
                                                             QGuiApplicationPrivate::mouseEventVelocity(event));
        QGuiApplicationPrivate::setMouseEventSource(&mouseEvent, Qt::MouseEventSynthesizedByQt);

        switch (mouseEvent.type()) {
        case QEvent::MouseMove:
            mouseMoveEvent(&mouseEvent);
            break;
        case QEvent::MouseButtonPress:
            mousePressEvent(&mouseEvent);
            break;
        case QEvent::MouseButtonRelease:
            mouseReleaseEvent(&mouseEvent);
            break;
        default:
            break;
        }
        grabber = c ? c->mouseGrabberItem() : 0;
        if (grabber && stealThisEvent && !grabber->keepMouseGrab() && grabber != this)
            grabMouse();

        return stealThisEvent;
    }
    if (event->type() == QEvent::MouseButtonRelease) {
        _stealMouse = false;
        if (c && c->mouseGrabberItem() == this)
            ungrabMouse();
        setKeepMouseGrab(false);
    }
    return false;
}
Example #11
0
bool ListDnd::eventFilter( QObject *, QEvent * event )
{
    switch ( event->type() ) {
    case QEvent::DragEnter:
	return dragEnterEvent( (QDragEnterEvent *) event );
    case QEvent::DragLeave:
	return dragLeaveEvent( (QDragLeaveEvent *) event );
    case QEvent::DragMove:
	return dragMoveEvent( (QDragMoveEvent *) event );
    case QEvent::Drop:
	return dropEvent( (QDropEvent *) event );
    case QEvent::MouseButtonPress:
	return mousePressEvent( (QMouseEvent *) event );
    case QEvent::MouseMove:
	return mouseMoveEvent( (QMouseEvent *) event );
    default:
	break;
    }
    return FALSE;
}
Example #12
0
bool CanvasQt::event(QEvent *e) {
    switch (e->type()) {
    case QEvent::KeyPress:
        keyPressEvent(static_cast<QKeyEvent*>(e));
        return true;
    case QEvent::KeyRelease:
        keyReleaseEvent(static_cast<QKeyEvent*>(e));
        return true;
    case QEvent::MouseButtonPress:
        if(!gestureMode_)
            mousePressEvent(static_cast<QMouseEvent*>(e));
        return true;
    case QEvent::MouseButtonRelease:
        if(!gestureMode_)
            mouseReleaseEvent(static_cast<QMouseEvent*>(e));
        return true;
    case QEvent::MouseMove:
        if(!gestureMode_)
            mouseMoveEvent(static_cast<QMouseEvent*>(e));
        return true;
    case QEvent::Wheel:
        wheelEvent(static_cast<QWheelEvent*>(e));
        return true;
#ifndef QT_NO_GESTURES
    case QEvent::TouchBegin:
    case QEvent::TouchEnd:
    case QEvent::TouchUpdate:
        touchEvent(static_cast<QTouchEvent*>(e));
        return true;
    case QEvent::Gesture:
        return gestureEvent(static_cast<QGestureEvent*>(e));
#endif
#ifdef USE_QWINDOW
    case QEvent::UpdateRequest:
        paintGL();
        return true;
#endif
    default:
        return QGLWindow::event(e);
    }
}
/*!
    \internal
*/
bool QDeclarativeGeoMapGestureArea::filterMapChildMouseEvent(QMouseEvent *event)
{
    if (usingTouch_)
        return false;

    bool used = false;
    switch (event->type()) {
    case QEvent::MouseButtonPress:
        used = mousePressEvent(event);
        break;
    case QEvent::MouseButtonRelease:
        used = mouseReleaseEvent(event);
        break;
    case QEvent::MouseMove:
        used = mouseMoveEvent(event);
        break;
    default:
        used = false;
        break;
    }
    return used && (isPanActive() || isPinchActive());
}
bool 
GraphicsViewPolylineInput_non_templated_base::eventFilter(QObject *obj, QEvent *event)
{
  if (event->type() == QEvent::GraphicsSceneMousePress) {
    QGraphicsSceneMouseEvent *mouseEvent = static_cast<QGraphicsSceneMouseEvent *>(event);
    if(!mousePressEvent(mouseEvent)) {
      // standard event processing if mousePressEvent has returned false
      return QObject::eventFilter(obj, event);
    }
  } else if (event->type() == QEvent::GraphicsSceneMouseMove) {
    QGraphicsSceneMouseEvent *mouseEvent = static_cast<QGraphicsSceneMouseEvent *>(event);
    mouseMoveEvent(mouseEvent);
    return QObject::eventFilter(obj, event);
  } else if (event->type() == QEvent::KeyPress) {
    QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
    if(!keyPressEvent(keyEvent)) {
      return QObject::eventFilter(obj, event);
    }
  }
  // standard event processing if keyPressEvent has returned false
  return QObject::eventFilter(obj, event);
}
Example #15
0
int Tableur::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QWidget::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: mousePressEvent((*reinterpret_cast< QMouseEvent*(*)>(_a[1]))); break;
        case 1: paintEvent((*reinterpret_cast< QPaintEvent*(*)>(_a[1]))); break;
        case 2: resizeEvent((*reinterpret_cast< QResizeEvent*(*)>(_a[1]))); break;
        case 3: clearImage(); break;
        case 4: drawGrid(); break;
        case 5: showSelectedCell(); break;
        case 6: addLign(); break;
        case 7: addColumn(); break;
        case 8: addCell(); break;
        default: ;
        }
        _id -= 9;
    }
    return _id;
}
void Ut_MButton::testPressedCanceled()
{
    QGraphicsSceneMouseEvent mousePressEvent(QEvent::GraphicsSceneMousePress);
    m_subject->mousePressEvent(&mousePressEvent);
    QVERIFY(m_subject->isDown() == true);

    QSignalSpy releasedSpy(m_subject, SIGNAL(released()));
    QSignalSpy clickedSpy(m_subject, SIGNAL(clicked()));
    MCancelEvent event;
    m_subject->cancelEvent(&event);

    QCOMPARE(clickedSpy.count(), 0);
    QVERIFY(!m_subject->isDown());

    QGraphicsSceneMouseEvent mouseMoveEvent(QEvent::GraphicsSceneMouseMove);
    mouseMoveEvent.setScenePos(m_subject->sceneBoundingRect().topLeft());
    m_subject->mouseMoveEvent(&mouseMoveEvent);

    QGraphicsSceneMouseEvent mouseReleaseEvent(QEvent::GraphicsSceneMouseRelease);
    m_subject->mouseReleaseEvent(&mouseReleaseEvent);

    QCOMPARE(releasedSpy.count(), 1);
}
Example #17
0
bool QrAbstractSpinBox::eventFilter( QObject *watched, QEvent *event)
{
    if( !isEnabled())
	return QObject::eventFilter( watched, event);

    switch( event->type())
    {
    case QEvent::MouseButtonPress:
	mousePressEvent( (QMouseEvent *) event);
	return true;

    case QEvent::MouseMove:
	mouseDragEvent( (QMouseEvent *) event);
	return true;

    case QEvent::MouseButtonRelease:
	mouseReleaseEvent( (QMouseEvent *) event);
	return true;

    default:
	return QObject::eventFilter( watched, event);
    }
}
bool SceneMaterialItem::event(QEvent *event)
{
    switch(event->type())
    {
        case QEvent::Enter:
            enterEvent(event);
            if (!event->isAccepted())
                return false;
            break;
        case QEvent::Leave:
            leaveEvent(event);
            if (!event->isAccepted())
                return false;
            break;
        case QEvent::MouseButtonPress:
            mousePressEvent((QMouseEvent*)event);
            if (!event->isAccepted())
                return false;
        default:
            break;
    }
    return true;
}
void CanvasMode_EditMeshGradient::mouseDoubleClickEvent(QMouseEvent *m)
{
    m->accept();
    m_canvas->m_viewMode.m_MouseButtonPressed = false;
    m_canvas->resetRenderMode();
    PageItem *currItem = 0;
    if ((m_doc->m_Selection->isMultipleSelection()) || (m_doc->appMode != modeNormal))
    {
        if ((m_doc->m_Selection->isMultipleSelection()) && (m_doc->appMode == modeNormal))
        {
            if (GetItem(&currItem))
            {
                /* CB: old code, removing this as shift-alt select on an unselected table selects a cell now.
                //#6789 is closed by sorting this.
                if (currItem->isTableItem)
                {
                	m_view->Deselect(false);
                	m_doc->m_Selection->addItem(currItem);
                	currItem->isSingleSel = true;
                	//CB FIXME don't call this if the added item is item 0
                	if (!m_doc->m_Selection->primarySelectionIs(currItem))
                		currItem->emitAllToGUI();
                	m_view->updateContents(currItem->getRedrawBounding(m_canvas->scale()));
                }*/
            }
            return;
        }
        else
        {
            if (!(GetItem(&currItem) && (m_doc->appMode == modeEdit) && currItem->asTextFrame()))
            {
                mousePressEvent(m);
                return;
            }
        }
    }
}
Example #20
0
/**
  \reimp
*/
bool TrayIcon::event( QEvent *e )
{
    switch ( e->type() ) {
    case QEvent::MouseMove:
	mouseMoveEvent( (QMouseEvent*)e );
	break;

    case QEvent::MouseButtonPress:
	mousePressEvent( (QMouseEvent*)e );
	break;

    case QEvent::MouseButtonRelease:
	mouseReleaseEvent( (QMouseEvent*)e );
	break;

    case QEvent::MouseButtonDblClick:
	mouseDoubleClickEvent( (QMouseEvent*)e );
	break;
    default:
	return QObject::event( e );
    }

    return TRUE;
}
bool RangeProfilePlotManager::eventFilter(QObject* pObj, QEvent* pEvent)
{
   PlotView* pView = dynamic_cast<PlotView*>(pObj);
   if (pView == NULL || pView->getCurrentMouseMode() != mpMode)
   {
      return QObject::eventFilter(pObj, pEvent);
   }
   switch(pEvent->type())
   {
   case QEvent::MouseButtonPress:
      return mousePressEvent(pView, static_cast<QMouseEvent*>(pEvent));
   case QEvent::MouseButtonRelease:
      return mouseReleaseEvent(pView, static_cast<QMouseEvent*>(pEvent));
   case QEvent::MouseMove:
      return mouseMoveEvent(pView, static_cast<QMouseEvent*>(pEvent));
   case QEvent::Wheel:
      return wheelEvent(pView, static_cast<QWheelEvent*>(pEvent));
   case QEvent::KeyPress:
      return keyPressEvent(pView, static_cast<QKeyEvent*>(pEvent));
   default:
      ; // do nothing
   }
   return QObject::eventFilter(pObj, pEvent);
}
Example #22
0
void DhQGLWidget::DvhmousePressEvent(QMouseEvent* x1) {
  return mousePressEvent(x1);
}
Example #23
0
void QtGradientWidget::mouseDoubleClickEvent(QMouseEvent *e)
{
    mousePressEvent(e);
}
bool QDeclarativeViewInspector::eventFilter(QObject *obj, QEvent *event)
{
    if (obj == data->view) {
        // Event from view
        if (event->type() == QEvent::ChildRemoved) {
            // Might mean that viewport has changed
            if (data->view->viewport() != data->viewport.data())
                data->setViewport(data->view->viewport());
        }
        return QObject::eventFilter(obj, event);
    }

    // Event from viewport
    switch (event->type()) {
    case QEvent::Leave: {
        if (leaveEvent(event))
            return true;
        break;
    }
    case QEvent::MouseButtonPress: {
        if (mousePressEvent(static_cast<QMouseEvent*>(event)))
            return true;
        break;
    }
    case QEvent::MouseMove: {
        if (mouseMoveEvent(static_cast<QMouseEvent*>(event)))
            return true;
        break;
    }
    case QEvent::MouseButtonRelease: {
        if (mouseReleaseEvent(static_cast<QMouseEvent*>(event)))
            return true;
        break;
    }
    case QEvent::KeyPress: {
        if (keyPressEvent(static_cast<QKeyEvent*>(event)))
            return true;
        break;
    }
    case QEvent::KeyRelease: {
        if (keyReleaseEvent(static_cast<QKeyEvent*>(event)))
            return true;
        break;
    }
    case QEvent::MouseButtonDblClick: {
        if (mouseDoubleClickEvent(static_cast<QMouseEvent*>(event)))
            return true;
        break;
    }
    case QEvent::Wheel: {
        if (wheelEvent(static_cast<QWheelEvent*>(event)))
            return true;
        break;
    }
    default: {
        break;
    }
    } //switch

    // standard event processing
    return QObject::eventFilter(obj, event);
}
Example #25
0
void Sdl2Application::mainLoop() {
    #ifndef CORRADE_TARGET_EMSCRIPTEN
    const UnsignedInt timeBefore = _minimalLoopPeriod ? SDL_GetTicks() : 0;
    #endif

    SDL_Event event;
    while(SDL_PollEvent(&event)) {
        switch(event.type) {
            case SDL_WINDOWEVENT:
                switch(event.window.event) {
                    case SDL_WINDOWEVENT_RESIZED: {
                        #ifndef CORRADE_TARGET_IOS
                        viewportEvent({event.window.data1, event.window.data2});
                        #else
                        /* On iOS the window event is in points and not pixels,
                           but we need pixels to call glViewport() properly */
                        Vector2i drawableSize;
                        SDL_GL_GetDrawableSize(_window, &drawableSize.x(), &drawableSize.y());
                        viewportEvent(drawableSize);
                        #endif
                        _flags |= Flag::Redraw;
                    } break;
                    case SDL_WINDOWEVENT_EXPOSED:
                        _flags |= Flag::Redraw;
                        break;
                } break;

            case SDL_KEYDOWN:
            case SDL_KEYUP: {
                KeyEvent e(static_cast<KeyEvent::Key>(event.key.keysym.sym), fixedModifiers(event.key.keysym.mod));
                event.type == SDL_KEYDOWN ? keyPressEvent(e) : keyReleaseEvent(e);
            } break;

            case SDL_MOUSEBUTTONDOWN:
            case SDL_MOUSEBUTTONUP: {
                MouseEvent e(static_cast<MouseEvent::Button>(event.button.button), {event.button.x, event.button.y});
                event.type == SDL_MOUSEBUTTONDOWN ? mousePressEvent(e) : mouseReleaseEvent(e);
            } break;

            case SDL_MOUSEWHEEL:
                if(event.wheel.y != 0) {
                    MouseEvent e(event.wheel.y > 0 ? MouseEvent::Button::WheelUp : MouseEvent::Button::WheelDown, {event.wheel.x, event.wheel.y});
                    mousePressEvent(e);
                } break;

            case SDL_MOUSEMOTION: {
                MouseMoveEvent e({event.motion.x, event.motion.y}, {event.motion.xrel, event.motion.yrel}, static_cast<MouseMoveEvent::Button>(event.motion.state));
                mouseMoveEvent(e);
                break;
            }

            case SDL_QUIT:
                #ifndef CORRADE_TARGET_EMSCRIPTEN
                _flags |= Flag::Exit;
                #else
                emscripten_cancel_main_loop();
                #endif
                return;
        }
    }

    /* Tick event */
    if(!(_flags & Flag::NoTickEvent)) tickEvent();

    /* Draw event */
    if(_flags & Flag::Redraw) {
        _flags &= ~Flag::Redraw;
        drawEvent();

        #ifndef CORRADE_TARGET_EMSCRIPTEN
        /* If VSync is not enabled, delay to prevent CPU hogging (if set) */
        if(!(_flags & Flag::VSyncEnabled) && _minimalLoopPeriod) {
            const UnsignedInt loopTime = SDL_GetTicks() - timeBefore;
            if(loopTime < _minimalLoopPeriod)
                SDL_Delay(_minimalLoopPeriod - loopTime);
        }
        #endif

        return;
    }

    #ifndef CORRADE_TARGET_EMSCRIPTEN
    /* If not drawing anything, delay to prevent CPU hogging (if set) */
    if(_minimalLoopPeriod) {
        const UnsignedInt loopTime = SDL_GetTicks() - timeBefore;
        if(loopTime < _minimalLoopPeriod)
            SDL_Delay(_minimalLoopPeriod - loopTime);
    }

    /* Then, if the tick event doesn't need to be called periodically, wait
       indefinitely for next input event */
    if(_flags & Flag::NoTickEvent) SDL_WaitEvent(nullptr);
    #endif
}
Example #26
0
/**
 * support for the wacom graphic tablet.
 */
void QG_GraphicView::tabletEvent(QTabletEvent* e) {
    if (testAttribute(Qt::WA_UnderMouse)) {
        switch (e->device()) {
        case QTabletEvent::Eraser:
            if (e->type()==QEvent::TabletRelease) {
                if (container!=NULL) {

                    RS_ActionSelectSingle* a =
                        new RS_ActionSelectSingle(*container, *this);
                    setCurrentAction(a);
                    QMouseEvent ev(QEvent::MouseButtonRelease, e->pos(),
                                   Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);//RLZ
                    mouseReleaseEvent(&ev);
                    a->finish();

                    if (container->countSelected()>0) {
                        setCurrentAction(
                            new RS_ActionModifyDelete(*container, *this));
                    }
                }
            }
            break;

        case QTabletEvent::Stylus:
        case QTabletEvent::Puck:
            if (e->type()==QEvent::TabletPress) {
                QMouseEvent ev(QEvent::MouseButtonPress, e->pos(),
                               Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);//RLZ
                mousePressEvent(&ev);
            } else if (e->type()==QEvent::TabletRelease) {
                QMouseEvent ev(QEvent::MouseButtonRelease, e->pos(),
                               Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);//RLZ
                mouseReleaseEvent(&ev);
            } else if (e->type()==QEvent::TabletMove) {
                QMouseEvent ev(QEvent::MouseMove, e->pos(),
                               Qt::NoButton, 0, Qt::NoModifier);//RLZ
                mouseMoveEvent(&ev);
            }
            break;

        default:
            break;
        }
    }

    // a 'mouse' click:
    /*if (e->pressure()>10 && lastPressure<10) {
        QMouseEvent e(QEvent::MouseButtonPress, e->pos(),
           Qt::LeftButton, Qt::LeftButton);
        mousePressEvent(&e);
}
    else if (e->pressure()<10 && lastPressure>10) {
        QMouseEvent e(QEvent::MouseButtonRelease, e->pos(),
           Qt::LeftButton, Qt::LeftButton);
        mouseReleaseEvent(&e);
}	else if (lastPos!=e->pos()) {
        QMouseEvent e(QEvent::MouseMove, e->pos(),
           Qt::NoButton, 0);
        mouseMoveEvent(&e);
}

    lastPressure = e->pressure();
    lastPos = e->pos();
    */
}
Example #27
0
void MapView::mouseDoubleClickEvent( QMouseEvent * event )
{
	mousePressEvent( event );
	mouseReleaseEvent( event );
}
Example #28
0
void DhQGroupBox::DvhmousePressEvent(QMouseEvent* x1) {
  return mousePressEvent(x1);
}
Example #29
0
void DhQPushButton::DvhmousePressEvent(QMouseEvent* x1) {
  return mousePressEvent(x1);
}
Example #30
0
void DhQAbstractSpinBox::DvhmousePressEvent(QMouseEvent* x1) {
  return mousePressEvent(x1);
}