moved division from MScore to Constant
This commit is contained in:
parent
61586637fd
commit
1101c9d1d5
46 changed files with 136 additions and 141 deletions
|
@ -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
|
||||
|
|
|
@ -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))));
|
||||
}
|
||||
|
||||
//---------------------------------------------------------
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
|
||||
|
|
|
@ -351,7 +351,6 @@ public:
|
|||
static bool debugMode;
|
||||
static bool testMode;
|
||||
|
||||
static int division;
|
||||
static int sampleRate;
|
||||
static int mtcType;
|
||||
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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";
|
||||
|
|
|
@ -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; }
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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();
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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();
|
||||
|
||||
|
|
|
@ -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()) {
|
||||
|
|
|
@ -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()) {
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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; }
|
||||
|
|
|
@ -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));
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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));
|
||||
}
|
||||
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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();
|
||||
|
|
|
@ -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
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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 {
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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();
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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(); }
|
||||
|
|
Loading…
Reference in a new issue