score.h

//=============================================================================
//  MuseScore
//  Music Composition & Notation
//
//  Copyright (C) 2019 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
//  as published by the Free Software Foundation and appearing in
//  the file LICENCE.GPL
//=============================================================================
 
#ifndef __PLUGIN_API_SCORE_H__
#define __PLUGIN_API_SCORE_H__
 
#include "scoreelement.h"
#include "part.h"
#include "style.h"
#include "excerpt.h"
#include "libmscore/score.h"
 
namespace Ms {
 
class InstrumentTemplate;
 
namespace PluginAPI {
 
class Cursor;
class Segment;
class Measure;
class Selection;
class Score;
class Staff;
 
extern Selection* selectionWrap(Ms::Selection* select);
 
//---------------------------------------------------------
//   Score
//---------------------------------------------------------
 
class Score : public Ms::PluginAPI::ScoreElement {
      Q_OBJECT
      Q_PROPERTY(QString                        composer          READ composer)
      Q_PROPERTY(int                            duration          READ duration)
      Q_PROPERTY(QQmlListProperty<Ms::PluginAPI::Excerpt>  excerpts   READ excerpts)
      Q_PROPERTY(Ms::PluginAPI::Measure*        firstMeasure      READ firstMeasure)
      Q_PROPERTY(Ms::PluginAPI::Measure*        firstMeasureMM    READ firstMeasureMM)
      Q_PROPERTY(int                            harmonyCount      READ harmonyCount)
      Q_PROPERTY(bool                           hasHarmonies      READ hasHarmonies)
      Q_PROPERTY(bool                           hasLyrics         READ hasLyrics)
      Q_PROPERTY(int                            keysig            READ keysig)
      Q_PROPERTY(Ms::PluginAPI::Measure*        lastMeasure       READ lastMeasure)
      Q_PROPERTY(Ms::PluginAPI::Measure*        lastMeasureMM     READ lastMeasureMM)
      Q_PROPERTY(Ms::PluginAPI::Segment*        lastSegment       READ lastSegment) // TODO: make it function? Was property in 2.X, but firstSegment is a function...
      Q_PROPERTY(int                            lyricCount        READ lyricCount)
      Q_PROPERTY(QString                        scoreName         READ name           WRITE setName)
      Q_PROPERTY(int                            nmeasures         READ nmeasures)
      Q_PROPERTY(int                            npages            READ npages)
      Q_PROPERTY(int                            nstaves           READ nstaves)
      Q_PROPERTY(int                            ntracks           READ ntracks)
//      Q_PROPERTY(Ms::PageFormat*                pageFormat        READ pageFormat     WRITE undoChangePageFormat)
      Q_PROPERTY(QQmlListProperty<Ms::PluginAPI::Part>     parts      READ parts)
      Q_PROPERTY(QString                        lyricist              READ lyricist)
//      Q_PROPERTY(QString                        subtitle          READ subtitle)
      Q_PROPERTY(QString                        title             READ title)
      Q_PROPERTY(QString                        mscoreVersion     READ mscoreVersion)
      Q_PROPERTY(QString                        mscoreRevision    READ mscoreRevision)
      Q_PROPERTY(Ms::PluginAPI::Selection*      selection         READ selection)
      Q_PROPERTY(Ms::PluginAPI::MStyle*         style             READ style)
      Q_PROPERTY(int pageNumberOffset READ pageNumberOffset WRITE setPageNumberOffset)

      Q_PROPERTY(QQmlListProperty<Ms::PluginAPI::Staff> staves    READ staves)

      Q_PROPERTY(QString path READ path)
 
 
   public:
      Score(Ms::Score* s = nullptr, Ownership o = Ownership::SCORE)
         : ScoreElement(s, o) {}
 
      Ms::Score* score() { return toScore(e); }
      const Ms::Score* score() const { return toScore(e); }
 
      QString composer() { return score()->metaTag("composer"); }
      int duration() { return score()->duration(); }
      int harmonyCount() { return score()->harmonyCount(); }
      bool hasHarmonies() { return score()->hasHarmonies(); }
      bool hasLyrics() { return score()->hasLyrics(); }
      int keysig() { return score()->keysig(); }
      int lyricCount() { return score()->lyricCount(); }
      QString lyricist() { return score()->metaTag("lyricist"); } // not the meanwhile obsolete "poet"
      QString title() { return score()->metaTag("workTitle"); }
      Ms::PluginAPI::Selection* selection() { return selectionWrap(&score()->selection()); }
      MStyle* style() { return wrap(&score()->style(), score()); }
      QString path() { return score()->importedFilePath(); }
 
      int pageNumberOffset() const { return score()->pageNumberOffset(); }
      void setPageNumberOffset(int offset) { score()->undoChangePageNumberOffset(offset); }


      Q_INVOKABLE QString metaTag(const QString& tag) const { return score()->metaTag(tag); }
      Q_INVOKABLE void setMetaTag(const QString& tag, const QString& val) { score()->setMetaTag(tag, val); }

      Q_INVOKABLE void appendPart(const QString& instrumentId);
      Q_INVOKABLE void appendPartByMusicXmlId(const QString& instrumentMusicXmlId);

      Q_INVOKABLE void appendMeasures(int n) { score()->appendMeasures(n); }
      Q_INVOKABLE void addText(const QString& type, const QString& text);
      Q_INVOKABLE Ms::PluginAPI::Cursor* newCursor();
 
      Q_INVOKABLE Ms::PluginAPI::Segment* firstSegment(); // TODO: segment type
      Segment* lastSegment();
 
      Measure* firstMeasure();
      Measure* firstMeasureMM();
      Measure* lastMeasure();
      Measure* lastMeasureMM();
 
      QString name() const { return score()->masterScore()->title(); }
      void setName(const QString& name) { score()->masterScore()->setName(name); }
 
      Q_INVOKABLE QString extractLyrics() { return score()->extractLyrics(); }
 
//      //@ ??
//      Q_INVOKABLE void updateRepeatList(bool expandRepeats) { score()->updateRepeatList(); } // TODO: needed?

      int nmeasures() const { return score()->nmeasures(); }
      int npages() const { return score()->npages(); }
      int nstaves() const { return score()->nstaves(); }
      int ntracks() const { return score()->ntracks(); }

      Q_INVOKABLE void startCmd();
      Q_INVOKABLE void endCmd(bool rollback = false) { score()->endCmd(rollback); }

      Q_INVOKABLE void createPlayEvents() { score()->createPlayEvents(); }

      QString mscoreVersion() { return score()->mscoreVersion(); }
      QString mscoreRevision() { return QString::number(score()->mscoreRevision(), /* base */ 16); }
 
      QQmlListProperty<Part> parts() { return wrapContainerProperty<Part>(this, score()->parts());   }
      QQmlListProperty<Excerpt> excerpts() { return wrapExcerptsContainerProperty<Excerpt>(this, score()->excerpts());   }
      QQmlListProperty<Staff> staves();
 
      static const Ms::InstrumentTemplate* instrTemplateFromName(const QString& name); // used by PluginAPI::newScore()
      };
} // namespace PluginAPI
} // namespace Ms
#endif