def init_regex(self):
self.__rules.update({
scheme['name']: [QRegExp(i) for i in scheme['regex']] + [
QRegExp("|".join(
[r"\b%s\b" % keyword for keyword in scheme['key']]))
]
for scheme in self.rules_scheme['scheme']
})
def __init__(self, formats=None):
self.styles = styles = dict(STYLES, **(formats or {}))
self.rules = [
# Match the prompt incase of a console
(QRegExp(r'IN[^\:]*'), 0, styles['inprompt']),
(QRegExp(r'OUT[^\:]*'), 0, styles['outprompt']),
# Numeric literals
(QRegExp(r'\b[+-]?[0-9]+\b'), 0, styles['numbers']),
]
def __init__(self, parent=None):
"""Display a dialog to open a new redis connection"""
super(OpenRedisDialog, self).__init__(parent)
self.load_ui()
v = QRegExpValidator(QRegExp("([^:/]+)?(:[0-9]+)?"))
self.ui.tcp.setValidator(v)
self.ui.tcp_option.setChecked(True)
def __init__(self, parent=None, macros=None, **kwargs):
super().__init__(parent=parent,
macros=macros,
ui_filename=EPICSTEL_MAIN_UI)
self.login_remote()
self.delete_pv_btn.clicked.connect(self.del_pv)
self.delete_user_btn.clicked.connect(self.del_user)
self.delete_team_btn.clicked.connect(self.del_team)
self.add_user_btn.clicked.connect(lambda: self.show_add_dialog("user"))
self.add_pv_btn.clicked.connect(lambda: self.show_add_dialog("pv"))
self.add_team_btn.clicked.connect(lambda: self.show_add_dialog("team"))
self.pvs_table.clicked.connect(lambda c: self.cell_clicked(c, "pvs"))
self.teams_table.clicked.connect(
lambda c: self.cell_clicked(c, "teams"))
self.users_table.clicked.connect(
lambda c: self.cell_clicked(c, "users"))
ip_regex = "^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]).){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$"
self.ca_addr_input.setValidator(QRegExpValidator(QRegExp(ip_regex)))
self.del_sc = QShortcut(QKeySequence("Del"), self)
self.del_sc.activated.connect(self.del_ca_addr)
self.add_ca_addr_btn.clicked.connect(self.add_ca_addr)
def create_lineedit(self,
text,
option,
default=NoDefault,
tip=None,
alignment=Qt.Vertical,
regex=None,
restart=False,
word_wrap=True,
placeholder=None,
content_type=None,
section=None):
label = QLabel(text)
label.setWordWrap(word_wrap)
edit = QLineEdit()
edit.content_type = content_type
layout = QVBoxLayout() if alignment == Qt.Vertical else QHBoxLayout()
layout.addWidget(label)
layout.addWidget(edit)
layout.setContentsMargins(0, 0, 0, 0)
if tip:
edit.setToolTip(tip)
if regex:
edit.setValidator(QRegExpValidator(QRegExp(regex)))
if placeholder:
edit.setPlaceholderText(placeholder)
self.lineedits[edit] = (section, option, default)
widget = QWidget(self)
widget.label = label
widget.textbox = edit
widget.setLayout(layout)
edit.restart_required = restart
edit.label_text = text
return widget
def __init__(self, parent=None):
super().__init__(parent)
self._data = {"element1": "", "element2": "", "energy": 0}
# Reference to function that computes pileup energy based on two emission lines
self._compute_energy = None
self.setWindowTitle("Pileup Peak Parameters")
self.le_element1 = LineEditExtended()
set_tooltip(self.le_element1,
"The <b>name</b> of the emission line #1")
self.le_element2 = LineEditExtended()
set_tooltip(self.le_element2,
"The <b>name</b> of the emission line #2")
self.peak_energy = LineEditReadOnly()
set_tooltip(
self.peak_energy,
"The <b>energy</b> (location) of the pileup peak center. The energy can not"
"be edited: it is set based on the selected emission lines",
)
self._validator_eline = QRegExpValidator()
# TODO: the following regex is too broad: [a-z] should be narrowed down
self._validator_eline.setRegExp(QRegExp(r"^[A-Z][a-z]?_[KLM][a-z]\d$"))
instructions = QLabel(
"Specify two emission lines, e.g. Si_Ka1 and Fe_Ka1")
grid = QGridLayout()
grid.addWidget(QLabel("Emission line 1:"), 0, 0)
grid.addWidget(self.le_element1, 0, 1)
grid.addWidget(QLabel("Emission line 2:"), 1, 0)
grid.addWidget(self.le_element2, 1, 1)
grid.addWidget(QLabel("Peak energy, keV:"), 2, 0)
grid.addWidget(self.peak_energy, 2, 1)
button_box = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
button_box.button(QDialogButtonBox.Cancel).setDefault(True)
button_box.accepted.connect(self.accept)
button_box.rejected.connect(self.reject)
self.pb_ok = button_box.button(QDialogButtonBox.Ok)
vbox = QVBoxLayout()
vbox.addWidget(instructions)
vbox.addSpacing(10)
vbox.addLayout(grid)
vbox.addWidget(button_box)
self.setLayout(vbox)
self.le_element1.editingFinished.connect(
self.le_element1_editing_finished)
self.le_element2.editingFinished.connect(
self.le_element2_editing_finished)
self.le_element1.textChanged.connect(self.le_element1_text_changed)
self.le_element2.textChanged.connect(self.le_element2_text_changed)
def __init__(self, regex=None, tooltip=None):
super(EditableListDelegate, self).__init__()
self.regex = regex
self.qregex = QRegExp(regex)
self.tooltip = tooltip
self.validator = QRegExpValidator(self.qregex)
self.edit = None
def __init__(self, parent, plugin, tabs, data, icon):
QDialog.__init__(self, parent)
# Variables
self.plugins_tabs = []
self.plugins_data = []
self.plugins_instances = []
self.add_plugin(plugin, tabs, data, icon)
self.plugin = None # Last plugin with focus
self.mode = self.FILE_MODE # By default start in this mode
self.initial_cursors = None # {fullpath: QCursor}
self.initial_path = None # Fullpath of initial active editor
self.initial_widget = None # Initial active editor
self.line_number = None # Selected line number in filer
self.is_visible = False # Is the switcher visible?
help_text = _("Press <b>Enter</b> to switch files or <b>Esc</b> to "
"cancel.<br><br>Type to filter filenames.<br><br>"
"Use <b>:number</b> to go to a line, e.g. "
"<b><code>main:42</code></b><br>"
"Use <b>@symbol_text</b> to go to a symbol, e.g. "
"<b><code>@init</code></b>"
"<br><br> Press <b>Ctrl+W</b> to close current tab.<br>")
# Either allow searching for a line number or a symbol but not both
regex = QRegExp("([A-Za-z0-9_]{0,100}@[A-Za-z0-9_]{0,100})|" +
"([A-Za-z0-9_]{0,100}:{0,1}[0-9]{0,100})")
# Widgets
self.edit = FilesFilterLine(self)
self.help = HelperToolButton()
self.list = QListWidget(self)
self.filter = KeyPressFilter()
regex_validator = QRegExpValidator(regex, self.edit)
# Widgets setup
self.setWindowFlags(Qt.Popup | Qt.FramelessWindowHint)
self.setWindowOpacity(0.95)
self.edit.installEventFilter(self.filter)
self.edit.setValidator(regex_validator)
self.help.setToolTip(help_text)
self.list.setItemDelegate(HTMLDelegate(self))
# Layout
edit_layout = QHBoxLayout()
edit_layout.addWidget(self.edit)
edit_layout.addWidget(self.help)
layout = QVBoxLayout()
layout.addLayout(edit_layout)
layout.addWidget(self.list)
self.setLayout(layout)
# Signals
self.rejected.connect(self.restore_initial_state)
self.filter.sig_up_key_pressed.connect(self.previous_row)
self.filter.sig_down_key_pressed.connect(self.next_row)
self.edit.returnPressed.connect(self.accept)
self.edit.textChanged.connect(self.setup)
self.list.itemSelectionChanged.connect(self.item_selection_changed)
self.list.clicked.connect(self.edit.setFocus)
def __init__(self, main_window, oswebext):
"""
desc:
Constructor.
arguments:
main_window: The main-window object.
"""
super(oswebext_widget,
self).__init__(main_window, ui=u'extensions.oswebext.oswebext')
self._oswebext = oswebext
self.ui.button_test.clicked.connect(self._test)
self.ui.fs_checkBox.toggled.connect(self._run_linter)
self.ui.button_jatos.clicked.connect(self._export_jatos)
self.ui.button_convert.clicked.connect(self._convert_results)
self.ui.plaintextedit_welcome_text.setPlainText(
safe_decode(cfg.oswebext_welcome_text))
self.ui.plaintextedit_welcome_text.textChanged.connect(
lambda: setattr(cfg, 'oswebext_welcome_text',
self.ui.plaintextedit_welcome_text.toPlainText()))
self.ui.plaintextedit_external_js.setPlainText(
safe_decode(cfg.oswebext_external_js))
self.ui.plaintextedit_external_js.textChanged.connect(
lambda: setattr(cfg, 'oswebext_external_js',
self.ui.plaintextedit_external_js.toPlainText()))
self.ui.label_version.setText(__version__)
self.ui.linedit_subject.setValidator(
QRegExpValidator(QRegExp("^(?:\d+(?:-\d+)?(?:,(?!$))?)+")))
self.ui.icon_expsize_warning.setPixmap(
QIcon.fromTheme('emblem-important').pixmap(32, 32))
self._init_widgets()
self._run_linter()
def __init__(self, initial_color=MPL_DEFAULT, parent=None):
super(ColorSelector, self).__init__(parent=parent)
self.initial_color = QColor(initial_color)
# Create line edit and push button and add to a horizontal layout
self.line_edit = QLineEdit(self)
self.button = QPushButton(self)
self.h_layout = QHBoxLayout(self)
self.h_layout.addWidget(self.line_edit)
self.h_layout.addWidget(self.button)
self.h_layout.setContentsMargins(0, 0, 0, 0)
self.line_edit.setText(self.initial_color.name())
self.prev_color = self.initial_color.name()
# Color input only allows valid hex codes.
re = QRegExp('^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$')
validator = ColorValidator(re, self.line_edit, self)
self.line_edit.setValidator(validator)
self.button.setAutoFillBackground(True)
self.button.setFlat(True)
self.update_color_button()
# Signals
self.button.clicked.connect(self.launch_qcolor_dialog)
self.line_edit.textChanged.connect(self.update_color_button)
self.line_edit.editingFinished.connect(
self.convert_three_digit_hex_to_six)
def create_lineedit(self,
text,
default=None,
tip=None,
alignment=Qt.Horizontal,
regex=None,
wrap=True):
label = QLabel(text)
label.setWordWrap(wrap)
edit = QLineEdit()
layout = QHBoxLayout() if alignment == Qt.Horizontal else QVBoxLayout()
layout.addWidget(label)
layout.addWidget(edit)
layout.setContentsMargins(0, 0, 0, 0)
if default:
edit.setText(default)
if tip:
edit.setToolTip(tip)
if regex:
edit.setValidator(QRegExpValidator(QRegExp(regex)))
widget = QWidget(self)
widget.label = label
widget.edit = edit
widget.setLayout(layout)
return widget
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 __init__(self, parent, regex_base=None, key_filter_dict=None):
super(FinderLineEdit, self).__init__(parent)
self.key_filter_dict = key_filter_dict
if regex_base is not None:
# Widget setup
regex = QRegExp(regex_base + "{100}")
self.setValidator(QRegExpValidator(regex))
def __init__(self, *args, **kwargs):
super(ProbeBasicLathe, self).__init__(*args, **kwargs)
self.run_from_line_Num.setValidator(QRegExpValidator(
QRegExp("[0-9]*")))
self.feed_unit_per_minute = 0.0
self.feed_per_rev = 0.0
self.css_sword = 0.0
self.rpm_mode = 0.0
def set_regex(self, regex):
"""
"""
if regex:
self.regex = regex
self.qregex = QRegExp(regex)
validator = QRegExpValidator(self.qregex)
self._text.setValidator(validator)
def createEditor(self, widget, option, index):
if not index.isValid():
return 0
if index.column() == 0: # only on the cells in the first column
editor = QLineEdit(widget)
validator = QRegExpValidator(QRegExp(self.__regex), editor)
editor.setValidator(validator)
return editor
return super(RegexValidator, self).createEditor(widget, option, index)
def __init__(self, *args, **kwargs):
super(ProbeBasicLathe, self).__init__(*args, **kwargs)
self.run_from_line_Num.setValidator(QRegExpValidator(
QRegExp("[0-9]*")))
self.feed_unit_per_minute = 0.0
self.feed_per_rev = 0.0
self.css_sword = 0.0
self.rpm_mode = 0.0
self.btnMdiBksp.clicked.connect(self.mdiBackSpace_clicked)
self.btnMdiSpace.clicked.connect(self.mdiSpace_clicked)
def show_debug_notifications(self):
self.all_button.setChecked(False)
self.info_button.setChecked(False)
self.warn_button.setChecked(False)
self.error_button.setChecked(False)
self.debug_button.setChecked(True)
self.notification_name.setText("Debug Notifications")
self.all_notification_model_proxy.setFilterRegExp(
QRegExp("DEBUG", Qt.CaseSensitive, QRegExp.FixedString))
def __init__(self, parent, callback=None):
super(ShortcutFinder, self).__init__(parent)
self._parent = parent
# Widget setup
regex = QRegExp(VALID_FINDER_CHARS + "{100}")
self.setValidator(QRegExpValidator(regex))
# Signals
if callback:
self.textChanged.connect(callback)
def coord_line_edit(self):
template = QRegExp(r"[-]?\d*\.?\d{0,3}")
validator = QRegExpValidator(template)
line = QLineEdit("0.0")
line.setValidator(validator)
line.setFixedWidth(60)
# line.editingFinished.connect(self.update_dist_to_target)
line.textChanged.connect(self.update_dist_to_target)
return line
def update_format_string(self):
"""
Accept a unit to display with a channel's value
The unit may or may not be displayed based on the :attr:`showUnits`
attribute. Receiving a new value for the unit causes the display to
reset.
"""
if self.channeltype is float:
decimal_point = locale.localeconv()['decimal_point']
# decimal_point = '.'
if self._show_units and self._unit != "":
re = QRegExp('(-?)(0|([1-9][0-9]*))(\\{}[0-9]+)?( {})?'.format(
decimal_point, self._unit))
else:
re = QRegExp(
'(-?)(0|([1-9][0-9]*))(\\{}[0-9]+)?'.format(decimal_point))
validator = QRegExpValidator(re, self)
self.setValidator(validator)
super().update_format_string()
def __init__(self, parent, callback=None, main=None,
regex_base=VALID_FINDER_CHARS):
super(FinderLineEdit, self).__init__(parent)
self._parent = parent
self.main = main
# Widget setup
regex = QRegExp(regex_base + "{100}")
self.setValidator(QRegExpValidator(regex))
# Signals
if callback:
self.textChanged.connect(callback)
def highlight_block(self, text, block):
"""
Highlights the block using a pygments lexer.
:param text: text of the block to highlith
:param block: block to highlight
"""
if self.color_scheme.name != self._pygments_style:
self._pygments_style = self.color_scheme.name
self._update_style()
original_text = text
if self.editor and self._lexer and self.enabled:
if block.blockNumber():
prev_data = self._prev_block.userData()
if prev_data:
if hasattr(prev_data, "syntax_stack"):
self._lexer._saved_state_stack = prev_data.syntax_stack
elif hasattr(self._lexer, '_saved_state_stack'):
del self._lexer._saved_state_stack
# Lex the text using Pygments
index = 0
usd = block.userData()
if usd is None:
usd = TextBlockUserData()
block.setUserData(usd)
tokens = list(self._lexer.get_tokens(text))
for token, text in tokens:
length = len(text)
fmt = self._get_format(token)
if token in [
Token.Literal.String, Token.Literal.String.Doc,
Token.Comment
]:
fmt.setObjectType(fmt.UserObject)
self.setFormat(index, length, fmt)
index += length
if hasattr(self._lexer, '_saved_state_stack'):
setattr(usd, "syntax_stack", self._lexer._saved_state_stack)
# Clean up for the next go-round.
del self._lexer._saved_state_stack
# spaces
text = original_text
expression = QRegExp(r'\s+')
index = expression.indexIn(text, 0)
while index >= 0:
index = expression.pos(0)
length = len(expression.cap(0))
self.setFormat(index, length, self._get_format(Whitespace))
index = expression.indexIn(text, index + length)
self._prev_block = block
def create_textbox(self, label, option, hint=None, regex=None, check=None):
widget = QLineEdit()
widget.setAttribute(Qt.WA_MacShowFocusRect, False)
widget.setMinimumWidth(250)
if regex:
regex_validator = QRegExpValidator(QRegExp(regex))
widget.setValidator(regex_validator)
widget.get_value = lambda w=widget: w.text()
widget.set_value = lambda value, w=widget: w.setText(value)
widget.set_warning = lambda w=widget: w.setSelection(0, 1000)
widget.textChanged.connect(
lambda v=None, w=widget: self.options_changed(widget=w))
self.create_widget(widget=widget,
option=option,
label=label,
hint=hint,
check=check)
def create_lineedit(self,
text,
default=None,
tip=None,
alignment=Qt.Horizontal,
regex=None,
wrap=True):
"""Create line-edit widget.
:param text: key
:type text: str
:param default: default value
:type default: str
:param tip: tool tip
:type tip: str
:param alignment: alignment, horizontal or vertical
:type alignment: Qt
:param regex: regular expression
:type regex: str
:param wrap: wrap text
:type wrap: bool
:return: QWidget
"""
label = QLabel(text)
label.setWordWrap(wrap)
edit = QLineEdit()
layout = QHBoxLayout() if alignment == Qt.Horizontal else QVBoxLayout()
layout.addWidget(label)
layout.addWidget(edit)
layout.setContentsMargins(0, 0, 0, 0)
if default:
edit.setText(default)
if tip:
edit.setToolTip(tip)
if regex:
edit.setValidator(QRegExpValidator(QRegExp(regex)))
widget = QWidget(self)
widget.label = label
widget.edit = edit
widget.setLayout(layout)
return widget
def __init__(self, main_window, oswebext):
"""
desc:
Constructor.
arguments:
main_window: The main-window object.
"""
super(oswebext_widget,
self).__init__(main_window, ui=u'extensions.oswebext.oswebext')
self._oswebext = oswebext
self.ui.button_test.clicked.connect(self._test)
self.ui.button_jatos.clicked.connect(self._export_jatos)
self.ui.button_convert.clicked.connect(self._convert_results)
self.ui.label_version.setText(__version__)
self.ui.linedit_subject.setValidator(
QRegExpValidator(QRegExp("^(?:\d+(?:-\d+)?(?:,(?!$))?)+")))
self.ui.icon_expsize_warning.setPixmap(
QIcon.fromTheme('emblem-important').pixmap(32, 32))
self._run_linter()
def __init__(self, *args, **kwargs):
super(ParametersFrame, self).__init__(*args, **kwargs)
self.setFrameStyle(QFrame.Panel | QFrame.Raised)
self.contentLayout = QGridLayout()
self.setpointVoltageLabel = QLabel("Fixed voltage [3000 to 7000] V")
self.setpointVoltageSettingLabel = QLabel()
self.setpointVoltageInp = QLineEdit()
self.setpointVoltageInp.setMaximumWidth(100)
self.setpointVoltageInp.setValidator(QIntValidator(3000, 7000))
self.setpointVoltageInp.setToolTip("Final voltage setpoint.")
self.setpointVoltageInp.setText("3000")
self.contentLayout.addWidget(self.setpointVoltageLabel, 0, 0, 1, 1)
self.contentLayout.addWidget(self.setpointVoltageInp, 0, 1, 1, 1)
self.contentLayout.addWidget(self.setpointVoltageSettingLabel, 0, 2, 1,
1)
self.stepToFixDelayLabel = QLabel("Step to Fixed delay (mm:ss)")
self.stepToFixDelaySettingLabel = QLabel()
self.stepToFixDelayInp = QLineEdit()
self.stepToFixDelayInp.setMaximumWidth(100)
self.stepToFixDelayInp.setValidator(
QRegExpValidator(QRegExp(MIN_SEC_PATTERN)))
self.stepToFixDelayInp.setToolTip(
"Delay between toStep and toFixed calls.")
self.stepToFixDelayInp.setText("05:00")
self.contentLayout.addWidget(self.stepToFixDelayLabel, 1, 0, 1, 1)
self.contentLayout.addWidget(self.stepToFixDelayInp, 1, 1, 1, 1)
self.contentLayout.addWidget(self.stepToFixDelaySettingLabel, 1, 2, 1,
1)
self.setButton = QPushButton("Confirm")
self.setButton.clicked.connect(self.confirm)
self.setButton.setToolTip("Apply settings")
self.contentLayout.addWidget(self.setButton, 3, 1, 1, 1)
self.setLayout(self.contentLayout)
self.confirm()
def generateRegExpValidator(widget, expression):
rx = QRegExp(expression)
return QRegExpValidator(rx, widget)
def set_regex_validation(self, regex):
"""Set the regular expression to validate content."""
self._regex = regex
self._reg = re.compile(regex, re.IGNORECASE)
validator = QRegExpValidator(QRegExp(regex))
self.lineedit.setValidator(validator)
def __init__(self, *args, **kwargs):
super(ProbeBasic, self).__init__(*args, **kwargs)
self.run_from_line_Num.setValidator(QRegExpValidator(QRegExp("[0-9]*")))
self.dynatc_left.iniFilePrefix = "LEFT_"
self.dynatc_right.iniFilePrefix = "RIGHT_"
