Python QSlider.setMinimum方法代码示例

# 需要导入模块: from PyQt5.QtWidgets import QSlider [as 别名]
# 或者: from PyQt5.QtWidgets.QSlider import setMinimum [as 别名]
class MyWindow(QMainWindow):

    def __init__(self):
        super().__init__()

        # 가로 슬라에더 생성
        self.slider = QSlider(Qt.Horizontal, self)  #<---- 1
        self.slider.setMaximum(1000)                #<---- 2
        self.slider.setMinimum(0)                   #<---- 3

        # 위치와 크기
        self.slider.setGeometry(30, 40, 100, 30)

        # 시그널 연결
        self.slider.valueChanged[int].connect(self.changeValue)  #<---- 4

        # 라벨 생성
        self.label = QLabel("current : 0", self)    #<----- 5
        self.label.setGeometry(30,70, 100, 30)

        # 윈도우 위치
        self.setGeometry(300, 300, 280, 170)
        self.setWindowTitle('Slider Example')
        self.show()


    def changeValue(self, value):                  #<----- 6
        "슬라이더 값 출력"
        self.label.setText("current : {}".format(value))  #<----- 7

# 需要导入模块: from PyQt5.QtWidgets import QSlider [as 别名]
# 或者: from PyQt5.QtWidgets.QSlider import setMinimum [as 别名]
class node_indicator(QWidget):
	def __init__(self):
		QWidget.__init__(self)
		self.hbox=QHBoxLayout()
		
		self.bar=progress_class()
		self.bar.spinner.stop()
		self.bar.spinner.hide()
		self.label=QLabel()
		
		self.slider = QSlider(Qt.Horizontal)
		self.slider.setMinimum(0)
		self.slider.setMaximum(10)

		self.slider.setTickPosition(QSlider.TicksBelow)
		self.slider.setTickInterval(1)
		#self.slider.valueChanged.connect(self.slider0_change)
		self.slider.setMinimumSize(300, 80)

		self.hbox.addWidget(self.label)
		self.hbox.addWidget(self.bar)
		self.hbox.addWidget(self.slider)

		self.setLayout(self.hbox)

	def set_cpus(self,cpus):
		self.slider.setValue(cpus)
	
	def set_text(self,text):
		self.label.setText(text)

# 需要导入模块: from PyQt5.QtWidgets import QSlider [as 别名]
# 或者: from PyQt5.QtWidgets.QSlider import setMinimum [as 别名]
class EditForm(QDialog):
    def __init__(self):
        super(EditForm, self).__init__()
        self.initUI(self)

    def initUI(self, EditForm):
        layout = QGridLayout(self)

        self.title_label = QLabel("Title:")
        self.title_line_edit = QLineEdit()
        self.rating_label = QLabel("Rating:")
        self.rating_slider = QSlider(Qt.Horizontal)
        self.rating_slider.setMinimum(0)
        self.rating_slider.setMaximum(5)
        self.rating_slider.setValue(0)
        self.rating_slider.setTickPosition(QSlider.TicksBelow)
        self.rating_slider.setTickInterval(5)

        self.review_label = QLabel("Review:")
        self.review_text_edit = QTextEdit()

        self.status_label = QLabel("Status:")
        self.status_combo_box = QComboBox()
        self.status_combo_box.addItems(["Read",
                                        "Currently Reading",
                                        "Want Тo Read"])
        self.edit_button = QPushButton("Edit book")

        layout.addWidget(self.title_label, 0, 0)
        layout.addWidget(self.title_line_edit, 0, 1)
        layout.addWidget(self.rating_label, 1, 0)
        layout.addWidget(self.rating_slider, 1, 1)
        layout.addWidget(self.review_label, 2, 0)
        layout.addWidget(self.review_text_edit, 2, 1)
        layout.addWidget(self.status_label, 3, 0)
        layout.addWidget(self.status_combo_box, 3, 1)
        layout.addWidget(self.edit_button, 4, 0, 1, 2, Qt.AlignCenter)

        self.setLayout(layout)
        self.edit_button.clicked.connect(self.edit_button_click)
        self.layout().setSizeConstraint(QLayout.SetFixedSize)
        self.setWindowTitle("Edit Book")
        self.setWindowIcon(QIcon(QPixmap('../images/edit.png')))

    def edit_button_click(self):
        title = self.title_line_edit.text()
        rating = self.rating_slider.value()
        review = self.review_text_edit.toPlainText()
        status = self.status_combo_box.currentText()

        if select_by_title(string.capwords(title)) == []:
            QMessageBox(QMessageBox.Critical, "Error",
                        "There is no such book in the library!").exec_()
        else:
            if update_entry(string.capwords(title), rating, review, status):
                QMessageBox(QMessageBox.Information, "Updated book info",
                            "You updated the info about this book!").exec_()
            else:
                QMessageBox(QMessageBox.Information, "Information",
                            "The book was NOT edited! Try again.").exec_()

# 需要导入模块: from PyQt5.QtWidgets import QSlider [as 别名]
# 或者: from PyQt5.QtWidgets.QSlider import setMinimum [as 别名]
class SpeedSettings(SettingsSection):

    NAME = 'Speed'
    ELEMENT = Speed

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

        self.id = Id

        self.groupBox = QGroupBox(self)
        self.groupBox.setGeometry(0, 0, self.width(), 80)

        self.layout = QHBoxLayout(self.groupBox)

        self.speedSlider = QSlider(self.groupBox)
        self.speedSlider.setMinimum(1)
        self.speedSlider.setMaximum(1000)
        self.speedSlider.setPageStep(1)
        self.speedSlider.setValue(100)
        self.speedSlider.setOrientation(QtCore.Qt.Horizontal)
        self.speedSlider.setTickPosition(QSlider.TicksAbove)
        self.speedSlider.setTickInterval(10)
        self.layout.addWidget(self.speedSlider)

        self.speedLabel = QLabel(self.groupBox)
        self.speedLabel.setAlignment(QtCore.Qt.AlignCenter)
        self.layout.addWidget(self.speedLabel)

        self.layout.setStretch(0, 3)
        self.layout.setStretch(1, 1)

        self.speedSlider.valueChanged.connect(self.speedChanged)

        self.retranslateUi()

    def retranslateUi(self):
        self.groupBox.setTitle("Speed")
        self.speedLabel.setText("1.0")

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

    def get_configuration(self):
        conf = {}

        if not (self.groupBox.isCheckable() and not self.groupBox.isChecked()):
            conf[self.id] = {'speed': self.speedSlider.value() / 100}

        return conf

    def set_configuration(self, conf):
        if conf is not None and self.id in conf:
            self.speedSlider.setValue(conf[self.id]['speed'] * 100)

    def speedChanged(self, value):
        self.speedLabel.setText(str(value / 100.0))

# 需要导入模块: from PyQt5.QtWidgets import QSlider [as 别名]
# 或者: from PyQt5.QtWidgets.QSlider import setMinimum [as 别名]
class SlidersGroup(QGroupBox):

    valueChanged = pyqtSignal(int)

    def __init__(self, orientation, title, parent=None):
        super(SlidersGroup, self).__init__(title, parent)

        self.slider = QSlider(orientation)
        self.slider.setFocusPolicy(Qt.StrongFocus)
        self.slider.setTickPosition(QSlider.TicksBothSides)
        self.slider.setTickInterval(10)
        self.slider.setSingleStep(1)

        self.scrollBar = QScrollBar(orientation)
        self.scrollBar.setFocusPolicy(Qt.StrongFocus)

        self.dial = QDial()
        self.dial.setFocusPolicy(Qt.StrongFocus)

        self.slider.valueChanged.connect(self.scrollBar.setValue)
        self.scrollBar.valueChanged.connect(self.dial.setValue)
        self.dial.valueChanged.connect(self.slider.setValue)
        self.dial.valueChanged.connect(self.valueChanged)

        if orientation == Qt.Horizontal:
            direction = QBoxLayout.TopToBottom
        else:
            direction = QBoxLayout.LeftToRight

        slidersLayout = QBoxLayout(direction)
        slidersLayout.addWidget(self.slider)
        slidersLayout.addWidget(self.scrollBar)
        slidersLayout.addWidget(self.dial)
        self.setLayout(slidersLayout)    

    def setValue(self, value):    
        self.slider.setValue(value)    

    def setMinimum(self, value):    
        self.slider.setMinimum(value)
        self.scrollBar.setMinimum(value)
        self.dial.setMinimum(value)    

    def setMaximum(self, value):    
        self.slider.setMaximum(value)
        self.scrollBar.setMaximum(value)
        self.dial.setMaximum(value)    

    def invertAppearance(self, invert):
        self.slider.setInvertedAppearance(invert)
        self.scrollBar.setInvertedAppearance(invert)
        self.dial.setInvertedAppearance(invert)    

    def invertKeyBindings(self, invert):
        self.slider.setInvertedControls(invert)
        self.scrollBar.setInvertedControls(invert)
        self.dial.setInvertedControls(invert)

# 需要导入模块: from PyQt5.QtWidgets import QSlider [as 别名]
# 或者: from PyQt5.QtWidgets.QSlider import setMinimum [as 别名]
class ControlWidget(QWidget):
    def __init__(self, parent):
        QWidget.__init__(self, parent)
        
        self.directionSlider = QSlider(Qt.Horizontal, self)
        self.directionSlider.setMinimum(0)
        self.directionSlider.setMaximum(360)

        self.direction = QLCDNumber(self)
        self.directionSlider.valueChanged.connect(self.direction.display)
        self.layout = QVBoxLayout()
        self.setLayout(self.layout)
        self.layout.addWidget(self.directionSlider)
        self.layout.addWidget(self.direction)

# 需要导入模块: from PyQt5.QtWidgets import QSlider [as 别名]
# 或者: from PyQt5.QtWidgets.QSlider import setMinimum [as 别名]
class _Slider(QWidget):
    """A popup slider.

    TODO: this slide can become a independent component?
    TODO: draw border radius for widget
    NOTE: inherit from QWidget instead of QSlider since QSlider can not
    work with Qt.Popup window flag well. Currently, I don't know why.
    """

    about_to_hide = pyqtSignal()

    def __init__(self, parent=None, initial_value=100):
        super().__init__(parent)

        self._slider = QSlider(self)
        self._layout = QVBoxLayout(self)
        self._layout.addWidget(self._slider)
        self._layout.setSpacing(0)
        # self._layout.setContentsMargins(0, 0, 0, 0)

        # map slider signal to widget
        self.valueChanged = self._slider.valueChanged

        self._slider.setMinimum(0)
        self._slider.setMaximum(100)
        self._slider.setValue(initial_value)
        self.setWindowFlags(Qt.Popup)

    def is_mute(self):
        return self._slider.value() <= 0

    def hideEvent(self, event):
        super().hideEvent(event)
        self.about_to_hide.emit()

    def showEvent(self, event):
        # TODO: move the position calculating logic to VolumeButton class
        # In general, the widget itself do not care about its position
        parent = self.parent()
        if parent:
            pgeom = parent.geometry()
            geom = self.geometry()
            x = (pgeom.width() - geom.width())//2
            y = -geom.height() - 10
            point = QPoint(x, y)
            self.move(parent.mapToGlobal(point))

# 需要导入模块: from PyQt5.QtWidgets import QSlider [as 别名]
# 或者: from PyQt5.QtWidgets.QSlider import setMinimum [as 别名]
class PercentSlider(QWidget):
    def __init__(self, parent):
        super(PercentSlider, self).__init__(parent)

        self._slider = QSlider(Qt.Vertical, self)
        self._slider.setMinimum(-100)
        self._slider.setMaximum(100)
        self._slider.setValue(0)
        self._slider.setTickInterval(100)
        self._slider.setTickPosition(QSlider.TicksBothSides)
        self._slider.valueChanged.connect(lambda: self._spinbox.setValue(self._slider.value()))

        self._spinbox = QSpinBox(self)
        self._spinbox.setMinimum(-100)
        self._spinbox.setMaximum(100)
        self._spinbox.setValue(0)
        self._spinbox.valueChanged.connect(lambda: self._slider.setValue(self._spinbox.value()))

        self._zero_button = make_icon_button("hand-stop-o", "Zero setpoint", self, on_clicked=self.zero)

        layout = QVBoxLayout(self)
        sub_layout = QHBoxLayout(self)
        sub_layout.addStretch()
        sub_layout.addWidget(self._slider)
        sub_layout.addStretch()
        layout.addLayout(sub_layout)
        layout.addWidget(self._spinbox)
        layout.addWidget(self._zero_button)
        self.setLayout(layout)

        self.setMinimumHeight(400)

    def zero(self):
        self._slider.setValue(0)

    def get_value(self):
        return self._slider.value()

# 需要导入模块: from PyQt5.QtWidgets import QSlider [as 别名]
# 或者: from PyQt5.QtWidgets.QSlider import setMinimum [as 别名]
 def multisig_dialog(self, run_next):
     cw = CosignWidget(2, 2)
     m_edit = QSlider(Qt.Horizontal, self)
     n_edit = QSlider(Qt.Horizontal, self)
     n_edit.setMinimum(2)
     n_edit.setMaximum(15)
     m_edit.setMinimum(1)
     m_edit.setMaximum(2)
     n_edit.setValue(2)
     m_edit.setValue(2)
     n_label = QLabel()
     m_label = QLabel()
     grid = QGridLayout()
     grid.addWidget(n_label, 0, 0)
     grid.addWidget(n_edit, 0, 1)
     grid.addWidget(m_label, 1, 0)
     grid.addWidget(m_edit, 1, 1)
     def on_m(m):
         m_label.setText(_('Require {0} signatures').format(m))
         cw.set_m(m)
     def on_n(n):
         n_label.setText(_('From {0} cosigners').format(n))
         cw.set_n(n)
         m_edit.setMaximum(n)
     n_edit.valueChanged.connect(on_n)
     m_edit.valueChanged.connect(on_m)
     on_n(2)
     on_m(2)
     vbox = QVBoxLayout()
     vbox.addWidget(cw)
     vbox.addWidget(WWLabel(_("Choose the number of signatures needed to unlock funds in your wallet:")))
     vbox.addLayout(grid)
     self.exec_layout(vbox, _("Multi-Signature Wallet"))
     m = int(m_edit.value())
     n = int(n_edit.value())
     return (m, n)

# 需要导入模块: from PyQt5.QtWidgets import QSlider [as 别名]
# 或者: from PyQt5.QtWidgets.QSlider import setMinimum [as 别名]
    def createBrightnessCtrl(self, name, value, i):
        sl = QSlider(Qt.Vertical)
        sl.setFocusPolicy(Qt.StrongFocus)
        sl.setTickPosition(QSlider.TicksBothSides)
        sl.setTickInterval(10)
        sl.setSingleStep(1)
        sl.setMinimum(5)
        sl.setMaximum(100)
        sl.setValue(value)

        sb = QSpinBox()
        sb.setRange(5, 100)
        sb.setSingleStep(10)
        sb.setValue(value)

        sl.valueChanged.connect(sb.setValue)
        sb.valueChanged.connect(sl.setValue)
        if i != None:
            sl.valueChanged.connect(self.setValuePartial(i))
            sb.valueChanged.connect(self.setValuePartial(i))

        boxLayout = QBoxLayout(QBoxLayout.LeftToRight)
        lbl = QLabel(name)
        boxLayout.addWidget(lbl)
        boxLayout.addWidget(sb)

        boxLayout.addWidget(sl)

        self.slidersLayout.addLayout(boxLayout)
        # stretch is between (label, spinner, slider) groups
        if i != None:
            self.slidersLayout.addStretch()

        self.sliders.append(sl)
#        self.spinBoxes.append(sl)
        self.labels.append(lbl)

# 需要导入模块: from PyQt5.QtWidgets import QSlider [as 别名]
# 或者: from PyQt5.QtWidgets.QSlider import setMinimum [as 别名]
    def initUI(self):
        #The genre drop down box
        genreCombo = QComboBox(self)
        #Some of the most popular genres
        genreCombo.addItem("Select Genre")
        genreCombo.addItem("Rap")
        genreCombo.addItem('Electronic')
        genreCombo.addItem("Techno")
        genreCombo.addItem("Rock")
        #Adds every genre on spotify to the list
        for i in range(len(genre_list)):
            genreCombo.addItem(genre_list[i])
        genreCombo.activated[str].connect(self.genreComboActivated)

        #The theme drop down box
        themeCombo = QComboBox(self)
        #Uses several base themes for tempo, loudness, etc...
        themeCombo.addItem("Select Theme")
        themeCombo.addItem("Workout")
        themeCombo.addItem('Study')
        themeCombo.addItem('Chill')
        themeCombo.addItem("Party")
        themeCombo.activated[str].connect(self.themeComboActivated)

        #A slider that creates an integer for use with the number of songs needed
        songCountSlider = QSlider(Qt.Horizontal, self)
        songCountSlider.setFocusPolicy(Qt.NoFocus)
        songCountSlider.setMinimum(1)
        songCountSlider.setMaximum(100)
        songCountSlider.valueChanged[int].connect(self.changeValue)

        #Labeled song count
        songCountLabel = QLabel('Song Count', self)

        #When pushed it runs the generatePlaylist method
        generatePlaylistPush = QPushButton('Generate Playlist', self)
        generatePlaylistPush.setToolTip('Generate your playlist!')
        generatePlaylistPush.clicked.connect(self.generatePlaylist)

        playlistNameForm = QLineEdit(self)
        playlistNameForm.setText('Enter Playlist Name')
        playlistNameForm.textChanged.connect(self.updatePlaylistName)

        # Layout control.
        hbox = QHBoxLayout()
        hbox.addStretch(1)

        vbox = QVBoxLayout()
        vbox.addStretch(1)
        vbox.addLayout(vbox)
        vbox.addWidget(playlistNameForm)
        vbox.addWidget(songCountLabel)
        vbox.addWidget(songCountSlider)
        vbox.addWidget(genreCombo)
        vbox.addWidget(themeCombo)
        vbox.addWidget(generatePlaylistPush)
        vbox.addLayout(hbox)
        self.setLayout(vbox)
        self.setGeometry(300, 300, 400, 300)
        self.setWindowTitle('Spotify Playlist Generator')  
        self.setWindowIcon(QIcon('spotify_256.png'))
        self.show()

# 需要导入模块: from PyQt5.QtWidgets import QSlider [as 别名]
# 或者: from PyQt5.QtWidgets.QSlider import setMinimum [as 别名]
class Ui_Widget(object):
    """ Klasa definiująca GUI """

    def setupUi(self, Widget):

        # widgety rysujące kształty, instancje klasy Ksztalt
        self.ksztalt1 = Ksztalt(self, Ksztalty.Polygon)
        self.ksztalt2 = Ksztalt(self, Ksztalty.Ellipse)
        self.ksztaltAktywny = self.ksztalt1

        # przyciski CheckBox ###
        uklad = QVBoxLayout()  # układ pionowy
        self.grupaChk = QButtonGroup()
        for i, v in enumerate(('Kwadrat', 'Koło', 'Trójkąt', 'Linia')):
            self.chk = QCheckBox(v)
            self.grupaChk.addButton(self.chk, i)
            uklad.addWidget(self.chk)
        self.grupaChk.buttons()[self.ksztaltAktywny.ksztalt].setChecked(True)
        # CheckBox do wyboru aktywnego kształtu
        self.ksztaltChk = QCheckBox('<=')
        self.ksztaltChk.setChecked(True)
        uklad.addWidget(self.ksztaltChk)

        # układ poziomy dla kształtów oraz przycisków CheckBox
        ukladH1 = QHBoxLayout()
        ukladH1.addWidget(self.ksztalt1)
        ukladH1.addLayout(uklad)
        ukladH1.addWidget(self.ksztalt2)
        # koniec CheckBox ###

        # Slider i LCDNumber ###
        self.suwak = QSlider(Qt.Horizontal)
        self.suwak.setMinimum(0)
        self.suwak.setMaximum(255)
        self.lcd = QLCDNumber()
        self.lcd.setSegmentStyle(QLCDNumber.Flat)
        # układ poziomy (splitter) dla slajdera i lcd
        ukladH2 = QSplitter(Qt.Horizontal, self)
        ukladH2.addWidget(self.suwak)
        ukladH2.addWidget(self.lcd)
        ukladH2.setSizes((125, 75))

        # przyciski RadioButton ###
        self.ukladR = QHBoxLayout()
        for v in ('R', 'G', 'B'):
            self.radio = QRadioButton(v)
            self.ukladR.addWidget(self.radio)
        self.ukladR.itemAt(0).widget().setChecked(True)
        # grupujemy przyciski
        self.grupaRBtn = QGroupBox('Opcje RGB')
        self.grupaRBtn.setLayout(self.ukladR)
        self.grupaRBtn.setObjectName('Radio')
        self.grupaRBtn.setCheckable(True)
        # układ poziomy dla grupy Radio
        ukladH3 = QHBoxLayout()
        ukladH3.addWidget(self.grupaRBtn)
        # koniec RadioButton ###

        # Lista ComboBox i SpinBox ###
        self.listaRGB = QComboBox(self)
        for v in ('R', 'G', 'B'):
            self.listaRGB.addItem(v)
        self.listaRGB.setEnabled(False)
        # SpinBox
        self.spinRGB = QSpinBox()
        self.spinRGB.setMinimum(0)
        self.spinRGB.setMaximum(255)
        self.spinRGB.setEnabled(False)
        # układ pionowy dla ComboBox i SpinBox
        uklad = QVBoxLayout()
        uklad.addWidget(self.listaRGB)
        uklad.addWidget(self.spinRGB)
        # do układu poziomego grupy Radio dodajemy układ ComboBox i SpinBox
        ukladH3.insertSpacing(1, 25)
        ukladH3.addLayout(uklad)
        # koniec ComboBox i SpinBox ###

        # przyciski PushButton ###
        uklad = QHBoxLayout()
        self.grupaP = QButtonGroup()
        self.grupaP.setExclusive(False)
        for v in ('R', 'G', 'B'):
            self.btn = QPushButton(v)
            self.btn.setCheckable(True)
            self.grupaP.addButton(self.btn)
            uklad.addWidget(self.btn)
        # grupujemy przyciski
        self.grupaPBtn = QGroupBox('Przyciski RGB')
        self.grupaPBtn.setLayout(uklad)
        self.grupaPBtn.setObjectName('Push')
        self.grupaPBtn.setCheckable(True)
        self.grupaPBtn.setChecked(False)
        # koniec PushButton ###

        # główny układ okna, wertykalny ###
        ukladOkna = QVBoxLayout()
        ukladOkna.addLayout(ukladH1)
        ukladOkna.addWidget(ukladH2)
        ukladOkna.addLayout(ukladH3)
        ukladOkna.addWidget(self.grupaPBtn)
#.........这里部分代码省略.........

# 需要导入模块: from PyQt5.QtWidgets import QSlider [as 别名]
# 或者: from PyQt5.QtWidgets.QSlider import setMinimum [as 别名]
class BookForm(QDialog):
    def __init__(self):
        super(BookForm, self).__init__()
        self.initUI(self)

    def initUI(self, BookForm):
        layout = QGridLayout(self)
        self.books = []

        self.isbn_label = QLabel("ISBN:")
        self.isbn_line_edit = QLineEdit()

        self.title_label = QLabel("Title:")
        self.title_line_edit = QLineEdit()

        self.author_label = QLabel("Author:")
        self.author_line_edit = QLineEdit()

        self.year_label = QLabel("Year:")
        self.year_line_edit = QLineEdit()

        self.genre_label = QLabel("Genre:")
        self.genre_combo_box = QComboBox()
        self.genre_combo_box.addItems(["Biography", "Business", "Chick Lit",
                                       "Classics", "Comics", "Contemporary",
                                       "Crime", "Fantasy", "Fiction",
                                       "Historical Fiction", "History",
                                       "Horror", "Humor and Comedy", "Memoir",
                                       "Mystery", "Nonfiction", "Paranormal",
                                       "Philosophy", "Poetry", "Psychology",
                                       "Romance", "Science", "Self Help",
                                       "Science Fiction", "Thriller",
                                       "Technical", "Young Adult", "Other"])
        self.rating_label = QLabel("Rating:")
        self.rating_slider = QSlider(Qt.Horizontal)
        self.rating_slider.setMinimum(0)
        self.rating_slider.setMaximum(5)
        self.rating_slider.setValue(0)
        self.rating_slider.setTickPosition(QSlider.TicksBelow)
        self.rating_slider.setTickInterval(5)

        self.review_label = QLabel("Review:")
        self.review_text_edit = QTextEdit()

        self.status_label = QLabel("Status:")
        self.status_combo_box = QComboBox()
        self.status_combo_box.addItems(["Read",
                                        "Currently Reading",
                                        "Want Тo Read"])

        self.add_button = QPushButton("Add Book")

        layout.addWidget(self.isbn_label, 0, 0)
        layout.addWidget(self.isbn_line_edit, 0, 1)
        layout.addWidget(self.title_label, 1, 0)
        layout.addWidget(self.title_line_edit, 1, 1)
        layout.addWidget(self.author_label, 2, 0)
        layout.addWidget(self.author_line_edit, 2, 1)
        layout.addWidget(self.year_label, 3, 0)
        layout.addWidget(self.year_line_edit, 3, 1)
        layout.addWidget(self.genre_label, 4, 0)
        layout.addWidget(self.genre_combo_box, 4, 1)
        layout.addWidget(self.rating_label, 5, 0)
        layout.addWidget(self.rating_slider, 5, 1)
        layout.addWidget(self.review_label, 6, 0)
        layout.addWidget(self.review_text_edit, 6, 1)
        layout.addWidget(self.status_label, 7, 0)
        layout.addWidget(self.status_combo_box, 7, 1)
        layout.addWidget(self.add_button, 8, 0, 1, 2, Qt.AlignCenter)

        self.setLayout(layout)
        self.add_button.clicked.connect(self.add_button_click)
        self.layout().setSizeConstraint(QLayout.SetFixedSize)
        self.setWindowTitle("Add Book")
        self.setWindowIcon(QIcon(QPixmap('../images/add.png')))

    def information_validation(self, year, isbn):
        return (not Validations.is_valid_year(year) or
                not Validations.is_valid_isbn(isbn))

    def error_message(self, year, isbn):
        validations = [Validations.is_valid_year, Validations.is_valid_isbn]
        var = [year, isbn]
        messages = ['year', 'ISBN']
        result = []
        for i in range(len(var)):
            if not validations[i](var[i]):
                result.append(messages[i] + ',')
        return ' '.join(result)

    def add_button_click(self):
        isbn = self.isbn_line_edit.text()
        title = self.title_line_edit.text()
        author = self.author_line_edit.text()
        year = self.year_line_edit.text()
        genre = self.genre_combo_box.currentText()
        rating = self.rating_slider.value()
        review = self.review_text_edit.toPlainText()
        status = self.status_combo_box.currentText()

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

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

#.........这里部分代码省略.........
            self._settings.value("control/autoplay_animation") == "True"
        )
        self.actAutoPlay.changed.connect(self.update_autoplay_setting)

        self.actPlayPause = QAction(self)
        self.actPlayPause.setText("Play Animation")
        self.actPlayPause.setIcon(QIcon(get_resource("play.png")))
        self.actPlayPause.setDisabled(True)
        self.actPlayPause.setShortcut(QKeySequence(Qt.Key_Space))
        self.actPlayPause.triggered.connect(self.play_animation)

        self.actStop = QAction(self)
        self.actStop.setText("Stop")
        self.actStop.setIcon(QIcon(get_resource("stop.png")))
        self.actStop.setDisabled(True)
        self.actStop.triggered.connect(self.stop_animation)

        self.actSlow = QAction(self)
        self.actSlow.setText("Slowest")
        self.actSlow.setIcon(QIcon(get_resource("slow.png")))
        self.actSlow.setDisabled(False)
        self.actSlow.triggered.connect(self.set_slowest_playback_speed)

        self.actFast = QAction(self)
        self.actFast.setText("Fastest")
        self.actFast.setIcon(QIcon(get_resource("fast.png")))
        self.actFast.setDisabled(False)
        self.actFast.triggered.connect(self.set_fastest_playback_speed)

        self.speedControl = QSlider(Qt.Horizontal, self)
        self.speedControl.setMaximumSize(200, 25)
        self.speedControl.setTickPosition(QSlider.TicksBothSides)
        self.speedControl.setDisabled(False)
        self.speedControl.setMinimum(0)
        self.speedControl.setMaximum(12)
        self.speedControl.setValue(6)
        self.speedControl.setTickInterval(6)
        self.speedControl.setSingleStep(2)
        self.speedControl.setPageStep(3)
        self.speedControl.valueChanged.connect(self.update_playback_speed)

        self.timeSlider = QSlider(Qt.Horizontal, self)
        self.timeSlider.setMinimum(0)
        self.timeSliderRange = 1000
        self.timeSlider.setMaximum(self.timeSliderRange)
        self.timeSlider.setTickInterval(1)
        self.timeSlider.setTracking(True)
        self.timeSlider.setDisabled(True)
        self.timeSlider.valueChanged.connect(self.update_playback_time)

        self.playbackTime = .0
        self.playbackGain = 1
        self.currentStepSize = .0
        self.currentEndTime = .0
        self.playbackTimer = QTimer()
        self.playbackTimer.timeout.connect(self.increment_playback_time)
        self.playbackTimeChanged.connect(self.update_gui)
        self.playbackTimeout = 33  # in [ms] -> 30 fps

        self.actResetCamera = QAction(self)
        self.actResetCamera.setText("Reset Camera")
        self.actResetCamera.setIcon(QIcon(get_resource("reset_camera.png")))
        self.actResetCamera.setDisabled(True)
        if available_vis:
            self.actResetCamera.setEnabled(self.visualizer.can_reset_view)
        self.actResetCamera.triggered.connect(self.reset_camera_clicked)

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

#.........这里部分代码省略.........
            self.tr("&Scripting Window"), self.scripting, "Ctrl+Alt+R")
        pythonMenu.addAction(
            self.tr("&Output Window"), self.outputWindow, "Ctrl+Alt+O")
        menuBar.addMenu(pythonMenu)

        windowMenu = QMenu(self.tr("&Windows"), self)
        action = windowMenu.addAction(
            self.tr("&Inspector"), self.inspector, "Ctrl+I")
        # XXX: we're getting duplicate shortcut when we spawn a new window...
        action.setShortcutContext(Qt.ApplicationShortcut)
        windowMenu.addAction(
            self.tr("&Metrics Window"), self.metrics, "Ctrl+Alt+S")
        windowMenu.addAction(
            self.tr("&Groups Window"), self.groups, "Ctrl+Alt+G")
        menuBar.addMenu(windowMenu)

        helpMenu = QMenu(self.tr("&Help"), self)
        helpMenu.addAction(self.tr("&About"), self.about)
        helpMenu.addAction(
            self.tr("About &Qt"), QApplication.instance().aboutQt)
        menuBar.addMenu(helpMenu)

        cellSize = 56
        self.glyphCellView = GlyphCellView(self)
        self.glyphCellView.glyphActivated.connect(self._glyphActivated)
        self.glyphCellView.glyphsDropped.connect(self._orderChanged)
        self.glyphCellView.selectionChanged.connect(self._selectionChanged)
        self.glyphCellView.setAcceptDrops(True)
        self.glyphCellView.setCellRepresentationName("TruFont.GlyphCell")
        self.glyphCellView.setCellSize(cellSize)
        self.glyphCellView.setFocus()

        self.cellSizeSlider = QSlider(Qt.Horizontal, self)
        self.cellSizeSlider.setMinimum(32)
        self.cellSizeSlider.setMaximum(116)
        self.cellSizeSlider.setFixedWidth(.9 * self.cellSizeSlider.width())
        self.cellSizeSlider.setValue(cellSize)
        self.cellSizeSlider.valueChanged.connect(self._sliderCellSizeChanged)
        self.selectionLabel = QLabel(self)
        statusBar = self.statusBar()
        statusBar.addPermanentWidget(self.cellSizeSlider)
        statusBar.addWidget(self.selectionLabel)

        self.setFont_(font)
        if font is not None:
            self.setCurrentFile(font.path)

        app = QApplication.instance()
        app.dispatcher.addObserver(
            self, "_preferencesChanged", "preferencesChanged")
        app.dispatcher.addObserver(self, "_fontSaved", "fontSaved")
        self._updateGlyphActions()

        self.setCentralWidget(self.glyphCellView)
        self.setWindowTitle()
        self.resize(605, 430)

    # --------------
    # Custom methods
    # --------------

    def font_(self):
        return self._font

    def setFont_(self, font):
        if self._font is not None: