/** * Paint arrow */ void drawLineHead (QPainter * painter, QPointF end, double angle, double size, bool figure) { QPointF lineP1 = end + QPointF( sin( angle + Pi / 3) * size, cos( angle + Pi / 3) * size); QPointF lineP2 = end + QPointF( sin( angle + Pi - Pi / 3) * size, cos( angle + Pi - Pi / 3) * size); QPointF centre = (lineP1 + lineP2 + end)/3; if (figure) { QPainterPath arrow; arrow.moveTo (end); arrow.quadTo (centre, lineP1); arrow.lineTo (lineP2); arrow.quadTo (centre, end); painter->drawPath (arrow); } else { QPolygonF lineHead; lineHead.clear(); lineHead << end << lineP1 << lineP2; painter->drawPolygon (lineHead); } }
void TaskItemDelegate::paintPriorityHeader(QPainter* painter, const QRectF& rect, const QModelIndex &index) const { painter->save(); //Draw colored gradient as priority background QLinearGradient gradient(rect.topLeft(), rect.bottomRight()); gradient.setColorAt(0, itemPriorityColor(index)); gradient.setColorAt(1, Qt::transparent); int h = QApplication::fontMetrics().height(); QPainterPath path; path.moveTo(rect.bottomLeft()); path.quadTo(rect.bottomLeft()+QPointF(0, -h), rect.bottomLeft()+QPointF(2, -h)); path.lineTo(rect.bottomRight()-QPointF(2, h)); path.quadTo(rect.bottomRight()+QPointF(0, -h), rect.bottomRight()); painter->setBrush(Qt::NoBrush); QPen thickPen(itemPriorityColor(index)); thickPen.setWidth(2); painter->setPen(thickPen); painter->drawPath(path); // Draw priority text QString priority = index.data(Qt::DisplayRole).toString(); painter->setPen(Plasma::Theme::defaultTheme()->color(Plasma::Theme::TextColor)); painter->setBrush(Qt::NoBrush); painter->drawText(rect.bottomLeft()+QPoint(MARGIN, -2*MARGIN) ,priority); painter->restore(); }
QPainterPath TriggerPoint::shape() const { QPainterPath path; float line = BasicBox::LINE_WIDTH / 2; QPointF adjustX(-line, 0); QPointF adjustY(0, -line); QRectF rect = boundingRect(); switch (_abstract->boxExtremity()) { case BOX_START: path.moveTo(rect.topLeft() + adjustX); path.lineTo(rect.bottomLeft() + adjustX + adjustY); path.lineTo(rect.bottomRight() + adjustY); path.lineTo(rect.bottomRight() + adjustY - QPointF(0, rect.height() / 5.)); path.quadTo(rect.topRight(), rect.topLeft() + adjustX); break; case BOX_END: path.moveTo(rect.topRight()); path.lineTo(rect.bottomRight() + adjustY); path.lineTo(rect.bottomLeft() + adjustY); path.lineTo(rect.bottomLeft() + adjustY - QPointF(0, rect.height() / 5.)); path.quadTo(rect.topLeft(), rect.topRight()); break; default: break; } return path; }
void EditorArea::paintEdges(QPainter &painter) { bool firstTime = true; QVector<int> edgesIds = workspace->getEdgesIds(); for (int i=0; i < edgesIds.size(); i++) { QPoint nodesOfEdge = workspace->getNodesOfEdge(edgesIds[i]); QPointF screenXYFirst = graph2screen(workspace->getNodePosition(nodesOfEdge.x())); QPointF screenXYSecond = graph2screen(workspace->getNodePosition(nodesOfEdge.y())); QPointF screenMidPoint = graph2screen(workspace->getThirdPointPos(edgesIds[i])); QPainterPath path; path.moveTo(screenXYFirst); path.quadTo(screenMidPoint, screenXYSecond); path.quadTo(screenMidPoint, screenXYFirst); painter.drawPath(path); QVector<QPointF> pointsOnBezier; QVector<float> sOnEdge; for (int k = 0; k < edgeDiscretization + 1; k++) { float t = float(k) / edgeDiscretization; QPointF coord = (1 - t) * (1 - t) * screenXYFirst + 2 * (1 - t) * t * screenMidPoint + t * t * screenXYSecond; pointsOnBezier << coord; } for (int k = 0; k < pointsOnBezier.size(); k++) { if (k == 0) { sOnEdge << 0.0; } else { float sJesima = workspace->distance(pointsOnBezier[k], pointsOnBezier[k - 1]); sOnEdge << sJesima; } } for (int k = 1; k < pointsOnBezier.size(); k++) { sOnEdge[k] = sOnEdge[k] + sOnEdge[k - 1]; } float length = sOnEdge.last(); for (int k = 0; k < sOnEdge.size(); k++) { sOnEdge[k] = sOnEdge[k] / length; } sOnBezier.insert(edgesIds[i], sOnEdge); if (path.intersects(QRectF(mouseCurrentPos.x() - 7, mouseCurrentPos.y() - 7, 14, 14))) { if (firstTime) { firstTime = false; hitElements.clear(); } QPoint temp(2, edgesIds[i]); hitElements.append(temp); } } }
void CurrentTrack::drawStatsBackground( QPainter *const p, const QRect &rect ) { // draw the complete outline. lots of little steps :) at each corner, leave // a 6x6 box. draw a quad bezier curve from the two ends of the lines, // through the original corner const qreal leftEdge = m_ratingWidget->boundingRect().right() + standardPadding(); const qreal rightEdge = rect.right() - standardPadding() / 2; const qreal ratingWidgetX = m_ratingWidget->pos().x(); const qreal ratingWidgetY = m_ratingWidget->pos().y(); const qreal ratingWidgetH = m_ratingWidget->boundingRect().height(); QColor topColor = The::paletteHandler()->palette().color( QPalette::Base ); QColor bottomColor = topColor; topColor.setAlpha( 200 ); bottomColor.setAlpha( 100 ); QPainterPath statsPath; statsPath.moveTo( leftEdge + 6, ratingWidgetY - ratingWidgetH + 8 ); // top left position of the rect, right below the album statsPath.lineTo( rightEdge - 6, ratingWidgetY - ratingWidgetH + 8 ); // go right to margin statsPath.quadTo( rightEdge, ratingWidgetY - ratingWidgetH + 8, rightEdge, ratingWidgetY - ratingWidgetH + 8 + 6 ); statsPath.lineTo( rightEdge, ratingWidgetY + ratingWidgetH - 6 ); // go down to bottom right corner statsPath.quadTo( rightEdge, ratingWidgetY + ratingWidgetH, rightEdge - 6, ratingWidgetY + ratingWidgetH ); statsPath.lineTo( ratingWidgetX + 6, ratingWidgetY + ratingWidgetH ); // way bottom left corner statsPath.quadTo( ratingWidgetX, ratingWidgetY + ratingWidgetH, ratingWidgetX, ratingWidgetY + ratingWidgetH - 6 ); statsPath.lineTo( ratingWidgetX, ratingWidgetY + 6 ); // top left of rating widget statsPath.quadTo( ratingWidgetX, ratingWidgetY, ratingWidgetX + 6, ratingWidgetY ); statsPath.lineTo( leftEdge - 6, ratingWidgetY ); // joining of two rects statsPath.quadTo( leftEdge, ratingWidgetY, leftEdge, ratingWidgetY - 6 ); statsPath.lineTo( leftEdge, ratingWidgetY - ratingWidgetH + 8 + 6 ); // back to start statsPath.quadTo( leftEdge, ratingWidgetY - ratingWidgetH + 8, leftEdge + 6, ratingWidgetY - ratingWidgetH + 8 ); // draw just the overlay which is the "header" row, to emphasize that we have 2 rows here QPainterPath headerPath; headerPath.moveTo( leftEdge + 6, ratingWidgetY - ratingWidgetH + 8 ); // top left position of the rect, right below the album headerPath.lineTo( rightEdge - 6, ratingWidgetY - ratingWidgetH + 8 ); // go right to margin headerPath.quadTo( rightEdge, ratingWidgetY - ratingWidgetH + 8, rightEdge, ratingWidgetY - ratingWidgetH + 8 + 6 ); headerPath.lineTo( rightEdge, ratingWidgetY ); // middle of the right side headerPath.lineTo( leftEdge - 6, ratingWidgetY ); // join spot, before quad curve headerPath.quadTo( leftEdge, ratingWidgetY, leftEdge, ratingWidgetY - 6 ); headerPath.lineTo( leftEdge, ratingWidgetY - ratingWidgetH + 8 + 6 ); // curve back through start headerPath.quadTo( leftEdge, ratingWidgetY - ratingWidgetH + 8, leftEdge + 6, ratingWidgetY - ratingWidgetH + 8 ); p->save(); p->setRenderHint( QPainter::Antialiasing ); p->fillPath( statsPath, bottomColor ); p->fillPath( headerPath, topColor ); p->restore(); }
/** * Returns a Bézier path from given points. * @param points points which define the Bézier curve * @return cubic Bézier spline */ QPainterPath AssociationLine::createBezierCurve(QVector<QPointF> points) { QPainterPath path; if (points.size() > 3) { // cubic Bezier curve(s) path.moveTo(points.at(0)); int i = 1; while (i + 2 < points.size()) { path.cubicTo(points.at(i), points.at(i+1), points.at(i+2)); i += 3; } while (i < points.size()) { // draw a line if points are not modulo 3 path.lineTo(points.at(i)); ++i; } } else { if (points.size() == 3) { // quadratic Bezier curve path.moveTo(points.at(0)); path.quadTo(points.at(1), points.at(2)); } else { // should not be reached QPolygonF polygon(points); path.addPolygon(polygon); } } return path; }
void Kompton::Particle::rebuildRepresentation() { //prepare a new path QPainterPath path; path.moveTo(m_line.p1()); //draw on the path according to the style if (m_style == Kompton::PlainStyle) { path.lineTo(m_line.p2()); } else if (m_style == Kompton::WigglyStyle) { const QPointF start = m_line.p1(); const QPointF diff = m_line.p2() - start; //some constants of the representation static const qreal amplitude = 10.0; //maximum wave elongation static const qreal wavelength = 20.0; //parameters for this wave const qreal waveCount = floor(sqrt(diff.x() * diff.x() + diff.y() * diff.y()) / wavelength); const QPointF waveDiff = diff / waveCount; const qreal slope = atan2(diff.y(), diff.x()); const QPointF waveElongationVector(amplitude * -sin(slope), amplitude * cos(slope)); //draw waves for (qreal i = 0.0; i < waveCount; ++i) { path.quadTo(start + waveDiff * (i + 0.25) + waveElongationVector, start + waveDiff * (i + 0.5)); path.quadTo(start + waveDiff * (i + 0.75) - waveElongationVector, start + waveDiff * (i + 1.0)); } } //make new path active setPath(path); }
void Quad_Curve::add_to(bool move, QPainterPath &ppth) const { if ( move ) ppth.moveTo(begin); ppth.quadTo(control,end); }
void EditorArea::paintHighlightingEdge(QPainter& painter) { QMap<QString, int> supportEdges(workspace->getSupportEdges()); QPoint nodesOfEdge = workspace->getNodesOfEdge(supportEdges.value("highlightingEdge")); QPointF screenXYFirst = graph2screen(workspace->getNodePosition(nodesOfEdge.x())); QPointF screenXYSecond = graph2screen(workspace->getNodePosition(nodesOfEdge.y())); QPointF screenMidPoint = graph2screen(workspace->getThirdPointPos(supportEdges.value("highlightingEdge"))); QPainterPath path; path.moveTo(screenXYFirst); path.quadTo(screenMidPoint, screenXYSecond); path.quadTo(screenMidPoint, screenXYFirst); path.closeSubpath(); painter.drawPath(path); }
void drawRoundedButton( QPainter* painter, const QRect& btnRect, const QColor& color, const QColor &gradient1bottom, const QColor& gradient2top, const QColor& gradient2bottom ) { QPainterPath btnPath; const int radius = 3; // draw top half gradient const int btnCenter = btnRect.bottom() - ( btnRect.height() / 2 ); btnPath.moveTo( btnRect.left(), btnCenter ); btnPath.lineTo( btnRect.left(), btnRect.top() + radius ); btnPath.quadTo( QPoint( btnRect.topLeft() ), QPoint( btnRect.left() + radius, btnRect.top() ) ); btnPath.lineTo( btnRect.right() - radius, btnRect.top() ); btnPath.quadTo( QPoint( btnRect.topRight() ), QPoint( btnRect.right(), btnRect.top() + radius ) ); btnPath.lineTo( btnRect.right(),btnCenter ); btnPath.lineTo( btnRect.left(), btnCenter ); QLinearGradient g; if ( gradient1bottom.isValid() ) { g.setColorAt( 0, color ); g.setColorAt( 0.5, gradient1bottom ); painter->fillPath( btnPath, g ); } else painter->fillPath( btnPath, color ); //painter->setPen( bg.darker() ); //painter->drawPath( btnPath ); btnPath = QPainterPath(); btnPath.moveTo( btnRect.left(), btnCenter ); btnPath.lineTo( btnRect.left(), btnRect.bottom() - radius ); btnPath.quadTo( QPoint( btnRect.bottomLeft() ), QPoint( btnRect.left() + radius, btnRect.bottom() ) ); btnPath.lineTo( btnRect.right() - radius, btnRect.bottom() ); btnPath.quadTo( QPoint( btnRect.bottomRight() ), QPoint( btnRect.right(), btnRect.bottom() - radius ) ); btnPath.lineTo( btnRect.right(), btnCenter ); btnPath.lineTo( btnRect.left(), btnCenter ); if ( gradient2top.isValid() && gradient2bottom.isValid() ) { g.setColorAt( 0, gradient2top ); g.setColorAt( 0.5, gradient2bottom ); painter->fillPath( btnPath, g ); } else painter->fillPath( btnPath, color ); }
void EditorArea::paintSupportEdges4selecting(QPainter& painter) { QVector<int> supportEdges4selecting(workspace->getSupportEdges4selecting()); for (int i = 0; i < supportEdges4selecting.size(); i++) { QPoint nodesOfEdge = workspace->getNodesOfEdge(supportEdges4selecting[i]); QPointF screenXYFirst = graph2screen(workspace->getNodePosition(nodesOfEdge.x())); QPointF screenXYSecond = graph2screen(workspace->getNodePosition(nodesOfEdge.y())); QPointF screenMidPoint = graph2screen(workspace->getThirdPointPos(supportEdges4selecting[i])); QPainterPath path; path.moveTo(screenXYFirst); path.quadTo(screenMidPoint, screenXYSecond); path.quadTo(screenMidPoint, screenXYFirst); painter.drawPath(path); } }
QPainterPath dialogPath( const QRect & rct , int padding ) const { QPainterPath path; path.setFillRule( Qt::WindingFill ); path.moveTo( rct.width()/2 , padding ); path.lineTo( rct.width()-padding-ROUNDED_PIXEL , padding ); path.quadTo( rct.width()-padding , padding , rct.width()-padding , padding+ROUNDED_PIXEL ); path.lineTo( rct.width()-padding , rct.height()-padding-ROUNDED_PIXEL ); path.quadTo( rct.width()-padding , rct.height()-padding , rct.width()-padding-ROUNDED_PIXEL , rct.height()-padding ); path.lineTo( padding+ROUNDED_PIXEL , rct.height()-padding ); path.quadTo( padding , rct.height()-padding , padding , rct.height()-padding-ROUNDED_PIXEL ); path.lineTo( padding , padding+ROUNDED_PIXEL ); path.quadTo( padding , padding , padding+ROUNDED_PIXEL , padding ); path.lineTo( rct.width()/2 , padding ); return path; }
void StylePainterMobile::drawChecker(QPainter* painter, const QRect& rect, const QColor& color) const { painter->setRenderHint(QPainter::Antialiasing, true); QPen pen(Qt::darkGray); pen.setCosmetic(true); painter->setPen(pen); painter->scale(rect.width(), rect.height()); QPainterPath path; path.moveTo(0.18, 0.47); path.lineTo(0.25, 0.4); path.lineTo(0.4, 0.55); path.quadTo(0.64, 0.29, 0.78, 0.2); path.lineTo(0.8, 0.25); path.quadTo(0.53, 0.55, 0.45, 0.75); path.closeSubpath(); painter->setBrush(color); painter->drawPath(path); }
static bool parseGlyphPathData(const char *svgPath, const char *svgPathEnd, QPainterPath &path, qreal fontPixelSize, const QPointF &offset, bool hinted) { Q_UNUSED(hinted) QPointF p1, p2, firstSubPathPoint; qreal *elementValues[] = {&p1.rx(), &p1.ry(), &p2.rx(), &p2.ry()}; const int unitsPerEm = 2048; // See: http://en.wikipedia.org/wiki/Em_%28typography%29 const qreal resizeFactor = fontPixelSize / unitsPerEm; while (svgPath < svgPathEnd) { skipSpacesAndComma(svgPath, svgPathEnd); const char pathElem = *svgPath++; skipSpacesAndComma(svgPath, svgPathEnd); if (pathElem != 'Z') { char *endStr = 0; int elementValuesCount = 0; for (int i = 0; i < 4; ++i) { // 4 = size of elementValues[] qreal coordinateValue = strtod(svgPath, &endStr); if (svgPath == endStr) break; if (i % 2) // Flip vertically coordinateValue = -coordinateValue; *elementValues[i] = coordinateValue * resizeFactor; elementValuesCount++; svgPath = endStr; skipSpacesAndComma(svgPath, svgPathEnd); } p1 += offset; if (elementValuesCount == 2) p2 = firstSubPathPoint; else p2 += offset; } switch (pathElem) { case 'M': firstSubPathPoint = p1; path.moveTo(p1); break; case 'Z': path.closeSubpath(); break; case 'L': path.lineTo(p1); break; case 'Q': path.quadTo(p1, p2); break; default: return false; } } return true; }
void CQGroupBox:: drawArcShape(QPainter *painter, double xc, double yc, double r, double startAngle, int sides) const { auto Deg2Rad = [](double d) -> double { return M_PI*d/180.0; }; //auto Rad2Deg = [](double r) -> double { return 180.0*r/M_PI; }; double x1 = xc - r; double y1 = yc - r; double x2 = xc + r; double y2 = yc + r; double xm = (x1 + x2)/2; double ym = (y1 + y2)/2; double da = 360.0/sides; double dc = 360.0/40; QPainterPath path; for (int i = 0; i < sides; ++i) { double angle = startAngle + i*da; double a1 = Deg2Rad(angle - dc); double a2 = Deg2Rad(angle + dc); double c1 = cos(a1), s1 = sin(a1); double c2 = cos(a2), s2 = sin(a2); QPointF p1(xm + r*c1, ym + r*s1); QPointF p2(xm + r*c2, ym + r*s2); if (i == 0) path.moveTo(p1); else path.lineTo(p1); //--- QPointF p12 = (p1 + p2)/2; double ar = 2*hypot(p1.x() - p12.x(), p1.y() - p12.y())/sides; double a = Deg2Rad(angle); double c = cos(a), s = sin(a); QPointF pq(xm + (r + ar)*c, ym + (r + ar)*s); path.quadTo(pq, p2); } path.closeSubpath(); painter->drawPath(path); }
QPainterPath strokeToPainterPath(TStroke *stroke) { QPainterPath path; int i, chunkSize = stroke->getChunkCount(); for (i = 0; i < chunkSize; i++) { const TThickQuadratic *q = stroke->getChunk(i); if (i == 0) path.moveTo(toQPointF(q->getThickP0())); path.quadTo(toQPointF(q->getThickP1()), toQPointF(q->getThickP2())); } return path; }
void ProgressWidgetGraphicsProxy::paintWindowFrame (QPainter * painter, const QStyleOptionGraphicsItem *, QWidget *) { QRectF widgetGeometry = windowFrameRect(); QPainterPath path; path.addRect(widgetGeometry); path.moveTo(widgetGeometry.topLeft() + QPointF(0, -offset)); path.quadTo(widgetGeometry.topLeft() + QPointF(-offset, -offset), widgetGeometry.topLeft() + QPointF(-offset, 0)); path.lineTo(widgetGeometry.bottomLeft() + QPointF(-offset, 0)); path.quadTo(widgetGeometry.bottomLeft() + QPointF(-offset, offset), widgetGeometry.bottomLeft() + QPointF(0, offset)); path.lineTo(widgetGeometry.bottomRight() + QPointF(0, offset)); path.quadTo(widgetGeometry.bottomRight() + QPointF(offset, offset), widgetGeometry.bottomRight() + QPointF(offset, 0)); path.lineTo(widgetGeometry.topRight() + QPointF(offset, 0)); path.quadTo(widgetGeometry.topRight() + QPointF(offset, -offset), widgetGeometry.topRight() + QPointF(0, -offset)); path.lineTo(widgetGeometry.topLeft() + QPointF(0, -offset)); painter->setPen(Qt::black); painter->setBrush(frameColor); painter->setRenderHint(QPainter::Antialiasing, true); painter->drawPath(path); painter->setRenderHint(QPainter::Antialiasing, false); }
void Context::AppletToolbarBase::paint( QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget ) { Q_UNUSED( option ) Q_UNUSED( widget ) painter->save(); painter->setRenderHint( QPainter::Antialiasing ); QColor topColor = palette().color( QPalette::Active, QPalette::Button ); QColor bottomColor = topColor; topColor.setAlpha( 200 ); bottomColor.setAlpha( 100 ); qreal radius = 3; qreal boundWidth = boundingRect().width(); qreal boundHeight = boundingRect().height(); // draw top half of rounded applet QPainterPath path; path.moveTo( 0, boundHeight / 2 ); path.lineTo( 0, radius ); path.quadTo( 0, 0, radius, 0 ); path.lineTo( boundWidth - radius, 0 ); path.quadTo( boundWidth, 0, boundWidth, radius ); path.lineTo( boundWidth, boundHeight / 2 ); path.lineTo( 0, boundHeight / 2 ); painter->fillPath( path, topColor ); QPainterPath bottom; bottom.moveTo( 0, boundHeight / 2 ); bottom.lineTo( 0, boundHeight - radius ); bottom.quadTo( 0, boundHeight, radius, boundHeight ); bottom.lineTo( boundWidth - radius, boundHeight ); bottom.quadTo( boundWidth, boundHeight, boundWidth, boundHeight - radius ); bottom.lineTo( boundWidth, boundHeight / 2 ); bottom.lineTo( 0, boundHeight / 2 ); painter->fillPath( bottom, bottomColor ); painter->restore(); }
void ArrowItem::updatePath(const QPointF &endPoint) { const double arrowWidth = 15.0; const double headWidth = 40.0; const double headLength = headWidth / pow(2, 0.5); // aka headWidth / sqrt (2) but this produces a compile error with MSVC++ const double phi = 15; if (!startItem) return; QPointF startPoint = startItem->mapToScene(QPointF(startItem->boundingRect().width() / 2, startItem->boundingRect().height() / 2)); QLineF line(startPoint, endPoint); qreal lineLength = line.length(); prepareGeometryChange(); if (lineLength < 30) path = QPainterPath(); else { QPointF c(lineLength / 2, tan(phi * M_PI / 180) * lineLength); QPainterPath centerLine; centerLine.moveTo(0, 0); centerLine.quadTo(c, QPointF(lineLength, 0)); double percentage = 1 - headLength / lineLength; QPointF arrowBodyEndPoint = centerLine.pointAtPercent(percentage); QLineF testLine(arrowBodyEndPoint, centerLine.pointAtPercent(percentage + 0.001)); qreal alpha = testLine.angle() - 90; QPointF endPoint1 = arrowBodyEndPoint + arrowWidth / 2 * QPointF(cos(alpha * M_PI / 180), -sin(alpha * M_PI / 180)); QPointF endPoint2 = arrowBodyEndPoint + arrowWidth / 2 * QPointF(-cos(alpha * M_PI / 180), sin(alpha * M_PI / 180)); QPointF point1 = endPoint1 + (headWidth - arrowWidth) / 2 * QPointF(cos(alpha * M_PI / 180), -sin(alpha * M_PI / 180)); QPointF point2 = endPoint2 + (headWidth - arrowWidth) / 2 * QPointF(-cos(alpha * M_PI / 180), sin(alpha * M_PI / 180)); path = QPainterPath(-arrowWidth / 2 * QPointF(cos((phi - 90) * M_PI / 180), sin((phi - 90) * M_PI / 180))); path.quadTo(c, endPoint1); path.lineTo(point1); path.lineTo(QPointF(lineLength, 0)); path.lineTo(point2); path.lineTo(endPoint2); path.quadTo(c, arrowWidth / 2 * QPointF(cos((phi - 90) * M_PI / 180), sin((phi - 90) * M_PI / 180))); path.lineTo(-arrowWidth / 2 * QPointF(cos((phi - 90) * M_PI / 180), sin((phi - 90) * M_PI / 180))); } setPos(startPoint); setTransform(QTransform().rotate(-line.angle())); }
bool BE::Contacts::setPhoto(const QString &path) { QRect r(0,0,160,160); QImage img = QImage( path ); if (img.isNull()) return false; const float f = qMin( float(img.width())/float(r.width()), float(img.height())/float(r.height()) ); r.setSize( r.size()*f ); r.moveTopRight( img.rect().topRight() ); img = img.copy(r).scaled( QSize(160,160), Qt::KeepAspectRatioByExpanding, Qt::SmoothTransformation); img = img.convertToFormat(QImage::Format_ARGB32); // if ( !MPC::setting("rgbCover").toBool() ) { int r,g,b; palette().color(foregroundRole()).getRgb(&r,&g,&b); int n = img.width() * img.height(); const uchar *bits = img.bits(); QRgb *pixel = (QRgb*)(const_cast<uchar*>(bits)); // this creates a (slightly) translucent monochromactic version of the // image using the foreground color // the gray value is turned into the opacity #define ALPHA qAlpha(pixel[i]) #define GRAY qGray(pixel[i]) #define OPACITY 224 if ( qMax( qMax(r,g), b ) > 128 ) // value > 50%, bright foreground for (int i = 0; i < n; ++i) pixel[i] = qRgba( r,g,b, ( ALPHA * ( (OPACITY*GRAY) / 255 ) ) / 255 ); else // inverse for (int i = 0; i < n; ++i) pixel[i] = qRgba( r,g,b, ( ALPHA * ( (OPACITY*(255-GRAY)) / 255 ) ) / 255 ); } #if 1 QPainterPath glasPath; glasPath.moveTo( img.rect().topLeft() ); glasPath.lineTo( img.rect().topRight() ); glasPath.quadTo( img.rect().center()/2, img.rect().bottomLeft() ); QPainter p( &img ); p.setRenderHint( QPainter::Antialiasing ); p.setPen( Qt::NoPen ); p.setBrush( QColor(255,255,255,64) ); p.drawPath(glasPath); p.end(); #endif m_ui2->photo->setPixmap( QPixmap::fromImage( img ) ); return true; }
void CCJKShapeLine::DrawArrow(QPainter *painter, ArrowTypeFlag arrowType, const QPointF &p, const QPointF &p1, const QPointF &p2, qreal arrowSize) { CJK_D(CCJKShapeLine); QPen pen = d->pen; pen.setStyle(Qt::SolidLine); pen.setJoinStyle(Qt::MiterJoin); painter->setPen(pen); switch (arrowType) { case ArrowArc: { QPainterPath path; path.moveTo(p1); path.lineTo(p); path.lineTo(p2); QPointF c = QPointF((p1.x() + p2.x() + p.x()) / 3, (p1.y() + p2.y() + p.y()) / 3); path.quadTo(c, p1); painter->drawPath(path); } break; case ArrowLine: { QBrush brsh(Qt::NoBrush); painter->setBrush(brsh); pen.setCapStyle(Qt::SquareCap); QPainterPath path; path.moveTo(p1); path.lineTo(p); path.lineTo(p2); painter->drawPath(path); } break; case ArrowCircle: { painter->drawEllipse(p, arrowSize / 2, arrowSize / 2); } break; case ArrowTriangle: default: { QPolygonF arrowHead; arrowHead << p << p1 << p2; painter->drawPolygon(arrowHead); break; } } painter->setBrush(d->brush); painter->setPen(d->pen); }
QPainterPath Previewer::magnifierPath( const QSize & top , const QRect & rct , int padding ) const { QPainterPath path; path.setFillRule( Qt::WindingFill ); /*! ======= Draw Top of the Magnifier ======= */ path.moveTo( (rct.width()-top.width())/2 , padding+top.height() ); path.lineTo( rct.width()/2 , padding ); path.lineTo( (rct.width()+top.width())/2 , padding+top.height() ); /*! ========================================= */ /*! ===== Draw Bottom of the Magnifier ====== */ path.lineTo( rct.width()-padding-ROUNDED_PIXEL , padding+top.height() ); path.quadTo( rct.width()-padding , padding+top.height() , rct.width()-padding , padding+top.height()+ROUNDED_PIXEL ); path.lineTo( rct.width()-padding , rct.height()-padding-ROUNDED_PIXEL ); path.quadTo( rct.width()-padding , rct.height()-padding , rct.width()-padding-ROUNDED_PIXEL , rct.height()-padding ); path.lineTo( padding+ROUNDED_PIXEL , rct.height()-padding ); path.quadTo( padding , rct.height()-padding , padding , rct.height()-padding-ROUNDED_PIXEL ); path.lineTo( padding , padding+top.height()+ROUNDED_PIXEL ); path.quadTo( padding , padding+top.height() , padding+ROUNDED_PIXEL , padding+top.height() ); path.lineTo( (rct.width()-top.width())/2 , padding+top.height() ); /*! ========================================= */ return path; }
SCEyeWipeEffectFactory::SCEyeWipeEffectFactory() : SCPageEffectFactory(EyeWipeEffectId, i18n("Eye")) { QPainterPath shape; //vertical shape.moveTo(0, -12); shape.quadTo(10, 0, 0, 12); shape.quadTo(-10, 0, 0, -12); addStrategy(new SCIrisWipeEffectStrategyBase(shape, Vertical, "eyeWipe", "vertical", false)); //vertical reverse addStrategy(new SCIrisWipeEffectStrategyBase(shape, VerticalReverse, "eyeWipe", "vertical", true)); //horizontal shape = QPainterPath(); shape.moveTo(-12, 0); shape.quadTo(0, 10, 12, 0); shape.quadTo(0, -10, -12, 0); addStrategy(new SCIrisWipeEffectStrategyBase(shape, Horizontal, "eyeWipe", "horizontal", false)); //horizontal reverse addStrategy(new SCIrisWipeEffectStrategyBase(shape, HorizontalReverse, "eyeWipe", "horizontal", true)); }
static QPixmap generateWavyPixmap(qreal maxRadius, const QPen &pen) { const qreal radiusBase = qMax(qreal(1), maxRadius); QString key = QLatin1String("WaveUnderline-Bauhaus"); QPixmap pixmap; if (QPixmapCache::find(key, pixmap)) return pixmap; const qreal halfPeriod = qMax(qreal(2), qreal(radiusBase * 1.61803399)); // the golden ratio const int width = qCeil(100 / (2 * halfPeriod)) * (2 * halfPeriod); const int radius = qFloor(radiusBase); QPainterPath path; qreal xs = 0; qreal ys = radius; while (xs < width) { xs += halfPeriod; ys = -ys; path.quadTo(xs - halfPeriod / 2, ys, xs, 0); } pixmap = QPixmap(width, radius * 2); pixmap.fill(Qt::transparent); { QPen wavePen = pen; wavePen.setCapStyle(Qt::SquareCap); // This is to protect against making the line too fat, as happens on Mac OS X // due to it having a rather thick width for the regular underline. const qreal maxPenWidth = .8 * radius; if (wavePen.widthF() > maxPenWidth) wavePen.setWidth(maxPenWidth); QPainter imgPainter(&pixmap); imgPainter.setPen(wavePen); imgPainter.setRenderHint(QPainter::Antialiasing); imgPainter.translate(0, radius); imgPainter.drawPath(path); } QPixmapCache::insert(key, pixmap); return pixmap; }
void KisCurvePaintOp::paintLine(KisPaintDeviceSP dab, const KisPaintInformation &pi1, const KisPaintInformation &pi2) { if (!m_painter) { m_painter = new KisPainter(dab); m_painter->setPaintColor(painter()->paintColor()); } int maxPoints = m_curveProperties.curve_stroke_history_size; m_points.append(pi2.pos()); while (m_points.length() > maxPoints) { m_points.removeFirst(); } const qreal additionalScale = KisLodTransform::lodToScale(painter()->device()); const qreal lineWidth = additionalScale * m_lineWidthOption.apply(pi2, m_curveProperties.curve_line_width); QPen pen(QBrush(Qt::white), lineWidth); QPainterPath path; if (m_curveProperties.curve_paint_connection_line) { path.moveTo(pi1.pos()); path.lineTo(pi2.pos()); m_painter->drawPainterPath(path, pen); path = QPainterPath(); } if (m_points.length() >= maxPoints) { // alpha * 0.2; path.moveTo(m_points.first()); if (m_curveProperties.curve_smoothing) { path.quadTo(m_points.at(maxPoints / 2), m_points.last()); } else { // control point is at 1/3 of the history, 2/3 of the history and endpoint at 3/3 int step = maxPoints / 3; path.cubicTo(m_points.at(step), m_points.at(step + step), m_points.last()); } qreal curveOpacity = m_curvesOpacityOption.apply(pi2, m_curveProperties.curve_curves_opacity); m_painter->setOpacity(qRound(255.0 * curveOpacity)); m_painter->drawPainterPath(path, pen); m_painter->setOpacity(255); // full } }
void TransitionItem::drawNormal(QPainter *painter) { QLineF line(mapFromItem(m_from, m_from->boundingRect().center()), mapFromItem(m_to, m_to->boundingRect().center())); qreal length = line.length(); QPointF edgeOffset((line.dx() * StateItem::radius) / length, (line.dy() * StateItem::radius) / length); m_start = line.p1() + edgeOffset; m_end = line.p2() - edgeOffset; line = QLineF(m_start, m_end); length = line.length(); QPainterPath path; path.moveTo(m_start); path.quadTo(m_control, m_end); if (isSelected()) { QPen pen(Qt::darkGreen); pen.setStyle(Qt::DashLine); painter->setPen(pen); painter->drawLine(m_start, m_control); painter->drawLine(m_end, m_control); } if (!m_isHovering) painter->setPen(Qt::black); else painter->setPen(Qt::blue); if (isSelected()) { QPen p(painter->pen()); p.setColor(Qt::red); p.setWidth(2); painter->setPen(p); } drawArrow(painter, path, m_end); painter->drawPath(path); drawFunctions(painter, path); }
QPainterPath StrokeTool::strokePathQuad(QList<QPointF> *strokePoints) { QPainterPath path; int pointCount, i = 0; if(strokePoints == 0 || (pointCount = strokePoints->size()) == 0) return path; path.moveTo(strokePoints->at(0)); if(pointCount == 2) { path.lineTo(strokePoints->at(1)); } else while(i < pointCount) { if(pointCount - i == 1) break; if(pointCount - i == 2) { path.lineTo(strokePoints->at(i + 1)); i += 1; } else { path.quadTo(strokePoints->at(i + 1), strokePoints->at(i + 2)); i += 2; } } return path; }
bool QQuickSvgParser::parsePathDataFast(const QString &dataStr, QPainterPath &path) { qreal x0 = 0, y0 = 0; // starting point qreal x = 0, y = 0; // current point char lastMode = 0; QPointF ctrlPt; const QChar *str = dataStr.constData(); const QChar *end = str + dataStr.size(); while (str != end) { while (str->isSpace()) ++str; QChar pathElem = *str; ++str; QChar endc = *end; *const_cast<QChar *>(end) = 0; // parseNumbersArray requires 0-termination that QStringRef cannot guarantee QVarLengthArray<qreal, 8> arg; parseNumbersArray(str, arg); *const_cast<QChar *>(end) = endc; if (pathElem == QLatin1Char('z') || pathElem == QLatin1Char('Z')) arg.append(0);//dummy const qreal *num = arg.constData(); int count = arg.count(); while (count > 0) { qreal offsetX = x; // correction offsets qreal offsetY = y; // for relative commands switch (pathElem.unicode()) { case 'm': { if (count < 2) { num++; count--; break; } x = x0 = num[0] + offsetX; y = y0 = num[1] + offsetY; num += 2; count -= 2; path.moveTo(x0, y0); // As per 1.2 spec 8.3.2 The "moveto" commands // If a 'moveto' is followed by multiple pairs of coordinates without explicit commands, // the subsequent pairs shall be treated as implicit 'lineto' commands. pathElem = QLatin1Char('l'); } break; case 'M': { if (count < 2) { num++; count--; break; } x = x0 = num[0]; y = y0 = num[1]; num += 2; count -= 2; path.moveTo(x0, y0); // As per 1.2 spec 8.3.2 The "moveto" commands // If a 'moveto' is followed by multiple pairs of coordinates without explicit commands, // the subsequent pairs shall be treated as implicit 'lineto' commands. pathElem = QLatin1Char('L'); } break; case 'z': case 'Z': { x = x0; y = y0; count--; // skip dummy num++; path.closeSubpath(); } break; case 'l': { if (count < 2) { num++; count--; break; } x = num[0] + offsetX; y = num[1] + offsetY; num += 2; count -= 2; path.lineTo(x, y); } break; case 'L': { if (count < 2) { num++; count--; break; } x = num[0]; y = num[1]; num += 2; count -= 2; path.lineTo(x, y); } break; case 'h': { x = num[0] + offsetX; num++; count--; path.lineTo(x, y); } break; case 'H': { x = num[0]; num++; count--; path.lineTo(x, y); } break; case 'v': { y = num[0] + offsetY; num++; count--; path.lineTo(x, y); } break; case 'V': { y = num[0]; num++; count--; path.lineTo(x, y); } break; case 'c': { if (count < 6) { num += count; count = 0; break; } QPointF c1(num[0] + offsetX, num[1] + offsetY); QPointF c2(num[2] + offsetX, num[3] + offsetY); QPointF e(num[4] + offsetX, num[5] + offsetY); num += 6; count -= 6; path.cubicTo(c1, c2, e); ctrlPt = c2; x = e.x(); y = e.y(); break; } case 'C': { if (count < 6) { num += count; count = 0; break; } QPointF c1(num[0], num[1]); QPointF c2(num[2], num[3]); QPointF e(num[4], num[5]); num += 6; count -= 6; path.cubicTo(c1, c2, e); ctrlPt = c2; x = e.x(); y = e.y(); break; } case 's': { if (count < 4) { num += count; count = 0; break; } QPointF c1; if (lastMode == 'c' || lastMode == 'C' || lastMode == 's' || lastMode == 'S') c1 = QPointF(2*x-ctrlPt.x(), 2*y-ctrlPt.y()); else c1 = QPointF(x, y); QPointF c2(num[0] + offsetX, num[1] + offsetY); QPointF e(num[2] + offsetX, num[3] + offsetY); num += 4; count -= 4; path.cubicTo(c1, c2, e); ctrlPt = c2; x = e.x(); y = e.y(); break; } case 'S': { if (count < 4) { num += count; count = 0; break; } QPointF c1; if (lastMode == 'c' || lastMode == 'C' || lastMode == 's' || lastMode == 'S') c1 = QPointF(2*x-ctrlPt.x(), 2*y-ctrlPt.y()); else c1 = QPointF(x, y); QPointF c2(num[0], num[1]); QPointF e(num[2], num[3]); num += 4; count -= 4; path.cubicTo(c1, c2, e); ctrlPt = c2; x = e.x(); y = e.y(); break; } case 'q': { if (count < 4) { num += count; count = 0; break; } QPointF c(num[0] + offsetX, num[1] + offsetY); QPointF e(num[2] + offsetX, num[3] + offsetY); num += 4; count -= 4; path.quadTo(c, e); ctrlPt = c; x = e.x(); y = e.y(); break; } case 'Q': { if (count < 4) { num += count; count = 0; break; } QPointF c(num[0], num[1]); QPointF e(num[2], num[3]); num += 4; count -= 4; path.quadTo(c, e); ctrlPt = c; x = e.x(); y = e.y(); break; } case 't': { if (count < 2) { num += count; count = 0; break; } QPointF e(num[0] + offsetX, num[1] + offsetY); num += 2; count -= 2; QPointF c; if (lastMode == 'q' || lastMode == 'Q' || lastMode == 't' || lastMode == 'T') c = QPointF(2*x-ctrlPt.x(), 2*y-ctrlPt.y()); else c = QPointF(x, y); path.quadTo(c, e); ctrlPt = c; x = e.x(); y = e.y(); break; } case 'T': { if (count < 2) { num += count; count = 0; break; } QPointF e(num[0], num[1]); num += 2; count -= 2; QPointF c; if (lastMode == 'q' || lastMode == 'Q' || lastMode == 't' || lastMode == 'T') c = QPointF(2*x-ctrlPt.x(), 2*y-ctrlPt.y()); else c = QPointF(x, y); path.quadTo(c, e); ctrlPt = c; x = e.x(); y = e.y(); break; } case 'a': { if (count < 7) { num += count; count = 0; break; } qreal rx = (*num++); qreal ry = (*num++); qreal xAxisRotation = (*num++); qreal largeArcFlag = (*num++); qreal sweepFlag = (*num++); qreal ex = (*num++) + offsetX; qreal ey = (*num++) + offsetY; count -= 7; qreal curx = x; qreal cury = y; pathArc(path, rx, ry, xAxisRotation, int(largeArcFlag), int(sweepFlag), ex, ey, curx, cury); x = ex; y = ey; } break; case 'A': { if (count < 7) { num += count; count = 0; break; } qreal rx = (*num++); qreal ry = (*num++); qreal xAxisRotation = (*num++); qreal largeArcFlag = (*num++); qreal sweepFlag = (*num++); qreal ex = (*num++); qreal ey = (*num++); count -= 7; qreal curx = x; qreal cury = y; pathArc(path, rx, ry, xAxisRotation, int(largeArcFlag), int(sweepFlag), ex, ey, curx, cury); x = ex; y = ey; } break; default: return false; } lastMode = pathElem.toLatin1(); } } return true; }
/*! Paints the gantt item \a idx using \a painter and \a opt */ void ItemDelegate::paintGanttItem( QPainter* painter, const StyleOptionGanttItem& opt, const QModelIndex& idx ) { if ( !idx.isValid() ) return; const ItemType typ = static_cast<ItemType>( idx.model()->data( idx, ItemTypeRole ).toInt() ); const QString& txt = opt.text; QRectF itemRect = opt.itemRect; QRectF boundingRect = opt.boundingRect; boundingRect.setY( itemRect.y() ); boundingRect.setHeight( itemRect.height() ); //qDebug() << "itemRect="<<itemRect<<", boundingRect="<<boundingRect; painter->save(); QPen pen = defaultPen( typ ); if ( opt.state & QStyle::State_Selected ) pen.setWidth( 2*pen.width() ); painter->setPen( pen ); painter->setBrush( defaultBrush( typ ) ); qreal pw = painter->pen().width()/2.; switch( typ ) { case TypeTask: if ( itemRect.isValid() ) { // TODO qreal pw = painter->pen().width()/2.; pw-=1; QRectF r = itemRect; r.translate( 0., r.height()/6. ); r.setHeight( 2.*r.height()/3. ); painter->setBrushOrigin( itemRect.topLeft() ); painter->save(); painter->translate( 0.5, 0.5 ); painter->drawRect( r ); bool ok; qreal completion = idx.model()->data( idx, KDGantt::TaskCompletionRole ).toDouble( &ok ); if ( ok ) { qreal h = r.height(); QRectF cr( r.x(), r.y()+h/4. + 1, r.width()*completion/100., h/2. - 2 ); painter->fillRect( cr, painter->pen().brush() ); } painter->restore(); Qt::Alignment ta; switch( opt.displayPosition ) { case StyleOptionGanttItem::Left: ta = Qt::AlignLeft; break; case StyleOptionGanttItem::Right: ta = Qt::AlignRight; break; case StyleOptionGanttItem::Center: ta = Qt::AlignCenter; break; } painter->drawText( boundingRect, ta, txt ); } break; case TypeSummary: if ( opt.itemRect.isValid() ) { // TODO pw-=1; const QRectF r = QRectF( opt.itemRect ).adjusted( -pw, -pw, pw, pw ); QPainterPath path; const qreal deltaY = r.height()/2.; const qreal deltaX = qMin( r.width()/qreal(2), deltaY ); path.moveTo( r.topLeft() ); path.lineTo( r.topRight() ); path.lineTo( QPointF( r.right(), r.top() + 2.*deltaY ) ); //path.lineTo( QPointF( r.right()-3./2.*delta, r.top() + delta ) ); path.quadTo( QPointF( r.right()-.5*deltaX, r.top() + deltaY ), QPointF( r.right()-2.*deltaX, r.top() + deltaY ) ); //path.lineTo( QPointF( r.left()+3./2.*delta, r.top() + delta ) ); path.lineTo( QPointF( r.left() + 2.*deltaX, r.top() + deltaY ) ); path.quadTo( QPointF( r.left()+.5*deltaX, r.top() + deltaY ), QPointF( r.left(), r.top() + 2.*deltaY ) ); path.closeSubpath(); painter->setBrushOrigin( itemRect.topLeft() ); painter->save(); painter->translate( 0.5, 0.5 ); painter->drawPath( path ); painter->restore(); Qt::Alignment ta; switch( opt.displayPosition ) { case StyleOptionGanttItem::Left: ta = Qt::AlignLeft; break; case StyleOptionGanttItem::Right: ta = Qt::AlignRight; break; case StyleOptionGanttItem::Center: ta = Qt::AlignCenter; break; } painter->drawText( boundingRect, ta | Qt::AlignVCenter, txt ); } break; case TypeEvent: /* TODO */ //qDebug() << opt.boundingRect << opt.itemRect; if ( opt.boundingRect.isValid() ) { const qreal pw = painter->pen().width() / 2. - 1; const QRectF r = QRectF( opt.rect ).adjusted( -pw, -pw, pw, pw ); QPainterPath path; const qreal delta = static_cast< int >( r.height() / 2 ); path.moveTo( delta, 0. ); path.lineTo( 2.*delta, delta ); path.lineTo( delta, 2.*delta ); path.lineTo( 0., delta ); path.closeSubpath(); painter->save(); painter->translate( r.topLeft() ); painter->translate( 0.5, 0.5 ); painter->drawPath( path ); painter->restore(); Qt::Alignment ta; switch( opt.displayPosition ) { case StyleOptionGanttItem::Left: ta = Qt::AlignLeft; break; case StyleOptionGanttItem::Right: ta = Qt::AlignRight; break; case StyleOptionGanttItem::Center: ta = Qt::AlignCenter; break; } painter->drawText( boundingRect, ta | Qt::AlignVCenter, txt ); } break; default: break; } painter->restore(); }
void ConnectorGraphics::updatePosition() { QPainterPath Path; QPointF FromPos; QPointF ToPos; if (m_FromOutNode == NODE_PROD) FromPos = mp_FromItem->getProducedIOPosition(); else FromPos = mp_FromItem->getUpOutIOPosition(); if (m_ToInNode == NODE_REQ) ToPos = mp_ToItem->getRequiredIOPosition(); else if (m_ToInNode == NODE_US) ToPos = mp_ToItem->getUsedIOPosition(); else ToPos = mp_ToItem->getUpInIOPosition(); Path.moveTo(FromPos); // intermediate position helps for correct bezier curve shape // and for positionning of variable names as curve label QPointF InterPos; if (FromPos.y() < ToPos.y()) // "From" slot (source) is upper than "To" slot (destination) { InterPos = QPointF(FromPos.x()+((ToPos.x()-FromPos.x())/2.0), FromPos.y()+((ToPos.y()-FromPos.y())/2.0)); Path.quadTo(QPointF(FromPos.x(),InterPos.y()),InterPos); Path.quadTo(QPointF(ToPos.x(),InterPos.y()),ToPos); } else // "From" slot (source) is lower than "To" slot (destination) { InterPos = QPointF(FromPos.x()+((ToPos.x()-FromPos.x())/2.0)-200, FromPos.y()+((ToPos.y()-FromPos.y())/2.0)); Path.quadTo(QPointF(FromPos.x()-200,FromPos.y()+200), InterPos); Path.quadTo(QPointF(ToPos.x()-200,ToPos.y()-200), ToPos); } setPath(Path); // variables names mp_VarsText->setText(m_Variables.join("\n")); QPointF TextPos(InterPos.x()-mp_VarsText->boundingRect().width()/2, InterPos.y()-mp_VarsText->boundingRect().height()/2); mp_VarsText->setPos(TextPos); // variables names background box mp_VarsTextBox->setRect(TextPos.x()-2,TextPos.y()-2, mp_VarsText->boundingRect().width()+4, mp_VarsText->boundingRect().height()+4); }