instrument.h

//=============================================================================
//  MuseScore
//  Music Composition & Notation
//
//  Copyright (C) 2020 MuseScore BVBA
//
//  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 __PLUGIN_API_INSTRUMENT_H__
#define __PLUGIN_API_INSTRUMENT_H__
 
#include "scoreelement.h"
#include "libmscore/instrument.h"
 
namespace Ms {
 
class Instrument;
 
namespace PluginAPI {
 
class Instrument;
 
//---------------------------------------------------------
//   Channel
//---------------------------------------------------------
 
class Channel : public QObject {
      Q_OBJECT
 
      Ms::Channel* _channel;
      Ms::Part* _part;
 
      Q_PROPERTY(QString name READ name)
 
      
      Q_PROPERTY(int volume READ volume WRITE setVolume)
      Q_PROPERTY(int pan READ pan WRITE setPan)
      Q_PROPERTY(int chorus READ chorus WRITE setChorus)
      Q_PROPERTY(int reverb READ reverb WRITE setReverb)
      Q_PROPERTY(bool mute READ mute WRITE setMute)
 
      Q_PROPERTY(int midiProgram READ midiProgram WRITE setMidiProgram)
      Q_PROPERTY(int midiBank READ midiBank WRITE setMidiBank)
 
      Ms::Channel* activeChannel();
 
      void setMidiBankAndProgram(int bank, int program, bool setUserBankController);
 
   public:
      Channel(Ms::Channel* ch, Ms::Part* p, QObject* parent = nullptr)
         : QObject(parent), _channel(ch), _part(p) {}
 
      QString name() const { return _channel->name(); }
 
      int volume() const { return _channel->volume(); }
      void setVolume(int val) { activeChannel()->setVolume(qBound(0, val, 127)); }
      int pan() const { return _channel->pan(); }
      void setPan(int val) { activeChannel()->setPan(qBound(0, val, 127)); }
      int chorus() const { return _channel->chorus(); }
      void setChorus(int val) { activeChannel()->setChorus(qBound(0, val, 127)); }
      int reverb() const { return _channel->reverb(); }
      void setReverb(int val) { activeChannel()->setReverb(qBound(0, val, 127)); }
 
      bool mute() const { return _channel->mute(); }
      void setMute(bool val) { activeChannel()->setMute(val); }
 
      int midiProgram() const { return _channel->program(); }
      void setMidiProgram(int prog);
      int midiBank() const { return _channel->bank(); }
      void setMidiBank(int bank);
      };
 
//---------------------------------------------------------
//   StringData
//---------------------------------------------------------
 
class StringData : public QObject {
      Q_OBJECT
 
      Q_PROPERTY(QVariantList strings READ stringList)
 
      
      Q_PROPERTY(int frets READ frets)
 
      Ms::StringData _data;
 
   public:
      StringData(const Ms::StringData* d, QObject* parent = nullptr)
         : QObject(parent), _data(*d) {}
 
      QVariantList stringList() const;
      int frets() const { return _data.frets(); }
      };
 
//---------------------------------------------------------
//   ChannelListProperty
//---------------------------------------------------------
 
class ChannelListProperty : public QQmlListProperty<Channel> {
public:
      ChannelListProperty(Instrument* i);
 
      static int count(QQmlListProperty<Channel>* l);
      static Channel* at(QQmlListProperty<Channel>* l, int i);
      };
 
//---------------------------------------------------------
//   Instrument
//---------------------------------------------------------
 
class Instrument : public QObject {
      Q_OBJECT
 
      Q_PROPERTY(QString                        instrumentId         READ instrumentId)
      // Ms::Instrument supports multiple short/long names (for aeolus instruments?)
      // but in practice only one is actually used. If this gets changed this API could
      // be expanded.
      Q_PROPERTY(QString                        longName             READ longName)
      Q_PROPERTY(QString                        shortName            READ shortName)
 
      Q_PROPERTY(Ms::PluginAPI::StringData* stringData READ stringData)
 
      // TODO: a property for drumset?
 
      Q_PROPERTY(QQmlListProperty<Ms::PluginAPI::Channel> channels READ channels)
 
      Ms::Instrument* _instrument;
      Ms::Part* _part;
 
   public:
      Instrument(Ms::Instrument* i, Ms::Part* p)
         : QObject(), _instrument(i), _part(p) {}
 
      Ms::Instrument* instrument() { return _instrument; }
      const Ms::Instrument* instrument() const { return _instrument; }
 
      Ms::Part* part() { return _part; }
 
      QString instrumentId() const { return instrument()->instrumentId(); }
      QString longName() const;
      QString shortName() const;
 
      StringData* stringData() { return customWrap<StringData>(instrument()->stringData()); }
 
      ChannelListProperty channels();
 
      Q_INVOKABLE bool is(Ms::PluginAPI::Instrument* other) { return other && instrument() == other->instrument(); }
      };
 
} // namespace PluginAPI
} // namespace Ms
 
#endif