def __init__(self): """ Class constructor. """ QMainWindow.__init__(self) dir = os.path.dirname(os.path.realpath(__file__)) self.__createMenus__() newfont = QFont() newfont.setPointSize(9) self.setFont(newfont) sb = QStatusBar() sb.setFixedHeight(24) self.setStatusBar(sb) self.statusBarThread = StatThread(self) self.statusBarThread.statusMessage.connect(self.handleStatusMessage) self.statusBarThread.start() # Create progress bar: #self.pb = QProgressBar(self.statusBar()) #self.statusBar().addPermanentWidget(self.pb) self.dset = None # Add the widgets to the panel: self.sidebar = kstSidebar() self.mainPanel = kstMainPanel() self.splitter = QSplitter(Qt.Horizontal) # Configure the sidebar: self.sidebar.hdfViewerTab.openImageDataEvent.connect(self.openImage) self.sidebar.preprocessingTab.preprocessingRequestedEvent.connect(self.applyPreprocessing) self.sidebar.reconstructionTab.recostructionRequestedEvent.connect(self.applyReconstruction) # Configure the splitter: self.splitter.addWidget(self.sidebar) self.splitter.addWidget(self.mainPanel) # Compose layout of the window: self.setCentralWidget(self.splitter) # Set title, icon and default size: self.setWindowTitle(SW_TITLE) self.setWindowIcon(QIcon(dir + "/resources/logo_kest.png")) # Default size: self.resize(1024,768) self.mainPanel.resize(int(round(self.width() * 0.75)), self.height()) self.mainPanel.imagePanel.resize(self.width(), int(round(self.height() * 0.85)))
class ImagePlayer(QWidget):
def __init__(self, img_path, parent=None):
super(ImagePlayer, self).__init__(parent)
if __name__ == '__main__':
self.setWindowTitle("Viewer")
self.setGeometry(0, 0, 640, 480)
self.main = QWidget()
else:
self.setGeometry(0, 0, parent.width(), parent.height())
self.main = parent
self.vue = QGraphicsView()
self.vue.setDragMode(QGraphicsView.ScrollHandDrag)
self.vue.wheelEvent = self.wheel_event
self.statusBar = QStatusBar()
self.statusBar.setFont(QFont("Noto Sans", 7))
self.statusBar.setFixedHeight(14)
self.verticalLayout = QVBoxLayout()
self.verticalLayout.addWidget(self.vue)
self.verticalLayout.addWidget(self.statusBar)
self.setPixmapView(img_path)
self.statusBar.showMessage(img_path)
if __name__ == '__main__':
self.image_btn = QToolButton()
self.image_btn.setText("Image")
self.image_btn.setObjectName("image_btn")
self.image_btn.clicked.connect(self.get_image)
self.verticalLayout.addWidget(self.image_btn)
self.setLayout(self.verticalLayout)
self.show()
else:
self.main.setLayout(self.verticalLayout)
def get_image(self):
img, _p = QFileDialog.getOpenFileName(
self, "Ouvrir un fichier", QDir.homePath(),
"All Files *.* ;; PNG *.png ;; JPG *.jpg ;; BMP *.bmp")
if not img:
with open("img.txt", "w") as file:
file.write("not img")
return
self.setPixmapView(img)
def setPixmapView(self, img_path):
self.current_image = ImageQt(img_path)
w, h = self.size().width(), self.size().height()
self.pixmap = QPixmap.fromImage(
self.current_image.scaled(w, h, Qt.KeepAspectRatio,
Qt.FastTransformation))
self.view_current()
self.statusBar.showMessage(img_path)
def view_current(self):
w_pix, h_pix = self.pixmap.width(), self.pixmap.height()
self.scene = QGraphicsScene()
self.scene.setSceneRect(0, 0, w_pix, h_pix)
self.scene.addPixmap(self.pixmap)
self.vue.setScene(self.scene)
def wheel_event(self, event):
steps = event.angleDelta().y() / 120.0
self.zoom(steps)
event.accept()
def zoom(self, step):
w_pix, h_pix = self.pixmap.width(), self.pixmap.height()
w, h = w_pix * (1 + 0.1 * step), h_pix * (1 + 0.1 * step)
self.pixmap = QPixmap.fromImage(
self.current_image.scaled(w, h, Qt.KeepAspectRatio,
Qt.FastTransformation))
self.view_current()
class MachineLearning(QMainWindow):
populateGallery = pyqtSignal()
closedWindow = pyqtSignal(object)
key_pressed = pyqtSignal(object)
def __init__(self, parent=None):
super(MachineLearning, self).__init__()
self.setWindowTitle('Machine Learning')
self.parent = parent
self.configure_gui()
self.create_menu()
self.create_widgets()
self.showMaximized()
def configure_gui(self):
self.stack = QStackedWidget(self)
self.setCentralWidget(self.stack)
self.stack.setContentsMargins(0, 0, 5, 0)
def create_widgets(self):
self.design = Design(self)
self.dataset = Dataset(self)
self.train = Train(self)
self.stack.addWidget(self.design)
self.stack.addWidget(self.dataset)
self.stack.addWidget(self.train)
self.statusbar = QStatusBar(self)
self.setStatusBar(self.statusbar)
self.statusbar.setFixedHeight(25)
def create_menu(self):
self.menubar = self.menuBar()
self.tooblar = self.addToolBar('')
# File
file = self.menubar.addMenu('File')
self.create_action(file, ['New...', 'Create new project'],
self.menuPressEvent, 'Ctrl+N')
self.create_action(file, ['Open...', 'Load project from file'],
self.menuPressEvent, 'Ctrl+O')
file.addMenu('Open recent')
file.addSeparator()
self.create_action(file, ['Save', 'Save project to file'],
self.menuPressEvent, 'Ctrl+S')
file.addAction('Save As...',
self.menuPressEvent,
shortcut='Ctrl+Shift+S')
file.addAction('Save a Copy...', self.menuPressEvent)
file.addAction('Save Selection...', self.menuPressEvent)
file.addAction('Export...', self.menuPressEvent)
file.addSeparator()
file.addAction('Close', self.menuPressEvent, shortcut='Ctrl+F4')
file.addSeparator()
file.addAction('Properties', self.menuPressEvent)
file.addSeparator()
file.addAction('Quit', self.menuPressEvent, shortcut='Ctrl+Q')
# Edit
edit = self.menubar.addMenu('Edit')
edit.addAction('Undo', self.menuPressEvent, shortcut='Ctrl+Z')
edit.addAction('Redo', self.menuPressEvent, shortcut='Ctrl+Y')
edit.addSeparator()
edit.addAction('Cut', self.menuPressEvent, shortcut='Ctrl+X')
edit.addAction('Copy', self.menuPressEvent, shortcut='Ctrl+C')
edit.addAction('Paste', self.menuPressEvent, shortcut='Ctrl+V')
edit.addAction('Delete', self.menuPressEvent, shortcut='Del')
edit.addSeparator()
edit.addAction('Select All', self.menuPressEvent, shortcut='Ctrl+A')
edit.addAction('Find', self.menuPressEvent, shortcut='Ctrl+F')
edit.addSeparator()
edit.addAction('Preferences', self.menuPressEvent)
# View
view = self.menubar.addMenu('View')
view.addAction('Palettes', self.menuPressEvent, shortcut='F9')
view.addAction('Inspector', self.menuPressEvent, shortcut='F8')
view.addSeparator()
view.addAction('Zoom in', self.menuPressEvent, shortcut='Ctrl++')
view.addAction('Zoom out', self.menuPressEvent, shortcut='Ctrl+-')
view.addSeparator()
view.addAction('Fulscreen', self.menuPressEvent, shortcut='F11')
# Layer
layer = self.menubar.addMenu('Layer')
# Tools
tools = self.menubar.addMenu('Tools')
# Help
help = self.menubar.addMenu('Help')
def create_action(self, menu, text, slot, shortcut):
if isinstance(text, list):
menu.addAction(text[0], self.menuPressEvent, shortcut=shortcut)
self.tooblar.addAction(
QAction(QIcon.fromTheme('new.bmp'), f'{text[1]} ({shortcut})',
self))
else:
menu.addAction(text, self.menuPressEvent, shortcut=shortcut)
def menuPressEvent(self, event=None):
action = event.text()
print(action)
def keyPressEvent(self, event):
key_press = event.key()
if key_press == Qt.Key_Escape: self.close()
else: self.key_pressed.emit(event)
def closeEvent(self, event):
self.closedWindow.emit(self)
class VideoPlayer(QWidget):
def __init__(self, img_path, parent=None):
super(VideoPlayer, self).__init__(parent)
if __name__ == '__main__':
self.setWindowTitle("Player")
self.setGeometry(0, 0, 640, 480)
else:
self.setGeometry(0, 0, parent.width(), parent.height())
self.main = parent
self.fileName = img_path
btnSize = QSize(16, 16)
self.videoWidget = QLabel()
self.videoWidget.setAlignment(Qt.AlignCenter)
if __name__ == '__main__':
openButton = QPushButton()
openButton.setToolTip("Open Video File")
openButton.setStatusTip("Open Video File")
openButton.setFixedHeight(24)
openButton.setIconSize(btnSize)
openButton.setText("Vidéo")
openButton.setFont(QFont("Noto Sans", 8))
openButton.setIcon(QIcon.fromTheme("document-open"))
openButton.clicked.connect(self.openFile)
self.playButton = QPushButton()
self.playButton.setEnabled(True)
self.playButton.setFixedHeight(24)
self.playButton.setIconSize(btnSize)
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.statusBar = QStatusBar()
self.statusBar.setFont(QFont("Noto Sans", 7))
self.statusBar.setFixedHeight(14)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
if __name__ == '__main__':
controlLayout.addWidget(openButton)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
layout = QVBoxLayout()
layout.addWidget(self.videoWidget)
layout.addLayout(controlLayout)
layout.addWidget(self.statusBar)
self.loadFile(self.fileName)
self.statusBar.showMessage(self.fileName)
if __name__ == '__main__':
self.setLayout(layout)
self.show()
else:
self.main.setLayout(layout)
def openFile(self):
self.fileName, _ = QFileDialog.getOpenFileName(
self, "Open Movie", QDir.homePath(),
"All Files *.* ;; MP4 *.mp4 ;; FLV *.flv ;; TS *.ts ;; MTS *.mts ;; AVI *.avi"
)
if self.fileName != '':
self.loadFile(self.fileName)
def loadFile(self, fileName):
self.state = "WaitingState"
self.mediaStateChanged()
self.cap = cv2.VideoCapture(str(fileName))
self.frame_num = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))
self.durationChanged()
self.frame_count = 0
self.statusBar.showMessage(fileName)
def play(self):
if self.state == "PlayingState":
self.pause()
elif self.state == "WaitingState":
self.start()
else:
self.state = "PlayingState"
self.mediaStateChanged()
self.cap = cv2.VideoCapture(str(self.fileName))
self.frame_count = 0
def pause(self):
self.state = "WaitingState"
self.mediaStateChanged()
self.timer.stop()
def start(self):
self.state = "PlayingState"
self.mediaStateChanged()
self.timer = QTimer()
self.timer.timeout.connect(self.nextFrameSlot)
self.timer.start(1000. / self.cap.get(cv2.CAP_PROP_FPS))
def nextFrameSlot(self):
self.frame_count += 1
self.positionChanged()
ret, frame = self.cap.read()
if ret:
img = QImage(frame.data, frame.shape[1], frame.shape[0],
QImage.Format_RGB888)
img = img.rgbSwapped()
if __name__ == '__main__':
w, h = self.videoWidget.size().width(), self.videoWidget.size(
).height()
else:
# TODO : Gérer le problème d'agrandissement de la fenêtre
w, h = self.size().width(), self.size().height()
pix = QPixmap.fromImage(
img.scaled(w, h, Qt.KeepAspectRatio, Qt.FastTransformation))
self.videoWidget.setPixmap(pix)
else:
self.state = "FinishingState"
self.mediaStateChanged()
def mediaStateChanged(self):
if self.state == "PlayingState":
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
elif self.state == "WaitingState":
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
else:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaStop))
def positionChanged(self):
self.positionSlider.setValue(self.frame_count)
def durationChanged(self):
self.positionSlider.setRange(0, self.frame_num)
class VideoPlayer(QWidget):
send_img = pyqtSignal(QPixmap)
def __init__(self):
super(VideoPlayer, self).__init__()
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
btnSize = QSize(16, 16)
self.videoWidget = QVideoWidget()
openBtn = QPushButton("Open")
openBtn.setFixedHeight(24)
openBtn.clicked.connect(self.loadVideo)
self.captureBtn = QPushButton("Capture")
self.captureBtn.setEnabled(False)
self.captureBtn.setFixedHeight(24)
self.playBtn = QPushButton()
self.playBtn.setEnabled(False)
self.playBtn.setFixedHeight(24)
self.playBtn.setIconSize(btnSize)
self.playBtn.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playBtn.clicked.connect(self.play)
self.positionSlider = QSlider(Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.setPosition)
self.statusBar = QStatusBar()
self.statusBar.setFont(QFont("Noto Sans", 7))
self.statusBar.setFixedHeight(14)
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("Ready")
self.captureBtn.clicked.connect(self.capture)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(openBtn)
controlLayout.addWidget(self.playBtn)
controlLayout.addWidget(self.positionSlider)
controlLayout.addWidget(self.captureBtn)
layout = QVBoxLayout()
layout.addWidget(self.videoWidget)
layout.addLayout(controlLayout)
layout.addWidget(self.statusBar)
self.setLayout(layout)
self.screen = QApplication.primaryScreen()
self.secondW = CaptureWindow()
self.send_img.connect(self.secondW.gotImg)
def capture(self):
shot = self.screen.grabWindow(self.videoWidget.winId())
print("Capture Btn Clicked")
self.send_img.emit(shot)
def loadVideo(self):
fileName, _ = QFileDialog.getOpenFileName(
self, "Selecciona los mediose", ".",
"Video Files (*.mp4 *.flv *.ts *.mts *.avi)")
if fileName != '':
try:
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.playBtn.setEnabled(True)
self.statusBar.showMessage(fileName)
self.play()
except Exception as e:
print(e)
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
self.captureBtn.setEnabled(True)
else:
self.mediaPlayer.play()
self.captureBtn.setEnabled(False)
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playBtn.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.playBtn.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.playBtn.setEnabled(False)
print(self.mediaPlayer.errorString())
self.statusBar.showMessage("Error: " + self.mediaPlayer.errorString())
class VideoPlayer(QWidget):
def __init__(self, parent=None):
super(VideoPlayer, self).__init__(parent)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
btnSize = QSize(16, 16)
videoWidget = QVideoWidget()
openButton = QPushButton("Open Video")
openButton.setToolTip("Open Video File")
openButton.setStatusTip("Open Video File")
openButton.setFixedHeight(24)
openButton.setIconSize(btnSize)
openButton.setFont(QFont("Noto Sans", 8))
openButton.setIcon(
QIcon.fromTheme("document-open", QIcon("D:/_Qt/img/open.png")))
openButton.clicked.connect(self.abrir)
speedButton = QPushButton("speedVideo")
speedButton.setToolTip("Open Video File")
speedButton.setStatusTip("Open Video File")
speedButton.setFixedHeight(24)
speedButton.setIconSize(btnSize)
speedButton.setFont(QFont("Noto Sans", 8))
speedButton.setIcon(
QIcon.fromTheme("document-open", QIcon("D:/_Qt/img/open.png")))
speedButton.clicked.connect(self.speed)
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setFixedHeight(24)
self.playButton.setIconSize(btnSize)
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.positionSlider = slider.Slider(QtCore.Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.setPosition)
self.positionSlider.sliderPressed.connect(self.setPosition)
self.positionSlider.sliderReleased.connect(self.setPosition)
self.statusBar = QStatusBar()
self.statusBar.setFont(QFont("Noto Sans", 7))
self.statusBar.setFixedHeight(14)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(openButton)
controlLayout.addWidget(speedButton)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
layout = QVBoxLayout()
layout.addWidget(videoWidget)
layout.addLayout(controlLayout)
layout.addWidget(self.statusBar)
self.setLayout(layout)
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)
self.statusBar.showMessage("Ready")
def abrir(self):
num = 0
cmd = "ffmpeg -y -i " + "PART/" + str(
num
) + ".mkv " + "-filter_complex \"[0:v]setpts=2.0*PTS[v];[0:a]atempo=0.5[a]\" -map \"[v]\" -map \"[a]\" " + str(
num) + ".mkv"
#cmd = "ffmpeg -y -i "+ "PART/" + str(num) + ".mkv" + " -filter:v \"setpts=2.0*PTS\" "+ str(num) + ".mkv"
os.system(cmd)
player.setWindowTitle("CLONES")
fileName = "/home/flo/tmp/Movie-SongMaker/0.mkv"
if fileName != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.playButton.setEnabled(True)
self.statusBar.showMessage(fileName)
self.play()
def speed(self):
num = 0
cmd = "ffmpeg -y -i " + "PART/" + str(
num
) + ".mkv " + "-filter_complex \"[0:v]setpts=1.0*PTS[v];[0:a]atempo=1.0[a]\" -map \"[v]\" -map \"[a]\" " + str(
num) + ".mkv"
#cmd = "ffmpeg -y -i "+ "PART/" + str(num) + ".mkv" + " -filter:v \"setpts=2.0*PTS\" "+ str(num) + ".mkv"
os.system(cmd)
player.setWindowTitle("CLONES")
fileName = "/home/flo/tmp/Movie-SongMaker/0.mkv"
if fileName != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.playButton.setEnabled(True)
self.statusBar.showMessage(fileName)
self.play()
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):
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.statusBar.showMessage("Error: " + self.mediaPlayer.errorString())
class VideoPlayer(QWidget):
def __init__(self, name, file_path, parent=None):
super(VideoPlayer, self).__init__(parent)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
# Contains full path
self.fileName = file_path
self.res = 'answer not yet'
btnSize = QSize(16, 16)
videoWidget = QVideoWidget()
#nameLabel = QLabel("")
#nameLabel.setText("Name of the person")
openButton = QPushButton("Open Video")
openButton.setToolTip("Open Video File")
openButton.setStatusTip("Open Video File")
openButton.setFixedHeight(24)
openButton.setIconSize(btnSize)
openButton.setFont(QFont("Noto Sans", 8))
openButton.setIcon(
QIcon.fromTheme("document-open", QIcon("D:/_Qt/img/open.png")))
# openButton.clicked.connect(self.abrir)
self.result = QPushButton("Result")
self.result.setGeometry(QtCore.QRect(500, 400, 141, 51))
self.result.setObjectName("result")
self.result.setEnabled(False)
self.result.clicked.connect(self.result_window)
"""
result window event
"""
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setFixedHeight(24)
self.playButton.setIconSize(btnSize)
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.statusBar = QStatusBar()
self.statusBar.setFont(QFont("Noto Sans", 7))
self.statusBar.setFixedHeight(50)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
#controlLayout.addWidget(openButton)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
controlLayout.addWidget(self.result)
layout = QVBoxLayout()
layout.addWidget(videoWidget)
layout.addLayout(controlLayout)
layout.addWidget(self.statusBar)
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(self.fileName)))
self.playButton.setEnabled(True)
#self.statusBar.showMessage(fileName)
self.play()
self.setLayout(layout)
f = "Hello, " + name
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)
self.statusBar.showMessage(f)
def enable_result(self, res):
self.res = res
self.result.setEnabled(True)
print('VideoPlayer, result is enabled')
pass
def abrir(self):
# fileName, _ = QFileDialog.getOpenFileName(self, "Selecciona los mediose",
# ".", "Video Files (*.mp4 *.flv *.ts *.mts *.avi)")
# if fileName != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(self.fileName)))
self.playButton.setEnabled(True)
#self.statusBar.showMessage(fileName)
self.play()
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):
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.statusBar.showMessage("Error: " + self.mediaPlayer.errorString())
def result_window(self):
print("answer: ", self.res)
class VideoPlayer(QWidget):
def __init__(self, parent=None):
super(VideoPlayer, self).__init__(parent)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
iconSize = QSize(12, 12)
videoWidget = QVideoWidget()
openButton = QPushButton("Open Video")
openButton.setToolTip("Open Video File")
openButton.setStatusTip("Open Video File")
openButton.setFixedHeight(24)
openButton.setFont(QFont("Noto Sans", 10))
openButton.clicked.connect(self.abrir)
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setFixedHeight(24)
self.playButton.setIconSize(iconSize)
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.volumeSlider = QSlider(Qt.Horizontal)
self.volumeSlider.setRange(0, 100)
self.volumeSlider.sliderMoved.connect(self.setVolume)
self.volumeLabel = QLabel()
self.volumeLabel.setText(" Volume Bar --> ")
self.volumeLabel.setFont(QFont("Noto Sans", 10, QFont.Bold))
#Information bar
self.statusBar = QStatusBar()
self.statusBar.setFont(QFont("Noto Sans", 7))
self.statusBar.setFixedHeight(14)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(openButton)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
layoutLine2 = QHBoxLayout()
layoutLine2.setContentsMargins(0, 0, 0, 0)
layoutLine2.addWidget(self.volumeLabel)
layoutLine2.addWidget(self.volumeSlider)
layout = QVBoxLayout()
layout.addWidget(videoWidget)
layout.addLayout(controlLayout)
layout.addLayout(layoutLine2)
layout.addWidget(self.statusBar)
self.setLayout(layout)
self.mediaPlayer.setVideoOutput(videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.volumeChanged.connect(self.volumeChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
self.statusBar.showMessage("Ready")
def abrir(self):
fileName, _ = QFileDialog.getOpenFileName(
self, "Selecciona los mediose", ".",
"Video Files (*.mp4 *.flv *.ts *.mts *.avi)")
if fileName != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.playButton.setEnabled(True)
self.statusBar.showMessage(fileName)
self.play()
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
print("Play state:", 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)
v = self.volumeSlider.value()
pause = False
global forwardLock
global backwardLock
global upLock
global downLock
f = open("result.txt", "r+")
data = f.readline()
print("Reading txt...")
print("Data read from txt: ", data)
if data == "[4]":
pause = True
self.mediaPlayer.pause()
self.mediaStateChanged(2)
f.close()
while pause:
f = open("result.txt", "r+")
l = f.readline()
if l == "[3]":
pause = False
self.mediaPlayer.play()
self.mediaStateChanged(1)
f.close()
if data == "[3]" and forwardLock == 0:
f.close()
forwardLock = 1
self.setPosition(position + 20000)
f = open("result.txt", "w")
f.write('no motion')
f.close()
elif data != "[3]" and forwardLock == 1:
forwardLock = 0
f.close()
else:
f.close()
if data == "[2]" and backwardLock == 0:
f.close()
backwardLock = 1
if position > 20000:
self.setPosition(position - 20000)
else:
self.setPosition(0)
f = open("result.txt", "w")
f.write('no motion')
f.close()
elif data != "[2]" and backwardLock == 1:
backwardLock = 0
f.close()
else:
f.close()
if data == "[1]" and upLock == 0:
f.close()
upLock = 1
print(v)
if v + 15 > 100:
self.setVolume(100)
else:
v += 15
self.setVolume(v)
print(v)
print("Volume set")
f = open("result.txt", "w")
f.write('no motion')
f.close()
elif data != "[1]" and upLock == 1:
upLock = 0
f.close()
else:
f.close()
if data == "[0]" and downLock == 0:
f.close()
downLock = 1
print(v)
if v - 15 < 0:
self.setVolume(0)
else:
v -= 15
self.setVolume(v)
print(v)
print("Volume set")
f = open("result.txt", "w")
f.write('no motion')
f.close()
elif data != "[0]" and downLock == 1:
downLock = 0
f.close()
else:
f.close()
self.setVolume(v)
print("Position changed:", position)
def volumeChanged(self, value):
self.volumeSlider.setValue(value)
def setVolume(self, value):
self.mediaPlayer.setVolume(value)
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
print("Duration changed:", duration)
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
print("Position set:", position)
def handleError(self):
self.playButton.setEnabled(False)
self.statusBar.showMessage("Error: " + self.mediaPlayer.errorString())
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 VideoPlayer(QWidget):
def __init__(self):
super().__init__()
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
btnSize = QSize(16, 16)
videoWidget = QVideoWidget()
openButton = QPushButton("Open Video")
openButton.setToolTip("Open Video File")
openButton.setStatusTip("Open Video File")
openButton.setFixedHeight(24)
openButton.setIconSize(btnSize)
openButton.setFont(QFont("Noto Sans", 8))
openButton.setIcon(
QIcon.fromTheme("document-open", QIcon("D:/_Qt/img/open.png")))
openButton.clicked.connect(self.abrir)
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setFixedHeight(24)
self.playButton.setIconSize(btnSize)
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.statusBar = QStatusBar()
self.statusBar.setFont(QFont("Noto Sans", 7))
self.statusBar.setFixedHeight(14)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(openButton)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
layout = QVBoxLayout()
layout.addWidget(videoWidget)
layout.addLayout(controlLayout)
layout.addWidget(self.statusBar)
self.setLayout(layout)
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)
self.statusBar.showMessage("Ready")
self.video_name = None
self.shortcut = QShortcut(QKeySequence(Qt.Key_Up), self)
self.shortcut.activated.connect(self.volumeUp)
self.shortcut = QShortcut(QKeySequence(Qt.Key_Down), self)
self.shortcut.activated.connect(self.volumeDown)
self.video_id = None
def abrir(self):
fileName, _ = QFileDialog.getOpenFileName(
self, "Selecciona los mediose", ".",
"Video Files (*.mp4 *.flv *.ts *.mts *.avi)")
if fileName != '':
r = requests.post(POST_DATA_URL_VIDEO, json=dict(name=fileName))
self.video_id = int(r.text)
self.video_name = os.path.basename(fileName)
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.playButton.setEnabled(True)
self.statusBar.showMessage(fileName)
self.play()
def get_video_id(self):
return self.video_id
def pause_video(self):
self.mediaPlayer.pause()
def resume_video(self):
self.mediaPlayer.play()
def volumeUp(self):
self.mediaPlayer.setVolume(self.mediaPlayer.volume() + 10)
print("Volume: " + str(self.mediaPlayer.volume()))
def volumeDown(self):
self.mediaPlayer.setVolume(self.mediaPlayer.volume() - 10)
print("Volume: " + str(self.mediaPlayer.volume()))
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def is_paused(self):
return not self.mediaPlayer.state() == QMediaPlayer.PlayingState
def get_position(self):
return self.mediaPlayer.position()
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.statusBar.showMessage("Error: " + self.mediaPlayer.errorString())
class VideoPlayer(QWidget):
"""
Source: https://stackoverflow.com/a/57842233
"""
def __init__(self, parent=None):
super(VideoPlayer, self).__init__(parent)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
btnSize = QSize(16, 16)
videoWidget = QVideoWidget()
self.overlay = PaintOverlay(videoWidget)
self.overlay.setVisible(True)
#self.overlay.hide()
# self.button.clicked.connect(
# lambda: self.overlay.setVisible(False) if self.overlay.isVisible() else self.overlay.setVisible(True))
openButton = QPushButton("Open Video")
openButton.setToolTip("Open Video File")
openButton.setStatusTip("Open Video File")
openButton.setFixedHeight(24)
openButton.setIconSize(btnSize)
openButton.setFont(QFont("Noto Sans", 8))
openButton.setIcon(
QIcon.fromTheme("document-open", QIcon("D:/_Qt/img/open.png")))
openButton.clicked.connect(self.abrir)
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setFixedHeight(24)
self.playButton.setIconSize(btnSize)
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.statusBar = QStatusBar()
self.statusBar.setFont(QFont("Noto Sans", 7))
self.statusBar.setFixedHeight(14)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(openButton)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
layout = QVBoxLayout()
layout.addWidget(videoWidget)
layout.addLayout(controlLayout)
layout.addWidget(self.statusBar)
self.setLayout(layout)
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)
self.statusBar.showMessage("Ready")
def abrir(self):
fileName, _ = QFileDialog.getOpenFileName(
self, 'Choose video file...', '.',
'Video Files (*.mp4 *.flv *.ts *.mts *.avi *.mkv)')
if fileName != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.playButton.setEnabled(True)
self.statusBar.showMessage(fileName)
self.play()
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):
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.statusBar.showMessage("Error: " + self.mediaPlayer.errorString())
def resizeEvent(self, event):
self.overlay.resize(event.size())
event.accept()
class Main(QMainWindow, Ui_MainWindow):
lyricList = []
lyricCount = 0
videoPath = ""
videoName = ""
darkMode = False
redMode = False
blueMode = False
latestStartTime = QtCore.QTime(0, 0, 0)
latestEndTime = QtCore.QTime(0, 0, 0)
def __init__(self):
super(Main, self).__init__()
self.setupUi(self)
self.removeButton.clicked.connect(self.OnRemove)
self.addButton.clicked.connect(lambda: self.OnAddButton())
self.createSRTButton.clicked.connect(self.CreateSRT)
self.actionOpen_Video.triggered.connect(self.OpenVideoFile)
#Modes
self.actionDark_Mode_2.triggered.connect(
lambda: self.ToggleDarkMode(self.darkMode))
self.actionLight_Mode.triggered.connect(self.ToggleLightMode)
self.actionRed_Palette.triggered.connect(
lambda: self.ToggleRedMode(self.redMode))
self.actionBlue_Palette.triggered.connect(
lambda: self.ToggleBlueMode(self.blueMode))
#Video
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
btnSize = QSize(16, 16)
videoWidget = QVideoWidget()
openButton = QPushButton("Abrir Video")
openButton.setToolTip("Abrir Video")
openButton.setStatusTip("Abrir Video")
openButton.setFixedHeight(40)
openButton.setIconSize(btnSize)
openButton.setFont(QFont("Noto Sans", 15))
openButton.setIcon(
QIcon.fromTheme("document-open", QIcon("D:/_Qt/img/open.png")))
openButton.clicked.connect(self.open)
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setFixedHeight(65)
self.playButton.setFixedWidth(60)
self.playButton.setIconSize(btnSize)
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.statusBar = QStatusBar()
self.statusBar.setFont(QFont("Noto Sans", 7))
self.statusBar.setFixedHeight(14)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(openButton)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
#self.QVideoBoxVLayout = QVBoxLayout()
self.QVideoBoxVLayout.addWidget(videoWidget)
self.QVideoBoxVLayout.addLayout(controlLayout)
self.QVideoBoxVLayout.addWidget(self.statusBar)
self.setLayout(self.QVideoBoxVLayout)
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)
# Every 200 ms
self.mediaPlayer.setNotifyInterval(200)
self.translator = google_translator()
self.statusBar.showMessage("Listo")
# connect buttons playback
self.fiveBack.clicked.connect(lambda: self.TimeSkip(5, False))
self.tenBack.clicked.connect(lambda: self.TimeSkip(10, False))
self.oneMBack.clicked.connect(lambda: self.TimeSkip(.1, False))
self.fiveForward.clicked.connect(lambda: self.TimeSkip(5, True))
self.tenForward.clicked.connect(lambda: self.TimeSkip(10, True))
self.oneMForward.clicked.connect(lambda: self.TimeSkip(.1, True))
#Import srt
self.actionInportar_Subtitulos_srt.triggered.connect(self.ImportSRT)
def ToggleLightMode(self):
light_palette = QPalette()
appctxt.app.setPalette(light_palette)
def ToggleRedMode(self, dark):
if not dark:
red_palette = QPalette()
red_palette.setColor(QPalette.Window, QColor(100, 53, 53))
red_palette.setColor(QPalette.WindowText, Qt.white)
red_palette.setColor(QPalette.Base, QColor(25, 25, 25))
red_palette.setColor(QPalette.AlternateBase, QColor(53, 53, 53))
red_palette.setColor(QPalette.ToolTipBase, Qt.white)
red_palette.setColor(QPalette.ToolTipText, Qt.white)
red_palette.setColor(QPalette.Text, Qt.white)
red_palette.setColor(QPalette.Button, QColor(53, 53, 53))
red_palette.setColor(QPalette.ButtonText, Qt.white)
red_palette.setColor(QPalette.BrightText, Qt.red)
red_palette.setColor(QPalette.Link, QColor(42, 130, 218))
red_palette.setColor(QPalette.Highlight, QColor(42, 130, 218))
red_palette.setColor(QPalette.HighlightedText, Qt.black)
appctxt.app.setPalette(red_palette)
#appctxt.app.setStyleSheet(
# "QToolTip { color: #ffffff; background-color: #2a82da; border: 1px solid white; }")
self.redMode = True
else:
light_palette = QPalette()
appctxt.app.setPalette(light_palette)
self.redMode = False
def ToggleBlueMode(self, dark):
if not dark:
blue_palette = QPalette()
blue_palette.setColor(QPalette.Window, QColor(53, 53, 100))
blue_palette.setColor(QPalette.WindowText, Qt.white)
blue_palette.setColor(QPalette.Base, QColor(25, 25, 25))
blue_palette.setColor(QPalette.AlternateBase, QColor(53, 53, 53))
blue_palette.setColor(QPalette.ToolTipBase, Qt.white)
blue_palette.setColor(QPalette.ToolTipText, Qt.white)
blue_palette.setColor(QPalette.Text, Qt.white)
blue_palette.setColor(QPalette.Button, QColor(53, 53, 53))
blue_palette.setColor(QPalette.ButtonText, Qt.white)
blue_palette.setColor(QPalette.BrightText, Qt.red)
blue_palette.setColor(QPalette.Link, QColor(42, 130, 218))
blue_palette.setColor(QPalette.Highlight, QColor(42, 130, 218))
blue_palette.setColor(QPalette.HighlightedText, Qt.black)
appctxt.app.setPalette(blue_palette)
#appctxt.app.setStyleSheet(
# "QToolTip { color: #ffffff; background-color: #2a82da; border: 1px solid white; }")
self.blueMode = True
else:
light_palette = QPalette()
appctxt.app.setPalette(light_palette)
self.blueMode = False
def ToggleDarkMode(self, dark):
if not dark:
dark_palette = QPalette()
dark_palette.setColor(QPalette.Window, QColor(53, 53, 53))
dark_palette.setColor(QPalette.WindowText, Qt.white)
dark_palette.setColor(QPalette.Base, QColor(25, 25, 25))
dark_palette.setColor(QPalette.AlternateBase, QColor(53, 53, 53))
dark_palette.setColor(QPalette.ToolTipBase, Qt.white)
dark_palette.setColor(QPalette.ToolTipText, Qt.white)
dark_palette.setColor(QPalette.Text, Qt.white)
dark_palette.setColor(QPalette.Button, QColor(53, 53, 53))
dark_palette.setColor(QPalette.ButtonText, Qt.white)
dark_palette.setColor(QPalette.BrightText, Qt.red)
dark_palette.setColor(QPalette.Link, QColor(42, 130, 218))
dark_palette.setColor(QPalette.Highlight, QColor(42, 130, 218))
dark_palette.setColor(QPalette.HighlightedText, Qt.black)
appctxt.app.setPalette(dark_palette)
#appctxt.app.setStyleSheet(
# "QToolTip { color: #ffffff; background-color: #2a82da; border: 1px solid white; }")
self.darkMode = True
else:
light_palette = QPalette()
appctxt.app.setPalette(light_palette)
self.darkMode = False
# Currently only supports mp4
def ImportSRT(self):
fileName, _ = QFileDialog.getOpenFileName(self,
"Selecciona los mediose",
".", "SRT Files (*.srt)")
videoFilePath = (fileName.split(".")[0]) + ".mp4"
print(videoFilePath)
if fileName != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(videoFilePath)))
self.playButton.setEnabled(True)
self.statusBar.showMessage(videoFilePath)
self.play()
self.videoPath = videoFilePath
self.videoName = self.videoPath.split("/")[-1]
# Delete existing objects
count = self.lyricCount
for i in range(count):
self.OnRemove()
# Create video objects
self.CreateLyricObjectsFromSRT(fileName)
def CreateLyricObjectsFromSRT(self, path):
srtFile = open(path, "r", encoding="utf-8")
# General srt format is
# index
# start time --> end time
# lyrics
# empty line
#--- Temp variables
index = 1
foundStart = False
foundEnd = False
foundLyrics = False
lyricsString = ""
subStringTime = "-->"
startString = ""
endString = ""
# iterate through srt file
for line in srtFile:
# after times is lyrics
if foundStart and foundEnd and not foundLyrics:
# until we find empty
if line == "\n":
foundLyrics = True
if lyricsString != "":
lyricsString = lyricsString + line.strip('\n').rstrip()
else:
lyricsString = line
# times
if subStringTime in line:
startString = line.split(" --> ")[0].rstrip()
endString = line.split(" --> ")[-1].rstrip()
if startString != "":
foundStart = True
else:
print("No start time for item", index)
if endString != "":
foundEnd = True
else:
print("No end time for item ", index)
index = index + 1
if foundLyrics and startString != "" and endString != "":
#Create lyrics object here
startQTime = self.ReturnQTimeObject(startString)
endQtime = self.ReturnQTimeObject(endString)
self.OnAdd(start=startQTime, end=endQtime, lyrics=lyricsString)
lyricsString = ""
foundLyrics = False
foundStart = False
foundEnd = False
srtFile.close()
def ReturnQTimeObject(self, timeString):
hours = timeString.split(":")[0]
minutes = timeString.split(":")[1]
secondsAndMsec = timeString.split(":")[2]
seconds = secondsAndMsec.split(",")[0]
mSeconds = secondsAndMsec.split(",")[1]
return QtCore.QTime(int(hours), int(minutes), int(seconds),
int(mSeconds))
def TimeSkip(self, amount, forward):
if forward:
tempPosition = self.mediaPlayer.position()
self.setPosition(tempPosition + int(amount * 1000))
else:
tempPosition = self.mediaPlayer.position()
self.setPosition(tempPosition - int(amount * 1000))
def SetCurrentTimeText(self, millis):
millis = int(millis)
seconds = (millis / 1000) % 60
seconds = int(seconds)
minutes = (millis / (1000 * 60)) % 60
minutes = int(minutes)
sMillis = self.ThreeCharSyntax(str(millis))
sSeconds = self.TwoCharSyntax(str(seconds))
sMinutes = self.TwoCharSyntax(str(minutes))
self.currentTime.setText("Tiempo Actual " + sMinutes + ":" + sSeconds +
":" + sMillis)
def open(self):
fileName, _ = QFileDialog.getOpenFileName(
self, "Selecciona los mediose", ".",
"Video Files (*.mp4 *.flv *.ts *.mts *.avi)")
if fileName != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.playButton.setEnabled(True)
self.statusBar.showMessage(fileName)
self.play()
self.videoPath = fileName
self.videoName = self.videoPath.split("/")[-1]
def OpenVideoFile(self):
#self.videoPath, _ = QFileDialog.getOpenFileName(self, 'Open File', options=QFileDialog.DontUseNativeDialog)
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
self.videoPath, _ = QFileDialog.getOpenFileName(
self,
"Select Video File",
"",
"Video File (*.mp4 *.avi *.ogv)",
options=options)
self.videoName = self.videoPath.split("/")[-1]
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))
# Show exact time when paused
self.SetCurrentTimeText(self.mediaPlayer.position())
self.SetCurrentLyrics(self.mediaPlayer.position())
else:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
self.SetCurrentTimeText(self.mediaPlayer.position())
self.SetCurrentLyrics(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.statusBar.showMessage("Error: " + self.mediaPlayer.errorString())
def OnRemove(self):
if len(self.lyricList) > 0:
self.verticalLayout.removeWidget(self.lyricList[-1])
sip.delete(self.lyricList[-1])
self.lyricCount -= 1
del (self.lyricList[-1])
self.progressBar.setProperty("value", 0)
def OnAddButton(self):
if self.lyricCount > 0:
endTimeObject = self.lyricList[self.lyricCount - 1].findChild(
QtWidgets.QTimeEdit, "endTime").time()
newTime = QtCore.QTime(0, endTimeObject.minute(),
endTimeObject.second(),
endTimeObject.msec() + 1)
self.OnAdd(start=newTime, end=newTime)
self.scrollArea.ensureWidgetVisible(self.lyricGroup)
max = self.scrollArea.verticalScrollBar().maximum()
self.scrollArea.verticalScrollBar().setValue(999999)
else:
self.OnAdd()
max = self.scrollArea.verticalScrollBar().maximum()
self.scrollArea.verticalScrollBar().setValue(max)
def OnAdd(self,
start=QtCore.QTime(0, 0, 0),
end=QtCore.QTime(0, 0, 0),
lyrics=""):
self.lyricGroup = QtWidgets.QWidget(self.scrollAreaWidgetContents)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum,
QtWidgets.QSizePolicy.Maximum)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.lyricGroup.sizePolicy().hasHeightForWidth())
self.lyricGroup.setSizePolicy(sizePolicy)
self.lyricGroup.setMinimumSize(QtCore.QSize(0, 150))
self.lyricGroup.setMaximumSize(QtCore.QSize(600, 100))
self.lyricGroup.setLayoutDirection(QtCore.Qt.LeftToRight)
self.lyricGroup.setObjectName("lyricGroup")
self.gridLayout = QtWidgets.QGridLayout(self.lyricGroup)
self.gridLayout.setObjectName("gridLayout")
self.startLabel = QtWidgets.QLabel(self.lyricGroup)
font = QtGui.QFont()
font.setPointSize(10)
self.startLabel.setFont(font)
self.startLabel.setObjectName("startLabel")
self.startLabel.setText("Inicio:")
self.gridLayout.addWidget(self.startLabel, 0, 0, 1, 1)
font = QtGui.QFont()
font.setPointSize(12)
self.lyricsText = QtWidgets.QPlainTextEdit(self.lyricGroup)
self.lyricsText.setObjectName("lyricsText")
self.lyricsText.setFont(font)
self.lyricsText.setPlainText(lyrics)
self.gridLayout.addWidget(self.lyricsText, 0, 2, 2, 1)
self.endLabel = QtWidgets.QLabel(self.lyricGroup)
font = QtGui.QFont()
font.setPointSize(10)
self.endLabel.setFont(font)
self.endLabel.setObjectName("endLabel")
self.endLabel.setText("Final:")
self.gridLayout.addWidget(self.endLabel, 1, 0, 1, 1)
self.endTime = QtWidgets.QTimeEdit(self.lyricGroup)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum,
QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.endTime.sizePolicy().hasHeightForWidth())
self.endTime.setSizePolicy(sizePolicy)
self.endTime.setMinimumSize(QtCore.QSize(100, 30))
self.endTime.setMaximumSize(QtCore.QSize(75, 16777215))
font = QtGui.QFont()
font.setPointSize(11)
self.endTime.setFont(font)
self.endTime.setObjectName("endTime")
self.endTime.setDisplayFormat("mm:ss:zzz")
self.gridLayout.addWidget(self.endTime, 1, 1, 1, 1)
self.endTime.setCurrentSectionIndex(0)
self.endTime.setTime(end)
self.startTime = QtWidgets.QTimeEdit(self.lyricGroup)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum,
QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.startTime.sizePolicy().hasHeightForWidth())
self.startTime.setSizePolicy(sizePolicy)
self.startTime.setMinimumSize(QtCore.QSize(100, 30))
self.startTime.setMaximumSize(QtCore.QSize(75, 16777215))
font = QtGui.QFont()
font.setPointSize(11)
self.startTime.setFont(font)
self.startTime.setCurrentSection(QtWidgets.QDateTimeEdit.MSecSection)
self.startTime.setCurrentSection(2)
self.startTime.setCurrentSectionIndex(2)
self.startTime.setTime(start)
self.startTime.setObjectName("startTime")
self.startTime.setDisplayFormat("mm:ss:zzz")
#self.startTime.timeChanged.connect(lambda:self.IncreaseTime(self.endTime))
self.gridLayout.addWidget(self.startTime, 0, 1, 1, 1)
self.verticalLayout.addWidget(self.lyricGroup, 0, QtCore.Qt.AlignTop)
# add to list
self.lyricList.append(self.lyricGroup)
self.lyricCount += 1
self.progressBar.setProperty("value", 0)
def IncreaseTime(self, endTime):
if endTime.time().currentTime() <= self.startTime.time().currentTime():
startTimeObject = self.startTime.time()
newTime = QtCore.QTime(0, startTimeObject.minute(),
startTimeObject.second(),
startTimeObject.msec())
endTime.setTime(newTime)
def CreateSRT(self):
# For progress bar
self.progressCount = 1
itemSelected = self.textAppendList.currentText()
# Check to see if file has been open
if self.videoPath:
self.newVideoPath = self.videoPath.split(
".")[0] + " - NoTranslation" + ".srt"
srtFile = open(self.newVideoPath, "w", encoding="utf-8")
if self.translateEnglish.isChecked(
) and self.translateSpanish.isChecked():
self.newVideoPath = self.videoPath.split(".")[0] + ".srt"
srtFile = open(self.newVideoPath, "w", encoding="utf-8")
elif self.translateEnglish.isChecked():
self.newVideoPath = self.videoPath.split(
".")[0] + " - English" + ".srt"
srtFile = open(self.newVideoPath, "w", encoding="utf-8")
elif self.translateSpanish.isChecked():
self.newVideoPath = self.videoPath.split(
".")[0] + " - Spanish" + ".srt"
srtFile = open(self.newVideoPath, "w", encoding="utf-8")
for i in range(len(self.lyricList)):
# lyrics
childLyricsText = self.lyricList[i].findChild(
QtWidgets.QPlainTextEdit, "lyricsText")
# start Time
## Format: hh:mm:ss:zzz
childStartTime = self.lyricList[i].findChild(
QtWidgets.QTimeEdit, "startTime").time()
# end Time
childEndTime = self.lyricList[i].findChild(
QtWidgets.QTimeEdit, "endTime").time()
#print("Start time : " + str(childStartTime.minute()) + str(childStartTime.second()) + str(
# childStartTime.msec()))
# Number of iteration
srtFile.write(str(self.progressCount) + "\n")
# start time
minuteTime = self.TwoCharSyntax(str(childStartTime.minute()))
secondTime = self.TwoCharSyntax(str(childStartTime.second()))
mSecTime = self.ThreeCharSyntax(str(childStartTime.msec()))
srtFile.write("00:" + minuteTime + ":" + secondTime + "," +
mSecTime + " --> ")
# end time
minuteTime = self.TwoCharSyntax(str(childEndTime.minute()))
secondTime = self.TwoCharSyntax(str(childEndTime.second()))
mSecTime = self.ThreeCharSyntax(str(childEndTime.msec()))
srtFile.write("00:" + minuteTime + ":" + secondTime + "," +
mSecTime)
# Lyrics
if self.translateEnglish.isChecked(
) and self.translateSpanish.isChecked():
result = self.translator.translate(
childLyricsText.toPlainText(), lang_tgt='en')
srtFile.write("\n" + result.rstrip().replace("\n", " ") +
"\n")
result = self.translator.translate(
childLyricsText.toPlainText(), lang_tgt='es')
srtFile.write(itemSelected +
result.rstrip().replace("\n", " ") +
itemSelected + "\n\n")
elif self.translateEnglish.isChecked():
result = self.translator.translate(
childLyricsText.toPlainText(), lang_tgt='en')
srtFile.write("\n" + result.rstrip().replace("\n", " ") +
"\n\n")
elif self.translateSpanish.isChecked():
result = self.translator.translate(
childLyricsText.toPlainText(), lang_tgt='es')
srtFile.write("\n" + itemSelected +
result.rstrip().replace("\n", " ") +
itemSelected + "\n\n")
else:
srtFile.write(
"\n" +
childLyricsText.toPlainText().replace("\n", " ") +
"\n\n")
progress = self.progressCount / self.lyricCount
print(int(progress * 100))
self.progressBar.setProperty("value", int(progress * 100))
self.progressCount += 1
if progress == 1:
print(self.newVideoPath)
openPath = self.newVideoPath.replace('/', '\\')
subprocess.Popen(r'explorer /select,"' + openPath + '"')
else:
self.ShowPopUpMessage()
# check if string is only 1 character
def TwoCharSyntax(self, str):
if len(str) != 2:
return "0" + str
else:
return str
#Make into 3 char
def ThreeCharSyntax(self, str):
if len(str) == 1:
return "00" + str
elif len(str) == 2:
return "0" + str
elif len(str) >= 4:
return str[-3:]
else:
return str
def SetCurrentLyrics(self, currentTime):
showingLyrics = False
for i in range(len(self.lyricList)):
# start Time
## Format: hh:mm:ss:zzz
childStartTime = self.lyricList[i].findChild(
QtWidgets.QTimeEdit, "startTime").time()
# convert to msecs
minuteTime = childStartTime.minute()
secondTime = childStartTime.second()
mSecTime = childStartTime.msec()
startTotal = (minuteTime * 60000) + (secondTime * 1000) + mSecTime
# end Time
childEndTime = self.lyricList[i].findChild(QtWidgets.QTimeEdit,
"endTime").time()
# convert to msecs
minuteTime = childEndTime.minute()
secondTime = childEndTime.second()
mSecTime = childEndTime.msec()
endTotal = (minuteTime * 60000) + (secondTime * 1000) + mSecTime
if currentTime >= startTotal and currentTime <= endTotal:
childLyricsText = self.lyricList[i].findChild(
QtWidgets.QPlainTextEdit, "lyricsText")
self.currentLyrics.setText(childLyricsText.toPlainText())
showingLyrics = True
if showingLyrics == False:
self.currentLyrics.setText("")
def ShowPopUpMessage(self):
errorMsg = QMessageBox()
errorMsg.setWindowTitle("Error")
errorMsg.setText("Por favor selecciona un video primero")
x = errorMsg.exec_()
class VideoSplitter(QMainWindow):
def __init__(self, parent=None):
super(VideoSplitter, self).__init__()
self.setWindowTitle('Video Splitter')
self.parent = parent
self.configure_gui()
self.create_widgets()
self.create_menu()
self.showMaximized()
def configure_gui(self):
self.center = QWidget(self)
self.vlayout = QVBoxLayout()
self.hlayout = QHBoxLayout()
self.center.setLayout(self.vlayout)
self.setCentralWidget(self.center)
self.vlayout.setContentsMargins(9, 9, 9, 0)
self.vlayout.addLayout(self.hlayout, 3)
def create_widgets(self):
self.files = FileExplorer(self)
self.video = Video(self)
self.clips = Clips(self)
self.timeline = Timeline(self)
self.hlayout.addWidget(self.files, 1)
self.hlayout.addWidget(self.video, 2)
self.hlayout.addWidget(self.clips, 1)
self.vlayout.addWidget(self.timeline, 1)
self.statusbar = QStatusBar(self)
self.setStatusBar(self.statusbar)
self.statusbar.setFixedHeight(25)
def create_menu(self):
self.menubar = self.menuBar()
self.menubar.triggered.connect(self.menuPressEvent)
# File
file = self.menubar.addMenu('File')
# View
help = self.menubar.addMenu('View')
# Help
help = self.menubar.addMenu('Help')
def menuPressEvent(self, event=None):
action = event.text()
def keyPressEvent(self, event):
key_press = event.key()
if key_press == Qt.Key_Escape: self.close()
elif self.parent is not None:
self.parent.keyPressEvent(event)
class AppView(QMainWindow):
def __init__(self):
super().__init__()
# 700 is base height + (menubar.width + statusbar.width)
self.cameraChoice = 0
self.cWidget = QWidget()
self.layout = QGridLayout(self.cWidget)
self.productManagerFrame = ProductManagerFrame(self)
self.settingButtonsFrame = SettingsButtonsFrame(self)
self.cameraDisplayFrame = CameraDisplayFrame(self)
self.layout.addWidget(self.cameraDisplayFrame, 0, 0, 12, 2)
self.layout.addWidget(self.productManagerFrame, 0, 2, 13, 1)
self.layout.addWidget(self.settingButtonsFrame, 12, 0, 1, 2)
self.setCentralWidget(self.cWidget)
self.menubar = QMenuBar(self)
self.menubar.setGeometry(QRect(0, 0, 1100, 30))
self.settingsMenu = QMenu("Settings", self.menubar)
self.applicationMenu = QMenu("Application", self.menubar)
self.aboutMenu = QMenu("About", self.menubar)
self.setMenuBar(self.menubar)
self.statusbar = QStatusBar(self)
self.setStatusBar(self.statusbar)
self.statusbar.setFixedHeight(20)
self.statusbar.setStyleSheet("font-size: 10px;")
self.statusUser = QLabel()
self.statusUser.setGeometry(QRect(0, 0, 20, 20))
self.statusbar.addWidget(self.statusUser)
# Actions choices
self.selectFolderAction = QAction(parent=self, text="Select Folder")
self.showProductsAction = QAction(parent=self,
text="Show products (S)")
self.photoAction = QAction(parent=self, text="Photo (P)")
self.selectCameraAction = QAction(parent=self, text="Change camera")
self.changeUserAction = QAction(parent=self, text="Change user")
self.createUserAction = QAction(parent=self, text="Create new user")
self.authorAction = QAction(parent=self, text="Author")
self.scannerModeAction = QAction(parent=self, text="Scanner mode")
self.scannerModeAction.setCheckable(True)
self.settingsMenu.addAction(self.selectFolderAction)
self.settingsMenu.addAction(self.selectCameraAction)
self.settingsMenu.addAction(self.scannerModeAction)
self.applicationMenu.addAction(self.showProductsAction)
self.applicationMenu.addAction(self.photoAction)
self.applicationMenu.addAction(self.changeUserAction)
self.applicationMenu.addAction(self.createUserAction)
self.aboutMenu.addAction(self.authorAction)
self.menubar.addAction(self.applicationMenu.menuAction())
self.menubar.addAction(self.settingsMenu.menuAction())
self.menubar.addAction(self.aboutMenu.menuAction())
self.setWindowTitle("STManager 2021 - version 1.0.0")
self.setup()
def getPhotoDestinationPath(self):
return self.saveDestination
def updateStatusbar(self):
self.statusUser.setText(
f"Logged as user {self.controller.getUsername()}")
def setup(self):
self.controller = AppController(self)
self.productManagerFrame.setup()
self.settingButtonsFrame.setup()
self.cameraDisplayFrame.setup(self.controller.getScannerMode())
self.updateStatusbar()
# connecting ui buttons signals
self.productManagerFrame.confirmButton.clicked.connect(
self.controller.saveCurrentProduct)
self.productManagerFrame.cancelButton.clicked.connect(
self.controller.deleteCurrentProduct)
self.settingButtonsFrame.photoButton.clicked.connect(
self.controller.takePhoto)
self.settingButtonsFrame.showProductsButton.clicked.connect(
self.searchProducts)
self.settingButtonsFrame.changeUserButton.clicked.connect(
self.controller.switchUser)
self.settingButtonsFrame.nextProductButton.clicked.connect(
self.controller.nextProduct)
self.settingButtonsFrame.prevProductButton.clicked.connect(
self.controller.previousProduct)
self.productManagerFrame.productBarcode.returnPressed.connect(
self.controller.takePhoto)
# connecting actions buttons singals
self.selectFolderAction.triggered.connect(
self.controller.changeSaveUrl)
self.showProductsAction.triggered.connect(self.searchProducts)
self.photoAction.triggered.connect(self.controller.takePhoto)
self.selectCameraAction.triggered.connect(self.showCameraChoice)
self.changeUserAction.triggered.connect(self.controller.switchUser)
self.createUserAction.triggered.connect(createAccount)
self.authorAction.triggered.connect(showInfo)
self.scannerModeAction.triggered.connect(
self.controller.toggleScannerMode)
if self.controller.getScannerMode():
self.scannerModeAction.setChecked(True)
def keyPressEvent(self, k):
key = k.key()
if key == Qt.Key_P:
self.controller.takePhoto()
elif key == Qt.Key_Enter and self.controller.getScannerMode():
self.controller.saveCurrentProduct()
elif key == Qt.Key_Delete:
self.controller.deleteCurrentProduct()
def setCameraIndex(self, i: int):
self.cameraChoice = i
def cleanUp(self):
"""
Slot connected to signal aboutToQuit from QApplication
"""
self.controller.cleanUp()
self.cameraDisplayFrame.turnOffCamera()
return 0
def getCameraIndex(self) -> int:
return self.cameraChoice
def getController(self) -> AppController:
return self.controller
def searchProducts(self):
from utils.ProductSearcher import ProductSearcher
p = ProductSearcher()
p.exec()
def showCameraChoice(self):
self.cameraChoice = cameraChoice()
class VideoPlayer(QWidget):
def __init__(self, filename, parent=None):
super(VideoPlayer, self).__init__(parent)
self.fileName = filename
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
btnSize = QSize(16, 16)
videoWidget = QVideoWidget()
self.playButton = QPushButton()
self.playButton.setEnabled(True)
self.playButton.setFixedHeight(24)
self.playButton.setIconSize(btnSize)
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.statusBar = QStatusBar()
self.statusBar.setFont(QFont("Noto Sans", 7))
self.statusBar.setFixedHeight(14)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
layout = QVBoxLayout()
layout.addWidget(videoWidget)
layout.addLayout(controlLayout)
layout.addWidget(self.statusBar)
self.setLayout(layout)
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)
self.statusBar.showMessage("Ready")
self.abrir()
def abrir(self):
if self.fileName != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(self.fileName)))
self.playButton.setEnabled(True)
self.statusBar.showMessage(self.fileName)
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):
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.statusBar.showMessage("Error: " + self.mediaPlayer.errorString())
class ManageData(QMainWindow):
populateGallery = pyqtSignal()
closedWindow = pyqtSignal(object)
def __init__(self, parent=None):
super(ManageData, self).__init__()
self.setWindowTitle('Manage Data')
self.parent = parent
self.configure_gui()
self.create_menu()
self.create_widgets()
self.showMaximized()
def configure_gui(self):
self.center = QWidget(self)
self.layout = QHBoxLayout()
self.center.setLayout(self.layout)
self.setCentralWidget(self.center)
self.layout.setContentsMargins(5, 0, 0, 0)
self.layout.setSpacing(0)
def create_widgets(self):
self.windows = set()
self.mysql = CONNECT()
self.gallery = Gallery(self)
self.preview = Preview(self, 'white')
self.layout.addWidget(self.gallery)
self.layout.addWidget(self.preview)
self.statusbar = QStatusBar(self)
self.setStatusBar(self.statusbar)
self.statusbar.setFixedHeight(30)
self.mysql.finishedTransaction.connect(self.select_records)
self.mysql.finishedSelect.connect(lambda x: self.preview.update(None))
self.mysql.finishedSelect.connect(self.gallery.clearSelection)
self.mysql.finishedSelect.connect(self.gallery.update)
self.mysql.finishedSelect.connect(self.update_statusbar)
self.mysql.finishedUpdate.connect(lambda x: self.windows.discard(x))
self.mysql.finishedDelete.connect(self.delete_records)
self.gallery.selection.connect(self.update_preview)
self.gallery.selection.connect(self.update_statusbar)
self.gallery.delete.connect(self.delete_records)
self.gallery.load_comic.connect(self.read_comic)
self.gallery.find_artist.connect(self.find_by_artist)
self.ribbon.selection_mode.connect(self.setSelectionMode)
def create_menu(self):
self.menubar = self.menuBar()
self.toolbar = self.addToolBar('Ribbon')
self.ribbon = Ribbon(self)
self.toolbar.addWidget(self.ribbon)
self.menubar.triggered.connect(self.menuPressEvent)
self.toolbar.actionTriggered.connect(self.menuPressEvent)
# File
file = self.menubar.addMenu('File')
file.addAction('Update Autocomplete')
file.addAction('Remove Redundancies')
file.addAction('Copy Images to')
file.addAction('Exit')
# View
help = self.menubar.addMenu('View')
# Help
help = self.menubar.addMenu('Help')
@pyqtSlot()
def select_records(self):
self.mysql.execute(self.ribbon.update_query())
def update_records(self, source, indexes, kwargs):
parameters = []
for key, vals in kwargs.items():
key = key.lower()
if isinstance(vals, tuple):
for val in vals[0]:
parameters.append(f'{key}=CONCAT({key}, " {val} ")')
for val in vals[1]:
parameters.append(f'{key}=REPLACE({key}, " {val} ", " ")')
else:
parameters.append(f'{key}={vals}')
return self.mysql.execute(MODIFY.format(', '.join(parameters)),
indexes,
many=1,
source=source)
def delete_records(self, indexes):
if isinstance(indexes[0], tuple):
for path, in indexes:
(ROOT / path).unlink(True)
return self.mysql.commit()
message = QMessageBox.question(
None, 'Delete', 'Are you sure you want to delete this?',
QMessageBox.Yes | QMessageBox.No)
if message == QMessageBox.Yes:
paths = [(index.data(Qt.UserRole)[0], ) for index in indexes
if index.data(300) is not None]
self.mysql.execute(DELETE, paths, many=1)
def start_slideshow(self, index=None):
if not self.gallery.total(): return
indexes = self.gallery.table.images
index = index if index else self.gallery.currentIndex()
index = sum(index.data(100))
slideshow = Slideshow(self, indexes, index)
self.windows.add(slideshow)
def update_preview(self, select, deselect):
if self.gallery.total():
if select := select.indexes(): image = select[0]
elif indexes := self.gallery.selectedIndexes():
image = min(indexes)
else:
image = None
self.preview.update(image)
class StatusbarUI(object):
def __init__(self, main_window: QMainWindow):
"""
状态栏
外观模式
:param main_window:
"""
self.main_window = main_window
self.statusbar = QStatusBar(self.main_window)
self.ui_list = []
self.show_time = ShowTime(self.statusbar, 1) # 时间模块
self.placeholder = Placeholder(self.statusbar, 2) # 占位符
self.net_speed = NetSpeed(self.statusbar, -4) # 网速
self.monitor_port = MonitorPort(self.statusbar, -3) # 监听端口
self.online_host = OnlineHost(self.statusbar, -1) # 上线主机
def options(self) -> None:
font = QFont()
font.setPointSize(10)
self.statusbar.setFont(font)
# self.statusbar.setGeometry(QtCore.QRect(0, 0, 900, 50))
self.statusbar.setFixedHeight(30)
self.main_window.setStatusBar(self.statusbar)
# self.main_window.setStatusBar()
# self.statusbar.setContextMenuPolicy(Qt.DefaultContextMenu)
def setup_ui(self) -> None:
self.statusbar.setObjectName("statusbar")
self.options()
self.load_ui()
self.show_ui()
if not settings.STATUSBAR_SHOW:
self.statusbar.setHidden(False)
# noinspection PyArgumentList
def retranslate_ui(self) -> None:
self.statusbar.setWindowTitle(_translate("StatusbarUI", "状态栏"))
def load_ui(self) -> None:
"""
加载模块
:return:
"""
self.ui_list.append(self.show_time)
self.ui_list.append(self.placeholder)
self.ui_list.append(self.net_speed)
self.ui_list.append(self.monitor_port)
self.ui_list.append(self.online_host)
def show_ui(self) -> None:
"""
显示数据
:return:
"""
for view in self.ui_list:
view.setup_ui()
view.retranslate_ui()
class GestureDraw(QMainWindow):
populateGallery = pyqtSignal()
closedWindow = pyqtSignal(object)
key_pressed = pyqtSignal(object)
def __init__(self, parent):
super(GestureDraw, self).__init__()
self.setWindowTitle('Gesture Draw')
self.parent = parent
self.configure_gui()
self.create_widgets()
self.create_menu()
self.order[0].actions()[-1].trigger()
self.show()
def configure_gui(self):
self.stack = QStackedWidget(self)
self.setCentralWidget(self.stack)
resolution = Qapp.desktop().screenGeometry()
width, height = resolution.width(), resolution.height()
self.setGeometry(0, 0, width // 2, height)
def create_widgets(self):
self.windows = set()
self.mysql = CONNECT(self)
self.threadpool = QThreadPool()
self.gallery = Gallery(self)
self.preview = Preview(self)
self.timer = Timer(self.preview, self)
self.stack.addWidget(self.gallery)
self.stack.addWidget(self.preview)
self.statusbar = QStatusBar(self)
self.setStatusBar(self.statusbar)
self.statusbar.setFixedHeight(30)
self.mysql.finishedTransaction.connect(self.select_records)
self.mysql.finishedSelect.connect(self.gallery.clearSelection)
self.mysql.finishedSelect.connect(self.gallery.update)
self.mysql.finishedSelect.connect(self.update_statusbar)
self.gallery.selection.connect(self.update_statusbar)
self.gallery.find_artist.connect(self.find_by_artist)
self.gallery.setContentsMargins(5, 0, 5, 0)
for action in self.gallery.menu.actions():
if action.text() in ['Delete', 'Properties']:
self.gallery.menu.removeAction(action)
self.preview.label.setStyleSheet(f'background: black')
def create_menu(self):
self.menubar = self.menuBar()
self.toolbar = self.addToolBar('Ribbon')
self.ribbon = Ribbon(self)
self.toolbar.addWidget(self.ribbon)
self.menubar.triggered.connect(self.menuPressEvent)
self.toolbar.actionTriggered.connect(self.menuPressEvent)
self.ribbon.selection_mode.connect(self.setSelectionMode)
self.ribbon.multi.click()
self.ribbon.tags.setFocus()
# File
file = self.menubar.addMenu('File')
file.addAction('Copy Images to')
self.gesture_menu = create_submenu_(self,
'Gesture Draw',
GESTURE.keys(),
check=False)[0]
file.addMenu(self.gesture_menu)
file.addSeparator()
file.addAction('Exit', self.close, shortcut='CTRL+W')
# database
database = self.menubar.addMenu('Database')
database.addAction('Reconnect')
database.addAction('Current statement')
database.addAction('Update Autocomplete')
database.addAction('Remove Redundancies')
# View
view = self.menubar.addMenu('View')
# Help
help = self.menubar.addMenu('Help')
@pyqtSlot()
def select_records(self):
worker = Worker(self.mysql.execute, self.ribbon.update_query(1, 1000))
self.threadpool.start(worker)
def start_session(self, gallery, time):
if gallery and time:
self.menubar.hide()
self.toolbar.hide()
self.statusbar.hide()
if ':' in time:
min, sec = time.split(':')
time = (int(min) * 60) + int(sec)
else:
time = int(time)
self.stack.setCurrentIndex(1)
self.timer.start(gallery, time)
else:
QMessageBox.information(self, '',
'You are either missing images or a time',
QMessageBox.Ok)
def update_statusbar(self):
total = self.gallery.total()
select = len(self.gallery.selectedIndexes())
total = (f'{total} image' if (total == 1) else f'{total} images')
if select:
select = (f'{select} image selected' if
(select == 1) else f'{select} images selected')
else:
select = ''
self.statusbar.showMessage(f' {total} {select}')
def find_by_artist(self, index):
artist = index.data(Qt.UserRole)[1]
if artist:
self.ribbon.setText(' OR '.join(artist.split()))
else:
QMessageBox.information(self, 'Find by artist',
'This image has no artist')
def setSelectionMode(self, event):
if event:
self.gallery.setSelectionMode(QAbstractItemView.MultiSelection)
else:
self.gallery.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.gallery.clearSelection()
def menuPressEvent(self, event=None):
action = event.text()
# Files
if action == 'Copy Images to':
copy_to(self, self.gallery.selectedIndexes())
elif action in GESTURE.keys():
if action == 'Custom Time':
time, ok = QInputDialog.getText(self, "Dialog", "Enter time:")
if ok:
gallery = self.gallery.selectedIndexes()
self.start_session(gallery, time)
else:
gallery = self.gallery.selectedIndexes()
self.start_session(gallery, GESTURE[action])
elif action == 'Exit':
self.close()
# Database
elif action == 'Reconnect':
self.mysql = CONNECT(self)
self.threadpool = QThreadPool()
elif action == 'Current Statement':
QMessageBox.information(self, 'Current Statement',
self.ribbon.query)
elif action == 'Update Autocomplete':
worker = Worker(update_autocomplete)
self.threadpool.start(worker)
self.ribbon.tags.setCompleter(
Completer(open(AUTOCOMPLETE).read().split()))
elif action == 'Remove Redundancies':
worker = Worker(remove_redundancies)
self.threadpool.start(worker)
def keyPressEvent(self, event):
key_press = event.key()
if key_press == Qt.Key_Space: self.timer.pause()
elif key_press in (Qt.Key_Left, Qt.Key_Right): pass
elif key_press == Qt.Key_Escape:
if self.stack.currentIndex():
self.timer.pause()
self.menubar.show()
self.toolbar.show()
self.statusbar.show()
self.statusbar.showMessage('')
self.stack.setCurrentIndex(0)
self.select_records()
else:
self.close()
else:
self.key_pressed.emit(event)
def mousePressEvent(self, event):
if event.button() == Qt.MouseButton.LeftButton: self.timer.pause()
def closeEvent(self, event):
self.threadpool.clear()
for window in self.windows:
window.close()
self.mysql.close()
self.closedWindow.emit(self)
class VideoPlayer(QWidget):
def __init__(self, parent=None):
super(VideoPlayer, self).__init__(parent)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
#self.mediaPlayer.setMinmumSize(QtCore.QSize(445, 225))
btnSize = QSize(16, 16)
videoWidget = QVideoWidget()
videoWidget.setMinimumSize(QtCore.QSize(445, 225))
openButton = QPushButton("Open Video")
openButton.setToolTip("Open Video File")
openButton.setStatusTip("Open Video File")
openButton.setFixedHeight(24)
openButton.setIconSize(btnSize)
openButton.setFont(QFont("Noto Sans", 8))
openButton.setIcon(
QIcon.fromTheme("document-open", QIcon("D:/_Qt/img/open.png")))
openButton.clicked.connect(self.abrir)
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setFixedHeight(24)
self.playButton.setIconSize(btnSize)
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.statusBar = QStatusBar()
self.statusBar.setFont(QFont("Noto Sans", 7))
self.statusBar.setFixedHeight(14)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
#controlLayout.addWidget(openButton)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
layout = QVBoxLayout()
#layout.setMinmumSize(QtCore.QSize(445, 225))
layout.addWidget(videoWidget)
layout.addLayout(controlLayout)
layout.addWidget(self.statusBar)
self.setLayout(layout)
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)
self.statusBar.showMessage("Ready")
def abrir(self):
fileName, _ = QFileDialog.getOpenFileName(
self, "Selecciona los mediose", ".",
"Video Files (*.mp4 *.flv *.ts *.mts *.avi)")
if fileName != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.playButton.setEnabled(True)
self.statusBar.showMessage(fileName)
self.play()
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):
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.statusBar.showMessage("Error: " + self.mediaPlayer.errorString())
class VideoPlayer(QWidget):
def __init__(self, img_path, parent=None):
super(VideoPlayer, self).__init__(parent)
if __name__ == '__main__':
self.setWindowTitle("Player")
self.setGeometry(0, 0, 640, 480)
else:
self.setGeometry(0, 0, parent.width(), parent.height())
self.main = parent
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
btnSize = QSize(16, 16)
videoWidget = QVideoWidget()
if __name__ == '__main__':
openButton = QPushButton()
openButton.setToolTip("Open Video File")
openButton.setStatusTip("Open Video File")
openButton.setFixedHeight(24)
openButton.setIconSize(btnSize)
openButton.setText("Vidéo")
openButton.setFont(QFont("Noto Sans", 8))
openButton.setIcon(QIcon.fromTheme("document-open"))
openButton.clicked.connect(self.openFile)
self.playButton = QPushButton()
self.playButton.setEnabled(True)
self.playButton.setFixedHeight(24)
self.playButton.setIconSize(btnSize)
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.statusBar = QStatusBar()
self.statusBar.setFont(QFont("Noto Sans", 7))
self.statusBar.setFixedHeight(14)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
if __name__ == '__main__':
controlLayout.addWidget(openButton)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
layout = QVBoxLayout()
layout.addWidget(videoWidget)
layout.addLayout(controlLayout)
layout.addWidget(self.statusBar)
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)
self.statusBar.showMessage("Ready")
self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile(img_path)))
self.statusBar.showMessage(img_path)
if __name__ == '__main__':
self.setLayout(layout)
self.show()
else:
self.main.setLayout(layout)
def openFile(self):
fileName, _ = QFileDialog.getOpenFileName(
self, "Open Movie",
QDir.homePath() + "/Videos",
"All Files *.* ;; MP4 *.mp4 ;; FLV *.flv ;; TS *.ts ;; MTS *.mts ;; AVI *.avi"
)
if fileName != '':
self.loadFile(fileName)
def loadFile(self, fileName):
self.mediaPlayer.setMedia(cv2.VideoCapture(fileName))
# self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile(fileName)))
self.playButton.setEnabled(True)
self.statusBar.showMessage(fileName)
self.play()
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):
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.statusBar.showMessage("Error: " + self.mediaPlayer.errorString())
