Add drag-handle overlay to edit per-note velocities

src/engraving/api/v1/elements.h

@@ -1426,6 +1426,11 @@ class Note : public EngravingItem
     /// The tuning of this note, in cents.
     API_PROPERTY_T(qreal,  tuning,        TUNING)
 
+    /// The start time offset for playback, in ticks.
+    API_PROPERTY_T(int, playbackStartOffset, PLAYBACK_START_OFFSET)
+    /// The duration offset for playback, in ticks.
+    API_PROPERTY_T(int, playbackDurationOffset, PLAYBACK_DURATION_OFFSET)
+
     /// For notes on non-tab staves: the line this note is on.
     API_PROPERTY_T(int,    line,          LINE)
     /// For notes on non-tab staves: Whether this note is

src/engraving/dom/note.cpp

@@ -738,6 +738,8 @@ Note::Note(const Note& n, bool link)
     m_harmonic          = n.m_harmonic;
     m_hasParens         = n.m_hasParens;
     m_hideGeneratedParens = n.m_hideGeneratedParens;
+    m_playbackStartOffset = n.m_playbackStartOffset;
+    m_playbackDurationOffset = n.m_playbackDurationOffset;
 
     if (n.m_accidental) {
         add(new Accidental(*(n.m_accidental)));
@@ -3134,6 +3136,10 @@ PropertyValue Note::getProperty(Pid propertyId) const
         return fixed();
     case Pid::FIXED_LINE:
         return fixedLine();
+    case Pid::PLAYBACK_START_OFFSET:
+        return m_playbackStartOffset;
+    case Pid::PLAYBACK_DURATION_OFFSET:
+        return m_playbackDurationOffset;
     case Pid::HAS_PARENTHESES:
         return m_hasParens ? ParenthesesMode::BOTH : ParenthesesMode::NONE;
     case Pid::HIDE_GENERATED_PARENTHESES:
@@ -3242,6 +3248,12 @@ bool Note::setProperty(Pid propertyId, const PropertyValue& v)
     case Pid::FIXED_LINE:
         setFixedLine(v.toInt());
         break;
+    case Pid::PLAYBACK_START_OFFSET:
+        setPlaybackStartOffset(v.toInt());
+        break;
+    case Pid::PLAYBACK_DURATION_OFFSET:
+        setPlaybackDurationOffset(v.toInt());
+        break;
     case Pid::HAS_PARENTHESES:
         if (v.value<ParenthesesMode>() != ParenthesesMode::BOTH && v.value<ParenthesesMode>() != ParenthesesMode::NONE) {
             ASSERT_X("Notes cannot set left & right parens individually");
@@ -3308,6 +3320,10 @@ PropertyValue Note::propertyDefault(Pid propertyId) const
         return 0;
     case Pid::TPC2:
         return getProperty(Pid::TPC1);
+    case Pid::PLAYBACK_START_OFFSET:
+        return 0;
+    case Pid::PLAYBACK_DURATION_OFFSET:
+        return 0;
     case Pid::PITCH:
     case Pid::TPC1:
         return PropertyValue();

src/engraving/dom/note.h

@@ -434,6 +434,12 @@ class Note final : public EngravingItem
     bool isTrillCueNote() const { return m_isTrillCueNote; }
     void setIsTrillCueNote(bool v);
 
+    int playbackStartOffset() const { return m_playbackStartOffset; }
+    void setPlaybackStartOffset(int offset) { m_playbackStartOffset = offset; }
+
+    int playbackDurationOffset() const { return m_playbackDurationOffset; }
+    void setPlaybackDurationOffset(int offset) { m_playbackDurationOffset = offset; }
+
     SymId noteHead() const;
     bool isNoteName() const;
 
@@ -561,5 +567,8 @@ class Note final : public EngravingItem
 
     std::vector<LineAttachPoint> m_lineAttachPoints;
     TieJumpPointList m_jumpPoints { this };
+
+    int m_playbackStartOffset = 0;  // offset in ticks to add to chord's tick for playback start
+    int m_playbackDurationOffset = 0; // offset in ticks to add to chord's ticks for playback duration
 };
 } // namespace mu::engraving

src/engraving/dom/property.cpp

@@ -519,6 +519,9 @@ static constexpr PropertyMetaData propertyList[] = {
 
     { Pid::SHARED_PART_ENABLED,                 P_TYPE::BOOL,                      PropertyGroup::NONE,       false, "sharedPartEnabled",               QT_TRANSLATE_NOOP("engraving/propertyName", "shared part enabled") },
 
+    { Pid::PLAYBACK_START_OFFSET,               P_TYPE::INT,                       PropertyGroup::APPEARANCE, false, "playbackStartOffset",             QT_TRANSLATE_NOOP("engraving/propertyName", "playback start offset") },
+    { Pid::PLAYBACK_DURATION_OFFSET,            P_TYPE::INT,                       PropertyGroup::APPEARANCE, false, "playbackDurationOffset",          QT_TRANSLATE_NOOP("engraving/propertyName", "playback duration offset") },
+
     { Pid::END,                                 P_TYPE::INT,                       PropertyGroup::NONE,       false, "++end++",                         nullptr }
 };
 /* *INDENT-ON* */

src/engraving/dom/property.h

@@ -528,6 +528,9 @@ enum class Pid : short {
 
     SHARED_PART_ENABLED,
 
+    PLAYBACK_START_OFFSET,
+    PLAYBACK_DURATION_OFFSET,
+
     END
 };
 

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/playback/renderers/noterenderer.cpp

@@ -128,6 +128,26 @@ void NoteRenderer::render(const Note* note, const RenderingContext& ctx, mpe::Pl
         return;
     }
 
+    if (note->playbackStartOffset() != 0 || note->playbackDurationOffset() != 0) {
+        // playbackStartOffset()/playbackDurationOffset() are ticks relative to the note's own
+        // nominal position - apply them on top of ctx's nominal tick range rather than
+        // recomputing from the chord's own tick()/ticks(). The chord's tick()/ticks() are its
+        // notated position/duration, which for a grace note or a note inside a repeated section
+        // is NOT the same as when/how long it actually plays - ctx.nominalPositionStartTick/
+        // nominalPositionEndTick already reflect that (see GraceChordCtx::buildCtx), whereas
+        // chord->tick() would collapse a grace note's "before the beat" timing back to the
+        // principal note's tick.
+        const int nominalStartTick = ctx.nominalPositionStartTick;
+        const int nominalEndTick = ctx.nominalPositionEndTick + note->playbackDurationOffset();
+        const int effectiveStartTick = std::max(0, nominalStartTick + note->playbackStartOffset());
+        const int effectiveDurationTicks = std::max(1, nominalEndTick - effectiveStartTick);
+
+        auto effectiveTnD = timestampAndDurationFromStartAndDurationTicks(ctx.score, effectiveStartTick, effectiveDurationTicks,
+                                                                          ctx.positionTickOffset);
+        noteCtx.timestamp = effectiveTnD.timestamp;
+        noteCtx.duration = effectiveTnD.duration;
+    }
+
     const Tie* tieFor = note->tieFor();
     if (tieFor && tieFor->playSpanner()) {
         if (tieFor->isPartialTie()) {

src/engraving/rw/read500/tread.cpp

@@ -3470,6 +3470,8 @@ bool TRead::readProperties(Note* n, XmlReader& e, ReadContext& ctx)
     } else if (tag == "overrideBendVisibilityRules") {
         n->setOverrideBendVisibilityRules(e.readBool());
     } else if (TRead::readProperty(n, tag, e, ctx, Pid::HIDE_GENERATED_PARENTHESES)) {
+    } else if (TRead::readProperty(n, tag, e, ctx, Pid::PLAYBACK_START_OFFSET)) {
+    } else if (TRead::readProperty(n, tag, e, ctx, Pid::PLAYBACK_DURATION_OFFSET)) {
     } else if (readItemProperties(n, e, ctx)) {
     } else {
         return false;

src/engraving/rw/write/twrite.cpp

@@ -2505,8 +2505,9 @@ 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/engraving/tests/note_tests.cpp

@@ -149,6 +149,14 @@ TEST_F(Engraving_NoteTests, note)
     EXPECT_EQ(n->userVelocity(), 71);
     delete n;
 
+    // playback start/duration offset
+    note->setPlaybackStartOffset(120);
+    note->setPlaybackDurationOffset(-60);
+    n = toNote(ScoreRW::writeReadElement(note));
+    EXPECT_EQ(n->playbackStartOffset(), 120);
+    EXPECT_EQ(n->playbackDurationOffset(), -60);
+    delete n;
+
     // tuning
     note->setTuning(1.3);
     n = toNote(ScoreRW::writeReadElement(note));

src/notation/CMakeLists.txt

@@ -36,6 +36,8 @@ target_sources(notation PRIVATE
     inotationselectionfilter.h
     inotationselectionrange.h
     inotationautomation.h
+    inotationnoteoffsets.h
+    inotationnotevelocity.h
     inotationinteraction.h
     inotationstyle.h
     inotationundostack.h
@@ -83,6 +85,10 @@ target_sources(notation PRIVATE
     internal/notationcontextconfiguration.h
     internal/notationautomation.cpp
     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

@@ -72,6 +72,8 @@ class IMasterNotation
     virtual void initNotationSoloMuteState(const INotationPtr notation) = 0;
 
     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

@@ -84,4 +84,10 @@ using INotationPlaybackPtr = std::shared_ptr<INotationPlayback>;
 
 class INotationAutomation;
 using INotationAutomationPtr = std::shared_ptr<INotationAutomation>;
+
+class INotationNoteOffsets;
+using INotationNoteOffsetsPtr = std::shared_ptr<INotationNoteOffsets>;
+
+class INotationNoteVelocity;
+using INotationNoteVelocityPtr = std::shared_ptr<INotationNoteVelocity>;
 }

src/notation/inotationnoteoffsets.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 INotationNoteOffsets
+{
+public:
+    virtual ~INotationNoteOffsets() = default;
+
+    virtual bool isEditModeEnabled() const = 0;
+    virtual void setEditModeEnabled(bool enabled) = 0;
+    virtual muse::async::Notification editModeEnabledChanged() const = 0;
+};
+
+using INotationNoteOffsetsPtr = std::shared_ptr<INotationNoteOffsets>;
+}

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

@@ -51,6 +51,8 @@
 #include "excerptnotation.h"
 #include "masternotationparts.h"
 #include "notationautomation.h"
+#include "notationnoteoffsets.h"
+#include "notationnotevelocity.h"
 #include "types/scorecreateoptions.h"
 
 #ifdef MUE_BUILD_ENGRAVING_PLAYBACK
@@ -92,6 +94,8 @@ MasterNotation::MasterNotation(project::INotationProject* project, const muse::m
 #endif
 
     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();
@@ -766,6 +770,16 @@ INotationAutomationPtr MasterNotation::automation() const
     return m_notationAutomation;
 }
 
+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

@@ -74,6 +74,8 @@ class MasterNotation : public IMasterNotation, public Notation, public std::enab
     void initNotationSoloMuteState(const INotationPtr notation) override;
 
     INotationAutomationPtr automation() const override;
+    INotationNoteOffsetsPtr noteOffsets() const override;
+    INotationNoteVelocityPtr noteVelocity() const override;
 
 private:
     friend class project::NotationProject;
@@ -102,6 +104,8 @@ class MasterNotation : public IMasterNotation, public Notation, public std::enab
     muse::async::Notification m_excerptsChanged;
     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;