116         m_curvyness_mul = CURVE_FLATNESS;

   126         m_curvyness_mul = CURVE_FLATNESS / m_inv_scale;

   133     m_sin_theta = qSin(Q_PI / m_roundness); // ### Use qFastSin

   143     m_sin_theta = qFastSin(Q_PI / m_roundness);

   134     m_cos_theta = qCos(Q_PI / m_roundness);

   144     m_cos_theta = qFastCos(Q_PI / m_roundness);

   168                     endCapOrJoinClosed(startPts, pts, path.hasImplicitClose(), endsAtStart);

   177                     endCapOrJoinClosed(startPts, pts-2, path.hasImplicitClose(), endsAtStart);

   246 

   314 void QTriangulatingStroker::join(const qreal *pts)

   315 {

   316     // Creates a join to the next segment (m_cx, m_cy) -> (pts[0], pts[1])

   317     normalVector(m_cx, m_cy, pts[0], pts[1], &m_nvx, &m_nvy);

   318 

   319     switch (m_join_style) {

   320     case Qt::BevelJoin:

   321         break;

   322     case Qt::SvgMiterJoin:

   323     case Qt::MiterJoin: {

   324         // Find out on which side the join should be.

   325         int count = m_vertices.size();

   326         float prevNvx = m_vertices.at(count - 2) - m_cx;

   327         float prevNvy = m_vertices.at(count - 1) - m_cy;

   328         float xprod = prevNvx * m_nvy - prevNvy * m_nvx;

   329         float px, py, qx, qy;

   330 

   331         // If the segments are parallel, use bevel join.

   332         if (qFuzzyIsNull(xprod))

   333             break;

   334 

   335         // Find the corners of the previous and next segment to join.

   336         if (xprod < 0) {

   337             px = m_vertices.at(count - 2);

   338             py = m_vertices.at(count - 1);

   339             qx = m_cx - m_nvx;

   340             qy = m_cy - m_nvy;

   341         } else {

   342             px = m_vertices.at(count - 4);

   343             py = m_vertices.at(count - 3);

   344             qx = m_cx + m_nvx;

   345             qy = m_cy + m_nvy;

   346         }

   347 

   348         // Find intersection point.

   349         float pu = px * prevNvx + py * prevNvy;

   350         float qv = qx * m_nvx + qy * m_nvy;

   351         float ix = (m_nvy * pu - prevNvy * qv) / xprod;

   352         float iy = (prevNvx * qv - m_nvx * pu) / xprod;

   353 

   354         // Check that the distance to the intersection point is less than the miter limit.

   355         if ((ix - px) * (ix - px) + (iy - py) * (iy - py) <= m_miter_limit * m_miter_limit) {

   356             m_vertices.add(ix);

   357             m_vertices.add(iy);

   358             m_vertices.add(ix);

   359             m_vertices.add(iy);

   360         }

   361         // else

   362         // Do a plain bevel join if the miter limit is exceeded or if

   363         // the lines are parallel. This is not what the raster

   364         // engine's stroker does, but it is both faster and similar to

   365         // what some other graphics API's do.

   366 

   367         break; }

   368     case Qt::RoundJoin: {

   369         QVarLengthArray<float> points;

   370         int count = m_vertices.size();

   371         float prevNvx = m_vertices.at(count - 2) - m_cx;

   372         float prevNvy = m_vertices.at(count - 1) - m_cy;

   373         if (m_nvx * prevNvy - m_nvy * prevNvx < 0) {

   374             arcPoints(0, 0, m_nvx, m_nvy, -prevNvx, -prevNvy, points);

   375             for (int i = points.size() / 2; i > 0; --i)

   376                 emitLineSegment(m_cx, m_cy, points[2 * i - 2], points[2 * i - 1]);

   377         } else {

   378             arcPoints(0, 0, -prevNvx, -prevNvy, m_nvx, m_nvy, points);

   379             for (int i = 0; i < points.size() / 2; ++i)

   380                 emitLineSegment(m_cx, m_cy, points[2 * i + 0], points[2 * i + 1]);

   381         }

   382         break; }

   383     default: break; // gcc warn--

   384     }

   385 

   386     emitLineSegment(m_cx, m_cy, m_nvx, m_nvy);

   387 }

   388 

   389 void QTriangulatingStroker::endCap(const qreal *)

   390 {

   391     switch (m_cap_style) {

   392     case Qt::FlatCap:

   393         break;

   394     case Qt::SquareCap:

   395         emitLineSegment(m_cx + m_nvy, m_cy - m_nvx, m_nvx, m_nvy);

   396         break;

   397     case Qt::RoundCap: {

   398         QVarLengthArray<float> points;

   399         int count = m_vertices.size();

   400         arcPoints(m_cx, m_cy, m_vertices.at(count - 2), m_vertices.at(count - 1), m_vertices.at(count - 4), m_vertices.at(count - 3), points);

   401         int front = 0;

   402         int end = points.size() / 2;

   403         while (front != end) {

   404             m_vertices.add(points[2 * end - 2]);

   405             m_vertices.add(points[2 * end - 1]);

   406             --end;

   407             if (front == end)

   408                 break;

   409             m_vertices.add(points[2 * front + 0]);

   410             m_vertices.add(points[2 * front + 1]);

   411             ++front;

   412         }

   413         break; }

   414     default: break; // to shut gcc up...

   415     }

   416 }

   417 

   418 void QTriangulatingStroker::arcPoints(float cx, float cy, float fromX, float fromY, float toX, float toY, QVarLengthArray<float> &points)

   419 {

   420     float dx1 = fromX - cx;

   421     float dy1 = fromY - cy;

   422     float dx2 = toX - cx;

   423     float dy2 = toY - cy;

   424 

   425     // while more than 180 degrees left:

   426     while (dx1 * dy2 - dx2 * dy1 < 0) {

   427         float tmpx = dx1 * m_cos_theta - dy1 * m_sin_theta;

   428         float tmpy = dx1 * m_sin_theta + dy1 * m_cos_theta;

   429         dx1 = tmpx;

   430         dy1 = tmpy;

   431         points.append(cx + dx1);

   432         points.append(cy + dy1);

   433     }

   434 

   435     // while more than 90 degrees left:

   436     while (dx1 * dx2 + dy1 * dy2 < 0) {

   437         float tmpx = dx1 * m_cos_theta - dy1 * m_sin_theta;

   438         float tmpy = dx1 * m_sin_theta + dy1 * m_cos_theta;

   439         dx1 = tmpx;

   440         dy1 = tmpy;

   441         points.append(cx + dx1);

   442         points.append(cy + dy1);

   443     }

   444 

   445     // while more than 0 degrees left:

   446     while (dx1 * dy2 - dx2 * dy1 > 0) {

   447         float tmpx = dx1 * m_cos_theta - dy1 * m_sin_theta;

   448         float tmpy = dx1 * m_sin_theta + dy1 * m_cos_theta;

   449         dx1 = tmpx;

   450         dy1 = tmpy;

   451         points.append(cx + dx1);

   452         points.append(cy + dy1);

   453     }

   454 

   455     // remove last point which was rotated beyond [toX, toY].

   456     if (!points.isEmpty())

   457         points.resize(points.size() - 2);

   458 }

   281     qreal width = pen.width();

   493     qreal width = qpen_widthf(pen);

   286     m_dash_stroker.setStrokeWidth(width);

   498     m_dash_stroker.setStrokeWidth(pen.isCosmetic() ? width * m_inv_scale : width);