v2.54.1 — Queue zeigt echte Wiedergabe-Reihenfolge (inkl. Shuffle), aktuelles Lied markiert

2026-08-05 12:20:32 +02:00
parent 8b6f0925a6
commit 5f7b652eb6
5 changed files with 333 additions and 33 deletions
@@ -341,6 +341,68 @@ class PlayerService extends ChangeNotifier {
  /// Index des aktuell spielenden Songs in der Warteschlange.
  int get aktuellerIndex => _aktuellerIndex;

+  /// Die tatsächliche Wiedergabe-Reihenfolge — beginnend mit dem aktuell
+  /// spielenden Song (Position 0). NICHT die Bibliotheks-Reihenfolge:
+  /// - Normal: Warteschlange ab dem aktuellen Index
+  /// - Shuffle: aktuelle Shuffle-Position + Rest der Zufallsreihenfolge
+  List<Song> get wiedergabeReihenfolge {
+    final ergebnis = <Song>[];
+    if (_warteschlange.isEmpty) return List.unmodifiable(ergebnis);
+    if (_aktuellerIndex >= 0 && _aktuellerIndex < _warteschlange.length) {
+      ergebnis.add(_warteschlange[_aktuellerIndex]);
+    }
+    if (_zufallsmodus) {
+      if (_shuffleReihenfolge.isNotEmpty) {
+        // _shufflePos == -1 → Shuffle gerade eingeschaltet, aktueller Song
+        // ist noch nicht in der Reihenfolge → ab Position 0 auflisten
+        final start = _shufflePos >= 0 ? _shufflePos + 1 : 0;
+        for (var i = start; i < _shuffleReihenfolge.length; i++) {
+          final idx = _shuffleReihenfolge[i];
+          if (idx >= 0 && idx < _warteschlange.length) {
+            ergebnis.add(_warteschlange[idx]);
+          }
+        }
+      }
+    } else {
+      for (var i = _aktuellerIndex + 1; i < _warteschlange.length; i++) {
+        ergebnis.add(_warteschlange[i]);
+      }
+    }
+    return List.unmodifiable(ergebnis);
+  }
+
+  /// Verschiebt einen Eintrag in der tatsächlichen Wiedergabe-Reihenfolge
+  /// (Drag-and-Drop im Queue-Sheet). Position 0 = aktuell spielender Song
+  /// (bleibt oben und kann nicht verschoben werden).
+  /// - Normal: verschiebt in der Warteschlange (ab dem aktuellen Index)
+  /// - Shuffle: verschiebt in der Zufallsreihenfolge — das ändert die echte
+  ///   Abspiel-Reihenfolge, ohne die Bibliotheks-Liste anzufassen
+  void verschiebeInWiedergabeReihenfolge(int von, int nach) {
+    if (von <= 0) return; // aktueller Song bleibt an Position 0
+    if (nach <= 0) nach = 1; // nie vor den aktuellen Song
+    if (von == nach) return;
+    if (_warteschlange.isEmpty) return;
+
+    if (_zufallsmodus) {
+      final start = _shufflePos >= 0 ? _shufflePos + 1 : 0;
+      final vonShuffle = start + von - 1;
+      final nachShuffle = start + nach - 1;
+      if (vonShuffle < 0 || vonShuffle >= _shuffleReihenfolge.length) return;
+      final item = _shuffleReihenfolge.removeAt(vonShuffle);
+      final ziel = nachShuffle > _shuffleReihenfolge.length
+          ? _shuffleReihenfolge.length
+          : nachShuffle;
+      _shuffleReihenfolge.insert(ziel, item);
+      notifyListeners();
+      return;
+    }
+
+    final vonQueue = _aktuellerIndex + von;
+    final nachQueue = _aktuellerIndex + nach;
+    if (vonQueue < 0 || vonQueue >= _warteschlange.length) return;
+    verschiebeInWarteschlange(vonQueue, nachQueue);
+  }
+
  /// Setzt [song] als nächstes auf die Wiedergabe — direkt nach dem aktuellen
  /// Song. Ist der Song bereits in der Warteschlange, wird er dorthin VERSCHOBEN
  /// statt dupliziert. Im Shuffle wird die Reihenfolge nicht neu gemischt: