Add drag-handle overlay to edit per-note playback start/duration offsets

src/notation/CMakeLists.txt

@@ -36,6 +36,7 @@ target_sources(notation PRIVATE
     inotationselectionfilter.h
     inotationselectionrange.h
     inotationautomation.h
+    inotationnoteoffsets.h
     inotationinteraction.h
     inotationstyle.h
     inotationundostack.h
@@ -83,6 +84,8 @@ target_sources(notation PRIVATE
     internal/notationcontextconfiguration.h
     internal/notationautomation.cpp
     internal/notationautomation.h
+    internal/notationnoteoffsets.cpp
+    internal/notationnoteoffsets.h
     internal/notationelements.cpp
     internal/notationelements.h
     internal/notationinteraction.cpp

src/notation/imasternotation.h

@@ -72,6 +72,7 @@ class IMasterNotation
     virtual void initNotationSoloMuteState(const INotationPtr notation) = 0;
 
     virtual INotationAutomationPtr automation() const = 0;
+    virtual INotationNoteOffsetsPtr noteOffsets() const = 0;
 };
 
 using IMasterNotationPtr = std::shared_ptr<IMasterNotation>;

src/notation/inotation_fwd.h

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

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/internal/masternotation.cpp

@@ -51,6 +51,7 @@
 #include "excerptnotation.h"
 #include "masternotationparts.h"
 #include "notationautomation.h"
+#include "notationnoteoffsets.h"
 #include "types/scorecreateoptions.h"
 
 #ifdef MUE_BUILD_ENGRAVING_PLAYBACK
@@ -92,6 +93,7 @@ MasterNotation::MasterNotation(project::INotationProject* project, const muse::m
 #endif
 
     m_notationAutomation = std::make_shared<NotationAutomation>(undoStack());
+    m_notationNoteOffsets = std::make_shared<NotationNoteOffsets>();
 
     m_parts->partsChanged().onNotify(this, [this]() {
         notifyAboutNotationChanged();
@@ -766,6 +768,11 @@ INotationAutomationPtr MasterNotation::automation() const
     return m_notationAutomation;
 }
 
+INotationNoteOffsetsPtr MasterNotation::noteOffsets() const
+{
+    return m_notationNoteOffsets;
+}
+
 void MasterNotation::initNotationSoloMuteState(const INotationPtr notation)
 {
     IF_ASSERT_FAILED(notation) {

src/notation/internal/masternotation.h

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

src/notation/internal/notationnoteoffsets.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 "notationnoteoffsets.h"
+
+using namespace mu::notation;
+
+bool NotationNoteOffsets::isEditModeEnabled() const
+{
+    return m_isEditModeEnabled;
+}
+
+void NotationNoteOffsets::setEditModeEnabled(bool enabled)
+{
+    if (m_isEditModeEnabled == enabled) {
+        return;
+    }
+    m_isEditModeEnabled = enabled;
+    m_editModeEnabledChanged.notify();
+}
+
+muse::async::Notification NotationNoteOffsets::editModeEnabledChanged() const
+{
+    return m_editModeEnabledChanged;
+}

src/notation/internal/notationnoteoffsets.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 "../inotationnoteoffsets.h"
+
+#include "async/notification.h"
+
+namespace mu::notation {
+class NotationNoteOffsets : public INotationNoteOffsets
+{
+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/notationscene/inotationcommandscontroller.h

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

src/notationscene/internal/notationactioncontroller.cpp

@@ -31,6 +31,7 @@
 #include "engraving/dom/harmony.h"
 #include "engraving/dom/masterscore.h"
 #include "engraving/dom/note.h"
+#include "engraving/dom/property.h"
 #include "engraving/dom/chord.h"
 #include "engraving/dom/text.h"
 #include "engraving/dom/sig.h"
@@ -39,6 +40,7 @@
 #include "notation/imasternotation.h"
 #include "notation/inotation.h"
 #include "notation/inotationautomation.h" // IWYU pragma: keep
+#include "notation/inotationnoteoffsets.h" // IWYU pragma: keep
 #include "notation/inotationelements.h"
 #include "notation/inotationmidiinput.h"
 #include "notation/inotationnoteinput.h"
@@ -581,6 +583,8 @@ void NotationActionController::init()
 
     registerCommand(TOGGLE_AUTOMATION_COMMAND, &Controller::toggleAutomation);
     registerQueryCommand(SELECT_AUTOMATION_TYPE_COMMAND, &Controller::selectAutomationType);
+    registerCommand(TOGGLE_NOTE_OFFSET_EDITOR_COMMAND, &Controller::toggleNoteOffsetEditor);
+    registerCommand(RESET_NOTE_OFFSETS_COMMAND, &Controller::resetNoteOffsets);
 
     // TAB
     registerCommand(SET_DURATION_WHOLE_TAB_COMMAND, [this]() { setDuration(DurationType::V_WHOLE); });
@@ -1052,6 +1056,7 @@ void NotationActionController::init()
             { "scoop", ADD_SCOOP_COMMAND, {} },
             { "hammer-on-pull-off", ADD_HAMMER_ON_PULL_OFF_COMMAND, {} },
             { "toggle-automation", TOGGLE_AUTOMATION_COMMAND, {} },
+            { "toggle-note-offset-editor", TOGGLE_NOTE_OFFSET_EDITOR_COMMAND, {} },
             { "string-up", GOTO_STRING_ABOVE_COMMAND, {} },
             { "string-down", GOTO_STRING_BELOW_COMMAND, {} },
             { "move-up", MOVE_UP_COMMAND, {} },
@@ -1129,6 +1134,10 @@ void NotationActionController::init()
                 masterNotation->automation()->automationModeEnabledChanged().onNotify(this, [this]() {
                     m_automationModeEnabledChanged.notify();
                 }, Asyncable::Mode::SetReplace);
+
+                masterNotation->noteOffsets()->editModeEnabledChanged().onNotify(this, [this]() {
+                    m_noteOffsetEditModeEnabledChanged.notify();
+                }, Asyncable::Mode::SetReplace);
             }
         }
 
@@ -3187,6 +3196,16 @@ bool NotationActionController::isAutomationModeEnabled() const
     return currentMasterNotation() ? currentMasterNotation()->automation()->isAutomationModeEnabled() : false;
 }
 
+bool NotationActionController::isNoteOffsetEditModeEnabled() const
+{
+    return currentMasterNotation() ? currentMasterNotation()->noteOffsets()->isEditModeEnabled() : false;
+}
+
+muse::async::Notification NotationActionController::noteOffsetEditModeEnabledChanged() const
+{
+    return m_noteOffsetEditModeEnabledChanged;
+}
+
 muse::async::Notification NotationActionController::automationModeEnabledChanged() const
 {
     return m_automationModeEnabledChanged;
@@ -3259,6 +3278,42 @@ void NotationActionController::toggleAutomation()
     masterNotation->automation()->setAutomationModeEnabled(!isEnabled);
 }
 
+void NotationActionController::toggleNoteOffsetEditor()
+{
+    TRACEFUNC;
+
+    IMasterNotationPtr masterNotation = currentMasterNotation();
+    if (!masterNotation) {
+        return;
+    }
+
+    const bool isEnabled = masterNotation->noteOffsets()->isEditModeEnabled();
+    masterNotation->noteOffsets()->setEditModeEnabled(!isEnabled);
+}
+
+void NotationActionController::resetNoteOffsets()
+{
+    TRACEFUNC;
+
+    INotationSelectionPtr selection = currentNotationSelection();
+    std::vector<Note*> notes = selection ? selection->notes() : std::vector<Note*>();
+    if (notes.empty()) {
+        return;
+    }
+
+    INotationUndoStackPtr undoStack = currentNotationUndoStack();
+    if (!undoStack) {
+        return;
+    }
+
+    undoStack->prepareChanges(TranslatableString("undoableAction", "Reset note offsets"));
+    for (Note* note : notes) {
+        note->undoChangeProperty(Pid::PLAYBACK_START_OFFSET, 0, mu::engraving::PropertyFlags::NOSTYLE);
+        note->undoChangeProperty(Pid::PLAYBACK_DURATION_OFFSET, 0, mu::engraving::PropertyFlags::NOSTYLE);
+    }
+    undoStack->commitChanges();
+}
+
 muse::Ret NotationActionController::selectAutomationType(const muse::rcommand::CommandQuery& query)
 {
     const std::string type = query.param("type").toString();

src/notationscene/internal/notationactioncontroller.h

@@ -118,6 +118,9 @@ class NotationActionController : public INotationCommandsController, public muse
     bool isAutomationModeEnabled() const override;
     muse::async::Notification automationModeEnabledChanged() const override;
 
+    bool isNoteOffsetEditModeEnabled() const override;
+    muse::async::Notification noteOffsetEditModeEnabledChanged() const override;
+
     bool isDebuggingCommandEnabled(const muse::rcommand::Command& command) const override;
     muse::async::Notification debuggingOptionsChanged() const override;
 
@@ -269,6 +272,8 @@ class NotationActionController : public INotationCommandsController, public muse
 
     void toggleAutomation();
     muse::Ret selectAutomationType(const muse::rcommand::CommandQuery& query);
+    void toggleNoteOffsetEditor();
+    void resetNoteOffsets();
 
     // commands
     void registerCommand(const muse::rcommand::Command&, std::function<void()>);
@@ -311,6 +316,7 @@ class NotationActionController : public INotationCommandsController, public muse
     muse::async::Channel<ScoreConfigType> m_scoreConfigChanged;
     muse::async::Notification m_currentNotationStyleChanged;
     muse::async::Notification m_automationModeEnabledChanged;
+    muse::async::Notification m_noteOffsetEditModeEnabledChanged;
 
     using IsActionEnabledFunc = std::function<bool ()>;
     std::map<muse::actions::ActionCode, IsActionEnabledFunc> m_isEnabledMap;

src/notationscene/internal/notationcommandsregister.cpp

@@ -2914,6 +2914,20 @@ static const std::vector<CommandInfo> s_commandInfos = {
         InputSchema(),
         Decoration(IconCode::Code::AUTOMATION, rcommand::Checkable::Yes)
     },
+    CommandInfo {
+        TOGGLE_NOTE_OFFSET_EDITOR_COMMAND,
+        TranslatableString("action", "Note offsets"),
+        TranslatableString("action", "Toggle note offset editor"),
+        InputSchema(),
+        Decoration(IconCode::Code::CLOCK, rcommand::Checkable::Yes)
+    },
+    CommandInfo {
+        RESET_NOTE_OFFSETS_COMMAND,
+        TranslatableString("action", "Reset note offsets"),
+        TranslatableString("action", "Reset note offsets"),
+        InputSchema(),
+        Decoration()
+    },
     CommandInfo {
         SELECT_AUTOMATION_TYPE_COMMAND,
         TranslatableString::untranslatable("Automation type"),

src/notationscene/internal/notationcommandsstate.cpp

@@ -349,6 +349,10 @@ void NotationCommandsState::init()
         updateCommandStates({ TOGGLE_AUTOMATION_COMMAND });
     });
 
+    controller()->noteOffsetEditModeEnabledChanged().onNotify(this, [this]() {
+        updateCommandStates({ TOGGLE_NOTE_OFFSET_EDITOR_COMMAND });
+    });
+
     controller()->debuggingOptionsChanged().onNotify(this, [this]() {
         updateCommandStates(DEBUG_COMMANDS);
     });
@@ -489,6 +493,10 @@ CommandState NotationCommandsState::doCommandState(const Command& command) const
         return CommandState(true, controller()->isAutomationModeEnabled());
     }
 
+    if (command == TOGGLE_NOTE_OFFSET_EDITOR_COMMAND) {
+        return CommandState(true, controller()->isNoteOffsetEditModeEnabled());
+    }
+
     if (muse::contains(DEBUG_COMMANDS, command)) {
         return CommandState(true, controller()->isDebuggingCommandEnabled(command));
     }