need to hide the boundaries of the loop, not to remove them

src/notation/inotationplayback.h

@@ -55,8 +55,8 @@ public:
     };
 
     virtual void addLoopBoundary(LoopBoundaryType boundaryType, int tick) = 0;
-    virtual void removeLoopBoundaries() = 0;
-    virtual async::Channel<LoopBoundaries> loopBoundariesChanged() const = 0;
+    virtual void setLoopBoundariesVisible(bool visible) = 0;
+    virtual ValCh<LoopBoundaries> loopBoundaries() const = 0;
 
     virtual Tempo tempo(int tick) const = 0;
     virtual MeasureBeat beat(int tick) const = 0;

src/notation/internal/notationplayback.cpp

@@ -96,6 +96,7 @@ void NotationPlayback::updateLoopBoundaries()
     boundaries.loopOutTick = score()->loopOutTick().ticks();
     boundaries.loopInRect = loopBoundaryRectByTick(LoopBoundaryType::LoopIn, boundaries.loopInTick);
     boundaries.loopOutRect = loopBoundaryRectByTick(LoopBoundaryType::LoopOut, boundaries.loopOutTick);
+    boundaries.visible = m_loopBoundaries.val.visible;
 
     if (m_loopBoundaries.val != boundaries) {
         m_loopBoundaries.set(boundaries);
@@ -636,11 +637,14 @@ void NotationPlayback::addLoopOut(int _tick)
     score()->setLoopOutTick(tick);
 }
 
-void NotationPlayback::removeLoopBoundaries()
+void NotationPlayback::setLoopBoundariesVisible(bool visible)
 {
-    Fraction null = Fraction::fromTicks(0);
-    score()->setLoopInTick(null);
-    score()->setLoopOutTick(null);
+    if (m_loopBoundaries.val.visible == visible) {
+        return;
+    }
+
+    m_loopBoundaries.val.visible = visible;
+    m_loopBoundaries.set(m_loopBoundaries.val);
 }
 
 QRect NotationPlayback::loopBoundaryRectByTick(LoopBoundaryType boundaryType, int _tick) const
@@ -723,9 +727,9 @@ QRect NotationPlayback::loopBoundaryRectByTick(LoopBoundaryType boundaryType, in
     return QRect(x, y, width, height);
 }
 
-mu::async::Channel<LoopBoundaries> NotationPlayback::loopBoundariesChanged() const
+mu::ValCh<LoopBoundaries> NotationPlayback::loopBoundaries() const
 {
-    return m_loopBoundaries.ch;
+    return m_loopBoundaries;
 }
 
 Tempo NotationPlayback::tempo(int tick) const

src/notation/internal/notationplayback.h

@@ -61,8 +61,8 @@ public:
     midi::MidiData playElementMidiData(const Element* element) const override;
 
     void addLoopBoundary(LoopBoundaryType boundaryType, int tick) override;
-    void removeLoopBoundaries() override;
-    async::Channel<LoopBoundaries> loopBoundariesChanged() const override;
+    void setLoopBoundariesVisible(bool visible) override;
+    ValCh<LoopBoundaries> loopBoundaries() const override;
 
     Tempo tempo(int tick) const override;
     MeasureBeat beat(int tick) const override;

src/notation/notationtypes.h

@@ -347,6 +347,8 @@ struct LoopBoundaries
     QRect loopInRect;
     QRect loopOutRect;
 
+    bool visible = false;
+
     bool isNull() const
     {
         return loopInTick == 0 && loopOutTick == 0;
@@ -360,6 +362,7 @@ struct LoopBoundaries
         equals &= loopOutTick == boundaries.loopOutTick;
         equals &= loopInRect == boundaries.loopInRect;
         equals &= loopOutRect == boundaries.loopOutRect;
+        equals &= visible == boundaries.visible;
 
         return equals;
     }

src/notation/view/notationpaintview.cpp

@@ -197,7 +197,7 @@ void NotationPaintView::onCurrentNotationChanged()
         }
     });
 
-    notationPlayback()->loopBoundariesChanged().onReceive(this, [this](const LoopBoundaries& boundaries) {
+    notationPlayback()->loopBoundaries().ch.onReceive(this, [this](const LoopBoundaries& boundaries) {
         updateLoopMarkers(boundaries);
     });
 
@@ -225,8 +225,8 @@ void NotationPaintView::updateLoopMarkers(const LoopBoundaries& boundaries)
     m_loopInMarker->setRect(boundaries.loopInRect);
     m_loopOutMarker->setRect(boundaries.loopOutRect);
 
-    m_loopInMarker->setVisible(!boundaries.isNull());
-    m_loopOutMarker->setVisible(!boundaries.isNull());
+    m_loopInMarker->setVisible(boundaries.visible);
+    m_loopOutMarker->setVisible(boundaries.visible);
 
     update();
 }

src/playback/internal/playbackcontroller.cpp

@@ -107,6 +107,16 @@ bool PlaybackController::isPaused() const
     return sequencer()->status() == ISequencer::PAUSED;
 }
 
+bool PlaybackController::isLoopVisible() const
+{
+    return playback() ? playback()->loopBoundaries().val.visible : false;
+}
+
+bool PlaybackController::isPlaybackLooped() const
+{
+    return playback() ? !playback()->loopBoundaries().val.isNull() : false;
+}
+
 Notification PlaybackController::isPlayingChanged() const
 {
     return m_isPlayingChanged;
@@ -172,8 +182,8 @@ void PlaybackController::onNotationChanged()
             seek(tick);
         });
 
-        m_notation->playback()->loopBoundariesChanged().onReceive(this, [this](const LoopBoundaries& boundary) {
-            setLoop(boundary);
+        m_notation->playback()->loopBoundaries().ch.onReceive(this, [this](const LoopBoundaries& boundaries) {
+            setLoop(boundaries);
         });
     }
 
@@ -289,8 +299,13 @@ void PlaybackController::toggleCountIn()
 
 void PlaybackController::toggleLoopPlayback()
 {
-    if (m_isPlaybackLooped) {
-        unsetLoop();
+    if (isLoopVisible()) {
+        hideLoop();
+        return;
+    }
+
+    if (isPlaybackLooped() && !selection()->isRange()) {
+        showLoop();
         return;
     }
 
@@ -302,47 +317,55 @@ void PlaybackController::toggleLoopPlayback()
         loopOutTick = selection()->range()->endTick().ticks();
     }
 
-    playback()->addLoopBoundary(LoopBoundaryType::LoopIn, loopInTick);
-    playback()->addLoopBoundary(LoopBoundaryType::LoopOut, loopOutTick);
-
-    m_isPlaybackLooped = true;
+    addLoopBoundaryToTick(LoopBoundaryType::LoopIn, loopInTick);
+    addLoopBoundaryToTick(LoopBoundaryType::LoopOut, loopOutTick);
 }
 
 void PlaybackController::addLoopBoundary(LoopBoundaryType type)
 {
-    if (!playback()) {
-        return;
-    }
-
     if (isPlaying()) {
-        playback()->addLoopBoundary(type, currentTick());
+        addLoopBoundaryToTick(type, currentTick());
     } else {
-        playback()->addLoopBoundary(type, INotationPlayback::SelectedNoteTick);
+        addLoopBoundaryToTick(type, INotationPlayback::SelectedNoteTick);
     }
 }
 
-void PlaybackController::setLoop(const LoopBoundaries& boundary)
+void PlaybackController::addLoopBoundaryToTick(LoopBoundaryType type, int tick)
 {
-    if (boundary.isNull()) {
-        unsetLoop();
+    if (playback()) {
+        playback()->addLoopBoundary(type, tick);
+        showLoop();
+    }
+}
+
+void PlaybackController::setLoop(const LoopBoundaries& boundaries)
+{
+    if (!boundaries.visible) {
+        hideLoop();
         return;
     }
 
-    uint64_t fromMilliseconds = secondsToMilliseconds(playback()->tickToSec(boundary.loopInTick));
-    uint64_t toMilliseconds = secondsToMilliseconds(playback()->tickToSec(boundary.loopOutTick));
+    uint64_t fromMilliseconds = secondsToMilliseconds(playback()->tickToSec(boundaries.loopInTick));
+    uint64_t toMilliseconds = secondsToMilliseconds(playback()->tickToSec(boundaries.loopOutTick));
 
     sequencer()->setLoop(fromMilliseconds, toMilliseconds);
+    showLoop();
 
-    m_isPlaybackLooped = true;
     notifyActionEnabledChanged(LOOP_CODE);
 }
 
-void PlaybackController::unsetLoop()
+void PlaybackController::showLoop()
 {
-    if (playback() && m_isPlaybackLooped) {
-        m_isPlaybackLooped = false;
+    if (playback()) {
+        playback()->setLoopBoundariesVisible(true);
+    }
+}
+
+void PlaybackController::hideLoop()
+{
+    if (playback()) {
         sequencer()->unsetLoop();
-        playback()->removeLoopBoundaries();
+        playback()->setLoopBoundariesVisible(false);
         notifyActionEnabledChanged(LOOP_CODE);
     }
 }
@@ -355,7 +378,7 @@ void PlaybackController::notifyActionEnabledChanged(const ActionCode& actionCode
 bool PlaybackController::isActionEnabled(const ActionCode& actionCode) const
 {
     QMap<std::string, bool> isEnabled {
-        { LOOP_CODE, m_isPlaybackLooped },
+        { LOOP_CODE, isLoopVisible() },
         { MIDI_ON_CODE, notationConfiguration()->isMidiInputEnabled() },
         { REPEAT_CODE, notationConfiguration()->isPlayRepeatsEnabled() },
         { PAN_CODE, notationConfiguration()->isAutomaticallyPanEnabled() },

src/playback/internal/playbackcontroller.h

@@ -72,6 +72,9 @@ private:
     int currentTick() const;
     bool isPaused() const;
 
+    bool isLoopVisible() const;
+    bool isPlaybackLooped() const;
+
     void onNotationChanged();
     void togglePlay();
     void rewind(const actions::ActionData& args);
@@ -88,8 +91,12 @@ private:
     void toggleLoopPlayback();
 
     void addLoopBoundary(notation::LoopBoundaryType type);
-    void setLoop(const notation::LoopBoundaries& boundary);
-    void unsetLoop();
+    void addLoopBoundaryToTick(notation::LoopBoundaryType type, int tick);
+
+    void setLoop(const notation::LoopBoundaries& boundaries);
+
+    void showLoop();
+    void hideLoop();
 
     void notifyActionEnabledChanged(const actions::ActionCode& actionCode);
 
@@ -101,7 +108,6 @@ private:
     async::Channel<actions::ActionCode> m_actionEnabledChanged;
 
     bool m_needRewindBeforePlay = false;
-    bool m_isPlaybackLooped = false;
 };
 }