Tidying

src/Insight/Insight.cpp

@@ -265,9 +265,9 @@ namespace Bloom
     }
 
     void Insight::onInsightWindowActivated() {
-        auto* getTargetStateTask = new GetTargetState();
+        const auto getTargetStateTask = QSharedPointer<GetTargetState>(new GetTargetState(), &QObject::deleteLater);
         QObject::connect(
-            getTargetStateTask,
+            getTargetStateTask.get(),
             &GetTargetState::targetState,
             this,
             [this] (Targets::TargetState targetState) {
@@ -354,10 +354,13 @@ namespace Bloom
         }
 
         if (event.state == TargetControllerState::ACTIVE) {
-            auto* getTargetDescriptorTask = new GetTargetDescriptor();
+            const auto getTargetDescriptorTask = QSharedPointer<GetTargetDescriptor>(
+                new GetTargetDescriptor(),
+                &QObject::deleteLater
+            );
 
             QObject::connect(
-                getTargetDescriptorTask,
+                getTargetDescriptorTask.get(),
                 &GetTargetDescriptor::targetDescriptor,
                 this,
                 [this] (Targets::TargetDescriptor targetDescriptor) {

src/Insight/InsightWorker/InsightWorker.cpp

@@ -33,16 +33,15 @@ namespace Bloom
         emit this->ready();
     }
 
-    void InsightWorker::queueTask(InsightWorkerTask* task) {
+    void InsightWorker::queueTask(const QSharedPointer<InsightWorkerTask>& task) {
-        const auto taskPtr = QSharedPointer<InsightWorkerTask>(task, &QObject::deleteLater);
+        task->moveToThread(nullptr);
-        taskPtr->moveToThread(nullptr);
 
         {
             const auto taskQueueLock = InsightWorker::queuedTasksById.acquireLock();
-            InsightWorker::queuedTasksById.getValue().emplace(taskPtr->id, taskPtr);
+            InsightWorker::queuedTasksById.getValue().emplace(task->id, task);
         }
 
-        emit InsightSignals::instance()->taskQueued(taskPtr);
+        emit InsightSignals::instance()->taskQueued(task);
     }
 
     void InsightWorker::executeTasks() {

src/Insight/InsightWorker/InsightWorker.hpp

@@ -29,7 +29,7 @@ namespace Bloom
 
         InsightWorker() = default;
         void startup();
-        static void queueTask(InsightWorkerTask* task);
+        static void queueTask(const QSharedPointer<InsightWorkerTask>& task);
 
     signals:
         void ready();

src/Insight/UserInterfaces/InsightWindow/InsightWindow.cpp

@@ -915,10 +915,13 @@ namespace Bloom
     }
 
     void InsightWindow::refreshProgramCounter(std::optional<std::function<void(void)>> callback) {
-        auto* readProgramCounterTask = new ReadProgramCounter();
+        const auto readProgramCounterTask = QSharedPointer<ReadProgramCounter>(
+            new ReadProgramCounter(),
+            &QObject::deleteLater
+        );
 
         QObject::connect(
-            readProgramCounterTask,
+            readProgramCounterTask.get(),
             &ReadProgramCounter::programCounterRead,
             this,
             [this] (Targets::TargetProgramCounter programCounter) {
@@ -930,7 +933,7 @@ namespace Bloom
 
         if (callback.has_value()) {
             QObject::connect(
-                readProgramCounterTask,
+                readProgramCounterTask.get(),
                 &ReadProgramCounter::finished,
                 this,
                 callback.value()

src/Insight/UserInterfaces/InsightWindow/Widgets/TargetMemoryInspectionPane/HexViewerWidget/ItemGraphicsScene.cpp

@@ -137,10 +137,13 @@ namespace Bloom::Widgets
     }
 
     void ItemGraphicsScene::init() {
-        auto* constructHexViewerTopLevelGroupItem = new ConstructHexViewerTopLevelGroupItem(this->focusedMemoryRegions, this->state);
+        const auto constructHexViewerTopLevelGroupItem = QSharedPointer<ConstructHexViewerTopLevelGroupItem>(
+            new ConstructHexViewerTopLevelGroupItem(this->focusedMemoryRegions, this->state),
+            &QObject::deleteLater
+        );
 
         QObject::connect(
-            constructHexViewerTopLevelGroupItem,
+            constructHexViewerTopLevelGroupItem.get(),
             &ConstructHexViewerTopLevelGroupItem::topLevelGroupItem,
             this,
             [this] (TopLevelGroupItem* item) {

src/Insight/UserInterfaces/InsightWindow/Widgets/TargetMemoryInspectionPane/SnapshotManager/SnapshotManager.cpp

@@ -92,10 +92,13 @@ namespace Bloom::Widgets
             }
         );
 
-        auto* retrieveSnapshotsTask = new RetrieveMemorySnapshots(this->memoryDescriptor.type);
+        const auto retrieveSnapshotsTask = QSharedPointer<RetrieveMemorySnapshots>(
+            new RetrieveMemorySnapshots(this->memoryDescriptor.type),
+            &QObject::deleteLater
+        );
 
         QObject::connect(
-            retrieveSnapshotsTask,
+            retrieveSnapshotsTask.get(),
             &RetrieveMemorySnapshots::memorySnapshotsRetrieved,
             this,
             [this] (std::vector<MemorySnapshot> snapshots) {
@@ -136,17 +139,20 @@ namespace Bloom::Widgets
         bool captureFocusedRegions,
         bool captureDirectlyFromTarget
     ) {
-        auto* captureTask = new CaptureMemorySnapshot(
+        const auto captureTask = QSharedPointer<CaptureMemorySnapshot>(
-            std::move(name),
+            new CaptureMemorySnapshot(
-            std::move(description),
+                std::move(name),
-            this->memoryDescriptor.type,
+                std::move(description),
-            {},
+                this->memoryDescriptor.type,
-            {},
+                {},
-            captureDirectlyFromTarget ? std::nullopt : this->data
+                {},
+                captureDirectlyFromTarget ? std::nullopt : this->data
+            ),
+            &QObject::deleteLater
         );
 
         QObject::connect(
-            captureTask,
+            captureTask.get(),
             &CaptureMemorySnapshot::memorySnapshotCaptured,
             this,
             [this] (MemorySnapshot snapshot) {

src/Insight/UserInterfaces/InsightWindow/Widgets/TargetMemoryInspectionPane/TargetMemoryInspectionPane.cpp

@@ -298,15 +298,18 @@ namespace Bloom::Widgets
             }
         );
 
-        auto* readMemoryTask = new ReadTargetMemory(
+        const auto readMemoryTask = QSharedPointer<ReadTargetMemory>(
-            this->targetMemoryDescriptor.type,
+            new ReadTargetMemory(
-            this->targetMemoryDescriptor.addressRange.startAddress,
+                this->targetMemoryDescriptor.type,
-            this->targetMemoryDescriptor.size(),
+                this->targetMemoryDescriptor.addressRange.startAddress,
-            excludedAddressRanges
+                this->targetMemoryDescriptor.size(),
+                excludedAddressRanges
+            ),
+            &QObject::deleteLater
         );
 
         QObject::connect(
-            readMemoryTask,
+            readMemoryTask.get(),
             &ReadTargetMemory::targetMemoryRead,
             this,
             [this, callback] (const Targets::TargetMemoryBuffer& data) {
@@ -314,9 +317,13 @@ namespace Bloom::Widgets
 
                 // Refresh the stack pointer if this is RAM.
                 if (this->targetMemoryDescriptor.type == Targets::TargetMemoryType::RAM) {
-                    auto* readStackPointerTask = new ReadStackPointer();
+                    const auto readStackPointerTask = QSharedPointer<ReadStackPointer>(
+                        new ReadStackPointer(),
+                        &QObject::deleteLater
+                    );
+
                     QObject::connect(
-                        readStackPointerTask,
+                        readStackPointerTask.get(),
                         &ReadStackPointer::stackPointerRead,
                         this,
                         [this] (Targets::TargetStackPointer stackPointer) {
@@ -325,7 +332,7 @@ namespace Bloom::Widgets
                     );
 
                     QObject::connect(
-                        readStackPointerTask,
+                        readStackPointerTask.get(),
                         &InsightWorkerTask::finished,
                         this,
                         [this] {
@@ -339,7 +346,7 @@ namespace Bloom::Widgets
 
                     if (callback.has_value()) {
                         QObject::connect(
-                            readStackPointerTask,
+                            readStackPointerTask.get(),
                             &InsightWorkerTask::completed,
                             this,
                             callback.value()
@@ -354,7 +361,7 @@ namespace Bloom::Widgets
         // If we're refreshing RAM, the UI should only be updated once we've retrieved the current stack pointer.
         if (this->targetMemoryDescriptor.type != Targets::TargetMemoryType::RAM) {
             QObject::connect(
-                readMemoryTask,
+                readMemoryTask.get(),
                 &InsightWorkerTask::finished,
                 this,
                 [this] {
@@ -368,7 +375,7 @@ namespace Bloom::Widgets
 
             if (callback.has_value()) {
                 QObject::connect(
-                    readMemoryTask,
+                    readMemoryTask.get(),
                     &InsightWorkerTask::completed,
                     this,
                     callback.value()
@@ -377,7 +384,7 @@ namespace Bloom::Widgets
 
         } else {
             QObject::connect(
-                readMemoryTask,
+                readMemoryTask.get(),
                 &InsightWorkerTask::failed,
                 this,
                 [this] {

src/Insight/UserInterfaces/InsightWindow/Widgets/TargetRegisterInspector/TargetRegisterInspectorWindow.cpp

@@ -317,10 +317,13 @@ namespace Bloom::Widgets
 
     void TargetRegisterInspectorWindow::refreshRegisterValue() {
         this->registerValueContainer->setDisabled(true);
-        auto* readTargetRegisterTask = new ReadTargetRegisters({this->registerDescriptor});
+        const auto readTargetRegisterTask = QSharedPointer<ReadTargetRegisters>(
+            new ReadTargetRegisters({this->registerDescriptor}),
+            &QObject::deleteLater
+        );
 
         QObject::connect(
-            readTargetRegisterTask,
+            readTargetRegisterTask.get(),
             &ReadTargetRegisters::targetRegistersRead,
             this,
             [this] (Targets::TargetRegisters targetRegisters) {
@@ -335,7 +338,7 @@ namespace Bloom::Widgets
         );
 
         QObject::connect(
-            readTargetRegisterTask,
+            readTargetRegisterTask.get(),
             &InsightWorkerTask::failed,
             this,
             [this] {
@@ -352,15 +355,18 @@ namespace Bloom::Widgets
             this->registerDescriptor,
             this->registerValue
         );
-        auto* writeRegisterTask = new WriteTargetRegister(targetRegister);
+        const auto writeRegisterTask = QSharedPointer<WriteTargetRegister>(
+            new WriteTargetRegister(targetRegister),
+            &QObject::deleteLater
+        );
 
-        QObject::connect(writeRegisterTask, &InsightWorkerTask::completed, this, [this, targetRegister] {
+        QObject::connect(writeRegisterTask.get(), &InsightWorkerTask::completed, this, [this, targetRegister] {
             this->registerValueContainer->setDisabled(false);
             this->registerHistoryWidget->updateCurrentItemValue(targetRegister.value);
             this->registerHistoryWidget->selectCurrentItem();
         });
 
-        QObject::connect(writeRegisterTask, &InsightWorkerTask::failed, this, [this] (QString errorMessage) {
+        QObject::connect(writeRegisterTask.get(), &InsightWorkerTask::failed, this, [this] (QString errorMessage) {
             this->registerValueContainer->setDisabled(false);
             auto* errorDialogue = new ErrorDialogue(
                 "Error",

src/Insight/UserInterfaces/InsightWindow/Widgets/TargetRegistersPane/TargetRegistersPaneWidget.cpp

@@ -266,14 +266,17 @@ namespace Bloom::Widgets
             return;
         }
 
-        auto* readRegisterTask = new ReadTargetRegisters(
+        const auto readRegisterTask = QSharedPointer<ReadTargetRegisters>(
-            registerDescriptor.has_value()
+            new ReadTargetRegisters(
-                ? Targets::TargetRegisterDescriptors({*registerDescriptor})
+                registerDescriptor.has_value()
-                : this->registerDescriptors
+                    ? Targets::TargetRegisterDescriptors({*registerDescriptor})
+                    : this->registerDescriptors
+            ),
+            &QObject::deleteLater
         );
 
         QObject::connect(
-            readRegisterTask,
+            readRegisterTask.get(),
             &ReadTargetRegisters::targetRegistersRead,
             this,
             &TargetRegistersPaneWidget::onRegistersRead
@@ -281,7 +284,7 @@ namespace Bloom::Widgets
 
         if (callback.has_value()) {
             QObject::connect(
-                readRegisterTask,
+                readRegisterTask.get(),
                 &InsightWorkerTask::completed,
                 this,
                 callback.value()

src/Insight/UserInterfaces/InsightWindow/Widgets/TargetWidgets/TargetPackageWidget.cpp

@@ -51,9 +51,13 @@ namespace Bloom::Widgets::InsightTargetWidgets
     }
 
     void TargetPackageWidget::refreshPinStates(std::optional<std::function<void(void)>> callback) {
-        auto* refreshTask = new RefreshTargetPinStates(this->targetVariant.id);
+        const auto refreshTask = QSharedPointer<RefreshTargetPinStates>(
+            new RefreshTargetPinStates(this->targetVariant.id),
+            &QObject::deleteLater
+        );
+
         QObject::connect(
-            refreshTask,
+            refreshTask.get(),
             &RefreshTargetPinStates::targetPinStatesRetrieved,
             this,
             &TargetPackageWidget::updatePinStates
@@ -61,7 +65,7 @@ namespace Bloom::Widgets::InsightTargetWidgets
 
         if (callback.has_value()) {
             QObject::connect(
-                refreshTask,
+                refreshTask.get(),
                 &InsightWorkerTask::completed,
                 this,
                 callback.value()

src/Insight/UserInterfaces/InsightWindow/Widgets/TargetWidgets/TargetPinWidget.cpp

@@ -26,22 +26,25 @@ namespace Bloom::Widgets::InsightTargetWidgets
 
     void TargetPinWidget::onWidgetBodyClicked() {
         // Currently, we only allow users to toggle the IO state of output pins
-        if (this->pinState.has_value()
+        if (this->pinState.has_value() && this->pinState.value().ioDirection == TargetPinState::IoDirection::OUTPUT) {
-            && this->pinState.value().ioDirection == TargetPinState::IoDirection::OUTPUT
-        ) {
             this->setDisabled(true);
 
             auto pinState = this->pinState.value();
-            pinState.ioState = (pinState.ioState == TargetPinState::IoState::HIGH) ?
+            pinState.ioState = (pinState.ioState == TargetPinState::IoState::HIGH)
-                TargetPinState::IoState::LOW : TargetPinState::IoState::HIGH;
+                ? TargetPinState::IoState::LOW
+                : TargetPinState::IoState::HIGH;
 
-            auto* setPinStateTask = new SetTargetPinState(this->pinDescriptor, pinState);
+            const auto setPinStateTask = QSharedPointer<SetTargetPinState>(
-            QObject::connect(setPinStateTask, &InsightWorkerTask::completed, this, [this, pinState] {
+                new SetTargetPinState(this->pinDescriptor, pinState),
+                &QObject::deleteLater
+            );
+
+            QObject::connect(setPinStateTask.get(), &InsightWorkerTask::completed, this, [this, pinState] {
                 this->updatePinState(pinState);
                 this->setDisabled(false);
             });
 
-            QObject::connect(setPinStateTask, &InsightWorkerTask::failed, this, [this] {
+            QObject::connect(setPinStateTask.get(), &InsightWorkerTask::failed, this, [this] {
                 this->setDisabled(false);
             });