def create_radiobutton(self, text, option, default=NoDefault,
tip=None, msg_warning=None, msg_info=None,
msg_if_enabled=False, button_group=None,
restart=False):
radiobutton = QRadioButton(text)
if button_group is None:
if self.default_button_group is None:
self.default_button_group = QButtonGroup(self)
button_group = self.default_button_group
button_group.addButton(radiobutton)
if tip is not None:
radiobutton.setToolTip(tip)
self.radiobuttons[radiobutton] = (option, default)
if msg_warning is not None or msg_info is not None:
def show_message(is_checked):
if is_checked or not msg_if_enabled:
if msg_warning is not None:
QMessageBox.warning(self, self.get_name(),
msg_warning, QMessageBox.Ok)
if msg_info is not None:
QMessageBox.information(self, self.get_name(),
msg_info, QMessageBox.Ok)
radiobutton.toggled.connect(show_message)
radiobutton.restart_required = restart
radiobutton.label_text = text
return radiobutton
def __init__(self, parent):
QWidget.__init__(self, parent)
vert_layout = QVBoxLayout()
# Type frame
type_layout = QHBoxLayout()
type_label = QLabel(_("Import as"))
type_layout.addWidget(type_label)
self.array_btn = array_btn = QRadioButton(_("array"))
array_btn.setEnabled(ndarray is not FakeObject)
array_btn.setChecked(ndarray is not FakeObject)
type_layout.addWidget(array_btn)
list_btn = QRadioButton(_("list"))
list_btn.setChecked(not array_btn.isChecked())
type_layout.addWidget(list_btn)
if pd:
self.df_btn = df_btn = QRadioButton(_("DataFrame"))
df_btn.setChecked(False)
type_layout.addWidget(df_btn)
h_spacer = QSpacerItem(40, 20,
QSizePolicy.Expanding, QSizePolicy.Minimum)
type_layout.addItem(h_spacer)
type_frame = QFrame()
type_frame.setLayout(type_layout)
self._table_view = PreviewTable(self)
vert_layout.addWidget(type_frame)
vert_layout.addWidget(self._table_view)
self.setLayout(vert_layout)
def _init_ui(self):
# Widgets
self._rdb_sum = QRadioButton("Sum")
self._rdb_sum.setChecked(True)
self._rdb_max = QRadioButton("Maximum")
self._rdb_single = QRadioButton("Single")
self._rdb_range = QRadioButton("Range")
self._sld_start = QSlider(Qt.Horizontal)
self._sld_start.setTickPosition(QSlider.TicksBelow)
self._sld_start.setEnabled(False)
self._sld_end = QSlider(Qt.Horizontal)
self._sld_end.setTickPosition(QSlider.TicksBelow)
self._sld_end.setEnabled(False)
self._wdg_imageraster2d = self._create_imageraster2d_widget()
self._wdg_analysis = self._create_analysis1d_widget()
# Layouts
layout = _DatumWidget._init_ui(self)
sublayout = QHBoxLayout()
sublayout.addWidget(self._rdb_sum)
sublayout.addWidget(self._rdb_max)
sublayout.addWidget(self._rdb_single)
sublayout.addWidget(self._rdb_range)
layout.addLayout(sublayout)
sublayout = QFormLayout()
sublayout.setFieldGrowthPolicy(QFormLayout.ExpandingFieldsGrow) # Fix for Mac OS
sublayout.addRow('Channels (Start)', self._sld_start)
sublayout.addRow('Channels (End)', self._sld_end)
layout.addLayout(sublayout)
splitter = QSplitter()
splitter.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
splitter.addWidget(self._wdg_imageraster2d)
splitter.addWidget(self._wdg_analysis)
layout.addWidget(splitter)
# Signals
self._rdb_sum.toggled.connect(self._on_mode_sum)
self._rdb_max.toggled.connect(self._on_mode_max)
self._rdb_single.toggled.connect(self._on_mode_single)
self._rdb_range.toggled.connect(self._on_mode_range)
self._sld_start.valueChanged.connect(self._on_slide_start)
self._sld_end.valueChanged.connect(self._on_slide_end)
self._wdg_imageraster2d.valueSelected.connect(self._on_value_selected)
# Defaults
self.setMode(self.MODE_SUM)
return layout
def _add_tab(self, json=None):
"""will look at the json and will display the values in conflicts in a new tab to allow the user
to fix the conflicts"""
number_of_tabs = self.ui.tabWidget.count()
_table = QTableWidget()
# initialize each table
columns_width = self._calculate_columns_width(json=json)
for _col in np.arange(len(json[0])):
_table.insertColumn(_col)
_table.setColumnWidth(_col, columns_width[_col])
for _row in np.arange(len(json)):
_table.insertRow(_row)
self.list_table.append(_table)
_table.setHorizontalHeaderLabels(self.columns_label)
for _row in np.arange(len(json)):
# run number
_col = 0
list_runs = json[_row]["Run Number"]
o_parser = ListRunsParser()
checkbox = QRadioButton(o_parser.new_runs(list_runs=list_runs))
if _row == 0:
checkbox.setChecked(True)
# QtCore.QObject.connect(checkbox, QtCore.SIGNAL("clicked(bool)"),
# lambda bool, row=_row, table_id=_table:
# self._changed_conflict_checkbox(bool, row, table_id))
_table.setCellWidget(_row, _col, checkbox)
_col += 1
# chemical formula
item = QTableWidgetItem(json[_row]["chemical_formula"])
_table.setItem(_row, _col, item)
_col += 1
# geometry
item = QTableWidgetItem(json[_row]["geometry"])
_table.setItem(_row, _col, item)
_col += 1
# mass_density
item = QTableWidgetItem(json[_row]["mass_density"])
_table.setItem(_row, _col, item)
_col += 1
# sample_env_device
item = QTableWidgetItem(json[_row]["sample_env_device"])
_table.setItem(_row, _col, item)
self.ui.tabWidget.insertTab(number_of_tabs, _table, "Conflict #{}".format(number_of_tabs))
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):
model_group = QGroupBox(_('Half-space elastic model'))
lbl_model = QLabel(_("Model"))
lbl_vp = QLabel(_("Vp"))
lbl_vs = QLabel(_("Vs"))
lbl_ro = QLabel(_("Density"))
lbl_upp = QLabel(_("Upper space"))
self.le_upp_vp = QLineEdit()
self.le_upp_vs = QLineEdit()
self.le_upp_ro = QLineEdit()
lbl_low = QLabel(_("Lower space"))
self.le_low_vp = QLineEdit()
self.le_low_vs = QLineEdit()
self.le_low_ro = QLineEdit()
model_layout = QGridLayout()
model_layout.addWidget(lbl_model, 0, 0)
model_layout.addWidget(lbl_vp, 0, 1)
model_layout.addWidget(lbl_vs, 0, 2)
model_layout.addWidget(lbl_ro, 0, 3)
model_layout.addWidget(lbl_upp, 1, 0)
model_layout.addWidget(self.le_upp_vp, 1, 1)
model_layout.addWidget(self.le_upp_vs, 1, 2)
model_layout.addWidget(self.le_upp_ro, 1, 3)
model_layout.addWidget(lbl_low, 2, 0)
model_layout.addWidget(self.le_low_vp, 2, 1)
model_layout.addWidget(self.le_low_vs, 2, 2)
model_layout.addWidget(self.le_low_ro, 2, 3)
model_group.setLayout(model_layout)
self.layout.addWidget(model_group)
text = _("Incident angles")
self.angles = self.create_lineedit(text)
self.layout.addWidget(self.angles)
lbl_reflection = QLabel(_('Reflection'))
self.rb_pp = QRadioButton(_('PP'))
self.rb_ps = QRadioButton(_('PS'))
bg_reflection = QButtonGroup()
bg_reflection.addButton(self.rb_pp)
bg_reflection.addButton(self.rb_ps)
hbox = QHBoxLayout()
hbox.addWidget(lbl_reflection)
hbox.addWidget(self.rb_pp)
hbox.addWidget(self.rb_ps)
self.layout.addLayout(hbox)
lbl_complex = QLabel(_('Complex'))
self.rb_amp = QRadioButton(_('amplitude'))
self.rb_pha = QRadioButton(_('phase'))
bg_complex = QButtonGroup()
bg_complex.addButton(self.rb_amp)
bg_complex.addButton(self.rb_pha)
hbox = QHBoxLayout()
hbox.addWidget(lbl_complex)
hbox.addWidget(self.rb_amp)
hbox.addWidget(self.rb_pha)
self.layout.addLayout(hbox)
lbl_equation = QLabel(_('Equation'))
self.rb_linear = QRadioButton(_('Linear'))
self.rb_quadratic = QRadioButton(_('Quadratic'))
self.rb_zoeppritz = QRadioButton(_('Zoeppritz'))
bg_equation = QButtonGroup()
bg_equation.addButton(self.rb_linear)
bg_equation.addButton(self.rb_quadratic)
bg_equation.addButton(self.rb_zoeppritz)
hbox = QHBoxLayout()
hbox.addWidget(lbl_equation)
hbox.addWidget(self.rb_linear)
hbox.addWidget(self.rb_quadratic)
hbox.addWidget(self.rb_zoeppritz)
self.layout.addLayout(hbox)
text = _("New point")
self.new_point = self.create_lineedit(text)
self.layout.addWidget(self.new_point)
action = self.create_action()
self.layout.addWidget(action)
self.rb_linear.toggled.connect(
lambda: self.set_equation(self.rb_linear))
self.rb_quadratic.toggled.connect(
lambda: self.set_equation(self.rb_quadratic))
self.rb_zoeppritz.toggled.connect(
lambda: self.set_equation(self.rb_zoeppritz))
self.rb_zoeppritz.setChecked(True)
self.rb_pp.toggled.connect(lambda: self.set_reflection(self.rb_pp))
self.rb_ps.toggled.connect(lambda: self.set_reflection(self.rb_ps))
self.rb_pp.setChecked(True)
self.rb_amp.toggled.connect(lambda: self.set_complex(self.rb_amp))
self.rb_pha.toggled.connect(lambda: self.set_complex(self.rb_pha))
self.rb_amp.setChecked(True)
class ProjectDialog(QDialog):
"""Project creation dialog."""
# path, type, packages
sig_project_creation_requested = Signal(object, object, object)
def __init__(self, parent):
"""Project creation dialog."""
super(ProjectDialog, self).__init__(parent=parent)
# Variables
current_python_version = '.'.join([to_text_string(sys.version_info[0]),
to_text_string(sys.version_info[1])])
python_versions = ['2.7', '3.4', '3.5']
if current_python_version not in python_versions:
python_versions.append(current_python_version)
python_versions = sorted(python_versions)
self.project_name = None
self.location = get_home_dir()
# Widgets
self.groupbox = QGroupBox()
self.radio_new_dir = QRadioButton(_("New directory"))
self.radio_from_dir = QRadioButton(_("Existing directory"))
self.label_project_name = QLabel(_('Project name'))
self.label_location = QLabel(_('Location'))
self.label_project_type = QLabel(_('Project type'))
self.label_python_version = QLabel(_('Python version'))
self.text_project_name = QLineEdit()
self.text_location = QLineEdit(get_home_dir())
self.combo_project_type = QComboBox()
self.combo_python_version = QComboBox()
self.button_select_location = QToolButton()
self.button_cancel = QPushButton(_('Cancel'))
self.button_create = QPushButton(_('Create'))
self.bbox = QDialogButtonBox(Qt.Horizontal)
self.bbox.addButton(self.button_cancel, QDialogButtonBox.ActionRole)
self.bbox.addButton(self.button_create, QDialogButtonBox.ActionRole)
# Widget setup
self.combo_python_version.addItems(python_versions)
self.radio_new_dir.setChecked(True)
self.text_location.setEnabled(True)
self.text_location.setReadOnly(True)
self.button_select_location.setIcon(get_std_icon('DirOpenIcon'))
self.button_cancel.setDefault(True)
self.button_cancel.setAutoDefault(True)
self.button_create.setEnabled(False)
self.combo_project_type.addItems(self._get_project_types())
self.combo_python_version.setCurrentIndex(
python_versions.index(current_python_version))
self.setWindowTitle(_('Create new project'))
self.setFixedWidth(500)
self.label_python_version.setVisible(False)
self.combo_python_version.setVisible(False)
# Layouts
layout_top = QHBoxLayout()
layout_top.addWidget(self.radio_new_dir)
layout_top.addWidget(self.radio_from_dir)
layout_top.addStretch(1)
self.groupbox.setLayout(layout_top)
layout_grid = QGridLayout()
layout_grid.addWidget(self.label_project_name, 0, 0)
layout_grid.addWidget(self.text_project_name, 0, 1, 1, 2)
layout_grid.addWidget(self.label_location, 1, 0)
layout_grid.addWidget(self.text_location, 1, 1)
layout_grid.addWidget(self.button_select_location, 1, 2)
layout_grid.addWidget(self.label_project_type, 2, 0)
layout_grid.addWidget(self.combo_project_type, 2, 1, 1, 2)
layout_grid.addWidget(self.label_python_version, 3, 0)
layout_grid.addWidget(self.combo_python_version, 3, 1, 1, 2)
layout = QVBoxLayout()
layout.addWidget(self.groupbox)
layout.addSpacing(10)
layout.addLayout(layout_grid)
layout.addStretch()
layout.addSpacing(20)
layout.addWidget(self.bbox)
self.setLayout(layout)
# Signals and slots
self.button_select_location.clicked.connect(self.select_location)
self.button_create.clicked.connect(self.create_project)
self.button_cancel.clicked.connect(self.close)
self.radio_from_dir.clicked.connect(self.update_location)
self.radio_new_dir.clicked.connect(self.update_location)
self.text_project_name.textChanged.connect(self.update_location)
def _get_project_types(self):
"""Get all available project types."""
project_types = get_available_project_types()
projects = []
for project in project_types:
projects.append(project.PROJECT_TYPE_NAME)
return projects
def select_location(self):
"""Select directory."""
location = osp.normpath(getexistingdirectory(self,
_("Select directory"),
self.location))
if location:
if is_writable(location):
self.location = location
self.update_location()
def update_location(self, text=''):
"""Update text of location."""
self.text_project_name.setEnabled(self.radio_new_dir.isChecked())
name = self.text_project_name.text().strip()
if name and self.radio_new_dir.isChecked():
path = osp.join(self.location, name)
self.button_create.setDisabled(os.path.isdir(path))
elif self.radio_from_dir.isChecked():
self.button_create.setEnabled(True)
path = self.location
else:
self.button_create.setEnabled(False)
path = self.location
self.text_location.setText(path)
def create_project(self):
"""Create project."""
packages = ['python={0}'.format(self.combo_python_version.currentText())]
self.sig_project_creation_requested.emit(
self.text_location.text(),
self.combo_project_type.currentText(),
packages)
self.accept()
class _ImageRaster2DSpectralWidget(_DatumWidget):
MODE_SUM = 'sum'
MODE_MAX = 'max'
MODE_SINGLE = 'single'
MODE_RANGE = 'range'
def __init__(self, controller, datum=None, parent=None):
self._datum = datum
_DatumWidget.__init__(self, ImageRaster2DSpectral, controller,
datum, parent)
def _init_ui(self):
# Widgets
self._rdb_sum = QRadioButton("Sum")
self._rdb_sum.setChecked(True)
self._rdb_max = QRadioButton("Maximum")
self._rdb_single = QRadioButton("Single")
self._rdb_range = QRadioButton("Range")
self._sld_start = QSlider(Qt.Horizontal)
self._sld_start.setTickPosition(QSlider.TicksBelow)
self._sld_start.setEnabled(False)
self._sld_end = QSlider(Qt.Horizontal)
self._sld_end.setTickPosition(QSlider.TicksBelow)
self._sld_end.setEnabled(False)
self._wdg_imageraster2d = self._create_imageraster2d_widget()
self._wdg_analysis = self._create_analysis1d_widget()
# Layouts
layout = _DatumWidget._init_ui(self)
sublayout = QHBoxLayout()
sublayout.addWidget(self._rdb_sum)
sublayout.addWidget(self._rdb_max)
sublayout.addWidget(self._rdb_single)
sublayout.addWidget(self._rdb_range)
layout.addLayout(sublayout)
sublayout = QFormLayout()
sublayout.setFieldGrowthPolicy(QFormLayout.ExpandingFieldsGrow) # Fix for Mac OS
sublayout.addRow('Channels (Start)', self._sld_start)
sublayout.addRow('Channels (End)', self._sld_end)
layout.addLayout(sublayout)
splitter = QSplitter()
splitter.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
splitter.addWidget(self._wdg_imageraster2d)
splitter.addWidget(self._wdg_analysis)
layout.addWidget(splitter)
# Signals
self._rdb_sum.toggled.connect(self._on_mode_sum)
self._rdb_max.toggled.connect(self._on_mode_max)
self._rdb_single.toggled.connect(self._on_mode_single)
self._rdb_range.toggled.connect(self._on_mode_range)
self._sld_start.valueChanged.connect(self._on_slide_start)
self._sld_end.valueChanged.connect(self._on_slide_end)
self._wdg_imageraster2d.valueSelected.connect(self._on_value_selected)
# Defaults
self.setMode(self.MODE_SUM)
return layout
def _create_analysis1d_widget(self):
raise NotImplementedError
def _create_imageraster2d_widget(self):
raise NotImplementedError
def _on_mode_sum(self, checked):
if checked:
self.setMode(self.MODE_SUM)
def _on_mode_max(self, checked):
if checked:
self.setMode(self.MODE_MAX)
def _on_mode_single(self, checked):
if checked:
self.setMode(self.MODE_SINGLE)
def _on_mode_range(self, checked):
if checked:
self.setMode(self.MODE_RANGE)
def _update_data(self, mode=None):
if mode is None:
mode = self.mode()
if mode == self.MODE_SUM:
self._update_mode_sum()
elif mode == self.MODE_MAX:
self._update_mode_max()
elif mode == self.MODE_SINGLE:
self._update_mode_single()
elif mode == self.MODE_RANGE:
self._update_mode_range()
def _update_mode_sum(self):
if self._datum is None:
return
subdatum = np.sum(self._datum, 2)
self._wdg_imageraster2d.setDatum(subdatum)
def _update_mode_max(self):
if self._datum is None:
return
subdatum = np.amax(self._datum, 2)
self._wdg_imageraster2d.setDatum(subdatum)
def _update_mode_single(self):
if self._datum is None:
return
channel = self._sld_start.value()
subdatum = self._datum[:, :, channel]
self._wdg_imageraster2d.setDatum(subdatum)
def _update_mode_range(self):
if self._datum is None:
return
start = self._sld_start.value()
end = self._sld_end.value()
start2 = min(start, end)
end2 = max(start, end)
subdatum = np.sum(self._datum[:, :, start2:end2 + 1], 2)
self._wdg_imageraster2d.setDatum(subdatum)
def _on_slide_start(self, channel):
if self._rdb_single.isChecked():
self._update_mode_single()
elif self._rdb_range.isChecked():
self._update_mode_range()
def _on_slide_end(self, channel):
self._update_mode_range()
def _on_value_selected(self, x, y):
if self._datum is None:
return
subdatum = self._datum[x, y]
self._wdg_analysis.setDatum(subdatum.view(Analysis1D))
def setDatum(self, datum):
_DatumWidget.setDatum(self, datum)
self._datum = datum
maximum = datum.channels - 1 if datum is not None else 0
self._sld_start.setMaximum(maximum)
self._sld_end.setMaximum(maximum)
self._update_data()
def setMode(self, mode):
rsum = rmax = rsingle = rrange = False
sstart = send = False
if mode == self.MODE_SUM:
rsum = True
elif mode == self.MODE_MAX:
rmax = True
elif mode == self.MODE_SINGLE:
rsingle = True
sstart = True
elif mode == self.MODE_RANGE:
rrange = True
sstart = send = True
else:
raise ValueError('Unknown mode')
self._rdb_sum.setChecked(rsum)
self._rdb_max.setChecked(rmax)
self._rdb_single.setChecked(rsingle)
self._rdb_range.setChecked(rrange)
self._sld_start.setEnabled(sstart)
self._sld_end.setEnabled(send)
self._update_data(mode)
def mode(self):
if self._rdb_sum.isChecked():
return self.MODE_SUM
elif self._rdb_max.isChecked():
return self.MODE_MAX
elif self._rdb_single.isChecked():
return self.MODE_SINGLE
elif self._rdb_range.isChecked():
return self.MODE_RANGE
else:
raise ValueError('Unknown mode')
class RunConfigOptions(QWidget):
"""Run configuration options"""
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)
def select_directory(self):
"""Select directory"""
basedir = to_text_string(self.wd_edit.text())
if not osp.isdir(basedir):
basedir = getcwd()
directory = getexistingdirectory(self, _("Select directory"), basedir)
if directory:
self.wd_edit.setText(directory)
self.wd_cb.setChecked(True)
def set(self, options):
self.runconf.set(options)
self.clo_cb.setChecked(self.runconf.args_enabled)
self.clo_edit.setText(self.runconf.args)
self.wd_cb.setChecked(self.runconf.wdir_enabled)
self.wd_edit.setText(self.runconf.wdir)
if self.runconf.current:
self.current_radio.setChecked(True)
elif self.runconf.systerm:
self.systerm_radio.setChecked(True)
else:
self.dedicated_radio.setChecked(True)
self.interact_cb.setChecked(self.runconf.interact)
self.show_kill_warning_cb.setChecked(self.runconf.show_kill_warning)
self.post_mortem_cb.setChecked(self.runconf.post_mortem)
self.pclo_cb.setChecked(self.runconf.python_args_enabled)
self.pclo_edit.setText(self.runconf.python_args)
def get(self):
self.runconf.args_enabled = self.clo_cb.isChecked()
self.runconf.args = to_text_string(self.clo_edit.text())
self.runconf.wdir_enabled = self.wd_cb.isChecked()
self.runconf.wdir = to_text_string(self.wd_edit.text())
self.runconf.current = self.current_radio.isChecked()
self.runconf.systerm = self.systerm_radio.isChecked()
self.runconf.interact = self.interact_cb.isChecked()
self.runconf.show_kill_warning = self.show_kill_warning_cb.isChecked()
self.runconf.post_mortem = self.post_mortem_cb.isChecked()
self.runconf.python_args_enabled = self.pclo_cb.isChecked()
self.runconf.python_args = to_text_string(self.pclo_edit.text())
return self.runconf.get()
def is_valid(self):
wdir = to_text_string(self.wd_edit.text())
if not self.wd_cb.isChecked() or osp.isdir(wdir):
return True
else:
QMessageBox.critical(
self, _("Run configuration"), _("The following working directory is " "not valid:<br><b>%s</b>") % wdir
)
return False
def set_firstrun_o(self):
CONF.set("run", ALWAYS_OPEN_FIRST_RUN_OPTION, self.firstrun_cb.isChecked())
class RunConfigOptions(QWidget):
"""Run configuration options"""
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 select_directory(self):
"""Select directory"""
basedir = to_text_string(self.wd_edit.text())
if not osp.isdir(basedir):
basedir = getcwd_or_home()
directory = getexistingdirectory(self, _("Select directory"), basedir)
if directory:
self.wd_edit.setText(directory)
self.dir = directory
def set(self, options):
self.runconf.set(options)
self.clo_cb.setChecked(self.runconf.args_enabled)
self.clo_edit.setText(self.runconf.args)
if self.runconf.current:
self.current_radio.setChecked(True)
elif self.runconf.systerm:
self.systerm_radio.setChecked(True)
else:
self.dedicated_radio.setChecked(True)
self.interact_cb.setChecked(self.runconf.interact)
self.post_mortem_cb.setChecked(self.runconf.post_mortem)
self.pclo_cb.setChecked(self.runconf.python_args_enabled)
self.pclo_edit.setText(self.runconf.python_args)
self.clear_var_cb.setChecked(self.runconf.clear_namespace)
self.file_dir_radio.setChecked(self.runconf.file_dir)
self.cwd_radio.setChecked(self.runconf.cw_dir)
self.fixed_dir_radio.setChecked(self.runconf.fixed_dir)
self.dir = self.runconf.dir
self.wd_edit.setText(self.dir)
def get(self):
self.runconf.args_enabled = self.clo_cb.isChecked()
self.runconf.args = to_text_string(self.clo_edit.text())
self.runconf.current = self.current_radio.isChecked()
self.runconf.systerm = self.systerm_radio.isChecked()
self.runconf.interact = self.interact_cb.isChecked()
self.runconf.post_mortem = self.post_mortem_cb.isChecked()
self.runconf.python_args_enabled = self.pclo_cb.isChecked()
self.runconf.python_args = to_text_string(self.pclo_edit.text())
self.runconf.clear_namespace = self.clear_var_cb.isChecked()
self.runconf.file_dir = self.file_dir_radio.isChecked()
self.runconf.cw_dir = self.cwd_radio.isChecked()
self.runconf.fixed_dir = self.fixed_dir_radio.isChecked()
self.runconf.dir = self.wd_edit.text()
return self.runconf.get()
def is_valid(self):
wdir = to_text_string(self.wd_edit.text())
if not self.fixed_dir_radio.isChecked() or osp.isdir(wdir):
return True
else:
QMessageBox.critical(self, _("Run configuration"),
_("The following working directory is "
"not valid:<br><b>%s</b>") % wdir)
return False
def set_firstrun_o(self):
CONF.set('run', ALWAYS_OPEN_FIRST_RUN_OPTION,
self.firstrun_cb.isChecked())
class ImportDialog(DialogBase):
"""Import project from folder or specification files."""
CONDA_ENV_FILES = 'Conda environment files (*.yaml *.yml)'
CONDA_SPEC_FILES = 'Conda explicit specification files (*.txt)'
PIP_REQUIREMENT_FILES = 'Pip requirement files (*.txt)'
def __init__(self, parent=None, projects=None):
"""Import project from folder or environment files."""
super(ImportDialog, self).__init__(parent=parent)
self.projects = projects if projects else {}
self.selected_file_filter = None
self._path = None
# Widgets
self.label_info = LabelSpecInfo('', parent=self)
self.label_name = QLabel("Project name")
self.label_path = QLabel("Specification File")
self.text_name = QLineEdit()
self.text_path = QLineEdit()
self.button_path = ButtonNormal("")
self.radio_folder = QRadioButton('From folder')
self.radio_spec = QRadioButton('From specification file')
self.button_cancel = ButtonNormal('Cancel')
self.button_ok = ButtonPrimary('Import')
# Widgets setup
self.button_path.setObjectName('import')
self.button_ok.setDefault(True)
self.text_path.setPlaceholderText("File to import from")
self.text_name.setPlaceholderText("New project name")
self.setMinimumWidth(380)
self.setWindowTitle("Import new project")
self.text_name.setValidator(get_regex_validator())
# Layouts
layout_radio = QHBoxLayout()
layout_radio.addWidget(self.radio_folder)
layout_radio.addWidget(SpacerHorizontal())
layout_radio.addWidget(self.radio_spec)
layout_infile = QHBoxLayout()
layout_infile.addWidget(self.text_path)
layout_infile.addWidget(SpacerHorizontal())
layout_infile.addWidget(self.button_path)
layout_grid = QGridLayout()
layout_grid.addWidget(self.label_name, 0, 0, 1, 2)
layout_grid.addWidget(SpacerHorizontal(), 0, 2)
layout_grid.addWidget(self.text_name, 0, 3)
layout_grid.addWidget(SpacerVertical(), 1, 0)
layout_grid.addWidget(self.label_path, 2, 0)
layout_grid.addWidget(self.label_info, 2, 1)
layout_grid.addWidget(SpacerHorizontal(), 2, 2)
layout_grid.addLayout(layout_infile, 2, 3)
layout_buttons = QHBoxLayout()
layout_buttons.addStretch()
layout_buttons.addWidget(self.button_cancel)
layout_buttons.addWidget(SpacerHorizontal())
layout_buttons.addWidget(self.button_ok)
layout = QVBoxLayout()
layout.addLayout(layout_radio)
layout.addWidget(SpacerVertical())
layout.addLayout(layout_grid)
layout.addWidget(SpacerVertical())
layout.addWidget(SpacerVertical())
layout.addLayout(layout_buttons)
self.setLayout(layout)
# Signals
self.button_ok.clicked.connect(self.accept)
self.button_cancel.clicked.connect(self.reject)
self.button_path.clicked.connect(self.choose)
self.text_path.textChanged.connect(self.refresh)
self.text_name.textChanged.connect(self.refresh)
self.radio_folder.toggled.connect(self.refresh)
self.radio_spec.toggled.connect(self.refresh)
# Setup
self.radio_folder.toggle()
self.refresh()
def refresh(self, text=''):
"""Update the status of buttons based on radio selection."""
if self.radio_folder.isChecked():
self.text_path.setPlaceholderText("Folder to import from")
self.label_path.setText('Folder')
self.label_info.setVisible(False)
else:
self.label_info.setVisible(True)
self.label_path.setText('File ')
self.text_path.setPlaceholderText("File to import from")
text = self.text_name.text()
path = self.text_path.text()
if (text and path and os.path.exists(path)
and is_valid_project_name(text, self.projects)):
self.button_ok.setDisabled(False)
self.button_ok.setDefault(True)
else:
self.button_ok.setDisabled(True)
self.button_cancel.setDefault(True)
def choose(self):
"""Display file dialog to select environment specification."""
selected_filter = None
if self.radio_spec.isChecked():
path, selected_filter = getopenfilename(
caption="Import Project",
basedir=HOME_PATH,
parent=None,
filters="{0};;{1};;{2}".format(self.CONDA_ENV_FILES,
self.CONDA_SPEC_FILES,
self.PIP_REQUIREMENT_FILES))
else:
path = getexistingdirectory(
caption="Import Project",
basedir=HOME_PATH,
parent=None,
)
if path:
name = self.text_name.text()
self.selected_file_filter = selected_filter
self.text_path.setText(path)
self.refresh(path)
self.text_name.setText(name)
@property
def name(self):
"""Return the project name."""
return self.text_name.text().strip()
@property
def path(self):
"""Return the project path to import (file or folder)."""
return self.text_path.text()
class ContentsWidget(QWidget):
"""Import wizard contents widget"""
asDataChanged = Signal(bool)
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)
self.ws_btn = QRadioButton(_("Whitespace"))
self.ws_btn.setChecked(False)
col_btn_layout.addWidget(self.ws_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 get_as_data(self):
"""Return if data type conversion"""
return self._as_data
def get_as_code(self):
"""Return if code type conversion"""
return self._as_code
def get_as_num(self):
"""Return if numeric type conversion"""
return self._as_num
def get_col_sep(self):
"""Return the column separator"""
if self.tab_btn.isChecked():
return u"\t"
elif self.ws_btn.isChecked():
return None
return to_text_string(self.line_edt.text())
def get_row_sep(self):
"""Return the row separator"""
if self.eol_btn.isChecked():
return u"\n"
return to_text_string(self.line_edt_row.text())
def get_skiprows(self):
"""Return number of lines to be skipped"""
return int(to_text_string(self.skiprows_edt.text()))
def get_comments(self):
"""Return comment string"""
return to_text_string(self.comments_edt.text())
@Slot(bool)
def set_as_data(self, as_data):
"""Set if data type conversion"""
self._as_data = as_data
self.asDataChanged.emit(as_data)
@Slot(bool)
def set_as_code(self, as_code):
"""Set if code type conversion"""
self._as_code = as_code
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)
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.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.save_connection_settings)
self.accept_btns.accepted.connect(self.accept)
self.accept_btns.rejected.connect(self.reject)
# Save connection settings checkbox
self.save_layout = QCheckBox(self)
self.save_layout.setText(_("Save connection settings"))
btns_layout = QHBoxLayout()
btns_layout.addWidget(self.save_layout)
btns_layout.addWidget(self.accept_btns)
# 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.addLayout(btns_layout)
self.load_connection_settings()
def load_connection_settings(self):
"""Load the user's previously-saved kernel connection settings."""
existing_kernel = CONF.get("existing-kernel", "settings", {})
connection_file_path = existing_kernel.get("json_file_path", "")
is_remote = existing_kernel.get("is_remote", False)
username = existing_kernel.get("username", "")
hostname = existing_kernel.get("hostname", "")
port = str(existing_kernel.get("port", 22))
is_ssh_kf = existing_kernel.get("is_ssh_keyfile", False)
ssh_kf = existing_kernel.get("ssh_key_file_path", "")
if connection_file_path != "":
self.cf.setText(connection_file_path)
if username != "":
self.un.setText(username)
if hostname != "":
self.hn.setText(hostname)
if ssh_kf != "":
self.kf.setText(ssh_kf)
self.rm_group.setChecked(is_remote)
self.pn.setText(port)
self.kf_radio.setChecked(is_ssh_kf)
self.pw_radio.setChecked(not is_ssh_kf)
try:
import keyring
ssh_passphrase = keyring.get_password("spyder_remote_kernel",
"ssh_key_passphrase")
ssh_password = keyring.get_password("spyder_remote_kernel",
"ssh_password")
if ssh_passphrase:
self.kfp.setText(ssh_passphrase)
if ssh_password:
self.pw.setText(ssh_password)
except Exception:
pass
def save_connection_settings(self):
"""Save user's kernel connection settings."""
if not self.save_layout.isChecked():
return
is_ssh_key = bool(self.kf_radio.isChecked())
connection_settings = {
"json_file_path": self.cf.text(),
"is_remote": self.rm_group.isChecked(),
"username": self.un.text(),
"hostname": self.hn.text(),
"port": self.pn.text(),
"is_ssh_keyfile": is_ssh_key,
"ssh_key_file_path": self.kf.text()
}
CONF.set("existing-kernel", "settings", connection_settings)
try:
import keyring
if is_ssh_key:
keyring.set_password("spyder_remote_kernel",
"ssh_key_passphrase",
self.kfp.text())
else:
keyring.set_password("spyder_remote_kernel",
"ssh_password",
self.pw.text())
except Exception:
pass
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, img):
QFrame.__init__(self)
# self.setFrameStyle(QFrame.Box | QFrame.Sunken)
self.img = img
self.mixer = ColorMixer(self.img)
self.callback = None
#---------------------------------------------------------------
# ComboBox
#---------------------------------------------------------------
self.combo_box_entries = ['RGB Color', 'HSV Color',
'Brightness/Contrast',
'Gamma',
'Gamma (Sigmoidal)']
self.combo_box = QComboBox()
for entry in self.combo_box_entries:
self.combo_box.addItem(entry)
self.combo_box.currentIndexChanged.connect(self.combo_box_changed)
#---------------------------------------------------------------
# RGB color sliders
#---------------------------------------------------------------
# radio buttons
self.rgb_add = QRadioButton('Additive')
self.rgb_mul = QRadioButton('Multiplicative')
self.rgb_mul.toggled.connect(self.rgb_radio_changed)
self.rgb_add.toggled.connect(self.rgb_radio_changed)
# sliders
rs = IntelligentSlider('R', 0.51, -255, self.rgb_changed)
gs = IntelligentSlider('G', 0.51, -255, self.rgb_changed)
bs = IntelligentSlider('B', 0.51, -255, self.rgb_changed)
self.rs = rs
self.gs = gs
self.bs = bs
self.rgb_widget = QWidget()
self.rgb_widget.layout = QGridLayout(self.rgb_widget)
self.rgb_widget.layout.addWidget(self.rgb_add, 0, 0, 1, 3)
self.rgb_widget.layout.addWidget(self.rgb_mul, 1, 0, 1, 3)
self.rgb_widget.layout.addWidget(self.rs, 2, 0)
self.rgb_widget.layout.addWidget(self.gs, 2, 1)
self.rgb_widget.layout.addWidget(self.bs, 2, 2)
#---------------------------------------------------------------
# HSV sliders
#---------------------------------------------------------------
# radio buttons
self.hsv_add = QRadioButton('Additive')
self.hsv_mul = QRadioButton('Multiplicative')
self.hsv_mul.toggled.connect(self.hsv_radio_changed)
self.hsv_mul.toggled.connect(self.hsv_radio_changed)
# sliders
hs = IntelligentSlider('H', 0.36, -180, self.hsv_changed)
ss = IntelligentSlider('S', 0.002, 0, self.hsv_changed)
vs = IntelligentSlider('V', 0.002, 0, self.hsv_changed)
self.hs = hs
self.ss = ss
self.vs = vs
self.hsv_widget = QWidget()
self.hsv_widget.layout = QGridLayout(self.hsv_widget)
self.hsv_widget.layout.addWidget(self.hsv_add, 0, 0, 1, 3)
self.hsv_widget.layout.addWidget(self.hsv_mul, 1, 0, 1, 3)
self.hsv_widget.layout.addWidget(self.hs, 2, 0)
self.hsv_widget.layout.addWidget(self.ss, 2, 1)
self.hsv_widget.layout.addWidget(self.vs, 2, 2)
#---------------------------------------------------------------
# Brightness/Contrast sliders
#---------------------------------------------------------------
# sliders
cont = IntelligentSlider('x', 0.002, 0, self.bright_changed)
bright = IntelligentSlider('+', 0.51, -255, self.bright_changed)
self.cont = cont
self.bright = bright
# layout
self.bright_widget = QWidget()
self.bright_widget.layout = QGridLayout(self.bright_widget)
self.bright_widget.layout.addWidget(self.cont, 0, 0)
self.bright_widget.layout.addWidget(self.bright, 0, 1)
#----------------------------------------------------------------------
# Gamma Slider
#----------------------------------------------------------------------
gamma = IntelligentSlider('gamma', 0.005, 0, self.gamma_changed)
self.gamma = gamma
# layout
self.gamma_widget = QWidget()
self.gamma_widget.layout = QGridLayout(self.gamma_widget)
self.gamma_widget.layout.addWidget(self.gamma, 0, 0)
#---------------------------------------------------------------
# Sigmoid Gamma sliders
#---------------------------------------------------------------
# sliders
alpha = IntelligentSlider('alpha', 0.011, 1, self.sig_gamma_changed)
beta = IntelligentSlider('beta', 0.012, 0, self.sig_gamma_changed)
self.a_gamma = alpha
self.b_gamma = beta
# layout
self.sig_gamma_widget = QWidget()
self.sig_gamma_widget.layout = QGridLayout(self.sig_gamma_widget)
self.sig_gamma_widget.layout.addWidget(self.a_gamma, 0, 0)
self.sig_gamma_widget.layout.addWidget(self.b_gamma, 0, 1)
#---------------------------------------------------------------
# Buttons
#---------------------------------------------------------------
self.commit_button = QPushButton('Commit')
self.commit_button.clicked.connect(self.commit_changes)
self.revert_button = QPushButton('Revert')
self.revert_button.clicked.connect(self.revert_changes)
#---------------------------------------------------------------
# Mixer Layout
#---------------------------------------------------------------
self.sliders = QStackedWidget()
self.sliders.addWidget(self.rgb_widget)
self.sliders.addWidget(self.hsv_widget)
self.sliders.addWidget(self.bright_widget)
self.sliders.addWidget(self.gamma_widget)
self.sliders.addWidget(self.sig_gamma_widget)
self.layout = QGridLayout(self)
self.layout.addWidget(self.combo_box, 0, 0)
self.layout.addWidget(self.sliders, 1, 0)
self.layout.addWidget(self.commit_button, 2, 0)
self.layout.addWidget(self.revert_button, 3, 0)
#---------------------------------------------------------------
# State Initialization
#---------------------------------------------------------------
self.combo_box.setCurrentIndex(0)
self.rgb_mul.setChecked(True)
self.hsv_mul.setChecked(True)
class MixerPanel(QFrame):
'''A color mixer to hook up to an image.
You pass the image you the panel to operate on
and it operates on that image in place. You also
pass a callback to be called to trigger a refresh.
This callback is called every time the mixer modifies
your image.'''
def __init__(self, img):
QFrame.__init__(self)
# self.setFrameStyle(QFrame.Box | QFrame.Sunken)
self.img = img
self.mixer = ColorMixer(self.img)
self.callback = None
#---------------------------------------------------------------
# ComboBox
#---------------------------------------------------------------
self.combo_box_entries = ['RGB Color', 'HSV Color',
'Brightness/Contrast',
'Gamma',
'Gamma (Sigmoidal)']
self.combo_box = QComboBox()
for entry in self.combo_box_entries:
self.combo_box.addItem(entry)
self.combo_box.currentIndexChanged.connect(self.combo_box_changed)
#---------------------------------------------------------------
# RGB color sliders
#---------------------------------------------------------------
# radio buttons
self.rgb_add = QRadioButton('Additive')
self.rgb_mul = QRadioButton('Multiplicative')
self.rgb_mul.toggled.connect(self.rgb_radio_changed)
self.rgb_add.toggled.connect(self.rgb_radio_changed)
# sliders
rs = IntelligentSlider('R', 0.51, -255, self.rgb_changed)
gs = IntelligentSlider('G', 0.51, -255, self.rgb_changed)
bs = IntelligentSlider('B', 0.51, -255, self.rgb_changed)
self.rs = rs
self.gs = gs
self.bs = bs
self.rgb_widget = QWidget()
self.rgb_widget.layout = QGridLayout(self.rgb_widget)
self.rgb_widget.layout.addWidget(self.rgb_add, 0, 0, 1, 3)
self.rgb_widget.layout.addWidget(self.rgb_mul, 1, 0, 1, 3)
self.rgb_widget.layout.addWidget(self.rs, 2, 0)
self.rgb_widget.layout.addWidget(self.gs, 2, 1)
self.rgb_widget.layout.addWidget(self.bs, 2, 2)
#---------------------------------------------------------------
# HSV sliders
#---------------------------------------------------------------
# radio buttons
self.hsv_add = QRadioButton('Additive')
self.hsv_mul = QRadioButton('Multiplicative')
self.hsv_mul.toggled.connect(self.hsv_radio_changed)
self.hsv_mul.toggled.connect(self.hsv_radio_changed)
# sliders
hs = IntelligentSlider('H', 0.36, -180, self.hsv_changed)
ss = IntelligentSlider('S', 0.002, 0, self.hsv_changed)
vs = IntelligentSlider('V', 0.002, 0, self.hsv_changed)
self.hs = hs
self.ss = ss
self.vs = vs
self.hsv_widget = QWidget()
self.hsv_widget.layout = QGridLayout(self.hsv_widget)
self.hsv_widget.layout.addWidget(self.hsv_add, 0, 0, 1, 3)
self.hsv_widget.layout.addWidget(self.hsv_mul, 1, 0, 1, 3)
self.hsv_widget.layout.addWidget(self.hs, 2, 0)
self.hsv_widget.layout.addWidget(self.ss, 2, 1)
self.hsv_widget.layout.addWidget(self.vs, 2, 2)
#---------------------------------------------------------------
# Brightness/Contrast sliders
#---------------------------------------------------------------
# sliders
cont = IntelligentSlider('x', 0.002, 0, self.bright_changed)
bright = IntelligentSlider('+', 0.51, -255, self.bright_changed)
self.cont = cont
self.bright = bright
# layout
self.bright_widget = QWidget()
self.bright_widget.layout = QGridLayout(self.bright_widget)
self.bright_widget.layout.addWidget(self.cont, 0, 0)
self.bright_widget.layout.addWidget(self.bright, 0, 1)
#----------------------------------------------------------------------
# Gamma Slider
#----------------------------------------------------------------------
gamma = IntelligentSlider('gamma', 0.005, 0, self.gamma_changed)
self.gamma = gamma
# layout
self.gamma_widget = QWidget()
self.gamma_widget.layout = QGridLayout(self.gamma_widget)
self.gamma_widget.layout.addWidget(self.gamma, 0, 0)
#---------------------------------------------------------------
# Sigmoid Gamma sliders
#---------------------------------------------------------------
# sliders
alpha = IntelligentSlider('alpha', 0.011, 1, self.sig_gamma_changed)
beta = IntelligentSlider('beta', 0.012, 0, self.sig_gamma_changed)
self.a_gamma = alpha
self.b_gamma = beta
# layout
self.sig_gamma_widget = QWidget()
self.sig_gamma_widget.layout = QGridLayout(self.sig_gamma_widget)
self.sig_gamma_widget.layout.addWidget(self.a_gamma, 0, 0)
self.sig_gamma_widget.layout.addWidget(self.b_gamma, 0, 1)
#---------------------------------------------------------------
# Buttons
#---------------------------------------------------------------
self.commit_button = QPushButton('Commit')
self.commit_button.clicked.connect(self.commit_changes)
self.revert_button = QPushButton('Revert')
self.revert_button.clicked.connect(self.revert_changes)
#---------------------------------------------------------------
# Mixer Layout
#---------------------------------------------------------------
self.sliders = QStackedWidget()
self.sliders.addWidget(self.rgb_widget)
self.sliders.addWidget(self.hsv_widget)
self.sliders.addWidget(self.bright_widget)
self.sliders.addWidget(self.gamma_widget)
self.sliders.addWidget(self.sig_gamma_widget)
self.layout = QGridLayout(self)
self.layout.addWidget(self.combo_box, 0, 0)
self.layout.addWidget(self.sliders, 1, 0)
self.layout.addWidget(self.commit_button, 2, 0)
self.layout.addWidget(self.revert_button, 3, 0)
#---------------------------------------------------------------
# State Initialization
#---------------------------------------------------------------
self.combo_box.setCurrentIndex(0)
self.rgb_mul.setChecked(True)
self.hsv_mul.setChecked(True)
def set_callback(self, callback):
self.callback = callback
def combo_box_changed(self, index):
self.sliders.setCurrentIndex(index)
self.reset()
def rgb_radio_changed(self):
self.reset()
def hsv_radio_changed(self):
self.reset()
def reset(self):
self.reset_sliders()
self.mixer.set_to_stateimg()
if self.callback:
self.callback()
def reset_sliders(self):
# handle changing the conversion factors necessary
if self.rgb_add.isChecked():
self.rs.set_conv_fac(0.51, -255)
self.rs.set_value(0)
self.gs.set_conv_fac(0.51, -255)
self.gs.set_value(0)
self.bs.set_conv_fac(0.51, -255)
self.bs.set_value(0)
else:
self.rs.set_conv_fac(0.002, 0)
self.rs.set_value(1.)
self.gs.set_conv_fac(0.002, 0)
self.gs.set_value(1.)
self.bs.set_conv_fac(0.002, 0)
self.bs.set_value(1.)
self.hs.set_value(0)
if self.hsv_add.isChecked():
self.ss.set_conv_fac(0.002, -1)
self.ss.set_value(0)
self.vs.set_conv_fac(0.002, -1)
self.vs.set_value(0)
else:
self.ss.set_conv_fac(0.002, 0)
self.ss.set_value(1.)
self.vs.set_conv_fac(0.002, 0)
self.vs.set_value(1.)
self.bright.set_value(0)
self.cont.set_value(1.)
self.gamma.set_value(1)
self.a_gamma.set_value(1)
self.b_gamma.set_value(0.5)
def rgb_changed(self, name, val):
if name == 'R':
channel = self.mixer.RED
elif name == 'G':
channel = self.mixer.GREEN
else:
channel = self.mixer.BLUE
if self.rgb_mul.isChecked():
self.mixer.multiply(channel, val)
elif self.rgb_add.isChecked():
self.mixer.add(channel, val)
else:
pass
if self.callback:
self.callback()
def hsv_changed(self, name, val):
h = self.hs.val()
s = self.ss.val()
v = self.vs.val()
if self.hsv_mul.isChecked():
self.mixer.hsv_multiply(h, s, v)
elif self.hsv_add.isChecked():
self.mixer.hsv_add(h, s, v)
else:
pass
if self.callback:
self.callback()
def bright_changed(self, name, val):
b = self.bright.val()
c = self.cont.val()
self.mixer.brightness(c, b)
if self.callback:
self.callback()
def gamma_changed(self, name, val):
self.mixer.gamma(val)
if self.callback:
self.callback()
def sig_gamma_changed(self, name, val):
ag = self.a_gamma.val()
bg = self.b_gamma.val()
self.mixer.sigmoid_gamma(ag, bg)
if self.callback:
self.callback()
def commit_changes(self):
self.mixer.commit_changes()
self.reset_sliders()
def revert_changes(self):
self.mixer.revert()
self.reset_sliders()
if self.callback:
self.callback()
class ImageRotationDialog(ExToolWindow):
def __init__(self, signal, axes, parent, plugin):
super(ImageRotationDialog, self).__init__(parent)
self.ui = parent
self.create_controls()
self.accepted.connect(self.ok)
self.rejected.connect(self.close_new)
self.signal = signal
self.plugin = plugin
self.new_out = None
self._connected_updates = False
if isinstance(axes, str):
axm = signal.signal.axes_manager
if axes.startswith("nav"):
axes = (axm._axes.index(axm.navigation_axes[0]),
axm._axes.index(axm.navigation_axes[1]))
elif axes.startswith("sig"):
axes = (axm._axes.index(axm.signal_axes[0]),
axm._axes.index(axm.signal_axes[1]))
self.axes = axes
self.setWindowTitle(tr("Rotate"))
# TODO: TAG: Functionality check
if not hasattr(signal.signal, 'events'):
self.gbo_preview.setVisible(False)
# TODO: Add dynamic rotation, e.g. one that rotates when source
# signal's data_changed event triggers
def connect(self):
# TODO: Don't have to con/dis those in gbo
self.opt_new.toggled.connect(self.close_new)
self.num_angle.valueChanged.connect(self.update)
self.chk_grid.toggled.connect(self.update)
self.num_grid.valueChanged.connect(self.update)
self.chk_reshape.toggled.connect(self.update)
self.opt_new.toggled.connect(self.update)
self.opt_replace.toggled.connect(self.update)
def disconnect(self):
self.num_angle.valueChanged.disconnect(self.update)
self.chk_grid.toggled.disconnect(self.update)
self.num_grid.valueChanged.disconnect(self.update)
self.chk_reshape.toggled.disconnect(self.update)
self.opt_new.toggled.disconnect(self.update)
self.opt_replace.toggled.disconnect(self.update)
def ok(self):
# Draw figure if not already done
# TODO: TAG: Functionality check
if not hasattr(self.signal.signal, 'events') or \
not self.gbo_preview.isChecked():
self.update()
angle = self.num_angle.value()
reshape = self.chk_reshape.isChecked()
self.plugin.record_code(
r"<p>.rotate_signal({0}, reshape={1}, axes={2})".format(
angle, reshape, self.axes))
# Clean up event connections
if self.new_out is not None:
self.connect_update_plot(self.new_out.signal, disconnect=True)
def close_new(self, value=False):
if self.new_out is not None and not value:
self.new_out.close()
self.new_out = None
self._connected_updates = False
def set_preview(self, value):
if not hasattr(self.signal.signal, 'events'):
return
if value:
self.connect()
self.update()
else:
self.disconnect()
self.close_new()
def _axes_in_nav(self):
axm = self.signal.signal.axes_manager
navidx = [axm._axes.index(ax) for ax in axm.navigation_axes]
if self.axes[0] in navidx:
return True
return False
def connect_update_plot(self, signal, disconnect=False):
if self._connected_updates != disconnect:
return # Nothing to do, prevent double connections
if self._axes_in_nav():
f = signal._plot.navigator_plot.update
else:
f = signal._plot.signal_plot.update
# TODO: TAG: Functionality check
if hasattr(signal, 'events') and hasattr(
signal.events, 'data_changed'):
if disconnect:
signal.events.data_changed.disconnect(f)
else:
signal.events.data_changed.connect(f, [])
self._connected_updates = not disconnect
def update(self):
angle = self.num_angle.value()
reshape = self.chk_reshape.isChecked()
if self.opt_new.isChecked():
if self.new_out is None:
out = None
else:
out = self.new_out.signal
elif self.opt_replace.isChecked():
out = self.signal.signal
else:
return # Indeterminate state, do nothing
s = self.plugin.rotate_signal(angle, self.signal.signal, record=False,
reshape=reshape, out=out, axes=self.axes)
if out is None:
s.metadata.General.title = self.signal.name + "[Rotated]"
s.plot()
self.connect_update_plot(s)
if (self.gbo_preview.isChecked() and self.opt_new.isChecked() and
self.new_out is None):
self.new_out = self.ui.lut_signalwrapper[s]
else:
s = out
if self.chk_grid.isChecked() is True:
pass # TODO: Draw grid
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 __init__(self, parent):
"""Project creation dialog."""
super(ProjectDialog, self).__init__(parent=parent)
# Variables
current_python_version = '.'.join([to_text_string(sys.version_info[0]),
to_text_string(sys.version_info[1])])
python_versions = ['2.7', '3.4', '3.5']
if current_python_version not in python_versions:
python_versions.append(current_python_version)
python_versions = sorted(python_versions)
self.project_name = None
self.location = get_home_dir()
# Widgets
self.groupbox = QGroupBox()
self.radio_new_dir = QRadioButton(_("New directory"))
self.radio_from_dir = QRadioButton(_("Existing directory"))
self.label_project_name = QLabel(_('Project name'))
self.label_location = QLabel(_('Location'))
self.label_project_type = QLabel(_('Project type'))
self.label_python_version = QLabel(_('Python version'))
self.text_project_name = QLineEdit()
self.text_location = QLineEdit(get_home_dir())
self.combo_project_type = QComboBox()
self.combo_python_version = QComboBox()
self.button_select_location = QToolButton()
self.button_cancel = QPushButton(_('Cancel'))
self.button_create = QPushButton(_('Create'))
self.bbox = QDialogButtonBox(Qt.Horizontal)
self.bbox.addButton(self.button_cancel, QDialogButtonBox.ActionRole)
self.bbox.addButton(self.button_create, QDialogButtonBox.ActionRole)
# Widget setup
self.combo_python_version.addItems(python_versions)
self.radio_new_dir.setChecked(True)
self.text_location.setEnabled(True)
self.text_location.setReadOnly(True)
self.button_select_location.setIcon(get_std_icon('DirOpenIcon'))
self.button_cancel.setDefault(True)
self.button_cancel.setAutoDefault(True)
self.button_create.setEnabled(False)
self.combo_project_type.addItems(self._get_project_types())
self.combo_python_version.setCurrentIndex(
python_versions.index(current_python_version))
self.setWindowTitle(_('Create new project'))
self.setFixedWidth(500)
self.label_python_version.setVisible(False)
self.combo_python_version.setVisible(False)
# Layouts
layout_top = QHBoxLayout()
layout_top.addWidget(self.radio_new_dir)
layout_top.addWidget(self.radio_from_dir)
layout_top.addStretch(1)
self.groupbox.setLayout(layout_top)
layout_grid = QGridLayout()
layout_grid.addWidget(self.label_project_name, 0, 0)
layout_grid.addWidget(self.text_project_name, 0, 1, 1, 2)
layout_grid.addWidget(self.label_location, 1, 0)
layout_grid.addWidget(self.text_location, 1, 1)
layout_grid.addWidget(self.button_select_location, 1, 2)
layout_grid.addWidget(self.label_project_type, 2, 0)
layout_grid.addWidget(self.combo_project_type, 2, 1, 1, 2)
layout_grid.addWidget(self.label_python_version, 3, 0)
layout_grid.addWidget(self.combo_python_version, 3, 1, 1, 2)
layout = QVBoxLayout()
layout.addWidget(self.groupbox)
layout.addSpacing(10)
layout.addLayout(layout_grid)
layout.addStretch()
layout.addSpacing(20)
layout.addWidget(self.bbox)
self.setLayout(layout)
# Signals and slots
self.button_select_location.clicked.connect(self.select_location)
self.button_create.clicked.connect(self.create_project)
self.button_cancel.clicked.connect(self.close)
self.radio_from_dir.clicked.connect(self.update_location)
self.radio_new_dir.clicked.connect(self.update_location)
self.text_project_name.textChanged.connect(self.update_location)
def setup_page(self):
vbox = QVBoxLayout()
btnWidget = QWidget(self)
btnWidget.setLayout(vbox)
text = _("Object")
geom = ['Point', 'Line', 'Tsurface', 'Gsurface', 'Cube']
self.grabob = self.create_grabob(text, geom=geom)
vbox.addWidget(self.grabob)
text = _("Property")
self.prop = self.create_combobox(text)
btn_load_property = QPushButton(_('Load'))
btn_load_property.clicked.connect(self.load_property)
hbox = QHBoxLayout()
hbox.addWidget(self.prop)
hbox.addWidget(btn_load_property)
vbox.addLayout(hbox)
lbl_orientation = QLabel(_('Orientation'))
rb_top = QRadioButton('Top')
rb_bottom = QRadioButton('Bottom')
rb_left = QRadioButton('Left')
rb_right = QRadioButton('Right')
hbox = QHBoxLayout()
hbox.addWidget(lbl_orientation)
hbox.addWidget(rb_top)
hbox.addWidget(rb_bottom)
hbox.addWidget(rb_left)
hbox.addWidget(rb_right)
vbox.addLayout(hbox)
lbl_clip_min = QLabel(_('Clip minimum'))
lbl_clip_max = QLabel(_('Clip maximum'))
self.le_clip_min = QLineEdit('0')
self.le_clip_max = QLineEdit('1')
hbox = QHBoxLayout()
hbox.addWidget(lbl_clip_min)
hbox.addWidget(self.le_clip_min)
hbox.addWidget(lbl_clip_max)
hbox.addWidget(self.le_clip_max)
vbox.addLayout(hbox)
opacity = QLabel(_('Opacity'))
self.opacity = QSlider(Qt.Horizontal)
self.opacity.setTracking(False)
self.opacity.setTickPosition(QSlider.TicksBelow)
self.opacity.setSingleStep(1)
self.opacity.setRange(0, 255)
self.opacity.setValue(255)
self.opacity.valueChanged.connect(self.opacity_changed)
hbox = QHBoxLayout()
hbox.addWidget(opacity)
hbox.addWidget(self.opacity)
vbox.addLayout(hbox)
action = self.create_action()
vbox.addWidget(action)
hlut_right = HistogramLUTWidget(orientation='right',
gradients=customGradients)
hlut_left = HistogramLUTWidget(orientation='left',
gradients=customGradients)
hlut_bottom = HistogramLUTWidget(orientation='bottom',
gradients=customGradients)
hlut_top = HistogramLUTWidget(orientation='top',
gradients=customGradients)
lbl_hlut_help = QLabel("You can activate any one of the four.")
split1 = QSplitter(Qt.Vertical)
split1.addWidget(hlut_top)
split1.addWidget(lbl_hlut_help)
split1.addWidget(hlut_bottom)
# split1.setStretchFactor(0, 0)
# split1.setStretchFactor(1, 1)
# split1.setStretchFactor(2, 0)
# split1.setSizes([50, 400, 50])
split2 = QSplitter(Qt.Horizontal)
split2.addWidget(hlut_left)
split2.addWidget(split1)
split2.addWidget(hlut_right)
split3 = QSplitter(Qt.Vertical)
split3.addWidget(btnWidget)
split3.addWidget(split2)
self.layout.addWidget(split3)
# self.le_clip_min.editingFinished.connect(self.clip_changed)
# self.le_clip_max.editingFinished.connect(self.clip_changed)
self.hlut_list = [hlut_top, hlut_bottom, hlut_left, hlut_right]
rb_top.toggled.connect(lambda:self.set_orientation(rb_top))
rb_bottom.toggled.connect(lambda:self.set_orientation(rb_bottom))
rb_left.toggled.connect(lambda:self.set_orientation(rb_left))
rb_right.toggled.connect(lambda:self.set_orientation(rb_right))
rb_right.setChecked(True)
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)
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.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.save_connection_settings)
self.accept_btns.accepted.connect(self.accept)
self.accept_btns.rejected.connect(self.reject)
# Save connection settings checkbox
self.save_layout = QCheckBox(self)
self.save_layout.setText(_("Save connection settings"))
btns_layout = QHBoxLayout()
btns_layout.addWidget(self.save_layout)
btns_layout.addWidget(self.accept_btns)
# 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.addLayout(btns_layout)
self.load_connection_settings()
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 __init__(self, parent=None):
super(KernelConnectionDialog, self).__init__(parent)
self.setWindowTitle(_('Connect to an existing kernel'))
main_label = QLabel(
_("<p>Please select a local JSON connection file (<i>e.g.</i> "
"<tt>kernel-1234.json</tt>) of the existing kernel. "
"<br><br>"
"If connecting to a remote machine, enter the SSH information, "
"adjust the command how to get jupyter runtime directory (if needed) "
"push the button to fetch remote configuration files and select one "
"of the loaded options."
"<br><br>"
"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)
self.TEXT_FETCH_REMOTE_CONN_FILES_BTN = 'Fetch remote connection files'
self.DEFAULT_CMD_FOR_JUPYTER_RUNTIME = 'jupyter --runtime-dir'
# 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)
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)
# Button to fetch JSON files listing
self.kf_fetch_conn_files_btn = QPushButton(
_(self.TEXT_FETCH_REMOTE_CONN_FILES_BTN))
self.kf_fetch_conn_files_btn.clicked.connect(
self.fill_combobox_with_fetched_remote_connection_files)
self.cb_remote_conn_files = QComboBox()
self.cb_remote_conn_files.currentIndexChanged.connect(
self._take_over_selected_remote_configuration_file)
# Remote kernel groupbox
self.start_remote_kernel_group = QGroupBox(_("Start remote kernel"))
# Advanced settings to get remote connection files
jupyter_runtime_location_cmd_label = QLabel(
_('Command to get Jupyter runtime:'))
self.jupyter_runtime_location_cmd_lineedit = QLineEdit()
self.jupyter_runtime_location_cmd_lineedit.setPlaceholderText(
_(self.DEFAULT_CMD_FOR_JUPYTER_RUNTIME))
# 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_layout.addWidget(jupyter_runtime_location_cmd_label, 4, 1)
auth_layout.addWidget(self.jupyter_runtime_location_cmd_lineedit, 4, 2)
auth_layout.addWidget(self.kf_fetch_conn_files_btn, 5, 1)
auth_layout.addWidget(self.cb_remote_conn_files, 5, 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.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.save_connection_settings)
self.accept_btns.accepted.connect(self.accept)
self.accept_btns.rejected.connect(self.reject)
# Save connection settings checkbox
self.save_layout = QCheckBox(self)
self.save_layout.setText(_("Save connection settings"))
btns_layout = QHBoxLayout()
btns_layout.addWidget(self.save_layout)
btns_layout.addWidget(self.accept_btns)
# 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.addLayout(btns_layout)
# List with connection file paths found on the remote host
self.remote_conn_file_paths = []
self.load_connection_settings()
class RunConfigOptions(QWidget):
"""Run configuration options"""
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)
def select_directory(self):
"""Select directory"""
basedir = to_text_string(self.wd_edit.text())
if not osp.isdir(basedir):
basedir = getcwd()
directory = getexistingdirectory(self, _("Select directory"), basedir)
if directory:
self.wd_edit.setText(directory)
self.wd_cb.setChecked(True)
def set(self, options):
self.runconf.set(options)
self.clo_cb.setChecked(self.runconf.args_enabled)
self.clo_edit.setText(self.runconf.args)
self.wd_cb.setChecked(self.runconf.wdir_enabled)
self.wd_edit.setText(self.runconf.wdir)
if self.runconf.current:
self.current_radio.setChecked(True)
elif self.runconf.systerm:
self.systerm_radio.setChecked(True)
else:
self.dedicated_radio.setChecked(True)
self.interact_cb.setChecked(self.runconf.interact)
self.show_kill_warning_cb.setChecked(self.runconf.show_kill_warning)
self.post_mortem_cb.setChecked(self.runconf.post_mortem)
self.pclo_cb.setChecked(self.runconf.python_args_enabled)
self.pclo_edit.setText(self.runconf.python_args)
def get(self):
self.runconf.args_enabled = self.clo_cb.isChecked()
self.runconf.args = to_text_string(self.clo_edit.text())
self.runconf.wdir_enabled = self.wd_cb.isChecked()
self.runconf.wdir = to_text_string(self.wd_edit.text())
self.runconf.current = self.current_radio.isChecked()
self.runconf.systerm = self.systerm_radio.isChecked()
self.runconf.interact = self.interact_cb.isChecked()
self.runconf.show_kill_warning = self.show_kill_warning_cb.isChecked()
self.runconf.post_mortem = self.post_mortem_cb.isChecked()
self.runconf.python_args_enabled = self.pclo_cb.isChecked()
self.runconf.python_args = to_text_string(self.pclo_edit.text())
return self.runconf.get()
def is_valid(self):
wdir = to_text_string(self.wd_edit.text())
if not self.wd_cb.isChecked() or osp.isdir(wdir):
return True
else:
QMessageBox.critical(
self, _("Run configuration"),
_("The following working directory is "
"not valid:<br><b>%s</b>") % wdir)
return False
def set_firstrun_o(self):
CONF.set('run', ALWAYS_OPEN_FIRST_RUN_OPTION,
self.firstrun_cb.isChecked())
class FindOptions(QWidget):
"""Find widget with options"""
find = Signal()
stop = Signal()
def __init__(self, parent, search_text, search_text_regexp, search_path,
include, include_idx, include_regexp, exclude, exclude_idx,
exclude_regexp, supported_encodings, in_python_path,
more_options):
QWidget.__init__(self, parent)
if search_path is None:
search_path = getcwd()
if not isinstance(search_text, (list, tuple)):
search_text = [search_text]
if not isinstance(search_path, (list, tuple)):
search_path = [search_path]
if not isinstance(include, (list, tuple)):
include = [include]
if not isinstance(exclude, (list, tuple)):
exclude = [exclude]
self.supported_encodings = supported_encodings
# Layout 1
hlayout1 = QHBoxLayout()
self.search_text = PatternComboBox(self, search_text,
_("Search pattern"))
self.edit_regexp = create_toolbutton(self,
icon=ima.icon('advanced'),
tip=_('Regular expression'))
self.edit_regexp.setCheckable(True)
self.edit_regexp.setChecked(search_text_regexp)
self.more_widgets = ()
self.more_options = create_toolbutton(self,
toggled=self.toggle_more_options)
self.more_options.setCheckable(True)
self.more_options.setChecked(more_options)
self.ok_button = create_toolbutton(self,
text=_("Search"),
icon=ima.icon('DialogApplyButton'),
triggered=lambda: self.find.emit(),
tip=_("Start search"),
text_beside_icon=True)
self.ok_button.clicked.connect(self.update_combos)
self.stop_button = create_toolbutton(
self,
text=_("Stop"),
icon=ima.icon('stop'),
triggered=lambda: self.stop.emit(),
tip=_("Stop search"),
text_beside_icon=True)
self.stop_button.setEnabled(False)
for widget in [
self.search_text, self.edit_regexp, self.ok_button,
self.stop_button, self.more_options
]:
hlayout1.addWidget(widget)
# Layout 2
hlayout2 = QHBoxLayout()
self.include_pattern = PatternComboBox(self, include,
_("Included filenames pattern"))
if include_idx is not None and include_idx >= 0 \
and include_idx < self.include_pattern.count():
self.include_pattern.setCurrentIndex(include_idx)
self.include_regexp = create_toolbutton(self,
icon=ima.icon('advanced'),
tip=_('Regular expression'))
self.include_regexp.setCheckable(True)
self.include_regexp.setChecked(include_regexp)
include_label = QLabel(_("Include:"))
include_label.setBuddy(self.include_pattern)
self.exclude_pattern = PatternComboBox(self, exclude,
_("Excluded filenames pattern"))
if exclude_idx is not None and exclude_idx >= 0 \
and exclude_idx < self.exclude_pattern.count():
self.exclude_pattern.setCurrentIndex(exclude_idx)
self.exclude_regexp = create_toolbutton(self,
icon=ima.icon('advanced'),
tip=_('Regular expression'))
self.exclude_regexp.setCheckable(True)
self.exclude_regexp.setChecked(exclude_regexp)
exclude_label = QLabel(_("Exclude:"))
exclude_label.setBuddy(self.exclude_pattern)
for widget in [
include_label, self.include_pattern, self.include_regexp,
exclude_label, self.exclude_pattern, self.exclude_regexp
]:
hlayout2.addWidget(widget)
# Layout 3
hlayout3 = QHBoxLayout()
self.python_path = QRadioButton(_("PYTHONPATH"), self)
self.python_path.setChecked(in_python_path)
self.python_path.setToolTip(
_("Search in all directories listed in sys.path which"
" are outside the Python installation directory"))
self.hg_manifest = QRadioButton(_("Hg repository"), self)
self.detect_hg_repository()
self.hg_manifest.setToolTip(
_("Search in current directory hg repository"))
self.custom_dir = QRadioButton(_("Here:"), self)
self.custom_dir.setChecked(not in_python_path)
self.dir_combo = PathComboBox(self)
self.dir_combo.addItems(search_path)
self.dir_combo.setToolTip(_("Search recursively in this directory"))
self.dir_combo.open_dir.connect(self.set_directory)
self.python_path.toggled.connect(self.dir_combo.setDisabled)
self.hg_manifest.toggled.connect(self.dir_combo.setDisabled)
browse = create_toolbutton(self,
icon=ima.icon('DirOpenIcon'),
tip=_('Browse a search directory'),
triggered=self.select_directory)
for widget in [
self.python_path, self.hg_manifest, self.custom_dir,
self.dir_combo, browse
]:
hlayout3.addWidget(widget)
self.search_text.valid.connect(lambda valid: self.find.emit())
vlayout = QVBoxLayout()
vlayout.setContentsMargins(0, 0, 0, 0)
vlayout.addLayout(hlayout1)
vlayout.addLayout(hlayout2)
vlayout.addLayout(hlayout3)
self.more_widgets = (hlayout2, hlayout3)
self.toggle_more_options(more_options)
self.setLayout(vlayout)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
@Slot(bool)
def toggle_more_options(self, state):
for layout in self.more_widgets:
for index in range(layout.count()):
if state and self.isVisible() or not state:
layout.itemAt(index).widget().setVisible(state)
if state:
icon = ima.icon('options_less')
tip = _('Hide advanced options')
else:
icon = ima.icon('options_more')
tip = _('Show advanced options')
self.more_options.setIcon(icon)
self.more_options.setToolTip(tip)
def update_combos(self):
self.search_text.lineEdit().returnPressed.emit()
self.include_pattern.lineEdit().returnPressed.emit()
self.exclude_pattern.lineEdit().returnPressed.emit()
def detect_hg_repository(self, path=None):
if path is None:
path = getcwd()
hg_repository = is_hg_installed() and get_vcs_root(path) is not None
self.hg_manifest.setEnabled(hg_repository)
if not hg_repository and self.hg_manifest.isChecked():
self.custom_dir.setChecked(True)
def set_search_text(self, text):
if text:
self.search_text.add_text(text)
self.search_text.lineEdit().selectAll()
self.search_text.setFocus()
def get_options(self, all=False):
# Getting options
utext = to_text_string(self.search_text.currentText())
if not utext:
return
try:
texts = [(utext.encode('ascii'), 'ascii')]
except UnicodeEncodeError:
texts = []
for enc in self.supported_encodings:
try:
texts.append((utext.encode(enc), enc))
except UnicodeDecodeError:
pass
text_re = self.edit_regexp.isChecked()
include = to_text_string(self.include_pattern.currentText())
include_re = self.include_regexp.isChecked()
exclude = to_text_string(self.exclude_pattern.currentText())
exclude_re = self.exclude_regexp.isChecked()
python_path = self.python_path.isChecked()
hg_manifest = self.hg_manifest.isChecked()
path = osp.abspath(to_text_string(self.dir_combo.currentText()))
# Finding text occurrences
if not include_re:
include = fnmatch.translate(include)
if not exclude_re:
exclude = fnmatch.translate(exclude)
if all:
search_text = [to_text_string(self.search_text.itemText(index)) \
for index in range(self.search_text.count())]
search_path = [to_text_string(self.dir_combo.itemText(index)) \
for index in range(self.dir_combo.count())]
include = [to_text_string(self.include_pattern.itemText(index)) \
for index in range(self.include_pattern.count())]
include_idx = self.include_pattern.currentIndex()
exclude = [to_text_string(self.exclude_pattern.itemText(index)) \
for index in range(self.exclude_pattern.count())]
exclude_idx = self.exclude_pattern.currentIndex()
more_options = self.more_options.isChecked()
return (search_text, text_re, search_path, include, include_idx,
include_re, exclude, exclude_idx, exclude_re, python_path,
more_options)
else:
return (path, python_path, hg_manifest, include, exclude, texts,
text_re)
@Slot()
def select_directory(self):
"""Select directory"""
self.parent().redirect_stdio.emit(False)
directory = getexistingdirectory(self, _("Select directory"),
self.dir_combo.currentText())
if directory:
self.set_directory(directory)
self.parent().redirect_stdio.emit(True)
def set_directory(self, directory):
path = to_text_string(osp.abspath(to_text_string(directory)))
self.dir_combo.setEditText(path)
self.detect_hg_repository(path)
def keyPressEvent(self, event):
"""Reimplemented to handle key events"""
ctrl = event.modifiers() & Qt.ControlModifier
shift = event.modifiers() & Qt.ShiftModifier
if event.key() in (Qt.Key_Enter, Qt.Key_Return):
self.find.emit()
elif event.key() == Qt.Key_F and ctrl and shift:
# Toggle find widgets
self.parent().toggle_visibility.emit(not self.isVisible())
else:
QWidget.keyPressEvent(self, event)
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 SelectSmoothing(QDialog):
"""
SelectSmoothing launches a GUI and executes smoothing.
Any output is added to the input data as a new component.
"""
def __init__(self, data, parent=None, smooth_cube=None,
allow_preview=False, allow_spectral_axes=False):
super(SelectSmoothing, self).__init__(parent)
self.setWindowFlags(self.windowFlags() | Qt.Tool)
self.parent = parent
self.title = "Smoothing Selection"
self.data = data # Glue data to be smoothed
# Check if smooth object is the caller
if smooth_cube is None:
self.smooth_cube = SmoothCube(data=self.data)
else:
self.smooth_cube = smooth_cube
self.allow_spectral_axes = allow_spectral_axes
self.allow_preview = allow_preview
self.is_preview_active = False # Flag to show if smoothing preview is active
self.abort_window = None # Small window pop up when smoothing.
self.component_id = None # Glue data component to smooth over
self.current_axis = None # Selected smoothing_axis
self.current_kernel_type = None # Selected kernel type, a key in SmoothCube.kernel_registry
self.current_kernel_name = None # Name of selected kernel
self._init_selection_ui() # Format and show gui
def _init_selection_ui(self):
# LINE 1: Radio box spatial vs spectral axis
self.axes_prompt = QLabel("Smoothing Axis:")
self.axes_prompt.setMinimumWidth(150)
self.spatial_radio = QRadioButton("Spatial")
self.spatial_radio.setChecked(True)
self.current_axis = "spatial"
self.spatial_radio.toggled.connect(self.spatial_radio_checked)
self.spectral_radio = QRadioButton("Spectral")
self.spectral_radio.toggled.connect(self.spectral_radio_checked)
# hbl is short for Horizontal Box Layout
hbl1 = QHBoxLayout()
hbl1.addWidget(self.axes_prompt)
hbl1.addWidget(self.spatial_radio)
hbl1.addWidget(self.spectral_radio)
# LINE 2: Kernel Type prompt
self.k_type_prompt = QLabel("Kernel Type:")
self.k_type_prompt.setMinimumWidth(150)
# Load kernel types + names and add to drop down
self._load_options()
self.combo = QComboBox()
self.combo.setMinimumWidth(150)
self.combo.addItems(self.options[self.current_axis])
hbl2 = QHBoxLayout()
hbl2.addWidget(self.k_type_prompt)
hbl2.addWidget(self.combo)
# LINE 3: Kernel size
self.size_prompt = QLabel(self.smooth_cube.get_kernel_size_prompt(self.current_kernel_type))
self.size_prompt.setWordWrap(True)
self.size_prompt.setMinimumWidth(150)
self.unit_label = QLabel(self.smooth_cube.get_kernel_unit(self.current_kernel_type))
self.k_size = QLineEdit("1") # Default Kernel size set here
hbl3 = QHBoxLayout()
hbl3.addWidget(self.size_prompt)
hbl3.addWidget(self.k_size)
hbl3.addWidget(self.unit_label)
# LINE 4: Data component drop down
self.component_prompt = QLabel("Data Component:")
self.component_prompt.setWordWrap(True)
self.component_prompt.setMinimumWidth(150)
# Load component_ids and add to drop down
# Add the data component labels to the drop down, with the ComponentID
# set as the userData:
if self.parent is not None and hasattr(self.parent, 'data_components'):
labeldata = [(str(cid), cid) for cid in self.parent.data_components]
else:
labeldata = [(str(cid), cid) for cid in self.data.main_components()]
self.component_combo = QComboBox()
update_combobox(self.component_combo, labeldata)
self.component_combo.setMaximumWidth(150)
self.component_combo.setCurrentIndex(0)
if self.allow_preview:
self.component_combo.currentIndexChanged.connect(self.update_preview_button)
hbl4 = QHBoxLayout()
hbl4.addWidget(self.component_prompt)
hbl4.addWidget(self.component_combo)
# Line 5: Preview Message
message = "Info: Smoothing previews are displayed on " \
"CubeViz's left and single image viewers."
self.preview_message = QLabel(message)
self.preview_message.setWordWrap(True)
self.preview_message.hide()
hbl5 = QHBoxLayout()
hbl5.addWidget(self.preview_message)
# LINE 6: preview ok cancel buttons
self.previewButton = QPushButton("Preview Slice")
self.previewButton.clicked.connect(self.call_preview)
self.okButton = QPushButton("Smooth Cube")
self.okButton.clicked.connect(self.call_main)
self.okButton.setDefault(True)
self.cancelButton = QPushButton("Cancel")
self.cancelButton.clicked.connect(self.cancel)
hbl6 = QHBoxLayout()
hbl6.addStretch(1)
if self.allow_preview:
hbl6.addWidget(self.previewButton)
hbl6.addWidget(self.cancelButton)
hbl6.addWidget(self.okButton)
# Add Lines to Vertical Layout
# vbl is short for Vertical Box Layout
vbl = QVBoxLayout()
if self.allow_spectral_axes:
vbl.addLayout(hbl1)
vbl.addLayout(hbl2)
vbl.addLayout(hbl3)
vbl.addLayout(hbl4)
vbl.addLayout(hbl5)
vbl.addLayout(hbl6)
self.setLayout(vbl)
self.setMaximumWidth(330)
# Connect kernel combo box to event handler
self.combo.currentIndexChanged.connect(self.selection_changed)
self.selection_changed(0)
self.show()
def _load_options(self):
"""Extract names + types of kernels from SmoothCube.kernel_registry"""
kernel_registry = self.smooth_cube.get_kernel_registry()
self.options = {"spatial": [], "spectral": []}
for k in kernel_registry:
axis = kernel_registry[k]["axis"]
for a in axis:
if "spatial" == a:
self.options["spatial"].append(kernel_registry[k]["name"])
elif "spectral" == a:
self.options["spectral"].append(kernel_registry[k]["name"])
self.options["spectral"].sort()
self.options["spatial"].sort()
self.current_kernel_name = self.options[self.current_axis][0]
self.current_kernel_type = self.smooth_cube.name_to_kernel_type(self.options[self.current_axis][0])
def selection_changed(self, i):
"""
Update kernel type, units, etc... when
kernel name changes in combo box.
"""
keys = self.options[self.current_axis]
name = keys[i]
self.current_kernel_name = name
self.current_kernel_type = self.smooth_cube.name_to_kernel_type(name)
self.unit_label.setText(self.smooth_cube.get_kernel_unit(self.current_kernel_type))
self.size_prompt.setText(self.smooth_cube.get_kernel_size_prompt(self.current_kernel_type))
def spatial_radio_checked(self):
self.current_axis = "spatial"
self.update_preview_button()
self.combo.clear()
self.combo.addItems(self.options[self.current_axis])
def spectral_radio_checked(self):
self.current_axis = "spectral"
self.update_preview_button()
self.combo.clear()
self.combo.addItems(self.options[self.current_axis])
def input_validation(self):
"""
Check if input will break Smoothing
:return: bool: True if no errors
"""
red = "background-color: rgba(255, 0, 0, 128);"
success = True
# Check 1: k_size
if self.k_size == "":
self.k_size.setStyleSheet(red)
success = False
else:
try:
if self.current_kernel_type == "median":
k_size = int(self.k_size.text())
else:
k_size = float(self.k_size.text())
if k_size <= 0:
self.k_size.setStyleSheet(red)
success = False
else:
self.k_size.setStyleSheet("")
except ValueError:
if self.current_kernel_type == "median":
info = QMessageBox.critical(self, "Error",
"Kernel size must be integer for median")
self.k_size.setStyleSheet(red)
success = False
return success
def call_main(self):
try:
self.main()
except Exception as e:
info = QMessageBox.critical(self, "Error", str(e))
self.cancel()
raise
def main(self):
"""
Main function to process input and call smoothing function
"""
success = self.input_validation()
if not success:
return
self.hide()
self.abort_window = AbortWindow(self)
QApplication.processEvents()
# Add smoothing parameters
self.smooth_cube.abort_window = self.abort_window
if self.smooth_cube.parent is None and self.parent is not self.smooth_cube:
self.smooth_cube.parent = self.parent
if self.parent is not self.smooth_cube:
self.smooth_cube.data = self.data
self.smooth_cube.smoothing_axis = self.current_axis
self.smooth_cube.kernel_type = self.current_kernel_type
if self.current_kernel_type == "median":
self.smooth_cube.kernel_size = int(self.k_size.text())
else:
self.smooth_cube.kernel_size = float(self.k_size.text())
self.smooth_cube.component_id = str(self.component_combo.currentText())
self.smooth_cube.output_as_component = True
if self.is_preview_active:
self.parent.end_smoothing_preview()
self.is_preview_active = False
self.smooth_cube.multi_threading_smooth()
return
def update_preview_button(self):
if self.parent is None or "spatial" != self.current_axis:
self.previewButton.setDisabled(True)
return
self.previewButton.setDisabled(False)
return
def call_preview(self):
try:
self.preview()
except Exception as e:
info = QMessageBox.critical(self, "Error", str(e))
self.cancel()
raise
def preview(self):
"""Preview current options"""
success = self.input_validation()
if not success:
return
if self.smooth_cube.parent is None and self.parent is not self.smooth_cube:
self.smooth_cube.parent = self.parent
self.smooth_cube.smoothing_axis = self.current_axis
self.smooth_cube.kernel_type = self.current_kernel_type
if self.current_kernel_type == "median":
self.smooth_cube.kernel_size = int(self.k_size.text())
else:
self.smooth_cube.kernel_size = float(self.k_size.text())
preview_function = self.smooth_cube.preview_smoothing
preview_title = self.smooth_cube.get_preview_title()
component_id = self.component_combo.currentData()
self.parent.start_smoothing_preview(preview_function, component_id, preview_title)
self.is_preview_active = True
self.preview_message.show()
def cancel(self):
self.clean_up()
def clean_up(self):
self.close()
if self.abort_window is not None:
self.abort_window.close()
if self.is_preview_active:
self.parent.end_smoothing_preview()
self.is_preview_active = False
def closeEvent(self, event):
if self.is_preview_active:
self.parent.end_smoothing_preview()
self.is_preview_active = False
def keyPressEvent(self, e):
if e.key() == Qt.Key_Escape:
self.clean_up()
def __init__(self, parent, search_text, search_text_regexp, search_path,
include, include_idx, include_regexp,
exclude, exclude_idx, exclude_regexp,
supported_encodings, in_python_path, more_options):
QWidget.__init__(self, parent)
if search_path is None:
search_path = getcwd()
if not isinstance(search_text, (list, tuple)):
search_text = [search_text]
if not isinstance(search_path, (list, tuple)):
search_path = [search_path]
if not isinstance(include, (list, tuple)):
include = [include]
if not isinstance(exclude, (list, tuple)):
exclude = [exclude]
self.supported_encodings = supported_encodings
# Layout 1
hlayout1 = QHBoxLayout()
self.search_text = PatternComboBox(self, search_text,
_("Search pattern"))
self.edit_regexp = create_toolbutton(self,
icon=ima.icon('advanced'),
tip=_('Regular expression'))
self.edit_regexp.setCheckable(True)
self.edit_regexp.setChecked(search_text_regexp)
self.more_widgets = ()
self.more_options = create_toolbutton(self,
toggled=self.toggle_more_options)
self.more_options.setCheckable(True)
self.more_options.setChecked(more_options)
self.ok_button = create_toolbutton(self, text=_("Search"),
icon=ima.icon('DialogApplyButton'),
triggered=lambda: self.find.emit(),
tip=_("Start search"),
text_beside_icon=True)
self.ok_button.clicked.connect(self.update_combos)
self.stop_button = create_toolbutton(self, text=_("Stop"),
icon=ima.icon('stop'),
triggered=lambda: self.stop.emit(),
tip=_("Stop search"),
text_beside_icon=True)
self.stop_button.setEnabled(False)
for widget in [self.search_text, self.edit_regexp,
self.ok_button, self.stop_button, self.more_options]:
hlayout1.addWidget(widget)
# Layout 2
hlayout2 = QHBoxLayout()
self.include_pattern = PatternComboBox(self, include,
_("Included filenames pattern"))
if include_idx is not None and include_idx >= 0 \
and include_idx < self.include_pattern.count():
self.include_pattern.setCurrentIndex(include_idx)
self.include_regexp = create_toolbutton(self,
icon=ima.icon('advanced'),
tip=_('Regular expression'))
self.include_regexp.setCheckable(True)
self.include_regexp.setChecked(include_regexp)
include_label = QLabel(_("Include:"))
include_label.setBuddy(self.include_pattern)
self.exclude_pattern = PatternComboBox(self, exclude,
_("Excluded filenames pattern"))
if exclude_idx is not None and exclude_idx >= 0 \
and exclude_idx < self.exclude_pattern.count():
self.exclude_pattern.setCurrentIndex(exclude_idx)
self.exclude_regexp = create_toolbutton(self,
icon=ima.icon('advanced'),
tip=_('Regular expression'))
self.exclude_regexp.setCheckable(True)
self.exclude_regexp.setChecked(exclude_regexp)
exclude_label = QLabel(_("Exclude:"))
exclude_label.setBuddy(self.exclude_pattern)
for widget in [include_label, self.include_pattern,
self.include_regexp,
exclude_label, self.exclude_pattern,
self.exclude_regexp]:
hlayout2.addWidget(widget)
# Layout 3
hlayout3 = QHBoxLayout()
self.python_path = QRadioButton(_("PYTHONPATH"), self)
self.python_path.setChecked(in_python_path)
self.python_path.setToolTip(_(
"Search in all directories listed in sys.path which"
" are outside the Python installation directory"))
self.hg_manifest = QRadioButton(_("Hg repository"), self)
self.detect_hg_repository()
self.hg_manifest.setToolTip(
_("Search in current directory hg repository"))
self.custom_dir = QRadioButton(_("Here:"), self)
self.custom_dir.setChecked(not in_python_path)
self.dir_combo = PathComboBox(self)
self.dir_combo.addItems(search_path)
self.dir_combo.setToolTip(_("Search recursively in this directory"))
self.dir_combo.open_dir.connect(self.set_directory)
self.python_path.toggled.connect(self.dir_combo.setDisabled)
self.hg_manifest.toggled.connect(self.dir_combo.setDisabled)
browse = create_toolbutton(self, icon=ima.icon('DirOpenIcon'),
tip=_('Browse a search directory'),
triggered=self.select_directory)
for widget in [self.python_path, self.hg_manifest, self.custom_dir,
self.dir_combo, browse]:
hlayout3.addWidget(widget)
self.search_text.valid.connect(lambda valid: self.find.emit())
self.include_pattern.valid.connect(lambda valid: self.find.emit())
self.exclude_pattern.valid.connect(lambda valid: self.find.emit())
self.dir_combo.valid.connect(lambda valid: self.find.emit())
vlayout = QVBoxLayout()
vlayout.setContentsMargins(0, 0, 0, 0)
vlayout.addLayout(hlayout1)
vlayout.addLayout(hlayout2)
vlayout.addLayout(hlayout3)
self.more_widgets = (hlayout2, hlayout3)
self.toggle_more_options(more_options)
self.setLayout(vlayout)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
def create_widgets(self, show_animation_button=True):
"""creates the menu objects"""
# title
self.title_label = QLabel("Title:")
self.title_edit = QLineEdit(str(self._default_title))
self.title_button = QPushButton("Default")
# Min
self.min_label = QLabel("Min:")
self.min_edit = QLineEdit(str(self._default_min))
self.min_button = QPushButton("Default")
# Max
self.max_label = QLabel("Max:")
self.max_edit = QLineEdit(str(self._default_max))
self.max_button = QPushButton("Default")
#---------------------------------------
# Format
self.format_label = QLabel("Format (e.g. %.3f, %g, %.6e):")
self.format_edit = QLineEdit(str(self._format))
self.format_button = QPushButton("Default")
#---------------------------------------
# Scale
self.scale_label = QLabel("True Scale:")
self.scale_edit = QLineEdit(str(self._scale))
self.scale_button = QPushButton("Default")
if self._icase_disp is None:
self.scale_label.setVisible(False)
self.scale_edit.setVisible(False)
self.scale_button.setVisible(False)
# Phase
self.phase_label = QLabel("Phase (deg):")
self.phase_edit = QLineEdit(str(self._phase))
self.phase_button = QPushButton("Default")
if self._icase_disp is None or self._default_phase is None:
self.phase_label.setVisible(False)
self.phase_edit.setVisible(False)
self.phase_button.setVisible(False)
self.phase_edit.setText('0.0')
#---------------------------------------
self.arrow_scale_label = QLabel("Arrow Scale:")
self.arrow_scale_edit = QLineEdit(str(self._arrow_scale))
self.arrow_scale_button = QPushButton("Default")
if self._icase_vector is None:
self.arrow_scale_label.setVisible(False)
self.arrow_scale_edit.setVisible(False)
self.arrow_scale_button.setVisible(False)
#tip = QtGui.QToolTip()
#tip.setTe
#self.format_edit.toolTip(tip)
#---------------------------------------
# nlabels
self.nlabels_label = QLabel("Number of Labels:")
self.nlabels_edit = QLineEdit(str(self._nlabels))
self.nlabels_button = QPushButton("Default")
self.labelsize_label = QLabel("Label Size:")
self.labelsize_edit = QLineEdit(str(self._labelsize))
self.labelsize_button = QPushButton("Default")
self.ncolors_label = QLabel("Number of Colors:")
self.ncolors_edit = QLineEdit(str(self._ncolors))
self.ncolors_button = QPushButton("Default")
self.colormap_label = QLabel("Color Map:")
self.colormap_edit = QComboBox(self)
self.colormap_button = QPushButton("Default")
for key in colormap_keys:
self.colormap_edit.addItem(key)
self.colormap_edit.setCurrentIndex(colormap_keys.index(self._colormap))
# --------------------------------------------------------------
# the header
self.grid2_title = QLabel("Color Scale:")
# red/blue or blue/red
self.low_to_high_radio = QRadioButton('Low -> High')
self.high_to_low_radio = QRadioButton('High -> Low')
widget = QWidget(self)
low_to_high_group = QButtonGroup(widget)
low_to_high_group.addButton(self.low_to_high_radio)
low_to_high_group.addButton(self.high_to_low_radio)
self.low_to_high_radio.setChecked(self._default_is_low_to_high)
self.high_to_low_radio.setChecked(not self._default_is_low_to_high)
# horizontal / vertical
self.horizontal_radio = QRadioButton("Horizontal")
self.vertical_radio = QRadioButton("Vertical")
widget = QWidget(self)
horizontal_vertical_group = QButtonGroup(widget)
horizontal_vertical_group.addButton(self.horizontal_radio)
horizontal_vertical_group.addButton(self.vertical_radio)
self.horizontal_radio.setChecked(self._default_is_horizontal)
self.vertical_radio.setChecked(not self._default_is_horizontal)
# on / off
self.show_radio = QRadioButton("Show")
self.hide_radio = QRadioButton("Hide")
widget = QWidget(self)
show_hide_group = QButtonGroup(widget)
show_hide_group.addButton(self.show_radio)
show_hide_group.addButton(self.hide_radio)
self.show_radio.setChecked(self._default_is_shown)
self.hide_radio.setChecked(not self._default_is_shown)
# --------------------------------------------------------------
if self._icase_fringe is None:
self.title_label.setVisible(False)
self.title_edit.setVisible(False)
self.title_button.setVisible(False)
if not self._is_fringe:
self.max_label.hide()
self.min_label.hide()
self.max_edit.hide()
self.min_edit.hide()
self.max_button.hide()
self.min_button.hide()
self.format_label.hide()
self.format_edit.hide()
self.format_button.hide()
self.nlabels_label.hide()
self.nlabels_edit.hide()
self.nlabels_button.hide()
self.ncolors_label.hide()
self.ncolors_edit.hide()
self.ncolors_button.hide()
self.grid2_title.hide()
self.vertical_radio.hide()
self.horizontal_radio.hide()
self.show_radio.hide()
self.hide_radio.hide()
self.low_to_high_radio.hide()
self.high_to_low_radio.hide()
self.colormap_label.hide()
self.colormap_edit.hide()
self.colormap_button.hide()
self.animate_button = QPushButton('Create Animation')
self.animate_button.setVisible(show_animation_button)
#self.advanced_button = QPushButton('Advanced')
if self._default_icase_disp is None: # or self._default_icase_vector is None:
self.animate_button.setEnabled(False)
self.animate_button.setToolTip(ANIMATE_TOOLTIP_OFF)
else:
self.animate_button.setEnabled(True)
self.animate_button.setToolTip(ANIMATE_TOOLTIP_ON)
# closing
self.apply_button = QPushButton("Apply")
self.ok_button = QPushButton("OK")
self.cancel_button = QPushButton("Cancel")
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)
def __init__(self, model, *args, **kwargs):
self.model = model
super().__init__(*args, **kwargs)
self.setLayout(QFormLayout())
# Radiobuttons to quickly select default time period
self.all_widget = QRadioButton("All")
self.year_widget = QRadioButton("1 Year")
self.month_widget = QRadioButton("30 Days")
self.week_widget = QRadioButton("1 Week")
self.today_widget = QRadioButton("24h")
self.hour_widget = QRadioButton("1 Hour")
self.radio_button_group = QButtonGroup()
self.radio_button_group.addButton(self.all_widget)
self.radio_button_group.addButton(self.year_widget)
self.radio_button_group.addButton(self.month_widget)
self.radio_button_group.addButton(self.week_widget)
self.radio_button_group.addButton(self.today_widget)
self.radio_button_group.addButton(self.hour_widget)
default_period_layout = QGridLayout()
default_period_layout.setHorizontalSpacing(85)
default_period_layout.setVerticalSpacing(10)
default_period_layout.addWidget(self.all_widget, 0, 0, 1, 2)
default_period_layout.addWidget(self.year_widget, 1, 0, 1, 2)
default_period_layout.addWidget(self.month_widget, 2, 0, 1, 2)
default_period_layout.addWidget(self.week_widget, 0, 1, 1, 2)
default_period_layout.addWidget(self.today_widget, 1, 1, 1, 2)
default_period_layout.addWidget(self.hour_widget, 2, 1, 1, 2)
self.layout().addRow("When:", default_period_layout)
# TODO: rethink if restriction to acceptable timedelta values is required
# from ..models.search.search_input import SearchInput
# self.allowed = {timedelta(days=-1), timedelta(days=-30), timedelta(minutes=-60), timedelta(days=-7),
# timedelta(days=-365)}
# def time_validator(since=None, until=None):
# """
# Enforce that since and until are values that a UI can represent.
# This is an example similar to what will be used in the Qt UI.
# """
# now = timedelta()
# if isinstance(since, timedelta):
# if not (until is None or until == now):
# raise ValueError(
# "This UI cannot express since=timedelta(...) unless until "
# "is timedelta() or None."
# )
# for item in allowed:
# if since == item:
# break
# else:
# # No matches
# raise ValueError(
# "This UI can only express since as a timedelta if it is "
# f"one of {allowed}. The value {since} is not allowed"
# )
# s = SearchInput()
# s.time_validator = time_validator
# "Since: <datetime picker>"
self.since_widget = QDateTimeEdit()
self.since_widget.setCalendarPopup(True)
self.since_widget.setDisplayFormat("yyyy-MM-dd HH:mm")
self.layout().addRow("Since:", self.since_widget)
# "Until: <datetime picker>"
self.until_widget = QDateTimeEdit()
self.until_widget.setCalendarPopup(True)
self.until_widget.setDisplayFormat("yyyy-MM-dd HH:mm")
self.layout().addRow("Until:", self.until_widget)
# Refresh Button
self.refresh_button = QPushButton("Refresh")
self.layout().addWidget(self.refresh_button)
# Changes to the GUI update the model.
self.since_widget.dateTimeChanged.connect(self.on_since_view_changed)
self.until_widget.dateTimeChanged.connect(self.on_until_view_changed)
self.refresh_button.clicked.connect(self.model.request_reload)
self.model.events.reload.connect(self.on_reload)
self.model.events.query.connect(self.on_reload)
# Changes to the model update the GUI.
self.model.events.since.connect(self.on_since_model_changed)
self.model.events.until.connect(self.on_until_model_changed)
# connect QRadioButtons and change date dropdowns (since/until widgets) accordingly
self.hour_widget.toggled.connect(self.on_toggle_hour)
self.today_widget.toggled.connect(self.on_toggle_24h)
self.week_widget.toggled.connect(self.on_toggle_week)
self.month_widget.toggled.connect(self.on_toggle_month)
self.year_widget.toggled.connect(self.on_toggle_year)
self.all_widget.toggled.connect(self.on_toggle_all)
self.all_widget.setChecked(True)
def __init__(self, parent, search_text, search_text_regexp, search_path,
include, include_idx, include_regexp, exclude, exclude_idx,
exclude_regexp, supported_encodings, in_python_path,
more_options):
QWidget.__init__(self, parent)
if search_path is None:
search_path = getcwd()
if not isinstance(search_text, (list, tuple)):
search_text = [search_text]
if not isinstance(search_path, (list, tuple)):
search_path = [search_path]
if not isinstance(include, (list, tuple)):
include = [include]
if not isinstance(exclude, (list, tuple)):
exclude = [exclude]
self.supported_encodings = supported_encodings
# Layout 1
hlayout1 = QHBoxLayout()
self.search_text = PatternComboBox(self, search_text,
_("Search pattern"))
self.edit_regexp = create_toolbutton(self,
icon=ima.icon('advanced'),
tip=_('Regular expression'))
self.edit_regexp.setCheckable(True)
self.edit_regexp.setChecked(search_text_regexp)
self.more_widgets = ()
self.more_options = create_toolbutton(self,
toggled=self.toggle_more_options)
self.more_options.setCheckable(True)
self.more_options.setChecked(more_options)
self.ok_button = create_toolbutton(self,
text=_("Search"),
icon=ima.icon('DialogApplyButton'),
triggered=lambda: self.find.emit(),
tip=_("Start search"),
text_beside_icon=True)
self.ok_button.clicked.connect(self.update_combos)
self.stop_button = create_toolbutton(
self,
text=_("Stop"),
icon=ima.icon('stop'),
triggered=lambda: self.stop.emit(),
tip=_("Stop search"),
text_beside_icon=True)
self.stop_button.setEnabled(False)
for widget in [
self.search_text, self.edit_regexp, self.ok_button,
self.stop_button, self.more_options
]:
hlayout1.addWidget(widget)
# Layout 2
hlayout2 = QHBoxLayout()
self.include_pattern = PatternComboBox(self, include,
_("Included filenames pattern"))
if include_idx is not None and include_idx >= 0 \
and include_idx < self.include_pattern.count():
self.include_pattern.setCurrentIndex(include_idx)
self.include_regexp = create_toolbutton(self,
icon=ima.icon('advanced'),
tip=_('Regular expression'))
self.include_regexp.setCheckable(True)
self.include_regexp.setChecked(include_regexp)
include_label = QLabel(_("Include:"))
include_label.setBuddy(self.include_pattern)
self.exclude_pattern = PatternComboBox(self, exclude,
_("Excluded filenames pattern"))
if exclude_idx is not None and exclude_idx >= 0 \
and exclude_idx < self.exclude_pattern.count():
self.exclude_pattern.setCurrentIndex(exclude_idx)
self.exclude_regexp = create_toolbutton(self,
icon=ima.icon('advanced'),
tip=_('Regular expression'))
self.exclude_regexp.setCheckable(True)
self.exclude_regexp.setChecked(exclude_regexp)
exclude_label = QLabel(_("Exclude:"))
exclude_label.setBuddy(self.exclude_pattern)
for widget in [
include_label, self.include_pattern, self.include_regexp,
exclude_label, self.exclude_pattern, self.exclude_regexp
]:
hlayout2.addWidget(widget)
# Layout 3
hlayout3 = QHBoxLayout()
self.python_path = QRadioButton(_("PYTHONPATH"), self)
self.python_path.setChecked(in_python_path)
self.python_path.setToolTip(
_("Search in all directories listed in sys.path which"
" are outside the Python installation directory"))
self.hg_manifest = QRadioButton(_("Hg repository"), self)
self.detect_hg_repository()
self.hg_manifest.setToolTip(
_("Search in current directory hg repository"))
self.custom_dir = QRadioButton(_("Here:"), self)
self.custom_dir.setChecked(not in_python_path)
self.dir_combo = PathComboBox(self)
self.dir_combo.addItems(search_path)
self.dir_combo.setToolTip(_("Search recursively in this directory"))
self.dir_combo.open_dir.connect(self.set_directory)
self.python_path.toggled.connect(self.dir_combo.setDisabled)
self.hg_manifest.toggled.connect(self.dir_combo.setDisabled)
browse = create_toolbutton(self,
icon=ima.icon('DirOpenIcon'),
tip=_('Browse a search directory'),
triggered=self.select_directory)
for widget in [
self.python_path, self.hg_manifest, self.custom_dir,
self.dir_combo, browse
]:
hlayout3.addWidget(widget)
self.search_text.valid.connect(lambda valid: self.find.emit())
vlayout = QVBoxLayout()
vlayout.setContentsMargins(0, 0, 0, 0)
vlayout.addLayout(hlayout1)
vlayout.addLayout(hlayout2)
vlayout.addLayout(hlayout3)
self.more_widgets = (hlayout2, hlayout3)
self.toggle_more_options(more_options)
self.setLayout(vlayout)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
def _init_selection_ui(self):
# LINE 1: Radio box spatial vs spectral axis
self.axes_prompt = QLabel("Smoothing Axis:")
self.axes_prompt.setMinimumWidth(150)
self.spatial_radio = QRadioButton("Spatial")
self.spatial_radio.setChecked(True)
self.current_axis = "spatial"
self.spatial_radio.toggled.connect(self.spatial_radio_checked)
self.spectral_radio = QRadioButton("Spectral")
self.spectral_radio.toggled.connect(self.spectral_radio_checked)
# hbl is short for Horizontal Box Layout
hbl1 = QHBoxLayout()
hbl1.addWidget(self.axes_prompt)
hbl1.addWidget(self.spatial_radio)
hbl1.addWidget(self.spectral_radio)
# LINE 2: Kernel Type prompt
self.k_type_prompt = QLabel("Kernel Type:")
self.k_type_prompt.setMinimumWidth(150)
# Load kernel types + names and add to drop down
self._load_options()
self.combo = QComboBox()
self.combo.setMinimumWidth(150)
self.combo.addItems(self.options[self.current_axis])
hbl2 = QHBoxLayout()
hbl2.addWidget(self.k_type_prompt)
hbl2.addWidget(self.combo)
# LINE 3: Kernel size
self.size_prompt = QLabel(self.smooth_cube.get_kernel_size_prompt(self.current_kernel_type))
self.size_prompt.setWordWrap(True)
self.size_prompt.setMinimumWidth(150)
self.unit_label = QLabel(self.smooth_cube.get_kernel_unit(self.current_kernel_type))
self.k_size = QLineEdit("1") # Default Kernel size set here
hbl3 = QHBoxLayout()
hbl3.addWidget(self.size_prompt)
hbl3.addWidget(self.k_size)
hbl3.addWidget(self.unit_label)
# LINE 4: Data component drop down
self.component_prompt = QLabel("Data Component:")
self.component_prompt.setWordWrap(True)
self.component_prompt.setMinimumWidth(150)
# Load component_ids and add to drop down
# Add the data component labels to the drop down, with the ComponentID
# set as the userData:
if self.parent is not None and hasattr(self.parent, 'data_components'):
labeldata = [(str(cid), cid) for cid in self.parent.data_components]
else:
labeldata = [(str(cid), cid) for cid in self.data.main_components()]
self.component_combo = QComboBox()
update_combobox(self.component_combo, labeldata)
self.component_combo.setMaximumWidth(150)
self.component_combo.setCurrentIndex(0)
if self.allow_preview:
self.component_combo.currentIndexChanged.connect(self.update_preview_button)
hbl4 = QHBoxLayout()
hbl4.addWidget(self.component_prompt)
hbl4.addWidget(self.component_combo)
# Line 5: Preview Message
message = "Info: Smoothing previews are displayed on " \
"CubeViz's left and single image viewers."
self.preview_message = QLabel(message)
self.preview_message.setWordWrap(True)
self.preview_message.hide()
hbl5 = QHBoxLayout()
hbl5.addWidget(self.preview_message)
# LINE 6: preview ok cancel buttons
self.previewButton = QPushButton("Preview Slice")
self.previewButton.clicked.connect(self.call_preview)
self.okButton = QPushButton("Smooth Cube")
self.okButton.clicked.connect(self.call_main)
self.okButton.setDefault(True)
self.cancelButton = QPushButton("Cancel")
self.cancelButton.clicked.connect(self.cancel)
hbl6 = QHBoxLayout()
hbl6.addStretch(1)
if self.allow_preview:
hbl6.addWidget(self.previewButton)
hbl6.addWidget(self.cancelButton)
hbl6.addWidget(self.okButton)
# Add Lines to Vertical Layout
# vbl is short for Vertical Box Layout
vbl = QVBoxLayout()
if self.allow_spectral_axes:
vbl.addLayout(hbl1)
vbl.addLayout(hbl2)
vbl.addLayout(hbl3)
vbl.addLayout(hbl4)
vbl.addLayout(hbl5)
vbl.addLayout(hbl6)
self.setLayout(vbl)
self.setMaximumWidth(330)
# Connect kernel combo box to event handler
self.combo.currentIndexChanged.connect(self.selection_changed)
self.selection_changed(0)
self.show()
class LegendPropertiesWindow(PyDialog):
"""
+-------------------+
| Legend Properties |
+-----------------------+
| Title ______ Default |
| Min ______ Default |
| Max ______ Default |
| Format ______ Default |
| Scale ______ Default |
| Phase ______ Default |
| Number of Colors ____ |
| Number of Labels ____ |
| Label Size ____ | (TODO)
| ColorMap ____ | (TODO)
| |
| x Min/Max (Blue->Red) |
| o Max/Min (Red->Blue) |
| |
| x Vertical/Horizontal |
| x Show/Hide |
| |
| Animate |
| Apply OK Cancel |
+-----------------------+
"""
def __init__(self, data, win_parent=None, show_animation_button=True):
PyDialog.__init__(self, data, win_parent)
self.is_gui = win_parent is not None
self._updated_legend = False
self.external_call = True
#if win_parent is None:
self._icase_fringe = data['icase_fringe']
self._icase_disp = data['icase_disp']
self._icase_vector = data['icase_vector']
#else:
#self._icase_fringe = data['icase']
#self._icase_disp = data['icase']
#self._icase_vector = data['icase']
self._default_icase_fringe = self._icase_fringe
self._default_icase_disp = self._icase_disp
self._default_icase_vector = self._icase_vector
#print('*icase_fringe=%s icase_disp=%s icase_vector=%s' % (
#self._default_icase_fringe, self._default_icase_disp, self._default_icase_vector))
self._default_title = data['title']
self._default_min = data['min_value']
self._default_max = data['max_value']
self._default_scale = data['default_scale']
self._scale = data['scale']
#if win_parent is None:
self._default_arrow_scale = data['default_arrow_scale']
self._arrow_scale = data['arrow_scale']
#else:
#self._default_arrow_scale = data['default_scale']
#self._arrow_scale = data['scale']
self._default_phase = data['default_phase']
self._phase = data['phase']
self._default_format = data['default_format']
self._format = data['format']
self._default_labelsize = data['default_labelsize']
self._labelsize = data['labelsize']
self._default_nlabels = data['default_nlabels']
self._nlabels = data['nlabels']
self._default_ncolors = data['default_ncolors']
self._ncolors = data['ncolors']
self._default_colormap = data['default_colormap']
self._colormap = data['colormap']
self._default_is_low_to_high = data['is_low_to_high']
self._default_is_discrete = data['is_discrete']
self._default_is_horizontal = data['is_horizontal']
self._default_is_shown = data['is_shown']
self._is_fringe = data['is_fringe']
self._update_defaults_to_blank()
self.setWindowTitle('Legend Properties')
self.create_widgets(show_animation_button=show_animation_button)
self.create_layout()
self.set_connections()
self.set_font_size(data['font_size'])
def _update_defaults_to_blank(self):
"""Changes the default (None) to a blank string"""
if self._default_colormap is None:
self._default_colormap = 'jet'
if self._default_labelsize is None:
self._default_labelsize = ''
if self._default_ncolors is None:
self._default_ncolors = ''
if self._default_nlabels is None:
self._default_nlabels = ''
if self._colormap is None:
self._colormap = 'jet'
if self._labelsize is None:
self._labelsize = ''
if self._ncolors is None:
self._ncolors = ''
if self._nlabels is None:
self._nlabels = ''
def update_legend(self,
icase_fringe,
icase_disp,
icase_vector,
title,
min_value,
max_value,
data_format,
nlabels,
labelsize,
ncolors,
colormap,
is_fringe,
scale,
phase,
arrow_scale,
default_title,
default_min_value,
default_max_value,
default_data_format,
default_nlabels,
default_labelsize,
default_ncolors,
default_colormap,
default_scale,
default_phase,
default_arrow_scale,
font_size=8,
external_call=False):
"""
We need to update the legend if there's been a result change request
"""
self.external_call = external_call
self.set_font_size(font_size)
update_fringe = False
update_disp = False
update_vector = False
#print('update_legend; fringe=%s disp=%s vector=%s' % (
#icase_fringe, icase_disp, icase_vector))
#print('update_legend; default: fringe=%s disp=%s vector=%s' % (
# self._default_icase_fringe, self._default_icase_disp, self._default_icase_vector))
if icase_fringe != self._default_icase_fringe:
self._icase_fringe = icase_fringe
self._default_icase_fringe = icase_fringe
update_fringe = True
#is_fringe = icase_fringe is not None
is_disp = icase_disp is not None
is_vector = icase_vector is not None
if icase_disp != self._default_icase_disp:
assert isinstance(
scale, float_types), 'scale=%r type=%s' % (scale, type(scale))
#assert isinstance(default_scale, float), 'default_scale=%r' % default_scale
self._icase_disp = icase_disp
self._default_icase_disp = icase_disp
self._default_scale = default_scale
self._default_phase = default_phase
update_disp = True
if icase_vector != self._default_icase_vector:
assert isinstance(
arrow_scale,
float_types), 'arrow_scale=%r type=%s' % (arrow_scale,
type(scale))
#assert isinstance(default_arrow_scale, float), 'default_arrow_scale=%r' % default_arrow_scale
self._icase_vector = icase_vector
self._default_icase_vector = icase_vector
self._default_arrow_scale = default_arrow_scale
update_vector = True
#print('*update_legend; default: fringe=%s disp=%s vector=%s' % (
# self._default_icase_fringe, self._default_icase_disp, self._default_icase_vector))
#print('update_fringe=%s update_disp=%s update_vector=%s' % (
# update_fringe, update_disp, update_vector))
#print('is_fringe=%s is_disp=%s is_vector=%s' % (
# is_fringe, is_disp, is_vector))
if update_fringe:
self._icase_fringe = icase_fringe
self._default_icase_fringe = icase_fringe
self._default_title = default_title
self._default_min = default_min_value
self._default_max = default_max_value
self._default_format = default_data_format
#self._default_is_low_to_high = is_low_to_high
self._default_is_discrete = True
#self._default_is_horizontal = is_horizontal_scalar_bar
self._default_nlabels = default_nlabels
self._default_labelsize = default_labelsize
self._default_ncolors = default_ncolors
self._default_colormap = default_colormap
self._is_fringe = is_fringe
if colormap is None:
colormap = 'jet'
if labelsize is None:
labelsize = ''
if ncolors is None:
ncolors = ''
if nlabels is None:
nlabels = ''
self._update_defaults_to_blank()
#-----------------------------------------------------------------------
update = update_fringe or update_disp or update_vector
if update:
#self.scale_label.setEnabled(is_disp)
#self.scale_edit.setEnabled(is_disp)
#self.scale_button.setEnabled(is_disp)
self.scale_label.setVisible(is_disp)
self.scale_edit.setVisible(is_disp)
self.scale_button.setVisible(is_disp)
is_complex_disp = self._default_phase is not None
self.phase_label.setVisible(is_complex_disp)
self.phase_edit.setVisible(is_complex_disp)
self.phase_button.setVisible(is_complex_disp)
self._scale = set_cell_to_blank_if_value_is_none(
self.scale_edit, scale)
self._phase = set_cell_to_blank_if_value_is_none(
self.phase_edit, phase)
if self._default_icase_disp is None: # or self._default_icase_vector is None:
self.animate_button.setEnabled(False)
self.animate_button.setToolTip(ANIMATE_TOOLTIP_OFF)
else:
self.animate_button.setEnabled(True)
self.animate_button.setToolTip(ANIMATE_TOOLTIP_ON)
#-----------------------------------------------------------------------
if update:
#self.arrow_scale_label.setEnabled(is_vector)
#self.arrow_scale_edit.setEnabled(is_vector)
#self.arrow_scale_button.setEnabled(is_vector)
self.arrow_scale_label.setVisible(is_vector)
self.arrow_scale_edit.setVisible(is_vector)
self.arrow_scale_button.setVisible(is_vector)
self._arrow_scale = set_cell_to_blank_if_value_is_none(
self.arrow_scale_edit, arrow_scale)
#-----------------------------------------------------------------------
if update_fringe:
#self.on_default_title()
#self.on_default_min()
#self.on_default_max()
#self.on_default_format()
#self.on_default_scale()
# reset defaults
self.title_edit.setText(title)
self.title_edit.setStyleSheet("QLineEdit{background: white;}")
self.min_edit.setText(str(min_value))
self.min_edit.setStyleSheet("QLineEdit{background: white;}")
self.max_edit.setText(str(max_value))
self.max_edit.setStyleSheet("QLineEdit{background: white;}")
self.format_edit.setText(str(data_format))
self.format_edit.setStyleSheet("QLineEdit{background: white;}")
self.nlabels_edit.setText(str(nlabels))
self.nlabels_edit.setStyleSheet("QLineEdit{background: white;}")
self.labelsize_edit.setText(str(labelsize))
self.labelsize_edit.setStyleSheet("QLineEdit{background: white;}")
self.ncolors_edit.setText(str(ncolors))
self.ncolors_edit.setStyleSheet("QLineEdit{background: white;}")
self.colormap_edit.setCurrentIndex(
colormap_keys.index(str(colormap)))
self._set_legend_fringe(self._is_fringe)
if update:
self.on_apply()
self.external_call = True
#print('---------------------------------')
def clear_disp(self):
"""hides dispacement blocks"""
self._icase_disp = None
self._default_icase_disp = None
self.scale_label.setVisible(False)
self.scale_edit.setVisible(False)
self.scale_button.setVisible(False)
self.phase_label.setVisible(False)
self.phase_edit.setVisible(False)
self.phase_button.setVisible(False)
def clear_vector(self):
"""hides vector blocks"""
self._icase_vector = None
self._default_icase_vector = None
self.arrow_scale_label.setVisible(False)
self.arrow_scale_edit.setVisible(False)
self.arrow_scale_button.setVisible(False)
def clear(self):
"""hides fringe, displacemnt, and vector blocks"""
self._icase_fringe = None
self._default_icase_fringe = None
self._set_legend_fringe(False)
self.clear_disp()
self.clear_vector()
def _set_legend_fringe(self, is_fringe):
"""
Show/hide buttons if we dont have a result. This is used for normals.
A result can still exist (i.e., icase_fringe is not None).
"""
# lots of hacking for the Normal vectors
self._is_fringe = is_fringe
#self._default_icase_fringe = None
enable = True
if not is_fringe:
enable = False
show_title = self._icase_fringe is not None
self.title_label.setVisible(show_title)
self.title_edit.setVisible(show_title)
self.title_button.setVisible(show_title)
self.max_label.setVisible(enable)
self.min_label.setVisible(enable)
self.max_edit.setVisible(enable)
self.min_edit.setVisible(enable)
self.max_button.setVisible(enable)
self.min_button.setVisible(enable)
self.show_radio.setVisible(enable)
self.hide_radio.setVisible(enable)
self.low_to_high_radio.setVisible(enable)
self.high_to_low_radio.setVisible(enable)
self.format_label.setVisible(enable)
self.format_edit.setVisible(enable)
self.format_edit.setVisible(enable)
self.format_button.setVisible(enable)
self.nlabels_label.setVisible(enable)
self.nlabels_edit.setVisible(enable)
self.nlabels_button.setVisible(enable)
self.ncolors_label.setVisible(enable)
self.ncolors_edit.setVisible(enable)
self.ncolors_button.setVisible(enable)
self.grid2_title.setVisible(enable)
self.vertical_radio.setVisible(enable)
self.horizontal_radio.setVisible(enable)
self.colormap_label.setVisible(enable)
self.colormap_edit.setVisible(enable)
self.colormap_button.setVisible(enable)
def create_widgets(self, show_animation_button=True):
"""creates the menu objects"""
# title
self.title_label = QLabel("Title:")
self.title_edit = QLineEdit(str(self._default_title))
self.title_button = QPushButton("Default")
# Min
self.min_label = QLabel("Min:")
self.min_edit = QLineEdit(str(self._default_min))
self.min_button = QPushButton("Default")
# Max
self.max_label = QLabel("Max:")
self.max_edit = QLineEdit(str(self._default_max))
self.max_button = QPushButton("Default")
#---------------------------------------
# Format
self.format_label = QLabel("Format (e.g. %.3f, %g, %.6e):")
self.format_edit = QLineEdit(str(self._format))
self.format_button = QPushButton("Default")
#---------------------------------------
# Scale
self.scale_label = QLabel("True Scale:")
self.scale_edit = QLineEdit(str(self._scale))
self.scale_button = QPushButton("Default")
if self._icase_disp is None:
self.scale_label.setVisible(False)
self.scale_edit.setVisible(False)
self.scale_button.setVisible(False)
# Phase
self.phase_label = QLabel("Phase (deg):")
self.phase_edit = QLineEdit(str(self._phase))
self.phase_button = QPushButton("Default")
if self._icase_disp is None or self._default_phase is None:
self.phase_label.setVisible(False)
self.phase_edit.setVisible(False)
self.phase_button.setVisible(False)
self.phase_edit.setText('0.0')
#---------------------------------------
self.arrow_scale_label = QLabel("Arrow Scale:")
self.arrow_scale_edit = QLineEdit(str(self._arrow_scale))
self.arrow_scale_button = QPushButton("Default")
if self._icase_vector is None:
self.arrow_scale_label.setVisible(False)
self.arrow_scale_edit.setVisible(False)
self.arrow_scale_button.setVisible(False)
#tip = QtGui.QToolTip()
#tip.setTe
#self.format_edit.toolTip(tip)
#---------------------------------------
# nlabels
self.nlabels_label = QLabel("Number of Labels:")
self.nlabels_edit = QLineEdit(str(self._nlabels))
self.nlabels_button = QPushButton("Default")
self.labelsize_label = QLabel("Label Size:")
self.labelsize_edit = QLineEdit(str(self._labelsize))
self.labelsize_button = QPushButton("Default")
self.ncolors_label = QLabel("Number of Colors:")
self.ncolors_edit = QLineEdit(str(self._ncolors))
self.ncolors_button = QPushButton("Default")
self.colormap_label = QLabel("Color Map:")
self.colormap_edit = QComboBox(self)
self.colormap_button = QPushButton("Default")
for key in colormap_keys:
self.colormap_edit.addItem(key)
self.colormap_edit.setCurrentIndex(colormap_keys.index(self._colormap))
# --------------------------------------------------------------
# the header
self.grid2_title = QLabel("Color Scale:")
# red/blue or blue/red
self.low_to_high_radio = QRadioButton('Low -> High')
self.high_to_low_radio = QRadioButton('High -> Low')
widget = QWidget(self)
low_to_high_group = QButtonGroup(widget)
low_to_high_group.addButton(self.low_to_high_radio)
low_to_high_group.addButton(self.high_to_low_radio)
self.low_to_high_radio.setChecked(self._default_is_low_to_high)
self.high_to_low_radio.setChecked(not self._default_is_low_to_high)
# horizontal / vertical
self.horizontal_radio = QRadioButton("Horizontal")
self.vertical_radio = QRadioButton("Vertical")
widget = QWidget(self)
horizontal_vertical_group = QButtonGroup(widget)
horizontal_vertical_group.addButton(self.horizontal_radio)
horizontal_vertical_group.addButton(self.vertical_radio)
self.horizontal_radio.setChecked(self._default_is_horizontal)
self.vertical_radio.setChecked(not self._default_is_horizontal)
# on / off
self.show_radio = QRadioButton("Show")
self.hide_radio = QRadioButton("Hide")
widget = QWidget(self)
show_hide_group = QButtonGroup(widget)
show_hide_group.addButton(self.show_radio)
show_hide_group.addButton(self.hide_radio)
self.show_radio.setChecked(self._default_is_shown)
self.hide_radio.setChecked(not self._default_is_shown)
# --------------------------------------------------------------
if self._icase_fringe is None:
self.title_label.setVisible(False)
self.title_edit.setVisible(False)
self.title_button.setVisible(False)
if not self._is_fringe:
self.max_label.hide()
self.min_label.hide()
self.max_edit.hide()
self.min_edit.hide()
self.max_button.hide()
self.min_button.hide()
self.format_label.hide()
self.format_edit.hide()
self.format_button.hide()
self.nlabels_label.hide()
self.nlabels_edit.hide()
self.nlabels_button.hide()
self.ncolors_label.hide()
self.ncolors_edit.hide()
self.ncolors_button.hide()
self.grid2_title.hide()
self.vertical_radio.hide()
self.horizontal_radio.hide()
self.show_radio.hide()
self.hide_radio.hide()
self.low_to_high_radio.hide()
self.high_to_low_radio.hide()
self.colormap_label.hide()
self.colormap_edit.hide()
self.colormap_button.hide()
self.animate_button = QPushButton('Create Animation')
self.animate_button.setVisible(show_animation_button)
#self.advanced_button = QPushButton('Advanced')
if self._default_icase_disp is None: # or self._default_icase_vector is None:
self.animate_button.setEnabled(False)
self.animate_button.setToolTip(ANIMATE_TOOLTIP_OFF)
else:
self.animate_button.setEnabled(True)
self.animate_button.setToolTip(ANIMATE_TOOLTIP_ON)
# closing
self.apply_button = QPushButton("Apply")
self.ok_button = QPushButton("OK")
self.cancel_button = QPushButton("Cancel")
def create_layout(self):
"""displays the menu objects"""
grid = QGridLayout()
grid.addWidget(self.title_label, 0, 0)
grid.addWidget(self.title_edit, 0, 1)
grid.addWidget(self.title_button, 0, 2)
grid.addWidget(self.min_label, 1, 0)
grid.addWidget(self.min_edit, 1, 1)
grid.addWidget(self.min_button, 1, 2)
grid.addWidget(self.max_label, 2, 0)
grid.addWidget(self.max_edit, 2, 1)
grid.addWidget(self.max_button, 2, 2)
grid.addWidget(self.format_label, 3, 0)
grid.addWidget(self.format_edit, 3, 1)
grid.addWidget(self.format_button, 3, 2)
grid.addWidget(self.scale_label, 4, 0)
grid.addWidget(self.scale_edit, 4, 1)
grid.addWidget(self.scale_button, 4, 2)
grid.addWidget(self.phase_label, 6, 0)
grid.addWidget(self.phase_edit, 6, 1)
grid.addWidget(self.phase_button, 6, 2)
grid.addWidget(self.arrow_scale_label, 5, 0)
grid.addWidget(self.arrow_scale_edit, 5, 1)
grid.addWidget(self.arrow_scale_button, 5, 2)
grid.addWidget(self.nlabels_label, 7, 0)
grid.addWidget(self.nlabels_edit, 7, 1)
grid.addWidget(self.nlabels_button, 7, 2)
#grid.addWidget(self.labelsize_label, 6, 0)
#grid.addWidget(self.labelsize_edit, 6, 1)
#grid.addWidget(self.labelsize_button, 6, 2)
grid.addWidget(self.ncolors_label, 8, 0)
grid.addWidget(self.ncolors_edit, 8, 1)
grid.addWidget(self.ncolors_button, 8, 2)
grid.addWidget(self.colormap_label, 9, 0)
grid.addWidget(self.colormap_edit, 9, 1)
grid.addWidget(self.colormap_button, 9, 2)
ok_cancel_box = QHBoxLayout()
ok_cancel_box.addWidget(self.apply_button)
ok_cancel_box.addWidget(self.ok_button)
ok_cancel_box.addWidget(self.cancel_button)
grid2 = QGridLayout()
grid2.addWidget(self.grid2_title, 0, 0)
grid2.addWidget(self.low_to_high_radio, 1, 0)
grid2.addWidget(self.high_to_low_radio, 2, 0)
grid2.addWidget(self.vertical_radio, 1, 1)
grid2.addWidget(self.horizontal_radio, 2, 1)
grid2.addWidget(self.show_radio, 1, 2)
grid2.addWidget(self.hide_radio, 2, 2)
grid2.addWidget(self.animate_button, 3, 1)
#grid2.setSpacing(0)
vbox = QVBoxLayout()
vbox.addLayout(grid)
#vbox.addLayout(checkboxes)
vbox.addLayout(grid2)
vbox.addStretch()
vbox.addLayout(ok_cancel_box)
self.setLayout(vbox)
def set_connections(self):
"""creates the actions for the buttons"""
self.title_button.clicked.connect(self.on_default_title)
self.min_button.clicked.connect(self.on_default_min)
self.max_button.clicked.connect(self.on_default_max)
self.format_button.clicked.connect(self.on_default_format)
self.scale_button.clicked.connect(self.on_default_scale)
self.arrow_scale_button.clicked.connect(self.on_default_arrow_scale)
self.phase_button.clicked.connect(self.on_default_phase)
self.nlabels_button.clicked.connect(self.on_default_nlabels)
self.labelsize_button.clicked.connect(self.on_default_labelsize)
self.ncolors_button.clicked.connect(self.on_default_ncolors)
self.colormap_button.clicked.connect(self.on_default_colormap)
self.animate_button.clicked.connect(self.on_animate)
self.show_radio.clicked.connect(self.on_show_hide)
self.hide_radio.clicked.connect(self.on_show_hide)
self.apply_button.clicked.connect(self.on_apply)
self.ok_button.clicked.connect(self.on_ok)
self.cancel_button.clicked.connect(self.on_cancel)
if qt_version == 4:
self.connect(self, QtCore.SIGNAL('triggered()'), self.closeEvent)
#self.colormap_edit.activated[str].connect(self.onActivated)
#else:
# closeEvent???
def set_font_size(self, font_size):
"""
Updates the font size of the objects
Parameters
----------
font_size : int
the font size
"""
if self.font_size == font_size:
return
self.font_size = font_size
font = QFont()
font.setPointSize(font_size)
self.setFont(font)
self.title_edit.setFont(font)
self.min_edit.setFont(font)
self.max_edit.setFont(font)
self.format_edit.setFont(font)
self.scale_edit.setFont(font)
self.phase_edit.setFont(font)
self.nlabels_edit.setFont(font)
self.labelsize_edit.setFont(font)
self.ncolors_edit.setFont(font)
def on_animate(self):
"""opens the animation window"""
title, flag0 = check_name_str(self.title_edit)
if not flag0:
return
scale, flag1 = check_float(self.scale_edit)
if not flag1:
scale = self._scale
data = {
'font_size': self.out_data['font_size'],
'icase_fringe': self._icase_fringe,
'icase_disp': self._icase_disp,
'icase_vector': self._icase_vector,
'title': title,
'time': 2,
'frames/sec': 30,
'resolution': 1,
'iframe': 0,
'scale': scale,
'default_scale': self._default_scale,
'arrow_scale': scale,
'default_arrow_scale': self._default_arrow_scale,
'is_scale': self._default_phase is None,
'phase': self._phase,
'default_phase': self._default_phase,
'dirname': os.path.abspath(os.getcwd()),
'clicked_ok': False,
'close': False,
}
self.win_parent.legend_obj.set_animation_window(data)
def on_default_title(self):
"""action when user clicks 'Default' for title"""
title = str(self._default_title)
self.title_edit.setText(title)
self.title_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_min(self):
"""action when user clicks 'Default' for min value"""
self.min_edit.setText(str(self._default_min))
self.min_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_max(self):
"""action when user clicks 'Default' for max value"""
self.max_edit.setText(str(self._default_max))
self.max_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_format(self):
"""action when user clicks 'Default' for the number format"""
self.format_edit.setText(str(self._default_format))
self.format_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_scale(self):
"""action when user clicks 'Default' for scale factor"""
self.scale_edit.setText(str(self._default_scale))
self.scale_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_arrow_scale(self):
"""action when user clicks 'Default' for arrow_scale factor"""
self.arrow_scale_edit.setText(str(self._default_arrow_scale))
self.arrow_scale_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_phase(self):
"""action when user clicks 'Default' for phase angle"""
self.phase_edit.setText(str(self._default_phase))
self.phase_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_ncolors(self):
"""action when user clicks 'Default' for number of colors"""
self.ncolors_edit.setText(str(self._default_ncolors))
self.ncolors_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_colormap(self):
"""action when user clicks 'Default' for the color map"""
self.colormap_edit.setCurrentIndex(
colormap_keys.index(self._default_colormap))
def on_default_nlabels(self):
"""action when user clicks 'Default' for number of labels"""
self.nlabels_edit.setStyleSheet("QLineEdit{background: white;}")
self.nlabels_edit.setText(str(self._default_nlabels))
def on_default_labelsize(self):
"""action when user clicks 'Default' for number of labelsize"""
self.labelsize_edit.setText(str(self._default_labelsize))
self.labelsize_edit.setStyleSheet("QLineEdit{background: white;}")
def on_show_hide(self):
"""action when user clicks the 'Show/Hide' radio button"""
#self.colormap_edit.setCurrentIndex(colormap_keys.index(self._default_colormap))
is_shown = self.show_radio.isChecked()
self.nlabels_edit.setEnabled(is_shown)
self.nlabels_button.setEnabled(is_shown)
self.ncolors_edit.setEnabled(is_shown)
self.ncolors_button.setEnabled(is_shown)
self.high_to_low_radio.setEnabled(is_shown)
self.low_to_high_radio.setEnabled(is_shown)
self.colormap_edit.setEnabled(is_shown)
self.colormap_button.setEnabled(is_shown)
self.vertical_radio.setEnabled(is_shown)
self.horizontal_radio.setEnabled(is_shown)
def show_legend(self):
"""shows the legend"""
self._set_legend(True)
def hide_legend(self):
"""hides the legend"""
self._set_legend(False)
def _set_legend(self, is_shown):
"""shows/hides the legend"""
self.show_radio.setChecked(is_shown)
self.hide_radio.setChecked(not is_shown)
#if self.is_gui:
#self.win_parent.scalar_bar_actor.SetVisibility(is_shown)
def on_validate(self):
"""checks to see if the ``on_apply`` method can be called"""
show_title = self._icase_fringe is not None
flag_title = True
title_value = ''
if show_title:
title_value, flag_title = check_name_str(self.title_edit)
flag_fringe = True
min_value = max_value = format_value = nlabels = ncolors = labelsize = colormap = None
if self._icase_fringe is not None:
min_value, flag1 = check_float(self.min_edit)
max_value, flag2 = check_float(self.max_edit)
format_value, flag3 = check_format(self.format_edit)
nlabels, flag4 = check_positive_int_or_blank(self.nlabels_edit)
ncolors, flag5 = check_positive_int_or_blank(self.ncolors_edit)
labelsize, flag6 = check_positive_int_or_blank(self.labelsize_edit)
colormap = str(self.colormap_edit.currentText())
if flag3 and 'i' in format_value:
format_value = '%i'
flag_fringe = all([flag1, flag2, flag3, flag4, flag5, flag6])
flag_disp = True
scale = phase = None
if self._icase_disp is not None:
scale, flag1 = check_float(self.scale_edit)
phase, flag2 = check_float(self.phase_edit)
assert isinstance(scale, float), scale
flag_disp = all([flag1, flag2])
flag_vector = True
arrow_scale = None
if self._icase_vector is not None:
arrow_scale, flag_vector = check_float(self.arrow_scale_edit)
if all([flag_title, flag_fringe, flag_disp, flag_vector]):
self.out_data['title'] = title_value
self.out_data['min_value'] = min_value
self.out_data['max_value'] = max_value
self.out_data['format'] = format_value
self.out_data['scale'] = scale
self.out_data['phase'] = phase
self.out_data['arrow_scale'] = arrow_scale
self.out_data['nlabels'] = nlabels
self.out_data['ncolors'] = ncolors
self.out_data['labelsize'] = labelsize
self.out_data['colormap'] = colormap
self.out_data['is_low_to_high'] = self.low_to_high_radio.isChecked(
)
self.out_data['is_horizontal'] = self.horizontal_radio.isChecked()
self.out_data['is_shown'] = self.show_radio.isChecked()
self.out_data['clicked_ok'] = True
self.out_data['close'] = True
#print('self.out_data = ', self.out_data)
#print("title = %r" % self.title_edit.text())
#print("min = %r" % self.min_edit.text())
#print("max = %r" % self.max_edit.text())
#print("format = %r" % self.format_edit.text())
return True
return False
def on_apply(self):
"""applies the current values"""
passed = self.on_validate()
if passed and self.external_call:
self.win_parent.legend_obj._apply_legend(self.out_data)
self.external_call = True
return passed
def on_ok(self):
"""applies the current values and closes the window"""
passed = self.on_apply()
if passed:
self.close()
#self.destroy()
def on_cancel(self):
"""closes the windows and reverts the legend"""
self.out_data['close'] = True
self.close()
class FindOptions(QWidget):
"""Find widget with options"""
REGEX_INVALID = "background-color:rgb(255, 175, 90);"
find = Signal()
stop = Signal()
redirect_stdio = Signal(bool)
def __init__(self, parent, search_text, search_text_regexp, search_path,
exclude, exclude_idx, exclude_regexp,
supported_encodings, in_python_path, more_options):
QWidget.__init__(self, parent)
if search_path is None:
search_path = getcwd()
self.path = ''
self.project_path = None
self.file_path = None
if not isinstance(search_text, (list, tuple)):
search_text = [search_text]
if not isinstance(search_path, (list, tuple)):
search_path = [search_path]
if not isinstance(exclude, (list, tuple)):
exclude = [exclude]
self.supported_encodings = supported_encodings
# Layout 1
hlayout1 = QHBoxLayout()
self.search_text = PatternComboBox(self, search_text,
_("Search pattern"))
self.edit_regexp = create_toolbutton(self,
icon=ima.icon('advanced'),
tip=_('Regular expression'))
self.edit_regexp.setCheckable(True)
self.edit_regexp.setChecked(search_text_regexp)
self.more_widgets = ()
self.more_options = create_toolbutton(self,
toggled=self.toggle_more_options)
self.more_options.setCheckable(True)
self.more_options.setChecked(more_options)
self.ok_button = create_toolbutton(self, text=_("Search"),
icon=ima.icon('find'),
triggered=lambda: self.find.emit(),
tip=_("Start search"),
text_beside_icon=True)
self.ok_button.clicked.connect(self.update_combos)
self.stop_button = create_toolbutton(self, text=_("Stop"),
icon=ima.icon('editclear'),
triggered=lambda:
self.stop.emit(),
tip=_("Stop search"),
text_beside_icon=True)
self.stop_button.setEnabled(False)
for widget in [self.search_text, self.edit_regexp,
self.ok_button, self.stop_button, self.more_options]:
hlayout1.addWidget(widget)
# Layout 2
hlayout2 = QHBoxLayout()
self.exclude_pattern = PatternComboBox(self, exclude,
_("Excluded filenames pattern"))
if exclude_idx is not None and exclude_idx >= 0 \
and exclude_idx < self.exclude_pattern.count():
self.exclude_pattern.setCurrentIndex(exclude_idx)
self.exclude_regexp = create_toolbutton(self,
icon=ima.icon('advanced'),
tip=_('Regular expression'))
self.exclude_regexp.setCheckable(True)
self.exclude_regexp.setChecked(exclude_regexp)
exclude_label = QLabel(_("Exclude:"))
exclude_label.setBuddy(self.exclude_pattern)
for widget in [exclude_label, self.exclude_pattern,
self.exclude_regexp]:
hlayout2.addWidget(widget)
# Layout 3
hlayout3 = QHBoxLayout()
self.global_path_search = QRadioButton(_("Current working "
"directory"), self)
self.global_path_search.setChecked(True)
self.global_path_search.setToolTip(_("Search in all files and "
"directories present on the"
"current Spyder path"))
self.project_search = QRadioButton(_("Project"), self)
self.project_search.setToolTip(_("Search in all files and "
"directories present on the"
"current project path (If opened)"))
self.project_search.setEnabled(False)
self.file_search = QRadioButton(_("File"), self)
self.file_search.setToolTip(_("Search in current opened file"))
for wid in [self.global_path_search,
self.project_search, self.file_search]:
hlayout3.addWidget(wid)
hlayout3.addStretch(1)
self.search_text.valid.connect(lambda valid: self.find.emit())
self.exclude_pattern.valid.connect(lambda valid: self.find.emit())
vlayout = QVBoxLayout()
vlayout.setContentsMargins(0, 0, 0, 0)
vlayout.addLayout(hlayout1)
vlayout.addLayout(hlayout2)
vlayout.addLayout(hlayout3)
self.more_widgets = (hlayout2,)
self.toggle_more_options(more_options)
self.setLayout(vlayout)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
@Slot(bool)
def toggle_more_options(self, state):
for layout in self.more_widgets:
for index in range(layout.count()):
if state and self.isVisible() or not state:
layout.itemAt(index).widget().setVisible(state)
if state:
icon = ima.icon('options_less')
tip = _('Hide advanced options')
else:
icon = ima.icon('options_more')
tip = _('Show advanced options')
self.more_options.setIcon(icon)
self.more_options.setToolTip(tip)
def update_combos(self):
self.search_text.lineEdit().returnPressed.emit()
self.exclude_pattern.lineEdit().returnPressed.emit()
def set_search_text(self, text):
if text:
self.search_text.add_text(text)
self.search_text.lineEdit().selectAll()
self.search_text.setFocus()
def get_options(self, all=False):
# Getting options
self.search_text.lineEdit().setStyleSheet("")
self.exclude_pattern.lineEdit().setStyleSheet("")
utext = to_text_string(self.search_text.currentText())
if not utext:
return
try:
texts = [(utext.encode('utf-8'), 'utf-8')]
except UnicodeEncodeError:
texts = []
for enc in self.supported_encodings:
try:
texts.append((utext.encode(enc), enc))
except UnicodeDecodeError:
pass
text_re = self.edit_regexp.isChecked()
exclude = to_text_string(self.exclude_pattern.currentText())
exclude_re = self.exclude_regexp.isChecked()
python_path = False
global_path_search = self.global_path_search.isChecked()
project_search = self.project_search.isChecked()
file_search = self.file_search.isChecked()
if global_path_search:
path = self.path
elif project_search:
path = self.project_path
else:
path = self.file_path
# Finding text occurrences
if not exclude_re:
exclude = fnmatch.translate(exclude)
else:
try:
exclude = re.compile(exclude)
except Exception:
exclude_edit = self.exclude_pattern.lineEdit()
exclude_edit.setStyleSheet(self.REGEX_INVALID)
return None
if text_re:
try:
texts = [(re.compile(x[0]), x[1]) for x in texts]
except Exception:
self.search_text.lineEdit().setStyleSheet(self.REGEX_INVALID)
return None
if all:
search_text = [to_text_string(self.search_text.itemText(index))
for index in range(self.search_text.count())]
exclude = [to_text_string(self.exclude_pattern.itemText(index))
for index in range(self.exclude_pattern.count())]
exclude_idx = self.exclude_pattern.currentIndex()
more_options = self.more_options.isChecked()
return (search_text, text_re, [],
exclude, exclude_idx, exclude_re,
python_path, more_options)
else:
return (path, file_search, exclude, texts, text_re)
@Slot()
def select_directory(self):
"""Select directory"""
self.redirect_stdio.emit(False)
directory = getexistingdirectory(self, _("Select directory"),
self.dir_combo.currentText())
if directory:
self.set_directory(directory)
self.redirect_stdio.emit(True)
def set_directory(self, directory):
self.path = to_text_string(osp.abspath(to_text_string(directory)))
def set_project_path(self, path):
self.project_path = to_text_string(osp.abspath(to_text_string(path)))
self.project_search.setEnabled(True)
def disable_project_search(self):
self.project_search.setEnabled(False)
self.project_search.setChecked(False)
self.project_path = None
def set_file_path(self, path):
self.file_path = path
def keyPressEvent(self, event):
"""Reimplemented to handle key events"""
ctrl = event.modifiers() & Qt.ControlModifier
shift = event.modifiers() & Qt.ShiftModifier
if event.key() in (Qt.Key_Enter, Qt.Key_Return):
self.find.emit()
elif event.key() == Qt.Key_F and ctrl and shift:
# Toggle find widgets
self.parent().toggle_visibility.emit(not self.isVisible())
else:
QWidget.keyPressEvent(self, event)
class QtSearchInput(QWidget):
"""
Qt view for SearchInput
Parameters
----------
model: SearchInput
"""
def __init__(self, model, *args, **kwargs):
self.model = model
super().__init__(*args, **kwargs)
self.setLayout(QFormLayout())
# Radiobuttons to quickly select default time period
self.all_widget = QRadioButton("All")
self.year_widget = QRadioButton("1 Year")
self.month_widget = QRadioButton("30 Days")
self.week_widget = QRadioButton("1 Week")
self.today_widget = QRadioButton("24h")
self.hour_widget = QRadioButton("1 Hour")
self.radio_button_group = QButtonGroup()
self.radio_button_group.addButton(self.all_widget)
self.radio_button_group.addButton(self.year_widget)
self.radio_button_group.addButton(self.month_widget)
self.radio_button_group.addButton(self.week_widget)
self.radio_button_group.addButton(self.today_widget)
self.radio_button_group.addButton(self.hour_widget)
default_period_layout = QGridLayout()
default_period_layout.setHorizontalSpacing(85)
default_period_layout.setVerticalSpacing(10)
default_period_layout.addWidget(self.all_widget, 0, 0, 1, 2)
default_period_layout.addWidget(self.year_widget, 1, 0, 1, 2)
default_period_layout.addWidget(self.month_widget, 2, 0, 1, 2)
default_period_layout.addWidget(self.week_widget, 0, 1, 1, 2)
default_period_layout.addWidget(self.today_widget, 1, 1, 1, 2)
default_period_layout.addWidget(self.hour_widget, 2, 1, 1, 2)
self.layout().addRow("When:", default_period_layout)
# TODO: rethink if restriction to acceptable timedelta values is required
# from ..models.search.search_input import SearchInput
# self.allowed = {timedelta(days=-1), timedelta(days=-30), timedelta(minutes=-60), timedelta(days=-7),
# timedelta(days=-365)}
# def time_validator(since=None, until=None):
# """
# Enforce that since and until are values that a UI can represent.
# This is an example similar to what will be used in the Qt UI.
# """
# now = timedelta()
# if isinstance(since, timedelta):
# if not (until is None or until == now):
# raise ValueError(
# "This UI cannot express since=timedelta(...) unless until "
# "is timedelta() or None."
# )
# for item in allowed:
# if since == item:
# break
# else:
# # No matches
# raise ValueError(
# "This UI can only express since as a timedelta if it is "
# f"one of {allowed}. The value {since} is not allowed"
# )
# s = SearchInput()
# s.time_validator = time_validator
# "Since: <datetime picker>"
self.since_widget = QDateTimeEdit()
self.since_widget.setCalendarPopup(True)
self.since_widget.setDisplayFormat("yyyy-MM-dd HH:mm")
self.layout().addRow("Since:", self.since_widget)
# "Until: <datetime picker>"
self.until_widget = QDateTimeEdit()
self.until_widget.setCalendarPopup(True)
self.until_widget.setDisplayFormat("yyyy-MM-dd HH:mm")
self.layout().addRow("Until:", self.until_widget)
# Refresh Button
self.refresh_button = QPushButton("Refresh")
self.layout().addWidget(self.refresh_button)
# Changes to the GUI update the model.
self.since_widget.dateTimeChanged.connect(self.on_since_view_changed)
self.until_widget.dateTimeChanged.connect(self.on_until_view_changed)
self.refresh_button.clicked.connect(self.model.request_reload)
self.model.events.reload.connect(self.on_reload)
self.model.events.query.connect(self.on_reload)
# Changes to the model update the GUI.
self.model.events.since.connect(self.on_since_model_changed)
self.model.events.until.connect(self.on_until_model_changed)
# connect QRadioButtons and change date dropdowns (since/until widgets) accordingly
self.hour_widget.toggled.connect(self.on_toggle_hour)
self.today_widget.toggled.connect(self.on_toggle_24h)
self.week_widget.toggled.connect(self.on_toggle_week)
self.month_widget.toggled.connect(self.on_toggle_month)
self.year_widget.toggled.connect(self.on_toggle_year)
self.all_widget.toggled.connect(self.on_toggle_all)
self.all_widget.setChecked(True)
def on_reload(self, event):
now = datetime.now(LOCAL_TIMEZONE)
if isinstance(self.model.since, timedelta):
with _blocked(self.since_widget):
self.since_widget.setDateTime(as_qdatetime(now + self.model.since))
if isinstance(self.model.until, timedelta):
with _blocked(self.until_widget):
self.until_widget.setDateTime(as_qdatetime(now + self.model.until))
def on_since_view_changed(self, qdatetime):
# When GUI is updated
self.model.since = QDateTime.toPython(qdatetime)
def on_since_model_changed(self, event):
# When model is updated (e.g. from console or by clicking a QRadioButton)
now = datetime.now(LOCAL_TIMEZONE)
if isinstance(event.date, timedelta):
qdatetime = as_qdatetime(now + event.date)
if event.date == timedelta(minutes=-60):
self.hour_widget.setChecked(True)
elif event.date == timedelta(days=-1):
self.today_widget.setChecked(True)
elif event.date == timedelta(days=-7):
self.week_widget.setChecked(True)
elif event.date == timedelta(days=-30):
self.month_widget.setChecked(True)
elif event.date == timedelta(days=-365):
self.year_widget.setChecked(True)
else:
# No checkbox associated with this custom timedelta
pass
else:
# Must be a datetime
if event.date == ADA_LOVELACE_BIRTHDAY:
self.all_widget.setChecked(True)
else:
self.uncheck_radiobuttons()
qdatetime = as_qdatetime(event.date)
with _blocked(self.since_widget):
self.since_widget.setDateTime(qdatetime)
with _blocked(self.until_widget):
self.until_widget.setDateTime(as_qdatetime(now))
def on_until_view_changed(self, qdatetime):
# When GUI is updated
self.model.until = QDateTime.toPython(qdatetime)
def on_until_model_changed(self, event):
# When model is updated (e.g. from console or by clicking a QRadioButton)
if not isinstance(event.date, timedelta):
qdatetime = as_qdatetime(event.date)
self.uncheck_radiobuttons()
with _blocked(self.until_widget):
self.until_widget.setDateTime(qdatetime)
def on_toggle_24h(self):
if self.today_widget.isChecked():
self.model.since = timedelta(days=-1)
self.model.until = timedelta()
def on_toggle_hour(self):
if self.hour_widget.isChecked():
self.model.since = timedelta(minutes=-60)
self.model.until = timedelta()
def on_toggle_week(self):
if self.week_widget.isChecked():
self.model.since = timedelta(days=-7)
self.model.until = timedelta()
def on_toggle_month(self):
if self.month_widget.isChecked():
self.model.since = timedelta(days=-30)
self.model.until = timedelta()
def on_toggle_year(self):
if self.year_widget.isChecked():
self.model.since = timedelta(days=-365)
self.model.until = timedelta()
def on_toggle_all(self):
# Search for all catalogs since Ada Lovelace's Birthday.
if self.all_widget.isChecked():
self.model.since = ADA_LOVELACE_BIRTHDAY
self.model.until = timedelta()
def uncheck_radiobuttons(self):
self.radio_button_group.setExclusive(False)
self.all_widget.setChecked(False)
self.year_widget.setChecked(False)
self.month_widget.setChecked(False)
self.week_widget.setChecked(False)
self.today_widget.setChecked(False)
self.hour_widget.setChecked(False)
self.radio_button_group.setExclusive(True)
def __init__(self, parent, search_text, search_text_regexp, search_path,
exclude, exclude_idx, exclude_regexp,
supported_encodings, in_python_path, more_options):
QWidget.__init__(self, parent)
if search_path is None:
search_path = getcwd()
self.path = ''
self.project_path = None
self.file_path = None
if not isinstance(search_text, (list, tuple)):
search_text = [search_text]
if not isinstance(search_path, (list, tuple)):
search_path = [search_path]
if not isinstance(exclude, (list, tuple)):
exclude = [exclude]
self.supported_encodings = supported_encodings
# Layout 1
hlayout1 = QHBoxLayout()
self.search_text = PatternComboBox(self, search_text,
_("Search pattern"))
self.edit_regexp = create_toolbutton(self,
icon=ima.icon('advanced'),
tip=_('Regular expression'))
self.edit_regexp.setCheckable(True)
self.edit_regexp.setChecked(search_text_regexp)
self.more_widgets = ()
self.more_options = create_toolbutton(self,
toggled=self.toggle_more_options)
self.more_options.setCheckable(True)
self.more_options.setChecked(more_options)
self.ok_button = create_toolbutton(self, text=_("Search"),
icon=ima.icon('find'),
triggered=lambda: self.find.emit(),
tip=_("Start search"),
text_beside_icon=True)
self.ok_button.clicked.connect(self.update_combos)
self.stop_button = create_toolbutton(self, text=_("Stop"),
icon=ima.icon('editclear'),
triggered=lambda:
self.stop.emit(),
tip=_("Stop search"),
text_beside_icon=True)
self.stop_button.setEnabled(False)
for widget in [self.search_text, self.edit_regexp,
self.ok_button, self.stop_button, self.more_options]:
hlayout1.addWidget(widget)
# Layout 2
hlayout2 = QHBoxLayout()
self.exclude_pattern = PatternComboBox(self, exclude,
_("Excluded filenames pattern"))
if exclude_idx is not None and exclude_idx >= 0 \
and exclude_idx < self.exclude_pattern.count():
self.exclude_pattern.setCurrentIndex(exclude_idx)
self.exclude_regexp = create_toolbutton(self,
icon=ima.icon('advanced'),
tip=_('Regular expression'))
self.exclude_regexp.setCheckable(True)
self.exclude_regexp.setChecked(exclude_regexp)
exclude_label = QLabel(_("Exclude:"))
exclude_label.setBuddy(self.exclude_pattern)
for widget in [exclude_label, self.exclude_pattern,
self.exclude_regexp]:
hlayout2.addWidget(widget)
# Layout 3
hlayout3 = QHBoxLayout()
self.global_path_search = QRadioButton(_("Current working "
"directory"), self)
self.global_path_search.setChecked(True)
self.global_path_search.setToolTip(_("Search in all files and "
"directories present on the"
"current Spyder path"))
self.project_search = QRadioButton(_("Project"), self)
self.project_search.setToolTip(_("Search in all files and "
"directories present on the"
"current project path (If opened)"))
self.project_search.setEnabled(False)
self.file_search = QRadioButton(_("File"), self)
self.file_search.setToolTip(_("Search in current opened file"))
for wid in [self.global_path_search,
self.project_search, self.file_search]:
hlayout3.addWidget(wid)
hlayout3.addStretch(1)
self.search_text.valid.connect(lambda valid: self.find.emit())
self.exclude_pattern.valid.connect(lambda valid: self.find.emit())
vlayout = QVBoxLayout()
vlayout.setContentsMargins(0, 0, 0, 0)
vlayout.addLayout(hlayout1)
vlayout.addLayout(hlayout2)
vlayout.addLayout(hlayout3)
self.more_widgets = (hlayout2,)
self.toggle_more_options(more_options)
self.setLayout(vlayout)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
class Dialog(EasyDialog):
NAME = _("Zoeppritz modeling")
sig_start = Signal(tuple, str, str, str, str, str)
def __init__(self, parent=None):
EasyDialog.__init__(self, parent)
self.setup_page()
def setup_page(self):
model_group = QGroupBox(_('Half-space elastic model'))
lbl_model = QLabel(_("Model"))
lbl_vp = QLabel(_("Vp"))
lbl_vs = QLabel(_("Vs"))
lbl_ro = QLabel(_("Density"))
lbl_upp = QLabel(_("Upper space"))
self.le_upp_vp = QLineEdit()
self.le_upp_vs = QLineEdit()
self.le_upp_ro = QLineEdit()
lbl_low = QLabel(_("Lower space"))
self.le_low_vp = QLineEdit()
self.le_low_vs = QLineEdit()
self.le_low_ro = QLineEdit()
model_layout = QGridLayout()
model_layout.addWidget(lbl_model, 0, 0)
model_layout.addWidget(lbl_vp, 0, 1)
model_layout.addWidget(lbl_vs, 0, 2)
model_layout.addWidget(lbl_ro, 0, 3)
model_layout.addWidget(lbl_upp, 1, 0)
model_layout.addWidget(self.le_upp_vp, 1, 1)
model_layout.addWidget(self.le_upp_vs, 1, 2)
model_layout.addWidget(self.le_upp_ro, 1, 3)
model_layout.addWidget(lbl_low, 2, 0)
model_layout.addWidget(self.le_low_vp, 2, 1)
model_layout.addWidget(self.le_low_vs, 2, 2)
model_layout.addWidget(self.le_low_ro, 2, 3)
model_group.setLayout(model_layout)
self.layout.addWidget(model_group)
text = _("Incident angles")
self.angles = self.create_lineedit(text)
self.layout.addWidget(self.angles)
lbl_reflection = QLabel(_('Reflection'))
self.rb_pp = QRadioButton(_('PP'))
self.rb_ps = QRadioButton(_('PS'))
bg_reflection = QButtonGroup()
bg_reflection.addButton(self.rb_pp)
bg_reflection.addButton(self.rb_ps)
hbox = QHBoxLayout()
hbox.addWidget(lbl_reflection)
hbox.addWidget(self.rb_pp)
hbox.addWidget(self.rb_ps)
self.layout.addLayout(hbox)
lbl_complex = QLabel(_('Complex'))
self.rb_amp = QRadioButton(_('amplitude'))
self.rb_pha = QRadioButton(_('phase'))
bg_complex = QButtonGroup()
bg_complex.addButton(self.rb_amp)
bg_complex.addButton(self.rb_pha)
hbox = QHBoxLayout()
hbox.addWidget(lbl_complex)
hbox.addWidget(self.rb_amp)
hbox.addWidget(self.rb_pha)
self.layout.addLayout(hbox)
lbl_equation = QLabel(_('Equation'))
self.rb_linear = QRadioButton(_('Linear'))
self.rb_quadratic = QRadioButton(_('Quadratic'))
self.rb_zoeppritz = QRadioButton(_('Zoeppritz'))
bg_equation = QButtonGroup()
bg_equation.addButton(self.rb_linear)
bg_equation.addButton(self.rb_quadratic)
bg_equation.addButton(self.rb_zoeppritz)
hbox = QHBoxLayout()
hbox.addWidget(lbl_equation)
hbox.addWidget(self.rb_linear)
hbox.addWidget(self.rb_quadratic)
hbox.addWidget(self.rb_zoeppritz)
self.layout.addLayout(hbox)
text = _("New point")
self.new_point = self.create_lineedit(text)
self.layout.addWidget(self.new_point)
action = self.create_action()
self.layout.addWidget(action)
self.rb_linear.toggled.connect(
lambda: self.set_equation(self.rb_linear))
self.rb_quadratic.toggled.connect(
lambda: self.set_equation(self.rb_quadratic))
self.rb_zoeppritz.toggled.connect(
lambda: self.set_equation(self.rb_zoeppritz))
self.rb_zoeppritz.setChecked(True)
self.rb_pp.toggled.connect(lambda: self.set_reflection(self.rb_pp))
self.rb_ps.toggled.connect(lambda: self.set_reflection(self.rb_ps))
self.rb_pp.setChecked(True)
self.rb_amp.toggled.connect(lambda: self.set_complex(self.rb_amp))
self.rb_pha.toggled.connect(lambda: self.set_complex(self.rb_pha))
self.rb_amp.setChecked(True)
def set_equation(self, rb):
if rb.isChecked():
if rb.text() == _('Linear'):
self.equation = 'linear'
elif rb.text() == _('Quadratic'):
self.equation = 'quadratic'
elif rb.text() == _('Zoeppritz'):
self.equation = 'zoeppritz'
else:
raise ValueError("Unknown value")
def set_reflection(self, rb):
if rb.isChecked():
if rb.text() == _('PP'):
self.reflection = 'PP'
elif rb.text() == _('PS'):
self.reflection = 'PS'
else:
raise ValueError("Unknown value")
def set_complex(self, rb):
if rb.isChecked():
if rb.text() == _('amplitude'):
self.complex = 'amplitude'
elif rb.text() == _('phase'):
self.complex = 'phase'
else:
raise ValueError("Unknown value")
def apply(self):
vp1 = float(self.le_upp_vp.text())
vs1 = float(self.le_upp_vs.text())
ro1 = float(self.le_upp_ro.text())
vp2 = float(self.le_low_vp.text())
vs2 = float(self.le_low_vs.text())
ro2 = float(self.le_low_ro.text())
model = (vp1, vs1, ro1, vp2, vs2, ro2)
inc_angles = self.angles.edit.text()
equation = self.equation
reflection = self.reflection
complexity = self.complex
object_name = self.new_point.edit.text()
self.sig_start.emit(model, inc_angles, equation, reflection,
complexity, object_name)
class DialogSelectScan(QDialog):
def __init__(self):
super().__init__()
self.resize(400, 200)
self.setWindowTitle("Load Run From Database")
self._id_uid = None
self._mode_id_uid = "id"
label = QLabel("Enter run ID or UID:")
self.le_id_uid = LineEditExtended()
self.le_id_uid.textChanged.connect(self.le_id_uid_text_changed)
self.le_id_uid.editingFinished.connect(self.le_id_uid_editing_finished)
set_tooltip(self.le_id_uid, "Enter <b>Run ID</b> or <b>Run UID</b>.")
self._validator_id = IntValidatorStrict()
# Short UID example: "04c9afa7"
self._validator_uid_short = QRegExpValidator(QRegExp(r"[0-9a-f]{8}"))
# Full UID example: "04c9afa7-a43a-4af1-8e55-2034384d4a77"
self._validator_uid_full = QRegExpValidator(
QRegExp(
r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}"
))
self.rb_id = QRadioButton("Run ID")
set_tooltip(
self.rb_id,
"The value in the line edit box is <b>Run ID</b> (e.g. <b>34235</b> or <b>-1</b>)"
)
self.rb_id.setChecked(self._mode_id_uid == "id")
self.rb_uid = QRadioButton("Run UID")
self.rb_uid.setChecked(self._mode_id_uid == "uid")
set_tooltip(
self.rb_uid,
"The value in the line edit box is <b>Run UID</b> "
"(e.g. <b>04c9afb7-a43a-4af1-8e55-2034384d4a77</b> or <b>04c9afb7</b>)",
)
self.btn_group = QButtonGroup()
self.btn_group.addButton(self.rb_id)
self.btn_group.addButton(self.rb_uid)
self.btn_group.buttonToggled.connect(self.btn_group_button_toggled)
button_box = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
button_box.accepted.connect(self.accept)
button_box.rejected.connect(self.reject)
self.pb_ok = button_box.button(QDialogButtonBox.Ok)
vbox = QVBoxLayout()
vbox.addStretch(1)
hbox = QHBoxLayout()
hbox.addWidget(label)
hbox.addStretch(1)
vbox.addLayout(hbox)
vbox.addWidget(self.le_id_uid)
hbox = QHBoxLayout()
hbox.addStretch(1)
hbox.addWidget(self.rb_id)
hbox.addStretch(1)
hbox.addWidget(self.rb_uid)
hbox.addStretch(1)
vbox.addLayout(hbox)
vbox.addStretch(1)
vbox.addWidget(button_box)
self.setLayout(vbox)
# This is how the button from QDialogButtonBox can be disabled
# button_box.button(QDialogButtonBox.Ok).setEnabled(False)
self.le_id_uid.setText("")
self._validate_id_uid()
def btn_group_button_toggled(self, button, state):
if state:
if button == self.rb_id:
self._mode_id_uid = "id"
elif button == self.rb_uid:
self._mode_id_uid = "uid"
text = self.le_id_uid.text()
if self._validate_id_uid(text):
self._read_id_uid(text)
def le_id_uid_text_changed(self, text):
self._validate_id_uid(text)
def le_id_uid_editing_finished(self):
text = self.le_id_uid.text()
if self._validate_id_uid(text):
self._read_id_uid(text)
def get_id_uid(self):
"""
Read the selected scan ID or UID
Returns
-------
(str, int) or (str, str)
keyword "id" or "uid" depending on whether the second element is scan ID or UID,
scan ID (int), scan UID (str) or None if no scan ID or UID is selected
"""
return self._mode_id_uid, self._id_uid
def _validate_id_uid(self, text=None):
valid = False
if text is None:
text = self.le_id_uid.text()
if self._mode_id_uid == "id":
if self._validator_id.validate(text,
0)[0] == QIntValidator.Acceptable:
valid = True
elif self._mode_id_uid == "uid":
if (self._validator_uid_short.validate(
text, 0)[0] == QIntValidator.Acceptable
or self._validator_uid_full.validate(
text, 0)[0] == QIntValidator.Acceptable):
valid = True
self.le_id_uid.setValid(valid)
self.pb_ok.setEnabled(valid)
return valid
def _read_id_uid(self, text):
# It is assumed that the entered text is valid for the selected mode
if text is None:
text = self.le_id_uid.text()
if self._mode_id_uid == "id":
self._id_uid = int(text)
elif self._mode_id_uid == "uid":
self._id_uid = text
def _set_mode(self, mode):
if mode == "id":
self._mode_id_uid = mode
self.rb_id.setChecked(True)
elif mode == "uid":
self._mode_id_uid = mode
self.rb_uid.setChecked(True)
def add_reader_buttons(self, layout, readers):
"""Add radio button to layout for each reader in readers"""
for display_name in sorted(readers):
button = QRadioButton(f"{display_name}")
self.reader_btn_group.addButton(button)
layout.addWidget(button)
def __init__(self):
super().__init__()
self.resize(400, 200)
self.setWindowTitle("Load Run From Database")
self._id_uid = None
self._mode_id_uid = "id"
label = QLabel("Enter run ID or UID:")
self.le_id_uid = LineEditExtended()
self.le_id_uid.textChanged.connect(self.le_id_uid_text_changed)
self.le_id_uid.editingFinished.connect(self.le_id_uid_editing_finished)
set_tooltip(self.le_id_uid, "Enter <b>Run ID</b> or <b>Run UID</b>.")
self._validator_id = IntValidatorStrict()
# Short UID example: "04c9afa7"
self._validator_uid_short = QRegExpValidator(QRegExp(r"[0-9a-f]{8}"))
# Full UID example: "04c9afa7-a43a-4af1-8e55-2034384d4a77"
self._validator_uid_full = QRegExpValidator(
QRegExp(
r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}"
))
self.rb_id = QRadioButton("Run ID")
set_tooltip(
self.rb_id,
"The value in the line edit box is <b>Run ID</b> (e.g. <b>34235</b> or <b>-1</b>)"
)
self.rb_id.setChecked(self._mode_id_uid == "id")
self.rb_uid = QRadioButton("Run UID")
self.rb_uid.setChecked(self._mode_id_uid == "uid")
set_tooltip(
self.rb_uid,
"The value in the line edit box is <b>Run UID</b> "
"(e.g. <b>04c9afb7-a43a-4af1-8e55-2034384d4a77</b> or <b>04c9afb7</b>)",
)
self.btn_group = QButtonGroup()
self.btn_group.addButton(self.rb_id)
self.btn_group.addButton(self.rb_uid)
self.btn_group.buttonToggled.connect(self.btn_group_button_toggled)
button_box = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
button_box.accepted.connect(self.accept)
button_box.rejected.connect(self.reject)
self.pb_ok = button_box.button(QDialogButtonBox.Ok)
vbox = QVBoxLayout()
vbox.addStretch(1)
hbox = QHBoxLayout()
hbox.addWidget(label)
hbox.addStretch(1)
vbox.addLayout(hbox)
vbox.addWidget(self.le_id_uid)
hbox = QHBoxLayout()
hbox.addStretch(1)
hbox.addWidget(self.rb_id)
hbox.addStretch(1)
hbox.addWidget(self.rb_uid)
hbox.addStretch(1)
vbox.addLayout(hbox)
vbox.addStretch(1)
vbox.addWidget(button_box)
self.setLayout(vbox)
# This is how the button from QDialogButtonBox can be disabled
# button_box.button(QDialogButtonBox.Ok).setEnabled(False)
self.le_id_uid.setText("")
self._validate_id_uid()
class RunConfigOptions(QWidget):
"""Run configuration options"""
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 select_directory(self):
"""Select directory"""
basedir = to_text_string(self.wd_edit.text())
if not osp.isdir(basedir):
basedir = getcwd_or_home()
directory = getexistingdirectory(self, _("Select directory"), basedir)
if directory:
self.wd_edit.setText(directory)
self.dir = directory
def set(self, options):
self.runconf.set(options)
self.clo_cb.setChecked(self.runconf.args_enabled)
self.clo_edit.setText(self.runconf.args)
if self.runconf.current:
self.current_radio.setChecked(True)
elif self.runconf.systerm:
self.systerm_radio.setChecked(True)
else:
self.dedicated_radio.setChecked(True)
self.interact_cb.setChecked(self.runconf.interact)
self.post_mortem_cb.setChecked(self.runconf.post_mortem)
self.pclo_cb.setChecked(self.runconf.python_args_enabled)
self.pclo_edit.setText(self.runconf.python_args)
self.clear_var_cb.setChecked(self.runconf.clear_namespace)
self.file_dir_radio.setChecked(self.runconf.file_dir)
self.cwd_radio.setChecked(self.runconf.cw_dir)
self.fixed_dir_radio.setChecked(self.runconf.fixed_dir)
self.dir = self.runconf.dir
self.wd_edit.setText(self.dir)
def get(self):
self.runconf.args_enabled = self.clo_cb.isChecked()
self.runconf.args = to_text_string(self.clo_edit.text())
self.runconf.current = self.current_radio.isChecked()
self.runconf.systerm = self.systerm_radio.isChecked()
self.runconf.interact = self.interact_cb.isChecked()
self.runconf.post_mortem = self.post_mortem_cb.isChecked()
self.runconf.python_args_enabled = self.pclo_cb.isChecked()
self.runconf.python_args = to_text_string(self.pclo_edit.text())
self.runconf.clear_namespace = self.clear_var_cb.isChecked()
self.runconf.file_dir = self.file_dir_radio.isChecked()
self.runconf.cw_dir = self.cwd_radio.isChecked()
self.runconf.fixed_dir = self.fixed_dir_radio.isChecked()
self.runconf.dir = self.wd_edit.text()
return self.runconf.get()
def is_valid(self):
wdir = to_text_string(self.wd_edit.text())
if not self.fixed_dir_radio.isChecked() or osp.isdir(wdir):
return True
else:
QMessageBox.critical(
self, _("Run configuration"),
_("The following working directory is "
"not valid:<br><b>%s</b>") % wdir)
return False
def set_firstrun_o(self):
CONF.set('run', ALWAYS_OPEN_FIRST_RUN_OPTION,
self.firstrun_cb.isChecked())
class WingWindow(PyDialog):
"""
+-------------------+
| Legend Properties |
+-----------------------+
| Title ______ Default |
| Min ______ Default |
| Max ______ Default |
| Format ______ Default |
| Scale ______ Default |
| Phase ______ Default |
| Number of Colors ____ |
| Number of Labels ____ |
| Label Size ____ | (TODO)
| ColorMap ____ | (TODO)
| |
| x Min/Max (Blue->Red) |
| o Max/Min (Red->Blue) |
| |
| x Vertical/Horizontal |
| x Show/Hide |
| |
| Animate |
| Apply OK Cancel |
+-----------------------+
"""
colormap_keys = ['metal', 'gold', 'grey']
def __init__(self, data, win_parent=None):
PyDialog.__init__(self, data, win_parent)
self._updated_legend = False
self._animation_window_shown = False
#self._icase = data['icase']
#self._default_icase = self._icase
self._default_name = data['name']
self._color_int = data['color']
#self.setupUi(self)
self.setWindowTitle('Wing')
self.create_widgets()
self.create_layout()
#self.set_connections()
self.set_font_size(data['font_size'])
self.symmetry = data['symmetry']
self.transform = data['transform']
def create_widgets(self):
"""creates the menu objects"""
self.create_general_widgets()
self.create_xform_widgets()
def create_general_widgets(self):
"""creates the menu objects"""
# --------------------------------------------------------------
# Name
self.name = QLabel("Name:")
self.name_edit = QLineEdit(str(self._default_name))
self.colormap = QLabel("Color:")
self.colormap_edit = QPushButtonColor(self._color_int,
'Select a color',
parent=self)
self.colormap_button = QPushButton("Advanced")
self.colormap_button.setEnabled(False)
# --------------------------------------------------------------
# TODO: the way these sliders work is they have some defined range
# if you go outside the range, they "reset" to 50% and
# are redefined from value-delta to value+delta, where
# delta=nominal/2
num_u = 5
num_w = 10
self.tesselation_u = QLabel("Num_U")
self.tesselation_u_edit = QJumpSlider(QtCore.Qt.Horizontal)
self.tesselation_u_edit.setTickPosition(QSlider.TicksBelow)
self.tesselation_u_edit.setRange(1, 10)
self.tesselation_u_edit.setValue(num_u)
self.tesselation_u_button = QLineEdit('')
def int_func(val):
return str(int(val))
self.tesselation_u_edit.set_forward_connection(
self.tesselation_u_button, int_func)
self.tesselation_w = QLabel("Num_W")
self.tesselation_w_edit = QJumpSlider(QtCore.Qt.Horizontal)
self.tesselation_w_edit.setTickPosition(QSlider.TicksBelow)
self.tesselation_w_edit.setRange(1, 10)
self.tesselation_w_edit.setValue(num_w)
self.tesselation_w_button = QLineEdit('')
# --------------------------------------------------------------
density = 1.0
self.density = QLabel("Density")
self.density_edit = QLineEdit(str(density))
self.density_button = QCheckBox('Thin Shell')
priority = 3
priority_max = 50
self.priority = QLabel('Priority')
msg = (
'Components compete for volume during the mass properties.\n'
'A lower priority (e.g., 0) takes precendence. Additionally, \n'
'when combined with a density of 0.0, this can be used to \n'
'create voids (empty regions).')
self.priority.setToolTip(msg)
self.priority_edit = QSpinBox(self)
self.priority_edit.setRange(0, priority_max)
self.priority_edit.setSingleStep(1)
self.priority_edit.setValue(priority)
# --------------------------------------------------------------
self.negative_volume_button = QCheckBox('Negative Volume')
# --------------------------------------------------------------
#for key in self.colormap_keys:
#self.colormap_edit.addItem(key)
#self._colormap = 'grey'
#self.colormap_edit.setCurrentIndex(self.colormap_keys.index(self._colormap))
# --------------------------------------------------------------
# the header
self.grid2_title = QLabel("Color Scale:")
# on / off
self.show_radio = QRadioButton("Show")
self.hide_radio = QRadioButton("Hide")
widget = QWidget(self)
show_hide_group = QButtonGroup(widget)
# --------------------------------------------------------------
# closing
self.apply_button = QPushButton("Apply")
self.ok_button = QPushButton("OK")
self.cancel_button = QPushButton("Cancel")
def create_xform_widgets(self):
xloc = 0.0
yloc = 0.0
zloc = 0.0
xrot = 0.0
yrot = 0.0
zrot = 0.0
rot_origin_angle = 0.0
self.xloc = QLabel("X Loc")
self.xloc_edit = QJumpSlider(QtCore.Qt.Horizontal)
self.xloc_button = QLineEdit(str(xloc))
self.xloc_edit.set_forward_connection(self.xloc_button, float_func)
#self.xloc_edit.setTickPosition(QSlider.TicksBelow)
self.xloc_edit.setRange(1, 10)
self.xloc_edit.setValue(xloc)
self.yloc = QLabel("Y Loc")
self.yloc_edit = QJumpSlider(QtCore.Qt.Horizontal)
self.yloc_button = QLineEdit(str(yloc))
self.yloc_edit.set_forward_connection(self.yloc_button, float_func)
#self.yloc_edit.setTickPosition(QSlider.TicksBelow)
self.yloc_edit.setRange(1, 10)
self.yloc_edit.setValue(yloc)
self.zloc = QLabel("Z Loc")
self.zloc_edit = QJumpSlider(QtCore.Qt.Horizontal)
self.zloc_button = QLineEdit(str(zloc))
self.zloc_edit.set_forward_connection(self.zloc_button, float_func)
#self.zloc_edit.setTickPosition(QSlider.TicksBelow)
self.zloc_edit.setRange(1, 10)
self.zloc_edit.setValue(zloc)
self.xrot = QLabel("X Rot")
self.xrot_edit = QJumpSlider(QtCore.Qt.Horizontal)
self.xrot_button = QLineEdit(str(xrot))
self.xrot_edit.set_forward_connection(self.xrot_button, float_func)
#self.xrot_edit.setTickPosition(QSlider.TicksBelow)
self.xrot_edit.setRange(1, 10)
self.xrot_edit.setValue(xrot)
self.yrot = QLabel("Y Rot")
self.yrot_edit = QJumpSlider(QtCore.Qt.Horizontal)
self.yrot_button = QLineEdit(str(yrot))
self.yrot_edit.set_forward_connection(self.yrot_button, float_func)
#self.yrot_edit.setTickPosition(QSlider.TicksBelow)
self.yrot_edit.setRange(1, 10)
self.yrot_edit.setValue(yrot)
self.zrot = QLabel("Z Rot")
self.zrot_edit = QJumpSlider(QtCore.Qt.Horizontal)
self.zrot_button = QLineEdit(str(zrot))
self.zrot_edit.set_forward_connection(self.zrot_button, float_func)
#self.zrot_edit.setTickPosition(QSlider.TicksBelow)
self.zrot_edit.setRange(1, 10)
self.zrot_edit.setValue(zrot)
self.rot_origin = QLabel("Rot Origin (X)")
self.rot_origin_edit = QJumpSlider(QtCore.Qt.Horizontal)
self.rot_origin_button = QLineEdit(str(rot_origin_angle))
self.rot_origin_edit.set_forward_connection(self.rot_origin_button,
float_func)
#self.rot_origin_edit.setTickPosition(QSlider.TicksBelow)
self.rot_origin_edit.setRange(1, 10)
self.rot_origin_edit.setValue(rot_origin_angle)
def create_geom_layout(self):
group_name_color = QGroupBox('Name and Color')
group_tesselation = QGroupBox('Tesselation')
group_mass_properties = QGroupBox('Mass Properties')
group_cfd_mesh = QGroupBox('CFD Mesh')
grid_name_color = QGridLayout()
grid_name_color.addWidget(self.name, 0, 0)
grid_name_color.addWidget(self.name_edit, 0, 1)
grid_name_color.addWidget(self.colormap, 1, 0)
grid_name_color.addWidget(self.colormap_edit, 1, 1)
grid_name_color.addWidget(self.colormap_button, 1, 2)
group_name_color.setLayout(grid_name_color)
#--------------------------------------------------------
grid_tesselation = QGridLayout()
grid_tesselation.addWidget(self.tesselation_u, 2, 0)
grid_tesselation.addWidget(self.tesselation_u_edit, 2, 1)
grid_tesselation.addWidget(self.tesselation_u_button, 2, 2)
grid_tesselation.addWidget(self.tesselation_w, 3, 0)
grid_tesselation.addWidget(self.tesselation_w_edit, 3, 1)
grid_tesselation.addWidget(self.tesselation_w_button, 3, 2)
group_tesselation.setLayout(grid_tesselation)
#--------------------------------------------------------
grid_mass_properties = QGridLayout()
grid_mass_properties.addWidget(self.density, 4, 0)
grid_mass_properties.addWidget(self.density_edit, 4, 1)
grid_mass_properties.addWidget(self.density_button, 4, 2)
grid_mass_properties.addWidget(self.priority, 5, 0)
grid_mass_properties.addWidget(self.priority_edit, 5, 1)
group_mass_properties.setLayout(grid_mass_properties)
#--------------------------------------------------------
grid_cfd_mesh = QGridLayout()
grid_cfd_mesh.addWidget(self.negative_volume_button, 1, 0)
group_cfd_mesh.setLayout(grid_cfd_mesh)
#--------------------------------------------------------
# footer
ok_cancel_box = QHBoxLayout()
ok_cancel_box.addWidget(self.apply_button)
ok_cancel_box.addWidget(self.ok_button)
ok_cancel_box.addWidget(self.cancel_button)
grid2 = QGridLayout()
grid2.addWidget(self.grid2_title, 0, 0)
#grid2.addWidget(self.low_to_high_radio, 1, 0)
#grid2.addWidget(self.high_to_low_radio, 2, 0)
#grid2.addWidget(self.vertical_radio, 1, 1)
#grid2.addWidget(self.horizontal_radio, 2, 1)
grid2.addWidget(self.show_radio, 1, 2)
grid2.addWidget(self.hide_radio, 2, 2)
vbox = QVBoxLayout()
vbox.addWidget(group_name_color)
vbox.addWidget(group_tesselation)
vbox.addWidget(group_mass_properties)
vbox.addWidget(group_cfd_mesh)
#vbox.addLayout(checkboxes)
#vbox.addLayout(grid2)
vbox.addStretch()
vbox.addLayout(ok_cancel_box)
#--------------------------------------------------------
tab1 = QWidget()
tab1.setLayout(vbox)
return tab1
def create_xform_layout(self):
group_transforms = QGroupBox('Transforms')
group_symmetry = QGroupBox('Symmetry')
group_scale_factor = QGroupBox('Scale Factor')
group_attach_to_parent = QGroupBox('Attach To Parent')
#--------------------------------------------------------
grid_location = QGridLayout()
grid_location.addWidget(self.xloc, 0, 0)
grid_location.addWidget(self.xloc_edit, 0, 1)
grid_location.addWidget(self.xloc_button, 0, 2)
grid_location.addWidget(self.yloc, 1, 0)
grid_location.addWidget(self.yloc_edit, 1, 1)
grid_location.addWidget(self.yloc_button, 1, 2)
grid_location.addWidget(self.zloc, 2, 0)
grid_location.addWidget(self.zloc_edit, 2, 1)
grid_location.addWidget(self.zloc_button, 2, 2)
#-------------
grid_location.addWidget(self.xrot, 3, 0)
grid_location.addWidget(self.xrot_edit, 3, 1)
grid_location.addWidget(self.xrot_button, 3, 2)
grid_location.addWidget(self.yrot, 4, 0)
grid_location.addWidget(self.yrot_edit, 4, 1)
grid_location.addWidget(self.yrot_button, 4, 2)
grid_location.addWidget(self.zrot, 5, 0)
grid_location.addWidget(self.zrot_edit, 5, 1)
grid_location.addWidget(self.zrot_button, 5, 2)
grid_location.addWidget(self.rot_origin, 6, 0)
grid_location.addWidget(self.rot_origin_edit, 6, 1)
grid_location.addWidget(self.rot_origin_button, 6, 2)
group_transforms.setLayout(grid_location)
#--------------------------------------------------------
self.about = QLabel('About')
self.about_edit = QComboBox(self)
for attach_item in ['0 : Global Origin', '1 : WingGeom']:
self.about_edit.addItem(attach_item)
self.attach_object = QComboBox(self)
for attach_item in ['Attach', 'Object']:
self.attach_object.addItem(attach_item)
grid_symmetry = QHBoxLayout()
grid_symmetry.addWidget(self.about)
grid_symmetry.addWidget(self.about_edit)
grid_symmetry.addWidget(self.attach_object)
group_symmetry.setLayout(grid_symmetry)
#--------------------------------------------------------
scale = 1.1
self.scale = QLabel('Scale')
self.scale_edit = QJumpSlider(QtCore.Qt.Horizontal)
self.scale_button = QLineEdit(str(scale))
self.scale_edit.set_forward_connection(self.scale_button, float_func)
self.reset_button = QPushButton('Reset')
self.accept_button = QPushButton('Accept')
grid_scale_factor = QGridLayout()
grid_scale_factor.addWidget(self.scale, 0, 0)
grid_scale_factor.addWidget(self.scale_edit, 0, 1)
grid_scale_factor.addWidget(self.scale_button, 0, 2)
grid_scale_factor.addWidget(self.reset_button, 0, 3)
grid_scale_factor.addWidget(self.accept_button, 0, 4)
group_scale_factor.setLayout(grid_scale_factor)
#--------------------------------------------------------
grid_attach_to_parent = QGridLayout()
translate = QLabel('Translate:')
rotate = QLabel('Rotate:')
fzero_to_100 = lambda x: str(x / 100.)
uvalue = 0.5
wvalue = 0.6
uname = QLabel('U:')
uedit = QJumpSlider(QtCore.Qt.Horizontal)
ubutton = QLineEdit(str(uvalue))
uedit.set_forward_connection(ubutton, fzero_to_100)
uedit.setRange(0, 100)
wname = QLabel('W:')
wedit = QJumpSlider(QtCore.Qt.Horizontal)
wbutton = QLineEdit(str(wvalue))
wedit.set_forward_connection(wbutton, fzero_to_100)
wedit.setRange(0, 100)
self.translate_none = QCheckBox('None')
self.translate_comp = QCheckBox('Comp')
self.translate_uw = QCheckBox('UW')
self.rotate_none = QCheckBox('None')
self.rotate_comp = QCheckBox('Comp')
self.rotate_uw = QCheckBox('UW')
grid_attach_to_parent.addWidget(translate, 0, 0)
grid_attach_to_parent.addWidget(self.translate_none, 0, 1)
grid_attach_to_parent.addWidget(self.translate_comp, 0, 2)
grid_attach_to_parent.addWidget(self.translate_uw, 0, 3)
grid_attach_to_parent.addWidget(rotate, 1, 0)
grid_attach_to_parent.addWidget(self.rotate_none, 1, 1)
grid_attach_to_parent.addWidget(self.rotate_comp, 1, 2)
grid_attach_to_parent.addWidget(self.rotate_uw, 1, 3)
grid_attach_to_parent.addWidget(uname, 2, 0)
grid_attach_to_parent.addWidget(uedit, 2, 1)
grid_attach_to_parent.addWidget(ubutton, 2, 2)
grid_attach_to_parent.addWidget(wname, 3, 0)
grid_attach_to_parent.addWidget(wedit, 3, 1)
grid_attach_to_parent.addWidget(wbutton, 3, 2)
group_attach_to_parent.setLayout(grid_attach_to_parent)
#--------------------------------------------------------
vbox = QVBoxLayout()
vbox.addWidget(group_transforms)
vbox.addWidget(group_symmetry)
vbox.addWidget(group_scale_factor)
vbox.addWidget(group_attach_to_parent)
vbox.addStretch()
#--------------------------------------------------------
tab1 = QWidget()
tab1.setLayout(vbox)
return tab1
def create_subsurfaces_layout(self):
tab1 = QWidget()
#tab1.setLayout(vbox)
return tab1
def create_design_layout(self):
tab1 = QWidget()
#tab1.setLayout(vbox)
return tab1
def create_skinning_layout(self):
tab1 = QWidget()
#tab1.setLayout(vbox)
return tab1
def create_xsec_layout(self):
tab1 = QWidget()
#tab1.setLayout(vbox)
return tab1
def create_layout(self):
"""displays the menu objects"""
tab1 = self.create_geom_layout()
tab2 = self.create_xform_layout()
tab3 = self.create_subsurfaces_layout()
tab4 = self.create_design_layout()
tab5 = self.create_skinning_layout()
tab6 = self.create_xsec_layout()
tab3.setEnabled(False)
tab4.setEnabled(False)
tab5.setEnabled(False)
tab6.setEnabled(False)
#Create central widget, add layout and set
#central_widget = QtGui.QWidget()
#central_widget.setLayout(vbox)
#self.setCentralWidget(central_widget)
tabs = QTabWidget()
tabs.addTab(tab1, "Geom")
tabs.addTab(tab2, "XForm")
tabs.addTab(tab3, "Sub-Surfaces") # 2
tabs.addTab(tab4, "Design")
tabs.addTab(tab5, "Skinning")
tabs.addTab(tab6, "X-Sec")
tabs.setTabEnabled(2, False) # 0-based
tabs.setTabEnabled(3, False) # 0-based
tabs.setTabEnabled(4, False) # 0-based
tabs.setTabEnabled(5, False) # 0-based
#=================================================================
vbox2 = QVBoxLayout()
vbox2.addWidget(tabs)
self.setLayout(vbox2)
def set_connections(self):
"""creates the actions for the buttons"""
self.name_button.clicked.connect(self.on_default_name)
self.min_button.clicked.connect(self.on_default_min)
self.max_button.clicked.connect(self.on_default_max)
self.format_button.clicked.connect(self.on_default_format)
self.scale_button.clicked.connect(self.on_default_scale)
self.phase_button.clicked.connect(self.on_default_phase)
self.nlabels_button.clicked.connect(self.on_default_nlabels)
self.labelsize_button.clicked.connect(self.on_default_labelsize)
self.ncolors_button.clicked.connect(self.on_default_ncolors)
self.colormap_button.clicked.connect(self.on_default_colormap)
self.animate_button.clicked.connect(self.on_animate)
self.show_radio.clicked.connect(self.on_show_hide)
self.hide_radio.clicked.connect(self.on_show_hide)
self.apply_button.clicked.connect(self.on_apply)
self.ok_button.clicked.connect(self.on_ok)
self.cancel_button.clicked.connect(self.on_cancel)
if qt_version == 4:
self.connect(self, QtCore.SIGNAL('triggered()'), self.closeEvent)
#self.colormap_edit.activated[str].connect(self.onActivated)
#else:
# closeEvent???
def set_font_size(self, font_size):
"""
Updates the font size of the objects
Parameters
----------
font_size : int
the font size
"""
return
if self.font_size == font_size:
return
self.font_size = font_size
font = QFont()
font.setPointSize(font_size)
self.setFont(font)
#self.name_edit.setFont(font)
#self.min_edit.setFont(font)
#self.max_edit.setFont(font)
#self.format_edit.setFont(font)
#self.scale_edit.setFont(font)
#self.phase_edit.setFont(font)
#self.nlabels_edit.setFont(font)
#self.labelsize_edit.setFont(font)
#self.ncolors_edit.setFont(font)
def on_default_name(self):
"""action when user clicks 'Default' for name"""
name = str(self._default_name)
self.name_edit.setText(name)
self.name_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_min(self):
"""action when user clicks 'Default' for min value"""
self.min_edit.setText(str(self._default_min))
self.min_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_max(self):
"""action when user clicks 'Default' for max value"""
self.max_edit.setText(str(self._default_max))
self.max_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_format(self):
"""action when user clicks 'Default' for the number format"""
self.format_edit.setText(str(self._default_format))
self.format_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_scale(self):
"""action when user clicks 'Default' for scale factor"""
self.scale_edit.setText(str(self._default_scale))
self.scale_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_phase(self):
"""action when user clicks 'Default' for phase angle"""
self.phase_edit.setText(str(self._default_phase))
self.phase_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_ncolors(self):
"""action when user clicks 'Default' for number of colors"""
self.ncolors_edit.setText(str(self._default_ncolors))
self.ncolors_edit.setStyleSheet("QLineEdit{background: white;}")
#def on_default_colormap(self):
#"""action when user clicks 'Default' for the color map"""
#self.colormap_edit.setCurrentIndex(colormap_keys.index(self._default_colormap))
def on_default_nlabels(self):
"""action when user clicks 'Default' for number of labels"""
self.nlabels_edit.setStyleSheet("QLineEdit{background: white;}")
self.nlabels_edit.setText(str(self._default_nlabels))
def on_default_labelsize(self):
"""action when user clicks 'Default' for number of labelsize"""
self.labelsize_edit.setText(str(self._default_labelsize))
self.labelsize_edit.setStyleSheet("QLineEdit{background: white;}")
def on_show_hide(self):
"""action when user clicks the 'Show/Hide' radio button"""
self.colormap_edit.setCurrentIndex(
colormap_keys.index(self._default_colormap))
is_shown = self.show_radio.isChecked()
self.vertical_radio.setEnabled(is_shown)
self.horizontal_radio.setEnabled(is_shown)
@staticmethod
def check_name(cell):
cell_value = cell.text()
try:
text = str(cell_value).strip()
except UnicodeEncodeError:
cell.setStyleSheet("QLineEdit{background: red;}")
return None, False
if len(text):
cell.setStyleSheet("QLineEdit{background: white;}")
return text, True
else:
cell.setStyleSheet("QLineEdit{background: red;}")
return None, False
#@staticmethod
#def check_colormap(cell):
#text = str(cell.text()).strip()
#if text in colormap_keys:
#cell.setStyleSheet("QLineEdit{background: white;}")
#return text, True
#else:
#cell.setStyleSheet("QLineEdit{background: red;}")
#return None, False
def on_validate(self):
name_value, flag0 = self.check_name(self.name_edit)
min_value, flag1 = self.check_float(self.min_edit)
max_value, flag2 = self.check_float(self.max_edit)
format_value, flag3 = self.check_format(self.format_edit)
scale, flag4 = self.check_float(self.scale_edit)
phase, flag5 = self.check_float(self.phase_edit)
nlabels, flag6 = self.check_positive_int_or_blank(self.nlabels_edit)
ncolors, flag7 = self.check_positive_int_or_blank(self.ncolors_edit)
labelsize, flag8 = self.check_positive_int_or_blank(
self.labelsize_edit)
colormap = str(self.colormap_edit.currentText())
if all([flag0, flag1, flag2, flag3, flag4, flag5, flag6, flag7,
flag8]):
if 'i' in format_value:
format_value = '%i'
assert isinstance(scale, float), scale
self.out_data['name'] = name_value
self.out_data['min'] = min_value
self.out_data['max'] = max_value
self.out_data['format'] = format_value
self.out_data['scale'] = scale
self.out_data['phase'] = phase
self.out_data['nlabels'] = nlabels
self.out_data['ncolors'] = ncolors
self.out_data['labelsize'] = labelsize
self.out_data['colormap'] = colormap
self.out_data['is_low_to_high'] = self.low_to_high_radio.isChecked(
)
self.out_data['is_horizontal'] = self.horizontal_radio.isChecked()
self.out_data['is_shown'] = self.show_radio.isChecked()
self.out_data['clicked_ok'] = True
self.out_data['close'] = True
#print('self.out_data = ', self.out_data)
#print("name = %r" % self.name_edit.text())
#print("min = %r" % self.min_edit.text())
#print("max = %r" % self.max_edit.text())
#print("format = %r" % self.format_edit.text())
return True
return False
def on_apply(self):
passed = self.on_validate()
if passed:
self.win_parent._apply_legend(self.out_data)
return passed
def on_ok(self):
passed = self.on_apply()
if passed:
self.close()
#self.destroy()
def on_cancel(self):
self.out_data['close'] = True
self.close()
def _setup_views(self):
"""Creates the UI widgets."""
self.central_splitter = QSplitter(self, orientation=Qt.Vertical)
layout = create_plugin_layout(self.tools_layout, self.central_splitter)
self.setLayout(layout)
# Stretch last column?
# It doesn't play nice when columns are hidden and then shown again.
obj_tree_header = self.obj_tree.header()
obj_tree_header.setSectionsMovable(True)
obj_tree_header.setStretchLastSection(False)
add_actions(self.show_cols_submenu,
self.obj_tree.toggle_column_actions_group.actions())
self.central_splitter.addWidget(self.obj_tree)
# Bottom pane
bottom_pane_widget = QWidget()
bottom_layout = QHBoxLayout()
bottom_layout.setSpacing(0)
bottom_layout.setContentsMargins(5, 5, 5, 5) # left top right bottom
bottom_pane_widget.setLayout(bottom_layout)
self.central_splitter.addWidget(bottom_pane_widget)
group_box = QGroupBox(_("Details"))
bottom_layout.addWidget(group_box)
v_group_layout = QVBoxLayout()
h_group_layout = QHBoxLayout()
h_group_layout.setContentsMargins(2, 2, 2, 2) # left top right bottom
group_box.setLayout(v_group_layout)
v_group_layout.addLayout(h_group_layout)
# Radio buttons
radio_widget = QWidget()
radio_layout = QVBoxLayout()
radio_layout.setContentsMargins(0, 0, 0, 0) # left top right bottom
radio_widget.setLayout(radio_layout)
self.button_group = QButtonGroup(self)
for button_id, attr_detail in enumerate(self._attr_details):
radio_button = QRadioButton(attr_detail.name)
radio_layout.addWidget(radio_button)
self.button_group.addButton(radio_button, button_id)
self.button_group.buttonClicked[int].connect(
self._change_details_field)
self.button_group.button(0).setChecked(True)
radio_layout.addStretch(1)
h_group_layout.addWidget(radio_widget)
# Editor widget
self.editor = SimpleCodeEditor(self)
self.editor.setReadOnly(True)
h_group_layout.addWidget(self.editor)
# Save and close buttons
btn_layout = QHBoxLayout()
btn_layout.addStretch()
if not self.readonly:
self.btn_save_and_close = QPushButton(_('Save and Close'))
self.btn_save_and_close.setDisabled(True)
self.btn_save_and_close.clicked.connect(self.accept)
btn_layout.addWidget(self.btn_save_and_close)
self.btn_close = QPushButton(_('Close'))
self.btn_close.setAutoDefault(True)
self.btn_close.setDefault(True)
self.btn_close.clicked.connect(self.reject)
btn_layout.addWidget(self.btn_close)
v_group_layout.addLayout(btn_layout)
# Splitter parameters
self.central_splitter.setCollapsible(0, False)
self.central_splitter.setCollapsible(1, True)
self.central_splitter.setSizes([500, 320])
# Connect signals
# Keep a temporary reference of the selection_model to prevent
# segfault in PySide.
# See http://permalink.gmane.org/gmane.comp.lib.qt.pyside.devel/222
selection_model = self.obj_tree.selectionModel()
selection_model.currentChanged.connect(self._update_details)
# Check if the values of the model have been changed
self._proxy_tree_model.sig_setting_data.connect(
self.save_and_close_enable)
self._proxy_tree_model.sig_update_details.connect(
self._update_details_for_item)
def create_general_widgets(self):
"""creates the menu objects"""
# --------------------------------------------------------------
# Name
self.name = QLabel("Name:")
self.name_edit = QLineEdit(str(self._default_name))
self.colormap = QLabel("Color:")
self.colormap_edit = QPushButtonColor(self._color_int,
'Select a color',
parent=self)
self.colormap_button = QPushButton("Advanced")
self.colormap_button.setEnabled(False)
# --------------------------------------------------------------
# TODO: the way these sliders work is they have some defined range
# if you go outside the range, they "reset" to 50% and
# are redefined from value-delta to value+delta, where
# delta=nominal/2
num_u = 5
num_w = 10
self.tesselation_u = QLabel("Num_U")
self.tesselation_u_edit = QJumpSlider(QtCore.Qt.Horizontal)
self.tesselation_u_edit.setTickPosition(QSlider.TicksBelow)
self.tesselation_u_edit.setRange(1, 10)
self.tesselation_u_edit.setValue(num_u)
self.tesselation_u_button = QLineEdit('')
def int_func(val):
return str(int(val))
self.tesselation_u_edit.set_forward_connection(
self.tesselation_u_button, int_func)
self.tesselation_w = QLabel("Num_W")
self.tesselation_w_edit = QJumpSlider(QtCore.Qt.Horizontal)
self.tesselation_w_edit.setTickPosition(QSlider.TicksBelow)
self.tesselation_w_edit.setRange(1, 10)
self.tesselation_w_edit.setValue(num_w)
self.tesselation_w_button = QLineEdit('')
# --------------------------------------------------------------
density = 1.0
self.density = QLabel("Density")
self.density_edit = QLineEdit(str(density))
self.density_button = QCheckBox('Thin Shell')
priority = 3
priority_max = 50
self.priority = QLabel('Priority')
msg = (
'Components compete for volume during the mass properties.\n'
'A lower priority (e.g., 0) takes precendence. Additionally, \n'
'when combined with a density of 0.0, this can be used to \n'
'create voids (empty regions).')
self.priority.setToolTip(msg)
self.priority_edit = QSpinBox(self)
self.priority_edit.setRange(0, priority_max)
self.priority_edit.setSingleStep(1)
self.priority_edit.setValue(priority)
# --------------------------------------------------------------
self.negative_volume_button = QCheckBox('Negative Volume')
# --------------------------------------------------------------
#for key in self.colormap_keys:
#self.colormap_edit.addItem(key)
#self._colormap = 'grey'
#self.colormap_edit.setCurrentIndex(self.colormap_keys.index(self._colormap))
# --------------------------------------------------------------
# the header
self.grid2_title = QLabel("Color Scale:")
# on / off
self.show_radio = QRadioButton("Show")
self.hide_radio = QRadioButton("Hide")
widget = QWidget(self)
show_hide_group = QButtonGroup(widget)
# --------------------------------------------------------------
# closing
self.apply_button = QPushButton("Apply")
self.ok_button = QPushButton("OK")
self.cancel_button = QPushButton("Cancel")
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)
self.ws_btn = QRadioButton(_("Whitespace"))
self.ws_btn.setChecked(False)
col_btn_layout.addWidget(self.ws_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 ProjectDialog(QDialog):
"""Project creation dialog."""
# path, type, packages
sig_project_creation_requested = Signal(object, object, object)
def __init__(self, parent):
"""Project creation dialog."""
super(ProjectDialog, self).__init__(parent=parent)
# Variables
current_python_version = '.'.join([
to_text_string(sys.version_info[0]),
to_text_string(sys.version_info[1])
])
python_versions = ['2.7', '3.4', '3.5']
if current_python_version not in python_versions:
python_versions.append(current_python_version)
python_versions = sorted(python_versions)
self.project_name = None
self.location = get_home_dir()
# Widgets
self.groupbox = QGroupBox()
self.radio_new_dir = QRadioButton(_("New directory"))
self.radio_from_dir = QRadioButton(_("Existing directory"))
self.label_project_name = QLabel(_('Project name'))
self.label_location = QLabel(_('Location'))
self.label_project_type = QLabel(_('Project type'))
self.label_python_version = QLabel(_('Python version'))
self.text_project_name = QLineEdit()
self.text_location = QLineEdit(get_home_dir())
self.combo_project_type = QComboBox()
self.combo_python_version = QComboBox()
self.button_select_location = QToolButton()
self.button_cancel = QPushButton(_('Cancel'))
self.button_create = QPushButton(_('Create'))
self.bbox = QDialogButtonBox(Qt.Horizontal)
self.bbox.addButton(self.button_cancel, QDialogButtonBox.ActionRole)
self.bbox.addButton(self.button_create, QDialogButtonBox.ActionRole)
# Widget setup
self.combo_python_version.addItems(python_versions)
self.radio_new_dir.setChecked(True)
self.text_location.setEnabled(True)
self.text_location.setReadOnly(True)
self.button_select_location.setIcon(get_std_icon('DirOpenIcon'))
self.button_cancel.setDefault(True)
self.button_cancel.setAutoDefault(True)
self.button_create.setEnabled(False)
self.combo_project_type.addItems(self._get_project_types())
self.combo_python_version.setCurrentIndex(
python_versions.index(current_python_version))
self.setWindowTitle(_('Create new project'))
self.setFixedWidth(500)
self.label_python_version.setVisible(False)
self.combo_python_version.setVisible(False)
# Layouts
layout_top = QHBoxLayout()
layout_top.addWidget(self.radio_new_dir)
layout_top.addWidget(self.radio_from_dir)
layout_top.addStretch(1)
self.groupbox.setLayout(layout_top)
layout_grid = QGridLayout()
layout_grid.addWidget(self.label_project_name, 0, 0)
layout_grid.addWidget(self.text_project_name, 0, 1, 1, 2)
layout_grid.addWidget(self.label_location, 1, 0)
layout_grid.addWidget(self.text_location, 1, 1)
layout_grid.addWidget(self.button_select_location, 1, 2)
layout_grid.addWidget(self.label_project_type, 2, 0)
layout_grid.addWidget(self.combo_project_type, 2, 1, 1, 2)
layout_grid.addWidget(self.label_python_version, 3, 0)
layout_grid.addWidget(self.combo_python_version, 3, 1, 1, 2)
layout = QVBoxLayout()
layout.addWidget(self.groupbox)
layout.addSpacing(10)
layout.addLayout(layout_grid)
layout.addStretch()
layout.addSpacing(20)
layout.addWidget(self.bbox)
self.setLayout(layout)
# Signals and slots
self.button_select_location.clicked.connect(self.select_location)
self.button_create.clicked.connect(self.create_project)
self.button_cancel.clicked.connect(self.close)
self.radio_from_dir.clicked.connect(self.update_location)
self.radio_new_dir.clicked.connect(self.update_location)
self.text_project_name.textChanged.connect(self.update_location)
def _get_project_types(self):
"""Get all available project types."""
project_types = get_available_project_types()
projects = []
for project in project_types:
projects.append(project.PROJECT_TYPE_NAME)
return projects
def select_location(self):
"""Select directory."""
location = getexistingdirectory(self, _("Select directory"),
self.location)
if location:
if is_writable(location):
self.location = location
self.update_location()
def update_location(self, text=''):
"""Update text of location."""
self.text_project_name.setEnabled(self.radio_new_dir.isChecked())
name = self.text_project_name.text().strip()
if name and self.radio_new_dir.isChecked():
path = osp.join(self.location, name)
self.button_create.setDisabled(os.path.isdir(path))
elif self.radio_from_dir.isChecked():
self.button_create.setEnabled(True)
path = self.location
else:
self.button_create.setEnabled(False)
path = self.location
self.text_location.setText(path)
def create_project(self):
"""Create project."""
packages = [
'python={0}'.format(self.combo_python_version.currentText())
]
self.sig_project_creation_requested.emit(
self.text_location.text(), self.combo_project_type.currentText(),
packages)
self.accept()
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)
def __init__(self, parent):
"""Project creation dialog."""
super(ProjectDialog, self).__init__(parent=parent)
# Variables
current_python_version = '.'.join([
to_text_string(sys.version_info[0]),
to_text_string(sys.version_info[1])
])
python_versions = ['2.7', '3.4', '3.5']
if current_python_version not in python_versions:
python_versions.append(current_python_version)
python_versions = sorted(python_versions)
self.project_name = None
self.location = get_home_dir()
# Widgets
self.groupbox = QGroupBox()
self.radio_new_dir = QRadioButton(_("New directory"))
self.radio_from_dir = QRadioButton(_("Existing directory"))
self.label_project_name = QLabel(_('Project name'))
self.label_location = QLabel(_('Location'))
self.label_project_type = QLabel(_('Project type'))
self.label_python_version = QLabel(_('Python version'))
self.text_project_name = QLineEdit()
self.text_location = QLineEdit(get_home_dir())
self.combo_project_type = QComboBox()
self.combo_python_version = QComboBox()
self.button_select_location = QToolButton()
self.button_cancel = QPushButton(_('Cancel'))
self.button_create = QPushButton(_('Create'))
self.bbox = QDialogButtonBox(Qt.Horizontal)
self.bbox.addButton(self.button_cancel, QDialogButtonBox.ActionRole)
self.bbox.addButton(self.button_create, QDialogButtonBox.ActionRole)
# Widget setup
self.combo_python_version.addItems(python_versions)
self.radio_new_dir.setChecked(True)
self.text_location.setEnabled(True)
self.text_location.setReadOnly(True)
self.button_select_location.setIcon(get_std_icon('DirOpenIcon'))
self.button_cancel.setDefault(True)
self.button_cancel.setAutoDefault(True)
self.button_create.setEnabled(False)
self.combo_project_type.addItems(self._get_project_types())
self.combo_python_version.setCurrentIndex(
python_versions.index(current_python_version))
self.setWindowTitle(_('Create new project'))
self.setFixedWidth(500)
self.label_python_version.setVisible(False)
self.combo_python_version.setVisible(False)
# Layouts
layout_top = QHBoxLayout()
layout_top.addWidget(self.radio_new_dir)
layout_top.addWidget(self.radio_from_dir)
layout_top.addStretch(1)
self.groupbox.setLayout(layout_top)
layout_grid = QGridLayout()
layout_grid.addWidget(self.label_project_name, 0, 0)
layout_grid.addWidget(self.text_project_name, 0, 1, 1, 2)
layout_grid.addWidget(self.label_location, 1, 0)
layout_grid.addWidget(self.text_location, 1, 1)
layout_grid.addWidget(self.button_select_location, 1, 2)
layout_grid.addWidget(self.label_project_type, 2, 0)
layout_grid.addWidget(self.combo_project_type, 2, 1, 1, 2)
layout_grid.addWidget(self.label_python_version, 3, 0)
layout_grid.addWidget(self.combo_python_version, 3, 1, 1, 2)
layout = QVBoxLayout()
layout.addWidget(self.groupbox)
layout.addSpacing(10)
layout.addLayout(layout_grid)
layout.addStretch()
layout.addSpacing(20)
layout.addWidget(self.bbox)
self.setLayout(layout)
# Signals and slots
self.button_select_location.clicked.connect(self.select_location)
self.button_create.clicked.connect(self.create_project)
self.button_cancel.clicked.connect(self.close)
self.radio_from_dir.clicked.connect(self.update_location)
self.radio_new_dir.clicked.connect(self.update_location)
self.text_project_name.textChanged.connect(self.update_location)
class ContentsWidget(QWidget):
"""Import wizard contents widget"""
asDataChanged = Signal(bool)
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 get_as_data(self):
"""Return if data type conversion"""
return self._as_data
def get_as_code(self):
"""Return if code type conversion"""
return self._as_code
def get_as_num(self):
"""Return if numeric type conversion"""
return self._as_num
def get_col_sep(self):
"""Return the column separator"""
if self.tab_btn.isChecked():
return u"\t"
return to_text_string(self.line_edt.text())
def get_row_sep(self):
"""Return the row separator"""
if self.eol_btn.isChecked():
return u"\n"
return to_text_string(self.line_edt_row.text())
def get_skiprows(self):
"""Return number of lines to be skipped"""
return int(to_text_string(self.skiprows_edt.text()))
def get_comments(self):
"""Return comment string"""
return to_text_string(self.comments_edt.text())
@Slot(bool)
def set_as_data(self, as_data):
"""Set if data type conversion"""
self._as_data = as_data
self.asDataChanged.emit(as_data)
@Slot(bool)
def set_as_code(self, as_code):
"""Set if code type conversion"""
self._as_code = as_code
class KernelConnectionDialog(QDialog, SpyderConfigurationAccessor):
"""Dialog to connect to existing kernels (either local or remote)."""
CONF_SECTION = 'existing-kernel'
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)
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.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.save_connection_settings)
self.accept_btns.accepted.connect(self.accept)
self.accept_btns.rejected.connect(self.reject)
# Save connection settings checkbox
self.save_layout = QCheckBox(self)
self.save_layout.setText(_("Save connection settings"))
btns_layout = QHBoxLayout()
btns_layout.addWidget(self.save_layout)
btns_layout.addWidget(self.accept_btns)
# 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.addLayout(btns_layout)
self.cf.setFocus()
self.load_connection_settings()
def load_connection_settings(self):
"""Load the user's previously-saved kernel connection settings."""
existing_kernel = self.get_conf("settings", {})
connection_file_path = existing_kernel.get("json_file_path", "")
is_remote = existing_kernel.get("is_remote", False)
username = existing_kernel.get("username", "")
hostname = existing_kernel.get("hostname", "")
port = str(existing_kernel.get("port", 22))
is_ssh_kf = existing_kernel.get("is_ssh_keyfile", False)
ssh_kf = existing_kernel.get("ssh_key_file_path", "")
if connection_file_path != "":
self.cf.setText(connection_file_path)
if username != "":
self.un.setText(username)
if hostname != "":
self.hn.setText(hostname)
if ssh_kf != "":
self.kf.setText(ssh_kf)
self.rm_group.setChecked(is_remote)
self.pn.setText(port)
self.kf_radio.setChecked(is_ssh_kf)
self.pw_radio.setChecked(not is_ssh_kf)
try:
import keyring
ssh_passphrase = keyring.get_password("spyder_remote_kernel",
"ssh_key_passphrase")
ssh_password = keyring.get_password("spyder_remote_kernel",
"ssh_password")
if ssh_passphrase:
self.kfp.setText(ssh_passphrase)
if ssh_password:
self.pw.setText(ssh_password)
except Exception:
pass
def save_connection_settings(self):
"""Save user's kernel connection settings."""
if not self.save_layout.isChecked():
return
is_ssh_key = bool(self.kf_radio.isChecked())
connection_settings = {
"json_file_path": self.cf.text(),
"is_remote": self.rm_group.isChecked(),
"username": self.un.text(),
"hostname": self.hn.text(),
"port": self.pn.text(),
"is_ssh_keyfile": is_ssh_key,
"ssh_key_file_path": self.kf.text()
}
self.set_conf("settings", connection_settings)
try:
import keyring
if is_ssh_key:
keyring.set_password("spyder_remote_kernel",
"ssh_key_passphrase", self.kfp.text())
else:
keyring.set_password("spyder_remote_kernel", "ssh_password",
self.pw.text())
except Exception:
pass
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, 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)
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.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.save_connection_settings)
self.accept_btns.accepted.connect(self.accept)
self.accept_btns.rejected.connect(self.reject)
# Save connection settings checkbox
self.save_layout = QCheckBox(self)
self.save_layout.setText(_("Save connection settings"))
btns_layout = QHBoxLayout()
btns_layout.addWidget(self.save_layout)
btns_layout.addWidget(self.accept_btns)
# 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.addLayout(btns_layout)
self.cf.setFocus()
self.load_connection_settings()
def __init__(self, settings):
BaseWidget.__init__(self, settings=settings)
inf = float('inf')
def set_spin(spin, minVal=-inf, maxVal=+inf, decimals=3):
spin.setRange(minVal, maxVal)
spin.setDecimals(decimals)
spin.setSingleStep(0.01)
def tip(widget, text):
if text:
widget.setToolTip(text)
return widget
def setEnabled(widget, *widgets):
"""enables widget, when value of all widgets evaluates to true"""
def setEnabled():
widget.setEnabled(all(w.isChecked() for w in widgets))
for w in widgets:
w.toggled.connect(setEnabled)
return widget
def DoubleEdit():
edit = SmallQLineEdit()
edit.setValidator(QDoubleValidator())
return edit
# ui data elements
self.prefix = tip(QLineEdit(), self.TIP_prefix)
self.dataDir = tip(QLineEdit(), self.TIP_dataDir)
self.saveDir = tip(QLineEdit(), self.TIP_saveDir)
self.vanRuns = tip(QLineEdit(), self.TIP_vanRuns)
self.vanCmnt = tip(QLineEdit(), self.TIP_vanCmnt)
self.vanTemp = tip(DoubleEdit(), self.TIP_vanTemp)
self.ecRuns = tip(SmallQLineEdit(), self.TIP_ecRuns)
self.ecTemp = tip(DoubleEdit(), self.TIP_ecTemp)
self.ecFactor = tip(QDoubleSpinBox(), self.TIP_ecFactor)
set_spin(self.ecFactor, 0, 1)
self.binEon = tip(QCheckBox(), self.TIP_binEon)
self.binEstart = setEnabled(tip(QDoubleSpinBox(), self.TIP_binEstart),
self.binEon)
self.binEstep = setEnabled(tip(QDoubleSpinBox(), self.TIP_binEstep),
self.binEon)
self.binEend = setEnabled(tip(QDoubleSpinBox(), self.TIP_binEend),
self.binEon)
set_spin(self.binEstart)
set_spin(self.binEstep, decimals=4)
set_spin(self.binEend)
self.binQon = setEnabled(tip(QCheckBox(), self.TIP_binQon),
self.binEon)
self.binQstart = setEnabled(tip(QDoubleSpinBox(), self.TIP_binQstart),
self.binEon, self.binQon)
self.binQstep = setEnabled(tip(QDoubleSpinBox(), self.TIP_binQstep),
self.binEon, self.binQon)
self.binQend = setEnabled(tip(QDoubleSpinBox(), self.TIP_binQend),
self.binEon, self.binQon)
set_spin(self.binQstart)
set_spin(self.binQstep)
set_spin(self.binQend)
self.maskDetectors = tip(QLineEdit(), self.TIP_maskDetectors)
headers = ('Data runs', 'Comment', 'T (K)')
self.dataRunsView = tip(
DataTableView(self, headers,
TOFTOFSetupWidget.TofTofDataTableModel),
self.TIP_dataRunsView)
self.dataRunsView.horizontalHeader().setStretchLastSection(True)
self.dataRunsView.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.runDataModel = self.dataRunsView.model()
# ui controls
self.btnDataDir = tip(QPushButton('Browse'), self.TIP_btnDataDir)
self.btnSaveDir = tip(QPushButton('Browse'), self.TIP_btnSaveDir)
self.chkSubtractECVan = tip(
QCheckBox('Subtract empty can from vanadium'),
self.TIP_chkSubtractECVan)
self.vanEcFactor = setEnabled(
tip(QDoubleSpinBox(), self.TIP_vanEcFactor), self.chkSubtractECVan)
set_spin(self.vanEcFactor, 0, 1)
self.chkReplaceNaNs = setEnabled(
tip(QCheckBox(u'Replace special values in S(Q, ω) with 0'),
self.TIP_chkReplaceNaNs), self.binEon)
self.chkCreateDiff = setEnabled(
tip(QCheckBox('Create diffractograms'), self.TIP_chkCreateDiff),
self.binEon)
self.chkKeepSteps = tip(QCheckBox('Keep intermediate steps'),
self.TIP_chkKeepSteps)
self.chkSofTWNxspe = setEnabled(
tip(QCheckBox('NXSPE'), self.TIP_chkNxspe), self.binEon)
self.chkSofTWNexus = tip(QCheckBox('NeXus'), self.TIP_chkNexus)
self.chkSofTWAscii = tip(QCheckBox('Ascii'), self.TIP_chkAscii)
self.chkSofQWNexus = setEnabled(
tip(QCheckBox('NeXus'), self.TIP_chkNexus), self.binEon,
self.binQon)
self.chkSofQWAscii = setEnabled(
tip(QCheckBox('Ascii'), self.TIP_chkAscii), self.binEon,
self.binQon)
self.rbtNormaliseNone = tip(QRadioButton('none'),
self.TIP_rbtNormaliseNone)
self.rbtNormaliseMonitor = tip(QRadioButton('to monitor'),
self.TIP_rbtNormaliseMonitor)
self.rbtNormaliseTime = tip(QRadioButton('to time'),
self.TIP_rbtNormaliseTime)
self.rbtCorrectTOFNone = tip(QRadioButton('none'),
self.TIP_rbtCorrectTOFNone)
self.rbtCorrectTOFVan = tip(QRadioButton('vanadium'),
self.TIP_rbtCorrectTOFVan)
self.rbtCorrectTOFSample = tip(QRadioButton('sample'),
self.TIP_rbtCorrectTOFSample)
# ui layout
def _box(cls, widgets):
box = cls()
for wgt in widgets:
if isinstance(wgt, QLayout):
box.addLayout(wgt)
elif isinstance(wgt, QWidget):
box.addWidget(wgt)
else:
box.addStretch(wgt)
return box
def hbox(*widgets):
return _box(QHBoxLayout, widgets)
def vbox(*widgets):
return _box(QVBoxLayout, widgets)
def label(text, tip):
label = QLabel(text)
if tip:
label.setToolTip(tip)
return label
self.gbSave = QGroupBox('Save reduced data')
self.gbSave.setCheckable(True)
gbDataDir = QGroupBox('Data search directory')
gbPrefix = QGroupBox('Workspace prefix')
gbOptions = QGroupBox('Options')
gbInputs = QGroupBox('Inputs')
gbBinning = QGroupBox('Binning')
gbData = QGroupBox('Data')
box = QVBoxLayout()
self._layout.addLayout(box)
box.addLayout(
hbox(vbox(gbDataDir, gbInputs, gbBinning, gbOptions, 1),
vbox(gbPrefix, gbData, self.gbSave)))
gbDataDir.setLayout(hbox(self.dataDir, self.btnDataDir))
gbPrefix.setLayout(hbox(self.prefix, ))
grid = QGridLayout()
grid.addWidget(self.chkSubtractECVan, 0, 0, 1, 4)
grid.addWidget(label('Normalise', 'tip'), 1, 0)
grid.addWidget(self.rbtNormaliseNone, 1, 1)
grid.addWidget(self.rbtNormaliseMonitor, 1, 2)
grid.addWidget(self.rbtNormaliseTime, 1, 3)
grid.addWidget(QLabel('Correct TOF'), 2, 0)
grid.addWidget(self.rbtCorrectTOFNone, 2, 1)
grid.addWidget(self.rbtCorrectTOFVan, 2, 2)
grid.addWidget(self.rbtCorrectTOFSample, 2, 3)
grid.addWidget(self.chkReplaceNaNs, 3, 0, 1, 4)
grid.addWidget(self.chkCreateDiff, 4, 0, 1, 4)
grid.addWidget(self.chkKeepSteps, 5, 0, 1, 4)
grid.setColumnStretch(4, 1)
gbOptions.setLayout(grid)
btnGroup = QButtonGroup(self)
btnGroup.addButton(self.rbtNormaliseNone)
btnGroup.addButton(self.rbtNormaliseMonitor)
btnGroup.addButton(self.rbtNormaliseTime)
btnGroup = QButtonGroup(self)
btnGroup.addButton(self.rbtCorrectTOFNone)
btnGroup.addButton(self.rbtCorrectTOFVan)
btnGroup.addButton(self.rbtCorrectTOFSample)
grid = QGridLayout()
grid.addWidget(QLabel('Vanadium runs'), 0, 0)
grid.addWidget(self.vanRuns, 0, 1, 1, 3)
grid.addWidget(QLabel('Van. comment'), 1, 0)
grid.addWidget(self.vanCmnt, 1, 1, 1, 1)
grid.addLayout(hbox(QLabel('EC factor'), self.vanEcFactor), 1, 2, 1, 1)
grid.addLayout(hbox(QLabel('T (K)'), self.vanTemp), 1, 3)
grid.addWidget(QLabel('Empty can runs'), 2, 0)
grid.addWidget(self.ecRuns, 2, 1, 1, 1)
grid.addLayout(hbox(QLabel('EC factor'), self.ecFactor), 2, 2, 1, 1)
grid.addLayout(hbox(QLabel('T (K)'), self.ecTemp), 2, 3)
grid.addWidget(QLabel('Mask detectors'), 3, 0)
grid.addWidget(self.maskDetectors, 3, 1, 1, 3)
gbInputs.setLayout(grid)
grid = QGridLayout()
grid.addWidget(QLabel('on'), 0, 1)
grid.addWidget(QLabel('start'), 0, 2)
grid.addWidget(QLabel('step'), 0, 3)
grid.addWidget(QLabel('end'), 0, 4)
grid.addWidget(QLabel('Energy'), 1, 0)
grid.addWidget(self.binEon, 1, 1)
grid.addWidget(self.binEstart, 1, 2)
grid.addWidget(self.binEstep, 1, 3)
grid.addWidget(self.binEend, 1, 4)
grid.addWidget(QLabel('Q'), 2, 0)
grid.addWidget(self.binQon, 2, 1)
grid.addWidget(self.binQstart, 2, 2)
grid.addWidget(self.binQstep, 2, 3)
grid.addWidget(self.binQend, 2, 4)
for col in (0, 2, 3, 4):
grid.setColumnStretch(col, 1)
gbBinning.setLayout(grid)
gbData.setLayout(hbox(self.dataRunsView))
grid = QGridLayout()
saveDirGroup = hbox(self.saveDir, self.btnSaveDir)
grid.addWidget(QLabel('Directory'), 0, 0)
grid.addLayout(saveDirGroup, 0, 1, 1, 4)
grid.addWidget(setEnabled(QLabel(u'S(Q, ω):'), self.binEon), 1, 0)
grid.addWidget(self.chkSofQWNexus, 1, 1)
grid.addWidget(self.chkSofQWAscii, 1, 2)
grid.addItem(QSpacerItem(5, 5, hPolicy=QSizePolicy.Expanding), 1, 4)
grid.addWidget(QLabel(u'S(2θ, ω):'), 2, 0)
grid.addWidget(self.chkSofTWNexus, 2, 1)
grid.addWidget(self.chkSofTWAscii, 2, 2)
grid.addWidget(self.chkSofTWNxspe, 2, 3)
self.gbSave.setLayout(grid)
# handle signals
self.btnDataDir.clicked.connect(self._onDataDir)
self.btnSaveDir.clicked.connect(self._onSaveDir)
self.runDataModel.selectCell.connect(self._onSelectedCell)
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)
class FindOptions(QWidget):
"""Find widget with options"""
find = Signal()
stop = Signal()
def __init__(self, parent, search_text, search_text_regexp, search_path,
include, include_idx, include_regexp,
exclude, exclude_idx, exclude_regexp,
supported_encodings, in_python_path, more_options):
QWidget.__init__(self, parent)
if search_path is None:
search_path = getcwd()
if not isinstance(search_text, (list, tuple)):
search_text = [search_text]
if not isinstance(search_path, (list, tuple)):
search_path = [search_path]
if not isinstance(include, (list, tuple)):
include = [include]
if not isinstance(exclude, (list, tuple)):
exclude = [exclude]
self.supported_encodings = supported_encodings
# Layout 1
hlayout1 = QHBoxLayout()
self.search_text = PatternComboBox(self, search_text,
_("Search pattern"))
self.edit_regexp = create_toolbutton(self,
icon=ima.icon('advanced'),
tip=_('Regular expression'))
self.edit_regexp.setCheckable(True)
self.edit_regexp.setChecked(search_text_regexp)
self.more_widgets = ()
self.more_options = create_toolbutton(self,
toggled=self.toggle_more_options)
self.more_options.setCheckable(True)
self.more_options.setChecked(more_options)
self.ok_button = create_toolbutton(self, text=_("Search"),
icon=ima.icon('DialogApplyButton'),
triggered=lambda: self.find.emit(),
tip=_("Start search"),
text_beside_icon=True)
self.ok_button.clicked.connect(self.update_combos)
self.stop_button = create_toolbutton(self, text=_("Stop"),
icon=ima.icon('stop'),
triggered=lambda: self.stop.emit(),
tip=_("Stop search"),
text_beside_icon=True)
self.stop_button.setEnabled(False)
for widget in [self.search_text, self.edit_regexp,
self.ok_button, self.stop_button, self.more_options]:
hlayout1.addWidget(widget)
# Layout 2
hlayout2 = QHBoxLayout()
self.include_pattern = PatternComboBox(self, include,
_("Included filenames pattern"))
if include_idx is not None and include_idx >= 0 \
and include_idx < self.include_pattern.count():
self.include_pattern.setCurrentIndex(include_idx)
self.include_regexp = create_toolbutton(self,
icon=ima.icon('advanced'),
tip=_('Regular expression'))
self.include_regexp.setCheckable(True)
self.include_regexp.setChecked(include_regexp)
include_label = QLabel(_("Include:"))
include_label.setBuddy(self.include_pattern)
self.exclude_pattern = PatternComboBox(self, exclude,
_("Excluded filenames pattern"))
if exclude_idx is not None and exclude_idx >= 0 \
and exclude_idx < self.exclude_pattern.count():
self.exclude_pattern.setCurrentIndex(exclude_idx)
self.exclude_regexp = create_toolbutton(self,
icon=ima.icon('advanced'),
tip=_('Regular expression'))
self.exclude_regexp.setCheckable(True)
self.exclude_regexp.setChecked(exclude_regexp)
exclude_label = QLabel(_("Exclude:"))
exclude_label.setBuddy(self.exclude_pattern)
for widget in [include_label, self.include_pattern,
self.include_regexp,
exclude_label, self.exclude_pattern,
self.exclude_regexp]:
hlayout2.addWidget(widget)
# Layout 3
hlayout3 = QHBoxLayout()
self.python_path = QRadioButton(_("PYTHONPATH"), self)
self.python_path.setChecked(in_python_path)
self.python_path.setToolTip(_(
"Search in all directories listed in sys.path which"
" are outside the Python installation directory"))
self.hg_manifest = QRadioButton(_("Hg repository"), self)
self.detect_hg_repository()
self.hg_manifest.setToolTip(
_("Search in current directory hg repository"))
self.custom_dir = QRadioButton(_("Here:"), self)
self.custom_dir.setChecked(not in_python_path)
self.dir_combo = PathComboBox(self)
self.dir_combo.addItems(search_path)
self.dir_combo.setToolTip(_("Search recursively in this directory"))
self.dir_combo.open_dir.connect(self.set_directory)
self.python_path.toggled.connect(self.dir_combo.setDisabled)
self.hg_manifest.toggled.connect(self.dir_combo.setDisabled)
browse = create_toolbutton(self, icon=ima.icon('DirOpenIcon'),
tip=_('Browse a search directory'),
triggered=self.select_directory)
for widget in [self.python_path, self.hg_manifest, self.custom_dir,
self.dir_combo, browse]:
hlayout3.addWidget(widget)
self.search_text.valid.connect(lambda valid: self.find.emit())
self.include_pattern.valid.connect(lambda valid: self.find.emit())
self.exclude_pattern.valid.connect(lambda valid: self.find.emit())
self.dir_combo.valid.connect(lambda valid: self.find.emit())
vlayout = QVBoxLayout()
vlayout.setContentsMargins(0, 0, 0, 0)
vlayout.addLayout(hlayout1)
vlayout.addLayout(hlayout2)
vlayout.addLayout(hlayout3)
self.more_widgets = (hlayout2, hlayout3)
self.toggle_more_options(more_options)
self.setLayout(vlayout)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
@Slot(bool)
def toggle_more_options(self, state):
for layout in self.more_widgets:
for index in range(layout.count()):
if state and self.isVisible() or not state:
layout.itemAt(index).widget().setVisible(state)
if state:
icon = ima.icon('options_less')
tip = _('Hide advanced options')
else:
icon = ima.icon('options_more')
tip = _('Show advanced options')
self.more_options.setIcon(icon)
self.more_options.setToolTip(tip)
def update_combos(self):
self.search_text.lineEdit().returnPressed.emit()
self.include_pattern.lineEdit().returnPressed.emit()
self.exclude_pattern.lineEdit().returnPressed.emit()
def detect_hg_repository(self, path=None):
if path is None:
path = getcwd()
hg_repository = is_hg_installed() and get_vcs_root(path) is not None
self.hg_manifest.setEnabled(hg_repository)
if not hg_repository and self.hg_manifest.isChecked():
self.custom_dir.setChecked(True)
def set_search_text(self, text):
if text:
self.search_text.add_text(text)
self.search_text.lineEdit().selectAll()
self.search_text.setFocus()
def get_options(self, all=False):
# Getting options
utext = to_text_string(self.search_text.currentText())
if not utext:
return
try:
texts = [(utext.encode('ascii'), 'ascii')]
except UnicodeEncodeError:
texts = []
for enc in self.supported_encodings:
try:
texts.append((utext.encode(enc), enc))
except UnicodeDecodeError:
pass
text_re = self.edit_regexp.isChecked()
include = to_text_string(self.include_pattern.currentText())
include_re = self.include_regexp.isChecked()
exclude = to_text_string(self.exclude_pattern.currentText())
exclude_re = self.exclude_regexp.isChecked()
python_path = self.python_path.isChecked()
hg_manifest = self.hg_manifest.isChecked()
path = osp.abspath( to_text_string( self.dir_combo.currentText() ) )
# Finding text occurrences
if not include_re:
include = fnmatch.translate(include)
if not exclude_re:
exclude = fnmatch.translate(exclude)
if all:
search_text = [to_text_string(self.search_text.itemText(index)) \
for index in range(self.search_text.count())]
search_path = [to_text_string(self.dir_combo.itemText(index)) \
for index in range(self.dir_combo.count())]
include = [to_text_string(self.include_pattern.itemText(index)) \
for index in range(self.include_pattern.count())]
include_idx = self.include_pattern.currentIndex()
exclude = [to_text_string(self.exclude_pattern.itemText(index)) \
for index in range(self.exclude_pattern.count())]
exclude_idx = self.exclude_pattern.currentIndex()
more_options = self.more_options.isChecked()
return (search_text, text_re, search_path,
include, include_idx, include_re,
exclude, exclude_idx, exclude_re,
python_path, more_options)
else:
return (path, python_path, hg_manifest,
include, exclude, texts, text_re)
@Slot()
def select_directory(self):
"""Select directory"""
self.parent().redirect_stdio.emit(False)
directory = getexistingdirectory(self, _("Select directory"),
self.dir_combo.currentText())
if directory:
self.set_directory(directory)
self.parent().redirect_stdio.emit(True)
def set_directory(self, directory):
path = to_text_string(osp.abspath(to_text_string(directory)))
self.dir_combo.setEditText(path)
self.detect_hg_repository(path)
def keyPressEvent(self, event):
"""Reimplemented to handle key events"""
ctrl = event.modifiers() & Qt.ControlModifier
shift = event.modifiers() & Qt.ShiftModifier
if event.key() in (Qt.Key_Enter, Qt.Key_Return):
self.find.emit()
elif event.key() == Qt.Key_F and ctrl and shift:
# Toggle find widgets
self.parent().toggle_visibility.emit(not self.isVisible())
else:
QWidget.keyPressEvent(self, event)