# -*- coding: utf-8 -*-
"""
Copyright (C) 2012 Oliver Tengler
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
"""
from typing import Tuple, Optional, Iterator
from enum import IntEnum
from PyQt5.QtCore import Qt, pyqtSignal, QRect, QRectF, pyqtSlot
from PyQt5.QtGui import QFont, QFontMetrics, QTextLayout, QPainter, QPaintEvent, QTextBlock, QResizeEvent, QTextCursor
from PyQt5.QtWidgets import QPlainTextEdit, QWidget
from .LineNumberArea import LineNumberArea
from .SyntaxHighlighter import SyntaxHighlighter
class HighlightStyle(IntEnum):
Outline = 1
Solid = 2
class HighlightingTextEdit (QPlainTextEdit):
updateNeeded = pyqtSignal()
parentheses = [('(',')'), ('[',']'), ('{', '}')]
highlightOutlineColor = Qt.darkGray
highlightSolidBackgroundColor = Qt.lightGray
highlightSolidForegroundColor = Qt.black
def __init__ (self, parent: QWidget) -> None:
super().__init__(parent)
self.highlighter = SyntaxHighlighter()
self.__highlightUpdateCounter = 0 # Increment every time the highlight changes
self.dynamicHighlight: Optional[str] = None
self.parenthesisPair: Optional[Tuple[int,int]] = None
self.highlightParenthesis = True
self.setUndoRedoEnabled(False)
self.setLineWrapMode(QPlainTextEdit.NoWrap)
self.setReadOnly(True)
self.setTextInteractionFlags(Qt.TextSelectableByKeyboard|Qt.TextSelectableByMouse)
self.lineNumberArea: Optional[LineNumberArea] = None
self.cursorPositionChanged.connect (self.cursorChanged)
self.selectionChanged.connect (self.onSelectionChanged)
@pyqtSlot()
def cursorChanged(self) -> None:
text = self.document().toPlainText()
pos = self.textCursor().position()
char = text[pos:pos+1]
paren = self.__isParenthesis(char)
if not paren and pos > 0:
pos -= 1
char = text[pos:pos+1]
paren = self.__isParenthesis(char)
if paren:
closePos = self.__findMatchingParenthesis(char, pos, paren)
if paren and closePos != -1:
self.setParenthesisPair((pos, closePos))
else:
self.setParenthesisPair(None)
@pyqtSlot()
def onSelectionChanged(self) -> None:
highlightParenthesis = not self.textCursor().selectedText()
if highlightParenthesis != self.highlightParenthesis:
self.highlightParenthesis = highlightParenthesis
self.viewport().update()
@pyqtSlot()
def jumpToMatchingBrace(self) -> None:
if self.parenthesisPair:
self.scrollToPosition(self.parenthesisPair[1], self.parenthesisPair[1] - self.parenthesisPair[0])
def scrollToPosition(self, index: int, scrollDir: int) -> None:
"""scrollHint is positive for scolling down and negative for scrolling up"""
cursor = self.textCursor()
cursor.setPosition(index)
if scrollDir > 0:
cursor.movePosition(QTextCursor.Down, QTextCursor.MoveAnchor, 5)
elif scrollDir < 0:
cursor.movePosition(QTextCursor.Up, QTextCursor.MoveAnchor, 5)
self.setTextCursor (cursor) # otherwise 'ensureCursorVisible' doesn't work
self.ensureCursorVisible ()
cursor.setPosition(index)
self.setTextCursor(cursor) # jump back to match to make sure the line number of the match is correct
def __findMatchingParenthesis(self, char: str, start: int, paren: Tuple[str, str]) -> int:
text = self.document().toPlainText()
openCount = 1
if char == paren[0]:
direction = 1
end = len(text)
start += 1
openChar, closeChar = paren[0],paren[1]
else:
direction = -1
start -= 1
end = -1
openChar, closeChar = paren[1],paren[0]
for i in range(start, end, direction):
char = text[i]
if char == openChar and not self.highlighter.isInsideComment(i):
openCount += 1
elif char == closeChar and not self.highlighter.isInsideComment(i):
openCount -= 1
if openCount == 0:
return i
return -1
def __isParenthesis(self, char: str) -> Optional[Tuple[str, str]]:
for p in self.parentheses:
if char in p:
return p
return None
def areLineNumbersShown(self) -> bool:
return bool(self.lineNumberArea)
def showLineNumbers(self, show: bool, firstLineNumber:int=1) -> None:
if show:
if not self.lineNumberArea:
self.lineNumberArea = LineNumberArea(self, firstLineNumber)
self.lineNumberArea.show()
else:
if self.lineNumberArea:
self.lineNumberArea.close()
self.lineNumberArea = None
def resizeEvent(self, e: QResizeEvent) -> None:
super().resizeEvent(e)
if self.lineNumberArea:
self.lineNumberArea.reactOnResize(e)
def setPlainText(self, text: str) -> None:
self.highlighter.setText(text)
super().setPlainText(text)
def setDynamicHighlight(self, text: str) -> None:
if self.dynamicHighlight != text:
self.dynamicHighlight = text
self.viewport().update()
def setParenthesisPair(self, pair: Optional[Tuple[int,int]]) -> None:
if not pair and not self.parenthesisPair:
return
self.parenthesisPair = pair
self.viewport().update()
def setFont(self, font: QFont) -> None:
super().setFont (font)
self.viewport().setFont(font)
self.highlighter.setFont(font)
def rehighlight(self) -> None:
"""
Evaluate syntax highlighting again
"""
self.__highlightUpdateCounter += 1 # causes all blocks to highlight again
self.viewport().update()
def paintEvent(self, event: QPaintEvent) -> None:
firstVisibleBlock: QTextBlock = self.firstVisibleBlock()
bColorizedBlocks = self.__colorizeVisibleBlocks(firstVisibleBlock)
super().paintEvent(event)
if not self.dynamicHighlight and not self.parenthesisPair:
return
painter = QPainter(self.viewport())
metrics = painter.fontMetrics()
for block, bound in self.__visibleBlocks(firstVisibleBlock):
bound = QRect(bound.left(), bound.top(), bound.width(), bound.height())
# Highlight all occurrences of selected word
if self.dynamicHighlight:
startIndex = 0
while startIndex != -1:
startIndex = block.text().find(self.dynamicHighlight, startIndex)
if startIndex != -1:
self.__highlightPartOfLine(painter, metrics, block, bound, startIndex, len(self.dynamicHighlight), HighlightStyle.Outline)
startIndex += len(self.dynamicHighlight)
# Highlight parenthesis pair
if self.highlightParenthesis and self.parenthesisPair:
p1, p2 = self.parenthesisPair
if block.position() <= p1 < block.position()+block.length():
self.__highlightPartOfLine(painter, metrics, block, bound, p1 - block.position(), 1, HighlightStyle.Solid)
if block.position() <= p2 < block.position()+block.length():
self.__highlightPartOfLine(painter, metrics, block, bound, p2 - block.position(), 1, HighlightStyle.Solid)
# Sometimes lines which are highlighted for the first time are not updated properly.
# This happens regularily if the text edit is scolled using the page down key.
# The following signal is emited if new lines were highlighted. The receiver
# is expected to call "update" on the control. Not nice but it works...
if bColorizedBlocks:
self.updateNeeded.emit()
def __highlightPartOfLine(self, painter: QPainter, metrics: QFontMetrics, block: QTextBlock, bound: QRect, startIndex: int, length: int, style: HighlightStyle) -> None:
text = block.text()[startIndex:startIndex+length]
partBefore = block.text()[:startIndex]
rectBefore = metrics.boundingRect(bound, Qt.TextExpandTabs, partBefore, self.tabStopWidth())
rectText = metrics.boundingRect(bound, Qt.TextExpandTabs, text, self.tabStopWidth())
if style == HighlightStyle.Outline:
rectResult = QRect(rectBefore.right()+4, rectBefore.top()+1, rectText.width()+2, rectText.height()-2)
painter.setPen(HighlightingTextEdit.highlightOutlineColor)
painter.drawRect(rectResult)
elif style == HighlightStyle.Solid:
rectResult = QRect(rectBefore.right()+4, rectBefore.top(), rectText.width()+2, rectText.height()+2)
painter.fillRect(rectResult, HighlightingTextEdit.highlightSolidBackgroundColor)
if HighlightingTextEdit.highlightSolidForegroundColor:
painter.setPen(HighlightingTextEdit.highlightSolidForegroundColor)
painter.drawText(QRectF(rectBefore.right()+5,rectBefore.top(),rectText.width(),rectText.height()), text)
def __colorizeVisibleBlocks(self, firstVisibleBlock: QTextBlock) -> bool:
bColorizedBlocks = False
for block, _ in self.__visibleBlocks(firstVisibleBlock):
# -1 means the block has not been highlighted yet
if block.userState() != self.__highlightUpdateCounter:
bColorizedBlocks = True
blockLength = len(block.text())
formats = self.highlighter.highlightBlock(block.position(), block.text())
addFormats = []
for (fmt, start, length) in formats:
formatRange = QTextLayout.FormatRange ()
formatRange.format = fmt
if start >= 0:
formatRange.start = start
else:
formatRange.start = 0
length += start
if formatRange.start + length > blockLength:
formatRange.length = blockLength - formatRange.start
else:
formatRange.length = length
if formatRange.length >= 0:
addFormats.append(formatRange)
block.layout().setAdditionalFormats(addFormats)
block.setUserState(self.__highlightUpdateCounter)
return bColorizedBlocks
def __visibleBlocks (self, firstVisibleBlock: QTextBlock) -> Iterator[Tuple[QTextBlock, QRectF]]:
size = self.viewport().size()
block = firstVisibleBlock
while block.isValid():
bound = self.blockBoundingGeometry(block).translated(self.contentOffset())
if bound.top() > size.height():
break
yield block, bound
block = block.next()
