VRCT/VRCT.py

from time import sleep
from os import path as os_path
from requests import get as requests_get
from queue import Queue
import customtkinter
from customtkinter import CTk, CTkFrame, CTkCheckBox, CTkFont, CTkButton, CTkImage, CTkTabview, CTkTextbox, CTkEntry
from PIL.Image import open as Image_open
from flashtext import KeywordProcessor

from threading import Thread
from utils import print_textbox, thread_fnc, get_localized_text, widget_main_window_label_setter
from osc_tools import send_typing, send_message, send_test_action, receive_osc_parameters
from window_config import ToplevelWindowConfig
from window_information import ToplevelWindowInformation
from languages import transcription_lang
from audio_utils import get_input_device_list, get_output_device_list
from audio_recorder import SelectedMicRecorder, SelectedSpeakerRecorder
from audio_transcriber import AudioTranscriber
from translation import Translator
from config import config
from notification import notification_xsoverlay_for_vrct

__version__ = "1.3.2"

class App(CTk):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

        # init instance
        self.translator = Translator()
        self.keyword_processor = KeywordProcessor()

        ## set UI theme
        customtkinter.set_appearance_mode(config.APPEARANCE_THEME)
        customtkinter.set_default_color_theme("blue")

        # init main window
        self.iconbitmap(os_path.join(os_path.dirname(__file__), "img", "app.ico"))
        self.title("VRCT")
        self.geometry(f"{400}x{175}")
        self.minsize(400, 175)
        self.grid_columnconfigure(1, weight=1)
        self.grid_rowconfigure(0, weight=1)
        self.wm_attributes("-alpha", config.TRANSPARENCY/100)
        customtkinter.set_widget_scaling(int(config.UI_SCALING.replace("%", "")) / 100)
        self.protocol("WM_DELETE_WINDOW", self.delete_window)

        # add sidebar
        self.add_sidebar()

        # add entry message box
        self.entry_message_box = CTkEntry(
            self,
            placeholder_text="message",
            font=CTkFont(family=config.FONT_FAMILY),
        )
        self.entry_message_box.grid(row=1, column=1, columnspan=2, padx=5, pady=(5, 10), sticky="nsew")
        self.entry_message_box.bind("<Return>", self.entry_message_box_press_key_enter)
        self.entry_message_box.bind("<Any-KeyPress>", self.entry_message_box_press_key_any)
        self.entry_message_box.bind("<Leave>", self.entry_message_box_leave)

        # add tabview textbox
        self.add_tabview_logs(get_localized_text(f"{config.UI_LANGUAGE}"))

        self.config_window = ToplevelWindowConfig(self)
        self.information_window = ToplevelWindowInformation(self)
        self.init_process()

    def init_process(self):
        # set translator
        if self.translator.authentication(config.CHOICE_TRANSLATOR, config.AUTH_KEYS[config.CHOICE_TRANSLATOR]) is False:
            # error update Auth key
            print_textbox(self.textbox_message_log, "Auth Key or language setting is incorrect", "ERROR")
            print_textbox(self.textbox_message_system_log, "Auth Key or language setting is incorrect", "ERROR")

        # set word filter
        for f in config.INPUT_MIC_WORD_FILTER:
            self.keyword_processor.add_keyword(f)

        # start receive osc
        th_receive_osc_parameters = Thread(target=receive_osc_parameters, args=(self.check_osc_receive,))
        th_receive_osc_parameters.daemon = True
        th_receive_osc_parameters.start()

        # check osc started
        send_test_action()

        # check update
        response = requests_get(config.GITHUB_URL)
        tag_name = response.json()["tag_name"]
        if tag_name != __version__:
            config.UPDATE_FLAG = True

    def button_config_callback(self):
        self.foreground_stop()
        self.transcription_stop()
        self.checkbox_translation.configure(state="disabled")
        self.checkbox_transcription_send.configure(state="disabled")
        self.checkbox_transcription_receive.configure(state="disabled")
        self.checkbox_foreground.configure(state="disabled")
        self.tabview_logs.configure(state="disabled")
        self.textbox_message_log.configure(state="disabled")
        self.textbox_message_send_log.configure(state="disabled")
        self.textbox_message_receive_log.configure(state="disabled")
        self.textbox_message_system_log.configure(state="disabled")
        self.entry_message_box.configure(state="disabled")
        self.button_config.configure(state="disabled", fg_color=["gray92", "gray14"])
        self.button_information.configure(state="disabled", fg_color=["gray92", "gray14"])
        self.config_window.deiconify()
        self.config_window.focus_set()
        self.config_window.focus()
        self.config_window.grab_set()

    def button_information_callback(self):
        self.information_window.deiconify()
        self.information_window.focus_set()
        self.information_window.focus()

    def checkbox_translation_callback(self):
        if self.checkbox_translation.get() is True:
            print_textbox(self.textbox_message_log, "Start translation", "INFO")
            print_textbox(self.textbox_message_system_log, "Start translation", "INFO")
        else:
            print_textbox(self.textbox_message_log, "Stop translation", "INFO")
            print_textbox(self.textbox_message_system_log, "Stop translation", "INFO")

    def transcription_send_start(self):
        self.mic_audio_queue = Queue()
        mic_device = [device for device in get_input_device_list()[config.CHOICE_MIC_HOST] if device["name"] == config.CHOICE_MIC_DEVICE][0]
        self.mic_audio_recorder = SelectedMicRecorder(
            mic_device,
            config.INPUT_MIC_ENERGY_THRESHOLD,
            config.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD,
            config.INPUT_MIC_RECORD_TIMEOUT,
        )
        self.mic_audio_recorder.record_into_queue(self.mic_audio_queue)
        self.mic_transcriber = AudioTranscriber(
            speaker=False,
            source=self.mic_audio_recorder.source,
            phrase_timeout=config.INPUT_MIC_PHRASE_TIMEOUT,
            max_phrases=config.INPUT_MIC_MAX_PHRASES,
        )
        def mic_transcript_to_chatbox():
            self.mic_transcriber.transcribe_audio_queue(self.mic_audio_queue, transcription_lang[config.INPUT_MIC_VOICE_LANGUAGE])
            message = self.mic_transcriber.get_transcript()
            if len(message) > 0:
                # word filter
                if len(self.keyword_processor.extract_keywords(message)) != 0:
                    print_textbox(self.textbox_message_log, f"Detect WordFilter :{message}", "INFO")
                    print_textbox(self.textbox_message_system_log, f"Detect WordFilter :{message}", "INFO")
                    return

                # translate
                if self.checkbox_translation.get() is False:
                    voice_message = f"{message}"
                elif self.translator.translator_status[config.CHOICE_TRANSLATOR] is False:
                    print_textbox(self.textbox_message_log,  "Auth Key or language setting is incorrect", "ERROR")
                    print_textbox(self.textbox_message_system_log, "Auth Key or language setting is incorrect", "ERROR")
                    voice_message = f"{message}"
                else:
                    result = self.translator.translate(
                        translator_name=config.CHOICE_TRANSLATOR,
                        source_language=config.INPUT_SOURCE_LANG,
                        target_language=config.INPUT_TARGET_LANG,
                        message=message
                    )
                    voice_message = config.MESSAGE_FORMAT.replace("[message]", message).replace("[translation]", result)

                if self.checkbox_transcription_send.get() is True:
                    if config.ENABLE_OSC is True:
                        # send OSC message
                        send_message(voice_message, config.OSC_IP_ADDRESS, config.OSC_PORT)
                    else:
                        print_textbox(self.textbox_message_log, "OSC is not enabled, please enable OSC and rejoin.", "ERROR")
                        print_textbox(self.textbox_message_system_log, "OSC is not enabled, please enable OSC and rejoin.", "ERROR")
                    # update textbox message log
                    print_textbox(self.textbox_message_log,  f"{voice_message}", "SEND")
                    print_textbox(self.textbox_message_send_log, f"{voice_message}", "SEND")

        self.mic_print_transcript = thread_fnc(mic_transcript_to_chatbox)
        self.mic_print_transcript.daemon = True
        self.mic_print_transcript.start()
        print_textbox(self.textbox_message_log, "Start voice2chatbox", "INFO")
        print_textbox(self.textbox_message_system_log, "Start voice2chatbox", "INFO")
        self.checkbox_transcription_send.configure(state="normal")
        self.checkbox_transcription_receive.configure(state="normal")
        self.button_config.configure(state="normal", fg_color=["#3B8ED0", "#1F6AA5"])

    def transcription_send_stop(self):
        if isinstance(self.mic_print_transcript, thread_fnc):
            self.mic_print_transcript.stop()
        if self.mic_audio_recorder.stop != None:
            self.mic_audio_recorder.stop()
            self.mic_audio_recorder.stop = None

        print_textbox(self.textbox_message_log, "Stop voice2chatbox", "INFO")
        print_textbox(self.textbox_message_system_log, "Stop voice2chatbox", "INFO")
        self.checkbox_transcription_send.configure(state="normal")
        self.checkbox_transcription_receive.configure(state="normal")
        self.button_config.configure(state="normal", fg_color=["#3B8ED0", "#1F6AA5"])

    def transcription_send_stop_for_config(self):
        if isinstance(self.mic_print_transcript, thread_fnc):
            self.mic_print_transcript.stop()
        if self.mic_audio_recorder.stop != None:
            self.mic_audio_recorder.stop()
            self.mic_audio_recorder.stop = None

        print_textbox(self.textbox_message_log, "Stop voice2chatbox", "INFO")
        print_textbox(self.textbox_message_system_log, "Stop voice2chatbox", "INFO")

    def checkbox_transcription_send_callback(self):
        self.checkbox_transcription_send.configure(state="disabled")
        self.checkbox_transcription_receive.configure(state="disabled")
        self.button_config.configure(state="disabled", fg_color=["gray92", "gray14"])
        if self.checkbox_transcription_send.get() is True:
            th_transcription_send_start = Thread(target=self.transcription_send_start)
            th_transcription_send_start.daemon = True
            th_transcription_send_start.start()
        else:
            th_transcription_send_stop = Thread(target=self.transcription_send_stop)
            th_transcription_send_stop.daemon = True
            th_transcription_send_stop.start()

    def transcription_receive_start(self):
        self.spk_audio_queue = Queue()
        spk_device = [device for device in get_output_device_list() if device["name"] == config.CHOICE_SPEAKER_DEVICE][0]
        self.spk_audio_recorder = SelectedSpeakerRecorder(
            spk_device,
            config.INPUT_SPEAKER_ENERGY_THRESHOLD,
            config.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD,
            config.INPUT_SPEAKER_RECORD_TIMEOUT,
        )
        self.spk_audio_recorder.record_into_queue(self.spk_audio_queue)
        self.spk_transcriber = AudioTranscriber(
            speaker=True,
            source=self.spk_audio_recorder.source,
            phrase_timeout=config.INPUT_SPEAKER_PHRASE_TIMEOUT,
            max_phrases=config.INPUT_SPEAKER_MAX_PHRASES,
        )

        def spk_transcript_to_textbox():
            self.spk_transcriber.transcribe_audio_queue(self.spk_audio_queue, transcription_lang[config.INPUT_SPEAKER_VOICE_LANGUAGE])
            message = self.spk_transcriber.get_transcript()
            if len(message) > 0:
                # translate
                if self.checkbox_translation.get() is False:
                    voice_message = f"{message}"
                elif self.translator.translator_status[config.CHOICE_TRANSLATOR] is False:
                    print_textbox(self.textbox_message_log, "Auth Key or language setting is incorrect", "ERROR")
                    print_textbox(self.textbox_message_system_log, "Auth Key or language setting is incorrect", "ERROR")
                    voice_message = f"{message}"
                else:
                    result = self.translator.translate(
                        translator_name=config.CHOICE_TRANSLATOR,
                        source_language=config.OUTPUT_SOURCE_LANG,
                        target_language=config.OUTPUT_TARGET_LANG,
                        message=message
                    )
                    voice_message = config.MESSAGE_FORMAT.replace("[message]", message).replace("[translation]", result)
                # send OSC message
                # send_message(voice_message, config.OSC_IP_ADDRESS, self.OSC_PORT)

                if self.checkbox_transcription_receive.get() is True:
                    # update textbox message receive log
                    print_textbox(self.textbox_message_log,  f"{voice_message}", "RECEIVE")
                    print_textbox(self.textbox_message_receive_log, f"{voice_message}", "RECEIVE")
                    if config.ENABLE_NOTICE_XSOVERLAY is True:
                        notification_xsoverlay_for_vrct(content=f"{voice_message}")

        self.spk_print_transcript = thread_fnc(spk_transcript_to_textbox)
        self.spk_print_transcript.daemon = True
        self.spk_print_transcript.start()
        print_textbox(self.textbox_message_log,  "Start speaker2log", "INFO")
        print_textbox(self.textbox_message_system_log, "Start speaker2log", "INFO")
        self.checkbox_transcription_send.configure(state="normal")
        self.checkbox_transcription_receive.configure(state="normal")
        self.button_config.configure(state="normal", fg_color=["#3B8ED0", "#1F6AA5"])

    def transcription_receive_stop(self):
        if isinstance(self.spk_print_transcript, thread_fnc):
            self.spk_print_transcript.stop()
        if self.spk_audio_recorder.stop != None:
            self.spk_audio_recorder.stop()
            self.spk_audio_recorder.stop = None

        print_textbox(self.textbox_message_log,  "Stop speaker2log", "INFO")
        print_textbox(self.textbox_message_system_log, "Stop speaker2log", "INFO")
        self.checkbox_transcription_send.configure(state="normal")
        self.checkbox_transcription_receive.configure(state="normal")
        self.button_config.configure(state="normal", fg_color=["#3B8ED0", "#1F6AA5"])

    def transcription_receive_stop_for_config(self):
        if isinstance(self.spk_print_transcript, thread_fnc):
            self.spk_print_transcript.stop()
        if self.spk_audio_recorder.stop != None:
            self.spk_audio_recorder.stop()
            self.spk_audio_recorder.stop = None

        print_textbox(self.textbox_message_log,  "Stop speaker2log", "INFO")
        print_textbox(self.textbox_message_system_log, "Stop speaker2log", "INFO")

    def checkbox_transcription_receive_callback(self):
        self.checkbox_transcription_send.configure(state="disabled")
        self.checkbox_transcription_receive.configure(state="disabled")
        self.button_config.configure(state="disabled", fg_color=["gray92", "gray14"])
        if self.checkbox_transcription_receive.get() is True:
            th_transcription_receive_start = Thread(target=self.transcription_receive_start)
            th_transcription_receive_start.daemon = True
            th_transcription_receive_start.start()
        else:
            th_transcription_receive_stop = Thread(target=self.transcription_receive_stop)
            th_transcription_receive_stop.daemon = True
            th_transcription_receive_stop.start()

    def transcription_start(self):
        if self.checkbox_transcription_send.get() is True:
            th_transcription_send_start = Thread(target=self.transcription_send_start)
            th_transcription_send_start.daemon = True
            th_transcription_send_start.start()
            sleep(2)
        if self.checkbox_transcription_receive.get() is True:
            th_transcription_receive_start = Thread(target=self.transcription_receive_start)
            th_transcription_receive_start.daemon = True
            th_transcription_receive_start.start()

    def transcription_stop(self):
        if self.checkbox_transcription_send.get() is True:
            th_transcription_send_stop = Thread(target=self.transcription_send_stop_for_config)
            th_transcription_send_stop.daemon = True
            th_transcription_send_stop.start()
        if self.checkbox_transcription_receive.get() is True:
            th_transcription_receive_stop = Thread(target=self.transcription_receive_stop_for_config)
            th_transcription_receive_stop.daemon = True
            th_transcription_receive_stop.start()

    def checkbox_foreground_callback(self):
        if self.checkbox_foreground.get():
            self.attributes("-topmost", True)
            print_textbox(self.textbox_message_log,  "Start foreground", "INFO")
            print_textbox(self.textbox_message_system_log, "Start foreground", "INFO")
        else:
            self.attributes("-topmost", False)
            print_textbox(self.textbox_message_log,  "Stop foreground", "INFO")
            print_textbox(self.textbox_message_system_log, "Stop foreground", "INFO")

    def foreground_start(self):
        if self.checkbox_foreground.get():
            self.attributes("-topmost", True)
            print_textbox(self.textbox_message_log,  "Start foreground", "INFO")
            print_textbox(self.textbox_message_system_log, "Start foreground", "INFO")

    def foreground_stop(self):
        if self.checkbox_foreground.get():
            self.attributes("-topmost", False)
            print_textbox(self.textbox_message_log,  "Stop foreground", "INFO")
            print_textbox(self.textbox_message_system_log, "Stop foreground", "INFO")

    def entry_message_box_press_key_enter(self, event):
        # send OSC typing
        send_typing(False, config.OSC_IP_ADDRESS, config.OSC_PORT)

        if self.checkbox_foreground.get():
            self.attributes("-topmost", True)

        message = self.entry_message_box.get()
        if len(message) > 0:
            # translate
            if self.checkbox_translation.get() is False:
                chat_message = f"{message}"
            elif self.translator.translator_status[config.CHOICE_TRANSLATOR] is False:
                print_textbox(self.textbox_message_log,  "Auth Key or language setting is incorrect", "ERROR")
                print_textbox(self.textbox_message_system_log, "Auth Key or language setting is incorrect", "ERROR")
                chat_message = f"{message}"
            else:
                result = self.translator.translate(
                    translator_name=config.CHOICE_TRANSLATOR,
                    source_language=config.INPUT_SOURCE_LANG,
                    target_language=config.INPUT_TARGET_LANG,
                    message=message
                )
                chat_message = config.MESSAGE_FORMAT.replace("[message]", message).replace("[translation]", result)

            # send OSC message
            if config.ENABLE_OSC is True:
                send_message(chat_message, config.OSC_IP_ADDRESS, config.OSC_PORT)
            else:
                print_textbox(self.textbox_message_log, "OSC is not enabled, please enable OSC and rejoin.", "ERROR")
                print_textbox(self.textbox_message_system_log, "OSC is not enabled, please enable OSC and rejoin.", "ERROR")

            # update textbox message log
            print_textbox(self.textbox_message_log,  f"{chat_message}", "SEND")
            print_textbox(self.textbox_message_send_log, f"{chat_message}", "SEND")

            # delete message in entry message box
            if config.ENABLE_AUTO_CLEAR_CHATBOX is True:
                self.entry_message_box.delete(0, customtkinter.END)

    BREAK_KEYSYM_LIST = [
        "Delete", "Select", "Up", "Down", "Next", "End", "Print",
        "Prior","Insert","Home", "Left", "Clear", "Right", "Linefeed"
    ]
    def entry_message_box_press_key_any(self, event):
        # send OSC typing
        send_typing(True, config.OSC_IP_ADDRESS, config.OSC_PORT)
        if self.checkbox_foreground.get():
            self.attributes("-topmost", False)

        if event.keysym != "??":
            if len(event.char) != 0 and event.keysym in self.BREAK_KEYSYM_LIST:
                self.entry_message_box.insert("end", event.char)
                return "break"

    def entry_message_box_leave(self, event):
        # send OSC typing
        send_typing(False, config.OSC_IP_ADDRESS, config.OSC_PORT)
        if self.checkbox_foreground.get():
            self.attributes("-topmost", True)

    def delete_window(self):
        self.quit()
        self.destroy()

    def add_sidebar(self):
        init_lang_text = "Loading..."
        self.sidebar_frame = CTkFrame(master=self, corner_radius=0)

        # add checkbox translation
        self.checkbox_translation = CTkCheckBox(
            self.sidebar_frame,
            text=init_lang_text,
            onvalue=True,
            offvalue=False,
            command=self.checkbox_translation_callback,
            font=CTkFont(family=config.FONT_FAMILY)
        )

        # add checkbox transcription send
        self.checkbox_transcription_send = CTkCheckBox(
            self.sidebar_frame,
            text=init_lang_text,
            onvalue=True,
            offvalue=False,
            command=self.checkbox_transcription_send_callback,
            font=CTkFont(family=config.FONT_FAMILY)
        )

        # add checkbox transcription receive
        self.checkbox_transcription_receive = CTkCheckBox(
            self.sidebar_frame,
            text=init_lang_text,
            onvalue=True,
            offvalue=False,
            command=self.checkbox_transcription_receive_callback,
            font=CTkFont(family=config.FONT_FAMILY)
        )

        # add checkbox foreground
        self.checkbox_foreground = CTkCheckBox(
            self.sidebar_frame,
            text=init_lang_text,
            onvalue=True,
            offvalue=False,
            command=self.checkbox_foreground_callback,
            font=CTkFont(family=config.FONT_FAMILY)
        )

        # add button information
        self.button_information = CTkButton(
            self.sidebar_frame,
            text=None,
            width=36,
            command=self.button_information_callback,
            image=CTkImage(Image_open(os_path.join(os_path.dirname(__file__), "img", "info-icon-white.png")))
        )

        # add button config
        self.button_config = CTkButton(
            self.sidebar_frame,
            text=None,
            width=36,
            command=self.button_config_callback,
            image=CTkImage(Image_open(os_path.join(os_path.dirname(__file__), "img", "config-icon-white.png")))
        )

        self.sidebar_frame.grid(row=0, column=0, rowspan=4, sticky="nsw")
        self.sidebar_frame.grid_rowconfigure(5, weight=1)
        self.checkbox_translation.grid(row=0, column=0, columnspan=2, padx=10, pady=(5, 5), sticky="we")
        self.checkbox_transcription_send.grid(row=1, column=0, columnspan=2, padx=10, pady=(5, 5), sticky="we")
        self.checkbox_transcription_receive.grid(row=2, column=0, columnspan=2, padx=10, pady=(5, 5), sticky="we")
        self.checkbox_foreground.grid(row=3, column=0, columnspan=2, padx=10, pady=(5, 5), sticky="we")
        self.button_information.grid(row=5, column=0, padx=(10, 5), pady=(5, 5), sticky="wse")
        self.button_config.grid(row=5, column=1, padx=(5, 10), pady=(5, 5), sticky="wse")

    def delete_tabview_logs(self, pre_language_yaml_data):
        self.tabview_logs.delete(pre_language_yaml_data["main_tab_title_log"])
        self.tabview_logs.delete(pre_language_yaml_data["main_tab_title_send"])
        self.tabview_logs.delete(pre_language_yaml_data["main_tab_title_receive"])
        self.tabview_logs.delete(pre_language_yaml_data["main_tab_title_system"])

    def add_tabview_logs(self, language_yaml_data):
        main_tab_title_log = language_yaml_data["main_tab_title_log"]
        main_tab_title_send = language_yaml_data["main_tab_title_send"]
        main_tab_title_receive = language_yaml_data["main_tab_title_receive"]
        main_tab_title_system = language_yaml_data["main_tab_title_system"]

        # add tabview textbox
        self.tabview_logs = CTkTabview(master=self)
        self.tabview_logs.add(main_tab_title_log)
        self.tabview_logs.add(main_tab_title_send)
        self.tabview_logs.add(main_tab_title_receive)
        self.tabview_logs.add(main_tab_title_system)
        self.tabview_logs.grid(row=0, column=1, padx=0, pady=0, sticky="nsew")
        self.tabview_logs._segmented_button.configure(font=CTkFont(family=config.FONT_FAMILY))
        self.tabview_logs._segmented_button.grid(sticky="W")
        self.tabview_logs.tab(main_tab_title_log).grid_rowconfigure(0, weight=1)
        self.tabview_logs.tab(main_tab_title_log).grid_columnconfigure(0, weight=1)
        self.tabview_logs.tab(main_tab_title_send).grid_rowconfigure(0, weight=1)
        self.tabview_logs.tab(main_tab_title_send).grid_columnconfigure(0, weight=1)
        self.tabview_logs.tab(main_tab_title_receive).grid_rowconfigure(0, weight=1)
        self.tabview_logs.tab(main_tab_title_receive).grid_columnconfigure(0, weight=1)
        self.tabview_logs.tab(main_tab_title_system).grid_rowconfigure(0, weight=1)
        self.tabview_logs.tab(main_tab_title_system).grid_columnconfigure(0, weight=1)
        self.tabview_logs.configure(fg_color="transparent")

        # add textbox message log
        self.textbox_message_log = CTkTextbox(
            self.tabview_logs.tab(main_tab_title_log),
            font=CTkFont(family=config.FONT_FAMILY)
        )

        # add textbox message send log
        self.textbox_message_send_log = CTkTextbox(
            self.tabview_logs.tab(main_tab_title_send),
            font=CTkFont(family=config.FONT_FAMILY)
        )

        # add textbox message receive log
        self.textbox_message_receive_log = CTkTextbox(
            self.tabview_logs.tab(main_tab_title_receive),
            font=CTkFont(family=config.FONT_FAMILY)
        )

        # add textbox message system log
        self.textbox_message_system_log = CTkTextbox(
            self.tabview_logs.tab(main_tab_title_system),
            font=CTkFont(family=config.FONT_FAMILY)
        )

        self.textbox_message_log.grid(row=0, column=0, padx=0, pady=0, sticky="nsew")
        self.textbox_message_send_log.grid(row=0, column=0, padx=0, pady=0, sticky="nsew")
        self.textbox_message_receive_log.grid(row=0, column=0, padx=0, pady=0, sticky="nsew")
        self.textbox_message_system_log.grid(row=0, column=0, padx=0, pady=0, sticky="nsew")
        self.textbox_message_log.configure(state='disabled')
        self.textbox_message_send_log.configure(state='disabled')
        self.textbox_message_receive_log.configure(state='disabled')
        self.textbox_message_system_log.configure(state='disabled')

        widget_main_window_label_setter(self, language_yaml_data)

    def check_osc_receive(self, address, osc_arguments):
        print(address, osc_arguments)
        if config.ENABLE_OSC is False:
            config.ENABLE_OSC = True

if __name__ == "__main__":
    try:
        app = App()
        app.mainloop()
    except Exception as e:
        import traceback
        with open('error.log', 'a') as f:
            traceback.print_exc(file=f)