Merge branch 'language-template' into UI_2.0

config.py

@@ -135,43 +135,43 @@ class Config:
             saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
 
     @property
-    def INPUT_SOURCE_LANG(self):
+    def SOURCE_LANGUAGE(self):
-        return self._INPUT_SOURCE_LANG
+        return self._SOURCE_LANGUAGE
 
-    @INPUT_SOURCE_LANG.setter
+    @SOURCE_LANGUAGE.setter
-    def INPUT_SOURCE_LANG(self, value):
+    def SOURCE_LANGUAGE(self, value):
-        if value in list(translation_lang[self.CHOICE_TRANSLATOR]["source"].keys()):
+        if type(value) is str:
-            self._INPUT_SOURCE_LANG = value
+            self._SOURCE_LANGUAGE = value
             saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
 
     @property
-    def INPUT_TARGET_LANG(self):
+    def SOURCE_COUNTRY(self):
-        return self._INPUT_TARGET_LANG
+        return self._SOURCE_COUNTRY
 
-    @INPUT_TARGET_LANG.setter
+    @SOURCE_COUNTRY.setter
-    def INPUT_TARGET_LANG(self, value):
+    def SOURCE_COUNTRY(self, value):
-        if value in list(translation_lang[self.CHOICE_TRANSLATOR]["target"].keys()):
+        if type(value) is str:
-            self._INPUT_TARGET_LANG = value
+            self._SOURCE_COUNTRY = value
             saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
 
     @property
-    def OUTPUT_SOURCE_LANG(self):
+    def TARGET_LANGUAGE(self):
-        return self._OUTPUT_SOURCE_LANG
+        return self._TARGET_LANGUAGE
 
-    @OUTPUT_SOURCE_LANG.setter
+    @TARGET_LANGUAGE.setter
-    def OUTPUT_SOURCE_LANG(self, value):
+    def TARGET_LANGUAGE(self, value):
-        if value in list(translation_lang[self.CHOICE_TRANSLATOR]["source"].keys()):
+        if type(value) is str:
-            self._OUTPUT_SOURCE_LANG = value
+            self._TARGET_LANGUAGE = value
             saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
 
     @property
-    def OUTPUT_TARGET_LANG(self):
+    def TARGET_COUNTRY(self):
-        return self._OUTPUT_TARGET_LANG
+        return self._TARGET_COUNTRY
 
-    @OUTPUT_TARGET_LANG.setter
+    @TARGET_COUNTRY.setter
-    def OUTPUT_TARGET_LANG(self, value):
+    def TARGET_COUNTRY(self, value):
-        if value in list(translation_lang[self.CHOICE_TRANSLATOR]["target"].keys()):
+        if type(value) is str:
-            self._OUTPUT_TARGET_LANG = value
+            self._TARGET_COUNTRY = value
             saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
 
     @property
@@ -194,16 +194,6 @@ class Config:
             self._CHOICE_MIC_DEVICE = value
             saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
 
-    @property
-    def INPUT_MIC_VOICE_LANGUAGE(self):
-        return self._INPUT_MIC_VOICE_LANGUAGE
-
-    @INPUT_MIC_VOICE_LANGUAGE.setter
-    def INPUT_MIC_VOICE_LANGUAGE(self, value):
-        if value in list(transcription_lang.keys()):
-            self._INPUT_MIC_VOICE_LANGUAGE = value
-            saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
-
     @property
     def INPUT_MIC_ENERGY_THRESHOLD(self):
         return self._INPUT_MIC_ENERGY_THRESHOLD
@@ -276,16 +266,6 @@ class Config:
                 self._CHOICE_SPEAKER_DEVICE = value
                 saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
 
-    @property
-    def INPUT_SPEAKER_VOICE_LANGUAGE(self):
-        return self._INPUT_SPEAKER_VOICE_LANGUAGE
-
-    @INPUT_SPEAKER_VOICE_LANGUAGE.setter
-    def INPUT_SPEAKER_VOICE_LANGUAGE(self, value):
-        if value in list(transcription_lang.keys()):
-            self._INPUT_SPEAKER_VOICE_LANGUAGE = value
-            saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
-
     @property
     def INPUT_SPEAKER_ENERGY_THRESHOLD(self):
         return self._INPUT_SPEAKER_ENERGY_THRESHOLD
@@ -432,6 +412,36 @@ class Config:
     def MAX_SPEAKER_ENERGY_THRESHOLD(self):
         return self._MAX_SPEAKER_ENERGY_THRESHOLD
 
+    @property
+    def SELECTED_TAB_NO(self):
+        return self._SELECTED_TAB_NO
+
+    @SELECTED_TAB_NO.setter
+    def SELECTED_TAB_NO(self, value):
+        if type(value) is str:
+            self._SELECTED_TAB_NO = value
+            saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
+
+    @property
+    def SELECTED_TAB_YOUR_LANGUAGES(self):
+        return self._SELECTED_TAB_YOUR_LANGUAGES
+
+    @SELECTED_TAB_YOUR_LANGUAGES.setter
+    def SELECTED_TAB_YOUR_LANGUAGES(self, value):
+        if type(value) is dict:
+            self._SELECTED_TAB_YOUR_LANGUAGES = value
+            saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
+
+    @property
+    def SELECTED_TAB_TARGET_LANGUAGES(self):
+        return self._SELECTED_TAB_TARGET_LANGUAGES
+
+    @SELECTED_TAB_TARGET_LANGUAGES.setter
+    def SELECTED_TAB_TARGET_LANGUAGES(self, value):
+        if type(value) is dict:
+            self._SELECTED_TAB_TARGET_LANGUAGES = value
+            saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
+
     def init_config(self):
         self._VERSION = "1.3.2"
         self._PATH_CONFIG = "./config.json"
@@ -445,13 +455,12 @@ class Config:
         self._FONT_FAMILY = "Yu Gothic UI"
         self._UI_LANGUAGE = "en"
         self._CHOICE_TRANSLATOR = translatorEngine[0]
-        self._INPUT_SOURCE_LANG = list(translation_lang[self.CHOICE_TRANSLATOR]["source"].keys())[0]
+        self._SOURCE_LANGUAGE = "Japanese"
-        self._INPUT_TARGET_LANG = list(translation_lang[self.CHOICE_TRANSLATOR]["target"].keys())[1]
+        self._SOURCE_COUNTRY = "Japan"
-        self._OUTPUT_SOURCE_LANG = list(translation_lang[self.CHOICE_TRANSLATOR]["source"].keys())[1]
+        self._TARGET_LANGUAGE = "English"
-        self._OUTPUT_TARGET_LANG = list(translation_lang[self.CHOICE_TRANSLATOR]["target"].keys())[0]
+        self._TARGET_COUNTRY = "United States"
         self._CHOICE_MIC_HOST = getDefaultInputDevice()["host"]["name"]
         self._CHOICE_MIC_DEVICE = getDefaultInputDevice()["device"]["name"]
-        self._INPUT_MIC_VOICE_LANGUAGE = list(transcription_lang.keys())[0]
         self._INPUT_MIC_ENERGY_THRESHOLD = 300
         self._INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD = True
         self._INPUT_MIC_RECORD_TIMEOUT = 3
@@ -459,7 +468,6 @@ class Config:
         self._INPUT_MIC_MAX_PHRASES = 10
         self._INPUT_MIC_WORD_FILTER = []
         self._CHOICE_SPEAKER_DEVICE = getDefaultOutputDevice()["name"]
-        self._INPUT_SPEAKER_VOICE_LANGUAGE = list(transcription_lang.keys())[1]
         self._INPUT_SPEAKER_ENERGY_THRESHOLD = 300
         self._INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD = True
         self._INPUT_SPEAKER_RECORD_TIMEOUT = 3
@@ -485,6 +493,17 @@ class Config:
         ]
         self._MAX_MIC_ENERGY_THRESHOLD = 2000
         self._MAX_SPEAKER_ENERGY_THRESHOLD = 4000
+        self._SELECTED_TAB_NO = "1"
+        self._SELECTED_TAB_YOUR_LANGUAGES = {
+            "1":"Japanese\n(Japan)",
+            "2":"Japanese\n(Japan)",
+            "3":"Japanese\n(Japan)",
+        }
+        self._SELECTED_TAB_TARGET_LANGUAGES = {
+            "1":"English\n(United States)",
+            "2":"English\n(United States)",
+            "3":"English\n(United States)",
+        }
 
     def load_config(self):
         if os_path.isfile(self.PATH_CONFIG) is not False:

main.py

@@ -1,8 +1,10 @@
 from threading import Thread
 import customtkinter
+from customtkinter import StringVar
 from vrct_gui import vrct_gui
 from config import config
 from model import model
+from vrct_gui.ui_utils import setDefaultActiveTab
 
 # func transcription send message
 def sendMicMessage(message):
@@ -117,6 +119,73 @@ def foregroundOnForcefully(e):
     if config.ENABLE_FOREGROUND:
         vrct_gui.attributes("-topmost", True)
 
+# func select languages
+def setYourLanguageAndCountry(select):
+    languages = config.SELECTED_TAB_YOUR_LANGUAGES
+    languages[config.SELECTED_TAB_NO] = select
+    config.SELECTED_TAB_YOUR_LANGUAGES = languages
+    language, country = model.getLanguageAndCountry(select)
+    config.SOURCE_LANGUAGE = language
+    config.SOURCE_COUNTRY = country
+    config.CHOICE_TRANSLATOR = model.findTranslationEngine(config.SOURCE_LANGUAGE, config.TARGET_LANGUAGE)
+
+def setTargetLanguageAndCountry(select):
+    languages = config.SELECTED_TAB_TARGET_LANGUAGES
+    languages[config.SELECTED_TAB_NO] = select
+    config.SELECTED_TAB_TARGET_LANGUAGES = languages
+    language, country = model.getLanguageAndCountry(select)
+    config.TARGET_LANGUAGE = language
+    config.TARGET_COUNTRY = country
+    config.CHOICE_TRANSLATOR = model.findTranslationEngine(config.SOURCE_LANGUAGE, config.TARGET_LANGUAGE)
+
+def callbackSelectedTabNo1():
+    config.SELECTED_TAB_NO = "1"
+    vrct_gui.YOUR_LANGUAGE = config.SELECTED_TAB_YOUR_LANGUAGES[config.SELECTED_TAB_NO]
+    vrct_gui.TARGET_LANGUAGE = config.SELECTED_TAB_TARGET_LANGUAGES[config.SELECTED_TAB_NO]
+    languages = config.SELECTED_TAB_YOUR_LANGUAGES
+    select = languages[config.SELECTED_TAB_NO]
+    language, country = model.getLanguageAndCountry(select)
+    config.SOURCE_LANGUAGE = language
+    config.SOURCE_COUNTRY = country
+    languages = config.SELECTED_TAB_TARGET_LANGUAGES
+    select = languages[config.SELECTED_TAB_NO]
+    language, country = model.getLanguageAndCountry(select)
+    config.TARGET_LANGUAGE = language
+    config.TARGET_COUNTRY = country
+    config.CHOICE_TRANSLATOR = model.findTranslationEngine(config.SOURCE_LANGUAGE, config.TARGET_LANGUAGE)
+
+def callbackSelectedTabNo2():
+    config.SELECTED_TAB_NO = "2"
+    vrct_gui.YOUR_LANGUAGE = config.SELECTED_TAB_YOUR_LANGUAGES[config.SELECTED_TAB_NO]
+    vrct_gui.TARGET_LANGUAGE = config.SELECTED_TAB_TARGET_LANGUAGES[config.SELECTED_TAB_NO]
+    languages = config.SELECTED_TAB_YOUR_LANGUAGES
+    select = languages[config.SELECTED_TAB_NO]
+    language, country = model.getLanguageAndCountry(select)
+    config.SOURCE_LANGUAGE = language
+    config.SOURCE_COUNTRY = country
+    languages = config.SELECTED_TAB_TARGET_LANGUAGES
+    select = languages[config.SELECTED_TAB_NO]
+    language, country = model.getLanguageAndCountry(select)
+    config.TARGET_LANGUAGE = language
+    config.TARGET_COUNTRY = country
+    config.CHOICE_TRANSLATOR = model.findTranslationEngine(config.SOURCE_LANGUAGE, config.TARGET_LANGUAGE)
+
+def callbackSelectedTabNo3():
+    config.SELECTED_TAB_NO = "3"
+    vrct_gui.YOUR_LANGUAGE = config.SELECTED_TAB_YOUR_LANGUAGES[config.SELECTED_TAB_NO]
+    vrct_gui.TARGET_LANGUAGE = config.SELECTED_TAB_TARGET_LANGUAGES[config.SELECTED_TAB_NO]
+    languages = config.SELECTED_TAB_YOUR_LANGUAGES
+    select = languages[config.SELECTED_TAB_NO]
+    language, country = model.getLanguageAndCountry(select)
+    config.SOURCE_LANGUAGE = language
+    config.SOURCE_COUNTRY = country
+    languages = config.SELECTED_TAB_TARGET_LANGUAGES
+    select = languages[config.SELECTED_TAB_NO]
+    language, country = model.getLanguageAndCountry(select)
+    config.TARGET_LANGUAGE = language
+    config.TARGET_COUNTRY = country
+    config.CHOICE_TRANSLATOR = model.findTranslationEngine(config.SOURCE_LANGUAGE, config.TARGET_LANGUAGE)
+
 # func print textbox
 def logTranslationStatusChange():
     textbox_all = getattr(vrct_gui, "textbox_all")
@@ -138,6 +207,16 @@ def logTranscriptionSendStatusChange():
         vrct_gui.printToTextbox(textbox_all, "Voice2chatbox機能をOFFにしました", "", "INFO")
         vrct_gui.printToTextbox(textbox_system, "Voice2chatbox機能をOFFにしました", "", "INFO")
 
+def logTranscriptionReceiveStatusChange():
+    textbox_all = getattr(vrct_gui, "textbox_all")
+    textbox_system = getattr(vrct_gui, "textbox_system")
+    if config.ENABLE_TRANSCRIPTION_RECEIVE is True:
+        vrct_gui.printToTextbox(textbox_all, "Speaker2chatbox機能をONにしました", "", "INFO")
+        vrct_gui.printToTextbox(textbox_system, "Speaker2chatbox機能をONにしました", "", "INFO")
+    else:
+        vrct_gui.printToTextbox(textbox_all, "Speaker2chatbox機能をOFFにしました", "", "INFO")
+        vrct_gui.printToTextbox(textbox_system, "Speaker2chatbox機能をOFFにしました", "", "INFO")
+
 def logSendMessage(message, translate):
     textbox_all = getattr(vrct_gui, "textbox_all")
     textbox_sent = getattr(vrct_gui, "textbox_sent")
@@ -179,11 +258,11 @@ def logForegroundStatusChange():
         vrct_gui.printToTextbox(textbox_system, "Stop foreground", "", "INFO")
 
 # command func
-def toggleTranslationFeature():
+def callbackToggleTranslation():
     config.ENABLE_TRANSLATION = getattr(vrct_gui, "translation_switch_box").get()
     logTranslationStatusChange()
 
-def toggleTranscriptionSendFeature():
+def callbackToggleTranscriptionSend():
     vrct_gui.changeMainWindowWidgetsStatus("disabled", "All")
     config.ENABLE_TRANSCRIPTION_SEND = getattr(vrct_gui, "transcription_send_switch_box").get()
     if config.ENABLE_TRANSCRIPTION_SEND is True:
@@ -196,7 +275,7 @@ def toggleTranscriptionSendFeature():
         th_stopTranscriptionSendMessage.start()
     logTranscriptionSendStatusChange()
 
-def toggleTranscriptionReceiveFeature():
+def callbackToggleTranscriptionReceive():
     vrct_gui.changeMainWindowWidgetsStatus("disabled", "All")
     config.ENABLE_TRANSCRIPTION_RECEIVE = getattr(vrct_gui, "transcription_receive_switch_box").get()
     if config.ENABLE_TRANSCRIPTION_RECEIVE is True:
@@ -207,9 +286,9 @@ def toggleTranscriptionReceiveFeature():
         th_stopTranscriptionReceiveMessage = Thread(target=stopTranscriptionReceiveMessage)
         th_stopTranscriptionReceiveMessage.daemon = True
         th_stopTranscriptionReceiveMessage.start()
-    logTranscriptionSendStatusChange()
+    logTranscriptionReceiveStatusChange()
 
-def toggleForegroundFeature():
+def callbackToggleForeground():
     config.ENABLE_FOREGROUND = getattr(vrct_gui, "foreground_switch_box").get()
     if config.ENABLE_FOREGROUND is True:
         vrct_gui.attributes("-topmost", True)
@@ -234,15 +313,11 @@ model.checkOSCStarted()
 # check Software Updated
 model.checkSoftwareUpdated()
 
-# set commands
+# set UI and callback
-translation_switch_box = getattr(vrct_gui, "translation_switch_box")
+vrct_gui.CALLBACK_TOGGLE_TRANSLATION = callbackToggleTranslation
-translation_switch_box.configure(command=toggleTranslationFeature)
+vrct_gui.CALLBACK_TOGGLE_TRANSCRIPTION_SEND = callbackToggleTranscriptionSend
-transcription_send_switch_box = getattr(vrct_gui, "transcription_send_switch_box")
+vrct_gui.CALLBACK_TOGGLE_TRANSCRIPTION_RECEIVE = callbackToggleTranscriptionReceive
-transcription_send_switch_box.configure(command=toggleTranscriptionSendFeature)
+vrct_gui.CALLBACK_TOGGLE_FOREGROUND = callbackToggleForeground
-transcription_receive_switch_box = getattr(vrct_gui, "transcription_receive_switch_box")
-transcription_receive_switch_box.configure(command=toggleTranscriptionReceiveFeature)
-foreground_switch_box = getattr(vrct_gui, "foreground_switch_box")
-foreground_switch_box.configure(command=toggleForegroundFeature)
 
 entry_message_box = getattr(vrct_gui, "entry_message_box")
 entry_message_box.bind("<Return>", messageBoxPressKeyEnter)
@@ -250,5 +325,26 @@ entry_message_box.bind("<Any-KeyPress>", messageBoxPressKeyAny)
 entry_message_box.bind("<FocusIn>", foregroundOffForcefully)
 entry_message_box.bind("<FocusOut>", foregroundOnForcefully)
 
+sqls__optionmenu_your_language = getattr(vrct_gui, "sqls__optionmenu_your_language")
+sqls__optionmenu_your_language.configure(values=model.getListLanguageAndCountry())
+sqls__optionmenu_your_language.configure(command=setYourLanguageAndCountry)
+sqls__optionmenu_your_language.configure(variable=StringVar(value=config.SELECTED_TAB_YOUR_LANGUAGES[config.SELECTED_TAB_NO]))
+
+sqls__optionmenu_target_language = getattr(vrct_gui, "sqls__optionmenu_target_language")
+sqls__optionmenu_target_language.configure(values=model.getListLanguageAndCountry())
+sqls__optionmenu_target_language.configure(command=setTargetLanguageAndCountry)
+sqls__optionmenu_target_language.configure(variable=StringVar(value=config.SELECTED_TAB_TARGET_LANGUAGES[config.SELECTED_TAB_NO]))
+
+vrct_gui.CALLBACK_SELECTED_TAB_NO_1 = callbackSelectedTabNo1
+vrct_gui.CALLBACK_SELECTED_TAB_NO_2 = callbackSelectedTabNo2
+vrct_gui.CALLBACK_SELECTED_TAB_NO_3 = callbackSelectedTabNo3
+
+vrct_gui.current_active_preset_tab = getattr(vrct_gui, f"sqls__presets_button_{config.SELECTED_TAB_NO}")
+setDefaultActiveTab(
+    active_tab_widget=vrct_gui.current_active_preset_tab,
+    active_bg_color=vrct_gui.settings.main.ctm.SQLS__PRESETS_TAB_BG_ACTIVE_COLOR,
+    active_text_color=vrct_gui.settings.main.ctm.SQLS__PRESETS_TAB_ACTIVE_TEXT_COLOR
+)
+
 if __name__ == "__main__":
     vrct_gui.startMainLoop()

model.py

@@ -11,6 +11,8 @@ from models.transcription.transcription_recorder import SelectedMicRecorder, Sel
 from models.transcription.transcription_recorder import SelectedMicEnergyRecorder, SelectedSpeakeEnergyRecorder
 from models.transcription.transcription_transcriber import AudioTranscriber
 from models.xsoverlay.notification import xsoverlayForVRCT
+from models.translation.translation_languages import translatorEngine, translation_lang
+from models.transcription.transcription_languages import transcription_lang
 from config import config
 
 class threadFnc(Thread):
@@ -29,6 +31,15 @@ class threadFnc(Thread):
             self.fnc(*self._args, **self._kwargs)
 
 class Model:
+    # Languages available for both transcription and translation
+    SUPPORTED_LANGUAGES = [
+        'Afrikaans', 'Arabic', 'Basque', 'Bulgarian', 'Catalan', 'Chinese', 'Croatian',
+        'Czech', 'Danish', 'Dutch', 'English', 'Filipino', 'Finnish', 'French', 'German',
+        'Greek', 'Hebrew', 'Hindi', 'Hungarian', 'Indonesian', 'Italian', 'Japanese',
+        'Korean', 'Lithuanian', 'Malay', 'Norwegian', 'Polish', 'Portuguese', 'Romanian',
+        'Russian', 'Serbian', 'Slovak', 'Slovenian', 'Spanish', 'Swedish', 'Thai', 'Turkish',
+        'Ukrainian', 'Vietnamese'
+        ]
     _instance = None
 
     def __new__(cls):
@@ -66,6 +77,31 @@ class Model:
             config.AUTH_KEYS = auth_keys
         return result
 
+    @staticmethod
+    def getListLanguageAndCountry():
+        langs = []
+        for lang in model.SUPPORTED_LANGUAGES:
+            for country in transcription_lang[lang]:
+                langs.append(f"{lang}\n({country})")
+        return langs
+
+    @staticmethod
+    def getLanguageAndCountry(select):
+        parts = select.split("\n")
+        language = parts[0]
+        country = parts[1][1:-1]
+        return language, country
+
+    @staticmethod
+    def findTranslationEngine(source_lang, target_lang):
+        compatible_engines = []
+        for engine in translatorEngine:
+            source_languages = translation_lang.get(engine, {}).get("source", {})
+            target_languages = translation_lang.get(engine, {}).get("target", {})
+            if source_lang in source_languages and target_lang in target_languages:
+                compatible_engines.append(engine)
+        return compatible_engines[0]
+
     def getTranslatorStatus(self):
         return self.translator.translator_status[config.CHOICE_TRANSLATOR]
 
@@ -75,8 +111,8 @@ class Model:
     def getInputTranslate(self, message):
         translation = self.translator.translate(
                         translator_name=config.CHOICE_TRANSLATOR,
-                        source_language=config.INPUT_SOURCE_LANG,
+                        source_language=config.SOURCE_LANGUAGE,
-                        target_language=config.INPUT_TARGET_LANG,
+                        target_language=config.TARGET_LANGUAGE,
                         message=message
                 )
         return translation
@@ -84,8 +120,8 @@ class Model:
     def getOutputTranslate(self, message):
         translation = self.translator.translate(
                         translator_name=config.CHOICE_TRANSLATOR,
-                        source_language=config.OUTPUT_SOURCE_LANG,
+                        source_language=config.TARGET_LANGUAGE,
-                        target_language=config.OUTPUT_TARGET_LANG,
+                        target_language=config.SOURCE_LANGUAGE,
                         message=message
                 )
         return translation
@@ -170,7 +206,7 @@ class Model:
             max_phrases=config.INPUT_MIC_MAX_PHRASES,
         )
         def sendMicTranscript():
-            mic_transcriber.transcribeAudioQueue(mic_audio_queue, config.INPUT_MIC_VOICE_LANGUAGE)
+            mic_transcriber.transcribeAudioQueue(mic_audio_queue, config.SOURCE_LANGUAGE, config.SOURCE_COUNTRY)
             message = mic_transcriber.getTranscript()
             fnc(message)
 
@@ -222,7 +258,7 @@ class Model:
             max_phrases=config.INPUT_SPEAKER_MAX_PHRASES,
         )
         def sendSpkTranscript():
-            spk_transcriber.transcribeAudioQueue(spk_audio_queue, config.INPUT_SPEAKER_VOICE_LANGUAGE)
+            spk_transcriber.transcribeAudioQueue(spk_audio_queue, config.TARGET_LANGUAGE, config.TARGET_COUNTRY)
             message = spk_transcriber.getTranscript()
             fnc(message)
 

models/transcription/transcription_languages.py

@@ -1,91 +1,177 @@
 transcription_lang = {
-    "Japanese (Japan)":"ja-JP",
+    "Afrikaans":{
-    "English (United States)":"en-US",
+        "South Africa":"af-ZA",
-    "English (United Kingdom)":"en-GB",
+    },
-    "Afrikaans (South Africa)":"af-ZA",
+    "Arabic":{
-    "Arabic (Algeria)":"ar-DZ",
+        "Algeria":"ar-DZ",
-    "Arabic (Bahrain)":"ar-BH",
+        "Bahrain":"ar-BH",
-    "Arabic (Egypt)":"ar-EG",
+        "Egypt":"ar-EG",
-    "Arabic (Israel)":"ar-IL",
+        "Israel":"ar-IL",
-    "Arabic (Iraq)":"ar-IQ",
+        "Iraq":"ar-IQ",
-    "Arabic (Jordan)":"ar-JO",
+        "Jordan":"ar-JO",
-    "Arabic (Kuwait)":"ar-KW",
+        "Kuwait":"ar-KW",
-    "Arabic (Lebanon)":"ar-LB",
+        "Lebanon":"ar-LB",
-    "Arabic (Morocco)":"ar-MA",
+        "Morocco":"ar-MA",
-    "Arabic (Oman)":"ar-OM",
+        "Oman":"ar-OM",
-    "Arabic (State of Palestine)":"ar-PS",
+        "State of Palestine":"ar-PS",
-    "Arabic (Qatar)":"ar-QA",
+        "Qatar":"ar-QA",
-    "Arabic (Saudi Arabia)":"ar-SA",
+        "Saudi Arabia":"ar-SA",
-    "Arabic (Tunisia)":"ar-TN",
+        "Tunisia":"ar-TN",
-    "Arabic (United Arab Emirates)":"ar-AE",
+        "United Arab Emirates":"ar-AE",
-    "Basque (Spain)":"eu-ES",
+    },
-    "Bulgarian (Bulgaria)":"bg-BG",
+    "Basque":{
-    "Catalan (Spain)":"ca-ES",
+        "Spain":"eu-ES",
-    "Chinese, Mandarin (Simplified, China)":"cmn-Hans-CN",
+    },
-    "Chinese, Mandarin (Simplified, Hong Kong)":"cmn-Hans-HK",
+    "Bulgarian":{
-    "Chinese, Mandarin (Traditional, Taiwan)":"cmn-Hant-TW",
+        "Bulgaria":"bg-BG",
-    "Chinese, Cantonese (Traditional Hong Kong)":"yue-Hant-HK",
+    },
-    "Croatian (Croatia)":"hr-HR",
+    "Catalan":{
-    "Czech (Czech Republic)":"cs-CZ",
+        "Spain":"ca-ES",
-    "Danish (Denmark)":"da-DK",
+    },
-    "English (Australia)":"en-AU",
+    "Chinese":{
-    "English (Canada)":"en-CA",
+        "Mandarin (Simplified, China)":"cmn-Hans-CN",
-    "English (India)":"en-IN",
+        "Mandarin (Simplified, Hong Kong)":"cmn-Hans-HK",
-    "English (Ireland)":"en-IE",
+        "Mandarin (Traditional, Taiwan)":"cmn-Hant-TW",
-    "English (New Zealand)":"en-NZ",
+        "Cantonese (Traditional Hong Kong)":"yue-Hant-HK",
-    "English (Philippines)":"en-PH",
+    },
-    "English (South Africa)":"en-ZA",
+    "Croatian":{
-    "Persian (Iran)":"fa-IR",
+        "Croatia":"hr-HR",
-    "French (France)":"fr-FR",
+    },
-    "Filipino (Philippines)":"fil-PH",
+    "Czech":{
-    "Galician (Spain)":"gl-ES",
+        "Czech Republic":"cs-CZ",
-    "German (Germany)":"de-DE",
+    },
-    "Greek (Greece)":"el-GR",
+    "Danish":{
-    "Finnish (Finland)":"fi-FI",
+        "Denmark":"da-DK",
-    "Hebrew (Israel)":"he-IL",
+    },
-    "Hindi (India)":"hi-IN",
+    "Dutch":{
-    "Hungarian (Hungary)":"hu-HU",
+        "Netherlands":"nl-NL",
-    "Indonesian (Indonesia)":"id-ID",
+    },
-    "Icelandic (Iceland)":"is-IS",
+    "English": {
-    "Italian (Italy)":"it-IT",
+        "United States":"en-US",
-    "Italian (Switzerland)":"it-CH",
+        "United Kingdom":"en-GB",
-    "Korean (South Korea)":"ko-KR",
+        "Australia":"en-AU",
-    "Lithuanian (Lithuania)":"lt-LT",
+        "Canada":"en-CA",
-    "Malay (Malaysia)":"ms-MY",
+        "India":"en-IN",
-    "Dutch (Netherlands)":"nl-NL",
+        "Ireland":"en-IE",
-    "Norwegian Bokmål (Norway)":"nb-NO",
+        "New Zealand":"en-NZ",
-    "Polish (Poland)":"pl-PL",
+        "Philippines":"en-PH",
-    "Portuguese (Brazil)":"pt-BR",
+        "South Africa":"en-ZA",
-    "Portuguese (Portugal)":"pt-PT",
+    },
-    "Romanian (Romania)":"ro-RO",
+    "Filipino":{
-    "Russian (Russia)":"ru-RU",
+        "Philippines":"fil-PH",
-    "Serbian (Serbia)":"sr-RS",
+    },
-    "Slovak (Slovakia)":"sk-SK",
+    "Finnish":{
-    "Slovenian (Slovenia)":"sl-SI",
+        "Finland":"fi-FI",
-    "Spanish (Argentina)":"es-AR",
+    },
-    "Spanish (Bolivia)":"es-BO",
+    "French":{
-    "Spanish (Chile)":"es-CL",
+        "France":"fr-FR",
-    "Spanish (Colombia)":"es-CO",
+    },
-    "Spanish (Costa Rica)":"es-CR",
+    "Galician":{
-    "Spanish (Dominican Republic)":"es-DO",
+        "Spain":"gl-ES",
-    "Spanish (Ecuador)":"es-EC",
+    },
-    "Spanish (El Salvador)":"es-SV",
+    "German":{
-    "Spanish (Guatemala)":"es-GT",
+        "Germany":"de-DE",
-    "Spanish (Honduras)":"es-HN",
+    },
-    "Spanish (Mexico)":"es-MX",
+    "Greek":{
-    "Spanish (Nicaragua)":"es-NI",
+        "Greece":"el-GR",
-    "Spanish (Panama)":"es-PA",
+    },
-    "Spanish (Paraguay)":"es-PY",
+    "Hebrew":{
-    "Spanish (Peru)":"es-PE",
+        "Israel":"he-IL",
-    "Spanish (Puerto Rico)":"es-PR",
+    },
-    "Spanish (Spain)":"es-ES",
+    "Hindi": {
-    "Spanish (Uruguay)":"es-UY",
+        "India":"hi-IN",
-    "Spanish (United States)":"es-US",
+    },
-    "Spanish (Venezuela)":"es-VE",
+    "Hungarian":{
-    "Swedish (Sweden)":"sv-SE",
+        "Hungary":"hu-HU",
-    "Thai (Thailand)":"th-TH",
+    },
-    "Turkish (Turkey)":"tr-TR",
+    "Indonesian":{
-    "Ukrainian (Ukraine)":"uk-UA",
+        "Indonesia":"id-ID",
-    "Vietnamese (Vietnam)":"vi-VN",
+    },
-    "Zulu (South Africa)":"zu-ZA"
+    "Icelandic":{
+        "Iceland":"is-IS",
+    },
+    "Italian":{
+        "Italy":"it-IT",
+        "Switzerland":"it-CH",
+    },
+    "Japanese":{
+        "Japan":"ja-JP",
+    },
+    "Korean":{
+        "South Korea":"ko-KR",
+    },
+    "Lithuanian":{
+        "Lithuania":"lt-LT",
+    },
+    "Malay":{
+        "Malaysia":"ms-MY",
+    },
+    "Norwegian":{
+        "Norway":"nb-NO",
+    },
+    "Persian":{
+        "Iran":"fa-IR",
+    },
+    "Polish":{
+        "Poland":"pl-PL",
+    },
+    "Portuguese":{
+        "Brazil":"pt-BR",
+        "Portugal":"pt-PT",
+    },
+    "Romanian":{
+        "Romania":"ro-RO",
+    },
+    "Russian":{
+        "Russia":"ru-RU",
+    },
+    "Serbian":{
+        "Serbia":"sr-RS",
+    },
+    "Slovak":{
+        "Slovakia":"sk-SK",
+    },
+    "Slovenian":{
+        "Slovenia":"sl-SI",
+    },
+    "Spanish":{
+        "Argentina":"es-AR",
+        "Bolivia":"es-BO",
+        "Chile":"es-CL",
+        "Colombia":"es-CO",
+        "Costa Rica":"es-CR",
+        "Dominican Republic":"es-DO",
+        "Ecuador":"es-EC",
+        "El Salvador":"es-SV",
+        "Guatemala":"es-GT",
+        "Honduras":"es-HN",
+        "Mexico":"es-MX",
+        "Nicaragua":"es-NI",
+        "Panama":"es-PA",
+        "Paraguay":"es-PY",
+        "Peru":"es-PE",
+        "Puerto Rico":"es-PR",
+        "Spain":"es-ES",
+        "Uruguay":"es-UY",
+        "United States":"es-US",
+        "Venezuela":"es-VE",
+    },
+    "Swedish":{
+        "Sweden":"sv-SE",
+    },
+    "Thai":{
+        "Thailand":"th-TH",
+    },
+    "Turkish":{
+        "Turkey":"tr-TR",
+    },
+    "Ukrainian":{
+        "Ukraine":"uk-UA",
+    },
+    "Vietnamese":{
+        "Vietnam":"vi-VN",
+    },
+    "Zulu":{
+        "South Africa":"zu-ZA"
+    },
 }

models/transcription/transcription_transcriber.py

@@ -27,7 +27,7 @@ class AudioTranscriber:
                 "process_data_func": self.processSpeakerData if speaker else self.processSpeakerData
         }
 
-    def transcribeAudioQueue(self, audio_queue, language):
+    def transcribeAudioQueue(self, audio_queue, language, country):
         # while True:
         audio, time_spoken = audio_queue.get()
         self.updateLastSampleAndPhraseStatus(audio, time_spoken)
@@ -37,7 +37,7 @@ class AudioTranscriber:
             # fd, path = tempfile.mkstemp(suffix=".wav")
             # os.close(fd)
             audio_data = self.audio_sources["process_data_func"]()
-            text = self.audio_recognizer.recognize_google(audio_data, language=transcription_lang[language])
+            text = self.audio_recognizer.recognize_google(audio_data, language=transcription_lang[language][country])
         except Exception as e:
             pass
         finally:

models/translation/translation_languages.py

@@ -1,4 +1,5 @@
-translatorEngine = ["DeepL(web)", "DeepL(auth)", "Google(web)", "Bing(web)"]
+# translatorEngine = ["DeepL(web)", "DeepL(auth)", "Google(web)", "Bing(web)"]
+translatorEngine = ["DeepL(web)", "Google(web)", "Bing(web)"]
 translation_lang = {}
 dict_deepl_web_languages = {
     "Japanese":"JA",

vrct_gui/_changeMainWindowWidgetsStatus.py

@@ -85,7 +85,8 @@ def _changeMainWindowWidgetsStatus(vrct_gui, settings, status, target_names):
                     vrct_gui.sqls__container_title.configure(text_color=settings.ctm.SF__TEXT_DISABLED_COLOR)
                     vrct_gui.sqls__title_text_your_language.configure(text_color=settings.ctm.SF__TEXT_DISABLED_COLOR)
                     vrct_gui.sqls__title_text_target_language.configure(text_color=settings.ctm.SF__TEXT_DISABLED_COLOR)
-                    vrct_gui.current_active_preset_tab.children["!ctklabel"].configure(text_color=settings.ctm.SQLS__PRESETS_TAB_ACTIVE_TEXT_COLOR_PASSIVE)
+                    if settings.IS_SIDEBAR_COMPACT_MODE is False:
+                        vrct_gui.current_active_preset_tab.children["!ctklabel"].configure(text_color=settings.ctm.SQLS__PRESETS_TAB_ACTIVE_TEXT_COLOR_PASSIVE)
                     vrct_gui.sqls__optionmenu_your_language.configure(state="disabled")
                     vrct_gui.sqls__optionmenu_target_language.configure(state="disabled")
 
@@ -93,8 +94,9 @@ def _changeMainWindowWidgetsStatus(vrct_gui, settings, status, target_names):
                     vrct_gui.sqls__container_title.configure(text_color=settings.ctm.LABELS_TEXT_COLOR)
                     vrct_gui.sqls__title_text_your_language.configure(text_color=settings.ctm.LABELS_TEXT_COLOR)
                     vrct_gui.sqls__title_text_target_language.configure(text_color=settings.ctm.LABELS_TEXT_COLOR)
-                    vrct_gui.current_active_preset_tab.children["!ctklabel"].configure(text_color=settings.ctm.SQLS__PRESETS_TAB_ACTIVE_TEXT_COLOR)
+                    if settings.IS_SIDEBAR_COMPACT_MODE is False:
-                    vrct_gui.current_active_preset_tab.children["!ctklabel"].configure(text_color=settings.ctm.SQLS__PRESETS_TAB_ACTIVE_TEXT_COLOR)
+                        vrct_gui.current_active_preset_tab.children["!ctklabel"].configure(text_color=settings.ctm.SQLS__PRESETS_TAB_ACTIVE_TEXT_COLOR)
+                        vrct_gui.current_active_preset_tab.children["!ctklabel"].configure(text_color=settings.ctm.SQLS__PRESETS_TAB_ACTIVE_TEXT_COLOR)
                     vrct_gui.sqls__optionmenu_your_language.configure(state="normal")
                     vrct_gui.sqls__optionmenu_target_language.configure(state="normal")
 

vrct_gui/main_window/widgets/create_sidebar.py

@@ -18,30 +18,30 @@ def createSidebar(settings, main_window):
 
 
     def toggleTranslationFeature():
+        if callable(main_window.CALLBACK_TOGGLE_TRANSLATION) is True:
+            main_window.CALLBACK_TOGGLE_TRANSLATION()
         is_turned_on = getattr(main_window, "translation_switch_box").get()
         print(is_turned_on)
         toggleSidebarFeatureSelectedMarkIfTurnedOn(is_turned_on, main_window.translation_selected_mark)
 
     def toggleTranscriptionSendFeature():
+        if callable(main_window.CALLBACK_TOGGLE_TRANSCRIPTION_SEND) is True:
+            main_window.CALLBACK_TOGGLE_TRANSCRIPTION_SEND()
         is_turned_on = getattr(main_window, "transcription_send_switch_box").get()
         print(is_turned_on)
         toggleSidebarFeatureSelectedMarkIfTurnedOn(is_turned_on, main_window.transcription_send_selected_mark)
-        if is_turned_on is True:
-            changeMainWindowWidgetsStatus("disabled", "All")
-            sleep(1.5)
-            changeMainWindowWidgetsStatus("normal", "All")
 
     def toggleTranscriptionReceiveFeature():
+        if callable(main_window.CALLBACK_TOGGLE_TRANSCRIPTION_RECEIVE) is True:
+            main_window.CALLBACK_TOGGLE_TRANSCRIPTION_RECEIVE()
         is_turned_on = getattr(main_window, "transcription_receive_switch_box").get()
         print(is_turned_on)
         toggleSidebarFeatureSelectedMarkIfTurnedOn(is_turned_on, main_window.transcription_receive_selected_mark)
-        if is_turned_on is True:
-            changeMainWindowWidgetsStatus("disabled", "All")
-            sleep(1.5)
-            changeMainWindowWidgetsStatus("normal", "All")
 
 
     def toggleForegroundFeature():
+        if callable(main_window.CALLBACK_TOGGLE_FOREGROUND) is True:
+            main_window.CALLBACK_TOGGLE_FOREGROUND()
         is_turned_on = getattr(main_window, "foreground_switch_box").get()
         print(is_turned_on)
         toggleSidebarFeatureSelectedMarkIfTurnedOn(is_turned_on, main_window.foreground_selected_mark)
@@ -120,22 +120,28 @@ def createSidebar(settings, main_window):
 
     def switchToPreset1(e):
         print("1")
-        main_window.YOUR_LANGUAGE = "Japanese\n(Japan)"
+        if callable(main_window.CALLBACK_SELECTED_TAB_NO_1) is True:
-        main_window.TARGET_LANGUAGE = "English\n(United States)"
+            main_window.CALLBACK_SELECTED_TAB_NO_1()
+        # main_window.YOUR_LANGUAGE = "Japanese\n(Japan)"
+        # main_window.TARGET_LANGUAGE = "English\n(United States)"
         target_active_widget = getattr(main_window, "sqls__presets_button_1")
         switchPresetTabFunction(target_active_widget)
 
     def switchToPreset2(e):
         print("2")
-        main_window.YOUR_LANGUAGE = "English\n(United States)"
+        if callable(main_window.CALLBACK_SELECTED_TAB_NO_2) is True:
-        main_window.TARGET_LANGUAGE = "Japanese\n(Japan)"
+            main_window.CALLBACK_SELECTED_TAB_NO_2()
+        # main_window.YOUR_LANGUAGE = "English\n(United States)"
+        # main_window.TARGET_LANGUAGE = "Japanese\n(Japan)"
         target_active_widget = getattr(main_window, "sqls__presets_button_2")
         switchPresetTabFunction(target_active_widget)
 
     def switchToPreset3(e):
         print("3")
-        main_window.YOUR_LANGUAGE = "Japanese\n(Japan)"
+        if callable(main_window.CALLBACK_SELECTED_TAB_NO_3) is True:
-        main_window.TARGET_LANGUAGE = "Chinese, Cantonese\n(Traditional Hong Kong)"
+            main_window.CALLBACK_SELECTED_TAB_NO_3()
+        # main_window.YOUR_LANGUAGE = "Japanese\n(Japan)"
+        # main_window.TARGET_LANGUAGE = "Chinese, Cantonese\n(Traditional Hong Kong)"
         target_active_widget = getattr(main_window, "sqls__presets_button_3")
         switchPresetTabFunction(target_active_widget)
 
@@ -507,12 +513,12 @@ def createSidebar(settings, main_window):
         column+=1
 
     # Set default active preset tab
-    main_window.current_active_preset_tab = getattr(main_window, "sqls__presets_button_1")
+    # main_window.current_active_preset_tab = getattr(main_window, "sqls__presets_button_1")
-    setDefaultActiveTab(
+    # setDefaultActiveTab(
-        active_tab_widget=main_window.current_active_preset_tab,
+    #     active_tab_widget=main_window.current_active_preset_tab,
-        active_bg_color=settings.ctm.SQLS__PRESETS_TAB_BG_ACTIVE_COLOR,
+    #     active_bg_color=settings.ctm.SQLS__PRESETS_TAB_BG_ACTIVE_COLOR,
-        active_text_color=settings.ctm.SQLS__PRESETS_TAB_ACTIVE_TEXT_COLOR
+    #     active_text_color=settings.ctm.SQLS__PRESETS_TAB_ACTIVE_TEXT_COLOR
-    )
+    # )
 
 
     # Quick Language settings BOX

vrct_gui/vrct_gui.py

@@ -47,6 +47,13 @@ class VRCT_GUI(CTk):
         self.YOUR_LANGUAGE = "Japanese\n(Japan)"
         self.TARGET_LANGUAGE = "English\n(United States)"
 
+        self.CALLBACK_TOGGLE_TRANSLATION = None
+        self.CALLBACK_TOGGLE_TRANSCRIPTION_SEND = None
+        self.CALLBACK_TOGGLE_TRANSCRIPTION_RECEIVE = None
+        self.CALLBACK_TOGGLE_FOREGROUND = None
+        self.CALLBACK_SELECTED_TAB_NO_1 = None
+        self.CALLBACK_SELECTED_TAB_NO_2 = None
+        self.CALLBACK_SELECTED_TAB_NO_3 = None
 
         self.config_window = ConfigWindow(vrct_gui=self, settings=self.settings.config_window)
         # self.information_window = ToplevelWindowInformation(self)