clean-up plugin files

Plugins/ZShell/Components/carouselview.cpp

@@ -11,9 +11,9 @@
 namespace ZShell::components {
 
 namespace {
-constexpr qreal kDragThreshold = 4.0;	  // px before a press becomes a drag
-constexpr qreal kFlickFriction = 0.0022;  // px/ms^2 deceleration
-constexpr qreal kMinFlickVelocity = 60.0; // px/sec below which we just snap
+constexpr qreal kDragThreshold = 4.0;
+constexpr qreal kFlickFriction = 0.0022;
+constexpr qreal kMinFlickVelocity = 60.0;
 constexpr qreal kMaxFlickVelocity = 6000.0;
 } // namespace
 
@@ -59,8 +59,6 @@ CarouselView::~CarouselView() {
 	releaseAllItems();
 }
 
-// ---------------------------------------------------------------- properties
-
 void CarouselView::setDelegate(QQmlComponent* c) {
 	if (m_delegate == c) return;
 	m_delegate = c;
@@ -73,7 +71,6 @@ void CarouselView::setModel(const QVariantList& m) {
 	m_model = m;
 	emit modelChanged();
 
-	// Re-anchor on the currently selected path if possible, otherwise clamp.
 	int newCount = m_model.size();
 	if (newCount == 0) {
 		m_currentRealIndex = -1;
@@ -93,9 +90,6 @@ void CarouselView::setModel(const QVariantList& m) {
 		return;
 	}
 
-	// Model contents changed under us (e.g. search text filtered the list).
-	// Re-anchor instantly on the clamped selection -- no glide, since this
-	// isn't a user-initiated navigation.
 	rebuildArrangement();
 	centerInstantlyOnReal(qBound(0, m_currentRealIndex, newCount - 1));
 }
@@ -173,16 +167,10 @@ void CarouselView::setCurrentIndex(int idx) {
 	goToIndex(idx);
 }
 
-// ---------------------------------------------------------------- geometry
-
 void CarouselView::geometryChange(const QRectF& newGeo, const QRectF& oldGeo) {
 	QQuickItem::geometryChange(newGeo, oldGeo);
 	if (!qFuzzyCompare(newGeo.width(), oldGeo.width()) ||
 		!qFuzzyCompare(newGeo.height(), oldGeo.height())) {
-		// Recentre on the same virtual index rather than letting contentX
-		// drift, exactly like the QML version's onWidthChanged handler --
-		// but here it happens in the same pass as the arrangement rebuild,
-		// so x/width for every slot are recomputed together.
 		rebuildArrangement();
 		if (m_initializedLayout)
 			m_contentX = contentXForIndex(m_currentVirtualIndex);
@@ -190,22 +178,10 @@ void CarouselView::geometryChange(const QRectF& newGeo, const QRectF& oldGeo) {
 	}
 }
 
-// ---------------------------------------------------------------- arrangement math
-// Direct port of the QML `arrangement` computed property + keylineCenter/
-// keylineSize/sampleCenter/sampleSize helpers. Kept numerically identical on
-// purpose so behaviour doesn't change, just *when* it's applied.
-
 void CarouselView::rebuildArrangement() {
 	Arrangement& a = m_arrangement;
 	a = Arrangement{};
 
-	// IMPORTANT: this must be the external constraint (m_maxWidth), never
-	// width() -- width() is a *result* of this computation (see below), and
-	// using it here would make the arrangement depend on its own previous
-	// output. On first layout, before width() has ever been set, that
-	// bootstraps to W==0 -> n==0 -> every side item falls back to a flat
-	// minEdgeWidth with no taper at all, which is what caused items to slide
-	// off looking "pushed out" instead of shrinking.
 	const qreal W = m_maxWidth;
 	const qreal F = m_focalWidth;
 	const qreal M = m_minEdgeWidth;
@@ -239,8 +215,6 @@ void CarouselView::rebuildArrangement() {
 		bestSizes = sizes;
 		bestWidth = requiredWidth;
 
-		// Safety valve: arrangement size is bounded by how many halvings fit,
-		// this just guards against pathological inputs (F <= M etc).
 		if (n > 64) break;
 	}
 
@@ -262,10 +236,6 @@ void CarouselView::rebuildArrangement() {
 	a.effectiveExtraWidth = extra;
 
 	setImplicitWidth(m_maxWidth);
-	// This mirrors the original `width: arrangement.width` binding. It's
-	// safe against feedback because the arrangement above only ever reads
-	// m_maxWidth, never width() -- so if a.width doesn't change, setWidth()
-	// here is a no-op and geometryChange() won't recurse.
 	setWidth(a.width);
 }
 
@@ -331,8 +301,6 @@ qreal CarouselView::sampleSize(qreal childLoc) const {
 	return keylineSize(a) + (keylineSize(b) - keylineSize(a)) * t;
 }
 
-// ---------------------------------------------------------------- index math
-
 int CarouselView::realIndexOf(int virtualIndex) const {
 	const int count = m_model.size();
 	if (count == 0) return -1;
@@ -373,8 +341,6 @@ void CarouselView::wrapContentIfNeeded() {
 			const qreal newEnd = m_flickAnim->endValue().toReal() - shift;
 			m_flickAnim->setEndValue(newEnd);
 		}
-		// Also shift every currently-live slot's virtual index bookkeeping so
-		// it doesn't think it needs to be recycled just because of the wrap.
 		const int indexShift = static_cast<int>(std::round(shift / pitch()));
 		for (Slot& s : m_slots) {
 			if (s.active) s.virtualIndex -= indexShift;
@@ -404,8 +370,6 @@ void CarouselView::updateCurrentIndexFromContentX(bool emitPreview) {
 	}
 }
 
-// ---------------------------------------------------------------- pool / delegates
-
 QQuickItem* CarouselView::acquireItem() {
 	if (!m_delegate) return nullptr;
 
@@ -479,8 +443,6 @@ void CarouselView::positionSlot(const Slot& slot) const {
 	const qreal center = sampleCenter(childLoc);
 	const qreal size = sampleSize(childLoc);
 
-	// slot's "column" spans one pitch, centred at width()/2 + center; item is
-	// centred within that column, matching the QML delegate's x expression.
 	const qreal slotX = childLoc + width() / 2.0 - pitch() / 2.0;
 	const qreal itemX = (center - childLoc) + (pitch() - size) / 2.0 + slotX;
 
@@ -497,8 +459,6 @@ void CarouselView::releaseAllItems() {
 	m_slots.clear();
 }
 
-// ---------------------------------------------------------------- layout pass
-
 void CarouselView::relayout() {
 	const int count = m_model.size();
 	if (count == 0 || width() <= 0 || m_focalWidth <= 0) {
@@ -508,20 +468,15 @@ void CarouselView::relayout() {
 	}
 
 	const int n = m_arrangement.n;
-	// Window of virtual indices that can ever be visible, plus a small buffer
-	// so items don't pop in/out right at the edge during a fast flick.
 	const int half = n + 3;
 	const int lo = m_currentVirtualIndex - half;
 	const int hi = m_currentVirtualIndex + half;
 	const int needed = hi - lo + 1;
 
-	// Grow the pool if needed (shrinking is unnecessary: idle items are just
-	// marked inactive/invisible, which is cheap and avoids churn).
 	while (m_slots.size() < needed)
 		m_slots.append(Slot{});
 
-	// Figure out which virtual indices are already backed by a slot.
-	QHash<int, int> virtualToSlot; // virtualIndex -> slot list position
+	QHash<int, int> virtualToSlot;
 	virtualToSlot.reserve(m_slots.size());
 	for (int i = 0; i < m_slots.size(); ++i) {
 		if (m_slots[i].active) virtualToSlot.insert(m_slots[i].virtualIndex, i);
@@ -533,15 +488,11 @@ void CarouselView::relayout() {
 		auto it = virtualToSlot.find(v);
 		if (it != virtualToSlot.end()) {
 			slotUsedThisPass[it.value()] = true;
-			// Content (isCurrent / modelData) may still need refreshing if
-			// currentRealIndex changed since last pass.
 			applyPropertiesToItem(
 				m_slots[it.value()].item, m_slots[it.value()].realIndex);
 			continue;
 		}
 
-		// find a free slot: one not used this pass and not already at a
-		// virtual index inside [lo, hi] (those are all still needed).
 		int freeSlot = -1;
 		for (int i = 0; i < m_slots.size(); ++i) {
 			if (slotUsedThisPass[i]) continue;
@@ -552,7 +503,6 @@ void CarouselView::relayout() {
 			break;
 		}
 		if (freeSlot < 0) {
-			// Shouldn't happen given the pool growth above, but guard anyway.
 			m_slots.append(Slot{});
 			slotUsedThisPass.append(false);
 			freeSlot = m_slots.size() - 1;
@@ -573,8 +523,6 @@ void CarouselView::relayout() {
 		positionSlot(s);
 }
 
-// ---------------------------------------------------------------- animation
-
 void CarouselView::cancelAnimations() {
 	if (m_glideAnim->state() == QAbstractAnimation::Running)
 		m_glideAnim->stop();
@@ -596,8 +544,6 @@ void CarouselView::snapToNearest() {
 	glideTo(snapTargetX(m_contentX));
 }
 
-// ---------------------------------------------------------------- public API
-
 void CarouselView::goToIndex(int realIndex) {
 	const int count = m_model.size();
 	if (count == 0) return;
@@ -659,19 +605,10 @@ void CarouselView::centerInstantlyOnReal(int realIndex) {
 	relayout();
 }
 
-// ---------------------------------------------------------------- input
-
 void CarouselView::mousePressEvent(QMouseEvent* event) {
-	// Deliberately do NOT cancel animations here. A press that turns out to
-	// be a plain tap (never crosses the drag threshold) should leave any
-	// in-flight glide/flick completely untouched. We only touch the
-	// animation once we know it's actually a drag (see mouseMoveEvent).
 	m_dragging = true;
 	m_dragActive = false;
 	m_pressPos = event->position();
-	// Capture wherever contentX currently is, even mid-animation -- if this
-	// does turn into a drag, it should pick up smoothly from the visual
-	// position, not teleport to some rest position first.
 	m_pressContentX = m_contentX;
 	m_dragTimer.start();
 	m_lastMoveX = event->position().x();
@@ -686,8 +623,7 @@ void CarouselView::mouseMoveEvent(QMouseEvent* event) {
 	const qreal dx = event->position().x() - m_pressPos.x();
 	if (!m_dragActive && std::abs(dx) > kDragThreshold) {
 		m_dragActive = true;
-		m_pressContentX =
-			m_contentX; // re-anchor to the live (possibly mid-animation) value
+		m_pressContentX = m_contentX;
 		cancelAnimations();
 		grabMouse();
 	}
@@ -703,7 +639,6 @@ void CarouselView::mouseMoveEvent(QMouseEvent* event) {
 	if (dt > 0) {
 		const qreal instVel =
 			(m_lastMoveX - event->position().x()) / (dt / 1000.0);
-		// Light smoothing so a single jittery sample doesn't dominate the flick.
 		m_velocity = m_velocity * 0.7 + instVel * 0.3;
 	}
 	m_lastMoveX = event->position().x();
@@ -718,8 +653,6 @@ void CarouselView::mouseReleaseEvent(QMouseEvent* event) {
 	ungrabMouse();
 
 	if (!m_dragActive) {
-		// A plain click/tap with no drag: let it fall through to the
-		// delegate's own StateLayer/MouseArea via requestActivate().
 		event->accept();
 		return;
 	}
@@ -732,10 +665,8 @@ void CarouselView::mouseReleaseEvent(QMouseEvent* event) {
 		return;
 	}
 
-	// Simple constant-deceleration flick: distance = v^2 / (2*friction).
 	const qreal duration = std::abs(v) / (kFlickFriction * 1000.0); // ms
-	const qreal distance =
-		(v * (duration / 1000.0)) / 2.0; // average-velocity approximation
+	const qreal distance = (v * (duration / 1000.0)) / 2.0;
 	const qreal rawDest = m_contentX + distance;
 	const qreal dest = snapTargetX(rawDest);
 
@@ -764,8 +695,6 @@ void CarouselView::wheelEvent(QWheelEvent* event) {
 	event->accept();
 }
 
-// ---------------------------------------------------------------- delegate signal
-
 void CarouselView::handleDelegateActivate() {
 	QQuickItem* item = qobject_cast<QQuickItem*>(sender());
 	if (!item) return;