Fix side services not correctly cleared on MIDI import

Author: juzzlin

src/CMakeLists.txt

@@ -70,6 +70,7 @@ set(HEADER_FILES
   domain/midi_cc_automation.hpp
   domain/midi_cc_data.hpp
   domain/midi_cc_setting.hpp
+  domain/midi_import_mode.hpp
   domain/midi_note_data.hpp
   domain/mixer_unit.hpp
   domain/note_data.hpp

src/application/application.cpp

@@ -340,10 +340,14 @@ void Application::exportToMidi(QString fileName, quint64 startPosition, quint64
         m_applicationService->requestStatusText(message);
     }
 }
-void Application::importFromMidi(QString fileName, int importMode, int patternLength, bool quantizeNoteOn, bool quantizeNoteOff, bool connectMidiPorts)
+void Application::importFromMidi(QString fileName, MidiImportMode importMode, int patternLength, bool quantizeNoteOn, bool quantizeNoteOff, bool connectMidiPorts)
 {
     try {
         const auto midiData = m_midiImporter->parseMidiFile(fileName.toStdString());
+        if (importMode == MidiImportMode::Overwrite) {
+            m_mixerService->clear();
+            m_automationService->clear();
+        }
         m_midiImporter->importTo(midiData, m_editorService->song(), importMode, patternLength, quantizeNoteOn, quantizeNoteOff, connectMidiPorts ? m_midiService : nullptr);
         const auto message = QString { "Imported MIDI file '%1' " }.arg(fileName);
         m_applicationService->requestStatusText(message);

src/application/application.hpp

@@ -116,7 +116,7 @@ class Application : public QObject
     void stopAllNotes() const;
 
     void exportToMidi(QString fileName, quint64 startPosition, quint64 endPosition, MidiExportOptions options);
-    void importFromMidi(QString fileName, int importMode, int patternLength, bool quantizeNoteOn, bool quantizeNoteOff, bool connectMidiPorts);
+    void importFromMidi(QString fileName, MidiImportMode importMode, int patternLength, bool quantizeNoteOn, bool quantizeNoteOff, bool connectMidiPorts);
 
     std::unique_ptr<UiLogger> m_uiLogger;
 

src/application/service/application_service.cpp

@@ -181,7 +181,7 @@ void ApplicationService::importMidiFile(QUrl url, int importMode, int patternLen
         fileName = url.toString();
     }
     juzzlin::L(TAG).info() << "MIDI import requested for " << fileName.toStdString() << " mode: " << importMode << " length: " << patternLength << " quantizeNoteOn: " << quantizeNoteOn << " quantizeNoteOff: " << quantizeNoteOff << " connectMidiPorts: " << connectMidiPorts;
-    emit midiImportRequested(fileName, importMode, patternLength, quantizeNoteOn, quantizeNoteOff, connectMidiPorts);
+    emit midiImportRequested(fileName, static_cast<MidiImportMode>(importMode), patternLength, quantizeNoteOn, quantizeNoteOff, connectMidiPorts);
 }
 
 void ApplicationService::requestLiveNoteOn(quint8 key, quint8 octave, quint8 velocity)

src/application/service/application_service.hpp

@@ -23,6 +23,7 @@
 
 #include <memory>
 
+#include "../../domain/midi_import_mode.hpp"
 #include "../../infra/midi/export/midi_exporter.hpp"
 
 namespace noteahead {
@@ -153,7 +154,7 @@ class ApplicationService : public QObject
     void midiExportRequested(QString fileName, quint64 startPosition, quint64 endPosition, MidiExportOptions options);
 
     void midiImportDialogRequested();
-    void midiImportRequested(QString fileName, int importMode, int patternLength, bool quantizeNoteOn, bool quantizeNoteOff, bool connectMidiPorts);
+    void midiImportRequested(QString fileName, MidiImportMode importMode, int patternLength, bool quantizeNoteOn, bool quantizeNoteOff, bool connectMidiPorts);
 
     void alertDialogRequested(QString message);
     void statusTextRequested(QString message);

src/domain/midi_import_mode.hpp

@@ -0,0 +1,28 @@
+// This file is part of Noteahead.
+// Copyright (C) 2026 Jussi Lind <jussi.lind@iki.fi>
+//
+// Noteahead is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// Noteahead is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Noteahead. If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef MIDI_IMPORT_MODE_HPP
+#define MIDI_IMPORT_MODE_HPP
+
+namespace noteahead {
+
+enum class MidiImportMode {
+    Overwrite,
+    Merge
+};
+
+} // namespace noteahead
+
+#endif // MIDI_IMPORT_MODE_HPP

src/infra/midi/import/midi_importer.cpp

@@ -200,9 +200,9 @@ MidiImporter::MidiTrack MidiImporter::parseTrack(std::istream & in, uint32_t tra
     return track;
 }
 
-void MidiImporter::initializeSong(SongS song, const MidiFileData & data, int importMode, int patternLength) const
+void MidiImporter::initializeSong(SongS song, const MidiFileData & data, MidiImportMode importMode, int patternLength) const
 {
-    if (!importMode) {
+    if (importMode == MidiImportMode::Overwrite) {
         song->initialize();
         song->setBeatsPerMinute(data.initialTempoBpm);
         if (patternLength > 0) {
@@ -274,17 +274,17 @@ size_t MidiImporter::getFreeColumn(SongS song, size_t patternIndex, size_t track
     return col;
 }
 
-void MidiImporter::finalizePlayOrder(SongS song, size_t maxPatternIndex, int importMode, [[maybe_unused]] int patternLength) const
+void MidiImporter::finalizePlayOrder(SongS song, size_t maxPatternIndex, MidiImportMode importMode, [[maybe_unused]] int patternLength) const
 {
-    if (!importMode) {
+    if (importMode == MidiImportMode::Overwrite) {
         song->setLength(maxPatternIndex + 1);
         for (size_t i = 0; i <= maxPatternIndex; ++i) {
             song->setPatternAtSongPosition(i, i);
         }
     }
 }
 
-void MidiImporter::importTo(const MidiFileData & data, SongS song, int importMode, int patternLength, bool quantizeNoteOn, bool quantizeNoteOff, MidiServiceS midiService) const
+void MidiImporter::importTo(const MidiFileData & data, SongS song, MidiImportMode importMode, int patternLength, bool quantizeNoteOn, bool quantizeNoteOff, MidiServiceS midiService) const
 {
     initializeSong(song, data, importMode, patternLength);
 

src/infra/midi/import/midi_importer.hpp

@@ -16,6 +16,8 @@
 #ifndef MIDI_IMPORTER_HPP
 #define MIDI_IMPORTER_HPP
 
+#include "../../../domain/midi_import_mode.hpp"
+
 #include <cstdint>
 #include <istream>
 #include <map>
@@ -69,7 +71,7 @@ class MidiImporter
 
     MidiFileData parseMidiFile(const std::string & fileName) const;
 
-    void importTo(const MidiFileData & data, SongS song, int importMode, int patternLength, bool quantizeNoteOn, bool quantizeNoteOff, MidiServiceS midiService) const;
+    void importTo(const MidiFileData & data, SongS song, MidiImportMode importMode, int patternLength, bool quantizeNoteOn, bool quantizeNoteOff, MidiServiceS midiService) const;
 
 private:
     struct PatternLine
@@ -78,10 +80,10 @@ class MidiImporter
         size_t lineIndex;
     };
 
-    void initializeSong(SongS song, const MidiFileData & data, int importMode, int patternLength) const;
+    void initializeSong(SongS song, const MidiFileData & data, MidiImportMode importMode, int patternLength) const;
     PatternLine getPatternLine(SongS song, size_t scaledTick, int patternLength) const;
     size_t getFreeColumn(SongS song, size_t patternIndex, size_t trackIndex, size_t lineIndex, const std::map<uint8_t, size_t> & activeNotes) const;
-    void finalizePlayOrder(SongS song, size_t maxPatternIndex, int importMode, int patternLength) const;
+    void finalizePlayOrder(SongS song, size_t maxPatternIndex, MidiImportMode importMode, int patternLength) const;
 
     uint32_t readBeU32(std::istream & in) const;
     uint16_t readBeU16(std::istream & in) const;

src/unit_tests/midi_importer_test/midi_importer_test.cpp

@@ -82,7 +82,7 @@ void MidiImporterTest::test_import_exportedFile_shouldRestoreNotes()
     importedSong->setLinesPerBeat(4);
 
     const auto midiData = importer.parseMidiFile(fileName.toStdString());
-    importer.importTo(midiData, importedSong, 0, 64, false, false, nullptr);
+    importer.importTo(midiData, importedSong, MidiImportMode::Overwrite, 64, false, false, nullptr);
 
     QCOMPARE(importedSong->beatsPerMinute(), 140);
     // Noteahead initializes with 8 tracks by default
@@ -142,7 +142,7 @@ void MidiImporterTest::test_import_multipleTracksAndPatterns_shouldRestoreCorrec
 
     const auto midiData = importer.parseMidiFile(fileName.toStdString());
     // Use pattern length 4 to match original structure
-    importer.importTo(midiData, importedSong, 0, 4, false, false, nullptr);
+    importer.importTo(midiData, importedSong, MidiImportMode::Overwrite, 4, false, false, nullptr);
 
     QCOMPARE(importedSong->trackCount(), 8);
     QCOMPARE(QString::fromStdString(importedSong->trackName(0)), QString { "Melody" });
@@ -199,7 +199,7 @@ void MidiImporterTest::test_import_polyphony_shouldCreateNewColumns()
     importedSong->setLinesPerBeat(4);
 
     const auto midiData = importer.parseMidiFile(fileName.toStdString());
-    importer.importTo(midiData, importedSong, 0, 64, false, false, nullptr);
+    importer.importTo(midiData, importedSong, MidiImportMode::Overwrite, 64, false, false, nullptr);
 
     // Should have 3 columns on track 0
     QCOMPARE(importedSong->columnCount(0), 3);
@@ -254,7 +254,7 @@ void MidiImporterTest::test_import_quantization_shouldZeroDelays()
     const auto midiData = importer.parseMidiFile(fileName.toStdString());
 
     // Import with quantization enabled
-    importer.importTo(midiData, importedSong, 0, 64, true, true, nullptr);
+    importer.importTo(midiData, importedSong, MidiImportMode::Overwrite, 64, true, true, nullptr);
 
     const auto noteOnQuantized = importedSong->noteDataAtPosition({ 0, 0, 0, 0 });
     const auto noteOffQuantized = importedSong->noteDataAtPosition({ 0, 0, 0, 1 });
@@ -266,7 +266,7 @@ void MidiImporterTest::test_import_quantization_shouldZeroDelays()
     const auto importedSongNoQuantize = std::make_shared<Song>();
     importedSongNoQuantize->setBeatsPerMinute(120);
     importedSongNoQuantize->setLinesPerBeat(4);
-    importer.importTo(midiData, importedSongNoQuantize, 0, 64, false, false, nullptr);
+    importer.importTo(midiData, importedSongNoQuantize, MidiImportMode::Overwrite, 64, false, false, nullptr);
 
     const auto noteOnNotQuantized = importedSongNoQuantize->noteDataAtPosition({ 0, 0, 0, 0 });
     const auto noteOffNotQuantized = importedSongNoQuantize->noteDataAtPosition({ 0, 0, 0, 1 });
@@ -313,7 +313,7 @@ void MidiImporterTest::test_import_bankAndProgramChange_shouldRestoreSettings()
 
     const auto importedSong = std::make_shared<Song>();
     const auto midiData = importer.parseMidiFile(fileName.toStdString());
-    importer.importTo(midiData, importedSong, 0, 64, false, false, midiService);
+    importer.importTo(midiData, importedSong, MidiImportMode::Overwrite, 64, false, false, midiService);
 
     const auto importedInstrument = importedSong->instrument(0);
     QVERIFY(importedInstrument != nullptr);

src/view/qml/Editor/Track.qml

@@ -164,13 +164,19 @@ Rectangle {
             resize(rootItem.width, rootItem.height);
         }
         function setColumnMuted(columnIndex: int, muted: bool): void {
-            _noteColumns[columnIndex].setMuted(muted);
+            if (_noteColumns[columnIndex]) {
+                _noteColumns[columnIndex].setMuted(muted);
+            }
         }
         function setColumnSoloed(columnIndex: int, soloed: bool): void {
-            _noteColumns[columnIndex].setSoloed(soloed);
+            if (_noteColumns[columnIndex]) {
+                _noteColumns[columnIndex].setSoloed(soloed);
+            }
         }
         function setColumnVelocityScale(columnIndex: int, value: int): void {
-            _noteColumns[columnIndex].setVelocityScale(value);
+            if (_noteColumns[columnIndex]) {
+                _noteColumns[columnIndex].setVelocityScale(value);
+            }
         }
         function clearMixerSettings(): void {
             _noteColumns.forEach(noteColumn => {