def _build_view(self, line_list, index, waverange=(None, None)):
if self.wave_range[0] and self.wave_range[1]:
line_list = line_list.extract_range(waverange)
table_model = LineListTableModel(line_list)
if table_model.rowCount() > 0:
# here we add the first pane (the one with the entire
# original line list), to the tabbed pane that contains
# the line sets corresponding to the current line list.
lineset_tabbed_pane = QTabWidget()
lineset_tabbed_pane.setTabsClosable(True)
pane, table_view = _create_line_list_pane(line_list, table_model, self)
lineset_tabbed_pane.addTab(pane, "Original")
pane._set_line_sets_tabbed_pane(lineset_tabbed_pane)
table_view.selectionModel().selectionChanged.connect(pane._handle_button_activation)
# internal signals do not use Hub infrastructure.
table_view.selectionModel().selectionChanged.connect(self._count_selections)
# now we add this "line set tabbed pane" to the main tabbed
# pane, with name taken from the list model.
self.tab_widget.insertTab(index, lineset_tabbed_pane, table_model.get_name())
self.tab_widget.setCurrentIndex(index)
# store for use down stream.
# self.table_views.append(table_view)
# self.set_tabbed_panes.append(set_tabbed_pane)
# self.tab_count.append(0)
# self.panes.append(pane)
return line_list
def display_graph(self):
'''Display the graph tabs and all their contents'''
gp_vlay = QVBoxLayout()
tab = QTabWidget()
tab.setObjectName("LITab")
for graph_name in self.graph_all_data:
tablay = QVBoxLayout()
tab_content = QWidget()
graph_item = self.graph_all_data.get(graph_name)
if len(graph_item.items()) != 2:
tablay.addWidget(self.createGraph(graph_item), 10)
tab_content.setLayout(tablay)
else:
for data in graph_item:
tablay.addWidget(self.createGraph(graph_item.get(data)),
10)
tab_content.setLayout(tablay)
tab.addTab(tab_content, graph_name)
gp_vlay.addWidget(tab)
return gp_vlay
def _build_view(self, line_list, index, waverange=(None,None)):
if waverange[0] and wave_range[1]:
line_list = line_list.extract_range(waverange)
table_model = LineListTableModel(line_list)
if table_model.rowCount() > 0:
# here we add the first pane (the one with the entire
# original line list), to the tabbed pane that contains
# the line sets corresponding to the current line list.
lineset_tabbed_pane = QTabWidget()
lineset_tabbed_pane.setTabsClosable(True)
pane, table_view = _createLineListPane(line_list, table_model, self)
lineset_tabbed_pane.addTab(pane, "Original")
pane.setLineSetsTabbedPane(lineset_tabbed_pane)
# connect signals
table_view.selectionModel().selectionChanged.connect(self._countSelections)
table_view.selectionModel().selectionChanged.connect(pane.handle_button_activation)
# now we add this "line set tabbed pane" to the main tabbed
# pane, with name taken from the list model.
self.tabWidget.insertTab(index, lineset_tabbed_pane, table_model.getName())
self.tabWidget.setCurrentIndex(index)
# store for use down stream.
# self.table_views.append(table_view)
# self.set_tabbed_panes.append(set_tabbed_pane)
# self.tab_count.append(0)
# self.panes.append(pane)
return line_list
class CanvasDisplayTabWidget(CanvasDisplayWidget):
"""Canvas display widget that displays canvases in tabs."""
def __init__(self, parent=None):
super(CanvasDisplayTabWidget, self).__init__(parent)
self._tabWidget = QTabWidget()
self._tabWidget.setParent(self)
self.setLayout(QVBoxLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self.layout().addWidget(self._tabWidget)
# Set attrs for when the buttons are created
self.icon = QIcon(path('icons/tabs.png'))
# TODO: right now, we are not attaching help text directly to this widget
# (it can be confusing when trying to hover over the StackedCanvasView,
# the StackedCanvasView's help text is hard to display)
self.tool_tip = "Tab View"
self.whats_this = "Reorganizes displayed data into separate tabs."
def getView(self):
return self._tabWidget.currentWidget()
def clear_canvases(self):
self._tabWidget.clear()
def show_canvases(self, canvases):
self._tabWidget.clear()
for canvas in canvases:
if canvas is not None:
self._tabWidget.addTab(canvas, canvas.canvas_name)
def _setupUi(self):
self.tune_settings = QWidget(self)
self.tune_settings.setLayout(self._setupTuneSettings())
self.le_tuneconfig.setText(self.tuneconfig_currname)
self.chrom_settings = QWidget(self)
self.chrom_settings.setLayout(self._setupChromSettings())
self.le_chromconfig.setText(self.chromconfig_currname)
self.bt_apply = QPushButton('Apply Settings', self)
self.bt_apply.setStyleSheet("""min-width:8em; max-width:8em;""")
self.bt_apply.clicked.connect(self._emitSettings)
self.bt_apply.setAutoDefault(False)
self.bt_apply.setDefault(False)
hlay_apply = QHBoxLayout()
hlay_apply.addItem(
QSpacerItem(20, 60, QSzPlcy.Expanding, QSzPlcy.Ignored))
hlay_apply.addWidget(self.bt_apply)
tabs = QTabWidget(self)
tabs.addTab(self.tune_settings, 'Tune')
tabs.addTab(self.chrom_settings, 'Chromaticity')
lay = QVBoxLayout()
lay.addWidget(tabs)
lay.addLayout(hlay_apply)
self.setLayout(lay)
class LoadTest(QMainWindow):
def __init__(self, nplots=150, ncols=6, nrows=5):
super().__init__()
win32_fix_title_bar_background(self)
self.tabw = QTabWidget()
self.setCentralWidget(self.tabw)
irow, icol, itab = 0, 0, 0
add_tab_at_next_step = True
for iplt in range(nplots):
if add_tab_at_next_step:
plottab = self.add_tab(itab)
add_tab_at_next_step = False
plottab.add_plot(iplt, irow, icol)
icol += 1
if icol == ncols:
icol = 0
irow += 1
if irow == nrows:
irow = 0
itab += 1
add_tab_at_next_step = True
self.refresh()
def add_tab(self, itab):
plottab = PlotTab()
self.tabw.addTab(plottab, "Tab #%d" % (itab + 1))
return plottab
def refresh(self):
"""Force window to show up and refresh (for test purpose only)"""
self.show()
QApplication.processEvents()
class Collections(QWidget):
"""Just a widget contains a sub tab widget."""
def __init__(self, parent: MainWindowBase):
"""Create two widget page and using main window to make their parent."""
super(Collections, self).__init__(parent)
layout = QVBoxLayout(self)
self.tab_widget = QTabWidget(self)
layout.addWidget(self.tab_widget)
self.setWindowIcon(QIcon(QPixmap(":/icons/collections.png")))
self.structure_widget = StructureWidget(parent)
self.configure_widget = ConfigureWidget(
self.structure_widget.add_collection, parent)
self.tab_widget.addTab(self.structure_widget,
self.structure_widget.windowIcon(),
"Structures")
self.tab_widget.addTab(self.configure_widget,
self.configure_widget.windowIcon(),
"Configuration")
self.structure_widget.configure_button.clicked.connect(
lambda: self.tab_widget.setCurrentIndex(1))
self.structure_widget.layout_sender.connect(
self.configure_widget.set_graph)
def clear(self) -> None:
"""Clear the sub-widgets."""
self.structure_widget.clear()
self.configure_widget.clear()
def collect_data(self) -> List[Sequence[Tuple[int, int]]]:
"""Return collections to database."""
return [tuple(G.edges) for G in self.structure_widget.collections]
def config_data(self) -> Dict[str, Dict[str, Any]]:
"""Return profiles to database."""
return self.configure_widget.collections
def displayTabs(self):
''' Display all the tabs '''
tab = QTabWidget()
tab.setObjectName("LITab")
tab.addTab(self.displayControlMPS(0), "MPS Controls")
tab.addTab(self.displayControlMPS(1), "Temperature")
tab.currentChanged.connect(self.adjustSize)
return tab
def setup_page(self):
# Variables
newcb = self.create_checkbox
# Widgets
general_widget = QWidget()
check_show_all = newcb(_("Show all files"), 'show_all')
check_show_hidden_files = newcb(_("Show hidden files"), 'show_hidden')
check_single_click = newcb(_("Single click to open files"),
'single_click_to_open')
edit_filename_filters = self.create_textedit(
_("Show files with these extensions:"),
'name_filters',
tip=("Enter values separated by commas"),
content_type=list,
)
edit_filename_filters.setEnabled(not check_show_all.isChecked())
associations_widget = QWidget()
self.edit_file_associations = self.create_textedit(
'',
'file_associations',
content_type=dict,
)
file_associations = FileAssociationsWidget()
# Widget setup
file_associations.load_values(self.get_option('file_associations'))
# The actual config data is stored on this text edit set to invisible
self.edit_file_associations.setVisible(False)
# Layout
layout = QVBoxLayout()
layout.addWidget(check_show_all)
layout.addWidget(check_show_hidden_files)
layout.addWidget(check_single_click)
layout.addWidget(edit_filename_filters)
general_widget.setLayout(layout)
layout_file = QVBoxLayout()
layout_file.addWidget(file_associations)
layout_file.addWidget(self.edit_file_associations)
associations_widget.setLayout(layout_file)
tabs = QTabWidget()
tabs.addTab(self.create_tab(general_widget), _("General"))
tabs.addTab(self.create_tab(associations_widget),
_("File associations"))
tab_layout = QVBoxLayout()
tab_layout.addWidget(tabs)
self.setLayout(tab_layout)
# Signals
file_associations.sig_data_changed.connect(self.update_associations)
check_show_all.toggled.connect(
lambda show_all: edit_filename_filters.setEnabled(not show_all))
def _setup_ui(self):
cwid = QTabWidget()
for section in ('tb', 'bo', 'ts', 'si'):
widget = EnergyButton(section, parent=cwid)
cwid.addTab(widget, section.upper())
self.setCentralWidget(cwid)
cwid.setObjectName('cwid')
cwid.setStyleSheet('#cwid{width: 20em; height: 25em;}')
class ReportsWidget(QWidget):
"""Reports widget."""
def __init__(self, parent):
"""Initialiaze ReportsWidget."""
QWidget.__init__(self, parent)
self.setWindowTitle("Reports")
self.tabs = QTabWidget()
self.tabs.setMovable(True)
self.tabs.setTabsClosable(True)
self.tabs.tabCloseRequested.connect(self.close_tab)
self.renderviews = {}
layout = QVBoxLayout()
layout.addWidget(self.tabs)
self.setLayout(layout)
self.set_html('', 'Welcome')
def set_html(self, html_text, name, base_url=None):
"""Set html text."""
renderview = self.renderviews.get(name)
if 'Welcome' in self.renderviews:
# Overwrite the welcome tab
renderview =self.renderviews.pop('Welcome')
self.renderviews[name] = renderview
self.tabs.setTabText(0, name)
if renderview is None:
# create a new renderview
renderview = RenderView(self)
self.renderviews[name] = renderview
self.tabs.addTab(renderview, name)
if base_url is not None:
renderview.setHtml(html_text, base_url)
else:
renderview.setHtml(html_text)
self.tabs.setCurrentWidget(renderview)
def close_tab(self, index):
"Close tab, and remove its widget form renderviews."
self.renderviews.pop(self.tabs.tabText(index))
self.tabs.removeTab(index)
def clear_all(self):
"""Clear widget web view content."""
for name in self.renderviews:
self.set_html('', name)
class DeviceWindow(FramelessWindow):
stop_task = Signal(Bot, Task)
force_start_task = Signal(Bot, Task)
run_shell = Signal(Bot, str)
def __init__(self, bot, parent):
super(DeviceWindow, self).__init__(parent)
self.setContentsMargins(11, 11, 11, 11)
self.tab_widget = QTabWidget(self)
self.addContentWidget(self.tab_widget)
self.tasks_tab = TasksWidget(bot, self)
self.tasks_tab.stop_task.connect(self.stop_task.emit)
self.tasks_tab.force_start_task.connect(self.force_start_task.emit)
self.shell_tab = ShellWidget(bot, self)
self.shell_tab.run_shell.connect(self.run_shell.emit)
self.modules_tab = ModulesWidget(bot, self)
self.relay_tab = RelayWidget(bot, self)
self.logs_tab = LogsWidget(bot, self)
self.attributes_tab = AttributesWidget(bot, self)
self.attributes_tab.update_attributes(bot)
self.tab_widget.addTab(self.tasks_tab, "Tasks")
self.tab_widget.addTab(self.modules_tab, "Modules")
self.tab_widget.addTab(self.shell_tab, "Shell")
self.tab_widget.addTab(self.relay_tab, "Relay")
self.tab_widget.addTab(self.logs_tab, "Log")
self.tab_widget.addTab(self.attributes_tab, "Information")
@Slot(list)
def update_attributes(self, info):
if self.isVisible():
self.attributes_tab.update_attributes(info)
@Slot(list)
def update_tasks(self, tasks):
if self.isVisible():
self.tasks_tab.update_tasks(tasks)
@Slot(Bot, str)
def append_shell(self, device, output):
if self.isVisible():
self.shell_tab.append_shell(device, output)
@Slot()
def close(self):
super().close()
self.deleteLater()
class TabGroupWidget(AbstractDataSetWidget):
def __init__(self, item, parent_layout):
super(TabGroupWidget, self).__init__(item, parent_layout)
self.tabs = QTabWidget()
items = item.item.group
self.widgets = []
for item in items:
if item.get_prop_value("display", parent_layout.instance, "hide",
False):
continue
item.set_prop("display", embedded=True)
widget = parent_layout.build_widget(item)
frame = QFrame()
label = widget.item.get_prop_value("display", "label")
icon = widget.item.get_prop_value("display", "icon", None)
if icon is not None:
self.tabs.addTab(frame, get_icon(icon), label)
else:
self.tabs.addTab(frame, label)
layout = QGridLayout()
layout.setAlignment(Qt.AlignTop)
frame.setLayout(layout)
widget.place_on_grid(layout, 0, 0, 1)
try:
widget.get()
except Exception:
print("Error building item :", item.item._name)
raise
self.widgets.append(widget)
def get(self):
"""Override AbstractDataSetWidget method"""
for widget in self.widgets:
widget.get()
def set(self):
"""Override AbstractDataSetWidget method"""
for widget in self.widgets:
widget.set()
def check(self):
"""Override AbstractDataSetWidget method"""
return True
def place_on_grid(self,
layout,
row,
label_column,
widget_column,
row_span=1,
column_span=1):
"""Override AbstractDataSetWidget method"""
layout.addWidget(self.tabs, row, label_column, row_span,
column_span + 1)
class ChartDialog(QDialog):
"""There are three charts are in the dialog.
+ Fitness / Generation Chart.
+ Generation / Time Chart.
+ Fitness / Time Chart.
"""
def __init__(
self,
title: str,
algorithm_data: Sequence[Mapping[str, Any]],
parent: QWidget
):
"""Add three tabs of chart."""
super(ChartDialog, self).__init__(parent)
self.setWindowTitle("Chart")
self.setWindowFlags(self.windowFlags() | Qt.WindowMaximizeButtonHint)
self.setSizeGripEnabled(True)
self.setModal(True)
self.setMinimumSize(QSize(800, 600))
self.title = title
self.algorithm_data = algorithm_data
# Widgets
main_layout = QVBoxLayout(self)
main_layout.setContentsMargins(6, 6, 6, 6)
self.tab_widget = QTabWidget(self)
self.__set_chart("F-G Plot", 0, 1, 'Generation', 'Fitness')
self.__set_chart("G-T Plot", 2, 0, 'Time', 'Generation')
self.__set_chart("F-T Plot", 2, 1, 'Time', 'Fitness')
main_layout.addWidget(self.tab_widget)
def __set_chart(
self,
name: str,
pos_x: int,
pos_y: int,
label_x: str,
label_y: str
) -> None:
"""Setting charts by data index.
pos_x / pos_y: [0], [1], [2]
time_fitness: List[List[Tuple[gen, fitness, time]]]
"""
chart = DataChart(self)
ax = chart.ax()
for i, data in enumerate(self.algorithm_data):
a = array(data['time_fitness'], dtype=float)
ax[0].plot(a[:, pos_x], a[:, pos_y], label=f"Task {i + 1}")
ax[0].set_xlabel(label_x)
ax[0].set_ylabel(label_y)
ax[0].legend()
self.tab_widget.addTab(chart, name)
class CurveBenchmark1(QMainWindow):
TITLE = "Curve benchmark"
SIZE = (1000, 500)
def __init__(self, max_n=1000000, parent=None, **kwargs):
super(CurveBenchmark1, self).__init__(parent=parent)
title = self.TITLE
if kwargs.get("only_lines", False):
title = "%s (%s)" % (title, "only lines")
self.setWindowTitle(title)
self.tabs = QTabWidget()
self.setCentralWidget(self.tabs)
self.text = BMText(self)
self.tabs.addTab(self.text, "Contents")
self.resize(*self.SIZE)
# Force window to show up and refresh (for test purpose only)
self.show()
QApplication.processEvents()
t0g = time.time()
self.run_benchmark(max_n, **kwargs)
dt = time.time() - t0g
self.text.append("<br><br><u>Total elapsed time</u>: %d ms" %
(dt * 1e3))
if os.environ.get("TEST_UNATTENDED") is None:
self.tabs.setCurrentIndex(0)
else:
self.tabs.setCurrentIndex(1)
def process_iteration(self, title, description, widget, t0):
self.tabs.addTab(widget, title)
self.tabs.setCurrentWidget(widget)
# Force widget to refresh (for test purpose only)
QApplication.processEvents()
time_str = "Elapsed time: %d ms" % ((time.time() - t0) * 1000)
widget.text.setText(time_str)
self.text.append("<br><i>%s:</i><br>%s" % (description, time_str))
def run_benchmark(self, max_n, **kwargs):
for idx in range(4, -1, -1):
points = int(max_n / 10**idx)
t0 = time.time()
widget = BMWidget(points, **kwargs)
title = "%d points" % points
description = "%d plots with %d curves of %d points" % (
widget.plot_nb,
widget.curve_nb,
points,
)
self.process_iteration(title, description, widget, t0)
class Env(QWidget):
makePlot = Signal(int, object, object, name='makePlot')
def __init__(self, comm, plot_spawner, parent=None):
super(__class__, self).__init__(parent)
self.setWindowTitle("Env")
self.comm = comm
self.srcBox = QLineEdit(self)
self.srcSelect = QPushButton('Select', self)
self.srcFilter = QPushButton('Filter', self)
self.postName = QLabel('Entry name', self)
self.postBox = QLineEdit(self)
self.tabs = QTabWidget(self)
self.tabs.addTab(TimePlot(0, self.comm, plot_spawner, self.tabs),
"Mean v Time")
self.tabs.addTab(ScanPlot(1, self.comm, plot_spawner, self.tabs),
"Mean v Scan")
self.button = QPushButton('Plot', self)
self.button.clicked.connect(self.on_click)
self.src = QGroupBox("Source Channel")
self.src_layout = QHBoxLayout(self.src)
self.src_layout.addWidget(self.srcBox)
self.src_layout.addWidget(self.srcSelect)
self.src_layout.addWidget(self.srcFilter)
self.post = QHBoxLayout()
self.post.addWidget(self.postName)
self.post.addWidget(self.postBox)
self.plot = QGroupBox("Plot Type")
self.plot_layout = QVBoxLayout(self.plot)
self.plot_layout.addWidget(self.tabs)
self.env_layout = QVBoxLayout(self)
self.env_layout.addWidget(self.src)
self.env_layout.addLayout(self.post)
self.env_layout.addWidget(self.plot)
self.env_layout.addWidget(self.button)
for i in range(self.tabs.count()):
self.makePlot.connect(self.tabs.widget(i).request_plot)
@Slot()
def on_click(self):
src = self.srcBox.text()
post = self.postBox.text()
if src:
self.makePlot.emit(self.tabs.currentIndex(), src, post)
def setupui(self):
"""."""
vbl = QVBoxLayout(self)
vbl.setContentsMargins(0, 0, 0, 0)
tabw = QTabWidget(self)
vbl.addWidget(tabw)
main_wid = self.get_main_widget(tabw)
tabw.addTab(main_wid, 'Main')
wid = AcqControlWidget(
tabw, self.device, prefix=self.prefix, acc=self.acc)
tabw.addTab(wid, 'Trig. Acq. Control')
def __init__(self, parent, device, prefix='', acc='SI'):
super().__init__(parent, device, prefix=prefix, acc=acc)
tab = QTabWidget(self)
hbl = QHBoxLayout(self)
hbl.addWidget(tab)
hbl.setContentsMargins(0, 0, 0, 0)
for dev in ('BPMX', 'BPMY', 'CH', 'CV'):
wid = SingleSelMatrix(tab,
dev,
self.device,
prefix=self.prefix,
acc=self.acc)
tab.addTab(wid, dev)
def setupui(self):
vbl = QVBoxLayout(self)
self.details = QCheckBox('Details', self)
vbl.addWidget(self.details, alignment=Qt.AlignRight)
grp_bx = self._get_acq_commom_params_grpbx()
vbl.addWidget(grp_bx)
vbl.addStretch()
tabw = QTabWidget(self)
grp_bx = self._get_single_pass_acq_grpbx()
tabw.addTab(grp_bx, 'SinglePass')
if self.isring:
grp_bx = self._get_multturn_acq_grpbx()
tabw.addTab(grp_bx, 'MultiTurn')
tabw.setCurrentIndex(1)
vbl.addWidget(tabw)
vbl.addStretch()
tabw = QTabWidget(self)
self._set_detailed(tabw)
grp_bx = _HLTriggerSimple(parent=tabw,
device=self._csorb.trigger_acq_name,
prefix=self.prefix,
src=True)
tabw.addTab(grp_bx, 'External Trigger')
grp_bx = self._get_trigdata_params_grpbx()
tabw.addTab(grp_bx, 'Data-Driven Trigger')
vbl.addWidget(tabw)
class AdjustImageDialog(QDialog):
def __init__(self, apply_adjust, parent=None):
super(AdjustImageDialog, self).__init__(parent)
self.setModal(True)
self.setWindowTitle("Image Adjust")
self.resize(800, 400)
self.layout = QVBoxLayout(self)
self.tabs = QTabWidget()
wwwc_tab, name = create_wwwc_tab(apply_adjust)
self.tabs.addTab(wwwc_tab, name)
self.tabs.addTab(QWidget(), "Brightness/Contrast")
self.layout.addWidget(self.tabs)
self.setLayout(self.layout)
class FormTabWidget(QWidget):
update_buttons = Signal()
def __init__(self, datalist, comment="", parent=None):
QWidget.__init__(self, parent)
layout = QVBoxLayout()
self.tabwidget = QTabWidget()
layout.addWidget(self.tabwidget)
self.setLayout(layout)
self.widgetlist = []
for data, title, comment in datalist:
if len(data[0])==3:
widget = FormComboWidget(data, comment=comment, parent=self)
else:
widget = FormWidget(data, comment=comment, parent=self)
index = self.tabwidget.addTab(widget, title)
self.tabwidget.setTabToolTip(index, comment)
self.widgetlist.append(widget)
def setup(self):
for widget in self.widgetlist:
widget.setup()
def get(self):
return [ widget.get() for widget in self.widgetlist]
class FormTabWidget(QWidget):
update_buttons = Signal()
def __init__(self, datalist, comment="", parent=None):
QWidget.__init__(self, parent)
layout = QVBoxLayout()
self.tabwidget = QTabWidget()
layout.addWidget(self.tabwidget)
self.setLayout(layout)
self.widgetlist = []
for data, title, comment in datalist:
if len(data[0]) == 3:
widget = FormComboWidget(data, comment=comment, parent=self)
else:
widget = FormWidget(data, comment=comment, parent=self)
index = self.tabwidget.addTab(widget, title)
self.tabwidget.setTabToolTip(index, comment)
self.widgetlist.append(widget)
def setup(self):
for widget in self.widgetlist:
widget.setup()
def get(self):
return [widget.get() for widget in self.widgetlist]
class DefaultTop(Display):
def __init__(self, parent=None, args=[], macros=None):
super(DefaultTop, self).__init__(parent=parent, args=args, macros=None)
self.setStyleSheet("*[dirty='true']\
{background-color: orange;}")
self.sizeX = None
self.sizeY = None
self.title = None
for a in args:
if 'sizeX=' in a:
self.sizeX = int(a.split('=')[1])
if 'sizeY=' in a:
self.sizeY = int(a.split('=')[1])
if 'title=' in a:
self.title = a.split('=')[1]
if self.title is None:
self.title = "Rogue Server: {}".format(os.getenv('ROGUE_SERVERS'))
if self.sizeX is None:
self.sizeX = 800
if self.sizeY is None:
self.sizeY = 1000
self.setWindowTitle(self.title)
vb = QVBoxLayout()
self.setLayout(vb)
self.tab = QTabWidget()
vb.addWidget(self.tab)
sys = SystemWindow(parent=None, init_channel=Channel)
self.tab.addTab(sys,'System')
var = DebugTree(parent=None, init_channel=Channel)
self.tab.addTab(var,'Debug Tree')
self.resize(self.sizeX, self.sizeY)
def ui_filepath(self):
# No UI file is being used
return None
class AnswerWindow:
def __init__(self, parent=None, numTab=5):
self.w = QDialog()
self.parent = parent
self.tables = []
self.numTab = numTab
self.initUI()
def closeWindow(self):
self.w.close()
def show(self):
self.setData()
self.w.exec_()
def setData(self, data=None):
horHeaders = [u'条件', u'値']
condNames = [
u'線材種', u'回転方向', u'回転速度', u'送り速度', u'切り込み量', u'突き出し量', u'乗せ率',
u'パス回数', u'摩耗量'
]
for i in range(self.numTab):
table = self.tables[i]
table.setHorizontalHeaderLabels(horHeaders)
for m in condNames:
item = QTableWidgetItem(m)
table.setItem(condNames.index(m), 0, item)
def initUI(self):
self.w.setWindowTitle(u'回答結果')
vbox = QVBoxLayout()
ansBtn = QPushButton(u"閉じる")
ansBtn.clicked.connect(self.closeWindow)
self.tabs = QTabWidget()
for i in range(self.numTab):
tab = QTableWidget()
tab.setRowCount(9) # あとで9のところは変更してください。
tab.setColumnCount(2)
self.tabs.addTab(tab, "第" + str(i + 1) + "候補")
self.tables.append(tab)
vbox.addWidget(self.tabs)
vbox.addWidget(ansBtn)
self.w.setLayout(vbox)
def _build_tab_widget(self):
"""The tab widget should allow:
- one tab per scenario to render (good idea)
- adding tabs
- other scenarios
- removing tabs (closing)
"""
widget_tabs = QTabWidget(self)
self._widgets['tabs'] = widget_tabs
# NOTE: the following is just for illustration purposes
# The actual fonctionality should dynamically create those components
# depending on the selection on the tree-widget
# Data is a set of plots of the toutput data
widget_dataviz = DataViz(widget_tabs)
widget_tabs.addTab(widget_dataviz, 'Dataviz')
self._widgets['dataviz'] = widget_dataviz
def __init__(self):
super().__init__()
self.setWindowTitle("First Python App!")
self.setWindowIcon(QIcon("./myicon.png"))
tabwidgt = QTabWidget()
self.firstTab = FirstTab()
tabwidgt.addTab(self.firstTab,"Information")
buttonbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
buttonbox.accepted.connect(self.firstTab.save)
buttonbox.rejected.connect(self.reject)
vbox = QVBoxLayout()
vbox.addWidget(tabwidgt)
vbox.addWidget(buttonbox)
self.setLayout(vbox)
def create_layout(self):
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)
#---------------------
version_tab = _version_tab(ok_cancel_box)
package_tab = _package_tab()
# --------------------
tab_widget = QTabWidget()
tab_widget.addTab(version_tab, 'Version')
tab_widget.addTab(package_tab, 'Packages')
#---------------------
vbox_outer = QVBoxLayout()
vbox_outer.addWidget(tab_widget)
#---------------------
self.setLayout(vbox_outer)
def setup_page(self):
text = _("Working directory")
default = os.getcwd()
self.setdir = self.create_browsedir(text, default=default)
gpPath = QGroupBox(_("Path"))
pathLayout = QVBoxLayout()
pathLayout.addWidget(self.setdir)
gpPath.setLayout(pathLayout)
gpGeneral = QGroupBox(_("TODO"))
gpStatus = QGroupBox(_("TODO"))
tabs = QTabWidget()
tabs.addTab(self.create_tab(gpPath), _("Basic"))
tabs.addTab(self.create_tab(gpGeneral, gpStatus),
_("Advanced Settings"))
self.layout.addWidget(tabs)
action = self.create_action()
self.layout.addWidget(action)
def updateEditors(self, *, payloadsView: QWidget, blocksView: QWidget,
panelsView: QWidget, imagesView: QWidget) -> None:
descriptionTextEdit = QPlainTextEdit()
self.descriptionTextEdit = descriptionTextEdit
descriptionLayout = QVBoxLayout()
descriptionLayout.addWidget(descriptionTextEdit)
descriptionBox = QGroupBox()
descriptionBox.setTitle("Description")
descriptionBox.setLayout(descriptionLayout)
descriptionBox.setMaximumHeight(130)
tabWidget = QTabWidget()
tabWidget.setObjectName("settingsWidget")
tabWidget.setTabPosition(QTabWidget.North)
tabWidget.addTab(payloadsView, "Payloads")
tabWidget.addTab(blocksView, "Blocks")
tabWidget.addTab(panelsView, "Panels")
tabWidget.addTab(imagesView, "Images")
self.tabWidget = tabWidget
layout = QVBoxLayout()
layout.addWidget(descriptionBox, stretch=0)
layout.addWidget(tabWidget, stretch=1)
# replace no_project_selected_label with the settings layout
parentLayout: QHBoxLayout = self.layout()
item: QLayoutItem = parentLayout.takeAt(
2) # after statusWidget and spacer
if item.widget() is not None:
item.widget().deleteLater()
parentLayout.addLayout(layout, stretch=1)
def get_correction_widget(self, parent):
"""."""
corr_wid = QGroupBox('Correction', parent)
corr_wid.setLayout(QVBoxLayout())
if self.acc != 'BO':
lbl = QLabel('Auto Correction State:', corr_wid)
wid = self.create_pair_butled(corr_wid, 'LoopState')
hbl = QHBoxLayout()
hbl.addWidget(lbl)
hbl.addWidget(wid)
corr_wid.layout().addLayout(hbl)
corr_tab = QTabWidget(corr_wid)
corr_wid.layout().addWidget(corr_tab)
if self.acc != 'BO':
auto_wid = self.get_auto_correction_widget(corr_tab)
corr_tab.addTab(auto_wid, 'Automatic')
man_wid = self.get_manual_correction_widget(corr_tab)
corr_tab.addTab(man_wid, 'Manual')
kicks_wid = KicksConfigWidget(
parent, self.device, prefix=self.prefix, acc=self.acc)
corr_tab.addTab(kicks_wid, 'Kicks Config')
if self.acc != 'BO':
hbl = kicks_wid.get_status_widget(corr_wid)
corr_wid.layout().addLayout(hbl)
return corr_wid
class MxAnalyzerWidget(MxToolBarMixin, QWidget):
def __init__(self, parent, **kwargs):
QWidget.__init__(self, parent)
self.plugin = parent
# Create tool bar
if "options_button" in kwargs:
self.options_button = kwargs["options_button"]
else:
self.options_button = None
self.plugin_actions = []
MxToolBarMixin.__init__(self,
options_button=self.options_button,
plugin_actions=self.plugin_actions)
# Create main widget
self.tabwidget = QTabWidget(parent=parent)
self.preds = MxAnalyzerTab(parent=self, adjacency='preds')
self.succs = MxAnalyzerTab(parent=self, adjacency='succs')
self.tabs = {'preds': self.preds, 'succs': self.succs}
self.tabwidget.addTab(self.preds, 'Precedents')
self.tabwidget.addTab(self.succs, 'Dependents')
layout = create_plugin_layout(self.tools_layout, self.tabwidget)
self.setFocusPolicy(Qt.ClickFocus)
self.setLayout(layout)
def set_shellwidget(self, shellwidget):
"""Bind shellwidget instance to namespace browser"""
self.shellwidget = shellwidget
for tab in self.tabs.values():
tab.shellwidget = shellwidget
shellwidget.set_mxanalyzer(self)
# Slot
def update_node(self, adjacency, data):
tab = self.tabs[adjacency]
tab.tree.process_remote_view(data)
def get_main_widget(self, parent):
"""."""
main_wid = QWidget(parent)
vbl = QVBoxLayout()
main_wid.setLayout(vbl)
tabw = QTabWidget(main_wid)
orb_wid = self.get_orbit_widget(tabw)
acqrt_wid = self.get_orbitdetails_widget(tabw)
tabw.addTab(orb_wid, 'Orbit')
tabw.addTab(acqrt_wid, 'Details')
corr_wid = self.get_correction_widget(main_wid)
mat_wid = RespMatWidget(main_wid, self.device, self.prefix, self.acc)
vbl.setContentsMargins(0, 0, 0, 0)
vbl.addWidget(tabw)
vbl.addStretch()
vbl.addWidget(corr_wid)
vbl.addStretch()
vbl.addWidget(mat_wid)
return main_wid
class MainWindow(QMainWindow):
"""OpenBurn's main window"""
title = "OpenBurn"
def __init__(self):
super(MainWindow, self).__init__()
self.setWindowTitle(self.title)
self.setGeometry(100, 100, 800, 600)
self.setWindowIcon(QIcon(RESOURCE_PATH + "icons/nakka-finocyl.gif"))
self.create_default_widgets()
self.setup_ui()
def create_default_widgets(self):
"""Creates static widgets such as menubar and statusbar"""
def create_menubar():
"""Create menu bar and populate it with sub menu actions"""
def file_menu():
"""Create a file submenu"""
self.file_sub_menu = self.menubar.addMenu('File')
self.open_action = QAction('Open File', self)
self.open_action.setStatusTip('Open a new design')
self.open_action.setShortcut('CTRL+O')
# self.open_action.triggered.connect(self.open_file)
self.exit_action = QAction('Exit', self)
self.exit_action.setStatusTip('Exit the application.')
self.exit_action.setShortcut('CTRL+Q')
self.exit_action.triggered.connect(QApplication.quit)
self.file_sub_menu.addAction(self.open_action)
self.file_sub_menu.addAction(self.exit_action)
def edit_menu():
self.edit_dub_menu = self.menubar.addMenu('Edit')
def tools_menu():
self.edit_dub_menu = self.menubar.addMenu('Tools')
def help_menu():
"""Create help submenu"""
self.help_sub_menu = self.menubar.addMenu('Help')
self.about_action = QAction('About', self)
self.about_action.setStatusTip('About the application.')
self.about_action.setShortcut('CTRL+H')
self.about_action.triggered.connect(self.about_dialog.exec_)
self.help_sub_menu.addAction(self.about_action)
self.menubar = QMenuBar(self)
file_menu()
edit_menu()
tools_menu()
help_menu()
def create_statusbar():
self.statusbar = QStatusBar(self)
self.statusbar.showMessage("Ready", 0)
self.about_dialog = AboutDialog(self)
create_menubar()
self.setMenuBar(self.menubar)
create_statusbar()
self.setStatusBar(self.statusbar)
def setup_ui(self):
"""setup the tab widget UI"""
self.tab_widget = QTabWidget()
self.tab_widget.addTab(DesignTab(), "Design")
self.tab_widget.addTab(QWidget(), "Simulation")
self.tab_widget.addTab(QWidget(), "Propellants")
self.layout = QVBoxLayout()
self.layout.addWidget(self.tab_widget)
self.frame = QFrame()
self.frame.setLayout(self.layout)
self.setCentralWidget(self.frame)
class DlgGitHubLogin(QDialog):
"""Dialog to submit error reports to Github."""
def __init__(self, parent, username, password, token, remember=False,
remember_token=False):
QDialog.__init__(self, parent)
title = _("Sign in to Github")
self.resize(415, 375)
self.setWindowTitle(title)
self.setWindowFlags(
self.windowFlags() & ~Qt.WindowContextHelpButtonHint)
# Header
html = ('<html><head/><body><p align="center">'
'{title}</p></body></html>')
lbl_html = QLabel(html.format(title=title))
lbl_html.setStyleSheet('font-size: 16px;')
# Tabs
self.tabs = QTabWidget()
# Basic form layout
basic_form_layout = QFormLayout()
basic_form_layout.setContentsMargins(-1, 0, -1, -1)
basic_lbl_msg = QLabel(_("For regular users, i.e. users <b>without</b>"
" two-factor authentication enabled"))
basic_lbl_msg.setWordWrap(True)
basic_lbl_msg.setAlignment(Qt.AlignJustify)
lbl_user = QLabel(_("Username:"******"", QWidget())
lbl_password = QLabel(_("Password: "******"Remember me"))
self.cb_remember.setToolTip(_("Spyder will save your credentials "
"safely"))
self.cb_remember.setChecked(remember)
basic_form_layout.setWidget(4, QFormLayout.FieldRole,
self.cb_remember)
# Basic auth tab
basic_auth = QWidget()
basic_layout = QVBoxLayout()
basic_layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 8)))
basic_layout.addWidget(basic_lbl_msg)
basic_layout.addSpacerItem(
QSpacerItem(QSpacerItem(0, 50, vPolicy=QSizePolicy.Expanding)))
basic_layout.addLayout(basic_form_layout)
basic_layout.addSpacerItem(
QSpacerItem(QSpacerItem(0, 50, vPolicy=QSizePolicy.Expanding)))
basic_auth.setLayout(basic_layout)
self.tabs.addTab(basic_auth, _("Password Only"))
# Token form layout
token_form_layout = QFormLayout()
token_form_layout.setContentsMargins(-1, 0, -1, -1)
token_lbl_msg = QLabel(_("For users <b>with</b> two-factor "
"authentication enabled, or who prefer a "
"per-app token authentication.<br><br>"
"You can go <b><a href=\"{}\">here</a></b> "
"and click \"Generate token\" at the bottom "
"to create a new token to use for this, with "
"the appropriate permissions.").format(
TOKEN_URL))
token_lbl_msg.setOpenExternalLinks(True)
token_lbl_msg.setWordWrap(True)
token_lbl_msg.setAlignment(Qt.AlignJustify)
lbl_token = QLabel("Token: ")
token_form_layout.setWidget(1, QFormLayout.LabelRole, lbl_token)
self.le_token = QLineEdit()
self.le_token.setEchoMode(QLineEdit.Password)
self.le_token.textChanged.connect(self.update_btn_state)
token_form_layout.setWidget(1, QFormLayout.FieldRole, self.le_token)
self.cb_remember_token = None
# Same validation as with cb_remember
if self.is_keyring_available() and valid_py_os:
self.cb_remember_token = QCheckBox(_("Remember token"))
self.cb_remember_token.setToolTip(_("Spyder will save your "
"token safely"))
self.cb_remember_token.setChecked(remember_token)
token_form_layout.setWidget(3, QFormLayout.FieldRole,
self.cb_remember_token)
# Token auth tab
token_auth = QWidget()
token_layout = QVBoxLayout()
token_layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 8)))
token_layout.addWidget(token_lbl_msg)
token_layout.addSpacerItem(
QSpacerItem(QSpacerItem(0, 50, vPolicy=QSizePolicy.Expanding)))
token_layout.addLayout(token_form_layout)
token_layout.addSpacerItem(
QSpacerItem(QSpacerItem(0, 50, vPolicy=QSizePolicy.Expanding)))
token_auth.setLayout(token_layout)
self.tabs.addTab(token_auth, _("Access Token"))
# Sign in button
self.bt_sign_in = QPushButton(_("Sign in"))
self.bt_sign_in.clicked.connect(self.accept)
self.bt_sign_in.setDisabled(True)
# Main layout
layout = QVBoxLayout()
layout.addWidget(lbl_html)
layout.addWidget(self.tabs)
layout.addWidget(self.bt_sign_in)
self.setLayout(layout)
# Final adjustments
if username and password:
self.le_user.setText(username)
self.le_password.setText(password)
self.bt_sign_in.setFocus()
elif username:
self.le_user.setText(username)
self.le_password.setFocus()
elif token:
self.le_token.setText(token)
else:
self.le_user.setFocus()
self.setFixedSize(self.width(), self.height())
self.le_password.installEventFilter(self)
self.le_user.installEventFilter(self)
self.tabs.currentChanged.connect(self.update_btn_state)
def eventFilter(self, obj, event):
interesting_objects = [self.le_password, self.le_user]
if obj in interesting_objects and event.type() == QEvent.KeyPress:
if (event.key() == Qt.Key_Return and
event.modifiers() & Qt.ControlModifier and
self.bt_sign_in.isEnabled()):
self.accept()
return True
return False
def update_btn_state(self):
user = to_text_string(self.le_user.text()).strip() != ''
password = to_text_string(self.le_password.text()).strip() != ''
token = to_text_string(self.le_token.text()).strip() != ''
enable = ((user and password and
self.tabs.currentIndex() == 0) or
(token and self.tabs.currentIndex() == 1))
self.bt_sign_in.setEnabled(enable)
def is_keyring_available(self):
"""Check if keyring is available for password storage."""
try:
import keyring # analysis:ignore
return True
except Exception:
return False
@classmethod
def login(cls, parent, username, password, token,
remember, remember_token):
dlg = DlgGitHubLogin(parent, username, password, token, remember,
remember_token)
if dlg.exec_() == dlg.Accepted:
user = dlg.le_user.text()
password = dlg.le_password.text()
token = dlg.le_token.text()
if dlg.cb_remember:
remember = dlg.cb_remember.isChecked()
else:
remember = False
if dlg.cb_remember_token:
remember_token = dlg.cb_remember_token.isChecked()
else:
remember_token = False
credentials = dict(username=user,
password=password,
token=token,
remember=remember,
remember_token=remember_token)
return credentials
return dict(username=None,
password=None,
token=None,
remember=False,
remember_token=False)
def setup_page(self):
newcb = self.create_checkbox
# --- Display tab ---
showtabbar_box = newcb(_("Show tab bar"), 'show_tab_bar')
showclassfuncdropdown_box = newcb(
_("Show selector for classes and functions"),
'show_class_func_dropdown')
showindentguides_box = newcb(_("Show Indent Guides"),
'indent_guides')
linenumbers_box = newcb(_("Show line numbers"), 'line_numbers')
blanks_box = newcb(_("Show blank spaces"), 'blank_spaces')
currentline_box = newcb(_("Highlight current line"),
'highlight_current_line')
currentcell_box = newcb(_("Highlight current cell"),
'highlight_current_cell')
wrap_mode_box = newcb(_("Wrap lines"), 'wrap')
scroll_past_end_box = newcb(_("Scroll past the end"),
'scroll_past_end')
edgeline_box = newcb(_("Show vertical lines at"), 'edge_line')
edgeline_edit = self.create_lineedit(
"",
'edge_line_columns',
tip=("Enter values separated by commas"),
alignment=Qt.Horizontal,
regex="[0-9]+(,[0-9]+)*")
edgeline_edit_label = QLabel(_("characters"))
edgeline_box.toggled.connect(edgeline_edit.setEnabled)
edgeline_box.toggled.connect(edgeline_edit_label.setEnabled)
edgeline_edit.setEnabled(self.get_option('edge_line'))
edgeline_edit_label.setEnabled(self.get_option('edge_line'))
occurrence_box = newcb(_("Highlight occurrences after"),
'occurrence_highlighting')
occurrence_spin = self.create_spinbox(
"", _(" ms"),
'occurrence_highlighting/timeout',
min_=100, max_=1000000, step=100)
occurrence_box.toggled.connect(occurrence_spin.spinbox.setEnabled)
occurrence_box.toggled.connect(occurrence_spin.slabel.setEnabled)
occurrence_spin.spinbox.setEnabled(
self.get_option('occurrence_highlighting'))
occurrence_spin.slabel.setEnabled(
self.get_option('occurrence_highlighting'))
display_g_layout = QGridLayout()
display_g_layout.addWidget(edgeline_box, 0, 0)
display_g_layout.addWidget(edgeline_edit.textbox, 0, 1)
display_g_layout.addWidget(edgeline_edit_label, 0, 2)
display_g_layout.addWidget(occurrence_box, 1, 0)
display_g_layout.addWidget(occurrence_spin.spinbox, 1, 1)
display_g_layout.addWidget(occurrence_spin.slabel, 1, 2)
display_h_layout = QHBoxLayout()
display_h_layout.addLayout(display_g_layout)
display_h_layout.addStretch(1)
display_layout = QVBoxLayout()
display_layout.addWidget(showtabbar_box)
display_layout.addWidget(showclassfuncdropdown_box)
display_layout.addWidget(showindentguides_box)
display_layout.addWidget(linenumbers_box)
display_layout.addWidget(blanks_box)
display_layout.addWidget(currentline_box)
display_layout.addWidget(currentcell_box)
display_layout.addWidget(wrap_mode_box)
display_layout.addWidget(scroll_past_end_box)
display_layout.addLayout(display_h_layout)
display_widget = QWidget()
display_widget.setLayout(display_layout)
# --- Source code tab ---
closepar_box = newcb(
_("Automatic insertion of parentheses, braces and brackets"),
'close_parentheses')
close_quotes_box = newcb(
_("Automatic insertion of closing quotes"),
'close_quotes')
add_colons_box = newcb(
_("Automatic insertion of colons after 'for', 'if', 'def', etc"),
'add_colons')
autounindent_box = newcb(
_("Automatic indentation after 'else', 'elif', etc."),
'auto_unindent')
tab_mode_box = newcb(
_("Tab always indent"),
'tab_always_indent', default=False,
tip=_("If enabled, pressing Tab will always indent,\n"
"even when the cursor is not at the beginning\n"
"of a line (when this option is enabled, code\n"
"completion may be triggered using the alternate\n"
"shortcut: Ctrl+Space)"))
ibackspace_box = newcb(
_("Intelligent backspace"),
'intelligent_backspace',
default=True)
removetrail_box = newcb(
_("Automatically remove trailing spaces when saving files"),
'always_remove_trailing_spaces',
default=False)
indent_chars_box = self.create_combobox(
_("Indentation characters: "),
((_("2 spaces"), '* *'),
(_("3 spaces"), '* *'),
(_("4 spaces"), '* *'),
(_("5 spaces"), '* *'),
(_("6 spaces"), '* *'),
(_("7 spaces"), '* *'),
(_("8 spaces"), '* *'),
(_("Tabulations"), '*\t*')),
'indent_chars')
tabwidth_spin = self.create_spinbox(
_("Tab stop width:"),
_("spaces"),
'tab_stop_width_spaces',
4, 1, 8, 1)
def enable_tabwidth_spin(index):
if index == 7: # Tabulations
tabwidth_spin.plabel.setEnabled(True)
tabwidth_spin.spinbox.setEnabled(True)
else:
tabwidth_spin.plabel.setEnabled(False)
tabwidth_spin.spinbox.setEnabled(False)
indent_chars_box.combobox.currentIndexChanged.connect(
enable_tabwidth_spin)
indent_tab_grid_layout = QGridLayout()
indent_tab_grid_layout.addWidget(indent_chars_box.label, 0, 0)
indent_tab_grid_layout.addWidget(indent_chars_box.combobox, 0, 1)
indent_tab_grid_layout.addWidget(tabwidth_spin.plabel, 1, 0)
indent_tab_grid_layout.addWidget(tabwidth_spin.spinbox, 1, 1)
indent_tab_grid_layout.addWidget(tabwidth_spin.slabel, 1, 2)
indent_tab_layout = QHBoxLayout()
indent_tab_layout.addLayout(indent_tab_grid_layout)
indent_tab_layout.addStretch(1)
sourcecode_layout = QVBoxLayout()
sourcecode_layout.addWidget(closepar_box)
sourcecode_layout.addWidget(autounindent_box)
sourcecode_layout.addWidget(add_colons_box)
sourcecode_layout.addWidget(close_quotes_box)
sourcecode_layout.addWidget(tab_mode_box)
sourcecode_layout.addWidget(ibackspace_box)
sourcecode_layout.addWidget(removetrail_box)
sourcecode_layout.addLayout(indent_tab_layout)
sourcecode_widget = QWidget()
sourcecode_widget.setLayout(sourcecode_layout)
# --- Run code tab ---
saveall_box = newcb(_("Save all files before running script"),
'save_all_before_run')
focus_box = newcb(_("Maintain focus in the Editor after running cells "
"or selections"), 'focus_to_editor')
run_cell_box = newcb(_("Copy full cell contents to the console when "
"running code cells"), 'run_cell_copy')
run_layout = QVBoxLayout()
run_layout.addWidget(saveall_box)
run_layout.addWidget(focus_box)
run_layout.addWidget(run_cell_box)
run_widget = QWidget()
run_widget.setLayout(run_layout)
# --- Advanced tab ---
# -- Templates
template_btn = self.create_button(_("Edit template for new files"),
self.plugin.edit_template)
# -- Autosave
autosave_group = QGroupBox(_('Autosave'))
autosave_checkbox = newcb(
_('Automatically save a copy of files with unsaved changes'),
'autosave_enabled')
autosave_spinbox = self.create_spinbox(
_('Autosave interval: '),
_('seconds'),
'autosave_interval',
min_=1, max_=3600)
autosave_checkbox.toggled.connect(autosave_spinbox.setEnabled)
autosave_layout = QVBoxLayout()
autosave_layout.addWidget(autosave_checkbox)
autosave_layout.addWidget(autosave_spinbox)
autosave_group.setLayout(autosave_layout)
# -- Docstring
docstring_group = QGroupBox(_('Docstring type'))
numpy_url = "<a href='{}'>Numpy</a>".format(NUMPYDOC)
googledoc_url = "<a href='{}'>Google</a>".format(GOOGLEDOC)
docstring_label = QLabel(
_("Here you can select the type of docstrings ({} or {}) you "
"want the editor to automatically introduce when pressing "
"<tt>{}</tt> after a function/method/class "
"declaration.").format(
numpy_url, googledoc_url, DOCSTRING_SHORTCUT))
docstring_label.setOpenExternalLinks(True)
docstring_label.setWordWrap(True)
docstring_combo_choices = ((_("Numpy"), 'Numpydoc'),
(_("Google"), 'Googledoc'),)
docstring_combo = self.create_combobox(
"Type:",
docstring_combo_choices,
'docstring_type')
docstring_layout = QVBoxLayout()
docstring_layout.addWidget(docstring_label)
docstring_layout.addWidget(docstring_combo)
docstring_group.setLayout(docstring_layout)
# -- Annotations
annotations_group = QGroupBox(_("Annotations"))
annotations_label = QLabel(
_("Display a marker to the left of line numbers when the "
"following annotations appear at the beginning of a comment: "
"<tt>TODO, FIXME, XXX, HINT, TIP, @todo, HACK, BUG, OPTIMIZE, "
"!!!, ???</tt>"))
annotations_label.setWordWrap(True)
todolist_box = newcb(
_("Display code annotations"),
'todo_list')
annotations_layout = QVBoxLayout()
annotations_layout.addWidget(annotations_label)
annotations_layout.addWidget(todolist_box)
annotations_group.setLayout(annotations_layout)
# -- EOL
eol_group = QGroupBox(_("End-of-line characters"))
eol_label = QLabel(_("When opening a text file containing "
"mixed end-of-line characters (this may "
"raise syntax errors in the consoles "
"on Windows platforms), Spyder may fix the "
"file automatically."))
eol_label.setWordWrap(True)
check_eol_box = newcb(_("Fix automatically and show warning "
"message box"),
'check_eol_chars', default=True)
convert_eol_on_save_box = newcb(_("On Save: convert EOL characters"
" to"),
'convert_eol_on_save', default=False)
eol_combo_choices = ((_("LF (UNIX)"), 'LF'),
(_("CRLF (Windows)"), 'CRLF'),
(_("CR (Mac)"), 'CR'),
)
convert_eol_on_save_combo = self.create_combobox("",
eol_combo_choices,
('convert_eol_on_'
'save_to'),
)
convert_eol_on_save_box.toggled.connect(
convert_eol_on_save_combo.setEnabled)
convert_eol_on_save_combo.setEnabled(
self.get_option('convert_eol_on_save'))
eol_on_save_layout = QHBoxLayout()
eol_on_save_layout.addWidget(convert_eol_on_save_box)
eol_on_save_layout.addWidget(convert_eol_on_save_combo)
eol_layout = QVBoxLayout()
eol_layout.addWidget(eol_label)
eol_layout.addWidget(check_eol_box)
eol_layout.addLayout(eol_on_save_layout)
eol_group.setLayout(eol_layout)
# --- Tabs ---
tabs = QTabWidget()
tabs.addTab(self.create_tab(display_widget), _("Display"))
tabs.addTab(self.create_tab(sourcecode_widget), _("Source code"))
tabs.addTab(self.create_tab(run_widget), _('Run Code'))
tabs.addTab(self.create_tab(template_btn, autosave_group,
docstring_group, annotations_group,
eol_group),
_("Advanced settings"))
vlayout = QVBoxLayout()
vlayout.addWidget(tabs)
self.setLayout(vlayout)
def setup_page(self):
self.ICON = ima.icon('genprefs')
newcb = self.create_checkbox
# --- Interface
general_group = QGroupBox(_("General"))
languages = LANGUAGE_CODES.items()
language_choices = sorted([(val, key) for key, val in languages])
language_combo = self.create_combobox(_('Language:'),
language_choices,
'interface_language',
restart=True)
opengl_options = ['Automatic', 'Desktop', 'Software', 'GLES']
opengl_choices = list(zip(opengl_options,
[c.lower() for c in opengl_options]))
opengl_combo = self.create_combobox(_('Rendering engine:'),
opengl_choices,
'opengl',
restart=True)
single_instance_box = newcb(_("Use a single instance"),
'single_instance',
tip=_("Set this to open external<br> "
"Python files in an already running "
"instance (Requires a restart)"))
prompt_box = newcb(_("Prompt when exiting"), 'prompt_on_exit')
popup_console_box = newcb(_("Show internal Spyder errors to report "
"them to Github"), 'show_internal_errors')
check_updates = newcb(_("Check for updates on startup"),
'check_updates_on_startup')
# Decide if it's possible to activate or not single instance mode
if running_in_mac_app():
self.set_option("single_instance", True)
single_instance_box.setEnabled(False)
comboboxes_advanced_layout = QHBoxLayout()
cbs_adv_grid = QGridLayout()
cbs_adv_grid.addWidget(language_combo.label, 0, 0)
cbs_adv_grid.addWidget(language_combo.combobox, 0, 1)
cbs_adv_grid.addWidget(opengl_combo.label, 1, 0)
cbs_adv_grid.addWidget(opengl_combo.combobox, 1, 1)
comboboxes_advanced_layout.addLayout(cbs_adv_grid)
comboboxes_advanced_layout.addStretch(1)
general_layout = QVBoxLayout()
general_layout.addLayout(comboboxes_advanced_layout)
general_layout.addWidget(single_instance_box)
general_layout.addWidget(prompt_box)
general_layout.addWidget(popup_console_box)
general_layout.addWidget(check_updates)
general_group.setLayout(general_layout)
# --- Theme
interface_group = QGroupBox(_("Interface"))
vertdock_box = newcb(_("Vertical title bars in panes"),
'vertical_dockwidget_titlebars')
verttabs_box = newcb(_("Vertical tabs in panes"),
'vertical_tabs')
animated_box = newcb(_("Animated toolbars and panes"),
'animated_docks')
tear_off_box = newcb(_("Tear off menus"), 'tear_off_menus',
tip=_("Set this to detach any<br> "
"menu from the main window"))
margin_box = newcb(_("Custom margin for panes:"),
'use_custom_margin')
margin_spin = self.create_spinbox("", _("pixels"), 'custom_margin',
0, 0, 30)
margin_box.toggled.connect(margin_spin.spinbox.setEnabled)
margin_box.toggled.connect(margin_spin.slabel.setEnabled)
margin_spin.spinbox.setEnabled(self.get_option('use_custom_margin'))
margin_spin.slabel.setEnabled(self.get_option('use_custom_margin'))
cursor_box = newcb(_("Cursor blinking:"),
'use_custom_cursor_blinking')
cursor_spin = self.create_spinbox(
"", _("ms"),
'custom_cursor_blinking',
default=QApplication.cursorFlashTime(),
min_=0, max_=5000, step=100)
cursor_box.toggled.connect(cursor_spin.spinbox.setEnabled)
cursor_box.toggled.connect(cursor_spin.slabel.setEnabled)
cursor_spin.spinbox.setEnabled(
self.get_option('use_custom_cursor_blinking'))
cursor_spin.slabel.setEnabled(
self.get_option('use_custom_cursor_blinking'))
margins_cursor_layout = QGridLayout()
margins_cursor_layout.addWidget(margin_box, 0, 0)
margins_cursor_layout.addWidget(margin_spin.spinbox, 0, 1)
margins_cursor_layout.addWidget(margin_spin.slabel, 0, 2)
margins_cursor_layout.addWidget(cursor_box, 1, 0)
margins_cursor_layout.addWidget(cursor_spin.spinbox, 1, 1)
margins_cursor_layout.addWidget(cursor_spin.slabel, 1, 2)
margins_cursor_layout.setColumnStretch(2, 100)
# Layout interface
interface_layout = QVBoxLayout()
interface_layout.addWidget(vertdock_box)
interface_layout.addWidget(verttabs_box)
interface_layout.addWidget(animated_box)
interface_layout.addWidget(tear_off_box)
interface_layout.addLayout(margins_cursor_layout)
interface_group.setLayout(interface_layout)
# --- Status bar
sbar_group = QGroupBox(_("Status bar"))
show_status_bar = newcb(_("Show status bar"), 'show_status_bar')
memory_box = newcb(_("Show memory usage every"), 'memory_usage/enable',
tip=self.main.mem_status.toolTip())
memory_spin = self.create_spinbox("", _(" ms"), 'memory_usage/timeout',
min_=100, max_=1000000, step=100)
memory_box.toggled.connect(memory_spin.setEnabled)
memory_spin.setEnabled(self.get_option('memory_usage/enable'))
memory_box.setEnabled(self.main.mem_status.is_supported())
memory_spin.setEnabled(self.main.mem_status.is_supported())
cpu_box = newcb(_("Show CPU usage every"), 'cpu_usage/enable',
tip=self.main.cpu_status.toolTip())
cpu_spin = self.create_spinbox("", _(" ms"), 'cpu_usage/timeout',
min_=100, max_=1000000, step=100)
cpu_box.toggled.connect(cpu_spin.setEnabled)
cpu_spin.setEnabled(self.get_option('cpu_usage/enable'))
cpu_box.setEnabled(self.main.cpu_status.is_supported())
cpu_spin.setEnabled(self.main.cpu_status.is_supported())
status_bar_o = self.get_option('show_status_bar')
show_status_bar.toggled.connect(memory_box.setEnabled)
show_status_bar.toggled.connect(memory_spin.setEnabled)
show_status_bar.toggled.connect(cpu_box.setEnabled)
show_status_bar.toggled.connect(cpu_spin.setEnabled)
memory_box.setEnabled(status_bar_o)
memory_spin.setEnabled(status_bar_o)
cpu_box.setEnabled(status_bar_o)
cpu_spin.setEnabled(status_bar_o)
# Layout status bar
cpu_memory_layout = QGridLayout()
cpu_memory_layout.addWidget(memory_box, 0, 0)
cpu_memory_layout.addWidget(memory_spin, 0, 1)
cpu_memory_layout.addWidget(cpu_box, 1, 0)
cpu_memory_layout.addWidget(cpu_spin, 1, 1)
sbar_layout = QVBoxLayout()
sbar_layout.addWidget(show_status_bar)
sbar_layout.addLayout(cpu_memory_layout)
sbar_group.setLayout(sbar_layout)
# --- Screen resolution Group (hidpi)
screen_resolution_group = QGroupBox(_("Screen resolution"))
screen_resolution_bg = QButtonGroup(screen_resolution_group)
screen_resolution_label = QLabel(_("Configuration for high DPI "
"screens<br><br>"
"Please see "
"<a href=\"{0}\">{0}</a><> "
"for more information about "
"these options (in "
"English).").format(HDPI_QT_PAGE))
screen_resolution_label.setWordWrap(True)
normal_radio = self.create_radiobutton(
_("Normal"),
'normal_screen_resolution',
button_group=screen_resolution_bg)
auto_scale_radio = self.create_radiobutton(
_("Enable auto high DPI scaling"),
'high_dpi_scaling',
button_group=screen_resolution_bg,
tip=_("Set this for high DPI displays"),
restart=True)
custom_scaling_radio = self.create_radiobutton(
_("Set a custom high DPI scaling"),
'high_dpi_custom_scale_factor',
button_group=screen_resolution_bg,
tip=_("Set this for high DPI displays when "
"auto scaling does not work"),
restart=True)
custom_scaling_edit = self.create_lineedit(
"",
'high_dpi_custom_scale_factors',
tip=_("Enter values for different screens "
"separated by semicolons ';', "
"float values are supported"),
alignment=Qt.Horizontal,
regex=r"[0-9]+(?:\.[0-9]*)(;[0-9]+(?:\.[0-9]*))*",
restart=True)
normal_radio.toggled.connect(custom_scaling_edit.setDisabled)
auto_scale_radio.toggled.connect(custom_scaling_edit.setDisabled)
custom_scaling_radio.toggled.connect(custom_scaling_edit.setEnabled)
# Layout Screen resolution
screen_resolution_layout = QVBoxLayout()
screen_resolution_layout.addWidget(screen_resolution_label)
screen_resolution_inner_layout = QGridLayout()
screen_resolution_inner_layout.addWidget(normal_radio, 0, 0)
screen_resolution_inner_layout.addWidget(auto_scale_radio, 1, 0)
screen_resolution_inner_layout.addWidget(custom_scaling_radio, 2, 0)
screen_resolution_inner_layout.addWidget(custom_scaling_edit, 2, 1)
screen_resolution_layout.addLayout(screen_resolution_inner_layout)
screen_resolution_group.setLayout(screen_resolution_layout)
tabs = QTabWidget()
tabs.addTab(self.create_tab(screen_resolution_group, interface_group),
_("Interface"))
tabs.addTab(self.create_tab(general_group, sbar_group),
_("Advanced Settings"))
vlayout = QVBoxLayout()
vlayout.addWidget(tabs)
self.setLayout(vlayout)
def setup_page(self):
interface_group = QGroupBox(_("Interface"))
newcb = self.create_checkbox
singletab_box = newcb(_("One tab per script"), 'single_tab')
showtime_box = newcb(_("Show elapsed time"), 'show_elapsed_time')
icontext_box = newcb(_("Show icons and text"), 'show_icontext')
# Interface Group
interface_layout = QVBoxLayout()
interface_layout.addWidget(singletab_box)
interface_layout.addWidget(showtime_box)
interface_layout.addWidget(icontext_box)
interface_group.setLayout(interface_layout)
# Source Code Group
display_group = QGroupBox(_("Source code"))
buffer_spin = self.create_spinbox(
_("Buffer: "), _(" lines"),
'max_line_count', min_=0, max_=1000000, step=100,
tip=_("Set maximum line count"))
wrap_mode_box = newcb(_("Wrap lines"), 'wrap')
merge_channels_box = newcb(
_("Merge process standard output/error channels"),
'merge_output_channels',
tip=_("Merging the output channels of the process means that\n"
"the standard error won't be written in red anymore,\n"
"but this has the effect of speeding up display."))
colorize_sys_stderr_box = newcb(
_("Colorize standard error channel using ANSI escape codes"),
'colorize_sys_stderr',
tip=_("This method is the only way to have colorized standard\n"
"error channel when the output channels have been "
"merged."))
merge_channels_box.toggled.connect(colorize_sys_stderr_box.setEnabled)
merge_channels_box.toggled.connect(colorize_sys_stderr_box.setChecked)
colorize_sys_stderr_box.setEnabled(
self.get_option('merge_output_channels'))
display_layout = QVBoxLayout()
display_layout.addWidget(buffer_spin)
display_layout.addWidget(wrap_mode_box)
display_layout.addWidget(merge_channels_box)
display_layout.addWidget(colorize_sys_stderr_box)
display_group.setLayout(display_layout)
# Background Color Group
bg_group = QGroupBox(_("Background color"))
bg_label = QLabel(_("This option will be applied the next time "
"a Python console or a terminal is opened."))
bg_label.setWordWrap(True)
lightbg_box = newcb(_("Light background (white color)"),
'light_background')
bg_layout = QVBoxLayout()
bg_layout.addWidget(bg_label)
bg_layout.addWidget(lightbg_box)
bg_group.setLayout(bg_layout)
# Advanced settings
source_group = QGroupBox(_("Source code"))
completion_box = newcb(_("Automatic code completion"),
'codecompletion/auto')
case_comp_box = newcb(_("Case sensitive code completion"),
'codecompletion/case_sensitive')
comp_enter_box = newcb(_("Enter key selects completion"),
'codecompletion/enter_key')
calltips_box = newcb(_("Display balloon tips"), 'calltips')
source_layout = QVBoxLayout()
source_layout.addWidget(completion_box)
source_layout.addWidget(case_comp_box)
source_layout.addWidget(comp_enter_box)
source_layout.addWidget(calltips_box)
source_group.setLayout(source_layout)
# PYTHONSTARTUP replacement
pystartup_group = QGroupBox(_("PYTHONSTARTUP replacement"))
pystartup_bg = QButtonGroup(pystartup_group)
pystartup_label = QLabel(_("This option will override the "
"PYTHONSTARTUP environment variable which\n"
"defines the script to be executed during "
"the Python console startup."))
def_startup_radio = self.create_radiobutton(
_("Default PYTHONSTARTUP script"),
'pythonstartup/default',
button_group=pystartup_bg)
cus_startup_radio = self.create_radiobutton(
_("Use the following startup script:"),
'pythonstartup/custom',
button_group=pystartup_bg)
pystartup_file = self.create_browsefile('', 'pythonstartup', '',
filters=_("Python scripts")+\
" (*.py)")
def_startup_radio.toggled.connect(pystartup_file.setDisabled)
cus_startup_radio.toggled.connect(pystartup_file.setEnabled)
pystartup_layout = QVBoxLayout()
pystartup_layout.addWidget(pystartup_label)
pystartup_layout.addWidget(def_startup_radio)
pystartup_layout.addWidget(cus_startup_radio)
pystartup_layout.addWidget(pystartup_file)
pystartup_group.setLayout(pystartup_layout)
# Monitor Group
monitor_group = QGroupBox(_("Monitor"))
monitor_label = QLabel(_("The monitor provides introspection "
"features to console: code completion, "
"calltips and variable explorer. "
"Because it relies on several modules, "
"disabling the monitor may be useful "
"to accelerate console startup."))
monitor_label.setWordWrap(True)
monitor_box = newcb(_("Enable monitor"), 'monitor/enabled')
for obj in (completion_box, case_comp_box, comp_enter_box,
calltips_box):
monitor_box.toggled.connect(obj.setEnabled)
obj.setEnabled(self.get_option('monitor/enabled'))
monitor_layout = QVBoxLayout()
monitor_layout.addWidget(monitor_label)
monitor_layout.addWidget(monitor_box)
monitor_group.setLayout(monitor_layout)
# Qt Group
opts = [
(_("Default library"), 'default'),
('PyQt5', 'pyqt5'),
('PyQt4', 'pyqt'),
('PySide', 'pyside'),
]
qt_group = QGroupBox(_("Qt-Python Bindings"))
qt_setapi_box = self.create_combobox(
_("Library:") + " ", opts,
'qt/api', default='default',
tip=_("This option will act on<br> "
"libraries such as Matplotlib, guidata "
"or ETS"))
qt_layout = QVBoxLayout()
qt_layout.addWidget(qt_setapi_box)
qt_group.setLayout(qt_layout)
# Matplotlib Group
mpl_group = QGroupBox(_("Graphics"))
mpl_label = QLabel(_("Decide which backend to use to display graphics. "
"If unsure, please select the <b>Automatic</b> "
"backend.<br><br>"
"<b>Note:</b> We support a very limited number "
"of backends in our Python consoles. If you "
"prefer to work with a different one, please use "
"an IPython console."))
mpl_label.setWordWrap(True)
backends = [(_("Automatic"), 0), (_("None"), 1)]
if not os.name == 'nt' and programs.is_module_installed('_tkinter'):
backends.append( ("Tkinter", 2) )
backends = tuple(backends)
mpl_backend_box = self.create_combobox( _("Backend:")+" ", backends,
'matplotlib/backend/value',
tip=_("This option will be applied the "
"next time a console is opened."))
mpl_installed = programs.is_module_installed('matplotlib')
mpl_layout = QVBoxLayout()
mpl_layout.addWidget(mpl_label)
mpl_layout.addWidget(mpl_backend_box)
mpl_group.setLayout(mpl_layout)
mpl_group.setEnabled(mpl_installed)
# ETS Group
ets_group = QGroupBox(_("Enthought Tool Suite"))
ets_label = QLabel(_("Enthought Tool Suite (ETS) supports "
"PyQt4 (qt4) and wxPython (wx) graphical "
"user interfaces."))
ets_label.setWordWrap(True)
ets_edit = self.create_lineedit(_("ETS_TOOLKIT:"), 'ets_backend',
alignment=Qt.Horizontal)
ets_layout = QVBoxLayout()
ets_layout.addWidget(ets_label)
ets_layout.addWidget(ets_edit)
ets_group.setLayout(ets_layout)
if CONF.get('main_interpreter','default'):
interpreter = get_python_executable()
else:
interpreter = CONF.get('main_interpreter', 'executable')
ets_group.setEnabled(programs.is_module_installed(
"enthought.etsconfig.api",
interpreter=interpreter))
tabs = QTabWidget()
tabs.addTab(self.create_tab(interface_group, display_group,
bg_group),
_("Display"))
tabs.addTab(self.create_tab(monitor_group, source_group),
_("Introspection"))
tabs.addTab(self.create_tab(pystartup_group), _("Advanced settings"))
tabs.addTab(self.create_tab(qt_group, mpl_group, ets_group),
_("External modules"))
vlayout = QVBoxLayout()
vlayout.addWidget(tabs)
self.setLayout(vlayout)
class PyChopGui(QMainWindow):
"""
GUI Class using PyQT for PyChop to help users plan inelastic neutron experiments
at spallation sources by calculating the resolution and flux at a given neutron energies.
"""
instruments = {}
choppers = {}
minE = {}
maxE = {}
def __init__(self):
super(PyChopGui, self).__init__()
self.folder = os.path.dirname(sys.modules[self.__module__].__file__)
for fname in os.listdir(self.folder):
if fname.endswith('.yaml'):
instobj = Instrument(os.path.join(self.folder, fname))
self.instruments[instobj.name] = instobj
self.choppers[instobj.name] = instobj.getChopperNames()
self.minE[instobj.name] = max([instobj.emin, 0.01])
self.maxE[instobj.name] = instobj.emax
self.drawLayout()
self.setInstrument(list(self.instruments.keys())[0])
self.resaxes_xlim = 0
self.qeaxes_xlim = 0
self.isFramePlotted = 0
def setInstrument(self, instname):
"""
Defines the instrument parameters by the name of the instrument.
"""
self.engine = self.instruments[str(instname)]
self.tabs.setTabEnabled(self.tdtabID, False)
self.widgets['ChopperCombo']['Combo'].clear()
self.widgets['FrequencyCombo']['Combo'].clear()
self.widgets['FrequencyCombo']['Label'].setText('Frequency')
self.widgets['PulseRemoverCombo']['Combo'].clear()
for item in self.choppers[str(instname)]:
self.widgets['ChopperCombo']['Combo'].addItem(item)
rep = self.engine.moderator.source_rep
maxfreq = self.engine.chopper_system.max_frequencies
# At the moment, the GUI only supports up to two independent frequencies
if not hasattr(maxfreq, '__len__') or len(maxfreq) == 1:
self.widgets['PulseRemoverCombo']['Combo'].hide()
self.widgets['PulseRemoverCombo']['Label'].hide()
for fq in range(rep, (maxfreq[0] if hasattr(maxfreq, '__len__') else maxfreq) + 1, rep):
self.widgets['FrequencyCombo']['Combo'].addItem(str(fq))
if hasattr(self.engine.chopper_system, 'frequency_names'):
self.widgets['FrequencyCombo']['Label'].setText(self.engine.chopper_system.frequency_names[0])
else:
self.widgets['PulseRemoverCombo']['Combo'].show()
self.widgets['PulseRemoverCombo']['Label'].show()
if hasattr(self.engine.chopper_system, 'frequency_names'):
for idx, chp in enumerate([self.widgets['FrequencyCombo']['Label'], self.widgets['PulseRemoverCombo']['Label']]):
chp.setText(self.engine.chopper_system.frequency_names[idx])
for fq in range(rep, maxfreq[0] + 1, rep):
self.widgets['FrequencyCombo']['Combo'].addItem(str(fq))
for fq in range(rep, maxfreq[1] + 1, rep):
self.widgets['PulseRemoverCombo']['Combo'].addItem(str(fq))
if len(self.engine.chopper_system.choppers) > 1:
self.widgets['MultiRepCheck'].setEnabled(True)
self.tabs.setTabEnabled(self.tdtabID, True)
else:
self.widgets['MultiRepCheck'].setEnabled(False)
self.widgets['MultiRepCheck'].setChecked(False)
self.widgets['Chopper2Phase']['Edit'].hide()
self.widgets['Chopper2Phase']['Label'].hide()
if self.engine.chopper_system.isPhaseIndependent:
self.widgets['Chopper2Phase']['Edit'].show()
self.widgets['Chopper2Phase']['Label'].show()
self.widgets['Chopper2Phase']['Edit'].setText(str(self.engine.chopper_system.defaultPhase[0]))
self.widgets['Chopper2Phase']['Label'].setText(self.engine.chopper_system.phaseNames[0])
# Special case for MERLIN - hide phase control from normal users
if 'MERLIN' in str(instname) and not self.instSciAct.isChecked():
self.widgets['Chopper2Phase']['Edit'].hide()
self.widgets['Chopper2Phase']['Label'].hide()
self.engine.setChopper(str(self.widgets['ChopperCombo']['Combo'].currentText()))
self.engine.setFrequency(float(self.widgets['FrequencyCombo']['Combo'].currentText()))
val = self.flxslder.val * self.maxE[self.engine.instname] / 100
self.flxedt.setText('%3.2f' % (val))
nframe = self.engine.moderator.n_frame if hasattr(self.engine.moderator, 'n_frame') else 1
self.repfig_nframe_edit.setText(str(nframe))
self.repfig_nframe_rep1only.setChecked(False)
if hasattr(self.engine.chopper_system, 'default_frequencies'):
cb = [self.widgets['FrequencyCombo']['Combo'], self.widgets['PulseRemoverCombo']['Combo']]
for idx, freq in enumerate(self.engine.chopper_system.default_frequencies):
cb[idx].setCurrentIndex([i for i in range(cb[idx].count()) if str(freq) in cb[idx].itemText(i)][0])
if idx > 1:
break
self.tabs.setTabEnabled(self.qetabID, False)
if self.engine.has_detector and hasattr(self.engine.detector, 'tthlims'):
self.tabs.setTabEnabled(self.qetabID, True)
def setChopper(self, choppername):
"""
Defines the Fermi chopper slit package type by name, or the disk chopper arrangement variant.
"""
self.engine.setChopper(str(choppername))
self.engine.setFrequency(float(self.widgets['FrequencyCombo']['Combo'].currentText()))
# Special case for MERLIN - only enable multirep for 'G' chopper
if 'MERLIN' in self.engine.instname:
if 'G' in str(choppername):
self.widgets['MultiRepCheck'].setEnabled(True)
self.tabs.setTabEnabled(self.tdtabID, True)
self.widgets['Chopper2Phase']['Edit'].setText('1500')
self.widgets['Chopper2Phase']['Label'].setText('Disk chopper phase delay time')
if self.instSciAct.isChecked():
self.widgets['Chopper2Phase']['Edit'].show()
self.widgets['Chopper2Phase']['Label'].show()
else:
self.widgets['MultiRepCheck'].setEnabled(False)
self.widgets['MultiRepCheck'].setChecked(False)
self.tabs.setTabEnabled(self.tdtabID, False)
self.widgets['Chopper2Phase']['Edit'].hide()
self.widgets['Chopper2Phase']['Label'].hide()
def setFreq(self, freqtext=None, **kwargs):
"""
Sets the chopper frequency(ies), in Hz.
"""
freq_gui = float(self.widgets['FrequencyCombo']['Combo'].currentText())
freq_in = kwargs['manual_freq'] if ('manual_freq' in kwargs.keys()) else freq_gui
if len(self.engine.getFrequency()) > 1 and (not hasattr(freq_in, '__len__') or len(freq_in)==1):
freqpr = float(self.widgets['PulseRemoverCombo']['Combo'].currentText())
freq_in = [freq_in, freqpr]
if not self.widgets['Chopper2Phase']['Label'].isHidden():
chop2phase = self.widgets['Chopper2Phase']['Edit'].text()
if isinstance(self.engine.chopper_system.defaultPhase[0], string_types):
chop2phase = str(chop2phase)
else:
chop2phase = float(chop2phase) % (1e6 / self.engine.moderator.source_rep)
self.engine.setFrequency(freq_in, phase=chop2phase)
else:
self.engine.setFrequency(freq_in)
def setEi(self):
"""
Sets the incident energy (or focused incident energy for multi-rep case).
"""
try:
eitxt = float(self.widgets['EiEdit']['Edit'].text())
self.engine.setEi(eitxt)
if self.eiPlots.isChecked():
self.calc_callback()
except ValueError:
raise ValueError('No Ei specified, or Ei string not understood')
def calc_callback(self):
"""
Calls routines to calculate the resolution / flux and to update the Matplotlib graphs.
"""
try:
if self.engine.getChopper() is None:
self.setChopper(self.widgets['ChopperCombo']['Combo'].currentText())
self.setEi()
self.setFreq()
self.calculate()
if self.errormess:
idx = [i for i, ei in enumerate(self.eis) if np.abs(ei - self.engine.getEi()) < 1.e-4]
if idx and self.flux[idx[0]] == 0:
raise ValueError(self.errormess)
self.errormessage(self.errormess)
self.plot_res()
self.plot_frame()
if self.instSciAct.isChecked():
self.update_script()
except ValueError as err:
self.errormessage(err)
self.plot_flux_ei()
self.plot_flux_hz()
def calculate(self):
"""
Performs the resolution and flux calculations.
"""
self.errormess = None
if self.engine.getEi() is None:
self.setEi()
if self.widgets['MultiRepCheck'].isChecked():
en = np.linspace(0, 0.95, 200)
self.eis = self.engine.getAllowedEi()
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always', UserWarning)
self.res = self.engine.getMultiRepResolution(en)
self.flux = self.engine.getMultiRepFlux()
if len(w) > 0:
mess = [str(w[i].message) for i in range(len(w))]
self.errormess = '\n'.join([m for m in mess if 'tchop' in m])
else:
en = np.linspace(0, 0.95*self.engine.getEi(), 200)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always', UserWarning)
self.res = self.engine.getResolution(en)
self.flux = self.engine.getFlux()
if len(w) > 0:
raise ValueError(w[0].message)
def _set_overplot(self, overplot, axisname):
axis = getattr(self, axisname)
if overplot:
if matplotlib.compare_versions('2.1.0',matplotlib.__version__):
axis.hold(True)
else:
setattr(self, axisname+'_xlim', 0)
axis.clear()
axis.axhline(color='k')
def plot_res(self):
"""
Plots the resolution in the resolution tab
"""
overplot = self.widgets['HoldCheck'].isChecked()
multiplot = self.widgets['MultiRepCheck'].isChecked()
self._set_overplot(overplot, 'resaxes')
self._set_overplot(overplot, 'qeaxes')
inst = self.engine.instname
freq = self.engine.getFrequency()
if hasattr(freq, '__len__'):
freq = freq[0]
if multiplot:
if matplotlib.compare_versions('2.1.0',matplotlib.__version__):
self.resaxes.hold(True)
for ie, Ei in enumerate(self.eis):
en = np.linspace(0, 0.95*Ei, 200)
if any(self.res[ie]):
if not self.flux[ie]:
continue
line, = self.resaxes.plot(en, self.res[ie])
label_text = '%s_%3.2fmeV_%dHz_Flux=%fn/cm2/s' % (inst, Ei, freq, self.flux[ie])
line.set_label(label_text)
if self.tabs.isTabEnabled(self.qetabID):
self.plot_qe(Ei, label_text, hold=True)
self.resaxes_xlim = max(Ei, self.resaxes_xlim)
if matplotlib.compare_versions('2.1.0',matplotlib.__version__):
self.resaxes.hold(False)
else:
ei = self.engine.getEi()
en = np.linspace(0, 0.95*ei, 200)
line, = self.resaxes.plot(en, self.res)
chopper = self.engine.getChopper()
label_text = '%s_%s_%3.2fmeV_%dHz_Flux=%fn/cm2/s' % (inst, chopper, ei, freq, self.flux)
line.set_label(label_text)
if self.tabs.isTabEnabled(self.qetabID):
self.plot_qe(ei, label_text, overplot)
self.resaxes_xlim = max(ei, self.resaxes_xlim)
self.resaxes.set_xlim([0, self.resaxes_xlim])
self.resaxes.legend().draggable()
self.resaxes.set_xlabel('Energy Transfer (meV)')
self.resaxes.set_ylabel(r'$\Delta$E (meV FWHM)')
self.rescanvas.draw()
def plot_qe(self, Ei, label_text, hold=False):
""" Plots the Q-E diagram """
from scipy import constants
E2q, meV2J = (2. * constants.m_n / (constants.hbar ** 2), constants.e / 1000.)
en = np.linspace(-Ei / 5., Ei, 100)
q2 = []
for tth in self.engine.detector.tthlims:
q = np.sqrt(E2q * (2 * Ei - en - 2 * np.sqrt(Ei * (Ei - en)) * np.cos(np.deg2rad(tth))) * meV2J) / 1e10
q2.append(np.concatenate((np.flipud(q), q)))
self._set_overplot(hold, 'qeaxes')
self.qeaxes_xlim = max(np.max(q2), self.qeaxes_xlim)
line, = self.qeaxes.plot(np.hstack(q2), np.concatenate((np.flipud(en), en)).tolist() * len(self.engine.detector.tthlims))
line.set_label(label_text)
self.qeaxes.set_xlim([0, self.qeaxes_xlim])
self.qeaxes.legend().draggable()
self.qeaxes.set_xlabel(r'$|Q| (\mathrm{\AA}^{-1})$')
self.qeaxes.set_ylabel('Energy Transfer (meV)')
self.qecanvas.draw()
def plot_flux_ei(self, **kwargs):
"""
Plots the flux vs Ei in the middle tab
"""
inst = self.engine.instname
chop = self.engine.getChopper()
freq = self.engine.getFrequency()
overplot = self.widgets['HoldCheck'].isChecked()
if hasattr(freq, '__len__'):
freq = freq[0]
update = kwargs['update'] if 'update' in kwargs.keys() else False
# Do not recalculate if all relevant parameters still the same.
_, labels = self.flxaxes2.get_legend_handles_labels()
searchStr = '([A-Z]+) "(.+)" ([0-9]+) Hz'
tmpinst = []
if (labels and (overplot or len(labels) == 1)) or update:
for prevtitle in labels:
prevInst, prevChop, prevFreq = re.search(searchStr, prevtitle).groups()
if update:
tmpinst.append(copy.deepcopy(Instrument(self.instruments[prevInst], prevChop, float(prevFreq))))
else:
if inst == prevInst and chop == prevChop and freq == float(prevFreq):
return
ne = 25
mn = self.minE[inst]
mx = (self.flxslder.val/100)*self.maxE[inst]
eis = np.linspace(mn, mx, ne)
flux = eis*0
elres = eis*0
if update:
self.flxaxes1.clear()
self.flxaxes2.clear()
if matplotlib.compare_versions('2.1.0',matplotlib.__version__):
self.flxaxes1.hold(True)
self.flxaxes2.hold(True)
for ii, instrument in enumerate(tmpinst):
for ie, ei in enumerate(eis):
with warnings.catch_warnings(record=True):
warnings.simplefilter('always', UserWarning)
flux[ie] = instrument.getFlux(ei)
elres[ie] = instrument.getResolution(0., ei)[0]
self.flxaxes1.plot(eis, flux)
line, = self.flxaxes2.plot(eis, elres)
line.set_label(labels[ii])
else:
for ie, ei in enumerate(eis):
with warnings.catch_warnings(record=True):
warnings.simplefilter('always', UserWarning)
flux[ie] = self.engine.getFlux(ei)
elres[ie] = self.engine.getResolution(0., ei)[0]
if overplot:
if matplotlib.compare_versions('2.1.0',matplotlib.__version__):
self.flxaxes1.hold(True)
self.flxaxes2.hold(True)
else:
self.flxaxes1.clear()
self.flxaxes2.clear()
self.flxaxes1.plot(eis, flux)
line, = self.flxaxes2.plot(eis, elres)
line.set_label('%s "%s" %d Hz' % (inst, chop, freq))
self.flxaxes1.set_xlim([mn, mx])
self.flxaxes2.set_xlim([mn, mx])
self.flxaxes1.set_xlabel('Incident Energy (meV)')
self.flxaxes1.set_ylabel('Flux (n/cm$^2$/s)')
self.flxaxes1.set_xlabel('Incident Energy (meV)')
self.flxaxes2.set_ylabel('Elastic Resolution FWHM (meV)')
lg = self.flxaxes2.legend()
lg.draggable()
self.flxcanvas.draw()
def update_slider(self, val=None):
"""
Callback function for the x-axis slider of the flux tab
"""
if val is None:
val = float(self.flxedt.text()) / self.maxE[self.engine.instname] * 100
if val < self.minE[self.engine.instname]:
self.errormessage("Max Ei must be greater than %2.1f" % (self.minE[self.engine.instname]))
val = (self.minE[self.engine.instname]+0.1) / self.maxE[self.engine.instname] * 100
self.flxslder.set_val(val)
else:
val = self.flxslder.val * self.maxE[self.engine.instname] / 100
self.flxedt.setText('%3.2f' % (val))
self.plot_flux_ei(update=True)
self.flxcanvas.draw()
def plot_flux_hz(self):
"""
Plots the flux vs freq in the middle tab
"""
inst = self.engine.instname
chop = self.engine.getChopper()
ei = float(self.widgets['EiEdit']['Edit'].text())
overplot = self.widgets['HoldCheck'].isChecked()
# Do not recalculate if one of the plots has the same parametersc
_, labels = self.frqaxes2.get_legend_handles_labels()
searchStr = '([A-Z]+) "(.+)" Ei = ([0-9.-]+) meV'
if labels and (overplot or len(labels) == 1):
for prevtitle in labels:
prevInst, prevChop, prevEi = re.search(searchStr, prevtitle).groups()
if inst == prevInst and chop == prevChop and abs(ei-float(prevEi)) < 0.01:
return
freq0 = self.engine.getFrequency()
rep = self.engine.moderator.source_rep
maxfreq = self.engine.chopper_system.max_frequencies
freqs = range(rep, (maxfreq[0] if hasattr(maxfreq, '__len__') else maxfreq) + 1, rep)
flux = np.zeros(len(freqs))
elres = np.zeros(len(freqs))
for ie, freq in enumerate(freqs):
if hasattr(freq0, '__len__'):
self.setFreq(manual_freq=[freq] + freq0[1:])
else:
self.setFreq(manual_freq=freq)
with warnings.catch_warnings(record=True):
warnings.simplefilter('always', UserWarning)
flux[ie] = self.engine.getFlux(ei)
elres[ie] = self.engine.getResolution(0., ei)[0]
if overplot:
if matplotlib.compare_versions('2.1.0',matplotlib.__version__):
self.frqaxes1.hold(True)
self.frqaxes2.hold(True)
else:
self.frqaxes1.clear()
self.frqaxes2.clear()
self.setFreq(manual_freq=freq0)
self.frqaxes1.set_xlabel('Chopper Frequency (Hz)')
self.frqaxes1.set_ylabel('Flux (n/cm$^2$/s)')
line, = self.frqaxes1.plot(freqs, flux, 'o-')
self.frqaxes1.set_xlim([0, np.max(freqs)])
self.frqaxes2.set_xlabel('Chopper Frequency (Hz)')
self.frqaxes2.set_ylabel('Elastic Resolution FWHM (meV)')
line, = self.frqaxes2.plot(freqs, elres, 'o-')
line.set_label('%s "%s" Ei = %5.3f meV' % (inst, chop, ei))
lg = self.frqaxes2.legend()
lg.draggable()
self.frqaxes2.set_xlim([0, np.max(freqs)])
self.frqcanvas.draw()
def instSciCB(self):
"""
Callback function for the "Instrument Scientist Mode" menu option
"""
# MERLIN is a special case - want to hide ability to change phase from users
if 'MERLIN' in self.engine.instname and 'G' in self.engine.getChopper():
if self.instSciAct.isChecked():
self.widgets['Chopper2Phase']['Edit'].show()
self.widgets['Chopper2Phase']['Label'].show()
self.widgets['Chopper2Phase']['Edit'].setText('1500')
self.widgets['Chopper2Phase']['Label'].setText('Disk chopper phase delay time')
else:
self.widgets['Chopper2Phase']['Edit'].hide()
self.widgets['Chopper2Phase']['Label'].hide()
if self.instSciAct.isChecked():
self.tabs.insertTab(self.scrtabID, self.scrtab, 'ScriptOutput')
self.scrtab.show()
else:
self.tabs.removeTab(self.scrtabID)
self.scrtab.hide()
def errormessage(self, message):
msg = QMessageBox()
msg.setText(str(message))
msg.setStandardButtons(QMessageBox.Ok)
msg.exec_()
def loadYaml(self):
yaml_file = QFileDialog().getOpenFileName(self.mainWidget, 'Open Instrument YAML File', self.folder, 'Files (*.yaml)')
if isinstance(yaml_file, tuple):
yaml_file = yaml_file[0]
yaml_file = str(yaml_file)
new_folder = os.path.dirname(yaml_file)
if new_folder != self.folder:
self.folder = new_folder
try:
new_inst = Instrument(yaml_file)
except (RuntimeError, AttributeError, ValueError) as err:
self.errormessage(err)
newname = new_inst.name
if newname in self.instruments.keys() and not self.overwriteload.isChecked():
overwrite, newname = self._ask_overwrite()
if overwrite == 1:
return
elif overwrite == 0:
newname = new_inst.name
self.instruments[newname] = new_inst
self.choppers[newname] = new_inst.getChopperNames()
self.minE[newname] = max([new_inst.emin, 0.01])
self.maxE[newname] = new_inst.emax
self.updateInstrumentList()
combo = self.widgets['InstrumentCombo']['Combo']
idx = [i for i in range(combo.count()) if str(combo.itemText(i)) == newname]
combo.setCurrentIndex(idx[0])
self.setInstrument(newname)
def _ask_overwrite(self):
msg = QDialog()
msg.setWindowTitle('Load overwrite')
layout = QGridLayout()
layout.addWidget(QLabel('Instrument %s already exists in memory. Overwrite this?'), 0, 0, 1, -1)
buttons = [QPushButton(label) for label in ['Load and overwrite', 'Cancel Load', 'Load and rename to']]
locations = [[1, 0], [1, 1], [2, 0]]
self.overwrite_flag = 1
def overwriteCB(idx):
self.overwrite_flag = idx
msg.accept()
for idx, button in enumerate(buttons):
button.clicked.connect(lambda _, idx=idx: overwriteCB(idx))
layout.addWidget(button, locations[idx][0], locations[idx][1])
newname = QLineEdit()
newname.editingFinished.connect(lambda: overwriteCB(2))
layout.addWidget(newname, 2, 1)
msg.setLayout(layout)
msg.exec_()
newname = str(newname.text())
if not newname or newname in self.instruments:
self.errormessage('Invalid instrument name. Cancelling load.')
self.overwrite_flag = 1
return self.overwrite_flag, newname
def updateInstrumentList(self):
combo = self.widgets['InstrumentCombo']['Combo']
old_instruments = [str(combo.itemText(i)) for i in range(combo.count())]
new_instruments = [inst for inst in self.instruments if inst not in old_instruments]
for inst in new_instruments:
combo.addItem(inst)
def plot_frame(self):
"""
Plots the distance-time diagram in the right tab
"""
if len(self.engine.chopper_system.choppers) > 1:
self.engine.n_frame = int(self.repfig_nframe_edit.text())
self.repaxes.clear()
self.engine.plotMultiRepFrame(self.repaxes, first_rep=self.repfig_nframe_rep1only.isChecked())
self.repcanvas.draw()
def _gen_text_ei(self, ei, obj_in):
obj = Instrument(obj_in)
obj.setEi(ei)
en = np.linspace(0, 0.95*ei, 10)
try:
flux = self.engine.getFlux()
res = self.engine.getResolution(en)
except ValueError as err:
self.errormessage(err)
raise ValueError(err)
tsqvan, tsqdic, tsqmodchop = obj.getVanVar()
v_mod, v_chop = tuple(np.sqrt(tsqmodchop[:2]) * 1e6)
x0, _, x1, x2, _ = obj.chopper_system.getDistances()
first_component = 'moderator'
if x0 != tsqmodchop[2]:
x0 = tsqmodchop[2]
first_component = 'chopper 1'
txt = '# ------------------------------------------------------------- #\n'
txt += '# Ei = %8.2f meV\n' % (ei)
txt += '# Flux = %8.2f n/cm2/s\n' % (flux)
txt += '# Elastic resolution = %6.2f meV\n' % (res[0])
txt += '# Time width at sample = %6.2f us, of which:\n' % (1e6*np.sqrt(tsqvan))
for ky, val in list(tsqdic.items()):
txt += '# %20s : %6.2f us\n' % (ky, 1e6*np.sqrt(val))
txt += '# %s distances:\n' % (obj.instname)
txt += '# x0 = %6.2f m (%s to Fermi)\n' % (x0, first_component)
txt += '# x1 = %6.2f m (Fermi to sample)\n' % (x1)
txt += '# x2 = %6.2f m (sample to detector)\n' % (x2)
txt += '# Approximate inelastic resolution is given by:\n'
txt += '# dE = 2 * E2V * sqrt(ef**3 * t_van**2) / x2\n'
txt += '# where: E2V = 4.373e-4 meV/(m/us) conversion from energy to speed\n'
txt += '# t_van**2 = (geom*t_mod)**2 + ((1+geom)*t_chop)**2\n'
txt += '# geom = (x1 + x2*(ei/ef)**1.5) / x0\n'
txt += '# and t_mod and t_chop are the moderator and chopper time widths at the\n'
txt += '# moderator and chopper positions (not at the sample as listed above).\n'
txt += '# Which in this case is:\n'
txt += '# %.4e*sqrt(ef**3 * ( (%6.5f*(%.3f+%.3f*(ei/ef)**1.5))**2 \n' % (874.78672e-6/x2, v_mod, x1/x0, x2/x0)
txt += '# + (%6.5f*(%.3f+%.3f*(ei/ef)**1.5))**2) )\n' % (v_chop, 1+x1/x0, x2/x0)
txt += '# EN (meV) Full dE (meV) Approx dE (meV)\n'
for ii in range(len(res)):
ef = ei-en[ii]
approx = (874.78672e-6/x2)*np.sqrt(ef**3 * ((v_mod*((x1/x0)+(x2/x0)*(ei/ef)**1.5))**2
+ (v_chop*(1+(x1/x0)+(x2/x0)*(ei/ef)**1.5))**2))
txt += '%12.5f %12.5f %12.5f\n' % (en[ii], res[ii], approx)
return txt
def genText(self):
"""
Generates text output of the resolution function versus energy transfer and other information.
"""
multiplot = self.widgets['MultiRepCheck'].isChecked()
obj = self.engine
if obj.getChopper() is None:
self.setChopper(self.widgets['ChopperCombo']['Combo'].currentText())
if obj.getEi() is None:
self.setEi()
instname, chtyp, freqs, ei_in = tuple([obj.instname, obj.getChopper(), obj.getFrequency(), obj.getEi()])
txt = '# ------------------------------------------------------------- #\n'
txt += '# Chop calculation for instrument %s\n' % (instname)
if obj.isFermi:
txt += '# with chopper %s at %3i Hz\n' % (chtyp, freqs[0])
else:
txt += '# in %s mode with:\n' % (chtyp)
freq_names = obj.chopper_system.frequency_names
for idx in range(len(freq_names)):
txt += '# %s at %3i Hz\n' % (freq_names[idx], freqs[idx])
txt += self._gen_text_ei(ei_in, obj)
if multiplot:
for ei in sorted(self.engine.getAllowedEi()):
if np.abs(ei - ei_in) > 0.001:
txt += self._gen_text_ei(ei, obj)
return txt
def showText(self):
"""
Creates a dialog to show the generated text output.
"""
try:
generatedText = self.genText()
except ValueError:
return
self.txtwin = QDialog()
self.txtedt = QTextEdit()
self.txtbtn = QPushButton('OK')
self.txtwin.layout = QVBoxLayout(self.txtwin)
self.txtwin.layout.addWidget(self.txtedt)
self.txtwin.layout.addWidget(self.txtbtn)
self.txtbtn.clicked.connect(self.txtwin.deleteLater)
self.txtedt.setText(generatedText)
self.txtedt.setReadOnly(True)
self.txtwin.setWindowTitle('Resolution information')
self.txtwin.setWindowModality(Qt.ApplicationModal)
self.txtwin.setAttribute(Qt.WA_DeleteOnClose)
self.txtwin.setMinimumSize(400, 600)
self.txtwin.resize(400, 600)
self.txtwin.show()
self.txtloop = QEventLoop()
self.txtloop.exec_()
def saveText(self):
"""
Saves the generated text to a file (opens file dialog).
"""
fname = QFileDialog.getSaveFileName(self, 'Open file', '')
if isinstance(fname, tuple):
fname = fname[0]
fid = open(fname, 'w')
fid.write(self.genText())
fid.close()
def update_script(self):
"""
Updates the text window with information about the previous calculation.
"""
if self.widgets['MultiRepCheck'].isChecked():
out = self.engine.getMultiWidths()
new_str = '\n'
for ie, ee in enumerate(out['Eis']):
res = out['Energy'][ie]
percent = res / ee * 100
chop_width = out['chopper'][ie]
mod_width = out['moderator'][ie]
new_str += 'Ei is %6.2f meV, resolution is %6.2f ueV, percentage resolution is %6.3f\n' % (ee, res * 1000, percent)
new_str += 'FWHM at sample from chopper and moderator are %6.2f us, %6.2f us\n' % (chop_width, mod_width)
else:
ei = self.engine.getEi()
out = self.engine.getWidths()
res = out['Energy']
percent = res / ei * 100
chop_width = out['chopper']
mod_width = out['moderator']
new_str = '\nEi is %6.2f meV, resolution is %6.2f ueV, percentage resolution is %6.3f\n' % (ei, res * 1000, percent)
new_str += 'FWHM at sample from chopper and moderator are %6.2f us, %6.2f us\n' % (chop_width, mod_width)
self.scredt.append(new_str)
def onHelp(self):
"""
Shows the help page
"""
try:
from pymantidplot.proxies import showCustomInterfaceHelp
showCustomInterfaceHelp("PyChop")
except ImportError:
helpTxt = "PyChop is a tool to allow direct inelastic neutron\nscattering users to estimate the inelastic resolution\n"
helpTxt += "and incident flux for a given spectrometer setting.\n\nFirst select the instrument, chopper settings and\n"
helpTxt += "Ei, and then click 'Calculate and Plot'. Data for all\nthe graphs will be generated (may take 1-2s) and\n"
helpTxt += "all graphs will be updated. If the 'Hold current plot'\ncheck box is ticked, additional settings will be\n"
helpTxt += "overplotted on the existing graphs if they are\ndifferent from previous settings.\n\nMore in-depth help "
helpTxt += "can be obtained from the\nMantid help pages."
self.hlpwin = QDialog()
self.hlpedt = QLabel(helpTxt)
self.hlpbtn = QPushButton('OK')
self.hlpwin.layout = QVBoxLayout(self.hlpwin)
self.hlpwin.layout.addWidget(self.hlpedt)
self.hlpwin.layout.addWidget(self.hlpbtn)
self.hlpbtn.clicked.connect(self.hlpwin.deleteLater)
self.hlpwin.setWindowTitle('Help')
self.hlpwin.setWindowModality(Qt.ApplicationModal)
self.hlpwin.setAttribute(Qt.WA_DeleteOnClose)
self.hlpwin.setMinimumSize(370, 300)
self.hlpwin.resize(370, 300)
self.hlpwin.show()
self.hlploop = QEventLoop()
self.hlploop.exec_()
def drawLayout(self):
"""
Draws the GUI layout.
"""
self.widgetslist = [
['pair', 'show', 'Instrument', 'combo', self.instruments, self.setInstrument, 'InstrumentCombo'],
['pair', 'show', 'Chopper', 'combo', '', self.setChopper, 'ChopperCombo'],
['pair', 'show', 'Frequency', 'combo', '', self.setFreq, 'FrequencyCombo'],
['pair', 'hide', 'Pulse remover chopper freq', 'combo', '', self.setFreq, 'PulseRemoverCombo'],
['pair', 'show', 'Ei', 'edit', '', self.setEi, 'EiEdit'],
['pair', 'hide', 'Chopper 2 phase delay time', 'edit', '5', self.setFreq, 'Chopper2Phase'],
['spacer'],
['single', 'show', 'Calculate and Plot', 'button', self.calc_callback, 'CalculateButton'],
['single', 'show', 'Hold current plot', 'check', lambda: None, 'HoldCheck'],
['single', 'show', 'Show multi-reps', 'check', lambda: None, 'MultiRepCheck'],
['spacer'],
['single', 'show', 'Show data ascii window', 'button', self.showText, 'ShowAsciiButton'],
['single', 'show', 'Save data as ascii', 'button', self.saveText, 'SaveAsciiButton']
]
self.droplabels = []
self.dropboxes = []
self.singles = []
self.widgets = {}
self.leftPanel = QVBoxLayout()
self.rightPanel = QVBoxLayout()
self.tabs = QTabWidget(self)
self.fullWindow = QGridLayout()
for widget in self.widgetslist:
if 'pair' in widget[0]:
self.droplabels.append(QLabel(widget[2]))
if 'combo' in widget[3]:
self.dropboxes.append(QComboBox(self))
self.dropboxes[-1].activated['QString'].connect(widget[5])
for item in widget[4]:
self.dropboxes[-1].addItem(item)
self.widgets[widget[-1]] = {'Combo':self.dropboxes[-1], 'Label':self.droplabels[-1]}
elif 'edit' in widget[3]:
self.dropboxes.append(QLineEdit(self))
self.dropboxes[-1].returnPressed.connect(widget[5])
self.widgets[widget[-1]] = {'Edit':self.dropboxes[-1], 'Label':self.droplabels[-1]}
else:
raise RuntimeError('Bug in code - widget %s is not recognised.' % (widget[3]))
self.leftPanel.addWidget(self.droplabels[-1])
self.leftPanel.addWidget(self.dropboxes[-1])
if 'hide' in widget[1]:
self.droplabels[-1].hide()
self.dropboxes[-1].hide()
elif 'single' in widget[0]:
if 'check' in widget[3]:
self.singles.append(QCheckBox(widget[2], self))
self.singles[-1].stateChanged.connect(widget[4])
elif 'button' in widget[3]:
self.singles.append(QPushButton(widget[2]))
self.singles[-1].clicked.connect(widget[4])
else:
raise RuntimeError('Bug in code - widget %s is not recognised.' % (widget[3]))
self.leftPanel.addWidget(self.singles[-1])
if 'hide' in widget[1]:
self.singles[-1].hide()
self.widgets[widget[-1]] = self.singles[-1]
elif 'spacer' in widget[0]:
self.leftPanel.addItem(QSpacerItem(0, 35))
else:
raise RuntimeError('Bug in code - widget class %s is not recognised.' % (widget[0]))
# Right panel, matplotlib figures
self.resfig = Figure()
self.resfig.patch.set_facecolor('white')
self.rescanvas = FigureCanvas(self.resfig)
self.resaxes = self.resfig.add_subplot(111)
self.resaxes.axhline(color='k')
self.resaxes.set_xlabel('Energy Transfer (meV)')
self.resaxes.set_ylabel(r'$\Delta$E (meV FWHM)')
self.resfig_controls = NavigationToolbar(self.rescanvas, self)
self.restab = QWidget(self.tabs)
self.restabbox = QVBoxLayout()
self.restabbox.addWidget(self.rescanvas)
self.restabbox.addWidget(self.resfig_controls)
self.restab.setLayout(self.restabbox)
self.flxfig = Figure()
self.flxfig.patch.set_facecolor('white')
self.flxcanvas = FigureCanvas(self.flxfig)
self.flxaxes1 = self.flxfig.add_subplot(121)
self.flxaxes1.set_xlabel('Incident Energy (meV)')
self.flxaxes1.set_ylabel('Flux (n/cm$^2$/s)')
self.flxaxes2 = self.flxfig.add_subplot(122)
self.flxaxes2.set_xlabel('Incident Energy (meV)')
self.flxaxes2.set_ylabel('Elastic Resolution FWHM (meV)')
self.flxfig_controls = NavigationToolbar(self.flxcanvas, self)
self.flxsldfg = Figure()
self.flxsldfg.patch.set_facecolor('white')
self.flxsldcv = FigureCanvas(self.flxsldfg)
self.flxsldax = self.flxsldfg.add_subplot(111)
self.flxslder = Slider(self.flxsldax, 'Ei (meV)', 0, 100, valinit=100)
self.flxslder.valtext.set_visible(False)
self.flxslder.on_changed(self.update_slider)
self.flxedt = QLineEdit()
self.flxedt.setText('1000')
self.flxedt.returnPressed.connect(self.update_slider)
self.flxtab = QWidget(self.tabs)
self.flxsldbox = QHBoxLayout()
self.flxsldbox.addWidget(self.flxsldcv)
self.flxsldbox.addWidget(self.flxedt)
self.flxsldwdg = QWidget()
self.flxsldwdg.setLayout(self.flxsldbox)
sz = self.flxsldwdg.maximumSize()
sz.setHeight(50)
self.flxsldwdg.setMaximumSize(sz)
self.flxtabbox = QVBoxLayout()
self.flxtabbox.addWidget(self.flxcanvas)
self.flxtabbox.addWidget(self.flxsldwdg)
self.flxtabbox.addWidget(self.flxfig_controls)
self.flxtab.setLayout(self.flxtabbox)
self.frqfig = Figure()
self.frqfig.patch.set_facecolor('white')
self.frqcanvas = FigureCanvas(self.frqfig)
self.frqaxes1 = self.frqfig.add_subplot(121)
self.frqaxes1.set_xlabel('Chopper Frequency (Hz)')
self.frqaxes1.set_ylabel('Flux (n/cm$^2$/s)')
self.frqaxes2 = self.frqfig.add_subplot(122)
self.frqaxes1.set_xlabel('Chopper Frequency (Hz)')
self.frqaxes2.set_ylabel('Elastic Resolution FWHM (meV)')
self.frqfig_controls = NavigationToolbar(self.frqcanvas, self)
self.frqtab = QWidget(self.tabs)
self.frqtabbox = QVBoxLayout()
self.frqtabbox.addWidget(self.frqcanvas)
self.frqtabbox.addWidget(self.frqfig_controls)
self.frqtab.setLayout(self.frqtabbox)
self.repfig = Figure()
self.repfig.patch.set_facecolor('white')
self.repcanvas = FigureCanvas(self.repfig)
self.repaxes = self.repfig.add_subplot(111)
self.repaxes.axhline(color='k')
self.repaxes.set_xlabel(r'TOF ($\mu$sec)')
self.repaxes.set_ylabel('Distance (m)')
self.repfig_controls = NavigationToolbar(self.repcanvas, self)
self.repfig_nframe_label = QLabel('Number of frames to plot')
self.repfig_nframe_edit = QLineEdit('1')
self.repfig_nframe_button = QPushButton('Replot')
self.repfig_nframe_button.clicked.connect(lambda: self.plot_frame())
self.repfig_nframe_rep1only = QCheckBox('First Rep Only')
self.repfig_nframe_box = QHBoxLayout()
self.repfig_nframe_box.addWidget(self.repfig_nframe_label)
self.repfig_nframe_box.addWidget(self.repfig_nframe_edit)
self.repfig_nframe_box.addWidget(self.repfig_nframe_button)
self.repfig_nframe_box.addWidget(self.repfig_nframe_rep1only)
self.reptab = QWidget(self.tabs)
self.repfig_nframe = QWidget(self.reptab)
self.repfig_nframe.setLayout(self.repfig_nframe_box)
self.repfig_nframe.setSizePolicy(QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed))
self.reptabbox = QVBoxLayout()
self.reptabbox.addWidget(self.repcanvas)
self.reptabbox.addWidget(self.repfig_nframe)
self.reptabbox.addWidget(self.repfig_controls)
self.reptab.setLayout(self.reptabbox)
self.qefig = Figure()
self.qefig.patch.set_facecolor('white')
self.qecanvas = FigureCanvas(self.qefig)
self.qeaxes = self.qefig.add_subplot(111)
self.qeaxes.axhline(color='k')
self.qeaxes.set_xlabel(r'$|Q| (\mathrm{\AA}^{-1})$')
self.qeaxes.set_ylabel('Energy Transfer (meV)')
self.qefig_controls = NavigationToolbar(self.qecanvas, self)
self.qetabbox = QVBoxLayout()
self.qetabbox.addWidget(self.qecanvas)
self.qetabbox.addWidget(self.qefig_controls)
self.qetab = QWidget(self.tabs)
self.qetab.setLayout(self.qetabbox)
self.scrtab = QWidget(self.tabs)
self.scredt = QTextEdit()
self.scrcls = QPushButton("Clear")
self.scrcls.clicked.connect(lambda: self.scredt.clear())
self.scrbox = QVBoxLayout()
self.scrbox.addWidget(self.scredt)
self.scrbox.addWidget(self.scrcls)
self.scrtab.setLayout(self.scrbox)
self.scrtab.hide()
self.tabs.addTab(self.restab, 'Resolution')
self.tabs.addTab(self.flxtab, 'Flux-Ei')
self.tabs.addTab(self.frqtab, 'Flux-Freq')
self.tabs.addTab(self.reptab, 'Time-Distance')
self.tdtabID = 3
self.tabs.setTabEnabled(self.tdtabID, False)
self.tabs.addTab(self.qetab, 'Q-E')
self.qetabID = 4
self.tabs.setTabEnabled(self.qetabID, False)
self.scrtabID = 5
self.rightPanel.addWidget(self.tabs)
self.menuLoad = QMenu('Load')
self.loadAct = QAction('Load YAML', self.menuLoad)
self.loadAct.triggered.connect(self.loadYaml)
self.menuLoad.addAction(self.loadAct)
self.menuOptions = QMenu('Options')
self.instSciAct = QAction('Instrument Scientist Mode', self.menuOptions, checkable=True)
self.instSciAct.triggered.connect(self.instSciCB)
self.menuOptions.addAction(self.instSciAct)
self.eiPlots = QAction('Press Enter in Ei box updates plots', self.menuOptions, checkable=True)
self.menuOptions.addAction(self.eiPlots)
self.overwriteload = QAction('Always overwrite instruments in memory', self.menuOptions, checkable=True)
self.menuOptions.addAction(self.overwriteload)
self.menuBar().addMenu(self.menuLoad)
self.menuBar().addMenu(self.menuOptions)
self.leftPanelWidget = QWidget()
self.leftPanelWidget.setLayout(self.leftPanel)
self.leftPanelWidget.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Preferred))
self.fullWindow.addWidget(self.leftPanelWidget, 0, 0)
self.fullWindow.addLayout(self.rightPanel, 0, 1)
self.helpbtn = QPushButton("?", self)
self.helpbtn.setMaximumWidth(30)
self.helpbtn.clicked.connect(self.onHelp)
self.fullWindow.addWidget(self.helpbtn, 1, 0, 1, -1)
self.mainWidget = QWidget()
self.mainWidget.setLayout(self.fullWindow)
self.setCentralWidget(self.mainWidget)
self.setWindowTitle('PyChopGUI')
self.show()
def setup_page(self):
newcb = self.create_checkbox
# --- Introspection ---
# Basic features group
basic_features_group = QGroupBox(_("Basic features"))
completion_box = newcb(_("Enable code completion"), 'code_completion')
goto_definition_box = newcb(
_("Enable Go to definition"),
'jedi_definition',
tip=_("If this option is enabled, left-clicking on\n"
"an object name while pressing the {} key will go to\n"
"that object's definition (if resolved).".format(self.CTRL)))
follow_imports_box = newcb(_("Follow imports when going to a "
"definition"),
'jedi_definition/follow_imports')
show_signature_box = newcb(_("Show calltips"), 'jedi_signature_help')
basic_features_layout = QVBoxLayout()
basic_features_layout.addWidget(completion_box)
basic_features_layout.addWidget(goto_definition_box)
basic_features_layout.addWidget(follow_imports_box)
basic_features_layout.addWidget(show_signature_box)
basic_features_group.setLayout(basic_features_layout)
# Advanced group
advanced_group = QGroupBox(_("Advanced"))
modules_textedit = self.create_textedit(
_("Preload the following modules to make completion faster "
"and more accurate:"),
'preload_modules'
)
if is_dark_interface():
modules_textedit.textbox.setStyleSheet(
"border: 1px solid #32414B;"
)
advanced_layout = QVBoxLayout()
advanced_layout.addWidget(modules_textedit)
advanced_group.setLayout(advanced_layout)
# --- Linting ---
# Linting options
linting_label = QLabel(_("Spyder can optionally highlight syntax "
"errors and possible problems with your "
"code in the editor."))
linting_label.setOpenExternalLinks(True)
linting_label.setWordWrap(True)
linting_check = self.create_checkbox(
_("Enable basic linting"),
'pyflakes')
linting_complexity_box = self.create_checkbox(
_("Enable complexity linting with "
"the Mccabe package"), 'mccabe')
# Linting layout
linting_layout = QVBoxLayout()
linting_layout.addWidget(linting_label)
linting_layout.addWidget(linting_check)
linting_layout.addWidget(linting_complexity_box)
linting_widget = QWidget()
linting_widget.setLayout(linting_layout)
# --- Code style tab ---
# Code style label
pep_url = (
'<a href="https://www.python.org/dev/peps/pep-0008">PEP 8</a>')
code_style_codes_url = _(
"<a href='http://pycodestyle.pycqa.org/en/stable"
"/intro.html#error-codes'>pycodestyle error codes</a>")
code_style_label = QLabel(
_("Spyder can use pycodestyle to analyze your code for "
"conformance to the {} convention. You can also "
"manually show or hide specific warnings by their "
"{}.").format(pep_url, code_style_codes_url))
code_style_label.setOpenExternalLinks(True)
code_style_label.setWordWrap(True)
# Code style checkbox
code_style_check = self.create_checkbox(
_("Enable code style linting"),
'pycodestyle')
# Code style options
self.code_style_filenames_match = self.create_lineedit(
_("Only check filenames matching these patterns:"),
'pycodestyle/filename', alignment=Qt.Horizontal, word_wrap=False,
placeholder=_("Check Python files: *.py"))
self.code_style_exclude = self.create_lineedit(
_("Exclude files or directories matching these patterns:"),
'pycodestyle/exclude', alignment=Qt.Horizontal, word_wrap=False,
placeholder=_("Exclude all test files: (?!test_).*\\.py"))
code_style_select = self.create_lineedit(
_("Show the following errors or warnings:").format(
code_style_codes_url),
'pycodestyle/select', alignment=Qt.Horizontal, word_wrap=False,
placeholder=_("Example codes: E113, W391"))
code_style_ignore = self.create_lineedit(
_("Ignore the following errors or warnings:"),
'pycodestyle/ignore', alignment=Qt.Horizontal, word_wrap=False,
placeholder=_("Example codes: E201, E303"))
code_style_max_line_length = self.create_spinbox(
_("Maximum allowed line length:"), None,
'pycodestyle/max_line_length', min_=10, max_=500, step=1,
tip=_("Default is 79"))
# Code style layout
code_style_g_layout = QGridLayout()
code_style_g_layout.addWidget(
self.code_style_filenames_match.label, 1, 0)
code_style_g_layout.addWidget(
self.code_style_filenames_match.textbox, 1, 1)
code_style_g_layout.addWidget(self.code_style_exclude.label, 2, 0)
code_style_g_layout.addWidget(self.code_style_exclude.textbox, 2, 1)
code_style_g_layout.addWidget(code_style_select.label, 3, 0)
code_style_g_layout.addWidget(code_style_select.textbox, 3, 1)
code_style_g_layout.addWidget(code_style_ignore.label, 4, 0)
code_style_g_layout.addWidget(code_style_ignore.textbox, 4, 1)
code_style_g_layout.addWidget(code_style_max_line_length.plabel, 5, 0)
code_style_g_layout.addWidget(
code_style_max_line_length.spinbox, 5, 1)
# Set Code style options enabled/disabled
code_style_g_widget = QWidget()
code_style_g_widget.setLayout(code_style_g_layout)
code_style_g_widget.setEnabled(self.get_option('pycodestyle'))
code_style_check.toggled.connect(code_style_g_widget.setEnabled)
# Code style layout
code_style_layout = QVBoxLayout()
code_style_layout.addWidget(code_style_label)
code_style_layout.addWidget(code_style_check)
code_style_layout.addWidget(code_style_g_widget)
code_style_widget = QWidget()
code_style_widget.setLayout(code_style_layout)
# --- Docstring tab ---
# Docstring style label
numpy_url = (
"<a href='https://numpydoc.readthedocs.io/en/"
"latest/format.html'>Numpy</a>")
pep257_url = (
"<a href='https://www.python.org/dev/peps/pep-0257/'>PEP 257</a>")
docstring_style_codes = _(
"<a href='http://www.pydocstyle.org/en/stable"
"/error_codes.html'>page</a>")
docstring_style_label = QLabel(
_("Here you can decide if you want to perform style analysis on "
"your docstrings according to the {} or {} conventions. You can "
"also decide if you want to show or ignore specific errors, "
"according to the codes found on this {}.").format(
numpy_url, pep257_url, docstring_style_codes))
docstring_style_label.setOpenExternalLinks(True)
docstring_style_label.setWordWrap(True)
# Docstring style checkbox
docstring_style_check = self.create_checkbox(
_("Enable docstring style linting"),
'pydocstyle')
# Docstring style options
docstring_style_convention = self.create_combobox(
_("Choose the convention used to lint docstrings: "),
(("Numpy", 'numpy'),
("PEP 257", 'pep257'),
("Custom", 'custom')),
'pydocstyle/convention')
self.docstring_style_select = self.create_lineedit(
_("Show the following errors:"),
'pydocstyle/select', alignment=Qt.Horizontal, word_wrap=False,
placeholder=_("Example codes: D413, D414"))
self.docstring_style_ignore = self.create_lineedit(
_("Ignore the following errors:"),
'pydocstyle/ignore', alignment=Qt.Horizontal, word_wrap=False,
placeholder=_("Example codes: D107, D402"))
self.docstring_style_match = self.create_lineedit(
_("Only check filenames matching these patterns:"),
'pydocstyle/match', alignment=Qt.Horizontal, word_wrap=False,
placeholder=_("Skip test files: (?!test_).*\\.py"))
self.docstring_style_match_dir = self.create_lineedit(
_("Only check in directories matching these patterns:"),
'pydocstyle/match_dir', alignment=Qt.Horizontal, word_wrap=False,
placeholder=_("Skip dot directories: [^\\.].*"))
# Custom option handling
docstring_style_convention.combobox.currentTextChanged.connect(
self.setup_docstring_style_convention)
current_convention = docstring_style_convention.combobox.currentText()
self.setup_docstring_style_convention(current_convention)
# Docstring style layout
docstring_style_g_layout = QGridLayout()
docstring_style_g_layout.addWidget(
docstring_style_convention.label, 1, 0)
docstring_style_g_layout.addWidget(
docstring_style_convention.combobox, 1, 1)
docstring_style_g_layout.addWidget(
self.docstring_style_select.label, 2, 0)
docstring_style_g_layout.addWidget(
self.docstring_style_select.textbox, 2, 1)
docstring_style_g_layout.addWidget(
self.docstring_style_ignore.label, 3, 0)
docstring_style_g_layout.addWidget(
self.docstring_style_ignore.textbox, 3, 1)
docstring_style_g_layout.addWidget(
self.docstring_style_match.label, 4, 0)
docstring_style_g_layout.addWidget(
self.docstring_style_match.textbox, 4, 1)
docstring_style_g_layout.addWidget(
self.docstring_style_match_dir.label, 5, 0)
docstring_style_g_layout.addWidget(
self.docstring_style_match_dir.textbox, 5, 1)
# Set Docstring style options enabled/disabled
docstring_style_g_widget = QWidget()
docstring_style_g_widget.setLayout(docstring_style_g_layout)
docstring_style_g_widget.setEnabled(self.get_option('pydocstyle'))
docstring_style_check.toggled.connect(
docstring_style_g_widget.setEnabled)
# Docstring style layout
docstring_style_layout = QVBoxLayout()
docstring_style_layout.addWidget(docstring_style_label)
docstring_style_layout.addWidget(docstring_style_check)
docstring_style_layout.addWidget(docstring_style_g_widget)
docstring_style_widget = QWidget()
docstring_style_widget.setLayout(docstring_style_layout)
# --- Advanced tab ---
# Advanced label
advanced_label = QLabel(
_("Please don't modify these values unless "
"you know what you're doing!"))
advanced_label.setWordWrap(True)
advanced_label.setAlignment(Qt.AlignJustify)
# Advanced options
advanced_command_launch = self.create_lineedit(
_("Command to launch the Python language server: "),
'advanced/command_launch', alignment=Qt.Horizontal,
word_wrap=False)
advanced_host = self.create_lineedit(
_("IP Address and port to bind the server to: "),
'advanced/host', alignment=Qt.Horizontal,
word_wrap=False)
advanced_port = self.create_spinbox(
":", "", 'advanced/port', min_=1, max_=65535, step=1)
# Advanced layout
advanced_g_layout = QGridLayout()
advanced_g_layout.addWidget(advanced_command_launch.label, 1, 0)
advanced_g_layout.addWidget(advanced_command_launch.textbox, 1, 1)
advanced_g_layout.addWidget(advanced_host.label, 2, 0)
advanced_host_port_g_layout = QGridLayout()
advanced_host_port_g_layout.addWidget(advanced_host.textbox, 1, 0)
advanced_host_port_g_layout.addWidget(advanced_port.plabel, 1, 1)
advanced_host_port_g_layout.addWidget(advanced_port.spinbox, 1, 2)
advanced_g_layout.addLayout(advanced_host_port_g_layout, 2, 1)
advanced_widget = QWidget()
advanced_layout = QVBoxLayout()
advanced_layout.addWidget(advanced_label)
advanced_layout.addLayout(advanced_g_layout)
advanced_widget.setLayout(advanced_layout)
# --- Other servers tab ---
# Section label
servers_label = QLabel(
_("Spyder uses the <a href=\"{lsp_url}\">Language Server "
"Protocol</a> to provide code completion and linting "
"for its Editor. Here, you can setup and configure LSP servers "
"for languages other than Python, so Spyder can provide such "
"features for those languages as well."
).format(lsp_url=LSP_URL))
servers_label.setOpenExternalLinks(True)
servers_label.setWordWrap(True)
servers_label.setAlignment(Qt.AlignJustify)
# Servers table
table_group = QGroupBox(_('Available servers:'))
self.table = LSPServerTable(self, text_color=ima.MAIN_FG_COLOR)
table_layout = QVBoxLayout()
table_layout.addWidget(self.table)
table_group.setLayout(table_layout)
# Buttons
self.reset_btn = QPushButton(_("Reset to default values"))
self.new_btn = QPushButton(_("Set up a new server"))
self.delete_btn = QPushButton(_("Delete currently selected server"))
self.delete_btn.setEnabled(False)
# Slots connected to buttons
self.new_btn.clicked.connect(self.create_new_server)
self.reset_btn.clicked.connect(self.reset_to_default)
self.delete_btn.clicked.connect(self.delete_server)
# Buttons layout
btns = [self.new_btn, self.delete_btn, self.reset_btn]
buttons_layout = QGridLayout()
for i, btn in enumerate(btns):
buttons_layout.addWidget(btn, i, 1)
buttons_layout.setColumnStretch(0, 1)
buttons_layout.setColumnStretch(1, 2)
buttons_layout.setColumnStretch(2, 1)
# Combined layout
servers_widget = QWidget()
servers_layout = QVBoxLayout()
servers_layout.addSpacing(-10)
servers_layout.addWidget(servers_label)
servers_layout.addWidget(table_group)
servers_layout.addSpacing(10)
servers_layout.addLayout(buttons_layout)
servers_widget.setLayout(servers_layout)
# --- Tabs organization ---
tabs = QTabWidget()
tabs.addTab(self.create_tab(basic_features_group, advanced_group),
_('Introspection'))
tabs.addTab(self.create_tab(linting_widget), _('Linting'))
tabs.addTab(self.create_tab(code_style_widget), _('Code style'))
tabs.addTab(self.create_tab(docstring_style_widget),
_('Docstring style'))
tabs.addTab(self.create_tab(advanced_widget),
_('Advanced'))
tabs.addTab(self.create_tab(servers_widget), _('Other languages'))
vlayout = QVBoxLayout()
vlayout.addWidget(tabs)
self.setLayout(vlayout)
def setup_page(self):
newcb = self.create_checkbox
# Interface Group
interface_group = QGroupBox(_("Interface"))
banner_box = newcb(_("Display initial banner"), 'show_banner',
tip=_("This option lets you hide the message "
"shown at\nthe top of the console when "
"it's opened."))
pager_box = newcb(_("Use a pager to display additional text inside "
"the console"), 'use_pager',
tip=_("Useful if you don't want to fill the "
"console with long help or completion "
"texts.\n"
"Note: Use the Q key to get out of the "
"pager."))
calltips_box = newcb(_("Show calltips"), 'show_calltips')
ask_box = newcb(_("Ask for confirmation before closing"),
'ask_before_closing')
reset_namespace_box = newcb(
_("Ask for confirmation before removing all user-defined "
"variables"),
'show_reset_namespace_warning',
tip=_("This option lets you hide the warning message shown\n"
"when resetting the namespace from Spyder."))
show_time_box = newcb(_("Show elapsed time"), 'show_elapsed_time')
ask_restart_box = newcb(
_("Ask for confirmation before restarting"),
'ask_before_restart',
tip=_("This option lets you hide the warning message shown\n"
"when restarting the kernel."))
interface_layout = QVBoxLayout()
interface_layout.addWidget(banner_box)
interface_layout.addWidget(pager_box)
interface_layout.addWidget(calltips_box)
interface_layout.addWidget(ask_box)
interface_layout.addWidget(reset_namespace_box)
interface_layout.addWidget(show_time_box)
interface_layout.addWidget(ask_restart_box)
interface_group.setLayout(interface_layout)
comp_group = QGroupBox(_("Completion Type"))
comp_label = QLabel(_("Decide what type of completion to use"))
comp_label.setWordWrap(True)
completers = [(_("Graphical"), 0), (_("Terminal"), 1), (_("Plain"), 2)]
comp_box = self.create_combobox(_("Completion:")+" ", completers,
'completion_type')
comp_layout = QVBoxLayout()
comp_layout.addWidget(comp_label)
comp_layout.addWidget(comp_box)
comp_group.setLayout(comp_layout)
# Source Code Group
source_code_group = QGroupBox(_("Source code"))
buffer_spin = self.create_spinbox(
_("Buffer: "), _(" lines"),
'buffer_size', min_=-1, max_=1000000, step=100,
tip=_("Set the maximum number of lines of text shown in the\n"
"console before truncation. Specifying -1 disables it\n"
"(not recommended!)"))
source_code_layout = QVBoxLayout()
source_code_layout.addWidget(buffer_spin)
source_code_group.setLayout(source_code_layout)
# --- Graphics ---
# Pylab Group
pylab_group = QGroupBox(_("Support for graphics (Matplotlib)"))
pylab_box = newcb(_("Activate support"), 'pylab')
autoload_pylab_box = newcb(
_("Automatically load Pylab and NumPy modules"),
'pylab/autoload',
tip=_("This lets you load graphics support without importing\n"
"the commands to do plots. Useful to work with other\n"
"plotting libraries different to Matplotlib or to develop\n"
"GUIs with Spyder."))
autoload_pylab_box.setEnabled(self.get_option('pylab'))
pylab_box.toggled.connect(autoload_pylab_box.setEnabled)
pylab_layout = QVBoxLayout()
pylab_layout.addWidget(pylab_box)
pylab_layout.addWidget(autoload_pylab_box)
pylab_group.setLayout(pylab_layout)
# Pylab backend Group
inline = _("Inline")
automatic = _("Automatic")
backend_group = QGroupBox(_("Graphics backend"))
bend_label = QLabel(_("Decide how graphics are going to be displayed "
"in the console. If unsure, please select "
"<b>%s</b> to put graphics inside the "
"console or <b>%s</b> to interact with "
"them (through zooming and panning) in a "
"separate window.") % (inline, automatic))
bend_label.setWordWrap(True)
backends = [(inline, 0), (automatic, 1), ("Qt5", 2), ("Qt4", 3)]
if sys.platform == 'darwin':
backends.append(("OS X", 4))
if sys.platform.startswith('linux'):
backends.append(("Gtk3", 5))
backends.append(("Gtk", 6))
if PY2:
backends.append(("Wx", 7))
backends.append(("Tkinter", 8))
backends = tuple(backends)
backend_box = self.create_combobox(
_("Backend:") + " ",
backends,
'pylab/backend', default=0,
tip=_("This option will be applied the next time a console is "
"opened."))
backend_layout = QVBoxLayout()
backend_layout.addWidget(bend_label)
backend_layout.addWidget(backend_box)
backend_group.setLayout(backend_layout)
backend_group.setEnabled(self.get_option('pylab'))
pylab_box.toggled.connect(backend_group.setEnabled)
# Inline backend Group
inline_group = QGroupBox(_("Inline backend"))
inline_label = QLabel(_("Decide how to render the figures created by "
"this backend"))
inline_label.setWordWrap(True)
formats = (("PNG", 0), ("SVG", 1))
format_box = self.create_combobox(_("Format:")+" ", formats,
'pylab/inline/figure_format',
default=0)
resolution_spin = self.create_spinbox(
_("Resolution:")+" ", " "+_("dpi"),
'pylab/inline/resolution', min_=50, max_=999, step=0.1,
tip=_("Only used when the format is PNG. Default is "
"72"))
width_spin = self.create_spinbox(
_("Width:")+" ", " "+_("inches"),
'pylab/inline/width', min_=2, max_=20, step=1,
tip=_("Default is 6"))
height_spin = self.create_spinbox(
_("Height:")+" ", " "+_("inches"),
'pylab/inline/height', min_=1, max_=20, step=1,
tip=_("Default is 4"))
bbox_inches_box = newcb(
_("Use a tight layout for inline plots"),
'pylab/inline/bbox_inches',
tip=_("Sets bbox_inches to \"tight\" when\n"
"plotting inline with matplotlib.\n"
"When enabled, can cause discrepancies\n"
"between the image displayed inline and\n"
"that created using savefig."))
inline_v_layout = QVBoxLayout()
inline_v_layout.addWidget(inline_label)
inline_layout = QGridLayout()
inline_layout.addWidget(format_box.label, 1, 0)
inline_layout.addWidget(format_box.combobox, 1, 1)
inline_layout.addWidget(resolution_spin.plabel, 2, 0)
inline_layout.addWidget(resolution_spin.spinbox, 2, 1)
inline_layout.addWidget(resolution_spin.slabel, 2, 2)
inline_layout.addWidget(width_spin.plabel, 3, 0)
inline_layout.addWidget(width_spin.spinbox, 3, 1)
inline_layout.addWidget(width_spin.slabel, 3, 2)
inline_layout.addWidget(height_spin.plabel, 4, 0)
inline_layout.addWidget(height_spin.spinbox, 4, 1)
inline_layout.addWidget(height_spin.slabel, 4, 2)
inline_layout.addWidget(bbox_inches_box, 5, 0, 1, 4)
inline_h_layout = QHBoxLayout()
inline_h_layout.addLayout(inline_layout)
inline_h_layout.addStretch(1)
inline_v_layout.addLayout(inline_h_layout)
inline_group.setLayout(inline_v_layout)
inline_group.setEnabled(self.get_option('pylab'))
pylab_box.toggled.connect(inline_group.setEnabled)
# --- Startup ---
# Run lines Group
run_lines_group = QGroupBox(_("Run code"))
run_lines_label = QLabel(_("You can run several lines of code when "
"a console is started. Please introduce "
"each one separated by semicolons and a "
"space, for example:<br>"
"<i>import os; import sys</i>"))
run_lines_label.setWordWrap(True)
run_lines_edit = self.create_lineedit(_("Lines:"), 'startup/run_lines',
'', alignment=Qt.Horizontal)
run_lines_layout = QVBoxLayout()
run_lines_layout.addWidget(run_lines_label)
run_lines_layout.addWidget(run_lines_edit)
run_lines_group.setLayout(run_lines_layout)
# Run file Group
run_file_group = QGroupBox(_("Run a file"))
run_file_label = QLabel(_("You can also run a whole file at startup "
"instead of just some lines (This is "
"similar to have a PYTHONSTARTUP file)."))
run_file_label.setWordWrap(True)
file_radio = newcb(_("Use the following file:"),
'startup/use_run_file', False)
run_file_browser = self.create_browsefile('', 'startup/run_file', '')
run_file_browser.setEnabled(False)
file_radio.toggled.connect(run_file_browser.setEnabled)
run_file_layout = QVBoxLayout()
run_file_layout.addWidget(run_file_label)
run_file_layout.addWidget(file_radio)
run_file_layout.addWidget(run_file_browser)
run_file_group.setLayout(run_file_layout)
# ---- Advanced settings ----
# Enable Jedi completion
jedi_group = QGroupBox(_("Jedi completion"))
jedi_label = QLabel(_("Enable Jedi-based <tt>Tab</tt> completion "
"in the IPython console; similar to the "
"greedy completer, but without evaluating "
"the code.<br>"
"<b>Warning:</b> Slows down your console "
"when working with large dataframes!"))
jedi_label.setWordWrap(True)
jedi_box = newcb(_("Use Jedi completion in the IPython console"),
"jedi_completer",
tip=_("<b>Warning</b>: "
"Slows down your console when working with "
"large dataframes!<br>"
"Allows completion of nested lists etc."))
jedi_layout = QVBoxLayout()
jedi_layout.addWidget(jedi_label)
jedi_layout.addWidget(jedi_box)
jedi_group.setLayout(jedi_layout)
# Greedy completer group
greedy_group = QGroupBox(_("Greedy completion"))
greedy_label = QLabel(_("Enable <tt>Tab</tt> completion on elements "
"of lists, results of function calls, etc, "
"<i>without</i> assigning them to a variable, "
"like <tt>li[0].<Tab></tt> or "
"<tt>ins.meth().<Tab></tt> <br>"
"<b>Warning:</b> Due to a bug, IPython's "
"greedy completer requires a leading "
"<tt><Space></tt> for some completions; "
"e.g. <tt>np.sin(<Space>np.<Tab>"
"</tt> works while <tt>np.sin(np.<Tab> "
"</tt> doesn't."))
greedy_label.setWordWrap(True)
greedy_box = newcb(_("Use greedy completion in the IPython console"),
"greedy_completer",
tip="<b>Warning</b>: It can be unsafe because the "
"code is actually evaluated when you press "
"<tt>Tab</tt>.")
greedy_layout = QVBoxLayout()
greedy_layout.addWidget(greedy_label)
greedy_layout.addWidget(greedy_box)
greedy_group.setLayout(greedy_layout)
# Autocall group
autocall_group = QGroupBox(_("Autocall"))
autocall_label = QLabel(_("Autocall makes IPython automatically call "
"any callable object even if you didn't "
"type explicit parentheses.<br>"
"For example, if you type <i>str 43</i> it "
"becomes <i>str(43)</i> automatically."))
autocall_label.setWordWrap(True)
smart = _('Smart')
full = _('Full')
autocall_opts = ((_('Off'), 0), (smart, 1), (full, 2))
autocall_box = self.create_combobox(
_("Autocall: "), autocall_opts, 'autocall', default=0,
tip=_("On <b>%s</b> mode, Autocall is not applied if "
"there are no arguments after the callable. On "
"<b>%s</b> mode, all callable objects are "
"automatically called (even if no arguments are "
"present).") % (smart, full))
autocall_layout = QVBoxLayout()
autocall_layout.addWidget(autocall_label)
autocall_layout.addWidget(autocall_box)
autocall_group.setLayout(autocall_layout)
# Sympy group
sympy_group = QGroupBox(_("Symbolic Mathematics"))
sympy_label = QLabel(_("Perfom symbolic operations in the console "
"(e.g. integrals, derivatives, vector "
"calculus, etc) and get the outputs in a "
"beautifully printed style (it requires the "
"Sympy module)."))
sympy_label.setWordWrap(True)
sympy_box = newcb(_("Use symbolic math"), "symbolic_math",
tip=_("This option loads the Sympy library to work "
"with.<br>Please refer to its documentation "
"to learn how to use it."))
sympy_layout = QVBoxLayout()
sympy_layout.addWidget(sympy_label)
sympy_layout.addWidget(sympy_box)
sympy_group.setLayout(sympy_layout)
# Prompts group
prompts_group = QGroupBox(_("Prompts"))
prompts_label = QLabel(_("Modify how Input and Output prompts are "
"shown in the console."))
prompts_label.setWordWrap(True)
in_prompt_edit = self.create_lineedit(
_("Input prompt:"),
'in_prompt', '',
_('Default is<br>'
'In [<span class="in-prompt-number">'
'%i</span>]:'),
alignment=Qt.Horizontal)
out_prompt_edit = self.create_lineedit(
_("Output prompt:"),
'out_prompt', '',
_('Default is<br>'
'Out[<span class="out-prompt-number">'
'%i</span>]:'),
alignment=Qt.Horizontal)
prompts_layout = QVBoxLayout()
prompts_layout.addWidget(prompts_label)
prompts_g_layout = QGridLayout()
prompts_g_layout.addWidget(in_prompt_edit.label, 0, 0)
prompts_g_layout.addWidget(in_prompt_edit.textbox, 0, 1)
prompts_g_layout.addWidget(out_prompt_edit.label, 1, 0)
prompts_g_layout.addWidget(out_prompt_edit.textbox, 1, 1)
prompts_layout.addLayout(prompts_g_layout)
prompts_group.setLayout(prompts_layout)
# Windows adjustments
windows_group = QGroupBox(_("Windows adjustments"))
hide_cmd_windows = newcb(
_("Hide command line output windows "
"generated by the subprocess module."),
'hide_cmd_windows')
windows_layout = QVBoxLayout()
windows_layout.addWidget(hide_cmd_windows)
windows_group.setLayout(windows_layout)
# --- Tabs organization ---
tabs = QTabWidget()
tabs.addTab(self.create_tab(interface_group, comp_group,
source_code_group), _("Display"))
tabs.addTab(self.create_tab(pylab_group, backend_group, inline_group),
_("Graphics"))
tabs.addTab(self.create_tab(run_lines_group, run_file_group),
_("Startup"))
tabs.addTab(self.create_tab(jedi_group, greedy_group, autocall_group,
sympy_group, prompts_group,
windows_group),
_("Advanced Settings"))
vlayout = QVBoxLayout()
vlayout.addWidget(tabs)
self.setLayout(vlayout)
class ImportWizard(QDialog):
"""Text data import wizard"""
def __init__(self, parent, text,
title=None, icon=None, contents_title=None, varname=None):
QDialog.__init__(self, parent)
# Destroying the C++ object right after closing the dialog box,
# otherwise it may be garbage-collected in another QThread
# (e.g. the editor's analysis thread in Spyder), thus leading to
# a segmentation fault on UNIX or an application crash on Windows
self.setAttribute(Qt.WA_DeleteOnClose)
if title is None:
title = _("Import wizard")
self.setWindowTitle(title)
if icon is None:
self.setWindowIcon(ima.icon('fileimport'))
if contents_title is None:
contents_title = _("Raw text")
if varname is None:
varname = _("variable_name")
self.var_name, self.clip_data = None, None
# Setting GUI
self.tab_widget = QTabWidget(self)
self.text_widget = ContentsWidget(self, text)
self.table_widget = PreviewWidget(self)
self.tab_widget.addTab(self.text_widget, _("text"))
self.tab_widget.setTabText(0, contents_title)
self.tab_widget.addTab(self.table_widget, _("table"))
self.tab_widget.setTabText(1, _("Preview"))
self.tab_widget.setTabEnabled(1, False)
name_layout = QHBoxLayout()
name_label = QLabel(_("Variable Name"))
name_layout.addWidget(name_label)
self.name_edt = QLineEdit()
self.name_edt.setText(varname)
name_layout.addWidget(self.name_edt)
btns_layout = QHBoxLayout()
cancel_btn = QPushButton(_("Cancel"))
btns_layout.addWidget(cancel_btn)
cancel_btn.clicked.connect(self.reject)
h_spacer = QSpacerItem(40, 20,
QSizePolicy.Expanding, QSizePolicy.Minimum)
btns_layout.addItem(h_spacer)
self.back_btn = QPushButton(_("Previous"))
self.back_btn.setEnabled(False)
btns_layout.addWidget(self.back_btn)
self.back_btn.clicked.connect(ft_partial(self._set_step, step=-1))
self.fwd_btn = QPushButton(_("Next"))
btns_layout.addWidget(self.fwd_btn)
self.fwd_btn.clicked.connect(ft_partial(self._set_step, step=1))
self.done_btn = QPushButton(_("Done"))
self.done_btn.setEnabled(False)
btns_layout.addWidget(self.done_btn)
self.done_btn.clicked.connect(self.process)
self.text_widget.asDataChanged.connect(self.fwd_btn.setEnabled)
self.text_widget.asDataChanged.connect(self.done_btn.setDisabled)
layout = QVBoxLayout()
layout.addLayout(name_layout)
layout.addWidget(self.tab_widget)
layout.addLayout(btns_layout)
self.setLayout(layout)
def _focus_tab(self, tab_idx):
"""Change tab focus"""
for i in range(self.tab_widget.count()):
self.tab_widget.setTabEnabled(i, False)
self.tab_widget.setTabEnabled(tab_idx, True)
self.tab_widget.setCurrentIndex(tab_idx)
def _set_step(self, step):
"""Proceed to a given step"""
new_tab = self.tab_widget.currentIndex() + step
assert new_tab < self.tab_widget.count() and new_tab >= 0
if new_tab == self.tab_widget.count()-1:
try:
self.table_widget.open_data(self._get_plain_text(),
self.text_widget.get_col_sep(),
self.text_widget.get_row_sep(),
self.text_widget.trnsp_box.isChecked(),
self.text_widget.get_skiprows(),
self.text_widget.get_comments())
self.done_btn.setEnabled(True)
self.done_btn.setDefault(True)
self.fwd_btn.setEnabled(False)
self.back_btn.setEnabled(True)
except (SyntaxError, AssertionError) as error:
QMessageBox.critical(self, _("Import wizard"),
_("<b>Unable to proceed to next step</b>"
"<br><br>Please check your entries."
"<br><br>Error message:<br>%s") % str(error))
return
elif new_tab == 0:
self.done_btn.setEnabled(False)
self.fwd_btn.setEnabled(True)
self.back_btn.setEnabled(False)
self._focus_tab(new_tab)
def get_data(self):
"""Return processed data"""
# It is import to avoid accessing Qt C++ object as it has probably
# already been destroyed, due to the Qt.WA_DeleteOnClose attribute
return self.var_name, self.clip_data
def _simplify_shape(self, alist, rec=0):
"""Reduce the alist dimension if needed"""
if rec != 0:
if len(alist) == 1:
return alist[-1]
return alist
if len(alist) == 1:
return self._simplify_shape(alist[-1], 1)
return [self._simplify_shape(al, 1) for al in alist]
def _get_table_data(self):
"""Return clipboard processed as data"""
data = self._simplify_shape(
self.table_widget.get_data())
if self.table_widget.array_btn.isChecked():
return array(data)
elif pd and self.table_widget.df_btn.isChecked():
info = self.table_widget.pd_info
buf = io.StringIO(self.table_widget.pd_text)
return pd.read_csv(buf, **info)
return data
def _get_plain_text(self):
"""Return clipboard as text"""
return self.text_widget.text_editor.toPlainText()
@Slot()
def process(self):
"""Process the data from clipboard"""
var_name = self.name_edt.text()
try:
self.var_name = str(var_name)
except UnicodeEncodeError:
self.var_name = to_text_string(var_name)
if self.text_widget.get_as_data():
self.clip_data = self._get_table_data()
elif self.text_widget.get_as_code():
self.clip_data = try_to_eval(
to_text_string(self._get_plain_text()))
else:
self.clip_data = to_text_string(self._get_plain_text())
self.accept()
