Add device/effect copy and effect gallery import

- Copy an existing device or effect directly when creating a new one:
  - "Copy Device..." in the Device Gallery duplicates another device into
    the slot; the picker lists devices with the track(s) they are used on.
  - "Copy Effect..." in the Effects Gallery duplicates another effect in
    the same rack.
  - Add direct "Import Effect..." to the Effects Gallery, matching the
    existing device import.

- Copies are in-memory clones via the existing serialize/deserialize
  paths (parameter clone for effects, kept in the domain layer).

Author: juzzlin

CHANGELOG

@@ -5,6 +5,12 @@ Release date:
 
 New features:
 
+* Copy an existing device or effect when creating a new one
+  - "Copy Device..." in the Device Gallery duplicates another device into the slot
+  - The device list shows the track(s) each device is used on
+  - "Copy Effect..." in the Effects Gallery duplicates another effect in the same rack
+  - Add direct "Import Effect..." to the Effects Gallery, matching device import
+
 * Add a stereo oscilloscope to the Synth
   - Live L/R waveform traces side by side on a new "Scope" tab
   - Reusable component that can later be added to other device dialogs

src/CMakeLists.txt

@@ -58,6 +58,8 @@ set(QML_SOURCE_FILES
     ${QML_BASE_DIR}/Dialogs/ColumnSettingsDialog_TimingSettings.qml
     ${QML_BASE_DIR}/Dialogs/CompressorDialog.qml
     ${QML_BASE_DIR}/Dialogs/ConfirmationDialog.qml
+    ${QML_BASE_DIR}/Dialogs/CopyDeviceDialog.qml
+    ${QML_BASE_DIR}/Dialogs/CopyEffectDialog.qml
     ${QML_BASE_DIR}/Dialogs/DelayCalculatorDialog.qml
     ${QML_BASE_DIR}/Dialogs/DelayDialog.qml
     ${QML_BASE_DIR}/Dialogs/DeleteUnusedPatternsDialog.qml

src/application/service/device_service.cpp

@@ -598,8 +598,11 @@ bool DeviceService::importDeviceSettings(int slotIndex, const QString & filePath
     if (!file.open(QIODevice::ReadOnly)) {
         return false;
     }
-    const auto xml = QString::fromUtf8(file.readAll());
+    return importDeviceSettingsFromXml(slotIndex, QString::fromUtf8(file.readAll()));
+}
 
+bool DeviceService::importDeviceSettingsFromXml(int slotIndex, const QString & xml)
+{
     // Extract embedded data before deserializing the device so that a Sampler can resolve its
     // nahd:// sample paths while loading. In the file the <Device> element precedes the <Data>
     // blocks, so a single streaming pass would try to load samples before they are extracted.
@@ -617,6 +620,23 @@ bool DeviceService::importDeviceSettings(int slotIndex, const QString & filePath
     return importDeviceSettings(slotIndex, reader);
 }
 
+bool DeviceService::copyDevice(int sourceSlot, int targetSlot)
+{
+    if (sourceSlot == targetSlot || !device(static_cast<size_t>(sourceSlot))) {
+        return false;
+    }
+
+    QString xml;
+    {
+        NahdXmlWriter writer { xml };
+        if (!exportDeviceSettings(sourceSlot, writer)) {
+            return false;
+        }
+    }
+
+    return importDeviceSettingsFromXml(targetSlot, xml);
+}
+
 bool DeviceService::importDeviceSettings(int slotIndex, ProjectReader & reader)
 {
     while (!reader.atEnd() && !reader.hasError()) {

src/application/service/device_service.hpp

@@ -88,6 +88,10 @@ class DeviceService : public QObject
     Q_INVOKABLE bool importDeviceSettings(int slotIndex, const QString & filePath);
     bool importDeviceSettings(int slotIndex, ProjectReader & reader);
 
+    //! Duplicate the device in sourceSlot into targetSlot (in-memory clone). Returns false if the
+    //! source slot is empty or source and target are the same slot.
+    bool copyDevice(int sourceSlot, int targetSlot);
+
     struct DeviceTypeInfo
     {
         QString typeId;
@@ -109,6 +113,8 @@ class DeviceService : public QObject
     void synthUserPresetsChanged(const UserPresets & presets);
 
 private:
+    bool importDeviceSettingsFromXml(int slotIndex, const QString & xml);
+
     DeviceService::DeviceS getDevice(std::string name, std::string typeId);
 
     std::shared_ptr<SynthDevice> findFirstSynthDevice() const;

src/domain/effects/effect_rack.cpp

@@ -361,4 +361,34 @@ bool EffectRack::importEffectSettings(size_t index, ProjectReader & reader)
     return false;
 }
 
+bool EffectRack::copyEffect(size_t sourceIndex, size_t targetIndex)
+{
+    const std::lock_guard<std::recursive_mutex> lock { m_mutex };
+    if (sourceIndex == targetIndex || sourceIndex >= m_effects.size() || !m_effects[sourceIndex]) {
+        return false;
+    }
+
+    const auto & source = m_effects[sourceIndex];
+    auto clone = EffectFactory::createEffect(source->typeId(), source->type());
+    if (!clone) {
+        return false;
+    }
+
+    clone->setEnabled(source->enabled());
+    for (const auto & [name, parameter] : source->parameters()) {
+        if (const auto target = clone->parameter(name); target) {
+            target->get().update(parameter.value());
+        }
+    }
+    clone->sync();
+
+    if (targetIndex >= m_effects.size()) {
+        m_effects.resize(targetIndex + 1, nullptr);
+    }
+    m_effects[targetIndex] = std::move(clone);
+    markChanged();
+
+    return true;
+}
+
 } // namespace noteahead

src/domain/effects/effect_rack.hpp

@@ -72,6 +72,10 @@ class EffectRack
     bool exportEffectSettings(size_t index, ProjectWriter & writer) const;
     bool importEffectSettings(size_t index, ProjectReader & reader);
 
+    //! Duplicate the effect in sourceIndex into targetIndex (in-memory clone). Returns false if the
+    //! source slot is empty or source and target are the same slot.
+    bool copyEffect(size_t sourceIndex, size_t targetIndex);
+
 private:
     void markChanged();
 

src/unit_tests/device_rack_controller_test/device_rack_controller_test.cpp

@@ -413,6 +413,45 @@ void DeviceRackControllerTest::test_confirmImportSettings_shouldImportAndNotify(
     QCOMPARE(synth->volume(), 0.42f);
 }
 
+void DeviceRackControllerTest::test_copyDevice_shouldDuplicateAndNotify()
+{
+    const auto audioEngine = std::make_shared<AudioEngine>();
+    const auto deviceService = std::make_shared<DeviceService>(audioEngine, std::make_shared<DataService>());
+    const auto editorService = std::make_shared<MockEditorService>();
+
+    const auto synth = std::dynamic_pointer_cast<SynthDevice>(DeviceFactory::createDevice(SynthDevice::typeIdString(), "TestSynth"));
+    synth->setVolume(0.42f);
+    deviceService->setDevice(0, synth);
+
+    DeviceRackController controller { deviceService, {}, editorService };
+    QSignalSpy revisionSpy { &controller, &DeviceRackController::revisionChanged };
+
+    controller.copyDevice(0, 1);
+
+    QVERIFY(revisionSpy.count() > 0);
+    QVERIFY(editorService->isModified());
+    const auto copy = std::dynamic_pointer_cast<SynthDevice>(deviceService->device(1));
+    QVERIFY(copy != nullptr);
+    QCOMPARE(copy->volume(), 0.42f);
+}
+
+void DeviceRackControllerTest::test_populatedDevices_shouldReturnOnlyFilledSlots()
+{
+    const auto audioEngine = std::make_shared<AudioEngine>();
+    const auto deviceService = std::make_shared<DeviceService>(audioEngine, std::make_shared<DataService>());
+    const auto editorService = std::make_shared<MockEditorService>();
+
+    deviceService->setDevice(0, DeviceFactory::createDevice(SynthDevice::typeIdString(), "TestSynth"));
+    deviceService->setDevice(2, DeviceFactory::createDevice(SamplerDevice::typeIdString(), "TestSampler"));
+
+    DeviceRackController controller { deviceService, {}, editorService };
+
+    const auto populated = controller.populatedDevices();
+    QCOMPARE(populated.size(), 2);
+    QCOMPARE(populated.at(0).toMap()["slotIndex"].toInt(), 0);
+    QCOMPARE(populated.at(1).toMap()["slotIndex"].toInt(), 2);
+}
+
 } // namespace noteahead
 
 QTEST_GUILESS_MAIN(noteahead::DeviceRackControllerTest)

src/unit_tests/device_rack_controller_test/device_rack_controller_test.hpp

@@ -38,6 +38,8 @@ private slots:
     void test_importSettings_matchingType_shouldEmitConfirmationWithoutMismatch();
     void test_importSettings_differentType_shouldEmitConfirmationWithMismatch();
     void test_confirmImportSettings_shouldImportAndNotify();
+    void test_copyDevice_shouldDuplicateAndNotify();
+    void test_populatedDevices_shouldReturnOnlyFilledSlots();
 };
 
 } // namespace noteahead

src/unit_tests/device_service_test/device_service_test.cpp

@@ -246,6 +246,64 @@ void DeviceServiceTest::test_importDeviceSettings_emptySlot_shouldCreateDeviceFr
     QCOMPARE(synth->volume(), 0.75f);
 }
 
+void DeviceServiceTest::test_copyDevice_shouldDuplicateParametersIntoTargetSlot()
+{
+    const auto audioEngine = std::make_shared<AudioEngine>();
+    const auto dataService = std::make_shared<DataService>();
+    DeviceService service { audioEngine, dataService };
+
+    const auto synth = std::dynamic_pointer_cast<SynthDevice>(DeviceFactory::createDevice(SynthDevice::typeIdString(), "TestSynth"));
+    synth->setVolume(0.75f);
+    service.setDevice(0, synth);
+
+    QVERIFY(!service.device(1));
+    QVERIFY(service.copyDevice(0, 1));
+
+    const auto copy = std::dynamic_pointer_cast<SynthDevice>(service.device(1));
+    QVERIFY(copy);
+    QCOMPARE(copy->typeId(), SynthDevice::typeIdString());
+    QCOMPARE(copy->volume(), 0.75f);
+    // The copy is an independent instance, not the same shared pointer.
+    QVERIFY(copy != synth);
+    // The source is left untouched.
+    QCOMPARE(service.device(0), synth);
+}
+
+void DeviceServiceTest::test_copyDevice_differentType_shouldReplaceTargetDevice()
+{
+    const auto audioEngine = std::make_shared<AudioEngine>();
+    const auto dataService = std::make_shared<DataService>();
+    DeviceService service { audioEngine, dataService };
+
+    service.setDevice(0, DeviceFactory::createDevice(SynthDevice::typeIdString(), "TestSynth"));
+    service.setDevice(1, DeviceFactory::createDevice(SamplerDevice::typeIdString(), "TestSampler"));
+
+    QCOMPARE(service.device(1)->typeId(), SamplerDevice::typeIdString());
+    QVERIFY(service.copyDevice(0, 1));
+    QCOMPARE(service.device(1)->typeId(), SynthDevice::typeIdString());
+}
+
+void DeviceServiceTest::test_copyDevice_emptySource_shouldFail()
+{
+    const auto audioEngine = std::make_shared<AudioEngine>();
+    const auto dataService = std::make_shared<DataService>();
+    DeviceService service { audioEngine, dataService };
+
+    QVERIFY(!service.device(0));
+    QVERIFY(!service.copyDevice(0, 1));
+    QVERIFY(!service.device(1));
+}
+
+void DeviceServiceTest::test_copyDevice_sameSlot_shouldFail()
+{
+    const auto audioEngine = std::make_shared<AudioEngine>();
+    const auto dataService = std::make_shared<DataService>();
+    DeviceService service { audioEngine, dataService };
+
+    service.setDevice(0, DeviceFactory::createDevice(SynthDevice::typeIdString(), "TestSynth"));
+    QVERIFY(!service.copyDevice(0, 0));
+}
+
 void DeviceServiceTest::test_exportImport_withEmbeddedData_shouldWork()
 {
     const auto audioEngine = std::make_shared<AudioEngine>();

src/unit_tests/device_service_test/device_service_test.hpp

@@ -32,6 +32,10 @@ private slots:
     void test_importDeviceSettings_shouldRestoreParameters();
     void test_importDeviceSettings_shouldReplaceDeviceIfTypeDiffers();
     void test_importDeviceSettings_emptySlot_shouldCreateDeviceFromFile();
+    void test_copyDevice_shouldDuplicateParametersIntoTargetSlot();
+    void test_copyDevice_differentType_shouldReplaceTargetDevice();
+    void test_copyDevice_emptySource_shouldFail();
+    void test_copyDevice_sameSlot_shouldFail();
     void test_exportImport_withEmbeddedData_shouldWork();
     void test_importDeviceSettings_embeddedData_emptySlot_shouldExtractDataBeforeLoadingSamples();
     void test_peekDeviceTypeInfo_synth_shouldReturnCorrectTypeInfo();