frontengine 0.0.55__py3-none-any.whl → 0.0.57__py3-none-any.whl

frontengine/ui/setting/chat/chatthread.py

@@ -1,78 +0,0 @@
-import asyncio
-import json
-from pathlib import Path
-from queue import Queue
-from threading import Thread
-
-from re_edge_gpt import Chatbot, ConversationStyle
-from PySide6.QtWidgets import QPlainTextEdit
-
-
-class DelegateChat(object):
-
-    def __init__(self):
-        self.chat_bot = None
-        self.style = ConversationStyle.creative
-
-    def new_topic(self, message_panel: QPlainTextEdit):
-        self.chat_bot = None
-        message_panel.clear()
-
-    def change_style(self, style: str):
-        if style == "creative":
-            self.style = ConversationStyle.creative
-        elif style == "precise":
-            self.style = ConversationStyle.precise
-        else:
-            self.style = ConversationStyle.balanced
-
-
-class ChatThread(Thread):
-
-    def __init__(self, chat_send_message: str, locale: str):
-        super().__init__()
-        self.current_message = None
-        self.chat_send_message = chat_send_message
-        PANEL_MESSAGE_QUEUE.put_nowait("Q: " + chat_send_message)
-        self.locale = locale
-        if DELEGATE_CHAT.chat_bot is not None:
-            self.chat_bot = DELEGATE_CHAT.chat_bot
-
-    def run(self) -> None:
-        try:
-            chat_response = dict()
-
-            async def send_chat_async():
-                nonlocal chat_response
-                if DELEGATE_CHAT.chat_bot is None:
-                    cookies = json.loads(open(
-                        str(Path(str(Path.cwd()) + "/bing_cookies.json")), encoding="utf-8").read())
-                    bot = await Chatbot.create(cookies=cookies)
-                    response = await bot.ask(
-                        prompt=self.chat_send_message, conversation_style=DELEGATE_CHAT.style, locale=self.locale
-                    )
-                    chat_response = response
-                    DELEGATE_CHAT.chat_bot = bot
-                else:
-                    response = await DELEGATE_CHAT.chat_bot.ask(
-                        prompt=self.chat_send_message, conversation_style=DELEGATE_CHAT.style)
-                    chat_response = response
-
-            asyncio.run(send_chat_async())
-            self.current_message = chat_response
-            if self.current_message is not None:
-                for text_dict in self.current_message.get("item").get("messages"):
-                    if text_dict.get("author") == "bot":
-                        response_text: str = text_dict.get("text")
-                        if response_text is not None and not response_text.isspace():
-                            MESSAGE_QUEUE.put_nowait(response_text)
-                            PANEL_MESSAGE_QUEUE.put_nowait("A: " + response_text)
-        except Exception as error:
-            EXCEPTION_QUEUE.put_nowait(repr(error))
-            raise error
-
-
-MESSAGE_QUEUE = Queue()
-PANEL_MESSAGE_QUEUE = Queue()
-DELEGATE_CHAT = DelegateChat()
-EXCEPTION_QUEUE = Queue()

frontengine/ui/setting/chat/speech_to_text.py

@@ -1,70 +0,0 @@
-import queue
-import sys
-import time
-
-from PySide6.QtCore import QTimer, Qt
-from PySide6.QtWidgets import QWidget, QPushButton, QBoxLayout, QLineEdit
-from speech_recognition import Microphone
-from speech_recognition import Recognizer
-from speech_recognition import RequestError, UnknownValueError
-from threading import Thread
-
-from frontengine.utils.multi_language.language_wrapper import language_wrapper
-
-LISTENER_QUEUE = queue.Queue()
-
-
-def callback(recognizer: Recognizer, audio):
-    try:
-        text = recognizer.recognize_google(audio)
-        LISTENER_QUEUE.put_nowait(text)
-    except (RequestError, UnknownValueError) as error:
-        print(repr(error), file=sys.stderr)
-
-
-class ChatSpeechToText(QWidget):
-
-    def __init__(self):
-        super().__init__()
-        # UI
-        self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
-        self.box_layout = QBoxLayout(QBoxLayout.Direction.LeftToRight)
-        self.voice_text_edit = QLineEdit()
-        self.start_listen_button = QPushButton(
-            language_wrapper.language_word_dict.get("chat_recognizer_voice_button"))
-        self.start_listen_button.clicked.connect(self.start_listener_thread)
-        self.send_text_button = QPushButton(
-            language_wrapper.language_word_dict.get("chat_scene_send_chat"))
-        self.box_layout.addWidget(self.voice_text_edit)
-        self.box_layout.addWidget(self.start_listen_button)
-        self.box_layout.addWidget(self.send_text_button)
-        self.setLayout(self.box_layout)
-        # Listener Timer
-        self.listener_timer = QTimer()
-        self.listener_timer.setInterval(100)
-        self.listener_timer.timeout.connect(self.update_voice_edit)
-        self.listener_timer.start()
-
-    def start_listener_thread(self):
-        listener_thread = Thread(target=self.start_listener)
-        listener_thread.daemon = True
-        listener_thread.start()
-
-    @classmethod
-    def start_listener(cls):
-        recognizer = Recognizer()
-        microphone = Microphone()
-        with microphone as source:
-            recognizer.adjust_for_ambient_noise(source, duration=0.1)
-        stop_listening = recognizer.listen_in_background(microphone, callback)
-        for receive_sound_time in range(50):
-            time.sleep(0.1)
-        stop_listening(wait_for_stop=False)
-
-    def update_voice_edit(self):
-        if not LISTENER_QUEUE.empty():
-            self.voice_text_edit.setText(str(LISTENER_QUEUE.get_nowait()))
-
-    def close(self) -> bool:
-        self.listener_timer.stop()
-        return super().close()

frontengine/ui/setting/image_generation/generation_image_thread.py

@@ -1,32 +0,0 @@
-import asyncio
-from queue import Queue
-from threading import Thread
-from re_edge_gpt import ImageGenAsync
-
-
-class ImageGenThread(Thread):
-
-    def __init__(self, image_keyword: str):
-        super().__init__()
-        auth_cooker = open("bing_cookies.txt", "r+").read()
-        self.async_gen = ImageGenAsync(auth_cookie=auth_cooker)
-        self.image_keyword = image_keyword
-
-    def run(self) -> None:
-        try:
-            image_list = list()
-
-            async def send_chat_async():
-                nonlocal image_list
-                image_list = await self.async_gen.get_images(self.image_keyword)
-
-            asyncio.run(send_chat_async())
-            for image in image_list:
-                IMAGE_QUEUE.put_nowait(image)
-        except Exception as error:
-            EXCEPTION_QUEUE.put_nowait(repr(error))
-            raise error
-
-
-IMAGE_QUEUE = Queue()
-EXCEPTION_QUEUE = Queue()

frontengine/ui/setting/image_generation/image_generation_input.py

@@ -1,63 +0,0 @@
-from typing import List
-
-import requests
-from PySide6.QtCore import QTimer
-from PySide6.QtGui import QPixmap, Qt
-from PySide6.QtWidgets import QWidget, QPushButton, QLineEdit, QGridLayout, QMessageBox, QPlainTextEdit
-
-from frontengine.show.image_generation.image_generation_show import ImageGenerateShow
-from frontengine.ui.setting.image_generation.generation_image_thread import ImageGenThread, IMAGE_QUEUE
-from frontengine.utils.multi_language.language_wrapper import language_wrapper
-
-
-class ImageGenerationUI(QWidget):
-    def __init__(self):
-        super().__init__()
-        self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
-        # UI
-        self.image_keyword_input = QLineEdit()
-        self.send_text_button = QPushButton()
-        self.send_text_button.setText(language_wrapper.language_word_dict.get("start_generate_image"))
-        self.image_panel = QPlainTextEdit()
-        self.image_panel.setReadOnly(True)
-        self.send_text_button.clicked.connect(self.generate_image)
-        # Layout
-        self.grid_layout = QGridLayout()
-        self.grid_layout.setContentsMargins(0, 0, 0, 0)
-        self.grid_layout.addWidget(self.image_keyword_input, 0, 0)
-        self.grid_layout.addWidget(self.send_text_button, 0, 1)
-        self.grid_layout.addWidget(self.image_panel, 1, 0, -1, -1)
-        self.setLayout(self.grid_layout)
-        # Pull image timer
-        self.pull_image_timer = QTimer()
-        self.pull_image_timer.setInterval(1000)
-        self.pull_image_timer.timeout.connect(self.get_image)
-        self.pull_image_timer.start()
-        # Manage show
-        self.show_list: List[QWidget] = list()
-
-    def generate_image(self):
-        if self.image_keyword_input.text() == "" or self.image_keyword_input.text().isspace():
-            input_error_message = QMessageBox(self)
-            input_error_message.setText(language_wrapper.language_word_dict.get("input_error"))
-            input_error_message.show()
-        else:
-            image_thread = ImageGenThread(self.image_keyword_input.text())
-            image_thread.daemon = True
-            image_thread.start()
-
-    def get_image(self):
-        if not IMAGE_QUEUE.empty():
-            image_link = IMAGE_QUEUE.get_nowait()
-            image_response = requests.get(image_link)
-            image = QPixmap()
-            image.loadFromData(image_response.content)
-            image_show = ImageGenerateShow(image, image_link)
-            self.show_list.append(image_show)
-            image_show.show()
-            self.image_panel.appendPlainText(image_link)
-
-    def close(self) -> bool:
-        for widget in self.show_list:
-            widget.close()
-        return super().close()

frontengine/ui/setting/scene_setting/scene_setting_ui.py

@@ -1,48 +0,0 @@
-from typing import Union
-
-from PySide6.QtCore import Qt
-from PySide6.QtWidgets import QWidget, QGridLayout, QTabWidget
-
-from frontengine.show.scene.scene import SceneManager
-from frontengine.ui.setting.scene_setting.scene_tabs.Image import ImageSceneSettingUI
-from frontengine.ui.setting.scene_setting.scene_tabs.gif import GIFSceneSettingUI
-from frontengine.ui.setting.scene_setting.scene_tabs.scene_control import SceneControlSettingUI
-from frontengine.ui.setting.scene_setting.scene_tabs.sound import SoundSceneSettingUI
-from frontengine.ui.setting.scene_setting.scene_tabs.text import TextSceneSettingUI
-from frontengine.ui.setting.scene_setting.scene_tabs.ui import UISceneSettingUI
-from frontengine.ui.setting.scene_setting.scene_tabs.video import VideoSceneSettingUI
-from frontengine.ui.setting.scene_setting.scene_tabs.web import WEBSceneSettingUI
-from frontengine.utils.multi_language.language_wrapper import language_wrapper
-
-
-class SceneSettingUI(QWidget):
-
-    def __init__(self):
-        super().__init__()
-        self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
-        self.grid_layout = QGridLayout()
-        self.grid_layout.setContentsMargins(0, 0, 0, 0)
-        # Init variable
-        self.scene: Union[None, SceneManager] = None
-        self.scene_control_setting = SceneControlSettingUI()
-        # Tab widget
-        self.tab_widget = QTabWidget(self)
-        self.tab_widget.addTab(
-            SceneControlSettingUI(), language_wrapper.language_word_dict.get("scene_control_panel"))
-        self.tab_widget.addTab(
-            ImageSceneSettingUI(), language_wrapper.language_word_dict.get("tab_image_text"))
-        self.tab_widget.addTab(
-            GIFSceneSettingUI(), language_wrapper.language_word_dict.get("tab_gif_text"))
-        self.tab_widget.addTab(
-            TextSceneSettingUI(), language_wrapper.language_word_dict.get("tab_text_text"))
-        self.tab_widget.addTab(
-            VideoSceneSettingUI(), language_wrapper.language_word_dict.get("tab_video_text"))
-        self.tab_widget.addTab(
-            WEBSceneSettingUI(), language_wrapper.language_word_dict.get("tab_web_text"))
-        self.tab_widget.addTab(
-            SoundSceneSettingUI(), language_wrapper.language_word_dict.get("tab_sound_text"))
-        self.tab_widget.addTab(
-            UISceneSettingUI(), language_wrapper.language_word_dict.get("tab_external_ui"))
-        # Add to layout
-        self.grid_layout.addWidget(self.tab_widget, 0, 0, -1, -1)
-        self.setLayout(self.grid_layout)

frontengine/ui/setting/scene_setting/scene_tabs/Image.py

@@ -1,61 +0,0 @@
-from PySide6.QtCore import Qt
-from PySide6.QtGui import QIntValidator
-from PySide6.QtWidgets import QWidget, QBoxLayout, QPushButton, QSlider, QLabel, QLineEdit, QHBoxLayout
-from frontengine.utils.multi_language.language_wrapper import language_wrapper
-
-from frontengine.ui.dialog.choose_file_dialog import choose_image
-from frontengine.ui.setting.scene_setting.scene_tabs.tableview_model import add_row_data
-from frontengine.utils.logging.loggin_instance import front_engine_logger
-
-
-class ImageSceneSettingUI(QWidget):
-
-    def __init__(self):
-        super().__init__()
-        self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
-        self.box_layout = QBoxLayout(QBoxLayout.Direction.TopToBottom)
-        # Image button
-        self.image_button = QPushButton(
-            language_wrapper.language_word_dict.get("scene_add_image")
-        )
-        self.image_button.clicked.connect(self.add_image)
-        # Opacity slider
-        self.opacity_slider = QSlider()
-        self.opacity_slider.setMinimum(1)
-        self.opacity_slider.setMaximum(100)
-        self.opacity_slider.setTickInterval(1)
-        self.opacity_slider.setValue(20)
-        self.opacity_slider.setOrientation(Qt.Orientation.Horizontal)
-        self.opacity_label = QLabel()
-        self.opacity_label.setText(language_wrapper.language_word_dict.get("Opacity"))
-        self.opacity_box_h_layout = QHBoxLayout()
-        self.opacity_box_h_layout.addWidget(self.opacity_label)
-        self.opacity_box_h_layout.addWidget(self.opacity_slider)
-        # Position x input
-        self.position_x_input_label = QLabel(language_wrapper.language_word_dict.get("position_x"))
-        self.position_x_input = QLineEdit()
-        self.position_x_input.setValidator(QIntValidator(0, 999999, self))
-        self.position_x_layout = QHBoxLayout()
-        self.position_x_layout.addWidget(self.position_x_input_label)
-        self.position_x_layout.addWidget(self.position_x_input)
-        # Position y input
-        self.position_y_input_label = QLabel(language_wrapper.language_word_dict.get("position_y"))
-        self.position_y_input = QLineEdit()
-        self.position_y_input.setValidator(QIntValidator(0, 999999, self))
-        self.position_y_layout = QHBoxLayout()
-        self.position_y_layout.addWidget(self.position_y_input_label)
-        self.position_y_layout.addWidget(self.position_y_input)
-        # Set UI
-        self.box_layout.addLayout(self.opacity_box_h_layout)
-        self.box_layout.addLayout(self.position_x_layout)
-        self.box_layout.addLayout(self.position_y_layout)
-        self.box_layout.addWidget(self.image_button)
-        self.setLayout(self.box_layout)
-
-    def add_image(self) -> None:
-        image_path = choose_image(self)
-        if image_path is not None:
-            row_data = ["IMAGE", image_path, "", "", str(self.opacity_slider.value()), "", "", "", "", "", "",
-                        self.position_x_input.text(), self.position_y_input.text()]
-            front_engine_logger.info(f"add image, param: {row_data}")
-            add_row_data(row_data)

frontengine/ui/setting/scene_setting/scene_tabs/gif.py

@@ -1,74 +0,0 @@
-from PySide6.QtCore import Qt
-from PySide6.QtGui import QIntValidator
-from PySide6.QtWidgets import QWidget, QBoxLayout, QPushButton, QSlider, QLabel, QLineEdit, QHBoxLayout
-from frontengine.utils.multi_language.language_wrapper import language_wrapper
-
-from frontengine.ui.dialog.choose_file_dialog import choose_gif
-from frontengine.ui.setting.scene_setting.scene_tabs.tableview_model import add_row_data
-from frontengine.utils.logging.loggin_instance import front_engine_logger
-
-
-class GIFSceneSettingUI(QWidget):
-
-    def __init__(self):
-        super().__init__()
-        self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
-        self.box_layout = QBoxLayout(QBoxLayout.Direction.TopToBottom)
-        # GIF button
-        self.gif_button = QPushButton(
-            language_wrapper.language_word_dict.get("scene_add_gif")
-        )
-        self.gif_button.clicked.connect(self.add_gif)
-        # Opacity slider
-        self.opacity_slider = QSlider()
-        self.opacity_slider.setMinimum(1)
-        self.opacity_slider.setMaximum(100)
-        self.opacity_slider.setTickInterval(1)
-        self.opacity_slider.setValue(20)
-        self.opacity_slider.setOrientation(Qt.Orientation.Horizontal)
-        self.opacity_label = QLabel()
-        self.opacity_label.setText(language_wrapper.language_word_dict.get("Opacity"))
-        self.opacity_box_h_layout = QHBoxLayout()
-        self.opacity_box_h_layout.addWidget(self.opacity_label)
-        self.opacity_box_h_layout.addWidget(self.opacity_slider)
-        # Speed slider
-        self.speed_slider = QSlider()
-        self.speed_slider.setMinimum(1)
-        self.speed_slider.setMaximum(100)
-        self.speed_slider.setTickInterval(1)
-        self.speed_slider.setValue(100)
-        self.speed_slider.setOrientation(Qt.Orientation.Horizontal)
-        self.speed_label = QLabel()
-        self.speed_label.setText(language_wrapper.language_word_dict.get("Speed"))
-        self.speed_box_h_layout = QHBoxLayout()
-        self.speed_box_h_layout.addWidget(self.speed_label)
-        self.speed_box_h_layout.addWidget(self.speed_slider)
-        # Position x input
-        self.position_x_input_label = QLabel(language_wrapper.language_word_dict.get("position_x"))
-        self.position_x_input = QLineEdit()
-        self.position_x_input.setValidator(QIntValidator(0, 999999, self))
-        self.position_x_layout = QHBoxLayout()
-        self.position_x_layout.addWidget(self.position_x_input_label)
-        self.position_x_layout.addWidget(self.position_x_input)
-        # Position y input
-        self.position_y_input_label = QLabel(language_wrapper.language_word_dict.get("position_y"))
-        self.position_y_input = QLineEdit()
-        self.position_y_input.setValidator(QIntValidator(0, 999999, self))
-        self.position_y_layout = QHBoxLayout()
-        self.position_y_layout.addWidget(self.position_y_input_label)
-        self.position_y_layout.addWidget(self.position_y_input)
-        # Set UI
-        self.box_layout.addLayout(self.opacity_box_h_layout)
-        self.box_layout.addLayout(self.speed_box_h_layout)
-        self.box_layout.addLayout(self.position_x_layout)
-        self.box_layout.addLayout(self.position_y_layout)
-        self.box_layout.addWidget(self.gif_button)
-        self.setLayout(self.box_layout)
-
-    def add_gif(self) -> None:
-        gif_path = choose_gif(self)
-        if gif_path is not None:
-            row_data = ["GIF", gif_path, "", "", str(self.opacity_slider.value()), str(self.speed_slider.value()),
-                        "", "", "", "", "", self.position_x_input.text(), self.position_y_input.text()]
-            front_engine_logger.info(f"add gif, param: {row_data}")
-            add_row_data(row_data)

frontengine/ui/setting/scene_setting/scene_tabs/scene_control.py

@@ -1,77 +0,0 @@
-from typing import Dict, Callable
-
-from PySide6.QtCore import Qt
-from PySide6.QtWidgets import QWidget, QGridLayout, QPushButton, QHeaderView, QTableView, QScrollArea
-
-from frontengine.show.scene.scene import SceneManager
-from frontengine.ui.setting.scene_setting.scene_tabs.tableview_model import tableview_model, output_scene_as_json, \
-    load_scene_json
-from frontengine.utils.logging.loggin_instance import front_engine_logger
-from frontengine.utils.multi_language.language_wrapper import language_wrapper
-
-
-class SceneControlSettingUI(QWidget):
-
-    def __init__(self):
-        super().__init__()
-        self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
-        self.grad_layout = QGridLayout()
-        self.param_key_name_list = [
-            "widget_type", "file_path", "url", "text", "opacity", "speed", "volume", "font_size", "play_rate",
-            "web_setting_open_local_file", "web_setting_open_enable_input", "position_x", "position_y"
-        ]
-        # Use to build component
-        self.scene = SceneManager()
-        self.scene_component: Dict[str, Callable] = {
-            "IMAGE": self.scene.add_image,
-            "GIF": self.scene.add_gif,
-            "SOUND": self.scene.add_sound,
-            "TEXT": self.scene.add_text,
-            "VIDEO": self.scene.add_video,
-            "WEB": self.scene.add_web,
-            "EXTEND_UI_FILE": self.scene.add_extend_ui_file
-        }
-        # Tableview
-        self.scene_table_view = QTableView()
-        self.scene_table_view_scroll_area = QScrollArea()
-        self.scene_table_view_scroll_area.setWidgetResizable(True)
-        self.scene_table_view_scroll_area.setViewportMargins(0, 0, 0, 0)
-        self.scene_table_view_scroll_area.setWidget(self.scene_table_view)
-        # Set resize as content
-        self.scene_table_view.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.ResizeToContents)
-        self.scene_table_view.verticalHeader().setSectionResizeMode(QHeaderView.ResizeMode.ResizeToContents)
-        self.scene_table_view.setModel(tableview_model)
-        # Scene output & input
-        self.scene_output_button = QPushButton(language_wrapper.language_word_dict.get("scene_output"))
-        self.scene_output_button.clicked.connect(output_scene_as_json)
-        self.scene_input_button = QPushButton(language_wrapper.language_word_dict.get("scene_input"))
-        self.scene_input_button.clicked.connect(load_scene_json)
-        # Start button
-        self.start_button = QPushButton(
-            language_wrapper.language_word_dict.get("scene_setting_start_scene_button")
-        )
-        self.start_button.clicked.connect(self.start_scene)
-        # Add to layout
-        self.grad_layout.addWidget(self.scene_input_button, 0, 0)
-        self.grad_layout.addWidget(self.scene_output_button, 0, 1)
-        self.grad_layout.addWidget(self.start_button, 0, 2)
-        self.grad_layout.addWidget(self.scene_table_view_scroll_area, 1, 0, -1, -1)
-        self.setLayout(self.grad_layout)
-
-    def close_scene(self) -> None:
-        self.scene.widget_list.clear()
-        self.scene.graphic_view.close()
-
-    def start_scene(self) -> None:
-        front_engine_logger.info("start_scene")
-        for row in range(tableview_model.rowCount()):
-            widget_type_text = tableview_model.item(row, 0).text()
-            add_widget_function = self.scene_component.get(widget_type_text)
-            param_dict: Dict[str, str] = dict()
-            for column in range(1, tableview_model.columnCount()):
-                param = tableview_model.item(row, column).text()
-                if param != "":
-                    param_dict.update({self.param_key_name_list[column]: param})
-            add_widget_function(param_dict)
-            front_engine_logger.info(f"start_scene type: {widget_type_text}, param: {param_dict}")
-        self.scene.show()

frontengine/ui/setting/scene_setting/scene_tabs/sound.py

@@ -1,44 +0,0 @@
-from PySide6.QtCore import Qt
-from PySide6.QtWidgets import QWidget, QBoxLayout, QSlider, QLabel, QHBoxLayout, QPushButton
-
-from frontengine.ui.dialog.choose_file_dialog import choose_player_sound
-from frontengine.ui.setting.scene_setting.scene_tabs.tableview_model import add_row_data
-from frontengine.utils.logging.loggin_instance import front_engine_logger
-from frontengine.utils.multi_language.language_wrapper import language_wrapper
-
-
-class SoundSceneSettingUI(QWidget):
-
-    def __init__(self):
-        super().__init__()
-        self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
-        self.box_layout = QBoxLayout(QBoxLayout.Direction.TopToBottom)
-        # Volume
-        self.volume_slider = QSlider()
-        self.volume_slider.setMinimum(1)
-        self.volume_slider.setMaximum(100)
-        self.volume_slider.setTickInterval(1)
-        self.volume_slider.setValue(100)
-        self.volume_slider.setOrientation(Qt.Orientation.Horizontal)
-        self.volume_label = QLabel()
-        self.volume_label.setText(language_wrapper.language_word_dict.get("Volume"))
-        self.volume_box_h_layout = QHBoxLayout()
-        self.volume_box_h_layout.addWidget(self.volume_label)
-        self.volume_box_h_layout.addWidget(self.volume_slider)
-        # SOUND button
-        self.sound_button = QPushButton(
-            language_wrapper.language_word_dict.get("scene_add_sound")
-        )
-        self.sound_button.clicked.connect(self.add_sound)
-        # Set UI
-        self.box_layout.addLayout(self.volume_box_h_layout)
-        self.box_layout.addWidget(self.sound_button)
-        self.setLayout(self.box_layout)
-
-    def add_sound(self) -> None:
-        sound_path = choose_player_sound(self)
-        if sound_path is not None:
-            row_data = ["SOUND", sound_path, "", "", "", "", str(self.volume_slider.value()),
-                        "", "", "", "", "", ""]
-            front_engine_logger.info(f"add sound, param: {row_data}")
-            add_row_data(row_data)

frontengine/ui/setting/scene_setting/scene_tabs/tableview_model.py

@@ -1,65 +0,0 @@
-from pathlib import Path
-from typing import List
-
-from PySide6.QtGui import QStandardItemModel, QStandardItem
-from PySide6.QtWidgets import QMessageBox
-
-from frontengine.ui.dialog.choose_file_dialog import choose_scene_json
-from frontengine.ui.dialog.save_file_dialog import choose_file_get_save_filename
-from frontengine.utils.json.json_file import write_json, read_json
-from frontengine.utils.multi_language.language_wrapper import language_wrapper
-
-tableview_model = QStandardItemModel()
-
-# Set horizontal label
-label_list = [
-    language_wrapper.language_word_dict.get("scene_table_view_type"),
-    language_wrapper.language_word_dict.get("scene_file_path"),
-    language_wrapper.language_word_dict.get("url"),
-    language_wrapper.language_word_dict.get("text"),
-    language_wrapper.language_word_dict.get("Opacity"),
-    language_wrapper.language_word_dict.get("Speed"),
-    language_wrapper.language_word_dict.get("Volume"),
-    language_wrapper.language_word_dict.get("Font size"),
-    language_wrapper.language_word_dict.get("Play rate"),
-    language_wrapper.language_word_dict.get("web_setting_open_local_file"),
-    language_wrapper.language_word_dict.get("web_setting_open_enable_input"),
-    language_wrapper.language_word_dict.get("position_x"),
-    language_wrapper.language_word_dict.get("position_y"),
-]
-tableview_model.setHorizontalHeaderLabels(label_list)
-
-
-def add_row_data(data_list: List):
-    row = tableview_model.rowCount()
-    for index, data in enumerate(data_list):
-        tableview_model.setItem(row, index, QStandardItem(str(data)))
-
-
-def output_scene_as_json(parent_qt_widget):
-    output_dict = dict()
-    output_setting = list()
-    for row in range(tableview_model.rowCount()):
-        settings = list()
-        for column in range(tableview_model.columnCount()):
-            settings.append(tableview_model.item(row, column).text())
-        output_setting.append(settings)
-    output_dict.update({"settings": output_setting})
-    file_path = choose_file_get_save_filename(parent_qt_widget)
-    if file_path is not None and file_path != "":
-        file_path = Path(file_path)
-        file_path = file_path.with_suffix(".json")
-        write_json(str(file_path), output_dict)
-    else:
-        choose_path_to_output_message_box = QMessageBox(parent_qt_widget)
-        choose_path_to_output_message_box.setText(
-            language_wrapper.language_word_dict.get("scene_choose_output_path_message_box"))
-
-
-def load_scene_json(parent_qt_widget):
-    scene_file = choose_scene_json(parent_qt_widget)
-    if scene_file is not None:
-        scene_setting: dict = read_json(scene_file)
-        scene_setting = scene_setting.get("settings")
-        for setting in scene_setting:
-            add_row_data(setting)