672 lines
26 KiB
C++
672 lines
26 KiB
C++
//=============================================================================
|
|
// MuseScore
|
|
// Music Composition & Notation
|
|
//
|
|
// Copyright (C) 2002-2011 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 "utils.h"
|
|
#include "score.h"
|
|
#include "pitchspelling.h"
|
|
#include "key.h"
|
|
#include "staff.h"
|
|
#include "note.h"
|
|
#include "harmony.h"
|
|
#include "segment.h"
|
|
#include "undo.h"
|
|
#include "keysig.h"
|
|
#include "stafftype.h"
|
|
#include "chord.h"
|
|
#include "measure.h"
|
|
#include "fret.h"
|
|
#include "part.h"
|
|
|
|
namespace Ms {
|
|
|
|
//---------------------------------------------------------
|
|
// keydiff2Interval
|
|
// keysig - -7(Cb) - +7(C#)
|
|
//---------------------------------------------------------
|
|
|
|
static Interval keydiff2Interval(Key oKey, Key nKey, TransposeDirection dir)
|
|
{
|
|
static int stepTable[15] = {
|
|
// C G D A E B Fis
|
|
0, 4, 1, 5, 2, 6, 3,
|
|
};
|
|
|
|
int cofSteps; // circle of fifth steps
|
|
int diatonic;
|
|
if (nKey > oKey)
|
|
cofSteps = int(nKey) - int(oKey);
|
|
else
|
|
cofSteps = 12 - (int(oKey) - int(nKey));
|
|
diatonic = stepTable[(int(nKey) + 7) % 7] - stepTable[(int(oKey) + 7) % 7];
|
|
if (diatonic < 0)
|
|
diatonic += 7;
|
|
diatonic %= 7;
|
|
int chromatic = (cofSteps * 7) % 12;
|
|
|
|
|
|
if ((dir == TransposeDirection::CLOSEST) && (chromatic > 6))
|
|
dir = TransposeDirection::DOWN;
|
|
|
|
if (dir == TransposeDirection::DOWN) {
|
|
chromatic = chromatic - 12;
|
|
diatonic = diatonic - 7;
|
|
if (diatonic == -7)
|
|
diatonic = 0;
|
|
if (chromatic == -12)
|
|
chromatic = 0;
|
|
}
|
|
qDebug("TransposeByKey %d -> %d chromatic %d diatonic %d", oKey, nKey, chromatic, diatonic);
|
|
return Interval(diatonic, chromatic);
|
|
}
|
|
|
|
/*!
|
|
* Transposes both pitch and spelling for a note given an interval.
|
|
*
|
|
* Uses addition for pitch and transposeTpc() for spelling.
|
|
*
|
|
* @param pitch
|
|
* The initial (current) pitch. (pitch)
|
|
* @param tpc
|
|
* The initial spelling. (tpc)
|
|
* @param rpitch
|
|
* A pointer to the transposed pitch, calculated by this function. (pitch)
|
|
* @param rtpc
|
|
* A pointer to the transposed spelling. (tcp)
|
|
* @param interval
|
|
* The interval to transpose by.
|
|
* @param useDoubleSharpsFlats
|
|
* Determines whether the output may include double sharps or flats (Abb)
|
|
* or should use an enharmonic pitch (Abb = G).
|
|
*/
|
|
|
|
void transposeInterval(int pitch, int tpc, int* rpitch, int* rtpc, Interval interval,
|
|
bool useDoubleSharpsFlats)
|
|
{
|
|
*rpitch = pitch + interval.chromatic;
|
|
*rtpc = transposeTpc(tpc, interval, useDoubleSharpsFlats);
|
|
}
|
|
|
|
/*!
|
|
* Transposes a pitch spelling given an interval.
|
|
*
|
|
* This function transposes a pitch spelling using first
|
|
* a diatonic transposition and then calculating any accidentals.
|
|
* This insures that the note is changed by the correct number of
|
|
* scale degrees unless it would require too many accidentals.
|
|
*
|
|
* @param tpc
|
|
* The initial pitch spelling.
|
|
* @param interval
|
|
* The interval to be transposed by.
|
|
* @param useDoubleSharpsFlats
|
|
* Determines whether the output may include double sharps or flats (Abb)
|
|
* or should use an enharmonic pitch (Abb = G).
|
|
*
|
|
* @return
|
|
* The transposed pitch spelling (tpc).
|
|
*/
|
|
|
|
int transposeTpc(int tpc, Interval interval, bool useDoubleSharpsFlats)
|
|
{
|
|
if (tpc == Tpc::TPC_INVALID) // perfect unison & perfect octave
|
|
return tpc;
|
|
|
|
int minAlter;
|
|
int maxAlter;
|
|
if (useDoubleSharpsFlats) {
|
|
minAlter = -2;
|
|
maxAlter = 2;
|
|
}
|
|
else {
|
|
minAlter = -1;
|
|
maxAlter = 1;
|
|
}
|
|
int steps = interval.diatonic;
|
|
int semitones = interval.chromatic;
|
|
|
|
// qDebug("transposeTpc tpc %d steps %d semitones %d", tpc, steps, semitones);
|
|
if (semitones == 0 && steps == 0)
|
|
return tpc;
|
|
|
|
int step;
|
|
int alter;
|
|
int pitch = tpc2pitch(tpc);
|
|
|
|
for (int k = 0; k < 10; ++k) {
|
|
step = tpc2step(tpc) + steps;
|
|
while (step < 0)
|
|
step += 7;
|
|
step %= 7;
|
|
int p1 = tpc2pitch(step2tpc(step, AccidentalVal::NATURAL));
|
|
alter = semitones - (p1 - pitch);
|
|
// alter = p1 + semitones - pitch;
|
|
|
|
// if (alter < 0) {
|
|
// alter *= -1;
|
|
// alter = 12 - alter;
|
|
// }
|
|
while (alter < 0)
|
|
alter += 12;
|
|
|
|
alter %= 12;
|
|
if (alter > 6)
|
|
alter -= 12;
|
|
if (alter > maxAlter)
|
|
++steps;
|
|
else if (alter < minAlter)
|
|
--steps;
|
|
else
|
|
break;
|
|
// qDebug(" again alter %d steps %d, step %d", alter, steps, step);
|
|
}
|
|
// qDebug(" = step %d alter %d tpc %d", step, alter, step2tpc(step, alter));
|
|
return step2tpc(step, AccidentalVal(alter));
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// transposeTpcDiatonicByKey
|
|
//
|
|
// returns the tpc diatonically transposed by steps, using degrees of given key
|
|
// option to keep any alteration tpc had with respect to unaltered corresponding degree of key
|
|
// option to enharmonically reduce tpc using double alterations
|
|
//---------------------------------------------------------
|
|
|
|
int transposeTpcDiatonicByKey(int tpc, int steps, Key key, bool keepAlteredDegrees, bool useDoubleSharpsFlats)
|
|
{
|
|
if (tpc == Tpc::TPC_INVALID)
|
|
return tpc;
|
|
|
|
// get step for tpc with alteration for key
|
|
int alter;
|
|
int step = tpc2stepByKey(tpc, key, &alter);
|
|
|
|
// transpose step and get tpc for step/key
|
|
step += steps;
|
|
int newTpc = step2tpcByKey(step, key);
|
|
|
|
// if required, apply alteration to new tpc
|
|
if(keepAlteredDegrees)
|
|
newTpc += alter * TPC_DELTA_SEMITONE;
|
|
|
|
// check results are in ranges
|
|
while (newTpc > Tpc::TPC_MAX) newTpc -= TPC_DELTA_ENHARMONIC;
|
|
while (newTpc < Tpc::TPC_MIN) newTpc += TPC_DELTA_ENHARMONIC;
|
|
|
|
// if required, reduce double alterations
|
|
if(!useDoubleSharpsFlats) {
|
|
if(newTpc >= Tpc::TPC_F_SS) newTpc -= TPC_DELTA_ENHARMONIC;
|
|
if(newTpc <= Tpc::TPC_B_BB) newTpc += TPC_DELTA_ENHARMONIC;
|
|
}
|
|
|
|
return newTpc;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// transpose
|
|
// return false on failure
|
|
//---------------------------------------------------------
|
|
|
|
bool Score::transpose(Note* n, Interval interval, bool useDoubleSharpsFlats)
|
|
{
|
|
int npitch;
|
|
int ntpc1, ntpc2;
|
|
transposeInterval(n->pitch(), n->tpc1(), &npitch, &ntpc1, interval, useDoubleSharpsFlats);
|
|
if (n->transposition()) {
|
|
int p;
|
|
transposeInterval(n->pitch() - n->transposition(), n->tpc2(), &p, &ntpc2, interval, useDoubleSharpsFlats);
|
|
}
|
|
else
|
|
ntpc2 = ntpc1;
|
|
if (npitch > 127)
|
|
return false;
|
|
undoChangePitch(n, npitch, ntpc1, ntpc2);
|
|
return true;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// transpose
|
|
// return false on failure
|
|
//---------------------------------------------------------
|
|
|
|
bool Score::transpose(TransposeMode mode, TransposeDirection direction, Key trKey,
|
|
int transposeInterval, bool trKeys, bool transposeChordNames, bool useDoubleSharpsFlats)
|
|
{
|
|
bool rangeSelection = selection().isRange();
|
|
int startStaffIdx = 0;
|
|
int startTick = 0;
|
|
if (rangeSelection) {
|
|
startStaffIdx = selection().staffStart();
|
|
startTick = selection().tickStart();
|
|
}
|
|
|
|
Staff* st = staff(startStaffIdx);
|
|
|
|
Interval interval;
|
|
if (mode != TransposeMode::DIATONICALLY) {
|
|
if (mode == TransposeMode::BY_KEY) {
|
|
// calculate interval from "transpose by key"
|
|
Key oKey = st->key(startTick);
|
|
if (!styleB(StyleIdx::concertPitch)) {
|
|
int diff = st->part()->instrument(startTick)->transpose().chromatic;
|
|
if (diff)
|
|
oKey = transposeKey(oKey, diff);
|
|
}
|
|
interval = keydiff2Interval(oKey, trKey, direction);
|
|
}
|
|
else {
|
|
interval = intervalList[transposeInterval];
|
|
if (direction == TransposeDirection::DOWN)
|
|
interval.flip();
|
|
}
|
|
|
|
if (!rangeSelection) {
|
|
trKeys = false;
|
|
}
|
|
bool fullOctave = (interval.chromatic % 12) == 0;
|
|
if (fullOctave && (mode != TransposeMode::BY_KEY)) {
|
|
trKeys = false;
|
|
transposeChordNames = false;
|
|
}
|
|
}
|
|
else { // diatonic transposition
|
|
if (direction == TransposeDirection::DOWN)
|
|
transposeInterval *= -1;
|
|
}
|
|
|
|
if (_selection.isList()) {
|
|
foreach (Element* e, _selection.uniqueElements()) {
|
|
if (e->staff()->staffType()->group() == StaffGroup::PERCUSSION)
|
|
continue;
|
|
if (e->type() == Element::Type::NOTE) {
|
|
Note* note = static_cast<Note*>(e);
|
|
if (mode == TransposeMode::DIATONICALLY)
|
|
note->transposeDiatonic(transposeInterval, trKeys, useDoubleSharpsFlats);
|
|
else {
|
|
if (!transpose(note, interval, useDoubleSharpsFlats))
|
|
return false;
|
|
}
|
|
}
|
|
else if ((e->type() == Element::Type::HARMONY) && transposeChordNames) {
|
|
Harmony* h = static_cast<Harmony*>(e);
|
|
int rootTpc, baseTpc;
|
|
if (mode == TransposeMode::DIATONICALLY) {
|
|
int tick = 0;
|
|
if (h->parent()->type() == Element::Type::SEGMENT)
|
|
tick = static_cast<Segment*>(h->parent())->tick();
|
|
else if (h->parent()->type() == Element::Type::FRET_DIAGRAM
|
|
&& h->parent()->parent()->type() == Element::Type::SEGMENT) {
|
|
tick = static_cast<Segment*>(h->parent()->parent())->tick();
|
|
}
|
|
Key key = !h->staff() ? Key::C : h->staff()->key(tick);
|
|
rootTpc = transposeTpcDiatonicByKey(h->rootTpc(),
|
|
transposeInterval, key, trKeys, useDoubleSharpsFlats);
|
|
baseTpc = transposeTpcDiatonicByKey(h->baseTpc(),
|
|
transposeInterval, key, trKeys, useDoubleSharpsFlats);
|
|
}
|
|
else {
|
|
rootTpc = transposeTpc(h->rootTpc(), interval, useDoubleSharpsFlats);
|
|
baseTpc = transposeTpc(h->baseTpc(), interval, useDoubleSharpsFlats);
|
|
}
|
|
undoTransposeHarmony(h, rootTpc, baseTpc);
|
|
}
|
|
else if ((e->type() == Element::Type::KEYSIG) && mode != TransposeMode::DIATONICALLY && trKeys) {
|
|
KeySig* ks = static_cast<KeySig*>(e);
|
|
if (!ks->isCustom()) {
|
|
Key key = st->key(ks->tick());
|
|
KeySigEvent ke = ks->keySigEvent();
|
|
ke.setKey(key);
|
|
undo(new ChangeKeySig(ks, ke, ks->showCourtesy()));
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//--------------------------
|
|
// process range selection
|
|
//--------------------------
|
|
|
|
QList<Staff*> sl;
|
|
for (int staffIdx = _selection.staffStart(); staffIdx < _selection.staffEnd(); ++staffIdx) {
|
|
Staff* s = staff(staffIdx);
|
|
if (s->staffType()->group() == StaffGroup::PERCUSSION) // ignore percussion staff
|
|
continue;
|
|
if (sl.contains(s))
|
|
continue;
|
|
bool alreadyThere = false;
|
|
for (Staff* s2 : sl) {
|
|
if (s2 == s || (s2->linkedStaves() && s2->linkedStaves()->staves().contains(s))) {
|
|
alreadyThere = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!alreadyThere)
|
|
sl.append(s);
|
|
}
|
|
QList<int> tracks;
|
|
for (Staff* s : sl) {
|
|
int idx = s->idx() * VOICES;
|
|
for (int i = 0; i < VOICES; ++i)
|
|
tracks.append(idx + i);
|
|
}
|
|
|
|
Segment* s1 = _selection.startSegment();
|
|
// if range start on mmRest, get the actual segment instead
|
|
if (s1->measure()->isMMRest())
|
|
s1 = tick2segment(s1->tick(), true, s1->segmentType(), false);
|
|
// if range starts with first CR of measure
|
|
// then start looping from very beginning of measure
|
|
// so we include key signature and can transpose that if requested
|
|
if (!s1->rtick())
|
|
s1 = s1->measure()->first();
|
|
Segment* s2 = _selection.endSegment();
|
|
for (Segment* segment = s1; segment && segment != s2; segment = segment->next1()) {
|
|
for (int st : tracks) {
|
|
if (staff(st/VOICES)->staffType()->group() == StaffGroup::PERCUSSION)
|
|
continue;
|
|
Element* e = segment->element(st);
|
|
if (!e)
|
|
continue;
|
|
|
|
if (e->type() == Element::Type::CHORD) {
|
|
Chord* chord = static_cast<Chord*>(e);
|
|
QList<Note*> nl = chord->notes();
|
|
for (Note* n : nl) {
|
|
if (mode == TransposeMode::DIATONICALLY)
|
|
n->transposeDiatonic(transposeInterval, trKeys, useDoubleSharpsFlats);
|
|
else {
|
|
if (!transpose(n, interval, useDoubleSharpsFlats))
|
|
return false;
|
|
}
|
|
}
|
|
for (Chord* g : chord->graceNotes()) {
|
|
for (Note* n : g->notes()) {
|
|
if (mode == TransposeMode::DIATONICALLY)
|
|
n->transposeDiatonic(transposeInterval, trKeys, useDoubleSharpsFlats);
|
|
else {
|
|
if (!transpose(n, interval, useDoubleSharpsFlats))
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (e->type() == Element::Type::KEYSIG && trKeys && mode != TransposeMode::DIATONICALLY) {
|
|
QList<ScoreElement*> ll = e->linkList();
|
|
for (ScoreElement* e : ll) {
|
|
KeySig* ks = static_cast<KeySig*>(e);
|
|
if (!ks->isCustom()) {
|
|
Key nKey = transposeKey(ks->key(), interval);
|
|
KeySigEvent ke = ks->keySigEvent();
|
|
ke.setKey(nKey);
|
|
undo(new ChangeKeySig(ks, ke, ks->showCourtesy()));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (transposeChordNames) {
|
|
foreach (Element* e, segment->annotations()) {
|
|
if ((e->type() != Element::Type::HARMONY) || (!tracks.contains(e->track())))
|
|
continue;
|
|
Harmony* h = static_cast<Harmony*>(e);
|
|
int rootTpc, baseTpc;
|
|
if (mode == TransposeMode::DIATONICALLY) {
|
|
int tick = segment->tick();
|
|
Key key = !h->staff() ? Key::C : h->staff()->key(tick);
|
|
rootTpc = transposeTpcDiatonicByKey(h->rootTpc(),
|
|
transposeInterval, key, trKeys, useDoubleSharpsFlats);
|
|
baseTpc = transposeTpcDiatonicByKey(h->baseTpc(),
|
|
transposeInterval, key, trKeys, useDoubleSharpsFlats);
|
|
}
|
|
else {
|
|
rootTpc = transposeTpc(h->rootTpc(), interval, useDoubleSharpsFlats);
|
|
baseTpc = transposeTpc(h->baseTpc(), interval, useDoubleSharpsFlats);
|
|
}
|
|
// undoTransposeHarmony does not do links
|
|
// because it is also used to handle transposing instruments
|
|
// and score / parts could be in different concert pitch states
|
|
for (ScoreElement* e : h->linkList())
|
|
undoTransposeHarmony(static_cast<Harmony*>(e), rootTpc, baseTpc);
|
|
}
|
|
}
|
|
}
|
|
//
|
|
// create missing key signatures
|
|
//
|
|
if (trKeys && (mode != TransposeMode::DIATONICALLY) && (s1->tick() == 0)) {
|
|
// Segment* seg = firstMeasure()->findSegment(Segment::Type::KeySig, 0);
|
|
Key nKey = transposeKey(Key::C, interval);
|
|
// if (seg == 0) {
|
|
for (int st : tracks) {
|
|
if (st % VOICES)
|
|
continue;
|
|
Segment* seg = firstMeasure()->undoGetSegment(Segment::Type::KeySig, 0);
|
|
KeySig* ks = static_cast<KeySig*>(seg->element(st));
|
|
if (!ks) {
|
|
ks = new KeySig(this);
|
|
ks->setTrack(st);
|
|
ks->setKey(nKey);
|
|
ks->setParent(seg);
|
|
undoAddElement(ks);
|
|
}
|
|
}
|
|
}
|
|
// }
|
|
return true;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// transposeKeys
|
|
// key - -7(Cb) - +7(C#)
|
|
//---------------------------------------------------------
|
|
|
|
void Score::transposeKeys(int staffStart, int staffEnd, int tickStart, int tickEnd, const Interval& interval)
|
|
{
|
|
for (int staffIdx = staffStart; staffIdx < staffEnd; ++staffIdx) {
|
|
Staff* st = staff(staffIdx);
|
|
if (st->staffType()->group() == StaffGroup::PERCUSSION)
|
|
continue;
|
|
|
|
bool createKey = tickStart == 0;
|
|
for (Segment* s = firstSegment(Segment::Type::KeySig); s; s = s->next1(Segment::Type::KeySig)) {
|
|
if (s->tick() < tickStart)
|
|
continue;
|
|
if (s->tick() >= tickEnd)
|
|
break;
|
|
KeySig* ks = static_cast<KeySig*>(s->element(staffIdx * VOICES));
|
|
if (!ks)
|
|
continue;
|
|
if (ks->generated())
|
|
continue;
|
|
if (s->tick() == 0)
|
|
createKey = false;
|
|
if (!ks->isCustom()) {
|
|
Key key = st->key(s->tick());
|
|
Key nKey = transposeKey(key, interval);
|
|
// remove initial C major key signatures
|
|
if (nKey == Key::C && s->tick() == 0) {
|
|
undo(new RemoveElement(ks));
|
|
if (s->isEmpty())
|
|
undo(new RemoveElement(s));
|
|
}
|
|
else {
|
|
KeySigEvent ke;
|
|
ke.setKey(nKey);
|
|
undo(new ChangeKeySig(ks, ke, ks->showCourtesy()));
|
|
}
|
|
}
|
|
}
|
|
if (createKey && firstMeasure()) {
|
|
Key key = Key::C;
|
|
Key nKey = transposeKey(key, interval);
|
|
KeySigEvent ke;
|
|
ke.setKey(nKey);
|
|
KeySig* ks = new KeySig(this);
|
|
ks->setTrack(staffIdx * VOICES);
|
|
ks->setKey(nKey);
|
|
Segment* seg = firstMeasure()->undoGetSegment(Segment::Type::KeySig, 0);
|
|
ks->setParent(seg);
|
|
undoAddElement(ks);
|
|
}
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// transposeSemitone
|
|
//---------------------------------------------------------
|
|
|
|
void Score::transposeSemitone(int step)
|
|
{
|
|
if (step == 0)
|
|
return;
|
|
if (step > 1)
|
|
step = 1;
|
|
if (step < -1)
|
|
step = -1;
|
|
|
|
TransposeDirection dir = step > 0 ? TransposeDirection::UP : TransposeDirection::DOWN;
|
|
|
|
int keyType = int(staff(0)->key(0)) + 7; // ??
|
|
|
|
int intervalList[15][2] = {
|
|
// up - down
|
|
{ 1, 1 }, // Cb
|
|
{ 1, 1 }, // Gb
|
|
{ 1, 1 }, // Db
|
|
{ 1, 1 }, // Ab
|
|
{ 1, 1 }, // Eb
|
|
{ 1, 1 }, // Bb
|
|
{ 1, 1 }, // F
|
|
{ 1, 1 }, // C
|
|
{ 1, 1 }, // G
|
|
{ 1, 1 }, // D
|
|
{ 1, 1 }, // A
|
|
{ 1, 1 }, // E
|
|
{ 1, 1 }, // B
|
|
{ 1, 1 }, // F#
|
|
{ 1, 1 } // C#
|
|
};
|
|
|
|
int interval = intervalList[keyType][step > 0 ? 0 : 1];
|
|
|
|
cmdSelectAll();
|
|
startCmd();
|
|
if (!transpose(TransposeMode::BY_INTERVAL, dir, Key::C, interval, true, true, false)) {
|
|
endCmd(true);
|
|
qDebug("Score::transposeSemitone: failed");
|
|
// TODO: popup message?
|
|
}
|
|
else {
|
|
deselectAll();
|
|
setLayoutAll(true);
|
|
endCmd(false);
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// Note::transposeDiatonic
|
|
//---------------------------------------------------------
|
|
|
|
void Note::transposeDiatonic(int interval, bool keepAlterations, bool useDoubleAccidentals)
|
|
{
|
|
// compute note current absolute step
|
|
int alter1;
|
|
int alter2;
|
|
int tick = chord()->segment()->tick();
|
|
Key key = !staff() ? Key::C : staff()->key(tick);
|
|
int absStep1 = pitch2absStepByKey(pitch(), tpc1(), key, &alter1);
|
|
int absStep2 = pitch2absStepByKey(pitch()-transposition(), tpc2(), key, &alter2);
|
|
|
|
// get pitch and tcp corresponding to unaltered degree for this key
|
|
int newPitch = absStep2pitchByKey(absStep1 + interval, key);
|
|
int newTpc1 = step2tpcByKey((absStep1 + interval) % STEP_DELTA_OCTAVE, key);
|
|
int newTpc2 = step2tpcByKey((absStep2 + interval) % STEP_DELTA_OCTAVE, key);
|
|
|
|
// if required, transfer original degree alteration to new pitch and tpc
|
|
if (keepAlterations) {
|
|
newPitch += alter1;
|
|
newTpc1 += alter1 * TPC_DELTA_SEMITONE;
|
|
newTpc2 += alter2 * TPC_DELTA_SEMITONE;
|
|
}
|
|
|
|
// check results are in ranges
|
|
while (newPitch > 127)
|
|
newPitch -= PITCH_DELTA_OCTAVE;
|
|
while (newPitch < 0)
|
|
newPitch += PITCH_DELTA_OCTAVE;
|
|
while (newTpc1 > Tpc::TPC_MAX)
|
|
newTpc1 -= TPC_DELTA_ENHARMONIC;
|
|
while (newTpc1 < Tpc::TPC_MIN)
|
|
newTpc1 += TPC_DELTA_ENHARMONIC;
|
|
while (newTpc2 > Tpc::TPC_MAX)
|
|
newTpc2 -= TPC_DELTA_ENHARMONIC;
|
|
while (newTpc2 < Tpc::TPC_MIN)
|
|
newTpc2 += TPC_DELTA_ENHARMONIC;
|
|
|
|
// if required, reduce double alterations
|
|
if (!useDoubleAccidentals) {
|
|
if (newTpc1 >= Tpc::TPC_F_SS)
|
|
newTpc1 -= TPC_DELTA_ENHARMONIC;
|
|
if (newTpc1 <= Tpc::TPC_B_BB)
|
|
newTpc1 += TPC_DELTA_ENHARMONIC;
|
|
if (newTpc2 >= Tpc::TPC_F_SS)
|
|
newTpc2 -= TPC_DELTA_ENHARMONIC;
|
|
if (newTpc2 <= Tpc::TPC_B_BB)
|
|
newTpc2 += TPC_DELTA_ENHARMONIC;
|
|
}
|
|
|
|
// store new data
|
|
score()->undoChangePitch(this, newPitch, newTpc1, newTpc2);
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// transpositionChanged
|
|
//---------------------------------------------------------
|
|
|
|
void Score::transpositionChanged(Part* part, Interval oldV)
|
|
{
|
|
Interval v = part->instrument()->transpose();
|
|
v.flip();
|
|
|
|
// transpose keys first
|
|
if (!styleB(StyleIdx::concertPitch)) {
|
|
Interval diffV(oldV.chromatic + v.chromatic);
|
|
int tickEnd = lastSegment() ? lastSegment()->tick() : 0;
|
|
transposeKeys(part->startTrack() / VOICES, part->endTrack() / VOICES, 0, tickEnd, diffV);
|
|
}
|
|
|
|
// now transpose notes
|
|
for (Segment* s = firstSegment(Segment::Type::ChordRest); s; s = s->next1(Segment::Type::ChordRest)) {
|
|
for (Staff* st : *part->staves()) {
|
|
if (st->staffType()->group() == StaffGroup::PERCUSSION)
|
|
continue;
|
|
int t1 = st->idx() * VOICES;
|
|
int t2 = t1 + VOICES;
|
|
for (int track = t1; track < t2; ++track) {
|
|
Chord* c = static_cast<Chord*>(s->element(track));
|
|
if (c && c->type() == Element::Type::CHORD) {
|
|
for (Chord* gc : c->graceNotes()) {
|
|
for (Note* n : gc->notes()) {
|
|
int tpc = transposeTpc(n->tpc1(), v, true);
|
|
n->undoSetTpc2(tpc);
|
|
}
|
|
}
|
|
for (Note* n : c->notes()) {
|
|
int tpc = transposeTpc(n->tpc1(), v, true);
|
|
n->undoSetTpc2(tpc);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|