def create_widgets(self, parent, refresh_callback):
self._refresh_callback = refresh_callback
self.prefix_label = QLabel()
font = self.prefix_label.font()
font.setPointSize(font.pointSize() + self._size_offset)
self.prefix_label.setFont(font)
self.button = QPushButton()
self.button.setIcon(get_icon("settings.png"))
self.button.setToolTip(
_("Edit '%s' fit parameter properties") % self.name)
self.button.clicked.connect(lambda: self.edit_param(parent))
self.lineedit = QLineEdit()
self.lineedit.editingFinished.connect(self.line_editing_finished)
self.unit_label = QLabel(self.unit)
self.slider = QSlider()
self.slider.setOrientation(Qt.Horizontal)
self.slider.setRange(0, self.steps - 1)
self.slider.valueChanged.connect(self.slider_value_changed)
self.update(refresh=False)
self.add_widgets([
self.prefix_label,
self.lineedit,
self.unit_label,
self.slider,
self.button,
])
def __init__(self, layer):
super().__init__()
self.layer = layer
layer.events.blending.connect(self._on_blending_change)
layer.events.opacity.connect(self._on_opacity_change)
self.setObjectName('layer')
self.setMouseTracking(True)
self.grid_layout = QGridLayout()
self.grid_layout.setContentsMargins(0, 0, 0, 0)
self.grid_layout.setSpacing(2)
self.setLayout(self.grid_layout)
sld = QSlider(Qt.Horizontal)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(0)
sld.setMaximum(100)
sld.setSingleStep(1)
sld.setValue(self.layer.opacity * 100)
sld.valueChanged[int].connect(
lambda value=sld: self.changeOpacity(value))
self.opacitySilder = sld
blend_comboBox = QComboBox()
for blend in Blending:
blend_comboBox.addItem(str(blend))
index = blend_comboBox.findText(self.layer.blending,
Qt.MatchFixedString)
blend_comboBox.setCurrentIndex(index)
blend_comboBox.activated[str].connect(
lambda text=blend_comboBox: self.changeBlending(text))
self.blendComboBox = blend_comboBox
def createBottomRightGroupBox(self):
self.bottomRightGroupBox = QGroupBox("Group 3")
self.bottomRightGroupBox.setCheckable(True)
self.bottomRightGroupBox.setChecked(True)
lineEdit = QLineEdit('s3cRe7')
lineEdit.setEchoMode(QLineEdit.Password)
spinBox = QSpinBox(self.bottomRightGroupBox)
spinBox.setValue(50)
dateTimeEdit = QDateTimeEdit(self.bottomRightGroupBox)
dateTimeEdit.setDateTime(QDateTime.currentDateTime())
slider = QSlider(Qt.Horizontal, self.bottomRightGroupBox)
slider.setValue(40)
scrollBar = QScrollBar(Qt.Horizontal, self.bottomRightGroupBox)
scrollBar.setValue(60)
dial = QDial(self.bottomRightGroupBox)
dial.setValue(30)
dial.setNotchesVisible(True)
layout = QGridLayout()
layout.addWidget(lineEdit, 0, 0, 1, 2)
layout.addWidget(spinBox, 1, 0, 1, 2)
layout.addWidget(dateTimeEdit, 2, 0, 1, 2)
layout.addWidget(slider, 3, 0)
layout.addWidget(scrollBar, 4, 0)
layout.addWidget(dial, 3, 1, 2, 1)
layout.setRowStretch(5, 1)
self.bottomRightGroupBox.setLayout(layout)
def __init__(self, layer):
super().__init__()
self.layer = layer
layer.events.blending.connect(self._on_blending_change)
layer.events.opacity.connect(self._on_opacity_change)
self.setObjectName('layer')
self.setMouseTracking(True)
self.grid_layout = QGridLayout(self)
self.grid_layout.setContentsMargins(0, 0, 0, 0)
self.grid_layout.setSpacing(2)
self.grid_layout.setColumnMinimumWidth(0, 86)
self.grid_layout.setColumnStretch(1, 1)
self.setLayout(self.grid_layout)
sld = QSlider(Qt.Horizontal, parent=self)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(0)
sld.setMaximum(100)
sld.setSingleStep(1)
sld.valueChanged.connect(self.changeOpacity)
self.opacitySlider = sld
self._on_opacity_change()
blend_comboBox = QComboBox(self)
blend_comboBox.addItems(Blending.keys())
index = blend_comboBox.findText(
self.layer.blending, Qt.MatchFixedString
)
blend_comboBox.setCurrentIndex(index)
blend_comboBox.activated[str].connect(self.changeBlending)
self.blendComboBox = blend_comboBox
def __init__(self,
text,
*args,
minimum=1,
maximum=10,
parent=None,
**kwargs):
super(LabeledSlider, self).__init__(parent)
self.label = QLabel(text)
self.slider = QSlider(*args, **kwargs)
self.slider.setMinimum(minimum)
self.slider.setMaximum(maximum)
self.slider.setTickInterval(5)
self.valuebox = QSpinBox()
self.valuebox.setRange(minimum, maximum)
self.valuebox.setValue(self.slider.value())
self.slider.valueChanged.connect(self.valuebox.setValue)
self.valuebox.valueChanged.connect(self.slider.setValue)
layout = QHBoxLayout()
layout.addWidget(self.label)
layout.addWidget(self.slider)
layout.addWidget(self.valuebox)
self.setLayout(layout)
def __init__(self, **kwargs):
super(VideoPlayerWidget, self).__init__(**kwargs)
self._video = None
self._playing = False
self._moving_seekbar = False
self.view = GraphicsView()
self.play_button = QPushButton()
self.play_button.setIcon(get_standard_icon(QStyle.SP_MediaPlay))
self.play_button.clicked.connect(self.on_play_button_clicked)
self.seekbar = QSlider(Qt.Horizontal)
self.seekbar.setMinimum(0)
self.seekbar.setMaximum(0)
self.seekbar.sliderPressed.connect(self.on_seekbar_sliderPressed)
self.seekbar.sliderMoved.connect(self.on_seekbar_sliderMoved)
self.seekbar.sliderReleased.connect(self.on_seekbar_sliderReleased)
self.seekbar.valueChanged.connect(self.on_seekbar_valueChanged)
self.nframes_label = QLabel('----- / -----')
self.update_timer = QTimer(self)
self.update_timer.timeout.connect(self.fetch_frame)
layout = vbox([
self.view,
hbox([self.play_button, self.seekbar, self.nframes_label])
])
self.setLayout(layout)
def create_widget(self):
self.check_param(self.param, assert_error=True)
self.default = self.param['range'][0]
if 'default' in self.param.keys():
if self.param['default']:
self.default = self.param['default']
self.widget_group = QWidget()
slider = QSlider(Qt.Horizontal)
slider.setValue(self.default)
slider.setRange(self.param['range'][0], self.param['range'][1])
self.widget = QSpinBox()
self.widget.setValue(self.default)
self.widget.setRange(self.param['range'][0], self.param['range'][1])
self.widget.valueChanged.connect(slider.setValue)
slider.valueChanged.connect(self.widget.setValue)
h_box = QHBoxLayout()
h_box.addWidget(slider)
h_box.addWidget(self.widget)
h_box.addStretch(1)
self.widget_group.setLayout(h_box)
def initUI(self):
lcd = QLCDNumber(self)
sld = QSlider(Qt.Horizontal, self)
self.lable = QLabel(self.text, self)
btn = QPushButton('bt1', self)
btn2 = QPushButton('bt2', self)
self.lable2 = QLabel(self.pushRecord, self)
hbox = QHBoxLayout()
hbox.addWidget(btn)
hbox.addWidget(btn2)
vbox = QVBoxLayout()
vbox.addWidget(lcd)
vbox.addWidget(sld)
vbox.addWidget(self.lable)
vbox.addLayout(hbox)
vbox.addWidget(self.lable2)
self.setLayout(vbox)
sld.valueChanged.connect(lcd.display) # sld的value会传入display
self.setMouseTracking(True)
btn.clicked.connect(self.buttonClicked)
btn2.clicked.connect(self.buttonClicked)
self.setGeometry(300, 300, 250, 150)
self.setWindowTitle('Event handler')
self.show()
def __init__(self, viewer: Viewer, parent=None):
super().__init__(parent=parent)
# Store reference to viewer and create animation
self.viewer = viewer
self.animation = Animation(self.viewer)
# Initialise User Interface
self.keyframesListControlWidget = KeyFrameListControlWidget(
animation=self.animation, parent=self)
self.keyframesListWidget = KeyFramesListWidget(
self.animation.key_frames, parent=self)
self.frameWidget = FrameWidget(parent=self)
self.saveButton = QPushButton("Save Animation", parent=self)
self.animationSlider = QSlider(Qt.Horizontal, parent=self)
self.animationSlider.setToolTip("Scroll through animation")
self.animationSlider.setRange(0, len(self.animation._frames) - 1)
# Create layout
self.setLayout(QVBoxLayout())
self.layout().addWidget(self.keyframesListControlWidget)
self.layout().addWidget(self.keyframesListWidget)
self.layout().addWidget(self.frameWidget)
self.layout().addWidget(self.saveButton)
self.layout().addWidget(self.animationSlider)
# establish key bindings and callbacks
self._add_keybind_callbacks()
self._add_callbacks()
def __init__(self, name, a, b, callback):
QWidget.__init__(self)
self.name = name
self.callback = callback
self.a = a
self.b = b
self.manually_triggered = False
self.slider = QSlider()
self.slider.setRange(0, 1000)
self.slider.setValue(500)
self.slider.valueChanged.connect(self.slider_changed)
self.name_label = QLabel()
self.name_label.setText(self.name)
self.name_label.setAlignment(QtCore.Qt.AlignCenter)
self.value_label = QLabel()
self.value_label.setText('%2.2f' %
(self.slider.value() * self.a + self.b))
self.value_label.setAlignment(QtCore.Qt.AlignCenter)
self.layout = QGridLayout(self)
self.layout.addWidget(self.name_label, 0, 0)
self.layout.addWidget(self.slider, 1, 0, QtCore.Qt.AlignHCenter)
self.layout.addWidget(self.value_label, 2, 0)
def textToSpeechUtility(self):
box = QGroupBox(config.thisTranslation["tts_utility"])
layout = QVBoxLayout()
subLayout = QHBoxLayout()
self.ttsEdit = QLineEdit()
self.ttsEdit.setClearButtonEnabled(True)
self.ttsEdit.setToolTip(config.thisTranslation["enter_text_here"])
self.ttsEdit.returnPressed.connect(self.speakText)
subLayout.addWidget(self.ttsEdit)
layout.addLayout(subLayout)
self.ttsSlider = QSlider(Qt.Horizontal)
self.ttsSlider.setToolTip(config.thisTranslation["adjustSpeed"])
self.ttsSlider.setMinimum(10)
self.ttsSlider.setMaximum(310)
self.ttsSlider.setValue(config.espeakSpeed if config.espeak else (
160 + config.qttsSpeed * 150))
self.ttsSlider.valueChanged.connect(
self.changeEspeakSpeed if config.espeak else self.changeQttsSpeed)
layout.addWidget(self.ttsSlider)
subLayout = QHBoxLayout()
self.languageCombo = QComboBox()
subLayout.addWidget(self.languageCombo)
if config.espeak:
languages = TtsLanguages().isoLang2epeakLang
else:
languages = TtsLanguages().isoLang2qlocaleLang
self.languageCodes = list(languages.keys())
for code in self.languageCodes:
self.languageCombo.addItem(languages[code][1])
# Check if selected tts engine has the language user specify.
if not (config.ttsDefaultLangauge in self.languageCodes):
config.ttsDefaultLangauge = "en"
# Set initial index
# It is essential. Otherwise, default tts language is changed by defaultTtsLanguageChanged method.
ttsLanguageIndex = self.languageCodes.index(config.ttsDefaultLangauge)
self.languageCombo.setCurrentIndex(ttsLanguageIndex)
# Change default tts language as users select a new language
self.languageCombo.currentIndexChanged.connect(
self.defaultTtsLanguageChanged)
button = QPushButton(config.thisTranslation["speak"])
button.setToolTip(config.thisTranslation["speak"])
button.clicked.connect(self.speakText)
subLayout.addWidget(button)
button = QPushButton(config.thisTranslation["stop"])
button.setToolTip(config.thisTranslation["stop"])
button.clicked.connect(
self.parent.parent.textCommandParser.stopTtsAudio)
subLayout.addWidget(button)
layout.addLayout(subLayout)
box.setLayout(layout)
return box
def __init__(self, dim_info, number=0, state=State.NONE, parent=None):
super().__init__(parent)
self.minimum = dim_info['minimum']
self.nbins = dim_info['number_of_bins']
self.width = dim_info['width']
self.number = number
self.layout = QHBoxLayout(self)
self.layout.setContentsMargins(0, 2, 0, 0)
self.name = QLabel(dim_info['name'])
self.units = QLabel(dim_info['units'])
self.x = QPushButton('X')
self.x.setCheckable(True)
self.x.clicked.connect(self.x_clicked)
# square button based on height. Default sizeHint is too large
self.x.setFixedWidth(self.x.sizeHint().height())
self.x.setToolTip("Swap X and Y axes")
self.y = QPushButton('Y')
self.y.setCheckable(True)
self.y.clicked.connect(self.y_clicked)
self.y.setFixedWidth(self.y.sizeHint().height())
self.y.setToolTip("Swap X and Y axes")
self.slider = QSlider(Qt.Horizontal)
self.slider.setRange(0, self.nbins - 1)
self.slider.valueChanged.connect(self.slider_changed)
self.update_value_from_slider = True
self.spinbox = QDoubleSpinBox()
self.spinbox.setDecimals(3)
self.spinbox.setRange(self.get_bin_center(0),
self.get_bin_center(self.nbins - 1))
self.spinbox.setSingleStep(self.width)
self.set_value(self.spinbox.minimum())
self.update_spinbox(
) # not updated with set_value unless instance of DimensionNonIntegrated
self.spinbox.editingFinished.connect(self.spinbox_changed)
self.layout.addWidget(self.name)
self.button_layout = QHBoxLayout()
self.button_layout.setContentsMargins(0, 0, 0, 0)
self.button_layout.setSpacing(0)
self.button_layout.addWidget(self.x)
self.button_layout.addWidget(self.y)
self.layout.addLayout(self.button_layout)
self.layout.addWidget(self.slider, stretch=1)
self.layout.addStretch(0)
self.layout.addWidget(self.spinbox)
self.layout.addWidget(self.units)
if self.nbins < 2:
state = State.DISABLE
self.set_state(state)
def __init__(self, theme='dark', emphasized=False):
super().__init__(None)
self.setProperty('emphasized', emphasized)
self.setStyleSheet(template(raw_stylesheet, **palettes[theme]))
lay = QVBoxLayout()
self.setLayout(lay)
lay.addWidget(QPushButton('push button'))
box = QComboBox()
box.addItems(['a', 'b', 'c', 'cd'])
lay.addWidget(box)
lay.addWidget(QFontComboBox())
hbox = QHBoxLayout()
chk = QCheckBox('tristate')
chk.setToolTip('I am a tooltip')
chk.setTristate(True)
chk.setCheckState(Qt.PartiallyChecked)
chk3 = QCheckBox('checked')
chk3.setChecked(True)
hbox.addWidget(QCheckBox('unchecked'))
hbox.addWidget(chk)
hbox.addWidget(chk3)
lay.addLayout(hbox)
lay.addWidget(TabDemo(emphasized=emphasized))
sld = QSlider(Qt.Horizontal)
sld.setValue(50)
lay.addWidget(sld)
scroll = QScrollBar(Qt.Horizontal)
scroll.setValue(50)
lay.addWidget(scroll)
lay.addWidget(QHRangeSlider(parent=self))
text = QTextEdit()
text.setMaximumHeight(100)
text.setHtml(blurb)
lay.addWidget(text)
lay.addWidget(QTimeEdit())
edit = QLineEdit()
edit.setPlaceholderText('LineEdit placeholder...')
lay.addWidget(edit)
lay.addWidget(QLabel('label'))
prog = QProgressBar()
prog.setValue(50)
lay.addWidget(prog)
groupBox = QGroupBox("Exclusive Radio Buttons")
radio1 = QRadioButton("&Radio button 1")
radio2 = QRadioButton("R&adio button 2")
radio3 = QRadioButton("Ra&dio button 3")
radio1.setChecked(True)
hbox = QHBoxLayout()
hbox.addWidget(radio1)
hbox.addWidget(radio2)
hbox.addWidget(radio3)
hbox.addStretch(1)
groupBox.setLayout(hbox)
lay.addWidget(groupBox)
def createSlider(self):
slider = QSlider(Qt.Vertical)
slider.setRange(0, 360 * 16)
slider.setSingleStep(16)
slider.setPageStep(15 * 16)
slider.setTickInterval(15 * 16)
slider.setTickPosition(QSlider.TicksRight)
return slider
def createZoomSlider(self):
slider = QSlider(Qt.Vertical)
slider.setRange(1, 1000000)
slider.setSingleStep(1)
slider.setPageStep(10)
slider.setTickInterval(10)
slider.setTickPosition(QSlider.TicksRight)
return slider
def __init__(self, vpoints: Sequence[VPoint], vlinks: Sequence[VLink],
path: _Paths, slider_path: _SliderPaths, monochrome: bool,
parent: QWidget):
super(AnimateDialog, self).__init__(parent)
self.setWindowTitle("Vector Animation")
self.setWindowFlags(self.windowFlags() | Qt.WindowMaximizeButtonHint
& ~Qt.WindowContextHelpButtonHint)
self.setMinimumSize(800, 600)
self.setModal(True)
main_layout = QVBoxLayout(self)
self.canvas = _DynamicCanvas(vpoints, vlinks, path, slider_path, self)
self.canvas.set_monochrome_mode(monochrome)
self.canvas.update_pos.connect(self.__set_pos)
layout = QHBoxLayout(self)
pt_option = QComboBox(self)
pt_option.addItems([f"P{p}" for p in range(len(vpoints))])
layout.addWidget(pt_option)
value_label = QLabel(self)
@Slot(int)
def show_values(ind: int):
vel, vel_deg = self.canvas.get_vel(ind)
acc, acc_deg = self.canvas.get_acc(ind)
value_label.setText(
f"Velocity: {vel:.04f} ({vel_deg:.04f}deg) | "
f"Acceleration: {acc:.04f} ({acc_deg:.04f}deg)")
pt_option.currentIndexChanged.connect(show_values)
layout.addWidget(value_label)
self.pos_label = QLabel(self)
layout.addItem(
QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum))
layout.addWidget(self.pos_label)
main_layout.addLayout(layout)
main_layout.addWidget(self.canvas)
layout = QHBoxLayout(self)
self.play = QPushButton(QIcon(QPixmap(":/icons/play.png")), "", self)
self.play.setCheckable(True)
self.play.clicked.connect(self.__play)
layout.addWidget(self.play)
self.slider = QSlider(Qt.Horizontal, self)
self.slider.setMaximum(max(len(p) for p in path) - 1)
self.slider.valueChanged.connect(self.canvas.set_index)
layout.addWidget(self.slider)
layout.addWidget(QLabel("Total times:", self))
factor = QDoubleSpinBox(self)
factor.valueChanged.connect(self.canvas.set_factor)
factor.setSuffix('s')
factor.setRange(0.01, 999999)
factor.setValue(10)
layout.addWidget(factor)
main_layout.addLayout(layout)
self.timer = QTimer()
self.timer.setInterval(10)
self.timer.timeout.connect(self.__move_ind)
def __init__(self, layer):
super().__init__(layer)
self.layer.events.edge_width.connect(self._on_edge_width_change)
self.layer.events.edge_color.connect(self._on_edge_color_change)
self.layer.events.face_color.connect(self._on_face_color_change)
sld = QSlider(Qt.Horizontal, self)
sld.setFocusPolicy(Qt.NoFocus)
sld.setFixedWidth(75)
sld.setMinimum(0)
sld.setMaximum(40)
sld.setSingleStep(1)
value = self.layer.edge_width
if isinstance(value, Iterable):
if isinstance(value, list):
value = np.asarray(value)
value = value.mean()
sld.setValue(int(value))
sld.valueChanged[int].connect(lambda value=sld:
self.changeWidth(value))
self.widthSlider = sld
self.grid_layout.addWidget(QLabel('width:'), 3, 0)
self.grid_layout.addWidget(sld, 3, 1)
face_comboBox = QComboBox()
colors = self.layer._colors
for c in colors:
face_comboBox.addItem(c)
index = face_comboBox.findText(
self.layer.face_color, Qt.MatchFixedString)
if index >= 0:
face_comboBox.setCurrentIndex(index)
face_comboBox.activated[str].connect(lambda text=face_comboBox:
self.changeFaceColor(text))
self.faceComboBox = face_comboBox
self.grid_layout.addWidget(QLabel('face_color:'), 4, 0)
self.grid_layout.addWidget(face_comboBox, 4, 1)
edge_comboBox = QComboBox()
colors = self.layer._colors
for c in colors:
edge_comboBox.addItem(c)
index = edge_comboBox.findText(
self.layer.edge_color, Qt.MatchFixedString)
if index >= 0:
edge_comboBox.setCurrentIndex(index)
edge_comboBox.activated[str].connect(lambda text=edge_comboBox:
self.changeEdgeColor(text))
self.edgeComboBox = edge_comboBox
self.grid_layout.addWidget(QLabel('edge_color:'), 5, 0)
self.grid_layout.addWidget(edge_comboBox, 5, 1)
self.setExpanded(False)
def __init__(self, dim_info, number=0, state=State.NONE, parent=None):
super().__init__(parent)
self.minimum = dim_info['minimum']
self.nbins = dim_info['number_of_bins']
self.width = dim_info['width']
self.number = number
self.layout = QHBoxLayout(self)
self.layout.setContentsMargins(0, 2, 0, 0)
self.name = QLabel(dim_info['name'])
self.units = QLabel(dim_info['units'])
self.x = QPushButton('X')
self.x.setFixedSize(26, 26)
self.x.setCheckable(True)
self.x.clicked.connect(self.x_clicked)
self.y = QPushButton('Y')
self.y.setFixedSize(26, 26)
self.y.setCheckable(True)
self.y.clicked.connect(self.y_clicked)
self.slider = QSlider(Qt.Horizontal)
self.slider.setRange(0, self.nbins - 1)
self.slider.valueChanged.connect(self.slider_changed)
self.spinbox = QDoubleSpinBox()
self.spinbox.setDecimals(3)
self.spinbox.setRange(self.get_bin_center(0),
self.get_bin_center(self.nbins - 1))
self.spinbox.setSingleStep(self.width)
self.spinbox.editingFinished.connect(self.spinbox_changed)
self.layout.addWidget(self.name)
self.button_layout = QHBoxLayout()
self.button_layout.setContentsMargins(0, 0, 0, 0)
self.button_layout.setSpacing(0)
self.button_layout.addWidget(self.x)
self.button_layout.addWidget(self.y)
self.layout.addLayout(self.button_layout)
self.layout.addWidget(self.slider, stretch=1)
self.layout.addStretch(0)
self.layout.addWidget(self.spinbox)
self.layout.addWidget(self.units)
self.set_value(0)
if self.nbins < 2:
state = State.DISABLE
self.set_state(state)
def __init__(self, item, parent_layout):
super(SliderWidget, self).__init__(item, parent_layout)
self.slider = self.vmin = self.vmax = None
if item.get_prop_value("display", "slider"):
self.vmin = item.get_prop_value("data", "min")
self.vmax = item.get_prop_value("data", "max")
assert (
self.vmin is not None and self.vmax is not None
), "SliderWidget requires that item min/max have been defined"
self.slider = QSlider()
self.slider.setOrientation(Qt.Horizontal)
self.setup_slider(item)
self.slider.valueChanged.connect(self.value_changed)
self.group.addWidget(self.slider)
def initUI(self):
lcd = QLCDNumber(self)
sld = QSlider(Qt.Horizontal, self)
vbox = QVBoxLayout()
vbox.addWidget(lcd)
vbox.addWidget(sld)
self.setLayout(vbox)
sld.valueChanged.connect(lambda x: lcd.display(2**x))
self.setGeometry(300, 300, 250, 150)
self.setWindowTitle('Signal & slot')
self.show()
def __init__(self, layer):
super().__init__(layer)
self.layer.events.colormap.connect(self._on_colormap_change)
self.layer.events.gamma.connect(self._on_gamma_change)
self.layer.events.contrast_limits.connect(
self._on_contrast_limits_change
)
comboBox = QtColormapComboBox(self)
comboBox.setObjectName("colormapComboBox")
comboBox._allitems = set(self.layer.colormaps)
for name, cm in AVAILABLE_COLORMAPS.items():
if name in self.layer.colormaps:
comboBox.addItem(cm._display_name, name)
comboBox.activated[str].connect(self.changeColor)
self.colormapComboBox = comboBox
# Create contrast_limits slider
self.contrastLimitsSlider = QHRangeSlider(
self.layer.contrast_limits,
self.layer.contrast_limits_range,
parent=self,
)
self.contrastLimitsSlider.mousePressEvent = self._clim_mousepress
set_clim = partial(setattr, self.layer, 'contrast_limits')
set_climrange = partial(setattr, self.layer, 'contrast_limits_range')
self.contrastLimitsSlider.valuesChanged.connect(set_clim)
self.contrastLimitsSlider.rangeChanged.connect(set_climrange)
# gamma slider
sld = QSlider(Qt.Horizontal, parent=self)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(2)
sld.setMaximum(200)
sld.setSingleStep(2)
sld.setValue(100)
sld.valueChanged.connect(self.gamma_slider_changed)
self.gammaSlider = sld
self._on_gamma_change()
self.colorbarLabel = QLabel(parent=self)
self.colorbarLabel.setObjectName('colorbar')
self.colorbarLabel.setToolTip(trans._('Colorbar'))
self._on_colormap_change()
def __init__(self, vpoints: Sequence[VPoint],
path: Sequence[Sequence[Tuple[float, float]]],
monochrome: bool, parent: QWidget):
super(AnimateDialog, self).__init__(parent)
self.setWindowTitle("Animation")
self.setWindowFlags(self.windowFlags() | Qt.WindowMaximizeButtonHint)
self.setMinimumSize(800, 600)
self.setModal(True)
layout = QVBoxLayout(self)
canvas = _DynamicCanvas(vpoints, path, self)
canvas.set_monochrome_mode(monochrome)
layout.addWidget(canvas)
slider = QSlider(Qt.Horizontal, self)
slider.setMaximum(max(len(p) for p in path))
slider.valueChanged.connect(canvas.set_index)
layout.addWidget(slider)
def __init__(self, layer):
super().__init__(layer)
self.layer.events.colormap.connect(self._on_colormap_change)
self.layer.events.contrast_limits.connect(
lambda e: self.contrast_limits_slider_update()
)
self.layer.events.gamma.connect(lambda e: self.gamma_slider_update())
comboBox = QComboBox()
for cmap in self.layer.colormaps:
comboBox.addItem(cmap)
comboBox._allitems = set(self.layer.colormaps)
comboBox.activated[str].connect(
lambda text=comboBox: self.changeColor(text)
)
self.colormapComboBox = comboBox
# Create contrast_limits slider
self.contrastLimitsSlider = QHRangeSlider(
slider_range=[0, 1, 0.0001], values=[0, 1]
)
self.contrastLimitsSlider.setEmitWhileMoving(True)
self.contrastLimitsSlider.collapsable = False
self.contrastLimitsSlider.setEnabled(True)
self.contrastLimitsSlider.rangeChanged.connect(
self.contrast_limits_slider_changed
)
self.contrast_limits_slider_update()
# gamma slider
sld = QSlider(Qt.Horizontal)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(2)
sld.setMaximum(200)
sld.setSingleStep(2)
sld.setValue(100)
sld.valueChanged[int].connect(self.gamma_slider_changed)
self.gammaSlider = sld
self.gamma_slider_update()
self.colorbarLabel = QLabel()
self.colorbarLabel.setObjectName('colorbar')
self.colorbarLabel.setToolTip('Colorbar')
self._on_colormap_change(None)
def test_library_widget(qtbot):
w = QWidget()
w.setLayout(QHBoxLayout())
l = LibraryWidget()
for i in range(15):
l.add_image(np.random.random((1000, 1000)), f"Sample {i+1}")
s = QSlider()
s.valueChanged.connect(partial(l.set_slice, axis="E"))
w.layout().addWidget(l)
w.layout().addWidget(s)
w.show()
qtbot.addWidget(w)
def __init__(self, parent=None, init_channel=None):
QFrame.__init__(self, parent)
PyDMWritableWidget.__init__(self, init_channel=init_channel)
self.alarmSensitiveContent = True
self.alarmSensitiveBorder = False
# Internal values for properties
self._ignore_mouse_wheel = False
self._show_limit_labels = True
self._show_value_label = True
self._user_defined_limits = False
self._needs_limit_info = True
self._minimum = None
self._maximum = None
self._user_minimum = -10.0
self._user_maximum = 10.0
self._num_steps = 101
self._orientation = Qt.Horizontal
# Set up all the internal widgets that make up a PyDMSlider.
# We'll add all these things to layouts when we call setup_widgets_for_orientation
label_size_policy = QSizePolicy(QSizePolicy.Maximum, QSizePolicy.Fixed)
self.low_lim_label = QLabel(self)
self.low_lim_label.setObjectName("lowLimLabel")
self.low_lim_label.setSizePolicy(label_size_policy)
self.low_lim_label.setAlignment(Qt.AlignLeft | Qt.AlignTrailing
| Qt.AlignVCenter)
self.value_label = QLabel(self)
self.value_label.setObjectName("valueLabel")
self.value_label.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
self.high_lim_label = QLabel(self)
self.high_lim_label.setObjectName("highLimLabel")
self.high_lim_label.setSizePolicy(label_size_policy)
self.high_lim_label.setAlignment(Qt.AlignRight | Qt.AlignTrailing
| Qt.AlignVCenter)
self._slider = QSlider(parent=self)
self._slider.setOrientation(Qt.Horizontal)
self._orig_wheel_event = self._slider.wheelEvent
self._slider.sliderMoved.connect(self.internal_slider_moved)
self._slider.sliderPressed.connect(self.internal_slider_pressed)
self._slider.sliderReleased.connect(self.internal_slider_released)
self._slider.valueChanged.connect(self.internal_slider_value_changed)
# self.vertical_layout.addWidget(self._slider)
# Other internal variables and final setup steps
self._slider_position_to_value_map = None
self._mute_internal_slider_changes = False
self.setup_widgets_for_orientation(self._orientation)
self.reset_slider_limits()
def test_library_view(qtbot, random_data_catalog):
from xicam.plugins.catalogplugin import CatalogModel
model = CatalogModel(random_data_catalog)
w = QWidget()
w.setLayout(QHBoxLayout())
l = LibraryView(model, slice={"E": 0})
s = QSlider()
s.valueChanged.connect(partial(l.set_slice, axis="E"))
w.layout().addWidget(l)
w.layout().addWidget(s)
w.show()
qtbot.addWidget(w)
def __init__(self, parent=None):
super(QLabeledSlider, self).__init__(parent)
self._range = range
self._slider = QSlider()
self._slider.setMinimum(0)
self._slider.setMaximum(100)
self._slider.setOrientation(Qt.Horizontal)
self._label = QLabel('')
self._layout = QHBoxLayout()
self._layout.setContentsMargins(2, 2, 2, 2)
self._layout.addWidget(self._slider)
self._layout.addWidget(self._label)
self._slider.valueChanged.connect(self._update_label)
self.setLayout(self._layout)
def __init__(self):
super(QTiffStackView, self).__init__()
#add the image display. This is a subclass of QLabel, where paintEvent is overriden.
self.frame_view = FrameView()
#self.frame_view.setSizePolicy(QSizePolicy.Expanding,QSizePolicy.Expanding)
#add the slide bar which allows the user to manual flick through
self.slideBar = QSlider(Qt.Horizontal)
self.slideBar.setTickPosition(QSlider.TicksAbove)
self.slideBar.setTracking(True)
self.slideBar.setTickInterval(100)
#add a counter which displays the frame which is currently displayed
self.counter = QSpinBox()
self.counter.setSingleStep(1)
self.counter.setRange(self.slideBar.minimum(), self.slideBar.maximum())
#self explanatory
self.play = QPushButton('Play')
#when play button is pressed the timer takes control of the displaying of frames
self.frametimer = QTimer()
frame_rate = 30
self.frametimer.setInterval(frame_rate)
#Add a sublayout to align the slidebar and frame counter next to eachother
slidelyt = QHBoxLayout()
slidelyt.addWidget(self.slideBar)
slidelyt.addWidget(self.counter)
#Add the main layout for the widget
lyt = QVBoxLayout()
lyt.addWidget(self.frame_view)
lyt.addLayout(slidelyt)
lyt.addWidget(self.play)
self.setLayout(lyt)
def open_perspective_popup(self):
"""Show a slider to control the viewer `camera.perspective`."""
if self.viewer.dims.ndisplay != 3:
return
# make slider connected to perspective parameter
sld = QSlider(Qt.Horizontal, self)
sld.setRange(0, max(90, self.viewer.camera.perspective))
sld.setValue(self.viewer.camera.perspective)
sld.valueChanged.connect(
lambda v: setattr(self.viewer.camera, 'perspective', v))
# make layout
layout = QHBoxLayout()
layout.addWidget(QLabel(trans._('Perspective'), self))
layout.addWidget(sld)
# popup and show
pop = QtPopup(self)
pop.frame.setLayout(layout)
pop.show_above_mouse()
def __init__(self, layer):
super().__init__(layer)
self.layer.events.colormap.connect(self._on_colormap_change)
self.layer.events.gamma.connect(self.gamma_slider_update)
self.layer.events.contrast_limits.connect(self._on_clims_change)
comboBox = QComboBox()
comboBox.addItems(self.layer.colormaps)
comboBox._allitems = set(self.layer.colormaps)
comboBox.activated[str].connect(self.changeColor)
self.colormapComboBox = comboBox
# Create contrast_limits slider
self.contrastLimitsSlider = QHRangeSlider(
self.layer.contrast_limits, self.layer.contrast_limits_range
)
self.contrastLimitsSlider.mousePressEvent = self._clim_mousepress
set_clim = partial(setattr, self.layer, 'contrast_limits')
set_climrange = partial(setattr, self.layer, 'contrast_limits_range')
self.contrastLimitsSlider.valuesChanged.connect(set_clim)
self.contrastLimitsSlider.rangeChanged.connect(set_climrange)
# gamma slider
sld = QSlider(Qt.Horizontal)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(2)
sld.setMaximum(200)
sld.setSingleStep(2)
sld.setValue(100)
sld.valueChanged.connect(self.gamma_slider_changed)
self.gammaSlider = sld
self.gamma_slider_update()
self.colorbarLabel = QLabel()
self.colorbarLabel.setObjectName('colorbar')
self.colorbarLabel.setToolTip('Colorbar')
self._on_colormap_change()