LoweBowe/MuseScore
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

moved division from MScore to Constant

Browse source
This commit is contained in:
Igor Korsukov 2021-11-25 18:31:04 +02:00
parent 61586637fd
commit 1101c9d1d5
46 changed files with 136 additions and 141 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
src/engraving/layout/layoutbeams.cpp
View file

@ -298,7 +298,7 @@ void LayoutBeams::createBeams(Score* score, LayoutContext& lc, Measure* measure)
if (mcr == 0) {
continue;
}
int beat = (mcr->rtick() * stretch).ticks() / MScore::division;
int beat = (mcr->rtick() * stretch).ticks() / Constants::division;
if (beatSubdivision.contains(beat)) {
beatSubdivision[beat] = qMin(beatSubdivision[beat], mcr->durationType());
} else {
@ -357,8 +357,8 @@ void LayoutBeams::createBeams(Score* score, LayoutContext& lc, Measure* measure)
if (checkBeats && cr->rtick().isNotZero()) {
Fraction tick = cr->rtick() * stretch;
// check if on the beat
if ((tick.ticks() % MScore::division) == 0) {
int beat = tick.ticks() / MScore::division;
if ((tick.ticks() % Constants::division) == 0) {
int beat = tick.ticks() / Constants::division;
// get minimum duration for this & previous beat
TDuration minDuration = qMin(beatSubdivision[beat], beatSubdivision[beat - 1]);
// re-calculate beam as if this were the duration of current chordrest

2
src/engraving/libmscore/dynamic.cpp
View file

@ -246,7 +246,7 @@ Fraction Dynamic::velocityChangeLength() const
break;
}
return Fraction::fromTicks(int(ratio * (speedMult * double(MScore::division))));
return Fraction::fromTicks(int(ratio * (speedMult * double(Constant::division))));
}
//---------------------------------------------------------

2
src/engraving/libmscore/groups.cpp
View file

@ -144,7 +144,7 @@ Beam::Mode Groups::beamMode(int tick, TDuration::DurationType d) const
default:
return Beam::Mode::AUTO;
}
const int dm = MScore::division / 8;
const int dm = Constant::division / 8;
for (const GroupNode& e : *this) {
if (e.pos * dm < tick) {
continue;

1
src/engraving/libmscore/mscore.cpp
View file

@ -112,7 +112,6 @@ qreal MScore::nudgeStep50;
int MScore::defaultPlayDuration;
QString MScore::lastError;
int MScore::division = 480; // 3840; // pulses per quarter note (PPQ) // ticks per beat
int MScore::sampleRate = 44100;
int MScore::mtcType;

1
src/engraving/libmscore/mscore.h
View file

@ -351,7 +351,6 @@ public:
static bool debugMode;
static bool testMode;
static int division;
static int sampleRate;
static int mtcType;

18
src/engraving/libmscore/note.cpp
View file

@ -2002,28 +2002,28 @@ EngravingItem* Note::drop(EditData& data)
{
switch (toActionIcon(e)->actionType()) {
case ActionIconType::ACCIACCATURA:
score()->setGraceNote(ch, pitch(), NoteType::ACCIACCATURA, MScore::division / 2);
score()->setGraceNote(ch, pitch(), NoteType::ACCIACCATURA, Constant::division / 2);
break;
case ActionIconType::APPOGGIATURA:
score()->setGraceNote(ch, pitch(), NoteType::APPOGGIATURA, MScore::division / 2);
score()->setGraceNote(ch, pitch(), NoteType::APPOGGIATURA, Constant::division / 2);
break;
case ActionIconType::GRACE4:
score()->setGraceNote(ch, pitch(), NoteType::GRACE4, MScore::division);
score()->setGraceNote(ch, pitch(), NoteType::GRACE4, Constant::division);
break;
case ActionIconType::GRACE16:
score()->setGraceNote(ch, pitch(), NoteType::GRACE16, MScore::division / 4);
score()->setGraceNote(ch, pitch(), NoteType::GRACE16, Constant::division / 4);
break;
case ActionIconType::GRACE32:
score()->setGraceNote(ch, pitch(), NoteType::GRACE32, MScore::division / 8);
score()->setGraceNote(ch, pitch(), NoteType::GRACE32, Constant::division / 8);
break;
case ActionIconType::GRACE8_AFTER:
score()->setGraceNote(ch, pitch(), NoteType::GRACE8_AFTER, MScore::division / 2);
score()->setGraceNote(ch, pitch(), NoteType::GRACE8_AFTER, Constant::division / 2);
break;
case ActionIconType::GRACE16_AFTER:
score()->setGraceNote(ch, pitch(), NoteType::GRACE16_AFTER, MScore::division / 4);
score()->setGraceNote(ch, pitch(), NoteType::GRACE16_AFTER, Constant::division / 4);
break;
case ActionIconType::GRACE32_AFTER:
score()->setGraceNote(ch, pitch(), NoteType::GRACE32_AFTER, MScore::division / 8);
score()->setGraceNote(ch, pitch(), NoteType::GRACE32_AFTER, Constant::division / 8);
break;
case ActionIconType::BEAM_START:
case ActionIconType::BEAM_MID:
@ -2051,7 +2051,7 @@ EngravingItem* Note::drop(EditData& data)
// before the current note
for (int i = nl.size() - 1; i >= 0; --i) {
int p = BagpipeEmbellishment::BagpipeNoteInfoList[nl.at(i)].pitch;
score()->setGraceNote(ch, p, NoteType::GRACE32, MScore::division / 8);
score()->setGraceNote(ch, p, NoteType::GRACE32, Constant::division / 8);
}
}
delete e;

18
src/engraving/libmscore/rendermidi.cpp
View file

@ -267,7 +267,7 @@ void Score::updateChannel()
//---------------------------------------------------------
int toMilliseconds(float tempo, float midiTime)
{
float ticksPerSecond = (float)MScore::division * tempo;
float ticksPerSecond = (float)Constant::division * tempo;
int time = (int)((midiTime / ticksPerSecond) * 1000.0f);
if (time > 0x7fff) { //maximum possible value
time = 0x7fff;
@ -1244,7 +1244,7 @@ void MidiRenderer::renderSpanners(const Chunk& chunk, EventMap* events)
}
int j = 0;
int delta = MScore::division / 8; // 1/8 note
int delta = Constant::division / 8; // 1/8 note
int lastPointTick = stick;
while (lastPointTick < etick) {
int pitch = (j % 4 < 2) ? spitch : epitch;
@ -1379,7 +1379,7 @@ void renderTremolo(Chord* chord, QList<NoteEventList>& ell)
// render tremolo with multiple events
if (chord->tremoloChordType() == TremoloChordType::TremoloFirstNote) {
int t = MScore::division / (1 << (tremolo->lines() + chord->durationType().hooks()));
int t = Constant::division / (1 << (tremolo->lines() + chord->durationType().hooks()));
if (t == 0) { // avoid crash on very short tremolo
t = 1;
}
@ -1455,7 +1455,7 @@ void renderTremolo(Chord* chord, QList<NoteEventList>& ell)
events->clear();
}
} else if (chord->tremoloChordType() == TremoloChordType::TremoloSingle) {
int t = MScore::division / (1 << (tremolo->lines() + chord->durationType().hooks()));
int t = Constant::division / (1 << (tremolo->lines() + chord->durationType().hooks()));
if (t == 0) { // avoid crash on very short tremolo
t = 1;
}
@ -1653,7 +1653,7 @@ int totalTiedNoteTicks(Note* note)
// renderNoteArticulation
// prefix, vector of int, normally something like {0,-1,0,1} modeling the prefix of tremblement relative to the base note
// body, vector of int, normally something like {0,-1,0,1} modeling the possibly repeated tremblement relative to the base note
// tickspernote, number of ticks, either _16h or _32nd, i.e., MScore::division/4 or MScore::division/8
// tickspernote, number of ticks, either _16h or _32nd, i.e., Constant::division/4 or Constant::division/8
// repeatp, true means repeat the body as many times as possible to fill the time slice.
// sustainp, true means the last note of the body is sustained to fill remaining time slice
//---------------------------------------------------------
@ -1686,7 +1686,7 @@ bool renderNoteArticulation(NoteEventList* events, Note* note, bool chromatic, i
Fraction tick = chord->tick();
qreal tempo = chord->score()->tempo(tick);
int ticksPerSecond = tempo * MScore::division;
int ticksPerSecond = tempo * Constant::division;
int minTicksPerNote = int(ticksPerSecond / fastestFreq);
int maxTicksPerNote = (0 == slowestFreq) ? 0 : int(ticksPerSecond / slowestFreq);
@ -1883,7 +1883,7 @@ struct OrnamentExcursion {
std::set<MScore::OrnamentStyle> baroque = { MScore::OrnamentStyle::BAROQUE };
std::set<MScore::OrnamentStyle> defstyle = { MScore::OrnamentStyle::DEFAULT };
std::set<MScore::OrnamentStyle> any; // empty set has the special meaning of any-style, rather than no-styles.
int _16th = MScore::division / 4;
int _16th = Constant::division / 4;
int _32nd = _16th / 2;
std::vector<OrnamentExcursion> excursions = {
@ -2045,7 +2045,7 @@ void renderGlissando(NoteEventList* events, Note* notestart)
if (spanner->type() == ElementType::GLISSANDO
&& toGlissando(spanner)->playGlissando()
&& glissandoPitchOffsets(spanner, body)) {
renderNoteArticulation(events, notestart, true, MScore::division, empty, body, false, true, empty, 16, 0);
renderNoteArticulation(events, notestart, true, Constant::division, empty, body, false, true, empty, 16, 0);
}
}
}
@ -2237,7 +2237,7 @@ void Score::createGraceNotesPlayEvents(const Fraction& tick, Chord* chord, int&
int graceDuration = 0;
bool drumset = (getDrumset(chord) != nullptr);
const qreal ticksPerSecond = tempo(tick) * MScore::division;
const qreal ticksPerSecond = tempo(tick) * Constant::division;
const qreal chordTimeMS = (chord->actualTicks().ticks() / ticksPerSecond) * 1000;
if (drumset) {
int flamDuration = 15; //ms

2
src/engraving/libmscore/score.cpp
View file

@ -321,7 +321,7 @@ Score::Score()
_scoreFont = ScoreFont::fontByName("Leland");
_fileDivision = MScore::division;
_fileDivision = Constant::division;
_style = DefaultStyle::defaultStyle();
// accInfo = tr("No selection"); // ??
accInfo = "No selection";

2
src/engraving/libmscore/score.h
View file

@ -847,7 +847,7 @@ public:
EngravingItem* getScoreElementOfMeasureBase(MeasureBase*) const;
void cmd(const QString&, EditData&);
int fileDivision(int t) const { return ((qint64)t * MScore::division + _fileDivision / 2) / _fileDivision; }
int fileDivision(int t) const { return ((qint64)t * Constant::division + _fileDivision / 2) / _fileDivision; }
void setFileDivision(int t) { _fileDivision = t; }
QString importedFilePath() const { return _importedFilePath; }

2
src/engraving/libmscore/scorefile.cpp
View file

@ -148,7 +148,7 @@ void Score::write(XmlWriter& xml, bool selectionOnly, compat::WriteScoreHook& ho
if (pageNumberOffset()) {
xml.tag("page-offset", pageNumberOffset());
}
xml.tag("Division", MScore::division);
xml.tag("Division", Constant::division);
xml.setCurTrack(-1);
hook.onWriteStyle302(this, xml);

10
src/engraving/libmscore/sig.cpp
View file

@ -32,8 +32,8 @@ namespace Ms {
int ticks_beat(int n)
{
int m = (MScore::division * 4) / n;
if ((MScore::division* 4) % n) {
int m = (Constant::division * 4) / n;
if ((Constant::division* 4) % n) {
qFatal("Mscore: ticks_beat(): bad divisor %d", n);
}
return m;
@ -45,7 +45,7 @@ int ticks_beat(int n)
static int ticks_measure(const Fraction& f)
{
return (MScore::division * 4 * f.numerator()) / f.denominator();
return (Constant::division * 4 * f.numerator()) / f.denominator();
}
//---------------------------------------------------------
@ -437,7 +437,7 @@ void SigEvent::write(XmlWriter& xml, int tick) const
int SigEvent::read(XmlReader& e, int fileDivision)
{
int tick = e.intAttribute("tick", 0);
tick = tick * MScore::division / fileDivision;
tick = tick * Constant::division / fileDivision;
int numerator = 1;
int denominator = 1;
@ -576,6 +576,6 @@ void TimeSigMap::dump() const
int TimeSigFrac::dUnitTicks() const
{
return (4 * MScore::division) / denominator();
return (4 * Constant::division) / denominator();
}
}

4
src/engraving/libmscore/staff.cpp
View file

@ -999,9 +999,9 @@ SwingParameters Staff::swing(const Fraction& tick) const
QString unit = score()->styleSt(Sid::swingUnit);
int swingRatio = score()->styleI(Sid::swingRatio);
if (unit == TDuration(TDuration::DurationType::V_EIGHTH).name()) {
swingUnit = MScore::division / 2;
swingUnit = Constant::division / 2;
} else if (unit == TDuration(TDuration::DurationType::V_16TH).name()) {
swingUnit = MScore::division / 4;
swingUnit = Constant::division / 4;
} else if (unit == TDuration(TDuration::DurationType::V_ZERO).name()) {
swingUnit = 0;
}

10
src/engraving/libmscore/stafftextbase.cpp
View file

@ -37,7 +37,7 @@ namespace Ms {
StaffTextBase::StaffTextBase(const ElementType& type, Segment* parent, Tid tid, ElementFlags flags)
: TextBase(type, parent, tid, flags)
{
setSwingParameters(MScore::division / 2, 60);
setSwingParameters(Constant::division / 2, 60);
}
//---------------------------------------------------------
@ -69,9 +69,9 @@ void StaffTextBase::write(XmlWriter& xml) const
}
if (swing()) {
QString swingUnit;
if (swingParameters()->swingUnit == MScore::division / 2) {
if (swingParameters()->swingUnit == Constant::division / 2) {
swingUnit = TDuration(TDuration::DurationType::V_EIGHTH).name();
} else if (swingParameters()->swingUnit == MScore::division / 4) {
} else if (swingParameters()->swingUnit == Constant::division / 4) {
swingUnit = TDuration(TDuration::DurationType::V_16TH).name();
} else {
swingUnit = TDuration(TDuration::DurationType::V_ZERO).name();
@ -156,9 +156,9 @@ bool StaffTextBase::readProperties(XmlReader& e)
QString swingUnit = e.attribute("unit", "");
int unit = 0;
if (swingUnit == TDuration(TDuration::DurationType::V_EIGHTH).name()) {
unit = MScore::division / 2;
unit = Constant::division / 2;
} else if (swingUnit == TDuration(TDuration::DurationType::V_16TH).name()) {
unit = MScore:: division / 4;
unit = Constant::division / 4;
} else if (swingUnit == TDuration(TDuration::DurationType::V_ZERO).name()) {
unit = 0;
}

6
src/engraving/libmscore/tempo.cpp
View file

@ -122,7 +122,7 @@ void TempoMap::normalize()
e->second.tempo = tempo;
}
int delta = e->first - tick;
time += qreal(delta) / (MScore::division * tempo * _relTempo);
time += qreal(delta) / (Constant::division * tempo * _relTempo);
time += e->second.pause;
e->second.time = time;
tick = e->first;
@ -292,7 +292,7 @@ qreal TempoMap::tick2time(int tick, int* sn) const
if (sn) {
*sn = _tempoSN;
}
time += delta / (MScore::division * tempo * _relTempo);
time += delta / (Constant::division * tempo * _relTempo);
return time;
}
@ -322,7 +322,7 @@ int TempoMap::time2tick(qreal time, int* sn) const
tempo = e->second.tempo;
}
delta = time - delta;
tick += lrint(delta * _relTempo * MScore::division * tempo);
tick += lrint(delta * _relTempo * Constant::division * tempo);
if (sn) {
*sn = _tempoSN;
}

2
src/engraving/rw/compat/read114.cpp
View file

@ -3064,7 +3064,7 @@ Score::FileError Read114::read114(MasterScore* masterScore, XmlReader& e, ReadCo
}
}
masterScore->_fileDivision = MScore::division;
masterScore->_fileDivision = Constants::division;
//
// sanity check for barLineSpan and update ottavas

2
src/engraving/rw/compat/read206.cpp
View file

@ -3405,7 +3405,7 @@ bool Read206::readScore206(Score* score, XmlReader& e, ReadContext& ctx)
score->connectTies();
score->setFileDivision(MScore::division);
score->setFileDivision(Constants::division);
score->fixTicks();

2
src/engraving/rw/compat/read302.cpp
View file

@ -235,7 +235,7 @@ bool Read302::readScore302(Ms::Score* score, XmlReader& e, ReadContext& ctx)
score->connectTies();
score->relayoutForStyles(); // force relayout if certain style settings are enabled
score->_fileDivision = MScore::division;
score->_fileDivision = Constants::division;
// Make sure every instrument has an instrumentId set.
for (Part* part : score->parts()) {

2
src/engraving/rw/read400.cpp
View file

@ -217,7 +217,7 @@ bool Read400::readScore400(Ms::Score* score, XmlReader& e, ReadContext& ctx)
score->connectTies();
score->relayoutForStyles(); // force relayout if certain style settings are enabled
score->_fileDivision = MScore::division;
score->_fileDivision = Constants::division;
// Make sure every instrument has an instrumentId set.
for (Part* part : score->parts()) {

7
src/engraving/types/constants.h
View file

@ -24,10 +24,15 @@
#define MU_ENGRAVING_CONSTANTS_H
namespace mu::engraving {
struct Constant
struct Constants
{
constexpr static int division = 480;
};
}
//! NOTE compat
namespace Ms {
using Constant = mu::engraving::Constants;
}
#endif // MU_ENGRAVING_CONSTANTS_H

20
src/engraving/types/fraction.h
View file

@ -244,11 +244,11 @@ public:
return -1;
}
// MScore::division - ticks per quarter note
// MScore::division * 4 - ticks per whole note
// result: rounded (MScore::division * 4 * m_numerator * 1.0 / m_denominator) value
// Constant::division - ticks per quarter note
// Constant::division * 4 - ticks per whole note
// result: rounded (Constant::division * 4 * m_numerator * 1.0 / m_denominator) value
const int sgn = (m_numerator < 0) ? -1 : 1;
const auto result = sgn * (static_cast<int_least64_t>(sgn * m_numerator) * Constant::division * 4 + (m_denominator / 2))
const auto result = sgn * (static_cast<int_least64_t>(sgn * m_numerator) * Constants::division * 4 + (m_denominator / 2))
/ m_denominator;
return static_cast<int>(result);
}
@ -258,11 +258,11 @@ public:
if (ticks == -1) {
return Fraction(-1, 1); // HACK
}
return Fraction(ticks, Constant::division * 4).reduced();
return Fraction(ticks, Constants::division * 4).reduced();
}
// A very small fraction, corresponds to 1 MIDI tick
static Fraction eps() { return Fraction(1, Constant::division * 4); }
static Fraction eps() { return Fraction(1, Constants::division * 4); }
QString toString() const { return QString("%1/%2").arg(m_numerator).arg(m_denominator); }
static Fraction fromString(const QString& str)
@ -270,14 +270,6 @@ public:
const int i = str.indexOf('/');
return (i == -1) ? Fraction(str.toInt(), 1) : Fraction(str.leftRef(i).toInt(), str.midRef(i + 1).toInt());
}
// QVariantMap toMap() const
// {
// return {
// { "numerator", numerator() },
// { "denominator", denominator() }
// };
// }
};
inline Fraction operator*(const Fraction& f, int v) { return Fraction(f) *= v; }

2
src/engraving/utests/note_tests.cpp
View file

@ -321,7 +321,7 @@ TEST_F(NoteTests, grace)
Note* note = chord->upNote();
// create
score->setGraceNote(chord, note->pitch(), NoteType::APPOGGIATURA, MScore::division / 2);
score->setGraceNote(chord, note->pitch(), NoteType::APPOGGIATURA, Constants::division / 2);
Ms::Chord* gc = chord->graceNotes().first();
Note* gn = gc->notes().front();
// Note* n = static_cast<Note*>(ScoreRW::writeReadElement(gn));

2
src/engraving/utests/selectionrangedelete_tests.cpp
View file

@ -66,7 +66,7 @@ void SelectionRangeDeleteTests::verifyNoDelete(MasterScore* score, size_t spanne
static EngravingItem* chordRestAtBeat(Score* score, int beat, int half = 0)
{
int division = MScore::division;
int division = Constants::division;
int tick = beat * division + half * division / 2;
return score->tick2segment(Fraction::fromTicks(tick), false, SegmentType::ChordRest, false)->element(0);
}

44
src/importexport/bb/internal/bb.cpp
View file

@ -354,7 +354,7 @@ bool BBFile::read(const QString& name)
continue;
}
Event note(ME_NOTE);
note.setOntime((tick.ticks() * MScore::division) / bbDivision);
note.setOntime((tick.ticks() * Constant::division) / bbDivision);
note.setPitch(a[idx + 5]);
note.setVelo(a[idx + 6]);
note.setChannel(channel);
@ -367,7 +367,7 @@ bool BBFile::read(const QString& name)
len1 = lastLen;
}
lastLen = len1;
note.setDuration((len1* MScore::division) / bbDivision);
note.setDuration((len1* Constant::division) / bbDivision);
track->append(note);
} else if (type == 0xb0 || type == 0xc0) {
// ignore controller
@ -497,7 +497,7 @@ Score::FileError importBB(MasterScore* score, const QString& name)
14, 9, 16, 11, 18, 13, 8, 15, 10, 17, 12, 19, 21, 23, 20, 22, 24
};
foreach (const BBChord& c, bb.chords()) {
Fraction tick = Fraction(c.beat, 4); // c.beat * MScore::division;
Fraction tick = Fraction(c.beat, 4); // c.beat * Constant::division;
// qDebug("CHORD %d %d", c.beat, tick);
Measure* m = score->tick2measure(tick);
if (m == 0) {
@ -789,7 +789,7 @@ void BBFile::convertTrack(Score* score, BBTrack* track, int staffIdx)
void BBTrack::quantize(int startTick, int endTick, EventList* dst)
{
int mintick = MScore::division * 64;
int mintick = Constant::division * 64;
iEvent i = _events.begin();
for (; i != _events.end(); ++i) {
if (i->ontime() >= startTick) {
@ -806,26 +806,26 @@ void BBTrack::quantize(int startTick, int endTick, EventList* dst)
mintick = e.duration();
}
}
if (mintick <= MScore::division / 16) { // minimum duration is 1/64
mintick = MScore::division / 16;
} else if (mintick <= MScore::division / 8) {
mintick = MScore::division / 8;
} else if (mintick <= MScore::division / 4) {
mintick = MScore::division / 4;
} else if (mintick <= MScore::division / 2) {
mintick = MScore::division / 2;
} else if (mintick <= MScore::division) {
mintick = MScore::division;
} else if (mintick <= MScore::division* 2) {
mintick = MScore::division * 2;
} else if (mintick <= MScore::division* 4) {
mintick = MScore::division * 4;
} else if (mintick <= MScore::division* 8) {
mintick = MScore::division * 8;
if (mintick <= Constant::division / 16) { // minimum duration is 1/64
mintick = Constant::division / 16;
} else if (mintick <= Constant::division / 8) {
mintick = Constant::division / 8;
} else if (mintick <= Constant::division / 4) {
mintick = Constant::division / 4;
} else if (mintick <= Constant::division / 2) {
mintick = Constant::division / 2;
} else if (mintick <= Constant::division) {
mintick = Constant::division;
} else if (mintick <= Constant::division* 2) {
mintick = Constant::division * 2;
} else if (mintick <= Constant::division* 4) {
mintick = Constant::division * 4;
} else if (mintick <= Constant::division* 8) {
mintick = Constant::division * 8;
}
int raster;
if (mintick > MScore::division) {
raster = MScore::division;
if (mintick > Constant::division) {
raster = Constant::division;
} else {
raster = mintick;
}

2
src/importexport/bww/internal/bww/importbww.cpp
View file

@ -342,7 +342,7 @@ void MsScWriter::note(const QString pitch, const QVector<Bww::BeamType> beamList
}
StepAlterOct sao = stepAlterOctMap.value(pitch);
int ticks = 4 * Ms::MScore::division / type.toInt();
int ticks = 4 * Ms::Constant::division / type.toInt();
if (dots) {
ticks = 3 * ticks / 2;
}

10
src/importexport/guitarpro_old/internal/importgtp-gp4.cpp
View file

@ -308,13 +308,13 @@ bool GuitarPro4::readNote(int string, int staffIdx, Note* note)
int transition = readUChar(); // grace transition
int duration = readUChar(); // grace duration
int grace_len = MScore::division / 8;
int grace_len = Constant::division / 8;
if (duration == 1) {
grace_len = MScore::division / 8; //32nd
grace_len = Constant::division / 8; //32nd
} else if (duration == 2) {
grace_len = MScore::division / 6; //24th
grace_len = Constant::division / 6; //24th
} else if (duration == 3) {
grace_len = MScore::division / 4; //16th
grace_len = Constant::division / 4; //16th
}
Note* gn = Factory::createNote(score->dummy()->chord());
@ -338,7 +338,7 @@ bool GuitarPro4::readNote(int string, int staffIdx, Note* note)
TDuration d;
d.setVal(grace_len);
if (grace_len == MScore::division / 6) {
if (grace_len == Constant::division / 6) {
d.setDots(1);
}
gc->setDurationType(d);

2
src/importexport/guitarpro_old/internal/importgtp-gp5.cpp
View file

@ -985,7 +985,7 @@ bool GuitarPro5::readNoteEffects(Note* note)
}
int grace_pitch = note->staff()->part()->instrument()->stringData()->getPitch(note->string(), fret, nullptr);
auto gnote = score->setGraceNote(note->chord(), grace_pitch, note_type, MScore::division / 2);
auto gnote = score->setGraceNote(note->chord(), grace_pitch, note_type, Constant::division / 2);
gnote->setString(note->string());
auto sd = note->part()->instrument()->stringData();
gnote->setFret(grace_pitch - sd->stringList().at(sd->stringList().size() - note->string() - 1).pitch);

4
src/importexport/guitarpro_old/internal/importgtp-gp6.cpp
View file

@ -1587,7 +1587,7 @@ Fraction GuitarPro6::readBeats(QString beats, GPPartInfo* partInfo, Measure* mea
auto chord = lyrNote->chord();
// before beat grace notes have to be handled after the Tpc is set from pitch
if (!graceNode.toElement().text().compare("OnBeat")) {
auto gNote = score->setGraceNote(chord, lyrNote->pitch(), NoteType::GRACE4, MScore::division / 2);
auto gNote = score->setGraceNote(chord, lyrNote->pitch(), NoteType::GRACE4, Constant::division / 2);
auto iter1 = slideMap.end();
for (auto beg = slideMap.begin(); beg != slideMap.end(); ++beg) {
if (beg->second == lyrNote) {
@ -1605,7 +1605,7 @@ Fraction GuitarPro6::readBeats(QString beats, GPPartInfo* partInfo, Measure* mea
lyrNote = nullptr;
}
} else if (!graceNode.toElement().text().compare("BeforeBeat") && chord->type() == ElementType::CHORD) {
auto gNote = score->setGraceNote(chord, lyrNote->pitch(), NoteType::ACCIACCATURA, MScore::division / 2);
auto gNote = score->setGraceNote(chord, lyrNote->pitch(), NoteType::ACCIACCATURA, Constant::division / 2);
auto iter1 = slideMap.end();
for (auto beg = slideMap.begin(); beg != slideMap.end(); ++beg) {
if (beg->second == lyrNote) {

10
src/importexport/guitarpro_old/internal/importgtp.cpp
View file

@ -1923,13 +1923,13 @@ bool GuitarPro1::readNote(int string, Note* note)
int transition = readUChar(); // grace transition
int duration = readUChar(); // grace duration
int grace_len = MScore::division / 8;
int grace_len = Constant::division / 8;
if (duration == 1) {
grace_len = MScore::division / 8; //32nd
grace_len = Constant::division / 8; //32nd
} else if (duration == 2) {
grace_len = MScore::division / 6; //24th
grace_len = Constant::division / 6; //24th
} else if (duration == 3) {
grace_len = MScore::division / 4; //16th
grace_len = Constant::division / 4; //16th
}
Note* gn = Factory::createNote(score->dummy()->chord());
@ -1954,7 +1954,7 @@ bool GuitarPro1::readNote(int string, Note* note)
gc = Factory::createChord(score->dummy()->segment());
TDuration d;
d.setVal(grace_len);
if (grace_len == MScore::division / 6) {
if (grace_len == Constant::division / 6) {
d.setDots(1);
}
gc->setDurationType(d);

2
src/importexport/midi/internal/midiconfiguration.cpp
View file

@ -35,7 +35,7 @@ static const Settings::Key EXPORTRPNS_KEY("iex_midi", "io/midi/exportRPNs");
void MidiConfiguration::init()
{
settings()->setDefaultValue(SHORTEST_NOTE_KEY, Val(Ms::MScore::division / 4));
settings()->setDefaultValue(SHORTEST_NOTE_KEY, Val(Ms::Constant::division / 4));
settings()->setDefaultValue(EXPORTRPNS_KEY, Val(false));
}

4
src/importexport/midi/internal/midiexport/exportmidi.cpp
View file

@ -215,7 +215,7 @@ void ExportMidi::writeHeader()
bool ExportMidi::write(QIODevice* device, bool midiExpandRepeats, bool exportRPNs, const SynthesizerState& synthState)
{
m_midiFile.setDivision(MScore::division);
m_midiFile.setDivision(Constant::division);
m_midiFile.setFormat(1);
QList<MidiTrack>& tracks = m_midiFile.tracks();
@ -408,7 +408,7 @@ void ExportMidi::PauseMap::calculate(const Score* s)
if (tick != startTick) {
Fraction timeSig(sigmap->timesig(tick).timesig());
qreal quarterNotesPerMeasure = (4.0 * timeSig.numerator()) / timeSig.denominator();
int ticksPerMeasure = quarterNotesPerMeasure * MScore::division; // store a full measure of ticks to keep barlines in same places
int ticksPerMeasure = quarterNotesPerMeasure * Constant::division; // store a full measure of ticks to keep barlines in same places
tempomapWithPauses->setTempo(this->addPauseTicks(utick), quarterNotesPerMeasure / it->second.pause); // new tempo for pause
this->insert(std::pair<const int, int>(utick, ticksPerMeasure + this->offsetAtUTick(utick))); // store running total of extra ticks
tempomapWithPauses->setTempo(this->addPauseTicks(utick), it->second.tempo); // restore previous tempo

2
src/importexport/midi/internal/midiimport/importmidi_beat.cpp
View file

@ -423,7 +423,7 @@ void adjustChordsToBeats(std::multimap<int, MTrack>& tracks)
Q_ASSERT_X(beats.size() > 1, "MidiBeat::adjustChordsToBeats", "Human beat count < 2");
const auto newBeatLen = ReducedFraction::fromTicks(MScore::division);
const auto newBeatLen = ReducedFraction::fromTicks(Constant::division);
for (auto trackIt = tracks.begin(); trackIt != tracks.end(); ++trackIt) {
auto& chords = trackIt->second.chords;

2
src/importexport/midi/internal/midiimport/importmidi_chord.cpp
View file

@ -84,7 +84,7 @@ findFirstChordInRange(const std::multimap<ReducedFraction, MidiChord>& chords,
const ReducedFraction& minAllowedDuration()
{
const static auto minDuration = ReducedFraction::fromTicks(MScore::division) / 32;
const static auto minDuration = ReducedFraction::fromTicks(Constant::division) / 32;
return minDuration;
}

16
src/importexport/midi/internal/midiimport/importmidi_fraction.cpp
View file

@ -134,7 +134,7 @@ ReducedFraction::ReducedFraction(const Fraction& fraction)
ReducedFraction ReducedFraction::fromTicks(int ticks)
{
return ReducedFraction(ticks, MScore::division * 4).reduced();
return ReducedFraction(ticks, Constant::division * 4).reduced();
}
ReducedFraction ReducedFraction::reduced() const
@ -155,7 +155,7 @@ int ReducedFraction::ticks() const
{
int integral = numerator_ / denominator_;
int newNumerator = numerator_ % denominator_;
int division = MScore::division * 4;
int division = Constant::division * 4;
#ifdef QT_DEBUG
Q_ASSERT_X(!isMultiplicationOverflow(newNumerator, division),
@ -361,20 +361,20 @@ ReducedFraction toMuseScoreTicks(int tick, int oldDivision, bool isDivisionInTps
const int integral = tick / oldDivision;
const int remainder = tick % oldDivision;
#ifdef QT_DEBUG
Q_ASSERT_X(!isMultiplicationOverflow(remainder, MScore::division),
Q_ASSERT_X(!isMultiplicationOverflow(remainder, Constant::division),
"ReducedFraction::toMuseScoreTicks", "Multiplication overflow");
Q_ASSERT_X(!isAdditionOverflow(remainder * MScore::division, oldDivision / 2),
Q_ASSERT_X(!isAdditionOverflow(remainder * Constant::division, oldDivision / 2),
"ReducedFraction::toMuseScoreTicks", "Addition overflow");
#endif
const int tmp = remainder * MScore::division + oldDivision / 2;
const int tmp = remainder * Constant::division + oldDivision / 2;
#ifdef QT_DEBUG
Q_ASSERT_X(!isDivisionOverflow(tmp, oldDivision),
"ReducedFraction::toMuseScoreTicks", "Division overflow");
Q_ASSERT_X(!isMultiplicationOverflow(integral, MScore::division),
Q_ASSERT_X(!isMultiplicationOverflow(integral, Constant::division),
"ReducedFraction::toMuseScoreTicks", "Multiplication overflow");
Q_ASSERT_X(!isAdditionOverflow(tmp / oldDivision, integral * MScore::division),
Q_ASSERT_X(!isAdditionOverflow(tmp / oldDivision, integral * Constant::division),
"ReducedFraction::toMuseScoreTicks", "Addition overflow");
#endif
return ReducedFraction::fromTicks(tmp / oldDivision + integral * MScore::division);
return ReducedFraction::fromTicks(tmp / oldDivision + integral * Constant::division);
}
} // namespace Ms

2
src/importexport/midi/internal/midiimport/importmidi_meter.cpp
View file

@ -313,7 +313,7 @@ bool isPowerOfTwo(unsigned int x)
bool isSimpleNoteDuration(const ReducedFraction& duration)
{
const auto division = ReducedFraction::fromTicks(MScore::division);
const auto division = ReducedFraction::fromTicks(Constant::division);
auto div = (duration > division) ? duration / division : division / duration;
if (div > ReducedFraction(0, 1)) {
div.reduce();

12
src/importexport/midi/internal/midiimport/importmidi_quant.cpp
View file

@ -44,7 +44,7 @@ namespace Ms {
namespace Quantize {
ReducedFraction quantValueToFraction(MidiOperations::QuantValue quantValue)
{
const auto division = ReducedFraction::fromTicks(MScore::division);
const auto division = ReducedFraction::fromTicks(Constant::division);
ReducedFraction fraction;
switch (quantValue) {
@ -85,7 +85,7 @@ ReducedFraction quantValueToFraction(MidiOperations::QuantValue quantValue)
MidiOperations::QuantValue fractionToQuantValue(const ReducedFraction& fraction)
{
const auto division = ReducedFraction::fromTicks(MScore::division);
const auto division = ReducedFraction::fromTicks(Constant::division);
MidiOperations::QuantValue quantValue = MidiOperations::QuantValue::Q_4;
if (fraction == division) {
@ -119,7 +119,7 @@ MidiOperations::QuantValue fractionToQuantValue(const ReducedFraction& fraction)
MidiOperations::QuantValue defaultQuantValueFromPreferences()
{
auto conf = mu::modularity::ioc()->resolve<mu::iex::midi::IMidiImportExportConfiguration>("iex_midi");
int ticks = conf ? conf->midiShortestNote() : (MScore::division / 4);
int ticks = conf ? conf->midiShortestNote() : (Constant::division / 4);
const auto fraction = ReducedFraction::fromTicks(ticks);
MidiOperations::QuantValue quantValue = fractionToQuantValue(fraction);
if (quantValue == MidiOperations::QuantValue::Q_INVALID) {
@ -133,7 +133,7 @@ ReducedFraction shortestQuantizedNoteInRange(
const std::multimap<ReducedFraction, MidiChord>::const_iterator& beg,
const std::multimap<ReducedFraction, MidiChord>::const_iterator& end)
{
const auto division = ReducedFraction::fromTicks(MScore::division);
const auto division = ReducedFraction::fromTicks(Constant::division);
auto minDuration = division;
for (auto it = beg; it != end; ++it) {
for (const auto& note: it->second.notes) {
@ -401,7 +401,7 @@ bool isHumanPerformance(
return false;
}
const auto basicQuant = ReducedFraction::fromTicks(MScore::division) / 4; // 1/16
const auto basicQuant = ReducedFraction::fromTicks(Constant::division) / 4; // 1/16
int matches = 0;
int count = 0;
@ -473,7 +473,7 @@ void setIfHumanPerformance(
if (opers.maxVoiceCount.canRedefineDefaultLater()) {
opers.maxVoiceCount.setDefaultValue(MidiOperations::VoiceCount::V_2);
}
const double ticksPerSec = MidiTempo::findBasicTempo(tracks, true) * MScore::division;
const double ticksPerSec = MidiTempo::findBasicTempo(tracks, true) * Constant::division;
MidiBeat::findBeatLocations(allChords, sigmap, ticksPerSec); // and set time sig
}
}

2
src/importexport/midi/internal/midiimport/importmidi_simplify.cpp
View file

@ -189,7 +189,7 @@ void shortenDrumNote(
}
if (next != chords.end()) {
const auto len = ReducedFraction::fromTicks(
MScore::division) / 8; // 1/32
Constant::division) / 8; // 1/32
auto newOffTime = it->first + len;
if (next->second.isInTuplet) {
const auto& tuplet = next->second.tuplet->second;

4
src/importexport/midi/internal/midiimport/importmidi_swing.cpp
View file

@ -68,7 +68,7 @@ void SwingDetector::add(ChordRest* cr)
return;
}
const int tickInBar = (cr->tick() - cr->measure()->tick()).ticks();
if (tickInBar % MScore::division == 0) {
if (tickInBar % Constant::division == 0) {
append(cr);
}
} else {
@ -170,7 +170,7 @@ void SwingDetector::applySwing()
const int startTick = first->segment()->tick().ticks();
ChordRest* last = elements.back();
last->segment()->remove(last);
Segment* s = last->measure()->getSegment(SegmentType::ChordRest, Fraction::fromTicks(startTick + MScore::division / 2));
Segment* s = last->measure()->getSegment(SegmentType::ChordRest, Fraction::fromTicks(startTick + Constant::division / 2));
s->add(last);
if (elements.size() == 3) {

4
src/importexport/midi/internal/midiimport/importmidi_tempo.cpp
View file

@ -104,7 +104,7 @@ void applyAllTempoEvents(const std::multimap<int, MTrack>& tracks, Score* score)
{
for (const auto& track: tracks) {
if (track.second.isDivisionInTps) { // ticks per second
const double ticksPerBeat = MScore::division;
const double ticksPerBeat = Constant::division;
const double beatsPerSecond = roundToBpm(track.second.division / ticksPerBeat);
setTempoToScore(score, 0, beatsPerSecond);
} else { // beats per second
@ -144,7 +144,7 @@ void setTempo(const std::multimap<int, MTrack>& tracks, Score* score)
int counter = 0;
auto it = beats.begin();
auto beatStart = *it;
const auto newBeatLen = ReducedFraction::fromTicks(MScore::division);
const auto newBeatLen = ReducedFraction::fromTicks(Constant::division);
for (++it; it != beats.end(); ++it) {
const auto& beatEnd = *it;

6
src/importexport/musedata/internal/musedata.cpp
View file

@ -236,7 +236,7 @@ void MuseData::readNote(Part* part, const QString& s)
if (pitch > 127) {
pitch = 127;
}
Fraction ticks = Fraction::fromTicks((s.midRef(5, 3).toInt() * MScore::division + _division / 2) / _division);
Fraction ticks = Fraction::fromTicks((s.midRef(5, 3).toInt() * Constant::division + _division / 2) / _division);
Fraction tick = curTick;
curTick += ticks;
@ -436,7 +436,7 @@ QString MuseData::diacritical(QString s)
void MuseData::readRest(Part* part, const QString& s)
{
Fraction ticks = Fraction::fromTicks((s.midRef(5, 3).toInt() * MScore::division + _division / 2) / _division);
Fraction ticks = Fraction::fromTicks((s.midRef(5, 3).toInt() * Constant::division + _division / 2) / _division);
Fraction tick = curTick;
curTick += ticks;
@ -480,7 +480,7 @@ void MuseData::readRest(Part* part, const QString& s)
void MuseData::readBackup(const QString& s)
{
Fraction ticks = Fraction::fromTicks((s.midRef(5, 3).toInt() * MScore::division + _division / 2) / _division);
Fraction ticks = Fraction::fromTicks((s.midRef(5, 3).toInt() * Constant::division + _division / 2) / _division);
if (s[0] == 'b') {
curTick -= ticks;
} else {

6
src/importexport/musicxml/internal/musicxml/exportxml.cpp
View file

@ -1178,7 +1178,7 @@ void ExportMusicXml::calcDivisions()
// init
integers.clear();
primes.clear();
integers.append(MScore::division);
integers.append(Constant::division);
primes.append(2);
primes.append(3);
primes.append(5);
@ -1250,7 +1250,7 @@ void ExportMusicXml::calcDivisions()
}
}
div = MScore::division / integers[0];
div = Constant::division / integers[0];
#ifdef DEBUG_TICK
qDebug("divisions=%d div=%d", integers[0], div);
#endif
@ -6954,7 +6954,7 @@ void ExportMusicXml::writeMeasure(const Measure* const m,
// output attributes with the first actual measure (pickup or regular)
if (isFirstActualMeasure) {
_attr.doAttr(_xml, true);
_xml.tag("divisions", MScore::division / div);
_xml.tag("divisions", Constant::division / div);
}
// output attributes at start of measure: key, time

4
src/importexport/musicxml/internal/musicxml/importmxmlpass2.cpp
View file

@ -274,8 +274,8 @@ static void fillGap(Measure* measure, int track, const Fraction& tstart, const F
Fraction restLen = tend - tstart;
// qDebug("\nfillGIFV fillGap(measure %p track %d tstart %d tend %d) restLen %d len",
// measure, track, tstart, tend, restLen);
// note: as MScore::division (#ticks in a quarter note) equals 480
// MScore::division / 64 (#ticks in a 256th note) equals 7.5 but is rounded down to 7
// note: as Constant::division (#ticks in a quarter note) equals 480
// Constant::division / 64 (#ticks in a 256th note) equals 7.5 but is rounded down to 7
while (restLen > Fraction(1, 256)) {
Fraction len = restLen;
TDuration d(TDuration::DurationType::V_INVALID);

2
src/notation/internal/masternotationmididata.cpp
View file

@ -209,7 +209,7 @@ MidiMapping MasterNotationMidiData::buildMidiMapping(const Ms::Part* part) const
{
midi::MidiMapping mapping;
mapping.division = Ms::MScore::division;
mapping.division = Ms::Constant::division;
mapping.tempo = makeTempoMap();
for (auto it = part->instruments()->cbegin(); it != part->instruments()->cend(); ++it) {

2
src/notation/internal/notationconfiguration.cpp
View file

@ -536,7 +536,7 @@ std::string NotationConfiguration::notationRevision() const
int NotationConfiguration::notationDivision() const
{
return Ms::MScore::division;
return Ms::Constant::division;
}
ValCh<Orientation> NotationConfiguration::canvasOrientation() const

2
src/notation/internal/notationinteraction.cpp
View file

@ -2658,7 +2658,7 @@ void NotationInteraction::addGraceNotesToSelectedNotes(GraceNoteType type)
}
startEdit();
score()->cmdAddGrace(type, Ms::MScore::division / denominator);
score()->cmdAddGrace(type, Ms::Constant::division / denominator);
apply();
notifyAboutNotationChanged();

8
src/notation/view/widgets/stafftextpropertiesdialog.cpp
View file

@ -188,11 +188,11 @@ StaffTextPropertiesDialog::StaffTextPropertiesDialog(QWidget* parent)
if (m_staffText->swing()) {
setSwingBox->setChecked(true);
if (m_staffText->swingParameters()->swingUnit == MScore::division / 2) {
if (m_staffText->swingParameters()->swingUnit == Constant::division / 2) {
swingBox->setEnabled(true);
swingEighth->setChecked(true);
swingBox->setValue(m_staffText->swingParameters()->swingRatio);
} else if (m_staffText->swingParameters()->swingUnit == MScore::division / 4) {
} else if (m_staffText->swingParameters()->swingUnit == Constant::division / 4) {
swingBox->setEnabled(true);
swingSixteenth->setChecked(true);
swingBox->setValue(m_staffText->swingParameters()->swingRatio);
@ -535,10 +535,10 @@ void StaffTextPropertiesDialog::saveValues()
m_staffText->setSwingParameters(0, swingBox->value());
swingBox->setEnabled(false);
} else if (swingEighth->isChecked()) {
m_staffText->setSwingParameters(MScore::division / 2, swingBox->value());
m_staffText->setSwingParameters(Constant::division / 2, swingBox->value());
swingBox->setEnabled(true);
} else if (swingSixteenth->isChecked()) {
m_staffText->setSwingParameters(MScore::division / 4, swingBox->value());
m_staffText->setSwingParameters(Constant::division / 4, swingBox->value());
swingBox->setEnabled(true);
}
}

2
src/plugins/api/qmlplugin.h
View file

@ -96,7 +96,7 @@ public:
virtual void runPlugin() = 0;
int division() const { return MScore::division; }
int division() const { return Constant::division; }
int mscoreVersion() const { return Ms::version(); }
int mscoreMajorVersion() const { return majorVersion(); }
int mscoreMinorVersion() const { return minorVersion(); }