4408 lines
166 KiB
C++
4408 lines
166 KiB
C++
//=============================================================================
|
||
// MuseScore
|
||
// Music Composition & Notation
|
||
//
|
||
// Copyright (C) 2002-2016 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 most part of class Measure.
|
||
*/
|
||
|
||
#include "log.h"
|
||
|
||
#include "measure.h"
|
||
#include "accidental.h"
|
||
#include "ambitus.h"
|
||
#include "articulation.h"
|
||
#include "barline.h"
|
||
#include "beam.h"
|
||
#include "box.h"
|
||
#include "bracket.h"
|
||
#include "breath.h"
|
||
#include "chord.h"
|
||
#include "clef.h"
|
||
#include "drumset.h"
|
||
#include "duration.h"
|
||
#include "dynamic.h"
|
||
#include "fermata.h"
|
||
#include "fret.h"
|
||
#include "glissando.h"
|
||
#include "hairpin.h"
|
||
#include "harmony.h"
|
||
#include "hook.h"
|
||
#include "icon.h"
|
||
#include "image.h"
|
||
#include "key.h"
|
||
#include "keysig.h"
|
||
#include "layoutbreak.h"
|
||
#include "layout.h"
|
||
#include "note.h"
|
||
#include "ottava.h"
|
||
#include "page.h"
|
||
#include "part.h"
|
||
#include "pedal.h"
|
||
#include "pitchspelling.h"
|
||
#include "repeat.h"
|
||
#include "rest.h"
|
||
#include "score.h"
|
||
#include "segment.h"
|
||
#include "select.h"
|
||
#include "sig.h"
|
||
#include "slur.h"
|
||
#include "spacer.h"
|
||
#include "staff.h"
|
||
#include "stafftext.h"
|
||
#include "stafftype.h"
|
||
#include "stringdata.h"
|
||
#include "style.h"
|
||
#include "sym.h"
|
||
#include "system.h"
|
||
#include "tempotext.h"
|
||
#include "measurenumber.h"
|
||
#include "tie.h"
|
||
#include "tiemap.h"
|
||
#include "timesig.h"
|
||
#include "tremolo.h"
|
||
#include "trill.h"
|
||
#include "tuplet.h"
|
||
#include "tupletmap.h"
|
||
#include "undo.h"
|
||
#include "utils.h"
|
||
#include "volta.h"
|
||
#include "xml.h"
|
||
#include "systemdivider.h"
|
||
#include "stafftypechange.h"
|
||
#include "stafflines.h"
|
||
#include "bracketItem.h"
|
||
|
||
namespace Ms {
|
||
|
||
//---------------------------------------------------------
|
||
// MStaff
|
||
/// Per staff values of measure.
|
||
//---------------------------------------------------------
|
||
|
||
class MStaff {
|
||
MeasureNumber* _noText { 0 }; ///< Measure number text object
|
||
StaffLines* _lines { 0 };
|
||
Spacer* _vspacerUp { 0 };
|
||
Spacer* _vspacerDown { 0 };
|
||
bool _hasVoices { false }; ///< indicates that MStaff contains more than one voice,
|
||
///< this changes some layout rules
|
||
bool _visible { true };
|
||
bool _stemless { false };
|
||
#ifndef NDEBUG
|
||
bool _corrupted { false };
|
||
#endif
|
||
|
||
public:
|
||
MStaff() {}
|
||
~MStaff();
|
||
MStaff(const MStaff&);
|
||
|
||
void setScore(Score*);
|
||
void setTrack(int);
|
||
|
||
MeasureNumber* noText() const { return _noText; }
|
||
void setNoText(MeasureNumber* t) { _noText = t; }
|
||
|
||
StaffLines* lines() const { return _lines; }
|
||
void setLines(StaffLines* l) { _lines = l; }
|
||
|
||
Spacer* vspacerUp() const { return _vspacerUp; }
|
||
void setVspacerUp(Spacer* s) { _vspacerUp = s; }
|
||
Spacer* vspacerDown() const { return _vspacerDown; }
|
||
void setVspacerDown(Spacer* s) { _vspacerDown = s; }
|
||
|
||
bool hasVoices() const { return _hasVoices; }
|
||
void setHasVoices(bool val) { _hasVoices = val; }
|
||
|
||
bool visible() const { return _visible; }
|
||
void setVisible(bool val) { _visible = val; }
|
||
|
||
bool stemless() const { return _stemless; }
|
||
void setStemless(bool val) { _stemless = val; }
|
||
|
||
#ifndef NDEBUG
|
||
bool corrupted() const { return _corrupted; }
|
||
void setCorrupted(bool val) { _corrupted = val; }
|
||
#endif
|
||
};
|
||
|
||
MStaff::~MStaff()
|
||
{
|
||
delete _noText;
|
||
delete _lines;
|
||
delete _vspacerUp;
|
||
delete _vspacerDown;
|
||
}
|
||
|
||
MStaff::MStaff(const MStaff& m)
|
||
{
|
||
_noText = 0;
|
||
_lines = new StaffLines(*m._lines);
|
||
_hasVoices = m._hasVoices;
|
||
_vspacerUp = 0;
|
||
_vspacerDown = 0;
|
||
_visible = m._visible;
|
||
_stemless = m._stemless;
|
||
#ifndef NDEBUG
|
||
_corrupted = m._corrupted;
|
||
#endif
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// MStaff::setScore
|
||
//---------------------------------------------------------
|
||
|
||
void MStaff::setScore(Score* score)
|
||
{
|
||
if (_lines)
|
||
_lines->setScore(score);
|
||
if (_vspacerUp)
|
||
_vspacerUp->setScore(score);
|
||
if (_vspacerDown)
|
||
_vspacerDown->setScore(score);
|
||
if (_noText)
|
||
_noText->setScore(score);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// setTrack
|
||
//---------------------------------------------------------
|
||
|
||
void MStaff::setTrack(int track)
|
||
{
|
||
if (_lines)
|
||
_lines->setTrack(track);
|
||
if (_vspacerUp)
|
||
_vspacerUp->setTrack(track);
|
||
if (_vspacerDown)
|
||
_vspacerDown->setTrack(track);
|
||
if (_noText)
|
||
_noText->setTrack(track);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// Measure
|
||
//---------------------------------------------------------
|
||
|
||
Measure::Measure(Score* s)
|
||
: MeasureBase(s), _timesig(4,4)
|
||
{
|
||
setTicks(Fraction(4,4));
|
||
_repeatCount = 2;
|
||
|
||
int n = score()->nstaves();
|
||
_mstaves.reserve(n);
|
||
for (int staffIdx = 0; staffIdx < n; ++staffIdx) {
|
||
MStaff* ms = new MStaff;
|
||
Staff* staff = score()->staff(staffIdx);
|
||
ms->setLines(new StaffLines(score()));
|
||
ms->lines()->setTrack(staffIdx * VOICES);
|
||
ms->lines()->setParent(this);
|
||
ms->lines()->setVisible(!staff->invisible());
|
||
_mstaves.push_back(ms);
|
||
}
|
||
setIrregular(false);
|
||
_noMode = MeasureNumberMode::AUTO;
|
||
_userStretch = 1.0;
|
||
_breakMultiMeasureRest = false;
|
||
_mmRest = 0;
|
||
_mmRestCount = 0;
|
||
setFlag(ElementFlag::MOVABLE, true);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// measure
|
||
//---------------------------------------------------------
|
||
|
||
Measure::Measure(const Measure& m)
|
||
: MeasureBase(m)
|
||
{
|
||
_segments = m._segments.clone();
|
||
_timesig = m._timesig;
|
||
_len = m._len;
|
||
_repeatCount = m._repeatCount;
|
||
_noMode = m._noMode;
|
||
_userStretch = m._userStretch;
|
||
|
||
_mstaves.reserve(m._mstaves.size());
|
||
for (MStaff* ms : m._mstaves)
|
||
_mstaves.push_back(new MStaff(*ms));
|
||
|
||
_breakMultiMeasureRest = m._breakMultiMeasureRest;
|
||
_mmRest = m._mmRest;
|
||
_mmRestCount = m._mmRestCount;
|
||
_playbackCount = m._playbackCount;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// layoutStaffLines
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::layoutStaffLines()
|
||
{
|
||
for (MStaff* ms : _mstaves)
|
||
ms->lines()->layout();
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// createStaves
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::createStaves(int staffIdx)
|
||
{
|
||
for (int n = int(_mstaves.size()); n <= staffIdx; ++n) {
|
||
Staff* staff = score()->staff(n);
|
||
MStaff* s = new MStaff;
|
||
s->setLines(new StaffLines(score()));
|
||
s->lines()->setParent(this);
|
||
s->lines()->setTrack(n * VOICES);
|
||
s->lines()->setVisible(!staff->invisible());
|
||
_mstaves.push_back(s);
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// setScore
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::setScore(Score* score)
|
||
{
|
||
MeasureBase::setScore(score);
|
||
for (Segment* s = first(); s; s = s->next())
|
||
s->setScore(score);
|
||
}
|
||
|
||
bool Measure::hasVoices(int staffIdx) const { return _mstaves[staffIdx]->hasVoices(); }
|
||
void Measure::setHasVoices(int staffIdx, bool v) { return _mstaves[staffIdx]->setHasVoices(v); }
|
||
StaffLines* Measure::staffLines(int staffIdx) { return _mstaves[staffIdx]->lines(); }
|
||
Spacer* Measure::vspacerDown(int staffIdx) const { return _mstaves[staffIdx]->vspacerDown(); }
|
||
Spacer* Measure::vspacerUp(int staffIdx) const { return _mstaves[staffIdx]->vspacerUp(); }
|
||
void Measure::setStaffVisible(int staffIdx, bool visible) { _mstaves[staffIdx]->setVisible(visible); }
|
||
void Measure::setStaffStemless(int staffIdx, bool stemless) { _mstaves[staffIdx]->setStemless(stemless); }
|
||
|
||
#ifndef NDEBUG
|
||
bool Measure::corrupted(int staffIdx) const { return _mstaves[staffIdx]->corrupted(); }
|
||
void Measure::setCorrupted(int staffIdx, bool val) { _mstaves[staffIdx]->setCorrupted(val); }
|
||
#endif
|
||
|
||
void Measure::setNoText(int staffIdx, MeasureNumber* t) { _mstaves[staffIdx]->setNoText(t); }
|
||
MeasureNumber* Measure::noText(int staffIdx) const { return _mstaves[staffIdx]->noText(); }
|
||
|
||
//---------------------------------------------------------
|
||
// Measure
|
||
//---------------------------------------------------------
|
||
|
||
Measure::~Measure()
|
||
{
|
||
for (Segment* s = first(); s;) {
|
||
Segment* ns = s->next();
|
||
delete s;
|
||
s = ns;
|
||
}
|
||
qDeleteAll(_mstaves);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// AcEl
|
||
//---------------------------------------------------------
|
||
|
||
struct AcEl {
|
||
Note* note;
|
||
qreal x;
|
||
};
|
||
|
||
//---------------------------------------------------------
|
||
// findAccidental
|
||
/// return current accidental value at note position
|
||
//---------------------------------------------------------
|
||
|
||
AccidentalVal Measure::findAccidental(Note* note) const
|
||
{
|
||
Chord* chord = note->chord();
|
||
AccidentalState tversatz; // state of already set accidentals for this measure
|
||
tversatz.init(chord->staff()->keySigEvent(tick()), chord->staff()->clef(tick()));
|
||
|
||
for (Segment* segment = first(); segment; segment = segment->next()) {
|
||
int startTrack = chord->staffIdx() * VOICES;
|
||
if (segment->isKeySigType()) {
|
||
KeySig* ks = toKeySig(segment->element(startTrack));
|
||
if (!ks)
|
||
continue;
|
||
tversatz.init(chord->staff()->keySigEvent(segment->tick()), chord->staff()->clef(segment->tick()));
|
||
}
|
||
else if (segment->segmentType() == SegmentType::ChordRest) {
|
||
int endTrack = startTrack + VOICES;
|
||
for (int track = startTrack; track < endTrack; ++track) {
|
||
Element* e = segment->element(track);
|
||
if (!e || !e->isChord())
|
||
continue;
|
||
Chord* crd = toChord(e);
|
||
for (Chord* chord1 : crd->graceNotes()) {
|
||
for (Note* note1 : chord1->notes()) {
|
||
if (note1->tieBack() && note1->accidental() == 0)
|
||
continue;
|
||
//
|
||
// compute accidental
|
||
//
|
||
int tpc = note1->tpc();
|
||
int line = absStep(tpc, note1->epitch());
|
||
|
||
if (note == note1)
|
||
return tversatz.accidentalVal(line);
|
||
tversatz.setAccidentalVal(line, tpc2alter(tpc));
|
||
}
|
||
}
|
||
for (Note* note1 : crd->notes()) {
|
||
if (note1->tieBack() && note1->accidental() == 0)
|
||
continue;
|
||
//
|
||
// compute accidental
|
||
//
|
||
int tpc = note1->tpc();
|
||
int line = absStep(tpc, note1->epitch());
|
||
|
||
if (note == note1)
|
||
return tversatz.accidentalVal(line);
|
||
tversatz.setAccidentalVal(line, tpc2alter(tpc));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
qDebug("Measure::findAccidental: note not found");
|
||
return AccidentalVal::NATURAL;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// findAccidental
|
||
/// Compute accidental state at segment/staffIdx for
|
||
/// relative staff line.
|
||
//---------------------------------------------------------
|
||
|
||
AccidentalVal Measure::findAccidental(Segment* s, int staffIdx, int line, bool &error) const
|
||
{
|
||
AccidentalState tversatz; // state of already set accidentals for this measure
|
||
Staff* staff = score()->staff(staffIdx);
|
||
tversatz.init(staff->keySigEvent(tick()), staff->clef(tick()));
|
||
|
||
SegmentType st = SegmentType::ChordRest;
|
||
int startTrack = staffIdx * VOICES;
|
||
int endTrack = startTrack + VOICES;
|
||
for (Segment* segment = first(st); segment; segment = segment->next(st)) {
|
||
if (segment == s && staff->isPitchedStaff(tick())) {
|
||
ClefType clef = staff->clef(s->tick());
|
||
int l = relStep(line, clef);
|
||
return tversatz.accidentalVal(l, error);
|
||
}
|
||
for (int track = startTrack; track < endTrack; ++track) {
|
||
Element* e = segment->element(track);
|
||
if (!e || !e->isChord())
|
||
continue;
|
||
Chord* chord = toChord(e);
|
||
for (Chord* chord1 : chord->graceNotes()) {
|
||
for (Note* note : chord1->notes()) {
|
||
if (note->tieBack() && note->accidental() == 0)
|
||
continue;
|
||
int tpc = note->tpc();
|
||
int l = absStep(tpc, note->epitch());
|
||
tversatz.setAccidentalVal(l, tpc2alter(tpc));
|
||
}
|
||
}
|
||
|
||
for (Note* note : chord->notes()) {
|
||
if (note->tieBack() && note->accidental() == 0)
|
||
continue;
|
||
int tpc = note->tpc();
|
||
int l = absStep(tpc, note->epitch());
|
||
tversatz.setAccidentalVal(l, tpc2alter(tpc));
|
||
}
|
||
}
|
||
}
|
||
qDebug("segment not found");
|
||
return AccidentalVal::NATURAL;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// tick2pos
|
||
// return x position for tick relative to System
|
||
//---------------------------------------------------------
|
||
|
||
qreal Measure::tick2pos(Fraction tck) const
|
||
{
|
||
tck -= ticks();
|
||
if (isMMRest()) {
|
||
Segment* s = first(SegmentType::ChordRest);
|
||
qreal x1 = s->x();
|
||
qreal w = width() - x1;
|
||
return x1 + (tck.ticks() * w) / (ticks().ticks() * mmRestCount());
|
||
}
|
||
|
||
Segment* s;
|
||
qreal x1 = 0;
|
||
qreal x2 = 0;
|
||
Fraction tick1 = Fraction(0,1);
|
||
Fraction tick2 = Fraction(0,1);
|
||
for (s = first(SegmentType::ChordRest); s; s = s->next(SegmentType::ChordRest)) {
|
||
x2 = s->x();
|
||
tick2 = s->rtick();
|
||
if (tck == tick2)
|
||
return x2 + pos().x();
|
||
if (tck <= tick2)
|
||
break;
|
||
x1 = x2;
|
||
tick1 = tick2;
|
||
}
|
||
if (s == 0) {
|
||
x2 = width();
|
||
tick2 = ticks();
|
||
}
|
||
qreal dx = x2 - x1;
|
||
Fraction dt = tick2 - tick1;
|
||
x1 += dt.isZero() ? 0.0 : (dx * (tck.ticks() - tick1.ticks()) / dt.ticks());
|
||
return x1 + pos().x();
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// showsMeasureNumberInAutoMode
|
||
/// Wheter the measure will show measure number(s) when MeasureNumberMode is set to AUTO
|
||
//---------------------------------------------------------
|
||
|
||
bool Measure::showsMeasureNumberInAutoMode()
|
||
{
|
||
// Check wheter any measure number should be shown
|
||
if (!score()->styleB(Sid::showMeasureNumber))
|
||
return false;
|
||
|
||
// Measure numbers should not be shown on irregular measures.
|
||
if (irregular())
|
||
return false;
|
||
|
||
// Measure numbers should not show on first measure unless specified with Sid::showMeasureNumberOne
|
||
if (!no())
|
||
return score()->styleB(Sid::showMeasureNumberOne);
|
||
|
||
if (score()->styleB(Sid::measureNumberSystem))
|
||
// Show either if
|
||
// 1) This is the first measure of the system OR
|
||
// 2) The previous measure in the system is the first, and is irregular.
|
||
return (isFirstInSystem()
|
||
|| (prevMeasure() && prevMeasure()->irregular() && prevMeasure()->isFirstInSystem()));
|
||
else {
|
||
// In the case of an interval, we should show the measure number either if:
|
||
// 1) We should show them every measure
|
||
int interval = score()->styleI(Sid::measureNumberInterval);
|
||
if (interval == 1)
|
||
return true;
|
||
|
||
// 2) (measureNumber + 1) % interval == 0 (or 1 if measure number one is numbered.)
|
||
// If measure number 1 is numbered, and the interval is let's say 5, then we should number #1, 6, 11, 16, etc.
|
||
// If measure number 1 is not numbered, with the same interval (5), then we should number #5, 10, 15, 20, etc.
|
||
return (((no() + 1) % score()->styleI(Sid::measureNumberInterval)) == (score()->styleB(Sid::showMeasureNumberOne) ? 1 : 0));
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// showsMeasureNumber
|
||
/// Wheter the Measure shows a MeasureNumber
|
||
//---------------------------------------------------------
|
||
|
||
bool Measure::showsMeasureNumber()
|
||
{
|
||
if (_noMode == MeasureNumberMode::SHOW)
|
||
return true;
|
||
else if (_noMode == MeasureNumberMode::HIDE)
|
||
return false;
|
||
else {
|
||
return showsMeasureNumberInAutoMode();
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// layoutMeasureNumber
|
||
/// Layouts the Measure Numbers according to the Measure's MeasureNumberMode
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::layoutMeasureNumber()
|
||
{
|
||
bool smn = showsMeasureNumber();
|
||
|
||
QString s;
|
||
if (smn)
|
||
s = QString("%1").arg(no() + 1);
|
||
unsigned nn = 1;
|
||
bool nas = score()->styleB(Sid::measureNumberAllStaves);
|
||
|
||
if (!nas) {
|
||
//find first non invisible staff
|
||
for (unsigned staffIdx = 0; staffIdx < _mstaves.size(); ++staffIdx) {
|
||
MStaff* ms = _mstaves[staffIdx];
|
||
SysStaff* ss = system()->staff(staffIdx);
|
||
Staff* staff = score()->staff(staffIdx);
|
||
if (ms->visible() && staff->show() && ss->show()) {
|
||
nn = staffIdx;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
for (unsigned staffIdx = 0; staffIdx < _mstaves.size(); ++staffIdx) {
|
||
MStaff* ms = _mstaves[staffIdx];
|
||
MeasureNumber* t = ms->noText();
|
||
if (t)
|
||
t->setTrack(staffIdx * VOICES);
|
||
if (smn && ((staffIdx == nn) || nas)) {
|
||
if (t == 0) {
|
||
t = new MeasureNumber(score());
|
||
t->setTrack(staffIdx * VOICES);
|
||
t->setGenerated(true);
|
||
t->setParent(this);
|
||
add(t);
|
||
}
|
||
t->setXmlText(s);
|
||
t->layout();
|
||
}
|
||
else {
|
||
if (t) {
|
||
if (t->generated())
|
||
score()->removeElement(t);
|
||
else
|
||
score()->undo(new RemoveElement(t));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// layout2
|
||
// called after layout of page
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::layout2()
|
||
{
|
||
Q_ASSERT(parent());
|
||
Q_ASSERT(score()->nstaves() == int(_mstaves.size()));
|
||
|
||
qreal _spatium = spatium();
|
||
|
||
for (int staffIdx = 0; staffIdx < score()->nstaves(); ++staffIdx) {
|
||
MStaff* ms = _mstaves[staffIdx];
|
||
Spacer* sp = ms->vspacerDown();
|
||
if (sp) {
|
||
sp->layout();
|
||
Staff* staff = score()->staff(staffIdx);
|
||
int n = staff->lines(tick()) - 1;
|
||
qreal y = system()->staff(staffIdx)->y();
|
||
sp->setPos(_spatium * .5, y + n * _spatium * staff->mag(tick()));
|
||
}
|
||
sp = ms->vspacerUp();
|
||
if (sp) {
|
||
sp->layout();
|
||
qreal y = system()->staff(staffIdx)->y();
|
||
sp->setPos(_spatium * .5, y - sp->gap());
|
||
}
|
||
}
|
||
|
||
MeasureBase::layout(); // layout LAYOUT_BREAK elements
|
||
|
||
//---------------------------------------------------
|
||
// layout ties
|
||
//---------------------------------------------------
|
||
|
||
Fraction stick = system()->measures().front()->tick();
|
||
int tracks = score()->ntracks();
|
||
static const SegmentType st { SegmentType::ChordRest };
|
||
for (int track = 0; track < tracks; ++track) {
|
||
if (!score()->staff(track / VOICES)->show()) {
|
||
track += VOICES-1;
|
||
continue;
|
||
}
|
||
for (Segment* seg = first(st); seg; seg = seg->next(st)) {
|
||
ChordRest* cr = seg->cr(track);
|
||
if (!cr)
|
||
continue;
|
||
|
||
if (cr->isChord()) {
|
||
Chord* c = toChord(cr);
|
||
c->layoutSpanners(system(), stick);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// findChord
|
||
/// Search for chord at position \a tick in \a track
|
||
//---------------------------------------------------------
|
||
|
||
Chord* Measure::findChord(Fraction t, int track)
|
||
{
|
||
t -= tick();
|
||
for (Segment* seg = last(); seg; seg = seg->prev()) {
|
||
if (seg->rtick() < t)
|
||
return 0;
|
||
if (seg->rtick() == t) {
|
||
Element* el = seg->element(track);
|
||
if (el && el->isChord())
|
||
return toChord(el);
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// findChordRest
|
||
/// Search for chord or rest at position \a tick at \a staff in \a voice.
|
||
//---------------------------------------------------------
|
||
|
||
ChordRest* Measure::findChordRest(Fraction t, int track)
|
||
{
|
||
t -= tick();
|
||
for (const Segment& seg : _segments) {
|
||
if (seg.rtick() > t)
|
||
return 0;
|
||
if (seg.rtick() == t) {
|
||
Element* el = seg.element(track);
|
||
if (el && el->isChordRest())
|
||
return toChordRest(el);
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// tick2segment
|
||
//---------------------------------------------------------
|
||
|
||
Segment* Measure::tick2segment(const Fraction& _t, SegmentType st)
|
||
{
|
||
Fraction t = _t - tick();
|
||
for (Segment& s : _segments) {
|
||
if (s.rtick() == t) {
|
||
if (s.segmentType() & st)
|
||
return &s;
|
||
}
|
||
if (s.rtick() > t)
|
||
break;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// findSegmentR
|
||
// Search for a segment of type st at measure relative
|
||
// position t.
|
||
//---------------------------------------------------------
|
||
|
||
Segment* Measure::findSegmentR(SegmentType st, const Fraction& t) const
|
||
{
|
||
Segment* s;
|
||
if (t > (ticks() * Fraction(1,2))) {
|
||
// search backwards
|
||
for (s = last(); s && s->rtick() > t; s = s->prev())
|
||
;
|
||
while (s && s->prev() && s->prev()->rtick() == t)
|
||
s = s->prev();
|
||
}
|
||
else {
|
||
// search forwards
|
||
for (s = first(); s && s->rtick() < t; s = s->next())
|
||
;
|
||
}
|
||
for (; s && s->rtick() == t; s = s->next()) {
|
||
if (s->segmentType() & st)
|
||
return s;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// undoGetSegmentR
|
||
//---------------------------------------------------------
|
||
|
||
Segment* Measure::undoGetSegmentR(SegmentType type, const Fraction& t)
|
||
{
|
||
Segment* s = findSegmentR(type, t);
|
||
if (s == 0) {
|
||
s = new Segment(this, type, t);
|
||
score()->undoAddElement(s);
|
||
}
|
||
return s;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// findFirstR
|
||
// return first segment of type st at relative
|
||
// position t.
|
||
//---------------------------------------------------------
|
||
|
||
Segment* Measure::findFirstR(SegmentType st, const Fraction& t) const
|
||
{
|
||
Segment* s;
|
||
// search forwards
|
||
for (s = first(); s && s->rtick() <= t; s = s->next()) {
|
||
if (s->segmentType() == st)
|
||
return s;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// getSegmentR
|
||
/// Get a segment of type st at relative tick position t.
|
||
/// If the segment does not exist, it is created.
|
||
//---------------------------------------------------------
|
||
|
||
Segment* Measure::getSegmentR(SegmentType st, const Fraction& t)
|
||
{
|
||
Segment* s = findSegmentR(st, t);
|
||
if (!s) {
|
||
s = new Segment(this, st, t);
|
||
add(s);
|
||
}
|
||
return s;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// add
|
||
/// Add new Element \a el to Measure.
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::add(Element* e)
|
||
{
|
||
e->setParent(this);
|
||
ElementType type = e->type();
|
||
|
||
switch (type) {
|
||
case ElementType::SEGMENT:
|
||
{
|
||
Segment* seg = toSegment(e);
|
||
Fraction t = seg->rtick();
|
||
SegmentType st = seg->segmentType();
|
||
Segment* s;
|
||
|
||
for (s = first(); s && s->rtick() < t; s = s->next())
|
||
;
|
||
while (s && s->rtick() == t) {
|
||
if (!seg->isChordRestType() && (seg->segmentType() == s->segmentType())) {
|
||
qDebug("there is already a <%s> segment", seg->subTypeName());
|
||
return;
|
||
}
|
||
if (s->segmentType() > st)
|
||
break;
|
||
s = s->next();
|
||
}
|
||
seg->setParent(this);
|
||
_segments.insert(seg, s);
|
||
//
|
||
// update measure flags
|
||
//
|
||
if (seg->header())
|
||
seg->measure()->setHeader(true);
|
||
if (seg->trailer())
|
||
seg->measure()->setTrailer(true);
|
||
}
|
||
break;
|
||
|
||
case ElementType::MEASURE_NUMBER:
|
||
if (e->staffIdx() < int(_mstaves.size()))
|
||
_mstaves[e->staffIdx()]->setNoText(toMeasureNumber(e));
|
||
break;
|
||
|
||
case ElementType::SPACER:
|
||
{
|
||
Spacer* sp = toSpacer(e);
|
||
switch (sp->spacerType()) {
|
||
case SpacerType::UP:
|
||
_mstaves[e->staffIdx()]->setVspacerUp(sp);
|
||
break;
|
||
case SpacerType::DOWN:
|
||
case SpacerType::FIXED:
|
||
_mstaves[e->staffIdx()]->setVspacerDown(sp);
|
||
break;
|
||
}
|
||
sp->setGap(sp->gap()); // trigger relayout
|
||
}
|
||
break;
|
||
case ElementType::JUMP:
|
||
setRepeatJump(true);
|
||
// fall through
|
||
|
||
case ElementType::MARKER:
|
||
el().push_back(e);
|
||
break;
|
||
|
||
case ElementType::HBOX:
|
||
if (e->staff())
|
||
e->setMag(e->staff()->mag(tick())); // ?!
|
||
el().push_back(e);
|
||
break;
|
||
|
||
case ElementType::MEASURE:
|
||
_mmRest = toMeasure(e);
|
||
break;
|
||
|
||
case ElementType::STAFFTYPE_CHANGE:
|
||
{
|
||
StaffTypeChange* stc = toStaffTypeChange(e);
|
||
Staff* staff = stc->staff();
|
||
const StaffType* st = stc->staffType();
|
||
StaffType* nst;
|
||
// st needs to point to the stafftype element within the stafftypelist for the staff
|
||
if (st) {
|
||
// executed on read, undo/redo, clone
|
||
// setStaffType adds a copy to list and returns a pointer to that element within list
|
||
// we won't need the original after that
|
||
// this requires that st was allocated via new to begin with!
|
||
nst = staff->setStaffType(tick(), *st);
|
||
delete st;
|
||
}
|
||
else {
|
||
// executed on add from palette
|
||
// staffType returns a pointer to the current stafftype element in the list
|
||
// setStaffType will make a copy and return a pointer to that element within list
|
||
st = staff->staffType(tick());
|
||
nst = staff->setStaffType(tick(), *st);
|
||
}
|
||
staff->staffTypeListChanged(tick());
|
||
stc->setStaffType(nst);
|
||
MeasureBase::add(e);
|
||
}
|
||
break;
|
||
|
||
default:
|
||
MeasureBase::add(e);
|
||
break;
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// remove
|
||
/// Remove Element \a el from Measure.
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::remove(Element* e)
|
||
{
|
||
Q_ASSERT(e->parent() == this);
|
||
Q_ASSERT(e->score() == score());
|
||
|
||
switch (e->type()) {
|
||
case ElementType::SEGMENT:
|
||
{
|
||
Segment* s = toSegment(e);
|
||
_segments.remove(s);
|
||
//
|
||
// update measure flags
|
||
//
|
||
if (s->header())
|
||
s->measure()->checkHeader();
|
||
if (s->trailer())
|
||
s->measure()->checkTrailer();
|
||
}
|
||
break;
|
||
|
||
case ElementType::MEASURE_NUMBER:
|
||
_mstaves[e->staffIdx()]->setNoText(nullptr);
|
||
break;
|
||
|
||
case ElementType::SPACER:
|
||
switch (toSpacer(e)->spacerType()) {
|
||
case SpacerType::DOWN:
|
||
case SpacerType::FIXED:
|
||
_mstaves[e->staffIdx()]->setVspacerDown(0);
|
||
break;
|
||
case SpacerType::UP:
|
||
_mstaves[e->staffIdx()]->setVspacerUp(0);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case ElementType::JUMP:
|
||
setRepeatJump(false);
|
||
// fall through
|
||
|
||
case ElementType::MARKER:
|
||
case ElementType::HBOX:
|
||
if (!el().remove(e)) {
|
||
qDebug("Measure(%p)::remove(%s,%p) not found", this, e->name(), e);
|
||
}
|
||
break;
|
||
|
||
case ElementType::CLEF:
|
||
case ElementType::CHORD:
|
||
case ElementType::REST:
|
||
case ElementType::TIMESIG:
|
||
for (Segment* segment = first(); segment; segment = segment->next()) {
|
||
int staves = score()->nstaves();
|
||
int tracks = staves * VOICES;
|
||
for (int track = 0; track < tracks; ++track) {
|
||
Element* ee = segment->element(track);
|
||
if (ee == e) {
|
||
segment->setElement(track, 0);
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
qDebug("Measure::remove: %s %p not found", e->name(), e);
|
||
break;
|
||
|
||
case ElementType::MEASURE:
|
||
_mmRest = 0;
|
||
break;
|
||
|
||
case ElementType::STAFFTYPE_CHANGE:
|
||
{
|
||
StaffTypeChange* stc = toStaffTypeChange(e);
|
||
Staff* staff = stc->staff();
|
||
if (staff) {
|
||
// st currently points to an list element that is about to be removed
|
||
// make a copy now to use on undo/redo
|
||
StaffType* st = new StaffType(*stc->staffType());
|
||
if (!tick().isZero())
|
||
staff->removeStaffType(tick());
|
||
stc->setStaffType(st);
|
||
}
|
||
MeasureBase::remove(e);
|
||
}
|
||
break;
|
||
|
||
default:
|
||
MeasureBase::remove(e);
|
||
break;
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// change
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::change(Element* o, Element* n)
|
||
{
|
||
if (o->isTuplet()) {
|
||
Tuplet* t = toTuplet(n);
|
||
for (DurationElement* e : t->elements())
|
||
e->setTuplet(t);
|
||
}
|
||
else {
|
||
remove(o);
|
||
add(n);
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// spatiumChanged
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::spatiumChanged(qreal /*oldValue*/, qreal /*newValue*/)
|
||
{
|
||
}
|
||
|
||
//-------------------------------------------------------------------
|
||
// moveTicks
|
||
// Also adjust endBarLine if measure len has changed. For this
|
||
// diff == 0 cannot be optimized away
|
||
//-------------------------------------------------------------------
|
||
|
||
void Measure::moveTicks(const Fraction& diff)
|
||
{
|
||
std::set<Tuplet*> tuplets;
|
||
setTick(tick() + diff);
|
||
for (Segment* segment = last(); segment; segment = segment->prev()) {
|
||
if (segment->segmentType() & (SegmentType::EndBarLine | SegmentType::TimeSigAnnounce))
|
||
segment->setRtick(ticks());
|
||
else if (segment->isChordRestType()) {
|
||
// Tuplet ticks are stored as absolute ticks, so they must be adjusted.
|
||
// But each tuplet must only be adjusted once.
|
||
for (Element* e : segment->elist()) {
|
||
if (e) {
|
||
ChordRest* cr = toChordRest(e);
|
||
Tuplet* tuplet = cr->tuplet();
|
||
if (tuplet && tuplets.count(tuplet) == 0)
|
||
tuplets.insert(tuplet);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
tuplets.clear();
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// removeStaves
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::removeStaves(int sStaff, int eStaff)
|
||
{
|
||
for (Segment* s = first(); s; s = s->next()) {
|
||
for (int staff = eStaff-1; staff >= sStaff; --staff) {
|
||
s->removeStaff(staff);
|
||
}
|
||
}
|
||
for (Element* e : el()) {
|
||
if (e->track() == -1)
|
||
continue;
|
||
int voice = e->voice();
|
||
int staffIdx = e->staffIdx();
|
||
if (staffIdx >= eStaff) {
|
||
staffIdx -= eStaff - sStaff;
|
||
e->setTrack(staffIdx * VOICES + voice);
|
||
}
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// insertStaves
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::insertStaves(int sStaff, int eStaff)
|
||
{
|
||
for (Element* e : el()) {
|
||
if (e->track() == -1)
|
||
continue;
|
||
int staffIdx = e->staffIdx();
|
||
if (staffIdx >= sStaff && !e->systemFlag()) {
|
||
int voice = e->voice();
|
||
staffIdx += eStaff - sStaff;
|
||
e->setTrack(staffIdx * VOICES + voice);
|
||
}
|
||
}
|
||
for (Segment* s = first(); s; s = s->next()) {
|
||
for (int staff = sStaff; staff < eStaff; ++staff) {
|
||
s->insertStaff(staff);
|
||
}
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// cmdRemoveStaves
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::cmdRemoveStaves(int sStaff, int eStaff)
|
||
{
|
||
int sTrack = sStaff * VOICES;
|
||
int eTrack = eStaff * VOICES;
|
||
for (Segment* s = first(); s; s = s->next()) {
|
||
for (int track = eTrack - 1; track >= sTrack; --track) {
|
||
Element* el = s->element(track);
|
||
if (el) {
|
||
el->undoUnlink();
|
||
score()->undo(new RemoveElement(el));
|
||
}
|
||
}
|
||
foreach (Element* e, s->annotations()) {
|
||
int staffIdx = e->staffIdx();
|
||
if ((staffIdx >= sStaff) && (staffIdx < eStaff) && !e->systemFlag()) {
|
||
e->undoUnlink();
|
||
score()->undo(new RemoveElement(e));
|
||
}
|
||
}
|
||
}
|
||
for (Element* e : el()) {
|
||
if (e->track() == -1)
|
||
continue;
|
||
int staffIdx = e->staffIdx();
|
||
if (staffIdx >= sStaff && (staffIdx < eStaff) && !e->systemFlag()) {
|
||
e->undoUnlink();
|
||
score()->undo(new RemoveElement(e));
|
||
}
|
||
}
|
||
|
||
score()->undo(new RemoveStaves(this, sStaff, eStaff));
|
||
|
||
for (int i = eStaff - 1; i >= sStaff; --i) {
|
||
MStaff* ms = *(_mstaves.begin()+i);
|
||
score()->undo(new RemoveMStaff(this, ms, i));
|
||
}
|
||
|
||
// barLine
|
||
// TODO
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// cmdAddStaves
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::cmdAddStaves(int sStaff, int eStaff, bool createRest)
|
||
{
|
||
score()->undo(new InsertStaves(this, sStaff, eStaff));
|
||
|
||
Segment* ts = findSegment(SegmentType::TimeSig, tick());
|
||
Segment* bs = findSegmentR(SegmentType::EndBarLine, ticks());
|
||
|
||
for (int i = sStaff; i < eStaff; ++i) {
|
||
Staff* staff = score()->staff(i);
|
||
MStaff* ms = new MStaff;
|
||
ms->setLines(new StaffLines(score()));
|
||
ms->lines()->setTrack(i * VOICES);
|
||
ms->lines()->setParent(this);
|
||
ms->lines()->setVisible(!staff->invisible());
|
||
score()->undo(new InsertMStaff(this, ms, i));
|
||
}
|
||
|
||
if (!createRest && !ts)
|
||
return;
|
||
|
||
|
||
// create list of unique staves (only one instance for linked staves):
|
||
|
||
QList<int> sl;
|
||
for (int staffIdx = sStaff; staffIdx < eStaff; ++staffIdx) {
|
||
Staff* s = score()->staff(staffIdx);
|
||
if (s->links()) {
|
||
bool alreadyInList = false;
|
||
for (int idx : sl) {
|
||
if (s->links()->contains(score()->staff(idx))) {
|
||
alreadyInList = true;
|
||
break;
|
||
}
|
||
}
|
||
if (alreadyInList)
|
||
continue;
|
||
}
|
||
sl.append(staffIdx);
|
||
}
|
||
|
||
for (int staffIdx : sl) {
|
||
if (createRest)
|
||
score()->setRest(tick(), staffIdx * VOICES, ticks(), false, 0, _timesig == ticks());
|
||
|
||
// replicate time signature
|
||
if (ts) {
|
||
TimeSig* ots = 0;
|
||
bool constructed = false;
|
||
for (unsigned track = 0; track < _mstaves.size() * VOICES; ++track) {
|
||
if (ts->element(track)) {
|
||
ots = toTimeSig(ts->element(track));
|
||
break;
|
||
}
|
||
}
|
||
if (!ots) {
|
||
// no time signature found; use measure timesig to construct one
|
||
ots = new TimeSig(score());
|
||
ots->setSig(timesig());
|
||
constructed = true;
|
||
}
|
||
// do no replicate local time signatures
|
||
if (ots && !ots->isLocal()) {
|
||
TimeSig* timesig = new TimeSig(*ots);
|
||
timesig->setTrack(staffIdx * VOICES);
|
||
timesig->setParent(ts);
|
||
timesig->setSig(ots->sig(), ots->timeSigType());
|
||
score()->undoAddElement(timesig);
|
||
if (constructed)
|
||
delete ots;
|
||
}
|
||
}
|
||
|
||
// replicate barline
|
||
if (bs) {
|
||
BarLine* obl = nullptr;
|
||
for (unsigned track = 0; track < _mstaves.size() * VOICES; ++track) {
|
||
Element* e = bs->element(track);
|
||
if (e && !e->generated()) {
|
||
obl = toBarLine(e);
|
||
break;
|
||
}
|
||
}
|
||
if (obl) {
|
||
BarLine* barline = new BarLine(*obl);
|
||
barline->setSpanStaff(score()->staff(staffIdx)->barLineSpan());
|
||
barline->setTrack(staffIdx * VOICES);
|
||
barline->setParent(bs);
|
||
barline->setGenerated(false);
|
||
score()->undoAddElement(barline);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// insertMStaff
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::insertMStaff(MStaff* staff, int idx)
|
||
{
|
||
_mstaves.insert(_mstaves.begin()+idx, staff);
|
||
for (unsigned staffIdx = 0; staffIdx < _mstaves.size(); ++staffIdx)
|
||
_mstaves[staffIdx]->setTrack(staffIdx * VOICES);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// removeMStaff
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::removeMStaff(MStaff* /*staff*/, int idx)
|
||
{
|
||
_mstaves.erase(_mstaves.begin()+idx);
|
||
for (unsigned staffIdx = 0; staffIdx < _mstaves.size(); ++staffIdx)
|
||
_mstaves[staffIdx]->setTrack(staffIdx * VOICES);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// insertStaff
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::insertStaff(Staff* staff, int staffIdx)
|
||
{
|
||
for (Segment* s = first(); s; s = s->next())
|
||
s->insertStaff(staffIdx);
|
||
|
||
MStaff* ms = new MStaff;
|
||
ms->setLines(new StaffLines(score()));
|
||
ms->lines()->setParent(this);
|
||
ms->lines()->setTrack(staffIdx * VOICES);
|
||
ms->lines()->setVisible(!staff->invisible());
|
||
insertMStaff(ms, staffIdx);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// staffabbox
|
||
//---------------------------------------------------------
|
||
|
||
QRectF Measure::staffabbox(int staffIdx) const
|
||
{
|
||
System* s = system();
|
||
QRectF sb(s->staff(staffIdx)->bbox());
|
||
QRectF rrr(sb.translated(s->pagePos()));
|
||
QRectF rr(abbox());
|
||
QRectF r(rr.x(), rrr.y(), rr.width(), rrr.height());
|
||
return r;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// acceptDrop
|
||
//---------------------------------------------------------
|
||
|
||
/**
|
||
Return true if an Element of type \a type can be dropped on a Measure
|
||
*/
|
||
|
||
bool Measure::acceptDrop(EditData& data) const
|
||
{
|
||
MuseScoreView* viewer = data.view;
|
||
QPointF pos = data.pos;
|
||
Element* e = data.dropElement;
|
||
|
||
int staffIdx;
|
||
Segment* seg;
|
||
if (!score()->pos2measure(pos, &staffIdx, 0, &seg, 0))
|
||
return false;
|
||
|
||
QRectF staffR = system()->staff(staffIdx)->bbox().translated(system()->canvasPos());
|
||
staffR &= canvasBoundingRect();
|
||
|
||
switch (e->type()) {
|
||
case ElementType::MEASURE_LIST:
|
||
case ElementType::JUMP:
|
||
case ElementType::MARKER:
|
||
case ElementType::LAYOUT_BREAK:
|
||
case ElementType::STAFF_LIST:
|
||
viewer->setDropRectangle(canvasBoundingRect());
|
||
return true;
|
||
|
||
case ElementType::KEYSIG:
|
||
case ElementType::TIMESIG:
|
||
if (data.modifiers & Qt::ControlModifier)
|
||
viewer->setDropRectangle(staffR);
|
||
else
|
||
viewer->setDropRectangle(canvasBoundingRect());
|
||
return true;
|
||
|
||
case ElementType::MEASURE_NUMBER:
|
||
viewer->setDropRectangle(canvasBoundingRect());
|
||
return true;
|
||
|
||
case ElementType::BRACKET:
|
||
case ElementType::REPEAT_MEASURE:
|
||
case ElementType::MEASURE:
|
||
case ElementType::SPACER:
|
||
case ElementType::IMAGE:
|
||
case ElementType::BAR_LINE:
|
||
case ElementType::SYMBOL:
|
||
case ElementType::CLEF:
|
||
case ElementType::STAFFTYPE_CHANGE:
|
||
viewer->setDropRectangle(staffR);
|
||
return true;
|
||
|
||
case ElementType::ICON:
|
||
switch (toIcon(e)->iconType()) {
|
||
case IconType::VFRAME:
|
||
case IconType::HFRAME:
|
||
case IconType::TFRAME:
|
||
case IconType::FFRAME:
|
||
case IconType::MEASURE:
|
||
viewer->setDropRectangle(canvasBoundingRect());
|
||
return true;
|
||
default:
|
||
break;
|
||
}
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// drop
|
||
/// Drop element.
|
||
/// Handle a dropped element at position \a pos of given
|
||
/// element \a type and \a subtype.
|
||
//---------------------------------------------------------
|
||
|
||
Element* Measure::drop(EditData& data)
|
||
{
|
||
Element* e = data.dropElement;
|
||
int staffIdx = -1;
|
||
Segment* seg;
|
||
score()->pos2measure(data.pos, &staffIdx, 0, &seg, 0);
|
||
|
||
if (e->systemFlag())
|
||
staffIdx = 0;
|
||
if (staffIdx < 0)
|
||
return 0;
|
||
Staff* staff = score()->staff(staffIdx);
|
||
//bool fromPalette = (e->track() == -1);
|
||
|
||
switch (e->type()) {
|
||
case ElementType::MEASURE_LIST:
|
||
delete e;
|
||
break;
|
||
|
||
case ElementType::STAFF_LIST:
|
||
//TODO score()->pasteStaff(e, this, staffIdx);
|
||
delete e;
|
||
break;
|
||
|
||
case ElementType::MARKER:
|
||
case ElementType::JUMP:
|
||
e->setParent(this);
|
||
e->setTrack(0);
|
||
score()->undoAddElement(e);
|
||
return e;
|
||
|
||
case ElementType::DYNAMIC:
|
||
case ElementType::FRET_DIAGRAM:
|
||
e->setParent(seg);
|
||
e->setTrack(staffIdx * VOICES);
|
||
score()->undoAddElement(e);
|
||
return e;
|
||
|
||
case ElementType::IMAGE:
|
||
case ElementType::SYMBOL:
|
||
e->setParent(seg);
|
||
e->setTrack(staffIdx * VOICES);
|
||
e->layout();
|
||
{
|
||
QPointF uo(data.pos - e->canvasPos() - data.dragOffset);
|
||
e->setOffset(uo);
|
||
}
|
||
score()->undoAddElement(e);
|
||
return e;
|
||
|
||
case ElementType::MEASURE_NUMBER:
|
||
undoChangeProperty(Pid::MEASURE_NUMBER_MODE, static_cast<int>(MeasureNumberMode::SHOW));
|
||
delete e;
|
||
break;
|
||
|
||
case ElementType::BRACKET:
|
||
{
|
||
Bracket* b = toBracket(e);
|
||
int level = 0;
|
||
int firstStaff = 0;
|
||
for (Staff* s : score()->staves()) {
|
||
for (const BracketItem* bi : s->brackets()) {
|
||
int lastStaff = firstStaff + bi->bracketSpan() - 1;
|
||
if (staffIdx >= firstStaff && staffIdx <= lastStaff)
|
||
++level;
|
||
}
|
||
firstStaff++;
|
||
}
|
||
Selection sel = score()->selection();
|
||
score()->undoAddBracket(staff, level, b->bracketType(), sel.staffEnd() - sel.staffStart());
|
||
delete b;
|
||
}
|
||
break;
|
||
|
||
case ElementType::CLEF:
|
||
score()->undoChangeClef(staff, this, toClef(e)->clefType());
|
||
delete e;
|
||
break;
|
||
|
||
case ElementType::KEYSIG:
|
||
{
|
||
KeySigEvent k = toKeySig(e)->keySigEvent();
|
||
delete e;
|
||
|
||
if (data.modifiers & Qt::ControlModifier) {
|
||
// apply only to this stave
|
||
score()->undoChangeKeySig(staff, tick(), k);
|
||
}
|
||
else {
|
||
// apply to all staves:
|
||
for (Staff* s : score()->staves())
|
||
score()->undoChangeKeySig(s, tick(), k);
|
||
}
|
||
|
||
break;
|
||
}
|
||
|
||
case ElementType::TIMESIG:
|
||
score()->cmdAddTimeSig(this, staffIdx, toTimeSig(e), data.modifiers & Qt::ControlModifier);
|
||
break;
|
||
|
||
case ElementType::LAYOUT_BREAK: {
|
||
LayoutBreak* b = toLayoutBreak(e);
|
||
Measure* measure = isMMRest() ? mmRestLast() : this;
|
||
switch (b->layoutBreakType()) {
|
||
case LayoutBreak::PAGE:
|
||
if (measure->pageBreak()) {
|
||
delete b;
|
||
b = 0;
|
||
}
|
||
else
|
||
measure->setLineBreak(false);
|
||
break;
|
||
case LayoutBreak::LINE:
|
||
if (measure->lineBreak()) {
|
||
delete b;
|
||
b = 0;
|
||
}
|
||
else
|
||
measure->setPageBreak(false);
|
||
break;
|
||
case LayoutBreak::SECTION:
|
||
if (measure->sectionBreak()) {
|
||
delete b;
|
||
b = 0;
|
||
}
|
||
else
|
||
measure->setLineBreak(false);
|
||
break;
|
||
case LayoutBreak::NOBREAK:
|
||
if (measure->noBreak()) {
|
||
delete b;
|
||
b = 0;
|
||
}
|
||
else {
|
||
measure->setLineBreak(false);
|
||
measure->setPageBreak(false);
|
||
}
|
||
break;
|
||
}
|
||
if (b) {
|
||
b->setTrack(-1); // these are system elements
|
||
b->setParent(measure);
|
||
score()->undoAddElement(b);
|
||
}
|
||
measure->cleanupLayoutBreaks(true);
|
||
return b;
|
||
}
|
||
|
||
case ElementType::SPACER:
|
||
{
|
||
Spacer* spacer = toSpacer(e);
|
||
spacer->setTrack(staffIdx * VOICES);
|
||
spacer->setParent(this);
|
||
if (spacer->spacerType() == SpacerType::FIXED) {
|
||
qreal gap = spatium() * 10;
|
||
System* s = system();
|
||
const int nextVisStaffIdx = s->nextVisibleStaff(staffIdx);
|
||
const bool systemEnd = (nextVisStaffIdx == score()->nstaves());
|
||
if (systemEnd) {
|
||
System* ns = 0;
|
||
for (System* ts : score()->systems()) {
|
||
if (ns) {
|
||
ns = ts;
|
||
break;
|
||
}
|
||
if (ts == s)
|
||
ns = ts;
|
||
}
|
||
if (ns && ns->page() == s->page()) {
|
||
qreal y1 = s->staffYpage(staffIdx);
|
||
qreal y2 = ns->staffYpage(0);
|
||
gap = y2 - y1 - score()->staff(staffIdx)->height();
|
||
}
|
||
}
|
||
else {
|
||
qreal y1 = s->staffYpage(staffIdx);
|
||
qreal y2 = s->staffYpage(nextVisStaffIdx);
|
||
gap = y2 - y1 - score()->staff(staffIdx)->height();
|
||
}
|
||
spacer->setGap(gap);
|
||
}
|
||
score()->undoAddElement(spacer);
|
||
triggerLayout();
|
||
return spacer;
|
||
}
|
||
|
||
case ElementType::BAR_LINE:
|
||
{
|
||
BarLine* bl = toBarLine(e);
|
||
|
||
// if dropped bar line refers to span rather than to subtype
|
||
// 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
|
||
seg = undoGetSegmentR(SegmentType::EndBarLine, ticks());
|
||
BarLine* cbl = toBarLine(seg->element(staffIdx * VOICES));
|
||
if (cbl)
|
||
cbl->drop(data);
|
||
}
|
||
else if (bl->barLineType() == BarLineType::START_REPEAT) {
|
||
Measure* m2 = isMMRest() ? mmRestFirst() : this;
|
||
for (Score* lscore : score()->scoreList()) {
|
||
Measure* lmeasure = lscore->tick2measure(m2->tick());
|
||
if (lmeasure)
|
||
lmeasure->undoChangeProperty(Pid::REPEAT_START, true);
|
||
}
|
||
}
|
||
else if (bl->barLineType() == BarLineType::END_REPEAT) {
|
||
Measure* m2 = isMMRest() ? mmRestLast() : this;
|
||
for (Score* lscore : score()->scoreList()) {
|
||
Measure* lmeasure = lscore->tick2measure(m2->tick());
|
||
if (lmeasure)
|
||
lmeasure->undoChangeProperty(Pid::REPEAT_END, true);
|
||
}
|
||
}
|
||
else if (bl->barLineType() == BarLineType::END_START_REPEAT) {
|
||
Measure* m2 = isMMRest() ? mmRestLast() : this;
|
||
for (Score* lscore : score()->scoreList()) {
|
||
Measure* lmeasure = lscore->tick2measure(m2->tick());
|
||
if (lmeasure) {
|
||
lmeasure->undoChangeProperty(Pid::REPEAT_END, true);
|
||
lmeasure = lmeasure->nextMeasure();
|
||
if (lmeasure)
|
||
lmeasure->undoChangeProperty(Pid::REPEAT_START, true);
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
// drop to first end barline
|
||
seg = findSegmentR(SegmentType::EndBarLine, ticks());
|
||
if (seg) {
|
||
for (Element* ee : seg->elist()) {
|
||
if (ee) {
|
||
ee->drop(data);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
delete e;
|
||
}
|
||
break;
|
||
}
|
||
|
||
case ElementType::REPEAT_MEASURE:
|
||
{
|
||
delete e;
|
||
return cmdInsertRepeatMeasure(staffIdx);
|
||
}
|
||
case ElementType::ICON:
|
||
switch(toIcon(e)->iconType()) {
|
||
case IconType::VFRAME:
|
||
score()->insertMeasure(ElementType::VBOX, this);
|
||
break;
|
||
case IconType::HFRAME:
|
||
score()->insertMeasure(ElementType::HBOX, this);
|
||
break;
|
||
case IconType::TFRAME:
|
||
score()->insertMeasure(ElementType::TBOX, this);
|
||
break;
|
||
case IconType::FFRAME:
|
||
score()->insertMeasure(ElementType::FBOX, this);
|
||
break;
|
||
case IconType::MEASURE:
|
||
score()->insertMeasure(ElementType::MEASURE, this);
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case ElementType::STAFFTYPE_CHANGE:
|
||
{
|
||
e->setParent(this);
|
||
e->setTrack(staffIdx * VOICES);
|
||
score()->undoAddElement(e);
|
||
}
|
||
break;
|
||
|
||
default:
|
||
qDebug("Measure: cannot drop %s here", e->name());
|
||
delete e;
|
||
break;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// cmdInsertRepeatMeasure
|
||
//---------------------------------------------------------
|
||
|
||
RepeatMeasure* Measure::cmdInsertRepeatMeasure(int staffIdx)
|
||
{
|
||
//
|
||
// see also cmdDeleteSelection()
|
||
//
|
||
score()->select(0, SelectType::SINGLE, 0);
|
||
for (Segment* s = first(); s; s = s->next()) {
|
||
if (s->segmentType() & SegmentType::ChordRest) {
|
||
int strack = staffIdx * VOICES;
|
||
int etrack = strack + VOICES;
|
||
for (int track = strack; track < etrack; ++track) {
|
||
Element* el = s->element(track);
|
||
if (el)
|
||
score()->undoRemoveElement(el);
|
||
}
|
||
}
|
||
}
|
||
//
|
||
// add repeat measure
|
||
//
|
||
Segment* seg = undoGetSegment(SegmentType::ChordRest, tick());
|
||
RepeatMeasure* rm = new RepeatMeasure(score());
|
||
rm->setTrack(staffIdx * VOICES);
|
||
rm->setParent(seg);
|
||
rm->setDurationType(TDuration::DurationType::V_MEASURE);
|
||
rm->setTicks(stretchedLen(score()->staff(staffIdx)));
|
||
score()->undoAddCR(rm, this, tick());
|
||
for (Element* e : el()) {
|
||
if (e->isSlur() && e->staffIdx() == staffIdx)
|
||
score()->undoRemoveElement(e);
|
||
}
|
||
return rm;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// adjustToLen
|
||
// change actual measure len, adjust elements to
|
||
// new len
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::adjustToLen(Fraction nf, bool appendRestsIfNecessary)
|
||
{
|
||
Fraction ol = ticks();
|
||
Fraction nl = nf;
|
||
Fraction diff = nl - ol;
|
||
|
||
Fraction startTick = endTick();
|
||
if (diff < Fraction(0,1))
|
||
startTick += diff;
|
||
|
||
score()->undoInsertTime(startTick, diff);
|
||
score()->undo(new InsertTime(score(), startTick, diff));
|
||
|
||
for (Score* s : score()->scoreList()) {
|
||
Measure* m = s->tick2measure(tick());
|
||
s->undo(new ChangeMeasureLen(m, nf));
|
||
if (nl > ol) {
|
||
// move EndBarLine, TimeSigAnnounce, KeySigAnnounce
|
||
for (Segment* seg = m->first(); seg; seg = seg->next()) {
|
||
if (seg->segmentType() & (SegmentType::EndBarLine|SegmentType::TimeSigAnnounce|SegmentType::KeySigAnnounce)) {
|
||
seg->setRtick(nl);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
Score* s = score()->masterScore();
|
||
Measure* m = s->tick2measure(tick());
|
||
QList<int> sl = s->uniqueStaves();
|
||
|
||
for (int staffIdx : sl) {
|
||
int rests = 0;
|
||
int chords = 0;
|
||
Rest* rest = 0;
|
||
for (Segment* segment = m->first(); segment; segment = segment->next()) {
|
||
int strack = staffIdx * VOICES;
|
||
int etrack = strack + VOICES;
|
||
for (int track = strack; track < etrack; ++track) {
|
||
Element* e = segment->element(track);
|
||
if (e) {
|
||
if (e->isRest()) {
|
||
++rests;
|
||
rest = toRest(e);
|
||
}
|
||
else if (e->isChord())
|
||
++chords;
|
||
}
|
||
}
|
||
}
|
||
Fraction stretch = s->staff(staffIdx)->timeStretch(tick());
|
||
// if just a single rest
|
||
if (rests == 1 && chords == 0) {
|
||
// if measure value didn't change, stick to whole measure rest
|
||
if (_timesig == nf) {
|
||
rest->undoChangeProperty(Pid::DURATION, QVariant::fromValue<Fraction>(nf * stretch));
|
||
rest->undoChangeProperty(Pid::DURATION_TYPE, QVariant::fromValue<TDuration>(TDuration::DurationType::V_MEASURE));
|
||
}
|
||
else { // if measure value did change, represent with rests actual measure value
|
||
#if 0
|
||
// any reason not to do this instead?
|
||
s->undoRemoveElement(rest);
|
||
s->setRest(tick(), staffIdx * VOICES, nf * stretch, false, 0, false);
|
||
#else
|
||
// convert the measure duration in a list of values (no dots for rests)
|
||
std::vector<TDuration> durList = toDurationList(nf * stretch, false, 0);
|
||
|
||
// set the existing rest to the first value of the duration list
|
||
for (ScoreElement* e : rest->linkList()) {
|
||
e->undoChangeProperty(Pid::DURATION, QVariant::fromValue<Fraction>(durList[0].fraction()));
|
||
e->undoChangeProperty(Pid::DURATION_TYPE, QVariant::fromValue<TDuration>(durList[0]));
|
||
}
|
||
|
||
// add rests for any other duration list value
|
||
Fraction tickOffset = tick() + rest->actualTicks();
|
||
for (unsigned i = 1; i < durList.size(); i++) {
|
||
Rest* newRest = new Rest(s);
|
||
newRest->setDurationType(durList.at(i));
|
||
newRest->setTicks(durList.at(i).fraction());
|
||
newRest->setTrack(rest->track());
|
||
score()->undoAddCR(newRest, this, tickOffset);
|
||
tickOffset += newRest->actualTicks();
|
||
}
|
||
#endif
|
||
}
|
||
continue;
|
||
}
|
||
|
||
int strack = staffIdx * VOICES;
|
||
int etrack = strack + VOICES;
|
||
|
||
for (int trk = strack; trk < etrack; ++trk) {
|
||
Fraction n = diff;
|
||
bool rFlag = false;
|
||
if (n < Fraction(0,1)) {
|
||
for (Segment* segment = m->last(); segment;) {
|
||
Segment* pseg = segment->prev();
|
||
if (segment->segmentType() == SegmentType::ChordRest) {
|
||
for (Element* a : segment->annotations())
|
||
if (a->track() == trk)
|
||
s->undoRemoveElement(a);
|
||
Element* e = segment->element(trk);
|
||
if (e && e->isChordRest()) {
|
||
ChordRest* cr = toChordRest(e);
|
||
if (cr->durationType() == TDuration::DurationType::V_MEASURE) {
|
||
Fraction actualTicks = cr->actualTicks();
|
||
n += actualTicks;
|
||
cr->setDurationType(TDuration(actualTicks));
|
||
}
|
||
else
|
||
n += cr->actualTicks();
|
||
s->undoRemoveElement(e);
|
||
if (n >= Fraction(0,1))
|
||
break;
|
||
}
|
||
}
|
||
else if (segment->segmentType() == SegmentType::Breath) {
|
||
Element* e = segment->element(trk);
|
||
if (e)
|
||
s->undoRemoveElement(e);
|
||
}
|
||
segment = pseg;
|
||
}
|
||
rFlag = true;
|
||
}
|
||
int voice = trk % VOICES;
|
||
if (appendRestsIfNecessary && (n > Fraction(0,1)) && (rFlag || voice == 0)) {
|
||
// add rest to measure
|
||
Fraction rtick = tick() + nl - n;
|
||
int track = staffIdx * VOICES + voice;
|
||
s->setRest(rtick, track, n * stretch, false, 0, false);
|
||
}
|
||
}
|
||
}
|
||
if (diff < Fraction(0,1)) {
|
||
//
|
||
// CHECK: do not remove all slurs
|
||
//
|
||
for (Element* e : m->el()) {
|
||
if (e->isSlur())
|
||
s->undoRemoveElement(e);
|
||
}
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// write
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::write(XmlWriter& xml, int staff, bool writeSystemElements, bool forceTimeSig) const
|
||
{
|
||
if (MScore::debugMode) {
|
||
const int mno = no() + 1;
|
||
xml.comment(QString("Measure %1").arg(mno));
|
||
}
|
||
if (_len != _timesig) {
|
||
// this is an irregular measure
|
||
xml.stag(this, QString("len=\"%1/%2\"").arg(_len.numerator()).arg(_len.denominator()));
|
||
}
|
||
else
|
||
xml.stag(this);
|
||
|
||
xml.setCurTick(tick());
|
||
xml.setCurTrack(staff * VOICES);
|
||
|
||
if (_mmRestCount > 0)
|
||
xml.tag("multiMeasureRest", _mmRestCount);
|
||
if (writeSystemElements) {
|
||
if (repeatStart())
|
||
xml.tagE("startRepeat");
|
||
if (repeatEnd())
|
||
xml.tag("endRepeat", _repeatCount);
|
||
writeProperty(xml, Pid::IRREGULAR);
|
||
writeProperty(xml, Pid::BREAK_MMR);
|
||
writeProperty(xml, Pid::USER_STRETCH);
|
||
writeProperty(xml, Pid::NO_OFFSET);
|
||
writeProperty(xml, Pid::MEASURE_NUMBER_MODE);
|
||
}
|
||
qreal _spatium = spatium();
|
||
MStaff* mstaff = _mstaves[staff];
|
||
if (mstaff->noText() && !mstaff->noText()->generated())
|
||
mstaff->noText()->write(xml);
|
||
|
||
if (mstaff->vspacerUp())
|
||
xml.tag("vspacerUp", mstaff->vspacerUp()->gap() / _spatium);
|
||
if (mstaff->vspacerDown()) {
|
||
if (mstaff->vspacerDown()->spacerType() == SpacerType::FIXED)
|
||
xml.tag("vspacerFixed", mstaff->vspacerDown()->gap() / _spatium);
|
||
else
|
||
xml.tag("vspacerDown", mstaff->vspacerDown()->gap() / _spatium);
|
||
}
|
||
if (!mstaff->visible())
|
||
xml.tag("visible", mstaff->visible());
|
||
if (mstaff->stemless()) {
|
||
xml.tag("slashStyle", mstaff->stemless()); // for backwards compatibility
|
||
xml.tag("stemless", mstaff->stemless());
|
||
}
|
||
|
||
int strack = staff * VOICES;
|
||
int etrack = strack + VOICES;
|
||
for (const Element* e : el()) {
|
||
if (!e->generated() && ((e->staffIdx() == staff) || (e->systemFlag() && writeSystemElements)))
|
||
e->write(xml);
|
||
}
|
||
Q_ASSERT(first());
|
||
Q_ASSERT(last());
|
||
if (first() && last())
|
||
score()->writeSegments(xml, strack, etrack, first(), last()->next1(), writeSystemElements, forceTimeSig);
|
||
|
||
xml.etag();
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// Measure::read
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::read(XmlReader& e, int staffIdx)
|
||
{
|
||
qreal _spatium = spatium();
|
||
e.setCurrentMeasure(this);
|
||
int nextTrack = staffIdx * VOICES;
|
||
e.setTrack(nextTrack);
|
||
|
||
for (int n = int(_mstaves.size()); n <= staffIdx; ++n) {
|
||
Staff* staff = score()->staff(n);
|
||
MStaff* s = new MStaff;
|
||
s->setLines(new StaffLines(score()));
|
||
s->lines()->setParent(this);
|
||
s->lines()->setTrack(n * VOICES);
|
||
s->lines()->setVisible(!staff->invisible());
|
||
_mstaves.push_back(s);
|
||
}
|
||
|
||
bool irregular;
|
||
if (e.hasAttribute("len")) {
|
||
QStringList sl = e.attribute("len").split('/');
|
||
if (sl.size() == 2)
|
||
_len = Fraction(sl[0].toInt(), sl[1].toInt());
|
||
else
|
||
qDebug("illegal measure size <%s>", qPrintable(e.attribute("len")));
|
||
irregular = true;
|
||
if (_len.numerator() <= 0 || _len.denominator() <= 0) {
|
||
e.raiseError(QObject::tr("MSCX error at line %1: invalid measure length: %2").arg(e.lineNumber()).arg(_len.toString()));
|
||
return;
|
||
}
|
||
score()->sigmap()->add(tick().ticks(), SigEvent(_len, _timesig));
|
||
score()->sigmap()->add((tick() + ticks()).ticks(), SigEvent(_timesig));
|
||
}
|
||
else
|
||
irregular = false;
|
||
|
||
while (e.readNextStartElement()) {
|
||
const QStringRef& tag(e.name());
|
||
|
||
if (tag == "voice") {
|
||
e.setTrack(nextTrack++);
|
||
e.setTick(tick());
|
||
readVoice(e, staffIdx, irregular);
|
||
}
|
||
else if (tag == "Image") {
|
||
if (MScore::noImages)
|
||
e.skipCurrentElement();
|
||
else {
|
||
Element* el = Element::name2Element(tag, score());
|
||
el->setTrack(staffIdx * VOICES);
|
||
el->read(e);
|
||
add(el);
|
||
}
|
||
}
|
||
else if (tag == "Marker" || tag == "Jump") {
|
||
Element* el = Element::name2Element(tag, score());
|
||
el->setTrack(e.track());
|
||
el->read(e);
|
||
add(el);
|
||
}
|
||
else if (tag == "stretch") {
|
||
double val = e.readDouble();
|
||
if (val < 0.0)
|
||
val = 0;
|
||
setUserStretch(val);
|
||
}
|
||
else if (tag == "noOffset")
|
||
setNoOffset(e.readInt());
|
||
else if (tag == "measureNumberMode")
|
||
setMeasureNumberMode(MeasureNumberMode(e.readInt()));
|
||
else if (tag == "irregular")
|
||
setIrregular(e.readBool());
|
||
else if (tag == "breakMultiMeasureRest")
|
||
_breakMultiMeasureRest = e.readBool();
|
||
else if (tag == "startRepeat") {
|
||
setRepeatStart(true);
|
||
e.readNext();
|
||
}
|
||
else if (tag == "endRepeat") {
|
||
_repeatCount = e.readInt();
|
||
setRepeatEnd(true);
|
||
}
|
||
else if (tag == "vspacer" || tag == "vspacerDown") {
|
||
if (!_mstaves[staffIdx]->vspacerDown()) {
|
||
Spacer* spacer = new Spacer(score());
|
||
spacer->setSpacerType(SpacerType::DOWN);
|
||
spacer->setTrack(staffIdx * VOICES);
|
||
add(spacer);
|
||
}
|
||
_mstaves[staffIdx]->vspacerDown()->setGap(e.readDouble() * _spatium);
|
||
}
|
||
else if (tag == "vspacerFixed") {
|
||
if (!_mstaves[staffIdx]->vspacerDown()) {
|
||
Spacer* spacer = new Spacer(score());
|
||
spacer->setSpacerType(SpacerType::FIXED);
|
||
spacer->setTrack(staffIdx * VOICES);
|
||
add(spacer);
|
||
}
|
||
_mstaves[staffIdx]->vspacerDown()->setGap(e.readDouble() * _spatium);
|
||
}
|
||
else if (tag == "vspacerUp") {
|
||
if (!_mstaves[staffIdx]->vspacerUp()) {
|
||
Spacer* spacer = new Spacer(score());
|
||
spacer->setSpacerType(SpacerType::UP);
|
||
spacer->setTrack(staffIdx * VOICES);
|
||
add(spacer);
|
||
}
|
||
_mstaves[staffIdx]->vspacerUp()->setGap(e.readDouble() * _spatium);
|
||
}
|
||
else if (tag == "visible")
|
||
_mstaves[staffIdx]->setVisible(e.readInt());
|
||
else if ((tag == "slashStyle") || (tag == "stemless"))
|
||
_mstaves[staffIdx]->setStemless(e.readInt());
|
||
else if (tag == "SystemDivider") {
|
||
SystemDivider* sd = new SystemDivider(score());
|
||
sd->read(e);
|
||
add(sd);
|
||
}
|
||
else if (tag == "multiMeasureRest") {
|
||
_mmRestCount = e.readInt();
|
||
// set tick to previous measure
|
||
setTick(e.lastMeasure()->tick());
|
||
e.setTick(e.lastMeasure()->tick());
|
||
}
|
||
else if (tag == "MeasureNumber") {
|
||
MeasureNumber* noText = new MeasureNumber(score());
|
||
noText->read(e);
|
||
noText->setTrack(e.track());
|
||
add(noText);
|
||
}
|
||
else if (MeasureBase::readProperties(e))
|
||
;
|
||
else
|
||
e.unknown();
|
||
}
|
||
e.checkConnectors();
|
||
if (isMMRest()) {
|
||
Measure* lm = e.lastMeasure();
|
||
e.setTick(lm->tick() + lm->ticks());
|
||
}
|
||
e.setCurrentMeasure(nullptr);
|
||
|
||
connectTremolo();
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// Measure::readVoice
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::readVoice(XmlReader& e, int staffIdx, bool irregular)
|
||
{
|
||
Segment* segment = nullptr;
|
||
QList<Chord*> graceNotes;
|
||
Beam* startingBeam = nullptr;
|
||
Tuplet* tuplet = nullptr;
|
||
Fermata* fermata = nullptr;
|
||
|
||
Staff* staff = score()->staff(staffIdx);
|
||
Fraction timeStretch(staff->timeStretch(tick()));
|
||
|
||
while (e.readNextStartElement()) {
|
||
const QStringRef& tag(e.name());
|
||
|
||
if (tag == "location") {
|
||
Location loc = Location::relative();
|
||
loc.read(e);
|
||
e.setLocation(loc);
|
||
}
|
||
else if (tag == "tick") { // obsolete?
|
||
qDebug("read midi tick");
|
||
e.setTick(Fraction::fromTicks(score()->fileDivision(e.readInt())));
|
||
}
|
||
else if (tag == "BarLine") {
|
||
BarLine* barLine = new BarLine(score());
|
||
barLine->setTrack(e.track());
|
||
barLine->read(e);
|
||
//
|
||
// StartRepeatBarLine: at rtick == 0, always BarLineType::START_REPEAT
|
||
// BarLine: in the middle of a measure, has no semantic
|
||
// EndBarLine: at the end of a measure
|
||
// BeginBarLine: first segment of a measure, systemic barline
|
||
|
||
SegmentType st = SegmentType::Invalid;
|
||
Fraction t = e.tick() - tick();
|
||
if (t.isNotZero() && (t != ticks()))
|
||
st = SegmentType::BarLine;
|
||
else if (barLine->barLineType() == BarLineType::START_REPEAT && t.isZero())
|
||
st = SegmentType::StartRepeatBarLine;
|
||
else if (barLine->barLineType() == BarLineType::START_REPEAT && t == ticks()) {
|
||
// old version, ignore
|
||
delete barLine;
|
||
barLine = 0;
|
||
}
|
||
else if (t.isZero() && segment == 0)
|
||
st = SegmentType::BeginBarLine;
|
||
else
|
||
st = SegmentType::EndBarLine;
|
||
if (barLine) {
|
||
segment = getSegmentR(st, t);
|
||
segment->add(barLine);
|
||
barLine->layout();
|
||
}
|
||
if (fermata) {
|
||
segment->add(fermata);
|
||
fermata = nullptr;
|
||
}
|
||
}
|
||
else if (tag == "Chord") {
|
||
Chord* chord = new Chord(score());
|
||
chord->setTrack(e.track());
|
||
chord->read(e);
|
||
if (startingBeam) {
|
||
startingBeam->add(chord); // also calls chord->setBeam(startingBeam)
|
||
startingBeam = nullptr;
|
||
}
|
||
// if (tuplet && !chord->isGrace())
|
||
// chord->readAddTuplet(tuplet);
|
||
segment = getSegment(SegmentType::ChordRest, e.tick());
|
||
if (chord->noteType() != NoteType::NORMAL)
|
||
graceNotes.push_back(chord);
|
||
else {
|
||
segment->add(chord);
|
||
for (int i = 0; i < graceNotes.size(); ++i) {
|
||
Chord* gc = graceNotes[i];
|
||
gc->setGraceIndex(i);
|
||
chord->add(gc);
|
||
}
|
||
graceNotes.clear();
|
||
if (tuplet)
|
||
tuplet->add(chord);
|
||
e.incTick(chord->actualTicks());
|
||
}
|
||
if (fermata) {
|
||
segment->add(fermata);
|
||
fermata = nullptr;
|
||
}
|
||
}
|
||
else if (tag == "Rest") {
|
||
Rest* rest = new Rest(score());
|
||
rest->setDurationType(TDuration::DurationType::V_MEASURE);
|
||
rest->setTicks(timesig()/timeStretch);
|
||
rest->setTrack(e.track());
|
||
rest->read(e);
|
||
if (startingBeam) {
|
||
startingBeam->add(rest); // also calls rest->setBeam(startingBeam)
|
||
startingBeam = nullptr;
|
||
}
|
||
segment = getSegment(SegmentType::ChordRest, e.tick());
|
||
segment->add(rest);
|
||
if (fermata) {
|
||
segment->add(fermata);
|
||
fermata = nullptr;
|
||
}
|
||
|
||
if (!rest->ticks().isValid()) // hack
|
||
rest->setTicks(timesig()/timeStretch);
|
||
|
||
if (tuplet)
|
||
tuplet->add(rest);
|
||
e.incTick(rest->actualTicks());
|
||
}
|
||
else if (tag == "Breath") {
|
||
Breath* breath = new Breath(score());
|
||
breath->setTrack(e.track());
|
||
breath->read(e);
|
||
segment = getSegment(SegmentType::Breath, e.tick());
|
||
segment->add(breath);
|
||
}
|
||
else if (tag == "Spanner")
|
||
Spanner::readSpanner(e, this, e.track());
|
||
else if (tag == "RepeatMeasure") {
|
||
RepeatMeasure* rm = new RepeatMeasure(score());
|
||
rm->setTrack(e.track());
|
||
rm->read(e);
|
||
segment = getSegment(SegmentType::ChordRest, e.tick());
|
||
segment->add(rm);
|
||
e.incTick(ticks());
|
||
}
|
||
else if (tag == "Clef") {
|
||
Clef* clef = new Clef(score());
|
||
clef->setTrack(e.track());
|
||
clef->read(e);
|
||
clef->setGenerated(false);
|
||
|
||
// there may be more than one clef segment for same tick position
|
||
// the first clef may be missing and is added later in layout
|
||
|
||
bool header;
|
||
if (e.tick() != tick())
|
||
header = false;
|
||
else if (!segment)
|
||
header = true;
|
||
else {
|
||
header = true;
|
||
for (Segment* s = _segments.first(); s && s->rtick().isZero(); s = s->next()) {
|
||
if (s->isKeySigType() || s->isTimeSigType()) {
|
||
// hack: there may be other segment types which should
|
||
// generate a clef at current position
|
||
header = false;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
segment = getSegment(header ? SegmentType::HeaderClef : SegmentType::Clef, e.tick());
|
||
segment->add(clef);
|
||
}
|
||
else if (tag == "TimeSig") {
|
||
TimeSig* ts = new TimeSig(score());
|
||
ts->setTrack(e.track());
|
||
ts->read(e);
|
||
// if time sig not at beginning of measure => courtesy time sig
|
||
Fraction currTick = e.tick();
|
||
bool courtesySig = (currTick > tick());
|
||
if (courtesySig) {
|
||
// if courtesy sig., just add it without map processing
|
||
segment = getSegment(SegmentType::TimeSigAnnounce, currTick);
|
||
segment->add(ts);
|
||
}
|
||
else {
|
||
// if 'real' time sig., do full process
|
||
segment = getSegment(SegmentType::TimeSig, currTick);
|
||
segment->add(ts);
|
||
|
||
timeStretch = ts->stretch().reduced();
|
||
_timesig = ts->sig() / timeStretch;
|
||
|
||
if (irregular) {
|
||
score()->sigmap()->add(tick().ticks(), SigEvent(_len, _timesig));
|
||
score()->sigmap()->add((tick() + ticks()).ticks(), SigEvent(_timesig));
|
||
}
|
||
else {
|
||
_len = _timesig;
|
||
score()->sigmap()->add(tick().ticks(), SigEvent(_timesig));
|
||
}
|
||
}
|
||
}
|
||
else if (tag == "KeySig") {
|
||
KeySig* ks = new KeySig(score());
|
||
ks->setTrack(e.track());
|
||
ks->read(e);
|
||
Fraction curTick = e.tick();
|
||
if (!ks->isCustom() && !ks->isAtonal() && ks->key() == Key::C && curTick.isZero()) {
|
||
// ignore empty key signature
|
||
qDebug("remove keysig c at tick 0");
|
||
}
|
||
else {
|
||
// if key sig not at beginning of measure => courtesy key sig
|
||
bool courtesySig = (curTick == endTick());
|
||
segment = getSegment(courtesySig ? SegmentType::KeySigAnnounce : SegmentType::KeySig, curTick);
|
||
segment->add(ks);
|
||
if (!courtesySig)
|
||
staff->setKey(curTick, ks->keySigEvent());
|
||
}
|
||
}
|
||
else if (tag == "Text") {
|
||
StaffText* t = new StaffText(score());
|
||
t->setTrack(e.track());
|
||
t->read(e);
|
||
if (t->empty()) {
|
||
qDebug("==reading empty text: deleted");
|
||
delete t;
|
||
}
|
||
else {
|
||
segment = getSegment(SegmentType::ChordRest, e.tick());
|
||
segment->add(t);
|
||
}
|
||
}
|
||
|
||
//----------------------------------------------------
|
||
// Annotation
|
||
|
||
else if (tag == "Dynamic") {
|
||
Dynamic* dyn = new Dynamic(score());
|
||
dyn->setTrack(e.track());
|
||
dyn->read(e);
|
||
segment = getSegment(SegmentType::ChordRest, e.tick());
|
||
segment->add(dyn);
|
||
}
|
||
else if (tag == "Harmony"
|
||
|| tag == "FretDiagram"
|
||
|| tag == "TremoloBar"
|
||
|| tag == "Symbol"
|
||
|| tag == "Tempo"
|
||
|| tag == "StaffText"
|
||
|| tag == "Sticking"
|
||
|| tag == "SystemText"
|
||
|| tag == "RehearsalMark"
|
||
|| tag == "InstrumentChange"
|
||
|| tag == "StaffState"
|
||
|| tag == "FiguredBass"
|
||
) {
|
||
Element* el = Element::name2Element(tag, score());
|
||
// hack - needed because tick tags are unreliable in 1.3 scores
|
||
// for symbols attached to anything but a measure
|
||
el->setTrack(e.track());
|
||
el->read(e);
|
||
segment = getSegment(SegmentType::ChordRest, e.tick());
|
||
segment->add(el);
|
||
}
|
||
else if (tag == "Fermata") {
|
||
fermata = new Fermata(score());
|
||
fermata->setTrack(e.track());
|
||
fermata->setPlacement(fermata->track() & 1 ? Placement::BELOW : Placement::ABOVE);
|
||
fermata->read(e);
|
||
}
|
||
// There could be an Image here if the score was saved with an earlier version of MuseScore 3.
|
||
// This image would not have been visible upon reload. Let's read it in and add it directly
|
||
// to the measure so that it can be displayed.
|
||
else if (tag == "Image") {
|
||
if (MScore::noImages)
|
||
e.skipCurrentElement();
|
||
else {
|
||
Element* el = Element::name2Element(tag, score());
|
||
el->setTrack(e.track());
|
||
el->read(e);
|
||
add(el);
|
||
}
|
||
}
|
||
//----------------------------------------------------
|
||
else if (tag == "Tuplet") {
|
||
Tuplet* oldTuplet = tuplet;
|
||
tuplet = new Tuplet(score());
|
||
tuplet->setTrack(e.track());
|
||
tuplet->setTick(e.tick());
|
||
tuplet->setParent(this);
|
||
tuplet->read(e);
|
||
if (oldTuplet)
|
||
oldTuplet->add(tuplet);
|
||
}
|
||
else if (tag == "endTuplet") {
|
||
if (!tuplet) {
|
||
qDebug("Measure::read: encountered <endTuplet/> when no tuplet was started");
|
||
e.skipCurrentElement();
|
||
continue;
|
||
}
|
||
Tuplet* oldTuplet = tuplet;
|
||
tuplet = tuplet->tuplet();
|
||
if (oldTuplet->elements().empty()) {
|
||
// this should not happen and is a sign of input file corruption
|
||
qDebug("Measure:read: empty tuplet in measure index=%d, input file corrupted?", e.currentMeasureIndex());
|
||
if (tuplet)
|
||
tuplet->remove(oldTuplet);
|
||
delete oldTuplet;
|
||
}
|
||
e.readNext();
|
||
}
|
||
else if (tag == "Beam") {
|
||
Beam* beam = new Beam(score());
|
||
beam->setTrack(e.track());
|
||
beam->read(e);
|
||
beam->setParent(0);
|
||
if (startingBeam) {
|
||
qDebug("The read beam was not used");
|
||
delete startingBeam;
|
||
}
|
||
startingBeam = beam;
|
||
}
|
||
else if (tag == "Segment" && segment)
|
||
segment->read(e);
|
||
else if (tag == "Ambitus") {
|
||
Ambitus* range = new Ambitus(score());
|
||
range->read(e);
|
||
segment = getSegment(SegmentType::Ambitus, e.tick());
|
||
range->setParent(segment); // a parent segment is needed for setTrack() to work
|
||
range->setTrack(trackZeroVoice(e.track()));
|
||
segment->add(range);
|
||
}
|
||
else
|
||
e.unknown();
|
||
}
|
||
if (startingBeam) {
|
||
qDebug("The read beam was not used");
|
||
delete startingBeam;
|
||
}
|
||
if (tuplet) {
|
||
qDebug("Measure:readVoice: measure index=%d, <endTuplet/> not found", e.currentMeasureIndex());
|
||
if (tuplet->elements().empty()) {
|
||
if (tuplet->tuplet())
|
||
tuplet->tuplet()->remove(tuplet);
|
||
delete tuplet;
|
||
}
|
||
}
|
||
if (fermata) {
|
||
SegmentType st = (e.tick() == endTick() ? SegmentType::EndBarLine : SegmentType::ChordRest);
|
||
segment = getSegment(st, e.tick());
|
||
segment->add(fermata);
|
||
fermata = nullptr;
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// Measure::readAddConnector
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::readAddConnector(ConnectorInfoReader* info, bool pasteMode)
|
||
{
|
||
const ElementType type = info->type();
|
||
switch(type) {
|
||
case ElementType::HAIRPIN:
|
||
case ElementType::PEDAL:
|
||
case ElementType::OTTAVA:
|
||
case ElementType::TRILL:
|
||
case ElementType::TEXTLINE:
|
||
case ElementType::LET_RING:
|
||
case ElementType::VIBRATO:
|
||
case ElementType::PALM_MUTE:
|
||
case ElementType::VOLTA:
|
||
{
|
||
Spanner* sp = toSpanner(info->connector());
|
||
const Location& l = info->location();
|
||
Fraction lTick = l.frac();
|
||
Fraction spTick = pasteMode ? lTick : (tick() + lTick);
|
||
if (info->isStart()) {
|
||
sp->setTrack(l.track());
|
||
sp->setTick(spTick);
|
||
score()->addSpanner(sp);
|
||
}
|
||
else if (info->isEnd()) {
|
||
sp->setTrack2(l.track());
|
||
sp->setTick2(spTick);
|
||
}
|
||
}
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// visible
|
||
//---------------------------------------------------------
|
||
|
||
bool Measure::visible(int staffIdx) const
|
||
{
|
||
if (staffIdx >= score()->staves().size()) {
|
||
qDebug("Measure::visible: bad staffIdx: %d", staffIdx);
|
||
return false;
|
||
}
|
||
if (system() && (system()->staves()->empty() || !system()->staff(staffIdx)->show()))
|
||
return false;
|
||
if (score()->staff(staffIdx)->cutaway() && isEmpty(staffIdx))
|
||
return false;
|
||
return score()->staff(staffIdx)->show() && _mstaves[staffIdx]->visible();
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// stemless
|
||
//---------------------------------------------------------
|
||
|
||
bool Measure::stemless(int staffIdx) const
|
||
{
|
||
const Staff* staff = score()->staff(staffIdx);
|
||
return staff->stemless(tick()) || _mstaves[staffIdx]->stemless() || staff->staffType(tick())->stemless();
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// isFinalMeasureOfSection
|
||
// returns true if this measure is final actual measure of a section
|
||
// takes into consideration fact that subsequent measures base objects
|
||
// may have section break before encountering next actual measure
|
||
//---------------------------------------------------------
|
||
|
||
bool Measure::isFinalMeasureOfSection() const
|
||
{
|
||
const MeasureBase* mb = static_cast<const MeasureBase*>(this);
|
||
|
||
do {
|
||
if (mb->sectionBreak())
|
||
return true;
|
||
|
||
mb = mb->next();
|
||
} while (mb && !mb->isMeasure()); // loop until reach next actual measure or end of score
|
||
|
||
return false;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// isAnacrusis
|
||
//---------------------------------------------------------
|
||
|
||
bool Measure::isAnacrusis() const
|
||
{
|
||
TimeSigFrac timeSig = score()->sigmap()->timesig(tick().ticks()).nominal();
|
||
return irregular() && ticks() < Fraction::fromTicks(timeSig.ticksPerMeasure());
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// isFirstInSystem
|
||
//---------------------------------------------------------
|
||
|
||
bool Measure::isFirstInSystem() const
|
||
{
|
||
IF_ASSERT_FAILED(system()) {
|
||
return false;
|
||
}
|
||
return system()->firstMeasure() == this;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// scanElements
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::scanElements(void* data, void (*func)(void*, Element*), bool all)
|
||
{
|
||
MeasureBase::scanElements(data, func, all);
|
||
|
||
int nstaves = score()->nstaves();
|
||
for (int staffIdx = 0; staffIdx < nstaves; ++staffIdx) {
|
||
if (!all && !(visible(staffIdx) && score()->staff(staffIdx)->show()))
|
||
continue;
|
||
MStaff* ms = _mstaves[staffIdx];
|
||
func(data, ms->lines());
|
||
if (ms->vspacerUp())
|
||
func(data, ms->vspacerUp());
|
||
if (ms->vspacerDown())
|
||
func(data, ms->vspacerDown());
|
||
if (ms->noText())
|
||
func(data, ms->noText());
|
||
}
|
||
|
||
for (Segment* s = first(); s; s = s->next()) {
|
||
if (!s->enabled())
|
||
continue;
|
||
s->scanElements(data, func, all);
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// connectTremolo
|
||
/// Connect two-notes tremolo and update duration types
|
||
/// for the involved chords.
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::connectTremolo()
|
||
{
|
||
const int ntracks = score()->ntracks();
|
||
constexpr SegmentType st = SegmentType::ChordRest;
|
||
for (Segment* s = first(st); s; s = s->next(st)) {
|
||
for (int i = 0; i < ntracks; ++i) {
|
||
Element* e = s->element(i);
|
||
if (!e || !e->isChord())
|
||
continue;
|
||
|
||
Chord* c = toChord(e);
|
||
Tremolo* tremolo = c->tremolo();
|
||
if (tremolo && tremolo->twoNotes()) {
|
||
// Ensure correct duration type for chord
|
||
c->setDurationType(tremolo->durationType());
|
||
|
||
// If it is the first tremolo's chord, find the second
|
||
// chord for tremolo, if needed.
|
||
if (!tremolo->chord1())
|
||
tremolo->setChords(c, tremolo->chord2());
|
||
else if (tremolo->chord1() != c || tremolo->chord2())
|
||
continue;
|
||
|
||
for (Segment* ls = s->next(st); ls; ls = ls->next(st)) {
|
||
if (Element* element = ls->element(i)) {
|
||
if (!element->isChord()) {
|
||
qDebug("cannot connect tremolo");
|
||
continue;
|
||
}
|
||
Chord* nc = toChord(element);
|
||
tremolo->setChords(c, nc);
|
||
nc->setTremolo(tremolo);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// createVoice
|
||
// Create a voice on demand by filling the measure
|
||
// with a whole measure rest.
|
||
// Check if there are any chord/rests in track; if
|
||
// not create a whole measure rest
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::createVoice(int track)
|
||
{
|
||
for (Segment* s = first(); s; s = s->next()) {
|
||
if (s->segmentType() != SegmentType::ChordRest)
|
||
continue;
|
||
if (s->element(track) == 0)
|
||
score()->setRest(s->tick(), track, ticks(), true, 0);
|
||
break;
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// sortStaves
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::sortStaves(QList<int>& dst)
|
||
{
|
||
std::vector<MStaff*> ms;
|
||
for (int idx : dst)
|
||
ms.push_back(_mstaves[idx]);
|
||
_mstaves = ms;
|
||
|
||
for (unsigned staffIdx = 0; staffIdx < _mstaves.size(); ++staffIdx)
|
||
_mstaves[staffIdx]->lines()->setTrack(staffIdx * VOICES);
|
||
for (Segment& s : _segments)
|
||
s.sortStaves(dst);
|
||
|
||
for (Element* e : el()) {
|
||
if (e->track() == -1 || e->systemFlag())
|
||
continue;
|
||
int voice = e->voice();
|
||
int staffIdx = e->staffIdx();
|
||
int idx = dst.indexOf(staffIdx);
|
||
e->setTrack(idx * VOICES + voice);
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// exchangeVoice
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::exchangeVoice(int strack, int dtrack, int staffIdx)
|
||
{
|
||
for (Segment* s = first(SegmentType::ChordRest); s; s = s->next(SegmentType::ChordRest)) {
|
||
s->swapElements(strack, dtrack);
|
||
}
|
||
|
||
auto spanners = score()->spannerMap().findOverlapping(tick().ticks(), endTick().ticks()-1);
|
||
Fraction start = tick();
|
||
Fraction end = start + ticks();
|
||
for (auto i = spanners.begin(); i < spanners.end(); i++) {
|
||
Spanner* sp = i->value;
|
||
Fraction spStart = sp->tick();
|
||
Fraction spEnd = spStart + sp->ticks();
|
||
qDebug("Start %d End %d Diff %d \n Measure Start %d End %d", spStart.ticks(), spEnd.ticks(), (spEnd-spStart).ticks(), start.ticks(), end.ticks());
|
||
if (sp->isSlur() && (spStart >= start || spEnd < end)) {
|
||
if (sp->track() == strack && spStart >= start){
|
||
sp->setTrack(dtrack);
|
||
}
|
||
else if (sp->track() == dtrack && spStart >= start){
|
||
sp->setTrack(strack);
|
||
}
|
||
if (sp->track2() == strack && spEnd < end){
|
||
sp->setTrack2(dtrack);
|
||
}
|
||
else if (sp->track2() == dtrack && spEnd < end){
|
||
sp->setTrack2(strack);
|
||
}
|
||
}
|
||
}
|
||
checkMultiVoices(staffIdx); // probably true, but check for invisible notes & rests
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// checkMultiVoices
|
||
/// Check for more than on voice in this measure and staff and
|
||
/// set MStaff->hasVoices
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::checkMultiVoices(int staffIdx)
|
||
{
|
||
if (hasVoices(staffIdx, tick(), ticks()))
|
||
_mstaves[staffIdx]->setHasVoices(true);
|
||
else
|
||
_mstaves[staffIdx]->setHasVoices(false);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// hasVoices
|
||
//---------------------------------------------------------
|
||
|
||
bool Measure::hasVoices(int staffIdx, Fraction stick, Fraction len) const
|
||
{
|
||
int strack = staffIdx * VOICES + 1;
|
||
int etrack = staffIdx * VOICES + VOICES;
|
||
Fraction etick = stick + len;
|
||
|
||
for (Segment* s = first(SegmentType::ChordRest); s; s = s->next(SegmentType::ChordRest)) {
|
||
if (s->tick() >= etick)
|
||
break;
|
||
for (int track = strack; track < etrack; ++track) {
|
||
ChordRest* cr = toChordRest(s->element(track));
|
||
if (cr) {
|
||
if (cr->tick() + cr->actualTicks() <= stick)
|
||
continue;
|
||
bool v = false;
|
||
if (cr->isChord()) {
|
||
// consider chord visible if any note is visible
|
||
Chord* c = toChord(cr);
|
||
for (Note* n : c->notes()) {
|
||
if (n->visible()) {
|
||
v = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
else if (cr->isRest())
|
||
v = cr->visible() && !toRest(cr)->isGap();
|
||
if (v)
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// hasVoice
|
||
//---------------------------------------------------------
|
||
|
||
bool Measure::hasVoice(int track) const
|
||
{
|
||
if (track >= score()->ntracks())
|
||
return false;
|
||
for (Segment* s = first(); s; s = s->next()) {
|
||
if (s->segmentType() != SegmentType::ChordRest)
|
||
continue;
|
||
if (s->element(track))
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
//-------------------------------------------------------------------
|
||
// isEmpty
|
||
/// Check if the measure is filled by a full-measure rest, or is
|
||
/// full of rests on this staff, that may have fermatas on them.
|
||
/// If staff is -1, then check for all staves.
|
||
//-------------------------------------------------------------------
|
||
|
||
bool Measure::isEmpty(int staffIdx) const
|
||
{
|
||
int strack;
|
||
int etrack;
|
||
if (staffIdx < 0) {
|
||
strack = 0;
|
||
etrack = score()->nstaves() * VOICES;
|
||
}
|
||
else {
|
||
strack = staffIdx * VOICES;
|
||
etrack = strack + VOICES;
|
||
}
|
||
for (Segment* s = first(SegmentType::ChordRest); s; s = s->next(SegmentType::ChordRest)) {
|
||
for (int track = strack; track < etrack; ++track) {
|
||
Element* e = s->element(track);
|
||
if (e && !e->isRest())
|
||
return false;
|
||
}
|
||
for (Element* a : s->annotations()) {
|
||
if (!a || a->systemFlag() || !a->visible() || a->isFermata())
|
||
continue;
|
||
int atrack = a->track();
|
||
if (atrack >= strack && atrack < etrack)
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// isFullMeasureRest
|
||
// Check for an empty measure, filled with full measure
|
||
// rests.
|
||
//---------------------------------------------------------
|
||
|
||
bool Measure::isFullMeasureRest() const
|
||
{
|
||
int strack = 0;
|
||
int etrack = score()->nstaves() * VOICES;
|
||
|
||
Segment* s = first(SegmentType::ChordRest);
|
||
for (int track = strack; track < etrack; ++track) {
|
||
Element* e = s->element(track);
|
||
if (e) {
|
||
if (!e->isRest())
|
||
return false;
|
||
Rest* rest = toRest(e);
|
||
if (rest->durationType().type() != TDuration::DurationType::V_MEASURE)
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// isRepeatMeasure
|
||
//---------------------------------------------------------
|
||
|
||
bool Measure::isRepeatMeasure(const Staff* staff) const
|
||
{
|
||
int staffIdx = staff->idx();
|
||
int strack = staffIdx * VOICES;
|
||
int etrack = (staffIdx + 1) * VOICES;
|
||
Segment* s = first(SegmentType::ChordRest);
|
||
|
||
if (s == 0)
|
||
return false;
|
||
|
||
for (int track = strack; track < etrack; ++track) {
|
||
Element* e = s->element(track);
|
||
if (e && e->isRepeatMeasure())
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// isEmpty
|
||
//---------------------------------------------------------
|
||
|
||
bool Measure::empty() const
|
||
{
|
||
if (irregular())
|
||
return false;
|
||
int n = 0;
|
||
int tracks = int(_mstaves.size()) * VOICES;
|
||
static const SegmentType st = SegmentType::ChordRest ;
|
||
for (const Segment* s = first(st); s; s = s->next(st)) {
|
||
bool restFound = false;
|
||
for (int track = 0; track < tracks; ++track) {
|
||
if ((track % VOICES) == 0 && !score()->staff(track/VOICES)->show()) {
|
||
track += VOICES-1;
|
||
continue;
|
||
}
|
||
if (s->element(track)) {
|
||
if (!s->element(track)->isRest())
|
||
return false;
|
||
restFound = true;
|
||
}
|
||
}
|
||
if (restFound)
|
||
++n;
|
||
// measure is not empty if there is more than one rest
|
||
if (n > 1)
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// isOnlyRests
|
||
//---------------------------------------------------------
|
||
|
||
bool Measure::isOnlyRests(int track) const
|
||
{
|
||
static const SegmentType st = SegmentType::ChordRest;
|
||
for (const Segment* s = first(st); s; s = s->next(st)) {
|
||
if (s->segmentType() != st || !s->element(track))
|
||
continue;
|
||
if (!s->element(track)->isRest())
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// isOnlyDeletedRests
|
||
//---------------------------------------------------------
|
||
|
||
bool Measure::isOnlyDeletedRests(int track) const
|
||
{
|
||
static const SegmentType st { SegmentType::ChordRest };
|
||
for (const Segment* s = first(st); s; s = s->next(st)) {
|
||
if (s->segmentType() != st || !s->element(track))
|
||
continue;
|
||
if (s->element(track)->isRest() ? !toRest(s->element(track))->isGap() : !s->element(track)->isRest())
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// stretchedLen
|
||
//---------------------------------------------------------
|
||
|
||
Fraction Measure::stretchedLen(Staff* staff) const
|
||
{
|
||
return ticks() * staff->timeStretch(tick());
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// cloneMeasure
|
||
//---------------------------------------------------------
|
||
|
||
Measure* Measure::cloneMeasure(Score* sc, const Fraction& tick, TieMap* tieMap)
|
||
{
|
||
Measure* m = new Measure(sc);
|
||
m->_timesig = _timesig;
|
||
m->_len = _len;
|
||
m->_repeatCount = _repeatCount;
|
||
|
||
Q_ASSERT(sc->staves().size() >= int(_mstaves.size())); // destination score we're cloning into must have at least as many staves as measure being cloned
|
||
|
||
m->setNo(no());
|
||
m->setNoOffset(noOffset());
|
||
m->setIrregular(irregular());
|
||
m->_userStretch = _userStretch;
|
||
m->_breakMultiMeasureRest = _breakMultiMeasureRest;
|
||
m->_playbackCount = _playbackCount;
|
||
|
||
m->setTick(tick);
|
||
m->setLineBreak(lineBreak());
|
||
m->setPageBreak(pageBreak());
|
||
m->setSectionBreak(sectionBreak() ? new LayoutBreak(*sectionBreakElement()) : 0);
|
||
|
||
m->setHeader(header()); m->setTrailer(trailer());
|
||
|
||
int tracks = sc->nstaves() * VOICES;
|
||
TupletMap tupletMap;
|
||
|
||
for (Segment* oseg = first(); oseg; oseg = oseg->next()) {
|
||
Segment* s = new Segment(m, oseg->segmentType(), oseg->rtick());
|
||
s->setEnabled(oseg->enabled()); s->setVisible(oseg->visible());
|
||
s->setHeader(oseg->header()); s->setTrailer(oseg->trailer());
|
||
|
||
m->_segments.push_back(s);
|
||
for (int track = 0; track < tracks; ++track) {
|
||
Element* oe = oseg->element(track);
|
||
for (Element* e : oseg->annotations()) {
|
||
if (e->generated() || e->track() != track)
|
||
continue;
|
||
Element* ne = e->clone();
|
||
ne->setTrack(track);
|
||
ne->setOffset(e->offset());
|
||
ne->setScore(sc);
|
||
s->add(ne);
|
||
}
|
||
if (!oe)
|
||
continue;
|
||
Element* ne = oe->clone();
|
||
if (oe->isChordRest()) {
|
||
ChordRest* ocr = toChordRest(oe);
|
||
ChordRest* ncr = toChordRest(ne);
|
||
Tuplet* ot = ocr->tuplet();
|
||
if (ot) {
|
||
Tuplet* nt = tupletMap.findNew(ot);
|
||
if (nt == 0) {
|
||
nt = new Tuplet(*ot);
|
||
nt->clear();
|
||
nt->setTrack(track);
|
||
nt->setScore(sc);
|
||
nt->setParent(m);
|
||
nt->setTick(m->tick() + ot->rtick());
|
||
tupletMap.add(ot, nt);
|
||
}
|
||
ncr->setTuplet(nt);
|
||
nt->add(ncr);
|
||
}
|
||
if (oe->isChord()) {
|
||
Chord* och = toChord(ocr);
|
||
Chord* nch = toChord(ncr);
|
||
size_t n = och->notes().size();
|
||
for (size_t i = 0; i < n; ++i) {
|
||
Note* on = och->notes().at(i);
|
||
Note* nn = nch->notes().at(i);
|
||
if (on->tieFor()) {
|
||
Tie* tie = on->tieFor()->clone();
|
||
tie->setScore(sc);
|
||
nn->setTieFor(tie);
|
||
tie->setStartNote(nn);
|
||
tieMap->add(on->tieFor(), tie);
|
||
}
|
||
if (on->tieBack()) {
|
||
Tie* tie = tieMap->findNew(on->tieBack());
|
||
if (tie) {
|
||
nn->setTieBack(tie);
|
||
tie->setEndNote(nn);
|
||
}
|
||
else {
|
||
qDebug("cloneMeasure: cannot find tie, track %d", track);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
ne->setOffset(oe->offset());
|
||
ne->setScore(sc);
|
||
s->add(ne);
|
||
}
|
||
}
|
||
for (Element* e : el()) {
|
||
Element* ne = e->clone();
|
||
ne->setScore(sc);
|
||
ne->setOffset(e->offset());
|
||
m->add(ne);
|
||
}
|
||
return m;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// snap
|
||
//---------------------------------------------------------
|
||
|
||
Fraction Measure::snap(const Fraction& tick, const QPointF p) const
|
||
{
|
||
Segment* s = first();
|
||
for (; s->next(); s = s->next()) {
|
||
qreal x = s->x();
|
||
qreal dx = s->next()->x() - x;
|
||
if (s->tick() == tick)
|
||
x += dx / 3.0 * 2.0;
|
||
else if (s->next()->tick() == tick)
|
||
x += dx / 3.0;
|
||
else
|
||
x += dx * .5;
|
||
if (p.x() < x)
|
||
break;
|
||
}
|
||
return s->tick();
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// snapNote
|
||
//---------------------------------------------------------
|
||
|
||
Fraction Measure::snapNote(const Fraction& /*tick*/, const QPointF p, int staff) const
|
||
{
|
||
Segment* s = first();
|
||
for (;;) {
|
||
Segment* ns = s->next();
|
||
while (ns && ns->element(staff) == 0)
|
||
ns = ns->next();
|
||
if (ns == 0)
|
||
break;
|
||
qreal x = s->x();
|
||
qreal nx = x + (ns->x() - x) * .5;
|
||
if (p.x() < nx)
|
||
break;
|
||
s = ns;
|
||
}
|
||
return s->tick();
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// searchSegment
|
||
/// Finds a segment which x position is most close to the
|
||
/// given \p x.
|
||
/// \param x The x coordinate in measure coordinates.
|
||
/// \param st Type of segments to search.
|
||
/// \param strack start of track range (strack included)
|
||
/// in which the found segment should contain elements.
|
||
/// \param etrack end of track range (etrack excluded)
|
||
/// in which the found segment should contain elements.
|
||
/// \param preferredSegment If not nullptr, will give
|
||
/// more space to the given segment when searching it by
|
||
/// coordinate.
|
||
/// \returns The segment that was found.
|
||
//---------------------------------------------------------
|
||
|
||
Segment* Measure::searchSegment(qreal x, SegmentType st, int strack, int etrack, const Segment* preferredSegment, qreal spacingFactor) const
|
||
{
|
||
const int lastTrack = etrack - 1;
|
||
for (Segment* segment = first(st); segment; segment = segment->next(st)) {
|
||
if (!segment->hasElements(strack, lastTrack))
|
||
continue;
|
||
Segment* ns = segment->next(st);
|
||
for (; ns; ns = ns->next(st)) {
|
||
if (ns->hasElements(strack, lastTrack))
|
||
break;
|
||
}
|
||
if (!ns)
|
||
return segment;
|
||
if (preferredSegment == segment) {
|
||
if (x < (segment->x() + (ns->x() - segment->x())))
|
||
return segment;
|
||
}
|
||
else if (preferredSegment == ns) {
|
||
if (x <= segment->x())
|
||
return segment;
|
||
}
|
||
else {
|
||
if (x < (segment->x() + (ns->x() - segment->x()) * spacingFactor))
|
||
return segment;
|
||
}
|
||
}
|
||
return nullptr;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// getProperty
|
||
//---------------------------------------------------------
|
||
|
||
QVariant Measure::getProperty(Pid propertyId) const
|
||
{
|
||
switch(propertyId) {
|
||
case Pid::TIMESIG_NOMINAL:
|
||
return QVariant::fromValue(_timesig);
|
||
case Pid::TIMESIG_ACTUAL:
|
||
return QVariant::fromValue(_len);
|
||
case Pid::MEASURE_NUMBER_MODE:
|
||
return int(measureNumberMode());
|
||
case Pid::BREAK_MMR:
|
||
return breakMultiMeasureRest();
|
||
case Pid::REPEAT_COUNT:
|
||
return repeatCount();
|
||
case Pid::USER_STRETCH:
|
||
return userStretch();
|
||
default:
|
||
return MeasureBase::getProperty(propertyId);
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// setProperty
|
||
//---------------------------------------------------------
|
||
|
||
bool Measure::setProperty(Pid propertyId, const QVariant& value)
|
||
{
|
||
switch (propertyId) {
|
||
case Pid::TIMESIG_NOMINAL:
|
||
_timesig = value.value<Fraction>();
|
||
break;
|
||
case Pid::TIMESIG_ACTUAL:
|
||
_len = value.value<Fraction>();
|
||
break;
|
||
case Pid::MEASURE_NUMBER_MODE:
|
||
setMeasureNumberMode(MeasureNumberMode(value.toInt()));
|
||
break;
|
||
case Pid::BREAK_MMR:
|
||
setBreakMultiMeasureRest(value.toBool());
|
||
break;
|
||
case Pid::REPEAT_COUNT:
|
||
setRepeatCount(value.toInt());
|
||
break;
|
||
case Pid::USER_STRETCH:
|
||
setUserStretch(value.toDouble());
|
||
break;
|
||
default:
|
||
return MeasureBase::setProperty(propertyId, value);
|
||
}
|
||
triggerLayout();
|
||
return true;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// propertyDefault
|
||
//---------------------------------------------------------
|
||
|
||
QVariant Measure::propertyDefault(Pid propertyId) const
|
||
{
|
||
switch(propertyId) {
|
||
case Pid::TIMESIG_NOMINAL:
|
||
case Pid::TIMESIG_ACTUAL:
|
||
return QVariant();
|
||
case Pid::MEASURE_NUMBER_MODE:
|
||
return int(MeasureNumberMode::AUTO);
|
||
case Pid::BREAK_MMR:
|
||
return false;
|
||
case Pid::REPEAT_COUNT:
|
||
return 2;
|
||
case Pid::USER_STRETCH:
|
||
return 1.0;
|
||
case Pid::NO_OFFSET:
|
||
return 0;
|
||
case Pid::IRREGULAR:
|
||
return false;
|
||
default:
|
||
break;
|
||
}
|
||
return MeasureBase::propertyDefault(propertyId);
|
||
}
|
||
|
||
//-------------------------------------------------------------------
|
||
// mmRestFirst
|
||
// this is a multi measure rest
|
||
// returns first measure of replaced sequence of empty measures
|
||
//-------------------------------------------------------------------
|
||
|
||
Measure* Measure::mmRestFirst() const
|
||
{
|
||
Q_ASSERT(isMMRest());
|
||
if (prev())
|
||
return toMeasure(prev()->next());
|
||
return score()->firstMeasure();
|
||
}
|
||
|
||
//-------------------------------------------------------------------
|
||
// mmRestLast
|
||
// this is a multi measure rest
|
||
// returns last measure of replaced sequence of empty measures
|
||
//-------------------------------------------------------------------
|
||
|
||
Measure* Measure::mmRestLast() const
|
||
{
|
||
Q_ASSERT(isMMRest());
|
||
if (next())
|
||
return toMeasure(next()->prev());
|
||
return score()->lastMeasure();
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// mmRest1
|
||
// return the multi measure rest this measure is covered
|
||
// by
|
||
//---------------------------------------------------------
|
||
|
||
const Measure* Measure::mmRest1() const
|
||
{
|
||
if (_mmRest)
|
||
return _mmRest;
|
||
if (_mmRestCount != -1)
|
||
// return const_cast<Measure*>(this);
|
||
return this;
|
||
const Measure* m = this;
|
||
while (m && !m->_mmRest)
|
||
m = m->prevMeasure();
|
||
if (m)
|
||
return const_cast<Measure*>(m->_mmRest);
|
||
return 0;
|
||
}
|
||
|
||
//-------------------------------------------------------------------
|
||
// userStretch
|
||
//-------------------------------------------------------------------
|
||
|
||
qreal Measure::userStretch() const
|
||
{
|
||
return (score()->layoutMode() == LayoutMode::FLOAT ? 1.0 : _userStretch);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// nextElementStaff
|
||
//---------------------------------------------------------
|
||
|
||
Element* Measure::nextElementStaff(int staff)
|
||
{
|
||
Element* e = score()->selection().element();
|
||
if (!e && !score()->selection().elements().isEmpty())
|
||
e = score()->selection().elements().first();
|
||
|
||
// handle measure elements
|
||
if (e->parent() == this) {
|
||
auto i = std::find(el().begin(), el().end(), e);
|
||
if (i != el().end()) {
|
||
if (++i != el().end()) {
|
||
Element* resElement = *i;
|
||
if (resElement)
|
||
return resElement;
|
||
}
|
||
}
|
||
}
|
||
|
||
for (; e && e->type() != ElementType::SEGMENT; e = e->parent()) {
|
||
;
|
||
}
|
||
Segment* seg = toSegment(e);
|
||
Segment* nextSegment = seg ? seg->next() : first();
|
||
Element* next = seg->firstElementOfSegment(nextSegment, staff);
|
||
if (next)
|
||
return next;
|
||
|
||
return score()->lastElement();
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// prevElementStaff
|
||
//---------------------------------------------------------
|
||
|
||
Element* Measure::prevElementStaff(int staff)
|
||
{
|
||
Element* e = score()->selection().element();
|
||
if (!e && !score()->selection().elements().isEmpty())
|
||
e = score()->selection().elements().first();
|
||
|
||
// handle measure elements
|
||
if (e->parent() == this) {
|
||
auto i = std::find(el().rbegin(), el().rend(), e);
|
||
if (i != el().rend()) {
|
||
if (++i != el().rend()) {
|
||
Element* resElement = *i;
|
||
if (resElement)
|
||
return resElement;
|
||
}
|
||
}
|
||
}
|
||
|
||
Measure* prevM = prevMeasureMM();
|
||
if (prevM) {
|
||
Segment* seg = prevM->last();
|
||
if (seg)
|
||
return seg->lastElement(staff);
|
||
}
|
||
return score()->firstElement();
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// accessibleInfo
|
||
//---------------------------------------------------------
|
||
|
||
QString Measure::accessibleInfo() const
|
||
{
|
||
return QString("%1: %2").arg(Element::accessibleInfo()).arg(QString::number(no() + 1));
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// stretchMeasure
|
||
// resize width of measure to targetWidth
|
||
//-----------------------------------------------------------------------------
|
||
|
||
void Measure::stretchMeasure(qreal targetWidth)
|
||
{
|
||
bbox().setWidth(targetWidth);
|
||
|
||
Fraction minTick = computeTicks();
|
||
|
||
//---------------------------------------------------
|
||
// compute stretch
|
||
//---------------------------------------------------
|
||
|
||
std::multimap<qreal, Segment*> springs;
|
||
|
||
Segment* seg = first();
|
||
while (seg && !seg->enabled())
|
||
seg = seg->next();
|
||
qreal minimumWidth = seg ? seg->x() : 0.0;
|
||
for (Segment& s : _segments) {
|
||
if (!s.enabled() || !s.visible())
|
||
continue;
|
||
Fraction t = s.ticks();
|
||
if (t.isNotZero()) {
|
||
qreal str = 1.0 + 0.865617 * log(qreal(t.ticks()) / qreal(minTick.ticks())); // .6 * log(t / minTick.ticks()) / log(2);
|
||
qreal d = s.width() / str;
|
||
s.setStretch(str);
|
||
springs.insert(std::pair<qreal, Segment*>(d, &s));
|
||
}
|
||
minimumWidth += s.width();
|
||
}
|
||
|
||
//---------------------------------------------------
|
||
// compute 1/Force for a given Extend
|
||
//---------------------------------------------------
|
||
|
||
if (targetWidth > minimumWidth) {
|
||
qreal force = 0;
|
||
qreal c = 0.0;
|
||
for (auto i = springs.begin(); i != springs.end();) {
|
||
c += i->second->stretch();
|
||
minimumWidth -= i->second->width();
|
||
qreal f = (targetWidth - minimumWidth) / c;
|
||
++i;
|
||
if (i == springs.end() || f <= i->first) {
|
||
force = f;
|
||
break;
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------
|
||
// distribute stretch to segments
|
||
//---------------------------------------------------
|
||
|
||
for (auto& i : springs) {
|
||
qreal width = force * i.second->stretch();
|
||
if (width > i.second->width())
|
||
i.second->setWidth(width);
|
||
}
|
||
|
||
//---------------------------------------------------
|
||
// move segments to final position
|
||
//---------------------------------------------------
|
||
|
||
Segment* s = first();
|
||
while (s && !s->enabled())
|
||
s = s->next();
|
||
qreal x = s->pos().x();
|
||
while (s) {
|
||
s->rxpos() = x;
|
||
x += s->width();
|
||
s = s->nextEnabled();
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------
|
||
// layout individual elements
|
||
//---------------------------------------------------
|
||
|
||
for (Segment& s : _segments) {
|
||
if (!s.enabled())
|
||
continue;
|
||
for (Element* e : s.elist()) {
|
||
if (!e)
|
||
continue;
|
||
ElementType t = e->type();
|
||
int staffIdx = e->staffIdx();
|
||
if (t == ElementType::REPEAT_MEASURE || (t == ElementType::REST && (isMMRest() || toRest(e)->isFullMeasureRest()))) {
|
||
//
|
||
// element has to be centered in free space
|
||
// x1 - left measure position of free space
|
||
// x2 - right measure position of free space
|
||
|
||
Segment* s1;
|
||
for (s1 = s.prev(); s1 && !s1->enabled(); s1 = s1->prev())
|
||
;
|
||
Segment* s2;
|
||
for (s2 = s.next(); s2; s2 = s2->next()) {
|
||
if (s2->enabled() && !s2->isChordRestType() && s2->element(staffIdx * VOICES))
|
||
break;
|
||
}
|
||
qreal x1 = s1 ? s1->x() + s1->minRight() : 0;
|
||
qreal x2 = s2 ? s2->x() - s2->minLeft() : targetWidth;
|
||
|
||
if (isMMRest()) {
|
||
Rest* rest = toRest(e);
|
||
//
|
||
// center multi measure rest
|
||
//
|
||
qreal d = score()->styleP(Sid::multiMeasureRestMargin);
|
||
qreal w = x2 - x1 - 2 * d;
|
||
|
||
rest->layoutMMRest(w);
|
||
e->setPos(x1 - s.x() + d, e->staff()->height() * .5); // center vertically in measure
|
||
s.createShape(staffIdx);
|
||
}
|
||
else { // if (rest->isFullMeasureRest()) {
|
||
//
|
||
// center full measure rest
|
||
//
|
||
e->rxpos() = (x2 - x1 - e->width()) * .5 + x1 - s.x() - e->bbox().x();
|
||
s.createShape(staffIdx); // DEBUG
|
||
}
|
||
}
|
||
else if (t == ElementType::REST)
|
||
e->rxpos() = 0;
|
||
else if (t == ElementType::CHORD) {
|
||
Chord* c = toChord(e);
|
||
c->layout2();
|
||
if (c->tremolo()) {
|
||
Tremolo* tr = c->tremolo();
|
||
Chord* c1 = tr->chord1();
|
||
Chord* c2 = tr->chord2();
|
||
if (!tr->twoNotes() || (c1 && !c1->staffMove() && c2 && !c2->staffMove()))
|
||
tr->layout();
|
||
}
|
||
}
|
||
else if (t == ElementType::BAR_LINE) {
|
||
e->rypos() = 0.0;
|
||
// for end barlines, x position was set in createEndBarLines
|
||
if (s.segmentType() != SegmentType::EndBarLine)
|
||
e->rxpos() = 0.0;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------
|
||
// computeTicks
|
||
// set ticks for all segments
|
||
// return minTick
|
||
//---------------------------------------------------
|
||
|
||
Fraction Measure::computeTicks()
|
||
{
|
||
Fraction minTick = ticks();
|
||
if (minTick <= Fraction(0,1)) {
|
||
qDebug("=====minTick %d measure %p", minTick.ticks(), this);
|
||
}
|
||
Q_ASSERT(minTick > Fraction(0,1));
|
||
|
||
Segment* ns = first();
|
||
while (ns && !ns->enabled())
|
||
ns = ns->next();
|
||
while (ns) {
|
||
Segment* s = ns;
|
||
ns = s->nextActive();
|
||
Fraction nticks = (ns ? ns->rtick() : ticks()) - s->rtick();
|
||
if (nticks.isNotZero()) {
|
||
if (nticks < minTick)
|
||
minTick = nticks;
|
||
}
|
||
s->setTicks(nticks);
|
||
}
|
||
return minTick;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// endBarLine
|
||
// return the first one
|
||
//---------------------------------------------------------
|
||
|
||
const BarLine* Measure::endBarLine() const
|
||
{
|
||
// search barline segment:
|
||
Segment* s = last();
|
||
while (s && !s->isEndBarLineType())
|
||
s = s->prev();
|
||
// search first element
|
||
if (s) {
|
||
for (const Element* e : s->elist()) {
|
||
if (e)
|
||
return toBarLine(e);
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// endBarLineType
|
||
// Assume all barlines have same type if there is more
|
||
// than one.
|
||
//---------------------------------------------------------
|
||
|
||
BarLineType Measure::endBarLineType() const
|
||
{
|
||
const BarLine* bl = endBarLine();
|
||
return bl ? bl->barLineType() : BarLineType::NORMAL;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// endBarLineType
|
||
// Assume all barlines have same visibility if there is more
|
||
// than one.
|
||
//---------------------------------------------------------
|
||
|
||
bool Measure::endBarLineVisible() const
|
||
{
|
||
const BarLine* bl = endBarLine();
|
||
return bl ? bl->visible() : true;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// triggerLayout
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::triggerLayout() const
|
||
{
|
||
if (prev() || next()) // avoid triggering layout before getting added to a score
|
||
score()->setLayout(tick(), endTick(), 0, score()->nstaves() - 1, this);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// setEndBarLineType
|
||
// Create a *generated* barline with the given type and
|
||
// properties if none exists. Modify if it exists.
|
||
// Useful for import filters.
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::setEndBarLineType(BarLineType val, int track, bool visible, QColor color)
|
||
{
|
||
Segment* seg = undoGetSegment(SegmentType::EndBarLine, endTick());
|
||
// get existing bar line for this staff, if any
|
||
BarLine* bl = toBarLine(seg->element(track));
|
||
if (!bl) {
|
||
// no suitable bar line: create a new one
|
||
bl = new BarLine(score());
|
||
bl->setParent(seg);
|
||
bl->setTrack(track);
|
||
score()->addElement(bl);
|
||
}
|
||
bl->setGenerated(false);
|
||
bl->setBarLineType(val);
|
||
bl->setVisible(visible);
|
||
bl->setColor(color.isValid() ? color : curColor());
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// barLinesSetSpan
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::barLinesSetSpan(Segment* seg)
|
||
{
|
||
int track = 0;
|
||
for (Staff* staff : score()->staves()) {
|
||
BarLine* bl = toBarLine(seg->element(track)); // get existing bar line for this staff, if any
|
||
if (bl) {
|
||
if (bl->generated()) {
|
||
bl->setSpanStaff(staff->barLineSpan());
|
||
bl->setSpanFrom(staff->barLineFrom());
|
||
bl->setSpanTo(staff->barLineTo());
|
||
}
|
||
}
|
||
else {
|
||
bl = new BarLine(score());
|
||
bl->setParent(seg);
|
||
bl->setTrack(track);
|
||
bl->setGenerated(true);
|
||
bl->setSpanStaff(staff->barLineSpan());
|
||
bl->setSpanFrom(staff->barLineFrom());
|
||
bl->setSpanTo(staff->barLineTo());
|
||
bl->layout();
|
||
score()->addElement(bl);
|
||
}
|
||
track += VOICES;
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// createEndBarLines
|
||
// actually creates or modifies barlines
|
||
// return the width change for measure
|
||
//---------------------------------------------------------
|
||
|
||
qreal Measure::createEndBarLines(bool isLastMeasureInSystem)
|
||
{
|
||
int nstaves = score()->nstaves();
|
||
Segment* seg = findSegmentR(SegmentType::EndBarLine, ticks());
|
||
Measure* nm = nextMeasure();
|
||
qreal blw = 0.0;
|
||
|
||
#if 0
|
||
#ifndef NDEBUG
|
||
computeMinWidth();
|
||
#endif
|
||
#endif
|
||
qreal oldWidth = width();
|
||
|
||
if (nm && nm->repeatStart() && !repeatEnd() && !isLastMeasureInSystem && next() == nm) {
|
||
// we may skip barline at end of a measure immediately before a start repeat:
|
||
// next measure is repeat start, this measure is not a repeat end,
|
||
// this is not last measure of system, no intervening frame
|
||
if (!seg)
|
||
return 0.0;
|
||
seg->setEnabled(false);
|
||
}
|
||
else {
|
||
BarLineType t = nm ? BarLineType::NORMAL : BarLineType::END;
|
||
if (!seg)
|
||
seg = getSegmentR(SegmentType::EndBarLine, ticks());
|
||
seg->setEnabled(true);
|
||
//
|
||
// Set flag "hasCourtesyKeySig" if this measure needs a courtesy key sig.
|
||
// This flag is later used to set a double end bar line and to actually
|
||
// create the courtesy key sig.
|
||
//
|
||
|
||
bool show = score()->styleB(Sid::genCourtesyKeysig) && !sectionBreak() && nm;
|
||
|
||
setHasCourtesyKeySig(false);
|
||
|
||
if (isLastMeasureInSystem && show) {
|
||
Fraction tick = endTick();
|
||
for (int staffIdx = 0; staffIdx < nstaves; ++staffIdx) {
|
||
Staff* staff = score()->staff(staffIdx);
|
||
KeySigEvent key1 = staff->keySigEvent(tick - Fraction::fromTicks(1));
|
||
KeySigEvent key2 = staff->keySigEvent(tick);
|
||
if (!(key1 == key2)) {
|
||
// locate a key sig. in next measure and, if found,
|
||
// check if it has court. sig turned off
|
||
Segment* s = nm->findSegment(SegmentType::KeySig, tick);
|
||
if (s) {
|
||
KeySig* ks = toKeySig(s->element(staffIdx * VOICES));
|
||
if (ks && !ks->showCourtesy())
|
||
continue;
|
||
}
|
||
setHasCourtesyKeySig(true);
|
||
t = BarLineType::DOUBLE;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
bool force = false;
|
||
if (repeatEnd()) {
|
||
t = BarLineType::END_REPEAT;
|
||
force = true;
|
||
}
|
||
else if (isLastMeasureInSystem && nextMeasure() && nextMeasure()->repeatStart()) {
|
||
t = BarLineType::NORMAL;
|
||
// force = true;
|
||
}
|
||
|
||
for (int staffIdx = 0; staffIdx < nstaves; ++staffIdx) {
|
||
int track = staffIdx * VOICES;
|
||
BarLine* bl = toBarLine(seg->element(track));
|
||
Staff* staff = score()->staff(staffIdx);
|
||
if (!bl) {
|
||
bl = new BarLine(score());
|
||
bl->setParent(seg);
|
||
bl->setTrack(track);
|
||
bl->setGenerated(true);
|
||
bl->setSpanStaff(staff->barLineSpan());
|
||
bl->setSpanFrom(staff->barLineFrom());
|
||
bl->setSpanTo(staff->barLineTo());
|
||
bl->setBarLineType(t);
|
||
score()->addElement(bl);
|
||
}
|
||
else {
|
||
// do not change bar line type if bar line is user modified
|
||
// and its not a repeat start/end barline (forced)
|
||
|
||
if (bl->generated()) {
|
||
bl->setSpanStaff(staff->barLineSpan());
|
||
bl->setSpanFrom(staff->barLineFrom());
|
||
bl->setSpanTo(staff->barLineTo());
|
||
bl->setBarLineType(t);
|
||
}
|
||
else {
|
||
if (bl->barLineType() != t) {
|
||
if (force) {
|
||
bl->undoChangeProperty(Pid::BARLINE_TYPE, QVariant::fromValue(t));
|
||
bl->setGenerated(true);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
bl->layout();
|
||
blw = qMax(blw, bl->width());
|
||
}
|
||
// right align within segment
|
||
for (int staffIdx = 0; staffIdx < nstaves; ++staffIdx) {
|
||
int track = staffIdx * VOICES;
|
||
BarLine* bl = toBarLine(seg->element(track));
|
||
if (bl)
|
||
bl->rxpos() += blw - bl->width();
|
||
}
|
||
seg->createShapes();
|
||
}
|
||
|
||
// set relative position of end barline and clef
|
||
// if end repeat, clef goes after, otherwise clef goes before
|
||
Segment* clefSeg = findSegmentR(SegmentType::Clef, ticks());
|
||
if (clefSeg) {
|
||
bool wasVisible = clefSeg->visible();
|
||
int visibleInt = 0;
|
||
for (int staffIdx = 0; staffIdx < nstaves; ++staffIdx) {
|
||
int track = staffIdx * VOICES;
|
||
Clef* clef = toClef(clefSeg->element(track));
|
||
if (clef) {
|
||
bool showCourtesy = score()->genCourtesyClef() && clef->showCourtesy(); // normally show a courtesy clef
|
||
// check if the measure is the last measure of the system or the last measure before a frame
|
||
bool lastMeasure = isLastMeasureInSystem || (nm ? !(next() == nm) : true);
|
||
if (!nm || isFinalMeasureOfSection() || (lastMeasure && !showCourtesy)) {
|
||
// hide the courtesy clef in the final measure of a section, or if the measure is the final measure of a system
|
||
// and the score style or the clef style is set to "not show courtesy clef",
|
||
// or if the clef is at the end of the very last measure of the score
|
||
clef->clear();
|
||
clefSeg->createShape(staffIdx);
|
||
if (visibleInt == 0)
|
||
visibleInt = 1;
|
||
}
|
||
else {
|
||
clef->layout();
|
||
clefSeg->createShape(staffIdx);
|
||
visibleInt = 2;
|
||
}
|
||
}
|
||
}
|
||
if (visibleInt == 2) // there is at least one visible clef in the clef segment
|
||
clefSeg->setVisible(true);
|
||
else if (visibleInt == 1) // all (courtesy) clefs in the clef segment are not visible
|
||
clefSeg->setVisible(false);
|
||
else // should never happen
|
||
qDebug("Clef Segment without Clef elements at tick %d/%d",clefSeg->tick().numerator(),clefSeg->tick().denominator());
|
||
if ((wasVisible != clefSeg->visible()) && system()) // recompute the width only if necessary
|
||
computeMinWidth();
|
||
if (seg) {
|
||
Segment* s1;
|
||
Segment* s2;
|
||
if (repeatEnd()) {
|
||
s1 = seg;
|
||
s2 = clefSeg;
|
||
}
|
||
else {
|
||
s1 = clefSeg;
|
||
s2 = seg;
|
||
}
|
||
if (s1->next() != s2) {
|
||
_segments.remove(s1);
|
||
_segments.insert(s1, s2);
|
||
}
|
||
}
|
||
}
|
||
|
||
// fix segment layout
|
||
Segment* s = seg->prevActive();
|
||
if (s) {
|
||
qreal x = s->rxpos();
|
||
computeMinWidth(s, x, false);
|
||
}
|
||
|
||
#if 0
|
||
#ifndef NDEBUG
|
||
qreal w = width();
|
||
computeMinWidth();
|
||
if (!qFuzzyCompare(w, width()))
|
||
qDebug("width mismatch %f != %f at %d", w, width(), tick());
|
||
#endif
|
||
#endif
|
||
return width() - oldWidth;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// basicStretch
|
||
//---------------------------------------------------------
|
||
|
||
qreal Measure::basicStretch() const
|
||
{
|
||
qreal stretch = userStretch() * score()->styleD(Sid::measureSpacing);
|
||
if (stretch < 1.0)
|
||
stretch = 1.0;
|
||
return stretch;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// basicWidth
|
||
//---------------------------------------------------------
|
||
|
||
qreal Measure::basicWidth() const
|
||
{
|
||
Segment* ls = last();
|
||
qreal w = (ls->x() + ls->width()) * basicStretch();
|
||
qreal minMeasureWidth = score()->styleP(Sid::minMeasureWidth);
|
||
if (w < minMeasureWidth)
|
||
w = minMeasureWidth;
|
||
return w;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// layoutWeight
|
||
//---------------------------------------------------------
|
||
|
||
int Measure::layoutWeight(int maxMMRestLength) const
|
||
{
|
||
int w = ticks().ticks();
|
||
// reduce weight of mmrests
|
||
// so the nominal width is not directly proportional to duration (still linear, just not 1:1)
|
||
// and they are not so "greedy" in taking up available space on a system
|
||
if (isMMRest()) {
|
||
int timesigTicks = timesig().ticks();
|
||
// TODO: style setting
|
||
if (maxMMRestLength) {
|
||
int maxW = timesigTicks * maxMMRestLength;
|
||
w = qMin(w, maxW);
|
||
}
|
||
w -= timesigTicks;
|
||
w = timesigTicks + w / 32;
|
||
}
|
||
return w;
|
||
}
|
||
|
||
//-------------------------------------------------------------------
|
||
// addSystemHeader
|
||
/// Add elements to make this measure suitable as the first measure
|
||
/// of a system.
|
||
// The system header can contain a starting BarLine, a Clef,
|
||
// and a KeySig
|
||
//-------------------------------------------------------------------
|
||
|
||
void Measure::addSystemHeader(bool isFirstSystem)
|
||
{
|
||
int staffIdx = 0;
|
||
Segment* kSegment = findFirstR(SegmentType::KeySig, Fraction(0,1));
|
||
Segment* cSegment = findFirstR(SegmentType::HeaderClef, Fraction(0,1));
|
||
|
||
for (const Staff* staff : score()->staves()) {
|
||
const int track = staffIdx * VOICES;
|
||
|
||
if (isFirstSystem || score()->styleB(Sid::genClef)) {
|
||
// find the clef type at the previous tick
|
||
ClefTypeList cl = staff->clefType(tick() - Fraction::fromTicks(1));
|
||
Segment* s = nullptr;
|
||
if (prevMeasure())
|
||
// look for a clef change at the end of the previous measure
|
||
s = prevMeasure()->findSegment(SegmentType::Clef, tick());
|
||
else if (isMMRest())
|
||
// look for a header clef at the beginning of the first underlying measure
|
||
s = mmRestFirst()->findFirstR(SegmentType::HeaderClef, Fraction(0,1));
|
||
if (s) {
|
||
Clef* c = toClef(s->element(track));
|
||
if (c)
|
||
cl = c->clefTypeList();
|
||
}
|
||
Clef* clef;
|
||
if (!cSegment) {
|
||
cSegment = new Segment(this, SegmentType::HeaderClef, Fraction(0,1));
|
||
cSegment->setHeader(true);
|
||
add(cSegment);
|
||
clef = 0;
|
||
}
|
||
else
|
||
clef = toClef(cSegment->element(track));
|
||
if (staff->staffType(tick())->genClef()) {
|
||
if (!clef) {
|
||
//
|
||
// create missing clef
|
||
//
|
||
clef = new Clef(score());
|
||
clef->setTrack(track);
|
||
clef->setGenerated(true);
|
||
clef->setParent(cSegment);
|
||
cSegment->add(clef);
|
||
}
|
||
if (clef->generated())
|
||
clef->setClefType(cl);
|
||
clef->setSmall(false);
|
||
clef->layout();
|
||
}
|
||
else if (clef) {
|
||
clef->parent()->remove(clef);
|
||
delete clef;
|
||
}
|
||
//cSegment->createShape(staffIdx);
|
||
cSegment->setEnabled(true);
|
||
}
|
||
else {
|
||
if (cSegment)
|
||
cSegment->setEnabled(false);
|
||
}
|
||
|
||
// keep key sigs in TABs: TABs themselves should hide them
|
||
bool needKeysig = isFirstSystem || score()->styleB(Sid::genKeysig);
|
||
|
||
// If we need a Key::C KeySig (which would be invisible) and there is
|
||
// a courtesy key sig, don’t create it and switch generated flags.
|
||
// This avoids creating an invisible KeySig which can distort layout.
|
||
|
||
KeySigEvent keyIdx = staff->keySigEvent(tick());
|
||
KeySig* ksAnnounce = 0;
|
||
if (needKeysig && (keyIdx.key() == Key::C)) {
|
||
Measure* pm = prevMeasure();
|
||
if (pm && pm->hasCourtesyKeySig()) {
|
||
Segment* ks = pm->first(SegmentType::KeySigAnnounce);
|
||
if (ks) {
|
||
ksAnnounce = toKeySig(ks->element(track));
|
||
if (ksAnnounce) {
|
||
needKeysig = false;
|
||
// if (keysig) {
|
||
// ksAnnounce->setGenerated(false);
|
||
//TODO keysig->setGenerated(true);
|
||
// }
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
needKeysig = needKeysig && (keyIdx.key() != Key::C || keyIdx.custom() || keyIdx.isAtonal());
|
||
|
||
if (needKeysig) {
|
||
KeySig* keysig;
|
||
if (!kSegment) {
|
||
kSegment = new Segment(this, SegmentType::KeySig, Fraction(0,1));
|
||
kSegment->setHeader(true);
|
||
add(kSegment);
|
||
keysig = 0;
|
||
}
|
||
else
|
||
keysig = toKeySig(kSegment->element(track));
|
||
if (!keysig) {
|
||
//
|
||
// create missing key signature
|
||
//
|
||
keysig = new KeySig(score());
|
||
keysig->setTrack(track);
|
||
keysig->setGenerated(true);
|
||
keysig->setParent(kSegment);
|
||
kSegment->add(keysig);
|
||
}
|
||
keysig->setKeySigEvent(keyIdx);
|
||
keysig->layout();
|
||
//kSegment->createShape(staffIdx);
|
||
kSegment->setEnabled(true);
|
||
}
|
||
else {
|
||
if (kSegment && staff->isPitchedStaff(tick())) {
|
||
// do not disable user modified keysigs
|
||
bool disable = true;
|
||
for (int i = 0; i < score()->nstaves(); ++i) {
|
||
Element* e = kSegment->element(i * VOICES);
|
||
Key key = score()->staff(i)->key(tick());
|
||
if ((e && !e->generated()) || (key != keyIdx.key())) {
|
||
disable = false;
|
||
}
|
||
else if (e && e->generated() && key == keyIdx.key() && keyIdx.key() == Key::C){
|
||
// If a key sig segment is disabled, it may be re-enabled if there is
|
||
// a transposing instrument using a different key sig.
|
||
// To prevent this from making the wrong key sig display, remove any key
|
||
// sigs on staves where the key in this measure is C.
|
||
kSegment->remove(e);
|
||
}
|
||
}
|
||
|
||
if (disable)
|
||
kSegment->setEnabled(false);
|
||
else {
|
||
Element* e = kSegment->element(track);
|
||
if (e && e->isKeySig()) {
|
||
KeySig* keysig = toKeySig(e);
|
||
keysig->layout();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
++staffIdx;
|
||
}
|
||
if (cSegment)
|
||
cSegment->createShapes();
|
||
if (kSegment)
|
||
kSegment->createShapes();
|
||
|
||
//
|
||
// create systemic barline
|
||
//
|
||
Segment* s = findSegment(SegmentType::BeginBarLine, tick());
|
||
int n = score()->nstaves();
|
||
if ((n > 1 && score()->styleB(Sid::startBarlineMultiple)) || (n == 1 && score()->styleB(Sid::startBarlineSingle))) {
|
||
if (!s) {
|
||
s = new Segment(this, SegmentType::BeginBarLine, Fraction(0,1));
|
||
add(s);
|
||
}
|
||
for (int track = 0; track < score()->ntracks(); track += VOICES) {
|
||
BarLine* bl = toBarLine(s->element(track));
|
||
if (!bl) {
|
||
bl = new BarLine(score());
|
||
bl->setTrack(track);
|
||
bl->setGenerated(true);
|
||
bl->setParent(s);
|
||
bl->setBarLineType(BarLineType::NORMAL);
|
||
bl->setSpanStaff(true);
|
||
bl->layout();
|
||
s->add(bl);
|
||
}
|
||
}
|
||
s->createShapes();
|
||
s->setEnabled(true);
|
||
s->setHeader(true);
|
||
setHeader(true);
|
||
}
|
||
else if (s)
|
||
s->setEnabled(false);
|
||
checkHeader();
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// addSystemTrailer
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::addSystemTrailer(Measure* nm)
|
||
{
|
||
Fraction _rtick = ticks();
|
||
bool isFinalMeasure = isFinalMeasureOfSection();
|
||
|
||
// locate a time sig. in the next measure and, if found,
|
||
// check if it has court. sig. turned off
|
||
TimeSig* ts = nullptr;
|
||
bool showCourtesySig = false;
|
||
Segment* s = findSegmentR(SegmentType::TimeSigAnnounce, _rtick);
|
||
if (nm && score()->genCourtesyTimesig() && !isFinalMeasure && !score()->floatMode()) {
|
||
Segment* tss = nm->findSegmentR(SegmentType::TimeSig, Fraction(0,1));
|
||
if (tss) {
|
||
int nstaves = score()->nstaves();
|
||
for (int track = 0; track < nstaves * VOICES; track += VOICES) {
|
||
ts = toTimeSig(tss->element(track));
|
||
if (ts)
|
||
break;
|
||
}
|
||
if (ts && ts->showCourtesySig()) {
|
||
showCourtesySig = true;
|
||
// if due, create a new courtesy time signature for each staff
|
||
if (!s) {
|
||
s = new Segment(this, SegmentType::TimeSigAnnounce, _rtick);
|
||
s->setTrailer(true);
|
||
add(s);
|
||
}
|
||
s->setEnabled(true);
|
||
for (int track = 0; track < nstaves * VOICES; track += VOICES) {
|
||
TimeSig* nts = toTimeSig(tss->element(track));
|
||
if (!nts)
|
||
continue;
|
||
ts = toTimeSig(s->element(track));
|
||
if (!ts) {
|
||
ts = new TimeSig(score());
|
||
ts->setTrack(track);
|
||
ts->setGenerated(true);
|
||
ts->setParent(s);
|
||
score()->undoAddElement(ts);
|
||
}
|
||
ts->setFrom(nts);
|
||
ts->layout();
|
||
//s->createShape(track / VOICES);
|
||
}
|
||
s->createShapes();
|
||
}
|
||
}
|
||
}
|
||
if (!showCourtesySig && s) {
|
||
// remove any existing time signatures
|
||
s->setEnabled(false);
|
||
}
|
||
|
||
// courtesy key signatures, clefs
|
||
|
||
int n = score()->nstaves();
|
||
bool show = hasCourtesyKeySig();
|
||
s = findSegmentR(SegmentType::KeySigAnnounce, _rtick);
|
||
|
||
Segment* clefSegment = findSegmentR(SegmentType::Clef, ticks());
|
||
|
||
for (int staffIdx = 0; staffIdx < n; ++staffIdx) {
|
||
int track = staffIdx * VOICES;
|
||
Staff* staff = score()->staff(staffIdx);
|
||
|
||
if (show) {
|
||
if (!s) {
|
||
s = new Segment(this, SegmentType::KeySigAnnounce, _rtick);
|
||
s->setTrailer(true);
|
||
add(s);
|
||
}
|
||
KeySig* ks = toKeySig(s->element(track));
|
||
KeySigEvent key2 = staff->keySigEvent(endTick());
|
||
|
||
if (!ks) {
|
||
ks = new KeySig(score());
|
||
ks->setTrack(track);
|
||
ks->setGenerated(true);
|
||
ks->setParent(s);
|
||
s->add(ks);
|
||
}
|
||
//else if (!(ks->keySigEvent() == key2)) {
|
||
// score()->undo(new ChangeKeySig(ks, key2, ks->showCourtesy()));
|
||
// }
|
||
ks->setKeySigEvent(key2);
|
||
ks->layout();
|
||
//s->createShape(track / VOICES);
|
||
s->setEnabled(true);
|
||
}
|
||
else {
|
||
// remove any existent courtesy key signature
|
||
if (s)
|
||
s->setEnabled(false);
|
||
}
|
||
if (clefSegment) {
|
||
Clef* clef = toClef(clefSegment->element(track));
|
||
if (clef)
|
||
clef->setSmall(true);
|
||
}
|
||
}
|
||
if (s)
|
||
s->createShapes();
|
||
if (clefSegment)
|
||
clefSegment->createShapes();
|
||
|
||
checkTrailer();
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// removeSystemHeader
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::removeSystemHeader()
|
||
{
|
||
if (!header())
|
||
return;
|
||
for (Segment* seg = first(); seg; seg = seg->next()) {
|
||
if (!seg->header())
|
||
break;
|
||
seg->setEnabled(false);
|
||
}
|
||
setHeader(false);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// removeSystemTrailer
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::removeSystemTrailer()
|
||
{
|
||
bool changed = false;
|
||
for (Segment* seg = last(); seg != first(); seg = seg->prev()) {
|
||
if (!seg->trailer())
|
||
break;
|
||
if (seg->enabled())
|
||
seg->setEnabled(false);
|
||
changed = true;
|
||
}
|
||
setTrailer(false);
|
||
if (system() && changed)
|
||
computeMinWidth();
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// checkHeader
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::checkHeader()
|
||
{
|
||
for (Segment* seg = first(); seg; seg = seg->next()) {
|
||
if (seg->enabled() && seg->header()) {
|
||
setHeader(seg->header());
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// checkTrailer
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::checkTrailer()
|
||
{
|
||
for (Segment* seg = last(); seg != first(); seg = seg->prev()) {
|
||
if (seg->enabled() && seg->trailer()) {
|
||
setTrailer(seg->trailer());
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// setStretchedWidth
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::setStretchedWidth(qreal w)
|
||
{
|
||
qreal minWidth = isMMRest() ? score()->styleP(Sid::minMMRestWidth) : score()->styleP(Sid::minMeasureWidth);
|
||
if (w < minWidth)
|
||
w = minWidth;
|
||
|
||
qreal stretchableWidth = 0.0;
|
||
for (Segment* s = first(SegmentType::ChordRest); s; s = s->next(SegmentType::ChordRest)) {
|
||
if (!s->enabled())
|
||
continue;
|
||
stretchableWidth += s->width();
|
||
}
|
||
const int maxMMRestLength = 32; // TODO: style
|
||
int weight = layoutWeight(maxMMRestLength);
|
||
w += stretchableWidth * (basicStretch() - 1.0) * weight / 1920.0;
|
||
|
||
setWidth(w);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// hasAccidental
|
||
//---------------------------------------------------------
|
||
|
||
static bool hasAccidental(Segment* s)
|
||
{
|
||
Score* score = s->score();
|
||
for (int track = 0; track < s->score()->ntracks(); ++track) {
|
||
Staff* staff = score->staff(track2staff(track));
|
||
if (!staff->show())
|
||
continue;
|
||
Element* e = s->element(track);
|
||
if (!e || !e->isChord())
|
||
continue;
|
||
Chord* c = toChord(e);
|
||
for (Note* n : c->notes()) {
|
||
if (n->accidental())
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// computeMinWidth
|
||
// sets the minimum stretched width of segment list s
|
||
// set the width and x position for all segments
|
||
//---------------------------------------------------------
|
||
|
||
void Measure::computeMinWidth(Segment* s, qreal x, bool isSystemHeader)
|
||
{
|
||
Segment* fs = firstEnabled();
|
||
if (!fs->visible()) // first enabled could be a clef change on invisible staff
|
||
fs = fs->nextActive();
|
||
bool first = isFirstInSystem();
|
||
const Shape ls(first ? QRectF(0.0, -1000000.0, 0.0, 2000000.0) : QRectF(0.0, 0.0, 0.0, spatium() * 4));
|
||
|
||
if (isMMRest()) {
|
||
// Reset MM rest to initial size and position
|
||
Segment* seg = findSegmentR(SegmentType::ChordRest, Fraction(0,1));
|
||
const int nstaves = score()->nstaves();
|
||
for (int st = 0; st < nstaves; ++st) {
|
||
Rest* mmRest = toRest(seg->element(staff2track(st)));
|
||
if (mmRest) {
|
||
mmRest->rxpos() = 0;
|
||
mmRest->layoutMMRest(score()->styleP(Sid::minMMRestWidth) * mag());
|
||
mmRest->segment()->createShapes();
|
||
}
|
||
}
|
||
}
|
||
|
||
while (s) {
|
||
s->rxpos() = x;
|
||
if (!s->enabled() || !s->visible()) {
|
||
s->setWidth(0);
|
||
s = s->next();
|
||
continue;
|
||
}
|
||
Segment* ns = s->nextActive();
|
||
// end barline might be disabled
|
||
// but still consider it for spacing of previous segment
|
||
if (!ns)
|
||
ns = s->next(SegmentType::BarLineType);
|
||
qreal w;
|
||
|
||
if (ns) {
|
||
if (isSystemHeader && (ns->isChordRestType() || (ns->isClefType() && !ns->header()))) {
|
||
// this is the system header gap
|
||
w = s->minHorizontalDistance(ns, true);
|
||
isSystemHeader = false;
|
||
}
|
||
else {
|
||
w = s->minHorizontalDistance(ns, false);
|
||
}
|
||
// printf(" min %f <%s>(%d) <%s>(%d)\n", s->x(), s->subTypeName(), s->enabled(), ns->subTypeName(), ns->enabled());
|
||
#if 1
|
||
// look back for collisions with previous segments
|
||
// this is time consuming (ca. +5%) and probably requires more optimization
|
||
|
||
if (s == fs) // don't let the second segment cross measure start (not covered by the loop below)
|
||
w = std::max(w, ns->minLeft(ls) - s->x());
|
||
|
||
int n = 1;
|
||
for (Segment* ps = s; ps != fs;) {
|
||
qreal ww;
|
||
ps = ps->prevActive();
|
||
|
||
Q_ASSERT(ps); // ps should never be nullptr but better be safe.
|
||
if (!ps)
|
||
break;
|
||
|
||
if (ps->isChordRestType())
|
||
++n;
|
||
ww = ps->minHorizontalCollidingDistance(ns) - (s->x() - ps->x());
|
||
|
||
if (ps == fs)
|
||
ww = std::max(ww, ns->minLeft(ls) - s->x());
|
||
|
||
if (ww > w) {
|
||
// overlap !
|
||
// distribute extra space between segments ps - ss;
|
||
// only ChordRest segments get more space
|
||
// TODO: is there a special case n == 0 ?
|
||
|
||
qreal d = (ww - w) / n;
|
||
qreal xx = ps->x();
|
||
for (Segment* ss = ps; ss != s;) {
|
||
Segment* ns1 = ss->nextActive();
|
||
qreal ww1 = ss->width();
|
||
if (ss->isChordRestType()) {
|
||
ww1 += d;
|
||
ss->setWidth(ww1);
|
||
}
|
||
xx += ww1;
|
||
ns1->rxpos() = xx;
|
||
ss = ns1;
|
||
}
|
||
w += d;
|
||
x = xx;
|
||
break;
|
||
}
|
||
}
|
||
#endif
|
||
}
|
||
else
|
||
w = s->minRight();
|
||
s->setWidth(w);
|
||
x += w;
|
||
s = s->next();
|
||
}
|
||
setStretchedWidth(x);
|
||
}
|
||
|
||
void Measure::computeMinWidth()
|
||
{
|
||
Segment* s;
|
||
|
||
//
|
||
// skip disabled segment
|
||
//
|
||
for (s = first(); s && !s->enabled(); s = s->next()) {
|
||
s->rxpos() = 0;
|
||
s->setWidth(0);
|
||
}
|
||
if (!s) {
|
||
setWidth(0.0);
|
||
return;
|
||
}
|
||
qreal x;
|
||
bool first = isFirstInSystem();
|
||
|
||
// left barriere:
|
||
// Make sure no elements crosses the left boarder if first measure in a system.
|
||
//
|
||
Shape ls(first ? QRectF(0.0, -1000000.0, 0.0, 2000000.0) : QRectF(0.0, 0.0, 0.0, spatium() * 4));
|
||
|
||
x = s->minLeft(ls);
|
||
|
||
if (s->isStartRepeatBarLineType()) {
|
||
System* sys = system();
|
||
MeasureBase* pmb = prev();
|
||
if (pmb->isMeasure() && pmb->system() == sys && pmb->repeatEnd()) {
|
||
Segment* seg = toMeasure(pmb)->last();
|
||
// overlap end repeat barline with start repeat barline
|
||
if (seg->isEndBarLineType())
|
||
x -= score()->styleP(Sid::endBarWidth) * mag();
|
||
}
|
||
}
|
||
|
||
if (s->isChordRestType())
|
||
x += score()->styleP(hasAccidental(s) ? Sid::barAccidentalDistance : Sid::barNoteDistance);
|
||
else if (s->isClefType() || s->isHeaderClefType())
|
||
x += score()->styleP(Sid::clefLeftMargin);
|
||
else if (s->isKeySigType())
|
||
x = qMax(x, score()->styleP(Sid::keysigLeftMargin));
|
||
else if (s->isTimeSigType())
|
||
x = qMax(x, score()->styleP(Sid::timesigLeftMargin));
|
||
x += s->extraLeadingSpace().val() * spatium();
|
||
bool isSystemHeader = s->header();
|
||
|
||
computeMinWidth(s, x, isSystemHeader);
|
||
}
|
||
|
||
}
|