pyqttoolkit 0.9.1__py3-none-any.whl

pyqttoolkit/views/bulk_value_selector.py

@@ -0,0 +1,112 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+import weakref
+from PyQt5.QtCore import pyqtSignal, QItemSelectionModel, QAbstractItemModel, QStringListModel, Qt
+from PyQt5.QtWidgets import QWidget, QGridLayout
+
+from pyqttoolkit.properties import auto_property
+from pyqttoolkit.models.roles import DataRole
+from .list_view import ListView
+
+class BulkValueSelectorWidget(QWidget):
+    def __init__(self, parent):
+        QWidget.__init__(self, parent)
+        self._value_selector = ListView(self)
+        self._value_selector.setSelectionMode(ListView.ExtendedSelection)
+        self._value_selector.selectedItemsChanged.connect(self._handle_selected_items_changed())
+
+        self._layout = QGridLayout(self)
+        self._layout.setContentsMargins(0, 0, 0, 0)
+        self._layout.addWidget(self._value_selector)
+        self.setLayout(self._layout)
+
+    valuesChanged = pyqtSignal(QAbstractItemModel)
+    selectedValuesChanged = pyqtSignal(list)
+    dataCommitted = pyqtSignal(list)
+
+    def _handle_selected_items_changed(self):
+        widget_ref = weakref.ref(self)
+        def _():
+            widget = widget_ref()
+            if widget:
+                widget.selectedValuesChanged.emit(widget.selectedValues)
+        return _
+
+    @auto_property(QAbstractItemModel)
+    def values(self):
+        return self._value_selector.model()
+    
+    @values.setter
+    def values(self, value):
+        self._value_selector.setModel(value)
+        self._value_selector.selectAll()
+        self.valuesChanged.emit(value)
+        self.selectedValuesChanged.emit(self.selectedValues)
+
+    def setValues(self, values):
+        self.values = values
+        values.dataChanged.connect(self._handle_values_changed)
+        if hasattr(values, 'selectionModel'):
+            self._value_selector.setSelectionModel(values.selectionModel)
+    
+    def selectAll(self):
+        self._value_selector.selectAll()
+    
+    @auto_property(list)
+    def selectedValues(self):
+        if isinstance(self._value_selector.model(), QStringListModel):
+            string_list = self._value_selector.model().stringList()
+            return [
+                string_list[i.row()]\
+                    for i in self._value_selector.selectedIndexes() if i.row() < self._value_selector.model().rowCount()
+            ]
+        return [self._value_selector.model().data(i, DataRole) for i in self._value_selector.selectedIndexes() if i.row() < self._value_selector.model().rowCount()]
+    
+    @selectedValues.setter
+    def selectedValues(self, values):
+        select_values = (
+            self._select_values_stringlist if isinstance(self._value_selector.model(), QStringListModel) 
+            else self._select_values if self._value_selector.model()
+            else None
+        )
+        if select_values and values != self.selectedValues:
+            signals_blocked = self.blockSignals(True)
+            self._value_selector.clearSelection()
+            select_values(values)
+            self.blockSignals(signals_blocked)
+            self.selectedValuesChanged.emit(self.selectedValues)
+    
+    def _select_values_stringlist(self, values):
+        for value in values:
+            index = self._value_selector.model().stringList().index(value)
+            model_index = self._value_selector.model().createIndex(index, 0)
+            self._value_selector.selectionModel().setCurrentIndex(model_index, QItemSelectionModel.Rows | QItemSelectionModel.Select)
+    
+    def _select_values(self, values):
+        model = self._value_selector.model()
+        for i in range(model.rowCount()):
+            model_index = model.createIndex(i, 0)
+            data = model.data(model_index, DataRole)
+            if data in values:
+                self._value_selector.selectionModel().setCurrentIndex(model_index, QItemSelectionModel.Rows | QItemSelectionModel.Select)
+
+    def _handle_values_changed(self):
+        self.selectedValuesChanged.emit(self.selectedValues)
+
+    def keyPressEvent(self, event):
+        if event.key() in [Qt.Key_Enter, Qt.Key_Return]:
+            self.dataCommitted.emit(self.selectedValues)

pyqttoolkit/views/check_box.py

@@ -0,0 +1,36 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from PyQt5.QtCore import pyqtSignal
+from PyQt5.QtWidgets import QCheckBox
+
+from pyqttoolkit.properties import AutoProperty
+from pyqttoolkit.views.styleable import make_styleable
+
+class BindableCheckBox(QCheckBox):
+    def __init__(self, label, parent):
+        QCheckBox.__init__(self, label, parent)
+        self.clicked.connect(self._handle_clicked)
+        self.checkedChanged.connect(self.setChecked)
+    
+    checkedChanged = pyqtSignal(bool)
+
+    checked = AutoProperty(bool)
+
+    def _handle_clicked(self):
+        self.checked = self.isChecked()
+
+BindableCheckBox = make_styleable(BindableCheckBox)

pyqttoolkit/views/code/__init__.py

@@ -0,0 +1,18 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from .code_edit import CodeEdit, PythonCodeEdit
+from .python_syntax import PythonHighlighter

pyqttoolkit/views/code/code_edit.py

@@ -0,0 +1,268 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+import weakref
+from PyQt5.QtCore import Qt, pyqtSignal, QSize, QRect
+from PyQt5.QtWidgets import (
+    QWidget, QGridLayout, QPlainTextEdit,
+    QSplitter, QTextBrowser,
+    QLabel, QTextEdit
+)
+from PyQt5.QtGui import (
+    QPainter, QColor, QPalette, QFont,
+    QTextOption, QFontMetrics, QTextFormat
+)
+
+from .python_syntax import PythonHighlighter
+
+class LineNumberArea(QWidget):
+    def __init__(self, editor):
+        QWidget.__init__(self, editor)
+        self._editor = editor
+    
+    def sizeHint(self):
+        return QSize(self._editor.lineNumberAreaWidth(), 0)
+
+    def paintEvent(self, event):
+        self._editor.lineNumberAreaPaintEvent(event)
+
+class CodeTextEdit(QPlainTextEdit):
+    def __init__(self, parent):
+        QPlainTextEdit.__init__(self, parent)
+        self.document().setDefaultFont(QFont('Courier', pointSize=7))
+        self.setWordWrapMode(QTextOption.NoWrap)
+        self.setTabStopWidth(32)
+
+        self._line_number_area = LineNumberArea(self)
+
+        self.blockCountChanged.connect(self.updateLineNumberAreaWidth)
+        self.updateRequest.connect(self.updateLineNumberArea)
+        self.cursorPositionChanged.connect(self.highlightCurrentLine)
+
+        self.updateLineNumberAreaWidth(0)
+
+        self._key_press_rules = None
+
+    editComplete = pyqtSignal(str)
+
+    def focusInEvent(self, event):
+        result = QPlainTextEdit.focusInEvent(self, event)
+        self.highlightCurrentLine()
+        return result
+        
+    def focusOutEvent(self, event):
+        self.editComplete.emit(self.toPlainText())
+        result = QPlainTextEdit.focusOutEvent(self, event)
+        self.highlightCurrentLine()
+        return result
+    
+    def lineNumberAreaWidth(self):
+        digits = 1
+        block_count = max(1, self.blockCount())
+        while block_count >= 10:
+            block_count /= 10
+            digits += 1
+        
+        space = 3 + self.fontMetrics().width('9') * digits
+
+        return space
+    
+    def fontMetrics(self):
+        return QFontMetrics(self.document().defaultFont())
+    
+    def updateLineNumberAreaWidth(self, block_count):
+        self.setViewportMargins(self.lineNumberAreaWidth(), 0, 0, 0)
+
+    def updateLineNumberArea(self, rect, dy):
+        if dy:
+            self._line_number_area.scroll(0, dy)
+        else:
+            self._line_number_area.update(0, rect.y(), self._line_number_area.width(), rect.height())
+        
+        if rect.contains(self.viewport().rect()):
+            self.updateLineNumberAreaWidth(0)
+    
+    def resizeEvent(self, event):
+        QPlainTextEdit.resizeEvent(self, event)
+
+        contents_rect = self.contentsRect()
+        self._line_number_area.setGeometry(QRect(contents_rect.left(), contents_rect.top(), self.lineNumberAreaWidth(), contents_rect.height()))
+
+    def lineNumberAreaPaintEvent(self, event):
+        painter = QPainter(self._line_number_area)
+        painter.fillRect(event.rect(), Qt.lightGray)
+        painter.setFont(self.document().defaultFont())
+
+        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(Qt.black)
+                painter.drawText(0, int(top), self._line_number_area.width(), self.fontMetrics().height(), Qt.AlignRight, number)
+            block = block.next()
+            top = bottom
+            bottom = top + self.blockBoundingRect(block).height()
+            block_number += 1
+    
+    def highlightCurrentLine(self):
+        extra_selections = []
+        if self.hasFocus() and not self.isReadOnly():
+            selection = QTextEdit.ExtraSelection()
+
+            line_color = QColor(Qt.yellow).lighter(180)
+
+            selection.format.setBackground(line_color)
+            selection.format.setProperty(QTextFormat.FullWidthSelection, True)
+            selection.cursor = self.textCursor()
+            selection.cursor.clearSelection()
+            extra_selections.append(selection)
+        self.setExtraSelections(extra_selections)
+
+    def setKeyPressRules(self, rules):
+        self._key_press_rules = rules
+
+    def keyPressEvent(self, event):
+        if event and self._key_press_rules:
+            next_text = self._key_press_rules.getText(event.key())
+            if next_text:
+                self.insertPlainText(next_text)
+                return
+        QPlainTextEdit.keyPressEvent(self, event)
+
+class CodeEdit(QWidget):
+    def __init__(self, parent):
+        QWidget.__init__(self, parent)
+
+        self._text_edit = CodeTextEdit(self)
+        self._output_pane = QTextBrowser(self)
+        self._output_pane.document().setDefaultFont(QFont('Courier', pointSize=7))
+        self._output_pane.setWordWrapMode(QTextOption.NoWrap)
+
+        self._output_pane_container = QWidget(self)
+        self._output_pane_layout = QGridLayout(self._output_pane_container)
+        self._output_pane_layout.setContentsMargins(0, 16, 0, 0)
+        self._output_pane_layout.addWidget(QLabel(self.tr('Script Output'), self), 0, 0)
+        self._output_pane_layout.addWidget(self._output_pane)
+
+        self._splitter = QSplitter(Qt.Vertical, self)
+
+        self._splitter.addWidget(self._text_edit)
+        self._splitter.addWidget(self._output_pane_container)
+        self._splitter.setStretchFactor(0, 3)
+        self._splitter.setStretchFactor(1, 1)
+
+        self._layout = QGridLayout(self)
+        self._layout.setContentsMargins(0, 0, 0, 0)
+        self._layout.addWidget(self._splitter, 0, 0)
+
+        self._text_edit.editComplete.connect(self.editComplete)
+   
+    editComplete = pyqtSignal(str)
+
+    @property
+    def textEdit(self):
+        return self._text_edit
+    
+    @property
+    def outputPane(self):
+        return self._output_pane
+    
+    def setFontSize(self, font_size):
+        self._text_edit.document().setDefaultFont(QFont('Courier', pointSize=font_size))
+        self._output_pane.document().setDefaultFont(QFont('Courier', pointSize=font_size))
+        self._text_edit.setTabStopWidth(font_size * 2)
+        self._output_pane.setTabStopWidth(font_size * 2)
+
+    def setModel(self, model):
+        self._text_edit.setPlainText(model.text)
+        model.textChanged.connect(self._set_text(self._text_edit))
+        if hasattr(model, 'output'):
+            self._output_pane.setPlainText(model.output.getvalue())
+            model.outputChanged.connect(self._set_text(self._output_pane, True))
+            self._output_pane.setVisible(True)
+        else:
+            self._output_pane_container.setVisible(False)
+        self.editComplete.connect(self._handle_text_changed(model))
+        model.validationMessageChanged.connect(self._handle_validation_message)
+    
+    def _set_text(self, widget, scroll_to_end=False):
+        widget_ref = weakref.ref(widget)
+        def _(text):
+            widget_inst = widget_ref()
+            if widget_inst:
+                text = text if isinstance(text, str) else text.getvalue()
+                if widget_inst.toPlainText() != text:
+                    widget_inst.setPlainText(text)
+                    if scroll_to_end:
+                        widget_inst.verticalScrollBar().setSliderPosition(widget_inst.verticalScrollBar().maximum())
+        return _
+
+    def _handle_text_changed(self, model):
+        model_ref = weakref.ref(model)
+        def _setter(value):
+            model_inst = model_ref()
+            if model_inst:
+                model_inst.text = value
+        return _setter
+
+    def _handle_validation_message(self, message):
+        if message:
+            palette = self.palette()
+            invalid_color = QColor(Qt.red)
+            invalid_color.setAlphaF(0.2)
+            palette.setColor(QPalette.Base, invalid_color)
+        else:
+            palette = self.style().standardPalette()
+        self._text_edit.setPalette(palette)
+        self._text_edit.setToolTip(message or None)
+
+class PythonCodeEdit(CodeEdit):
+    def __init__(self, parent):
+        CodeEdit.__init__(self, parent)
+        self._highlighter = PythonHighlighter(self.textEdit.document())
+        self.textEdit.setKeyPressRules(PythonKeyPressRules(self.textEdit, 4))
+
+class KeyPressRules:
+    def getText(self, key):
+        raise NotImplementedError()
+
+class PythonKeyPressRules(KeyPressRules):
+    def __init__(self, text_edit, tab_width):
+        self._text_edit = text_edit
+        self._tab_width = tab_width
+
+    def getText(self, key):
+        if key in [Qt.Key_Tab, Qt.Key_Backtab]:
+            return ' ' * self._tab_width
+        if key in [Qt.Key_Return, Qt.Key_Enter]:
+            current_position = self._text_edit.textCursor().positionInBlock()
+            current_line = self._text_edit.textCursor().block().text()
+            if current_position == len(current_line):
+                if current_line.strip() and current_line.strip()[-1] == ':':
+                    return '\n' + ' ' * self._tab_width
+                n_spaces = 0
+                for c in current_line:
+                    if c == ' ':
+                        n_spaces += 1
+                    else:
+                        break
+                return '\n' + ' ' * n_spaces
+        return None
+            

pyqttoolkit/views/code/python_syntax.py

@@ -0,0 +1,226 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+"""
+PythonHighlighter
+
+Source: https://wiki.python.org/moin/PyQt/Python%20syntax%20highlighting
+
+BSD 3-Clause License
+
+----
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    (1) Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer. 
+
+    (2) Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in
+    the documentation and/or other materials provided with the
+    distribution.  
+    
+    (3)The name of the author may not be used to
+    endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+"""
+#pylint:disable=no-name-in-module
+from PyQt5.QtCore import QRegExp
+from PyQt5.QtGui import QColor, QTextCharFormat, QFont, QSyntaxHighlighter
+#pylint:enable=no-name-in-module
+
+def format(color, style=''):
+    """Return a QTextCharFormat with the given attributes.
+    """
+    _color = QColor()
+    _color.setNamedColor(color)
+
+    _format = QTextCharFormat()
+    _format.setForeground(_color)
+    if 'bold' in style:
+        _format.setFontWeight(QFont.Bold)
+    if 'italic' in style:
+        _format.setFontItalic(True)
+
+    return _format
+
+
+# Syntax styles that can be shared by all languages
+STYLES = {
+    'keyword': format('blue'),
+    'operator': format('red'),
+    'brace': format('darkGray'),
+    'defclass': format('black', 'bold'),
+    'string': format('magenta'),
+    'string2': format('darkMagenta'),
+    'comment': format('darkGreen', 'italic'),
+    'self': format('black', 'italic'),
+    'numbers': format('brown'),
+}
+
+
+class PythonHighlighter (QSyntaxHighlighter):
+    """Syntax highlighter for the Python language.
+    """
+    # Python keywords
+    keywords = [
+        'and', 'assert', 'break', 'class', 'continue', 'def',
+        'del', 'elif', 'else', 'except', 'exec', 'finally',
+        'for', 'from', 'global', 'if', 'import', 'in',
+        'is', 'lambda', 'not', 'or', 'pass', 'print',
+        'raise', 'return', 'try', 'while', 'yield',
+        'None', 'True', 'False',
+    ]
+
+    # Python operators
+    operators = [
+        '=',
+        # Comparison
+        '==', '!=', '<', '<=', '>', '>=',
+        # Arithmetic
+        '\+', '-', '\*', '/', '//', '\%', '\*\*',
+        # In-place
+        '\+=', '-=', '\*=', '/=', '\%=',
+        # Bitwise
+        '\^', '\|', '\&', '\~', '>>', '<<',
+    ]
+
+    # Python braces
+    braces = [
+        '\{', '\}', '\(', '\)', '\[', '\]',
+    ]
+    def __init__(self, document):
+        QSyntaxHighlighter.__init__(self, document)
+
+        # Multi-line strings (expression, flag, style)
+        # FIXME: The triple-quotes in these two lines will mess up the
+        # syntax highlighting from this point onward
+        self.tri_single = (QRegExp("'''"), 1, STYLES['string2'])
+        self.tri_double = (QRegExp('"""'), 2, STYLES['string2'])
+
+        rules = []
+
+        # Keyword, operator, and brace rules
+        rules += [(r'\b%s\b' % w, 0, STYLES['keyword'])
+            for w in PythonHighlighter.keywords]
+        rules += [(r'%s' % o, 0, STYLES['operator'])
+            for o in PythonHighlighter.operators]
+        rules += [(r'%s' % b, 0, STYLES['brace'])
+            for b in PythonHighlighter.braces]
+
+        # All other rules
+        rules += [
+            # 'self'
+            (r'\bself\b', 0, STYLES['self']),
+
+            # Double-quoted string, possibly containing escape sequences
+            (r'"[^"\\]*(\\.[^"\\]*)*"', 0, STYLES['string']),
+            # Single-quoted string, possibly containing escape sequences
+            (r"'[^'\\]*(\\.[^'\\]*)*'", 0, STYLES['string']),
+
+            # 'def' followed by an identifier
+            (r'\bdef\b\s*(\w+)', 1, STYLES['defclass']),
+            # 'class' followed by an identifier
+            (r'\bclass\b\s*(\w+)', 1, STYLES['defclass']),
+
+            # From '#' until a newline
+            (r'#[^\n]*', 0, STYLES['comment']),
+
+            # Numeric literals
+            (r'\b[+-]?[0-9]+[lL]?\b', 0, STYLES['numbers']),
+            (r'\b[+-]?0[xX][0-9A-Fa-f]+[lL]?\b', 0, STYLES['numbers']),
+            (r'\b[+-]?[0-9]+(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?\b', 0, STYLES['numbers']),
+        ]
+
+        # Build a QRegExp for each pattern
+        self.rules = [(QRegExp(pat), index, fmt)
+            for (pat, index, fmt) in rules]
+
+
+    def highlightBlock(self, text):
+        """Apply syntax highlighting to the given block of text.
+        """
+        # Do other syntax formatting
+        for expression, nth, format in self.rules:
+            index = expression.indexIn(text, 0)
+
+            while index >= 0:
+                # We actually want the index of the nth match
+                index = expression.pos(nth)
+                length = len(expression.cap(nth))
+                self.setFormat(index, length, format)
+                index = expression.indexIn(text, index + length)
+
+        self.setCurrentBlockState(0)
+
+        # Do multi-line strings
+        in_multiline = self.match_multiline(text, *self.tri_single)
+        if not in_multiline:
+            in_multiline = self.match_multiline(text, *self.tri_double)
+
+
+    def match_multiline(self, text, delimiter, in_state, style):
+        """Do highlighting of multi-line strings. ``delimiter`` should be a
+        ``QRegExp`` for triple-single-quotes or triple-double-quotes, and
+        ``in_state`` should be a unique integer to represent the corresponding
+        state changes when inside those strings. Returns True if we're still
+        inside a multi-line string when this function is finished.
+        """
+        # If inside triple-single quotes, start at 0
+        if self.previousBlockState() == in_state:
+            start = 0
+            add = 0
+        # Otherwise, look for the delimiter on this line
+        else:
+            start = delimiter.indexIn(text)
+            # Move past this match
+            add = delimiter.matchedLength()
+
+        # As long as there's a delimiter match on this line...
+        while start >= 0:
+            # Look for the ending delimiter
+            end = delimiter.indexIn(text, start + add)
+            # Ending delimiter on this line?
+            if end >= add:
+                length = end - start + add + delimiter.matchedLength()
+                self.setCurrentBlockState(0)
+            # No; multi-line string
+            else:
+                self.setCurrentBlockState(in_state)
+                length = len(text) - start + add
+            # Apply formatting
+            self.setFormat(start, length, style)
+            # Look for the next match
+            start = delimiter.indexIn(text, start + length)
+
+        # Return True if still inside a multi-line string, False otherwise
+        if self.currentBlockState() == in_state:
+            return True
+        else:
+            return False