VRCT/src-python/webui_controller.py

from typing import Callable, Union
from time import sleep
from subprocess import Popen
from threading import Thread
from config import config
from model import model
# from view import view
from utils import getKeyByValue, isUniqueStrings, strPctToInt
import argparse

# Common
def callbackUpdateSoftware(func=None):
    setMainWindowGeometry()
    model.updateSoftware(restart=True, func=func)

def callbackRestartSoftware():
    setMainWindowGeometry()
    model.reStartSoftware()

def callbackFilepathLogs():
    print("[LOG]", "callbackFilepathLogs", config.PATH_LOGS.replace('/', '\\'))
    Popen(['explorer', config.PATH_LOGS.replace('/', '\\')], shell=True)
    return "Success", 200

def callbackFilepathConfigFile():
    print("[LOG]","callbackFilepathConfigFile", config.PATH_LOCAL.replace('/', '\\'))
    Popen(['explorer', config.PATH_LOCAL.replace('/', '\\')], shell=True)
    return "Success", 200

def callbackQuitVrct():
    setMainWindowGeometry()

def callbackEnableEasterEgg():
    config.IS_EASTER_EGG_ENABLED = True
    config.OVERLAY_UI_TYPE = "sakura"
    # view.printToTextbox_enableEasterEgg()

def setMainWindowGeometry():
    # PRE_SCALING_INT = strPctToInt(view.getPreUiScaling())
    # NEW_SCALING_INT = strPctToInt(config.UI_SCALING)
    # MULTIPLY_FLOAT = (NEW_SCALING_INT / PRE_SCALING_INT)
    # main_window_geometry = view.getMainWindowGeometry(return_int=True)
    # main_window_geometry["width"] = str(int(main_window_geometry["width"] * MULTIPLY_FLOAT))
    # main_window_geometry["height"] = str(int(main_window_geometry["height"] * MULTIPLY_FLOAT))
    # main_window_geometry["x_pos"] = str(main_window_geometry["x_pos"])
    # main_window_geometry["y_pos"] = str(main_window_geometry["y_pos"])
    # config.MAIN_WINDOW_GEOMETRY = main_window_geometry
    pass

def messageFormatter(format_type:str, translation, message):
    if format_type == "RECEIVED":
        FORMAT_WITH_T = config.RECEIVED_MESSAGE_FORMAT_WITH_T
        FORMAT = config.RECEIVED_MESSAGE_FORMAT
    elif format_type == "SEND":
        FORMAT_WITH_T = config.SEND_MESSAGE_FORMAT_WITH_T
        FORMAT = config.SEND_MESSAGE_FORMAT
    else:
        raise ValueError("format_type is not found", format_type)

    if len(translation) > 0:
        osc_message = FORMAT_WITH_T.replace("[message]", message)
        osc_message = osc_message.replace("[translation]", translation)
    else:
        osc_message = FORMAT.replace("[message]", message)
    return osc_message

def changeToCTranslate2Process():
    if config.CHOICE_INPUT_TRANSLATOR != "CTranslate2" or config.CHOICE_OUTPUT_TRANSLATOR != "CTranslate2":
        config.CHOICE_INPUT_TRANSLATOR = "CTranslate2"
        config.CHOICE_OUTPUT_TRANSLATOR = "CTranslate2"
        updateTranslationEngineAndEngineList()
        # view.printToTextbox_TranslationEngineLimitError()

# func transcription send message
class MicMessage:
    def __init__(self, action:Callable[[dict], None]) -> None:
        self.action = action

    def send(self, message: Union[str, bool]) -> None:
        if isinstance(message, bool) and message is False:
            self.action({"status":"error", "message":"No mic device detected."})
        elif isinstance(message, str) and len(message) > 0:
            addSentMessageLog(message)
            translation = ""
            if model.checkKeywords(message):
                self.action("mic", {"status":"error", "message":f"Detected by word filter:{message}"})
                return
            elif model.detectRepeatSendMessage(message):
                return
            elif config.ENABLE_TRANSLATION is False:
                pass
            else:
                translation, success = model.getInputTranslate(message)
                if success is False:
                    changeToCTranslate2Process()

            if config.ENABLE_TRANSCRIPTION_SEND is True:
                if config.ENABLE_SEND_MESSAGE_TO_VRC is True:
                    if config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES is True:
                        if config.ENABLE_TRANSLATION is False:
                            osc_message = messageFormatter("SEND", "", message)
                        else:
                            osc_message = messageFormatter("SEND", "", translation)
                    else:
                        osc_message = messageFormatter("SEND", translation, message)
                    model.oscSendMessage(osc_message)

                self.action("mic", {"status":"success", "message":message, "translation":translation})
                if config.ENABLE_LOGGER is True:
                    if len(translation) > 0:
                        translation = f" ({translation})"
                    model.logger.info(f"[SENT] {message}{translation}")

                # if config.ENABLE_OVERLAY_SMALL_LOG is True:
                #     overlay_image = model.createOverlayImageShort(message, translation)
                #     model.updateOverlay(overlay_image)
                #     overlay_image = model.createOverlayImageLong("send", message, translation)
                #     model.updateOverlay(overlay_image)

def startTranscriptionSendMessage(action:Callable[[dict], None]) -> None:
    mic_message = MicMessage(action)
    model.startMicTranscript(mic_message.send)

def stopTranscriptionSendMessage(action:Callable[[dict], None]) -> None:
    model.stopMicTranscript()
    action("mic", {"status":"success", "message":"Stopped sending messages"})

def startThreadingTranscriptionSendMessage(action:Callable[[dict], None]) -> None:
    th_startTranscriptionSendMessage = Thread(target=startTranscriptionSendMessage, args=(action,))
    th_startTranscriptionSendMessage.daemon = True
    th_startTranscriptionSendMessage.start()

def stopThreadingTranscriptionSendMessage(action:Callable[[dict], None]) -> None:
    th_stopTranscriptionSendMessage = Thread(target=stopTranscriptionSendMessage, args=(action,))
    th_stopTranscriptionSendMessage.daemon = True
    th_stopTranscriptionSendMessage.start()

def startTranscriptionSendMessageOnCloseConfigWindow(action:Callable[[dict], None]) -> None:
    mic_message = MicMessage(action)
    model.startMicTranscript(mic_message.send)

def stopTranscriptionSendMessageOnOpenConfigWindow():
    model.stopMicTranscript()

def startThreadingTranscriptionSendMessageOnCloseConfigWindow(action:Callable[[dict], None]) -> None:
    th_startTranscriptionSendMessage = Thread(target=startTranscriptionSendMessageOnCloseConfigWindow, args=(action,))
    th_startTranscriptionSendMessage.daemon = True
    th_startTranscriptionSendMessage.start()

def stopThreadingTranscriptionSendMessageOnOpenConfigWindow() -> None:
    th_stopTranscriptionSendMessage = Thread(target=stopTranscriptionSendMessageOnOpenConfigWindow)
    th_stopTranscriptionSendMessage.daemon = True
    th_stopTranscriptionSendMessage.start()

# func transcription receive message
class SpeakerMessage:
    def __init__(self, action:Callable[[dict], None]) -> None:
        self.action = action

    def receive(self, message):
        if isinstance(message, bool) and message is False:
            self.action("speaker", {"status":"error", "message":"No mic device detected."})
        elif isinstance(message, str) and len(message) > 0:
            translation = ""
            if model.detectRepeatReceiveMessage(message):
                return
            elif config.ENABLE_TRANSLATION is False:
                pass
            else:
                translation, success = model.getOutputTranslate(message)
                if success is False:
                    changeToCTranslate2Process()

            if config.ENABLE_TRANSCRIPTION_RECEIVE is True:
                if config.ENABLE_NOTICE_XSOVERLAY is True:
                    xsoverlay_message = messageFormatter("RECEIVED", translation, message)
                    model.notificationXSOverlay(xsoverlay_message)

                if config.ENABLE_OVERLAY_SMALL_LOG is True:
                    if model.overlay.initialized is True:
                        overlay_image = model.createOverlayImageShort(message, translation)
                        model.updateOverlay(overlay_image)
                    # overlay_image = model.createOverlayImageLong("receive", message, translation)
                    # model.updateOverlay(overlay_image)

                # ------------Speaker2Chatbox------------
                if config.ENABLE_SPEAKER2CHATBOX is True:
                    # send OSC message
                    if config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC is True:
                        osc_message = messageFormatter("RECEIVED", translation, message)
                        model.oscSendMessage(osc_message)
                # ------------Speaker2Chatbox------------

                # update textbox message log (Received)
                self.action("speaker",{"status":"success", "message":message, "translation":translation})
                if config.ENABLE_LOGGER is True:
                    if len(translation) > 0:
                        translation = f" ({translation})"
                    model.logger.info(f"[RECEIVED] {message}{translation}")

def startTranscriptionReceiveMessage(action:Callable[[dict], None]) -> None:
    speaker_message = SpeakerMessage(action)
    model.startSpeakerTranscript(speaker_message.receive)

def stopTranscriptionReceiveMessage(action:Callable[[dict], None]) -> None:
    model.stopSpeakerTranscript()
    action({"status":"success", "message":"Stopped receiving messages"})

def startThreadingTranscriptionReceiveMessage(action:Callable[[dict], None]) -> None:
    th_startTranscriptionReceiveMessage = Thread(target=startTranscriptionReceiveMessage, args=(action,))
    th_startTranscriptionReceiveMessage.daemon = True
    th_startTranscriptionReceiveMessage.start()

def stopThreadingTranscriptionReceiveMessage(action:Callable[[dict], None]) -> None:
    th_stopTranscriptionReceiveMessage = Thread(target=stopTranscriptionReceiveMessage, args=(action,))
    th_stopTranscriptionReceiveMessage.daemon = True
    th_stopTranscriptionReceiveMessage.start()

def startTranscriptionReceiveMessageOnCloseConfigWindow(action:Callable[[dict], None]) -> None:
    speaker_message = SpeakerMessage(action)
    model.startSpeakerTranscript(speaker_message.receive)

def stopTranscriptionReceiveMessageOnOpenConfigWindow():
    model.stopSpeakerTranscript()

def startThreadingTranscriptionReceiveMessageOnCloseConfigWindow(action:Callable[[dict], None]) -> None:
    th_startTranscriptionReceiveMessage = Thread(target=startTranscriptionReceiveMessageOnCloseConfigWindow, args=(action,))
    th_startTranscriptionReceiveMessage.daemon = True
    th_startTranscriptionReceiveMessage.start()

def stopThreadingTranscriptionReceiveMessageOnOpenConfigWindow():
    th_stopTranscriptionReceiveMessage = Thread(target=stopTranscriptionReceiveMessageOnOpenConfigWindow)
    th_stopTranscriptionReceiveMessage.daemon = True
    th_stopTranscriptionReceiveMessage.start()

# func message box
def sendChatMessage(message):
    if len(message) > 0:
        addSentMessageLog(message)
        translation = ""
        if config.ENABLE_TRANSLATION is False:
            pass
        else:
            translation, success = model.getInputTranslate(message)
            if success is False:
                changeToCTranslate2Process()

        # send OSC message
        if config.ENABLE_SEND_MESSAGE_TO_VRC is True:
            if config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES is True:
                if config.ENABLE_TRANSLATION is False:
                    osc_message = messageFormatter("SEND", "", message)
                else:
                    osc_message = messageFormatter("SEND", "", translation)
            else:
                osc_message = messageFormatter("SEND", translation, message)
            model.oscSendMessage(osc_message)

        # if config.ENABLE_OVERLAY_SMALL_LOG is True:
        #     overlay_image = model.createOverlayImageShort(message, translation)
        #     model.updateOverlay(overlay_image)
        #     overlay_image = model.createOverlayImageLong("send", message, translation)
        #     model.updateOverlay(overlay_image)

        # update textbox message log (Sent)
        # view.printToTextbox_SentMessage(message, translation)
        if config.ENABLE_LOGGER is True:
            if len(translation) > 0:
                translation = f" ({translation})"
            model.logger.info(f"[SENT] {message}{translation}")

        # delete message in entry message box
        if config.ENABLE_AUTO_CLEAR_MESSAGE_BOX is True:
            # view.clearMessageBox()
            pass

def messageBoxPressKeyEnter():
    # model.oscStopSendTyping()
    # message = view.getTextFromMessageBox()
    # sendChatMessage(message)
    pass

def messageBoxPressKeyAny(e):
    if config.ENABLE_SEND_MESSAGE_TO_VRC is True:
        model.oscStartSendTyping()
    else:
        model.oscStopSendTyping()

def messageBoxFocusIn(e):
    # view.foregroundOffIfForegroundEnabled()
    pass

def messageBoxFocusOut(e):
    # view.foregroundOnIfForegroundEnabled()
    if config.ENABLE_SEND_MESSAGE_TO_VRC is True:
        model.oscStopSendTyping()

def addSentMessageLog(sent_message):
    config.SENT_MESSAGES_LOG.append(sent_message)
    config.CURRENT_SENT_MESSAGES_LOG_INDEX = len(config.SENT_MESSAGES_LOG)

def updateMessageBox(index_offset):
    if len(config.SENT_MESSAGES_LOG) == 0:
        return
    try:
        new_index = config.CURRENT_SENT_MESSAGES_LOG_INDEX + index_offset
        target_message_text = config.SENT_MESSAGES_LOG[new_index]
        # view.replaceMessageBox(target_message_text)
        config.CURRENT_SENT_MESSAGES_LOG_INDEX = new_index
    except IndexError:
        pass

def messageBoxUpKeyPress():
    if config.CURRENT_SENT_MESSAGES_LOG_INDEX > 0:
        updateMessageBox(-1)

def messageBoxDownKeyPress():
    if config.CURRENT_SENT_MESSAGES_LOG_INDEX < len(config.SENT_MESSAGES_LOG) - 1:
        updateMessageBox(1)

def updateTranslationEngineAndEngineList():
    engine = config.CHOICE_INPUT_TRANSLATOR
    engines = model.findTranslationEngines(config.SOURCE_LANGUAGE, config.TARGET_LANGUAGE)
    if engine not in engines:
        engine = engines[0]
    config.CHOICE_INPUT_TRANSLATOR = engine
    config.CHOICE_OUTPUT_TRANSLATOR = engine

def initSetTranslateEngine():
    engine = config.SELECTED_TAB_YOUR_TRANSLATOR_ENGINES[config.SELECTED_TAB_NO]
    config.CHOICE_INPUT_TRANSLATOR = engine
    engine = config.SELECTED_TAB_TARGET_TRANSLATOR_ENGINES[config.SELECTED_TAB_NO]
    config.CHOICE_OUTPUT_TRANSLATOR = engine

def initSetLanguageAndCountry():
    select = config.SELECTED_TAB_YOUR_LANGUAGES[config.SELECTED_TAB_NO]
    config.SOURCE_LANGUAGE = select["language"]
    config.SOURCE_COUNTRY = select["country"]
    select = config.SELECTED_TAB_TARGET_LANGUAGES[config.SELECTED_TAB_NO]
    config.TARGET_LANGUAGE = select["language"]
    config.TARGET_COUNTRY = select["country"]

def setYourTranslateEngine(select):
    engines = config.SELECTED_TAB_YOUR_TRANSLATOR_ENGINES
    engines[config.SELECTED_TAB_NO] = select
    config.SELECTED_TAB_YOUR_TRANSLATOR_ENGINES = engines
    config.CHOICE_INPUT_TRANSLATOR = select

def setTargetTranslateEngine(select):
    engines = config.SELECTED_TAB_TARGET_TRANSLATOR_ENGINES
    engines[config.SELECTED_TAB_NO] = select
    config.SELECTED_TAB_TARGET_TRANSLATOR_ENGINES = engines
    config.CHOICE_OUTPUT_TRANSLATOR = select

def setYourLanguageAndCountry(select:dict, *args, **kwargs) -> dict:
    print("setYourLanguageAndCountry", select)
    languages = config.SELECTED_TAB_YOUR_LANGUAGES
    languages[config.SELECTED_TAB_NO] = select
    config.SELECTED_TAB_YOUR_LANGUAGES = languages
    config.SOURCE_LANGUAGE = select["language"]
    config.SOURCE_COUNTRY = select["country"]
    updateTranslationEngineAndEngineList()
    return {"status":"success",
            "data":{
                "your":{
                    "language":config.SOURCE_LANGUAGE,
                    "country":config.SOURCE_COUNTRY
                }
            }
        }

def setTargetLanguageAndCountry(select:dict, *args, **kwargs) -> dict:
    print("setTargetLanguageAndCountry", select)
    languages = config.SELECTED_TAB_TARGET_LANGUAGES
    languages[config.SELECTED_TAB_NO] = select
    config.SELECTED_TAB_TARGET_LANGUAGES = languages
    config.TARGET_LANGUAGE = select["language"]
    config.TARGET_COUNTRY = select["country"]
    updateTranslationEngineAndEngineList()
    return {"status":"success",
            "data":{
                "target":{
                    "language":config.TARGET_LANGUAGE,
                    "country":config.TARGET_COUNTRY
                },
            }
        }

def swapYourLanguageAndTargetLanguage(*args, **kwargs) -> dict:
    print("swapYourLanguageAndTargetLanguage")
    your_language = config.SELECTED_TAB_YOUR_LANGUAGES[config.SELECTED_TAB_NO]
    target_language = config.SELECTED_TAB_TARGET_LANGUAGES[config.SELECTED_TAB_NO]
    setYourLanguageAndCountry(target_language)
    setTargetLanguageAndCountry(your_language)
    return {"status":"success",
            "data":{
                "your":{"language":config.SOURCE_LANGUAGE,
                        "country":config.SOURCE_COUNTRY,
                        },
                "target":{
                    "language":config.TARGET_LANGUAGE,
                    "country":config.TARGET_COUNTRY,
                    },
                },
            }

def callbackSelectedLanguagePresetTab(selected_tab_no:str, *args, **kwargs) -> dict:
    print("callbackSelectedLanguagePresetTab", selected_tab_no)
    config.SELECTED_TAB_NO = selected_tab_no

    engines = config.SELECTED_TAB_YOUR_TRANSLATOR_ENGINES
    engine = engines[config.SELECTED_TAB_NO]
    config.CHOICE_INPUT_TRANSLATOR = engine

    engines = config.SELECTED_TAB_TARGET_TRANSLATOR_ENGINES
    engine = engines[config.SELECTED_TAB_NO]
    config.CHOICE_OUTPUT_TRANSLATOR = engine

    languages = config.SELECTED_TAB_YOUR_LANGUAGES
    select = languages[config.SELECTED_TAB_NO]
    config.SOURCE_LANGUAGE = select["language"]
    config.SOURCE_COUNTRY = select["country"]

    languages = config.SELECTED_TAB_TARGET_LANGUAGES
    select = languages[config.SELECTED_TAB_NO]
    config.TARGET_LANGUAGE = select["language"]
    config.TARGET_COUNTRY = select["country"]
    updateTranslationEngineAndEngineList()
    return {"status":"success", "data":config.SELECTED_TAB_NO}

def callbackSelectedTranslationEngine(selected_translation_engine:str, *args, **kwargs) -> dict:
    print("callbackSelectedTranslationEngine", selected_translation_engine)
    setYourTranslateEngine(selected_translation_engine)
    setTargetTranslateEngine(selected_translation_engine)
    return {"status":"success", "data":selected_translation_engine}

# command func
def callbackEnableTranslation(*args, **kwargs) -> dict:
    print("callbackEnableTranslation")
    config.ENABLE_TRANSLATION = True
    if model.isLoadedCTranslate2Model() is False:
        model.changeTranslatorCTranslate2Model()
    return {"status":"success", "data":config.ENABLE_TRANSLATION}

def callbackDisableTranslation(*args, **kwargs) -> dict:
    print("callbackDisableTranslation")
    config.ENABLE_TRANSLATION = False
    return {"status":"success", "data":config.ENABLE_TRANSLATION}

def callbackEnableTranscriptionSend(data, action, *args, **kwargs) -> dict:
    print("callbackEnableTranscriptionSend")
    config.ENABLE_TRANSCRIPTION_SEND = True
    startThreadingTranscriptionSendMessage(action)
    return {"status":"success", "data":config.ENABLE_TRANSCRIPTION_SEND}

def callbackDisableTranscriptionSend(data, action, *args, **kwargs) -> dict:
    config.ENABLE_TRANSCRIPTION_SEND = False
    stopThreadingTranscriptionSendMessage(action)
    return {"status":"success", "data":config.ENABLE_TRANSCRIPTION_SEND}

def callbackEnableTranscriptionReceive(data, action, *args, **kwargs) -> dict:
    config.ENABLE_TRANSCRIPTION_RECEIVE = True
    startThreadingTranscriptionReceiveMessage(action)

    if config.ENABLE_OVERLAY_SMALL_LOG is True:
        if model.overlay.initialized is False and model.overlay.checkSteamvrRunning() is True:
            model.startOverlay()
    return {"status":"success", "data":config.ENABLE_TRANSCRIPTION_RECEIVE}

def callbackDisableTranscriptionReceive(data, action, *args, **kwargs) -> dict:
    config.ENABLE_TRANSCRIPTION_RECEIVE = False
    stopThreadingTranscriptionReceiveMessage(action)
    return {"status":"success", "data":config.ENABLE_TRANSCRIPTION_RECEIVE}

def callbackEnableForeground(*args, **kwargs) -> dict:
    config.ENABLE_FOREGROUND = True
    return {"status":"success", "data":config.ENABLE_FOREGROUND}

def callbackDisableForeground(*args, **kwargs) -> dict:
    config.ENABLE_FOREGROUND = False
    return {"status":"success", "data":config.ENABLE_FOREGROUND}

def callbackEnableMainWindowSidebarCompactMode(*args, **kwargs) -> dict:
    config.IS_MAIN_WINDOW_SIDEBAR_COMPACT_MODE = True
    return {"status":"success", "data":config.IS_MAIN_WINDOW_SIDEBAR_COMPACT_MODE}

def callbackDisableMainWindowSidebarCompactMode(*args, **kwargs) -> dict:
    config.IS_MAIN_WINDOW_SIDEBAR_COMPACT_MODE = False
    return {"status":"success", "data":config.IS_MAIN_WINDOW_SIDEBAR_COMPACT_MODE}

# Config Window
def callbackOpenConfigWindow(*args, **kwargs) -> dict:
    if config.ENABLE_TRANSCRIPTION_SEND is True:
        stopThreadingTranscriptionSendMessageOnOpenConfigWindow()
    if config.ENABLE_TRANSCRIPTION_RECEIVE is True:
        stopThreadingTranscriptionReceiveMessageOnOpenConfigWindow()
    return {"status":"success"}

def callbackCloseConfigWindow(data, action, *args, **kwargs) -> dict:
    model.stopCheckMicEnergy()
    model.stopCheckSpeakerEnergy()

    if config.ENABLE_TRANSCRIPTION_SEND is True:
        startThreadingTranscriptionSendMessageOnCloseConfigWindow(action)
        if config.ENABLE_TRANSCRIPTION_RECEIVE is True:
            sleep(2)
    if config.ENABLE_TRANSCRIPTION_RECEIVE is True:
        startThreadingTranscriptionReceiveMessageOnCloseConfigWindow(action)
    return {"status":"success"}

# Compact Mode Switch
def callbackEnableConfigWindowCompactMode(*args, **kwargs) -> dict:
    config.IS_CONFIG_WINDOW_COMPACT_MODE = True
    model.stopCheckMicEnergy()
    model.stopCheckSpeakerEnergy()
    return {"status":"success", "data":config.IS_CONFIG_WINDOW_COMPACT_MODE}

def callbackDisableConfigWindowCompactMode(*args, **kwargs) -> dict:
    config.IS_CONFIG_WINDOW_COMPACT_MODE = False
    model.stopCheckMicEnergy()
    model.stopCheckSpeakerEnergy()
    return {"status":"success", "data":config.IS_CONFIG_WINDOW_COMPACT_MODE}

# Appearance Tab
def callbackSetTransparency(data, *args, **kwargs) -> dict:
    print("callbackSetTransparency", int(data))
    config.TRANSPARENCY = int(data)
    return {"status":"success", "data":config.TRANSPARENCY}

def callbackSetAppearance(data, *args, **kwargs) -> dict:
    print("callbackSetAppearance", data)
    config.APPEARANCE_THEME = data
    return {"status":"success", "data":config.APPEARANCE_THEME}

def callbackSetUiScaling(data, *args, **kwargs) -> dict:
    print("callbackSetUiScaling", data)
    config.UI_SCALING = data
    return {"status":"success", "data":config.UI_SCALING}

def callbackSetTextboxUiScaling(data, *args, **kwargs) -> dict:
    print("callbackSetTextboxUiScaling", int(data))
    config.TEXTBOX_UI_SCALING = int(data)
    return {"status":"success", "data":config.TEXTBOX_UI_SCALING}

def callbackSetMessageBoxRatio(data, *args, **kwargs) -> dict:
    print("callbackSetMessageBoxRatio", int(data))
    config.MESSAGE_BOX_RATIO = int(data)
    return {"status":"success", "data":config.MESSAGE_BOX_RATIO}

def callbackSetFontFamily(data, *args, **kwargs) -> dict:
    print("callbackSetFontFamily", data)
    config.FONT_FAMILY = data
    return {"status":"success", "data":config.FONT_FAMILY}

def callbackSetUiLanguage(data, *args, **kwargs) -> dict:
    print("callbackSetUiLanguage", data)
    data = getKeyByValue(config.SELECTABLE_UI_LANGUAGES_DICT, data)
    print("callbackSetUiLanguage__after_getKeyByValue", data)
    config.UI_LANGUAGE = data
    return {"status":"success", "data":config.UI_LANGUAGE}

def callbackSetEnableRestoreMainWindowGeometry(data, *args, **kwargs) -> dict:
    print("callbackSetEnableRestoreMainWindowGeometry", data)
    config.ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY = data
    return {"status":"success", "data":config.ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY}

# Translation Tab
def callbackSetUseTranslationFeature(data, *args, **kwargs) -> dict:
    print("callbackSetUseTranslationFeature", data)
    config.USE_TRANSLATION_FEATURE = data
    if config.USE_TRANSLATION_FEATURE is True:
        if model.checkCTranslatorCTranslate2ModelWeight():
            config.IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION = False
            def callback():
                model.changeTranslatorCTranslate2Model()
            th_callback = Thread(target=callback)
            th_callback.daemon = True
            th_callback.start()
        else:
            config.IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION = True
    else:
        config.IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION = False
    return {"status":"success",
            "data":{
                "feature":config.USE_TRANSLATION_FEATURE,
                "reset":config.IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION,
                },
            }

def callbackSetCtranslate2WeightType(data, *args, **kwargs) -> dict:
    print("callbackSetCtranslate2WeightType", data)
    config.CTRANSLATE2_WEIGHT_TYPE = str(data)
    if model.checkCTranslatorCTranslate2ModelWeight():
        config.IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION = False
        def callback():
            model.changeTranslatorCTranslate2Model()
        th_callback = Thread(target=callback)
        th_callback.daemon = True
        th_callback.start()
    else:
        config.IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION = True
    return {"status":"success",
            "data":{
                "feature":config.CTRANSLATE2_WEIGHT_TYPE,
                "reset":config.IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION,
                },
            }

def callbackSetDeeplAuthKey(data, *args, **kwargs) -> dict:
    status = "error"
    print("callbackSetDeeplAuthKey", str(data))
    if len(data) == 36 or len(data) == 39:
        result = model.authenticationTranslatorDeepLAuthKey(auth_key=data)
        if result is True:
            key = data
            status = "success"
        else:
            key = None
        auth_keys = config.AUTH_KEYS
        auth_keys["DeepL_API"] = key
        config.AUTH_KEYS = auth_keys
        updateTranslationEngineAndEngineList()
    return {"status":status, "data":config.AUTH_KEYS["DeepL_API"]}

def callbackClearDeeplAuthKey(*args, **kwargs) -> dict:
    auth_keys = config.AUTH_KEYS
    auth_keys["DeepL_API"] = None
    config.AUTH_KEYS = auth_keys
    updateTranslationEngineAndEngineList()
    return {"status":"success", "data":config.AUTH_KEYS["DeepL_API"]}

# Transcription Tab
# Transcription (Mic)
def callbackSetMicHost(data, *args, **kwargs) -> dict:
    print("callbackSetMicHost", data)
    config.CHOICE_MIC_HOST = data
    config.CHOICE_MIC_DEVICE = model.getInputDefaultDevice()
    model.stopCheckMicEnergy()
    return {"status":"success",
            "data":{
                "host":config.CHOICE_MIC_HOST,
                "device":config.CHOICE_MIC_DEVICE,
                },
            }

def callbackSetMicDevice(data, *args, **kwargs) -> dict:
    print("callbackSetMicDevice", data)
    config.CHOICE_MIC_DEVICE = data
    model.stopCheckMicEnergy()
    return {"status":"success",
            "data":{
                "host":config.CHOICE_MIC_HOST,
                },
            }

def callbackSetMicEnergyThreshold(data, *args, **kwargs) -> dict:
    status = "error"
    print("callbackSetMicEnergyThreshold", data)
    data = int(data)
    if 0 <= data <= config.MAX_MIC_ENERGY_THRESHOLD:
        config.INPUT_MIC_ENERGY_THRESHOLD = data
        status = "success"
    return {"status": status, "data": config.INPUT_MIC_ENERGY_THRESHOLD}

def callbackSetMicDynamicEnergyThreshold(data, *args, **kwargs) -> dict:
    print("callbackSetMicDynamicEnergyThreshold", data)
    config.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD = data
    return {"status":"success", "data":config.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD}

class ProgressBarEnergy:
    def __init__(self, action):
        self.action = action

    def set(self, energy) -> None:
        self.action("energy", {"status":"success", "energy":energy})

def callbackEnableCheckMicThreshold(data, action, *args, **kwargs) -> dict:
    print("callbackEnableCheckMicThreshold")
    progressbar_mic_energy = ProgressBarEnergy(action)
    model.startCheckMicEnergy(progressbar_mic_energy.set)
    return {"status":"success"}

def callbackDisableCheckMicThreshold(*args, **kwargs) -> dict:
    print("callbackDisableCheckMicThreshold")
    model.stopCheckMicEnergy()
    return {"status":"success"}

def callbackSetMicRecordTimeout(data, *args, **kwargs) -> dict:
    print("callbackSetMicRecordTimeout", data)
    try:
        data = int(data)
        if 0 <= data <= config.INPUT_MIC_PHRASE_TIMEOUT:
            config.INPUT_MIC_RECORD_TIMEOUT = data
        else:
            raise ValueError()
    except Exception:
        response = {"status":"error", "message":"Error Mic Record Timeout"}
    else:
        response = {"status":"success", "data":config.INPUT_MIC_RECORD_TIMEOUT}
    return response

def callbackSetMicPhraseTimeout(data, *args, **kwargs) -> dict:
    print("callbackSetMicPhraseTimeout", data)
    try:
        data = int(data)
        if data >= config.INPUT_MIC_RECORD_TIMEOUT:
            config.INPUT_MIC_PHRASE_TIMEOUT = data
        else:
            raise ValueError()
    except Exception:
        response = {"status":"error", "message":"Error Mic Phrase Timeout"}
    else:
        response = {"status":"success", "data":config.INPUT_MIC_PHRASE_TIMEOUT}
    return response

def callbackSetMicMaxPhrases(data, *args, **kwargs) -> dict:
    print("callbackSetMicMaxPhrases", data)
    try:
        data = int(data)
        if 0 <= data:
            config.INPUT_MIC_MAX_PHRASES = data
        else:
            raise ValueError()
    except Exception:
        response = {"status":"error", "message":"Error Mic Max Phrases"}
    else:
        response = {"status":"success", "data":config.INPUT_MIC_MAX_PHRASES}
    return response

def callbackSetMicWordFilter(data, *args, **kwargs) -> dict:
    print("callbackSetMicWordFilter", data)
    data = str(data)
    data = [w.strip() for w in data.split(",") if len(w.strip()) > 0]
    # Copy the list
    new_input_mic_word_filter_list = config.INPUT_MIC_WORD_FILTER
    new_added_value = []
    for value in data:
        if value in new_input_mic_word_filter_list:
            # If the value is already in the list, do nothing.
            pass
        else:
            new_input_mic_word_filter_list.append(value)
            new_added_value.append(value)
    config.INPUT_MIC_WORD_FILTER = new_input_mic_word_filter_list

    model.resetKeywordProcessor()
    model.addKeywords()
    return {"status":"success", "data":config.INPUT_MIC_WORD_FILTER}

def callbackDeleteMicWordFilter(data, *args, **kwargs) -> dict:
    print("callbackDeleteMicWordFilter", data)
    try:
        new_input_mic_word_filter_list = config.INPUT_MIC_WORD_FILTER
        new_input_mic_word_filter_list.remove(str(data))
        config.INPUT_MIC_WORD_FILTER = new_input_mic_word_filter_list
        model.resetKeywordProcessor()
        model.addKeywords()
    except Exception:
        print("There was no the target word in config.INPUT_MIC_WORD_FILTER")
    return {"status":"success", "data":config.INPUT_MIC_WORD_FILTER}

# Transcription (Speaker)
def callbackSetSpeakerDevice(data, *args, **kwargs) -> dict:
    print("callbackSetSpeakerDevice", data)
    config.CHOICE_SPEAKER_DEVICE = data
    model.stopCheckSpeakerEnergy()
    return {"status":"success", "data":config.CHOICE_SPEAKER_DEVICE}

def callbackSetSpeakerEnergyThreshold(data, *args, **kwargs) -> dict:
    print("callbackSetSpeakerEnergyThreshold", data)
    try:
        data = int(data)
        if 0 <= data <= config.MAX_SPEAKER_ENERGY_THRESHOLD:
            # view.clearNotificationMessage()
            config.INPUT_SPEAKER_ENERGY_THRESHOLD = data
            # view.setGuiVariable_SpeakerEnergyThreshold(config.INPUT_SPEAKER_ENERGY_THRESHOLD)
        else:
            raise ValueError()
    except Exception:
        response = {"status":"error", "message":"Error Set Speaker Energy Threshold"}
    else:
        response = {"status":"success", "data":config.INPUT_SPEAKER_ENERGY_THRESHOLD}
    return response

def callbackSetSpeakerDynamicEnergyThreshold(data, *args, **kwargs) -> dict:
    print("callbackSetSpeakerDynamicEnergyThreshold", data)
    config.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD = data
    return {"status":"success", "data":config.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD}

def callbackEnableCheckSpeakerThreshold(data, action, *args, **kwargs) -> dict:
    print("callbackEnableCheckSpeakerThreshold")
    progressbar_speaker_energy = ProgressBarEnergy(action)
    model.startCheckSpeakerEnergy(progressbar_speaker_energy.set)
    return {"status":"success"}

def callbackDisableCheckSpeakerThreshold(*args, **kwargs) -> dict:
    print("callbackDisableCheckSpeakerThreshold")
    model.stopCheckSpeakerEnergy()
    return {"status":"success"}

def callbackSetSpeakerRecordTimeout(data, *args, **kwargs) -> dict:
    print("callbackSetSpeakerRecordTimeout", data)
    try:
        data = int(data)
        if 0 <= data <= config.INPUT_SPEAKER_PHRASE_TIMEOUT:
            config.INPUT_SPEAKER_RECORD_TIMEOUT = data
        else:
            raise ValueError()
    except Exception:
        response = {"status":"error", "message":"Error Speaker Record Timeout"}
    else:
        response = {"status":"success", "data":config.INPUT_SPEAKER_RECORD_TIMEOUT}
    return response

def callbackSetSpeakerPhraseTimeout(data, *args, **kwargs) -> dict:
    print("callbackSetSpeakerPhraseTimeout", data)
    try:
        data = int(data)
        if 0 <= data and data >= config.INPUT_SPEAKER_RECORD_TIMEOUT:
            config.INPUT_SPEAKER_PHRASE_TIMEOUT = data
        else:
            raise ValueError()
    except Exception:
        response = {"status":"error", "message":"Error Speaker Phrase Timeout"}
    else:
        response = {"status":"success", "data":config.INPUT_SPEAKER_PHRASE_TIMEOUT}
    return response

def callbackSetSpeakerMaxPhrases(data, *args, **kwargs) -> dict:
    print("callbackSetSpeakerMaxPhrases", data)
    try:
        data = int(data)
        if 0 <= data:
            config.INPUT_SPEAKER_MAX_PHRASES = data
        else:
            raise ValueError()
    except Exception:
        response = {"status":"error", "message":"Error Speaker Max Phrases"}
    else:
        response = {"status":"success", "data":config.INPUT_SPEAKER_MAX_PHRASES}
    return response

# Transcription (Internal AI Model)
def callbackSetUserWhisperFeature(data, *args, **kwargs) -> dict:
    print("callbackSetUserWhisperFeature", data)
    config.USE_WHISPER_FEATURE = data
    if config.USE_WHISPER_FEATURE is True:
        if model.checkTranscriptionWhisperModelWeight() is True:
            config.IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER = False
            config.SELECTED_TRANSCRIPTION_ENGINE = "Whisper"
        else:
            config.IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER = True
            config.SELECTED_TRANSCRIPTION_ENGINE = "Google"
    else:
        config.IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER = False
        config.SELECTED_TRANSCRIPTION_ENGINE = "Google"
    return {"status":"success",
            "data":{
                "feature":config.USE_WHISPER_FEATURE,
                "transcription_engine":config.SELECTED_TRANSCRIPTION_ENGINE,
                "reset":config.IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER,
                },
            }

def callbackSetWhisperWeightType(data, *args, **kwargs) -> dict:
    print("callbackSetWhisperWeightType", data)
    config.WHISPER_WEIGHT_TYPE = str(data)
    if model.checkTranscriptionWhisperModelWeight() is True:
        config.IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER = False
        config.SELECTED_TRANSCRIPTION_ENGINE = "Whisper"
    else:
        config.IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER = True
        config.SELECTED_TRANSCRIPTION_ENGINE = "Google"
    return {"status":"success",
            "data":{
                "weight_type":config.WHISPER_WEIGHT_TYPE,
                "transcription_engine":config.SELECTED_TRANSCRIPTION_ENGINE,
                "reset":config.IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER,
            }
        }

# VR Tab
def callbackSetOverlaySettingsOpacity(data, *args, **kwargs) -> dict:
    print("callbackSetOverlaySettingsOpacity", data)
    pre_settings = config.OVERLAY_SETTINGS
    pre_settings["opacity"] = data
    config.OVERLAY_SETTINGS = pre_settings
    model.updateOverlayImageOpacity()
    return {"status":"success", "data":config.OVERLAY_SETTINGS["opacity"]}

def callbackSetOverlaySettingsUiScaling(data, *args, **kwargs) -> dict:
    print("callbackSetOverlaySettingsUiScaling", data)
    pre_settings = config.OVERLAY_SETTINGS
    pre_settings["ui_scaling"] = data
    config.OVERLAY_SETTINGS = pre_settings
    model.updateOverlayImageUiScaling()
    return {"status":"success", "data":config.OVERLAY_SETTINGS["ui_scaling"]}

def callbackEnableOverlaySmallLog(data, *args, **kwargs) -> dict:
    print("callbackEnableOverlaySmallLog", data)
    config.ENABLE_OVERLAY_SMALL_LOG = data

    if config.ENABLE_OVERLAY_SMALL_LOG is True and config.ENABLE_TRANSCRIPTION_RECEIVE is True:
        if model.overlay.initialized is False and model.overlay.checkSteamvrRunning() is True:
            model.startOverlay()
    return {"status":"success", "data":config.ENABLE_OVERLAY_SMALL_LOG}

def callbackDisableOverlaySmallLog(data, *args, **kwargs) -> dict:
    print("callbackDisableOverlaySmallLog", data)
    config.ENABLE_OVERLAY_SMALL_LOG = data
    if config.ENABLE_OVERLAY_SMALL_LOG is False:
        model.clearOverlayImage()
        model.shutdownOverlay()
    return {"status":"success", "data":config.ENABLE_OVERLAY_SMALL_LOG}

def callbackSetOverlaySmallLogSettings(value, set_type:str):
    print("callbackSetOverlaySmallLogSettings", value, set_type)
    pre_settings = config.OVERLAY_SMALL_LOG_SETTINGS
    pre_settings[set_type] = value
    config.OVERLAY_SMALL_LOG_SETTINGS = pre_settings
    match (set_type):
        case "x_pos" | "y_pos" | "z_pos" | "x_rotation" | "y_rotation" | "z_rotation":
            model.updateOverlayPosition()
        case "display_duration" | "fadeout_duration":
            model.updateOverlayTimes()

def callbackSetOverlaySmallLogSettingsXPos(data, *args, **kwargs) -> dict:
    print("callbackSetOverlaySmallLogSettingsXPos", data)
    pre_settings = config.OVERLAY_SMALL_LOG_SETTINGS
    pre_settings["x_pos"] = data
    config.OVERLAY_SMALL_LOG_SETTINGS = pre_settings
    model.updateOverlayPosition()
    return {"status":"success", "data":config.OVERLAY_SMALL_LOG_SETTINGS["x_pos"]}

def callbackSetOverlaySmallLogSettingsYPos(data, *args, **kwargs) -> dict:
    print("callbackSetOverlaySmallLogSettingsYPos", data)
    pre_settings = config.OVERLAY_SMALL_LOG_SETTINGS
    pre_settings["y_pos"] = data
    config.OVERLAY_SMALL_LOG_SETTINGS = pre_settings
    model.updateOverlayPosition()
    return {"status":"success", "data":config.OVERLAY_SMALL_LOG_SETTINGS["y_pos"]}

def callbackSetOverlaySmallLogSettingsZPos(data, *args, **kwargs) -> dict:
    print("callbackSetOverlaySmallLogSettingsZPos", data)
    pre_settings = config.OVERLAY_SMALL_LOG_SETTINGS
    pre_settings["z_pos"] = data
    config.OVERLAY_SMALL_LOG_SETTINGS = pre_settings
    model.updateOverlayPosition()
    return {"status":"success", "data":config.OVERLAY_SMALL_LOG_SETTINGS["z_pos"]}

def callbackSetOverlaySmallLogSettingsXRotation(data, *args, **kwargs) -> dict:
    print("callbackSetOverlaySmallLogSettingsXRotation", data)
    pre_settings = config.OVERLAY_SMALL_LOG_SETTINGS
    pre_settings["x_rotation"] = data
    config.OVERLAY_SMALL_LOG_SETTINGS = pre_settings
    model.updateOverlayPosition()
    return {"status":"success", "data":config.OVERLAY_SMALL_LOG_SETTINGS["x_rotation"]}

def callbackSetOverlaySmallLogSettingsYRotation(data, *args, **kwargs) -> dict:
    print("callbackSetOverlaySmallLogSettingsYRotation", data)
    pre_settings = config.OVERLAY_SMALL_LOG_SETTINGS
    pre_settings["y_rotation"] = data
    config.OVERLAY_SMALL_LOG_SETTINGS = pre_settings
    model.updateOverlayPosition()
    return {"status":"success", "data":config.OVERLAY_SMALL_LOG_SETTINGS["y_rotation"]}

def callbackSetOverlaySmallLogSettingsZRotation(data, *args, **kwargs) -> dict:
    print("callbackSetOverlaySmallLogSettingsZRotation", data)
    pre_settings = config.OVERLAY_SMALL_LOG_SETTINGS
    pre_settings["z_rotation"] = data
    config.OVERLAY_SMALL_LOG_SETTINGS = pre_settings
    model.updateOverlayPosition()
    return {"status":"success", "data":config.OVERLAY_SMALL_LOG_SETTINGS["z_rotation"]}

# Others Tab
def callbackSetEnableAutoClearMessageBox(data, *args, **kwargs) -> dict:
    print("callbackSetEnableAutoClearMessageBox", data)
    config.ENABLE_AUTO_CLEAR_MESSAGE_BOX = data
    return {"status":"success", "data":config.ENABLE_AUTO_CLEAR_MESSAGE_BOX}

def callbackSetEnableSendOnlyTranslatedMessages(data, *args, **kwargs) -> dict:
    print("callbackSetEnableSendOnlyTranslatedMessages", data)
    config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES = data
    return {"status":"success", "data":config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES}

def callbackSetSendMessageButtonType(data, *args, **kwargs) -> dict:
    print("callbackSetSendMessageButtonType", data)
    config.SEND_MESSAGE_BUTTON_TYPE = data
    return {"status":"success", "data":config.SEND_MESSAGE_BUTTON_TYPE}

def callbackEnableNoticeXsoverlay(*args, **kwargs) -> dict:
    print("callbackEnableNoticeXsoverlay")
    config.ENABLE_NOTICE_XSOVERLAY = True
    return {"status":"success", "data":config.ENABLE_NOTICE_XSOVERLAY}

def callbackDisableNoticeXsoverlay(*args, **kwargs) -> dict:
    print("callbackDisableNoticeXsoverlay")
    config.ENABLE_NOTICE_XSOVERLAY = False
    return {"status":"success", "data":config.ENABLE_NOTICE_XSOVERLAY}

def callbackEnableAutoExportMessageLogs(*args, **kwargs) -> dict:
    print("callbackEnableAutoExportMessageLogs")
    config.ENABLE_LOGGER = True
    model.startLogger()

def callbackDisableAutoExportMessageLogs(*args, **kwargs) -> dict:
    print("callbackDisableAutoExportMessageLogs")
    config.ENABLE_LOGGER = False
    model.stopLogger()

def callbackEnableVrcMicMuteSync(*args, **kwargs) -> dict:
    print("callbackEnableVrcMicMuteSync")
    config.ENABLE_VRC_MIC_MUTE_SYNC = True
    model.startCheckMuteSelfStatus()
    model.changeMicTranscriptStatus()

def callbackDisableVrcMicMuteSync(*args, **kwargs) -> dict:
    print("callbackDisableVrcMicMuteSync")
    config.ENABLE_VRC_MIC_MUTE_SYNC = False
    model.stopCheckMuteSelfStatus()
    model.changeMicTranscriptStatus()

def callbackEnableSendMessageToVrc(*args, **kwargs) -> dict:
    print("callbackEnableSendMessageToVrc")
    config.ENABLE_SEND_MESSAGE_TO_VRC = True
    return {"status":"success", "data":config.ENABLE_SEND_MESSAGE_TO_VRC}

def callbackDisableSendMessageToVrc(*args, **kwargs) -> dict:
    print("callbackSetEnableSendMessageToVrc")
    config.ENABLE_SEND_MESSAGE_TO_VRC = False
    return {"status":"success", "data":config.ENABLE_SEND_MESSAGE_TO_VRC}

# Others (Message Formats(Send)
def callbackSetSendMessageFormat(data, *args, **kwargs) -> dict:
    print("callbackSetSendMessageFormat", data)
    if isUniqueStrings(["[message]"], data) is True:
        config.SEND_MESSAGE_FORMAT = data
    return {"status":"success", "data":config.SEND_MESSAGE_FORMAT}

def callbackSetSendMessageFormatWithT(data, *args, **kwargs) -> dict:
    print("callbackSetSendMessageFormatWithT", data)
    if len(data) > 0:
        if isUniqueStrings(["[message]", "[translation]"], data) is True:
            config.SEND_MESSAGE_FORMAT_WITH_T = data
    return {"status":"success", "data":config.SEND_MESSAGE_FORMAT_WITH_T}

# Others (Message Formats(Received)
def callbackSetReceivedMessageFormat(data, *args, **kwargs) -> dict:
    print("callbackSetReceivedMessageFormat", data)
    if isUniqueStrings(["[message]"], data) is True:
        config.RECEIVED_MESSAGE_FORMAT = data
    return {"status":"success", "data":config.RECEIVED_MESSAGE_FORMAT}

def callbackSetReceivedMessageFormatWithT(data, *args, **kwargs) -> dict:
    print("callbackSetReceivedMessageFormatWithT", data)
    if len(data) > 0:
        if isUniqueStrings(["[message]", "[translation]"], data) is True:
            config.RECEIVED_MESSAGE_FORMAT_WITH_T = data
    return {"status":"success", "data":config.RECEIVED_MESSAGE_FORMAT_WITH_T}

# ---------------------Speaker2Chatbox---------------------
def callbackEnableSendReceivedMessageToVrc(*args, **kwargs) -> dict:
    print("callbackEnableSendReceivedMessageToVrc")
    config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC = True
    return {"status":"success", "data":config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC}

def callbackDisableSendReceivedMessageToVrc(*args, **kwargs) -> dict:
    print("callbackDisableSendReceivedMessageToVrc")
    config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC = False
    return {"status":"success", "data":config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC}
# ---------------------Speaker2Chatbox---------------------

# Advanced Settings Tab
def callbackSetOscIpAddress(data, *args, **kwargs) -> dict:
    print("callbackSetOscIpAddress", str(data))
    config.OSC_IP_ADDRESS = str(data)
    return {"status":"success", "data":config.OSC_IP_ADDRESS}

def callbackSetOscPort(data, *args, **kwargs) -> dict:
    print("callbackSetOscPort", int(data))
    config.OSC_PORT = int(data)
    return {"status":"success", "data":config.OSC_PORT}

def getListLanguageAndCountry():
    return model.getListLanguageAndCountry()

def getListInputHost():
    return model.getListInputHost()

def getListInputDevice():
    return model.getListInputDevice()

def getListOutputDevice():
    return model.getListOutputDevice()


def initSetConfigByExeArguments():
    parser = argparse.ArgumentParser()
    parser.add_argument("--ip")
    parser.add_argument("--port")
    args = parser.parse_args()
    if args.ip is not None:
        config.OSC_IP_ADDRESS = str(args.ip)
        # view.setGuiVariable_OscIpAddress(config.OSC_IP_ADDRESS)
    if args.port is not None:
        config.OSC_PORT = int(args.port)
        # view.setGuiVariable_OscPort(config.OSC_PORT)

def createMainWindow(splash):
    splash.toProgress(1)
    # create GUI
    # view.createGUI()
    splash.toProgress(2)

    # init config
    initSetConfigByExeArguments()
    initSetTranslateEngine()
    initSetLanguageAndCountry()

    if config.AUTH_KEYS["DeepL_API"] is not None:
        if model.authenticationTranslatorDeepLAuthKey(auth_key=config.AUTH_KEYS["DeepL_API"]) is False:
            # error update Auth key
            auth_keys = config.AUTH_KEYS
            auth_keys["DeepL_API"] = None
            config.AUTH_KEYS = auth_keys
            # view.printToTextbox_AuthenticationError()

    # set Translation Engine
    updateTranslationEngineAndEngineList()

    # set Transcription Engine
    if config.USE_WHISPER_FEATURE is True:
        config.SELECTED_TRANSCRIPTION_ENGINE = "Whisper"
    else:
        config.SELECTED_TRANSCRIPTION_ENGINE = "Google"

    # set word filter
    model.addKeywords()

    # check Software Updated
    if model.checkSoftwareUpdated() is True:
        # view.showUpdateAvailableButton()
        pass

    # init logger
    if config.ENABLE_LOGGER is True:
        model.startLogger()

    # init OSC receive
    model.startReceiveOSC()
    if config.ENABLE_VRC_MIC_MUTE_SYNC is True:
        model.startCheckMuteSelfStatus()

    splash.toProgress(3) # Last one.

    # set UI and callback
    # view.register(
    #     common_registers={
    #         "callback_enable_easter_egg": callbackEnableEasterEgg,

    #         "callback_update_software": callbackUpdateSoftware,
    #         "callback_restart_software": callbackRestartSoftware,
    #         "callback_filepath_logs": callbackFilepathLogs,
    #         "callback_filepath_config_file": callbackFilepathConfigFile,
    #         "callback_quit_vrct": callbackQuitVrct,
    #     },

    #     window_action_registers={
    #         "callback_open_config_window": callbackOpenConfigWindow,
    #         "callback_close_config_window": callbackCloseConfigWindow,
    #     },

    #     main_window_registers={
    #         "callback_enable_main_window_sidebar_compact_mode": callbackEnableMainWindowSidebarCompactMode,
    #         "callback_disable_main_window_sidebar_compact_mode": callbackDisableMainWindowSidebarCompactMode,

    #         "callback_toggle_translation": callbackToggleTranslation,
    #         "callback_toggle_transcription_send": callbackToggleTranscriptionSend,
    #         "callback_toggle_transcription_receive": callbackToggleTranscriptionReceive,
    #         "callback_toggle_foreground": callbackToggleForeground,

    #         "callback_your_language": setYourLanguageAndCountry,
    #         "callback_target_language": setTargetLanguageAndCountry,
    #         "values": model.getListLanguageAndCountry(),
    #         "callback_swap_languages": swapYourLanguageAndTargetLanguage,

    #         "callback_selected_language_preset_tab": callbackSelectedLanguagePresetTab,

    #         "callback_selected_translation_engine": callbackSelectedTranslationEngine,

    #         "message_box_bind_Return": messageBoxPressKeyEnter,
    #         "message_box_bind_Any_KeyPress": messageBoxPressKeyAny,
    #         "message_box_bind_FocusIn": messageBoxFocusIn,
    #         "message_box_bind_FocusOut": messageBoxFocusOut,
    #         "message_box_bind_Up_KeyPress": messageBoxUpKeyPress,
    #         "message_box_bind_Down_KeyPress": messageBoxDownKeyPress,
    #     },

    #     config_window_registers={
    #         # Compact Mode Switch
    #         "callback_disable_config_window_compact_mode": callbackEnableConfigWindowCompactMode,
    #         "callback_enable_config_window_compact_mode": callbackDisableConfigWindowCompactMode,

    #         # Appearance Tab
    #         "callback_set_transparency": callbackSetTransparency,
    #         "callback_set_appearance": callbackSetAppearance,
    #         "callback_set_ui_scaling": callbackSetUiScaling,
    #         "callback_set_textbox_ui_scaling": callbackSetTextboxUiScaling,
    #         "callback_set_message_box_ratio": callbackSetMessageBoxRatio,
    #         "callback_set_font_family": callbackSetFontFamily,
    #         "callback_set_ui_language": callbackSetUiLanguage,
    #         "callback_set_enable_restore_main_window_geometry": callbackSetEnableRestoreMainWindowGeometry,

    #         # Translation Tab
    #         "callback_set_use_translation_feature": callbackSetUseTranslationFeature,
    #         "callback_set_ctranslate2_weight_type": callbackSetCtranslate2WeightType,
    #         "callback_set_deepl_auth_key": callbackSetDeeplAuthKey,

    #         # Transcription Tab (Mic)
    #         "callback_set_mic_host": callbackSetMicHost,
    #         "list_mic_host": model.getListInputHost(),
    #         "callback_set_mic_device": callbackSetMicDevice,
    #         "list_mic_device": model.getListInputDevice(),
    #         "callback_set_mic_energy_threshold": callbackSetMicEnergyThreshold,
    #         "callback_set_mic_dynamic_energy_threshold": callbackSetMicDynamicEnergyThreshold,
    #         "callback_check_mic_threshold": callbackCheckMicThreshold,
    #         "callback_set_mic_record_timeout": callbackSetMicRecordTimeout,
    #         "callback_set_mic_phrase_timeout": callbackSetMicPhraseTimeout,
    #         "callback_set_mic_max_phrases": callbackSetMicMaxPhrases,
    #         "callback_set_mic_word_filter": callbackSetMicWordFilter,
    #         "callback_delete_mic_word_filter": callbackDeleteMicWordFilter,

    #         # Transcription Tab (Speaker)
    #         "callback_set_speaker_device": callbackSetSpeakerDevice,
    #         "list_speaker_device": model.getListOutputDevice(),
    #         "callback_set_speaker_energy_threshold": callbackSetSpeakerEnergyThreshold,
    #         "callback_set_speaker_dynamic_energy_threshold": callbackSetSpeakerDynamicEnergyThreshold,
    #         "callback_check_speaker_threshold": callbackCheckSpeakerThreshold,
    #         "callback_set_speaker_record_timeout": callbackSetSpeakerRecordTimeout,
    #         "callback_set_speaker_phrase_timeout": callbackSetSpeakerPhraseTimeout,
    #         "callback_set_speaker_max_phrases": callbackSetSpeakerMaxPhrases,

    #         # Transcription Tab (Internal AI Model)
    #         "callback_set_use_whisper_feature": callbackSetUserWhisperFeature,
    #         "callback_set_whisper_weight_type": callbackSetWhisperWeightType,

    #         # VR Tab
    #         "callback_set_overlay_settings": callbackSetOverlaySettings,
    #         "callback_set_enable_overlay_small_log": callbackSetEnableOverlaySmallLog,
    #         "callback_set_overlay_small_log_settings": callbackSetOverlaySmallLogSettings,

    #         # Others Tab
    #         "callback_set_enable_auto_clear_chatbox": callbackSetEnableAutoClearMessageBox,
    #         "callback_set_send_only_translated_messages": callbackSetEnableSendOnlyTranslatedMessages,
    #         "callback_set_send_message_button_type": callbackSetSendMessageButtonType,
    #         "callback_set_enable_notice_xsoverlay": callbackSetEnableNoticeXsoverlay,
    #         "callback_set_enable_auto_export_message_logs": callbackSetEnableAutoExportMessageLogs,
    #         "callback_set_enable_vrc_mic_mute_sync": callbackSetEnableVrcMicMuteSync,
    #         "callback_set_enable_send_message_to_vrc": callbackSetEnableSendMessageToVrc,
    #         # Others(Message Formats(Send)
    #         "callback_set_send_message_format": callbackSetSendMessageFormat,
    #         "callback_set_send_message_format_with_t": callbackSetSendMessageFormatWithT,
    #         # Others(Message Formats(Received)
    #         "callback_set_received_message_format": callbackSetReceivedMessageFormat,
    #         "callback_set_received_message_format_with_t": callbackSetReceivedMessageFormatWithT,

    #         # Speaker2Chatbox----------------
    #         "callback_set_enable_send_received_message_to_vrc": callbackSetEnableSendReceivedMessageToVrc,
    #         # Speaker2Chatbox----------------

    #         # Advanced Settings Tab
    #         "callback_set_osc_ip_address": callbackSetOscIpAddress,
    #         "callback_set_osc_port": callbackSetOscPort,
    #     },
    # )

# def showMainWindow():
#     view.startMainLoop()