Local/global time fixes

Reedbeta · Reedbeta · commit c60d6338c596 · 2025-12-01T23:11:15.000-08:00
diff --git a/src/engraving/dom/paste.cpp b/src/engraving/dom/paste.cpp
@@ -102,7 +102,7 @@ void Score::pasteChordRest(ChordRest* cr, const Fraction& t)
         Transpose::transposeChord(chord, tick);
         if (chord->tremoloTwoChord()) {
             twoNoteTremoloFactor = 2;
-        } else if (cr->durationTypeTicks() == (cr->actualTicksAt(tick) * 2)) {
+        } else if (cr->durationTypeTicks() == (cr->ticks() * 2)) {
             // this could be the 2nd note of a two-note tremolo
             // check previous CR on same track, if it has a two-note tremolo, then set twoNoteTremoloFactor to 2
             Segment* seg = measure->undoGetSegment(SegmentType::ChordRest, tick);
@@ -122,7 +122,7 @@ void Score::pasteChordRest(ChordRest* cr, const Fraction& t)
     // otherwise, we need to convert to duration rest(s)
     // and potentially split the rest up (eg, 5/4 => whole + quarter)
     bool convertMeasureRest = cr->isRest() && cr->durationType().type() == DurationType::V_MEASURE
-                              && (tick != measure->tick() || cr->ticks() != measure->ticks());
+                              && (tick != measure->tick() || cr->actualTicksAt(tick) != measure->ticks());
 
     Fraction measureEnd = measure->endTick();
     bool isGrace = cr->isChord() && toChord(cr)->noteType() != NoteType::NORMAL;
@@ -145,40 +145,39 @@ void Score::pasteChordRest(ChordRest* cr, const Fraction& t)
     if (cr->isMeasureRepeat()) {
         partialCopy = toMeasureRepeat(cr)->actualTicks() != measure->ticks();
     } else if (!isGrace && !cr->tuplet()) {
-        partialCopy = cr->durationTypeTicks() != (cr->actualTicksAt(tick) * twoNoteTremoloFactor);
+        partialCopy = cr->durationTypeTicks() != (cr->ticks() * twoNoteTremoloFactor);
     }
 
     // if note is too long to fit in measure, split it up with a tie across the barline
     // exclude tuplets from consideration
     // we have already disallowed a tuplet from crossing the barline, so there is no problem here
     // but due to rounding, it might appear from actualTicks() that the last note is too long by a couple of ticks
 
+    Staff* stf = cr->staff();
     if (!isGrace && !cr->tuplet() && (tick + cr->actualTicksAt(tick) > measureEnd || partialCopy || convertMeasureRest)) {
         if (cr->isChord()) {
             // split Chord
             Chord* c = toChord(cr);
-            Fraction rest = c->actualTicksAt(tick);
+            Fraction rest = c->ticks();
             bool firstpart = true;
             while (rest.isNotZero()) {
                 measure = tick2measure(tick);
                 Chord* c2 = firstpart ? c : toChord(c->clone());
                 if (!firstpart) {
                     c2->removeMarkings(true);
                 }
-                Fraction mlen = measure->endTick() - tick;
+                Fraction timeStretch = stf->timeStretch(tick);
+                Fraction mlen = (measure->endTick() - tick) * timeStretch;
                 Fraction len = mlen > rest ? rest : mlen;
-                Fraction timeStretch = c2->staff()->timeStretch(tick);
-                std::vector<TDuration> dl = toRhythmicDurationList(len * timeStretch, false, (tick - measure->tick()) * timeStretch,
+                std::vector<TDuration> dl = toRhythmicDurationList(len, false, (tick - measure->tick()) * timeStretch,
                                                                    sigmap()->timesig(tick).nominal(), measure, MAX_DOTS, timeStretch);
                 if (dl.empty()) {
                     LOGD("Could not make durations for: %d/%d", len.numerator(), len.denominator());
                     return;
                 }
                 TDuration d = dl[0];
-                Fraction c2Tick(tick + c->tick());
                 c2->setDurationType(d);
                 c2->setTicks(d.fraction());
-                rest -= c2->actualTicksAt(c2Tick);
                 undoAddCR(c2, measure, tick);
 
                 std::vector<Note*> nl1 = c->notes();
@@ -201,9 +200,10 @@ void Score::pasteChordRest(ChordRest* cr, const Fraction& t)
                         nl2[i]->setTieBack(tie);
                     }
                 }
-                c = c2;
+                rest -= c2->ticks();
+                tick += c2->actualTicksAt(tick);
                 firstpart = false;
-                tick += c->actualTicksAt(c2Tick);
+                c = c2;
             }
         } else if (cr->isRest()) {
             // split Rest
@@ -214,34 +214,35 @@ void Score::pasteChordRest(ChordRest* cr, const Fraction& t)
             while (!rest.isZero()) {
                 Rest* r2      = firstpart ? r : toRest(r->clone());
                 measure       = tick2measure(tick);
-                Fraction mlen = measure->endTick() - tick;
+                Fraction timeStretch = stf->timeStretch(tick);
+                Fraction mlen = (measure->endTick() - tick) * timeStretch;
                 Fraction len  = rest > mlen ? mlen : rest;
-                Fraction timeStretch = r2->staff()->timeStretch(tick);
-                std::vector<TDuration> dl = toRhythmicDurationList(len * timeStretch, true, (tick - measure->tick()) * timeStretch,
+                std::vector<TDuration> dl = toRhythmicDurationList(len, true, (tick - measure->tick()) * timeStretch,
                                                                    sigmap()->timesig(tick).nominal(), measure, MAX_DOTS, timeStretch);
                 if (dl.empty()) {
                     LOGD("Could not make durations for: %d/%d", len.numerator(), len.denominator());
                     return;
                 }
                 TDuration d = dl[0];
                 r2->setDurationType(d);
-                r2->setTicks(d.isMeasure() ? measure->ticks() : d.fraction());
+                r2->setTicks(d.isMeasure() ? measure->stretchedLen(stf) : d.fraction());
                 undoAddCR(r2, measure, tick);
                 rest -= r2->ticks();
                 tick += r2->actualTicksAt(tick);
                 firstpart = false;
             }
         } else if (cr->isMeasureRepeat()) {
             MeasureRepeat* mr = toMeasureRepeat(cr);
-            std::vector<TDuration> list = toDurationList(mr->actualTicks(), true);
+            std::vector<TDuration> list = toDurationList(mr->ticks(), true);
             for (auto dur : list) {
                 Rest* r = Factory::createRest(this->dummy()->segment(), dur);
                 r->setTrack(cr->track());
                 Fraction rest = r->ticks();
                 while (!rest.isZero()) {
                     Rest* r2      = toRest(r->clone());
                     measure       = tick2measure(tick);
-                    Fraction mlen = measure->endTick() - tick;
+                    Fraction timeStretch = stf->timeStretch(tick);
+                    Fraction mlen = (measure->endTick() - tick) * timeStretch;
                     Fraction len  = rest > mlen ? mlen : rest;
                     std::vector<TDuration> dl = toDurationList(len, false);
                     if (dl.empty()) {
@@ -252,7 +253,7 @@ void Score::pasteChordRest(ChordRest* cr, const Fraction& t)
                     r2->setTicks(d.fraction());
                     r2->setDurationType(d);
                     undoAddCR(r2, measure, tick);
-                    rest -= d.fraction();
+                    rest -= r2->ticks();
                     tick += r2->actualTicksAt(tick);
                 }
                 delete r;
diff --git a/src/engraving/editing/cmd.cpp b/src/engraving/editing/cmd.cpp
@@ -1276,6 +1276,7 @@ Fraction Score::makeGap(Segment* segment, track_idx_t track, const Fraction& _sd
     assert(_sd.numerator());
 
     Measure* measure = segment->measure();
+    Staff* stf = staff(track2staff(track));
     Fraction accumulated;
     Fraction sd = _sd;
 
@@ -1292,13 +1293,15 @@ Fraction Score::makeGap(Segment* segment, track_idx_t track, const Fraction& _sd
         // voices != 0 may have gaps:
         //
         ChordRest* cr = toChordRest(seg->element(track));
+        Fraction timeStretch = cr->staff()->timeStretch(cr->tick());
         if (!cr) {
             if (seg->tick() < nextTick) {
                 continue;
             }
             Segment* seg1 = seg->next(SegmentType::ChordRest);
             Fraction tick2 = seg1 ? seg1->tick() : seg->measure()->endTick();
             Fraction td(tick2 - seg->tick());
+            td *= timeStretch;  // @reedbeta TODO - need to multiply by tuplet ratio also?
             if (td > sd) {
                 td = sd;
             }
@@ -1313,6 +1316,7 @@ Fraction Score::makeGap(Segment* segment, track_idx_t track, const Fraction& _sd
         if (seg->tick() > nextTick) {
             // there was a gap
             Fraction td(seg->tick() - nextTick);
+            td *= timeStretch;  // @reedbeta TODO - need to multiply by tuplet ratio also?
             if (td > sd) {
                 td = sd;
             }
@@ -1377,7 +1381,6 @@ Fraction Score::makeGap(Segment* segment, track_idx_t track, const Fraction& _sd
             // even if there was a tuplet, we didn't remove it
             ltuplet = 0;
         }
-        Fraction timeStretch = cr->staff()->timeStretch(cr->tick());
         nextTick += actualTicks(td, tuplet, timeStretch);
         if (sd < td) {
             //
@@ -1392,7 +1395,6 @@ Fraction Score::makeGap(Segment* segment, track_idx_t track, const Fraction& _sd
                 dList = toDurationList(rd, false);
                 std::reverse(dList.begin(), dList.end());
             } else {
-                Staff* stf = staff(track2staff(track));
                 TimeSig* timeSig = stf->timeSig(tick);
                 TimeSigFrac refTimeSig = timeSig ? timeSig->sig() : sigmap()->timesig(tick).nominal();
                 Fraction rTickStart = (tick - measure->tick()) * stf->timeStretch(tick);
@@ -1419,19 +1421,9 @@ Fraction Score::makeGap(Segment* segment, track_idx_t track, const Fraction& _sd
             break;
         }
     }
-//      Fraction ticks = measure->endTick() - segment->tick();
-//      Fraction td = Fraction::fromTicks(ticks);
-// NEEDS REVIEW !!
-// once the statement below is removed, these two lines do nothing
-//      if (td > sd)
-//            td = sd;
-// ???  accumulated should already contain the total value of the created gap: line 749, 811 or 838
-//      this line creates a double-sized gap if the needed gap crosses a measure boundary
-//      by adding again the duration already added in line 838
-//      accumulated += td;
 
     const Fraction t1 = firstSegmentEnd;
-    const Fraction t2 = firstSegment->tick() + accumulated;
+    const Fraction t2 = firstSegment->tick() + actualTicks(accumulated, tuplet, stf->timeStretch(firstSegment->tick()));
     if (t1 < t2) {
         Segment* s1 = tick2rightSegment(t1);
         Segment* s2 = tick2rightSegment(t2);
@@ -1471,7 +1463,7 @@ bool Score::makeGap1(const Fraction& baseTick, staff_idx_t staffIdx, const Fract
         if (!voiceOffset[track - strack].isValid()) {
             continue;
         }
-        Fraction tick = baseTick + voiceOffset[track - strack];
+        Fraction tick = baseTick + actualTicks(voiceOffset[track - strack], nullptr, staff(staffIdx)->timeStretch(baseTick));
         Measure* tm   = tick2measure(tick);
         if ((track % VOICES) && !tm->hasVoices(staffIdx)) {
             continue;
@@ -1481,7 +1473,7 @@ bool Score::makeGap1(const Fraction& baseTick, staff_idx_t staffIdx, const Fract
         assert(newLen.numerator() != 0);
 
         if (newLen > Fraction(0, 1)) {
-            const Fraction endTick = tick + newLen;
+            const Fraction endTick = tick + actualTicks(newLen, nullptr, staff(staffIdx)->timeStretch(tick));
 
             SelectionFilter filter;
             // chord symbols can exist without chord/rest so they should not be removed
@@ -1523,7 +1515,7 @@ bool Score::makeGapVoice(Segment* seg, track_idx_t track, Fraction len, const Fr
         }
         ChordRest* cr1 = toChordRest(seg1->element(track));
         Fraction srcF = cr1->ticks();
-        Fraction dstF = tick - cr1->tick();
+        Fraction dstF = (tick - cr1->tick()) * cr1->staff()->timeStretch(cr1->tick());
         std::vector<TDuration> dList = toDurationList(dstF, true);
         if (dList.empty()) {
             LOGD("Could not make durations for: %d/%d", dstF.numerator(), dstF.denominator());
@@ -4150,6 +4142,7 @@ void Score::cmdSlashRhythm()
 
 //---------------------------------------------------------
 //   setChord
+//    'dur' is in local (stretched) time
 //    return segment of last created chord
 //---------------------------------------------------------
 static Segment* setChord(Score* score, Segment* segment, track_idx_t track, const Chord* chordTemplate, Fraction dur)
@@ -4336,7 +4329,7 @@ void Score::cmdRealizeChordSymbols(bool literal, Voicing voicing, HDuration dura
         const RealizedHarmony& r = h->getRealizedHarmony();
         Segment* seg = h->explicitParent()->isSegment() ? toSegment(h->explicitParent()) : toSegment(h->explicitParent()->explicitParent());
         Fraction tick = seg->tick();
-        Fraction duration = r.getActualDuration(tick.ticks(), durationType);
+        Fraction duration = r.getActualDuration(tick.ticks(), durationType) * h->staff()->timeStretch(tick);
         bool concertPitch = style().styleB(Sid::concertPitch);
 
         Chord* chord = Factory::createChord(this->dummy()->segment());     //chord template
diff --git a/src/engraving/editing/edit.cpp b/src/engraving/editing/edit.cpp
@@ -450,7 +450,7 @@ ChordRest* Score::addClone(ChordRest* cr, const Fraction& tick, const TDuration&
     }
     newcr->mutldata()->setPosX(0.0);
     newcr->setDurationType(d);
-    newcr->setTicks(d.isMeasure() ? cr->measure()->ticks() : d.fraction());
+    newcr->setTicks(d.isMeasure() ? cr->measure()->stretchedLen(cr->staff()) : d.fraction());
     newcr->setTuplet(cr->tuplet());
     newcr->setSelected(false);
     if (newcr->isChord()) {
@@ -1824,19 +1824,19 @@ void Score::regroupNotesAndRests(const Fraction& startTick, const Fraction& endT
                     }
                     lastRest = cr;
                 }
-                Fraction restTicks = lastRest->tick() + lastRest->ticks() - curr->tick();
+                Fraction restTicks = (lastRest->endTick() - curr->tick()) * curr->staff()->timeStretch(curr->tick());
                 seg = setNoteRest(seg, curr->track(), NoteVal(), restTicks, DirectionV::AUTO, false, {}, true);
             } else if (curr->isChord()) {
                 // combine tied chords
                 Chord* chord = toChord(curr);
                 Chord* lastTiedChord = chord;
-                for (Chord* next = chord->nextTiedChord(); next && next->tick() + next->ticks() <= maxTick; next = next->nextTiedChord()) {
+                for (Chord* next = chord->nextTiedChord(); next && next->endTick() <= maxTick; next = next->nextTiedChord()) {
                     lastTiedChord = next;
                 }
                 if (!lastTiedChord) {
                     lastTiedChord = chord;
                 }
-                Fraction noteTicks = lastTiedChord->tick() + lastTiedChord->ticks() - chord->tick();
+                Fraction noteTicks = (lastTiedChord->endTick() - chord->tick()) * chord->staff()->timeStretch(chord->tick());
                 if (!(curr->tuplet())) {
                     // store start/end note for backward/forward ties ending/starting on the group of notes being rewritten
                     size_t numNotes = chord->notes().size();
diff --git a/src/engraving/rw/read400/read400.cpp b/src/engraving/rw/read400/read400.cpp
@@ -427,9 +427,9 @@ bool Read400::pasteStaff(XmlReader& e, Segment* dst, staff_idx_t dstStaff, Fract
                         }
                         voice_idx_t voiceId = static_cast<voice_idx_t>(e.intAttribute("id", -1));
                         assert(voiceId < VOICES);
-                        voiceOffset[voiceId] = Fraction::fromTicks(e.readInt());
+                        voiceOffset[voiceId] = Fraction::fromTicks(e.readInt()) * timeStretch;
                     }
-                    if (!score->makeGap1(dstTick, dstStaffIdx, tickLen, voiceOffset)) {
+                    if (!score->makeGap1(dstTick, dstStaffIdx, tickLen * timeStretch, voiceOffset)) {
                         LOGD() << "cannot make gap in staff " << dstStaffIdx << " at tick " << dstTick.ticks();
                         done = true;             // break main loop, cannot make gap
                         break;
@@ -501,7 +501,7 @@ bool Read400::pasteStaff(XmlReader& e, Segment* dst, staff_idx_t dstStaff, Fract
                         if (tuplet) {
                             cr->readAddTuplet(tuplet);
                         }
-                        ctx.incTick(cr->actualTicks());
+                        ctx.incTick(cr->actualTicksAt(tick));
                         if (doScale) {
                             Fraction d = cr->durationTypeTicks();
                             cr->setTicks(cr->ticks() * scale);
@@ -521,7 +521,7 @@ bool Read400::pasteStaff(XmlReader& e, Segment* dst, staff_idx_t dstStaff, Fract
                                     Fraction d = t->durationType().ticks();
                                     t->setDurationType(d * scale);
                                 }
-                                Fraction tremoloEndTick = tick + chord->actualTicks();
+                                Fraction tremoloEndTick = tick + chord->actualTicksAt(tick);
                                 Fraction measureEndTick = score->tick2measure(tick)->endTick();
                                 if (tremoloEndTick > measureEndTick) {
                                     MScore::setError(MsError::DEST_TREMOLO);
@@ -542,7 +542,7 @@ bool Read400::pasteStaff(XmlReader& e, Segment* dst, staff_idx_t dstStaff, Fract
                             graceNotes.clear();
                         }
                         // delete pending ties, they are not selected when copy
-                        if ((tick - dstTick) + cr->actualTicks() >= tickLen) {
+                        if ((tick - dstTick) + cr->actualTicksAt(tick) >= tickLen) {
                             if (cr->isChord()) {
                                 Chord* c = toChord(cr);
                                 for (Note* note: c->notes()) {
@@ -555,7 +555,7 @@ bool Read400::pasteStaff(XmlReader& e, Segment* dst, staff_idx_t dstStaff, Fract
                             }
                         }
                         // shorten last cr to fit in the space made by makeGap
-                        if ((tick - dstTick) + cr->actualTicks() > tickLen) {
+                        if ((tick - dstTick) + cr->actualTicksAt(tick) > tickLen) {
                             Fraction newLength = tickLen - (tick - dstTick);
                             // check previous CR on same track, if it has tremolo, delete the tremolo
                             // we don't want a tremolo and two different chord durations
@@ -581,8 +581,8 @@ bool Read400::pasteStaff(XmlReader& e, Segment* dst, staff_idx_t dstStaff, Fract
                                 // shorten duration
                                 // exempt notes in tuplets, since we don't allow copy of partial tuplet anyhow
                                 // TODO: figure out a reasonable fudge factor to make sure shorten tuplets appropriately if we do ever copy a partial tuplet
-                                cr->setTicks(newLength);
-                                cr->setDurationType(newLength);
+                                cr->setTicks(newLength * timeStretch);
+                                cr->setDurationType(newLength * timeStretch);
                             }
                         }
                         score->pasteChordRest(cr, tick);
diff --git a/src/engraving/rw/read410/read410.cpp b/src/engraving/rw/read410/read410.cpp
diff --git a/src/engraving/rw/read460/read460.cpp b/src/engraving/rw/read460/read460.cpp
