Add UndoAddOn and supports undo/redo

CrSjimo · CrSjimo · commit 9bd856654ef1 · 2025-12-16T00:23:17.000+08:00
diff --git a/src/libs/application/dspxmodel/src/EntityObject.cpp b/src/libs/application/dspxmodel/src/EntityObject.cpp
@@ -22,7 +22,7 @@ namespace dspx {
     EntityObject::~EntityObject() {
         Q_D(EntityObject);
         if (d->model && d->handle) {
-            d->model->strategy()->destroyEntity(d->handle);
+
         }
     }
 
diff --git a/src/libs/application/dspxmodel/src/Model.cpp b/src/libs/application/dspxmodel/src/Model.cpp
@@ -69,6 +69,9 @@ namespace dspx {
 
     void ModelPrivate::handleNotifications() {
         Q_Q(Model);
+        QObject::connect(strategy, &ModelStrategy::destroyEntityNotified, q, [=, this](Handle handle) {
+            handleEntityDestroyed(handle);
+        });
         QObject::connect(strategy, &ModelStrategy::insertIntoSequenceContainerNotified, q, [=, this](Handle sequenceContainerEntity, Handle entity) {
             if (auto sequenceContainerObject = mapToObject(sequenceContainerEntity)) {
                 sequenceContainerObject->handleInsertIntoSequenceContainer(entity);
@@ -314,7 +317,9 @@ namespace dspx {
 
     void Model::destroyItem(EntityObject *object) {
         Q_D(Model);
-        // TODO do some checks
+        auto handle = object->handle();
+        object->d_func()->handle = {};
+        d->strategy->destroyEntity(handle);
         object->deleteLater();
     }
 
diff --git a/src/libs/application/dspxmodel/src/UndoableModelStrategy.cpp b/src/libs/application/dspxmodel/src/UndoableModelStrategy.cpp
@@ -17,14 +17,16 @@ namespace dspx {
     }
 
     CreateEntityCommand::~CreateEntityCommand() {
-        if (m_object && m_object->parent() != m_strategy) {
-            delete m_object;
+        // Delete object if command is in undone state
+        if (m_object && m_undone) {
+            delete m_object.data();
         }
     }
 
     void CreateEntityCommand::undo() {
         // Detach object from strategy but keep it alive
         m_object->setParent(nullptr);
+        m_undone = true;
         Q_EMIT m_strategy->destroyEntityNotified(entity());
     }
 
@@ -36,6 +38,7 @@ namespace dspx {
             // Subsequent times: re-parent the existing object
             m_object->setParent(m_strategy);
         }
+        m_undone = false;
         Q_EMIT m_strategy->createEntityNotified(entity(), m_entityType);
     }
 
@@ -49,8 +52,9 @@ namespace dspx {
     }
 
     DestroyEntityCommand::~DestroyEntityCommand() {
-        if (m_object && m_object->parent() != m_strategy) {
-            delete m_object;
+        // Delete object if command is NOT in undone state (i.e., destroy was executed)
+        if (m_object && !m_undone) {
+            delete m_object.data();
         }
     }
 
@@ -94,10 +98,12 @@ namespace dspx {
 
     void DestroyEntityCommand::undo() {
         recursivelyCreate(m_object);
+        m_undone = true;
     }
 
     void DestroyEntityCommand::redo() {
         recursivelyDestroy(m_object);
+        m_undone = false;
     }
 
     //================================================================
@@ -134,24 +140,27 @@ namespace dspx {
     }
 
     TakeFromSequenceContainerCommand::~TakeFromSequenceContainerCommand() {
-        if (m_object && m_object->parent() != handle_cast<QObject>(m_container)) {
-            delete m_object;
+        // Delete object if command is NOT in undone state (i.e., take was executed)
+        if (m_object && !m_undone) {
+            delete m_object.data();
         }
     }
 
     void TakeFromSequenceContainerCommand::undo() {
         auto containerObj = handle_cast<BasicModelStrategySequenceContainerEntity>(m_container);
         containerObj->sequence.insert(m_object);
         m_object->setParent(containerObj);
-        Q_EMIT m_strategy->insertIntoSequenceContainerNotified(m_container, {reinterpret_cast<quintptr>(m_object)});
+        m_undone = true;
+        Q_EMIT m_strategy->insertIntoSequenceContainerNotified(m_container, {reinterpret_cast<quintptr>(m_object.data())});
     }
 
     void TakeFromSequenceContainerCommand::redo() {
         auto containerObj = handle_cast<BasicModelStrategySequenceContainerEntity>(m_container);
         containerObj->sequence.remove(m_object);
         m_object->setParent(m_strategy);
-        Q_EMIT m_strategy->takeFromContainerNotified({reinterpret_cast<quintptr>(m_object)}, m_container,
-                                                     {reinterpret_cast<quintptr>(m_object)});
+        m_undone = false;
+        Q_EMIT m_strategy->takeFromContainerNotified({reinterpret_cast<quintptr>(m_object.data())}, m_container,
+                                                     {reinterpret_cast<quintptr>(m_object.data())});
     }
 
     InsertIntoListContainerCommand::InsertIntoListContainerCommand(
@@ -185,15 +194,17 @@ namespace dspx {
     }
 
     TakeFromListContainerCommand::~TakeFromListContainerCommand() {
-        if (m_object && m_object->parent() != handle_cast<QObject>(m_container)) {
-            delete m_object;
+        // Delete object if command is NOT in undone state (i.e., take was executed)
+        if (m_object && !m_undone) {
+            delete m_object.data();
         }
     }
 
     void TakeFromListContainerCommand::undo() {
         auto containerObj = handle_cast<BasicModelStrategyListContainerEntity>(m_container);
         containerObj->list.insert(m_index, m_object);
         m_object->setParent(containerObj);
+        m_undone = true;
         Q_EMIT m_strategy->insertIntoListContainerNotified(m_container, entity(), m_index);
     }
 
@@ -205,11 +216,12 @@ namespace dspx {
         auto containerObj = handle_cast<BasicModelStrategyListContainerEntity>(m_container);
         containerObj->list.removeAt(m_index);
         m_object->setParent(m_strategy);
+        m_undone = false;
         Q_EMIT m_strategy->takeFromListContainerNotified(entity(), m_container, m_index);
     }
 
     Handle TakeFromListContainerCommand::entity() const {
-        return {reinterpret_cast<quintptr>(m_object)};
+        return {reinterpret_cast<quintptr>(m_object.data())};
     }
 
     InsertIntoMapContainerCommand::InsertIntoMapContainerCommand(UndoableModelStrategy *strategy,
@@ -222,7 +234,7 @@ namespace dspx {
 
     InsertIntoMapContainerCommand::~InsertIntoMapContainerCommand() {
         if (m_oldObject) {
-            delete m_oldObject;
+            delete m_oldObject.data();
         }
     }
 
@@ -238,7 +250,7 @@ namespace dspx {
             containerObj->map.insert(m_key, m_oldObject);
             m_oldObject->setParent(containerObj);
             Q_EMIT m_strategy->insertIntoMapContainerNotified(m_container,
-                                                              {reinterpret_cast<quintptr>(m_oldObject)}, m_key);
+                                                              {reinterpret_cast<quintptr>(m_oldObject.data())}, m_key);
             m_oldObject = nullptr; // Transfer ownership back to container
         }
     }
@@ -250,7 +262,7 @@ namespace dspx {
         if (containerObj->map.contains(m_key)) {
             m_oldObject = containerObj->map.take(m_key);
             m_oldObject->setParent(nullptr); // Take ownership
-            Q_EMIT m_strategy->takeFromMapContainerNotified({reinterpret_cast<quintptr>(m_oldObject)}, m_container,
+            Q_EMIT m_strategy->takeFromMapContainerNotified({reinterpret_cast<quintptr>(m_oldObject.get())}, m_container,
                                                             m_key);
         }
 
@@ -266,15 +278,17 @@ namespace dspx {
     }
 
     TakeFromMapContainerCommand::~TakeFromMapContainerCommand() {
-        if (m_object && m_object->parent() != handle_cast<QObject>(m_container)) {
-            delete m_object;
+        // Delete object if command is NOT in undone state (i.e., take was executed)
+        if (m_object && !m_undone) {
+            delete m_object.data();
         }
     }
 
     void TakeFromMapContainerCommand::undo() {
         auto containerObj = handle_cast<BasicModelStrategyMapContainerEntity>(m_container);
         containerObj->map.insert(m_key, m_object);
         m_object->setParent(containerObj);
+        m_undone = true;
         Q_EMIT m_strategy->insertIntoMapContainerNotified(m_container, entity(), m_key);
     }
 
@@ -286,11 +300,12 @@ namespace dspx {
         auto containerObj = handle_cast<BasicModelStrategyMapContainerEntity>(m_container);
         containerObj->map.remove(m_key);
         m_object->setParent(m_strategy);
+        m_undone = false;
         Q_EMIT m_strategy->takeFromMapContainerNotified(entity(), m_container, m_key);
     }
 
     Handle TakeFromMapContainerCommand::entity() const {
-        return {reinterpret_cast<quintptr>(m_object)};
+        return {reinterpret_cast<quintptr>(m_object.data())};
     }
 
     RotateListContainerCommand::RotateListContainerCommand(UndoableModelStrategy *strategy,
diff --git a/src/libs/application/dspxmodel/src/UndoableModelStrategy_p.h b/src/libs/application/dspxmodel/src/UndoableModelStrategy_p.h
@@ -32,6 +32,7 @@ namespace dspx {
         UndoableModelStrategy *m_strategy;
         BasicModelStrategy::Entity m_entityType;
         QPointer<BasicModelStrategyEntity> m_object;
+        bool m_undone = false;
     };
 
     class DestroyEntityCommand : public QUndoCommand {
@@ -45,6 +46,7 @@ namespace dspx {
     private:
         UndoableModelStrategy *m_strategy;
         QPointer<BasicModelStrategyEntity> m_object;
+        bool m_undone = false;
         void recursivelyDestroy(BasicModelStrategyEntity *object);
         void recursivelyCreate(BasicModelStrategyEntity *object);
     };
@@ -80,7 +82,8 @@ namespace dspx {
     private:
         UndoableModelStrategy *m_strategy;
         Handle m_container;
-        BasicModelStrategyEntity *m_object;
+        QPointer<BasicModelStrategyEntity> m_object;
+        bool m_undone = false;
     };
 
     class InsertIntoListContainerCommand : public QUndoCommand {
@@ -110,8 +113,9 @@ namespace dspx {
     private:
         UndoableModelStrategy *m_strategy;
         Handle m_container;
-        BasicModelStrategyEntity *m_object;
+        QPointer<BasicModelStrategyEntity> m_object;
         int m_index;
+        bool m_undone = false;
     };
 
     class InsertIntoMapContainerCommand : public QUndoCommand {
@@ -128,7 +132,7 @@ namespace dspx {
         Handle m_container;
         Handle m_entity;
         QString m_key;
-        BasicModelStrategyEntity *m_oldObject;
+        QPointer<BasicModelStrategyEntity> m_oldObject;
     };
 
     class TakeFromMapContainerCommand : public QUndoCommand {
@@ -143,8 +147,9 @@ namespace dspx {
     private:
         UndoableModelStrategy *m_strategy;
         Handle m_container;
-        BasicModelStrategyEntity *m_object;
+        QPointer<BasicModelStrategyEntity> m_object;
         QString m_key;
+        bool m_undone = false;
     };
 
     class RotateListContainerCommand : public QUndoCommand {
diff --git a/src/plugins/coreplugin/internal/CorePlugin.cpp b/src/plugins/coreplugin/internal/CorePlugin.cpp
@@ -62,6 +62,7 @@
 #include <coreplugin/internal/RecentFileAddOn.h>
 #include <coreplugin/internal/TimeIndicatorPage.h>
 #include <coreplugin/internal/TimelineAddOn.h>
+#include <coreplugin/internal/UndoAddOn.h>
 #include <coreplugin/internal/ViewVisibilityAddOn.h>
 #include <coreplugin/internal/WorkspaceAddOn.h>
 #include <coreplugin/ProjectWindowInterface.h>
@@ -323,6 +324,7 @@ namespace Core::Internal {
         HomeWindowInterfaceRegistry::instance()->attach<FindActionsAddOn>();
         ProjectWindowInterfaceRegistry::instance()->attach<FindActionsAddOn>();
         ProjectWindowInterfaceRegistry::instance()->attach<EditActionsAddOn>();
+        ProjectWindowInterfaceRegistry::instance()->attach<UndoAddOn>();
         ProjectWindowInterfaceRegistry::instance()->attach<TimelineAddOn>();
         ProjectWindowInterfaceRegistry::instance()->attach<ProjectStartupTimerAddOn>();
         HomeWindowInterfaceRegistry::instance()->attach<RecentFileAddOn>();
diff --git a/src/plugins/coreplugin/internal/addon/UndoAddOn.cpp b/src/plugins/coreplugin/internal/addon/UndoAddOn.cpp
@@ -0,0 +1,38 @@
+#include "UndoAddOn.h"
+
+#include <QQmlComponent>
+
+#include <CoreApi/runtimeinterface.h>
+
+#include <QAKQuick/quickactioncontext.h>
+
+#include <coreplugin/ProjectWindowInterface.h>
+
+namespace Core::Internal {
+
+    UndoAddOn::UndoAddOn(QObject *parent) : WindowInterfaceAddOn(parent) {
+    }
+
+    UndoAddOn::~UndoAddOn() = default;
+
+    void UndoAddOn::initialize() {
+        auto windowInterface = windowHandle()->cast<ProjectWindowInterface>();
+        QQmlComponent component(RuntimeInterface::qmlEngine(), "DiffScope.Core", "UndoAddOnActions");
+        if (component.isError()) {
+            qFatal() << component.errorString();
+        }
+        auto o = component.createWithInitialProperties({
+            {"addOn", QVariant::fromValue(this)},
+        });
+        o->setParent(this);
+        QMetaObject::invokeMethod(o, "registerToContext", windowInterface->actionContext());
+    }
+
+    void UndoAddOn::extensionsInitialized() {
+    }
+
+    bool UndoAddOn::delayedInitialize() {
+        return WindowInterfaceAddOn::delayedInitialize();
+    }
+
+}
diff --git a/src/plugins/coreplugin/internal/addon/UndoAddOn.h b/src/plugins/coreplugin/internal/addon/UndoAddOn.h
@@ -0,0 +1,25 @@
+#ifndef DIFFSCOPE_COREPLUGIN_UNDOADDON_H
+#define DIFFSCOPE_COREPLUGIN_UNDOADDON_H
+
+#include <qqmlintegration.h>
+
+#include <CoreApi/windowinterface.h>
+
+namespace Core::Internal {
+
+    class UndoAddOn : public WindowInterfaceAddOn {
+        Q_OBJECT
+        QML_ELEMENT
+        QML_UNCREATABLE("")
+    public:
+        explicit UndoAddOn(QObject *parent = nullptr);
+        ~UndoAddOn() override;
+
+        void initialize() override;
+        void extensionsInitialized() override;
+        bool delayedInitialize() override;
+    };
+
+}
+
+#endif //DIFFSCOPE_COREPLUGIN_UNDOADDON_H
diff --git a/src/plugins/coreplugin/project/ProjectTimeline.cpp b/src/plugins/coreplugin/project/ProjectTimeline.cpp
@@ -58,7 +58,7 @@ namespace Core {
             musicTimeline->setTempo(pos, (*tempoSet.begin())->value());
         }
         tempoPosMap.remove(tempo);
-        QObject::disconnect(tempo, &dspx::Tempo::valueChanged, q, nullptr);
+        QObject::disconnect(tempo, nullptr, q, nullptr);
     }
     void ProjectTimelinePrivate::handleTimeSignatureInsertedOrUpdated(dspx::TimeSignature *timeSignature) {
         Q_Q(ProjectTimeline);
@@ -106,7 +106,7 @@ namespace Core {
             musicTimeline->setTimeSignature(measure, {item->numerator(), item->denominator()});
         }
         timeSignatureMeasureMap.remove(timeSignature);
-        QObject::disconnect(timeSignature, &dspx::TimeSignature::numeratorChanged, q, nullptr);
+        QObject::disconnect(timeSignature, nullptr, q, nullptr);
     }
 
     ProjectTimeline::ProjectTimeline(DspxDocument *document, QObject *parent) : QObject(parent), d_ptr(new ProjectTimelinePrivate) {
diff --git a/src/plugins/coreplugin/qml/actions/EditActionsAddOnActions.qml b/src/plugins/coreplugin/qml/actions/EditActionsAddOnActions.qml
@@ -10,25 +10,6 @@ ActionCollection {
     required property QtObject addOn
     readonly property ProjectWindowInterface windowHandle: addOn?.windowHandle ?? null
 
-    // Basic edit actions
-    ActionItem {
-        actionId: "org.diffscope.core.edit.undo"
-        Action {
-            onTriggered: {
-                // TODO: Implement undo functionality
-            }
-        }
-    }
-
-    ActionItem {
-        actionId: "org.diffscope.core.edit.redo"
-        Action {
-            onTriggered: {
-                // TODO: Implement redo functionality
-            }
-        }
-    }
-
     component EditAction: Action {
         required property int flag
         enabled: d.windowHandle.mainEditActionsHandlerRegistry.enabledActions & flag
diff --git a/src/plugins/coreplugin/qml/actions/UndoAddOnActions.qml b/src/plugins/coreplugin/qml/actions/UndoAddOnActions.qml

Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ namespace dspx {`
`22`	`22`	`EntityObject::~EntityObject() {`
`23`	`23`	`Q_D(EntityObject);`
`24`	`24`	`if (d->model && d->handle) {`
`25`		`- d->model->strategy()->destroyEntity(d->handle);`
	`25`	`+`
`26`	`26`	`}`
`27`	`27`	`}`
`28`	`28`
Original file line number	Diff line number	Diff line change
`@@ -17,14 +17,16 @@ namespace dspx {`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`CreateEntityCommand::~CreateEntityCommand() {`
`20`		`- if (m_object && m_object->parent() != m_strategy) {`
`21`		`- delete m_object;`
	`20`	`+ // Delete object if command is in undone state`
	`21`	`+ if (m_object && m_undone) {`
	`22`	`+ delete m_object.data();`
`22`	`23`	`}`
`23`	`24`	`}`
`24`	`25`
`25`	`26`	`void CreateEntityCommand::undo() {`
`26`	`27`	`// Detach object from strategy but keep it alive`
`27`	`28`	`m_object->setParent(nullptr);`
	`29`	`+ m_undone = true;`
`28`	`30`	`Q_EMIT m_strategy->destroyEntityNotified(entity());`
`29`	`31`	`}`
`30`	`32`
`@@ -36,6 +38,7 @@ namespace dspx {`
`36`	`38`	`// Subsequent times: re-parent the existing object`
`37`	`39`	`m_object->setParent(m_strategy);`
`38`	`40`	`}`
	`41`	`+ m_undone = false;`
`39`	`42`	`Q_EMIT m_strategy->createEntityNotified(entity(), m_entityType);`
`40`	`43`	`}`
`41`	`44`
`@@ -49,8 +52,9 @@ namespace dspx {`
`49`	`52`	`}`
`50`	`53`
`51`	`54`	`DestroyEntityCommand::~DestroyEntityCommand() {`
`52`		`- if (m_object && m_object->parent() != m_strategy) {`
`53`		`- delete m_object;`
	`55`	`+ // Delete object if command is NOT in undone state (i.e., destroy was executed)`
	`56`	`+ if (m_object && !m_undone) {`
	`57`	`+ delete m_object.data();`
`54`	`58`	`}`
`55`	`59`	`}`
`56`	`60`
`@@ -94,10 +98,12 @@ namespace dspx {`
`94`	`98`
`95`	`99`	`void DestroyEntityCommand::undo() {`
`96`	`100`	`recursivelyCreate(m_object);`
	`101`	`+ m_undone = true;`
`97`	`102`	`}`
`98`	`103`
`99`	`104`	`void DestroyEntityCommand::redo() {`
`100`	`105`	`recursivelyDestroy(m_object);`
	`106`	`+ m_undone = false;`
`101`	`107`	`}`
`102`	`108`
`103`	`109`	`//================================================================`
`@@ -134,24 +140,27 @@ namespace dspx {`
`134`	`140`	`}`
`135`	`141`
`136`	`142`	`TakeFromSequenceContainerCommand::~TakeFromSequenceContainerCommand() {`
`137`		`- if (m_object && m_object->parent() != handle_cast<QObject>(m_container)) {`
`138`		`- delete m_object;`
	`143`	`+ // Delete object if command is NOT in undone state (i.e., take was executed)`
	`144`	`+ if (m_object && !m_undone) {`
	`145`	`+ delete m_object.data();`
`139`	`146`	`}`
`140`	`147`	`}`
`141`	`148`
`142`	`149`	`void TakeFromSequenceContainerCommand::undo() {`
`143`	`150`	`auto containerObj = handle_cast<BasicModelStrategySequenceContainerEntity>(m_container);`
`144`	`151`	`containerObj->sequence.insert(m_object);`
`145`	`152`	`m_object->setParent(containerObj);`
`146`		`- Q_EMIT m_strategy->insertIntoSequenceContainerNotified(m_container, {reinterpret_cast<quintptr>(m_object)});`
	`153`	`+ m_undone = true;`
	`154`	`+ Q_EMIT m_strategy->insertIntoSequenceContainerNotified(m_container, {reinterpret_cast<quintptr>(m_object.data())});`
`147`	`155`	`}`
`148`	`156`
`149`	`157`	`void TakeFromSequenceContainerCommand::redo() {`
`150`	`158`	`auto containerObj = handle_cast<BasicModelStrategySequenceContainerEntity>(m_container);`
`151`	`159`	`containerObj->sequence.remove(m_object);`
`152`	`160`	`m_object->setParent(m_strategy);`
`153`		`- Q_EMIT m_strategy->takeFromContainerNotified({reinterpret_cast<quintptr>(m_object)}, m_container,`
`154`		`- {reinterpret_cast<quintptr>(m_object)});`
	`161`	`+ m_undone = false;`
	`162`	`+ Q_EMIT m_strategy->takeFromContainerNotified({reinterpret_cast<quintptr>(m_object.data())}, m_container,`
	`163`	`+ {reinterpret_cast<quintptr>(m_object.data())});`
`155`	`164`	`}`
`156`	`165`
`157`	`166`	`InsertIntoListContainerCommand::InsertIntoListContainerCommand(`
`@@ -185,15 +194,17 @@ namespace dspx {`
`185`	`194`	`}`
`186`	`195`
`187`	`196`	`TakeFromListContainerCommand::~TakeFromListContainerCommand() {`
`188`		`- if (m_object && m_object->parent() != handle_cast<QObject>(m_container)) {`
`189`		`- delete m_object;`
	`197`	`+ // Delete object if command is NOT in undone state (i.e., take was executed)`
	`198`	`+ if (m_object && !m_undone) {`
	`199`	`+ delete m_object.data();`
`190`	`200`	`}`
`191`	`201`	`}`
`192`	`202`
`193`	`203`	`void TakeFromListContainerCommand::undo() {`
`194`	`204`	`auto containerObj = handle_cast<BasicModelStrategyListContainerEntity>(m_container);`
`195`	`205`	`containerObj->list.insert(m_index, m_object);`
`196`	`206`	`m_object->setParent(containerObj);`
	`207`	`+ m_undone = true;`
`197`	`208`	`Q_EMIT m_strategy->insertIntoListContainerNotified(m_container, entity(), m_index);`
`198`	`209`	`}`
`199`	`210`
`@@ -205,11 +216,12 @@ namespace dspx {`
`205`	`216`	`auto containerObj = handle_cast<BasicModelStrategyListContainerEntity>(m_container);`
`206`	`217`	`containerObj->list.removeAt(m_index);`
`207`	`218`	`m_object->setParent(m_strategy);`
	`219`	`+ m_undone = false;`
`208`	`220`	`Q_EMIT m_strategy->takeFromListContainerNotified(entity(), m_container, m_index);`
`209`	`221`	`}`
`210`	`222`
`211`	`223`	`Handle TakeFromListContainerCommand::entity() const {`
`212`		`- return {reinterpret_cast<quintptr>(m_object)};`
	`224`	`+ return {reinterpret_cast<quintptr>(m_object.data())};`
`213`	`225`	`}`
`214`	`226`
`215`	`227`	`InsertIntoMapContainerCommand::InsertIntoMapContainerCommand(UndoableModelStrategy *strategy,`
`@@ -222,7 +234,7 @@ namespace dspx {`
`222`	`234`
`223`	`235`	`InsertIntoMapContainerCommand::~InsertIntoMapContainerCommand() {`
`224`	`236`	`if (m_oldObject) {`
`225`		`- delete m_oldObject;`
	`237`	`+ delete m_oldObject.data();`
`226`	`238`	`}`
`227`	`239`	`}`
`228`	`240`
`@@ -238,7 +250,7 @@ namespace dspx {`
`238`	`250`	`containerObj->map.insert(m_key, m_oldObject);`
`239`	`251`	`m_oldObject->setParent(containerObj);`
`240`	`252`	`Q_EMIT m_strategy->insertIntoMapContainerNotified(m_container,`
`241`		`- {reinterpret_cast<quintptr>(m_oldObject)}, m_key);`
	`253`	`+ {reinterpret_cast<quintptr>(m_oldObject.data())}, m_key);`
`242`	`254`	`m_oldObject = nullptr; // Transfer ownership back to container`
`243`	`255`	`}`
`244`	`256`	`}`
`@@ -250,7 +262,7 @@ namespace dspx {`
`250`	`262`	`if (containerObj->map.contains(m_key)) {`
`251`	`263`	`m_oldObject = containerObj->map.take(m_key);`
`252`	`264`	`m_oldObject->setParent(nullptr); // Take ownership`
`253`		`- Q_EMIT m_strategy->takeFromMapContainerNotified({reinterpret_cast<quintptr>(m_oldObject)}, m_container,`
	`265`	`+ Q_EMIT m_strategy->takeFromMapContainerNotified({reinterpret_cast<quintptr>(m_oldObject.get())}, m_container,`
`254`	`266`	`m_key);`
`255`	`267`	`}`
`256`	`268`
`@@ -266,15 +278,17 @@ namespace dspx {`
`266`	`278`	`}`
`267`	`279`
`268`	`280`	`TakeFromMapContainerCommand::~TakeFromMapContainerCommand() {`
`269`		`- if (m_object && m_object->parent() != handle_cast<QObject>(m_container)) {`
`270`		`- delete m_object;`
	`281`	`+ // Delete object if command is NOT in undone state (i.e., take was executed)`
	`282`	`+ if (m_object && !m_undone) {`
	`283`	`+ delete m_object.data();`
`271`	`284`	`}`
`272`	`285`	`}`
`273`	`286`
`274`	`287`	`void TakeFromMapContainerCommand::undo() {`
`275`	`288`	`auto containerObj = handle_cast<BasicModelStrategyMapContainerEntity>(m_container);`
`276`	`289`	`containerObj->map.insert(m_key, m_object);`
`277`	`290`	`m_object->setParent(containerObj);`
	`291`	`+ m_undone = true;`
`278`	`292`	`Q_EMIT m_strategy->insertIntoMapContainerNotified(m_container, entity(), m_key);`
`279`	`293`	`}`
`280`	`294`
`@@ -286,11 +300,12 @@ namespace dspx {`
`286`	`300`	`auto containerObj = handle_cast<BasicModelStrategyMapContainerEntity>(m_container);`
`287`	`301`	`containerObj->map.remove(m_key);`
`288`	`302`	`m_object->setParent(m_strategy);`
	`303`	`+ m_undone = false;`
`289`	`304`	`Q_EMIT m_strategy->takeFromMapContainerNotified(entity(), m_container, m_key);`
`290`	`305`	`}`
`291`	`306`
`292`	`307`	`Handle TakeFromMapContainerCommand::entity() const {`
`293`		`- return {reinterpret_cast<quintptr>(m_object)};`
	`308`	`+ return {reinterpret_cast<quintptr>(m_object.data())};`
`294`	`309`	`}`
`295`	`310`
`296`	`311`	`RotateListContainerCommand::RotateListContainerCommand(UndoableModelStrategy *strategy,`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ namespace Core {`
`58`	`58`	`musicTimeline->setTempo(pos, (*tempoSet.begin())->value());`
`59`	`59`	`}`
`60`	`60`	`tempoPosMap.remove(tempo);`
`61`		`- QObject::disconnect(tempo, &dspx::Tempo::valueChanged, q, nullptr);`
	`61`	`+ QObject::disconnect(tempo, nullptr, q, nullptr);`
`62`	`62`	`}`
`63`	`63`	`void ProjectTimelinePrivate::handleTimeSignatureInsertedOrUpdated(dspx::TimeSignature *timeSignature) {`
`64`	`64`	`Q_Q(ProjectTimeline);`
`@@ -106,7 +106,7 @@ namespace Core {`
`106`	`106`	`musicTimeline->setTimeSignature(measure, {item->numerator(), item->denominator()});`
`107`	`107`	`}`
`108`	`108`	`timeSignatureMeasureMap.remove(timeSignature);`
`109`		`- QObject::disconnect(timeSignature, &dspx::TimeSignature::numeratorChanged, q, nullptr);`
	`109`	`+ QObject::disconnect(timeSignature, nullptr, q, nullptr);`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`ProjectTimeline::ProjectTimeline(DspxDocument document, QObject parent) : QObject(parent), d_ptr(new ProjectTimelinePrivate) {`