zach/z-bar-qt
1
1
Fork 0
Code Issues 24 Pull Requests 2 Actions Packages Projects 1 Releases Wiki Activity

fix(strokecanvasitem): use qreal instead of float to suppress -Wdouble-promotion
Lint & Format (JS/TS) / lint-format (pull_request) Successful in 16s
Details
Python / lint-format (pull_request) Successful in 23s
Details
Python / test (pull_request) Successful in 48s
Details
C++ / build (pull_request) Successful in 2m20s
Details
Lint & Format (Rust) / lint-format (pull_request) Successful in 1m59s
Details

Browse Source
This commit is contained in:
AramJonghu
2026-06-30 01:22:40 +02:00
parent 3eecbc16bc
commit 4a18edfc78
5 changed files with 184 additions and 188 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Plugins/ZShell/Internal/stroke.hpp
+2 -2
View File
@@ -11,9 +11,9 @@ struct Stroke {
QVector<QPointF> points; QVector<QPointF> points;
QCanvasPath path; QCanvasPath path;
QColor color; QColor color;
float width; qreal width;
int groupId = -1; int groupId = -1;
bool isSinglePoint = false; bool isSinglePoint = false;
}; };
}; }; // namespace ZShell::internal
Plugins/ZShell/Internal/strokecanvasitem.cpp
+38 -46
View File
@@ -6,55 +6,52 @@
namespace ZShell::internal { namespace ZShell::internal {
StrokeCanvasItem::StrokeCanvasItem(QQuickItem *parent) : QCanvasPainterItem(parent) { StrokeCanvasItem::StrokeCanvasItem(QQuickItem* parent)
: QCanvasPainterItem(parent) {
setFillColor(Qt::transparent); setFillColor(Qt::transparent);
setAlphaBlending(true); setAlphaBlending(true);
} }
QCanvasPainterItemRenderer *StrokeCanvasItem::createItemRenderer() const { QCanvasPainterItemRenderer* StrokeCanvasItem::createItemRenderer() const {
return new StrokeCanvasRenderer; return new StrokeCanvasRenderer;
} }
static bool shouldAddPoint( static bool shouldAddPoint(
const QVector<QPointF> &points, const QVector<QPointF>& points, const QPointF& p, qreal minDistance) {
const QPointF &p, if (points.isEmpty()) return true;
qreal minDistance)
{
if (points.isEmpty())
return true;
const QPointF delta = p - points.last(); const QPointF delta = p - points.last();
return QPointF::dotProduct(delta, delta) return QPointF::dotProduct(delta, delta) >= minDistance * minDistance;
>= minDistance * minDistance;
} }
static QCanvasPath buildStrokePath(const QVector<QPointF> &points, float width) { static QCanvasPath buildStrokePath(const QVector<QPointF>& points, qreal width) {
QCanvasPath path; QCanvasPath path;
if (points.size() == 1) { if (points.size() == 1) {
path.circle(points[0], width * 0.5f); path.circle(points[0], width * 0.5);
return path; return path;
} }
auto catmullToBezier = []( auto catmullToBezier = [](const QPointF& p0,
const QPointF &p0, const QPointF &p1, const QPointF& p1,
const QPointF &p2, const QPointF &p3, const QPointF& p2,
float tension, const QPointF& p3,
QPointF &cp1, QPointF &cp2) qreal tension,
{ QPointF& cp1,
cp1 = p1 + (p2 - p0) * tension / 3.0f; QPointF& cp2) {
cp2 = p2 - (p3 - p1) * tension / 3.0f; cp1 = p1 + (p2 - p0) * tension / 3.0;
}; cp2 = p2 - (p3 - p1) * tension / 3.0;
};
const float tension = 0.5f; const qreal tension = 0.5;
path.moveTo(points[0]); path.moveTo(points[0]);
for (int i = 0; i < points.size() - 1; ++i) { for (int i = 0; i < points.size() - 1; ++i) {
const QPointF &p0 = points[qMax(i - 1, 0)]; const QPointF& p0 = points[qMax(i - 1, 0)];
const QPointF &p1 = points[i]; const QPointF& p1 = points[i];
const QPointF &p2 = points[i + 1]; const QPointF& p2 = points[i + 1];
const QPointF &p3 = points[qMin(i + 2, points.size() - 1)]; const QPointF& p3 = points[qMin(i + 2, points.size() - 1)];
QPointF cp1, cp2; QPointF cp1, cp2;
catmullToBezier(p0, p1, p2, p3, tension, cp1, cp2); catmullToBezier(p0, p1, p2, p3, tension, cp1, cp2);
@@ -64,9 +61,8 @@ static QCanvasPath buildStrokePath(const QVector<QPointF> &points, float width)
return path; return path;
} }
void StrokeCanvasItem::setPenColor(const QColor &color) { void StrokeCanvasItem::setPenColor(const QColor& color) {
if (m_penColor == color) if (m_penColor == color) return;
return;
m_penColor = color; m_penColor = color;
update(); update();
@@ -75,8 +71,7 @@ void StrokeCanvasItem::setPenColor(const QColor &color) {
} }
void StrokeCanvasItem::setHoverVisible(bool visible) { void StrokeCanvasItem::setHoverVisible(bool visible) {
if (m_hoverVisible == visible) if (m_hoverVisible == visible) return;
return;
m_hoverVisible = visible; m_hoverVisible = visible;
update(); update();
@@ -84,9 +79,8 @@ void StrokeCanvasItem::setHoverVisible(bool visible) {
emit hoverVisibleChanged(); emit hoverVisibleChanged();
} }
void StrokeCanvasItem::setHoverPoint(const QPointF &point) { void StrokeCanvasItem::setHoverPoint(const QPointF& point) {
if (m_hoverPoint == point) if (m_hoverPoint == point) return;
return;
m_hoverPoint = point; m_hoverPoint = point;
update(); update();
@@ -110,8 +104,7 @@ void StrokeCanvasItem::showHover(qreal x, qreal y) {
} }
void StrokeCanvasItem::hideHover() { void StrokeCanvasItem::hideHover() {
if (!m_hoverVisible) if (!m_hoverVisible) return;
return;
m_hoverVisible = false; m_hoverVisible = false;
update(); update();
@@ -119,9 +112,8 @@ void StrokeCanvasItem::hideHover() {
emit hoverVisibleChanged(); emit hoverVisibleChanged();
} }
void StrokeCanvasItem::setPenWidth(float width) { void StrokeCanvasItem::setPenWidth(qreal width) {
if (qFuzzyCompare(m_penWidth, width)) if (qFuzzyCompare(m_penWidth, width)) return;
return;
m_penWidth = width; m_penWidth = width;
update(); update();
@@ -143,8 +135,7 @@ void StrokeCanvasItem::beginStroke(qreal x, qreal y) {
void StrokeCanvasItem::appendPoint(qreal x, qreal y) { void StrokeCanvasItem::appendPoint(qreal x, qreal y) {
const QPointF incoming{x, y}; const QPointF incoming{x, y};
if (!shouldAddPoint(m_currentStroke.points, incoming, 2.0)) if (!shouldAddPoint(m_currentStroke.points, incoming, 2.0)) return;
return;
QPointF smoothed; QPointF smoothed;
if (m_currentStroke.points.isEmpty()) { if (m_currentStroke.points.isEmpty()) {
@@ -159,7 +150,8 @@ void StrokeCanvasItem::appendPoint(qreal x, qreal y) {
constexpr qreal minAlpha = 0.1; constexpr qreal minAlpha = 0.1;
constexpr qreal maxAlpha = 0.3; constexpr qreal maxAlpha = 0.3;
const qreal t = std::clamp((dist - minDist) / (maxDist - minDist), 0.0, 1.0); const qreal t =
std::clamp((dist - minDist) / (maxDist - minDist), 0.0, 1.0);
const qreal alpha = minAlpha + t * (maxAlpha - minAlpha); const qreal alpha = minAlpha + t * (maxAlpha - minAlpha);
smoothed = last * (1.0 - alpha) + incoming * alpha; smoothed = last * (1.0 - alpha) + incoming * alpha;
@@ -171,11 +163,11 @@ void StrokeCanvasItem::appendPoint(qreal x, qreal y) {
void StrokeCanvasItem::endStroke() { void StrokeCanvasItem::endStroke() {
m_isDrawing = false; m_isDrawing = false;
if (m_currentStroke.points.isEmpty()) if (m_currentStroke.points.isEmpty()) return;
return;
m_currentStroke.isSinglePoint = (m_currentStroke.points.size() == 1); m_currentStroke.isSinglePoint = (m_currentStroke.points.size() == 1);
m_currentStroke.path = buildStrokePath(m_currentStroke.points, m_currentStroke.width); m_currentStroke.path =
buildStrokePath(m_currentStroke.points, m_currentStroke.width);
m_currentStroke.groupId = m_nextGroupId++; m_currentStroke.groupId = m_nextGroupId++;
m_currentStroke.points.clear(); m_currentStroke.points.clear();
m_strokes.append(m_currentStroke); m_strokes.append(m_currentStroke);
@@ -190,4 +182,4 @@ void StrokeCanvasItem::clear() {
update(); update();
} }
}; }; // namespace ZShell::internal
Plugins/ZShell/Internal/strokecanvasitem.hpp
+47 -48
View File
@@ -13,68 +13,67 @@ namespace ZShell::internal {
class StrokeCanvasRenderer; class StrokeCanvasRenderer;
class StrokeCanvasItem : public QCanvasPainterItem { class StrokeCanvasItem : public QCanvasPainterItem {
Q_OBJECT Q_OBJECT
QML_NAMED_ELEMENT(StrokeCanvas) QML_NAMED_ELEMENT(StrokeCanvas)
Q_PROPERTY(QColor penColor READ penColor WRITE setPenColor NOTIFY penColorChanged) Q_PROPERTY(
Q_PROPERTY(bool hoverVisible READ hoverVisible WRITE setHoverVisible NOTIFY hoverVisibleChanged) QColor penColor READ penColor WRITE setPenColor NOTIFY penColorChanged)
Q_PROPERTY(QPointF hoverPoint READ hoverPoint WRITE setHoverPoint NOTIFY hoverPointChanged) Q_PROPERTY(
Q_PROPERTY(qreal penWidth READ penWidth WRITE setPenWidth NOTIFY penWidthChanged) bool hoverVisible READ hoverVisible WRITE setHoverVisible NOTIFY
hoverVisibleChanged)
Q_PROPERTY(
QPointF hoverPoint READ hoverPoint WRITE setHoverPoint NOTIFY
hoverPointChanged)
Q_PROPERTY(
qreal penWidth READ penWidth WRITE setPenWidth NOTIFY penWidthChanged)
public: public:
explicit StrokeCanvasItem(QQuickItem *parent = nullptr); explicit StrokeCanvasItem(QQuickItem* parent = nullptr);
[[nodiscard]] bool hoverVisible() const { [[nodiscard]] bool hoverVisible() const { return m_hoverVisible; }
return m_hoverVisible; [[nodiscard]] QPointF hoverPoint() const { return m_hoverPoint; }
}
[[nodiscard]] QPointF hoverPoint() const {
return m_hoverPoint;
}
void setHoverVisible(bool visible); void setHoverVisible(bool visible);
void setHoverPoint(const QPointF &point); void setHoverPoint(const QPointF& point);
Q_INVOKABLE void showHover(qreal x, qreal y); Q_INVOKABLE void showHover(qreal x, qreal y);
Q_INVOKABLE void hideHover(); Q_INVOKABLE void hideHover();
[[nodiscard]] QColor penColor() const { [[nodiscard]] QColor penColor() const { return m_penColor; }
return m_penColor; [[nodiscard]] qreal penWidth() const { return m_penWidth; }
}
[[nodiscard]] float penWidth() const {
return m_penWidth;
}
void setPenColor(const QColor &color); void setPenColor(const QColor& color);
void setPenWidth(float width); void setPenWidth(qreal width);
Q_INVOKABLE void clear(); Q_INVOKABLE void clear();
Q_INVOKABLE void beginStroke(qreal x, qreal y); Q_INVOKABLE void beginStroke(qreal x, qreal y);
Q_INVOKABLE void appendPoint(qreal x, qreal y); Q_INVOKABLE void appendPoint(qreal x, qreal y);
Q_INVOKABLE void endStroke(); Q_INVOKABLE void endStroke();
signals: signals:
void penColorChanged(); void penColorChanged();
void penWidthChanged(); void penWidthChanged();
void hoverVisibleChanged(); void hoverVisibleChanged();
void hoverPointChanged(); void hoverPointChanged();
protected: protected:
[[nodiscard]] QCanvasPainterItemRenderer *createItemRenderer() const override; [[nodiscard]] QCanvasPainterItemRenderer* createItemRenderer()
const override;
private: private:
friend class StrokeCanvasRenderer; friend class StrokeCanvasRenderer;
bool m_hoverVisible = false; bool m_hoverVisible = false;
QPointF m_hoverPoint; QPointF m_hoverPoint;
QColor m_penColor = Qt::white; QColor m_penColor = Qt::white;
float m_penWidth = 4.f; qreal m_penWidth = 4.0;
bool m_isDrawing = false; bool m_isDrawing = false;
int m_nextGroupId = 0; int m_nextGroupId = 0;
QVector<Stroke> m_strokes; QVector<Stroke> m_strokes;
Stroke m_currentStroke; Stroke m_currentStroke;
}; };
}; }; // namespace ZShell::internal
Plugins/ZShell/Internal/strokecanvasrenderer.cpp
+84 -77
View File
@@ -5,13 +5,11 @@
namespace ZShell::internal { namespace ZShell::internal {
static void drawStroke( static void drawStroke(
QCanvasPainter *painter, QCanvasPainter* painter,
const QVector<QPointF> &points, const QVector<QPointF>& points,
const QColor &color, const QColor& color,
float width) { qreal width) {
if (points.isEmpty()) return;
if (points.isEmpty())
return;
painter->setStrokeStyle(color); painter->setStrokeStyle(color);
painter->setFillStyle(color); painter->setFillStyle(color);
@@ -26,26 +24,27 @@ static void drawStroke(
return; return;
} }
auto catmullToBezier = []( auto catmullToBezier = [](const QPointF& p0,
const QPointF &p0, const QPointF &p1, const QPointF& p1,
const QPointF &p2, const QPointF &p3, const QPointF& p2,
float tension, const QPointF& p3,
QPointF &cp1, QPointF &cp2) qreal tension,
{ QPointF& cp1,
cp1 = p1 + (p2 - p0) * tension / 3.0f; QPointF& cp2) {
cp2 = p2 - (p3 - p1) * tension / 3.0f; 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->beginPath();
painter->moveTo(points[0]); painter->moveTo(points[0]);
for (int i = 0; i < points.size() - 1; ++i) { for (int i = 0; i < points.size() - 1; ++i) {
const QPointF &p0 = points[qMax(i - 1, 0)]; const QPointF& p0 = points[qMax(i - 1, 0)];
const QPointF &p1 = points[i]; const QPointF& p1 = points[i];
const QPointF &p2 = points[i + 1]; const QPointF& p2 = points[i + 1];
const QPointF &p3 = points[qMin(i + 2, points.size() - 1)]; const QPointF& p3 = points[qMin(i + 2, points.size() - 1)];
QPointF cp1, cp2; QPointF cp1, cp2;
catmullToBezier(p0, p1, p2, p3, tension, cp1, cp2); catmullToBezier(p0, p1, p2, p3, tension, cp1, cp2);
@@ -56,13 +55,12 @@ static void drawStroke(
} }
static void drawHoverCursor( static void drawHoverCursor(
QCanvasPainter *painter, QCanvasPainter* painter,
const QPointF &point, const QPointF& point,
float penWidth, qreal penWidth,
QColor penColor, QColor penColor,
bool isDrawing) bool isDrawing) {
{ const qreal radius = penWidth * 0.5;
const float radius = penWidth * 0.5f;
if (isDrawing) { if (isDrawing) {
painter->setFillStyle(penColor); painter->setFillStyle(penColor);
@@ -73,55 +71,59 @@ static void drawHoverCursor(
const float lineWidth = 1.5f; const float lineWidth = 1.5f;
const float crosshairSize = 6.0f; const float crosshairSize = 6.0f;
const bool useDashes = penWidth > 10.0f; const bool useDashes = penWidth > 10.0;
auto drawOutline = [&](const QColor &color, float width) { auto drawOutline = [&](const QColor& color, qreal width) {
painter->setStrokeStyle(color); painter->setStrokeStyle(color);
painter->setLineWidth(width); painter->setLineWidth(width);
painter->setLineCap(QCanvasPainter::LineCap::Round); painter->setLineCap(QCanvasPainter::LineCap::Round);
if (useDashes) { if (useDashes) {
const int dashCount = 12; const int dashCount = 12;
const float fullAngle = 2.0f * M_PI; const float fullAngle = 2.0f * M_PI;
const float dashAngle = fullAngle / dashCount * 0.5f; const float dashAngle = fullAngle / dashCount * 0.5f;
const float gapAngle = fullAngle / dashCount * 0.5f; const float gapAngle = fullAngle / dashCount * 0.5f;
float angle = 0.0f; float angle = 0.0f;
for (int i = 0; i < dashCount; ++i) { for (int i = 0; i < dashCount; ++i) {
painter->beginPath(); painter->beginPath();
painter->arc(point, radius, angle, angle + dashAngle, painter->arc(
QCanvasPainter::PathWinding::ClockWise, point,
QCanvasPainter::PathConnection::NotConnected); radius,
painter->stroke(); angle,
angle += dashAngle + gapAngle; angle + dashAngle,
} QCanvasPainter::PathWinding::ClockWise,
} else { QCanvasPainter::PathConnection::NotConnected);
painter->beginPath(); painter->stroke();
painter->circle(point, radius); angle += dashAngle + gapAngle;
painter->stroke(); }
} } else {
}; painter->beginPath();
painter->circle(point, radius);
painter->stroke();
}
};
auto drawCrosshair = [&](const QColor &color, float width) { auto drawCrosshair = [&](const QColor& color, qreal width) {
painter->setStrokeStyle(color); painter->setStrokeStyle(color);
painter->setLineWidth(width); painter->setLineWidth(width);
painter->setLineCap(QCanvasPainter::LineCap::Round); painter->setLineCap(QCanvasPainter::LineCap::Round);
const float inner = radius + 3.0f; const float inner = radius + 3.0f;
const float outer = radius + 3.0f + crosshairSize; const float outer = radius + 3.0f + crosshairSize;
painter->beginPath(); painter->beginPath();
painter->moveTo(point + QPointF(0, -outer)); painter->moveTo(point + QPointF(0, -outer));
painter->lineTo(point + QPointF(0, -inner)); painter->lineTo(point + QPointF(0, -inner));
painter->moveTo(point + QPointF(0, outer)); painter->moveTo(point + QPointF(0, outer));
painter->lineTo(point + QPointF(0, inner)); painter->lineTo(point + QPointF(0, inner));
painter->moveTo(point + QPointF(-outer, 0)); painter->moveTo(point + QPointF(-outer, 0));
painter->lineTo(point + QPointF(-inner, 0)); painter->lineTo(point + QPointF(-inner, 0));
painter->moveTo(point + QPointF( outer, 0)); painter->moveTo(point + QPointF(outer, 0));
painter->lineTo(point + QPointF( inner, 0)); painter->lineTo(point + QPointF(inner, 0));
painter->stroke(); painter->stroke();
}; };
drawOutline(QColor(0, 0, 0, 160), lineWidth + 1.0f); drawOutline(QColor(0, 0, 0, 160), lineWidth + 1.0f);
drawCrosshair(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); drawCrosshair(QColor(255, 255, 255, 220), lineWidth);
} }
void StrokeCanvasRenderer::synchronizeData(QCanvasPainterItem *item) { void StrokeCanvasRenderer::synchronizeData(QCanvasPainterItem* item) {
auto *canvas = static_cast<StrokeCanvasItem *>(item); auto* canvas = static_cast<StrokeCanvasItem*>(item);
m_penColor = canvas->m_penColor; m_penColor = canvas->m_penColor;
m_penWidth = canvas->m_penWidth; m_penWidth = canvas->m_penWidth;
@@ -140,7 +142,7 @@ void StrokeCanvasRenderer::synchronizeData(QCanvasPainterItem *item) {
m_strokes.append(canvas->m_strokes[m_strokes.size()]); m_strokes.append(canvas->m_strokes[m_strokes.size()]);
if (canvas->m_strokes.isEmpty() && !m_strokes.isEmpty()) { if (canvas->m_strokes.isEmpty() && !m_strokes.isEmpty()) {
for (const auto &stroke : m_strokes) for (const auto& stroke : m_strokes)
if (stroke.groupId >= 0) if (stroke.groupId >= 0)
m_pendingGroupRemovals.append(stroke.groupId); m_pendingGroupRemovals.append(stroke.groupId);
m_strokes.clear(); m_strokes.clear();
@@ -153,14 +155,14 @@ void StrokeCanvasRenderer::synchronizeData(QCanvasPainterItem *item) {
m_isDrawing = canvas->m_isDrawing; m_isDrawing = canvas->m_isDrawing;
} }
void StrokeCanvasRenderer::paint(QCanvasPainter *painter) { void StrokeCanvasRenderer::paint(QCanvasPainter* painter) {
for (int id : m_pendingGroupRemovals) for (int id : m_pendingGroupRemovals)
painter->removePathGroup(id); painter->removePathGroup(id);
m_pendingGroupRemovals.clear(); m_pendingGroupRemovals.clear();
painter->clearRect(0, 0, width(), height()); painter->clearRect(0, 0, width(), height());
for (const auto &stroke : m_strokes) { for (const auto& stroke : m_strokes) {
painter->setStrokeStyle(stroke.color); painter->setStrokeStyle(stroke.color);
painter->setFillStyle(stroke.color); painter->setFillStyle(stroke.color);
painter->setLineWidth(stroke.width); 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) 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
Plugins/ZShell/Internal/strokecanvasrenderer.hpp
+13 -15
View File
@@ -7,22 +7,20 @@
namespace ZShell::internal { namespace ZShell::internal {
class StrokeCanvasRenderer final : public QCanvasPainterItemRenderer { class StrokeCanvasRenderer final : public QCanvasPainterItemRenderer {
public:
void synchronizeData(QCanvasPainterItem* item) override;
void paint(QCanvasPainter* painter) override;
public: private:
void synchronizeData(QCanvasPainterItem *item) override; QColor m_penColor;
void paint(QCanvasPainter *painter) override; qreal m_penWidth = 4.0;
bool m_hoverVisible = false;
private: QPointF m_hoverPoint;
QColor m_penColor; bool m_isDrawing = false;
float m_penWidth = 4.f;
bool m_hoverVisible = false;
QPointF m_hoverPoint;
bool m_isDrawing = false;
QVector<Stroke> m_strokes;
Stroke m_currentStroke;
QVector<int> m_pendingGroupRemovals;
QVector<Stroke> m_strokes;
Stroke m_currentStroke;
QVector<int> m_pendingGroupRemovals;
}; };
}; }; // namespace ZShell::internal