musicxmlsupport.h

Go to the documentation of this file.

//=============================================================================
//  MusE Score
//  Linux Music Score Editor
//
//  Copyright (C) 2012 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.
//=============================================================================

#ifndef __MUSICXMLSUPPORT_H__
#define __MUSICXMLSUPPORT_H__

#include "libmscore/fraction.h"
#include "libmscore/mscore.h"
#include "libmscore/note.h"

namespace Ms {

//---------------------------------------------------------
//   NoteList
//---------------------------------------------------------

typedef QPair<int, int> StartStop;
typedef QList<StartStop> StartStopList;

//---------------------------------------------------------
//   NoteList
//---------------------------------------------------------

class NoteList {
public:
      NoteList();
      void addNote(const int startTick, const int endTick, const int staff);
      void dump(const QString& voice) const;
      bool stavesOverlap(const int staff1, const int staff2) const;
      bool anyStaffOverlaps() const;
private:
      QList<StartStopList> _staffNoteLists; 
      };

//---------------------------------------------------------
//   VoiceDesc
//---------------------------------------------------------

class VoiceDesc {
public:
      VoiceDesc();
      void incrChordRests(int s);
      int numberChordRests() const;
      int numberChordRests(int s) const { return (s >= 0 && s < MAX_STAVES) ? _chordRests[s] : 0; }
      int preferredStaff() const;       
      void setStaff(int s) { if (s >= 0) _staff = s; }
      int staff() const { return _staff; }
      void setVoice(int v) { if (v >= 0) _voice = v; }
      int voice() const { return _voice; }
      void setVoice(int s, int v) { if (s >= 0 && s < MAX_STAVES) _voices[s] = v; }
      int voice(int s) const { return (s >= 0 && s < MAX_STAVES) ? _voices[s] : -1; }
      void setOverlap(bool b) { _overlaps = b; }
      bool overlaps() const { return _overlaps; }
      void setStaffAlloc(int s, int i) { if (s >= 0 && s < MAX_STAVES) _staffAlloc[s] = i; }
      int staffAlloc(int s) const { return (s >= 0 && s < MAX_STAVES) ? _staffAlloc[s] : -1; }
      QString toString() const;
private:
      int _chordRests[MAX_STAVES];      
      int _staff;                       
      int _voice;                       
      bool _overlaps;                   
      int _staffAlloc[MAX_STAVES];      
      int _voices[MAX_STAVES];          
      };

//---------------------------------------------------------
//   VoiceOverlapDetector
//---------------------------------------------------------

class VoiceOverlapDetector {
public:
      VoiceOverlapDetector();
      void addNote(const int startTick, const int endTick, const QString& voice, const int staff);
      void dump() const;
      void newMeasure();
      bool stavesOverlap(const QString& voice) const;
private:
      QMap<QString, NoteList> _noteLists; 
      };

//---------------------------------------------------------
//   MusicXMLDrumInstrument
//---------------------------------------------------------

struct MusicXMLDrumInstrument {
      int pitch;                       // pitch read from MusicXML
      QString name;                    // name read from MusicXML
      QString sound;                   // sound read from MusicXML
      QString virtLib;                 // virtual library read from MusicXML
      QString virtName;                // virtualname read from MusicXML
      int midiChannel;                 // channel read from MusicXML
      int midiPort;                    // port read from MusicXML
      int midiProgram;                 // program read from MusicXML
      int midiVolume;                  // volume read from MusicXML
      int midiPan;                     // pan value read from MusicXML
      NoteHead::Group notehead;        
      int line;                        
      Direction stemDirection;

      QString toString() const;

      MusicXMLDrumInstrument()
            : pitch(-1), name(), midiChannel(-1), midiPort(-1), midiProgram(-1), midiVolume(100), midiPan(63),
            notehead(NoteHead::Group::HEAD_INVALID), line(0), stemDirection(Direction::AUTO) {}
      MusicXMLDrumInstrument(QString s)
            : pitch(-1), name(s), midiChannel(-1), midiPort(-1), midiProgram(-1), midiVolume(100), midiPan(63),
            notehead(NoteHead::Group::HEAD_INVALID), line(0), stemDirection(Direction::AUTO) {}
      MusicXMLDrumInstrument(int p, QString s, NoteHead::Group nh, int l, Direction d)
            : pitch(p), name(s), midiChannel(-1), midiPort(-1), midiProgram(-1), midiVolume(100), midiPan(63),
            notehead(nh), line(l), stemDirection(d) {}
      };

typedef QMap<QString, MusicXMLDrumInstrument> MusicXMLDrumset;
typedef QMapIterator<QString, MusicXMLDrumInstrument> MusicXMLDrumsetIterator;


//---------------------------------------------------------
//   MxmlSupport -- MusicXML import support functions
//---------------------------------------------------------

class MxmlSupport {
public:
      static int stringToInt(const QString& s, bool* ok);
      static Fraction durationAsFraction(const int divisions, const QDomElement e);
      static Fraction noteTypeToFraction(QString type);
      static Fraction calculateFraction(QString type, int dots, int normalNotes, int actualNotes);
      };

//---------------------------------------------------------
//   ValidatorMessageHandler
//---------------------------------------------------------

class ValidatorMessageHandler : public QAbstractMessageHandler
      {
      Q_OBJECT

public:
      ValidatorMessageHandler() : QAbstractMessageHandler(0) {}
      QString getErrors() const { return errors; }
protected:
      virtual void handleMessage(QtMsgType type, const QString& description,
                                 const QUrl& identifier, const QSourceLocation& sourceLocation);
private:
      QString errors;
      };

extern void domError(const QDomElement&);
extern void domNotImplemented(const QDomElement&);


extern QString accSymId2MxmlString(const SymId id);
extern QString accidentalType2MxmlString(const AccidentalType type);
extern AccidentalType mxmlString2accidentalType(const QString mxmlName);
extern SymId mxmlString2accSymId(const QString mxmlName);
extern AccidentalType microtonalGuess(double val);

} // namespace Ms
#endif