fix(strokecanvasitem): use qreal instead of float to suppress -Wdouble-promotion

Plugins/ZShell/Internal/strokecanvasrenderer.cpp

@@ -5,13 +5,11 @@
 namespace ZShell::internal {
 
 static void drawStroke(
-	QCanvasPainter *painter,
-	const QVector<QPointF> &points,
-	const QColor &color,
-	float width) {
-
-	if (points.isEmpty())
-		return;
+	QCanvasPainter* painter,
+	const QVector<QPointF>& points,
+	const QColor& color,
+	qreal width) {
+	if (points.isEmpty()) return;
 
 	painter->setStrokeStyle(color);
 	painter->setFillStyle(color);
@@ -26,26 +24,27 @@ static void drawStroke(
 		return;
 	}
 
-	auto catmullToBezier = [](
-		const QPointF &p0, const QPointF &p1,
-		const QPointF &p2, const QPointF &p3,
-		float tension,
-		QPointF &cp1, QPointF &cp2)
-			       {
-				       cp1 = p1 + (p2 - p0) * tension / 3.0f;
-				       cp2 = p2 - (p3 - p1) * tension / 3.0f;
-			       };
+	auto catmullToBezier = [](const QPointF& p0,
+							  const QPointF& p1,
+							  const QPointF& p2,
+							  const QPointF& p3,
+							  qreal tension,
+							  QPointF& cp1,
+							  QPointF& cp2) {
+		cp1 = p1 + (p2 - p0) * tension / 3.0;
+		cp2 = p2 - (p3 - p1) * tension / 3.0;
+	};
 
-	const float tension = 0.5f; // increase toward 1.0 for tighter curves
+	const qreal tension = 0.5; // increase toward 1.0 for tighter curves
 
 	painter->beginPath();
 	painter->moveTo(points[0]);
 
 	for (int i = 0; i < points.size() - 1; ++i) {
-		const QPointF &p0 = points[qMax(i - 1, 0)];
-		const QPointF &p1 = points[i];
-		const QPointF &p2 = points[i + 1];
-		const QPointF &p3 = points[qMin(i + 2, points.size() - 1)];
+		const QPointF& p0 = points[qMax(i - 1, 0)];
+		const QPointF& p1 = points[i];
+		const QPointF& p2 = points[i + 1];
+		const QPointF& p3 = points[qMin(i + 2, points.size() - 1)];
 
 		QPointF cp1, cp2;
 		catmullToBezier(p0, p1, p2, p3, tension, cp1, cp2);
@@ -56,13 +55,12 @@ static void drawStroke(
 }
 
 static void drawHoverCursor(
-	QCanvasPainter *painter,
-	const QPointF &point,
-	float penWidth,
+	QCanvasPainter* painter,
+	const QPointF& point,
+	qreal penWidth,
 	QColor penColor,
-	bool isDrawing)
-{
-	const float radius = penWidth * 0.5f;
+	bool isDrawing) {
+	const qreal radius = penWidth * 0.5;
 
 	if (isDrawing) {
 		painter->setFillStyle(penColor);
@@ -73,55 +71,59 @@ static void drawHoverCursor(
 
 	const float lineWidth = 1.5f;
 	const float crosshairSize = 6.0f;
-	const bool useDashes = penWidth > 10.0f;
+	const bool useDashes = penWidth > 10.0;
 
-	auto drawOutline = [&](const QColor &color, float width) {
-				   painter->setStrokeStyle(color);
-				   painter->setLineWidth(width);
-				   painter->setLineCap(QCanvasPainter::LineCap::Round);
+	auto drawOutline = [&](const QColor& color, qreal width) {
+		painter->setStrokeStyle(color);
+		painter->setLineWidth(width);
+		painter->setLineCap(QCanvasPainter::LineCap::Round);
 
 
-				   if (useDashes) {
-					   const int dashCount = 12;
-					   const float fullAngle = 2.0f * M_PI;
-					   const float dashAngle = fullAngle / dashCount * 0.5f;
-					   const float gapAngle  = fullAngle / dashCount * 0.5f;
+		if (useDashes) {
+			const int dashCount = 12;
+			const float fullAngle = 2.0f * M_PI;
+			const float dashAngle = fullAngle / dashCount * 0.5f;
+			const float gapAngle = fullAngle / dashCount * 0.5f;
 
-					   float angle = 0.0f;
-					   for (int i = 0; i < dashCount; ++i) {
-						   painter->beginPath();
-						   painter->arc(point, radius, angle, angle + dashAngle,
-						                QCanvasPainter::PathWinding::ClockWise,
-						                QCanvasPainter::PathConnection::NotConnected);
-						   painter->stroke();
-						   angle += dashAngle + gapAngle;
-					   }
-				   } else {
-					   painter->beginPath();
-					   painter->circle(point, radius);
-					   painter->stroke();
-				   }
-			   };
+			float angle = 0.0f;
+			for (int i = 0; i < dashCount; ++i) {
+				painter->beginPath();
+				painter->arc(
+					point,
+					radius,
+					angle,
+					angle + dashAngle,
+					QCanvasPainter::PathWinding::ClockWise,
+					QCanvasPainter::PathConnection::NotConnected);
+				painter->stroke();
+				angle += dashAngle + gapAngle;
+			}
+		} else {
+			painter->beginPath();
+			painter->circle(point, radius);
+			painter->stroke();
+		}
+	};
 
-	auto drawCrosshair = [&](const QColor &color, float width) {
-				     painter->setStrokeStyle(color);
-				     painter->setLineWidth(width);
-				     painter->setLineCap(QCanvasPainter::LineCap::Round);
+	auto drawCrosshair = [&](const QColor& color, qreal width) {
+		painter->setStrokeStyle(color);
+		painter->setLineWidth(width);
+		painter->setLineCap(QCanvasPainter::LineCap::Round);
 
-				     const float inner = radius + 3.0f;
-				     const float outer = radius + 3.0f + crosshairSize;
+		const float inner = radius + 3.0f;
+		const float outer = radius + 3.0f + crosshairSize;
 
-				     painter->beginPath();
-				     painter->moveTo(point + QPointF(0, -outer));
-				     painter->lineTo(point + QPointF(0, -inner));
-				     painter->moveTo(point + QPointF(0,  outer));
-				     painter->lineTo(point + QPointF(0,  inner));
-				     painter->moveTo(point + QPointF(-outer, 0));
-				     painter->lineTo(point + QPointF(-inner, 0));
-				     painter->moveTo(point + QPointF( outer, 0));
-				     painter->lineTo(point + QPointF( inner, 0));
-				     painter->stroke();
-			     };
+		painter->beginPath();
+		painter->moveTo(point + QPointF(0, -outer));
+		painter->lineTo(point + QPointF(0, -inner));
+		painter->moveTo(point + QPointF(0, outer));
+		painter->lineTo(point + QPointF(0, inner));
+		painter->moveTo(point + QPointF(-outer, 0));
+		painter->lineTo(point + QPointF(-inner, 0));
+		painter->moveTo(point + QPointF(outer, 0));
+		painter->lineTo(point + QPointF(inner, 0));
+		painter->stroke();
+	};
 
 	drawOutline(QColor(0, 0, 0, 160), lineWidth + 1.0f);
 	drawCrosshair(QColor(0, 0, 0, 160), lineWidth + 1.0f);
@@ -130,8 +132,8 @@ static void drawHoverCursor(
 	drawCrosshair(QColor(255, 255, 255, 220), lineWidth);
 }
 
-void StrokeCanvasRenderer::synchronizeData(QCanvasPainterItem *item) {
-	auto *canvas = static_cast<StrokeCanvasItem *>(item);
+void StrokeCanvasRenderer::synchronizeData(QCanvasPainterItem* item) {
+	auto* canvas = static_cast<StrokeCanvasItem*>(item);
 
 	m_penColor = canvas->m_penColor;
 	m_penWidth = canvas->m_penWidth;
@@ -140,7 +142,7 @@ void StrokeCanvasRenderer::synchronizeData(QCanvasPainterItem *item) {
 		m_strokes.append(canvas->m_strokes[m_strokes.size()]);
 
 	if (canvas->m_strokes.isEmpty() && !m_strokes.isEmpty()) {
-		for (const auto &stroke : m_strokes)
+		for (const auto& stroke : m_strokes)
 			if (stroke.groupId >= 0)
 				m_pendingGroupRemovals.append(stroke.groupId);
 		m_strokes.clear();
@@ -153,14 +155,14 @@ void StrokeCanvasRenderer::synchronizeData(QCanvasPainterItem *item) {
 	m_isDrawing = canvas->m_isDrawing;
 }
 
-void StrokeCanvasRenderer::paint(QCanvasPainter *painter) {
+void StrokeCanvasRenderer::paint(QCanvasPainter* painter) {
 	for (int id : m_pendingGroupRemovals)
 		painter->removePathGroup(id);
 	m_pendingGroupRemovals.clear();
 
 	painter->clearRect(0, 0, width(), height());
 
-	for (const auto &stroke : m_strokes) {
+	for (const auto& stroke : m_strokes) {
 		painter->setStrokeStyle(stroke.color);
 		painter->setFillStyle(stroke.color);
 		painter->setLineWidth(stroke.width);
@@ -174,10 +176,15 @@ void StrokeCanvasRenderer::paint(QCanvasPainter *painter) {
 		}
 	}
 
-	drawStroke(painter, m_currentStroke.points, m_currentStroke.color, m_currentStroke.width);
+	drawStroke(
+		painter,
+		m_currentStroke.points,
+		m_currentStroke.color,
+		m_currentStroke.width);
 
 	if (m_hoverVisible)
-		drawHoverCursor(painter, m_hoverPoint, m_penWidth, m_penColor, m_isDrawing);
+		drawHoverCursor(
+			painter, m_hoverPoint, m_penWidth, m_penColor, m_isDrawing);
 }
 
-};
+}; // namespace ZShell::internal