Пример #1
0
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);
}
Пример #2
0
void CanvasGL::renderNoise() {
    if (!noiseShader_)
        return;
    activate();
    glViewport(0, 0, getScreenDimensions().x, getScreenDimensions().y);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
    noiseShader_->activate();
    drawRect();
    noiseShader_->deactivate();
    glSwapBuffers();
    activateDefaultRenderContext();
}
Пример #3
0
void CanvasQt::mousePressEvent(QMouseEvent* e) {

#if !defined(QT_NO_GESTURES) && defined(USING_QT4)
    if (gestureMode_) return;
#endif
    ivec2 screenPos(e->pos().x(), e->pos().y());
    ivec2 screenPosInvY(screenPos.x, static_cast<int>(getScreenDimensions().y) - 1 - screenPos.y);
    MouseEvent mouseEvent(screenPos,
                           EventConverterQt::getMouseButton(e), MouseEvent::MOUSE_STATE_PRESS,
                           EventConverterQt::getModifier(e), getScreenDimensions(), 
                           getDepthValueAtCoord(screenPosInvY));
    e->accept();
    Canvas::mousePressEvent(&mouseEvent);
}
Пример #4
0
void CanvasGL::renderTexture(int unitNumber) {
    if (!shader_)
        return;
    activate();
    glViewport(0, 0, getScreenDimensions().x, getScreenDimensions().y);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    shader_->activate();
    shader_->setUniform("tex_", unitNumber);
    drawRect();
    shader_->deactivate();
    glDisable(GL_BLEND);
    glSwapBuffers();
    activateDefaultRenderContext();
}
Пример #5
0
void CanvasQt::panTriggered(QPanGesture* gesture) {

#ifndef QT_NO_CURSOR
    switch (gesture->state()) {
         case Qt::GestureStarted:
         case Qt::GestureUpdated:
             setCursor(Qt::SizeAllCursor);
             break;
         default:
             setCursor(Qt::ArrowCursor);
    }
#endif
    // Mouse events will be triggered for touch events by Qt 5.3.1 (even though we specify that the touch event is handled)
    // http://www.qtcentre.org/archive/index.php/t-52367.html
    // Therefore keep track of if we are performing and disallow mouse events while performing a gesture ( see CanvasQt::event(QEvent *e) )
    switch (gesture->state()) {
    case Qt::GestureStarted:
    case Qt::GestureUpdated:
        gestureMode_ = true;
        break;
    default:
        gestureMode_ = false;
    }
    vec2 deltaPos = vec2((gesture->lastOffset().x()-gesture->offset().x())/getScreenDimensions().x, (gesture->offset().y()-gesture->lastOffset().y())/getScreenDimensions().y);

    if(deltaPos == vec2(0.f))
        return;

    //std::cout << "PAN: " << deltaPos.x << ":" << deltaPos.y << std::endl;

    GestureEvent gestureEvent(deltaPos, 0.0, GestureEvent::PAN, EventConverterQt::getGestureState(gesture), lastNumFingers_, screenPositionNormalized_, getScreenDimensions());
    Canvas::gestureEvent(&gestureEvent);
}
Пример #6
0
CanvasGLFW::CanvasGLFW(std::string windowTitle, uvec2 dimensions)
    : CanvasGL(dimensions)
    , windowTitle_(windowTitle)
    , glWindow_(nullptr)
    , mouseButton_(MouseEvent::MOUSE_BUTTON_NONE)
    , mouseState_(MouseEvent::MOUSE_STATE_NONE)
    , mouseModifiers_(InteractionEvent::MODIFIER_NONE) {
    
    glfwWindowHint(GLFW_FLOATING, alwaysOnTop_ ? GL_TRUE : GL_FALSE);
    glfwWindowHint(GLFW_VISIBLE, GL_FALSE);

#ifdef __APPLE__
    if (!sharedContext_ && OpenGLCapabilities::getPreferredProfile() == "core") {
        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
        glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    }
#endif

    glWindow_ = glfwCreateWindow(getScreenDimensions().x, getScreenDimensions().y,
                                 windowTitle_.c_str(), nullptr, sharedContext_);

    if (!glWindow_) {
        glfwTerminate();
        throw Exception("Could not create GLFW window.", IvwContext);
    }

    if (!sharedContext_) sharedContext_ = glWindow_;

    // register callbacks
    glfwSetKeyCallback(glWindow_, keyboard);
    glfwSetMouseButtonCallback(glWindow_, mouseButton);
    glfwSetCursorPosCallback(glWindow_, mouseMotion);
    glfwSetScrollCallback(glWindow_, scroll);
    glfwSetWindowCloseCallback(glWindow_, closeWindow);
    glfwSetWindowUserPointer(glWindow_, this);
    glfwSetWindowSizeCallback(glWindow_, reshape);
    glfwSetWindowPosCallback(glWindow_, move);
}
Пример #7
0
void CanvasQt::mouseMoveEvent(QMouseEvent* e) {

#if !defined(QT_NO_GESTURES)
    if (gestureMode_) return;
#endif


    ivec2 screenPos(e->pos().x(), e->pos().y());
    ivec2 screenPosInvY(screenPos.x, static_cast<int>(getScreenDimensions().y) - 1 - screenPos.y);

    // Optimization, do not sample depth value when hovering, i.e. move without holding a mouse button
    int button = EventConverterQt::getMouseButton(e);
    double depth = 1.0;
    if (button != MouseEvent::MOUSE_BUTTON_NONE)
        depth = getDepthValueAtCoord(screenPosInvY);

    MouseEvent mouseEvent(screenPos, button, MouseEvent::MOUSE_STATE_MOVE,
                            EventConverterQt::getModifier(e), getScreenDimensions(),
                            depth);
    e->accept();
    Canvas::mouseMoveEvent(&mouseEvent);
}
Пример #8
0
void CanvasQt::mouseReleaseEvent(QMouseEvent* e) {
#if !defined(QT_NO_GESTURES) && defined(USING_QT4)
    if (gestureMode_){ 
        gestureMode_ = false;
        return;
    }
#endif
    uvec2 screenPos(static_cast<unsigned int>(e->pos().x()), static_cast<unsigned int>(e->pos().y()));
    MouseEvent mouseEvent(screenPos,
        EventConverterQt::getMouseButtonCausingEvent(e), MouseEvent::MOUSE_STATE_RELEASE,
        EventConverterQt::getModifier(e), getScreenDimensions(),
        getDepthValueAtCoord(screenPos));
    e->accept();
    Canvas::mouseReleaseEvent(&mouseEvent);
}
Пример #9
0
void CanvasQt::pinchTriggered(QPinchGesture* gesture) { 
    //std::cout << "PINCH: " << gesture->scaleFactor() << std::endl;
    // Mouse events will be triggered for touch events by Qt 5.3.1 (even though we specify that the touch event is handled)
    // http://www.qtcentre.org/archive/index.php/t-52367.html
    // Therefore keep track of if we are performing and disallow mouse events while performing a gesture ( see CanvasQt::event(QEvent *e) )
    switch (gesture->state()) {
    case Qt::GestureStarted:
    case Qt::GestureUpdated:
        gestureMode_ = true;
        break;
    default:
        gestureMode_ = false;
    }
    GestureEvent gestureEvent(vec2(gesture->centerPoint().x(), gesture->centerPoint().y()), static_cast<double>(gesture->scaleFactor())-1.0,
        GestureEvent::PINCH, EventConverterQt::getGestureState(gesture), lastNumFingers_, screenPositionNormalized_, getScreenDimensions());
    Canvas::gestureEvent(&gestureEvent);
}
Пример #10
0
void CanvasQt::touchEvent(QTouchEvent* touch) {
    size_t nTouchPoints = touch->touchPoints().size();
    if (nTouchPoints < 1) {
        return;
    }

    QTouchEvent::TouchPoint firstPoint = touch->touchPoints()[0];
    
    switch (firstPoint.state())
    {
    case Qt::TouchPointPressed:
        gestureMode_ = nTouchPoints > 1; // Treat single touch point as mouse event
        break;
    case Qt::TouchPointMoved:
        gestureMode_ = nTouchPoints > 1; // Treat single touch point as mouse event
        break;
    case Qt::TouchPointStationary:
        gestureMode_ = nTouchPoints > 1; // Treat single touch point as mouse event
        break;
    case Qt::TouchPointReleased:
        gestureMode_ = false;
        break;
    default:
        gestureMode_ = false;
    }
    // Copy touch points
    std::vector<TouchPoint> touchPoints;
    touchPoints.reserve(touch->touchPoints().size());
    // Fetch layer before loop (optimization)
    const LayerRAM* depthLayerRAM = getDepthLayerRAM();
    vec2 screenSize(getScreenDimensions());

    std::vector<int> endedTouchIds;

    for (auto& touchPoint : touch->touchPoints()) {
        vec2 screenTouchPos(touchPoint.pos().x(), touchPoint.pos().y());
        vec2 prevScreenTouchPos(touchPoint.lastPos().x(), touchPoint.lastPos().y());
        TouchPoint::TouchState touchState;
        switch (touchPoint.state())
        {
        case Qt::TouchPointPressed:
            touchState = TouchPoint::TOUCH_STATE_STARTED;
            break;
        case Qt::TouchPointMoved:
            touchState = TouchPoint::TOUCH_STATE_UPDATED;
            break;
        case Qt::TouchPointStationary:
            touchState = TouchPoint::TOUCH_STATE_STATIONARY;
            break;
        case Qt::TouchPointReleased:
            touchState = TouchPoint::TOUCH_STATE_ENDED;
            break;
        default:
            touchState = TouchPoint::TOUCH_STATE_NONE;
        }

        ivec2 pixelCoord = ivec2(static_cast<int>(screenTouchPos.x),
            screenSize.y - 1 - static_cast<int>(screenTouchPos.y));
        
        // Note that screenTouchPos/prevScreenTouchPos are in [0 screenDim] and does not need to be 
        // adjusted to become centered in the pixel (+0.5)
        
        // Saving id order to preserve order of touch points at next touch event
        
        const auto lastIdIdx = std::find(lastTouchIds_.begin(), lastTouchIds_.end(), touchPoint.id());

        if (lastIdIdx != lastTouchIds_.end()) {
            if (touchState == TouchPoint::TOUCH_STATE_ENDED){
                endedTouchIds.push_back(touchPoint.id());
            }
        }
        else{
            lastTouchIds_.push_back(touchPoint.id());


        }
        touchPoints.emplace_back(touchPoint.id(), screenTouchPos,
            (screenTouchPos) / screenSize,
            prevScreenTouchPos,
            (prevScreenTouchPos) / screenSize,
            touchState, getDepthValueAtCoord(pixelCoord, depthLayerRAM));
    }
    // Ensure that the order to the touch points are the same as last touch event.
    // Note that the ID of a touch point is always the same but the order in which
    // they are given can vary.
    // Example
    // lastTouchIds_    touchPoints
    //     0                 0
    //     3                 1 
    //     2                 2
    //     4
    // Will result in:
    //                  touchPoints
    //                       0 (no swap)
    //                       2 (2 will swap with 1)
    //                       1

    auto touchIndex = 0; // Index to first unsorted element in touchPoints array
    for (const auto& lastTouchPointId : lastTouchIds_) {
        const auto touchPointIt = std::find_if(touchPoints.begin(), touchPoints.end(), [lastTouchPointId](const TouchPoint& p) { return p.getId() == lastTouchPointId; });
        // Swap current location in the container with the location it was in last touch event.
        if (touchPointIt != touchPoints.end() && std::distance(touchPoints.begin(), touchPointIt) != touchIndex) {
            std::swap(*(touchPoints.begin() + touchIndex), *touchPointIt);
            ++touchIndex;
        }
    }

    for (auto& endedId : endedTouchIds) {
        std::vector<int>::iterator foundIdx = std::find(lastTouchIds_.begin(), lastTouchIds_.end(), endedId);
        if (foundIdx != lastTouchIds_.end())
            lastTouchIds_.erase(foundIdx);
    }

    TouchEvent touchEvent(touchPoints, getScreenDimensions());
    touch->accept();

    // We need to send out touch event all the time to support one -> two finger touch switch
    Canvas::touchEvent(&touchEvent);

    // Mouse events will be triggered for touch events by Qt4 and Qt >= 5.3.0
    // https://bugreports.qt.io/browse/QTBUG-40038
#if defined(USING_QT5) && (QT_VERSION < QT_VERSION_CHECK(5, 3, 0))
    if(touch->touchPoints().size() == 1 && lastNumFingers_ < 2){
        MouseEvent* mouseEvent = nullptr;
        ivec2 pos = ivec2(static_cast<int>(firstPoint.pos().x()), static_cast<int>(firstPoint.pos().y()));
        uvec2 screenPosInvY(static_cast<unsigned int>(pos.x), static_cast<unsigned int>(getScreenDimensions().y-1-pos.y));
        double depth = getDepthValueAtCoord(screenPosInvY);
        switch (touchPoints.front().state())
        {
        case TouchPoint::TOUCH_STATE_STARTED:
            mouseEvent = new MouseEvent(pos, MouseEvent::MOUSE_BUTTON_LEFT, MouseEvent::MOUSE_STATE_PRESS, 
                EventConverterQt::getModifier(touch), getScreenDimensions(), depth);
            Canvas::mousePressEvent(mouseEvent);
            break;
        case TouchPoint::TOUCH_STATE_UPDATED:
            mouseEvent = new MouseEvent(pos, MouseEvent::MOUSE_BUTTON_LEFT, MouseEvent::MOUSE_STATE_MOVE, 
                EventConverterQt::getModifier(touch), getScreenDimensions(), depth);
            Canvas::mouseMoveEvent(mouseEvent);
            break;
        case TouchPoint::TOUCH_STATE_STATIONARY:
            break; // Do not fire event while standing still.
        case TouchPoint::TOUCH_STATE_ENDED:
            mouseEvent = new MouseEvent(pos, MouseEvent::MOUSE_BUTTON_LEFT, MouseEvent::MOUSE_STATE_RELEASE, 
                EventConverterQt::getModifier(touch), getScreenDimensions(), depth);
            Canvas::mouseReleaseEvent(mouseEvent);
            break;
        default:
            break;
        }
        delete mouseEvent;
    }
#endif

    lastNumFingers_ = static_cast<int>(touch->touchPoints().size());
    screenPositionNormalized_ = touchEvent.getCenterPointNormalized();
}