main_window.py

Go to the documentation of this file.

"""!
********************************************************************************
@file   main_window.py
@brief  View controller for the main window
********************************************************************************
"""
 
import sys
import os
import subprocess
import logging
import enum
from typing import Optional, Callable, Any
from datetime import datetime
import json
import base64
import webbrowser
import shutil
 
from Source.version import __title__, __home__
from Source.Util.app_data import EUser, L_CONFIG_USER, ETheme, EPaper, S_PW, I_GROUP_3, ELanguages, \
    read_sound_settings, save_window_state, D_DEFAULT_USER, RESET_CODE, ICON_APP, \
    ICON_HELP_LIGHT, S_UNIT_SYMBOL, ICON_REPORT_LIGHT, ICON_PRINTER_LIGHT, open_explorer, \
    DEFAULT_CODE, ICON_USER_RESET_LIGHT, ICON_ARTICLES_RESET_LIGHT, reset_config_dialog, ICON_HELP_DARK, \
    write_update_version, read_update_version, I_ITEM_ARRAY_SIZE, ItemNumber, get_default_item_config
from Source.Util.app_err_handler import UncaughtHook
from Source.Util.app_log import LogConfig
from Source.Util.gui_toolkit import WINDOW_TYPE, MAIN_WINDOW, SIGNAL, \
    emit_signal, config_window, get_window_geometry, get_window_state, \
    filter_menubar, connect_menu, get_menu_text, config_menu, group_menu, \
    connect_button, config_btn, get_btn_text, config_text, LABEL, config_label, \
    config_statusbar, config_table, insert_table_item, get_selected_table_row, get_selected_table_column, \
    open_message_box, input_dialog, open_directory, open_file, save_file, copy_to_clipboard, create_timer, \
    ACTION, RESIZE_EVENT, CLOSE_EVENT, close_app, BUTTON
 
from Source.Controller.help_dialog import create_help_dialog
from Source.Controller.about_dialog import show_about_dialog
from Source.Controller.report_dialog import show_report_dialog
 
from Source.Model.model import Model
from Source.Model.authentication import EWindowView
from Source.Model.config import write_config_to_file, S_USER_TEMP_FILE, S_USER_FILE, S_ITEM_FILE, S_ITEM_TEMP_FILE
from Source.Model.language import L_SAVE, L_PRINT, L_OPEN, L_CLEAR, L_MENU_HELP, L_CLOSE, L_YES, L_NO, L_CANCEL, \
    L_COPY_URL, L_YOU_SURE, L_MENU_USER
from Source.Model.report import Item, create_item
from Source.Model.update_service import get_tool_update_status, compare_versions, S_UPDATE_URL
from Source.Worker.open_notepad import ENotepadSelection
 
log = logging.getLogger(__title__)
 
B_NOTEPAD_REPORT = False  # True: show report in notepad file; False: show report in GUI
 
if B_NOTEPAD_REPORT:
    S_REPORT_TEMP_FILE = "_temp_Report.md"
 
 
S_NULL = "0"
S_DOUBLE_NULL = "00"
S_DOT = "."
L_SPECIAL_BTNS = [S_NULL, S_DOUBLE_NULL, S_DOT]
I_BTN_LONG_PRESS_TIME = 1000  # time in "ms" to set press button long for colored selection
 
# autopep8: off
L_LOGIN_KEYS = [S_NULL,                                "1",                  "4",                 "7", EUser.B.value + "1",
                EUser.ADMIN.value,                     "2",                  "5",                 "8", EUser.B.value + "2",
                EUser.HOST.value,                      "3",                  "6",                 "9", EUser.B.value + "3",
                EUser.FREE.value,     EUser.B.value + "13", EUser.B.value + "10", EUser.B.value + "7", EUser.B.value + "4",
                EUser.LOCAL.value,    EUser.B.value + "14", EUser.B.value + "11", EUser.B.value + "8", EUser.B.value + "5",
                EUser.USER.value,     EUser.B.value + "15", EUser.B.value + "12", EUser.B.value + "9", EUser.B.value + "6"]
# autopep8: on
 
STATUS_TEXT_TIME = 3000
STATUS_HIGHLIGHT_TEXT_TIME = 5000
STATUS_WARNING_TEXT_TIME = 15000
 
DEFAULT_STYLE = "None"
WARNING_STYLE = "orange"
WARNING_STYLE_DARK = "darkorange"
HIGHLIGHT_STYLE = "red"
LOCKED_STYLE = "grey"
 
 
class EConfigSelection(str, enum.Enum):
    """!
    @brief Mode of configuration change.
    """
    EDIT = "edit"
    IMPORT = "import"
    EXPORT = "export"
    RESET = "reset"
    PDF_IMPORT = "pdf_import"
 
 
INI_FILE_TYPES = ("INI file", "*.ini")
LOG_FILE_TYPES = ("CSV file", "*.csv")
REPORT_FILE_TYPES = ("MD file", "*.md")
I_MAX_ITEMS_TO_PRINT = 50
 
 
def connect_menu_com_port(menu: ACTION, function: Callable[[str], None]) -> None:
    """!
    @brief Connect menu for COM ports.
    @param menu : connect function to this menu
    @param function : function to connect
    """
    menu_text = get_menu_text(menu)
    connect_menu(menu, function, menu_text.split(maxsplit=1)[0])
 
 
class MainWindow(WINDOW_TYPE, MAIN_WINDOW):
    """!
    @brief The view-controller for main window. Entry point of application.
           Provides general methods that may be called by any other controller.
    @param qt_exception_hook : exception hook
    @param log_config : log configuration of the application
    @param test_mode : status if application run in test mode for pytest
    @param authenticated : status if you are authenticated to use this program
    """
    resized = SIGNAL()  # need to defined out of scope
 
    def __init__(self, qt_exception_hook: UncaughtHook, log_config: LogConfig, test_mode: bool = False,
                 authenticated: bool = False, *args: Any, **kwargs: Any) -> None:  # pylint: disable=keyword-arg-before-vararg
        log.debug("Initializing Main Window")
        super().__init__(*args, **kwargs)
        self.test_mode = test_mode
        self.qt_exception_hook = qt_exception_hook
        self.close_window_dialog = True
        self.gui_locked = False
        self.b_warning_active = False
        self.setupUi(self)
        config_window(self, title=__title__)
        self.dialog_help = create_help_dialog(self)
 
        # split statusbar
        self.statusbar_left = LABEL()
        self.statusbar_right = LABEL()
        config_statusbar(statusbar=self.statusbar, lbl_left=self.statusbar_left, lbl_right=self.statusbar_right)
 
        # Init settings
        log.debug("Initializing main configuration")
 
        # TODO Instanzen nach Module auslagern
        self.l_action_com_port = [self.action_port_1,
                                  self.action_port_2,
                                  self.action_port_3,
                                  self.action_port_4,
                                  self.action_port_5,
                                  self.action_port_6,
                                  self.action_port_7,
                                  self.action_port_8,
                                  self.action_port_9,
                                  self.action_port_10]
        self.ag_port = None
 
        self.model = Model(self, log_config)
        log_config.ui = self  # set ui here because object generates before main window
 
        self.model.c_monitor.update_darkmode_status(self.model.c_monitor.e_style)
 
        self.model.c_sound.update_sound_status(read_sound_settings())
        self.status_timer = create_timer(parent=self, callback=self.clear_status)  # statusbar timer
 
        # Action Group Log Verbosity
        self.ag_verbosity = group_menu(self,
                                       [self.action_log_error, self.action_log_warning, self.action_log_info, self.action_log_debug],
                                       self.model.log_config.i_log_level,
                                       [logging.ERROR, logging.WARNING, logging.INFO, logging.DEBUG])
 
        # Action Group paper width
        self.ag_paper_width = group_menu(self,
                                         [self.action_58mm, self.action_80mm],
                                         self.model.c_printer.i_paper_width,
                                         [EPaper.WIDTH_58_MM, EPaper.WIDTH_80_MM])
 
        # Sound
        config_menu(self.action_sound, checked=self.model.c_sound.b_sound)
 
        # Show Price
        config_menu(self.action_show_price, checked=self.model.b_show_price)
 
        # Enable Print Report
        config_menu(self.action_enable_report, checked=self.model.b_enable_report)
 
        # Action Group theme
        self.ag_theme = group_menu(self,
                                   [self.action_auto, self.action_light, self.action_dark, self.action_system],
                                   self.model.c_monitor.e_style,
                                   [ETheme.AUTO, ETheme.LIGHT, ETheme.DARK, ETheme.SYSTEM])
 
        # Action Group language
        self.ag_language = group_menu(self,
                                      [self.action_english, self.action_german],
                                      self.model.c_language.e_language,
                                      [ELanguages.ENGLISH, ELanguages.GERMAN])
 
        # Connect Callbacks
        # button connections
        self.l_bnt_fnc: list[BUTTON] = [self.btn_item1, self.btn_item2, self.btn_item3, self.btn_item4, self.btn_item5,
                                        self.btn_item6, self.btn_item7, self.btn_item8, self.btn_item9, self.btn_item10,
                                        self.btn_item11, self.btn_item12, self.btn_item13, self.btn_item14, self.btn_item15,
                                        self.btn_item16, self.btn_item17, self.btn_item18, self.btn_item19, self.btn_item20,
                                        self.btn_item21, self.btn_item22, self.btn_item23, self.btn_item24, self.btn_item25,
                                        self.btn_item26, self.btn_item27, self.btn_item28, self.btn_item29, self.btn_item30,
                                        self.btn_item31, self.btn_item32, self.btn_item33, self.btn_item34, self.btn_item35,
                                        self.btn_item36, self.btn_item37, self.btn_item38, self.btn_item39, self.btn_item40,
                                        self.btn_item41, self.btn_item42, self.btn_item43, self.btn_item44, self.btn_item45,
                                        self.btn_item46, self.btn_item47, self.btn_item48, self.btn_item49, self.btn_item50,
                                        self.btn_item51, self.btn_item52, self.btn_item53, self.btn_item54, self.btn_item55,
                                        self.btn_item56]
        self.b_btn_hold = False
        self.i_btn_hold_idx = 0
        self.btn_timer = create_timer(parent=self, callback=self.btn_item_held)  # timer for button held
        for i, btn in enumerate(self.l_bnt_fnc):
            connect_button(btn,
                           clicked_fnc=self.btn_item_clicked,
                           pressed_fnc=self.btn_item_pressed,
                           released_fnc=self.btn_item_released,
                           index=i)
        connect_button(self.btn_multi, self.btn_multi_clicked)
        connect_button(self.btn_calc, self.btn_calc_clicked)
        connect_button(self.btn_clear, self.btn_clear_clicked)
        connect_button(self.btn_print, self.btn_print_clicked)
        connect_button(self.btn_lock, self.btn_lock_clicked)
 
        # Menu buttons
        connect_menu(self.action_show_interim, self.btn_report_print, False)
        connect_menu(self.action_open_folder, self.btn_open_folder)
        connect_menu(self.action_combine_manual, self.btn_combine_manual)
        connect_menu(self.action_combine_auto, self.btn_combine_auto)
        connect_menu(self.action_print_file, self.btn_print_file)
        connect_menu(self.action_article_preview, self.btn_article_preview)
        connect_menu(self.action_enable_report, self.model.update_enable_report_status)
        connect_menu(self.action_create_billing, self.btn_report_print, True)
        # User
        connect_menu(self.action_user_edit, self.btn_change_user, EConfigSelection.EDIT)
        connect_menu(self.action_user_import, self.btn_change_user, EConfigSelection.IMPORT)
        connect_menu(self.action_user_export, self.btn_change_user, EConfigSelection.EXPORT)
        connect_menu(self.action_user_new, self.btn_change_user, EConfigSelection.RESET)
        # Items
        connect_menu(self.action_articles_edit, self.btn_change_item, EConfigSelection.EDIT)
        connect_menu(self.action_articles_import, self.btn_change_item, EConfigSelection.IMPORT)
        connect_menu(self.action_articles_export, self.btn_change_item, EConfigSelection.EXPORT)
        connect_menu(self.action_articles_new, self.btn_change_item, EConfigSelection.RESET)
        # Other Config
        connect_menu(self.action_change_path, self.change_output_path)
        # COM Port (max number of supported ports: 10 TODO use variable number of ports (not only 10) but is buggy)
        connect_menu(self.action_none, self.model.c_printer.update_com_port, None)
        connect_menu_com_port(self.action_port_1, self.model.c_printer.update_com_port)
        connect_menu_com_port(self.action_port_2, self.model.c_printer.update_com_port)
        connect_menu_com_port(self.action_port_3, self.model.c_printer.update_com_port)
        connect_menu_com_port(self.action_port_4, self.model.c_printer.update_com_port)
        connect_menu_com_port(self.action_port_5, self.model.c_printer.update_com_port)
        connect_menu_com_port(self.action_port_6, self.model.c_printer.update_com_port)
        connect_menu_com_port(self.action_port_7, self.model.c_printer.update_com_port)
        connect_menu_com_port(self.action_port_8, self.model.c_printer.update_com_port)
        connect_menu_com_port(self.action_port_9, self.model.c_printer.update_com_port)
        connect_menu_com_port(self.action_port_10, self.model.c_printer.update_com_port)
        # Paper
        connect_menu(self.action_58mm, self.model.c_printer.update_paper_width, EPaper.WIDTH_58_MM.value)
        connect_menu(self.action_80mm, self.model.c_printer.update_paper_width, EPaper.WIDTH_80_MM.value)
        # Sound
        connect_menu(self.action_sound, self.model.c_sound.update_sound_status)
        # Dark Mode
        connect_menu(self.action_auto, self.model.c_monitor.update_darkmode_status, ETheme.AUTO)
        connect_menu(self.action_light, self.model.c_monitor.update_darkmode_status, ETheme.LIGHT)
        connect_menu(self.action_dark, self.model.c_monitor.update_darkmode_status, ETheme.DARK)
        config_menu(self.action_normal, show=False)
        connect_menu(self.action_system, self.model.c_monitor.update_darkmode_status, ETheme.SYSTEM)
        # Language
        connect_menu(self.action_english, self.model.c_language.update_language, ELanguages.ENGLISH)
        connect_menu(self.action_german, self.model.c_language.update_language, ELanguages.GERMAN)
        # Show Price
        connect_menu(self.action_show_price, self.model.update_show_price_status)
        # Verbosity
        connect_menu(self.action_log_error, self.model.log_config.update_log_level, logging.ERROR)
        connect_menu(self.action_log_warning, self.model.log_config.update_log_level, logging.WARNING)
        connect_menu(self.action_log_info, self.model.log_config.update_log_level, logging.INFO)
        connect_menu(self.action_log_debug, self.model.log_config.update_log_level, logging.DEBUG)
        # Paper change
        # Help
        connect_menu(self.action_help, self.show_help_dialog)
        connect_menu(self.action_about_app, show_about_dialog, self)
        connect_menu(self.action_reset, self.reset_config)
 
        filter_menubar(self.menubar, self)
 
        # initialize screen
        self.model.c_report.create_report(b_clear_report=False, b_startup_check=True)  # check for valid report at startup
        config_window(self, fullscreen=False, resize_callback=self.model.c_monitor.resize_window)
        self.model.c_monitor.resize_window()
        self.update_screen()
        if not authenticated:
            self.show_unauthenticated_dialog()
        elif self.test_mode:
            self.model.c_config.read_user_file("user_example.ini")
            self.model.c_config.read_item_file("articles_example.ini")
        else:
            newer_tool_version = get_tool_update_status()
            if (newer_tool_version is not None) and (compare_versions(read_update_version(), newer_tool_version)):
                self.show_update_dialog(newer_tool_version)
            if self.model.c_config.d_user == D_DEFAULT_USER:
                self.show_welcome_dialog()
        self.clear_status(b_override=True)
 
    def resizeEvent(self, _event: RESIZE_EVENT | None) -> None:
        """!
        @brief Default resize Event Method to handle change of window size
        @param _event : arrived event
        """
        emit_signal(self.resized)
 
    def closeEvent(self, event: CLOSE_EVENT | None) -> None:  # pylint: disable=invalid-name
        """!
        @brief Default close Event Method to handle application close
        @param event : arrived event
        """
        if event is None:
            return
        log.debug("Close Event")
        save_window_state(get_window_geometry(self), get_window_state(self))
        if not self.close_window_dialog or self.qt_exception_hook.crash_arrived or self.test_mode or self.confirm_dialog(["Close Program", "Programm schließen"]):
            log.debug("Application closed")
            self.model.c_printer.terminate()
            event.accept()
        else:
            event.ignore()
 
    def confirm_dialog(self, title_value: str | list[str], s_icon_path: str = ICON_APP, l_optional_text: Optional[list[str]] = None) -> bool:
        """!
        @brief Show confirm dialog to accept or cancel.
        @param title_value : dialog title
        @param s_icon_path : icon of dialog
        @param l_optional_text : optional text
        @return return accept status
        """
        title = self.model.c_language.get_language_text(title_value) if isinstance(title_value, list) else title_value
        fix_text = self.model.c_language.get_language_text(L_YOU_SURE)
        if l_optional_text is None:
            text = fix_text
        else:
            text = fix_text + "\n\n" + self.model.c_language.get_language_text(l_optional_text)
        b_accept, _ = open_message_box(parent=self,
                                       title=title,
                                       text=text,
                                       btn_yes=self.model.c_language.get_language_text(L_YES),
                                       btn_cancel=self.model.c_language.get_language_text(L_CANCEL),
                                       window_icon=s_icon_path)
        return b_accept
 
    def set_ui(self, b_state: bool) -> None:
        """!
        @brief Blocks/Unblock the main UI elements.
        @param b_state : state if UI should blocked or unblocked, True: Enable, False: Disable
        """
        if not b_state:
            for btn in self.l_bnt_fnc:
                config_btn(btn, enable=b_state)
 
            config_btn(self.btn_print, enable=b_state)
            config_btn(self.btn_clear, enable=b_state)
            config_btn(self.btn_multi, enable=b_state)
            config_btn(self.btn_calc, enable=b_state)
            config_btn(self.btn_lock, enable=b_state)
        config_menu(self.menu_prints, enable=b_state)
        config_menu(self.menu_configuration, enable=b_state)
        config_menu(self.menu_settings, enable=b_state)
        config_menu(self.menu_help, enable=b_state)
 
    def block_ui(self) -> None:
        """!
        @brief Blocks the main UI elements.
        """
        log.debug("Block UI")
        self.set_ui(False)
        self.gui_locked = True
        self.set_status("")
 
    def unblock_ui(self) -> None:
        """!
        @brief Unblock the main UI elements.
        """
        log.debug("Unblock UI")
        self.set_ui(True)
        self.gui_locked = False
        self.update_screen()
        self.status_timer.stop()  # stop timer to deactivate unlock diagnostic directly after clear status
        self.clear_status()
 
    def show_update_dialog(self, newer_tool_version: str) -> None:
        """!
        @brief Show Update dialog.
        @param newer_tool_version : newest tool version
        """
        l_text = [f"New version available! \nUpdate to version {newer_tool_version}?",
                  f"Neue Version verfügbar! \nUpdate auf Version {newer_tool_version} durchführen?"]
        l_remember = ["Don't show again",
                      "Nicht mehr anzeigen"]
        s_title = self.model.c_language.get_language_text(["Update Service", "Update-Dienst"])
        b_update, is_checked = open_message_box(parent=self,
                                                title=s_title,
                                                text=self.model.c_language.get_language_text(l_text),
                                                btn_yes=self.model.c_language.get_language_text(L_YES),
                                                btn_no=self.model.c_language.get_language_text(L_NO),
                                                check_box=self.model.c_language.get_language_text(l_remember),
                                                window_icon=ICON_APP)
        if is_checked:
            write_update_version(newer_tool_version)  # write newest version for don't remember again
        if b_update:
            copy_to_clipboard(S_UPDATE_URL)
            webbrowser.open_new_tab(S_UPDATE_URL)
            sys.exit()  # exit application without close dialog
 
    def show_welcome_dialog(self) -> None:
        """!
        @brief Show welcome screen and choose admin password.
        """
        l_text = ["To change user and articles configuration, see the Help menu."
                  + "\n\nIf the Admin password is lost, all data can be reset:"
                  + "\n1. Select Admin User to show hidden menu"
                  + "\n2. Help→Reset"
                  + f"\n3. Enter reset code: {base64.b64decode(RESET_CODE).decode('utf-8')}"
                  + "\n\nChoose an Admin password (numbers only):",
                  "Um die Benutzer- und Artikelkonfiguration zu ändern, siehe im Menü Hilfe"
                  + "\n\nWenn das Admin-Passwort verloren geht, können alle Daten zurückgesetzt werden:"
                  + "\n1. Wählen Sie Admin User, um das ausgeblendete Menü anzuzeigen"
                  + "\n2. Help→Reset"
                  + f"\n3. Reset-Code eingeben: {base64.b64decode(RESET_CODE).decode('utf-8')}"
                  + "\n\nWählen Sie ein Admin-Passwort (nur Zahlen):"]
        s_title = self.model.c_language.get_language_text(["Welcome to", "Willkommen zu"])
        password, ok = input_dialog(self, f"{s_title} {__title__}", self.model.c_language.get_language_text(l_text), DEFAULT_CODE, icon=ICON_APP)
        if ok and (password.isdigit() or password == ""):
            self.model.c_config.d_user[EUser.ADMIN.value][S_PW] = str(password)
            self.model.c_config.store_user_data()
        else:
            sys.exit()  # exit application without close dialog
 
    def show_unauthenticated_dialog(self) -> None:
        """!
        @brief Show unauthenticated dialog.
        """
        s_text = self.model.c_language.get_language_text(["Unauthenticated use", "Unauthentifizierte Verwendung"])
        l_text = ["You are not entitled to test a pre-release version."
                  + "\n\nUse a published version:"
                  + f"\n{__home__}",
                  "Sie sind nicht berechtigt, eine Vorabversion zu testen."
                  + "\n\nVerwenden Sie eine veröffentlichte Version:"
                  + f"\n{__home__}"]
        b_accept, _ = open_message_box(parent=self,
                                       title=s_text,
                                       text=self.model.c_language.get_language_text(l_text),
                                       btn_close=self.model.c_language.get_language_text(L_CLOSE),
                                       btn_special=self.model.c_language.get_language_text(L_COPY_URL),
                                       window_icon=ICON_APP)
        if b_accept:
            copy_to_clipboard(__home__)
        sys.exit()  # exit application without close dialog
 
    def show_help_dialog(self) -> None:
        """!
        @brief Show help dialog.
        """
        log.debug("Starting help dialog")
        icon = ICON_HELP_LIGHT if self.model.c_monitor.is_light_theme() else ICON_HELP_DARK
        config_window(self.dialog_help, title=self.model.c_language.get_language_text(L_MENU_HELP), icon=icon, show=True)
 
    def set_status(self, text_value: str | list[str], b_warning: bool = False, i_timeout: Optional[int] = None, b_highlight: bool = False, b_thread: bool = False) -> None:
        """!
        @brief Logs a status message to status bar (with timer) and logging handler
        @param text_value : text to set
        @param b_warning : [True] Text is a warning; [False] normal info
        @param b_highlight : [True] highlight text; [False] normal text
        @param i_timeout : timeout for statustext in "ms". If None use default time
        @param b_thread : call from thread to prevent timer activations (not allowed from thread)
        """
        text = self.model.c_language.get_language_text(text_value) if isinstance(text_value, list) else text_value
        if b_warning:
            log.warning(text)
        else:
            log.info(text)
 
        if self.gui_locked:
            locked_text = self.model.c_language.get_language_text(["Window Locked!",
                                                                   "Das Fenster ist gesperrt!"])
            config_label(self.statusbar_left, text=locked_text, bg=LOCKED_STYLE)
        else:
            if not (not b_warning and self.b_warning_active):
                if hasattr(self, "status_timer"):
                    if not b_thread:  # start/stop time from thread is not allowed
                        if i_timeout is None:
                            if b_warning:
                                i_timeout = STATUS_WARNING_TEXT_TIME
                            else:
                                i_timeout = STATUS_HIGHLIGHT_TEXT_TIME if b_highlight else STATUS_TEXT_TIME
                        if i_timeout is None:
                            self.status_timer.stop()
                        else:
                            self.status_timer.start(i_timeout)
                if b_warning:
                    foreground = None
                    background = WARNING_STYLE if self.model.c_monitor.is_light_theme() else WARNING_STYLE_DARK
                    self.b_warning_active = True
                else:
                    foreground = HIGHLIGHT_STYLE if b_highlight else None
                    background = DEFAULT_STYLE
                    self.b_warning_active = False
                config_label(self.statusbar_left, text=text, bg=background, fg=foreground)
 
    def clear_status(self, b_override: bool = False) -> None:
        """!
        @brief Clear status bar text and set active user as default
        @param b_override : status if actual status should override
        """
        if not self.gui_locked:
            if not self.status_timer.isActive() or (b_override and not self.b_warning_active):
                user = self.model.c_auth.s_login_user
                if user and user[0] == EUser.B.name:
                    user_name = self.model.c_config.get_user_name(user)
                    if user_name != "":
                        user_name = f" ({user_name})"
                else:
                    user_name = ""
                if user:
                    user = user.replace("\n", " ")  # prevent word wrapping for user in statusbar
                s_user_text = f"{self.model.c_language.get_language_text(L_MENU_USER)}: {user}{user_name}"
                config_label(self.statusbar_left, text=s_user_text, bg=DEFAULT_STYLE)
                self.b_warning_active = False
 
    def open_report_dialog(self, b_clear_report: bool, b_auto_print: bool) -> None:
        """!
        @brief Open report dialog.
        @param b_clear_report : [True] create report and clear log; [False] show only status
        @param b_auto_print : status if report was printed automatic
        """
        show_report_dialog(self, b_clear_report, b_auto_print)
 
    def show_item_btns(self) -> None:
        """!
        @brief Update item buttons.
        """
        log.debug("Update item buttons")
        for i, btn in enumerate(self.l_bnt_fnc):
            i_pos = i + 1
            if i < self.model.c_config.item_number_size:
                if self.model.c_auth.check_user_login(L_CONFIG_USER):
                    # show only disabled numbers
                    config_btn(btn, enable=False, show=True, text=str(i_pos))
                else:
                    s_item_name = self.model.c_config.get_item_button_name(i_pos)
                    s_visible_user = self.model.c_config.get_item_visible_user(i_pos)
                    if (s_item_name != "") and ((s_visible_user is None) or self.model.c_auth.check_user_login(s_visible_user)):
                        if self.model.b_show_price:
                            f_item_price = self.model.c_config.get_item_price(i_pos)
                            s_item_name += f"\n{f_item_price:.2f} {S_UNIT_SYMBOL}"
                        config_btn(btn, enable=True, show=True, text=s_item_name)
                    else:
                        config_btn(btn, show=False)
                if self.model.c_report.l_marked_items[i]:
                    background_color = "orange"
                elif self.model.c_auth.check_user_login(EUser.FREE):
                    background_color = "lightgreen" if self.model.c_monitor.is_light_theme() else "darkgreen"
                else:
                    select_bg = self.model.c_config.get_item_background(i_pos)
                    if select_bg:
                        background_color = select_bg
                    else:
                        background_color = None
                if background_color is None:
                    config_btn(btn, style=self.model.c_monitor.default_button_stylesheet)
                else:
                    config_btn(btn, bg=background_color)
            else:
                config_btn(btn, show=False)
        config_btn(self.btn_lock, enable=True)
 
    def show_login_btns(self) -> None:
        """!
        @brief Update login buttons.
        """
        log.debug("Update login buttons")
        for i, btn in enumerate(self.l_bnt_fnc):
            if i < ItemNumber.MIN:
                pressed_button = L_LOGIN_KEYS[i]
                s_name = pressed_button
                if not pressed_button.isdigit():
                    user_name = self.model.c_config.get_user_name(L_LOGIN_KEYS[i])
                    if user_name != "":
                        s_name = "\n".join([s_name + ":"] + user_name.split())
                config_btn(btn, enable=True, show=True, text=s_name)
                background_color = None
                match pressed_button:
                    case EUser.ADMIN:
                        background_color = "red"
                    case EUser.HOST:
                        background_color = "brown"
                    case EUser.FREE:
                        background_color = "green"
                    case EUser.LOCAL:
                        background_color = "blue"
                    case EUser.USER:
                        background_color = "lightgray" if self.model.c_monitor.is_light_theme() else "#141414"
                    case _:
                        if pressed_button[0] == EUser.B:
                            background_color = "lightblue" if self.model.c_monitor.is_light_theme() else "darkblue"
                if background_color is None:
                    config_btn(btn, style=self.model.c_monitor.default_button_stylesheet)
                else:
                    config_btn(btn, bg=background_color)
 
                # enable user button if activated
                pw = self.model.c_config.get_user_pw(pressed_button)
                b_enable_user = bool((pressed_button in self.model.c_config.d_user)
                                     and (S_PW in self.model.c_config.d_user[pressed_button])
                                     and (pw.isdigit() or pw == ""))
                match pressed_button:
                    case EUser.ADMIN:
                        b_enable_user = True  # admin is already enabled to be able to reset config data
                    case EUser.HOST | EUser.FREE | EUser.LOCAL:
                        pass  # b_enable_user is correct
                    case EUser.USER:
                        b_enable_user = False
                    case _:
                        if pressed_button[0] == EUser.B:
                            pass  # b_enable_user is correct
                        else:
                            b_enable_user = bool(self.model.c_auth.s_login_user is not None)  # numbers are enabled for select user
                config_btn(btn, enable=b_enable_user)
            else:
                config_btn(btn, show=False)
        config_btn(self.btn_lock, enable=False)
        config_btn(self.btn_print, enable=False)
 
    def show_number_btns(self) -> None:
        """!
        @brief Update number buttons.
        """
        log.debug("Update number buttons")
        for i, btn in enumerate(self.l_bnt_fnc):
            if i < ItemNumber.MIN:
                s_name = L_LOGIN_KEYS[i]
                match s_name:
                    case EUser.ADMIN:
                        s_name = S_DOT
                        b_show = bool(self.model.c_auth.e_view == EWindowView.CALC)
                    case EUser.HOST:
                        s_name = S_DOUBLE_NULL
                        b_show = True
                    case _:
                        b_show = bool((len(s_name) == 1) and s_name.isnumeric())
                b_enable = bool((s_name not in L_SPECIAL_BTNS)
                                or ((self.model.c_calc.s_text_total != "") and ((s_name != S_DOT) or (S_DOT not in self.model.c_calc.s_text_total))))
                config_btn(btn, text=s_name, enable=b_enable, style=self.model.c_monitor.default_button_stylesheet, show=b_show)
            else:
                config_btn(btn, show=False)
        config_btn(self.btn_lock, enable=True)
        match self.model.c_auth.e_view:
            case EWindowView.MULTI:
                config_btn(self.btn_multi, enable=True, show=True)
                config_btn(self.btn_calc, enable=False, show=False)
            case EWindowView.CALC:
                config_btn(self.btn_multi, enable=False, show=False)
                config_btn(self.btn_calc, enable=True, show=True)
            case _:
                self.set_status("Invalid Number Button Code", True)  # state not possible
        config_btn(self.btn_print, show=False)
 
    def update_table(self) -> None:
        """!
        @brief Update table and print/clear button.
        """
        log.debug("Update table")
        self.model.c_auth.refresh_timer()  # refresh timer for every button click
        clear_text = self.model.c_language.get_language_text(L_CLEAR)
        l_row_description = self.model.c_language.get_table_row_description()
        b_items_in_list = False
        b_update_clear_btn = True
        table = self.table_items
        config_table(table, single_row_selection=not self.model.c_calc.b_hold_last_print,
                     row_description=l_row_description,
                     font=self.model.c_monitor.table_font, auto_size=True)  # auto to set correct for style change
        if self.model.c_calc.b_hold_last_print:
            if self.model.c_auth.e_view == EWindowView.CALC:  # hold items in calculator mode
                b_clear_btn_enable = bool((self.model.c_calc.s_text_total != "") or (self.model.c_calc.i_multi > 0))  # enable status in multi/calc mode
                fg_color = "red" if b_clear_btn_enable else "grey"
                config_btn(self.btn_clear, enable=b_clear_btn_enable, text=clear_text, fg=fg_color, icon="")
            background_color = "lightgreen" if self.model.c_monitor.is_light_theme() else "darkgreen"
            config_text(self.text_total, bg=background_color, fg="black")  # update color if theme changed while hold
            self.model.c_calc.b_hold_last_print = False
        else:
            i = 0
            f_total = 0.0
            for i_item_pos, entry in enumerate(self.model.c_report.l_bar_items):
                self.model.c_report.l_table_position[i_item_pos] = None
                if entry != 0:
                    b_items_in_list = True
                    fg = None
                    item_name = self.model.c_config.get_item_name(i_item_pos + 1)
                    if self.model.c_auth.check_user_login(EUser.FREE):
                        f_price = 0.0
                    else:
                        f_item_price = self.model.c_config.get_item_price(i_item_pos + 1)
                        f_price = f_item_price * entry
                        f_total += f_price
                    bg = "orange" if self.model.c_report.l_marked_items[i_item_pos] else None
                    insert_table_item(table, i, [str(entry),
                                                 item_name,
                                                 f"{f_price:.2f} {S_UNIT_SYMBOL}"],
                                      font=self.model.c_monitor.table_font,
                                      fg=fg,
                                      bg=bg)
                    self.model.c_report.l_table_position[i_item_pos] = i  # save table position of item to delete single entries
                    i += 1
 
            config_table(table, row_count=i, auto_size=True)
 
            if self.model.c_auth.b_login_state and (self.model.c_auth.e_view == EWindowView.MAIN):
                self.model.c_calc.s_text_total = f"{f_total:.2f} {S_UNIT_SYMBOL}"
            if self.model.c_monitor.is_light_theme():
                config_text(self.text_total, bg="white", fg="black")
            else:
                config_text(self.text_total, bg="black", fg="white")
        if get_selected_table_column(self.table_items) != 0:  # clear selected table position not if first column is selected
            config_table(table, clear_selection=True)  # clear selection at end of update to prevent that last single item marker jump to next
 
        # update print button text
        open_text = self.model.c_language.get_language_text(L_OPEN)
        b_items_in_list = b_items_in_list or (sum(self.model.c_report.l_bar_items) != 0)
        if self.model.c_printer.b_select_com_port_available:
            if b_items_in_list or not self.model.c_auth.b_login_state:
                s_btn_print_text = self.model.c_language.get_language_text(L_PRINT)
            else:
                s_btn_print_text = open_text
        else:
            s_btn_print_text = self.model.c_language.get_language_text(L_SAVE)
 
        # set total text
        if self.model.c_calc.i_multi > 1:
            text = f"{self.model.c_calc.i_multi} x"
        elif self.model.c_calc.f_back is not None:
            to_pay_text = self.model.c_language.get_language_text(["to pay", "zu zahlen"])
            given_text = self.model.c_language.get_language_text(["Given", "Gegeben"])
            s_given_sum = f"{float(self.model.c_calc.f_payed):.2f}"
            back_text = self.model.c_language.get_language_text(["Back", "Zurück"])
            s_back_sum = f"{self.model.c_calc.f_back:.2f}" if (self.model.c_calc.f_back >= 0) else "---"
            text = f"{to_pay_text}: {self.model.c_calc.f_total:.2f} {S_UNIT_SYMBOL}"
            text += f"\n{given_text}: {s_given_sum} {S_UNIT_SYMBOL}"
            text += f"\n{back_text}: {s_back_sum} {S_UNIT_SYMBOL}"
            self.model.c_calc.f_back = None
            self.model.c_calc.f_total = 0
        else:
            text = str(self.model.c_calc.s_text_total)
        config_text(self.text_total, text=text)
 
        # enable/disable/show/hide table buttons
        b_no_config_user = not self.model.c_auth.check_user_login(L_CONFIG_USER)
        b_sell_user = bool(self.model.c_auth.b_login_state and b_no_config_user)
        config_btn(self.btn_multi, enable=b_sell_user)
        config_btn(self.btn_calc, enable=(self.model.c_auth.check_user_login(EUser.LOCAL) and self.model.c_auth.b_login_state and (self.model.c_calc.f_total != 0)))
        if b_update_clear_btn:
            match self.model.c_auth.e_view:
                case EWindowView.CALC | EWindowView.MULTI:
                    b_clear_btn_enable = bool((self.model.c_calc.s_text_total != "") or (self.model.c_calc.i_multi > 0))  # enable status in multi/calc mode
                case _:
                    b_clear_btn_enable = bool(b_items_in_list or ((not self.model.c_auth.b_login_state) and (self.model.c_calc.s_text_total != "")))
            fg_color = "red" if b_clear_btn_enable else "grey"
            config_btn(self.btn_clear, enable=b_clear_btn_enable, text=clear_text, fg=fg_color, icon="")
        b_enable_print = bool((not self.model.c_auth.check_user_login(EUser.USER))
                              and (b_items_in_list or ((s_btn_print_text == open_text) and self.model.c_auth.b_login_state and not self.model.c_auth.check_user_login(EUser.B))))
        config_btn(self.btn_print, enable=b_enable_print, text=s_btn_print_text)
        if self.model.c_auth.e_view == EWindowView.MAIN:
            config_btn(self.btn_multi, show=True)
            config_btn(self.btn_calc, show=True)
            config_btn(self.btn_clear, show=True)
            config_btn(self.btn_print, show=True)
        self.model.c_monitor.resize_window(b_update_only_total_font=True)  # update only total text font size for pay back
 
    def update_menu(self) -> None:
        """!
        @brief Update menu.
        """
        b_admin_settings = bool(self.model.c_auth.b_login_state and (self.model.c_auth.check_user_login(EUser.ADMIN)))
        b_printer_available = bool(self.model.c_printer.s_select_com_port is not None)
        b_edit_user = self.model.c_auth.b_login_state and (self.model.c_auth.check_user_login(L_CONFIG_USER))
        b_log_exist = self.model.c_report.check_sales_exist()
        b_print_menu = (self.model.b_enable_report or self.model.c_auth.check_user_login(EUser.ADMIN)) and self.model.c_auth.b_login_state and (not self.model.c_auth.check_user_login(EUser.FREE))
        config_menu(self.menu_prints, show=b_print_menu)
        config_menu(self.action_show_interim, enable=b_log_exist, show=self.model.b_enable_report)
        config_menu(self.action_open_folder, show=b_edit_user)
        config_menu(self.menu_combine_report, show=b_edit_user)
        config_menu(self.action_print_file, enable=b_printer_available, show=b_edit_user)
        config_menu(self.action_article_preview, show=b_edit_user)
        config_menu(self.action_enable_report, show=b_admin_settings)
        config_menu(self.action_create_billing, enable=b_log_exist, show=b_edit_user and self.model.b_enable_report)
        config_menu(self.action_auto_export, show=False)
        config_menu(self.menu_configuration, show=b_edit_user)
        config_menu(self.action_user_import, enable=b_admin_settings)
        config_menu(self.action_user_export, enable=b_admin_settings)
        config_menu(self.action_user_new, enable=b_admin_settings)
        config_menu(self.menu_articles, enable=b_admin_settings)
        config_menu(self.action_articles_pdf_import, show=False)
        config_menu(self.action_change_path, enable=b_admin_settings)
        config_menu(self.action_webserver, show=False)
        config_menu(self.menu_com_port, enable=b_admin_settings)
        config_menu(self.menu_paper_width, enable=b_admin_settings)
        config_menu(self.menu_smartcard, show=False)
        config_menu(self.menu_display_port, show=False)
        config_menu(self.action_auto_import, show=False)
        config_menu(self.menu_log_verbosity, show=b_admin_settings)
        config_menu(self.action_paper_change, show=False)
        config_menu(self.action_reset, show=self.model.c_auth.check_user_login(EUser.ADMIN))
 
    def update_screen(self) -> None:
        """!
        @brief Update complete screen.
        """
        log.debug("Update screen")
        if not self.gui_locked:
            self.model.c_monitor.check_for_style_change()  # check every complete update cycle if style changed
            if self.model.c_auth.b_login_state:
                match self.model.c_auth.e_view:
                    case EWindowView.MULTI | EWindowView.CALC:
                        self.show_number_btns()
                    case _:
                        self.show_item_btns()
            else:
                self.model.c_report.clear_print_items()
                self.show_login_btns()
            self.update_table()
            self.update_menu()
            if self.model.c_config.item_number_size != ItemNumber.MIN:  # update only required in extended item view for different button rows
                self.model.c_monitor.resize_window()
        else:
            log.debug("Screen is locked - no update")
 
    def btn_item_clicked(self, i_item_number: int) -> None:
        """!
        @brief Handle item button/login (1-30) clicked.
        @param i_item_number : button index that was clicked
        """
        log.debug("Item button %s clicked", i_item_number)
        if self.model.c_auth.b_login_state:  # item mode
            if not self.b_btn_hold:
                match self.model.c_auth.e_view:
                    case EWindowView.MULTI | EWindowView.CALC:
                        s_name = L_LOGIN_KEYS[i_item_number]
                        match s_name:
                            case EUser.ADMIN:
                                s_name = S_DOT
                            case EUser.HOST:
                                s_name = S_DOUBLE_NULL
                            case _:
                                if (len(s_name) == 1) and s_name.isnumeric():
                                    pass  # use this number
                                else:
                                    self.set_status("Invalid Multiple Button pressed", True)  # state not possible
                                    s_name = ""
                        self.model.c_calc.s_text_total += s_name
                        self.show_number_btns()
                    case _:
                        b_add_item = True
                        if self.model.c_calc.i_multi > 0:
                            i_factor = self.model.c_calc.i_multi
                            self.model.c_calc.i_multi = 0
                        else:
                            i_factor = 1
                        if b_add_item:
                            i_item_index = i_item_number
                            self.model.c_report.l_bar_items[i_item_index] += i_factor  # add item
                        self.model.c_calc.f_total = 0
                if self.model.c_sound.b_sound:
                    self.model.c_sound.c_sound_touch.play()
                if self.model.c_auth.e_view == EWindowView.CALC:  # hold items in calculator mode
                    self.model.c_calc.b_hold_last_print = True
                self.update_table()
        else:  # login mode
            s_key = L_LOGIN_KEYS[i_item_number]
            if len(s_key) == 1:  # number pressed
                if self.model.c_auth.s_login_user is None:
                    self.set_status("None user input password", True)  # state not possible
                    return
                self.model.c_auth.s_pw += s_key
                pw = self.model.c_config.get_user_pw(self.model.c_auth.s_login_user)
                if len(self.model.c_auth.s_pw) == len(pw):
                    if self.model.c_auth.s_pw == pw:
                        self.model.c_auth.log_in()
                    else:
                        self.model.c_calc.s_text_total = self.model.c_auth.s_login_user
                    self.model.c_auth.s_pw = ""
                else:
                    self.model.c_calc.s_text_total = "*" * len(self.model.c_auth.s_pw)
            else:  # user pressed
                self.model.c_auth.s_pw = ""
                self.model.c_auth.s_login_user = s_key
                self.model.c_calc.s_text_total = s_key
                pw = self.model.c_config.get_user_pw(s_key)
                if pw == "":
                    self.model.c_auth.log_in()  # no pw for no user
            self.model.c_calc.f_total = 0
            if self.model.c_sound.b_sound:
                if self.model.c_auth.b_login_state:
                    self.model.c_sound.c_sound_unlock.play()
                else:
                    self.model.c_sound.c_sound_touch.play()
            self.update_screen()
        self.b_btn_hold = False
 
    def btn_item_pressed(self, i_item_number: int) -> None:
        """!
        @brief Handle item button/login (1-30) pressed.
        @param i_item_number : button index that was pressed
        """
        log.debug("Item button %s pressed", i_item_number)
        if self.model.c_auth.b_login_state and (self.model.c_auth.e_view == EWindowView.MAIN):
            self.btn_timer.start(I_BTN_LONG_PRESS_TIME)
            self.i_btn_hold_idx = i_item_number
 
    def btn_item_released(self, i_item_number: int) -> None:
        """!
        @brief Handle item button/login (1-30) released.
        @param i_item_number : button index that was released
        """
        log.debug("Item button %s released", i_item_number)
        self.btn_timer.stop()
 
    def btn_item_held(self) -> None:
        """!
        @brief Item button held.
        """
        log.debug("Item held")
        self.b_btn_hold = True
        self.model.c_report.l_marked_items[self.i_btn_hold_idx] = not self.model.c_report.l_marked_items[self.i_btn_hold_idx]
        self.update_screen()
 
    def btn_multi_clicked(self) -> None:
        """!
        @brief Handle multi button clicked.
        """
        log.debug("Multi button clicked")
        match self.model.c_auth.e_view:
            case EWindowView.MULTI:
                if self.model.c_calc.s_text_total == "":
                    self.model.c_calc.s_text_total = str(0)  # if multi btn clicked without input
                self.model.c_calc.i_multi = int(self.model.c_calc.s_text_total)
                self.model.c_auth.e_view = EWindowView.MAIN
            case _:
                self.model.c_calc.s_text_total = ""
                self.model.c_calc.i_multi = 0
                self.model.c_auth.e_view = EWindowView.MULTI
        if self.model.c_sound.b_sound:
            self.model.c_sound.c_sound_touch.play()
        self.update_screen()
 
    def btn_calc_clicked(self) -> None:
        """!
        @brief Handle calc button clicked.
        """
        log.debug("Calc button clicked")
        b_last_calc = bool(self.model.c_auth.e_view == EWindowView.CALC)
        match self.model.c_auth.e_view:
            case EWindowView.CALC:
                if self.model.c_calc.s_text_total == "":
                    self.model.c_calc.s_text_total = str(0)  # if calc btn clicked without input
                self.model.c_calc.f_payed = float(self.model.c_calc.s_text_total)
                if self.model.c_calc.f_total > self.model.c_calc.f_payed:
                    self.set_status(["Not enough Money", "Nicht genug Geld"], b_highlight=True)
                self.model.c_calc.f_back = self.model.c_calc.f_payed - self.model.c_calc.f_total
                self.model.c_auth.e_view = EWindowView.MAIN
            case _:
                self.model.c_calc.s_text_total = ""
                self.model.c_calc.f_back = None
                self.model.c_auth.e_view = EWindowView.CALC
        if self.model.c_sound.b_sound:
            self.model.c_sound.c_sound_touch.play()
        self.model.c_calc.b_hold_last_print = True
        self.update_screen()
        if b_last_calc:  # Disable and set CLR button TODO update screen setzen
            config_btn(self.btn_clear, enable=False, text=self.model.c_language.get_language_text(L_CLEAR), fg="grey", icon="")
 
    def clear_articles(self) -> None:
        """!
        @brief Clear articles.
        """
        i_select_item = None
        selected_row = get_selected_table_row(self.table_items)
        selected_column = get_selected_table_column(self.table_items)
        if selected_row is not None:
            for i_pos, table_pos in enumerate(self.model.c_report.l_table_position):
                if table_pos == selected_row:
                    i_select_item = i_pos
                    break
        if i_select_item is None:
            self.model.c_report.clear_print_items()
        else:
            if self.model.c_report.l_bar_items[i_select_item] != 0:
                if selected_column == 2:  # clear all counts if price column selected
                    self.model.c_report.l_bar_items[i_select_item] = 0  # delete all item counts
                else:
                    self.model.c_report.l_bar_items[i_select_item] -= 1  # delete single item
            else:
                self.set_status(f"Not possible to delete single item at position {selected_row}", True)  # state not possible
 
    def btn_clear_clicked(self) -> None:
        """!
        @brief Handle clear button clicked.
        """
        log.debug("Clear button clicked")
        b_ec_pressed = False
        if self.model.c_auth.b_login_state:
            match self.model.c_auth.e_view:
                case EWindowView.MULTI | EWindowView.CALC:
                    self.model.c_calc.s_text_total = ""
                case _:
                    btn_text = get_btn_text(self.btn_clear)
                    if self.model.c_language.get_language_text(L_CLEAR) == btn_text:
                        self.clear_articles()
                    else:
                        pass
        else:  # user view
            if self.model.c_auth.s_pw != "":
                self.model.c_auth.s_pw = ""
                if self.model.c_auth.s_login_user is not None:
                    self.model.c_calc.s_text_total = self.model.c_auth.s_login_user
                else:
                    self.model.c_calc.s_text_total = ""
                    self.set_status("None user input password", True)  # state not possible
            else:
                self.model.c_auth.s_login_user = None
                self.model.c_calc.s_text_total = ""
        # play sound
        if self.model.c_sound.b_sound:
            sound = self.model.c_sound.c_sound_touch if b_ec_pressed else self.model.c_sound.c_sound_clear
            sound.play()
        if b_ec_pressed or (self.model.c_auth.e_view == EWindowView.CALC):
            self.model.c_calc.b_hold_last_print = True
        self.update_screen()
 
    def print_selected_articles(self, l_item_log: list[Item], actual_datetime: datetime) -> float:
        """!
        @brief Print selected articles.
        @param l_item_log : add printed articles to this list
        @param actual_datetime : date for printed items
        @return total price
        """
        f_total_price = 0.0
        for i_item_pos, entry in enumerate(self.model.c_report.l_bar_items):
            if entry != 0:  # items present and not free user for deposit
                i_item_number = i_item_pos + 1
                name = self.model.c_config.get_item_name(i_item_number)
                f_single_price = self.model.c_config.get_item_price(i_item_number)
                group = self.model.c_config.get_item_group(i_item_number)
                number = i_item_number
                b_print = self.model.c_config.get_print_article_status()
                if b_print:
                    b_print = self.model.c_config.get_item_print_status(i_item_pos + 1)
                b_free_user = self.model.c_auth.check_user_login(EUser.FREE)
                f_price = 0.0 if b_free_user else f_single_price * entry
                f_total_price += f_price
                l_item_log.append(create_item(entry, name, number, group, f_single_price, f_price, self.model.c_auth.s_login_user, actual_datetime, b_print))
        return f_total_price
 
    def btn_print_clicked(self, b_smartcard: bool = False) -> None:
        """!
        @brief Handle print button clicked.
        @param b_smartcard : status if print triggered by smart card
        """
        log.debug("Print button clicked")
        btn_text = get_btn_text(self.btn_print)
        if btn_text != self.model.c_language.get_language_text(L_OPEN):
            if self.model.c_printer.b_select_com_port_available or self.model.c_printer.s_select_com_port is None:
                i_user_pos = self.model.c_auth.get_user_position()
                if i_user_pos is not None:
                    i_number_of_items = sum(self.model.c_report.l_bar_items)
                    if i_number_of_items != 0:
                        if i_number_of_items <= I_MAX_ITEMS_TO_PRINT:
                            l_item_log: list[Item] = []
                            now = datetime.now()
                            self.model.c_calc.f_total = 0.0
                            # add articles
                            self.model.c_calc.f_total += self.print_selected_articles(l_item_log, now)
                            # open drawer
                            if self.model.c_config.get_auto_open() and (self.model.c_auth.check_user_login(EUser.LOCAL)):  # No auto open for free user
                                self.model.c_printer.open_drawer()
                            self.model.c_printer.add_to_queue(l_item_log, i_user_pos, self.model.c_calc.f_total)
                            if self.model.c_sound.b_sound:
                                self.model.c_sound.c_sound_print.play()
                            background_color = "lightgreen" if self.model.c_monitor.is_light_theme() else "darkgreen"
                            config_text(self.text_total, bg=background_color, fg="black")
                            if b_smartcard:
                                self.model.c_auth.s_login_user = EUser.USER.value  # set back to user after smartcard print
                            elif self.model.c_auth.check_user_login(EUser.B):  # logout user after print
                                self.model.c_auth.log_out()
                            elif self.model.c_auth.check_user_login(EUser.FREE):  # check free user auto logout
                                if self.model.c_config.get_free_auto_logout():
                                    self.model.c_auth.log_out()
                            self.model.c_calc.b_hold_last_print = True
                            self.model.c_report.clear_print_items()
                        else:
                            self.set_status([f"Maximal {I_MAX_ITEMS_TO_PRINT} articles allowed to print",
                                             f"Maximal {I_MAX_ITEMS_TO_PRINT} Artikel möglich zu drucken"], b_highlight=True)
                    else:
                        self.set_status(["No Items to print", "Keine Artikel zu drucken"], True)
                self.update_screen()
            else:
                self.set_status([f"No Print: {self.model.c_printer.s_select_com_port} not available",
                                 f"Kein Druck: {self.model.c_printer.s_select_com_port} nicht verfügbar"], True)
        else:
            if not self.model.c_auth.check_user_login(EUser.B):
                self.model.c_printer.open_drawer()
                self.set_status(["Open cash drawer", "Öffne Kassenschublade"])
            else:
                self.set_status("Stuff cant open cash drawer", True)  # state not possible
            if self.model.c_sound.b_sound:
                self.model.c_sound.c_sound_touch.play()
 
    def btn_lock_clicked(self, b_auto_logout: bool = False) -> None:
        """!
        @brief Handle lock button clicked.
        @param b_auto_logout : [True] automatic logout (timeout); [False] manual logout
        """
        if b_auto_logout:
            log.debug("Auto logout")
        else:
            log.debug("Lock button clicked")
            if self.model.c_sound.b_sound:
                self.model.c_sound.c_sound_touch.play()
        self.model.c_calc.s_text_total = ""
        self.model.c_auth.log_out()
        self.update_screen()
 
    def btn_report_print(self, b_clear_report: bool) -> None:
        """!
        @brief Handle report or status button clicked.
        @param b_clear_report : [True] create report and clear log; [False] show only status
        """
        b_call_report = True
        if b_clear_report:
            b_call_report = self.confirm_dialog(["Create Report & clear", "Bericht erstellen & löschen"], s_icon_path=ICON_REPORT_LIGHT)
        if b_call_report:
            self.set_status(["Show Status", "Zwischenstand anzeigen"])
            self.model.c_report.create_report(b_clear_report=b_clear_report, d_item=self.model.c_config.d_item, b_open_folder=B_NOTEPAD_REPORT)
            self.block_ui()
            if B_NOTEPAD_REPORT:
                with open(S_REPORT_TEMP_FILE, mode="w", encoding="utf-8") as file:
                    file.write(self.model.c_report.s_report_text)
                self.model.notepad_worker.open_report_file(S_REPORT_TEMP_FILE, ENotepadSelection.STATUS, self.unblock_ui)
 
            if self.model.c_printer.s_select_com_port is not None:
                if b_clear_report and (not self.model.c_auth.check_user_login(EUser.ADMIN)):  # no auto print for admin
                    b_print_report = True
                else:
                    if B_NOTEPAD_REPORT:
                        b_print_report = self.confirm_dialog(["Print out status", "Status drucken"], s_icon_path=ICON_PRINTER_LIGHT)
                    else:
                        b_print_report = False
                if b_print_report:
                    self.model.c_printer.add_to_report(self.model.c_report.s_report_text)
            else:
                b_print_report = False
 
            if not B_NOTEPAD_REPORT:
                self.open_report_dialog(b_clear_report, b_print_report)
                self.unblock_ui()
            self.update_menu()
 
    def btn_change_user(self, e_config_selection: EConfigSelection) -> None:
        """!
        @brief Handle change user configuration.
        @param e_config_selection : mode of user change (edit/import/export/reset)
        """
        match e_config_selection:
            case EConfigSelection.RESET | EConfigSelection.EDIT:
                if e_config_selection == EConfigSelection.RESET:
                    d_user_dict = D_DEFAULT_USER.copy()  # copy that admin not delete in global data
                    d_user_dict[EUser.ADMIN.value][S_PW] = DEFAULT_CODE
                    b_reset = self.confirm_dialog(["Reset user", "Benutzer zurücksetzen"], s_icon_path=ICON_USER_RESET_LIGHT)
                else:
                    d_user_dict = self.model.c_config.d_user.copy()  # copy that admin not delete in global data
                    b_reset = True
                if b_reset:
                    if not self.model.c_auth.check_user_login(EUser.ADMIN):  # only Admin can view his PW
                        if EUser.ADMIN.value in d_user_dict:
                            del d_user_dict[EUser.ADMIN.value]
                        else:
                            self.set_status(["No Admin user in config data",
                                             "Kein Admin Nutzer in den Konfigurationsdaten hinterlegt"], True)
                    write_config_to_file(S_USER_TEMP_FILE, d_user_dict)
                    self.block_ui()
                    self.edit_user_in_notepad(S_USER_TEMP_FILE)
            case EConfigSelection.IMPORT:
                l_title = ["Select user configuration file to import", "Wähle eine Benutzer Konfigurationsdatei zum importieren"]
                config_import_file = open_file(parent=self, title=self.model.c_language.get_language_text(l_title),
                                               directory=self.model.get_last_path(), filetypes=INI_FILE_TYPES)
                if isinstance(config_import_file, str):
                    if config_import_file:
                        self.model.set_last_path(os.path.dirname(config_import_file))
                        b_imported = self.model.c_config.read_user_file(config_import_file)
                        if b_imported:
                            self.set_status([f"User configuration imported: {config_import_file}",
                                             f"Benutzer Konfigurationsdaten importiert: {config_import_file}"])
                else:
                    self.set_status("Config import file is not string", True)  # state not possible
            case EConfigSelection.EXPORT:
                l_title = ["Export user configuration file", "Benutzer Konfigurationsdatei exportieren"]
                config_export_file = save_file(parent=self, title=self.model.c_language.get_language_text(l_title),
                                               directory=f"{self.model.get_last_path()}/{S_USER_FILE}",
                                               filetypes=INI_FILE_TYPES)
                if config_export_file:
                    self.model.set_last_path(os.path.dirname(config_export_file))
                    write_config_to_file(config_export_file, self.model.c_config.d_user)
                    self.set_status([f"User configuration exported: {config_export_file}",
                                     f"Benutzer Konfigurationsdaten exportiert: {config_export_file}"])
            case _:
                self.set_status(f"Invalid user menu: {e_config_selection}", True)  # state not possible
 
    def edit_user_in_notepad(self, s_file_name: str) -> None:
        """!
        @brief Open user file in notepad.
        @param s_file_name : file name to open in notepad
        """
        self.model.notepad_worker.open_report_file(s_file_name, ENotepadSelection.USER, lambda: self.model.c_config.read_user_file(s_file_name, True))
 
    def btn_change_item(self, e_config_selection: EConfigSelection) -> None:
        """!
        @brief Handle change articles configuration.
        @param e_config_selection : mode of articles change (edit/import/export/reset)
        """
        match e_config_selection:
            case EConfigSelection.RESET | EConfigSelection.EDIT:
                if e_config_selection == EConfigSelection.RESET:
                    s_deposit_name = None
                    d_articles_dict = get_default_item_config(s_deposit_name)
                    b_reset = self.confirm_dialog(["Reset articles", "Artikel zurücksetzen"], s_icon_path=ICON_ARTICLES_RESET_LIGHT)
                else:
                    d_articles_dict = self.model.c_config.d_item
                    b_reset = True
                if b_reset:
                    write_config_to_file(S_ITEM_TEMP_FILE, d_articles_dict)
                    self.block_ui()
                    self.edit_items_in_notepad(S_ITEM_TEMP_FILE)
            case EConfigSelection.IMPORT:
                l_title = ["Select article configuration file to import", "Wähle eine Artikel Konfigurationsdatei zum importieren"]
                config_import_file = open_file(parent=self, title=self.model.c_language.get_language_text(l_title),
                                               directory=self.model.get_last_path(), filetypes=INI_FILE_TYPES)
                if isinstance(config_import_file, str):
                    if config_import_file:
                        self.model.set_last_path(os.path.dirname(config_import_file))
                        b_imported = self.model.c_config.read_item_file(config_import_file)
                        if b_imported:
                            self.set_status([f"Articles configuration imported: {config_import_file}",
                                             f"Artikel Konfigurationsdaten importiert: {config_import_file}"])
                else:
                    self.set_status("Config import file is not string", True)  # state not possible
            case EConfigSelection.EXPORT:
                l_title = ["Export article configuration file", "Artikel Konfigurationsdatei exportieren"]
                config_export_file = save_file(parent=self, title=self.model.c_language.get_language_text(l_title),
                                               directory=f"{self.model.get_last_path()}/{S_ITEM_FILE}",
                                               filetypes=INI_FILE_TYPES)
                if config_export_file:
                    self.model.set_last_path(os.path.dirname(config_export_file))
                    write_config_to_file(config_export_file, self.model.c_config.d_item)
                    self.set_status([f"Articles configuration exported: {config_export_file}",
                                     f"Artikel Konfigurationsdaten exportiert: {config_export_file}"])
            case EConfigSelection.PDF_IMPORT:
                pass
            case _:
                self.set_status(f"Invalid articles menu: {e_config_selection}", True)  # state not possible
 
    def edit_items_in_notepad(self, s_file_name: str) -> None:
        """!
        @brief Open item file in notepad.
        @param s_file_name : file name to open in notepad
        """
        self.model.notepad_worker.open_report_file(s_file_name, ENotepadSelection.ARTICLES, lambda: self.model.c_config.read_item_file(s_file_name, True))
 
    def btn_open_folder(self) -> None:
        """!
        @brief Handle Open output folder.
        """
        path = self.model.s_output_path
        if os.path.exists(path):
            log.debug("Open Folder: %s", path)
            self.set_status([f"Open Folder: {path}", f"Öffne Ordner: {path}"])
            with subprocess.Popen("explorer " + path.replace("/", "\\")):
                pass
        else:
            self.set_status([f"Folder not exist: {path}", f"Ordner existiert nicht: {path}"], True)
 
    def btn_combine_manual(self) -> None:
        """!
        @brief Combine Reports manual to create single report from multiple other data.
        """
        l_title = ["Select report files to combine", "Wähle Berichte zum kombinieren"]
        l_select_files = open_file(parent=self, title=self.model.c_language.get_language_text(l_title),
                                   directory=self.model.get_last_path(), filetypes=LOG_FILE_TYPES,
                                   multiple=True)
        if isinstance(l_select_files, list):
            if l_select_files:
                self.model.set_last_path(os.path.dirname(l_select_files[0]))
                self.model.c_report.create_report(l_files=l_select_files, b_combine=True, b_clear_report=False,
                                                  s_path=self.model.get_last_path(), b_open_folder=True)
        else:
            self.set_status("Combine files are not list", True)  # state not possible
 
    def btn_combine_auto(self) -> None:
        """!
        @brief Combine Reports manual to create single report from multiple other data.
        """
        l_title = ["Select directory to combine", "Wähle ein Verzeichnis zum kombinieren"]
        directory = open_directory(parent=self, title=self.model.c_language.get_language_text(l_title), directory=self.model.get_last_path())
        if directory:
            self.model.set_last_path(directory)
            l_files = []
 
            for root, _dirs, files in os.walk(directory):
                for file in files:
                    if file.endswith(".csv"):
                        l_files.append(os.path.join(root, file))
 
            if l_files:
                self.model.c_report.create_report(l_files=l_files, b_combine=True, b_clear_report=False,
                                                  s_path=self.model.get_last_path(), b_open_folder=True)
            else:
                self.set_status(["No CSV files found", "Keine CSV Dateien gefunden"])
 
    def btn_print_file(self) -> None:
        """!
        @brief Select and print markdown file from directory.
        """
        if self.model.c_printer.s_select_com_port is not None:
            l_title = ["Select file to print", "Datei zum Drucken auswählen"]
            select_file = open_file(parent=self, title=self.model.c_language.get_language_text(l_title),
                                    directory=self.model.get_last_path(), filetypes=REPORT_FILE_TYPES)
            if isinstance(select_file, str):
                if select_file:
                    with open(select_file, mode="r", encoding="utf-8") as file:
                        text = file.read()
                        self.model.c_printer.add_to_report(text)
                        self.set_status([f"Print file: {select_file}", f"Datei wird gedruckt: {select_file}"])
            else:
                self.set_status("Print file is not string", True)  # state not possible
        else:
            self.set_status(["File cannot be printed. Printer not available.",
                             "Datei kann nicht gedruckt werden. Drucker nicht verfügbar."], b_warning=True)
 
    def btn_article_preview(self) -> None:
        """!
        @brief Article Print Preview
        """
        self.block_ui()
        l_preview_text = []
        i_break_line = int(self.model.c_printer.i_line_break / 2)
        line_text = "Name".ljust(i_break_line) + "   | Group |  Price "
        line_text += "| Cut"
        l_preview_text.append(line_text)
        line_text = "-" * (i_break_line + 50)
        l_preview_text.append(line_text)
 
        for i_item_pos in range(I_ITEM_ARRAY_SIZE):
            i_item_number = i_item_pos + 1
            name = self.model.c_config.get_item_name(i_item_number)
            b_show = True
            if name != "" and b_show:
                group = self.model.c_config.get_item_group(i_item_number)
                f_item_price = self.model.c_config.get_item_price(i_item_number)
                s_item_price = f"{f_item_price:.2f} {S_UNIT_SYMBOL}"
                s_item_price = s_item_price.rjust(8)
                line_text = f"{name.ljust(i_break_line)[:i_break_line]}"
                line_text += f"   |   {group}"
                line_text += f"   |{s_item_price}"
                line_text += f"| {name[i_break_line:]}"
                l_preview_text.append(line_text)
 
        preview_text = '\n'.join(l_preview_text)
        show_report_dialog(self, report_text=preview_text)
        self.unblock_ui()
 
    def change_output_path(self) -> None:
        """!
        @brief Handle change output path.
        """
        l_title = ["Set output path", "Wähle ein Ausgabeverzeichnis"]
        s_path = open_directory(parent=self, title=self.model.c_language.get_language_text(l_title), directory=self.model.s_output_path)
        if s_path:  # if not canceled
            self.model.set_last_path(s_path)
            self.model.update_output_path(s_path)
 
    def reset_config(self) -> None:
        """!
        @brief Handle reset configuration.
        """
        log.debug("Reset clicked")
        b_reset, ok = reset_config_dialog(self)
        if b_reset:
            self.close_window_dialog = False
            close_app(self)
        elif ok:
            self.set_status(["Invalid Password", "Passwort ungültig"])