Fix test failures, round 1 (and probably enable GTP import of two-mea…

…sure repeats)

libmscore/layout.cpp

@@ -3794,7 +3794,7 @@ System* Score::collectSystem(LayoutContext& lc)
                 // but if too many are grouped, stop before we get 0 measures left on system
                 // TODO: intelligently break group into smaller groups instead
                 lc.tick -= lc.curMeasure->ticks();
-                --lc.measureNo;
+                lc.measureNo = lc.prevMeasure->no();
 
                 lc.nextMeasure = lc.curMeasure;
                 lc.curMeasure  = lc.prevMeasure;

libmscore/measure.cpp

@@ -2789,26 +2789,6 @@ bool Measure::isFullMeasureRest() const
     return true;
 }
 
-//---------------------------------------------------------
-//   containsMeasureRepeat
-//---------------------------------------------------------
-
-MeasureRepeat* Measure::containsMeasureRepeat(int staffIdx) const
-{
-    int strack   = staffIdx * VOICES;
-    int etrack   = (staffIdx + 1) * VOICES;
-
-    for (Segment* s = first(SegmentType::ChordRest); s && s != last(); s = s->next(SegmentType::ChordRest)) {
-        for (int track = strack; track < etrack; ++track) {
-            Element* e = s->element(track);
-            if (e && e->isMeasureRepeat()) {
-                return toMeasureRepeat(e);
-            }
-        }
-    }
-    return nullptr;
-}
-
 //---------------------------------------------------------
 //   isEmpty
 //---------------------------------------------------------
@@ -3297,14 +3277,23 @@ MeasureRepeat* Measure::measureRepeatElement(int staffIdx) const
     if (!m) {
         return nullptr;
     }
-    MeasureRepeat* mr;
-    for (;;) {
-        mr = m->containsMeasureRepeat(staffIdx);
-        if (mr) {
-            return mr;
+    while (m->isMeasureRepeatGroup(staffIdx)) {
+        int strack = staff2track(staffIdx);
+        int etrack = staff2track(staffIdx + 1);
+        for (int track = strack; track < etrack; ++track) {
+            // should only be in first track, but just in case
+            std::cout << "Searching for MR element in measure " << m->no() << ", track " << track << std::endl;
+            for (Segment* s = m->first(SegmentType::ChordRest); s && s != m->last(); s = s->next(SegmentType::ChordRest)) {
+                // should only be in first segment, but just in case
+                Element* e = s->element(track);
+                if (e && e->isMeasureRepeat()) {
+                    return toMeasureRepeat(e);
+                }
+            }
         }
         m = m->nextMeasure();
     }
+    return nullptr;
 }
 
 //---------------------------------------------------------

libmscore/measure.h

@@ -294,7 +294,6 @@ class Measure final : public MeasureBase
     bool isMeasureRepeatGroupWithPrevM(int staffIdx) const;
     Measure* firstOfMeasureRepeatGroup(int staffIdx) const;     // used to find beginning of group
     MeasureRepeat* measureRepeatElement(int staffIdx) const;    // get measure repeat element from anywhere within group
-    MeasureRepeat* containsMeasureRepeat(int staffIdx) const;
     int measureRepeatNumMeasures(int staffIdx) const;
     bool isOneMeasureRepeat(int staffIdx) const;
     bool nextIsOneMeasureRepeat(int staffidx) const;

libmscore/measurerepeat.cpp

@@ -96,7 +96,7 @@ void MeasureRepeat::layout()
             }
             if (placeInSeries % score()->styleI(Sid::mrNumberEveryXMeasures) == 0) {
                 if (score()->styleB(Sid::mrNumberSeriesWithParentheses)) {
-                    m_numberSym = toTimeSigString("(" + QString::number(placeInSeries) + ")");
+                    m_numberSym = toTimeSigString(QString("(%1)").arg(placeInSeries));
                 } else {
                     setNumberSym(placeInSeries);
                 }

libmscore/measurerepeat.h

@@ -10,8 +10,8 @@
 //  the file LICENCE.GPL
 //=============================================================================
 
-#ifndef __REPEAT_H__
-#define __REPEAT_H__
+#ifndef __MEASUREREPEAT_H__
+#define __MEASUREREPEAT_H__
 
 #include "rest.h"
 #include "text.h"

mtest/libmscore/compat206/markers-ref.mscx

@@ -305,9 +305,11 @@
           </voice>
         </Measure>
       <Measure>
+        <measureRepeatCount>1</measureRepeatCount>
         <voice>
           <MeasureRepeat>
             <subtype>1</subtype>
+            <autoplace>0</autoplace>
             <durationType>measure</durationType>
             <duration>4/4</duration>
             </MeasureRepeat>

mu4/domain/importexport/internal/guitarpro/importgtp-gp6.cpp

@@ -1970,12 +1970,32 @@ void GuitarPro6::readBars(QDomNode* barList, Measure* measure, ClefType oldClefI
                 if (!currentNode.toElement().text().compare("Simple")
                     || !currentNode.toElement().text().compare("FirstOfDouble")
                     || !currentNode.toElement().text().compare("SecondOfDouble")) {
-                    MeasureRepeat* rm = new MeasureRepeat(score);
-                    rm->setTrack(staffIdx * VOICES);
-                    rm->setTicks(measure->ticks());
-                    rm->setDurationType(TDuration::DurationType::V_MEASURE);
+                    MeasureRepeat* mr = new MeasureRepeat(score);
+                    mr->setTrack(staff2track(staffIdx));
+                    mr->setTicks(measure->ticks());
+                    mr->setNumMeasures(1);
                     Segment* segment = measure->getSegment(SegmentType::ChordRest, tick);
-                    segment->add(rm);
+                    segment->add(mr);
+                    measure->setMeasureRepeatCount(1, staffIdx);
+                } else if (currentNode.toElement().text().compare("FirstOfDouble")) {
+                    // speculative, untested (due to lacking input files),
+                    // but seems like this should work to import two-measure repeats/"similes"
+                    MeasureRepeat* mr = new MeasureRepeat(score);
+                    mr->setTrack(staff2track(staffIdx));
+                    mr->setTicks(measure->ticks());
+                    mr->setNumMeasures(2);
+                    Segment* segment = measure->getSegment(SegmentType::ChordRest, tick);
+                    segment->add(mr);
+                    measure->setMeasureRepeatCount(1, staffIdx);
+                } else if (currentNode.toElement().text().compare("SecondOfDouble")) {
+                    // second measure of group contains undisplayed rest in MuseScore
+                    Rest* r = new Rest(score);
+                    r->setTrack(staff2track(staffIdx));
+                    r->setTicks(measure->ticks());
+                    r->setDurationType(TDuration::DurationType::V_MEASURE);
+                    Segment* segment = measure->getSegment(SegmentType::ChordRest, tick);
+                    segment->add(r);
+                    measure->setMeasureRepeatCount(2, staffIdx);
                 } else {
                     qDebug() << "WARNING: unhandle similie mark type: " << currentNode.toElement().text();
                 }

mu4/domain/importexport/internal/musicxml/exportxml.cpp

@@ -6726,18 +6726,17 @@ void ExportMusicXml::writeParts()
                     }
                     const auto m = toMeasure(mb);
 
-                    // write the measure, or,
-                    // in case of a multimeasure rest, the measure range it replaces, or
-                    // in case of measure repeat, the measure that it indicates for the musician to play
                     if (m->isMMRest()) {
-                        const auto m2 = m->mmRestLast();
+                        // in case of a multimeasure rest (which is a single measure in MuseScore), write the measure range it replaces
+                        const auto m2 = m->mmRestLast()->nextMeasure();
                         for (auto m1 = m->mmRestFirst(); m1 != m2; m1 = m1->nextMeasure()) {
                             if (m1->isMeasure()) {
                                 writeMeasure(m1, partIndex, staffCount, mnsh, fbMap, mpc);
                                 mpc.measureWritten(m1);
                             }
                         }
                     } else {
+                        // write the measure (or, if measure repeat, the "underlying" measure that it indicates for the musician to play)
                         writeMeasure(m, partIndex, staffCount, mnsh, fbMap, mpc);
                         mpc.measureWritten(m);
                     }

mu4/domain/importexport/internal/musicxml/importmxmlpass2.cpp

@@ -2130,8 +2130,7 @@ void MusicXMLParserPass2::measure(const QString& partId, const Fraction time)
             _score->makeGap(measure->first(SegmentType::ChordRest), track, measure->stretchedLen(_score->staff(staffIdx)), 0);
 
             if (_measureRepeatCount[i] == _measureRepeatNumMeasures[i]) {
-                // in middle of measure repeats (otherwise _measureRepeatsStarted would be false),
-                // but starting a new one, not continuing a multi-measure group
+                // starting a new one, not continuing a multi-measure group
                 _measureRepeatCount[i] = 1;
             } else {
                 // continue building measure repeat group
@@ -2354,17 +2353,16 @@ void MusicXMLParserPass2::measureStyle(const QString& partId, Measure* measure)
     Q_ASSERT(_e.isStartElement() && _e.name() == "measure-style");
 
     QStringRef staffNumberString = _e.attributes().value("number");
-    int nstaves = _pass1.getPart(partId)->nstaves();
 
     // by default, apply to all staves in part
     int startStaff = 0;
-    int endStaff = nstaves - 1;
+    int endStaff = _nstaves - 1;
 
     // but if a staff number was specified in the measure-style tag, use that instead
     if (!staffNumberString.isEmpty()) {
         int staffNumber = staffNumberString.toInt();
-        if (staffNumber < 1 || staffNumber > nstaves) {
-            _logger->logError(QString("measure-style staff number can only be int from 1 to nStaves."));
+        if (staffNumber < 1 || staffNumber > _nstaves) {
+            _logger->logError(QString("measure-style staff number can only be int from 1 to _nstaves."));
         }
         --staffNumber; // convert to 0-based
         endStaff = startStaff = staffNumber;