1 //=============================================================================
2 // MuseScore
3 // Music Composition & Notation
4 //
5 // Copyright (C) 2012 Werner Schweer
6 //
7 // This program is free software; you can redistribute it and/or modify
8 // it under the terms of the GNU General Public License version 2
9 // as published by the Free Software Foundation and appearing in
10 // the file LICENCE.GPL
11 //=============================================================================
12
13 #include "score.h"
14
15 #include "rest.h"
16 #include "staff.h"
17 #include "measure.h"
18 #include "harmony.h"
19 #include "fret.h"
20 #include "breath.h"
21 #include "beam.h"
22 #include "figuredbass.h"
23 #include "ottava.h"
24 #include "part.h"
25 #include "lyrics.h"
26 #include "hairpin.h"
27 #include "tie.h"
28 #include "tuplet.h"
29 #include "utils.h"
30 #include "xml.h"
31 #include "image.h"
32 #include "repeat.h"
33 #include "chord.h"
34 #include "tremolo.h"
35 #include "slur.h"
36 #include "articulation.h"
37 #include "sig.h"
38
39 namespace Ms {
40
41 //---------------------------------------------------------
42 // transposeChord
43 //---------------------------------------------------------
44
transposeChord(Chord * c,Interval srcTranspose,const Fraction & tick)45 static void transposeChord(Chord* c, Interval srcTranspose, const Fraction& tick)
46 {
47 // set note track
48 // check if staffMove moves a note to a
49 // nonexistent staff
50 //
51 int track = c->track();
52 int nn = (track / VOICES) + c->staffMove();
53 if (nn < 0 || nn >= c->score()->nstaves())
54 c->setStaffMove(0);
55 Part* part = c->part();
56 Interval dstTranspose = part->instrument(tick)->transpose();
57
58 if (srcTranspose != dstTranspose) {
59 if (!dstTranspose.isZero()) {
60 dstTranspose.flip();
61 for (Note* n : c->notes()) {
62 int npitch;
63 int ntpc;
64 transposeInterval(n->pitch(), n->tpc1(), &npitch, &ntpc, dstTranspose, true);
65 n->setTpc2(ntpc);
66 }
67 }
68 else {
69 for (Note* n : c->notes())
70 n->setTpc2(n->tpc1());
71 }
72 }
73 }
74
75 //---------------------------------------------------------
76 // pasteStaff
77 // return false if paste fails
78 //---------------------------------------------------------
79
pasteStaff(XmlReader & e,Segment * dst,int dstStaff,Fraction scale)80 bool Score::pasteStaff(XmlReader& e, Segment* dst, int dstStaff, Fraction scale)
81 {
82 Q_ASSERT(dst->isChordRestType());
83
84 std::vector<Harmony*> pastedHarmony;
85 QList<Chord*> graceNotes;
86 Beam* startingBeam = nullptr;
87 Tuplet* tuplet = nullptr;
88 Fraction dstTick = dst->tick();
89 bool pasted = false;
90 Fraction tickLen = Fraction(0,1);
91 int staves = 0;
92 bool done = false;
93 bool doScale = (scale != Fraction(1, 1));
94
95 while (e.readNextStartElement()) {
96 if (done)
97 break;
98 if (e.name() != "StaffList") {
99 e.unknown();
100 break;
101 }
102 QString version = e.attribute("version", "NONE");
103 if (!MScore::testMode) {
104 if (version != MSC_VERSION) {
105 qDebug("pasteStaff: bad version");
106 break;
107 }
108 }
109 Fraction tickStart = Fraction::fromTicks(e.intAttribute("tick", 0));
110 tickLen = Fraction::fromTicks(e.intAttribute("len", 0));
111 Fraction oTickLen = tickLen;
112 tickLen *= scale;
113 int staffStart = e.intAttribute("staff", 0);
114 staves = e.intAttribute("staves", 0);
115
116 Fraction oEndTick = dstTick + oTickLen;
117 auto oSpanner = spannerMap().findContained(dstTick.ticks(), oEndTick.ticks());
118 bool spannerFound = false;
119
120 e.setTickOffset(dstTick - tickStart);
121 e.setTick(Fraction(0,1));
122
123 while (e.readNextStartElement()) {
124 if (done)
125 break;
126 if (e.name() != "Staff") {
127 e.unknown();
128 break;
129 }
130 e.setTransposeChromatic(0);
131 e.setTransposeDiatonic(0);
132
133 int srcStaffIdx = e.attribute("id", "0").toInt();
134 e.setTrack(srcStaffIdx * VOICES);
135 e.setTrackOffset((dstStaff - staffStart) * VOICES);
136 int dstStaffIdx = e.track() / VOICES;
137 if (dstStaffIdx >= dst->score()->nstaves()) {
138 qDebug("paste beyond staves");
139 done = true;
140 break;
141 }
142
143 while (e.readNextStartElement()) {
144 pasted = true;
145 const QStringRef& tag(e.name());
146
147 if (tag == "transposeChromatic")
148 e.setTransposeChromatic(e.readInt());
149 else if (tag == "transposeDiatonic")
150 e.setTransposeDiatonic(e.readInt());
151 else if (tag == "voiceOffset") {
152 int voiceOffset[VOICES];
153 std::fill(voiceOffset, voiceOffset+VOICES, -1);
154 while (e.readNextStartElement()) {
155 if (e.name() != "voice")
156 e.unknown();
157 int voiceId = e.attribute("id", "-1").toInt();
158 Q_ASSERT(voiceId >= 0 && voiceId < VOICES);
159 voiceOffset[voiceId] = e.readInt();
160 }
161 e.readNext();
162 if (!makeGap1(dstTick, dstStaffIdx, tickLen, voiceOffset)) {
163 qDebug("cannot make gap in staff %d at tick %d", dstStaffIdx, dstTick.ticks());
164 done = true; // break main loop, cannot make gap
165 break;
166 }
167 }
168 else if (tag == "location") {
169 Location loc = Location::relative();
170 loc.read(e);
171 e.setLocation(loc);
172 }
173 else if (tag == "Tuplet") {
174 Tuplet* oldTuplet = tuplet;
175 Fraction tick = doScale ? (e.tick() - dstTick) * scale + dstTick : e.tick();
176 // no paste into local time signature
177 if (staff(dstStaffIdx)->isLocalTimeSignature(tick)) {
178 MScore::setError(DEST_LOCAL_TIME_SIGNATURE);
179 if (oldTuplet && oldTuplet->elements().empty())
180 delete oldTuplet;
181 return false;
182 }
183 tuplet = new Tuplet(this);
184 tuplet->setTrack(e.track());
185 tuplet->read(e);
186 if (doScale) {
187 tuplet->setTicks(tuplet->ticks() * scale);
188 tuplet->setBaseLen(tuplet->baseLen().fraction() * scale);
189 }
190 Measure* measure = tick2measure(tick);
191 tuplet->setParent(measure);
192 tuplet->setTick(tick);
193 tuplet->setTuplet(oldTuplet);
194 if (tuplet->rtick() + tuplet->actualTicks() > measure->ticks()) {
195 delete tuplet;
196 if (oldTuplet && oldTuplet->elements().empty())
197 delete oldTuplet;
198 MScore::setError(TUPLET_CROSSES_BAR);
199 return false;
200 }
201 if (oldTuplet)
202 tuplet->readAddTuplet(oldTuplet);
203 }
204 else if (tag == "endTuplet") {
205 if (!tuplet) {
206 qDebug("Score::pasteStaff: encountered <endTuplet/> when no tuplet was started");
207 e.skipCurrentElement();
208 continue;
209 }
210 Tuplet* oldTuplet = tuplet;
211 tuplet = tuplet->tuplet();
212 if (oldTuplet->elements().empty()) {
213 qDebug("Score::pasteStaff: ended tuplet is empty");
214 if (tuplet)
215 tuplet->remove(oldTuplet);
216 delete oldTuplet;
217 }
218 else
219 oldTuplet->sortElements();
220 e.readNext();
221 }
222 else if (tag == "Chord" || tag == "Rest" || tag == "RepeatMeasure") {
223 ChordRest* cr = toChordRest(Element::name2Element(tag, this));
224 cr->setTrack(e.track());
225 cr->read(e);
226 cr->setSelected(false);
227 Fraction tick = doScale ? (e.tick() - dstTick) * scale + dstTick : e.tick();
228 // no paste into local time signature
229 if (staff(dstStaffIdx)->isLocalTimeSignature(tick)) {
230 MScore::setError(DEST_LOCAL_TIME_SIGNATURE);
231 return false;
232 }
233 if (startingBeam) {
234 startingBeam->add(cr); // also calls cr->setBeam(startingBeam)
235 startingBeam = nullptr;
236 }
237 if (cr->isGrace())
238 graceNotes.push_back(toChord(cr));
239 else {
240 if (tuplet)
241 cr->readAddTuplet(tuplet);
242 e.incTick(cr->actualTicks());
243 if (doScale) {
244 Fraction d = cr->durationTypeTicks();
245 cr->setTicks(cr->ticks() * scale);
246 cr->setDurationType(d * scale);
247 for (Lyrics* l : cr->lyrics())
248 l->setTicks(l->ticks() * scale);
249 }
250 if (cr->isChord()) {
251 Chord* chord = toChord(cr);
252 // disallow tie across barline within two-note tremolo
253 // tremolos can potentially still straddle the barline if no tie is required
254 // but these will be removed later
255 Tremolo* t = chord->tremolo();
256 if (t && t->twoNotes()) {
257 if (doScale) {
258 Fraction d = t->durationType().ticks();
259 t->setDurationType(d * scale);
260 }
261 Measure* m = tick2measure(tick);
262 Fraction ticks = cr->actualTicks();
263 Fraction rticks = m->endTick() - tick;
264 if (rticks < ticks || (rticks != ticks && rticks < ticks * 2)) {
265 MScore::setError(DEST_TREMOLO);
266 return false;
267 }
268 }
269 for (int i = 0; i < graceNotes.size(); ++i) {
270 Chord* gc = graceNotes[i];
271 gc->setGraceIndex(i);
272 transposeChord(gc, e.transpose(), tick);
273 chord->add(gc);
274 }
275 graceNotes.clear();
276 }
277 // delete pending ties, they are not selected when copy
278 if ((tick - dstTick) + cr->actualTicks() >= tickLen) {
279 if (cr->isChord()) {
280 Chord* c = toChord(cr);
281 for (Note* note: c->notes()) {
282 Tie* tie = note->tieFor();
283 if (tie) {
284 note->setTieFor(0);
285 delete tie;
286 }
287 }
288 }
289 }
290 // shorten last cr to fit in the space made by makeGap
291 if ((tick - dstTick) + cr->actualTicks() > tickLen) {
292 Fraction newLength = tickLen - (tick - dstTick);
293 // check previous CR on same track, if it has tremolo, delete the tremolo
294 // we don't want a tremolo and two different chord durations
295 if (cr->isChord()) {
296 Segment* s = tick2leftSegment(tick - Fraction::fromTicks(1));
297 if (s) {
298 ChordRest* crt = toChordRest(s->element(cr->track()));
299 if (!crt)
300 crt = s->nextChordRest(cr->track(), true);
301 if (crt && crt->isChord()) {
302 Chord* chrt = toChord(crt);
303 Tremolo* tr = chrt->tremolo();
304 if (tr) {
305 tr->setChords(chrt, toChord(cr));
306 chrt->remove(tr);
307 delete tr;
308 }
309 }
310 }
311 }
312 if (!cr->tuplet()) {
313 // shorten duration
314 // exempt notes in tuplets, since we don't allow copy of partial tuplet anyhow
315 // TODO: figure out a reasonable fudge factor to make sure shorten tuplets appropriately if we do ever copy a partial tuplet
316 cr->setTicks(newLength);
317 cr->setDurationType(newLength);
318 }
319 }
320 pasteChordRest(cr, tick, e.transpose());
321 }
322 }
323 else if (tag == "Spanner") {
324 Spanner::readSpanner(e, this, e.track());
325 spannerFound = true;
326 }
327 else if (tag == "Harmony") {
328 Harmony* harmony = new Harmony(this);
329 harmony->setTrack(e.track());
330 harmony->read(e);
331 harmony->setTrack(e.track());
332 // transpose
333 Fraction tick = doScale ? (e.tick() - dstTick) * scale + dstTick : e.tick();
334 Part* partDest = staff(e.track() / VOICES)->part();
335 Interval interval = partDest->instrument(tick)->transpose();
336 if (!styleB(Sid::concertPitch) && !interval.isZero()) {
337 interval.flip();
338 int rootTpc = transposeTpc(harmony->rootTpc(), interval, true);
339 int baseTpc = transposeTpc(harmony->baseTpc(), interval, true);
340 undoTransposeHarmony(harmony, rootTpc, baseTpc);
341 }
342
343 Measure* m = tick2measure(tick);
344 Segment* seg = m->undoGetSegment(SegmentType::ChordRest, tick);
345 // remove pre-existing chords on this track
346 // but be sure not to remove any we just added
347 for (Element* el : seg->findAnnotations(ElementType::HARMONY, e.track(), e.track())) {
348 if (std::find(pastedHarmony.begin(), pastedHarmony.end(), el) == pastedHarmony.end())
349 undoRemoveElement(el);
350 }
351 harmony->setParent(seg);
352 undoAddElement(harmony);
353 pastedHarmony.push_back(harmony);
354 }
355 else if (tag == "Dynamic"
356 || tag == "Symbol"
357 || tag == "FretDiagram"
358 || tag == "TremoloBar"
359 || tag == "Marker"
360 || tag == "Jump"
361 || tag == "Image"
362 || tag == "Text"
363 || tag == "StaffText"
364 || tag == "TempoText"
365 || tag == "FiguredBass"
366 || tag == "Sticking"
367 || tag == "Fermata"
368 ) {
369 Element* el = Element::name2Element(tag, this);
370 el->setTrack(e.track()); // a valid track might be necessary for el->read() to work
371 if (el->isFermata())
372 el->setPlacement(el->track() & 1 ? Placement::BELOW : Placement::ABOVE);
373 el->read(e);
374
375 Fraction tick = doScale ? (e.tick() - dstTick) * scale + dstTick : e.tick();
376 Measure* m = tick2measure(tick);
377 Segment* seg = m->undoGetSegment(SegmentType::ChordRest, tick);
378 el->setParent(seg);
379
380 // be sure to paste the element in the destination track;
381 // setting track needs to be repeated, as it might have been overwritten by el->read()
382 // preserve *voice* from source, though
383 el->setTrack((e.track() / VOICES) * VOICES + el->voice());
384
385 undoAddElement(el);
386 }
387 else if (tag == "Clef") {
388 Clef* clef = new Clef(this);
389 clef->read(e);
390 clef->setTrack(e.track());
391 Fraction tick = doScale ? (e.tick() - dstTick) * scale + dstTick : e.tick();
392 Measure* m = tick2measure(tick);
393 if (m->tick().isNotZero() && m->tick() == tick)
394 m = m->prevMeasure();
395 Segment* segment = m->undoGetSegment(SegmentType::Clef, tick);
396 clef->setParent(segment);
397 undoChangeElement(segment->element(e.track()), clef);
398 }
399 else if (tag == "Breath") {
400 Breath* breath = new Breath(this);
401 breath->setTrack(e.track());
402 breath->setPlacement(breath->track() & 1 ? Placement::BELOW : Placement::ABOVE);
403 breath->read(e);
404 Fraction tick = doScale ? (e.tick() - dstTick) * scale + dstTick : e.tick();
405 Measure* m = tick2measure(tick);
406 if (m->tick() == tick)
407 m = m->prevMeasure();
408 Segment* segment = m->undoGetSegment(SegmentType::Breath, tick);
409 breath->setParent(segment);
410 undoChangeElement(segment->element(e.track()), breath);
411 }
412 else if (tag == "Beam") {
413 Beam* beam = new Beam(this);
414 beam->setTrack(e.track());
415 beam->read(e);
416 beam->setParent(0);
417 if (startingBeam) {
418 qDebug("The read beam was not used");
419 delete startingBeam;
420 }
421 startingBeam = beam;
422 }
423 else if (tag == "BarLine") {
424 e.skipCurrentElement(); // ignore bar line
425 }
426 else {
427 qDebug("PasteStaff: element %s not handled", tag.toUtf8().data());
428 e.skipCurrentElement(); // ignore
429 }
430 }
431
432 e.checkConnectors();
433 if (startingBeam) {
434 qDebug("The read beam was not used");
435 delete startingBeam;
436 }
437 if (tuplet) {
438 qDebug("<endTuplet/> not found");
439 if (tuplet->elements().empty()) {
440 if (tuplet->tuplet())
441 tuplet->tuplet()->remove(tuplet);
442 delete tuplet;
443 }
444 }
445 }
446 // fix up spanners
447 if (doScale && spannerFound) {
448 // build list of original spanners
449 std::vector<Spanner*> oSpannerList;
450 for (auto interval : oSpanner) {
451 Spanner* sp = interval.value;
452 oSpannerList.push_back(sp);
453 }
454 auto nSpanner = spannerMap().findContained(dstTick.ticks(), oEndTick.ticks());
455 for (auto interval : nSpanner) {
456 Spanner* sp = interval.value;
457 // skip if not in this staff list
458 if (sp->staffIdx() < dstStaff || sp->staffIdx() >= dstStaff + staves)
459 continue;
460 // CHORD and NOTE spanners are normally handled already
461 if (sp->anchor() == Spanner::Anchor::CHORD || sp->anchor() == Spanner::Anchor::NOTE)
462 continue;
463 // skip if present oiginally
464 auto i = std::find(oSpannerList.begin(), oSpannerList.end(), sp);
465 if (i != oSpannerList.end())
466 continue;
467 Fraction tick = (sp->tick() - dstTick) * scale + dstTick;
468 sp->undoChangeProperty(Pid::SPANNER_TICK, tick);
469 sp->undoChangeProperty(Pid::SPANNER_TICKS, sp->ticks() * scale);
470 }
471 }
472 }
473
474 for (Score* s : scoreList()) // for all parts
475 s->connectTies();
476
477 if (pasted) { //select only if we pasted something
478 int endStaff = dstStaff + staves;
479 if (endStaff > nstaves())
480 endStaff = nstaves();
481 //check and add truly invisible rests instead of gaps
482 //TODO: look if this could be done different
483 Measure* dstM = tick2measure(dstTick);
484 Measure* endM = tick2measure(dstTick + tickLen);
485 for (int i = dstStaff; i < endStaff; i++) {
486 for (Measure* m = dstM; m && m != endM->nextMeasure(); m = m->nextMeasure())
487 m->checkMeasure(i);
488 }
489 _selection.setRangeTicks(dstTick, dstTick + tickLen, dstStaff, endStaff);
490
491 //finding the first element that has a track
492 //the canvas position will be set to this element
493 Element* el = 0;
494 Segment* s = tick2segmentMM(dstTick);
495 Segment* s2 = tick2segmentMM(dstTick + tickLen);
496 bool found = false;
497 if (s2)
498 s2 = s2->next1MM();
499 while (!found && s != s2) {
500 for (int i = dstStaff * VOICES; i < (endStaff + 1) * VOICES; i++) {
501 el = s->element(i);
502 if (el) {
503 found = true;
504 break;
505 }
506 }
507 s = s->next1MM();
508 }
509
510 for (MuseScoreView* v : qAsConst(viewer))
511 v->adjustCanvasPosition(el, false);
512 if (!selection().isRange())
513 _selection.setState(SelState::RANGE);
514 }
515 return true;
516 }
517
518 //---------------------------------------------------------
519 // Score::readAddConnector
520 //---------------------------------------------------------
521
readAddConnector(ConnectorInfoReader * info,bool pasteMode)522 void Score::readAddConnector(ConnectorInfoReader* info, bool pasteMode)
523 {
524 if (!pasteMode) {
525 // How did we get there?
526 qDebug("Score::readAddConnector is called not in paste mode.");
527 return;
528 }
529 const ElementType type = info->type();
530 switch(type) {
531 case ElementType::HAIRPIN:
532 case ElementType::PEDAL:
533 case ElementType::OTTAVA:
534 case ElementType::TRILL:
535 case ElementType::TEXTLINE:
536 case ElementType::VOLTA:
537 case ElementType::PALM_MUTE:
538 case ElementType::LET_RING:
539 case ElementType::VIBRATO:
540 {
541 Spanner* sp = toSpanner(info->connector());
542 const Location& l = info->location();
543 if (info->isStart()) {
544 sp->setAnchor(Spanner::Anchor::SEGMENT);
545 sp->setTrack(l.track());
546 sp->setTrack2(l.track());
547 sp->setTick(l.frac());
548 }
549 else if (info->isEnd()) {
550 sp->setTick2(l.frac());
551 undoAddElement(sp);
552 if (sp->isOttava())
553 sp->staff()->updateOttava();
554 }
555 }
556 break;
557 default:
558 break;
559 }
560 }
561
562 //---------------------------------------------------------
563 // pasteChordRest
564 //---------------------------------------------------------
565
pasteChordRest(ChordRest * cr,const Fraction & t,const Interval & srcTranspose)566 void Score::pasteChordRest(ChordRest* cr, const Fraction& t, const Interval& srcTranspose)
567 {
568 Fraction tick(t);
569 // qDebug("pasteChordRest %s at %d, len %d/%d", cr->name(), tick, cr->ticks().numerator(), cr->ticks().denominator() );
570
571 Measure* measure = tick2measure(tick);
572 if (!measure)
573 return;
574
575 int twoNoteTremoloFactor = 1;
576 if (cr->isChord()) {
577 transposeChord(toChord(cr), srcTranspose, tick);
578 if (toChord(cr)->tremolo() && toChord(cr)->tremolo()->twoNotes())
579 twoNoteTremoloFactor = 2;
580 else if (cr->durationTypeTicks() == (cr->actualTicks() * 2)) {
581 // this could be the 2nd note of a two-note tremolo
582 // check previous CR on same track, if it has a two-note tremolo, then set twoNoteTremoloFactor to 2
583 Segment* seg = measure->undoGetSegment(SegmentType::ChordRest, tick);
584 ChordRest* crt = seg->nextChordRest(cr->track(), true);
585 if (crt && crt->isChord()) {
586 Chord* chrt = toChord(crt);
587 Tremolo* tr = chrt->tremolo();
588 if (tr && tr->twoNotes())
589 twoNoteTremoloFactor = 2;
590 }
591 }
592 }
593
594 // we can paste a measure rest as such only at start of measure
595 // and only if the lengths of the rest and measure match
596 // otherwise, we need to convert to duration rest(s)
597 // and potentially split the rest up (eg, 5/4 => whole + quarter)
598 bool convertMeasureRest = cr->isRest() && cr->durationType().type() == TDuration::DurationType::V_MEASURE
599 && (tick != measure->tick() || cr->ticks() != measure->ticks());
600
601 Fraction measureEnd = measure->endTick();
602 bool isGrace = cr->isChord() && toChord(cr)->noteType() != NoteType::NORMAL;
603
604 // find out if the chordrest was only partially contained in the copied range
605 bool partialCopy = false;
606 if (cr->isRepeatMeasure())
607 partialCopy = toRepeatMeasure(cr)->actualTicks() != measure->ticks();
608 else if (!isGrace && !cr->tuplet())
609 partialCopy = cr->durationTypeTicks() != (cr->actualTicks() * twoNoteTremoloFactor);
610
611 // if note is too long to fit in measure, split it up with a tie across the barline
612 // exclude tuplets from consideration
613 // we have already disallowed a tuplet from crossing the barline, so there is no problem here
614 // but due to rounding, it might appear from actualTicks() that the last note is too long by a couple of ticks
615
616 if (!isGrace && !cr->tuplet() && (tick + cr->actualTicks() > measureEnd || partialCopy || convertMeasureRest)) {
617 if (cr->isChord()) {
618 // split Chord
619 Chord* c = toChord(cr);
620 Fraction rest = c->actualTicks();
621 bool firstpart = true;
622 while (rest.isNotZero()) {
623 measure = tick2measure(tick);
624 Chord* c2 = firstpart ? c : toChord(c->clone());
625 if (!firstpart)
626 c2->removeMarkings(true);
627 Fraction mlen = measure->tick() + measure->ticks() - tick;
628 Fraction len = mlen > rest ? rest : mlen;
629 std::vector<TDuration> dl = toRhythmicDurationList(len, false, tick - measure->tick(), sigmap()->timesig(tick).nominal(), measure, MAX_DOTS);
630 TDuration d = dl[0];
631 c2->setDurationType(d);
632 c2->setTicks(d.fraction());
633 rest -= c2->actualTicks();
634 undoAddCR(c2, measure, tick);
635
636 std::vector<Note*> nl1 = c->notes();
637 std::vector<Note*> nl2 = c2->notes();
638
639 if (!firstpart)
640 for (unsigned i = 0; i < nl1.size(); ++i) {
641 Tie* tie = new Tie(this);
642 tie->setStartNote(nl1[i]);
643 tie->setEndNote(nl2[i]);
644 tie->setTick(tie->startNote()->tick());
645 tie->setTick2(tie->endNote()->tick());
646 tie->setTrack(c->track());
647 Tie* tie2 = nl1[i]->tieFor();
648 if (tie2) {
649 nl2[i]->setTieFor(nl1[i]->tieFor());
650 tie2->setStartNote(nl2[i]);
651 }
652 nl1[i]->setTieFor(tie);
653 nl2[i]->setTieBack(tie);
654 }
655 c = c2;
656 firstpart = false;
657 tick += c->actualTicks();
658 }
659 }
660 else if (cr->isRest()) {
661 // split Rest
662 Rest* r = toRest(cr);
663 Fraction rest = r->ticks();
664
665 bool firstpart = true;
666 while (!rest.isZero()) {
667 Rest* r2 = firstpart ? r : toRest(r->clone());
668 measure = tick2measure(tick);
669 Fraction mlen = measure->tick() + measure->ticks() - tick;
670 Fraction len = rest > mlen ? mlen : rest;
671 std::vector<TDuration> dl = toRhythmicDurationList(len, true, tick - measure->tick(), sigmap()->timesig(tick).nominal(), measure, MAX_DOTS);
672 TDuration d = dl[0];
673 r2->setDurationType(d);
674 r2->setTicks(d.isMeasure() ? measure->ticks() : d.fraction());
675 undoAddCR(r2, measure, tick);
676 rest -= r2->ticks();
677 tick += r2->actualTicks();
678 firstpart = false;
679 }
680 }
681 else if (cr->isRepeatMeasure()) {
682 RepeatMeasure* rm = toRepeatMeasure(cr);
683 std::vector<TDuration> list = toDurationList(rm->actualTicks(), true);
684 for (auto dur : list) {
685 Rest* r = new Rest(this, dur);
686 r->setTrack(cr->track());
687 Fraction rest = r->ticks();
688 while (!rest.isZero()) {
689 Rest* r2 = toRest(r->clone());
690 measure = tick2measure(tick);
691 Fraction mlen = measure->tick() + measure->ticks() - tick;
692 Fraction len = rest > mlen ? mlen : rest;
693 std::vector<TDuration> dl = toDurationList(len, false);
694 TDuration d = dl[0];
695 r2->setTicks(d.fraction());
696 r2->setDurationType(d);
697 undoAddCR(r2, measure, tick);
698 rest -= d.fraction();
699 tick += r2->actualTicks();
700 }
701 delete r;
702 }
703 delete cr;
704 }
705 }
706 else {
707 undoAddCR(cr, measure, tick);
708 }
709 }
710
711
712 //---------------------------------------------------------
713 // pasteSymbols
714 //
715 // pastes a list of symbols into cr and following ChordRest's
716 //
717 // (Note: info about delta ticks is currently ignored)
718 //---------------------------------------------------------
719
pasteSymbols(XmlReader & e,ChordRest * dst)720 void Score::pasteSymbols(XmlReader& e, ChordRest* dst)
721 {
722 e.setPasteMode(true); // ensure the reader is in paste mode
723 Segment* currSegm = dst->segment();
724 Fraction destTick = Fraction(0,1); // the tick and track to place the pasted element at
725 int destTrack = 0;
726 bool done = false;
727 int segDelta = 0;
728 Segment* startSegm= currSegm;
729 Fraction startTick = dst->tick(); // the initial tick and track where to start pasting
730 int startTrack = dst->track();
731 int maxTrack = ntracks();
732 Fraction lastTick = lastSegment()->tick();
733
734 while (e.readNextStartElement()) {
735 if (done)
736 break;
737 if (e.name() != "SymbolList") {
738 e.unknown();
739 break;
740 }
741 QString version = e.attribute("version", "NONE");
742 if (version != MSC_VERSION)
743 break;
744
745 while (e.readNextStartElement()) {
746 if (done)
747 break;
748 const QStringRef& tag(e.name());
749
750 if (tag == "trackOffset") {
751 destTrack = startTrack + e.readInt();
752 currSegm = startSegm;
753 }
754 else if (tag == "tickOffset")
755 destTick = startTick + Fraction::fromTicks(e.readInt());
756 else if (tag == "segDelta")
757 segDelta = e.readInt();
758 else {
759
760 if (tag == "Harmony" || tag == "FretDiagram") {
761 //
762 // Harmony elements (= chord symbols) are positioned respecting
763 // the original tickOffset: advance to destTick (or near)
764 // same for FretDiagram elements
765 //
766 Segment* harmSegm;
767 for (harmSegm = startSegm; harmSegm && (harmSegm->tick() < destTick);
768 harmSegm = harmSegm->nextCR())
769 ;
770 // if destTick overshot, no dest. segment: create one
771 if (destTick >= lastTick) {
772 harmSegm = nullptr;
773 }
774 else if (!harmSegm || harmSegm->tick() > destTick) {
775 Measure* meas = tick2measure(destTick);
776 harmSegm = meas ? meas->undoGetSegment(SegmentType::ChordRest, destTick) : nullptr;
777 }
778 if (destTrack >= maxTrack || harmSegm == nullptr) {
779 qDebug("PasteSymbols: no track or segment for %s", tag.toUtf8().data());
780 e.skipCurrentElement(); // ignore
781 continue;
782 }
783 if (tag == "Harmony") {
784 Harmony* el = new Harmony(this);
785 el->setTrack(trackZeroVoice(destTrack));
786 el->read(e);
787 el->setTrack(trackZeroVoice(destTrack));
788 // transpose
789 Part* partDest = staff(track2staff(destTrack))->part();
790 Interval interval = partDest->instrument(destTick)->transpose();
791 if (!styleB(Sid::concertPitch) && !interval.isZero()) {
792 interval.flip();
793 int rootTpc = transposeTpc(el->rootTpc(), interval, true);
794 int baseTpc = transposeTpc(el->baseTpc(), interval, true);
795 undoTransposeHarmony(el, rootTpc, baseTpc);
796 }
797 el->setParent(harmSegm);
798 undoAddElement(el);
799 }
800 else {
801 FretDiagram* el = new FretDiagram(this);
802 el->setTrack(trackZeroVoice(destTrack));
803 el->read(e);
804 el->setTrack(trackZeroVoice(destTrack));
805 el->setParent(harmSegm);
806 undoAddElement(el);
807 }
808 }
809 else if (tag == "Dynamic") {
810 ChordRest* destCR = findCR(destTick, destTrack);
811 if (!destCR) {
812 e.skipCurrentElement();
813 continue;
814 }
815 Dynamic* d = new Dynamic(this);
816 d->setTrack(destTrack);
817 d->read(e);
818 d->setTrack(destTrack);
819 d->setParent(destCR->segment());
820 undoAddElement(d);
821 }
822 else if (tag == "HairPin") {
823 Hairpin* h = new Hairpin(this);
824 h->setTrack(destTrack);
825 h->read(e);
826 h->setTrack(destTrack);
827 h->setTrack2(destTrack);
828 h->setTick(destTick);
829 undoAddElement(h);
830 }
831 else {
832 //
833 // All other elements are positioned respecting the distance in chords
834 //
835 for ( ; currSegm && segDelta > 0; segDelta--)
836 currSegm = currSegm->nextCR(destTrack);
837 // check the intended dest. track and segment exist
838 if (destTrack >= maxTrack || currSegm == nullptr) {
839 qDebug("PasteSymbols: no track or segment for %s", tag.toUtf8().data());
840 e.skipCurrentElement(); // ignore
841 continue;
842 }
843 // check there is a segment element in the required track
844 if (currSegm->element(destTrack) == nullptr) {
845 qDebug("PasteSymbols: no track element for %s", tag.toUtf8().data());
846 e.skipCurrentElement();
847 continue;
848 }
849 ChordRest* cr = toChordRest(currSegm->element(destTrack));
850
851 if (tag == "Articulation") {
852 Articulation* el = new Articulation(this);
853 el->read(e);
854 el->setTrack(destTrack);
855 el->setParent(cr);
856 if (!el->isFermata() && cr->isRest())
857 delete el;
858 else
859 undoAddElement(el);
860 }
861 else if (tag == "StaffText" || tag == "Sticking") {
862 Element* el = Element::name2Element(tag, this);
863 el->read(e);
864 el->setTrack(destTrack);
865 el->setParent(currSegm);
866 if (el->isSticking() && cr->isRest())
867 delete el;
868 else
869 undoAddElement(el);
870 }
871 else if (tag == "FiguredBass") {
872 // FiguredBass always belongs to first staff voice
873 destTrack = trackZeroVoice(destTrack);
874 Fraction ticks;
875 FiguredBass* el = new FiguredBass(this);
876 el->setTrack(destTrack);
877 el->read(e);
878 el->setTrack(destTrack);
879 // if f.b. is off-note, we have to locate a place before currSegm
880 // where an on-note f.b. element could (potentially) be
881 // (while having an off-note f.b. without an on-note one before it
882 // is un-idiomatic, possible mismatch in rhythmic patterns between
883 // copy source and paste destination does not allow to be too picky)
884 if (!el->onNote()) {
885 FiguredBass* onNoteFB = nullptr;
886 Segment* prevSegm = currSegm;
887 bool done1 = false;
888 while (prevSegm) {
889 if (done1)
890 break;
891 prevSegm = prevSegm->prev1(SegmentType::ChordRest);
892 // if there is a ChordRest in the dest. track
893 // this segment is a (potential) f.b. location
894 if (prevSegm->element(destTrack) != nullptr) {
895 done1 = true;
896 }
897 // in any case, look for a f.b. in annotations:
898 // if there is a f.b. element in the right track,
899 // this is an (actual) f.b. location
900 foreach (Element* a, prevSegm->annotations()) {
901 if (a->isFiguredBass() && a->track() == destTrack) {
902 onNoteFB = toFiguredBass(a);
903 done1 = true;
904 }
905 }
906 }
907 if (!prevSegm) {
908 qDebug("PasteSymbols: can't place off-note FiguredBass");
909 delete el;
910 continue;
911 }
912 // by default, split on-note duration in half: half on-note and half off-note
913 Fraction totTicks = currSegm->tick() - prevSegm->tick();
914 Fraction destTick1 = prevSegm->tick() + (totTicks * Fraction(1,2));
915 ticks = totTicks * Fraction(1, 2);
916 if (onNoteFB)
917 onNoteFB->setTicks(totTicks * Fraction(1,2));
918 // look for a segment at this tick; if none, create one
919 Segment * nextSegm = prevSegm;
920 while (nextSegm && nextSegm->tick() < destTick1)
921 nextSegm = nextSegm->next1(SegmentType::ChordRest);
922 if (!nextSegm || nextSegm->tick() > destTick1) { // no ChordRest segm at this tick
923 nextSegm = new Segment(prevSegm->measure(), SegmentType::ChordRest, destTick1);
924 if (!nextSegm) {
925 qDebug("PasteSymbols: can't find or create destination segment for FiguredBass");
926 delete el;
927 continue;
928 }
929 undoAddElement(nextSegm);
930 }
931 currSegm = nextSegm;
932 }
933 else
934 // by default, assign to FiguredBass element the duration of the chord it refers to
935 ticks = toChordRest(currSegm->element(destTrack))->ticks();
936 // in both cases, look for an existing f.b. element in segment and remove it, if found
937 FiguredBass* oldFB = nullptr;
938 foreach (Element* a, currSegm->annotations()) {
939 if (a->isFiguredBass() && a->track() == destTrack) {
940 oldFB = toFiguredBass(a);
941 break;
942 }
943 }
944 if (oldFB)
945 undoRemoveElement(oldFB);
946 el->setParent(currSegm);
947 el->setTicks(ticks);
948 undoAddElement(el);
949 }
950 else if (tag == "Lyrics") {
951 // with lyrics, skip rests
952 while (!cr->isChord() && currSegm) {
953 currSegm = currSegm->nextCR(destTrack);
954 if (currSegm)
955 cr = toChordRest(currSegm->element(destTrack));
956 else
957 break;
958 }
959 if (currSegm == nullptr) {
960 qDebug("PasteSymbols: no segment for Lyrics");
961 e.skipCurrentElement();
962 continue;
963 }
964 if (!cr->isChord()) {
965 qDebug("PasteSymbols: can't paste Lyrics to rest");
966 e.skipCurrentElement();
967 continue;
968 }
969 Lyrics* el = new Lyrics(this);
970 el->setTrack(destTrack);
971 el->read(e);
972 el->setTrack(destTrack);
973 el->setParent(cr);
974 undoAddElement(el);
975 }
976 else {
977 qDebug("PasteSymbols: element %s not handled", tag.toUtf8().data());
978 e.skipCurrentElement(); // ignore
979 }
980 } // if !Harmony
981 } // if element
982 } // outer while readNextstartElement()
983 } // inner while readNextstartElement()
984 } // pasteSymbolList()
985
986 //---------------------------------------------------------
987 // cmdPaste
988 //---------------------------------------------------------
989
cmdPaste(const QMimeData * ms,MuseScoreView * view,Fraction scale)990 void Score::cmdPaste(const QMimeData* ms, MuseScoreView* view, Fraction scale)
991 {
992 if (ms == 0) {
993 qDebug("no application mime data");
994 MScore::setError(NO_MIME);
995 return;
996 }
997 if ((_selection.isSingle() || _selection.isList()) && ms->hasFormat(mimeSymbolFormat)) {
998 QByteArray data(ms->data(mimeSymbolFormat));
999
1000 QPointF dragOffset;
1001 Fraction duration(1, 4);
1002 std::unique_ptr<Element> el(Element::readMimeData(this, data, &dragOffset, &duration));
1003
1004 if (!el)
1005 return;
1006
1007 QList<Element*> els;
1008 if (_selection.isSingle())
1009 els.append(_selection.element());
1010 else
1011 els.append(_selection.elements());
1012
1013 for (Element* target : els) {
1014 el->setTrack(target->track());
1015 Element* nel = el->clone();
1016 addRefresh(target->abbox()); // layout() ?!
1017 EditData ddata(view);
1018 ddata.view = view;
1019 ddata.dropElement = nel;
1020 if (target->acceptDrop(ddata)) {
1021 if (el->isNote()) {
1022 // dropping a note replaces and invalidates the target,
1023 // so we need to deselect it
1024 ElementType targetType = target->type();
1025 deselect(target);
1026
1027 // perform the drop
1028 target->drop(ddata);
1029
1030 // if the target is a rest rather than a note,
1031 // a new note is generated, and nel becomes invalid as well
1032 // (ChordRest::drop() will select it for us)
1033 if (targetType == ElementType::NOTE)
1034 select(nel);
1035 }
1036 else {
1037 target->drop(ddata);
1038 }
1039 if (_selection.element())
1040 addRefresh(_selection.element()->abbox());
1041 }
1042 else
1043 delete nel;
1044 }
1045 }
1046 else if ((_selection.isRange() || _selection.isList()) && ms->hasFormat(mimeStaffListFormat)) {
1047 ChordRest* cr = 0;
1048 if (_selection.isRange())
1049 cr = _selection.firstChordRest();
1050 else if (_selection.isSingle()) {
1051 Element* e = _selection.element();
1052 if (!e->isNote() && !e->isChordRest()) {
1053 qDebug("cannot paste to %s", e->name());
1054 MScore::setError(DEST_NO_CR);
1055 return;
1056 }
1057 if (e->isNote())
1058 e = toNote(e)->chord();
1059 cr = toChordRest(e);
1060 }
1061 if (cr == 0) {
1062 MScore::setError(NO_DEST);
1063 return;
1064 }
1065 else if (cr->tuplet() && cr->tick() != cr->topTuplet()->tick()) {
1066 MScore::setError(DEST_TUPLET);
1067 return;
1068 }
1069 else {
1070 QByteArray data(ms->data(mimeStaffListFormat));
1071 if (MScore::debugMode)
1072 qDebug("paste <%s>", data.data());
1073 XmlReader e(data);
1074 e.setPasteMode(true);
1075 if (!pasteStaff(e, cr->segment(), cr->staffIdx(), scale))
1076 return;
1077 }
1078 }
1079 else if (ms->hasFormat(mimeSymbolListFormat)) {
1080 ChordRest* cr = 0;
1081 if (_selection.isRange())
1082 cr = _selection.firstChordRest();
1083 else if (_selection.isSingle()) {
1084 Element* e = _selection.element();
1085 if (!e->isNote() && !e->isRest() && !e->isChord()) {
1086 qDebug("cannot paste to %s", e->name());
1087 MScore::setError(DEST_NO_CR);
1088 return;
1089 }
1090 if (e->isNote())
1091 e = toNote(e)->chord();
1092 cr = toChordRest(e);
1093 }
1094 if (cr == 0) {
1095 MScore::setError(NO_DEST);
1096 return;
1097 }
1098 else {
1099 QByteArray data(ms->data(mimeSymbolListFormat));
1100 if (MScore::debugMode)
1101 qDebug("paste <%s>", data.data());
1102 XmlReader e(data);
1103 pasteSymbols(e, cr);
1104 }
1105 }
1106 else if (ms->hasImage()) {
1107 QImage im = qvariant_cast<QImage>(ms->imageData());
1108 QByteArray ba;
1109 QBuffer buffer(&ba);
1110 buffer.open(QIODevice::WriteOnly);
1111 im.save(&buffer, "PNG");
1112
1113 Image* image = new Image(this);
1114 image->setImageType(ImageType::RASTER);
1115 image->loadFromData("dragdrop", ba);
1116
1117 QList<Element*> els;
1118 if (_selection.isSingle())
1119 els.append(_selection.element());
1120 else
1121 els.append(_selection.elements());
1122
1123 for (Element* target : els) {
1124 Element* nel = image->clone();
1125 addRefresh(target->abbox()); // layout() ?!
1126 EditData ddata(view);
1127 ddata.view = view;
1128 ddata.dropElement = nel;
1129 target->drop(ddata);
1130 if (_selection.element())
1131 addRefresh(_selection.element()->abbox());
1132 }
1133 delete image;
1134 }
1135 else {
1136 qDebug("cannot paste selState %d staffList %s",
1137 int(_selection.state()), (ms->hasFormat(mimeStaffListFormat))? "true" : "false");
1138 for (const QString& s : ms->formats())
1139 qDebug(" format %s", qPrintable(s));
1140 }
1141 }
1142 }
1143