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)
def tabWidget(self, b, c, v, text, initialTab):
self.tabs = QTabWidget()
# 0
self.bibleTab = BibleExplorer(self, (b, c, v, text))
self.tabs.addTab(self.bibleTab, config.thisTranslation["cp0"])
self.tabs.setTabToolTip(0, config.thisTranslation["cp0Tip"])
# 1
libraryTab = LibraryLauncher(self)
self.tabs.addTab(libraryTab, config.thisTranslation["cp1"])
self.tabs.setTabToolTip(1, config.thisTranslation["cp1Tip"])
# 2
self.toolTab = SearchLauncher(self)
self.tabs.addTab(self.toolTab, config.thisTranslation["cp2"])
self.tabs.setTabToolTip(2, config.thisTranslation["cp2Tip"])
# 3
self.historyTab = HistoryLauncher(self)
self.tabs.addTab(self.historyTab, config.thisTranslation["cp3"])
self.tabs.setTabToolTip(3, config.thisTranslation["cp3Tip"])
# 4
self.miscellaneousTab = MiscellaneousLauncher(self)
self.tabs.addTab(self.miscellaneousTab, config.thisTranslation["cp4"])
self.tabs.setTabToolTip(4, config.thisTranslation["cp4Tip"])
# set action with changing tabs
self.tabs.currentChanged.connect(self.tabChanged)
# set initial tab
self.tabs.setCurrentIndex(initialTab)
return self.tabs
def __init__(self, parent=None):
super().__init__(parent=parent)
self.setMinimumWidth(self.__sidebar_width__ + 50)
self.setMinimumHeight(600)
self.tabwidget = QTabWidget()
vbox = VBox(self, margin=(1, 1, 2, 0), spacing=2)
vbox.addWidget(self.tabwidget, 1)
self.tabs = [
(QWidget(), t)
for t in config["api"]["plugins"]
if (t != "workspace") and (t != "render")
]
# 'workspace' and 'render' are internal plugins with no gui
for t in self.tabs:
self.tabwidget.addTab(t[0], t[1].capitalize())
t[0].layout = QVBoxLayout()
t[0].setLayout(t[0].layout)
self.title = Header("Plugin")
self.containers = {}
for t in self.tabs:
pane = ScrollPane(parent=self)
t[0].layout.addWidget(pane)
self.containers[t[1]] = pane
self.plugins = {}
self.selected_name = None
self.selected = None
def __init__(self, parent: MainWindowBase) -> None:
"""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 __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 __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 createBottomLeftTabWidget(self):
self.bottomLeftTabWidget = QTabWidget()
self.bottomLeftTabWidget.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Ignored)
tab1 = QWidget()
tableWidget = QTableWidget(10, 10)
tab1hbox = QHBoxLayout()
tab1hbox.setContentsMargins(5, 5, 5, 5)
tab1hbox.addWidget(tableWidget)
tab1.setLayout(tab1hbox)
tab2 = QWidget()
textEdit = QTextEdit()
textEdit.setPlainText("Twinkle, twinkle, little star,\n"
"How I wonder what you are.\n"
"Up above the world so high,\n"
"Like a diamond in the sky.\n"
"Twinkle, twinkle, little star,\n"
"How I wonder what you are!\n")
tab2hbox = QHBoxLayout()
tab2hbox.setContentsMargins(5, 5, 5, 5)
tab2hbox.addWidget(textEdit)
tab2.setLayout(tab2hbox)
self.bottomLeftTabWidget.addTab(tab1, "&Table")
self.bottomLeftTabWidget.addTab(tab2, "Text &Edit")
def create_controls(self):
"""
Create UI controls.
"""
self.tabs = QTabWidget(self)
# Fill in tabs by setting groups
s = QSettings(self.ui)
self._add_groups(s)
# Add button bar at end
btns = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Apply
| QDialogButtonBox.Cancel | QDialogButtonBox.Reset,
QtCore.Qt.Horizontal, self)
btns.accepted.connect(self._on_accept)
btns.rejected.connect(self.reject)
btns.clicked[QAbstractButton].connect(self._on_click)
self._btns = btns
self.apply_btn.setEnabled(False)
vbox = QVBoxLayout()
vbox.addWidget(self.tabs)
vbox.addWidget(btns)
self.setLayout(vbox)
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 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 __init__(self, parent, **kwargs):
QWidget.__init__(self, parent)
if spyder.version_info > (5,):
self.plugin = parent.get_plugin()
else:
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.precedents = MxAnalyzerTab(parent=self, adjacency='precedents')
self.succs = MxAnalyzerTab(parent=self, adjacency='succs')
self.tabs = {'precedents': self.precedents,
'succs': self.succs}
self.tabwidget.addTab(self.precedents, 'Precedents')
self.tabwidget.addTab(self.succs, 'Dependents')
layout = create_plugin_layout(self.tools_layout, self.tabwidget)
self.setFocusPolicy(Qt.ClickFocus)
self.setLayout(layout)
def __init__(self, parent, state_colors):
super(DetailedProgressWidget, self).__init__(parent)
self.setWindowTitle("Realization Progress")
layout = QGridLayout(self)
self.iterations = QTabWidget()
self.state_colors = state_colors
self.single_view = SingleTableView()
self.single_view.setModel(
SingleProgressModel(self.single_view, state_colors))
self.single_view_label = QLabel("Realization details")
layout.addWidget(self.iterations, 1, 0)
layout.addWidget(self.single_view_label, 2, 0)
layout.addWidget(self.single_view, 3, 0)
self.setLayout(layout)
self.layout().setRowStretch(1, 1)
self.layout().setRowStretch(3, 1)
self.progress = None
self.selected_realization = -1
self.current_iteration = -1
self.resize(parent.width(), parent.height())
self.progress = {}
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
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)
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")
def setupUi(self, MainWindow):
MainWindow.setObjectName(_fromUtf8("MainWindow"))
MainWindow.resize(1155, 853)
self.centralwidget = QWidget(MainWindow)
self.centralwidget.setObjectName(_fromUtf8("centralwidget"))
self.verticalLayout = QVBoxLayout(self.centralwidget)
self.verticalLayout.setObjectName(_fromUtf8("verticalLayout"))
self.tabWidget = QTabWidget(self.centralwidget)
self.tabWidget.setObjectName(_fromUtf8("tabWidget"))
self.tab = QWidget()
self.tab.setObjectName(_fromUtf8("tab"))
self.tabWidget.addTab(self.tab, _fromUtf8(""))
self.tab_2 = QWidget()
self.tab_2.setObjectName(_fromUtf8("tab_2"))
self.tabWidget.addTab(self.tab_2, _fromUtf8(""))
self.verticalLayout.addWidget(self.tabWidget)
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QMenuBar(MainWindow)
self.menubar.setGeometry(QRect(0, 0, 1155, 20))
self.menubar.setObjectName(_fromUtf8("menubar"))
MainWindow.setMenuBar(self.menubar)
self.statusbar = QStatusBar(MainWindow)
self.statusbar.setObjectName(_fromUtf8("statusbar"))
MainWindow.setStatusBar(self.statusbar)
self.retranslateUi(MainWindow)
self.tabWidget.setCurrentIndex(0)
QMetaObject.connectSlotsByName(MainWindow)
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
def __init__(self, env):
super().__init__()
self._env = env
self._extra_menu_actions = []
self._extra_toolbar_actions = []
self.update_title()
main_menu = self.menuBar()
self.main_menu = main_menu
project_menu = main_menu.addMenu("&Project")
toolbar = self.addToolBar("Top")
self.toolbar = toolbar
new_action = QAction("&New", self)
new_action.setShortcut("Ctrl+N")
new_action.setStatusTip("Create a new empty project")
new_action.triggered.connect(lambda: env.new())
project_menu.addAction(new_action)
open_action = QAction("&Open...", self)
open_action.setShortcut("Ctrl+O")
open_action.setStatusTip("Open an existing project")
open_action.triggered.connect(lambda: env.open())
project_menu.addAction(open_action)
save_action = QAction("&Save", self)
self.save_action = save_action
save_action.setShortcut("Ctrl+S")
save_action.setIcon(QIcon.fromTheme("document-save"))
#save_action.setIcon(self.style().standardIcon(
# self.style().SP_DialogSaveButton))
save_action.setStatusTip("Save project")
save_action.setEnabled(False)
save_action.triggered.connect(lambda: env.save())
project_menu.addAction(save_action)
toolbar.addAction(save_action)
save_as_action = QAction("Save &As...", self)
save_as_action.setStatusTip("Save project under a new name")
save_as_action.triggered.connect(lambda: env.save_as())
project_menu.addAction(save_as_action)
quit_action = QAction("&Quit", self)
quit_action.setShortcut("Ctrl+Q")
quit_action.setStatusTip("Quit Hildegard")
quit_action.triggered.connect(self.handle_quit)
project_menu.addAction(quit_action)
self.tabs = QTabWidget()
self.tabs.setTabsClosable(True)
self.tabs.tabCloseRequested.connect(
lambda index: env.close(self.tabs.widget(index).entity, quit=True))
self.tabs.currentChanged.connect(self._handle_switch_to_tab)
self.setCentralWidget(self.tabs)
self.statusBar()
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;}')
def __init__(self, config_file, storage_client, parent):
QMainWindow.__init__(self, parent)
if storage_client:
self._api = storage_client
else:
self._api = PlotApi(ERT.enkf_facade)
self.setMinimumWidth(850)
self.setMinimumHeight(650)
self.setWindowTitle("Plotting - {}".format(config_file))
self.activateWindow()
self._key_definitions = self._api.all_data_type_keys()
self._plot_customizer = PlotCustomizer(self, self._key_definitions)
self._plot_customizer.settingsChanged.connect(self.keySelected)
self._central_tab = QTabWidget()
central_widget = QWidget()
central_layout = QVBoxLayout()
central_layout.setContentsMargins(0, 0, 0, 0)
central_widget.setLayout(central_layout)
central_layout.addWidget(self._central_tab)
self.setCentralWidget(central_widget)
self._plot_widgets = []
""":type: list of PlotWidget"""
self.addPlotWidget(ENSEMBLE, EnsemblePlot())
self.addPlotWidget(STATISTICS, StatisticsPlot())
self.addPlotWidget(HISTOGRAM, HistogramPlot())
self.addPlotWidget(GAUSSIAN_KDE, GaussianKDEPlot())
self.addPlotWidget(DISTRIBUTION, DistributionPlot())
self.addPlotWidget(CROSS_CASE_STATISTICS, CrossCaseStatisticsPlot())
self._central_tab.currentChanged.connect(self.currentPlotChanged)
cases = self._api.get_all_cases_not_running()
case_names = [case["name"] for case in cases if not case["hidden"]]
self._data_type_keys_widget = DataTypeKeysWidget(self._key_definitions)
self._data_type_keys_widget.dataTypeKeySelected.connect(
self.keySelected)
self.addDock("Data types", self._data_type_keys_widget)
self._case_selection_widget = CaseSelectionWidget(case_names)
self._case_selection_widget.caseSelectionChanged.connect(
self.keySelected)
self.addDock("Plot case", self._case_selection_widget)
current_plot_widget = self._plot_widgets[
self._central_tab.currentIndex()]
self._data_type_keys_widget.selectDefault()
self._updateCustomizer(current_plot_widget)
def _setupUi(self):
cwid = QWidget(self)
self.setCentralWidget(cwid)
title = QLabel('<h3>Machine Reports</h3>',
self,
alignment=Qt.AlignCenter)
self._timesel_gbox = self._setupTimePeriodSelWidget()
self._timesel_gbox.setObjectName('timesel_gbox')
self._timesel_gbox.setStyleSheet(
"#timesel_gbox{min-height: 8em; max-height: 8em;}")
self._progress_list = QListWidget(self)
self._progress_list.setObjectName('progress_list')
self._progress_list.setStyleSheet(
"#progress_list{min-height: 8em; max-height: 8em;}")
self._reports_wid = QTabWidget(cwid)
self._reports_wid.setObjectName('ASTab')
self._reports_wid.addTab(self._setupUserShiftStatsWidget(),
'User Shift Stats')
self._reports_wid.addTab(self._setupLightSourceUsageStats(),
'Light Source Usage Stats')
self._reports_wid.addTab(self._setupStoredCurrentStats(),
'Stored Current Stats')
self._pb_showraw = QPushButton(qta.icon('mdi.chart-line'),
'Show Raw Data', self)
self._pb_showraw.setEnabled(False)
self._pb_showraw.clicked.connect(self._show_raw_data)
self._pb_showpvsd = QPushButton(qta.icon('mdi.chart-line'),
'Show Progrmd.vs.Delivered Hours',
self)
self._pb_showpvsd.setEnabled(False)
self._pb_showpvsd.clicked.connect(self._show_progmd_vs_delivd)
lay = QGridLayout(cwid)
lay.setVerticalSpacing(10)
lay.setHorizontalSpacing(10)
lay.setContentsMargins(18, 9, 18, 9)
lay.addWidget(title, 0, 0, 1, 3)
lay.addWidget(self._timesel_gbox, 1, 0)
lay.addWidget(self._progress_list,
1,
1,
1,
2,
alignment=Qt.AlignBottom)
lay.addWidget(self._reports_wid, 2, 0, 1, 3)
lay.addWidget(self._pb_showpvsd, 4, 0, alignment=Qt.AlignLeft)
lay.addWidget(self._pb_showraw, 4, 2, alignment=Qt.AlignRight)
self._updateUserShiftStats(setup=True)
self._updateStoredCurrentStats(setup=True)
self._updateLightSourceUsageStats(setup=True)
def mousePressEvent(self, event):
# the user did not click on a tab at all, stop all further mouseEvents processing
if self.last_tab_clicked < 0:
return
if Qt.MiddleButton == event.button():
self.tabCloseRequested.emit(self.last_tab_clicked)
QTabWidget(self).mousePressEvent(event)
def __init__(self, parent=None):
super(HintTabView, self).__init__(parent)
self._tabWidget = QTabWidget()
self._tabWidget.setParent(self)
self._indexToTabMap = OrderedDict()
self.setLayout(QVBoxLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self.layout().addWidget(self._tabWidget)
def _setup_ui(self):
self.setWindowTitle(self._section+' PS Control')
# Create Tabs
self.tabs = QTabWidget()
self.tabs.setObjectName(self._section + "Tab")
self.TabIndex = dict()
self._addTabs()
self.tabs.currentChanged.connect(self._fillTabTask)
# Set widget layout
self.setCentralWidget(self.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)
self.icon = QIcon(path('icons/tabs.png'))
def create_tabwidget(self):
"""Create a new QTabWidget with a button to add new tabs"""
tabs = QTabWidget(self)
tabs.setMovable(True)
tabs.setTabsClosable(True)
# create a button to add new tabs
plus_btn = QToolButton(tabs)
plus_btn.setText('+')
plus_btn.clicked.connect(self.plus_button_clicked)
tabs.setCornerWidget(plus_btn, Qt.TopLeftCorner)
tabs.tabCloseRequested.connect(self.close_tab)
return tabs
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, **kwargs):
QWidget.__init__(self, parent)
self.plugin = parent.get_plugin()
self.last_modelpath = None
# Create and place Model Selector
txt = _("Model")
if sys.platform == 'darwin':
expr_label = QLabel(" " + txt)
else:
expr_label = QLabel(txt)
# expr_label.setAlignment(Qt.AlignCenter | Qt.AlignRight)
self.model_selector = MxModelSelector(self)
selector_layout = QHBoxLayout()
selector_layout.addWidget(expr_label)
selector_layout.addWidget(self.model_selector)
selector_layout.insertStretch(-1, 1)
selector_layout.setStretch(0, 0)
selector_layout.setStretch(1, 1)
# Create widget and add to dockwindow
self.explorer = MxExplorer(self)
# Create code list
self.codelist = MxCodeListWidget(self)
self.propwidget = MxPropertyWidget(self, orientation=Qt.Vertical)
self.datalist = MxDataListWidget(self, orientation=Qt.Vertical)
# Create splitter
self.splitter = QSplitter(self)
self.splitter.setContentsMargins(0, 0, 0, 0)
# self.splitter.addWidget(self.widget)
# self.splitter.setStretchFactor(0, 5)
# self.splitter.setStretchFactor(1, 1)
self.tabwidget = QTabWidget(parent=self)
# self.tabwidget.setContentsMargins(0, 0, 0, 0)
MxMainWidget.IdxProperties = self.tabwidget.addTab(self.propwidget, "Properties")
MxMainWidget.IdxFormulas = self.tabwidget.addTab(self.codelist, "Formulas")
MxMainWidget.IdxDataList = self.tabwidget.addTab(self.datalist, "Data")
# Layout management
self.splitter.addWidget(self.explorer)
self.splitter.addWidget(self.tabwidget)
layout = create_plugin_layout(selector_layout, self.splitter)
self.setLayout(layout)
self.setFocusPolicy(Qt.ClickFocus)
