Python QtWidgets.QSlider类代码示例

    def drawSpan(self, painter, rect):
        opt = QStyleOptionSlider()
        QSlider.initStyleOption(self, opt)

        # area
        groove = self.style().subControlRect(QStyle.CC_Slider, opt, QStyle.SC_SliderGroove, self)
        if opt.orientation == QtCore.Qt.Horizontal:
            groove.adjust(0, 0, -1, 0)
        else:
            groove.adjust(0, 0, 0, -1)

        # pen & brush
        painter.setPen(QPen(self.gradientLeftColor, 0))
        if opt.orientation == QtCore.Qt.Horizontal:
            self.setupPainter(painter, opt.orientation, groove.center().x(),
                              groove.top(), groove.center().x(),
                              groove.bottom())
        else:
            self.setupPainter(painter, opt.orientation, groove.left(),
                              groove.center().y(), groove.right(),
                              groove.center().y())

        # draw groove
        intersected = QtCore.QRectF(rect.intersected(groove))
        gradient = QLinearGradient(intersected.topLeft(), intersected.topRight())
        gradient.setColorAt(0, self.gradientLeft)
        gradient.setColorAt(1, self.gradientRight)
        painter.fillRect(intersected, gradient)

    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 createUI(self):
        """Set up the user interface, signals & slots
        """
        self.widget = QWidget(self)
        self.setCentralWidget(self.widget)

        # In this widget, the video will be drawn
        if sys.platform == "darwin": # for MacOS
            from PyQt5.QtWidgets import QMacCocoaViewContainer	
            self.videoframe = QMacCocoaViewContainer(0)
        else:
            self.videoframe = QFrame()
        self.palette = self.videoframe.palette()
        self.palette.setColor (QPalette.Window,
                               QColor(0,0,0))
        self.videoframe.setPalette(self.palette)
        self.videoframe.setAutoFillBackground(True)

        self.positionslider = QSlider(Qt.Horizontal, self)
        self.positionslider.setToolTip("Position")
        self.positionslider.setMaximum(1000)
        self.positionslider.sliderMoved.connect(self.setPosition)

        self.hbuttonbox = QHBoxLayout()
        self.playbutton = QPushButton("Play")
        self.hbuttonbox.addWidget(self.playbutton)
        self.playbutton.clicked.connect(self.PlayPause)

        self.stopbutton = QPushButton("Stop")
        self.hbuttonbox.addWidget(self.stopbutton)
        self.stopbutton.clicked.connect(self.Stop)

        self.hbuttonbox.addStretch(1)
        self.volumeslider = QSlider(Qt.Horizontal, self)
        self.volumeslider.setMaximum(100)
        self.volumeslider.setValue(self.mediaplayer.audio_get_volume())
        self.volumeslider.setToolTip("Volume")
        self.hbuttonbox.addWidget(self.volumeslider)
        self.volumeslider.valueChanged.connect(self.setVolume)

        self.vboxlayout = QVBoxLayout()
        self.vboxlayout.addWidget(self.videoframe)
        self.vboxlayout.addWidget(self.positionslider)
        self.vboxlayout.addLayout(self.hbuttonbox)

        self.widget.setLayout(self.vboxlayout)

        open = QAction("&Open", self)
        open.triggered.connect(self.OpenFile)
        exit = QAction("&Exit", self)
        exit.triggered.connect(sys.exit)
        menubar = self.menuBar()
        filemenu = menubar.addMenu("&File")
        filemenu.addAction(open)
        filemenu.addSeparator()
        filemenu.addAction(exit)

        self.timer = QTimer(self)
        self.timer.setInterval(200)
        self.timer.timeout.connect(self.updateUI)

class PlayerControls(QWidget):

    def __init__(self, parent=None):
        super().__init__(parent)
        layout = QHBoxLayout(self)

        self.seek_slider = QSlider(orientation=Qt.Horizontal, parent=self)
        self.volume_slider = QSlider(orientation=Qt.Horizontal, maximum=1000,
                                     parent=self)
        self.playback_time = QLabel(parent=self)
        self.duration = QLabel(parent=self)

        layout.addWidget(self.seek_slider)
        layout.addWidget(self.volume_slider)
        layout.addWidget(self.playback_time)
        layout.addWidget(self.duration)

        self.setLayout(layout)

    @pyqtSlot(float)
    def update_seek_slider_position(self, val):
        if not self.seek_slider.isSliderDown():
            self.seek_slider.setSliderPosition(val * 1000)

    @pyqtSlot(float)
    def update_seek_slider_maximum(self, val):
        self.seek_slider.setMaximum(val * 1000)

    @pyqtSlot(float)
    def update_duration(self, val):
        self.duration.setText('{:.2f}'.format(val))

    @pyqtSlot(float)
    def update_playback_time(self, val):
        self.playback_time.setText('{:.2f}'.format(val))

    def __init__(self, dockwidget):
        super(Widget, self).__init__(dockwidget)
        self._document = None
        self._fileSelector = QComboBox(editable=True, insertPolicy=QComboBox.NoInsert)
        gadgets.drag.ComboDrag(self._fileSelector).role = Qt.UserRole
        self._fileSelector.lineEdit().setReadOnly(True)
        self._fileSelector.lineEdit().setFocusPolicy(Qt.NoFocus)
        self._stopButton = QToolButton()
        self._playButton = QToolButton()
        self._timeSlider = QSlider(Qt.Horizontal, tracking=False,
            singleStep=500, pageStep=5000, invertedControls=True)
        self._display = Display()
        self._tempoFactor = QSlider(Qt.Vertical, minimum=-50, maximum=50,
            singleStep=1, pageStep=5)

        grid = QGridLayout(spacing=0)
        self.setLayout(grid)

        grid.addWidget(self._fileSelector, 0, 0, 1, 3)
        grid.addWidget(self._stopButton, 1, 0)
        grid.addWidget(self._playButton, 1, 1)
        grid.addWidget(self._timeSlider, 1, 2)
        grid.addWidget(self._display, 2, 0, 1, 3)
        grid.addWidget(self._tempoFactor, 0, 3, 3, 1)

        # size policy of combo
        p = self._fileSelector.sizePolicy()
        p.setHorizontalPolicy(QSizePolicy.Ignored)
        self._fileSelector.setSizePolicy(p)

        # size policy of combo popup
        p = self._fileSelector.view().sizePolicy()
        p.setHorizontalPolicy(QSizePolicy.MinimumExpanding)
        self._fileSelector.view().setSizePolicy(p)

        self._player = player.Player()
        self._outputCloseTimer = QTimer(interval=60000, singleShot=True,
            timeout=self.closeOutput)
        self._timeSliderTicker = QTimer(interval=200, timeout=self.updateTimeSlider)
        self._fileSelector.activated[int].connect(self.slotFileSelected)
        self._tempoFactor.valueChanged.connect(self.slotTempoChanged)
        self._timeSlider.valueChanged.connect(self.slotTimeSliderChanged)
        self._timeSlider.sliderMoved.connect(self.slotTimeSliderMoved)
        self._player.beat.connect(self.updateDisplayBeat)
        self._player.time.connect(self.updateDisplayTime)
        self._player.stateChanged.connect(self.slotPlayerStateChanged)
        self.slotPlayerStateChanged(False)
        dockwidget.mainwindow().currentDocumentChanged.connect(self.loadResults)
        app.documentLoaded.connect(self.slotDocumentLoaded)
        app.jobFinished.connect(self.slotUpdatedFiles)
        app.aboutToQuit.connect(self.stop)
        midihub.aboutToRestart.connect(self.slotAboutToRestart)
        midihub.settingsChanged.connect(self.clearMidiSettings, -100)
        midihub.settingsChanged.connect(self.readMidiSettings)
        app.documentClosed.connect(self.slotDocumentClosed)
        app.translateUI(self)
        self.readMidiSettings()
        d = dockwidget.mainwindow().currentDocument()
        if d:
            self.loadResults(d)

    def mousePressEvent(self, QMouseEvent):
        print("fug :-D")

        if QMouseEvent.button() == Qt.LeftButton:
            time = self.minimum() + ((self.maximum()-self.minimum()) * QMouseEvent.x()) / self.width()
            self.parent().seek(time)
            self.setValue(time)

        QSlider.mousePressEvent(self, QMouseEvent)

 def __init__(self, window, config, callback):
     QSlider.__init__(self, Qt.Horizontal)
     self.config = config
     self.window = window
     self.callback = callback
     self.dyn = False
     self.lock = threading.RLock()
     self.update()
     self.valueChanged.connect(self.moved)

    def createGUI(self):
        self.widget = QWidget(self)
        self.gvMain = MainView(self, 0, self.blocks)
        self.views = {key: XYZview(self, self.blocks, key)
                for key in ('xy', 'yz', 'zx')}
        self.cbSelectBox = QComboBox(self)
        self.pbAddBox = QPushButton("Add Box", self)
        self.pbDeleteBox = QPushButton("Delete selected box", self)
        self.slScale = QSlider(self)
        self.slScale.setOrientation(Qt.Horizontal)
        self.slScale.setRange(2, 15)
        self.slScale.setValue(5)
        self.slResolution = QSlider(self)
        self.slResolution.setOrientation(Qt.Horizontal)
        self.slResolution.setRange(1, 6) # resolution is 2**this_value
        self.slResolution.setValue(4) # 2**4 is 16 -- initial resolution
        self.turn_buttons = {'x': QPushButton("Turn around X axis", self),
                             'y': QPushButton("Turn around Y axis", self),
                             'z': QPushButton("Turn around Z axis", self)}
        self.swap_buttons = {'xy': QPushButton("Swap X and Y", self),
                             'yz': QPushButton("Swap Y and Z", self),
                             'zx': QPushButton("Swap Z and X", self)}
        self.grLayout = QGridLayout()
        self.grLayout.addWidget(QLabel("Main view"), 0, 0)
        self.grLayout.addWidget(self.gvMain, 1, 0)
        self.grLayout.addWidget(QLabel("Y view"), 0, 1)
        self.grLayout.addWidget(self.views['zx'], 1, 1)

        self.vbRightLayout = QVBoxLayout()
        self.vbRightLayout.addWidget(QLabel("Select box"))
        self.vbRightLayout.addWidget(self.cbSelectBox)
        self.vbRightLayout.addWidget(self.pbAddBox)
        self.vbRightLayout.addWidget(self.pbDeleteBox)
        self.vbRightLayout.addWidget(QLabel("Scale"))
        self.vbRightLayout.addWidget(self.slScale)
        self.vbRightLayout.addWidget(QLabel("Resolution"))
        self.vbRightLayout.addWidget(self.slResolution)
        self.vbRightLayout.addItem(
            QSpacerItem(0, 0, QSizePolicy.Minimum, QSizePolicy.Expanding))
        for button in self.swap_buttons.values():
            self.vbRightLayout.addWidget(button)
        for button in self.turn_buttons.values():
            self.vbRightLayout.addWidget(button)

        self.hbMainLayout = QHBoxLayout()
        self.hbMainLayout.addLayout(self.grLayout, 10)
        self.hbMainLayout.addLayout(self.vbRightLayout, 1)

        self.grLayout.addWidget(QLabel("X view"), 2, 0)
        self.grLayout.addWidget(self.views['yz'], 3, 0)
        self.grLayout.addWidget(QLabel("Z view"), 2, 1)
        self.grLayout.addWidget(self.views['xy'], 3, 1)
        self.widget.setLayout(self.hbMainLayout)
        self.setCentralWidget(self.widget)
        self.setWindowTitle("Nodebox editor")
        self.resize(1000, 600)

class ColorConvertor(QDialog):
    def __init__(self,parent=None):
        super().__init__(parent=parent)
        self.colorR = 255
        self.colorG = 255
        self.colorB = 255
        self.opacity = 255
        self.color = QColor(self.colorR,self.colorG,self.colorB)
        #RGB
        rgbLayout=QFormLayout()
        labelR = QLabel("R")
        self.sliderR = QSlider(Qt.Horizontal)
        labelG = QLabel("G")
        self.sliderG = QSlider(Qt.Horizontal)
        labelB = QLabel("B")
        self.sliderB = QSlider(Qt.Horizontal)
        labelOpacity = QLabel("opacity")
        self.sliderOpacity = QSlider(Qt.Horizontal)
        for (l,s) in ((labelR,self.sliderR),(labelG,self.sliderG),(labelB,self.sliderB),(labelOpacity,self.sliderOpacity)):
            rgbLayout.addRow(l,s)
            s.setMinimum(0)
            s.setMaximum(255)
            s.setValue(255)
            s.setSingleStep(10)
            s.valueChanged.connect(self.changeColor)


        self.label = QLabel()
        self.label.setTextInteractionFlags(Qt.TextSelectableByMouse)#可复制
        self.label.setText('''RGB:{colorR} {colorG} {colorB}  HTML:#{colorR:02X}{colorG:02X}{colorB:02X}
opacity:{opacity}'''.format(colorR=self.colorR,colorG=self.colorG,colorB=self.colorB,opacity=self.opacity))

        mainLayout=QVBoxLayout()
        mainLayout.addLayout(rgbLayout)
        mainLayout.addWidget(self.label)

        self.setLayout(mainLayout)

    def paintEvent(self,event):
        painter = QPainter()
        painter.begin(self)
        painter.fillRect(event.rect(),QBrush(self.color))
        painter.end()


    def changeColor(self,value):
        self.colorR = self.sliderR.value()
        self.colorG = self.sliderG.value()
        self.colorB = self.sliderB.value()
        self.opacity = self.sliderOpacity.value()
        self.color = QColor(self.colorR,self.colorG,self.colorB,self.opacity)

        self.label.setText('''RGB:{colorR} {colorG} {colorB}  HTML:#{colorR:02X}{colorG:02X}{colorB:02X}
opacity:{opacity}'''.format(colorR=self.colorR,colorG=self.colorG,colorB=self.colorB,opacity=self.opacity))
        self.update()

    def create_slider(self, label, idx, precision_sld, lower_bound, upper_bound, slider_fun):
        # create slider
        sld = QSlider(QtCore.Qt.Horizontal, self)
        sld.id = idx
        sld.precision = precision_sld

        # display label
        layout_disp = QHBoxLayout()
        sld.label = QLabel(label)
        sld.label.setAlignment(QtCore.Qt.AlignBottom | QtCore.Qt.AlignLeft)
        layout_disp.addWidget(sld.label)

        # display of current value
        sld.value = QLabel('Value: 0')
        sld.value.setAlignment(QtCore.Qt.AlignBottom | QtCore.Qt.AlignRight)
        layout_disp.addWidget(sld.value)

        # slider layout
        layout_sld = QVBoxLayout()
        layout_sld.addLayout(layout_disp)
        layout_sld.addWidget(sld)

        # settings
        sld.setFocusPolicy(QtCore.Qt.NoFocus)
        sld.valueChanged.connect(slider_fun)
        sld.setRange(int(np.round(lower_bound/precision_sld, 0)),
                     int(np.round(upper_bound/precision_sld, 0)))
        return layout_sld, sld

 def __init__(self, army):
     super().__init__()
     self.addLabels()
     self.cavSld = QSlider(Qt.Horizontal, self)
     self.cavSld.move(150, 40)
     self.infSld = QSlider(Qt.Horizontal, self)
     self.infSld.move(0, 40)
     self.addNumbers()
     accept = QPushButton("Accept", self)
     accept.move(100, 150)
     accept.clicked.connect(self.accept)

    def createEditor(self, parent, option, index):
        editor = QSlider(parent=parent, orientation=Qt.Horizontal)
        editor.setRange(0, 5)
        editor.setAutoFillBackground(True)

        editor.setTickPosition(QSlider.TicksBelow)
        editor.setTickInterval(1)

        return editor

    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)

class AudioPanSettings(SettingsSection):

    NAME = "Pan"
    ELEMENT = AudioPan

    def __init__(self, size, Id, parent=None):
        super().__init__(size, parent)

        self.id = Id

        self.panBox = QGroupBox(self)
        self.panBox.setGeometry(0, 0, self.width(), 80)
        self.panBox.setLayout(QHBoxLayout(self.panBox))

        self.panSlider = QSlider(self.panBox)
        self.panSlider.setRange(-10, 10)
        self.panSlider.setPageStep(1)
        self.panSlider.setOrientation(Qt.Horizontal)
        self.panSlider.valueChanged.connect(self.pan_changed)
        self.panBox.layout().addWidget(self.panSlider)

        self.panLabel = QLabel(self.panBox)
        self.panLabel.setAlignment(Qt.AlignCenter)
        self.panBox.layout().addWidget(self.panLabel)

        self.panBox.layout().setStretch(0, 5)
        self.panBox.layout().setStretch(1, 1)

        self.retransaleUi()

    def retransaleUi(self):
        self.panBox.setTitle("Audio Pan")
        self.panLabel.setText("Center")

    def enable_check(self, enable):
        self.panBox.setCheckable(enable)
        self.panBox.setChecked(False)

    def get_configuration(self):
        conf = {}

        if not (self.panBox.isCheckable() and not self.panBox.isChecked()):
            conf["panorama"] = self.panSlider.value() / 10

        return {self.id: conf}

    def set_configuration(self, conf):
        if conf is not None and self.id in conf:
            self.panSlider.setValue(conf[self.id]["panorama"] * 10)

    def pan_changed(self, value):
        if value < 0:
            self.panLabel.setText("Left")
        elif value > 0:
            self.panLabel.setText("Right")
        else:
            self.panLabel.setText("Center")

    def initUI(self):     
 
        sld = QSlider(Qt.Horizontal, self)
        sld.setFocusPolicy(Qt.NoFocus)
        sld.setGeometry(30, 40, 100, 30)
        sld.valueChanged[int].connect(self.changeValue)
         
        self.label = QLabel(self)
        self.label.setPixmap(QPixmap('mute.png'))
        self.label.setGeometry(160, 40, 80, 30)
         
        self.setGeometry(300, 300, 280, 170)
        self.setWindowTitle('QSlider')
        self.show()