def __init__(self, document): QSyntaxHighlighter.__init__(self, document) self.tri_single = (QRegularExpression("'''"), 1, STYLES['string2']) self.tri_double = (QRegularExpression('"""'), 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 += [ (r'\bself\b', 0, STYLES['self']), (r'"[^"\\]*(\\.[^"\\]*)*"', 0, STYLES['string']), (r"'[^'\\]*(\\.[^'\\]*)*'", 0, STYLES['string']), (r'\bdef\b\s*(\w+)', 1, STYLES['defclass']), (r'\bclass\b\s*(\w+)', 1, STYLES['defclass']), (r'#[^\n]*', 0, STYLES['comment']), (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']), ] # Создайте QRegExp для каждого шаблона self.rules = [(QRegularExpression(pat), index, fmt) for (pat, index, fmt) in rules]
def set_plain_text_format(self): # format for name labels regex_label_name = QRegularExpression("label_pl_[1-6]_name") for label_name in self.findChildren(QLabel, regex_label_name, Qt.FindChildrenRecursively): label_name: QLabel label_name.setTextFormat(Qt.PlainText) # format for stack of each player regex_label_btc = QRegularExpression("label_pl_[1-6]_btc") for label_btc in self.findChildren(QLabel, regex_label_btc, Qt.FindChildrenRecursively): label_name: QLabel label_btc.setTextFormat(Qt.PlainText) # format for bet amount of each player regex_label_bet = QRegularExpression("label_pl_[1-6]_bet_amt") for label_bet in self.findChildren(QLabel, regex_label_bet, Qt.FindChildrenRecursively): label_name: QLabel label_bet.setTextFormat(Qt.PlainText) # for pot and result label self.ui.label_result.setTextFormat(Qt.PlainText) self.ui.label_pot.setTextFormat(Qt.PlainText)
def search_highlight(self): """The function that will be called whenever the search area is submitted. It will search within the text_field and highlights matches.""" cursor = self.text_field.textCursor() char_format = QTextCharFormat() cursor.select(QTextCursor.Document) cursor.mergeCharFormat(char_format) cursor.clearSelection() char_format.setBackground(QBrush(QColor('yellow'))) regex = QRegularExpression(self.ui.search_area.text()) matches = regex.globalMatch(self.text_field.toPlainText()) _matches = [] while matches.hasNext(): _matches.append(matches.next()) self.search_matches = _matches self.ui.search_matches_label.setText('Matches: ' + str(len(self.search_matches))) self.ui.search_progress_bar.setRange(0, len(self.search_matches)) if len(self.search_matches) > 100: self.ui.search_progress_bar.show() match_count = 1 for match in self.search_matches: if match_count > 1000: # TODO: implement proper handling of > 1000 matches break self.ui.search_progress_bar.setValue(match_count) match_count += 1 cursor.setPosition(match.capturedStart()) cursor.setPosition(match.capturedEnd(), QTextCursor.KeepAnchor) cursor.mergeCharFormat(format) self.ui.search_progress_bar.hide()
def procurar(self): if not self.diretorio: Ui_Dialog(text="selecione o diretorio alvo primeiro", title="diretorio alvo", buttonText="selecionar", action=self.selecionarDiretorioDialog) return self.txtAlvo = self.lne_textAlvo.text() print(self.txtAlvo) if self.txtAlvo == '' or self.txtAlvo == 'Texto alvo': a = Ui_Entry( parent=self, lblText='digite o texto alvo, que será procurado', title="valro alvo", ) a.signal.connect(self.dialogPronto) return exp = self.lne_textAlvo.text() if self.cb_palavraToda.isChecked(): exp = "\\b" + exp + "\\b" if not self.cb_keySensitive.isChecked(): self.expression = QRegularExpression(exp) else: self.expression = QRegularExpression( exp, QRegularExpression.CaseInsensitiveOption) t = refactorThread(self.diretorio, self.expression) t.appendTextSigal.connect(self.txt_textoAlvo.append) t.setTextSignal.connect(self.txt_textoAlvo.setText) t.statusBarSignal.connect(self.lbl_status.setText) t.focousSignal.connect(self.setFocousFormat) t.start()
def highlight(self, regex: QRegularExpression, color: QColor = QColor(Qt.yellow)): if regex.pattern() == "": return self.moveCursor(QTextCursor.Start) matches = [] it: QRegularExpressionMatchIterator = regex.globalMatch(self.toPlainText()) while it.hasNext(): match: QRegularExpressionMatch = it.next() if not match.hasMatch(): continue begin = match.capturedStart() end = match.capturedEnd() matchSelection: QTextEdit.ExtraSelection = QTextEdit.ExtraSelection() fmt: QTextCharFormat = matchSelection.format fmt.setBackground(color) matchSelection.cursor = self.textCursor() matchSelection.cursor.setPosition(begin, QTextCursor.MoveAnchor) matchSelection.cursor.setPosition(end, QTextCursor.KeepAnchor) matches.append(matchSelection) self.setExtraSelections(matches) self.moveCursor(QTextCursor.Start)
def highlightBlock(self, text): regExp = QRegularExpression("[0-9]") matchIterator = regExp.globalMatch(text) while matchIterator.hasNext(): match = matchIterator.next() self.setFormat(match.capturedStart(), match.capturedLength(), self.numberFormat)
def __init__(self, document): QSyntaxHighlighter.__init__(self, document) rules = [] # Keyword, operator, and brace rules rules += [(r'\b%s\b' % w, 0, self.STYLES['dot_keywords'], "dot_keywords", []) for w in PythonHighlighter.dot_keywords] patterns_cond_bool_operators = [ (r'\b%s\b' % c, 0, self.STYLES['cond_bool_operators'], "cond_bool_operators", []) for c in PythonHighlighter.cond_bool_operators ] rules_cond_bool_operators = [ (QRegularExpression(pat), index, fmt, ruleid, subrules) for (pat, index, fmt, ruleid, subrules) in patterns_cond_bool_operators ] patterns_cond_operators = [ (r'\b%s\b' % c, 0, self.STYLES['cond_operators'], "cond_operators", []) for c in PythonHighlighter.cond_operators ] rules_cond_operators = [ (QRegularExpression(pat), index, fmt, ruleid, subrules) for (pat, index, fmt, ruleid, subrules) in patterns_cond_operators ] patterns_cond_keywords = [ (r'\b%s\b' % c, 0, self.STYLES['cond_keywords'], "cond_keywords", []) for c in PythonHighlighter.cond_keywords ] rules_cond_keywords = [ (QRegularExpression(pat), index, fmt, ruleid, subrules) for (pat, index, fmt, ruleid, subrules) in patterns_cond_keywords ] # All other rules rules += [ # Conditions (r'cond(ition)? *= *"[^"]*(\\.[^"\\]*)*"', 0, self.STYLES['default'], "cond1", rules_cond_operators + rules_cond_keywords + rules_cond_bool_operators), (r'cond(ition)? *=[^,\]]*[,\]]', 0, self.STYLES['default'], "cond2", rules_cond_operators + rules_cond_keywords + rules_cond_bool_operators), # Single-quoted string, possibly containing escape sequences (r"'[^'\\]*(\\.[^'\\]*)*'", 0, self.STYLES['default'], "singlequotedstrings", []), # From '//' until a newline: comments (r'^//[^\n]*', 0, self.STYLES['comment'], "comment", []), ] # Build a QRegularExpression for each pattern self.rules = [(QRegularExpression(pat), index, fmt, ruleid, subrules) for (pat, index, fmt, ruleid, subrules) in rules]
def __init__(self, parent=None): super().__init__(parent) self.setAttribute(Qt.WA_QuitOnClose, False) self.setWindowFlags(Qt.Dialog | Qt.WindowTitleHint | Qt.WindowSystemMenuHint) self.setWindowTitle(_('Base Conversions')) self.value = 0 self.numBits = 32 self.twosComplement = False layout = QVBoxLayout(self) layout.setSpacing(0) decimalLabel = QLabel(_('&Decmal')) layout.addWidget(decimalLabel) decimalEdit = QLineEdit() decimalLabel.setBuddy(decimalEdit) decimalEdit.base = 10 decRegEx = QRegularExpression('[-0-9]*') decimalEdit.setValidator(QRegularExpressionValidator(decRegEx)) layout.addWidget(decimalEdit) layout.addSpacing(8) hexLabel = QLabel(_('&Hex')) layout.addWidget(hexLabel) hexEdit = QLineEdit() hexLabel.setBuddy(hexEdit) hexEdit.base = 16 hexRegEx = QRegularExpression('[-0-9a-fA-F]*') hexEdit.setValidator(QRegularExpressionValidator(hexRegEx)) layout.addWidget(hexEdit) layout.addSpacing(8) octalLabel = QLabel(_('&Octal')) layout.addWidget(octalLabel) octalEdit = QLineEdit() octalLabel.setBuddy(octalEdit) octalEdit.base = 8 octRegEx = QRegularExpression('[-0-7]*') octalEdit.setValidator(QRegularExpressionValidator(octRegEx)) layout.addWidget(octalEdit) layout.addSpacing(8) binaryLabel = QLabel(_('&Binary')) layout.addWidget(binaryLabel) binaryEdit = QLineEdit() binaryLabel.setBuddy(binaryEdit) binaryEdit.base = 2 binRegEx = QRegularExpression('[-01]*') binaryEdit.setValidator(QRegularExpressionValidator(binRegEx)) layout.addWidget(binaryEdit) layout.addSpacing(8) self.bitsButton = QPushButton('') self.setButtonLabel() layout.addWidget(self.bitsButton) self.bitsButton.clicked.connect(self.changeBitSettings) layout.addSpacing(8) closeButton = QPushButton(_('&Close')) layout.addWidget(closeButton) closeButton.clicked.connect(self.close) self.editors = (decimalEdit, hexEdit, octalEdit, binaryEdit) for editor in self.editors: editor.textEdited.connect(self.updateValue)
def __init__(self, doc, pattern, color): super().__init__(doc) self._format = QTextCharFormat() self._format.setForeground(color) words = pattern.split() words.sort(key=len, reverse=True) pat = "|".join(re.escape(word) for word in words) self._expression = QRegularExpression( pat, QRegularExpression.CaseInsensitiveOption)
def setExpression(self, exp, caseSensitive, wholeWord): if wholeWord: exp = "\\b" + exp + "\\b" print(exp) if caseSensitive: self.expression = QRegularExpression(exp) else: self.expression = QRegularExpression( exp, QRegularExpression.CaseInsensitiveOption)
def _init_line_edits(self): validator = QRegularExpressionValidator(QRegularExpression("[^ ]+")) self.name_line_edit.setValidator(validator) self.symbol_line_edit.setValidator(validator) self.unit_line_edit.setValidator(validator) self.unit_net_price_line_edit.setValidator( QRegularExpressionValidator(QRegularExpression("\d+(,\d{2})?"))) self.vat_line_edit.setValidator( QRegularExpressionValidator(QRegularExpression("\d{1,2}")))
def highlightBlock(self, text): for pattern, fmt in self.highlightingRules: regex = QRegularExpression(pattern) i = regex.globalMatch(text) while i.hasNext(): match = i.next() start = match.capturedStart() length = match.capturedLength() self.setFormat(start, length, fmt) self.setCurrentBlockState(0)
def addBlockRule(self, startPattern, endPattern, textFormat): """ Add a block syntax highlighting rule, that begins with regex string *startPattern* and ends with *endPattern* formatted according to QTextCharFormat_ *format*. .. _QTextCharFormat: http://doc.qt.io/qt-5/qtextcharformat.html """ startRegex = QRegularExpression(startPattern) endRegex = QRegularExpression(endPattern) self._blockHighlightingRules.append((startRegex, endRegex, textFormat))
def highlightBlock(self, text): highlightFormat = QTextCharFormat() highlightFormat.setForeground(Qt.red) highlightFormat.setBackground(Qt.black) highlightFormat.setFontWeight(QFont.Bold) regex = QRegularExpression(self.query) it = regex.globalMatch(text) while(it.hasNext()): match = it.next() self.setFormat(match.capturedStart(), match.capturedLength(), highlightFormat)
def __setup_validators(self): positive_integer = QRegularExpression(r"\d+") positive_integer_validator = QRegularExpressionValidator(positive_integer) rational = QRegularExpression(r"-?\d+\.\d+") rational_validator = QRegularExpressionValidator(rational) self.__ui.x0_Input.setValidator(rational_validator) self.__ui.y0_Input.setValidator(rational_validator) self.__ui.x_Input.setValidator(rational_validator) self.__ui.n_Input.setValidator(positive_integer_validator) self.__ui.n0_error_Input.setValidator(positive_integer_validator) self.__ui.n_error_Input.setValidator(positive_integer_validator)
def highlightBlock(self, text): rExpr = QRegularExpression(self.highStr) matches = rExpr.globalMatch(text) if not matches.isValid(): return while matches.hasNext(): match = matches.next() if not match.isValid(): break self.setFormat(match.capturedStart(), match.capturedLength(), self.fmt)
def _init_line_edits(self): self.name_line_edit.setValidator( QRegularExpressionValidator( QRegularExpression("[a-zA-ZĄąĆćĘꣳŃńÓ󌜯żŹź\\s]+"))) self.lastname_line_edit.setValidator( QRegularExpressionValidator( QRegularExpression("[a-zA-ZĄąĆćĘꣳŃńÓ󌜯żŹź\\s\\-]+"))) self.taxid_line_edit.setValidator( QRegularExpressionValidator(QRegularExpression("[\\d\\-?]+"))) self.postalcode_line_edit.setValidator( QRegularExpressionValidator(QRegularExpression("\\d{2}\\-\\d{3}"))) self.city_line_edit.setValidator( QRegularExpressionValidator( QRegularExpression("[a-zA-ZĄąĆćĘꣳŃńÓ󌜯żŹź\\s\\-]+")))
def apply_filter(self, *args): text = self.filterEdit.text() if text: if self.filter_columns.currentText() == "name": m = QRegularExpression(text) if m.isValid(): if self.name_regex_option.currentText( ) == "case-insensitive": m.setPatternOptions( QRegularExpression.CaseInsensitiveOption) m.optimize() filter = lambda row_num: m.match( self.table.item(row_num, 0).text()).hasMatch() else: return elif self.filter_columns.currentText() == "denticity": if text.isdigit(): filter = lambda row_num: int( self.table.item(row_num, 1).text()) == int(text) else: filter = lambda row: True elif self.filter_columns.currentText() == "coordinating elements": method = self.coordinating_elements_method.currentText() def filter(row_num): row_key_atoms = [ item.strip() for item in self.table.item( row_num, 2).text().split(',') ] search_atoms = [] for item in text.split(): for ele in item.split(','): if ele.strip() != "": search_atoms.append(ele) if method == "exactly": if all([row_key_atoms.count(element) == search_atoms.count(element) for element in set(search_atoms)]) and \ all([row_key_atoms.count(element) == search_atoms.count(element) for element in set(row_key_atoms)]): return True else: return False elif method == "at least": if all([ row_key_atoms.count(element) >= search_atoms.count(element) for element in set(search_atoms) ]): return True else: return False else: filter = lambda row: True for i in range(0, self.table.rowCount()): self.table.setRowHidden(i, not filter(i))
def rxExecute(regexp, options, text, startpos): """ Function to execute the given regular expression for a given text. @param regexp regular expression to validate (string) @param options list of options (list of string) @param text text to execute on (string) @param startpos start position for the execution (integer) @return tuple of a flag indicating a successful match (boolean) and a list of captures containing the complete match as matched string (string), match start (integer), match end (integer) and match length (integer) for each entry """ valid, error, errorOffset = rxValidate(regexp, options) if not valid: return valid, error, errorOffset from PyQt5.QtCore import QRegularExpression rxOptions = QRegularExpression.NoPatternOption if "CaseInsensitiveOption" in options: rxOptions |= QRegularExpression.CaseInsensitiveOption if "MultilineOption" in options: rxOptions |= QRegularExpression.MultilineOption if "DotMatchesEverythingOption" in options: rxOptions |= QRegularExpression.DotMatchesEverythingOption if "ExtendedPatternSyntaxOption" in options: rxOptions |= QRegularExpression.ExtendedPatternSyntaxOption if "InvertedGreedinessOption" in options: rxOptions |= QRegularExpression.InvertedGreedinessOption if "UseUnicodePropertiesOption" in options: rxOptions |= QRegularExpression.UseUnicodePropertiesOption if "DontCaptureOption" in options: rxOptions |= QRegularExpression.DontCaptureOption matched = False captures = [] re = QRegularExpression(regexp, rxOptions) match = re.match(text, startpos) if match.hasMatch(): matched = True for index in range(match.lastCapturedIndex() + 1): captures.append([ match.captured(index), match.capturedStart(index), match.capturedEnd(index), match.capturedLength(index) ]) return matched, captures
def __init__(self): '''Initializes a MainModel instance.''' self._searchText = '' self._matchCase = False self._includePrivateMembers = False self._includeInheritedMembers = False self._sortByType = True # Initialize icons. iconDir = f'{dirname(dirname(__file__))}/icons' self._icons = { 'module': QIcon(f'{iconDir}/module.svg'), 'abstract base class': QIcon(f'{iconDir}/abstract.svg'), 'class': QIcon(f'{iconDir}/class.svg'), 'function': QIcon(f'{iconDir}/function.svg'), 'property': QIcon(f'{iconDir}/property.svg'), 'object': QIcon(f'{iconDir}/object.svg') } # Create the unfiltered tree model. self._treeModel = QStandardItemModel() # Create regular expressions that exclude or include private members. self._excludePrivateRegEx = QRegularExpression('^[^_]|^__') self._includePrivateRegEx = QRegularExpression('') # Create regular expressions that exclude or include inherited members. self._excludeInheritedRegEx = QRegularExpression('^$') self._includeInheritedRegEx = QRegularExpression('') # Create a filtered tree model used to exclude or include private members. self._intermediateTreeModel = QSortFilterProxyModel() self._intermediateTreeModel.setSourceModel(self._treeModel) privateRegEx = self._includePrivateRegEx if self._includePrivateMembers else self._excludePrivateRegEx self._intermediateTreeModel.setFilterRegularExpression(privateRegEx) # Create a filtered tree model used to exclude or include inherited members. self._secondIntermediateTreeModel = QSortFilterProxyModel() self._secondIntermediateTreeModel.setSourceModel(self._intermediateTreeModel) self._secondIntermediateTreeModel.setFilterKeyColumn(2) inheritedRegEx = self._includeInheritedRegEx if self._includeInheritedMembers else self._excludeInheritedRegEx self._secondIntermediateTreeModel.setFilterRegularExpression(inheritedRegEx) # Create a filtered tree model that matches the search text. self._filteredTreeModel = QSortFilterProxyModel() self._filteredTreeModel.setSourceModel(self._secondIntermediateTreeModel) self._filteredTreeModel.setRecursiveFilteringEnabled(True) self._filteredTreeModel.setFilterFixedString(self._searchText) self._filteredTreeModel.setFilterCaseSensitivity(1 if self._matchCase else 0)
def checkSpelling(self, text): if not self.dictionary: return wordFinder = QRegularExpression("[A-Za-z]+"); wordIterator = wordFinder.globalMatch(text) while wordIterator.hasNext(): match = wordIterator.next() if not self.dictionary.check(match.captured()): # update the word's current format spellingErrorformat = self.format(match.capturedStart()) spellingErrorformat.setUnderlineColor(Qt.red) spellingErrorformat.setUnderlineStyle(QTextCharFormat.SpellCheckUnderline) # set the new format self.setFormat(match.capturedStart(), match.capturedLength(), spellingErrorformat)
def __init__(self, parent=None): super(Highlighter, self).__init__(parent) self.highlighting_rules = list() self.keywordFormat = QTextCharFormat() self.keywordFormat.setForeground(Qt.darkBlue) self.keywordFormat.setFontWeight(QFont.Bold) self.keyword_patterns = [ '\\babort\\b', '\\bexit\\b', '\\bdo\\b', '\\bloop\\b', '\\bunloop\\b', '\\bbegin\\b', '\\buntil\\b', '\\bwhile\\b', '\\brepeat\\b', '\\bexit\\b', '\\bif\\b', '\\belse\\b', '\\bthen\\b', '\\bcase\\b', '\\bendcase\\b', '\\bof\\b', '\\bendof\\b', '\\bagain\\b', '\\bleave\\b', '\\brequire\\b', '\\bincluded\\b', '\\bdecimal\\b', '\\bhex\\b', '\\balso\\b', '\\bonly\\b', '\\bprevious\\b', '\\bcreate\\b', '\\bdoes>\\b', '\\bvariable\\b', 'b\\value\\b', '\\b2variable\\b', '\\bconstant\\b', '\\babort"\\b', '\\bdup\\b', '\\bdrop\\b', '\\bswap\\b', '\\bover\\b', '\\bpick\\b', '\\broll\\b', '\\b2dup\\b', '\\b2drop\\b', '\\b2swas\\b', '\\b2over\\b', '\\b!\\b', '\\bc!\\b', '\\brot\\b', '\\b@\\b', '\\bc@\\b', '\\b2!\\b', '\\b2@\\b', '\\band\\b', '\\bor\\b', '\\bxor\\b', '\\binvert\\b', '\\bnegate\\b', '\\b/\\b', '\\b/mod\\b', '\\bbye\\b', '\\bmod\\b', '\\brshift\\b', '\\blshift\\b' ] for pattern in self.keyword_patterns: self.highlighting_rules.append( [QRegularExpression(pattern), self.keywordFormat])
def loadIntegerFloatList(self, font, src, dst): values = " ".join(str(val) for val in getattr(font.info, src)) setattr(self, dst + "Edit", QLineEdit(values, self)) validator = QRegularExpressionValidator(self) validator.setRegularExpression( QRegularExpression("(-?\d+(.\d+)?\s*)*")) getattr(self, dst + "Edit").setValidator(validator)
def __init__(self, redactor):#*args, **kwargs super().__init__(redactor) """ this is Fanuc turn - milling simulator. If u writing similar one, use it as parent or collateral. To add command, create behavior function; add to special_commands list string, color, style. Note, that pattern will be checked one after another, so if u have patternA thant includes patternB as a part, order matters """ #self.k_XYZABC['X'] = 0.5 #self.ABC_HEAD[2] = False#ax Z belong to table or spindle #print('self.k_XYZABC = ', self.k_XYZABC) self.update_rules() #self.ABC_turning_Zero['A'] = #print('k_XYZABC_list = ', self.k_XYZABC_list) #n_number = r'^\s*N(\d*)\s*'#херня какая то self.special_commands = [ [r'\s*G(1[789])\s*', self.change_plane, format('blue', 'bold')], [r'G28\s*(([UVW])\s*0.?\s*)(([UVW])\s*0.?\s*)?(([UVW])\s*0.?\s*)?$', self.G28_U0_V0_W0, format('red', 'bold')], [r'\s*G(9[01])\s*', self.absolut_and_reference_coord_G90_G91, format('blue', 'bold')], #[r'^\s*N(\d*)\s*', self.N_number, format('blue', 'bold')], ] for i in range(0, len(self.special_commands)): self.special_commands[i][0] = QRegularExpression(self.special_commands[i][0]) #look Perl RegularExpressions if u need print('self.special_commands = ', self.special_commands)
def __init__(self, *, combobox_model, **kwargs): super(NewProfileDialog, self).__init__(**kwargs) self.setupUi(self) self.okbutton = self.buttonBox.button(QDialogButtonBox.Ok) self.okbutton.setDisabled(True) self.final_name = None self.copy_from = None self.comboBox.setModel(combobox_model) # according to timeit, checking if a word is in a list is # faster than checking against a RegExp--even a compiled RE, # and even if you pre-process the word to check each time # (e.g.: word.lower() in wordlist) self.name_list = [p.lower() for p in combobox_model.profiles] # self.name_list = [p.name.lower() for p in combobox_model.profiles] # this validator ensures that no spaces or invalid characters can be entered. # (only letters, numbers, underscores, hyphens, and periods) vre_str = r"[\w\d_.-]+" self.vre = QRegularExpression(vre_str) self.validator = QRegularExpressionValidator(self.vre) self.lineEdit.setValidator(self.validator) # stylesheet for invalid text self.ss_invalid = "QLineEdit { color: red }" # tooltip for invalid text self.tt_invalid = "Profile names must be unique"
def __init__(self, max_bits=-1, bit_group_size=4): super().__init__() self.max_bits = max_bits self.bit_group_size = bit_group_size if max_bits == 0: self.re_acceptable = QRegularExpression('') elif max_bits > 0: self.re_acceptable = QRegularExpression( '^([0,1](\s[0,1]){0,%d})?$' % (max_bits - 1)) self.re_intermediate = QRegularExpression('^(\s*[0,1]){0,%d}\s*$' % (max_bits)) else: self.re_acceptable = QRegularExpression('^([0,1](\s[0,1])*)?$') self.re_intermediate = QRegularExpression('^(\s*[0,1])*\s*$')
def __init__(self, addon=False, parent=None): """ Constructor @param addon flag indicating an addon firmware @type bool @param parent reference to the parent widget @type QWidget """ super(EspFirmwareSelectionDialog, self).__init__(parent) self.setupUi(self) self.__addon = addon self.firmwarePicker.setMode(E5PathPickerModes.OpenFileMode) self.firmwarePicker.setFilters( self.tr("Firmware Files (*.bin);;All Files (*)")) self.espComboBox.addItems(["", "ESP32", "ESP8266"]) if addon: self.__validator = QRegularExpressionValidator( QRegularExpression(r"[0-9a-fA-F]{0,4}")) self.addressEdit.setValidator(self.__validator) else: self.addressLabel.hide() self.addressEdit.hide() msh = self.minimumSizeHint() self.resize(max(self.width(), msh.width()), msh.height())
class TextFilesProxyModel(QSortFilterProxyModel): def __init__(self, parent=None): super().__init__(parent) self._filter = QRegularExpression() def setFilter(self, filesFilter: QRegularExpression): if self._filter == filesFilter: return self._filter = filesFilter self.invalidateFilter() def setUseRegExp(self, useRegExp: bool): self._useRegExp = useRegExp self.invalidateFilter() def filterAcceptsRow(self, sourceRow: int, sourceParent: QModelIndex): if self._filter.pattern() == "": return True index: QModelIndex = self.sourceModel().index(sourceRow, 0, sourceParent) file: TextFile = self.sourceModel().data(index, Qt.UserRole).value() return file.contains(self._filter, self._useRegExp) def filteredFiles(self) -> List[TextFile]: files = [] for i in range(0, self.rowCount()): index: QModelIndex = self.mapToSource(self.index(i, 0, QModelIndex())) file: TextFile = self.sourceModel().data(index, Qt.UserRole).value() files.append(file) return files
def __init__(self, parent, predicates=None, functions=None): super(CLIFSyntaxHighlighter, self).__init__(parent) self.setDocument(parent.document()) self.predicates = [] if predicates is None else predicates self.functions = [] if functions is None else functions # define formats and rules ignore_case = QRegularExpression.CaseInsensitiveOption self.rules = [] # real colors for functions and predicates self.format_predicate = QTextCharFormat() self.format_predicate.setForeground(get_color("color_predicate")) self.format_function = QTextCharFormat() self.format_function.setForeground(get_color("color_function")) format_equals = QTextCharFormat() format_equals.setForeground(get_color("color_equals")) self.rules.append((QRegularExpression("="), 0, format_equals)) format_connective = QTextCharFormat() format_connective.setForeground(get_color("color_connective")) connectives = ["AND", "OR", "IF", "IFF"] for c in connectives: self.rules.append( (QRegularExpression("\(" + c, ignore_case), 1, format_connective)) format_not = QTextCharFormat() format_not.setForeground(get_color("color_not")) self.rules.append((QRegularExpression("NOT", ignore_case), 0, format_not)) format_quantifier = QTextCharFormat() format_quantifier.setForeground(get_color("color_quantifier")) quantifiers = ["EXISTS", "FORALL"] for q in quantifiers: self.rules.append( (QRegularExpression("\(" + q, ignore_case), 1, format_quantifier)) format_parentheses = QTextCharFormat() format_parentheses.setForeground(get_color("color_parentheses")) parentheses = ["\(", "\)"] for p in parentheses: self.rules.append((QRegularExpression(p), 0, format_parentheses))
def onSearchBarTextChanged(self, text): moodleTreeView = self.findChild(QTreeView, "moodleTree") searchBar = self.findChild(QLineEdit, "searchBar") if not text: self.filterModel.setFilterRegularExpression(".*") moodleTreeView.collapseAll() searchBar.setStyleSheet("") else: regexp = QRegularExpression(text) if regexp.isValid(): self.filterModel.setFilterRegularExpression(regexp) moodleTreeView.expandAll() searchBar.setStyleSheet("") else: log.debug("invalid search regular expression, not searching") searchBar.setStyleSheet("QLineEdit { color: red; }")
class WorkspaceNameValidator(QValidator): def __init__(self): self.regex = QRegularExpression(r"^.{1,256}$") def validate(self, string, pos): if self.regex.match(string, pos).hasMatch(): return QValidator.Acceptable, string, pos return QValidator.Invalid, string, pos
def rxValidate(regexp, options): """ Function to validate the given regular expression. @param regexp regular expression to validate (string) @param options list of options (list of string) @return tuple of flag indicating validity (boolean), error string (string) and error offset (integer) """ try: from PyQt5.QtCore import QRegularExpression rxOptions = QRegularExpression.NoPatternOption if "CaseInsensitiveOption" in options: rxOptions |= QRegularExpression.CaseInsensitiveOption if "MultilineOption" in options: rxOptions |= QRegularExpression.MultilineOption if "DotMatchesEverythingOption" in options: rxOptions |= QRegularExpression.DotMatchesEverythingOption if "ExtendedPatternSyntaxOption" in options: rxOptions |= QRegularExpression.ExtendedPatternSyntaxOption if "InvertedGreedinessOption" in options: rxOptions |= QRegularExpression.InvertedGreedinessOption if "UseUnicodePropertiesOption" in options: rxOptions |= QRegularExpression.UseUnicodePropertiesOption if "DontCaptureOption" in options: rxOptions |= QRegularExpression.DontCaptureOption error = "" errorOffset = -1 re = QRegularExpression(regexp, rxOptions) valid = re.isValid() if not valid: error = re.errorString() errorOffset = re.patternErrorOffset() except ImportError: valid = False error = "ImportError" errorOffset = 0 return valid, error, errorOffset