Add drag-handle overlay to edit per-note velocities

src/engraving/playback/playbackmodel.cpp

@@ -394,6 +394,16 @@ muse::async::Channel<InstrumentTrackId> PlaybackModel::trackRemoved() const
     return m_trackRemoved;
 }
 
+dynamic_level_t PlaybackModel::appliableDynamicLevel(track_idx_t trackIdx, int tick) const
+{
+    if (!m_playbackCtx) {
+        return dynamicLevelFromType(muse::mpe::DynamicType::Natural);
+    }
+
+    const int utick = repeatList().tick2utick(tick);
+    return m_playbackCtx->appliableDynamicLevel(trackIdx, utick);
+}
+
 void PlaybackModel::update(const int tickFrom, const int tickTo, const track_idx_t trackFrom, const track_idx_t trackTo,
                            ChangedTrackIdSet* trackChanges)
 {

src/engraving/playback/playbackmodel.h

@@ -93,6 +93,8 @@ class PlaybackModel : public muse::Contextable, public muse::async::Asyncable
     muse::async::Channel<InstrumentTrackId> trackAdded() const;
     muse::async::Channel<InstrumentTrackId> trackRemoved() const;
 
+    muse::mpe::dynamic_level_t appliableDynamicLevel(track_idx_t trackIdx, int tick) const;
+
 private:
     static const InstrumentTrackId METRONOME_TRACK_ID;
     static const InstrumentTrackId CHORD_SYMBOLS_TRACK_ID;

src/engraving/rw/write/twrite.cpp

@@ -2505,8 +2505,8 @@ void TWrite::write(const Note* item, XmlWriter& xml, WriteContext& ctx)
         xml.endElement();
     }
     for (Pid id : { Pid::PITCH, Pid::CENT_OFFSET, Pid::TPC1, Pid::TPC2, Pid::SMALL, Pid::MIRROR_HEAD, Pid::DOT_POSITION,
-                    Pid::HEAD_SCHEME, Pid::HEAD_GROUP, Pid::USER_VELOCITY, Pid::PLAY, Pid::TUNING, Pid::FRET, Pid::STRING,
-                    Pid::GHOST, Pid::DEAD, Pid::HEAD_TYPE, Pid::FIXED, Pid::FIXED_LINE,
+                    Pid::HEAD_SCHEME, Pid::HEAD_GROUP, Pid::VELO_TYPE, Pid::USER_VELOCITY, Pid::PLAY, Pid::TUNING, Pid::FRET,
+                    Pid::STRING, Pid::GHOST, Pid::DEAD, Pid::HEAD_TYPE, Pid::FIXED, Pid::FIXED_LINE,
                     Pid::PLAYBACK_START_OFFSET, Pid::PLAYBACK_DURATION_OFFSET }) {
         writeProperty(item, xml, id);
     }

src/notation/CMakeLists.txt

@@ -37,6 +37,7 @@ target_sources(notation PRIVATE
     inotationselectionrange.h
     inotationautomation.h
     inotationnoteoffsets.h
+    inotationnotevelocity.h
     inotationinteraction.h
     inotationstyle.h
     inotationundostack.h
@@ -86,6 +87,8 @@ target_sources(notation PRIVATE
     internal/notationautomation.h
     internal/notationnoteoffsets.cpp
     internal/notationnoteoffsets.h
+    internal/notationnotevelocity.cpp
+    internal/notationnotevelocity.h
     internal/notationelements.cpp
     internal/notationelements.h
     internal/notationinteraction.cpp

src/notation/imasternotation.h

@@ -73,6 +73,7 @@ class IMasterNotation
 
     virtual INotationAutomationPtr automation() const = 0;
     virtual INotationNoteOffsetsPtr noteOffsets() const = 0;
+    virtual INotationNoteVelocityPtr noteVelocity() const = 0;
 };
 
 using IMasterNotationPtr = std::shared_ptr<IMasterNotation>;

src/notation/inotation_fwd.h

@@ -87,4 +87,7 @@ using INotationAutomationPtr = std::shared_ptr<INotationAutomation>;
 
 class INotationNoteOffsets;
 using INotationNoteOffsetsPtr = std::shared_ptr<INotationNoteOffsets>;
+
+class INotationNoteVelocity;
+using INotationNoteVelocityPtr = std::shared_ptr<INotationNoteVelocity>;
 }

src/notation/inotationnotevelocity.h

@@ -0,0 +1,39 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0-only
+ * MuseScore-Studio-CLA-applies
+ *
+ * MuseScore Studio
+ * Music Composition & Notation
+ *
+ * Copyright (C) 2026 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/>.
+ */
+
+#pragma once
+
+#include "async/notification.h"
+
+namespace mu::notation {
+class INotationNoteVelocity
+{
+public:
+    virtual ~INotationNoteVelocity() = default;
+
+    virtual bool isEditModeEnabled() const = 0;
+    virtual void setEditModeEnabled(bool enabled) = 0;
+    virtual muse::async::Notification editModeEnabledChanged() const = 0;
+};
+
+using INotationNoteVelocityPtr = std::shared_ptr<INotationNoteVelocity>;
+}

src/notation/inotationplayback.h

@@ -67,6 +67,10 @@ class INotationPlayback
     virtual muse::async::Channel<engraving::InstrumentTrackId> trackAdded() const = 0;
     virtual muse::async::Channel<engraving::InstrumentTrackId> trackRemoved() const = 0;
 
+    // Dynamic level (marking/hairpin only, no per-note override) that would apply at this tick,
+    // for use by UI that needs a musically-coherent baseline (e.g. a velocity editor).
+    virtual muse::mpe::dynamic_level_t appliableDynamicLevel(engraving::track_idx_t trackIdx, int tick) const = 0;
+
     virtual muse::audio::secs_t totalPlayTime() const = 0;
     virtual muse::async::Channel<muse::audio::secs_t> totalPlayTimeChanged() const = 0;
 

src/notation/internal/masternotation.cpp

@@ -52,6 +52,7 @@
 #include "masternotationparts.h"
 #include "notationautomation.h"
 #include "notationnoteoffsets.h"
+#include "notationnotevelocity.h"
 #include "types/scorecreateoptions.h"
 
 #ifdef MUE_BUILD_ENGRAVING_PLAYBACK
@@ -94,6 +95,7 @@ MasterNotation::MasterNotation(project::INotationProject* project, const muse::m
 
     m_notationAutomation = std::make_shared<NotationAutomation>(undoStack());
     m_notationNoteOffsets = std::make_shared<NotationNoteOffsets>();
+    m_notationNoteVelocity = std::make_shared<NotationNoteVelocity>();
 
     m_parts->partsChanged().onNotify(this, [this]() {
         notifyAboutNotationChanged();
@@ -773,6 +775,11 @@ INotationNoteOffsetsPtr MasterNotation::noteOffsets() const
     return m_notationNoteOffsets;
 }
 
+INotationNoteVelocityPtr MasterNotation::noteVelocity() const
+{
+    return m_notationNoteVelocity;
+}
+
 void MasterNotation::initNotationSoloMuteState(const INotationPtr notation)
 {
     IF_ASSERT_FAILED(notation) {

src/notation/internal/masternotation.h

@@ -75,6 +75,7 @@ class MasterNotation : public IMasterNotation, public Notation, public std::enab
 
     INotationAutomationPtr automation() const override;
     INotationNoteOffsetsPtr noteOffsets() const override;
+    INotationNoteVelocityPtr noteVelocity() const override;
 
 private:
     friend class project::NotationProject;
@@ -104,6 +105,7 @@ class MasterNotation : public IMasterNotation, public Notation, public std::enab
     INotationPlaybackPtr m_notationPlayback = nullptr;
     INotationAutomationPtr m_notationAutomation = nullptr;
     INotationNoteOffsetsPtr m_notationNoteOffsets = nullptr;
+    INotationNoteVelocityPtr m_notationNoteVelocity = nullptr;
     muse::async::Notification m_hasPartsChanged;
 
     mutable ExcerptNotationList m_potentialExcerpts;

src/notation/internal/notationnotevelocity.cpp

@@ -0,0 +1,44 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0-only
+ * MuseScore-Studio-CLA-applies
+ *
+ * MuseScore Studio
+ * Music Composition & Notation
+ *
+ * Copyright (C) 2026 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/>.
+ */
+
+#include "notationnotevelocity.h"
+
+using namespace mu::notation;
+
+bool NotationNoteVelocity::isEditModeEnabled() const
+{
+    return m_isEditModeEnabled;
+}
+
+void NotationNoteVelocity::setEditModeEnabled(bool enabled)
+{
+    if (m_isEditModeEnabled == enabled) {
+        return;
+    }
+    m_isEditModeEnabled = enabled;
+    m_editModeEnabledChanged.notify();
+}
+
+muse::async::Notification NotationNoteVelocity::editModeEnabledChanged() const
+{
+    return m_editModeEnabledChanged;
+}

src/notation/internal/notationnotevelocity.h

@@ -0,0 +1,40 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0-only
+ * MuseScore-Studio-CLA-applies
+ *
+ * MuseScore Studio
+ * Music Composition & Notation
+ *
+ * Copyright (C) 2026 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/>.
+ */
+#pragma once
+
+#include "../inotationnotevelocity.h"
+
+#include "async/notification.h"
+
+namespace mu::notation {
+class NotationNoteVelocity : public INotationNoteVelocity
+{
+public:
+    bool isEditModeEnabled() const override;
+    void setEditModeEnabled(bool enabled) override;
+    muse::async::Notification editModeEnabledChanged() const override;
+
+private:
+    bool m_isEditModeEnabled = false;
+    muse::async::Notification m_editModeEnabledChanged;
+};
+}

src/notation/internal/notationplayback.cpp

@@ -218,6 +218,11 @@ muse::async::Channel<InstrumentTrackId> NotationPlayback::trackRemoved() const
     return m_playbackModel.trackRemoved();
 }
 
+muse::mpe::dynamic_level_t NotationPlayback::appliableDynamicLevel(track_idx_t trackIdx, int tick) const
+{
+    return m_playbackModel.appliableDynamicLevel(trackIdx, tick);
+}
+
 void NotationPlayback::updateLoopBoundaries()
 {
     LoopBoundaries newBoundaries;

src/notation/internal/notationplayback.h

@@ -66,6 +66,8 @@ class NotationPlayback : public INotationPlayback, public muse::async::Asyncable
     muse::async::Channel<engraving::InstrumentTrackId> trackAdded() const override;
     muse::async::Channel<engraving::InstrumentTrackId> trackRemoved() const override;
 
+    muse::mpe::dynamic_level_t appliableDynamicLevel(engraving::track_idx_t trackIdx, int tick) const override;
+
     muse::audio::secs_t totalPlayTime() const override;
     muse::async::Channel<muse::audio::secs_t> totalPlayTimeChanged() const override;
 

src/notation/internal/notationplaybackstub.cpp

@@ -106,6 +106,11 @@ muse::async::Channel<InstrumentTrackId> NotationPlaybackStub::trackRemoved() con
     return muse::async::Channel<InstrumentTrackId>();
 }
 
+muse::mpe::dynamic_level_t NotationPlaybackStub::appliableDynamicLevel(track_idx_t, int) const
+{
+    return muse::mpe::dynamicLevelFromType(muse::mpe::DynamicType::Natural);
+}
+
 muse::audio::secs_t NotationPlaybackStub::totalPlayTime() const
 {
     return muse::audio::secs_t();

src/notation/internal/notationplaybackstub.h

@@ -52,6 +52,8 @@ class NotationPlaybackStub : public INotationPlayback
     muse::async::Channel<engraving::InstrumentTrackId> trackAdded() const override;
     muse::async::Channel<engraving::InstrumentTrackId> trackRemoved() const override;
 
+    muse::mpe::dynamic_level_t appliableDynamicLevel(engraving::track_idx_t trackIdx, int tick) const override;
+
     muse::audio::secs_t totalPlayTime() const override;
     muse::async::Channel<muse::audio::secs_t> totalPlayTimeChanged() const override;
 

src/notationscene/inotationcommandscontroller.h

@@ -92,6 +92,9 @@ class INotationCommandsController : MODULE_CONTEXT_INTERFACE
     virtual bool isNoteOffsetEditModeEnabled() const = 0;
     virtual muse::async::Notification noteOffsetEditModeEnabledChanged() const = 0;
 
+    virtual bool isNoteVelocityEditModeEnabled() const = 0;
+    virtual muse::async::Notification noteVelocityEditModeEnabledChanged() const = 0;
+
     virtual bool isDebuggingCommandEnabled(const muse::rcommand::Command& command) const = 0;
     virtual muse::async::Notification debuggingOptionsChanged() const = 0;
 };