from enum import Enum, IntEnum from typing import TYPE_CHECKING, Optional from qtpy.QtCore import QTimer, Slot, QPoint, QObject, Qt # type:ignore from qtpy.QtGui import QPalette, QIcon if TYPE_CHECKING: # FIX : QAction not found by pylance from qtpy.QtGui import QAction from qtpy.QtWidgets import ( QWidget, QMainWindow, QAction, QApplication, QMenu) # type:ignore from patshared import TransportPosition from .widgets.bar_widget_jack import BarWidgetJack from .widgets.bar_widget_transport import BarWidgetTransport from .widgets.bar_widget_canvas import BarWidgetCanvas from .bases.elements import ToolDisplayed if TYPE_CHECKING: from .patchbay_manager import PatchbayManager from .widgets.tool_bar import PatchbayToolBar _translate = QApplication.translate def is_dark_theme(widget: QWidget) -> bool: return bool( widget.palette().brush( QPalette.ColorGroup.Active, QPalette.ColorRole.WindowText).color().lightness() > 128) class JackAgnostic(Enum): 'Enum used by Patchichi to set what is displayed' NONE = 0 'Not JACK agnostic, used by Patchance and RaySession' DUMMY = 1 'JACK agnostic in reality, but display all widgets' FULL = 2 'Hide all widgets related to JACK' class TextWithIcons(Enum): NO = 0 AUTO = 1 YES = 2 @classmethod def by_name(cls, name: str) -> 'TextWithIcons': if name == 'NO': return cls.NO if name == 'YES': return cls.YES return cls.AUTO class TBar(IntEnum): MAIN = 0 TRANSPORT = 1 JACK = 2 CANVAS = 3 class PatchbayToolsWidget(QObject): def __init__(self): QObject.__init__(self) self._jack_running = True self.mng: 'Optional[PatchbayManager]' = None self.no_text_with_icons_act = False self._jack_agnostic = JackAgnostic.NONE self._tools_displayed = ToolDisplayed.ALL self.tbars : Optional[tuple[PatchbayToolBar, ...]] = None self._last_layout = '' self._text_with_icons = TextWithIcons.AUTO self._transport_wg: Optional[BarWidgetTransport] = None self._jack_wg: Optional[BarWidgetJack] = None self._canvas_wg: Optional[BarWidgetCanvas] = None self._last_win_width = 0 self._main_bar_little_width = 0 self._main_bar_large_width = 0 self._first_resize_done = False @staticmethod def _make_context_actions() -> dict[ToolDisplayed, QAction]: return { ToolDisplayed.UNDO_REDO: QAction(QIcon.fromTheme('edit-undo'), _translate('tool_bar', 'Undo / Redo')), ToolDisplayed.VIEWS_SELECTOR: QAction(QIcon.fromTheme('view-multiple-objects'), _translate('tool_bar', 'Views selector')), ToolDisplayed.HIDDENS_BOX: QAction(QIcon.fromTheme('hint'), _translate('tool_bar', 'Hidden boxes')), ToolDisplayed.PORT_TYPES_VIEW: QAction(QIcon.fromTheme('view-filter'), _translate('tool_bar', 'Type filter')), ToolDisplayed.ZOOM_SLIDER: QAction(QIcon.fromTheme('zoom-select'), _translate('tool_bar', 'Zoom slider')), ToolDisplayed.TRANSPORT_CLOCK: QAction(QIcon.fromTheme('clock'), _translate('tool_bar', 'Transport clock')), ToolDisplayed.TRANSPORT_PLAY_STOP: QAction(QIcon.fromTheme('media-playback-pause'), _translate('tool_bar', 'Transport Play/Stop')), ToolDisplayed.TRANSPORT_TEMPO: QAction(QIcon.fromTheme('folder-music-symbolic'), _translate('tool_bar', 'Transport Tempo')), ToolDisplayed.BUFFER_SIZE: QAction(QIcon.fromTheme('settings-configure'), _translate('tool_bar', 'Buffer size')), ToolDisplayed.SAMPLERATE: QAction(QIcon.fromTheme('filename-sample-rate'), _translate('tool_bar', 'Sample rate')), ToolDisplayed.LATENCY: QAction(QIcon.fromTheme('chronometer-lap'), _translate('tool_bar', 'Latency')), ToolDisplayed.XRUNS: QAction(QIcon.fromTheme('data-error'), _translate('tool_bar', 'Xruns')), ToolDisplayed.DSP_LOAD: QAction(QIcon.fromTheme('histogram-symbolic'), _translate('tool_bar', 'DSP Load')) } def _make_context_menu( self, context_actions: dict[ToolDisplayed, QAction]) -> QMenu: menu = QMenu() menu.addSection(_translate('tool_bar', 'Displayed tools')) for key, act in context_actions.items(): act.setCheckable(True) act.setChecked(bool(self._tools_displayed & key)) if self.mng is not None: if not self.mng.server_is_started: if key in (ToolDisplayed.UNDO_REDO, ToolDisplayed.VIEWS_SELECTOR, ToolDisplayed.PORT_TYPES_VIEW, ToolDisplayed.HIDDENS_BOX, ToolDisplayed.ZOOM_SLIDER): act.setEnabled(self.mng.alsa_midi_enabled) else: act.setEnabled(False) if self._jack_agnostic is JackAgnostic.FULL: if key in (ToolDisplayed.TRANSPORT_CLOCK, ToolDisplayed.TRANSPORT_PLAY_STOP, ToolDisplayed.TRANSPORT_TEMPO, ToolDisplayed.BUFFER_SIZE, ToolDisplayed.SAMPLERATE, ToolDisplayed.LATENCY, ToolDisplayed.XRUNS, ToolDisplayed.DSP_LOAD): continue menu.addAction(act) if key is ToolDisplayed.ZOOM_SLIDER: menu.addSeparator() return menu def set_patchbay_manager(self, mng: 'PatchbayManager'): self.mng = mng if self._canvas_wg is not None: self._canvas_wg.set_patchbay_manager(mng) if self._transport_wg is not None: self._transport_wg.set_patchbay_manager(mng) if self._jack_wg is not None: self._jack_wg.set_patchbay_manager(mng) def set_tool_bars(self, *tool_bars: 'PatchbayToolBar'): self.tbars = tool_bars if self._transport_wg is None: self._transport_wg = BarWidgetTransport( self.tbars[TBar.TRANSPORT]) if self._jack_wg is None: self._jack_wg = BarWidgetJack(self.tbars[TBar.JACK]) if self._canvas_wg is None: self._canvas_wg = BarWidgetCanvas(self.tbars[TBar.CANVAS]) if self._text_with_icons is not TextWithIcons.NO: # evaluate main bar widths (with and without text beside icons) main_bar = self.tbars[TBar.MAIN] tool_button_style = main_bar.toolButtonStyle() main_bar.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly) self._main_bar_little_width = main_bar.sizeHint().width() main_bar.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon) self._main_bar_large_width = main_bar.sizeHint().width() main_bar.setToolButtonStyle(tool_button_style) self.tbars[TBar.TRANSPORT].addWidget(self._transport_wg) self.tbars[TBar.JACK].addWidget(self._jack_wg) self.tbars[TBar.CANVAS].addWidget(self._canvas_wg) for tbar in self.tbars: tbar.toggleViewAction().setEnabled(False) tbar.toggleViewAction().setVisible(False) tbar.menu_asked.connect(self._menu_asked) def change_text_with_icons(self, text_with_icons: TextWithIcons): if text_with_icons is self._text_with_icons: return self._text_with_icons = text_with_icons if self.tbars is None: return main_bar = self.tbars[TBar.MAIN] main_bar.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly) self._main_bar_little_width = main_bar.sizeHint().width() main_bar.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon) self._main_bar_large_width = main_bar.sizeHint().width() self._resize_later() @Slot(QPoint) def _menu_asked(self, point: QPoint): context_actions = self._make_context_actions() menu = self._make_context_menu(context_actions) act_text_with_icons = QAction( QIcon.fromTheme('format-text-direction-symbolic'), _translate('tool_bar', 'Display text beside icons')) act_text_with_icons.setCheckable(True) act_text_with_icons.setChecked( self._text_with_icons is TextWithIcons.YES) if not self.no_text_with_icons_act: menu.addSeparator() menu.addAction(act_text_with_icons) selected_act = menu.exec(point) if selected_act is None: return if selected_act is act_text_with_icons: if act_text_with_icons.isChecked(): self._text_with_icons = TextWithIcons.YES else: self._text_with_icons = TextWithIcons.NO for key, act in context_actions.items(): if act is selected_act: if act.isChecked(): self._tools_displayed |= key else: self._tools_displayed &= ~key self.change_tools_displayed(self._tools_displayed) def set_jack_agnostic(self, agnostic: JackAgnostic): '''Use without any jack tool. Used by Patchichi.''' self._jack_agnostic = agnostic self.change_tools_displayed(self._tools_displayed) def change_tools_displayed(self, tools_displayed: ToolDisplayed): self._tools_displayed = tools_displayed if (self._jack_agnostic is not JackAgnostic.FULL and not self._jack_running): if self.mng is not None: self.set_jack_running( False, use_alsa_midi=self.mng.alsa_midi_enabled) return if self.tbars is None: return if self._canvas_wg is not None: self._canvas_wg.change_tools_displayed(tools_displayed) if self._transport_wg is not None: self._transport_wg.change_tools_displayed(tools_displayed) if self._jack_wg is not None: self._jack_wg.change_tools_displayed(tools_displayed) if self._jack_agnostic is JackAgnostic.FULL: if self._jack_wg is not None: self._jack_wg.setVisible(False) if self._transport_wg is not None: self._transport_wg.setVisible(False) elif self._jack_agnostic is JackAgnostic.DUMMY: if self._jack_wg is not None: self._jack_wg.set_jack_running(True) self._jack_wg.set_dsp_load(2) QTimer.singleShot(0, self._resize_later) @Slot() def _resize_later(self): if self.mng is not None and self.mng.main_win is not None: self.main_win_resize(self.mng.main_win) def set_samplerate(self, samplerate: int): if self._jack_wg is not None: self._jack_wg.set_samplerate(samplerate) if self._transport_wg is not None: self._transport_wg.set_samplerate(samplerate) def set_buffer_size(self, buffer_size: int): if self._jack_wg is not None: self._jack_wg.set_buffer_size(buffer_size) def update_xruns(self): if self._jack_wg is not None: self._jack_wg.update_xruns() def add_xrun(self): if self._jack_wg is not None: self._jack_wg.add_xrun() def reset_xruns(self): if self._jack_wg is not None: self._jack_wg.reset_xruns() def set_dsp_load(self, dsp_load: int): if self._jack_wg is not None: self._jack_wg.set_dsp_load(dsp_load) def change_buffersize(self, buffersize: int): if self._jack_wg is not None: self._jack_wg.change_buffersize(buffersize) def refresh_transport(self, transport_pos: TransportPosition): if self._transport_wg is not None: self._transport_wg.refresh_transport(transport_pos) def set_jack_running(self, yesno: bool, use_alsa_midi=False): self._jack_running = yesno if self._transport_wg is not None: self._transport_wg.set_jack_running(yesno) if self._jack_wg is not None: self._jack_wg.set_jack_running(yesno) if yesno: self.change_tools_displayed(self._tools_displayed) def _canvas_is_last_of_line(self, layout: str) -> bool: for line in layout.split('_'): if line.endswith('C'): return True return False def _get_toolbars_layout( self, width: int, text_icons=TextWithIcons.AUTO) -> str: if self.tbars is None: return '' tbar_widths = [b.needed_width() for b in self.tbars] if text_icons is TextWithIcons.NO: tbar_widths[TBar.MAIN] = self._main_bar_little_width elif text_icons is TextWithIcons.YES: tbar_widths[TBar.MAIN] = self._main_bar_large_width m, t, j, c = tbar_widths # Main, Transport, Jack, Canvas # '_' for toolbarBreak (new line) if self._jack_agnostic is JackAgnostic.FULL: if width >= m + c: return 'MC' return 'M_C' if width >= sum(tbar_widths): return 'MCTJ' if width >= m + t + j: return 'MTJ_C' if width >= m + j: if width >= t + c: return 'MJ_CT' return 'MJ_T_C' if width >= c + t + j: return 'M_TJC' if width >= t + j: return 'M_TJ_C' if width >= t + c: return 'M_J_CT' return 'M_J_T_C' def main_win_resize(self, main_win: QMainWindow): if self.tbars is None: return self._last_win_width = main_win.width() if self._text_with_icons is TextWithIcons.AUTO: layout_little = self._get_toolbars_layout( self._last_win_width, TextWithIcons.NO) layout_large = self._get_toolbars_layout( self._last_win_width, TextWithIcons.YES) little_lines = len(layout_little.split('_')) large_lines = len(layout_large.split('_')) if little_lines < large_lines: layout = layout_little self.tbars[TBar.MAIN].setToolButtonStyle( Qt.ToolButtonStyle.ToolButtonIconOnly) else: layout = layout_large if self._main_bar_large_width < self._last_win_width: self.tbars[TBar.MAIN].setToolButtonStyle( Qt.ToolButtonStyle.ToolButtonTextBesideIcon) else: self.tbars[TBar.MAIN].setToolButtonStyle( Qt.ToolButtonStyle.ToolButtonIconOnly) elif self._text_with_icons is TextWithIcons.YES: if (self._main_bar_large_width > self._last_win_width): self.tbars[TBar.MAIN].setToolButtonStyle( Qt.ToolButtonStyle.ToolButtonIconOnly) else: self.tbars[TBar.MAIN].setToolButtonStyle( Qt.ToolButtonStyle.ToolButtonTextBesideIcon) layout = self._get_toolbars_layout(self._last_win_width) else: self.tbars[TBar.MAIN].setToolButtonStyle( Qt.ToolButtonStyle.ToolButtonIconOnly) layout = self._get_toolbars_layout(self._last_win_width) if (layout == self._last_layout): self._arrange_tool_bars() return self._last_layout = layout # add/remove spacer at right of canvas bar widget if self._canvas_wg is not None: self._canvas_wg.set_at_end_of_line( self._canvas_is_last_of_line(self._last_layout)) self._arrange_tool_bars() visibles = [t.isVisible() for t in self.tbars] if (self._first_resize_done and visibles == [False, False, False, False]): return for toolbar in self.tbars: main_win.removeToolBar(toolbar) letter_bar = {'M': TBar.MAIN, 'T': TBar.TRANSPORT, 'C': TBar.CANVAS, 'J': TBar.JACK} for letter in layout: if letter == '_': main_win.addToolBarBreak() elif letter in letter_bar: main_win.addToolBar(self.tbars[letter_bar[letter]]) for i in range(len(self.tbars)): if (self._jack_agnostic is JackAgnostic.FULL and i in (TBar.JACK, TBar.TRANSPORT)): continue self.tbars[i].setVisible(True) self._first_resize_done = True def _arrange_tool_bars(self): if self.tbars is None: return tbar_widths = [b.needed_width() for b in self.tbars] m, t, j, c = tbar_widths if self._last_layout in ('MCTJ', 'M_CTJ', 'MJ_CT'): diff = self._last_win_width - t - c if self._last_layout in ('MCTJ', 'M_CTJ'): diff -= j if self._last_layout == 'MCTJ': diff -= m if diff > 0: self.tbars[TBar.CANVAS].set_min_width(c + int(diff * 1.0)) else: for tbar in self.tbars: tbar.set_min_width(None) elif self._last_layout in ('MTJ_C', 'M_TJ_C'): diff = self._last_win_width - t - j if self._last_layout == 'MTJ_C': diff -= m if diff > 0: self.tbars[TBar.TRANSPORT].set_min_width(t + diff) else: for tbar in self.tbars: tbar.set_min_width(None) else: for tbar in self.tbars: tbar.set_min_width(None)