New engraving interface

Author: XiaoMigros

src/engraving/CMakeLists.txt

@@ -60,6 +60,7 @@ set(MODULE_SRC
     ${CMAKE_CURRENT_LIST_DIR}/engravingerrors.h
     ${CMAKE_CURRENT_LIST_DIR}/engravingproject.cpp
     ${CMAKE_CURRENT_LIST_DIR}/engravingproject.h
+    ${CMAKE_CURRENT_LIST_DIR}/iengraving.h
     ${CMAKE_CURRENT_LIST_DIR}/iengravingconfiguration.h
     ${CMAKE_CURRENT_LIST_DIR}/iengravingfont.h
     ${CMAKE_CURRENT_LIST_DIR}/iengravingfontsprovider.h

src/engraving/api/v1/qmlpluginapi.cpp

@@ -28,8 +28,6 @@
 #include "engraving/compat/scoreaccess.h"
 #include "engraving/dom/factory.h"
 #include "engraving/dom/masterscore.h"
-#include "notation/inotation.h"
-#include "project/inotationwriter.h"
 
 // api
 #include "engravingapiv1.h"
@@ -186,44 +184,7 @@ bool PluginAPI::writeScore(Score* s, const QString& name, const QString& ext)
         LOGW("PluginAPI::writeScore: only writing the selected score is currently supported");
         return false;
     }
-
-    const notation::INotationPtr notation = context()->currentNotation();
-
-    if (!notation) {
-        LOGW("PluginAPI::writeScore: no notation found");
-        return false;
-    }
-
-    const auto unitType = determineWriterUnitType(ext.toStdString());
-
-    if (!unitType) {
-        LOGW("PluginAPI::writeScore: '%s' format is not supported", ext.toUtf8().constData());
-        return false;
-    }
-
-    const QString outPath = name.endsWith(ext) ? name : (name + '.' + ext);
-    return exportProjectScenario()->exportScores({ notation }, outPath, *unitType, /* openDestinationFolderOnExport */ false);
-}
-
-std::optional<project::INotationWriter::UnitType> PluginAPI::determineWriterUnitType(const std::string& ext) const
-{
-    const project::INotationWriterPtr writer = writers()->writer(ext);
-
-    if (!writer) {
-        return std::nullopt;
-    }
-
-    project::INotationWriter::UnitType unitType;
-
-    if (writer->supportsUnitType(project::INotationWriter::UnitType::PER_PAGE)) {
-        unitType = project::INotationWriter::UnitType::PER_PAGE;
-    } else if (writer->supportsUnitType(project::INotationWriter::UnitType::PER_PART)) {
-        unitType = project::INotationWriter::UnitType::PER_PART;
-    } else {
-        unitType = project::INotationWriter::UnitType::MULTI_PART;
-    }
-
-    return unitType;
+    return engravingInterface->APIwriteScore(name, ext);
 }
 
 //---------------------------------------------------------
@@ -246,18 +207,23 @@ apiv1::Score* PluginAPI::readScore(const QString& name, bool noninteractive)
 
     if (noninteractive) {
         LOGW("PluginAPI::readScore: noninteractive flag is not yet implemented");
+        return nullptr;
     }
 
-    const muse::io::path_t path(name);
-    const project::ProjectFile file(path);
-    const muse::Ret ret = projectFilesController()->openProject(file);
-
-    return (ret.success() && !hadScoreOpened) ? curScore() : nullptr;
+    mu::engraving::Score* score = engravingInterface->APIreadScore(name);
+    if (score) {
+        return wrap<apiv1::Score>(score, Ownership::SCORE);
+    }
+    return nullptr;
 }
 
 //---------------------------------------------------------
 //   closeScore
 //---------------------------------------------------------
+void PluginAPI::closeScore()
+{
+    return closeScore(curScore());
+}
 
 void PluginAPI::closeScore(apiv1::Score* score)
 {
@@ -271,7 +237,7 @@ void PluginAPI::closeScore(apiv1::Score* score)
         return;
     }
 
-    projectFilesController()->closeOpenedProject();
+    engravingInterface->APIcloseScore();
 }
 
 //---------------------------------------------------------

src/engraving/api/v1/qmlpluginapi.h

@@ -31,6 +31,7 @@
 #include "actions/iactionsdispatcher.h"
 #include "context/iglobalcontext.h"
 #include "global/iapplication.h"
+#include "engraving/iengraving.h"
 
 #include "enums.h"
 #include "engraving/dom/score.h"
@@ -92,12 +93,6 @@ class PluginAPI : public QQuickItem, public muse::extensions::apiv1::IPluginApiV
 {
     Q_OBJECT
 
-    INJECT(muse::actions::IActionsDispatcher, actionsDispatcher)
-    INJECT(mu::context::IGlobalContext, context)
-    INJECT(mu::project::INotationWritersRegister, writers)
-    INJECT(mu::project::IExportProjectScenario, exportProjectScenario)
-    INJECT(mu::project::IProjectFilesController, projectFilesController)
-
     /** Path where the plugin is placed in menu */
     Q_PROPERTY(QString menuPath READ menuPath WRITE setMenuPath)
     /** Title of this plugin */
@@ -138,9 +133,9 @@ class PluginAPI : public QQuickItem, public muse::extensions::apiv1::IPluginApiV
     /** List of currently open scores (read only).\n \since MuseScore 3.2 */
     Q_PROPERTY(QQmlListProperty<mu::engraving::apiv1::Score> scores READ scores)
 
-    muse::Inject<mu::context::IGlobalContext> context = { this };
-
 public:
+    muse::Inject<muse::actions::IActionsDispatcher> actionsDispatcher = { this };
+    muse::Inject<mu::context::IGlobalContext> context = { this };
     muse::Inject<muse::IApplication> application = { this };
 
 public:
@@ -285,6 +280,9 @@ class PluginAPI : public QQuickItem, public muse::extensions::apiv1::IPluginApiV
     /// \cond MS_INTERNAL
     PluginAPI(QQuickItem* parent = 0);
 
+    explicit PluginAPI(IEngraving* engraving)
+        : engravingInterface(engraving) {}
+
     static void registerQmlTypes();
 
     void setup(QQmlEngine* e) override;
@@ -305,7 +303,8 @@ class PluginAPI : public QQuickItem, public muse::extensions::apiv1::IPluginApiV
     Q_INVOKABLE apiv1::MsProcess* newQProcess();
     Q_INVOKABLE bool writeScore(apiv1::Score*, const QString& name, const QString& ext);
     Q_INVOKABLE apiv1::Score* readScore(const QString& name, bool noninteractive = false);
-    Q_INVOKABLE void closeScore(apiv1::Score*);
+    Q_INVOKABLE void closeScore(apiv1::Score* score);
+    Q_INVOKABLE void closeScore();
 
     Q_INVOKABLE void log(const QString&);
     Q_INVOKABLE void logn(const QString&);
@@ -354,6 +353,8 @@ class PluginAPI : public QQuickItem, public muse::extensions::apiv1::IPluginApiV
 private:
     mu::engraving::Score* currentScore() const;
 
+    IEngraving* engravingInterface;
+
     QString m_pluginType;
     QString m_title;
     QString m_version;
@@ -362,7 +363,6 @@ class PluginAPI : public QQuickItem, public muse::extensions::apiv1::IPluginApiV
     QString m_thumbnailName;
     QString m_categoryCode;
     muse::async::Notification m_closeRequested;
-    std::optional<project::INotationWriter::UnitType> determineWriterUnitType(const std::string& ext) const;
 };
 
 #undef DECLARE_API_ENUM

src/engraving/iengraving.h

@@ -0,0 +1,42 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0-only
+ * MuseScore-Studio-CLA-applies
+ *
+ * MuseScore Studio
+ * Music Composition & Notation
+ *
+ * Copyright (C) 2021 MuseScore Limited
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * 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, see <https://www.gnu.org/licenses/>.
+ */
+#ifndef MU_ENGRAVING_IENGRAVING_H
+#define MU_ENGRAVING_IENGRAVING_H
+
+#include <QString>
+
+namespace mu::engraving {
+class IEngraving;
+
+class IEngraving
+{
+public:
+    virtual ~IEngraving() = default;
+
+    /// Methods for plugin API
+    virtual bool APIwriteScore(const QString& name, const QString& ext) = 0;
+    virtual Score* APIreadScore(const QString& name) = 0;
+    virtual void APIcloseScore() = 0;
+};
+}
+
+#endif // MU_ENGRAVING_IENGRAVING_H

src/project/internal/projectactionscontroller.cpp

@@ -35,9 +35,11 @@
 
 #include "cloud/clouderrors.h"
 #include "cloud/cloudqmltypes.h"
+#include "engraving/iengraving.h"
 #include "engraving/infrastructure/mscio.h"
 #include "engraving/engravingerrors.h"
 
+#include "inotationwriter.h"
 #include "projecterrors.h"
 #include "projectextensionpoints.h"
 
@@ -46,6 +48,7 @@
 using namespace mu;
 using namespace mu::project;
 using namespace mu::notation;
+using namespace mu::engraving;
 using namespace muse;
 using namespace muse::actions;
 
@@ -1900,3 +1903,61 @@ void ProjectActionsController::openProjectProperties()
 {
     interactive()->open(PROJECT_PROPERTIES_URI);
 }
+
+std::optional<INotationWriter::UnitType> ProjectActionsController::determineWriterUnitType(const std::string& ext) const
+{
+    const INotationWriterPtr writer = writers()->writer(ext);
+
+    if (!writer) {
+        return std::nullopt;
+    }
+
+    project::INotationWriter::UnitType unitType;
+
+    if (writer->supportsUnitType(project::INotationWriter::UnitType::PER_PAGE)) {
+        unitType = project::INotationWriter::UnitType::PER_PAGE;
+    } else if (writer->supportsUnitType(project::INotationWriter::UnitType::PER_PART)) {
+        unitType = project::INotationWriter::UnitType::PER_PART;
+    } else {
+        unitType = project::INotationWriter::UnitType::MULTI_PART;
+    }
+
+    return unitType;
+}
+
+bool ProjectActionsController::APIwriteScore(const QString& name, const QString& ext)
+{
+    const INotationPtr notation = globalContext()->currentNotation();
+
+    if (!notation) {
+        LOGW("PluginAPI::writeScore: no notation found");
+        return false;
+    }
+
+    const auto unitType = determineWriterUnitType(ext.toStdString());
+
+    if (!unitType) {
+        LOGW("PluginAPI::writeScore: '%s' format is not supported", ext.toUtf8().constData());
+        return false;
+    }
+
+    const QString outPath = name.endsWith(ext) ? name : (name + '.' + ext);
+    return exportProjectScenario()->exportScores({ notation }, outPath, *unitType, /* openDestinationFolderOnExport */ false);
+}
+
+Score* ProjectActionsController::APIreadScore(const QString& name)
+{
+    const muse::io::path_t path(name);
+    const ProjectFile file(path);
+    const Ret ret = projectFilesController()->openProject(file);
+
+    if (ret.success() && globalContext()->currentNotation()) {
+        return globalContext()->currentNotation()->elements()->msScore();
+    }
+    return nullptr;
+}
+
+void ProjectActionsController::APIcloseScore()
+{
+    projectFilesController()->closeOpenedProject();
+}

src/project/internal/projectactionscontroller.h

@@ -25,6 +25,7 @@
 #include "iprojectfilescontroller.h"
 
 #include <QObject>
+#include <QString>
 
 #include "modularity/ioc.h"
 #include "iinteractive.h"
@@ -39,28 +40,33 @@
 #include "print/iprintprovider.h"
 #include "iexportprojectscenario.h"
 #include "inotationreadersregister.h"
+#include "inotationwritersregister.h"
 #include "iopensaveprojectscenario.h"
 #include "imscmetareader.h"
 #include "io/ifilesystem.h"
 #include "notation/inotationconfiguration.h"
+#include "engraving/iengraving.h"
 #include "musesounds/imusesoundscheckupdatescenario.h"
 #include "extensions/iextensionsprovider.h"
 #include "tours/itoursservice.h"
 
 #include "async/asyncable.h"
 
+#include "inotationwriter.h"
 #include "iprojectconfiguration.h"
 #include "iprojectcreator.h"
 #include "irecentfilescontroller.h"
 #include "iprojectautosaver.h"
 
 namespace mu::project {
 class ProjectActionsController : public IProjectFilesController, public muse::mi::IProjectProvider, public muse::Injectable,
-    public muse::actions::Actionable, public muse::async::Asyncable
+    public muse::actions::Actionable, public muse::async::Asyncable, public engraving::IEngraving
 {
     muse::Inject<IProjectConfiguration> configuration = { this };
     muse::Inject<INotationReadersRegister> readers = { this };
+    muse::Inject<INotationWritersRegister> writers = { this };
     muse::Inject<IProjectCreator> projectCreator = { this };
+    muse::Inject<IProjectFilesController> projectFilesController = { this };
     muse::Inject<IRecentFilesController> recentFilesController = { this };
     muse::Inject<IProjectAutoSaver> projectAutoSaver = { this };
     muse::Inject<IOpenSaveProjectScenario> openSaveProjectScenario = { this };
@@ -73,6 +79,7 @@ class ProjectActionsController : public IProjectFilesController, public muse::mi
     muse::Inject<muse::cloud::IMuseScoreComService> museScoreComService = { this };
     muse::Inject<muse::cloud::IAudioComService> audioComService = { this };
     muse::Inject<notation::INotationConfiguration> notationConfiguration = { this };
+    // muse::Inject<engraving::IEngraving> engraving = { this };
     muse::Inject<playback::IPlaybackController> playbackController = { this };
     muse::Inject<print::IPrintProvider> printProvider = { this };
     muse::Inject<muse::io::IFileSystem> fileSystem = { this };
@@ -104,6 +111,11 @@ class ProjectActionsController : public IProjectFilesController, public muse::mi
     const ProjectBeingDownloaded& projectBeingDownloaded() const override;
     muse::async::Notification projectBeingDownloadedChanged() const override;
 
+    std::optional<INotationWriter::UnitType> determineWriterUnitType(const std::string& ext) const;
+    bool APIwriteScore(const QString& name, const QString& ext) override;
+    mu::engraving::Score* APIreadScore(const QString& name) override;
+    void APIcloseScore() override;
+
 private:
     void setupConnections();