Merge pull request #26136 from mike-spa/fixSystemLockOnRemoveMeasures

Fix system locks on remove measures

Author: mike-spa

src/engraving/dom/edit.cpp

@@ -6625,6 +6625,104 @@ void Score::removeLayoutBreaksOnAddSystemLock(const SystemLock* lock)
     }
 }
 
+void Score::removeSystemLocksOnRemoveMeasures(const MeasureBase* m1, const MeasureBase* m2)
+{
+    std::vector<const SystemLock*> allSysLocks = systemLocks()->allLocks();
+    for (const SystemLock* lock : allSysLocks) {
+        MeasureBase* lockStart = lock->startMB();
+        MeasureBase* lockEnd = lock->endMB();
+        bool lockStartIsInRange = lockStart->isAfterOrEqual(m1) && lockStart->isBeforeOrEqual(m2);
+        bool lockEndIsInRange = lockEnd->isAfterOrEqual(m1) && lockEnd->isBeforeOrEqual(m2);
+        if (lockStartIsInRange || lockEndIsInRange) {
+            undoRemoveSystemLock(lock);
+        }
+        if (lockStartIsInRange && !lockEndIsInRange) {
+            MeasureBase* newLockStart = m2->nextMeasure();
+            if (newLockStart) {
+                undoAddSystemLock(new SystemLock(newLockStart, lockEnd));
+            }
+        } else if (!lockStartIsInRange && lockEndIsInRange) {
+            MeasureBase* newLockEnd = m1->prevMeasure();
+            if (newLockEnd) {
+                undoAddSystemLock(new SystemLock(lockStart, newLockEnd));
+            }
+        }
+    }
+}
+
+void Score::updateSystemLocksOnDisableMMRests()
+{
+    // NOTE: this can be done before layout for the full score
+    // because we already know where the mmRests are.
+
+    assert(!style().styleB(Sid::createMultiMeasureRests));
+
+    std::vector<const SystemLock*> allLocks = m_systemLocks.allLocks();
+    for (const SystemLock* lock : allLocks) {
+        MeasureBase* startMB = lock->startMB();
+        MeasureBase* endMB = lock->endMB();
+        bool startIsMMRest = startMB->isMeasure() && toMeasure(startMB)->isMMRest();
+        bool endIsMMRest = endMB->isMeasure() && toMeasure(endMB)->isMMRest();
+        if (startIsMMRest || endIsMMRest) {
+            undoRemoveSystemLock(lock);
+            MeasureBase* newStartMeas = startMB;
+            MeasureBase* newEndMeas = endMB;
+            if (startIsMMRest) {
+                newStartMeas = toMeasure(startMB)->mmRestFirst();
+            }
+            if (endIsMMRest) {
+                newEndMeas = toMeasure(endMB)->mmRestLast();
+            }
+            undoAddSystemLock(new SystemLock(newStartMeas, newEndMeas));
+        }
+    }
+}
+
+void Score::updateSystemLocksOnCreateMMRests(Measure* first, Measure* last)
+{
+    // NOTE: this must be done during layout as the mmRests get created.
+
+    for (const SystemLock* lock : systemLocks()->locksContainedInRange(first, last)) {
+        // These locks are inside the range of the mmRest so remove them
+        undoRemoveSystemLock(lock);
+    }
+
+    const SystemLock* lockOnFirst = systemLocks()->lockContaining(first);
+    const SystemLock* lockOnLast = systemLocks()->lockContaining(last);
+
+    if (lockOnFirst) {
+        MeasureBase* startMB = lockOnFirst->startMB();
+        MeasureBase* endMB = lockOnFirst->endMB();
+
+        if (startMB->isBefore(first)) {
+            if (endMB->isBeforeOrEqual(last)) {
+                endMB = first->mmRest();
+            } else {
+                return;
+            }
+        } else {
+            startMB = first->mmRest();
+        }
+
+        if (startMB != lockOnFirst->startMB() || endMB != lockOnFirst->endMB()) {
+            undoRemoveSystemLock(lockOnFirst);
+            undoAddSystemLock(new SystemLock(startMB, endMB));
+        }
+    }
+
+    if (!lockOnLast || lockOnLast == lockOnFirst) {
+        return;
+    }
+
+    MeasureBase* startMB = lockOnLast->startMB();
+    MeasureBase* endMB = lockOnLast->endMB();
+    assert(startMB->isAfter(first) && endMB->isAfter(last));
+
+    undoRemoveSystemLock(lockOnLast);
+    startMB = last->nextMM();
+    undoAddSystemLock(new SystemLock(startMB, endMB));
+}
+
 //---------------------------------------------------------
 //   undoAddCR
 //---------------------------------------------------------
@@ -7118,6 +7216,8 @@ void Score::undoRemoveMeasures(Measure* m1, Measure* m2, bool preserveTies, bool
         }
     }
 
+    removeSystemLocksOnRemoveMeasures(m1, m2);
+
     undo(new RemoveMeasures(m1, m2, moveStaffTypeChanges));
 }
 

src/engraving/dom/measurebase.cpp

@@ -706,11 +706,22 @@ bool MeasureBase::isBefore(const EngravingItem* other) const
 
 bool MeasureBase::isBefore(const MeasureBase* other) const
 {
+    if (this == other) {
+        return false;
+    }
+
     Fraction otherTick = other->tick();
     if (otherTick != m_tick) {
         return m_tick < otherTick;
     }
 
+    if (this->isMeasure() && other->isMeasure()) {
+        // (this == other) has already been excluded, so this is only
+        // possible if one is the overlying mmRest starting on the other.
+        // Let's set by convention that the mmRest isBefore the underlying measure.
+        return toMeasure(this)->isMMRest();
+    }
+
     bool otherIsMMRest = other->isMeasure() && toMeasure(other)->isMMRest();
     for (const MeasureBase* mb = otherIsMMRest ? nextMM() : next(); mb && mb->tick() == m_tick;
          mb = otherIsMMRest ? mb->nextMM() : mb->next()) {

src/engraving/dom/score.h

@@ -1021,6 +1021,9 @@ class Score : public EngravingObject, public muse::Injectable
     void makeIntoSystem(MeasureBase* first, MeasureBase* last);
     void removeSystemLocksOnAddLayoutBreak(LayoutBreakType breakType, const MeasureBase* measure);
     void removeLayoutBreaksOnAddSystemLock(const SystemLock* lock);
+    void removeSystemLocksOnRemoveMeasures(const MeasureBase* m1, const MeasureBase* m2);
+    void updateSystemLocksOnDisableMMRests();
+    void updateSystemLocksOnCreateMMRests(Measure* first, Measure* last);
 
     friend class Chord;
 

src/engraving/dom/systemlock.cpp

@@ -77,7 +77,7 @@ const SystemLock* SystemLocks::lockContaining(const MeasureBase* mb) const
     return lock->contains(mb) ? lock : nullptr;
 }
 
-std::vector<const SystemLock*> SystemLocks::locksContainedInRange(const MeasureBase* start, const MeasureBase* end)
+std::vector<const SystemLock*> SystemLocks::locksContainedInRange(const MeasureBase* start, const MeasureBase* end) const
 {
     std::vector<const SystemLock*> result;
 

src/engraving/dom/systemlock.h

@@ -58,7 +58,7 @@ class SystemLocks
 
     const SystemLock* lockStartingAt(const MeasureBase* mb) const;
     const SystemLock* lockContaining(const MeasureBase* mb) const;
-    std::vector<const SystemLock*> locksContainedInRange(const MeasureBase* start, const MeasureBase* end);
+    std::vector<const SystemLock*> locksContainedInRange(const MeasureBase* start, const MeasureBase* end) const;
 
     std::vector<const SystemLock*> allLocks() const;
 

src/engraving/dom/undo.cpp

@@ -2039,6 +2039,11 @@ static void changeStyleValue(Score* score, Sid idx, const PropertyValue& oldValu
     case Sid::defaultsVersion:
         score->style().setDefaultStyleVersion(newValue.toInt());
         break;
+    case Sid::createMultiMeasureRests:
+        if (oldValue.toBool() == true && newValue.toBool() == false) {
+            score->updateSystemLocksOnDisableMMRests();
+        }
+        break;
     default:
         break;
     }

src/engraving/rendering/score/layoutcontext.cpp

@@ -392,6 +392,14 @@ void DomAccessor::removeElement(EngravingItem* item)
     score()->removeElement(item);
 }
 
+void DomAccessor::updateSystemLocksOnCreateMMRest(Measure* first, Measure* last)
+{
+    IF_ASSERT_FAILED(score()) {
+        return;
+    }
+    score()->updateSystemLocksOnCreateMMRests(first, last);
+}
+
 void DomAccessor::addUnmanagedSpanner(Spanner* s)
 {
     IF_ASSERT_FAILED(score()) {

src/engraving/rendering/score/layoutcontext.h

@@ -198,6 +198,7 @@ class DomAccessor
     void undo(UndoCommand* cmd, EditData* ed = nullptr) const;
     void addElement(EngravingItem* item);
     void removeElement(EngravingItem* item);
+    void updateSystemLocksOnCreateMMRest(Measure* first, Measure* last);
 
     void addUnmanagedSpanner(Spanner* s);
     const std::set<Spanner*>& unmanagedSpanners() const;

src/engraving/rendering/score/measurelayout.cpp

@@ -227,6 +227,8 @@ void MeasureLayout::createMMRest(LayoutContext& ctx, Measure* firstMeasure, Meas
     mmrMeasure->setMMRestCount(numMeasuresInMMRest);
     mmrMeasure->setNo(firstMeasure->no());
 
+    ctx.mutDom().updateSystemLocksOnCreateMMRest(firstMeasure, lastMeasure);
+
     //
     // set mmrMeasure with same barline as last underlying measure
     //