frontengine 0.0.56__tar.gz → 0.0.58__tar.gz

{frontengine-0.0.56 → frontengine-0.0.58}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: frontengine
-Version: 0.0.56
+Version: 0.0.58
 Summary: FrontEngine is BingGPT that can use-define front end or only use like screen saver
 Author-email: JE-Chen <jechenmailman@gmail.com>
 License: MIT

{frontengine-0.0.56 → frontengine-0.0.58}/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-0.0.56 → frontengine-0.0.58}/frontengine/show/scene/extend_graphic_scene.py

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

{frontengine-0.0.56 → frontengine-0.0.58}/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-0.0.56 → frontengine-0.0.58}/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-0.0.56 → frontengine-0.0.58}/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-0.0.56 → frontengine-0.0.58}/frontengine/show/video/video_player.py

@@ -7,6 +7,7 @@ from PySide6.QtMultimedia import QMediaPlayer, QAudioOutput
 from PySide6.QtMultimediaWidgets import QVideoWidget
 from PySide6.QtWidgets import QMessageBox
 
+from frontengine.utils.logging.loggin_instance import front_engine_logger
 from frontengine.utils.multi_language.language_wrapper import language_wrapper
 
 
@@ -17,13 +18,11 @@ class VideoWidget(QVideoWidget):
         self.opacity: float = 0.2
         self.volume: float = 1
         self.play_rate: float = 1
-        self.setAttribute(
-            Qt.WidgetAttribute.WA_TranslucentBackground
-        )
         self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
         self.media_player = QMediaPlayer()
         self.video_path = Path(video_path)
         if self.video_path.exists() and self.video_path.is_file():
+            front_engine_logger.info("start_play_video")
             self.video_file_path = str(self.video_path)
             self.audioOutput = QAudioOutput()
             # QUrl non ascii path encode, Avoid read wrong path and file name

{frontengine-0.0.56 → frontengine-0.0.58}/frontengine/show/web/webview.py

@@ -2,7 +2,7 @@ import os
 from pathlib import Path
 
 from PySide6.QtCore import Qt, QUrl
-from PySide6.QtGui import QIcon
+from PySide6.QtGui import QIcon, QAction
 from PySide6.QtWebEngineWidgets import QWebEngineView
 from PySide6.QtWidgets import QMessageBox
 
@@ -35,6 +35,13 @@ class WebWidget(QWebEngineView):
         if self.icon_path.exists() and self.icon_path.is_file():
             self.setWindowIcon(QIcon(str(self.icon_path)))
 
+    def contextMenuEvent(self, event):
+        self.menu = self.createStandardContextMenu()
+        self.close_action = QAction("Close")
+        self.close_action.triggered.connect(self.close)
+        self.menu.addAction(self.close_action)
+        self.menu.popup(event.globalPos())
+
     def set_ui_variable(self, opacity: float = 0.2) -> None:
         self.opacity = opacity
         self.setWindowOpacity(opacity)
@@ -56,6 +63,8 @@ class WebWidget(QWebEngineView):
         )
 
     def mousePressEvent(self, event) -> None:
+        # if event.button() == Qt.MouseButton.MiddleButton:
+        print(event.button())
         super().mousePressEvent(event)
 
     def mouseDoubleClickEvent(self, event) -> None:

{frontengine-0.0.56 → frontengine-0.0.58}/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-0.0.56 → frontengine-0.0.58}/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-0.0.58/frontengine/ui/menu/how_to_menu.py

@@ -0,0 +1,25 @@
+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
+
+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.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-0.0.58/frontengine/ui/menu/language_menu.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from frontengine.ui.main_ui import FrontEngineMainUI
+from PySide6.QtGui import QAction
+from PySide6.QtWidgets import QMessageBox
+
+from frontengine.user_setting.user_setting_file import user_setting_dict
+from frontengine.utils.multi_language.language_wrapper import language_wrapper
+
+
+def build_language_menu(ui_we_want_to_set: FrontEngineMainUI) -> None:
+    ui_we_want_to_set.language_menu = ui_we_want_to_set.menu_bar.addMenu(
+        language_wrapper.language_word_dict.get("menu_bar_language")
+    )
+    ui_we_want_to_set.language_menu.change_to_english_language_action = QAction(
+        language_wrapper.language_word_dict.get("language_menu_bar_english")
+    )
+    ui_we_want_to_set.language_menu.change_to_english_language_action.triggered.connect(
+        lambda: set_language("English", ui_we_want_to_set)
+    )
+    ui_we_want_to_set.language_menu.change_to_traditional_chinese_language_action = QAction(
+        language_wrapper.language_word_dict.get("language_menu_bar_traditional_chinese")
+    )
+    ui_we_want_to_set.language_menu.change_to_traditional_chinese_language_action.triggered.connect(
+        lambda: set_language("Traditional_Chinese", ui_we_want_to_set)
+    )
+    ui_we_want_to_set.language_menu.change_to_simplified_chinese_language_action = QAction(
+        language_wrapper.language_word_dict.get("language_menu_bar_simplified_chinese")
+    )
+    ui_we_want_to_set.language_menu.change_to_simplified_chinese_language_action.triggered.connect(
+        lambda: set_language("Simplified_Chinese", ui_we_want_to_set)
+    )
+    ui_we_want_to_set.language_menu.change_to_deutsch_language_action = QAction(
+        language_wrapper.language_word_dict.get("language_menu_bar_germany")
+    )
+    ui_we_want_to_set.language_menu.change_to_deutsch_language_action.triggered.connect(
+        lambda: set_language("Deutsch", ui_we_want_to_set)
+    )
+    ui_we_want_to_set.language_menu.change_to_russian_language_action = QAction(
+        language_wrapper.language_word_dict.get("language_menu_bar_russian")
+    )
+    ui_we_want_to_set.language_menu.change_to_russian_language_action.triggered.connect(
+        lambda: set_language("Russian", ui_we_want_to_set)
+    )
+    ui_we_want_to_set.language_menu.change_to_france_language_action = QAction(
+        language_wrapper.language_word_dict.get("language_menu_bar_french")
+    )
+    ui_we_want_to_set.language_menu.change_to_france_language_action.triggered.connect(
+        lambda: set_language("France", ui_we_want_to_set)
+    )
+    ui_we_want_to_set.language_menu.change_to_italian_language_action = QAction(
+        language_wrapper.language_word_dict.get("language_menu_bar_italian")
+    )
+    ui_we_want_to_set.language_menu.change_to_italian_language_action.triggered.connect(
+        lambda: set_language("Italy", ui_we_want_to_set)
+    )
+    ui_we_want_to_set.language_menu.addAction(
+        ui_we_want_to_set.language_menu.change_to_english_language_action
+    )
+    ui_we_want_to_set.language_menu.addAction(
+        ui_we_want_to_set.language_menu.change_to_traditional_chinese_language_action
+    )
+    ui_we_want_to_set.language_menu.addAction(
+        ui_we_want_to_set.language_menu.change_to_simplified_chinese_language_action
+    )
+    ui_we_want_to_set.language_menu.addAction(
+        ui_we_want_to_set.language_menu.change_to_deutsch_language_action
+    )
+    ui_we_want_to_set.language_menu.addAction(
+        ui_we_want_to_set.language_menu.change_to_russian_language_action
+    )
+    ui_we_want_to_set.language_menu.addAction(
+        ui_we_want_to_set.language_menu.change_to_france_language_action
+    )
+    ui_we_want_to_set.language_menu.addAction(
+        ui_we_want_to_set.language_menu.change_to_italian_language_action
+    )
+
+
+def set_language(language: str, ui_we_want_to_set: FrontEngineMainUI) -> None:
+    language_wrapper.reset_language(language)
+    user_setting_dict.update({"language": language})
+    message_box = QMessageBox(ui_we_want_to_set)
+    message_box.setText(language_wrapper.language_word_dict.get("language_menu_bar_please_restart_messagebox"))
+    message_box.show()

{frontengine-0.0.56 → frontengine-0.0.58}/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-0.0.56 → frontengine-0.0.58}/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-0.0.56 → frontengine-0.0.58}/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-0.0.58/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))