main_window.py

        layout.addWidget(label)
        Hlayout.setSpacing(20)

        Hlayout.addWidget(self.creat_color_button(Execution_Time_Color))
        Hlayout.addWidget(self.creat_color_button(Latency_Color))
        Hlayout.addWidget(
            self.creat_color_button(
                ColorDataType(
                    current_color=Latency_Color.DEFAULT,
                    DEFAULT=QColor('skyblue'),
                    name="Latency Color per Type",
                )
            )
        )

        groupbox.setLayout(Hlayout)
        layout.addWidget(groupbox)

        label = QLabel("Signal Colors:")
        layout.addWidget(label)
        groupbox = QGroupBox()
        Hlayout = QHBoxLayout()
        Hlayout.setSpacing(20)

        Signal_button = self.creat_color_button(Signal_Color)
        Signal_button.setStyleSheet(
            f"color: {QColor(255,255,255,0).name()}; background-color: {Signal_Color.DEFAULT.name()}"
        )

        Hlayout.addWidget(Signal_button)
        Hlayout.addWidget(self.creat_color_button(Signal_Warning_Color))
        Hlayout.addWidget(self.creat_color_button(Active_Color))

        groupbox.setLayout(Hlayout)
        layout.addWidget(groupbox)

        Reset_Color_button = ColorButton(QColor('silver'))
        Reset_Color_button.setText('Reset All Color settings')
        Reset_Color_button.pressed.connect(self.reset_color_clicked)
        layout.addWidget(Reset_Color_button)

        label = QLabel("Font Settings:")
        layout.addWidget(label)

        groupbox = QGroupBox()
        Hlayout = QHBoxLayout()
        Hlayout.setSpacing(10)

        Font_button = ColorButton(QColor('moccasin'))
        Font_button.setText('Font Settings')
        Hlayout.addWidget(Font_button)

        Font_color_button = ColorButton(QColor('moccasin'))
        Font_color_button.setText('Font Color')
        Font_color_button.pressed.connect(self.font_color_clicked)
        Hlayout.addWidget(Font_color_button)

        groupbox2 = QGroupBox()
        Hlayout2 = QHBoxLayout()

        icon = QIcon.fromTheme("format-text-italic")
        Italicbutton = (
            ColorButton(QColor('silver'))
            if Font.italic
            else ColorButton(QColor('snow'))
        )
        Italicbutton.setIcon(icon)
        Italicbutton.pressed.connect(lambda: self.Italic_font_clicked(Italicbutton))
        Hlayout2.addWidget(Italicbutton)

        icon = QIcon.fromTheme("format-text-bold")
        Boldbutton = (
            ColorButton(QColor('silver')) if Font.bold else ColorButton(QColor('snow'))
        )
        Boldbutton.setIcon(icon)
        Boldbutton.pressed.connect(lambda: self.Bold_font_clicked(Boldbutton))
        Hlayout2.addWidget(Boldbutton)

        groupbox2.setLayout(Hlayout2)
        Hlayout.addWidget(groupbox2)

        groupbox2 = QGroupBox()
        Hlayout2 = QHBoxLayout()
        Font_Size_input = QLineEdit()
        Font_button.pressed.connect(
            lambda: self.font_clicked(Font_Size_input, Italicbutton, Boldbutton)
        )

        icon = QIcon.fromTheme("list-add")
        Incr_button = ColorButton(QColor('smoke'))
        Incr_button.setIcon(icon)
        Incr_button.pressed.connect(lambda: self.Incr_font_clicked(Font_Size_input))
        Incr_button.setShortcut(QCoreApplication.translate("MainWindow", "Ctrl++"))
        Hlayout2.addWidget(Incr_button)

        Font_Size_input.setPlaceholderText('Font Size')
        Font_Size_input.setText(f'Font Size: {Font.size}')
        Font_Size_input.setValidator(QIntValidator(0, 99))
        Font_Size_input.setAlignment(Qt.AlignCenter)
        Font_Size_input.textChanged.connect(
            lambda: self.set_fontSize_clicked(Font_Size_input.text())
        )
        Font_Size_input.textChanged.connect(
            lambda: self.set_fontSize_clicked(Font_Size_input.text())
        )
        Hlayout2.addWidget(Font_Size_input)

        icon = QIcon.fromTheme("list-remove")
        Decr_button = ColorButton(QColor('smoke'))
        Decr_button.setIcon(icon)
        Decr_button.pressed.connect(lambda: self.Decr_font_clicked(Font_Size_input))
        Decr_button.setShortcut(QCoreApplication.translate("MainWindow", "Ctrl+-"))

        Hlayout2.addWidget(Decr_button)

        groupbox2.setLayout(Hlayout2)
        Hlayout.addWidget(groupbox2)

        groupbox.setLayout(Hlayout)
        layout.addWidget(groupbox)

        Reset_Font_button = ColorButton(QColor('silver'))
        Reset_Font_button.setText('Reset All Font Settings')
        Reset_Font_button.pressed.connect(
            lambda: self.reset_font_clicked(Font_Size_input, Italicbutton, Boldbutton)
        )
        layout.addWidget(Reset_Font_button)

        label = QLabel("")
        layout.addWidget(label)

        Reset_button = ColorButton(QColor('salmon'))
        Reset_button.setText('Reset All Settings')
        Reset_button.pressed.connect(
            lambda: self.reset_all_clicked(Font_Size_input, Italicbutton, Boldbutton)
        )
        layout.addWidget(Reset_button)

        dialog.setLayout(layout)
        buttonBox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Close)
        buttonBox.ButtonLayout(QDialogButtonBox.MacLayout)
        buttonBox.accepted.connect(dialog.accept)
        buttonBox.rejected.connect(dialog.close)
        layout.addWidget(buttonBox)

        dialog.exec_()

    def creat_color_button(self, color: ColorDataType) -> ColorButton:
        """Create a colored button to be used to modify a certain color
        color_type: ColorDataType
            The color_type assigned to the butten to be created.
        """
        button = ColorButton(color.DEFAULT)
        button.setText(color.name)
        if color.name == "Latency Color":
            button.pressed.connect(
                lambda: self.set_latency_color_by_type_name(all=True)
            )
        elif color.name == "Latency Color per Type":
            button.pressed.connect(
                lambda: self.set_latency_color_by_type_name(all=False)
            )
        else:
            button.pressed.connect(lambda: self.Color_button_clicked(color))
        return button

    def set_latency_color_by_type_name(self, all: bool):
        """Set latency color based on operation type names
        all: bool
            Indicates if the color of all type names to be modified.
        """
        if Latency_Color.changed:
            current_color = Latency_Color.current_color
        else:
            current_color = Latency_Color.DEFAULT

        # Prompt user to select operation type if not setting color for all types
        if not all:
            used_types = self._schedule.get_used_type_names()
            type, ok = QInputDialog.getItem(
                self, "Select Operation Type", "Type", used_types, editable=False
            )
        else:
            type = "all operations"
            ok = False

        # Open a color dialog to get the selected color
        if all or ok:
            color = QColorDialog.getColor(
                current_color, self, f"Select the color of {type}"
            )

            # If a valid color is selected, update color settings and graph
            if color.isValid():
                if all:
                    Latency_Color.changed = True
                    self._color_changed_perType = False
                    self.changed_operation_colors.clear()
                    Latency_Color.current_color = color
                # Save color settings for each operation type
                else:
                    self._color_changed_perType = True
                    self.changed_operation_colors[type] = color
                self.color_pref_update()
                self.update_statusbar("Preferences Updated")

    def color_pref_update(self):
        """Update preferences of Latency color per type"""
        for type in self._schedule.get_used_type_names():
            if Latency_Color.changed and not self._color_changed_perType:
                self._color_per_type[type] = Latency_Color.current_color
            elif not Latency_Color.changed and not self._color_changed_perType:
                self._color_per_type[type] = Latency_Color.DEFAULT
            elif not Latency_Color.changed and self._color_changed_perType:
                if type in self.changed_operation_colors.keys():
                    self._color_per_type[type] = self.changed_operation_colors[type]
                else:
                    self._color_per_type[type] = Latency_Color.DEFAULT
            else:
                if type in self.changed_operation_colors.keys():
                    self._color_per_type[type] = self.changed_operation_colors[type]
                else:
                    self._color_per_type[type] = Latency_Color.current_color
        self.Save_colortype()

    def Save_colortype(self):
        """Save preferences of Latency color per type in settings"""
        settings = QSettings()
        for key, color in self._color_per_type.items():
            self._graph._color_change(color, key)
            self.converted_colorPerType[key] = color.name()
        settings.setValue(
            f"scheduler/preferences/{Latency_Color.name}",
            Latency_Color.current_color,
        )
        settings.setValue(
            f"scheduler/preferences/{Latency_Color.name}_changed", Latency_Color.changed
        )
        settings.setValue(
            f"scheduler/preferences/{Latency_Color.name}/perType",
            self.converted_colorPerType,
        )
        settings.setValue(
            f"scheduler/preferences/{Latency_Color.name}/perType_changed",
            self._color_changed_perType,
        )

    def Color_button_clicked(self, color_type: ColorDataType):
        """Open a color dialog to select a color based on the specified color type
        color_type: ColorDataType
            The color_type to be changed.
        """
        settings = QSettings()
        if color_type.changed:
            current_color = color_type.current_color
        else:
            current_color = color_type.DEFAULT

        color = QColorDialog.getColor(current_color, self, f"Select {color_type.name}")
        # If a valid color is selected, update the current color and settings
        if color.isValid():
            color_type.current_color = color
            # colorbutton.set_color(color)
            color_type.changed = (
                False if color_type.current_color == color_type.DEFAULT else True
            )
            settings.setValue(f"scheduler/preferences/{color_type.name}", color.name())
            settings.sync()

        self._graph._signals.reopen.emit()
        self.update_statusbar("Preferences Updated")

    def font_clicked(
        self, Sizeline: QLineEdit, italicbutton: ColorButton, boldbutton: ColorButton
    ):
        """Open a font dialog to select a font and update the current font
        Sizeline: QLineEdit
            The line displaying the text size to be matched with the chosen font.
        italicbutton: ColorButton
            The button displaying the italic state to be matched with the chosen font.
        boldbutton: ColorButton
            The button displaying the bold state to be matched with the chosen font.
        """
        if Font.changed:
            current_font = Font.current_font
        else:
            current_font = Font.DEFAULT

        (ok, font) = QFontDialog.getFont(current_font, self)
        if ok:
            Font.current_font = font
            Font.size = int(font.pointSizeF())
            Font.bold = font.bold()
            Font.italic = font.italic()
            self.Update_font()
            self.Match_Dialog_Font(Sizeline, italicbutton, boldbutton)
            self.update_statusbar("Preferences Updated")

    def Update_font(self):
        """Update font preferences based on current Font settings"""
        settings = QSettings()
        Font.changed = (
            False
            if (
                Font.current_font == Font.DEFAULT
                and Font.size == int(Font.DEFAULT.pointSizeF())
                and Font.italic == Font.DEFAULT.italic()
                and Font.bold == Font.DEFAULT.bold()
            )
            else True
        )
        settings.setValue("scheduler/preferences/font", Font.current_font.toString())
        settings.setValue("scheduler/preferences/fontSize", Font.size)
        settings.setValue("scheduler/preferences/fontBold", Font.bold)
        settings.setValue("scheduler/preferences/fontItalic", Font.italic)
        settings.sync()
        self.load_preferences()

    def load_preferences(self):
        "Load the last saved preferences from settings"
        settings = QSettings()
        Latency_Color.current_color = QColor(
            settings.value(
                f"scheduler/preferences/{Latency_Color.name}",
                defaultValue=Latency_Color.DEFAULT,
                type=str,
            )
        )
        Latency_Color.changed = settings.value(
            f"scheduler/preferences/{Latency_Color.name}_changed", False, bool
        )
        self.converted_colorPerType = settings.value(
            f"scheduler/preferences/{Latency_Color.name}/perType",
            self.converted_colorPerType,
        )
        self._color_changed_perType = settings.value(
            f"scheduler/preferences/{Latency_Color.name}/perType_changed", False, bool
        )
        settings.sync()

        for key, color_str in self.converted_colorPerType.items():
            color = QColor(color_str)
            self._color_per_type[key] = color
            Match = (
                (color == Latency_Color.current_color)
                if Latency_Color.changed
                else (color == Latency_Color.DEFAULT)
            )
            if self._color_changed_perType and not Match:
                self.changed_operation_colors[key] = color
        self.color_pref_update()

        if Font.changed:
            Font.current_font.setPointSizeF(Font.size)
            Font.current_font.setItalic(Font.italic)
            Font.current_font.setBold(Font.bold)
            self._graph._font_change(Font.current_font)
            self._graph._font_color_change(Font.color)
        else:
            self._graph._font_change(Font.DEFAULT)
            self._graph._font_color_change(Font.DEFAULT_COLOR)

        self.update_statusbar("Saved Preferences Loaded")

    def font_color_clicked(self):
        """Select a font color and update preferences"""
        settings = QSettings()
        color = QColorDialog.getColor(Font.color, self, "Select Font Color")
        if color.isValid():
            Font.color = color
            Font.changed = True
        settings.setValue("scheduler/preferences/fontColor", Font.color.name())
        settings.sync()
        self._graph._font_color_change(Font.color)

    def set_fontSize_clicked(self, size):
        """Set the font size to the specified size and update the font
        size
            The font size to be set.
        """
        Font.size = int(size) if (not size == "") else 6
        Font.current_font.setPointSizeF(Font.size)
        self.Update_font()

    def Italic_font_clicked(self, button: ColorButton):
        """Toggle the font style to italic if not already italic, otherwise remove italic
        button: ColorButton
            The clicked button. Used to indicate state on/off.
        """
        Font.italic = not Font.italic
        Font.current_font.setItalic(Font.italic)
        (
            button.set_color(QColor('silver'))
            if Font.italic
            else button.set_color(QColor('snow'))
        )
        self.Update_font()

    def Bold_font_clicked(self, button: ColorButton):
        """Toggle the font style to bold if not already bold, otherwise unbold
        button: ColorButton
            The clicked button. Used to indicate state on/off.
        """
        Font.bold = not Font.bold
        Font.current_font.setBold(Font.bold)
        Font.current_font.setWeight(50)
        (
            button.set_color(QColor('silver'))
            if Font.bold
            else button.set_color(QColor('snow'))
        )
        self.Update_font()

    def Incr_font_clicked(self, line: QLineEdit):
        """
        Increase the font size by 1.
        line: QLineEdit
            The line displaying the text size to be matched.
        """
        (
            line.setText(str(Font.size + 1))
            if Font.size <= 71
            else line.setText(str(Font.size))
        )

    def Decr_font_clicked(self, line: QLineEdit):
        """
        Decrease the font size by 1.
        line: QLineEdit
            The line displaying the text size to be matched.
        """
        (
            line.setText(str(Font.size - 1))
            if Font.size >= 7
            else line.setText(str(Font.size))
        )

    def reset_color_clicked(self):
        """Reset the color settings"""
        settings = QSettings()
        Latency_Color.changed = False
        Active_Color.changed = False
        Signal_Warning_Color.changed = False
        Signal_Color.changed = False
        Execution_Time_Color.changed = False
        self._color_changed_perType = False
        self.color_pref_update()

        settings.beginGroup("scheduler/preferences")
        settings.setValue(Latency_Color.name, Latency_Color.DEFAULT.name())
        settings.setValue(Signal_Color.name, Signal_Color.DEFAULT.name())
        settings.setValue(Active_Color.name, Active_Color.DEFAULT.name())
        settings.setValue(
            Signal_Warning_Color.name, Signal_Warning_Color.DEFAULT.name()
        )
        settings.setValue(
            Execution_Time_Color.name, Execution_Time_Color.DEFAULT.name()
        )
        settings.endGroup()

        self._graph._color_change(Latency_Color.DEFAULT, "all operations")
        self._graph._signals.reopen.emit()
        self.load_preferences()

    def reset_font_clicked(
        self, Sizeline: QLineEdit, italicbutton: ColorButton, boldbutton: ColorButton
    ):
        """Reset the font settings.
        Sizeline: QLineEdit
            The line displaying the text size to be matched with the chosen font.
        italicbutton: ColorButton
            The button displaying the italic state to be matched with the chosen font.
        boldbutton: ColorButton
            The button displaying the bold state to be matched with the chosen font.
        """
        Font.current_font = QFont("Times", 12)
        Font.changed = False
        Font.color = Font.DEFAULT_COLOR
        Font.size = int(Font.DEFAULT.pointSizeF())
        Font.bold = Font.DEFAULT.bold()
        Font.italic = Font.DEFAULT.italic()
        self.Update_font()
        self.load_preferences()
        self.Match_Dialog_Font(Sizeline, italicbutton, boldbutton)

    def reset_all_clicked(
        self, Sizeline: QLineEdit, italicbutton: ColorButton, boldbutton: ColorButton
    ):
        """Reset both the color and the font settings"""
        self.reset_color_clicked()
        self.reset_font_clicked(Sizeline, italicbutton, boldbutton)

    def Match_Dialog_Font(
        self, Sizeline: QLineEdit, italicbutton: ColorButton, boldbutton: ColorButton
    ):
        """Update the widgets on the pref dialog to match the current font
        Sizeline: QLineEdit
            The line displaying the text size to be matched with the current font.
        italicbutton: ColorButton
            The button displaying the italic state to be matched with the current font.
        boldbutton: ColorButton
            The button displaying the bold state to be matched with the current font.
        """
        Sizeline.setText(str(Font.size))

        (
            italicbutton.set_color(QColor('silver'))
            if Font.italic
            else italicbutton.set_color(QColor('snow'))
        )
        (
            boldbutton.set_color(QColor('silver'))
            if Font.bold
            else boldbutton.set_color(QColor('snow'))
        )

    @Slot(str)
    def _show_execution_times_for_type(self, type_name):
        self._execution_time_plot(type_name)

    def _closed_execution_times_for_type(self, type_name):
        self._execution_time_plot_dialogs[type_name] = None

    def _execution_time_plot(self, type_name: str) -> None:
        self._execution_time_plot_dialogs[type_name] = MPLWindow(
            f"Execution times for {type_name}"
        )
        self._execution_time_plot_dialogs[type_name].finished.connect(
            lambda b=0, x=type_name: self._closed_execution_times_for_type(x)
        )
        self._update_execution_times_for_type(type_name)
        self._execution_time_plot_dialogs[type_name].show()

    def _update_execution_times_for_type(self, type_name):
        if self._execution_time_plot_dialogs[type_name]:
            self._execution_time_plot_dialogs[type_name].axes.clear()
            self._schedule.get_operations().get_by_type_name(type_name).plot(
                self._execution_time_plot_dialogs[type_name].axes
            )
            self._execution_time_plot_dialogs[type_name].redraw()

    def _show_execution_times_for_variables(self):
        self._execution_time_for_variables = MPLWindow("Execution times for variables")
        self._execution_time_for_variables.finished.connect(
            self._execution_times_for_variables_closed
        )
        self._update_execution_times_for_variables()
        self._execution_time_for_variables.show()

    def _update_execution_times_for_variables(self):
        if self._execution_time_for_variables:
            self._execution_time_for_variables.axes.clear()
            self._schedule.get_memory_variables().plot(
                self._execution_time_for_variables.axes, allow_excessive_lifetimes=True
            )
            self._execution_time_for_variables.redraw()

    @Slot()
    def _execution_times_for_variables_closed(self):
        self._execution_time_for_variables = None

    def _show_ports_accesses_for_storage(self):
        self._ports_accesses_for_storage = MPLWindow(
            "Port accesses for storage", subplots=(3, 1)
        )
        self._ports_accesses_for_storage.finished.connect(
            self._ports_accesses_for_storage_closed
        )
        self._update_ports_accesses_for_storage()
        self._ports_accesses_for_storage.show()

    def _update_ports_accesses_for_storage(self) -> None:
        if self._ports_accesses_for_storage:
            for ax in self._ports_accesses_for_storage.axes:
                ax.clear()
            mem_vars = self._schedule.get_memory_variables()
            _, mem_vars = mem_vars.split_on_length()
            mem_vars.plot_port_accesses(self._ports_accesses_for_storage.axes)
            self._ports_accesses_for_storage.redraw()

    @Slot()
    def _ports_accesses_for_storage_closed(self) -> None:
        self._ports_accesses_for_storage = None

    @Slot()
    @Slot(str)
    def _schedule_changed(self, type_name: Optional[str] = None):
        self._update_execution_times_for_variables()
        self._update_ports_accesses_for_storage()
        for key, dialog in self._execution_time_plot_dialogs.items():
            if dialog:
                self._update_execution_times_for_type(key)

    def _update_recent_file_list(self):
        settings = QSettings()

        rfp = cast(deque, settings.value("scheduler/recentFiles"))

        # print(rfp)
        if rfp:
            dequelen = len(rfp)
            if dequelen > 0:
                for i in range(dequelen):
                    action = self._recent_files_actions[i]
                    action.setText(rfp[i])
                    action.setData(QFileInfo(rfp[i]))
                    action.setVisible(True)

                for i in range(dequelen, self._max_recent_files):
                    self._recent_files_actions[i].setVisible(False)

    def _open_recent_file(self, action):
        if action.data().filePath().endswith('.bsc'):
            self._open_schedule_file(action.data().filePath())
        else:
            self._load_from_file(action.data().filePath())

    def _add_recent_file(self, filename):
        settings = QSettings()

        rfp = cast(deque, settings.value("scheduler/recentFiles"))

        if rfp:
            if filename not in rfp:
                rfp.append(filename)
        else:
            rfp = deque(maxlen=self._max_recent_files)
            rfp.append(filename)

        settings.setValue("scheduler/recentFiles", rfp)

        self._update_recent_file_list()

    def _zoom_to_fit(self, event=None):
        """Callback for zoom to fit schedule in window."""
        self.view.fitInView(self._scene.sceneRect(), Qt.AspectRatioMode.KeepAspectRatio)

    def _toggle_statusbar(self, event=None) -> None:
        """Callback for toggling the status bar."""
        self.statusbar.setVisible(self.actionStatus_bar.isChecked())

    def _toggle_execution_time_warning(self, event=None) -> None:
        """Callback for toggling the status bar."""
        self._show_incorrect_execution_time = (
            self.action_incorrect_execution_time.isChecked()
        )
        self._graph.set_warnings(self._show_incorrect_execution_time)

    def _toggle_port_number(self, event=None) -> None:
        """Callback for toggling the status bar."""
        self._show_port_numbers = self.action_show_port_numbers.isChecked()
        self._graph.set_port_numbers(self._show_port_numbers)

    def _toggle_fullscreen(self, event=None):
        """Callback for toggling full screen mode."""
        if self.isFullScreen():
            self.showNormal()
            self.actionToggle_full_screen.setIcon(get_icon('full-screen'))
        else:
            self.showFullScreen()
            self.actionToggle_full_screen.setIcon(get_icon('full-screen-exit'))


@overload
def start_scheduler(schedule: Schedule) -> Schedule: ...


@overload
def start_scheduler(schedule: None) -> Optional[Schedule]: ...


@overload
def start_scheduler() -> Optional[Schedule]: ...


def start_scheduler(schedule: Optional[Schedule] = None) -> Optional[Schedule]:
    """
    Start scheduler GUI.

    Parameters
    ----------
    schedule : Schedule, optional
        The schedule to start the editor with.

    Returns
    -------
    Schedule
        The edited schedule.
    """
    if not QApplication.instance():
        app = QApplication(sys.argv)
    else:
        app = QApplication.instance()

    # Enforce a light palette regardless of laptop theme
    palette = QPalette()
    palette.setColor(QPalette.ColorRole.Window, QtCore.Qt.white)
    palette.setColor(QPalette.ColorRole.WindowText, QtCore.Qt.black)
    palette.setColor(QPalette.ColorRole.ButtonText, QtCore.Qt.black)
    palette.setColor(QPalette.ColorRole.Base, QtCore.Qt.white)
    palette.setColor(QPalette.ColorRole.AlternateBase, QtCore.Qt.lightGray)
    palette.setColor(QPalette.ColorRole.Text, QtCore.Qt.black)
    app.setPalette(palette)

    window = ScheduleMainWindow()
    if schedule:
        window.open(schedule)
    window.show()
    app.exec_()
    return window.schedule


if __name__ == "__main__":
    start_scheduler()