toolbar ¶

def get_notches(self) -> Notches:
    from .custom import Notches
    return Notches()

def get_separator(self, horizontal: bool = False) -> QFrame:
    separator = QFrame(self)
    separator.setFrameShape(QFrame.Shape.HLine if horizontal else QFrame.Shape.VLine)
    separator.setFrameShadow(QFrame.Shadow.Sunken)
    return separator

def init_notches(self, main: MainWindow = ...) -> None:
    self.notches_changed.connect(main.timeline.update_notches)

def on_copy_frame_button_clicked(self, checked: bool | None = None) -> None:
    self.main.clipboard.setText(str(self.main.current_output.last_showed_frame))
    self.main.show_message('Current frame number copied to clipboard')

def on_copy_timestamp_button_clicked(self, checked: bool | None = None) -> None:
    self.main.clipboard.setText(self.time_control.text())
    self.main.show_message('Current timestamp copied to clipboard')

def on_current_frame_changed(self, frame: Frame) -> None:
    qt_silent_call(self.frame_control.setValue, frame)
    qt_silent_call(self.time_control.setValue, Time(frame))

    if self.outputs and len(self.outputs) > 1 and self.sync_outputs_checkbox.isChecked():
        self.on_sync_outputs_clicked(True, force_frame=frame)

def on_current_output_changed(self, index: int, prev_index: int) -> None:
    qt_silent_call(self.outputs_combobox.setCurrentIndex, index)
    qt_silent_call(self.frame_control.setMaximum, self.main.current_output.total_frames - 1)
    qt_silent_call(self.time_control.setMaximum, self.main.current_output.total_time)

def on_switch_timeline_mode_clicked(self, checked: bool | None = None) -> None:
    if self.main.timeline.mode == self.main.timeline.Mode.TIME:
        self.main.timeline.mode = self.main.timeline.Mode.FRAME
    elif self.main.timeline.mode == self.main.timeline.Mode.FRAME:
        self.main.timeline.mode = self.main.timeline.Mode.TIME

def on_sync_outputs_clicked(self, checked: bool | None = None, force_frame: Frame | None = None) -> None:
    if not self.outputs:
        return

    if checked:
        from ...main.timeline import Timeline

        if not force_frame:
            force_frame = self.main.current_output.last_showed_frame

        if self.main.timeline.mode == Timeline.Mode.TIME:
            for output in self.outputs:
                output.last_showed_frame = output.to_frame(
                    self.main.current_output.to_time(force_frame)
                )
        else:
            for output in self.outputs:
                output.last_showed_frame = force_frame

def on_toggle(self, new_state: bool) -> None:
    if new_state == self.visibility:
        return

    # invoking order matters
    self.setVisible(new_state)
    self.visibility = new_state
    self.toggle_button.setChecked(new_state)
    self.resize_main_window(new_state)

def rescan_outputs(self, outputs: VideoOutputs | None = None) -> None:
    self.outputs = outputs if isinstance(outputs, VideoOutputs) else VideoOutputs(self.main)
    self.main.init_outputs()
    self.outputs_combobox.setModel(self.outputs)

def resize_main_window(self, expanding: bool) -> None:
    if self.main.windowState() in {Qt.WindowState.WindowMaximized, Qt.WindowState.WindowFullScreen}:
        return

    if expanding:
        self.main.resize(self.main.width(), self.main.height() + self.height() + round(6 * self.main.display_scale))
    if not expanding:
        self.main.resize(self.main.width(), self.main.height() - self.height() - round(6 * self.main.display_scale))
        self.main.timeline.update()

def set_qobject_names(self) -> None:
    if not hasattr(self, '__slots__'):
        return

    slots = list(self.__slots__)

    if isinstance(self, AbstractToolbar) and 'main' in slots:
        slots.remove('main')

    for attr_name in slots:
        attr = getattr(self, attr_name)
        if not isinstance(attr, QObject):
            continue
        attr.setObjectName(type(self).__name__ + '.' + attr_name)

def setup_ui(self) -> None:
    super().setup_ui()

    self.setVisible(True)

    self.outputs_combobox = ComboBox[VideoOutput](
        self, editable=True, insertPolicy=QComboBox.InsertPolicy.InsertAtCurrent,
        duplicatesEnabled=True, sizeAdjustPolicy=QComboBox.SizeAdjustPolicy.AdjustToContents
    )
    self.outputs_combobox.currentIndexChanged.connect(self.main.switch_output)
    self.outputs_combobox.view().setMinimumWidth(
        self.outputs_combobox.minimumSizeHint().width()
    )

    self.frame_control = FrameEdit(self, valueChanged=self.main.switch_frame)
    if not self.settings.INSTANT_FRAME_UPDATE:
        self.frame_control.setKeyboardTracking(False)

    self.copy_frame_button = PushButton('⎘', self, clicked=self.on_copy_frame_button_clicked)

    self.time_control = TimeEdit(self, valueChanged=self.main.switch_frame)

    self.copy_timestamp_button = PushButton('⎘', self, clicked=self.on_copy_timestamp_button_clicked)

    self.sync_outputs_checkbox = CheckBox(
        'Sync Outputs', self, checked=self.settings.SYNC_OUTPUTS, clicked=self.on_sync_outputs_clicked
    )

    self.switch_timeline_mode_button = PushButton(
        'Switch Timeline Mode', self, clicked=self.on_switch_timeline_mode_clicked
    )

    self.settings_button = PushButton('Settings', self, clicked=self.main.app_settings.show)

    self.hlayout.addWidgets([
        self.outputs_combobox,
        self.frame_control, self.copy_frame_button,
        self.time_control, self.copy_timestamp_button,
        self.sync_outputs_checkbox,
        self.get_separator(),
        self.main.graphics_view.controls,
        self.switch_timeline_mode_button,
        self.settings_button
    ])

    self.hlayout.addStretch()