feat: dashboard show on hover, media and weather tabs added

Plugins/ZShell/Internal/sparklineitem.cpp

@@ -1,9 +1,11 @@
 #include "sparklineitem.hpp"
 
 #include <qmath.h>
+#include <qnumeric.h>
 #include <qpainter.h>
 #include <qpainterpath.h>
 #include <qpen.h>
+#include <qtypes.h>
 
 namespace ZShell::internal {
 
@@ -35,9 +37,19 @@ void SparklineItem::drawLine(
 	const int len = buffer->count();
 	if (len < 2 || m_maxValue <= 0.0) return;
 
-	const qreal stepX = w / static_cast<qreal>(m_historyLength - 1);
-	const qreal startX =
-		w - (len - 1) * stepX - stepX * m_slideProgress + stepX;
+	qreal stepX = 0.0;
+
+	if (m_sliding)
+		stepX = w / static_cast<qreal>(m_historyLength - 1);
+	else
+		stepX = w / static_cast<qreal>(len - 1);
+
+	qreal startX = 0.0;
+
+	if (m_sliding)
+		startX = w - (len - 1) * stepX - stepX * m_slideProgress + stepX;
+	else
+		startX = 0;
 
 	const qreal strokePad = qCeil(m_lineWidth / 2);
 	const qreal curvePad = 3.0;
@@ -52,24 +64,75 @@ void SparklineItem::drawLine(
 	points.reserve(len);
 
 	for (int i = 0; i < len; ++i) {
+		qreal value = 0.0;
+
+		if (m_smoothing > 0.0) {
+			const int radius = qRound(m_smoothing);
+			qreal sum = 0.0;
+			int count = 0;
+
+			for (int j = -radius; j <= radius; ++j) {
+				const int index = i + j;
+
+				if (index < 0 || index >= len) continue;
+
+				sum += buffer->at(index);
+				count++;
+			}
+
+			value = sum / static_cast<qreal>(count);
+		} else {
+			value = buffer->at(i);
+		}
+
+		value = qBound<qreal>(0.0, value, m_maxValue);
+
 		const qreal x = startX + i * stepX;
-		const qreal value = qBound<qreal>(0.0, buffer->at(i), m_maxValue);
 		const qreal y = plotTop + (1.0 - (value / m_maxValue)) * plotH;
+
 		points.append(QPointF(x, y));
 	}
 
 	QPainterPath linePath;
 	linePath.moveTo(points[0]);
 
-	for (int i = 0; i < points.size() - 1; ++i) {
-		const QPointF& p0 = points[i];
-		const QPointF& p1 = points[i + 1];
+	if (m_curveSmoothing && points.size() > 2) {
+		// 1.0 = standard uniform Catmull-Rom. Lower (e.g. 0.5) = tighter, less overshoot.
+		const qreal tension = 1.0;
+		const qreal k =
+			tension / 6.0; // Catmull-Rom -> Bezier factor (1/6 for uniform)
 
-		const qreal ctrlX = (p0.x() + p1.x()) * 0.5;
-		const QPointF c1(ctrlX, p0.y());
-		const QPointF c2(ctrlX, p1.y());
+		const int n = points.size();
 
-		linePath.cubicTo(c1, c2, p1);
+		for (int i = 0; i < n - 1; ++i) {
+			// Duplicate endpoints so the first/last segments are well-defined
+			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, n - 1)];
+
+			QPointF c1 = p1 + (p2 - p0) * k;
+			QPointF c2 = p2 - (p3 - p1) * k;
+
+			// Keep control points inside the vertical range of the segment's
+			// endpoints so we never overshoot (no dips below zero, no
+			// bulges above a peak). Remember: smaller y = higher value.
+			const qreal segMinY = qMin(p1.y(), p2.y());
+			const qreal segMaxY = qMax(p1.y(), p2.y());
+			c1.setY(qBound(segMinY, c1.y(), segMaxY));
+			c2.setY(qBound(segMinY, c2.y(), segMaxY));
+
+			linePath.cubicTo(c1, c2, p2);
+		}
+	} else {
+		// Existing horizontal-tangent (smoothstep-style) curve
+		for (int i = 0; i < points.size() - 1; ++i) {
+			const QPointF& p0 = points[i];
+			const QPointF& p1 = points[i + 1];
+
+			const qreal ctrlX = (p0.x() + p1.x()) * 0.5;
+			linePath.cubicTo(QPointF(ctrlX, p0.y()), QPointF(ctrlX, p1.y()), p1);
+		}
 	}
 
 	QPen pen(color, m_lineWidth);
@@ -224,4 +287,36 @@ void SparklineItem::setLineWidth(qreal width) {
 	update();
 }
 
+void SparklineItem::setSliding(bool sliding) {
+	if (m_sliding == sliding) return;
+	m_sliding = sliding;
+	emit slidingChanged();
+}
+
+bool SparklineItem::sliding() const {
+	return m_sliding;
+};
+
+void SparklineItem::setSmoothing(qreal smoothing) {
+	smoothing = qMax<qreal>(0.0, smoothing);
+
+	if (qFuzzyCompare(m_smoothing, smoothing)) return;
+	m_smoothing = smoothing;
+	emit smoothingChanged();
+}
+
+qreal SparklineItem::smoothing() const {
+	return m_smoothing;
+};
+
+void SparklineItem::setCurveSmoothing(bool sliding) {
+	if (m_curveSmoothing == sliding) return;
+	m_curveSmoothing = sliding;
+	emit curveSmoothingChanged();
+}
+
+bool SparklineItem::curveSmoothing() const {
+	return m_curveSmoothing;
+};
+
 } // namespace ZShell::internal

Plugins/ZShell/Internal/sparklineitem.hpp

@@ -4,6 +4,7 @@
 #include <qobject.h>
 #include <qqmlintegration.h>
 #include <qquickpainteditem.h>
+#include <qtmetamacros.h>
 
 #include "circularbuffer.hpp"
 
@@ -40,6 +41,13 @@ class SparklineItem : public QQuickPaintedItem {
 	Q_PROPERTY(
 		qreal lineWidth READ lineWidth WRITE setLineWidth NOTIFY
 			lineWidthChanged)
+	Q_PROPERTY(bool sliding READ sliding WRITE setSliding NOTIFY slidingChanged)
+	Q_PROPERTY(
+		qreal smoothing READ smoothing WRITE setSmoothing NOTIFY
+			smoothingChanged)
+	Q_PROPERTY(
+		bool curveSmoothing READ curveSmoothing WRITE setCurveSmoothing NOTIFY
+			curveSmoothingChanged)
 
 	public:
 	explicit SparklineItem(QQuickItem* parent = nullptr);
@@ -76,6 +84,15 @@ class SparklineItem : public QQuickPaintedItem {
 	[[nodiscard]] qreal lineWidth() const;
 	void setLineWidth(qreal width);
 
+	[[nodiscard]] bool sliding() const;
+	void setSliding(bool sliding);
+
+	[[nodiscard]] qreal smoothing() const;
+	void setSmoothing(qreal smoothing);
+
+	[[nodiscard]] bool curveSmoothing() const;
+	void setCurveSmoothing(bool curveSmoothing);
+
 	signals:
 	void line1Changed();
 	void line2Changed();
@@ -87,6 +104,9 @@ class SparklineItem : public QQuickPaintedItem {
 	void slideProgressChanged();
 	void historyLengthChanged();
 	void lineWidthChanged();
+	void slidingChanged();
+	void smoothingChanged();
+	void curveSmoothingChanged();
 
 	private:
 	void drawLine(
@@ -106,6 +126,9 @@ class SparklineItem : public QQuickPaintedItem {
 	qreal m_slideProgress = 0.0;
 	int m_historyLength = 30;
 	qreal m_lineWidth = 2.0;
+	bool m_sliding = true;
+	qreal m_smoothing = 0.0;
+	bool m_curveSmoothing = false;
 };
 
 } // namespace ZShell::internal