2400 lines
93 KiB
C++
2400 lines
93 KiB
C++
//=============================================================================
|
|
// MusE Score
|
|
// Linux Music Score Editor
|
|
// $Id: importove.cpp 3763 2010-12-15 15:50:09Z vanferry $
|
|
//
|
|
// Copyright (C) 2002-2009 Werner Schweer and others
|
|
//
|
|
// This program is free software; you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License version 2.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program; if not, write to the Free Software
|
|
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
//=============================================================================
|
|
|
|
#include "ove.h"
|
|
|
|
#include "globals.h"
|
|
#include "musescore.h"
|
|
#include "libmscore/sig.h"
|
|
#include "libmscore/tempo.h"
|
|
#include "libmscore/arpeggio.h"
|
|
#include "libmscore/articulation.h"
|
|
#include "libmscore/barline.h"
|
|
#include "libmscore/box.h"
|
|
#include "libmscore/bracket.h"
|
|
#include "libmscore/breath.h"
|
|
#include "libmscore/chord.h"
|
|
#include "libmscore/clef.h"
|
|
#include "libmscore/drumset.h"
|
|
#include "libmscore/dynamic.h"
|
|
#include "libmscore/hairpin.h"
|
|
#include "libmscore/harmony.h"
|
|
#include "libmscore/glissando.h"
|
|
#include "libmscore/keysig.h"
|
|
#include "libmscore/layoutbreak.h"
|
|
#include "libmscore/lyrics.h"
|
|
#include "libmscore/measure.h"
|
|
#include "libmscore/note.h"
|
|
#include "libmscore/ottava.h"
|
|
#include "libmscore/part.h"
|
|
#include "libmscore/pedal.h"
|
|
#include "libmscore/pitchspelling.h"
|
|
#include "preferences.h"
|
|
#include "libmscore/repeat.h"
|
|
#include "libmscore/rest.h"
|
|
#include "libmscore/score.h"
|
|
#include "libmscore/segment.h"
|
|
#include "libmscore/slur.h"
|
|
#include "libmscore/tie.h"
|
|
#include "libmscore/staff.h"
|
|
#include "libmscore/tempotext.h"
|
|
#include "libmscore/text.h"
|
|
#include "libmscore/timesig.h"
|
|
#include "libmscore/tuplet.h"
|
|
#include "libmscore/tremolo.h"
|
|
#include "libmscore/volta.h"
|
|
#include "libmscore/chordlist.h"
|
|
#include "libmscore/rehearsalmark.h"
|
|
#include "libmscore/marker.h"
|
|
#include "libmscore/jump.h"
|
|
|
|
using namespace Ms;
|
|
|
|
class MeasureToTick {
|
|
public:
|
|
MeasureToTick();
|
|
~MeasureToTick();
|
|
|
|
public:
|
|
void build(OVE::OveSong* ove, int quarter);
|
|
|
|
int getTick(int measure, int tick_pos);
|
|
static int unitToTick(int unit, int quarter);
|
|
|
|
struct TimeTick {
|
|
int numerator_;
|
|
int denominator_;
|
|
int measure_;
|
|
int tick_;
|
|
bool isSymbol_;
|
|
|
|
TimeTick():numerator_(4), denominator_(4), measure_(0), tick_(0), isSymbol_(false){}
|
|
};
|
|
QList<TimeTick> getTimeTicks() const;
|
|
|
|
private:
|
|
int quarter_;
|
|
OVE::OveSong* ove_;
|
|
QList<TimeTick> tts_;
|
|
};
|
|
|
|
int getMeasureTick(int quarter, int num, int den){
|
|
return quarter * 4 * num / den;
|
|
}
|
|
|
|
MeasureToTick::MeasureToTick(){
|
|
quarter_ = 480;
|
|
ove_ = 0;
|
|
}
|
|
|
|
MeasureToTick::~MeasureToTick(){
|
|
}
|
|
|
|
void MeasureToTick::build(OVE::OveSong* ove, int quarter){
|
|
unsigned int i;
|
|
int currentTick = 0;
|
|
unsigned int measureCount = ove->getMeasureCount();
|
|
|
|
quarter_ = quarter;
|
|
ove_ = ove;
|
|
tts_.clear();
|
|
|
|
for(i=0; i<measureCount; ++i) {
|
|
OVE::Measure* measure = ove_->getMeasure(i);
|
|
OVE::TimeSignature* time = measure->getTime();
|
|
TimeTick tt;
|
|
bool change = false;
|
|
|
|
tt.tick_ = currentTick;
|
|
tt.numerator_ = time->getNumerator();
|
|
tt.denominator_ = time->getDenominator();
|
|
tt.measure_ = i;
|
|
tt.isSymbol_ = time->getIsSymbol();
|
|
|
|
if( i == 0 ){
|
|
change = true;
|
|
} else {
|
|
OVE::TimeSignature* previousTime = ove_->getMeasure(i-1)->getTime();
|
|
|
|
if( time->getNumerator() != previousTime->getNumerator() ||
|
|
time->getDenominator() != previousTime->getDenominator() ){
|
|
change = true;
|
|
} else if(time->getIsSymbol() != previousTime->getIsSymbol()){
|
|
change = true;
|
|
}
|
|
}
|
|
|
|
if( change ){
|
|
tts_.push_back(tt);
|
|
}
|
|
|
|
currentTick += getMeasureTick(quarter_, tt.numerator_, tt.denominator_);
|
|
}
|
|
}
|
|
|
|
int MeasureToTick::getTick(int measure, int tick_pos){
|
|
TimeTick tt;
|
|
|
|
for(int i=0; i<tts_.size(); ++i) {
|
|
if( measure >= tts_[i].measure_ && ( i==tts_.size()-1 || measure < tts_[i+1].measure_ ) ) {
|
|
int measuresTick = (measure - tts_[i].measure_) * getMeasureTick(quarter_, tts_[i].numerator_, tts_[i].denominator_);
|
|
return tts_[i].tick_ + measuresTick + tick_pos;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int MeasureToTick::unitToTick(int unit, int quarter) {
|
|
// 0x100 correspond to quarter tick
|
|
float ratio = (float)unit / (float)256.0;
|
|
int tick = ratio * quarter;
|
|
return tick;
|
|
}
|
|
|
|
QList<MeasureToTick::TimeTick> MeasureToTick::getTimeTicks() const {
|
|
return tts_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////
|
|
class OveToMScore {
|
|
public:
|
|
OveToMScore();
|
|
~OveToMScore();
|
|
|
|
public:
|
|
void convert(OVE::OveSong* oveData, Score* score);
|
|
|
|
private:
|
|
void createStructure();
|
|
void convertHeader();
|
|
void convertGroups();
|
|
void convertTrackHeader(OVE::Track* track, Part* part);
|
|
void convertTrackElements(int track);
|
|
void convertLineBreak();
|
|
void convertSignatures();
|
|
void convertMeasures();
|
|
void convertMeasure(Measure* measure);
|
|
void convertMeasureMisc(Measure* measure, int part, int staff, int track);
|
|
void convertNotes(Measure* measure, int part, int staff, int track);
|
|
void convertArticulation(Measure* measure, ChordRest* cr, int track, int absTick, OVE::Articulation* art);
|
|
void convertLyrics(Measure* measure, int part, int staff, int track);
|
|
void convertHarmonys(Measure* measure, int part, int staff, int track);
|
|
void convertRepeats(Measure* measure, int part, int staff, int track);
|
|
void convertDynamics(Measure* measure, int part, int staff, int track);
|
|
void convertExpressions(Measure* measure, int part, int staff, int track);
|
|
void convertLines(Measure* measure);
|
|
void convertSlurs(Measure* measure, int part, int staff, int track);
|
|
void convertGlissandos(Measure* measure, int part, int staff, int track);
|
|
void convertWedges(Measure* measure, int part, int staff, int track);
|
|
void convertOctaveShifts(Measure* measure, int part, int staff, int track);
|
|
|
|
OVE::NoteContainer* getContainerByPos(int part, int staff, const OVE::MeasurePos& pos);
|
|
//OVE::MusicData* getMusicDataByUnit(int part, int staff, int measure, int unit, OVE::MusicDataType type);
|
|
OVE::MusicData* getCrossMeasureElementByPos(int part, int staff, const OVE::MeasurePos& pos, int voice, OVE::MusicDataType type);
|
|
ChordRest* findChordRestByPos(int absTick, int track);
|
|
|
|
void clearUp();
|
|
|
|
private:
|
|
OVE::OveSong* ove_;
|
|
Score* score_;
|
|
MeasureToTick* mtt_;
|
|
|
|
Pedal* pedal_;
|
|
};
|
|
|
|
OveToMScore::OveToMScore() {
|
|
ove_ = 0;
|
|
mtt_ = new MeasureToTick();
|
|
pedal_ = 0;
|
|
}
|
|
|
|
OveToMScore::~OveToMScore() {
|
|
delete mtt_;
|
|
}
|
|
|
|
void OveToMScore::convert(OVE::OveSong* ove, Score* score) {
|
|
ove_ = ove;
|
|
score_ = score;
|
|
mtt_->build(ove_, ove_->getQuarter());
|
|
|
|
convertHeader();
|
|
createStructure();
|
|
convertGroups();
|
|
convertSignatures();
|
|
//convertLineBreak();
|
|
|
|
int staffCount = 0;
|
|
for(int i=0; i<ove_->getPartCount(); ++i ){
|
|
int partStaffCount = ove_->getStaffCount(i) ;
|
|
Part* part = score_->parts().at(i);
|
|
|
|
for(int j=0; j<partStaffCount; ++j){
|
|
OVE::Track* track = ove_->getTrack(i, j);
|
|
|
|
convertTrackHeader(track, part);
|
|
}
|
|
|
|
staffCount += partStaffCount;
|
|
}
|
|
|
|
convertMeasures();
|
|
|
|
// convert elements by ove track sequence
|
|
staffCount = 0;
|
|
for(int i=0; i<ove_->getPartCount(); ++i ){
|
|
int partStaffCount = ove_->getStaffCount(i) ;
|
|
|
|
for(int j=0; j<partStaffCount; ++j){
|
|
int trackIndex = staffCount + j;
|
|
|
|
convertTrackElements(trackIndex);
|
|
}
|
|
|
|
staffCount += partStaffCount;
|
|
}
|
|
|
|
clearUp();
|
|
}
|
|
|
|
void OveToMScore::createStructure() {
|
|
int i;
|
|
for(i=0; i<ove_->getPartCount(); ++i ){
|
|
int partStaffCount = ove_->getStaffCount(i) ;
|
|
Part* part = new Part(score_);
|
|
|
|
for(int j=0; j<partStaffCount; ++j){
|
|
//OVE::Track* track = ove_->getTrack(i, j);
|
|
Staff* staff = new Staff(score_);
|
|
staff->setPart(part);
|
|
|
|
part->staves()->push_back(staff);
|
|
score_->staves().push_back(staff);
|
|
}
|
|
|
|
score_->appendPart(part);
|
|
part->setStaves(partStaffCount);
|
|
}
|
|
|
|
for(i = 0; i <ove_->getMeasureCount(); ++i) {
|
|
Measure* measure = new Measure(score_);
|
|
int tick = mtt_->getTick(i, 0);
|
|
measure->setTick(tick);
|
|
measure->setNo(i);
|
|
score_->measures()->add(measure);
|
|
}
|
|
}
|
|
|
|
void OveToMScore::clearUp() {
|
|
if(pedal_ != NULL) {
|
|
delete pedal_;
|
|
pedal_ = 0;
|
|
}
|
|
}
|
|
|
|
OVE::Staff* getStaff(const OVE::OveSong* ove, int track) {
|
|
if (ove->getLineCount() > 0) {
|
|
OVE::Line* line = ove->getLine(0);
|
|
if(line != 0 && line->getStaffCount() > 0) {
|
|
OVE::Staff* staff = line->getStaff(track);
|
|
return staff;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void addText(VBox* & vbox, Score* s, QString strTxt, TextStyleType stl) {
|
|
if (!strTxt.isEmpty()) {
|
|
Text* text = new Text(s);
|
|
text->setTextStyleType(stl);
|
|
text->setText(strTxt);
|
|
if(vbox == 0) {
|
|
vbox = new VBox(s);
|
|
}
|
|
vbox->add(text);
|
|
}
|
|
}
|
|
|
|
void OveToMScore::convertHeader() {
|
|
VBox* vbox = 0;
|
|
QList<QString> titles = ove_->getTitles();
|
|
if( !titles.empty() && !titles[0].isEmpty() ) {
|
|
QString title = titles[0];
|
|
score_->setMetaTag("movementTitle", title);
|
|
addText(vbox, score_, title, TextStyleType::TITLE);
|
|
}
|
|
|
|
QList<QString> writers = ove_->getWriters();
|
|
if(!writers.empty()) {
|
|
QString composer = writers[0];
|
|
addText(vbox, score_, composer, TextStyleType::COMPOSER);
|
|
}
|
|
|
|
if(writers.size() > 1) {
|
|
QString lyricist = writers[1];
|
|
addText(vbox, score_, lyricist, TextStyleType::POET);
|
|
}
|
|
|
|
if (vbox) {
|
|
vbox->setTick(0);
|
|
score_->measures()->add(vbox);
|
|
}
|
|
}
|
|
|
|
void OveToMScore::convertGroups() {
|
|
int i;
|
|
int staffCount = 0;
|
|
const QList<Part*>& parts = score_->parts();
|
|
for(i=0; i<ove_->getPartCount(); ++i ){
|
|
int partStaffCount = ove_->getStaffCount(i);
|
|
//if(parts == 0)
|
|
// continue;
|
|
Part* part = parts.at(i);
|
|
if(part == 0)
|
|
continue;
|
|
|
|
for(int j=0; j<partStaffCount; ++j){
|
|
int staffIndex = staffCount + j;
|
|
Staff* staff = score_->staff(staffIndex);
|
|
if(staff == 0)
|
|
continue;
|
|
|
|
// brace
|
|
if( j == 0 && partStaffCount == 2 ) {
|
|
staff->setBracket(0, BracketType::BRACE);
|
|
staff->setBracketSpan(0, 2);
|
|
staff->setBarLineSpan(2);
|
|
}
|
|
|
|
// bracket
|
|
OVE::Staff* staffPtr = getStaff(ove_, staffIndex);
|
|
if(staffPtr != 0 && staffPtr->getGroupType() == OVE::GroupType::Bracket) {
|
|
int span = staffPtr->getGroupStaffCount() + 1;
|
|
int endStaff = staffIndex + span;
|
|
if(span > 0 && endStaff >= staffIndex && endStaff <= ove_->getTrackCount()) {
|
|
staff->addBracket(BracketItem(BracketType::NORMAL, span));
|
|
staff->setBarLineSpan(span);
|
|
}
|
|
}
|
|
}
|
|
|
|
staffCount += partStaffCount;
|
|
}
|
|
}
|
|
|
|
ClefType OveClefToClef(OVE::ClefType type){
|
|
ClefType clef = ClefType::G;
|
|
switch(type){
|
|
case OVE::ClefType::Treble:{
|
|
clef = ClefType::G;
|
|
break;
|
|
}
|
|
case OVE::ClefType::Bass:{
|
|
clef = ClefType::F;
|
|
break;
|
|
}
|
|
case OVE::ClefType::Alto:{
|
|
clef = ClefType::C3;
|
|
break;
|
|
}
|
|
case OVE::ClefType::UpAlto:{
|
|
clef = ClefType::C4;
|
|
break;
|
|
}
|
|
case OVE::ClefType::DownDownAlto:{
|
|
clef = ClefType::C1;
|
|
break;
|
|
}
|
|
case OVE::ClefType::DownAlto:{
|
|
clef = ClefType::C2;
|
|
break;
|
|
}
|
|
case OVE::ClefType::UpUpAlto:{
|
|
clef = ClefType::C5;
|
|
break;
|
|
}
|
|
case OVE::ClefType::Treble8va:{
|
|
clef = ClefType::G1;
|
|
break;
|
|
}
|
|
case OVE::ClefType::Bass8va:{
|
|
clef = ClefType::F_8VA;
|
|
break;
|
|
}
|
|
case OVE::ClefType::Treble8vb:{
|
|
clef = ClefType::G3;
|
|
break;
|
|
}
|
|
case OVE::ClefType::Bass8vb:{
|
|
clef = ClefType::F8;
|
|
break;
|
|
}
|
|
case OVE::ClefType::Percussion1:{
|
|
clef = ClefType::PERC;
|
|
break;
|
|
}
|
|
case OVE::ClefType::Percussion2:{
|
|
clef = ClefType::PERC2;
|
|
break;
|
|
}
|
|
case OVE::ClefType::TAB:{
|
|
clef = ClefType::TAB;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return clef;
|
|
}
|
|
|
|
NoteHead::Group getHeadGroup(OVE::NoteHeadType type) {
|
|
NoteHead::Group headGroup = NoteHead::Group::HEAD_NORMAL;
|
|
switch (type) {
|
|
case OVE::NoteHeadType::Standard: {
|
|
headGroup = NoteHead::Group::HEAD_NORMAL;
|
|
break;
|
|
}
|
|
case OVE::NoteHeadType::Invisible: {
|
|
break;
|
|
}
|
|
case OVE::NoteHeadType::Rhythmic_Slash: {
|
|
headGroup = NoteHead::Group::HEAD_SLASH;
|
|
break;
|
|
}
|
|
case OVE::NoteHeadType::Percussion: {
|
|
headGroup = NoteHead::Group::HEAD_XCIRCLE;
|
|
break;
|
|
}
|
|
case OVE::NoteHeadType::Closed_Rhythm: {
|
|
headGroup = NoteHead::Group::HEAD_CROSS;
|
|
break;
|
|
}
|
|
case OVE::NoteHeadType::Open_Rhythm: {
|
|
headGroup = NoteHead::Group::HEAD_CROSS;
|
|
break;
|
|
}
|
|
case OVE::NoteHeadType::Closed_Slash: {
|
|
headGroup = NoteHead::Group::HEAD_SLASH;
|
|
break;
|
|
}
|
|
case OVE::NoteHeadType::Open_Slash: {
|
|
headGroup = NoteHead::Group::HEAD_SLASH;
|
|
break;
|
|
}
|
|
case OVE::NoteHeadType::Closed_Do: {
|
|
headGroup = NoteHead::Group::HEAD_DO;
|
|
break;
|
|
}
|
|
case OVE::NoteHeadType::Open_Do: {
|
|
headGroup = NoteHead::Group::HEAD_DO;
|
|
break;
|
|
}
|
|
case OVE::NoteHeadType::Closed_Re: {
|
|
headGroup = NoteHead::Group::HEAD_RE;
|
|
break;
|
|
}
|
|
case OVE::NoteHeadType::Open_Re: {
|
|
headGroup = NoteHead::Group::HEAD_RE;
|
|
break;
|
|
}
|
|
case OVE::NoteHeadType::Closed_Mi: {
|
|
headGroup = NoteHead::Group::HEAD_MI;
|
|
break;
|
|
}
|
|
case OVE::NoteHeadType::Open_Mi: {
|
|
headGroup = NoteHead::Group::HEAD_MI;
|
|
break;
|
|
}
|
|
case OVE::NoteHeadType::Closed_Fa: {
|
|
headGroup = NoteHead::Group::HEAD_FA;
|
|
break;
|
|
}
|
|
case OVE::NoteHeadType::Open_Fa: {
|
|
headGroup = NoteHead::Group::HEAD_FA;
|
|
break;
|
|
}
|
|
case OVE::NoteHeadType::Closed_Sol: {
|
|
break;
|
|
}
|
|
case OVE::NoteHeadType::Open_Sol: {
|
|
break;
|
|
}
|
|
case OVE::NoteHeadType::Closed_La: {
|
|
headGroup = NoteHead::Group::HEAD_LA;
|
|
break;
|
|
}
|
|
case OVE::NoteHeadType::Open_La: {
|
|
headGroup = NoteHead::Group::HEAD_LA;
|
|
break;
|
|
}
|
|
case OVE::NoteHeadType::Closed_Ti: {
|
|
headGroup = NoteHead::Group::HEAD_TI;
|
|
break;
|
|
}
|
|
case OVE::NoteHeadType::Open_Ti: {
|
|
headGroup = NoteHead::Group::HEAD_TI;
|
|
break;
|
|
}
|
|
default: {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return headGroup;
|
|
}
|
|
|
|
void OveToMScore::convertTrackHeader(OVE::Track* track, Part* part){
|
|
if(track == 0 || part == 0)
|
|
return;
|
|
|
|
QString longName = track->getName();
|
|
if (longName != QString() && track->getShowName()){
|
|
part->setLongName(longName);
|
|
}
|
|
|
|
QString shortName = track->getBriefName();
|
|
if (shortName != QString() && track->getShowBriefName()) {
|
|
part->setShortName(shortName);
|
|
}
|
|
|
|
part->setMidiProgram(track->getPatch());
|
|
|
|
if (ove_->getShowTransposeTrack() && track->getTranspose() != 0 ) {
|
|
Ms::Interval interval = part->instrument()->transpose();
|
|
interval.diatonic = -track->getTranspose();
|
|
part->instrument()->setTranspose(interval);
|
|
}
|
|
|
|
// DrumSet
|
|
if(track->getStartClef()==OVE::ClefType::Percussion1 || track->getStartClef()==OVE::ClefType::Percussion2) {
|
|
//use overture drumset
|
|
Drumset* drumset = new Drumset();
|
|
for (int i = 0; i < DRUM_INSTRUMENTS; ++i) {
|
|
drumset->drum(i).name = smDrumset->drum(i).name;
|
|
drumset->drum(i).notehead = smDrumset->drum(i).notehead;
|
|
drumset->drum(i).line = smDrumset->drum(i).line;
|
|
drumset->drum(i).stemDirection = smDrumset->drum(i).stemDirection;
|
|
drumset->drum(i).voice = smDrumset->drum(i).voice;
|
|
drumset->drum(i).shortcut = 0;
|
|
}
|
|
QList<OVE::Track::DrumNode> nodes = track->getDrumKit();
|
|
for (int i=0; i<nodes.size(); ++i) {
|
|
int pitch = nodes[i].pitch_;
|
|
OVE::Track::DrumNode node = nodes[i];
|
|
if (pitch < DRUM_INSTRUMENTS) {
|
|
drumset->drum(pitch).line = node.line_;
|
|
drumset->drum(pitch).notehead = getHeadGroup(OVE::NoteHeadType(node.headType_));
|
|
drumset->drum(pitch).voice = node.voice_;
|
|
}
|
|
}
|
|
|
|
part->instrument()->channel(0)->bank = 128;
|
|
part->setMidiProgram(0);
|
|
part->instrument()->setDrumset(smDrumset);
|
|
part->instrument()->setDrumset(drumset);
|
|
}
|
|
}
|
|
|
|
static Ottava::Type OctaveShiftTypeToInt(OVE::OctaveShiftType type) {
|
|
Ottava::Type subtype = Ottava::Type::OTTAVA_8VA;
|
|
switch (type) {
|
|
case OVE::OctaveShiftType::OS_8: {
|
|
subtype = Ottava::Type::OTTAVA_8VA;
|
|
break;
|
|
}
|
|
case OVE::OctaveShiftType::OS_15: {
|
|
subtype = Ottava::Type::OTTAVA_15MA;
|
|
break;
|
|
}
|
|
case OVE::OctaveShiftType::OS_Minus_8: {
|
|
subtype = Ottava::Type::OTTAVA_8VB;
|
|
break;
|
|
}
|
|
case OVE::OctaveShiftType::OS_Minus_15: {
|
|
subtype = Ottava::Type::OTTAVA_15MB;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return subtype;
|
|
}
|
|
|
|
void OveToMScore::convertTrackElements(int track) {
|
|
Ottava* ottava = 0;
|
|
|
|
for(int i=0; i<ove_->getTrackBarCount(); ++i) {
|
|
OVE::MeasureData* measureData = ove_->getMeasureData(track, i);
|
|
if(measureData == 0)
|
|
continue;
|
|
|
|
// octave shift
|
|
QList<OVE::MusicData*> octaves = measureData->getMusicDatas(OVE::MusicDataType::OctaveShift_EndPoint);
|
|
for(int j=0; j<octaves.size(); ++j) {
|
|
OVE::OctaveShiftEndPoint* octave = static_cast<OVE::OctaveShiftEndPoint*>(octaves[j]);
|
|
int absTick = mtt_->getTick(i, octave->getTick());
|
|
|
|
if(octave->getOctaveShiftPosition() == OVE::OctaveShiftPosition::Start) {
|
|
if(ottava == 0) {
|
|
ottava = new Ottava(score_);
|
|
ottava->setTrack(track * VOICES);
|
|
ottava->setOttavaType(OctaveShiftTypeToInt(octave->getOctaveShiftType()));
|
|
|
|
int y_off = 0;
|
|
switch (octave->getOctaveShiftType()) {
|
|
case OVE::OctaveShiftType::OS_8:
|
|
case OVE::OctaveShiftType::OS_15: {
|
|
y_off = -3;
|
|
break;
|
|
}
|
|
case OVE::OctaveShiftType::OS_Minus_8:
|
|
case OVE::OctaveShiftType::OS_Minus_15: {
|
|
y_off = 8;
|
|
break;
|
|
}
|
|
default:{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(y_off != 0) {
|
|
ottava->setUserOff(QPointF(0, y_off * score_->spatium()));
|
|
}
|
|
|
|
ottava->setTick(absTick);
|
|
|
|
} else {
|
|
qDebug("overlapping octave-shift not supported");
|
|
delete ottava;
|
|
ottava = 0;
|
|
}
|
|
} else if (octave->getOctaveShiftPosition() == OVE::OctaveShiftPosition::Stop) {
|
|
if(ottava != 0) {
|
|
int absTick = mtt_->getTick(i, octave->getEndTick());
|
|
|
|
ottava->setTick2(absTick);
|
|
score_->addSpanner(ottava);
|
|
ottava->staff()->updateOttava();
|
|
ottava = 0;
|
|
} else {
|
|
qDebug("octave-shift stop without start");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void OveToMScore::convertLineBreak(){
|
|
for (MeasureBase* mb = score_->measures()->first(); mb; mb = mb->next()) {
|
|
if (mb->type() != Element::Type::MEASURE)
|
|
continue;
|
|
Measure* measure = static_cast<Measure*> (mb);
|
|
|
|
for (int i = 0; i < ove_->getLineCount(); ++i) {
|
|
OVE::Line* line = ove_->getLine(i);
|
|
if (measure->no() > 0) {
|
|
if ((int)line->getBeginBar() + (int)line->getBarCount()-1 == measure->no()) {
|
|
LayoutBreak* lb = new LayoutBreak(score_);
|
|
lb->setTrack(0);
|
|
lb->setLayoutBreakType(LayoutBreak::Type::LINE);
|
|
measure->add(lb);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void OveToMScore::convertSignatures(){
|
|
int i;
|
|
int j;
|
|
int k;
|
|
|
|
// Time
|
|
const QList<MeasureToTick::TimeTick> tts = mtt_->getTimeTicks() ;
|
|
for( i=0; i<(int)tts.size(); ++i ){
|
|
MeasureToTick::TimeTick tt = tts[i];
|
|
Fraction f(tt.numerator_, tt.denominator_);
|
|
|
|
TimeSigMap* sigmap = score_->sigmap();
|
|
sigmap->add(tt.tick_, f);
|
|
|
|
Measure* measure = score_->tick2measure(tt.tick_);
|
|
if(measure){
|
|
for(int staffIdx = 0; staffIdx < score_->nstaves(); ++staffIdx) {
|
|
TimeSigType subtype = TimeSigType::NORMAL;
|
|
if(tt.numerator_ == 4 && tt.denominator_ == 4 && tt.isSymbol_ ){
|
|
subtype = TimeSigType::FOUR_FOUR;
|
|
} else if(tt.numerator_ == 2 && tt.denominator_ == 2 && tt.isSymbol_ ){
|
|
subtype = TimeSigType::ALLA_BREVE;
|
|
}
|
|
|
|
TimeSig* ts = new TimeSig(score_);
|
|
ts->setTrack(staffIdx * VOICES);
|
|
ts->setSig(Fraction(tt.numerator_, tt.denominator_), subtype);
|
|
|
|
Segment* seg = measure->getSegment(ts, tt.tick_);
|
|
seg->add(ts);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Key
|
|
int staffCount = 0;
|
|
bool createKey = false ;
|
|
for(i=0; i<ove_->getPartCount(); ++i ){
|
|
int partStaffCount = ove_->getStaffCount(i) ;
|
|
|
|
for(j=0; j<partStaffCount; ++j){
|
|
for(k=0; k<ove_->getMeasureCount(); ++k){
|
|
OVE::MeasureData* measureData = ove_->getMeasureData(i, j, k) ;
|
|
|
|
if( measureData != 0 ){
|
|
OVE::Key* keyPtr = measureData->getKey() ;
|
|
|
|
if( k == 0 || keyPtr->getKey() != keyPtr->getPreviousKey() ) {
|
|
int tick = mtt_->getTick(k, 0);
|
|
int keyValue = keyPtr->getKey();
|
|
Measure* measure = score_->tick2measure(tick);
|
|
if(measure){
|
|
KeySigEvent ke;
|
|
ke.setKey(Key(keyValue));
|
|
score_->staff(staffCount+j)->setKey(tick, ke);
|
|
|
|
KeySig* keysig = new KeySig(score_);
|
|
keysig->setTrack((staffCount+j) * VOICES);
|
|
keysig->setKeySigEvent(ke);
|
|
|
|
Segment* s = measure->getSegment(keysig, tick);
|
|
s->add(keysig);
|
|
|
|
createKey = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
staffCount += partStaffCount;
|
|
}
|
|
|
|
if( !createKey ){
|
|
staffCount = 0;
|
|
for(i=0; i<ove_->getPartCount(); ++i ){
|
|
int partStaffCount = ove_->getStaffCount(i) ;
|
|
|
|
for(j=0; j<partStaffCount; ++j){
|
|
Measure* measure = score_->tick2measure(mtt_->getTick(0, 0));
|
|
if(measure){
|
|
KeySig* keysig = new KeySig(score_);
|
|
keysig->setTrack((staffCount+j) * VOICES);
|
|
keysig->setKeySigEvent(KeySigEvent());
|
|
|
|
Segment* s = measure->getSegment(keysig, 0);
|
|
s->add(keysig);
|
|
}
|
|
}
|
|
staffCount += partStaffCount;
|
|
}
|
|
}
|
|
|
|
// Clef
|
|
staffCount = 0;
|
|
for(i=0; i<ove_->getPartCount(); ++i){
|
|
int partStaffCount = ove_->getStaffCount(i) ;
|
|
for(j=0; j<partStaffCount; ++j){
|
|
// start clef
|
|
Staff* staff = score_->staff(staffCount+j);
|
|
if(staff){
|
|
OVE::Track* track = ove_->getTrack(i, j);
|
|
ClefType clefType = OveClefToClef(track->getStartClef());
|
|
Measure* measure = score_->tick2measure(0);
|
|
// staff->setClef(0, clefType);
|
|
|
|
// note: also generate symbol for tick 0
|
|
// was not necessary before 0.9.6
|
|
Clef* clef = new Clef(score_);
|
|
clef->setClefType(clefType);
|
|
clef->setTrack((staffCount+j)*VOICES);
|
|
|
|
Segment* s = measure->getSegment(clef, 0);
|
|
s->add(clef);
|
|
}
|
|
|
|
// clef in measure
|
|
for(k=0; k<ove_->getMeasureCount(); ++k){
|
|
OVE::MeasureData* measureData = ove_->getMeasureData(i, j, k);
|
|
QList<OVE::MusicData*> clefs = measureData->getMusicDatas(OVE::MusicDataType::Clef);
|
|
Measure* measure = score_->tick2measure(mtt_->getTick(k, 0));
|
|
|
|
for( int l=0; l<clefs.size(); ++l){
|
|
if(measure != 0){
|
|
OVE::Clef* clefPtr = static_cast<OVE::Clef*>(clefs[l]);
|
|
int absTick = mtt_->getTick(k, clefPtr->getTick());
|
|
ClefType clefType = OveClefToClef(clefPtr->getClefType());
|
|
|
|
Clef* clef = new Clef(score_);
|
|
clef->setClefType(clefType);
|
|
clef->setTrack((staffCount+j)*VOICES);
|
|
|
|
Segment* s = measure->getSegment(clef, absTick);
|
|
s->add(clef);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
staffCount += partStaffCount;
|
|
}
|
|
|
|
// Tempo
|
|
std::map<int, int> tempos;
|
|
for(i=0; i<ove_->getPartCount(); ++i){
|
|
int partStaffCount = ove_->getStaffCount(i);
|
|
|
|
for(j=0; j<partStaffCount; ++j){
|
|
for(k=0; k<ove_->getMeasureCount(); ++k){
|
|
OVE::Measure* measure = ove_->getMeasure(k);
|
|
OVE::MeasureData* measureData = ove_->getMeasureData(i, j, k);
|
|
QList<OVE::MusicData*> tempoPtrs = measureData->getMusicDatas(OVE::MusicDataType::Tempo);
|
|
|
|
if(k==0 || ( k>0 && qAbs(measure->getTypeTempo()-ove_->getMeasure(k-1)->getTypeTempo())>0.01 )){
|
|
int tick = mtt_->getTick(k, 0);
|
|
tempos[tick] = (int)measure->getTypeTempo();
|
|
}
|
|
|
|
for(int l=0; l<tempoPtrs.size(); ++l) {
|
|
OVE::Tempo* ptr = static_cast<OVE::Tempo*>(tempoPtrs[l]);
|
|
int tick = mtt_->getTick(measure->getBarNumber()->getIndex(), ptr->getTick());
|
|
int tempo = ptr->getQuarterTempo()>0 ? ptr->getQuarterTempo() : 1;
|
|
|
|
tempos[tick] = tempo;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
std::map<int, int>::iterator it;
|
|
int lastTempo = 0;
|
|
for(it=tempos.begin(); it!=tempos.end(); ++it) {
|
|
if( it==tempos.begin() || (*it).second != lastTempo ) {
|
|
double tpo = ((double)(*it).second) / 60.0;
|
|
score_->setTempo((*it).first, tpo);
|
|
}
|
|
|
|
lastTempo = (*it).second;
|
|
}
|
|
}
|
|
|
|
int ContainerToTick(OVE::NoteContainer* container, int quarter){
|
|
int tick = OVE::NoteTypeToTick(container->getNoteType(), quarter);
|
|
|
|
int dotLength = tick;
|
|
for( int i=0; i<container->getDot(); ++i ) {
|
|
dotLength /= 2;
|
|
}
|
|
dotLength = tick - dotLength;
|
|
|
|
if(container->getTuplet() > 0) {
|
|
tick = tick * container->getSpace() / container->getTuplet();
|
|
}
|
|
|
|
tick += dotLength;
|
|
|
|
return tick;
|
|
}
|
|
|
|
const OVE::Tuplet* getTuplet(const QList<OVE::MusicData*>& tuplets, int unit){
|
|
for(int i=0; i<tuplets.size(); ++i){
|
|
const OVE::MusicData* data = tuplets[i];
|
|
if(unit >= data->start()->getOffset() && unit <= data->stop()->getOffset()){
|
|
const OVE::Tuplet* tuplet = static_cast<OVE::Tuplet*>(tuplets[i]);
|
|
return tuplet;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
TDuration OveNoteType_To_Duration(OVE::NoteType noteType){
|
|
TDuration d;
|
|
switch(noteType){
|
|
case OVE::NoteType::Note_DoubleWhole: {
|
|
d.setType(TDuration::DurationType::V_BREVE);
|
|
break;
|
|
}
|
|
case OVE::NoteType::Note_Whole: {
|
|
d.setType(TDuration::DurationType::V_WHOLE);
|
|
break;
|
|
}
|
|
case OVE::NoteType::Note_Half: {
|
|
d.setType(TDuration::DurationType::V_HALF);
|
|
break;
|
|
}
|
|
case OVE::NoteType::Note_Quarter: {
|
|
d.setType(TDuration::DurationType::V_QUARTER);
|
|
break;
|
|
}
|
|
case OVE::NoteType::Note_Eight: {
|
|
d.setType(TDuration::DurationType::V_EIGHTH);
|
|
break;
|
|
}
|
|
case OVE::NoteType::Note_Sixteen: {
|
|
d.setType(TDuration::DurationType::V_16TH);
|
|
break;
|
|
}
|
|
case OVE::NoteType::Note_32: {
|
|
d.setType(TDuration::DurationType::V_32ND);
|
|
break;
|
|
}
|
|
case OVE::NoteType::Note_64: {
|
|
d.setType(TDuration::DurationType::V_64TH);
|
|
break;
|
|
}
|
|
case OVE::NoteType::Note_128: {
|
|
d.setType(TDuration::DurationType::V_128TH);
|
|
break;
|
|
}
|
|
case OVE::NoteType::Note_256: {
|
|
d.setType(TDuration::DurationType::V_256TH);
|
|
break;
|
|
}
|
|
default:
|
|
d.setType(TDuration::DurationType::V_QUARTER);
|
|
break;
|
|
}
|
|
|
|
return d;
|
|
}
|
|
|
|
int accidentalToAlter(OVE::AccidentalType type) {
|
|
int alter = 0;
|
|
|
|
switch( type ) {
|
|
case OVE::AccidentalType::Normal:
|
|
case OVE::AccidentalType::Natural:
|
|
case OVE::AccidentalType::Natural_Caution: {
|
|
alter = 0;
|
|
break;
|
|
}
|
|
case OVE::AccidentalType::Sharp:
|
|
case OVE::AccidentalType::Sharp_Caution: {
|
|
alter = 1;
|
|
break;
|
|
}
|
|
case OVE::AccidentalType::Flat:
|
|
case OVE::AccidentalType::Flat_Caution: {
|
|
alter = -1;
|
|
break;
|
|
}
|
|
case OVE::AccidentalType::DoubleSharp:
|
|
case OVE::AccidentalType::DoubleSharp_Caution: {
|
|
alter = 2;
|
|
break;
|
|
}
|
|
case OVE::AccidentalType::DoubleFlat:
|
|
case OVE::AccidentalType::DoubleFlat_Caution: {
|
|
alter = -2;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return alter;
|
|
}
|
|
|
|
void getMiddleToneOctave(OVE::ClefType clef, OVE::ToneType& tone, int& octave) {
|
|
tone = OVE::ToneType::B;
|
|
octave = 4;
|
|
|
|
switch ( clef ) {
|
|
case OVE::ClefType::Treble: {
|
|
tone = OVE::ToneType::B;
|
|
octave = 4;
|
|
break;
|
|
}
|
|
case OVE::ClefType::Treble8va: {
|
|
tone = OVE::ToneType::B;
|
|
octave = 5;
|
|
break;
|
|
}
|
|
case OVE::ClefType::Treble8vb: {
|
|
tone = OVE::ToneType::B;
|
|
octave = 3;
|
|
break;
|
|
}
|
|
case OVE::ClefType::Bass: {
|
|
tone = OVE::ToneType::D;
|
|
octave = 3;
|
|
break;
|
|
}
|
|
case OVE::ClefType::Bass8va: {
|
|
tone = OVE::ToneType::D;
|
|
octave = 4;
|
|
break;
|
|
}
|
|
case OVE::ClefType::Bass8vb: {
|
|
tone = OVE::ToneType::D;
|
|
octave = 2;
|
|
break;
|
|
}
|
|
case OVE::ClefType::Alto: {
|
|
tone = OVE::ToneType::C;
|
|
octave = 4;
|
|
break;
|
|
}
|
|
case OVE::ClefType::UpAlto: {
|
|
tone = OVE::ToneType::A;
|
|
octave = 3;
|
|
break;
|
|
}
|
|
case OVE::ClefType::DownDownAlto: {
|
|
tone = OVE::ToneType::G;
|
|
octave = 4;
|
|
break;
|
|
}
|
|
case OVE::ClefType::DownAlto: {
|
|
tone = OVE::ToneType::E;
|
|
octave = 4;
|
|
break;
|
|
}
|
|
case OVE::ClefType::UpUpAlto: {
|
|
tone = OVE::ToneType::F;
|
|
octave = 3;
|
|
break;
|
|
}
|
|
case OVE::ClefType::Percussion1: {
|
|
tone = OVE::ToneType::A;
|
|
octave = 3;
|
|
break;
|
|
}
|
|
case OVE::ClefType::Percussion2: {
|
|
tone = OVE::ToneType::A;
|
|
octave = 3;
|
|
break;
|
|
}
|
|
case OVE::ClefType::TAB: {
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
OVE::ClefType getClefType(OVE::MeasureData* measure, int tick) {
|
|
OVE::ClefType type = measure->getClef()->getClefType();
|
|
QList<OVE::MusicData*> clefs = measure->getMusicDatas(OVE::MusicDataType::Clef);
|
|
|
|
for(int i=0; i<clefs.size(); ++i){
|
|
if(tick < clefs[i]->getTick()){
|
|
break;
|
|
}
|
|
if(tick >= clefs[i]->getTick()){
|
|
OVE::Clef* clef = static_cast<OVE::Clef*>(clefs[i]);
|
|
type = clef->getClefType();
|
|
}
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
void OveToMScore::convertMeasures() {
|
|
for (MeasureBase* mb = score_->measures()->first(); mb; mb = mb->next()) {
|
|
if (mb->type() != Element::Type::MEASURE)
|
|
continue;
|
|
Measure* measure = static_cast<Measure*>(mb);
|
|
int tick = measure->tick();
|
|
measure->setLen(score_->sigmap()->timesig(tick).timesig());
|
|
measure->setTimesig(score_->sigmap()->timesig(tick).timesig()); //?
|
|
convertMeasure(measure);
|
|
}
|
|
|
|
// convert based on notes
|
|
for (MeasureBase* mb = score_->measures()->first(); mb; mb = mb->next()) {
|
|
if (mb->type() != Element::Type::MEASURE)
|
|
continue;
|
|
Measure* measure = static_cast<Measure*>(mb);
|
|
|
|
convertLines(measure);
|
|
}
|
|
}
|
|
|
|
void OveToMScore::convertMeasure(Measure* measure){
|
|
int staffCount = 0;
|
|
int measureCount = ove_->getMeasureCount();
|
|
|
|
for (int i=0; i < ove_->getPartCount(); ++i) {
|
|
int partStaffCount = ove_->getStaffCount(i);
|
|
|
|
for (int j=0; j < partStaffCount; ++j) {
|
|
int measureID = measure->no();
|
|
|
|
if (measureID >= 0 && measureID < measureCount) {
|
|
int trackIndex = (staffCount + j) * VOICES;
|
|
|
|
convertMeasureMisc(measure, i, j, trackIndex);
|
|
convertNotes(measure, i, j, trackIndex);
|
|
convertLyrics(measure, i, j, trackIndex);
|
|
convertHarmonys(measure, i, j, trackIndex);
|
|
convertRepeats(measure, i, j, trackIndex);
|
|
convertDynamics(measure, i, j, trackIndex);
|
|
convertExpressions(measure, i, j, trackIndex);
|
|
}
|
|
}
|
|
|
|
staffCount += partStaffCount;
|
|
}
|
|
}
|
|
|
|
void OveToMScore::convertLines(Measure* measure){
|
|
int staffCount = 0;
|
|
int measureCount = ove_->getMeasureCount();
|
|
|
|
for( int i=0; i<ove_->getPartCount(); ++i ){
|
|
int partStaffCount = ove_->getStaffCount(i);
|
|
|
|
for( int j=0; j<partStaffCount; ++j ){
|
|
int measureID = measure->no();
|
|
|
|
if (measureID >= 0 && measureID < measureCount) {
|
|
int trackIndex = (staffCount + j) * VOICES;
|
|
|
|
convertSlurs(measure, i, j, trackIndex);
|
|
convertGlissandos(measure, i, j, trackIndex);
|
|
convertWedges(measure, i, j, trackIndex);
|
|
}
|
|
}
|
|
|
|
staffCount += partStaffCount;
|
|
}
|
|
}
|
|
|
|
void OveToMScore::convertMeasureMisc(Measure* measure, int part, int staff, int track){
|
|
OVE::Measure* measurePtr = ove_->getMeasure(measure->no());
|
|
OVE::MeasureData* measureData = ove_->getMeasureData(part, staff, measure->no());
|
|
if(measurePtr == 0 || measureData == 0)
|
|
return;
|
|
|
|
// pickup
|
|
if(measurePtr->getIsPickup()){
|
|
measure->setIrregular(true);
|
|
}
|
|
|
|
// multiple measure rest
|
|
if(measurePtr->getIsMultiMeasureRest()){
|
|
measure->setBreakMultiMeasureRest(true);
|
|
}
|
|
|
|
// barline
|
|
BarLineType bartype = BarLineType::NORMAL;
|
|
|
|
switch(measurePtr->getRightBarline()) {
|
|
case OVE::BarLineType::Default:{
|
|
bartype = BarLineType::NORMAL;
|
|
break;
|
|
}
|
|
case OVE::BarLineType::Double:{
|
|
bartype = BarLineType::DOUBLE;
|
|
break;
|
|
}
|
|
case OVE::BarLineType::Final:{
|
|
bartype = BarLineType::END;
|
|
break;
|
|
}
|
|
case OVE::BarLineType::Null:{
|
|
bartype = BarLineType::NORMAL;
|
|
break;
|
|
}
|
|
case OVE::BarLineType::RepeatLeft:{
|
|
bartype = BarLineType::START_REPEAT;
|
|
measure->setRepeatFlags(Repeat::START);
|
|
break;
|
|
}
|
|
case OVE::BarLineType::RepeatRight:{
|
|
bartype = BarLineType::END_REPEAT;
|
|
measure->setRepeatFlags(Repeat::END);
|
|
break;
|
|
}
|
|
case OVE::BarLineType::Dashed:{
|
|
bartype = BarLineType::BROKEN;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if(measure->no() == ove_->getMeasureCount()-1){
|
|
bartype = BarLineType::END;
|
|
}
|
|
|
|
measure->setEndBarLineType(bartype, false);
|
|
|
|
if(measurePtr->getLeftBarline() == OVE::BarLineType::RepeatLeft){
|
|
//bartype = BarLineType::START_REPEAT;
|
|
measure->setRepeatFlags(measure->repeatFlags()|Repeat::START);
|
|
}
|
|
|
|
// rehearsal
|
|
int i;
|
|
QList<OVE::MusicData*> texts = measureData->getMusicDatas(OVE::MusicDataType::Text);
|
|
for(i=0; i<texts.size(); ++i){
|
|
OVE::Text* textPtr = static_cast<OVE::Text*>(texts[i]);
|
|
if(textPtr->getTextType() == OVE::Text::Type::Rehearsal){
|
|
Text* text = new RehearsalMark(score_);
|
|
text->setText(textPtr->getText());
|
|
text->setAbove(true);
|
|
text->setTrack(track);
|
|
|
|
Segment* s = measure->getSegment(Segment::Type::ChordRest, mtt_->getTick(measure->no(), 0));
|
|
s->add(text);
|
|
}
|
|
}
|
|
|
|
// tempo
|
|
QList<OVE::MusicData*> tempos = measureData->getMusicDatas(OVE::MusicDataType::Tempo);
|
|
for(i=0; i<tempos.size(); ++i){
|
|
OVE::Tempo* tempoPtr = static_cast<OVE::Tempo*>(tempos[i]);
|
|
TempoText* t = new TempoText(score_);
|
|
int absTick = mtt_->getTick(measure->no(), tempoPtr->getTick());
|
|
double tpo = ((double)tempoPtr->getQuarterTempo())/60.0;
|
|
|
|
score_->setTempo(absTick, tpo);
|
|
|
|
t->setTempo(tpo);
|
|
t->setText(tempoPtr->getRightText());
|
|
t->setAbove(true);
|
|
t->setTrack(track);
|
|
|
|
Segment* s = measure->getSegment(Segment::Type::ChordRest, absTick);
|
|
s->add(t);
|
|
}
|
|
}
|
|
|
|
// beam in grace
|
|
int getGraceLevel(const QList<OVE::NoteContainer*>& containers, int tick, int unit){
|
|
int graceCount = 0;
|
|
int level = 0; // normal chord rest
|
|
|
|
for(int i=0; i<containers.size(); ++i){
|
|
OVE::NoteContainer* container = containers[i];
|
|
if(container->getTick() > tick)
|
|
break;
|
|
|
|
if(container->getIsGrace() && container->getTick() == tick){
|
|
++graceCount;
|
|
|
|
if(unit <= container->start()->getOffset()){
|
|
++level;
|
|
}
|
|
}
|
|
}
|
|
|
|
return level;
|
|
}
|
|
|
|
bool isRestDefaultLine(OVE::Note* rest, OVE::NoteType noteType) {
|
|
bool isDefault = true;
|
|
switch (noteType) {
|
|
case OVE::NoteType::Note_DoubleWhole:
|
|
case OVE::NoteType::Note_Whole:
|
|
case OVE::NoteType::Note_Half:
|
|
case OVE::NoteType::Note_Quarter: {
|
|
if(rest->getLine() != 0)
|
|
isDefault = false;
|
|
break;
|
|
}
|
|
case OVE::NoteType::Note_Eight: {
|
|
if(rest->getLine() != 1)
|
|
isDefault = false;
|
|
break;
|
|
}
|
|
case OVE::NoteType::Note_Sixteen:
|
|
case OVE::NoteType::Note_32: {
|
|
if(rest->getLine() != -1)
|
|
isDefault = false;
|
|
break;
|
|
}
|
|
case OVE::NoteType::Note_64: {
|
|
if(rest->getLine() != -3)
|
|
isDefault = false;
|
|
break;
|
|
}
|
|
case OVE::NoteType::Note_128: {
|
|
if(rest->getLine() != -4)
|
|
isDefault = false;
|
|
break;
|
|
}
|
|
default: {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return isDefault;
|
|
}
|
|
|
|
Drumset* getDrumset(Score* score, int part) {
|
|
Part* p = score->parts().at(part);
|
|
return const_cast<Drumset*>(p->instrument()->drumset()); //TODO: remove cast
|
|
}
|
|
|
|
void OveToMScore::convertNotes(Measure* measure, int part, int staff, int track){
|
|
int j;
|
|
OVE::MeasureData* measureData = ove_->getMeasureData(part, staff, measure->no());
|
|
QList<OVE::NoteContainer*> containers = measureData->getNoteContainers();
|
|
QList<OVE::MusicData*> tuplets = measureData->getCrossMeasureElements(OVE::MusicDataType::Tuplet, OVE::MeasureData::PairType::Start);
|
|
QList<OVE::MusicData*> beams = measureData->getCrossMeasureElements(OVE::MusicDataType::Beam, OVE::MeasureData::PairType::Start);
|
|
Tuplet* tuplet = 0;
|
|
ChordRest* cr = 0;
|
|
int partStaffCount = ove_->getStaffCount(part);
|
|
|
|
if(containers.empty()){
|
|
int absTick = mtt_->getTick(measure->no(), 0);
|
|
|
|
cr = new Rest(score_);
|
|
cr->setDuration(measure->len());
|
|
cr->setDurationType(TDuration::DurationType::V_MEASURE);
|
|
cr->setTrack(track);
|
|
Segment* s = measure->getSegment(cr, absTick);
|
|
s->add(cr);
|
|
}
|
|
QList<Ms::Chord*> graceNotes;
|
|
for (int i = 0; i < containers.size(); ++i) {
|
|
OVE::NoteContainer* container = containers[i];
|
|
int tick = mtt_->getTick(measure->no(), container->getTick());
|
|
int noteTrack = track + container->getVoice();
|
|
|
|
if (container->getIsRest()) {
|
|
TDuration duration = OveNoteType_To_Duration(container->getNoteType());
|
|
duration.setDots(container->getDot());
|
|
|
|
cr = new Rest(score_);
|
|
cr->setDuration(duration.fraction());
|
|
cr->setDurationType(duration);
|
|
cr->setTrack(noteTrack);
|
|
cr->setVisible(container->getShow());
|
|
|
|
QList<OVE::Note*> notes = container->getNotesRests();
|
|
for (j = 0; j < notes.size(); ++j) {
|
|
OVE::Note* notePtr = notes[j];
|
|
if(!isRestDefaultLine(notePtr, container->getNoteType()) && notePtr->getLine() != 0) {
|
|
double yOffset = -((double)notePtr->getLine()/2.0 * score_->spatium());
|
|
cr->setUserYoffset(yOffset);
|
|
}
|
|
}
|
|
|
|
Segment* s = measure->getSegment(cr, tick);
|
|
s->add(cr);
|
|
} else {
|
|
QList<OVE::Note*> notes = container->getNotesRests();
|
|
|
|
cr = measure->findChord(tick, noteTrack);
|
|
if (cr == 0) {
|
|
cr = new Ms::Chord(score_);
|
|
cr->setTrack(noteTrack);
|
|
|
|
// grace
|
|
if (container->getIsGrace()) {
|
|
TDuration duration = OveNoteType_To_Duration(container->getGraceNoteType());
|
|
duration.setDots(container->getDot());
|
|
((Ms::Chord*) cr)->setNoteType(NoteType::APPOGGIATURA);
|
|
|
|
if (duration.type() == TDuration::DurationType::V_QUARTER) {
|
|
((Ms::Chord*) cr)->setNoteType(NoteType::GRACE4);
|
|
cr->setDurationType(TDuration::DurationType::V_QUARTER);
|
|
} else if (duration.type() == TDuration::DurationType::V_16TH) {
|
|
((Ms::Chord*) cr)->setNoteType(NoteType::GRACE16);
|
|
cr->setDurationType(TDuration::DurationType::V_16TH);
|
|
} else if (duration.type() == TDuration::DurationType::V_32ND) {
|
|
((Ms::Chord*) cr)->setNoteType(NoteType::GRACE32);
|
|
cr->setDurationType(TDuration::DurationType::V_32ND);
|
|
} else {
|
|
cr->setDurationType(TDuration::DurationType::V_EIGHTH);
|
|
}
|
|
|
|
// st = Segment::Type::Grace;
|
|
} else {
|
|
TDuration duration = OveNoteType_To_Duration(container->getNoteType());
|
|
duration.setDots(container->getDot());
|
|
|
|
if (duration.type() == TDuration::DurationType::V_INVALID)
|
|
duration.setType(TDuration::DurationType::V_QUARTER);
|
|
cr->setDurationType(duration);
|
|
// append grace notes before
|
|
int ii = -1;
|
|
for (ii = graceNotes.size() - 1; ii >= 0; ii--) {
|
|
Ms::Chord* gc = graceNotes[ii];
|
|
if(gc->voice() == cr->voice()){
|
|
cr->add(gc);
|
|
}
|
|
}
|
|
graceNotes.clear();
|
|
}
|
|
cr->setDuration(cr->durationType().fraction());
|
|
|
|
if(!container->getIsGrace()) {
|
|
Segment* s = measure->getSegment(cr, tick);
|
|
s->add(cr);
|
|
}
|
|
else {
|
|
graceNotes.append(static_cast<Ms::Chord*>(cr));
|
|
}
|
|
}
|
|
|
|
for (j = 0; j < notes.size(); ++j) {
|
|
OVE::Note* oveNote = notes[j];
|
|
Note* note = new Note(score_);
|
|
int pitch = oveNote->getNote();
|
|
|
|
//note->setTrack(noteTrack);
|
|
note->setVeloType(Note::ValueType::USER_VAL);
|
|
note->setVeloOffset(oveNote->getOnVelocity());
|
|
//note->setUserAccidental(OveAccidental_to_Accidental(notePtr->getAccidental()));
|
|
note->setPitch(pitch);
|
|
|
|
// tpc
|
|
bool setDirection = false;
|
|
OVE::ClefType clefType = getClefType(measureData, container->getTick());
|
|
if(clefType == OVE::ClefType::Percussion1 || clefType == OVE::ClefType::Percussion2) {
|
|
Drumset* drumset = getDrumset(score_, part);
|
|
if(drumset != 0) {
|
|
if (!drumset->isValid(pitch) || pitch == -1) {
|
|
qDebug("unmapped drum note 0x%02x %d", note->pitch(), note->pitch());
|
|
} else {
|
|
note->setHeadGroup(drumset->noteHead(pitch));
|
|
int line = drumset->line(pitch);
|
|
note->setLine(line);
|
|
note->setTpcFromPitch();
|
|
((Ms::Chord*) cr)->setStemDirection(drumset->stemDirection(pitch));
|
|
setDirection = true;
|
|
}
|
|
}
|
|
} else {
|
|
const int OCTAVE = 7;
|
|
OVE::ToneType clefMiddleTone;
|
|
int clefMiddleOctave;
|
|
getMiddleToneOctave(clefType, clefMiddleTone, clefMiddleOctave);
|
|
int absLine = (int) clefMiddleTone + clefMiddleOctave * OCTAVE + oveNote->getLine();
|
|
int tone = absLine % OCTAVE;
|
|
int alter = accidentalToAlter(oveNote->getAccidental());
|
|
NoteVal nv(pitch);
|
|
note->setTrack(cr->track());
|
|
note->setNval(nv, tick);
|
|
// note->setTpcFromPitch();
|
|
note->setTpc(step2tpc(tone, AccidentalVal(alter)));
|
|
|
|
note->setHeadGroup(getHeadGroup(oveNote->getHeadType()));
|
|
}
|
|
|
|
// tie
|
|
if ((int(oveNote->getTiePos()) & int(OVE::TiePos::LeftEnd)) == int(OVE::TiePos::LeftEnd)) {
|
|
Tie* tie = new Tie(score_);
|
|
note->setTieFor(tie);
|
|
tie->setStartNote(note);
|
|
tie->setTrack(noteTrack);
|
|
}
|
|
|
|
// pitch must be set before adding note to chord as note
|
|
// is inserted into pitch sorted list (ws)
|
|
cr->add(note);
|
|
|
|
cr->setVisible(oveNote->getShow());
|
|
((Ms::Chord*) cr)->setNoStem(int(container->getNoteType()) <= int(OVE::NoteType::Note_Whole));
|
|
if(!setDirection)
|
|
((Ms::Chord*) cr)->setStemDirection(container->getStemUp() ? MScore::Direction::UP : MScore::Direction::DOWN);
|
|
|
|
// cross staff
|
|
int staffMove = 0;
|
|
if(partStaffCount == 2) { /*treble-bass*/
|
|
staffMove = oveNote->getOffsetStaff();
|
|
}
|
|
cr->setStaffMove(staffMove);
|
|
}
|
|
}
|
|
|
|
// beam
|
|
Beam::Mode bm = container->getIsRest() ? Beam::Mode::NONE : Beam::Mode::AUTO;
|
|
if(container->getInBeam()){
|
|
OVE::MeasurePos pos = container->start()->shiftMeasure(0);
|
|
OVE::MusicData* data = getCrossMeasureElementByPos(part, staff, pos, container->getVoice(), OVE::MusicDataType::Beam);
|
|
|
|
if(data != 0){
|
|
OVE::Beam* beam = static_cast<OVE::Beam*>(data);
|
|
OVE::MeasurePos startPos = beam->start()->shiftMeasure(0);
|
|
OVE::MeasurePos stopPos = beam->stop()->shiftMeasure(beam->start()->getMeasure());
|
|
|
|
if(startPos == pos){
|
|
bm = Beam::Mode::BEGIN;
|
|
}
|
|
else if(stopPos == pos){
|
|
bm = Beam::Mode::END;
|
|
}
|
|
else{
|
|
bm = Beam::Mode::MID;
|
|
}
|
|
}
|
|
}
|
|
cr->setBeamMode(bm);
|
|
|
|
// tuplet
|
|
if (container->getTuplet() > 0) {
|
|
if (tuplet == 0) {
|
|
bool create = true;
|
|
|
|
// check tuplet start
|
|
if(container->getNoteType() < OVE::NoteType::Note_Eight) {
|
|
const OVE::Tuplet* oveTuplet = getTuplet(tuplets, container->start()->getOffset());
|
|
if(oveTuplet == 0) {
|
|
create = false;
|
|
}
|
|
}
|
|
|
|
if(create) {
|
|
tuplet = new Tuplet(score_);
|
|
tuplet->setTrack(noteTrack);
|
|
tuplet->setRatio(Fraction(container->getTuplet(), container->getSpace()));
|
|
tuplet->setTick(tick);
|
|
measure->add(tuplet);
|
|
}
|
|
}
|
|
|
|
if (tuplet != 0) {
|
|
cr->setTuplet(tuplet);
|
|
tuplet->add(cr);
|
|
}
|
|
|
|
if (tuplet != 0) {
|
|
// check tuplet end
|
|
const OVE::Tuplet* oveTuplet = getTuplet(tuplets, container->start()->getOffset());
|
|
if (oveTuplet != 0) {
|
|
//set direction
|
|
tuplet->setDirection(oveTuplet->getLeftShoulder()->getYOffset() < 0 ? MScore::Direction::UP : MScore::Direction::DOWN);
|
|
|
|
if(container->start()->getOffset() == oveTuplet->stop()->getOffset()){
|
|
tuplet = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// articulation
|
|
QList<OVE::Articulation*> articulations = container->getArticulations();
|
|
for (j = 0; j < articulations.size(); ++j) {
|
|
convertArticulation(measure, cr, noteTrack, tick, articulations[j]);
|
|
}
|
|
}
|
|
}
|
|
|
|
void OveToMScore::convertArticulation(
|
|
Measure* measure, ChordRest* cr,
|
|
int track, int absTick, OVE::Articulation* art){
|
|
|
|
switch ( art->getArtType() ) {
|
|
case OVE::ArticulationType::Major_Trill :
|
|
case OVE::ArticulationType::Minor_Trill :{
|
|
Articulation* a = new Articulation(score_);
|
|
a->setArticulationType(ArticulationType::Trill);
|
|
cr->add(a);
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::Trill_Section :{
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::Inverted_Short_Mordent :
|
|
case OVE::ArticulationType::Inverted_Long_Mordent :{
|
|
Articulation* a = new Articulation(score_);
|
|
a->setArticulationType(ArticulationType::Prall);
|
|
cr->add(a);
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::Short_Mordent :{
|
|
Articulation* a = new Articulation(score_);
|
|
a->setArticulationType(ArticulationType::Mordent);
|
|
cr->add(a);
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::Turn :{
|
|
Articulation* a = new Articulation(score_);
|
|
a->setArticulationType(ArticulationType::Turn);
|
|
cr->add(a);
|
|
break;
|
|
}
|
|
// case OVE::ArticulationType::Flat_Accidental_For_Trill :
|
|
// case OVE::ArticulationType::Sharp_Accidental_For_Trill :
|
|
// case OVE::ArticulationType::Natural_Accidental_For_Trill :
|
|
case OVE::ArticulationType::Tremolo_Eighth :{
|
|
Tremolo* t = new Tremolo(score_);
|
|
t->setTremoloType(TremoloType::R8);
|
|
cr->add(t);
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::Tremolo_Sixteenth :{
|
|
Tremolo* t = new Tremolo(score_);
|
|
t->setTremoloType(TremoloType::R16);
|
|
cr->add(t);
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::Tremolo_Thirty_Second :{
|
|
Tremolo* t = new Tremolo(score_);
|
|
t->setTremoloType(TremoloType::R32);
|
|
cr->add(t);
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::Tremolo_Sixty_Fourth :{
|
|
Tremolo* t = new Tremolo(score_);
|
|
t->setTremoloType(TremoloType::R64);
|
|
cr->add(t);
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::Marcato :{
|
|
Articulation* a = new Articulation(score_);
|
|
a->setArticulationType(ArticulationType::Sforzatoaccent);
|
|
cr->add(a);
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::Marcato_Dot :{
|
|
Articulation* a = new Articulation(score_);
|
|
a->setArticulationType(ArticulationType::Sforzatoaccent);
|
|
cr->add(a);
|
|
|
|
a = new Articulation(score_);
|
|
a->setArticulationType(ArticulationType::Staccato);
|
|
cr->add(a);
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::Heavy_Attack :{
|
|
Articulation* a = new Articulation(score_);
|
|
a->setArticulationType(ArticulationType::Sforzatoaccent);
|
|
cr->add(a);
|
|
|
|
a = new Articulation(score_);
|
|
a->setArticulationType(ArticulationType::Tenuto);
|
|
cr->add(a);
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::SForzando :{
|
|
Articulation* a = new Articulation(score_);
|
|
a->setUp(true);
|
|
a->setArticulationType(ArticulationType::Marcato);
|
|
cr->add(a);
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::SForzando_Inverted :{
|
|
Articulation* a = new Articulation(score_);
|
|
a->setUp(false);
|
|
a->setArticulationType(ArticulationType::Marcato);
|
|
cr->add(a);
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::SForzando_Dot :{
|
|
Articulation* a = new Articulation(score_);
|
|
a->setUp(true);
|
|
a->setArticulationType(ArticulationType::Marcato);
|
|
cr->add(a);
|
|
|
|
a = new Articulation(score_);
|
|
a->setArticulationType(ArticulationType::Staccato);
|
|
cr->add(a);
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::SForzando_Dot_Inverted :{
|
|
Articulation* a = new Articulation(score_);
|
|
a->setUp(false);
|
|
a->setArticulationType(ArticulationType::Marcato);
|
|
cr->add(a);
|
|
|
|
a = new Articulation(score_);
|
|
a->setArticulationType(ArticulationType::Staccato);
|
|
cr->add(a);
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::Heavier_Attack :{
|
|
Articulation* a = new Articulation(score_);
|
|
a->setUp(true);
|
|
a->setArticulationType(ArticulationType::Marcato);
|
|
cr->add(a);
|
|
|
|
a = new Articulation(score_);
|
|
a->setArticulationType(ArticulationType::Tenuto);
|
|
cr->add(a);
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::Staccatissimo :{
|
|
Articulation* a = new Articulation(score_);
|
|
a->setUp(true);
|
|
a->setArticulationType(ArticulationType::Staccatissimo);
|
|
cr->add(a);
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::Staccato :{
|
|
Articulation* a = new Articulation(score_);
|
|
a->setArticulationType(ArticulationType::Staccato);
|
|
cr->add(a);
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::Tenuto :{
|
|
Articulation* a = new Articulation(score_);
|
|
a->setArticulationType(ArticulationType::Tenuto);
|
|
cr->add(a);
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::Pause :{
|
|
Breath* b = new Breath(score_);
|
|
b->setTrack(track);
|
|
Segment* seg = measure->getSegment(Segment::Type::Breath, absTick + cr ? cr->actualTicks() : 0);
|
|
seg->add(b);
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::Grand_Pause :{
|
|
// TODO?
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::Up_Bow :{
|
|
Articulation* a = new Articulation(score_);
|
|
a->setArticulationType(ArticulationType::Upbow);
|
|
cr->add(a);
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::Down_Bow :{
|
|
Articulation* a = new Articulation(score_);
|
|
a->setArticulationType(ArticulationType::Downbow);
|
|
cr->add(a);
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::Up_Bow_Inverted :{
|
|
Articulation* a = new Articulation(score_);
|
|
a->setArticulationType(ArticulationType::Upbow);
|
|
a->setUserYoffset(5.3);
|
|
cr->add(a);
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::Down_Bow_Inverted :{
|
|
Articulation* a = new Articulation(score_);
|
|
a->setArticulationType(ArticulationType::Downbow);
|
|
a->setUserYoffset(5.3);
|
|
cr->add(a);
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::Natural_Harmonic :{
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::Artificial_Harmonic :{
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::Finger_1 :
|
|
case OVE::ArticulationType::Finger_2 :
|
|
case OVE::ArticulationType::Finger_3 :
|
|
case OVE::ArticulationType::Finger_4 :
|
|
case OVE::ArticulationType::Finger_5 :{
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::Plus_Sign :{
|
|
Articulation* a = new Articulation(score_);
|
|
a->setArticulationType(ArticulationType::Plusstop);
|
|
cr->add(a);
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::Arpeggio :{
|
|
// there can be only one
|
|
if (!(static_cast<Ms::Chord*>(cr))->arpeggio()) {
|
|
Arpeggio* a = new Arpeggio(score_);
|
|
a->setArpeggioType(ArpeggioType::NORMAL);
|
|
/* if (art->getPlacementAbove()){
|
|
a->setSubtype(ArpeggioType::UP);
|
|
}else {
|
|
a->setSubtype(ARpeggioType::DOWN);
|
|
}*/
|
|
cr->add(a);
|
|
}
|
|
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::Fermata :{
|
|
Articulation* a = new Articulation(score_);
|
|
a->setUp(true);
|
|
a->setArticulationType(ArticulationType::Fermata);
|
|
cr->add(a);
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::Fermata_Inverted :{
|
|
Articulation* a = new Articulation(score_);
|
|
a->setUp(false);
|
|
a->setArticulationType(ArticulationType::Fermata);
|
|
cr->add(a);
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::Pedal_Down :{
|
|
if (pedal_) {
|
|
delete pedal_;
|
|
pedal_ = 0;
|
|
}
|
|
else {
|
|
pedal_ = new Pedal(score_);
|
|
pedal_->setTrack(track);
|
|
Segment* seg = measure->getSegment(Segment::Type::ChordRest, absTick);
|
|
pedal_->setTick(seg->tick());
|
|
score_->addSpanner(pedal_);
|
|
}
|
|
break;
|
|
}
|
|
case OVE::ArticulationType::Pedal_Up :{
|
|
if(pedal_){
|
|
Segment* seg = measure->getSegment(Segment::Type::ChordRest, absTick);
|
|
pedal_->setTick2(seg->tick());
|
|
pedal_ = 0;
|
|
}
|
|
break;
|
|
}
|
|
// case OVE::ArticulationType::Toe_Pedal :
|
|
// case OVE::ArticulationType::Heel_Pedal :
|
|
// case OVE::ArticulationType::Toe_To_Heel_Pedal :
|
|
// case OVE::ArticulationType::Heel_To_Toe_Pedal :
|
|
// case OVE::ArticulationType::Open_String :
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void OveToMScore::convertLyrics(Measure* measure, int part, int staff, int track){
|
|
OVE::MeasureData* measureData = ove_->getMeasureData(part, staff, measure->no());
|
|
if(measureData == 0)
|
|
return;
|
|
|
|
QList<OVE::MusicData*> lyrics = measureData->getMusicDatas(OVE::MusicDataType::Lyric);
|
|
|
|
for(int i=0; i<lyrics.size(); ++i){
|
|
OVE::Lyric* oveLyric = static_cast<OVE::Lyric*>(lyrics[i]);
|
|
int tick = mtt_->getTick(measure->no(), oveLyric->getTick());
|
|
|
|
Lyrics* lyric = new Lyrics(score_);
|
|
lyric->setNo(oveLyric->getVerse());
|
|
lyric->setText(oveLyric->getLyric());
|
|
lyric->setTrack(track);
|
|
Segment* segment = measure->getSegment(Segment::Type::ChordRest, tick);
|
|
if (segment->element(track))
|
|
static_cast<ChordRest*>(segment->element(track))->add(lyric);
|
|
}
|
|
}
|
|
|
|
QString OveHarmony_To_String(OVE::HarmonyType type){
|
|
static std::map<unsigned int, QString> harmony_map;
|
|
|
|
harmony_map[int(OVE::HarmonyType::H_maj)] = "major";
|
|
harmony_map[int(OVE::HarmonyType::H_min)] = "minor";
|
|
harmony_map[int(OVE::HarmonyType::H_aug)] = "augmented";
|
|
harmony_map[int(OVE::HarmonyType::H_dim)] = "diminished";
|
|
harmony_map[int(OVE::HarmonyType::H_dim7)] = "diminished-seventh";
|
|
harmony_map[int(OVE::HarmonyType::H_sus2)] = "suspended-second";
|
|
harmony_map[int(OVE::HarmonyType::H_sus4)] = "suspended-fourth";
|
|
harmony_map[int(OVE::HarmonyType::H_sus24)] = "suspended-second";
|
|
harmony_map[int(OVE::HarmonyType::H_add2)] = "major";
|
|
harmony_map[int(OVE::HarmonyType::H_add9)] = "dominant-ninth";
|
|
//harmony_map[int(OVE::HarmonyType::H_omit3)] = "";
|
|
//harmony_map[int(OVE::HarmonyType::H_omit5)] = "";
|
|
harmony_map[int(OVE::HarmonyType::H_2)] = "2";
|
|
harmony_map[int(OVE::HarmonyType::H_5)] = "power";
|
|
harmony_map[int(OVE::HarmonyType::H_6)] = "major-sixth";
|
|
harmony_map[int(OVE::HarmonyType::H_69)] = "major-sixth";
|
|
harmony_map[int(OVE::HarmonyType::H_7)] = "dominant";
|
|
harmony_map[int(OVE::HarmonyType::H_7b5)] = "dominant";
|
|
harmony_map[int(OVE::HarmonyType::H_7b9)] = "dominant";
|
|
harmony_map[int(OVE::HarmonyType::H_7s9)] = "dominant";
|
|
harmony_map[int(OVE::HarmonyType::H_7s11)] = "dominant";
|
|
harmony_map[int(OVE::HarmonyType::H_7b5s9)] = "dominant";
|
|
harmony_map[int(OVE::HarmonyType::H_7b5b9)] = "dominant";
|
|
harmony_map[int(OVE::HarmonyType::H_7b9s9)] = "dominant";
|
|
harmony_map[int(OVE::HarmonyType::H_7b9s11)] = "dominant";
|
|
harmony_map[int(OVE::HarmonyType::H_7sus4)] = "suspended-fourth";
|
|
harmony_map[int(OVE::HarmonyType::H_9)] = "dominant-ninth";
|
|
harmony_map[int(OVE::HarmonyType::H_9b5)] = "dominant-ninth";
|
|
harmony_map[int(OVE::HarmonyType::H_9s11)] = "dominant-ninth";
|
|
harmony_map[int(OVE::HarmonyType::H_9sus4)] = "dominant-ninth";
|
|
harmony_map[int(OVE::HarmonyType::H_11)] = "dominant-11th";
|
|
harmony_map[int(OVE::HarmonyType::H_13)] = "dominant-13th";
|
|
harmony_map[int(OVE::HarmonyType::H_13b5)] = "dominant-13th";
|
|
harmony_map[int(OVE::HarmonyType::H_13b9)] = "dominant-13th";
|
|
harmony_map[int(OVE::HarmonyType::H_13s9)] = "dominant-13th";
|
|
harmony_map[int(OVE::HarmonyType::H_13s11)] = "dominant-13th";
|
|
harmony_map[int(OVE::HarmonyType::H_13sus4)] = "dominant-13th";
|
|
harmony_map[int(OVE::HarmonyType::H_min_add2)] = "minor";
|
|
harmony_map[int(OVE::HarmonyType::H_min_add9)] = "minor";
|
|
harmony_map[int(OVE::HarmonyType::H_min_maj7)] = "minor-major";
|
|
harmony_map[int(OVE::HarmonyType::H_min6)] = "minor-sixth";
|
|
harmony_map[int(OVE::HarmonyType::H_min6_add9)] = "minor-sixth";
|
|
harmony_map[int(OVE::HarmonyType::H_min7)] = "minor-seventh";
|
|
harmony_map[int(OVE::HarmonyType::H_min7b5)] = "half-diminished";
|
|
harmony_map[int(OVE::HarmonyType::H_min7_add4)] = "minor-seventh";
|
|
harmony_map[int(OVE::HarmonyType::H_min7_add11)] = "minor-seventh";
|
|
harmony_map[int(OVE::HarmonyType::H_min9)] = "minor-ninth";
|
|
harmony_map[int(OVE::HarmonyType::H_min9_b5)] = "minor-ninth";
|
|
harmony_map[int(OVE::HarmonyType::H_min9_maj7)] = "major-minor";
|
|
harmony_map[int(OVE::HarmonyType::H_min11)] = "minor-11th";
|
|
harmony_map[int(OVE::HarmonyType::H_min13)] = "minor-13th";
|
|
harmony_map[int(OVE::HarmonyType::H_maj7)] = "major-seventh";
|
|
harmony_map[int(OVE::HarmonyType::H_maj7_b5)] = "major-seventh";
|
|
harmony_map[int(OVE::HarmonyType::H_maj7_s5)] = "major-seventh";
|
|
harmony_map[int(OVE::HarmonyType::H_maj7_69)] = "major-seventh";
|
|
harmony_map[int(OVE::HarmonyType::H_maj7_add9)] = "major-seventh";
|
|
harmony_map[int(OVE::HarmonyType::H_maj7_s11)] = "major-seventh";
|
|
harmony_map[int(OVE::HarmonyType::H_maj9)] = "major-ninth";
|
|
harmony_map[int(OVE::HarmonyType::H_maj9_sus4)] = "major-ninth";
|
|
harmony_map[int(OVE::HarmonyType::H_maj9_b5)] = "major-ninth";
|
|
harmony_map[int(OVE::HarmonyType::H_maj9_s5)] = "major-ninth";
|
|
harmony_map[int(OVE::HarmonyType::H_maj9_s11)] = "major-ninth";
|
|
harmony_map[int(OVE::HarmonyType::H_maj13)] = "major-13th";
|
|
harmony_map[int(OVE::HarmonyType::H_maj13_b5)] = "major-13th";
|
|
harmony_map[int(OVE::HarmonyType::H_maj13_b9)] = "major-13th";
|
|
harmony_map[int(OVE::HarmonyType::H_maj13_b9b5)] = "major-13th";
|
|
harmony_map[int(OVE::HarmonyType::H_maj13_s11)] = "major-13th";
|
|
harmony_map[int(OVE::HarmonyType::H_aug7)] = "augmented-seventh";
|
|
harmony_map[int(OVE::HarmonyType::H_aug7_b9)] = "augmented-seventh";
|
|
harmony_map[int(OVE::HarmonyType::H_aug7_s9)] = "augmented-seventh";
|
|
|
|
return harmony_map[int(type)];
|
|
}
|
|
|
|
void OveToMScore::convertHarmonys(Measure* measure, int part, int staff, int track){
|
|
OVE::MeasureData* measureData = ove_->getMeasureData(part, staff, measure->no());
|
|
if(measureData == 0)
|
|
return;
|
|
|
|
QList<OVE::MusicData*> harmonys = measureData->getMusicDatas(OVE::MusicDataType::Harmony);
|
|
|
|
for(int i=0; i<harmonys.size(); ++i){
|
|
OVE::Harmony* harmonyPtr = static_cast<OVE::Harmony*>(harmonys[i]);
|
|
int absTick = mtt_->getTick(measure->no(), harmonyPtr->getTick());
|
|
|
|
Harmony* harmony = new Harmony(score_);
|
|
|
|
// TODO - does this need to be key-aware?
|
|
harmony->setTrack(track);
|
|
harmony->setRootTpc(pitch2tpc(harmonyPtr->getRoot(), Key::C, Prefer::NEAREST));
|
|
if(harmonyPtr->getBass() != OVE::INVALID_NOTE && harmonyPtr->getBass() != harmonyPtr->getRoot()){
|
|
harmony->setBaseTpc(pitch2tpc(harmonyPtr->getBass(), Key::C, Prefer::NEAREST));
|
|
}
|
|
const ChordDescription* d = harmony->fromXml(OveHarmony_To_String(harmonyPtr->getHarmonyType()));
|
|
if(d != 0){
|
|
harmony->setId(d->id);
|
|
harmony->render();
|
|
}
|
|
|
|
Segment* s = measure->getSegment(Segment::Type::ChordRest, absTick);
|
|
s->add(harmony);
|
|
}
|
|
}
|
|
|
|
/*OVE::MusicData* OveToMScore::getMusicDataByUnit(int part, int staff, int measure, int unit, OVE::MusicDataType type){
|
|
OVE::MeasureData* measureData = ove_->getMeasureData(part, staff, measure);
|
|
if(measureData != 0) {
|
|
const QList<OVE::MusicData*>& datas = measureData->getMusicDatas(type);
|
|
for(unsigned int i=0; i<datas.size(); ++i){
|
|
if(datas[i]->getTick() == unit){//different measurement
|
|
return datas[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}*/
|
|
|
|
OVE::MusicData* OveToMScore::getCrossMeasureElementByPos(int part, int staff, const OVE::MeasurePos& pos, int voice, OVE::MusicDataType type){
|
|
OVE::MeasureData* measureData = ove_->getMeasureData(part, staff, pos.getMeasure());
|
|
if(measureData != 0) {
|
|
const QList<OVE::MusicData*>& datas = measureData->getCrossMeasureElements(type, OVE::MeasureData::PairType::All);
|
|
for(int i=0; i<datas.size(); ++i){
|
|
OVE::MeasurePos dataStart = datas[i]->start()->shiftMeasure(0);
|
|
OVE::MeasurePos dataStop = datas[i]->stop()->shiftMeasure(datas[i]->start()->getMeasure());
|
|
|
|
if(dataStart <= pos && dataStop >= pos && (int)datas[i]->getVoice() == voice){
|
|
return datas[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
OVE::NoteContainer* OveToMScore::getContainerByPos(int part, int staff, const OVE::MeasurePos& pos){
|
|
OVE::MeasureData* measureData = ove_->getMeasureData(part, staff, pos.getMeasure());
|
|
if(measureData != 0) {
|
|
const QList<OVE::NoteContainer*>& containers = measureData->getNoteContainers();
|
|
for(int i=0; i<containers.size(); ++i){
|
|
if(pos == containers[i]->start()->shiftMeasure(0)){
|
|
return containers[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void OveToMScore::convertRepeats(Measure* measure, int part, int staff, int track){
|
|
OVE::MeasureData* measureData = ove_->getMeasureData(part, staff, measure->no());
|
|
if(measureData == 0)
|
|
return;
|
|
|
|
int i;
|
|
QList<OVE::MusicData*> repeats = measureData->getMusicDatas(OVE::MusicDataType::Repeat);
|
|
|
|
for(i=0; i<repeats.size(); ++i){
|
|
OVE::RepeatSymbol* repeatPtr = static_cast<OVE::RepeatSymbol*>(repeats[i]);
|
|
OVE::RepeatType type = repeatPtr->getRepeatType();
|
|
Element* e = 0;
|
|
|
|
switch(type) {
|
|
case OVE::RepeatType::Segno:{
|
|
Marker* marker = new Marker(score_);
|
|
marker->setMarkerType(Marker::Type::SEGNO);
|
|
e = marker;
|
|
break;
|
|
}
|
|
case OVE::RepeatType::Coda:{
|
|
Marker* marker = new Marker(score_);
|
|
marker->setMarkerType(Marker::Type::CODA);
|
|
e = marker;
|
|
break;
|
|
}
|
|
case OVE::RepeatType::DSAlCoda:{
|
|
Jump* jp = new Jump(score_);
|
|
jp->setJumpType(Jump::Type::DS_AL_CODA);
|
|
e = jp;
|
|
break;
|
|
}
|
|
case OVE::RepeatType::DSAlFine:{
|
|
Jump* jp = new Jump(score_);
|
|
jp->setJumpType(Jump::Type::DS_AL_FINE);
|
|
e = jp;
|
|
break;
|
|
}
|
|
case OVE::RepeatType::DCAlCoda:{
|
|
Jump* jp = new Jump(score_);
|
|
jp->setJumpType(Jump::Type::DC_AL_CODA);
|
|
e = jp;
|
|
break;
|
|
}
|
|
case OVE::RepeatType::DCAlFine:{
|
|
Jump* jp = new Jump(score_);
|
|
jp->setJumpType(Jump::Type::DC_AL_FINE);
|
|
e = jp;
|
|
break;
|
|
}
|
|
case OVE::RepeatType::ToCoda:{
|
|
Marker* m = new Marker(score_);
|
|
m->setMarkerType(Marker::Type::TOCODA);
|
|
e = m;
|
|
break;
|
|
}
|
|
case OVE::RepeatType::Fine:{
|
|
Marker* m = new Marker(score_);
|
|
m->setMarkerType(Marker::Type::FINE);
|
|
e = m;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if(e != 0){
|
|
e->setTrack(track);
|
|
measure->add(e);
|
|
}
|
|
}
|
|
|
|
QList<OVE::MusicData*> endings = measureData->getCrossMeasureElements(
|
|
OVE::MusicDataType::Numeric_Ending,
|
|
OVE::MeasureData::PairType::Start);
|
|
|
|
for(i=0; i<endings.size(); ++i){
|
|
OVE::NumericEnding* ending = static_cast<OVE::NumericEnding*>(endings[i]);
|
|
int absTick1 = mtt_->getTick(measure->no(), 0);
|
|
int absTick2 = mtt_->getTick(measure->no() + ending->stop()->getMeasure(), 0);
|
|
|
|
if (absTick1 < absTick2) {
|
|
Volta* volta = new Volta(score_);
|
|
volta->setTrack(track);
|
|
volta->setTick(absTick1);
|
|
volta->setTick2(absTick2);
|
|
score_->addElement(volta);
|
|
volta->setVoltaType(Volta::Type::CLOSED);
|
|
volta->setText(ending->getText());
|
|
|
|
volta->endings().clear();
|
|
QList<int> numbers = ending->getNumbers();
|
|
for (int j = 0; j < numbers.size(); ++j) {
|
|
volta->endings().append(numbers[j]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void OveToMScore::convertSlurs(Measure* measure, int part, int staff, int track){
|
|
OVE::MeasureData* measureData = ove_->getMeasureData(part, staff, measure->no());
|
|
if(measureData == 0)
|
|
return;
|
|
|
|
QList<OVE::MusicData*> slurs = measureData->getCrossMeasureElements(OVE::MusicDataType::Slur, OVE::MeasureData::PairType::Start);
|
|
|
|
for(int i=0; i<slurs.size(); ++i){
|
|
OVE::Slur* slurPtr = static_cast<OVE::Slur*>(slurs[i]);
|
|
|
|
OVE::NoteContainer* startContainer = getContainerByPos(part, staff, slurPtr->start()->shiftMeasure(0));
|
|
OVE::NoteContainer* endContainer = getContainerByPos(
|
|
part,
|
|
staff,
|
|
slurPtr->stop()->shiftMeasure(slurPtr->start()->getMeasure()));
|
|
|
|
if(startContainer != 0 && endContainer != 0){
|
|
int absStartTick = mtt_->getTick(slurPtr->start()->getMeasure(), startContainer->getTick());
|
|
int absEndTick = mtt_->getTick(slurPtr->start()->getMeasure()+slurPtr->stop()->getMeasure(), endContainer->getTick());
|
|
|
|
Slur* slur = new Slur(score_);
|
|
slur->setSlurDirection(slurPtr->getShowOnTop()? MScore::Direction::UP : MScore::Direction::DOWN);
|
|
slur->setTick(absStartTick);
|
|
slur->setTick2(absEndTick);
|
|
slur->setTrack(track);
|
|
slur->setTrack2(track+endContainer->getOffsetStaff());
|
|
|
|
score_->addSpanner(slur);
|
|
}
|
|
}
|
|
}
|
|
|
|
QString OveDynamics_To_Dynamics(OVE::DynamicsType type){
|
|
QString dynamic = "other-dynamics";
|
|
|
|
switch( type ){
|
|
case OVE::DynamicsType::PPPP:
|
|
dynamic = "pppp";
|
|
break;
|
|
case OVE::DynamicsType::PPP:
|
|
dynamic = "ppp";
|
|
break;
|
|
case OVE::DynamicsType::PP:
|
|
dynamic = "pp";
|
|
break;
|
|
case OVE::DynamicsType::P:
|
|
dynamic = "p";
|
|
break;
|
|
case OVE::DynamicsType::MP:
|
|
dynamic = "mp";
|
|
break;
|
|
case OVE::DynamicsType::MF:
|
|
dynamic = "mf";
|
|
break;
|
|
case OVE::DynamicsType::F:
|
|
dynamic = "f";
|
|
break;
|
|
case OVE::DynamicsType::FF:
|
|
dynamic = "ff";
|
|
break;
|
|
case OVE::DynamicsType::FFF:
|
|
dynamic = "fff";
|
|
break;
|
|
case OVE::DynamicsType::FFFF:
|
|
dynamic = "ffff";
|
|
break;
|
|
case OVE::DynamicsType::SF:
|
|
dynamic = "sf";
|
|
break;
|
|
case OVE::DynamicsType::FZ:
|
|
dynamic = "fz";
|
|
break;
|
|
case OVE::DynamicsType::SFZ:
|
|
dynamic = "sfz";
|
|
break;
|
|
case OVE::DynamicsType::SFFZ:
|
|
dynamic = "sffz";
|
|
break;
|
|
case OVE::DynamicsType::FP:
|
|
dynamic = "fp";
|
|
break;
|
|
case OVE::DynamicsType::SFP:
|
|
dynamic = "sfp";
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return dynamic;
|
|
}
|
|
|
|
void OveToMScore::convertDynamics(Measure* measure, int part, int staff, int track){
|
|
OVE::MeasureData* measureData = ove_->getMeasureData(part, staff, measure->no());
|
|
if(measureData == 0)
|
|
return;
|
|
|
|
QList<OVE::MusicData*> dynamics = measureData->getMusicDatas(OVE::MusicDataType::Dynamics);
|
|
|
|
for(int i=0; i<dynamics.size(); ++i){
|
|
OVE::Dynamics* dynamicPtr = static_cast<OVE::Dynamics*>(dynamics[i]);
|
|
int absTick = mtt_->getTick(measure->no(), dynamicPtr->getTick());
|
|
Dynamic* dynamic = new Dynamic(score_);
|
|
|
|
dynamic->setDynamicType(OveDynamics_To_Dynamics(dynamicPtr->getDynamicsType()));
|
|
dynamic->setTrack(track);
|
|
|
|
Segment* s = measure->getSegment(Segment::Type::ChordRest, absTick);
|
|
s->add(dynamic);
|
|
}
|
|
}
|
|
|
|
void OveToMScore::convertExpressions(Measure* measure, int part, int staff, int track){
|
|
OVE::MeasureData* measureData = ove_->getMeasureData(part, staff, measure->no());
|
|
if(measureData == 0)
|
|
return;
|
|
|
|
QList<OVE::MusicData*> expressions = measureData->getMusicDatas(OVE::MusicDataType::Expressions);
|
|
|
|
for(int i=0; i<expressions.size(); ++i){
|
|
OVE::Expressions* expressionPtr = static_cast<OVE::Expressions*>(expressions[i]);
|
|
int absTick = mtt_->getTick(measure->no(), expressionPtr->getTick());
|
|
Text* t = new Text(score_);
|
|
|
|
t->setTextStyleType(TextStyleType::TECHNIQUE);
|
|
t->setText(expressionPtr->getText());
|
|
t->setTrack(track);
|
|
|
|
Segment* s = measure->getSegment(Segment::Type::ChordRest, absTick);
|
|
s->add(t);
|
|
}
|
|
}
|
|
|
|
void OveToMScore::convertGlissandos(Measure* measure, int part, int staff, int track){
|
|
OVE::MeasureData* measureData = ove_->getMeasureData(part, staff, measure->no());
|
|
if(measureData == 0)
|
|
return;
|
|
|
|
QList<OVE::MusicData*> glissandos = measureData->getCrossMeasureElements(OVE::MusicDataType::Glissando, OVE::MeasureData::PairType::All);
|
|
|
|
for(int i=0; i<glissandos.size(); ++i){
|
|
OVE::Glissando* glissandoPtr = static_cast<OVE::Glissando*>(glissandos[i]);
|
|
OVE::NoteContainer* startContainer = getContainerByPos(part, staff, glissandoPtr->start()->shiftMeasure(0));
|
|
OVE::NoteContainer* endContainer = getContainerByPos(
|
|
part,
|
|
staff,
|
|
glissandoPtr->stop()->shiftMeasure(glissandoPtr->start()->getMeasure()));
|
|
|
|
if(startContainer != 0 && endContainer != 0){
|
|
int absTick = mtt_->getTick(measure->no(), glissandoPtr->getTick());
|
|
ChordRest* cr = measure->findChordRest(absTick, track);
|
|
if(cr != 0){
|
|
Glissando* g = new Glissando(score_);
|
|
g->setGlissandoType(Glissando::Type::WAVY);
|
|
cr->add(g);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static Hairpin::Type OveWedgeType_To_Type(OVE::WedgeType type) {
|
|
Hairpin::Type subtype = Hairpin::Type::CRESCENDO;
|
|
switch(type) {
|
|
case OVE::WedgeType::Cres_Line: {
|
|
subtype = Hairpin::Type::CRESCENDO;
|
|
break;
|
|
}
|
|
case OVE::WedgeType::Double_Line: {
|
|
subtype = Hairpin::Type::CRESCENDO;
|
|
break;
|
|
}
|
|
case OVE::WedgeType::Decresc_Line: {
|
|
subtype = Hairpin::Type::DECRESCENDO;
|
|
break;
|
|
}
|
|
case OVE::WedgeType::Cres: {
|
|
subtype = Hairpin::Type::CRESCENDO;
|
|
break;
|
|
}
|
|
case OVE::WedgeType::Decresc: {
|
|
subtype = Hairpin::Type::DECRESCENDO;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return subtype;
|
|
}
|
|
|
|
void OveToMScore::convertWedges(Measure* measure, int part, int staff, int track) {
|
|
OVE::MeasureData* measureData = ove_->getMeasureData(part, staff, measure->no());
|
|
if(measureData == 0)
|
|
return;
|
|
|
|
QList<OVE::MusicData*> wedges = measureData->getCrossMeasureElements(OVE::MusicDataType::Wedge, OVE::MeasureData::PairType::All);
|
|
|
|
for(int i=0; i<wedges.size(); ++i){
|
|
OVE::Wedge* wedgePtr = static_cast<OVE::Wedge*>(wedges[i]);
|
|
int absTick = mtt_->getTick(
|
|
measure->no(),
|
|
MeasureToTick::unitToTick(wedgePtr->start()->getOffset(), ove_->getQuarter()));
|
|
int absTick2 = mtt_->getTick(
|
|
measure->no()+wedgePtr->stop()->getMeasure(),
|
|
MeasureToTick::unitToTick(wedgePtr->stop()->getOffset(), ove_->getQuarter()));
|
|
|
|
if (absTick2 > absTick) {
|
|
Hairpin* hp = new Hairpin(score_);
|
|
|
|
hp->setHairpinType(OveWedgeType_To_Type(wedgePtr->getWedgeType()));
|
|
//hp->setYoff(wedgePtr->getYOffset());
|
|
hp->setTrack(track);
|
|
|
|
hp->setTick(absTick);
|
|
hp->setTick2(absTick2);
|
|
hp->setAnchor(Spanner::Anchor::SEGMENT);
|
|
score_->addSpanner(hp);
|
|
score_->updateHairpin(hp);
|
|
}
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
Score::FileError importOve(Score* score, const QString& name) {
|
|
OVE::IOVEStreamLoader* oveLoader = OVE::createOveStreamLoader();
|
|
OVE::OveSong oveSong;
|
|
|
|
QFile oveFile(name);
|
|
if(!oveFile.exists())
|
|
return Score::FileError::FILE_NOT_FOUND;
|
|
if (!oveFile.open(QFile::ReadOnly)) {
|
|
//messageOutString(QString("can't read file!"));
|
|
return Score::FileError::FILE_OPEN_ERROR;
|
|
}
|
|
|
|
QByteArray buffer = oveFile.readAll();
|
|
|
|
oveFile.close();
|
|
|
|
oveSong.setTextCodecName(preferences.importCharsetOve);
|
|
oveLoader->setOve(&oveSong);
|
|
oveLoader->setFileStream((unsigned char*) buffer.data(), buffer.size());
|
|
bool result = oveLoader->load();
|
|
oveLoader->release();
|
|
|
|
if(result){
|
|
OveToMScore otm;
|
|
otm.convert(&oveSong, score);
|
|
|
|
// score->connectSlurs();
|
|
}
|
|
|
|
return result ? Score::FileError::FILE_NO_ERROR : Score::FileError::FILE_ERROR;
|
|
}
|