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

je_editor/pyside_ui/main_ui/menu/tab_menu/build_tab_menu.py

@@ -4,9 +4,11 @@ from typing import TYPE_CHECKING
 
 from frontengine import FrontEngineMainUI
 
-from je_editor.pyside_ui.git_ui.code_diff_compare.code_diff_viewer_widget import DiffViewerWidget
 from je_editor.pyside_ui.browser.main_browser_widget import MainBrowserWidget
 from je_editor.pyside_ui.code.variable_inspector.inspector_gui import VariableInspector
+# 匯入各種 UI 元件 (編輯器、瀏覽器、Git、變數檢查器、聊天、控制台、IPython、程式碼比對)
+# Import various UI components (editor, browser, Git, variable inspector, chat, console, IPython, code diff)
+from je_editor.pyside_ui.git_ui.code_diff_compare.code_diff_viewer_widget import DiffViewerWidget
 from je_editor.pyside_ui.git_ui.git_client.git_branch_tree_widget import GitTreeViewGUI
 from je_editor.pyside_ui.git_ui.git_client.git_client_gui import GitGui
 from je_editor.pyside_ui.main_ui.ai_widget.chat_ui import ChatUI
@@ -15,81 +17,127 @@ from je_editor.pyside_ui.main_ui.editor.editor_widget import EditorWidget
 from je_editor.pyside_ui.main_ui.ipython_widget.rich_jupyter import IpythonWidget
 from je_editor.utils.logging.loggin_instance import jeditor_logger
 
+# 啟用未來的註解功能，允許在型別提示中使用字串形式的前向參照
+# Enable future annotations, allowing forward references in type hints
+# TYPE_CHECKING 用於避免在型別檢查時引入不必要的模組
+# TYPE_CHECKING is used to avoid unnecessary imports during type checking
+# 匯入 FrontEngine 主 UI
+# Import the FrontEngine main UI
+# 匯入日誌工具，用於記錄操作
+# Import logger for recording operations
+
 if TYPE_CHECKING:
     from je_editor.pyside_ui.main_ui.main_editor import EditorMain
+    # 僅在型別檢查時匯入 EditorMain，避免循環依賴
+    # Import EditorMain only for type checking to avoid circular imports
+
 from PySide6.QtGui import QAction
+# 匯入 QAction，用於建立選單動作
+# Import QAction for creating menu actions
+
 from je_editor.utils.multi_language.multi_language_wrapper import language_wrapper
 
 
+# 匯入多語言包裝器，用於支援多語系 UI
+# Import language wrapper for multilingual UI support
+
+
 def set_tab_menu(ui_we_want_to_set: EditorMain) -> None:
+    """
+    設定主編輯器的分頁選單
+    Set up the tab menu for the main editor
+    """
     jeditor_logger.info(f"build_tab_menu.py set_tab_menu ui_we_want_to_set:{ui_we_want_to_set}")
-    # Editor
+
+    # 建立 Tab 選單 (主容器)
+    # Create the Tab menu (main container)
     ui_we_want_to_set.tab_menu = ui_we_want_to_set.menu.addMenu(
         language_wrapper.language_word_dict.get("tab_menu_label")
     )
+
+    # === Editor 分頁 ===
+    # === Editor Tab ===
     ui_we_want_to_set.tab_menu.add_editor_action = QAction(
         language_wrapper.language_word_dict.get("tab_menu_add_editor_label"))
     ui_we_want_to_set.tab_menu.add_editor_action.triggered.connect(
         lambda: add_editor_tab(ui_we_want_to_set)
     )
-    # Front Engine
     ui_we_want_to_set.tab_menu.addAction(ui_we_want_to_set.tab_menu.add_editor_action)
+
+    # === Front Engine 分頁 ===
+    # === Front Engine Tab ===
     ui_we_want_to_set.tab_menu.add_frontengine_action = QAction(
         language_wrapper.language_word_dict.get("tab_menu_add_frontengine_label"))
     ui_we_want_to_set.tab_menu.add_frontengine_action.triggered.connect(
         lambda: add_frontengine_tab(ui_we_want_to_set)
     )
-    # Web
     ui_we_want_to_set.tab_menu.addAction(ui_we_want_to_set.tab_menu.add_frontengine_action)
+
+    # === Web 瀏覽器分頁 ===
+    # === Web Browser Tab ===
     ui_we_want_to_set.tab_menu.add_web_action = QAction(
         language_wrapper.language_word_dict.get("tab_menu_add_web_label"))
     ui_we_want_to_set.tab_menu.add_web_action.triggered.connect(
         lambda: add_web_tab(ui_we_want_to_set)
     )
     ui_we_want_to_set.tab_menu.addAction(ui_we_want_to_set.tab_menu.add_web_action)
-    # IPython
+
+    # === IPython 分頁 ===
+    # === IPython Tab ===
     ui_we_want_to_set.tab_menu.add_ipython_action = QAction(
         language_wrapper.language_word_dict.get("tab_menu_ipython_tab_name"))
     ui_we_want_to_set.tab_menu.add_ipython_action.triggered.connect(
         lambda: add_ipython_tab(ui_we_want_to_set)
     )
     ui_we_want_to_set.tab_menu.addAction(ui_we_want_to_set.tab_menu.add_ipython_action)
-    # ChatUI
+
+    # === Chat UI 分頁 ===
+    # === Chat UI Tab ===
     ui_we_want_to_set.tab_menu.add_chat_ui_action = QAction(
         language_wrapper.language_word_dict.get("tab_menu_chat_ui_tab_name"))
     ui_we_want_to_set.tab_menu.add_chat_ui_action.triggered.connect(
         lambda: add_chat_ui_tab(ui_we_want_to_set)
     )
     ui_we_want_to_set.tab_menu.addAction(ui_we_want_to_set.tab_menu.add_chat_ui_action)
-    # Git Client
+
+    # === Git Client 分頁 ===
+    # === Git Client Tab ===
     ui_we_want_to_set.tab_menu.add_git_client_ui_action = QAction(
         language_wrapper.language_word_dict.get("tab_menu_git_client_tab_name"))
     ui_we_want_to_set.tab_menu.add_git_client_ui_action.triggered.connect(
         lambda: add_git_client_tab(ui_we_want_to_set)
     )
     ui_we_want_to_set.tab_menu.addAction(ui_we_want_to_set.tab_menu.add_git_client_ui_action)
-    # Git Branch tree
+
+    # === Git Branch Tree 分頁 ===
+    # === Git Branch Tree Tab ===
     ui_we_want_to_set.tab_menu.add_git_branch_view_ui_action = QAction(
         language_wrapper.language_word_dict.get("tab_menu_git_branch_tree_view_tab_name"))
     ui_we_want_to_set.tab_menu.add_git_branch_view_ui_action.triggered.connect(
         lambda: add_git_tree_view_tab(ui_we_want_to_set)
     )
     ui_we_want_to_set.tab_menu.addAction(ui_we_want_to_set.tab_menu.add_git_branch_view_ui_action)
-    # Variable Inspector
+
+    # === Variable Inspector 分頁 ===
+    # === Variable Inspector Tab ===
     ui_we_want_to_set.tab_menu.add_variable_inspector_ui_action = QAction(
         language_wrapper.language_word_dict.get("tab_menu_variable_inspector_tab_name"))
     ui_we_want_to_set.tab_menu.add_variable_inspector_ui_action.triggered.connect(
         lambda: add_variable_inspector_tab(ui_we_want_to_set)
     )
     ui_we_want_to_set.tab_menu.addAction(ui_we_want_to_set.tab_menu.add_variable_inspector_ui_action)
-    # Dynamic Console
+
+    # === Console 分頁 ===
+    # === Console Tab ===
     ui_we_want_to_set.tab_menu.add_console_widget_ui_action = QAction(
         language_wrapper.language_word_dict.get("tab_menu_console_widget_tab_name"))
     ui_we_want_to_set.tab_menu.add_console_widget_ui_action.triggered.connect(
         lambda: add_console_widget_tab(ui_we_want_to_set)
     )
     ui_we_want_to_set.tab_menu.addAction(ui_we_want_to_set.tab_menu.add_console_widget_ui_action)
-    # Code diff viewer
+
+    # === Code Diff Viewer 分頁 ===
+    # === Code Diff Viewer Tab ===
     ui_we_want_to_set.tab_menu.add_code_diff_viewer_ui_action = QAction(
         language_wrapper.language_word_dict.get("tab_code_diff_viewer_tab_name"))
     ui_we_want_to_set.tab_menu.add_code_diff_viewer_ui_action.triggered.connect(
@@ -97,7 +145,13 @@ def set_tab_menu(ui_we_want_to_set: EditorMain) -> None:
     )
     ui_we_want_to_set.tab_menu.addAction(ui_we_want_to_set.tab_menu.add_code_diff_viewer_ui_action)
 
+
+# === 以下為各分頁新增函式 ===
+# === Functions to add each tab ===
+
 def add_editor_tab(ui_we_want_to_set: EditorMain):
+    # 新增 Editor 分頁
+    # Add Editor tab
     jeditor_logger.info(f"build_tab_menu.py add editor tab ui_we_want_to_set: {ui_we_want_to_set}")
     widget = EditorWidget(ui_we_want_to_set)
     ui_we_want_to_set.tab_widget.addTab(
@@ -108,69 +162,113 @@ def add_editor_tab(ui_we_want_to_set: EditorMain):
 
 
 def add_frontengine_tab(ui_we_want_to_set: EditorMain):
+    # 新增 FrontEngine 分頁
+    # Add FrontEngine tab
     jeditor_logger.info(f"build_tab_menu.py add frontengine tab ui_we_want_to_set: {ui_we_want_to_set}")
     ui_we_want_to_set.tab_widget.addTab(
         FrontEngineMainUI(show_system_tray_ray=False, redirect_output=False),
         f"{language_wrapper.language_word_dict.get('tab_menu_frontengine_tab_name')} "
         f"{ui_we_want_to_set.tab_widget.count()}")
 
-
 def add_web_tab(ui_we_want_to_set: EditorMain):
+    # 紀錄日誌：新增 Web 分頁
+    # Log: add a Web tab
     jeditor_logger.info(f"build_tab_menu.py add web tab ui_we_want_to_set: {ui_we_want_to_set}")
+    # 在主編輯器的 tab_widget 中新增一個瀏覽器分頁
+    # Add a browser tab into the main editor's tab_widget
     ui_we_want_to_set.tab_widget.addTab(
-        MainBrowserWidget(),
+        MainBrowserWidget(),  # 建立瀏覽器元件 / Create browser widget
         f"{language_wrapper.language_word_dict.get('tab_menu_web_tab_name')} "
-        f"{ui_we_want_to_set.tab_widget.count()}")
+        f"{ui_we_want_to_set.tab_widget.count()}"  # 分頁名稱包含序號 / Tab name with index
+    )
 
 
 def add_ipython_tab(ui_we_want_to_set: EditorMain):
+    # 紀錄日誌：新增 IPython 分頁
+    # Log: add an IPython tab
     jeditor_logger.info(f"build_tab_menu.py add ipython tab ui_we_want_to_set: {ui_we_want_to_set}")
+    # 在主編輯器中新增 IPython 互動式分頁
+    # Add an IPython interactive tab
     ui_we_want_to_set.tab_widget.addTab(
-        IpythonWidget(ui_we_want_to_set),
+        IpythonWidget(ui_we_want_to_set),  # 建立 IPython 元件 / Create IPython widget
         f"{language_wrapper.language_word_dict.get('tab_menu_ipython_tab_name')} "
-        f"{ui_we_want_to_set.tab_widget.count()}")
+        f"{ui_we_want_to_set.tab_widget.count()}"
+    )
 
 
 def add_chat_ui_tab(ui_we_want_to_set: EditorMain):
+    # 紀錄日誌：新增 Chat UI 分頁
+    # Log: add a Chat UI tab
     jeditor_logger.info(f"build_tab_menu.py add chat_ui tab ui_we_want_to_set: {ui_we_want_to_set}")
+    # 在主編輯器中新增聊天分頁
+    # Add a chat tab into the main editor
     ui_we_want_to_set.tab_widget.addTab(
-        ChatUI(ui_we_want_to_set),
+        ChatUI(ui_we_want_to_set),  # 建立聊天元件 / Create Chat UI widget
         f"{language_wrapper.language_word_dict.get('tab_menu_chat_ui_tab_name')} "
-        f"{ui_we_want_to_set.tab_widget.count()}")
+        f"{ui_we_want_to_set.tab_widget.count()}"
+    )
 
 
 def add_git_client_tab(ui_we_want_to_set: EditorMain):
+    # 紀錄日誌：新增 Git Client 分頁
+    # Log: add a Git Client tab
     jeditor_logger.info(f"build_tab_menu.py add git client tab ui_we_want_to_set: {ui_we_want_to_set}")
+    # 在主編輯器中新增 Git 客戶端分頁
+    # Add a Git client tab
     ui_we_want_to_set.tab_widget.addTab(
-        GitGui(),
+        GitGui(),  # 建立 Git GUI 元件 / Create Git GUI widget
         f"{language_wrapper.language_word_dict.get('tab_menu_git_client_tab_name')} "
-        f"{ui_we_want_to_set.tab_widget.count()}")
+        f"{ui_we_want_to_set.tab_widget.count()}"
+    )
+
 
 def add_git_tree_view_tab(ui_we_want_to_set: EditorMain):
+    # 紀錄日誌：新增 Git Branch Tree 分頁
+    # Log: add a Git Branch Tree tab
     jeditor_logger.info(f"build_tab_menu.py add git tree view tab ui_we_want_to_set: {ui_we_want_to_set}")
+    # 在主編輯器中新增 Git 分支樹狀圖分頁
+    # Add a Git branch tree view tab
     ui_we_want_to_set.tab_widget.addTab(
-        GitTreeViewGUI(),
+        GitTreeViewGUI(),  # 建立 Git Tree View 元件 / Create Git Tree View widget
         f"{language_wrapper.language_word_dict.get('tab_menu_git_branch_tree_view_tab_name')} "
-        f"{ui_we_want_to_set.tab_widget.count()}")
+        f"{ui_we_want_to_set.tab_widget.count()}"
+    )
+
 
 def add_variable_inspector_tab(ui_we_want_to_set: EditorMain):
+    # 紀錄日誌：新增 Variable Inspector 分頁
+    # Log: add a Variable Inspector tab
     jeditor_logger.info(f"build_tab_menu.py add variable inspector tab ui_we_want_to_set: {ui_we_want_to_set}")
+    # 在主編輯器中新增變數檢查器分頁
+    # Add a variable inspector tab
     ui_we_want_to_set.tab_widget.addTab(
-        VariableInspector(),
+        VariableInspector(),  # 建立變數檢查器元件 / Create Variable Inspector widget
         f"{language_wrapper.language_word_dict.get('tab_menu_variable_inspector_tab_name')} "
-        f"{ui_we_want_to_set.tab_widget.count()}")
+        f"{ui_we_want_to_set.tab_widget.count()}"
+    )
 
 
 def add_console_widget_tab(ui_we_want_to_set: EditorMain):
+    # 紀錄日誌：新增 Console 分頁
+    # Log: add a Console tab
     jeditor_logger.info(f"build_tab_menu.py add console widget tab ui_we_want_to_set: {ui_we_want_to_set}")
+    # 在主編輯器中新增動態控制台分頁
+    # Add a dynamic console tab
     ui_we_want_to_set.tab_widget.addTab(
-        ConsoleWidget(),
+        ConsoleWidget(),  # 建立控制台元件 / Create Console widget
         f"{language_wrapper.language_word_dict.get('tab_menu_console_widget_tab_name')} "
-        f"{ui_we_want_to_set.tab_widget.count()}")
+        f"{ui_we_want_to_set.tab_widget.count()}"
+    )
+
 
 def add_code_diff_compare_tab(ui_we_want_to_set: EditorMain):
+    # 紀錄日誌：新增 Code Diff Compare 分頁
+    # Log: add a Code Diff Compare tab
     jeditor_logger.info(f"build_tab_menu.py add code diff compare tab ui_we_want_to_set: {ui_we_want_to_set}")
+    # 在主編輯器中新增程式碼差異比較分頁
+    # Add a code diff comparison tab
     ui_we_want_to_set.tab_widget.addTab(
-        DiffViewerWidget(),
+        DiffViewerWidget(),  # 建立程式碼比對元件 / Create Code Diff Viewer widget
         f"{language_wrapper.language_word_dict.get('tab_code_diff_viewer_tab_name')} "
-        f"{ui_we_want_to_set.tab_widget.count()}")
+        f"{ui_we_want_to_set.tab_widget.count()}"
+    )

je_editor/pyside_ui/main_ui/menu/text_menu/build_text_menu.py

@@ -1,31 +1,69 @@
 from __future__ import annotations
+# 啟用未來註解功能，允許型別提示使用字串前向參照
+# Enable future annotations, allowing forward references in type hints
 
 from typing import TYPE_CHECKING
+# TYPE_CHECKING 用於避免在執行時載入不必要的模組
+# TYPE_CHECKING prevents unnecessary imports at runtime
 
 from PySide6.QtGui import QAction
+# 匯入 QAction，用於建立選單動作
+# Import QAction for creating menu actions
 
 from je_editor.pyside_ui.main_ui.editor.editor_widget import EditorWidget
+# 匯入編輯器元件
+# Import the Editor widget
+
 from je_editor.pyside_ui.main_ui.save_settings.user_setting_file import user_setting_dict
+# 匯入使用者設定字典，用於儲存字型與字體大小
+# Import user setting dictionary to save font and size
+
 from je_editor.utils.logging.loggin_instance import jeditor_logger
+# 匯入日誌工具
+# Import logger
 
 if TYPE_CHECKING:
     from je_editor.pyside_ui.main_ui.main_editor import EditorMain
+    # 僅在型別檢查時匯入 EditorMain，避免循環依賴
+    # Import EditorMain only for type checking
+
 from je_editor.utils.multi_language.multi_language_wrapper import language_wrapper
+# 匯入多語言包裝器，用於多語系 UI
+# Import language wrapper for multilingual UI
 
 
 def set_text_menu(ui_we_want_to_set: EditorMain):
+    """
+    建立文字選單，包含字型與字體大小的子選單
+    Create the text menu, including font and font size submenus
+    """
     jeditor_logger.info(f"build_text_menu.py set_text_menu ui_we_want_to_set: {ui_we_want_to_set}")
+
+    # 建立 Text Menu
+    # Create Text Menu
     ui_we_want_to_set.text_menu = ui_we_want_to_set.menu.addMenu(
         language_wrapper.language_word_dict.get("text_menu_label"))
+
+    # === 字型選單 (Font Menu) ===
+    # === Font Menu ===
     ui_we_want_to_set.text_menu.font_menu = ui_we_want_to_set.text_menu.addMenu(
         language_wrapper.language_word_dict.get("text_menu_label_font"))
+
+    # 將系統支援的字型加入選單
+    # Add available system fonts into the menu
     for family in ui_we_want_to_set.font_database.families():
         font_action = QAction(family, parent=ui_we_want_to_set.text_menu.font_menu)
         font_action.triggered.connect(
             lambda checked=False, action=font_action: set_font(ui_we_want_to_set, action))
         ui_we_want_to_set.text_menu.font_menu.addAction(font_action)
+
+    # === 字體大小選單 (Font Size Menu) ===
+    # === Font Size Menu ===
     ui_we_want_to_set.text_menu.font_size_menu = ui_we_want_to_set.text_menu.addMenu(
         language_wrapper.language_word_dict.get("text_menu_label_font_size"))
+
+    # 提供 12 ~ 36 pt 的字體大小選項 (每次增加 2)
+    # Provide font sizes from 12 to 36 pt (step = 2)
     for size in range(12, 38, 2):
         font_action = QAction(str(size), parent=ui_we_want_to_set.text_menu.font_size_menu)
         font_action.triggered.connect(
@@ -34,36 +72,62 @@ def set_text_menu(ui_we_want_to_set: EditorMain):
 
 
 def set_font(ui_we_want_to_set: EditorMain, action: QAction) -> None:
+    """
+    設定編輯器的字型
+    Set the font family for the editor
+    """
     jeditor_logger.info("build_text_menu.py set_font "
                         f"ui_we_want_to_set: {ui_we_want_to_set} "
                         f"action: {action}")
+
+    # 遍歷所有分頁，找到 EditorWidget 並套用字型
+    # Iterate through all tabs, apply font to EditorWidget
     for code_editor in range(ui_we_want_to_set.tab_widget.count()):
         widget = ui_we_want_to_set.tab_widget.widget(code_editor)
         if isinstance(widget, EditorWidget):
+            # 設定程式碼編輯區字型
+            # Set font for code editor
             widget.code_edit.setStyleSheet(
                 f"font-size: {widget.code_edit.font().pointSize()}pt;"
                 f"font-family: {action.text()};"
             )
+            # 設定輸出結果區字型
+            # Set font for result display
             widget.code_result.setStyleSheet(
                 f"font-size: {widget.code_result.font().pointSize()}pt;"
                 f"font-family: {action.text()};"
             )
+            # 更新使用者設定
+            # Update user settings
             user_setting_dict.update({"font": action.text()})
 
 
 def set_font_size(ui_we_want_to_set: EditorMain, action: QAction) -> None:
+    """
+    設定編輯器的字體大小
+    Set the font size for the editor
+    """
     jeditor_logger.info("build_text_menu.py set_font_size "
                         f"ui_we_want_to_set: {ui_we_want_to_set} "
                         f"action: {action}")
+
+    # 遍歷所有分頁，找到 EditorWidget 並套用字體大小
+    # Iterate through all tabs, apply font size to EditorWidget
     for code_editor in range(ui_we_want_to_set.tab_widget.count()):
         widget = ui_we_want_to_set.tab_widget.widget(code_editor)
         if type(widget) is EditorWidget:
+            # 設定程式碼編輯區字體大小
+            # Set font size for code editor
             widget.code_edit.setStyleSheet(
                 f"font-size: {int(action.text())}pt;"
                 f"font-family: {widget.code_edit.font().family()};"
             )
+            # 設定輸出結果區字體大小
+            # Set font size for result display
             widget.code_result.setStyleSheet(
                 f"font-size: {int(action.text())}pt;"
                 f"font-family: {widget.code_result.font().family()};"
             )
-            user_setting_dict.update({"font_size": int(action.text())})
+            # 更新使用者設定
+            # Update user settings
+            user_setting_dict.update({"font_size": int(action.text())})

je_editor/pyside_ui/main_ui/save_settings/setting_utils.py

@@ -6,11 +6,28 @@ from je_editor.utils.logging.loggin_instance import jeditor_logger
 
 
 def write_setting(save_dict: dict, file_name: str) -> None:
+    """
+    將設定資料寫入 JSON 檔案
+    Write settings dictionary into a JSON file
+    """
+    # 紀錄日誌，方便除錯與追蹤
+    # Log the action for debugging and tracking
     jeditor_logger.info("setting_utils.py write_setting "
                         f"save_dict: {save_dict} "
                         f"file_name: {file_name}")
+
+    # 建立儲存設定的資料夾路徑：當前工作目錄下的 `.jeditor`
+    # Create the save directory path: `.jeditor` under current working directory
     save_dir = Path(getcwd() + "/.jeditor")
+
+    # 如果資料夾不存在就自動建立 (parents=True 表示可遞迴建立多層資料夾)
+    # Create the directory if it does not exist (parents=True allows nested dirs)
     save_dir.mkdir(parents=True, exist_ok=True)
+
+    # 建立完整的檔案路徑，例如 `.jeditor/settings.json`
+    # Create the full file path, e.g., `.jeditor/settings.json`
     save_file = Path(getcwd() + f"/.jeditor/{file_name}")
-    write_json(str(save_file), save_dict)
 
+    # 將設定字典寫入 JSON 檔案
+    # Write the dictionary into the JSON file
+    write_json(str(save_file), save_dict)

je_editor/pyside_ui/main_ui/save_settings/user_color_setting_file.py

@@ -10,34 +10,47 @@ from je_editor.utils.logging.loggin_instance import jeditor_logger
 
 
 def update_actually_color_dict():
+    """
+    更新實際使用的顏色字典 (actually_color_dict)，
+    將 user_setting_color_dict 中的 RGB 值轉換成 QColor 物件。
+    Update the actual color dictionary (actually_color_dict),
+    converting RGB values from user_setting_color_dict into QColor objects.
+    """
     jeditor_logger.info(f"user_color_setting_file.py update_actually_color_dict")
+
     actually_color_dict.update(
         {
+            # 行號顏色 / Line number color
             "line_number_color": QColor(
                 user_setting_color_dict.get("line_number_color")[0],
                 user_setting_color_dict.get("line_number_color")[1],
                 user_setting_color_dict.get("line_number_color")[2],
             ),
+            # 行號背景顏色 / Line number background color
             "line_number_background_color": QColor(
                 user_setting_color_dict.get("line_number_background_color")[0],
                 user_setting_color_dict.get("line_number_background_color")[1],
                 user_setting_color_dict.get("line_number_background_color")[2],
             ),
+            # 當前行顏色 / Current line highlight color
             "current_line_color": QColor(
                 user_setting_color_dict.get("current_line_color")[0],
                 user_setting_color_dict.get("current_line_color")[1],
                 user_setting_color_dict.get("current_line_color")[2],
             ),
+            # 一般輸出顏色 / Normal output color
             "normal_output_color": QColor(
                 user_setting_color_dict.get("normal_output_color")[0],
                 user_setting_color_dict.get("normal_output_color")[1],
                 user_setting_color_dict.get("normal_output_color")[2],
             ),
+            # 錯誤輸出顏色 / Error output color
             "error_output_color": QColor(
                 user_setting_color_dict.get("error_output_color")[0],
                 user_setting_color_dict.get("error_output_color")[1],
                 user_setting_color_dict.get("error_output_color")[2],
             ),
+            # 警告輸出顏色 / Warning output color
             "warning_output_color": QColor(
                 user_setting_color_dict.get("warning_output_color")[0],
                 user_setting_color_dict.get("warning_output_color")[1],
@@ -47,6 +60,8 @@ def update_actually_color_dict():
     )
 
 
+# 使用者設定的顏色字典 (以 RGB list 表示)
+# User-defined color dictionary (stored as RGB lists)
 user_setting_color_dict: Dict[str, list] = {
     "line_number_color": [255, 255, 255],
     "line_number_background_color": [179, 179, 179],
@@ -56,18 +71,33 @@ user_setting_color_dict: Dict[str, list] = {
     "warning_output_color": [204, 204, 0]
 }
 
-actually_color_dict: Dict[str, QColor] = {
-}
+# 實際使用的顏色字典 (以 QColor 表示)
+# Actual color dictionary (stored as QColor objects)
+actually_color_dict: Dict[str, QColor] = {}
+
+# 初始化時先更新一次
+# Update once at initialization
 update_actually_color_dict()
 
 
 def write_user_color_setting() -> None:
+    """
+    將使用者顏色設定寫入 JSON 檔案
+    Write user color settings into a JSON file
+    """
     jeditor_logger.info("user_color_setting_file.py write_user_color_setting")
     write_setting(user_setting_color_dict, "user_color_setting.json")
 
 
 def read_user_color_setting() -> None:
+    """
+    從 JSON 檔案讀取使用者顏色設定，並更新 user_setting_color_dict
+    Read user color settings from JSON file and update user_setting_color_dict
+    """
     jeditor_logger.info("user_color_setting_file.py read_user_color_setting")
     user_color_setting_file = Path(getcwd() + "/.jeditor/user_color_setting.json")
+
+    # 如果檔案存在，就讀取並更新設定
+    # If the file exists, read and update the settings
     if user_color_setting_file.exists() and user_color_setting_file.is_file():
-        user_setting_color_dict.update(read_json(str(user_color_setting_file)))
+        user_setting_color_dict.update(read_json(str(user_color_setting_file)))

je_editor/pyside_ui/main_ui/save_settings/user_setting_file.py

@@ -2,30 +2,57 @@ from os import getcwd
 from pathlib import Path
 
 from je_editor.pyside_ui.main_ui.save_settings.setting_utils import write_setting
+# 匯入通用的設定寫入工具
+# Import utility function to write settings
+
 from je_editor.utils.json.json_file import read_json
+# 匯入 JSON 讀取工具
+# Import JSON reader utility
+
 from je_editor.utils.logging.loggin_instance import jeditor_logger
+# 匯入日誌工具
+# Import logger
+
 
+# 使用者設定字典，包含 UI 與編輯器的偏好
+# User settings dictionary, storing UI and editor preferences
 user_setting_dict = {
-    "ui_font": "Lato",
-    "ui_font_size": 12,
-    "language": "English",
-    "ui_style": "dark_amber.xml",
-    "font": "Lato",
-    "font_size": 12,
-    "encoding": "utf-8",
-    "last_file": None,
-    "python_compiler": None,
-    "max_line_of_output": 200000,
+    "ui_font": "Lato",              # UI 字型 / UI font
+    "ui_font_size": 12,             # UI 字體大小 / UI font size
+    "language": "English",          # 語言設定 / Language setting
+    "ui_style": "dark_amber.xml",   # UI 樣式檔 / UI style file
+    "font": "Lato",                 # 編輯器字型 / Editor font
+    "font_size": 12,                # 編輯器字體大小 / Editor font size
+    "encoding": "utf-8",            # 檔案編碼 / File encoding
+    "last_file": None,              # 上次開啟的檔案 / Last opened file
+    "python_compiler": None,        # Python 編譯器路徑 / Python compiler path
+    "max_line_of_output": 200000,   # 最大輸出行數限制 / Max lines of output
 }
 
 
 def write_user_setting() -> None:
+    """
+    將使用者設定寫入 JSON 檔案
+    Write user settings into a JSON file
+    """
     jeditor_logger.info("user_setting_file.py write_user_setting")
+    # 呼叫通用工具，將 user_setting_dict 寫入 `.jeditor/user_setting.json`
+    # Use utility to write user_setting_dict into `.jeditor/user_setting.json`
     write_setting(user_setting_dict, "user_setting.json")
 
 
 def read_user_setting() -> None:
+    """
+    從 JSON 檔案讀取使用者設定，並更新 user_setting_dict
+    Read user settings from JSON file and update user_setting_dict
+    """
     jeditor_logger.info("user_setting_file.py read_user_setting")
+
+    # 設定檔路徑：當前工作目錄下的 `.jeditor/user_setting.json`
+    # File path: `.jeditor/user_setting.json` under current working directory
     user_setting_file = Path(getcwd() + "/.jeditor/user_setting.json")
+
+    # 如果檔案存在，就讀取並更新設定字典
+    # If the file exists, read and update the settings dictionary
     if user_setting_file.exists() and user_setting_file.is_file():
-        user_setting_dict.update(read_json(str(user_setting_file)))
+        user_setting_dict.update(read_json(str(user_setting_file)))