Midi port selection based on selected controller (#79)

Author: modyf01

midi_app_controller/gui/midi_status.py

@@ -40,7 +40,7 @@ class MidiStatus(QWidget):
     current_midi_in : DynamicQComboBox
         Button that allows to select MIDI input port using its menu. Its
         text is set to currently selected port.
-    current_midi_in : DynamicQComboBox
+    current_midi_out : DynamicQComboBox
         Button that allows to select MIDI output port using its menu. Its
         text is set to currently selected port.
     status : QLabel
@@ -159,6 +159,10 @@ def refresh(self):
 
         self.current_binds.refresh_items()
         self.current_binds.set_current(state.selected_binds)
+        self.current_midi_in.refresh_items()
+        self.current_midi_in.set_current(state.selected_midi_in)
+        self.current_midi_out.refresh_items()
+        self.current_midi_out.set_current(state.selected_midi_out)
         self.show_binds_file_button.setEnabled(state.selected_binds is not None)
         self.edit_binds_button.setEnabled(state.selected_binds is not None)
         self.delete_binds_button.setEnabled(state.selected_binds is not None)
@@ -182,6 +186,7 @@ def _select_controller(self, controller: Optional[SelectedItem]) -> None:
         state = get_state_manager()
         state.select_controller(controller)
         state.select_recent_binds()
+        state.select_recent_midi_ports()
         self.refresh()
 
     def _copy_binds(self) -> None:

midi_app_controller/models/app_state.py

@@ -19,6 +19,8 @@ class AppState(YamlBaseModel):
         Selected MIDI output port.
     recent_binds_for_controller: dict[Path, Optional[Path]]
         Mapping between each controller and which binds setup was last used.
+    recent_midi_ports_for_controller: dict[Path, dict[str, Optional[str]]]
+        Mapping between controllers and the last used MIDI ports (in/out)
     """
 
     selected_controller_path: Optional[Path]
@@ -27,3 +29,4 @@ class AppState(YamlBaseModel):
     selected_midi_out: Optional[str]
 
     recent_binds_for_controller: dict[Path, Optional[Path]]
+    recent_midi_ports_for_controller: dict[Path, dict[str, Optional[str]]]

midi_app_controller/state/_tests/test_state_manager.py

@@ -402,3 +402,40 @@ def test_start_handling_without_fields_set(mock_midi_in_out, state_manager):
     with pytest.raises(Exception) as excinfo:
         state_manager.start_handling()
     assert "No MIDI output" not in str(excinfo.value)
+
+
+@pytest.mark.parametrize(
+    (
+        "available_midi_in, available_midi_out, recent_ports, "
+        "expected_midi_in, expected_midi_out"
+    ),
+    [
+        (["in1", "in2"], ["out1", "out2"], {"in": "in1", "out": "out2"}, "in1", "out2"),
+        (["in1", "in2"], ["out1", "out2"], {}, None, None),
+        (["in1", "in2"], ["out1", "out2"], {"in": "in3", "out": "out3"}, None, None),
+    ],
+)
+def test_select_recent_midi_ports(
+    mock_midi_in_out,
+    state_manager,
+    available_midi_in,
+    available_midi_out,
+    recent_ports,
+    expected_midi_in,
+    expected_midi_out,
+):
+    mock_midi_in, mock_midi_out = mock_midi_in_out
+    mock_midi_in.get_ports.return_value = available_midi_in
+    mock_midi_out.get_ports.return_value = available_midi_out
+
+    controller_path = Path("test_controller_path")
+    state_manager.selected_controller = SelectedItem("TestController", controller_path)
+
+    state_manager.recent_midi_ports_for_controller = (
+        {controller_path: recent_ports} if recent_ports else {}
+    )
+
+    state_manager.select_recent_midi_ports()
+
+    assert state_manager.selected_midi_in == expected_midi_in
+    assert state_manager.selected_midi_out == expected_midi_out

midi_app_controller/state/state_manager.py

@@ -49,6 +49,10 @@ class StateManager:
     recent_binds_for_controller: dict[Path, Path] = {}
         Mapping of controller schemas to the binds set most recently used
         with the schema.
+    recent_midi_ports_for_controller: dict[Path, dict[str, str]]
+        Mapping of controller schemas to the MIDI ports most
+        recently used (precisely dict with keys "in" and "out")
+        with the schema.
     selected_midi_in : Optional[str]
         Name of currently selected MIDI input.
     selected_midi_out : Optional[str]
@@ -68,7 +72,8 @@ class StateManager:
     def __init__(self, app: Application):
         self.selected_controller = None
         self.selected_binds = None
-        self.recent_binds_for_controller: dict[Path, Path] = {}
+        self.recent_binds_for_controller = {}
+        self.recent_midi_ports_for_controller = {}
         self.selected_midi_in = None
         self.selected_midi_out = None
         self.app = app
@@ -204,13 +209,23 @@ def select_midi_in(self, port_name: Optional[str]) -> None:
         Does not have any immediate effect except updating the value.
         """
         self.selected_midi_in = port_name
+        if self.selected_controller:
+            self.recent_midi_ports_for_controller[self.selected_controller.path] = {
+                "in": self.selected_midi_in,
+                "out": self.selected_midi_out,
+            }
 
     def select_midi_out(self, port_name: Optional[str]) -> None:
         """Updates currently selected MIDI output port name.
 
         Does not have any immediate effect except updating the value.
         """
         self.selected_midi_out = port_name
+        if self.selected_controller:
+            self.recent_midi_ports_for_controller[self.selected_controller.path] = {
+                "in": self.selected_midi_in,
+                "out": self.selected_midi_out,
+            }
 
     def stop_handling(self) -> None:
         """Stops handling any MIDI signals."""
@@ -269,6 +284,18 @@ def start_handling(self) -> None:
             midi_out=self._midi_out,
         )
 
+    def select_recent_midi_ports(self):
+        """Select MIDI ports that were recently used with the current controller."""
+        if (
+            self.selected_controller
+            and self.selected_controller.path in self.recent_midi_ports_for_controller
+        ):
+            ports = self.recent_midi_ports_for_controller[self.selected_controller.path]
+            if ports["in"] in self.get_available_midi_in():
+                self.selected_midi_in = ports["in"]
+            if ports["out"] in self.get_available_midi_out():
+                self.selected_midi_out = ports["out"]
+
     def save_state(self):
         """Saves the current settings to the disk."""
         AppState(
@@ -281,6 +308,7 @@ def save_state(self):
             selected_midi_in=self.selected_midi_in,
             selected_midi_out=self.selected_midi_out,
             recent_binds_for_controller=self.recent_binds_for_controller,
+            recent_midi_ports_for_controller=self.recent_midi_ports_for_controller,
         ).save_to(Config.APP_STATE_FILE)
 
     def load_state(self):
@@ -316,6 +344,7 @@ def load_state(self):
         self.select_midi_in(state.selected_midi_in)
         self.select_midi_out(state.selected_midi_out)
         self.recent_binds_for_controller = state.recent_binds_for_controller
+        self.recent_midi_ports_for_controller = state.recent_midi_ports_for_controller
 
 
 _STATE_MANAGER = None