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

frontengine/__init__.py

@@ -18,7 +18,6 @@ from frontengine.ui.page.video.video_setting_ui import VideoSettingUI
 from frontengine.ui.page.control_center.control_center_ui import ControlCenterUI
 from frontengine.ui.page.scene_setting.scene_setting_ui import SceneSettingUI
 from frontengine.ui.main_ui import FrontEngineMainUI
-from frontengine.ui.page.scene_setting.scene_setting_ui import SceneControlSettingUI
 from frontengine.ui.main_ui import FrontEngine_EXTEND_TAB
 from frontengine.utils.redirect_manager.redirect_manager_class import RedirectManager
 
@@ -26,6 +25,6 @@ __all__ = [
     "start_front_engine", "GifWidget", "SoundPlayer", "SoundEffectWidget", "TextWidget",
     "WebWidget", "ImageWidget", "VideoWidget", "language_wrapper", "load_extend_ui_file", "load_ui_file",
     "TextSettingUI", "WEBSettingUI", "GIFSettingUI", "ImageSettingUI", "SoundPlayerSettingUI",
-    "VideoSettingUI", "ControlCenterUI", "SceneSettingUI", "FrontEngineMainUI", "SceneControlSettingUI",
+    "VideoSettingUI", "ControlCenterUI", "SceneSettingUI", "FrontEngineMainUI",
     "FrontEngine_EXTEND_TAB", "RedirectManager"
 ]

frontengine/show/scene/extend_graphic_scene.py

@@ -5,4 +5,3 @@ class ExtendGraphicScene(QGraphicsScene):
 
     def __init__(self):
         super().__init__()
-

frontengine/show/scene/extend_graphic_view.py

@@ -12,6 +12,7 @@ class ExtendGraphicView(QGraphicsView):
             Qt.WindowType.WindowType_Mask |
             Qt.WindowType.Tool
         )
+        self.setStyleSheet("background:transparent")
         self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
         self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
         self.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
@@ -23,7 +24,7 @@ class ExtendGraphicView(QGraphicsView):
             pass
         else:
             current_position = event.position()
-            scene_position = self.mapToScene(QPoint(current_position.x(), current_position.y()))
+            scene_position = self.mapToScene(QPoint(int(current_position.x()), int(current_position.y())))
             view_width = self.viewport().width()
             view_height = self.viewport().height()
             horizon_scale = current_position.x() / view_width

frontengine/show/scene/scene.py

@@ -1,12 +1,11 @@
 from typing import List, Dict
 
-from PySide6.QtWidgets import QGraphicsProxyWidget, QWidget
+from PySide6.QtWidgets import QGraphicsProxyWidget
+from frontengine.show.scene.extend_graphic_view import ExtendGraphicView
 
 from frontengine.show.gif.paint_gif import GifWidget
 from frontengine.show.image.paint_image import ImageWidget
-from frontengine.show.load.load_someone_make_ui import load_ui_file, read_extend_ui
 from frontengine.show.scene.extend_graphic_scene import ExtendGraphicScene
-from frontengine.show.scene.extend_graphic_view import ExtendGraphicView
 from frontengine.show.sound_player.sound_player import SoundPlayer
 from frontengine.show.text.draw_text import TextWidget
 from frontengine.show.video.video_player import VideoWidget
@@ -20,25 +19,25 @@ class SceneManager(object):
     ):
         super().__init__()
         self.graphic_scene = ExtendGraphicScene()
-        self.graphic_view = ExtendGraphicView(self.graphic_scene)
         self.widget_list: List[QGraphicsProxyWidget] = list()
+        self.view_list: List[ExtendGraphicView] = []
 
-    def add_image(self, image_setting: Dict[str, str]) -> QGraphicsProxyWidget:
-        image_path = image_setting.get("file_path")
+    def add_image(self, setting_dict: Dict) -> QGraphicsProxyWidget:
+        image_path = setting_dict.get("file_path")
         image_widget = ImageWidget(image_path)
-        opacity = float(image_setting.get("opacity")) / 100
+        opacity = float(setting_dict.get("opacity")) / 100
         opacity = opacity if opacity is not None else 0.2
         image_widget.set_ui_variable(opacity)
         proxy_widget = self.graphic_scene.addWidget(image_widget)
         self.widget_list.append(proxy_widget)
         return proxy_widget
 
-    def add_gif(self, gif_setting: Dict[str, str]) -> QGraphicsProxyWidget:
-        gif_image_path = gif_setting.get("file_path")
+    def add_gif(self, setting_dict: Dict) -> QGraphicsProxyWidget:
+        gif_image_path = setting_dict.get("file_path")
         gif_widget = GifWidget(gif_image_path)
-        speed = int(gif_setting.get("speed"))
+        speed = int(setting_dict.get("speed"))
         speed = speed if speed is not None else 100
-        opacity = float(gif_setting.get("opacity")) / 100
+        opacity = float(setting_dict.get("opacity")) / 100
         opacity = opacity if opacity is not None else 0.2
         gif_widget.set_gif_variable(speed)
         gif_widget.set_ui_variable(opacity)
@@ -46,30 +45,32 @@ class SceneManager(object):
         self.widget_list.append(proxy_widget)
         return proxy_widget
 
-    def add_sound(self, sound_setting: Dict[str, str]) -> QGraphicsProxyWidget:
-        sound_path = sound_setting.get("file_path")
+    def add_sound(self, setting_dict: Dict) -> QGraphicsProxyWidget:
+        sound_path = setting_dict.get("file_path")
         sound_widget = SoundPlayer(sound_path)
-        volume = float(sound_setting.get("volume")) / 100
+        volume = float(setting_dict.get("volume")) / 100
         volume = volume if volume is not None else 1
         sound_widget.set_player_variable(volume)
         proxy_widget = self.graphic_scene.addWidget(sound_widget)
         self.widget_list.append(proxy_widget)
         return proxy_widget
 
-    def add_text(self, text_setting: Dict[str, str]) -> QGraphicsProxyWidget:
-        text = text_setting.get("text")
+    def add_text(self, setting_dict: Dict) -> QGraphicsProxyWidget:
+        text = setting_dict.get("text")
         text_widget = TextWidget(text)
-        font_size = int(text_setting.get("font_size"))
+        font_size = int(setting_dict.get("font_size"))
         font_size = font_size if font_size is not None else 100
-        opacity = float(text_setting.get("opacity")) / 100
+        opacity = float(setting_dict.get("opacity")) / 100
         opacity = opacity if opacity is not None else 0.2
+        alignment = setting_dict.get("alignment", "Center")
         text_widget.set_ui_variable(opacity)
         text_widget.set_font_variable(font_size)
+        text_widget.set_alignment(alignment)
         proxy_widget = self.graphic_scene.addWidget(text_widget)
         self.widget_list.append(proxy_widget)
         return proxy_widget
 
-    def add_video(self, video_setting: Dict[str, str]) -> QGraphicsProxyWidget:
+    def add_video(self, video_setting: Dict) -> QGraphicsProxyWidget:
         video_path = video_setting.get("file_path")
         video_widget = VideoWidget(video_path)
         opacity = float(video_setting.get("opacity")) / 100
@@ -84,31 +85,12 @@ class SceneManager(object):
         self.widget_list.append(proxy_widget)
         return proxy_widget
 
-    def add_web(self, web_setting: Dict[str, str]) -> QGraphicsProxyWidget:
-        url = web_setting.get("url")
+    def add_web(self, setting_dict: Dict) -> QGraphicsProxyWidget:
+        url = setting_dict.get("url")
         web_widget = WebWidget(url)
-        opacity = float(web_setting.get("opacity")) / 100
+        opacity = float(setting_dict.get("opacity")) / 100
         opacity = opacity if opacity is not None else 0.2
-        enable_input = web_setting.get("enable_input")
-        enable_input = enable_input if enable_input is not None else False
         web_widget.set_ui_variable(opacity)
-        web_widget.set_ui_window_flag(enable_input=enable_input)
         proxy_widget = self.graphic_scene.addWidget(web_widget)
         self.widget_list.append(proxy_widget)
         return proxy_widget
-
-    def add_extend_ui_file(self, ui_setting_dict: Dict[str, str]) -> QGraphicsProxyWidget:
-        ui_path = ui_setting_dict.get("file_path")
-        extend_widget = load_ui_file(ui_path)
-        proxy_widget = self.graphic_scene.addWidget(extend_widget)
-        self.widget_list.append(proxy_widget)
-        return proxy_widget
-
-    def add_extend_ui(self, ui: QWidget) -> QGraphicsProxyWidget:
-        extend_widget = read_extend_ui(ui)
-        proxy_widget = self.graphic_scene.addWidget(extend_widget)
-        self.widget_list.append(proxy_widget)
-        return proxy_widget
-
-    def show(self):
-        self.graphic_view.showMaximized()

frontengine/show/text/draw_text.py

@@ -8,7 +8,8 @@ from PySide6.QtWidgets import QWidget
 
 class TextWidget(QWidget):
 
-    def __init__(self, text: str, draw_location_x: int = 0, draw_location_y: int = 0):
+    def __init__(self, text: str, draw_location_x: int = 0, draw_location_y: int = 0,
+                 alignment: str = "Center"):
         super().__init__()
         self.draw_location_x = draw_location_x
         self.draw_location_y = draw_location_y
@@ -17,6 +18,16 @@ class TextWidget(QWidget):
         self.text = text
         self.font_size = 100
         self.opacity = 0.2
+        if alignment == "TopLeft":
+            self.alignment = (Qt.AlignmentFlag.AlignTop | Qt.AlignmentFlag.AlignLeft)
+        elif alignment == "TopRight":
+            self.alignment = (Qt.AlignmentFlag.AlignTop | Qt.AlignmentFlag.AlignRight)
+        elif alignment == "BottomLeft":
+            self.alignment = (Qt.AlignmentFlag.AlignBottom | Qt.AlignmentFlag.AlignLeft)
+        elif alignment == "BottomRight":
+            self.alignment = (Qt.AlignmentFlag.AlignBottom | Qt.AlignmentFlag.AlignRight)
+        else:
+            self.alignment = Qt.AlignmentFlag.AlignCenter
         self.draw_font = QFontDatabase.font(self.font().family(), "", self.font_size)
         # Set Icon
         self.icon_path = Path(os.getcwd() + "/je_driver_icon.ico")
@@ -40,6 +51,21 @@ class TextWidget(QWidget):
     def set_ui_variable(self, opacity: float = 0.2) -> None:
         self.opacity = opacity
 
+    def set_font(self):
+        self.draw_font = QFontDatabase.font(self.font().family(), "", self.font_size)
+
+    def set_alignment(self, alignment: str = "Center") -> None:
+        if alignment == "TopLeft":
+            self.alignment = (Qt.AlignmentFlag.AlignTop | Qt.AlignmentFlag.AlignLeft)
+        elif alignment == "TopRight":
+            self.alignment = (Qt.AlignmentFlag.AlignTop | Qt.AlignmentFlag.AlignRight)
+        elif alignment == "BottomLeft":
+            self.alignment = (Qt.AlignmentFlag.AlignBottom | Qt.AlignmentFlag.AlignLeft)
+        elif alignment == "BottomRight":
+            self.alignment = (Qt.AlignmentFlag.AlignBottom | Qt.AlignmentFlag.AlignRight)
+        else:
+            self.alignment = Qt.AlignmentFlag.AlignCenter
+
     def paintEvent(self, event) -> None:
         painter = QPainter(self)
         painter.setFont(
@@ -49,7 +75,7 @@ class TextWidget(QWidget):
         painter.setOpacity(self.opacity)
         painter.drawText(
             QRect(self.draw_location_x, self.draw_location_y, self.width(), self.height()),
-            Qt.AlignmentFlag.AlignTop | Qt.AlignmentFlag.AlignLeft,
+            int(self.alignment),
             self.text
         )
         painter.restore()
@@ -62,4 +88,3 @@ class TextWidget(QWidget):
 
     def mouseGrabber(self) -> None:
         super().mouseGrabber()
-

frontengine/ui/dialog/choose_file_dialog.py

@@ -68,12 +68,3 @@ def choose_video(
     return choose_file(
         trigger_ui=trigger_ui, file_filter=file_filter, extensions=extensions,
         warning_message=language_wrapper.language_word_dict.get("video_setting_message_box"))
-
-
-def choose_scene_json(
-        trigger_ui: QWidget, file_filter: str = "Json (*.json;)", extensions: list = None) -> str:
-    front_engine_logger.info("choose_scene_json")
-    extensions = extensions or [".json"]
-    return choose_file(
-        trigger_ui=trigger_ui, file_filter=file_filter, extensions=extensions,
-        warning_message=language_wrapper.language_word_dict.get("scene_choose_message_box"))

frontengine/ui/main_ui.py

@@ -10,6 +10,7 @@ from qt_material import apply_stylesheet, QtStyleTools
 
 from frontengine.system_tray.extend_system_tray import ExtendSystemTray
 from frontengine.ui.menu.help_menu import build_help_menu
+from frontengine.ui.menu.how_to_menu import build_how_to_menu
 from frontengine.ui.menu.language_menu import build_language_menu
 from frontengine.ui.page.control_center.control_center_ui import ControlCenterUI
 from frontengine.ui.page.gif.gif_setting_ui import GIFSettingUI
@@ -95,6 +96,7 @@ class FrontEngineMainUI(QMainWindow, QtStyleTools):
             self.tab_widget.addTab(widget(), widget_name)
         build_language_menu(self)
         build_help_menu(self)
+        build_how_to_menu(self)
         # Set Icon
         self.icon_path = Path(os.getcwd() + "/je_driver_icon.ico")
         self.icon = QIcon(str(self.icon_path))

frontengine/ui/menu/how_to_menu.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 from typing import TYPE_CHECKING
 
+from frontengine.utils.browser.browser import open_browser
+
 if TYPE_CHECKING:
     from frontengine.ui.main_ui import FrontEngineMainUI
 from PySide6.QtGui import QAction
@@ -9,6 +11,15 @@ from frontengine.utils.multi_language.language_wrapper import language_wrapper
 
 
 def build_how_to_menu(ui_we_want_to_set: FrontEngineMainUI) -> None:
-    ui_we_want_to_set.menu_bar.how_to_menu = ui_we_want_to_set.menu_bar.addMenu(
-        language_wrapper.language_word_dict.get("menu_bar_language")
+    ui_we_want_to_set.how_to_menu = ui_we_want_to_set.menu_bar.addMenu(
+        language_wrapper.language_word_dict.get("doc_menu_label")
+    )
+    ui_we_want_to_set.how_to_menu.open_doc_action = QAction(
+        language_wrapper.language_word_dict.get("doc_menu_open_doc")
+    )
+    ui_we_want_to_set.how_to_menu.open_doc_action.triggered.connect(
+        lambda: open_browser("https://frontengine.readthedocs.io/en/latest/")
+    )
+    ui_we_want_to_set.how_to_menu.addAction(
+        ui_we_want_to_set.how_to_menu.open_doc_action
     )

frontengine/ui/page/control_center/control_center_ui.py

@@ -145,11 +145,7 @@ class ControlCenterUI(QWidget):
 
     def clear_scene(self) -> None:
         front_engine_logger.info("clear_scene")
-        self.scene_setting_ui.scene_control_setting.close_scene()
-
-    def clear_chat(self):
-        front_engine_logger.info("clear_chat")
-        self.chat_scene_ui.close_chat_ui()
+        self.scene_setting_ui.close_scene()
 
     def clear_all(self) -> None:
         front_engine_logger.info("clear_all")
@@ -159,7 +155,7 @@ class ControlCenterUI(QWidget):
         self.gif_setting_ui.gif_widget_list.clear()
         self.sound_player_setting_ui.sound_widget_list.clear()
         self.text_setting_ui.text_widget_list.clear()
-        self.scene_setting_ui.scene_control_setting.close_scene()
+        self.scene_setting_ui.close_scene()
 
     def redirect(self) -> None:
         if not redirect_manager_instance.std_out_queue.empty():

frontengine/ui/page/gif/gif_setting_ui.py

@@ -1,10 +1,11 @@
 from PySide6.QtCore import Qt
 from PySide6.QtGui import QGuiApplication
 from PySide6.QtWidgets import QWidget, QGridLayout, QLabel, QSlider, QPushButton, QMessageBox, \
-    QCheckBox
+    QCheckBox, QDialog
 
 from frontengine.show.gif.paint_gif import GifWidget
 from frontengine.ui.dialog.choose_file_dialog import choose_gif
+from frontengine.ui.page.utils import monitor_choose_dialog
 from frontengine.utils.logging.loggin_instance import front_engine_logger
 from frontengine.utils.multi_language.language_wrapper import language_wrapper
 
@@ -19,7 +20,7 @@ class GIFSettingUI(QWidget):
         self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
         # Init variable
         self.gif_widget_list = list()
-        self.show_all_screen = True
+        self.show_all_screen = False
         self.ready_to_play = False
         # Opacity setting
         self.opacity_slider = QSlider()
@@ -103,11 +104,22 @@ class GIFSettingUI(QWidget):
             message_box.show()
         else:
             front_engine_logger.info("start_play_gif")
-            if not self.show_all_screen:
+            monitors = QGuiApplication.screens()
+            if self.show_all_screen is False and len(monitors) <= 1:
                 gif_widget = self._create_gif_widget()
                 gif_widget.showFullScreen()
+            elif self.show_all_screen is False and len(monitors) >= 2:
+                input_dialog, combobox = monitor_choose_dialog(self, monitors)
+                result = input_dialog.exec_()
+                if result == QDialog.DialogCode.Accepted:
+                    select_monitor_index = int(combobox.currentText())
+                    if len(monitors) > select_monitor_index:
+                        monitor = monitors[select_monitor_index]
+                        gif_widget = self._create_gif_widget()
+                        gif_widget.setScreen(monitor)
+                        gif_widget.move(monitor.availableGeometry().topLeft())
+                        gif_widget.showFullScreen()
             else:
-                monitors = QGuiApplication.screens()
                 for monitor in monitors:
                     gif_widget = self._create_gif_widget()
                     gif_widget.setScreen(monitor)

frontengine/ui/page/image/image_setting_ui.py

@@ -1,10 +1,11 @@
 from PySide6.QtCore import Qt
 from PySide6.QtGui import QScreen, QGuiApplication
 from PySide6.QtWidgets import QWidget, QGridLayout, QSlider, QLabel, QPushButton, QMessageBox, \
-    QCheckBox
+    QCheckBox, QDialog
 
 from frontengine.show.image.paint_image import ImageWidget
 from frontengine.ui.dialog.choose_file_dialog import choose_image
+from frontengine.ui.page.utils import monitor_choose_dialog
 from frontengine.utils.logging.loggin_instance import front_engine_logger
 from frontengine.utils.multi_language.language_wrapper import language_wrapper
 
@@ -88,11 +89,22 @@ class ImageSettingUI(QWidget):
             message_box.show()
         else:
             front_engine_logger.info("start_play_image")
-            if not self.show_all_screen:
+            monitors = QGuiApplication.screens()
+            if self.show_all_screen is False and len(monitors) <= 1:
                 image_widget = self._create_image_widget()
                 image_widget.showFullScreen()
+            elif self.show_all_screen is False and len(monitors) >= 2:
+                input_dialog, combobox = monitor_choose_dialog(self, monitors)
+                result = input_dialog.exec_()
+                if result == QDialog.DialogCode.Accepted:
+                    select_monitor_index = int(combobox.currentText())
+                    if len(monitors) > select_monitor_index:
+                        monitor = monitors[select_monitor_index]
+                        gif_widget = self._create_image_widget()
+                        gif_widget.setScreen(monitor)
+                        gif_widget.move(monitor.availableGeometry().topLeft())
+                        gif_widget.showFullScreen()
             else:
-                monitors = QGuiApplication.screens()
                 for monitor in monitors:
                     image_widget = self._create_image_widget()
                     image_widget.setScreen(monitor)

frontengine/ui/page/scene_setting/scene_manager.py

@@ -0,0 +1,96 @@
+import json
+
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QGuiApplication
+from PySide6.QtWidgets import QWidget, QGridLayout, QPlainTextEdit, QPushButton, QCheckBox, QDialog
+
+from frontengine.show.scene.extend_graphic_view import ExtendGraphicView
+from frontengine.ui.page.utils import monitor_choose_dialog
+from frontengine.user_setting.scene_setting import choose_scene_json, write_scene_file, scene_json
+from frontengine.utils.multi_language.language_wrapper import language_wrapper
+
+
+class SceneManagerUI(QWidget):
+
+    def __init__(self, scene_manager):
+        super().__init__()
+        self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
+        self.grid_layout = QGridLayout()
+        self.grid_layout.setContentsMargins(0, 0, 0, 0)
+        self.scene = scene_manager
+        self.show_all_screen = False
+        # Read and write scene json button
+        self.read_scene_json_button = QPushButton(language_wrapper.language_word_dict.get("scene_input"))
+        self.read_scene_json_button.clicked.connect(self.update_scene_json)
+        self.write_scene_json_button = QPushButton(language_wrapper.language_word_dict.get("scene_output"))
+        self.write_scene_json_button.clicked.connect(lambda: write_scene_file(self))
+        # Json plaintext
+        self.json_plaintext = QPlainTextEdit()
+        self.json_plaintext.setReadOnly(True)
+        self.json_plaintext.appendPlainText("{}")
+        # Start button
+        self.start_button = QPushButton(
+            language_wrapper.language_word_dict.get("scene_start")
+        )
+        self.start_button.clicked.connect(self.start_scene)
+        # Show on all screen
+        self.show_on_all_screen_checkbox = QCheckBox(
+            language_wrapper.language_word_dict.get("Show on all screen")
+        )
+        self.show_on_all_screen_checkbox.clicked.connect(self.set_show_all_screen)
+        # Add to layout
+        self.grid_layout.addWidget(self.json_plaintext, 0, 0, -1, -1)
+        self.grid_layout.addWidget(self.read_scene_json_button, 1, 0)
+        self.grid_layout.addWidget(self.write_scene_json_button, 1, 1)
+        self.grid_layout.addWidget(self.show_on_all_screen_checkbox, 2, 0)
+        self.grid_layout.addWidget(self.start_button, 3, 0, 1, 0)
+        self.setLayout(self.grid_layout)
+
+    def set_show_all_screen(self) -> None:
+        self.show_all_screen = self.show_on_all_screen_checkbox.isChecked()
+
+    def start_scene(self):
+        scene: dict = json.loads(self.json_plaintext.toPlainText())
+        scene_add_function = {
+            "TEXT": self.scene.add_text,
+            "IMAGE": self.scene.add_image,
+            "GIF": self.scene.add_gif,
+            "SOUND": self.scene.add_sound,
+            "VIDEO": self.scene.add_video,
+            "WEB": self.scene.add_web
+        }
+        for scene_dict in scene.values():
+            scene_widget_type = scene_dict.get("type")
+            function = scene_add_function.get(scene_widget_type)
+            function(setting_dict=scene_dict)
+        monitors = QGuiApplication.screens()
+        if self.show_all_screen is False and len(monitors) <= 1:
+            graphic_view = ExtendGraphicView(self.scene.graphic_scene)
+            self.scene.view_list.append(graphic_view)
+            graphic_view.showMaximized()
+        elif self.show_all_screen is False and len(monitors) >= 2:
+            input_dialog, combobox = monitor_choose_dialog(self, monitors)
+            result = input_dialog.exec_()
+            if result == QDialog.DialogCode.Accepted:
+                select_monitor_index = int(combobox.currentText())
+                if len(monitors) > select_monitor_index:
+                    monitor = monitors[select_monitor_index]
+                    graphic_view = ExtendGraphicView(self.scene.graphic_scene)
+                    graphic_view.setScreen(monitor)
+                    graphic_view.move(monitor.availableGeometry().topLeft())
+                    self.scene.view_list.append(graphic_view)
+                    graphic_view.showMaximized()
+        else:
+            for monitor in monitors:
+                graphic_view = ExtendGraphicView(self.scene.graphic_scene)
+                graphic_view.setScreen(monitor)
+                graphic_view.move(monitor.availableGeometry().topLeft())
+                self.scene.view_list.append(graphic_view)
+                graphic_view.showMaximized()
+
+    def update_scene_json(self):
+        choose_scene_json(self)
+        self.renew_json_plain_text()
+
+    def renew_json_plain_text(self):
+        self.json_plaintext.setPlainText(json.dumps(scene_json, indent=4))

frontengine/ui/page/scene_setting/scene_page/gif.py

@@ -0,0 +1,102 @@
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import QWidget, QGridLayout, QSlider, QLabel, QPushButton, QMessageBox
+
+from frontengine.ui.dialog.choose_file_dialog import choose_gif
+from frontengine.ui.page.scene_setting.scene_manager import SceneManagerUI
+from frontengine.user_setting.scene_setting import scene_json
+from frontengine.utils.multi_language.language_wrapper import language_wrapper
+
+
+class GIFSceneSettingUI(QWidget):
+
+    def __init__(self, script_ui: SceneManagerUI):
+        super().__init__()
+        self.script_ui = script_ui
+        # UI components
+        self.opacity_slider = QSlider()
+        self.opacity_slider.setOrientation(Qt.Orientation.Horizontal)
+        self.opacity_label = QLabel(
+            language_wrapper.language_word_dict.get("Opacity")
+        )
+        self.opacity_slider.setMinimum(1)
+        self.opacity_slider.setMaximum(100)
+        self.opacity_slider.setValue(20)
+        self.opacity_slider.setTickInterval(1)
+        self.opacity_slider_value_label = QLabel(str(self.opacity_slider.value()))
+        self.opacity_slider.actionTriggered.connect(self.opacity_trick)
+        # Speed setting
+        self.speed_label = QLabel(
+            language_wrapper.language_word_dict.get("Speed")
+        )
+        self.speed_slider = QSlider()
+        self.speed_slider.setMinimum(1)
+        self.speed_slider.setMaximum(200)
+        self.speed_slider.setTickInterval(1)
+        self.speed_slider.setValue(100)
+        self.speed_slider_value_label = QLabel(str(self.speed_slider.value()))
+        self.speed_slider.setOrientation(Qt.Orientation.Horizontal)
+        self.speed_slider.actionTriggered.connect(self.speed_trick)
+        # Choose file button
+        self.choose_file_button = QPushButton(
+            language_wrapper.language_word_dict.get("gif_setting_ui_choose_file")
+        )
+        self.choose_file_button.clicked.connect(self.get_gif)
+        self.ready_to_play = False
+        self.ready_label = QLabel(
+            language_wrapper.language_word_dict.get("Not Ready")
+        )
+        self.gif_image_path: [str, None] = None
+        self.update_scene_button = QPushButton(
+            language_wrapper.language_word_dict.get("scene_add_gif")
+        )
+        self.update_scene_button.clicked.connect(self.update_scene_json)
+        # Add to layout
+        self.grid_layout = QGridLayout()
+        self.grid_layout.addWidget(self.opacity_label, 0, 0)
+        self.grid_layout.addWidget(self.opacity_slider_value_label, 0, 1)
+        self.grid_layout.addWidget(self.opacity_slider, 0, 2)
+        self.grid_layout.addWidget(self.speed_label, 1, 0)
+        self.grid_layout.addWidget(self.speed_slider_value_label, 1, 1)
+        self.grid_layout.addWidget(self.speed_slider, 1, 2)
+        self.grid_layout.addWidget(self.choose_file_button, 2, 0)
+        self.grid_layout.addWidget(self.ready_label, 2, 1)
+        self.grid_layout.addWidget(self.update_scene_button, 3, 0)
+        self.setLayout(self.grid_layout)
+
+    def opacity_trick(self) -> None:
+        self.opacity_slider_value_label.setText(str(self.opacity_slider.value()))
+
+    def speed_trick(self) -> None:
+        self.speed_slider_value_label.setText(str(self.speed_slider.value()))
+
+    def get_gif(self):
+        self.ready_label.setText(
+            language_wrapper.language_word_dict.get("Not Ready")
+        )
+        self.ready_to_play = False
+        self.gif_image_path = choose_gif(self)
+        if self.gif_image_path is not None:
+            self.ready_label.setText(
+                language_wrapper.language_word_dict.get("Ready")
+            )
+            self.ready_to_play = True
+
+    def update_scene_json(self):
+        if self.gif_image_path is None:
+            message_box = QMessageBox(self)
+            message_box.setText(
+                language_wrapper.language_word_dict.get('not_prepare')
+            )
+            message_box.show()
+        else:
+            scene_json.update(
+                {
+                    f"{len(scene_json)}": {
+                        "type": "GIF",
+                        "file_path": self.gif_image_path,
+                        "opacity": self.opacity_slider.value(),
+                        "speed": self.speed_slider.value()
+                    }
+                }
+            )
+            self.script_ui.renew_json_plain_text()