def __init__(self, *args, **kwargs): super(MessageCheckBox, self).__init__(*args, **kwargs) self.setWindowModality(Qt.NonModal) self._checkbox = QCheckBox(self) # Set layout to include checkbox size = 9 check_layout = QVBoxLayout() check_layout.addItem(QSpacerItem(size, size)) check_layout.addWidget(self._checkbox, 0, Qt.AlignRight) check_layout.addItem(QSpacerItem(size, size)) # Access the Layout of the MessageBox to add the Checkbox layout = self.layout() if PYQT5: layout.addLayout(check_layout, 1, 2) else: layout.addLayout(check_layout, 1, 1)
def __init__(self, workflowview: QAbstractItemView, operation_filter: Callable[[OperationPlugin], bool] = None): super(WorkflowWidget, self).__init__() self.operation_filter = operation_filter self.view = workflowview self.autorun_checkbox = QCheckBox("Run Automatically") self.autorun_checkbox.setCheckState(Qt.Unchecked) self.autorun_checkbox.stateChanged.connect(self._autorun_state_changed) self.run_button = QPushButton("Run Workflow") self.run_button.clicked.connect(self.sigRunWorkflow.emit) self.view.model().workflow.attach(self._autorun) # TODO -- actually hook up the auto run OR dependent class needs to connect (see SAXSGUIPlugin) self.toolbar = QToolBar() self.addfunctionmenu = QToolButton() self.addfunctionmenu.setIcon(QIcon(path("icons/addfunction.png"))) self.addfunctionmenu.setText("Add Function") # Defer menu population to once the plugins have been loaded; otherwise, the menu may not contain anything # if this widget is init'd before all plugins have been loaded. self.functionmenu = QMenu() self.functionmenu.aboutToShow.connect(self.populateFunctionMenu) self.addfunctionmenu.setMenu(self.functionmenu) self.addfunctionmenu.setPopupMode(QToolButton.InstantPopup) self.toolbar.addWidget(self.addfunctionmenu) # self.toolbar.addAction(QIcon(path('icons/up.png')), 'Move Up') # self.toolbar.addAction(QIcon(path('icons/down.png')), 'Move Down') self.toolbar.addAction(QIcon(path("icons/folder.png")), "Load Workflow") self.toolbar.addAction(QIcon(path("icons/trash.png")), "Delete Operation", self.deleteOperation) v = QVBoxLayout() v.addWidget(self.view) h = QHBoxLayout() h.addWidget(self.autorun_checkbox) h.addWidget(self.run_button) v.addLayout(h) v.addWidget(self.toolbar) v.setContentsMargins(0, 0, 0, 0) self.setLayout(v)
def event(self, event: QEvent) -> bool: if event.type() == QEvent.WindowActivate: self.channel_select.change_channels_num(self.settings.image.channels) selected = self._clean_measurements() for val in MEASUREMENT_DICT.values(): area = val.get_starting_leaf().area pc = val.get_starting_leaf().per_component if ( val.get_fields() or (area is not None and area != AreaType.ROI) or (pc is not None and pc != PerComponent.Yes) ): continue text = val.get_name() chk = QCheckBox(text) if text in selected: chk.setChecked(True) self.measurement_layout.addWidget(chk) return super().event(event)
def createTopLeftGroupBox(self): self.topLeftGroupBox = QGroupBox("Group 1") radioButton1 = QRadioButton("Radio button 1") radioButton2 = QRadioButton("Radio button 2") radioButton3 = QRadioButton("Radio button 3") radioButton1.setChecked(True) checkBox = QCheckBox("Tri-state check box") checkBox.setTristate(True) checkBox.setCheckState(Qt.PartiallyChecked) layout = QVBoxLayout() layout.addWidget(radioButton1) layout.addWidget(radioButton2) layout.addWidget(radioButton3) layout.addWidget(checkBox) layout.addStretch(1) self.topLeftGroupBox.setLayout(layout)
def setup_toolbar(self): """Set up toolbar.""" self.addToolBar(self.toolbar) self.toolbar.setMovable(False) self.toolbar.setFloatable(False) self.toolbar.setStyleSheet( "QToolButton {{height:{30}px;width:{30}px;}}") self.new_btn = create_toolbutton(self, qta.icon("mdi.new-box", color=ICON_COLOR), "Start new game.", triggered=self.new_game) self.toolbar.addWidget(self.new_btn) self.toolbar.addSeparator() self.clear_btn = create_toolbutton(self, qta.icon("fa5s.eraser", color=ICON_COLOR), "Click을 초기화 한다.", triggered=self.show_puzzle) self.toolbar.addWidget(self.clear_btn) self.toolbar.addSeparator() self.n_lights_1axis_spinbox = QSpinBox(self) self.n_lights_1axis_spinbox.setValue(4) self.n_lights_1axis_spinbox.setRange(2, 10) self.n_lights_1axis_spinbox.setAlignment(Qt.AlignRight) self.n_lights_1axis_spinbox.setToolTip( "Set Number of light in 1 axis.") self.toolbar.addWidget(self.n_lights_1axis_spinbox) self.toolbar.addSeparator() self.show_solution_chkbox = QCheckBox("Solution", self) self.show_solution_chkbox.setStyleSheet(""" background : "#32414B" """) self.show_solution_chkbox.setToolTip("Show the solution.") self.show_solution_chkbox.stateChanged.connect(self.show_solution) self.toolbar.addWidget(self.show_solution_chkbox) self.toolbar.addSeparator() self.toolbar.adjustSize()
def __init__(self, settings: StackSettings, parent=None): """:type settings: ImageSettings""" super().__init__(parent) self._settings = settings self.path = QTextEdit("<b>Path:</b> example image") self.path.setWordWrapMode(QTextOption.WrapAnywhere) self.path.setReadOnly(True) self.setMinimumHeight(20) self.spacing = [QDoubleSpinBox() for _ in range(3)] self.multiple_files = QCheckBox("Show multiple files panel") self.multiple_files.setChecked( settings.get("multiple_files_widget", True)) self.multiple_files.stateChanged.connect(self.set_multiple_files) units_value = self._settings.get("units_value", Units.nm) for el in self.spacing: el.setAlignment(Qt.AlignRight) el.setButtonSymbols(QAbstractSpinBox.NoButtons) el.setRange(0, 100000) # noinspection PyUnresolvedReferences el.valueChanged.connect(self.image_spacing_change) self.units = QEnumComboBox(enum_class=Units) self.units.setCurrentEnum(units_value) # noinspection PyUnresolvedReferences self.units.currentIndexChanged.connect(self.update_spacing) self.add_files = AddFiles(settings, btn_layout=FlowLayout) spacing_layout = QFormLayout() spacing_layout.addRow("x:", self.spacing[0]) spacing_layout.addRow("y:", self.spacing[1]) spacing_layout.addRow("z:", self.spacing[2]) spacing_layout.addRow("Units:", self.units) layout = QVBoxLayout() layout.addWidget(self.path) layout.addWidget(QLabel("Image spacing:")) layout.addLayout(spacing_layout) layout.addWidget(self.add_files) layout.addStretch(1) layout.addWidget(self.multiple_files) self.setLayout(layout) self._settings.image_changed[str].connect(self.set_image_path)
def __init__( self, layer: OctreeImage, on_set_level: IntCallback, on_set_track: IntCallback, ): super().__init__() self.level = QtLevelCombo(layer.num_octree_levels, on_set_level) self.addLayout(self.level) self.track = QCheckBox("Track View") self.track.stateChanged.connect(on_set_track) self.track.setChecked(layer.track_view) self.addWidget(self.track) self.table = QtSimpleTable() self.addWidget(self.table) self.set_layout(layer) # Initial settings.
def __init__(self): super().__init__() label = QLabel("Terms And Conditions") listwidget = QListWidget() list = [] for i in range(1,20): list.append("This Is Terms and Conditions") listwidget.insertItems(0,list) checkbox = QCheckBox("Agree The Terms And Conditions") layout = QVBoxLayout() layout.addWidget(label) layout.addWidget(listwidget) layout.addWidget(checkbox) self.setLayout(layout)
def __init__(self, dims, axis, reverse=False, fps=10, mode=LoopMode.LOOP): super().__init__() self.dims = dims self.axis = axis self.reverse = reverse self.fps = fps self.mode = mode self.setProperty('reverse', str(reverse)) # for styling self.setProperty('playing', 'False') # for styling # build popup modal form self.popup = QtPopup(self) form_layout = QFormLayout() self.popup.frame.setLayout(form_layout) fpsspin = QtCustomDoubleSpinBox(self.popup) fpsspin.setObjectName("fpsSpinBox") fpsspin.setAlignment(Qt.AlignCenter) fpsspin.setValue(self.fps) if hasattr(fpsspin, 'setStepType'): # this was introduced in Qt 5.12. Totally optional, just nice. fpsspin.setStepType(QDoubleSpinBox.AdaptiveDecimalStepType) fpsspin.setMaximum(500) fpsspin.setMinimum(0) form_layout.insertRow(0, QLabel('frames per second:', parent=self.popup), fpsspin) self.fpsspin = fpsspin revcheck = QCheckBox(self.popup) revcheck.setObjectName("playDirectionCheckBox") form_layout.insertRow(1, QLabel('play direction:', parent=self.popup), revcheck) self.reverse_check = revcheck mode_combo = QComboBox(self.popup) mode_combo.addItems([str(i).replace('_', ' ') for i in LoopMode]) form_layout.insertRow(2, QLabel('play mode:', parent=self.popup), mode_combo) mode_combo.setCurrentText(str(self.mode)) self.mode_combo = mode_combo
def __init__(self, *args, **kwargs): super(QuitApplicationDialog, self).__init__(*args, **kwargs) self.label_icon = QLabel() self.label_about = QLabel('Quit Anaconda Navigator?') self.button_ok = QPushButton('Yes') self.button_cancel = ButtonCancel('No') self.buttonbox = QDialogButtonBox(Qt.Horizontal) self.checkbox = QCheckBox("Don't show again") # Widget setup if CONF.get('main', 'hide_quit_dialog'): hide_dialog = Qt.Checked else: hide_dialog = Qt.Unchecked self.checkbox.setChecked(hide_dialog) self.buttonbox.addButton(self.button_ok, QDialogButtonBox.ActionRole) self.buttonbox.addButton(self.button_cancel, QDialogButtonBox.ActionRole) self.label_icon.setPixmap(QPixmap(images.ANACONDA_ICON_64_PATH)) self.setWindowTitle("Quit application") # Layouts h_layout = QHBoxLayout() h_layout.addWidget(self.label_icon, 0, Qt.AlignTop) h_layout.addSpacing(10) h_layout.addWidget(self.label_about) main_layout = QVBoxLayout() main_layout.addLayout(h_layout) main_layout.addWidget(self.checkbox, 0, Qt.AlignRight) main_layout.addSpacing(24) main_layout.addWidget(self.buttonbox) self.setLayout(main_layout) # Signals self.button_ok.clicked.connect(self.accept) self.button_cancel.clicked.connect(self.reject) # Setup self.update_style_sheet()
def set_check_box(self, row, col, state): """ function to add a new select checkbox to a cell in a table row won't add a new checkbox if one already exists """ # Check input assert isinstance(state, bool) # Check if cellWidget exists if self.cellWidget(row, col): # existing: just set the value self.cellWidget(row, col).setChecked(state) else: # case to add checkbox checkbox = QCheckBox() checkbox.setText('') checkbox.setChecked(state) # Adding a widget which will be inserted into the table cell # then centering the checkbox within this widget which in turn, # centers it within the table column :-) self.setCellWidget(row, col, checkbox)
def _get_renderer_widget(renderer: Renderer) -> QWidget: widget = QWidget() layout = QVBoxLayout() # axes def _axes_callback(state: bool) -> None: if state: renderer.show_axes() else: renderer.hide_axes() axes = QCheckBox("Axes") if hasattr(renderer, "axes_widget"): axes.setChecked(renderer.axes_widget.GetEnabled()) else: axes.setChecked(False) axes.toggled.connect(_axes_callback) layout.addWidget(axes) widget.setLayout(layout) return widget
def create_checkbox(self, label, option, check=None, hint=None, info=None): """Create checkbox preference option.""" widget = QCheckBox() widget.get_value = lambda w=widget: bool(w.checkState()) widget.set_value = lambda value, w=widget: bool( w.setCheckState(Qt.Checked if value else Qt.Unchecked) ) api_widget = self.widgets_dic['anaconda_api_url'] widget.set_warning = lambda w=widget: api_widget widget.stateChanged.connect( lambda v=None, w=widget: self.options_changed(widget=w) ) self.create_widget( widget=widget, option=option, label=label, hint=hint, check=check, info=info, )
def create_checkbox(self, text, option, default=NoDefault, tip=None, msg_warning=None, msg_info=None, msg_if_enabled=False, section=None, restart=False): checkbox = QCheckBox(text) self.checkboxes[checkbox] = (section, option, default) if section is not None and section != self.CONF_SECTION: self.cross_section_options[option] = section if tip is not None: checkbox.setToolTip(tip) if msg_warning is not None or msg_info is not None: def show_message(is_checked=False): if is_checked or not msg_if_enabled: if msg_warning is not None: QMessageBox.warning(self, self.get_name(), msg_warning, QMessageBox.Ok) if msg_info is not None: QMessageBox.information(self, self.get_name(), msg_info, QMessageBox.Ok) checkbox.clicked.connect(show_message) checkbox.restart_required = restart return checkbox
def __init__(self, colormap: Colormap, accepted: bool, name: str, removable: bool = False, used: bool = False): super().__init__() self.image = convert_colormap_to_image(colormap) self.name = name self.removable = removable self.checked = QCheckBox() self.checked.setChecked(accepted) self.checked.setDisabled(used) self.label = QLabel(name) self.label.setFixedWidth(150) self.setMinimumWidth(80) metrics = QFontMetrics(QFont()) layout = QHBoxLayout() layout.addWidget(self.checked) layout.addStretch(1) self.remove_btn = QToolButton() self.remove_btn.setIcon(_icon_selector.close_icon) if removable: self.remove_btn.setToolTip("Remove colormap") else: self.remove_btn.setToolTip("This colormap is protected") self.remove_btn.setEnabled(not accepted and self.removable) self.edit_btn = QToolButton() self.edit_btn.setIcon(_icon_selector.edit_icon) layout.addWidget(self.remove_btn) layout.addWidget(self.edit_btn) layout.addWidget(self.label) self.setLayout(layout) self.checked.stateChanged.connect(self._selection_changed) self.edit_btn.clicked.connect(partial(self.edit_request.emit, name)) if len(colormap.controls) < 20: self.edit_btn.clicked.connect(partial(self.edit_request[Colormap].emit, colormap)) self.edit_btn.setToolTip("Create colormap base on this") else: self.edit_btn.setDisabled(True) self.edit_btn.setToolTip("This colormap is not editable") self.remove_btn.clicked.connect(partial(self.remove_request.emit, name)) self.setMinimumHeight(max(metrics.height(), self.edit_btn.minimumHeight(), self.checked.minimumHeight()) + 20) self.setToolTip(self.name)
def __init__(self, settings: BaseSettings, load_dict: Dict[str, LoadBase], compare_in_context_menu=False): super().__init__() self.settings = settings self.state_dict: Dict[str, Dict[str, ProjectInfoBase]] = defaultdict(dict) self.state_dict_count = Counter() self.file_list = [] self.load_register = load_dict self.file_view = CustomTreeWidget(compare_in_context_menu) self.file_view.header().close() self.save_state_btn = QPushButton("Save state") self.save_state_btn.setStyleSheet("QPushButton{font-weight: bold;}") self.load_files_btn = QPushButton("Load Files") self.forget_btn = QPushButton("Forget") self.save_state_btn.clicked.connect(self.save_state) self.forget_btn.clicked.connect(self.forget) self.load_files_btn.clicked.connect(self.load_files) self.file_view.itemDoubleClicked.connect(self.load_state) self.file_view.context_load.connect(self.load_state) self.last_point = None self.custom_names_chk = QCheckBox("Custom names") layout = QGridLayout() layout.addWidget(self.file_view, 0, 0, 1, 2) layout.addWidget(self.save_state_btn, 1, 0, 1, 2) layout.addWidget(self.load_files_btn, 2, 0) layout.addWidget(self.forget_btn, 2, 1) layout.addWidget(self.custom_names_chk, 3, 0, 1, 2) self.setLayout(layout) self.setMouseTracking(True) self.file_view.setMouseTracking(True) self.file_view.context_load.connect(self.load_state) self.file_view.context_compare.connect(self.load_compare) self.file_view.context_forget.connect(self.forget_action) self.error_list = [] self._add_state.connect(self.save_state_action) self.settings.data_changed.connect(self.view_changed)
def __init__(self, parent, items): super().__init__() self.parent = parent lexeme, lexicalEntry, morphologyString, translations = items # morphology items morphologyLayout = QVBoxLayout() morphologyLayout.setContentsMargins(0, 0, 0, 0) lexemeLabel = QLabel(lexeme) morphologyLayout.addWidget(lexemeLabel) self.checkBoxes = [] self.morphologyList = morphologyString.split(",") for counter, value in enumerate(self.morphologyList[:-1]): self.checkBoxes.append(QCheckBox(value)) morphologyLayout.addWidget(self.checkBoxes[counter]) # Two buttons buttonsLayout = QHBoxLayout() self.searchButton = QPushButton("&{0}".format( config.thisTranslation["menu5_search"])) self.searchButton.clicked.connect( lambda: self.searchMorphology(lexicalEntry)) buttonsLayout.addWidget(self.searchButton) self.cancelButton = QPushButton("&{0}".format( config.thisTranslation["message_cancel"])) self.cancelButton.clicked.connect(self.close) buttonsLayout.addWidget(self.cancelButton) # options to search morphology in combination with interlinear translations self.interlinearCombo = CheckableComboBox(translations, []) # set main layout & title mainLayout = QVBoxLayout() mainLayout.addLayout(morphologyLayout) mainLayout.addWidget(self.interlinearCombo) mainLayout.addLayout(buttonsLayout) self.setLayout(mainLayout) self.setWindowTitle(config.thisTranslation["message_searchMorphology"])
def _setup_load_group(self): self.group_file = QGroupBox("Load Data") self.pb_file = QPushButton("Read File ...") self.pb_file.clicked.connect(self.pb_file_clicked) self.pb_dbase = QPushButton("Load Run ...") self.pb_dbase.setEnabled( self.gui_vars["gui_state"]["databroker_available"]) self.pb_dbase.clicked.connect(self.pb_dbase_clicked) self.cb_file_all_channels = QCheckBox("All channels") self.cb_file_all_channels.setChecked(self.gpc.get_load_each_channel()) self.cb_file_all_channels.toggled.connect( self.cb_file_all_channels_toggled) self.le_file_default = "No data is loaded" self.le_file = LineEditReadOnly(self.le_file_default) self.pb_view_metadata = QPushButton("View Metadata ...") self.pb_view_metadata.setEnabled(False) self.pb_view_metadata.clicked.connect(self.pb_view_metadata_clicked) vbox = QVBoxLayout() hbox = QHBoxLayout() hbox.addWidget(self.pb_file) hbox.addWidget(self.pb_dbase) hbox.addWidget(self.cb_file_all_channels) vbox.addLayout(hbox) vbox.addWidget(self.le_file) hbox = QHBoxLayout() hbox.addStretch(1) hbox.addWidget(self.pb_view_metadata) vbox.addLayout(hbox) self.group_file.setLayout(vbox)
def connect_to_viewer(viewer): """ Add all gui elements to the viewer """ save_gui_btn = QPushButton("save annotations [shift + s]") save_gui_btn.clicked.connect(lambda: _save_labels(viewer)) update_gui_btn = QPushButton("update layers [u]") update_gui_btn.clicked.connect(lambda: update_layers(viewer)) def hide_toggle(hide_gui_btn, viewer): hide = viewer.layers['cell-segmentation'].metadata['hide_annotated_segments'] if hide_gui_btn.isChecked() != hide: toggle_hide_annotated_segments(viewer) hide_gui_btn = QCheckBox("hide annotated cells [h]") hide_gui_btn.toggled.connect(lambda: hide_toggle(hide_gui_btn, viewer)) viewer._hide_gui_btn = hide_gui_btn paint_gui_btn = QPushButton("get next label [n]") paint_gui_btn.clicked.connect(lambda: paint_new_label(viewer)) # make a tooltop about the label colors tooltip = QLabel() # TODO see if we can get this working im_file = os.path.join(os.path.split(__file__)[0], "images", "placeholder.png") if os.path.exists(im_file): qimage = None tooltip.setPicture(qimage) else: qtext = "<b>Labels:</b>" qtext += "<br><font color='white'>Unlabeled</font> <br> <font color='red'>Infected</font>" qtext += "<br><font color='cyan'>Control</font> <br> <font color='yellow'>Uncertain</font>" tooltip.setText(qtext) viewer.window.add_dock_widget( [tooltip, update_gui_btn, hide_gui_btn, paint_gui_btn, save_gui_btn], area="right", allowed_areas=["right", "left"], )
def __init__(self, item: QListWidgetItem, parent: QWidget = None): super().__init__(parent) self.item = item self.opacity = QGraphicsOpacityEffect(self) self.setGraphicsEffect(self.opacity) layout = QHBoxLayout() self.setLayout(layout) self.position_label = QLabel() self.update_position_label() self.setToolTip(trans._("Click and drag to change call order")) self.plugin_name_label = ElidingLabel(parent=self) self.plugin_name_label.setObjectName('small_text') self.plugin_name_label.setText(item.hook_implementation.plugin_name) plugin_name_size_policy = QSizePolicy( QSizePolicy.MinimumExpanding, QSizePolicy.Preferred ) plugin_name_size_policy.setHorizontalStretch(2) self.plugin_name_label.setSizePolicy(plugin_name_size_policy) self.function_name_label = QLabel( item.hook_implementation.function.__name__ ) self.enabled_checkbox = QCheckBox(self) self.enabled_checkbox.setToolTip( trans._("Uncheck to disable this plugin") ) self.enabled_checkbox.stateChanged.connect(self._set_enabled) self.enabled_checkbox.setChecked( getattr(item.hook_implementation, 'enabled', True) ) layout.addWidget(self.position_label) layout.addWidget(self.enabled_checkbox) layout.addWidget(self.function_name_label) layout.addWidget(self.plugin_name_label) layout.setStretch(2, 1) layout.setContentsMargins(0, 0, 0, 0)
def __init__(self, parent): super().__init__(parent) self.setWindowTitle("Interpolate bad channels") vbox = QVBoxLayout(self) grid = QGridLayout() grid.addWidget(QLabel("Reset bads:"), 0, 0) self.reset_bads_checkbox = QCheckBox() self.reset_bads_checkbox.setChecked(True) grid.addWidget(self.reset_bads_checkbox, 0, 1) grid.addWidget(QLabel("Mode:"), 1, 0) self.mode_select = QComboBox() self.modes = {"Accurate": "accurate", "Fast": "fast"} self.mode_select.addItems(self.modes.keys()) self.mode_select.setCurrentText("Accurate") grid.addWidget(self.mode_select, 1, 1) grid.addWidget(QLabel("Origin (x, y, z):"), 2, 0) hbox = QHBoxLayout() self.x = QDoubleSpinBox() self.x.setValue(0) self.x.setDecimals(3) hbox.addWidget(self.x) self.y = QDoubleSpinBox() self.y.setValue(0) self.y.setDecimals(3) hbox.addWidget(self.y) self.z = QDoubleSpinBox() self.z.setValue(0.04) self.z.setDecimals(3) hbox.addWidget(self.z) grid.addLayout(hbox, 2, 1) vbox.addLayout(grid) buttonbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) vbox.addWidget(buttonbox) buttonbox.accepted.connect(self.accept) buttonbox.rejected.connect(self.reject) vbox.setSizeConstraint(QVBoxLayout.SetFixedSize)
def get_widgets(self): widgets = list() sz_polc = QSzPlcy(QSzPlcy.Fixed, QSzPlcy.Fixed) for idx, name in enumerate(self.BPM_NAMES): wid = QWidget(self.parent()) tooltip = '{0}; Pos = {1:5.1f} m'.format(self.BPM_NICKNAMES[idx], self.BPM_POS[idx]) if self.propty: item = SiriusLedState(self) item.setParent(wid) item.setSizePolicy(sz_polc) item.setToolTip(tooltip) pvname = SiriusPVName.from_sp2rb( name.substitute(prefix=self.prefix, propty=self.propty)) item.channel = pvname else: item = QCheckBox(self) item.setSizePolicy(sz_polc) hbl = QHBoxLayout(wid) hbl.setContentsMargins(0, 0, 0, 0) hbl.addWidget(item) widgets.append(wid) return widgets
def __init__(self, plot, *args, **kwargs): super().__init__(*args, **kwargs) self.plot = plot ly = QGridLayout() # remove annoying padding ly.setContentsMargins(0, 0, 0, 0) self.setLayout(ly) self.label = QLabel('Binning:') ly.addWidget(self.label, 0, 0) self.auto = QCheckBox('auto', checked=False) ly.addWidget(self.auto, 0, 1) self.spinbox = QSpinBox() ly.addWidget(self.spinbox, 1, 0, 1, 2) self.spinbox.setRange(1, 100000) self.spinbox.setValue(10) self.spinbox.valueChanged.connect(self._on_binning_change) self.auto.clicked.connect(self._on_auto_change) self.auto.click()
def __init__(self, parent=None): super(ProbeSim, self).__init__(parent=parent) self.info = Info() self.log = Log self.close_button = QPushButton("Touch") self.pulse_checkbox = QCheckBox("Pulse") main_layout = QVBoxLayout() main_layout.addWidget(self.close_button) main_layout.addWidget(self.pulse_checkbox) self.setLayout(main_layout) self.setWindowTitle("Simulate touch probe") self.close_button.pressed.connect(self.touch_on) self.close_button.released.connect(self.touch_off) self.timer = QTimer() self.timer.timeout.connect(self.pulse_off) self.timer.setSingleShot(True)
def __init__(self, item: QListWidgetItem, parent: QWidget = None): super().__init__(parent) self.setToolTip("Click and drag to change call order") self.item = item self.opacity = QGraphicsOpacityEffect(self) self.setGraphicsEffect(self.opacity) layout = QHBoxLayout() self.setLayout(layout) self.position_label = QLabel() self.update_position_label() self.plugin_name_label = QLabel(item.hook_implementation.plugin_name) self.enabled_checkbox = QCheckBox(self) self.enabled_checkbox.setToolTip("Uncheck to disable this plugin") self.enabled_checkbox.stateChanged.connect(self._set_enabled) self.enabled_checkbox.setChecked( getattr(item.hook_implementation, 'enabled', True)) layout.addWidget(self.position_label) layout.addWidget(self.enabled_checkbox) layout.addWidget(self.plugin_name_label) layout.setStretch(2, 1) layout.setContentsMargins(0, 0, 0, 0)
def _get_field_from_value_type(cls, ap: AlgorithmProperty): if issubclass(ap.value_type, Channel): res = ChannelComboBox() res.change_channels_num(10) elif issubclass(ap.value_type, AlgorithmDescribeBase): res = SubAlgorithmWidget(ap) elif issubclass(ap.value_type, bool): res = QCheckBox() elif issubclass(ap.value_type, (float, int)): res = cls._get_numeric_field(ap) elif issubclass(ap.value_type, Enum): # noinspection PyTypeChecker res = QEnumComboBox(enum_class=ap.value_type) elif issubclass(ap.value_type, str): res = QLineEdit() elif issubclass(ap.value_type, ROIExtractionProfile): res = ProfileSelect() elif issubclass(ap.value_type, list): res = QComboBox() res.addItems(list(map(str, ap.possible_values))) else: res = create_widget(annotation=ap.value_type, options={}) return res
def __init__(self, parent=None): QDialog.__init__( self, parent, flags=Qt.WindowSystemMenuHint | Qt.WindowTitleHint) self.setWindowTitle('Write Model') self.treeview = parent self.setAttribute(Qt.WA_DeleteOnClose) fixed_dir_layout = QHBoxLayout() browse_btn = QPushButton(ima.icon('DirOpenIcon'), '', self) browse_btn.setToolTip(_("Select model directory")) browse_btn.clicked.connect(self.select_directory) self.wd_edit = QLineEdit() fixed_dir_layout.addWidget(self.wd_edit) fixed_dir_layout.addWidget(browse_btn) fixed_dir_layout.setContentsMargins(0, 0, 0, 0) namelabel = QLabel(_("Folder Name")) self.nameEdit = QLineEdit(self) self.backupCheck = QCheckBox(_("Back up old folder")) self.backupCheck.setCheckState(Qt.Checked) self.buttonBox = QDialogButtonBox(self) self.buttonBox.setOrientation(Qt.Horizontal) self.buttonBox.setStandardButtons( QDialogButtonBox.Cancel|QDialogButtonBox.Ok) self.buttonBox.accepted.connect(self.accept) self.buttonBox.rejected.connect(self.reject) mainLayout = QGridLayout(self) mainLayout.addLayout(fixed_dir_layout, 0, 0, 1, 2) mainLayout.addWidget(namelabel, 1, 0) mainLayout.addWidget(self.nameEdit, 1, 1) mainLayout.addWidget(self.backupCheck, 2, 0, 1, 2) mainLayout.addWidget(self.buttonBox, 3, 0, 1, 2) # mainLayout.setContentsMargins(0, 0, 0, 0) self.setLayout(mainLayout)
def __init__(self, *args) -> None: """Type name: "DXF module".""" super(DxfOutputDialog, self).__init__( "DXF", "dxf.png", "The part sketchs will including in the file.", "There is only wire frame will be generated.", *args ) # DXF version option. version_label = QLabel("DXF version:", self) self.version_option = QComboBox(self) self.version_option.addItems(sorted(( f"{name} - {DXF_VERSIONS_MAP[name]}" for name in DXF_VERSIONS ), key=lambda v: v.split()[-1])) self.version_option.setCurrentIndex(self.version_option.count() - 1) self.version_option.setSizePolicy(QSizePolicy( QSizePolicy.Expanding, QSizePolicy.Fixed )) dxf_version_layout = QHBoxLayout() dxf_version_layout.addWidget(version_label) dxf_version_layout.addWidget(self.version_option) self.main_layout.insertLayout(3, dxf_version_layout) # Parts interval. self.interval_enable = QCheckBox("Parts interval:", self) self.interval_enable.setCheckState(Qt.Checked) self.interval_option = QDoubleSpinBox(self) self.interval_option.setValue(10) self.interval_enable.stateChanged.connect(self.interval_option.setEnabled) dxf_interval_layout = QHBoxLayout() dxf_interval_layout.addWidget(self.interval_enable) dxf_interval_layout.addItem( QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum) ) dxf_interval_layout.addWidget(self.interval_option) self.assembly_layout.insertLayout(2, dxf_interval_layout)
def __init__(self, parent, data, readonly=False, xlabels=None, ylabels=None): QWidget.__init__(self, parent) self.data = data self.old_data_shape = None if len(self.data.shape) == 1: self.old_data_shape = self.data.shape self.data.shape = (self.data.shape[0], 1) elif len(self.data.shape) == 0: self.old_data_shape = self.data.shape self.data.shape = (1, 1) format = SUPPORTED_FORMATS.get(data.dtype.name, '%s') self.model = ArrayModel(self.data, format=format, xlabels=xlabels, ylabels=ylabels, readonly=readonly, parent=self) self.view = ArrayView(self, self.model, data.dtype, data.shape) btn_layout = QHBoxLayout() btn_layout.setAlignment(Qt.AlignLeft) btn = QPushButton(_( "Format")) # disable format button for int type btn.setEnabled(is_float(data.dtype)) btn_layout.addWidget(btn) btn.clicked.connect(self.change_format) btn = QPushButton(_( "Resize")) btn_layout.addWidget(btn) btn.clicked.connect(self.view.resize_to_contents) bgcolor = QCheckBox(_( 'Background color')) bgcolor.setChecked(self.model.bgcolor_enabled) bgcolor.setEnabled(self.model.bgcolor_enabled) bgcolor.stateChanged.connect(self.model.bgcolor) btn_layout.addWidget(bgcolor) layout = QVBoxLayout() layout.addWidget(self.view) layout.addLayout(btn_layout) self.setLayout(layout)
def __init__(self, settings: PartSettings, channel_property: ChannelProperty, name: str): super().__init__(settings, channel_property, name) self._channel_control_top = True self.only_border = QCheckBox("") self.image_state.only_borders = False self.only_border.setChecked(self.image_state.only_borders) self.only_border.stateChanged.connect(self.image_state.set_borders) self.opacity = QDoubleSpinBox() self.opacity.setRange(0, 1) self.opacity.setValue(self.image_state.opacity) self.opacity.setSingleStep(0.1) self.opacity.valueChanged.connect(self.image_state.set_opacity) self.opacity.setMinimumWidth(500) self.channel_control_index = self.btn_layout.indexOf( self.channel_control) self.label1 = QLabel("Borders:") self.label2 = QLabel("Opacity:") self.roi_alternative_select = QComboBox() self.roi_alternative_select.currentTextChanged.connect( self.image_state.set_roi_presented) self.btn_layout.insertWidget(self.channel_control_index + 1, self.label1) self.btn_layout.insertWidget(self.channel_control_index + 2, self.only_border) self.btn_layout.insertWidget(self.channel_control_index + 3, self.label2) self.btn_layout.insertWidget(self.channel_control_index + 4, self.opacity) self.btn_layout.insertWidget(self.channel_control_index + 1, self.roi_alternative_select) self.label1.setVisible(False) self.label2.setVisible(False) self.opacity.setVisible(False) self.only_border.setVisible(False) self.roi_alternative_select.setVisible(False)