void ChordRest::add(Element* e)
{
e->setParent(this);
e->setTrack(track());
switch(e->type()) {
case Element::Type::ARTICULATION:
{
Articulation* a = static_cast<Articulation*>(e);
_articulations.push_back(a);
if (a->timeStretch() != 1.0)
score()->fixTicks(); // update tempo map
}
break;
case Element::Type::LYRICS:
{
Lyrics* l = static_cast<Lyrics*>(e);
int size = _lyricsList.size();
if (l->no() >= size) {
for (int i = size-1; i < l->no(); ++i)
_lyricsList.append(0);
}
_lyricsList[l->no()] = l;
}
break;
default:
qFatal("ChordRest::add: unknown element %s", e->name());
break;
}
}
ChordRest::ChordRest(const ChordRest& cr, bool link)
: DurationElement(cr)
{
_durationType = cr._durationType;
_staffMove = cr._staffMove;
_beam = 0;
_tabDur = 0; // tab sur. symb. depends upon context: can't be
// simply copied from another CR
for (Articulation* a : cr._articulations) { // make deep copy
Articulation* na = new Articulation(*a);
if (link)
na->linkTo(a);
na->setParent(this);
na->setTrack(track());
_articulations.append(na);
}
_beamMode = cr._beamMode;
_up = cr._up;
_small = cr._small;
_crossMeasure = cr._crossMeasure;
_space = cr._space;
for (Lyrics* l : cr._lyricsList) { // make deep copy
if (l == 0)
continue;
Lyrics* nl = new Lyrics(*l);
if (link)
nl->linkTo(l);
nl->setParent(this);
nl->setTrack(track());
_lyricsList.append(nl);
}
}
void ScoreView::lyricsReturn()
{
Lyrics* lyrics = (Lyrics*)editObject;
Segment* segment = lyrics->segment();
endEdit();
_score->startCmd();
Lyrics* oldLyrics = lyrics;
lyrics = static_cast<Lyrics*>(Element::create(lyrics->type(), _score));
lyrics->setTrack(oldLyrics->track());
lyrics->setParent(segment->element(oldLyrics->track()));
lyrics->setNo(oldLyrics->no() + 1);
_score->undoAddElement(lyrics);
_score->select(lyrics, SELECT_SINGLE, 0);
startEdit(lyrics, -1);
mscore->changeState(mscoreState());
adjustCanvasPosition(lyrics, false);
_score->setLayoutAll(true);
_score->end2();
_score->end1();
}
void ScoreView::lyricsEndEdit()
{
Lyrics* lyrics = toLyrics(editData.element);
// if not empty, make sure this new lyrics does not fall in the middle
// of an existing melisma from a previous lyrics; in case, shorten it
int verse = lyrics->no();
Placement placement = lyrics->placement();
int track = lyrics->track();
// search previous lyric
Lyrics* prevLyrics = 0;
Segment* prevSegment = lyrics->segment()->prev1(SegmentType::ChordRest);
Segment* segment = prevSegment;
while (segment) {
ChordRest* cr = toChordRest(segment->element(track));
if (cr) {
prevLyrics = cr->lyrics(verse, placement);
if (prevLyrics)
break;
}
segment = segment->prev1(SegmentType::ChordRest);
}
if (prevLyrics && prevLyrics->syllabic() == Lyrics::Syllabic::END) {
int endTick = prevSegment->tick(); // a prev. melisma should not go beyond this segment
if (prevLyrics->endTick() >= endTick)
prevLyrics->undoChangeProperty(Pid::LYRIC_TICKS, endTick - prevLyrics->segment()->tick());
}
}
void ScoreView::lyricsUpDown(bool up, bool end)
{
Lyrics* lyrics = toLyrics(editData.element);
int track = lyrics->track();
ChordRest* cr = lyrics->chordRest();
int verse = lyrics->no();
Placement placement = lyrics->placement();
if (placement == Placement::ABOVE)
up = !up;
if (up) {
if (verse == 0)
return;
--verse;
}
else {
++verse;
if (verse > cr->lastVerse(placement))
return;
}
changeState(ViewState::NORMAL);
lyrics = cr->lyrics(verse, placement);
if (!lyrics) {
lyrics = new Lyrics(_score);
lyrics->setTrack(track);
lyrics->setParent(cr);
lyrics->setNo(verse);
lyrics->setPlacement(placement);
_score->startCmd();
_score->undoAddElement(lyrics);
_score->endCmd();
}
_score->select(lyrics, SelectType::SINGLE, 0);
startEdit(lyrics, Grip::NO_GRIP);
mscore->changeState(mscoreState());
adjustCanvasPosition(lyrics, false);
lyrics = toLyrics(editData.element);
TextCursor* cursor = lyrics->cursor(editData);
if (end) {
cursor->movePosition(QTextCursor::Start, QTextCursor::MoveAnchor);
cursor->movePosition(QTextCursor::End, QTextCursor::KeepAnchor);
}
else {
cursor->movePosition(QTextCursor::End, QTextCursor::MoveAnchor);
cursor->movePosition(QTextCursor::Start, QTextCursor::KeepAnchor);
}
_score->setLayoutAll();
_score->update();
}
void InspectorLyric::valueChanged(int idx)
{
if (iList[idx].t == P_ID::VERSE) {
int val = getValue(iList[idx]).toInt();
Lyrics* l = toLyrics(inspector->element());
printf("value changed %d old %d\n", val, l->no());
Lyrics* nl = l->chordRest()->lyrics(val, l->placement());
if (nl) {
printf(" move away %d -> %d\n", nl->no(), l->no());
nl->undoChangeProperty(P_ID::VERSE, l->no());
}
}
InspectorBase::valueChanged(idx);
}
void InspectorLyric::valueChanged(int idx)
{
if (iList[idx].t == Pid::VERSE) {
int val = getValue(iList[idx]).toInt();
Lyrics* l = toLyrics(inspector->element());
Lyrics* nl = l->chordRest()->lyrics(val, l->placement());
if (nl) {
nl->undoChangeProperty(Pid::VERSE, l->no());
}
}
InspectorBase::valueChanged(idx);
}
void ScoreView::lyricsUpDown(bool up, bool end)
{
Lyrics* lyrics = static_cast<Lyrics*>(editObject);
int track = lyrics->track();
ChordRest* cr = lyrics->chordRest();
int verse = lyrics->no();
const QList<Lyrics*>* ll = &lyrics->chordRest()->lyricsList();
if (up) {
if (verse == 0)
return;
--verse;
}
else {
++verse;
if (verse >= ll->size())
return;
}
endEdit();
_score->startCmd();
lyrics = ll->value(verse);
if (!lyrics) {
lyrics = new Lyrics(_score);
lyrics->setTrack(track);
lyrics->setParent(cr);
lyrics->setNo(verse);
_score->undoAddElement(lyrics);
}
_score->select(lyrics, SELECT_SINGLE, 0);
startEdit(lyrics, -1);
mscore->changeState(mscoreState());
adjustCanvasPosition(lyrics, false);
if (end)
((Lyrics*)editObject)->moveCursorToEnd();
else
((Lyrics*)editObject)->moveCursorToStart();
_score->setLayoutAll(true);
_score->end2();
_score->end1();
}
void TuLyrics::construct()
{
Lyrics *pLyrics;
/* Step 1: Default constructor. */
try
{
pLyrics = new Lyrics();
QVERIFY(pLyrics != NULL);
QVERIFY(pLyrics->sections().isEmpty());
QCOMPARE(pLyrics->title(), QString());
delete pLyrics;
}
catch (LyricsSection::TextParseException &)
{
QFAIL("Unexpected TextParseException thrown");
}
Lyrics::LyricsSectionList sectionList;
sectionList.append(LyricsSection("test[b]1[/b]", "1", LyricsSection::NoLineWrap));
QVERIFY(sectionList.size() == 1);
/* Step 2: Parametrised constructor. */
try
{
pLyrics = new Lyrics(123, sectionList, "test2");
QCOMPARE(pLyrics->id(), 123u);
QCOMPARE(pLyrics->sections()[0].text(), QString("test[b]1[/b]"));
QCOMPARE(pLyrics->title(), QString("test2"));
delete pLyrics;
}
catch (LyricsSection::TextParseException &)
{
QFAIL("Unexpected TextParseException thrown");
}
}
int GuitarPro5::readBeat(int tick, int voice, Measure* measure, int staffIdx, Tuplet** tuplets, bool /*mixChange*/)
{
uchar beatBits = readUChar();
bool dotted = beatBits & BEAT_DOTTED;
slide = -1;
int track = staffIdx * VOICES + voice;
if (slides.contains(track))
slide = slides.take(track);
int pause = -1;
if (beatBits & BEAT_PAUSE)
pause = readUChar();
// readDuration
int len = readChar();
int tuple = 0;
if (beatBits & BEAT_TUPLET)
tuple = readInt();
Segment* segment = measure->getSegment(Segment::Type::ChordRest, tick);
if (beatBits & BEAT_CHORD) {
int numStrings = score->staff(staffIdx)->part()->instr()->stringData()->strings();
skip(17);
QString name = readPascalString(21);
skip(4);
// no header to be read in the GP5 format - default to true.
readChord(segment, staffIdx * VOICES, numStrings, name, true);
skip(32);
}
Lyrics* lyrics = 0;
if (beatBits & BEAT_LYRICS) {
QString txt = readDelphiString();
lyrics = new Lyrics(score);
lyrics->setText(txt);
}
gpLyrics.beatCounter++;
if (gpLyrics.beatCounter >= gpLyrics.fromBeat && gpLyrics.lyricTrack == staffIdx+1) {
int index = gpLyrics.beatCounter - gpLyrics.fromBeat;
if (index < gpLyrics.lyrics.size()) {
lyrics = new Lyrics(score);
lyrics->setText(gpLyrics.lyrics[index]);
}
}
int beatEffects = 0;
if (beatBits & BEAT_EFFECTS)
beatEffects = readBeatEffects(track, segment);
if (beatBits & BEAT_MIX_CHANGE)
readMixChange(measure);
int strings = readUChar(); // used strings mask
Fraction l = len2fraction(len);
// Some beat effects could add a Chord before this
ChordRest* cr = segment->cr(track);
if (voice != 0 && pause == 0 && strings == 0)
cr = 0;
else {
if (strings == 0) {
if (cr) {
segment->remove(cr);
delete cr;
cr = 0;
}
cr = new Rest(score);
}
else {
if (!cr)
cr = new Chord(score);
}
cr->setTrack(track);
TDuration d(l);
d.setDots(dotted ? 1 : 0);
if (dotted)
l = l + (l/2);
if (tuple) {
Tuplet* tuplet = tuplets[staffIdx * 2 + voice];
if ((tuplet == 0) || (tuplet->elementsDuration() == tuplet->baseLen().fraction() * tuplet->ratio().numerator())) {
tuplet = new Tuplet(score);
// int track = staffIdx * 2 + voice;
tuplets[staffIdx * 2 + voice] = tuplet;
tuplet->setTrack(cr->track());
setTuplet(tuplet, tuple);
tuplet->setParent(measure);
}
tuplet->setTrack(cr->track());
tuplet->setBaseLen(l);
tuplet->setDuration(l * tuplet->ratio().denominator());
cr->setTuplet(tuplet);
tuplet->add(cr);
}
cr->setDuration(l);
if (cr->type() == Element::Type::REST && (pause == 0 || l == measure->len()))
cr->setDurationType(TDuration::DurationType::V_MEASURE);
else
cr->setDurationType(d);
if(!segment->cr(track))
segment->add(cr);
Staff* staff = cr->staff();
int numStrings = staff->part()->instr()->stringData()->strings();
bool hasSlur = false;
for (int i = 6; i >= 0; --i) {
if (strings & (1 << i) && ((6-i) < numStrings)) {
Note* note = new Note(score);
if (dotted) {
// there is at most one dotted note in this guitar pro version
NoteDot* dot = new NoteDot(score);
dot->setIdx(0);
dot->setParent(note);
dot->setTrack(track); // needed to know the staff it belongs to (and detect tablature)
dot->setVisible(true);
note->add(dot);
}
static_cast<Chord*>(cr)->add(note);
hasSlur = readNote(6-i, note);
note->setTpcFromPitch();
}
}
createSlur(hasSlur, staffIdx, cr);
if (lyrics)
cr->add(lyrics);
}
int rr = readChar();
if (cr && (cr->type() == Element::Type::CHORD)) {
Chord* chord = static_cast<Chord*>(cr);
applyBeatEffects(chord, beatEffects);
if (rr == ARPEGGIO_DOWN)
chord->setStemDirection(MScore::Direction::DOWN);
else if (rr == ARPEGGIO_UP)
chord->setStemDirection(MScore::Direction::UP);
}
int r = readChar();
if (r & 0x8) {
int rrr = readChar();
qDebug(" 3beat read 0x%02x", rrr);
}
if (cr && (cr->type() == Element::Type::CHORD) && slide > 0)
createSlide(slide, cr, staffIdx);
restsForEmptyBeats(segment, measure, cr, l, track, tick);
return cr ? cr->actualTicks() : measure->ticks();
}
void ScoreView::lyricsReturn()
{
Lyrics* lyrics = toLyrics(editData.element);
changeState(ViewState::NORMAL);
_score->startCmd();
int newVerse;
newVerse = lyrics->no() + 1;
Lyrics* oldLyrics = lyrics;
lyrics = new Lyrics(_score);
lyrics->setTrack(oldLyrics->track());
lyrics->setParent(oldLyrics->segment()->element(oldLyrics->track()));
lyrics->setPlacement(oldLyrics->placement());
lyrics->setPropertyFlags(Pid::PLACEMENT, oldLyrics->propertyFlags(Pid::PLACEMENT));
lyrics->setNo(newVerse);
_score->undoAddElement(lyrics);
_score->endCmd();
_score->select(lyrics, SelectType::SINGLE, 0);
startEdit(lyrics, Grip::NO_GRIP);
adjustCanvasPosition(lyrics, false);
}
void ScoreView::lyricsMinus()
{
Lyrics* lyrics = toLyrics(editData.element);
int track = lyrics->track();
Segment* segment = lyrics->segment();
int verse = lyrics->no();
Placement placement = lyrics->placement();
PropertyFlags pFlags = lyrics->propertyFlags(Pid::PLACEMENT);
changeState(ViewState::NORMAL);
// search next chord
Segment* nextSegment = segment;
while ((nextSegment = nextSegment->next1(SegmentType::ChordRest))) {
Element* el = nextSegment->element(track);
if (el && el->isChord())
break;
}
if (nextSegment == 0)
return;
// look for the lyrics we are moving from; may be the current lyrics or a previous one
// we are extending with several dashes
Lyrics* fromLyrics = 0;
while (segment) {
ChordRest* cr = toChordRest(segment->element(track));
if (!cr) {
segment = segment->prev1(SegmentType::ChordRest);
continue;
}
fromLyrics = cr->lyrics(verse, placement);
if (fromLyrics)
break;
segment = segment->prev1(SegmentType::ChordRest);
}
_score->startCmd();
ChordRest* cr = toChordRest(nextSegment->element(track));
Lyrics* toLyrics = cr->lyrics(verse, placement);
bool newLyrics = (toLyrics == 0);
if (!toLyrics) {
toLyrics = new Lyrics(_score);
toLyrics->setTrack(track);
toLyrics->setParent(nextSegment->element(track));
toLyrics->setNo(verse);
toLyrics->setPlacement(placement);
toLyrics->setPropertyFlags(Pid::PLACEMENT, pFlags);
toLyrics->setSyllabic(Lyrics::Syllabic::END);
}
else {
// as we arrived at toLyrics by a dash, it cannot be initial or isolated
if (toLyrics->syllabic() == Lyrics::Syllabic::BEGIN)
toLyrics->undoChangeProperty(Pid::SYLLABIC, int(Lyrics::Syllabic::MIDDLE));
else if (toLyrics->syllabic() == Lyrics::Syllabic::SINGLE)
toLyrics->undoChangeProperty(Pid::SYLLABIC, int(Lyrics::Syllabic::END));
}
if (fromLyrics) {
// as we moved away from fromLyrics by a dash,
// it can have syll. dashes before and after but cannot be isolated or terminal
switch(fromLyrics->syllabic()) {
case Lyrics::Syllabic::BEGIN:
case Lyrics::Syllabic::MIDDLE:
break;
case Lyrics::Syllabic::SINGLE:
fromLyrics->undoChangeProperty(Pid::SYLLABIC, int(Lyrics::Syllabic::BEGIN));
break;
case Lyrics::Syllabic::END:
fromLyrics->undoChangeProperty(Pid::SYLLABIC, int(Lyrics::Syllabic::MIDDLE));
break;
}
// for the same reason, it cannot have a melisma
fromLyrics->undoChangeProperty(Pid::LYRIC_TICKS, 0);
}
if (newLyrics)
_score->undoAddElement(toLyrics);
_score->endCmd();
_score->select(toLyrics, SelectType::SINGLE, 0);
startEdit(toLyrics, Grip::NO_GRIP);
adjustCanvasPosition(toLyrics, false);
TextCursor* cursor = Ms::toLyrics(editData.element)->cursor(editData);
Ms::toLyrics(editData.element)->selectAll(cursor);
_score->setLayoutAll();
}
void LyricsLineSegment::layout()
{
bool endOfSystem = false;
bool isEndMelisma = lyricsLine()->lyrics()->ticks() > 0;
Lyrics* lyr = 0;
Lyrics* nextLyr = 0;
qreal fromX = 0;
qreal toX = 0; // start and end point of intra-lyrics room
qreal sp = spatium();
System* sys;
if (lyricsLine()->ticks() <= 0) { // if no span,
_numOfDashes = 0; // nothing to draw
return; // and do nothing
}
// HORIZONTAL POSITION
// A) if line precedes a syllable, advance line end to right before the next syllable text
// if not a melisma and there is a next syllable;
if (!isEndMelisma && lyricsLine()->nextLyrics() && isSingleEndType()) {
lyr = nextLyr = lyricsLine()->nextLyrics();
sys = lyr->segment()->system();
endOfSystem = (sys != system());
// if next lyrics is on a different system, this line segment is at the end of its system:
// do not adjust for next lyrics position
if (!endOfSystem) {
qreal lyrX = lyr->bbox().x();
qreal lyrXp = lyr->pagePos().x();
qreal sysXp = sys->pagePos().x();
toX = lyrXp - sysXp + lyrX; // syst.rel. X pos.
qreal offsetX = toX - pos().x() - pos2().x() - score()->styleP(Sid::lyricsDashPad);
// delta from current end pos.| ending padding
rxpos2() += offsetX;
}
}
// B) if line follows a syllable, advance line start to after the syllable text
lyr = lyricsLine()->lyrics();
sys = lyr->segment()->system();
if (sys && isSingleBeginType()) {
qreal lyrX = lyr->bbox().x();
qreal lyrXp = lyr->pagePos().x();
qreal lyrW = lyr->bbox().width();
qreal sysXp = sys->pagePos().x();
fromX = lyrXp - sysXp + lyrX + lyrW;
// syst.rel. X pos. | lyr.advance
qreal offsetX = fromX - pos().x();
offsetX += score()->styleP(isEndMelisma ? Sid::lyricsMelismaPad : Sid::lyricsDashPad);
// delta from curr.pos. | add initial padding
rxpos() += offsetX;
rxpos2() -= offsetX;
}
// VERTICAL POSITION: at the base line of the syllable text
if (!isEndType())
rypos() = lyr->ipos().y();
else {
// use Y position of *next* syllable if there is one on same system
Lyrics* nextLyr = searchNextLyrics(lyr->segment(), lyr->staffIdx(), lyr->no(), lyr->placement());
if (nextLyr && nextLyr->segment()->system() == system())
rypos() = nextLyr->y();
else
rypos() = lyr->y();
}
// MELISMA vs. DASHES
if (isEndMelisma) { // melisma
_numOfDashes = 1;
rypos() -= lyricsLine()->lineWidth() * .5; // let the line 'sit on' the base line
qreal offsetX = score()->styleP(Sid::minNoteDistance) * mag();
// if final segment, extend slightly after the chord, otherwise shorten it
rxpos2() += (isBeginType() || isEndType()) ? -offsetX : +offsetX;
}
else { // dash(es)
// set conventional dash Y pos
rypos() -= MScore::pixelRatio * lyr->fontMetrics().xHeight() * score()->styleD(Sid::lyricsDashYposRatio);
_dashLength = score()->styleP(Sid::lyricsDashMaxLength) * mag(); // and dash length
qreal len = pos2().x();
qreal minDashLen = score()->styleS(Sid::lyricsDashMinLength).val() * sp;
qreal maxDashDist = score()->styleS(Sid::lyricsDashMaxDistance).val() * sp;
if (len < minDashLen) { // if no room for a dash
// if at end of system or dash is forced
if (endOfSystem || score()->styleB(Sid::lyricsDashForce)) {
rxpos2() = minDashLen; // draw minimal dash
_numOfDashes = 1;
_dashLength = minDashLen;
}
else // if within system or dash not forced
_numOfDashes = 0; // draw no dash
}
else if (len < (maxDashDist * 2.0)) { // if no room for two dashes
_numOfDashes = 1; // draw one dash
if (_dashLength > len) // if no room for a full dash
_dashLength = len; // shorten it
}
else
_numOfDashes = len / (maxDashDist); // draw several dashes
// adjust next lyrics horiz. position if too little a space forced to skip the dash
if (_numOfDashes == 0 && nextLyr != nullptr && len > 0)
nextLyr->rxpos() -= (toX - fromX);
}
// set bounding box
QRectF r = QRectF(0.0, 0.0, pos2().x(), pos2().y()).normalized();
qreal lw = lyricsLine()->lineWidth() * .5;
setbbox(r.adjusted(-lw, -lw, lw, lw));
}
void ScoreView::lyricsEndEdit()
{
Lyrics* lyrics = (Lyrics*)editObject;
int endTick = lyrics->segment()->tick();
// search previous lyric:
int verse = lyrics->no();
int staffIdx = lyrics->staffIdx();
// search previous lyric
Lyrics* oldLyrics = 0;
Segment* segment = lyrics->segment();
while (segment) {
const QList<Lyrics*>* nll = segment->lyricsList(staffIdx);
if (nll) {
oldLyrics = nll->value(verse);
if (oldLyrics)
break;
}
segment = segment->prev1(Segment::SegChordRest | Segment::SegGrace);
}
// if (lyrics->isEmpty() && origL->isEmpty())
if (lyrics->isEmpty())
lyrics->parent()->remove(lyrics);
else {
if (oldLyrics && oldLyrics->syllabic() == Lyrics::END) {
if (oldLyrics->endTick() >= endTick)
oldLyrics->setTicks(0);
}
}
}
FXint run() {
Lyrics lyrics;
lyrics.fetch(track);
return 0;
}
void ScoreView::lyricsReturn()
{
Lyrics* lyrics = toLyrics(editData.element);
Segment* segment = lyrics->segment();
changeState(ViewState::NORMAL);
Lyrics* oldLyrics = lyrics;
_score->startCmd();
int newVerse;
if (lyrics->placeAbove()) {
newVerse = oldLyrics->no() - 1;
if (newVerse == -1) {
// raise all lyrics above
newVerse = 0;
for (Segment* s = _score->firstSegment(SegmentType::ChordRest); s; s = s->next1(SegmentType::ChordRest)) {
ChordRest* cr = s->cr(lyrics->track());
if (cr) {
for (Lyrics* l : cr->lyrics()) {
if (l->placement() == oldLyrics->placement())
l->undoChangeProperty(Pid::VERSE, l->no() + 1);
}
}
}
}
}
else
newVerse = oldLyrics->no() + 1;
lyrics = toLyrics(Element::create(lyrics->type(), _score));
lyrics->setTrack(oldLyrics->track());
lyrics->setParent(segment->element(oldLyrics->track()));
lyrics->setPlacement(oldLyrics->placement());
lyrics->setNo(newVerse);
_score->undoAddElement(lyrics);
_score->endCmd();
_score->select(lyrics, SelectType::SINGLE, 0);
startEdit(lyrics, Grip::NO_GRIP);
adjustCanvasPosition(lyrics, false);
_score->setLayoutAll();
}
void ScoreView::lyricsUnderscore()
{
Lyrics* lyrics = static_cast<Lyrics*>(editObject);
int track = lyrics->track();
Segment* segment = lyrics->segment();
int verse = lyrics->no();
int endTick = segment->tick();
endEdit();
// search next chord
Segment* nextSegment = segment;
while ((nextSegment = nextSegment->next1(Segment::Type::ChordRest))) {
Element* el = nextSegment->element(track);
if (el && el->type() == Element::Type::CHORD)
break;
}
// search previous lyric
Lyrics* oldLyrics = 0;
while (segment) {
const QList<Lyrics*>* nll = segment->lyricsList(track);
if (nll) {
oldLyrics = nll->value(verse);
if (oldLyrics)
break;
}
segment = segment->prev1(Segment::Type::ChordRest);
}
if (nextSegment == 0) {
if (oldLyrics) {
switch(oldLyrics->syllabic()) {
case Lyrics::Syllabic::SINGLE:
case Lyrics::Syllabic::END:
break;
default:
oldLyrics->undoChangeProperty(P_ID::SYLLABIC, int(Lyrics::Syllabic::END));
break;
}
if (oldLyrics->segment()->tick() < endTick)
oldLyrics->undoChangeProperty(P_ID::LYRIC_TICKS, endTick - oldLyrics->segment()->tick());
}
return;
}
_score->startCmd();
const QList<Lyrics*>* ll = nextSegment->lyricsList(track);
lyrics = ll->value(verse);
bool newLyrics = (lyrics == 0);
if (!lyrics) {
lyrics = new Lyrics(_score);
lyrics->setTrack(track);
lyrics->setParent(nextSegment->element(track));
lyrics->setNo(verse);
lyrics->setSyllabic(Lyrics::Syllabic::SINGLE);
}
else
lyrics->undoChangeProperty(P_ID::SYLLABIC, int(Lyrics::Syllabic::SINGLE));
if (oldLyrics) {
switch(oldLyrics->syllabic()) {
case Lyrics::Syllabic::SINGLE:
case Lyrics::Syllabic::END:
break;
default:
oldLyrics->undoChangeProperty(P_ID::SYLLABIC, int(Lyrics::Syllabic::END));
break;
}
if (oldLyrics->segment()->tick() < endTick)
oldLyrics->undoChangeProperty(P_ID::LYRIC_TICKS, endTick - oldLyrics->segment()->tick());
}
if (newLyrics)
_score->undoAddElement(lyrics);
_score->select(lyrics, SelectType::SINGLE, 0);
startEdit(lyrics, -1);
mscore->changeState(mscoreState());
adjustCanvasPosition(lyrics, false);
((Lyrics*)editObject)->moveCursorToEnd();
_score->setLayoutAll(true);
_score->update();
}
void ScoreView::lyricsTab(bool back, bool end, bool moveOnly)
{
Lyrics* lyrics = toLyrics(editData.element);
int track = lyrics->track();
Segment* segment = lyrics->segment();
int verse = lyrics->no();
Placement placement = lyrics->placement();
PropertyFlags pFlags = lyrics->propertyFlags(Pid::PLACEMENT);
Segment* nextSegment = segment;
if (back) {
// search prev chord
while ((nextSegment = nextSegment->prev1(SegmentType::ChordRest))) {
Element* el = nextSegment->element(track);
if (el && el->isChord())
break;
}
}
else {
// search next chord
while ((nextSegment = nextSegment->next1(SegmentType::ChordRest))) {
Element* el = nextSegment->element(track);
if (el && el->isChord())
break;
}
}
if (nextSegment == 0)
return;
changeState(ViewState::NORMAL);
// look for the lyrics we are moving from; may be the current lyrics or a previous one
// if we are skipping several chords with spaces
Lyrics* fromLyrics = 0;
if (!back) {
while (segment) {
ChordRest* cr = toChordRest(segment->element(track));
if (cr) {
fromLyrics = cr->lyrics(verse, placement);
if (fromLyrics)
break;
}
segment = segment->prev1(SegmentType::ChordRest);
}
}
ChordRest* cr = toChordRest(nextSegment->element(track));
if (!cr) {
qDebug("no next lyrics list: %s", nextSegment->element(track)->name());
return;
}
Lyrics* _toLyrics = cr->lyrics(verse, placement);
bool newLyrics = false;
if (!_toLyrics) {
_toLyrics = new Lyrics(_score);
_toLyrics->setTrack(track);
ChordRest* cr = toChordRest(nextSegment->element(track));
_toLyrics->setParent(cr);
_toLyrics->setNo(verse);
_toLyrics->setPlacement(placement);
_toLyrics->setPropertyFlags(Pid::PLACEMENT, pFlags);
_toLyrics->setSyllabic(Lyrics::Syllabic::SINGLE);
newLyrics = true;
}
_score->startCmd();
if (fromLyrics && !moveOnly) {
switch (_toLyrics->syllabic()) {
// as we arrived at toLyrics by a [Space], it can be the beginning
// of a multi-syllable, but cannot have syllabic dashes before
case Lyrics::Syllabic::SINGLE:
case Lyrics::Syllabic::BEGIN:
break;
case Lyrics::Syllabic::END:
_toLyrics->undoChangeProperty(Pid::SYLLABIC, int(Lyrics::Syllabic::SINGLE));
break;
case Lyrics::Syllabic::MIDDLE:
_toLyrics->undoChangeProperty(Pid::SYLLABIC, int(Lyrics::Syllabic::BEGIN));
break;
}
// as we moved away from fromLyrics by a [Space], it can be
// the end of a multi-syllable, but cannot have syllabic dashes after
switch (fromLyrics->syllabic()) {
case Lyrics::Syllabic::SINGLE:
case Lyrics::Syllabic::END:
break;
case Lyrics::Syllabic::BEGIN:
fromLyrics->undoChangeProperty(Pid::SYLLABIC, int(Lyrics::Syllabic::SINGLE));
break;
case Lyrics::Syllabic::MIDDLE:
fromLyrics->undoChangeProperty(Pid::SYLLABIC, int(Lyrics::Syllabic::END));
break;
}
// for the same reason, it cannot have a melisma
fromLyrics->undoChangeProperty(Pid::LYRIC_TICKS, 0);
}
if (newLyrics)
_score->undoAddElement(_toLyrics);
_score->endCmd();
_score->select(_toLyrics, SelectType::SINGLE, 0);
startEdit(_toLyrics, Grip::NO_GRIP);
adjustCanvasPosition(_toLyrics, false);
TextCursor* cursor = toLyrics(editData.element)->cursor(editData);
if (end) {
cursor->movePosition(QTextCursor::Start, QTextCursor::MoveAnchor);
cursor->movePosition(QTextCursor::End, QTextCursor::KeepAnchor);
}
else {
cursor->movePosition(QTextCursor::End, QTextCursor::MoveAnchor);
cursor->movePosition(QTextCursor::Start, QTextCursor::KeepAnchor);
}
_score->setLayoutAll();
}
void ScoreView::lyricsEndEdit()
{
Lyrics* lyrics = static_cast<Lyrics*>(editObject);
int endTick = lyrics->segment()->tick();
// search previous lyric:
int verse = lyrics->no();
int track = lyrics->track();
// search previous lyric
Lyrics* oldLyrics = 0;
Segment* segment = lyrics->segment();
while (segment) {
const QList<Lyrics*>* nll = segment->lyricsList(track);
if (nll) {
oldLyrics = nll->value(verse);
if (oldLyrics)
break;
}
segment = segment->prev1(Segment::Type::ChordRest);
}
if (lyrics->isEmpty())
lyrics->parent()->remove(lyrics);
else {
if (oldLyrics && oldLyrics->syllabic() == Lyrics::Syllabic::END) {
if (oldLyrics->endTick() >= endTick)
oldLyrics->undoChangeProperty(P_ID::LYRIC_TICKS, 0);
}
}
}
void ScoreView::lyricsUnderscore()
{
Lyrics* lyrics = toLyrics(editData.element);
int track = lyrics->track();
Segment* segment = lyrics->segment();
int verse = lyrics->no();
Placement placement = lyrics->placement();
PropertyFlags pFlags = lyrics->propertyFlags(Pid::PLACEMENT);
int endTick = segment->tick(); // a previous melisma cannot extend beyond this point
changeState(ViewState::NORMAL);
// search next chord
Segment* nextSegment = segment;
while ((nextSegment = nextSegment->next1(SegmentType::ChordRest))) {
Element* el = nextSegment->element(track);
if (el && el->isChord())
break;
}
// look for the lyrics we are moving from; may be the current lyrics or a previous one
// we are extending with several underscores
Lyrics* fromLyrics = 0;
while (segment) {
ChordRest* cr = toChordRest(segment->element(track));
if (cr) {
fromLyrics = cr->lyrics(verse, placement);
if (fromLyrics)
break;
}
segment = segment->prev1(SegmentType::ChordRest);
// if the segment has a rest in this track, stop going back
Element* e = segment ? segment->element(track) : 0;
if (e && !e->isChord())
break;
}
// one-chord melisma?
// if still at melisma initial chord and there is a valid next chord (if not,
// there will be no melisma anyway), set a temporary melisma duration
if (fromLyrics == lyrics && nextSegment) {
_score->startCmd();
lyrics->undoChangeProperty(Pid::LYRIC_TICKS, Lyrics::TEMP_MELISMA_TICKS);
_score->setLayoutAll();
_score->endCmd();
}
if (nextSegment == 0) {
_score->startCmd();
if (fromLyrics) {
switch(fromLyrics->syllabic()) {
case Lyrics::Syllabic::SINGLE:
case Lyrics::Syllabic::END:
break;
default:
fromLyrics->undoChangeProperty(Pid::SYLLABIC, int(Lyrics::Syllabic::END));
break;
}
if (fromLyrics->segment()->tick() < endTick)
fromLyrics->undoChangeProperty(Pid::LYRIC_TICKS, endTick - fromLyrics->segment()->tick());
}
// leave edit mode, select something (just for user feedback) and update to show extended melisam
mscore->changeState(STATE_NORMAL);
if (fromLyrics)
_score->select(fromLyrics, SelectType::SINGLE, 0);
_score->setLayoutAll();
_score->endCmd();
return;
}
// if a place for a new lyrics has been found, create a lyrics there
ChordRest* cr = toChordRest(nextSegment->element(track));
Lyrics* toLyrics = cr->lyrics(verse, placement);
bool newLyrics = (toLyrics == 0);
if (!toLyrics) {
toLyrics = new Lyrics(_score);
toLyrics->setTrack(track);
toLyrics->setParent(nextSegment->element(track));
toLyrics->setNo(verse);
toLyrics->setPlacement(placement);
toLyrics->setPropertyFlags(Pid::PLACEMENT, pFlags);
toLyrics->setSyllabic(Lyrics::Syllabic::SINGLE);
}
// as we arrived at toLyrics by an underscore, it cannot have syllabic dashes before
else if (toLyrics->syllabic() == Lyrics::Syllabic::MIDDLE)
toLyrics->undoChangeProperty(Pid::SYLLABIC, int(Lyrics::Syllabic::BEGIN));
else if (toLyrics->syllabic() == Lyrics::Syllabic::END)
toLyrics->undoChangeProperty(Pid::SYLLABIC, int(Lyrics::Syllabic::SINGLE));
if (fromLyrics) {
// as we moved away from fromLyrics by an underscore,
// it can be isolated or terminal but cannot have dashes after
switch(fromLyrics->syllabic()) {
case Lyrics::Syllabic::SINGLE:
case Lyrics::Syllabic::END:
break;
default:
fromLyrics->undoChangeProperty(Pid::SYLLABIC, int(Lyrics::Syllabic::END));
break;
}
// for the same reason, if it has a melisma, this cannot extend beyond toLyrics
if (fromLyrics->segment()->tick() < endTick)
fromLyrics->undoChangeProperty(Pid::LYRIC_TICKS, endTick - fromLyrics->segment()->tick());
}
if (newLyrics)
_score->undoAddElement(toLyrics);
_score->endCmd();
_score->select(toLyrics, SelectType::SINGLE, 0);
startEdit(toLyrics, Grip::NO_GRIP);
adjustCanvasPosition(toLyrics, false);
TextCursor* cursor = Ms::toLyrics(editData.element)->cursor(editData);
Ms::toLyrics(editData.element)->selectAll(cursor);
}
void ScoreView::lyricsTab(bool back, bool end, bool moveOnly)
{
Lyrics* lyrics = (Lyrics*)editObject;
int track = lyrics->track();
Segment* segment = lyrics->segment();
int verse = lyrics->no();
Segment* nextSegment = segment;
if (back) {
// search prev chord
while ((nextSegment = nextSegment->prev1(Segment::Type::ChordRest))) {
Element* el = nextSegment->element(track);
if (el && el->type() == Element::Type::CHORD)
break;
}
}
else {
// search next chord
while ((nextSegment = nextSegment->next1(Segment::Type::ChordRest))) {
Element* el = nextSegment->element(track);
if (el && el->type() == Element::Type::CHORD)
break;
}
}
if (nextSegment == 0)
return;
endEdit();
// search previous lyric
Lyrics* oldLyrics = 0;
if (!back) {
while (segment) {
const QList<Lyrics*>* nll = segment->lyricsList(track);
if (nll) {
oldLyrics = nll->value(verse);
if (oldLyrics)
break;
}
segment = segment->prev1(Segment::Type::ChordRest);
}
}
const QList<Lyrics*>* ll = nextSegment->lyricsList(track);
if (ll == 0) {
qDebug("no next lyrics list: %s", nextSegment->element(track)->name());
return;
}
lyrics = ll->value(verse);
bool newLyrics = false;
if (!lyrics) {
lyrics = new Lyrics(_score);
lyrics->setTrack(track);
ChordRest* cr = static_cast<ChordRest*>(nextSegment->element(track));
lyrics->setParent(cr);
lyrics->setNo(verse);
lyrics->setSyllabic(Lyrics::Syllabic::SINGLE);
newLyrics = true;
}
_score->startCmd();
if (oldLyrics && !moveOnly) {
switch(lyrics->syllabic()) {
case Lyrics::Syllabic::SINGLE:
case Lyrics::Syllabic::BEGIN:
break;
case Lyrics::Syllabic::END:
lyrics->undoChangeProperty(P_ID::SYLLABIC, int(Lyrics::Syllabic::SINGLE));
break;
case Lyrics::Syllabic::MIDDLE:
lyrics->undoChangeProperty(P_ID::SYLLABIC, int(Lyrics::Syllabic::BEGIN));
break;
}
switch(oldLyrics->syllabic()) {
case Lyrics::Syllabic::SINGLE:
case Lyrics::Syllabic::END:
break;
case Lyrics::Syllabic::BEGIN:
oldLyrics->undoChangeProperty(P_ID::SYLLABIC, int(Lyrics::Syllabic::SINGLE));
break;
case Lyrics::Syllabic::MIDDLE:
oldLyrics->undoChangeProperty(P_ID::SYLLABIC, int(Lyrics::Syllabic::END));
break;
}
}
if (newLyrics)
_score->undoAddElement(lyrics);
_score->select(lyrics, SelectType::SINGLE, 0);
startEdit(lyrics, -1);
mscore->changeState(mscoreState());
adjustCanvasPosition(lyrics, false);
if (end)
((Lyrics*)editObject)->moveCursorToEnd();
else
((Lyrics*)editObject)->moveCursorToStart();
_score->setLayoutAll(true);
_score->update();
}
void MuseData::readNote(Part* part, const QString& s)
{
// a b c d e f g
static int table[7] = { 9, 11, 0, 2, 4, 5, 7 };
int step = s[0].toLatin1() - 'A';
int alter = 0;
int octave = 0;
for (int i = 1; i < 3; ++i) {
if (s[i] == '#')
alter += 1;
else if (s[i] == 'f')
alter -= 1;
else if (s[i].isDigit()) {
octave = s.mid(i,1).toInt();
break;
}
}
MScore::Direction dir = MScore::AUTO;
if (s.size() >= 23) {
if (s[22] == 'u')
dir = MScore::UP;
else if (s[22] == 'd')
dir = MScore::DOWN;
}
int staffIdx = 0;
if (s.size() >= 24) {
if (s[23].isDigit())
staffIdx = s.mid(23,1).toInt() - 1;
}
Staff* staff = part->staff(staffIdx);
int gstaff = staff->idx();
int pitch = table[step] + alter + (octave + 1) * 12;
if (pitch < 0)
pitch = 0;
if (pitch > 127)
pitch = 127;
int ticks = s.mid(5, 3).toInt();
ticks = (ticks * MScore::division + _division/2) / _division;
int tick = curTick;
curTick += ticks;
Tuplet* tuplet = 0;
if (s.size() >= 22) {
int a = 1;
int b = 1;
if (s[19] != ' ') {
a = s[19].toLatin1() - '0';
if (a == 3 && s[20] != ':')
b = 2;
else {
b = s[21].toLatin1() - '0';
}
}
if (a == 3 && b == 2) { // triplet
if (chordRest && chordRest->tuplet() && ntuplet) {
tuplet = chordRest->tuplet();
}
else {
tuplet = new Tuplet(score);
tuplet->setTrack(gstaff * VOICES);
tuplet->setTick(tick);
ntuplet = a;
tuplet->setRatio(Fraction(a, b));
measure->add(tuplet);
}
}
else if (a == 1 && b == 1)
;
else
qDebug("unsupported tuple %d/%d", a, b);
}
Chord* chord = new Chord(score);
chordRest = chord;
chord->setTrack(gstaff * VOICES);
chord->setStemDirection(dir);
if (tuplet) {
chord->setTuplet(tuplet);
tuplet->add(chord);
--ntuplet;
}
TDuration d;
d.setVal(ticks);
chord->setDurationType(d);
Segment* segment = measure->getSegment(chord, tick);
voice = 0;
for (; voice < VOICES; ++voice) {
Element* e = segment->element(gstaff * VOICES + voice);
if (e == 0) {
chord->setTrack(gstaff * VOICES + voice);
segment->add(chord);
break;
}
}
if (voice == VOICES) {
qDebug("cannot allocate voice");
delete chord;
return;
}
Note* note = new Note(score);
note->setPitch(pitch);
note->setTpcFromPitch();
note->setTrack(gstaff * VOICES + voice);
chord->add(note);
QString dynamics;
QString an = s.mid(31, 11);
for (int i = 0; i < an.size(); ++i) {
if (an[i] == '(')
openSlur(0, tick, staff, voice);
else if (an[i] == ')')
closeSlur(0, tick, staff, voice);
else if (an[i] == '[')
openSlur(1, tick, staff, voice);
else if (an[i] == ']')
closeSlur(1, tick, staff, voice);
else if (an[i] == '{')
openSlur(2, tick, staff, voice);
else if (an[i] == '}')
closeSlur(2, tick, staff, voice);
else if (an[i] == 'z')
openSlur(3, tick, staff, voice);
else if (an[i] == 'x')
closeSlur(3, tick, staff, voice);
else if (an[i] == '.') {
Articulation* atr = new Articulation(score);
atr->setArticulationType(Articulation_Staccato);
chord->add(atr);
}
else if (an[i] == '_') {
Articulation* atr = new Articulation(score);
atr->setArticulationType(Articulation_Tenuto);
chord->add(atr);
}
else if (an[i] == 'v') {
Articulation* atr = new Articulation(score);
atr->setArticulationType(Articulation_Upbow);
chord->add(atr);
}
else if (an[i] == 'n') {
Articulation* atr = new Articulation(score);
atr->setArticulationType(Articulation_Downbow);
chord->add(atr);
}
else if (an[i] == 't') {
Articulation* atr = new Articulation(score);
atr->setArticulationType(Articulation_Trill);
chord->add(atr);
}
else if (an[i] == 'F') {
Articulation* atr = new Articulation(score);
atr->setUp(true);
atr->setArticulationType(Articulation_Fermata);
chord->add(atr);
}
else if (an[i] == 'E') {
Articulation* atr = new Articulation(score);
atr->setUp(false);
atr->setArticulationType(Articulation_Fermata);
chord->add(atr);
}
else if (an[i] == 'O') {
// Articulation* atr = new Articulation(score);
// atr->setArticulationType(Articulation_Downbow);
// chord->add(atr);
qDebug("%06d: open string '%c' not implemented", tick, an[i].toLatin1());
}
else if (an[i] == '&') {
// skip editorial level
if (i <= an.size() && an[i+1].isDigit())
++i;
}
else if (an[i] == 'p')
dynamics += "p";
else if (an[i] == 'm')
dynamics += "m";
else if (an[i] == 'f')
dynamics += "f";
else if (an[i] == '-') // tie
;
else if (an[i] == '*') // start tuplet
;
else if (an[i] == '!') // stop tuplet
;
else if (an[i] == '+') // cautionary accidental
;
else if (an[i] == 'X') // ???
;
else if (an[i] == ' ')
;
else {
qDebug("%06d: notation '%c' not implemented", tick, an[i].toLatin1());
}
}
if (!dynamics.isEmpty()) {
Dynamic* dyn = new Dynamic(score);
dyn->setDynamicType(dynamics);
dyn->setTrack(gstaff * VOICES);
Segment* s = measure->getSegment(Segment::SegChordRest, tick);
s->add(dyn);
}
QString txt = s.mid(43, 36);
if (!txt.isEmpty()) {
QStringList sl = txt.split("|");
int no = 0;
foreach(QString w, sl) {
w = diacritical(w);
Lyrics* l = new Lyrics(score);
l->setText(w);
l->setNo(no++);
l->setTrack(gstaff * VOICES);
Segment* segment = measure->tick2segment(tick);
segment->add(l);
}
void ScoreView::lyricsMinus()
{
Lyrics* lyrics = (Lyrics*)editObject;
int track = lyrics->track();
int staffIdx = lyrics->staffIdx();
Segment* segment = lyrics->segment();
int verse = lyrics->no();
endEdit();
// search next chord
Segment* nextSegment = segment;
while ((nextSegment = nextSegment->next1(Segment::SegChordRest | Segment::SegGrace))) {
Element* el = nextSegment->element(track);
if (el && el->type() == Element::CHORD)
break;
}
if (nextSegment == 0) {
return;
}
// search previous lyric
Lyrics* oldLyrics = 0;
while (segment) {
const QList<Lyrics*>* nll = segment->lyricsList(staffIdx);
if (!nll) {
segment = segment->prev1(Segment::SegChordRest | Segment::SegGrace);
continue;
}
oldLyrics = nll->value(verse);
if (oldLyrics)
break;
segment = segment->prev1(Segment::SegChordRest | Segment::SegGrace);
}
_score->startCmd();
const QList<Lyrics*>* ll = nextSegment->lyricsList(staffIdx);
lyrics = ll->value(verse);
bool newLyrics = (lyrics == 0);
if (!lyrics) {
lyrics = new Lyrics(_score);
lyrics->setTrack(track);
lyrics->setParent(nextSegment->element(track));
lyrics->setNo(verse);
lyrics->setSyllabic(Lyrics::END);
}
if(lyrics->syllabic()==Lyrics::BEGIN) {
lyrics->setSyllabic(Lyrics::MIDDLE);
}
else if(lyrics->syllabic()==Lyrics::SINGLE) {
lyrics->setSyllabic(Lyrics::END);
}
if (oldLyrics) {
switch(oldLyrics->syllabic()) {
case Lyrics::BEGIN:
case Lyrics::MIDDLE:
break;
case Lyrics::SINGLE:
oldLyrics->setSyllabic(Lyrics::BEGIN);
break;
case Lyrics::END:
oldLyrics->setSyllabic(Lyrics::MIDDLE);
break;
}
}
if(newLyrics)
_score->undoAddElement(lyrics);
_score->select(lyrics, SELECT_SINGLE, 0);
startEdit(lyrics, -1);
mscore->changeState(mscoreState());
adjustCanvasPosition(lyrics, false);
((Lyrics*)editObject)->moveCursorToEnd();
_score->setLayoutAll(true);
_score->end2();
_score->end1();
}
