d24c1fecf0
Clef changes and courtesy clef on/off display have several issues: changed clef is not always shown, courtesy clefs on/off is unreliable and so on. In this fix: - A clef change at measure boundary is always placed at the end of the previous measure (unless for the very first measure). - This measure-final clef is never destroyed or re-created (the clef at the beginning of the next staff is managed by Score::layoutSystemRow() as before): this ensures a consistent context. - Showing / hiding of a courtesy clef is managed by Clef::layout() rather than by Score::layoutSystemRow() as before. - The clef change on measure boundary (always at the end of the previous measure and always present) is shown if: -- there is not another clef at the beginning of the next measure (not a courtesy clef at all); -- the score is set to show courtesy clefs -- the previous measure is not the last of a repeat or of a section -- the individual clef is set to show courtesy clef. - In all other cases, the clef is hidden (i.e. laid out to a element without any symbol). - The Clef Inspector is changed so that, if there is a pair of matching courtesy and main clef, their Show Courtesy flags are kept in sync (modifying either modifies both)
629 lines
24 KiB
C++
629 lines
24 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
|
|
//=============================================================================
|
|
|
|
/**
|
|
\file
|
|
Implementation of classes Clef (partial) and ClefList (complete).
|
|
*/
|
|
|
|
#include "clef.h"
|
|
#include "measure.h"
|
|
#include "ambitus.h"
|
|
#include "xml.h"
|
|
#include "sym.h"
|
|
#include "symbol.h"
|
|
#include "score.h"
|
|
#include "staff.h"
|
|
#include "segment.h"
|
|
#include "stafftype.h"
|
|
|
|
namespace Ms {
|
|
|
|
#define TR(a) QT_TRANSLATE_NOOP("clefTable", a)
|
|
|
|
// table must be in sync with enum ClefType
|
|
const ClefInfo ClefInfo::clefTable[] = {
|
|
// tag xmlName line oCh pOff|-lines for sharps---||---lines for flats--| name
|
|
{ "G", "G", 2, 0, 45, { 0, 3,-1, 2, 5, 1, 4, 4, 1, 5, 2, 6, 3, 7 }, TR("Treble clef"), STANDARD_STAFF_GROUP },
|
|
{ "G8va", "G", 2, 1, 52, { 0, 3,-1, 2, 5, 1, 4, 4, 1, 5, 2, 6, 3, 7 }, TR("Treble clef 8va"), STANDARD_STAFF_GROUP },
|
|
{ "G15ma","G", 2, 2, 59, { 0, 3,-1, 2, 5, 1, 4, 4, 1, 5, 2, 6, 3, 7 }, TR("Treble clef 15ma"), STANDARD_STAFF_GROUP },
|
|
{ "G8vb", "G", 2, -1, 38, { 0, 3,-1, 2, 5, 1, 4, 4, 1, 5, 2, 6, 3, 7 }, TR("Treble clef 8vb"), STANDARD_STAFF_GROUP },
|
|
{ "F", "F", 4, 0, 33, { 2, 5, 1, 4, 7, 3, 6, 6, 3, 7, 4, 8, 5, 9 }, TR("Bass clef"), STANDARD_STAFF_GROUP },
|
|
{ "F8vb", "F", 4, -1, 26, { 2, 5, 1, 4, 7, 3, 6, 6, 3, 7, 4, 8, 5, 9 }, TR("Bass clef 8vb"), STANDARD_STAFF_GROUP },
|
|
{ "F15mb","F", 4, -2, 19, { 2, 5, 1, 4, 7, 3, 6, 6, 3, 7, 4, 8, 5, 9 }, TR("Bass clef 15mb"), STANDARD_STAFF_GROUP },
|
|
{ "F3", "F", 3, 0, 35, { 4, 0, 3,-1, 2, 5, 1, 1, 5, 2, 6, 3, 7, 4 }, TR("Baritone clef (F clef)"), STANDARD_STAFF_GROUP },
|
|
{ "F5", "F", 5, 0, 31, { 0, 3,-1, 2, 5, 1, 4, 4, 1, 5, 2, 6, 3, 7 }, TR("Subbass clef"), STANDARD_STAFF_GROUP },
|
|
{ "C1", "C", 1, 0, 43, { 5, 1, 4, 0, 3,-1, 2, 2,-1, 3, 0, 4, 1, 5 }, TR("Soprano clef"), STANDARD_STAFF_GROUP }, // C1
|
|
{ "C2", "C", 2, 0, 41, { 3, 6, 2, 5, 1, 4, 0, 0, 4, 1, 5, 2, 6, 3 }, TR("Mezzo-soprano clef"), STANDARD_STAFF_GROUP }, // C2
|
|
{ "C3", "C", 3, 0, 39, { 1, 4, 0, 3, 6, 2, 5, 5, 2, 6, 3, 7, 4, 8 }, TR("Alto clef"), STANDARD_STAFF_GROUP }, // C3
|
|
{ "C4", "C", 4, 0, 37, { 6, 2, 5, 1, 4, 0, 3, 3, 0, 4, 1, 5, 2, 6 }, TR("Tenor clef"), STANDARD_STAFF_GROUP }, // C4
|
|
{ "TAB", "TAB", 5, 0, 0, { 0, 3,-1, 2, 5, 1, 4, 4, 1, 5, 2, 6, 3, 7 }, TR("Tablature"), TAB_STAFF_GROUP },
|
|
{ "PERC", "percussion",2, 0, 45, { 0, 3,-1, 2, 5, 1, 4, 4, 1, 5, 2, 6, 3, 7 }, TR("Percussion"), PERCUSSION_STAFF_GROUP},
|
|
{ "C5", "C", 5, 0, 35, { 4, 0, 3,-1, 2, 5, 1, 1, 5, 2, 6, 3, 7, 4 }, TR("Baritone clef (C clef)"), STANDARD_STAFF_GROUP }, // C5
|
|
{ "G1", "G", 1, 0, 47, { 2, 5, 1, 4, 7, 3, 6, 6, 3, 7, 4, 8, 5, 9 }, TR("French violin clef"), STANDARD_STAFF_GROUP }, // G4
|
|
{ "F8va", "F", 4, 1, 40, { 2, 5, 1, 4, 7, 3, 6, 6, 3, 7, 4, 8, 5, 9 }, TR("Bass clef 8va"), STANDARD_STAFF_GROUP }, // F_8VA
|
|
{ "F15ma","F", 4, 2, 47, { 2, 5, 1, 4, 7, 3, 6, 6, 3, 7, 4, 8, 5, 9 }, TR("Bass clef 15ma"), STANDARD_STAFF_GROUP }, // F_15MA
|
|
{ "PERC2","percussion",2, 0, 45, { 0, 3,-1, 2, 5, 1, 4, 4, 1, 5, 2, 6, 3, 7 }, TR("Percussion"), PERCUSSION_STAFF_GROUP}, // PERC2 placeholder
|
|
{ "TAB2", "TAB", 5, 0, 0, { 0, 3,-1, 2, 5, 1, 4, 4, 1, 5, 2, 6, 3, 7 }, TR("Tablature2"), TAB_STAFF_GROUP },
|
|
};
|
|
#undef TR
|
|
|
|
//---------------------------------------------------------
|
|
// tag2type
|
|
//---------------------------------------------------------
|
|
|
|
ClefType ClefInfo::tag2type(const QString& s)
|
|
{
|
|
for (unsigned i = 0; i < sizeof(ClefInfo::clefTable)/sizeof(*ClefInfo::clefTable); ++i) {
|
|
if (clefTable[i]._tag == s)
|
|
return ClefType(i);
|
|
}
|
|
return ClefType::G;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// Clef
|
|
//---------------------------------------------------------
|
|
|
|
Clef::Clef(Score* s)
|
|
: Element(s)
|
|
{
|
|
// setFlags(ELEMENT_SELECTABLE | ELEMENT_ON_STAFF | ELEMENT_MOVABLE);
|
|
setFlags(ELEMENT_SELECTABLE | ELEMENT_ON_STAFF);
|
|
|
|
_showCourtesy = true;
|
|
_small = false;
|
|
_clefTypes._concertClef = ClefType::INVALID;
|
|
_clefTypes._transposingClef = ClefType::INVALID;
|
|
curClefType = ClefType::G;
|
|
curLines = -1;
|
|
curLineDist = 1.0;
|
|
}
|
|
|
|
Clef::Clef(const Clef& c)
|
|
: Element(c)
|
|
{
|
|
_showCourtesy = c._showCourtesy;
|
|
_showPreviousClef = c._showPreviousClef;
|
|
_small = c._small;
|
|
_clefTypes = c._clefTypes;
|
|
curClefType = c.curClefType;
|
|
curLines = c.curLines;
|
|
curLineDist = c.curLineDist;
|
|
layout1();
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// mag
|
|
//---------------------------------------------------------
|
|
|
|
qreal Clef::mag() const
|
|
{
|
|
qreal mag = staff() ? staff()->mag() : 1.0;
|
|
if (_small)
|
|
mag *= score()->style(ST_smallClefMag).toDouble();
|
|
return mag;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// add
|
|
//---------------------------------------------------------
|
|
|
|
void Clef::addElement(Element* e, qreal x, qreal y)
|
|
{
|
|
e->layout();
|
|
e->setPos(x, y);
|
|
e->setParent(this);
|
|
e->setSelected(selected());
|
|
elements.push_back(e);
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// setSelected
|
|
//---------------------------------------------------------
|
|
|
|
void Clef::setSelected(bool f)
|
|
{
|
|
Element::setSelected(f);
|
|
foreach(Element* e, elements)
|
|
e->setSelected(f);
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// layout
|
|
//---------------------------------------------------------
|
|
|
|
void Clef::layout()
|
|
{
|
|
// determine current number of lines and line distance
|
|
int lines = 5; // assume a resonable default
|
|
qreal lineDist = 1.0;
|
|
|
|
Staff* stf = staff();
|
|
StaffType* staffType = nullptr;
|
|
if (stf && stf->staffType()) {
|
|
staffType = staff()->staffType();
|
|
if (!staffType->genClef()) { // if no clef, set empty bbox and do nothing
|
|
qDeleteAll(elements);
|
|
elements.clear();
|
|
setbbox(QRectF());
|
|
return;
|
|
}
|
|
|
|
// tablatures:
|
|
if (staffType->group() == TAB_STAFF_GROUP) {
|
|
// if current clef type not compatible with tablature,
|
|
// set tab clef according to score style
|
|
if (ClefInfo::staffGroup(clefType()) != TAB_STAFF_GROUP)
|
|
setClefType( ClefType(score()->styleI(ST_tabClef)) );
|
|
}
|
|
|
|
//
|
|
// all staff types
|
|
//
|
|
// courtesy clef
|
|
//
|
|
bool showClef = true;
|
|
Segment* clefSeg = static_cast<Segment*>(parent());
|
|
if (clefSeg) {
|
|
int tick = clefSeg->tick();
|
|
// only if there is a clef change
|
|
if (stf->clef(tick) != stf->clef(tick-1)) {
|
|
// locate clef at the begining of next measure, if any
|
|
Clef* clefNext = nullptr;
|
|
Segment* clefSegNext = nullptr;
|
|
Measure* meas = static_cast<Measure*>(clefSeg->parent());
|
|
Measure* measNext = meas->nextMeasure();
|
|
if (measNext) {
|
|
clefSegNext = measNext->findSegment(Segment::SegClef, tick);
|
|
if (clefSegNext)
|
|
clefNext = static_cast<Clef*>(clefSegNext->element(track()));
|
|
}
|
|
// show this clef if: it is not a courtesy clef (no next clef or not at the end of the measure)
|
|
showClef = !clefNext || (clefSeg->tick() != meas->tick() + meas->ticks())
|
|
// if courtesy clef: show if score has courtesy clefs on
|
|
|| ( score()->styleB(ST_genCourtesyClef)
|
|
// AND measure is not at the end of a repeat or of a section
|
|
&& !( (meas->repeatFlags() & RepeatEnd) || meas->sectionBreak() )
|
|
// AND this clef has courtesy clef turned on
|
|
&& showCourtesy() );
|
|
if (!showClef) { // if no clef, set empty bbox and do nothing
|
|
qDeleteAll(elements);
|
|
elements.clear();
|
|
setbbox(QRectF());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
lines = staffType->lines(); // init values from staff type
|
|
lineDist = staffType->lineDistance().val();
|
|
}
|
|
|
|
// if nothing changed since last layout, do nothing
|
|
// if (curClefType == clefType() && curLines == lines && curLineDist == lineDist)
|
|
// return;
|
|
// if something has changed, cache new values and re-layout
|
|
curClefType = clefType();
|
|
curLines = lines;
|
|
curLineDist = lineDist;
|
|
layout1();
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// layout1
|
|
//---------------------------------------------------------
|
|
|
|
void Clef::layout1()
|
|
{
|
|
qreal smag = mag();
|
|
qreal _spatium = spatium();
|
|
// qreal msp = score()->spatium() * smag;
|
|
qreal yoff = 0.0;
|
|
|
|
qDeleteAll(elements);
|
|
elements.clear();
|
|
|
|
Symbol* symbol = new Symbol(score());
|
|
|
|
switch (curClefType) {
|
|
case ClefType::G: // G clef on 2nd line
|
|
symbol->setSym(SymId::gClef);
|
|
yoff = 3.0 * curLineDist;
|
|
break;
|
|
case ClefType::G1: // G clef 8va on 2nd line
|
|
symbol->setSym(SymId::gClef8va);
|
|
yoff = 3.0 * curLineDist;
|
|
break;
|
|
case ClefType::G2: // G clef 15ma on 2nd line
|
|
symbol->setSym(SymId::gClef15ma);
|
|
yoff = 3.0 * curLineDist;
|
|
break;
|
|
case ClefType::G3: // G clef 8vb on 2nd line
|
|
symbol->setSym(SymId::gClef8vb);
|
|
yoff = 3.0 * curLineDist;
|
|
break;
|
|
case ClefType::F: // F clef on penultimate line
|
|
symbol->setSym(SymId::fClef);
|
|
yoff = 1.0 * curLineDist;
|
|
break;
|
|
case ClefType::F8: // F clef 8va bassa on penultimate line
|
|
symbol->setSym(SymId::fClef8vb);
|
|
yoff = 1.0 * curLineDist;
|
|
break;
|
|
case ClefType::F15: // F clef 15ma bassa on penultimate line
|
|
symbol->setSym(SymId::fClef15mb);
|
|
yoff = 1.0 * curLineDist;
|
|
break;
|
|
case ClefType::F_B: // baritone clef
|
|
symbol->setSym(SymId::fClef);
|
|
yoff = 2.0 * curLineDist;
|
|
break;
|
|
case ClefType::F_C: // subbass clef
|
|
symbol->setSym(SymId::fClef);
|
|
yoff = 0.0;
|
|
break;
|
|
case ClefType::C1: // C clef in 1st line
|
|
symbol->setSym(SymId::cClef);
|
|
yoff = 4.0 * curLineDist;
|
|
break;
|
|
case ClefType::C2: // C clef on 2nd line
|
|
symbol->setSym(SymId::cClef);
|
|
yoff = 3.0 * curLineDist;
|
|
break;
|
|
case ClefType::C3: // C clef in 3rd line
|
|
symbol->setSym(SymId::cClef);
|
|
yoff = 2.0 * curLineDist;
|
|
break;
|
|
case ClefType::C4: // C clef on 4th line
|
|
symbol->setSym(SymId::cClef);
|
|
yoff = 1.0 * curLineDist;
|
|
break;
|
|
case ClefType::C5: // C clef on 5th line
|
|
symbol->setSym(SymId::cClef);
|
|
yoff = 0.0;
|
|
break;
|
|
case ClefType::TAB: // TAB clef
|
|
symbol->setSym(SymId::sixStringTabClef);
|
|
// on tablature, position clef at half the number of spaces * line distance
|
|
yoff = curLineDist * (curLines - 1) * .5;
|
|
break;
|
|
case ClefType::TAB2: // TAB clef alternate style
|
|
symbol->setSym(SymId::sixStringTabClefSerif);
|
|
// on tablature, position clef at half the number of spaces * line distance
|
|
yoff = curLineDist * (curLines - 1) * .5;
|
|
break;
|
|
case ClefType::PERC: // percussion clefs
|
|
case ClefType::PERC2: // no longer supported: fall back to same glyph as PERC
|
|
symbol->setSym(SymId::unpitchedPercussionClef1);
|
|
yoff = curLineDist * (curLines - 1) * 0.5;
|
|
break;
|
|
case ClefType::G4: // G clef in 1st line
|
|
symbol->setSym(SymId::gClef);
|
|
yoff = 4.0 * curLineDist;
|
|
break;
|
|
case ClefType::F_8VA: // F clef 8va on penultimate line
|
|
symbol->setSym(SymId::fClef8va);
|
|
yoff = 1.0 * curLineDist;
|
|
break;
|
|
case ClefType::F_15MA: // F clef 15ma on penultimate line
|
|
symbol->setSym(SymId::fClef15ma);
|
|
yoff = 1.0 * curLineDist;
|
|
break;
|
|
case ClefType::INVALID:
|
|
case ClefType::MAX:
|
|
return;
|
|
}
|
|
|
|
symbol->setMag(smag);
|
|
symbol->layout();
|
|
addElement(symbol, .0, yoff * _spatium);
|
|
setbbox(QRectF());
|
|
for (auto i = elements.begin(); i != elements.end(); ++i) {
|
|
Element* e = *i;
|
|
e->setColor(curColor());
|
|
addbbox(e->bbox().translated(e->pos()));
|
|
e->setSelected(selected());
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// draw
|
|
//---------------------------------------------------------
|
|
|
|
void Clef::draw(QPainter* painter) const
|
|
{
|
|
if (staff() && !staff()->staffType()->genClef())
|
|
return;
|
|
QColor color(curColor());
|
|
foreach(Element* e, elements) {
|
|
e->setColor(color);
|
|
QPointF pt(e->pos());
|
|
painter->translate(pt);
|
|
e->draw(painter);
|
|
painter->translate(-pt);
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// acceptDrop
|
|
//---------------------------------------------------------
|
|
|
|
bool Clef::acceptDrop(MuseScoreView*, const QPointF&, Element* e) const
|
|
{
|
|
return (e->type() == CLEF || (/*!generated() &&*/ e->type() == AMBITUS) );
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// drop
|
|
//---------------------------------------------------------
|
|
|
|
Element* Clef::drop(const DropData& data)
|
|
{
|
|
Element* e = data.element;
|
|
Clef* c = 0;
|
|
if (e->type() == CLEF) {
|
|
Clef* clef = static_cast<Clef*>(e);
|
|
ClefType stype = clef->clefType();
|
|
if (clefType() != stype) {
|
|
score()->undoChangeClef(staff(), segment(), stype);
|
|
c = this;
|
|
}
|
|
}
|
|
else if (e->type() == AMBITUS) {
|
|
/*if (!generated())*/ {
|
|
Measure* meas = measure();
|
|
Segment* segm = meas->getSegment(Segment::SegAmbitus, meas->tick());
|
|
if (segm->element(track()))
|
|
score()->undoRemoveElement(segm->element(track()));
|
|
Ambitus* r = new Ambitus(score());
|
|
r->setParent(segm);
|
|
r->setTrack(track());
|
|
score()->undoAddElement(r);
|
|
}
|
|
}
|
|
delete e;
|
|
return c;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// setSmall
|
|
//---------------------------------------------------------
|
|
|
|
void Clef::setSmall(bool val)
|
|
{
|
|
if (val != _small) {
|
|
_small = val;
|
|
curClefType = ClefType::INVALID;
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// read
|
|
//---------------------------------------------------------
|
|
|
|
void Clef::read(XmlReader& e)
|
|
{
|
|
while (e.readNextStartElement()) {
|
|
const QStringRef& tag(e.name());
|
|
if (tag == "subtype")
|
|
setClefType(clefType(e.readElementText()));
|
|
else if (tag == "concertClefType")
|
|
_clefTypes._concertClef = Clef::clefType(e.readElementText());
|
|
else if (tag == "transposingClefType")
|
|
_clefTypes._transposingClef = Clef::clefType(e.readElementText());
|
|
else if (tag == "showCourtesyClef")
|
|
_showCourtesy = e.readInt();
|
|
else if (!Element::readProperties(e))
|
|
e.unknown();
|
|
}
|
|
if (score()->mscVersion() < 113)
|
|
setUserOff(QPointF());
|
|
if (clefType() == ClefType::INVALID)
|
|
setClefType(ClefType::G);
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// write
|
|
//---------------------------------------------------------
|
|
|
|
void Clef::write(Xml& xml) const
|
|
{
|
|
xml.stag(name());
|
|
if(_clefTypes._concertClef != ClefType::INVALID)
|
|
xml.tag("concertClefType", ClefInfo::tag(_clefTypes._concertClef));
|
|
if(_clefTypes._transposingClef != ClefType::INVALID)
|
|
xml.tag("transposingClefType", ClefInfo::tag(_clefTypes._transposingClef));
|
|
if (!_showCourtesy)
|
|
xml.tag("showCourtesyClef", _showCourtesy);
|
|
Element::writeProperties(xml);
|
|
xml.etag();
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// tick
|
|
//---------------------------------------------------------
|
|
|
|
int Clef::tick() const
|
|
{
|
|
return segment() ? segment()->tick() : 0;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// setClefType
|
|
//---------------------------------------------------------
|
|
|
|
void Clef::setClefType(const QString& s)
|
|
{
|
|
ClefType ct = clefType(s);
|
|
if (ct == ClefType::INVALID) {
|
|
qDebug("Clef::setSubtype: unknown: <%s>\n", qPrintable(s));
|
|
ct = ClefType::G;
|
|
}
|
|
setClefType(ct);
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// clefType
|
|
//---------------------------------------------------------
|
|
|
|
ClefType Clef::clefType(const QString& s)
|
|
{
|
|
ClefType ct = ClefType::G;
|
|
bool ok;
|
|
int i = s.toInt(&ok);
|
|
if (ok) {
|
|
//
|
|
// convert obsolete old coding
|
|
//
|
|
switch (i) {
|
|
default:
|
|
case 0: ct = ClefType::G; break;
|
|
case 1: ct = ClefType::G1; break;
|
|
case 2: ct = ClefType::G2; break;
|
|
case 3: ct = ClefType::G3; break;
|
|
case 4: ct = ClefType::F; break;
|
|
case 5: ct = ClefType::F8; break;
|
|
case 6: ct = ClefType::F15; break;
|
|
case 7: ct = ClefType::F_B; break;
|
|
case 8: ct = ClefType::F_C; break;
|
|
case 9: ct = ClefType::C1; break;
|
|
case 10: ct = ClefType::C2; break;
|
|
case 11: ct = ClefType::C3; break;
|
|
case 12: ct = ClefType::C4; break;
|
|
case 13: ct = ClefType::TAB; break;
|
|
case 14: ct = ClefType::PERC; break;
|
|
case 15: ct = ClefType::C5; break;
|
|
case 16: ct = ClefType::G4; break;
|
|
case 17: ct = ClefType::F_8VA; break;
|
|
case 18: ct = ClefType::F_15MA; break;
|
|
case 19: ct = ClefType::PERC2; break;
|
|
case 20: ct = ClefType::TAB2; break;
|
|
}
|
|
}
|
|
else
|
|
ct = ClefInfo::tag2type(s);
|
|
return ct;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// setClefType
|
|
//---------------------------------------------------------
|
|
|
|
void Clef::setClefType(ClefType i)
|
|
{
|
|
if (score()->concertPitch()) {
|
|
_clefTypes._concertClef = i;
|
|
if (_clefTypes._transposingClef == ClefType::INVALID)
|
|
_clefTypes._transposingClef = i;
|
|
|
|
}
|
|
else {
|
|
_clefTypes._transposingClef = i;
|
|
if (_clefTypes._concertClef == ClefType::INVALID)
|
|
_clefTypes._concertClef = i;
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// setConcertClef
|
|
//---------------------------------------------------------
|
|
|
|
void Clef::setConcertClef(ClefType val)
|
|
{
|
|
_clefTypes._concertClef = val;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// setTransposingClef
|
|
//---------------------------------------------------------
|
|
|
|
void Clef::setTransposingClef(ClefType val)
|
|
{
|
|
_clefTypes._transposingClef = val;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// clefType
|
|
//---------------------------------------------------------
|
|
|
|
ClefType Clef::clefType() const
|
|
{
|
|
if (score()->concertPitch())
|
|
return _clefTypes._concertClef;
|
|
else
|
|
return _clefTypes._transposingClef;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// spatiumChanged
|
|
//---------------------------------------------------------
|
|
|
|
void Clef::spatiumChanged(qreal oldValue, qreal newValue)
|
|
{
|
|
layout1();
|
|
Element::spatiumChanged(oldValue, newValue);
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// undoSetShowCourtesy
|
|
//---------------------------------------------------------
|
|
|
|
void Clef::undoSetShowCourtesy(bool v)
|
|
{
|
|
score()->undoChangeProperty(this, P_SHOW_COURTESY, v);
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// getProperty
|
|
//---------------------------------------------------------
|
|
|
|
QVariant Clef::getProperty(P_ID propertyId) const
|
|
{
|
|
switch(propertyId) {
|
|
case P_SHOW_COURTESY: return showCourtesy();
|
|
case P_SMALL: return small();
|
|
default:
|
|
return Element::getProperty(propertyId);
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// setProperty
|
|
//---------------------------------------------------------
|
|
|
|
bool Clef::setProperty(P_ID propertyId, const QVariant& v)
|
|
{
|
|
switch(propertyId) {
|
|
case P_SHOW_COURTESY: _showCourtesy = v.toBool(); break;
|
|
case P_SMALL: setSmall(v.toBool()); break;
|
|
default:
|
|
return Element::setProperty(propertyId, v);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// propertyDefault
|
|
//---------------------------------------------------------
|
|
|
|
QVariant Clef::propertyDefault(P_ID id) const
|
|
{
|
|
switch(id) {
|
|
case P_SHOW_COURTESY: return true;
|
|
case P_SMALL: return false;
|
|
default: return Element::propertyDefault(id);
|
|
}
|
|
}
|
|
|
|
}
|
|
|