frontengine-dev 0.0.53__py3-none-any.whl → 0.0.71__py3-none-any.whl

frontengine/__init__.py

@@ -7,26 +7,24 @@ 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
 from frontengine.show.web.webview import WebWidget
-from frontengine.ui.main.main_ui import start_front_engine
+from frontengine.ui.main_ui import start_front_engine
 from frontengine.utils.multi_language.language_wrapper import language_wrapper
-from frontengine.ui.setting.text.text_setting_ui import TextSettingUI
-from frontengine.ui.setting.web.web_setting_ui import WEBSettingUI
-from frontengine.ui.setting.gif.gif_setting_ui import GIFSettingUI
-from frontengine.ui.setting.image.image_setting_ui import ImageSettingUI
-from frontengine.ui.setting.sound_player.sound_player_setting_ui import SoundPlayerSettingUI
-from frontengine.ui.setting.video.video_setting_ui import VideoSettingUI
-from frontengine.ui.setting.control_center.control_center_ui import ControlCenterUI
-from frontengine.ui.setting.scene_setting.scene_setting_ui import SceneSettingUI
-from frontengine.ui.main.main_ui import FrontEngineMainUI
-from frontengine.ui.setting.scene_setting.scene_setting_ui import SceneControlSettingUI
-from frontengine.ui.setting.chat.chat_scene_setting import ChatSceneUI
-from frontengine.ui.main.main_ui import FrontEngine_EXTEND_TAB
+from frontengine.ui.page.text.text_setting_ui import TextSettingUI
+from frontengine.ui.page.web.web_setting_ui import WEBSettingUI
+from frontengine.ui.page.gif.gif_setting_ui import GIFSettingUI
+from frontengine.ui.page.image.image_setting_ui import ImageSettingUI
+from frontengine.ui.page.sound_player.sound_player_setting_ui import SoundPlayerSettingUI
+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.main_ui import FrontEngine_EXTEND_TAB
 from frontengine.utils.redirect_manager.redirect_manager_class import RedirectManager
 
 __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",
-    "ChatSceneUI", "FrontEngine_EXTEND_TAB", "RedirectManager"
+    "VideoSettingUI", "ControlCenterUI", "SceneSettingUI", "FrontEngineMainUI",
+    "FrontEngine_EXTEND_TAB", "RedirectManager"
 ]

frontengine/show/clicker/clicker_scene.py

@@ -0,0 +1,7 @@
+from PySide6.QtWidgets import QGraphicsScene
+
+
+class ClickerGraphicScene(QGraphicsScene):
+
+    def __init__(self):
+        super().__init__()

frontengine/show/clicker/clicker_ui.py

@@ -0,0 +1,30 @@
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import QWidget, QGridLayout
+
+from frontengine.show.clicker.clicker_scene import ClickerGraphicScene
+from frontengine.show.scene.extend_graphic_view import ExtendGraphicView
+
+
+class ClickerWidget(QWidget):
+
+    def __init__(self):
+        super().__init__()
+        self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
+        self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
+        self.clicker_view = ExtendGraphicView()
+        self.clicker_scene = ClickerGraphicScene()
+        self.clicker_view.setScene(self.clicker_scene)
+        self.grid_layout = QGridLayout()
+        self.grid_layout.addWidget(self.clicker_view, 0, 0, -1, -1)
+        self.setLayout(self.grid_layout)
+
+    def set_ui_window_flag(self, show_on_bottom: bool = False) -> None:
+        self.setWindowFlag(
+            Qt.WindowType.WindowTransparentForInput |
+            Qt.WindowType.FramelessWindowHint |
+            Qt.WindowType.Tool
+        )
+        if not show_on_bottom:
+            self.setWindowFlag(Qt.WindowType.WindowStaysOnTopHint)
+        else:
+            self.setWindowFlag(Qt.WindowType.WindowStaysOnBottomHint)

frontengine/show/gif/paint_gif.py

@@ -10,8 +10,10 @@ from frontengine.utils.multi_language.language_wrapper import language_wrapper
 
 class GifWidget(QWidget):
 
-    def __init__(self, gif_image_path: str):
+    def __init__(self, gif_image_path: str, draw_location_x: int = 0, draw_location_y: int = 0):
         super().__init__()
+        self.draw_location_x = draw_location_x
+        self.draw_location_y = draw_location_y
         self.opacity: float = 0.2
         self.speed: int = 100
         self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
@@ -26,6 +28,7 @@ class GifWidget(QWidget):
             self.movie.frameChanged.connect(self.repaint)
             self.gif_label.setMovie(self.movie)
             self.movie.start()
+            self.resize(self.movie.frameRect().size())
         else:
             message_box: QMessageBox = QMessageBox(self)
             message_box.setText(
@@ -61,7 +64,7 @@ class GifWidget(QWidget):
         painter.setOpacity(self.opacity)
         painter.drawPixmap(
             QRect(
-                self.x(), self.y(), self.width(), self.height()
+                self.draw_location_x, self.draw_location_y, self.width(), self.height()
             ),
             current_gif_frame
         )

frontengine/show/image/paint_image.py

@@ -10,13 +10,16 @@ from frontengine.utils.multi_language.language_wrapper import language_wrapper
 
 class ImageWidget(QWidget):
 
-    def __init__(self, image_path: str):
+    def __init__(self, image_path: str, draw_location_x: int = 0, draw_location_y: int = 0):
         super().__init__()
+        self.draw_location_x = draw_location_x
+        self.draw_location_y = draw_location_y
         self.opacity: float = 0.2
         self.image_path: Path = Path(image_path)
         if self.image_path.exists() and self.image_path.is_file():
             print(f"Origin file {str(self.image_path)}")
             self.image = QImage(str(self.image_path))
+            self.resize(self.image.size())
         else:
             message_box: QMessageBox = QMessageBox(self)
             message_box.setText(
@@ -48,7 +51,7 @@ class ImageWidget(QWidget):
         painter = QPainter(self)
         painter.setOpacity(self.opacity)
         painter.drawImage(
-            QRect(self.x(), self.y(), self.width(), self.height()),
+            QRect(self.draw_location_x, self.draw_location_y, self.width(), self.height()),
             self.image)
         painter.restore()
 

frontengine/show/particle/particle_scene.py

@@ -0,0 +1,71 @@
+import random
+from typing import Callable
+
+from PySide6.QtCore import QTimer, QPoint, QRect
+from PySide6.QtGui import QPixmap
+from PySide6.QtWidgets import QGraphicsScene
+
+from frontengine.show.particle.particle_utils import particle_down, particle_up, particle_left, particle_right, \
+    particle_left_down, particle_left_up, particle_right_down, particle_right_up, particle_random_minus, \
+    particle_random_add, particle_random
+
+
+class ParticleGraphicScene(QGraphicsScene):
+
+    def __init__(self, particle_pixmap: QPixmap, particle_direction: str,
+                 particle_count: int = 500,
+                 screen_height: int = 1920, screen_width: int = 1080, opacity: float = 0.2,
+                 particle_speed: int = 1):
+        super().__init__()
+        self.particle_pixmap: QPixmap = particle_pixmap
+        self.particle_direction: str = particle_direction
+        self.particle_count: int = particle_count
+        self.opacity: float = opacity
+        self.particle_dict: dict = {}
+        self.particle_speed: int = particle_speed
+        self.screen_height: int = screen_height
+        self.screen_width: int = screen_width
+        self.create_particle()
+        self.update_function: Callable = {
+            "down": particle_down,
+            "up": particle_up,
+            "left": particle_left,
+            "right": particle_right,
+            "left_down": particle_left_down,
+            "left_up": particle_left_up,
+            "right_down": particle_right_down,
+            "right_up": particle_right_up,
+            "random_minus": particle_random_minus,
+            "random_add": particle_random_add,
+            "random": particle_random
+        }.get(self.particle_direction)
+        self.setSceneRect(QRect(0, 0, screen_width, screen_height))
+        self.update_timer: QTimer = QTimer()
+        self.update_timer.setInterval(100)
+        self.update_timer.timeout.connect(self.update_particle_xy)
+        self.update_timer.start()
+
+    def create_particle(self):
+        self.particle_dict = {}
+        for count in range(self.particle_count):
+            item = self.addPixmap(self.particle_pixmap)
+            item.setOpacity(self.opacity)
+            self.particle_dict.update({
+                f"particle_{count}": {
+                    "x": random.randint(0, self.screen_width),
+                    "y": random.randint(0, self.screen_height),
+                    "height": self.screen_height,
+                    "width": self.screen_width,
+                    "pixmap_item": item,
+                }
+            })
+
+    def update_particle_xy(self):
+        self.update_function(self.particle_dict, self.particle_speed)
+        for particle_key, particle in self.particle_dict.items():
+            pixmap_item = particle.get("pixmap_item")
+            pixmap_item.setPos(particle.get("x"), particle.get("y"))
+            if not self.sceneRect().contains(QPoint(particle.get("x"), particle.get("y"))):
+                self.removeItem(particle.get("pixmap_item"))
+        if len(self.items()) == 0:
+            self.create_particle()

frontengine/show/particle/particle_ui.py

@@ -0,0 +1,39 @@
+from PySide6.QtCore import QSize
+from PySide6.QtGui import QPixmap, Qt
+from PySide6.QtWidgets import QWidget, QGridLayout
+
+from frontengine.show.particle.particle_scene import ParticleGraphicScene
+from frontengine.show.scene.extend_graphic_view import ExtendGraphicView
+
+
+class ParticleWidget(QWidget):
+
+    def __init__(self, pixmap: QPixmap, particle_size: int, particle_direction: str, particle_count: int = 50,
+                 screen_height: int = 1080, screen_width: int = 1920, opacity: float = 0.2,
+                 particle_speed: int = 1):
+        super().__init__()
+        self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
+        self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
+        if particle_size:
+            self.pixmap = pixmap.scaled(QSize(particle_size, particle_size), Qt.AspectRatioMode.KeepAspectRatio)
+        else:
+            self.pixmap = pixmap.scaled(QSize(pixmap.width(), pixmap.height()), Qt.AspectRatioMode.KeepAspectRatio)
+        self.particle_view = ExtendGraphicView()
+        self.particle_scene = ParticleGraphicScene(
+            self.pixmap, particle_direction, particle_count,
+            screen_height, screen_width, opacity, particle_speed)
+        self.particle_view.setScene(self.particle_scene)
+        self.grid_layout = QGridLayout()
+        self.grid_layout.addWidget(self.particle_view, 0, 0, -1, -1)
+        self.setLayout(self.grid_layout)
+
+    def set_ui_window_flag(self, show_on_bottom: bool = False) -> None:
+        self.setWindowFlag(
+            Qt.WindowType.WindowTransparentForInput |
+            Qt.WindowType.FramelessWindowHint |
+            Qt.WindowType.Tool
+        )
+        if not show_on_bottom:
+            self.setWindowFlag(Qt.WindowType.WindowStaysOnTopHint)
+        else:
+            self.setWindowFlag(Qt.WindowType.WindowStaysOnBottomHint)

frontengine/show/particle/particle_utils.py

@@ -0,0 +1,61 @@
+import random
+from typing import Dict, Callable
+
+
+def particle_down(particle_dict: Dict[str, dict], particle_speed: int = 30) -> None:
+    for particle in particle_dict.values():
+        particle.update({"y": particle.get("y") + random.randint(0, particle_speed)})
+
+
+def particle_up(particle_dict: Dict[str, dict], particle_speed: int = 30) -> None:
+    for particle in particle_dict.values():
+        particle.update({"y": particle.get("y") - random.randint(0, particle_speed)})
+
+
+def particle_left(particle_dict: Dict[str, dict], particle_speed: int = 30) -> None:
+    for particle in particle_dict.values():
+        particle.update({"x": particle.get("x") - random.randint(0, particle_speed)})
+
+
+def particle_right(particle_dict: Dict[str, dict], particle_speed: int = 30) -> None:
+    for particle in particle_dict.values():
+        particle.update({"x": particle.get("x") + random.randint(0, particle_speed)})
+
+
+def particle_left_down(particle_dict: Dict[str, dict], particle_speed: int = 30) -> None:
+    particle_left(particle_dict, particle_speed)
+    particle_down(particle_dict, particle_speed)
+
+
+def particle_left_up(particle_dict: Dict[str, dict], particle_speed: int = 30) -> None:
+    particle_left(particle_dict, particle_speed)
+    particle_up(particle_dict, particle_speed)
+
+
+def particle_right_down(particle_dict: Dict[str, dict], particle_speed: int = 30) -> None:
+    particle_right(particle_dict, particle_speed)
+    particle_down(particle_dict, particle_speed)
+
+
+def particle_right_up(particle_dict: Dict[str, dict], particle_speed: int = 30) -> None:
+    particle_right(particle_dict, particle_speed)
+    particle_up(particle_dict, particle_speed)
+
+
+def particle_random_minus(particle_dict: Dict[str, dict], particle_speed: int = 30) -> None:
+    for particle in particle_dict.values():
+        particle.update({"y": particle.get("y") + random.randint(0, particle_speed)})
+        particle.update({"x": particle.get("x") - random.randint(0, particle_speed)})
+
+
+def particle_random_add(particle_dict: Dict[str, dict], particle_speed: int = 30) -> None:
+    for particle in particle_dict.values():
+        particle.update({"y": particle.get("y") - random.randint(0, particle_speed)})
+        particle.update({"x": particle.get("x") + random.randint(0, particle_speed)})
+
+
+def particle_random(particle_dict: Dict[str, dict], particle_speed: int = 30) -> None:
+    function: Callable = random.choice(
+        [particle_down, particle_up, particle_left, particle_right, particle_right_up, particle_left_down,
+         particle_left_up, particle_right_down, particle_random_add, particle_random_minus])
+    function(particle_dict, particle_speed)

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,26 +19,25 @@ class SceneManager(object):
     ):
         super().__init__()
         self.graphic_scene = ExtendGraphicScene()
-        self.graphic_view = ExtendGraphicView(self.graphic_scene)
-        self.graphic_view.showMaximized()
         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)
@@ -47,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
@@ -85,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/sound_player/sound_effect.py

@@ -26,8 +26,7 @@ class SoundEffectWidget(QWidget):
         self.sound_path = Path(sound_path)
         if self.sound_path.exists() and self.sound_path.is_file():
             # QUrl non ascii path encode, Avoid read wrong path and file name
-            source = QUrl.fromLocalFile(str(self.sound_path).encode())
-            source = source.fromEncoded(source.toEncoded())
+            source = QUrl.fromLocalFile(str(self.sound_path))
             print(f"Origin file {str(self.sound_path)}")
             self.sound_player.setSource(source)
             # -2 means loop forever

frontengine/show/sound_player/sound_player.py

@@ -28,8 +28,7 @@ class SoundPlayer(QWidget):
             self.media_player.setAudioOutput(self.media_player_audio)
             self.media_player_audio = self.media_player.audioOutput()
             # QUrl non ascii path encode, Avoid read wrong path and file name
-            source = QUrl.fromLocalFile(str(self.sound_path).encode())
-            source = source.fromEncoded(source.toEncoded())
+            source = QUrl.fromLocalFile(str(self.sound_path))
             print(f"Origin file {str(self.sound_path)}")
             self.media_player.setSource(source)
             self.media_player.setLoops(-1)

frontengine/show/text/draw_text.py

@@ -8,13 +8,26 @@ from PySide6.QtWidgets import QWidget
 
 class TextWidget(QWidget):
 
-    def __init__(self, text: str):
+    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
         self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
         self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
         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")
@@ -38,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(
@@ -46,8 +74,8 @@ class TextWidget(QWidget):
         painter.setPen(Qt.GlobalColor.black)
         painter.setOpacity(self.opacity)
         painter.drawText(
-            QRect(self.x(), self.y(), self.width(), self.height()),
-            Qt.AlignmentFlag.AlignTop | Qt.AlignmentFlag.AlignLeft,
+            QRect(self.draw_location_x, self.draw_location_y, self.width(), self.height()),
+            int(self.alignment),
             self.text
         )
         painter.restore()
@@ -60,4 +88,3 @@ class TextWidget(QWidget):
 
     def mouseGrabber(self) -> None:
         super().mouseGrabber()
-

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,18 +18,15 @@ 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
-            source = QUrl.fromLocalFile(str(self.video_file_path).encode())
-            source = source.fromEncoded(source.toEncoded())
+            source = QUrl.fromLocalFile(str(self.video_file_path))
             print(f"Origin file {str(self.video_file_path)}")
             self.media_player.setSource(source)
             self.media_player.setVideoOutput(self)
@@ -47,6 +45,7 @@ class VideoWidget(QVideoWidget):
         if self.icon_path.exists() and self.icon_path.is_file():
             self.setWindowIcon(QIcon(str(self.icon_path)))
 
+
     def set_ui_window_flag(self, show_on_bottom: bool = False) -> None:
         self.setWindowFlag(
             Qt.WindowType.WindowTransparentForInput |

frontengine/show/web/webview.py

@@ -2,9 +2,9 @@ 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
+from PySide6.QtWidgets import QMessageBox, QMenu
 
 from frontengine.utils.multi_language.language_wrapper import language_wrapper
 
@@ -13,6 +13,8 @@ class WebWidget(QWebEngineView):
 
     def __init__(self, url: str, is_file: bool = False):
         super().__init__()
+        self.menu = None
+        self.close_action = None
         self.opacity: float = 0.2
         self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
         if not is_file:
@@ -21,8 +23,7 @@ class WebWidget(QWebEngineView):
             self.web_url = Path(url)
             if self.web_url.exists() and self.web_url.is_file():
                 # QUrl non ascii path encode, Avoid read wrong path and file name
-                source = QUrl.fromLocalFile(str(self.web_url).encode())
-                source = source.fromEncoded(source.toEncoded())
+                source = QUrl.fromLocalFile(str(self.web_url))
                 print(f"Origin file {str(self.web_url)}")
                 self.load(source)
             else:
@@ -36,6 +37,15 @@ 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):
+        if self.close_action is None:
+            self.close_action = QAction("Close")
+            self.close_action.triggered.connect(self.close)
+        if self.menu is None:
+            self.menu = QMenu(self)
+            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)
@@ -57,6 +67,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:
@@ -64,4 +76,3 @@ class WebWidget(QWebEngineView):
 
     def mouseGrabber(self) -> None:
         super().mouseGrabber()
-

frontengine/{ui/main/system_tray → system_tray}/extend_system_tray.py

@@ -3,8 +3,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from frontengine.ui.main.main_ui import FrontEngineMainUI
-import sys
+    from frontengine.ui.main_ui import FrontEngineMainUI
 
 from PySide6.QtGui import QAction
 from PySide6.QtWidgets import QSystemTrayIcon, QMenu
@@ -34,7 +33,6 @@ class ExtendSystemTray(QSystemTrayIcon):
     def close_all(self):
         self.setVisible(False)
         self.main_window.close()
-        sys.exit(0)
 
     def clicked(self, reason):
         if reason == self.ActivationReason.DoubleClick: