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

fix #268110

Browse source
This commit is contained in:
Werner Schweer 2018-01-04 12:41:42 +01:00
parent c68c9455d7
commit f26ebf688f
19 changed files with 172 additions and 166 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
libmscore/barline.cpp
View file

@ -24,6 +24,7 @@
#include "marker.h"
#include "stafflines.h"
#include "spanner.h"
#include "utils.h"
namespace Ms {
@ -499,8 +500,10 @@ void BarLine::read(XmlReader& e)
bool BarLine::acceptDrop(EditData& data) const
{
ElementType type = data.element->type();
if (type == ElementType::BAR_LINE)
if (type == ElementType::BAR_LINE) {
printf("may drop\n");
return true;
}
else {
return (type == ElementType::ARTICULATION
&& segment()
@ -518,6 +521,7 @@ Element* BarLine::drop(EditData& data)
Element* e = data.element;
if (e->isBarLine()) {
printf("drop\n");
BarLine* bl = toBarLine(e);
BarLineType st = bl->barLineType();
@ -559,8 +563,7 @@ Element* BarLine::drop(EditData& data)
// Update repeat flags
//---------------------------------------------
Measure* m = segment()->measure();
score()->undoChangeBarLine(m, st, segment()->segmentType());
undoChangeBarLineType(this, st);
delete e;
return 0;
}
@ -1097,6 +1100,18 @@ bool BarLine::setProperty(P_ID id, const QVariant& v)
return true;
}
//---------------------------------------------------------
// undoChangeProperty
//---------------------------------------------------------
void BarLine::undoChangeProperty(P_ID id, const QVariant& v, PropertyFlags ps)
{
if (id == P_ID::BARLINE_TYPE && segment())
undoChangeBarLineType(this, v.value<BarLineType>());
else
ScoreElement::undoChangeProperty(id, v, ps);
}
//---------------------------------------------------------
// propertyDefault
//---------------------------------------------------------

2
libmscore/barline.h
View file

@ -127,6 +127,8 @@ class BarLine final : public Element {
virtual QVariant getProperty(P_ID propertyId) const override;
virtual bool setProperty(P_ID propertyId, const QVariant&) override;
virtual QVariant propertyDefault(P_ID propertyId) const override;
virtual void undoChangeProperty(P_ID id, const QVariant&, PropertyFlags ps);
using ScoreElement::undoChangeProperty;
static qreal layoutWidth(Score*, BarLineType);

11
libmscore/box.cpp
View file

@ -666,17 +666,6 @@ Element* Box::drop(EditData& data)
e->setParent(this);
score()->undoAddElement(e);
return e;
#if 0
case ElementType::BAR_LINE: {
MeasureBase* mb = next();
if (!mb || !mb->isMeasure()) {
delete e;
return 0;
}
score()->undoChangeBarLine(toMeasure(mb), toBarLine(e)->barLineType(), true);
}
return 0;
#endif
default:
return 0;
}

15
libmscore/cmd.cpp
View file

@ -1380,8 +1380,7 @@ void Score::upDown(bool up, UpDownMode mode)
}
// store the fretting change before undoChangePitch() chooses
// a fretting of its own liking!
undoChangeProperty(oNote, P_ID::FRET, fret);
// undoChangeProperty(oNote, P_ID::STRING, string);
oNote->undoChangeProperty(P_ID::FRET, fret);
}
break;
}
@ -1459,11 +1458,11 @@ void Score::upDown(bool up, UpDownMode mode)
else if (staff->staffType(tick)->group() == StaffGroup::TAB) {
bool refret = false;
if (oNote->string() != string) {
undoChangeProperty(oNote, P_ID::STRING, string);
oNote->undoChangeProperty(P_ID::STRING, string);
refret = true;
}
if (oNote->fret() != fret) {
undoChangeProperty(oNote, P_ID::FRET, fret);
oNote->undoChangeProperty(P_ID::FRET, fret);
refret = true;
}
if (refret) {
@ -1808,11 +1807,11 @@ void Score::cmdResetBeamMode()
continue;
if (cr->type() == ElementType::CHORD) {
if (cr->beamMode() != Beam::Mode::AUTO)
undoChangeProperty(cr, P_ID::BEAM_MODE, int(Beam::Mode::AUTO));
cr->undoChangeProperty(P_ID::BEAM_MODE, int(Beam::Mode::AUTO));
}
else if (cr->type() == ElementType::REST) {
if (cr->beamMode() != Beam::Mode::NONE)
undoChangeProperty(cr, P_ID::BEAM_MODE, int(Beam::Mode::NONE));
cr->undoChangeProperty(P_ID::BEAM_MODE, int(Beam::Mode::NONE));
}
}
}
@ -2225,7 +2224,7 @@ void Score::cmdMirrorNoteHead()
if (e->type() == ElementType::NOTE) {
Note* note = toNote(e);
if (note->staff() && note->staff()->isTabStaff(note->chord()->tick()))
note->score()->undoChangeProperty(e, P_ID::GHOST, !note->ghost());
e->undoChangeProperty(P_ID::GHOST, !note->ghost());
else {
MScore::DirectionH d = note->userMirror();
if (d == MScore::DirectionH::AUTO)
@ -2310,7 +2309,7 @@ void Score::cmdMoveRest(Rest* rest, Direction dir)
pos.ry() -= spatium();
else if (dir == Direction::DOWN)
pos.ry() += spatium();
undoChangeProperty(rest, P_ID::USER_OFF, pos);
rest->undoChangeProperty(P_ID::USER_OFF, pos);
}
//---------------------------------------------------------

132
libmscore/edit.cpp
View file

@ -571,7 +571,7 @@ bool Score::rewriteMeasures(Measure* fm, const Fraction& ns, int staffIdx)
if (m->first(SegmentType::TimeSig))
break;
Fraction fr(ns);
undoChangeProperty(m, P_ID::TIMESIG_NOMINAL, QVariant::fromValue(fr));
m->undoChangeProperty(P_ID::TIMESIG_NOMINAL, QVariant::fromValue(fr));
}
return false;
}
@ -715,9 +715,9 @@ void Score::cmdAddTimeSig(Measure* fm, int staffIdx, TimeSig* ts, bool local)
Measure* fm = score->tick2measure(tick);
for (Measure* m = fm; m != lm; m = m->nextMeasure()) {
bool changeActual = m->len() == m->timesig();
undoChangeProperty(m, P_ID::TIMESIG_NOMINAL, QVariant::fromValue(ns));
m->undoChangeProperty(P_ID::TIMESIG_NOMINAL, QVariant::fromValue(ns));
if (changeActual)
undoChangeProperty(m, P_ID::TIMESIG_ACTUAL, QVariant::fromValue(ns));
m->undoChangeProperty(P_ID::TIMESIG_ACTUAL, QVariant::fromValue(ns));
}
}
int n = nstaves();
@ -738,7 +738,7 @@ void Score::cmdAddTimeSig(Measure* fm, int staffIdx, TimeSig* ts, bool local)
//
if (fm == score->firstMeasure() && fm->nextMeasure() && (fm->len() != fm->timesig())) {
// handle upbeat
undoChangeProperty(fm, P_ID::TIMESIG_NOMINAL, QVariant::fromValue(ns));
fm->undoChangeProperty(P_ID::TIMESIG_NOMINAL, QVariant::fromValue(ns));
Measure* m = fm->nextMeasure();
Segment* s = m->findSegment(SegmentType::TimeSig, m->tick());
fm = s ? 0 : fm->nextMeasure();
@ -1198,7 +1198,7 @@ void Score::cmdSetBeamMode(Beam::Mode mode)
{
for (ChordRest* cr : getSelectedChordRests()) {
if (cr)
undoChangeProperty(cr, P_ID::BEAM_MODE, int(mode));
cr->undoChangeProperty(P_ID::BEAM_MODE, int(mode));
}
}
@ -1229,19 +1229,19 @@ void Score::cmdFlip()
continue;
else {
Direction dir = chord->up() ? Direction::DOWN : Direction::UP;
undoChangeProperty(chord, P_ID::STEM_DIRECTION, QVariant::fromValue<Direction>(dir));
chord->undoChangeProperty(P_ID::STEM_DIRECTION, QVariant::fromValue<Direction>(dir));
}
}
else if (e->isBeam()) {
Beam* beam = toBeam(e);
Direction dir = beam->up() ? Direction::DOWN : Direction::UP;
undoChangeProperty(beam, P_ID::STEM_DIRECTION, QVariant::fromValue<Direction>(dir));
beam->undoChangeProperty(P_ID::STEM_DIRECTION, QVariant::fromValue<Direction>(dir));
}
else if (e->isSlurTieSegment()) {
SlurTie* slur = toSlurTieSegment(e)->slurTie();
Direction dir = slur->up() ? Direction::DOWN : Direction::UP;
undoChangeProperty(slur, P_ID::SLUR_DIRECTION, QVariant::fromValue<Direction>(dir));
slur->undoChangeProperty(P_ID::SLUR_DIRECTION, QVariant::fromValue<Direction>(dir));
}
else if (e->isHairpinSegment()) {
Hairpin* h = toHairpinSegment(e)->hairpin();
@ -1252,7 +1252,7 @@ void Score::cmdFlip()
case HairpinType::CRESC_LINE: st = HairpinType::DECRESC_LINE; break;
case HairpinType::DECRESC_LINE: st = HairpinType::CRESC_LINE; break;
}
undoChangeProperty(h, P_ID::HAIRPIN_TYPE, int(st));
h->undoChangeProperty(P_ID::HAIRPIN_TYPE, int(st));
}
else if (e->isArticulation()) {
Articulation* a = toArticulation(e);
@ -1274,18 +1274,18 @@ void Score::cmdFlip()
aa = ArticulationAnchor::TOP_STAFF;
break;
}
// undoChangeProperty(a, P_ID::DIRECTION, a->up() ? Direction::DOWN : Direction::UP);
undoChangeProperty(a, P_ID::ARTICULATION_ANCHOR, int(aa));
// a->undoChangeProperty(P_ID::DIRECTION, a->up() ? Direction::DOWN : Direction::UP);
a->undoChangeProperty(P_ID::ARTICULATION_ANCHOR, int(aa));
}
else if (e->isTuplet()) {
Tuplet* tuplet = toTuplet(e);
Direction d = tuplet->isUp() ? Direction::DOWN : Direction::UP;
undoChangeProperty(tuplet, P_ID::DIRECTION, QVariant::fromValue<Direction>(d));
tuplet->undoChangeProperty(P_ID::DIRECTION, QVariant::fromValue<Direction>(d));
}
else if (e->isNoteDot()) {
Note* note = toNote(e->parent());
Direction d = note->dotIsUp() ? Direction::DOWN : Direction::UP;
undoChangeProperty(note, P_ID::DOT_POSITION, QVariant::fromValue<Direction>(d));
note->undoChangeProperty(P_ID::DOT_POSITION, QVariant::fromValue<Direction>(d));
}
else if (e->isTempoText()
|| e->isStaffText()
@ -1653,7 +1653,7 @@ void Score::deleteItem(Element* el)
case ElementType::TEXT:
if (el->parent()->isTBox())
undoChangeProperty(el, P_ID::TEXT, QString());
el->undoChangeProperty(P_ID::TEXT, QString());
else
undoRemoveElement(el);
break;
@ -2287,7 +2287,7 @@ void Score::colorItem(Element* element)
foreach(Element* e, selection().elements()) {
if (e->color() != c) {
undoChangeProperty(e, P_ID::COLOR, c);
e->undoChangeProperty(P_ID::COLOR, c);
e->setGenerated(false);
addRefresh(e->abbox());
if (e->isBarLine()) {
@ -3090,24 +3090,6 @@ void Score::cloneVoice(int strack, int dtrack, Segment* sf, int lTick, bool link
//TODO ?? doLayoutRange(start, lTick);
}
//---------------------------------------------------------
// undoChangeProperty
//---------------------------------------------------------
void Score::undoChangeProperty(ScoreElement* e, P_ID t, const QVariant& st, PropertyFlags ps)
{
if (propertyLink(t)) {
for (ScoreElement* ee : e->linkList()) {
if (ee->getProperty(t) != st || ee->propertyFlags(t) != ps)
undo(new ChangeProperty(ee, t, st, ps));
}
}
else {
if (e->getProperty(t) != st || e->propertyFlags(t) != ps)
undo(new ChangeProperty(e, t, st, ps));
}
}
//---------------------------------------------------------
// undoPropertyChanged
//---------------------------------------------------------
@ -3628,7 +3610,7 @@ void Score::undoInsertStaff(Staff* staff, int ridx, bool createRests)
void Score::undoChangeInvisible(Element* e, bool v)
{
undoChangeProperty(e, P_ID::VISIBLE, v);
e->undoChangeProperty(P_ID::VISIBLE, v);
e->setGenerated(false);
}
@ -4301,12 +4283,12 @@ void Score::undoRemoveElement(Element* element)
void Score::undoChangeTuning(Note* n, qreal v)
{
undoChangeProperty(n, P_ID::TUNING, v);
n->undoChangeProperty(P_ID::TUNING, v);
}
void Score::undoChangeUserMirror(Note* n, MScore::DirectionH d)
{
undoChangeProperty(n, P_ID::MIRROR_HEAD, int(d));
n->undoChangeProperty(P_ID::MIRROR_HEAD, int(d));
}
//---------------------------------------------------------
@ -4390,7 +4372,7 @@ void Score::undoInsertTime(int tick, int len)
// +----spanner--------+
// +---add---
//
undoChangeProperty(s, P_ID::SPANNER_TICKS, s->ticks() + len);
s->undoChangeProperty(P_ID::SPANNER_TICKS, s->ticks() + len);
}
else if (tick <= s->tick()) {
//
@ -4400,7 +4382,7 @@ void Score::undoInsertTime(int tick, int len)
// and
// +----spanner--------
// +---add---+
undoChangeProperty(s, P_ID::SPANNER_TICK, s->tick() + len);
s->undoChangeProperty(P_ID::SPANNER_TICK, s->tick() + len);
}
}
else {
@ -4413,7 +4395,7 @@ void Score::undoInsertTime(int tick, int len)
int t = s->tick() + len;
if (t < 0)
t = 0;
undoChangeProperty(s, P_ID::SPANNER_TICK, t);
s->undoChangeProperty(P_ID::SPANNER_TICK, t);
}
else if ((s->tick() < tick) && (s->tick2() > tick2)) {
//
@ -4423,7 +4405,7 @@ void Score::undoInsertTime(int tick, int len)
//
int t2 = s->tick2() + len;
if (t2 > s->tick()) {
undoChangeProperty(s, P_ID::SPANNER_TICKS, s->ticks() + len);
s->undoChangeProperty(P_ID::SPANNER_TICKS, s->ticks() + len);
}
}
// else if (s->tick() >= tick && s->tick2() < tick2) {
@ -4448,8 +4430,8 @@ void Score::undoInsertTime(int tick, int len)
undoRemoveElement(s);
}
else {
undoChangeProperty(s, P_ID::SPANNER_TICK, s->tick() - d1);
undoChangeProperty(s, P_ID::SPANNER_TICKS, len);
s->undoChangeProperty(P_ID::SPANNER_TICK, s->tick() - d1);
s->undoChangeProperty(P_ID::SPANNER_TICKS, len);
}
}
}
@ -4493,70 +4475,4 @@ void Score::undoRemoveMeasures(Measure* m1, Measure* m2)
undo(new RemoveMeasures(m1, m2));
}
//---------------------------------------------------------
// undoChangeBarLine
//---------------------------------------------------------
void Score::undoChangeBarLine(Measure* measure, BarLineType barType, SegmentType segmentType)
{
int tick = measure->tick();
for (Score* s : scoreList()) {
Measure* m = s->tick2measure(tick);
// Measure* nm = m->nextMeasure();
switch (barType) {
case BarLineType::END:
case BarLineType::NORMAL:
case BarLineType::DOUBLE:
case BarLineType::BROKEN:
case BarLineType::DOTTED: {
Segment* segment;
if (segmentType == SegmentType::EndBarLine) {
s->undoChangeProperty(m, P_ID::REPEAT_END, false);
// if (nm)
// s->undoChangeProperty(nm, P_ID::REPEAT_START, false);
segment = m->findSegment(SegmentType::EndBarLine, m->endTick());
if (segment) {
for (Element* e : segment->elist()) {
if (e) {
e->undoChangeProperty(P_ID::BARLINE_TYPE, QVariant::fromValue(barType));
e->undoChangeProperty(P_ID::GENERATED, false);
}
}
}
}
else if (segmentType == SegmentType::BeginBarLine) {
segment = m->undoGetSegment(SegmentType::BeginBarLine, tick);
for (Element* e : segment->elist()) {
if (e) {
e->undoChangeProperty(P_ID::BARLINE_TYPE, QVariant::fromValue(barType));
e->undoChangeProperty(P_ID::GENERATED, false);
}
else {
BarLine* bl = new BarLine(s);
bl->setBarLineType(barType);
bl->setParent(segment);
bl->setTrack(0);
bl->setSpanStaff(s->nstaves());
undo(new AddElement(bl));
}
}
}
else if (segmentType == SegmentType::StartRepeatBarLine) {
s->undoChangeProperty(m, P_ID::REPEAT_START, false);
}
}
break;
case BarLineType::START_REPEAT:
s->undoChangeProperty(m, P_ID::REPEAT_START, true);
break;
case BarLineType::END_REPEAT:
s->undoChangeProperty(m, P_ID::REPEAT_END, true);
break;
}
}
}
}

3
libmscore/element.h
View file

@ -367,9 +367,6 @@ class Element : public ScoreElement {
qreal magS() const;
bool isPrintable() const;
// virtual bool isSpanner() const { return false; }
// virtual bool isSpannerSegment() const { return false; }
qreal point(const Spatium sp) const { return sp.val() * spatium(); }
virtual int tick() const; // utility, searches for segment / segment parent

4
libmscore/layout.cpp
View file

@ -1735,8 +1735,8 @@ void Score::createMMRest(Measure* m, Measure* lm, const Fraction& len)
BarLine* bd = toBarLine(ds->element(staffIdx * VOICES));
BarLine* bs = toBarLine(e);
if (bd->barLineType() != bs->barLineType()) {
undoChangeProperty(bd, P_ID::BARLINE_TYPE, QVariant::fromValue(bs->barLineType()));
undoChangeProperty(bd, P_ID::GENERATED, true);
bd->undoChangeProperty(P_ID::BARLINE_TYPE, QVariant::fromValue(bs->barLineType()));
bd->undoChangeProperty(P_ID::GENERATED, true);
}
}
}

17
libmscore/measure.cpp
View file

@ -1484,15 +1484,24 @@ Element* Measure::drop(EditData& data)
// or if Ctrl key used
if ((bl->spanFrom() && bl->spanTo()) || data.control()) {
// get existing bar line for this staff, and drop the change to it
Segment* seg = undoGetSegment(SegmentType::EndBarLine, tick() + ticks());
Segment* seg = undoGetSegmentR(SegmentType::EndBarLine, ticks());
BarLine* cbl = toBarLine(seg->element(staffIdx * VOICES));
if (cbl)
cbl->drop(data);
}
else {
// if dropped bar line refers to line subtype
score()->undoChangeBarLine(this, bl->barLineType(), SegmentType::EndBarLine);
delete e;
// drop to first end barline
Segment* seg = findSegmentR(SegmentType::EndBarLine, ticks());
if (seg) {
for (Element* ee : seg->elist()) {
if (ee) {
ee->drop(data);
break;
}
}
}
else
delete e;
}
break;
}

4
libmscore/score.h
View file

@ -619,7 +619,7 @@ class Score : public QObject, ScoreElement {
void undoChangeUserMirror(Note*, MScore::DirectionH);
void undoChangeKeySig(Staff* ostaff, int tick, KeySigEvent);
void undoChangeClef(Staff* ostaff, Segment*, ClefType st);
void undoChangeProperty(ScoreElement*, P_ID, const QVariant&, PropertyFlags ps = PropertyFlags::NOSTYLE);
// void undoChangeProperty(ScoreElement*, P_ID, const QVariant&, PropertyFlags ps = PropertyFlags::NOSTYLE);
void undoPropertyChanged(Element*, P_ID, const QVariant& v);
void undoPropertyChanged(ScoreElement*, P_ID, const QVariant& v);
inline virtual UndoStack* undoStack() const;
@ -628,7 +628,7 @@ class Score : public QObject, ScoreElement {
void undoAddBracket(Staff* staff, int level, BracketType type, int span);
void undoRemoveBracket(Bracket*);
void undoInsertTime(int tick, int len);
void undoChangeBarLine(Measure*, BarLineType, SegmentType type);
// void undoChangeBarLine(Measure*, BarLineType, SegmentType type);
void undoChangeStyleVal(StyleIdx idx, const QVariant& v);
Note* setGraceNote(Chord*, int pitch, NoteType type, int len);

30
libmscore/scoreElement.cpp
View file

@ -33,8 +33,8 @@ static const ElementName elementNames[] = {
{ ElementType::INSTRUMENT_NAME, "InstrumentName", QT_TRANSLATE_NOOP("elementName", "Instrument Name") },
{ ElementType::SLUR_SEGMENT, "SlurSegment", QT_TRANSLATE_NOOP("elementName", "Slur Segment") },
{ ElementType::TIE_SEGMENT, "TieSegment", QT_TRANSLATE_NOOP("elementName", "Tie Segment") },
{ ElementType::STAFF_LINES, "StaffLines", QT_TRANSLATE_NOOP("elementName", "Staff Lines") },
{ ElementType::BAR_LINE, "BarLine", QT_TRANSLATE_NOOP("elementName", "Barline") },
{ ElementType::STAFF_LINES, "StaffLines", QT_TRANSLATE_NOOP("elementName", "Staff Lines") },
{ ElementType::SYSTEM_DIVIDER, "SystemDivider", QT_TRANSLATE_NOOP("elementName", "System Divider") },
{ ElementType::STEM_SLASH, "StemSlash", QT_TRANSLATE_NOOP("elementName", "Stem Slash") },
{ ElementType::ARPEGGIO, "Arpeggio", QT_TRANSLATE_NOOP("elementName", "Arpeggio") },
@ -181,6 +181,24 @@ void ScoreElement::undoResetProperty(P_ID id)
undoChangeProperty(id, propertyDefault(id), f);
}
//---------------------------------------------------------
// changeProperties
//---------------------------------------------------------
static void changeProperties(ScoreElement* e, P_ID t, const QVariant& st, PropertyFlags ps)
{
if (propertyLink(t)) {
for (ScoreElement* ee : e->linkList()) {
if (ee->getProperty(t) != st || ee->propertyFlags(t) != ps)
ee->score()->undo(new ChangeProperty(ee, t, st, ps));
}
}
else {
if (e->getProperty(t) != st || e->propertyFlags(t) != ps)
e->score()->undo(new ChangeProperty(e, t, st, ps));
}
}
//---------------------------------------------------------
// undoChangeProperty
//---------------------------------------------------------
@ -218,9 +236,9 @@ void ScoreElement::undoChangeProperty(P_ID id, const QVariant& v, PropertyFlags
auto l = subStyle(SubStyle(v.toInt()));
// Change to SubStyle defaults
for (const StyledProperty& p : l)
score()->undoChangeProperty(this, p.propertyIdx, score()->styleV(p.styleIdx), PropertyFlags::STYLED);
changeProperties(this, p.propertyIdx, score()->styleV(p.styleIdx), PropertyFlags::STYLED);
}
score()->undoChangeProperty(this, id, v, ps);
changeProperties(this, id, v, ps);
}
//---------------------------------------------------------
@ -313,10 +331,10 @@ void ScoreElement::undoUnlink()
QList<ScoreElement*> ScoreElement::linkList() const
{
QList<ScoreElement*> el;
if (links())
el.append(*links());
if (_links)
el.append(*_links);
else
el.append((Element*)this);
el.append(const_cast<ScoreElement*>(this));
return el;
}

2
libmscore/scoreElement.h
View file

@ -192,7 +192,7 @@ class ScoreElement {
virtual StyleIdx getPropertyStyle(P_ID) const;
void undoChangeProperty(P_ID id, const QVariant&, PropertyFlags ps);
virtual void undoChangeProperty(P_ID id, const QVariant&, PropertyFlags ps);
void undoChangeProperty(P_ID id, const QVariant&);
void undoResetProperty(P_ID id);

8
libmscore/stringdata.cpp
View file

@ -202,9 +202,9 @@ void StringData::fretChords(Chord * chord) const
note->setFretConflict(true);
// store fretting change without affecting chord context
if (nFret != nNewFret)
note->score()->undoChangeProperty(note, P_ID::FRET, nNewFret);
note->undoChangeProperty(P_ID::FRET, nNewFret);
if (nString != nNewString)
note->score()->undoChangeProperty(note, P_ID::STRING, nNewString);
note->undoChangeProperty(P_ID::STRING, nNewString);
continue;
}
// note can be fretted: use string
@ -232,9 +232,9 @@ void StringData::fretChords(Chord * chord) const
// if fretting did change, store as a fret change
if (nFret != nNewFret)
note->score()->undoChangeProperty(note, P_ID::FRET, nNewFret);
note->undoChangeProperty(P_ID::FRET, nNewFret);
if (nString != nNewString)
note->score()->undoChangeProperty(note, P_ID::STRING, nNewString);
note->undoChangeProperty(P_ID::STRING, nNewString);
}
// check for any remaining fret conflict

2
libmscore/types.h
View file

@ -33,8 +33,8 @@ enum class ElementType {
INSTRUMENT_NAME,
SLUR_SEGMENT,
TIE_SEGMENT,
STAFF_LINES,
BAR_LINE,
STAFF_LINES,
SYSTEM_DIVIDER,
STEM_SLASH,
ARPEGGIO,

58
libmscore/utils.cpp
View file

@ -28,6 +28,8 @@
#include "sig.h"
#include "tuplet.h"
#include "sym.h"
#include "barline.h"
#include "undo.h"
namespace Ms {
@ -1024,5 +1026,61 @@ std::vector<SymId> toTimeSigString(const QString& s)
return d;
}
//---------------------------------------------------------
// undoChangeBarLineType
//---------------------------------------------------------
void undoChangeBarLineType(BarLine* bl, BarLineType barType)
{
Measure* m = bl->measure();
switch (barType) {
case BarLineType::END:
case BarLineType::NORMAL:
case BarLineType::DOUBLE:
case BarLineType::BROKEN:
case BarLineType::DOTTED: {
SegmentType segmentType = bl->segment()->segmentType();
if (segmentType == SegmentType::EndBarLine) {
m->undoChangeProperty(P_ID::REPEAT_END, false);
Segment* segment = m->findSegmentR(SegmentType::EndBarLine, m->ticks());
if (segment) {
for (Element* e : segment->elist()) {
if (e) {
e->score()->undo(new ChangeProperty(e, P_ID::BARLINE_TYPE, QVariant::fromValue(barType), PropertyFlags::NOSTYLE));
e->score()->undo(new ChangeProperty(e, P_ID::GENERATED, false, PropertyFlags::NOSTYLE));
}
}
}
}
else if (segmentType == SegmentType::BeginBarLine) {
Segment* segment = m->undoGetSegmentR(SegmentType::BeginBarLine, 0);
for (Element* e : segment->elist()) {
if (e) {
e->score()->undo(new ChangeProperty(e, P_ID::BARLINE_TYPE, QVariant::fromValue(barType), PropertyFlags::NOSTYLE));
e->score()->undo(new ChangeProperty(e, P_ID::GENERATED, false, PropertyFlags::NOSTYLE));
}
else {
BarLine* bl = new BarLine(bl->score());
bl->setBarLineType(barType);
bl->setParent(segment);
bl->setTrack(0);
bl->setSpanStaff(bl->score()->nstaves());
bl->score()->undo(new AddElement(bl));
}
}
}
else if (segmentType == SegmentType::StartRepeatBarLine)
m->undoChangeProperty(P_ID::REPEAT_START, false);
}
break;
case BarLineType::START_REPEAT:
m->undoChangeProperty(P_ID::REPEAT_START, true);
break;
case BarLineType::END_REPEAT:
m->undoChangeProperty(P_ID::REPEAT_END, true);
break;
}
}
}

3
libmscore/utils.h
View file

@ -39,6 +39,7 @@ class System;
class Element;
class Note;
class Tuplet;
class BarLine;
enum class ClefType : signed char;
@ -85,6 +86,8 @@ extern int step2pitch(int step);
extern Segment* skipTuplet(Tuplet* tuplet);
extern std::vector<SymId> toTimeSigString(const QString&);
extern void undoChangeBarLineType(BarLine* bl, BarLineType barType);
} // namespace Ms
#endif

8
mscore/dragdrop.cpp
View file

@ -41,24 +41,20 @@ void ScoreView::setDropTarget(const Element* el)
if (dropTarget != el) {
if (dropTarget) {
dropTarget->setDropTarget(false);
// _score->addRefresh(dropTarget->canvasBoundingRect());
dropTarget = 0;
}
dropTarget = el;
if (dropTarget) {
dropTarget->setDropTarget(true);
// _score->addRefresh(dropTarget->canvasBoundingRect());
}
}
if (!dropAnchor.isNull()) {
QRectF r;
r.setTopLeft(dropAnchor.p1());
r.setBottomRight(dropAnchor.p2());
// _score->addRefresh(r.normalized());
dropAnchor = QLineF();
}
if (dropRectangle.isValid()) {
// _score->addRefresh(dropRectangle);
dropRectangle = QRectF();
}
update();
@ -369,6 +365,10 @@ void ScoreView::dragMoveEvent(QDragMoveEvent* event)
case ElementType::FRET_DIAGRAM:
case ElementType::STAFFTYPE_CHANGE: {
QList<Element*> el = elementsAt(pos);
printf("elements at\n");
for (Element* e : el)
printf(" %s\n", e->name());
bool found = false;
setDropTarget(0);
for (const Element* e : el) {

8
mscore/mixer.cpp
View file

@ -164,16 +164,16 @@ void PartEdit::playbackVoiceChanged()
switch (voice) {
case 0:
printf("undo\n");
score->undoChangeProperty(staff, P_ID::PLAYBACK_VOICE1, val);
staff->undoChangeProperty(P_ID::PLAYBACK_VOICE1, val);
break;
case 1:
score->undoChangeProperty(staff, P_ID::PLAYBACK_VOICE2, val);
staff->undoChangeProperty(P_ID::PLAYBACK_VOICE2, val);
break;
case 2:
score->undoChangeProperty(staff, P_ID::PLAYBACK_VOICE3, val);
staff->undoChangeProperty(P_ID::PLAYBACK_VOICE3, val);
break;
case 3:
score->undoChangeProperty(staff, P_ID::PLAYBACK_VOICE4, val);
staff->undoChangeProperty(P_ID::PLAYBACK_VOICE4, val);
break;
}
}

6
mscore/propertymenu.cpp
View file

@ -399,10 +399,10 @@ void ScoreView::elementPropertyAction(const QString& cmd, Element* e)
delete r;
}
else if (cmd == "smallNote")
score()->undoChangeProperty(e, P_ID::SMALL, !static_cast<Note*>(e)->small());
e->undoChangeProperty(P_ID::SMALL, !static_cast<Note*>(e)->small());
else if (cmd == "clef-courtesy") {
bool show = !static_cast<Clef*>(e)->showCourtesy();
score()->undoChangeProperty(e, P_ID::SHOW_COURTESY, show);
e->undoChangeProperty(P_ID::SHOW_COURTESY, show);
}
else if (cmd == "st-props") {
StaffTextProperties rp(static_cast<StaffText*>(e));
@ -486,7 +486,7 @@ void ScoreView::elementPropertyAction(const QString& cmd, Element* e)
nlb->setStartWithLongNames(sbp.startWithLongNames());
nlb->setStartWithMeasureOne(sbp.startWithMeasureOne());
// propagate in parts
score()->undoChangeProperty(lb, P_ID::PAUSE, sbp.pause());
lb->undoChangeProperty(P_ID::PAUSE, sbp.pause());
score()->undoChangeElement(lb, nlb);
}
}

4
mscore/scoreview.cpp
View file

@ -3283,8 +3283,8 @@ void ScoreView::cmdChangeEnharmonic(bool both)
int string = n->line() + (both ? 1 : -1);
int fret = staff->part()->instrument()->stringData()->fret(n->pitch(), string, staff, n->chord()->tick());
if (fret != -1) {
score()->undoChangeProperty(n, P_ID::FRET, fret);
score()->undoChangeProperty(n, P_ID::STRING, string);
n->undoChangeProperty(P_ID::FRET, fret);
n->undoChangeProperty(P_ID::STRING, string);
}
}
else {