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)
