766 lines
23 KiB
C++
766 lines
23 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 "sym.h"
|
|
#include "staff.h"
|
|
#include "clef.h"
|
|
#include "keysig.h"
|
|
#include "measure.h"
|
|
#include "segment.h"
|
|
#include "score.h"
|
|
#include "system.h"
|
|
#include "undo.h"
|
|
#include "xml.h"
|
|
|
|
namespace Ms {
|
|
const char* keyNames[] = {
|
|
QT_TRANSLATE_NOOP("MuseScore", "G major, E minor"),
|
|
QT_TRANSLATE_NOOP("MuseScore", "C♭ major, A♭ minor"),
|
|
QT_TRANSLATE_NOOP("MuseScore", "D major, B minor"),
|
|
QT_TRANSLATE_NOOP("MuseScore", "G♭ major, E♭ minor"),
|
|
QT_TRANSLATE_NOOP("MuseScore", "A major, F♯ minor"),
|
|
QT_TRANSLATE_NOOP("MuseScore", "D♭ major, B♭ minor"),
|
|
QT_TRANSLATE_NOOP("MuseScore", "E major, C♯ minor"),
|
|
QT_TRANSLATE_NOOP("MuseScore", "A♭ major, F minor"),
|
|
QT_TRANSLATE_NOOP("MuseScore", "B major, G♯ minor"),
|
|
QT_TRANSLATE_NOOP("MuseScore", "E♭ major, C minor"),
|
|
QT_TRANSLATE_NOOP("MuseScore", "F♯ major, D♯ minor"),
|
|
QT_TRANSLATE_NOOP("MuseScore", "B♭ major, G minor"),
|
|
QT_TRANSLATE_NOOP("MuseScore", "C♯ major, A♯ minor"),
|
|
QT_TRANSLATE_NOOP("MuseScore", "F major, D minor"),
|
|
QT_TRANSLATE_NOOP("MuseScore", "C major, A minor"),
|
|
QT_TRANSLATE_NOOP("MuseScore", "Open/Atonal")
|
|
};
|
|
|
|
//---------------------------------------------------------
|
|
// KeySig
|
|
//---------------------------------------------------------
|
|
|
|
KeySig::KeySig(Score* s)
|
|
: Element(s, ElementFlag::ON_STAFF)
|
|
{
|
|
_showCourtesy = true;
|
|
_hideNaturals = false;
|
|
}
|
|
|
|
KeySig::KeySig(const KeySig& k)
|
|
: Element(k)
|
|
{
|
|
_showCourtesy = k._showCourtesy;
|
|
_sig = k._sig;
|
|
_hideNaturals = false;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// mag
|
|
//---------------------------------------------------------
|
|
|
|
qreal KeySig::mag() const
|
|
{
|
|
return staff() ? staff()->staffMag(tick()) : 1.0;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// add
|
|
//---------------------------------------------------------
|
|
|
|
void KeySig::addLayout(SymId sym, qreal x, int line)
|
|
{
|
|
qreal stepDistance = staff() ? staff()->lineDistance(tick()) * 0.5 : 0.5;
|
|
KeySym ks;
|
|
ks.sym = sym;
|
|
ks.spos = QPointF(x, qreal(line) * stepDistance);
|
|
_sig.keySymbols().append(ks);
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// layout
|
|
//---------------------------------------------------------
|
|
|
|
void KeySig::layout()
|
|
{
|
|
qreal _spatium = spatium();
|
|
setbbox(QRectF());
|
|
|
|
if (isCustom() && !isAtonal()) {
|
|
for (KeySym& ks: _sig.keySymbols()) {
|
|
ks.pos = ks.spos * _spatium;
|
|
addbbox(symBbox(ks.sym).translated(ks.pos));
|
|
}
|
|
return;
|
|
}
|
|
|
|
_sig.keySymbols().clear();
|
|
if (staff() && !staff()->staffType(tick())->genKeysig()) {
|
|
return;
|
|
}
|
|
|
|
// determine current clef for this staff
|
|
ClefType clef = ClefType::G;
|
|
if (staff()) {
|
|
// Look for a clef before the key signature at the same tick
|
|
Clef* c = nullptr;
|
|
if (segment()) {
|
|
for (Segment* seg = segment()->prev1(); !c && seg && seg->tick() == tick(); seg = seg->prev1()) {
|
|
if (seg->isClefType() || seg->isHeaderClefType()) {
|
|
c = toClef(seg->element(track()));
|
|
}
|
|
}
|
|
}
|
|
if (c) {
|
|
clef = c->clefType();
|
|
} else {
|
|
// no clef found, so get the clef type from the clefs list, using the previous tick
|
|
clef = staff()->clef(tick() - Fraction::fromTicks(1));
|
|
}
|
|
}
|
|
|
|
int accidentals = 0, naturals = 0;
|
|
int t1 = int(_sig.key());
|
|
switch (qAbs(t1)) {
|
|
case 7: accidentals = 0x7f;
|
|
break;
|
|
case 6: accidentals = 0x3f;
|
|
break;
|
|
case 5: accidentals = 0x1f;
|
|
break;
|
|
case 4: accidentals = 0xf;
|
|
break;
|
|
case 3: accidentals = 0x7;
|
|
break;
|
|
case 2: accidentals = 0x3;
|
|
break;
|
|
case 1: accidentals = 0x1;
|
|
break;
|
|
case 0: accidentals = 0;
|
|
break;
|
|
default:
|
|
qDebug("illegal t1 key %d", t1);
|
|
break;
|
|
}
|
|
|
|
// manage display of naturals:
|
|
// naturals are shown if there is some natural AND prev. measure has no section break
|
|
// AND style says they are not off
|
|
// OR key sig is CMaj/Amin (in which case they are always shown)
|
|
|
|
bool naturalsOn = false;
|
|
Measure* prevMeasure = measure() ? measure()->prevMeasure() : 0;
|
|
|
|
// If we're not force hiding naturals (Continuous panel), use score style settings
|
|
if (!_hideNaturals) {
|
|
const bool newSection = (!segment()
|
|
|| (segment()->rtick().isZero() && (!prevMeasure || prevMeasure->sectionBreak()))
|
|
);
|
|
naturalsOn = !newSection && (score()->styleI(Sid::keySigNaturals) != int(KeySigNatural::NONE) || (t1 == 0));
|
|
}
|
|
|
|
// Don't repeat naturals if shown in courtesy
|
|
if (measure() && measure()->system() && measure()->isFirstInSystem()
|
|
&& prevMeasure && prevMeasure->findSegment(SegmentType::KeySigAnnounce, tick())
|
|
&& !segment()->isKeySigAnnounceType()) {
|
|
naturalsOn = false;
|
|
}
|
|
if (track() == -1) {
|
|
naturalsOn = false;
|
|
}
|
|
|
|
int coffset = 0;
|
|
Key t2 = Key::C;
|
|
if (naturalsOn) {
|
|
if (staff()) {
|
|
t2 = staff()->key(tick() - Fraction(1, 480 * 4));
|
|
}
|
|
if (t2 == Key::C) {
|
|
naturalsOn = false;
|
|
} else {
|
|
switch (qAbs(int(t2))) {
|
|
case 7: naturals = 0x7f;
|
|
break;
|
|
case 6: naturals = 0x3f;
|
|
break;
|
|
case 5: naturals = 0x1f;
|
|
break;
|
|
case 4: naturals = 0xf;
|
|
break;
|
|
case 3: naturals = 0x7;
|
|
break;
|
|
case 2: naturals = 0x3;
|
|
break;
|
|
case 1: naturals = 0x1;
|
|
break;
|
|
case 0: naturals = 0;
|
|
break;
|
|
default:
|
|
qDebug("illegal t2 key %d", int(t2));
|
|
break;
|
|
}
|
|
// remove redundant naturals
|
|
if (!((t1 > 0) ^ (t2 > 0))) {
|
|
naturals &= ~accidentals;
|
|
}
|
|
if (t2 < 0) {
|
|
coffset = 7;
|
|
}
|
|
}
|
|
}
|
|
|
|
// naturals should go BEFORE accidentals if style says so
|
|
// OR going from sharps to flats or vice versa (i.e. t1 & t2 have opposite signs)
|
|
|
|
bool prefixNaturals
|
|
=naturalsOn
|
|
&& (score()->styleI(Sid::keySigNaturals) == int(KeySigNatural::BEFORE) || t1 * int(t2) < 0);
|
|
|
|
// naturals should go AFTER accidentals if they should not go before!
|
|
bool suffixNaturals = naturalsOn && !prefixNaturals;
|
|
|
|
const signed char* lines = ClefInfo::lines(clef);
|
|
|
|
// add prefixed naturals, if any
|
|
|
|
qreal xo = 0.0;
|
|
if (prefixNaturals) {
|
|
for (int i = 0; i < 7; ++i) {
|
|
if (naturals & (1 << i)) {
|
|
addLayout(SymId::accidentalNatural, xo, lines[i + coffset]);
|
|
xo += 1.0;
|
|
}
|
|
}
|
|
}
|
|
// add accidentals
|
|
static const qreal sspread = 1.0;
|
|
static const qreal fspread = 1.0;
|
|
|
|
switch (t1) {
|
|
case 7: addLayout(SymId::accidentalSharp, xo + 6.0 * sspread, lines[6]);
|
|
// fall through
|
|
case 6: addLayout(SymId::accidentalSharp, xo + 5.0 * sspread, lines[5]);
|
|
// fall through
|
|
case 5: addLayout(SymId::accidentalSharp, xo + 4.0 * sspread, lines[4]);
|
|
// fall through
|
|
case 4: addLayout(SymId::accidentalSharp, xo + 3.0 * sspread, lines[3]);
|
|
// fall through
|
|
case 3: addLayout(SymId::accidentalSharp, xo + 2.0 * sspread, lines[2]);
|
|
// fall through
|
|
case 2: addLayout(SymId::accidentalSharp, xo + 1.0 * sspread, lines[1]);
|
|
// fall through
|
|
case 1: addLayout(SymId::accidentalSharp, xo, lines[0]);
|
|
break;
|
|
case -7: addLayout(SymId::accidentalFlat, xo + 6.0 * fspread, lines[13]);
|
|
// fall through
|
|
case -6: addLayout(SymId::accidentalFlat, xo + 5.0 * fspread, lines[12]);
|
|
// fall through
|
|
case -5: addLayout(SymId::accidentalFlat, xo + 4.0 * fspread, lines[11]);
|
|
// fall through
|
|
case -4: addLayout(SymId::accidentalFlat, xo + 3.0 * fspread, lines[10]);
|
|
// fall through
|
|
case -3: addLayout(SymId::accidentalFlat, xo + 2.0 * fspread, lines[9]);
|
|
// fall through
|
|
case -2: addLayout(SymId::accidentalFlat, xo + 1.0 * fspread, lines[8]);
|
|
// fall through
|
|
case -1: addLayout(SymId::accidentalFlat, xo, lines[7]);
|
|
case 0:
|
|
break;
|
|
default:
|
|
qDebug("illegal t1 key %d", t1);
|
|
break;
|
|
}
|
|
// add suffixed naturals, if any
|
|
if (suffixNaturals) {
|
|
xo += qAbs(t1); // skip accidentals
|
|
if (t1 > 0) { // after sharps, add a little more space
|
|
xo += 0.15;
|
|
// if last sharp (t1) is above next natural (t1+1)...
|
|
if (lines[t1] < lines[t1 + 1]) {
|
|
xo += 0.2; // ... add more space
|
|
}
|
|
}
|
|
for (int i = 0; i < 7; ++i) {
|
|
if (naturals & (1 << i)) {
|
|
addLayout(SymId::accidentalNatural, xo, lines[i + coffset]);
|
|
xo += 1.0;
|
|
}
|
|
}
|
|
}
|
|
|
|
// compute bbox
|
|
for (KeySym& ks : _sig.keySymbols()) {
|
|
ks.pos = ks.spos * _spatium;
|
|
addbbox(symBbox(ks.sym).translated(ks.pos));
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// shape
|
|
//---------------------------------------------------------
|
|
|
|
Shape KeySig::shape() const
|
|
{
|
|
QRectF box(bbox());
|
|
const Staff* st = staff();
|
|
if (st && addToSkyline()) {
|
|
// Extend key signature shape up and down to
|
|
// the first ledger line height to ensure that
|
|
// no notes will be too close to the keysig.
|
|
const qreal sp = spatium();
|
|
const qreal y = pos().y();
|
|
box.setTop(std::min(-sp - y, box.top()));
|
|
box.setBottom(std::max(st->height() - y + sp, box.bottom()));
|
|
}
|
|
return Shape(box);
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// set
|
|
//---------------------------------------------------------
|
|
|
|
void KeySig::draw(QPainter* p) const
|
|
{
|
|
p->setPen(curColor());
|
|
for (const KeySym& ks: _sig.keySymbols()) {
|
|
drawSymbol(ks.sym, p, QPointF(ks.pos.x(), ks.pos.y()));
|
|
}
|
|
if (!parent() && (isAtonal() || isCustom()) && _sig.keySymbols().empty()) {
|
|
// empty custom or atonal key signature - draw something for palette
|
|
p->setPen(Qt::gray);
|
|
drawSymbol(SymId::timeSigX, p, QPointF(symWidth(SymId::timeSigX) * -0.5, 2.0 * spatium()));
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// acceptDrop
|
|
//---------------------------------------------------------
|
|
|
|
bool KeySig::acceptDrop(EditData& data) const
|
|
{
|
|
return data.dropElement->type() == ElementType::KEYSIG;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// drop
|
|
//---------------------------------------------------------
|
|
|
|
Element* KeySig::drop(EditData& data)
|
|
{
|
|
KeySig* ks = toKeySig(data.dropElement);
|
|
if (ks->type() != ElementType::KEYSIG) {
|
|
delete ks;
|
|
return 0;
|
|
}
|
|
KeySigEvent k = ks->keySigEvent();
|
|
delete ks;
|
|
if (data.modifiers & Qt::ControlModifier) {
|
|
// apply only to this stave
|
|
if (!(k == keySigEvent())) {
|
|
score()->undoChangeKeySig(staff(), tick(), k);
|
|
}
|
|
} else {
|
|
// apply to all staves:
|
|
foreach (Staff* s, score()->masterScore()->staves()) {
|
|
score()->undoChangeKeySig(s, tick(), k);
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// setKey
|
|
//---------------------------------------------------------
|
|
|
|
void KeySig::setKey(Key key)
|
|
{
|
|
KeySigEvent e;
|
|
e.setKey(key);
|
|
setKeySigEvent(e);
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// write
|
|
//---------------------------------------------------------
|
|
|
|
void KeySig::write(XmlWriter& xml) const
|
|
{
|
|
xml.stag(this);
|
|
Element::writeProperties(xml);
|
|
if (_sig.isAtonal()) {
|
|
xml.tag("custom", 1);
|
|
} else if (_sig.custom()) {
|
|
xml.tag("custom", 1);
|
|
for (const KeySym& ks : _sig.keySymbols()) {
|
|
xml.stag("KeySym");
|
|
xml.tag("sym", Sym::id2name(ks.sym));
|
|
xml.tag("pos", ks.spos);
|
|
xml.etag();
|
|
}
|
|
} else {
|
|
xml.tag("accidental", int(_sig.key()));
|
|
}
|
|
switch (_sig.mode()) {
|
|
case KeyMode::NONE: xml.tag("mode", "none");
|
|
break;
|
|
case KeyMode::MAJOR: xml.tag("mode", "major");
|
|
break;
|
|
case KeyMode::MINOR: xml.tag("mode", "minor");
|
|
break;
|
|
case KeyMode::DORIAN: xml.tag("mode", "dorian");
|
|
break;
|
|
case KeyMode::PHRYGIAN: xml.tag("mode", "phrygian");
|
|
break;
|
|
case KeyMode::LYDIAN: xml.tag("mode", "lydian");
|
|
break;
|
|
case KeyMode::MIXOLYDIAN: xml.tag("mode", "mixolydian");
|
|
break;
|
|
case KeyMode::AEOLIAN: xml.tag("mode", "aeolian");
|
|
break;
|
|
case KeyMode::IONIAN: xml.tag("mode", "ionian");
|
|
break;
|
|
case KeyMode::LOCRIAN: xml.tag("mode", "locrian");
|
|
break;
|
|
case KeyMode::UNKNOWN:
|
|
default:
|
|
;
|
|
}
|
|
if (!_showCourtesy) {
|
|
xml.tag("showCourtesySig", _showCourtesy);
|
|
}
|
|
if (forInstrumentChange()) {
|
|
xml.tag("forInstrumentChange", true);
|
|
}
|
|
xml.etag();
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// read
|
|
//---------------------------------------------------------
|
|
|
|
void KeySig::read(XmlReader& e)
|
|
{
|
|
_sig = KeySigEvent(); // invalidate _sig
|
|
int subtype = 0;
|
|
|
|
while (e.readNextStartElement()) {
|
|
const QStringRef& tag(e.name());
|
|
if (tag == "KeySym") {
|
|
KeySym ks;
|
|
while (e.readNextStartElement()) {
|
|
const QStringRef& t(e.name());
|
|
if (t == "sym") {
|
|
QString val(e.readElementText());
|
|
bool valid;
|
|
SymId id = SymId(val.toInt(&valid));
|
|
if (!valid) {
|
|
id = Sym::name2id(val);
|
|
}
|
|
if (score()->mscVersion() <= 114) {
|
|
if (valid) {
|
|
id = KeySig::convertFromOldId(val.toInt(&valid));
|
|
} else {
|
|
id = Sym::oldName2id(val);
|
|
}
|
|
}
|
|
ks.sym = id;
|
|
} else if (t == "pos") {
|
|
ks.spos = e.readPoint();
|
|
} else {
|
|
e.unknown();
|
|
}
|
|
}
|
|
_sig.keySymbols().append(ks);
|
|
} else if (tag == "showCourtesySig") {
|
|
_showCourtesy = e.readInt();
|
|
} else if (tag == "showNaturals") { // obsolete
|
|
e.readInt();
|
|
} else if (tag == "accidental") {
|
|
_sig.setKey(Key(e.readInt()));
|
|
} else if (tag == "natural") { // obsolete
|
|
e.readInt();
|
|
} else if (tag == "custom") {
|
|
e.readInt();
|
|
_sig.setCustom(true);
|
|
} else if (tag == "mode") {
|
|
QString m(e.readElementText());
|
|
if (m == "none") {
|
|
_sig.setMode(KeyMode::NONE);
|
|
} else if (m == "major") {
|
|
_sig.setMode(KeyMode::MAJOR);
|
|
} else if (m == "minor") {
|
|
_sig.setMode(KeyMode::MINOR);
|
|
} else if (m == "dorian") {
|
|
_sig.setMode(KeyMode::DORIAN);
|
|
} else if (m == "phrygian") {
|
|
_sig.setMode(KeyMode::PHRYGIAN);
|
|
} else if (m == "lydian") {
|
|
_sig.setMode(KeyMode::LYDIAN);
|
|
} else if (m == "mixolydian") {
|
|
_sig.setMode(KeyMode::MIXOLYDIAN);
|
|
} else if (m == "aeolian") {
|
|
_sig.setMode(KeyMode::AEOLIAN);
|
|
} else if (m == "ionian") {
|
|
_sig.setMode(KeyMode::IONIAN);
|
|
} else if (m == "locrian") {
|
|
_sig.setMode(KeyMode::LOCRIAN);
|
|
} else {
|
|
_sig.setMode(KeyMode::UNKNOWN);
|
|
}
|
|
} else if (tag == "subtype") {
|
|
subtype = e.readInt();
|
|
} else if (tag == "forInstrumentChange") {
|
|
setForInstrumentChange(e.readBool());
|
|
} else if (!Element::readProperties(e)) {
|
|
e.unknown();
|
|
}
|
|
}
|
|
// for backward compatibility
|
|
if (!_sig.isValid()) {
|
|
_sig.initFromSubtype(subtype);
|
|
}
|
|
if (_sig.custom() && _sig.keySymbols().empty()) {
|
|
_sig.setMode(KeyMode::NONE);
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// convertFromOldId
|
|
//
|
|
// for import of 1.3 scores
|
|
//---------------------------------------------------------
|
|
|
|
SymId KeySig::convertFromOldId(int val) const
|
|
{
|
|
SymId symId = SymId::noSym;
|
|
switch (val) {
|
|
case 32: symId = SymId::accidentalSharp;
|
|
break;
|
|
case 33: symId = SymId::accidentalThreeQuarterTonesSharpArrowUp;
|
|
break;
|
|
case 34: symId = SymId::accidentalQuarterToneSharpArrowDown;
|
|
break;
|
|
// case 35: // "sharp arrow both" missing in SMuFL
|
|
case 36: symId = SymId::accidentalQuarterToneSharpStein;
|
|
break;
|
|
case 37: symId = SymId::accidentalBuyukMucennebSharp;
|
|
break;
|
|
case 38: symId = SymId::accidentalKomaSharp;
|
|
break;
|
|
case 39: symId = SymId::accidentalThreeQuarterTonesSharpStein;
|
|
break;
|
|
case 40: symId = SymId::accidentalNatural;
|
|
break;
|
|
case 41: symId = SymId::accidentalQuarterToneSharpNaturalArrowUp;
|
|
break;
|
|
case 42: symId = SymId::accidentalQuarterToneFlatNaturalArrowDown;
|
|
break;
|
|
// case 43: // "natural arrow both" missing in SMuFL
|
|
case 44: symId = SymId::accidentalFlat;
|
|
break;
|
|
case 45: symId = SymId::accidentalQuarterToneFlatArrowUp;
|
|
break;
|
|
case 46: symId = SymId::accidentalThreeQuarterTonesFlatArrowDown;
|
|
break;
|
|
// case 47: // "flat arrow both" missing in SMuFL
|
|
case 48: symId = SymId::accidentalBakiyeFlat;
|
|
break;
|
|
case 49: symId = SymId::accidentalBuyukMucennebFlat;
|
|
break;
|
|
case 50: symId = SymId::accidentalThreeQuarterTonesFlatZimmermann;
|
|
break;
|
|
case 51: symId = SymId::accidentalQuarterToneFlatStein;
|
|
break;
|
|
// case 52: // "mirrored flat slash" missing in SMuFL
|
|
case 53: symId = SymId::accidentalDoubleFlat;
|
|
break;
|
|
// case 54: // "flat flat slash" missing in SMuFL
|
|
case 55: symId = SymId::accidentalDoubleSharp;
|
|
break;
|
|
case 56: symId = SymId::accidentalSori;
|
|
break;
|
|
case 57: symId = SymId::accidentalKoron;
|
|
break;
|
|
default:
|
|
qDebug("MuseScore 1.3 symbol id corresponding to <%d> not found", val);
|
|
symId = SymId::noSym;
|
|
break;
|
|
}
|
|
return symId;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// operator==
|
|
//---------------------------------------------------------
|
|
|
|
bool KeySig::operator==(const KeySig& k) const
|
|
{
|
|
return _sig == k._sig;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// isChange
|
|
//---------------------------------------------------------
|
|
|
|
bool KeySig::isChange() const
|
|
{
|
|
if (!staff()) {
|
|
return false;
|
|
}
|
|
if (!segment() || segment()->segmentType() != SegmentType::KeySig) {
|
|
return false;
|
|
}
|
|
Fraction keyTick = tick();
|
|
return staff()->currentKeyTick(keyTick) == keyTick;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// changeKeySigEvent
|
|
//---------------------------------------------------------
|
|
|
|
void KeySig::changeKeySigEvent(const KeySigEvent& t)
|
|
{
|
|
if (_sig == t) {
|
|
return;
|
|
}
|
|
setKeySigEvent(t);
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// undoSetShowCourtesy
|
|
//---------------------------------------------------------
|
|
|
|
void KeySig::undoSetShowCourtesy(bool v)
|
|
{
|
|
undoChangeProperty(Pid::SHOW_COURTESY, v);
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// undoSetMode
|
|
//---------------------------------------------------------
|
|
|
|
void KeySig::undoSetMode(KeyMode v)
|
|
{
|
|
undoChangeProperty(Pid::KEYSIG_MODE, int(v));
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// getProperty
|
|
//---------------------------------------------------------
|
|
|
|
QVariant KeySig::getProperty(Pid propertyId) const
|
|
{
|
|
switch (propertyId) {
|
|
case Pid::KEY:
|
|
return int(key());
|
|
case Pid::SHOW_COURTESY:
|
|
return int(showCourtesy());
|
|
case Pid::KEYSIG_MODE:
|
|
return int(mode());
|
|
default:
|
|
return Element::getProperty(propertyId);
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// setProperty
|
|
//---------------------------------------------------------
|
|
|
|
bool KeySig::setProperty(Pid propertyId, const QVariant& v)
|
|
{
|
|
switch (propertyId) {
|
|
case Pid::KEY:
|
|
if (generated()) {
|
|
return false;
|
|
}
|
|
setKey(Key(v.toInt()));
|
|
break;
|
|
case Pid::SHOW_COURTESY:
|
|
if (generated()) {
|
|
return false;
|
|
}
|
|
setShowCourtesy(v.toBool());
|
|
break;
|
|
case Pid::KEYSIG_MODE:
|
|
if (generated()) {
|
|
return false;
|
|
}
|
|
setMode(KeyMode(v.toInt()));
|
|
break;
|
|
default:
|
|
if (!Element::setProperty(propertyId, v)) {
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
triggerLayoutAll();
|
|
setGenerated(false);
|
|
return true;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// propertyDefault
|
|
//---------------------------------------------------------
|
|
|
|
QVariant KeySig::propertyDefault(Pid id) const
|
|
{
|
|
switch (id) {
|
|
case Pid::KEY:
|
|
return int(Key::INVALID);
|
|
case Pid::SHOW_COURTESY:
|
|
return true;
|
|
case Pid::KEYSIG_MODE:
|
|
return int(KeyMode::UNKNOWN);
|
|
default:
|
|
return Element::propertyDefault(id);
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// nextSegmentElement
|
|
//---------------------------------------------------------
|
|
|
|
Element* KeySig::nextSegmentElement()
|
|
{
|
|
return segment()->firstInNextSegments(staffIdx());
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// prevSegmentElement
|
|
//---------------------------------------------------------
|
|
|
|
Element* KeySig::prevSegmentElement()
|
|
{
|
|
return segment()->lastInPrevSegments(staffIdx());
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// accessibleInfo
|
|
//---------------------------------------------------------
|
|
|
|
QString KeySig::accessibleInfo() const
|
|
{
|
|
QString keySigType;
|
|
if (isAtonal()) {
|
|
return QString("%1: %2").arg(Element::accessibleInfo()).arg(qApp->translate("MuseScore", keyNames[15]));
|
|
} else if (isCustom()) {
|
|
return QObject::tr("%1: Custom").arg(Element::accessibleInfo());
|
|
}
|
|
|
|
if (key() == Key::C) {
|
|
return QString("%1: %2").arg(Element::accessibleInfo()).arg(qApp->translate("MuseScore", keyNames[14]));
|
|
}
|
|
int keyInt = static_cast<int>(key());
|
|
if (keyInt < 0) {
|
|
keySigType = qApp->translate("MuseScore", keyNames[(7 + keyInt) * 2 + 1]);
|
|
} else {
|
|
keySigType = qApp->translate("MuseScore", keyNames[(keyInt - 1) * 2]);
|
|
}
|
|
return QString("%1: %2").arg(Element::accessibleInfo()).arg(keySigType);
|
|
}
|
|
}
|