import re from qtpy import QtCore from qtpy import QtGui from qtpy import QtWidgets from qtpy.QtCore import Qt from .. import qtutils from .. import spellcheck from ..i18n import N_ from .text import event_anchor_mode, HintedTextEdit class SpellCheckTextEdit(HintedTextEdit): def __init__(self, context, hint, check=None, parent=None): HintedTextEdit.__init__(self, context, hint, parent) # Default dictionary based on the current locale. self.spellcheck = check or spellcheck.NorvigSpellCheck() self.highlighter = Highlighter(self.document(), self.spellcheck) def mousePressEvent(self, event): if event.button() == Qt.RightButton: # Rewrite the mouse event to a left button event so the cursor is # moved to the location of the pointer. if hasattr(event, 'position'): # Qt6 position = event.position() else: position = event.pos() event = QtGui.QMouseEvent( QtCore.QEvent.MouseButtonPress, position, Qt.LeftButton, Qt.LeftButton, Qt.NoModifier, ) HintedTextEdit.mousePressEvent(self, event) def create_context_menu(self, event_pos): popup_menu = super().create_context_menu(event_pos) # Check if the selected word is misspelled and offer spelling # suggestions if it is. spell_menu = None if self.textCursor().hasSelection(): text = self.textCursor().selectedText() if not self.spellcheck.check(text): title = N_('Spelling Suggestions') spell_menu = qtutils.create_menu(title, self) for word in self.spellcheck.suggest(text): action = SpellAction(word, spell_menu) action.result.connect(self.correct) spell_menu.addAction(action) # Only add the spelling suggests to the menu if there are # suggestions. if spell_menu.actions(): popup_menu.addSeparator() popup_menu.addMenu(spell_menu) return popup_menu def contextMenuEvent(self, event): """Select the current word and then show a context menu""" # Select the word under the cursor before calling the default contextMenuEvent. cursor = self.textCursor() cursor.select(QtGui.QTextCursor.WordUnderCursor) self.setTextCursor(cursor) super().contextMenuEvent(event) def correct(self, word): """Replaces the selected text with word.""" cursor = self.textCursor() cursor.beginEditBlock() cursor.removeSelectedText() cursor.insertText(word) cursor.endEditBlock() class SpellCheckLineEdit(SpellCheckTextEdit): """A fake QLineEdit that provides spellcheck capabilities This class emulates QLineEdit using our QPlainTextEdit base class so that we can leverage the existing spellcheck feature. """ down_pressed = QtCore.Signal() # This widget is a single-line QTextEdit as described in # http://blog.ssokolow.com/archives/2022/07/22/a-qlineedit-replacement-with-spell-checking/ def __init__(self, context, hint, check=None, parent=None): super().__init__(context, hint, check=check, parent=parent) self.setSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Fixed) self.setLineWrapMode(QtWidgets.QTextEdit.NoWrap) self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff) self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) self.setWordWrapMode(QtGui.QTextOption.NoWrap) self.setTabChangesFocus(True) self.textChanged.connect(self._trim_changed_text_lines) def focusInEvent(self, event): """Select text when entering with a tab to mimic QLineEdit""" super().focusInEvent(event) if event.reason() in ( Qt.BacktabFocusReason, Qt.ShortcutFocusReason, Qt.TabFocusReason, ): self.selectAll() def focusOutEvent(self, event): """De-select text when exiting with tab to mimic QLineEdit""" super().focusOutEvent(event) if event.reason() in ( Qt.BacktabFocusReason, Qt.MouseFocusReason, Qt.ShortcutFocusReason, Qt.TabFocusReason, ): cur = self.textCursor() cur.movePosition(QtGui.QTextCursor.End) self.setTextCursor(cur) def keyPressEvent(self, event): """Handle the up/down arrow keys""" event_key = event.key() if event_key == Qt.Key_Up: cursor = self.textCursor() if cursor.position() == 0: cursor.clearSelection() else: mode = event_anchor_mode(event) cursor.setPosition(0, mode) self.setTextCursor(cursor) return if event_key == Qt.Key_Down: cursor = self.textCursor() cur_position = cursor.position() end_position = len(self.value()) if cur_position == end_position: cursor.clearSelection() self.setTextCursor(cursor) self.down_pressed.emit() else: mode = event_anchor_mode(event) cursor.setPosition(end_position, mode) self.setTextCursor(cursor) return super().keyPressEvent(event) def minimumSizeHint(self): """Match QLineEdit's size behavior""" width = super().minimumSizeHint().width() height = self._get_preferred_height() style_opts = QtWidgets.QStyleOptionFrame() style_opts.initFrom(self) style_opts.lineWidth = self.frameWidth() return self.style().sizeFromContents( QtWidgets.QStyle.CT_LineEdit, style_opts, QtCore.QSize(width, height), self ) def sizeHint(self): """Use the minimum size as the sizeHint()""" return self.minimumSizeHint() def setFont(self, font): """Set the current font""" self.setMinimumHeight(self._get_preferred_height(font=font)) super().setFont(font) def _get_preferred_height(self, font=None): """Calculate the preferred height for this widget""" if font is None: font = self.font() block_fmt = self.document().firstBlock().blockFormat() height = int( QtGui.QFontMetricsF(font).lineSpacing() + block_fmt.topMargin() + block_fmt.bottomMargin() + 2 * self.document().documentMargin() + 2 * self.frameWidth() ) return height def _trim_changed_text_lines(self): """Trim the document to a single line to enforce a maximum of one line""" # self.setMaximumBlockCount(1) Undo/Redo. if self.document().blockCount() > 1: self.document().setPlainText(self.document().firstBlock().text()) class Highlighter(QtGui.QSyntaxHighlighter): WORDS = r"(?iu)[\w']+" def __init__(self, doc, spellcheck_widget): QtGui.QSyntaxHighlighter.__init__(self, doc) self.spellcheck = spellcheck_widget self.enabled = False def enable(self, enabled): self.enabled = enabled self.rehighlight() def highlightBlock(self, text): if not self.enabled: return fmt = QtGui.QTextCharFormat() fmt.setUnderlineColor(Qt.red) fmt.setUnderlineStyle(QtGui.QTextCharFormat.SpellCheckUnderline) for word_object in re.finditer(self.WORDS, text): if not self.spellcheck.check(word_object.group()): self.setFormat( word_object.start(), word_object.end() - word_object.start(), fmt ) class SpellAction(QtWidgets.QAction): """QAction that returns the text in a signal.""" result = QtCore.Signal(object) def __init__(self, *args): QtWidgets.QAction.__init__(self, *args) self.triggered.connect(self.correct) def correct(self): self.result.emit(self.text())