gui_toolkit.py

Go to the documentation of this file.

"""!
********************************************************************************
@file   gui_toolkit.py
@brief  individual GUI toolkit function and selection
********************************************************************************
"""
 
# autopep8: off
import sys
import os
from typing import Any, Optional, TYPE_CHECKING
 
 
import markdown  # pylint: disable=wrong-import-position
import qdarktheme  # pylint: disable=wrong-import-position
import pygame  # pylint: disable=wrong-import-position
 
from PyQt6.QtGui import QIcon, QPixmap, QFont, QAction, QActionGroup, QStatusTipEvent, QColor, QResizeEvent, QCloseEvent  # pylint: disable=wrong-import-position
from PyQt6.QtWidgets import QMainWindow, QMessageBox, QAbstractItemView, QTableWidgetItem, QPushButton, QLabel, QTextBrowser, QStatusBar, QTabWidget, \
                            QHeaderView, QInputDialog, QLineEdit, QApplication, QDialog, QFileDialog, QMenuBar, QTableWidget, QCheckBox, QWidget, QMenu  # pylint: disable=wrong-import-position
from PyQt6.QtCore import QSharedMemory, Qt, QThread, QSettings, QObject, pyqtSignal, pyqtBoundSignal, QSize, QRect, QEvent, QTimer, QByteArray  # pylint: disable=wrong-import-position
 
from Source.Views.mainwindow_ui import Ui_MainWindow  # pylint: disable=wrong-import-position
from Source.Views.dialogs.dialog_splash_ui import Ui_SplashScreen  # pylint: disable=wrong-import-position
from Source.Views.dialogs.dialog_about_ui import Ui_AboutDialog  # pylint: disable=wrong-import-position
from Source.Views.dialogs.dialog_help_ui import Ui_HelpDialog  # pylint: disable=wrong-import-position
from Source.Views.dialogs.dialog_report_ui import Ui_ReportDialog  # pylint: disable=wrong-import-position
from Source.Views.dialogs.dialog_article_size_ui import Ui_ArticleSizeDialog  # pylint: disable=wrong-import-position
if TYPE_CHECKING:
    from Source.Controller.main_window import MainWindow
# autopep8: on
 
 
APPLICATION = QApplication
SHARED_MEMORY = QSharedMemory
WINDOW_TYPE = QMainWindow
THREAD = QThread
SIGNAL = pyqtSignal
SIGNAL_BOUND = pyqtBoundSignal
SETTINGS = QSettings
OBJECT = QObject
LABEL = QLabel
WIDGET = QWidget
ACTION = QAction
RESIZE_EVENT = QResizeEvent
CLOSE_EVENT = QCloseEvent
DIALOG = QDialog
FONT = QFont
BYTE_ARRAY = QByteArray
BUTTON = QPushButton
MAIN_WINDOW = Ui_MainWindow
SPLASH_SCREEN = Ui_SplashScreen
HELP_DIALOG = Ui_HelpDialog
ABOUT_DIALOG = Ui_AboutDialog
REPORT_DIALOG = Ui_ReportDialog
ARTICLE_SIZE_DIALOG = Ui_ArticleSizeDialog
 
I_MENU_FONT_SIZE = 14
I_MENU_BAR_HEIGHT = 30
 
 

 
def check_app_already_open(shared_memory: QSharedMemory) -> bool:
    """!
    @brief Check if application is already open
    @param shared_memory : shared memory
    @return status if application is already open
    """
    b_already_open = not shared_memory.create(1)
    return b_already_open
 
 
def run_app(window: "APPLICATION | DIALOG | MainWindow", app: Optional[APPLICATION | DIALOG], close_event: bool = False) -> None:
    """!
    @brief Run application
    @param window : window
    @param app : app
    @param close_event: close complete application
    """
    if window is not None:
        if not isinstance(window, APPLICATION):
            window.show()
    if app is not None:
        if close_event:
            sys.exit(app.exec())
        else:
            app.exec()
 
 
def close_app(window: "DIALOG | MainWindow") -> None:
    """!
    @brief Close application
    @param window : window to close
    """
    window.close()
 
 
def connect_signal(signal: SIGNAL_BOUND, function: Any) -> None:
    """!
    @brief Connect signal.
    @param signal : signal variable
    @param function : function to connect
    """
    signal.connect(function)
 
 
def disconnect_signal(signal: SIGNAL_BOUND) -> None:
    """!
    @brief Disconnect signal.
    @param signal : signal variable
    """
    signal.disconnect()
 
 
def emit_signal(signal: SIGNAL_BOUND) -> None:
    """!
    @brief Emit signal.
    @param signal : signal to call
    """
    signal.emit()
 
 

 
def config_window(window: "DIALOG | MainWindow", title: Optional[str] = None, frameless: bool = False, icon: Optional[str] = None, fullscreen: Optional[bool] = None,
                  min_width: Optional[int] = None, min_height: Optional[int] = None, geometry: Optional[QByteArray] = None, state: Optional[QByteArray] = None,
                  fix_size: bool = False, resize: Optional[tuple[int, int]] = None, move: Optional[tuple[int, int]] = None, style: Optional[str] = None,
                  resize_callback: Any = None, show: Optional[bool] = None, thread: Optional[bool] = False) -> None:
    """!
    @brief Configure Window
    @param window : window
    @param title : windows title
    @param icon : window icon
    @param fullscreen : fullscreen status
    @param min_width : minimum window width
    @param min_height : minimum window height
    @param geometry : window geometry
    @param state : window state
    @param fix_size : state if window is resizable
    @param resize : resize size
    @param move : move window
    @param style : window style
    @param resize_callback : resize callback function
    @param frameless : no window flags and frameless
    @param show : show/close window
    @param thread : run window in Thread
    """
    if title is not None:
        window.setWindowTitle(title)
    if frameless:
        window.setWindowFlag(Qt.WindowType.FramelessWindowHint)
    else:
        if icon is not None:
            window.setWindowIcon(QIcon(icon))
    if fullscreen is not None:
        if fullscreen:
            if not window.isFullScreen():
                window.showFullScreen()
        else:
            if window.isFullScreen():
                window.showNormal()
    if min_width is not None:
        window.setMinimumWidth(min_width)
    if min_height is not None:
        window.setMinimumHeight(min_height)
    if geometry is not None:
        window.restoreGeometry(geometry)
    if state is not None:
        if not isinstance(window, DIALOG):
            window.restoreState(state)
    if fix_size:
        window.setFixedSize(window.size())
    if resize is not None:
        width, height = resize
        window.resize(width, height)
    if move is not None:
        x, y = move
        window.move(x, y)
    if style is not None:
        window.setStyleSheet(style)
    if resize_callback is not None:
        if not isinstance(window, DIALOG):
            window.resized.connect(resize_callback)
    if show is not None:
        if show:
            window.show()
        else:
            window.close()
 
 
def config_app(app: APPLICATION, icon: Optional[str] = None, process_events: Optional[bool] = False) -> None:
    """!
    @brief Configure Application
    @param app : application
    @param icon : window icon
    @param process_events : process event status
    """
    if icon is not None:
        app.setWindowIcon(QIcon(icon))
    if process_events:
        app.processEvents()
 
 
def get_window_size(window: "MainWindow | QDialog") -> tuple[int, int]:
    """!
    @brief Get window size
    @param window : window
    @return windows width and height
    """
    width = window.frameGeometry().width()
    height = window.frameGeometry().height()
    return width, height
 
 
def get_window_position(window: "MainWindow | QDialog") -> tuple[int, int]:
    """!
    @brief Get window position
    @param window : window
    @return windows x and y position
    """
    x = window.x()
    y = window.y()
    return x, y
 
 
def get_window_geometry(window: WINDOW_TYPE) -> BYTE_ARRAY:
    """!
    @brief Get window geometry for safe
    @param window : window
    @return window geometry
    """
    window_geometry = window.saveGeometry()
    return window_geometry
 
 
def get_window_state(window: WINDOW_TYPE) -> BYTE_ARRAY:
    """!
    @brief Get window state for safe
    @param window : window
    @return window geometry
    """
    window_geometry = window.saveState()
    return window_geometry
 
 
def get_fullscreen_status(window: WINDOW_TYPE) -> bool:
    """!
    @brief Get fullscreen status
    @param window : window
    @return fullscreen status
    """
    fullscreen = bool(window.isFullScreen())
    return fullscreen
 
 
def get_style(dark_mode: bool = False) -> str:
    """!
    @brief Get Style
    @param dark_mode : style status for dark mode
    @return style
    """
    style: str
    if dark_mode:
        style = qdarktheme.load_stylesheet("dark", corner_shape="rounded")
    else:
        style = qdarktheme.load_stylesheet("light", corner_shape="rounded")
    return style
 
 

 
def filter_menubar(menubar: QMenuBar, gui: WINDOW_TYPE) -> None:
    """!
    @brief Menubar filter
    @param menubar : menubar
    @param gui : gui
    @return event filter TODO kein richtiger return
    """
    class StatusTipFilter(QObject):
        """!
        @brief Event Filter.
        """
 
        def eventFilter(self, watched: Optional[QObject], event: Optional[QEvent]) -> bool:  # pylint: disable=invalid-name
            """!
            @brief Filter to prevent tip event (statusbar message no longer disappears on menu hover).
            @param watched : object
            @param event : arrived event
            @return return event filter
            """
            if isinstance(event, QStatusTipEvent):
                b_return = True
            else:
                b_return = super().eventFilter(watched, event)
            return b_return
 
    menubar.installEventFilter(StatusTipFilter(gui))
 
 
def connect_menu(menu: QMenu | QAction, function: Any, index: Any = "") -> None:
    """!
    @brief Connect menu.
    @param menu : connect function to this menu
    @param function : function to connect
    @param index : index to connect function with parameter
    """
    if index == "":
        menu.triggered.connect(function)
    else:
        menu.triggered.connect(lambda: function(index))
 
 
def get_menu_text(menu: QAction) -> str:
    """!
    @brief Get text from menu
    @param menu : menu to get text
    @return text from menu
    """
    menu_text = menu.text()
    return menu_text
 
 
def config_menu(menu: QMenu | QAction, enable: Optional[bool] = None, show: Optional[bool] = None,
                text: Optional[str] = None, checked: Optional[bool] = None, icon: Optional[str] = None) -> None:
    """!
    @brief Configure menu.
    @param menu : menu to configure
    @param enable : enable status
    @param show : show status
    @param text : menu text
    @param checked : checked status
    @param icon : path for menu icon
    """
    if enable is not None:
        menu.setEnabled(enable)
    if show is not None:
        if isinstance(menu, QMenu):
            menu_action = menu.menuAction()
            if menu_action is not None:
                menu_action.setVisible(show)
        else:
            menu.setVisible(show)
    if text is not None:
        if isinstance(menu, QMenu):
            menu.setTitle(text)
        else:
            menu.setText(text)
        font = QFont()
        font.setPointSize(I_MENU_FONT_SIZE)
        menu.setFont(font)
    if checked is not None:
        if isinstance(menu, QAction):
            menu.setChecked(checked)
    if icon is not None:
        menu.setIcon(QIcon(icon))
 
 
def group_menu(parent: "MainWindow", l_actions: list[QAction], actual_value: Any, l_match_values: list[Any]) -> QActionGroup:
    """!
    @brief Set action group.
    @param parent : parent window controller
    @param l_actions: list with actions to add
    @param actual_value : actual setting value
    @param l_match_values : list with possible match values to check default setting
    @return action group object
    """
    action_group = QActionGroup(parent)
    for action in l_actions:
        action_group.addAction(action)
    for i, match_value in enumerate(l_match_values):
        if match_value == actual_value:
            l_actions[i].setChecked(True)
            break
    return action_group
 
 
def group_available_menu(parent: "MainWindow", l_actions: list[QAction], actual_value: Any,
                         l_match_values: list[Any], none_action: QAction) -> tuple[QActionGroup, bool]:
    """!
    @brief Set action group.
    @param parent : parent window controller
    @param l_actions: list with actions to add
    @param actual_value : actual setting value
    @param l_match_values : list with possible match values to check default setting
    @param none_action : none action is set if actual_value is None
    @return action group object
    """
    action_group = QActionGroup(parent)
    action_group.addAction(none_action)
    all_actions_add = True
    config_menu(none_action, text="None")
    if actual_value is None:
        none_action.setChecked(True)
        b_action_present = True
    else:
        none_action.setChecked(False)
        b_action_present = False
    i_action_index = 0
    for value in l_match_values:
        if i_action_index < len(l_actions):
            config_menu(l_actions[i_action_index], enable=True, show=True, text=value)
            action_group.addAction(l_actions[i_action_index])
            if actual_value == value:
                b_action_present = True
                config_menu(l_actions[i_action_index])
                l_actions[i_action_index].setChecked(True)
            else:
                l_actions[i_action_index].setChecked(False)
            i_action_index += 1
        else:
            all_actions_add = False
            break
    for i_index in range(i_action_index, len(l_actions)):
        if (i_index == i_action_index) and (not b_action_present):
            config_menu(l_actions[i_index], enable=False, show=True, text=actual_value)
            l_actions[i_index].setChecked(True)
        else:
            config_menu(l_actions[i_index], enable=False, show=False)
        action_group.addAction(l_actions[i_index])
    return action_group, all_actions_add
 
 

 
def connect_button(btn: QPushButton, clicked_fnc: Any = None, pressed_fnc: Any = None,
                   released_fnc: Any = None, index: Any = "") -> None:
    """!
    @brief Connect widget.
    @param btn : connect function to this button
    @param clicked_fnc : function to connect button clicked
    @param pressed_fnc : function to connect button pressed
    @param released_fnc : function to connect button released
    @param index : index to connect function with parameter
    """
    if clicked_fnc is not None:
        if index == "":
            btn.clicked.connect(clicked_fnc)
        else:
            btn.clicked.connect(lambda: clicked_fnc(index))
    if pressed_fnc is not None:
        if index == "":
            btn.pressed.connect(pressed_fnc)
        else:
            btn.pressed.connect(lambda: pressed_fnc(index))
    if released_fnc is not None:
        if index == "":
            btn.released.connect(released_fnc)
        else:
            btn.released.connect(lambda: released_fnc(index))
 
 
def config_btn(btn: QPushButton, enable: Optional[bool] = None, show: Optional[bool] = None, text: Optional[str] = None,
               fg: Optional[str] = None, bg: Optional[str] = None, style: Optional[str] = None, icon: Optional[str] = None,
               size: Optional[tuple[int, int, int, int]] = None, font: Optional[QFont] = None, icon_size: Optional[int] = None) -> None:
    """!
    @brief Configure button.
    @param btn : button to configure
    @param enable : enable status
    @param show : show status
    @param text : button text
    @param fg : foreground color
    @param bg : background color
    @param style : button style
    @param icon : icon in button
    @param size : button size and position
    @param font : button text font
    @param icon_size : icon size
    """
    if enable is not None:
        btn.setEnabled(enable)
    if show is not None:
        if show:
            btn.show()
        else:
            btn.hide()
    if text is not None:
        btn.setText(text)
    if style is None:
        if fg is not None:
            btn.setStyleSheet(f"color: {fg};")
        if bg is not None:
            btn.setStyleSheet(f"background-color: {bg};")
    else:
        btn.setStyleSheet(style)
    if icon is not None:
        if icon:
            image = QIcon()
            image.addPixmap(QPixmap(icon), QIcon.Mode.Normal, QIcon.State.Off)
            btn.setIcon(image)
        else:
            btn.setIcon(QIcon())  # delete icon from button
    if icon_size is not None:
        btn.setIconSize(QSize(icon_size, icon_size))
    if size is not None:
        x, y, width, height = size
        btn.setGeometry(QRect(x, y, width, height))
    if font is not None:
        btn.setFont(font)
 
 
def get_btn_text(btn: QPushButton) -> str:
    """!
    @brief Get button text
    @param btn : button to get text
    @return button text
    """
    btn_text = btn.text()
    return btn_text
 
 

 
def config_label(label: QLabel, text: Optional[str] = None, fg: Optional[str] = None, bg: Optional[str] = None,
                 size: Optional[tuple[int, int, int, int]] = None, font: Optional[QFont] = None, central: bool = False,
                 open_link: Optional[str] = None, show: Optional[bool] = None) -> None:
    """!
    @brief Configure label.
    @param label : label widget to set
    @param text : text to set
    @param fg : foreground color
    @param bg : background color
    @param size : text size and position
    @param font : text font
    @param central : central alignment
    @param open_link : open link
    @param show : show text
    """
    if text is not None:
        if open_link is not None:
            text += f"<a href=\"{open_link}\">{open_link}</a>"
        label.setText(text)
    if bg is not None:  # call before set foreground to prevent override.
        label.setStyleSheet(f"background-color: {bg};")
    if fg is not None:
        label.setStyleSheet(f"color: {fg};")
    if size is not None:
        x, y, width, height = size
        label.setGeometry(QRect(x, y, width, height))
    if font is not None:
        label.setFont(font)
    if central:
        label.setAlignment(Qt.AlignmentFlag.AlignCenter)
    if open_link is not None:
        label.setOpenExternalLinks(bool(open_link))
    if show is not None:
        if show:
            label.show()
        else:
            label.hide()
 
 

 
def config_text(label: QTextBrowser, text: Optional[str] = None, fg: Optional[str] = None, bg: Optional[str] = None,
                size: Optional[tuple[int, int, int, int]] = None, font: Optional[QFont] = None) -> None:
    """!
    @brief Configure text.
    @param label : label widget to set
    @param text : text to set
    @param fg : foreground color
    @param bg : background color
    @param size : text size and position
    @param font : text font
    """
    if text is not None:
        label.setText(text)
    if fg is not None:
        label.setStyleSheet(f"color: {fg};")
    if bg is not None:
        label.setStyleSheet(f"background-color: {bg};")
    if size is not None:
        x, y, width, height = size
        label.setGeometry(QRect(x, y, width, height))
    if font is not None:
        label.setFont(font)
 
 
def get_text(label: QTextBrowser) -> str:
    """!
    @brief Configure text.
    @param label : label widget to set
    @return text from label
    """
    text = label.toPlainText()
    return text
 
 

 
def config_statusbar(statusbar: QStatusBar, lbl_left: Optional[QLabel] = None, lbl_right: Optional[QLabel] = None,
                     text: Optional[str] = None, fg: Optional[str] = None, bg: Optional[str] = None) -> None:
    """!
    @brief Configure statusbar.
    @param statusbar : statusbar widget
    @param lbl_left : statusbar label left
    @param lbl_right : statusbar label right
    @param text : statusbar text
    @param fg : front color
    @param bg : background color
    """
    if (lbl_left is None) and (lbl_right is None):
        if text is not None:
            statusbar.showMessage(text)
        if bg is not None:
            statusbar.setStyleSheet(f"background-color: {bg};")  # call before set foreground to prevent override.
        if fg is not None:
            statusbar.setStyleSheet(f"color: {fg};")
    else:
        if lbl_left is not None:
            statusbar.addWidget(lbl_left)
        if lbl_right is not None:
            statusbar.addPermanentWidget(lbl_right)
 
 

 
def config_table(table: QTableWidget, clear_selection: bool = False, single_row_selection: Optional[bool] = None,
                 row_description: Optional[list[str]] = None, font: Optional[QFont] = None,
                 size: Optional[tuple[int, int, int, int]] = None, min_section_size: Optional[int] = None,
                 row_count: Optional[int] = None, auto_size: bool = False) -> None:
    """!
    @brief Configure table
    @param table : table to configure
    @param clear_selection : clear selected table item
    @param single_row_selection : only one line can select
    @param row_description : row description text
    @param font : row description font
    @param size :row description  size
    @param min_section_size : default vertical size
    @param row_count : number of rows to set
    @param auto_size : do auto size of horizontal entries
    """
    if single_row_selection is not None:
        if single_row_selection:
            table.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection)  # only one line can select
        else:
            table.setSelectionMode(QAbstractItemView.SelectionMode.NoSelection)  # no table selection possible
    if clear_selection:
        table.clearSelection()  # clear selected table entry to delete single items
    if row_description is not None:
        table.setColumnCount(len(row_description))
        for i, value in enumerate(row_description):
            item = QTableWidgetItem()
            table.setHorizontalHeaderItem(i, item)
            horizontal_header_item = table.horizontalHeaderItem(i)
            if horizontal_header_item is not None:
                horizontal_header_item.setText(value)
                if font is not None:
                    horizontal_header_item.setFont(font)
    if size is not None:
        x, y, width, height = size
        table.setGeometry(QRect(x, y, width, height))
    if min_section_size is not None:
        # first call setMinimumSectionSize to set actual correct size
        vertical_header = table.verticalHeader()
        if vertical_header is not None:
            vertical_header.setMinimumSectionSize(min_section_size)  # minimum vertical size
            vertical_header.setDefaultSectionSize(min_section_size)  # default vertical size
    if row_count is not None:
        table.setRowCount(row_count)
    if auto_size:
        # Update font before auto width
        if font is not None:
            for row in range(table.rowCount()):  # set font size of table entries
                for col in range(table.columnCount()):
                    table_item = table.item(row, col)
                    if table_item is not None:
                        table_item.setFont(font)
        table.resizeColumnsToContents()  # auto column width
        header = table.horizontalHeader()
        if header is not None:
            header.setSectionResizeMode(1, QHeaderView.ResizeMode.Stretch)  # fill middle row
        vertical_header = table.verticalHeader()
        if vertical_header is not None:
            vertical_header.setVisible(False)
        table.scrollToBottom()  # scroll to bottom to show deposit anyway
 
 
def insert_table_item(table: QTableWidget, i_entry_index: int, l_item_param: list[str],
                      font: Optional[QFont] = None, fg: Optional[str] = None, bg: Optional[str] = None) -> None:
    """!
    @brief Insert table item
    @param table : insert item to this table
    @param i_entry_index : table index of the new item
    @param l_item_param : item parameter to insert to table
    @param font : font of table item
    @param fg : foreground color
    @param bg : foreground color
    """
    for j, param in enumerate(l_item_param):
        row_cnt = table.rowCount()
        if row_cnt <= i_entry_index:
            table.insertRow(i_entry_index)
        item = QTableWidgetItem(param)
        if fg is not None:
            item.setForeground(QColor(fg))
        if bg is not None:
            item.setBackground(QColor(bg))
        if j == 1:
            item.setTextAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
        else:
            item.setTextAlignment(Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter)
        if font is not None:
            item.setFont(font)
        table.setItem(i_entry_index, j, item)
 
 
def get_selected_table_row(table: QTableWidget) -> int | None:
    """!
    @brief Get selected table row
    @param table : get selected row of this table
    @return selected table row index
    """
    selected_items = table.selectedItems()
    if selected_items:
        selected_row = selected_items[0].row()
    else:
        selected_row = None
    return selected_row
 
 
def get_selected_table_column(table: QTableWidget) -> int | None:
    """!
    @brief Get selected table column
    @param table : get selected column of this table
    @return selected table column index
    """
    selected_items = table.selectedItems()
    if selected_items:
        selected_column = selected_items[0].column()
    else:
        selected_column = None
    return selected_column
 
 

 
def create_dialog(parent: "MainWindow | None", icon: Optional[str] = None, minmax: bool = False, frameless: bool = False) -> DIALOG:
    """!
    @brief Create dialog
    @param parent : parent window controller
    @param icon : table header to set
    @param minmax : min and max window flag
    @param frameless : no window flags and frameless
    @return dialog
    """
    dialog = QDialog(parent)
    dialog.setWindowFlag(Qt.WindowType.WindowContextHelpButtonHint, False)
    dialog.setWindowFlag(Qt.WindowType.WindowMinMaxButtonsHint, minmax)
    if frameless:
        dialog.setWindowFlag(Qt.WindowType.FramelessWindowHint)
    else:
        if icon is not None:
            dialog.setWindowIcon(QIcon(icon))
    return dialog
 
 
def config_tab(tab: QTextBrowser | None, tab_index: Optional[int] = None, text: Optional[str] = None,
               main_tab: Optional[QTabWidget] = None, tab_name: Optional[str] = None) -> None:
    """!
    @brief Select Tab index
    @param tab : tab to config
    @param tab_index : tab index to set
    @param text : text to set
    @param main_tab : main tab
    @param tab_name : tab name
    """
    if main_tab is not None:
        if tab_index is not None:
            main_tab.setCurrentIndex(tab_index)
            if tab_name is not None:
                main_tab.setTabText(tab_index, tab_name)
    if text is not None:
        if tab is not None:
            html = markdown.markdown(text)
            tab.setHtml(html)
 
 
def open_message_box(parent: "MainWindow | None", title: str, text: str, btn_yes: Optional[str] = None, btn_no: Optional[str] = None,
                     btn_ok: Optional[str] = None, btn_close: Optional[str] = None, btn_cancel: Optional[str] = None, btn_special: Optional[str] = None,
                     check_box: Optional[str] = None, window_icon: Optional[str] = None, detailed_text: Optional[str] = None, execute: bool = True) -> tuple[bool, bool]:
    """!
    @brief Open message box
    @param parent : parent window controller
    @param title : box title
    @param text : box text
    @param btn_yes : button yes
    @param btn_no : button no
    @param btn_ok : button okay
    @param btn_close : button close
    @param btn_cancel : button cancel
    @param btn_special : special button (user defined) name
    @param check_box : name for check box
    @param window_icon : box icon
    @param detailed_text : detailed text
    @param execute : execute message box
    @return accept status of message box and check box status
    """
    if execute:
        dialog = QMessageBox(parent)
        dialog.setWindowTitle(title)
        if window_icon is not None:
            dialog.setWindowIcon(QIcon(window_icon))
        dialog.setText(text)
        if detailed_text:
            dialog.setIcon(QMessageBox.Icon.Critical)
        else:
            dialog.setIcon(QMessageBox.Icon.Question if btn_cancel else QMessageBox.Icon.Information)
        if btn_yes is not None:
            dialog.addButton(QMessageBox.StandardButton.Yes)
            if isinstance(btn_yes, str):
                btn = dialog.button(QMessageBox.StandardButton.Yes)
                if btn is not None:
                    btn.setText(btn_yes)
        if btn_no is not None:
            dialog.addButton(QMessageBox.StandardButton.No)
            if isinstance(btn_no, str):
                btn = dialog.button(QMessageBox.StandardButton.No)
                if btn is not None:
                    btn.setText(btn_no)
        if btn_ok is not None:
            dialog.addButton(QMessageBox.StandardButton.Ok)
            if isinstance(btn_ok, str):
                btn = dialog.button(QMessageBox.StandardButton.Ok)
                if btn is not None:
                    btn.setText(btn_ok)
        if btn_close is not None:
            dialog.addButton(QMessageBox.StandardButton.Close)
            if isinstance(btn_close, str):
                btn = dialog.button(QMessageBox.StandardButton.Close)
                if btn is not None:
                    btn.setText(btn_close)
        if btn_cancel is not None:
            dialog.addButton(QMessageBox.StandardButton.Cancel)
            if isinstance(btn_cancel, str):
                btn = dialog.button(QMessageBox.StandardButton.Cancel)
                if btn is not None:
                    btn.setText(btn_cancel)
        if btn_special is not None:
            if isinstance(btn_special, str):
                dialog.addButton(btn_special, QMessageBox.ButtonRole.ResetRole)
        if detailed_text is not None:
            dialog.setDetailedText(detailed_text)
        if check_box is not None:
            box = QCheckBox(check_box)
            dialog.setCheckBox(box)
        else:
            box = None
        dialog.close()
        choice = dialog.exec()
        if box is not None:
            is_checked = box.isChecked()
        else:
            is_checked = False
        b_accept = choice not in [QMessageBox.StandardButton.No, QMessageBox.StandardButton.Close, QMessageBox.StandardButton.Cancel]
    else:
        b_accept = False
        is_checked = False
    return b_accept, is_checked
 
 
def input_dialog(parent: "MainWindow | None", title: str, label: str, default_input: str = "", show_input: bool = True,
                 password_input: bool = False, icon: Optional[str] = None) -> tuple[str, bool]:
    """!
    @brief Open input dialog
    @param parent : parent window controller
    @param title : dialog title
    @param label : dialog label
    @param default_input : default input text
    @param show_input : show input text status
    @param password_input : show input text as password status
    @param icon : dialog icon
    @return input text
    @todo Button Text an Sprachauswahl anpassen
    """
 
    if show_input:
        if password_input:
            echo = QLineEdit.EchoMode.Password
        else:
            echo = QLineEdit.EchoMode.Normal
    else:
        echo = QLineEdit.EchoMode.NoEcho
    input_text, ok = QInputDialog.getText(parent, title, label, echo=echo, text=default_input)
    return input_text, bool(ok)
 
 
def open_directory(parent: "MainWindow", title: str, directory: str | None) -> str:
    """!
    @brief Open directory
    @param parent : parent window controller
    @param title : dialog title
    @param directory : open file dialog in this directory
    @return selected path
    """
    s_path = QFileDialog.getExistingDirectory(parent=parent,
                                              caption=title,
                                              directory=directory)
    return s_path
 
 
def open_file(parent: "MainWindow", title: str, directory: Optional[str] = None,
              filetypes: Optional[tuple[str, str]] = None, multiple: bool = False) -> str | list[str]:
    """!
    @brief Open file
    @param parent : parent window controller
    @param title : dialog title
    @param directory : open file dialog in this directory
    @param filetypes : file types to select
    @param multiple : status if multiple files can selected
    @return selected file
    """
    file_dialog = QFileDialog.getOpenFileNames if multiple else QFileDialog.getOpenFileName
    if filetypes is not None:
        filter_name, filter_type = filetypes
        type_filter = f"{filter_name} ({filter_type})"
    else:
        type_filter = None
    s_file_name_path, _ = file_dialog(parent=parent, caption=title,
                                      directory=directory,
                                      filter=type_filter)
    return s_file_name_path
 
 
def save_file(parent: "MainWindow", title: str, directory: str, filetypes: tuple[str, str]) -> str:
    """!
    @brief Save file
    @param parent : parent window controller
    @param title : dialog title
    @param directory : open file dialog in this directory
    @param filetypes : file type to save
    @return path to save file
    """
    filter_name, filter_type = filetypes
    s_file_name_path, _ = QFileDialog.getSaveFileName(parent=parent, caption=title,
                                                      directory=directory,
                                                      filter=f"{filter_name} ({filter_type})")
    return s_file_name_path
 
 

 
def create_sound(sound_path: str) -> pygame.mixer.Sound:
    """!
    @brief Create sound
    @param sound_path : path to sound file
    @return sound object
    """
    # TODO use QSoundEffect is bug solved
    pygame.mixer.init()  # only initialized by first call
    sound = pygame.mixer.Sound(sound_path)
    return sound
 
 

 
def copy_to_clipboard(text: str) -> None:
    """!
    @brief Copy text to clipboard
    @param text : text to copy
    """
    cb = QApplication.clipboard()
    if cb is not None:
        cb.clear()
        cb.setText(text)
 
 

 
def create_timer(parent: QWidget, callback: Any = None) -> QTimer:
    """!
    @brief Create timer
    @param parent : parent window
    @param callback : timeout callback function
    @return timer
    """
 
    timer = QTimer(parent)
    timer.setSingleShot(True)
    if callback is not None:
        timer.timeout.connect(callback)
    return timer
 
 

 
def config_icon(widget: QLabel, icon: Optional[str] = None, icon_size: Optional[tuple[int, int]] = None) -> None:
    """!
    @brief Configure icon
    @param widget : set icon of this widget
    @param icon : icon to set
    @param icon_size : icon size
    """
    if icon is not None:
        widget.setPixmap(QPixmap(icon))
 
 
def get_stylesheet(widget: Any) -> str:
    """!
    @brief Create Stylesheet
    @param widget : get style of this widget
    @return style
    """
    style: str = widget.styleSheet()
    return style
 
 
def create_font(font_style: Any, font_size: int) -> QFont:
    """!
    @brief Create font
    @param font_style : font style
    @param font_size : font size
    @return font
    """
    font = QFont(font_style, font_size)
    return font