/*! Draw step function The direction of the steps depends on Inverted attribute. \param painter Painter \param xMap x map \param yMap y map \param canvasRect Contents rectangle of the canvas \param from index of the first point to be painted \param to index of the last point to be painted \sa CurveAttribute, setCurveAttribute(), draw(), drawCurve(), drawDots(), drawLines(), drawSticks() */ void QwtPlotCurve::drawSteps( QPainter *painter, const QwtScaleMap &xMap, const QwtScaleMap &yMap, const QRectF &canvasRect, int from, int to ) const { const bool doAlign = QwtPainter::roundingAlignment( painter ); QPolygonF polygon( 2 * ( to - from ) + 1 ); QPointF *points = polygon.data(); bool inverted = orientation() == Qt::Vertical; if ( d_data->attributes & Inverted ) inverted = !inverted; const QwtSeriesData<QPointF> *series = data(); int i, ip; for ( i = from, ip = 0; i <= to; i++, ip += 2 ) { const QPointF sample = series->sample( i ); double xi = xMap.transform( sample.x() ); double yi = yMap.transform( sample.y() ); if ( doAlign ) { xi = qRound( xi ); yi = qRound( yi ); } if ( ip > 0 ) { const QPointF &p0 = points[ip - 2]; QPointF &p = points[ip - 1]; if ( inverted ) { p.rx() = p0.x(); p.ry() = yi; } else { p.rx() = xi; p.ry() = p0.y(); } } points[ip].rx() = xi; points[ip].ry() = yi; } if ( d_data->paintAttributes & ClipPolygons ) { QRectF clipRect = qwtIntersectedClipRect( canvasRect, painter ); const qreal pw = qMax( qreal( 1.0 ), painter->pen().widthF()); clipRect = clipRect.adjusted(-pw, -pw, pw, pw); const QPolygonF clipped = QwtClipper::clipPolygonF( clipRect, polygon, false ); QwtPainter::drawPolyline( painter, clipped ); } else { QwtPainter::drawPolyline( painter, polygon ); } if ( d_data->brush.style() != Qt::NoBrush ) fillCurve( painter, xMap, yMap, canvasRect, polygon ); }
void QtGradientWidget::mousePressEvent(QMouseEvent *e) { if (e->button() != Qt::LeftButton) return; QPoint p = e->pos(); if (d_ptr->m_gradientType == QGradient::LinearGradient) { QPointF startPoint = d_ptr->toViewport(d_ptr->m_startLinear); double x = p.x() - startPoint.x(); double y = p.y() - startPoint.y(); if ((d_ptr->m_handleSize * d_ptr->m_handleSize / 4) > (x * x + y * y)) { d_ptr->m_dragHandle = QtGradientWidgetPrivate::StartLinearHandle; d_ptr->m_dragOffset = QPointF(x, y); update(); return; } QPointF endPoint = d_ptr->toViewport(d_ptr->m_endLinear); x = p.x() - endPoint.x(); y = p.y() - endPoint.y(); if ((d_ptr->m_handleSize * d_ptr->m_handleSize / 4) > (x * x + y * y)) { d_ptr->m_dragHandle = QtGradientWidgetPrivate::EndLinearHandle; d_ptr->m_dragOffset = QPointF(x, y); update(); return; } } else if (d_ptr->m_gradientType == QGradient::RadialGradient) { QPointF focalPoint = d_ptr->toViewport(d_ptr->m_focalRadial); double x = p.x() - focalPoint.x(); double y = p.y() - focalPoint.y(); if ((d_ptr->m_handleSize * d_ptr->m_handleSize / 9) > (x * x + y * y)) { d_ptr->m_dragHandle = QtGradientWidgetPrivate::FocalRadialHandle; d_ptr->m_dragOffset = QPointF(x, y); update(); return; } QPointF centralPoint = d_ptr->toViewport(d_ptr->m_centralRadial); x = p.x() - centralPoint.x(); y = p.y() - centralPoint.y(); if ((d_ptr->m_handleSize * d_ptr->m_handleSize / 4) > (x * x + y * y)) { d_ptr->m_dragHandle = QtGradientWidgetPrivate::CentralRadialHandle; d_ptr->m_dragOffset = QPointF(x, y); update(); return; } QPointF central = d_ptr->toViewport(d_ptr->m_centralRadial); QRectF r = d_ptr->pointRect(central, 2 * d_ptr->m_handleSize / 3); QRectF r1(0, r.y(), size().width(), r.height()); QRectF r2(r.x(), 0, r.width(), r.y()); QRectF r3(r.x(), r.y() + r.height(), r.width(), size().height() - r.y() - r.height()); QPointF pF(p.x(), p.y()); if (r1.contains(pF) || r2.contains(pF) || r3.contains(pF)) { x = pF.x() / size().width() - d_ptr->m_centralRadial.x(); y = pF.y() / size().height() - d_ptr->m_centralRadial.y(); double clickRadius = sqrt(x * x + y * y); //d_ptr->m_radiusOffset = d_ptr->m_radiusRadial - clickRadius; d_ptr->m_radiusFactor = d_ptr->m_radiusRadial / clickRadius; if (d_ptr->m_radiusFactor == 0) d_ptr->m_radiusFactor = 1; d_ptr->m_dragRadius = d_ptr->m_radiusRadial; d_ptr->m_dragHandle = QtGradientWidgetPrivate::RadiusRadialHandle; mouseMoveEvent(e); update(); return; } } else if (d_ptr->m_gradientType == QGradient::ConicalGradient) { QPointF centralPoint = d_ptr->toViewport(d_ptr->m_centralConical); double x = p.x() - centralPoint.x(); double y = p.y() - centralPoint.y(); if ((d_ptr->m_handleSize * d_ptr->m_handleSize / 4) > (x * x + y * y)) { d_ptr->m_dragHandle = QtGradientWidgetPrivate::CentralConicalHandle; d_ptr->m_dragOffset = QPointF(x, y); update(); return; } double radius = size().width(); if (size().height() < radius) radius = size().height(); radius /= 2; double corr = d_ptr->m_handleSize / 3; radius -= corr; QPointF vp = d_ptr->toViewport(d_ptr->m_centralConical); x = p.x() - vp.x(); y = p.y() - vp.y(); if (((radius - corr) * (radius - corr) < (x * x + y * y)) && ((radius + corr) * (radius + corr) > (x * x + y * y))) { QPointF central = d_ptr->toViewport(d_ptr->m_centralConical); QPointF current(e->pos().x(), e->pos().y()); x = current.x() - central.x(); y = current.y() - central.y(); x /= size().width() / 2; y /= size().height() / 2; double r = sqrt(x * x + y * y); double arcSin = asin(y / r); double arcCos = acos(x / r); double angle = arcCos * 180 / M_PI; if (arcSin > 0) { angle = -angle; } d_ptr->m_angleOffset = d_ptr->m_angleConical - angle; d_ptr->m_dragAngle = d_ptr->m_angleConical; d_ptr->m_dragHandle = QtGradientWidgetPrivate::AngleConicalHandle; update(); return; } } }
void QtGradientWidget::paintEvent(QPaintEvent *e) { Q_UNUSED(e) QPainter p(this); if (d_ptr->m_backgroundCheckered) { int pixSize = 40; QPixmap pm(2 * pixSize, 2 * pixSize); QPainter pmp(&pm); pmp.fillRect(0, 0, pixSize, pixSize, Qt::white); pmp.fillRect(pixSize, pixSize, pixSize, pixSize, Qt::white); pmp.fillRect(0, pixSize, pixSize, pixSize, Qt::black); pmp.fillRect(pixSize, 0, pixSize, pixSize, Qt::black); p.setBrushOrigin((size().width() % pixSize + pixSize) / 2, (size().height() % pixSize + pixSize) / 2); p.fillRect(rect(), pm); p.setBrushOrigin(0, 0); } QGradient *gradient = 0; switch (d_ptr->m_gradientType) { case QGradient::LinearGradient: gradient = new QLinearGradient(d_ptr->m_startLinear, d_ptr->m_endLinear); break; case QGradient::RadialGradient: gradient = new QRadialGradient(d_ptr->m_centralRadial, d_ptr->m_radiusRadial, d_ptr->m_focalRadial); break; case QGradient::ConicalGradient: gradient = new QConicalGradient(d_ptr->m_centralConical, d_ptr->m_angleConical); break; default: break; } if (!gradient) return; gradient->setStops(d_ptr->m_gradientStops); gradient->setSpread(d_ptr->m_gradientSpread); p.save(); p.scale(size().width(), size().height()); p.fillRect(QRect(0, 0, 1, 1), *gradient); p.restore(); p.setRenderHint(QPainter::Antialiasing); QColor c = QColor::fromRgbF(0.5, 0.5, 0.5, 0.5); QBrush br(c); p.setBrush(br); QPen pen(Qt::white); pen.setWidthF(1); p.setPen(pen); QPen dragPen = pen; dragPen.setWidthF(2); if (d_ptr->m_gradientType == QGradient::LinearGradient) { p.save(); if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::StartLinearHandle) p.setPen(dragPen); d_ptr->paintPoint(&p, d_ptr->m_startLinear, d_ptr->m_handleSize); p.restore(); p.save(); if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::EndLinearHandle) p.setPen(dragPen); d_ptr->paintPoint(&p, d_ptr->m_endLinear, d_ptr->m_handleSize); p.restore(); } else if (d_ptr->m_gradientType == QGradient::RadialGradient) { QPointF central = d_ptr->toViewport(d_ptr->m_centralRadial); p.save(); QRectF r = d_ptr->pointRect(central, 2 * d_ptr->m_handleSize / 3); QRectF r1(0, r.y(), size().width(), r.height()); QRectF r2(r.x(), 0, r.width(), r.y()); QRectF r3(r.x(), r.y() + r.height(), r.width(), size().height() - r.y() - r.height()); p.fillRect(r1, c); p.fillRect(r2, c); p.fillRect(r3, c); p.setBrush(Qt::NoBrush); p.save(); if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::CentralRadialHandle) p.setPen(dragPen); d_ptr->paintPoint(&p, d_ptr->m_centralRadial, d_ptr->m_handleSize); p.restore(); QRectF rect = QRectF(central.x() - d_ptr->m_radiusRadial * size().width(), central.y() - d_ptr->m_radiusRadial * size().height(), 2 * d_ptr->m_radiusRadial * size().width(), 2 * d_ptr->m_radiusRadial * size().height()); p.setClipRect(r1); p.setClipRect(r2, Qt::UniteClip); p.setClipRect(r3, Qt::UniteClip); p.drawEllipse(rect); if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::RadiusRadialHandle) { p.save(); p.setPen(dragPen); QRectF rect = QRectF(central.x() - d_ptr->m_radiusRadial / d_ptr->m_radiusFactor * size().width(), central.y() - d_ptr->m_radiusRadial / d_ptr->m_radiusFactor * size().height(), 2 * d_ptr->m_radiusRadial / d_ptr->m_radiusFactor * size().width(), 2 * d_ptr->m_radiusRadial / d_ptr->m_radiusFactor * size().height()); p.drawEllipse(rect); p.restore(); } p.restore(); p.save(); if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::FocalRadialHandle) p.setPen(dragPen); d_ptr->paintPoint(&p, d_ptr->m_focalRadial, 2 * d_ptr->m_handleSize / 3); p.restore(); } else if (d_ptr->m_gradientType == QGradient::ConicalGradient) { double radius = size().width(); if (size().height() < radius) radius = size().height(); radius /= 2; double corr = d_ptr->m_handleSize / 3; radius -= corr; QPointF central = d_ptr->toViewport(d_ptr->m_centralConical); p.save(); p.setBrush(Qt::NoBrush); QPen pen2(c); pen2.setWidthF(2 * d_ptr->m_handleSize / 3); p.setPen(pen2); p.drawEllipse(d_ptr->pointRect(central, 2 * radius)); p.restore(); p.save(); p.setBrush(Qt::NoBrush); int pointCount = 2; for (int i = 0; i < pointCount; i++) { QPointF ang(cos(M_PI * (i * 180.0 / pointCount + d_ptr->m_angleConical) / 180) * size().width() / 2, -sin(M_PI * (i * 180.0 / pointCount + d_ptr->m_angleConical) / 180) * size().height() / 2); double mod = sqrt(ang.x() * ang.x() + ang.y() * ang.y()); p.drawLine(QPointF(central.x() + ang.x() * (radius - corr) / mod, central.y() + ang.y() * (radius - corr) / mod), QPointF(central.x() + ang.x() * (radius + corr) / mod, central.y() + ang.y() * (radius + corr) / mod)); p.drawLine(QPointF(central.x() - ang.x() * (radius - corr) / mod, central.y() - ang.y() * (radius - corr) / mod), QPointF(central.x() - ang.x() * (radius + corr) / mod, central.y() - ang.y() * (radius + corr) / mod)); } if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::AngleConicalHandle) { p.save(); p.setPen(dragPen); QPointF ang(cos(M_PI * (d_ptr->m_angleConical - d_ptr->m_angleOffset) / 180) * size().width() / 2, -sin(M_PI * (d_ptr->m_angleConical - d_ptr->m_angleOffset) / 180) * size().height() / 2); double mod = sqrt(ang.x() * ang.x() + ang.y() * ang.y()); p.drawLine(QPointF(central.x() + ang.x() * (radius - corr) / mod, central.y() + ang.y() * (radius - corr) / mod), QPointF(central.x() + ang.x() * (radius + corr) / mod, central.y() + ang.y() * (radius + corr) / mod)); p.restore(); } p.restore(); p.save(); if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::CentralConicalHandle) p.setPen(dragPen); d_ptr->paintPoint(&p, d_ptr->m_centralConical, d_ptr->m_handleSize); p.restore(); } delete gradient; }
void QgsMapToolAnnotation::canvasMoveEvent( QMouseEvent * e ) { QgsAnnotationItem* sItem = selectedItem(); if ( sItem && ( e->buttons() & Qt::LeftButton ) ) { if ( mCurrentMoveAction == QgsAnnotationItem::MoveMapPosition ) { sItem->setMapPosition( toMapCoordinates( e->pos() ) ); sItem->update(); } else if ( mCurrentMoveAction == QgsAnnotationItem::MoveFramePosition ) { if ( sItem->mapPositionFixed() ) { sItem->setOffsetFromReferencePoint( sItem->offsetFromReferencePoint() + ( e->posF() - mLastMousePosition ) ); } else { QPointF newCanvasPos = sItem->pos() + ( e->posF() - mLastMousePosition ); sItem->setMapPosition( toMapCoordinates( newCanvasPos.toPoint() ) ); } sItem->update(); } else if ( mCurrentMoveAction != QgsAnnotationItem::NoAction ) { //handle the frame resize actions QSizeF size = sItem->frameSize(); double xmin = sItem->offsetFromReferencePoint().x(); double ymin = sItem->offsetFromReferencePoint().y(); double xmax = xmin + size.width(); double ymax = ymin + size.height(); if ( mCurrentMoveAction == QgsAnnotationItem::ResizeFrameRight || mCurrentMoveAction == QgsAnnotationItem::ResizeFrameRightDown || mCurrentMoveAction == QgsAnnotationItem::ResizeFrameRightUp ) { xmax += e->posF().x() - mLastMousePosition.x(); } if ( mCurrentMoveAction == QgsAnnotationItem::ResizeFrameLeft || mCurrentMoveAction == QgsAnnotationItem::ResizeFrameLeftDown || mCurrentMoveAction == QgsAnnotationItem::ResizeFrameLeftUp ) { xmin += e->posF().x() - mLastMousePosition.x(); } if ( mCurrentMoveAction == QgsAnnotationItem::ResizeFrameUp || mCurrentMoveAction == QgsAnnotationItem::ResizeFrameLeftUp || mCurrentMoveAction == QgsAnnotationItem::ResizeFrameRightUp ) { ymin += e->posF().y() - mLastMousePosition.y(); } if ( mCurrentMoveAction == QgsAnnotationItem::ResizeFrameDown || mCurrentMoveAction == QgsAnnotationItem::ResizeFrameLeftDown || mCurrentMoveAction == QgsAnnotationItem::ResizeFrameRightDown ) { ymax += e->posF().y() - mLastMousePosition.y(); } //switch min / max if necessary double tmp; if ( xmax < xmin ) { tmp = xmax; xmax = xmin; xmin = tmp; } if ( ymax < ymin ) { tmp = ymax; ymax = ymin; ymin = tmp; } sItem->setOffsetFromReferencePoint( QPointF( xmin, ymin ) ); sItem->setFrameSize( QSizeF( xmax - xmin, ymax - ymin ) ); sItem->update(); } } else if ( sItem ) { QgsAnnotationItem::MouseMoveAction moveAction = sItem->moveActionForPosition( e->posF() ); if ( mCanvas ) { mCanvas->setCursor( QCursor( sItem->cursorShapeForAction( moveAction ) ) ); } } mLastMousePosition = e->posF(); }
QRectF QtGradientWidgetPrivate::pointRect(const QPointF &point, double size) const { return QRectF(point.x() - size / 2, point.y() - size / 2, size, size); }
void Arrow::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *) { qDebug() << "Arrow: paint"; if (myStartItem->collidesWithItem(myEndItem)) return; /* QPen myPen = pen(); myPen.setColor(myColor); qreal arrowSize = 20; painter->setPen(myPen); painter->setBrush(myColor); QLineF centerLine(myStartItem->pos(), myEndItem->pos()); QPolygonF endPolygon = myEndItem->polygon(); //p1 = coordinates of first pointer of enditem in //scene coordinates QPointF p1 = endPolygon.first() + myEndItem->pos(); QPointF p2; QPointF intersectPoint; QLineF polyLine; //.count()=.size() for (int i = 1; i < endPolygon.count(); ++i) { p2 = endPolygon.at(i) + myEndItem->pos(); polyLine = QLineF(p1, p2); QLineF::IntersectType intersectType = polyLine.intersect(centerLine, &intersectPoint); if (intersectType == QLineF::BoundedIntersection) break; p1 = p2; } */ //qreal comp1=intersectPoint.x(); //qreal comp2; //TODO: //This is my patch to define input and output points for lines //All code above this point is rendered useless and should be removed QPointF intersectPoint; QPen myPen = pen(); myPen.setColor(myColor); qreal arrowSize = 20; painter->setPen(myPen); painter->setBrush(myColor); intersectPoint=myEndItem->pos(); intersectPoint.setX(intersectPoint.x()-myEndItem->boundingRect().width()/2); QPointF otherPoint; otherPoint=myStartItem->pos(); otherPoint.setX(otherPoint.x()+myStartItem->boundingRect().width()/2); //original setLine(QLineF(otherPoint, intersectPoint)); if(isZone2()){ zone2(otherPoint); } else{ zone1(otherPoint); } //double angle = ::acos(line().dx() / line().length()); double angle=Pi; if (line().dy() >= 0) angle = (Pi * 2) - angle; QPointF arrowP1 = line().p2() + QPointF(sin(angle + Pi / 3) * arrowSize, cos(angle + Pi / 3) * arrowSize); QPointF arrowP2 = line().p2() + QPointF(sin(angle + Pi - Pi / 3) * arrowSize, cos(angle + Pi - Pi / 3) * arrowSize); arrowHead.clear(); arrowHead << line().p2() << arrowP1 << arrowP2; for(int i=0;i<part.size();++i) painter->drawLine(*part[i]); //setLine(*part[0]); //painter->drawLine(line()); painter->drawPolygon(arrowHead); if (isSelected()) { painter->setPen(QPen(myColor, 1, Qt::DashLine)); QLineF myLine = line(); myLine.translate(0, 4.0); painter->drawLine(myLine); myLine.translate(0,-8.0); painter->drawLine(myLine); } //qDebug() << "PAINT ORDER FINISH"; }
void PlotObject::updatePath() { _path = QPainterPath(); if (((SelectProperty*) properties()["mode"])->currentIndex() == 0) { QList<qreal> xValues; QList<qreal> yValues; qreal start = ((RealProperty*) properties()["start"])->value(); qreal end = ((RealProperty*) properties()["end"])->value(); qreal pointCount = ((IntegerProperty*) properties()["points"])->value(); qreal step = (end - start) / pointCount; if (step > 0) { for (qreal x = start; x <= end; x += step) { xValues.append(x); } } else if (step < 0) { for (qreal x = start; x >= end; x += step) { xValues.append(x); } } else { return; } if (xValues.isEmpty()) return; yValues = MathUtility::parse(((PropertyString*) properties()["formular"])->string(), xValues); _path = QPainterPath(QPointF(xValues.first(), yValues.first())); for (int i = 1; i < xValues.size(); i++) { _path.lineTo(xValues[i], yValues[i]); } } else { QList<qreal> alphas; QList<qreal> radius; qreal start = ((RealProperty*) properties()["polar-start"])->value() * M_PI/180.0; qreal end = ((RealProperty*) properties()["polar-end"])->value() * M_PI/180.0; qreal pointCount = ((IntegerProperty*) properties()["points"])->value(); qreal step = (end - start) / pointCount; if (step > 0) { for (qreal x = start; x <= end; x += step) { alphas.append(x); } } else if (step < 0) { for (qreal x = start; x >= end; x += step) { alphas.append(x); } } else { return; } radius = MathUtility::parse(((PropertyString*) properties()["formular"])->string(), alphas); auto polarToCart = [](qreal alpha, qreal radius) { return QPointF(qCos(alpha) * radius, qSin(alpha) * radius); }; _path = QPainterPath(polarToCart(alphas.first(), radius.first())); for (int i = 1; i < alphas.size(); i++) { QPointF p = polarToCart(alphas[i], radius[i]); _path.lineTo(p.x(), p.y()); } } }
ShapeShearStrategy::ShapeShearStrategy(KToolBase *tool, const QPointF &clicked, KFlake::SelectionHandle direction) : KInteractionStrategy(tool) , m_start(clicked) { KShapeSelection *sel = tool->canvas()->shapeManager()->selection(); QList<KShape*> selectedShapes = sel->selectedShapes(KFlake::StrippedSelection); foreach (KShape *shape, selectedShapes) { if (!shape->isEditable()) continue; m_selectedShapes << shape; m_oldTransforms << shape->transformation(); } m_initialSelectionMatrix = sel->transformation(); // Eventhoug we aren't currently activated by the corner handles we might as well code like it switch (direction) { case KFlake::TopMiddleHandle: m_top = true; m_bottom = false; m_left = false; m_right = false; break; case KFlake::TopRightHandle: m_top = true; m_bottom = false; m_left = false; m_right = true; break; case KFlake::RightMiddleHandle: m_top = false; m_bottom = false; m_left = false; m_right = true; break; case KFlake::BottomRightHandle: m_top = false; m_bottom = true; m_left = false; m_right = true; break; case KFlake::BottomMiddleHandle: m_top = false; m_bottom = true; m_left = false; m_right = false; break; case KFlake::BottomLeftHandle: m_top = false; m_bottom = true; m_left = true; m_right = false; break; case KFlake::LeftMiddleHandle: m_top = false; m_bottom = false; m_left = true; m_right = false; break; case KFlake::TopLeftHandle: m_top = true; m_bottom = false; m_left = true; m_right = false; break; default: Q_ASSERT(0); } m_initialSize = sel->size(); m_solidPoint = QPointF(m_initialSize.width() / 2, m_initialSize.height() / 2); if (m_top) m_solidPoint += QPointF(0, m_initialSize.height() / 2); else if (m_bottom) m_solidPoint -= QPointF(0, m_initialSize.height() / 2); if (m_left) m_solidPoint += QPointF(m_initialSize.width() / 2, 0); else if (m_right) m_solidPoint -= QPointF(m_initialSize.width() / 2, 0); QPointF edge; qreal angle = 0.0; if (m_top) { edge = sel->absolutePosition(KFlake::BottomLeftCorner) - sel->absolutePosition(KFlake::BottomRightCorner); angle = 180.0; } else if (m_bottom) { edge = sel->absolutePosition(KFlake::TopRightCorner) - sel->absolutePosition(KFlake::TopLeftCorner); angle = 0.0; } else if (m_left) { edge = sel->absolutePosition(KFlake::BottomLeftCorner) - sel->absolutePosition(KFlake::TopLeftCorner); angle = 90.0; } else if (m_right) { edge = sel->absolutePosition(KFlake::TopRightCorner) - sel->absolutePosition(KFlake::BottomRightCorner); angle = 270.0; } qreal currentAngle = atan2(edge.y(), edge.x()) / M_PI * 180; m_initialSelectionAngle = currentAngle - angle; //kDebug() <<" PREsol.x=" << m_solidPoint.x() <<" sol.y=" << m_solidPoint.y(); m_solidPoint = tool->canvas()->shapeManager()->selection()->absoluteTransformation(0).map(m_solidPoint); // use crossproduct of top edge and left edge of selection bounding rect // to determine if the selection is mirrored QPointF top = sel->absolutePosition(KFlake::TopRightCorner) - sel->absolutePosition(KFlake::TopLeftCorner); QPointF left = sel->absolutePosition(KFlake::BottomLeftCorner) - sel->absolutePosition(KFlake::TopLeftCorner); m_isMirrored = (top.x()*left.y() - top.y()*left.x()) < 0.0; }
QPointF operator+(QPointF &p) { QPointF b(p.x()+m_X,p.y()+m_Y); return b; }
void QgsEllipseSymbolLayerV2::renderPoint( const QPointF& point, QgsSymbolV2RenderContext& context ) { bool ok; if ( hasDataDefinedProperty( "outline_width" ) ) { double width = evaluateDataDefinedProperty( "outline_width", context.feature(), mOutlineWidth ).toDouble(); width *= QgsSymbolLayerV2Utils::lineWidthScaleFactor( context.renderContext(), mOutlineWidthUnit, mOutlineWidthMapUnitScale ); mPen.setWidthF( width ); } if ( hasDataDefinedProperty( "outline_style" ) ) { QString styleString = evaluateDataDefinedProperty( "outline_style", context.feature(), QVariant(), &ok ).toString(); if ( ok ) { Qt::PenStyle style = QgsSymbolLayerV2Utils::decodePenStyle( styleString ); mPen.setStyle( style ); } } if ( hasDataDefinedProperty( "fill_color" ) ) { QString colorString = evaluateDataDefinedProperty( "fill_color", context.feature(), QVariant(), &ok ).toString(); if ( ok ) mBrush.setColor( QColor( QgsSymbolLayerV2Utils::decodeColor( colorString ) ) ); } if ( hasDataDefinedProperty( "outline_color" ) ) { QString colorString = evaluateDataDefinedProperty( "outline_color", context.feature(), QVariant(), &ok ).toString(); if ( ok ) mPen.setColor( QColor( QgsSymbolLayerV2Utils::decodeColor( colorString ) ) ); } double scaledWidth = mSymbolWidth; double scaledHeight = mSymbolHeight; if ( hasDataDefinedProperty( "width" ) || hasDataDefinedProperty( "height" ) || hasDataDefinedProperty( "symbol_name" ) ) { QString symbolName = mSymbolName; if ( hasDataDefinedProperty( "symbol_name" ) ) { symbolName = evaluateDataDefinedProperty( "symbol_name", context.feature(), mSymbolName ).toString(); } preparePath( symbolName, context, &scaledWidth, &scaledHeight, context.feature() ); } //offset double offsetX = 0; double offsetY = 0; markerOffset( context, scaledWidth, scaledHeight, mSymbolWidthUnit, mSymbolHeightUnit, offsetX, offsetY, mSymbolWidthMapUnitScale, mSymbolHeightMapUnitScale ); QPointF off( offsetX, offsetY ); QPainter* p = context.renderContext().painter(); if ( !p ) { return; } //priority for rotation: 1. data defined symbol level, 2. symbol layer rotation (mAngle) double rotation = 0.0; if ( hasDataDefinedProperty( "rotation" ) ) { rotation = evaluateDataDefinedProperty( "rotation", context.feature(), mAngle ).toDouble(); } else if ( !qgsDoubleNear( mAngle, 0.0 ) ) { rotation = mAngle; } if ( rotation ) off = _rotatedOffset( off, rotation ); QMatrix transform; transform.translate( point.x() + off.x(), point.y() + off.y() ); if ( !qgsDoubleNear( rotation, 0.0 ) ) { transform.rotate( rotation ); } p->setPen( mPen ); p->setBrush( mBrush ); p->drawPath( transform.map( mPainterPath ) ); }
bool QgsEllipseSymbolLayerV2::writeDxf( QgsDxfExport& e, double mmMapUnitScaleFactor, const QString& layerName, const QgsSymbolV2RenderContext* context, const QgsFeature* f, const QPointF& shift ) const { //width double symbolWidth = mSymbolWidth; if ( hasDataDefinedProperty( "width" ) ) //1. priority: data defined setting on symbol layer le { symbolWidth = evaluateDataDefinedProperty( "width", f, mSymbolWidth ).toDouble(); } else if ( context->renderHints() & QgsSymbolV2::DataDefinedSizeScale ) //2. priority: is data defined size on symbol level { symbolWidth = mSize; } if ( mSymbolWidthUnit == QgsSymbolV2::MM ) { symbolWidth *= mmMapUnitScaleFactor; } //height double symbolHeight = mSymbolHeight; if ( hasDataDefinedProperty( "height" ) ) //1. priority: data defined setting on symbol layer level { symbolHeight = evaluateDataDefinedProperty( "height", f, mSymbolHeight ).toDouble(); } else if ( context->renderHints() & QgsSymbolV2::DataDefinedSizeScale ) //2. priority: is data defined size on symbol level { symbolHeight = mSize; } if ( mSymbolHeightUnit == QgsSymbolV2::MM ) { symbolHeight *= mmMapUnitScaleFactor; } //outline width double outlineWidth = mOutlineWidth; if ( hasDataDefinedProperty( "outline_width" ) ) { outlineWidth = evaluateDataDefinedProperty( "outline_width", f, mOutlineWidth ).toDouble(); } if ( mOutlineWidthUnit == QgsSymbolV2::MM ) { outlineWidth *= outlineWidth; } //fill color bool ok; QColor fc = mFillColor; if ( hasDataDefinedProperty( "fill_color" ) ) { QString colorString = evaluateDataDefinedProperty( "fill_color", f, QVariant(), &ok ).toString(); if ( ok ) fc = QColor( colorString ); } //outline color QColor oc = mOutlineColor; if ( hasDataDefinedProperty( "outline_color" ) ) { QString colorString = evaluateDataDefinedProperty( "outline_color", f, QVariant(), &ok ).toString(); if ( ok ) oc = QColor( colorString ); } //symbol name QString symbolName = mSymbolName; if ( hasDataDefinedProperty( "symbol_name" ) ) { symbolName = evaluateDataDefinedProperty( "symbol_name", f, mSymbolName ).toString(); } //offset double offsetX = 0; double offsetY = 0; markerOffset( *context, offsetX, offsetY ); QPointF off( offsetX, offsetY ); //priority for rotation: 1. data defined symbol level, 2. symbol layer rotation (mAngle) double rotation = 0.0; if ( hasDataDefinedProperty( "rotation" ) ) { rotation = evaluateDataDefinedProperty( "rotation", f, mAngle ).toDouble(); } else if ( !qgsDoubleNear( mAngle, 0.0 ) ) { rotation = mAngle; } rotation = -rotation; //rotation in Qt is counterclockwise if ( rotation ) off = _rotatedOffset( off, rotation ); QTransform t; t.translate( shift.x() + offsetX, shift.y() + offsetY ); if ( rotation != 0 ) t.rotate( rotation ); double halfWidth = symbolWidth / 2.0; double halfHeight = symbolHeight / 2.0; if ( symbolName == "circle" ) { if ( qgsDoubleNear( halfWidth, halfHeight ) ) { QPointF pt( t.map( QPointF( 0, 0 ) ) ); e.writeFilledCircle( layerName, oc, pt, halfWidth ); } else { QgsPolyline line; double stepsize = 2 * M_PI / 40; for ( int i = 0; i < 39; ++i ) { double angle = stepsize * i; double x = halfWidth * cos( angle ); double y = halfHeight * sin( angle ); QPointF pt( t.map( QPointF( x, y ) ) ); line.push_back( pt ); } //close ellipse with first point line.push_back( line.at( 0 ) ); e.writePolyline( line, layerName, "SOLID", oc, outlineWidth ); } } else if ( symbolName == "rectangle" ) { QPointF pt1( t.map( QPointF( -halfWidth, -halfHeight ) ) ); QPointF pt2( t.map( QPointF( halfWidth, -halfHeight ) ) ); QPointF pt3( t.map( QPointF( -halfWidth, halfHeight ) ) ); QPointF pt4( t.map( QPointF( halfWidth, halfHeight ) ) ); e.writeSolid( layerName, fc, pt1, pt2, pt3, pt4 ); return true; } else if ( symbolName == "cross" ) { QgsPolyline line1( 2 ); QPointF pt1( t.map( QPointF( -halfWidth, 0 ) ) ); QPointF pt2( t.map( QPointF( halfWidth, 0 ) ) ); line1[0] = pt1; line1[1] = pt2; e.writePolyline( line1, layerName, "CONTINUOUS", oc, outlineWidth ); QgsPolyline line2( 2 ); QPointF pt3( t.map( QPointF( 0, halfHeight ) ) ); QPointF pt4( t.map( QPointF( 0, -halfHeight ) ) ); line2[0] = pt3; line2[1] = pt4; e.writePolyline( line2, layerName, "CONTINUOUS", oc, outlineWidth ); return true; } else if ( symbolName == "triangle" ) { QPointF pt1( t.map( QPointF( -halfWidth, -halfHeight ) ) ); QPointF pt2( t.map( QPointF( halfWidth, -halfHeight ) ) ); QPointF pt3( t.map( QPointF( 0, halfHeight ) ) ); QPointF pt4( t.map( QPointF( 0, halfHeight ) ) ); e.writeSolid( layerName, fc, pt1, pt2, pt3, pt4 ); return true; } return false; //soon... }
QPointF glc::round(const QPointF& point) { QPointF subject(glc::round(static_cast<double>(point.x())), glc::round(static_cast<double>(point.y()))); return subject; }
bool glc::compare(const QPointF& v1, const QPointF& v2) { bool compareResult= (qAbs(v1.x() - v2.x()) <= comparedPrecision); return compareResult && (qAbs(v1.y() - v2.y()) <= comparedPrecision); }
void VBox::setGrip(Grip, const QPointF& pt) { setBoxHeight(Spatium(pt.y())); layout(); }
void Plugin_Entity::rotate(QPointF center, double angle){ entity->rotate( RS_Vector(center.x(), center.y()) , angle); }
FitVector(QPointF &p) { m_X=p.x(); m_Y=p.y(); }
void Plugin_Entity::scale(QPointF center, QPointF factor){ entity->scale( RS_Vector(center.x(), center.y()), RS_Vector(factor.x(), factor.y()) ); }
FitVector(QPointF &a, QPointF &b) { m_X=a.x()-b.x(); m_Y=a.y()-b.y(); }
void FormText::moveResizable( const QPointF & delta ) { moveBy( delta.x(), delta.y() ); }
double TupGraphicalAlgorithm::distanceToPoint(const QPointF &pos) { return ::sqrt(pos.x()* pos.x() + pos.y() * pos.y()); }
void MainView2D::createFixtureItem(quint32 fxID, quint16 headIndex, quint16 linkedIndex, QVector3D pos, bool mmCoords) { if (isEnabled() == false) return; if (m_gridItem == NULL) initialize2DProperties(); qDebug() << "[MainView2D] Creating fixture with ID" << fxID << headIndex << linkedIndex << "pos:" << pos; Fixture *fixture = m_doc->fixture(fxID); if (fixture == NULL) return; quint32 itemID = FixtureUtils::fixtureItemID(fxID, headIndex, linkedIndex); QLCFixtureMode *fxMode = fixture->fixtureMode(); QQuickItem *newFixtureItem = qobject_cast<QQuickItem*>(fixtureComponent->create()); quint32 itemFlags = m_monProps->fixtureFlags(fxID, headIndex, linkedIndex); newFixtureItem->setParentItem(m_gridItem); newFixtureItem->setProperty("itemID", itemID); if (itemFlags & MonitorProperties::HiddenFlag) newFixtureItem->setProperty("visible", false); if (fxMode != NULL && fixture->type() != QLCFixtureDef::Dimmer) { QLCPhysical phy = fxMode->physical(); //qDebug() << "Current mode fixture heads:" << fxMode->heads().count(); newFixtureItem->setProperty("headsNumber", fxMode->heads().count()); if (fixture->channelNumber(QLCChannel::Pan, QLCChannel::MSB) != QLCChannel::invalid()) { int panDeg = phy.focusPanMax(); if (panDeg == 0) panDeg = 360; newFixtureItem->setProperty("panMaxDegrees", panDeg); } if (fixture->channelNumber(QLCChannel::Tilt, QLCChannel::MSB) != QLCChannel::invalid()) { int tiltDeg = phy.focusTiltMax(); if (tiltDeg == 0) tiltDeg = 270; newFixtureItem->setProperty("tiltMaxDegrees", tiltDeg); } } QPointF itemPos; QSizeF size = FixtureUtils::item2DDimension(fixture->type() == QLCFixtureDef::Dimmer ? NULL : fxMode, m_monProps->pointOfView()); if (mmCoords == false && (pos.x() != 0 || pos.y() != 0)) { float gridUnits = m_monProps->gridUnits() == MonitorProperties::Meters ? 1000.0 : 304.8; itemPos.setX((pos.x() * gridUnits) / m_cellPixels); itemPos.setY((pos.y() * gridUnits) / m_cellPixels); } if (m_monProps->containsItem(fxID, headIndex, linkedIndex)) { itemPos = FixtureUtils::item2DPosition(m_monProps, m_monProps->pointOfView(), pos); newFixtureItem->setProperty("rotation", FixtureUtils::item2DRotation(m_monProps->pointOfView(), m_monProps->fixtureRotation(fxID, headIndex, linkedIndex))); } else { itemPos = FixtureUtils::available2DPosition(m_doc, m_monProps->pointOfView(), QRectF(itemPos.x(), itemPos.y(), size.width(), size.height())); // add the new fixture to the Doc monitor properties QVector3D newPos = FixtureUtils::item3DPosition(m_monProps, itemPos, 1000.0); m_monProps->setFixturePosition(fxID, headIndex, linkedIndex, newPos); m_monProps->setFixtureFlags(fxID, headIndex, linkedIndex, 0); Tardis::instance()->enqueueAction(Tardis::FixtureSetPosition, itemID, QVariant(QVector3D(0, 0, 0)), QVariant(newPos)); } newFixtureItem->setProperty("mmXPos", itemPos.x()); newFixtureItem->setProperty("mmYPos", itemPos.y()); newFixtureItem->setProperty("mmWidth", size.width()); newFixtureItem->setProperty("mmHeight", size.height()); newFixtureItem->setProperty("fixtureName", fixture->name()); // and finally add the new item to the items map m_itemsMap[itemID] = newFixtureItem; QByteArray values; updateFixture(fixture, values); }
/*! \internal */ void QGeoMapCircleGeometry::updateScreenPointsInvert(const QGeoMap &map) { if (!screenDirty_) return; if (map.width() == 0 || map.height() == 0) { clear(); return; } QPointF origin = map.coordinateToItemPosition(srcOrigin_, false).toPointF(); QPainterPath ppi = srcPath_; clear(); // a circle requires at least 3 points; if (ppi.elementCount() < 3) return; // translate the path into top-left-centric coordinates QRectF bb = ppi.boundingRect(); ppi.translate(-bb.left(), -bb.top()); firstPointOffset_ = -1 * bb.topLeft(); ppi.closeSubpath(); // calculate actual width of map on screen in pixels QGeoCoordinate mapCenter(0, map.cameraData().center().longitude()); QDoubleVector2D midPoint = map.coordinateToItemPosition(mapCenter, false); QDoubleVector2D midPointPlusOne = QDoubleVector2D(midPoint.x() + 1.0, midPoint.y()); QGeoCoordinate coord1 = map.itemPositionToCoordinate(midPointPlusOne, false); double geoDistance = coord1.longitude() - map.cameraData().center().longitude(); if ( geoDistance < 0 ) geoDistance += 360.0; double mapWidth = 360.0 / geoDistance; qreal leftOffset = origin.x() - (map.width()/2.0 - mapWidth/2.0) - firstPointOffset_.x(); qreal topOffset = origin.y() - (midPoint.y() - mapWidth/2.0) - firstPointOffset_.y(); QPainterPath ppiBorder; ppiBorder.moveTo(QPointF(-leftOffset, -topOffset)); ppiBorder.lineTo(QPointF(mapWidth - leftOffset, -topOffset)); ppiBorder.lineTo(QPointF(mapWidth - leftOffset, mapWidth - topOffset)); ppiBorder.lineTo(QPointF(-leftOffset, mapWidth - topOffset)); screenOutline_ = ppiBorder; std::vector<p2t::Point*> borderPts; borderPts.reserve(4); std::vector<p2t::Point*> curPts; curPts.reserve(ppi.elementCount()); for (int i = 0; i < ppi.elementCount(); ++i) { const QPainterPath::Element e = ppi.elementAt(i); if (e.isMoveTo() || i == ppi.elementCount() - 1 || (qAbs(e.x - curPts.front()->x) < 0.1 && qAbs(e.y - curPts.front()->y) < 0.1)) { if (curPts.size() > 2) { for (int j = 0; j < 4; ++j) { const QPainterPath::Element e2 = ppiBorder.elementAt(j); borderPts.push_back(new p2t::Point(e2.x, e2.y)); } p2t::CDT *cdt = new p2t::CDT(borderPts); cdt->AddHole(curPts); cdt->Triangulate(); std::vector<p2t::Triangle*> tris = cdt->GetTriangles(); screenVertices_.reserve(screenVertices_.size() + int(tris.size())); for (size_t i = 0; i < tris.size(); ++i) { p2t::Triangle *t = tris.at(i); for (int j = 0; j < 3; ++j) { p2t::Point *p = t->GetPoint(j); screenVertices_ << QPointF(p->x, p->y); } } delete cdt; } curPts.clear(); curPts.reserve(ppi.elementCount() - i); curPts.push_back(new p2t::Point(e.x, e.y)); } else if (e.isLineTo()) { curPts.push_back(new p2t::Point(e.x, e.y)); } else { qWarning("Unhandled element type in circle painterpath"); } } if (curPts.size() > 0) { qDeleteAll(curPts.begin(), curPts.end()); curPts.clear(); } if (borderPts.size() > 0) { qDeleteAll(borderPts.begin(), borderPts.end()); borderPts.clear(); } screenBounds_ = ppiBorder.boundingRect(); }
void ColorRing::setColorFromPoint(float x, float y) { float r2 = x*x + y*y; QRect r = contentsRect(); if(grabring && grabtriangle) { grabring = grabtriangle = false; } if(!grabring && !grabtriangle) { if(r2 > RING2) { grabring = true; } else { grabtriangle = true; } } if(grabring) { float angle = (atan2f(y,-x)/M_PI); angle = (angle * 0.5f) + 0.5f; col.setHsvF(angle, col.saturationF(), col.valueF()); } else if(grabtriangle) { QMatrix m; m.scale(1.f/RING, 1.f/RING); m.rotate(col.hueF() * 360); if(triangleMode) { QPointF p = m.map(QPointF(x, y)), p2; QLineF satL(points[0], points[1]); QLineF l1(points[2], p); switch(satL.intersect(l1, &p2)) { case QLineF::BoundedIntersection: case QLineF::UnboundedIntersection: { float sat = QLineF(points[1], p2).length()/satL.length(); if(satL.length() < QLineF(points[0], p2).length()) sat = 0; float val = QLineF(points[2], p).length()/QLineF(points[2], p2).length(); if(QLineF(p, p2).length() > QLineF(points[2], p2).length()) val = .0f; if(sat > 1.f) sat = 1.f; if(sat < .0f) sat = 0.f; if(val > 1.f) val = 1.f; if(val < .0f) val = .0f; col.setHsvF(col.hueF(), sat, val); break; } case QLineF::NoIntersection: break; } } else { // box mode QMatrix m2; m2.rotate(45); m.rotate(45); QPointF p = m.map(QPointF(x, y)), p1 = m2.map(points2[1]), p2 = m2.map(points2[2]), p0 = m2.map(points2[0]); float sat = (p.x() - p1.x()) / (p0.x() - p1.x()); float val = (p.y() - p1.y()) / (p2.y() - p1.y()); if(sat > 1.f) sat = 1.f; if(sat < .0f) sat = 0.f; if(val > 1.f) val = 1.f; if(val < .0f) val = .0f; col.setHsvF(col.hueF(), sat, val); //QMessageBox::information(0, "", QString("x=%1, y=%2, p1.x=%3, p1.y=%4, p2.x=%5, p2.y=%6").arg(QString::number(p.x())).arg(QString::number(p.y())).arg(QString::number(p1.x())).arg(QString::number(p1.y())).arg(QString::number(p2.x())).arg(QString::number(p2.y()))); } } emit hChanged(col.hueF()); emit colorChanged(col); repaint(); }
void QDeclarativePinchArea::updatePinch() { Q_D(QDeclarativePinchArea); if (d->touchPoints.count() == 0) { if (d->inPinch) { d->stealMouse = false; setKeepMouseGrab(false); d->inPinch = false; QPointF pinchCenter = mapFromScene(d->sceneLastCenter); QDeclarativePinchEvent pe(pinchCenter, d->pinchLastScale, d->pinchLastAngle, d->pinchRotation); pe.setStartCenter(d->pinchStartCenter); pe.setPreviousCenter(pinchCenter); pe.setPreviousAngle(d->pinchLastAngle); pe.setPreviousScale(d->pinchLastScale); pe.setStartPoint1(mapFromScene(d->sceneStartPoint1)); pe.setStartPoint2(mapFromScene(d->sceneStartPoint2)); pe.setPoint1(mapFromScene(d->lastPoint1)); pe.setPoint2(mapFromScene(d->lastPoint2)); emit pinchFinished(&pe); d->pinchStartDist = 0; d->pinchActivated = false; if (d->pinch && d->pinch->target()) d->pinch->setActive(false); } return; } QTouchEvent::TouchPoint touchPoint1 = d->touchPoints.at(0); QTouchEvent::TouchPoint touchPoint2 = d->touchPoints.at(d->touchPoints. count() >= 2 ? 1 : 0); if (d->touchPoints.count() == 2 && (touchPoint1.state() & Qt::TouchPointPressed || touchPoint2.state() & Qt::TouchPointPressed)) { d->id1 = touchPoint1.id(); d->sceneStartPoint1 = touchPoint1.scenePos(); d->sceneStartPoint2 = touchPoint2.scenePos(); d->inPinch = false; d->pinchRejected = false; d->pinchActivated = true; } else if (d->pinchActivated && !d->pinchRejected) { const int dragThreshold = QApplication::startDragDistance(); QPointF p1 = touchPoint1.scenePos(); QPointF p2 = touchPoint2.scenePos(); qreal dx = p1.x() - p2.x(); qreal dy = p1.y() - p2.y(); qreal dist = sqrt(dx*dx + dy*dy); QPointF sceneCenter = (p1 + p2)/2; qreal angle = QLineF(p1, p2).angle(); if (d->touchPoints.count() == 1) { // If we only have one point then just move the center if (d->id1 == touchPoint1.id()) sceneCenter = d->sceneLastCenter + touchPoint1.scenePos() - d->lastPoint1; else sceneCenter = d->sceneLastCenter + touchPoint2.scenePos() - d->lastPoint2; angle = d->pinchLastAngle; } d->id1 = touchPoint1.id(); if (angle > 180) angle -= 360; if (!d->inPinch) { if (d->touchPoints.count() >= 2 && (qAbs(p1.x()-d->sceneStartPoint1.x()) > dragThreshold || qAbs(p1.y()-d->sceneStartPoint1.y()) > dragThreshold || qAbs(p2.x()-d->sceneStartPoint2.x()) > dragThreshold || qAbs(p2.y()-d->sceneStartPoint2.y()) > dragThreshold)) { d->sceneStartCenter = sceneCenter; d->sceneLastCenter = sceneCenter; d->pinchStartCenter = mapFromScene(sceneCenter); d->pinchStartDist = dist; d->pinchStartAngle = angle; d->pinchLastScale = 1.0; d->pinchLastAngle = angle; d->pinchRotation = 0.0; d->lastPoint1 = p1; d->lastPoint2 = p2; QDeclarativePinchEvent pe(d->pinchStartCenter, 1.0, angle, 0.0); pe.setStartCenter(d->pinchStartCenter); pe.setPreviousCenter(d->pinchStartCenter); pe.setPreviousAngle(d->pinchLastAngle); pe.setPreviousScale(d->pinchLastScale); pe.setStartPoint1(mapFromScene(d->sceneStartPoint1)); pe.setStartPoint2(mapFromScene(d->sceneStartPoint2)); pe.setPoint1(mapFromScene(d->lastPoint1)); pe.setPoint2(mapFromScene(d->lastPoint2)); pe.setPointCount(d->touchPoints.count()); emit pinchStarted(&pe); if (pe.accepted()) { d->inPinch = true; d->stealMouse = true; QGraphicsScene *s = scene(); if (s && s->mouseGrabberItem() != this) grabMouse(); setKeepMouseGrab(true); if (d->pinch && d->pinch->target()) { d->pinchStartPos = pinch()->target()->pos(); d->pinchStartScale = d->pinch->target()->scale(); d->pinchStartRotation = d->pinch->target()->rotation(); d->pinch->setActive(true); } } else { d->pinchRejected = true; } } } else if (d->pinchStartDist > 0) { qreal scale = dist ? dist / d->pinchStartDist : d->pinchLastScale; qreal da = d->pinchLastAngle - angle; if (da > 180) da -= 360; else if (da < -180) da += 360; d->pinchRotation += da; QPointF pinchCenter = mapFromScene(sceneCenter); QDeclarativePinchEvent pe(pinchCenter, scale, angle, d->pinchRotation); pe.setStartCenter(d->pinchStartCenter); pe.setPreviousCenter(mapFromScene(d->sceneLastCenter)); pe.setPreviousAngle(d->pinchLastAngle); pe.setPreviousScale(d->pinchLastScale); pe.setStartPoint1(mapFromScene(d->sceneStartPoint1)); pe.setStartPoint2(mapFromScene(d->sceneStartPoint2)); pe.setPoint1(touchPoint1.pos()); pe.setPoint2(touchPoint2.pos()); pe.setPointCount(d->touchPoints.count()); d->pinchLastScale = scale; d->sceneLastCenter = sceneCenter; d->pinchLastAngle = angle; d->lastPoint1 = touchPoint1.scenePos(); d->lastPoint2 = touchPoint2.scenePos(); emit pinchUpdated(&pe); if (d->pinch && d->pinch->target()) { qreal s = d->pinchStartScale * scale; s = qMin(qMax(pinch()->minimumScale(),s), pinch()->maximumScale()); pinch()->target()->setScale(s); QPointF pos = sceneCenter - d->sceneStartCenter + d->pinchStartPos; if (pinch()->axis() & QDeclarativePinch::XAxis) { qreal x = pos.x(); if (x < pinch()->xmin()) x = pinch()->xmin(); else if (x > pinch()->xmax()) x = pinch()->xmax(); pinch()->target()->setX(x); } if (pinch()->axis() & QDeclarativePinch::YAxis) { qreal y = pos.y(); if (y < pinch()->ymin()) y = pinch()->ymin(); else if (y > pinch()->ymax()) y = pinch()->ymax(); pinch()->target()->setY(y); } if (d->pinchStartRotation >= pinch()->minimumRotation() && d->pinchStartRotation <= pinch()->maximumRotation()) { qreal r = d->pinchRotation + d->pinchStartRotation; r = qMin(qMax(pinch()->minimumRotation(),r), pinch()->maximumRotation()); pinch()->target()->setRotation(r); } } } } }
QPointF QtGradientWidgetPrivate::toViewport(const QPointF &point) const { QSize size = q_ptr->size(); return QPointF(point.x() * size.width(), point.y() * size.height()); }
void EraserTool::drawStroke() { StrokeTool::drawStroke(); QList<QPointF> p = m_pStrokeManager->interpolateStroke(currentWidth); Layer *layer = m_pEditor->getCurrentLayer(); if (layer->type == Layer::BITMAP) { for (int i = 0; i < p.size(); i++) { p[i] = m_pScribbleArea->pixelToPoint(p[i]); } qreal opacity = 1.0; qreal brushWidth = currentWidth + 0.5 * properties.feather; qreal offset = qMax(0.0, currentWidth - 0.5 * properties.feather) / brushWidth; opacity = currentPressure; brushWidth = brushWidth * currentPressure; // if (tabletInUse) { opacity = tabletPressure; } // if (usePressure) { brushWidth = brushWidth * tabletPressure; } qreal brushStep = 0.5 * currentWidth + 0.5 * properties.feather; brushStep = brushStep * currentPressure; // if (usePressure) { brushStep = brushStep * tabletPressure; } brushStep = qMax(1.0, brushStep); currentWidth = properties.width; BlitRect rect; QRadialGradient radialGrad(QPointF(0,0), 0.5 * brushWidth); m_pScribbleArea->setGaussianGradient(radialGrad, QColor(255,255,255), opacity, offset); QPointF a = lastBrushPoint; QPointF b = getCurrentPoint(); // foreach (QSegment segment, calculateStroke(brushWidth)) // { // QPointF a = lastBrushPoint; // QPointF b = m_pScribbleArea->pixelToPoint(segment.second); qreal distance = 4 * QLineF(b, a).length(); int steps = qRound(distance) / brushStep; for (int i = 0; i < steps; i++) { QPointF point = lastBrushPoint + (i + 1) * (brushStep) * (b - lastBrushPoint) / distance; rect.extend(point.toPoint()); m_pScribbleArea->drawBrush(point, brushWidth, offset, QColor(255,255,255), opacity); if (i == (steps - 1)) { lastBrushPoint = point; } } // } int rad = qRound(brushWidth) / 2 + 2; m_pScribbleArea->refreshBitmap(rect, rad); } else if (layer->type == Layer::VECTOR) { QPen pen(Qt::white, currentWidth, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin); int rad = qRound((currentWidth / 2 + 2) * (qAbs(m_pScribbleArea->getTempViewScaleX()) + qAbs(m_pScribbleArea->getTempViewScaleY()))); if (p.size() == 4) { QSizeF size(2,2); QPainterPath path(p[0]); path.cubicTo(p[1], p[2], p[3]); m_pScribbleArea->drawPath(path, pen, Qt::NoBrush, QPainter::CompositionMode_Source); m_pScribbleArea->refreshVector(path.boundingRect().toRect(), rad); } } }
void QtGradientWidget::mouseMoveEvent(QMouseEvent *e) { if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::NoHandle) return; QPointF newPos = QPointF((double)e->pos().x() - d_ptr->m_dragOffset.x(), (double)e->pos().y() - d_ptr->m_dragOffset.y()); QPointF newPoint = d_ptr->fromViewport(newPos); if (newPoint.x() < 0) newPoint.setX(0); else if (newPoint.x() > 1) newPoint.setX(1); if (newPoint.y() < 0) newPoint.setY(0); else if (newPoint.y() > 1) newPoint.setY(1); if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::StartLinearHandle) { d_ptr->m_startLinear = newPoint; emit startLinearChanged(newPoint); } else if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::EndLinearHandle) { d_ptr->m_endLinear = newPoint; emit endLinearChanged(newPoint); } else if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::CentralRadialHandle) { d_ptr->m_centralRadial = newPoint; emit centralRadialChanged(newPoint); } else if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::FocalRadialHandle) { d_ptr->m_focalRadial = newPoint; emit focalRadialChanged(newPoint); } else if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::RadiusRadialHandle) { QPointF centralPoint = d_ptr->toViewport(d_ptr->m_centralRadial); QPointF pF(e->pos().x(), e->pos().y()); double x = pF.x() - centralPoint.x(); double y = pF.y() - centralPoint.y(); if ((d_ptr->m_handleSize * d_ptr->m_handleSize / 4) > (x * x + y * y)) { if (d_ptr->m_radiusRadial != d_ptr->m_dragRadius) { d_ptr->m_radiusRadial = d_ptr->m_dragRadius; emit radiusRadialChanged(d_ptr->m_radiusRadial); } } else { x = pF.x() / size().width() - d_ptr->m_centralRadial.x(); y = pF.y() / size().height() - d_ptr->m_centralRadial.y(); double moveRadius = sqrt(x * x + y * y); //double newRadius = moveRadius + d_ptr->m_radiusOffset; double newRadius = moveRadius * d_ptr->m_radiusFactor; if (newRadius > 2) newRadius = 2; d_ptr->m_radiusRadial = newRadius; emit radiusRadialChanged(d_ptr->m_radiusRadial); } } else if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::CentralConicalHandle) { d_ptr->m_centralConical = newPoint; emit centralConicalChanged(newPoint); } else if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::AngleConicalHandle) { QPointF centralPoint = d_ptr->toViewport(d_ptr->m_centralConical); QPointF pF(e->pos().x(), e->pos().y()); double x = pF.x() - centralPoint.x(); double y = pF.y() - centralPoint.y(); if ((d_ptr->m_handleSize * d_ptr->m_handleSize / 4) > (x * x + y * y)) { if (d_ptr->m_angleConical != d_ptr->m_dragAngle) { d_ptr->m_angleConical = d_ptr->m_dragAngle; emit angleConicalChanged(d_ptr->m_angleConical); } } else { QPointF central = d_ptr->toViewport(d_ptr->m_centralConical); QPointF current = pF; x = current.x() - central.x(); y = current.y() - central.y(); x /= size().width() / 2; y /= size().height() / 2; double r = sqrt(x * x + y * y); double arcSin = asin(y / r); double arcCos = acos(x / r); double angle = arcCos * 180 / M_PI; if (arcSin > 0) { angle = -angle; } angle += d_ptr->m_angleOffset; d_ptr->setAngleConical(angle); } } update(); }
void Plugin_Entity::move(QPointF offset){ entity->move( RS_Vector(offset.x(), offset.y()) ); }
void MavPlot::fwd_markerData(const Data *const d) { if (!d || !_data_marker_visible) return; const double markerx = _data_marker.xValue(); double markerx_next = markerx; #if 0 /******************* * SCAN IN Data *******************/ #else /******************* * SCAN IN Plot *******************/ // FIXME: heavy code clone from rev_markerData() QPointF xy; QString value; bool found = false; // find out what it is, then scan for data const QWT_ABSTRACT_SERIESITEM*s = _get_series(d); if (s) { // it's a series const QwtPlotCurve *curve = dynamic_cast<const QwtPlotCurve *>(s); if (curve) { for (unsigned int k=0; k<curve->dataSize(); k++) { xy = curve->sample(k); double x = xy.x(); if (x > markerx) { found = true; markerx_next = x; value = QString::number(xy.y()); break; } } } } // annotation std::vector<QwtPlotItem*>*v = _get_annotations(d); if (v && !found) { // it's an annotation...we have to go through all of them for (std::vector<QwtPlotItem*>::const_iterator it = v->begin(); it != v->end(); ++it) { // only support marker annotations const QwtPlotMarker * m = dynamic_cast<const QwtPlotMarker*>(*it); if (m) { // we only handle vertical markers if (QwtPlotMarker::VLine == m->lineStyle()) { xy = m->value(); double x = xy.x(); if (x > markerx) { found = true; markerx_next = x; value = m->label().text(); break; } } } } } #endif // set marker to found location if (found) { _data_marker_label = value; _data_marker.setValue(markerx_next, 0); replot(); } updateStatusbar(); }
/*! Draw dots \param painter Painter \param xMap x map \param yMap y map \param canvasRect Contents rectangle of the canvas \param from index of the first point to be painted \param to index of the last point to be painted \sa draw(), drawCurve(), drawSticks(), drawLines(), drawSteps() */ void QwtPlotCurve::drawDots( QPainter *painter, const QwtScaleMap &xMap, const QwtScaleMap &yMap, const QRectF &canvasRect, int from, int to ) const { const QColor color = painter->pen().color(); if ( painter->pen().style() == Qt::NoPen || color.alpha() == 0 ) { return; } const bool doFill = ( d_data->brush.style() != Qt::NoBrush ) && ( d_data->brush.color().alpha() > 0 ); const bool doAlign = QwtPainter::roundingAlignment( painter ); QwtPointMapper mapper; mapper.setBoundingRect( canvasRect ); mapper.setFlag( QwtPointMapper::RoundPoints, doAlign ); if ( d_data->paintAttributes & FilterPoints ) { if ( ( color.alpha() == 255 ) && !( painter->renderHints() & QPainter::Antialiasing ) ) { mapper.setFlag( QwtPointMapper::WeedOutPoints, true ); } } if ( doFill ) { mapper.setFlag( QwtPointMapper::WeedOutPoints, false ); QPolygonF points = mapper.toPointsF( xMap, yMap, data(), from, to ); QwtPainter::drawPoints( painter, points ); fillCurve( painter, xMap, yMap, canvasRect, points ); } else if ( d_data->paintAttributes & ImageBuffer ) { const QImage image = mapper.toImage( xMap, yMap, data(), from, to, d_data->pen, painter->testRenderHint( QPainter::Antialiasing ), renderThreadCount() ); painter->drawImage( canvasRect.toAlignedRect(), image ); } else if ( d_data->paintAttributes & MinimizeMemory ) { const QwtSeriesData<QPointF> *series = data(); for ( int i = from; i <= to; i++ ) { const QPointF sample = series->sample( i ); double xi = xMap.transform( sample.x() ); double yi = yMap.transform( sample.y() ); if ( doAlign ) { xi = qRound( xi ); yi = qRound( yi ); } QwtPainter::drawPoint( painter, QPointF( xi, yi ) ); } } else { if ( doAlign ) { const QPolygon points = mapper.toPoints( xMap, yMap, data(), from, to ); QwtPainter::drawPoints( painter, points ); } else { const QPolygonF points = mapper.toPointsF( xMap, yMap, data(), from, to ); QwtPainter::drawPoints( painter, points ); } } }