MuseScore/libmscore/edit.cpp

2115 lines
83 KiB
C++
Raw Normal View History

2012-05-26 14:26:10 +02:00
//=============================================================================
// MuseScore
// Music Composition & Notation
//
// Copyright (C) 2002-2012 Werner Schweer
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2
// as published by the Free Software Foundation and appearing in
// the file LICENCE.GPL
//=============================================================================
#include "note.h"
#include "rest.h"
#include "chord.h"
#include "key.h"
#include "sig.h"
#include "clef.h"
#include "score.h"
#include "slur.h"
2013-08-22 12:18:14 +02:00
#include "tie.h"
2012-05-26 14:26:10 +02:00
#include "hairpin.h"
#include "segment.h"
#include "staff.h"
#include "part.h"
#include "timesig.h"
#include "page.h"
#include "barline.h"
#include "tuplet.h"
#include "lyrics.h"
#include "image.h"
#include "keysig.h"
#include "beam.h"
#include "utils.h"
#include "harmony.h"
#include "system.h"
#include "navigate.h"
#include "articulation.h"
#include "drumset.h"
#include "measure.h"
#include "tempo.h"
#include "undo.h"
#include "stringdata.h"
2012-05-26 14:26:10 +02:00
#include "stafftype.h"
#include "tupletmap.h"
#include "tiemap.h"
#include "stem.h"
#include "iname.h"
#include "range.h"
#include "hook.h"
2012-08-08 20:46:29 +02:00
#include "pitchspelling.h"
#include "tempotext.h"
#include "dynamic.h"
2013-02-21 13:59:44 +01:00
#include "repeat.h"
2013-06-28 17:46:24 +02:00
#include "bracket.h"
#include "ottava.h"
2012-05-26 14:26:10 +02:00
2013-05-13 18:49:17 +02:00
namespace Ms {
2012-05-26 14:26:10 +02:00
//---------------------------------------------------------
// getSelectedNote
//---------------------------------------------------------
Note* Score::getSelectedNote()
{
Element* el = selection().element();
if (el) {
if (el->type() == Element::ElementType::NOTE)
2012-05-26 14:26:10 +02:00
return static_cast<Note*>(el);
}
selectNoteMessage();
return 0;
}
//---------------------------------------------------------
// getSelectedChordRest
//---------------------------------------------------------
ChordRest* Score::getSelectedChordRest() const
{
Element* el = selection().element();
if (el) {
if (el->type() == Element::ElementType::NOTE)
2012-05-26 14:26:10 +02:00
return static_cast<Note*>(el)->chord();
else if (el->type() == Element::ElementType::REST || el->type() == Element::ElementType::REPEAT_MEASURE)
2012-05-26 14:26:10 +02:00
return static_cast<Rest*>(el);
else if (el->type() == Element::ElementType::CHORD)
2012-05-26 14:26:10 +02:00
return static_cast<Chord*>(el);
}
selectNoteRestMessage();
return 0;
}
//---------------------------------------------------------
// getSelectedChordRest2
//---------------------------------------------------------
void Score::getSelectedChordRest2(ChordRest** cr1, ChordRest** cr2) const
{
*cr1 = 0;
*cr2 = 0;
foreach(Element* e, selection().elements()) {
if (e->type() == Element::ElementType::NOTE)
2012-05-26 14:26:10 +02:00
e = e->parent();
if (e->isChordRest()) {
ChordRest* cr = static_cast<ChordRest*>(e);
if (*cr1 == 0 || (*cr1)->tick() > cr->tick())
*cr1 = cr;
if (*cr2 == 0 || (*cr2)->tick() < cr->tick())
*cr2 = cr;
}
}
if (*cr1 == 0)
selectNoteRestMessage();
if (*cr1 == *cr2)
*cr2 = 0;
}
//---------------------------------------------------------
// pos
//---------------------------------------------------------
int Score::pos()
{
Element* el = selection().element();
if (selection().activeCR())
el = selection().activeCR();
if (el) {
switch(el->type()) {
case Element::ElementType::NOTE:
2012-05-26 14:26:10 +02:00
el = el->parent();
// fall through
case Element::ElementType::REPEAT_MEASURE:
case Element::ElementType::REST:
case Element::ElementType::CHORD:
2012-05-26 14:26:10 +02:00
return static_cast<ChordRest*>(el)->tick();
default:
break;
}
}
return -1;
}
//---------------------------------------------------------
// addRest
// create one Rest at tick with duration d
// create segment if necessary
//---------------------------------------------------------
Rest* Score::addRest(int tick, int track, TDuration d, Tuplet* tuplet)
{
Measure* measure = tick2measure(tick);
Rest* rest = new Rest(this, d);
if (d.type() == TDuration::DurationType::V_MEASURE)
2012-05-26 14:26:10 +02:00
rest->setDuration(measure->stretchedLen(staff(track/VOICES)));
else
rest->setDuration(d.fraction());
rest->setTrack(track);
rest->setTuplet(tuplet);
undoAddCR(rest, measure, tick);
return rest;
}
//---------------------------------------------------------
// addRest
//---------------------------------------------------------
Rest* Score::addRest(Segment* s, int track, TDuration d, Tuplet* tuplet)
{
Rest* rest = new Rest(this, d);
if (d.type() == TDuration::DurationType::V_MEASURE)
2012-05-26 14:26:10 +02:00
rest->setDuration(s->measure()->stretchedLen(staff(track/VOICES)));
else
rest->setDuration(d.fraction());
rest->setTrack(track);
rest->setParent(s);
rest->setTuplet(tuplet);
2014-02-25 10:02:39 +01:00
// undoAddElement(rest);
undoAddCR(rest, tick2measure(s->tick()), s->tick());
2012-05-26 14:26:10 +02:00
return rest;
}
//---------------------------------------------------------
// addChord
// Create one Chord at tick with duration d
// - create segment if necessary.
// - Use chord "oc" as prototype;
// - if "genTie" then tie to chord "oc"
//---------------------------------------------------------
Chord* Score::addChord(int tick, TDuration d, Chord* oc, bool genTie, Tuplet* tuplet)
{
Measure* measure = tick2measure(tick);
if (measure->endTick() <= tick) {
qDebug("Score::addChord(): end of score?");
return 0;
}
Chord* chord = new Chord(this);
chord->setTuplet(tuplet);
chord->setTrack(oc->track());
chord->setDurationType(d);
chord->setDuration(d.fraction());
foreach(Note* n, oc->notes()) {
Note* nn = new Note(this);
chord->add(nn);
nn->setPitch(n->pitch());
nn->setTpc1(n->tpc1());
nn->setTpc2(n->tpc2());
2012-05-26 14:26:10 +02:00
}
undoAddCR(chord, measure, tick);
//
// now as both chords are in place
// (have segments as parent) we can add ties:
//
if (genTie) {
int n = oc->notes().size();
for(int i = 0; i < n; ++i) {
Note* n = oc->notes()[i];
Note* nn = chord->notes()[i];
Tie* tie = new Tie(this);
tie->setStartNote(n);
tie->setEndNote(nn);
tie->setTrack(n->track());
undoAddElement(tie);
}
}
2014-04-22 17:02:03 +02:00
measure->cmdUpdateNotes(chord->staffIdx());
2012-05-26 14:26:10 +02:00
return chord;
}
//---------------------------------------------------------
// addClone
//---------------------------------------------------------
ChordRest* Score::addClone(ChordRest* cr, int tick, const TDuration& d)
{
qDebug("addClone %s at %d %s", cr->name(), tick, qPrintable(d.fraction().print()));
ChordRest* newcr;
// change a RepeatMeasure() into an Rest()
if (cr->type() == Element::ElementType::REPEAT_MEASURE)
2012-05-26 14:26:10 +02:00
newcr = new Rest(*static_cast<Rest*>(cr));
else
newcr = static_cast<ChordRest*>(cr->clone());
newcr->rxpos() = 0.0;
newcr->setDurationType(d);
newcr->setDuration(d.fraction());
newcr->setTuplet(cr->tuplet());
newcr->setSelected(false);
undoAddCR(newcr, cr->measure(), tick);
return newcr;
}
//---------------------------------------------------------
// setRest
// create one or more rests to fill "l"
//---------------------------------------------------------
Rest* Score::setRest(int tick, int track, Fraction l, bool useDots, Tuplet* tuplet, bool useFullMeasureRest)
2012-05-26 14:26:10 +02:00
{
Measure* measure = tick2measure(tick);
Rest* r = 0;
while (!l.isZero()) {
//
// divide into measures
//
Fraction f;
if (tuplet) {
int ticks = (tuplet->tick() + tuplet->actualTicks()) - tick;
f = Fraction::fromTicks(ticks);
for (Tuplet* t = tuplet; t; t = t->tuplet())
f *= t->ratio();
//
// restrict to tuplet len
//
if (f < l)
l = f;
}
else if (measure->tick() < tick)
f = Fraction::fromTicks(measure->tick() + measure->ticks() - tick);
else
f = measure->len();
if (f > l)
f = l;
if ((track % VOICES) && !measure->hasVoice(track) && (tick == measure->tick())) {
l -= f;
measure = measure->nextMeasure();
if (!measure)
break;
tick = measure->tick();
continue;
}
if ((measure->timesig() == measure->len()) // not in pickup measure
&& (measure->tick() == tick)
&& (measure->timesig() == f)
&& (useFullMeasureRest)) {
Rest* rest = addRest(tick, track, TDuration(TDuration::DurationType::V_MEASURE), tuplet);
2012-05-26 14:26:10 +02:00
tick += measure->timesig().ticks();
if (r == 0)
r = rest;
}
else {
//
// compute list of durations which will fit l
//
2013-06-04 18:29:14 +02:00
QList<TDuration> dList = toDurationList(f, useDots);
2012-05-26 14:26:10 +02:00
if (dList.isEmpty())
return 0;
foreach(TDuration d, dList) {
qDebug(" duration %d/%d", d.fraction().numerator(), d.fraction().denominator());
}
Rest* rest = 0;
if (((tick - measure->tick()) % dList[0].ticks()) == 0) {
foreach(TDuration d, dList) {
rest = addRest(tick, track, d, tuplet);
if (r == 0)
r = rest;
tick += rest->actualTicks();
}
}
else {
for (int i = dList.size() - 1; i >= 0; --i) {
rest = addRest(tick, track, dList[i], tuplet);
if (r == 0)
r = rest;
tick += rest->actualTicks();
}
}
}
l -= f;
measure = measure->nextMeasure();
if (!measure)
break;
tick = measure->tick();
}
return r;
}
//---------------------------------------------------------
// addNote from NoteVal
//---------------------------------------------------------
Note* Score::addNote(Chord* chord, NoteVal& noteVal)
{
Note* note = new Note(this);
note->setParent(chord);
note->setTrack(chord->track());
note->setNval(noteVal);
undoAddElement(note);
_playNote = true;
select(note, SelectType::SINGLE, 0);
if (!chord->staff()->isTabStaff())
2013-10-24 12:09:00 +02:00
_is.moveToNextInputPos();
return note;
}
2012-05-26 14:26:10 +02:00
//---------------------------------------------------------
// rewriteMeasures
2014-05-14 19:19:29 +02:00
// rewrite all measures from fm to lm
2012-05-26 14:26:10 +02:00
//---------------------------------------------------------
bool Score::rewriteMeasures(Measure* fm, Measure* lm, const Fraction& ns)
{
int measures = 1;
for (Measure* m = fm; m != lm; m = m -> nextMeasure())
++measures;
2012-05-26 14:26:10 +02:00
ScoreRange range;
2014-05-14 19:19:29 +02:00
range.read(fm->first(), lm->last());
2012-05-26 14:26:10 +02:00
if (!range.canWrite(ns))
return false;
//
// calculate number of required measures = nm
//
2014-05-14 19:19:29 +02:00
Fraction k = range.duration() / ns;
int nm = (k.numerator() + k.denominator() - 1)/ k.denominator();
2012-05-26 14:26:10 +02:00
Fraction nd(nm * ns.numerator(), ns.denominator()); // total new duration
2013-01-18 14:42:11 +01:00
// evtl. we have to fill the last measure
Fraction fill = nd - range.duration();
2014-05-14 19:19:29 +02:00
range.fill(fill);
for (Score* s : scoreList()) {
Measure* m1 = s->tick2measure(fm->tick());
Measure* m2 = s->tick2measure(lm->tick());
s->undoRemoveMeasures(m1, m2);
Measure* nlm = 0;
Measure* nfm = 0;
int tick = 0;
bool endBarGenerated = m1->endBarLineGenerated();
for (int i = 0; i < nm; ++i) {
Measure* m = new Measure(s);
m->setPrev(nlm);
if (nlm)
nlm->setNext(m);
m->setTimesig(ns);
m->setLen(ns);
m->setTick(tick);
m->setEndBarLineType(BarLineType::NORMAL, endBarGenerated);
2014-05-14 19:19:29 +02:00
tick += m->ticks();
nlm = m;
if (nfm == 0)
nfm = m;
}
nlm->setEndBarLineType(m2->endBarLineType(), m2->endBarLineGenerated(),
m2->endBarLineVisible(), m2->endBarLineColor());
//
// insert new calculated measures
//
nfm->setPrev(m1->prev());
nlm->setNext(m2->next());
s->undo(new InsertMeasures(nfm, nlm));
2012-05-26 14:26:10 +02:00
}
2014-05-14 19:19:29 +02:00
if (!range.write(rootScore(), fm->tick()))
qFatal("Cannot write measures");
2012-05-26 14:26:10 +02:00
return true;
}
//---------------------------------------------------------
// warnTupletCrossing
//---------------------------------------------------------
static void warnTupletCrossing()
{
2014-02-28 12:49:24 +01:00
if (!MScore::noGui)
2013-12-31 12:42:12 +01:00
QMessageBox::warning(0,
QT_TRANSLATE_NOOP("addRemoveTimeSig", "MuseScore"),
QT_TRANSLATE_NOOP("addRemoveTimeSig", "Cannot rewrite measures:\n"
2013-12-31 12:42:12 +01:00
"tuplet would cross measure")
);
2012-05-26 14:26:10 +02:00
}
//---------------------------------------------------------
// rewriteMeasures
// rewrite all measures up to the next time signature
//---------------------------------------------------------
2013-12-31 12:42:12 +01:00
bool Score::rewriteMeasures(Measure* fm, const Fraction& ns)
2012-05-26 14:26:10 +02:00
{
Measure* lm = fm;
Measure* fm1 = fm;
//
// split into Measure segments fm-lm
//
for (MeasureBase* m = fm; ; m = m->next()) {
if (!m || (m->type() != Element::ElementType::MEASURE)
|| (static_cast<Measure*>(m)->first(Segment::SegTimeSig) && m != fm))
2012-05-26 14:26:10 +02:00
{
if (!rewriteMeasures(fm1, lm, ns)) {
warnTupletCrossing();
for (Measure* m = fm1; m; m = m->nextMeasure()) {
if (m->first(Segment::SegTimeSig))
2012-05-26 14:26:10 +02:00
break;
Fraction fr(ns);
2014-05-26 18:18:01 +02:00
undoChangeProperty(m, P_ID::TIMESIG_NOMINAL, QVariant::fromValue(fr));
2012-05-26 14:26:10 +02:00
}
2013-12-31 12:42:12 +01:00
return false;
2012-05-26 14:26:10 +02:00
}
if (!m || m->type() == Element::ElementType::MEASURE)
2012-05-26 14:26:10 +02:00
break;
while (m->type() != Element::ElementType::MEASURE) {
2012-05-26 14:26:10 +02:00
m = m->next();
if (!m)
break;
}
2012-05-26 14:26:10 +02:00
fm1 = static_cast<Measure*>(m);
if (fm1 == 0)
break;
}
lm = static_cast<Measure*>(m);
}
2013-12-31 12:42:12 +01:00
return true;
2012-05-26 14:26:10 +02:00
}
//---------------------------------------------------------
// cmdAddTimeSig
//
// Add or change time signature at measure in response
// to gui command (drop timesig on measure or timesig)
//---------------------------------------------------------
void Score::cmdAddTimeSig(Measure* fm, int staffIdx, TimeSig* ts, bool local)
2012-05-26 14:26:10 +02:00
{
Fraction ns = ts->sig();
int tick = fm->tick();
TimeSig* lts = staff(staffIdx)->timeSig(tick);
Fraction stretch;
Fraction lsig; // last signature
2012-05-26 14:26:10 +02:00
if (lts) {
stretch = lts->stretch();
lsig = lts->sig();
}
else {
stretch.set(1,1);
lsig.set(4,4); // set to default
2012-05-26 14:26:10 +02:00
}
int track = staffIdx * VOICES;
Segment* seg = fm->undoGetSegment(Segment::SegTimeSig, tick);
2012-05-26 14:26:10 +02:00
TimeSig* ots = static_cast<TimeSig*>(seg->element(track));
if (ots) {
//
// ignore if there is already a timesig
// with same values
//
if ((ots->timeSigType() == ts->timeSigType())
2012-05-26 14:26:10 +02:00
&& (ots->sig().identical(ts->sig()))
&& (ots->stretch() == ts->stretch())) {
delete ts;
return;
}
}
if (local) {
ts->setParent(seg);
ts->setTrack(track);
2012-06-28 15:12:17 +02:00
ts->setStretch(ts->sig() / lsig);
undoAddElement(ts);
timesigStretchChanged(ts, fm, staffIdx);
return;
2012-05-26 14:26:10 +02:00
}
2014-05-14 19:19:29 +02:00
if (ots && ots->sig() == ts->sig() && ots->stretch() == ts->stretch()) {
foreach (Score* score, scoreList()) {
Measure* fm = score->tick2measure(tick);
2013-03-01 10:32:07 +01:00
for (Measure* m = fm; m; m = m->nextMeasure()) {
if ((m != fm) && m->first(Segment::SegTimeSig))
break;
bool changeActual = m->len() == m->timesig();
2014-05-26 18:18:01 +02:00
undoChangeProperty(m, P_ID::TIMESIG_NOMINAL, QVariant::fromValue(ns));
2013-03-01 10:32:07 +01:00
if (changeActual)
2014-05-26 18:18:01 +02:00
undoChangeProperty(m, P_ID::TIMESIG_ACTUAL, QVariant::fromValue(ns));
2013-03-01 10:32:07 +01:00
}
2012-05-26 14:26:10 +02:00
}
2014-05-14 19:19:29 +02:00
}
else {
Score* score = rootScore();
Measure* fm = score->tick2measure(tick);
//
// rewrite all measures up to the next time signature
//
if (fm == score->firstMeasure() && (fm->len() != fm->timesig())) {
// handle upbeat
2014-05-26 18:18:01 +02:00
undoChangeProperty(fm, P_ID::TIMESIG_NOMINAL, QVariant::fromValue(ns));
2014-05-14 19:19:29 +02:00
Measure* m = fm->nextMeasure();
Segment* s = m->findSegment(Segment::SegTimeSig, m->tick());
fm = s ? 0 : fm->nextMeasure();
}
2012-05-26 14:26:10 +02:00
else {
2014-05-14 19:19:29 +02:00
if (sigmap()->timesig(seg->tick()).timesig() == ts->sig())
fm = 0;
}
if (fm) {
if (!score->rewriteMeasures(fm, ns)) {
delete ts;
return;
2013-03-01 10:32:07 +01:00
}
2012-05-26 14:26:10 +02:00
}
2014-05-14 19:19:29 +02:00
foreach (Score* score, scoreList()) {
Measure* nfm = score->tick2measure(tick);
seg = nfm->undoGetSegment(Segment::SegTimeSig, nfm->tick());
int n = score->nstaves();
for (int staffIdx = 0; staffIdx < n; ++staffIdx) {
TimeSig* nsig = static_cast<TimeSig*>(seg->element(staffIdx * VOICES));
if (nsig == 0) {
nsig = new TimeSig(score);
nsig->setTrack(staffIdx * VOICES);
nsig->setParent(seg);
nsig->setSig(ts->sig(), ts->timeSigType());
undoAddElement(nsig);
}
else {
undo(new ChangeTimesig(nsig, false, ts->sig(), ts->stretch(),
ts->numeratorString(), ts->denominatorString(), ts->timeSigType()));
nsig->setDropTarget(0); // DEBUG
}
2013-03-01 10:32:07 +01:00
}
2012-05-26 14:26:10 +02:00
}
}
delete ts;
}
//---------------------------------------------------------
// timesigStretchChanged
//---------------------------------------------------------
void Score::timesigStretchChanged(TimeSig* ts, Measure* fm, int staffIdx)
{
for (Measure* m = fm; m; m = m->nextMeasure()) {
if ((m != fm) && m->first(Segment::SegTimeSig))
2012-05-26 14:26:10 +02:00
break;
int strack = staffIdx * VOICES;
int etrack = strack + VOICES;
for (Segment* s = m->first(Segment::SegChordRest); s; s = s->next(Segment::SegChordRest)) {
2012-05-26 14:26:10 +02:00
for (int track = strack; track < etrack; ++track) {
ChordRest* cr = static_cast<ChordRest*>(s->element(track));
if (!cr)
continue;
if (cr->type() == Element::ElementType::REST && cr->durationType() == TDuration::DurationType::V_MEASURE)
2012-06-28 15:12:17 +02:00
cr->setDuration(ts->sig());
2012-05-26 14:26:10 +02:00
else
qDebug("timeSigChanged: not implemented: chord/rest does not fit");
}
}
}
}
//---------------------------------------------------------
// cmdRemoveTimeSig
//---------------------------------------------------------
void Score::cmdRemoveTimeSig(TimeSig* ts)
{
Measure* m = ts->measure();
//
// we cannot remove a courtesy time signature
//
if (m->tick() != ts->segment()->tick())
return;
2012-05-26 14:26:10 +02:00
undoRemoveElement(ts->segment());
Measure* pm = m->prevMeasure();
2012-05-26 14:26:10 +02:00
Fraction ns(pm ? pm->timesig() : Fraction(4,4));
rewriteMeasures(m, ns);
2012-05-26 14:26:10 +02:00
}
//---------------------------------------------------------
// putNote
2014-05-27 10:35:28 +02:00
// mouse click in state NoteType::ENTRY
2012-05-26 14:26:10 +02:00
//---------------------------------------------------------
void Score::putNote(const QPointF& pos, bool replace)
{
Position p;
if (!getPosition(&p, pos, _is.voice())) {
qDebug("cannot put note here, get position failed");
return;
}
2012-08-07 12:44:19 +02:00
putNote(p, replace);
}
2012-05-26 14:26:10 +02:00
2012-08-07 12:44:19 +02:00
void Score::putNote(const Position& p, bool replace)
{
2012-05-26 14:26:10 +02:00
Segment* s = p.segment;
int staffIdx = p.staffIdx;
int line = p.line;
2012-08-07 12:44:19 +02:00
int tick = s->tick();
2012-05-26 14:26:10 +02:00
Staff* st = staff(staffIdx);
2012-08-07 12:44:19 +02:00
ClefType clef = st->clef(tick);
2012-05-26 14:26:10 +02:00
2014-04-15 14:18:56 +02:00
// qDebug("putNote at tick %d staff %d line %d clef %d",
// tick, staffIdx, line, clef);
2012-05-26 14:26:10 +02:00
_is.setTrack(staffIdx * VOICES + _is.voice());
_is.setSegment(s);
2014-04-10 13:13:37 +02:00
const Instrument* instr = st->part()->instr(s->tick());
2014-05-07 18:09:01 +02:00
Direction stemDirection = Direction::AUTO;
2012-05-26 14:26:10 +02:00
NoteVal nval;
2014-05-13 17:15:32 +02:00
const StringData* stringData = 0;
2014-04-28 18:38:50 +02:00
StaffType* tab = 0;
2012-05-26 14:26:10 +02:00
switch(st->staffType()->group()) {
case StaffGroup::PERCUSSION: {
2013-10-24 12:09:00 +02:00
if (_is.rest())
break;
2012-05-26 14:26:10 +02:00
Drumset* ds = instr->drumset();
nval.pitch = _is.drumNote();
if (nval.pitch < 0)
return;
nval.headGroup = ds->noteHead(nval.pitch);
if (nval.headGroup == NoteHeadGroup::HEAD_INVALID)
2012-05-26 14:26:10 +02:00
return;
stemDirection = ds->stemDirection(nval.pitch);
break;
}
case StaffGroup::TAB: {
2013-10-24 12:09:00 +02:00
if (_is.rest())
return;
stringData = instr->stringData();
2014-04-28 18:38:50 +02:00
tab = st->staffType();
int string = tab->VisualStringToPhys(line);
if (string < 0 || string >= stringData->strings())
2012-08-08 23:58:56 +02:00
return;
2012-05-26 14:26:10 +02:00
// build a default NoteVal for that line
nval.string = string;
if(p.fret != FRET_NONE) // if a fret is given, use it
nval.fret = p.fret;
else { // if no fret, use 0 as default
_is.setString(line);
nval.fret = 0;
}
nval.pitch = stringData->getPitch(string, nval.fret);
2012-05-26 14:26:10 +02:00
break;
}
case StaffGroup::STANDARD: {
AccidentalVal acci = s->measure()->findAccidental(s, staffIdx, line);
2012-08-08 20:46:29 +02:00
int step = absStep(line, clef);
int octave = step/7;
nval.pitch = step2pitch(step) + octave * 12 + int(acci);
2014-05-26 15:31:36 +02:00
if (!styleB(StyleIdx::concertPitch))
2014-04-10 14:55:34 +02:00
nval.pitch += instr->transpose().chromatic;
2014-04-11 14:50:53 +02:00
nval.tpc = step2tpc(step % 7, acci);
2012-08-08 20:46:29 +02:00
}
2012-05-26 14:26:10 +02:00
break;
}
expandVoice();
ChordRest* cr = _is.cr();
bool addToChord = false;
if (cr) {
// retrieve total duration of current chord
2012-05-26 14:26:10 +02:00
TDuration d = cr->durationType();
// if not in replace mode AND chord duration == input duration AND not rest input
// we need to add to current chord (otherwise, we will need to replace it or create a new onw)
2012-05-26 14:26:10 +02:00
if (!replace
&& (d == _is.duration())
&& (cr->type() == Element::ElementType::CHORD)
2013-10-24 12:09:00 +02:00
&& !_is.rest())
2012-05-26 14:26:10 +02:00
{
if (st->isTabStaff()) { // TAB
// if a note on same string already exists, update to new pitch/fret
foreach(Note * note, static_cast<Chord*>(cr)->notes())
if(note->string() == nval.string) { // if string is the same
// if adding a new digit will keep fret number within fret limit,
// add a digit to existing fret number
if (stringData) {
int fret = note->fret() * 10 + nval.fret;
if (fret <= stringData->frets() ) {
nval.fret = fret;
nval.pitch = stringData->getPitch(nval.string, nval.fret);
}
else
qDebug("can't increase fret to %d", fret);
}
// set fret number (orignal or combined) in all linked notes
// int tpc1 = pitch2tpc(nval.pitch, Key::C, Prefer::NEAREST);
foreach (Element* e, note->linkList()) {
Note* linkedNote = static_cast<Note*>(e);
nval.tpc = linkedNote->tpc1default(nval.pitch);
Staff* staff = linkedNote->staff();
if (staff->isTabStaff()) {
2014-05-26 18:18:01 +02:00
(static_cast<Note*>(linkedNote))->undoChangeProperty(P_ID::PITCH, nval.pitch);
(static_cast<Note*>(linkedNote))->undoChangeProperty(P_ID::TPC1, nval.tpc);
(static_cast<Note*>(linkedNote))->undoChangeProperty(P_ID::FRET, nval.fret);
(static_cast<Note*>(linkedNote))->undoChangeProperty(P_ID::STRING,nval.string);
}
2014-04-14 10:39:27 +02:00
else if (staff->isPitchedStaff()) {
// TODO: check tpc2
int tpc2 = linkedNote->tpc2default(nval.pitch);
undoChangePitch(linkedNote, nval.pitch, nval.tpc, tpc2);
2014-04-14 10:39:27 +02:00
}
}
return;
}
}
else { // not TAB
// if a note with the same pitch already exists in the chord, remove it
Chord* chord = static_cast<Chord*>(cr);
Note* note = chord->findNote(nval.pitch);
if (note) {
if (chord->notes().size() > 1)
undoRemoveElement(note);
return;
}
2012-05-26 14:26:10 +02:00
}
addToChord = true; // if no special case, add note to chord
2012-05-26 14:26:10 +02:00
}
}
if (addToChord && cr->type() == Element::ElementType::CHORD) {
// if adding, add!
addNote(static_cast<Chord*>(cr), nval);
return;
}
2012-05-26 14:26:10 +02:00
else {
// if not adding, replace current chord (or create a new one)
2013-10-24 12:09:00 +02:00
if (_is.rest())
2012-05-26 14:26:10 +02:00
nval.pitch = -1;
setNoteRest(_is.segment(), _is.track(), nval, _is.duration().fraction(), stemDirection);
}
if (!st->isTabStaff())
2013-10-24 12:09:00 +02:00
_is.moveToNextInputPos();
2012-05-26 14:26:10 +02:00
}
2013-04-18 11:41:14 +02:00
//---------------------------------------------------------
// repitchNote
//---------------------------------------------------------
void Score::repitchNote(const Position& p, bool replace)
{
Segment* s = p.segment;
int tick = s->tick();
Staff* st = staff(p.staffIdx);
ClefType clef = st->clef(tick);
NoteVal nval;
AccidentalVal acci = s->measure()->findAccidental(s, p.staffIdx, p.line);
int step = absStep(p.line, clef);
int octave = step / 7;
nval.pitch = step2pitch(step) + octave * 12 + int(acci);
2014-05-26 15:31:36 +02:00
if (!styleB(StyleIdx::concertPitch))
2014-04-10 14:55:34 +02:00
nval.pitch += st->part()->instr(s->tick())->transpose().chromatic;
nval.tpc = step2tpc(step % 7, acci);
2013-04-18 11:41:14 +02:00
Chord* chord;
if (_is.cr()->type() == Element::ElementType::REST) { //skip rests
ChordRest* next = nextChordRest(_is.cr());
while(next && next->type() != Element::ElementType::CHORD)
next = nextChordRest(next);
if(next)
2013-10-24 12:09:00 +02:00
_is.moveInputPos(next->segment());
return;
2013-04-18 11:41:14 +02:00
}
else {
chord = static_cast<Chord*>(_is.cr());
}
Note* note = new Note(this);
note->setNval(nval);
note->setParent(chord);
if (replace) {
while (!chord->notes().isEmpty())
undoRemoveElement(chord->notes().first());
}
undoAddElement(note);
2013-10-29 14:34:02 +01:00
select(note);
// move to next Chord
ChordRest* next = nextChordRest(_is.cr());
while(next && next->type() != Element::ElementType::CHORD)
next = nextChordRest(next);
2013-10-24 12:09:00 +02:00
if (next)
_is.moveInputPos(next->segment());
2013-04-18 11:41:14 +02:00
}
2012-05-26 14:26:10 +02:00
//---------------------------------------------------------
// cmdAddTie
//---------------------------------------------------------
void Score::cmdAddTie()
{
QList<Note*> noteList;
Element* el = selection().element();
if (el && el->type() == Element::ElementType::NOTE)
2012-05-26 14:26:10 +02:00
noteList.append(static_cast<Note*>(el));
else if (el && el->type() == Element::ElementType::STEM) {
2012-05-26 14:26:10 +02:00
Chord* chord = static_cast<Stem*>(el)->chord();
noteList = chord->notes();
}
else
noteList = selection().noteList();
if (noteList.isEmpty()) {
qDebug("no notes selected");
return;
}
startCmd();
foreach (Note* note, noteList) {
2013-08-31 12:44:59 +02:00
if(note->chord() && note->chord()->isGrace())
continue;
2012-05-26 14:26:10 +02:00
if (note->tieFor()) {
2013-07-24 10:02:50 +02:00
qDebug("cmdAddTie: note %p has already tie? noteFor: %p", note, note->tieFor());
2012-05-26 14:26:10 +02:00
continue;
}
Chord* chord = note->chord();
if (noteEntryMode()) {
2013-07-24 10:02:50 +02:00
if (note->chord() == _is.cr()) // if noteentry is started
break;
2012-05-26 14:26:10 +02:00
if (_is.cr() == 0) {
if (MScore::debugMode)
qDebug("cmdAddTie: no pos");
expandVoice();
}
if (_is.cr() == 0)
break;
bool addFlag = _is.cr()->type() == Element::ElementType::CHORD;
2012-05-26 14:26:10 +02:00
Note* n = addPitch(note->pitch(), addFlag);
if (n) {
// n is not necessarly next note if duration span over measure
Note* nnote = searchTieNote(note);
if (nnote) {
n->setLine(note->line());
n->setTpc(note->tpc());
Tie* tie = new Tie(this);
tie->setStartNote(note);
tie->setEndNote(nnote);
tie->setTrack(note->track());
undoAddElement(tie);
nextInputPos(n->chord(), false);
}
2012-05-26 14:26:10 +02:00
}
continue;
}
Note* note2 = searchTieNote(note);
Part* part = chord->staff()->part();
int strack = part->staves()->front()->idx() * VOICES;
int etrack = strack + part->staves()->size() * VOICES;
2013-06-12 14:23:57 +02:00
for (Segment* seg = chord->segment()->next1(Segment::SegChordRest); seg; seg = seg->next1(Segment::SegChordRest)) {
2012-05-26 14:26:10 +02:00
bool noteFound = false;
for (int track = strack; track < etrack; ++track) {
ChordRest* cr = static_cast<ChordRest*>(seg->element(track));
if (cr == 0 || cr->type() != Element::ElementType::CHORD)
2012-05-26 14:26:10 +02:00
continue;
int staffIdx = cr->staffIdx() + cr->staffMove();
if (staffIdx != chord->staffIdx() + chord->staffMove())
2012-05-26 14:26:10 +02:00
continue;
foreach(Note* n, static_cast<Chord*>(cr)->notes()) {
if (n->pitch() == note->pitch()) {
if (note2 == 0 || note->chord()->track() == chord->track())
note2 = n;
}
else if (cr->track() == chord->track())
noteFound = true;
}
}
if (noteFound || note2)
break;
}
2013-06-16 23:33:37 +02:00
if (note2) {
2013-06-05 16:18:31 +02:00
Tie* tie = new Tie(this);
tie->setStartNote(note);
tie->setEndNote(note2);
tie->setTrack(note->track());
undoAddElement(tie);
}
2012-05-26 14:26:10 +02:00
}
endCmd();
}
//---------------------------------------------------------
// cmdAddHairpin
// 'H' typed on keyboard
//---------------------------------------------------------
void Score::cmdAddHairpin(bool decrescendo)
{
ChordRest* cr1;
ChordRest* cr2;
getSelectedChordRest2(&cr1, &cr2);
if (!cr1)
return;
if (cr2 == 0)
cr2 = nextChordRest(cr1);
if (cr2 == 0)
return;
Hairpin* pin = new Hairpin(this);
2014-05-21 15:45:01 +02:00
pin->setHairpinType(decrescendo ? Hairpin::HairpinType::DECRESCENDO : Hairpin::HairpinType::CRESCENDO);
2012-05-26 14:26:10 +02:00
pin->setTrack(cr1->track());
2013-06-10 11:03:34 +02:00
pin->setTick(cr1->segment()->tick());
pin->setTick2(cr2->segment()->tick());
2012-05-26 14:26:10 +02:00
undoAddElement(pin);
if (!noteEntryMode())
select(pin, SelectType::SINGLE, 0);
2012-05-26 14:26:10 +02:00
}
//---------------------------------------------------------
// cmdAddOttava
//---------------------------------------------------------
void Score::cmdAddOttava(OttavaType type)
{
ChordRest* cr1;
ChordRest* cr2;
getSelectedChordRest2(&cr1, &cr2);
if (!cr1)
return;
if (cr2 == 0)
cr2 = cr1;
Ottava* ottava = new Ottava(this);
ottava->setOttavaType(type);
ottava->setTrack(cr1->track());
ottava->setTick(cr1->tick());
ottava->setTick2(cr2->tick());
undoAddElement(ottava);
if (!noteEntryMode())
select(ottava, SelectType::SINGLE, 0);
}
2012-05-26 14:26:10 +02:00
//---------------------------------------------------------
// cmdSetBeamMode
//---------------------------------------------------------
void Score::cmdSetBeamMode(BeamMode mode)
2012-05-26 14:26:10 +02:00
{
ChordRest* cr = getSelectedChordRest();
if (cr == 0)
return;
cr->setBeamMode(mode);
2012-05-26 14:26:10 +02:00
_layoutAll = true;
}
//---------------------------------------------------------
// cmdFlip
//---------------------------------------------------------
void Score::cmdFlip()
{
const QList<Element*>& el = selection().elements();
if (el.isEmpty()) {
selectNoteSlurMessage();
return;
}
foreach (Element* e, el) {
if (e->type() == Element::ElementType::NOTE || e->type() == Element::ElementType::STEM || e->type() == Element::ElementType::HOOK) {
Chord* chord;
if (e->type() == Element::ElementType::NOTE)
chord = static_cast<Note*>(e)->chord();
else if (e->type() == Element::ElementType::STEM)
2012-05-26 14:26:10 +02:00
chord = static_cast<Stem*>(e)->chord();
else if (e->type() == Element::ElementType::HOOK)
2012-05-26 14:26:10 +02:00
chord = static_cast<Hook*>(e)->chord();
if (chord->beam())
e = chord->beam(); // fall trough
else {
2014-05-07 18:09:01 +02:00
Direction dir = chord->up() ? Direction::DOWN : Direction::UP;
2014-05-26 18:18:01 +02:00
undoChangeProperty(chord, P_ID::STEM_DIRECTION, int(dir));
2012-05-26 14:26:10 +02:00
}
}
if (e->type() == Element::ElementType::BEAM) {
2012-05-26 14:26:10 +02:00
Beam* beam = static_cast<Beam*>(e);
2014-05-07 18:09:01 +02:00
Direction dir = beam->up() ? Direction::DOWN : Direction::UP;
2014-05-26 18:18:01 +02:00
undoChangeProperty(beam, P_ID::STEM_DIRECTION, int(dir));
2012-05-26 14:26:10 +02:00
}
else if (e->type() == Element::ElementType::SLUR_SEGMENT) {
2012-05-26 14:26:10 +02:00
SlurTie* slur = static_cast<SlurSegment*>(e)->slurTie();
2014-05-07 18:09:01 +02:00
Direction dir = slur->up() ? Direction::DOWN : Direction::UP;
2014-05-26 18:18:01 +02:00
undoChangeProperty(slur, P_ID::SLUR_DIRECTION, int(dir));
2012-05-26 14:26:10 +02:00
}
else if (e->type() == Element::ElementType::HAIRPIN_SEGMENT) {
2013-10-31 13:39:44 +01:00
Hairpin* h = static_cast<HairpinSegment*>(e)->hairpin();
2014-05-21 15:45:01 +02:00
Hairpin::HairpinType st = h->hairpinType() == Hairpin::HairpinType::CRESCENDO ? Hairpin::HairpinType::CRESCENDO : Hairpin::HairpinType::DECRESCENDO;
2014-05-26 18:18:01 +02:00
undoChangeProperty(h, P_ID::HAIRPIN_TYPE, int(st));
2012-05-26 14:26:10 +02:00
}
else if (e->type() == Element::ElementType::ARTICULATION) {
2012-05-26 14:26:10 +02:00
Articulation* a = static_cast<Articulation*>(e);
if (a->articulationType() == ArticulationType::Staccato
|| a->articulationType() == ArticulationType::Tenuto
|| a->articulationType() == ArticulationType::Sforzatoaccent) {
2012-05-26 14:26:10 +02:00
ArticulationAnchor aa = a->anchor();
if (aa == ArticulationAnchor::TOP_CHORD)
aa = ArticulationAnchor::BOTTOM_CHORD;
else if (aa == ArticulationAnchor::BOTTOM_CHORD)
aa = ArticulationAnchor::TOP_CHORD;
else if (aa == ArticulationAnchor::CHORD)
aa = a->up() ? ArticulationAnchor::BOTTOM_CHORD : ArticulationAnchor::TOP_CHORD;
2012-05-26 14:26:10 +02:00
if (aa != a->anchor())
2014-05-26 18:18:01 +02:00
undoChangeProperty(a, P_ID::ARTICULATION_ANCHOR, int(aa));
2012-05-26 14:26:10 +02:00
}
else {
2014-05-07 18:09:01 +02:00
Direction d = a->up() ? Direction::DOWN : Direction::UP;
2014-05-26 18:18:01 +02:00
undoChangeProperty(a, P_ID::DIRECTION, int(d));
2012-05-26 14:26:10 +02:00
}
return; // no layoutAll
}
else if (e->type() == Element::ElementType::TUPLET) {
2012-05-26 14:26:10 +02:00
Tuplet* tuplet = static_cast<Tuplet*>(e);
2014-05-07 18:09:01 +02:00
Direction d = tuplet->isUp() ? Direction::DOWN : Direction::UP;
2014-05-26 18:18:01 +02:00
undoChangeProperty(tuplet, P_ID::DIRECTION, int(d));
2012-05-26 14:26:10 +02:00
}
else if (e->type() == Element::ElementType::NOTEDOT) {
2014-04-02 20:31:37 +02:00
Note* note = static_cast<Note*>(e->parent());
2014-05-07 18:09:01 +02:00
Direction d = note->dotIsUp() ? Direction::DOWN : Direction::UP;
2014-05-26 18:18:01 +02:00
undoChangeProperty(note, P_ID::DOT_POSITION, int(d));
2014-04-02 20:31:37 +02:00
// undo(new FlipNoteDotDirection(static_cast<Note*>(e->parent())));
}
2012-10-31 14:39:14 +01:00
else if (
(e->type() == Element::ElementType::TEMPO_TEXT)
| (e->type() == Element::ElementType::DYNAMIC)
| (e->type() == Element::ElementType::HAIRPIN)
| (e->type() == Element::ElementType::DYNAMIC)
2012-10-31 14:39:14 +01:00
) {
2014-05-21 15:47:21 +02:00
Element::Placement p = e->placement() == Element::Placement::ABOVE ? Element::Placement::BELOW : Element::Placement::ABOVE;
2014-05-26 18:18:01 +02:00
undoChangeProperty(e, P_ID::PLACEMENT, int(p));
}
2012-05-26 14:26:10 +02:00
}
_layoutAll = true; // must be set in und/redo
}
//---------------------------------------------------------
// deleteItem
//---------------------------------------------------------
void Score::deleteItem(Element* el)
{
2013-09-28 11:02:51 +02:00
if (!el)
return;
2014-05-28 16:17:40 +02:00
// qDebug("deleteItem %s", el->name());
2014-04-22 17:02:03 +02:00
switch (el->type()) {
case Element::ElementType::INSTRUMENT_NAME: {
2012-05-26 14:26:10 +02:00
Part* part = el->staff()->part();
InstrumentName* in = static_cast<InstrumentName*>(el);
if (in->instrumentNameType() == InstrumentNameType::LONG)
2014-02-11 14:27:44 +01:00
undo(new ChangeInstrumentLong(0, part, QList<StaffName>()));
else if (in->instrumentNameType() == InstrumentNameType::SHORT)
2014-02-11 14:27:44 +01:00
undo(new ChangeInstrumentShort(0, part, QList<StaffName>()));
2012-05-26 14:26:10 +02:00
}
break;
case Element::ElementType::TIMESIG:
2012-05-26 14:26:10 +02:00
cmdRemoveTimeSig(static_cast<TimeSig*>(el));
break;
case Element::ElementType::KEYSIG:
2014-04-22 17:02:03 +02:00
undoRemoveElement(el);
cmdUpdateNotes();
break;
case Element::ElementType::OTTAVA_SEGMENT:
case Element::ElementType::HAIRPIN_SEGMENT:
case Element::ElementType::TRILL_SEGMENT:
case Element::ElementType::TEXTLINE_SEGMENT:
case Element::ElementType::VOLTA_SEGMENT:
case Element::ElementType::SLUR_SEGMENT:
case Element::ElementType::PEDAL_SEGMENT:
2012-05-26 14:26:10 +02:00
undoRemoveElement(static_cast<SpannerSegment*>(el)->spanner());
break;
case Element::ElementType::NOTE:
2012-05-26 14:26:10 +02:00
{
Chord* chord = static_cast<Chord*>(el->parent());
if (chord->notes().size() > 1) {
undoRemoveElement(el);
select(chord->downNote(), SelectType::SINGLE, 0);
2012-05-26 14:26:10 +02:00
break;
}
// else fall through
el = chord;
}
case Element::ElementType::CHORD:
2012-05-26 14:26:10 +02:00
{
Chord* chord = static_cast<Chord*>(el);
removeChordRest(chord, false);
// replace with rest if voice 0 or if in tuplet
Tuplet* tuplet = chord->tuplet();
2014-05-27 10:35:28 +02:00
// if ((el->voice() == 0 || tuplet) && (chord->noteType() == NoteType::NORMAL)) {
if (chord->noteType() == NoteType::NORMAL) {
2012-05-26 14:26:10 +02:00
Rest* rest = new Rest(this, chord->durationType());
rest->setDurationType(chord->durationType());
rest->setDuration(chord->duration());
2012-08-08 20:46:29 +02:00
2012-05-26 14:26:10 +02:00
rest->setTrack(el->track());
rest->setParent(chord->parent());
Segment* segment = chord->segment();
undoAddCR(rest, segment->measure(), segment->tick());
2012-08-08 20:46:29 +02:00
2012-05-26 14:26:10 +02:00
// undoAddElement(rest);
if (tuplet) {
tuplet->add(rest);
rest->setTuplet(tuplet);
rest->setDurationType(chord->durationType());
}
select(rest, SelectType::SINGLE, 0);
2012-05-26 14:26:10 +02:00
}
else {
// remove segment if empty
Segment* seg = chord->segment();
if (seg->isEmpty())
undoRemoveElement(seg);
}
}
break;
case Element::ElementType::REPEAT_MEASURE:
2013-02-21 13:59:44 +01:00
{
RepeatMeasure* rm = static_cast<RepeatMeasure*>(el);
removeChordRest(rm, false);
Rest* rest = new Rest(this);
rest->setDurationType(TDuration::DurationType::V_MEASURE);
2013-02-21 13:59:44 +01:00
rest->setDuration(rm->measure()->len());
rest->setTrack(rm->track());
rest->setParent(rm->parent());
Segment* segment = rm->segment();
undoAddCR(rest, segment->measure(), segment->tick());
}
case Element::ElementType::REST:
2012-05-26 14:26:10 +02:00
//
// only allow for voices != 0
// e.g. voice 0 rests cannot be removed
//
{
Rest* rest = static_cast<Rest*>(el);
if (rest->tuplet() && rest->tuplet()->elements().empty())
undoRemoveElement(rest->tuplet());
if (el->voice() != 0)
undoRemoveElement(el);
}
break;
case Element::ElementType::ACCIDENTAL:
if (el->parent()->type() == Element::ElementType::NOTE)
changeAccidental(static_cast<Note*>(el->parent()), Accidental::AccidentalType::NONE);
2013-08-30 16:03:46 +02:00
else
undoRemoveElement(el);
2012-05-26 14:26:10 +02:00
break;
case Element::ElementType::BAR_LINE:
2012-05-26 14:26:10 +02:00
{
BarLine* bl = static_cast<BarLine*>(el);
if (bl->parent()->type() != Element::ElementType::SEGMENT)
break;
Segment* seg = static_cast<Segment*>(bl->parent());
bool normalBar = seg->measure()->endBarLineType() == BarLineType::NORMAL;
int tick = seg->tick();
Segment::SegmentType segType = seg->segmentType();
foreach(Score* score, scoreList()) {
Measure* m = score->tick2measure(tick);
if (segType == Segment::SegStartRepeatBarLine)
2014-05-26 18:18:01 +02:00
undoChangeProperty(m, P_ID::REPEAT_FLAGS, m->repeatFlags() & ~Repeat::START);
else if (segType == Segment::SegBarLine)
undoRemoveElement(el);
else if (segType == Segment::SegEndBarLine) {
// if bar line has custom barLineType, change to barLineType of the whole measure
if (bl->customSubtype()) {
undoChangeProperty(bl, P_ID::SUBTYPE, int(seg->measure()->endBarLineType()));
}
// otherwise, if whole measure has special end bar line, change to normal
else if (!normalBar) {
if (m->tick() >= tick)
m = m->prevMeasure();
2014-05-26 18:18:01 +02:00
undoChangeProperty(m, P_ID::REPEAT_FLAGS, m->repeatFlags() & ~Repeat::END);
Measure* nm = m->nextMeasure();
if (nm)
2014-05-26 18:18:01 +02:00
undoChangeProperty(nm, P_ID::REPEAT_FLAGS, nm->repeatFlags() & ~Repeat::START);
undoChangeEndBarLineType(m, BarLineType::NORMAL);
m->setEndBarLineGenerated(true);
}
2012-05-26 14:26:10 +02:00
}
}
}
break;
2013-09-28 11:02:51 +02:00
case Element::ElementType::TUPLET:
2012-05-26 14:26:10 +02:00
cmdDeleteTuplet(static_cast<Tuplet*>(el), true);
break;
case Element::ElementType::MEASURE:
2013-06-19 16:25:29 +02:00
undoRemoveMeasures(static_cast<Measure*>(el), static_cast<Measure*>(el));
2013-06-16 23:33:37 +02:00
break;
case Element::ElementType::BRACKET:
2013-06-28 17:46:24 +02:00
undoRemoveBracket(static_cast<Bracket*>(el));
break;
case Element::ElementType::LAYOUT_BREAK:
2013-09-27 18:43:25 +02:00
{
undoRemoveElement(el);
LayoutBreak* lb = static_cast<LayoutBreak*>(el);
Measure* m = lb->measure();
if (m->isMMRest()) {
2013-09-28 11:02:51 +02:00
// propagate to original measure
2013-10-30 14:21:08 +01:00
m = m->mmRestLast();
2013-09-27 18:43:25 +02:00
foreach(Element* e, *m->el()) {
if (e->type() == Element::ElementType::LAYOUT_BREAK) {
2013-09-27 18:43:25 +02:00
undoRemoveElement(e);
break;
}
}
}
}
2013-09-28 11:02:51 +02:00
break;
case Element::ElementType::CLEF:
2013-09-28 11:02:51 +02:00
{
Clef* clef = static_cast<Clef*>(el);
2014-05-08 17:59:24 +02:00
int tick = clef->segment()->tick();
2013-09-28 11:02:51 +02:00
Measure* m = clef->measure();
if (m->isMMRest()) {
// propagate to original measure
2013-10-30 14:21:08 +01:00
m = m->mmRestLast();
2013-09-28 11:02:51 +02:00
Segment* s = m->findSegment(Segment::SegClef, clef->segment()->tick());
2014-05-08 17:59:24 +02:00
if (s && s->element(clef->track())) {
Clef* c = static_cast<Clef*>(s->element(clef->track()));
undoRemoveElement(c);
undo(new SetClefType(c->staff(), tick, c->staff()->clefTypeList(tick-1)));
}
2013-09-28 11:02:51 +02:00
}
2014-05-08 17:59:24 +02:00
else {
undoRemoveElement(clef);
undo(new SetClefType(clef->staff(), tick, clef->staff()->clefTypeList(tick-1)));
}
cmdUpdateNotes();
2013-10-30 14:21:08 +01:00
}
break;
case Element::ElementType::REHEARSAL_MARK:
case Element::ElementType::TEMPO_TEXT:
2013-10-30 14:21:08 +01:00
{
Segment* s = static_cast<Segment*>(el->parent());
Measure* m = s->measure();
if (m->isMMRest()) {
// propagate to original measure/element
m = m->mmRestFirst();
Segment* ns = m->findSegment(Segment::SegChordRest, s->tick());
for (Element* e : ns->annotations()) {
if (e->type() == el->type() && e->track() == el->track()) {
el = e;
undoRemoveElement(el);
break;
}
}
}
else
undoRemoveElement(el);
2013-09-28 11:02:51 +02:00
}
2013-09-27 18:43:25 +02:00
break;
2012-05-26 14:26:10 +02:00
default:
undoRemoveElement(el);
break;
}
}
//---------------------------------------------------------
// cmdDeleteSelectedMeasures
//---------------------------------------------------------
void Score::cmdDeleteSelectedMeasures()
{
2014-05-24 12:53:50 +02:00
if (!selection().isRange())
2012-05-26 14:26:10 +02:00
return;
MeasureBase* is = selection().startSegment()->measure();
Segment* seg = selection().endSegment();
MeasureBase* ie;
// choose the correct last measure based on the end segment
// this depends on whether a whole measure is selected or only a few notes within it
if (seg)
ie = seg->prev() ? seg->measure() : seg->measure()->prev();
else
ie = lastMeasure();
Measure* mBeforeSel = is->prevMeasure();
2012-05-26 14:26:10 +02:00
// createEndBar if last measure is deleted
bool createEndBar = false;
if (ie->type() == Element::ElementType::MEASURE) {
Measure* iem = static_cast<Measure*>(ie);
createEndBar = (iem == lastMeasureMM()) && (iem->endBarLineType() == BarLineType::END);
2012-05-26 14:26:10 +02:00
}
// get the last deleted timesig in order to restore after deletion
TimeSig* lastDeletedSig = 0;
for (MeasureBase* mb = ie;; mb = mb->prev()) {
if (mb->type() == Element::ElementType::MEASURE) {
Measure* m = static_cast<Measure*>(mb);
Segment* sts = m->findSegment(Segment::SegTimeSig, m->tick());
if (sts) {
lastDeletedSig = static_cast<TimeSig*>(sts->element(0));
break;
}
}
if (mb == is)
break;
}
2012-05-26 14:26:10 +02:00
QList<Score*> scores = scoreList();
2014-02-28 14:25:47 +01:00
int startTick = is->tick();
2014-03-03 17:24:28 +01:00
// int endIdx = measureIdx(ie);
// Measure* m = static_cast<Measure *>(ie);
// if (m->isMMRest())
// endIdx += m->mmRestCount() - 1;
// int endTick = measure(endIdx)->tick();
int endTick = ie->tick();
2013-06-16 23:33:37 +02:00
foreach (Score* score, scores) {
2013-07-24 14:33:35 +02:00
Measure* is = score->tick2measure(startTick);
Measure* ie = score->tick2measure(endTick);
2013-06-20 15:25:11 +02:00
mBeforeSel = is->prevMeasure();
2013-07-24 14:33:35 +02:00
2013-06-19 16:25:29 +02:00
int ticks = 0;
2013-07-24 14:33:35 +02:00
for (Measure* m = is; m; m = m->nextMeasure()) {
ticks += m->ticks();
if (m == ie)
2012-05-26 14:26:10 +02:00
break;
}
2013-07-24 14:33:35 +02:00
2013-07-24 14:46:26 +02:00
#if 0
2013-07-24 14:33:35 +02:00
// remove spanner
std::list<Spanner*> sl;
int tick2 = startTick + ticks;
for (auto i : score->_spanner.map()) {
Spanner* s = i.second;
if (s->tick() >= startTick && s->tick() < tick2)
sl.push_back(s);
}
for (Spanner* s : sl)
score->undoRemoveElement(s);
2013-07-24 14:46:26 +02:00
#endif
2013-07-24 14:33:35 +02:00
undoRemoveMeasures(is, ie);
// adjust views
Measure* focusOn = is;
if (focusOn->prevMeasure()) {
focusOn = focusOn->prevMeasure();
}
else {
focusOn = this->firstMeasure();
}
2014-04-03 23:05:36 +02:00
foreach(MuseScoreView* v, score->viewer)
v->adjustCanvasPosition(focusOn, false);
2013-06-20 15:25:11 +02:00
if (createEndBar) {
2013-07-24 14:33:35 +02:00
Measure* lastMeasure = score->lastMeasure();
if (lastMeasure && lastMeasure->endBarLineType() == BarLineType::NORMAL)
undoChangeEndBarLineType(lastMeasure, BarLineType::END);
2012-05-26 14:26:10 +02:00
}
2013-07-24 14:33:35 +02:00
2013-06-20 15:25:11 +02:00
// insert correct timesig after deletion
Measure* mAfterSel = mBeforeSel ? mBeforeSel->nextMeasure() : firstMeasure();
if (mAfterSel && lastDeletedSig) {
bool changed = true;
if (mBeforeSel) {
if (mBeforeSel->timesig() == mAfterSel->timesig()) {
changed = false;
}
}
2013-06-20 15:25:11 +02:00
Segment* s = mAfterSel->findSegment(Segment::SegTimeSig, mAfterSel->tick());
if (!s && changed) {
Segment* ns = mAfterSel->undoGetSegment(Segment::SegTimeSig, mAfterSel->tick());
for (int staffIdx = 0; staffIdx < score->nstaves(); staffIdx++) {
TimeSig* nts = new TimeSig(score);
nts->setTrack(staffIdx * VOICES);
nts->setParent(ns);
nts->setSig(lastDeletedSig->sig(), lastDeletedSig->timeSigType());
score->undoAddElement(nts);
}
}
}
}
select(0, SelectType::SINGLE, 0);
2012-05-26 14:26:10 +02:00
_is.setSegment(0); // invalidate position
}
//---------------------------------------------------------
// cmdDeleteSelection
//---------------------------------------------------------
void Score::cmdDeleteSelection()
{
2014-05-24 12:53:50 +02:00
if (selection().isRange()) {
2012-05-26 14:26:10 +02:00
Segment* s1 = selection().startSegment();
Segment* s2 = selection().endSegment();
int stick1 = selection().tickStart();
int stick2 = selection().tickEnd();
2012-05-26 14:26:10 +02:00
Segment* ss1 = s1;
if (ss1->segmentType() != Segment::SegChordRest)
ss1 = ss1->next1(Segment::SegChordRest);
bool fullMeasure = ss1 && (ss1->measure()->first(Segment::SegChordRest) == ss1)
&& (s2 == 0 || (s2->segmentType() == Segment::SegEndBarLine));
2012-05-26 14:26:10 +02:00
int tick2 = s2 ? s2->tick() : INT_MAX;
int track1 = selection().staffStart() * VOICES;
int track2 = selection().staffEnd() * VOICES;
for (auto i : _spanner.findOverlapping(stick1, stick2 - 1)) {
Spanner* sp = i.value;
if (sp->track() >= track1 && sp->track() < track2)
undoRemoveElement(sp);
}
2012-05-26 14:26:10 +02:00
for (int track = track1; track < track2; ++track) {
Fraction f;
int tick = -1;
Tuplet* tuplet = 0;
for (Segment* s = s1; s != s2; s = s->next1()) {
2013-06-12 14:23:57 +02:00
if (s->element(track) && s->segmentType() == Segment::SegBreath) {
2012-05-26 14:26:10 +02:00
deleteItem(s->element(track));
continue;
}
if (s->segmentType() != Segment::SegChordRest || !s->element(track))
2012-05-26 14:26:10 +02:00
continue;
ChordRest* cr = static_cast<ChordRest*>(s->element(track));
if (tick == -1) {
// first ChordRest found:
int offset = cr->tick() - s->measure()->tick();
if (cr->measure()->tick() >= s1->tick() && offset) {
f = Fraction::fromTicks(offset);
tick = s->measure()->tick();
}
else {
tick = s->tick();
f = Fraction();
}
tuplet = cr->tuplet();
if (tuplet && (tuplet->tick() == tick) && ((tuplet->tick() + tuplet->actualTicks()) < tick2) ) {
// remove complete top level tuplet
Tuplet* t = cr->tuplet();
while (t->tuplet())
t = t->tuplet();
cmdDeleteTuplet(t, false);
f += t->duration();
tuplet = 0;
continue;
}
}
if (tuplet != cr->tuplet()) {
Tuplet* t = cr->tuplet();
if (t && (((t->tick() + t->actualTicks()) <= tick2) || fullMeasure)) {
// remove complete top level tuplet
while (t->tuplet())
t = t->tuplet();
cmdDeleteTuplet(t, false);
f += t->duration();
tuplet = 0;
continue;
}
if (f.isValid())
setRest(tick, track, f, false, tuplet);
tick = cr->tick();
tuplet = cr->tuplet();
removeChordRest(cr, true);
f = cr->duration();
}
else {
removeChordRest(cr, true);
f += cr->duration();
}
}
if (f.isValid() && !f.isZero()) {
if (fullMeasure) {
// handle this as special case to be able to
// fix broken measures:
for (Measure* m = s1->measure(); m; m = m->nextMeasure()) {
setRest(m->tick(), track, Fraction(m->len()), false, 0);
if (s2 && (m == s2->measure()))
break;
}
}
else {
setRest(tick, track, f, false, tuplet);
}
}
}
2013-10-01 17:37:05 +02:00
s1 = tick2segment(stick1);
s2 = tick2segment(stick2);
if (s1 == 0 || s2 == 0)
deselectAll();
else {
_selection.setStartSegment(s1);
_selection.setEndSegment(s2);
_selection.updateSelectedElements();
}
2012-05-26 14:26:10 +02:00
}
else {
// deleteItem modifies selection().elements() list,
// so we need a local copy:
QList<Element*> el(selection().elements());
if (el.isEmpty())
qDebug("...nothing selected");
foreach(Element* e, el)
deleteItem(e);
}
_layoutAll = true;
}
//---------------------------------------------------------
// cmdFullMeasureRest
//---------------------------------------------------------
void Score::cmdFullMeasureRest()
{
2014-05-24 12:53:50 +02:00
if (selection().isRange()) {
Segment* s1 = selection().startSegment();
Segment* s2 = selection().endSegment();
int stick1 = selection().tickStart();
int stick2 = selection().tickEnd();
2014-02-25 10:02:39 +01:00
Segment* ss1 = s1;
if (ss1->segmentType() != Segment::SegChordRest)
ss1 = ss1->next1(Segment::SegChordRest);
bool fullMeasure = ss1 && (ss1->measure()->first(Segment::SegChordRest) == ss1)
2014-02-25 10:02:39 +01:00
&& (s2 == 0 || (s2->segmentType() == Segment::SegEndBarLine)
|| (s2->segmentType() == Segment::SegTimeSigAnnounce)
|| (s2->segmentType() == Segment::SegKeySigAnnounce));
if (!fullMeasure) {
return;
}
int track1 = selection().staffStart() * VOICES;
int track2 = selection().staffEnd() * VOICES;
for (int track = track1; track < track2; ++track) {
int tick = -1;
for (Segment* s = s1; s != s2; s = s->next1()) {
if (!(s->measure()->isOnlyRests(track))) // Don't remove anything from measures that contain notes
continue;
if (s->segmentType() != Segment::SegChordRest || !s->element(track))
continue;
ChordRest* cr = static_cast<ChordRest*>(s->element(track));
2014-02-25 10:02:39 +01:00
if (tick == -1) {
// first ChordRest found:
2014-05-30 13:35:44 +02:00
tick = s->measure()->tick();
removeChordRest(cr, true);
}
else {
removeChordRest(cr, true);
}
}
for (Measure* m = s1->measure(); m; m = m->nextMeasure()) {
if (!(track % VOICES) && m->isOnlyRests(track)) {
2014-05-30 13:35:44 +02:00
addRest(m->tick(), track, TDuration(TDuration::DurationType::V_MEASURE), 0);
}
if (s2 && (m == s2->measure()))
break;
}
}
s1 = tick2segment(stick1);
s2 = tick2segment(stick2);
if (s1 == 0 || s2 == 0)
deselectAll();
else {
_selection.setStartSegment(s1);
_selection.setEndSegment(s2);
_selection.updateSelectedElements();
}
}
_layoutAll = true;
}
2012-05-26 14:26:10 +02:00
//---------------------------------------------------------
// addLyrics
// called from Keyboard Accelerator & menue
//---------------------------------------------------------
Lyrics* Score::addLyrics()
{
Element* el = selection().element();
if (el == 0 || (el->type() != Element::ElementType::NOTE && el->type() != Element::ElementType::LYRICS)) {
2012-05-26 14:26:10 +02:00
QMessageBox::information(0,
QMessageBox::tr("MuseScore"),
2012-05-26 14:26:10 +02:00
QMessageBox::tr("No note or lyrics selected:\n"
"Please select a single note or lyrics and retry operation\n"),
QMessageBox::Ok, QMessageBox::NoButton);
return 0;
}
ChordRest* cr;
if (el->type() == Element::ElementType::NOTE) {
2012-05-26 14:26:10 +02:00
cr = static_cast<Note*>(el)->chord();
if(cr->isGrace())
cr = static_cast<ChordRest*>(cr->parent());
}
else if (el->type() == Element::ElementType::LYRICS)
2012-05-26 14:26:10 +02:00
cr = static_cast<Lyrics*>(el)->chordRest();
else
return 0;
QList<Lyrics*> ll = cr->lyricsList();
int no = ll.size();
Lyrics* lyrics = new Lyrics(this);
lyrics->setTrack(cr->track());
lyrics->setParent(cr);
lyrics->setNo(no);
undoAddElement(lyrics);
select(lyrics, SelectType::SINGLE, 0);
2012-05-26 14:26:10 +02:00
return lyrics;
}
//---------------------------------------------------------
// cmdCreateTuplet
// replace cr with tuplet
//---------------------------------------------------------
void Score::cmdCreateTuplet(ChordRest* ocr, Tuplet* tuplet)
{
2013-07-31 16:32:09 +02:00
qDebug("cmdCreateTuplet at %d <%s> track %d duration <%s> ratio <%s> baseLen <%s>",
ocr->tick(), ocr->name(), ocr->track(),
2012-05-26 14:26:10 +02:00
qPrintable(ocr->duration().print()),
qPrintable(tuplet->ratio().print()),
qPrintable(tuplet->baseLen().fraction().print())
);
int track = ocr->track();
Measure* measure = ocr->measure();
int tick = ocr->tick();
if (ocr->tuplet())
tuplet->setTuplet(ocr->tuplet());
undoRemoveElement(ocr);
ChordRest* cr;
if (ocr->type() == Element::ElementType::CHORD) {
2012-05-26 14:26:10 +02:00
cr = new Chord(this);
foreach (Note* oldNote, static_cast<Chord*>(ocr)->notes()) {
2012-05-26 14:26:10 +02:00
Note* note = new Note(this);
note->setPitch(oldNote->pitch());
note->setTpc1(oldNote->tpc1());
note->setTpc2(oldNote->tpc2());
2012-05-26 14:26:10 +02:00
cr->add(note);
}
}
else
cr = new Rest(this);
Fraction an = (tuplet->duration() * tuplet->ratio()) / tuplet->baseLen().fraction();
int actualNotes = an.numerator() / an.denominator();
2013-07-31 16:32:09 +02:00
tuplet->setTrack(track);
2012-05-26 14:26:10 +02:00
cr->setTuplet(tuplet);
cr->setTrack(track);
cr->setDurationType(tuplet->baseLen());
cr->setDuration(tuplet->baseLen().fraction());
2013-07-31 16:32:09 +02:00
qDebug("tuplet note duration %s actualNotes %d ticks %d track %d tuplet track %d",
qPrintable(tuplet->baseLen().name()), actualNotes, cr->actualTicks(), track, tuplet->track());
2012-05-26 14:26:10 +02:00
undoAddCR(cr, measure, tick);
int ticks = cr->actualTicks();
for (int i = 0; i < (actualNotes-1); ++i) {
tick += ticks;
Rest* rest = new Rest(this);
rest->setTuplet(tuplet);
rest->setTrack(track);
rest->setDurationType(tuplet->baseLen());
rest->setDuration(tuplet->baseLen().fraction());
undoAddCR(rest, measure, tick);
}
_layoutAll = true;
}
//---------------------------------------------------------
// colorItem
//---------------------------------------------------------
void Score::colorItem(Element* element)
{
QColor sc(element->color());
QColor c = QColorDialog::getColor(sc);
if (!c.isValid())
return;
foreach(Element* e, selection().elements()) {
if (e->color() != c) {
2014-05-26 18:18:01 +02:00
undoChangeProperty(e, P_ID::COLOR, c);
2012-05-26 14:26:10 +02:00
e->setGenerated(false);
refresh |= e->abbox();
if (e->type() == Element::ElementType::BAR_LINE) {
2012-05-26 14:26:10 +02:00
Element* ep = e->parent();
if (ep->type() == Element::ElementType::SEGMENT && static_cast<Segment*>(ep)->segmentType() == Segment::SegEndBarLine) {
2012-05-26 14:26:10 +02:00
Measure* m = static_cast<Segment*>(ep)->measure();
BarLine* bl = static_cast<BarLine*>(e);
m->setEndBarLineType(bl->barLineType(), false, e->visible(), e->color());
2012-05-26 14:26:10 +02:00
}
}
}
}
deselectAll();
}
//---------------------------------------------------------
// cmdExchangeVoice
//---------------------------------------------------------
void Score::cmdExchangeVoice(int s, int d)
{
2014-05-24 12:53:50 +02:00
if (!selection().isRange()) {
2012-05-26 14:26:10 +02:00
selectStavesMessage();
return;
}
int t1 = selection().tickStart();
int t2 = selection().tickEnd();
Measure* m1 = tick2measure(t1);
Measure* m2 = tick2measure(t2);
if (t2 > m2->tick())
m2 = 0;
for (;;) {
undoExchangeVoice(m1, s, d, selection().staffStart(), selection().staffEnd());
m1 = m1->nextMeasure();
if ((m1 == 0) || (m2 && (m1->tick() == m2->tick())))
break;
}
}
//---------------------------------------------------------
// cmdEnterRest
//---------------------------------------------------------
void Score::cmdEnterRest(const TDuration& d)
{
if (_is.track() == -1) {
qDebug("cmdEnterRest: track -1");
return;
}
startCmd();
expandVoice();
if (_is.cr() == 0) {
qDebug("cannot enter rest here");
return;
}
int track = _is.track();
NoteVal nval;
2014-05-07 18:09:01 +02:00
setNoteRest(_is.segment(), track, nval, d.fraction(), Direction::AUTO);
2013-10-24 12:09:00 +02:00
_is.moveToNextInputPos();
_is.setRest(false); // continue with normal note entry
2012-05-26 14:26:10 +02:00
endCmd();
}
//---------------------------------------------------------
// removeChordRest
// remove chord or rest
// remove associated segment if empty
// remove beam
// remove slurs
//---------------------------------------------------------
void Score::removeChordRest(ChordRest* cr, bool clearSegment)
{
2014-05-20 17:26:26 +02:00
QList<Segment*> segments;
for (Element* e : cr->linkList()) {
undo(new RemoveElement(e));
Segment* s = cr->segment();
if (!segments.contains(s))
segments.append(s);
}
2012-05-26 14:26:10 +02:00
if (clearSegment) {
2014-05-20 17:26:26 +02:00
for (Segment* s : segments) {
if (s->isEmpty())
undo(new RemoveElement(s));
}
2012-05-26 14:26:10 +02:00
}
if (cr->beam()) {
Beam* beam = cr->beam();
if (beam->generated()) {
beam->parent()->remove(beam);
delete beam;
}
else
undoRemoveElement(beam);
}
}
//---------------------------------------------------------
// cmdDeleteTuplet
// remove tuplet and replace with rest
//---------------------------------------------------------
void Score::cmdDeleteTuplet(Tuplet* tuplet, bool replaceWithRest)
{
qDebug("Score::cmdDeleteTuplet elements %d replace %d",
tuplet->elements().size(), replaceWithRest);
foreach(DurationElement* de, tuplet->elements()) {
qDebug(" element %s", de->name());
if (de->isChordRest())
removeChordRest(static_cast<ChordRest*>(de), true);
else {
Q_ASSERT(de->type() == Element::ElementType::TUPLET);
2012-05-26 14:26:10 +02:00
cmdDeleteTuplet(static_cast<Tuplet*>(de), false);
}
}
// undoRemoveElement(tuplet);
if (replaceWithRest) {
Rest* rest = setRest(tuplet->tick(), tuplet->track(), tuplet->duration(), true, 0);
if (tuplet->tuplet()) {
rest->setTuplet(tuplet->tuplet());
tuplet->tuplet()->add(rest);
}
}
}
//---------------------------------------------------------
// nextInputPos
//---------------------------------------------------------
void Score::nextInputPos(ChordRest* cr, bool doSelect)
{
ChordRest* ncr = nextChordRest(cr);
if ((ncr == 0) && (_is.track() % VOICES)) {
Segment* s = tick2segment(cr->tick() + cr->actualTicks());
int track = (cr->track() / VOICES) * VOICES;
ncr = s ? static_cast<ChordRest*>(s->element(track)) : 0;
}
_is.setSegment(ncr ? ncr->segment() : 0);
if (doSelect)
select(ncr, SelectType::SINGLE, 0);
2013-10-24 12:09:00 +02:00
if (ncr)
setPlayPos(ncr->tick());
2012-05-26 14:26:10 +02:00
}
2014-03-03 17:24:28 +01:00
//---------------------------------------------------------
// searchMeasureBase
// search corresponding measure in linked score
//---------------------------------------------------------
static MeasureBase* searchMeasureBase(Score* score, MeasureBase* mb)
{
if (mb == 0)
return nullptr;
if (mb->type() == Element::ElementType::MEASURE) {
2014-03-03 17:24:28 +01:00
for (Measure* m = score->firstMeasure(); m; m = m->nextMeasure()) {
if (m->tick() == mb->tick())
return m;
}
}
else {
if (!mb->links())
qDebug("searchMeasureBase: no links");
else {
for (Element* m : *mb->links()) {
if (m->score() == score)
return static_cast<MeasureBase*>(m);
}
}
}
qDebug("searchMeasureBase: measure not found");
return nullptr;
}
2012-05-26 14:26:10 +02:00
//---------------------------------------------------------
// insertMeasure
// Create a new MeasureBase of type type and insert
// before measure.
// If measure is zero, append new MeasureBase.
//---------------------------------------------------------
2014-02-28 14:25:47 +01:00
MeasureBase* Score::insertMeasure(Element::ElementType type, MeasureBase* measure, bool createEmptyMeasures)
2012-05-26 14:26:10 +02:00
{
int tick;
2014-03-03 17:24:28 +01:00
int ticks = 0;
2012-05-26 14:26:10 +02:00
if (measure) {
if (measure->type() == Element::ElementType::MEASURE && static_cast<Measure*>(measure)->isMMRest()) {
measure = static_cast<Measure*>(measure)->prev();
measure = measure ? measure->next() : firstMeasure();
2013-09-28 12:05:48 +02:00
deselectAll();
}
2012-05-26 14:26:10 +02:00
tick = measure->tick();
}
2014-03-03 17:24:28 +01:00
else
tick = last() ? last()->endTick() : 0;
// use nominal time signature of previous measure
Fraction f = sigmap()->timesig(tick - 1).nominal();
QList<pair<Score*, MeasureBase*>> ml;
for (Score* score : scoreList())
ml.append(pair<Score*,MeasureBase*>(score,searchMeasureBase(score, measure)));
2012-05-26 14:26:10 +02:00
2014-03-14 12:08:12 +01:00
MeasureBase* omb = nullptr;
2014-03-03 17:24:28 +01:00
for (pair<Score*, MeasureBase*> p : ml) {
Score* score = p.first;
MeasureBase* im = p.second;
2012-05-26 14:26:10 +02:00
MeasureBase* mb = static_cast<MeasureBase*>(Element::create(type, score));
mb->setTick(tick);
2014-03-14 12:08:12 +01:00
if (score == this)
omb = mb;
if (type == Element::ElementType::MEASURE) {
2014-03-03 17:24:28 +01:00
if (score == rootScore())
omb = static_cast<Measure*>(mb);
2012-05-26 14:26:10 +02:00
bool createEndBar = false;
bool endBarGenerated = false;
2014-03-03 17:24:28 +01:00
if (!measure) {
2012-05-26 14:26:10 +02:00
Measure* lm = score->lastMeasure();
if (lm && lm->endBarLineType() == BarLineType::END) {
2012-05-26 14:26:10 +02:00
createEndBar = true;
if (!lm->endBarLineGenerated()) {
score->undoChangeEndBarLineType(lm, BarLineType::NORMAL);
2012-05-26 14:26:10 +02:00
}
else {
endBarGenerated = true;
lm->setEndBarLineType(BarLineType::NORMAL, true);
2012-05-26 14:26:10 +02:00
}
}
2014-03-03 17:24:28 +01:00
else if (lm == nullptr)
2012-05-26 14:26:10 +02:00
createEndBar = true;
}
Measure* m = static_cast<Measure*>(mb);
m->setTimesig(f);
m->setLen(f);
2014-03-03 17:24:28 +01:00
ticks = m->ticks();
2012-05-26 14:26:10 +02:00
QList<TimeSig*> tsl;
QList<KeySig*> ksl;
QList<Clef*> cl;
if (tick == 0) {
//
// remove time and key signatures
//
for (int staffIdx = 0; staffIdx < nstaves(); ++staffIdx) {
for (Segment* s = score->firstSegment(); s && s->tick() == 0; s = s->next()) {
Element* e = s->element(staffIdx * VOICES);
2014-03-03 17:24:28 +01:00
if (e == nullptr)
2012-05-26 14:26:10 +02:00
continue;
if (e->type() == Element::ElementType::KEYSIG) {
2012-05-26 14:26:10 +02:00
KeySig* ks = static_cast<KeySig*>(e);
ksl.append(ks);
undo(new RemoveElement(ks));
if (ks->segment()->isEmpty())
undoRemoveElement(ks->segment());
}
else if (e->type() == Element::ElementType::TIMESIG) {
2012-05-26 14:26:10 +02:00
TimeSig* ts = static_cast<TimeSig*>(e);
tsl.append(ts);
undo(new RemoveElement(ts));
if (ts->segment()->isEmpty())
undoRemoveElement(ts->segment());
}
else if (e->type() == Element::ElementType::CLEF) {
2012-05-26 14:26:10 +02:00
Clef* clef = static_cast<Clef*>(e);
cl.append(clef);
undo(new RemoveElement(e));
if (clef->segment()->isEmpty())
undoRemoveElement(clef->segment());
}
}
}
}
undo(new InsertMeasure(m, im));
//
// if measure is inserted at tick zero,
// create key and time signature
//
foreach(TimeSig* ts, tsl) {
TimeSig* nts = new TimeSig(*ts);
Segment* s = m->undoGetSegment(Segment::SegTimeSig, 0);
2012-05-26 14:26:10 +02:00
nts->setParent(s);
undoAddElement(nts);
}
foreach(KeySig* ks, ksl) {
KeySig* nks = new KeySig(*ks);
Segment* s = m->undoGetSegment(Segment::SegKeySig, 0);
2012-05-26 14:26:10 +02:00
nks->setParent(s);
undoAddElement(nks);
}
foreach(Clef* clef, cl) {
Clef* nClef = new Clef(*clef);
Segment* s = m->undoGetSegment(Segment::SegClef, 0);
2012-05-26 14:26:10 +02:00
nClef->setParent(s);
undoAddElement(nClef);
}
if (createEndBar) {
2013-10-28 15:52:32 +01:00
// Measure* lm = score->lastMeasure();
// if (lm)
// lm->setEndBarLineType(BarLineType::END, endBarGenerated);
m->setEndBarLineType(BarLineType::END, endBarGenerated);
2012-05-26 14:26:10 +02:00
}
2013-02-27 18:16:24 +01:00
score->fixTicks();
2012-05-26 14:26:10 +02:00
}
else {
undo(new InsertMeasure(mb, im));
}
}
2014-03-03 17:24:28 +01:00
undoInsertTime(tick, ticks);
2013-06-21 15:19:15 +02:00
if (omb && type == Element::ElementType::MEASURE && !createEmptyMeasures) {
2012-05-26 14:26:10 +02:00
//
// fill measure with rest
//
2014-03-03 17:24:28 +01:00
Score* _root = rootScore();
for (int staffIdx = 0; staffIdx < _root->nstaves(); ++staffIdx) {
2013-02-27 18:16:24 +01:00
int track = staffIdx * VOICES;
2014-03-03 17:24:28 +01:00
int tick = omb->tick();
2014-03-14 12:08:12 +01:00
Segment* s = static_cast<Measure*>(omb)->findSegment(Segment::SegChordRest, tick);
2013-02-27 18:16:24 +01:00
if (s == 0 || s->element(track) == 0) {
// add rest to this staff and to all the staves linked to it
Rest* rest = new Rest(_root, TDuration(TDuration::DurationType::V_MEASURE));
2014-03-03 17:24:28 +01:00
Fraction timeStretch(_root->staff(staffIdx)->timeStretch(tick));
2014-03-14 12:08:12 +01:00
rest->setDuration(static_cast<Measure*>(omb)->len() / timeStretch);
2013-02-27 18:16:24 +01:00
rest->setTrack(track);
2014-03-14 12:08:12 +01:00
undoAddCR(rest, static_cast<Measure*>(omb), tick);
2013-02-27 18:16:24 +01:00
}
}
2012-05-26 14:26:10 +02:00
}
2014-03-03 17:24:28 +01:00
2012-05-26 14:26:10 +02:00
return omb;
}
2013-05-13 18:49:17 +02:00
}