Porting some PRs to 4.5.0 (2)

src/engraving/dom/cmd.cpp

@@ -1809,7 +1809,7 @@ void Score::changeCRlen(ChordRest* cr, const Fraction& dstF, bool fillWithRest)
     connectTies();
 
     if (elementToSelect) {
-        if (containsElement(elementToSelect)) {
+        if (canReselectItem(elementToSelect)) {
             select(elementToSelect, SelectType::SINGLE, 0);
         }
     }

src/engraving/dom/score.cpp

@@ -1816,21 +1816,20 @@ void Score::doUndoRemoveElement(EngravingItem* element)
     }
 }
 
-bool Score::containsElement(const EngravingItem* element) const
+bool Score::canReselectItem(const EngravingItem* item) const
 {
-    if (!element) {
+    if (!item || item->selected()) {
         return false;
     }
 
-    EngravingItem* parent = element->parentItem();
-    if (!parent) {
-        return false;
+    EngravingItem* seg = const_cast<EngravingItem*>(item->findAncestor(ElementType::SEGMENT));
+    if (seg) {
+        std::vector<EngravingItem*> elements;
+        seg->scanElements(&elements, collectElements, false /*all*/);
+        return muse::contains(elements, const_cast<EngravingItem*>(item));
     }
 
-    std::vector<EngravingItem*> elements;
-    parent->scanElements(&elements, collectElements, false /*all*/);
-
-    return std::find(elements.cbegin(), elements.cend(), element) != elements.cend();
+    return true;
 }
 
 //---------------------------------------------------------
@@ -3219,7 +3218,7 @@ void Score::padToggle(Pad p, bool toggleForSelectionOnly)
                     }
 
                     for (const NoteVal& nval : m_is.notes()) {
-                        if (chordContainsNoteVal(chord, nval)) {
+                        if (chord && chord->findNote(nval.pitch)) {
                             continue;
                         }
 
@@ -3317,6 +3316,22 @@ void Score::padToggle(Pad p, bool toggleForSelectionOnly)
         }
     }
 
+    const int dots = m_is.duration().dots();
+
+    if (toggleForSelectionOnly && dots > 0 && !crs.empty()) {
+        bool shouldRemoveDots = true;
+        for (const ChordRest* cr : crs) {
+            if (dots != cr->dots()) {
+                shouldRemoveDots = false;
+                break;
+            }
+        }
+
+        if (shouldRemoveDots) {
+            m_is.setDots(0);
+        }
+    }
+
     for (ChordRest* cr : crs) {
         if (cr->isChord() && (toChord(cr)->isGrace())) {
             //
@@ -3331,10 +3346,11 @@ void Score::padToggle(Pad p, bool toggleForSelectionOnly)
     if (!elementsToSelect.empty()) {
         std::vector<EngravingItem*> selectList;
         for (EngravingItem* e : elementsToSelect) {
-            if (e && !e->selected()) {
+            if (canReselectItem(e)) {
                 selectList.push_back(e);
             }
         }
+
         select(selectList, SelectType::ADD, 0);
         selection().updateSelectedElements();
     }
@@ -3343,8 +3359,11 @@ void Score::padToggle(Pad p, bool toggleForSelectionOnly)
         m_is.setDuration(oldDuration);
         m_is.setRest(oldRest);
         m_is.setAccidentalType(oldAccidentalType);
+
         if (noteEntryMode()) {
-            m_is.moveToNextInputPos();
+            if (m_is.lastSegment() == m_is.segment()) {
+                m_is.moveToNextInputPos();
+            }
         }
     }
 }

src/engraving/dom/score.h

@@ -514,7 +514,6 @@ class Score : public EngravingObject, public muse::Injectable
     void doUndoAddElement(EngravingItem*);
     void removeElement(EngravingItem*);
     void doUndoRemoveElement(EngravingItem*);
-    bool containsElement(const EngravingItem*) const;
 
     Note* addPitch(NoteVal&, bool addFlag, InputState* externalInputState = nullptr);
     Note* addMidiPitch(int pitch, bool addFlag, bool allowTransposition);
@@ -1085,6 +1084,8 @@ class Score : public EngravingObject, public muse::Injectable
     void selectAdd(EngravingItem* e);
     void selectRange(EngravingItem* e, staff_idx_t staffIdx);
 
+    bool canReselectItem(const EngravingItem* item) const;
+
     bool trySelectSimilarInRange(EngravingItem* e);
     bool tryExtendSingleSelectionToRange(EngravingItem* e, staff_idx_t staffIdx);
 

src/engraving/dom/utils.cpp

@@ -1708,19 +1708,4 @@ bool segmentsAreAdjacentInRepeatStructure(const Segment* firstSeg, const Segment
 
     return true;
 }
-
-bool chordContainsNoteVal(const Chord* chord, const NoteVal& nval)
-{
-    if (!chord) {
-        return false;
-    }
-
-    for (const Note* note : chord->notes()) {
-        if (note->noteVal() == nval) {
-            return true;
-        }
-    }
-
-    return false;
-}
 }

src/engraving/dom/utils.h

@@ -117,6 +117,4 @@ extern std::vector<Measure*> findFollowingRepeatMeasures(const Measure* measure)
 extern std::vector<Measure*> findPreviousRepeatMeasures(const Measure* measure);
 extern bool repeatHasPartialLyricLine(const Measure* endRepeatMeasure);
 extern bool segmentsAreAdjacentInRepeatStructure(const Segment* firstSeg, const Segment* secondSeg);
-
-extern bool chordContainsNoteVal(const Chord* chord, const NoteVal& nval);
 } // namespace mu::engraving

src/engraving/playback/playbackmodel.cpp

@@ -717,7 +717,9 @@ void PlaybackModel::clearExpiredEvents(const int tickFrom, const int tickTo, con
         int removeEventsFromTick = std::max(tickFrom, repeatStartTick);
         timestamp_t removeEventsFrom = timestampFromTicks(m_score, removeEventsFromTick + tickPositionOffset);
 
-        int removeEventsToTick = std::min(tickTo, repeatEndTick);
+        //! NOTE: the end tick of the current repeat segment == the start tick of the next repeat segment
+        //! so subtract 1 to avoid removing events belonging to the next segment
+        int removeEventsToTick = std::min(tickTo, repeatEndTick - 1);
         timestamp_t removeEventsTo = timestampFromTicks(m_score, removeEventsToTick + tickPositionOffset);
 
         removeEventsFromRange(trackFrom, trackTo, removeEventsFrom, removeEventsTo);

src/engraving/tests/playback/playbackmodel_tests.cpp

@@ -845,22 +845,33 @@ TEST_F(Engraving_PlaybackModelTests, SimpleRepeat_Changes_Notification)
     model.load(score);
 
     PlaybackData result = model.resolveTrackPlaybackData(part->id(), part->instrumentId());
+    EXPECT_EQ(result.originEvents.size(), expectedChangedEventsCount);
 
     // [THEN] Updated events map will match our expectations
     result.mainStream.onReceive(this, [expectedChangedEventsCount](const PlaybackEventsMap& updatedEvents, const DynamicLevelLayers&,
                                                                    const PlaybackParamLayers&) {
         EXPECT_EQ(updatedEvents.size(), expectedChangedEventsCount);
     });
 
-    // [WHEN] Notation has been changed
+    // [WHEN] Score has been changed: the range starts ouside the repeat and ends inside it
     ScoreChangesRange range;
-    range.tickFrom = 480; // 2nd note of the 1st measure
+    range.tickFrom = 480; // 2nd note of the 1st measure (outside the repeat)
     range.tickTo = 3840; // 1st note of the 3rd measure (inside the repeat)
     range.staffIdxFrom = 0;
     range.staffIdxTo = 0;
     range.changedTypes = { ElementType::NOTE };
 
     score->changesChannel().send(range);
+
+    // [WHEN] Score has been changed: the range is inside the repeat and tickTo == the end tick of the repeat
+    // See: https://github.com/musescore/MuseScore/issues/25899
+    range.tickFrom = 4800; // 3rd note of the 3rd measure (inside the repeat)
+    range.tickTo = 5760; // end tick of the repeat
+    range.staffIdxFrom = 0;
+    range.staffIdxTo = 0;
+    range.changedTypes = { ElementType::PEDAL };
+
+    score->changesChannel().send(range);
 }
 
 /**

src/framework/audio/audioutils.h

@@ -59,6 +59,15 @@ inline String audioSourceName(const AudioInputParams& params)
     return String::fromStdString(params.resourceMeta.id);
 }
 
+inline String audioSourcePackName(const AudioInputParams& params)
+{
+    if (params.type() == AudioSourceType::MuseSampler) {
+        return params.resourceMeta.attributeVal(u"musePack");
+    }
+
+    return String();
+}
+
 inline String audioSourceCategoryName(const AudioInputParams& params)
 {
     if (params.type() == AudioSourceType::MuseSampler) {

src/framework/shortcuts/view/mididevicemappingmodel.cpp

@@ -56,6 +56,7 @@ inline ActionCodeList allMidiActions()
         "pad-note-32",
         "pad-note-64",
         "undo",
+        "rest",
         "pad-rest",
         "tie",
         "pad-dot",

src/framework/vst/internal/vstplugininstance.h

@@ -71,7 +71,7 @@ class VstPluginInstance : public IVstPluginInstance, public async::Asyncable
 
     async::Notification loadingCompleted() const override;
 
-    async::Channel<muse::audio::AudioUnitConfig> pluginSettingsChanged() const;
+    async::Channel<muse::audio::AudioUnitConfig> pluginSettingsChanged() const override;
 
 private:
     void rescanParams();

src/instrumentsscene/view/layoutpaneltreemodel.cpp

@@ -455,8 +455,6 @@ void LayoutPanelTreeModel::addSystemMarkings()
     if (const Staff* staff = resolveNewSystemObjectStaff()) {
         m_masterNotation->parts()->addSystemObjects({ staff->id() });
     }
-
-    updateIsAddingSystemMarkingsAvailable();
 }
 
 void LayoutPanelTreeModel::moveSelectedRowsUp()
@@ -1104,6 +1102,8 @@ void LayoutPanelTreeModel::updateSystemObjectLayers()
             break;
         }
     }
+
+    updateIsAddingSystemMarkingsAvailable();
 }
 
 const PartTreeItem* LayoutPanelTreeModel::findPartItemByStaff(const Staff* staff) const

src/notation/internal/notationinteraction.cpp

@@ -5053,6 +5053,18 @@ void NotationInteraction::putRestToSelection()
 
     if (is.usingNoteEntryMethod(NoteEntryMethod::BY_DURATION) || is.usingNoteEntryMethod(NoteEntryMethod::RHYTHM)) {
         m_noteInput->padNote(Pad::REST);
+    } else if (is.usingNoteEntryMethod(NoteEntryMethod::REPITCH)) {
+        ChordRest* cr = is.cr();
+        if (cr) {
+            TDuration duration = cr->durationType();
+            if (duration.isValid() && !duration.isZero()) {
+                if (duration.isMeasure()) {
+                    is.moveToNextInputPos();
+                } else {
+                    putRest(duration);
+                }
+            }
+        }
     } else {
         putRest(is.duration());
     }

src/notation/internal/notationnoteinput.cpp

@@ -855,7 +855,14 @@ void NotationNoteInput::updateInputState()
 {
     TRACEFUNC;
 
-    score()->inputState().update(score()->selection());
+    NoteInputState& is = score()->inputState();
+    is.update(score()->selection());
+
+    if (!configuration()->addAccidentalDotsArticulationsToNextNoteEntered()) {
+        is.setAccidentalType(AccidentalType::NONE);
+        is.setDots(0);
+        is.setArticulationIds({});
+    }
 
     notifyAboutStateChanged();
 }

src/notation/internal/notationuiactions.cpp

@@ -1109,7 +1109,8 @@ const UiActionList NotationUiActions::m_actions = {
              mu::context::UiCtxProjectOpened,
              mu::context::CTX_NOTATION_NOT_NOTE_INPUT_STAFF_TAB,
              TranslatableString("action", "Rest"),
-             TranslatableString("action", "Enter rest")
+             TranslatableString("action", "Enter rest"),
+             IconCode::Code::REST
              ),
     UiAction("rest-TAB",
              mu::context::UiCtxProjectOpened,

src/notation/view/percussionpanel/percussionpanelmodel.cpp

@@ -357,15 +357,25 @@ void PercussionPanelModel::updateSoundTitle(const InstrumentTrackId& trackId)
     }
 
     const audio::AudioInputParams& params = audioSettings()->trackInputParams(trackId);
-
     const QString name = muse::audio::audioSourceName(params).toQString();
-    const QString category = muse::audio::audioSourceCategoryName(params).toQString();
-    if (name.isEmpty() || category.isEmpty()) {
+    if (name.isEmpty()) {
         setSoundTitle(QString());
         return;
     }
 
-    setSoundTitle(category + ": " + name);
+    const QString pack = muse::audio::audioSourcePackName(params).toQString();
+    if (!pack.isEmpty() && pack != name) {
+        setSoundTitle(pack + ": " + name);
+        return;
+    }
+
+    const QString category = muse::audio::audioSourceCategoryName(params).toQString();
+    if (!category.isEmpty() && category != name) {
+        setSoundTitle(category + ": " + name);
+        return;
+    }
+
+    setSoundTitle(name);
 }
 
 bool PercussionPanelModel::eventFilter(QObject* watched, QEvent* event)

src/notation/view/percussionpanel/percussionpanelmodel.h

@@ -77,10 +77,7 @@ class PercussionPanelModel : public QObject, public muse::Injectable, public mus
     explicit PercussionPanelModel(QObject* parent = nullptr);
 
     bool enabled() const;
-    void setEnabled(bool enabled);
-
     QString soundTitle() const;
-    void setSoundTitle(const QString& soundTitle);
 
     PanelMode::Mode currentPanelMode() const;
     void setCurrentPanelMode(const PanelMode::Mode& panelMode);
@@ -117,9 +114,11 @@ class PercussionPanelModel : public QObject, public muse::Injectable, public mus
 private:
     void setUpConnections();
 
+    void setEnabled(bool enabled);
     void setDrumset(mu::engraving::Drumset* drumset);
 
     void updateSoundTitle(const InstrumentTrackId& trackId);
+    void setSoundTitle(const QString& soundTitle);
 
     bool eventFilter(QObject* watched, QEvent* event) override;
 

src/playback/view/playbacktoolbarmodel.cpp

@@ -146,7 +146,7 @@ MenuItem* PlaybackToolBarModel::makeInputPitchMenu()
         items << makeMenuItem(action.code);
     }
 
-    MenuItem* menu = makeMenu(muse::TranslatableString("notation", "Input pitch"), items);
+    MenuItem* menu = makeMenu(muse::TranslatableString("notation", "MIDI input pitch"), items);
     UiAction action = menu->action();
     action.iconCode = IconCode::Code::MUSIC_NOTES;
     menu->setAction(action);