def setup_page(self):
newcb = self.create_checkbox
# --- Workspace
interface_group = QGroupBox(_("Interface"))
restore_data_box = newcb(_("Restore data on startup"),
'restore_data_on_startup')
save_data_box = newcb(_("Save data on exit"),
'save_data_on_exit')
save_history_box = newcb(_("Save history"),
'save_history')
save_non_project_box = newcb(_("Save non project files opened"),
'save_non_project_files')
interface_layout = QVBoxLayout()
interface_layout.addWidget(restore_data_box)
interface_layout.addWidget(save_data_box)
interface_layout.addWidget(save_history_box)
interface_layout.addWidget(save_non_project_box)
interface_group.setLayout(interface_layout)
vlayout = QVBoxLayout()
vlayout.addWidget(interface_group)
vlayout.addStretch(1)
self.setLayout(vlayout)
def create_controls(self):
"""
Create UI controls.
"""
vbox = QVBoxLayout()
form = QFormLayout()
self.num_angle = QDoubleSpinBox()
self.num_angle.setValue(0.0)
self.num_angle.setMinimum(-360)
self.num_angle.setMaximum(360)
form.addRow(tr("Angle:"), self.num_angle)
vbox.addLayout(form)
self.gbo_preview = QGroupBox(tr("Preview"))
self.gbo_preview.setCheckable(True)
self.gbo_preview.setChecked(False)
gbo_vbox = QVBoxLayout()
self.chk_grid = QCheckBox(tr("Grid"))
self.chk_grid.setChecked(False)
self.num_grid = QSpinBox()
self.num_grid.setValue(4)
self.num_grid.setMinimum(1)
self.num_grid.setEnabled(False)
self.chk_grid.toggled[bool].connect(self.num_grid.setEnabled)
gbo_vbox.addWidget(self.chk_grid)
gbo_vbox.addWidget(self.num_grid)
self.gbo_preview.setLayout(gbo_vbox)
vbox.addWidget(self.gbo_preview)
self.gbo_preview.toggled[bool].connect(self.set_preview)
self.gbo_output = QGroupBox(tr("Output"))
self.opt_new = QRadioButton(tr("New signal"))
self.opt_replace = QRadioButton(tr("In place"))
self.opt_new.setChecked(True)
gbo_vbox2 = QVBoxLayout()
gbo_vbox2.addWidget(self.opt_new)
gbo_vbox2.addWidget(self.opt_replace)
self.gbo_output.setLayout(gbo_vbox2)
vbox.addWidget(self.gbo_output)
self.chk_reshape = QCheckBox(tr("Resize to fit"))
self.chk_reshape.setChecked(False)
vbox.addWidget(self.chk_reshape)
self.btn_ok = QPushButton(tr("&OK"))
self.btn_ok.setDefault(True)
self.btn_ok.clicked.connect(self.accept)
self.btn_cancel = QPushButton(tr("&Cancel"))
self.btn_cancel.clicked.connect(self.reject)
hbox = QHBoxLayout()
hbox.addWidget(self.btn_ok)
hbox.addWidget(self.btn_cancel)
vbox.addLayout(hbox)
vbox.addStretch(1)
self.setLayout(vbox)
def setup_page(self):
# Connections group
connections_group = QGroupBox(_("Automatic connections"))
connections_label = QLabel(_("This pane can automatically "
"show an object's help information after "
"a left parenthesis is written next to it. "
"Below you can decide to which plugin "
"you want to connect it to turn on this "
"feature."))
connections_label.setWordWrap(True)
editor_box = self.create_checkbox(_("Editor"), 'connect/editor')
rope_installed = programs.is_module_installed('rope')
jedi_installed = programs.is_module_installed('jedi', '>=0.8.1')
editor_box.setEnabled(rope_installed or jedi_installed)
if not rope_installed and not jedi_installed:
editor_tip = _("This feature requires the Rope or Jedi libraries.\n"
"It seems you don't have either installed.")
editor_box.setToolTip(editor_tip)
ipython_box = self.create_checkbox(_("IPython Console"),
'connect/ipython_console')
connections_layout = QVBoxLayout()
connections_layout.addWidget(connections_label)
connections_layout.addWidget(editor_box)
connections_layout.addWidget(ipython_box)
connections_group.setLayout(connections_layout)
# Features group
features_group = QGroupBox(_("Additional features"))
math_box = self.create_checkbox(_("Render mathematical equations"),
'math')
req_sphinx = programs.is_module_installed('sphinx', '>=1.1')
math_box.setEnabled(req_sphinx)
if not req_sphinx:
sphinx_ver = programs.get_module_version('sphinx')
sphinx_tip = _("This feature requires Sphinx 1.1 or superior.")
sphinx_tip += "\n" + _("Sphinx %s is currently installed.") % sphinx_ver
math_box.setToolTip(sphinx_tip)
features_layout = QVBoxLayout()
features_layout.addWidget(math_box)
features_group.setLayout(features_layout)
# Source code group
sourcecode_group = QGroupBox(_("Source code"))
wrap_mode_box = self.create_checkbox(_("Wrap lines"), 'wrap')
sourcecode_layout = QVBoxLayout()
sourcecode_layout.addWidget(wrap_mode_box)
sourcecode_group.setLayout(sourcecode_layout)
# Final layout
vlayout = QVBoxLayout()
vlayout.addWidget(connections_group)
vlayout.addWidget(features_group)
vlayout.addWidget(sourcecode_group)
vlayout.addStretch(1)
self.setLayout(vlayout)
def setup_page(self):
about_label = QLabel(_("The <b>current working directory</b> is "
"the working directory for IPython consoles "
"and the current directory for the File Explorer."))
about_label.setWordWrap(True)
console_group = QGroupBox(_("Console directory"))
console_label = QLabel(_("The working directory for new consoles is:"))
console_label.setWordWrap(True)
console_bg = QButtonGroup(console_group)
console_project_radio = self.create_radiobutton(
_("The current project directory "
"or user home directory "
"(if no project is active)"),
'console/use_project_or_home_directory',
True,
button_group=console_bg)
console_cwd_radio = self.create_radiobutton(
_("The current working directory"),
'console/use_cwd',
False,
button_group=console_bg)
console_dir_radio = self.create_radiobutton(
_("the following directory:"),
'console/use_fixed_directory', False,
_("The directory when a new console "
"is open will be the specified path"),
button_group=console_bg)
console_dir_bd = self.create_browsedir("", 'console/fixed_directory',
getcwd())
console_dir_radio.toggled.connect(console_dir_bd.setEnabled)
console_project_radio.toggled.connect(console_dir_bd.setDisabled)
console_cwd_radio.toggled.connect(console_dir_bd.setDisabled)
console_dir_layout = QHBoxLayout()
console_dir_layout.addWidget(console_dir_radio)
console_dir_layout.addWidget(console_dir_bd)
console_layout = QVBoxLayout()
console_layout.addWidget(console_label)
console_layout.addWidget(console_project_radio)
console_layout.addWidget(console_cwd_radio)
console_layout.addLayout(console_dir_layout)
console_group.setLayout(console_layout)
vlayout = QVBoxLayout()
vlayout.addWidget(about_label)
vlayout.addSpacing(10)
vlayout.addWidget(console_group)
vlayout.addStretch(1)
self.setLayout(vlayout)
def setup_page(self):
ar_group = QGroupBox(_("Autorefresh"))
ar_box = self.create_checkbox(_("Enable autorefresh"),
'autorefresh')
ar_spin = self.create_spinbox(_("Refresh interval: "),
_(" ms"), 'autorefresh/timeout',
min_=100, max_=1000000, step=100)
filter_group = QGroupBox(_("Filter"))
filter_data = [
('exclude_private', _("Exclude private references")),
('exclude_capitalized', _("Exclude capitalized references")),
('exclude_uppercase', _("Exclude all-uppercase references")),
('exclude_unsupported', _("Exclude unsupported data types")),
]
filter_boxes = [self.create_checkbox(text, option)
for option, text in filter_data]
display_group = QGroupBox(_("Display"))
display_data = [('truncate', _("Truncate values"), '')]
if programs.is_module_installed('numpy'):
display_data.append(('minmax', _("Show arrays min/max"), ''))
display_data.append(
('remote_editing', _("Edit data in the remote process"),
_("Editors are opened in the remote process for NumPy "
"arrays, PIL images, lists, tuples and dictionaries.\n"
"This avoids transfering large amount of data between "
"the remote process and Spyder (through the socket)."))
)
display_boxes = [self.create_checkbox(text, option, tip=tip)
for option, text, tip in display_data]
ar_layout = QVBoxLayout()
ar_layout.addWidget(ar_box)
ar_layout.addWidget(ar_spin)
ar_group.setLayout(ar_layout)
filter_layout = QVBoxLayout()
for box in filter_boxes:
filter_layout.addWidget(box)
filter_group.setLayout(filter_layout)
display_layout = QVBoxLayout()
for box in display_boxes:
display_layout.addWidget(box)
display_group.setLayout(display_layout)
vlayout = QVBoxLayout()
vlayout.addWidget(ar_group)
vlayout.addWidget(filter_group)
vlayout.addWidget(display_group)
vlayout.addStretch(1)
self.setLayout(vlayout)
def create_fontgroup(self, option=None, text=None, title=None,
tip=None, fontfilters=None, without_group=False):
"""Option=None -> setting plugin font"""
if title:
fontlabel = QLabel(title)
else:
fontlabel = QLabel(_("Font"))
fontbox = QFontComboBox()
if fontfilters is not None:
fontbox.setFontFilters(fontfilters)
sizelabel = QLabel(" "+_("Size"))
sizebox = QSpinBox()
sizebox.setRange(7, 100)
self.fontboxes[(fontbox, sizebox)] = option
layout = QHBoxLayout()
for subwidget in (fontlabel, fontbox, sizelabel, sizebox):
layout.addWidget(subwidget)
layout.addStretch(1)
widget = QWidget(self)
widget.fontlabel = fontlabel
widget.sizelabel = sizelabel
widget.fontbox = fontbox
widget.sizebox = sizebox
widget.setLayout(layout)
if not without_group:
if text is None:
text = _("Font style")
group = QGroupBox(text)
group.setLayout(layout)
if tip is not None:
group.setToolTip(tip)
return group
else:
return widget
def setup_page(self):
newcb = self.create_checkbox
# --- Workspace
vcs_group = QGroupBox(_("Version control"))
use_version_control = newcb(_("Use version control"), "use_version_control")
styles = ["git", "hg"]
choices = list(zip(styles, [style.lower() for style in styles]))
vcs_combo = self.create_combobox(_("Version control system"), choices, "version_control_system", default="git")
vcs_layout = QVBoxLayout()
vcs_layout.addWidget(use_version_control)
vcs_layout.addWidget(vcs_combo)
vcs_group.setLayout(vcs_layout)
vlayout = QVBoxLayout()
vlayout.addWidget(vcs_group)
vlayout.addStretch(1)
self.setLayout(vlayout)
def setup_page(self):
settings_group = QGroupBox(_("Settings"))
save_box = self.create_checkbox(_("Save file before analyzing it"),
'save_before', default=True)
hist_group = QGroupBox(_("History"))
hist_label1 = QLabel(_("The following option will be applied at next "
"startup."))
hist_label1.setWordWrap(True)
hist_spin = self.create_spinbox(_("History: "),
_(" results"), 'max_entries', default=50,
min_=10, max_=1000000, step=10)
results_group = QGroupBox(_("Results"))
results_label1 = QLabel(_("Results are stored here:"))
results_label1.setWordWrap(True)
# Warning: do not try to regroup the following QLabel contents with
# widgets above -- this string was isolated here in a single QLabel
# on purpose: to fix Issue 863
results_label2 = QLabel(PylintWidget.DATAPATH)
results_label2.setTextInteractionFlags(Qt.TextSelectableByMouse)
results_label2.setWordWrap(True)
settings_layout = QVBoxLayout()
settings_layout.addWidget(save_box)
settings_group.setLayout(settings_layout)
hist_layout = QVBoxLayout()
hist_layout.addWidget(hist_label1)
hist_layout.addWidget(hist_spin)
hist_group.setLayout(hist_layout)
results_layout = QVBoxLayout()
results_layout.addWidget(results_label1)
results_layout.addWidget(results_label2)
results_group.setLayout(results_layout)
vlayout = QVBoxLayout()
vlayout.addWidget(settings_group)
vlayout.addWidget(hist_group)
vlayout.addWidget(results_group)
vlayout.addStretch(1)
self.setLayout(vlayout)
def setup_page(self):
"""Setup config page widgets and options."""
settings_group = QGroupBox(_("Settings"))
hist_spin = self.create_spinbox(
_("History depth: "), _(" entries"),
'max_entries', min_=10, max_=10000, step=10,
tip=_("Set maximum line count"))
sourcecode_group = QGroupBox(_("Source code"))
wrap_mode_box = self.create_checkbox(_("Wrap lines"), 'wrap')
linenumbers_mode_box = self.create_checkbox(_("Show line numbers"),
'line_numbers')
go_to_eof_box = self.create_checkbox(
_("Scroll automatically to last entry"), 'go_to_eof')
settings_layout = QVBoxLayout()
settings_layout.addWidget(hist_spin)
settings_group.setLayout(settings_layout)
sourcecode_layout = QVBoxLayout()
sourcecode_layout.addWidget(wrap_mode_box)
sourcecode_layout.addWidget(linenumbers_mode_box)
sourcecode_layout.addWidget(go_to_eof_box)
sourcecode_group.setLayout(sourcecode_layout)
vlayout = QVBoxLayout()
vlayout.addWidget(settings_group)
vlayout.addWidget(sourcecode_group)
vlayout.addStretch(1)
self.setLayout(vlayout)
def setup_page(self):
settings_group = QGroupBox(_("Settings"))
use_color_box = self.create_checkbox(
_("Use deterministic colors to differentiate functions"),
'use_colors', default=True)
results_group = QGroupBox(_("Results"))
results_label1 = QLabel(_("Memory profiler plugin results "
"(the output of memory_profiler)\n"
"is stored here:"))
results_label1.setWordWrap(True)
# Warning: do not try to regroup the following QLabel contents with
# widgets above -- this string was isolated here in a single QLabel
# on purpose: to fix Issue 863 of Profiler plugon
results_label2 = QLabel(MemoryProfilerWidget.DATAPATH)
results_label2.setTextInteractionFlags(Qt.TextSelectableByMouse)
results_label2.setWordWrap(True)
settings_layout = QVBoxLayout()
settings_layout.addWidget(use_color_box)
settings_group.setLayout(settings_layout)
results_layout = QVBoxLayout()
results_layout.addWidget(results_label1)
results_layout.addWidget(results_label2)
results_group.setLayout(results_layout)
vlayout = QVBoxLayout()
vlayout.addWidget(settings_group)
vlayout.addWidget(results_group)
vlayout.addStretch(1)
self.setLayout(vlayout)
def setup_ui(self):
self.setWindowTitle("Add New Grain")
self.setWindowIcon(QIcon(RESOURCE_PATH + "icons/nakka-finocyl.gif"))
self.resize(400, 400)
controls = QGridLayout()
gb_frame = QGroupBox(self.tr("Grain Design"))
gb_frame.setLayout(controls)
self.cb_grain_type = QComboBox()
# TODO: make grain types auto propagate combobox
self.cb_grain_type.addItems([self.tr("Cylindrical (BATES)")])
controls.addWidget(QLabel(self.tr("Core Shape")), 0, 0)
controls.addWidget(self.cb_grain_type, 0, 1)
self.cb_propellant_type = QComboBox()
self.cb_propellant_type.addItems(app_context.propellant_db.propellant_names())
controls.addWidget(QLabel(self.tr("Propellant Type")), 1, 0)
controls.addWidget(self.cb_propellant_type, 1, 1)
# ok and cancel buttons
btn_ok = QPushButton(self.tr("Apply"))
btn_ok.clicked.connect(self.confirm_grain)
btn_cancel = QPushButton(self.tr("Close"))
btn_cancel.clicked.connect(self.close)
lay_btns = QHBoxLayout()
lay_btns.addWidget(btn_ok)
lay_btns.addWidget(btn_cancel)
frame_btns = QFrame()
frame_btns.setLayout(lay_btns)
# master layout
master = QVBoxLayout()
master.addWidget(gb_frame)
master.addSpacing(10)
master.addWidget(frame_btns)
self.setLayout(master)
def setup_page(self):
settings_group = QGroupBox(_("Settings"))
hist_spin = self.create_spinbox(
_("History depth: "),
_(" entries"),
"max_entries",
min_=10,
max_=10000,
step=10,
tip=_("Set maximum line count"),
)
sourcecode_group = QGroupBox(_("Source code"))
wrap_mode_box = self.create_checkbox(_("Wrap lines"), "wrap")
go_to_eof_box = self.create_checkbox(_("Scroll automatically to last entry"), "go_to_eof")
settings_layout = QVBoxLayout()
settings_layout.addWidget(hist_spin)
settings_group.setLayout(settings_layout)
sourcecode_layout = QVBoxLayout()
sourcecode_layout.addWidget(wrap_mode_box)
sourcecode_layout.addWidget(go_to_eof_box)
sourcecode_group.setLayout(sourcecode_layout)
vlayout = QVBoxLayout()
vlayout.addWidget(settings_group)
vlayout.addWidget(sourcecode_group)
vlayout.addStretch(1)
self.setLayout(vlayout)
def setup_page(self):
filter_group = QGroupBox(_("Filter"))
filter_data = [
('exclude_private', _("Exclude private references")),
('exclude_capitalized', _("Exclude capitalized references")),
('exclude_uppercase', _("Exclude all-uppercase references")),
('exclude_unsupported', _("Exclude unsupported data types")),
]
filter_boxes = [self.create_checkbox(text, option)
for option, text in filter_data]
display_group = QGroupBox(_("Display"))
display_data = [('minmax', _("Show arrays min/max"), '')]
display_boxes = [self.create_checkbox(text, option, tip=tip)
for option, text, tip in display_data]
filter_layout = QVBoxLayout()
for box in filter_boxes:
filter_layout.addWidget(box)
filter_group.setLayout(filter_layout)
display_layout = QVBoxLayout()
for box in display_boxes:
display_layout.addWidget(box)
display_group.setLayout(display_layout)
vlayout = QVBoxLayout()
vlayout.addWidget(filter_group)
vlayout.addWidget(display_group)
vlayout.addStretch(1)
self.setLayout(vlayout)
def setup_page(self):
network_group = QGroupBox(_("Network settings"))
self.checkbox_proxy = self.create_checkbox(_("Use network proxy"),
'use_proxy_flag',
default=False)
server = self.create_lineedit(_('Server'), 'server', default='',
alignment=Qt.Horizontal)
port = self.create_lineedit(_('Port'), 'port', default='',
alignment=Qt.Horizontal)
user = self.create_lineedit(_('User'), 'user', default='',
alignment=Qt.Horizontal)
password = self.create_lineedit(_('Password'), 'password', default='',
alignment=Qt.Horizontal)
self.widgets = [server, port, user, password]
# Layouts
network_layout = QGridLayout()
network_layout.addWidget(self.checkbox_proxy, 0, 0)
network_layout.addWidget(server.label, 1, 0)
network_layout.addWidget(server.textbox, 1, 1)
network_layout.addWidget(port.label, 1, 2)
network_layout.addWidget(port.textbox, 1, 3)
network_layout.addWidget(user.label, 2, 0)
network_layout.addWidget(user.textbox, 2, 1)
network_layout.addWidget(password.label, 2, 2)
network_layout.addWidget(password.textbox, 2, 3)
network_group.setLayout(network_layout)
vlayout = QVBoxLayout()
vlayout.addWidget(network_group)
vlayout.addStretch(1)
self.setLayout(vlayout)
# Signals
self.checkbox_proxy.clicked.connect(self.proxy_settings)
self.proxy_settings()
def setup_page(self):
results_group = QGroupBox(_("Results"))
results_label1 = QLabel(
_("Profiler plugin results " "(the output of python's profile/cProfile)\n" "are stored here:")
)
results_label1.setWordWrap(True)
# Warning: do not try to regroup the following QLabel contents with
# widgets above -- this string was isolated here in a single QLabel
# on purpose: to fix Issue 863
results_label2 = QLabel(ProfilerWidget.DATAPATH)
results_label2.setTextInteractionFlags(Qt.TextSelectableByMouse)
results_label2.setWordWrap(True)
results_layout = QVBoxLayout()
results_layout.addWidget(results_label1)
results_layout.addWidget(results_label2)
results_group.setLayout(results_layout)
vlayout = QVBoxLayout()
vlayout.addWidget(results_group)
vlayout.addStretch(1)
self.setLayout(vlayout)
def setup_chamber_design():
# master layout
master = QVBoxLayout()
# master group box
self.gb_chamber = QGroupBox(self.tr("Chamber Design"))
# nozzle settings button
self.btn_nozzle_settings = QPushButton(self.tr("Edit Nozzle"))
self.btn_nozzle_settings.setMinimumHeight(50)
master.addWidget(self.btn_nozzle_settings)
# nozzle info pane
fl_nozzle_info = QFormLayout()
gb_nozzle = QGroupBox(self.tr("Nozzle Info"))
gb_nozzle.setLayout(fl_nozzle_info)
self.lbl_nozzle_throat = QLabel()
fl_nozzle_info.addRow(QLabel(self.tr("Throat Diameter:")), self.lbl_nozzle_throat)
self.lbl_nozzle_exit = QLabel()
fl_nozzle_info.addRow(QLabel(self.tr("Exit Diameter:")), self.lbl_nozzle_exit)
self.lbl_nozzle_expansion_ratio = QLabel()
fl_nozzle_info.addRow(QLabel(self.tr("Expansion Ratio:")), self.lbl_nozzle_expansion_ratio)
# add group box to master
master.addWidget(gb_nozzle)
master.addStretch()
# overall motor info pane
fl_motor_info = QFormLayout()
gb_motor = QGroupBox(self.tr("Motor Info"))
gb_motor.setLayout(fl_motor_info)
self.lbl_kn = QLabel()
fl_motor_info.addRow(QLabel(self.tr("Kn:")), self.lbl_kn)
self.lbl_port_throat = QLabel()
fl_motor_info.addRow(QLabel(self.tr("Port/Throat Ratio:")), self.lbl_port_throat)
master.addWidget(gb_motor)
self.gb_chamber.setLayout(master)
def _setup_ui(self):
# setup central widget
self.central_widget = QFrame()
self.central_widget.setStyleSheet("""
#OkList {
background-color: #eafaea;
}
#NokList {
background-color: #ffebe6;
}
QLabel{
max-height: 1.29em;
}
QTabWidget::pane {
border-left: 2px solid gray;
border-bottom: 2px solid gray;
border-right: 2px solid gray;
}""")
self.setCentralWidget(self.central_widget)
self.tab = QTabWidget(self)
self.tab.setObjectName('ASTab')
# # PS
self.ps_wid = QWidget(self)
lay_ps = QGridLayout(self.ps_wid)
lay_ps.setContentsMargins(0, 9, 0, 0)
lay_ps.setHorizontalSpacing(0)
# PS selection
self.ps_tree = PVNameTree(items=self._get_ps_tree_names(),
tree_levels=('sec', 'mag_group'),
parent=self)
self.ps_tree.tree.setHeaderHidden(True)
self.ps_tree.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Preferred)
self.ps_tree.tree.setColumnCount(1)
self.ps_tree.tree.doubleClicked.connect(self._open_detail)
self.ps_tree.tree.itemChanged.connect(
self._handle_checked_items_changed)
gbox_ps_select = QGroupBox('Select PS: ', self)
gbox_ps_select.setObjectName('select')
gbox_ps_select.setStyleSheet("""
#select{
border-top: 0px solid transparent;
border-left: 0px solid transparent;
border-bottom: 0px solid transparent;
}""")
lay_ps_select = QVBoxLayout(gbox_ps_select)
lay_ps_select.addWidget(self.ps_tree)
lay_ps.addWidget(gbox_ps_select, 0, 0)
lay_ps.setColumnStretch(0, 1)
# PS commands
self.checkcomm_ps_bt = QPushButton('Check Communication', self)
self.checkcomm_ps_bt.clicked.connect(_part(self._set_lastcomm, 'PS'))
self.checkcomm_ps_bt.clicked.connect(self._check_comm)
self.checkcomm_ps_bt.setToolTip(
'Check PS and DCLinks communication status (verify invalid alarms '
'and, if LI, the value of Connected-Mon PV)')
self.checkstatus_ps_bt = QPushButton('Show Status Summary', self)
self.checkstatus_ps_bt.clicked.connect(_part(self._set_lastcomm, 'PS'))
self.checkstatus_ps_bt.clicked.connect(_part(self._check_status, 'PS'))
self.checkstatus_ps_bt.setToolTip(
'Check PS and DCLinks interlock status and, if powered on, '
'check if it is following reference')
self.dsbltrigger_ps_bt = QPushButton('Disable PS triggers', self)
self.dsbltrigger_ps_bt.clicked.connect(_part(self._set_lastcomm, 'PS'))
self.dsbltrigger_ps_bt.clicked.connect(
_part(self._set_check_trigger_state, 'PS', 'dsbl'))
self.setsofbmode_ps_bt = QPushButton('Turn Off SOFBMode', self)
self.setsofbmode_ps_bt.clicked.connect(_part(self._set_lastcomm, 'PS'))
self.setsofbmode_ps_bt.clicked.connect(
_part(self._set_check_fbp_sofbmode, 'off'))
self.setslowref_ps_bt = QPushButton('Set PS and DCLinks to SlowRef',
self)
self.setslowref_ps_bt.clicked.connect(_part(self._set_lastcomm, 'PS'))
self.setslowref_ps_bt.clicked.connect(self._set_check_opmode_slowref)
self.currzero_ps_bt1 = QPushButton('Set PS Current to zero', self)
self.currzero_ps_bt1.clicked.connect(_part(self._set_lastcomm, 'PS'))
self.currzero_ps_bt1.clicked.connect(self._set_zero_ps)
self.reset_ps_bt = QPushButton('Reset PS and DCLinks', self)
self.reset_ps_bt.clicked.connect(_part(self._set_lastcomm, 'PS'))
self.reset_ps_bt.clicked.connect(_part(self._reset_intlk, 'PS'))
self.prep_sidclink_bt = QPushButton('Prepare SI Fam DCLinks', self)
self.prep_sidclink_bt.clicked.connect(_part(self._set_lastcomm, 'PS'))
self.prep_sidclink_bt.clicked.connect(self._prepare_sidclinks)
self.prep_sidclink_bt.setVisible(False)
self.init_sips_bt = QPushButton('Initialize SI Fam PS', self)
self.init_sips_bt.clicked.connect(_part(self._set_lastcomm, 'PS'))
self.init_sips_bt.clicked.connect(self._set_check_pwrstateinit)
self.init_sips_bt.setVisible(False)
self.aux_label = QLabel('')
self.aux_label.setVisible(False)
self.turnon_dcl_bt = QPushButton('Turn DCLinks On', self)
self.turnon_dcl_bt.clicked.connect(_part(self._set_lastcomm, 'PS'))
self.turnon_dcl_bt.clicked.connect(
_part(self._set_check_pwrstate_dclinks, 'on'))
self.checkctrlloop_dcl_bt = QPushButton('Check DCLinks CtrlLoop', self)
self.checkctrlloop_dcl_bt.clicked.connect(
_part(self._set_lastcomm, 'PS'))
self.checkctrlloop_dcl_bt.clicked.connect(
_part(self._set_check_ctrlloop, 'dclink'))
self.setvolt_dcl_bt = QPushButton('Set DCLinks Voltage', self)
self.setvolt_dcl_bt.clicked.connect(_part(self._set_lastcomm, 'PS'))
self.setvolt_dcl_bt.clicked.connect(self._set_check_dclinks_capvolt)
self.turnon_ps_bt = QPushButton('Turn PS On', self)
self.turnon_ps_bt.clicked.connect(_part(self._set_lastcomm, 'PS'))
self.turnon_ps_bt.clicked.connect(
_part(self._set_check_pwrstate, 'PS', 'on', True))
self.setcheckctrlloop_ps_bt = QPushButton('Check PS CtrlLoop', self)
self.setcheckctrlloop_ps_bt.clicked.connect(
_part(self._set_lastcomm, 'PS'))
self.setcheckctrlloop_ps_bt.clicked.connect(
_part(self._set_check_ctrlloop, 'pwrsupply'))
self.test_ps_bt = QPushButton('Set PS Current to test value', self)
self.test_ps_bt.clicked.connect(_part(self._set_lastcomm, 'PS'))
self.test_ps_bt.clicked.connect(self._set_test_ps)
self.currzero_ps_bt2 = QPushButton('Set PS Current to zero', self)
self.currzero_ps_bt2.clicked.connect(_part(self._set_lastcomm, 'PS'))
self.currzero_ps_bt2.clicked.connect(self._set_zero_ps)
self.restoretrigger_ps_bt = QPushButton('Restore PS triggers', self)
self.restoretrigger_ps_bt.clicked.connect(
_part(self._set_lastcomm, 'PS'))
self.restoretrigger_ps_bt.clicked.connect(
_part(self._restore_triggers_state, 'PS'))
gbox_ps_comm = QGroupBox('Commands', self)
gbox_ps_comm.setObjectName('comm')
gbox_ps_comm.setStyleSheet('#comm{border: 0px solid transparent;}')
lay_ps_comm = QVBoxLayout(gbox_ps_comm)
lay_ps_comm.setContentsMargins(20, 9, 20, 9)
lay_ps_comm.addWidget(QLabel(''))
lay_ps_comm.addWidget(
QLabel('<h4>Check</h4>', self, alignment=Qt.AlignCenter))
lay_ps_comm.addWidget(self.checkcomm_ps_bt)
lay_ps_comm.addWidget(self.checkstatus_ps_bt)
lay_ps_comm.addWidget(QLabel(''))
lay_ps_comm.addWidget(
QLabel('<h4>Prepare</h4>', self, alignment=Qt.AlignCenter))
lay_ps_comm.addWidget(self.dsbltrigger_ps_bt)
lay_ps_comm.addWidget(self.setsofbmode_ps_bt)
lay_ps_comm.addWidget(self.setslowref_ps_bt)
lay_ps_comm.addWidget(self.currzero_ps_bt1)
lay_ps_comm.addWidget(self.reset_ps_bt)
lay_ps_comm.addWidget(QLabel(''))
lay_ps_comm.addWidget(self.prep_sidclink_bt)
lay_ps_comm.addWidget(self.init_sips_bt)
lay_ps_comm.addWidget(self.aux_label)
lay_ps_comm.addWidget(
QLabel('<h4>Config DCLinks</h4>', self, alignment=Qt.AlignCenter))
lay_ps_comm.addWidget(self.turnon_dcl_bt)
lay_ps_comm.addWidget(self.checkctrlloop_dcl_bt)
lay_ps_comm.addWidget(self.setvolt_dcl_bt)
lay_ps_comm.addWidget(QLabel(''))
lay_ps_comm.addWidget(
QLabel('<h4>Test</h4>', self, alignment=Qt.AlignCenter))
lay_ps_comm.addWidget(self.turnon_ps_bt)
lay_ps_comm.addWidget(self.setcheckctrlloop_ps_bt)
lay_ps_comm.addWidget(self.test_ps_bt)
lay_ps_comm.addWidget(self.currzero_ps_bt2)
lay_ps_comm.addWidget(QLabel(''))
lay_ps_comm.addWidget(
QLabel('<h4>Restore</h4>', self, alignment=Qt.AlignCenter))
lay_ps_comm.addWidget(self.restoretrigger_ps_bt)
lay_ps_comm.addWidget(QLabel(''))
lay_ps.addWidget(gbox_ps_comm, 0, 1)
lay_ps.setColumnStretch(1, 1)
self.tab.addTab(self.ps_wid, 'PS')
# # PU
self.pu_wid = QWidget(self)
lay_pu = QGridLayout(self.pu_wid)
lay_pu.setContentsMargins(0, 9, 0, 0)
lay_pu.setHorizontalSpacing(0)
# PU selection
self.pu_tree = PVNameTree(items=self._get_pu_tree_names(),
tree_levels=('sec', ),
parent=self)
self.pu_tree.tree.setHeaderHidden(True)
self.pu_tree.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Preferred)
self.pu_tree.tree.setColumnCount(1)
self.pu_tree.tree.doubleClicked.connect(self._open_detail)
gbox_pu_select = QGroupBox('Select PU: ', self)
gbox_pu_select.setObjectName('select')
gbox_pu_select.setStyleSheet("""
#select{
border-top: 0px solid transparent;
border-left: 0px solid transparent;
border-bottom: 0px solid transparent;
}""")
lay_pu_select = QVBoxLayout(gbox_pu_select)
lay_pu_select.addWidget(self.pu_tree)
lay_pu.addWidget(gbox_pu_select, 0, 0)
lay_pu.setColumnStretch(0, 1)
# PU commands
self.checkstatus_pu_bt = QPushButton('Show Status Summary', self)
self.checkstatus_pu_bt.clicked.connect(_part(self._set_lastcomm, 'PU'))
self.checkstatus_pu_bt.clicked.connect(_part(self._check_status, 'PU'))
self.checkstatus_pu_bt.setToolTip(
'Check PU interlock status and, if powered on, '
'check if it is following voltage setpoint')
self.voltzero_pu_bt1 = QPushButton('Set PU Voltage to zero', self)
self.voltzero_pu_bt1.clicked.connect(_part(self._set_lastcomm, 'PU'))
self.voltzero_pu_bt1.clicked.connect(_part(self._set_zero_pu, False))
self.reset_pu_bt = QPushButton('Reset PU', self)
self.reset_pu_bt.clicked.connect(_part(self._set_lastcomm, 'PU'))
self.reset_pu_bt.clicked.connect(_part(self._reset_intlk, 'PU'))
self.turnon_pu_bt = QPushButton('Turn PU On', self)
self.turnon_pu_bt.clicked.connect(_part(self._set_lastcomm, 'PU'))
self.turnon_pu_bt.clicked.connect(
_part(self._set_check_pwrstate, 'PU', 'on', True))
self.enblpulse_pu_bt = QPushButton('Enable PU Pulse', self)
self.enblpulse_pu_bt.clicked.connect(_part(self._set_lastcomm, 'PU'))
self.enblpulse_pu_bt.clicked.connect(_part(self._set_check_pulse,
'on'))
self.enbltrigger_pu_bt = QPushButton('Enable PU triggers', self)
self.enbltrigger_pu_bt.clicked.connect(_part(self._set_lastcomm, 'PU'))
self.enbltrigger_pu_bt.clicked.connect(
_part(self._set_check_trigger_state, 'PU', 'on'))
self.test_pu_bt = QPushButton('Set PU Voltage to test value', self)
self.test_pu_bt.clicked.connect(_part(self._set_lastcomm, 'PU'))
self.test_pu_bt.clicked.connect(self._set_test_pu)
self.voltzero_pu_bt2 = QPushButton('Set PU Voltage to zero', self)
self.voltzero_pu_bt2.clicked.connect(_part(self._set_lastcomm, 'PU'))
self.voltzero_pu_bt2.clicked.connect(_part(self._set_zero_pu, True))
self.restoretrigger_pu_bt = QPushButton('Restore PU triggers', self)
self.restoretrigger_pu_bt.clicked.connect(
_part(self._set_lastcomm, 'PU'))
self.restoretrigger_pu_bt.clicked.connect(
_part(self._restore_triggers_state, 'PU'))
gbox_pu_comm = QGroupBox('Commands', self)
gbox_pu_comm.setObjectName('comm')
gbox_pu_comm.setStyleSheet('#comm{border: 0px solid transparent;}')
lay_pu_comm = QVBoxLayout(gbox_pu_comm)
lay_pu_comm.setContentsMargins(20, 9, 20, 9)
lay_pu_comm.addWidget(QLabel(''))
lay_pu_comm.addWidget(
QLabel('<h4>Check</h4>', self, alignment=Qt.AlignCenter))
lay_pu_comm.addWidget(self.checkstatus_pu_bt)
lay_pu_comm.addWidget(QLabel(''))
lay_pu_comm.addWidget(
QLabel('<h4>Prepare</h4>', self, alignment=Qt.AlignCenter))
lay_pu_comm.addWidget(self.voltzero_pu_bt1)
lay_pu_comm.addWidget(self.reset_pu_bt)
lay_pu_comm.addWidget(QLabel(''))
lay_pu_comm.addWidget(
QLabel('<h4>Test</h4>', self, alignment=Qt.AlignCenter))
lay_pu_comm.addWidget(self.turnon_pu_bt)
lay_pu_comm.addWidget(self.enblpulse_pu_bt)
lay_pu_comm.addWidget(self.enbltrigger_pu_bt)
lay_pu_comm.addWidget(self.test_pu_bt)
lay_pu_comm.addWidget(self.voltzero_pu_bt2)
lay_pu_comm.addWidget(QLabel(''))
lay_pu_comm.addWidget(
QLabel('<h4>Restore</h4>', self, alignment=Qt.AlignCenter))
lay_pu_comm.addWidget(self.restoretrigger_pu_bt)
lay_pu_comm.addWidget(QLabel(''))
lay_pu.addWidget(gbox_pu_comm, 0, 1)
lay_pu.setColumnStretch(1, 1)
self.tab.addTab(self.pu_wid, 'PU')
# lists
self.label_lastcomm = QLabel('Last Command: ', self)
self.ok_ps = QListWidget(self)
self.ok_ps.setObjectName('OkList')
self.ok_ps.doubleClicked.connect(self._open_detail)
self.ok_ps.setSelectionMode(QAbstractItemView.MultiSelection)
self.ok_ps.setToolTip(
'Select rows and press Ctrl+C to copy and Esc to deselect.')
self.nok_ps = QListWidget(self)
self.nok_ps.setObjectName('NokList')
self.nok_ps.doubleClicked.connect(self._open_detail)
self.nok_ps.setSelectionMode(QAbstractItemView.MultiSelection)
self.nok_ps.setToolTip(
'Select rows and press Ctrl+C to copy and Esc to deselect.')
self.clearlists_bt = QPushButton('Clear', self)
self.clearlists_bt.clicked.connect(self._clear_lastcomm)
self.ok_ps_aux_list = list()
self.nok_ps_aux_list = list()
hbox = QHBoxLayout()
hbox.addWidget(self.label_lastcomm)
hbox.addWidget(self.clearlists_bt, alignment=Qt.AlignRight)
list_layout = QGridLayout()
list_layout.setContentsMargins(0, 0, 0, 0)
list_layout.setVerticalSpacing(6)
list_layout.setHorizontalSpacing(9)
list_layout.addLayout(hbox, 0, 0, 1, 2)
list_layout.addWidget(
QLabel('<h4>Ok</h4>', self, alignment=Qt.AlignCenter), 1, 0)
list_layout.addWidget(self.ok_ps, 2, 0)
list_layout.addWidget(
QLabel('<h4>Failed</h4>', self, alignment=Qt.AlignCenter), 1, 1)
list_layout.addWidget(self.nok_ps, 2, 1)
# menu
self.menu = self.menuBar()
self.act_cycle = self.menu.addAction('Open Cycle Window')
connect_newprocess(self.act_cycle,
'sirius-hla-as-ps-cycle.py',
parent=self)
self.aux_comm = self.menu.addMenu('Auxiliary commands')
# # auxiliary PS
self.ps_menu = self.aux_comm.addMenu('PS')
self.act_turnoff_ps = self.ps_menu.addAction('Turn PS Off')
self.act_turnoff_ps.triggered.connect(_part(self._set_lastcomm, 'PS'))
self.act_turnoff_ps.triggered.connect(
_part(self._set_check_pwrstate, 'PS', 'off', True))
self.act_turnoff_dclink = self.ps_menu.addAction('Turn DCLinks Off')
self.act_turnoff_dclink.triggered.connect(
_part(self._set_lastcomm, 'PS'))
self.act_turnoff_dclink.triggered.connect(
_part(self._set_check_pwrstate_dclinks, 'off'))
self.act_setcurrent_ps = self.ps_menu.addAction('Set PS Current')
self.act_setcurrent_ps.triggered.connect(
_part(self._set_lastcomm, 'PS'))
self.act_setcurrent_ps.triggered.connect(self._set_check_current)
self.act_opmode_ps = self.ps_menu.addAction('Set PS OpMode')
self.act_opmode_ps.triggered.connect(_part(self._set_lastcomm, 'PS'))
self.act_opmode_ps.triggered.connect(self._set_check_opmode)
# # auxiliary PU
self.pu_menu = self.aux_comm.addMenu('PU')
self.act_turnoff_pu = self.pu_menu.addAction('Turn PU Off')
self.act_turnoff_pu.triggered.connect(_part(self._set_lastcomm, 'PU'))
self.act_turnoff_pu.triggered.connect(
_part(self._set_check_pwrstate, 'PU', 'off', True))
self.act_dsblpulse_pu = self.pu_menu.addAction('Disable PU Pulse')
self.act_dsblpulse_pu.triggered.connect(_part(self._set_lastcomm,
'PU'))
self.act_dsblpulse_pu.triggered.connect(
_part(self._set_check_pulse, 'off'))
# layout
lay = QGridLayout()
lay.setHorizontalSpacing(15)
lay.setVerticalSpacing(5)
lay.addWidget(
QLabel('<h3>Power Supplies Test</h3>',
self,
alignment=Qt.AlignCenter), 0, 0, 1, 3)
lay.addWidget(self.tab, 1, 0)
lay.addLayout(list_layout, 1, 1)
lay.setColumnStretch(0, 2)
lay.setColumnStretch(1, 2)
lay.setRowStretch(0, 2)
lay.setRowStretch(1, 18)
self.central_widget.setLayout(lay)
class PlotSettingsWidget(QWidget):
def __init__(self, settings, plotWidget, parent=None):
super().__init__(parent)
self.mainwindow = parent
self.plotWidget = plotWidget
# xmin
self.xminLabel = QLabel(self.tr('xmin:'))
self.xminSpinBox = CoordSpinBox()
self.xminLabel.setBuddy(self.xminSpinBox)
self.xminSpinBox.editingFinished.connect(self.change_limits)
# xmax
self.xmaxLabel = QLabel(self.tr('xmax:'))
self.xmaxSpinBox = CoordSpinBox()
self.xmaxLabel.setBuddy(self.xmaxSpinBox)
self.xmaxSpinBox.editingFinished.connect(self.change_limits)
# ymin
self.yminLabel = QLabel(self.tr('ymin:'))
self.yminSpinBox = CoordSpinBox()
self.yminLabel.setBuddy(self.yminSpinBox)
self.yminSpinBox.editingFinished.connect(self.change_limits)
# ymax
self.ymaxLabel = QLabel(self.tr('ymax:'))
self.ymaxSpinBox = CoordSpinBox()
self.ymaxLabel.setBuddy(self.ymaxSpinBox)
self.ymaxSpinBox.editingFinished.connect(self.change_limits)
# Autoscale Radio Group
self.autoscaleButtonGroup = QButtonGroup()
# Autoscale Group Box
self.autoscaleGroupBox = QGroupBox()
# autoscale
self.autoscaleRadioButton = QRadioButton(self.tr("autoscale"))
self.autoscaleButtonGroup.addButton(self.autoscaleRadioButton)
# autotrack
self.autoscrollRadioButton = QRadioButton(self.tr("autoscroll"))
self.autoscaleButtonGroup.addButton(self.autoscrollRadioButton)
# no autoscale
self.manualscaleRadioButton = QRadioButton(self.tr("manual"))
self.autoscaleButtonGroup.addButton(self.manualscaleRadioButton)
layout = QVBoxLayout()
layout.addWidget(self.autoscaleRadioButton)
layout.addWidget(self.autoscrollRadioButton)
layout.addWidget(self.manualscaleRadioButton)
self.autoscaleGroupBox.setLayout(layout)
# Layout
layout = QGridLayout()
layout.addWidget(self.xminLabel, 1, 0)
layout.addWidget(self.xminSpinBox, 1, 1)
layout.addWidget(self.xmaxLabel, 2, 0)
layout.addWidget(self.xmaxSpinBox, 2, 1)
layout.addWidget(self.yminLabel, 3, 0)
layout.addWidget(self.yminSpinBox, 3, 1)
layout.addWidget(self.ymaxLabel, 4, 0)
layout.addWidget(self.ymaxSpinBox, 4, 1)
layout.addWidget(self.autoscaleGroupBox, 5, 0, 1, 2)
layout.setRowStretch(6, 1)
self.setLayout(layout)
# settings
self.settings = settings
self.settings.add_handler(S_XMIN, self.xminSpinBox)
self.settings.add_handler(S_XMAX, self.xmaxSpinBox)
self.settings.add_handler(S_YMIN, self.yminSpinBox)
self.settings.add_handler(S_YMAX, self.ymaxSpinBox)
self.settings.add_handler(S_AUTOSCALE, self.autoscaleButtonGroup)
def refresh(self, state):
pass
def change_limits(self):
if self.autoscale != AUTOSCALE_COMPLETE:
self.plotWidget.xmin = self.xmin
self.plotWidget.xmax = self.xmax
self.plotWidget.ymin = self.ymin
self.plotWidget.ymax = self.ymax
self.plotWidget.draw()
@property
def xmin(self):
return self.xminSpinBox.value()
@property
def xmax(self):
return self.xmaxSpinBox.value()
@property
def ymin(self):
return self.yminSpinBox.value()
@property
def ymax(self):
return self.ymaxSpinBox.value()
@property
def autoscale(self):
return self.autoscaleButtonGroup.checkedId()
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.dir = None
self.runconf = RunConfiguration()
firstrun_o = CONF.get('run', ALWAYS_OPEN_FIRST_RUN_OPTION, False)
# --- Interpreter ---
interpreter_group = QGroupBox(_("Console"))
interpreter_layout = QVBoxLayout()
interpreter_group.setLayout(interpreter_layout)
self.current_radio = QRadioButton(CURRENT_INTERPRETER)
interpreter_layout.addWidget(self.current_radio)
self.dedicated_radio = QRadioButton(DEDICATED_INTERPRETER)
interpreter_layout.addWidget(self.dedicated_radio)
self.systerm_radio = QRadioButton(SYSTERM_INTERPRETER)
interpreter_layout.addWidget(self.systerm_radio)
# --- General settings ----
common_group = QGroupBox(_("General settings"))
common_layout = QGridLayout()
common_group.setLayout(common_layout)
self.clear_var_cb = QCheckBox(CLEAR_ALL_VARIABLES)
common_layout.addWidget(self.clear_var_cb, 0, 0)
self.post_mortem_cb = QCheckBox(POST_MORTEM)
common_layout.addWidget(self.post_mortem_cb, 1, 0)
self.clo_cb = QCheckBox(_("Command line options:"))
common_layout.addWidget(self.clo_cb, 2, 0)
self.clo_edit = QLineEdit()
self.clo_cb.toggled.connect(self.clo_edit.setEnabled)
self.clo_edit.setEnabled(False)
common_layout.addWidget(self.clo_edit, 2, 1)
# --- Working directory ---
wdir_group = QGroupBox(_("Working Directory settings"))
wdir_layout = QVBoxLayout()
wdir_group.setLayout(wdir_layout)
self.file_dir_radio = QRadioButton(FILE_DIR)
wdir_layout.addWidget(self.file_dir_radio)
self.cwd_radio = QRadioButton(CW_DIR)
wdir_layout.addWidget(self.cwd_radio)
fixed_dir_layout = QHBoxLayout()
self.fixed_dir_radio = QRadioButton(FIXED_DIR)
fixed_dir_layout.addWidget(self.fixed_dir_radio)
self.wd_edit = QLineEdit()
self.fixed_dir_radio.toggled.connect(self.wd_edit.setEnabled)
self.wd_edit.setEnabled(False)
fixed_dir_layout.addWidget(self.wd_edit)
browse_btn = QPushButton(ima.icon('DirOpenIcon'), '', self)
browse_btn.setToolTip(_("Select directory"))
browse_btn.clicked.connect(self.select_directory)
fixed_dir_layout.addWidget(browse_btn)
wdir_layout.addLayout(fixed_dir_layout)
# --- System terminal ---
external_group = QGroupBox(_("External system terminal"))
external_group.setDisabled(True)
self.systerm_radio.toggled.connect(external_group.setEnabled)
external_layout = QGridLayout()
external_group.setLayout(external_layout)
self.interact_cb = QCheckBox(INTERACT)
external_layout.addWidget(self.interact_cb, 1, 0, 1, -1)
self.pclo_cb = QCheckBox(_("Command line options:"))
external_layout.addWidget(self.pclo_cb, 3, 0)
self.pclo_edit = QLineEdit()
self.pclo_cb.toggled.connect(self.pclo_edit.setEnabled)
self.pclo_edit.setEnabled(False)
self.pclo_edit.setToolTip(
_("<b>-u</b> is added to the "
"other options you set here"))
external_layout.addWidget(self.pclo_edit, 3, 1)
# Checkbox to preserve the old behavior, i.e. always open the dialog
# on first run
hline = QFrame()
hline.setFrameShape(QFrame.HLine)
hline.setFrameShadow(QFrame.Sunken)
self.firstrun_cb = QCheckBox(ALWAYS_OPEN_FIRST_RUN % _("this dialog"))
self.firstrun_cb.clicked.connect(self.set_firstrun_o)
self.firstrun_cb.setChecked(firstrun_o)
layout = QVBoxLayout()
layout.addWidget(interpreter_group)
layout.addWidget(common_group)
layout.addWidget(wdir_group)
layout.addWidget(external_group)
layout.addWidget(hline)
layout.addWidget(self.firstrun_cb)
self.setLayout(layout)
def setup_page(self):
about_label = QLabel(_("The following are the default options for "
"running files.These options may be overriden "
"using the <b>Configuration per file</b> entry "
"of the <b>Run</b> menu."))
about_label.setWordWrap(True)
interpreter_group = QGroupBox(_("Console"))
interpreter_bg = QButtonGroup(interpreter_group)
self.current_radio = self.create_radiobutton(CURRENT_INTERPRETER,
CURRENT_INTERPRETER_OPTION, True,
button_group=interpreter_bg)
self.dedicated_radio = self.create_radiobutton(DEDICATED_INTERPRETER,
DEDICATED_INTERPRETER_OPTION, False,
button_group=interpreter_bg)
self.systerm_radio = self.create_radiobutton(SYSTERM_INTERPRETER,
SYSTERM_INTERPRETER_OPTION, False,
button_group=interpreter_bg)
interpreter_layout = QVBoxLayout()
interpreter_group.setLayout(interpreter_layout)
interpreter_layout.addWidget(self.current_radio)
interpreter_layout.addWidget(self.dedicated_radio)
interpreter_layout.addWidget(self.systerm_radio)
general_group = QGroupBox(_("General settings"))
post_mortem = self.create_checkbox(POST_MORTEM, 'post_mortem', False)
clear_variables = self.create_checkbox(CLEAR_ALL_VARIABLES,
'clear_namespace', False)
general_layout = QVBoxLayout()
general_layout.addWidget(clear_variables)
general_layout.addWidget(post_mortem)
general_group.setLayout(general_layout)
wdir_group = QGroupBox(_("Working Directory settings"))
wdir_bg = QButtonGroup(wdir_group)
wdir_label = QLabel(_("Default working directory is:"))
wdir_label.setWordWrap(True)
dirname_radio = self.create_radiobutton(
FILE_DIR,
WDIR_USE_SCRIPT_DIR_OPTION, True,
button_group=wdir_bg)
cwd_radio = self.create_radiobutton(
CW_DIR,
WDIR_USE_CWD_DIR_OPTION, False,
button_group=wdir_bg)
thisdir_radio = self.create_radiobutton(
FIXED_DIR,
WDIR_USE_FIXED_DIR_OPTION, False,
button_group=wdir_bg)
thisdir_bd = self.create_browsedir("", WDIR_FIXED_DIR_OPTION,
getcwd_or_home())
thisdir_radio.toggled.connect(thisdir_bd.setEnabled)
dirname_radio.toggled.connect(thisdir_bd.setDisabled)
cwd_radio.toggled.connect(thisdir_bd.setDisabled)
thisdir_layout = QHBoxLayout()
thisdir_layout.addWidget(thisdir_radio)
thisdir_layout.addWidget(thisdir_bd)
wdir_layout = QVBoxLayout()
wdir_layout.addWidget(wdir_label)
wdir_layout.addWidget(dirname_radio)
wdir_layout.addWidget(cwd_radio)
wdir_layout.addLayout(thisdir_layout)
wdir_group.setLayout(wdir_layout)
external_group = QGroupBox(_("External system terminal"))
interact_after = self.create_checkbox(INTERACT, 'interact', False)
external_layout = QVBoxLayout()
external_layout.addWidget(interact_after)
external_group.setLayout(external_layout)
firstrun_cb = self.create_checkbox(
ALWAYS_OPEN_FIRST_RUN % _("Run Settings dialog"),
ALWAYS_OPEN_FIRST_RUN_OPTION, False)
vlayout = QVBoxLayout()
vlayout.addWidget(about_label)
vlayout.addSpacing(10)
vlayout.addWidget(interpreter_group)
vlayout.addWidget(general_group)
vlayout.addWidget(wdir_group)
vlayout.addWidget(external_group)
vlayout.addWidget(firstrun_cb)
vlayout.addStretch(1)
self.setLayout(vlayout)
def setup_page(self):
about_label = QLabel(
_("The following are the default options for "
"running files.These options may be overriden "
"using the <b>Configuration per file</b> entry "
"of the <b>Run</b> menu."))
about_label.setWordWrap(True)
interpreter_group = QGroupBox(_("Console"))
interpreter_bg = QButtonGroup(interpreter_group)
self.current_radio = self.create_radiobutton(
CURRENT_INTERPRETER,
CURRENT_INTERPRETER_OPTION,
True,
button_group=interpreter_bg)
self.dedicated_radio = self.create_radiobutton(
DEDICATED_INTERPRETER,
DEDICATED_INTERPRETER_OPTION,
False,
button_group=interpreter_bg)
self.systerm_radio = self.create_radiobutton(
SYSTERM_INTERPRETER,
SYSTERM_INTERPRETER_OPTION,
False,
button_group=interpreter_bg)
interpreter_layout = QVBoxLayout()
interpreter_group.setLayout(interpreter_layout)
interpreter_layout.addWidget(self.current_radio)
interpreter_layout.addWidget(self.dedicated_radio)
interpreter_layout.addWidget(self.systerm_radio)
general_group = QGroupBox(_("General settings"))
post_mortem = self.create_checkbox(POST_MORTEM, 'post_mortem', False)
clear_variables = self.create_checkbox(CLEAR_ALL_VARIABLES,
'clear_namespace', False)
general_layout = QVBoxLayout()
general_layout.addWidget(clear_variables)
general_layout.addWidget(post_mortem)
general_group.setLayout(general_layout)
wdir_group = QGroupBox(_("Working Directory settings"))
wdir_bg = QButtonGroup(wdir_group)
wdir_label = QLabel(_("Default working directory is:"))
wdir_label.setWordWrap(True)
dirname_radio = self.create_radiobutton(FILE_DIR,
WDIR_USE_SCRIPT_DIR_OPTION,
True,
button_group=wdir_bg)
cwd_radio = self.create_radiobutton(CW_DIR,
WDIR_USE_CWD_DIR_OPTION,
False,
button_group=wdir_bg)
thisdir_radio = self.create_radiobutton(FIXED_DIR,
WDIR_USE_FIXED_DIR_OPTION,
False,
button_group=wdir_bg)
thisdir_bd = self.create_browsedir("", WDIR_FIXED_DIR_OPTION, getcwd())
thisdir_radio.toggled.connect(thisdir_bd.setEnabled)
dirname_radio.toggled.connect(thisdir_bd.setDisabled)
cwd_radio.toggled.connect(thisdir_bd.setDisabled)
thisdir_layout = QHBoxLayout()
thisdir_layout.addWidget(thisdir_radio)
thisdir_layout.addWidget(thisdir_bd)
wdir_layout = QVBoxLayout()
wdir_layout.addWidget(wdir_label)
wdir_layout.addWidget(dirname_radio)
wdir_layout.addWidget(cwd_radio)
wdir_layout.addLayout(thisdir_layout)
wdir_group.setLayout(wdir_layout)
external_group = QGroupBox(_("External system terminal"))
interact_after = self.create_checkbox(INTERACT, 'interact', False)
external_layout = QVBoxLayout()
external_layout.addWidget(interact_after)
external_group.setLayout(external_layout)
firstrun_cb = self.create_checkbox(
ALWAYS_OPEN_FIRST_RUN % _("Run Settings dialog"),
ALWAYS_OPEN_FIRST_RUN_OPTION, False)
vlayout = QVBoxLayout()
vlayout.addWidget(about_label)
vlayout.addSpacing(10)
vlayout.addWidget(interpreter_group)
vlayout.addWidget(general_group)
vlayout.addWidget(wdir_group)
vlayout.addWidget(external_group)
vlayout.addWidget(firstrun_cb)
vlayout.addStretch(1)
self.setLayout(vlayout)
def __init__(self, parent):
super().__init__(parent)
newcb = self.create_checkbox
pep_url = (
'<a href="https://www.python.org/dev/peps/pep-0008">PEP 8</a>')
code_style_codes_url = _(
"<a href='http://pycodestyle.pycqa.org/en/stable"
"/intro.html#error-codes'>pycodestyle error codes</a>")
code_style_label = QLabel(
_("Spyder can use pycodestyle to analyze your code for "
"conformance to the {} convention. You can also "
"manually show or hide specific warnings by their "
"{}.").format(pep_url, code_style_codes_url))
code_style_label.setOpenExternalLinks(True)
code_style_label.setWordWrap(True)
# Code style checkbox
self.code_style_check = self.create_checkbox(
_("Enable code style linting"),
'pycodestyle')
# Code style options
self.code_style_filenames_match = self.create_lineedit(
_("Only check filenames matching these patterns:"),
'pycodestyle/filename', alignment=Qt.Horizontal, word_wrap=False,
placeholder=_("Check Python files: *.py"))
self.code_style_exclude = self.create_lineedit(
_("Exclude files or directories matching these patterns:"),
'pycodestyle/exclude', alignment=Qt.Horizontal, word_wrap=False,
placeholder=_("Exclude all test files: (?!test_).*\\.py"))
code_style_select = self.create_lineedit(
_("Show the following errors or warnings:").format(
code_style_codes_url),
'pycodestyle/select', alignment=Qt.Horizontal, word_wrap=False,
placeholder=_("Example codes: E113, W391"))
code_style_ignore = self.create_lineedit(
_("Ignore the following errors or warnings:"),
'pycodestyle/ignore', alignment=Qt.Horizontal, word_wrap=False,
placeholder=_("Example codes: E201, E303"))
self.code_style_max_line_length = self.create_spinbox(
_("Maximum allowed line length:"), None,
'pycodestyle/max_line_length', min_=10, max_=500, step=1,
tip=_("Default is 79"))
vertical_line_box = newcb(
_("Show vertical line at that length"), 'edge_line',
section='editor')
# Code style layout
code_style_g_layout = QGridLayout()
code_style_g_layout.addWidget(
self.code_style_filenames_match.label, 1, 0)
code_style_g_layout.addWidget(
self.code_style_filenames_match.textbox, 1, 1)
code_style_g_layout.addWidget(self.code_style_exclude.label, 2, 0)
code_style_g_layout.addWidget(self.code_style_exclude.textbox, 2, 1)
code_style_g_layout.addWidget(code_style_select.label, 3, 0)
code_style_g_layout.addWidget(code_style_select.textbox, 3, 1)
code_style_g_layout.addWidget(code_style_ignore.label, 4, 0)
code_style_g_layout.addWidget(code_style_ignore.textbox, 4, 1)
# Set Code style options enabled/disabled
code_style_g_widget = QWidget()
code_style_g_widget.setLayout(code_style_g_layout)
code_style_g_widget.setEnabled(self.get_option('pycodestyle'))
self.code_style_check.toggled.connect(code_style_g_widget.setEnabled)
# Code style layout
code_style_group = QGroupBox(_("Code style"))
code_style_layout = QVBoxLayout()
code_style_layout.addWidget(code_style_label)
code_style_layout.addWidget(self.code_style_check)
code_style_layout.addWidget(code_style_g_widget)
code_style_group.setLayout(code_style_layout)
# Maximum allowed line length layout
line_length_group = QGroupBox(_("Line length"))
line_length_layout = QVBoxLayout()
line_length_layout.addWidget(self.code_style_max_line_length)
line_length_layout.addWidget(vertical_line_box)
line_length_group.setLayout(line_length_layout)
# Code formatting label
autopep8_url = (
"<a href='https://github.com/hhatto/autopep8'>Autopep8</a>"
)
yapf_url = (
"<a href='https://github.com/google/yapf'>Yapf</a>"
)
black_url = (
"<a href='https://black.readthedocs.io/en/stable'>Black</a>"
)
code_fmt_label = QLabel(
_("Spyder can use {0} or {1} to format your code for "
"conformance to the {2} convention.").format(
autopep8_url, black_url, pep_url))
code_fmt_label.setOpenExternalLinks(True)
code_fmt_label.setWordWrap(True)
# Code formatting providers
code_fmt_provider = self.create_combobox(
_("Choose the code formatting provider: "),
(("autopep8", 'autopep8'),
("black", 'black')),
'formatting')
# Autoformat on save
format_on_save_box = newcb(
_("Autoformat files on save"),
'format_on_save',
tip=_("If enabled, autoformatting will take place when "
"saving a file"))
# Code formatting layout
code_fmt_group = QGroupBox(_("Code formatting"))
code_fmt_layout = QVBoxLayout()
code_fmt_layout.addWidget(code_fmt_label)
code_fmt_layout.addWidget(code_fmt_provider)
code_fmt_layout.addWidget(format_on_save_box)
code_fmt_group.setLayout(code_fmt_layout)
code_style_fmt_layout = QVBoxLayout()
code_style_fmt_layout.addWidget(code_style_group)
code_style_fmt_layout.addWidget(code_fmt_group)
code_style_fmt_layout.addWidget(line_length_group)
self.setLayout(code_style_fmt_layout)
def _setupUi(self):
title = QLabel(self.title, self, alignment=Qt.AlignCenter)
title.setStyleSheet("font-weight: bold;")
title.setSizePolicy(QSzPlcy.Preferred, QSzPlcy.Maximum)
# limit setpoints
self._wid_lims = QGroupBox('Select Thresholds: ')
lay_lims = QGridLayout(self._wid_lims)
lay_lims.setAlignment(Qt.AlignTop)
row = 0
if 'sum' in self.metric:
text = '\nThresholds must be set in Monit1 rate\n'\
'counts. Here we make available you \n'\
'to read Sum-Mon values, in Monit rate\n'\
'counts, and convert them to Monit1\n'\
'rate counts using calibration curves.\n'\
'You can also apply a scale factor to\n'\
'the values read.\n\n'
self._label_help = QLabel(text, self)
lay_lims.addWidget(self._label_help, row, 0, 1, 2)
row += 1
self._pb_get = QPushButton('Get current Sum-Mon', self)
self._pb_get.released.connect(self._get_new_sum)
lay_lims.addWidget(self._pb_get, row, 0, 1, 2)
row += 1
self._label_getsts = QLabel('\n', self)
lay_lims.addWidget(self._label_getsts, row, 0, 1, 2)
row += 1
self._label_scl = QLabel('Scale: ', self)
lay_lims.addWidget(self._label_scl, row, 0)
self._spin_scl = QDoubleSpinBox(self)
self._spin_scl.setDecimals(2)
self._spin_scl.setValue(1.00)
self._spin_scl.setMinimum(-100.00)
self._spin_scl.setMaximum(+100.00)
lay_lims.addWidget(self._spin_scl, row, 1)
else:
self._head_value = QLabel('Value', self, alignment=Qt.AlignCenter)
lay_lims.addWidget(self._head_value, 0, 1)
self._head_send = QLabel('Apply', self, alignment=Qt.AlignCenter)
lay_lims.addWidget(self._head_send, 0, 2)
self._spins, self._checks = dict(), dict()
for lsp in self.lim_sp:
row += 1
text = lsp.split('-')[0].split('Lmt')[1] + ' [nm]: '
label = QLabel(text, self, alignment=Qt.AlignRight)
lay_lims.addWidget(label, row, 0)
spin = QSpinBox(self)
self._spins[lsp] = spin
spin.setValue(0)
spin.setMinimum(-1e9)
spin.setMaximum(1e9)
lay_lims.addWidget(spin, row, 1)
check = QCheckBox(self)
self._checks[lsp] = check
lay_lims.addWidget(check, row, 2, alignment=Qt.AlignCenter)
row += 1
self._label_reforb = QLabel(
'\nChoose Ref.Orb. to calculate reference\n' +
self.title.lower() +
' around which we\napply the values above:')
lay_lims.addWidget(self._label_reforb, row, 0, 1, 3)
row += 1
self._cb_reforb = RefOrbComboBox(self)
self._cb_reforb.refOrbChanged.connect(self._set_ref_orb)
lay_lims.addWidget(self._cb_reforb, row, 0, 1, 3)
if 'trans' in self.metric:
text = '\n\nBPM calculation consider the translation\n' \
'estimative:' \
'\n\n(pos@downstream+pos@upstream)/2\n\n' \
'where the pairs upstream/downstream\nfolow:\n' \
' - M1/M2\n' \
' - C1-1/C1-2\n' \
' - C2/C3-1\n' \
' - C3-2/C4\n'
elif 'ang' in self.metric:
text = '\n\nBPM calculation consider the angulation\n' \
'estimative:' \
'\n\n(pos@downstream - pos@upstream)\n\n' \
'where the pairs upstream/downstream\nfolow:\n' \
' - M1/M2\n' \
' - C1-1/C1-2\n' \
' - C2/C3-1\n' \
' - C3-2/C4\n'
row += 1
self._label_help = QLabel(text, self)
lay_lims.addWidget(self._label_help, row, 0, 1, 3)
# BPM selection
groupsel = QGroupBox('Select BPMs:')
groupsel.setObjectName('groupsel')
groupsel.setStyleSheet('#groupsel{min-width: 27em; max-width: 27em;}')
self._bpm_sel = _BPMSelectionWidget(self,
show_toggle_all_false=False,
toggle_all_true_text='Select All',
prefix=self.prefix)
lay_groupsel = QGridLayout(groupsel)
lay_groupsel.addWidget(self._bpm_sel)
# connect signals and slots
self._bpm_sel.applyChangesClicked.connect(self.send_value)
lay = QGridLayout(self)
lay.addWidget(title, 0, 0, 1, 2)
lay.addWidget(self._wid_lims, 1, 0)
lay.addWidget(groupsel, 1, 1)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.current_radio = None
self.dedicated_radio = None
self.systerm_radio = None
self.runconf = RunConfiguration()
firstrun_o = CONF.get("run", ALWAYS_OPEN_FIRST_RUN_OPTION, False)
# --- General settings ----
common_group = QGroupBox(_("General settings"))
common_layout = QGridLayout()
common_group.setLayout(common_layout)
self.clo_cb = QCheckBox(_("Command line options:"))
common_layout.addWidget(self.clo_cb, 0, 0)
self.clo_edit = QLineEdit()
self.clo_cb.toggled.connect(self.clo_edit.setEnabled)
self.clo_edit.setEnabled(False)
common_layout.addWidget(self.clo_edit, 0, 1)
self.wd_cb = QCheckBox(_("Working directory:"))
common_layout.addWidget(self.wd_cb, 1, 0)
wd_layout = QHBoxLayout()
self.wd_edit = QLineEdit()
self.wd_cb.toggled.connect(self.wd_edit.setEnabled)
self.wd_edit.setEnabled(False)
wd_layout.addWidget(self.wd_edit)
browse_btn = QPushButton(ima.icon("DirOpenIcon"), "", self)
browse_btn.setToolTip(_("Select directory"))
browse_btn.clicked.connect(self.select_directory)
wd_layout.addWidget(browse_btn)
common_layout.addLayout(wd_layout, 1, 1)
self.post_mortem_cb = QCheckBox(_("Enter debugging mode when " "errors appear during execution"))
common_layout.addWidget(self.post_mortem_cb)
# --- Interpreter ---
interpreter_group = QGroupBox(_("Console"))
interpreter_layout = QVBoxLayout()
interpreter_group.setLayout(interpreter_layout)
self.current_radio = QRadioButton(CURRENT_INTERPRETER)
interpreter_layout.addWidget(self.current_radio)
self.dedicated_radio = QRadioButton(DEDICATED_INTERPRETER)
interpreter_layout.addWidget(self.dedicated_radio)
self.systerm_radio = QRadioButton(SYSTERM_INTERPRETER)
interpreter_layout.addWidget(self.systerm_radio)
# --- Dedicated interpreter ---
new_group = QGroupBox(_("Dedicated Python console"))
self.current_radio.toggled.connect(new_group.setDisabled)
new_layout = QGridLayout()
new_group.setLayout(new_layout)
self.interact_cb = QCheckBox(_("Interact with the Python " "console after execution"))
new_layout.addWidget(self.interact_cb, 1, 0, 1, -1)
self.show_kill_warning_cb = QCheckBox(_("Show warning when killing" " running process"))
new_layout.addWidget(self.show_kill_warning_cb, 2, 0, 1, -1)
self.pclo_cb = QCheckBox(_("Command line options:"))
new_layout.addWidget(self.pclo_cb, 3, 0)
self.pclo_edit = QLineEdit()
self.pclo_cb.toggled.connect(self.pclo_edit.setEnabled)
self.pclo_edit.setEnabled(False)
self.pclo_edit.setToolTip(_("<b>-u</b> is added to the " "other options you set here"))
new_layout.addWidget(self.pclo_edit, 3, 1)
# Checkbox to preserve the old behavior, i.e. always open the dialog
# on first run
hline = QFrame()
hline.setFrameShape(QFrame.HLine)
hline.setFrameShadow(QFrame.Sunken)
self.firstrun_cb = QCheckBox(ALWAYS_OPEN_FIRST_RUN % _("this dialog"))
self.firstrun_cb.clicked.connect(self.set_firstrun_o)
self.firstrun_cb.setChecked(firstrun_o)
layout = QVBoxLayout()
layout.addWidget(interpreter_group)
layout.addWidget(common_group)
layout.addWidget(new_group)
layout.addWidget(hline)
layout.addWidget(self.firstrun_cb)
self.setLayout(layout)
class SegmentationWidget(QWidget):
def __init__(
self,
viewer: napari.viewer.Viewer,
boundaries_string=BOUNDARIES_STRING,
):
super(SegmentationWidget, self).__init__()
# general variables
self.viewer = viewer
# Main layers
self.base_layer = [] # Contains registered brain / reference brain
self.atlas_layer = [] # Contains annotations / region information
# Other data
self.hemispheres_data = []
# Track variables
self.track_layers = []
# Region variables
self.label_layers = []
# Atlas variables
self.current_atlas_name = ""
self.atlas = None
self.boundaries_string = boundaries_string
self.directory = ""
# Set up segmentation methods
self.region_seg = RegionSeg(self)
self.track_seg = TrackSeg(self)
# Generate main layout
self.setup_main_layout()
if DISPLAY_REGION_INFO:
@self.viewer.mouse_move_callbacks.append
def display_region_info(v, event):
"""
Show brain region info on mouse over in status bar on the right
"""
assert self.viewer == v
if v.dims.ndisplay == 2:
if len(v.layers) and self.atlas_layer and self.atlas:
_, _, _, region_info = structure_from_viewer(
self.viewer.status, self.atlas_layer, self.atlas)
self.viewer.help = region_info
else:
self.viewer.help = ""
def setup_main_layout(self):
"""
Construct main layout of widget
"""
self.layout = QGridLayout()
self.layout.setContentsMargins(10, 10, 10, 10)
self.layout.setAlignment(QtCore.Qt.AlignTop)
self.layout.setSpacing(4)
# 3 Steps:
# - Loading panel
# - Segmentation methods panel
# -> Individual segmentation methods (which are invisible at first)
# - Saving panel
self.add_loading_panel(1)
self.add_segmentation_methods_panel(1)
self.track_seg.add_track_panel(2) # Track segmentation subpanel
self.region_seg.add_region_panel(3) # Region segmentation subpanel
self.add_saving_panel(4)
# Take care of status label
self.status_label = QLabel()
self.status_label.setText("Ready")
self.layout.addWidget(self.status_label, 5, 0)
self.setLayout(self.layout)
# PANELS ###############################################################
def add_segmentation_methods_panel(self, row, column=1):
"""
Segmentation methods chooser panel:
Toggle visibility of segmentation
methods
"""
self.toggle_methods_panel = QGroupBox("Segmentation")
self.toggle_methods_layout = QGridLayout()
self.toggle_methods_layout.setContentsMargins(10, 10, 10, 10)
self.toggle_methods_layout.setSpacing(5)
self.toggle_methods_layout.setAlignment(QtCore.Qt.AlignBottom)
self.show_trackseg_button = add_button(
"Track tracing",
self.toggle_methods_layout,
self.track_seg.toggle_track_panel,
0,
1,
minimum_width=COLUMN_WIDTH,
alignment=SEGM_METHODS_PANEL_ALIGN,
)
self.show_trackseg_button.setEnabled(False)
self.show_regionseg_button = add_button(
"Region segmentation",
self.toggle_methods_layout,
self.region_seg.toggle_region_panel,
1,
1,
minimum_width=COLUMN_WIDTH,
alignment=SEGM_METHODS_PANEL_ALIGN,
)
self.show_regionseg_button.setEnabled(False)
self.toggle_methods_layout.setColumnMinimumWidth(1, COLUMN_WIDTH)
self.toggle_methods_panel.setLayout(self.toggle_methods_layout)
self.toggle_methods_panel.setVisible(True)
self.layout.addWidget(self.toggle_methods_panel, row, column, 1, 1)
def add_loading_panel(self, row, column=0):
"""
Loading panel:
- Load project (sample space)
- Load project (atlas space)
- Atlas chooser
"""
self.load_data_panel = QGroupBox("Load data")
self.load_data_layout = QGridLayout()
self.load_data_layout.setSpacing(15)
self.load_data_layout.setContentsMargins(10, 10, 10, 10)
self.load_data_layout.setAlignment(QtCore.Qt.AlignBottom)
self.load_button = add_button(
"Load project (sample space)",
self.load_data_layout,
self.load_brainreg_directory_sample,
0,
0,
visibility=False,
minimum_width=COLUMN_WIDTH,
alignment=LOADING_PANEL_ALIGN,
)
self.load_button_standard = add_button(
"Load project (atlas space)",
self.load_data_layout,
self.load_brainreg_directory_standard,
1,
0,
visibility=False,
minimum_width=COLUMN_WIDTH,
alignment=LOADING_PANEL_ALIGN,
)
self.add_atlas_menu(self.load_data_layout)
self.load_data_layout.setColumnMinimumWidth(0, COLUMN_WIDTH)
self.load_data_panel.setLayout(self.load_data_layout)
self.load_data_panel.setVisible(True)
self.layout.addWidget(self.load_data_panel, row, column, 1, 1)
# buttons made visible after adding to main widget, preventing them
# from briefly appearing in a separate window
self.load_button.setVisible(True)
self.load_button_standard.setVisible(True)
def add_saving_panel(self, row):
"""
Saving/Export panel
"""
self.save_data_panel = QGroupBox()
self.save_data_layout = QGridLayout()
self.export_button = add_button(
"To brainrender",
self.save_data_layout,
self.export_to_brainrender,
0,
0,
visibility=False,
)
self.save_button = add_button("Save",
self.save_data_layout,
self.save,
0,
1,
visibility=False)
self.save_data_layout.setColumnMinimumWidth(1, COLUMN_WIDTH)
self.save_data_panel.setLayout(self.save_data_layout)
self.layout.addWidget(self.save_data_panel, row, 0, 1, 2)
self.save_data_panel.setVisible(False)
# ATLAS INTERACTION ####################################################
def add_atlas_menu(self, layout):
list_of_atlasses = ["Load atlas"]
available_atlases = get_available_atlases()
for atlas in available_atlases.keys():
atlas_desc = f"{atlas} v{available_atlases[atlas]}"
list_of_atlasses.append(atlas_desc)
atlas_menu, _ = add_combobox(
layout,
None,
list_of_atlasses,
2,
0,
label_stack=True,
callback=self.initialise_atlas,
width=COLUMN_WIDTH,
)
self.atlas_menu = atlas_menu
def initialise_atlas(self):
atlas_string = self.atlas_menu.currentText()
atlas_name = atlas_string.split(" ")[0].strip()
if atlas_name != self.current_atlas_name:
status = self.remove_layers()
if not status: # Something prevented deletion
self.reset_atlas_menu()
return
else:
print(f"{atlas_string} already selected for segmentation.")
self.reset_atlas_menu()
return
# Get / set output directory
self.set_output_directory()
if not self.directory:
self.reset_atlas_menu()
return
self.current_atlas_name = atlas_name
# Instantiate atlas layers
self.load_atlas()
self.directory = self.directory / atlas_name
self.paths = Paths(self.directory, atlas_space=True)
self.status_label.setText("Ready")
# Set window title
self.initialise_segmentation_interface()
# Check / load previous regions and tracks
self.region_seg.check_saved_region()
self.track_seg.check_saved_track()
self.reset_atlas_menu()
def set_output_directory(self):
self.status_label.setText("Loading...")
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
self.directory = QFileDialog.getExistingDirectory(
self,
"Select output directory",
options=options,
)
if self.directory != "":
self.directory = Path(self.directory)
def load_atlas(self):
atlas = BrainGlobeAtlas(self.current_atlas_name)
self.atlas = atlas
self.base_layer = self.viewer.add_image(
self.atlas.reference,
name="Reference",
)
self.atlas_layer = self.viewer.add_labels(
self.atlas.annotation,
name=self.atlas.atlas_name,
blending="additive",
opacity=0.3,
visible=False,
)
self.standard_space = True
def reset_atlas_menu(self):
# Reset menu for atlas - show initial description
self.atlas_menu.blockSignals(True)
self.atlas_menu.setCurrentIndex(0)
self.atlas_menu.blockSignals(False)
# BRAINREG INTERACTION #################################################
def load_brainreg_directory_sample(self):
self.get_brainreg_directory(standard_space=False)
def load_brainreg_directory_standard(self):
self.get_brainreg_directory(standard_space=True)
def get_brainreg_directory(self, standard_space):
"""
Shows file dialog to choose output directory
and sets global directory info
"""
if standard_space:
self.plugin = (
"brainglobe-napari-io.brainreg_read_dir_standard_space")
self.standard_space = True
else:
self.plugin = "brainglobe-napari-io.brainreg_read_dir"
self.standard_space = False
self.status_label.setText("Loading...")
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
brainreg_directory = QFileDialog.getExistingDirectory(
self,
"Select brainreg directory",
options=options,
)
if not brainreg_directory:
return
if self.directory != brainreg_directory:
status = self.remove_layers()
if not status:
return # Something prevented deletion
self.directory = Path(brainreg_directory)
else:
print(f"{str(brainreg_directory)} already loaded.")
return
# Otherwise, proceed loading brainreg dir
self.load_brainreg_directory()
def load_brainreg_directory(self):
"""
Opens brainreg folder in napari.
Calls initialise_loaded_data to set up layers / info.
Then checks for previously loaded data.
"""
try:
self.viewer.open(str(self.directory), plugin=self.plugin)
self.paths = Paths(
self.directory,
standard_space=self.standard_space,
)
self.initialise_loaded_data()
except ValueError:
print(f"The directory ({self.directory}) does not appear to be "
f"a brainreg directory, please try again.")
return
# Check / load previous regions and tracks
self.region_seg.check_saved_region()
self.track_seg.check_saved_track()
def initialise_loaded_data(self):
"""
Set up brainreg layers in napari / fill with new data and info
"""
try:
self.viewer.layers.remove(self.boundaries_string)
except ValueError:
pass
self.base_layer = self.viewer.layers["Registered image"]
self.metadata = self.base_layer.metadata
self.atlas = self.metadata["atlas_class"]
self.atlas_layer = self.viewer.layers[self.metadata["atlas"]]
if self.standard_space:
self.hemispheres_data = self.atlas.hemispheres
else:
self.hemispheres_data = self.viewer.layers["Hemispheres"].data
self.initialise_segmentation_interface()
self.status_label.setText("Ready")
# MORE LAYOUT COMPONENTS ###########################################
def initialise_segmentation_interface(self):
self.reset_variables()
self.initialise_image_view()
self.save_data_panel.setVisible(True)
self.save_button.setVisible(True)
self.export_button.setVisible(self.standard_space)
self.show_regionseg_button.setEnabled(True)
self.show_trackseg_button.setEnabled(True)
self.status_label.setText("Ready")
def initialise_image_view(self):
self.set_z_position()
def set_z_position(self):
midpoint = int(round(len(self.base_layer.data) / 2))
self.viewer.dims.set_point(0, midpoint)
def reset_variables(self):
"""
Reset atlas scale dependent variables
- point_size (Track segmentation)
- spline_size (Track segmentation)
- brush_size (Region segmentation)
"""
self.mean_voxel_size = int(
np.sum(self.atlas.resolution) / len(self.atlas.resolution))
self.track_seg.point_size = (self.track_seg.point_size_default /
self.mean_voxel_size)
self.track_seg.spline_size = (self.track_seg.spline_size_default /
self.mean_voxel_size)
self.region_seg.brush_size = (self.region_seg.brush_size_default /
self.mean_voxel_size)
return
def remove_layers(self):
"""
TODO: This needs work. Runs into an error currently
when switching from a annotated project to another one
"""
if len(self.viewer.layers) != 0:
# Check with user if that is really what is wanted
if self.track_layers or self.label_layers:
choice = display_warning(
self,
"About to remove layers",
"All layers are about to be deleted. Proceed?",
)
if not choice:
print('Preventing deletion because user chose "Cancel"')
return False
# Remove old layers
for layer in list(self.viewer.layers):
try:
self.viewer.layers.remove(layer)
except IndexError: # no idea why this happens
pass
self.track_layers = []
self.label_layers = []
return True
def save(self, override=True):
if self.label_layers or self.track_layers:
if not override:
choice = display_warning(
self,
"About to save files",
"Existing files will be will be deleted. Proceed?",
)
else:
choice = True # for debugging
if choice:
print("Saving")
worker = save_all(
self.paths.regions_directory,
self.paths.tracks_directory,
self.label_layers,
self.track_layers,
track_file_extension=TRACK_FILE_EXT,
)
worker.start()
else:
print('Not saving because user chose "Cancel" \n')
def export_to_brainrender(self, override=False):
if not override:
choice = display_warning(
self,
"About to export files",
"Existing files will be will be deleted. Proceed?",
)
else:
choice = True # for debugging
if choice:
print("Exporting")
worker = export_all(
self.paths.regions_directory,
self.paths.tracks_directory,
self.label_layers,
self.track_seg.splines,
self.track_seg.spline_names,
self.atlas.resolution[0],
)
worker.start()
else:
print('Not exporting because user chose "Cancel" \n')
def setup_page(self):
# Connections group
connections_group = QGroupBox(_("Automatic connections"))
connections_label = QLabel(
_("This pane can automatically "
"show an object's help information after "
"a left parenthesis is written next to it. "
"Below you can decide to which plugin "
"you want to connect it to turn on this "
"feature."))
connections_label.setWordWrap(True)
editor_box = self.create_checkbox(_("Editor"), 'connect/editor')
rope_installed = programs.is_module_installed('rope')
jedi_installed = programs.is_module_installed('jedi', '>=0.8.1')
editor_box.setEnabled(rope_installed or jedi_installed)
if not rope_installed and not jedi_installed:
editor_tip = _(
"This feature requires the Rope or Jedi libraries.\n"
"It seems you don't have either installed.")
editor_box.setToolTip(editor_tip)
ipython_box = self.create_checkbox(_("IPython Console"),
'connect/ipython_console')
connections_layout = QVBoxLayout()
connections_layout.addWidget(connections_label)
connections_layout.addWidget(editor_box)
connections_layout.addWidget(ipython_box)
connections_group.setLayout(connections_layout)
# Features group
features_group = QGroupBox(_("Additional features"))
math_box = self.create_checkbox(_("Render mathematical equations"),
'math')
req_sphinx = programs.is_module_installed('sphinx', '>=1.1')
math_box.setEnabled(req_sphinx)
if not req_sphinx:
sphinx_ver = programs.get_module_version('sphinx')
sphinx_tip = _("This feature requires Sphinx 1.1 or superior.")
sphinx_tip += "\n" + _(
"Sphinx %s is currently installed.") % sphinx_ver
math_box.setToolTip(sphinx_tip)
features_layout = QVBoxLayout()
features_layout.addWidget(math_box)
features_group.setLayout(features_layout)
# Source code group
sourcecode_group = QGroupBox(_("Source code"))
wrap_mode_box = self.create_checkbox(_("Wrap lines"), 'wrap')
sourcecode_layout = QVBoxLayout()
sourcecode_layout.addWidget(wrap_mode_box)
sourcecode_group.setLayout(sourcecode_layout)
# Final layout
vlayout = QVBoxLayout()
vlayout.addWidget(connections_group)
vlayout.addWidget(features_group)
vlayout.addWidget(sourcecode_group)
vlayout.addStretch(1)
self.setLayout(vlayout)
def __init__(self,
parent,
language=None,
cmd='',
host='127.0.0.1',
port=2084,
args='',
external=False,
stdio=False,
configurations={},
**kwargs):
super(LSPServerEditor, self).__init__(parent)
description = _(
"To create a new server configuration, you need to select a "
"programming language, set the command to start its associated "
"server and enter any arguments that should be passed to it on "
"startup. Additionally, you can set the server's hostname and "
"port if connecting to an external server, "
"or to a local one using TCP instead of stdio pipes."
"<br><br>"
"<i>Note</i>: You can use the placeholders <tt>{host}</tt> and "
"<tt>{port}</tt> in the server arguments field to automatically "
"fill in the respective values.<br>")
self.parent = parent
self.external = external
# Widgets
self.server_settings_description = QLabel(description)
self.lang_cb = QComboBox(self)
self.external_cb = QCheckBox(_('External server'), self)
self.host_label = QLabel(_('Host:'))
self.host_input = QLineEdit(self)
self.port_label = QLabel(_('Port:'))
self.port_spinner = QSpinBox(self)
self.cmd_label = QLabel(_('Command:'))
self.cmd_input = QLineEdit(self)
self.args_label = QLabel(_('Arguments:'))
self.args_input = QLineEdit(self)
self.json_label = QLabel(self.JSON_VALID, self)
self.conf_label = QLabel(_('<b>Server Configuration:</b>'))
self.conf_input = CodeEditor(None)
self.bbox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.button_ok = self.bbox.button(QDialogButtonBox.Ok)
self.button_cancel = self.bbox.button(QDialogButtonBox.Cancel)
# Widget setup
self.setMinimumSize(self.MIN_SIZE)
self.setWindowTitle(_('LSP server editor'))
self.server_settings_description.setWordWrap(True)
self.lang_cb.setToolTip(
_('Programming language provided by the LSP server'))
self.lang_cb.addItem(_('Select a language'))
self.lang_cb.addItems(LSP_LANGUAGES)
self.button_ok.setEnabled(False)
if language is not None:
idx = LSP_LANGUAGES.index(language)
self.lang_cb.setCurrentIndex(idx + 1)
self.button_ok.setEnabled(True)
self.host_input.setPlaceholderText('127.0.0.1')
self.host_input.setText(host)
self.host_input.textChanged.connect(lambda x: self.validate())
self.port_spinner.setToolTip(_('TCP port number of the server'))
self.port_spinner.setMinimum(1)
self.port_spinner.setMaximum(60000)
self.port_spinner.setValue(port)
self.cmd_input.setText(cmd)
self.cmd_input.setPlaceholderText('/absolute/path/to/command')
self.args_input.setToolTip(
_('Additional arguments required to start the server'))
self.args_input.setText(args)
self.args_input.setPlaceholderText(r'--host {host} --port {port}')
self.conf_input.setup_editor(language='json',
color_scheme=CONF.get(
'appearance', 'selected'),
wrap=False,
edge_line=True,
highlight_current_line=True,
highlight_current_cell=True,
occurrence_highlighting=True,
auto_unindent=True,
font=get_font(),
filename='config.json',
folding=False)
self.conf_input.set_language('json', 'config.json')
self.conf_input.setToolTip(
_('Additional LSP server configuration '
'set at runtime. JSON required'))
try:
conf_text = json.dumps(configurations, indent=4, sort_keys=True)
except Exception:
conf_text = '{}'
self.conf_input.set_text(conf_text)
self.external_cb.setToolTip(
_('Check if the server runs on a remote location'))
self.external_cb.setChecked(external)
self.stdio_cb = QCheckBox(_('Use stdio pipes for communication'), self)
self.stdio_cb.setToolTip(
_('Check if the server communicates '
'using stdin/out pipes'))
self.stdio_cb.setChecked(stdio)
# Layout setup
hlayout = QHBoxLayout()
general_vlayout = QVBoxLayout()
general_vlayout.addWidget(self.server_settings_description)
vlayout = QVBoxLayout()
lang_group = QGroupBox(_('Language'))
lang_layout = QVBoxLayout()
lang_layout.addWidget(self.lang_cb)
lang_group.setLayout(lang_layout)
vlayout.addWidget(lang_group)
server_group = QGroupBox(_('Language server'))
server_layout = QGridLayout()
server_layout.addWidget(self.cmd_label, 0, 0)
server_layout.addWidget(self.cmd_input, 0, 1)
server_layout.addWidget(self.args_label, 1, 0)
server_layout.addWidget(self.args_input, 1, 1)
server_group.setLayout(server_layout)
vlayout.addWidget(server_group)
address_group = QGroupBox(_('Server address'))
host_layout = QVBoxLayout()
host_layout.addWidget(self.host_label)
host_layout.addWidget(self.host_input)
port_layout = QVBoxLayout()
port_layout.addWidget(self.port_label)
port_layout.addWidget(self.port_spinner)
conn_info_layout = QHBoxLayout()
conn_info_layout.addLayout(host_layout)
conn_info_layout.addLayout(port_layout)
address_group.setLayout(conn_info_layout)
vlayout.addWidget(address_group)
advanced_group = QGroupBox(_('Advanced'))
advanced_layout = QVBoxLayout()
advanced_layout.addWidget(self.external_cb)
advanced_layout.addWidget(self.stdio_cb)
advanced_group.setLayout(advanced_layout)
vlayout.addWidget(advanced_group)
conf_layout = QVBoxLayout()
conf_layout.addWidget(self.conf_label)
conf_layout.addWidget(self.conf_input)
conf_layout.addWidget(self.json_label)
vlayout.addStretch()
hlayout.addLayout(vlayout, 2)
hlayout.addLayout(conf_layout, 3)
general_vlayout.addLayout(hlayout)
general_vlayout.addWidget(self.bbox)
self.setLayout(general_vlayout)
self.form_status(False)
# Signals
if not external:
self.cmd_input.textChanged.connect(lambda x: self.validate())
self.external_cb.stateChanged.connect(self.set_local_options)
self.stdio_cb.stateChanged.connect(self.set_stdio_options)
self.lang_cb.currentIndexChanged.connect(self.lang_selection_changed)
self.conf_input.textChanged.connect(self.validate)
self.bbox.accepted.connect(self.accept)
self.bbox.rejected.connect(self.reject)
# Final setup
if language is not None:
self.form_status(True)
self.validate()
if stdio:
self.set_stdio_options(True)
if external:
self.set_local_options(True)
def setup_page(self):
pybutton = QPushButton('Click me', self)
# pybutton.resize(100, 32)
# pybutton.move(50, 50)
pybutton.clicked.connect(self.clickMethod)
# Connections group
connections_group = QGroupBox(_("Automatic connections"))
connections_label = QLabel(_("This pane can automatically "
"show an object's help information after "
"a left parenthesis is written next to it. "
"Below you can decide to which plugin "
"you want to connect it to turn on this "
"feature."))
connections_label.setWordWrap(True)
editor_box = self.create_checkbox(_("Editor"), 'connect/editor')
ipython_box = self.create_checkbox(_("IPython Console"),
'connect/ipython_console')
connections_layout = QVBoxLayout()
connections_layout.addWidget(connections_label)
connections_layout.addWidget(editor_box)
connections_layout.addWidget(ipython_box)
connections_group.setLayout(connections_layout)
# Features group
features_group = QGroupBox(_("Additional features"))
math_box = self.create_checkbox(_("Render mathematical equations"),
'math')
req_sphinx = programs.is_module_installed('sphinx', '>=1.1')
math_box.setEnabled(req_sphinx)
if not req_sphinx:
sphinx_ver = programs.get_module_version('sphinx')
sphinx_tip = _("This feature requires Sphinx 1.1 or superior.")
sphinx_tip += "\n" + _("Sphinx %s is currently installed.") % sphinx_ver
math_box.setToolTip(sphinx_tip)
features_layout = QVBoxLayout()
features_layout.addWidget(math_box)
features_group.setLayout(features_layout)
# Source code group
sourcecode_group = QGroupBox(_("Source code"))
wrap_mode_box = self.create_checkbox(_("Wrap lines"), 'wrap')
sourcecode_layout = QVBoxLayout()
sourcecode_layout.addWidget(wrap_mode_box)
sourcecode_group.setLayout(sourcecode_layout)
# Final layout
vlayout = QVBoxLayout()
vlayout.addWidget(connections_group)
vlayout.addWidget(features_group)
vlayout.addWidget(sourcecode_group)
vlayout.addWidget(pybutton)
vlayout.addStretch(1)
self.setLayout(vlayout)
class AnimationWindow(PyDialog):
"""
+-------------------+
| Animation |
+-------------------------+
| icase ______ |
| scale ______ Default |
| time ______ Default |
| |
| nframes ______ Default |
| resolu. ______ Default |
| Dir ______ Browse |
| iFrame ______ |
| |
| Animations: |
| o Scale, Phase, Time |
| |
| x delete images |
| x repeat | # TODO: change to an integer
| x make gif |
| |
| Step, RunAll |
| Close |
+-------------------------+
TODO: add key-frame support
"""
def __init__(self, data, win_parent=None, fringe_cases=None, is_gui_parent=False):
PyDialog.__init__(self, data, win_parent)
# is the parent the gui?
self.is_gui_parent = False
self.fringe_cases = fringe_cases
self.set_font_size(data['font_size'])
self.istep = 0
self._animate_type = 'time'
self._updated_animation = False
self._active_deformation = 0.
self._icase_fringe = data['icase_fringe']
self._icase_disp = data['icase_disp']
self._icase_vector = data['icase_vector']
self._default_title = data['title']
self._default_time = data['time']
self._default_fps = data['frames/sec']
self._default_resolution = data['resolution']
self._scale = data['scale']
self._default_scale = data['default_scale']
self._default_is_scale = data['is_scale']
self._arrow_scale = data['arrow_scale']
self._default_arrow_scale = data['default_arrow_scale']
self._phase = data['phase']
self._default_phase = data['default_phase']
self._default_dirname = data['dirname']
self._default_gif_name = os.path.join(self._default_dirname, data['title'] + '.gif')
self.animation_types = [
'Animate Scale',
]
#'Animate Phase',
#'Animate Time',
#'Animate Frequency Sweep'
#]
self.setWindowTitle('Animate Model')
self.create_widgets()
self.create_layout()
self.set_connections()
self.is_gui = False
self.gui = None
if hasattr(self.win_parent, '_updated_legend'):
self.win_parent.is_animate_open = True
self.is_gui = True
self.gui = self.win_parent.win_parent
if is_gui_parent:
self.is_gui = True
self.gui = self.win_parent
self.on_update_min_max_defaults()
def create_widgets(self):
"""creates the menu objects"""
self.box_scale = QGroupBox('Animate Scale')
self.box_time = QGroupBox('Animate Time')
icase_max = 1000 # TODO: update 1000
self.checkbox_fringe = QCheckBox('Animate')
self.checkbox_fringe.setToolTip(
'Animate the fringe in addition to the deflection')
#self.checkbox_disp = QCheckBox('Animate')
self.checkbox_fringe.setEnabled(False)
self.icase_fringe_label = QLabel("iCase (Fringe):")
self.icase_fringe_edit = QSpinBox(self)
self.icase_fringe_edit.setRange(0, icase_max)
self.icase_fringe_edit.setSingleStep(1)
if self._icase_fringe is not None:
self.icase_fringe_edit.setValue(self._icase_fringe)
self.icase_fringe_edit.setToolTip(
'Case Number for the Scale/Phase Animation Type.\n'
'Defaults to the result you had shown when you clicked "Create Animation".\n'
'iCase can be seen by clicking "Apply" on a result.')
self.icase_disp_label = QLabel("iCase (Disp):")
self.icase_disp_edit = QSpinBox(self)
self.icase_disp_edit.setRange(1, icase_max)
self.icase_disp_edit.setSingleStep(1)
if self._icase_disp is not None:
self.icase_disp_edit.setValue(self._icase_disp)
self.checkbox_vector = QCheckBox('Animate')
self.checkbox_vector.setToolTip(
'Animate the vector in addition to the deflection')
self.checkbox_vector.hide()
#self.checkbox_disp = QCheckBox('Animate')
self.icase_vector_label = QLabel("iCase (Vector):")
self.icase_vector_edit = QSpinBox(self)
self.icase_vector_edit.setRange(1, icase_max)
self.icase_vector_edit.setSingleStep(1)
if self._icase_vector is not None:
self.icase_vector_edit.setValue(self._icase_vector)
self.scale_label = QLabel("True Scale:")
self.scale_edit = QLineEdit(str(self._scale))
self.scale_button = QPushButton("Default")
self.scale_edit.setToolTip('Scale factor of the "deflection"')
self.scale_button.setToolTip('Sets the scale factor of the gif to %s' % self._scale)
self.arrow_scale_label = QLabel("Arrow Scale:")
self.arrow_scale_edit = QLineEdit(str(self._scale))
self.arrow_scale_button = QPushButton("Default")
self.arrow_scale_edit.setToolTip('Scale factor of the "arrows"')
self.arrow_scale_button.setToolTip('Sets the arrow scale factor of the gif to %s' % (
self._arrow_scale))
self.arrow_scale_label.setVisible(False)
self.arrow_scale_edit.setVisible(False)
self.arrow_scale_button.setVisible(False)
self.time_label = QLabel("Total Time (sec):")
self.time_edit = QDoubleSpinBox(self)
self.time_edit.setValue(self._default_time)
self.time_edit.setRange(0.1, 5. * 60.)
self.time_edit.setDecimals(2)
self.time_edit.setSingleStep(0.1)
self.time_button = QPushButton("Default")
self.time_edit.setToolTip("Total time of the gif")
self.time_button.setToolTip('Sets the total time of the gif to %.2f' % self._default_time)
self.fps_label = QLabel("Frames/Second:")
self.fps_edit = QSpinBox(self)
self.fps_edit.setRange(1, 60)
self.fps_edit.setSingleStep(1)
self.fps_edit.setValue(self._default_fps)
self.fps_button = QPushButton("Default")
self.fps_edit.setToolTip("A higher FPS is smoother, but may not play well for large gifs")
self.fps_button.setToolTip('Sets the FPS to %s' % self._default_fps)
self.resolution_label = QLabel("Resolution Scale:")
self.resolution_edit = QSpinBox(self)
self.resolution_edit.setRange(1, 5)
self.resolution_edit.setSingleStep(1)
self.resolution_edit.setValue(self._default_resolution)
self.resolution_button = QPushButton("Default")
self.resolution_edit.setToolTip('Scales the window resolution by an integer factor')
self.resolution_button.setToolTip('Sets the resolution to %s' % self._default_resolution)
#-----------------
# Time plot
self.fringe_label = QLabel("Fringe")
self.icase_fringe_start_edit = QSpinBox(self)
self.icase_fringe_start_edit.setRange(0, icase_max)
self.icase_fringe_start_edit.setSingleStep(1)
self.icase_fringe_start_edit.setValue(self._icase_fringe)
self.icase_fringe_start_button = QPushButton("Default")
self.icase_fringe_end_edit = QSpinBox(self)
self.icase_fringe_end_edit.setRange(0, icase_max)
self.icase_fringe_end_edit.setSingleStep(1)
self.icase_fringe_end_edit.setValue(self._icase_fringe)
self.icase_fringe_end_button = QPushButton("Default")
self.icase_fringe_delta_edit = QSpinBox(self)
self.icase_fringe_delta_edit.setRange(1, icase_max)
self.icase_fringe_delta_edit.setSingleStep(1)
self.icase_fringe_delta_edit.setValue(1)
self.icase_fringe_delta_button = QPushButton("Default")
self.displacement_label = QLabel("Displacement")
self.icase_start = QLabel("iCase Start:")
self.icase_disp_start_edit = QSpinBox(self)
self.icase_disp_start_edit.setRange(0, icase_max)
self.icase_disp_start_edit.setSingleStep(1)
self.icase_disp_start_edit.setValue(self._icase_fringe)
self.icase_disp_start_button = QPushButton("Default")
self.icase_end_label = QLabel("iCase End:")
self.icase_disp_end_edit = QSpinBox(self)
self.icase_disp_end_edit.setRange(0, icase_max)
self.icase_disp_end_edit.setSingleStep(1)
self.icase_disp_end_edit.setValue(self._icase_fringe)
self.icase_disp_end_button = QPushButton("Default")
self.icase_delta_label = QLabel("iCase Delta:")
self.icase_disp_delta_edit = QSpinBox(self)
self.icase_disp_delta_edit.setRange(1, icase_max)
self.icase_disp_delta_edit.setSingleStep(1)
self.icase_disp_delta_edit.setValue(1)
self.icase_disp_delta_button = QPushButton("Default")
self.min_value_enable = QCheckBox()
self.min_value_label = QLabel("Min Value:")
self.min_value_edit = QLineEdit('')
#self.min_value_edit.setRange(1, 1000)
#self.min_value_edit.setSingleStep(1)
#self.min_value_edit.setValue(1)
self.min_value_button = QPushButton("Default")
self.max_value_enable = QCheckBox()
self.max_value_label = QLabel("Max Value:")
self.max_value_edit = QLineEdit('')
#self.min_value_edit.setRange(1, 1000) # TODO: update 1000
#self.min_value_edit.setSingleStep(1)
#self.min_value_edit.setValue(1)
self.max_value_button = QPushButton("Default")
# TODO: enable this (uncomment) ------------------------------------------
#self.min_value_enable.hide()
#self.min_value.hide()
#self.min_value_edit.hide()
#self.min_value_button.hide()
#self.max_value_enable.hide()
#self.max_value.hide()
#self.max_value_edit.hide()
#self.max_value_button.hide()
# TODO: enable this (uncomment) ------------------------------------------
self.icase_disp_start_edit.setToolTip('The first frame of the animation')
self.icase_disp_end_edit.setToolTip(
'The last frame of the animation\n'
'Assumes icase_start + nframes * icase_delta = icase_end')
self.icase_disp_delta_edit.setToolTip(
'The frame step size (to skip non-consecutive results).\n'
'Frame skipping can be used to:\n'
" - skip across results that you don't want to plot\n"
' - adjust the FPS')
self.min_value_edit.setToolTip('Min value of the legend (not supported)')
self.max_value_edit.setToolTip('Max value of the legend (not supported)')
#'time' : 0.,
#'default_time' : 0,
#'icase_start' : 10,
#'icase_delta' : 3,
#'min_value' : 0.,
#'max_value' : 1000.,
self.browse_folder_label = QLabel('Output Directory:')
self.browse_folder_edit = QLineEdit(str(self._default_dirname))
self.browse_folder_button = QPushButton('Browse...')
self.browse_folder_edit.setToolTip('Location to save the png/gif files')
self.gif_label = QLabel("Gif Filename:")
self.gif_edit = QLineEdit(str(self._default_title + '.gif'))
self.gif_button = QPushButton('Default')
self.gif_edit.setToolTip('Name of the gif')
self.gif_button.setToolTip('Sets the name of the gif to %s.gif' % self._default_title)
# scale / phase
if 1: # pragma: no cover
self.animate_scale_radio = QRadioButton("Animate Scale")
self.animate_phase_radio = QRadioButton("Animate Phase")
self.animate_time_radio = QRadioButton("Animate Time")
self.animate_freq_sweeep_radio = QRadioButton("Animate Frequency Sweep")
self.animate_scale_radio.setToolTip(
'Animates the scale factor based on the "Animation Type"')
self.animate_time_radio.setToolTip('Animates the time/load/mode step')
self.animate_scale_radio.setChecked(self._default_is_scale)
self.animate_phase_radio.setChecked(not self._default_is_scale)
self.animate_time_radio.setChecked(False)
msg = 'Scale : Animates the scale factor based on the "Animation Profile"\n'
if self._default_phase is None:
self.animate_phase_radio.setDisabled(True)
self.animate_phase_radio.setToolTip('Animates the phase angle '
'(only for complex results)')
msg += 'Phase : Animates the phase angle (only for complex results)\n'
else:
self.animate_phase_radio.setToolTip("Animates the phase angle")
msg += 'Phase : Animates the phase angle\n'
msg += (
'Time : Animates the time/load/mode step\n'
'Freq Sweep : Animates a complex result across a range of frequencies '
'(not supported)\n'
)
self.animate_freq_sweeep_radio.setDisabled(True)
self.animate_freq_sweeep_radio.setToolTip(
'Animates a complex result across a range of frequencies (not supported)')
else:
msg = 'Scale : Animates the scale factor based on the "Animation Profile"\n'
if self._default_phase is None:
#self.animate_phase_radio.setDisabled(True)
#self.animate_phase_radio.setToolTip('Animates the phase angle '
#'(only for complex results)')
msg += 'Phase : Animates the phase angle (only for complex results)\n'
else:
#self.animate_phase_radio.setToolTip("Animates the phase angle")
msg += 'Phase : Animates the phase angle\n'
msg += (
'Time : Animates the time/load/mode step\n'
'Freq Sweep : Animates a complex result across a range of frequencies '
'(not supported)\n'
)
self.animation_type = QLabel("Animation Type:")
animation_type = OrderedDict()
#scale_msg = 'Scale\n'
#phase_msg = 'Phase\n'
#time_msg = 'Time\n'
#animation_types = [
#('Animate Scale', scale_msg),
#('Animate Phase', phase_msg),
#('Animate Time', time_msg),
##'Animate Frequency Sweep'
#]
if self._phase is not None:
self.animation_types.append('Animate Phase')
self.animation_types.append('Animate Time')
self.animation_profile_label = QLabel("Animation Profile:")
self.animation_profile_edit = QComboBox()
for animation_profile in ANIMATION_PROFILES:
self.animation_profile_edit.addItem(animation_profile)
self.animation_profile_edit.setToolTip('The profile for a scaled GIF')
self.animation_type_edit = QComboBox()
# TODO: add a tooltip for each item
for animation_type in self.animation_types:
self.animation_type_edit.addItem(animation_type)
#self.animation_type_edit.setToolTip('The profile for a scaled GIF')
self.animation_type_edit.setToolTip(msg.rstrip())
self.csv_profile_label = QLabel("CSV profile:")
self.csv_profile_edit = QLineEdit()
self.csv_profile_browse_button = QPushButton('Browse')
self.csv_profile_edit.setToolTip(
'The path to the CSV file of (Scale1, Scale2, Scale3, ...)')
#widget = QWidget(self)
#horizontal_vertical_group = QButtonGroup(widget)
#horizontal_vertical_group.addButton(self.animate_scale_radio)
#horizontal_vertical_group.addButton(self.animate_phase_radio)
#horizontal_vertical_group.addButton(self.animate_time_radio)
#horizontal_vertical_group.addButton(self.animate_freq_sweeep_radio)
# animate in gui
self.animate_in_gui_checkbox = QCheckBox("Animate In GUI?")
self.animate_in_gui_checkbox.setChecked(True)
# make images
self.make_images_checkbox = QCheckBox("Make images?")
self.make_images_checkbox.setChecked(True)
# make images
self.overwrite_images_checkbox = QCheckBox("Overwrite images?")
self.overwrite_images_checkbox.setChecked(True)
# delete images when finished
self.delete_images_checkbox = QCheckBox("Delete images when finished?")
self.delete_images_checkbox.setChecked(True)
# endless loop
self.repeat_checkbox = QCheckBox("Repeat?")
self.repeat_checkbox.setChecked(True)
self.repeat_checkbox.setToolTip("Repeating creates an infinitely looping gif")
# endless loop
self.make_gif_checkbox = QCheckBox("Make Gif?")
if IS_IMAGEIO:
self.make_gif_checkbox.setChecked(True)
else:
self.make_gif_checkbox.setChecked(False)
self.make_gif_checkbox.setEnabled(False)
self.make_gif_checkbox.setToolTip('imageio is not available; install it')
# bottom buttons
self.step_button = QPushButton("Step")
self.wipe_button = QPushButton("Wipe Deformed Shape")
self.stop_button = QPushButton("Stop")
self.run_button = QPushButton("Run")
self.step_button.setToolTip('Steps through the animation (for testing)')
self.wipe_button.setToolTip('Removes the existing "deflecton" from the animation')
self.stop_button.setToolTip('Stops the animation')
self.run_button.setToolTip('Creates the animation')
self.step_button.hide()
self.wipe_button.hide()
self.wipe_button.setEnabled(False)
#self.wipe_button.hide()
self.stop_button.setEnabled(False)
self.cancel_button = QPushButton("Close")
#self.set_grid_time(enabled=False)
#self.set_grid_scale(enabled=self._default_is_scale)
if self._default_phase:
self.on_animate_phase(force=True)
set_combo_box_text(self.animation_type_edit, 'Animate Phase')
else:
self.on_animate_scale(force=True)
def set_connections(self):
"""creates the actions for the menu"""
self.checkbox_vector.clicked.connect(self.on_checkbox_vector)
self.scale_button.clicked.connect(self.on_default_scale)
self.arrow_scale_button.clicked.connect(self.on_default_arrow_scale)
self.time_button.clicked.connect(self.on_default_time)
self.fps_button.clicked.connect(self.on_default_fps)
self.resolution_button.clicked.connect(self.on_default_resolution)
self.browse_folder_button.clicked.connect(self.on_browse_folder)
self.csv_profile_browse_button.clicked.connect(self.on_browse_csv)
self.gif_button.clicked.connect(self.on_default_title)
self.step_button.clicked.connect(self.on_step)
self.wipe_button.clicked.connect(self.on_wipe)
self.stop_button.clicked.connect(self.on_stop)
self.run_button.clicked.connect(self.on_run)
self.min_value_enable.clicked.connect(self.on_min_value_enable)
self.max_value_enable.clicked.connect(self.on_max_value_enable)
self.min_value_button.clicked.connect(self.on_min_value_default)
self.max_value_button.clicked.connect(self.on_max_value_default)
self.icase_disp_start_button.clicked.connect(self.on_update_min_max_defaults)
#self.animate_scale_radio.clicked.connect(self.on_animate_scale)
#self.animate_phase_radio.clicked.connect(self.on_animate_phase)
#self.animate_time_radio.clicked.connect(self.on_animate_time)
self.animation_type_edit.currentIndexChanged.connect(self.on_animate)
#self.animate_freq_sweeep_radio
self.cancel_button.clicked.connect(self.on_cancel)
self.animate_in_gui_checkbox.clicked.connect(self.on_animate_in_gui)
self.animate_in_gui_checkbox.setChecked(True)
self.on_animate_in_gui()
def on_checkbox_vector(self):
is_enabled = self.checkbox_vector.isEnabled()
is_checked = self.checkbox_vector.isChecked()
enable_edit = is_enabled and is_checked
self.icase_vector_label.setEnabled(is_checked)
self.icase_vector_edit.setEnabled(enable_edit)
def on_animate_in_gui(self):
animate_in_gui = self.animate_in_gui_checkbox.isChecked()
enable = not animate_in_gui
if HIDE_WHEN_INACTIVE:
self.make_images_checkbox.setVisible(enable)
self.delete_images_checkbox.setVisible(enable)
self.make_gif_checkbox.setVisible(enable)
self.repeat_checkbox.setVisible(enable)
self.resolution_button.setVisible(enable)
self.resolution_label.setVisible(enable)
self.resolution_edit.setVisible(enable)
self.gif_label.setVisible(enable)
self.gif_edit.setVisible(enable)
self.gif_button.setVisible(enable)
self.browse_folder_label.setVisible(enable)
self.browse_folder_button.setVisible(enable)
self.browse_folder_edit.setVisible(enable)
self.step_button.setEnabled(enable)
self.make_images_checkbox.setEnabled(enable)
self.delete_images_checkbox.setEnabled(enable)
self.make_gif_checkbox.setEnabled(enable)
self.repeat_checkbox.setEnabled(enable)
self.resolution_button.setEnabled(enable)
self.resolution_edit.setEnabled(enable)
self.gif_edit.setEnabled(enable)
self.gif_button.setEnabled(enable)
self.browse_folder_button.setEnabled(enable)
self.browse_folder_edit.setEnabled(enable)
self.step_button.setEnabled(enable)
#wipe_button
def on_animate(self, value):
"""
animate pulldown
Parameters
----------
value : int
index in animation_types
"""
#animation_types = ['Animate Scale', 'Animate Phase', 'Animate Time',
#'Animate Frequency Sweep']
animation_type = self.animation_types[value]
if animation_type == 'Animate Scale':
self.on_animate_scale()
elif animation_type == 'Animate Phase':
self.on_animate_phase()
elif animation_type == 'Animate Time':
self.on_animate_time()
else:
raise NotImplementedError('value = ', value)
def on_animate_time(self, force=False):
"""enables the secondary input"""
#print('on_animate_time')
if self._animate_type == 'scale' or force:
self.set_grid_scale(False, 'time')
self.set_grid_time(True, 'time')
self._animate_type = 'time'
def on_animate_scale(self, force=False):
"""enables the secondary input"""
#print('on_animate_scale')
self.set_grid_scale(True, 'scale')
if self._animate_type == 'time' or force:
self.set_grid_time(False, 'scale')
self._animate_type = 'scale'
def on_animate_phase(self, force=False):
"""enables the secondary input"""
#print('on_animate_phase')
if self._animate_type == 'scale' or force:
self.set_grid_scale(False, 'phase')
if self._animate_type == 'time' or force:
self.set_grid_time(False, 'phase')
self._animate_type = 'phase'
def set_grid_scale(self, enabled=True, word=''):
"""enables/disables the secondary input"""
#print('%s-set_grid_scale; enabled = %r' % (word, enabled))
if HIDE_WHEN_INACTIVE:
self.box_scale.setVisible(enabled)
self.animation_profile_label.setVisible(enabled)
self.animation_profile_edit.setVisible(enabled)
#self.min_value_enable.setVisible(enabled)
#self.max_value_enable.setVisible(enabled)
self.animation_profile_label.setEnabled(enabled)
self.animation_profile_edit.setEnabled(enabled)
# TODO: doesn't work...
#self.csv_profile.setEnabled(enabled)
#self.csv_profile_edit.setEnabled(enabled)
#self.csv_profile_button.setEnabled(enabled)
self.min_value_enable.setEnabled(enabled)
self.max_value_enable.setEnabled(enabled)
self.on_min_value_enable()
self.on_max_value_enable()
def set_grid_time(self, enabled=True, word=''):
"""enables/disables the secondary input"""
#print('%s-set_grid_time; enabled = %r' % (word, enabled))
if HIDE_WHEN_INACTIVE:
self.box_time.setVisible(enabled)
self.checkbox_fringe.setVisible(not enabled)
self.icase_fringe_label.setVisible(not enabled)
self.icase_fringe_edit.setVisible(not enabled)
self.icase_disp_label.setVisible(not enabled)
self.icase_disp_edit.setVisible(not enabled)
self.icase_vector_label.setVisible(not enabled)
self.icase_vector_edit.setVisible(not enabled)
#self.icase_fringe_delta_edit.setVisible(enabled)
self.icase_disp_delta_edit.setVisible(enabled)
self.icase_disp_delta_edit.setVisible(enabled)
self.fps_label.setVisible(enabled)
self.fps_edit.setVisible(enabled)
self.fps_button.setVisible(enabled)
self.displacement_label.setEnabled(enabled)
self.fringe_label.setEnabled(enabled)
self.icase_start.setEnabled(enabled)
self.icase_disp_start_edit.setEnabled(enabled)
self.icase_disp_start_button.setEnabled(enabled)
self.icase_fringe_start_edit.setEnabled(enabled)
self.icase_fringe_start_button.setEnabled(enabled)
self.icase_end_label.setEnabled(enabled)
self.icase_disp_end_edit.setEnabled(enabled)
self.icase_disp_end_button.setEnabled(enabled)
self.icase_fringe_end_edit.setEnabled(enabled)
self.icase_fringe_end_button.setEnabled(enabled)
self.icase_delta_label.setEnabled(enabled)
self.icase_disp_delta_edit.setEnabled(enabled)
self.icase_disp_delta_button.setEnabled(enabled)
self.icase_fringe_delta_edit.setEnabled(enabled)
self.icase_fringe_delta_button.setEnabled(enabled)
#-----------------------------------------------------------------------
is_min_enabled = self.min_value_enable.isChecked()
self.min_value_label.setEnabled(is_min_enabled)
self.min_value_edit.setEnabled(is_min_enabled)
self.min_value_button.setEnabled(is_min_enabled)
is_max_enabled = self.max_value_enable.isChecked()
self.max_value_label.setEnabled(is_max_enabled)
self.max_value_edit.setEnabled(is_max_enabled)
self.max_value_button.setEnabled(is_max_enabled)
self.min_value_enable.setEnabled(enabled)
self.on_min_value_enable()
#self.min_value.setEnabled(enabled)
#self.min_value_edit.setEnabled(enabled)
#self.min_value_button.setEnabled(enabled)
self.max_value_enable.setEnabled(enabled)
self.on_max_value_enable()
#self.max_value.setEnabled(enabled)
#self.max_value_edit.setEnabled(enabled)
#self.max_value_button.setEnabled(enabled)
self.icase_fringe_label.setEnabled(not enabled)
self.icase_fringe_edit.setEnabled(not enabled)
self.checkbox_fringe.setEnabled(not enabled)
self.icase_disp_label.setEnabled(not enabled)
self.icase_disp_edit.setEnabled(not enabled)
self.icase_vector_label.setEnabled(not enabled)
self.icase_vector_edit.setEnabled(not enabled)
self.checkbox_vector.setEnabled(not enabled)
self.on_checkbox_vector()
self.fps_label.setEnabled(not enabled)
self.fps_edit.setEnabled(not enabled)
self.fps_button.setEnabled(not enabled)
def on_min_value_enable(self):
"""
The min edit value box is enabled when we switch to time
and the box is checked
"""
is_min_enabled = self.min_value_enable.isChecked() and self.min_value_enable.isEnabled()
self.min_value_label.setEnabled(is_min_enabled)
self.min_value_edit.setEnabled(is_min_enabled)
self.min_value_button.setEnabled(is_min_enabled)
def on_max_value_enable(self):
"""
The max edit value box is enabled when we switch to time
and the box is checked
"""
is_max_enabled = self.max_value_enable.isChecked() and self.max_value_enable.isEnabled()
self.max_value_label.setEnabled(is_max_enabled)
self.max_value_edit.setEnabled(is_max_enabled)
self.max_value_button.setEnabled(is_max_enabled)
def on_update_min_max_defaults(self):
"""
When the icase is changed, the min/max value default message is changed
"""
icase = self.icase_disp_start_edit.value()
min_value, max_value = self.get_min_max(icase)
self.min_value_button.setToolTip('Sets the min value to %g' % min_value)
self.max_value_button.setToolTip('Sets the max value to %g' % max_value)
def on_min_value_default(self):
"""When min default icase is pressued, update the value"""
icase = self.icase_disp_start_edit.value()
min_value = self.get_min_max(icase)[0]
self.min_value_edit.setText(str(min_value))
self.min_value_edit.setStyleSheet("QLineEdit{background: white;}")
def on_max_value_default(self):
"""When max default icase is pressued, update the value"""
icase = self.icase_disp_start_edit.value()
max_value = self.get_min_max(icase)[1]
self.max_value_edit.setText(str(max_value))
self.max_value_edit.setStyleSheet("QLineEdit{background: white;}")
def on_browse_folder(self):
"""opens a folder dialog"""
dirname = getexistingdirectory(parent=self, caption='Select a Directory',
basedir='',
options=QFileDialog.ShowDirsOnly)
if not dirname:
return
self.browse_folder_edit.setText(dirname)
def on_browse_csv(self):
"""opens a file dialog"""
default_filename = ''
file_types = 'Delimited Text (*.txt; *.dat; *.csv)'
dirname = open_file_dialog(self, 'Select a CSV File', default_filename, file_types)
if not dirname:
return
self.csv_profile_browse_button.setText(dirname)
def on_default_title(self):
"""sets the default gif name"""
self.gif_edit.setText(self._default_title + '.gif')
def on_default_scale(self):
"""sets the default displacement scale factor"""
if self.is_gui:
icase_disp = self.icase_disp_edit.value()
out = self.gui.legend_obj.get_legend_disp(
icase_disp)
unused_scale, unused_phase, default_scale, unused_default_phase = out
else:
default_scale = self._default_scale
self.scale_edit.setText(str(default_scale))
self.scale_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_arrow_scale(self):
"""sets the default arrow scale factor"""
if self.is_gui:
icase_vector = self.icase_vector_edit.value()
out = self.gui.legend_obj.get_legend_vector(icase_vector)
unused_arrow_scale, default_arrow_scale = out
else:
default_arrow_scale = self._default_arrow_scale
self.arrow_scale_edit.setText(str(default_arrow_scale))
self.arrow_scale_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_time(self):
"""sets the default gif time"""
self.time_edit.setValue(self._default_time)
def on_default_fps(self):
"""sets the default FPS"""
self.fps_edit.setValue(self._default_fps)
def on_default_resolution(self):
"""sets the default image resolution scale factor"""
self.resolution_edit.setValue(self._default_resolution)
def create_layout(self):
"""displays the menu objects"""
grid = QGridLayout()
irow = 0
grid.addWidget(self.icase_fringe_label, irow, 0)
grid.addWidget(self.icase_fringe_edit, irow, 1)
grid.addWidget(self.checkbox_fringe, irow, 2)
irow += 1
grid.addWidget(self.icase_disp_label, irow, 0)
grid.addWidget(self.icase_disp_edit, irow, 1)
#grid.addWidget(self.checkbox_disp, irow, 2)
irow += 1
grid.addWidget(self.icase_vector_label, irow, 0)
grid.addWidget(self.icase_vector_edit, irow, 1)
grid.addWidget(self.checkbox_vector, irow, 2)
irow += 1
grid.addWidget(self.scale_label, irow, 0)
grid.addWidget(self.scale_edit, irow, 1)
grid.addWidget(self.scale_button, irow, 2)
irow += 1
grid.addWidget(self.arrow_scale_label, irow, 0)
grid.addWidget(self.arrow_scale_edit, irow, 1)
grid.addWidget(self.arrow_scale_button, irow, 2)
irow += 1
grid.addWidget(self.time_label, irow, 0)
grid.addWidget(self.time_edit, irow, 1)
grid.addWidget(self.time_button, irow, 2)
irow += 1
# spacer
spacer = QLabel('')
grid.addWidget(self.fps_label, irow, 0)
grid.addWidget(self.fps_edit, irow, 1)
grid.addWidget(self.fps_button, irow, 2)
irow += 1
grid.addWidget(self.animation_type, irow, 0)
grid.addWidget(self.animation_type_edit, irow, 1)
irow += 1
grid.addWidget(spacer, irow, 0)
irow += 1
#----------
#Time
grid_time = QGridLayout()
jrow = 0
self.fringe_label.setAlignment(Qt.AlignCenter)
self.displacement_label.setAlignment(Qt.AlignCenter)
if not IS_TIME_FRINGE:
self.fringe_label.hide()
self.icase_fringe_delta_edit.hide()
self.icase_fringe_start_edit.hide()
self.icase_fringe_end_edit.hide()
self.icase_fringe_delta_button.hide()
grid_time.addWidget(self.displacement_label, jrow, 1)
grid_time.addWidget(self.fringe_label, jrow, 2)
jrow += 1
grid_time.addWidget(self.icase_start, jrow, 0)
grid_time.addWidget(self.icase_disp_start_edit, jrow, 1)
grid_time.addWidget(self.icase_fringe_start_edit, jrow, 2)
#grid_time.addWidget(self.icase_disp_start_button, jrow, 2)
jrow += 1
grid_time.addWidget(self.icase_end_label, jrow, 0)
grid_time.addWidget(self.icase_disp_end_edit, jrow, 1)
grid_time.addWidget(self.icase_fringe_end_edit, jrow, 2)
#grid_time.addWidget(self.icase_end_button, jrow, 2)
jrow += 1
grid_time.addWidget(self.icase_delta_label, jrow, 0)
grid_time.addWidget(self.icase_disp_delta_edit, jrow, 1)
grid_time.addWidget(self.icase_fringe_delta_edit, jrow, 2)
#grid_time.addWidget(self.icase_delta_button, jrow, 2)
jrow += 1
hbox_min = QHBoxLayout()
hbox_min.addWidget(self.min_value_enable)
hbox_min.addWidget(self.min_value_label)
grid_time.addLayout(hbox_min, jrow, 0)
grid_time.addWidget(self.min_value_edit, jrow, 1)
grid_time.addWidget(self.min_value_button, jrow, 2)
jrow += 1
hbox_max = QHBoxLayout()
hbox_max.addWidget(self.max_value_enable)
hbox_max.addWidget(self.max_value_label)
grid_time.addLayout(hbox_max, jrow, 0)
grid_time.addWidget(self.max_value_edit, jrow, 1)
grid_time.addWidget(self.max_value_button, jrow, 2)
jrow += 1
grid_time.addWidget(spacer, jrow, 0)
jrow += 1
#--------------
grid_scale = QGridLayout()
grid_scale.addWidget(self.animation_profile_label, 0, 0)
grid_scale.addWidget(self.animation_profile_edit, 0, 1)
#grid_scale.addWidget(self.csv_profile, 1, 0)
#grid_scale.addWidget(self.csv_profile_edit, 1, 1)
#grid_scale.addWidget(self.csv_profile_browse_button, 1, 2)
self.csv_profile = QLabel("CSV profile:")
self.csv_profile_edit = QLineEdit()
self.csv_profile_button = QPushButton('Browse')
#box_time = QVBoxLayout()
# TODO: It's super annoying that the animate time box doesn't
# line up with the previous box
self.box_scale.setLayout(grid_scale)
self.box_time.setLayout(grid_time)
#----------
grid2 = QGridLayout()
irow = 0
#grid2.addWidget(self.animate_scale_radio, 8, 0)
#grid2.addWidget(self.animate_phase_radio, 8, 1)
#grid2.addWidget(self.animate_time_radio, 8, 2)
#grid2.addWidget(self.animate_freq_sweeep_radio, 8, 3)
grid2.addWidget(self.animate_in_gui_checkbox, irow, 0)
irow += 1
grid2.addWidget(self.resolution_label, irow, 0)
grid2.addWidget(self.resolution_edit, irow, 1)
grid2.addWidget(self.resolution_button, irow, 2)
irow += 1
grid2.addWidget(self.browse_folder_label, irow, 0)
grid2.addWidget(self.browse_folder_edit, irow, 1)
grid2.addWidget(self.browse_folder_button, irow, 2)
irow += 1
grid2.addWidget(self.gif_label, irow, 0)
grid2.addWidget(self.gif_edit, irow, 1)
grid2.addWidget(self.gif_button, irow, 2)
irow += 1
grid2.addWidget(self.make_images_checkbox, irow, 0)
#grid2.addWidget(self.overwrite_images_checkbox, irow, 0)
grid2.addWidget(self.delete_images_checkbox, irow, 1)
grid2.addWidget(self.make_gif_checkbox, irow, 2)
irow += 1
grid2.addWidget(self.repeat_checkbox, irow, 0)
irow += 1
grid2.addWidget(spacer, irow, 0)
grid_hbox = QHBoxLayout()
grid_hbox.addWidget(spacer)
grid_hbox.addLayout(grid2)
grid_hbox.addWidget(spacer)
# bottom buttons
step_run_box = QHBoxLayout()
step_run_box.addWidget(self.step_button)
step_run_box.addWidget(self.wipe_button)
step_run_box.addWidget(self.stop_button)
step_run_box.addWidget(self.run_button)
ok_cancel_box = QHBoxLayout()
ok_cancel_box.addWidget(self.cancel_button)
vbox = QVBoxLayout()
vbox.addLayout(grid)
vbox.addWidget(self.box_scale)
vbox.addWidget(self.box_time)
#vbox.addLayout(checkboxes)
vbox.addLayout(grid_hbox)
vbox.addStretch()
vbox.addLayout(step_run_box)
vbox.addLayout(ok_cancel_box)
if IS_RESULTS_SELECTOR and self.fringe_cases:
cases = get_cases_from_tree(self.fringe_cases)
parent = self
name = 'main'
data = self.fringe_cases
choices = cases
results_widget = ResultsWindow(parent, name, data, choices,
include_clear=False, include_delete=False)
vbox_results = QVBoxLayout()
results_widget_label = QLabel('Results:')
vbox_results.addWidget(results_widget_label)
vbox_results.addWidget(results_widget)
hbox_main = QHBoxLayout()
hbox_main.addLayout(vbox)
hbox_main.addLayout(vbox_results)
self.setLayout(hbox_main)
else:
self.setLayout(vbox)
def on_fringe(self, icase):
"""sets the icase fringe"""
self.icase_fringe_edit.setValue(icase)
def on_disp(self, icase):
"""sets the icase disp"""
self.icase_disp_edit.setValue(icase)
def on_vector(self, icase):
"""sets the icase vector"""
self.icase_vector_edit.setValue(icase)
def on_clear_results(self):
"""sink for the right click menu"""
pass
def on_step(self):
"""click the Step button"""
passed, validate_out = self.on_validate()
if passed:
try:
self._make_gif(validate_out, istep=self.istep)
self.istep += 1
except IndexError:
self._make_gif(validate_out, istep=0)
self.istep += 1
self.wipe_button.setEnabled(True)
def on_wipe(self):
"""click the Wipe button"""
passed, validate_out = self.on_validate(wipe=True)
if passed:
self.istep = 0
self._make_gif(validate_out, istep=self.istep)
self.wipe_button.setEnabled(False)
self.stop_button.setEnabled(False)
def on_stop(self):
"""click the Stop button"""
#passed, validate_out = self.on_validate()
#if passed:
#self._make_gif(validate_out, stop_animation=True)
if self.is_gui:
self.gui.stop_animation()
self.wipe_button.setEnabled(True)
self.stop_button.setEnabled(False)
def on_run(self):
"""click the Run button"""
self.istep = 0
self.wipe_button.setEnabled(False)
self.stop_button.setEnabled(True)
passed, validate_out = self.on_validate()
if passed:
self._make_gif(validate_out, istep=None)
return passed
def _make_gif(self, validate_out, istep=None, stop_animation=False):
"""interface for making the gif"""
(icase_fringe, icase_disp, icase_vector, scale, time, fps, animate_in_gui,
magnify, output_dir, gifbase,
min_value, max_value) = validate_out
fps = int(fps)
gif_filename = None
if not stop_animation and not animate_in_gui and gifbase is not None:
if gifbase.lower().endswith('.gif'):
gifbase = gifbase[:-4]
gif_filename = os.path.join(output_dir, gifbase + '.gif')
animate_fringe = self.checkbox_fringe.isChecked()
animate_vector = self.checkbox_vector.isChecked()
animate_scale = self.animate_scale_radio.isChecked()
animate_phase = self.animate_phase_radio.isChecked()
animate_time = self.animate_time_radio.isChecked()
if not self.checkbox_vector.isEnabled():
icase_vector = None
animate_scale = False
animate_phase = False
animate_time = False
if self._animate_type == 'scale':
animate_scale = True
elif self._animate_type == 'phase':
animate_phase = True
elif self._animate_type == 'time':
animate_time = True
else:
raise NotImplementedError(self._animate_type)
make_images = self.make_images_checkbox.isChecked()
delete_images = self.delete_images_checkbox.isChecked()
make_gif = self.make_gif_checkbox.isChecked()
animation_profile = str(self.animation_profile_edit.currentText())
icase_disp_start = self.icase_disp_start_edit.value()
icase_disp_end = self.icase_disp_end_edit.value()
icase_disp_delta = self.icase_disp_delta_edit.value()
bool_repeat = self.repeat_checkbox.isChecked() # TODO: change this to an integer
if bool_repeat:
nrepeat = 0
else:
nrepeat = 1
#self.out_data['is_shown'] = self.show_radio.isChecked()
#icase = self._icase
if self.is_gui:
self.gui.make_gif(
gif_filename, scale, istep=istep,
animate_scale=animate_scale, animate_phase=animate_phase, animate_time=animate_time,
icase_fringe=icase_fringe, icase_disp=icase_disp, icase_vector=icase_vector,
animate_fringe=animate_fringe, animate_vector=animate_vector,
icase_start=icase_disp_start, icase_end=icase_disp_end, icase_delta=icase_disp_delta,
time=time, animation_profile=animation_profile,
nrepeat=nrepeat, fps=fps, magnify=magnify,
make_images=make_images, delete_images=delete_images, make_gif=make_gif,
stop_animation=stop_animation, animate_in_gui=animate_in_gui,
min_value=min_value, max_value=max_value,
)
self.out_data['clicked_ok'] = True
self.out_data['close'] = True
def get_min_max(self, icase):
if self.is_gui:
(obj, (i, name)) = self.gui.result_cases[icase]
min_value, max_value = obj.get_min_max(i, name)
else:
return 0., 1.0
return min_value, max_value
def on_validate(self, wipe=False):
"""checks to see if the input is valid"""
# requires no special validation
icase_fringe, flag0 = check_int(self.icase_fringe_edit)
icase_disp, unused_flaga = check_int(self.icase_disp_edit)
icase_vector, unused_flagb = check_int(self.icase_vector_edit)
#icase_disp = self._icase_disp
#icase_vector = self._icase_vector
scale, flag1 = check_float(self.scale_edit)
time, flag2 = check_float(self.time_edit)
fps, flag3 = check_float(self.fps_edit)
min_value = max_value = None
flag4 = flag5 = True
if self.min_value_edit.isEnabled():
min_value, flag4 = check_float(self.min_value_edit)
if self.max_value_edit.isEnabled():
max_value, flag5 = check_float(self.max_value_edit)
if wipe:
animate_in_gui = False
scale = 0.
flag1 = True
else:
animate_in_gui = self.animate_in_gui_checkbox.isChecked()
if scale == 0.0:
self.scale_edit.setStyleSheet("QLineEdit{background: red;}")
flag1 = False
if animate_in_gui or wipe:
passed = all([flag0, flag1, flag2, flag3, flag4, flag5])
magnify, output_dir, gifbase = None, None, None
else:
magnify, flag6 = check_int(self.resolution_edit)
output_dir, flag7 = check_path(self.browse_folder_edit)
gifbase, flag8 = check_name_str(self.gif_edit)
passed = all([flag0, flag1, flag2, flag3, flag4, flag5, flag6, flag7, flag8])
return passed, (icase_fringe, icase_disp, icase_vector, scale, time, fps, animate_in_gui,
magnify, output_dir, gifbase, min_value, max_value)
#def on_ok(self):
#"""click the OK button"""
#passed = self.on_apply()
#if passed:
#self.win_parent._animation_window_shown = False
#self.close()
##self.destroy()
def on_cancel(self):
"""click the Cancel button"""
self.on_stop()
self.out_data['close'] = True
self.close()
def create_widgets(self):
"""creates the menu objects"""
self.box_scale = QGroupBox('Animate Scale')
self.box_time = QGroupBox('Animate Time')
icase_max = 1000 # TODO: update 1000
self.checkbox_fringe = QCheckBox('Animate')
self.checkbox_fringe.setToolTip(
'Animate the fringe in addition to the deflection')
#self.checkbox_disp = QCheckBox('Animate')
self.checkbox_fringe.setEnabled(False)
self.icase_fringe_label = QLabel("iCase (Fringe):")
self.icase_fringe_edit = QSpinBox(self)
self.icase_fringe_edit.setRange(0, icase_max)
self.icase_fringe_edit.setSingleStep(1)
if self._icase_fringe is not None:
self.icase_fringe_edit.setValue(self._icase_fringe)
self.icase_fringe_edit.setToolTip(
'Case Number for the Scale/Phase Animation Type.\n'
'Defaults to the result you had shown when you clicked "Create Animation".\n'
'iCase can be seen by clicking "Apply" on a result.')
self.icase_disp_label = QLabel("iCase (Disp):")
self.icase_disp_edit = QSpinBox(self)
self.icase_disp_edit.setRange(1, icase_max)
self.icase_disp_edit.setSingleStep(1)
if self._icase_disp is not None:
self.icase_disp_edit.setValue(self._icase_disp)
self.checkbox_vector = QCheckBox('Animate')
self.checkbox_vector.setToolTip(
'Animate the vector in addition to the deflection')
self.checkbox_vector.hide()
#self.checkbox_disp = QCheckBox('Animate')
self.icase_vector_label = QLabel("iCase (Vector):")
self.icase_vector_edit = QSpinBox(self)
self.icase_vector_edit.setRange(1, icase_max)
self.icase_vector_edit.setSingleStep(1)
if self._icase_vector is not None:
self.icase_vector_edit.setValue(self._icase_vector)
self.scale_label = QLabel("True Scale:")
self.scale_edit = QLineEdit(str(self._scale))
self.scale_button = QPushButton("Default")
self.scale_edit.setToolTip('Scale factor of the "deflection"')
self.scale_button.setToolTip('Sets the scale factor of the gif to %s' % self._scale)
self.arrow_scale_label = QLabel("Arrow Scale:")
self.arrow_scale_edit = QLineEdit(str(self._scale))
self.arrow_scale_button = QPushButton("Default")
self.arrow_scale_edit.setToolTip('Scale factor of the "arrows"')
self.arrow_scale_button.setToolTip('Sets the arrow scale factor of the gif to %s' % (
self._arrow_scale))
self.arrow_scale_label.setVisible(False)
self.arrow_scale_edit.setVisible(False)
self.arrow_scale_button.setVisible(False)
self.time_label = QLabel("Total Time (sec):")
self.time_edit = QDoubleSpinBox(self)
self.time_edit.setValue(self._default_time)
self.time_edit.setRange(0.1, 5. * 60.)
self.time_edit.setDecimals(2)
self.time_edit.setSingleStep(0.1)
self.time_button = QPushButton("Default")
self.time_edit.setToolTip("Total time of the gif")
self.time_button.setToolTip('Sets the total time of the gif to %.2f' % self._default_time)
self.fps_label = QLabel("Frames/Second:")
self.fps_edit = QSpinBox(self)
self.fps_edit.setRange(1, 60)
self.fps_edit.setSingleStep(1)
self.fps_edit.setValue(self._default_fps)
self.fps_button = QPushButton("Default")
self.fps_edit.setToolTip("A higher FPS is smoother, but may not play well for large gifs")
self.fps_button.setToolTip('Sets the FPS to %s' % self._default_fps)
self.resolution_label = QLabel("Resolution Scale:")
self.resolution_edit = QSpinBox(self)
self.resolution_edit.setRange(1, 5)
self.resolution_edit.setSingleStep(1)
self.resolution_edit.setValue(self._default_resolution)
self.resolution_button = QPushButton("Default")
self.resolution_edit.setToolTip('Scales the window resolution by an integer factor')
self.resolution_button.setToolTip('Sets the resolution to %s' % self._default_resolution)
#-----------------
# Time plot
self.fringe_label = QLabel("Fringe")
self.icase_fringe_start_edit = QSpinBox(self)
self.icase_fringe_start_edit.setRange(0, icase_max)
self.icase_fringe_start_edit.setSingleStep(1)
self.icase_fringe_start_edit.setValue(self._icase_fringe)
self.icase_fringe_start_button = QPushButton("Default")
self.icase_fringe_end_edit = QSpinBox(self)
self.icase_fringe_end_edit.setRange(0, icase_max)
self.icase_fringe_end_edit.setSingleStep(1)
self.icase_fringe_end_edit.setValue(self._icase_fringe)
self.icase_fringe_end_button = QPushButton("Default")
self.icase_fringe_delta_edit = QSpinBox(self)
self.icase_fringe_delta_edit.setRange(1, icase_max)
self.icase_fringe_delta_edit.setSingleStep(1)
self.icase_fringe_delta_edit.setValue(1)
self.icase_fringe_delta_button = QPushButton("Default")
self.displacement_label = QLabel("Displacement")
self.icase_start = QLabel("iCase Start:")
self.icase_disp_start_edit = QSpinBox(self)
self.icase_disp_start_edit.setRange(0, icase_max)
self.icase_disp_start_edit.setSingleStep(1)
self.icase_disp_start_edit.setValue(self._icase_fringe)
self.icase_disp_start_button = QPushButton("Default")
self.icase_end_label = QLabel("iCase End:")
self.icase_disp_end_edit = QSpinBox(self)
self.icase_disp_end_edit.setRange(0, icase_max)
self.icase_disp_end_edit.setSingleStep(1)
self.icase_disp_end_edit.setValue(self._icase_fringe)
self.icase_disp_end_button = QPushButton("Default")
self.icase_delta_label = QLabel("iCase Delta:")
self.icase_disp_delta_edit = QSpinBox(self)
self.icase_disp_delta_edit.setRange(1, icase_max)
self.icase_disp_delta_edit.setSingleStep(1)
self.icase_disp_delta_edit.setValue(1)
self.icase_disp_delta_button = QPushButton("Default")
self.min_value_enable = QCheckBox()
self.min_value_label = QLabel("Min Value:")
self.min_value_edit = QLineEdit('')
#self.min_value_edit.setRange(1, 1000)
#self.min_value_edit.setSingleStep(1)
#self.min_value_edit.setValue(1)
self.min_value_button = QPushButton("Default")
self.max_value_enable = QCheckBox()
self.max_value_label = QLabel("Max Value:")
self.max_value_edit = QLineEdit('')
#self.min_value_edit.setRange(1, 1000) # TODO: update 1000
#self.min_value_edit.setSingleStep(1)
#self.min_value_edit.setValue(1)
self.max_value_button = QPushButton("Default")
# TODO: enable this (uncomment) ------------------------------------------
#self.min_value_enable.hide()
#self.min_value.hide()
#self.min_value_edit.hide()
#self.min_value_button.hide()
#self.max_value_enable.hide()
#self.max_value.hide()
#self.max_value_edit.hide()
#self.max_value_button.hide()
# TODO: enable this (uncomment) ------------------------------------------
self.icase_disp_start_edit.setToolTip('The first frame of the animation')
self.icase_disp_end_edit.setToolTip(
'The last frame of the animation\n'
'Assumes icase_start + nframes * icase_delta = icase_end')
self.icase_disp_delta_edit.setToolTip(
'The frame step size (to skip non-consecutive results).\n'
'Frame skipping can be used to:\n'
" - skip across results that you don't want to plot\n"
' - adjust the FPS')
self.min_value_edit.setToolTip('Min value of the legend (not supported)')
self.max_value_edit.setToolTip('Max value of the legend (not supported)')
#'time' : 0.,
#'default_time' : 0,
#'icase_start' : 10,
#'icase_delta' : 3,
#'min_value' : 0.,
#'max_value' : 1000.,
self.browse_folder_label = QLabel('Output Directory:')
self.browse_folder_edit = QLineEdit(str(self._default_dirname))
self.browse_folder_button = QPushButton('Browse...')
self.browse_folder_edit.setToolTip('Location to save the png/gif files')
self.gif_label = QLabel("Gif Filename:")
self.gif_edit = QLineEdit(str(self._default_title + '.gif'))
self.gif_button = QPushButton('Default')
self.gif_edit.setToolTip('Name of the gif')
self.gif_button.setToolTip('Sets the name of the gif to %s.gif' % self._default_title)
# scale / phase
if 1: # pragma: no cover
self.animate_scale_radio = QRadioButton("Animate Scale")
self.animate_phase_radio = QRadioButton("Animate Phase")
self.animate_time_radio = QRadioButton("Animate Time")
self.animate_freq_sweeep_radio = QRadioButton("Animate Frequency Sweep")
self.animate_scale_radio.setToolTip(
'Animates the scale factor based on the "Animation Type"')
self.animate_time_radio.setToolTip('Animates the time/load/mode step')
self.animate_scale_radio.setChecked(self._default_is_scale)
self.animate_phase_radio.setChecked(not self._default_is_scale)
self.animate_time_radio.setChecked(False)
msg = 'Scale : Animates the scale factor based on the "Animation Profile"\n'
if self._default_phase is None:
self.animate_phase_radio.setDisabled(True)
self.animate_phase_radio.setToolTip('Animates the phase angle '
'(only for complex results)')
msg += 'Phase : Animates the phase angle (only for complex results)\n'
else:
self.animate_phase_radio.setToolTip("Animates the phase angle")
msg += 'Phase : Animates the phase angle\n'
msg += (
'Time : Animates the time/load/mode step\n'
'Freq Sweep : Animates a complex result across a range of frequencies '
'(not supported)\n'
)
self.animate_freq_sweeep_radio.setDisabled(True)
self.animate_freq_sweeep_radio.setToolTip(
'Animates a complex result across a range of frequencies (not supported)')
else:
msg = 'Scale : Animates the scale factor based on the "Animation Profile"\n'
if self._default_phase is None:
#self.animate_phase_radio.setDisabled(True)
#self.animate_phase_radio.setToolTip('Animates the phase angle '
#'(only for complex results)')
msg += 'Phase : Animates the phase angle (only for complex results)\n'
else:
#self.animate_phase_radio.setToolTip("Animates the phase angle")
msg += 'Phase : Animates the phase angle\n'
msg += (
'Time : Animates the time/load/mode step\n'
'Freq Sweep : Animates a complex result across a range of frequencies '
'(not supported)\n'
)
self.animation_type = QLabel("Animation Type:")
animation_type = OrderedDict()
#scale_msg = 'Scale\n'
#phase_msg = 'Phase\n'
#time_msg = 'Time\n'
#animation_types = [
#('Animate Scale', scale_msg),
#('Animate Phase', phase_msg),
#('Animate Time', time_msg),
##'Animate Frequency Sweep'
#]
if self._phase is not None:
self.animation_types.append('Animate Phase')
self.animation_types.append('Animate Time')
self.animation_profile_label = QLabel("Animation Profile:")
self.animation_profile_edit = QComboBox()
for animation_profile in ANIMATION_PROFILES:
self.animation_profile_edit.addItem(animation_profile)
self.animation_profile_edit.setToolTip('The profile for a scaled GIF')
self.animation_type_edit = QComboBox()
# TODO: add a tooltip for each item
for animation_type in self.animation_types:
self.animation_type_edit.addItem(animation_type)
#self.animation_type_edit.setToolTip('The profile for a scaled GIF')
self.animation_type_edit.setToolTip(msg.rstrip())
self.csv_profile_label = QLabel("CSV profile:")
self.csv_profile_edit = QLineEdit()
self.csv_profile_browse_button = QPushButton('Browse')
self.csv_profile_edit.setToolTip(
'The path to the CSV file of (Scale1, Scale2, Scale3, ...)')
#widget = QWidget(self)
#horizontal_vertical_group = QButtonGroup(widget)
#horizontal_vertical_group.addButton(self.animate_scale_radio)
#horizontal_vertical_group.addButton(self.animate_phase_radio)
#horizontal_vertical_group.addButton(self.animate_time_radio)
#horizontal_vertical_group.addButton(self.animate_freq_sweeep_radio)
# animate in gui
self.animate_in_gui_checkbox = QCheckBox("Animate In GUI?")
self.animate_in_gui_checkbox.setChecked(True)
# make images
self.make_images_checkbox = QCheckBox("Make images?")
self.make_images_checkbox.setChecked(True)
# make images
self.overwrite_images_checkbox = QCheckBox("Overwrite images?")
self.overwrite_images_checkbox.setChecked(True)
# delete images when finished
self.delete_images_checkbox = QCheckBox("Delete images when finished?")
self.delete_images_checkbox.setChecked(True)
# endless loop
self.repeat_checkbox = QCheckBox("Repeat?")
self.repeat_checkbox.setChecked(True)
self.repeat_checkbox.setToolTip("Repeating creates an infinitely looping gif")
# endless loop
self.make_gif_checkbox = QCheckBox("Make Gif?")
if IS_IMAGEIO:
self.make_gif_checkbox.setChecked(True)
else:
self.make_gif_checkbox.setChecked(False)
self.make_gif_checkbox.setEnabled(False)
self.make_gif_checkbox.setToolTip('imageio is not available; install it')
# bottom buttons
self.step_button = QPushButton("Step")
self.wipe_button = QPushButton("Wipe Deformed Shape")
self.stop_button = QPushButton("Stop")
self.run_button = QPushButton("Run")
self.step_button.setToolTip('Steps through the animation (for testing)')
self.wipe_button.setToolTip('Removes the existing "deflecton" from the animation')
self.stop_button.setToolTip('Stops the animation')
self.run_button.setToolTip('Creates the animation')
self.step_button.hide()
self.wipe_button.hide()
self.wipe_button.setEnabled(False)
#self.wipe_button.hide()
self.stop_button.setEnabled(False)
self.cancel_button = QPushButton("Close")
#self.set_grid_time(enabled=False)
#self.set_grid_scale(enabled=self._default_is_scale)
if self._default_phase:
self.on_animate_phase(force=True)
set_combo_box_text(self.animation_type_edit, 'Animate Phase')
else:
self.on_animate_scale(force=True)
def setup_page(self):
newcb = self.create_checkbox
# Python executable Group
pyexec_group = QGroupBox(_("Python interpreter"))
pyexec_bg = QButtonGroup(pyexec_group)
pyexec_label = QLabel(_("Select the Python interpreter for all Spyder "
"consoles"))
def_exec_radio = self.create_radiobutton(
_("Default (i.e. the same as Spyder's)"),
'default', button_group=pyexec_bg)
self.cus_exec_radio = self.create_radiobutton(
_("Use the following Python interpreter:"),
'custom', button_group=pyexec_bg)
if os.name == 'nt':
filters = _("Executables")+" (*.exe)"
else:
filters = None
pyexec_file = self.create_browsefile('', 'executable', filters=filters)
for le in self.lineedits:
if self.lineedits[le][0] == 'executable':
self.pyexec_edit = le
def_exec_radio.toggled.connect(pyexec_file.setDisabled)
self.cus_exec_radio.toggled.connect(pyexec_file.setEnabled)
pyexec_layout = QVBoxLayout()
pyexec_layout.addWidget(pyexec_label)
pyexec_layout.addWidget(def_exec_radio)
pyexec_layout.addWidget(self.cus_exec_radio)
pyexec_layout.addWidget(pyexec_file)
pyexec_group.setLayout(pyexec_layout)
# UMR Group
umr_group = QGroupBox(_("User Module Reloader (UMR)"))
umr_label = QLabel(_("UMR forces Python to reload modules which were "
"imported when executing a file in a Python or "
"IPython console with the <i>runfile</i> "
"function."))
umr_label.setWordWrap(True)
umr_enabled_box = newcb(_("Enable UMR"), 'umr/enabled',
msg_if_enabled=True, msg_warning=_(
"This option will enable the User Module Reloader (UMR) "
"in Python/IPython consoles. UMR forces Python to "
"reload deeply modules during import when running a "
"Python script using the Spyder's builtin function "
"<b>runfile</b>."
"<br><br><b>1.</b> UMR may require to restart the "
"console in which it will be called "
"(otherwise only newly imported modules will be "
"reloaded when executing files)."
"<br><br><b>2.</b> If errors occur when re-running a "
"PyQt-based program, please check that the Qt objects "
"are properly destroyed (e.g. you may have to use the "
"attribute <b>Qt.WA_DeleteOnClose</b> on your main "
"window, using the <b>setAttribute</b> method)"),
)
umr_verbose_box = newcb(_("Show reloaded modules list"),
'umr/verbose', msg_info=_(
"Please note that these changes will "
"be applied only to new consoles"))
umr_namelist_btn = QPushButton(
_("Set UMR excluded (not reloaded) modules"))
umr_namelist_btn.clicked.connect(self.set_umr_namelist)
umr_layout = QVBoxLayout()
umr_layout.addWidget(umr_label)
umr_layout.addWidget(umr_enabled_box)
umr_layout.addWidget(umr_verbose_box)
umr_layout.addWidget(umr_namelist_btn)
umr_group.setLayout(umr_layout)
vlayout = QVBoxLayout()
vlayout.addWidget(pyexec_group)
vlayout.addWidget(umr_group)
vlayout.addStretch(1)
self.setLayout(vlayout)
def setup_page(self):
interface_group = QGroupBox(_("Interface"))
newcb = self.create_checkbox
singletab_box = newcb(_("One tab per script"), 'single_tab')
showtime_box = newcb(_("Show elapsed time"), 'show_elapsed_time')
icontext_box = newcb(_("Show icons and text"), 'show_icontext')
# Interface Group
interface_layout = QVBoxLayout()
interface_layout.addWidget(singletab_box)
interface_layout.addWidget(showtime_box)
interface_layout.addWidget(icontext_box)
interface_group.setLayout(interface_layout)
# Source Code Group
display_group = QGroupBox(_("Source code"))
buffer_spin = self.create_spinbox(_("Buffer: "),
_(" lines"),
'max_line_count',
min_=0,
max_=1000000,
step=100,
tip=_("Set maximum line count"))
wrap_mode_box = newcb(_("Wrap lines"), 'wrap')
merge_channels_box = newcb(
_("Merge process standard output/error channels"),
'merge_output_channels',
tip=_("Merging the output channels of the process means that\n"
"the standard error won't be written in red anymore,\n"
"but this has the effect of speeding up display."))
colorize_sys_stderr_box = newcb(
_("Colorize standard error channel using ANSI escape codes"),
'colorize_sys_stderr',
tip=_("This method is the only way to have colorized standard\n"
"error channel when the output channels have been "
"merged."))
merge_channels_box.toggled.connect(colorize_sys_stderr_box.setEnabled)
merge_channels_box.toggled.connect(colorize_sys_stderr_box.setChecked)
colorize_sys_stderr_box.setEnabled(
self.get_option('merge_output_channels'))
display_layout = QVBoxLayout()
display_layout.addWidget(buffer_spin)
display_layout.addWidget(wrap_mode_box)
display_layout.addWidget(merge_channels_box)
display_layout.addWidget(colorize_sys_stderr_box)
display_group.setLayout(display_layout)
# Background Color Group
bg_group = QGroupBox(_("Background color"))
bg_label = QLabel(
_("This option will be applied the next time "
"a Python console or a terminal is opened."))
bg_label.setWordWrap(True)
lightbg_box = newcb(_("Light background (white color)"),
'light_background')
bg_layout = QVBoxLayout()
bg_layout.addWidget(bg_label)
bg_layout.addWidget(lightbg_box)
bg_group.setLayout(bg_layout)
# Advanced settings
source_group = QGroupBox(_("Source code"))
completion_box = newcb(_("Automatic code completion"),
'codecompletion/auto')
case_comp_box = newcb(_("Case sensitive code completion"),
'codecompletion/case_sensitive')
comp_enter_box = newcb(_("Enter key selects completion"),
'codecompletion/enter_key')
calltips_box = newcb(_("Display balloon tips"), 'calltips')
source_layout = QVBoxLayout()
source_layout.addWidget(completion_box)
source_layout.addWidget(case_comp_box)
source_layout.addWidget(comp_enter_box)
source_layout.addWidget(calltips_box)
source_group.setLayout(source_layout)
# PYTHONSTARTUP replacement
pystartup_group = QGroupBox(_("PYTHONSTARTUP replacement"))
pystartup_bg = QButtonGroup(pystartup_group)
pystartup_label = QLabel(
_("This option will override the "
"PYTHONSTARTUP environment variable which\n"
"defines the script to be executed during "
"the Python console startup."))
def_startup_radio = self.create_radiobutton(
_("Default PYTHONSTARTUP script"),
'pythonstartup/default',
button_group=pystartup_bg)
cus_startup_radio = self.create_radiobutton(
_("Use the following startup script:"),
'pythonstartup/custom',
button_group=pystartup_bg)
pystartup_file = self.create_browsefile('', 'pythonstartup', '',
filters=_("Python scripts")+\
" (*.py)")
def_startup_radio.toggled.connect(pystartup_file.setDisabled)
cus_startup_radio.toggled.connect(pystartup_file.setEnabled)
pystartup_layout = QVBoxLayout()
pystartup_layout.addWidget(pystartup_label)
pystartup_layout.addWidget(def_startup_radio)
pystartup_layout.addWidget(cus_startup_radio)
pystartup_layout.addWidget(pystartup_file)
pystartup_group.setLayout(pystartup_layout)
# Monitor Group
monitor_group = QGroupBox(_("Monitor"))
monitor_label = QLabel(
_("The monitor provides introspection "
"features to console: code completion, "
"calltips and variable explorer. "
"Because it relies on several modules, "
"disabling the monitor may be useful "
"to accelerate console startup."))
monitor_label.setWordWrap(True)
monitor_box = newcb(_("Enable monitor"), 'monitor/enabled')
for obj in (completion_box, case_comp_box, comp_enter_box,
calltips_box):
monitor_box.toggled.connect(obj.setEnabled)
obj.setEnabled(self.get_option('monitor/enabled'))
monitor_layout = QVBoxLayout()
monitor_layout.addWidget(monitor_label)
monitor_layout.addWidget(monitor_box)
monitor_group.setLayout(monitor_layout)
# Qt Group
opts = [
(_("Default library"), 'default'),
('PyQt5', 'pyqt5'),
('PyQt4', 'pyqt'),
('PySide', 'pyside'),
]
qt_group = QGroupBox(_("Qt-Python Bindings"))
qt_setapi_box = self.create_combobox(
_("Library:") + " ",
opts,
'qt/api',
default='default',
tip=_("This option will act on<br> "
"libraries such as Matplotlib, guidata "
"or ETS"))
qt_layout = QVBoxLayout()
qt_layout.addWidget(qt_setapi_box)
qt_group.setLayout(qt_layout)
# Matplotlib Group
mpl_group = QGroupBox(_("Graphics"))
mpl_label = QLabel(
_("Decide which backend to use to display graphics. "
"If unsure, please select the <b>Automatic</b> "
"backend.<br><br>"
"<b>Note:</b> We support a very limited number "
"of backends in our Python consoles. If you "
"prefer to work with a different one, please use "
"an IPython console."))
mpl_label.setWordWrap(True)
backends = [(_("Automatic"), 0), (_("None"), 1)]
if not os.name == 'nt' and programs.is_module_installed('_tkinter'):
backends.append(("Tkinter", 2))
backends = tuple(backends)
mpl_backend_box = self.create_combobox(
_("Backend:") + " ",
backends,
'matplotlib/backend/value',
tip=_("This option will be applied the "
"next time a console is opened."))
mpl_installed = programs.is_module_installed('matplotlib')
mpl_layout = QVBoxLayout()
mpl_layout.addWidget(mpl_label)
mpl_layout.addWidget(mpl_backend_box)
mpl_group.setLayout(mpl_layout)
mpl_group.setEnabled(mpl_installed)
# ETS Group
ets_group = QGroupBox(_("Enthought Tool Suite"))
ets_label = QLabel(
_("Enthought Tool Suite (ETS) supports "
"PyQt4 (qt4) and wxPython (wx) graphical "
"user interfaces."))
ets_label.setWordWrap(True)
ets_edit = self.create_lineedit(_("ETS_TOOLKIT:"),
'ets_backend',
alignment=Qt.Horizontal)
ets_layout = QVBoxLayout()
ets_layout.addWidget(ets_label)
ets_layout.addWidget(ets_edit)
ets_group.setLayout(ets_layout)
if CONF.get('main_interpreter', 'default'):
interpreter = get_python_executable()
else:
interpreter = CONF.get('main_interpreter', 'executable')
ets_group.setEnabled(
programs.is_module_installed("enthought.etsconfig.api",
interpreter=interpreter))
tabs = QTabWidget()
tabs.addTab(self.create_tab(interface_group, display_group, bg_group),
_("Display"))
tabs.addTab(self.create_tab(monitor_group, source_group),
_("Introspection"))
tabs.addTab(self.create_tab(pystartup_group), _("Advanced settings"))
tabs.addTab(self.create_tab(qt_group, mpl_group, ets_group),
_("External modules"))
vlayout = QVBoxLayout()
vlayout.addWidget(tabs)
self.setLayout(vlayout)
def setup_page(self):
"""Create configuration page."""
options_layout = QGridLayout()
# Custom shell options
shell_group = QGroupBox(_("Terminal shell"))
shell_layout = QVBoxLayout()
if WINDOWS:
self.shells = WINDOWS_SHELLS
else:
self.shells = UNIX_SHELLS
valid_shells = []
for shell in self.shells:
if find_program(shell) is not None:
valid_shells.append(shell)
valid_shells = zip(valid_shells, valid_shells)
if WINDOWS:
default_option = 'cmd'
elif sys.platform.startswith('linux'):
default_option = 'bash'
else:
mac_ver = LooseVersion(platform.mac_ver()[0])
if mac_ver >= LooseVersion('10.15.0'):
# Catalina changed the default shell to zsh
default_option = 'zsh'
else:
default_option = 'bash'
shell_combo = self.create_combobox(_("Select the shell interpreter:"),
valid_shells,
'shell',
restart=True,
default=default_option)
shell_combo.combobox.setMinimumContentsLength(15)
shell_layout.addWidget(shell_combo)
shell_group.setLayout(shell_layout)
shell_layout.addStretch(1)
options_layout.addWidget(shell_group)
# Display preferences
display_group = QGroupBox(_("Terminal display preferences"))
display_layout = QVBoxLayout()
# Custom buffer limit
self.buffer_sb = self.create_spinbox(_("Buffer limit: "),
"",
'buffer_limit',
min_=100,
default=1000,
max_=1000000,
step=1)
display_layout.addWidget(self.buffer_sb)
display_group.setLayout(display_layout)
display_layout.addStretch(1)
options_layout.addWidget(display_group)
# Style preferences
terminal_group = QGroupBox(_("Terminal style preferences"))
# Custom bar option
cursor_choices = [(_("Block"), 0), (_("Underline"), 1), (_("Bar"), 2)]
self.cursor_combo = self.create_combobox(_("Type of cursor:"),
cursor_choices, 'cursor_type')
self.cursor_combo.combobox.setMinimumContentsLength(15)
options_layout.addWidget(self.cursor_combo)
# Custom sound option
self.sound_cb = self.create_checkbox(
_("Enable bell sound"),
'sound',
tip=_("Enable bell sound on terminal"))
options_layout.addWidget(self.sound_cb)
terminal_group.setLayout(options_layout)
layout = QVBoxLayout()
layout.addWidget(shell_group)
layout.addWidget(display_group)
layout.addWidget(terminal_group)
layout.addStretch(1)
self.setLayout(layout)
def setup_page(self):
ar_group = QGroupBox(_("Autorefresh"))
ar_box = self.create_checkbox(_("Enable autorefresh"), 'autorefresh')
ar_spin = self.create_spinbox(_("Refresh interval: "),
_(" ms"),
'autorefresh/timeout',
min_=100,
max_=1000000,
step=100)
filter_group = QGroupBox(_("Filter"))
filter_data = [
('exclude_private', _("Exclude private references")),
('exclude_capitalized', _("Exclude capitalized references")),
('exclude_uppercase', _("Exclude all-uppercase references")),
('exclude_unsupported', _("Exclude unsupported data types")),
]
filter_boxes = [
self.create_checkbox(text, option) for option, text in filter_data
]
display_group = QGroupBox(_("Display"))
display_data = [('truncate', _("Truncate values"), '')]
if programs.is_module_installed('numpy'):
display_data.append(('minmax', _("Show arrays min/max"), ''))
display_data.append(
('remote_editing', _("Edit data in the remote process"),
_("Editors are opened in the remote process for NumPy "
"arrays, PIL images, lists, tuples and dictionaries.\n"
"This avoids transfering large amount of data between "
"the remote process and Spyder (through the socket).")))
display_boxes = [
self.create_checkbox(text, option, tip=tip)
for option, text, tip in display_data
]
ar_layout = QVBoxLayout()
ar_layout.addWidget(ar_box)
ar_layout.addWidget(ar_spin)
ar_group.setLayout(ar_layout)
filter_layout = QVBoxLayout()
for box in filter_boxes:
filter_layout.addWidget(box)
filter_group.setLayout(filter_layout)
display_layout = QVBoxLayout()
for box in display_boxes:
display_layout.addWidget(box)
display_group.setLayout(display_layout)
vlayout = QVBoxLayout()
vlayout.addWidget(ar_group)
vlayout.addWidget(filter_group)
vlayout.addWidget(display_group)
vlayout.addStretch(1)
self.setLayout(vlayout)
def setup_page(self):
newcb = self.create_checkbox
# Python executable Group
pyexec_group = QGroupBox(_("Python interpreter"))
pyexec_bg = QButtonGroup(pyexec_group)
pyexec_label = QLabel(
_("Select the Python interpreter for all Spyder "
"consoles"))
self.def_exec_radio = self.create_radiobutton(
_("Default (i.e. the same as Spyder's)"),
'default',
button_group=pyexec_bg,
)
self.cus_exec_radio = self.create_radiobutton(
_("Use the following Python interpreter:"),
'custom',
button_group=pyexec_bg,
)
if os.name == 'nt':
filters = _("Executables") + " (*.exe)"
else:
filters = None
pyexec_layout = QVBoxLayout()
pyexec_layout.addWidget(pyexec_label)
pyexec_layout.addWidget(self.def_exec_radio)
pyexec_layout.addWidget(self.cus_exec_radio)
self.validate_custom_interpreters_list()
self.cus_exec_combo = self.create_file_combobox(
_('Recent custom interpreters'),
self.get_option('custom_interpreters_list'),
'custom_interpreter',
filters=filters,
default_line_edit=True,
adjust_to_contents=True,
validate_callback=programs.is_python_interpreter,
)
self.def_exec_radio.toggled.connect(self.cus_exec_combo.setDisabled)
self.cus_exec_radio.toggled.connect(self.cus_exec_combo.setEnabled)
pyexec_layout.addWidget(self.cus_exec_combo)
pyexec_group.setLayout(pyexec_layout)
self.pyexec_edit = self.cus_exec_combo.combobox.lineEdit()
# UMR Group
umr_group = QGroupBox(_("User Module Reloader (UMR)"))
umr_label = QLabel(
_("UMR forces Python to reload modules which were "
"imported when executing a file in a Python or "
"IPython console with the <i>runfile</i> "
"function."))
umr_label.setWordWrap(True)
umr_enabled_box = newcb(
_("Enable UMR"),
'umr/enabled',
msg_if_enabled=True,
msg_warning=_(
"This option will enable the User Module Reloader (UMR) "
"in Python/IPython consoles. UMR forces Python to "
"reload deeply modules during import when running a "
"Python file using the Spyder's builtin function "
"<b>runfile</b>."
"<br><br><b>1.</b> UMR may require to restart the "
"console in which it will be called "
"(otherwise only newly imported modules will be "
"reloaded when executing files)."
"<br><br><b>2.</b> If errors occur when re-running a "
"PyQt-based program, please check that the Qt objects "
"are properly destroyed (e.g. you may have to use the "
"attribute <b>Qt.WA_DeleteOnClose</b> on your main "
"window, using the <b>setAttribute</b> method)"),
)
umr_verbose_box = newcb(
_("Show reloaded modules list"),
'umr/verbose',
msg_info=_("Please note that these changes will "
"be applied only to new consoles"),
)
umr_namelist_btn = QPushButton(
_("Set UMR excluded (not reloaded) modules"))
umr_namelist_btn.clicked.connect(self.set_umr_namelist)
umr_layout = QVBoxLayout()
umr_layout.addWidget(umr_label)
umr_layout.addWidget(umr_enabled_box)
umr_layout.addWidget(umr_verbose_box)
umr_layout.addWidget(umr_namelist_btn)
umr_group.setLayout(umr_layout)
vlayout = QVBoxLayout()
vlayout.addWidget(pyexec_group)
vlayout.addWidget(umr_group)
vlayout.addStretch(1)
self.setLayout(vlayout)
def setup_page(self):
self.ICON = ima.icon('genprefs')
newcb = self.create_checkbox
# --- Interface
general_group = QGroupBox(_("General"))
# Remove disabled languages
language_codes = LANGUAGE_CODES.copy()
for lang in DISABLED_LANGUAGES:
language_codes.pop(lang)
languages = language_codes.items()
language_choices = sorted([(val, key) for key, val in languages])
language_combo = self.create_combobox(_('Language:'),
language_choices,
'interface_language',
restart=True)
opengl_options = ['Automatic', 'Desktop', 'Software', 'GLES']
opengl_choices = list(
zip(opengl_options, [c.lower() for c in opengl_options]))
opengl_combo = self.create_combobox(_('Rendering engine:'),
opengl_choices,
'opengl',
restart=True)
single_instance_box = newcb(_("Use a single instance"),
'single_instance',
tip=_("Set this to open external<br> "
"Python files in an already running "
"instance (Requires a restart)"))
prompt_box = newcb(_("Prompt when exiting"), 'prompt_on_exit')
popup_console_box = newcb(
_("Show internal Spyder errors to report "
"them to Github"), 'show_internal_errors')
check_updates = newcb(_("Check for updates on startup"),
'check_updates_on_startup')
# Decide if it's possible to activate or not single instance mode
if running_in_mac_app():
self.set_option("single_instance", True)
single_instance_box.setEnabled(False)
comboboxes_advanced_layout = QHBoxLayout()
cbs_adv_grid = QGridLayout()
cbs_adv_grid.addWidget(language_combo.label, 0, 0)
cbs_adv_grid.addWidget(language_combo.combobox, 0, 1)
cbs_adv_grid.addWidget(opengl_combo.label, 1, 0)
cbs_adv_grid.addWidget(opengl_combo.combobox, 1, 1)
comboboxes_advanced_layout.addLayout(cbs_adv_grid)
comboboxes_advanced_layout.addStretch(1)
general_layout = QVBoxLayout()
general_layout.addLayout(comboboxes_advanced_layout)
general_layout.addWidget(single_instance_box)
general_layout.addWidget(prompt_box)
general_layout.addWidget(popup_console_box)
general_layout.addWidget(check_updates)
general_group.setLayout(general_layout)
# --- Theme
interface_group = QGroupBox(_("Interface"))
verttabs_box = newcb(_("Vertical tabs in panes"), 'vertical_tabs')
margin_box = newcb(_("Custom margin for panes:"), 'use_custom_margin')
margin_spin = self.create_spinbox("",
_("pixels"),
'custom_margin',
default=0,
min_=0,
max_=30)
margin_box.toggled.connect(margin_spin.spinbox.setEnabled)
margin_box.toggled.connect(margin_spin.slabel.setEnabled)
margin_spin.spinbox.setEnabled(self.get_option('use_custom_margin'))
margin_spin.slabel.setEnabled(self.get_option('use_custom_margin'))
cursor_box = newcb(_("Cursor blinking:"), 'use_custom_cursor_blinking')
cursor_spin = self.create_spinbox(
"",
_("ms"),
'custom_cursor_blinking',
default=QApplication.cursorFlashTime(),
min_=0,
max_=5000,
step=100)
cursor_box.toggled.connect(cursor_spin.spinbox.setEnabled)
cursor_box.toggled.connect(cursor_spin.slabel.setEnabled)
cursor_spin.spinbox.setEnabled(
self.get_option('use_custom_cursor_blinking'))
cursor_spin.slabel.setEnabled(
self.get_option('use_custom_cursor_blinking'))
margins_cursor_layout = QGridLayout()
margins_cursor_layout.addWidget(margin_box, 0, 0)
margins_cursor_layout.addWidget(margin_spin.spinbox, 0, 1)
margins_cursor_layout.addWidget(margin_spin.slabel, 0, 2)
margins_cursor_layout.addWidget(cursor_box, 1, 0)
margins_cursor_layout.addWidget(cursor_spin.spinbox, 1, 1)
margins_cursor_layout.addWidget(cursor_spin.slabel, 1, 2)
margins_cursor_layout.setColumnStretch(2, 100)
# Layout interface
interface_layout = QVBoxLayout()
interface_layout.addWidget(verttabs_box)
interface_layout.addLayout(margins_cursor_layout)
interface_group.setLayout(interface_layout)
if sys.platform == "darwin":
def set_open_file(state):
if state:
register_app_launchservices()
else:
restore_launchservices()
macOS_group = QGroupBox(_("macOS integration"))
mac_open_file_box = newcb(
_("Open files from Finder with Spyder"),
'mac_open_file',
tip=_("Register Spyder with the Launch Services"))
mac_open_file_box.toggled.connect(set_open_file)
macOS_layout = QVBoxLayout()
macOS_layout.addWidget(mac_open_file_box)
if als.get_bundle_identifier() is None:
# Disable setting
mac_open_file_box.setDisabled(True)
macOS_layout.addWidget(
QLabel(
_('Launch Spyder with <code>python.app</code> to enable'
' Apple event integrations.')))
macOS_group.setLayout(macOS_layout)
# --- Status bar
sbar_group = QGroupBox(_("Status bar"))
show_status_bar = newcb(_("Show status bar"), 'show_status_bar')
memory_box = newcb(_("Show memory usage every"),
'memory_usage/enable',
tip=self.main.mem_status.toolTip())
memory_spin = self.create_spinbox("",
_(" ms"),
'memory_usage/timeout',
min_=100,
max_=1000000,
step=100)
memory_box.toggled.connect(memory_spin.setEnabled)
memory_spin.setEnabled(self.get_option('memory_usage/enable'))
memory_box.setEnabled(self.main.mem_status.is_supported())
memory_spin.setEnabled(self.main.mem_status.is_supported())
cpu_box = newcb(_("Show CPU usage every"),
'cpu_usage/enable',
tip=self.main.cpu_status.toolTip())
cpu_spin = self.create_spinbox("",
_(" ms"),
'cpu_usage/timeout',
min_=100,
max_=1000000,
step=100)
cpu_box.toggled.connect(cpu_spin.setEnabled)
cpu_spin.setEnabled(self.get_option('cpu_usage/enable'))
cpu_box.setEnabled(self.main.cpu_status.is_supported())
cpu_spin.setEnabled(self.main.cpu_status.is_supported())
clock_box = newcb(_("Show clock"), 'clock/enable')
status_bar_o = self.get_option('show_status_bar')
show_status_bar.toggled.connect(memory_box.setEnabled)
show_status_bar.toggled.connect(memory_spin.setEnabled)
show_status_bar.toggled.connect(cpu_box.setEnabled)
show_status_bar.toggled.connect(cpu_spin.setEnabled)
show_status_bar.toggled.connect(clock_box.setEnabled)
memory_box.setEnabled(status_bar_o)
memory_spin.setEnabled(status_bar_o)
cpu_box.setEnabled(status_bar_o)
cpu_spin.setEnabled(status_bar_o)
clock_box.setEnabled(status_bar_o)
# Layout status bar
cpu_memory_layout = QGridLayout()
cpu_memory_layout.addWidget(memory_box, 0, 0)
cpu_memory_layout.addWidget(memory_spin, 0, 1)
cpu_memory_layout.addWidget(cpu_box, 1, 0)
cpu_memory_layout.addWidget(cpu_spin, 1, 1)
cpu_memory_layout.addWidget(clock_box, 2, 0)
sbar_layout = QVBoxLayout()
sbar_layout.addWidget(show_status_bar)
sbar_layout.addLayout(cpu_memory_layout)
sbar_group.setLayout(sbar_layout)
# --- Screen resolution Group (hidpi)
screen_resolution_group = QGroupBox(_("Screen resolution"))
screen_resolution_bg = QButtonGroup(screen_resolution_group)
screen_resolution_label = QLabel(
_("Configuration for high DPI "
"screens<br><br>"
"Please see "
"<a href=\"{0}\">{0}</a><> "
"for more information about "
"these options (in "
"English).").format(HDPI_QT_PAGE))
screen_resolution_label.setWordWrap(True)
screen_resolution_label.setOpenExternalLinks(True)
normal_radio = self.create_radiobutton(
_("Normal"),
'normal_screen_resolution',
button_group=screen_resolution_bg)
auto_scale_radio = self.create_radiobutton(
_("Enable auto high DPI scaling"),
'high_dpi_scaling',
button_group=screen_resolution_bg,
tip=_("Set this for high DPI displays"),
restart=True)
custom_scaling_radio = self.create_radiobutton(
_("Set a custom high DPI scaling"),
'high_dpi_custom_scale_factor',
button_group=screen_resolution_bg,
tip=_("Set this for high DPI displays when "
"auto scaling does not work"),
restart=True)
self.custom_scaling_edit = self.create_lineedit(
"",
'high_dpi_custom_scale_factors',
tip=_("Enter values for different screens "
"separated by semicolons ';'.\n"
"Float values are supported"),
alignment=Qt.Horizontal,
regex=r"[0-9]+(?:\.[0-9]*)(;[0-9]+(?:\.[0-9]*))*",
restart=True)
normal_radio.toggled.connect(self.custom_scaling_edit.setDisabled)
auto_scale_radio.toggled.connect(self.custom_scaling_edit.setDisabled)
custom_scaling_radio.toggled.connect(
self.custom_scaling_edit.setEnabled)
# Layout Screen resolution
screen_resolution_layout = QVBoxLayout()
screen_resolution_layout.addWidget(screen_resolution_label)
screen_resolution_inner_layout = QGridLayout()
screen_resolution_inner_layout.addWidget(normal_radio, 0, 0)
screen_resolution_inner_layout.addWidget(auto_scale_radio, 1, 0)
screen_resolution_inner_layout.addWidget(custom_scaling_radio, 2, 0)
screen_resolution_inner_layout.addWidget(self.custom_scaling_edit, 2,
1)
screen_resolution_layout.addLayout(screen_resolution_inner_layout)
screen_resolution_group.setLayout(screen_resolution_layout)
if sys.platform == "darwin":
interface_tab = self.create_tab(screen_resolution_group,
interface_group, macOS_group)
else:
interface_tab = self.create_tab(screen_resolution_group,
interface_group)
tabs = QTabWidget()
tabs.addTab(interface_tab, _("Interface"))
tabs.addTab(self.create_tab(general_group, sbar_group),
_("Advanced settings"))
vlayout = QVBoxLayout()
vlayout.addWidget(tabs)
self.setLayout(vlayout)
def setup_page(self):
run_dlg = _("Run Settings")
run_menu = _("Run")
about_label = QLabel(
_(
"The following are the default <i>%s</i>. "
"These options may be overriden using the "
"<b>%s</b> dialog box (see the <b>%s</b> menu)"
)
% (run_dlg, run_dlg, run_menu)
)
about_label.setWordWrap(True)
interpreter_group = QGroupBox(_("Console"))
interpreter_bg = QButtonGroup(interpreter_group)
self.current_radio = self.create_radiobutton(
CURRENT_INTERPRETER, CURRENT_INTERPRETER_OPTION, True, button_group=interpreter_bg
)
self.dedicated_radio = self.create_radiobutton(
DEDICATED_INTERPRETER, DEDICATED_INTERPRETER_OPTION, False, button_group=interpreter_bg
)
self.systerm_radio = self.create_radiobutton(
SYSTERM_INTERPRETER, SYSTERM_INTERPRETER_OPTION, False, button_group=interpreter_bg
)
interpreter_layout = QVBoxLayout()
interpreter_group.setLayout(interpreter_layout)
interpreter_layout.addWidget(self.current_radio)
interpreter_layout.addWidget(self.dedicated_radio)
interpreter_layout.addWidget(self.systerm_radio)
general_group = QGroupBox("General settings")
wdir_bg = QButtonGroup(general_group)
wdir_label = QLabel(_("Default working directory is:"))
wdir_label.setWordWrap(True)
dirname_radio = self.create_radiobutton(
_("the script directory"), WDIR_USE_SCRIPT_DIR_OPTION, True, button_group=wdir_bg
)
thisdir_radio = self.create_radiobutton(
_("the following directory:"), WDIR_USE_FIXED_DIR_OPTION, False, button_group=wdir_bg
)
thisdir_bd = self.create_browsedir("", WDIR_FIXED_DIR_OPTION, getcwd())
thisdir_radio.toggled.connect(thisdir_bd.setEnabled)
dirname_radio.toggled.connect(thisdir_bd.setDisabled)
thisdir_layout = QHBoxLayout()
thisdir_layout.addWidget(thisdir_radio)
thisdir_layout.addWidget(thisdir_bd)
post_mortem = self.create_checkbox(
_("Enter debugging mode when errors appear during execution"), "post_mortem", False
)
general_layout = QVBoxLayout()
general_layout.addWidget(wdir_label)
general_layout.addWidget(dirname_radio)
general_layout.addLayout(thisdir_layout)
general_layout.addWidget(post_mortem)
general_group.setLayout(general_layout)
dedicated_group = QGroupBox(_("Dedicated Python console"))
interact_after = self.create_checkbox(_("Interact with the Python console after execution"), "interact", False)
show_warning = self.create_checkbox(_("Show warning when killing running processes"), "show_kill_warning", True)
dedicated_layout = QVBoxLayout()
dedicated_layout.addWidget(interact_after)
dedicated_layout.addWidget(show_warning)
dedicated_group.setLayout(dedicated_layout)
firstrun_cb = self.create_checkbox(
ALWAYS_OPEN_FIRST_RUN % _("Run Settings dialog"), ALWAYS_OPEN_FIRST_RUN_OPTION, False
)
vlayout = QVBoxLayout()
vlayout.addWidget(about_label)
vlayout.addSpacing(10)
vlayout.addWidget(interpreter_group)
vlayout.addWidget(general_group)
vlayout.addWidget(dedicated_group)
vlayout.addWidget(firstrun_cb)
vlayout.addStretch(1)
self.setLayout(vlayout)
def create_layout(self):
"""displays the menu objects"""
grid = QGridLayout()
grid.addWidget(self.icase_fringe, 0, 0)
grid.addWidget(self.icase_fringe_edit, 0, 1)
grid.addWidget(self.scale, 1, 0)
grid.addWidget(self.scale_edit, 1, 1)
grid.addWidget(self.scale_button, 1, 2)
grid.addWidget(self.arrow_scale, 2, 0)
grid.addWidget(self.arrow_scale_edit, 2, 1)
grid.addWidget(self.arrow_scale_button, 2, 2)
grid.addWidget(self.time, 3, 0)
grid.addWidget(self.time_edit, 3, 1)
grid.addWidget(self.time_button, 3, 2)
# spacer
spacer = QLabel('')
grid.addWidget(self.fps, 4, 0)
grid.addWidget(self.fps_edit, 4, 1)
grid.addWidget(self.fps_button, 4, 2)
grid.addWidget(self.resolution, 5, 0)
grid.addWidget(self.resolution_edit, 5, 1)
grid.addWidget(self.resolution_button, 5, 2)
grid.addWidget(self.browse_folder, 6, 0)
grid.addWidget(self.browse_folder_edit, 6, 1)
grid.addWidget(self.browse_folder_button, 6, 2)
grid.addWidget(self.gif, 7, 0)
grid.addWidget(self.gif_edit, 7, 1)
grid.addWidget(self.gif_button, 7, 2)
grid.addWidget(self.animation_type, 8, 0)
grid.addWidget(self.animation_type_edit, 8, 1)
grid.addWidget(spacer, 9, 0)
#----------
#Time
grid_time = QGridLayout()
grid_time.addWidget(self.icase_start, 0, 0)
grid_time.addWidget(self.icase_start_edit, 0, 1)
#grid_time.addWidget(self.icase_start_button, 0, 2)
grid_time.addWidget(self.icase_end, 1, 0)
grid_time.addWidget(self.icase_end_edit, 1, 1)
#grid_time.addWidget(self.icase_end_button, 1, 2)
grid_time.addWidget(self.icase_delta, 2, 0)
grid_time.addWidget(self.icase_delta_edit, 2, 1)
#grid_time.addWidget(self.icase_delta_button, 2, 2)
hbox = QHBoxLayout()
hbox.addWidget(self.min_value_enable)
hbox.addWidget(self.min_value)
grid_time.addLayout(hbox, 3, 0)
grid_time.addWidget(self.min_value_edit, 3, 1)
grid_time.addWidget(self.min_value_button, 3, 2)
hbox = QHBoxLayout()
hbox.addWidget(self.max_value_enable)
hbox.addWidget(self.max_value)
grid_time.addLayout(hbox, 4, 0)
grid_time.addWidget(self.max_value_edit, 4, 1)
grid_time.addWidget(self.max_value_button, 4, 2)
grid_time.addWidget(spacer, 5, 0)
#--------------
grid_scale = QGridLayout()
grid_scale.addWidget(self.animation_profile, 0, 0)
grid_scale.addWidget(self.animation_profile_edit, 0, 1)
#grid_scale.addWidget(self.csv_profile, 1, 0)
#grid_scale.addWidget(self.csv_profile_edit, 1, 1)
#grid_scale.addWidget(self.csv_profile_browse_button, 1, 2)
self.csv_profile = QLabel("CSV profile:")
self.csv_profile_edit = QLineEdit()
self.csv_profile_button = QPushButton('Browse')
#box_time = QVBoxLayout()
# TODO: It's super annoying that the animate time box doesn't
# line up with the previous box
box_scale = QGroupBox('Animate Scale')
box_scale.setLayout(grid_scale)
box_time = QGroupBox('Animate Time')
box_time.setLayout(grid_time)
#----------
grid2 = QGridLayout()
#grid2.addWidget(self.animate_scale_radio, 8, 0)
#grid2.addWidget(self.animate_phase_radio, 8, 1)
#grid2.addWidget(self.animate_time_radio, 8, 2)
#grid2.addWidget(self.animate_freq_sweeep_radio, 8, 3)
grid2.addWidget(self.animate_in_gui_checkbox, 10, 0)
grid2.addWidget(self.make_images_checkbox, 11, 0)
#grid2.addWidget(self.overwrite_images_checkbox, 11, 0)
grid2.addWidget(self.delete_images_checkbox, 11, 1)
grid2.addWidget(self.make_gif_checkbox, 11, 2)
grid2.addWidget(self.repeat_checkbox, 12, 0)
grid2.addWidget(spacer, 13, 0)
grid_hbox = QHBoxLayout()
grid_hbox.addWidget(spacer)
grid_hbox.addLayout(grid2)
grid_hbox.addWidget(spacer)
# bottom buttons
step_run_box = QHBoxLayout()
step_run_box.addWidget(self.step_button)
step_run_box.addWidget(self.wipe_button)
step_run_box.addWidget(self.stop_button)
step_run_box.addWidget(self.run_button)
ok_cancel_box = QHBoxLayout()
ok_cancel_box.addWidget(self.cancel_button)
vbox = QVBoxLayout()
vbox.addLayout(grid)
vbox.addWidget(box_scale)
vbox.addWidget(box_time)
#vbox.addLayout(checkboxes)
vbox.addLayout(grid_hbox)
vbox.addStretch()
vbox.addLayout(step_run_box)
vbox.addLayout(ok_cancel_box)
self.setLayout(vbox)
def __init__(self, parent, text):
QWidget.__init__(self, parent)
self.text_editor = QTextEdit(self)
self.text_editor.setText(text)
self.text_editor.setReadOnly(True)
# Type frame
type_layout = QHBoxLayout()
type_label = QLabel(_("Import as"))
type_layout.addWidget(type_label)
data_btn = QRadioButton(_("data"))
data_btn.setChecked(True)
self._as_data= True
type_layout.addWidget(data_btn)
code_btn = QRadioButton(_("code"))
self._as_code = False
type_layout.addWidget(code_btn)
txt_btn = QRadioButton(_("text"))
type_layout.addWidget(txt_btn)
h_spacer = QSpacerItem(40, 20,
QSizePolicy.Expanding, QSizePolicy.Minimum)
type_layout.addItem(h_spacer)
type_frame = QFrame()
type_frame.setLayout(type_layout)
# Opts frame
grid_layout = QGridLayout()
grid_layout.setSpacing(0)
col_label = QLabel(_("Column separator:"))
grid_layout.addWidget(col_label, 0, 0)
col_w = QWidget()
col_btn_layout = QHBoxLayout()
self.tab_btn = QRadioButton(_("Tab"))
self.tab_btn.setChecked(False)
col_btn_layout.addWidget(self.tab_btn)
other_btn_col = QRadioButton(_("other"))
other_btn_col.setChecked(True)
col_btn_layout.addWidget(other_btn_col)
col_w.setLayout(col_btn_layout)
grid_layout.addWidget(col_w, 0, 1)
self.line_edt = QLineEdit(",")
self.line_edt.setMaximumWidth(30)
self.line_edt.setEnabled(True)
other_btn_col.toggled.connect(self.line_edt.setEnabled)
grid_layout.addWidget(self.line_edt, 0, 2)
row_label = QLabel(_("Row separator:"))
grid_layout.addWidget(row_label, 1, 0)
row_w = QWidget()
row_btn_layout = QHBoxLayout()
self.eol_btn = QRadioButton(_("EOL"))
self.eol_btn.setChecked(True)
row_btn_layout.addWidget(self.eol_btn)
other_btn_row = QRadioButton(_("other"))
row_btn_layout.addWidget(other_btn_row)
row_w.setLayout(row_btn_layout)
grid_layout.addWidget(row_w, 1, 1)
self.line_edt_row = QLineEdit(";")
self.line_edt_row.setMaximumWidth(30)
self.line_edt_row.setEnabled(False)
other_btn_row.toggled.connect(self.line_edt_row.setEnabled)
grid_layout.addWidget(self.line_edt_row, 1, 2)
grid_layout.setRowMinimumHeight(2, 15)
other_group = QGroupBox(_("Additional options"))
other_layout = QGridLayout()
other_group.setLayout(other_layout)
skiprows_label = QLabel(_("Skip rows:"))
other_layout.addWidget(skiprows_label, 0, 0)
self.skiprows_edt = QLineEdit('0')
self.skiprows_edt.setMaximumWidth(30)
intvalid = QIntValidator(0, len(to_text_string(text).splitlines()),
self.skiprows_edt)
self.skiprows_edt.setValidator(intvalid)
other_layout.addWidget(self.skiprows_edt, 0, 1)
other_layout.setColumnMinimumWidth(2, 5)
comments_label = QLabel(_("Comments:"))
other_layout.addWidget(comments_label, 0, 3)
self.comments_edt = QLineEdit('#')
self.comments_edt.setMaximumWidth(30)
other_layout.addWidget(self.comments_edt, 0, 4)
self.trnsp_box = QCheckBox(_("Transpose"))
#self.trnsp_box.setEnabled(False)
other_layout.addWidget(self.trnsp_box, 1, 0, 2, 0)
grid_layout.addWidget(other_group, 3, 0, 2, 0)
opts_frame = QFrame()
opts_frame.setLayout(grid_layout)
data_btn.toggled.connect(opts_frame.setEnabled)
data_btn.toggled.connect(self.set_as_data)
code_btn.toggled.connect(self.set_as_code)
# self.connect(txt_btn, SIGNAL("toggled(bool)"),
# self, SLOT("is_text(bool)"))
# Final layout
layout = QVBoxLayout()
layout.addWidget(type_frame)
layout.addWidget(self.text_editor)
layout.addWidget(opts_frame)
self.setLayout(layout)
class DesignTab(QWidget):
def __init__(self):
super(DesignTab, self).__init__()
self.setup_ui()
self.grain_dialog = None
self.btn_new_grain.clicked.connect(self.create_grain_dialog)
def create_grain_dialog(self):
self.grain_dialog = NewGrainDialog()
self.grain_dialog.show()
self.grain_dialog.activateWindow()
self.grain_dialog.raise_()
def setup_ui(self):
sp = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.setSizePolicy(sp)
def setup_grain_design():
# grain table view
master = QHBoxLayout(self)
master.addWidget(QTableView())
# grain design controls
controls = QVBoxLayout(self)
# add a push button
self.btn_new_grain = QPushButton(self.tr("New Grain"))
self.btn_new_grain.setMinimumHeight(50)
controls.addWidget(self.btn_new_grain)
# add a dividing line
line = QFrame()
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
controls.addSpacing(5)
controls.addWidget(line)
# rest of the controls buttons
self.btn_edit_grain = QPushButton(self.tr("Edit"))
self.btn_edit_grain.setMinimumHeight(30)
controls.addWidget(self.btn_edit_grain)
self.btn_delete_Grain = QPushButton(self.tr("Delete"))
self.btn_delete_Grain.setMinimumHeight(30)
controls.addWidget(self.btn_delete_Grain)
# move grain up and down
moveup = QHBoxLayout()
self.btn_move_up = QToolButton()
self.btn_move_up.setArrowType(Qt.UpArrow)
moveup.addWidget(self.btn_move_up)
moveup.addWidget(QLabel(self.tr("Move Up")))
controls.addLayout(moveup)
movedown = QHBoxLayout()
self.btn_move_down = QToolButton()
self.btn_move_down.setArrowType(Qt.DownArrow)
movedown.addWidget(self.btn_move_down)
movedown.addWidget(QLabel(self.tr("Move Down")))
controls.addLayout(movedown)
controls.addStretch()
# add info for motor design
fl_propellant_info = QFormLayout()
gb_motor_info = QGroupBox(self.tr("Propellant Info"))
gb_motor_info.setLayout(fl_propellant_info)
self.lbl_num_grains = QLabel()
fl_propellant_info.addRow(QLabel(self.tr("Number of Segments:")), self.lbl_num_grains)
self.lbl_motor_dia = QLabel()
fl_propellant_info.addRow(QLabel(self.tr("Motor Diameter:")), self.lbl_motor_dia)
self.lbl_motor_len = QLabel()
fl_propellant_info.addRow(QLabel(self.tr("Propellant Length:")), self.lbl_motor_len)
self.lbl_prop_mass = QLabel()
fl_propellant_info.addRow(QLabel(self.tr("Propellant Mass:")), self.lbl_prop_mass)
self.lbl_volume_loading = QLabel()
fl_propellant_info.addRow(QLabel(self.tr("Volume Loading:")), self.lbl_volume_loading)
# set group box's layout
controls.addWidget(gb_motor_info)
# setup master layout
master.addLayout(controls)
self.gb_design = QGroupBox(self.tr("Grain Design"))
self.gb_design.setLayout(master)
def setup_chamber_design():
# master layout
master = QVBoxLayout()
# master group box
self.gb_chamber = QGroupBox(self.tr("Chamber Design"))
# nozzle settings button
self.btn_nozzle_settings = QPushButton(self.tr("Edit Nozzle"))
self.btn_nozzle_settings.setMinimumHeight(50)
master.addWidget(self.btn_nozzle_settings)
# nozzle info pane
fl_nozzle_info = QFormLayout()
gb_nozzle = QGroupBox(self.tr("Nozzle Info"))
gb_nozzle.setLayout(fl_nozzle_info)
self.lbl_nozzle_throat = QLabel()
fl_nozzle_info.addRow(QLabel(self.tr("Throat Diameter:")), self.lbl_nozzle_throat)
self.lbl_nozzle_exit = QLabel()
fl_nozzle_info.addRow(QLabel(self.tr("Exit Diameter:")), self.lbl_nozzle_exit)
self.lbl_nozzle_expansion_ratio = QLabel()
fl_nozzle_info.addRow(QLabel(self.tr("Expansion Ratio:")), self.lbl_nozzle_expansion_ratio)
# add group box to master
master.addWidget(gb_nozzle)
master.addStretch()
# overall motor info pane
fl_motor_info = QFormLayout()
gb_motor = QGroupBox(self.tr("Motor Info"))
gb_motor.setLayout(fl_motor_info)
self.lbl_kn = QLabel()
fl_motor_info.addRow(QLabel(self.tr("Kn:")), self.lbl_kn)
self.lbl_port_throat = QLabel()
fl_motor_info.addRow(QLabel(self.tr("Port/Throat Ratio:")), self.lbl_port_throat)
master.addWidget(gb_motor)
self.gb_chamber.setLayout(master)
def setup_gfx_ui():
# design overview
self.motor_display_view = QGraphicsView()
self.motor_display_scene = QGraphicsScene()
self.motor_display_view.setScene(self.motor_display_scene)
self.motor_display_view.show()
# sliced cross section
self.grain_slice_view = QGraphicsView()
self.grain_slice_scene = QGraphicsScene()
self.grain_slice_view.setScene(self.grain_slice_scene)
self.grain_slice_view.show()
# splitter
self.splt_gfx = QSplitter(Qt.Horizontal)
self.splt_gfx.addWidget(self.motor_display_view)
self.splt_gfx.addWidget(self.grain_slice_view)
self.splt_gfx.setStretchFactor(0, 10)
self.splt_gfx.setStretchFactor(1, 3)
self.splt_gfx.setMinimumHeight(50)
setup_grain_design()
setup_chamber_design()
setup_gfx_ui()
self.splt_grain_design = QSplitter(Qt.Horizontal)
self.splt_grain_design.addWidget(self.gb_design)
self.splt_grain_design.addWidget(self.gb_chamber)
self.splt_grain_design.setStretchFactor(0, 10)
self.splt_grain_design.setStretchFactor(1, 3)
self.splt_main = QSplitter(Qt.Vertical)
self.splt_main.addWidget(self.splt_grain_design)
self.splt_main.addWidget(self.splt_gfx)
self.splt_main.setSizes([300, 150])
layout = QVBoxLayout()
layout.addWidget(self.splt_main)
self.setLayout(layout)
def _get_config_widget(self, parent):
gb_pos = QGroupBox('Image Processing ', parent)
meth_sp = PyDMEnumComboBox(
gb_pos, init_channel=self._dev+':CalcMethod-Sel')
meth_lb = SiriusLabel(gb_pos, init_channel=self._dev+':CalcMethod-Sts')
meth_ld = QLabel('Method', gb_pos)
nrpt_ld = QLabel('Num. Pts.', gb_pos)
nrpt_sp = SiriusSpinbox(
gb_pos, init_channel=self._dev+':NrAverages-SP')
nrpt_sp.showStepExponent = False
rdb = PyDMLabel(gb_pos, init_channel=self._dev+':NrAverages-RB')
rdb.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
slsh = QLabel('/', gb_pos, alignment=Qt.AlignCenter)
slsh.setStyleSheet('min-width:0.7em; max-width:0.7em;')
cnt = PyDMLabel(gb_pos, init_channel=self._dev+':BufferSize-Mon')
cnt.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
cnt.setToolTip('Current Buffer Size')
pbt = PyDMPushButton(
gb_pos, init_channel=self._dev+':ResetBuffer-Cmd', pressValue=1)
pbt.setToolTip('Reset Buffer')
pbt.setIcon(qta.icon('mdi.delete-empty'))
pbt.setObjectName('rst')
pbt.setStyleSheet(
'#rst{min-width:25px; max-width:25px; icon-size:20px;}')
nrpt_wd = QWidget(gb_pos)
hbl = QHBoxLayout(nrpt_wd)
hbl.addWidget(pbt)
hbl.addStretch()
hbl.addWidget(cnt)
hbl.addWidget(slsh)
hbl.addWidget(rdb)
rsx_sp = SiriusSpinbox(gb_pos, init_channel=self._dev+':ROISizeX-SP')
rsx_sp.showStepExponent = False
rsx_lb = SiriusLabel(gb_pos, init_channel=self._dev+':ROISizeX-RB')
rsx_ld = QLabel('ROI Size X', gb_pos)
rsy_sp = SiriusSpinbox(gb_pos, init_channel=self._dev+':ROISizeY-SP')
rsy_sp.showStepExponent = False
rsy_lb = SiriusLabel(gb_pos, init_channel=self._dev+':ROISizeY-RB')
rsy_ld = QLabel('ROI Size Y', gb_pos)
ra_bt = PyDMStateButton(
gb_pos, init_channel=self._dev+':ROIAutoCenter-Sel')
ra_lb = SiriusLabel(
gb_pos, init_channel=self._dev+':ROIAutoCenter-Sts')
ra_ld = QLabel('Auto Center:', gb_pos)
rcx_sp = SiriusSpinbox(gb_pos, init_channel=self._dev+':ROICenterX-SP')
rcx_sp.showStepExponent = False
rcx_lb = SiriusLabel(gb_pos, init_channel=self._dev+':ROICenterX-RB')
rcx_ld = QLabel('ROI Center X', gb_pos)
rcy_sp = SiriusSpinbox(gb_pos, init_channel=self._dev+':ROICenterY-SP')
rcy_sp.showStepExponent = False
rcy_lb = SiriusLabel(gb_pos, init_channel=self._dev+':ROICenterY-RB')
rcy_ld = QLabel('ROI Center Y', gb_pos)
sts_bt = QPushButton(qta.icon('fa5s.ellipsis-h'), '', gb_pos)
sts_bt.setToolTip('Open Detailed Configs')
sts_bt.setObjectName('sts')
sts_bt.setStyleSheet(
'#sts{min-width:25px; max-width:25px; icon-size:20px;}')
Window = create_window_from_widget(
_DetailedWidget, title='Image Processing Detailed Configs')
connect_window(
sts_bt, Window, gb_pos, device=self._dev,
convertion_set=self._conv_set)
hlay = QHBoxLayout()
hlay.addWidget(sts_bt, alignment=Qt.AlignRight)
lay = QGridLayout(gb_pos)
if self._ori == 'V':
lay.addWidget(meth_ld, 0, 0, 2, 1, alignment=Qt.AlignLeft)
lay.addWidget(meth_sp, 0, 1)
lay.addWidget(meth_lb, 1, 1)
lay.addWidget(nrpt_ld, 2, 0, alignment=Qt.AlignLeft)
lay.addWidget(nrpt_sp, 2, 1)
lay.addWidget(nrpt_wd, 3, 0, 1, 2)
lay.addWidget(rsx_ld, 4+0, 0, 2, 1, alignment=Qt.AlignLeft)
lay.addWidget(rsx_sp, 4+0, 1)
lay.addWidget(rsx_lb, 4+1, 1)
lay.addWidget(rsy_ld, 6+0, 0, 2, 1, alignment=Qt.AlignLeft)
lay.addWidget(rsy_sp, 6+0, 1)
lay.addWidget(rsy_lb, 6+1, 1)
lay.addWidget(sts_bt, 0, 0+4, alignment=Qt.AlignRight)
lay.addWidget(ra_ld, 2+0, 0+3, 2, 1, alignment=Qt.AlignLeft)
lay.addWidget(ra_bt, 2+0, 1+3)
lay.addWidget(ra_lb, 2+1, 1+3, alignment=Qt.AlignLeft)
lay.addWidget(rcx_ld, 4+0, 0+3, 2, 1, alignment=Qt.AlignLeft)
lay.addWidget(rcx_sp, 4+0, 1+3)
lay.addWidget(rcx_lb, 4+1, 1+3)
lay.addWidget(rcy_ld, 6+0, 0+3, 2, 1, alignment=Qt.AlignLeft)
lay.addWidget(rcy_sp, 6+0, 1+3)
lay.addWidget(rcy_lb, 6+1, 1+3)
else:
lay.addWidget(meth_ld, 0, 0, 2, 1, alignment=Qt.AlignLeft)
lay.addWidget(meth_sp, 0, 1)
lay.addWidget(meth_lb, 1, 1)
lay.addWidget(nrpt_ld, 2, 0, alignment=Qt.AlignLeft)
lay.addWidget(nrpt_sp, 2, 1)
lay.addWidget(nrpt_wd, 3, 0, 1, 2)
lay.addWidget(rsx_ld, 4+0, 0, 2, 1, alignment=Qt.AlignLeft)
lay.addWidget(rsx_sp, 4+0, 1)
lay.addWidget(rsx_lb, 4+1, 1)
lay.addWidget(rsy_ld, 6+0, 0, 2, 1, alignment=Qt.AlignLeft)
lay.addWidget(rsy_sp, 6+0, 1)
lay.addWidget(rsy_lb, 6+1, 1)
lay.addWidget(ra_ld, 8+0, 0, 2, 1, alignment=Qt.AlignLeft)
lay.addWidget(ra_bt, 8+0, 1)
lay.addWidget(ra_lb, 8+1, 1, alignment=Qt.AlignLeft)
lay.addWidget(rcx_ld, 10+0, 0, 2, 1, alignment=Qt.AlignLeft)
lay.addWidget(rcx_sp, 10+0, 1)
lay.addWidget(rcx_lb, 10+1, 1)
lay.addWidget(rcy_ld, 12+0, 0, 2, 1, alignment=Qt.AlignLeft)
lay.addWidget(rcy_sp, 12+0, 1)
lay.addWidget(rcy_lb, 12+1, 1)
lay.addWidget(sts_bt, 14, 0, alignment=Qt.AlignLeft)
lay.setRowStretch(15, 5)
return gb_pos
def setup_page(self):
if ERR_MSG:
label = QLabel(_("Could not load plugin:\n{0}".format(ERR_MSG)))
layout = QVBoxLayout()
layout.addWidget(label)
self.setLayout(layout)
return
# General options
# Hack : the spinbox widget will be added to self.spinboxes
# spinboxes_before = set(self.spinboxes)
# line length
line_length_spin = self.create_spinbox(
_("Line length: "),
"",
"line_length",
default=self.OPTIONS["line_length"],
min_=40,
max_=200,
step=1,
tip=_("Set line lenght"),
)
# spinbox = set(self.spinboxes) - spinboxes_before
# spinbox = spinbox.pop()
# target python version
versions_group = QGroupBox(_("Target versions"))
target_layout = QGridLayout()
default = get_python_version() # the python version being used
for i, option in enumerate(self.OPTIONS["target_version"]):
if default == option[0]:
value = True
else:
value = False
col = i - (i // 2) * 2
row = i // 2
cb = self.create_checkbox(option[0], option[1], default=value)
target_layout.addWidget(cb, row, col)
versions_group.setLayout(target_layout)
# skip string normalization
choices = self.OPTIONS["skip_string_normalization"]
default = "False"
skip_string_combobox = self.create_combobox(
_("Skip string normalization: "),
choices,
"skip_string_normalization",
default=default,
)
# General layout
options_layout = QVBoxLayout()
options_layout.addWidget(line_length_spin)
options_layout.addWidget(versions_group)
options_layout.addWidget(skip_string_combobox)
options_group = QGroupBox(_("Options"))
options_group.setLayout(options_layout)
vlayout = QVBoxLayout()
vlayout.addWidget(options_group)
self.setLayout(vlayout)
def setup_grain_design():
# grain table view
master = QHBoxLayout(self)
master.addWidget(QTableView())
# grain design controls
controls = QVBoxLayout(self)
# add a push button
self.btn_new_grain = QPushButton(self.tr("New Grain"))
self.btn_new_grain.setMinimumHeight(50)
controls.addWidget(self.btn_new_grain)
# add a dividing line
line = QFrame()
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
controls.addSpacing(5)
controls.addWidget(line)
# rest of the controls buttons
self.btn_edit_grain = QPushButton(self.tr("Edit"))
self.btn_edit_grain.setMinimumHeight(30)
controls.addWidget(self.btn_edit_grain)
self.btn_delete_Grain = QPushButton(self.tr("Delete"))
self.btn_delete_Grain.setMinimumHeight(30)
controls.addWidget(self.btn_delete_Grain)
# move grain up and down
moveup = QHBoxLayout()
self.btn_move_up = QToolButton()
self.btn_move_up.setArrowType(Qt.UpArrow)
moveup.addWidget(self.btn_move_up)
moveup.addWidget(QLabel(self.tr("Move Up")))
controls.addLayout(moveup)
movedown = QHBoxLayout()
self.btn_move_down = QToolButton()
self.btn_move_down.setArrowType(Qt.DownArrow)
movedown.addWidget(self.btn_move_down)
movedown.addWidget(QLabel(self.tr("Move Down")))
controls.addLayout(movedown)
controls.addStretch()
# add info for motor design
fl_propellant_info = QFormLayout()
gb_motor_info = QGroupBox(self.tr("Propellant Info"))
gb_motor_info.setLayout(fl_propellant_info)
self.lbl_num_grains = QLabel()
fl_propellant_info.addRow(QLabel(self.tr("Number of Segments:")), self.lbl_num_grains)
self.lbl_motor_dia = QLabel()
fl_propellant_info.addRow(QLabel(self.tr("Motor Diameter:")), self.lbl_motor_dia)
self.lbl_motor_len = QLabel()
fl_propellant_info.addRow(QLabel(self.tr("Propellant Length:")), self.lbl_motor_len)
self.lbl_prop_mass = QLabel()
fl_propellant_info.addRow(QLabel(self.tr("Propellant Mass:")), self.lbl_prop_mass)
self.lbl_volume_loading = QLabel()
fl_propellant_info.addRow(QLabel(self.tr("Volume Loading:")), self.lbl_volume_loading)
# set group box's layout
controls.addWidget(gb_motor_info)
# setup master layout
master.addLayout(controls)
self.gb_design = QGroupBox(self.tr("Grain Design"))
self.gb_design.setLayout(master)
def __init__(self, parent):
QGroupBox.__init__(self, parent)
self.ui = Ui_groupBoxZ_Component_Single()
self.ui.setupUi(self)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.dir = None
self.runconf = RunConfiguration()
firstrun_o = CONF.get('run', ALWAYS_OPEN_FIRST_RUN_OPTION, False)
# --- Interpreter ---
interpreter_group = QGroupBox(_("Console"))
interpreter_layout = QVBoxLayout()
interpreter_group.setLayout(interpreter_layout)
self.current_radio = QRadioButton(CURRENT_INTERPRETER)
interpreter_layout.addWidget(self.current_radio)
self.dedicated_radio = QRadioButton(DEDICATED_INTERPRETER)
interpreter_layout.addWidget(self.dedicated_radio)
self.systerm_radio = QRadioButton(SYSTERM_INTERPRETER)
interpreter_layout.addWidget(self.systerm_radio)
# --- General settings ----
common_group = QGroupBox(_("General settings"))
common_layout = QGridLayout()
common_group.setLayout(common_layout)
self.clear_var_cb = QCheckBox(CLEAR_ALL_VARIABLES)
common_layout.addWidget(self.clear_var_cb, 0, 0)
self.post_mortem_cb = QCheckBox(POST_MORTEM)
common_layout.addWidget(self.post_mortem_cb, 1, 0)
self.clo_cb = QCheckBox(_("Command line options:"))
common_layout.addWidget(self.clo_cb, 2, 0)
self.clo_edit = QLineEdit()
self.clo_cb.toggled.connect(self.clo_edit.setEnabled)
self.clo_edit.setEnabled(False)
common_layout.addWidget(self.clo_edit, 2, 1)
# --- Working directory ---
wdir_group = QGroupBox(_("Working Directory settings"))
wdir_layout = QVBoxLayout()
wdir_group.setLayout(wdir_layout)
self.file_dir_radio = QRadioButton(FILE_DIR)
wdir_layout.addWidget(self.file_dir_radio)
self.cwd_radio = QRadioButton(CW_DIR)
wdir_layout.addWidget(self.cwd_radio)
fixed_dir_layout = QHBoxLayout()
self.fixed_dir_radio = QRadioButton(FIXED_DIR)
fixed_dir_layout.addWidget(self.fixed_dir_radio)
self.wd_edit = QLineEdit()
self.fixed_dir_radio.toggled.connect(self.wd_edit.setEnabled)
self.wd_edit.setEnabled(False)
fixed_dir_layout.addWidget(self.wd_edit)
browse_btn = QPushButton(ima.icon('DirOpenIcon'), '', self)
browse_btn.setToolTip(_("Select directory"))
browse_btn.clicked.connect(self.select_directory)
fixed_dir_layout.addWidget(browse_btn)
wdir_layout.addLayout(fixed_dir_layout)
# --- System terminal ---
external_group = QGroupBox(_("External system terminal"))
external_group.setDisabled(True)
self.systerm_radio.toggled.connect(external_group.setEnabled)
external_layout = QGridLayout()
external_group.setLayout(external_layout)
self.interact_cb = QCheckBox(INTERACT)
external_layout.addWidget(self.interact_cb, 1, 0, 1, -1)
self.pclo_cb = QCheckBox(_("Command line options:"))
external_layout.addWidget(self.pclo_cb, 3, 0)
self.pclo_edit = QLineEdit()
self.pclo_cb.toggled.connect(self.pclo_edit.setEnabled)
self.pclo_edit.setEnabled(False)
self.pclo_edit.setToolTip(_("<b>-u</b> is added to the "
"other options you set here"))
external_layout.addWidget(self.pclo_edit, 3, 1)
# Checkbox to preserve the old behavior, i.e. always open the dialog
# on first run
hline = QFrame()
hline.setFrameShape(QFrame.HLine)
hline.setFrameShadow(QFrame.Sunken)
self.firstrun_cb = QCheckBox(ALWAYS_OPEN_FIRST_RUN % _("this dialog"))
self.firstrun_cb.clicked.connect(self.set_firstrun_o)
self.firstrun_cb.setChecked(firstrun_o)
layout = QVBoxLayout()
layout.addWidget(interpreter_group)
layout.addWidget(common_group)
layout.addWidget(wdir_group)
layout.addWidget(external_group)
layout.addWidget(hline)
layout.addWidget(self.firstrun_cb)
self.setLayout(layout)
def _get_acq_commom_params_grpbx(self):
grp_bx = QGroupBox('Common Parameters', self)
fbl = QFormLayout(grp_bx)
lbl = QLabel('Non-linear Corr.', grp_bx, alignment=Qt.AlignCenter)
wid = self.create_pair_butled(grp_bx, 'PolyCalibration')
fbl.addRow(lbl, wid)
self._set_detailed([lbl, wid])
lbl = QLabel('Channel Rate', grp_bx, alignment=Qt.AlignCenter)
wid = self.create_pair_sel(grp_bx, 'TrigAcqChan')
fbl.addRow(lbl, wid)
lbl = QLabel('Trigger Type', grp_bx, alignment=Qt.AlignCenter)
wid = self.create_pair_sel(grp_bx, 'TrigAcqTrigger')
fbl.addRow(lbl, wid)
self._set_detailed([lbl, wid])
lbl = QLabel('Repeat', grp_bx, alignment=Qt.AlignCenter)
wid = self.create_pair_butled(grp_bx, 'TrigAcqRepeat')
fbl.addRow(lbl, wid)
self._set_detailed([lbl, wid])
if self.isring:
lbl = QLabel('Nr of Shots', grp_bx, alignment=Qt.AlignCenter)
wid = self.create_pair(grp_bx, 'TrigNrShots')
fbl.addRow(lbl, wid)
self._set_detailed([lbl, wid])
lbl = QLabel('SamplesPre', grp_bx, alignment=Qt.AlignCenter)
wid = self.create_pair(grp_bx, 'TrigNrSamplesPre')
fbl.addRow(lbl, wid)
lbl = QLabel('SamplesPost', grp_bx, alignment=Qt.AlignCenter)
wid = self.create_pair(grp_bx, 'TrigNrSamplesPost')
fbl.addRow(lbl, wid)
lbl = QLabel('Acquisition:', grp_bx, alignment=Qt.AlignCenter)
strt = PyDMPushButton(
grp_bx,
label='',
init_channel=self.devpref.substitute(propty='TrigAcqCtrl-Sel'),
pressValue=self._csorb.TrigAcqCtrl.Start)
strt.setToolTip('Start Acquisition')
strt.setIcon(qta.icon('fa5s.play'))
strt.setObjectName('strt')
strt.setStyleSheet(
'#strt{min-width:25px; max-width:25px; icon-size:20px;}')
stop = PyDMPushButton(
grp_bx,
label='',
init_channel=self.devpref.substitute(propty='TrigAcqCtrl-Sel'),
pressValue=self._csorb.TrigAcqCtrl.Stop)
stop.setToolTip('Stop Acquisition')
stop.setIcon(qta.icon('fa5s.stop'))
stop.setObjectName('stop')
stop.setStyleSheet(
'#stop{min-width:25px; max-width:25px; icon-size:20px;}')
abrt = PyDMPushButton(
grp_bx,
label='',
init_channel=self.devpref.substitute(propty='TrigAcqCtrl-Sel'),
pressValue=self._csorb.TrigAcqCtrl.Abort)
abrt.setToolTip('Abort Acquisition')
abrt.setIcon(qta.icon('fa5s.ban'))
abrt.setObjectName('abrt')
abrt.setStyleSheet(
'#abrt{min-width:25px; max-width:25px; icon-size:20px;}')
pdmlbl = PyDMLabel(grp_bx,
self.devpref.substitute(propty='TrigAcqCtrl-Sts'))
pdmlbl.setObjectName('pdmlbl')
pdmlbl.setStyleSheet('#pdmlbl{min-width:6em; max-width:6em;}')
pdmlbl.setAlignment(Qt.AlignCenter)
hbl = QHBoxLayout()
fbl.addRow(hbl)
hbl.addStretch()
hbl.addWidget(lbl)
hbl.addWidget(strt)
hbl.addWidget(stop)
hbl.addWidget(abrt)
hbl.addWidget(pdmlbl)
conf = PyDMPushButton(
grp_bx,
pressValue=1,
init_channel=self.devpref.substitute(propty='TrigAcqConfig-Cmd'))
conf.setToolTip('Resend Configurations')
conf.setIcon(qta.icon('fa5s.sync'))
conf.setObjectName('conf')
conf.setStyleSheet(
'#conf{min-width:25px; max-width:25px; icon-size:20px;}')
sts = QPushButton('', grp_bx)
sts.setIcon(qta.icon('fa5s.list-ul'))
sts.setToolTip('Open Detailed Status View')
sts.setObjectName('sts')
sts.setStyleSheet(
'#sts{min-width:25px; max-width:25px; icon-size:20px;}')
Window = create_window_from_widget(StatusWidget, title='Orbit Status')
connect_window(sts,
Window,
grp_bx,
device=self.device,
prefix=self.prefix,
acc=self.acc,
is_orb=True)
pdm_led = SiriusLedAlert(
grp_bx, self.devpref.substitute(propty='OrbStatus-Mon'))
lbl = QLabel('Status:', grp_bx)
hbl = QHBoxLayout()
hbl.setSpacing(9)
hbl.addStretch()
hbl.addWidget(lbl)
hbl.addWidget(pdm_led)
hbl.addWidget(sts)
hbl.addWidget(conf)
fbl.addRow(hbl)
return grp_bx
def __init__(self, parent, text):
QWidget.__init__(self, parent)
self.text_editor = QTextEdit(self)
self.text_editor.setText(text)
self.text_editor.setReadOnly(True)
# Type frame
type_layout = QHBoxLayout()
type_label = QLabel(_("Import as"))
type_layout.addWidget(type_label)
data_btn = QRadioButton(_("data"))
data_btn.setChecked(True)
self._as_data = True
type_layout.addWidget(data_btn)
code_btn = QRadioButton(_("code"))
self._as_code = False
type_layout.addWidget(code_btn)
txt_btn = QRadioButton(_("text"))
type_layout.addWidget(txt_btn)
h_spacer = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
type_layout.addItem(h_spacer)
type_frame = QFrame()
type_frame.setLayout(type_layout)
# Opts frame
grid_layout = QGridLayout()
grid_layout.setSpacing(0)
col_label = QLabel(_("Column separator:"))
grid_layout.addWidget(col_label, 0, 0)
col_w = QWidget()
col_btn_layout = QHBoxLayout()
self.tab_btn = QRadioButton(_("Tab"))
self.tab_btn.setChecked(False)
col_btn_layout.addWidget(self.tab_btn)
other_btn_col = QRadioButton(_("other"))
other_btn_col.setChecked(True)
col_btn_layout.addWidget(other_btn_col)
col_w.setLayout(col_btn_layout)
grid_layout.addWidget(col_w, 0, 1)
self.line_edt = QLineEdit(",")
self.line_edt.setMaximumWidth(30)
self.line_edt.setEnabled(True)
other_btn_col.toggled.connect(self.line_edt.setEnabled)
grid_layout.addWidget(self.line_edt, 0, 2)
row_label = QLabel(_("Row separator:"))
grid_layout.addWidget(row_label, 1, 0)
row_w = QWidget()
row_btn_layout = QHBoxLayout()
self.eol_btn = QRadioButton(_("EOL"))
self.eol_btn.setChecked(True)
row_btn_layout.addWidget(self.eol_btn)
other_btn_row = QRadioButton(_("other"))
row_btn_layout.addWidget(other_btn_row)
row_w.setLayout(row_btn_layout)
grid_layout.addWidget(row_w, 1, 1)
self.line_edt_row = QLineEdit(";")
self.line_edt_row.setMaximumWidth(30)
self.line_edt_row.setEnabled(False)
other_btn_row.toggled.connect(self.line_edt_row.setEnabled)
grid_layout.addWidget(self.line_edt_row, 1, 2)
grid_layout.setRowMinimumHeight(2, 15)
other_group = QGroupBox(_("Additional options"))
other_layout = QGridLayout()
other_group.setLayout(other_layout)
skiprows_label = QLabel(_("Skip rows:"))
other_layout.addWidget(skiprows_label, 0, 0)
self.skiprows_edt = QLineEdit('0')
self.skiprows_edt.setMaximumWidth(30)
intvalid = QIntValidator(0, len(to_text_string(text).splitlines()),
self.skiprows_edt)
self.skiprows_edt.setValidator(intvalid)
other_layout.addWidget(self.skiprows_edt, 0, 1)
other_layout.setColumnMinimumWidth(2, 5)
comments_label = QLabel(_("Comments:"))
other_layout.addWidget(comments_label, 0, 3)
self.comments_edt = QLineEdit('#')
self.comments_edt.setMaximumWidth(30)
other_layout.addWidget(self.comments_edt, 0, 4)
self.trnsp_box = QCheckBox(_("Transpose"))
#self.trnsp_box.setEnabled(False)
other_layout.addWidget(self.trnsp_box, 1, 0, 2, 0)
grid_layout.addWidget(other_group, 3, 0, 2, 0)
opts_frame = QFrame()
opts_frame.setLayout(grid_layout)
data_btn.toggled.connect(opts_frame.setEnabled)
data_btn.toggled.connect(self.set_as_data)
code_btn.toggled.connect(self.set_as_code)
# self.connect(txt_btn, SIGNAL("toggled(bool)"),
# self, SLOT("is_text(bool)"))
# Final layout
layout = QVBoxLayout()
layout.addWidget(type_frame)
layout.addWidget(self.text_editor)
layout.addWidget(opts_frame)
self.setLayout(layout)
def setup_page(self):
self.ICON = ima.icon('eyedropper')
names = self.get_option("names")
try:
names.pop(names.index(u'Custom'))
except ValueError:
pass
custom_names = self.get_option("custom_names", [])
# Interface options
theme_group = QGroupBox(_("Main interface"))
# Interface Widgets
ui_themes = ['Automatic', 'Light', 'Dark']
ui_theme_choices = list(
zip(ui_themes, [ui_theme.lower() for ui_theme in ui_themes]))
ui_theme_combo = self.create_combobox(_('Interface theme'),
ui_theme_choices,
'ui_theme',
restart=True)
styles = [str(txt) for txt in list(QStyleFactory.keys())]
# Don't offer users the possibility to change to a different
# style in Gtk-based desktops
# Fixes Issue 2036
if is_gtk_desktop() and ('GTK+' in styles):
styles = ['GTK+']
choices = list(zip(styles, [style.lower() for style in styles]))
style_combo = self.create_combobox(_('Qt windows style'),
choices,
'windows_style',
default=self.main.default_style)
self.style_combobox = style_combo.combobox
themes = ['Spyder 2', 'Spyder 3']
icon_choices = list(zip(themes, [theme.lower() for theme in themes]))
icons_combo = self.create_combobox(_('Icon theme'),
icon_choices,
'icon_theme',
restart=True)
theme_comboboxes_layout = QGridLayout()
theme_comboboxes_layout.addWidget(ui_theme_combo.label, 0, 0)
theme_comboboxes_layout.addWidget(ui_theme_combo.combobox, 0, 1)
theme_comboboxes_layout.addWidget(style_combo.label, 1, 0)
theme_comboboxes_layout.addWidget(self.style_combobox, 1, 1)
theme_comboboxes_layout.addWidget(icons_combo.label, 2, 0)
theme_comboboxes_layout.addWidget(icons_combo.combobox, 2, 1)
theme_layout = QVBoxLayout()
theme_layout.addLayout(theme_comboboxes_layout)
theme_group.setLayout(theme_layout)
# Syntax coloring options
syntax_group = QGroupBox(_("Syntax highlighting theme"))
# Syntax Widgets
edit_button = QPushButton(_("Edit selected scheme"))
create_button = QPushButton(_("Create new scheme"))
self.delete_button = QPushButton(_("Delete scheme"))
self.reset_button = QPushButton(_("Reset to defaults"))
self.preview_editor = CodeEditor(self)
self.stacked_widget = QStackedWidget(self)
self.scheme_editor_dialog = SchemeEditor(parent=self,
stack=self.stacked_widget)
self.scheme_choices_dict = {}
schemes_combobox_widget = self.create_combobox('', [('', '')],
'selected')
self.schemes_combobox = schemes_combobox_widget.combobox
# Syntax layout
syntax_layout = QGridLayout(syntax_group)
btns = [
self.schemes_combobox, edit_button, self.reset_button,
create_button, self.delete_button
]
for i, btn in enumerate(btns):
syntax_layout.addWidget(btn, i, 1)
syntax_layout.setColumnStretch(0, 1)
syntax_layout.setColumnStretch(1, 2)
syntax_layout.setColumnStretch(2, 1)
syntax_layout.setContentsMargins(0, 12, 0, 12)
# Fonts options
fonts_group = QGroupBox(_("Fonts"))
# Fonts widgets
plain_text_font = self.create_fontgroup(
option='font',
title=_("Plain text"),
fontfilters=QFontComboBox.MonospacedFonts,
without_group=True)
rich_text_font = self.create_fontgroup(option='rich_font',
title=_("Rich text"),
without_group=True)
# Fonts layouts
fonts_layout = QGridLayout(fonts_group)
fonts_layout.addWidget(plain_text_font.fontlabel, 0, 0)
fonts_layout.addWidget(plain_text_font.fontbox, 0, 1)
fonts_layout.addWidget(plain_text_font.sizelabel, 0, 2)
fonts_layout.addWidget(plain_text_font.sizebox, 0, 3)
fonts_layout.addWidget(rich_text_font.fontlabel, 1, 0)
fonts_layout.addWidget(rich_text_font.fontbox, 1, 1)
fonts_layout.addWidget(rich_text_font.sizelabel, 1, 2)
fonts_layout.addWidget(rich_text_font.sizebox, 1, 3)
fonts_layout.setRowStretch(fonts_layout.rowCount(), 1)
# Left options layout
options_layout = QVBoxLayout()
options_layout.addWidget(theme_group)
options_layout.addWidget(syntax_group)
options_layout.addWidget(fonts_group)
# Right preview layout
preview_group = QGroupBox(_("Preview"))
preview_layout = QVBoxLayout()
preview_layout.addWidget(self.preview_editor)
preview_group.setLayout(preview_layout)
# Combined layout
combined_layout = QGridLayout()
combined_layout.setRowStretch(0, 1)
combined_layout.setColumnStretch(1, 100)
combined_layout.addLayout(options_layout, 0, 0)
combined_layout.addWidget(preview_group, 0, 1)
self.setLayout(combined_layout)
# Signals and slots
create_button.clicked.connect(self.create_new_scheme)
edit_button.clicked.connect(self.edit_scheme)
self.reset_button.clicked.connect(self.reset_to_default)
self.delete_button.clicked.connect(self.delete_scheme)
self.schemes_combobox.currentIndexChanged.connect(self.update_preview)
self.schemes_combobox.currentIndexChanged.connect(self.update_buttons)
# Setup
for name in names:
self.scheme_editor_dialog.add_color_scheme_stack(name)
for name in custom_names:
self.scheme_editor_dialog.add_color_scheme_stack(name, custom=True)
self.update_combobox()
self.update_preview()
self.update_qt_style_combobox()
def setup_page(self):
self.ICON = ima.icon('genprefs')
newcb = self.create_checkbox
# --- Interface
general_group = QGroupBox(_("General"))
languages = LANGUAGE_CODES.items()
language_choices = sorted([(val, key) for key, val in languages])
language_combo = self.create_combobox(_('Language:'),
language_choices,
'interface_language',
restart=True)
opengl_options = ['Automatic', 'Desktop', 'Software', 'GLES']
opengl_choices = list(zip(opengl_options,
[c.lower() for c in opengl_options]))
opengl_combo = self.create_combobox(_('Rendering engine:'),
opengl_choices,
'opengl',
restart=True)
single_instance_box = newcb(_("Use a single instance"),
'single_instance',
tip=_("Set this to open external<br> "
"Python files in an already running "
"instance (Requires a restart)"))
prompt_box = newcb(_("Prompt when exiting"), 'prompt_on_exit')
popup_console_box = newcb(_("Show internal Spyder errors to report "
"them to Github"), 'show_internal_errors')
check_updates = newcb(_("Check for updates on startup"),
'check_updates_on_startup')
# Decide if it's possible to activate or not single instance mode
if running_in_mac_app():
self.set_option("single_instance", True)
single_instance_box.setEnabled(False)
comboboxes_advanced_layout = QHBoxLayout()
cbs_adv_grid = QGridLayout()
cbs_adv_grid.addWidget(language_combo.label, 0, 0)
cbs_adv_grid.addWidget(language_combo.combobox, 0, 1)
cbs_adv_grid.addWidget(opengl_combo.label, 1, 0)
cbs_adv_grid.addWidget(opengl_combo.combobox, 1, 1)
comboboxes_advanced_layout.addLayout(cbs_adv_grid)
comboboxes_advanced_layout.addStretch(1)
general_layout = QVBoxLayout()
general_layout.addLayout(comboboxes_advanced_layout)
general_layout.addWidget(single_instance_box)
general_layout.addWidget(prompt_box)
general_layout.addWidget(popup_console_box)
general_layout.addWidget(check_updates)
general_group.setLayout(general_layout)
# --- Theme
interface_group = QGroupBox(_("Interface"))
vertdock_box = newcb(_("Vertical title bars in panes"),
'vertical_dockwidget_titlebars')
verttabs_box = newcb(_("Vertical tabs in panes"),
'vertical_tabs')
animated_box = newcb(_("Animated toolbars and panes"),
'animated_docks')
tear_off_box = newcb(_("Tear off menus"), 'tear_off_menus',
tip=_("Set this to detach any<br> "
"menu from the main window"))
margin_box = newcb(_("Custom margin for panes:"),
'use_custom_margin')
margin_spin = self.create_spinbox("", _("pixels"), 'custom_margin',
0, 0, 30)
margin_box.toggled.connect(margin_spin.spinbox.setEnabled)
margin_box.toggled.connect(margin_spin.slabel.setEnabled)
margin_spin.spinbox.setEnabled(self.get_option('use_custom_margin'))
margin_spin.slabel.setEnabled(self.get_option('use_custom_margin'))
cursor_box = newcb(_("Cursor blinking:"),
'use_custom_cursor_blinking')
cursor_spin = self.create_spinbox(
"", _("ms"),
'custom_cursor_blinking',
default=QApplication.cursorFlashTime(),
min_=0, max_=5000, step=100)
cursor_box.toggled.connect(cursor_spin.spinbox.setEnabled)
cursor_box.toggled.connect(cursor_spin.slabel.setEnabled)
cursor_spin.spinbox.setEnabled(
self.get_option('use_custom_cursor_blinking'))
cursor_spin.slabel.setEnabled(
self.get_option('use_custom_cursor_blinking'))
margins_cursor_layout = QGridLayout()
margins_cursor_layout.addWidget(margin_box, 0, 0)
margins_cursor_layout.addWidget(margin_spin.spinbox, 0, 1)
margins_cursor_layout.addWidget(margin_spin.slabel, 0, 2)
margins_cursor_layout.addWidget(cursor_box, 1, 0)
margins_cursor_layout.addWidget(cursor_spin.spinbox, 1, 1)
margins_cursor_layout.addWidget(cursor_spin.slabel, 1, 2)
margins_cursor_layout.setColumnStretch(2, 100)
# Layout interface
interface_layout = QVBoxLayout()
interface_layout.addWidget(vertdock_box)
interface_layout.addWidget(verttabs_box)
interface_layout.addWidget(animated_box)
interface_layout.addWidget(tear_off_box)
interface_layout.addLayout(margins_cursor_layout)
interface_group.setLayout(interface_layout)
# --- Status bar
sbar_group = QGroupBox(_("Status bar"))
show_status_bar = newcb(_("Show status bar"), 'show_status_bar')
memory_box = newcb(_("Show memory usage every"), 'memory_usage/enable',
tip=self.main.mem_status.toolTip())
memory_spin = self.create_spinbox("", _(" ms"), 'memory_usage/timeout',
min_=100, max_=1000000, step=100)
memory_box.toggled.connect(memory_spin.setEnabled)
memory_spin.setEnabled(self.get_option('memory_usage/enable'))
memory_box.setEnabled(self.main.mem_status.is_supported())
memory_spin.setEnabled(self.main.mem_status.is_supported())
cpu_box = newcb(_("Show CPU usage every"), 'cpu_usage/enable',
tip=self.main.cpu_status.toolTip())
cpu_spin = self.create_spinbox("", _(" ms"), 'cpu_usage/timeout',
min_=100, max_=1000000, step=100)
cpu_box.toggled.connect(cpu_spin.setEnabled)
cpu_spin.setEnabled(self.get_option('cpu_usage/enable'))
cpu_box.setEnabled(self.main.cpu_status.is_supported())
cpu_spin.setEnabled(self.main.cpu_status.is_supported())
status_bar_o = self.get_option('show_status_bar')
show_status_bar.toggled.connect(memory_box.setEnabled)
show_status_bar.toggled.connect(memory_spin.setEnabled)
show_status_bar.toggled.connect(cpu_box.setEnabled)
show_status_bar.toggled.connect(cpu_spin.setEnabled)
memory_box.setEnabled(status_bar_o)
memory_spin.setEnabled(status_bar_o)
cpu_box.setEnabled(status_bar_o)
cpu_spin.setEnabled(status_bar_o)
# Layout status bar
cpu_memory_layout = QGridLayout()
cpu_memory_layout.addWidget(memory_box, 0, 0)
cpu_memory_layout.addWidget(memory_spin, 0, 1)
cpu_memory_layout.addWidget(cpu_box, 1, 0)
cpu_memory_layout.addWidget(cpu_spin, 1, 1)
sbar_layout = QVBoxLayout()
sbar_layout.addWidget(show_status_bar)
sbar_layout.addLayout(cpu_memory_layout)
sbar_group.setLayout(sbar_layout)
# --- Screen resolution Group (hidpi)
screen_resolution_group = QGroupBox(_("Screen resolution"))
screen_resolution_bg = QButtonGroup(screen_resolution_group)
screen_resolution_label = QLabel(_("Configuration for high DPI "
"screens<br><br>"
"Please see "
"<a href=\"{0}\">{0}</a><> "
"for more information about "
"these options (in "
"English).").format(HDPI_QT_PAGE))
screen_resolution_label.setWordWrap(True)
normal_radio = self.create_radiobutton(
_("Normal"),
'normal_screen_resolution',
button_group=screen_resolution_bg)
auto_scale_radio = self.create_radiobutton(
_("Enable auto high DPI scaling"),
'high_dpi_scaling',
button_group=screen_resolution_bg,
tip=_("Set this for high DPI displays"),
restart=True)
custom_scaling_radio = self.create_radiobutton(
_("Set a custom high DPI scaling"),
'high_dpi_custom_scale_factor',
button_group=screen_resolution_bg,
tip=_("Set this for high DPI displays when "
"auto scaling does not work"),
restart=True)
custom_scaling_edit = self.create_lineedit(
"",
'high_dpi_custom_scale_factors',
tip=_("Enter values for different screens "
"separated by semicolons ';', "
"float values are supported"),
alignment=Qt.Horizontal,
regex=r"[0-9]+(?:\.[0-9]*)(;[0-9]+(?:\.[0-9]*))*",
restart=True)
normal_radio.toggled.connect(custom_scaling_edit.setDisabled)
auto_scale_radio.toggled.connect(custom_scaling_edit.setDisabled)
custom_scaling_radio.toggled.connect(custom_scaling_edit.setEnabled)
# Layout Screen resolution
screen_resolution_layout = QVBoxLayout()
screen_resolution_layout.addWidget(screen_resolution_label)
screen_resolution_inner_layout = QGridLayout()
screen_resolution_inner_layout.addWidget(normal_radio, 0, 0)
screen_resolution_inner_layout.addWidget(auto_scale_radio, 1, 0)
screen_resolution_inner_layout.addWidget(custom_scaling_radio, 2, 0)
screen_resolution_inner_layout.addWidget(custom_scaling_edit, 2, 1)
screen_resolution_layout.addLayout(screen_resolution_inner_layout)
screen_resolution_group.setLayout(screen_resolution_layout)
tabs = QTabWidget()
tabs.addTab(self.create_tab(screen_resolution_group, interface_group),
_("Interface"))
tabs.addTab(self.create_tab(general_group, sbar_group),
_("Advanced Settings"))
vlayout = QVBoxLayout()
vlayout.addWidget(tabs)
self.setLayout(vlayout)
class KernelConnectionDialog(QDialog):
"""Dialog to connect to existing kernels (either local or remote)."""
def __init__(self, parent=None):
super(KernelConnectionDialog, self).__init__(parent)
self.setWindowTitle(_('Connect to an existing kernel'))
main_label = QLabel(_(
"<p>Please select the JSON connection file (<i>e.g.</i> "
"<tt>kernel-1234.json</tt>) of the existing kernel, and enter "
"the SSH information if connecting to a remote machine. "
"To learn more about starting external kernels and connecting "
"to them, see <a href=\"https://docs.spyder-ide.org/"
"ipythonconsole.html#connect-to-an-external-kernel\">"
"our documentation</a>.</p>"))
main_label.setWordWrap(True)
main_label.setAlignment(Qt.AlignJustify)
main_label.setOpenExternalLinks(True)
# Connection file
cf_label = QLabel(_('Connection file:'))
self.cf = QLineEdit()
self.cf.setPlaceholderText(_('Kernel connection file path'))
self.cf.setMinimumWidth(350)
cf_open_btn = QPushButton(_('Browse'))
cf_open_btn.clicked.connect(self.select_connection_file)
cf_layout = QHBoxLayout()
cf_layout.addWidget(cf_label)
cf_layout.addWidget(self.cf)
cf_layout.addWidget(cf_open_btn)
# Remote kernel groupbox
self.rm_group = QGroupBox(_("This is a remote kernel (via SSH)"))
# SSH connection
hn_label = QLabel(_('Hostname:'))
self.hn = QLineEdit()
pn_label = QLabel(_('Port:'))
self.pn = QLineEdit()
self.pn.setMaximumWidth(75)
self.pn.setText('22')
un_label = QLabel(_('Username:'******'Password:'******'SSH keyfile:'))
self.pw = QLineEdit()
self.pw.setEchoMode(QLineEdit.Password)
self.pw_radio.toggled.connect(self.pw.setEnabled)
self.kf_radio.toggled.connect(self.pw.setDisabled)
self.kf = QLineEdit()
kf_open_btn = QPushButton(_('Browse'))
kf_open_btn.clicked.connect(self.select_ssh_key)
kf_layout = QHBoxLayout()
kf_layout.addWidget(self.kf)
kf_layout.addWidget(kf_open_btn)
kfp_label = QLabel(_('Passphase:'))
self.kfp = QLineEdit()
self.kfp.setPlaceholderText(_('Optional'))
self.kfp.setEchoMode(QLineEdit.Password)
self.kf_radio.toggled.connect(self.kf.setEnabled)
self.kf_radio.toggled.connect(self.kfp.setEnabled)
self.kf_radio.toggled.connect(kf_open_btn.setEnabled)
self.kf_radio.toggled.connect(kfp_label.setEnabled)
self.pw_radio.toggled.connect(self.kf.setDisabled)
self.pw_radio.toggled.connect(self.kfp.setDisabled)
self.pw_radio.toggled.connect(kf_open_btn.setDisabled)
self.pw_radio.toggled.connect(kfp_label.setDisabled)
# SSH layout
ssh_layout = QGridLayout()
ssh_layout.addWidget(hn_label, 0, 0, 1, 2)
ssh_layout.addWidget(self.hn, 0, 2)
ssh_layout.addWidget(pn_label, 0, 3)
ssh_layout.addWidget(self.pn, 0, 4)
ssh_layout.addWidget(un_label, 1, 0, 1, 2)
ssh_layout.addWidget(self.un, 1, 2, 1, 3)
# SSH authentication layout
auth_layout = QGridLayout()
auth_layout.addWidget(self.pw_radio, 1, 0)
auth_layout.addWidget(pw_label, 1, 1)
auth_layout.addWidget(self.pw, 1, 2)
auth_layout.addWidget(self.kf_radio, 2, 0)
auth_layout.addWidget(kf_label, 2, 1)
auth_layout.addLayout(kf_layout, 2, 2)
auth_layout.addWidget(kfp_label, 3, 1)
auth_layout.addWidget(self.kfp, 3, 2)
auth_group.setLayout(auth_layout)
# Remote kernel layout
rm_layout = QVBoxLayout()
rm_layout.addLayout(ssh_layout)
rm_layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 8)))
rm_layout.addWidget(auth_group)
self.rm_group.setLayout(rm_layout)
self.rm_group.setCheckable(True)
self.rm_group.setChecked(False)
self.rm_group.toggled.connect(self.pw_radio.setChecked)
# Ok and Cancel buttons
self.accept_btns = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel,
Qt.Horizontal, self)
self.accept_btns.accepted.connect(self.accept)
self.accept_btns.rejected.connect(self.reject)
# Dialog layout
layout = QVBoxLayout(self)
layout.addWidget(main_label)
layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 8)))
layout.addLayout(cf_layout)
layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 12)))
layout.addWidget(self.rm_group)
layout.addWidget(self.accept_btns)
def select_connection_file(self):
cf = getopenfilename(self, _('Select kernel connection file'),
jupyter_runtime_dir(), '*.json;;*.*')[0]
self.cf.setText(cf)
def select_ssh_key(self):
kf = getopenfilename(self, _('Select SSH keyfile'),
get_home_dir(), '*.pem;;*')[0]
self.kf.setText(kf)
@staticmethod
def get_connection_parameters(parent=None, dialog=None):
if not dialog:
dialog = KernelConnectionDialog(parent)
result = dialog.exec_()
is_remote = bool(dialog.rm_group.isChecked())
accepted = result == QDialog.Accepted
if is_remote:
def falsy_to_none(arg):
return arg if arg else None
if dialog.hn.text() and dialog.un.text():
port = dialog.pn.text() if dialog.pn.text() else '22'
hostname = "{0}@{1}:{2}".format(dialog.un.text(),
dialog.hn.text(),
port)
else:
hostname = None
if dialog.pw_radio.isChecked():
password = falsy_to_none(dialog.pw.text())
keyfile = None
elif dialog.kf_radio.isChecked():
keyfile = falsy_to_none(dialog.kf.text())
password = falsy_to_none(dialog.kfp.text())
else: # imposible?
keyfile = None
password = None
return (dialog.cf.text(), hostname, keyfile, password, accepted)
else:
path = dialog.cf.text()
_dir, filename = osp.dirname(path), osp.basename(path)
if _dir == '' and not filename.endswith('.json'):
path = osp.join(jupyter_runtime_dir(), 'kernel-'+path+'.json')
return (path, None, None, None, accepted)
def __init__(self, settings, plotWidget, parent=None):
super().__init__(parent)
self.mainwindow = parent
self.plotWidget = plotWidget
# xmin
self.xminLabel = QLabel(self.tr('xmin:'))
self.xminSpinBox = CoordSpinBox()
self.xminLabel.setBuddy(self.xminSpinBox)
self.xminSpinBox.editingFinished.connect(self.change_limits)
# xmax
self.xmaxLabel = QLabel(self.tr('xmax:'))
self.xmaxSpinBox = CoordSpinBox()
self.xmaxLabel.setBuddy(self.xmaxSpinBox)
self.xmaxSpinBox.editingFinished.connect(self.change_limits)
# ymin
self.yminLabel = QLabel(self.tr('ymin:'))
self.yminSpinBox = CoordSpinBox()
self.yminLabel.setBuddy(self.yminSpinBox)
self.yminSpinBox.editingFinished.connect(self.change_limits)
# ymax
self.ymaxLabel = QLabel(self.tr('ymax:'))
self.ymaxSpinBox = CoordSpinBox()
self.ymaxLabel.setBuddy(self.ymaxSpinBox)
self.ymaxSpinBox.editingFinished.connect(self.change_limits)
# Autoscale Radio Group
self.autoscaleButtonGroup = QButtonGroup()
# Autoscale Group Box
self.autoscaleGroupBox = QGroupBox()
# autoscale
self.autoscaleRadioButton = QRadioButton(self.tr("autoscale"))
self.autoscaleButtonGroup.addButton(self.autoscaleRadioButton)
# autotrack
self.autoscrollRadioButton = QRadioButton(self.tr("autoscroll"))
self.autoscaleButtonGroup.addButton(self.autoscrollRadioButton)
# no autoscale
self.manualscaleRadioButton = QRadioButton(self.tr("manual"))
self.autoscaleButtonGroup.addButton(self.manualscaleRadioButton)
layout = QVBoxLayout()
layout.addWidget(self.autoscaleRadioButton)
layout.addWidget(self.autoscrollRadioButton)
layout.addWidget(self.manualscaleRadioButton)
self.autoscaleGroupBox.setLayout(layout)
# Layout
layout = QGridLayout()
layout.addWidget(self.xminLabel, 1, 0)
layout.addWidget(self.xminSpinBox, 1, 1)
layout.addWidget(self.xmaxLabel, 2, 0)
layout.addWidget(self.xmaxSpinBox, 2, 1)
layout.addWidget(self.yminLabel, 3, 0)
layout.addWidget(self.yminSpinBox, 3, 1)
layout.addWidget(self.ymaxLabel, 4, 0)
layout.addWidget(self.ymaxSpinBox, 4, 1)
layout.addWidget(self.autoscaleGroupBox, 5, 0, 1, 2)
layout.setRowStretch(6, 1)
self.setLayout(layout)
# settings
self.settings = settings
self.settings.add_handler(S_XMIN, self.xminSpinBox)
self.settings.add_handler(S_XMAX, self.xmaxSpinBox)
self.settings.add_handler(S_YMIN, self.yminSpinBox)
self.settings.add_handler(S_YMAX, self.ymaxSpinBox)
self.settings.add_handler(S_AUTOSCALE, self.autoscaleButtonGroup)
def __init__(self, parent):
super().__init__(parent)
lsp_advanced_group = QGroupBox(
_('Python Language Server configuration'))
advanced_label = QLabel(
_("<b>Warning</b>: Only modify these values if "
"you know what you're doing!"))
advanced_label.setWordWrap(True)
advanced_label.setAlignment(Qt.AlignJustify)
# Advanced settings checkbox
self.advanced_options_check = self.create_checkbox(
_("Enable advanced settings"), 'advanced/enabled')
# Advanced options
self.advanced_module = self.create_lineedit(
_("Module for the Python language server: "),
'advanced/module',
alignment=Qt.Horizontal,
word_wrap=False)
self.advanced_host = self.create_lineedit(
_("IP Address and port to bind the server to: "),
'advanced/host',
alignment=Qt.Horizontal,
word_wrap=False)
self.advanced_port = self.create_spinbox(":",
"",
'advanced/port',
min_=1,
max_=65535,
step=1)
self.external_server = self.create_checkbox(
_("This is an external server"), 'advanced/external')
self.use_stdio = self.create_checkbox(
_("Use stdio pipes to communicate with server"), 'advanced/stdio')
self.use_stdio.stateChanged.connect(self.disable_tcp)
self.external_server.stateChanged.connect(self.disable_stdio)
# Advanced layout
advanced_g_layout = QGridLayout()
advanced_g_layout.addWidget(self.advanced_module.label, 1, 0)
advanced_g_layout.addWidget(self.advanced_module.textbox, 1, 1)
advanced_g_layout.addWidget(self.advanced_host.label, 2, 0)
advanced_host_port_g_layout = QGridLayout()
advanced_host_port_g_layout.addWidget(self.advanced_host.textbox, 1, 0)
advanced_host_port_g_layout.addWidget(self.advanced_port.plabel, 1, 1)
advanced_host_port_g_layout.addWidget(self.advanced_port.spinbox, 1, 2)
advanced_g_layout.addLayout(advanced_host_port_g_layout, 2, 1)
# External server and stdio options layout
advanced_server_layout = QVBoxLayout()
advanced_server_layout.addWidget(self.external_server)
advanced_server_layout.addWidget(self.use_stdio)
advanced_options_layout = QVBoxLayout()
advanced_options_layout.addLayout(advanced_g_layout)
advanced_options_layout.addLayout(advanced_server_layout)
# Set advanced options enabled/disabled
advanced_options_widget = QWidget()
advanced_options_widget.setLayout(advanced_options_layout)
advanced_options_widget.setEnabled(self.get_option('advanced/enabled'))
self.advanced_options_check.toggled.connect(
advanced_options_widget.setEnabled)
self.advanced_options_check.toggled.connect(self.show_advanced_warning)
# Advanced options layout
advanced_layout = QVBoxLayout()
advanced_layout.addWidget(advanced_label)
advanced_layout.addWidget(self.advanced_options_check)
advanced_layout.addWidget(advanced_options_widget)
lsp_advanced_group.setLayout(advanced_layout)
layout = QVBoxLayout()
layout.addWidget(lsp_advanced_group)
self.setLayout(layout)
def setup_page(self):
about_label = QLabel(_("The <b>global working directory</b> is "
"the working directory for newly opened <i>consoles</i> "
"(Python/IPython consoles and terminals), for the "
"<i>file explorer</i>, for the <i>find in files</i> "
"plugin and for new files created in the <i>editor</i>."))
about_label.setWordWrap(True)
startup_group = QGroupBox(_("Startup"))
startup_bg = QButtonGroup(startup_group)
startup_label = QLabel(_("At startup, the global working "
"directory is:"))
startup_label.setWordWrap(True)
lastdir_radio = self.create_radiobutton(
_("the same as in last session"),
'startup/use_last_directory', True,
_("At startup, Spyder will restore the "
"global directory from last session"),
button_group=startup_bg)
thisdir_radio = self.create_radiobutton(
_("the following directory:"),
'startup/use_fixed_directory', False,
_("At startup, the global working "
"directory will be the specified path"),
button_group=startup_bg)
thisdir_bd = self.create_browsedir("", 'startup/fixed_directory',
getcwd())
thisdir_radio.toggled.connect(thisdir_bd.setEnabled)
lastdir_radio.toggled.connect(thisdir_bd.setDisabled)
thisdir_layout = QHBoxLayout()
thisdir_layout.addWidget(thisdir_radio)
thisdir_layout.addWidget(thisdir_bd)
editor_o_group = QGroupBox(_("Open file"))
editor_o_label = QLabel(_("Files are opened from:"))
editor_o_label.setWordWrap(True)
editor_o_bg = QButtonGroup(editor_o_group)
editor_o_radio1 = self.create_radiobutton(
_("the current file directory"),
'editor/open/browse_scriptdir',
button_group=editor_o_bg)
editor_o_radio2 = self.create_radiobutton(
_("the global working directory"),
'editor/open/browse_workdir',
button_group=editor_o_bg)
editor_n_group = QGroupBox(_("New file"))
editor_n_label = QLabel(_("Files are created in:"))
editor_n_label.setWordWrap(True)
editor_n_bg = QButtonGroup(editor_n_group)
editor_n_radio1 = self.create_radiobutton(
_("the current file directory"),
'editor/new/browse_scriptdir',
button_group=editor_n_bg)
editor_n_radio2 = self.create_radiobutton(
_("the global working directory"),
'editor/new/browse_workdir',
button_group=editor_n_bg)
# Note: default values for the options above are set in plugin's
# constructor (see below)
other_group = QGroupBox(_("Change to file base directory"))
newcb = self.create_checkbox
open_box = newcb(_("When opening a file"),
'editor/open/auto_set_to_basedir')
save_box = newcb(_("When saving a file"),
'editor/save/auto_set_to_basedir')
startup_layout = QVBoxLayout()
startup_layout.addWidget(startup_label)
startup_layout.addWidget(lastdir_radio)
startup_layout.addLayout(thisdir_layout)
startup_group.setLayout(startup_layout)
editor_o_layout = QVBoxLayout()
editor_o_layout.addWidget(editor_o_label)
editor_o_layout.addWidget(editor_o_radio1)
editor_o_layout.addWidget(editor_o_radio2)
editor_o_group.setLayout(editor_o_layout)
editor_n_layout = QVBoxLayout()
editor_n_layout.addWidget(editor_n_label)
editor_n_layout.addWidget(editor_n_radio1)
editor_n_layout.addWidget(editor_n_radio2)
editor_n_group.setLayout(editor_n_layout)
other_layout = QVBoxLayout()
other_layout.addWidget(open_box)
other_layout.addWidget(save_box)
other_group.setLayout(other_layout)
vlayout = QVBoxLayout()
vlayout.addWidget(about_label)
vlayout.addSpacing(10)
vlayout.addWidget(startup_group)
vlayout.addWidget(editor_o_group)
vlayout.addWidget(editor_n_group)
vlayout.addWidget(other_group)
vlayout.addStretch(1)
self.setLayout(vlayout)
def __init__(self, settings: QSettings, parent: Optional[QObject] = None):
# noinspection PyArgumentList
super(NappingDialog, self).__init__(parent)
checked_selection_mode = NappingDialog.SelectionMode(
int(
settings.value(
self.SELECTION_MODE_SETTING,
defaultValue=self.DEFAULT_SELECTION_MODE.value)))
self._file_selection_mode_button = QRadioButton(
'Single file pair', self)
self._file_selection_mode_button.setChecked(
checked_selection_mode == NappingDialog.SelectionMode.FILE)
self._dir_selection_mode_button = QRadioButton(
'Directories (multiple file pairs)', self)
self._dir_selection_mode_button.setChecked(
checked_selection_mode == NappingDialog.SelectionMode.DIR)
self._selection_mode_buttons_group = QButtonGroup(self)
self._selection_mode_buttons_group.addButton(
self._file_selection_mode_button, NappingDialog.SelectionMode.FILE)
self._selection_mode_buttons_group.addButton(
self._dir_selection_mode_button, NappingDialog.SelectionMode.DIR)
# noinspection PyUnresolvedReferences
self._selection_mode_buttons_group.buttonClicked.connect(
lambda _: self.refresh())
matching_strategy_combo_box_current_text = str(
settings.value(self.MATCHING_STRATEGY_SETTING,
defaultValue=self.DEFAULT_MATCHING_STRATEGY.value))
self._matching_strategy_combo_box = QComboBox(self)
self._matching_strategy_combo_box.addItems(
[x.value for x in NappingDialog.MatchingStrategy])
self._matching_strategy_combo_box.setCurrentText(
matching_strategy_combo_box_current_text)
# noinspection PyUnresolvedReferences
self._matching_strategy_combo_box.currentIndexChanged.connect(
lambda _: self.refresh())
source_images_file_line_edit_text = str(
settings.value(self.SOURCE_IMAGES_SETTING,
defaultValue=self.DEFAULT_SOURCE_IMAGES))
self._source_images_file_line_edit = FileLineEdit(check_exists=True,
parent=self)
self._source_images_file_line_edit.file_dialog.setWindowTitle(
'Select source image(s)')
self._source_images_file_line_edit.setText(
source_images_file_line_edit_text)
# noinspection PyUnresolvedReferences
self._source_images_file_line_edit.textChanged.connect(
lambda text: self.refresh(text))
source_regex_line_edit_text = str(
settings.value(self.SOURCE_REGEX_SETTING,
defaultValue=self.DEFAULT_SOURCE_REGEX))
self._source_regex_label = QLabel(' RegEx:')
self._source_regex_line_edit = QLineEdit(self)
self._source_regex_line_edit.setText(source_regex_line_edit_text)
# noinspection PyUnresolvedReferences
self._source_regex_line_edit.textChanged.connect(
lambda _: self.refresh())
target_images_file_line_edit_text = str(
settings.value(self.TARGET_IMAGES_SETTING,
defaultValue=self.DEFAULT_TARGET_IMAGES))
self._target_images_file_line_edit = FileLineEdit(check_exists=True,
parent=self)
self._target_images_file_line_edit.file_dialog.setWindowTitle(
'Select target image(s)')
self._target_images_file_line_edit.setText(
target_images_file_line_edit_text)
# noinspection PyUnresolvedReferences
self._target_images_file_line_edit.textChanged.connect(
lambda text: self.refresh(text))
target_regex_line_edit_text = str(
settings.value(self.TARGET_REGEX_SETTING,
defaultValue=self.DEFAULT_TARGET_REGEX))
self._target_regex_label = QLabel(' RegEx:')
self._target_regex_line_edit = QLineEdit(self)
self._target_regex_line_edit.setText(target_regex_line_edit_text)
# noinspection PyUnresolvedReferences
self._target_regex_line_edit.textChanged.connect(
lambda _: self.refresh())
control_points_dest_file_line_edit_text = str(
settings.value(self.CONTROL_POINTS_DEST_SETTING,
defaultValue=self.DEFAULT_CONTROL_POINTS_DEST))
self._control_points_dest_file_line_edit = FileLineEdit(parent=self)
self._control_points_dest_file_line_edit.file_dialog.setWindowTitle(
'Select control points destination')
self._control_points_dest_file_line_edit.setText(
control_points_dest_file_line_edit_text)
# noinspection PyUnresolvedReferences
self._control_points_dest_file_line_edit.textChanged.connect(
lambda text: self.refresh(text))
joint_transform_dest_file_line_edit_text = str(
settings.value(self.JOINT_TRANSFORM_DEST_SETTING,
defaultValue=self.DEFAULT_JOINT_TRANSFORM_DEST))
self._joint_transform_dest_file_line_edit = FileLineEdit(parent=self)
self._joint_transform_dest_file_line_edit.file_dialog.setWindowTitle(
'Select joint transform destination')
self._joint_transform_dest_file_line_edit.setText(
joint_transform_dest_file_line_edit_text)
# noinspection PyUnresolvedReferences
self._joint_transform_dest_file_line_edit.textChanged.connect(
lambda text: self.refresh(text))
transform_type_combo_box_current_text = str(
settings.value(self.TRANSFORM_TYPE_SETTING,
defaultValue=self.DEFAULT_TRANSFORM_TYPE))
self._transform_type_combo_box = QComboBox(self)
self._transform_type_combo_box.addItems(
[x.value for x in NappingDialog.TransformType])
self._transform_type_combo_box.setCurrentText(
transform_type_combo_box_current_text)
# noinspection PyUnresolvedReferences
self._transform_type_combo_box.currentIndexChanged.connect(
lambda _: self.refresh())
source_coords_file_line_edit_text = str(
settings.value(self.SOURCE_COORDS_SETTING,
defaultValue=self.DEFAULT_SOURCE_COORDS))
self._source_coords_file_line_edit = FileLineEdit(check_exists=True,
parent=self)
self._source_coords_file_line_edit.file_dialog.setWindowTitle(
'Select source coordinates')
self._source_coords_file_line_edit.setText(
source_coords_file_line_edit_text)
# noinspection PyUnresolvedReferences
self._source_coords_file_line_edit.textChanged.connect(
lambda text: self.refresh(text))
source_coords_regex_line_edit_text = str(
settings.value(self.SOURCE_COORDS_REGEX_SETTING,
defaultValue=self.DEFAULT_SOURCE_COORDS_REGEX))
self._source_coords_regex_label = QLabel(' RegEx:')
self._source_coords_regex_line_edit = QLineEdit(self)
self._source_coords_regex_line_edit.setText(
source_coords_regex_line_edit_text)
# noinspection PyUnresolvedReferences
self._source_coords_regex_line_edit.textChanged.connect(
lambda _: self.refresh())
transformed_coords_dest_file_line_edit_text = str(
settings.value(self.TRANSFORMED_COORDS_DEST_SETTING,
defaultValue=self.DEFAULT_TRANSFORMED_COORDS_DEST))
self._transformed_coords_dest_file_line_edit = FileLineEdit(
parent=self)
self._transformed_coords_dest_file_line_edit.file_dialog.setWindowTitle(
'Select transformed coordinates destination')
self._transformed_coords_dest_file_line_edit.setText(
transformed_coords_dest_file_line_edit_text)
# noinspection PyUnresolvedReferences
self._transformed_coords_dest_file_line_edit.textChanged.connect(
lambda text: self.refresh(text))
pre_transform_file_line_edit_text = str(
settings.value(self.PRE_TRANSFORM_SETTING,
defaultValue=self.DEFAULT_PRE_TRANSFORM))
self._pre_transform_file_line_edit = FileLineEdit(parent=self)
self._pre_transform_file_line_edit.file_dialog.setWindowTitle(
'Select pre-transform')
self._pre_transform_file_line_edit.setText(
pre_transform_file_line_edit_text)
self._pre_transform_file_line_edit.file_dialog.setFileMode(
QFileDialog.ExistingFile)
self._pre_transform_file_line_edit.file_dialog.setNameFilter(
'Numpy files (*.npy)')
# noinspection PyUnresolvedReferences
self._pre_transform_file_line_edit.textChanged.connect(
lambda text: self.refresh(text))
post_transform_file_line_edit_text = str(
settings.value(self.POST_TRANSFORM_SETTING,
defaultValue=self.DEFAULT_POST_TRANSFORM))
self._post_transform_file_line_edit = FileLineEdit(parent=self)
self._post_transform_file_line_edit.file_dialog.setWindowTitle(
'Select post-transform')
self._post_transform_file_line_edit.file_dialog.setFileMode(
QFileDialog.ExistingFile)
self._post_transform_file_line_edit.file_dialog.setNameFilter(
'Numpy files (*.npy)')
self._post_transform_file_line_edit.setText(
post_transform_file_line_edit_text)
# noinspection PyUnresolvedReferences
self._post_transform_file_line_edit.textChanged.connect(
lambda text: self.refresh(text))
self._button_box = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel, self)
# noinspection PyUnresolvedReferences
self._button_box.rejected.connect(self.reject)
# noinspection PyUnresolvedReferences
@self._button_box.accepted.connect
def on_button_box_accepted():
settings.setValue(self.SELECTION_MODE_SETTING,
self.selection_mode.value)
settings.setValue(self.SOURCE_IMAGES_SETTING,
str(self.source_images_path))
settings.setValue(self.SOURCE_REGEX_SETTING, self.source_regex)
settings.setValue(self.TARGET_IMAGES_SETTING,
str(self.target_images_path))
settings.setValue(self.TARGET_REGEX_SETTING, self.target_regex)
settings.setValue(self.CONTROL_POINTS_DEST_SETTING,
str(self.control_points_dest_path))
settings.setValue(self.JOINT_TRANSFORM_DEST_SETTING,
str(self.joint_transform_dest_path))
settings.setValue(self.TRANSFORM_TYPE_SETTING,
self.transform_type.value)
settings.setValue(self.MATCHING_STRATEGY_SETTING,
self.matching_strategy.value)
settings.setValue(self.SOURCE_COORDS_SETTING,
str(self.source_coords_path or ''))
settings.setValue(self.SOURCE_COORDS_REGEX_SETTING,
self.source_coords_regex)
settings.setValue(self.TRANSFORMED_COORDS_DEST_SETTING,
str(self.transformed_coords_dest_path or ''))
settings.setValue(self.PRE_TRANSFORM_SETTING,
str(self.pre_transform_path or ''))
settings.setValue(self.POST_TRANSFORM_SETTING,
str(self.post_transform_path or ''))
settings.sync()
self.accept()
required_group_box = QGroupBox(self)
required_group_box_layout = QFormLayout()
required_group_box_layout.setLabelAlignment(Qt.AlignLeft)
required_group_box_layout.setRowWrapPolicy(QFormLayout.DontWrapRows)
required_group_box_layout.setFieldGrowthPolicy(
QFormLayout.AllNonFixedFieldsGrow)
required_group_box_layout.addRow('Source image(s):',
self._source_images_file_line_edit)
required_group_box_layout.addRow(self._source_regex_label,
self._source_regex_line_edit)
required_group_box_layout.addRow('Target image(s):',
self._target_images_file_line_edit)
required_group_box_layout.addRow(self._target_regex_label,
self._target_regex_line_edit)
required_group_box_layout.addRow(
'Control points dest.:', self._control_points_dest_file_line_edit)
required_group_box_layout.addRow(
'Joint transform dest.:',
self._joint_transform_dest_file_line_edit)
required_group_box_layout.addRow('Transform type:',
self._transform_type_combo_box)
required_group_box.setLayout(required_group_box_layout)
optional_group_box = QGroupBox(self)
optional_group_box_layout = QFormLayout()
optional_group_box_layout.setLabelAlignment(Qt.AlignLeft)
optional_group_box_layout.setRowWrapPolicy(QFormLayout.DontWrapRows)
optional_group_box_layout.setFieldGrowthPolicy(
QFormLayout.AllNonFixedFieldsGrow)
optional_group_box_layout.addRow('Source coordinates:',
self._source_coords_file_line_edit)
optional_group_box_layout.addRow(self._source_coords_regex_label,
self._source_coords_regex_line_edit)
optional_group_box_layout.addRow(
'Transformed coord. dest.:',
self._transformed_coords_dest_file_line_edit)
optional_group_box_layout.addRow('Pre-transform:',
self._pre_transform_file_line_edit)
optional_group_box_layout.addRow('Post-transform:',
self._post_transform_file_line_edit)
optional_group_box.setLayout(optional_group_box_layout)
layout = QVBoxLayout()
mode_layout = QHBoxLayout()
# noinspection PyArgumentList
mode_layout.addWidget(self._file_selection_mode_button)
# noinspection PyArgumentList
mode_layout.addWidget(self._dir_selection_mode_button)
# noinspection PyArgumentList
mode_layout.addWidget(self._matching_strategy_combo_box)
mode_layout.addStretch()
layout.addLayout(mode_layout)
# noinspection PyArgumentList
layout.addWidget(required_group_box)
# noinspection PyArgumentList
layout.addWidget(optional_group_box)
# noinspection PyArgumentList
layout.addWidget(self._button_box)
self.setLayout(layout)
self.setWindowTitle('Control point matching')
self.setMinimumWidth(600)
self.refresh()
def _setupCoefficientsEditWidget(self, parent=None):
wid = QGroupBox('Edit Coefficients', parent or self)
le_coefdesc = PyDMLineEdit(self, self.dev_pref + ':DESC_COEFF')
graph_coefs = WfmGraph(wid)
graph_coefs.add_scatter_curve(ychannel=self.dev_pref + ':COEFF',
lineStyle=Qt.SolidLine)
graph_fftmag = WfmGraph(wid)
graph_fftmag.setObjectName('graph')
graph_fftmag.setStyleSheet('#graph{min-height: 12em;}')
graph_fftmag.setLabel('left', text='Magnitude [dB]')
graph_fftmag.setLabel('bottom', text='Fractional Freq.')
graph_fftmag.add_scatter_curve(ychannel=self.dev_pref + ':FTF_MAG',
xchannel=self.dev_pref + ':FTF_FREQ',
color=QColor('blue'),
lineWidth=2,
lineStyle=Qt.SolidLine,
symbolSize=4)
graph_fftmag.add_scatter_curve(ychannel=self.dev_pref + ':FTF_GTUNE',
xchannel=self.dev_pref + ':FTF_FTUNE',
name='Tune',
color=QColor('red'))
graph_fftphs = WfmGraph(wid)
graph_fftphs.setLabel('left', text='Phase [°]')
graph_fftphs.setLabel('bottom', text='Fractional Freq.')
graph_fftphs.add_scatter_curve(ychannel=self.dev_pref + ':FTF_PHASE',
xchannel=self.dev_pref + ':FTF_FREQ',
color=QColor('blue'),
lineWidth=2,
lineStyle=Qt.SolidLine,
symbolSize=4)
graph_fftphs.add_scatter_curve(ychannel=self.dev_pref + ':FTF_PTUNE',
xchannel=self.dev_pref + ':FTF_FTUNE',
name='Tune',
color=QColor('red'))
ld_fractune = QLabel('<h4> Marker:</h4>',
wid,
alignment=Qt.AlignLeft | Qt.AlignVCenter)
ld_ftval = QLabel('Frequency [0-1]',
wid,
alignment=Qt.AlignRight | Qt.AlignVCenter)
sb_ftval = PyDMSpinbox(wid, self.dev_pref + ':FTF_TUNE')
sb_ftval.showStepExponent = False
ld_ftgain = QLabel('Gain [dB]',
wid,
alignment=Qt.AlignRight | Qt.AlignVCenter)
lb_ftgain = Label(wid, self.dev_pref + ':FTF_GTUNE')
lb_ftgain.precisionFromPV = False
lb_ftgain.precision = 2
ld_ftphs = QLabel('Phase [°]',
wid,
alignment=Qt.AlignRight | Qt.AlignVCenter)
lb_ftphs = Label(wid, self.dev_pref + ':FTF_PTUNE')
lb_ftphs.precisionFromPV = False
lb_ftphs.precision = 2
lay_genft = QGridLayout()
lay_genft.setVerticalSpacing(6)
lay_genft.setHorizontalSpacing(9)
lay_genft.addWidget(ld_fractune, 0, 0)
lay_genft.addWidget(ld_ftval, 0, 2)
lay_genft.addWidget(sb_ftval, 0, 3)
lay_genft.addWidget(ld_ftgain, 0, 5)
lay_genft.addWidget(lb_ftgain, 0, 6)
lay_genft.addWidget(ld_ftphs, 0, 8)
lay_genft.addWidget(lb_ftphs, 0, 9)
lay_genft.setRowStretch(1, 2)
lay_genft.setRowStretch(4, 2)
lay_genft.setRowStretch(7, 2)
lay_genft.setRowStretch(10, 2)
coef_edit_wid = self._setupCoeffSettingsWidget()
lay = QGridLayout(wid)
lay.setVerticalSpacing(15)
lay.addWidget(coef_edit_wid, 0, 0, 2, 1)
lay.addWidget(le_coefdesc, 0, 1)
lay.addWidget(graph_coefs, 1, 1)
lay.addWidget(graph_fftmag, 2, 0)
lay.addWidget(graph_fftphs, 2, 1)
lay.addLayout(lay_genft, 3, 0, 1, 2)
return wid
def _setupCoefficientsViewWidget(self):
ld_coef0 = QLabel('<h4>Set 0</h4>', self)
ld_coef0.setStyleSheet('max-width: 3em;')
lb_coef0 = PyDMLabel(self, self.dev_pref + ':DESC_CSET0')
lb_coef0.setStyleSheet('background-color: #DCDCDC;')
led_coef0 = SiriusLedAlert(self, self.dev_pref + ':CVERIFY.C')
led_coef0.setStyleSheet('min-width: 1.29em; max-width: 1.29em;')
graph_coef0 = WfmGraph(self)
graph_coef0.add_scatter_curve(ychannel=self.dev_pref + ':CSET0',
lineStyle=Qt.SolidLine)
ld_coef1 = QLabel('<h4>Set 1</h4>', self)
ld_coef1.setStyleSheet('max-width: 3em;')
lb_coef1 = PyDMLabel(self, self.dev_pref + ':DESC_CSET1')
lb_coef1.setStyleSheet('background-color: #DCDCDC;')
led_coef1 = SiriusLedAlert(self, self.dev_pref + ':CVERIFY.D')
led_coef1.setStyleSheet('min-width: 1.29em; max-width: 1.29em;')
graph_coef1 = WfmGraph(self)
graph_coef1.add_scatter_curve(ychannel=self.dev_pref + ':CSET1',
lineStyle=Qt.SolidLine)
ld_coef2 = QLabel('<h4>Set 2</h4>', self)
ld_coef2.setStyleSheet('max-width: 3em;')
lb_coef2 = PyDMLabel(self, self.dev_pref + ':DESC_CSET2')
lb_coef2.setStyleSheet('background-color: #DCDCDC;')
led_coef2 = SiriusLedAlert(self, self.dev_pref + ':CVERIFY.G')
led_coef2.setStyleSheet('min-width: 1.29em; max-width: 1.29em;')
graph_coef2 = WfmGraph(self)
graph_coef2.add_scatter_curve(ychannel=self.dev_pref + ':CSET2',
lineStyle=Qt.SolidLine)
ld_coef3 = QLabel('<h4>Set 3</h4>', self)
ld_coef3.setStyleSheet('max-width: 3em;')
lb_coef3 = PyDMLabel(self, self.dev_pref + ':DESC_CSET3')
lb_coef3.setStyleSheet('background-color: #DCDCDC;')
led_coef3 = SiriusLedAlert(self, self.dev_pref + ':CVERIFY.H')
led_coef3.setStyleSheet('min-width: 1.29em; max-width: 1.29em;')
graph_coef3 = WfmGraph(self)
graph_coef3.add_scatter_curve(ychannel=self.dev_pref + ':CSET3',
lineStyle=Qt.SolidLine)
gbox_coefview = QGroupBox('Coefficient Sets View', self)
gbox_coefview.setLayout(QGridLayout())
tab_coefview = QTabWidget(gbox_coefview)
gbox_coefview.layout().addWidget(tab_coefview, 0, 0)
norm_wid = QWidget(tab_coefview)
tab_coefview.addTab(norm_wid, 'Normal')
lay_norm = QGridLayout(norm_wid)
lay_norm.addWidget(ld_coef0, 0, 0)
lay_norm.addWidget(lb_coef0, 0, 1)
lay_norm.addWidget(led_coef0, 0, 2)
lay_norm.addWidget(graph_coef0, 1, 0, 1, 3)
lay_norm.addWidget(ld_coef1, 2, 0)
lay_norm.addWidget(lb_coef1, 2, 1)
lay_norm.addWidget(led_coef1, 2, 2)
lay_norm.addWidget(graph_coef1, 3, 0, 1, 3)
alter_wid = QWidget(tab_coefview)
tab_coefview.addTab(alter_wid, 'Alternate')
lay_alter = QGridLayout(alter_wid)
lay_alter.addWidget(ld_coef2, 0, 3)
lay_alter.addWidget(lb_coef2, 0, 4)
lay_alter.addWidget(led_coef2, 0, 5)
lay_alter.addWidget(graph_coef2, 1, 3, 1, 3)
lay_alter.addWidget(ld_coef3, 2, 3)
lay_alter.addWidget(lb_coef3, 2, 4)
lay_alter.addWidget(led_coef3, 2, 5)
lay_alter.addWidget(graph_coef3, 3, 3, 1, 3)
return gbox_coefview
def add_color_scheme_stack(self, scheme_name, custom=False):
"""Add a stack for a given scheme and connects the CONF values."""
color_scheme_groups = [(_('Text'), [
"normal",
"comment",
"string",
"number",
"keyword",
"builtin",
"definition",
"instance",
]),
(_('Highlight'), [
"currentcell", "currentline", "occurrence",
"matched_p", "unmatched_p", "ctrlclick"
]),
(_('Background'), ["background", "sideareas"])]
parent = self.parent
line_edit = parent.create_lineedit(_("Scheme name:"),
'{0}/name'.format(scheme_name))
self.widgets[scheme_name] = {}
# Widget setup
line_edit.label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
self.setWindowTitle(_('Color scheme editor'))
# Layout
name_layout = QHBoxLayout()
name_layout.addWidget(line_edit.label)
name_layout.addWidget(line_edit.textbox)
self.scheme_name_textbox[scheme_name] = line_edit.textbox
if not custom:
line_edit.textbox.setDisabled(True)
if not self.isVisible():
line_edit.setVisible(False)
cs_layout = QVBoxLayout()
cs_layout.addLayout(name_layout)
h_layout = QHBoxLayout()
v_layout = QVBoxLayout()
for index, item in enumerate(color_scheme_groups):
group_name, keys = item
group_layout = QGridLayout()
for row, key in enumerate(keys):
option = "{0}/{1}".format(scheme_name, key)
value = self.parent.get_option(option)
name = syntaxhighlighters.COLOR_SCHEME_KEYS[key]
if is_text_string(value):
label, clayout = parent.create_coloredit(
name,
option,
without_layout=True,
)
label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
group_layout.addWidget(label, row + 1, 0)
group_layout.addLayout(clayout, row + 1, 1)
# Needed to update temp scheme to obtain instant preview
self.widgets[scheme_name][key] = [clayout]
else:
label, clayout, cb_bold, cb_italic = parent.create_scedit(
name,
option,
without_layout=True,
)
label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
group_layout.addWidget(label, row + 1, 0)
group_layout.addLayout(clayout, row + 1, 1)
group_layout.addWidget(cb_bold, row + 1, 2)
group_layout.addWidget(cb_italic, row + 1, 3)
# Needed to update temp scheme to obtain instant preview
self.widgets[scheme_name][key] = [
clayout, cb_bold, cb_italic
]
group_box = QGroupBox(group_name)
group_box.setLayout(group_layout)
if index == 0:
h_layout.addWidget(group_box)
else:
v_layout.addWidget(group_box)
h_layout.addLayout(v_layout)
cs_layout.addLayout(h_layout)
stackitem = QWidget()
stackitem.setLayout(cs_layout)
self.stack.addWidget(stackitem)
self.order.append(scheme_name)
def setup_page(self):
settings_group = QGroupBox(_("Settings"))
save_box = self.create_checkbox(_("Save file before analyzing it"),
'save_before',
default=True)
hist_group = QGroupBox(_("History"))
hist_label1 = QLabel(
_("The following option will be applied at next "
"startup."))
hist_label1.setWordWrap(True)
hist_spin = self.create_spinbox(_("History: "),
_(" results"),
'max_entries',
default=50,
min_=10,
max_=1000000,
step=10)
results_group = QGroupBox(_("Results"))
results_label1 = QLabel(_("Results are stored here:"))
results_label1.setWordWrap(True)
# Warning: do not try to regroup the following QLabel contents with
# widgets above -- this string was isolated here in a single QLabel
# on purpose: to fix Issue 863
results_label2 = QLabel(PylintWidget.DATAPATH)
results_label2.setTextInteractionFlags(Qt.TextSelectableByMouse)
results_label2.setWordWrap(True)
settings_layout = QVBoxLayout()
settings_layout.addWidget(save_box)
settings_group.setLayout(settings_layout)
hist_layout = QVBoxLayout()
hist_layout.addWidget(hist_label1)
hist_layout.addWidget(hist_spin)
hist_group.setLayout(hist_layout)
results_layout = QVBoxLayout()
results_layout.addWidget(results_label1)
results_layout.addWidget(results_label2)
results_group.setLayout(results_layout)
vlayout = QVBoxLayout()
vlayout.addWidget(settings_group)
vlayout.addWidget(hist_group)
vlayout.addWidget(results_group)
vlayout.addStretch(1)
self.setLayout(vlayout)
def __init__(self, parent=None):
super(KernelConnectionDialog, self).__init__(parent)
self.setWindowTitle(_('Connect to an existing kernel'))
main_label = QLabel(_(
"<p>Please select the JSON connection file (<i>e.g.</i> "
"<tt>kernel-1234.json</tt>) of the existing kernel, and enter "
"the SSH information if connecting to a remote machine. "
"To learn more about starting external kernels and connecting "
"to them, see <a href=\"https://docs.spyder-ide.org/"
"ipythonconsole.html#connect-to-an-external-kernel\">"
"our documentation</a>.</p>"))
main_label.setWordWrap(True)
main_label.setAlignment(Qt.AlignJustify)
main_label.setOpenExternalLinks(True)
# Connection file
cf_label = QLabel(_('Connection file:'))
self.cf = QLineEdit()
self.cf.setPlaceholderText(_('Kernel connection file path'))
self.cf.setMinimumWidth(350)
cf_open_btn = QPushButton(_('Browse'))
cf_open_btn.clicked.connect(self.select_connection_file)
cf_layout = QHBoxLayout()
cf_layout.addWidget(cf_label)
cf_layout.addWidget(self.cf)
cf_layout.addWidget(cf_open_btn)
# Remote kernel groupbox
self.rm_group = QGroupBox(_("This is a remote kernel (via SSH)"))
# SSH connection
hn_label = QLabel(_('Hostname:'))
self.hn = QLineEdit()
pn_label = QLabel(_('Port:'))
self.pn = QLineEdit()
self.pn.setMaximumWidth(75)
self.pn.setText('22')
un_label = QLabel(_('Username:'******'Password:'******'SSH keyfile:'))
self.pw = QLineEdit()
self.pw.setEchoMode(QLineEdit.Password)
self.pw_radio.toggled.connect(self.pw.setEnabled)
self.kf_radio.toggled.connect(self.pw.setDisabled)
self.kf = QLineEdit()
kf_open_btn = QPushButton(_('Browse'))
kf_open_btn.clicked.connect(self.select_ssh_key)
kf_layout = QHBoxLayout()
kf_layout.addWidget(self.kf)
kf_layout.addWidget(kf_open_btn)
kfp_label = QLabel(_('Passphase:'))
self.kfp = QLineEdit()
self.kfp.setPlaceholderText(_('Optional'))
self.kfp.setEchoMode(QLineEdit.Password)
self.kf_radio.toggled.connect(self.kf.setEnabled)
self.kf_radio.toggled.connect(self.kfp.setEnabled)
self.kf_radio.toggled.connect(kf_open_btn.setEnabled)
self.kf_radio.toggled.connect(kfp_label.setEnabled)
self.pw_radio.toggled.connect(self.kf.setDisabled)
self.pw_radio.toggled.connect(self.kfp.setDisabled)
self.pw_radio.toggled.connect(kf_open_btn.setDisabled)
self.pw_radio.toggled.connect(kfp_label.setDisabled)
# SSH layout
ssh_layout = QGridLayout()
ssh_layout.addWidget(hn_label, 0, 0, 1, 2)
ssh_layout.addWidget(self.hn, 0, 2)
ssh_layout.addWidget(pn_label, 0, 3)
ssh_layout.addWidget(self.pn, 0, 4)
ssh_layout.addWidget(un_label, 1, 0, 1, 2)
ssh_layout.addWidget(self.un, 1, 2, 1, 3)
# SSH authentication layout
auth_layout = QGridLayout()
auth_layout.addWidget(self.pw_radio, 1, 0)
auth_layout.addWidget(pw_label, 1, 1)
auth_layout.addWidget(self.pw, 1, 2)
auth_layout.addWidget(self.kf_radio, 2, 0)
auth_layout.addWidget(kf_label, 2, 1)
auth_layout.addLayout(kf_layout, 2, 2)
auth_layout.addWidget(kfp_label, 3, 1)
auth_layout.addWidget(self.kfp, 3, 2)
auth_group.setLayout(auth_layout)
# Remote kernel layout
rm_layout = QVBoxLayout()
rm_layout.addLayout(ssh_layout)
rm_layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 8)))
rm_layout.addWidget(auth_group)
self.rm_group.setLayout(rm_layout)
self.rm_group.setCheckable(True)
self.rm_group.setChecked(False)
self.rm_group.toggled.connect(self.pw_radio.setChecked)
# Ok and Cancel buttons
self.accept_btns = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel,
Qt.Horizontal, self)
self.accept_btns.accepted.connect(self.accept)
self.accept_btns.rejected.connect(self.reject)
# Dialog layout
layout = QVBoxLayout(self)
layout.addWidget(main_label)
layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 8)))
layout.addLayout(cf_layout)
layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 12)))
layout.addWidget(self.rm_group)
layout.addWidget(self.accept_btns)
def setup_page(self):
newcb = self.create_checkbox
# --- Introspection ---
# Basic features group
basic_features_group = QGroupBox(_("Basic features"))
completion_box = newcb(_("Enable code completion"), 'code_completion')
enable_hover_hints_box = newcb(
_("Enable hover hints"),
'enable_hover_hints',
tip=_("If enabled, hovering the mouse pointer over an object\n"
"name will display that object's signature and/or\n"
"docstring (if present)."))
goto_definition_box = newcb(
_("Enable Go to definition"),
'jedi_definition',
tip=_("If enabled, left-clicking on an object name while \n"
"pressing the {} key will go to that object's definition\n"
"(if resolved).".format(self.CTRL)))
follow_imports_box = newcb(
_("Follow imports when going to a "
"definition"), 'jedi_definition/follow_imports')
show_signature_box = newcb(_("Show calltips"), 'jedi_signature_help')
basic_features_layout = QVBoxLayout()
basic_features_layout.addWidget(completion_box)
basic_features_layout.addWidget(enable_hover_hints_box)
basic_features_layout.addWidget(goto_definition_box)
basic_features_layout.addWidget(follow_imports_box)
basic_features_layout.addWidget(show_signature_box)
basic_features_group.setLayout(basic_features_layout)
# Advanced group
advanced_group = QGroupBox(_("Advanced"))
modules_textedit = self.create_textedit(
_("Preload the following modules to make completion faster "
"and more accurate:"), 'preload_modules')
if is_dark_interface():
modules_textedit.textbox.setStyleSheet(
"border: 1px solid #32414B;")
advanced_layout = QVBoxLayout()
advanced_layout.addWidget(modules_textedit)
advanced_group.setLayout(advanced_layout)
# --- Linting ---
# Linting options
linting_label = QLabel(
_("Spyder can optionally highlight syntax "
"errors and possible problems with your "
"code in the editor."))
linting_label.setOpenExternalLinks(True)
linting_label.setWordWrap(True)
linting_check = self.create_checkbox(_("Enable basic linting"),
'pyflakes')
linting_complexity_box = self.create_checkbox(
_("Enable complexity linting with "
"the Mccabe package"), 'mccabe')
# Linting layout
linting_layout = QVBoxLayout()
linting_layout.addWidget(linting_label)
linting_layout.addWidget(linting_check)
linting_layout.addWidget(linting_complexity_box)
linting_widget = QWidget()
linting_widget.setLayout(linting_layout)
# --- Code style tab ---
# Code style label
pep_url = (
'<a href="https://www.python.org/dev/peps/pep-0008">PEP 8</a>')
code_style_codes_url = _(
"<a href='http://pycodestyle.pycqa.org/en/stable"
"/intro.html#error-codes'>pycodestyle error codes</a>")
code_style_label = QLabel(
_("Spyder can use pycodestyle to analyze your code for "
"conformance to the {} convention. You can also "
"manually show or hide specific warnings by their "
"{}.").format(pep_url, code_style_codes_url))
code_style_label.setOpenExternalLinks(True)
code_style_label.setWordWrap(True)
# Code style checkbox
code_style_check = self.create_checkbox(_("Enable code style linting"),
'pycodestyle')
# Code style options
self.code_style_filenames_match = self.create_lineedit(
_("Only check filenames matching these patterns:"),
'pycodestyle/filename',
alignment=Qt.Horizontal,
word_wrap=False,
placeholder=_("Check Python files: *.py"))
self.code_style_exclude = self.create_lineedit(
_("Exclude files or directories matching these patterns:"),
'pycodestyle/exclude',
alignment=Qt.Horizontal,
word_wrap=False,
placeholder=_("Exclude all test files: (?!test_).*\\.py"))
code_style_select = self.create_lineedit(
_("Show the following errors or warnings:").format(
code_style_codes_url),
'pycodestyle/select',
alignment=Qt.Horizontal,
word_wrap=False,
placeholder=_("Example codes: E113, W391"))
code_style_ignore = self.create_lineedit(
_("Ignore the following errors or warnings:"),
'pycodestyle/ignore',
alignment=Qt.Horizontal,
word_wrap=False,
placeholder=_("Example codes: E201, E303"))
code_style_max_line_length = self.create_spinbox(
_("Maximum allowed line length:"),
None,
'pycodestyle/max_line_length',
min_=10,
max_=500,
step=1,
tip=_("Default is 79"))
# Code style layout
code_style_g_layout = QGridLayout()
code_style_g_layout.addWidget(self.code_style_filenames_match.label, 1,
0)
code_style_g_layout.addWidget(self.code_style_filenames_match.textbox,
1, 1)
code_style_g_layout.addWidget(self.code_style_exclude.label, 2, 0)
code_style_g_layout.addWidget(self.code_style_exclude.textbox, 2, 1)
code_style_g_layout.addWidget(code_style_select.label, 3, 0)
code_style_g_layout.addWidget(code_style_select.textbox, 3, 1)
code_style_g_layout.addWidget(code_style_ignore.label, 4, 0)
code_style_g_layout.addWidget(code_style_ignore.textbox, 4, 1)
code_style_g_layout.addWidget(code_style_max_line_length.plabel, 5, 0)
code_style_g_layout.addWidget(code_style_max_line_length.spinbox, 5, 1)
# Set Code style options enabled/disabled
code_style_g_widget = QWidget()
code_style_g_widget.setLayout(code_style_g_layout)
code_style_g_widget.setEnabled(self.get_option('pycodestyle'))
code_style_check.toggled.connect(code_style_g_widget.setEnabled)
# Code style layout
code_style_layout = QVBoxLayout()
code_style_layout.addWidget(code_style_label)
code_style_layout.addWidget(code_style_check)
code_style_layout.addWidget(code_style_g_widget)
code_style_widget = QWidget()
code_style_widget.setLayout(code_style_layout)
# --- Docstring tab ---
# Docstring style label
numpy_url = ("<a href='https://numpydoc.readthedocs.io/en/"
"latest/format.html'>Numpy</a>")
pep257_url = (
"<a href='https://www.python.org/dev/peps/pep-0257/'>PEP 257</a>")
docstring_style_codes = _(
"<a href='http://www.pydocstyle.org/en/stable"
"/error_codes.html'>page</a>")
docstring_style_label = QLabel(
_("Here you can decide if you want to perform style analysis on "
"your docstrings according to the {} or {} conventions. You can "
"also decide if you want to show or ignore specific errors, "
"according to the codes found on this {}.").format(
numpy_url, pep257_url, docstring_style_codes))
docstring_style_label.setOpenExternalLinks(True)
docstring_style_label.setWordWrap(True)
# Docstring style checkbox
docstring_style_check = self.create_checkbox(
_("Enable docstring style linting"), 'pydocstyle')
# Docstring style options
docstring_style_convention = self.create_combobox(
_("Choose the convention used to lint docstrings: "),
(("Numpy", 'numpy'), ("PEP 257", 'pep257'), ("Custom", 'custom')),
'pydocstyle/convention')
self.docstring_style_select = self.create_lineedit(
_("Show the following errors:"),
'pydocstyle/select',
alignment=Qt.Horizontal,
word_wrap=False,
placeholder=_("Example codes: D413, D414"))
self.docstring_style_ignore = self.create_lineedit(
_("Ignore the following errors:"),
'pydocstyle/ignore',
alignment=Qt.Horizontal,
word_wrap=False,
placeholder=_("Example codes: D107, D402"))
self.docstring_style_match = self.create_lineedit(
_("Only check filenames matching these patterns:"),
'pydocstyle/match',
alignment=Qt.Horizontal,
word_wrap=False,
placeholder=_("Skip test files: (?!test_).*\\.py"))
self.docstring_style_match_dir = self.create_lineedit(
_("Only check in directories matching these patterns:"),
'pydocstyle/match_dir',
alignment=Qt.Horizontal,
word_wrap=False,
placeholder=_("Skip dot directories: [^\\.].*"))
# Custom option handling
docstring_style_convention.combobox.currentTextChanged.connect(
self.setup_docstring_style_convention)
current_convention = docstring_style_convention.combobox.currentText()
self.setup_docstring_style_convention(current_convention)
# Docstring style layout
docstring_style_g_layout = QGridLayout()
docstring_style_g_layout.addWidget(docstring_style_convention.label, 1,
0)
docstring_style_g_layout.addWidget(docstring_style_convention.combobox,
1, 1)
docstring_style_g_layout.addWidget(self.docstring_style_select.label,
2, 0)
docstring_style_g_layout.addWidget(self.docstring_style_select.textbox,
2, 1)
docstring_style_g_layout.addWidget(self.docstring_style_ignore.label,
3, 0)
docstring_style_g_layout.addWidget(self.docstring_style_ignore.textbox,
3, 1)
docstring_style_g_layout.addWidget(self.docstring_style_match.label, 4,
0)
docstring_style_g_layout.addWidget(self.docstring_style_match.textbox,
4, 1)
docstring_style_g_layout.addWidget(
self.docstring_style_match_dir.label, 5, 0)
docstring_style_g_layout.addWidget(
self.docstring_style_match_dir.textbox, 5, 1)
# Set Docstring style options enabled/disabled
docstring_style_g_widget = QWidget()
docstring_style_g_widget.setLayout(docstring_style_g_layout)
docstring_style_g_widget.setEnabled(self.get_option('pydocstyle'))
docstring_style_check.toggled.connect(
docstring_style_g_widget.setEnabled)
# Docstring style layout
docstring_style_layout = QVBoxLayout()
docstring_style_layout.addWidget(docstring_style_label)
docstring_style_layout.addWidget(docstring_style_check)
docstring_style_layout.addWidget(docstring_style_g_widget)
docstring_style_widget = QWidget()
docstring_style_widget.setLayout(docstring_style_layout)
# --- Advanced tab ---
# Advanced label
advanced_label = QLabel(
_("Please don't modify these values unless "
"you know what you're doing!"))
advanced_label.setWordWrap(True)
advanced_label.setAlignment(Qt.AlignJustify)
# Advanced options
advanced_command_launch = self.create_lineedit(
_("Command to launch the Python language server: "),
'advanced/command_launch',
alignment=Qt.Horizontal,
word_wrap=False)
advanced_host = self.create_lineedit(
_("IP Address and port to bind the server to: "),
'advanced/host',
alignment=Qt.Horizontal,
word_wrap=False)
advanced_port = self.create_spinbox(":",
"",
'advanced/port',
min_=1,
max_=65535,
step=1)
external_server = self.create_checkbox(_("This is an external server"),
'advanced/external')
# Advanced layout
advanced_g_layout = QGridLayout()
advanced_g_layout.addWidget(advanced_command_launch.label, 1, 0)
advanced_g_layout.addWidget(advanced_command_launch.textbox, 1, 1)
advanced_g_layout.addWidget(advanced_host.label, 2, 0)
advanced_host_port_g_layout = QGridLayout()
advanced_host_port_g_layout.addWidget(advanced_host.textbox, 1, 0)
advanced_host_port_g_layout.addWidget(advanced_port.plabel, 1, 1)
advanced_host_port_g_layout.addWidget(advanced_port.spinbox, 1, 2)
advanced_g_layout.addLayout(advanced_host_port_g_layout, 2, 1)
advanced_widget = QWidget()
advanced_layout = QVBoxLayout()
advanced_layout.addWidget(advanced_label)
advanced_layout.addLayout(advanced_g_layout)
advanced_layout.addWidget(external_server)
advanced_widget.setLayout(advanced_layout)
# --- Other servers tab ---
# Section label
servers_label = QLabel(
_("Spyder uses the <a href=\"{lsp_url}\">Language Server "
"Protocol</a> to provide code completion and linting "
"for its Editor. Here, you can setup and configure LSP servers "
"for languages other than Python, so Spyder can provide such "
"features for those languages as well.").format(lsp_url=LSP_URL))
servers_label.setOpenExternalLinks(True)
servers_label.setWordWrap(True)
servers_label.setAlignment(Qt.AlignJustify)
# Servers table
table_group = QGroupBox(_('Available servers:'))
self.table = LSPServerTable(self, text_color=ima.MAIN_FG_COLOR)
table_layout = QVBoxLayout()
table_layout.addWidget(self.table)
table_group.setLayout(table_layout)
# Buttons
self.reset_btn = QPushButton(_("Reset to default values"))
self.new_btn = QPushButton(_("Set up a new server"))
self.delete_btn = QPushButton(_("Delete currently selected server"))
self.delete_btn.setEnabled(False)
# Slots connected to buttons
self.new_btn.clicked.connect(self.create_new_server)
self.reset_btn.clicked.connect(self.reset_to_default)
self.delete_btn.clicked.connect(self.delete_server)
# Buttons layout
btns = [self.new_btn, self.delete_btn, self.reset_btn]
buttons_layout = QGridLayout()
for i, btn in enumerate(btns):
buttons_layout.addWidget(btn, i, 1)
buttons_layout.setColumnStretch(0, 1)
buttons_layout.setColumnStretch(1, 2)
buttons_layout.setColumnStretch(2, 1)
# Combined layout
servers_widget = QWidget()
servers_layout = QVBoxLayout()
servers_layout.addSpacing(-10)
servers_layout.addWidget(servers_label)
servers_layout.addWidget(table_group)
servers_layout.addSpacing(10)
servers_layout.addLayout(buttons_layout)
servers_widget.setLayout(servers_layout)
# --- Tabs organization ---
tabs = QTabWidget()
tabs.addTab(self.create_tab(basic_features_group, advanced_group),
_('Introspection'))
tabs.addTab(self.create_tab(linting_widget), _('Linting'))
tabs.addTab(self.create_tab(code_style_widget), _('Code style'))
tabs.addTab(self.create_tab(docstring_style_widget),
_('Docstring style'))
tabs.addTab(self.create_tab(advanced_widget), _('Advanced'))
tabs.addTab(self.create_tab(servers_widget), _('Other languages'))
vlayout = QVBoxLayout()
vlayout.addWidget(tabs)
self.setLayout(vlayout)
