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