1 //=============================================================================
2 // MusE Score
3 // Linux Music Score Editor
4 //
5 // Copyright (C) 2002-2009 Werner Schweer and others
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 //
10 // This program is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with this program; if not, write to the Free Software
17 // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 //=============================================================================
19
20 #include "ove.h"
21
22 #include "mscore/preferences.h"
23
24 #include "libmscore/sig.h"
25 #include "libmscore/tempo.h"
26 #include "libmscore/arpeggio.h"
27 #include "libmscore/articulation.h"
28 #include "libmscore/barline.h"
29 #include "libmscore/box.h"
30 #include "libmscore/bracket.h"
31 #include "libmscore/breath.h"
32 #include "libmscore/chord.h"
33 #include "libmscore/clef.h"
34 #include "libmscore/drumset.h"
35 #include "libmscore/dynamic.h"
36 #include "libmscore/hairpin.h"
37 #include "libmscore/harmony.h"
38 #include "libmscore/glissando.h"
39 #include "libmscore/keysig.h"
40 #include "libmscore/layoutbreak.h"
41 #include "libmscore/lyrics.h"
42 #include "libmscore/measure.h"
43 #include "libmscore/note.h"
44 #include "libmscore/accidental.h"
45 #include "libmscore/ottava.h"
46 #include "libmscore/part.h"
47 #include "libmscore/pedal.h"
48 #include "libmscore/pitchspelling.h"
49 #include "libmscore/repeat.h"
50 #include "libmscore/rest.h"
51 #include "libmscore/score.h"
52 #include "libmscore/segment.h"
53 #include "libmscore/slur.h"
54 #include "libmscore/tie.h"
55 #include "libmscore/staff.h"
56 #include "libmscore/tempotext.h"
57 #include "libmscore/text.h"
58 #include "libmscore/timesig.h"
59 #include "libmscore/tuplet.h"
60 #include "libmscore/tremolo.h"
61 #include "libmscore/volta.h"
62 #include "libmscore/chordlist.h"
63 #include "libmscore/rehearsalmark.h"
64 #include "libmscore/marker.h"
65 #include "libmscore/jump.h"
66 #include "libmscore/sym.h"
67 #include "libmscore/bracketItem.h"
68
69 using namespace Ms;
70
71 class MeasureToTick {
72 public:
73 MeasureToTick();
74 ~MeasureToTick();
75
76 public:
77 void build(OVE::OveSong* ove, int quarter);
78
79 int getTick(int measure, int tick_pos);
80 static int unitToTick(int unit, int quarter);
81
82 struct TimeTick {
83 int numerator_;
84 int denominator_;
85 int measure_;
86 int tick_;
87 bool isSymbol_;
88
TimeTickMeasureToTick::TimeTick89 TimeTick():numerator_(4), denominator_(4), measure_(0), tick_(0), isSymbol_(false){}
90 };
91 QList<TimeTick> getTimeTicks() const;
92
93 private:
94 int quarter_;
95 OVE::OveSong* ove_;
96 QList<TimeTick> tts_;
97 };
98
getMeasureTick(int quarter,int num,int den)99 int getMeasureTick(int quarter, int num, int den){
100 return quarter * 4 * num / den;
101 }
102
MeasureToTick()103 MeasureToTick::MeasureToTick(){
104 quarter_ = 480;
105 ove_ = 0;
106 }
107
~MeasureToTick()108 MeasureToTick::~MeasureToTick(){
109 }
110
build(OVE::OveSong * ove,int quarter)111 void MeasureToTick::build(OVE::OveSong* ove, int quarter){
112 unsigned int i;
113 int currentTick = 0;
114 unsigned int measureCount = ove->getMeasureCount();
115
116 quarter_ = quarter;
117 ove_ = ove;
118 tts_.clear();
119
120 for(i=0; i<measureCount; ++i) {
121 OVE::Measure* measure = ove_->getMeasure(i);
122 OVE::TimeSignature* time = measure->getTime();
123 TimeTick tt;
124 bool change = false;
125
126 tt.tick_ = currentTick;
127 tt.numerator_ = time->getNumerator();
128 tt.denominator_ = time->getDenominator();
129 tt.measure_ = i;
130 tt.isSymbol_ = time->getIsSymbol();
131
132 if( i == 0 ){
133 change = true;
134 } else {
135 OVE::TimeSignature* previousTime = ove_->getMeasure(i-1)->getTime();
136
137 if( time->getNumerator() != previousTime->getNumerator() ||
138 time->getDenominator() != previousTime->getDenominator() ){
139 change = true;
140 } else if(time->getIsSymbol() != previousTime->getIsSymbol()){
141 change = true;
142 }
143 }
144
145 if( change ){
146 tts_.push_back(tt);
147 }
148
149 currentTick += getMeasureTick(quarter_, tt.numerator_, tt.denominator_);
150 }
151 }
152
getTick(int measure,int tick_pos)153 int MeasureToTick::getTick(int measure, int tick_pos){
154 TimeTick tt;
155
156 for(int i=0; i<tts_.size(); ++i) {
157 if( measure >= tts_[i].measure_ && ( i==tts_.size()-1 || measure < tts_[i+1].measure_ ) ) {
158 int measuresTick = (measure - tts_[i].measure_) * getMeasureTick(quarter_, tts_[i].numerator_, tts_[i].denominator_);
159 return tts_[i].tick_ + measuresTick + tick_pos;
160 }
161 }
162
163 return 0;
164 }
165
unitToTick(int unit,int quarter)166 int MeasureToTick::unitToTick(int unit, int quarter) {
167 // 0x100 correspond to quarter tick
168 float ratio = (float)unit / (float)256.0;
169 int tick = ratio * quarter;
170 return tick;
171 }
172
getTimeTicks() const173 QList<MeasureToTick::TimeTick> MeasureToTick::getTimeTicks() const {
174 return tts_;
175 }
176
177 ///////////////////////////////////////////////////////////////////
178 class OveToMScore {
179 public:
180 OveToMScore();
181 ~OveToMScore();
182
183 public:
184 void convert(OVE::OveSong* oveData, Score* score);
185
186 private:
187 void createStructure();
188 void convertHeader();
189 void convertGroups();
190 void convertTrackHeader(OVE::Track* track, Part* part);
191 void convertTrackElements(int track);
192 void convertLineBreak();
193 void convertSignatures();
194 void convertMeasures();
195 void convertMeasure(Measure* measure);
196 void convertMeasureMisc(Measure* measure, int part, int staff, int track);
197 void convertNotes(Measure* measure, int part, int staff, int track);
198 void convertArticulation(Measure* measure, ChordRest* cr, int track, int absTick, OVE::Articulation* art);
199 void convertLyrics(Measure* measure, int part, int staff, int track);
200 void convertHarmonys(Measure* measure, int part, int staff, int track);
201 void convertRepeats(Measure* measure, int part, int staff, int track);
202 void convertDynamics(Measure* measure, int part, int staff, int track);
203 void convertExpressions(Measure* measure, int part, int staff, int track);
204 void convertLines(Measure* measure);
205 void convertSlurs(Measure* measure, int part, int staff, int track);
206 void convertGlissandos(Measure* measure, int part, int staff, int track);
207 void convertWedges(Measure* measure, int part, int staff, int track);
208 void convertOctaveShifts(Measure* measure, int part, int staff, int track);
209
210 OVE::NoteContainer* getContainerByPos(int part, int staff, const OVE::MeasurePos& pos);
211 //OVE::MusicData* getMusicDataByUnit(int part, int staff, int measure, int unit, OVE::MusicDataType type);
212 OVE::MusicData* getCrossMeasureElementByPos(int part, int staff, const OVE::MeasurePos& pos, int voice, OVE::MusicDataType type);
213 ChordRest* findChordRestByPos(int absTick, int track);
214
215 void clearUp();
216
217 private:
218 OVE::OveSong* ove_;
219 Score* score_;
220 MeasureToTick* mtt_;
221
222 Pedal* pedal_;
223 };
224
OveToMScore()225 OveToMScore::OveToMScore() {
226 ove_ = 0;
227 mtt_ = new MeasureToTick();
228 pedal_ = 0;
229 }
230
~OveToMScore()231 OveToMScore::~OveToMScore() {
232 delete mtt_;
233 }
234
convert(OVE::OveSong * ove,Score * score)235 void OveToMScore::convert(OVE::OveSong* ove, Score* score) {
236 ove_ = ove;
237 score_ = score;
238 mtt_->build(ove_, ove_->getQuarter());
239
240 convertHeader();
241 createStructure();
242 convertGroups();
243 convertSignatures();
244 //convertLineBreak();
245
246 int staffCount = 0;
247 for(int i=0; i<ove_->getPartCount(); ++i ){
248 int partStaffCount = ove_->getStaffCount(i) ;
249 Part* part = score_->parts().at(i);
250
251 for(int j=0; j<partStaffCount; ++j){
252 OVE::Track* track = ove_->getTrack(i, j);
253
254 convertTrackHeader(track, part);
255 }
256
257 staffCount += partStaffCount;
258 }
259
260 convertMeasures();
261
262 // convert elements by ove track sequence
263 staffCount = 0;
264 for(int i=0; i<ove_->getPartCount(); ++i ){
265 int partStaffCount = ove_->getStaffCount(i) ;
266
267 for(int j=0; j<partStaffCount; ++j){
268 int trackIndex = staffCount + j;
269
270 convertTrackElements(trackIndex);
271 }
272
273 staffCount += partStaffCount;
274 }
275
276 clearUp();
277 }
278
createStructure()279 void OveToMScore::createStructure() {
280 int i;
281 for(i=0; i<ove_->getPartCount(); ++i ){
282 int partStaffCount = ove_->getStaffCount(i) ;
283 Part* part = new Part(score_);
284
285 for(int j=0; j<partStaffCount; ++j){
286 //OVE::Track* track = ove_->getTrack(i, j);
287 Staff* staff = new Staff(score_);
288 staff->setPart(part);
289
290 part->staves()->push_back(staff);
291 score_->staves().push_back(staff);
292 }
293
294 score_->appendPart(part);
295 part->setStaves(partStaffCount);
296 }
297
298 for(i = 0; i <ove_->getMeasureCount(); ++i) {
299 Measure* measure = new Measure(score_);
300 int tick = mtt_->getTick(i, 0);
301 measure->setTick(Fraction::fromTicks(tick));
302 measure->setNo(i);
303 score_->measures()->add(measure);
304 }
305 }
306
clearUp()307 void OveToMScore::clearUp() {
308 if(pedal_ != NULL) {
309 delete pedal_;
310 pedal_ = 0;
311 }
312 }
313
getStaff(const OVE::OveSong * ove,int track)314 OVE::Staff* getStaff(const OVE::OveSong* ove, int track) {
315 if (ove->getLineCount() > 0) {
316 OVE::Line* line = ove->getLine(0);
317 if(line != 0 && line->getStaffCount() > 0) {
318 OVE::Staff* staff = line->getStaff(track);
319 return staff;
320 }
321 }
322
323 return 0;
324 }
325
addText(VBox * & vbox,Score * s,QString strTxt,Tid stl)326 void addText(VBox* & vbox, Score* s, QString strTxt, Tid stl) {
327 if (!strTxt.isEmpty()) {
328 Text* text = new Text(s, stl);
329 text->setPlainText(strTxt);
330 if(vbox == 0) {
331 vbox = new VBox(s);
332 }
333 vbox->add(text);
334 }
335 }
336
convertHeader()337 void OveToMScore::convertHeader() {
338 VBox* vbox = 0;
339 QList<QString> titles = ove_->getTitles();
340 if( !titles.empty() && !titles[0].isEmpty() ) {
341 QString title = titles[0];
342 score_->setMetaTag("movementTitle", title);
343 addText(vbox, score_, title, Tid::TITLE);
344 }
345
346 QList<QString> copyrights = ove_->getCopyrights();
347 if( !copyrights.empty() && !copyrights[0].isEmpty() ) {
348 QString copyright = copyrights[0];
349 score_->setMetaTag("copyright", copyright);
350 }
351
352 QList<QString> annotates = ove_->getAnnotates();
353 if( !annotates.empty() && !annotates[0].isEmpty() ) {
354 QString annotate = annotates[0];
355 addText(vbox, score_, annotate, Tid::POET);
356 }
357
358 QList<QString> writers = ove_->getWriters();
359 if(!writers.empty()) {
360 QString composer = writers[0];
361 score_->setMetaTag("composer", composer);
362 addText(vbox, score_, composer, Tid::COMPOSER);
363 }
364
365 if(writers.size() > 1) {
366 QString lyricist = writers[1];
367 addText(vbox, score_, lyricist, Tid::POET);
368 }
369
370 if (vbox) {
371 vbox->setTick(Fraction(0,1));
372 score_->measures()->add(vbox);
373 }
374 }
375
convertGroups()376 void OveToMScore::convertGroups() {
377 int i;
378 int staffCount = 0;
379 const QList<Part*>& parts = score_->parts();
380 for(i=0; i<ove_->getPartCount(); ++i ){
381 int partStaffCount = ove_->getStaffCount(i);
382 //if(parts == 0)
383 // continue;
384 Part* part = parts.at(i);
385 if(part == 0)
386 continue;
387
388 for(int j=0; j<partStaffCount; ++j){
389 int staffIndex = staffCount + j;
390 Staff* staff = score_->staff(staffIndex);
391 if(staff == 0)
392 continue;
393
394 // brace
395 if( j == 0 && partStaffCount == 2 ) {
396 staff->setBracketType(0, BracketType::BRACE);
397 staff->setBracketSpan(0, 2);
398 staff->setBarLineSpan(2);
399 }
400
401 // bracket
402 OVE::Staff* staffPtr = getStaff(ove_, staffIndex);
403 if(staffPtr != 0 && staffPtr->getGroupType() == OVE::GroupType::Bracket) {
404 int span = staffPtr->getGroupStaffCount() + 1;
405 int endStaff = staffIndex + span;
406 if(span > 0 && endStaff >= staffIndex && endStaff <= ove_->getTrackCount()) {
407 staff->addBracket(new BracketItem(staff->score(), BracketType::NORMAL, span));
408 staff->setBarLineSpan(span);
409 }
410 }
411 }
412
413 staffCount += partStaffCount;
414 }
415 }
416
OveClefToClef(OVE::ClefType type)417 ClefType OveClefToClef(OVE::ClefType type){
418 ClefType clef = ClefType::G;
419 switch(type){
420 case OVE::ClefType::Treble:{
421 clef = ClefType::G;
422 break;
423 }
424 case OVE::ClefType::Bass:{
425 clef = ClefType::F;
426 break;
427 }
428 case OVE::ClefType::Alto:{
429 clef = ClefType::C3;
430 break;
431 }
432 case OVE::ClefType::UpAlto:{
433 clef = ClefType::C4;
434 break;
435 }
436 case OVE::ClefType::DownDownAlto:{
437 clef = ClefType::C1;
438 break;
439 }
440 case OVE::ClefType::DownAlto:{
441 clef = ClefType::C2;
442 break;
443 }
444 case OVE::ClefType::UpUpAlto:{
445 clef = ClefType::C5;
446 break;
447 }
448 case OVE::ClefType::Treble8va:{
449 clef = ClefType::G8_VA;
450 break;
451 }
452 case OVE::ClefType::Bass8va:{
453 clef = ClefType::F_8VA;
454 break;
455 }
456 case OVE::ClefType::Treble8vb:{
457 clef = ClefType::G8_VB;
458 break;
459 }
460 case OVE::ClefType::Bass8vb:{
461 clef = ClefType::F8_VB;
462 break;
463 }
464 case OVE::ClefType::Percussion1:{
465 clef = ClefType::PERC;
466 break;
467 }
468 case OVE::ClefType::Percussion2:{
469 clef = ClefType::PERC2;
470 break;
471 }
472 case OVE::ClefType::TAB:{
473 clef = ClefType::TAB;
474 break;
475 }
476 default:
477 break;
478 }
479 return clef;
480 }
481
getHeadGroup(OVE::NoteHeadType type)482 NoteHead::Group getHeadGroup(OVE::NoteHeadType type) {
483 NoteHead::Group headGroup = NoteHead::Group::HEAD_NORMAL;
484 switch (type) {
485 case OVE::NoteHeadType::Standard: {
486 headGroup = NoteHead::Group::HEAD_NORMAL;
487 break;
488 }
489 case OVE::NoteHeadType::Invisible: {
490 break;
491 }
492 case OVE::NoteHeadType::Rhythmic_Slash: {
493 headGroup = NoteHead::Group::HEAD_SLASH;
494 break;
495 }
496 case OVE::NoteHeadType::Percussion: {
497 headGroup = NoteHead::Group::HEAD_XCIRCLE;
498 break;
499 }
500 case OVE::NoteHeadType::Closed_Rhythm: {
501 headGroup = NoteHead::Group::HEAD_CROSS;
502 break;
503 }
504 case OVE::NoteHeadType::Open_Rhythm: {
505 headGroup = NoteHead::Group::HEAD_CROSS;
506 break;
507 }
508 case OVE::NoteHeadType::Closed_Slash: {
509 headGroup = NoteHead::Group::HEAD_SLASH;
510 break;
511 }
512 case OVE::NoteHeadType::Open_Slash: {
513 headGroup = NoteHead::Group::HEAD_SLASH;
514 break;
515 }
516 case OVE::NoteHeadType::Closed_Do: {
517 headGroup = NoteHead::Group::HEAD_DO;
518 break;
519 }
520 case OVE::NoteHeadType::Open_Do: {
521 headGroup = NoteHead::Group::HEAD_DO;
522 break;
523 }
524 case OVE::NoteHeadType::Closed_Re: {
525 headGroup = NoteHead::Group::HEAD_RE;
526 break;
527 }
528 case OVE::NoteHeadType::Open_Re: {
529 headGroup = NoteHead::Group::HEAD_RE;
530 break;
531 }
532 case OVE::NoteHeadType::Closed_Mi: {
533 headGroup = NoteHead::Group::HEAD_MI;
534 break;
535 }
536 case OVE::NoteHeadType::Open_Mi: {
537 headGroup = NoteHead::Group::HEAD_MI;
538 break;
539 }
540 case OVE::NoteHeadType::Closed_Fa: {
541 headGroup = NoteHead::Group::HEAD_FA;
542 break;
543 }
544 case OVE::NoteHeadType::Open_Fa: {
545 headGroup = NoteHead::Group::HEAD_FA;
546 break;
547 }
548 case OVE::NoteHeadType::Closed_Sol: {
549 break;
550 }
551 case OVE::NoteHeadType::Open_Sol: {
552 break;
553 }
554 case OVE::NoteHeadType::Closed_La: {
555 headGroup = NoteHead::Group::HEAD_LA;
556 break;
557 }
558 case OVE::NoteHeadType::Open_La: {
559 headGroup = NoteHead::Group::HEAD_LA;
560 break;
561 }
562 case OVE::NoteHeadType::Closed_Ti: {
563 headGroup = NoteHead::Group::HEAD_TI;
564 break;
565 }
566 case OVE::NoteHeadType::Open_Ti: {
567 headGroup = NoteHead::Group::HEAD_TI;
568 break;
569 }
570 default: {
571 break;
572 }
573 }
574
575 return headGroup;
576 }
577
convertTrackHeader(OVE::Track * track,Part * part)578 void OveToMScore::convertTrackHeader(OVE::Track* track, Part* part){
579 if(track == 0 || part == 0)
580 return;
581
582 QString longName = track->getName();
583 if (longName != QString() && track->getShowName()){
584 part->setPlainLongName(longName);
585 }
586
587 QString shortName = track->getBriefName();
588 if (shortName != QString() && track->getShowBriefName()) {
589 part->setPlainShortName(shortName);
590 }
591
592 part->setMidiProgram(track->getPatch());
593
594 if (ove_->getShowTransposeTrack() && track->getTranspose() != 0 ) {
595 Ms::Interval interval = part->instrument()->transpose();
596 interval.diatonic = -track->getTranspose();
597 part->instrument()->setTranspose(interval);
598 }
599
600 // DrumSet
601 if(track->getStartClef()==OVE::ClefType::Percussion1 || track->getStartClef()==OVE::ClefType::Percussion2) {
602 //use overture drumset
603 Drumset* drumset = new Drumset();
604 for (int i = 0; i < DRUM_INSTRUMENTS; ++i) {
605 drumset->drum(i).name = smDrumset->drum(i).name;
606 drumset->drum(i).notehead = smDrumset->drum(i).notehead;
607 drumset->drum(i).line = smDrumset->drum(i).line;
608 drumset->drum(i).stemDirection = smDrumset->drum(i).stemDirection;
609 drumset->drum(i).voice = smDrumset->drum(i).voice;
610 drumset->drum(i).shortcut = 0;
611 }
612 QList<OVE::Track::DrumNode> nodes = track->getDrumKit();
613 for (int i=0; i<nodes.size(); ++i) {
614 int pitch = nodes[i].pitch_;
615 OVE::Track::DrumNode node = nodes[i];
616 if (pitch < DRUM_INSTRUMENTS) {
617 drumset->drum(pitch).line = node.line_;
618 drumset->drum(pitch).notehead = getHeadGroup(OVE::NoteHeadType(node.headType_));
619 drumset->drum(pitch).voice = node.voice_;
620 }
621 }
622
623 part->instrument()->channel(0)->setBank(128);
624 part->setMidiProgram(0);
625 part->instrument()->setDrumset(smDrumset);
626 part->instrument()->setDrumset(drumset);
627 }
628 }
629
OctaveShiftTypeToInt(OVE::OctaveShiftType type)630 static OttavaType OctaveShiftTypeToInt(OVE::OctaveShiftType type) {
631 OttavaType subtype = OttavaType::OTTAVA_8VA;
632 switch (type) {
633 case OVE::OctaveShiftType::OS_8: {
634 subtype = OttavaType::OTTAVA_8VA;
635 break;
636 }
637 case OVE::OctaveShiftType::OS_15: {
638 subtype = OttavaType::OTTAVA_15MA;
639 break;
640 }
641 case OVE::OctaveShiftType::OS_Minus_8: {
642 subtype = OttavaType::OTTAVA_8VB;
643 break;
644 }
645 case OVE::OctaveShiftType::OS_Minus_15: {
646 subtype = OttavaType::OTTAVA_15MB;
647 break;
648 }
649 default:
650 break;
651 }
652
653 return subtype;
654 }
655
convertTrackElements(int track)656 void OveToMScore::convertTrackElements(int track) {
657 Ottava* ottava = 0;
658
659 for(int i=0; i<ove_->getTrackBarCount(); ++i) {
660 OVE::MeasureData* measureData = ove_->getMeasureData(track, i);
661 if(measureData == 0)
662 continue;
663
664 // octave shift
665 QList<OVE::MusicData*> octaves = measureData->getMusicDatas(OVE::MusicDataType::OctaveShift_EndPoint);
666 for(int j=0; j<octaves.size(); ++j) {
667 OVE::OctaveShiftEndPoint* octave = static_cast<OVE::OctaveShiftEndPoint*>(octaves[j]);
668 int absTick = mtt_->getTick(i, octave->getTick());
669
670 if(octave->getOctaveShiftPosition() == OVE::OctaveShiftPosition::Start) {
671 if(ottava == 0) {
672 ottava = new Ottava(score_);
673 ottava->setTrack(track * VOICES);
674 ottava->setOttavaType(OctaveShiftTypeToInt(octave->getOctaveShiftType()));
675
676 int y_off = 0;
677 switch (octave->getOctaveShiftType()) {
678 case OVE::OctaveShiftType::OS_8:
679 case OVE::OctaveShiftType::OS_15: {
680 y_off = -3;
681 break;
682 }
683 case OVE::OctaveShiftType::OS_Minus_8:
684 case OVE::OctaveShiftType::OS_Minus_15: {
685 y_off = 8;
686 break;
687 }
688 default:{
689 break;
690 }
691 }
692
693 if(y_off != 0) {
694 ottava->setOffset(QPointF(0, y_off * score_->spatium()));
695 }
696
697 ottava->setTick(Fraction::fromTicks(absTick));
698
699 } else {
700 qDebug("overlapping octave-shift not supported");
701 delete ottava;
702 ottava = 0;
703 }
704 } else if (octave->getOctaveShiftPosition() == OVE::OctaveShiftPosition::Stop) {
705 if(ottava != 0) {
706 ottava->setTick2(Fraction::fromTicks(absTick));
707 score_->addSpanner(ottava);
708 ottava->staff()->updateOttava();
709 ottava = 0;
710 } else {
711 qDebug("octave-shift stop without start");
712 }
713 }
714 }
715 }
716 }
717
convertLineBreak()718 void OveToMScore::convertLineBreak(){
719 for (MeasureBase* mb = score_->measures()->first(); mb; mb = mb->next()) {
720 if (mb->type() != ElementType::MEASURE)
721 continue;
722 Measure* measure = static_cast<Measure*> (mb);
723
724 for (int i = 0; i < ove_->getLineCount(); ++i) {
725 OVE::Line* line = ove_->getLine(i);
726 if (measure->no() > 0) {
727 if ((int)line->getBeginBar() + (int)line->getBarCount()-1 == measure->no()) {
728 LayoutBreak* lb = new LayoutBreak(score_);
729 lb->setTrack(0);
730 lb->setLayoutBreakType(LayoutBreak::Type::LINE);
731 measure->add(lb);
732 }
733 }
734 }
735 }
736 }
737
convertSignatures()738 void OveToMScore::convertSignatures(){
739 int i;
740 int j;
741 int k;
742
743 // Time
744 const QList<MeasureToTick::TimeTick> tts = mtt_->getTimeTicks() ;
745 for( i=0; i<(int)tts.size(); ++i ){
746 MeasureToTick::TimeTick tt = tts[i];
747 Fraction f(tt.numerator_, tt.denominator_);
748
749 TimeSigMap* sigmap = score_->sigmap();
750 sigmap->add(tt.tick_, f);
751
752 Measure* measure = score_->tick2measure(Fraction::fromTicks(tt.tick_));
753 if(measure){
754 for(int staffIdx = 0; staffIdx < score_->nstaves(); ++staffIdx) {
755 TimeSigType subtype = TimeSigType::NORMAL;
756 if(tt.numerator_ == 4 && tt.denominator_ == 4 && tt.isSymbol_ ){
757 subtype = TimeSigType::FOUR_FOUR;
758 } else if(tt.numerator_ == 2 && tt.denominator_ == 2 && tt.isSymbol_ ){
759 subtype = TimeSigType::ALLA_BREVE;
760 }
761
762 TimeSig* ts = new TimeSig(score_);
763 ts->setTrack(staffIdx * VOICES);
764 ts->setSig(Fraction(tt.numerator_, tt.denominator_), subtype);
765
766 Segment* seg = measure->getSegment(SegmentType::TimeSig, Fraction::fromTicks(tt.tick_));
767 seg->add(ts);
768 }
769 }
770 }
771
772 // Key
773 int staffCount = 0;
774 bool createKey = false ;
775 for(i=0; i<ove_->getPartCount(); ++i ){
776 int partStaffCount = ove_->getStaffCount(i) ;
777
778 for(j=0; j<partStaffCount; ++j){
779 for(k=0; k<ove_->getMeasureCount(); ++k){
780 OVE::MeasureData* measureData = ove_->getMeasureData(i, j, k) ;
781
782 if( measureData != 0 ){
783 OVE::Key* keyPtr = measureData->getKey() ;
784
785 if( k == 0 || keyPtr->getKey() != keyPtr->getPreviousKey() ) {
786 int tick = mtt_->getTick(k, 0);
787 int keyValue = keyPtr->getKey();
788 Measure* measure = score_->tick2measure(Fraction::fromTicks(tick));
789 if(measure){
790 KeySigEvent ke;
791 ke.setKey(Key(keyValue));
792 score_->staff(staffCount+j)->setKey(Fraction::fromTicks(tick), ke);
793
794 KeySig* keysig = new KeySig(score_);
795 keysig->setTrack((staffCount+j) * VOICES);
796 keysig->setKeySigEvent(ke);
797
798 Segment* s = measure->getSegment(SegmentType::KeySig, Fraction::fromTicks(tick));
799 s->add(keysig);
800
801 createKey = true;
802 }
803 }
804 }
805 }
806 }
807
808 staffCount += partStaffCount;
809 }
810
811 if( !createKey ){
812 staffCount = 0;
813 for(i=0; i<ove_->getPartCount(); ++i ){
814 int partStaffCount = ove_->getStaffCount(i) ;
815
816 for(j=0; j<partStaffCount; ++j){
817 Measure* measure = score_->tick2measure(Fraction::fromTicks(mtt_->getTick(0, 0)));
818 if(measure){
819 KeySig* keysig = new KeySig(score_);
820 keysig->setTrack((staffCount+j) * VOICES);
821 keysig->setKeySigEvent(KeySigEvent());
822
823 Segment* s = measure->getSegment(SegmentType::KeySig, Fraction(0,1));
824 s->add(keysig);
825 }
826 }
827 staffCount += partStaffCount;
828 }
829 }
830
831 // Clef
832 staffCount = 0;
833 for(i=0; i<ove_->getPartCount(); ++i){
834 int partStaffCount = ove_->getStaffCount(i) ;
835 for(j=0; j<partStaffCount; ++j){
836 // start clef
837 Staff* staff = score_->staff(staffCount+j);
838 if(staff){
839 OVE::Track* track = ove_->getTrack(i, j);
840 ClefType clefType = OveClefToClef(track->getStartClef());
841 Measure* measure = score_->tick2measure(Fraction(0,1));
842 // staff->setClef(0, clefType);
843
844 // note: also generate symbol for tick 0
845 // was not necessary before 0.9.6
846 Clef* clef = new Clef(score_);
847 clef->setClefType(clefType);
848 clef->setTrack((staffCount+j)*VOICES);
849
850 Segment* s = measure->getSegment(SegmentType::HeaderClef, Fraction(0,1));
851 s->add(clef);
852 }
853
854 // clef in measure
855 for(k=0; k<ove_->getMeasureCount(); ++k){
856 OVE::MeasureData* measureData = ove_->getMeasureData(i, j, k);
857 QList<OVE::MusicData*> clefs = measureData->getMusicDatas(OVE::MusicDataType::Clef);
858 Measure* measure = score_->tick2measure(Fraction::fromTicks(mtt_->getTick(k, 0)));
859
860 for( int l=0; l<clefs.size(); ++l){
861 if(measure != 0){
862 OVE::Clef* clefPtr = static_cast<OVE::Clef*>(clefs[l]);
863 int absTick = mtt_->getTick(k, clefPtr->getTick());
864 ClefType clefType = OveClefToClef(clefPtr->getClefType());
865
866 Clef* clef = new Clef(score_);
867 clef->setClefType(clefType);
868 clef->setTrack((staffCount+j)*VOICES);
869
870 Segment* s = measure->getSegment(SegmentType::Clef, Fraction::fromTicks(absTick));
871 s->add(clef);
872 }
873 }
874 }
875 }
876
877 staffCount += partStaffCount;
878 }
879
880 // Tempo
881 std::map<int, double> tempos;
882 for(i=0; i<ove_->getPartCount(); ++i){
883 int partStaffCount = ove_->getStaffCount(i);
884
885 for(j=0; j<partStaffCount; ++j){
886 for(k=0; k<ove_->getMeasureCount(); ++k){
887 OVE::Measure* measure = ove_->getMeasure(k);
888 OVE::MeasureData* measureData = ove_->getMeasureData(i, j, k);
889 QList<OVE::MusicData*> tempoPtrs = measureData->getMusicDatas(OVE::MusicDataType::Tempo);
890
891 if(k==0 || ( k>0 && qAbs(measure->getTypeTempo()-ove_->getMeasure(k-1)->getTypeTempo())>0.01 )){
892 int tick = mtt_->getTick(k, 0);
893 tempos[tick] = measure->getTypeTempo();
894 }
895
896 for(int l=0; l<tempoPtrs.size(); ++l) {
897 OVE::Tempo* ptr = static_cast<OVE::Tempo*>(tempoPtrs[l]);
898 int tick = mtt_->getTick(measure->getBarNumber()->getIndex(), ptr->getTick());
899 double tempo = ptr->getQuarterTempo()>0 ? ptr->getQuarterTempo() : 1.0;
900
901 tempos[tick] = tempo;
902 }
903 }
904 }
905 }
906
907 std::map<int, double>::iterator it;
908 int lastTempo = 0;
909 for(it=tempos.begin(); it!=tempos.end(); ++it) {
910 if( it==tempos.begin() || (*it).second != lastTempo ) {
911 double tpo = ((*it).second) / 60.0;
912 score_->setTempo(Fraction::fromTicks((*it).first), tpo);
913 }
914
915 lastTempo = (*it).second;
916 }
917 }
918
ContainerToTick(OVE::NoteContainer * container,int quarter)919 int ContainerToTick(OVE::NoteContainer* container, int quarter){
920 int tick = OVE::NoteTypeToTick(container->getNoteType(), quarter);
921
922 int dotLength = tick;
923 for( int i=0; i<container->getDot(); ++i ) {
924 dotLength /= 2;
925 }
926 dotLength = tick - dotLength;
927
928 if(container->getTuplet() > 0) {
929 tick = tick * container->getSpace() / container->getTuplet();
930 }
931
932 tick += dotLength;
933
934 return tick;
935 }
936
getTuplet(const QList<OVE::MusicData * > & tuplets,int unit)937 const OVE::Tuplet* getTuplet(const QList<OVE::MusicData*>& tuplets, int unit){
938 for(int i=0; i<tuplets.size(); ++i){
939 const OVE::MusicData* data = tuplets[i];
940 if(unit >= data->start()->getOffset() && unit <= data->stop()->getOffset()){
941 const OVE::Tuplet* tuplet = static_cast<OVE::Tuplet*>(tuplets[i]);
942 return tuplet;
943 }
944 }
945 return 0;
946 }
947
OveNoteType_To_Duration(OVE::NoteType noteType)948 TDuration OveNoteType_To_Duration(OVE::NoteType noteType){
949 TDuration d;
950 switch(noteType){
951 case OVE::NoteType::Note_DoubleWhole: {
952 d.setType(TDuration::DurationType::V_BREVE);
953 break;
954 }
955 case OVE::NoteType::Note_Whole: {
956 d.setType(TDuration::DurationType::V_WHOLE);
957 break;
958 }
959 case OVE::NoteType::Note_Half: {
960 d.setType(TDuration::DurationType::V_HALF);
961 break;
962 }
963 case OVE::NoteType::Note_Quarter: {
964 d.setType(TDuration::DurationType::V_QUARTER);
965 break;
966 }
967 case OVE::NoteType::Note_Eight: {
968 d.setType(TDuration::DurationType::V_EIGHTH);
969 break;
970 }
971 case OVE::NoteType::Note_Sixteen: {
972 d.setType(TDuration::DurationType::V_16TH);
973 break;
974 }
975 case OVE::NoteType::Note_32: {
976 d.setType(TDuration::DurationType::V_32ND);
977 break;
978 }
979 case OVE::NoteType::Note_64: {
980 d.setType(TDuration::DurationType::V_64TH);
981 break;
982 }
983 case OVE::NoteType::Note_128: {
984 d.setType(TDuration::DurationType::V_128TH);
985 break;
986 }
987 case OVE::NoteType::Note_256: {
988 d.setType(TDuration::DurationType::V_256TH);
989 break;
990 }
991 // case OVE::NoteType::Note_512: {
992 // d.setType(TDuration::DurationType::V_512TH);
993 // break;
994 // }
995 // case OVE::NoteType::Note_1024: {
996 // d.setType(TDuration::DurationType::V_1024TH);
997 // break;
998 // }
999 default:
1000 d.setType(TDuration::DurationType::V_QUARTER);
1001 break;
1002 }
1003
1004 return d;
1005 }
1006
accidentalToAlter(OVE::AccidentalType type)1007 int accidentalToAlter(OVE::AccidentalType type) {
1008 int alter = 0;
1009
1010 switch( type ) {
1011 case OVE::AccidentalType::Normal:
1012 case OVE::AccidentalType::Natural:
1013 case OVE::AccidentalType::Natural_Caution: {
1014 alter = 0;
1015 break;
1016 }
1017 case OVE::AccidentalType::Sharp:
1018 case OVE::AccidentalType::Sharp_Caution: {
1019 alter = 1;
1020 break;
1021 }
1022 case OVE::AccidentalType::Flat:
1023 case OVE::AccidentalType::Flat_Caution: {
1024 alter = -1;
1025 break;
1026 }
1027 case OVE::AccidentalType::DoubleSharp:
1028 case OVE::AccidentalType::DoubleSharp_Caution: {
1029 alter = 2;
1030 break;
1031 }
1032 case OVE::AccidentalType::DoubleFlat:
1033 case OVE::AccidentalType::DoubleFlat_Caution: {
1034 alter = -2;
1035 break;
1036 }
1037 default:
1038 break;
1039 }
1040
1041 return alter;
1042 }
1043
getMiddleToneOctave(OVE::ClefType clef,OVE::ToneType & tone,int & octave)1044 void getMiddleToneOctave(OVE::ClefType clef, OVE::ToneType& tone, int& octave) {
1045 tone = OVE::ToneType::B;
1046 octave = 4;
1047
1048 switch ( clef ) {
1049 case OVE::ClefType::Treble: {
1050 tone = OVE::ToneType::B;
1051 octave = 4;
1052 break;
1053 }
1054 case OVE::ClefType::Treble8va: {
1055 tone = OVE::ToneType::B;
1056 octave = 5;
1057 break;
1058 }
1059 case OVE::ClefType::Treble8vb: {
1060 tone = OVE::ToneType::B;
1061 octave = 3;
1062 break;
1063 }
1064 case OVE::ClefType::Bass: {
1065 tone = OVE::ToneType::D;
1066 octave = 3;
1067 break;
1068 }
1069 case OVE::ClefType::Bass8va: {
1070 tone = OVE::ToneType::D;
1071 octave = 4;
1072 break;
1073 }
1074 case OVE::ClefType::Bass8vb: {
1075 tone = OVE::ToneType::D;
1076 octave = 2;
1077 break;
1078 }
1079 case OVE::ClefType::Alto: {
1080 tone = OVE::ToneType::C;
1081 octave = 4;
1082 break;
1083 }
1084 case OVE::ClefType::UpAlto: {
1085 tone = OVE::ToneType::A;
1086 octave = 3;
1087 break;
1088 }
1089 case OVE::ClefType::DownDownAlto: {
1090 tone = OVE::ToneType::G;
1091 octave = 4;
1092 break;
1093 }
1094 case OVE::ClefType::DownAlto: {
1095 tone = OVE::ToneType::E;
1096 octave = 4;
1097 break;
1098 }
1099 case OVE::ClefType::UpUpAlto: {
1100 tone = OVE::ToneType::F;
1101 octave = 3;
1102 break;
1103 }
1104 case OVE::ClefType::Percussion1: {
1105 tone = OVE::ToneType::A;
1106 octave = 3;
1107 break;
1108 }
1109 case OVE::ClefType::Percussion2: {
1110 tone = OVE::ToneType::A;
1111 octave = 3;
1112 break;
1113 }
1114 case OVE::ClefType::TAB: {
1115 break;
1116 }
1117 default:
1118 break;
1119 }
1120 }
1121
getClefType(OVE::MeasureData * measure,int tick)1122 OVE::ClefType getClefType(OVE::MeasureData* measure, int tick) {
1123 OVE::ClefType type = measure->getClef()->getClefType();
1124 QList<OVE::MusicData*> clefs = measure->getMusicDatas(OVE::MusicDataType::Clef);
1125
1126 for(int i=0; i<clefs.size(); ++i){
1127 if(tick < clefs[i]->getTick()){
1128 break;
1129 }
1130 if(tick >= clefs[i]->getTick()){
1131 OVE::Clef* clef = static_cast<OVE::Clef*>(clefs[i]);
1132 type = clef->getClefType();
1133 }
1134 }
1135
1136 return type;
1137 }
1138
convertMeasures()1139 void OveToMScore::convertMeasures() {
1140 for (MeasureBase* mb = score_->measures()->first(); mb; mb = mb->next()) {
1141 if (mb->type() != ElementType::MEASURE)
1142 continue;
1143 Measure* measure = static_cast<Measure*>(mb);
1144 int tick = measure->tick().ticks();
1145 measure->setTicks(score_->sigmap()->timesig(tick).timesig());
1146 measure->setTimesig(score_->sigmap()->timesig(tick).timesig()); //?
1147 convertMeasure(measure);
1148 }
1149
1150 // convert based on notes
1151 for (MeasureBase* mb = score_->measures()->first(); mb; mb = mb->next()) {
1152 if (mb->type() != ElementType::MEASURE)
1153 continue;
1154 Measure* measure = static_cast<Measure*>(mb);
1155
1156 convertLines(measure);
1157 }
1158 }
1159
convertMeasure(Measure * measure)1160 void OveToMScore::convertMeasure(Measure* measure){
1161 int staffCount = 0;
1162 int measureCount = ove_->getMeasureCount();
1163
1164 for (int i=0; i < ove_->getPartCount(); ++i) {
1165 int partStaffCount = ove_->getStaffCount(i);
1166
1167 for (int j=0; j < partStaffCount; ++j) {
1168 int measureID = measure->no();
1169
1170 if (measureID >= 0 && measureID < measureCount) {
1171 int trackIndex = (staffCount + j) * VOICES;
1172
1173 convertMeasureMisc(measure, i, j, trackIndex);
1174 convertNotes(measure, i, j, trackIndex);
1175 convertLyrics(measure, i, j, trackIndex);
1176 convertHarmonys(measure, i, j, trackIndex);
1177 convertRepeats(measure, i, j, trackIndex);
1178 convertDynamics(measure, i, j, trackIndex);
1179 convertExpressions(measure, i, j, trackIndex);
1180 }
1181 }
1182
1183 staffCount += partStaffCount;
1184 }
1185 }
1186
convertLines(Measure * measure)1187 void OveToMScore::convertLines(Measure* measure){
1188 int staffCount = 0;
1189 int measureCount = ove_->getMeasureCount();
1190
1191 for( int i=0; i<ove_->getPartCount(); ++i ){
1192 int partStaffCount = ove_->getStaffCount(i);
1193
1194 for( int j=0; j<partStaffCount; ++j ){
1195 int measureID = measure->no();
1196
1197 if (measureID >= 0 && measureID < measureCount) {
1198 int trackIndex = (staffCount + j) * VOICES;
1199
1200 convertSlurs(measure, i, j, trackIndex);
1201 convertGlissandos(measure, i, j, trackIndex);
1202 convertWedges(measure, i, j, trackIndex);
1203 }
1204 }
1205
1206 staffCount += partStaffCount;
1207 }
1208 }
1209
convertMeasureMisc(Measure * measure,int part,int staff,int track)1210 void OveToMScore::convertMeasureMisc(Measure* measure, int part, int staff, int track){
1211 OVE::Measure* measurePtr = ove_->getMeasure(measure->no());
1212 OVE::MeasureData* measureData = ove_->getMeasureData(part, staff, measure->no());
1213 if(measurePtr == 0 || measureData == 0)
1214 return;
1215
1216 // pickup
1217 if(measurePtr->getIsPickup()){
1218 measure->setIrregular(true);
1219 }
1220
1221 // multiple measure rest
1222 if(measurePtr->getIsMultiMeasureRest()){
1223 measure->setBreakMultiMeasureRest(true);
1224 }
1225
1226 // barline
1227 BarLineType bartype = BarLineType::NORMAL;
1228
1229 switch(measurePtr->getRightBarline()) {
1230 case OVE::BarLineType::Default:{
1231 bartype = BarLineType::NORMAL;
1232 break;
1233 }
1234 case OVE::BarLineType::Double:{
1235 bartype = BarLineType::DOUBLE;
1236 break;
1237 }
1238 case OVE::BarLineType::Final:{
1239 bartype = BarLineType::END;
1240 break;
1241 }
1242 case OVE::BarLineType::Null:{
1243 bartype = BarLineType::NORMAL;
1244 break;
1245 }
1246 case OVE::BarLineType::RepeatLeft:{
1247 bartype = BarLineType::START_REPEAT;
1248 measure->setRepeatStart(true);
1249 break;
1250 }
1251 case OVE::BarLineType::RepeatRight:{
1252 bartype = BarLineType::END_REPEAT;
1253 measure->setRepeatEnd(true);
1254 break;
1255 }
1256 case OVE::BarLineType::Dashed:{
1257 bartype = BarLineType::BROKEN;
1258 break;
1259 }
1260 default:
1261 break;
1262 }
1263
1264 if (bartype != BarLineType::NORMAL && bartype != BarLineType::END_REPEAT && bartype != BarLineType::START_REPEAT && bartype != BarLineType::END_START_REPEAT && bartype != BarLineType::END)
1265 measure->setEndBarLineType(bartype, 0);
1266
1267 if (bartype == BarLineType::END_REPEAT)
1268 measure->setRepeatEnd(true);
1269
1270 if(measurePtr->getLeftBarline() == OVE::BarLineType::RepeatLeft){
1271 //bartype = BarLineType::START_REPEAT;
1272 measure->setRepeatStart(true);
1273 }
1274
1275 // rehearsal
1276 int i;
1277 QList<OVE::MusicData*> texts = measureData->getMusicDatas(OVE::MusicDataType::Text);
1278 for(i=0; i<texts.size(); ++i){
1279 OVE::Text* textPtr = static_cast<OVE::Text*>(texts[i]);
1280 if(textPtr->getTextType() == OVE::Text::Type::Rehearsal){
1281 RehearsalMark* text = new RehearsalMark(score_);
1282 text->setPlainText(textPtr->getText());
1283 //TODO:ws text->setAbove(true);
1284 text->setTrack(track);
1285
1286 Segment* s = measure->getSegment(SegmentType::ChordRest,
1287 Fraction::fromTicks(mtt_->getTick(measure->no(), 0)));
1288 s->add(text);
1289 }
1290 }
1291
1292 // tempo
1293 QList<OVE::MusicData*> tempos = measureData->getMusicDatas(OVE::MusicDataType::Tempo);
1294 for(i=0; i<tempos.size(); ++i){
1295 OVE::Tempo* tempoPtr = static_cast<OVE::Tempo*>(tempos[i]);
1296 TempoText* t = new TempoText(score_);
1297 int absTick = mtt_->getTick(measure->no(), tempoPtr->getTick());
1298 double tpo = (tempoPtr->getQuarterTempo())/60.0;
1299
1300 score_->setTempo(Fraction::fromTicks(absTick), tpo);
1301
1302 t->setTempo(tpo);
1303 QString durationTempoL;
1304 QString durationTempoR;
1305 if (static_cast<int>(tempoPtr->getLeftNoteType()))
1306 durationTempoL = TempoText::duration2tempoTextString(OveNoteType_To_Duration(tempoPtr->getLeftNoteType()));
1307 if (static_cast<int>(tempoPtr->getRightNoteType()))
1308 durationTempoR = TempoText::duration2tempoTextString(OveNoteType_To_Duration(tempoPtr->getRightNoteType()));
1309 QString textTempo;
1310 if (tempoPtr->getShowBeforeText())
1311 textTempo += (tempoPtr->getLeftText()).toHtmlEscaped();
1312 if (tempoPtr->getShowMark()) {
1313 if (!textTempo.isEmpty())
1314 textTempo += " ";
1315 if (tempoPtr->getShowParenthesis())
1316 textTempo += "(";
1317 textTempo += durationTempoL;
1318 if (tempoPtr->getLeftNoteDot())
1319 textTempo += "<sym>space</sym><sym>metAugmentationDot</sym>";
1320 textTempo += " = ";
1321 switch (tempoPtr->getRightSideType()) {
1322 case 1:
1323 textTempo += durationTempoR;
1324 if (tempoPtr->getRightNoteDot())
1325 textTempo += "<sym>space</sym><sym>metAugmentationDot</sym>";
1326 break;
1327 case 2:
1328 textTempo += (tempoPtr->getRightText()).toHtmlEscaped();
1329 break;
1330 case 3:
1331 textTempo += QString::number(qFloor(tempoPtr->getTypeTempo()));
1332 break;
1333 case 0:
1334 default:
1335 textTempo += QString::number(tempoPtr->getTypeTempo());
1336 break;
1337 }
1338 if (tempoPtr->getShowParenthesis())
1339 textTempo += ")";
1340 }
1341 if (textTempo.isEmpty()) {
1342 textTempo = durationTempoL;
1343 if (tempoPtr->getLeftNoteDot())
1344 textTempo += "<sym>space</sym><sym>metAugmentationDot</sym>";
1345 textTempo += " = " + QString::number(tempoPtr->getTypeTempo());
1346 t->setVisible(false);
1347 }
1348 t->setXmlText(textTempo);
1349 //TODO:ws t->setAbove(true);
1350 t->setTrack(track);
1351
1352 Segment* s = measure->getSegment(SegmentType::ChordRest, Fraction::fromTicks(absTick));
1353 s->add(t);
1354 }
1355 }
1356
1357 // beam in grace
getGraceLevel(const QList<OVE::NoteContainer * > & containers,int tick,int unit)1358 int getGraceLevel(const QList<OVE::NoteContainer*>& containers, int tick, int unit){
1359 int graceCount = 0;
1360 int level = 0; // normal chord rest
1361
1362 for(int i=0; i<containers.size(); ++i){
1363 OVE::NoteContainer* container = containers[i];
1364 if(container->getTick() > tick)
1365 break;
1366
1367 if(container->getIsGrace() && container->getTick() == tick){
1368 ++graceCount;
1369
1370 if(unit <= container->start()->getOffset()){
1371 ++level;
1372 }
1373 }
1374 }
1375
1376 return level;
1377 }
1378
isRestDefaultLine(OVE::Note * rest,OVE::NoteType noteType)1379 bool isRestDefaultLine(OVE::Note* rest, OVE::NoteType noteType) {
1380 bool isDefault = true;
1381 switch (noteType) {
1382 case OVE::NoteType::Note_DoubleWhole:
1383 case OVE::NoteType::Note_Whole:
1384 case OVE::NoteType::Note_Half:
1385 case OVE::NoteType::Note_Quarter: {
1386 if(rest->getLine() != 0)
1387 isDefault = false;
1388 break;
1389 }
1390 case OVE::NoteType::Note_Eight: {
1391 if(rest->getLine() != 1)
1392 isDefault = false;
1393 break;
1394 }
1395 case OVE::NoteType::Note_Sixteen:
1396 case OVE::NoteType::Note_32: {
1397 if(rest->getLine() != -1)
1398 isDefault = false;
1399 break;
1400 }
1401 case OVE::NoteType::Note_64: {
1402 if(rest->getLine() != -3)
1403 isDefault = false;
1404 break;
1405 }
1406 case OVE::NoteType::Note_128: {
1407 if(rest->getLine() != -4)
1408 isDefault = false;
1409 break;
1410 }
1411 default: {
1412 break;
1413 }
1414 }
1415
1416 return isDefault;
1417 }
1418
getDrumset(Score * score,int part)1419 Drumset* getDrumset(Score* score, int part) {
1420 Part* p = score->parts().at(part);
1421 return const_cast<Drumset*>(p->instrument()->drumset()); //TODO: remove cast
1422 }
1423
convertNotes(Measure * measure,int part,int staff,int track)1424 void OveToMScore::convertNotes(Measure* measure, int part, int staff, int track){
1425 int j;
1426 OVE::MeasureData* measureData = ove_->getMeasureData(part, staff, measure->no());
1427 QList<OVE::NoteContainer*> containers = measureData->getNoteContainers();
1428 QList<OVE::MusicData*> tuplets = measureData->getCrossMeasureElements(OVE::MusicDataType::Tuplet, OVE::MeasureData::PairType::Start);
1429 QList<OVE::MusicData*> beams = measureData->getCrossMeasureElements(OVE::MusicDataType::Beam, OVE::MeasureData::PairType::Start);
1430 Tuplet* tuplet = 0;
1431 ChordRest* cr = 0;
1432 int partStaffCount = ove_->getStaffCount(part);
1433
1434 if(containers.empty()){
1435 int absTick = mtt_->getTick(measure->no(), 0);
1436
1437 cr = new Rest(score_);
1438 cr->setTicks(measure->ticks());
1439 cr->setDurationType(TDuration::DurationType::V_MEASURE);
1440 cr->setTrack(track);
1441 Segment* s = measure->getSegment(SegmentType::ChordRest, Fraction::fromTicks(absTick));
1442 s->add(cr);
1443 }
1444 QList<Ms::Chord*> graceNotes;
1445 for (int i = 0; i < containers.size(); ++i) {
1446 OVE::NoteContainer* container = containers[i];
1447 int tick = mtt_->getTick(measure->no(), container->getTick());
1448 int noteTrack = track + container->getVoice();
1449
1450 if (container->getIsRest()) {
1451 TDuration duration = OveNoteType_To_Duration(container->getNoteType());
1452 duration.setDots(container->getDot());
1453
1454 cr = new Rest(score_);
1455 cr->setTicks(duration.fraction());
1456 cr->setDurationType(duration);
1457 cr->setTrack(noteTrack);
1458 cr->setVisible(container->getShow());
1459 Segment* s = measure->getSegment(SegmentType::ChordRest, Fraction::fromTicks(tick));
1460 s->add(cr);
1461
1462 QList<OVE::Note*> notes = container->getNotesRests();
1463 for (j = 0; j < notes.size(); ++j) {
1464 OVE::Note* notePtr = notes[j];
1465 if(!isRestDefaultLine(notePtr, container->getNoteType()) && notePtr->getLine() != 0) {
1466 double yOffset = -(double)(notePtr->getLine());
1467 int stepOffset = cr->staff()->staffType(cr->tick())->stepOffset();
1468 int lineOffset = static_cast<Ms::Rest*>(cr)->computeLineOffset(5);
1469 yOffset -= qreal(lineOffset + stepOffset);
1470 yOffset *= score_->spatium()/2.0;
1471 cr->ryoffset() = yOffset;
1472 cr->setAutoplace(false);
1473 }
1474 }
1475 }
1476 else {
1477 QList<OVE::Note*> notes = container->getNotesRests();
1478
1479 cr = measure->findChord(Fraction::fromTicks(tick), noteTrack);
1480 if (cr == 0) {
1481 cr = new Ms::Chord(score_);
1482 cr->setTrack(noteTrack);
1483
1484 // grace
1485 if (container->getIsGrace()) {
1486 TDuration duration = OveNoteType_To_Duration(container->getGraceNoteType());
1487 duration.setDots(container->getDot());
1488 ((Ms::Chord*) cr)->setNoteType(NoteType::APPOGGIATURA);
1489
1490 if (duration.type() == TDuration::DurationType::V_QUARTER) {
1491 ((Ms::Chord*) cr)->setNoteType(NoteType::GRACE4);
1492 cr->setDurationType(TDuration::DurationType::V_QUARTER);
1493 } else if (duration.type() == TDuration::DurationType::V_16TH) {
1494 ((Ms::Chord*) cr)->setNoteType(NoteType::GRACE16);
1495 cr->setDurationType(TDuration::DurationType::V_16TH);
1496 } else if (duration.type() == TDuration::DurationType::V_32ND) {
1497 ((Ms::Chord*) cr)->setNoteType(NoteType::GRACE32);
1498 cr->setDurationType(TDuration::DurationType::V_32ND);
1499 } else {
1500 cr->setDurationType(TDuration::DurationType::V_EIGHTH);
1501 }
1502
1503 // st = SegmentType::Grace;
1504 }
1505 else {
1506 TDuration duration = OveNoteType_To_Duration(container->getNoteType());
1507 duration.setDots(container->getDot());
1508
1509 if (duration.type() == TDuration::DurationType::V_INVALID)
1510 duration.setType(TDuration::DurationType::V_QUARTER);
1511 cr->setDurationType(duration);
1512 // append grace notes before
1513 int ii = -1;
1514 for (ii = graceNotes.size() - 1; ii >= 0; ii--) {
1515 Ms::Chord* gc = graceNotes[ii];
1516 if(gc->voice() == cr->voice()){
1517 cr->add(gc);
1518 }
1519 }
1520 graceNotes.clear();
1521 }
1522 cr->setTicks(cr->durationType().fraction());
1523
1524 if(!container->getIsGrace()) {
1525 Segment* s = measure->getSegment(SegmentType::ChordRest, Fraction::fromTicks(tick));
1526 s->add(cr);
1527 }
1528 else {
1529 graceNotes.append(static_cast<Ms::Chord*>(cr));
1530 }
1531 }
1532
1533 cr->setVisible(container->getShow());
1534 cr->setSmall(container->getIsCue());
1535 for (j = 0; j < notes.size(); ++j) {
1536 OVE::Note* oveNote = notes[j];
1537 Note* note = new Note(score_);
1538 int pitch = oveNote->getNote();
1539
1540 //note->setTrack(noteTrack);
1541 note->setVeloType(Note::ValueType::USER_VAL);
1542 note->setVeloOffset(oveNote->getOnVelocity());
1543 note->setPitch(pitch);
1544
1545 // tpc
1546 bool setDirection = false;
1547 OVE::ClefType clefType = getClefType(measureData, container->getTick());
1548 if(clefType == OVE::ClefType::Percussion1 || clefType == OVE::ClefType::Percussion2) {
1549 Drumset* drumset = getDrumset(score_, part);
1550 if(drumset != 0) {
1551 if (!drumset->isValid(pitch) || pitch == -1) {
1552 qDebug("unmapped drum note 0x%02x %d", note->pitch(), note->pitch());
1553 }
1554 else {
1555 note->setHeadGroup(drumset->noteHead(pitch));
1556 int line = drumset->line(pitch);
1557 note->setLine(line);
1558 note->setTpcFromPitch();
1559 ((Ms::Chord*) cr)->setStemDirection(drumset->stemDirection(pitch));
1560 setDirection = true;
1561 }
1562 }
1563 else {
1564 // no drumset, we don't allow mid staff percussion
1565 note->setTpc(14);
1566 }
1567 }
1568 else {
1569 const int OCTAVE = 7;
1570 OVE::ToneType clefMiddleTone;
1571 int clefMiddleOctave;
1572 getMiddleToneOctave(clefType, clefMiddleTone, clefMiddleOctave);
1573 int absLine = static_cast<int>(clefMiddleTone) + clefMiddleOctave * OCTAVE + oveNote->getLine();
1574 if ((partStaffCount == 2) && oveNote->getOffsetStaff())
1575 absLine += 2 * (oveNote->getOffsetStaff());
1576 int tone = absLine % OCTAVE;
1577 int alter = accidentalToAlter(oveNote->getAccidental());
1578 NoteVal nv(pitch);
1579 note->setTrack(cr->track());
1580 note->setNval(nv, Fraction::fromTicks(tick));
1581 // note->setTpcFromPitch();
1582 note->setTpc(step2tpc(tone, AccidentalVal(alter)));
1583 if (oveNote->getShowAccidental()) {
1584 Ms::Accidental* a = new Accidental(score_);
1585 bool bracket = static_cast<int>(oveNote->getAccidental()) & 0x8;
1586 AccidentalType at = Ms::AccidentalType::NONE;
1587 switch(alter) {
1588 case 0: at = Ms::AccidentalType::NATURAL; break;
1589 case 1: at = Ms::AccidentalType::SHARP; break;
1590 case -1: at = Ms::AccidentalType::FLAT; break;
1591 case 2: at = Ms::AccidentalType::SHARP2; break;
1592 case -2: at = Ms::AccidentalType::FLAT2; break;
1593 }
1594 a->setAccidentalType(at);
1595 a->setBracket(AccidentalBracket(bracket));
1596 a->setRole(Ms::AccidentalRole::USER);
1597 note->add(a);
1598 }
1599 note->setHeadGroup(getHeadGroup(oveNote->getHeadType()));
1600 }
1601 if ((oveNote->getHeadType() == OVE::NoteHeadType::Invisible) || !(oveNote->getShow()))
1602 note->setVisible(false);
1603 // tie
1604 if ((int(oveNote->getTiePos()) & int(OVE::TiePos::LeftEnd)) == int(OVE::TiePos::LeftEnd)) {
1605 Tie* tie = new Tie(score_);
1606 note->setTieFor(tie);
1607 tie->setStartNote(note);
1608 tie->setTrack(noteTrack);
1609 }
1610
1611 // pitch must be set before adding note to chord as note
1612 // is inserted into pitch sorted list (ws)
1613 cr->add(note);
1614
1615 //cr->setVisible(oveNote->getShow());
1616 ((Ms::Chord*) cr)->setNoStem(int(container->getNoteType()) <= int(OVE::NoteType::Note_Whole));
1617 if(!setDirection)
1618 ((Ms::Chord*) cr)->setStemDirection(container->getStemUp() ? Direction::UP : Direction::DOWN);
1619
1620 // cross staff
1621 int staffMove = 0;
1622 if(partStaffCount == 2) { /*treble-bass*/
1623 staffMove = oveNote->getOffsetStaff();
1624 }
1625 cr->setStaffMove(staffMove);
1626 }
1627 }
1628
1629 // beam
1630 //Beam::Mode bm = container->getIsRest() ? Beam::Mode::NONE : Beam::Mode::AUTO;
1631 Beam::Mode bm = Beam::Mode::NONE;
1632 if(container->getInBeam()){
1633 OVE::MeasurePos pos = container->start()->shiftMeasure(0);
1634 OVE::MusicData* data = getCrossMeasureElementByPos(part, staff, pos, container->getVoice(), OVE::MusicDataType::Beam);
1635
1636 if(data != 0){
1637 OVE::Beam* beam = static_cast<OVE::Beam*>(data);
1638 OVE::MeasurePos startPos = beam->start()->shiftMeasure(0);
1639 OVE::MeasurePos stopPos = beam->stop()->shiftMeasure(beam->start()->getMeasure());
1640
1641 if(startPos == pos){
1642 bm = Beam::Mode::BEGIN;
1643 }
1644 else if(stopPos == pos){
1645 bm = Beam::Mode::END;
1646 }
1647 else{
1648 bm = Beam::Mode::MID;
1649 }
1650 }
1651 }
1652 cr->setBeamMode(bm);
1653
1654 // tuplet
1655 if (container->getTuplet() > 0) {
1656 if (tuplet == 0) {
1657 bool create = true;
1658
1659 // check tuplet start
1660 if(container->getNoteType() < OVE::NoteType::Note_Eight) {
1661 const OVE::Tuplet* oveTuplet = getTuplet(tuplets, container->start()->getOffset());
1662 if(oveTuplet == 0) {
1663 create = false;
1664 }
1665 }
1666
1667 if(create) {
1668 tuplet = new Tuplet(score_);
1669 tuplet->setTrack(noteTrack);
1670 tuplet->setRatio(Fraction(container->getTuplet(), container->getSpace()));
1671 TDuration duration = OveNoteType_To_Duration(container->getNoteType());
1672 tuplet->setBaseLen(duration);
1673 // tuplet->setTick(tick);
1674 tuplet->setParent(measure);
1675 //measure->add(tuplet);
1676 }
1677 }
1678
1679 if (tuplet != 0) {
1680 cr->setTuplet(tuplet);
1681 tuplet->add(cr);
1682 }
1683
1684 if (tuplet != 0) {
1685 // check tuplet end
1686 const OVE::Tuplet* oveTuplet = getTuplet(tuplets, container->start()->getOffset());
1687 if (oveTuplet != 0) {
1688 //set direction
1689 tuplet->setDirection(oveTuplet->getLeftShoulder()->getYOffset() < 0 ? Direction::UP : Direction::DOWN);
1690
1691 if(container->start()->getOffset() == oveTuplet->stop()->getOffset()){
1692 tuplet = 0;
1693 }
1694 }
1695 }
1696 }
1697
1698 // articulation
1699 QList<OVE::Articulation*> articulations = container->getArticulations();
1700 for (j = 0; j < articulations.size(); ++j) {
1701 convertArticulation(measure, cr, noteTrack, tick, articulations[j]);
1702 }
1703 }
1704 }
1705
convertArticulation(Measure * measure,ChordRest * cr,int track,int absTick,OVE::Articulation * art)1706 void OveToMScore::convertArticulation(
1707 Measure* measure, ChordRest* cr,
1708 int track, int absTick, OVE::Articulation* art){
1709
1710 switch ( art->getArtType() ) {
1711 case OVE::ArticulationType::Major_Trill :
1712 case OVE::ArticulationType::Minor_Trill :{
1713 Articulation* a = new Articulation(score_);
1714 a->setSymId(SymId::ornamentTrill);
1715 cr->add(a);
1716 break;
1717 }
1718 case OVE::ArticulationType::Trill_Section :{
1719 break;
1720 }
1721 case OVE::ArticulationType::Inverted_Short_Mordent :
1722 case OVE::ArticulationType::Inverted_Long_Mordent :{
1723 Articulation* a = new Articulation(score_);
1724 a->setSymId(SymId::ornamentMordent);
1725 cr->add(a);
1726 break;
1727 }
1728 case OVE::ArticulationType::Short_Mordent :{
1729 Articulation* a = new Articulation(score_);
1730 a->setSymId(SymId::ornamentShortTrill);
1731 cr->add(a);
1732 break;
1733 }
1734 case OVE::ArticulationType::Turn :{
1735 Articulation* a = new Articulation(score_);
1736 a->setSymId(SymId::ornamentTurn);
1737 cr->add(a);
1738 break;
1739 }
1740 // case OVE::ArticulationType::Flat_Accidental_For_Trill :
1741 // case OVE::ArticulationType::Sharp_Accidental_For_Trill :
1742 // case OVE::ArticulationType::Natural_Accidental_For_Trill :
1743 case OVE::ArticulationType::Tremolo_Eighth :{
1744 Tremolo* t = new Tremolo(score_);
1745 t->setTremoloType(TremoloType::R8);
1746 cr->add(t);
1747 break;
1748 }
1749 case OVE::ArticulationType::Tremolo_Sixteenth :{
1750 Tremolo* t = new Tremolo(score_);
1751 t->setTremoloType(TremoloType::R16);
1752 cr->add(t);
1753 break;
1754 }
1755 case OVE::ArticulationType::Tremolo_Thirty_Second :{
1756 Tremolo* t = new Tremolo(score_);
1757 t->setTremoloType(TremoloType::R32);
1758 cr->add(t);
1759 break;
1760 }
1761 case OVE::ArticulationType::Tremolo_Sixty_Fourth :{
1762 Tremolo* t = new Tremolo(score_);
1763 t->setTremoloType(TremoloType::R64);
1764 cr->add(t);
1765 break;
1766 }
1767 case OVE::ArticulationType::Marcato :{
1768 Articulation* a = new Articulation(score_);
1769 a->setSymId(SymId::articAccentAbove);
1770 cr->add(a);
1771 break;
1772 }
1773 case OVE::ArticulationType::Marcato_Dot :{
1774 Articulation* a = new Articulation(score_);
1775 a->setSymId(SymId::articAccentAbove);
1776 cr->add(a);
1777
1778 a = new Articulation(score_);
1779 a->setSymId(SymId::articStaccatoAbove);
1780 cr->add(a);
1781 break;
1782 }
1783 case OVE::ArticulationType::Heavy_Attack :{
1784 Articulation* a = new Articulation(score_);
1785 a->setSymId(SymId::articAccentAbove);
1786 cr->add(a);
1787
1788 a = new Articulation(score_);
1789 a->setSymId(SymId::articTenutoAbove);
1790 cr->add(a);
1791 break;
1792 }
1793 case OVE::ArticulationType::SForzando :{
1794 Articulation* a = new Articulation(score_);
1795 a->setUp(true);
1796 a->setSymId(SymId::articMarcatoAbove);
1797 cr->add(a);
1798 break;
1799 }
1800 case OVE::ArticulationType::SForzando_Inverted :{
1801 Articulation* a = new Articulation(score_);
1802 a->setUp(false);
1803 a->setSymId(SymId::articMarcatoAbove);
1804 cr->add(a);
1805 break;
1806 }
1807 case OVE::ArticulationType::SForzando_Dot :{
1808 Articulation* a = new Articulation(score_);
1809 a->setUp(true);
1810 a->setSymId(SymId::articMarcatoAbove);
1811 cr->add(a);
1812
1813 a = new Articulation(score_);
1814 a->setSymId(SymId::articStaccatoAbove);
1815 cr->add(a);
1816 break;
1817 }
1818 case OVE::ArticulationType::SForzando_Dot_Inverted :{
1819 Articulation* a = new Articulation(score_);
1820 a->setUp(false);
1821 a->setSymId(SymId::articMarcatoAbove);
1822 cr->add(a);
1823
1824 a = new Articulation(score_);
1825 a->setSymId(SymId::articStaccatoAbove);
1826 cr->add(a);
1827 break;
1828 }
1829 case OVE::ArticulationType::Heavier_Attack :{
1830 Articulation* a = new Articulation(score_);
1831 a->setUp(true);
1832 a->setSymId(SymId::articMarcatoAbove);
1833 cr->add(a);
1834
1835 a = new Articulation(score_);
1836 a->setSymId(SymId::articTenutoAbove);
1837 cr->add(a);
1838 break;
1839 }
1840 case OVE::ArticulationType::Staccatissimo :{
1841 Articulation* a = new Articulation(score_);
1842 a->setUp(true);
1843 a->setSymId(SymId::articStaccatissimoAbove);
1844 cr->add(a);
1845 break;
1846 }
1847 case OVE::ArticulationType::Staccato :{
1848 Articulation* a = new Articulation(score_);
1849 a->setSymId(SymId::articStaccatoAbove);
1850 cr->add(a);
1851 break;
1852 }
1853 case OVE::ArticulationType::Tenuto :{
1854 Articulation* a = new Articulation(score_);
1855 a->setSymId(SymId::articTenutoAbove);
1856 cr->add(a);
1857 break;
1858 }
1859 case OVE::ArticulationType::Pause :{
1860 Breath* b = new Breath(score_);
1861 b->setTrack(track);
1862 Segment* seg = measure->getSegment(SegmentType::Breath,
1863 Fraction::fromTicks(absTick + (cr ? cr->actualTicks().ticks() : 0)));
1864 seg->add(b);
1865 break;
1866 }
1867 case OVE::ArticulationType::Grand_Pause :{
1868 // TODO?
1869 break;
1870 }
1871 case OVE::ArticulationType::Up_Bow :{
1872 Articulation* a = new Articulation(score_);
1873 a->setSymId(SymId::stringsUpBow);
1874 cr->add(a);
1875 break;
1876 }
1877 case OVE::ArticulationType::Down_Bow :{
1878 Articulation* a = new Articulation(score_);
1879 a->setSymId(SymId::stringsDownBow);
1880 cr->add(a);
1881 break;
1882 }
1883 case OVE::ArticulationType::Up_Bow_Inverted :{
1884 Articulation* a = new Articulation(score_);
1885 a->setSymId(SymId::stringsUpBow);
1886 a->ryoffset() = 5.3;
1887 cr->add(a);
1888 break;
1889 }
1890 case OVE::ArticulationType::Down_Bow_Inverted :{
1891 Articulation* a = new Articulation(score_);
1892 a->setSymId(SymId::stringsDownBow);
1893 a->ryoffset() = 5.3;
1894 cr->add(a);
1895 break;
1896 }
1897 case OVE::ArticulationType::Natural_Harmonic :{
1898 Articulation* a = new Articulation(score_);
1899 a->setSymId(SymId::stringsHarmonic);
1900 cr->add(a);
1901 break;
1902 }
1903 case OVE::ArticulationType::Artificial_Harmonic :{
1904 break;
1905 }
1906 case OVE::ArticulationType::Finger_1 :
1907 case OVE::ArticulationType::Finger_2 :
1908 case OVE::ArticulationType::Finger_3 :
1909 case OVE::ArticulationType::Finger_4 :
1910 case OVE::ArticulationType::Finger_5 :{
1911 break;
1912 }
1913 case OVE::ArticulationType::Plus_Sign :{
1914 Articulation* a = new Articulation(score_);
1915 a->setSymId(SymId::brassMuteClosed);
1916 cr->add(a);
1917 break;
1918 }
1919 case OVE::ArticulationType::Arpeggio :{
1920 // there can be only one
1921 if (!(static_cast<Ms::Chord*>(cr))->arpeggio()) {
1922 Arpeggio* a = new Arpeggio(score_);
1923 a->setArpeggioType(ArpeggioType::NORMAL);
1924 /* if (art->getPlacementAbove()){
1925 a->setSubtype(ArpeggioType::UP);
1926 }else {
1927 a->setSubtype(ARpeggioType::DOWN);
1928 }*/
1929 cr->add(a);
1930 }
1931
1932 break;
1933 }
1934 case OVE::ArticulationType::Fermata :{
1935 Articulation* a = new Articulation(score_);
1936 a->setUp(true);
1937 a->setSymId(SymId::fermataAbove);
1938 cr->add(a);
1939 break;
1940 }
1941 case OVE::ArticulationType::Fermata_Inverted :{
1942 Articulation* a = new Articulation(score_);
1943 a->setDirection(Direction::DOWN);
1944 a->setSymId(SymId::fermataBelow);
1945 cr->add(a);
1946 break;
1947 }
1948 case OVE::ArticulationType::Pedal_Down :{
1949 if (pedal_) {
1950 delete pedal_;
1951 pedal_ = 0;
1952 }
1953 else {
1954 pedal_ = new Pedal(score_);
1955 pedal_->setTrack(track);
1956 Segment* seg = measure->getSegment(SegmentType::ChordRest, Fraction::fromTicks(absTick));
1957 pedal_->setTick(seg->tick());
1958 }
1959 break;
1960 }
1961 case OVE::ArticulationType::Pedal_Up :{
1962 if(pedal_){
1963 Segment* seg = measure->getSegment(SegmentType::ChordRest, Fraction::fromTicks(absTick));
1964 pedal_->setTick2(seg->tick());
1965 score_->addSpanner(pedal_);
1966 pedal_ = 0;
1967 }
1968 break;
1969 }
1970 // case OVE::ArticulationType::Toe_Pedal :
1971 // case OVE::ArticulationType::Heel_Pedal :
1972 // case OVE::ArticulationType::Toe_To_Heel_Pedal :
1973 // case OVE::ArticulationType::Heel_To_Toe_Pedal :
1974 // case OVE::ArticulationType::Open_String :
1975 default:
1976 break;
1977 }
1978 }
1979
convertLyrics(Measure * measure,int part,int staff,int track)1980 void OveToMScore::convertLyrics(Measure* measure, int part, int staff, int track){
1981 OVE::MeasureData* measureData = ove_->getMeasureData(part, staff, measure->no());
1982 if(measureData == 0)
1983 return;
1984
1985 QList<OVE::MusicData*> lyrics = measureData->getMusicDatas(OVE::MusicDataType::Lyric);
1986
1987 for(int i=0; i<lyrics.size(); ++i){
1988 OVE::Lyric* oveLyric = static_cast<OVE::Lyric*>(lyrics[i]);
1989 int tick = mtt_->getTick(measure->no(), oveLyric->getTick());
1990
1991 Lyrics* lyric = new Lyrics(score_);
1992 lyric->setNo(oveLyric->getVerse());
1993 lyric->setPlainText(oveLyric->getLyric());
1994 lyric->setTrack(track);
1995 Segment* segment = measure->getSegment(SegmentType::ChordRest, Fraction::fromTicks(tick));
1996 if (segment->element(track))
1997 static_cast<ChordRest*>(segment->element(track))->add(lyric);
1998 }
1999 }
2000
convertHarmonys(Measure * measure,int part,int staff,int track)2001 void OveToMScore::convertHarmonys(Measure* measure, int part, int staff, int track){
2002 OVE::MeasureData* measureData = ove_->getMeasureData(part, staff, measure->no());
2003 if(measureData == 0)
2004 return;
2005
2006 QList<OVE::MusicData*> harmonys = measureData->getMusicDatas(OVE::MusicDataType::Harmony);
2007
2008 for(int i=0; i<harmonys.size(); ++i){
2009 OVE::Harmony* harmonyPtr = static_cast<OVE::Harmony*>(harmonys[i]);
2010 int absTick = mtt_->getTick(measure->no(), harmonyPtr->getTick());
2011
2012 Harmony* harmony = new Harmony(score_);
2013
2014 // TODO - does this need to be key-aware?
2015 harmony->setTrack(track);
2016 harmony->setRootTpc(step2tpc(harmonyPtr->getRoot(), AccidentalVal(harmonyPtr->getAlterRoot())));
2017 if(harmonyPtr->getBass() != OVE::INVALID_NOTE && (harmonyPtr->getBass() != harmonyPtr->getRoot() || (harmonyPtr->getBass() == harmonyPtr->getRoot() && harmonyPtr->getAlterBass() != harmonyPtr->getAlterRoot()))){
2018 harmony->setBaseTpc(step2tpc(harmonyPtr->getBass(), AccidentalVal(harmonyPtr->getAlterBass())));
2019 }
2020 const ChordDescription* d = harmony->fromXml(harmonyPtr->getHarmonyType());
2021 if(d != 0){
2022 harmony->setId(d->id);
2023 harmony->setTextName(d->names.front());
2024 }
2025 else {
2026 harmony->setId(-1);
2027 harmony->setTextName(harmonyPtr->getHarmonyType());
2028 }
2029 harmony->render();
2030
2031 Segment* s = measure->getSegment(SegmentType::ChordRest, Fraction::fromTicks(absTick));
2032 s->add(harmony);
2033 }
2034 }
2035
2036 /*OVE::MusicData* OveToMScore::getMusicDataByUnit(int part, int staff, int measure, int unit, OVE::MusicDataType type){
2037 OVE::MeasureData* measureData = ove_->getMeasureData(part, staff, measure);
2038 if(measureData != 0) {
2039 const QList<OVE::MusicData*>& datas = measureData->getMusicDatas(type);
2040 for(unsigned int i=0; i<datas.size(); ++i){
2041 if(datas[i]->getTick() == unit){//different measurement
2042 return datas[i];
2043 }
2044 }
2045 }
2046
2047 return 0;
2048 }*/
2049
getCrossMeasureElementByPos(int part,int staff,const OVE::MeasurePos & pos,int voice,OVE::MusicDataType type)2050 OVE::MusicData* OveToMScore::getCrossMeasureElementByPos(int part, int staff, const OVE::MeasurePos& pos, int voice, OVE::MusicDataType type){
2051 OVE::MeasureData* measureData = ove_->getMeasureData(part, staff, pos.getMeasure());
2052 if(measureData != 0) {
2053 const QList<OVE::MusicData*>& datas = measureData->getCrossMeasureElements(type, OVE::MeasureData::PairType::All);
2054 for(int i=0; i<datas.size(); ++i){
2055 OVE::MeasurePos dataStart = datas[i]->start()->shiftMeasure(0);
2056 OVE::MeasurePos dataStop = datas[i]->stop()->shiftMeasure(datas[i]->start()->getMeasure());
2057
2058 if(dataStart <= pos && dataStop >= pos && (int)datas[i]->getVoice() == voice){
2059 return datas[i];
2060 }
2061 }
2062 }
2063
2064 return 0;
2065 }
2066
getContainerByPos(int part,int staff,const OVE::MeasurePos & pos)2067 OVE::NoteContainer* OveToMScore::getContainerByPos(int part, int staff, const OVE::MeasurePos& pos){
2068 OVE::MeasureData* measureData = ove_->getMeasureData(part, staff, pos.getMeasure());
2069 if(measureData != 0) {
2070 const QList<OVE::NoteContainer*>& containers = measureData->getNoteContainers();
2071 for(int i=0; i<containers.size(); ++i){
2072 if(pos == containers[i]->start()->shiftMeasure(0)){
2073 return containers[i];
2074 }
2075 }
2076 }
2077
2078 return 0;
2079 }
2080
convertRepeats(Measure * measure,int part,int staff,int track)2081 void OveToMScore::convertRepeats(Measure* measure, int part, int staff, int track){
2082 OVE::MeasureData* measureData = ove_->getMeasureData(part, staff, measure->no());
2083 if(measureData == 0)
2084 return;
2085
2086 int i;
2087 QList<OVE::MusicData*> repeats = measureData->getMusicDatas(OVE::MusicDataType::Repeat);
2088
2089 for(i=0; i<repeats.size(); ++i){
2090 OVE::RepeatSymbol* repeatPtr = static_cast<OVE::RepeatSymbol*>(repeats[i]);
2091 OVE::RepeatType type = repeatPtr->getRepeatType();
2092 Element* e = 0;
2093
2094 switch(type) {
2095 case OVE::RepeatType::Segno:{
2096 Marker* marker = new Marker(score_);
2097 marker->setMarkerType(Marker::Type::SEGNO);
2098 e = marker;
2099 break;
2100 }
2101 case OVE::RepeatType::Coda:{
2102 Marker* marker = new Marker(score_);
2103 marker->setMarkerType(Marker::Type::CODA);
2104 e = marker;
2105 break;
2106 }
2107 case OVE::RepeatType::DSAlCoda:{
2108 Jump* jp = new Jump(score_);
2109 jp->setJumpType(Jump::Type::DS_AL_CODA);
2110 e = jp;
2111 break;
2112 }
2113 case OVE::RepeatType::DSAlFine:{
2114 Jump* jp = new Jump(score_);
2115 jp->setJumpType(Jump::Type::DS_AL_FINE);
2116 e = jp;
2117 break;
2118 }
2119 case OVE::RepeatType::DCAlCoda:{
2120 Jump* jp = new Jump(score_);
2121 jp->setJumpType(Jump::Type::DC_AL_CODA);
2122 e = jp;
2123 break;
2124 }
2125 case OVE::RepeatType::DCAlFine:{
2126 Jump* jp = new Jump(score_);
2127 jp->setJumpType(Jump::Type::DC_AL_FINE);
2128 e = jp;
2129 break;
2130 }
2131 case OVE::RepeatType::ToCoda:{
2132 Marker* m = new Marker(score_);
2133 m->setMarkerType(Marker::Type::TOCODA);
2134 e = m;
2135 break;
2136 }
2137 case OVE::RepeatType::Fine:{
2138 Marker* m = new Marker(score_);
2139 m->setMarkerType(Marker::Type::FINE);
2140 e = m;
2141 break;
2142 }
2143 default:
2144 break;
2145 }
2146
2147 if(e != 0){
2148 e->setTrack(track);
2149 measure->add(e);
2150 }
2151 }
2152
2153 QList<OVE::MusicData*> endings = measureData->getCrossMeasureElements(
2154 OVE::MusicDataType::Numeric_Ending,
2155 OVE::MeasureData::PairType::Start);
2156
2157 for(i=0; i<endings.size(); ++i){
2158 OVE::NumericEnding* ending = static_cast<OVE::NumericEnding*>(endings[i]);
2159 int absTick1 = mtt_->getTick(measure->no(), 0);
2160 int absTick2 = mtt_->getTick(measure->no() + ending->stop()->getMeasure(), 0);
2161
2162 if (absTick1 < absTick2) {
2163 Volta* volta = new Volta(score_);
2164 volta->setTrack(track);
2165 volta->setTick(Fraction::fromTicks(absTick1));
2166 volta->setTick2(Fraction::fromTicks(absTick2));
2167 score_->addElement(volta);
2168 volta->setVoltaType(Volta::Type::CLOSED);
2169 volta->setText(ending->getText());
2170
2171 volta->endings().clear();
2172 QList<int> numbers = ending->getNumbers();
2173 for (int j = 0; j < numbers.size(); ++j) {
2174 volta->endings().append(numbers[j]);
2175 }
2176 }
2177 }
2178 }
2179
convertSlurs(Measure * measure,int part,int staff,int track)2180 void OveToMScore::convertSlurs(Measure* measure, int part, int staff, int track){
2181 OVE::MeasureData* measureData = ove_->getMeasureData(part, staff, measure->no());
2182 if(measureData == 0)
2183 return;
2184
2185 QList<OVE::MusicData*> slurs = measureData->getCrossMeasureElements(OVE::MusicDataType::Slur, OVE::MeasureData::PairType::Start);
2186
2187 for(int i=0; i<slurs.size(); ++i){
2188 OVE::Slur* slurPtr = static_cast<OVE::Slur*>(slurs[i]);
2189
2190 OVE::NoteContainer* startContainer = getContainerByPos(part, staff, slurPtr->start()->shiftMeasure(0));
2191 OVE::NoteContainer* endContainer = getContainerByPos(
2192 part,
2193 staff,
2194 slurPtr->stop()->shiftMeasure(slurPtr->start()->getMeasure()));
2195
2196 if(startContainer != 0 && endContainer != 0){
2197 int absStartTick = mtt_->getTick(slurPtr->start()->getMeasure(), startContainer->getTick());
2198 int absEndTick = mtt_->getTick(slurPtr->start()->getMeasure()+slurPtr->stop()->getMeasure(), endContainer->getTick());
2199
2200 Slur* slur = new Slur(score_);
2201 slur->setSlurDirection(slurPtr->getShowOnTop()? Direction::UP : Direction::DOWN);
2202 slur->setTick(Fraction::fromTicks(absStartTick));
2203 slur->setTick2(Fraction::fromTicks(absEndTick));
2204 slur->setTrack(track);
2205 slur->setTrack2(track+endContainer->getOffsetStaff());
2206
2207 score_->addSpanner(slur);
2208 }
2209 }
2210 }
2211
OveDynamics_To_Dynamics(OVE::DynamicsType type)2212 QString OveDynamics_To_Dynamics(OVE::DynamicsType type){
2213 QString dynamic = "other-dynamics";
2214
2215 switch( type ){
2216 case OVE::DynamicsType::PPPP:
2217 dynamic = "pppp";
2218 break;
2219 case OVE::DynamicsType::PPP:
2220 dynamic = "ppp";
2221 break;
2222 case OVE::DynamicsType::PP:
2223 dynamic = "pp";
2224 break;
2225 case OVE::DynamicsType::P:
2226 dynamic = "p";
2227 break;
2228 case OVE::DynamicsType::MP:
2229 dynamic = "mp";
2230 break;
2231 case OVE::DynamicsType::MF:
2232 dynamic = "mf";
2233 break;
2234 case OVE::DynamicsType::F:
2235 dynamic = "f";
2236 break;
2237 case OVE::DynamicsType::FF:
2238 dynamic = "ff";
2239 break;
2240 case OVE::DynamicsType::FFF:
2241 dynamic = "fff";
2242 break;
2243 case OVE::DynamicsType::FFFF:
2244 dynamic = "ffff";
2245 break;
2246 case OVE::DynamicsType::SF:
2247 dynamic = "sf";
2248 break;
2249 case OVE::DynamicsType::FZ:
2250 dynamic = "fz";
2251 break;
2252 case OVE::DynamicsType::SFZ:
2253 dynamic = "sfz";
2254 break;
2255 case OVE::DynamicsType::SFFZ:
2256 dynamic = "sffz";
2257 break;
2258 case OVE::DynamicsType::FP:
2259 dynamic = "fp";
2260 break;
2261 case OVE::DynamicsType::SFP:
2262 dynamic = "sfp";
2263 break;
2264 default:
2265 break;
2266 }
2267
2268 return dynamic;
2269 }
2270
convertDynamics(Measure * measure,int part,int staff,int track)2271 void OveToMScore::convertDynamics(Measure* measure, int part, int staff, int track){
2272 OVE::MeasureData* measureData = ove_->getMeasureData(part, staff, measure->no());
2273 if(measureData == 0)
2274 return;
2275
2276 QList<OVE::MusicData*> dynamics = measureData->getMusicDatas(OVE::MusicDataType::Dynamics);
2277
2278 for(int i=0; i<dynamics.size(); ++i){
2279 OVE::Dynamics* dynamicPtr = static_cast<OVE::Dynamics*>(dynamics[i]);
2280 int absTick = mtt_->getTick(measure->no(), dynamicPtr->getTick());
2281 Dynamic* dynamic = new Dynamic(score_);
2282
2283 dynamic->setDynamicType(OveDynamics_To_Dynamics(dynamicPtr->getDynamicsType()));
2284 dynamic->setTrack(track);
2285
2286 Segment* s = measure->getSegment(SegmentType::ChordRest, Fraction::fromTicks(absTick));
2287 s->add(dynamic);
2288 }
2289 }
2290
convertExpressions(Measure * measure,int part,int staff,int track)2291 void OveToMScore::convertExpressions(Measure* measure, int part, int staff, int track){
2292 OVE::MeasureData* measureData = ove_->getMeasureData(part, staff, measure->no());
2293 if(measureData == 0)
2294 return;
2295
2296 QList<OVE::MusicData*> expressions = measureData->getMusicDatas(OVE::MusicDataType::Expressions);
2297
2298 for(int i=0; i<expressions.size(); ++i){
2299 OVE::Expressions* expressionPtr = static_cast<OVE::Expressions*>(expressions[i]);
2300 int absTick = mtt_->getTick(measure->no(), expressionPtr->getTick());
2301 Text* t = new Text(score_, Tid::EXPRESSION);
2302
2303 t->setPlainText(expressionPtr->getText());
2304 t->setTrack(track);
2305
2306 Segment* s = measure->getSegment(SegmentType::ChordRest, Fraction::fromTicks(absTick));
2307 s->add(t);
2308 }
2309 }
2310
convertGlissandos(Measure * measure,int part,int staff,int track)2311 void OveToMScore::convertGlissandos(Measure* measure, int part, int staff, int track){
2312 OVE::MeasureData* measureData = ove_->getMeasureData(part, staff, measure->no());
2313 if(measureData == 0)
2314 return;
2315
2316 QList<OVE::MusicData*> glissandos = measureData->getCrossMeasureElements(OVE::MusicDataType::Glissando, OVE::MeasureData::PairType::All);
2317
2318 for(int i=0; i<glissandos.size(); ++i){
2319 OVE::Glissando* glissandoPtr = static_cast<OVE::Glissando*>(glissandos[i]);
2320 OVE::NoteContainer* startContainer = getContainerByPos(part, staff, glissandoPtr->start()->shiftMeasure(0));
2321 OVE::NoteContainer* endContainer = getContainerByPos(
2322 part,
2323 staff,
2324 glissandoPtr->stop()->shiftMeasure(glissandoPtr->start()->getMeasure()));
2325
2326 if(startContainer != 0 && endContainer != 0){
2327 int absTick = mtt_->getTick(measure->no(), glissandoPtr->getTick());
2328 ChordRest* cr = measure->findChordRest(Fraction::fromTicks(absTick), track);
2329 if(cr != 0){
2330 Glissando* g = new Glissando(score_);
2331 g->setGlissandoType(GlissandoType::WAVY);
2332 cr->add(g);
2333 }
2334 }
2335 }
2336 }
2337
OveWedgeType_To_Type(OVE::WedgeType type)2338 static HairpinType OveWedgeType_To_Type(OVE::WedgeType type) {
2339 HairpinType subtype = HairpinType::CRESC_HAIRPIN;
2340 switch(type) {
2341 case OVE::WedgeType::Cres_Line: {
2342 subtype = HairpinType::CRESC_HAIRPIN;
2343 break;
2344 }
2345 case OVE::WedgeType::Double_Line: {
2346 subtype = HairpinType::CRESC_HAIRPIN;
2347 break;
2348 }
2349 case OVE::WedgeType::Decresc_Line: {
2350 subtype = HairpinType::DECRESC_HAIRPIN;
2351 break;
2352 }
2353 case OVE::WedgeType::Cres: {
2354 subtype = HairpinType::CRESC_HAIRPIN;
2355 break;
2356 }
2357 case OVE::WedgeType::Decresc: {
2358 subtype = HairpinType::DECRESC_HAIRPIN;
2359 break;
2360 }
2361 default:
2362 break;
2363 }
2364
2365 return subtype;
2366 }
2367
convertWedges(Measure * measure,int part,int staff,int track)2368 void OveToMScore::convertWedges(Measure* measure, int part, int staff, int track) {
2369 OVE::MeasureData* measureData = ove_->getMeasureData(part, staff, measure->no());
2370 if(measureData == 0)
2371 return;
2372
2373 QList<OVE::MusicData*> wedges = measureData->getCrossMeasureElements(OVE::MusicDataType::Wedge, OVE::MeasureData::PairType::All);
2374
2375 for(int i=0; i<wedges.size(); ++i){
2376 OVE::Wedge* wedgePtr = static_cast<OVE::Wedge*>(wedges[i]);
2377 int absTick = mtt_->getTick(
2378 measure->no(),
2379 MeasureToTick::unitToTick(wedgePtr->start()->getOffset(), ove_->getQuarter()));
2380 int absTick2 = mtt_->getTick(
2381 measure->no()+wedgePtr->stop()->getMeasure(),
2382 MeasureToTick::unitToTick(wedgePtr->stop()->getOffset(), ove_->getQuarter()));
2383
2384 if (absTick2 > absTick) {
2385 Hairpin* hp = new Hairpin(score_);
2386
2387 hp->setHairpinType(OveWedgeType_To_Type(wedgePtr->getWedgeType()));
2388 //hp->setYoff(wedgePtr->getYOffset());
2389 hp->setTrack(track);
2390
2391 hp->setTick(Fraction::fromTicks(absTick));
2392 hp->setTick2(Fraction::fromTicks(absTick2));
2393 hp->setAnchor(Spanner::Anchor::SEGMENT);
2394 score_->addSpanner(hp);
2395 score_->updateHairpin(hp);
2396 }
2397 }
2398 }
2399
2400 //////////////////////////////////////////////////////////////////////////
2401
importOve(MasterScore * score,const QString & name)2402 Score::FileError importOve(MasterScore* score, const QString& name) {
2403 OVE::IOVEStreamLoader* oveLoader = OVE::createOveStreamLoader();
2404 OVE::OveSong oveSong;
2405
2406 QFile oveFile(name);
2407 if(!oveFile.exists())
2408 return Score::FileError::FILE_NOT_FOUND;
2409 if (!oveFile.open(QFile::ReadOnly)) {
2410 //messageOutString(QString("can't read file!"));
2411 return Score::FileError::FILE_OPEN_ERROR;
2412 }
2413
2414 QByteArray buffer = oveFile.readAll();
2415
2416 oveFile.close();
2417
2418 oveSong.setTextCodecName(preferences.getString(PREF_IMPORT_OVERTURE_CHARSET));
2419 oveLoader->setOve(&oveSong);
2420 oveLoader->setFileStream((unsigned char*) buffer.data(), buffer.size());
2421 bool result = oveLoader->load();
2422 oveLoader->release();
2423
2424 if(result){
2425 OveToMScore otm;
2426 otm.convert(&oveSong, score);
2427
2428 // score->connectSlurs();
2429 }
2430
2431 return result ? Score::FileError::FILE_NO_ERROR : Score::FileError::FILE_ERROR;
2432 }
2433
2434