def __init__(self):
super(VideoWindow, self).__init__()
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
videoWidget = QVideoWidget()
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)
self.errorLabel = QLabel()
self.errorLabel.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
# Create layouts to place inside widget
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.setSpacing(0)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
layout.addWidget(videoWidget)
layout.addLayout(controlLayout)
layout.addWidget(self.errorLabel)
# layout.addWidget(self.start_btn)
# Set widget to contain window contents
self.setLayout(layout)
videoWidget.setFullScreen(False)
self.mediaPlayer.setVideoOutput(videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
class GUI(QWidget):
def __init__(self):
super(GUI, self).__init__()
self.layout = QVBoxLayout()
self.vw = QVideoWidget()
self.player = QMediaPlayer()
self.vw.setAspectRatioMode(Qt.IgnoreAspectRatio)
self.vw.setFullScreen(True)
self.layout.addWidget(self.vw)
self.setLayout(self.layout)
self.showMaximized()
def keyPressEvent(self, event):
if (event.key() == Qt.Key_Return):
self.player.play() # 播放视频
if (event.key() == Qt.Key_Space):
self.player.pause()
if event.key() == Qt.Key_S:
self.player.pause()
self.hide()
test = Camera(0)
test.runCamera()
self.show()
class Reproductor(Genesis, QMainWindow):
""" Instalar MatroskaSplitter y LAVFilters(Codecs), para que pueda reproducir videos y audio
LAVFilters
https://github.com/Nevcairiel/LAVFilters/releases
MatroskaSplitter
https://haali.su/mkv/
"""
def __init__(self, *args, **kwargs):
super(Reproductor, self).__init__()
self.transcurso = 0
# Centramos la ventana principal
self.centrar()
# Inicializamos el modulo QMediaPlayer
self.media = QMediaPlayer()
self.media.setVolume(5)
self.reproducir.setEnabled(False)
# Setup the playlist.
self.lista_repro = QMediaPlaylist()
self.media.setPlaylist(self.lista_repro)
self.modelo = ListaModelo(self.lista_repro)
self.lista.setModel(self.modelo)
self.lista_repro.currentIndexChanged.connect(self.cambio_lista_repro)
modelo_seleccion = self.lista.selectionModel()
modelo_seleccion.selectionChanged.connect(self.seleccion_lista_repro)
# ********** Inicializamos el modulo QVideoWidget *******
self.video = QVideoWidget()
# Agregamos el modulo QVideoWidget al grid donde se mostrara el video
self.reproductor.addWidget(self.video)
# Tambien lo agregamos al modulo QMediaPlayer
self.media.setVideoOutput(self.video)
# Conectamos el boton de reproducir con su metodo correspondiente
self.reproducir.clicked.connect(self.play_video)
# Conectamos el Skider del tiempo con su metodo correspondiente
self.tiempo.sliderMoved.connect(self.posicion_establecida)
# ****** Conectamos los estados del modulo QMediaPlayer con sus correspondientes metodos *****
self.media.stateChanged.connect(self.cambios_video)
self.media.positionChanged.connect(self.posicion_video)
self.media.durationChanged.connect(self.duracion_video)
self.total_duracion = 0
self.cargar.clicked.connect(self.abrir_archivo)
#self.marco.origen.connect(self.arrastrar_soltar)
self.parar.pressed.connect(self.media.stop)
self.atras.pressed.connect(self.lista_repro.previous)
self.adelante.pressed.connect(self.lista_repro.next)
self.volumen.valueChanged.connect(self.media.setVolume)
self.logo_volumen.clicked.connect(self.silenciar)
self.lista.doubleClicked.connect(self.play_video)
self.video.keyPressEvent = self.keyPressEvent
# ****** Boton de menu ******
self.lista.setMinimumSize(QSize(0, 0))
self.lista_visible = True
self.menu.clicked.connect(self.boton_menu)
self.setAcceptDrops(True)
self.primera_reproduccion = True
self.show()
# ---------------- Inicio de Metodos --------------------------- #
# Detectamos una tecla presionada
def keyPressEvent(self, event):
if event.key() == Qt.Key_F11 or event.key() == Qt.Key_Escape and self.video.isFullScreen():
self.fullscreen_change()
elif event.key() == Qt.Key_Space:
self.play_video()
#Pantalla completa
def fullscreen_change(self):
if self.video.isFullScreen():
self.video.setFullScreen(False)
self.lista.setMinimumSize(QSize(300, 16777215))
else:
self.video.setFullScreen(True)
# Ocultar y mostrar la lista de reproduccion
def boton_menu(self):
if self.lista_visible:
self.lista.setVisible(False)
size_policy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.marco.setSizePolicy(size_policy)
self.lista_visible = False
else:
self.lista.setVisible(True)
self.lista_visible = True
# Metodos para arrastrar y soltar en la lista de reproduccion
def dragEnterEvent(self, e):
if e.mimeData().hasUrls():
e.acceptProposedAction()
# Metodos para arrastrar y soltar en la lista de reproduccion
def dropEvent(self, e):
for url in e.mimeData().urls():
self.lista_repro.addMedia(QMediaContent(url))
self.lista_repro.setPlaybackMode(QMediaPlaylist.Loop)
self.media.setPlaylist(self.lista_repro)
self.reproducir.setEnabled(True)
self.reproductor.removeWidget(self.logo)
self.media.play()
self.modelo.layoutChanged.emit()
"""
# If not playing, seeking to first of newly added + play.
if self.media.state() != QMediaPlayer.PlayingState:
#i = self.lista_repro.mediaCount() - len(e.mimeData().urls())
#print(i)
#self.lista_repro.setCurrentIndex(i)
self.reproducir.setEnabled(True)
self.reproductor.removeWidget(self.logo)
#self.media.setPlaylist(playlist)
self.media.play() """
# Metodo para cargar el video en cuestion
def abrir_archivo(self):
archivo, _ = QFileDialog.getOpenFileName(self, ' Abrir Archivo !!!', 'C:/Users/Duque/Videos', 'Solo Video (*.mp4 *.mov *.flv *.mkv *.ts *.mts *.avi);; Solo Audio (*.mp3 *.flac *.m4a *.wav)')
if archivo != '':
self.reproductor.removeWidget(self.logo)
self.primera_reproduccion = False
self.lista_repro.addMedia(QMediaContent(QUrl.fromLocalFile(archivo)))
self.reproducir.setEnabled(True)
self.modelo.layoutChanged.emit()
# Metodo para el cambio en la lista de reproduccion
def cambio_lista_repro(self, i):
if i > -1:
ix = self.modelo.index(i)
self.lista.setCurrentIndex(ix)
# Metodo para la seleccion en la lista de reproduccion
def seleccion_lista_repro(self, ix):
i = ix.indexes()[0].row()
self.lista_repro.setCurrentIndex(i)
# Metodo para silenciar el audio o video
def silenciar(self):
if self.media.isMuted():
self.media.setMuted(False)
icon = QIcon()
icon.addPixmap(QPixmap(":/img/altavoz3.png"), QIcon.Normal, QIcon.Off)
self.logo_volumen.setIcon(icon)
self.logo_volumen.setToolTip(' Silenciar ')
else:
self.media.setMuted(True)
icon = QIcon()
icon.addPixmap(QPixmap(":/img/altavoz4.png"), QIcon.Normal, QIcon.Off)
self.logo_volumen.setIcon(icon)
self.logo_volumen.setToolTip(' Restablecer Sonido ')
@pyqtSlot(str)
def arrastrar_soltar(self, archivo):
if archivo != '':
self.media.setMedia(QMediaContent(QUrl.fromLocalFile(archivo)))
self.reproducir.setEnabled(True)
self.lista_repro.addMedia(QMediaContent(QUrl.fromLocalFile(archivo)))
self.modelo.layoutChanged.emit()
# Metodo para reproducir el video en cuestion
def play_video(self):
if self.primera_reproduccion:
self.reproductor.removeWidget(self.logo)
self.primera_reproduccion = False
if self.media.state() == QMediaPlayer.PlayingState:
self.media.pause()
else:
self.media.play()
# Metodo que detecta el estado de cambio del boton reproducir de play a pausa y viceversa
def cambios_video(self, state):
if self.media.state() == QMediaPlayer.PlayingState:
icon = QIcon()
icon.addPixmap(QPixmap(":/img/pausa.png"), QIcon.Normal, QIcon.Off)
self.reproducir.setIcon(icon)
self.reproducir.setToolTip(' Pausar Video o Audio ')
QToolTip.setFont(QFont('Cascadia Code PL', 18))
else:
icon = QIcon()
icon.addPixmap(QPixmap(":/img/play.svg"), QIcon.Normal, QIcon.Off)
self.reproducir.setIcon(icon)
self.reproducir.setToolTip(' Reproducir Video o Audio ')
QToolTip.setFont(QFont('Cascadia Code PL', 18))
def duracion_video(self, duracion):
"""
# Detecta la duración del vídeo en el slider.
"""
self.tiempo.setMaximum(duracion)
self.total_duracion = duracion
# Metodo que detecta la posiscion del video en el slider
def posicion_video(self, posicion):
if posicion >= 0:
reproduccion = f'{detalle_tiempo(posicion)} || {detalle_tiempo(self.total_duracion)}'
self.datos.setText(reproduccion)
self.tiempo.blockSignals(True)
self.tiempo.setValue(posicion)
self.tiempo.blockSignals(False)
# Metodo que detecta la posiscion establecida del modulo QMediaPlayer
def posicion_establecida(self, position):
self.media.setPosition(position)
def errores(self):
self.reproducir.setEnabled(False)
# self.lbl.setText("Error: " + self.media.errorString())
# Metodo para centrar la ventana principal
def centrar(self):
ventana = self.frameGeometry()
centro = QDesktopWidget().availableGeometry().center()
# print(centro)
ventana.moveCenter(centro)
self.move(ventana.topLeft())
class Player(QWidget):
"""Sub-class of QWidget"""
def __init__(self, parent=None, *args, **kwargs):
"""Initialize class attributes"""
super(Player, self).__init__(parent, *args, **kwargs)
self.init_ui()
def init_ui(self):
"""Create local components"""
# loop
self.loop = False
# time label text
self.time_text = '{:0>2d}:{:0>2d}:{:0>2d}/{:0>2d}:{:0>2d}:{:0>2d}'
self.hours = self.minutes = self.seconds = 0
# create media player object
self.mediaPlayer = QMediaPlayer(self, QMediaPlayer.VideoSurface)
# create videowidget object
self.videoWidget = QVideoWidget()
# create open button
self.btn_size = QSize(16, 16)
openButton = Button("Open")
openButton.setToolTip("Open Media File")
openButton.setStatusTip("Open Media File")
openButton.setFixedHeight(24)
openButton.setIconSize(self.btn_size)
openButton.setIcon(
QIcon.fromTheme("document-open", QIcon("Icons/Open.bmp")))
# openButton.setStyleSheet("background-color: #B0C4DE")
openButton.clicked.connect(self.abrir)
# create play button
self.playButton = Button()
self.playButton.setEnabled(False)
self.playButton.setFixedHeight(24)
self.playButton.setIconSize(self.btn_size)
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
# self.playButton.setStyleSheet("background-color: #B0C4DE")
self.playButton.clicked.connect(self.play)
# create slider
self.positionSlider = PositionSlider(self.mediaPlayer, Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.setObjectName("positionSlider")
# create status bar
self.statusBar = QStatusBar()
self.statusBar.setFont(QFont("Noto sans", 8))
self.statusBar.setFixedHeight(14)
self.statusBar.setStyleSheet('color:#ffffff')
# create duration time label
self.durationLabel = QLabel()
self.durationLabel.setStyleSheet(
'background-color:rgba(255, 255, 255, 0)')
self.durationLabel.setText('00:00:00/00:00:00')
# create hbox layout
controlLayoutWidget = QWidget(self)
controlLayout = QHBoxLayout(controlLayoutWidget)
controlLayoutWidget.setLayout(controlLayout)
controlLayout.setContentsMargins(2, 2, 2, 2)
# set widgets to the hbox layout
controlLayout.addWidget(openButton)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
controlLayout.addWidget(self.durationLabel)
# change hbox color
controlLayoutWidget.setStyleSheet(
'background-color:rgba(255, 255, 255, 50)')
controlLayoutWidget.setWindowOpacity(0.1)
# create vbox layout
self.layout = QVBoxLayout()
self.layout.setSpacing(0)
# set widgets to vbox layout
self.layout.addWidget(self.videoWidget)
self.layout.addWidget(controlLayoutWidget)
self.sub_controls()
self.layout.addWidget(self.statusBar)
self.setLayout(self.layout)
self.mediaPlayer.setVideoOutput(self.videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
self.statusBar.showMessage('{:->33s}{:-<33s}'.format("Have Fun", ""))
self.key_bindings()
def key_bindings(self):
# bind Keys to methods
self.onplaypause = self.create_shortcut(Qt.Key_Space, self.videoWidget,
self.play) # Space key for
self.on_fscreen = self.create_shortcut(
Qt.Key_F, self.videoWidget,
self.toggle_fullscreen) # F key for fullscreen on
self.onforward = self.create_shortcut(
Qt.Key_Right, self.videoWidget,
self.forward) # Right key for forward
self.redvolume = self.create_shortcut(
Qt.Key_Down, self.videoWidget,
self.red_volume) # Down key reduce volume
self.incvolume = self.create_shortcut(
Qt.Key_Up, self.videoWidget,
self.inc_volume) # Up key increase volume
self.onsetloop = self.create_shortcut(
"L",
self.videoWidget, # L key for repeat on,
(lambda self=self: self.repeat.toggle() or self.play_again()))
self.onrewind = self.create_shortcut(
Qt.Key_Left, self.videoWidget, self.rewind) # Left key for rewind
self.volmute = self.create_shortcut(Qt.Key_M, self.videoWidget,
self.mute) # M for mute and unmute
self.onopen = self.create_shortcut('Ctrl+O', self.videoWidget,
self.abrir) # Ctrl+O for open
self.onstop = self.create_shortcut(Qt.Key_S, self.videoWidget,
self.stop_media) # S key for stop
def create_shortcut(self, sequence, widget, obj):
"""generate key shortcuts"""
return QShortcut(QKeySequence(sequence),
widget,
obj,
context=Qt.ApplicationShortcut)
def sub_controls(self):
"""Repeat, volume, and mute controls"""
# repeat button
self.repeat = Button()
self.repeat.setCheckable(True)
self.repeat.toggle()
self.repeat.setIconSize(self.btn_size)
self.repeat.setFixedHeight(24)
self.repeat.setFixedWidth(26)
self.repeat.setToolTip("repeat")
self.repeat.setStatusTip("repeat")
# Icons to correspond with button state
icon = QIcon()
icon.addPixmap(QPixmap(os.path.join(FOLDER, "Icons/repeat(1).png")),
QIcon.Normal, QIcon.On)
icon.addPixmap(QPixmap(os.path.join(FOLDER, "Icons/repeat(2).png")),
QIcon.Active)
self.repeat.setIcon(icon)
# self.repeat.setStyleSheet("background-color: #B0C4DE; margin: 0px 0px 0px 2px;")
self.repeat.clicked.connect(self.play_again)
# stop button
self.stop = Button()
self.stop.setIconSize(self.btn_size)
self.stop.setFixedHeight(24)
self.stop.setFixedWidth(26)
self.stop.setToolTip("Stop playing media")
self.stop.setStatusTip("Stop playing media")
self.stop.setIcon(self.style().standardIcon(QStyle.SP_MediaStop))
# self.stop.setStyleSheet("background-color: #B0C4DE; margin: 0px 0px 0px 2px;")
self.stop.clicked.connect(self.stop_media)
# volume slider
self.volumeSlider = VolumeSlider(self.mediaPlayer, Qt.Horizontal)
self.volumeSlider.setRange(0, 100)
self.volumeSlider.setFixedWidth(200)
self.mediaPlayer.setVolume(50)
self.volumeSlider.sliderMoved.connect(self.set_volume)
# volume button
self.volume = Button(self)
self.volume.setIconSize(self.btn_size)
self.volume.setFixedHeight(24)
self.volume.setFixedWidth(26)
self.volume.setToolTip("Mute or Unmute")
self.volume.setStatusTip("Mute or Unmute")
self.volume.setIcon(self.style().standardIcon(QStyle.SP_MediaVolume))
# self.volume.setStyleSheet("background-color: #B0C4DE; margin: 0px 0px 0px 2px;")
self.volume.clicked.connect(self.mute)
# create control widget
subControlWidget = QWidget(self)
subControlWidget.setStyleSheet(
'background-color:rgba(255, 255, 255, 30)')
# create Horizontal Layout
subControlLayout = QHBoxLayout(subControlWidget)
subControlLayout.setContentsMargins(0, 0, 0, 0)
subControlLayout.addWidget(self.repeat, 0, Qt.AlignLeft)
subControlLayout.addWidget(self.stop, 1, Qt.AlignLeft)
# sub layout for volume control
self.sub_layout = QHBoxLayout()
self.sub_layout.addWidget(self.volume)
self.sub_layout.addWidget(self.volumeSlider)
subControlLayout.addLayout(self.sub_layout)
subControlLayout.setContentsMargins(2, 2, 2, 2)
self.layout.addWidget(subControlWidget)
def abrir(self, event=None, url=None):
"""" Equivalent to open for most GUIs"""
fileName = None
if self.videoWidget.isFullScreen():
self.toggle_fullscreen()
if not url:
fileName, _ = QFileDialog.getOpenFileName(self, "Select media")
if fileName:
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
else:
self.mediaPlayer.setMedia(QMediaContent(QUrl(url)))
if url or fileName:
self.volumeSlider.setValue(self.mediaPlayer.volume())
self.playButton.setEnabled(True)
self.statusBar.showMessage((fileName or url))
if not self.loop:
self.play()
def play(self):
"""Start media player"""
if self.playButton.isEnabled():
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
"""Callback for media player state change"""
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
if state == QMediaPlayer.StoppedState and self.loop:
self.play()
def positionChanged(self, position):
"""Callback for media player position change"""
if self.mediaPlayer.state() == QMediaPlayer.StoppedState:
position = 0
self.positionSlider.setValue(position)
hours, position = position // 3600000, position % 3600000
minutes, position = position // 60000, position % 60000
seconds = position // 1000
self.durationLabel.setText(
self.time_text.format(hours, minutes, seconds, self.hours,
self.minutes, self.seconds))
def durationChanged(self, duration):
"""Callback for media player duration of media change"""
self.positionSlider.setRange(0, duration)
self.hours, duration = duration // 3600000, duration % 3600000
self.minutes, duration = duration // 60000, duration % 60000
self.seconds = duration // 1000
self.durationLabel.setText(
self.time_text.format(0, 0, 0, self.hours, self.minutes,
self.seconds))
def setPosition(self, position):
"""set media player play position"""
self.mediaPlayer.setPosition(position)
def handleError(self):
"""Callback for multiplayer errors"""
self.playButton.setEnabled(False)
self.statusBar.showMessage("Error: " + self.mediaPlayer.errorString())
def play_again(self):
"""Set repeat on or off"""
self.loop = not self.loop
def stop_media(self):
"""Callback for stop button"""
if self.loop:
self.loop = False
self.repeat.toggle()
self.mediaPlayer.stop()
def toggle_fullscreen(self):
"""Toggle in or out of fullscreen mode"""
self.videoWidget.setWindowFlags(Qt.FramelessWindowHint
| Qt.WindowStaysOnTopHint)
if self.videoWidget.isFullScreen():
self.videoWidget.setFullScreen(False)
self.videoWidget.setWindowState(Qt.WindowNoState)
self.videoWidget.setParent(self)
self.layout.insertWidget(0, self.videoWidget)
self.videoWidget.showNormal()
self.show()
else:
self.videoWidget.setFullScreen(True)
self.hide()
def rewind(self, lapse=2500):
"""Rewind the current media file by 1 second"""
new_position = self.mediaPlayer.position() - lapse
self.setPosition(new_position)
def forward(self, lapse=2500):
"""Forward media file by 1 second"""
new_position = self.mediaPlayer.position() + lapse
self.setPosition(new_position)
def set_volume(self, vol=0):
"""Set media player volume volume"""
if vol:
self.mediaPlayer.setVolume(vol)
def red_volume(self, vol=1):
"""Reduce volume by a factor of 0.01"""
volume = self.mediaPlayer.volume()
if volume >= 0:
new_volume = volume - 1
self.volumeSlider.setValue(new_volume)
self.set_volume(new_volume)
def inc_volume(self, vol=1):
"""Increase volume by a factor of 0.01"""
volume = self.mediaPlayer.volume()
if self.mediaPlayer.isMuted():
self.mediaPlayer.setMuted(False)
self.volume.setIcon(self.style().standardIcon(
QStyle.SP_MediaVolume))
if volume <= 100:
new_volume = volume + 1
self.volumeSlider.setValue(new_volume)
self.set_volume(new_volume)
def mute(self):
"""Mute media player"""
if self.mediaPlayer.isMuted():
self.mediaPlayer.setMuted(False)
self.volume.setIcon(self.style().standardIcon(
QStyle.SP_MediaVolume))
else:
self.mediaPlayer.setMuted(True)
self.volume.setIcon(self.style().standardIcon(
QStyle.SP_MediaVolumeMuted))
class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
# Controles principales para organizar la ventana.
self.setupConstants()
self.widget = QWidget(self)
# tha main layout
self.layout = QVBoxLayout()
# the top box with file selections
self.input_layout = QHBoxLayout()
self.output_layout = QHBoxLayout()
self.bottom_layout = QHBoxLayout()
self.volume_box = QHBoxLayout()
# video playback section
self.video_widget = QVideoWidget(self)
self.media_player = QMediaPlayer()
self.media_player.setVideoOutput(self.video_widget)
# initialize audio recording section
self.recorder = QAudioRecorder()
# labels
self.volume_label = QLabel()
self.volume_label.setText("Volume")
# Buttons for the I/O files selection
self.input_file_button = QPushButton("Video Input", self)
self.output_file_button = QPushButton("Audio output", self)
# path/file line edits
self.input_file_edit = QLineEdit()
self.output_file_edit = QLineEdit()
self.play_button = QPushButton("", self)
self.play_button.setIcon(self.play_normal_icon)
self.play_button.resize(150, 150)
self.stop_button = QPushButton("", self)
self.stop_button.setIcon(self.stop_normal_icon)
self.record_button = QPushButton("", self)
self.record_button.setCheckable(True)
self.record_button.setIcon(self.rec_icon)
self.seek_slider = QSlider(Qt.Horizontal)
self.volume_slider = QSlider(Qt.Horizontal)
self.volume_slider.setRange(0, 100)
self.volume_slider.setValue(self.media_player.volume())
self.input_layout.addWidget(self.input_file_button)
self.input_layout.addWidget(self.input_file_edit)
self.output_layout.addWidget(self.output_file_button)
self.output_layout.addWidget(self.output_file_edit)
self.bottom_layout.addWidget(self.play_button)
self.bottom_layout.addWidget(self.stop_button)
self.bottom_layout.addWidget(self.record_button)
self.bottom_layout.addLayout(self.volume_box)
self.volume_box.addWidget(self.volume_label)
self.volume_box.addWidget(self.volume_slider)
self.layout.addWidget(self.video_widget)
self.layout.addLayout(self.bottom_layout)
self.layout.addWidget(self.seek_slider)
self.layout.addLayout(self.input_layout)
self.layout.addLayout(self.output_layout)
# Personalizzazione della finestra
self.setWindowTitle("Wish' Karaoke! :)")
self.resize(800, 600)
self.layout.setContentsMargins(10, 10, 10, 10)
self.bottom_layout.setContentsMargins(0, 0, 0, 0)
self.widget.setLayout(self.layout)
self.setCentralWidget(self.widget)
self.setupMenus()
self.setupUiConnections()
def setupMenus(self):
# setup the menus
self.mainMenu = self.menuBar()
# File menu and subitems
self.fileMenu = self.mainMenu.addMenu('File')
self.exitButton = QAction(self.exit_icon, 'Exit', self)
self.exitButton.setShortcut('Ctrl+Q')
self.exitButton.setStatusTip('Exit application')
self.fileMenu.addAction(self.exitButton)
# View menu and related items
self.viewMenu = self.mainMenu.addMenu('View')
# Fullscreen item
self.toggleFullscreenButton = QAction(QIcon(""), 'Fullscreen', self)
self.toggleFullscreenButton.setCheckable(True)
self.toggleFullscreenButton.setStatusTip('Toggle fullscreen more')
self.toggleFullscreenButton.setShortcut("CTRL+SHIFT+F")
self.viewMenu.addAction(self.toggleFullscreenButton)
# Tools menu and related items
self.toolsMenu = self.mainMenu.addMenu('Tools')
# Play/Rec bind toggle
self.bindPlayRecButton = QAction(QIcon(""), 'Bind Play/Rec', self)
self.bindPlayRecButton.setCheckable(True)
self.bindPlayRecButton.setStatusTip('Bind Play and Rec')
self.toolsMenu.addAction(self.bindPlayRecButton)
def setupUiConnections(self):
"""
Put all the UI connections and event catchers here, just to keep the code clean
:return:
"""
self.record_button.clicked.connect(self.recButtonState)
self.seek_slider.sliderMoved.connect(self.media_player.setPosition)
self.volume_slider.sliderMoved.connect(self.media_player.setVolume)
self.media_player.positionChanged.connect(self.seek_slider.setValue)
self.media_player.durationChanged.connect(
partial(self.seek_slider.setRange, 0))
self.play_button.clicked.connect(self.play_clicked)
self.stop_button.clicked.connect(self.stop_clicked)
self.media_player.stateChanged.connect(self.state_changed)
#
self.input_file_button.clicked.connect(self.selectInputFile)
#
self.input_file_edit.textChanged.connect(self.setInputMedia)
#
self.output_file_button.clicked.connect(self.selectOutputFile)
self.output_file_edit.textChanged.connect(self.setOutputMedia)
# menu connections
# fullscreen
self.toggleFullscreenButton.toggled.connect(self.toggleFullscreen)
# quit
self.exitButton.triggered.connect(self.close)
# Play/Rec bind
self.bindPlayRecButton.toggled.connect(self.bind_play_rec)
# Installing event filter for the video widget
self.video_widget.installEventFilter(self)
def bind_play_rec(self):
"""
toggle the binding between play and rec to start recording as soon as playback starts.
:return: Nothing
"""
if not self.bindPlayRecStatus:
self.bindPlayRecStatus = True
else:
self.bindPlayRecStatus = False
# If binding is active, the REC button is disabled.
self.record_button.setDisabled(self.bindPlayRecStatus)
def play_clicked(self):
"""
Start or resume playback.
If binding is active, start/pause the audio recording as well
"""
if (self.media_player.state()
in (QMediaPlayer.PausedState, QMediaPlayer.StoppedState)):
self.media_player.play()
logger.info("(Re)Starting playback")
if self.bindPlayRecStatus:
if (self.recorder.state() in (QAudioRecorder.PausedState,
QAudioRecorder.StoppedState)):
logger.info(
"Rec/Play bind is on! (Re)Starting Recorder as well.")
self.recorder.record()
else:
self.media_player.pause()
logger.info("Pausing playback")
if self.bindPlayRecStatus:
logger.info("Rec/Play bind is on! Pausing Recorder as well.")
self.recorder.pause()
def stop_clicked(self):
"""
Stopping playback.
if Play/Rec binding is on, stop also the recorder.
"""
logger.info("Stopping playback")
self.media_player.stop()
if self.bindPlayRecStatus:
logger.info("Rec/Play bind is on! Stopping Recorder as well.")
self.recorder.stop()
def state_changed(self, newstate):
"""
Update buttons. Not really needed, probably.
"""
states = {
QMediaPlayer.PausedState: self.play_normal_icon,
QMediaPlayer.PlayingState: self.pause_icon,
QMediaPlayer.StoppedState: self.play_normal_icon
}
self.play_button.setIcon(states[newstate])
# elegant way to enable/disable the stop button
self.stop_button.setEnabled(newstate != QMediaPlayer.StoppedState)
def eventFilter(self, obj, event):
"""
Catch MouseButtonDblClick or CTRL+SHIFT+F to toggle fullscreen
"""
if (event.type() == QEvent.KeyPress and event.modifiers() & Qt.ShiftModifier \
and event.modifiers() & Qt.ControlModifier and event.key() == 70) \
or event.type() == QEvent.MouseButtonDblClick:
obj.setFullScreen(not obj.isFullScreen())
return False
def toggleFullscreen(self):
self.video_widget.setFullScreen(not self.video_widget.isFullScreen())
def selectInputFile(self):
"""
Just a small function to open a file dialog
"""
#self.input_file_edit.setText(QFileDialog.getOpenFileName())
# encode the resulting filename as UNICODE text
self.input_filename, _ = QFileDialog.getOpenFileName()
self.input_file_edit.setText(self.input_filename)
def setInputMedia(self, filename):
self.media_player.setMedia(QMediaContent(QUrl.fromLocalFile(filename)))
def selectOutputFile(self):
"""
Just a small function to open a file dialog
"""
self.output_filename, _ = QFileDialog.getSaveFileName()
self.output_file_edit.setText(self.output_filename)
def setOutputMedia(self, filename):
self.recorder.setOutputLocation(QUrl.fromLocalFile(filename))
def recButtonState(self):
if self.record_button.isChecked():
self.doRecord()
else:
self.stopRecord()
def doRecord(self):
"""
TODO: define this function better, toggled by the Rec button
:return:
"""
print("Recording")
self.recorder.record()
def stopRecord(self):
print("Stopping recorder")
self.recorder.stop()
def setupConstants(self):
self.rec_icon = QIcon.fromTheme("media-record", QIcon("icons/rec.png"))
self.play_normal_icon = QIcon.fromTheme("media-playback-start",
QIcon("icons/Play-Normal.png"))
self.stop_normal_icon = QIcon.fromTheme("media-playback-stop",
QIcon("icons/Stop-Normal.png"))
self.exit_icon = QIcon.fromTheme("application-exit",
QIcon("icons/application-exit.png"))
self.pause_icon = QIcon.fromTheme(
"media-playback-pause", QIcon("icons/Pause-Disabled-icon.png"))
self.bindPlayRecStatus = False
class MainVideo(QMainWindow):
def __init__(self, videoUrl):
super().__init__()
self.video = videoUrl
self.init_ui()
def init_ui(self):
url = self.video
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.videoWidget = QVideoWidget()
self.videoWidget.setFullScreen(False)
self.videoWidget.keyPressEvent = self.exitFullScreen
# self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile(url))) # For Local files Only
self.mediaPlayer.setMedia(QMediaContent(QUrl(url))) # For URLs
self.mediaPlayer.play()
self.playState = True
self.playButton = QPushButton()
self.playButton.setEnabled(True)
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPause))
self.playButton.clicked.connect(self.play)
self.positionSlider = QSlider(Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.setTracking(False)
print("Tracking: ", self.positionSlider.hasTracking())
# self.positionSlider.sliderPressed.connect(self.pause)
self.positionSlider.sliderReleased.connect(self.sliderReleased)
# self.positionSlider.sliderMoved.connect(self.setPosition)
self.positionSlider.valueChanged.connect(self.setPosition)
self.length = QLabel()
image = QPixmap("./images/fullscreen.png")
image = image.scaled(30, 30)
# fullScreen = QLabel()
# fullScreen.setFixedHeight(image.height())
# fullScreen.setFixedWidth(image.width())
# fullScreen.setPixmap(image)
# # fullScreen.setStyleSheet("border: 1px solid black")
# fullScreen.mousePressEvent = self.fullscreen
fullScreen = QPushButton()
fullScreen.setIcon(QIcon(image))
fullScreen.setIconSize(QSize(30, 30))
fullScreen.setFixedWidth(image.width())
fullScreen.setFixedHeight(image.height())
fullScreen.setStyleSheet("border: none")
fullScreen.clicked.connect(self.fullscreen)
'''
Error Label not used yet.
'''
self.errorLabel = QLabel()
self.errorLabel.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
controlLayout.addWidget(self.length)
controlLayout.addWidget(fullScreen)
layout = QVBoxLayout()
layout.addWidget(self.videoWidget)
layout.addLayout(controlLayout)
layout.addWidget(self.errorLabel)
wid = QWidget(self)
self.setCentralWidget(wid)
wid.setLayout(layout)
self.setWindowTitle("Video Display from URL")
self.resize(400, 400)
self.mediaPlayer.setVideoOutput(self.videoWidget)
# self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
# self.mediaPlayer.durationChanged.connect(self.durationChanged)
# self.mediaPlayer.error.connect(self.handleError)
self.mediaPlayer.mediaStatusChanged.connect(self.mediaStatusChanged)
self.show()
self.center()
def mediaStatusChanged(self, status):
print("Status: ", status)
print("Duration: ", self.mediaPlayer.duration()/1000)
self.positionSlider.setMinimum(0)
self.positionSlider.setMaximum(self.mediaPlayer.duration()/1000)
self.length.setText(str(int((self.mediaPlayer.position() / 1000) / 60)).zfill(2) + ":"
+ str(round((self.mediaPlayer.position() / 1000) % 60)).zfill(2)
+ "/" + str(int((self.mediaPlayer.duration() / 1000) / 60)) + ":"
+ str(round((self.mediaPlayer.duration() / 1000) % 60)).zfill(2))
def setPosition(self, position):
if not self.positionSlider.isSliderDown():
print("Track Position: ", position)
else:
print("Slider Down Position: ", position)
def play(self):
if not self.playState:
self.mediaPlayer.play()
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPause))
self.playState = True
self.resize(401, 400)
self.resize(400, 400)
self.center()
else:
self.mediaPlayer.pause()
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playState = False
def pause(self):
self.mediaPlayer.pause()
def sliderReleased(self):
print("Value: ", type(self.positionSlider.value()))
self.mediaPlayer.setPosition(self.positionSlider.value() * 1000)
# def play(self):
# if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
# self.mediaPlayer.pause()
# else:
# self.mediaPlayer.play()
#
# def mediaStateChanged(self, state):
# if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
# self.playButton.setIcon(
# self.style().standardIcon(QStyle.SP_MediaPause))
# else:
# self.playButton.setIcon(
# self.style().standardIcon(QStyle.SP_MediaPlay))
#
def positionChanged(self, position):
print("Media Player Position: ", str(int(position / 1000)))
self.positionSlider.setValue(position/1000)
duration = str(int((self.mediaPlayer.duration() / 1000) / 60)) + ":" \
+ str(round((self.mediaPlayer.duration() / 1000) % 60)).zfill(2)
self.length.setText(str(int((self.mediaPlayer.position() / 1000) / 60)).zfill(2) + ":"
+ str(round((self.mediaPlayer.position() / 1000) % 60)).zfill(2)
+ "/" + duration)
#
# def durationChanged(self, duration):
# print("Duration Change Called")
# self.positionSlider.setRange(0, duration)
#
# def setPosition(self, position):
# # print("Slider: ", int(self.positionSlider.value() / 1000))
# print("Slider Pos: ", position)
# self.mediaPlayer.setPosition(position)
#
# def handleError(self):
# self.playButton.setEnabled(False)
# self.errorLabel.setText("Error: " + self.mediaPlayer.errorString())
#
# def sliderPressed(self):
# self.mediaPlayer.pause()
#
# def sliderReleased(self):
# self.mediaPlayer.play()
def center(self):
qtRectangle = self.frameGeometry()
centerPoint = QDesktopWidget().availableGeometry().center()
qtRectangle.moveCenter(centerPoint)
self.move(qtRectangle.topLeft())
def closeEvent(self, a0: QCloseEvent):
self.mediaPlayer.stop()
# ====================================================== Try here
def fullscreen(self, event):
if self.videoWidget.isFullScreen():
self.videoWidget.setFullScreen(False)
self.show()
# self.showNormal()
print("Fullscreen: True")
else:
self.hide()
self.videoWidget.setFullScreen(True)
# widget = QWidget()
# widget.setLayout(self.controlLayout)
# widget.move(0, 0)
# self.show()
# self.showFullScreen()
print("Fullscreen: False")
def exitFullScreen(self, event):
# print("Keypressevent", self.videoWidget.isFullScreen())
# self.videoWidget.setFullScreen(False)
# self.show()
if event.key() == Qt.Key_Right:
self.mediaPlayer.setPosition(self.mediaPlayer.position() + 5000)
print(self.mediaPlayer.position())
elif event.key() == Qt.Key_Left:
self.mediaPlayer.setPosition(self.mediaPlayer.position() - 5000)
print(self.mediaPlayer.position())
elif event.key() == Qt.Key_Escape:
self.videoWidget.setFullScreen(False)
self.show()
# if event.key() == Qt.Key_Escape:
# self.videoWidget.setFullScreen(False)
# # event.accept()
# # self.showNormal()
# print("Key Press")
# # self.fullscreen
def keyPressEvent(self, event):
if event.key() == Qt.Key_Right:
duration = str(int((self.mediaPlayer.duration() / 1000) / 60)) + ":" \
+ str(round((self.mediaPlayer.duration() / 1000) % 60)).zfill(2)
min = str(int((self.mediaPlayer.duration() / 1000) / 60))
sec = str(round((self.mediaPlayer.duration() / 1000) % 60)).zfill(2)
# self.mediaPlayer.setPosition(self.mediaPlayer.position() + 5000)
self.mediaPlayer.setPosition((self.positionSlider.value() * 1000) + 5000)
if self.playState:
self.mediaPlayer.pause()
self.mediaPlayer.play()
self.resize(401, 400)
self.resize(400, 400)
self.center()
# self.length.setText(str(int((self.mediaPlayer.position() / 1000) / 60)).zfill(2) + ":"
# + str(round((self.mediaPlayer.position() / 1000) % 60)).zfill(2)
# + "/" + duration)
print(self.mediaPlayer.position())
elif event.key() == Qt.Key_Left:
self.mediaPlayer.setPosition(self.mediaPlayer.position() - 5000)
print(self.mediaPlayer.position())
elif event.key() == Qt.Key_Space:
self.play()
class VideoWindow(QMainWindow):
def __init__(self, parent=None):
super(VideoWindow, self).__init__(parent)
self.setWindowTitle("PyQt Video Player Widget Example")
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.videoWidget = QVideoWidget()
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)
self.errorLabel = QLabel()
self.errorLabel.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
# Create new action
openAction = QAction(QIcon('open.png'), '&Open', self)
openAction.setShortcut('Ctrl+O')
openAction.setStatusTip('Open movie')
openAction.triggered.connect(self.openFile)
# Create exit action
exitAction = QAction(QIcon('exit.png'), '&Exit', self)
exitAction.setShortcut('Ctrl+Q')
exitAction.setStatusTip('Exit application')
exitAction.triggered.connect(self.exitCall)
# Create menu bar and add action
menuBar = self.menuBar()
fileMenu = menuBar.addMenu('&File')
#fileMenu.addAction(newAction)
fileMenu.addAction(openAction)
fileMenu.addAction(exitAction)
# Create a widget for window contents
wid = QWidget(self)
self.setCentralWidget(wid)
# Create layouts to place inside widget
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
layout = QVBoxLayout()
layout.addWidget(self.videoWidget)
layout.addLayout(controlLayout)
layout.addWidget(self.errorLabel)
# Set widget to contain window contents
wid.setLayout(layout)
self.mediaPlayer.setVideoOutput(self.videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
def openFile(self):
fileName, _ = QFileDialog.getOpenFileName(self, "Open Movie",
QDir.homePath())
if fileName != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.playButton.setEnabled(True)
def exitCall(self):
sys.exit(app.exec_())
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.videoWidget.setFullScreen(True)
self.mediaPlayer.play()
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def handleError(self):
self.playButton.setEnabled(False)
self.errorLabel.setText("Error: " + self.mediaPlayer.errorString())
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(1000, 700)
self.centralWidget = QtWidgets.QWidget(MainWindow)
self.videoWidget = QVideoWidget()
self.videoWidget.setFullScreen(False)
self.playlistView = QtWidgets.QListView(self.centralWidget)
self.playlistView.setStyleSheet(
"background-color: #000000;\ncolor: #ffffff;\nfont: 15px;")
self.currentTimeLabel = QtWidgets.QLabel(self.centralWidget)
self.currentTimeLabel.setText("-:--")
self.currentTimeLabel.setStyleSheet("color: #ffffff;\nfont: 18px;")
self.timeSlider = QtWidgets.QSlider(self.centralWidget)
self.timeSlider.setStyleSheet("QSlider::groove:horizontal {\n"
"border: 1px solid #ffffff;"
"height: 10px;"
"border-radius: 4px;"
"}\n"
"QSlider::handle:horizontal {\n"
"width: 10px;}\n"
"QSlider::add-page:qlineargradient {\n"
"background: white;"
"border-top-right-radius: 9px;"
"border-bottom-right-radius: 9px;"
"border-top-left-radius: 0px;"
"border-bottom-left-radius: 0px;"
"}\n"
"QSlider::sub-page:qlineargradient {\n"
"background: black;"
"border-top-right-radius: 0px;"
"border-bottom-right-radius: 0px;"
"border-top-left-radius: 9px;"
"border-bottom-left-radius: 9px;"
"}")
self.timeSlider.setOrientation(QtCore.Qt.Horizontal)
self.totalTimeLabel = QtWidgets.QLabel(self.centralWidget)
self.totalTimeLabel.setText("-:--")
self.totalTimeLabel.setStyleSheet("color: #ffffff;font: 18px;")
self.openButton = QtWidgets.QPushButton(self.centralWidget)
self.openButton.setText("📁")
self.openButton.setStyleSheet("QPushButton{\n"
"background-color: #000000;\n"
"color: #ffffff;\n"
"border: 3px outset #1B1B1B;\n"
"border-radius: 10px;"
"width: 55px;\n"
"}\n"
"QPushButton:hover{\n"
"background-color: #171717"
"}\n"
"QPushButton:pressed{\n"
"background-color: #000000;\n"
"border: 3px inset #1B1B1B;\n"
"}")
self.previousButton = QtWidgets.QPushButton(self.centralWidget)
self.previousButton.setText("⇦")
self.previousButton.setStyleSheet("QPushButton{\n"
"background-color: #000000;\n"
"color: #ffffff;\n"
"border: 3px outset #1B1B1B;\n"
"border-radius: 10px;"
"width: 55px;\n"
"}\n"
"QPushButton:hover{\n"
"background-color: #171717"
"}\n"
"QPushButton:pressed{\n"
"background-color: #000000;\n"
"border: 3px inset #1B1B1B;\n"
"}")
self.playButton = QtWidgets.QPushButton(self.centralWidget)
self.playButton.setText("▶") #♬
self.playButton.setStyleSheet("QPushButton{\n"
"background-color: #000000;\n"
"color: #ffffff;\n"
"border: 3px outset #1B1B1B;\n"
"border-radius: 10px;"
"width: 55px;\n"
"}\n"
"QPushButton:hover{\n"
"background-color: #171717"
"}\n"
"QPushButton:pressed{\n"
"background-color: #000000;\n"
"border: 3px inset #1B1B1B;\n"
"}")
self.pauseButton = QtWidgets.QPushButton(self.centralWidget)
self.pauseButton.setText("❚❚️")
self.pauseButton.setStyleSheet("QPushButton{\n"
"background-color: #000000;\n"
"color: #ffffff;\n"
"border: 3px outset #1B1B1B;\n"
"border-radius: 10px;"
"width: 55px;\n"
"}\n"
"QPushButton:hover{\n"
"background-color: #171717"
"}\n"
"QPushButton:pressed{\n"
"background-color: #000000;\n"
"border: 3px inset #1B1B1B;\n"
"}")
self.stopButton = QtWidgets.QPushButton(self.centralWidget)
self.stopButton.setText("⬛")
self.stopButton.setStyleSheet("QPushButton{\n"
"background-color: #000000;\n"
"color: #ffffff;\n"
"border: 3px outset #1B1B1B;\n"
"border-radius: 10px;"
"width: 55px;\n"
"}\n"
"QPushButton:hover{\n"
"background-color: #171717"
"}\n"
"QPushButton:pressed{\n"
"background-color: #000000;\n"
"border: 3px inset #1B1B1B;\n"
"}")
self.nextButton = QtWidgets.QPushButton(self.centralWidget)
self.nextButton.setText("⇨")
self.nextButton.setStyleSheet("QPushButton{\n"
"background-color: #000000;\n"
"color: #ffffff;\n"
"border: 3px outset #1B1B1B;\n"
"border-radius: 10px;"
"width: 55px;\n"
"}\n"
"QPushButton:hover{\n"
"background-color: #171717"
"}\n"
"QPushButton:pressed{\n"
"background-color: #000000;\n"
"border: 3px inset #1B1B1B;\n"
"}")
self.label = QtWidgets.QPushButton(self.centralWidget)
self.label.setText("🔈")
self.label.setStyleSheet("QPushButton{\n"
"background-color: #000000;\n"
"color: #ffffff;\n"
"border: 3px outset #1B1B1B;\n"
"border-radius: 10px;"
"width: 25px;\n"
"}\n"
"QPushButton:hover{\n"
"background-color: #171717"
"}\n")
self.volumeSlider = QtWidgets.QSlider(self.centralWidget)
self.volumeSlider.setMaximum(100)
self.volumeSlider.setStyleSheet("QSlider::groove:horizontal {\n"
"border: 1px solid #ffffff;"
"height: 10px;"
"border-radius: 4px;"
"}\n"
"QSlider::handle:horizontal {\n"
"width: 10px;}\n"
"QSlider::add-page:qlineargradient {\n"
"background: white;"
"border-top-right-radius: 9px;"
"border-bottom-right-radius: 9px;"
"border-top-left-radius: 0px;"
"border-bottom-left-radius: 0px;"
"}\n"
"QSlider::sub-page:qlineargradient {\n"
"background: black;"
"border-top-right-radius: 0px;"
"border-bottom-right-radius: 0px;"
"border-top-left-radius: 9px;"
"border-bottom-left-radius: 9px;"
"}")
self.volumeSlider.setOrientation(QtCore.Qt.Horizontal)
self.volumeSlider.setProperty("value", 100)
self.invButton = QtWidgets.QPushButton("☚")
self.invButton.setStyleSheet("QPushButton{\n"
"background-color: #000000;\n"
"color: #ffffff;\n"
"border: 3px outset #1B1B1B;\n"
"border-radius: 10px;"
"width: 55px;\n"
"}\n"
"QPushButton:hover{\n"
"background-color: #171717"
"}\n"
"QPushButton:pressed{\n"
"background-color: #000000;\n"
"border: 3px inset #1B1B1B;\n"
"}")
self.anButton = QtWidgets.QPushButton("☛")
self.anButton.setStyleSheet("QPushButton{\n"
"background-color: #000000;\n"
"color: #ffffff;\n"
"border: 3px outset #1B1B1B;\n"
"border-radius: 10px;"
"width: 55px;\n"
"}\n"
"QPushButton:hover{\n"
"background-color: #171717"
"}\n"
"QPushButton:pressed{\n"
"background-color: #000000;\n"
"border: 3px inset #1B1B1B;\n"
"}")
self.horizontalLayout = QtWidgets.QHBoxLayout(self.centralWidget)
self.verticalLayout = QtWidgets.QVBoxLayout()
self.horizontalLayout_up = QtWidgets.QHBoxLayout()
self.horizontalLayout_low = QtWidgets.QHBoxLayout()
displayLayout = QtWidgets.QHBoxLayout()
displayLayout.addWidget(self.videoWidget, 2)
displayLayout.addWidget(self.playlistView)
self.horizontalLayout_up.addWidget(self.currentTimeLabel)
self.horizontalLayout_up.addWidget(self.timeSlider)
self.horizontalLayout_up.addWidget(self.totalTimeLabel)
self.horizontalLayout_low.addWidget(self.openButton)
self.horizontalLayout_low.addStretch(1)
self.horizontalLayout_low.addWidget(self.previousButton)
self.horizontalLayout_low.addWidget(self.playButton)
self.horizontalLayout_low.addWidget(self.pauseButton)
self.horizontalLayout_low.addWidget(self.stopButton)
self.horizontalLayout_low.addWidget(self.nextButton)
self.horizontalLayout_low.addWidget(self.label)
self.horizontalLayout_low.addWidget(self.volumeSlider)
self.horizontalLayout_low.addStretch(1)
self.horizontalLayout_low.addWidget(self.invButton)
self.horizontalLayout_low.addWidget(self.anButton)
self.verticalLayout.addLayout(displayLayout)
self.verticalLayout.addLayout(self.horizontalLayout_up)
self.verticalLayout.addLayout(self.horizontalLayout_low)
self.horizontalLayout.addLayout(self.verticalLayout)
MainWindow.setCentralWidget(self.centralWidget)
self.retranslateUi(MainWindow)
def retranslateUi(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(_translate("MainWindow", "ABPlayer"))
