Python QSlider.setMinimumWidth方法代码示例

# 需要导入模块: from PyQt5.QtWidgets import QSlider [as 别名]
# 或者: from PyQt5.QtWidgets.QSlider import setMinimumWidth [as 别名]
class LinearPoti(PluginBase):
    def __init__(self, *args):
        super().__init__(BrickletLinearPoti, *args)

        self.lp = self.device

        self.cbe_position = CallbackEmulator(self.lp.get_position,
                                             None,
                                             self.cb_position,
                                             self.increase_error_count)

        self.slider = QSlider(Qt.Horizontal)
        self.slider.setRange(0, 100)
        self.slider.setMinimumWidth(200)

        self.current_position = CurveValueWrapper()

        plots = [('Position', Qt.red, self.current_position, str)]
        self.plot_widget = PlotWidget('Position', plots, extra_key_widgets=[self.slider],
                                      update_interval=0.025, y_resolution=1.0)

        layout = QVBoxLayout(self)
        layout.addWidget(self.plot_widget)

    def start(self):
        self.cbe_position.set_period(25)

        self.plot_widget.stop = False

    def stop(self):
        self.cbe_position.set_period(0)

        self.plot_widget.stop = True

    def destroy(self):
        pass

    @staticmethod
    def has_device_identifier(device_identifier):
        return device_identifier == BrickletLinearPoti.DEVICE_IDENTIFIER

    def cb_position(self, position):
        self.current_position.value = position
        self.slider.setValue(position)

# 需要导入模块: from PyQt5.QtWidgets import QSlider [as 别名]
# 或者: from PyQt5.QtWidgets.QSlider import setMinimumWidth [as 别名]

#.........这里部分代码省略.........

        hbox.addLayout(vboxSelected)
        hbox.addLayout(vbox)
        hbox.addLayout(vboxAvailable)

        self.selectedFeatureList = selectedFeatureList
        self.availableFeatureList = availableFeatureList

        return hbox

    def widgetParameters(self):
        """Create parameters widgets.
        """
        # Cluster Count
        self.autoK = QCheckBox(self.tr('Auto'))
        self.clusterCount = QSpinBox(self)
        self.clusterCount.setValue(2)
        self.clusterCount.setMinimum(1)
        self.modeK = QComboBox(self)

        hcluster = QHBoxLayout()
        hcluster.addWidget(QLabel(self.tr('Cluster count:')))
        hcluster.addWidget(self.modeK)
        hcluster.addWidget(self.clusterCount)

        # Slider
        hslider = QHBoxLayout()
        clusterLabel = QLabel(self.tr('Cluster count'))
        self.clusterSliderLabel = QLabel()
        compactnessLabel = QLabel(self.tr('Compactness'))
        self.compactnessSliderLabel = QLabel()
        self.clusterSlider = QSlider(QtCore.Qt.Horizontal)
        self.clusterSlider.valueChanged[int].connect(self.sliderMoved)
        self.clusterSlider.setMinimumWidth(100)
        self.clusterSlider.setValue(50)
        self.clusterSlider.setMaximum(100)
        hslider.addWidget(clusterLabel)
        hslider.addWidget(self.clusterSliderLabel)
        hslider.addWidget(self.clusterSlider)
        hslider.addWidget(compactnessLabel)
        hslider.addWidget(self.compactnessSliderLabel)
        self.clusterSliderWidget = QWidget()
        self.clusterSliderWidget.setLayout(hslider)

        # Set default mode
        self.modeK.currentIndexChanged.connect(self.toggleClusterCount)
        default = Clusterer.getDefaultKMode()
        defaultIndex = 0
        for i, (mode, name) in enumerate(Clusterer.getAllKModes()):
            if mode == default:
                defaultIndex = i
            self.modeK.addItem(name)
        self.modeK.setCurrentIndex(defaultIndex)

        # Algo
        combo = QComboBox(self)
        default = Clusterer.getDefaultMode()
        defaultIndex = 0
        for i, (mode, name) in enumerate(Clusterer.getAllModes()):
            if mode == default:
                defaultIndex = i
            combo.addItem(name)
        combo.setCurrentIndex(defaultIndex)
        halgo = QHBoxLayout()
        halgo.addWidget(QLabel(self.tr('Algorithm:')))
        halgo.addWidget(combo)

# 需要导入模块: from PyQt5.QtWidgets import QSlider [as 别名]
# 或者: from PyQt5.QtWidgets.QSlider import setMinimumWidth [as 别名]

#.........这里部分代码省略.........
            (2*np.pi*mean_sequence)/trigger_level
        RD_spectrum = RD_spectrum[0:int(RD_order/2)]

        """ pyqtgraph variante"""

        win.setWindowTitle(self.windowtitle)
        c0.clear()
        c0 = p0.plot(self.time_vec, raw_data_plot)
        p1.clear()
        p1.plot(data_time, decimated_data, pen='g', name="Decimated Data ")
        p1.plot(trigger_event_time/rate_down, trigger_event_amp,
                pen=None, symbol='t', symbolPen=None, symbolBrush='r')
        p2.clear()
        p2.plot(RD_time, RD_sequence, pen='g')
        p3.clear()
        p3.plot(RD_freq, abs(RD_spectrum), pen='g')

        self.statusBar().showMessage('Ready')

    def on_radio_button_toggled(self):
            radiobutton = self.sender()

            if radiobutton.isChecked():
                self.activeaxis = radiobutton.axis

    def create_main_frame(self):
        self.main_frame = QWidget()

        # Create the navigation toolbar, tied to the canvas
        # Other GUI controls    
        """RD order"""
        RDTextbox_label = QLabel('RD order:')
        self.RDTextbox = QLineEdit()
        self.RDTextbox.setMinimumWidth(0.5)

        RecLength_label = QLabel('Record length [s]:')
        self.RecLength_textbox = QLineEdit()
        self.RecLength_textbox.setMinimumWidth(0.5)
        self.RecLength_textbox.setReadOnly(True)

        spinBox_label = QLabel('Decimation')
        self.spinBox = QSpinBox()
        self.spinBox.setGeometry(QRect(440, 260, 71, 22))
        self.spinBox.setMinimum(1)
        self.spinBox.setMaximum(10)
        self.spinBox.setSingleStep(1)
        self.spinBox.setObjectName("spinBox")

        Sampling_label = QLabel('Sampling Frequency [Hz]')
        self.Sampling_textbox = QLineEdit()
        self.Sampling_textbox.setMinimumWidth(0.5)
        self.Sampling_textbox.setReadOnly = (True)

        self.draw_button = QPushButton("&GO!")
        self.draw_button.clicked.connect(self.on_draw)

        slider_label = QLabel('Trigger Level (%):')
        self.slider = QSlider(Qt.Horizontal)
        self.slider.setRange(1, 100)
        self.slider.setValue(25)
        self.slider.setTracking(True)
        self.slider.setTickPosition(QSlider.TicksBothSides)
        self.slider.setMinimumWidth(0.8)

        checkbox_label = QLabel('Highpass')
        self.checkbox = QCheckBox()

# 需要导入模块: from PyQt5.QtWidgets import QSlider [as 别名]
# 或者: from PyQt5.QtWidgets.QSlider import setMinimumWidth [as 别名]
class PianoWidget(QWidget):
    noteOn = pyqtSignal(music.Pitch, int)
    noteOff = pyqtSignal(music.Pitch)

    def __init__(self, parent, app):
        super().__init__(parent)

        self._app = app

        self.setFocusPolicy(Qt.StrongFocus)

        layout = QVBoxLayout()
        self.setLayout(layout)

        toolbar = QHBoxLayout()
        layout.addLayout(toolbar)

        self.focus_indicator = QLed(self)
        self.focus_indicator.setMinimumSize(24, 24)
        self.focus_indicator.setMaximumSize(24, 24)
        toolbar.addWidget(self.focus_indicator)

        toolbar.addSpacing(10)

        self._keyboard_listener = None

        self.keyboard_selector = QComboBox()
        self.keyboard_selector.addItem("None", userData=None)
        for device_id, port_info in self._app.midi_hub.list_devices():
            self.keyboard_selector.addItem(
                "%s (%s)" % (port_info.name, port_info.client_info.name),
                userData=device_id)
        self.keyboard_selector.currentIndexChanged.connect(
            self.onKeyboardDeviceChanged)
        toolbar.addWidget(self.keyboard_selector)

        toolbar.addSpacing(10)

        # speaker icon should go here...
        #tb = QToolButton(self)
        #tb.setIcon(QIcon.fromTheme('multimedia-volume-control'))
        #toolbar.addWidget(tb)

        self.volume = QSlider(Qt.Horizontal, self)
        self.volume.setMinimumWidth(200)
        self.volume.setMinimum(0)
        self.volume.setMaximum(127)
        self.volume.setValue(127)
        self.volume.setTickPosition(QSlider.TicksBothSides)
        toolbar.addWidget(self.volume)

        toolbar.addStretch(1)

        self.piano_keys = PianoKeys(self)
        layout.addWidget(self.piano_keys)

    def close(self):
        if not super().close():  # pragma: no coverage
            return False

        if self._keyboard_listener is not None:
            self._keyboard_listener.remove()
            self._keyboard_listener = None

        return True

    def onKeyboardDeviceChanged(self, index):
        if self._keyboard_listener is not None:
            self._keyboard_listener.remove()
            self._keyboard_listener = None

        device_id = self.keyboard_selector.itemData(index)
        if device_id is not None:
            self._keyboard_listener = self._app.midi_hub.listeners.add(
                device_id, self.midiEvent)

    def focusInEvent(self, event):
        event.accept()
        self.focus_indicator.setValue(True)

    def focusOutEvent(self, event):
        event.accept()
        self.focus_indicator.setValue(False)

    def keyPressEvent(self, event):
        self.piano_keys.keyPressEvent(event)

    def keyReleaseEvent(self, event):
        self.piano_keys.keyReleaseEvent(event)

    def midiEvent(self, event):
        self.piano_keys.midiEvent(event)

# 需要导入模块: from PyQt5.QtWidgets import QSlider [as 别名]
# 或者: from PyQt5.QtWidgets.QSlider import setMinimumWidth [as 别名]
class QuadStatusBar(QHBoxLayout):
    positionChanged = pyqtSignal(int, int, int)  # x,y,z

    def __init__(self, parent=None):
        QHBoxLayout.__init__(self, parent)
        self.setContentsMargins(0, 4, 0, 0)
        self.setSpacing(0)
        self.timeControlFontSize = 12

    def showXYCoordinates(self):
        self.zLabel.setHidden(True)
        self.zSpinBox.setHidden(True)

    def showXYZCoordinates(self):
        self.zLabel.setHidden(False)
        self.zSpinBox.setHidden(False)

    def hideTimeSlider(self, flag):
        visibleBefore = not self.timeSlider.isHidden()
        self.timeSlider.setHidden(flag)
        self.timeEndButton.setHidden(flag)
        self.timeStartButton.setHidden(flag)
        self.timePreviousButton.setHidden(flag)
        self.timeNextButton.setHidden(flag)
        self._registerTimeframeShortcuts(enabled=not flag, remove=visibleBefore)

    def setToolTipTimeButtons(self, croppingFlag=False):
        self.timeStartButton.setToolTip("First Frame")
        self.timeEndButton.setToolTip("Last Frame")
        self.timePreviousButton.setToolTip("Previous Frame")
        self.timeNextButton.setToolTip("Next Frame")

    def setToolTipTimeSlider(self, croppingFlag=False):
        self.timeSlider.setToolTip("Choose the time coordinate of the current dataset.")

    def createQuadViewStatusBar(
        self, xbackgroundColor, xforegroundColor, ybackgroundColor, yforegroundColor, zbackgroundColor, zforegroundColor
    ):
        self.xLabel, self.xSpinBox = _get_pos_widget("X", xbackgroundColor, xforegroundColor)
        self.yLabel, self.ySpinBox = _get_pos_widget("Y", ybackgroundColor, yforegroundColor)
        self.zLabel, self.zSpinBox = _get_pos_widget("Z", zbackgroundColor, zforegroundColor)

        self.xSpinBox.delayedValueChanged.connect(partial(self._handlePositionBoxValueChanged, "x"))
        self.ySpinBox.delayedValueChanged.connect(partial(self._handlePositionBoxValueChanged, "y"))
        self.zSpinBox.delayedValueChanged.connect(partial(self._handlePositionBoxValueChanged, "z"))

        self.addWidget(self.xLabel)
        self.addWidget(self.xSpinBox)
        self.addWidget(self.yLabel)
        self.addWidget(self.ySpinBox)
        self.addWidget(self.zLabel)
        self.addWidget(self.zSpinBox)

        self.addSpacing(10)

        self.crosshairsCheckbox = QCheckBox()
        self.crosshairsCheckbox.setChecked(False)
        self.crosshairsCheckbox.setCheckable(True)
        self.crosshairsCheckbox.setText("Crosshairs")
        self.addWidget(self.crosshairsCheckbox)

        self.addSpacing(10)

        self.busyIndicator = QProgressBar()
        self.busyIndicator.setMaximumWidth(200)
        self.busyIndicator.setMaximum(0)
        self.busyIndicator.setMinimum(0)
        self.busyIndicator.setVisible(False)
        self.busyIndicator.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
        self.addWidget(self.busyIndicator)
        self.setStretchFactor(self.busyIndicator, 1)

        self.addStretch()

        self.addSpacing(20)

        self.timeSpinBox = DelayedSpinBox(750)

        icons_dir = os.path.dirname(volumina.__file__) + "/icons"

        self.timeStartButton = QToolButton()
        self.timeStartButton.setIcon(QIcon(icons_dir + "/skip-start.png"))
        self.addWidget(self.timeStartButton)
        self.timeStartButton.clicked.connect(self._onTimeStartButtonClicked)
        # self.timeStartButton.setFixedWidth(4*self.timeControlFontSize)

        self.timePreviousButton = QToolButton()
        self.timePreviousButton.setIcon(QIcon(icons_dir + "/play-reverse.png"))
        self.addWidget(self.timePreviousButton)
        self.timePreviousButton.clicked.connect(self._onTimePreviousButtonClicked)
        # self.timePreviousButton.setFixedWidth(4*self.timeControlFontSize)

        self.timeSlider = QSlider(Qt.Horizontal)
        self.timeSlider.setMinimumWidth(10)
        self.timeSlider.setMaximumWidth(200)
        self.setToolTipTimeSlider()
        self.addWidget(self.timeSlider)
        self.timeSlider.valueChanged.connect(self._onTimeSliderChanged)

        self.timeNextButton = QToolButton()
#.........这里部分代码省略.........

# 需要导入模块: from PyQt5.QtWidgets import QSlider [as 别名]
# 或者: from PyQt5.QtWidgets.QSlider import setMinimumWidth [as 别名]
class MotorizedLinearPoti(COMCUPluginBase):
    def __init__(self, *args):
        super().__init__(BrickletMotorizedLinearPoti, *args)

        self.mp = self.device

        self.cbe_position = CallbackEmulator(self.mp.get_position,
                                             None,
                                             self.cb_position,
                                             self.increase_error_count)

        self.current_position = CurveValueWrapper()

        self.slider = QSlider(Qt.Horizontal)
        self.slider.setRange(0, 100)
        self.slider.setMinimumWidth(200)
        self.slider.setEnabled(False)

        plots = [('Potentiometer Position', Qt.red, self.current_position, str)]
        self.plot_widget = PlotWidget('Position', plots, extra_key_widgets=[self.slider],
                                      update_interval=0.025, y_resolution=1.0)

        self.motor_slider = QSlider(Qt.Horizontal)
        self.motor_slider.setRange(0, 100)
        self.motor_slider.valueChanged.connect(self.motor_slider_value_changed)
        self.motor_hold_position = QCheckBox("Hold Position")
        self.motor_drive_mode = QComboBox()
        self.motor_drive_mode.addItem('Fast')
        self.motor_drive_mode.addItem('Smooth')

        def get_motor_slider_value():
            return self.motor_slider.value()

        self.motor_hold_position.stateChanged.connect(lambda x: self.motor_slider_value_changed(get_motor_slider_value()))
        self.motor_drive_mode.currentIndexChanged.connect(lambda x: self.motor_slider_value_changed(get_motor_slider_value()))

        self.motor_position_label = MotorPositionLabel('Motor Target Position:')

        hlayout = QHBoxLayout()
        hlayout.addWidget(self.motor_position_label)
        hlayout.addWidget(self.motor_slider)
        hlayout.addWidget(self.motor_drive_mode)
        hlayout.addWidget(self.motor_hold_position)

        line = QFrame()
        line.setObjectName("line")
        line.setFrameShape(QFrame.HLine)
        line.setFrameShadow(QFrame.Sunken)

        layout = QVBoxLayout(self)
        layout.addWidget(self.plot_widget)
        layout.addWidget(line)
        layout.addLayout(hlayout)

    def start(self):
        async_call(self.mp.get_motor_position, None, self.get_motor_position_async, self.increase_error_count)

        self.cbe_position.set_period(25)

        self.plot_widget.stop = False

    def stop(self):
        self.cbe_position.set_period(0)

        self.plot_widget.stop = True

    def destroy(self):
        pass

    @staticmethod
    def has_device_identifier(device_identifier):
        return device_identifier == BrickletMotorizedLinearPoti.DEVICE_IDENTIFIER

    def cb_position(self, position):
        self.current_position.value = position
        self.slider.setValue(position)

    def get_motor_position_async(self, motor):
        self.motor_slider.blockSignals(True)
        self.motor_hold_position.blockSignals(True)
        self.motor_drive_mode.blockSignals(True)

        self.motor_hold_position.setChecked(motor.hold_position)
        self.motor_drive_mode.setCurrentIndex(motor.drive_mode)
        self.motor_position_label.setText(str(motor.position))
        self.motor_slider.setValue(motor.position)

        self.motor_slider.blockSignals(False)
        self.motor_hold_position.blockSignals(False)
        self.motor_drive_mode.blockSignals(False)

    def motor_slider_value_changed(self, position):
        self.motor_position_label.setText(str(position))
        self.mp.set_motor_position(self.motor_slider.value(), self.motor_drive_mode.currentIndex(), self.motor_hold_position.isChecked())