ui/page_search_widget.py

from qtpy.QtWidgets import QHBoxLayout, QComboBox, QTextEdit, QLabel, QPlainTextEdit, QCheckBox, QVBoxLayout,  QGraphicsDropShadowEffect, QWidget
from qtpy.QtCore import Qt, QTimer, Signal
from qtpy.QtGui import QKeyEvent, QTextCursor, QHideEvent, QInputMethodEvent, QFontMetrics, QColor, QShowEvent, QSyntaxHighlighter, QTextCharFormat

from typing import List, Union, Tuple, Dict
import re

from utils.config import pcfg
from .custom_widget import Widget, ClickableLabel
from .textitem import TextBlkItem
from .textedit_area import TransPairWidget, SourceTextEdit, TransTextEdit

SEARCHRST_HIGHLIGHT_COLOR = QColor(30, 147, 229, 60)
CURRENT_TEXT_COLOR = QColor(244, 249, 28)


class Matched:
    def __init__(self, local_no: int, start: int, end: int) -> None:
        self.local_no = local_no
        self.start = start
        self.end = end


def match_text(pattern: re.Pattern, text: str) -> Tuple[int, Dict]:
    found_counter = 0
    match_map = {}
    rst_iter = pattern.finditer(text)
    for rst in rst_iter:
        span = rst.span()
        match_map[span[1]] = Matched(found_counter, span[0], span[1])
        found_counter += 1
    return found_counter, match_map


class HighlightMatched(QSyntaxHighlighter):

    def __init__(self, edit: SourceTextEdit, matched_map: dict = None):
        super().__init__(edit.document())
        
        self.case_sensitive = False
        self.whole_word = False
        if matched_map is None:
            self.matched_map: Dict = {}
        else:
            self.matched_map = matched_map
        self.current_start = -1
        self.edit = edit

    def setEditor(self, edit: SourceTextEdit):
        old_edit = self.edit
        if old_edit is not None:
            old_edit.highlighting = True
            old_edit.block_all_signals(True)
        if edit is not None:
            edit.highlighting = True
            self.setDocument(edit.document())
            edit.highlighting = False
        else:
            self.setDocument(None)
        self.edit = edit
        if old_edit is not None:
            old_edit.highlighting = False
            old_edit.block_all_signals(False)

    def set_matched_map(self, matched_map: dict):
        self.matched_map = matched_map
        self.rehighlight()

    def rehighlight(self) -> None:
        if self.edit is not None:
            self.edit.highlighting = True
        super().rehighlight()
        if self.edit is not None:
            self.edit.highlighting = False

    def set_current_span(self, start: int, end: int):
        self.current_start = start
        self.current_end = end
        self.rehighlight()

    def highlightBlock(self, text: str) -> None:
        if self.edit is None:
            return
        self.edit.highlighting = True
        fmt = QTextCharFormat()
        fmt.setBackground(SEARCHRST_HIGHLIGHT_COLOR)
        block = self.currentBlock()
        block_start = block.position()
        block_end = block_start + block.length()
        matched: Matched
        for match_end, matched in self.matched_map.items():
            match_start = matched.start
            intersect_start = max(match_start, block_start)
            intersect_end = min(match_end, block_end)
            length = intersect_end - intersect_start
            if length > 0:
                self.setFormat(intersect_start - block_start, length, fmt)

        if self.current_start >= 0:
            intersect_start = max(self.current_start, block_start)
            intersect_end = min(self.current_end, block_end)
            length = intersect_end - intersect_start
            if length > 0:
                fmt.setBackground(CURRENT_TEXT_COLOR)
                self.setFormat(intersect_start - block_start, length, fmt)
        self.edit.highlighting = False


class SearchEditor(QPlainTextEdit):
    height_changed = Signal()
    commit = Signal()
    enter_pressed = Signal()
    shift_enter_pressed = Signal()
    def __init__(self, parent: QWidget = None, original_height: int = 32, commit_latency: int = -1, shift_enter_prev: bool = True, *args, **kwargs):
        super().__init__(parent, *args, **kwargs)
        self.original_height = original_height
        self.commit_latency = commit_latency
        self.shift_enter_prev = shift_enter_prev
        if commit_latency > 0:
            self.commit_timer = QTimer(self)
            self.commit_timer.timeout.connect(self.on_commit_timer_timeout)
        else:
            self.commit_timer = None
        self.pre_editing = False
        self.setFixedHeight(original_height)
        self.document().documentLayout().documentSizeChanged.connect(self.adjustSize)
        self.textChanged.connect(self.on_text_changed)
        self.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
        self.setAttribute(Qt.WidgetAttribute.WA_InputMethodEnabled, True)

    def adjustSize(self):
        fm = QFontMetrics(self.font())
        h = fm.height() * self.document().size().height() * 1.05
        h += self.document().documentMargin() * 2
        h = int(h)
        if self.geometry().height() != h:
            self.setFixedHeight(max(h, self.original_height))
            self.height_changed.emit()

    def keyPressEvent(self, e: QKeyEvent) -> None:
        if e.key() == Qt.Key.Key_Return:
            if self.commit_timer is not None:
                self.commit_timer.stop()
            if e.modifiers() == Qt.KeyboardModifier.ShiftModifier:
                if self.shift_enter_prev:
                    e.setAccepted(True)
                    self.shift_enter_pressed.emit()
                    return
            else:
                e.setAccepted(True)
                self.enter_pressed.emit()
                return
        return super().keyPressEvent(e)

    def on_text_changed(self):
        if self.commit_timer is not None:
            if not self.pre_editing:
                self.commit_timer.stop()
                self.commit_timer.start(self.commit_latency)
        elif not self.pre_editing:
            self.commit.emit()

    def on_commit_timer_timeout(self):
        self.commit_timer.stop()
        self.commit.emit()

    def hideEvent(self, e: QHideEvent) -> None:
        if self.commit_timer is not None:
            self.commit_timer.stop()
        return super().hideEvent(e)

    def inputMethodEvent(self, e: QInputMethodEvent) -> None:
        if e.preeditString() == '':
            self.pre_editing = False
            if self.commit_timer is not None:
                self.commit_timer.start(self.commit_latency)
        else:
            if self.commit_timer is not None:
                self.commit_timer.stop()
            self.pre_editing = True
        return super().inputMethodEvent(e)


class PageSearchWidget(Widget):

    search = Signal()
    replace_all = Signal()
    replace_one = Signal()

    def __init__(self, parent: QWidget = None, *args, **kwargs) -> None:
        super().__init__(parent)

        self.search_rstedit_list: List[SourceTextEdit] = []
        self.search_counter_list: List[int] = []
        self.highlighter_list: List[HighlightMatched] = []
        self.counter_sum = 0
        self.pairwidget_list: List[TransPairWidget] = []
        self.textblk_item_list: List[TextBlkItem] = []

        self.current_edit: SourceTextEdit = None
        self.current_cursor: QTextCursor = None
        self.current_highlighter: HighlightMatched = None
        self.result_pos = 0
        self.update_cursor_on_insert = True

        self.search_editor = SearchEditor(self, commit_latency=-1)
        self.search_editor.setPlaceholderText(self.tr('Find'))
        self.search_editor.height_changed.connect(self.on_editor_height_changed)
        
        self.no_result_str = self.tr('No result')
        self.result_counter_label = QLabel(self.no_result_str)
        self.result_counter_label.setMaximumHeight(32)
        self.prev_match_btn = ClickableLabel(None, self)
        self.prev_match_btn.setObjectName('PrevMatchBtn')
        self.prev_match_btn.clicked.connect(self.on_prev_search_result)
        self.prev_match_btn.setToolTip(self.tr('Previous Match (Shift+Enter)'))

        self.next_match_btn = ClickableLabel(None, self)
        self.next_match_btn.setObjectName('NextMatchBtn')
        self.next_match_btn.clicked.connect(self.on_next_search_result)
        self.next_match_btn.setToolTip(self.tr('Next Match (Enter)'))

        self.case_sensitive_toggle = QCheckBox(self)
        self.case_sensitive_toggle.setObjectName('CaseSensitiveToggle')
        self.case_sensitive_toggle.setToolTip(self.tr('Match Case'))
        self.case_sensitive_toggle.clicked.connect(self.on_case_clicked)

        self.whole_word_toggle = QCheckBox(self)
        self.whole_word_toggle.setObjectName('WholeWordToggle')
        self.whole_word_toggle.setToolTip(self.tr('Match Whole Word'))
        self.whole_word_toggle.clicked.connect(self.on_whole_word_clicked)

        self.regex_toggle = QCheckBox(self)
        self.regex_toggle.setObjectName('RegexToggle')
        self.regex_toggle.setToolTip(self.tr('Use Regular Expression'))
        self.regex_toggle.clicked.connect(self.on_regex_clicked)

        self.range_combobox = QComboBox(self)
        self.range_combobox.addItems([self.tr('Translation'), self.tr('Source'), self.tr('All')])
        self.range_combobox.currentIndexChanged.connect(self.on_range_changed)
        self.range_label = QLabel(self)
        self.range_label.setText(self.tr('Range'))

        self.replace_editor = SearchEditor(self)
        self.replace_editor.setPlaceholderText(self.tr('Replace'))
        self.replace_btn = ClickableLabel(None, self)
        self.replace_btn.setObjectName('ReplaceBtn')
        self.replace_btn.clicked.connect(self.on_replace_btn_clicked)
        self.replace_btn.setToolTip(self.tr('Replace'))
        self.replace_all_btn = ClickableLabel(None, self)
        self.replace_all_btn.setObjectName('ReplaceAllBtn')
        self.replace_all_btn.clicked.connect(self.on_replaceall_btn_clicked)
        self.replace_all_btn.setToolTip(self.tr('Replace All'))

        hlayout_bar1_0 = QHBoxLayout()
        hlayout_bar1_0.addWidget(self.search_editor)
        hlayout_bar1_0.addWidget(self.result_counter_label)
        hlayout_bar1_0.setAlignment(Qt.AlignmentFlag.AlignTop)
        hlayout_bar1_0.setSpacing(10)

        hlayout_bar1_1 = QHBoxLayout()
        hlayout_bar1_1.addWidget(self.case_sensitive_toggle)
        hlayout_bar1_1.addWidget(self.whole_word_toggle)
        hlayout_bar1_1.addWidget(self.regex_toggle)
        hlayout_bar1_1.addWidget(self.prev_match_btn)
        hlayout_bar1_1.addWidget(self.next_match_btn)
        hlayout_bar1_1.setAlignment(hlayout_bar1_1.alignment() | Qt.AlignmentFlag.AlignTop)
        hlayout_bar1_1.setSpacing(5)

        hlayout_bar1 = QHBoxLayout()
        hlayout_bar1.addLayout(hlayout_bar1_0)
        hlayout_bar1.addLayout(hlayout_bar1_1)
        
        hlayout_bar2 = QHBoxLayout()
        hlayout_bar2.addWidget(self.replace_editor)
        hlayout_bar2.addWidget(self.replace_btn)
        hlayout_bar2.addWidget(self.replace_all_btn)
        hlayout_bar2.addStretch()
        hlayout_bar2.addWidget(self.range_label)
        hlayout_bar2.addWidget(self.range_combobox)
        hlayout_bar2.setSpacing(5)

        vlayout = QVBoxLayout(self)
        vlayout.addLayout(hlayout_bar1)
        vlayout.addLayout(hlayout_bar2)

        self.search_editor.commit.connect(self.on_commit_search)
        self.close_btn = ClickableLabel(None, self)
        self.close_btn.setObjectName('SearchCloseBtn')
        self.close_btn.setToolTip(self.tr('Close (Escape)'))
        self.close_btn.clicked.connect(self.on_close_button_clicked)
        hlayout_bar1_1.addWidget(self.close_btn)
        e = QGraphicsDropShadowEffect(self)
        e.setOffset(0, 0)
        e.setBlurRadius(35)
        self.setGraphicsEffect(e)
        self.setFixedWidth(520)
        self.search_editor.setFixedWidth(200)
        self.replace_editor.setFixedWidth(200)
        self.search_editor.enter_pressed.connect(self.on_next_search_result)
        self.search_editor.shift_enter_pressed.connect(self.on_prev_search_result)

        self.adjustSize()
        

    def on_close_button_clicked(self):
        self.hide()

    def hideEvent(self, e: QHideEvent) -> None:
        self.clean_highlighted()
        return super().hideEvent(e)

    def showEvent(self, e: QShowEvent) -> None:
        self.search_editor.setFocus()
        cursor = self.search_editor.textCursor()
        cursor.movePosition(QTextCursor.MoveOperation.End, QTextCursor.MoveMode.KeepAnchor)
        self.search_editor.setTextCursor(cursor)
        text = self.search_editor.toPlainText()
        if text != '':
            self.on_commit_search()
        return super().showEvent(e)

    def on_editor_height_changed(self):
        self.adjustSize()

    def adjustSize(self) -> None:
        tgt_size = self.search_editor.height() + self.replace_editor.height() + 30
        self.setFixedHeight(tgt_size)

    def setReplaceWidgetsVisibility(self, visible: bool):
        self.replace_editor.setVisible(visible)
        self.replace_all_btn.setVisible(visible)
        self.replace_btn.setVisible(visible)

    def clean_highlighted(self):
        for ii, e in enumerate(self.search_rstedit_list):
            self.highlighter_list[ii].setEditor(None)

    def clearSearchResult(self):
        for rst, hightlighter in zip(self.search_rstedit_list, self.highlighter_list):
            rst.text_changed.disconnect(self.on_rst_text_changed)
            hightlighter.setDocument(None)
        self.search_rstedit_list.clear()
        self.search_counter_list.clear()
        self.highlighter_list.clear()

        self.current_edit = None
        self.current_highlighter = None
        self.current_cursor = None
        self.updateCounterText()

    def on_rst_text_changed(self):
        edit: SourceTextEdit = self.sender()
        if edit.pre_editing or edit.highlighting:
            return

        idx = self.get_result_edit_index(edit)
        if idx < 0:
            return

        highlighter = self.highlighter_list[idx]
        counter, matched_map = self._match_text(edit.toPlainText())

        delta_count = counter - self.search_counter_list[idx]
        self.counter_sum += delta_count
        
        is_current_edit = False
        before_current = False
        if edit == self.current_edit:
            is_current_edit = True
        elif self.current_edit is not None and self.current_edit_index() > idx:
            before_current = True

        if counter > 0:
            self.search_counter_list[idx] = counter
            if is_current_edit:
                cursor_end = self.current_cursor.selectionEnd() 
                if cursor_end not in matched_map:
                    matched = self.get_prev_match(cursor_end)
                    if matched is None:
                        self.setCurrentEditor(self.current_edit)
                    else:
                        self.current_cursor.setPosition(matched.start)
                        self.current_cursor.setPosition(matched.end, QTextCursor.MoveMode.KeepAnchor)
                        self.result_pos = matched_map[matched.end].local_no
                        if idx > 0:
                            self.result_pos += sum(self.search_counter_list[ :idx])
                        self.highlight_current_text()
                else:
                    self.result_pos = matched_map[cursor_end].local_no
                    if idx > 0:
                        self.result_pos += sum(self.search_counter_list[ :idx])
                    self.highlight_current_text()
            elif before_current:
                self.result_pos += delta_count
            highlighter.set_matched_map(matched_map)
        else:
            edit = self.search_rstedit_list.pop(idx)
            self.search_counter_list.pop(idx)
            edit.text_changed.disconnect(self.on_rst_text_changed)
            highlighter = self.highlighter_list.pop(idx)
            highlighter.setEditor(None)
            if len(self.search_rstedit_list) == 0:
                self.clearSearchResult()
            elif self.current_edit is not None:
                if is_current_edit:
                    if idx >= len(self.search_rstedit_list):
                        self.setCurrentEditor(self.search_rstedit_list[0])
                    else:
                        self.setCurrentEditor(self.search_rstedit_list[idx])
                elif before_current:
                    self.result_pos += delta_count
        self.updateCounterText()

    def reInitialize(self):
        self.clearSearchResult()

    def page_search(self, update_cursor=True):

        self.clean_highlighted()
        self.clearSearchResult()

        if not self.isVisible():
            return

        text = self.search_editor.toPlainText()
        if text == '':
            self.updateCounterText()
            return

        search_range = self.range_combobox.currentIndex()
        search_src = search_range == 1
        search_trans = search_range == 0

        if search_src:
            for pw in self.pairwidget_list:
                self.find_page_text(pw.e_source)
        elif search_trans:
            for pw in self.pairwidget_list:
                self.find_page_text(pw.e_trans)
        else:
            for pw in self.pairwidget_list:
                self.find_page_text(pw.e_source)
                self.find_page_text(pw.e_trans)

        if len(self.search_counter_list) > 0:
            self.counter_sum = sum(self.search_counter_list)
        else:
            self.counter_sum = 0

        if update_cursor:
            if len(self.search_rstedit_list) > 0:
                self.setCurrentEditor(self.search_rstedit_list[0])
            else:
                self.updateCounterText()

    def get_regex_pattern(self) -> re.Pattern:
        target_text = self.search_editor.toPlainText()
        regexr = target_text
        if target_text == '':
            return None

        flag = re.DOTALL
        if not self.case_sensitive_toggle.isChecked():
            flag |= re.IGNORECASE
        if not self.regex_toggle.isChecked():
            regexr = re.escape(regexr)
        if self.whole_word_toggle.isChecked():
            regexr = r'\b' + target_text + r'\b'

        return re.compile(regexr, flag)

    def find_page_text(self, text_edit: QTextEdit):
        found_counter, pos_map = self._match_text(text_edit.toPlainText())
        if found_counter > 0:
            self.search_rstedit_list.append(text_edit)
            self.search_counter_list.append(found_counter)
            self.highlighter_list.append(HighlightMatched(text_edit, pos_map))
            text_edit.text_changed.connect(self.on_rst_text_changed)

    def _match_text(self, text: str) -> Tuple[int, Dict]:
        try:
            return match_text(self.get_regex_pattern(), text)
        except re.error:
            return 0, {}

    def get_result_edit_index(self, result: SourceTextEdit) -> int:
        try:
            return self.search_rstedit_list.index(result)
        except ValueError:
            return -1

    def current_edit_index(self) -> int:
        if self.current_edit is None:
            return -1
        return self.get_result_edit_index(self.current_edit)

    def setCurrentEditor(self, edit: SourceTextEdit):
        
        if type(edit) == SourceTextEdit and self.range_combobox.currentIndex() == 0 \
            or type(edit) == TransPairWidget and self.range_combobox.currentIndex() == 1:
            edit = None

        old_idx = self.current_edit_index()
        self.current_edit = edit

        if edit is None:
            if len(self.search_rstedit_list) > 0:
                self.current_edit = self.search_rstedit_list[0]
                self.current_highlighter = self.highlighter_list[0]

        if self.current_edit is not None:
            idx = self.current_edit_index()
            self.current_highlighter = self.highlighter_list[idx]
            self.updateCurrentCursor()
            matched_map = self.current_highlighter.matched_map
            matched: Matched = matched_map[self.current_cursor.selectionEnd()]
            self.result_pos = matched.local_no
            if idx > 0:
                self.result_pos += sum(self.search_counter_list[ :idx])
        else:
            self.current_cursor = None
            self.current_highlighter = None
        
        self.updateCounterText()
        self.highlight_current_text(old_idx)

    def updateCurrentCursor(self, intro_cursor=False, backward=False):
        cursor = self.current_edit.textCursor()
        text = self.search_editor.toPlainText()
        if intro_cursor or cursor.selectedText() != text:
            cursor.clearSelection()
            
        matched_map = self.current_highlighter.matched_map
        matched: Matched
        
        if not cursor.hasSelection():
            if backward:
                matched: Matched = matched_map[list(matched_map.keys())[-1]]
            else:
                matched: Matched = matched_map[list(matched_map.keys())[0]]
            cursor.setPosition(matched.start)
            cursor.setPosition(matched.end, QTextCursor.MoveMode.KeepAnchor)
        else:
            sel_start = cursor.selectionStart()
            for _, matched in matched_map.items():
                if matched.start >= sel_start:
                    cursor.setPosition(matched.start)
                    cursor.setPosition(matched.end, QTextCursor.MoveMode.KeepAnchor)
                    break

        c_pos = cursor.position()
        if c_pos not in matched_map:
            for k, matched in reversed(matched_map.items()):
                if k < c_pos:
                    cursor.setPosition(matched.start)
                    cursor.setPosition(matched.end, QTextCursor.MoveMode.KeepAnchor)
                    break

        if cursor is not None:
            if cursor.selectionEnd() not in self.current_highlighter.matched_map:
                for k, matched in self.current_highlighter.matched_map.items():
                    cursor.setPosition(matched.start)
                    cursor.setPosition(matched.end, QTextCursor.MoveMode.KeepAnchor)
                    break

        self.current_cursor = cursor

    def updateCounterText(self):
        if self.current_cursor is None or len(self.search_rstedit_list) == 0:
            self.result_counter_label.setText(self.no_result_str)
        else:
            self.result_counter_label.setText(f'{self.result_pos + 1} of {self.counter_sum}')

    def clean_current_selection(self):
        cursor = self.current_edit.textCursor()
        if cursor.hasSelection():
            cursor.clearSelection()
            self.current_edit.setTextCursor(cursor)

    def get_next_match(self, cursor_sel_start: int) -> Matched:
        if self.current_highlighter is None:
            return None
        matched: Matched
        for _, matched in self.current_highlighter.matched_map.items():
            if matched.start > cursor_sel_start:
                return matched
        return None

    def get_prev_match(self, cursor_sel_end: int) -> Matched:
        if self.current_highlighter is None:
            return None
        matched: Matched
        for _, matched in reversed(self.current_highlighter.matched_map.items()):
            if matched.end < cursor_sel_end:
                return matched
        return None

    def move_cursor(self, step: int = 1) -> int:
        cursor_reset = 0
        self.clean_current_selection()
        if step < 0:
            moved_matched = self.get_prev_match(self.current_cursor.selectionEnd())
        else:
            moved_matched = self.get_next_match(self.current_cursor.selectionStart())

        old_idx = -1
        if moved_matched is None:
            old_idx = self.current_edit_index()
            idx = old_idx + step
            # return step value if next move will be out of page
            num_rstedit = len(self.search_rstedit_list)
            if idx >= num_rstedit:
                cursor_reset = step
                idx = 0
            elif idx < 0:
                cursor_reset = step
                idx = num_rstedit - 1
            self.current_edit = self.search_rstedit_list[idx]
            self.current_highlighter = self.highlighter_list[idx]
            self.updateCurrentCursor(intro_cursor=True, backward=step < 0)
        else:
            self.current_cursor.setPosition(moved_matched.start)
            self.current_cursor.setPosition(moved_matched.end, QTextCursor.MoveMode.KeepAnchor)

        self.highlight_current_text(old_idx)
        return cursor_reset

    def highlight_current_text(self, old_idx: int = -1):
        if self.current_edit is None or not self.current_cursor.hasSelection():
            return

        idx = self.current_edit_index()
        if idx != -1:
            self.highlighter_list[idx].set_current_span(self.current_cursor.selectionStart(), self.current_cursor.selectionEnd())

        if old_idx != -1 and old_idx != idx:
            self.highlighter_list[old_idx].set_current_span(-1, -1)

        if self.isVisible():
            self.current_edit.ensure_scene_visible.emit()

    def on_next_search_result(self):
        if self.current_cursor is None:
            return
        move = self.move_cursor(1)
        if move == 0:
            self.result_pos = min(self.result_pos + 1, self.counter_sum - 1)
        else:
            self.result_pos = 0
        self.updateCounterText()

    def on_prev_search_result(self):
        if self.current_cursor is None:
            return
        move = self.move_cursor(-1)
        if move == 0:
            self.result_pos = max(self.result_pos - 1, 0)
        else:
            self.result_pos = self.counter_sum - 1
        self.updateCounterText()

    def on_whole_word_clicked(self):
        pcfg.fsearch_whole_word = self.whole_word_toggle.isChecked()
        self.page_search()

    def on_regex_clicked(self):
        pcfg.fsearch_regex = self.regex_toggle.isChecked()
        self.page_search()

    def on_case_clicked(self):
        pcfg.fsearch_case = self.case_sensitive_toggle.isChecked()
        self.page_search()

    def on_range_changed(self):
        pcfg.fsearch_range = self.range_combobox.currentIndex()
        self.page_search()

    def on_commit_search(self):
        self.page_search()
        self.highlight_current_text()

    def on_replaceall_btn_clicked(self):
        if self.counter_sum > 0:
            self.replace_all.emit()

    def on_replace_btn_clicked(self):
        if self.current_cursor is not None:
            self.replace_one.emit()

    def on_new_textblk(self, idx: int):
        if self.isVisible():
            pair_widget = self.pairwidget_list[idx]
            pair_widget.e_trans.text_changed.connect(self.on_nonrst_edit_text_changed)
            pair_widget.e_source.text_changed.connect(self.on_nonrst_edit_text_changed)

    def on_nonrst_edit_text_changed(self):
        edit: SourceTextEdit = self.sender()
        if not self.isVisible() or edit.pre_editing or edit in self.search_rstedit_list:
            return

        if type(edit) == SourceTextEdit and self.range_combobox.currentIndex() == 0 \
            or type(edit) == TransPairWidget and self.range_combobox.currentIndex() == 1:
            return

        text = self.search_editor.toPlainText()
        if text == '':
            return

        found_counter, match_map = self._match_text(edit.toPlainText())
        if found_counter > 0:
            current_idx = self.current_edit_index()
            insert_idx = 0
            for e in self.search_rstedit_list:
                if e.idx < edit.idx:
                    insert_idx += 1
                elif e.idx == edit.idx:
                    if type(edit) == TransTextEdit:
                        insert_idx += 1

            self.search_counter_list.insert(insert_idx, found_counter)
            self.search_rstedit_list.insert(insert_idx, edit)
            self.highlighter_list.insert(insert_idx, HighlightMatched(edit, match_map))
            edit.text_changed.connect(self.on_rst_text_changed)
            self.counter_sum += found_counter

            if current_idx != -1 and current_idx >= insert_idx:
                self.result_pos += found_counter
                self.updateCounterText()
            else:
                if self.update_cursor_on_insert:
                    self.result_pos = 0
                    self.setCurrentEditor(edit)
                else:
                    self.updateCounterText()