je-editor 0.0.223__py3-none-any.whl → 0.0.224__py3-none-any.whl

je_editor/pyside_ui/main_ui/editor/editor_widget_dock.py

@@ -11,33 +11,60 @@ from je_editor.utils.logging.loggin_instance import jeditor_logger
 
 
 class FullEditorWidget(QWidget):
+    """
+    FullEditorWidget 提供一個完整的單檔編輯器介面，
+    包含程式碼編輯區、捲動支援，以及關閉時自動儲存功能。
+
+    FullEditorWidget provides a full single-file editor interface,
+    including code editing area, scroll support, and auto-save on close.
+    """
 
     def __init__(self, current_file: str):
+        # 初始化時記錄日誌 / Log initialization
         jeditor_logger.info(f"Init FullEditorWidget current_file: {current_file}")
         super().__init__()
-        # Init variable
-        self.current_file = current_file
-        # Attr
+
+        # ---------------- Init variable 初始化變數 ----------------
+        self.current_file = current_file  # 目前編輯的檔案路徑 / Current editing file path
+
+        # ---------------- Attributes 屬性設定 ----------------
+        # 設定關閉時自動刪除物件，釋放記憶體
+        # Delete object on close to free memory
         self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
-        # UI
+
+        # ---------------- UI 初始化 ----------------
         self.grid_layout = QGridLayout(self)
         self.setWindowTitle(language_wrapper.language_word_dict.get("application_name"))
-        # code edit and code result plaintext
+
+        # 建立程式碼編輯器並放入捲動區域
+        # Create code editor and put inside scroll area
         self.code_edit = CodeEditor(self)
         self.code_edit_scroll_area = QScrollArea()
         self.code_edit_scroll_area.setWidgetResizable(True)
         self.code_edit_scroll_area.setViewportMargins(0, 0, 0, 0)
         self.code_edit_scroll_area.setWidget(self.code_edit)
+
+        # 將編輯器加入版面配置
+        # Add editor to layout
         self.grid_layout.addWidget(self.code_edit_scroll_area, 0, 0)
-        # Font
+
+        # 設定字體樣式 (從使用者設定檔讀取)
+        # Set font style (from user settings)
         self.code_edit.setStyleSheet(
             f"font-size: {user_setting_dict.get('font_size', 12)}pt;"
             f"font-family: {user_setting_dict.get('font', 'Lato')};"
         )
 
     def closeEvent(self, event) -> None:
+        """
+        覆寫 closeEvent，在關閉視窗時自動儲存檔案內容。
+        Override closeEvent to auto-save file content when closing window.
+        """
         jeditor_logger.info(f"FullEditorWidget closeEvent event: {event}")
         path = Path(self.current_file)
         if path.exists() and path.is_file():
+            # 將編輯器內容寫回檔案 / Write editor content back to file
             write_file(self.current_file, self.code_edit.toPlainText())
-        super().closeEvent(event)
+        # 呼叫父類別的 closeEvent，完成 Qt 預設流程
+        # Call parent closeEvent to complete Qt default process
+        super().closeEvent(event)

je_editor/pyside_ui/main_ui/editor/process_input.py

@@ -1,57 +1,83 @@
-from __future__ import annotations
+from __future__ import annotations  # 允許未來版本的型別註解功能 / Enable postponed evaluation of type annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING  # 用於避免循環匯入，僅在型別檢查時載入 / Used to avoid circular imports, only loaded during type checking
 
-from PySide6.QtCore import Qt
+from PySide6.QtCore import Qt  # Qt 核心模組 / Qt core module
 from PySide6.QtWidgets import QWidget, QLineEdit, QBoxLayout, QPushButton, QHBoxLayout
+# 匯入 PySide6 的 GUI 元件 / Import GUI widgets from PySide6
 
 from je_editor.utils.logging.loggin_instance import jeditor_logger
+# 專案內的日誌紀錄器 / Project's logger instance
 
 if TYPE_CHECKING:
     from je_editor.pyside_ui.main_ui.main_editor import EditorWidget
+    # 僅在型別檢查時匯入 EditorWidget，避免循環依賴 / Import only for type checking to avoid circular dependency
 
 from je_editor.utils.multi_language.multi_language_wrapper import language_wrapper
+# 多語系支援工具 / Multi-language wrapper for UI text
 
 
 class ProcessInput(QWidget):
+    """
+    ProcessInput 是一個輸入視窗，允許使用者輸入指令並傳送到不同的子程序 (program/shell/debugger)。
+    ProcessInput is an input widget that allows users to send commands to different subprocesses.
+    """
 
     def __init__(self, main_window: EditorWidget, process_type: str = "debugger"):
+        # 初始化時記錄日誌 / Log initialization
         jeditor_logger.info("Init ProcessInput "
                             f"main_window: {main_window} "
                             f"process_type: {process_type}")
         super().__init__()
-        # Attr
+
+        # 設定當視窗關閉時自動刪除資源
+        # Set attribute to delete widget on close
         self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
-        # UI setting
-        self.main_window = main_window
-        self.box_layout = QBoxLayout(QBoxLayout.Direction.TopToBottom)
-        self.command_input = QLineEdit()
-        self.send_command_button = QPushButton()
+
+        # === UI 設定 / UI Setup ===
+        self.main_window = main_window  # 儲存主視窗參考 / Store reference to main window
+        self.box_layout = QBoxLayout(QBoxLayout.Direction.TopToBottom)  # 垂直佈局 / Vertical layout
+        self.command_input = QLineEdit()  # 輸入框 / Input field
+        self.send_command_button = QPushButton()  # 傳送按鈕 / Send button
+
+        # 設定按鈕文字 (多語系) / Set button text (multi-language)
         self.send_command_button.setText(language_wrapper.language_word_dict.get("process_input_send_command"))
+
+        # 水平佈局，放置按鈕 / Horizontal layout for button
         self.box_h_layout = QHBoxLayout()
         self.box_h_layout.addWidget(self.send_command_button)
+
+        # 將元件加入主佈局 / Add widgets to main layout
         self.box_layout.addWidget(self.command_input)
         self.box_layout.addLayout(self.box_h_layout)
+
+        # 根據 process_type 設定不同的標題與功能 / Configure behavior based on process_type
         if process_type == "program":
             self.setWindowTitle(language_wrapper.language_word_dict.get("editor_program_input_title_label"))
             self.send_command_button.clicked.connect(self.program_send_command)
         elif process_type == "shell":
             self.setWindowTitle(language_wrapper.language_word_dict.get("editor_shell_input_title_label"))
             self.send_command_button.clicked.connect(self.shell_send_command)
-        else:
+        else:  # 預設為 debugger / Default: debugger
             self.setWindowTitle(language_wrapper.language_word_dict.get("editor_debugger_input_title_label"))
             self.send_command_button.clicked.connect(self.debugger_send_command)
+            # 切換主視窗的顯示頁面到 debugger 結果 / Switch main window tab to debugger result
             self.main_window.code_difference_result.setCurrentWidget(self.main_window.debugger_result)
+
+        # 設定主佈局 / Apply layout
         self.setLayout(self.box_layout)
 
+    # === Debugger 指令傳送 / Send command to debugger ===
     def debugger_send_command(self):
         jeditor_logger.info("EditorWidget debugger_send_command")
         if self.main_window.exec_python_debugger is not None:
             process_stdin = self.main_window.exec_python_debugger.process.stdin
             if process_stdin is not None:
+                # 將輸入框文字編碼後寫入子程序 stdin / Write encoded input to subprocess stdin
                 process_stdin.write(self.command_input.text().encode() + b"\n")
                 process_stdin.flush()
 
+    # === Shell 指令傳送 / Send command to shell ===
     def shell_send_command(self):
         jeditor_logger.info("EditorWidget shell_send_command")
         if self.main_window.exec_shell is not None:
@@ -60,10 +86,11 @@ class ProcessInput(QWidget):
                 process_stdin.write(self.command_input.text().encode() + b"\n")
                 process_stdin.flush()
 
+    # === Program 指令傳送 / Send command to program ===
     def program_send_command(self):
         jeditor_logger.info("EditorWidget program_send_command")
         if self.main_window.exec_program is not None:
             process_stdin = self.main_window.exec_program.process.stdin
             if process_stdin is not None:
                 process_stdin.write(self.command_input.text().encode() + b"\n")
-                process_stdin.flush()
+                process_stdin.flush()

je_editor/pyside_ui/main_ui/ipython_widget/rich_jupyter.py

@@ -1,43 +1,78 @@
-from __future__ import annotations
+from __future__ import annotations  # 啟用未來版本的型別註解功能 / Enable postponed evaluation of type annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING  # 僅在型別檢查時使用，避免循環匯入 / Used only for type checking to avoid circular imports
 
-from IPython.lib import guisupport
-from PySide6.QtWidgets import QWidget, QGridLayout
-from qtconsole.inprocess import QtInProcessKernelManager
-from qtconsole.rich_jupyter_widget import RichJupyterWidget
+from IPython.lib import guisupport  # 提供與 Qt GUI 整合的支援 / Provides support for integrating IPython with Qt GUI
+from PySide6.QtWidgets import QWidget, QGridLayout  # PySide6 視窗元件 / PySide6 widgets
+from qtconsole.inprocess import QtInProcessKernelManager  # 管理內嵌的 Jupyter kernel / Manages an in-process Jupyter kernel
+from qtconsole.rich_jupyter_widget import RichJupyterWidget  # Jupyter 富文本控制台元件 / Rich Jupyter console widget
 
-from je_editor.utils.logging.loggin_instance import jeditor_logger
+from je_editor.utils.logging.loggin_instance import jeditor_logger  # 專案內的日誌紀錄器 / Project logger
 
 if TYPE_CHECKING:
     from je_editor.pyside_ui.main_ui.main_editor import EditorMain
+    # 僅在型別檢查時匯入 EditorMain，避免循環依賴 / Import only for type checking to avoid circular dependency
 
 
 class IpythonWidget(QWidget):
+    """
+    IpythonWidget 類別
+    - 在 PySide6 GUI 中嵌入一個 Jupyter/IPython 控制台
+    - 提供互動式 Python 環境，方便在應用程式內直接執行程式碼
+    IpythonWidget class
+    - Embeds a Jupyter/IPython console inside a PySide6 GUI
+    - Provides an interactive Python environment within the application
+    """
 
     def __init__(self, main_window: EditorMain):
+        # 初始化時記錄日誌 / Log initialization
         jeditor_logger.info(f"Init IpythonWidget main_window: {main_window}")
         super().__init__()
+
+        # 建立網格佈局 / Create grid layout
         self.grid_layout = QGridLayout()
+
+        # 取得 Qt 應用程式實例 (Qt4 API，但可在 PySide6 中使用) / Get Qt application instance
         app = guisupport.get_app_qt4()
-        self.kernel_manager = QtInProcessKernelManager()
-        self.kernel_manager.start_kernel()
-        self.kernel = self.kernel_manager.kernel
+
+        # === 建立並啟動 Jupyter Kernel / Create and start Jupyter kernel ===
+        self.kernel_manager = QtInProcessKernelManager()  # 內嵌 kernel 管理器 / In-process kernel manager
+        self.kernel_manager.start_kernel()  # 啟動 kernel / Start kernel
+        self.kernel = self.kernel_manager.kernel  # 取得 kernel 實例 / Get kernel instance
+
+        # 建立 kernel client 並啟動通訊管道 / Create kernel client and start communication channels
         self.kernel_client = self.kernel_manager.client()
         self.kernel_client.start_channels()
+
+        # === 建立 Jupyter 控制台元件 / Create Jupyter console widget ===
         self.jupyter_widget = RichJupyterWidget()
         self.jupyter_widget.kernel_manager = self.kernel_manager
         self.jupyter_widget.kernel_client = self.kernel_client
+
+        # 將控制台加入佈局 (佔滿整個視窗) / Add console widget to layout (fill entire window)
         self.grid_layout.addWidget(self.jupyter_widget, 0, 0, -1, -1)
+
+        # 啟動 Qt 事件迴圈，讓 Jupyter 控制台能正常運作 / Start Qt event loop for Jupyter console
         guisupport.start_event_loop_qt4(app)
 
+        # 設定主佈局 / Apply layout
         self.setLayout(self.grid_layout)
 
     def close(self):
+        """
+        覆寫 close 方法，確保關閉時正確釋放資源
+        Override close method to properly release resources
+        """
         jeditor_logger.info("IpythonWidget close")
+
+        # 停止 kernel client 的通訊管道 / Stop kernel client channels
         if self.kernel_client:
             self.kernel_client.stop_channels()
+
+        # 重啟並關閉 kernel，確保乾淨退出 / Restart and shutdown kernel for clean exit
         if self.kernel_manager:
             self.kernel_manager.restart_kernel()
             self.kernel_manager.shutdown_kernel()
-        super().close()
+
+        # 呼叫父類別的 close 方法 / Call parent close method
+        super().close()

je_editor/pyside_ui/main_ui/main_editor.py

@@ -4,38 +4,66 @@ import sys
 from pathlib import Path
 from typing import Dict, Type
 
+# 匯入 Jedi 設定，用於 Python 自動補全與分析
+# Import Jedi settings for Python auto-completion and analysis
 import jedi.settings
+
+# 匯入 PySide6 (Qt for Python) 的核心模組
+# Import PySide6 core modules
 from PySide6.QtCore import QTimer, QEvent
 from PySide6.QtGui import QFontDatabase, QIcon, Qt, QTextCharFormat
 from PySide6.QtWidgets import QMainWindow, QWidget, QTabWidget
+
+# 匯入 Qt Material 主題工具
+# Import Qt Material style tools
 from qt_material import QtStyleTools
 
+# 匯入專案內部模組 (自訂 UI 與功能)
+# Import project-specific modules (custom UI and features)
 from je_editor.pyside_ui.browser.browser_widget import BrowserWidget
 from je_editor.pyside_ui.browser.main_browser_widget import MainBrowserWidget
 from je_editor.pyside_ui.code.auto_save.auto_save_manager import init_new_auto_save_thread, file_is_open_manager_dict
 from je_editor.pyside_ui.main_ui.editor.editor_widget import EditorWidget
 from je_editor.pyside_ui.main_ui.menu.set_menu_bar import set_menu_bar
-from je_editor.pyside_ui.main_ui.save_settings.user_color_setting_file import write_user_color_setting, \
-    read_user_color_setting, update_actually_color_dict, actually_color_dict
-from je_editor.pyside_ui.main_ui.save_settings.user_setting_file import user_setting_dict, read_user_setting, \
+from je_editor.pyside_ui.main_ui.save_settings.user_color_setting_file import (
+    write_user_color_setting,
+    read_user_color_setting,
+    update_actually_color_dict,
+    actually_color_dict
+)
+from je_editor.pyside_ui.main_ui.save_settings.user_setting_file import (
+    user_setting_dict,
+    read_user_setting,
     write_user_setting
+)
 from je_editor.pyside_ui.main_ui.system_tray.extend_system_tray import ExtendSystemTray
 from je_editor.utils.file.open.open_file import read_file
 from je_editor.utils.logging.loggin_instance import jeditor_logger
 from je_editor.utils.multi_language.multi_language_wrapper import language_wrapper
 from je_editor.utils.redirect_manager.redirect_manager_class import redirect_manager_instance
 
+# 定義一個字典，用來存放可擴充的 Tab (標籤頁)
+# Define a dictionary to store extendable tabs
 EDITOR_EXTEND_TAB: Dict[str, Type[QWidget]] = {}
 
 
 class EditorMain(QMainWindow, QtStyleTools):
+    """
+    主編輯器視窗類別
+    Main editor window class
+    繼承 QMainWindow 與 QtStyleTools
+    """
 
     def __init__(self, debug_mode: bool = False, show_system_tray_ray: bool = False):
+        # 初始化時記錄 log
+        # Log initialization
         jeditor_logger.info(f"Init EditorMain "
                             f"debug_mode: {debug_mode} "
                             f"show_system_tray_ray: {show_system_tray_ray}")
         super(EditorMain, self).__init__()
-        # Init variable
+
+        # 初始化變數
+        # Initialize variables
         self.file_menu = None
         self.code_result = None
         self.code_edit = None
@@ -45,77 +73,130 @@ class EditorMain(QMainWindow, QtStyleTools):
         self.font_menu = None
         self.working_dir = None
         self.show_system_tray_ray = show_system_tray_ray
-        # Self attr
-        # Read user setting first
+
+        # 讀取使用者設定
+        # Read user settings
         read_user_setting()
-        # Set language
+
+        # 設定語言 (多語系支援)
+        # Set language (multi-language support)
         language_wrapper.reset_language(user_setting_dict.get("language", "English"))
-        # Jedi run on thread safe
+
+        # Jedi 設定：關閉快取解析器，避免執行緒問題
+        # Jedi settings: disable fast parser for thread safety
         jedi.settings.fast_parser = False
-        # Jedi only show right case_insensitive
-        jedi.settings.case_insensitive_completion = False
-        # Project compiler if user not choose this will use which to find
+        jedi.settings.case_insensitive_completion = False  # 關閉大小寫不敏感補全 / Disable case-insensitive completion
+
+        # Python 編譯器 (可由使用者指定)
+        # Python compiler (can be set by user)
         self.python_compiler = None
+
+        # 除錯模式
         # Debug mode
         self.debug_mode: bool = debug_mode
-        # Windows setup
+
+        # Windows 系統專用：設定應用程式 ID
+        # Windows only: set application ID
         self.id = language_wrapper.language_word_dict.get("application_name")
         if sys.platform in ["win32", "cygwin", "msys"]:
             from ctypes import windll
             windll.shell32.SetCurrentProcessExplicitAppUserModelID(self.id)
-        # set python buffered
+
+        # 設定 Python 輸出不緩衝
+        # Set Python output unbuffered
         os.environ["PYTHONUNBUFFERED"] = "1"
-        # Auto save thread
+
+        # 自動儲存執行緒
+        # Auto-save thread
         self.auto_save_thread = None
-        # Encoding
+
+        # 預設編碼
+        # Default encoding
         self.encoding = "utf-8"
+
+        # 讀取使用者顏色設定
+        # Read user color settings
         read_user_color_setting()
-        # Font
+
+        # 字型資料庫
+        # Font database
         self.font_database = QFontDatabase()
-        # TabWidget
+
+        # 建立 TabWidget (多分頁編輯器)
+        # Create TabWidget (multi-tab editor)
         self.tab_widget = QTabWidget()
-        self.tab_widget.setTabsClosable(True)
+        self.tab_widget.setTabsClosable(True)  # 可關閉分頁 / Tabs closable
         self.tab_widget.setAttribute(Qt.WidgetAttribute.WA_AlwaysShowToolTips, on=False)
         self.tab_widget.tabCloseRequested.connect(self.close_tab)
-        # Timer to redirect error or message
+
+        # 建立計時器，用來處理訊息重導 (stdout/stderr)
+        # Timer for redirecting messages (stdout/stderr)
         self.redirect_timer = QTimer(self)
         self.redirect_timer.setInterval(10)
         self.redirect_timer.start()
+
+        # 設定視窗標題與提示
+        # Set window title and tooltip
         self.setWindowTitle(language_wrapper.language_word_dict.get("application_name"))
         self.setToolTip(language_wrapper.language_word_dict.get("application_name"))
+
+        # 設定選單列
+        # Set menu bar
         set_menu_bar(self)
-        # Set Icon
+
+        # 設定應用程式圖示
+        # Set application icon
         self.icon_path = Path(os.getcwd() + "/je_driver_icon.ico")
         self.icon = QIcon(str(self.icon_path))
         if self.icon.isNull() is False:
             self.setWindowIcon(self.icon)
+            # 如果系統支援系統匣，則顯示圖示
+            # Show system tray icon if available
             if ExtendSystemTray.isSystemTrayAvailable() and self.show_system_tray_ray:
                 self.system_tray = ExtendSystemTray(main_window=self)
                 self.system_tray.setIcon(self.icon)
                 self.system_tray.setVisible(True)
                 self.system_tray.show()
                 self.system_tray.setToolTip(language_wrapper.language_word_dict.get("application_name"))
-        # Put Redirect on last to trace exception
+
+        # 設定輸出重導 (stdout/stderr)
+        # Setup output redirection (stdout/stderr)
         redirect_manager_instance.restore_std()
         redirect_manager_instance.set_redirect()
-        # Timer to redirect error or message
+
+        # 再次設定計時器，定期檢查輸出
+        # Setup timer again to check redirected output
         self.redirect_timer = QTimer(self)
         self.redirect_timer.setInterval(10)
         self.redirect_timer.timeout.connect(self.redirect)
         self.redirect_timer.start()
-        # TAB Add
+
+        # 建立主要分頁：編輯器與瀏覽器
+        # Create main tabs: editor and browser
         main_browser_widget = MainBrowserWidget()
         self.tab_widget.addTab(EditorWidget(self), language_wrapper.language_word_dict.get("tab_name_editor"))
         self.tab_widget.addTab(main_browser_widget, language_wrapper.language_word_dict.get("tab_name_web_browser"))
+
+        # 預設新增一個 StackOverflow 瀏覽分頁
+        # Add a default StackOverflow browser tab
         main_browser_widget.add_browser_tab(
             BrowserWidget(start_url="https://stackoverflow.com/", search_prefix="https://stackoverflow.com/search?q="))
 
+        # 加入擴充的自訂分頁
+        # Add extended custom tabs
         for widget_name, widget in EDITOR_EXTEND_TAB.items():
             self.tab_widget.addTab(widget(), widget_name)
+
+        # 設定中央元件為 TabWidget
+        # Set central widget as TabWidget
         self.setCentralWidget(self.tab_widget)
-        # Read Setting
+
+        # 啟動時讀取設定
+        # Load startup settings
         self.startup_setting()
-        # If debug open 10s and close
+
+        # 如果是 debug 模式，10 秒後自動關閉
+        # If debug mode, auto-close after 10 seconds
         if self.debug_mode:
             close_timer = QTimer(self)
             close_timer.setInterval(10000)
@@ -123,61 +204,91 @@ class EditorMain(QMainWindow, QtStyleTools):
             close_timer.start()
 
     def clear_code_result(self):
+        """
+        清除目前編輯器的輸出結果
+        Clear the current editor's output result
+        """
         jeditor_logger.info(f"EditorMain clear_code_result")
         widget = self.tab_widget.currentWidget()
         if isinstance(widget, EditorWidget):
             widget.code_result.clear()
 
     def redirect(self) -> None:
+        """
+        將 stdout/stderr 的訊息導入到編輯器的輸出區域
+        Redirect stdout/stderr messages into the editor's output area
+        """
         jeditor_logger.info(f"EditorMain redirect")
+        # 遍歷所有分頁 (Tab)，尋找 EditorWidget
+        # Iterate through all tabs to find EditorWidget
         for code_editor in range(self.tab_widget.count()):
             widget = self.tab_widget.widget(code_editor)
             if isinstance(widget, EditorWidget):
-                # Pull out redirect text and put text in code result area
+                # stdout 輸出處理
+                # Handle stdout messages
                 if not redirect_manager_instance.std_out_queue.empty():
                     output_message = redirect_manager_instance.std_out_queue.get_nowait()
                     output_message = str(output_message).strip()
                     if output_message:
                         text_cursor = self.code_result.textCursor()
                         text_format = QTextCharFormat()
+                        # 設定正常輸出顏色
+                        # Set normal output color
                         text_format.setForeground(actually_color_dict.get("normal_output_color"))
                         text_cursor.insertText(output_message, text_format)
                         text_cursor.insertBlock()
+
+                # stderr 錯誤輸出處理
+                # Handle stderr messages
                 if not redirect_manager_instance.std_err_queue.empty():
                     error_message = redirect_manager_instance.std_err_queue.get_nowait()
                     error_message = str(error_message).strip()
                     if error_message:
                         text_cursor = self.code_result.textCursor()
                         text_format = QTextCharFormat()
+                        # 設定錯誤輸出顏色
+                        # Set error output color
                         text_format.setForeground(actually_color_dict.get("error_output_color"))
                         text_cursor.insertText(error_message, text_format)
                         text_cursor.insertBlock()
-                break
+                break  # 找到第一個 EditorWidget 就結束迴圈 / Stop after first EditorWidget found
 
     def startup_setting(self) -> None:
+        """
+        啟動時套用使用者設定 (字型、樣式、上次開啟的檔案)
+        Apply user settings on startup (fonts, styles, last opened file)
+        """
         jeditor_logger.info(f"EditorMain startup_setting")
-        # Set font and font size, then try to open last edit file
+        # 設定 UI 字型與大小
+        # Set UI font and size
         self.setStyleSheet(
             f"font-size: {user_setting_dict.get('ui_font_size', 12)}pt;"
             f"font-family: {user_setting_dict.get('ui_font', 'Lato')};"
         )
-        # User setting
+
+        # 套用到每個編輯器分頁
+        # Apply settings to each editor tab
         for code_editor_count in range(self.tab_widget.count()):
             widget = self.tab_widget.widget(code_editor_count)
             if isinstance(widget, EditorWidget):
-                # Font size
+                # 編輯區字型
+                # Font for code editor
                 widget.code_edit.setStyleSheet(
                     f"font-size: {user_setting_dict.get('font_size', 12)}pt;"
                     f"font-family: {user_setting_dict.get('font', 'Lato')};"
                 )
-                # Font
+                # 輸出區字型
+                # Font for output area
                 widget.code_result.setStyleSheet(
                     f"font-size: {user_setting_dict.get('font_size', 12)}pt;"
                     f"font-family: {user_setting_dict.get('font', 'Lato')};"
                 )
-                # Default compiler
+                # 預設 Python 編譯器
+                # Default Python compiler
                 self.python_compiler = user_setting_dict.get("python_compiler", None)
-                # Last edit file
+
+                # 嘗試開啟上次編輯的檔案
+                # Try to open last edited file
                 last_file = user_setting_dict.get("last_file", None)
                 if last_file is not None:
                     last_file_path = pathlib.Path(last_file)
@@ -189,32 +300,51 @@ class EditorMain(QMainWindow, QtStyleTools):
                         file_is_open_manager_dict.update({str(last_file_path): str(last_file_path.name)})
                         widget.rename_self_tab()
 
-        # Style
+        # 套用 UI 樣式 (主題)
+        # Apply UI stylesheet (theme)
         self.apply_stylesheet(self, user_setting_dict.get("ui_style", "dark_amber.xml"))
-        # Color
+        # 更新顏色設定
+        # Update color settings
         update_actually_color_dict()
 
     def go_to_new_tab(self, file_path: Path):
+        """
+        開啟新分頁並載入檔案
+        Open a new tab and load a file
+        """
         jeditor_logger.info(f"EditorMain go_to_new_tab file_path: {file_path}")
         if file_is_open_manager_dict.get(str(file_path), None) is None:
+            # 建立新的編輯器分頁
+            # Create a new editor tab
             editor_widget = EditorWidget(self)
             self.tab_widget.addTab(
                 editor_widget,
                 f"{language_wrapper.language_word_dict.get('tab_menu_editor_tab_name')} "
-                f"{self.tab_widget.count()}")
+                f"{self.tab_widget.count()}"
+            )
             self.tab_widget.setCurrentWidget(editor_widget)
             editor_widget.open_an_file(file_path)
         else:
+            # 如果檔案已開啟，直接切換到該分頁
+            # If file already opened, switch to that tab
             widget: QWidget = self.tab_widget.findChild(EditorWidget, str(file_path))
             self.tab_widget.setCurrentWidget(widget)
 
     def closeEvent(self, event) -> None:
+        """
+        視窗關閉事件：儲存使用者設定
+        Window close event: save user settings
+        """
         jeditor_logger.info("EditorMain closeEvent")
         write_user_setting()
         write_user_color_setting()
         super().closeEvent(event)
 
     def event(self, event: QEvent) -> bool:
+        """
+        事件處理：忽略 ToolTip 類型事件
+        Event handler: ignore ToolTip events
+        """
         jeditor_logger.info(f"EditorMain event: {event}")
         if event.type() == QEvent.Type.ToolTip:
             event.ignore()
@@ -223,6 +353,10 @@ class EditorMain(QMainWindow, QtStyleTools):
             return super().event(event)
 
     def close_tab(self, index: int):
+        """
+        關閉指定索引的分頁
+        Close tab at given index
+        """
         widget = self.tab_widget.widget(index)
         if widget:
             widget.close()
@@ -230,4 +364,8 @@ class EditorMain(QMainWindow, QtStyleTools):
 
     @classmethod
     def debug_close(cls):
-        sys.exit(0)
+        """
+        除錯模式下自動關閉程式
+        Auto-close the program in debug mode
+        """
+        sys.exit(0)