← Back to branch summary

~ubuntu-branches/ubuntu/utopic/musescore/utopic

« back to all changes in this revision

Viewing changes to mscore/mscore/importove.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Toby Smithe, Matthias Klose
  • Date: 2011-02-16 20:04:20 UTC
  • mfrom: (3.1.2 sid)
  • Revision ID: james.westby@ubuntu.com-20110216200420-rlu5xdmcop6skghj
Tags: 1.0+dfsg-2
http://bugs.debian.org/597802
https://launchpad.net/bugs/642117
* Re-include Matthias Klose's armel qreal fixes (Closes: #597802)
  (I missed 0.9.6.3+dfsg-0ubuntu2...
   Apologies to Matthias and my sponsor, Tobias Quathamer!)

* debian/patches/12-debianise-about-box.dpatch:
  + Update "About" dialogue box to give copyright to 2011.

[ Matthias Klose ]
* More armel qreal fixes. LP: #642117.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mscore/mscore/importove.cpp
18
18
//  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19
19
//=============================================================================
20
20
 
21
 
#include <vector>
22
21
#include "ove.h"
23
22
 
 
23
#include "globals.h"
24
24
#include "al/sig.h"
25
25
#include "al/tempo.h"
26
26
#include "arpeggio.h"
78
78
 
79
79
                TimeTick():numerator_(4), denominator_(4), measure_(0), tick_(0), isSymbol_(false){}
80
80
        };
81
 
        std::vector<TimeTick> getTimeTicks() const;
 
81
        QList<TimeTick> getTimeTicks() const;
82
82
 
83
83
private:
84
84
        int quarter_;
85
85
        OVE::OveSong* ove_;
86
 
        std::vector<TimeTick> tts_;
 
86
        QList<TimeTick> tts_;
87
87
};
88
88
 
89
89
int getMeasureTick(int quarter, int num, int den){
107
107
        ove_ = ove;
108
108
        tts_.clear();
109
109
 
110
 
        for( i=0; i<measureCount; ++i ) {
 
110
        for(i=0; i<measureCount; ++i)   {
111
111
                OVE::Measure* measure = ove_->getMeasure(i);
112
112
                OVE::TimeSignature* time = measure->getTime();
113
113
                TimeTick tt;
121
121
 
122
122
                if( i == 0 ){
123
123
                        change = true;
124
 
                }
125
 
                else {
 
124
                } else {
126
125
                        OVE::TimeSignature* previousTime = ove_->getMeasure(i-1)->getTime();
127
126
 
128
127
                        if( time->getNumerator() != previousTime->getNumerator() ||
129
128
                                time->getDenominator() != previousTime->getDenominator() ){
130
129
                                change = true;
131
 
                        }
132
 
                        else if(time->getIsSymbol() != previousTime->getIsSymbol()){
 
130
                        } else if(time->getIsSymbol() != previousTime->getIsSymbol()){
133
131
                                change = true;
134
132
                        }
135
133
                }
143
141
}
144
142
 
145
143
int MeasureToTick::getTick(int measure, int tick_pos){
146
 
        unsigned int i;
147
144
        TimeTick tt;
148
145
 
149
 
        for( i=0; i<tts_.size(); ++i ) {
 
146
        for(int i=0; i<tts_.size(); ++i) {
150
147
                if( measure >= tts_[i].measure_ && ( i==tts_.size()-1 || measure < tts_[i+1].measure_ ) ) {
151
148
                        int measuresTick = (measure - tts_[i].measure_) * getMeasureTick(quarter_, tts_[i].numerator_, tts_[i].denominator_);
152
149
                        return tts_[i].tick_ + measuresTick + tick_pos;
163
160
        return tick;
164
161
}
165
162
 
166
 
std::vector<MeasureToTick::TimeTick> MeasureToTick::getTimeTicks() const {
 
163
QList<MeasureToTick::TimeTick> MeasureToTick::getTimeTicks() const {
167
164
        return tts_;
168
165
}
169
166
 
192
189
        void convertLyrics(Measure* measure, int part, int staff, int track);
193
190
        void convertHarmonys(Measure* measure, int part, int staff, int track);
194
191
        void convertRepeats(Measure* measure, int part, int staff, int track);
195
 
        void convertSlurs(Measure* measure, int part, int staff, int track);
196
192
        void convertDynamics(Measure* measure, int part, int staff, int track);
197
193
        void convertExpressions(Measure* measure, int part, int staff, int track);
 
194
        void convertLines(Measure* measure);
 
195
        void convertSlurs(Measure* measure, int part, int staff, int track);
198
196
        void convertGlissandos(Measure* measure, int part, int staff, int track);
199
197
        void convertWedges(Measure* measure, int part, int staff, int track);
200
198
        void convertOctaveShifts(Measure* measure, int part, int staff, int track);
202
200
        OVE::NoteContainer* getContainerByPos(int part, int staff, const OVE::MeasurePos& pos);
203
201
        //OVE::MusicData* getMusicDataByUnit(int part, int staff, int measure, int unit, OVE::MusicDataType type);
204
202
        OVE::MusicData* getCrossMeasureElementByPos(int part, int staff, const OVE::MeasurePos& pos, int voice, OVE::MusicDataType type);
 
203
        ChordRest* findChordRestByPos(int absTick, int track);
205
204
 
206
205
        void clearUp();
207
206
 
313
312
        return 0;
314
313
}
315
314
 
316
 
QString toQString(const std::string& str) {
317
 
        QTextCodec* codec = QTextCodec::codecForName(preferences.importCharset.toUtf8());
318
 
        return codec->toUnicode(str.c_str());
319
 
}
320
 
 
321
315
void addText(VBox* & vbox, Score* s, QString strTxt, int sbtp, int stl) {
322
316
        if (!strTxt.isEmpty()) {
323
317
                Text* text = new Text(s);
333
327
 
334
328
void OveToMScore::convertHeader() {
335
329
        VBox* vbox = 0;
336
 
        std::vector<std::string> titles = ove_->getTitles();
337
 
        if( !titles.empty() && titles[0] != std::string() ) {
338
 
                QString title = toQString(titles[0]);
 
330
        QList<QString> titles = ove_->getTitles();
 
331
        if( !titles.empty() && !titles[0].isEmpty() ) {
 
332
                QString title = titles[0];
339
333
                score_->setMovementTitle(title);
340
334
                addText(vbox, score_, title, TEXT_TITLE, TEXT_STYLE_TITLE);
341
335
        }
342
336
 
343
 
        std::vector<std::string> writers = ove_->getWriters();
 
337
        QList<QString> writers = ove_->getWriters();
344
338
        if(!writers.empty()) {
345
 
                QString composer = toQString(writers[0]);
 
339
                QString composer = writers[0];
346
340
                addText(vbox, score_, composer, TEXT_COMPOSER, TEXT_STYLE_COMPOSER);
347
341
        }
348
342
 
349
343
        if(writers.size() > 1) {
350
 
                QString lyricist = toQString(writers[1]);
 
344
                QString lyricist = writers[1];
351
345
                addText(vbox, score_, lyricist, TEXT_POET, TEXT_STYLE_POET);
352
346
        }
353
347
 
553
547
        if(track == 0 || part == 0)
554
548
                return;
555
549
 
556
 
        QString longName = toQString(track->getName());
 
550
        QString longName = track->getName();
557
551
        if (longName != QString() && track->getShowName()){
558
552
                part->setLongName(longName);
559
553
        }
560
554
 
561
 
        QString shortName = toQString(track->getBriefName());
 
555
        QString shortName = track->getBriefName();
562
556
        if (shortName != QString() && track->getShowBriefName()) {
563
557
                part->setShortName(shortName);
564
558
        }
583
577
                drumset->drum(i).voice     = smDrumset->drum(i).voice;
584
578
                drumset->drum(i).shortcut = 0;
585
579
        }
586
 
        std::vector<OVE::Track::DrumNode> nodes = track->getDrumKit();
587
 
        for (unsigned int i=0; i<nodes.size(); ++i) {
 
580
        QList<OVE::Track::DrumNode> nodes = track->getDrumKit();
 
581
        for (int i=0; i<nodes.size(); ++i) {
588
582
                int pitch = nodes[i].pitch_;
589
583
                OVE::Track::DrumNode node = nodes[i];
590
584
                if (pitch < DRUM_INSTRUMENTS) {
636
630
                        continue;
637
631
 
638
632
                // octave shift
639
 
                std::vector<OVE::MusicData*> octaves = measureData->getMusicDatas(OVE::MusicData_OctaveShift_EndPoint);
640
 
                for(unsigned int j=0; j<octaves.size(); ++j) {
 
633
                QList<OVE::MusicData*> octaves = measureData->getMusicDatas(OVE::MusicData_OctaveShift_EndPoint);
 
634
                for(int j=0; j<octaves.size(); ++j) {
641
635
                        OVE::OctaveShiftEndPoint* octave = static_cast<OVE::OctaveShiftEndPoint*>(octaves[j]);
642
636
 
643
637
                        if(octave->getOctaveShiftPosition() == OVE::OctavePosition_Start) {
718
712
        int k;
719
713
 
720
714
        // Time
721
 
        const std::vector<MeasureToTick::TimeTick> tts = mtt_->getTimeTicks() ;
 
715
        const QList<MeasureToTick::TimeTick> tts = mtt_->getTimeTicks() ;
722
716
        for( i=0; i<(int)tts.size(); ++i ){
723
717
                MeasureToTick::TimeTick tt = tts[i];
724
718
                AL::TimeSigMap* sigmap = score_->sigmap();
826
820
                        // clef in measure
827
821
                        for(k=0; k<ove_->getMeasureCount(); ++k){
828
822
                                OVE::MeasureData* measureData = ove_->getMeasureData(i, j, k);
829
 
                                std::vector<OVE::MusicData*> clefs = measureData->getMusicDatas(OVE::MusicData_Clef);
 
823
                                QList<OVE::MusicData*> clefs = measureData->getMusicDatas(OVE::MusicData_Clef);
830
824
                                Measure* measure = score_->tick2measure(mtt_->getTick(k, 0));
831
825
 
832
 
                                for( int l=0; l<(int)clefs.size(); ++l){
 
826
                                for(int l=0; l<clefs.size(); ++l){
833
827
                                        if(measure != 0){
834
828
                                                OVE::Clef* clefPtr = static_cast<OVE::Clef*>(clefs[l]);
835
829
                                                int absTick = mtt_->getTick(k, clefPtr->getTick());
863
857
                        for(k=0; k<ove_->getMeasureCount(); ++k){
864
858
                                OVE::Measure* measure = ove_->getMeasure(k);
865
859
                                OVE::MeasureData* measureData = ove_->getMeasureData(i, j, k);
866
 
                                std::vector<OVE::MusicData*> tempoPtrs = measureData->getMusicDatas(OVE::MusicData_Tempo);
 
860
                                QList<OVE::MusicData*> tempoPtrs = measureData->getMusicDatas(OVE::MusicData_Tempo);
867
861
 
868
862
                                if(k==0 || ( k>0 && abs(measure->getTypeTempo()-ove_->getMeasure(k-1)->getTypeTempo())>0.01 )){
869
863
                                        int tick = mtt_->getTick(k, 0);
870
864
                                        tempos[tick] = (int)measure->getTypeTempo();
871
865
                                }
872
866
 
873
 
                                for(unsigned int l=0; l<tempoPtrs.size(); ++l) {
 
867
                                for(int l=0; l<tempoPtrs.size(); ++l) {
874
868
                                        OVE::Tempo* ptr = static_cast<OVE::Tempo*>(tempoPtrs[l]);
875
869
                                        int tick = mtt_->getTick(measure->getBarNumber()->getIndex(), ptr->getTick());
876
870
                                        int tempo = ptr->getQuarterTempo()>0 ? ptr->getQuarterTempo() : 1;
914
908
        return tick;
915
909
}
916
910
 
917
 
OVE::Tuplet* getTuplet(const std::vector<OVE::MusicData*>& tuplets, int unit){
918
 
        for(int i=0; i<(int)tuplets.size(); ++i){
919
 
                if(unit >= tuplets[i]->start()->getOffset() && unit <= tuplets[i]->stop()->getOffset()){
920
 
                        OVE::Tuplet* tuplet = static_cast<OVE::Tuplet*>(tuplets[i]);
 
911
const OVE::Tuplet* getTuplet(const QList<OVE::MusicData*>& tuplets, int unit){
 
912
        for(int i=0; i<tuplets.size(); ++i){
 
913
                const OVE::MusicData* data = tuplets[i];
 
914
                if(unit >= data->start()->getOffset() && unit <= data->stop()->getOffset()){
 
915
                        const OVE::Tuplet* tuplet = static_cast<OVE::Tuplet*>(tuplets[i]);
921
916
                        return tuplet;
922
917
                }
923
918
        }
1091
1086
}
1092
1087
 
1093
1088
OVE::ClefType getClefType(OVE::MeasureData* measure, int tick) {
1094
 
        unsigned int i;
1095
1089
        OVE::ClefType type = measure->getClef()->getClefType();
1096
 
        std::vector<OVE::MusicData*> clefs = measure->getMusicDatas(OVE::MusicData_Clef);
 
1090
        QList<OVE::MusicData*> clefs = measure->getMusicDatas(OVE::MusicData_Clef);
1097
1091
 
1098
 
        for(i=0; i<clefs.size(); ++i){
 
1092
        for(int i=0; i<clefs.size(); ++i){
1099
1093
                if(tick < clefs[i]->getTick()){
1100
1094
                        break;
1101
1095
                }
1116
1110
 
1117
1111
          convertMeasure(measure);
1118
1112
    }
 
1113
 
 
1114
    //  convert based on notes
 
1115
    for (MeasureBase* mb = score_->measures()->first(); mb; mb = mb->next()) {
 
1116
          if (mb->type() != MEASURE)
 
1117
                continue;
 
1118
          Measure* measure = static_cast<Measure*>(mb);
 
1119
 
 
1120
          convertLines(measure);
 
1121
    }
1119
1122
}
1120
1123
 
1121
1124
void OveToMScore::convertMeasure(Measure* measure){
1136
1139
                                convertLyrics(measure, i, j, trackIndex);
1137
1140
                                convertHarmonys(measure, i, j, trackIndex);
1138
1141
                                convertRepeats(measure, i, j, trackIndex);
1139
 
                                convertSlurs(measure, i, j, trackIndex);
1140
1142
                                convertDynamics(measure, i, j, trackIndex);
1141
1143
                                convertExpressions(measure, i, j, trackIndex);
 
1144
                        }
 
1145
                }
 
1146
 
 
1147
                staffCount += partStaffCount;
 
1148
        }
 
1149
}
 
1150
 
 
1151
void OveToMScore::convertLines(Measure* measure){
 
1152
        int staffCount = 0;
 
1153
        int measureCount = ove_->getMeasureCount();
 
1154
 
 
1155
        for( int i=0; i<ove_->getPartCount(); ++i ){
 
1156
                int partStaffCount = ove_->getStaffCount(i);
 
1157
 
 
1158
                for( int j=0; j<partStaffCount; ++j ){
 
1159
                        int measureID = measure->no();
 
1160
 
 
1161
                        if (measureID >= 0 && measureID < measureCount) {
 
1162
                                int trackIndex = (staffCount + j) * VOICES;
 
1163
 
 
1164
                                convertSlurs(measure, i, j, trackIndex);
1142
1165
                                convertGlissandos(measure, i, j, trackIndex);
1143
1166
                                convertWedges(measure, i, j, trackIndex);
1144
1167
                        }
1214
1237
        }
1215
1238
 
1216
1239
        // rehearsal
1217
 
        unsigned int i;
1218
 
        std::vector<OVE::MusicData*> texts = measureData->getMusicDatas(OVE::MusicData_Text);
 
1240
        int i;
 
1241
        QList<OVE::MusicData*> texts = measureData->getMusicDatas(OVE::MusicData_Text);
1219
1242
        for(i=0; i<texts.size(); ++i){
1220
1243
                OVE::Text* textPtr = static_cast<OVE::Text*>(texts[i]);
1221
1244
                if(textPtr->getTextType() == OVE::Text::Text_Rehearsal){
1223
1246
                        text->setSubtype(TEXT_REHEARSAL_MARK);
1224
1247
                        text->setTextStyle(TEXT_STYLE_REHEARSAL_MARK);
1225
1248
                        text->setTick(mtt_->getTick(measure->no(), 0));
1226
 
            text->setText(toQString(textPtr->getText()));
 
1249
            text->setText(textPtr->getText());
1227
1250
            text->setAbove(true);
1228
1251
            text->setTrack(track);
1229
1252
            measure->add(text);
1231
1254
        }
1232
1255
 
1233
1256
        // tempo
1234
 
        std::vector<OVE::MusicData*> tempos = measureData->getMusicDatas(OVE::MusicData_Tempo);
 
1257
        QList<OVE::MusicData*> tempos = measureData->getMusicDatas(OVE::MusicData_Tempo);
1235
1258
        for(i=0; i<tempos.size(); ++i){
1236
1259
                OVE::Tempo* tempoPtr = static_cast<OVE::Tempo*>(tempos[i]);
1237
1260
                TempoText* t = new TempoText(score_);
1245
1268
 
1246
1269
        t->setTempo(tpo);
1247
1270
        t->setTick(absTick);
1248
 
        t->setText(toQString(tempoPtr->getRightText()));
 
1271
        t->setText(tempoPtr->getRightText());
1249
1272
        t->setAbove(true);
1250
1273
        t->setTrack(track);
1251
1274
        measure->add(t);
1253
1276
}
1254
1277
 
1255
1278
// beam in grace
1256
 
int getGraceLevel(const std::vector<OVE::NoteContainer*>& containers, int tick, int unit){
 
1279
int getGraceLevel(const QList<OVE::NoteContainer*>& containers, int tick, int unit){
1257
1280
        int graceCount = 0;
1258
1281
        int level = 0; // normal chord rest
1259
1282
 
1260
 
        for(unsigned int i=0; i<containers.size(); ++i){
 
1283
        for(int i=0; i<containers.size(); ++i){
1261
1284
                OVE::NoteContainer* container = containers[i];
1262
1285
                if(container->getTick() > tick)
1263
1286
                        break;
1320
1343
}
1321
1344
 
1322
1345
void OveToMScore::convertNotes(Measure* measure, int part, int staff, int track){
1323
 
        unsigned int i;
1324
 
        unsigned int j;
 
1346
        int j;
1325
1347
        OVE::MeasureData* measureData = ove_->getMeasureData(part, staff, measure->no());
1326
 
        std::vector<OVE::NoteContainer*> containers = measureData->getNoteContainers();
1327
 
        std::vector<OVE::MusicData*> tuplets = measureData->getCrossMeasureElements(OVE::MusicData_Tuplet, OVE::MeasureData::PairType_Start);
1328
 
        std::vector<OVE::MusicData*> beams = measureData->getCrossMeasureElements(OVE::MusicData_Beam, OVE::MeasureData::PairType_Start);
 
1348
        QList<OVE::NoteContainer*> containers = measureData->getNoteContainers();
 
1349
        QList<OVE::MusicData*> tuplets = measureData->getCrossMeasureElements(OVE::MusicData_Tuplet, OVE::MeasureData::PairType_Start);
 
1350
        QList<OVE::MusicData*> beams = measureData->getCrossMeasureElements(OVE::MusicData_Beam, OVE::MeasureData::PairType_Start);
1329
1351
        Tuplet* tuplet = 0;
1330
1352
        ChordRest* cr = 0;
1331
1353
        int partStaffCount = ove_->getStaffCount(part);
1340
1362
                s->add(cr);
1341
1363
        }
1342
1364
 
1343
 
        for (i = 0; i < containers.size(); ++i) {
 
1365
        for (int i = 0; i < containers.size(); ++i) {
1344
1366
                OVE::NoteContainer* container = containers[i];
1345
1367
                int tick = mtt_->getTick(measure->no(), container->getTick());
1346
1368
                int noteTrack = track + container->getVoice();
1353
1375
                        cr->setTrack(noteTrack);
1354
1376
                        cr->setVisible(container->getShow());
1355
1377
 
1356
 
                        std::vector<OVE::Note*> notes = container->getNotesRests();
 
1378
                        QList<OVE::Note*> notes = container->getNotesRests();
1357
1379
                        for (j = 0; j < notes.size(); ++j) {
1358
1380
                                OVE::Note* notePtr = notes[j];
1359
1381
                                if(!isRestDefaultLine(notePtr, container->getNoteType()) && notePtr->getLine() != 0) {
1365
1387
                        Segment* s = measure->getSegment(cr);
1366
1388
                        s->add(cr);
1367
1389
                } else {
1368
 
                        std::vector<OVE::Note*> notes = container->getNotesRests();
 
1390
                        QList<OVE::Note*> notes = container->getNotesRests();
1369
1391
 
1370
1392
                        cr = measure->findChord(tick, noteTrack, container->getIsGrace());
1371
1393
                        if (cr == 0) {
1412
1434
                        }
1413
1435
 
1414
1436
                        for (j = 0; j < notes.size(); ++j) {
1415
 
                                OVE::Note* notePtr = notes[j];
 
1437
                                OVE::Note* oveNote = notes[j];
1416
1438
                                Note* note = new Note(score_);
1417
 
                                int pitch = notePtr->getNote();
 
1439
                                int pitch = oveNote->getNote();
1418
1440
 
1419
1441
                                note->setTrack(noteTrack);
1420
 
                                note->setVelocity(notePtr->getOnVelocity());
 
1442
                                note->setVelocity(oveNote->getOnVelocity());
1421
1443
                                //note->setUserAccidental(OveAccidental_to_Accidental(notePtr->getAccidental()));
1422
1444
                                note->setPitch(pitch);
1423
1445
 
1427
1449
                                if(clefType == OVE::Clef_Percussion1 || clefType == OVE::Clef_Percussion2) {
1428
1450
                                        Drumset* drumset = getDrumset(score_, part);
1429
1451
                                        if(drumset != 0) {
1430
 
                                                if (!drumset->isValid(pitch)) {
 
1452
                                                if (!drumset->isValid(pitch) || pitch == -1) {
1431
1453
                                                        printf("unmapped drum note 0x%02x %d\n", note->pitch(), note->pitch());
1432
1454
                                                } else {
1433
1455
                                                        note->setHeadGroup(drumset->noteHead(pitch));
1443
1465
                                        OVE::ToneType clefMiddleTone;
1444
1466
                                        int clefMiddleOctave;
1445
1467
                                        getMiddleToneOctave(clefType, clefMiddleTone, clefMiddleOctave);
1446
 
                                        int absLine = (int) clefMiddleTone + clefMiddleOctave * OCTAVE + notePtr->getLine();
 
1468
                                        int absLine = (int) clefMiddleTone + clefMiddleOctave * OCTAVE + oveNote->getLine();
1447
1469
                                        int tone = absLine % OCTAVE;
1448
 
                                        int alter = accidentalToAlter(notePtr->getAccidental());
 
1470
                                        int alter = accidentalToAlter(oveNote->getAccidental());
1449
1471
                                        note->setTpc(step2tpc(tone, alter));
1450
1472
 
1451
 
                                        note->setHeadGroup(getHeadGroup(notePtr->getHeadType()));
 
1473
                                        note->setHeadGroup(getHeadGroup(oveNote->getHeadType()));
1452
1474
                                }
1453
1475
 
1454
1476
                                // tie
1455
 
                                if ((notePtr->getTiePos() & OVE::Tie_LeftEnd) == OVE::Tie_LeftEnd) {
 
1477
                                if ((oveNote->getTiePos() & OVE::Tie_LeftEnd) == OVE::Tie_LeftEnd) {
1456
1478
                                        Tie* tie = new Tie(score_);
1457
1479
                                        note->setTieFor(tie);
1458
1480
                                        tie->setStartNote(note);
1463
1485
                                // is inserted into pitch sorted list (ws)
1464
1486
                                cr->add(note);
1465
1487
 
1466
 
                                cr->setVisible(notePtr->getShow());
 
1488
                                cr->setVisible(oveNote->getShow());
1467
1489
                                ((Chord*) cr)->setNoStem((int) container->getNoteType() <= OVE::Note_Whole);
1468
1490
                                if(!setDirection)
1469
1491
                                        ((Chord*) cr)->setStemDirection(container->getStemUp() ? UP : DOWN);
1471
1493
                                // cross staff
1472
1494
                                int staffMove = 0;
1473
1495
                                if(partStaffCount == 2){/*treble-bass*/
1474
 
                                        staffMove = notePtr->getOffsetStaff();
 
1496
                                        staffMove = oveNote->getOffsetStaff();
1475
1497
                                }
1476
1498
                                cr->setStaffMove(staffMove);
1477
1499
                        }
1504
1526
                // tuplet
1505
1527
                if (container->getTuplet() > 0) {
1506
1528
                        if (tuplet == 0) {
1507
 
                                tuplet = new Tuplet(score_);
1508
 
                                tuplet->setTrack(noteTrack);
1509
 
                                tuplet->setRatio(Fraction(container->getTuplet(), container->getSpace()));
1510
 
                                tuplet->setTick(tick);
1511
 
                                measure->add(tuplet);
 
1529
                                bool create = true;
 
1530
 
 
1531
                                // check tuplet start
 
1532
                                if(container->getNoteType() < OVE::Note_Eight) {
 
1533
                                        const OVE::Tuplet* oveTuplet = getTuplet(tuplets, container->start()->getOffset());
 
1534
                                        if(oveTuplet == 0) {
 
1535
                                                create = false;
 
1536
                                        }
 
1537
                                }
 
1538
 
 
1539
                                if(create) {
 
1540
                                        tuplet = new Tuplet(score_);
 
1541
                                        tuplet->setTrack(noteTrack);
 
1542
                                        tuplet->setRatio(Fraction(container->getTuplet(), container->getSpace()));
 
1543
                                        tuplet->setTick(tick);
 
1544
                                        measure->add(tuplet);
 
1545
                                }
1512
1546
                        }
1513
1547
 
1514
1548
                        if (tuplet != 0) {
1518
1552
 
1519
1553
                        if (tuplet != 0) {
1520
1554
                                // check tuplet end
1521
 
                                OVE::Tuplet* tupletPtr = getTuplet(tuplets, container->start()->getOffset());
1522
 
                                if (tupletPtr != 0) {
 
1555
                                const OVE::Tuplet* oveTuplet = getTuplet(tuplets, container->start()->getOffset());
 
1556
                                if (oveTuplet != 0) {
1523
1557
                                        //set direction
1524
 
                                        tuplet->setDirection(tupletPtr->getLeftShoulder()->getYOffset() < 0 ? UP : DOWN);
 
1558
                                        tuplet->setDirection(oveTuplet->getLeftShoulder()->getYOffset() < 0 ? UP : DOWN);
1525
1559
 
1526
 
                                        if(container->start()->getOffset() == tupletPtr->stop()->getOffset()){
 
1560
                                        if(container->start()->getOffset() == oveTuplet->stop()->getOffset()){
1527
1561
                                                tuplet = 0;
1528
1562
                                        }
1529
1563
                                }
1531
1565
                }
1532
1566
 
1533
1567
                // articulation
1534
 
                std::vector<OVE::Articulation*> articulations = container->getArticulations();
 
1568
                QList<OVE::Articulation*> articulations = container->getArticulations();
1535
1569
                for (j = 0; j < articulations.size(); ++j) {
1536
1570
                        convertArticulation(measure, cr, noteTrack, tick, articulations[j]);
1537
1571
                }
1761
1795
                break;
1762
1796
        }
1763
1797
        case OVE::Articulation_Pedal_Down :{
1764
 
                if(pedal_ == NULL) {
 
1798
                if(pedal_) {
 
1799
                        delete pedal_;
 
1800
                        pedal_ = 0;
 
1801
                }
 
1802
                else {
1765
1803
                        pedal_ = new Pedal(score_);
1766
1804
                        pedal_->setTrack(track);
1767
1805
                        pedal_->setTick(absTick);
1795
1833
        if(measureData == 0)
1796
1834
                return;
1797
1835
 
1798
 
        std::vector<OVE::MusicData*> lyrics = measureData->getMusicDatas(OVE::MusicData_Lyric);
 
1836
        QList<OVE::MusicData*> lyrics = measureData->getMusicDatas(OVE::MusicData_Lyric);
1799
1837
 
1800
 
        for(unsigned int i=0; i<lyrics.size(); ++i){
1801
 
                OVE::Lyric* lyricPtr = static_cast<OVE::Lyric*>(lyrics[i]);
1802
 
                int tick = mtt_->getTick(measure->no(), lyricPtr->getTick());
 
1838
        for(int i=0; i<lyrics.size(); ++i){
 
1839
                OVE::Lyric* oveLyric = static_cast<OVE::Lyric*>(lyrics[i]);
 
1840
                int tick = mtt_->getTick(measure->no(), oveLyric->getTick());
1803
1841
 
1804
1842
                Lyrics* lyric = new Lyrics(score_);
1805
 
                lyric->setNo(lyricPtr->getVerse());
 
1843
                lyric->setNo(oveLyric->getVerse());
1806
1844
                lyric->setTick(tick);
1807
 
                lyric->setText(toQString(lyricPtr->getLyric()));
 
1845
                lyric->setText(oveLyric->getLyric());
1808
1846
                lyric->setTrack(track);
1809
1847
            Segment* segment = measure->getSegment(lyric);
1810
1848
            segment->add(lyric);
1893
1931
        if(measureData == 0)
1894
1932
                return;
1895
1933
 
1896
 
        std::vector<OVE::MusicData*> harmonys = measureData->getMusicDatas(OVE::MusicData_Harmony);
 
1934
        QList<OVE::MusicData*> harmonys = measureData->getMusicDatas(OVE::MusicData_Harmony);
1897
1935
 
1898
 
        for(unsigned int i=0; i<harmonys.size(); ++i){
 
1936
        for(int i=0; i<harmonys.size(); ++i){
1899
1937
                OVE::Harmony* harmonyPtr = static_cast<OVE::Harmony*>(harmonys[i]);
1900
1938
                int absTick = mtt_->getTick(measure->no(), harmonyPtr->getTick());
1901
1939
 
1920
1958
/*OVE::MusicData* OveToMScore::getMusicDataByUnit(int part, int staff, int measure, int unit, OVE::MusicDataType type){
1921
1959
        OVE::MeasureData* measureData = ove_->getMeasureData(part, staff, measure);
1922
1960
        if(measureData != 0) {
1923
 
                const std::vector<OVE::MusicData*>& datas = measureData->getMusicDatas(type);
 
1961
                const QList<OVE::MusicData*>& datas = measureData->getMusicDatas(type);
1924
1962
                for(unsigned int i=0; i<datas.size(); ++i){
1925
1963
                        if(datas[i]->getTick() == unit){//different measurement
1926
1964
                                return datas[i];
1934
1972
OVE::MusicData* OveToMScore::getCrossMeasureElementByPos(int part, int staff, const OVE::MeasurePos& pos, int voice, OVE::MusicDataType type){
1935
1973
        OVE::MeasureData* measureData = ove_->getMeasureData(part, staff, pos.getMeasure());
1936
1974
        if(measureData != 0) {
1937
 
                const std::vector<OVE::MusicData*>& datas = measureData->getCrossMeasureElements(type, OVE::MeasureData::PairType_All);
1938
 
                for(unsigned int i=0; i<datas.size(); ++i){
 
1975
                const QList<OVE::MusicData*>& datas = measureData->getCrossMeasureElements(type, OVE::MeasureData::PairType_All);
 
1976
                for(int i=0; i<datas.size(); ++i){
1939
1977
                        OVE::MeasurePos dataStart = datas[i]->start()->shiftMeasure(0);
1940
1978
                        OVE::MeasurePos dataStop = datas[i]->stop()->shiftMeasure(datas[i]->start()->getMeasure());
1941
1979
 
1951
1989
OVE::NoteContainer* OveToMScore::getContainerByPos(int part, int staff, const OVE::MeasurePos& pos){
1952
1990
        OVE::MeasureData* measureData = ove_->getMeasureData(part, staff, pos.getMeasure());
1953
1991
        if(measureData != 0) {
1954
 
                const std::vector<OVE::NoteContainer*>& containers = measureData->getNoteContainers();
1955
 
                for(unsigned int i=0; i<containers.size(); ++i){
 
1992
                const QList<OVE::NoteContainer*>& containers = measureData->getNoteContainers();
 
1993
                for(int i=0; i<containers.size(); ++i){
1956
1994
                        if(pos == containers[i]->start()->shiftMeasure(0)){
1957
1995
                                return containers[i];
1958
1996
                        }
1967
2005
        if(measureData == 0)
1968
2006
                return;
1969
2007
 
1970
 
        unsigned int i;
1971
 
        std::vector<OVE::MusicData*> repeats = measureData->getMusicDatas(OVE::MusicData_Repeat);
 
2008
        int i;
 
2009
        QList<OVE::MusicData*> repeats = measureData->getMusicDatas(OVE::MusicData_Repeat);
1972
2010
 
1973
2011
        for(i=0; i<repeats.size(); ++i){
1974
2012
                OVE::RepeatSymbol* repeatPtr = static_cast<OVE::RepeatSymbol*>(repeats[i]);
2034
2072
                }
2035
2073
        }
2036
2074
 
2037
 
        std::vector<OVE::MusicData*> endings = measureData->getCrossMeasureElements(
 
2075
        QList<OVE::MusicData*> endings = measureData->getCrossMeasureElements(
2038
2076
                                                                                                                        OVE::MusicData_Numeric_Ending,
2039
2077
                                                                                                                        OVE::MeasureData::PairType_Start);
2040
2078
 
2043
2081
                int absTick1 = mtt_->getTick(measure->no(), 0);
2044
2082
                int absTick2 = mtt_->getTick(measure->no() + ending->stop()->getMeasure(), 0);
2045
2083
 
2046
 
        Volta* volta = new Volta(score_);
2047
 
        volta->setTrack(track);
2048
 
        volta->setTick(absTick1);
2049
 
        volta->setTick2(absTick2);
2050
 
        volta->setSubtype(Volta::VOLTA_CLOSED);
2051
 
        volta->setText(toQString(ending->getText()));
2052
 
 
2053
 
        volta->endings().clear();
2054
 
        std::vector<int> numbers = ending->getNumbers();
2055
 
        for(unsigned int j=0; j<numbers.size(); ++j){
2056
 
                volta->endings().append(numbers[j]);
2057
 
        }
2058
 
 
2059
 
                if(volta->tick2() > volta->tick()){
 
2084
                if (absTick1 < absTick2) {
 
2085
                Volta* volta = new Volta(score_);
 
2086
                volta->setTrack(track);
 
2087
            volta->setTick(absTick1);
 
2088
                volta->setTick2(absTick2);
 
2089
                volta->setSubtype(Volta::VOLTA_CLOSED);
 
2090
            volta->setText(ending->getText());
 
2091
 
 
2092
                        volta->endings().clear();
 
2093
                        QList<int> numbers = ending->getNumbers();
 
2094
                        for (int j = 0; j < numbers.size(); ++j) {
 
2095
                                volta->endings().append(numbers[j]);
 
2096
                        }
 
2097
                        
2060
2098
                        score_->add(volta);
2061
 
                } else {
2062
 
                        delete volta;
2063
2099
                }
2064
2100
        }
2065
2101
}
2069
2105
        if(measureData == 0)
2070
2106
                return;
2071
2107
 
2072
 
        std::vector<OVE::MusicData*> slurs = measureData->getCrossMeasureElements(OVE::MusicData_Slur, OVE::MeasureData::PairType_Start);
 
2108
        QList<OVE::MusicData*> slurs = measureData->getCrossMeasureElements(OVE::MusicData_Slur, OVE::MeasureData::PairType_Start);
2073
2109
 
2074
 
        for(unsigned int i=0; i<slurs.size(); ++i){
 
2110
        for(int i=0; i<slurs.size(); ++i){
2075
2111
                OVE::Slur* slurPtr = static_cast<OVE::Slur*>(slurs[i]);
2076
2112
 
2077
2113
                OVE::NoteContainer* startContainer = getContainerByPos(part, staff, slurPtr->start()->shiftMeasure(0));
2176
2212
        if(measureData == 0)
2177
2213
                return;
2178
2214
 
2179
 
        std::vector<OVE::MusicData*> dynamics = measureData->getMusicDatas(OVE::MusicData_Dynamics);
 
2215
        QList<OVE::MusicData*> dynamics = measureData->getMusicDatas(OVE::MusicData_Dynamics);
2180
2216
 
2181
 
        for(unsigned int i=0; i<dynamics.size(); ++i){
 
2217
        for(int i=0; i<dynamics.size(); ++i){
2182
2218
                OVE::Dynamics* dynamicPtr = static_cast<OVE::Dynamics*>(dynamics[i]);
2183
2219
                int absTick = mtt_->getTick(measure->no(), dynamicPtr->getTick());
2184
2220
                Dynamic* dynamic = new Dynamic(score_);
2196
2232
        if(measureData == 0)
2197
2233
                return;
2198
2234
 
2199
 
        std::vector<OVE::MusicData*> expressions = measureData->getMusicDatas(OVE::MusicData_Expressions);
 
2235
        QList<OVE::MusicData*> expressions = measureData->getMusicDatas(OVE::MusicData_Expressions);
2200
2236
 
2201
 
        for(unsigned int i=0; i<expressions.size(); ++i){
 
2237
        for(int i=0; i<expressions.size(); ++i){
2202
2238
                OVE::Expressions* expressionPtr = static_cast<OVE::Expressions*>(expressions[i]);
2203
2239
                int absTick = mtt_->getTick(measure->no(), expressionPtr->getTick());
2204
2240
                Text* t = new Text(score_);
2205
2241
 
2206
2242
                t->setTextStyle(TEXT_STYLE_TECHNIK);
2207
2243
 
2208
 
                t->setText(toQString(expressionPtr->getText()));
 
2244
                t->setText(expressionPtr->getText());
2209
2245
                t->setTrack(track);
2210
2246
                t->setTick(absTick);
2211
2247
 
2218
2254
        if(measureData == 0)
2219
2255
                return;
2220
2256
 
2221
 
        std::vector<OVE::MusicData*> glissandos = measureData->getCrossMeasureElements(OVE::MusicData_Glissando, OVE::MeasureData::PairType_All);
 
2257
        QList<OVE::MusicData*> glissandos = measureData->getCrossMeasureElements(OVE::MusicData_Glissando, OVE::MeasureData::PairType_All);
2222
2258
 
2223
 
        for(unsigned int i=0; i<glissandos.size(); ++i){
 
2259
        for(int i=0; i<glissandos.size(); ++i){
2224
2260
                OVE::Glissando* glissandoPtr = static_cast<OVE::Glissando*>(glissandos[i]);
2225
2261
                OVE::NoteContainer* startContainer = getContainerByPos(part, staff, glissandoPtr->start()->shiftMeasure(0));
2226
2262
                OVE::NoteContainer* endContainer = getContainerByPos(
2275
2311
        if(measureData == 0)
2276
2312
                return;
2277
2313
 
2278
 
        std::vector<OVE::MusicData*> wedges = measureData->getCrossMeasureElements(OVE::MusicData_Wedge, OVE::MeasureData::PairType_All);
 
2314
        QList<OVE::MusicData*> wedges = measureData->getCrossMeasureElements(OVE::MusicData_Wedge, OVE::MeasureData::PairType_All);
2279
2315
 
2280
 
        for(unsigned int i=0; i<wedges.size(); ++i){
 
2316
        for(int i=0; i<wedges.size(); ++i){
2281
2317
                OVE::Wedge* wedgePtr = static_cast<OVE::Wedge*>(wedges[i]);
2282
2318
                int absTick = mtt_->getTick(
2283
2319
                                                        measure->no(),
2295
2331
                        //hp->setYoff(wedgePtr->getYOffset());
2296
2332
                        hp->setTrack(track);
2297
2333
 
2298
 
                        if(hp->tick2() > hp->tick()){
2299
 
                                score_->add(hp);
2300
 
                        } else {
2301
 
                                delete hp;
2302
 
                        }
 
2334
                        score_->add(hp);
2303
2335
                }
2304
2336
        }
2305
2337
}
2320
2352
 
2321
2353
        oveFile.close();
2322
2354
 
 
2355
        oveSong.setTextCodecName(preferences.importCharset);
2323
2356
        oveLoader->setOve(&oveSong);
2324
2357
        oveLoader->setFileStream((unsigned char*) buffer.data(), buffer.size());
2325
2358
        bool result = oveLoader->load();