Add "Play from selection" shortcut

RomanPudashkin · RomanPudashkin · commit c89d560827b5 · 2025-11-20T14:15:37.000+02:00
diff --git a/src/app/configs/data/shortcuts.xml b/src/app/configs/data/shortcuts.xml
@@ -801,6 +801,11 @@
     <seq>Space</seq>
     <autorepeat>0</autorepeat>
     </SC>
+  <SC>
+    <key>play-from-selection</key>
+    <seq>Shift+Space</seq>
+    <autorepeat>0</autorepeat>
+    </SC>
   <SC>
     <key>pause-and-select</key>
     <seq>Ctrl+Space</seq>
diff --git a/src/app/configs/data/shortcuts_azerty.xml b/src/app/configs/data/shortcuts_azerty.xml
@@ -842,6 +842,11 @@
     <seq>Space</seq>
     <autorepeat>0</autorepeat>
     </SC>
+  <SC>
+    <key>play-from-selection</key>
+    <seq>Shift+Space</seq>
+    <autorepeat>0</autorepeat>
+    </SC>
   <SC>
     <key>pause-and-select</key>
     <seq>Ctrl+Space</seq>
diff --git a/src/app/configs/data/shortcuts_mac.xml b/src/app/configs/data/shortcuts_mac.xml
@@ -801,6 +801,11 @@
     <seq>Space</seq>
     <autorepeat>0</autorepeat>
     </SC>
+  <SC>
+    <key>play-from-selection</key>
+    <seq>Shift+Space</seq>
+    <autorepeat>0</autorepeat>
+    </SC>
   <SC>
     <key>pause-and-select</key>
     <seq>Alt+Space</seq>
diff --git a/src/notation/inotationinteraction.h b/src/notation/inotationinteraction.h
@@ -171,7 +171,8 @@ class INotationInteraction
     virtual void startEditGrip(EngravingItem* element, mu::engraving::Grip grip) = 0;
     virtual void endEditGrip() = 0;
 
-    virtual bool isElementEditStarted() const = 0;
+    virtual bool isEditingElement() const = 0;
+    virtual muse::async::Notification isEditingElementChanged() const = 0;
     virtual void startEditElement(EngravingItem* element) = 0;
     virtual void changeEditElement(EngravingItem* newElement) = 0;
     virtual bool isEditAllowed(QKeyEvent* event) = 0;
diff --git a/src/notation/internal/notationactioncontroller.cpp b/src/notation/internal/notationactioncontroller.cpp
@@ -712,7 +712,7 @@ void NotationActionController::resetState()
     if (interaction->isTextEditingStarted()) {
         interaction->endEditElement();
         return;
-    } else if (interaction->isElementEditStarted()) {
+    } else if (interaction->isEditingElement()) {
         interaction->endEditElement();
     }
 
@@ -2349,7 +2349,7 @@ bool NotationActionController::isEditingElement() const
 {
     auto interaction = currentNotationInteraction();
     if (interaction) {
-        return interaction->isElementEditStarted() || interaction->isDragStarted();
+        return interaction->isEditingElement() || interaction->isDragStarted();
     }
     return false;
 }
diff --git a/src/notation/internal/notationinteraction.cpp b/src/notation/internal/notationinteraction.cpp
@@ -1130,10 +1130,8 @@ void NotationInteraction::clearSelection()
 {
     TRACEFUNC;
 
-    if (isElementEditStarted()) {
+    if (isEditingElement()) {
         endEditElement();
-    } else if (m_editData.element) {
-        m_editData.element = nullptr;
     }
 
     if (isDragStarted()) {
@@ -1295,7 +1293,7 @@ void NotationInteraction::drag(const PointF& fromPos, const PointF& toPos, DragM
     m_dragData.ed.pos = toPos;
     m_dragData.ed.modifiers = keyboardModifier(QGuiApplication::keyboardModifiers());
 
-    m_dragData.ed.isEditMode = isElementEditStarted();
+    m_dragData.ed.isEditMode = isEditingElement();
 
     if (isTextEditingStarted()) {
         m_editData.pos = toPos;
@@ -3767,7 +3765,7 @@ void NotationInteraction::addToSelection(MoveDirection d, MoveSelectionType type
 bool NotationInteraction::moveSelectionAvailable(MoveSelectionType type) const
 {
     if (type != MoveSelectionType::EngravingItem) {
-        return !isElementEditStarted();
+        return !isEditingElement();
     }
 
     EngravingItem* el = score()->selection().element();
@@ -3785,7 +3783,7 @@ bool NotationInteraction::moveSelectionAvailable(MoveSelectionType type) const
         return true;
     }
 
-    return m_editData.element && m_editData.element->isTextBase() ? !isTextEditingStarted() : !isElementEditStarted();
+    return m_editData.element && m_editData.element->isTextBase() ? !isTextEditingStarted() : !isEditingElement();
 }
 
 void NotationInteraction::moveSelection(MoveDirection d, MoveSelectionType type)
@@ -4099,7 +4097,7 @@ void NotationInteraction::moveElementSelection(MoveDirection d)
         return;
     }
 
-    if (isElementEditStarted()) {
+    if (isEditingElement()) {
         endEditElement();
     }
 
@@ -4308,6 +4306,7 @@ void NotationInteraction::startEditText(EngravingItem* element, const PointF& cu
 
     m_editData.element->startEdit(m_editData);
 
+    m_isEditingElementChanged.notify();
     notifyAboutTextEditingStarted();
     notifyAboutTextEditingChanged();
 }
@@ -4448,6 +4447,8 @@ void NotationInteraction::endEditText()
 
     TextBase* editedElement = toTextBase(m_editData.element);
     doEndEditElement();
+
+    m_isEditingElementChanged.notify();
     notifyAboutTextEditingEnded(editedElement);
 
     notifyAboutTextEditingChanged();
@@ -4622,7 +4623,7 @@ void NotationInteraction::updateDragAnchorLines()
     setAnchorLines(anchorLines);
 }
 
-bool NotationInteraction::isElementEditStarted() const
+bool NotationInteraction::isEditingElement() const
 {
     return m_editData.element != nullptr;
 }
@@ -4633,7 +4634,7 @@ void NotationInteraction::startEditElement(EngravingItem* element)
         return;
     }
 
-    if (isElementEditStarted()) {
+    if (isEditingElement()) {
         return;
     }
 
@@ -4645,6 +4646,8 @@ void NotationInteraction::startEditElement(EngravingItem* element)
         element->startEdit(m_editData);
         m_editData.element = element;
     }
+
+    m_isEditingElementChanged.notify();
 }
 
 void NotationInteraction::changeEditElement(EngravingItem* newElement)
@@ -4794,9 +4797,15 @@ void NotationInteraction::endEditElement()
     doEndEditElement();
     resetAnchorLines();
 
+    m_isEditingElementChanged.notify();
     notifyAboutNotationChanged();
 }
 
+muse::async::Notification NotationInteraction::isEditingElementChanged() const
+{
+    return m_isEditingElementChanged;
+}
+
 void NotationInteraction::updateTimeTickAnchors(QKeyEvent* event)
 {
     EngravingItem* selectedElement = m_selection->element();
@@ -6414,7 +6423,7 @@ bool NotationInteraction::needEndTextEditing(const std::vector<EngravingItem*>&
 
 bool NotationInteraction::needEndElementEditing(const std::vector<EngravingItem*>& newSelectedElements) const
 {
-    if (!isElementEditStarted()) {
+    if (!isEditingElement()) {
         return false;
     }
 
diff --git a/src/notation/internal/notationinteraction.h b/src/notation/internal/notationinteraction.h
@@ -180,7 +180,8 @@ class NotationInteraction : public INotationInteraction, public muse::Injectable
     void startEditGrip(EngravingItem* element, mu::engraving::Grip grip) override;
     void endEditGrip() override;
 
-    bool isElementEditStarted() const override;
+    bool isEditingElement() const override;
+    muse::async::Notification isEditingElementChanged() const override;
     void startEditElement(EngravingItem* element) override;
     void changeEditElement(EngravingItem* newElement) override;
     bool isEditAllowed(QKeyEvent* event) override;
@@ -534,6 +535,8 @@ class NotationInteraction : public INotationInteraction, public muse::Injectable
 
     mu::engraving::EditData m_editData;
 
+    muse::async::Notification m_isEditingElementChanged;
+
     muse::async::Notification m_textEditingStarted;
     muse::async::Notification m_textEditingChanged;
     muse::async::Channel<TextBase*> m_textEditingEnded;
diff --git a/src/notation/tests/mocks/notationinteractionmock.h b/src/notation/tests/mocks/notationinteractionmock.h
@@ -132,7 +132,8 @@ class NotationInteractionMock : public INotationInteraction
     MOCK_METHOD(void, startEditGrip, (EngravingItem*, mu::engraving::Grip), (override));
     MOCK_METHOD(void, endEditGrip, (), (override));
 
-    MOCK_METHOD(bool, isElementEditStarted, (), (const, override));
+    MOCK_METHOD(bool, isEditingElement, (), (const, override));
+    MOCK_METHOD(muse::async::Notification, isEditingElementChanged, (), (const, override));
     MOCK_METHOD(void, startEditElement, (EngravingItem*), (override));
     MOCK_METHOD(void, changeEditElement, (EngravingItem*), (override));
     MOCK_METHOD(bool, isEditAllowed, (QKeyEvent*), (override));
diff --git a/src/notation/view/notationviewinputcontroller.cpp b/src/notation/view/notationviewinputcontroller.cpp
@@ -1084,7 +1084,7 @@ void NotationViewInputController::mouseMoveEvent(QMouseEvent* event)
         const EngravingItem* hitElement = hitElementContext().element;
 
         // drag element
-        if ((hitElement && (hitElement->isMovable() || viewInteraction()->isElementEditStarted()))
+        if ((hitElement && (hitElement->isMovable() || viewInteraction()->isEditingElement()))
             || viewInteraction()->isGripEditStarted()) {
             if (hitElement && !viewInteraction()->isDragStarted()) {
                 startDragElements(hitElement->type(), hitElement->offset());
@@ -1364,7 +1364,7 @@ bool NotationViewInputController::shortcutOverrideEvent(QKeyEvent* event)
         return true;
     }
 
-    if (viewInteraction()->isElementEditStarted()) {
+    if (viewInteraction()->isEditingElement()) {
         return viewInteraction()->isEditAllowed(event);
     }
 
@@ -1388,7 +1388,7 @@ void NotationViewInputController::keyPressEvent(QKeyEvent* event)
         m_mouseDownInfo.dragAction = MouseDownInfo::Nothing;
         m_view->asItem()->setCursor({});
         event->accept();
-    } else if (viewInteraction()->isElementEditStarted()) {
+    } else if (viewInteraction()->isEditingElement()) {
         viewInteraction()->editElement(event);
         if (key == Qt::Key_Shift) {
             viewInteraction()->updateTimeTickAnchors(event);
diff --git a/src/playback/internal/playbackcontroller.cpp b/src/playback/internal/playbackcontroller.cpp
@@ -44,6 +44,7 @@ using namespace mu::notation;
 using namespace mu::playback;
 
 static const ActionCode PLAY_CODE("play");
+static const ActionCode PLAY_FROM_SELECTION("play-from-selection");
 static const ActionCode STOP_CODE("stop");
 static const ActionCode PAUSE_AND_SELECT_CODE("pause-and-select");
 static const ActionCode REWIND_CODE("rewind");
@@ -91,6 +92,7 @@ static std::string resolveAuxTrackTitle(aux_channel_idx_t index, const AudioOutp
 void PlaybackController::init()
 {
     dispatcher()->reg(this, PLAY_CODE, this, &PlaybackController::togglePlay);
+    dispatcher()->reg(this, PLAY_FROM_SELECTION, this, &PlaybackController::playFromSelection);
     dispatcher()->reg(this, STOP_CODE, [this]() { PlaybackController::pause(/*select*/ false); });
     dispatcher()->reg(this, PAUSE_AND_SELECT_CODE, [this]() { PlaybackController::pause(/*select*/ true); });
     dispatcher()->reg(this, REWIND_CODE, this, &PlaybackController::rewind);
@@ -667,6 +669,38 @@ void PlaybackController::play()
     currentPlayer()->play(delay);
 }
 
+void PlaybackController::playFromSelection()
+{
+    if (selection()->isNone()) {
+        return;
+    }
+
+    int startTick = INT_MAX;
+    for (const EngravingItem* item : selection()->elements()) {
+        startTick = std::min(startTick, item->tick().ticks());
+    }
+
+    const LoopBoundaries& loop = notationPlayback()->loopBoundaries();
+    if (loop.enabled) {
+        if (startTick < loop.loopInTick.ticks() || startTick > loop.loopOutTick.ticks()) {
+            startTick = loop.loopInTick.ticks();
+        }
+    }
+
+    const RetVal<midi::tick_t> retval = notationPlayback()->playPositionTickByRawTick(startTick);
+    if (!retval.ret) {
+        return;
+    }
+
+    seek(playedTickToSecs(retval.val));
+
+    if (isPaused()) {
+        resume();
+    } else if (!isPlaying()) {
+        play();
+    }
+}
+
 void PlaybackController::rewind(const ActionData& args)
 {
     secs_t startSecs = playbackStartSecs();
diff --git a/src/playback/internal/playbackcontroller.h b/src/playback/internal/playbackcontroller.h
@@ -167,6 +167,7 @@ class PlaybackController : public IPlaybackController, public muse::actions::Act
     void togglePlay();
     void rewind(const muse::actions::ActionData& args);
     void play();
+    void playFromSelection();
     void pause(bool select = false);
     void stop();
     void resume();
diff --git a/src/playback/internal/playbackuiactions.cpp b/src/playback/internal/playbackuiactions.cpp
@@ -27,10 +27,14 @@
 #include "types/translatablestring.h"
 
 using namespace mu::playback;
+using namespace mu::notation;
 using namespace muse;
 using namespace muse::ui;
 using namespace muse::actions;
 
+static const ActionCode PLAY_FROM_SELECTION_CODE("play-from-selection");
+static const ActionCode CLEAR_ONLINE_SOUNDS_CACHE_CODE("clear-online-sounds-cache");
+
 const UiActionList PlaybackUiActions::s_mainActions = {
     UiAction("play",
              mu::context::UiCtxProjectOpened,
@@ -39,6 +43,13 @@ const UiActionList PlaybackUiActions::s_mainActions = {
              TranslatableString("action", "Play"),
              IconCode::Code::PLAY
              ),
+    UiAction(PLAY_FROM_SELECTION_CODE,
+             mu::context::UiCtxProjectOpened,
+             mu::context::CTX_NOTATION_OPENED,
+             TranslatableString("action", "Play from selection"),
+             TranslatableString("action", "Play from selection"),
+             IconCode::Code::PLAY
+             ),
     UiAction("stop",
              mu::context::UiCtxProjectOpened,
              mu::context::CTX_NOTATION_OPENED,
@@ -183,8 +194,6 @@ const UiActionList PlaybackUiActions::s_diagnosticActions = {
              )
 };
 
-static const ActionCode CLEAR_ONLINE_SOUNDS_CACHE_CODE("clear-online-sounds-cache");
-
 const UiActionList PlaybackUiActions::s_onlineSoundsActions = {
     UiAction(CLEAR_ONLINE_SOUNDS_CACHE_CODE,
              mu::context::UiCtxAny,
@@ -217,6 +226,22 @@ void PlaybackUiActions::init()
         m_actionEnabledChanged.send(codes);
     });
 
+    globalContext()->currentNotationChanged().onNotify(this, [this]() {
+        INotationPtr currNotation = globalContext()->currentNotation();
+        if (!currNotation) {
+            return;
+        }
+
+        INotationInteractionPtr interaction = currNotation->interaction();
+        interaction->selectionChanged().onNotify(this, [this]() {
+            m_actionEnabledChanged.send({ PLAY_FROM_SELECTION_CODE });
+        });
+
+        interaction->isEditingElementChanged().onNotify(this, [this]() {
+            m_actionEnabledChanged.send({ PLAY_FROM_SELECTION_CODE });
+        });
+    });
+
     m_controller->onlineSoundsChanged().onNotify(this, [this]() {
         m_actionEnabledChanged.send({ CLEAR_ONLINE_SOUNDS_CACHE_CODE });
     });
@@ -251,6 +276,12 @@ bool PlaybackUiActions::actionEnabled(const UiAction& act) const
         return !m_controller->onlineSounds().empty();
     }
 
+    if (act.code == PLAY_FROM_SELECTION) {
+        const INotationPtr currNotation = globalContext()->currentNotation();
+        const INotationInteractionPtr interaction = currNotation ? currNotation->interaction() : nullptr;
+        return interaction && !interaction->selection()->isNone() && !interaction->isEditingElement();
+    }
+
     return true;
 }
 
diff --git a/src/playback/internal/playbackuiactions.h b/src/playback/internal/playbackuiactions.h
@@ -26,13 +26,15 @@
 #include "playbackcontroller.h"
 #include "modularity/ioc.h"
 #include "context/iuicontextresolver.h"
+#include "context/iglobalcontext.h"
 #include "async/asyncable.h"
 #include "ui/uitypes.h"
 
 namespace mu::playback {
 class PlaybackUiActions : public muse::ui::IUiActionsModule, public muse::async::Asyncable
 {
     INJECT(context::IUiContextResolver, uicontextResolver)
+    INJECT(context::IGlobalContext, globalContext)
 
 public:
     PlaybackUiActions(std::shared_ptr<PlaybackController> controller);

Original file line number	Diff line number	Diff line change
`@@ -712,7 +712,7 @@ void NotationActionController::resetState()`
`712`	`712`	`if (interaction->isTextEditingStarted()) {`
`713`	`713`	`interaction->endEditElement();`
`714`	`714`	`return;`
`715`		`- } else if (interaction->isElementEditStarted()) {`
	`715`	`+ } else if (interaction->isEditingElement()) {`
`716`	`716`	`interaction->endEditElement();`
`717`	`717`	`}`
`718`	`718`
`@@ -2349,7 +2349,7 @@ bool NotationActionController::isEditingElement() const`
`2349`	`2349`	`{`
`2350`	`2350`	`auto interaction = currentNotationInteraction();`
`2351`	`2351`	`if (interaction) {`
`2352`		`- return interaction->isElementEditStarted() \|\| interaction->isDragStarted();`
	`2352`	`+ return interaction->isEditingElement() \|\| interaction->isDragStarted();`
`2353`	`2353`	`}`
`2354`	`2354`	`return false;`
`2355`	`2355`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1130,10 +1130,8 @@ void NotationInteraction::clearSelection()`
`1130`	`1130`	`{`
`1131`	`1131`	`TRACEFUNC;`
`1132`	`1132`
`1133`		`- if (isElementEditStarted()) {`
	`1133`	`+ if (isEditingElement()) {`
`1134`	`1134`	`endEditElement();`
`1135`		`- } else if (m_editData.element) {`
`1136`		`- m_editData.element = nullptr;`
`1137`	`1135`	`}`
`1138`	`1136`
`1139`	`1137`	`if (isDragStarted()) {`
`@@ -1295,7 +1293,7 @@ void NotationInteraction::drag(const PointF& fromPos, const PointF& toPos, DragM`
`1295`	`1293`	`m_dragData.ed.pos = toPos;`
`1296`	`1294`	`m_dragData.ed.modifiers = keyboardModifier(QGuiApplication::keyboardModifiers());`
`1297`	`1295`
`1298`		`- m_dragData.ed.isEditMode = isElementEditStarted();`
	`1296`	`+ m_dragData.ed.isEditMode = isEditingElement();`
`1299`	`1297`
`1300`	`1298`	`if (isTextEditingStarted()) {`
`1301`	`1299`	`m_editData.pos = toPos;`
`@@ -3767,7 +3765,7 @@ void NotationInteraction::addToSelection(MoveDirection d, MoveSelectionType type`
`3767`	`3765`	`bool NotationInteraction::moveSelectionAvailable(MoveSelectionType type) const`
`3768`	`3766`	`{`
`3769`	`3767`	`if (type != MoveSelectionType::EngravingItem) {`
`3770`		`- return !isElementEditStarted();`
	`3768`	`+ return !isEditingElement();`
`3771`	`3769`	`}`
`3772`	`3770`
`3773`	`3771`	`EngravingItem* el = score()->selection().element();`
`@@ -3785,7 +3783,7 @@ bool NotationInteraction::moveSelectionAvailable(MoveSelectionType type) const`
`3785`	`3783`	`return true;`
`3786`	`3784`	`}`
`3787`	`3785`
`3788`		`- return m_editData.element && m_editData.element->isTextBase() ? !isTextEditingStarted() : !isElementEditStarted();`
	`3786`	`+ return m_editData.element && m_editData.element->isTextBase() ? !isTextEditingStarted() : !isEditingElement();`
`3789`	`3787`	`}`
`3790`	`3788`
`3791`	`3789`	`void NotationInteraction::moveSelection(MoveDirection d, MoveSelectionType type)`
`@@ -4099,7 +4097,7 @@ void NotationInteraction::moveElementSelection(MoveDirection d)`
`4099`	`4097`	`return;`
`4100`	`4098`	`}`
`4101`	`4099`
`4102`		`- if (isElementEditStarted()) {`
	`4100`	`+ if (isEditingElement()) {`
`4103`	`4101`	`endEditElement();`
`4104`	`4102`	`}`
`4105`	`4103`
`@@ -4308,6 +4306,7 @@ void NotationInteraction::startEditText(EngravingItem* element, const PointF& cu`
`4308`	`4306`
`4309`	`4307`	`m_editData.element->startEdit(m_editData);`
`4310`	`4308`
	`4309`	`+ m_isEditingElementChanged.notify();`
`4311`	`4310`	`notifyAboutTextEditingStarted();`
`4312`	`4311`	`notifyAboutTextEditingChanged();`
`4313`	`4312`	`}`
`@@ -4448,6 +4447,8 @@ void NotationInteraction::endEditText()`
`4448`	`4447`
`4449`	`4448`	`TextBase* editedElement = toTextBase(m_editData.element);`
`4450`	`4449`	`doEndEditElement();`
	`4450`	`+`
	`4451`	`+ m_isEditingElementChanged.notify();`
`4451`	`4452`	`notifyAboutTextEditingEnded(editedElement);`
`4452`	`4453`
`4453`	`4454`	`notifyAboutTextEditingChanged();`
`@@ -4622,7 +4623,7 @@ void NotationInteraction::updateDragAnchorLines()`
`4622`	`4623`	`setAnchorLines(anchorLines);`
`4623`	`4624`	`}`
`4624`	`4625`
`4625`		`-bool NotationInteraction::isElementEditStarted() const`
	`4626`	`+bool NotationInteraction::isEditingElement() const`
`4626`	`4627`	`{`
`4627`	`4628`	`return m_editData.element != nullptr;`
`4628`	`4629`	`}`
`@@ -4633,7 +4634,7 @@ void NotationInteraction::startEditElement(EngravingItem* element)`
`4633`	`4634`	`return;`
`4634`	`4635`	`}`
`4635`	`4636`
`4636`		`- if (isElementEditStarted()) {`
	`4637`	`+ if (isEditingElement()) {`
`4637`	`4638`	`return;`
`4638`	`4639`	`}`
`4639`	`4640`
`@@ -4645,6 +4646,8 @@ void NotationInteraction::startEditElement(EngravingItem* element)`
`4645`	`4646`	`element->startEdit(m_editData);`
`4646`	`4647`	`m_editData.element = element;`
`4647`	`4648`	`}`
	`4649`	`+`
	`4650`	`+ m_isEditingElementChanged.notify();`
`4648`	`4651`	`}`
`4649`	`4652`
`4650`	`4653`	`void NotationInteraction::changeEditElement(EngravingItem* newElement)`
`@@ -4794,9 +4797,15 @@ void NotationInteraction::endEditElement()`
`4794`	`4797`	`doEndEditElement();`
`4795`	`4798`	`resetAnchorLines();`
`4796`	`4799`
	`4800`	`+ m_isEditingElementChanged.notify();`
`4797`	`4801`	`notifyAboutNotationChanged();`
`4798`	`4802`	`}`
`4799`	`4803`
	`4804`	`+muse::async::Notification NotationInteraction::isEditingElementChanged() const`
	`4805`	`+{`
	`4806`	`+ return m_isEditingElementChanged;`
	`4807`	`+}`
	`4808`	`+`
`4800`	`4809`	`void NotationInteraction::updateTimeTickAnchors(QKeyEvent* event)`
`4801`	`4810`	`{`
`4802`	`4811`	`EngravingItem* selectedElement = m_selection->element();`
`@@ -6414,7 +6423,7 @@ bool NotationInteraction::needEndTextEditing(const std::vector<EngravingItem*>&`
`6414`	`6423`
`6415`	`6424`	`bool NotationInteraction::needEndElementEditing(const std::vector<EngravingItem*>& newSelectedElements) const`
`6416`	`6425`	`{`
`6417`		`- if (!isElementEditStarted()) {`
	`6426`	`+ if (!isEditingElement()) {`
`6418`	`6427`	`return false;`
`6419`	`6428`	`}`
`6420`	`6429`