1382 lines
42 KiB
C++
1382 lines
42 KiB
C++
/*
|
|
* SPDX-License-Identifier: GPL-3.0-only
|
|
* MuseScore-CLA-applies
|
|
*
|
|
* MuseScore
|
|
* Music Composition & Notation
|
|
*
|
|
* Copyright (C) 2021 MuseScore BVBA and others
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 3 as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "utils.h"
|
|
|
|
#include <cmath>
|
|
#include <map>
|
|
|
|
#include "containers.h"
|
|
|
|
#include "chord.h"
|
|
#include "chordrest.h"
|
|
#include "clef.h"
|
|
#include "keysig.h"
|
|
#include "measure.h"
|
|
#include "note.h"
|
|
#include "page.h"
|
|
#include "part.h"
|
|
#include "pitchspelling.h"
|
|
#include "rest.h"
|
|
#include "score.h"
|
|
#include "segment.h"
|
|
#include "sig.h"
|
|
#include "staff.h"
|
|
#include "system.h"
|
|
#include "tuplet.h"
|
|
|
|
#include "log.h"
|
|
|
|
using namespace mu;
|
|
|
|
namespace mu::engraving {
|
|
//---------------------------------------------------------
|
|
// handleRect
|
|
//---------------------------------------------------------
|
|
|
|
RectF handleRect(const PointF& pos)
|
|
{
|
|
return RectF(pos.x() - 4, pos.y() - 4, 8, 8);
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// tick2measure
|
|
//---------------------------------------------------------
|
|
|
|
Measure* Score::tick2measure(const Fraction& tick) const
|
|
{
|
|
if (tick == Fraction(-1, 1)) { // special number
|
|
return lastMeasure();
|
|
}
|
|
if (tick <= Fraction(0, 1)) {
|
|
return firstMeasure();
|
|
}
|
|
|
|
Measure* lm = 0;
|
|
for (Measure* m = firstMeasure(); m; m = m->nextMeasure()) {
|
|
if (tick < m->tick()) {
|
|
assert(lm);
|
|
return lm;
|
|
}
|
|
lm = m;
|
|
}
|
|
// check last measure
|
|
if (lm && (tick >= lm->tick()) && (tick <= lm->endTick())) {
|
|
return lm;
|
|
}
|
|
LOGD("tick2measure %d (max %d) not found", tick.ticks(), lm ? lm->tick().ticks() : -1);
|
|
return 0;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// tick2measureMM
|
|
//---------------------------------------------------------
|
|
|
|
Measure* Score::tick2measureMM(const Fraction& t) const
|
|
{
|
|
Fraction tick(t);
|
|
if (tick == Fraction(-1, 1)) {
|
|
return lastMeasureMM();
|
|
}
|
|
if (tick < Fraction(0, 1)) {
|
|
tick = Fraction(0, 1);
|
|
}
|
|
|
|
Measure* lm = 0;
|
|
|
|
for (Measure* m = firstMeasureMM(); m; m = m->nextMeasureMM()) {
|
|
if (tick < m->tick()) {
|
|
assert(lm);
|
|
return lm;
|
|
}
|
|
lm = m;
|
|
}
|
|
// check last measure
|
|
if (lm && (tick >= lm->tick()) && (tick <= lm->endTick())) {
|
|
return lm;
|
|
}
|
|
LOGD("tick2measureMM %d (max %d) not found", tick.ticks(), lm ? lm->tick().ticks() : -1);
|
|
return 0;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// tick2measureBase
|
|
//---------------------------------------------------------
|
|
|
|
MeasureBase* Score::tick2measureBase(const Fraction& tick) const
|
|
{
|
|
for (MeasureBase* mb = first(); mb; mb = mb->next()) {
|
|
Fraction st = mb->tick();
|
|
Fraction l = mb->ticks();
|
|
if (tick >= st && tick < (st + l)) {
|
|
return mb;
|
|
}
|
|
}
|
|
// LOGD("tick2measureBase %d not found", tick);
|
|
return 0;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// tick2segment
|
|
//---------------------------------------------------------
|
|
|
|
Segment* Score::tick2segmentMM(const Fraction& tick, bool first, SegmentType st) const
|
|
{
|
|
return tick2segment(tick, first, st, true);
|
|
}
|
|
|
|
Segment* Score::tick2segmentMM(const Fraction& tick) const
|
|
{
|
|
return tick2segment(tick, false, SegmentType::All, true);
|
|
}
|
|
|
|
Segment* Score::tick2segmentMM(const Fraction& tick, bool first) const
|
|
{
|
|
return tick2segment(tick, first, SegmentType::All, true);
|
|
}
|
|
|
|
Segment* Score::tick2segment(const Fraction& t, bool first, SegmentType st, bool useMMrest) const
|
|
{
|
|
Fraction tick(t);
|
|
Measure* m;
|
|
if (useMMrest) {
|
|
m = tick2measureMM(tick);
|
|
// When mmRest force tick to the first segment of mmRest.
|
|
if (m && m->isMMRest() && tick != m->endTick()) {
|
|
tick = m->tick();
|
|
}
|
|
} else {
|
|
m = tick2measure(tick);
|
|
}
|
|
|
|
if (m == 0) {
|
|
LOGD("no measure for tick %d", tick.ticks());
|
|
return 0;
|
|
}
|
|
for (Segment* segment = m->first(st); segment;) {
|
|
Fraction t1 = segment->tick();
|
|
Segment* nsegment = segment->next(st);
|
|
if (tick == t1) {
|
|
if (first) {
|
|
return segment;
|
|
} else {
|
|
if (!nsegment || tick < nsegment->tick()) {
|
|
return segment;
|
|
}
|
|
}
|
|
}
|
|
segment = nsegment;
|
|
}
|
|
LOGD("no segment for tick %d (start search at %d (measure %d))", tick.ticks(), t.ticks(), m->tick().ticks());
|
|
return 0;
|
|
}
|
|
|
|
Segment* Score::tick2segment(const Fraction& tick) const
|
|
{
|
|
return tick2segment(tick, false, SegmentType::All, false);
|
|
}
|
|
|
|
Segment* Score::tick2segment(const Fraction& tick, bool first) const
|
|
{
|
|
return tick2segment(tick, first, SegmentType::All, false);
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// tick2leftSegment
|
|
/// return the segment at this tick position if any or
|
|
/// the first segment *before* this tick position
|
|
//---------------------------------------------------------
|
|
|
|
Segment* Score::tick2leftSegment(const Fraction& tick, bool useMMrest, bool anySegmentType) const
|
|
{
|
|
Measure* m = useMMrest ? tick2measureMM(tick) : tick2measure(tick);
|
|
if (m == 0) {
|
|
LOGD("tick2leftSegment(): not found tick %d", tick.ticks());
|
|
return 0;
|
|
}
|
|
|
|
// loop over all segments
|
|
SegmentType segmentType = anySegmentType ? SegmentType::All : SegmentType::ChordRest;
|
|
Segment* ps = 0;
|
|
for (Segment* s = m->first(segmentType); s; s = s->next(segmentType)) {
|
|
if (tick < s->tick()) {
|
|
return ps;
|
|
} else if (tick == s->tick()) {
|
|
return s;
|
|
}
|
|
ps = s;
|
|
}
|
|
return ps;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// tick2rightSegment
|
|
/// return the segment at this tick position if any or
|
|
/// the first segment *after* this tick position
|
|
//---------------------------------------------------------
|
|
|
|
Segment* Score::tick2rightSegment(const Fraction& tick, bool useMMrest) const
|
|
{
|
|
Measure* m = useMMrest ? tick2measureMM(tick) : tick2measure(tick);
|
|
if (m == 0) {
|
|
//LOGD("tick2nearestSegment(): not found tick %d", tick.ticks());
|
|
return 0;
|
|
}
|
|
// loop over all segments
|
|
for (Segment* s = m->first(SegmentType::ChordRest); s; s = s->next1(SegmentType::ChordRest)) {
|
|
if (tick <= s->tick()) {
|
|
return s;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// tick2beatType
|
|
//---------------------------------------------------------
|
|
|
|
BeatType Score::tick2beatType(const Fraction& tick) const
|
|
{
|
|
Measure* m = tick2measure(tick);
|
|
Fraction msrTick = m->tick();
|
|
TimeSigFrac timeSig = sigmap()->timesig(msrTick).nominal();
|
|
|
|
int rtick = (tick - msrTick).ticks();
|
|
|
|
if (m->isAnacrusis()) { // measure is incomplete (anacrusis)
|
|
rtick += timeSig.ticksPerMeasure() - m->ticks().ticks();
|
|
}
|
|
|
|
return timeSig.rtick2beatType(rtick);
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// getStaff
|
|
//---------------------------------------------------------
|
|
|
|
int getStaff(System* system, const PointF& p)
|
|
{
|
|
PointF pp = p - system->page()->pos() - system->pos();
|
|
for (size_t i = 0; i < system->page()->score()->nstaves(); ++i) {
|
|
double sp = system->spatium();
|
|
RectF r = system->bboxStaff(static_cast<int>(i)).adjusted(0.0, -sp, 0.0, sp);
|
|
if (r.contains(pp)) {
|
|
return static_cast<int>(i);
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// nextSeg
|
|
//---------------------------------------------------------
|
|
|
|
Fraction Score::nextSeg(const Fraction& tick, int track)
|
|
{
|
|
Segment* seg = tick2segment(tick);
|
|
while (seg) {
|
|
seg = seg->next1(SegmentType::ChordRest);
|
|
if (seg == 0) {
|
|
break;
|
|
}
|
|
if (seg->element(track)) {
|
|
break;
|
|
}
|
|
}
|
|
return seg ? seg->tick() : Fraction(-1, 1);
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// nextSeg1
|
|
//---------------------------------------------------------
|
|
|
|
Segment* nextSeg1(Segment* seg, track_idx_t& track)
|
|
{
|
|
staff_idx_t staffIdx = track / VOICES;
|
|
track_idx_t startTrack = staffIdx * VOICES;
|
|
track_idx_t endTrack = startTrack + VOICES;
|
|
while ((seg = seg->next1(SegmentType::ChordRest))) {
|
|
for (track_idx_t t = startTrack; t < endTrack; ++t) {
|
|
if (seg->element(t)) {
|
|
track = t;
|
|
return seg;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// prevSeg1
|
|
//---------------------------------------------------------
|
|
|
|
Segment* prevSeg1(Segment* seg, track_idx_t& track)
|
|
{
|
|
staff_idx_t staffIdx = track / VOICES;
|
|
track_idx_t startTrack = staffIdx * VOICES;
|
|
track_idx_t endTrack = startTrack + VOICES;
|
|
while ((seg = seg->prev1(SegmentType::ChordRest))) {
|
|
for (track_idx_t t = startTrack; t < endTrack; ++t) {
|
|
if (seg->element(t)) {
|
|
track = t;
|
|
return seg;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// next/prevChordNote
|
|
//
|
|
// returns the top note of the next/previous chord. If a
|
|
// chord exists in the same track as note,
|
|
// it is used. If not, the topmost existing chord is used.
|
|
// May return nullptr if there is no next/prev note
|
|
//---------------------------------------------------------
|
|
|
|
Note* nextChordNote(Note* note)
|
|
{
|
|
track_idx_t track = note->track();
|
|
track_idx_t fromTrack = (track / VOICES) * VOICES;
|
|
track_idx_t toTrack = fromTrack + VOICES;
|
|
// TODO : limit to same instrument, not simply to same staff!
|
|
Segment* seg = note->chord()->segment()->nextCR(track, true);
|
|
while (seg) {
|
|
EngravingItem* targetElement = seg->elementAt(track);
|
|
// if a chord exists in the same track, return its top note
|
|
if (targetElement && targetElement->isChord()) {
|
|
return toChord(targetElement)->upNote();
|
|
}
|
|
// if not, return topmost chord in track range
|
|
for (track_idx_t i = fromTrack; i < toTrack; i++) {
|
|
targetElement = seg->elementAt(i);
|
|
if (targetElement && targetElement->isChord()) {
|
|
return toChord(targetElement)->upNote();
|
|
}
|
|
}
|
|
seg = seg->nextCR(track, true);
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
Note* prevChordNote(Note* note)
|
|
{
|
|
track_idx_t track = note->track();
|
|
track_idx_t fromTrack = (track / VOICES) * VOICES;
|
|
track_idx_t toTrack = fromTrack + VOICES;
|
|
// TODO : limit to same instrument, not simply to same staff!
|
|
Segment* seg = note->chord()->segment()->prev1();
|
|
while (seg) {
|
|
if (seg->segmentType() == SegmentType::ChordRest) {
|
|
EngravingItem* targetElement = seg->elementAt(track);
|
|
// if a chord exists in the same track, return its top note
|
|
if (targetElement && targetElement->isChord()) {
|
|
return toChord(targetElement)->upNote();
|
|
}
|
|
// if not, return topmost chord in track range
|
|
for (track_idx_t i = fromTrack; i < toTrack; i++) {
|
|
targetElement = seg->elementAt(i);
|
|
if (targetElement && targetElement->isChord()) {
|
|
return toChord(targetElement)->upNote();
|
|
}
|
|
}
|
|
}
|
|
seg = seg->prev1();
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// pitchKeyAdjust
|
|
// change entered note to sounding pitch dependent
|
|
// on key.
|
|
// Example: if F is entered in G-major, a Fis is played
|
|
// key -7 ... +7
|
|
//---------------------------------------------------------
|
|
|
|
int pitchKeyAdjust(int step, Key key)
|
|
{
|
|
static int ptab[15][7] = {
|
|
// c d e f g a b
|
|
{ -1, 1, 3, 4, 6, 8, 10 }, // Bes
|
|
{ -1, 1, 3, 5, 6, 8, 10 }, // Ges
|
|
{ 0, 1, 3, 5, 6, 8, 10 }, // Des
|
|
{ 0, 1, 3, 5, 7, 8, 10 }, // As
|
|
{ 0, 2, 3, 5, 7, 8, 10 }, // Es
|
|
{ 0, 2, 3, 5, 7, 9, 10 }, // B
|
|
{ 0, 2, 4, 5, 7, 9, 10 }, // F
|
|
{ 0, 2, 4, 5, 7, 9, 11 }, // C
|
|
{ 0, 2, 4, 6, 7, 9, 11 }, // G
|
|
{ 1, 2, 4, 6, 7, 9, 11 }, // D
|
|
{ 1, 2, 4, 6, 8, 9, 11 }, // A
|
|
{ 1, 3, 4, 6, 8, 9, 11 }, // E
|
|
{ 1, 3, 4, 6, 8, 10, 11 }, // H
|
|
{ 1, 3, 5, 6, 8, 10, 11 }, // Fis
|
|
{ 1, 3, 5, 6, 8, 10, 12 }, // Cis
|
|
};
|
|
return ptab[int(key) + 7][step];
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// y2pitch
|
|
//---------------------------------------------------------
|
|
|
|
int y2pitch(double y, ClefType clef, double _spatium)
|
|
{
|
|
int l = lrint(y / _spatium * 2.0);
|
|
return line2pitch(l, clef, Key::C);
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// line2pitch
|
|
// key -7 ... +7
|
|
//---------------------------------------------------------
|
|
|
|
int line2pitch(int line, ClefType clef, Key key)
|
|
{
|
|
int l = ClefInfo::pitchOffset(clef) - line;
|
|
int octave = 0;
|
|
if (l < 0) {
|
|
l = 0;
|
|
}
|
|
|
|
octave += l / 7;
|
|
l = l % 7;
|
|
|
|
int pitch = pitchKeyAdjust(l, key) + octave * 12;
|
|
|
|
if (pitch > 127) {
|
|
pitch = 127;
|
|
} else if (pitch < 0) {
|
|
pitch = 0;
|
|
}
|
|
return pitch;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// quantizeLen
|
|
//---------------------------------------------------------
|
|
|
|
int quantizeLen(int len, int raster)
|
|
{
|
|
if (raster == 0) {
|
|
return len;
|
|
}
|
|
return int(((float)len / raster) + 0.5) * raster; //round to the closest multiple of raster
|
|
}
|
|
|
|
static const char16_t* valSharp[] = {
|
|
u"c",
|
|
u"c♯",
|
|
u"d",
|
|
u"d♯",
|
|
u"e",
|
|
u"f",
|
|
u"f♯",
|
|
u"g",
|
|
u"g♯",
|
|
u"a",
|
|
u"a♯",
|
|
u"b"
|
|
};
|
|
static const char16_t* valFlat[] = {
|
|
u"c",
|
|
u"d♭",
|
|
u"d",
|
|
u"e♭",
|
|
u"e",
|
|
u"f",
|
|
u"g♭",
|
|
u"g",
|
|
u"a♭",
|
|
u"a",
|
|
u"b♭",
|
|
u"b"
|
|
};
|
|
|
|
/*!
|
|
* Returns the string representation of the given pitch.
|
|
*
|
|
* Returns the latin letter name, accidental, and octave numeral.
|
|
* Uses upper case only for pitches 0-24.
|
|
*
|
|
* @param v
|
|
* The pitch number of the note.
|
|
*
|
|
* @return
|
|
* The string representation of the note.
|
|
*/
|
|
String pitch2string(int v, bool useFlats)
|
|
{
|
|
if (v < 0 || v > 127) {
|
|
return String(u"----");
|
|
}
|
|
int octave = (v / PITCH_DELTA_OCTAVE) - 1;
|
|
String o;
|
|
o = String::number(octave);
|
|
int i = v % PITCH_DELTA_OCTAVE;
|
|
|
|
String pitchStr = useFlats ? valFlat[i] : valSharp[i];
|
|
if (octave < 0) {
|
|
pitchStr = pitchStr.toUpper();
|
|
}
|
|
|
|
return pitchStr + o;
|
|
}
|
|
|
|
/*!
|
|
* Returns the pitch number of the given string.
|
|
*
|
|
* @param s
|
|
* The string representation of the note.
|
|
*
|
|
* @return
|
|
* The pitch number of the note.
|
|
*/
|
|
int string2pitch(const String& s)
|
|
{
|
|
if (s == String(u"----")) {
|
|
return -1;
|
|
}
|
|
|
|
String value = s;
|
|
|
|
bool negative = s.contains(u'-');
|
|
int octave = String(s[s.size() - 1]).toInt() * (negative ? -1 : 1);
|
|
if (octave < -1 || octave > 9) {
|
|
return -1;
|
|
}
|
|
|
|
value = value.mid(0, value.size() - (negative ? 2 : 1));
|
|
value = value.toLower();
|
|
|
|
int pitchIndex = -1;
|
|
for (int i = 0; i < PITCH_DELTA_OCTAVE; ++i) {
|
|
if (value == valFlat[i] || value == valSharp[i]) {
|
|
pitchIndex = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (pitchIndex == -1) {
|
|
return -1;
|
|
}
|
|
|
|
return (octave + 1) * PITCH_DELTA_OCTAVE + pitchIndex;
|
|
}
|
|
|
|
/*!
|
|
* An array of all supported interval sorted by size.
|
|
*
|
|
* Because intervals can be spelled differently, this array
|
|
* tracks all the different valid intervals. They are arranged
|
|
* in diatonic then chromatic order.
|
|
*/
|
|
Interval intervalList[intervalListSize] = {
|
|
// diatonic - chromatic
|
|
Interval(0, 0), // 0 Perfect Unison
|
|
Interval(0, 1), // 1 Augmented Unison
|
|
|
|
Interval(1, 0), // 2 Diminished Second
|
|
Interval(1, 1), // 3 Minor Second
|
|
Interval(1, 2), // 4 Major Second
|
|
Interval(1, 3), // 5 Augmented Second
|
|
|
|
Interval(2, 2), // 6 Diminished Third
|
|
Interval(2, 3), // 7 Minor Third
|
|
Interval(2, 4), // 8 Major Third
|
|
Interval(2, 5), // 9 Augmented Third
|
|
|
|
Interval(3, 4), // 10 Diminished Fourth
|
|
Interval(3, 5), // 11 Perfect Fourth
|
|
Interval(3, 6), // 12 Augmented Fourth
|
|
|
|
Interval(4, 6), // 13 Diminished Fifth
|
|
Interval(4, 7), // 14 Perfect Fifth
|
|
Interval(4, 8), // 15 Augmented Fifth
|
|
|
|
Interval(5, 7), // 16 Diminished Sixth
|
|
Interval(5, 8), // 17 Minor Sixth
|
|
Interval(5, 9), // 18 Major Sixth
|
|
Interval(5, 10), // 19 Augmented Sixth
|
|
|
|
Interval(6, 9), // 20 Diminished Seventh
|
|
Interval(6, 10), // 21 Minor Seventh
|
|
Interval(6, 11), // 22 Major Seventh
|
|
Interval(6, 12), // 23 Augmented Seventh
|
|
|
|
Interval(7, 11), // 24 Diminished Octave
|
|
Interval(7, 12) // 25 Perfect Octave
|
|
};
|
|
|
|
/*!
|
|
* Finds the most likely diatonic interval for a semitone distance.
|
|
*
|
|
* Uses the most common diatonic intervals.
|
|
*
|
|
* @param
|
|
* The number of semitones in the chromatic interval.
|
|
* Negative semitones will simply be made positive.
|
|
*
|
|
* @return
|
|
* The number of diatonic steps in the interval.
|
|
*/
|
|
|
|
int chromatic2diatonic(int semitones)
|
|
{
|
|
static int il[12] = {
|
|
0, // Perfect Unison
|
|
3, // Minor Second
|
|
4, // Major Second
|
|
7, // Minor Third
|
|
8, // Major Third
|
|
11, // Perfect Fourth
|
|
12, // Augmented Fourth
|
|
14, // Perfect Fifth
|
|
17, // Minor Sixth
|
|
18, // Major Sixth
|
|
21, // Minor Seventh
|
|
22, // Major Seventh
|
|
// 25 Perfect Octave
|
|
};
|
|
bool down = semitones < 0;
|
|
if (down) {
|
|
semitones = -semitones;
|
|
}
|
|
int val = semitones % 12;
|
|
int octave = semitones / 12;
|
|
int intervalIndex = il[val];
|
|
int steps = intervalList[intervalIndex].diatonic;
|
|
steps = steps + octave * 7;
|
|
return down ? -steps : steps;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// searchInterval
|
|
//---------------------------------------------------------
|
|
|
|
int searchInterval(int steps, int semitones)
|
|
{
|
|
unsigned n = sizeof(intervalList) / sizeof(*intervalList);
|
|
for (unsigned i = 0; i < n; ++i) {
|
|
if ((intervalList[i].diatonic == steps) && (intervalList[i].chromatic == semitones)) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// diatonicUpDown
|
|
// used to find the second note of a trill, mordent etc.
|
|
// key -7 ... +7
|
|
//---------------------------------------------------------
|
|
|
|
int diatonicUpDown(Key k, int pitch, int steps)
|
|
{
|
|
static int ptab[15][7] = {
|
|
// c c# d d# e f f# g g# a a# b
|
|
{ -1, 1, 3, 4, 6, 8, 10 }, // Cb Ces
|
|
{ -1, 1, 3, 5, 6, 8, 10 }, // Gb Ges
|
|
{ 0, 1, 3, 5, 6, 8, 10 }, // Db Des
|
|
{ 0, 1, 3, 5, 7, 8, 10 }, // Ab As
|
|
{ 0, 2, 3, 5, 7, 8, 10 }, // Eb Es
|
|
{ 0, 2, 3, 5, 7, 9, 10 }, // Bb B
|
|
{ 0, 2, 4, 5, 7, 9, 10 }, // F F
|
|
|
|
{ 0, 2, 4, 5, 7, 9, 11 }, // C C
|
|
|
|
{ 0, 2, 4, 6, 7, 9, 11 }, // G G
|
|
{ 1, 2, 4, 6, 7, 9, 11 }, // D D
|
|
{ 1, 2, 4, 6, 8, 9, 11 }, // A A
|
|
{ 1, 3, 4, 6, 8, 9, 11 }, // E E
|
|
{ 1, 3, 4, 6, 8, 10, 11 }, // B H
|
|
{ 1, 3, 5, 6, 8, 10, 11 }, // F# Fis
|
|
{ 1, 3, 5, 6, 8, 10, 12 }, // C# Cis
|
|
};
|
|
|
|
int key = int(k) + 7;
|
|
int step = pitch % 12;
|
|
int octave = pitch / 12;
|
|
|
|
// loop through the diatonic steps of the key looking for the given note
|
|
// or the gap where it would fit
|
|
int i = 0;
|
|
while (i < 7) {
|
|
if (ptab[key][i] >= step) {
|
|
break;
|
|
}
|
|
++i;
|
|
}
|
|
|
|
// neither step nor gap found
|
|
// reset to beginning
|
|
if (i == 7) {
|
|
++octave;
|
|
i = 0;
|
|
}
|
|
// if given step not found (gap found instead), and we are stepping up
|
|
// then we've already accounted for one step
|
|
if (ptab[key][i] > step && steps > 0) {
|
|
--steps;
|
|
}
|
|
|
|
// now start counting diatonic steps up or down
|
|
if (steps > 0) {
|
|
// count up
|
|
while (steps--) {
|
|
++i;
|
|
if (i == 7) {
|
|
// hit last step; reset to beginning
|
|
++octave;
|
|
i = 0;
|
|
}
|
|
}
|
|
} else if (steps < 0) {
|
|
// count down
|
|
while (steps++) {
|
|
--i;
|
|
if (i < 0) {
|
|
// hit first step; reset to end
|
|
--octave;
|
|
i = 6;
|
|
}
|
|
}
|
|
}
|
|
|
|
// convert step to pitch
|
|
step = ptab[key][i];
|
|
pitch = octave * 12 + step;
|
|
if (pitch < 0) {
|
|
pitch = 0;
|
|
}
|
|
if (pitch > 127) {
|
|
pitch = 128;
|
|
}
|
|
return pitch;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// searchTieNote
|
|
// search Note to tie to "note"
|
|
//---------------------------------------------------------
|
|
|
|
Note* searchTieNote(Note* note)
|
|
{
|
|
if (!note) {
|
|
return nullptr;
|
|
}
|
|
|
|
Note* note2 = 0;
|
|
Chord* chord = note->chord();
|
|
Segment* seg = chord->segment();
|
|
Part* part = chord->part();
|
|
track_idx_t strack = part->staves().front()->idx() * VOICES;
|
|
track_idx_t etrack = strack + part->staves().size() * VOICES;
|
|
|
|
if (chord->isGraceBefore()) {
|
|
chord = toChord(chord->explicitParent());
|
|
|
|
// try to tie to next grace note
|
|
|
|
size_t index = note->chord()->graceIndex();
|
|
for (Chord* c : chord->graceNotes()) {
|
|
if (c->graceIndex() == index + 1) {
|
|
note2 = c->findNote(note->pitch());
|
|
if (note2) {
|
|
//printf("found grace-grace tie\n");
|
|
return note2;
|
|
}
|
|
}
|
|
}
|
|
|
|
// try to tie to note in parent chord
|
|
note2 = chord->findNote(note->pitch());
|
|
if (note2) {
|
|
return note2;
|
|
}
|
|
} else if (chord->isGraceAfter()) {
|
|
// grace after
|
|
// we will try to tie to note in next normal chord, below
|
|
// meanwhile, set chord to parent chord so the endTick calculation will make sense
|
|
chord = toChord(chord->explicitParent());
|
|
} else {
|
|
// normal chord
|
|
// try to tie to grace note after if present
|
|
std::vector<Chord*> gna = chord->graceNotesAfter();
|
|
if (!gna.empty()) {
|
|
Chord* gc = gna[0];
|
|
note2 = gc->findNote(note->pitch());
|
|
if (note2) {
|
|
return note2;
|
|
}
|
|
}
|
|
}
|
|
// at this point, chord is a regular chord, not a grace chord
|
|
// and we are looking for a note in the *next* chord (grace or regular)
|
|
|
|
// calculate end of current note duration
|
|
// but err on the safe side in case there is roundoff in tick count
|
|
Fraction endTick = chord->tick() + chord->actualTicks() - Fraction(1, 4 * 480);
|
|
|
|
int idx1 = note->unisonIndex();
|
|
while ((seg = seg->next1(SegmentType::ChordRest))) {
|
|
// skip ahead to end of current note duration as calculated above
|
|
// but just in case, stop if we find element in current track
|
|
if (seg->tick() < endTick && !seg->element(chord->track())) {
|
|
continue;
|
|
}
|
|
for (track_idx_t track = strack; track < etrack; ++track) {
|
|
EngravingItem* e = seg->element(track);
|
|
if (e == 0 || !e->isChord()) {
|
|
continue;
|
|
}
|
|
Chord* c = toChord(e);
|
|
const staff_idx_t staffIdx = c->staffIdx() + c->staffMove();
|
|
if (staffIdx != chord->staffIdx() + chord->staffMove()) {
|
|
// this check is needed as we are iterating over all staves to capture cross-staff chords
|
|
continue;
|
|
}
|
|
// if there are grace notes before, try to tie to first one
|
|
std::vector<Chord*> gnb = c->graceNotesBefore();
|
|
if (!gnb.empty()) {
|
|
Chord* gc = gnb[0];
|
|
Note* gn2 = gc->findNote(note->pitch());
|
|
if (gn2) {
|
|
return gn2;
|
|
}
|
|
}
|
|
int idx2 = 0;
|
|
for (Note* n : c->notes()) {
|
|
if (n->pitch() == note->pitch()) {
|
|
if (idx1 == idx2) {
|
|
if (note2 == 0 || c->track() == chord->track()) {
|
|
note2 = n;
|
|
break;
|
|
}
|
|
} else {
|
|
++idx2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (note2) {
|
|
break;
|
|
}
|
|
}
|
|
return note2;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// searchTieNote114
|
|
// search Note to tie to "note", tie to next note in
|
|
// same voice
|
|
//---------------------------------------------------------
|
|
|
|
Note* searchTieNote114(Note* note)
|
|
{
|
|
Note* note2 = 0;
|
|
Chord* chord = note->chord();
|
|
Segment* seg = chord->segment();
|
|
Part* part = chord->part();
|
|
track_idx_t strack = part->staves().front()->idx() * VOICES;
|
|
track_idx_t etrack = strack + part->staves().size() * VOICES;
|
|
|
|
while ((seg = seg->next1(SegmentType::ChordRest))) {
|
|
for (track_idx_t track = strack; track < etrack; ++track) {
|
|
EngravingItem* e = seg->element(track);
|
|
if (e == 0 || (!e->isChord()) || (e->track() != chord->track())) {
|
|
continue;
|
|
}
|
|
Chord* c = toChord(e);
|
|
staff_idx_t staffIdx = c->staffIdx() + c->staffMove();
|
|
if (staffIdx != chord->staffIdx() + chord->staffMove()) { // cannot happen?
|
|
continue;
|
|
}
|
|
for (Note* n : c->notes()) {
|
|
if (n->pitch() == note->pitch()) {
|
|
if (note2 == 0 || c->track() == chord->track()) {
|
|
note2 = n;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (note2) {
|
|
break;
|
|
}
|
|
}
|
|
return note2;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// absStep
|
|
/// Compute absolute step.
|
|
/// C D E F G A B ....
|
|
//---------------------------------------------------------
|
|
|
|
int absStep(int tpc, int pitch)
|
|
{
|
|
int line = tpc2step(tpc) + (pitch / 12) * 7;
|
|
int tpcPitch = tpc2pitch(tpc);
|
|
|
|
if (tpcPitch < 0) {
|
|
line += 7;
|
|
} else {
|
|
line -= (tpcPitch / 12) * 7;
|
|
}
|
|
return line;
|
|
}
|
|
|
|
int absStep(int pitch)
|
|
{
|
|
// TODO - does this need to be key-aware?
|
|
int tpc = pitch2tpc(pitch, Key::C, Prefer::NEAREST);
|
|
return absStep(tpc, pitch);
|
|
}
|
|
|
|
int absStep(int line, ClefType clef)
|
|
{
|
|
return ClefInfo::pitchOffset(clef) - line;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// relStep
|
|
/// Compute relative step from absolute step
|
|
/// which depends on actual clef. Step 0 starts on the
|
|
/// first (top) staff line.
|
|
//---------------------------------------------------------
|
|
|
|
int relStep(int line, ClefType clef)
|
|
{
|
|
return ClefInfo::pitchOffset(clef) - line;
|
|
}
|
|
|
|
int relStep(int pitch, int tpc, ClefType clef)
|
|
{
|
|
return relStep(absStep(tpc, pitch), clef);
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// pitch2step
|
|
// returns one of { 0, 1, 2, 3, 4, 5, 6 }
|
|
//---------------------------------------------------------
|
|
|
|
int pitch2step(int pitch)
|
|
{
|
|
// C C# D D# E F F# G G# A A# B
|
|
static const char tab[12] = { 0, 0, 1, 1, 2, 3, 3, 4, 4, 5, 5, 6 };
|
|
return tab[pitch % 12];
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// step2pitch
|
|
// returns one of { 0, 2, 4, 5, 7, 9, 11 }
|
|
//---------------------------------------------------------
|
|
|
|
int step2pitch(int step)
|
|
{
|
|
static const char tab[7] = { 0, 2, 4, 5, 7, 9, 11 };
|
|
return tab[step % 7];
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// convertLine
|
|
// find the line in clefF corresponding to lineL2 in clefR
|
|
//---------------------------------------------------------
|
|
|
|
int convertLine(int lineL2, ClefType clefL, ClefType clefR)
|
|
{
|
|
int lineR2 = lineL2;
|
|
int goalpitch = line2pitch(lineL2, clefL, Key::C);
|
|
int p;
|
|
while ((p = line2pitch(lineR2, clefR, Key::C)) > goalpitch && p < 127) {
|
|
lineR2++;
|
|
}
|
|
while ((p = line2pitch(lineR2, clefR, Key::C)) < goalpitch && p > 0) {
|
|
lineR2--;
|
|
}
|
|
return lineR2;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// convertLine
|
|
// find the line in clef for NoteL corresponding to lineL2 in clef for noteR
|
|
// for example middle C is line 10 in Treble clef, but is line -2 in Bass clef.
|
|
//---------------------------------------------------------
|
|
|
|
int convertLine(int lineL2, const Note* noteL, const Note* noteR)
|
|
{
|
|
return convertLine(lineL2,
|
|
noteL->chord()->staff()->clef(noteL->chord()->tick()),
|
|
noteR->chord()->staff()->clef(noteR->chord()->tick()));
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// chromaticPitchSteps -- an articulation such as a trill, or mordant consists of several notes
|
|
// played in succession. The pitch offsets of each such note in the sequence can be represented either
|
|
// as a number of steps in the diatonic scale, or in half steps as on a piano keyboard.
|
|
// this function, articulationExcursion, takes deltastep indicating the number of steps in the
|
|
// diatonic scale, and calculates (and returns) the number of half steps, taking several things into account.
|
|
// E.g., the key signature, a trill from e to f, is to be understood as a trill between E and F# if we are
|
|
// in the key of G.
|
|
// E.g., if previously (looking backward in time) in the same measure there is another note on the same
|
|
// staff line/space, and that note has an accidental (sharp,flat,natural,etc), then we want to match that
|
|
// tone exactly.
|
|
// E.g., If there are multiple notes on the same line/space, then we only consider the most
|
|
// recent one, but avoid looking forward in time after the current note.
|
|
// E.g., Also if there is an accidental // on a note one (or more) octaves above or below we
|
|
// observe its accidental as well.
|
|
// E.g., Still another case is that if two staves are involved (such as a glissando between two
|
|
// notes on different staves) then we have to search both staves for the most recent accidental.
|
|
//
|
|
// noteL is the note to measure the deltastep from, i.e., ornaments are w.r.t. this note
|
|
// noteR is the note to search backward from to find accidentals.
|
|
// for ornament calculation noteL and noteR are the same, but for glissando they are
|
|
// the start and end note of glissando.
|
|
// nominalDiatonicSteps is the desired number of diatonic steps between the base note and this articulation step.
|
|
//---------------------------------------------------------
|
|
|
|
int chromaticPitchSteps(const Note* noteL, const Note* noteR, const int nominalDiatonicSteps)
|
|
{
|
|
if (0 == nominalDiatonicSteps) {
|
|
return 0;
|
|
}
|
|
Chord* chordL = noteL->chord();
|
|
Chord* chordR = noteR->chord();
|
|
int epitchL = noteL->epitch();
|
|
Fraction tickL = chordL->tick();
|
|
// we cannot use staffL = chord->staff() because that won't correspond to the noteL->line()
|
|
// in the case the user has pressed Shift-Cmd->Up or Shift-Cmd-Down.
|
|
// Therefore we have to take staffMove() into account using vStaffIdx().
|
|
Staff* staffL = noteL->score()->staff(chordL->vStaffIdx());
|
|
ClefType clefL = staffL->clef(tickL);
|
|
// line represents the ledger line of the staff. 0 is the top line, 1, is the space between the top 2 lines,
|
|
// ... 8 is the bottom line.
|
|
int lineL = noteL->line();
|
|
if (lineL == INVALID_LINE) {
|
|
int relLine = absStep(noteL->tpc(), noteL->epitch());
|
|
ClefType clef = noteL->staff()->clef(noteL->tick());
|
|
lineL = relStep(relLine, clef);
|
|
}
|
|
|
|
// we use line - deltastep, because lines are oriented from top to bottom, while step is oriented from bottom to top.
|
|
int lineL2 = lineL - nominalDiatonicSteps;
|
|
Measure* measureR = chordR->segment()->measure();
|
|
|
|
Segment* segment = noteL->chord()->segment();
|
|
int lineR2 = convertLine(lineL2, noteL, noteR);
|
|
// is there another note in this segment on the same line?
|
|
// if so, use its pitch exactly.
|
|
int halfsteps = 0;
|
|
staff_idx_t staffIdx = noteL->chord()->staff()->idx(); // cannot use staffL->idx() because of staffMove()
|
|
track_idx_t startTrack = staffIdx * VOICES;
|
|
track_idx_t endTrack = startTrack + VOICES;
|
|
bool done = false;
|
|
for (track_idx_t track = startTrack; track < endTrack; ++track) {
|
|
EngravingItem* e = segment->element(track);
|
|
if (!e || e->type() != ElementType::CHORD) {
|
|
continue;
|
|
}
|
|
Chord* chord = toChord(e);
|
|
if (chord->vStaffIdx() != chordL->vStaffIdx()) {
|
|
continue;
|
|
}
|
|
if (!done) {
|
|
if (staffL->isPitchedStaff(segment->tick())) {
|
|
bool error = false;
|
|
AccidentalVal acciv2 = measureR->findAccidental(chordR->segment(), chordR->vStaffIdx(), lineR2, error);
|
|
int acci2 = int(acciv2);
|
|
// epitch (effective pitch) is a visible pitch so line2pitch returns exactly that.
|
|
halfsteps = line2pitch(lineL - nominalDiatonicSteps, clefL, Key::C) + acci2 - epitchL;
|
|
} else {
|
|
// cannot rely on accidentals or key signatures
|
|
halfsteps = nominalDiatonicSteps;
|
|
}
|
|
}
|
|
}
|
|
return halfsteps;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// skipTuplet
|
|
// return segment of rightmost chord/rest in a
|
|
// (possible nested) tuplet
|
|
//---------------------------------------------------------
|
|
|
|
Segment* skipTuplet(Tuplet* tuplet)
|
|
{
|
|
DurationElement* nde = tuplet->elements().back();
|
|
while (nde->isTuplet()) {
|
|
tuplet = toTuplet(nde);
|
|
nde = tuplet->elements().back();
|
|
}
|
|
return toChordRest(nde)->segment();
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// timeSigSymIdsFromString
|
|
// replace ascii with bravura symbols
|
|
//---------------------------------------------------------
|
|
|
|
SymIdList timeSigSymIdsFromString(const String& string)
|
|
{
|
|
static const std::map<Char, SymId> dict = {
|
|
{ 43, SymId::timeSigPlusSmall }, // '+'
|
|
{ 48, SymId::timeSig0 }, // '0'
|
|
{ 49, SymId::timeSig1 }, // '1'
|
|
{ 50, SymId::timeSig2 }, // '2'
|
|
{ 51, SymId::timeSig3 }, // '3'
|
|
{ 52, SymId::timeSig4 }, // '4'
|
|
{ 53, SymId::timeSig5 }, // '5'
|
|
{ 54, SymId::timeSig6 }, // '6'
|
|
{ 55, SymId::timeSig7 }, // '7'
|
|
{ 56, SymId::timeSig8 }, // '8'
|
|
{ 57, SymId::timeSig9 }, // '9'
|
|
{ 67, SymId::timeSigCommon }, // 'C'
|
|
{ 40, SymId::timeSigParensLeftSmall }, // '('
|
|
{ 41, SymId::timeSigParensRightSmall }, // ')'
|
|
{ 162, SymId::timeSigCutCommon }, // '¢'
|
|
{ 189, SymId::timeSigFractionHalf },
|
|
{ 188, SymId::timeSigFractionQuarter },
|
|
{ 59664, SymId::mensuralProlation1 },
|
|
{ 79, SymId::mensuralProlation2 }, // 'O'
|
|
{ 59665, SymId::mensuralProlation2 },
|
|
{ 216, SymId::mensuralProlation3 }, // 'Ø'
|
|
{ 59666, SymId::mensuralProlation3 },
|
|
{ 59667, SymId::mensuralProlation4 },
|
|
{ 59668, SymId::mensuralProlation5 },
|
|
{ 59670, SymId::mensuralProlation7 },
|
|
{ 59671, SymId::mensuralProlation8 },
|
|
{ 59673, SymId::mensuralProlation10 },
|
|
{ 59674, SymId::mensuralProlation11 },
|
|
};
|
|
|
|
SymIdList list;
|
|
for (size_t i = 0; i < string.size(); ++i) {
|
|
SymId sym = mu::value(dict, string.at(i), SymId::noSym);
|
|
if (sym != SymId::noSym) {
|
|
list.push_back(sym);
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// actualTicks
|
|
//---------------------------------------------------------
|
|
|
|
Fraction actualTicks(Fraction duration, Tuplet* tuplet, Fraction timeStretch)
|
|
{
|
|
Fraction f = duration / timeStretch;
|
|
for (Tuplet* t = tuplet; t; t = t->tuplet()) {
|
|
f /= t->ratio();
|
|
}
|
|
return f;
|
|
}
|
|
|
|
double yStaffDifference(const System* system1, staff_idx_t staffIdx1, const System* system2, staff_idx_t staffIdx2)
|
|
{
|
|
if (!system1 || !system2) {
|
|
return 0.0;
|
|
}
|
|
const SysStaff* staff1 = system1->staff(staffIdx1);
|
|
const SysStaff* staff2 = system2->staff(staffIdx2);
|
|
if (!staff1 || !staff2) {
|
|
return 0.0;
|
|
}
|
|
return staff1->y() - staff2->y();
|
|
}
|
|
|
|
bool allowRemoveWhenRemovingStaves(EngravingItem* item, staff_idx_t startStaff, staff_idx_t endStaff)
|
|
{
|
|
// Sanity checks
|
|
if (!item || item->staffIdx() == mu::nidx || startStaff == mu::nidx || endStaff == mu::nidx) {
|
|
return false;
|
|
}
|
|
|
|
Score* score = item->score();
|
|
if (score->nstaves() == 1) {
|
|
return true;
|
|
}
|
|
|
|
if (endStaff == 0) { // Default initialized
|
|
endStaff = startStaff + 1;
|
|
}
|
|
|
|
staff_idx_t staffIdx = item->staffIdx();
|
|
if (staffIdx < startStaff || staffIdx >= endStaff) {
|
|
return false;
|
|
}
|
|
|
|
Staff* nextRemaining = score->staff(endStaff);
|
|
bool nextRemainingIsSystemObjectStaff = nextRemaining && score->isSystemObjectStaff(nextRemaining);
|
|
if (item->isTopSystemObject() && !nextRemainingIsSystemObjectStaff) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool moveDownWhenAddingStaves(EngravingItem* item, staff_idx_t startStaff, staff_idx_t endStaff)
|
|
{
|
|
// Sanity checks
|
|
if (!item || item->staffIdx() == mu::nidx || startStaff == mu::nidx || endStaff == mu::nidx) {
|
|
return false;
|
|
}
|
|
|
|
if (item->staffIdx() < startStaff) {
|
|
return false;
|
|
}
|
|
|
|
if (endStaff == 0) { // Default initialized
|
|
endStaff = startStaff + 1;
|
|
}
|
|
|
|
Score* score = item->score();
|
|
Staff* nextAfterInserted = score->staff(endStaff);
|
|
bool nextAfterInsertedIsSystemObjectStaff = nextAfterInserted && score->isSystemObjectStaff(nextAfterInserted);
|
|
if (item->isTopSystemObject() && !nextAfterInsertedIsSystemObjectStaff) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void collectChordsAndRest(Segment* segment, staff_idx_t staffIdx, std::vector<Chord*>& chords, std::vector<Rest*>& rests)
|
|
{
|
|
if (!segment) {
|
|
return;
|
|
}
|
|
|
|
track_idx_t startTrack = staffIdx * VOICES;
|
|
track_idx_t endTrack = startTrack + VOICES;
|
|
|
|
for (track_idx_t track = startTrack; track < endTrack; ++track) {
|
|
EngravingItem* e = segment->elementAt(track);
|
|
if (!e) {
|
|
continue;
|
|
}
|
|
if (e->isChord() && !toChordRest(e)->staffMove()) {
|
|
chords.push_back(toChord(e));
|
|
} else if (e->isRest() && !toChordRest(e)->staffMove()) {
|
|
rests.push_back(toRest(e));
|
|
}
|
|
}
|
|
}
|
|
|
|
void collectChordsOverlappingRests(Segment* segment, staff_idx_t staffIdx, std::vector<Chord*>& chords)
|
|
{
|
|
// Check if previous segments contain chords in other voices
|
|
// whose duration overlaps with rests on this segment
|
|
|
|
track_idx_t startTrack = staffIdx * VOICES;
|
|
track_idx_t endTrack = startTrack + VOICES;
|
|
|
|
std::set<track_idx_t> tracksToCheck;
|
|
for (track_idx_t track = startTrack; track < endTrack; ++track) {
|
|
EngravingItem* item = segment->elementAt(track);
|
|
if (!item || !item->isRest()) {
|
|
tracksToCheck.insert(track);
|
|
}
|
|
}
|
|
|
|
Fraction curTick = segment->rtick();
|
|
for (Segment* prevSeg = segment->prev(); prevSeg; prevSeg = prevSeg->prev()) {
|
|
if (!prevSeg->isChordRestType()) {
|
|
continue;
|
|
}
|
|
Fraction prevSegTick = prevSeg->rtick();
|
|
for (track_idx_t track : tracksToCheck) {
|
|
EngravingItem* e = prevSeg->elementAt(track);
|
|
if (!e || !e->isChord()) {
|
|
continue;
|
|
}
|
|
Chord* chord = toChord(e);
|
|
Fraction chordEndTick = prevSegTick + chord->actualTicks();
|
|
if (chordEndTick <= curTick) {
|
|
continue;
|
|
}
|
|
Measure* measure = segment->measure();
|
|
Segment* endSegment = measure->findSegmentR(SegmentType::ChordRest, chordEndTick);
|
|
if (!endSegment) {
|
|
continue;
|
|
}
|
|
EngravingItem* endItem = endSegment->elementAt(track);
|
|
if (!endItem || !endItem->isChord()) {
|
|
continue;
|
|
}
|
|
|
|
chords.push_back(chord);
|
|
}
|
|
}
|
|
}
|
|
|
|
String formatUniqueExcerptName(const String& baseName, const StringList& allExcerptLowerNames)
|
|
{
|
|
String result = baseName;
|
|
int num = 0;
|
|
|
|
while (allExcerptLowerNames.contains(result.toLower())) {
|
|
result = baseName + String(u" (%1)").arg(++num);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool isFirstSystemKeySig(const KeySig* ks)
|
|
{
|
|
if (!ks) {
|
|
return false;
|
|
}
|
|
const System* sys = ks->measure()->system();
|
|
if (!sys) {
|
|
return false;
|
|
}
|
|
return ks->tick() == sys->firstMeasure()->tick();
|
|
}
|
|
|
|
String bendAmountToString(int fulls, int quarts)
|
|
{
|
|
String string = String::number(fulls);
|
|
if (fulls == 0 && quarts != 0) {
|
|
string = u"";
|
|
}
|
|
|
|
switch (quarts) {
|
|
case 1:
|
|
string += u"\u00BC";
|
|
break;
|
|
case 2:
|
|
string += u"\u00BD";
|
|
break;
|
|
case 3:
|
|
string += u"\u00BE";
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return string;
|
|
}
|
|
}
|