pyloid 0.21.0.dev1__py3-none-any.whl → 0.22.0.dev2__py3-none-any.whl

pyloid/browser_window.py

@@ -8,13 +8,11 @@ from PySide6.QtWebChannel import QWebChannel
 from PySide6.QtGui import (
     QKeySequence,
     QShortcut,
-    QCursor,
 )
-from PySide6.QtCore import Qt, QPoint, QUrl, QEvent, QFile
+from PySide6.QtCore import Qt, QPoint, QUrl, QEvent, QFile, QEventLoop, QTimer, QObject, Signal, Slot
 from PySide6.QtWebEngineCore import (
     QWebEnginePage,
     QWebEngineSettings,
-    QWebEngineUrlRequestInterceptor,
 )
 from .api import PyloidAPI
 import uuid
@@ -25,19 +23,14 @@ from PySide6.QtWidgets import (
     QVBoxLayout,
 )
 from .custom.titlebar import CustomTitleBar
-from .js_api.window_api import WindowAPI
+from .js_api.base import BaseAPI
 from PySide6.QtGui import QPixmap, QMovie
 from PySide6.QtWidgets import QSplashScreen, QLabel
-from typing import TYPE_CHECKING
-from PySide6.QtWebEngineCore import (
-    QWebEngineSettings,
-    QWebEngineDesktopMediaRequest,
-    QWebEngineUrlRequestInterceptor,
-)
-from .utils import get_production_path, is_production
+from typing import TYPE_CHECKING, Any
+from PySide6.QtWebEngineCore import QWebEngineSettings, QWebEngineDesktopMediaRequest
 
 if TYPE_CHECKING:
-    from ..pyloid import Pyloid
+    from .pyloid import _Pyloid
 
 
 class CustomWebPage(QWebEnginePage):
@@ -72,6 +65,7 @@ class CustomWebPage(QWebEnginePage):
         self._permission_handlers[feature] = handler
 
     def _handleDesktopMediaRequest(self, request: QWebEngineDesktopMediaRequest):
+        return
         print("Desktop media request received:", request)
 
         # 사용 가능한 화면 목록 확인
@@ -89,79 +83,66 @@ class CustomWebPage(QWebEnginePage):
             window_index = windows_model.index(i)
             window_name = windows_model.data(window_index)
             print(f"Window {i}: {window_name}")
-
+            
         request.selectWindow(windows_model.index(3))
 
-    # interceptor ( navigation request )
-    def acceptNavigationRequest(self, url, navigation_type, is_main_frame):
-        """네비게이션 요청을 처리하는 메서드"""
-        url_string = url.toString()
-        print(f"Navigation Request - URL: {url_string}")
-        print(f"Navigation Type: {navigation_type}")
-        print(f"Is Main Frame: {is_main_frame}")
+    # # interceptor ( navigation request )
+    # def acceptNavigationRequest(self, url, navigation_type, is_main_frame):
+    #     """네비게이션 요청을 처리하는 메서드"""
+    #     print(f"Navigation Request - URL: {url.toString()}")
+    #     print(f"Navigation Type: {navigation_type}")
+    #     print(f"Is Main Frame: {is_main_frame}")
 
-        # file:// 프로토콜 처리
-        if url.scheme() == "file":
-            # 파일 경로에서 file:/// 제거
-            file_path = url_string.replace("file:///", "").rstrip("/")
-
-            # HTML 파일이 아닌 경우에만 index.html로 리다이렉트
-            if not file_path.endswith(".html"):
-                base_path = os.path.dirname(file_path)
-                self.setUrl(QUrl.fromLocalFile(os.path.join(base_path, "index.html")))
-                return False
-
-        return True
+    #     return True
 
 
 # interceptor ( all url request )
-class CustomUrlInterceptor(QWebEngineUrlRequestInterceptor):
-    def interceptRequest(self, info):
-        url = info.requestUrl().toString()
-        print(url)
-
+# class CustomUrlInterceptor(QWebEngineUrlRequestInterceptor):
+#     def interceptRequest(self, info):
+#         url = info.requestUrl().toString()
+#         print(url)
 
 # class CustomInterceptor(QWebEngineUrlRequestInterceptor):
 #     def __init__(self, index_path=None):
 #         super().__init__()
 #         self.index_path = get_production_path()
 #         self.last_path = "/"
-
+        
 #     def interceptRequest(self, info):
 #         url = info.requestUrl()
 #         navigation_type = info.navigationType()
 
 #         print("--------------------------------")
-
+        
 #         if navigation_type == QWebEnginePage.NavigationType.NavigationTypeTyped:
 #             print("NavigationTypeTyped")
-
+            
 #         if navigation_type == QWebEnginePage.NavigationType.NavigationTypeReload:
 #             print("NavigationTypeReload")
-
+            
 #         if navigation_type == QWebEnginePage.NavigationType.NavigationTypeBackForward:
 #             print("NavigationTypeBackForward")
-
+        
 #         if navigation_type == QWebEnginePage.NavigationType.NavigationTypeLinkClicked:
 #             print("NavigationTypeLinkClicked")
-
+            
 #         if navigation_type == QWebEnginePage.NavigationType.NavigationTypeFormSubmitted:
 #             print("NavigationTypeFormSubmitted")
-
+            
 #         if navigation_type == QWebEnginePage.NavigationType.NavigationTypeTyped:
 #             print("NavigationTypeTyped")
-
+            
 #         if navigation_type == QWebEnginePage.NavigationType.NavigationTypeOther:
 #             print("NavigationTypeOther")
-
+            
 #         print(navigation_type.value)
-
+        
 #         print(url)
 #         print(url.scheme())
 #         print(url.host())
 #         print(url.url())
 #         print(self.last_path)
-
+        
 #         self.last_path = url.path()
 
 
@@ -307,10 +288,10 @@ class CustomWebEngineView(QWebEngineView):
             self.resize_start_pos = global_pos
 
 
-class BrowserWindow:
+class _BrowserWindow:
     def __init__(
         self,
-        app: "Pyloid",
+        app: "_Pyloid",
         title: str = "pyloid app",
         width: int = 800,
         height: int = 600,
@@ -337,7 +318,7 @@ class BrowserWindow:
         self.frame = frame
         self.context_menu = context_menu
         self.dev_tools = dev_tools
-        self.js_apis = [WindowAPI()]
+        self.js_apis = [BaseAPI(self.id, self.app.data)]
         for js_api in js_apis:
             self.js_apis.append(js_api)
         self.shortcuts = {}
@@ -489,10 +470,10 @@ class BrowserWindow:
 
         # Set F12 shortcut
         self.set_dev_tools(self.dev_tools)
-
+        
         # 프로필 가져오기 및 인터셉터 설정
         profile = self.web_view.page().profile()
-
+        
         # # 기존 인터셉터가 있다면 제거
         # if self.interceptor:
         #     profile.setUrlRequestInterceptor(None)
@@ -552,7 +533,7 @@ class BrowserWindow:
                     
                     document.addEventListener('mousedown', function (e) {
                         if (e.target.hasAttribute('data-pyloid-drag-region')) {
-                            window.pyloid.WindowAPI.startSystemDrag();
+                            window.pyloid.BaseAPI.startSystemDrag();
                         }
                     });
                     
@@ -885,9 +866,9 @@ class BrowserWindow:
 
     def _remove_from_app_windows(self):
         """Removes the window from the app's window list."""
-        if self in self.app.windows:
-            self.app.windows.remove(self)
-        if not self.app.windows:
+        if self in self.app.windows_dict:
+            self.app.windows_dict.pop(self.id)
+        if not self.app.windows_dict:
             self.app.quit()  # Quit the app if all windows are closed
 
     ###########################################################################################
@@ -927,11 +908,14 @@ class BrowserWindow:
         >>> window = app.create_window("pyloid-window")
         >>> window.focus()
         """
+        was_on_top = bool(self._window.windowFlags() & Qt.WindowStaysOnTopHint)
+        if not was_on_top:
+            self._window.setWindowFlag(Qt.WindowStaysOnTopHint, True)
+            self._window.show()
         self._window.activateWindow()
-        self._window.raise_()
-        self._window.setWindowState(
-            self._window.windowState() & ~Qt.WindowMinimized | Qt.WindowActive
-        )
+        if not was_on_top:
+            self._window.setWindowFlag(Qt.WindowStaysOnTopHint, False)
+            self._window.show()
 
     def show_and_focus(self):
         """
@@ -943,12 +927,14 @@ class BrowserWindow:
         >>> window = app.create_window("pyloid-window")
         >>> window.show_and_focus()
         """
-        self._window.show()
+        was_on_top = bool(self._window.windowFlags() & Qt.WindowStaysOnTopHint)
+        if not was_on_top:
+            self._window.setWindowFlag(Qt.WindowStaysOnTopHint, True)
+            self._window.show()
         self._window.activateWindow()
-        self._window.raise_()
-        self._window.setWindowState(
-            self._window.windowState() & ~Qt.WindowMinimized | Qt.WindowActive
-        )
+        if not was_on_top:
+            self._window.setWindowFlag(Qt.WindowStaysOnTopHint, False)
+            self._window.show()
 
     def close(self):
         """
@@ -1190,9 +1176,9 @@ class BrowserWindow:
     ###########################################################################################
     # Event (Calling the JS from Python)
     ###########################################################################################
-    def emit(self, event_name, data: Optional[Dict] = None):
+    def invoke(self, event_name, data: Optional[Dict] = None):
         """
-        Emits an event to the JavaScript side.
+        Invokes an event to the JavaScript side.
 
         Parameters
         ----------
@@ -1208,7 +1194,7 @@ class BrowserWindow:
         app = Pyloid(app_name="Pyloid-App")
 
         window = app.create_window("pyloid-window")
-        window.emit("customEvent", {"message": "Hello, Pyloid!"})
+        window.invoke("customEvent", {"message": "Hello, Pyloid!"})
 
         app.run()
         ```
@@ -1590,52 +1576,52 @@ class BrowserWindow:
     ###########################################################################################
     # For Custom Pyside6 Features
     ###########################################################################################
-    def get_QMainWindow(self) -> QMainWindow:
-        """
-        Returns the QMainWindow object of the window.
+    # def get_QMainWindow(self) -> QMainWindow:
+    #     """
+    #     Returns the QMainWindow object of the window.
 
-        you can use all the features of QMainWindow for customizing the window.
+    #     you can use all the features of QMainWindow for customizing the window.
 
-        Returns
-        -------
-        QMainWindow
-            QMainWindow object of the window
+    #     Returns
+    #     -------
+    #     QMainWindow
+    #         QMainWindow object of the window
 
-        Examples
-        --------
-        ```python
-        from PySide6.QtCore import Qt
-        from pyloid import Pyloid
+    #     Examples
+    #     --------
+    #     ```python
+    #     from PySide6.QtCore import Qt
+    #     from pyloid import Pyloid
 
-        app = Pyloid(app_name="Pyloid-App")
+    #     app = Pyloid(app_name="Pyloid-App")
 
-        window = app.create_window("pyloid-window")
-        qmain = window.get_QMainWindow()
+    #     window = app.create_window("pyloid-window")
+    #     qmain = window.get_QMainWindow()
 
-        qmain.setWindowFlags(qmain.windowFlags() | Qt.WindowStaysOnTopHint) # window stays on top
-        ```
-        """
-        return self._window
+    #     qmain.setWindowFlags(qmain.windowFlags() | Qt.WindowStaysOnTopHint) # window stays on top
+    #     ```
+    #     """
+    #     return self._window
 
-    def get_QWebEngineView(self) -> CustomWebEngineView:
-        """
-        Returns the CustomWebEngineView object which inherits from QWebEngineView.
+    # def get_QWebEngineView(self) -> CustomWebEngineView:
+    #     """
+    #     Returns the CustomWebEngineView object which inherits from QWebEngineView.
 
-        Returns
-        -------
-        CustomWebEngineView
-            CustomWebEngineView object of the window
+    #     Returns
+    #     -------
+    #     CustomWebEngineView
+    #         CustomWebEngineView object of the window
 
-        Examples
-        --------
-        ```python
-        window = app.create_window("pyloid-window")
-        web_view = window.get_QWebEngineView()
+    #     Examples
+    #     --------
+    #     ```python
+    #     window = app.create_window("pyloid-window")
+    #     web_view = window.get_QWebEngineView()
 
-        web_view.page().runJavaScript("console.log('Hello, Pyloid!')")
-        ```
-        """
-        return self.web_view
+    #     web_view.page().runJavaScript("console.log('Hello, Pyloid!')")
+    #     ```
+    #     """
+    #     return self.web_view
 
     ###########################################################################################
     # QMainWindow flags
@@ -1733,7 +1719,7 @@ class BrowserWindow:
         Examples
         --------
         ```python
-        window.set_image_splash_screen("./assets/loading.png", close_on_load=True, stay_on_top=True)
+        window.set_static_image_splash_screen("./assets/loading.png", close_on_load=True, stay_on_top=True)
         ```
         """
         pixmap = QPixmap(image_path)
@@ -1871,150 +1857,1121 @@ class BrowserWindow:
     ###########################################################################################
     # WebEngineView Attribute setting
     ###########################################################################################
-    def set_web_engine_view_attribute(self, attribute: QWebEngineSettings, on: bool):
+    # def set_web_engine_view_attribute(self, attribute: QWebEngineSettings, on: bool):
+    #     """
+    #     Sets the attribute of the WebEngineView.
+
+    #     Parameters
+    #     ----------
+    #     attribute : QWebEngineSettings
+    #         Attribute to set
+    #     on : bool
+    #         True to enable the attribute, False to disable it
+
+    #     Examples
+    #     --------
+    #     ```python
+    #     window.set_web_engine_view_attribute(QWebEngineSettings.WebAttribute.ScreenCaptureEnabled, False)
+    #     ```
+    #     """
+    #     settings = self.web_view.settings()
+    #     settings.setAttribute(attribute, on)
+
+    # def is_web_engine_view_attribute(self, attribute: QWebEngineSettings) -> bool:
+    #     """
+    #     Returns the attribute of the WebEngineView.
+
+    #     Parameters
+    #     ----------
+    #     attribute : QWebEngineSettings
+    #         Attribute to get
+
+    #     Returns
+    #     -------
+    #     bool
+    #         True if the attribute is enabled, False otherwise
+
+    #     Examples
+    #     --------
+    #     ```python
+    #     window.is_web_engine_view_attribute(QWebEngineSettings.WebAttribute.ScreenCaptureEnabled)
+    #     ```
+    #     """
+    #     settings = self.web_view.settings()
+    #     return settings.testAttribute(attribute)
+
+    # def set_permission_handler(self, feature: QWebEnginePage.Feature, handler):
+    #     """
+    #     Sets a handler for a specific permission.
+
+    #     Parameters
+    #     ----------
+    #     feature : QWebEnginePage.Feature
+    #         The type of permission to set
+    #     handler : callable
+    #         The handler function to process the permission request
+
+    #     Examples
+    #     --------
+    #     ```python
+    #     def handle_camera(origin, feature):
+    #         window.web_view.page().setFeaturePermission(
+    #             origin,
+    #             feature,
+    #             QWebEnginePage.PermissionPolicy.PermissionGrantedByUser
+    #         )
+
+    #     window.set_permission_handler(
+    #         QWebEnginePage.Feature.MediaVideoCapture,
+    #         handle_camera
+    #     )
+    #     ```
+    #     """
+    #     self.web_view.custom_page.setPermissionHandler(feature, handler)
+
+    # def grant_permission(self, feature: QWebEnginePage.Feature):
+    #     """
+    #     Automatically grants a specific permission when a request is made.
+
+    #     Parameters
+    #     ----------
+    #     feature : QWebEnginePage.Feature
+    #         The type of permission to automatically grant
+
+    #     Examples
+    #     --------
+    #     ```python
+    #     window.grant_permission(QWebEnginePage.Feature.MediaVideoCapture)
+    #     ```
+    #     """
+
+    #     def auto_grant(origin, feat):
+    #         self.web_view.page().setFeaturePermission(
+    #             origin, feat, QWebEnginePage.PermissionPolicy.PermissionGrantedByUser
+    #         )
+
+    #     self.set_permission_handler(feature, auto_grant)
+
+    # def deny_permission(self, feature: QWebEnginePage.Feature):
+    #     """
+    #     Automatically denies a specific permission when a request is made.
+
+    #     Parameters
+    #     ----------
+    #     feature : QWebEnginePage.Feature
+    #         The type of permission to automatically deny
+
+    #     Examples
+    #     --------
+    #     ```python
+    #     window.deny_permission(QWebEnginePage.Feature.Notifications)
+    #     ```
+    #     """
+
+    #     def auto_deny(origin, feat):
+    #         self.web_view.page().setFeaturePermission(
+    #             origin, feat, QWebEnginePage.PermissionPolicy.PermissionDeniedByUser
+    #         )
+
+    #     self.set_permission_handler(feature, auto_deny)
+
+    # def set_desktop_media_handler(self, handler):
+    #     """
+    #     데스크톱 미디어(화면/윈도우) 선택 핸들러를 설정합니다.
+
+    #     Parameters
+    #     ----------
+    #     handler : callable
+    #         요청을 처리할 핸들러 함수. QWebEngineDesktopMediaRequest 인자로 받습니다.
+
+    #     Examples
+    #     --------
+    #     ```python
+    #     def custom_media_handler(request):
+    #         # 사용 가능한 화면 목록 출력
+    #         for screen in request.screenList():
+    #             print(f"Screen: {screen.name}")
+
+    #         # 사용 가능한 윈도우 목록 출력
+    #         for window in request.windowList():
+    #             print(f"Window: {window.name}")
+
+    #         # 첫 번째 화면 선택
+    #         if request.screenList():
+    #             request.selectScreen(request.screenList()[0])
+
+    #     window.set_desktop_media_handler(custom_media_handler)
+    #     ```
+    #     """
+    #     self.web_view.custom_page.setDesktopMediaHandler(handler)
+
+
+# This wrapper class work in other thread
+class BrowserWindow(QObject):
+    command_signal = Signal(str, str, object)
+    result_signal = Signal(str, object)
+    
+    def __init__(self, app, title: str, width: int, height: int, x: int, y: int, frame: bool, context_menu: bool, dev_tools: bool, js_apis: List[PyloidAPI]):
+        super().__init__()
+        self._window = _BrowserWindow(app, title, width, height, x, y, frame, context_menu, dev_tools, js_apis)
+        self.command_signal.connect(self._handle_command)
+    
+    @Slot(str, str, object)
+    def _handle_command(self, command_id: str, command_type: str, params: object) -> None:
+        """
+        Handles commands sent from multiple threads.
+        Calls the corresponding method of _BrowserWindow based on the command type and returns the result.
+
+        :param command_id: Unique identifier for each command
+        :param command_type: Type of command to execute (e.g., "load_file", "set_title", etc.)
+        :param params: Object containing parameters needed for command execution
+        """
+        result = None
+
+        if command_type == "load_file":
+            result = self._window.load_file(params["file_path"])
+        elif command_type == "load_url":
+            result = self._window.load_url(params["url"])
+        elif command_type == "load_html":
+            html_content = params.get("html_content", "")
+            base_url = params.get("base_url", "")
+            result = self._window.load_html(html_content, base_url)
+        elif command_type == "set_title":
+            result = self._window.set_title(params["title"])
+        elif command_type == "set_size":
+            result = self._window.set_size(params["width"], params["height"])
+        elif command_type == "set_position":
+            result = self._window.set_position(params["x"], params["y"])
+        elif command_type == "set_position_by_anchor":
+            result = self._window.set_position_by_anchor(params["anchor"])
+        elif command_type == "set_frame":
+            result = self._window.set_frame(params["frame"])
+        elif command_type == "set_context_menu":
+            result = self._window.set_context_menu(params["context_menu"])
+        elif command_type == "set_dev_tools":
+            result = self._window.set_dev_tools(params["enable"])
+        elif command_type == "open_dev_tools":
+            result = self._window.open_dev_tools()
+        elif command_type == "hide":
+            result = self._window.hide()
+        elif command_type == "show":
+            result = self._window.show()
+        elif command_type == "focus":
+            result = self._window.focus()
+        elif command_type == "show_and_focus":
+            result = self._window.show_and_focus()
+        elif command_type == "close":
+            result = self._window.close()
+        elif command_type == "fullscreen":
+            result = self._window.fullscreen()
+        elif command_type == "toggle_fullscreen":
+            result = self._window.toggle_fullscreen()
+        elif command_type == "minimize":
+            result = self._window.minimize()
+        elif command_type == "maximize":
+            result = self._window.maximize()
+        elif command_type == "unmaximize":
+            result = self._window.unmaximize()
+        elif command_type == "toggle_maximize":
+            result = self._window.toggle_maximize()
+        elif command_type == "is_fullscreen":
+            result = self._window.is_fullscreen()
+        elif command_type == "is_maximized":
+            result = self._window.is_maximized()
+        elif command_type == "capture":
+            result = self._window.capture(params["save_path"])
+        elif command_type == "add_shortcut":
+            result = self._window.add_shortcut(params["key_sequence"], params["callback"])
+        elif command_type == "remove_shortcut":
+            result = self._window.remove_shortcut(params["key_sequence"])
+        elif command_type == "get_all_shortcuts":
+            result = self._window.get_all_shortcuts()
+        elif command_type == "emit":
+            event_name = params["event_name"]
+            data = params.get("data")
+            result = self._window.invoke(event_name, data)
+        elif command_type == "get_window_properties":
+            result = self._window.get_window_properties()
+        elif command_type == "get_id":
+            result = self._window.get_id()
+        elif command_type == "get_size":
+            result = self._window.get_size()
+        elif command_type == "get_position":
+            result = self._window.get_position()
+        elif command_type == "get_title":
+            result = self._window.get_title()
+        elif command_type == "get_url":
+            result = self._window.get_url()
+        elif command_type == "get_visible":
+            result = self._window.get_visible()
+        elif command_type == "get_frame":
+            result = self._window.get_frame()
+        elif command_type == "set_resizable":
+            result = self._window.set_resizable(params["resizable"])
+        elif command_type == "set_minimum_size":
+            result = self._window.set_minimum_size(params["min_width"], params["min_height"])
+        elif command_type == "set_maximum_size":
+            result = self._window.set_maximum_size(params["max_width"], params["max_height"])
+        elif command_type == "get_minimum_size":
+            result = self._window.get_minimum_size()
+        elif command_type == "get_maximum_size":
+            result = self._window.get_maximum_size()
+        elif command_type == "get_resizable":
+            result = self._window.get_resizable()
+        elif command_type == "set_static_image_splash_screen":
+            result = self._window.set_static_image_splash_screen(
+                params["image_path"],
+                params.get("close_on_load", True),
+                params.get("stay_on_top", True),
+                params.get("clickable", True),
+                params.get("position", "center")
+            )
+        elif command_type == "set_gif_splash_screen":
+            result = self._window.set_gif_splash_screen(
+                params["gif_path"],
+                params.get("close_on_load", True),
+                params.get("stay_on_top", True),
+                params.get("clickable", True),
+                params.get("position", "center")
+            )
+        elif command_type == "close_splash_screen":
+            result = self._window.close_splash_screen()
+        else:
+            return None
+
+        self.result_signal.emit(command_id, result)
+    
+    def execute_command(self, command_type: str, params: object, timeout: Optional[int] = None):
+        command_id = str(uuid.uuid4())
+        
+        result_data = [None]
+        loop = QEventLoop()
+        
+        if timeout:
+            timer = QTimer()
+            timer.setSingleShot(True)
+            timer.timeout.connect(loop.quit)
+            timer.start(timeout)
+        
+        def on_result(received_id, result):
+            if received_id == command_id:
+                result_data[0] = result     
+                loop.quit()
+
+        
+        self.result_signal.connect(on_result, Qt.QueuedConnection)
+        
+        self.command_signal.emit(command_id, command_type, params)
+                
+        loop.exec()
+                
+        self.result_signal.disconnect(on_result)
+        
+        return result_data[0]
+    
+    # -------------------------------------------------------------------
+    # Execute_command wrapper functions
+    # -------------------------------------------------------------------
+    def load_file(self, file_path: str) -> None:
         """
-        Sets the attribute of the WebEngineView.
+        Loads a local HTML file into the web view.
 
         Parameters
         ----------
-        attribute : QWebEngineSettings
-            Attribute to set
-        on : bool
-            True to enable the attribute, False to disable it
+        file_path : str
+            The path to the local HTML file to be loaded.
 
         Examples
         --------
-        ```python
-        window.set_web_engine_view_attribute(QWebEngineSettings.WebAttribute.ScreenCaptureEnabled, False)
-        ```
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> window.load_file('/path/to/local/file.html')
+        >>> window.show()
         """
-        settings = self.web_view.settings()
-        settings.setAttribute(attribute, on)
+        return self.execute_command("load_file", {"file_path": file_path})
 
-    def is_web_engine_view_attribute(self, attribute: QWebEngineSettings) -> bool:
+    def load_url(self, url: str) -> None:
         """
-        Returns the attribute of the WebEngineView.
+        Sets the URL of the window.
 
         Parameters
         ----------
-        attribute : QWebEngineSettings
-            Attribute to get
+        url : str
+            The URL to be loaded in the web view.
 
-        Returns
-        -------
-        bool
-            True if the attribute is enabled, False otherwise
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> window.load_url('https://www.example.com')
+        >>> window.show()
+        """
+        return self.execute_command("load_url", {"url": url})
+
+    def load_html(self, html_content: str, base_url: str = "") -> None:
+        """
+        Loads HTML content directly into the web view.
+
+        Parameters
+        ----------
+        html_content : str
+            The HTML content to be loaded.
+        base_url : str, optional
+            The base URL to use for resolving relative URLs (default is "").
 
         Examples
         --------
-        ```python
-        window.is_web_engine_view_attribute(QWebEngineSettings.WebAttribute.ScreenCaptureEnabled)
-        ```
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> html_content = "<html><body><h1>Hello, Pyloid!</h1></body></html>"
+        >>> window.load_html(html_content)
+        >>> window.show()
         """
-        settings = self.web_view.settings()
-        return settings.testAttribute(attribute)
+        return self.execute_command("load_html", {"html_content": html_content, "base_url": base_url})
 
-    def set_permission_handler(self, feature: QWebEnginePage.Feature, handler):
+    def set_title(self, title: str) -> None:
         """
-        Sets a handler for a specific permission.
+        Sets the title of the window.
 
         Parameters
         ----------
-        feature : QWebEnginePage.Feature
-            The type of permission to set
-        handler : callable
-            The handler function to process the permission request
+        title : str
+            The title to be set for the window.
 
         Examples
         --------
-        ```python
-        def handle_camera(origin, feature):
-            window.web_view.page().setFeaturePermission(
-                origin,
-                feature,
-                QWebEnginePage.PermissionPolicy.PermissionGrantedByUser
-            )
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> window.set_title('My Window Title')
+        """
+        return self.execute_command("set_title", {"title": title})
 
-        window.set_permission_handler(
-            QWebEnginePage.Feature.MediaVideoCapture,
-            handle_camera
-        )
-        ```
+    def set_size(self, width: int, height: int) -> None:
+        """
+        Sets the size of the window.
+
+        Parameters
+        ----------
+        width : int
+            The width of the window.
+        height : int
+            The height of the window.
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> window.set_size(800, 600)
         """
-        self.web_view.custom_page.setPermissionHandler(feature, handler)
+        return self.execute_command("set_size", {"width": width, "height": height})
 
-    def grant_permission(self, feature: QWebEnginePage.Feature):
+    def set_position(self, x: int, y: int) -> None:
         """
-        Automatically grants a specific permission when a request is made.
+        Sets the position of the window.
 
         Parameters
         ----------
-        feature : QWebEnginePage.Feature
-            The type of permission to automatically grant
+        x : int
+            The x-coordinate of the window's position.
+        y : int
+            The y-coordinate of the window's position.
 
         Examples
         --------
-        ```python
-        window.grant_permission(QWebEnginePage.Feature.MediaVideoCapture)
-        ```
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> window.set_position(100, 100)
         """
+        return self.execute_command("set_position", {"x": x, "y": y})
 
-        def auto_grant(origin, feat):
-            self.web_view.page().setFeaturePermission(
-                origin, feat, QWebEnginePage.PermissionPolicy.PermissionGrantedByUser
-            )
+    def set_position_by_anchor(self, anchor: str) -> None:
+        """
+        Positions the window at a specific location on the screen.
+
+        Parameters
+        ----------
+        anchor : str
+            The anchor point indicating where to position the window.
+            Possible values: 'center', 'top', 'bottom', 'left', 'right',
+                             'top-left', 'top-right', 'bottom-left', 'bottom-right'
 
-        self.set_permission_handler(feature, auto_grant)
+        Examples
+        --------
+        >>> window.set_position_by_anchor('center')
+        >>> window.set_position_by_anchor('top-right')
+        """
+        return self.execute_command("set_position_by_anchor", {"anchor": anchor})
 
-    def deny_permission(self, feature: QWebEnginePage.Feature):
+    def set_frame(self, frame: bool) -> None:
         """
-        Automatically denies a specific permission when a request is made.
+        Sets the frame of the window.
 
         Parameters
         ----------
-        feature : QWebEnginePage.Feature
-            The type of permission to automatically deny
+        frame : bool
+            If True, the window will have a frame. If False, the window will be frameless.
 
         Examples
         --------
-        ```python
-        window.deny_permission(QWebEnginePage.Feature.Notifications)
-        ```
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> window.set_frame(True)
+        >>> window.set_frame(False)
         """
+        return self.execute_command("set_frame", {"frame": frame})
 
-        def auto_deny(origin, feat):
-            self.web_view.page().setFeaturePermission(
-                origin, feat, QWebEnginePage.PermissionPolicy.PermissionDeniedByUser
-            )
+    def set_context_menu(self, context_menu: bool) -> None:
+        """
+        Sets the context menu of the window.
+
+        Parameters
+        ----------
+        context_menu : bool
+            If True, the context menu will be disabled. If False, the default context menu will be enabled.
 
-        self.set_permission_handler(feature, auto_deny)
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> window.set_context_menu(True)
+        >>> window.set_context_menu(False)
+        """
+        return self.execute_command("set_context_menu", {"context_menu": context_menu})
 
-    def set_desktop_media_handler(self, handler):
+    def set_dev_tools(self, enable: bool) -> None:
         """
-        데스크톱 미디어(화면/윈도우) 선택 핸들러를 설정합니다.
+        Sets the developer tools of the window.
+
+        If enabled, the developer tools can be opened using the F12 key.
 
         Parameters
         ----------
-        handler : callable
-            요청을 처리할 핸들러 함수. QWebEngineDesktopMediaRequest 인자로 받습니다.
+        enable : bool
+            If True, the developer tools will be enabled. If False, the developer tools will be disabled.
 
         Examples
         --------
-        ```python
-        def custom_media_handler(request):
-            # 사용 가능한 화면 목록 출력
-            for screen in request.screenList():
-                print(f"Screen: {screen.name}")
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> window.set_dev_tools(True)
+        >>> window.set_dev_tools(False)
+        """
+        return self.execute_command("set_dev_tools", {"enable": enable})
+
+    def open_dev_tools(self) -> None:
+        """
+        Opens the developer tools window.
 
-            # 사용 가능한 윈도우 목록 출력
-            for window in request.windowList():
-                print(f"Window: {window.name}")
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> window.open_dev_tools()
+        """
+        return self.execute_command("open_dev_tools", {})
 
-            # 첫 번째 화면 선택
-            if request.screenList():
-                request.selectScreen(request.screenList()[0])
+    def hide(self) -> None:
+        """
+        Hides the window.
 
-        window.set_desktop_media_handler(custom_media_handler)
-        ```
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> window.hide()
+        """
+        return self.execute_command("hide", {})
+
+    def show(self) -> None:
+        """
+        Shows the window.
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> window.show()
+        """
+        return self.execute_command("show", {})
+
+    def focus(self) -> None:
+        """
+        Focuses the window.
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> window.focus()
+        """
+        return self.execute_command("focus", {})
+
+    def show_and_focus(self) -> None:
+        """
+        Shows and focuses the window.
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> window.show_and_focus()
+        """
+        return self.execute_command("show_and_focus", {})
+
+    def close(self) -> None:
+        """
+        Closes the window.
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> window.close()
+        """
+        return self.execute_command("close", {})
+
+    def fullscreen(self) -> None:
+        """
+        Enters fullscreen mode.
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> window.fullscreen()
+        """
+        return self.execute_command("fullscreen", {})
+
+    def toggle_fullscreen(self) -> None:
+        """
+        Toggles the fullscreen mode of the window.
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> window.toggle_fullscreen()
+        """
+        return self.execute_command("toggle_fullscreen", {})
+
+    def minimize(self) -> None:
+        """
+        Minimizes the window.
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> window.minimize()
+        """
+        return self.execute_command("minimize", {})
+
+    def maximize(self) -> None:
+        """
+        Maximizes the window.
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> window.maximize()
+        """
+        return self.execute_command("maximize", {})
+
+    def unmaximize(self) -> None:
+        """
+        Restores the window from maximized state.
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> window.unmaximize()
+        """
+        return self.execute_command("unmaximize", {})
+
+    def toggle_maximize(self) -> None:
+        """
+        Toggles the maximized state of the window.
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> window.toggle_maximize()
+        """
+        return self.execute_command("toggle_maximize", {})
+
+    def is_fullscreen(self) -> bool:
+        """
+        Returns True if the window is fullscreen.
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> window.is_fullscreen()
+        """
+        return self.execute_command("is_fullscreen", {})
+
+    def is_maximized(self) -> bool:
+        """
+        Returns True if the window is maximized.
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> window.is_maximized()
+        """
+        return self.execute_command("is_maximized", {})
+
+    def capture(self, save_path: str) -> "Optional[str]":
+        """
+        Captures the current window.
+
+        Parameters
+        ----------
+        save_path : str
+            Path to save the captured image. If not specified, it will be saved in the current directory.
+
+        Returns
+        -------
+        Optional[str]
+            Returns the path of the saved image.
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> save_path = window.capture("screenshot.png")
+        >>> print(f"Image saved at: {save_path}")
+        """
+        return self.execute_command("capture", {"save_path": save_path})
+
+    def add_shortcut(self, key_sequence: str, callback: Callable) -> Any:
+        """
+        Adds a keyboard shortcut to the window if it does not already exist.
+
+        Parameters
+        ----------
+        key_sequence : str
+            Shortcut sequence (e.g., "Ctrl+C")
+        callback : Callable
+            Function to be executed when the shortcut is pressed
+
+        Returns
+        -------
+        QShortcut or None
+            Created QShortcut object or None if the shortcut already exists
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> def on_shortcut():
+        ...     print("Shortcut activated!")
+        >>> window.add_shortcut("Ctrl+C", on_shortcut)
+        >>> app.run()
+        """
+        return self.execute_command("add_shortcut", {"key_sequence": key_sequence, "callback": callback})
+
+    def remove_shortcut(self, key_sequence: str) -> None:
+        """
+        Removes a keyboard shortcut from the window.
+
+        Parameters
+        ----------
+        key_sequence : str
+            Shortcut sequence to be removed
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> window.remove_shortcut("Ctrl+C")
+        >>> app.run()
+        """
+        return self.execute_command("remove_shortcut", {"key_sequence": key_sequence})
+
+    def get_all_shortcuts(self) -> dict:
+        """
+        Returns all registered shortcuts in the window.
+
+        Returns
+        -------
+        dict
+            Dictionary of shortcut sequences and QShortcut objects
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> shortcuts = window.get_all_shortcuts()
+        >>> print(shortcuts)
+        >>> app.run()
+        """
+        return self.execute_command("get_all_shortcuts", {})
+
+    def invoke(self, event_name: str, data: "Optional[Dict]" = None) -> None:
+        """
+        Invokes an event to the JavaScript side.
+
+        Parameters
+        ----------
+        event_name : str
+            Name of the event
+        data : dict, optional
+            Data to be sent with the event (default is None)
+
+        Examples
+        --------
+        (Python)
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> window.invoke("customEvent", {"message": "Hello, Pyloid!"})
+
+        (JavaScript)
+        >>> document.addEventListener('customEvent', (data) => {
+        ...     console.log(data.message);
+        ... });
+        """
+        return self.execute_command("invoke", {"event_name": event_name, "data": data})
+
+    def get_window_properties(self) -> dict:
+        """
+        Returns the properties of the window.
+
+        Returns
+        -------
+        dict
+            Dictionary containing the properties of the window
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> properties = window.get_window_properties()
+        >>> print(properties)
+        >>> app.run()
+        """
+        return self.execute_command("get_window_properties", {})
+
+    def get_id(self) -> str:
+        """
+        Returns the ID of the window.
+
+        Returns
+        -------
+        str
+            ID of the window
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> window_id = window.get_id()
+        >>> print(window_id)
+        >>> app.run()
+        """
+        return self.execute_command("get_id", {})
+
+    def get_size(self) -> "Dict[str, int]":
+        """
+        Returns the size of the window.
+
+        Returns
+        -------
+        dict
+            Dictionary containing the width and height of the window
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> size = window.get_size()
+        >>> print(size)
+        >>> app.run()
+        """
+        return self.execute_command("get_size", {})
+
+    def get_position(self) -> "Dict[str, int]":
+        """
+        Returns the position of the window.
+
+        Returns
+        -------
+        dict
+            Dictionary containing the x and y coordinates of the window
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> position = window.get_position()
+        >>> print(position)
+        >>> app.run()
+        """
+        return self.execute_command("get_position", {})
+
+    def get_title(self) -> str:
+        """
+        Returns the title of the window.
+
+        Returns
+        -------
+        str
+            Title of the window
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> title = window.get_title()
+        >>> print(title)
+        >>> app.run()
+        """
+        return self.execute_command("get_title", {})
+
+    def get_url(self) -> str:
+        """
+        Returns the URL of the window.
+
+        Returns
+        -------
+        str
+            URL of the window
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> url = window.get_url()
+        >>> print(url)
+        >>> app.run()
+        """
+        return self.execute_command("get_url", {})
+
+    def get_visible(self) -> bool:
+        """
+        Returns the visibility of the window.
+
+        Returns
+        -------
+        bool
+            True if the window is visible, False otherwise
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> visible = window.get_visible()
+        >>> print(visible)
+        >>> app.run()
+        """
+        return self.execute_command("get_visible", {})
+
+    def get_frame(self) -> bool:
+        """
+        Returns the frame enabled state of the window.
+
+        Returns
+        -------
+        bool
+            True if the frame is enabled, False otherwise
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> frame = window.get_frame()
+        >>> print(frame)
+        >>> app.run()
+        """
+        return self.execute_command("get_frame", {})
+
+    def set_resizable(self, resizable: bool) -> None:
+        """
+        Sets the resizability of the window.
+
+        Parameters
+        ----------
+        resizable : bool
+            True to make the window resizable, False to make it fixed size
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> window.set_resizable(True)
+        >>> app.run()
+        """
+        return self.execute_command("set_resizable", {"resizable": resizable})
+
+    def set_minimum_size(self, min_width: int, min_height: int) -> None:
+        """
+        Sets the minimum size of the window.
+
+        Parameters
+        ----------
+        min_width : int
+            Minimum width of the window
+        min_height : int
+            Minimum height of the window
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> window.set_minimum_size(400, 300)
+        >>> app.run()
+        """
+        return self.execute_command("set_minimum_size", {"min_width": min_width, "min_height": min_height})
+
+    def set_maximum_size(self, max_width: int, max_height: int) -> None:
+        """
+        Sets the maximum size of the window.
+
+        Parameters
+        ----------
+        max_width : int
+            Maximum width of the window
+        max_height : int
+            Maximum height of the window
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> window.set_maximum_size(1024, 768)
+        >>> app.run()
+        """
+        return self.execute_command("set_maximum_size", {"max_width": max_width, "max_height": max_height})
+
+    def get_minimum_size(self) -> "Dict[str, int]":
+        """
+        Returns the minimum size of the window.
+
+        Returns
+        -------
+        dict
+            Dictionary containing the minimum width and height of the window
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> min_size = window.get_minimum_size()
+        >>> print(min_size)
+        >>> app.run()
+        """
+        return self.execute_command("get_minimum_size", {})
+
+    def get_maximum_size(self) -> "Dict[str, int]":
+        """
+        Returns the maximum size of the window.
+
+        Returns
+        -------
+        dict
+            Dictionary containing the maximum width and height of the window
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> max_size = window.get_maximum_size()
+        >>> print(max_size)
+        >>> app.run()
+        """
+        return self.execute_command("get_maximum_size", {})
+
+    def get_resizable(self) -> bool:
+        """
+        Returns the resizability of the window.
+
+        Returns
+        -------
+        bool
+            True if the window is resizable, False otherwise
+
+        Examples
+        --------
+        >>> app = Pyloid(app_name="Pyloid-App")
+        >>> window = app.create_window("pyloid-window")
+        >>> resizable = window.get_resizable()
+        >>> print(resizable)
+        >>> app.run()
+        """
+        return self.execute_command("get_resizable", {})
+
+    def set_static_image_splash_screen(self, image_path: str, close_on_load: bool = True, stay_on_top: bool = True, clickable: bool = True, position: str = "center") -> None:
+        """
+        Sets the static image splash screen of the window.
+
+        Parameters
+        ----------
+        image_path : str
+            Path to the image file
+        close_on_load : bool, optional
+            True to close the splash screen when the page is loaded, False otherwise (default is True)
+        stay_on_top : bool, optional
+            True to keep the splash screen on top, False otherwise (default is True)
+        clickable : bool, optional
+            True to make the splash screen clickable, False otherwise (default is True)
+            if clickable is True, you can click the splash screen to close it.
+        position : str, optional
+            Position of the splash screen. Options are 'center', 'top-left', 'top-right', 'bottom-left', 'bottom-right' (default is 'center')
+
+        Examples
+        --------
+        >>> window.set_static_image_splash_screen("./assets/loading.png", close_on_load=True, stay_on_top=True)
+        """
+        return self.execute_command("set_static_image_splash_screen", {
+            "image_path": image_path,
+            "close_on_load": close_on_load,
+            "stay_on_top": stay_on_top,
+            "clickable": clickable,
+            "position": position
+        })
+
+    def set_gif_splash_screen(self, gif_path: str, close_on_load: bool = True, stay_on_top: bool = True, clickable: bool = True, position: str = "center") -> None:
+        """
+        Sets the gif splash screen of the window.
+
+        Parameters
+        ----------
+        gif_path : str
+            Path to the gif file
+        close_on_load : bool, optional
+            True to close the splash screen when the page is loaded, False otherwise (default is True)
+        stay_on_top : bool, optional
+            True to keep the splash screen on top, False otherwise (default is True)
+        clickable : bool, optional
+            True to make the splash screen clickable, False otherwise (default is True)
+            if clickable is True, you can click the splash screen to close it.
+        position : str, optional
+            Position of the splash screen. Options are 'center', 'top-left', 'top-right', 'bottom-left', 'bottom-right' (default is 'center')
+
+        Examples
+        --------
+        >>> window.set_gif_splash_screen("./assets/loading.gif", close_on_load=True, stay_on_top=True)
+        """
+        return self.execute_command("set_gif_splash_screen", {
+            "gif_path": gif_path,
+            "close_on_load": close_on_load,
+            "stay_on_top": stay_on_top,
+            "clickable": clickable,
+            "position": position
+        })
+
+    def close_splash_screen(self) -> None:
+        """
+        Closes the splash screen if it exists.
+
+        Examples
+        --------
+        >>> window.close_splash_screen()
         """
-        self.web_view.custom_page.setDesktopMediaHandler(handler)
+        return self.execute_command("close_splash_screen", {})
+