LoweBowe/MuseScore
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

renaming: TempoChangeRanged -> GradualTempoChange

Browse source
This commit is contained in:
Roman Pudashkin 2022-06-06 11:35:11 +02:00
parent bebe6b4019
commit 7182a7c505
42 changed files with 213 additions and 211 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/engraving/libmscore/edit.cpp
View file

@ -2167,7 +2167,7 @@ void Score::cmdFlip()
|| e->isTextLineSegment()
|| e->isPedalSegment()
|| e->isLetRingSegment()
|| e->isTempoChangeRanged()
|| e->isGradualTempoChange()
|| e->isPalmMuteSegment()
|| e->isFermata()
|| e->isLyrics()
@ -2621,7 +2621,7 @@ void Score::deleteItem(EngravingItem* el)
case ElementType::PEDAL_SEGMENT:
case ElementType::GLISSANDO_SEGMENT:
case ElementType::LET_RING_SEGMENT:
case ElementType::TEMPO_RANGED_CHANGE_SEGMENT:
case ElementType::GRADUAL_TEMPO_CHANGE_SEGMENT:
case ElementType::PALM_MUTE_SEGMENT:
case ElementType::WHAMMY_BAR_SEGMENT:
case ElementType::RASGUEADO_SEGMENT:

2
src/engraving/libmscore/engravingobject.cpp
View file

@ -792,7 +792,7 @@ bool EngravingObject::isSLineSegment() const
return isHairpinSegment() || isOttavaSegment() || isPedalSegment()
|| isTrillSegment() || isVoltaSegment() || isTextLineSegment()
|| isGlissandoSegment() || isLetRingSegment() || isVibratoSegment() || isPalmMuteSegment()
|| isTempoChangeRangedSegment();
|| isGradualTempoChangeSegment();
}
//---------------------------------------------------------

16
src/engraving/libmscore/engravingobject.h
View file

@ -153,8 +153,8 @@ class Fermata;
class LetRing;
class LetRingSegment;
class TempoChangeRanged;
class TempoChangeRangedSegment;
class GradualTempoChange;
class GradualTempoChangeSegment;
class Vibrato;
class VibratoSegment;
class PalmMute;
@ -373,8 +373,8 @@ public:
CONVERT(TrillSegment, TRILL_SEGMENT)
CONVERT(LetRing, LET_RING)
CONVERT(LetRingSegment, LET_RING_SEGMENT)
CONVERT(TempoChangeRanged, TEMPO_RANGED_CHANGE)
CONVERT(TempoChangeRangedSegment, TEMPO_RANGED_CHANGE_SEGMENT)
CONVERT(GradualTempoChange, GRADUAL_TEMPO_CHANGE)
CONVERT(GradualTempoChangeSegment, GRADUAL_TEMPO_CHANGE_SEGMENT)
CONVERT(Vibrato, VIBRATO)
CONVERT(PalmMute, PALM_MUTE)
CONVERT(PalmMuteSegment, PALM_MUTE_SEGMENT)
@ -429,7 +429,7 @@ public:
{
return isHairpinSegment()
|| isLetRingSegment()
|| isTempoChangeRangedSegment()
|| isGradualTempoChangeSegment()
|| isTextLineSegment()
|| isOttavaSegment()
|| isPalmMuteSegment()
@ -461,7 +461,7 @@ public:
{
return isHairpin()
|| isLetRing()
|| isTempoChangeRanged()
|| isGradualTempoChange()
|| isNoteLine()
|| isOttava()
|| isPalmMute()
@ -703,8 +703,8 @@ CONVERT(Trill)
CONVERT(TrillSegment)
CONVERT(LetRing)
CONVERT(LetRingSegment)
CONVERT(TempoChangeRanged)
CONVERT(TempoChangeRangedSegment)
CONVERT(GradualTempoChange)
CONVERT(GradualTempoChangeSegment)
CONVERT(Vibrato)
CONVERT(VibratoSegment)
CONVERT(PalmMute)

12
src/engraving/libmscore/factory.cpp
View file

@ -37,7 +37,7 @@
#include "noteline.h"
#include "trill.h"
#include "letring.h"
#include "tempochangeranged.h"
#include "gradualtempochange.h"
#include "vibrato.h"
#include "palmmute.h"
#include "whammybar.h"
@ -169,7 +169,7 @@ static const ElementName elementNames[] = {
{ ElementType::OTTAVA_SEGMENT, "OttavaSegment", QT_TRANSLATE_NOOP("elementName", "Ottava segment") },
{ ElementType::TRILL_SEGMENT, "TrillSegment", QT_TRANSLATE_NOOP("elementName", "Trill segment") },
{ ElementType::LET_RING_SEGMENT, "LetRingSegment", QT_TRANSLATE_NOOP("elementName", "Let ring segment") },
{ ElementType::TEMPO_RANGED_CHANGE_SEGMENT, "TempoChangeRangedSegment", QT_TRANSLATE_NOOP("elementName", "Tempo change ranged segment") },
{ ElementType::GRADUAL_TEMPO_CHANGE_SEGMENT, "GradualTempoChangeSegment", QT_TRANSLATE_NOOP("elementName", "Gradual tempo change segment") },
{ ElementType::VIBRATO_SEGMENT, "VibratoSegment", QT_TRANSLATE_NOOP("elementName", "Vibrato segment") },
{ ElementType::PALM_MUTE_SEGMENT, "PalmMuteSegment", QT_TRANSLATE_NOOP("elementName", "Palm mute segment") },
{ ElementType::WHAMMY_BAR_SEGMENT, "WhammyBarSegment", QT_TRANSLATE_NOOP("elementName", "Whammy bar segment") },
@ -199,7 +199,7 @@ static const ElementName elementNames[] = {
{ ElementType::PEDAL, "Pedal", QT_TRANSLATE_NOOP("elementName", "Pedal") },
{ ElementType::TRILL, "Trill", QT_TRANSLATE_NOOP("elementName", "Trill") },
{ ElementType::LET_RING, "LetRing", QT_TRANSLATE_NOOP("elementName", "Let ring") },
{ ElementType::TEMPO_RANGED_CHANGE, "TempoChangeRanged", QT_TRANSLATE_NOOP("elementName", "Tempo changed ranged") },
{ ElementType::GRADUAL_TEMPO_CHANGE, "GradualTempoChange", QT_TRANSLATE_NOOP("elementName", "Gradual tempo change") },
{ ElementType::VIBRATO, "Vibrato", QT_TRANSLATE_NOOP("elementName", "Vibrato") },
{ ElementType::PALM_MUTE, "PalmMute", QT_TRANSLATE_NOOP("elementName", "Palm mute") },
{ ElementType::WHAMMY_BAR, "WhammyBar", QT_TRANSLATE_NOOP("elementName", "Whammy bar") },
@ -252,7 +252,7 @@ EngravingItem* Factory::doCreateItem(ElementType type, EngravingItem* parent)
case ElementType::NOTELINE: return new NoteLine(parent);
case ElementType::TRILL: return new Trill(parent);
case ElementType::LET_RING: return new LetRing(parent);
case ElementType::TEMPO_RANGED_CHANGE: return new TempoChangeRanged(parent);
case ElementType::GRADUAL_TEMPO_CHANGE: return new GradualTempoChange(parent);
case ElementType::VIBRATO: return new Vibrato(parent);
case ElementType::PALM_MUTE: return new PalmMute(parent);
case ElementType::WHAMMY_BAR: return new WhammyBar(parent);
@ -346,7 +346,7 @@ EngravingItem* Factory::doCreateItem(ElementType type, EngravingItem* parent)
case ElementType::OTTAVA_SEGMENT:
case ElementType::TRILL_SEGMENT:
case ElementType::LET_RING_SEGMENT:
case ElementType::TEMPO_RANGED_CHANGE_SEGMENT:
case ElementType::GRADUAL_TEMPO_CHANGE_SEGMENT:
case ElementType::VIBRATO_SEGMENT:
case ElementType::PALM_MUTE_SEGMENT:
case ElementType::WHAMMY_BAR_SEGMENT:
@ -748,7 +748,7 @@ Marker* Factory::createMarker(EngravingItem * parent, TextStyleType tid, bool is
return m;
}
CREATE_ITEM_IMPL(TempoChangeRanged, ElementType::TEMPO_RANGED_CHANGE, EngravingItem, isAccessibleEnabled)
CREATE_ITEM_IMPL(GradualTempoChange, ElementType::GRADUAL_TEMPO_CHANGE, EngravingItem, isAccessibleEnabled)
CREATE_ITEM_IMPL(PalmMute, ElementType::PALM_MUTE, EngravingItem, isAccessibleEnabled)

2
src/engraving/libmscore/factory.h
View file

@ -223,7 +223,7 @@ public:
static Marker* createMarker(EngravingItem* parent, TextStyleType tid, bool isAccessibleEnabled = true);
static TempoChangeRanged* createTempoChangeRanged(EngravingItem* parent, bool isAccessibleEnabled = true);
static GradualTempoChange* createGradualTempoChange(EngravingItem* parent, bool isAccessibleEnabled = true);
static PalmMute* createPalmMute(EngravingItem* parent, bool isAccessibleEnabled = true);

88
src/engraving/libmscore/tempochangeranged.cpp → src/engraving/libmscore/gradualtempochange.cpp
View file

@ -20,7 +20,7 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include "tempochangeranged.h"
#include "gradualtempochange.h"
#include "log.h"
@ -67,22 +67,22 @@ static const ElementStyle tempoSegmentStyle {
{ Sid::tempoMinDistance, Pid::MIN_DISTANCE }
};
static const std::unordered_map<TempoChangeType, double> DEFAULT_FACTORS_MAP {
{ TempoChangeType::Accelerando, 1.33 },
{ TempoChangeType::Allargando, 0.75 },
{ TempoChangeType::Calando, 0.5 },
{ TempoChangeType::Lentando, 0.75 },
{ TempoChangeType::Morendo, 0.5 },
{ TempoChangeType::Precipitando, 1.15 },
{ TempoChangeType::Rallentando, 0.75 },
{ TempoChangeType::Ritardando, 0.75 },
{ TempoChangeType::Smorzando, 0.5 },
{ TempoChangeType::Sostenuto, 0.95 },
{ TempoChangeType::Stringendo, 1.5 }
static const std::unordered_map<GradualTempoChangeType, double> DEFAULT_FACTORS_MAP {
{ GradualTempoChangeType::Accelerando, 1.33 },
{ GradualTempoChangeType::Allargando, 0.75 },
{ GradualTempoChangeType::Calando, 0.5 },
{ GradualTempoChangeType::Lentando, 0.75 },
{ GradualTempoChangeType::Morendo, 0.5 },
{ GradualTempoChangeType::Precipitando, 1.15 },
{ GradualTempoChangeType::Rallentando, 0.75 },
{ GradualTempoChangeType::Ritardando, 0.75 },
{ GradualTempoChangeType::Smorzando, 0.5 },
{ GradualTempoChangeType::Sostenuto, 0.95 },
{ GradualTempoChangeType::Stringendo, 1.5 }
};
TempoChangeRanged::TempoChangeRanged(EngravingItem* parent)
: ChordTextLineBase(ElementType::TEMPO_RANGED_CHANGE, parent)
GradualTempoChange::GradualTempoChange(EngravingItem* parent)
: ChordTextLineBase(ElementType::GRADUAL_TEMPO_CHANGE, parent)
{
initElementStyle(&tempoStyle);
resetProperty(Pid::LINE_VISIBLE);
@ -95,12 +95,12 @@ TempoChangeRanged::TempoChangeRanged(EngravingItem* parent)
resetProperty(Pid::END_TEXT);
}
TempoChangeRanged* TempoChangeRanged::clone() const
GradualTempoChange* GradualTempoChange::clone() const
{
return new TempoChangeRanged(*this);
return new GradualTempoChange(*this);
}
void TempoChangeRanged::read(XmlReader& reader)
void GradualTempoChange::read(XmlReader& reader)
{
while (reader.readNextStartElement()) {
const AsciiString tag(reader.name());
@ -128,7 +128,7 @@ void TempoChangeRanged::read(XmlReader& reader)
}
}
void TempoChangeRanged::write(XmlWriter& writer) const
void GradualTempoChange::write(XmlWriter& writer) const
{
writer.startElement(this);
writeProperty(writer, Pid::TEMPO_CHANGE_TYPE);
@ -138,30 +138,30 @@ void TempoChangeRanged::write(XmlWriter& writer) const
writer.endElement();
}
LineSegment* TempoChangeRanged::createLineSegment(System* parent)
LineSegment* GradualTempoChange::createLineSegment(System* parent)
{
TempoChangeRangedSegment* lineSegment = new TempoChangeRangedSegment(this, parent);
GradualTempoChangeSegment* lineSegment = new GradualTempoChangeSegment(this, parent);
lineSegment->setTrack(track());
lineSegment->initElementStyle(&tempoSegmentStyle);
return lineSegment;
}
TempoChangeType TempoChangeRanged::tempoChangeType() const
GradualTempoChangeType GradualTempoChange::tempoChangeType() const
{
return m_tempoChangeType;
}
ChangeMethod TempoChangeRanged::easingMethod() const
ChangeMethod GradualTempoChange::easingMethod() const
{
return m_tempoEasingMethod;
}
void TempoChangeRanged::setTempoChangeType(const TempoChangeType type)
void GradualTempoChange::setTempoChangeType(const GradualTempoChangeType type)
{
m_tempoChangeType = type;
}
double TempoChangeRanged::tempoChangeFactor() const
double GradualTempoChange::tempoChangeFactor() const
{
if (m_tempoChangeFactor.has_value()) {
return m_tempoChangeFactor.value();
@ -170,7 +170,7 @@ double TempoChangeRanged::tempoChangeFactor() const
return mu::value(DEFAULT_FACTORS_MAP, m_tempoChangeType, 1.0);
}
PropertyValue TempoChangeRanged::getProperty(Pid id) const
PropertyValue GradualTempoChange::getProperty(Pid id) const
{
switch (id) {
case Pid::TEMPO_CHANGE_TYPE:
@ -184,11 +184,11 @@ PropertyValue TempoChangeRanged::getProperty(Pid id) const
}
}
bool TempoChangeRanged::setProperty(Pid id, const PropertyValue& val)
bool GradualTempoChange::setProperty(Pid id, const PropertyValue& val)
{
switch (id) {
case Pid::TEMPO_CHANGE_TYPE:
m_tempoChangeType = TempoChangeType(val.toInt());
m_tempoChangeType = GradualTempoChangeType(val.toInt());
break;
case Pid::TEMPO_EASING_METHOD:
m_tempoEasingMethod = ChangeMethod(val.toInt());
@ -207,7 +207,7 @@ bool TempoChangeRanged::setProperty(Pid id, const PropertyValue& val)
return true;
}
PropertyValue TempoChangeRanged::propertyDefault(Pid propertyId) const
PropertyValue GradualTempoChange::propertyDefault(Pid propertyId) const
{
switch (propertyId) {
case Pid::ALIGN:
@ -241,7 +241,7 @@ PropertyValue TempoChangeRanged::propertyDefault(Pid propertyId) const
return TextPlace::AUTO;
case Pid::TEMPO_CHANGE_TYPE:
return TempoChangeType::Undefined;
return GradualTempoChangeType::Undefined;
case Pid::TEMPO_EASING_METHOD:
return ChangeMethod::NORMAL;
case Pid::TEMPO_CHANGE_FACTOR:
@ -252,7 +252,7 @@ PropertyValue TempoChangeRanged::propertyDefault(Pid propertyId) const
}
}
Sid TempoChangeRanged::getPropertyStyle(Pid id) const
Sid GradualTempoChange::getPropertyStyle(Pid id) const
{
switch (id) {
case Pid::PLACEMENT:
@ -281,17 +281,17 @@ Sid TempoChangeRanged::getPropertyStyle(Pid id) const
return TextLineBase::getPropertyStyle(id);
}
void TempoChangeRanged::added()
void GradualTempoChange::added()
{
requestToRebuildTempo();
}
void TempoChangeRanged::removed()
void GradualTempoChange::removed()
{
requestToRebuildTempo();
}
void TempoChangeRanged::requestToRebuildTempo()
void GradualTempoChange::requestToRebuildTempo()
{
IF_ASSERT_FAILED(score()) {
return;
@ -300,28 +300,28 @@ void TempoChangeRanged::requestToRebuildTempo()
score()->setUpTempoMap();
}
TempoChangeRangedSegment::TempoChangeRangedSegment(TempoChangeRanged* annotation, System* parent)
: TextLineBaseSegment(ElementType::TEMPO_RANGED_CHANGE_SEGMENT, annotation, parent, ElementFlag::MOVABLE | ElementFlag::ON_STAFF)
GradualTempoChangeSegment::GradualTempoChangeSegment(GradualTempoChange* annotation, System* parent)
: TextLineBaseSegment(ElementType::GRADUAL_TEMPO_CHANGE_SEGMENT, annotation, parent, ElementFlag::MOVABLE | ElementFlag::ON_STAFF)
{
}
TempoChangeRangedSegment* TempoChangeRangedSegment::clone() const
GradualTempoChangeSegment* GradualTempoChangeSegment::clone() const
{
return new TempoChangeRangedSegment(*this);
return new GradualTempoChangeSegment(*this);
}
TempoChangeRanged* TempoChangeRangedSegment::tempoChange() const
GradualTempoChange* GradualTempoChangeSegment::tempoChange() const
{
return static_cast<TempoChangeRanged*>(spanner());
return static_cast<GradualTempoChange*>(spanner());
}
void TempoChangeRangedSegment::layout()
void GradualTempoChangeSegment::layout()
{
TextLineBaseSegment::layout();
autoplaceSpannerSegment();
}
void TempoChangeRangedSegment::endEdit(EditData& editData)
void GradualTempoChangeSegment::endEdit(EditData& editData)
{
IF_ASSERT_FAILED(tempoChange()) {
return;
@ -331,7 +331,7 @@ void TempoChangeRangedSegment::endEdit(EditData& editData)
tempoChange()->requestToRebuildTempo();
}
void TempoChangeRangedSegment::added()
void GradualTempoChangeSegment::added()
{
IF_ASSERT_FAILED(tempoChange()) {
return;
@ -340,7 +340,7 @@ void TempoChangeRangedSegment::added()
tempoChange()->requestToRebuildTempo();
}
void TempoChangeRangedSegment::removed()
void GradualTempoChangeSegment::removed()
{
IF_ASSERT_FAILED(tempoChange()) {
return;

32
src/engraving/libmscore/tempochangeranged.h → src/engraving/libmscore/gradualtempochange.h
View file

@ -20,8 +20,8 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef MU_ENGRAVING_TEMPORANGEDCHANGEANNOTATION_H
#define MU_ENGRAVING_TEMPORANGEDCHANGEANNOTATION_H
#ifndef MU_ENGRAVING_GRADUALTEMPOCHANGE_H
#define MU_ENGRAVING_GRADUALTEMPOCHANGE_H
#include <optional>
@ -29,22 +29,22 @@
#include "types/types.h"
namespace mu::engraving {
class TempoChangeRangedSegment;
class TempoChangeRanged : public ChordTextLineBase
class GradualTempoChangeSegment;
class GradualTempoChange : public ChordTextLineBase
{
public:
TempoChangeRanged(EngravingItem* parent);
GradualTempoChange(EngravingItem* parent);
TempoChangeRanged* clone() const override;
GradualTempoChange* clone() const override;
void read(XmlReader& reader) override;
void write(XmlWriter& writer) const override;
LineSegment* createLineSegment(System* parent) override;
TempoChangeType tempoChangeType() const;
GradualTempoChangeType tempoChangeType() const;
ChangeMethod easingMethod() const;
void setTempoChangeType(const TempoChangeType type);
void setTempoChangeType(const GradualTempoChangeType type);
double tempoChangeFactor() const;
@ -60,29 +60,29 @@ protected:
private:
void requestToRebuildTempo();
TempoChangeType m_tempoChangeType = TempoChangeType::Undefined;
GradualTempoChangeType m_tempoChangeType = GradualTempoChangeType::Undefined;
ChangeMethod m_tempoEasingMethod = ChangeMethod::NORMAL;
std::optional<float> m_tempoChangeFactor;
friend class TempoChangeRangedSegment;
friend class GradualTempoChangeSegment;
};
class TempoChangeRangedSegment : public TextLineBaseSegment
class GradualTempoChangeSegment : public TextLineBaseSegment
{
public:
TempoChangeRangedSegment(TempoChangeRanged* annotation, System* parent);
GradualTempoChangeSegment(GradualTempoChange* annotation, System* parent);
TempoChangeRangedSegment* clone() const override;
GradualTempoChangeSegment* clone() const override;
TempoChangeRanged* tempoChange() const;
GradualTempoChange* tempoChange() const;
void layout() override;
void endEdit(EditData& editData) override;
void added() override;
void removed() override;
friend class TempoChangeRanged;
friend class GradualTempoChange;
};
}
#endif // MU_ENGRAVING_TEMPORANGEDCHANGEANNOTATION_H
#endif // MU_ENGRAVING_GRADUALTEMPOCHANGE_H

4
src/engraving/libmscore/libmscore.cmake
View file

@ -349,6 +349,6 @@ set(LIBMSCORE_SRC
${CMAKE_CURRENT_LIST_DIR}/whammybar.h
${CMAKE_CURRENT_LIST_DIR}/playtechannotation.cpp
${CMAKE_CURRENT_LIST_DIR}/playtechannotation.h
${CMAKE_CURRENT_LIST_DIR}/tempochangeranged.cpp
${CMAKE_CURRENT_LIST_DIR}/tempochangeranged.h
${CMAKE_CURRENT_LIST_DIR}/gradualtempochange.cpp
${CMAKE_CURRENT_LIST_DIR}/gradualtempochange.h
)

2
src/engraving/libmscore/measure.cpp
View file

@ -2037,7 +2037,7 @@ void Measure::readAddConnector(ConnectorInfoReader* info, bool pasteMode)
case ElementType::TRILL:
case ElementType::TEXTLINE:
case ElementType::LET_RING:
case ElementType::TEMPO_RANGED_CHANGE:
case ElementType::GRADUAL_TEMPO_CHANGE:
case ElementType::VIBRATO:
case ElementType::PALM_MUTE:
case ElementType::WHAMMY_BAR:

2
src/engraving/libmscore/navigate.cpp
View file

@ -653,7 +653,7 @@ EngravingItem* Score::nextElement()
case ElementType::TRILL_SEGMENT:
case ElementType::VIBRATO_SEGMENT:
case ElementType::LET_RING_SEGMENT:
case ElementType::TEMPO_RANGED_CHANGE_SEGMENT:
case ElementType::GRADUAL_TEMPO_CHANGE_SEGMENT:
case ElementType::PALM_MUTE_SEGMENT:
case ElementType::WHAMMY_BAR_SEGMENT:
case ElementType::RASGUEADO_SEGMENT:

2
src/engraving/libmscore/paste.cpp
View file

@ -580,7 +580,7 @@ void Score::readAddConnector(ConnectorInfoReader* info, bool pasteMode)
case ElementType::RASGUEADO:
case ElementType::HARMONIC_MARK:
case ElementType::LET_RING:
case ElementType::TEMPO_RANGED_CHANGE:
case ElementType::GRADUAL_TEMPO_CHANGE:
case ElementType::VIBRATO:
{
Spanner* sp = toSpanner(info->connector());

4
src/engraving/libmscore/property.cpp
View file

@ -390,7 +390,7 @@ static constexpr PropertyMetaData propertyList[] = {
{ Pid::PLAY_TECH_TYPE, true, "playTechType", P_TYPE::PLAYTECH_TYPE, DUMMY_QT_TR_NOOP("propertyName", "playing technique type") },
{ Pid::TEMPO_CHANGE_TYPE, true, "tempoChangeType", P_TYPE::TEMPOCHANGE_TYPE, DUMMY_QT_TR_NOOP("propertyName", "tempo ranged change type") },
{ Pid::TEMPO_CHANGE_TYPE, true, "tempoChangeType", P_TYPE::TEMPOCHANGE_TYPE, DUMMY_QT_TR_NOOP("propertyName", "gradual tempo change type") },
{ Pid::TEMPO_EASING_METHOD, true, "tempoEasingMethod", P_TYPE::CHANGE_METHOD, DUMMY_QT_TR_NOOP("propertyName", "tempo easing method") },
{ Pid::TEMPO_CHANGE_FACTOR, true, "tempoChangeFactor", P_TYPE::REAL, DUMMY_QT_TR_NOOP("propertyName", "tempo change factor") },
@ -580,7 +580,7 @@ PropertyValue readProperty(Pid id, XmlReader& e)
case P_TYPE::PLAYTECH_TYPE:
return PropertyValue(TConv::fromXml(e.readElementAsciiText(), PlayingTechniqueType::Natural));
case P_TYPE::TEMPOCHANGE_TYPE:
return PropertyValue(TConv::fromXml(e.readElementAsciiText(), TempoChangeType::Undefined));
return PropertyValue(TConv::fromXml(e.readElementAsciiText(), GradualTempoChangeType::Undefined));
default:
ASSERT_X("unhandled PID type");
break;

10
src/engraving/libmscore/score.cpp
View file

@ -89,7 +89,7 @@
#include "system.h"
#include "tempo.h"
#include "tempotext.h"
#include "tempochangeranged.h"
#include "gradualtempochange.h"
#include "text.h"
#include "tie.h"
#include "tiemap.h"
@ -567,11 +567,11 @@ void Score::setUpTempoMap()
for (const auto& pair : spanner()) {
const Spanner* spannerItem = pair.second;
if (!spannerItem || !spannerItem->isTempoChangeRanged()) {
if (!spannerItem || !spannerItem->isGradualTempoChange()) {
continue;
}
const TempoChangeRanged* tempoChange = toTempoChangeRanged(spannerItem);
const GradualTempoChange* tempoChange = toGradualTempoChange(spannerItem);
if (!tempoChange) {
continue;
}
@ -1565,7 +1565,7 @@ void Score::addElement(EngravingItem* element)
case ElementType::TEXTLINE:
case ElementType::HAIRPIN:
case ElementType::LET_RING:
case ElementType::TEMPO_RANGED_CHANGE:
case ElementType::GRADUAL_TEMPO_CHANGE:
case ElementType::PALM_MUTE:
case ElementType::WHAMMY_BAR:
case ElementType::RASGUEADO:
@ -1723,7 +1723,7 @@ void Score::removeElement(EngravingItem* element)
case ElementType::VIBRATO:
case ElementType::PEDAL:
case ElementType::LET_RING:
case ElementType::TEMPO_RANGED_CHANGE:
case ElementType::GRADUAL_TEMPO_CHANGE:
case ElementType::PALM_MUTE:
case ElementType::WHAMMY_BAR:
case ElementType::RASGUEADO:

4
src/engraving/libmscore/system.cpp
View file

@ -1141,7 +1141,7 @@ void System::add(EngravingItem* el)
case ElementType::LYRICSLINE_SEGMENT:
case ElementType::GLISSANDO_SEGMENT:
case ElementType::LET_RING_SEGMENT:
case ElementType::TEMPO_RANGED_CHANGE_SEGMENT:
case ElementType::GRADUAL_TEMPO_CHANGE_SEGMENT:
case ElementType::PALM_MUTE_SEGMENT:
case ElementType::WHAMMY_BAR_SEGMENT:
case ElementType::RASGUEADO_SEGMENT:
@ -1215,7 +1215,7 @@ void System::remove(EngravingItem* el)
case ElementType::TIE_SEGMENT:
case ElementType::PEDAL_SEGMENT:
case ElementType::LYRICSLINE_SEGMENT:
case ElementType::TEMPO_RANGED_CHANGE_SEGMENT:
case ElementType::GRADUAL_TEMPO_CHANGE_SEGMENT:
case ElementType::GLISSANDO_SEGMENT:
if (!mu::remove(_spannerSegments, toSpannerSegment(el))) {
LOGD("System::remove: %p(%s) not found, score %p", el, el->typeName(), score());

4
src/engraving/libmscore/types.h
View file

@ -109,7 +109,7 @@ enum class ElementType {
OTTAVA_SEGMENT,
TRILL_SEGMENT,
LET_RING_SEGMENT,
TEMPO_RANGED_CHANGE_SEGMENT,
GRADUAL_TEMPO_CHANGE_SEGMENT,
VIBRATO_SEGMENT,
PALM_MUTE_SEGMENT,
WHAMMY_BAR_SEGMENT,
@ -139,7 +139,7 @@ enum class ElementType {
PEDAL,
TRILL,
LET_RING,
TEMPO_RANGED_CHANGE,
GRADUAL_TEMPO_CHANGE,
VIBRATO,
PALM_MUTE,
WHAMMY_BAR,

2
src/engraving/playback/playbackmodel.cpp
View file

@ -331,7 +331,7 @@ bool PlaybackModel::hasToReloadTracks(const std::unordered_set<ElementType>& cha
bool PlaybackModel::hasToReloadScore(const std::unordered_set<ElementType>& changedTypes) const
{
static const std::unordered_set<ElementType> REQUIRED_TYPES = {
ElementType::TEMPO_RANGED_CHANGE, ElementType::TEMPO_RANGED_CHANGE_SEGMENT,
ElementType::GRADUAL_TEMPO_CHANGE, ElementType::GRADUAL_TEMPO_CHANGE_SEGMENT,
ElementType::TEMPO_TEXT,
ElementType::LAYOUT_BREAK, ElementType::FERMATA
};

4
src/engraving/property/propertyvalue.cpp
View file

@ -155,7 +155,7 @@ QVariant PropertyValue::toQVariant() const
case P_TYPE::KEY_MODE: return static_cast<int>(value<KeyMode>());
case P_TYPE::TEXT_STYLE: return static_cast<int>(value<TextStyleType>());
case P_TYPE::PLAYTECH_TYPE: return static_cast<int>(value<PlayingTechniqueType>());
case P_TYPE::TEMPOCHANGE_TYPE: return static_cast<int>(value<TempoChangeType>());
case P_TYPE::TEMPOCHANGE_TYPE: return static_cast<int>(value<GradualTempoChangeType>());
case P_TYPE::SLUR_STYLE_TYPE: return static_cast<int>(value<SlurStyleType>());
// Other
@ -245,7 +245,7 @@ PropertyValue PropertyValue::fromQVariant(const QVariant& v, P_TYPE type)
case P_TYPE::KEY_MODE: return PropertyValue(KeyMode(v.toInt()));
case P_TYPE::TEXT_STYLE: return PropertyValue(TextStyleType(v.toInt()));
case P_TYPE::PLAYTECH_TYPE: return PropertyValue(PlayingTechniqueType(v.toInt()));
case P_TYPE::TEMPOCHANGE_TYPE: return PropertyValue(TempoChangeType(v.toInt()));
case P_TYPE::TEMPOCHANGE_TYPE: return PropertyValue(GradualTempoChangeType(v.toInt()));
case P_TYPE::SLUR_STYLE_TYPE: return PropertyValue(SlurStyleType(v.toInt()));
// Other

4
src/engraving/property/propertyvalue.h
View file

@ -242,8 +242,8 @@ public:
PropertyValue(PlayingTechniqueType v)
: m_type(P_TYPE::PLAYTECH_TYPE), m_data(make_data<PlayingTechniqueType>(v)) {}
PropertyValue(TempoChangeType v)
: m_type(P_TYPE::TEMPOCHANGE_TYPE), m_data(make_data<TempoChangeType>(v)) {}
PropertyValue(GradualTempoChangeType v)
: m_type(P_TYPE::TEMPOCHANGE_TYPE), m_data(make_data<GradualTempoChangeType>(v)) {}
PropertyValue(SlurStyleType v)
: m_type(P_TYPE::SLUR_STYLE_TYPE), m_data(make_data<SlurStyleType>(v)) {}

2
src/engraving/rw/xmlwriter.cpp
View file

@ -288,7 +288,7 @@ void XmlWriter::tagProperty(const AsciiString& name, P_TYPE type, const Property
element(name, TConv::toXml(data.value<PlayingTechniqueType>()));
} break;
case P_TYPE::TEMPOCHANGE_TYPE: {
element(name, TConv::toXml(data.value<TempoChangeType>()));
element(name, TConv::toXml(data.value<GradualTempoChangeType>()));
} break;
default: {
UNREACHABLE; //! TODO

2
src/engraving/types/types.h
View file

@ -532,7 +532,7 @@ enum class PlayingTechniqueType {
Overdrive
};
enum class TempoChangeType {
enum class GradualTempoChangeType {
Undefined = -1,
Accelerando,
Allargando,

34
src/engraving/types/typesconv.cpp
View file

@ -1029,29 +1029,29 @@ PlayingTechniqueType TConv::fromXml(const AsciiString& tag, PlayingTechniqueType
return findTypeByXmlTag<PlayingTechniqueType>(PLAY_TECH_TYPES, tag, def);
}
static const std::vector<Item<TempoChangeType> > TEMPO_CHANGE_TYPES = {
{ TempoChangeType::Undefined, "undefined" },
{ TempoChangeType::Accelerando, "accelerando" },
{ TempoChangeType::Allargando, "allargando" },
{ TempoChangeType::Calando, "calando" },
{ TempoChangeType::Lentando, "lentando" },
{ TempoChangeType::Morendo, "morendo" },
{ TempoChangeType::Precipitando, "precipitando" },
{ TempoChangeType::Rallentando, "rallentando" },
{ TempoChangeType::Ritardando, "ritardando" },
{ TempoChangeType::Smorzando, "smorzando" },
{ TempoChangeType::Sostenuto, "sostenuto" },
{ TempoChangeType::Stringendo, "stringendo" }
static const std::vector<Item<GradualTempoChangeType> > TEMPO_CHANGE_TYPES = {
{ GradualTempoChangeType::Undefined, "undefined" },
{ GradualTempoChangeType::Accelerando, "accelerando" },
{ GradualTempoChangeType::Allargando, "allargando" },
{ GradualTempoChangeType::Calando, "calando" },
{ GradualTempoChangeType::Lentando, "lentando" },
{ GradualTempoChangeType::Morendo, "morendo" },
{ GradualTempoChangeType::Precipitando, "precipitando" },
{ GradualTempoChangeType::Rallentando, "rallentando" },
{ GradualTempoChangeType::Ritardando, "ritardando" },
{ GradualTempoChangeType::Smorzando, "smorzando" },
{ GradualTempoChangeType::Sostenuto, "sostenuto" },
{ GradualTempoChangeType::Stringendo, "stringendo" }
};
AsciiString TConv::toXml(TempoChangeType v)
AsciiString TConv::toXml(GradualTempoChangeType v)
{
return findXmlTagByType<TempoChangeType>(TEMPO_CHANGE_TYPES, v);
return findXmlTagByType<GradualTempoChangeType>(TEMPO_CHANGE_TYPES, v);
}
TempoChangeType TConv::fromXml(const AsciiString& tag, TempoChangeType def)
GradualTempoChangeType TConv::fromXml(const AsciiString& tag, GradualTempoChangeType def)
{
return findTypeByXmlTag<TempoChangeType>(TEMPO_CHANGE_TYPES, tag, def);
return findTypeByXmlTag<GradualTempoChangeType>(TEMPO_CHANGE_TYPES, tag, def);
}
static const std::vector<Item<OrnamentStyle> > ORNAMENTSTYLE_TYPES = {

4
src/engraving/types/typesconv.h
View file

@ -111,8 +111,8 @@ public:
static AsciiString toXml(PlayingTechniqueType v);
static PlayingTechniqueType fromXml(const AsciiString& tag, PlayingTechniqueType def);
static AsciiString toXml(TempoChangeType v);
static TempoChangeType fromXml(const AsciiString& tag, TempoChangeType def);
static AsciiString toXml(GradualTempoChangeType v);
static GradualTempoChangeType fromXml(const AsciiString& tag, GradualTempoChangeType def);
static AsciiString toXml(OrnamentStyle v);
static OrnamentStyle fromXml(const AsciiString& str, OrnamentStyle def);

8
src/engraving/utests/tempomap_data/gradual_tempo_change_accelerando/gradual_tempo_change_accelerando.mscx
View file

@ -260,8 +260,8 @@
</Measure>
<Measure>
<voice>
<Spanner type="TempoChangeRanged">
<TempoChangeRanged>
<Spanner type="GradualTempoChange">
<GradualTempoChange>
<tempoChangeType>accelerando</tempoChangeType>
<beginHookHeight>1.9</beginHookHeight>
<endHookType>0</endHookType>
@ -273,7 +273,7 @@
<offset x="0" y="0"/>
<off2 x="0.495815" y="0"/>
</Segment>
</TempoChangeRanged>
</GradualTempoChange>
<next>
<location>
<measures>2</measures>
@ -344,7 +344,7 @@
</Measure>
<Measure>
<voice>
<Spanner type="TempoChangeRanged">
<Spanner type="GradualTempoChange">
<prev>
<location>
<measures>-2</measures>

8
src/engraving/utests/tempomap_data/gradual_tempo_change_rallentando/gradual_tempo_change_rallentando.mscx
View file

@ -260,8 +260,8 @@
</Measure>
<Measure>
<voice>
<Spanner type="TempoChangeRanged">
<TempoChangeRanged>
<Spanner type="GradualTempoChange">
<GradualTempoChange>
<tempoChangeType>rallentando</tempoChangeType>
<beginHookHeight>1.9</beginHookHeight>
<endHookType>0</endHookType>
@ -273,7 +273,7 @@
<offset x="0" y="0"/>
<off2 x="0.495815" y="0"/>
</Segment>
</TempoChangeRanged>
</GradualTempoChange>
<next>
<location>
<measures>2</measures>
@ -344,7 +344,7 @@
</Measure>
<Measure>
<voice>
<Spanner type="TempoChangeRanged">
<Spanner type="GradualTempoChange">
<prev>
<location>
<measures>-2</measures>

28
src/importexport/guitarpro/internal/gtp/gpconverter.cpp
View file

@ -40,7 +40,7 @@
#include "libmscore/staff.h"
#include "types/symid.h"
#include "libmscore/tempotext.h"
#include "libmscore/tempochangeranged.h"
#include "libmscore/gradualtempochange.h"
#include "libmscore/tie.h"
#include "libmscore/timesig.h"
#include "libmscore/tremolo.h"
@ -1056,7 +1056,7 @@ void GPConverter::addTempoMap()
};
int measureIdx = 0;
TempoChangeRanged* _lastTempoChangeRanged = nullptr;
GradualTempoChange* _lastGradualTempoChange = nullptr;
int previousTempo = -1;
for (auto m = _score->firstMeasure(); m; m = m->nextMeasure()) {
@ -1074,25 +1074,25 @@ void GPConverter::addTempoMap()
segment->add(tt);
_score->setTempo(tick, tt->tempo());
if (_lastTempoChangeRanged) {
_lastTempoChangeRanged->setTick2(tick);
if (_lastGradualTempoChange) {
_lastGradualTempoChange->setTick2(tick);
if (realTemp > previousTempo) {
_lastTempoChangeRanged->setTempoChangeType(TempoChangeType::Accelerando);
_lastTempoChangeRanged->setBeginText("accel");
_lastGradualTempoChange->setTempoChangeType(GradualTempoChangeType::Accelerando);
_lastGradualTempoChange->setBeginText("accel");
} else {
_lastTempoChangeRanged->setTempoChangeType(TempoChangeType::Rallentando);
_lastTempoChangeRanged->setBeginText("rall");
_lastGradualTempoChange->setTempoChangeType(GradualTempoChangeType::Rallentando);
_lastGradualTempoChange->setBeginText("rall");
}
_score->addElement(_lastTempoChangeRanged);
_lastTempoChangeRanged = nullptr;
_score->addElement(_lastGradualTempoChange);
_lastGradualTempoChange = nullptr;
}
if (tempIt->second.linear) {
TempoChangeRanged* tempoChangeRanged = Factory::createTempoChangeRanged(segment);
tempoChangeRanged->setTick(tick);
tempoChangeRanged->setTrack(0);
_lastTempoChangeRanged = tempoChangeRanged;
GradualTempoChange* tempoChange = Factory::createGradualTempoChange(segment);
tempoChange->setTick(tick);
tempoChange->setTrack(0);
_lastGradualTempoChange = tempoChange;
}
previousTempo = realTemp;

8
src/importexport/musicxml/internal/musicxml/exportxml.cpp
View file

@ -114,7 +114,7 @@
#include "libmscore/textframe.h"
#include "libmscore/instrchange.h"
#include "libmscore/letring.h"
#include "libmscore/tempochangeranged.h"
#include "libmscore/gradualtempochange.h"
#include "libmscore/palmmute.h"
#include "libmscore/whammybar.h"
#include "libmscore/rasgueado.h"
@ -3983,7 +3983,7 @@ static void directionTag(XmlWriter& xml, Attributes& attr, EngravingItem const*
|| el->type() == ElementType::PEDAL || el->type() == ElementType::TEXTLINE
|| el->type() == ElementType::LET_RING || el->type() == ElementType::PALM_MUTE
|| el->type() == ElementType::WHAMMY_BAR || el->type() == ElementType::RASGUEADO
|| el->type() == ElementType::HARMONIC_MARK || el->type() == ElementType::TEMPO_RANGED_CHANGE) {
|| el->type() == ElementType::HARMONIC_MARK || el->type() == ElementType::GRADUAL_TEMPO_CHANGE) {
// handle elements derived from SLine
// find the system containing the first linesegment
const SLine* sl = static_cast<const SLine*>(el);
@ -5743,8 +5743,8 @@ static void spannerStart(ExportMusicXml* exp, track_idx_t strack, track_idx_t et
case ElementType::LET_RING:
exp->textLine(toLetRing(e), sstaff, seg->tick());
break;
case ElementType::TEMPO_RANGED_CHANGE:
exp->textLine(toTempoChangeRanged(e), sstaff, seg->tick());
case ElementType::GRADUAL_TEMPO_CHANGE:
exp->textLine(toGradualTempoChange(e), sstaff, seg->tick());
break;
case ElementType::PALM_MUTE:
exp->textLine(toPalmMute(e), sstaff, seg->tick());

8
src/inspector/CMakeLists.txt
View file

@ -78,8 +78,8 @@ set(MODULE_SRC
${CMAKE_CURRENT_LIST_DIR}/models/general/playback/internal_models/hairpinplaybackmodel.h
${CMAKE_CURRENT_LIST_DIR}/models/general/playback/internal_models/noteplaybackmodel.cpp
${CMAKE_CURRENT_LIST_DIR}/models/general/playback/internal_models/noteplaybackmodel.h
${CMAKE_CURRENT_LIST_DIR}/models/general/playback/internal_models/temporangedchangeplaybackmodel.cpp
${CMAKE_CURRENT_LIST_DIR}/models/general/playback/internal_models/temporangedchangeplaybackmodel.h
${CMAKE_CURRENT_LIST_DIR}/models/general/playback/internal_models/gradualtempochangeplaybackmodel.cpp
${CMAKE_CURRENT_LIST_DIR}/models/general/playback/internal_models/gradualtempochangeplaybackmodel.h
${CMAKE_CURRENT_LIST_DIR}/models/measures/measuressettingsmodel.cpp
${CMAKE_CURRENT_LIST_DIR}/models/measures/measuressettingsmodel.h
${CMAKE_CURRENT_LIST_DIR}/models/score/scoreappearancesettingsmodel.cpp
@ -144,8 +144,8 @@ set(MODULE_SRC
${CMAKE_CURRENT_LIST_DIR}/models/notation/lines/palmmutesettingsmodel.h
${CMAKE_CURRENT_LIST_DIR}/models/notation/lines/textlinesettingsmodel.cpp
${CMAKE_CURRENT_LIST_DIR}/models/notation/lines/textlinesettingsmodel.h
${CMAKE_CURRENT_LIST_DIR}/models/notation/lines/temporangedchangesettingsmodel.cpp
${CMAKE_CURRENT_LIST_DIR}/models/notation/lines/temporangedchangesettingsmodel.h
${CMAKE_CURRENT_LIST_DIR}/models/notation/lines/gradualtempochangesettingsmodel.cpp
${CMAKE_CURRENT_LIST_DIR}/models/notation/lines/gradualtempochangesettingsmodel.h
${CMAKE_CURRENT_LIST_DIR}/models/notation/images/imagesettingsmodel.cpp
${CMAKE_CURRENT_LIST_DIR}/models/notation/images/imagesettingsmodel.h
${CMAKE_CURRENT_LIST_DIR}/models/notation/jumps/jumpsettingsmodel.cpp

4
src/inspector/internal/services/elementrepositoryservice.cpp
View file

@ -99,7 +99,7 @@ QList<mu::engraving::EngravingItem*> ElementRepositoryService::findElementsByTyp
case mu::engraving::ElementType::TEXTLINE:
case mu::engraving::ElementType::SLUR:
case mu::engraving::ElementType::TIE:
case mu::engraving::ElementType::TEMPO_RANGED_CHANGE:
case mu::engraving::ElementType::GRADUAL_TEMPO_CHANGE:
case mu::engraving::ElementType::PALM_MUTE: return findLines(elementType);
default:
QList<mu::engraving::EngravingItem*> resultList;
@ -290,7 +290,7 @@ QList<mu::engraving::EngravingItem*> ElementRepositoryService::findLines(mu::eng
{ mu::engraving::ElementType::TEXTLINE, mu::engraving::ElementType::TEXTLINE_SEGMENT },
{ mu::engraving::ElementType::SLUR, mu::engraving::ElementType::SLUR_SEGMENT },
{ mu::engraving::ElementType::TIE, mu::engraving::ElementType::TIE_SEGMENT },
{ mu::engraving::ElementType::TEMPO_RANGED_CHANGE, mu::engraving::ElementType::TEMPO_RANGED_CHANGE_SEGMENT }
{ mu::engraving::ElementType::GRADUAL_TEMPO_CHANGE, mu::engraving::ElementType::GRADUAL_TEMPO_CHANGE_SEGMENT }
};
QList<mu::engraving::EngravingItem*> resultList;

4
src/inspector/models/abstractinspectormodel.cpp
View file

@ -89,8 +89,8 @@ static const QMap<mu::engraving::ElementType, InspectorModelType> NOTATION_ELEME
{ mu::engraving::ElementType::TUPLET, InspectorModelType::TYPE_TUPLET },
{ mu::engraving::ElementType::TEXTLINE, InspectorModelType::TYPE_TEXT_LINE },
{ mu::engraving::ElementType::TEXTLINE_SEGMENT, InspectorModelType::TYPE_TEXT_LINE },
{ mu::engraving::ElementType::TEMPO_RANGED_CHANGE, InspectorModelType::TYPE_TEMPO_RANGED_CHANGE },
{ mu::engraving::ElementType::TEMPO_RANGED_CHANGE_SEGMENT, InspectorModelType::TYPE_TEMPO_RANGED_CHANGE },
{ mu::engraving::ElementType::GRADUAL_TEMPO_CHANGE, InspectorModelType::TYPE_GRADUAL_TEMPO_CHANGE },
{ mu::engraving::ElementType::GRADUAL_TEMPO_CHANGE_SEGMENT, InspectorModelType::TYPE_GRADUAL_TEMPO_CHANGE },
{ mu::engraving::ElementType::INSTRUMENT_NAME, InspectorModelType::TYPE_INSTRUMENT_NAME }
};

2
src/inspector/models/abstractinspectormodel.h
View file

@ -120,7 +120,7 @@ public:
TYPE_DYNAMIC,
TYPE_TUPLET,
TYPE_TEXT_LINE,
TYPE_TEMPO_RANGED_CHANGE,
TYPE_GRADUAL_TEMPO_CHANGE,
TYPE_INSTRUMENT_NAME
};
Q_ENUM(InspectorModelType)

20
src/inspector/models/general/playback/internal_models/temporangedchangeplaybackmodel.cpp → src/inspector/models/general/playback/internal_models/gradualtempochangeplaybackmodel.cpp
View file

@ -20,33 +20,33 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include "temporangedchangeplaybackmodel.h"
#include "gradualtempochangeplaybackmodel.h"
#include "engraving/types/types.h"
using namespace mu::inspector;
using namespace mu::engraving;
TempoRangedChangePlaybackModel::TempoRangedChangePlaybackModel(QObject* parent, IElementRepositoryService* repository)
: AbstractInspectorModel(parent, repository, ElementType::TEMPO_RANGED_CHANGE)
GradualTempoChangePlaybackModel::GradualTempoChangePlaybackModel(QObject* parent, IElementRepositoryService* repository)
: AbstractInspectorModel(parent, repository, ElementType::GRADUAL_TEMPO_CHANGE)
{
setTitle(qtrc("inspector", "Tempo change"));
setModelType(InspectorModelType::TYPE_TEMPO_RANGED_CHANGE);
setModelType(InspectorModelType::TYPE_GRADUAL_TEMPO_CHANGE);
createProperties();
}
PropertyItem* TempoRangedChangePlaybackModel::tempoChangeFactor() const
PropertyItem* GradualTempoChangePlaybackModel::tempoChangeFactor() const
{
return m_tempoChangeFactor;
}
PropertyItem* TempoRangedChangePlaybackModel::tempoEasingMethod() const
PropertyItem* GradualTempoChangePlaybackModel::tempoEasingMethod() const
{
return m_tempoEasingMethod;
}
QVariantList TempoRangedChangePlaybackModel::possibleEasingMethods() const
QVariantList GradualTempoChangePlaybackModel::possibleEasingMethods() const
{
QVariantList methods {
object(ChangeMethod::NORMAL, qtrc("inspector", "Normal")),
@ -57,7 +57,7 @@ QVariantList TempoRangedChangePlaybackModel::possibleEasingMethods() const
return methods;
}
void TempoRangedChangePlaybackModel::createProperties()
void GradualTempoChangePlaybackModel::createProperties()
{
m_tempoChangeFactor = buildPropertyItem(Pid::TEMPO_CHANGE_FACTOR, [this](const Pid pid, const QVariant& newValue) {
onPropertyValueChanged(pid, newValue.toDouble() / 100);
@ -66,7 +66,7 @@ void TempoRangedChangePlaybackModel::createProperties()
m_tempoEasingMethod = buildPropertyItem(Pid::TEMPO_EASING_METHOD);
}
void TempoRangedChangePlaybackModel::loadProperties()
void GradualTempoChangePlaybackModel::loadProperties()
{
loadPropertyItem(m_tempoChangeFactor, [](const QVariant& elementPropertyValue) -> QVariant {
return static_cast<int>(DataFormatter::roundDouble(elementPropertyValue.toDouble() * 100.0));
@ -75,7 +75,7 @@ void TempoRangedChangePlaybackModel::loadProperties()
loadPropertyItem(m_tempoEasingMethod);
}
void TempoRangedChangePlaybackModel::resetProperties()
void GradualTempoChangePlaybackModel::resetProperties()
{
m_tempoChangeFactor->resetToDefault();
m_tempoEasingMethod->resetToDefault();

10
src/inspector/models/general/playback/internal_models/temporangedchangeplaybackmodel.h → src/inspector/models/general/playback/internal_models/gradualtempochangeplaybackmodel.h
View file

@ -19,13 +19,13 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef MU_INSPECTOR_TEMPORANGEDCHANGEPLAYBACKMODEL_H
#define MU_INSPECTOR_TEMPORANGEDCHANGEPLAYBACKMODEL_H
#ifndef MU_INSPECTOR_GRADUALTEMPOCHANGEPLAYBACKMODEL_H
#define MU_INSPECTOR_GRADUALTEMPOCHANGEPLAYBACKMODEL_H
#include "models/abstractinspectormodel.h"
namespace mu::inspector {
class TempoRangedChangePlaybackModel : public AbstractInspectorModel
class GradualTempoChangePlaybackModel : public AbstractInspectorModel
{
Q_OBJECT
@ -33,7 +33,7 @@ class TempoRangedChangePlaybackModel : public AbstractInspectorModel
Q_PROPERTY(PropertyItem * tempoEasingMethod READ tempoEasingMethod CONSTANT)
public:
explicit TempoRangedChangePlaybackModel(QObject* parent, IElementRepositoryService* repository);
explicit GradualTempoChangePlaybackModel(QObject* parent, IElementRepositoryService* repository);
PropertyItem* tempoChangeFactor() const;
PropertyItem* tempoEasingMethod() const;
@ -51,4 +51,4 @@ private:
};
}
#endif // MU_INSPECTOR_TEMPORANGEDCHANGEPLAYBACKMODEL_H
#endif // MU_INSPECTOR_GRADUALTEMPOCHANGEPLAYBACKMODEL_H

6
src/inspector/models/general/playback/playbackproxymodel.cpp
View file

@ -28,7 +28,7 @@
#include "internal_models/glissandoplaybackmodel.h"
#include "internal_models/dynamicplaybackmodel.h"
#include "internal_models/hairpinplaybackmodel.h"
#include "internal_models/temporangedchangeplaybackmodel.h"
#include "internal_models/gradualtempochangeplaybackmodel.h"
using namespace mu::inspector;
@ -43,7 +43,7 @@ PlaybackProxyModel::PlaybackProxyModel(QObject* parent, IElementRepositoryServic
new GlissandoPlaybackModel(this, repository),
new DynamicPlaybackModel(this, repository),
new HairpinPlaybackModel(this, repository),
new TempoRangedChangePlaybackModel(this, repository)
new GradualTempoChangePlaybackModel(this, repository)
};
setModels(models);
@ -57,7 +57,7 @@ bool PlaybackProxyModel::hasGeneralSettings() const
InspectorModelType::TYPE_FERMATA,
InspectorModelType::TYPE_BREATH,
InspectorModelType::TYPE_GLISSANDO,
InspectorModelType::TYPE_TEMPO_RANGED_CHANGE
InspectorModelType::TYPE_GRADUAL_TEMPO_CHANGE
};
return !isGropEmpty(generalGroup);

6
src/inspector/models/inspectormodelcreator.cpp
View file

@ -48,7 +48,7 @@
#include "notation/lines/palmmutesettingsmodel.h"
#include "notation/lines/vibratosettingsmodel.h"
#include "notation/lines/slurandtiesettingsmodel.h"
#include "notation/lines/temporangedchangesettingsmodel.h"
#include "notation/lines/gradualtempochangesettingsmodel.h"
#include "notation/stafftype/stafftypesettingsmodel.h"
#include "notation/frames/textframesettingsmodel.h"
#include "notation/frames/verticalframesettingsmodel.h"
@ -128,8 +128,8 @@ AbstractInspectorModel* InspectorModelCreator::newInspectorModel(InspectorModelT
return new LetRingSettingsModel(parent, repository);
case InspectorModelType::TYPE_TEXT_LINE:
return new TextLineSettingsModel(parent, repository);
case InspectorModelType::TYPE_TEMPO_RANGED_CHANGE:
return new TempoRangedChangeSettingsModel(parent, repository);
case InspectorModelType::TYPE_GRADUAL_TEMPO_CHANGE:
return new GradualTempoChangeSettingsModel(parent, repository);
case InspectorModelType::TYPE_VIBRATO:
return new VibratoSettingsModel(parent, repository);
case InspectorModelType::TYPE_SLUR:

10
src/inspector/models/notation/lines/temporangedchangesettingsmodel.cpp → src/inspector/models/notation/lines/gradualtempochangesettingsmodel.cpp
View file

@ -20,21 +20,21 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include "temporangedchangesettingsmodel.h"
#include "gradualtempochangesettingsmodel.h"
using namespace mu::inspector;
using namespace mu::engraving;
TempoRangedChangeSettingsModel::TempoRangedChangeSettingsModel(QObject* parent, IElementRepositoryService* repository)
: TextLineSettingsModel(parent, repository, ElementType::TEMPO_RANGED_CHANGE)
GradualTempoChangeSettingsModel::GradualTempoChangeSettingsModel(QObject* parent, IElementRepositoryService* repository)
: TextLineSettingsModel(parent, repository, ElementType::GRADUAL_TEMPO_CHANGE)
{
setModelType(InspectorModelType::TYPE_TEMPO_RANGED_CHANGE);
setModelType(InspectorModelType::TYPE_GRADUAL_TEMPO_CHANGE);
setTitle(qtrc("inspector", "Tempo change"));
createProperties();
}
void TempoRangedChangeSettingsModel::createProperties()
void GradualTempoChangeSettingsModel::createProperties()
{
TextLineSettingsModel::createProperties();

10
src/inspector/models/notation/lines/temporangedchangesettingsmodel.h → src/inspector/models/notation/lines/gradualtempochangesettingsmodel.h
View file

@ -19,22 +19,22 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef MU_INSPECTOR_TEMPORANGEDCHANGESETTINGSMODEL_H
#define MU_INSPECTOR_TEMPORANGEDCHANGESETTINGSMODEL_H
#ifndef MU_INSPECTOR_GRADUALTEMPOCHANGESETTINGSMODEL_H
#define MU_INSPECTOR_GRADUALTEMPOCHANGESETTINGSMODEL_H
#include "textlinesettingsmodel.h"
namespace mu::inspector {
class TempoRangedChangeSettingsModel : public TextLineSettingsModel
class GradualTempoChangeSettingsModel : public TextLineSettingsModel
{
Q_OBJECT
public:
explicit TempoRangedChangeSettingsModel(QObject* parent, IElementRepositoryService* repository);
explicit GradualTempoChangeSettingsModel(QObject* parent, IElementRepositoryService* repository);
private:
void createProperties() override;
};
}
#endif // MU_INSPECTOR_TEMPORANGEDCHANGESETTINGSMODEL_H
#endif // MU_INSPECTOR_GRADUALTEMPOCHANGESETTINGSMODEL_H

2
src/inspector/view/inspector_resources.qrc
View file

@ -21,7 +21,7 @@
<file>qml/MuseScore/Inspector/general/playback/PlaybackDynamicsSettings.qml</file>
<file>qml/MuseScore/Inspector/general/playback/internal/HairpinsExpandableBlank.qml</file>
<file>qml/MuseScore/Inspector/general/playback/internal/ArpeggioExpandableBlank.qml</file>
<file>qml/MuseScore/Inspector/general/playback/internal/TempoRangedChangeBlank.qml</file>
<file>qml/MuseScore/Inspector/general/playback/internal/GradualTempoChangeBlank.qml</file>
<file>qml/MuseScore/Inspector/general/appearance/internal/HorizontalSpacingSection.qml</file>
<file>qml/MuseScore/Inspector/general/appearance/internal/AppearanceOffsetSection.qml</file>
<file>qml/MuseScore/Inspector/general/appearance/internal/ArrangeSection.qml</file>

6
src/inspector/view/qml/MuseScore/Inspector/general/playback/PlaybackGeneralSettings.qml
View file

@ -95,11 +95,13 @@ Item {
model: proxyModel ? proxyModel.modelByType(Inspector.TYPE_GLISSANDO) : null
}
TempoRangedChangeBlank {
SeparatorLine { anchors.margins: -12 }
GradualTempoChangeBlank {
navigation.panel: root.navigationPanel
navigation.row: glissandoSection.navigationRowEnd + 1
model: proxyModel ? proxyModel.modelByType(Inspector.TYPE_TEMPO_RANGED_CHANGE) : null
model: proxyModel ? proxyModel.modelByType(Inspector.TYPE_GRADUAL_TEMPO_CHANGE) : null
}
}
}

0
src/inspector/view/qml/MuseScore/Inspector/general/playback/internal/TempoRangedChangeBlank.qml → src/inspector/view/qml/MuseScore/Inspector/general/playback/internal/GradualTempoChangeBlank.qml
View file

2
src/inspector/view/qml/MuseScore/Inspector/notation/NotationInspectorSectionLoader.qml
View file

@ -104,7 +104,7 @@ Loader {
case Inspector.TYPE_PALM_MUTE:
case Inspector.TYPE_LET_RING:
case Inspector.TYPE_VOLTA:
case Inspector.TYPE_TEMPO_RANGED_CHANGE:
case Inspector.TYPE_GRADUAL_TEMPO_CHANGE:
case Inspector.TYPE_TEXT_LINE: return lineComp
case Inspector.TYPE_STAFF_TYPE_CHANGES: return staffTypeComp
case Inspector.TYPE_TEXT_FRAME: return textFrameComp

4
src/notation/internal/notationinteraction.cpp
View file

@ -1086,7 +1086,7 @@ bool NotationInteraction::isDropAccepted(const PointF& pos, Qt::KeyboardModifier
return dragMeasureAnchorElement(pos);
case ElementType::PEDAL:
case ElementType::LET_RING:
case ElementType::TEMPO_RANGED_CHANGE:
case ElementType::GRADUAL_TEMPO_CHANGE:
case ElementType::VIBRATO:
case ElementType::PALM_MUTE:
case ElementType::OTTAVA:
@ -1192,7 +1192,7 @@ bool NotationInteraction::drop(const PointF& pos, Qt::KeyboardModifiers modifier
case ElementType::TRILL:
case ElementType::PEDAL:
case ElementType::LET_RING:
case ElementType::TEMPO_RANGED_CHANGE:
case ElementType::GRADUAL_TEMPO_CHANGE:
case ElementType::VIBRATO:
case ElementType::PALM_MUTE:
case ElementType::HAIRPIN:

38
src/palette/internal/palettecreator.cpp
View file

@ -55,7 +55,7 @@
#include "libmscore/keysig.h"
#include "libmscore/layoutbreak.h"
#include "libmscore/letring.h"
#include "libmscore/tempochangeranged.h"
#include "libmscore/gradualtempochange.h"
#include "libmscore/marker.h"
#include "libmscore/masterscore.h"
#include "libmscore/measure.h"
@ -1313,29 +1313,29 @@ PalettePtr PaletteCreator::newTempoPalette(bool defaultPalette)
}
}
static const std::map<TempoChangeType, const char*> DEFAULT_TEMPO_CHANGE = {
{ TempoChangeType::Accelerando, QT_TRANSLATE_NOOP("palette", "accel.") },
{ TempoChangeType::Allargando, QT_TRANSLATE_NOOP("palette", "allarg.") },
{ TempoChangeType::Rallentando, QT_TRANSLATE_NOOP("palette", "rall.") },
{ TempoChangeType::Ritardando, QT_TRANSLATE_NOOP("palette", "rit.") },
static const std::map<GradualTempoChangeType, const char*> DEFAULT_TEMPO_CHANGE = {
{ GradualTempoChangeType::Accelerando, QT_TRANSLATE_NOOP("palette", "accel.") },
{ GradualTempoChangeType::Allargando, QT_TRANSLATE_NOOP("palette", "allarg.") },
{ GradualTempoChangeType::Rallentando, QT_TRANSLATE_NOOP("palette", "rall.") },
{ GradualTempoChangeType::Ritardando, QT_TRANSLATE_NOOP("palette", "rit.") },
};
static const std::map<TempoChangeType, const char*> MASTER_TEMPO_CHANGE = {
{ TempoChangeType::Accelerando, QT_TRANSLATE_NOOP("palette", "accel.") },
{ TempoChangeType::Allargando, QT_TRANSLATE_NOOP("palette", "allarg.") },
{ TempoChangeType::Calando, QT_TRANSLATE_NOOP("palette", "calando") },
{ TempoChangeType::Lentando, QT_TRANSLATE_NOOP("palette", "lentando") },
{ TempoChangeType::Morendo, QT_TRANSLATE_NOOP("palette", "morendo") },
{ TempoChangeType::Precipitando, QT_TRANSLATE_NOOP("palette", "precipitando") },
{ TempoChangeType::Rallentando, QT_TRANSLATE_NOOP("palette", "rall.") },
{ TempoChangeType::Ritardando, QT_TRANSLATE_NOOP("palette", "rit.") },
{ TempoChangeType::Smorzando, QT_TRANSLATE_NOOP("palette", "smorz.") },
{ TempoChangeType::Sostenuto, QT_TRANSLATE_NOOP("palette", "sost.") },
{ TempoChangeType::Stringendo, QT_TRANSLATE_NOOP("palette", "string.") }
static const std::map<GradualTempoChangeType, const char*> MASTER_TEMPO_CHANGE = {
{ GradualTempoChangeType::Accelerando, QT_TRANSLATE_NOOP("palette", "accel.") },
{ GradualTempoChangeType::Allargando, QT_TRANSLATE_NOOP("palette", "allarg.") },
{ GradualTempoChangeType::Calando, QT_TRANSLATE_NOOP("palette", "calando") },
{ GradualTempoChangeType::Lentando, QT_TRANSLATE_NOOP("palette", "lentando") },
{ GradualTempoChangeType::Morendo, QT_TRANSLATE_NOOP("palette", "morendo") },
{ GradualTempoChangeType::Precipitando, QT_TRANSLATE_NOOP("palette", "precipitando") },
{ GradualTempoChangeType::Rallentando, QT_TRANSLATE_NOOP("palette", "rall.") },
{ GradualTempoChangeType::Ritardando, QT_TRANSLATE_NOOP("palette", "rit.") },
{ GradualTempoChangeType::Smorzando, QT_TRANSLATE_NOOP("palette", "smorz.") },
{ GradualTempoChangeType::Sostenuto, QT_TRANSLATE_NOOP("palette", "sost.") },
{ GradualTempoChangeType::Stringendo, QT_TRANSLATE_NOOP("palette", "string.") }
};
for (const auto& pair : defaultPalette ? DEFAULT_TEMPO_CHANGE : MASTER_TEMPO_CHANGE) {
auto item = makeElement<TempoChangeRanged>(gpaletteScore);
auto item = makeElement<GradualTempoChange>(gpaletteScore);
item->setTempoChangeType(pair.first);
item->setBeginText(pair.second);
sp->appendElement(item, pair.second, 1.3)->yoffset = 0.4;