je-editor 0.0.104__py3-none-any.whl → 0.0.228__py3-none-any.whl

je_editor/pyside_ui/code/code_process/code_exec.py

@@ -0,0 +1,267 @@
+from __future__ import annotations  # 支援延遲型別註解 (Python 3.7+)
+
+import queue  # 佇列，用於執行緒間傳遞訊息
+import subprocess  # 建立與管理子程序 (執行外部程式)
+import sys  # 系統相關資訊 (平台、參數等)
+from pathlib import Path  # 處理檔案與路徑
+from threading import Thread  # 執行緒，用於非同步處理
+from typing import Union  # 型別提示：允許多種型別
+
+from PySide6.QtCore import QTimer  # Qt 計時器，用於定時觸發事件
+from PySide6.QtGui import QTextCharFormat  # 設定文字格式 (顏色、字型等)
+from PySide6.QtWidgets import QTextEdit  # 文字編輯器元件
+
+# 專案內部模組
+from je_editor.pyside_ui.code.running_process_manager import run_instance_manager
+from je_editor.pyside_ui.main_ui.editor.editor_widget import EditorWidget
+from je_editor.pyside_ui.main_ui.save_settings.user_color_setting_file import actually_color_dict
+from je_editor.utils.exception.exception_tags import je_editor_init_error
+from je_editor.utils.exception.exceptions import JEditorException
+from je_editor.utils.logging.loggin_instance import jeditor_logger
+from je_editor.utils.venv_check.check_venv import check_and_choose_venv
+
+
+# Support postponed evaluation of type annotations
+
+
+class ExecManager(object):
+    """
+    程式執行管理器
+    Execution manager for running code inside the editor.
+    負責：
+    - 建立子程序 (subprocess)
+    - 讀取標準輸出與錯誤輸出
+    - 將結果顯示在 QTextEdit
+    - 管理計時器與執行緒
+    """
+
+    def __init__(
+            self,
+            main_window: Union[EditorWidget, None] = None,  # 主視窗 (可為 None)
+            program_language: str = "python",  # 預設程式語言
+            program_encoding: str = "utf-8",  # 預設編碼
+            program_buffer: int = 1024,  # 緩衝區大小
+    ):
+        """
+        初始化執行管理器
+        Initialize ExecManager
+        """
+        jeditor_logger.info(f"Init ExecManager "
+                            f"main_window: {main_window} "
+                            f"program_language: {program_language} "
+                            f"program_encoding: {program_encoding} "
+                            f"program_buffer: {program_buffer}")
+        # 初始化屬性
+        self.read_program_error_output_from_thread = None  # 錯誤輸出讀取執行緒
+        self.read_program_output_from_thread = None  # 標準輸出讀取執行緒
+        self.main_window: EditorWidget = main_window  # 主視窗
+        self.compiler_path = None  # 編譯器/直譯器路徑
+        self.code_result: Union[QTextEdit, None] = None  # 顯示程式輸出的文字框
+        self.code_result_cursor: Union[QTextEdit.textCursor, None] = None
+        self.timer: Union[QTimer, None] = None  # 定時器
+        self.still_run_program = True  # 程式是否仍在執行
+        self.process: Union[subprocess.Popen, None] = None  # 子程序
+        self.run_output_queue = queue.Queue()  # 標準輸出佇列
+        self.run_error_queue = queue.Queue()  # 錯誤輸出佇列
+        self.program_language = program_language
+        self.program_encoding = program_encoding
+        self.program_buffer = program_buffer
+        self.renew_path()  # 設定 Python 直譯器路徑
+        run_instance_manager.instance_list.append(self)  # 註冊到全域執行管理器
+
+    def renew_path(self) -> None:
+        """更新 Python 直譯器路徑 / Renew compiler path"""
+        jeditor_logger.info("ExecManager renew_path")
+        if self.main_window.python_compiler is None:
+            # 如果主視窗沒有指定 Python，則使用虛擬環境
+            if sys.platform in ["win32", "cygwin", "msys"]:
+                venv_path = Path(str(Path.cwd()) + "/venv/Scripts")
+            else:
+                venv_path = Path(str(Path.cwd()) + "/venv/bin")
+            self.compiler_path = check_and_choose_venv(venv_path)
+        else:
+            self.compiler_path = self.main_window.python_compiler
+
+    def later_init(self) -> None:
+        """延遲初始化，設定輸出區與計時器 / Setup code result area and timer"""
+        jeditor_logger.info("ExecManager later_init")
+        if self.main_window is not None:
+            self.code_result: QTextEdit = self.main_window.code_result
+            self.timer = QTimer(self.main_window)
+        else:
+            raise JEditorException(je_editor_init_error)
+
+    def exec_code(self, exec_file_name, exec_prefix: Union[str, list] = None) -> None:
+        """
+        執行指定檔案
+        Execute given file
+        :param exec_file_name: 要執行的檔案名稱
+        :param exec_prefix: 使用者自定義前綴 (例如 python -m)
+        """
+        jeditor_logger.info(f"ExecManager exec_code "
+                            f"exec_file_name: {exec_file_name} "
+                            f"exec_prefix: {exec_prefix}")
+        try:
+            self.exit_program()  # 確保先結束舊的程式
+            self.code_result.setPlainText("")  # 清空輸出區
+            file_path = Path(exec_file_name)
+            reformat_os_file_path = str(file_path.absolute())
+            exec_file = reformat_os_file_path
+
+            # 建立執行參數
+            if exec_prefix is None:
+                execute_program_param = [self.compiler_path, exec_file]
+            else:
+                if isinstance(exec_prefix, str):
+                    execute_program_param = [self.compiler_path, exec_prefix, exec_file]
+                else:
+                    execute_program_param = [self.compiler_path] + exec_prefix + [exec_file]
+
+            # 非 Windows 平台需轉為字串
+            if sys.platform not in ["win32", "cygwin", "msys"]:
+                execute_program_param = " ".join(execute_program_param)
+
+            # 建立子程序
+            self.process = subprocess.Popen(
+                execute_program_param,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                stdin=subprocess.PIPE,
+                shell=False
+            )
+            self.still_run_program = True
+
+            # 啟動輸出讀取執行緒
+            self.read_program_output_from_thread = Thread(
+                target=self.read_program_output_from_process,
+                daemon=True
+            )
+            self.read_program_output_from_thread.start()
+
+            # 啟動錯誤讀取執行緒
+            self.read_program_error_output_from_thread = Thread(
+                target=self.read_program_error_output_from_process,
+                daemon=True
+            )
+            self.read_program_error_output_from_thread.start()
+
+            # 顯示執行的檔案路徑
+            text_cursor = self.code_result.textCursor()
+            text_format = QTextCharFormat()
+            text_format.setForeground(actually_color_dict.get("normal_output_color"))
+            text_cursor.insertText(self.compiler_path + " " + reformat_os_file_path, text_format)
+            text_cursor.insertBlock()
+
+            # 啟動定時器，每 10ms 更新輸出
+            self.timer = QTimer(self.main_window)
+            self.timer.setInterval(10)
+            self.timer.timeout.connect(self.pull_text)
+            self.timer.start()
+
+        except Exception as error:
+            # 發生錯誤時顯示錯誤訊息
+            text_cursor = self.code_result.textCursor()
+            text_format = QTextCharFormat()
+            text_format.setForeground(actually_color_dict.get("normal_output_color"))
+            text_cursor.insertText(str(error), text_format)
+            text_cursor.insertBlock()
+            if self.process is not None:
+                self.process.terminate()
+
+    def full_exit_program(self):
+        """完全結束程式 / Fully exit program"""
+        jeditor_logger.info("ExecManager full_exit_program")
+        self.timer.stop()
+        self.exit_program()
+        self.main_window.exec_program = None
+
+    def pull_text(self) -> None:
+        jeditor_logger.info("ExecManager pull_text")
+        # 從佇列中取出訊息並顯示到 QTextEdit
+        # Pull text from queue and put in code result area
+        try:
+            # 處理標準輸出
+            if not self.run_output_queue.empty():
+                output_message = self.run_output_queue.get_nowait()
+                output_message = str(output_message).strip()
+                if output_message:
+                    text_cursor = self.code_result.textCursor()
+                    text_format = QTextCharFormat()
+                    text_format.setForeground(actually_color_dict.get("normal_output_color"))
+                    text_cursor.insertText(output_message, text_format)
+                    text_cursor.insertBlock()
+            # 處理錯誤輸出
+            if not self.run_error_queue.empty():
+                error_message = self.run_error_queue.get_nowait()
+                error_message = str(error_message).strip()
+                if error_message:
+                    text_cursor = self.code_result.textCursor()
+                    text_format = QTextCharFormat()
+                    text_format.setForeground(actually_color_dict.get("error_output_color"))
+                    text_cursor.insertText(error_message, text_format)
+                    text_cursor.insertBlock()
+        except queue.Empty:
+            # 如果佇列是空的就忽略
+            pass
+
+        # 如果子程序已經結束(returncode 不為 None)，則完全退出
+        if self.process.returncode == 0:
+            self.full_exit_program()
+        elif self.process.returncode is not None:
+            self.full_exit_program()
+
+        # 如果程式仍在執行，持續檢查狀態
+        if self.still_run_program:
+            # poll() 不會阻塞，只是更新 returncode
+            self.process.poll()
+
+    # 結束程式：將執行旗標設為 False，清理執行緒、佇列與子程序
+    # Exit program: change run flag to false and clean read thread, queue, and process
+    def exit_program(self) -> None:
+        jeditor_logger.info("ExecManager exit_program")
+        self.still_run_program = False
+        # 清除讀取執行緒的引用
+        if self.read_program_output_from_thread is not None:
+            self.read_program_output_from_thread = None
+        if self.read_program_error_output_from_thread is not None:
+            self.read_program_error_output_from_thread = None
+        # 清空佇列
+        self.print_and_clear_queue()
+        # 如果子程序存在，則終止
+        if self.process is not None:
+            self.process.terminate()
+            text_cursor = self.code_result.textCursor()
+            text_format = QTextCharFormat()
+            text_format.setForeground(actually_color_dict.get("normal_output_color"))
+            text_cursor.insertText(f"Program exit with code {self.process.returncode}", text_format)
+            text_cursor.insertBlock()
+            self.process = None
+
+    # 清空輸出與錯誤佇列
+    # Pull all remaining strings in queues and reset them
+    def print_and_clear_queue(self) -> None:
+        jeditor_logger.info("ExecManager print_and_clear_queue")
+        self.run_output_queue = queue.Queue()
+        self.run_error_queue = queue.Queue()
+
+    # 從子程序 stdout 持續讀取資料並放入輸出佇列
+    # Continuously read from process stdout and put into output queue
+    def read_program_output_from_process(self) -> None:
+        jeditor_logger.info("ExecManager read_program_output_from_process")
+        while self.still_run_program:
+            program_output_data: str = self.process.stdout.readline(
+                self.program_buffer).decode(self.program_encoding, "replace")
+            if self.process:
+                self.process.stdout.flush()
+            self.run_output_queue.put_nowait(program_output_data)
+
+    # 從子程序 stderr 持續讀取資料並放入錯誤佇列
+    # Continuously read from process stderr and put into error queue
+    def read_program_error_output_from_process(self) -> None:
+        jeditor_logger.info("ExecManager read_program_error_output_from_process")
+        while self.still_run_program:
+            program_error_output_data: str = self.process.stderr.readline(
+                self.program_buffer).decode(self.program_encoding, "replace")
+            if self.process:
+                self.process.stderr.flush()
+            self.run_error_queue.put_nowait(program_error_output_data)

je_editor/pyside_ui/code/plaintext_code_edit/code_edit_plaintext.py

@@ -0,0 +1,412 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from je_editor.utils.logging.loggin_instance import jeditor_logger
+
+# 僅在型別檢查時匯入，避免循環引用
+# Only imported for type checking, avoids circular imports
+if TYPE_CHECKING:
+    from je_editor.pyside_ui.main_ui.editor.editor_widget import EditorWidget
+    from je_editor.pyside_ui.main_ui.editor.editor_widget_dock import FullEditorWidget
+
+from typing import Union, List
+
+import jedi  # Python 自動補全與靜態分析工具
+from PySide6 import QtGui
+from PySide6.QtCore import Qt, QRect
+from PySide6.QtGui import (
+    QPainter, QTextCharFormat, QTextFormat, QKeyEvent, QAction,
+    QTextDocument, QTextCursor, QTextOption
+)
+from PySide6.QtWidgets import QPlainTextEdit, QWidget, QTextEdit, QCompleter
+from jedi.api.classes import Completion
+
+from je_editor.pyside_ui.code.syntax.python_syntax import PythonHighlighter
+from je_editor.pyside_ui.dialog.search_ui.search_text_box import SearchBox
+from je_editor.pyside_ui.main_ui.save_settings.user_color_setting_file import actually_color_dict
+
+
+def venv_check():
+    """檢查當前工作目錄下是否有 venv 資料夾 / Check if venv exists in current working directory"""
+    jeditor_logger.info("code_edit_plaintext.py venv check")
+    venv_path = Path(str(Path.cwd()) + "/venv")
+    return venv_path
+
+
+class CodeEditor(QPlainTextEdit):
+    """
+    自訂的程式碼編輯器，繼承 QPlainTextEdit
+    Custom code editor extending QPlainTextEdit
+
+    功能：
+    - 行號顯示 (Line number area)
+    - Tab 縮排距離設定
+    - Python 語法高亮 (Syntax highlighting)
+    - 搜尋功能 (Search box)
+    - 自動補全 (Autocomplete with Jedi)
+    """
+
+    def __init__(self, main_window: Union[EditorWidget, FullEditorWidget]):
+        jeditor_logger.info(f"Init CodeEditor main_window: {main_window}")
+        super().__init__()
+
+        # Jedi 環境，用於 Python 自動補全
+        self.env = None
+        self.check_env()
+
+        # 主視窗 (父元件)
+        self.main_window = main_window
+        self.current_file = main_window.current_file
+
+        # 定義哪些按鍵不會觸發補全視窗
+        self.skip_popup_behavior_list = [
+            Qt.Key.Key_Enter, Qt.Key.Key_Return, Qt.Key.Key_Up, Qt.Key.Key_Down,
+            Qt.Key.Key_Tab, Qt.Key.Key_Backtab, Qt.Key.Key_Space, Qt.Key.Key_Backspace
+        ]
+
+        # 定義哪些按鍵會觸發補全 (A-Z)
+        self.need_complete_list = [
+            Qt.Key.Key_A, Qt.Key.Key_B, Qt.Key.Key_C, Qt.Key.Key_D, Qt.Key.Key_E, Qt.Key.Key_F,
+            Qt.Key.Key_G, Qt.Key.Key_H, Qt.Key.Key_I, Qt.Key.Key_J, Qt.Key.Key_K, Qt.Key.Key_L,
+            Qt.Key.Key_M, Qt.Key.Key_N, Qt.Key.Key_O, Qt.Key.Key_P, Qt.Key.Key_Q, Qt.Key.Key_R,
+            Qt.Key.Key_S, Qt.Key.Key_T, Qt.Key.Key_U, Qt.Key.Key_V, Qt.Key.Key_W, Qt.Key.Key_X,
+            Qt.Key.Key_Y, Qt.Key.Key_Z
+        ]
+
+        # 搜尋框 (延遲建立)
+        self.search_box = None
+
+        # 行號區域 (LineNumber 是另一個自訂類別)
+        self.line_number: LineNumber = LineNumber(self)
+        self.blockCountChanged.connect(self.update_line_number_area_width)
+        self.updateRequest.connect(self.update_line_number_area)
+        self.update_line_number_area_width(0)
+
+        # 當文字改變時，重新高亮當前行
+        self.textChanged.connect(self.highlight_current_line)
+
+        # 設定 Tab 寬度 (以字元寬度計算)
+        self.setTabStopDistance(
+            QtGui.QFontMetricsF(self.font()).horizontalAdvance("        ")
+        )
+
+        # Python 語法高亮
+        self.highlighter = PythonHighlighter(self.document(), main_window=self)
+        self.highlight_current_line()
+
+        # 關閉自動換行，改為單行顯示
+        self.setLineWrapMode(self.LineWrapMode.NoWrap)
+        self.setWordWrapMode(QTextOption.WrapMode.WrapAnywhere)
+
+        # 搜尋功能 (Ctrl+F)
+        self.search_action = QAction("Search")
+        self.search_action.setShortcut("Ctrl+f")
+        self.search_action.triggered.connect(self.start_search_dialog)
+        self.addAction(self.search_action)
+
+        # 自動補全初始化
+        self.completer: Union[None, QCompleter] = None
+        self.set_complete([])
+
+    def reset_highlighter(self):
+        """重設語法高亮 / Reset syntax highlighter"""
+        jeditor_logger.info("CodeEditor reset_highlighter")
+        self.highlighter = PythonHighlighter(self.document(), main_window=self)
+        self.highlight_current_line()
+
+    def check_env(self):
+        """檢查虛擬環境並建立 Jedi 環境 / Check venv and create Jedi environment"""
+        jeditor_logger.info("CodeEditor check_env")
+        path = venv_check()
+        if path.exists():
+            self.env = jedi.create_environment(str(path))
+
+    def set_complete(self, list_to_complete: list) -> None:
+        """
+        設定自動補全清單
+        Set completion list
+        """
+        jeditor_logger.info(f"CodeEditor set_complete list_to_complete: {list_to_complete}")
+        completer = QCompleter(list_to_complete)
+        completer.activated.connect(self.insert_completion)
+        completer.setWidget(self)
+        completer.setWrapAround(False)
+        completer.setCompletionMode(QCompleter.CompletionMode.PopupCompletion)
+        completer.setCaseSensitivity(Qt.CaseSensitivity.CaseInsensitive)
+        self.completer = completer
+
+    def insert_completion(self, completion) -> None:
+        """
+        插入補全文字
+        Insert completion text into editor
+        """
+        jeditor_logger.info(f"CodeEditor insert_completion completion: {completion}")
+        if self.completer.widget() != self:
+            return
+        text_cursor = self.textCursor()
+        extra = len(completion) - len(self.completer.completionPrefix())
+        text_cursor.movePosition(QTextCursor.MoveOperation.Left)
+        text_cursor.movePosition(QTextCursor.MoveOperation.EndOfWord)
+        text_cursor.insertText(completion[-extra:])
+        self.setTextCursor(text_cursor)
+
+    @property
+    def text_under_cursor(self):
+        """取得游標下的文字 / Get text under cursor"""
+        jeditor_logger.info("CodeEditor text_under_cursor")
+        text_cursor = self.textCursor()
+        text_cursor.select(QTextCursor.SelectionType.WordUnderCursor)
+        return text_cursor.selectedText()
+
+    def focusInEvent(self, e) -> None:
+        """當編輯器獲得焦點時，確保 completer 綁定正確"""
+        jeditor_logger.info(f"CodeEditor focusInEvent event: {e}")
+        if self.completer:
+            self.completer.setWidget(self)
+        QPlainTextEdit.focusInEvent(self, e)
+
+    def complete(self) -> None:
+        """
+        使用 Jedi 進行自動補全
+        Keyword autocomplete with Jedi
+        """
+        jeditor_logger.info("CodeEditor complete")
+        prefix = self.text_under_cursor
+        if self.env is not None:
+            script = jedi.Script(code=self.toPlainText(), environment=self.env)
+        else:
+            script = jedi.Script(code=self.toPlainText())
+
+        # 取得補全清單
+        jedi_complete_list: List[Completion] = script.complete(
+            self.textCursor().blockNumber() + 1,
+            len(self.textCursor().document().findBlockByLineNumber(self.textCursor().blockNumber()).text())
+        )
+
+        if len(jedi_complete_list) > 0:
+            new_complete_list = [complete_text.name for complete_text in jedi_complete_list]
+            self.set_complete(new_complete_list)
+
+        # 顯示補全視窗
+        self.completer.setCompletionPrefix(prefix)
+        popup = self.completer.popup()
+        cursor_rect = self.cursorRect()
+        popup.setCurrentIndex(self.completer.completionModel().index(0, 0))
+        cursor_rect.setWidth(self.completer.popup().rect().size().width())
+        self.completer.complete(cursor_rect)
+
+    def start_search_dialog(self) -> None:
+        """顯示搜尋框 / Show search box"""
+        jeditor_logger.info("CodeEditor start_search_dialog")
+        self.search_box = SearchBox()
+        self.search_box.search_back_button.clicked.connect(self.find_back_text)
+        self.search_box.search_next_button.clicked.connect(
+            self.find_next_text
+        )
+        self.search_box.show()
+
+    def find_next_text(self) -> None:
+        """
+        找到下一個符合的文字
+        Find next match text
+        """
+        jeditor_logger.info("CodeEditor find_next_text")
+        if self.search_box.isVisible():
+            text = self.search_box.command_input.text()
+            self.find(text)
+
+    def find_back_text(self) -> None:
+        """
+        找到上一個符合的文字
+        Find previous match text
+        """
+        jeditor_logger.info("CodeEditor find_back_text")
+        if self.search_box.isVisible():
+            text = self.search_box.command_input.text()
+            self.find(text, QTextDocument.FindFlag.FindBackward)
+
+    def line_number_paint(self, event) -> None:
+        """
+        繪製行號區域
+        Paint line number area
+        """
+        jeditor_logger.info(f"CodeEditor line_number_paint event: {event}")
+        painter = QPainter(self.line_number)
+        # 填滿背景色
+        painter.fillRect(event.rect(), actually_color_dict.get("line_number_background_color"))
+
+        # 從第一個可見區塊開始
+        block = self.firstVisibleBlock()
+        block_number = block.blockNumber()
+        top = self.blockBoundingGeometry(block).translated(self.contentOffset()).top()
+        bottom = top + self.blockBoundingRect(block).height()
+
+        # 逐行繪製行號
+        while block.isValid() and top <= event.rect().bottom():
+            if block.isVisible() and bottom >= event.rect().top():
+                number = str(block_number + 1)
+                painter.setPen(actually_color_dict.get("line_number_color"))
+                painter.drawText(
+                    0,
+                    top,
+                    self.line_number.width(),
+                    self.fontMetrics().height(),
+                    Qt.AlignmentFlag.AlignCenter,
+                    number,
+                )
+            block = block.next()
+            top = bottom
+            bottom = top + self.blockBoundingRect(block).height()
+            block_number += 1
+
+    def line_number_width(self) -> int:
+        """
+        計算行號區域寬度
+        Calculate line number area width
+        """
+        jeditor_logger.info("CodeEditor line_number_width")
+        digits = len(str(self.blockCount()))  # 根據總行數決定位數
+        space = 12 * digits
+        return space
+
+    def update_line_number_area_width(self, value) -> None:
+        """
+        更新行號區域寬度
+        Update line number area width
+        """
+        jeditor_logger.info(f"CodeEditor update_line_number_area_width value: {value}")
+        self.setViewportMargins(self.line_number_width(), 0, 0, 0)
+
+    def resizeEvent(self, event) -> None:
+        """
+        視窗大小改變時，調整行號區域
+        Resize line number paint area
+        """
+        jeditor_logger.info(f"CodeEditor resizeEvent event:{event}")
+        QPlainTextEdit.resizeEvent(self, event)
+        cr = self.contentsRect()
+        self.line_number.setGeometry(
+            QRect(cr.left(), cr.top(), self.line_number_width(), cr.height()),
+        )
+
+    def update_line_number_area(self, rect, dy) -> None:
+        """
+        更新行號顯示
+        Update line number area
+        """
+        jeditor_logger.info(f"CodeEditor update_line_number_area rect: {rect}, dy: {dy}")
+        if dy:
+            self.line_number.scroll(0, dy)
+        else:
+            self.line_number.update(
+                0,
+                rect.y(),
+                self.line_number.width(),
+                rect.height(),
+            )
+        if rect.contains(self.viewport().rect()):
+            self.update_line_number_area_width(0)
+
+    def highlight_current_line(self) -> None:
+        """
+        高亮目前所在行
+        Highlight current line
+        """
+        jeditor_logger.info("CodeEditor highlight_current_line")
+        selections = []
+        if not self.isReadOnly():
+            formats = QTextCharFormat()
+            selection = QTextEdit.ExtraSelection()
+            selection.format = formats
+            color_of_the_line = actually_color_dict.get("current_line_color")
+            selection.cursor = self.textCursor()
+            selection.cursor.clearSelection()
+            selections.append(selection)
+            selection.format.setBackground(color_of_the_line)
+            selection.format.setProperty(QTextFormat.FullWidthSelection, True)
+        self.setExtraSelections(selections)
+
+    def keyPressEvent(self, event: QKeyEvent) -> None:
+        """
+        鍵盤事件處理
+        Handle key press events
+        - Ctrl+B: 使用 Jedi 跳轉定義
+        - Shift+Enter: 忽略軟換行
+        - 其他情況觸發自動補全
+        """
+        key = event.key()
+        jeditor_logger.info(f"CodeEditor keyPressEvent event: {event} key: {key}")
+
+        # Ctrl + B → 跳轉到定義
+        if event.modifiers() and Qt.Modifier.CTRL:
+            if key == Qt.Key.Key_B:
+                if self.env is not None:
+                    script = jedi.Script(code=self.toPlainText(), environment=self.env)
+                else:
+                    script = jedi.Script(code=self.toPlainText())
+                goto_list: List[jedi.api.classes.Name] = script.goto(
+                    self.textCursor().blockNumber() + 1, self.textCursor().positionInBlock())
+                if len(goto_list) > 0:
+                    path = goto_list[0].module_path
+                    if path is not None and path.exists():
+                        if self.main_window.current_file != str(path):
+                            self.main_window.main_window.go_to_new_tab(path)
+                    else:
+                        self.textCursor().setPosition(goto_list[0].line - 1)
+                return
+
+        # 如果補全視窗開啟，且按下不該觸發的按鍵 → 關閉補全
+        if self.completer.popup().isVisible() and key in self.skip_popup_behavior_list:
+            self.completer.popup().close()
+            event.ignore()
+            return
+
+        # Shift+Enter → 忽略 (避免軟換行影響行號)
+        if event.modifiers() and Qt.Modifier.SHIFT:
+            if key == Qt.Key.Key_Enter or key == Qt.Key.Key_Return:
+                event.ignore()
+                return
+
+        # 呼叫父類別處理其他按鍵
+        super().keyPressEvent(event)
+
+        # 更新目前行高亮
+        self.highlight_current_line()
+
+        # 如果輸入英文字母，觸發自動補全
+        if key in self.need_complete_list and self.completer is not None:
+            if self.completer.popup().isVisible():
+                self.completer.popup().close()
+            self.complete()
+
+    def mousePressEvent(self, event) -> None:
+        """
+        滑鼠點擊事件
+        Mouse press event
+        - 點擊後高亮所在行
+        """
+        jeditor_logger.info(f"CodeEditor mousePressEvent event: {event}")
+        super().mousePressEvent(event)
+        self.highlight_current_line()
+
+
+class LineNumber(QWidget):
+    """
+    行號區域元件
+    Widget used to paint line numbers
+    """
+
+    def __init__(self, editor):
+        jeditor_logger.info("Init LineNumber")
+        QWidget.__init__(self, parent=editor)
+        self.editor = editor
+
+    def paintEvent(self, event) -> None:
+        """
+        呼叫編輯器的 line_number_paint 來繪製行號
+        Delegate painting to CodeEditor.line_number_paint
+        """
+        jeditor_logger.info(f"LineNumber paintEvent event: {event}")
+        self.editor.line_number_paint(event)