Python QSlider.setValue方法代码示例

# 需要导入模块: from PyQt5.QtWidgets import QSlider [as 别名]
# 或者: from PyQt5.QtWidgets.QSlider import setValue [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 setValue [as 别名]
class OutputWidget(QWidget):

    Sections = {}

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

        # Import here for avoid circular import
        if len(self.Sections) == 0:
            from lisp.gst import settings
            OutputWidget.Sections = settings.sections_by_element_name()

        self._conf = conf

        self.gridLayout = QGridLayout(self)

        self.outputType = QLabel(self)
        self.outputType.setAlignment(Qt.AlignCenter)
        self.outputType.setText(conf['name'])
        self.gridLayout.addWidget(self.outputType, 0, 0, 1, 2)

        self.sinkSettings = QPushButton('Settings', self)
        self.sinkSettings.setEnabled(self._conf['name'] in self.Sections)
        self.sinkSettings.setIcon(QIcon.fromTheme('settings'))
        self.gridLayout.addWidget(self.sinkSettings, 0, 2)

        self.mute = QMuteButton(self)
        self.mute.setMute(conf.get('mute', False))
        self.gridLayout.addWidget(self.mute, 1, 0)

        self.volume = QSlider(Qt.Horizontal, self)
        self.volume.setRange(-100, 0)
        self.volume.setPageStep(1)
        volume = linear_to_db(conf.get('volume', 1))
        self.volume.setValue(volume)
        self.gridLayout.addWidget(self.volume, 1, 1)

        self.volumeLabel = QLabel(self)
        self.volumeLabel.setText(str(volume) + ' dB')
        self.volumeLabel.setAlignment(Qt.AlignCenter)
        self.gridLayout.addWidget(self.volumeLabel, 1, 2)

        self.volume.valueChanged.connect(self._volume_changed)
        self.sinkSettings.clicked.connect(self._settings)

    def get_settings(self):
        self._conf['volume'] = db_to_linear(self.volume.value())
        self._conf['mute'] = self.mute.isMute()

        return self._conf

    def _volume_changed(self, value):
        self.volumeLabel.setText(str(value) + ' dB')

    def _settings(self):
        dialog = SettingsDialog(self.Sections[self._conf['name']], self._conf)
        dialog.exec_()

        if dialog.result() == dialog.Accepted:
            self._conf.update(dialog.get_settings())

# 需要导入模块: from PyQt5.QtWidgets import QSlider [as 别名]
# 或者: from PyQt5.QtWidgets.QSlider import setValue [as 别名]
    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)

# 需要导入模块: from PyQt5.QtWidgets import QSlider [as 别名]
# 或者: from PyQt5.QtWidgets.QSlider import setValue [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 setValue [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 setValue [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 setValue [as 别名]
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")

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

    NAME = 'Pan'
    ELEMENT = AudioPan

    def __init__(self, element_id, **kwargs):
        super().__init__(element_id)
        self.setLayout(QVBoxLayout())
        self.layout().setAlignment(Qt.AlignTop)

        self.panBox = QGroupBox(self)
        self.panBox.setGeometry(0, 0, self.width(), 80)
        self.panBox.setLayout(QHBoxLayout(self.panBox))
        self.layout().addWidget(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_settings(self):
        conf = {}

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

        return {self.id: conf}

    def load_settings(self, settings):
        if settings is not None and self.id in settings:
            self.panSlider.setValue(settings[self.id]['pan'] * 10)

    def pan_changed(self, value):
        position = 'Left' if value < 0 else 'Right' if value > 0 else 'Center'
        self.panLabel.setText('{0} - {1}'.format(value, position))

# 需要导入模块: from PyQt5.QtWidgets import QSlider [as 别名]
# 或者: from PyQt5.QtWidgets.QSlider import setValue [as 别名]
class Slider(QSlider):
    def __init__(self, lower, upper, step_size, default):
        super(Slider, self).__init__()

        self.slider = QSlider(Qt.Horizontal)

        self.slider.setFocusPolicy(Qt.StrongFocus)
        self.slider.setTickPosition(QSlider.TicksBothSides)
        self.slider.setTickInterval(step_size)

        self.slider.setRange(lower, upper)
        self.slider.setSingleStep(step_size)
        self.slider.setValue(default)
        self.slider.setPageStep(step_size)

# 需要导入模块: from PyQt5.QtWidgets import QSlider [as 别名]
# 或者: from PyQt5.QtWidgets.QSlider import setValue [as 别名]
class Window(QWidget):
    """
    The main window of the application. Houses a media player and related
    controls.
    """
    def __init__(self):
        super().__init__()

        layout = QVBoxLayout()
        self.slider = QSlider(Qt.Horizontal)
        btnOpen = QPushButton("Open")
        btnPlay = QPushButton("Play")
        self.player = QMediaPlayer()
        tl = Timeline(None, None)
        tlscroll = QScrollArea()
        tlscroll.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        tlscroll.setWidget(tl)

        btnOpen.clicked.connect(self.open)
        btnPlay.clicked.connect(self.play)

        self.player.durationChanged.connect(self.durationChanged)
        self.player.positionChanged.connect(self.positionChanged)

        layout.addWidget(self.slider)
        layout.addWidget(btnOpen)
        layout.addWidget(btnPlay)
        layout.addWidget(tlscroll)
        self.setLayout(layout)

    def open(self):
        fileName = QFileDialog.getOpenFileName(self, "Open File")[0]
        fileInfo = QFileInfo(fileName)
        if fileInfo.exists():
            url = QUrl.fromLocalFile(fileInfo.absoluteFilePath())
            self.changeMedia(QMediaContent(url))

    def play(self):
        self.player.play()

    def changeMedia(self, mediaContent):
        self.player.setMedia(mediaContent)

    def durationChanged(self, duration):
        self.slider.setRange(0, duration)

    def positionChanged(self, position):
        self.slider.setValue(position)

# 需要导入模块: from PyQt5.QtWidgets import QSlider [as 别名]
# 或者: from PyQt5.QtWidgets.QSlider import setValue [as 别名]
    def add_slider_box(self, name, default, lower, upper):

        """

        Args:
            name:
            default:
            lower:
            upper:

        Returns:
            object:

        """

        slider_box = QGroupBox(name)
        slider_box_layout = QGridLayout()

        # Slider itself
        slider = QSlider(Qt.Horizontal)
        slider.setFocusPolicy(Qt.StrongFocus)
        slider.setTickPosition(QSlider.TicksBothSides)
        slider.setRange(lower, upper)
        slider.setValue(default)
        #slider.setTickInterval(10)
        slider.setSingleStep(upper-lower)

        # Textfield
        textfield = QSpinBox()
        textfield.setRange(lower, upper)
        textfield.setSingleStep(1)
        textfield.setValue(default)

        # Label
        title = QLabel("" + name + ": ")

        # Connect Textfield with Slider
        textfield.valueChanged.connect(slider.setValue)
        slider.valueChanged.connect(textfield.setValue)

        # Arrange Title, Slider and Textfield on the Box
        slider_box_layout.addWidget(title, 0, 0)
        slider_box_layout.addWidget(slider, 0, 1)
        slider_box_layout.addWidget(textfield, 0, 2)
        slider_box.setLayout(slider_box_layout)

        return slider_box

# 需要导入模块: from PyQt5.QtWidgets import QSlider [as 别名]
# 或者: from PyQt5.QtWidgets.QSlider import setValue [as 别名]
class window(QWidget):
    def __init__(self):
        super().__init__()
        self.windowUi()
        self.toolboxUi()
        self.myStyleSheet()

    def windowUi(self):
        self.setWindowFlags(Qt.WindowStaysOnTopHint | Qt.FramelessWindowHint)
        self.setGeometry(300, 0, 200, 500)
        self.show()

    def toolboxUi(self):
        self.quit = QPushButton()
        self.octSlider = QSlider(Qt.Horizontal)
        self.octSlider.setRange(40, 100)
        self.octSlider.setSingleStep(1)
        self.octSlider.setValue(100)
        self.octSlider.valueChanged.connect(self.changeOpacityValue)
        self.quit.clicked.connect(self.close)  # 关闭窗口

        hbox = QHBoxLayout()
        hbox.addStretch(1)
        hbox.addWidget(self.quit)
        hbox.addWidget(self.octSlider)

        self.vbox = QVBoxLayout()
        self.vbox.addStretch(1)
        self.vbox.addLayout(hbox)

        # self.setLayout(self.vbox)
        # self.show()

    def changeOpacityValue(self):
        self.setWindowOpacity(self.octSlider.value() * 0.01)

    def myStyleSheet(self):
        self.quit.setStyleSheet(
            'QPushButton{'
            'image:url(close.png); '
            'border:none; max-width:30px;}'
        )  # stylesheet设置样式表 css
        # self.quit.setIcon(QIcon('close.png'))

    def mouseMoveEvent(self, QMouseEvent):
        self.setMouseTracking(1)
        self.setLayout(self.vbox)

# 需要导入模块: from PyQt5.QtWidgets import QSlider [as 别名]
# 或者: from PyQt5.QtWidgets.QSlider import setValue [as 别名]
    def add_slider_box(self, name, default, lower, upper, row):
        """

        Args:
            row:
            name:
            default:
            lower:
            upper:

        Returns:
            object:

        """

        slider_box = QGridLayout()

        # Slider itself
        slider = QSlider(Qt.Horizontal)
        slider.setFocusPolicy(Qt.StrongFocus)
        slider.setTickPosition(QSlider.TicksBothSides)
        slider.setRange(lower, upper)
        slider.setValue(default)
        # ?slider.setTickInterval(10)?
        slider.setSingleStep(upper - lower)

        # Textfield
        textfield = QSpinBox()
        textfield.setRange(lower, upper)
        textfield.setSingleStep(1)
        textfield.setValue(default)

        # Label

        label = QLabel()
        label.setText(name + ": ")

        # Connect Textfield with Slider
        textfield.valueChanged.connect(slider.setValue)
        slider.valueChanged.connect(textfield.setValue)

        # Arrange Title, Slider and Textfield on the Box
        slider_box.addWidget(label, row, 0)
        slider_box.addWidget(slider, row, 1)
        slider_box.addWidget(textfield, row, 2)

        self.settingsLayout.setLayout(slider_box)

# 需要导入模块: from PyQt5.QtWidgets import QSlider [as 别名]
# 或者: from PyQt5.QtWidgets.QSlider import setValue [as 别名]
    def __init__(self, parent=None):
        super(VideoPlayer, self).__init__(parent)

        self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)

        self.videoItem = QGraphicsVideoItem()
        self.videoItem.setSize(QSizeF(640, 480))

        scene = QGraphicsScene(self)
        graphicsView = QGraphicsView(scene)

        scene.addItem(self.videoItem)

        rotateSlider = QSlider(Qt.Horizontal)
        rotateSlider.setRange(-180,  180)
        rotateSlider.setValue(0)
        rotateSlider.valueChanged.connect(self.rotateVideo)

        openButton = QPushButton("Open...")
        openButton.clicked.connect(self.openFile)

        self.playButton = QPushButton()
        self.playButton.setEnabled(False)
        self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
        self.playButton.clicked.connect(self.play)

        self.positionSlider = QSlider(Qt.Horizontal)
        self.positionSlider.setRange(0, 0)
        self.positionSlider.sliderMoved.connect(self.setPosition)

        controlLayout = QHBoxLayout()
        controlLayout.setContentsMargins(0, 0, 0, 0)
        controlLayout.addWidget(openButton)
        controlLayout.addWidget(self.playButton)
        controlLayout.addWidget(self.positionSlider)

        layout = QVBoxLayout()
        layout.addWidget(graphicsView)
        layout.addWidget(rotateSlider)
        layout.addLayout(controlLayout)

        self.setLayout(layout)

        self.mediaPlayer.setVideoOutput(self.videoItem)
        self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
        self.mediaPlayer.positionChanged.connect(self.positionChanged)
        self.mediaPlayer.durationChanged.connect(self.durationChanged)

# 需要导入模块: from PyQt5.QtWidgets import QSlider [as 别名]
# 或者: from PyQt5.QtWidgets.QSlider import setValue [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))