def initialize_content(self): # Validators self._summary.detector_offset_edit.setValidator(QDoubleValidator(self._summary.detector_offset_edit)) self._summary.sample_dist_edit.setValidator(QDoubleValidator(self._summary.sample_dist_edit)) self._summary.n_q_bins_edit.setValidator(QIntValidator(self._summary.n_q_bins_edit)) # Event connections self._summary.detector_offset_chk.clicked.connect(self._det_offset_clicked) self._summary.sample_dist_chk.clicked.connect(self._sample_dist_clicked) self._summary.help_button.clicked.connect(self._show_help) self._summary.dark_current_check.clicked.connect(self._dark_clicked) self._summary.dark_browse_button.clicked.connect(self._dark_browse) self._summary.dark_plot_button.clicked.connect(self._dark_plot_clicked) # Output directory g2 = QButtonGroup(self) g2.addButton(self._summary.select_output_dir_radio) g2.addButton(self._summary.use_data_dir_radio) g2.setExclusive(True) self._summary.select_output_dir_radio.clicked.connect(self._output_dir_clicked) self._summary.use_data_dir_radio.clicked.connect(self._output_dir_clicked) self._summary.output_dir_browse_button.clicked.connect(self._output_dir_browse) self._output_dir_clicked() # Lin/log option g3 = QButtonGroup(self) g3.addButton(self._summary.log_binning_radio) g3.addButton(self._summary.lin_binning_radio) g3.setExclusive(True) # Q range self._summary.n_q_bins_edit.setText("100") self._summary.scale_edit.setText("1") self._summary.instr_name_label.hide() self._dark_clicked(self._summary.dark_current_check.isChecked()) # Mask Connections self._summary.mask_browse_button.clicked.connect(self._mask_browse_clicked) self._summary.mask_plot_button.clicked.connect(self._mask_plot_clicked) self._summary.mask_check.clicked.connect(self._mask_checked) # Absolute scale connections and validators self._summary.scale_edit.setValidator(QDoubleValidator(self._summary.scale_edit)) self._summary.scale_beam_radius_edit.setValidator(QDoubleValidator(self._summary.scale_beam_radius_edit)) self._summary.scale_att_trans_edit.setValidator(QDoubleValidator(self._summary.scale_att_trans_edit)) self._summary.scale_data_browse_button.clicked.connect(self._scale_data_browse) self._summary.scale_data_plot_button.clicked.connect(self._scale_data_plot_clicked) self._summary.beamstop_chk.clicked.connect(self._beamstop_clicked) self._summary.scale_chk.clicked.connect(self._scale_clicked) self._scale_clicked(self._summary.scale_chk.isChecked()) # TOF cut validator self._summary.low_tof_edit.setValidator(QDoubleValidator(self._summary.low_tof_edit)) self._summary.high_tof_edit.setValidator(QDoubleValidator(self._summary.high_tof_edit)) # TOF connections self._summary.tof_cut_chk.clicked.connect(self._tof_clicked) # Monitor normalization self._summary.beam_monitor_chk.clicked.connect(self._beam_monitor_clicked) self._summary.beam_monitor_browse_button.clicked.connect(self._beam_monitor_reference_browse) # Resolution validator self._summary.sample_apert_edit.setValidator(QDoubleValidator(self._summary.sample_apert_edit)) self._summary.resolution_chk.clicked.connect(self._resolution_clicked) # Since EQSANS does not currently use the absolute scale calculation, expose it in debug mode only for now if not self._settings.debug: self._summary.config_options_layout.deleteLater() self._summary.abs_scale_options_layout.deleteLater() self._summary.abs_scale_direct_beam_layout.deleteLater() self._summary.monitor_layout.deleteLater() self._summary.direct_beam_label.hide() self._summary.att_trans_label.hide() self._summary.beamstop_chk.hide() self._summary.scale_data_edit.hide() self._summary.scale_data_plot_button.hide() self._summary.scale_data_browse_button.hide() self._summary.scale_att_trans_edit.hide() self._summary.scale_beam_radius_edit.hide() self._summary.scale_chk.hide() self._summary.beam_monitor_chk.hide() self._summary.tof_correction_chk.hide() self._summary.beam_monitor_edit.hide() self._summary.beam_monitor_browse_button.hide() # Same thing for sample-detector distance and offset: not yet hooked in self._summary.geometry_options_groupbox.hide() # Hide expert options #self._summary.config_mask_chk.hide() self._summary.tof_cut_chk.hide() self._summary.low_tof_edit.hide() self._summary.high_tof_edit.hide() self._summary.low_tof_label.hide() self._summary.high_tof_label.hide() if not self._settings.advanced: self._summary.att_scale_factor_label.hide() self._summary.scale_edit.hide() self._summary.mask_groupbox.hide() self._summary.solid_angle_chk.hide() self._summary.resolution_chk.hide() self._summary.sample_apert_edit.hide() self._summary.sample_apert_label.hide() # We need the EQSANS data proxy for a quick load of a file for masking purposes, but # we don't want to show the plot button. Turn this off for the moment. if True or not self._has_instrument_view: self._summary.dark_plot_button.hide() self._summary.scale_data_plot_button.hide()
def initialize_content(self): """ Declare the validators and event connections for the widgets loaded through the .ui file. """ # Sample data # Validators self._content.transmission_edit.setValidator( QDoubleValidator(self._content.transmission_edit)) self._content.dtransmission_edit.setValidator( QDoubleValidator(self._content.dtransmission_edit)) self._content.beam_radius_edit.setValidator( QDoubleValidator(self._content.beam_radius_edit)) self._content.sample_thickness_edit.setValidator( QDoubleValidator(self._content.sample_thickness_edit)) # Connections self._content.data_file_browse_button.clicked.connect( self._data_file_browse) self._content.calculate_radio.clicked.connect(self._calculate_clicked) self._content.fix_trans_radio.clicked.connect(self._calculate_clicked) self._content.empty_button.clicked.connect(self._empty_browse) self._content.sample_button.clicked.connect(self._sample_browse) self._content.data_file_plot_button.clicked.connect( self._data_file_plot) self._content.empty_plot_button.clicked.connect(self._empty_plot) self._content.sample_plot_button.clicked.connect(self._sample_plot) # Calculate/Fix radio button g1 = QButtonGroup(self) g1.addButton(self._content.calculate_radio) g1.addButton(self._content.fix_trans_radio) g1.setExclusive(True) if not self._settings.debug: self._content.fix_transmission_layout.deleteLater() self._content.calculate_radio.hide() self._content.fix_trans_radio.hide() self._content.plus_minus_label.hide() self._content.transmission_edit.hide() self._content.dtransmission_edit.hide() if not self._has_instrument_view: self._content.data_file_plot_button.hide() self._content.empty_plot_button.hide() self._content.sample_plot_button.hide() # Background ########## # Validators self._content.bck_transmission_edit.setValidator( QDoubleValidator(self._content.bck_transmission_edit)) self._content.bck_dtransmission_edit.setValidator( QDoubleValidator(self._content.bck_dtransmission_edit)) self._content.bck_beam_radius_edit.setValidator( QDoubleValidator(self._content.beam_radius_edit)) #self._content.bck_thickness_edit.setValidator(QDoubleValidator(self._content.bck_thickness_edit)) # Connections self._content.background_chk.clicked.connect(self._background_clicked) self._content.background_browse.clicked.connect( self._background_browse) self._content.bck_calculate_radio.clicked.connect( self._bck_calculate_clicked) self._content.bck_fix_trans_radio.clicked.connect( self._bck_calculate_clicked) self._content.bck_empty_button.clicked.connect(self._bck_empty_browse) self._content.bck_sample_button.clicked.connect( self._bck_sample_browse) self._content.background_plot_button.clicked.connect( self._background_plot_clicked) self._content.bck_empty_plot_button.clicked.connect( self._bck_empty_plot) self._content.bck_sample_plot_button.clicked.connect( self._bck_sample_plot) # Calculate/Fix radio button g2 = QButtonGroup(self) g2.addButton(self._content.bck_calculate_radio) g2.addButton(self._content.bck_fix_trans_radio) g2.setExclusive(True) if not self._settings.debug: self._content.bck_fix_transmission_layout.deleteLater() self._content.bck_calculate_radio.hide() self._content.bck_fix_trans_radio.hide() self._content.bck_plus_minus_label.hide() self._content.bck_transmission_edit.hide() self._content.bck_dtransmission_edit.hide() if not self._settings.advanced: self._content.theta_dep_chk.hide() self._content.bck_theta_dep_chk.hide() self._content.sample_thickness_label.hide() self._content.sample_thickness_edit.hide() #self._content.bck_thickness_label.hide() #self._content.bck_thickness_edit.hide() if not self._has_instrument_view: self._content.background_plot_button.hide() self._content.bck_empty_plot_button.hide() self._content.bck_sample_plot_button.hide()
class PyDMEnumButton(QWidget, PyDMWritableWidget, WidgetType): """ A QWidget that renders buttons for every option of Enum Items. For now three types of buttons can be rendered: - Push Button - Radio Button Parameters ---------- parent : QWidget The parent widget for the Label init_channel : str, optional The channel to be used by the widget. Signals ------- send_value_signal : int, float, str, bool or np.ndarray Emitted when the user changes the value. """ Q_ENUMS(WidgetType) WidgetType = WidgetType def __init__(self, parent=None, init_channel=None): QWidget.__init__(self, parent) PyDMWritableWidget.__init__(self, init_channel=init_channel) self._has_enums = False self._checkable = True self.setLayout(QGridLayout(self)) self._btn_group = QButtonGroup() self._btn_group.setExclusive(True) self._btn_group.buttonClicked[int].connect(self.handle_button_clicked) self._widget_type = WidgetType.PushButton self._orientation = Qt.Vertical self._widgets = [] self.rebuild_widgets() def minimumSizeHint(self): """ This property holds the recommended minimum size for the widget. Returns ------- QSize """ # This is totally arbitrary, I just want *some* visible nonzero size return QSize(50, 100) @Property("QStringList") def items(self): """ Items to be displayed in the button group. This property can be overridden by the items coming from the control system. Because C++ QStringList expects a list type, we need to make sure that None is never returned. Returns ------- List[str] """ return self.enum_strings or [] @items.setter def items(self, value): self.enum_strings_changed(value) @Property(WidgetType) def widgetType(self): """ The widget type to be used when composing the group. Returns ------- WidgetType """ return self._widget_type @widgetType.setter def widgetType(self, new_type): """ The widget type to be used when composing the group. Parameters ---------- new_type : WidgetType """ if new_type != self._widget_type: self._widget_type = new_type self.rebuild_widgets() @Property(Qt.Orientation) def orientation(self): """ Whether to lay out the bit indicators vertically or horizontally. Returns ------- int """ return self._orientation @orientation.setter def orientation(self, new_orientation): """ Whether to lay out the bit indicators vertically or horizontally. Parameters ------- new_orientation : Qt.Orientation, int """ if new_orientation != self._orientation: self._orientation = new_orientation self.rebuild_layout() @Property(bool) def checkable(self): """ Whether or not the button should be checkable. Returns ------- bool """ return self._checkable @checkable.setter def checkable(self, value): if value != self._checkable: self._checkable = value for widget in self._widgets: widget.setCheckable(value) @Slot(int) def handle_button_clicked(self, id): """ Handles the event of a button being clicked. Parameters ---------- id : int The clicked button id. """ self.send_value_signal.emit(id) def clear(self): """ Remove all inner widgets from the layout """ for col in range(0, self.layout().columnCount()): for row in range(0, self.layout().rowCount()): item = self.layout().itemAtPosition(row, col) if item is not None: w = item.widget() if w is not None: self.layout().removeWidget(w) def rebuild_widgets(self): """ Rebuild the list of widgets based on a new enum or generates a default list of fake strings so we can see something at Designer. """ def generate_widgets(items): while len(self._widgets) != 0: w = self._widgets.pop(0) self._btn_group.removeButton(w) w.deleteLater() for idx, entry in enumerate(items): w = class_for_type[self._widget_type](parent=self) w.setCheckable(self.checkable) w.setText(entry) self._widgets.append(w) self._btn_group.addButton(w, idx) self.clear() if self._has_enums: generate_widgets(self.enum_strings) else: generate_widgets(["Item 1", "Item 2", "Item ..."]) self.rebuild_layout() def rebuild_layout(self): """ Method to reorganize the top-level widget and its contents according to the layout property values. """ self.clear() if self.orientation == Qt.Vertical: for i, widget in enumerate(self._widgets): self.layout().addWidget(widget, i, 0) elif self.orientation == Qt.Horizontal: for i, widget in enumerate(self._widgets): self.layout().addWidget(widget, 0, i) def check_enable_state(self): """ Checks whether or not the widget should be disable. This method also disables the widget and add a Tool Tip with the reason why it is disabled. """ status = self._write_access and self._connected and self._has_enums tooltip = "" if not self._connected: tooltip += "Channel is disconnected." elif not self._write_access: if data_plugins.is_read_only(): tooltip += "Running PyDM on Read-Only mode." else: tooltip += "Access denied by Channel Access Security." elif not self._has_enums: tooltip += "Enums not available." self.setToolTip(tooltip) self.setEnabled(status) def value_changed(self, new_val): """ Callback invoked when the Channel value is changed. Parameters ---------- new_val : int The new value from the channel. """ if new_val is not None and new_val != self.value: super(PyDMEnumButton, self).value_changed(new_val) btn = self._btn_group.button(new_val) if btn: btn.setChecked(True) def enum_strings_changed(self, new_enum_strings): """ Callback invoked when the Channel has new enum values. This callback also triggers a value_changed call so the new enum values to be broadcasted. Parameters ---------- new_enum_strings : tuple The new list of values """ if new_enum_strings is not None \ and new_enum_strings != self.enum_strings: super(PyDMEnumButton, self).enum_strings_changed(new_enum_strings) self._has_enums = True self.check_enable_state() self.rebuild_widgets() def paintEvent(self, _): """ Paint events are sent to widgets that need to update themselves, for instance when part of a widget is exposed because a covering widget was moved. At PyDMDrawing this method handles the alarm painting with parameters from the stylesheet, configures the brush, pen and calls ```draw_item``` so the specifics can be performed for each of the drawing classes. Parameters ---------- event : QPaintEvent """ painter = QPainter(self) opt = QStyleOption() opt.initFrom(self) self.style().drawPrimitive(QStyle.PE_Widget, opt, painter, self) painter.setRenderHint(QPainter.Antialiasing)
def initialize_content(self): """ Declare the validators and event connections for the widgets loaded through the .ui file. """ # Sample data # Validators self._content.transmission_edit.setValidator(QDoubleValidator(self._content.transmission_edit)) self._content.dtransmission_edit.setValidator(QDoubleValidator(self._content.dtransmission_edit)) self._content.beam_radius_edit.setValidator(QDoubleValidator(self._content.beam_radius_edit)) self._content.sample_thickness_edit.setValidator(QDoubleValidator(self._content.sample_thickness_edit)) # Connections self._content.data_file_browse_button.clicked.connect(self._data_file_browse) self._content.calculate_radio.clicked.connect(self._calculate_clicked) self._content.fix_trans_radio.clicked.connect(self._calculate_clicked) self._content.empty_button.clicked.connect(self._empty_browse) self._content.sample_button.clicked.connect(self._sample_browse) self._content.data_file_plot_button.clicked.connect(self._data_file_plot) self._content.empty_plot_button.clicked.connect(self._empty_plot) self._content.sample_plot_button.clicked.connect(self._sample_plot) # Calculate/Fix radio button g1 = QButtonGroup(self) g1.addButton(self._content.calculate_radio) g1.addButton(self._content.fix_trans_radio) g1.setExclusive(True) if not self._settings.debug: self._content.fix_transmission_layout.deleteLater() self._content.calculate_radio.hide() self._content.fix_trans_radio.hide() self._content.plus_minus_label.hide() self._content.transmission_edit.hide() self._content.dtransmission_edit.hide() if not self._has_instrument_view: self._content.data_file_plot_button.hide() self._content.empty_plot_button.hide() self._content.sample_plot_button.hide() # Background ########## # Validators self._content.bck_transmission_edit.setValidator(QDoubleValidator(self._content.bck_transmission_edit)) self._content.bck_dtransmission_edit.setValidator(QDoubleValidator(self._content.bck_dtransmission_edit)) self._content.bck_beam_radius_edit.setValidator(QDoubleValidator(self._content.beam_radius_edit)) #self._content.bck_thickness_edit.setValidator(QDoubleValidator(self._content.bck_thickness_edit)) # Connections self._content.background_chk.clicked.connect(self._background_clicked) self._content.background_browse.clicked.connect(self._background_browse) self._content.bck_calculate_radio.clicked.connect(self._bck_calculate_clicked) self._content.bck_fix_trans_radio.clicked.connect(self._bck_calculate_clicked) self._content.bck_empty_button.clicked.connect(self._bck_empty_browse) self._content.bck_sample_button.clicked.connect(self._bck_sample_browse) self._content.background_plot_button.clicked.connect(self._background_plot_clicked) self._content.bck_empty_plot_button.clicked.connect(self._bck_empty_plot) self._content.bck_sample_plot_button.clicked.connect(self._bck_sample_plot) # Calculate/Fix radio button g2 = QButtonGroup(self) g2.addButton(self._content.bck_calculate_radio) g2.addButton(self._content.bck_fix_trans_radio) g2.setExclusive(True) if not self._settings.debug: self._content.bck_fix_transmission_layout.deleteLater() self._content.bck_calculate_radio.hide() self._content.bck_fix_trans_radio.hide() self._content.bck_plus_minus_label.hide() self._content.bck_transmission_edit.hide() self._content.bck_dtransmission_edit.hide() if not self._settings.advanced: self._content.theta_dep_chk.hide() self._content.bck_theta_dep_chk.hide() self._content.sample_thickness_label.hide() self._content.sample_thickness_edit.hide() #self._content.bck_thickness_label.hide() #self._content.bck_thickness_edit.hide() if not self._has_instrument_view: self._content.background_plot_button.hide() self._content.bck_empty_plot_button.hide() self._content.bck_sample_plot_button.hide()
class BaseWindow(SiriusMainWindow): """Base class.""" def __init__(self, parent=None, prefix=_VACA_PREFIX): """Init.""" super().__init__(parent) self.prefix = prefix self._curr_dir = _os.path.abspath(_os.path.dirname(__file__)) def _setupUi(self): # menubar self.menubar = QMenuBar(self) self.menubar.setNativeMenuBar(False) self.setMenuBar(self.menubar) self.menu = self.menubar.addMenu("Open...") self._setupMenu() # auxiliar diagnostics widget self.auxdig_wid = None self._setupDiagWidget() # lattice widget self.lattice_wid = QSvgWidget( _os.path.join(self._curr_dir, self.SVG_FILE)) # screens view widget (create only one ScrnView) self._scrns_wids_dict = dict() self._currScrn = 0 scrn_wid = SiriusScrnView(parent=self, prefix=self.prefix, device=self._scrns[self._currScrn]) scrn_wid.setVisible(True) self._scrns_wids_dict[self._currScrn] = scrn_wid self.scrns_wid = QWidget() lay_scrns = QGridLayout(self.scrns_wid) lay_scrns.addWidget(scrn_wid) # correction widget self.corr_wid = QGroupBox('Screens and Correctors Panel') self._scrns_sel_bg = QButtonGroup(parent=self.corr_wid) self._scrns_sel_bg.setExclusive(True) self._setupScrnsCorrsWidget() vlay1 = QVBoxLayout() if self.auxdig_wid: vlay1.addWidget(self.auxdig_wid) vlay1.addWidget(self.scrns_wid) vlay2 = QVBoxLayout() vlay2.addWidget(self.lattice_wid) vlay2.addWidget(self.corr_wid) cw = QWidget() lay = QHBoxLayout(cw) lay.addLayout(vlay1) lay.addLayout(vlay2) self.setCentralWidget(cw) def _setupMenu(self): raise NotImplementedError def _setupScrnsCorrsWidget(self): raise NotImplementedError def _setupDiagWidget(self): raise NotImplementedError @Slot() def _setScrnWidget(self): scrn_obj = self._scrns_wids_dict[self._currScrn] scrn_obj.setVisible(False) sender = self.sender() self._currScrn = self._scrns_sel_bg.id(sender) if self._currScrn not in self._scrns_wids_dict.keys(): scrn_obj = SiriusScrnView(parent=self, prefix=self.prefix, device=self._scrns[self._currScrn]) self.scrns_wid.layout().addWidget(scrn_obj, 2, 0) self._scrns_wids_dict[self._currScrn] = scrn_obj else: scrn_obj = self._scrns_wids_dict[self._currScrn] self._scrns_wids_dict[self._currScrn].setVisible(True) def _create_headerline(self, labels): """Create and return a headerline.""" hl = QWidget() hl.setLayout(QHBoxLayout()) hl.layout().setContentsMargins(0, 9, 0, 0) glay = None for text, width in labels: if not width: if glay: hl.layout().addLayout(glay) hl.layout().addStretch() glay = QGridLayout() glay.setAlignment(Qt.AlignCenter) glay.setContentsMargins(0, 0, 0, 0) c = 0 else: label = QLabel(text, self) label.setStyleSheet(""" min-width:valueem; min-height:1.29em; max-height:1.29em; font-weight:bold; qproperty-alignment: AlignCenter; """.replace('value', str(width))) glay.addWidget(label, 0, c) c += 1 return hl def _create_scrn_summwidget(self, scrn_device, scrn_idx): """Create and return a screen detail widget.""" cb_scrn = QCheckBox(scrn_device.get_nickname(dev=True), self) self._scrns_sel_bg.addButton(cb_scrn) self._scrns_sel_bg.setId(cb_scrn, scrn_idx) if scrn_idx == self._currScrn: cb_scrn.setChecked(True) cb_scrn.clicked.connect(self._setScrnWidget) cb_scrn.setStyleSheet(""" min-width:6.5em; max-width:6.5em; font-weight:bold;""") led_camenbl = SiriusLedState( self, scrn_device.substitute(prefix=self.prefix, propty='CamEnbl-Sts')) led_camenbl.setStyleSheet("min-width:3.2em; max-width:3.2em;") cb_scrntype = PyDMEnumComboBox( self, scrn_device.substitute(prefix=self.prefix, propty='ScrnType-Sel')) cb_scrntype.setSizePolicy(QSzPlcy.Minimum, QSzPlcy.Fixed) cb_scrntype.setStyleSheet("min-width:4.5em;max-width:4.5em;") lb_scrntype = PyDMLabel( self, scrn_device.substitute(prefix=self.prefix, propty='ScrnType-Sts')) lb_scrntype.setStyleSheet("min-width:4.5em; max-width:4.5em;") lb_scrntype.setAlignment(Qt.AlignCenter) led_scrntype = PyDMLed(self, scrn_device.substitute(prefix=self.prefix, propty='ScrnType-Sts'), color_list=[ PyDMLed.LightGreen, PyDMLed.Red, PyDMLed.Red, PyDMLed.Yellow ]) led_scrntype.shape = 2 led_scrntype.setStyleSheet("""min-width:4.5em; max-width:4.5em;""") wid = QWidget() lay = QGridLayout(wid) lay.setAlignment(Qt.AlignCenter) lay.addWidget(cb_scrn, 1, 1) lay.addWidget(led_camenbl, 1, 2) lay.addWidget(cb_scrntype, 1, 3) lay.addWidget(lb_scrntype, 1, 4) lay.addWidget(led_scrntype, 2, 4) return wid def _create_corr_summwidget(self, corr): """Create and return a corrector detail widget.""" wid = QWidget() wid.setSizePolicy(QSzPlcy.Preferred, QSzPlcy.Maximum) lay = QGridLayout(wid) lay.setContentsMargins(0, 0, 0, 0) lay.setAlignment(Qt.AlignCenter) propty_sp = 'Current-SP' if corr.sec == 'LI' else 'Kick-SP' propty_mon = propty_sp.replace('SP', 'Mon') led = SiriusLedState( self, corr.substitute(prefix=self.prefix, propty='PwrState-Sts')) led.setStyleSheet("max-width:1.29em;") lay.addWidget(led, 1, 1) nickname = corr.get_nickname(sec=corr.sec == 'LI', dev=True) pb = QPushButton(nickname, self) if corr.dis == 'PU': util.connect_window(pb, PUDetailWindow, parent=self, devname=corr) else: util.connect_window(pb, PSDetailWindow, parent=self, psname=corr) pb.setStyleSheet(""" min-width:6em; max-width:6em; min-height:1.29em;""") lay.addWidget(pb, 1, 2) sp_kick = PyDMSpinboxScrollbar( self, corr.substitute(prefix=self.prefix, propty=propty_sp)) sp_kick.setStyleSheet("QDoubleSpinBox{min-width:4em; max-width:4em; }" "QScrollBar{max-width:4em;}") sp_kick.spinbox.precisionFromPV = False sp_kick.spinbox.precision = 1 sp_kick.scrollbar.limitsFromPV = True lay.addWidget(sp_kick, 1, 3, 2, 1) lb_kick = PyDMLabel( self, corr.substitute(prefix=self.prefix, propty=propty_mon)) lb_kick.setStyleSheet(""" min-width:5em; max-width:5em; min-height:1.29em;""") lb_kick.showUnits = True lb_kick.precisionFromPV = False lb_kick.precision = 1 lb_kick.setAlignment(Qt.AlignCenter) lay.addWidget(lb_kick, 1, 4) return wid
class PyDMEnumButton(QWidget, PyDMWritableWidget, WidgetType): """ A QWidget that renders buttons for every option of Enum Items. For now three types of buttons can be rendered: - Push Button - Radio Button Parameters ---------- parent : QWidget The parent widget for the Label init_channel : str, optional The channel to be used by the widget. Signals ------- send_value_signal : int, float, str, bool or np.ndarray Emitted when the user changes the value. """ Q_ENUMS(WidgetType) WidgetType = WidgetType def __init__(self, parent=None, init_channel=None): QWidget.__init__(self, parent) PyDMWritableWidget.__init__(self, init_channel=init_channel) self._has_enums = False self.setLayout(QGridLayout(self)) self._btn_group = QButtonGroup() self._btn_group.setExclusive(True) self._btn_group.buttonClicked[int].connect(self.handle_button_clicked) self._widget_type = WidgetType.PushButton self._orientation = Qt.Vertical self._widgets = [] self.rebuild_widgets() def minimumSizeHint(self): """ This property holds the recommended minimum size for the widget. Returns ------- QSize """ # This is totally arbitrary, I just want *some* visible nonzero size return QSize(50, 100) @Property(WidgetType) def widgetType(self): """ The widget type to be used when composing the group. Returns ------- WidgetType """ return self._widget_type @widgetType.setter def widgetType(self, new_type): """ The widget type to be used when composing the group. Parameters ---------- new_type : WidgetType """ if new_type != self._widget_type: self._widget_type = new_type self.rebuild_widgets() @Property(Qt.Orientation) def orientation(self): """ Whether to lay out the bit indicators vertically or horizontally. Returns ------- int """ return self._orientation @orientation.setter def orientation(self, new_orientation): """ Whether to lay out the bit indicators vertically or horizontally. Parameters ------- new_orientation : Qt.Orientation, int """ if new_orientation != self._orientation: self._orientation = new_orientation self.rebuild_layout() @Slot(int) def handle_button_clicked(self, id): """ Handles the event of a button being clicked. Parameters ---------- id : int The clicked button id. """ self.send_value_signal.emit(id) def clear(self): """ Remove all inner widgets from the layout """ for col in range(0, self.layout().columnCount()): for row in range(0, self.layout().rowCount()): item = self.layout().itemAtPosition(row, col) if item is not None: w = item.widget() if w is not None: self.layout().removeWidget(w) def rebuild_widgets(self): """ Rebuild the list of widgets based on a new enum or generates a default list of fake strings so we can see something at Designer. """ def generate_widgets(items): while len(self._widgets) != 0: w = self._widgets.pop(0) self._btn_group.removeButton(w) w.deleteLater() for idx, entry in enumerate(items): w = class_for_type[self._widget_type](parent=self) w.setCheckable(True) w.setText(entry) self._widgets.append(w) self._btn_group.addButton(w, idx) self.clear() if self._has_enums: generate_widgets(self.enum_strings) else: generate_widgets(["Item 1", "Item 2", "Item ..."]) self.rebuild_layout() def rebuild_layout(self): """ Method to reorganize the top-level widget and its contents according to the layout property values. """ self.clear() if self.orientation == Qt.Vertical: for i, widget in enumerate(self._widgets): self.layout().addWidget(widget, i, 0) elif self.orientation == Qt.Horizontal: for i, widget in enumerate(self._widgets): self.layout().addWidget(widget, 0, i) def check_enable_state(self): """ Checks whether or not the widget should be disable. This method also disables the widget and add a Tool Tip with the reason why it is disabled. """ status = self._write_access and self._connected and self._has_enums tooltip = "" if not self._connected: tooltip += "Channel is disconnected." elif not self._write_access: if data_plugins.is_read_only(): tooltip += "Running PyDM on Read-Only mode." else: tooltip += "Access denied by Channel Access Security." elif not self._has_enums: tooltip += "Enums not available." self.setToolTip(tooltip) self.setEnabled(status) def value_changed(self, new_val): """ Callback invoked when the Channel value is changed. Parameters ---------- new_val : int The new value from the channel. """ if new_val is not None and new_val != self.value: super(PyDMEnumButton, self).value_changed(new_val) btn = self._btn_group.button(new_val) if btn: btn.setChecked(True) def enum_strings_changed(self, new_enum_strings): """ Callback invoked when the Channel has new enum values. This callback also triggers a value_changed call so the new enum values to be broadcasted. Parameters ---------- new_enum_strings : tuple The new list of values """ if new_enum_strings is not None \ and new_enum_strings != self.enum_strings: super(PyDMEnumButton, self).enum_strings_changed(new_enum_strings) self._has_enums = True self.check_enable_state() self.rebuild_widgets()
class ConsoleRestartDialog(QDialog): """ Dialog to apply preferences that need a restart of the console kernel. """ # Constants for actions when Preferences require a kernel restart NO_RESTART = 1 RESTART_CURRENT = 2 RESTART_ALL = 3 def __init__(self, parent): super(ConsoleRestartDialog, self).__init__(parent) self.setWindowFlags(Qt.Dialog | Qt.WindowTitleHint) self._parent = parent self._action = self.NO_RESTART self._action_string = { self.NO_RESTART: _("Keep Existing Kernels"), self.RESTART_CURRENT: _("Restart Current Kernel"), self.RESTART_ALL: _("Restart All Kernels") } # Dialog widgets # Text self._text_label = QLabel( _("By default, some IPython console preferences will be " "applied to new consoles only. To apply preferences to " "existing consoles, select from the options below.<br><br>" "Please note: applying changes to running consoles will force" " a kernel restart and all current work will be lost."), self) self._text_label.setWordWrap(True) self._text_label.setFixedWidth(450) # Checkboxes self._restart_current = QCheckBox( _("Apply to current console and restart kernel"), self) self._restart_all = QCheckBox( _("Apply to all existing consoles and restart all kernels"), self) self._checkbox_group = QButtonGroup(self) self._checkbox_group.setExclusive(False) self._checkbox_group.addButton(self._restart_current, id=self.RESTART_CURRENT) self._checkbox_group.addButton(self._restart_all, id=self.RESTART_ALL) self._action_button = QPushButton(self._action_string[self.NO_RESTART], parent=self) # Dialog Layout layout = QVBoxLayout(self) layout.addWidget(self._text_label) layout.addSpacing(5) layout.addWidget(self._restart_current) layout.addWidget(self._restart_all) layout.addSpacing(10) layout.addWidget(self._action_button, 0, Qt.AlignRight) layout.setContentsMargins(20, 20, 20, 20) self.setLayout(layout) # Signals self._checkbox_group.buttonToggled.connect( self.update_action_button_text) self._action_button.clicked.connect(self.accept) def update_action_button_text(self, checkbox, is_checked): """ Update action button text. Takes into account the given checkbox to update the text. """ checkbox_id = self._checkbox_group.id(checkbox) if is_checked: text = self._action_string[checkbox_id] self._checkbox_group.buttonToggled.disconnect( self.update_action_button_text) self._restart_current.setChecked(False) self._restart_all.setChecked(False) checkbox.setChecked(True) self._checkbox_group.buttonToggled.connect( self.update_action_button_text) else: text = self._action_string[self.NO_RESTART] self._action_button.setText(text) def get_action_value(self): """ Return tuple indicating True or False for the available actions. """ restart_current = self._restart_current.isChecked() restart_all = self._restart_all.isChecked() no_restart = not any([restart_all, restart_current]) return restart_all, restart_current, no_restart
class QtSearchInput(QWidget): """ Qt view for SearchInput Parameters ---------- model: SearchInput """ def __init__(self, model, *args, **kwargs): self.model = model super().__init__(*args, **kwargs) self.setLayout(QFormLayout()) # Radiobuttons to quickly select default time period self.all_widget = QRadioButton("All") self.year_widget = QRadioButton("1 Year") self.month_widget = QRadioButton("30 Days") self.week_widget = QRadioButton("1 Week") self.today_widget = QRadioButton("24h") self.hour_widget = QRadioButton("1 Hour") self.radio_button_group = QButtonGroup() self.radio_button_group.addButton(self.all_widget) self.radio_button_group.addButton(self.year_widget) self.radio_button_group.addButton(self.month_widget) self.radio_button_group.addButton(self.week_widget) self.radio_button_group.addButton(self.today_widget) self.radio_button_group.addButton(self.hour_widget) default_period_layout = QGridLayout() default_period_layout.setHorizontalSpacing(85) default_period_layout.setVerticalSpacing(10) default_period_layout.addWidget(self.all_widget, 0, 0, 1, 2) default_period_layout.addWidget(self.year_widget, 1, 0, 1, 2) default_period_layout.addWidget(self.month_widget, 2, 0, 1, 2) default_period_layout.addWidget(self.week_widget, 0, 1, 1, 2) default_period_layout.addWidget(self.today_widget, 1, 1, 1, 2) default_period_layout.addWidget(self.hour_widget, 2, 1, 1, 2) self.layout().addRow("When:", default_period_layout) # TODO: rethink if restriction to acceptable timedelta values is required # from ..models.search.search_input import SearchInput # self.allowed = {timedelta(days=-1), timedelta(days=-30), timedelta(minutes=-60), timedelta(days=-7), # timedelta(days=-365)} # def time_validator(since=None, until=None): # """ # Enforce that since and until are values that a UI can represent. # This is an example similar to what will be used in the Qt UI. # """ # now = timedelta() # if isinstance(since, timedelta): # if not (until is None or until == now): # raise ValueError( # "This UI cannot express since=timedelta(...) unless until " # "is timedelta() or None." # ) # for item in allowed: # if since == item: # break # else: # # No matches # raise ValueError( # "This UI can only express since as a timedelta if it is " # f"one of {allowed}. The value {since} is not allowed" # ) # s = SearchInput() # s.time_validator = time_validator # "Since: <datetime picker>" self.since_widget = QDateTimeEdit() self.since_widget.setCalendarPopup(True) self.since_widget.setDisplayFormat("yyyy-MM-dd HH:mm") self.layout().addRow("Since:", self.since_widget) # "Until: <datetime picker>" self.until_widget = QDateTimeEdit() self.until_widget.setCalendarPopup(True) self.until_widget.setDisplayFormat("yyyy-MM-dd HH:mm") self.layout().addRow("Until:", self.until_widget) # Refresh Button self.refresh_button = QPushButton("Refresh") self.layout().addWidget(self.refresh_button) # Changes to the GUI update the model. self.since_widget.dateTimeChanged.connect(self.on_since_view_changed) self.until_widget.dateTimeChanged.connect(self.on_until_view_changed) self.refresh_button.clicked.connect(self.model.request_reload) self.model.events.reload.connect(self.on_reload) self.model.events.query.connect(self.on_reload) # Changes to the model update the GUI. self.model.events.since.connect(self.on_since_model_changed) self.model.events.until.connect(self.on_until_model_changed) # connect QRadioButtons and change date dropdowns (since/until widgets) accordingly self.hour_widget.toggled.connect(self.on_toggle_hour) self.today_widget.toggled.connect(self.on_toggle_24h) self.week_widget.toggled.connect(self.on_toggle_week) self.month_widget.toggled.connect(self.on_toggle_month) self.year_widget.toggled.connect(self.on_toggle_year) self.all_widget.toggled.connect(self.on_toggle_all) self.all_widget.setChecked(True) def on_reload(self, event): now = datetime.now(LOCAL_TIMEZONE) if isinstance(self.model.since, timedelta): with _blocked(self.since_widget): self.since_widget.setDateTime(as_qdatetime(now + self.model.since)) if isinstance(self.model.until, timedelta): with _blocked(self.until_widget): self.until_widget.setDateTime(as_qdatetime(now + self.model.until)) def on_since_view_changed(self, qdatetime): # When GUI is updated self.model.since = QDateTime.toPython(qdatetime) def on_since_model_changed(self, event): # When model is updated (e.g. from console or by clicking a QRadioButton) now = datetime.now(LOCAL_TIMEZONE) if isinstance(event.date, timedelta): qdatetime = as_qdatetime(now + event.date) if event.date == timedelta(minutes=-60): self.hour_widget.setChecked(True) elif event.date == timedelta(days=-1): self.today_widget.setChecked(True) elif event.date == timedelta(days=-7): self.week_widget.setChecked(True) elif event.date == timedelta(days=-30): self.month_widget.setChecked(True) elif event.date == timedelta(days=-365): self.year_widget.setChecked(True) else: # No checkbox associated with this custom timedelta pass else: # Must be a datetime if event.date == ADA_LOVELACE_BIRTHDAY: self.all_widget.setChecked(True) else: self.uncheck_radiobuttons() qdatetime = as_qdatetime(event.date) with _blocked(self.since_widget): self.since_widget.setDateTime(qdatetime) with _blocked(self.until_widget): self.until_widget.setDateTime(as_qdatetime(now)) def on_until_view_changed(self, qdatetime): # When GUI is updated self.model.until = QDateTime.toPython(qdatetime) def on_until_model_changed(self, event): # When model is updated (e.g. from console or by clicking a QRadioButton) if not isinstance(event.date, timedelta): qdatetime = as_qdatetime(event.date) self.uncheck_radiobuttons() with _blocked(self.until_widget): self.until_widget.setDateTime(qdatetime) def on_toggle_24h(self): if self.today_widget.isChecked(): self.model.since = timedelta(days=-1) self.model.until = timedelta() def on_toggle_hour(self): if self.hour_widget.isChecked(): self.model.since = timedelta(minutes=-60) self.model.until = timedelta() def on_toggle_week(self): if self.week_widget.isChecked(): self.model.since = timedelta(days=-7) self.model.until = timedelta() def on_toggle_month(self): if self.month_widget.isChecked(): self.model.since = timedelta(days=-30) self.model.until = timedelta() def on_toggle_year(self): if self.year_widget.isChecked(): self.model.since = timedelta(days=-365) self.model.until = timedelta() def on_toggle_all(self): # Search for all catalogs since Ada Lovelace's Birthday. if self.all_widget.isChecked(): self.model.since = ADA_LOVELACE_BIRTHDAY self.model.until = timedelta() def uncheck_radiobuttons(self): self.radio_button_group.setExclusive(False) self.all_widget.setChecked(False) self.year_widget.setChecked(False) self.month_widget.setChecked(False) self.week_widget.setChecked(False) self.today_widget.setChecked(False) self.hour_widget.setChecked(False) self.radio_button_group.setExclusive(True)
def initialize_content(self): """ Initialize the content of the frame """ # Validators self._content.low_scale_edit.setValidator(QDoubleValidator(self._content.low_scale_edit)) self._content.medium_scale_edit.setValidator(QDoubleValidator(self._content.medium_scale_edit)) self._content.high_scale_edit.setValidator(QDoubleValidator(self._content.high_scale_edit)) self._content.low_min_edit.setValidator(QDoubleValidator(self._content.low_min_edit)) self._content.low_max_edit.setValidator(QDoubleValidator(self._content.low_max_edit)) self._content.medium_min_edit.setValidator(QDoubleValidator(self._content.medium_min_edit)) self._content.medium_max_edit.setValidator(QDoubleValidator(self._content.medium_max_edit)) # Browse buttons self._content.low_q_browse_button.clicked.connect(self._low_q_browse) self._content.medium_q_browse_button.clicked.connect(self._medium_q_browse) self._content.high_q_browse_button.clicked.connect(self._high_q_browse) self._content.low_q_combo.activated.connect(self._update_low_q) self._content.medium_q_combo.activated.connect(self._update_medium_q) self._content.high_q_combo.activated.connect(self._update_high_q) # Radio buttons self._content.low_radio.clicked.connect(self._low_q_selected) self._content.medium_radio.clicked.connect(self._medium_q_selected) self._content.high_radio.clicked.connect(self._high_q_selected) # Selection buttons self._content.low_range_button.clicked.connect(self._low_range) self._content.medium_range_button.clicked.connect(self._medium_range) # Scale factors self._content.low_scale_edit.returnPressed.connect(self._update_low_scale) self._content.medium_scale_edit.returnPressed.connect(self._update_medium_scale) self._content.high_scale_edit.returnPressed.connect(self._update_high_scale) # Apply and save buttons self._content.apply_button.clicked.connect(self._apply) self._content.save_result_button.clicked.connect(self._save_result) # Create button group for data set selection g = QButtonGroup(self) g.addButton(self._content.low_radio) g.addButton(self._content.medium_radio) g.addButton(self._content.high_radio) g.setExclusive(True) self._content.low_radio.setChecked(True) self._content.low_q_combo.insertItem(0, "") self.populate_combobox(self._content.low_q_combo) self._content.low_q_combo.setEditable(True) self._content.medium_q_combo.insertItem(0, "") self.populate_combobox(self._content.medium_q_combo) self._content.medium_q_combo.setEditable(True) self._content.high_q_combo.insertItem(0, "") self.populate_combobox(self._content.high_q_combo) self._content.high_q_combo.setEditable(True) # pylint: disable = no-self-argument class ShowEventFilter(QObject): def eventFilter(obj_self, filteredObj, event): if event.type() == QEvent.HoverEnter: self.populate_combobox(filteredObj) filteredObj.update() elif event.type() == QEvent.KeyPress: if filteredObj == self._content.low_q_combo: self._low_q_modified = True elif filteredObj == self._content.medium_q_combo: self._medium_q_modified = True elif filteredObj == self._content.high_q_combo: self._high_q_modified = True if event.key() == Qt.Key_Return or event.key() == Qt.Key_Enter: filteredObj.setItemText(0, filteredObj.lineEdit().text()) if filteredObj == self._content.low_q_combo: self._update_low_q() elif filteredObj == self._content.medium_q_combo: self._update_medium_q() elif filteredObj == self._content.high_q_combo: self._update_high_q() return True return QObject.eventFilter(obj_self, filteredObj, event) eventFilter = ShowEventFilter(self) self._content.low_q_combo.installEventFilter(eventFilter) self._content.medium_q_combo.installEventFilter(eventFilter) self._content.high_q_combo.installEventFilter(eventFilter)
class PeriodicTableWidget(QWidget): selectionChanged = Signal() def __init__(self, parent=None): QWidget.__init__(self, parent) # Widgets, layouts and signals self._group = QButtonGroup() layout = QGridLayout() layout.setSpacing(0) ## Element for z, position in _ELEMENT_POSITIONS.items(): widget = ElementPushButton(z) widget.setCheckable(True) layout.addWidget(widget, *position) self._group.addButton(widget, z) ## Labels layout.addWidget(QLabel(''), 7, 0) # Dummy layout.addWidget(QLabel('*'), 5, 2, Qt.AlignRight) layout.addWidget(QLabel('*'), 8, 2, Qt.AlignRight) layout.addWidget(QLabel('**'), 6, 2, Qt.AlignRight) layout.addWidget(QLabel('**'), 9, 2, Qt.AlignRight) for row in [0, 1, 2, 3, 4, 5, 6, 8, 9]: layout.setRowStretch(row, 1) self.setLayout(layout) # Signals self._group.buttonClicked.connect(self.selectionChanged) # Default self.setColorFunction(_category_color_function) def setColorFunction(self, func): if not callable(func): raise ValueError('Not a function') self._color_function = func # Redraw for widget in self._group.buttons(): z = self._group.id(widget) bcolor = func(z) fcolor = 'white' if _calculate_brightness(bcolor) < 128 else 'black' sheet = 'background-color: %s; color: %s' % (bcolor.name(), fcolor) widget.setStyleSheet(sheet) def colorFunction(self): return self._color_function def setMultipleSelection(self, multiple): self._group.setExclusive(not multiple) def isMultipleSelection(self): return not self._group.exclusive() def setSelection(self, selection): def _uncheckedAll(): for widget in self._group.buttons(): widget.setChecked(False) if selection is None: _uncheckedAll() self.selectionChanged.emit() return if isinstance(selection, (int, six.string_types)): selection = [selection] if not self.isMultipleSelection() and len(selection) > 1: raise ValueError('Multiple selection mode is off. Cannot select more than one element') _uncheckedAll() for z in selection: if isinstance(z, six.string_types): z = get_atomic_number(z) self._group.button(z).setChecked(True) self.selectionChanged.emit() # def selection(self): selection = set() for widget in self._group.buttons(): if widget.isChecked(): selection.add(self._group.id(widget)) if self.isMultipleSelection(): return frozenset(selection) else: if len(selection) > 0: return list(selection)[0] else: return None def selectionSymbol(self): selection = self.selection() if self.isMultipleSelection(): return frozenset(map(get_symbol, selection)) else: if selection is None: return None else: return get_symbol(selection)
class WndLoadQuantitativeCalibration(SecondaryWindow): signal_quantitative_calibration_changed = Signal() def __init__(self, *, gpc, gui_vars): super().__init__() # Global processing classes self.gpc = gpc # Global GUI variables (used for control of GUI state) self.gui_vars = gui_vars self.initialize() def initialize(self): self.table_header_display_names = False self.setWindowTitle("PyXRF: Load Quantitative Calibration") self.setMinimumWidth(750) self.setMinimumHeight(400) self.resize(750, 600) self.pb_load_calib = QPushButton("Load Calibration ...") self.pb_load_calib.clicked.connect(self.pb_load_calib_clicked) self._changes_exist = False self._auto_update = True self.cb_auto_update = QCheckBox("Auto") self.cb_auto_update.setCheckState( Qt.Checked if self._auto_update else Qt.Unchecked) self.cb_auto_update.stateChanged.connect( self.cb_auto_update_state_changed) self.pb_update_plots = QPushButton("Update Plots") self.pb_update_plots.clicked.connect(self.pb_update_plots_clicked) self.grp_current_scan = QGroupBox( "Parameters of Currently Processed Scan") self._distance_to_sample = 0.0 self.le_distance_to_sample = LineEditExtended() le_dist_validator = QDoubleValidator() le_dist_validator.setBottom(0) self.le_distance_to_sample.setValidator(le_dist_validator) self._set_distance_to_sample() self.le_distance_to_sample.editingFinished.connect( self.le_distance_to_sample_editing_finished) self.le_distance_to_sample.focusOut.connect( self.le_distance_to_sample_focus_out) hbox = QHBoxLayout() hbox.addWidget(QLabel("Distance-to-sample:")) hbox.addWidget(self.le_distance_to_sample) hbox.addStretch(1) self.grp_current_scan.setLayout(hbox) self.eline_rb_exclusive = [ ] # Holds the list of groups of exclusive radio buttons self._setup_tab_widget() vbox = QVBoxLayout() hbox = QHBoxLayout() hbox.addWidget(self.pb_load_calib) hbox.addStretch(1) hbox.addWidget(self.cb_auto_update) hbox.addWidget(self.pb_update_plots) vbox.addLayout(hbox) vbox.addWidget(self.tab_widget) vbox.addWidget(self.grp_current_scan) self.setLayout(vbox) # Display data self.update_all_data() self._set_tooltips() def _setup_tab_widget(self): self.tab_widget = QTabWidget() self.loaded_standards = QWidget() # self.display_loaded_standards() self.scroll = QScrollArea() self.scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) self.scroll.setWidget(self.loaded_standards) self.tab_widget.addTab(self.scroll, "Loaded Standards") self.combo_set_table_header = QComboBox() self.combo_set_table_header.addItems( ["Standard Serial #", "Standard Name"]) self.combo_set_table_header.currentIndexChanged.connect( self.combo_set_table_header_index_changed) vbox = QVBoxLayout() vbox.addSpacing(5) hbox = QHBoxLayout() hbox.addWidget(QLabel("Display in table header:")) hbox.addWidget(self.combo_set_table_header) hbox.addStretch(1) vbox.addLayout(hbox) self.table = QTableWidget() self.table.verticalHeader().hide() self.table.setSelectionMode(QTableWidget.NoSelection) self.table.horizontalHeader().setSectionResizeMode( QHeaderView.ResizeToContents) self.table.horizontalHeader().setMinimumSectionSize(150) vbox.addWidget(self.table) self.table.setStyleSheet("QTableWidget::item{color: black;}") frame = QFrame() vbox.setContentsMargins(0, 0, 0, 0) frame.setLayout(vbox) self.tab_widget.addTab(frame, "Selected Emission Lines") def display_loaded_standards(self): calib_data = self.gpc.get_quant_calibration_data() calib_settings = self.gpc.get_quant_calibration_settings() # Create the new widget (this deletes the old widget) self.loaded_standards = QWidget() self.loaded_standards.setMinimumWidth(700) # Also delete references to all components self.frames_calib_data = [] self.pbs_view = [] self.pbs_remove = [] # All 'View' buttons are added to the group in order to be connected to the same slot self.group_view = QButtonGroup() self.group_view.setExclusive(False) self.group_view.buttonClicked.connect(self.pb_view_clicked) # The same for the 'Remove' buttons self.group_remove = QButtonGroup() self.group_remove.setExclusive(False) self.group_remove.buttonClicked.connect(self.pb_remove_clicked) vbox = QVBoxLayout() class _LabelBlack(QLabel): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.setStyleSheet("color: black") for cdata, csettings in zip(calib_data, calib_settings): frame = QFrame() frame.setFrameStyle(QFrame.StyledPanel) frame.setStyleSheet( get_background_css((200, 255, 200), widget="QFrame")) _vbox = QVBoxLayout() name = cdata["name"] # Standard name (can be arbitrary string # If name is long, then print it in a separate line _name_is_long = len(name) > 30 pb_view = QPushButton("View ...") self.group_view.addButton(pb_view) pb_remove = QPushButton("Remove") self.group_remove.addButton(pb_remove) # Row 1: serial, name serial = cdata["serial"] _hbox = QHBoxLayout() _hbox.addWidget(_LabelBlack(f"<b>Standard</b> #{serial}")) if not _name_is_long: _hbox.addWidget(_LabelBlack(f"'{name}'")) _hbox.addStretch(1) _hbox.addWidget(pb_view) _hbox.addWidget(pb_remove) _vbox.addLayout(_hbox) # Optional row if _name_is_long: # Wrap name if it is extemely long name = textwrap.fill(name, width=80) _hbox = QHBoxLayout() _hbox.addWidget(_LabelBlack("<b>Name:</b> "), 0, Qt.AlignTop) _hbox.addWidget(_LabelBlack(name), 0, Qt.AlignTop) _hbox.addStretch(1) _vbox.addLayout(_hbox) # Row 2: description description = textwrap.fill(cdata["description"], width=80) _hbox = QHBoxLayout() _hbox.addWidget(_LabelBlack("<b>Description:</b>"), 0, Qt.AlignTop) _hbox.addWidget(_LabelBlack(f"{description}"), 0, Qt.AlignTop) _hbox.addStretch(1) _vbox.addLayout(_hbox) # Row 3: incident_energy = cdata["incident_energy"] scaler = cdata["scaler_name"] detector_channel = cdata["detector_channel"] distance_to_sample = cdata["distance_to_sample"] _hbox = QHBoxLayout() _hbox.addWidget( _LabelBlack(f"<b>Incident energy, keV:</b> {incident_energy}")) _hbox.addWidget(_LabelBlack(f" <b>Scaler:</b> {scaler}")) _hbox.addWidget( _LabelBlack(f" <b>Detector channel:</b> {detector_channel}")) _hbox.addWidget( _LabelBlack( f" <b>Distance-to-sample:</b> {distance_to_sample}")) _hbox.addStretch(1) _vbox.addLayout(_hbox) # Row 4: file name fln = textwrap.fill(csettings["file_path"], width=80) _hbox = QHBoxLayout() _hbox.addWidget(_LabelBlack("<b>Source file:</b>"), 0, Qt.AlignTop) _hbox.addWidget(_LabelBlack(fln), 0, Qt.AlignTop) _hbox.addStretch(1) _vbox.addLayout(_hbox) frame.setLayout(_vbox) # Now the group box is added to the upper level layout vbox.addWidget(frame) vbox.addSpacing(5) self.frames_calib_data.append(frame) self.pbs_view.append(pb_view) self.pbs_remove.append(pb_remove) # Add the layout to the widget self.loaded_standards.setLayout(vbox) # ... and put the widget inside the scroll area. This will update the # contents of the scroll area. self.scroll.setWidget(self.loaded_standards) def display_table_header(self): calib_data = self.gpc.get_quant_calibration_data() header_by_name = self.table_header_display_names tbl_labels = ["Lines"] for n, cdata in enumerate(calib_data): if header_by_name: txt = cdata["name"] else: txt = cdata["serial"] txt = textwrap.fill(txt, width=20) tbl_labels.append(txt) self.table.setHorizontalHeaderLabels(tbl_labels) def display_standard_selection_table(self): calib_data = self.gpc.get_quant_calibration_data() self._quant_file_paths = self.gpc.get_quant_calibration_file_path_list( ) brightness = 220 table_colors = [(255, brightness, brightness), (brightness, 255, brightness)] # Disconnect all radio button signals before clearing the table for bgroup in self.eline_rb_exclusive: bgroup.buttonToggled.disconnect(self.rb_selection_toggled) # This list will hold radio button groups for horizontal rows # Those are exclusive groups. They are not going to be # used directly, but they must be kept alive in order # for the radiobuttons to work properly. Most of the groups # will contain only 1 radiobutton, which will always remain checked. self.eline_rb_exclusive = [] # The following list will contain the list of radio buttons for each # row. If there is no radiobutton in a position, then the element is # set to None. # N rows: the number of emission lines, N cols: the number of standards self.eline_rb_lists = [] self.table.clear() if not calib_data: self.table.setRowCount(0) self.table.setColumnCount(0) else: # Create the sorted list of available element lines line_set = set() for cdata in calib_data: ks = list(cdata["element_lines"].keys()) line_set.update(list(ks)) self.eline_list = list(line_set) self.eline_list.sort() for n in range(len(self.eline_list)): self.eline_rb_exclusive.append(QButtonGroup()) self.eline_rb_lists.append([None] * len(calib_data)) self.table.setColumnCount(len(calib_data) + 1) self.table.setRowCount(len(self.eline_list)) self.display_table_header() for n, eline in enumerate(self.eline_list): rgb = table_colors[n % 2] item = QTableWidgetItem(eline) item.setTextAlignment(Qt.AlignCenter) item.setFlags(item.flags() & ~Qt.ItemIsEditable) item.setBackground(QBrush(QColor(*rgb))) self.table.setItem(n, 0, item) for ns, cdata in enumerate(calib_data): q_file_path = self._quant_file_paths[ ns] # Used to identify standard if eline in cdata["element_lines"]: rb = QRadioButton() if self.gpc.get_quant_calibration_is_eline_selected( eline, q_file_path): rb.setChecked(True) rb.setStyleSheet("color: black") self.eline_rb_lists[n][ns] = rb # self.eline_rb_by_standard[ns].addButton(rb) self.eline_rb_exclusive[n].addButton(rb) item = QWidget() item_hbox = QHBoxLayout(item) item_hbox.addWidget(rb) item_hbox.setAlignment(Qt.AlignCenter) item_hbox.setContentsMargins(0, 0, 0, 0) item.setStyleSheet(get_background_css(rgb)) # Generate tooltip density = cdata["element_lines"][eline]["density"] fluorescence = cdata["element_lines"][eline][ "fluorescence"] ttip = f"Fluorescence (F): {fluorescence:12g}\nDensity (D): {density:12g}\n" # Avoid very small values of density (probably zero) if abs(density) > 1e-30: ttip += f"F/D: {fluorescence/density:12g}" item.setToolTip(ttip) self.table.setCellWidget(n, ns + 1, item) else: # There is no radio button, but we still need to fill the cell item = QTableWidgetItem("") item.setFlags(item.flags() & ~Qt.ItemIsEditable) item.setBackground(QBrush(QColor(*rgb))) self.table.setItem(n, ns + 1, item) # Now the table is set (specifically radio buttons). # So we can connect the button groups with the event processing function for bgroup in self.eline_rb_exclusive: bgroup.buttonToggled.connect(self.rb_selection_toggled) @Slot() def update_all_data(self): self.display_loaded_standards() self.display_standard_selection_table() self._set_distance_to_sample() def _set_distance_to_sample(self): """Set 'le_distance_to_sample` without updating maps""" distance_to_sample = self.gpc.get_quant_calibration_distance_to_sample( ) if distance_to_sample is None: distance_to_sample = 0.0 self._distance_to_sample = distance_to_sample self._set_le_distance_to_sample(distance_to_sample) def _set_tooltips(self): set_tooltip(self.pb_load_calib, "Load <b>calibration data</b> from JSON file.") set_tooltip( self.cb_auto_update, "Automatically <b>update the plots</b> when changes are made. " "If unchecked, then button <b>Update Plots</b> must be pressed " "to update the plots. Automatic update is often undesirable " "when large maps are displayed and multiple changes to parameters " "are made.", ) set_tooltip( self.pb_update_plots, "<b>Update plots</b> based on currently selected parameters.") set_tooltip( self.le_distance_to_sample, "Distance between <b>the sample and the detector</b>. The ratio between of the distances " "during calibration and measurement is used to scale computed concentrations. " "If distance-to-sample is 0 for calibration or measurement, then no scaling is performed.", ) set_tooltip( self.combo_set_table_header, "Use <b>Serial Number</b> or <b>Name</b> of the calibration standard in the header of the table", ) set_tooltip( self.table, "Use Radio Buttons to select the <b>source of calibration data</b> for each emission line. " "This feature is needed if multiple loaded calibration files have data on the same " "emission line.", ) def update_widget_state(self, condition=None): # Update the state of the menu bar state = not self.gui_vars["gui_state"]["running_computations"] self.setEnabled(state) # Hide the window if required by the program state state_xrf_map_exists = self.gui_vars["gui_state"][ "state_xrf_map_exists"] if not state_xrf_map_exists: self.hide() if condition == "tooltips": self._set_tooltips() def cb_auto_update_state_changed(self, state): self._auto_update = state self.pb_update_plots.setEnabled(not state) # If changes were made, apply the changes while switching to 'auto' mode if state and self._changes_exist: self._update_maps_auto() def pb_update_plots_clicked(self): self._update_maps() def pb_load_calib_clicked(self): current_dir = self.gpc.get_current_working_directory() file_name = QFileDialog.getOpenFileName( self, "Select File with Quantitative Calibration Data", current_dir, "JSON (*.json);; All (*)") file_name = file_name[0] if file_name: try: logger.debug( f"Loading quantitative calibration from file: '{file_name}'" ) self.gpc.load_quantitative_calibration_data(file_name) self.update_all_data() self._update_maps_auto() except Exception: msg = "The selected JSON file has incorrect format. Select a different file." msgbox = QMessageBox(QMessageBox.Critical, "Data Loading Error", msg, QMessageBox.Ok, parent=self) msgbox.exec() def pb_view_clicked(self, button): try: n_standard = self.pbs_view.index(button) calib_settings = self.gpc.get_quant_calibration_settings() file_path = calib_settings[n_standard]["file_path"] calib_preview = self.gpc.get_quant_calibration_text_preview( file_path) dlg = DialogViewCalibStandard(None, file_path=file_path, calib_preview=calib_preview) dlg.exec() except ValueError: logger.error( "'View' button was pressed, but not found in the list of buttons" ) def pb_remove_clicked(self, button): try: n_standard = self.pbs_remove.index(button) calib_settings = self.gpc.get_quant_calibration_settings() file_path = calib_settings[n_standard]["file_path"] self.gpc.quant_calibration_remove_entry(file_path) self.update_all_data() self._update_maps_auto() except ValueError: logger.error( "'Remove' button was pressed, but not found in the list of buttons" ) def rb_selection_toggled(self, button, checked): if checked: # Find the button in 2D list 'self.eline_rb_lists' button_found = False for nr, rb_list in enumerate(self.eline_rb_lists): try: nc = rb_list.index(button) button_found = True break except ValueError: pass if button_found: eline = self.eline_list[nr] n_standard = nc file_path = self._quant_file_paths[n_standard] self.gpc.set_quant_calibration_select_eline(eline, file_path) self._update_maps_auto() else: # This should never happen logger.error( "Selection radio button was pressed, but not found in the list" ) def combo_set_table_header_index_changed(self, index): self.table_header_display_names = bool(index) self.display_table_header() def le_distance_to_sample_editing_finished(self): distance_to_sample = float(self.le_distance_to_sample.text()) if distance_to_sample != self._distance_to_sample: self._distance_to_sample = distance_to_sample self.gpc.set_quant_calibration_distance_to_sample( distance_to_sample) self._update_maps_auto() def le_distance_to_sample_focus_out(self): try: float(self.le_distance_to_sample.text()) except ValueError: # If the text can not be interpreted to float, then replace the text with the old value self._set_le_distance_to_sample(self._distance_to_sample) def _set_le_distance_to_sample(self, distance_to_sample): self.le_distance_to_sample.setText(f"{distance_to_sample:.12g}") def _update_maps_auto(self): """Update maps only if 'auto' update is ON. Used as a 'filter' to prevent extra plot updates.""" self._changes_exist = True if self._auto_update: self._update_maps() def _update_maps(self): """Upload the selections (limit table) and update plot""" self._changes_exist = False self._redraw_maps() # Emit signal only after the maps are redrawn. This should change # ranges in the respective controls for the plots self.signal_quantitative_calibration_changed.emit() def _redraw_maps(self): # We don't emit any signals here, but we don't really need to. logger.debug("Redrawing RGB XRF Maps") self.gpc.compute_map_ranges() self.gpc.redraw_maps() self.gpc.compute_rgb_map_ranges() self.gpc.redraw_rgb_maps()