def resizeEvent(self, event):
"""
Reimplement Qt method to be able to save the widget's size from the
main application
"""
QDialog.resizeEvent(self, event)
self.size_change.emit(self.size())
def __init__(self, parent):
QDialog.__init__(self, parent)
self.setWindowTitle("Spyder %s: %s" % (__version__,
_("Dependencies")))
self.setWindowIcon(ima.icon('tooloptions'))
self.setModal(True)
self.treewidget = DependenciesTreeWidget(self)
self.label = QLabel(_("Optional modules are not required to run "
"Spyder but enhance its functions."))
self.label2 = QLabel(_("<b>Note:</b> New dependencies or changed ones "
"will be correctly detected only after Spyder "
"is restarted."))
btn = QPushButton(_("Copy to clipboard"), )
btn.clicked.connect(self.copy_to_clipboard)
bbox = QDialogButtonBox(QDialogButtonBox.Ok)
bbox.accepted.connect(self.accept)
hlayout = QHBoxLayout()
hlayout.addWidget(btn)
hlayout.addStretch()
hlayout.addWidget(bbox)
vlayout = QVBoxLayout()
vlayout.addWidget(self.treewidget)
vlayout.addWidget(self.label)
vlayout.addWidget(self.label2)
vlayout.addLayout(hlayout)
self.setLayout(vlayout)
self.resize(840, 560)
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, parent=None):
QDialog.__init__(self, parent)
self.main = parent
# Widgets
self.pages_widget = QStackedWidget()
self.pages_widget.setMinimumWidth(600)
self.contents_widget = QListWidget()
self.button_reset = QPushButton(_('Reset to defaults'))
bbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Apply |
QDialogButtonBox.Cancel)
self.apply_btn = bbox.button(QDialogButtonBox.Apply)
# Widgets setup
# Destroying the C++ object right after closing the dialog box,
# otherwise it may be garbage-collected in another QThread
# (e.g. the editor's analysis thread in Spyder), thus leading to
# a segmentation fault on UNIX or an application crash on Windows
self.setAttribute(Qt.WA_DeleteOnClose)
self.setWindowTitle(_('Preferences'))
self.setWindowIcon(ima.icon('configure'))
self.contents_widget.setMovement(QListView.Static)
self.contents_widget.setSpacing(1)
self.contents_widget.setCurrentRow(0)
self.contents_widget.setMinimumWidth(220)
self.contents_widget.setMinimumHeight(400)
# Layout
hsplitter = QSplitter()
hsplitter.addWidget(self.contents_widget)
hsplitter.addWidget(self.pages_widget)
hsplitter.setStretchFactor(0, 1)
hsplitter.setStretchFactor(1, 2)
btnlayout = QHBoxLayout()
btnlayout.addWidget(self.button_reset)
btnlayout.addStretch(1)
btnlayout.addWidget(bbox)
vlayout = QVBoxLayout()
vlayout.addWidget(hsplitter)
vlayout.addLayout(btnlayout)
self.setLayout(vlayout)
# Signals and slots
if self.main:
self.button_reset.clicked.connect(self.main.reset_spyder)
self.pages_widget.currentChanged.connect(self.current_page_changed)
self.contents_widget.currentRowChanged.connect(
self.pages_widget.setCurrentIndex)
bbox.accepted.connect(self.accept)
bbox.rejected.connect(self.reject)
bbox.clicked.connect(self.button_clicked)
# Ensures that the config is present on spyder first run
CONF.set('main', 'interface_language', load_lang_conf())
def reject(self):
'''
Stops any sound that is playing and exits.
'''
if self.__sound is not None and not self.__sound.isFinished():
self.__sound.stop()
self.__sound = None
QDialog.reject(self)
def accept(self):
'''
Applies the changes to the master/slaves.
'''
self.__signal_model.free_all()
for master_name, slaves in self.__model.rows.items():
self.__signal_model.enslave(master_name, slaves)
QDialog.accept(self)
def accept(self):
"""Reimplement Qt method"""
if not self.runconfigoptions.is_valid():
return
configurations = _get_run_configurations()
configurations.insert(0, (self.filename, self.runconfigoptions.get()))
_set_run_configurations(configurations)
QDialog.accept(self)
def accept(self):
"""Reimplement Qt method"""
for index in range(self.pages_widget.count()):
configpage = self.get_page(index)
if not configpage.is_valid():
return
configpage.apply_changes()
QDialog.accept(self)
def accept(self):
"""Reimplement Qt method"""
for index in range(self.pages_widget.count()):
configpage = self.get_page(index)
if not configpage.is_valid():
return
configpage.apply_changes()
QDialog.accept(self)
def accept(self):
"""Reimplement Qt method"""
if not self.runconfigoptions.is_valid():
return
configurations = _get_run_configurations()
configurations.insert(0, (self.filename, self.runconfigoptions.get()))
_set_run_configurations(configurations)
QDialog.accept(self)
def __init__(self, text, title='', font=None, parent=None,
readonly=False, size=(400, 300)):
QDialog.__init__(self, parent)
# Destroying the C++ object right after closing the dialog box,
# otherwise it may be garbage-collected in another QThread
# (e.g. the editor's analysis thread in Spyder), thus leading to
# a segmentation fault on UNIX or an application crash on Windows
self.setAttribute(Qt.WA_DeleteOnClose)
self.text = None
self.btn_save_and_close = None
# Display text as unicode if it comes as bytes, so users see
# its right representation
if is_binary_string(text):
self.is_binary = True
text = to_text_string(text, 'utf8')
else:
self.is_binary = False
self.layout = QVBoxLayout()
self.setLayout(self.layout)
# Text edit
self.edit = QTextEdit(parent)
self.edit.setReadOnly(readonly)
self.edit.textChanged.connect(self.text_changed)
self.edit.setPlainText(text)
if font is None:
font = get_font()
self.edit.setFont(font)
self.layout.addWidget(self.edit)
# Buttons configuration
btn_layout = QHBoxLayout()
btn_layout.addStretch()
if not readonly:
self.btn_save_and_close = QPushButton(_('Save and Close'))
self.btn_save_and_close.setDisabled(True)
self.btn_save_and_close.clicked.connect(self.accept)
btn_layout.addWidget(self.btn_save_and_close)
self.btn_close = QPushButton(_('Close'))
self.btn_close.setAutoDefault(True)
self.btn_close.setDefault(True)
self.btn_close.clicked.connect(self.reject)
btn_layout.addWidget(self.btn_close)
self.layout.addLayout(btn_layout)
# Make the dialog act as a window
self.setWindowFlags(Qt.Window)
self.setWindowIcon(ima.icon('edit'))
self.setWindowTitle(_("Text editor") + \
"%s" % (" - "+str(title) if str(title) else ""))
self.resize(size[0], size[1])
def __init__(self, parent=None, objname=None):
QDialog.__init__(self, parent)
# If used for data object in tree, the main is the tree widget.
self.parent = parent
self.objname = objname
# Widgets
self.pages_widget = QStackedWidget()
self.contents_widget = QListWidget()
self.button_reset = QPushButton(_('Reset to defaults'))
bbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Apply |
QDialogButtonBox.Cancel)
self.apply_btn = bbox.button(QDialogButtonBox.Apply)
# Widgets setup
# Destroying the C++ object right after closing the dialog box,
# otherwise it may be garbage-collected in another QThread
# (e.g. the editor's analysis thread in Ezcad), thus leading to
# a segmentation fault on UNIX or an application crash on Windows
self.setAttribute(Qt.WA_DeleteOnClose)
if self.objname is None:
self.setWindowTitle(_('Preferences'))
else:
self.setWindowTitle(_('Preferences of ') + self.objname)
self.setWindowIcon(ima.icon('configure'))
self.contents_widget.setMovement(QListView.Static)
self.contents_widget.setSpacing(1)
self.contents_widget.setCurrentRow(0)
# Layout
hsplitter = QSplitter()
hsplitter.addWidget(self.contents_widget)
hsplitter.addWidget(self.pages_widget)
hsplitter.setSizes([150,500])
btnlayout = QHBoxLayout()
btnlayout.addWidget(self.button_reset)
btnlayout.addStretch(1)
btnlayout.addWidget(bbox)
vlayout = QVBoxLayout()
vlayout.addWidget(hsplitter)
vlayout.addLayout(btnlayout)
self.setLayout(vlayout)
# Signals and slots
self.pages_widget.currentChanged.connect(self.current_page_changed)
self.contents_widget.currentRowChanged.connect(
self.pages_widget.setCurrentIndex)
bbox.accepted.connect(self.accept)
bbox.rejected.connect(self.reject)
bbox.clicked.connect(self.button_clicked)
# Ensures that the config is present on ezcad first run
CONF.set('main', 'interface_language', load_lang_conf())
def __init__(
self,
title="Title",
description="Description",
unique_names=None,
choose_from_list=False,
):
QDialog.__init__(self)
self.setModal(True)
self.setWindowTitle(title)
# self.setMinimumWidth(250)
# self.setMinimumHeight(150)
if unique_names is None:
unique_names = []
self.unique_names = unique_names
self.choose_from_list = choose_from_list
self.layout = QFormLayout()
self.layout.setSizeConstraint(QLayout.SetFixedSize)
label = QLabel(description)
label.setAlignment(Qt.AlignHCenter)
self.layout.addRow(self.createSpace(5))
self.layout.addRow(label)
self.layout.addRow(self.createSpace(10))
buttons = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel, Qt.Horizontal, self)
self.ok_button = buttons.button(QDialogButtonBox.Ok)
self.ok_button.setEnabled(False)
if choose_from_list:
self.param_name_combo = QComboBox()
self.param_name.currentIndexChanged.connect(self.validateChoice)
for item in unique_names:
self.param_name_combo.addItem(item)
self.layout.addRow("Job:", self.param_name_combo)
else:
self.param_name = QLineEdit(self)
self.param_name.setFocus()
self.param_name.textChanged.connect(self.validateName)
self.validColor = self.param_name.palette().color(
self.param_name.backgroundRole())
self.layout.addRow("Name:", self.param_name)
self.layout.addRow(self.createSpace(10))
self.layout.addRow(buttons)
buttons.accepted.connect(self.accept)
buttons.rejected.connect(self.reject)
self.setLayout(self.layout)
def __init__(self, parent=None):
QDialog.__init__(self, parent)
# Destroying the C++ object right after closing the dialog box,
# otherwise it may be garbage-collected in another QThread
# (e.g. the editor's analysis thread in Spyder), thus leading to
# a segmentation fault on UNIX or an application crash on Windows
self.setAttribute(Qt.WA_DeleteOnClose)
self.is_series = False
self.layout = None
def __init__(self, control, code):
QDialog.__init__(self, None)
self.setupUi(self)
self.bOK.clicked.connect(self.runOK)
self.bCANCEL.clicked.connect(self.runCANCEL)
self.bInfo.setDisabled(True)
self._text = ''
self._control = control
self._code = 0
def __init__(self):
QDialog.__init__(self, None)
self.setupUi(self)
self.bClose.clicked.connect(self.leave)
self.bClear.clicked.connect(self.clear)
self.setWindowTitle("%s: Log" % OCTXT._ToolName)
self.eLog.setReadOnly(True)
self.eLog.setAcceptRichText(False)
self.eLog.setStyleSheet("font: 12pt \"Courier\";")
def setup_actions(self, target: QtWidgets.QDialog) -> None:
undo_action = self.createUndoAction(target)
undo_action.setShortcuts(QtGui.QKeySequence.Undo)
redo_action = self.createRedoAction(target)
redo_action.setShortcuts(QtGui.QKeySequence.Redo)
target.addAction(undo_action)
target.addAction(redo_action)
def __init__(self, parent=None):
QDialog.__init__(self, parent)
# Destroying the C++ object right after closing the dialog box,
# otherwise it may be garbage-collected in another QThread
# (e.g. the editor's analysis thread in Spyder), thus leading to
# a segmentation fault on UNIX or an application crash on Windows
self.setAttribute(Qt.WA_DeleteOnClose)
self.is_series = False
self.layout = None
def __init__(self):
QDialog.__init__(self)
self.ui = Ui_MovieSettings()
self.ui.setupUi(self)
self.actualizePreview()
self.ui.txtMSOutFormat.textChanged[str].connect(self.actualizePreview)
self.ui.txtMSOutFormat.setText(guiConfig['movie_output_format'])
self.ui.buttonBox.accepted.connect(self.accepted)
def __init__(self, numbersOnly: bool):
QDialog.__init__(self)
self.ui = Ui_SetId()
self.ui.setupUi(self)
self.ui.btnOk.accepted.connect(self.accepted)
if numbersOnly:
self.ui.txtId.setInputMask("99999999")
def __init__(self, url, version, win_parent=None):
self.win_parent = win_parent
self.url = url
self.version = version
QDialog.__init__(self, win_parent)
self.setWindowTitle('pyNastran Update')
self.create_widgets()
self.create_layout()
self.set_connections()
def accept(self):
"""Reimplement Qt method."""
try:
for index in range(self.stack.count()):
self.stack.widget(index).accept_changes()
QDialog.accept(self)
except RuntimeError:
# Sometimes under CI testing the object the following error appears
# RuntimeError: wrapped C/C++ object has been deleted
pass
def __init__(self,
parent=None,
pathlist=None,
ro_pathlist=None,
not_active_pathlist=None,
sync=True):
QDialog.__init__(self, parent)
# Destroying the C++ object right after closing the dialog box,
# otherwise it may be garbage-collected in another QThread
# (e.g. the editor's analysis thread in Spyder), thus leading to
# a segmentation fault on UNIX or an application crash on Windows
self.setAttribute(Qt.WA_DeleteOnClose)
assert isinstance(pathlist, list)
self.pathlist = pathlist
if not_active_pathlist is None:
not_active_pathlist = []
self.not_active_pathlist = not_active_pathlist
if ro_pathlist is None:
ro_pathlist = []
self.ro_pathlist = ro_pathlist
self.last_path = getcwd_or_home()
self.setWindowTitle(_("PYTHONPATH manager"))
self.setWindowIcon(ima.icon('pythonpath'))
self.resize(500, 300)
self.selection_widgets = []
layout = QVBoxLayout()
self.setLayout(layout)
top_layout = QHBoxLayout()
layout.addLayout(top_layout)
self.toolbar_widgets1 = self.setup_top_toolbar(top_layout)
self.listwidget = QListWidget(self)
self.listwidget.currentRowChanged.connect(self.refresh)
self.listwidget.itemChanged.connect(self.update_not_active_pathlist)
layout.addWidget(self.listwidget)
bottom_layout = QHBoxLayout()
layout.addLayout(bottom_layout)
self.sync_button = None
self.toolbar_widgets2 = self.setup_bottom_toolbar(bottom_layout, sync)
# Buttons configuration
bbox = QDialogButtonBox(QDialogButtonBox.Close)
bbox.rejected.connect(self.reject)
bottom_layout.addWidget(bbox)
self.update_list()
self.refresh()
def __init__(self, configuration_path, parent=None):
QDialog.__init__(self, parent)
self.setModal(True)
self.setWindowTitle("New configuration file")
self.setMinimumWidth(250)
self.setMinimumHeight(150)
layout = QFormLayout()
directory, filename = os.path.split(configuration_path)
if directory.strip() == "":
directory = os.path.abspath(os.curdir)
self.configuration_path = "%s/%s" % (directory, filename)
else:
self.configuration_path = configuration_path
configuration_location = QLabel()
configuration_location.setText(directory)
configuration_name = QLabel()
configuration_name.setText(filename)
self.db_type = QComboBox()
self.db_type.addItem("BLOCK_FS")
self.db_type.addItem("PLAIN")
self.num_realizations = QSpinBox()
self.num_realizations.setMinimum(1)
self.num_realizations.setMaximum(1000)
self.num_realizations.setValue(10)
self.storage_path = QLineEdit()
self.storage_path.setText("Storage")
self.storage_path.textChanged.connect(self._validateName)
layout.addRow(createSpace(10))
layout.addRow("Configuration name:", configuration_name)
layout.addRow("Configuration location:", configuration_location)
layout.addRow("Path to store DBase:", self.storage_path)
layout.addRow("DBase type:", self.db_type)
layout.addRow("Number of realizations", self.num_realizations)
layout.addRow(createSpace(10))
buttons = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel, Qt.Horizontal, self)
self.ok_button = buttons.button(QDialogButtonBox.Ok)
layout.addRow(buttons)
buttons.accepted.connect(self.accept)
buttons.rejected.connect(self.reject)
self.setLayout(layout)
def __init__(self,
text,
title='',
font=None,
parent=None,
readonly=False,
size=(400, 300)):
QDialog.__init__(self, parent)
# Destroying the C++ object right after closing the dialog box,
# otherwise it may be garbage-collected in another QThread
# (e.g. the editor's analysis thread in Spyder), thus leading to
# a segmentation fault on UNIX or an application crash on Windows
self.setAttribute(Qt.WA_DeleteOnClose)
self.text = None
# Display text as unicode if it comes as bytes, so users see
# its right representation
if is_binary_string(text):
self.is_binary = True
text = to_text_string(text, 'utf8')
else:
self.is_binary = False
self.layout = QVBoxLayout()
self.setLayout(self.layout)
# Text edit
self.edit = QTextEdit(parent)
self.edit.textChanged.connect(self.text_changed)
self.edit.setReadOnly(readonly)
self.edit.setPlainText(text)
if font is None:
font = get_font()
self.edit.setFont(font)
self.layout.addWidget(self.edit)
# Buttons configuration
buttons = QDialogButtonBox.Ok
if not readonly:
buttons = buttons | QDialogButtonBox.Cancel
bbox = QDialogButtonBox(buttons)
bbox.accepted.connect(self.accept)
bbox.rejected.connect(self.reject)
self.layout.addWidget(bbox)
# Make the dialog act as a window
self.setWindowFlags(Qt.Window)
self.setWindowIcon(ima.icon('edit'))
self.setWindowTitle(_("Text editor") + \
"%s" % (" - "+str(title) if str(title) else ""))
self.resize(size[0], size[1])
def __init__(self, editor):
QDialog.__init__(self, editor, Qt.WindowTitleHint
| Qt.WindowCloseButtonHint)
# Destroying the C++ object right after closing the dialog box,
# otherwise it may be garbage-collected in another QThread
# (e.g. the editor's analysis thread in Spyder), thus leading to
# a segmentation fault on UNIX or an application crash on Windows
self.setAttribute(Qt.WA_DeleteOnClose)
self.lineno = None
self.editor = editor
self.setWindowTitle(_("Editor"))
self.setModal(True)
label = QLabel(_("Go to line:"))
self.lineedit = QLineEdit()
validator = QIntValidator(self.lineedit)
validator.setRange(1, editor.get_line_count())
self.lineedit.setValidator(validator)
self.lineedit.textChanged.connect(self.text_has_changed)
cl_label = QLabel(_("Current line:"))
cl_label_v = QLabel("<b>%d</b>" % editor.get_cursor_line_number())
last_label = QLabel(_("Line count:"))
last_label_v = QLabel("%d" % editor.get_line_count())
glayout = QGridLayout()
glayout.addWidget(label, 0, 0, Qt.AlignVCenter | Qt.AlignRight)
glayout.addWidget(self.lineedit, 0, 1, Qt.AlignVCenter)
glayout.addWidget(cl_label, 1, 0, Qt.AlignVCenter | Qt.AlignRight)
glayout.addWidget(cl_label_v, 1, 1, Qt.AlignVCenter)
glayout.addWidget(last_label, 2, 0, Qt.AlignVCenter | Qt.AlignRight)
glayout.addWidget(last_label_v, 2, 1, Qt.AlignVCenter)
bbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel,
Qt.Vertical, self)
bbox.accepted.connect(self.accept)
bbox.rejected.connect(self.reject)
btnlayout = QVBoxLayout()
btnlayout.addWidget(bbox)
btnlayout.addStretch(1)
ok_button = bbox.button(QDialogButtonBox.Ok)
ok_button.setEnabled(False)
self.lineedit.textChanged.connect(
lambda text: ok_button.setEnabled(len(text) > 0))
layout = QHBoxLayout()
layout.addLayout(glayout)
layout.addLayout(btnlayout)
self.setLayout(layout)
self.lineedit.setFocus()
def __init__(self, parent=None):
self.parent = parent
QDialog.__init__(self, parent=parent)
self.ui = load_ui('filter_rule_editor.ui', baseinstance=self)
#self.ui = UiDialog()
#self.ui.setupUi(self)
self.init_widgets()
self.load_global_rule_dict()
self.refresh_global_rule()
self.check_widgets()
def __init__(self, parent=None):
QDialog.__init__(self, parent)
# Destroying the C++ object right after closing the dialog box,
# otherwise it may be garbage-collected in another QThread
# (e.g. the editor's analysis thread in TRex), thus leading to
# a segmentation fault on UNIX or an application crash on Windows
self.setAttribute(Qt.WA_DeleteOnClose)
self.setWindowIcon(ima.icon('run_settings'))
layout = QVBoxLayout()
self.setLayout(layout)
def accept(self):
'''
Executes the ffmpeg command.
'''
if self.__extracted is False:
self.__extract()
if not self.__is_remux:
self.signalName.setEnabled(True)
self.signalNameLabel.setEnabled(True)
else:
if self.__create_signals():
QDialog.accept(self)
def __init__(self, parent=None, filename=''):
self.filename = filename
self.parent = parent
QDialog.__init__(self, parent=parent)
self.ui = load_ui('list_of_scan_loader_dialog.ui', baseinstance=self)
self.init_widgets()
short_filename = os.path.basename(filename)
self.setWindowTitle("Options to load {}".format(short_filename))
self.parent.ascii_loader_option = None
def accept(self):
"""Reimplement Qt method"""
configurations = []
for index in range(self.stack.count()):
filename = to_text_string(self.combo.itemText(index))
runconfigoptions = self.stack.widget(index)
if index == self.stack.currentIndex() and not runconfigoptions.is_valid():
return
options = runconfigoptions.get()
configurations.append((filename, options))
_set_run_configurations(configurations)
QDialog.accept(self)
def __init__(self, appdata: CnaData, centralwidget: CentralWidget):
QDialog.__init__(self)
self.setWindowTitle("Yield optimization")
self.appdata = appdata
self.centralwidget = centralwidget
self.eng = appdata.engine
self.linear_re = re.compile(
r'([ ]*(?P<factor1>[-]?\d*)[ ]*[*]?[ ]*(?P<reac_id>[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVW]+\w*)[ ]*[*]?[ ]*(?P<factor2>[-]?\d*)[ ]*)'
)
completer = QCompleter(
self.appdata.project.cobra_py_model.reactions.list_attr("id"),
self)
completer.setCaseSensitivity(Qt.CaseInsensitive)
self.layout = QVBoxLayout()
l = QLabel(
"Define the yield function Y=c*r/d*r by providing c and d as linear expression of form: \n \
id_1 * w_1 + ... id_n * w_n\n \
Where id_x are reaction ids and w_x optional weighting factor\n"
)
self.layout.addWidget(l)
t1 = QLabel("Define c")
self.layout.addWidget(t1)
self.c = CompleterLineEdit(
self.appdata.project.cobra_py_model.reactions.list_attr("id"), "")
self.c.setCompleter(completer)
self.c.setPlaceholderText("")
self.layout.addWidget(self.c)
t2 = QLabel("Define d")
self.layout.addWidget(t2)
self.d = CompleterLineEdit(
self.appdata.project.cobra_py_model.reactions.list_attr("id"), "")
self.d.setPlaceholderText("")
self.d.setCompleter(completer)
self.layout.addWidget(self.d)
l3 = QHBoxLayout()
self.button = QPushButton("Compute")
self.cancel = QPushButton("Close")
l3.addWidget(self.button)
l3.addWidget(self.cancel)
self.layout.addItem(l3)
self.setLayout(self.layout)
# Connecting the signal
self.c.textChangedX.connect(self.validate_dialog)
self.d.textChangedX.connect(self.validate_dialog)
self.cancel.clicked.connect(self.reject)
self.button.clicked.connect(self.compute)
self.validate_dialog()
def set_bounds(self):
dialog = QDialog()
loadUi(os.path.join(UI_PATH, "roi_bounds_dialog.ui"), dialog)
dialog.min_line_edit.setText("{:g}".format(self.getRegion()[0]))
dialog.max_line_edit.setText("{:g}".format(self.getRegion()[-1]))
if dialog.exec_():
self.setRegion([
float(dialog.min_line_edit.text()),
float(dialog.max_line_edit.text())
])
def accept(self):
"""Reimplement Qt method"""
configurations = []
for index in range(self.stack.count()):
filename = to_text_string(self.combo.itemText(index))
runconfigoptions = self.stack.widget(index)
if index == self.stack.currentIndex() and\
not runconfigoptions.is_valid():
return
options = runconfigoptions.get()
configurations.append( (filename, options) )
_set_run_configurations(configurations)
QDialog.accept(self)
def __init__(self, instrument_list=None):
QDialog.__init__(self)
self.ui = load_ui(__file__, 'ui/instrument_dialog.ui', baseinstance=self)
self.instrument_list = instrument_list
self.instr_combo.clear()
self.facility_combo.clear()
instruments = sorted(INSTRUMENT_DICT.keys())
instruments.reverse()
for facility in instruments:
self.facility_combo.addItem(facility)
self._facility_changed(instruments[0])
self.facility_combo.activated.connect(self._facility_changed)
def __init__(self, parent):
QDialog.__init__(self, parent)
self.vtk_widget = parent
ui = self.ui = get_ui('distributed.ui', self)
self.setWindowTitle('Distribution Wizard')
ui.pushbutton_close.clicked.connect(self.close)
ui.pushbutton_apply.clicked.connect(self.apply_)
ui.combobox_distribution.currentIndexChanged.connect(self.dist_changed)
ui.pushbutton_close.setFocus(False)
def show_about_dialog(parent: QWidget = None) -> None:
label = QLabel()
label.setText("Digital pathology for local <i>in vivo</i> drug delivery.")
layout = QHBoxLayout()
layout.addWidget(label)
dialog = QDialog(parent=parent)
dialog.setWindowModality(Qt.ApplicationModal)
dialog.setLayout(layout)
dialog.setWindowTitle("About")
dialog.exec_()
def __init__(self, parent=None, pathlist=None, ro_pathlist=None,
not_active_pathlist=None, sync=True):
QDialog.__init__(self, parent)
# Destroying the C++ object right after closing the dialog box,
# otherwise it may be garbage-collected in another QThread
# (e.g. the editor's analysis thread in Spyder), thus leading to
# a segmentation fault on UNIX or an application crash on Windows
self.setAttribute(Qt.WA_DeleteOnClose)
assert isinstance(pathlist, list)
self.pathlist = pathlist
if not_active_pathlist is None:
not_active_pathlist = []
self.not_active_pathlist = not_active_pathlist
if ro_pathlist is None:
ro_pathlist = []
self.ro_pathlist = ro_pathlist
self.last_path = getcwd()
self.setWindowTitle(_("PYTHONPATH manager"))
self.setWindowIcon(ima.icon('pythonpath'))
self.resize(500, 300)
self.selection_widgets = []
layout = QVBoxLayout()
self.setLayout(layout)
top_layout = QHBoxLayout()
layout.addLayout(top_layout)
self.toolbar_widgets1 = self.setup_top_toolbar(top_layout)
self.listwidget = QListWidget(self)
self.listwidget.currentRowChanged.connect(self.refresh)
self.listwidget.itemChanged.connect(self.update_not_active_pathlist)
layout.addWidget(self.listwidget)
bottom_layout = QHBoxLayout()
layout.addLayout(bottom_layout)
self.sync_button = None
self.toolbar_widgets2 = self.setup_bottom_toolbar(bottom_layout, sync)
# Buttons configuration
bbox = QDialogButtonBox(QDialogButtonBox.Close)
bbox.rejected.connect(self.reject)
bottom_layout.addWidget(bbox)
self.update_list()
self.refresh()
def __init__(self, instrument_list=None):
QDialog.__init__(self)
self.ui = load_ui(__file__, 'ui/instrument_dialog.ui', baseinstance=self)
self.instrument_list = instrument_list
self.instr_combo.clear()
self.facility_combo.clear()
facilities = sorted([fac for fac in INSTRUMENT_DICT.keys() if
any([inst in INSTRUMENT_DICT[fac] for inst in instrument_list])])
facilities.reverse()
for facility in facilities:
self.facility_combo.addItem(facility)
self._facility_changed(facilities[0])
self.facility_combo.activated.connect(self._facility_changed)
def __init__(self, autosave_dir, autosave_mapping, parent=None):
"""Constructor."""
QDialog.__init__(self, parent)
self.layout = QVBoxLayout(self)
self.setLayout(self.layout)
self.layout.setSpacing(self.layout.spacing() * 3)
self.autosave_dir = autosave_dir
self.autosave_mapping = autosave_mapping
self.files_to_open = []
self.gather_data()
self.add_label()
self.add_table()
self.add_cancel_button()
self.setWindowTitle(_('Recover from autosave'))
def ProxyDialog(self):
def SetProxy():
self.use_proxy = bool(self.checkUseProxy.isChecked())
self.proxy_config = self.textProxyConfig.text()
if os.environ['QT_API'] == 'pyqt':
self.settings.setValue("use_proxy", self.use_proxy)
self.settings.setValue("proxy_config", str(self.proxy_config))
elif os.environ['QT_API'] == 'pyqt5':
self.settings.setValue("use_proxy",
QtCore.QVariant(self.use_proxy))
self.settings.setValue("proxy_config",
QtCore.QVariant(str(self.proxy_config)))
d.done(0)
d = QDialog()
box = QVBoxLayout()
hBox_proxy = QHBoxLayout()
hBox_proxy.setSpacing(5)
label = QLabel('Proxy')
hBox_proxy.addWidget(label)
self.textProxyConfig = QLineEdit()
try:
self.textProxyConfig.setText(
self.settings.value('proxy_config', str))
except:
self.textProxyConfig.setText(bombo.PROXY_DATA)
self.textProxyConfig.setMinimumWidth(200)
hBox_proxy.addWidget(self.textProxyConfig)
box.addLayout(hBox_proxy)
self.checkUseProxy = QCheckBox("Use proxy")
try:
self.checkUseProxy.setChecked(
self.settings.value('use_proxy', bool))
except:
self.checkUseProxy.setChecked(bool(bombo.USE_PROXY))
box.addWidget(self.checkUseProxy)
button = QPushButton("Save configuration")
button.clicked.connect(SetProxy)
box.addWidget(button)
d.setWindowTitle("Proxy configuration")
d.setLayout(box)
d.setWindowModality(QtCore.Qt.ApplicationModal)
d.exec_()
def __init__(self, parent=None, father=None):
self.parent = parent
self.father = father
QDialog.__init__(self, parent=parent)
self.ui = load_ui('launchMantid.ui', baseinstance=self)
_title = "Launching Mantid Reduction"
self.setWindowTitle(_title)
_runs = self.father.parameters['runs']
nbr_jobs = len(_runs)
_message = 'You are about to launch {} Mantid Reductions jobs!'.format(nbr_jobs)
self.ui.label.setText(_message)
def reject(self):
""" """
if self.busy:
answer = QMessageBox.question(
self,
'Quit Conda Manager?',
'Conda is still busy.\n\nDo you want to quit?',
buttons=QMessageBox.Yes | QMessageBox.No)
if answer == QMessageBox.Yes:
QDialog.reject(self)
# Do some cleanup?
else:
QDialog.reject(self)
def keyPressEvent(self, event):
"""
Qt override.
"""
QToolTip.hideText()
ctrl = event.modifiers() & Qt.ControlModifier
if event.key() in [Qt.Key_Enter, Qt.Key_Return]:
if ctrl:
self.process_text(array=False)
else:
self.process_text(array=True)
self.accept()
else:
QDialog.keyPressEvent(self, event)
def __init__(self, ui_module, parent, modal=True, connect_actions=True):
self.gui = parent
QtGuiApplication.__init__(self, ui_module)
QDialog.__init__(self, parent)
self.modal = modal
self.setModal(modal)
try:
self.ui = ui_module.Ui_Form()
self.setupUI(self)
except:
self.compile_ui(ui_module, True)
self.ui = ui_module.Ui_Form()
self.setupUI(self)
if connect_actions:
self.connect_actions()
def onHelp(self):
"""
Shows the help page
"""
try:
from pymantidplot.proxies import showCustomInterfaceHelp
showCustomInterfaceHelp("PyChop")
except ImportError:
helpTxt = "PyChop is a tool to allow direct inelastic neutron\nscattering users to estimate the inelastic resolution\n"
helpTxt += "and incident flux for a given spectrometer setting.\n\nFirst select the instrument, chopper settings and\n"
helpTxt += "Ei, and then click 'Calculate and Plot'. Data for all\nthe graphs will be generated (may take 1-2s) and\n"
helpTxt += "all graphs will be updated. If the 'Hold current plot'\ncheck box is ticked, additional settings will be\n"
helpTxt += "overplotted on the existing graphs if they are\ndifferent from previous settings.\n\nMore in-depth help "
helpTxt += "can be obtained from the\nMantid help pages."
self.hlpwin = QDialog()
self.hlpedt = QLabel(helpTxt)
self.hlpbtn = QPushButton('OK')
self.hlpwin.layout = QVBoxLayout(self.hlpwin)
self.hlpwin.layout.addWidget(self.hlpedt)
self.hlpwin.layout.addWidget(self.hlpbtn)
self.hlpbtn.clicked.connect(self.hlpwin.deleteLater)
self.hlpwin.setWindowTitle('Help')
self.hlpwin.setWindowModality(Qt.ApplicationModal)
self.hlpwin.setAttribute(Qt.WA_DeleteOnClose)
self.hlpwin.setMinimumSize(370, 300)
self.hlpwin.resize(370, 300)
self.hlpwin.show()
self.hlploop = QEventLoop()
self.hlploop.exec_()
def showText(self):
"""
Creates a dialog to show the generated text output.
"""
try:
generatedText = self.genText()
except ValueError:
return
self.txtwin = QDialog()
self.txtedt = QTextEdit()
self.txtbtn = QPushButton('OK')
self.txtwin.layout = QVBoxLayout(self.txtwin)
self.txtwin.layout.addWidget(self.txtedt)
self.txtwin.layout.addWidget(self.txtbtn)
self.txtbtn.clicked.connect(self.txtwin.deleteLater)
self.txtedt.setText(generatedText)
self.txtedt.setReadOnly(True)
self.txtwin.setWindowTitle('Resolution information')
self.txtwin.setWindowModality(Qt.ApplicationModal)
self.txtwin.setAttribute(Qt.WA_DeleteOnClose)
self.txtwin.setMinimumSize(400, 600)
self.txtwin.resize(400, 600)
self.txtwin.show()
self.txtloop = QEventLoop()
self.txtloop.exec_()
def __init__(self, parent=None):
QDialog.__init__(self, parent)
# Destroying the C++ object right after closing the dialog box,
# otherwise it may be garbage-collected in another QThread
# (e.g. the editor's analysis thread in Spyder), thus leading to
# a segmentation fault on UNIX or an application crash on Windows
self.setAttribute(Qt.WA_DeleteOnClose)
self.data = None
self.arraywidget = None
self.stack = None
self.layout = None
# Values for 3d array editor
self.dim_indexes = [{}, {}, {}]
self.last_dim = 0 # Adjust this for changing the startup dimension
def cancel_process(self):
"""
Allow user to cancel an ongoing process.
"""
logger.debug(str('process canceled by user.'))
if self.busy:
dlg = self.cancel_dialog()
reply = dlg.exec_()
if reply:
self.update_status(hide=False, message='Process cancelled')
self.api.conda_terminate()
self.api.download_requests_terminate()
self.api.conda_clear_lock()
self.table.clear_actions()
self.sig_process_cancelled.emit()
else:
QDialog.reject(self)
def __init__(self, parent=None, key=None, data_type='sample'):
self.parent = parent
self.key = key
self.data_type = data_type
QDialog.__init__(self, parent=parent)
self.ui = load_ui('dimensions_setter.ui', baseinstance=self)
self.group_widgets()
self.init_widgets_layout()
self.init_widgets_content()
if parent.geometry_ui_position:
self.move(parent.geometry_ui_position)
self.check_save_button()
self.set_column_index()
def _ask_overwrite(self):
msg = QDialog()
msg.setWindowTitle('Load overwrite')
layout = QGridLayout()
layout.addWidget(QLabel('Instrument %s already exists in memory. Overwrite this?'), 0, 0, 1, -1)
buttons = [QPushButton(label) for label in ['Load and overwrite', 'Cancel Load', 'Load and rename to']]
locations = [[1, 0], [1, 1], [2, 0]]
self.overwrite_flag = 1
def overwriteCB(idx):
self.overwrite_flag = idx
msg.accept()
for idx, button in enumerate(buttons):
button.clicked.connect(lambda _, idx=idx: overwriteCB(idx))
layout.addWidget(button, locations[idx][0], locations[idx][1])
newname = QLineEdit()
newname.editingFinished.connect(lambda: overwriteCB(2))
layout.addWidget(newname, 2, 1)
msg.setLayout(layout)
msg.exec_()
newname = str(newname.text())
if not newname or newname in self.instruments:
self.errormessage('Invalid instrument name. Cancelling load.')
self.overwrite_flag = 1
return self.overwrite_flag, newname
def __init__(self, parent):
QDialog.__init__(self, parent)
self.setWindowTitle("Spyder %s: %s" % (__version__,
_("Dependencies")))
self.setWindowIcon(ima.icon('tooloptions'))
self.setModal(True)
self.view = DependenciesTableView(self, [])
opt_mods = ['NumPy', 'Matplotlib', 'Pandas', 'SymPy']
self.label = QLabel(_("Spyder depends on several Python modules to "
"provide the right functionality for all its "
"panes. The table below shows the required "
"and installed versions (if any) of all of "
"them.<br><br>"
"<b>Note</b>: You can safely use Spyder "
"without the following modules installed: "
"<b>%s</b> and <b>%s</b>.<br><br>"
"Please also note that new "
"dependencies or changed ones will be correctly "
"detected only after Spyder is restarted.")
% (', '.join(opt_mods[:-1]), opt_mods[-1]))
self.label.setWordWrap(True)
self.label.setAlignment(Qt.AlignJustify)
self.label.setContentsMargins(5, 8, 12, 10)
btn = QPushButton(_("Copy to clipboard"), )
btn.clicked.connect(self.copy_to_clipboard)
bbox = QDialogButtonBox(QDialogButtonBox.Ok)
bbox.accepted.connect(self.accept)
hlayout = QHBoxLayout()
hlayout.addWidget(btn)
hlayout.addStretch()
hlayout.addWidget(bbox)
vlayout = QVBoxLayout()
vlayout.addWidget(self.label)
vlayout.addWidget(self.view)
vlayout.addLayout(hlayout)
self.setLayout(vlayout)
self.resize(630, 420)
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.setWindowTitle('Periodic table')
# Variables
self._required_selection = True
# Widgets
self._wdg_table = PeriodicTableWidget()
buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
# Layouts
layout = QVBoxLayout()
layout.addWidget(self._wdg_table)
layout.addWidget(buttons)
self.setLayout(layout)
# Signals
self._wdg_table.selectionChanged.connect(self.selectionChanged)
buttons.accepted.connect(self._onOk)
buttons.rejected.connect(self._onCancel)
def __init__(self, data, title="", comment="",
icon=None, parent=None, apply=None):
QDialog.__init__(self, parent)
self.apply_callback = apply
# Form
if isinstance(data[0][0], (list, tuple)):
self.formwidget = FormTabWidget(data, comment=comment,
parent=self)
elif len(data[0])==3:
self.formwidget = FormComboWidget(data, comment=comment,
parent=self)
else:
self.formwidget = FormWidget(data, comment=comment,
parent=self)
layout = QVBoxLayout()
layout.addWidget(self.formwidget)
self.float_fields = []
self.formwidget.setup()
# Button box
self.bbox = bbox = QDialogButtonBox(QDialogButtonBox.Ok
|QDialogButtonBox.Cancel)
self.formwidget.update_buttons.connect(self.update_buttons)
if self.apply_callback is not None:
apply_btn = bbox.addButton(QDialogButtonBox.Apply)
apply_btn.clicked.connect(self.apply)
bbox.accepted.connect(self.accept)
bbox.rejected.connect(self.reject)
layout.addWidget(bbox)
self.setLayout(layout)
self.setWindowTitle(title)
if not isinstance(icon, QIcon):
icon = QWidget().style().standardIcon(QStyle.SP_MessageBoxQuestion)
self.setWindowIcon(icon)
def final_dialog(self, label):
"""
Final dialog that to show where the calculated collapsed cube was put.
:param label:
:return:
"""
final_dialog = QDialog()
# Create data component label and input box
widget_desc = QLabel('The collapsed cube was added as an overlay with label "{}". {}'.format(
label, self._extra_message))
widget_desc.setWordWrap(True)
widget_desc.setFixedWidth(350)
widget_desc.setAlignment((Qt.AlignLeft | Qt.AlignTop))
hb_desc = QHBoxLayout()
hb_desc.addWidget(widget_desc)
# Create Ok button
okButton = QPushButton("Ok")
okButton.clicked.connect(lambda: final_dialog.close())
okButton.setDefault(True)
hb_buttons = QHBoxLayout()
hb_buttons.addStretch(1)
hb_buttons.addWidget(okButton)
# Add description and buttons to popup box
vbl = QVBoxLayout()
vbl.addLayout(hb_desc)
vbl.addLayout(hb_buttons)
final_dialog.setLayout(vbl)
final_dialog.setMaximumWidth(400)
final_dialog.show()
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.setWindowTitle(_("Spyder internal error"))
self.setModal(True)
# To save the traceback sent to the internal console
self.error_traceback = ""
# Dialog main label
self.main_label = QLabel(
_("""<b>Spyder has encountered an internal problem</b><hr>
Please enter below a step-by-step description of
your problem (in English). Issue reports without
a clear way to reproduce them will be closed.
<br><br>
<b>Note</b>: You need a Github account for this.
"""))
self.main_label.setWordWrap(True)
self.main_label.setAlignment(Qt.AlignJustify)
# Field to input the description of the problem
self.input_description = DescriptionWidget(self)
# Only allow to submit to Github if we have a long enough description
self.input_description.textChanged.connect(self._description_changed)
# Widget to show errors
self.details = ShowErrorWidget(self)
self.details.set_pythonshell_font(get_font())
self.details.hide()
# Label to show missing chars
self.initial_chars = len(self.input_description.toPlainText())
self.chars_label = QLabel(_("Enter at least {} "
"characters".format(MIN_CHARS)))
# Checkbox to dismiss future errors
self.dismiss_box = QCheckBox()
self.dismiss_box.setText(_("Don't show again during this session"))
# Labels layout
labels_layout = QHBoxLayout()
labels_layout.addWidget(self.chars_label)
labels_layout.addWidget(self.dismiss_box, 0, Qt.AlignRight)
# Dialog buttons
self.submit_btn = QPushButton(_('Submit to Github'))
self.submit_btn.setEnabled(False)
self.submit_btn.clicked.connect(self._submit_to_github)
self.details_btn = QPushButton(_('Show details'))
self.details_btn.clicked.connect(self._show_details)
self.close_btn = QPushButton(_('Close'))
# Buttons layout
buttons_layout = QHBoxLayout()
buttons_layout.addWidget(self.submit_btn)
buttons_layout.addWidget(self.details_btn)
buttons_layout.addWidget(self.close_btn)
# Main layout
vlayout = QVBoxLayout()
vlayout.addWidget(self.main_label)
vlayout.addWidget(self.input_description)
vlayout.addWidget(self.details)
vlayout.addLayout(labels_layout)
vlayout.addLayout(buttons_layout)
self.setLayout(vlayout)
self.resize(600, 420)
self.input_description.setFocus()
def accept(self):
self.is_visible = False
QDialog.accept(self)
self.list.clear()
def __init__(self, parent, username, password, token, remember=False,
remember_token=False):
QDialog.__init__(self, parent)
title = _("Sign in to Github")
self.resize(415, 375)
self.setWindowTitle(title)
self.setWindowFlags(
self.windowFlags() & ~Qt.WindowContextHelpButtonHint)
# Header
html = ('<html><head/><body><p align="center">'
'{title}</p></body></html>')
lbl_html = QLabel(html.format(title=title))
lbl_html.setStyleSheet('font-size: 16px;')
# Tabs
self.tabs = QTabWidget()
# Basic form layout
basic_form_layout = QFormLayout()
basic_form_layout.setContentsMargins(-1, 0, -1, -1)
basic_lbl_msg = QLabel(_("For regular users, i.e. users <b>without</b>"
" two-factor authentication enabled"))
basic_lbl_msg.setWordWrap(True)
basic_lbl_msg.setAlignment(Qt.AlignJustify)
lbl_user = QLabel(_("Username:"******"", QWidget())
lbl_password = QLabel(_("Password: "******"Remember me"))
self.cb_remember.setToolTip(_("Spyder will save your credentials "
"safely"))
self.cb_remember.setChecked(remember)
basic_form_layout.setWidget(4, QFormLayout.FieldRole,
self.cb_remember)
# Basic auth tab
basic_auth = QWidget()
basic_layout = QVBoxLayout()
basic_layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 8)))
basic_layout.addWidget(basic_lbl_msg)
basic_layout.addSpacerItem(
QSpacerItem(QSpacerItem(0, 50, vPolicy=QSizePolicy.Expanding)))
basic_layout.addLayout(basic_form_layout)
basic_layout.addSpacerItem(
QSpacerItem(QSpacerItem(0, 50, vPolicy=QSizePolicy.Expanding)))
basic_auth.setLayout(basic_layout)
self.tabs.addTab(basic_auth, _("Password Only"))
# Token form layout
token_form_layout = QFormLayout()
token_form_layout.setContentsMargins(-1, 0, -1, -1)
token_lbl_msg = QLabel(_("For users <b>with</b> two-factor "
"authentication enabled, or who prefer a "
"per-app token authentication.<br><br>"
"You can go <b><a href=\"{}\">here</a></b> "
"and click \"Generate token\" at the bottom "
"to create a new token to use for this, with "
"the appropriate permissions.").format(
TOKEN_URL))
token_lbl_msg.setOpenExternalLinks(True)
token_lbl_msg.setWordWrap(True)
token_lbl_msg.setAlignment(Qt.AlignJustify)
lbl_token = QLabel("Token: ")
token_form_layout.setWidget(1, QFormLayout.LabelRole, lbl_token)
self.le_token = QLineEdit()
self.le_token.setEchoMode(QLineEdit.Password)
self.le_token.textChanged.connect(self.update_btn_state)
token_form_layout.setWidget(1, QFormLayout.FieldRole, self.le_token)
self.cb_remember_token = None
# Same validation as with cb_remember
if self.is_keyring_available() and valid_py_os:
self.cb_remember_token = QCheckBox(_("Remember token"))
self.cb_remember_token.setToolTip(_("Spyder will save your "
"token safely"))
self.cb_remember_token.setChecked(remember_token)
token_form_layout.setWidget(3, QFormLayout.FieldRole,
self.cb_remember_token)
# Token auth tab
token_auth = QWidget()
token_layout = QVBoxLayout()
token_layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 8)))
token_layout.addWidget(token_lbl_msg)
token_layout.addSpacerItem(
QSpacerItem(QSpacerItem(0, 50, vPolicy=QSizePolicy.Expanding)))
token_layout.addLayout(token_form_layout)
token_layout.addSpacerItem(
QSpacerItem(QSpacerItem(0, 50, vPolicy=QSizePolicy.Expanding)))
token_auth.setLayout(token_layout)
self.tabs.addTab(token_auth, _("Access Token"))
# Sign in button
self.bt_sign_in = QPushButton(_("Sign in"))
self.bt_sign_in.clicked.connect(self.accept)
self.bt_sign_in.setDisabled(True)
# Main layout
layout = QVBoxLayout()
layout.addWidget(lbl_html)
layout.addWidget(self.tabs)
layout.addWidget(self.bt_sign_in)
self.setLayout(layout)
# Final adjustments
if username and password:
self.le_user.setText(username)
self.le_password.setText(password)
self.bt_sign_in.setFocus()
elif username:
self.le_user.setText(username)
self.le_password.setFocus()
elif token:
self.le_token.setText(token)
else:
self.le_user.setFocus()
self.setFixedSize(self.width(), self.height())
self.le_password.installEventFilter(self)
self.le_user.installEventFilter(self)
self.tabs.currentChanged.connect(self.update_btn_state)
def __init__(self, parent=None, inline=True, offset=0, force_float=False):
QDialog.__init__(self, parent=parent)
self._parent = parent
self._text = None
self._valid = None
self._offset = offset
# TODO: add this as an option in the General Preferences?
self._force_float = force_float
self._help_inline = _("""
<b>Numpy Array/Matrix Helper</b><br>
Type an array in Matlab : <code>[1 2;3 4]</code><br>
or Spyder simplified syntax : <code>1 2;3 4</code>
<br><br>
Hit 'Enter' for array or 'Ctrl+Enter' for matrix.
<br><br>
<b>Hint:</b><br>
Use two spaces or two tabs to generate a ';'.
""")
self._help_table = _("""
<b>Numpy Array/Matrix Helper</b><br>
Enter an array in the table. <br>
Use Tab to move between cells.
<br><br>
Hit 'Enter' for array or 'Ctrl+Enter' for matrix.
<br><br>
<b>Hint:</b><br>
Use two tabs at the end of a row to move to the next row.
""")
# Widgets
self._button_warning = QToolButton()
self._button_help = HelperToolButton()
self._button_help.setIcon(ima.icon('MessageBoxInformation'))
style = """
QToolButton {
border: 1px solid grey;
padding:0px;
border-radius: 2px;
background-color: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
stop: 0 #f6f7fa, stop: 1 #dadbde);
}
"""
self._button_help.setStyleSheet(style)
if inline:
self._button_help.setToolTip(self._help_inline)
self._text = NumpyArrayInline(self)
self._widget = self._text
else:
self._button_help.setToolTip(self._help_table)
self._table = NumpyArrayTable(self)
self._widget = self._table
style = """
QDialog {
margin:0px;
border: 1px solid grey;
padding:0px;
border-radius: 2px;
}"""
self.setStyleSheet(style)
style = """
QToolButton {
margin:1px;
border: 0px solid grey;
padding:0px;
border-radius: 0px;
}"""
self._button_warning.setStyleSheet(style)
# widget setup
self.setWindowFlags(Qt.Window | Qt.Dialog | Qt.FramelessWindowHint)
self.setModal(True)
self.setWindowOpacity(0.90)
self._widget.setMinimumWidth(200)
# layout
self._layout = QHBoxLayout()
self._layout.addWidget(self._widget)
self._layout.addWidget(self._button_warning, 1, Qt.AlignTop)
self._layout.addWidget(self._button_help, 1, Qt.AlignTop)
self.setLayout(self._layout)
self._widget.setFocus()