Merge pull request #143 from kevlatus/indefinite-spin-13212144778224149486

kevlatus · web-flow · commit aaf52ad560d0 · 2026-01-10T18:38:43.000+01:00
Support indefinite spinning and smooth stop at target
diff --git a/example/lib/pages/bar.dart b/example/lib/pages/bar.dart
@@ -1,3 +1,4 @@
+import 'dart:async';
 import 'package:flutter/material.dart';
 import 'package:flutter_fortune_wheel/flutter_fortune_wheel.dart';
 import 'package:flutter_hooks/flutter_hooks.dart';
@@ -18,16 +19,35 @@ class FortuneBarPage extends HookWidget {
     final selected = useStreamController<int>();
     final selectedIndex = useStream(selected.stream, initialData: 0).data ?? 0;
     final isAnimating = useState(false);
+    final isIndefinite = useState(false);
 
     void handleRoll() {
-      selected.add(
-        roll(Constants.fortuneValues.length),
-      );
+      if (isIndefinite.value) {
+        selected.add(Fortune.indefinite);
+        Future.delayed(const Duration(seconds: 2), () {
+          selected.add(roll(Constants.fortuneValues.length));
+        });
+      } else {
+        selected.add(
+          roll(Constants.fortuneValues.length),
+        );
+      }
     }
 
     return AppLayout(
       child: Column(
         children: [
+          SizedBox(height: 8),
+          Row(
+            mainAxisAlignment: MainAxisAlignment.center,
+            children: [
+              Text('Indefinite wait'),
+              Switch(
+                value: isIndefinite.value,
+                onChanged: (v) => isIndefinite.value = v,
+              ),
+            ],
+          ),
           SizedBox(height: 8),
           RollButtonWithPreview(
             selected: selectedIndex,
diff --git a/example/lib/pages/wheel.dart b/example/lib/pages/wheel.dart
@@ -1,3 +1,4 @@
+import 'dart:async';
 import 'package:flutter/material.dart';
 import 'package:flutter_fortune_wheel/flutter_fortune_wheel.dart';
 import 'package:flutter_hooks/flutter_hooks.dart';
@@ -19,16 +20,25 @@ class FortuneWheelPage extends HookWidget {
     final selected = useStreamController<int>();
     final selectedIndex = useStream(selected.stream, initialData: 0).data ?? 0;
     final isAnimating = useState(false);
+    final isIndefinite = useState(false);
 
     final alignmentSelector = AlignmentSelector(
       selected: alignment.value,
       onChanged: (v) => alignment.value = v!,
     );
 
     void handleRoll() {
-      selected.add(
-        roll(Constants.fortuneValues.length),
-      );
+      if (isIndefinite.value) {
+        // Indefinite mode: start spinning, then stop after delay
+        selected.add(Fortune.indefinite);
+        Future.delayed(const Duration(seconds: 2), () {
+          selected.add(roll(Constants.fortuneValues.length));
+        });
+      } else {
+        selected.add(
+          roll(Constants.fortuneValues.length),
+        );
+      }
     }
 
     return AppLayout(
@@ -38,6 +48,17 @@ class FortuneWheelPage extends HookWidget {
           children: [
             alignmentSelector,
             SizedBox(height: 8),
+            Row(
+              mainAxisAlignment: MainAxisAlignment.center,
+              children: [
+                Text('Indefinite wait'),
+                Switch(
+                  value: isIndefinite.value,
+                  onChanged: (v) => isIndefinite.value = v,
+                ),
+              ],
+            ),
+            SizedBox(height: 8),
             RollButtonWithPreview(
               selected: selectedIndex,
               items: Constants.fortuneValues,
diff --git a/lib/src/bar/fortune_bar.dart b/lib/src/bar/fortune_bar.dart
@@ -105,6 +105,8 @@ class FortuneBar extends StatefulWidget implements FortuneWidget {
 class _FortuneBarState extends State<FortuneBar>
     with SingleTickerProviderStateMixin {
   late FortuneAnimationManager _animationManager;
+  double _scrollWeightOffset = 0;
+  int _previousIndex = 0;
 
   @override
   void initState() {
@@ -118,15 +120,58 @@ class _FortuneBarState extends State<FortuneBar>
       onAnimationEnd: () => widget.onAnimationEnd?.call(),
     );
 
+    _animationManager.selectedIndex.addListener(_handleSelectionChange);
+
     if (widget.animateFirst) {
       WidgetsBinding.instance!.addPostFrameCallback((_) {
         _animationManager.animate();
       });
     }
   }
 
+  void _handleSelectionChange() {
+    final oldIndex = _previousIndex;
+    final newIndex = _animationManager.selectedIndex.value;
+
+    final currentRotation = _animationManager.animation.value;
+    final totalWeight = _getTotalWeight();
+
+    final oldTarget = _getItemCenterWeight(oldIndex);
+    final oldTotalWeight = widget.rotationCount * totalWeight + oldTarget;
+
+    // Use previous interpolation logic to reconstruct where we are.
+    // oldScrollWeight = _scrollWeightOffset * (1 - t) + t * oldTotalWeight
+
+    final oldScrollWeight = _scrollWeightOffset * (1 - currentRotation) + currentRotation * oldTotalWeight;
+
+    final newTarget = _getItemCenterWeight(newIndex);
+    // newTotalWeight = widget.rotationCount * totalWeight + newTarget;
+    // newScrollWeight(0) = _newOffset * (1-0) + 0 * ... = _newOffset.
+
+    // We want oldScrollWeight = newScrollWeight(0) = _newOffset.
+
+    _scrollWeightOffset = oldScrollWeight;
+    _previousIndex = newIndex;
+  }
+
+  double _getTotalWeight() {
+     return widget.items.fold<double>(0, (p, e) => p + e.weight);
+  }
+
+  double _getItemCenterWeight(int index) {
+      if (index < 0 || index >= widget.items.length) return 0;
+
+      double targetCenterWeight = 0;
+      for (int i = 0; i < index; i++) {
+        targetCenterWeight += widget.items[i].weight;
+      }
+      targetCenterWeight += widget.items[index].weight / 2;
+      return targetCenterWeight;
+  }
+
   @override
   void dispose() {
+    _animationManager.selectedIndex.removeListener(_handleSelectionChange);
     _animationManager.dispose();
     super.dispose();
   }
@@ -164,8 +209,7 @@ class _FortuneBarState extends State<FortuneBar>
             );
 
             // Calculate weights and dimensions
-            final totalWeight =
-                widget.items.fold<double>(0, (p, e) => p + e.weight);
+            final totalWeight = _getTotalWeight();
             final avgWeight = totalWeight / widget.items.length;
             final visibleWeight = widget.visibleItemCount * avgWeight;
             final unitWidth = size.width / visibleWeight;
@@ -179,11 +223,7 @@ class _FortuneBarState extends State<FortuneBar>
               builder: (context, _) {
                 // Calculate Target
                 final selectedIndex = _animationManager.selectedIndex.value;
-                double targetCenterWeight = 0;
-                for (int i = 0; i < selectedIndex; i++) {
-                  targetCenterWeight += widget.items[i].weight;
-                }
-                targetCenterWeight += widget.items[selectedIndex].weight / 2;
+                final targetCenterWeight = _getItemCenterWeight(selectedIndex);
 
                 final targetTotalScrollWeight =
                     widget.rotationCount * totalWeight + targetCenterWeight;
@@ -198,8 +238,11 @@ class _FortuneBarState extends State<FortuneBar>
                 final isAnimatingPanFactor = isAnimating ? 0 : 1;
 
                 // Current Scroll Weight
-                final currentScrollWeight = _animationManager.animation.value *
-                        targetTotalScrollWeight +
+                // Logic: _scrollWeightOffset * (1 - t) + t * targetTotalScrollWeight
+
+                final animationValue = _animationManager.animation.value;
+                final currentScrollWeight = _scrollWeightOffset * (1 - animationValue) +
+                        animationValue * targetTotalScrollWeight +
                     panWeight * isAnimatingPanFactor;
 
                 final scrollOffset = currentScrollWeight * unitWidth;
diff --git a/lib/src/core/animations.dart b/lib/src/core/animations.dart
@@ -60,7 +60,11 @@ class FortuneAnimationManager {
 
     await Future.microtask(() => onAnimationStart?.call());
     try {
-      await controller.forward(from: 0);
+      if (selectedIndex.value == Fortune.indefinite) {
+        await controller.repeat();
+      } else {
+        await controller.forward(from: 0);
+      }
     } catch (e) {
       // Controller might be disposed
       return;
diff --git a/lib/src/core/random.dart b/lib/src/core/random.dart
@@ -4,6 +4,9 @@ part of 'core.dart';
 
 /// Static methods for common tasks when working with [FortuneWidget]s.
 abstract class Fortune {
+  /// The value to use to indicate that the fortune wheel should spin indefinitely.
+  static const int indefinite = -1;
+
   /// Generates a random integer uniformly distributed in the range
   /// from [min], inclusive, to [max], exclusive.
   ///
diff --git a/lib/src/wheel/fortune_wheel.dart b/lib/src/wheel/fortune_wheel.dart
@@ -205,6 +205,8 @@ class _FortuneWheelState extends State<FortuneWheel>
   late AnimationController _arrowController;
   late Animation<double> _arrowAnimation;
   double _lastVibratedAngle = 0;
+  double _rotationOffset = 0;
+  int _previousIndex = 0;
 
   @override
   void initState() {
@@ -232,13 +234,52 @@ class _FortuneWheelState extends State<FortuneWheel>
       onAnimationEnd: () => widget.onAnimationEnd?.call(),
     );
 
+    _animationManager.selectedIndex.addListener(_handleSelectionChange);
+
     if (widget.animateFirst) {
       WidgetsBinding.instance!.addPostFrameCallback((_) {
         _animationManager.animate();
       });
     }
   }
 
+  void _handleSelectionChange() {
+    final oldIndex = _previousIndex;
+    final newIndex = _animationManager.selectedIndex.value;
+
+    final currentRotation = _animationManager.animation.value;
+    final oldSelectedAngle = _getAngleForIndex(oldIndex);
+
+    // We want to calculate the current actual angle of rotation.
+    // However, build() uses _rotationOffset * (1 - animation.value).
+    // So the previous state calculation is slightly complex.
+    // But conceptually, _rotationOffset decays to 0.
+    // So if the previous animation finished (value=1), the offset is 0.
+    // If it was interrupted (e.g. infinite spin), value might be anything.
+    // But in infinite spin, we likely want to use the standard rotation formula.
+    // Let's assume standard rotation logic applies for extracting "current pos".
+
+    // Wait, if we use the new formula:
+    // rotationAngle = _rotationOffset * (1 - value) + widget._getAngle(value);
+
+    final oldRotationAngle = _rotationOffset * (1 - currentRotation) + widget._getAngle(currentRotation);
+
+    final newSelectedAngle = _getAngleForIndex(newIndex);
+
+    // We want the new animation to start at the same total angle.
+    // newTotalAngle(0) = newSelectedAngle + newRotationAngle(0).
+    // newRotationAngle(0) = _newRotationOffset * (1 - 0) + widget._getAngle(0)
+    //                     = _newRotationOffset.
+
+    // So: oldSelectedAngle + oldRotationAngle = newSelectedAngle + _newRotationOffset.
+    // _newRotationOffset = oldSelectedAngle + oldRotationAngle - newSelectedAngle.
+
+    final oldTotal = oldSelectedAngle + oldRotationAngle;
+    _rotationOffset = oldTotal - newSelectedAngle;
+
+    _previousIndex = newIndex;
+  }
+
   void _arrowStatusListener(AnimationStatus status) {
     if (status == AnimationStatus.completed) {
       _arrowController.reverse();
@@ -254,6 +295,7 @@ class _FortuneWheelState extends State<FortuneWheel>
 
   @override
   void dispose() {
+    _animationManager.selectedIndex.removeListener(_handleSelectionChange);
     _arrowController.removeStatusListener(_arrowStatusListener);
     _arrowController.dispose();
     _animationManager.dispose();
@@ -275,6 +317,10 @@ class _FortuneWheelState extends State<FortuneWheel>
   }
 
   double _getAngleForIndex(int index) {
+    if (index < 0 || index >= widget.items.length) {
+      return 0;
+    }
+
     final items = widget.items;
     final totalWeight = items.fold<double>(0, (prev, element) => prev + element.weight);
 
@@ -326,8 +372,13 @@ class _FortuneWheelState extends State<FortuneWheel>
 
                   final panAngle =
                       panState.distance * panFactor * isAnimatingPanFactor;
-                  final rotationAngle =
-                      widget._getAngle(_animationManager.animation.value);
+
+                  // Use the interpolation logic:
+                  // rotationAngle = _rotationOffset * (1 - t) + standardRotation(t).
+                  final animationValue = _animationManager.animation.value;
+                  final rotationAngle = _rotationOffset * (1 - animationValue) +
+                      widget._getAngle(animationValue);
+
                   final alignmentOffset =
                       _calculateAlignmentOffset(widget.alignment);
                   final totalAngle = selectedAngle + panAngle + rotationAngle;
diff --git a/test/indefinite_test.dart b/test/indefinite_test.dart
@@ -0,0 +1,39 @@
+
+import 'dart:async';
+import 'package:flutter/material.dart';
+import 'package:flutter_fortune_wheel/flutter_fortune_wheel.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+import 'test_helpers.dart';
+
+void main() {
+  group('FortuneWheel Indefinite Spin', () {
+    testWidgets('supports indefinite spin then stop at target', (WidgetTester tester) async {
+      final selected = StreamController<int>();
+
+      await pumpFortuneWidget(tester,
+        FortuneWheel(
+          items: [
+            FortuneItem(child: Text('0')),
+            FortuneItem(child: Text('1')),
+            FortuneItem(child: Text('2')),
+          ],
+          selected: selected.stream,
+        ),
+      );
+
+      // Trigger indefinite spin
+      selected.add(Fortune.indefinite);
+      await tester.pump();
+      await tester.pump(const Duration(seconds: 1));
+
+      // Trigger stop
+      selected.add(1);
+      await tester.pump();
+      await tester.pump(const Duration(seconds: 5)); // Allow time to settle
+
+      // Verify no crashes.
+      // In a real integration test we would verify the visual state, but here we ensure the logic runs.
+    });
+  });
+}
