def __init__(self, data_file, parent=None): super(HDF5Browser, self).__init__(parent) self.data_file = data_file self.treeWidget = HDF5TreeWidget( data_file, parent=self, ) self.treeWidget.selectionModel().selectionChanged.connect( self.selection_changed) self.viewer = HDF5ItemViewer( parent=self, show_controls=True, ) self.refresh_tree_button = QtWidgets.QPushButton( ) #Create a refresh button self.refresh_tree_button.setText("Refresh Tree") #adding the refresh button self.treelayoutwidget = QtWidgets.QWidget( ) #construct a widget which can then contain the refresh button and the tree self.treelayoutwidget.setLayout(QtWidgets.QVBoxLayout()) self.treelayoutwidget.layout().addWidget(self.treeWidget) self.treelayoutwidget.layout().addWidget(self.refresh_tree_button) self.refresh_tree_button.clicked.connect( self.treeWidget.model.refresh_tree) splitter = QtWidgets.QSplitter() splitter.addWidget( self.treelayoutwidget ) #Add newly constructed widget (treeview and button) to the splitter splitter.addWidget(self.viewer) self.setLayout(QtWidgets.QHBoxLayout()) self.layout().addWidget(splitter)
def SolsTiSupdatestatus(self): ''' relevant_properties is a dictionary of labels to display (keys) and names of the properties to display as returned by the laser We then create a dictionary with the labels and the values of the properties (display_dicc) And display that dictionary as a table :return: ''' relevant_properties = { 'C. lock': 'cavity_lock', 'E. lock': 'etalon_lock', 'T': 'temperature', 'R. volt.': 'resonator_voltage', 'E. volt.': 'etalon_voltage', 'wvl': 'wavelength', 'Out': 'output_monitor' } display_dicc = { new_key: self.SolsTiS.laser_status[relevant_properties[new_key]] for new_key in relevant_properties.keys() } self.tableWidget.setRowCount(len(relevant_properties)) row = 0 for key in display_dicc.keys(): item_key = QtWidgets.QTableWidgetItem(key) item_value = QtWidgets.QTableWidgetItem(str(display_dicc[key])) self.tableWidget.setItem(row, 0, item_key) self.tableWidget.setItem(row, 1, item_value) row = row + 1 self.tableWidget.resizeColumnsToContents()
def __init__(self, camera, *args, **kwargs): super(CameraParametersWidget, self).__init__(*args, **kwargs) self.camera = camera self.table_model = CameraParametersTableModel(camera) self.table_view = QtWidgets.QTableView() self.table_view.setModel(self.table_model) self.table_view.setCornerButtonEnabled(False) self.table_view.resizeColumnsToContents() self.table_view.horizontalHeader().setStretchLastSection(True) layout = QtWidgets.QVBoxLayout(self) layout.addWidget(self.table_view) self.setLayout(layout)
def _make_gui(self, hide_border=True): """Creates and sets the widget layout :param hide_border: bool. See __init__ :return: """ self._QLabel = QtWidgets.QLabel(self) layout = QtWidgets.QHBoxLayout(self) layout.setContentsMargins(0, 0, 0, 0) layout.addWidget(self._QLabel) self.setLayout(layout) self.setWindowTitle('SLM Phase') if hide_border: self.setWindowFlags(QtCore.Qt.CustomizeWindowHint | QtCore.Qt.FramelessWindowHint)
def _init_ui(self): self.setWindowTitle('Spectrometers') self.controls_layout = QtWidgets.QHBoxLayout() controls_group = QtWidgets.QGroupBox() controls_group.setTitle('Spectrometers') controls_group.setLayout(self.controls_layout) self.controls = [] for spectrometer in self.spectrometers.spectrometers: control = spectrometer.get_qt_ui(control_only=True) self.controls_layout.addWidget(control) self.controls.append(control) self.display = SpectrometerDisplayUI(self.spectrometers) layout = QtWidgets.QVBoxLayout() layout.addWidget(controls_group) layout.addWidget(self.display) self.setLayout(layout)
def add_checkbox(self, name, title=None): if title is None: title = name.title() checkbox = QtWidgets.QCheckBox() self.controls[name] = checkbox checkbox.setObjectName(name + "_checkbox") checkbox.setText(title) self.layout().addRow("", checkbox)
def _addActionViewMenu(self, instr): if instr not in self.actions['Views']: action = QtWidgets.QAction(instr, self) self.menuView.addAction(action) action.setCheckable(True) action.setChecked(True) action.triggered.connect(lambda: self._toggleView(instr)) self.actions['Views'][instr] = action
def _addActionInstrMenu(self, instr): if instr not in self.actions['Instruments']: action = QtWidgets.QAction(instr, self) self.menuInstr.addAction(action) action.setCheckable(True) action.setChecked(settings.addresses[instr]['use?']) action.triggered.connect(lambda: self._toggleInstr(instr)) self.actions['Instruments'][instr] = action
def __init__(self, spectrometer, ui_file=os.path.join(os.path.dirname(__file__), 'spectrometer_view.ui'), parent=None): assert isinstance(spectrometer, Spectrometer) or isinstance(spectrometer, Spectrometers),\ "instrument must be a Spectrometer or an instance of Spectrometers" super(SpectrometerDisplayUI, self).__init__() uic.loadUi(ui_file, self) if isinstance(spectrometer, Spectrometers) and spectrometer.num_spectrometers == 1: spectrometer = spectrometer.spectrometers[0] if isinstance(spectrometer, Spectrometer): spectrometer.num_spectrometers = 1 self.spectrometer = spectrometer print(self.spectrometer) pg.setConfigOption('background', 'w') pg.setConfigOption('foreground', 'k') self.plotbox = QtWidgets.QGroupBox() self.plotbox.setLayout(QtWidgets.QGridLayout()) self.plotlayout = self.plotbox.layout() self.plots = [] for spectrometer_nom in range(self.spectrometer.num_spectrometers): self.plots.append( pg.PlotWidget(labels={'bottom': 'Wavelength (nm)'})) self.plotlayout.addWidget(self.plots[spectrometer_nom]) self.figure_widget = self.replace_widget(self.display_layout, self.figure_widget, self.plotbox) self.take_spectrum_button.clicked.connect(self.button_pressed) self.live_button.clicked.connect(self.button_pressed) self.save_button.clicked.connect(self.button_pressed) self.threshold.setValidator(QtGui.QDoubleValidator()) self.threshold.textChanged.connect(self.check_state) self._display_thread = DisplayThread(self) self._display_thread.spectrum_ready.connect(self.update_display) self._display_thread.spectra_ready.connect(self.update_display) self.period = 0.2 self.filename_lineEdit.textChanged.connect(self.filename_changed_ui) register_for_property_changes(self.spectrometer, 'filename', self.filename_changed)
def add_button(self, name, title=None): """Add a button.""" if title is None: title = name.title() button = QtWidgets.QPushButton() self.controls[name] = button button.setObjectName(name + "_button") button.setText(title) self.layout().addRow(button)
def _addActionViewMenu(self, instr): """Create the actions menu - such as enabled and disabling gui's on the fly """ if instr not in self.actions['Views']: action = QtWidgets.QAction(instr, self) self.menuView.addAction(action) action.setCheckable(True) action.setChecked(True) action.triggered.connect(lambda: self._toggleView(instr)) self.actions['Views'][instr] = action
def add_spinbox(self, name, vmin=-2**31, vmax=2**31 - 1): """Add a floating-point spin box control.""" sb = QtWidgets.QSpinBox() self.controls[name] = sb sb.setObjectName(name + "_spinbox") sb.setMinimum(vmin) sb.setMaximum(vmax) sb.setKeyboardTracking(False) self.layout().addRow(name.title(), sb)
def renderer_selected(self, index): """Change the figure widget to use the selected renderer.""" # The class of the renderer is stored as the combobox data RendererClass = self.renderer_combobox.itemData(index) try: self.renderer = RendererClass(self.data, self) except TypeError: # If the box is empty (e.g. it's just been cleared) use a blank widget self.renderer = QtWidgets.QWidget()
def __init__(self, experiment): """Create a widget to display an experiment's logs.""" self.experiment = experiment super(LogWidget, self).__init__() self.text_edit = QtWidgets.QPlainTextEdit() self.text_edit.setReadOnly(True) self.layout().addRow(self.text_edit) self.add_button("clear", title="Clear Logs") self.auto_connect_by_name()
def add_combobox(self, name, options, title=None): if title is None: title = name.title() combobox = QtWidgets.QComboBox() for option in options: combobox.addItem(option) self.controls[name] = combobox combobox.setObjectName(name + "_combobox") # combobox.setText(title) self.layout().addRow("", combobox)
def context_menu(self, treeview, position): """Generate a right-click menu for the items""" menu = QtWidgets.QMenu() actions = {} for operation in ['Refresh tree']: actions[operation] = menu.addAction(operation) action = menu.exec_(treeview.viewport().mapToGlobal(position)) if action == actions['Refresh tree']: self.refresh_tree()
def SolsTiSReLock(self): progress = QtWidgets.QProgressDialog("Re-locking etalon", "Abort", 0, 5, self) progress.show() i = 0 self.SolsTiS.system_status() while self.SolsTiS.laser_status['etalon_lock'] != 'on' and i < 5: progress.setValue(i) self.SolsTiS.etalon_lock('on') time.sleep(0.5) self.SolsTiS.system_status() time.sleep(0.1) i += 1 progress.close() if i < 5: self.SolsTiSLockMonitor() else: popup = QtWidgets.QMessageBox() popup.setText("Re-locking the etalon failed") popup.exec_()
def __init__(self, cwl): assert isinstance(cwl, CameraWithLocation), "instrument must be a CameraWithLocation" super(CameraWithLocationUI, self).__init__() self.cwl = cwl # Set up the UI self.setWindowTitle(self.cwl.camera.__class__.__name__ + " (location-aware)") layout = QtWidgets.QVBoxLayout() # We use a tabbed control section below an image. self.tabs = QtWidgets.QTabWidget() self.microscope_controls = self.cwl.get_control_widget() self.camera_controls = self.cwl.camera.get_control_widget() self.tabs.addTab(self.microscope_controls, "Camera with Location controls") self.tabs.addTab(self.camera_controls, "Camera") # The camera viewer widget is provided by the camera... self.camera_preview = self.cwl.camera.get_preview_widget() # The overall layout puts the image at the top and the controls below l = QtWidgets.QVBoxLayout() l.addWidget(self.camera_preview) l.addWidget(self.tabs) self.setLayout(l)
def __init__(self, counter): super(CounterPreviewWidget, self).__init__() # self.plot_item = pg.pl self.plot_widget = pg.PlotWidget(labels={'bottom': 'Time'}) self.plot = self.plot_widget.getPlotItem() self.setLayout(QtWidgets.QGridLayout()) self.layout().addWidget(self.plot_widget) self.counter = counter # We want to make sure we always update the data in the GUI thread. # This is done using the signal/slot mechanism self.update_data_signal.connect(self.update_widget, type=QtCore.Qt.QueuedConnection)
def _init_ui(self): self.setWindowTitle(self.spectrometer.__class__.__name__) self.controls = self.spectrometer.get_qt_ui(control_only=True) self.display = SpectrometerDisplayUI(self.spectrometer) layout = QtWidgets.QVBoxLayout() # controls_layout = QtWidgets.QVBoxLayout() # controls_layout.addWidget(self.controls) # controls_layout.setContentsMargins(0,0,0,0) # controls_group = QtWidgets.QGroupBox() # controls_group.setTitle('Spectrometer') # controls_group.setLayout(controls_layout) layout.addWidget(self.controls) layout.addWidget(self.display) layout.setContentsMargins(5, 5, 5, 5) layout.setSpacing(5) self.setLayout(layout)
def payload(save_group=df._current_group): import numpy as np input_variables = {} for variable in self.controls.keys(): if variable == 'save_returned' or variable == 'start' or variable == 'function name': continue variable_control = self.controls[variable] if type(variable_control) == type(QtWidgets.QLineEdit( )) and variable_control.isReadOnly() == True: fullargs = inspect.getargspec(self.function) args = fullargs.args try: args.remove('self') except ValueError: pass args = np.array(args) defaults = np.array(fullargs.defaults) default_value = defaults[args == variable] input_variables[variable] = default_value[0] print variable, default_value elif (type(variable_control) == QtWidgets.QSpinBox or type(variable_control) == QtWidgets.QDoubleSpinBox): input_variables[variable] = variable_control.value() elif type(variable_control) == QtWidgets.QLineEdit: try: exec 'temp_var = ' + variable_control.text() in locals( ) input_variables[variable] = temp_var except Exception as e: print e print 'Qlineedit input error for ', variable elif type(variable_control) == QtWidgets.QCheckBox: input_variables[variable] = variable_control.isChecked() try: function_returns = self.function(**input_variables) except TypeError: print input_variables print 'function: ', task print 'Did not recieve the correct inputs!' print 'did you make an error in your lineedit inputs?' if self.controls['save_returned'].isChecked() == True: save_group.create_dataset(task, data=function_returns, attrs=input_variables)
def __init__(self, counter): #TODO: better checking (e.g. assert camera has color_image, gray_image methods) super(CounterUI, self).__init__() self.counter = counter # Set up the UI self.setWindowTitle(self.counter.__class__.__name__) layout = QtWidgets.QVBoxLayout() # The image display goes at the top of the window self.preview_widget = self.counter.get_preview_widget() layout.addWidget(self.preview_widget) # The controls go in a layout, inside a group box. self.control_widget = self.counter.get_control_widget() layout.addWidget(self.control_widget) #layout.setContentsMargins(5,5,5,5) layout.setSpacing(5) self.setLayout(layout)
def __init__(self, camera): assert isinstance(camera, Camera), "instrument must be a Camera" #TODO: better checking (e.g. assert camera has color_image, gray_image methods) super(CameraUI, self).__init__() self.camera = camera # Set up the UI self.setWindowTitle(self.camera.__class__.__name__) layout = QtWidgets.QVBoxLayout() # The image display goes at the top of the window self.preview_widget = self.camera.get_preview_widget() layout.addWidget(self.preview_widget) # The controls go in a layout, inside a group box. self.controls = self.camera.get_control_widget() layout.addWidget(self.controls) #layout.setContentsMargins(5,5,5,5) layout.setSpacing(5) self.setLayout(layout)
def __init__(self, scale=(1, 1), offset=(0, 0)): super(DisplayWidgetRoiScale, self).__init__() self._pxl_scale = scale self._pxl_offset = offset self.LineDisplay = self.ui.roiPlot self.LineDisplay.showGrid(x=True, y=True) self.ui.splitter.setHandleWidth(10) self.getHistogramWidget().gradient.restoreState( list(Gradients.values())[1]) self.imageItem.setTransform(QtGui.QTransform()) self.LineDisplay.show() self.plot = () for ii in range(self._max_num_line_plots): self.plot += (self.LineDisplay.plot( pen=pyqtgraph.intColor(ii, self._max_num_line_plots)), ) self.toggle_displays() self.checkbox_autorange = QtWidgets.QCheckBox('Autorange') self.tools.gridLayout.addWidget(self.checkbox_autorange, 0, 3, 1, 1)
def __init__(self, cwl): super(CameraWithLocationControlUI, self).__init__() self.cwl = cwl cc = QuickControlBox("Settings") cc.add_doublespinbox("calibration_distance") cc.add_button("calibrate_xy_gui", "Calibrate XY") cc.auto_connect_by_name(self) self.calibration_controls = cc fc = QuickControlBox("Autofocus") fc.add_doublespinbox("af_step_size") fc.add_spinbox("af_steps") fc.add_button("autofocus_gui", "Autofocus") fc.add_button("quick_autofocus_gui", "Quick Autofocus") fc.auto_connect_by_name(self.cwl) self.focus_controls = fc # sc = l = QtWidgets.QHBoxLayout() l.addWidget(cc) l.addWidget(fc) self.setLayout(l)
def __init__(self, title="Quick Settings", *args, **kwargs): super(QuickControlBox, self).__init__(*args, **kwargs) self.setTitle(title) self.setLayout(QtWidgets.QFormLayout()) self.controls = dict()
def __init__(self, instrument_dict, parent=None, dock_settings_path=None, scripts_path=None, working_directory=None): # """Args: instrument_dict(dict) : This is a dictionary containg the instruments objects where the key is the objects new name in the generated new Ipython console dock_settings_path(str): A path for loading a previous dock widget configuration script_path(str): The path of any scripts the user may want to run using the drop down menu at the top of the gui working_directory(str): A path to the requested working directory - handy if you always wish to save data to the same directorys """ super(GuiGenerator, self).__init__(parent) self._logger = LOGGER self.instr_dict = instrument_dict if working_directory == None: self.working_directory = os.path.join(os.getcwd()) else: self.working_directory = working_directory self.data_file = df.current(working_directory=working_directory) self.instr_dict['HDF5'] = self.data_file self.setDockNestingEnabled(1) uic.loadUi(os.path.join(os.path.dirname(__file__), 'guigenerator.ui'), self) self.allDocks = {} self.allWidgets = {} self.actions = dict(Views={}, Instruments={}) self.dockwidgetArea = pyqtgraph.dockarea.DockArea() self.dockWidgetArea = self.replace_widget(self.verticalLayout, self.centralWidget(), self.dockwidgetArea) self.dockWidgetAllInstruments.setWidget(self.dockwidgetArea) self.dockWidgetAllInstruments.setTitleBarWidget( QtWidgets.QWidget()) # This trick makes the title bar disappear # Iterate over all the opened instruments. If the instrument has a GUI (i.e. if they have the get_qt_ui function # defined inside them), then create a pyqtgraph.Dock for it and add its widget to the Dock. Also prints out any # instruments that do not have GUIs self._logger.info('Opening all GUIs') for instr in self.instr_dict: self._open_one_gui(instr) self.terminalWindow = None self.menuTerminal() self._addActionViewMenu('Terminal') self.script_menu = None if scripts_path is not None: self.scripts_path = scripts_path else: self.scripts_path = 'scripts' self.makeScriptMenu() self.NightMode = 1 # address of h5 file self.filename = df.current().filename # self._tabifyAll() self._setupSignals() if dock_settings_path is not None: self.dock_settings_path = dock_settings_path self.menuLoadSettings() else: self.dock_settings_path = None self.showMaximized()
def __init__(self, instrument_dict, parent=None, dock_settings_path=None, scripts_path=None, working_directory=None): super(GuiGenerator, self).__init__(parent) self._logger = LOGGER self.instr_dict = instrument_dict if working_directory == None: self.working_directory = os.path.join(os.getcwd()) else: self.working_directory = working_directory self.data_file = df.current(working_directory=working_directory) self.instr_dict['HDF5'] = self.data_file self.setDockNestingEnabled(1) uic.loadUi(os.path.join(os.path.dirname(__file__), 'guigenerator.ui'), self) self.allDocks = {} self.allWidgets = {} self.actions = dict(Views={}, Instruments={}) self.dockwidgetArea = pyqtgraph.dockarea.DockArea() self.dockWidgetArea = self.replace_widget(self.verticalLayout, self.centralWidget(), self.dockwidgetArea) self.dockWidgetAllInstruments.setWidget(self.dockwidgetArea) self.dockWidgetAllInstruments.setTitleBarWidget( QtWidgets.QWidget()) # This trick makes the title bar disappear # Iterate over all the opened instruments. If the instrument has a GUI (i.e. if they have the get_qt_ui function # defined inside them), then create a pyqtgraph.Dock for it and add its widget to the Dock. Also prints out any # instruments that do not have GUIs self._logger.info('Opening all GUIs') for instr in self.instr_dict: self._open_one_gui(instr) self.terminalWindow = None self.menuTerminal() self._addActionViewMenu('Terminal') self.script_menu = None if scripts_path is not None: self.scripts_path = scripts_path else: self.scripts_path = 'scripts' self.makeScriptMenu() self.NightMode = 1 # address of h5 file self.filename = df.current().filename # self._tabifyAll() self._setupSignals() if dock_settings_path is not None: self.dock_settings_path = dock_settings_path self.menuLoadSettings() else: self.dock_settings_path = None self.showMaximized()
def __init__( self, item=None, parent=None, figure_widget=None, show_controls=True, show_refresh=True, show_default_button=True, show_copy=True, renderer_combobox=None, refresh_button=None, copy_button=None, default_button=None, ): """Create a viewer widget for any dataset or datagroup object Arguments: item : HDF5 group or dataset (optional) The dataset (or group) to display parent : QWidget (optional) The Qt parent of the widget. show_controls : bool (optional) If True (default), show the refresh button and combobox. If False, just show the renderer. show_refresh : bool (optional) If show_controls is True, this sets whether the refresh button is visible. renderer_combobox : QComboBox (optional) If this is specified, use the supplied combobox instead of creating a new one. You probably want to specify show_controls=False. refresh_button : QPushButton (optional) If specified, use the supplied button instead of creating one. copy_button : QPushButton (optional) If specified, use the supplied button instead of creating one. default_button : QPushButton (optional) If specified, use the supplied button to select the default rendererinstead of creating one. """ super(HDF5ItemViewer, self).__init__(parent) if figure_widget is None: self.figure_widget = QtWidgets.QWidget() else: self.figure_widget = figure_widget if renderer_combobox is None: self.renderer_combobox = QtWidgets.QComboBox() else: self.renderer_combobox = renderer_combobox self.renderer_combobox.activated[int].connect(self.renderer_selected) if refresh_button is None: self.refresh_button = QtWidgets.QPushButton() self.refresh_button.setText("Refresh Figure") else: self.refresh_button = refresh_button self.refresh_button.clicked.connect(self.refresh) if default_button is None: self.default_button = QtWidgets.QPushButton() self.default_button.setText("Default Renderer") else: self.default_button = default_button self.default_button.clicked.connect(self.default_renderer) if copy_button is None: self.copy_button = QtWidgets.QPushButton() self.copy_button.setText("Copy Figure") else: self.copy_button = copy_button self.copy_button.clicked.connect(self.CopyActivated) self.clipboard = QtWidgets.QApplication.clipboard() self.setLayout(QtWidgets.QVBoxLayout()) self.layout().addWidget(self.figure_widget, stretch=1) self.layout().setContentsMargins(0, 0, 0, 0) self.renderers = list() if show_controls: # this part may be broken hb = QtWidgets.QHBoxLayout() hb.addWidget(self.renderer_combobox, stretch=1) if show_refresh: hb.addWidget(self.refresh_button, stretch=0) if show_copy: hb.addWidget(self.copy_button, stretch=0) if show_default_button: hb.addWidget(self.default_button, stretch=0) self.layout().addLayout(hb, stretch=0)
def add_lineedit(self, name): """Add a single-line text box control.""" le = QtWidgets.QLineEdit() self.controls[name] = le le.setObjectName(name + "_lineedit") self.layout().addRow(name.title(), le)