def __init__(self, parent=None):
QSyntaxHighlighter.__init__(self, parent)
self.parent = parent
sqlKeyword = QTextCharFormat()
sqlOperator = QTextCharFormat()
self.highlightingRules = []
#Keywords
sqlKeyword.setFontWeight(QFont.Bold)
sqlKeyword.setForeground(Qt.blue)
sqlKeywords = ["AND", "OR", "LIKE"]
for word in sqlKeywords:
regExp = QRegExp("\\b" + word + "\\b", Qt.CaseInsensitive)
rule = HighlightingRule(regExp, sqlKeyword)
self.highlightingRules.append(rule)
#Comparison Operators
sqlOperator.setForeground(Qt.magenta)
sqlOperators = ["<", ">", "="]
for operator in sqlOperators:
regExp = QRegExp("\\W" + operator + "\\W", Qt.CaseInsensitive)
rule = HighlightingRule(regExp, sqlOperator)
self.highlightingRules.append(rule)
def finish_execution(self, exitCode, exitStatus):
"""Print a message and hide the input line when the execution ends."""
self.lblInput.hide()
self.input.hide()
format_ = QTextCharFormat()
format_.setAnchor(True)
font = settings.FONT
format_.setFont(font)
self.output.textCursor().insertText('\n\n')
if exitStatus == QProcess.NormalExit:
format_.setForeground(
QBrush(
QColor(
resources.CUSTOM_SCHEME.get(
"keyword", resources.COLOR_SCHEME["keyword"]))))
self.output.textCursor().insertText(
self.tr("Execution Successful!"), format_)
else:
format_.setForeground(
QBrush(
QColor(
resources.CUSTOM_SCHEME.get(
"error-underline",
resources.COLOR_SCHEME["error-underline"]))))
self.output.textCursor().insertText(
self.tr("Execution Interrupted"), format_)
self.output.textCursor().insertText('\n\n')
self.__post_execution()
def colorizeDiff(self, diffinfos):
cursor = self.textCursor()
cursor.setPosition(QTextCursor.Start)
text = self.toPlainText()
keys = diffinfos.keys()
keys.sort()
for offset in keys:
difflen = diffinfos[offset]
pos = offset + (offset / 16)
# count = offset / 16
# print "offset ", offset, " count ", count
count = difflen + (((offset + difflen) / 16) - (offset / 16))
# count = difflen
cursor.setPosition(pos, QTextCursor.MoveAnchor)
# print "L", l, " len ", pos + difflen
cursor.movePosition(QTextCursor.NextCharacter, QTextCursor.KeepAnchor, count)
format = QTextCharFormat()
format.setFont(self.sfont)
format.setForeground(QBrush(QColor(Qt.red)))
cursor.setCharFormat(format)
cursor.setPosition(QTextCursor.Start, QTextCursor.MoveAnchor)
def __init__(self, parent=None):
self.keywordFormat = QTextCharFormat()
self.keywordFormat.setForeground(QBrush(Qt.blue))
self.keywordFormat.setFontWeight(QFont.Bold)
self.stringFormat = QTextCharFormat()
self.stringFormat.setForeground(QBrush(Qt.darkGreen))
self.defFormat = QTextCharFormat()
self.defFormat.setForeground(QBrush(Qt.black))
self.defFormat.setFontWeight(QFont.Bold)
self.commentFormat = QTextCharFormat()
self.commentFormat.setForeground(QBrush(Qt.lightGray))
self.decoratorFormat = QTextCharFormat()
self.decoratorFormat.setForeground(QBrush(Qt.darkGray))
self.keywords = list(keyword.kwlist)
self.rules = [(QRegExp(r"\b%s\b" % kwd), self.keywordFormat)
for kwd in self.keywords] + \
[(QRegExp(r"\bdef\s+([A-Za-z_]+[A-Za-z0-9_]+)\s*\("),
self.defFormat),
(QRegExp(r"\bclass\s+([A-Za-z_]+[A-Za-z0-9_]+)\s*\("),
self.defFormat),
(QRegExp(r"'.*'"), self.stringFormat),
(QRegExp(r'".*"'), self.stringFormat),
(QRegExp(r"#.*"), self.commentFormat),
(QRegExp(r"@[A-Za-z_]+[A-Za-z0-9_]+"),
self.decoratorFormat)]
self.multilineStart = QRegExp(r"(''')|" + r'(""")')
self.multilineEnd = QRegExp(r"(''')|" + r'(""")')
QSyntaxHighlighter.__init__(self, parent)
def __init__(self, document):
QSyntaxHighlighter.__init__(self, document)
self.clb = ConfigurationLineBuilder(ErtKeywords())
self.comment_format = QTextCharFormat()
self.comment_format.setForeground(QColor(0, 128, 0))
self.comment_format.setFontItalic(True)
self.keyword_format = QTextCharFormat()
self.keyword_format.setForeground(QColor(200, 100, 0))
# self.keyword_format.setFontWeight(QFont.Bold)
self.error_format = QTextCharFormat()
# self.error_format.setForeground(QColor(255, 0, 0))
self.error_format.setUnderlineStyle(QTextCharFormat.WaveUnderline)
self.error_format.setUnderlineColor(QColor(255, 0, 0))
self.search_format = QTextCharFormat()
self.search_format.setBackground(QColor(220, 220, 220))
self.builtin_format = QTextCharFormat()
self.builtin_format.setForeground(QColor(0, 170, 227))
self.search_string = ""
def update_char_format(baseformat,
color=None,
background=None,
weight=None,
italic=None,
underline=None,
font=None):
"""
Return a copy of `baseformat` :class:`QTextCharFormat` with
updated color, weight, background and font properties.
"""
charformat = QTextCharFormat(baseformat)
if color is not None:
charformat.setForeground(color)
if background is not None:
charformat.setBackground(background)
if font is not None:
charformat.setFont(font)
else:
font = update_font(baseformat.font(), weight, italic, underline)
charformat.setFont(font)
return charformat
def __init__(self, parent=None):
super(DiffsMenu, self).__init__(parent)
self.ui = Ui_Diffs()
self.ui.setupUi(self)
self.ui.actionCopyPath = QtGui.QAction("Copy path",
None,
triggered=self.copyPath)
self.ui.treeResults.addAction(self.ui.actionCopyPath)
self.folder1 = None
self.folder2 = None
self.files = None
self.files_nodupes = None
self.files_missing = None
self.saved_diffs = {}
self.format1 = QTextCharFormat()
self.format1.setBackground(QColor(255, 224, 224))
self.format2 = QTextCharFormat()
self.format2.setBackground(QColor(224, 240, 255))
self.menu_name = "Diffs"
self.format_plain = QTextCharFormat()
def setDateBackground(self, color):
brush = QBrush(color)
frmt = QTextCharFormat()
frmt.setBackground(brush)
return frmt
def __init__(self, parent=None):
super(ReferenceHighlighter, self).__init__(parent)
self.format = QTextCharFormat()
self.format.setForeground(QColor(0, 0, 255))
self.references = []
def __init__(self, document):
QSyntaxHighlighter.__init__(self, document)
self.clb = ConfigurationLineBuilder(ErtKeywords())
self.comment_format = QTextCharFormat()
self.comment_format.setForeground(QColor(0, 128, 0))
self.comment_format.setFontItalic(True)
self.keyword_format = QTextCharFormat()
self.keyword_format.setForeground(QColor(200, 100, 0))
# self.keyword_format.setFontWeight(QFont.Bold)
self.error_format = QTextCharFormat()
# self.error_format.setForeground(QColor(255, 0, 0))
self.error_format.setUnderlineStyle(QTextCharFormat.WaveUnderline)
self.error_format.setUnderlineColor(QColor(255, 0, 0))
self.search_format = QTextCharFormat()
self.search_format.setBackground(QColor(220, 220, 220))
self.builtin_format = QTextCharFormat()
self.builtin_format.setForeground(QColor(0, 170, 227))
self.search_string = ""
def __init__(self, parent):
QPlainTextEdit.__init__(self, parent)
self._parent = parent
self.setReadOnly(True)
self.maxValue = 0
self.actualValue = 0
#traceback pattern
self.patLink = re.compile(r'(\s)*File "(.*?)", line \d.+')
#formats
self.plain_format = QTextCharFormat()
self.plain_format.setForeground(QBrush(QColor(
resources.CUSTOM_SCHEME.get("editor-text",
resources.COLOR_SCHEME["editor-text"]))))
self.error_format = QTextCharFormat()
self.error_format.setAnchor(True)
self.error_format.setFontUnderline(True)
self.error_format.setUnderlineStyle(QTextCharFormat.SingleUnderline)
self.error_format.setUnderlineColor(Qt.red)
self.error_format.setForeground(Qt.blue)
self.error_format.setToolTip(self.tr("Click to show the source"))
self.connect(self, SIGNAL("blockCountChanged(int)"), self._scroll_area)
css = 'QPlainTextEdit {color: %s; background-color: %s;' \
'selection-color: %s; selection-background-color: %s;}' \
% (resources.CUSTOM_SCHEME.get('editor-text',
resources.COLOR_SCHEME['editor-text']),
resources.CUSTOM_SCHEME.get('editor-background',
resources.COLOR_SCHEME['editor-background']),
resources.CUSTOM_SCHEME.get('editor-selection-color',
resources.COLOR_SCHEME['editor-selection-color']),
resources.CUSTOM_SCHEME.get('editor-selection-background',
resources.COLOR_SCHEME['editor-selection-background']))
self.setStyleSheet(css)
def __init__(self, parent = None):
super(DiffsMenu, self).__init__(parent)
self.ui = Ui_Diffs()
self.ui.setupUi(self)
self.ui.actionCopyPath = QtGui.QAction("Copy path", None, triggered = self.copyPath)
self.ui.treeResults.addAction(self.ui.actionCopyPath)
self.folder1 = None
self.folder2 = None
self.files = None
self.files_nodupes = None
self.files_missing = None
self.saved_diffs = {}
self.format1 = QTextCharFormat()
self.format1.setBackground(QColor(255, 224, 224))
self.format2 = QTextCharFormat()
self.format2.setBackground(QColor(224, 240, 255))
self.menu_name = "Diffs"
self.format_plain = QTextCharFormat()
def setDateBackground(self, color):
brush = QBrush(color)
frmt = QTextCharFormat()
frmt.setBackground(brush)
return frmt
def __post_execution_message(self):
"""Print post execution message."""
self.output.textCursor().insertText("\n\n")
format = QTextCharFormat()
format.setAnchor(True)
format.setForeground(Qt.green)
self.output.textCursor().insertText(self.tr("Post Execution Script Successfully executed."), format)
def __init__(self, parent=None):
self.keywordFormat = QTextCharFormat()
self.keywordFormat.setForeground(QBrush(Qt.blue))
self.keywordFormat.setFontWeight(QFont.Bold)
self.stringFormat = QTextCharFormat()
self.stringFormat.setForeground(QBrush(Qt.darkGreen))
self.defFormat = QTextCharFormat()
self.defFormat.setForeground(QBrush(Qt.black))
self.defFormat.setFontWeight(QFont.Bold)
self.commentFormat = QTextCharFormat()
self.commentFormat.setForeground(QBrush(Qt.lightGray))
self.decoratorFormat = QTextCharFormat()
self.decoratorFormat.setForeground(QBrush(Qt.darkGray))
self.keywords = list(keyword.kwlist)
self.rules = [(QRegExp(r"\b%s\b" % kwd), self.keywordFormat)
for kwd in self.keywords] + \
[(QRegExp(r"\bdef\s+([A-Za-z_]+[A-Za-z0-9_]+)\s*\("),
self.defFormat),
(QRegExp(r"\bclass\s+([A-Za-z_]+[A-Za-z0-9_]+)\s*\("),
self.defFormat),
(QRegExp(r"'.*'"), self.stringFormat),
(QRegExp(r'".*"'), self.stringFormat),
(QRegExp(r"#.*"), self.commentFormat),
(QRegExp(r"@[A-Za-z_]+[A-Za-z0-9_]+"),
self.decoratorFormat)]
self.multilineStart = QRegExp(r"(''')|" + r'(""")')
self.multilineEnd = QRegExp(r"(''')|" + r'(""")')
QSyntaxHighlighter.__init__(self, parent)
def _insert_metadata_info(self):
#Insert version and build numbers respectively.
if not self._metadata is None:
installed_version = self._metadata.get('version_installed', None)
else:
installed_version = version_from_metadata()
if installed_version is None:
return
cursor = self.txtAbout.textCursor()
cursor.movePosition(QTextCursor.End)
cursor.insertBlock()
cursor.insertBlock()
#Insert installed version text
version_msg = QApplication.translate(
'AboutSTDMDialog',
'STDM version'
)
version_text = u'{0} {1}'.format(version_msg, installed_version)
char_format = cursor.blockCharFormat()
text_format = QTextCharFormat(char_format)
text_format.setFontWeight(75)
cursor.insertText(version_text, text_format)
class ViewHighlighter(widgets.arbitraryhighlighter.ArbitraryHighlighter, plugin.Plugin):
def __init__(self, view):
super(ViewHighlighter, self).__init__(view)
self._cursorFormat = QTextCharFormat()
self._cursorFormat.setProperty(QTextFormat.FullWidthSelection, True)
app.settingsChanged.connect(self.readSettings)
self.readSettings()
bookmarks.bookmarks(view.document()).marksChanged.connect(self.updateMarkedLines)
self.updateMarkedLines()
view.cursorPositionChanged.connect(self.updateCursor)
view.installEventFilter(self)
def updateMarkedLines(self):
"""Called when something changes in the bookmarks."""
for type, marks in bookmarks.bookmarks(self.parent().document()).marks().items():
self.highlight(type, marks, -1)
def eventFilter(self, view, ev):
if ev.type() in (QEvent.FocusIn, QEvent.FocusOut):
self.updateCursor(view)
return False
def updateCursor(self, view=None):
"""Called when the textCursor has moved. Highlights the current line.
If view is None (the default), our parent() is assumed to be the
view. The eventFilter() method calls us with the view, this is
done because the event filter is sometimes called very late in
the destructor phase, when our parent is possibly not valid
anymore.
"""
if view is None:
view = self.parent()
# highlight current line
color = QColor(self._baseColors['current'])
color.setAlpha(200 if view.hasFocus() else 100)
self._cursorFormat.setBackground(color)
cursor = view.textCursor()
cursor.clearSelection()
self.highlight(self._cursorFormat, [cursor], 0)
def readSettings(self):
data = textformats.formatData('editor')
self._baseColors = data.baseColors
self.updateCursor()
self.reload()
def textFormat(self, name):
"""(Internal) Returns a QTextCharFormat setup according to the preferences.
For bookmarks and the current line, FullWidthSelection is automatically enabled.
"""
f = QTextCharFormat()
f.setBackground(self._baseColors[name])
if name in ('current', 'mark', 'error'):
f.setProperty(QTextFormat.FullWidthSelection, True)
return f
def write_info(self, text):
old_format = self.currentCharFormat();
format = QTextCharFormat()
format.setForeground(QColor("white"))
format.setBackground(QColor("darkgreen"))
self.setCurrentCharFormat(format);
self.appendPlainText("Done.\n");
self.setCurrentCharFormat(old_format);
def setBold(self):
format = QTextCharFormat()
if self.boldAct.isChecked():
weight = QFont.Bold
else:
weight = QFont.Normal
format.setFontWeight(weight)
self.setFormat(format)
def setBold(self):
format = QTextCharFormat()
if self.boldAct.isChecked():
weight = QFont.Bold
else:
weight = QFont.Normal
format.setFontWeight(weight)
self.setFormat(format)
def load(self, scheme):
"""Load the settings for the scheme. Called on init."""
s = QSettings()
s.beginGroup("fontscolors/" + scheme)
# load font
defaultfont = "Lucida Console" if os.name == "nt" else "monospace"
self.font = QFont(s.value("fontfamily", defaultfont, type("")))
self.font.setPointSizeF(s.value("fontsize", 10.0, float))
# load base colors
s.beginGroup("basecolors")
for name in baseColors:
if s.contains(name):
self.baseColors[name] = QColor(s.value(name, "", type("")))
else:
self.baseColors[name] = baseColorDefaults[name]()
s.endGroup()
# get the list of supported styles from ly.colorize
all_styles = ly.colorize.default_mapping()
default_styles = set()
for group, styles in all_styles:
d = self._inherits[group] = {}
for style in styles:
if style.base:
default_styles.add(style.base)
d[style.name] = style.base
default_scheme = ly.colorize.default_scheme
# load default styles
s.beginGroup("defaultstyles")
for name in default_styles:
self.defaultStyles[name] = f = QTextCharFormat()
css = default_scheme[None].get(name)
if css:
css2fmt(css, f)
s.beginGroup(name)
self.loadTextFormat(f, s)
s.endGroup()
s.endGroup()
# load specific styles
s.beginGroup("allstyles")
for group, styles in all_styles:
self.allStyles[group]= {}
s.beginGroup(group)
for style in styles:
self.allStyles[group][style.name] = f = QTextCharFormat()
css = default_scheme[group].get(style.name)
if css:
css2fmt(css, f)
s.beginGroup(style.name)
self.loadTextFormat(f, s)
s.endGroup()
s.endGroup()
s.endGroup()
def format(color, style=''):
"""Return a QTextCharFormat with the given attributes.
"""
c = QColor(color)
#c.setNamedColor(color)
f = QTextCharFormat()
f.setForeground(c)
return f
class Matcher(widgets.matcher.Matcher):
def __init__(self, edit):
super(Matcher, self).__init__(edit)
self.readSettings()
app.settingsChanged.connect(self.readSettings)
def readSettings(self):
self.format = QTextCharFormat()
self.format.setBackground(textformats.formatData('editor').baseColors['match'])
def _insertAnchors(self, cursor, plainText, matcher, hrefFunc):
for start, end, matcher in self._iterMatchedRanges(matcher, plainText):
cursor.setPosition(start);
cursor.setPosition(end, QTextCursor.KeepAnchor)
fmt = QTextCharFormat()
fmt.setAnchor(True)
fmt.setAnchorHref(hrefFunc(matcher.cap()))
cursor.mergeCharFormat(fmt)
def getFormat(self, format):
color = QColor()
color.setRed(self.formats[format]['color'][0])
color.setGreen(self.formats[format]['color'][1])
color.setBlue(self.formats[format]['color'][2])
format = QTextCharFormat()
format.setForeground(color)
return format
def set_font(self, font):
"""Set shell styles font"""
self.set_pythonshell_font(font)
cursor = self.textCursor()
cursor.select(QTextCursor.Document)
charformat = QTextCharFormat()
charformat.setFontFamily(font.family())
charformat.setFontPointSize(font.pointSize())
cursor.mergeCharFormat(charformat)
def format(color, style=''):
"""Return a QTextCharFormat with the given attributes.
"""
c = QColor(color)
#c.setNamedColor(color)
f = QTextCharFormat()
f.setForeground(c)
return f
def format(color):
#Return a QTextCharFormat with the given attributes.
_color = QColor()
_color.setNamedColor(color)
_format = QTextCharFormat()
_format.setForeground(_color)
return _format
def set_char_format(self, format, start, end):
oldcur = self.textCursor()
cur = QtGui.QTextEdit.textCursor(self)
cur.setPosition(start)
cur.setPosition(end, QtGui.QTextCursor.KeepAnchor)
cur.setCharFormat(format)
fmt2 = QTextCharFormat()
fmt2.setUnderlineStyle(QTextCharFormat.NoUnderline)
oldcur.setCharFormat(fmt2)
self.setTextCursor(oldcur)
def clear_markers(self):
cursor = self.ui.plainTextEditCode.textCursor()
cursor.setPosition(0, QTextCursor.MoveAnchor)
cursor.movePosition(QTextCursor.End, QTextCursor.KeepAnchor)
format = QTextCharFormat()
color = QColor()
color.setAlpha(0) #nice trick to get the original background color back
brush = QBrush(color)
format.setBackground(brush)
cursor.mergeCharFormat(format)
def __init__(self, parent=None):
super(SpellCheckHighlighter, self).__init__(parent)
self.set_language("en_US")
self.format = QTextCharFormat()
self.format.setUnderlineColor(QColor(255, 0, 0))
self.format.setUnderlineStyle(QTextCharFormat.SpellCheckUnderline)
self.errors = []
def imagiformat(color, style=''):
_color = QColor()
_color.setNamedColor(color)
_format = QTextCharFormat()
_format.setForeground(_color)
if 'bold' in style:
_format.setFontWeight(QFont.Bold)
return _format
def __init__(self, widget):
QSyntaxHighlighter.__init__(self, widget)
self.regex = None
# create format type
self.odd_format = QTextCharFormat()
self.odd_format.setFontWeight(QFont.Bold)
self.odd_format.setForeground(Qt.darkBlue)
self.even_format = QTextCharFormat()
self.even_format.setFontWeight(QFont.Bold)
self.even_format.setForeground(Qt.darkMagenta)
class Matcher(widgets.matcher.Matcher):
def __init__(self, edit):
super(Matcher, self).__init__(edit)
self.readSettings()
app.settingsChanged.connect(self.readSettings)
def readSettings(self):
self.format = QTextCharFormat()
self.format.setBackground(
textformats.formatData('editor').baseColors['match'])
def __init__(self, parent=None):
super(KeywordHighlighter, self).__init__(parent)
self.format = QTextCharFormat()
self.format.setForeground(QColor(255, 0, 0))
self.keywords = []
self.matches = []
self.re_flags = re.IGNORECASE | re.UNICODE
def toggleBold(self):
#self.setFontWeight(QFont.Normal if self.fontWeight() > QFont.Normal else QFont.Bold)
if self.which_header():
return
bold = self.fontWeight() > QFont.Normal
cursor = self.textCursor()
char_format = QTextCharFormat()
char_format.setFont(self.font)
char_format.setFontWeight(QFont.Normal if bold else QFont.Bold)
cursor.setCharFormat(char_format)
def toggleItalic(self):
if self.which_header():
return
#self.setFontItalic(not self.fontItalic())
italic = self.fontItalic()
cursor = self.textCursor()
char_format = QTextCharFormat()
char_format.setFont(self.font)
char_format.setFontItalic(not italic)
cursor.setCharFormat(char_format)
def __init__(self, parent = None, theme = None, prefix = ''):
QSyntaxHighlighter.__init__(self, parent)
self.rules = []
self.prefix = prefix
kwFormat = QTextCharFormat()
kwFormat.setForeground( Qt.blue )
#kwFormat.setFontWeight( QFont.Bold )
quoteFormat = QTextCharFormat()
quoteFormat.setForeground( Qt.red )
commentFormat = QTextCharFormat()
commentFormat.setForeground( Qt.darkGray )
keywords = ["and", "del", "for", "is", "raise",
"assert", "elif", "from", "lambda",
"break", "else", "global", "not", "try",
"class", "except", "if", "or", "while",
"continue", "exec", "import", "pass", "yield",
"def", "finally", "in", "print", "self"
]
for kw in keywords:
self.rules.append( (QRegExp("\\b" + kw + "\\b"), kwFormat) )
self.rules.append( (QRegExp(r'"(?:[^"\\]|\\.)*"'), quoteFormat) )
self.rules.append( (QRegExp(r"'(?:[^\']+|\.)*'"), quoteFormat) )
self.rules.append( (QRegExp(r"#.*$"), commentFormat) )
class ConsoleFontStyle(object):
def __init__(self, foregroundcolor, backgroundcolor, bold, italic,
underline):
self.foregroundcolor = foregroundcolor
self.backgroundcolor = backgroundcolor
self.bold = bold
self.italic = italic
self.underline = underline
self.format = None
def apply_style(self, font, light_background, is_default):
self.format = QTextCharFormat()
self.format.setFont(font)
foreground = QColor(self.foregroundcolor)
if not light_background and is_default:
inverse_color(foreground)
self.format.setForeground(foreground)
background = QColor(self.backgroundcolor)
if not light_background:
inverse_color(background)
self.format.setBackground(background)
font = self.format.font()
font.setBold(self.bold)
font.setItalic(self.italic)
font.setUnderline(self.underline)
self.format.setFont(font)
def updateFonts(self, font):
self.base_format.setFont(font)
self.empty_format = QTextCharFormat(self.base_format)
#self.empty_format.setFontPointSize(font.pointSize()/4.0)
self.keywordFormat = QTextCharFormat(self.base_format)
self.keywordFormat.setForeground(QColor(scheme.syntax_keyword))
self.keywordFormat.setFontWeight(QFont.Bold)
self.builtinFormat = QTextCharFormat(self.base_format)
self.builtinFormat.setForeground(QColor(scheme.syntax_builtin))
self.magicFormat = QTextCharFormat(self.base_format)
self.magicFormat.setForeground(QColor(scheme.syntax_magic))
#self.qtFormat = QTextCharFormat(self.base_format)
#self.qtFormat.setForeground(QColor(scheme.syntax_qt))
##self.qtFormat.setFontWeight(QFont.Bold)
self.selfFormat = QTextCharFormat(self.base_format)
self.selfFormat.setForeground(QColor(scheme.syntax_self))
#self.selfFormat.setFontItalic(True)
self.singleLineCommentFormat = QTextCharFormat(self.base_format)
self.singleLineCommentFormat.setForeground(QColor(scheme.syntax_comment))
self.singleLineCommentFormat.setFontItalic(True)
self.multiLineStringFormat = QTextCharFormat(self.base_format)
self.multiLineStringFormat.setForeground(QColor(scheme.syntax_string))
#self.multiLineStringFormat.setBackground(QBrush(Qt.green))
self.quotationFormat1 = QTextCharFormat(self.base_format)
self.quotationFormat1.setForeground(QColor(scheme.syntax_string))
self.quotationFormat2 = QTextCharFormat(self.base_format)
self.quotationFormat2.setForeground(QColor(scheme.syntax_string))
self.numFormat = QTextCharFormat(self.base_format)
self.numFormat.setForeground(QColor(scheme.syntax_number))
class ConsoleFontStyle(object):
def __init__(self, foregroundcolor, backgroundcolor,
bold, italic, underline):
self.foregroundcolor = foregroundcolor
self.backgroundcolor = backgroundcolor
self.bold = bold
self.italic = italic
self.underline = underline
self.format = None
def apply_style(self, font, light_background, is_default):
self.format = QTextCharFormat()
self.format.setFont(font)
foreground = QColor(self.foregroundcolor)
if not light_background and is_default:
inverse_color(foreground)
self.format.setForeground(foreground)
background = QColor(self.backgroundcolor)
if not light_background:
inverse_color(background)
self.format.setBackground(background)
font = self.format.font()
font.setBold(self.bold)
font.setItalic(self.italic)
font.setUnderline(self.underline)
self.format.setFont(font)
def textFormat(self, name):
"""(Internal) Returns a QTextCharFormat setup according to the preferences.
For bookmarks and the current line, FullWidthSelection is automatically enabled.
"""
f = QTextCharFormat()
f.setBackground(self._baseColors[name])
if name in ('current', 'mark', 'error'):
f.setProperty(QTextFormat.FullWidthSelection, True)
return f
def __init__(self, edit):
self.textedit = edit
document = edit.document()
QSyntaxHighlighter.__init__(self, document)
base_format = QTextCharFormat()
base_format.setFont(edit.font())
self.base_format = base_format
self.document = document
self.updateHighlighter(base_format.font())
def make_plain_text(self):
cursor = self.textCursor()
char_format = QTextCharFormat()
char_format.setFont(self.font)
cursor.setCharFormat(char_format)
block_format = QTextBlockFormat()
block_format.setNonBreakableLines(False)
cursor.setBlockFormat(block_format)
def __init__(self, view):
super(ViewHighlighter, self).__init__(view)
self._cursorFormat = QTextCharFormat()
self._cursorFormat.setProperty(QTextFormat.FullWidthSelection, True)
app.settingsChanged.connect(self.readSettings)
self.readSettings()
bookmarks.bookmarks(view.document()).marksChanged.connect(
self.updateMarkedLines)
self.updateMarkedLines()
view.cursorPositionChanged.connect(self.updateCursor)
view.installEventFilter(self)
def formatKeyword(self, keyword, validation_status):
assert isinstance(keyword, Keyword)
if keyword.hasKeywordDefinition():
keyword_format = QTextCharFormat(self.keyword_format)
if not validation_status:
keyword_format.merge(self.error_format)
self.formatToken(keyword, keyword_format)
else:
self.formatToken(keyword, self.error_format)
def make_plain_text(self):
cursor = self.textCursor()
char_format = QTextCharFormat()
char_format.setFont(self.font)
cursor.setCharFormat(char_format)
block_format = QTextBlockFormat()
block_format.setNonBreakableLines(False)
cursor.setBlockFormat(block_format)
def formatKeyword(self, keyword, validation_status):
assert isinstance(keyword, Keyword)
if keyword.hasKeywordDefinition():
keyword_format = QTextCharFormat(self.keyword_format)
if not validation_status:
keyword_format.merge(self.error_format)
self.formatToken(keyword, keyword_format)
else:
self.formatToken(keyword, self.error_format)
def __init__(self, edit):
self.textedit = edit
document = edit.document()
QSyntaxHighlighter.__init__(self, document)
base_format = QTextCharFormat()
base_format.setFont(edit.font())
self.base_format = base_format
self.document = document
self.updateHighlighter(base_format.font())
def setup_formats(self, font=None):
base_format = QTextCharFormat()
if font is not None:
base_format.setFont(font)
self.formats = {}
for name, color, bold, italic in self.COLORS[self.color_scheme]:
format = QTextCharFormat(base_format)
format.setForeground(QColor(color))
if bold:
format.setFontWeight(QFont.Bold)
format.setFontItalic(italic)
self.formats[name] = format
def process_error(self, error):
"""Listen to the error signals from the running process."""
self.lblInput.hide()
self.input.hide()
self._proc.kill()
format = QTextCharFormat()
format.setAnchor(True)
format.setForeground(Qt.red)
if error == 0:
self.output.textCursor().insertText(self.tr("Failed to start"), format)
else:
self.output.textCursor().insertText(self.tr("Error during execution, QProcess error: %d" % error), format)
def highlight_marker(self, marker_meta_data, color=None):
'''
highlights text according to the marker and the color in the current file
use metadata.color_name if color is None
'''
cursor = self.ui.plainTextEditCode.textCursor()
cursor.setPosition(marker_meta_data.start_pos)
cursor.setPosition(marker_meta_data.end_pos, QTextCursor.KeepAnchor)
format = QTextCharFormat()
if color is None:
color = QColor(marker_meta_data.color_name)
brush = QBrush(color)
format.setBackground(brush)
cursor.mergeCharFormat(format)
def make_heading(self, heading):
# not finished
cursor = self.textCursor()
cursor.select(QTextCursor.BlockUnderCursor) #QTextCursor.LineUnderCursor
char_format = QTextCharFormat()
#font = self.font this is a problem because it changes self.font gets changed below
font = QFont()
font.setFamily("helvetica")
font.setPointSize({1:20, 2:15, 3:12}[heading])
font.setBold(True)
char_format.setFont(font)
cursor.setCharFormat(char_format)
class SpellCheckHighlighter(QtGui.QSyntaxHighlighter):
def __init__(self, parent=None):
super(SpellCheckHighlighter, self).__init__(parent)
self.set_language("en_US")
self.format = QTextCharFormat()
self.format.setUnderlineColor(QColor(255, 0, 0))
self.format.setUnderlineStyle(QTextCharFormat.SpellCheckUnderline)
self.errors = []
def set_language(self, lang):
dict = enchant.DictWithPWL(lang, "data/dict/enchant.txt")
self.checker = SpellChecker(dict, chunkers=(HTMLChunker, ))
def get_language(self):
return self.checker.dict.tag
def highlightBlock(self, text):
# If there is no previous state, then it's -1, which makes the first line 0.
# And every line after that increases as expected.
line = self.previousBlockState() + 1
self.setCurrentBlockState(line)
# Make sure our error list is long enough to hold this line.
for i in range(len(self.errors), line + 1):
self.errors.append([])
text = common.qt_to_unicode(text)
text = RE_ANGLED_APOST.sub("'", text)
self.errors[line] = []
self.checker.set_text(text)
for err in self.checker:
self.setFormat(err.wordpos, len(err.word), self.format)
self.errors[line].append((err.word, err.wordpos))
def add(self, word):
self.checker.add(word)
self.rehighlight()
def ignore(self, word):
self.checker.ignore_always(word)
self.rehighlight()
### EOF ###
def __init__(self, text_edit, level_file):
super().__init__(text_edit)
text = level_file.read()
text = SuperTuxLispHighlighter.clean_text(text)
text_edit.setText(text)
self.highlighting_rules += SuperTuxHighlighter.load_patterns(
"highlighters/patterns.json")
string_format = QTextCharFormat()
string_format.setForeground(Qt.darkRed)
string_pattern = '"'
self.string = HighlightingRule(string_pattern, string_format, "string")
def __init__(self, parent=None):
global reWord
super(wordHighLighter, self).__init__(parent)
# store a local reference to the global regex
self.wordMatch = reWord
# Initialize text formats to apply to words from various lists.
# - Scanno candidates get a light lilac background.
self.scannoFormat = QTextCharFormat()
self.scannoFormat.setBackground(QBrush(QColor("#EBD7E6")))
# Set the style for misspelt words. We underline in red using the
# well-known wavy red underline, the same on all platforms.
self.misspeltFormat = QTextCharFormat()
self.misspeltFormat.setUnderlineStyle(QTextCharFormat.WaveUnderline)
self.misspeltFormat.setUnderlineColor(QColor("red"))
def format(color, style=''):
"""Return a QTextCharFormat with the given attributes."""
_color = QColor()
_color.setNamedColor(color)
_format = QTextCharFormat()
_format.setFontFamily(settings.FONT)
_format.setForeground(_color)
if 'bold' in style:
_format.setFontWeight(QFont.Bold)
if 'italic' in style:
_format.setFontItalic(True)
return _format
def __init__(self, dockwidget):
"""Creates the Music View for the dockwidget."""
super(MusicView, self).__init__(dockwidget)
self._positions = weakref.WeakKeyDictionary()
self._currentDocument = None
self._links = None
self._clicking_link = False
self._highlightFormat = QTextCharFormat()
self._highlightMusicFormat = Highlighter()
self._highlightRange = None
self._highlightTimer = QTimer(singleShot=True,
interval=250,
timeout=self.updateHighlighting)
self._highlightRemoveTimer = QTimer(singleShot=True,
timeout=self.clearHighlighting)
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
self.view = popplerview.View(self)
self.view.MAX_ZOOM = 8.0
layout.addWidget(self.view)
app.settingsChanged.connect(self.readSettings)
self.readSettings()
self.view.setViewMode(qpopplerview.FitWidth)
self.view.surface().setPageLayout(qpopplerview.RowLayout())
self.view.surface().linkClicked.connect(self.slotLinkClicked)
self.view.surface().linkHovered.connect(self.slotLinkHovered)
self.view.surface().linkLeft.connect(self.slotLinkLeft)
self.view.surface().setShowUrlTips(False)
self.view.surface().linkHelpRequested.connect(
self.slotLinkHelpRequested)
self.view.viewModeChanged.connect(self.updateZoomInfo)
self.view.surface().pageLayout().scaleChanged.connect(
self.updateZoomInfo)
self.view.setContextMenuPolicy(Qt.CustomContextMenu)
self.view.customContextMenuRequested.connect(self.showContextMenu)
# react if cursor of current text document moves
dockwidget.mainwindow().currentViewChanged.connect(
self.slotCurrentViewChanged)
view = dockwidget.mainwindow().currentView()
if view:
self.slotCurrentViewChanged(view)
class ReferenceHighlighter(QtGui.QSyntaxHighlighter):
### SIGNALS ###
refs_edited = pyqtSignal()
def __init__(self, parent=None):
super(ReferenceHighlighter, self).__init__(parent)
self.format = QTextCharFormat()
self.format.setForeground(QColor(0, 0, 255))
self.references = []
def highlightBlock(self, text):
# If there is no previous state, then it's -1, which makes the first line 0.
# And every line after that increases as expected.
line = self.previousBlockState() + 1
self.setCurrentBlockState(line)
old_refs = copy.deepcopy(self.references)
# Make sure we aren't too long.
if len(self.references) > self.parent().blockCount():
self.references = self.references[:self.parent().blockCount()]
# Make sure our matches list is long enough to hold this line.
for i in range(len(self.references), line + 1):
self.references.append([])
if len(self.references) == 0:
return
self.references[line] = []
text = common.qt_to_unicode(text).lower()
matches = RE_REFERENCE.finditer(text)
for match in matches:
self.setFormat(match.start(),
match.end() - match.start(), self.format)
self.references[line].append((match.group(1), match.start() + 1))
if not old_refs == self.references:
self.refs_edited.emit()
### EOF ###
def apply_style(self, font, light_background, is_default):
self.format = QTextCharFormat()
self.format.setFont(font)
foreground = QColor(self.foregroundcolor)
if not light_background and is_default:
inverse_color(foreground)
self.format.setForeground(foreground)
background = QColor(self.backgroundcolor)
if not light_background:
inverse_color(background)
self.format.setBackground(background)
font = self.format.font()
font.setBold(self.bold)
font.setItalic(self.italic)
font.setUnderline(self.underline)
self.format.setFont(font)
