C++ QPinchGesture::scaleFactor方法代码示例

bool TouchSupportManager::handleGesture(QGestureEvent *gestureEvent)
{
	if (gestureEvent->gesture(Qt::TapGesture)) {
		mScroller.onTap();
	} else if (QGesture *tapAndHold = gestureEvent->gesture(Qt::TapAndHoldGesture)) {
		// Filters out tap & hold with mouse
		if (mFingersInGesture > 0) {
			processGestureState(tapAndHold);
			simulateRightClick(static_cast<QTapAndHoldGesture *>(tapAndHold));
		}
	} else if (QGesture *pan = gestureEvent->gesture(Qt::PanGesture)) {
		processGestureState(pan);
		if (mFingersInGesture > 2) {
			mScroller.onPan(pan);
		}
	} else if (QGesture *pinch = gestureEvent->gesture(Qt::PinchGesture)) {
		processGestureState(pinch);
		QPinchGesture *pinchGesture = static_cast<QPinchGesture *>(pinch);
		mEditorView->setTransformationAnchor(QGraphicsView::AnchorViewCenter);
		mEditorView->zoom(pinchGesture->scaleFactor());
		mEditorView->setTransformationAnchor(QGraphicsView::AnchorUnderMouse);
	}

	return true;
}

bool SimObjectWidget::event(QEvent* event)
{
  if(event->type() == QEvent::Gesture)
  {
    QPinchGesture* pinch = static_cast<QPinchGesture*>(static_cast<QGestureEvent*>(event)->gesture(Qt::PinchGesture));
    if(pinch && (pinch->changeFlags() & QPinchGesture::ScaleFactorChanged))
    {
      float change = static_cast<float>(pinch->scaleFactor() > pinch->lastScaleFactor()
                     ? -pinch->scaleFactor() / pinch->lastScaleFactor()
                     : pinch->lastScaleFactor() / pinch->scaleFactor());
      objectRenderer.zoom(change * 100.f);
      update();
      return true;
    }
  }
  return QGLWidget::event(event);
}

bool CanvasQt::gestureEvent(QGestureEvent* ge) {
    QGesture* gesture = nullptr;
    QPanGesture* panGesture = nullptr;
    QPinchGesture* pinchGesture = nullptr;

    if((gesture = ge->gesture(Qt::PanGesture))){
        panGesture = static_cast<QPanGesture *>(gesture);
    }
    if ((gesture = ge->gesture(Qt::PinchGesture))){
        pinchGesture = static_cast<QPinchGesture *>(gesture);
    }

    if(panGesture && pinchGesture){
        double absDeltaDist = glm::abs(static_cast<double>(pinchGesture->scaleFactor())-1.0);
        if(absDeltaDist > 0.05 || (lastType_ == Qt::PinchGesture || lastType_ != Qt::PanGesture)){
            lastType_ = Qt::PinchGesture;
            pinchTriggered(pinchGesture);
        }
        else{
            lastType_ = Qt::PanGesture;
            panTriggered(panGesture);
        }
    }
    else if(panGesture){
        lastType_ = Qt::PanGesture;
        panTriggered(panGesture);
    }
    else if(pinchGesture){
        double absDeltaDist = glm::abs(static_cast<double>(pinchGesture->scaleFactor())-1.0);
        if(absDeltaDist > 0.05)
            lastType_ = Qt::PinchGesture;
        pinchTriggered(pinchGesture);
    }

    ge->accept();
    return true;
}

void CanvasView::gestureEvent(QGestureEvent *event)
{
	QPinchGesture *pinch = static_cast<QPinchGesture*>(event->gesture(Qt::PinchGesture));
	if(pinch) {
		if(pinch->state() == Qt::GestureStarted) {
			_gestureStartZoom = _zoom;
			_gestureStartAngle = _rotate;
		}

		if((pinch->changeFlags() & QPinchGesture::ScaleFactorChanged))
			setZoom(_gestureStartZoom * pinch->scaleFactor());

		if((pinch->changeFlags() & QPinchGesture::RotationAngleChanged))
			setRotation(_gestureStartAngle + pinch->rotationAngle());
	}
}

bool TouchSupportManager::handleGesture(QGestureEvent *gestureEvent)
{
    if (gestureEvent->gesture(Qt::TapGesture)) {
        mScroller.onTap();
    } else if (QGesture *tapAndHold = gestureEvent->gesture(Qt::TapAndHoldGesture)) {
        if (mFingersInGesture > 0) {
            processGestureState(tapAndHold);
            simulateRightClick(static_cast<QTapAndHoldGesture *>(tapAndHold));
        }
    } else if (QGesture *pan = gestureEvent->gesture(Qt::PanGesture)) {
        processGestureState(pan);
        mScroller.onPan(pan);
    } else if (QGesture *pinch = gestureEvent->gesture(Qt::PinchGesture)) {
        processGestureState(pinch);
        QPinchGesture *pinchGesture = static_cast<QPinchGesture *>(pinch);
        mEditorView->zoom(pinchGesture->scaleFactor());
    }
    return true;
}

bool View::gestureEvent(QGestureEvent* event)
{   
    //
    // pinch has precedence
    if (QGesture *pinchEvent = event->gesture(Qt::PinchGesture)) {
        QPinchGesture* pinch = static_cast<QPinchGesture*>(pinchEvent);

        //
        // only pinch if the fingers have already moved a significant amount
        qreal totalScaleFactor = pinch->totalScaleFactor();
        if((totalScaleFactor < 0.66) || (totalScaleFactor > 1.5)){
            qreal zoomDelta = pinch->scaleFactor();
            qreal resultZoom = m_zoomFactor * zoomDelta;
            if(resultZoom > s_maxZoomFactor){
                zoomDelta = s_maxZoomFactor / m_zoomFactor;
            }else if(resultZoom < s_minZoomFactor){
                zoomDelta = s_minZoomFactor / m_zoomFactor;
            }

            // scale the view
            scale(zoomDelta,zoomDelta);
            m_zoomFactor *= zoomDelta;

            return true;
        }
    }

    //
    // pan
    if (QGesture *panEvent = event->gesture(Qt::PanGesture)) {
        QPanGesture* pan = static_cast<QPanGesture*>(panEvent);
        QPointF delta = pan->delta();
        qreal factor = (1.0 / m_zoomFactor) * 0.9;

        QScrollBar* vScrollBar = verticalScrollBar();
        vScrollBar->setValue(vScrollBar->value() - int(delta.y()/factor));

        QScrollBar* hScrollBar = horizontalScrollBar();
        hScrollBar->setValue(hScrollBar->value() - int(delta.x()/factor));
    }

    return true;
}

bool HPiano::gestureEvent(QGestureEvent *event)
      {
      if (QGesture *gesture = event->gesture(Qt::PinchGesture)) {
            // Zoom in/out when receiving a pinch gesture
            QPinchGesture *pinch = static_cast<QPinchGesture *>(gesture);

            static qreal magStart = 1.0;
            if (pinch->state() == Qt::GestureStarted) {
                  magStart = scaleVal;
                  }
            if (pinch->changeFlags() & QPinchGesture::ScaleFactorChanged) {
                  // On Windows, totalScaleFactor() contains the net magnification.
                  // On OS X, totalScaleFactor() is 1, and scaleFactor() contains the net magnification.
                  qreal value = pinch->totalScaleFactor();
                  if (value == 1) {
                        value = pinch->scaleFactor();
                        }
                  // Qt 5.4 doesn't report pinch->centerPoint() correctly
                  setScale(magStart*value);
                  }
            }
      return true;
      }

//===============================================================
bool MousePanNZoomNavigator::eventFilter(QObject *widget, QEvent *e) {
// according to Qt's doc, this constant has been defined by wheel mouse vendors
// we need it to interpret the value of QWheelEvent->delta()
#define WHEEL_DELTA 120
  if (e->type() == QEvent::Wheel &&
      (((QWheelEvent *) e)->orientation() == Qt::Vertical)) {

    GlMainWidget *g = (GlMainWidget *) widget;

    if(((QWheelEvent *) e)->delta() < 0 && g->getScene()->getCamera().getZoomFactor() < 0.5f) {
      return true;
    }

    g->getScene()->zoomXY(((QWheelEvent *) e)->delta() / WHEEL_DELTA,
                          ((QWheelEvent *) e)->x(), ((QWheelEvent *) e)->y());
    g->draw(false);
    return true;
  }

  if(e->type() == QEvent::Gesture) {
    GlMainWidget *g = (GlMainWidget *) widget;
    QGestureEvent* gesture = (QGestureEvent*)e;
    QPointF center;
    //swipe events and pan events are never fired, known Qt bug
    /*if(gesture->gesture(Qt::SwipeGesture)) {
      QSwipeGesture* swipe = (QSwipeGesture*)gesture->gesture(Qt::SwipeGesture);
      int x = cos(swipe->swipeAngle()) * swipe->property("velocity").toFloat();
      int y = sin(swipe->swipeAngle()) * swipe->property("velocity").toFloat();
      g->getScene()->translateCamera(x, y, 0);
    }*/

    if(gesture->gesture(Qt::PinchGesture)) {
      QPinchGesture* pinch = (QPinchGesture*)gesture->gesture(Qt::PinchGesture);
      Camera& camera = g->getScene()->getCamera();

      //store the camera scale factor when starting the gesture
      if(pinch->state() == Qt::GestureStarted) {
        cameraScaleFactor = camera.getZoomFactor();
        isGesturing = true;
      }

      if(pinch->changeFlags() & QPinchGesture::ScaleFactorChanged) {
        //only set the zoom factor if two events in a row were in the same direction (zoom in or out) to smooth a bit the effect.
        if((pinch->lastScaleFactor() > 1 && pinch->scaleFactor() > 1) || (pinch->lastScaleFactor() <= 1 && pinch->scaleFactor() <= 1)) {
          camera.setZoomFactor(cameraScaleFactor * pinch->totalScaleFactor());
        }
      }

      if(pinch->changeFlags() & QPinchGesture::RotationAngleChanged) {
        /*//backup the current camera center
              Coord oldCenter = camera.getCenter();
              Coord oldEye = camera.getEyes();
        //sets the camera center to the center of the pich gesture
              Coord rotationCenter(g->mapFromGlobal(pinch->centerPoint().toPoint()).x(), g->mapFromGlobal(pinch->centerPoint().toPoint()).y(), oldCenter.getZ());
              Coord rotationEye=camera.getEyes()+(rotationCenter-oldCenter);
              camera.setCenter(rotationCenter);
              camera.setEyes(rotationEye);*/
        //rotates the camera
        camera.rotate((pinch->rotationAngle() - pinch->lastRotationAngle())/180*M_PI, 0, 0, 1);
        /*
        //restore old camera center and eyes
              camera.setCenter(oldCenter);
              camera.setEyes(oldEye); */
      }

      if(pinch->state() == Qt::GestureFinished) {
        isGesturing = false;
      }

      if(gesture->gesture(Qt::PanGesture)) {
        QPanGesture* pan = (QPanGesture*)gesture->gesture(Qt::PanGesture);

        if(pan->state() == Qt::GestureStarted) {
          isGesturing = true;
        }

        if(pan->state() == Qt::GestureFinished) {
          isGesturing = false;
        }

        center = pan->delta();
        g->getScene()->translateCamera(pan->delta().x(), -pan->delta().y(), 0);
      }
    }

    g->draw(false);
    return true;
  }

  return false;
}