//=============================================================================
//  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/accidental.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"
#include "libmscore/sym.h"
#include "libmscore/bracketItem.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, SubStyle stl) {
      if (!strTxt.isEmpty()) {
            Text* text = new Text(s);
            text->initSubStyle(stl);
            text->setPlainText(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, SubStyle::TITLE);
            }
 
      QList<QString> copyrights = ove_->getCopyrights();
      if( !copyrights.empty() && !copyrights[0].isEmpty() ) {
            QString copyright = copyrights[0];
            score_->setMetaTag("copyright", copyright);
            }
 
      QList<QString> annotates = ove_->getAnnotates();
      if( !annotates.empty() && !annotates[0].isEmpty() ) {
            QString annotate = annotates[0];
            addText(vbox, score_, annotate, SubStyle::POET);
            }
 
      QList<QString> writers = ove_->getWriters();
      if(!writers.empty()) {
            QString composer = writers[0];
            score_->setMetaTag("composer", composer);
            addText(vbox, score_, composer, SubStyle::COMPOSER);
            }
 
      if(writers.size() > 1) {
            QString lyricist = writers[1];
            addText(vbox, score_, lyricist, SubStyle::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->setBracketType(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(new BracketItem(staff->score(), 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::G8_VA;
                  break;
                  }
            case OVE::ClefType::Bass8va:{
                  clef = ClefType::F_8VA;
                  break;
                  }
            case OVE::ClefType::Treble8vb:{
                  clef = ClefType::G8_VB;
                  break;
                  }
            case OVE::ClefType::Bass8vb:{
                  clef = ClefType::F8_VB;
                  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->setPlainLongName(longName);
            }
 
      QString shortName = track->getBriefName();
      if (shortName != QString() && track->getShowBriefName()) {
            part->setPlainShortName(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 OttavaType OctaveShiftTypeToInt(OVE::OctaveShiftType type) {
      OttavaType subtype = OttavaType::OTTAVA_8VA;
      switch (type) {
            case OVE::OctaveShiftType::OS_8: {
                  subtype = OttavaType::OTTAVA_8VA;
                  break;
                  }
            case OVE::OctaveShiftType::OS_15: {
                  subtype = OttavaType::OTTAVA_15MA;
                  break;
                  }
            case OVE::OctaveShiftType::OS_Minus_8: {
                  subtype = OttavaType::OTTAVA_8VB;
                  break;
                  }
            case OVE::OctaveShiftType::OS_Minus_15: {
                  subtype = OttavaType::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() != ElementType::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(SegmentType::TimeSig, 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(SegmentType::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(SegmentType::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(SegmentType::HeaderClef, 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(SegmentType::Clef, absTick);
                                    s->add(clef);
                                    }
                              }
                        }
                  }
 
            staffCount += partStaffCount;
            }
 
      // Tempo
      std::map<int, double> 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] = 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());
                              double tempo = ptr->getQuarterTempo()>0 ? ptr->getQuarterTempo() : 1.0;
 
                              tempos[tick] = tempo;
                              }
                        }
                  }
            }
 
      std::map<int, double>::iterator it;
      int lastTempo = 0;
      for(it=tempos.begin(); it!=tempos.end(); ++it) {
            if( it==tempos.begin() || (*it).second != lastTempo ) {
                  double tpo = ((*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() != ElementType::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() != ElementType::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->setRepeatStart(true);
                  break;
                  }
            case OVE::BarLineType::RepeatRight:{
                  bartype = BarLineType::END_REPEAT;
                  measure->setRepeatEnd(true);
                  break;
                  }
            case OVE::BarLineType::Dashed:{
                  bartype = BarLineType::BROKEN;
                  break;
                  }
            default:
                  break;
            }
 
//TODO      if (bartype != BarLineType::NORMAL && bartype != BarLineType::END_REPEAT && bartype != BarLineType::START_REPEAT && bartype != BarLineType::END_START_REPEAT && bartype != BarLineType::END)
      if (bartype != BarLineType::NORMAL && bartype != BarLineType::END_REPEAT && bartype != BarLineType::START_REPEAT && bartype != BarLineType::END)
            measure->setEndBarLineType(bartype, 0);
 
      if (bartype == BarLineType::END_REPEAT)
            measure->setRepeatEnd(true);
 
      if(measurePtr->getLeftBarline() == OVE::BarLineType::RepeatLeft){
            //bartype = BarLineType::START_REPEAT;
            measure->setRepeatStart(true);
            }
 
      // 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->setPlainText(textPtr->getText());
//TODO:ws                  text->setAbove(true);
                  text->setTrack(track);
 
                  Segment* s = measure->getSegment(SegmentType::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 = (tempoPtr->getQuarterTempo())/60.0;
 
            score_->setTempo(absTick, tpo);
 
            t->setTempo(tpo);
            QString durationTempoL;
            QString durationTempoR;
            if ((int)(tempoPtr->getLeftNoteType()))
                  durationTempoL = TempoText::duration2tempoTextString(OveNoteType_To_Duration(tempoPtr->getLeftNoteType()));
            if ((int)(tempoPtr->getRightNoteType()))
                  durationTempoR = TempoText::duration2tempoTextString(OveNoteType_To_Duration(tempoPtr->getRightNoteType()));
            QString textTempo;
            if (tempoPtr->getShowBeforeText())
                  textTempo += (tempoPtr->getLeftText()).toHtmlEscaped();
            if (tempoPtr->getShowMark()) {
                  if (!textTempo.isEmpty())
                        textTempo += " ";
                  if (tempoPtr->getShowParenthesis())
                        textTempo += "(";
                  textTempo += durationTempoL;
                  if (tempoPtr->getLeftNoteDot())
                        textTempo += "<sym>space</sym><sym>metAugmentationDot</sym>";
                  textTempo += " = ";
                  switch (tempoPtr->getRightSideType()) {
                        case 1:
                              textTempo += durationTempoR;
                              if (tempoPtr->getRightNoteDot())
                                    textTempo += "<sym>space</sym><sym>metAugmentationDot</sym>";
                              break;
                        case 2:
                              textTempo += (tempoPtr->getRightText()).toHtmlEscaped();
                              break;
                        case 3:
                              textTempo += QString::number(qFloor(tempoPtr->getTypeTempo()));
                              break;
                        case 0:
                        default:
                              textTempo += QString::number(tempoPtr->getTypeTempo());
                              break;
                        }
                  if (tempoPtr->getShowParenthesis())
                        textTempo += ")";
                  }
            if (textTempo.isEmpty()) {
                  textTempo = durationTempoL;
                  if (tempoPtr->getLeftNoteDot())
                        textTempo += "<sym>space</sym><sym>metAugmentationDot</sym>";
                  textTempo += " = " + QString::number(tempoPtr->getTypeTempo());
                  t->setVisible(false);
                  }
            t->setXmlText(textTempo);
//TODO:ws            t->setAbove(true);
            t->setTrack(track);
 
            Segment* s = measure->getSegment(SegmentType::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(SegmentType::ChordRest, 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());
                  Segment* s = measure->getSegment(SegmentType::ChordRest, tick);
                  s->add(cr);
 
                  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());
                              int stepOffset = cr->staff()->staffType(cr->tick())->stepOffset();
                              int lineOffset = static_cast<Ms::Rest*>(cr)->computeLineOffset(5);
                              yOffset -= qreal(lineOffset + stepOffset);
                              yOffset *= score_->spatium()/2.0;
                              cr->setUserYoffset(yOffset);
                              cr->setAutoplace(false);
                              }
                        }
                  }
            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 = SegmentType::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(SegmentType::ChordRest, tick);
                              s->add(cr);
                              }
                        else {
                              graceNotes.append(static_cast<Ms::Chord*>(cr));
                              }
                        }
 
                  cr->setVisible(container->getShow());
                  cr->setSmall(container->getIsCue());
                  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->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 {
                              	// no drumset, we don't allow mid staff percussion
                                    note->setTpc(14);
                              	}
                              }
                        else {
                              const int OCTAVE = 7;
                              OVE::ToneType clefMiddleTone;
                              int clefMiddleOctave;
                              getMiddleToneOctave(clefType, clefMiddleTone, clefMiddleOctave);
                              int absLine = (int) clefMiddleTone + clefMiddleOctave * OCTAVE + oveNote->getLine();
                              if ((partStaffCount == 2) && oveNote->getOffsetStaff())
                                    absLine += 2 * (oveNote->getOffsetStaff());
                              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)));
                              if (oveNote->getShowAccidental()) {
                                    Ms::Accidental* a = new Accidental(score_);
                                    bool bracket = (int)(oveNote->getAccidental()) & 0x8;
                                    AccidentalType at = Ms::AccidentalType::NONE;
                                    switch(alter) {
                                          case 0: at = Ms::AccidentalType::NATURAL; break;
                                          case 1: at = Ms::AccidentalType::SHARP; break;
                                          case -1: at = Ms::AccidentalType::FLAT; break;
                                          case 2: at = Ms::AccidentalType::SHARP2; break;
                                          case -2: at = Ms::AccidentalType::FLAT2; break;
                                          }
                                    a->setAccidentalType(at);
                                    a->setBracket(AccidentalBracket(bracket));
                                    a->setRole(Ms::AccidentalRole::USER);
                                    note->add(a);
                                    }
                              note->setHeadGroup(getHeadGroup(oveNote->getHeadType()));
                              }
                        if ((oveNote->getHeadType() == OVE::NoteHeadType::Invisible) || !(oveNote->getShow()))
                              note->setVisible(false);
                        // 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() ? Direction::UP : 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;
            Beam::Mode bm = Beam::Mode::NONE;
            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()));
                              TDuration duration = OveNoteType_To_Duration(container->getNoteType());
                              tuplet->setBaseLen(duration);
                              tuplet->setTick(tick);
                              tuplet->setParent(measure);
                              //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 ? Direction::UP : 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->setSymId(SymId::ornamentTrill);
                  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->setSymId(SymId::ornamentMordent);
                  cr->add(a);
                  break;
                  }
            case OVE::ArticulationType::Short_Mordent :{
                  Articulation* a = new Articulation(score_);
                  a->setSymId(SymId::ornamentMordentInverted);
                  cr->add(a);
                  break;
                  }
            case OVE::ArticulationType::Turn :{
                  Articulation* a = new Articulation(score_);
                  a->setSymId(SymId::ornamentTurn);
                  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->setSymId(SymId::articAccentAbove);
                  cr->add(a);
                  break;
                  }
            case OVE::ArticulationType::Marcato_Dot :{
                  Articulation* a = new Articulation(score_);
                  a->setSymId(SymId::articAccentAbove);
                  cr->add(a);
 
                  a = new Articulation(score_);
                  a->setSymId(SymId::articStaccatoAbove);
                  cr->add(a);
                  break;
                  }
            case OVE::ArticulationType::Heavy_Attack :{
                  Articulation* a = new Articulation(score_);
                  a->setSymId(SymId::articAccentAbove);
                  cr->add(a);
 
                  a = new Articulation(score_);
                  a->setSymId(SymId::articTenutoAbove);
                  cr->add(a);
                  break;
                  }
            case OVE::ArticulationType::SForzando :{
                  Articulation* a = new Articulation(score_);
                  a->setUp(true);
                  a->setSymId(SymId::articMarcatoAbove);
                  cr->add(a);
                  break;
                  }
            case OVE::ArticulationType::SForzando_Inverted :{
                  Articulation* a = new Articulation(score_);
                  a->setUp(false);
                  a->setSymId(SymId::articMarcatoAbove);
                  cr->add(a);
                  break;
                  }
            case OVE::ArticulationType::SForzando_Dot :{
                  Articulation* a = new Articulation(score_);
                  a->setUp(true);
                  a->setSymId(SymId::articMarcatoAbove);
                  cr->add(a);
 
                  a = new Articulation(score_);
                  a->setSymId(SymId::articStaccatoAbove);
                  cr->add(a);
                  break;
                  }
            case OVE::ArticulationType::SForzando_Dot_Inverted :{
                  Articulation* a = new Articulation(score_);
                  a->setUp(false);
                  a->setSymId(SymId::articMarcatoAbove);
                  cr->add(a);
 
                  a = new Articulation(score_);
                  a->setSymId(SymId::articStaccatoAbove);
                  cr->add(a);
                  break;
                  }
            case OVE::ArticulationType::Heavier_Attack :{
                  Articulation* a = new Articulation(score_);
                  a->setUp(true);
                  a->setSymId(SymId::articMarcatoAbove);
                  cr->add(a);
 
                  a = new Articulation(score_);
                  a->setSymId(SymId::articTenutoAbove);
                  cr->add(a);
                  break;
                  }
            case OVE::ArticulationType::Staccatissimo :{
                  Articulation* a = new Articulation(score_);
                  a->setUp(true);
                  a->setSymId(SymId::articStaccatissimoAbove);
                  cr->add(a);
                  break;
                  }
            case OVE::ArticulationType::Staccato :{
                  Articulation* a = new Articulation(score_);
                  a->setSymId(SymId::articStaccatoAbove);
                  cr->add(a);
                  break;
                  }
            case OVE::ArticulationType::Tenuto :{
                  Articulation* a = new Articulation(score_);
                  a->setSymId(SymId::articTenutoAbove);
                  cr->add(a);
                  break;
                  }
            case OVE::ArticulationType::Pause :{
                  Breath* b = new Breath(score_);
                  b->setTrack(track);
                  Segment* seg = measure->getSegment(SegmentType::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->setSymId(SymId::stringsUpBow);
                  cr->add(a);
                  break;
                  }
            case OVE::ArticulationType::Down_Bow :{
                  Articulation* a = new Articulation(score_);
                  a->setSymId(SymId::stringsDownBow);
                  cr->add(a);
                  break;
                  }
            case OVE::ArticulationType::Up_Bow_Inverted :{
                  Articulation* a = new Articulation(score_);
                  a->setSymId(SymId::stringsUpBow);
                  a->setUserYoffset(5.3);
                  cr->add(a);
                  break;
                  }
            case OVE::ArticulationType::Down_Bow_Inverted :{
                  Articulation* a = new Articulation(score_);
                  a->setSymId(SymId::stringsDownBow);
                  a->setUserYoffset(5.3);
                  cr->add(a);
                  break;
                  }
            case OVE::ArticulationType::Natural_Harmonic :{
                  Articulation* a = new Articulation(score_);
                  a->setSymId(SymId::stringsHarmonic);
                  cr->add(a);
                  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->setSymId(SymId::brassMuteClosed);
                  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->setSymId(SymId::fermataAbove);
                  cr->add(a);
                  break;
                  }
            case OVE::ArticulationType::Fermata_Inverted :{
                  Articulation* a = new Articulation(score_);
                  a->setDirection(Direction::DOWN);
                  a->setSymId(SymId::fermataBelow);
                  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(SegmentType::ChordRest, absTick);
                        pedal_->setTick(seg->tick());
                        score_->addSpanner(pedal_);
                        }
                  break;
                  }
            case OVE::ArticulationType::Pedal_Up :{
                  if(pedal_){
                        Segment* seg = measure->getSegment(SegmentType::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->setPlainText(oveLyric->getLyric());
            lyric->setTrack(track);
            Segment* segment = measure->getSegment(SegmentType::ChordRest, tick);
            if (segment->element(track))
                  static_cast<ChordRest*>(segment->element(track))->add(lyric);
            }
      }
 
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(step2tpc(harmonyPtr->getRoot(), AccidentalVal(harmonyPtr->getAlterRoot())));
            if(harmonyPtr->getBass() != OVE::INVALID_NOTE && (harmonyPtr->getBass() != harmonyPtr->getRoot() || (harmonyPtr->getBass() == harmonyPtr->getRoot() && harmonyPtr->getAlterBass() != harmonyPtr->getAlterRoot()))){
                  harmony->setBaseTpc(step2tpc(harmonyPtr->getBass(), AccidentalVal(harmonyPtr->getAlterBass())));
                  }
            const ChordDescription* d = harmony->fromXml(harmonyPtr->getHarmonyType());
            if(d != 0){
                  harmony->setId(d->id);
                  harmony->setTextName(d->names.front());
                  }
            else {
                  harmony->setId(-1);
                  harmony->setTextName(harmonyPtr->getHarmonyType());
                  }
            harmony->render();
 
            Segment* s = measure->getSegment(SegmentType::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()? Direction::UP : 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(SegmentType::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(SubStyle::EXPRESSION, score_);
 
            t->setPlainText(expressionPtr->getText());
            t->setTrack(track);
 
            Segment* s = measure->getSegment(SegmentType::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 HairpinType OveWedgeType_To_Type(OVE::WedgeType type) {
      HairpinType subtype = HairpinType::CRESC_HAIRPIN;
      switch(type) {
            case OVE::WedgeType::Cres_Line: {
                  subtype = HairpinType::CRESC_HAIRPIN;
                  break;
                  }
            case OVE::WedgeType::Double_Line: {
                  subtype = HairpinType::CRESC_HAIRPIN;
                  break;
                  }
            case OVE::WedgeType::Decresc_Line: {
                  subtype = HairpinType::DECRESC_HAIRPIN;
                  break;
                  }
            case OVE::WedgeType::Cres: {
                  subtype = HairpinType::CRESC_HAIRPIN;
                  break;
                  }
            case OVE::WedgeType::Decresc: {
                  subtype = HairpinType::DECRESC_HAIRPIN;
                  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(MasterScore* 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;
      }
 

V728 An excessive check 'k > 0' can be simplified. The '||' operator is surrounded by opposite expressions.

V728 An excessive check can be simplified. The '||' operator is surrounded by opposite expressions.

V730 Not all members of a class are initialized inside the constructor. Consider inspecting: score_.