scoreelement.h

//=============================================================================
//  MuseScore
//  Music Composition & Notation
//
//  Copyright (C) 2012 Werner Schweer
//
//  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_SCOREELEMENT_H__
#define __PLUGIN_API_SCOREELEMENT_H__
 
#include "libmscore/property.h"
 
namespace Ms {
 
class ScoreElement;
 
namespace PluginAPI {
 
//---------------------------------------------------------
//   Ownership
//---------------------------------------------------------
 
enum class Ownership {
      PLUGIN,
      SCORE,
      };
 
//---------------------------------------------------------
//   ScoreElement
//---------------------------------------------------------
 
class ScoreElement : public QObject {
      Q_OBJECT
      Q_PROPERTY(int       type READ type)
      Q_PROPERTY(QString   name READ name)
 
      Ownership _ownership;
 
      qreal spatium() const;
 
   protected:
      Ms::ScoreElement* const e;
 
   public:
      ScoreElement(Ms::ScoreElement* _e = nullptr, Ownership own = Ownership::PLUGIN)
         : QObject(), _ownership(own), e(_e) {}
      ScoreElement(const ScoreElement&) = delete;
      ScoreElement& operator=(const ScoreElement&) = delete;
      virtual ~ScoreElement();
 
      Ownership ownership() const { return _ownership; }
      void setOwnership(Ownership o) { _ownership = o; }
 
      Ms::ScoreElement* element() { return e; };
      const Ms::ScoreElement* element() const { return e; };
 
      QString name() const;
      int type() const;
 
      QVariant get(Ms::Pid pid) const;
      void set(Ms::Pid pid, QVariant val);
 
      Q_INVOKABLE QString userName() const;
      Q_INVOKABLE bool is(Ms::PluginAPI::ScoreElement* other) { return other && element() == other->element(); }
      };
 
//---------------------------------------------------------
//   wrap
//---------------------------------------------------------
 
template <class Wrapper, class T>
Wrapper* wrap(T* t, Ownership own = Ownership::SCORE)
      {
      Wrapper* w = t ? new Wrapper(t, own) : nullptr;
      // All wrapper objects should belong to JavaScript code.
      QQmlEngine::setObjectOwnership(w, QQmlEngine::JavaScriptOwnership);
      return w;
      }
 
extern ScoreElement* wrap(Ms::ScoreElement* se, Ownership own = Ownership::SCORE);
 
//---------------------------------------------------------
//   customWrap
//---------------------------------------------------------
 
template <class Wrapper, class T, typename... Args>
Wrapper* customWrap(T* t, Args... args)
      {
      Wrapper* w = t ? new Wrapper(t, std::forward<Args>(args)...) : nullptr;
      // All wrapper objects should belong to JavaScript code.
      QQmlEngine::setObjectOwnership(w, QQmlEngine::JavaScriptOwnership);
      return w;
      }
 
//---------------------------------------------------------
//---------------------------------------------------------
 
template <typename T, class Container>
class QmlListAccess : public QQmlListProperty<T> {
public:
      QmlListAccess(QObject* obj, Container& container)
            : QQmlListProperty<T>(obj, const_cast<void*>(static_cast<const void*>(&container)), &count, &at) {}
 
      static int count(QQmlListProperty<T>* l)     { return int(static_cast<Container*>(l->data)->size()); }
      static T* at(QQmlListProperty<T>* l, int i)
            {
            auto el = static_cast<Container*>(l->data)->at(i);
            // If a polymorphic wrap() function is available
            // for the requested type, use it for wrapping.
            if (std::is_same<T*, decltype(wrap(el, Ownership::SCORE))>::value)
                  return static_cast<T*>(wrap(el, Ownership::SCORE));
            // Otherwise, wrap directly to the requested wrapper type.
            return wrap<T>(el, Ownership::SCORE);
            }
      };

template<typename T, class Container>
QmlListAccess<T, Container> wrapContainerProperty(QObject* obj, Container& c)
      {
      return QmlListAccess<T, Container>(obj, c);
      }
} // namespace PluginAPI
} // namespace Ms
#endif