'Backup'

Author: lebrunthibault

application/control_surface/group/ActionGroupTest.py

@@ -55,20 +55,20 @@ def configure(self):
     def action_log_midi(self):
         # type: () -> None
         if isinstance(Song.selected_clip(), MidiClip):
-            Logger.dev("midi hash: %s" % Song.selected_clip(MidiClip).midi_hash)
-            Logger.dev("previous midi hash: %s" % Song.selected_clip(MidiClip).previous_midi_hash)
+            Logger.info("midi hash: %s" % Song.selected_clip(MidiClip).midi_hash)
+            Logger.info("previous midi hash: %s" % Song.selected_clip(MidiClip).previous_midi_hash)
         else:
             track = Song.selected_track(SimpleAudioTrack)
-            Logger.dev(track.audio_to_midi_clip_mapping._file_path_mapping)
+            Logger.info(track.audio_to_midi_clip_mapping._file_path_mapping)
             midi_hash = track.audio_to_midi_clip_mapping._file_path_mapping.get(
                 Song.selected_clip(AudioClip).file_path, None
             )
-            Logger.dev("midi hash: %s" % midi_hash)
-            Logger.dev(
+            Logger.info("midi hash: %s" % midi_hash)
+            Logger.info(
                 "midi hash equivalences: %s"
                 % track.audio_to_midi_clip_mapping._midi_hash_equivalences.get(midi_hash, None)
             )
 
     def action_test(self):
         # type: () -> None
-        pass
+        Backend.client().show_plugins()

domain/lom/device/DeviceDisplayService.py

@@ -9,6 +9,7 @@
 from protocol0.domain.shared.BrowserServiceInterface import BrowserServiceInterface
 from protocol0.domain.shared.backend.Backend import Backend
 from protocol0.domain.shared.errors.Protocol0Error import Protocol0Error
+from protocol0.domain.shared.scheduler.Scheduler import Scheduler
 from protocol0.shared.sequence.Sequence import Sequence
 
 
@@ -31,6 +32,7 @@ def make_plugin_window_showable(self, track, device, slow):
         parent_rack = self._find_parent_rack(track, device)
         seq = Sequence()
         seq.add(ApplicationViewFacade.show_device)
+        Scheduler.wait_ms(1000, Backend.client().show_plugins)  # because of the keyboard shortcut
         seq.defer()
 
         if not parent_rack:
@@ -52,10 +54,7 @@ def _make_top_device_window_showable(self, track, device, slow):
         seq.add(
             lambda: Backend.client().toggle_ableton_button(x=x_device, y=y_device, activate=True)
         )
-        if slow:
-            seq.wait(60)
-        else:
-            seq.wait(30)
+        seq.wait(60 if slow else 30)
         seq.add(partial(self._un_collapse_devices, devices_to_collapse))
 
         return seq.done()

domain/lom/instrument/InstrumentDisplayService.py

@@ -64,7 +64,7 @@ def _on_instrument_selected_event(self, _):
         # type: (InstrumentSelectedEvent) -> Optional[Sequence]
         return self.show_instrument(Song.current_track())
 
-    def activate_plugin_window(self, track, force_activate=False, slow=True):
+    def activate_plugin_window(self, track, force_activate=False, slow=False):
         # type: (SimpleTrack, bool, bool) -> Optional[Sequence]
         seq = Sequence()
         instrument = track.instrument

domain/lom/scene/Scene.py

@@ -82,8 +82,6 @@ def on_added(self):
     @property
     def next_scene(self):
         # type: () -> Scene
-        from protocol0.shared.logging.Logger import Logger
-        Logger.dev("self.should_loop: %s" % self.should_loop)
         if self.should_loop:
             return self
         else:
@@ -133,12 +131,8 @@ def on_bar_end(self):
         if Song.is_track_recording():
             return
 
-        from protocol0.shared.logging.Logger import Logger
-        Logger.dev(self.playing_state.in_last_bar)
         if self.playing_state.in_last_bar:
             next_scene = self.next_scene
-            from protocol0.shared.logging.Logger import Logger
-            Logger.dev(next_scene)
 
             if next_scene != self:
                 next_scene.fire()  # do not fire same scene as it focus it again (can lose current parameter focus)
@@ -186,8 +180,6 @@ def fire(self):
         # stop the previous scene in advance, using clip launch quantization
         DomainEventBus.emit(SceneFiredEvent(self.index))
 
-        from protocol0.shared.logging.Logger import Logger
-        Logger.dev("firing %s" % self)
         self._scene.fire()
 
     def stop(self, next_scene=None, immediate=False):