Beispiel #1
0
class App(QMainWindow):
    def __init__(self, song):
        super().__init__()
        self.song_path = song
        self.player = QMediaPlayer()
        self.playlist = QMediaPlaylist()
        self.title = 'PyTunes'
        self.left = 300
        self.top = 300
        self.width = 300
        self.height = 150
        self.color = 0  # 0- toggle to dark 1- toggle to light
        self.userAction = -1  # 0- stopped, 1- playing 2-paused
        self.initUI()
        self.song = song

    def initUI(self):
        # Add file menu

        self.addControls()

        self.setWindowTitle(self.title)
        self.setGeometry(self.left, self.top, self.width, self.height)
        self.toggleColors()
        self.show()

    def addControls(self):
        wid = QWidget(self)
        self.setCentralWidget(wid)
        # Add song controls
        volumeslider = QSlider(Qt.Horizontal, self)
        volumeslider.setFocusPolicy(Qt.NoFocus)
        volumeslider.valueChanged[int].connect(self.changeVolume)
        volumeslider.setValue(100)
        playBtn = QPushButton('Play')  # play button
        pauseBtn = QPushButton('Pause')  # pause button
        # Add button layouts
        controlArea = QVBoxLayout()  # centralWidget
        controls = QHBoxLayout()
        playlistCtrlLayout = QHBoxLayout()
        # Add buttons to song controls layout
        controls.addWidget(playBtn)
        controls.addWidget(pauseBtn)
        # Add buttons to playlist controls layout
        # Add to vertical layout
        controlArea.addWidget(volumeslider)
        controlArea.addLayout(controls)
        controlArea.addLayout(playlistCtrlLayout)
        wid.setLayout(controlArea)
        # Connect each signal to their appropriate function
        playBtn.clicked.connect(self.playhandler)
        pauseBtn.clicked.connect(self.pausehandler)

        self.statusBar()
        self.playlist.currentMediaChanged.connect(self.songChanged)

    def openFile(self):

        url = QUrl.fromLocalFile(self.song_path)

        self.playlist.addMedia(QMediaContent(url))
        self.player.setPlaylist(self.playlist)
        self.player.play()
        self.userAction = 1

    def addFiles(self):
        if self.playlist.mediaCount() != 0:
            self.folderIterator()
        else:
            self.folderIterator()
            self.player.setPlaylist(self.playlist)
            self.player.playlist().setCurrentIndex(0)
            self.player.play()
            self.userAction = 1

    def folderIterator(self):
        folderChosen = QFileDialog.getExistingDirectory(
            self, 'Open Music Folder', '~')
        if folderChosen != None:
            it = QDirIterator(folderChosen)
            it.next()
            while it.hasNext():
                if it.fileInfo().isDir() == False and it.filePath() != '.':
                    fInfo = it.fileInfo()
                    if fInfo.suffix() in ('mp3', 'ogg', 'wav', 'm4a'):
                        self.playlist.addMedia(
                            QMediaContent(QUrl.fromLocalFile(it.filePath())))
                it.next()
            if it.fileInfo().isDir() == False and it.filePath() != '.':
                fInfo = it.fileInfo()
                if fInfo.suffix() in ('mp3', 'ogg', 'wav', 'm4a'):
                    self.playlist.addMedia(
                        QMediaContent(QUrl.fromLocalFile(it.filePath())))

    def playhandler(self):
        if self.playlist.mediaCount() == 0:
            self.openFile()
        elif self.playlist.mediaCount() != 0:
            self.player.play()
            self.userAction = 1

    def pausehandler(self):
        self.userAction = 2
        self.player.pause()

    def changeVolume(self, value):
        self.player.setVolume(value)

    def songChanged(self, media):
        if not media.isNull():
            url = media.canonicalUrl()
            self.statusBar().showMessage(url.fileName())

    def toggleColors(self):
        """ Fusion dark palette from https://gist.github.com/QuantumCD/6245215. Modified by me and J.J. """
        app.setStyle("Fusion")
        palette = QPalette()
        if self.color == 0:
            palette.setColor(QPalette.Window, QColor(53, 53, 53))
            palette.setColor(QPalette.WindowText, Qt.white)
            palette.setColor(QPalette.Base, QColor(25, 25, 25))
            palette.setColor(QPalette.AlternateBase, QColor(53, 53, 53))
            palette.setColor(QPalette.ToolTipBase, Qt.white)
            palette.setColor(QPalette.ToolTipText, Qt.white)
            palette.setColor(QPalette.Text, Qt.white)
            palette.setColor(QPalette.Button, QColor(53, 53, 53))
            palette.setColor(QPalette.ButtonText, Qt.white)
            palette.setColor(QPalette.BrightText, Qt.red)
            palette.setColor(QPalette.Link, QColor(235, 101, 54))
            palette.setColor(QPalette.Highlight, QColor(235, 101, 54))
            palette.setColor(QPalette.HighlightedText, Qt.black)
            app.setPalette(palette)
            self.color = 1
        elif self.color == 1:
            palette.setColor(QPalette.Window, Qt.white)
            palette.setColor(QPalette.WindowText, Qt.black)
            palette.setColor(QPalette.Base, QColor(240, 240, 240))
            palette.setColor(QPalette.AlternateBase, Qt.white)
            palette.setColor(QPalette.ToolTipBase, Qt.white)
            palette.setColor(QPalette.ToolTipText, Qt.white)
            palette.setColor(QPalette.Text, Qt.black)
            palette.setColor(QPalette.Button, Qt.white)
            palette.setColor(QPalette.ButtonText, Qt.black)
            palette.setColor(QPalette.BrightText, Qt.red)
            palette.setColor(QPalette.Link, QColor(66, 155, 248))
            palette.setColor(QPalette.Highlight, QColor(66, 155, 248))
            palette.setColor(QPalette.HighlightedText, Qt.black)
            app.setPalette(palette)
            self.color = 0
Beispiel #2
0
class App(QMainWindow):

    def __init__(self):
        super().__init__()
        self.player = QMediaPlayer()
        self.playlist = QMediaPlaylist()
        self.title = 'Personal audio player v2.3'
        self.left = 300
        self.top = 300
        self.width = 300
        self.height = 150
        self.color = 0  # 0- toggle to dark 1- toggle to light
        self.userAction = -1  # 0- stopped, 1- playing 2-paused
        self.duration = 0
        #self.getRecommendedPlaylist()
        self.initUI()

    def initUI(self):
        # Add file menu
        menubar = self.menuBar()
        filemenu = menubar.addMenu('File')
        windowmenu = menubar.addMenu('Window')
        connectTo = menubar.addMenu('Connect to...')

        fileAct = QAction('Open File', self)
        folderAct = QAction('Open Folder', self)
        themeAct = QAction('Toggle light/dark theme', self)
        yandexMusic = QAction('Yandex Music', self)
        deezer = QAction('Deezer', self)
        spotify = QAction('Spotify', self)
        pandora = QAction('Pandora', self)
        mixcloud = QAction('Pandora', self)

        fileAct.setShortcut('Ctrl+O')
        folderAct.setShortcut('Ctrl+D')
        themeAct.setShortcut('Ctrl+T')


        filemenu.addAction(fileAct)
        filemenu.addAction(folderAct)
        windowmenu.addAction(themeAct)
        connectTo.addAction(yandexMusic)
        connectTo.addAction(deezer)
        connectTo.addAction(pandora)
        connectTo.addAction(mixcloud)
        connectTo.addAction(spotify)

        fileAct.triggered.connect(self.openFile)
        folderAct.triggered.connect(self.addFiles)
        themeAct.triggered.connect(self.toggleColors)
        yandexMusic.triggered.connect(self.connectYandexMusic)
        deezer.triggered.connect(self.connectYandexMusic)
        pandora.triggered.connect(self.connectYandexMusic)
        mixcloud.triggered.connect(self.connectYandexMusic)
        spotify.triggered.connect(self.connectYandexMusic)

        self.addControls()

        self.setWindowTitle(self.title)
        self.setGeometry(self.left, self.top, self.width, self.height)
        self.toggleColors()
        self.show()

    def downloadTrack(self, name):
        page = requests.get("http://zaycev.net/search.html?query_search=" + name).text
        parser = fromstring(page)
        fileJSON = parser.xpath('//div/@data-url')
        resp = requests.get("http://zaycev.net" + fileJSON[1])
        data = resp.json()
        with open("track.json", 'w') as outfile:
            json.dump(data, outfile)
        connection_file = open("track.json", 'r')
        conn_string = json.load(connection_file)

        track = requests.get(conn_string['url'].rsplit('?')[0])
        try:
            os.makedirs('./tracks')
        except OSError:
            pass

        out = open("./tracks/" + name.strip() + ".mp3", 'wb')
        out.write(track.content)
        out.close()
        QMessageBox.about(self, "Track added!", name.strip() + " was added")

    def playRecommend(self):
        try:
            similarTracks = open("playlist.txt", 'r')
            i = 0
            for line in similarTracks.readlines():
                if i == 5:
                    break
                else:
                    i = i+1
                print(line)
                self.downloadTrack(line)
                self.openFileRec("./tracks/" + line.strip() + ".mp3")

        except:
            QMessageBox.about(self, "Play error!", "Unknown error!")

    def getRecommendedPlaylist(self, song):
        try:
            audio = ID3(song[0])
            title = ''.join(audio['TIT2'].text[0].rsplit('(')[0])
            if title[-1] == ' ':
                title = title[0:-1]
            artist = audio['TPE1'].text[0]
            if artist[-1] == ' ':
                artist = artist[0:-1]
            print(artist + " " + title)
            resp = requests.get("http://ws.audioscrobbler.com/2.0/?method=track.getsimilar&artist=" + artist + "&track=" + title +
                                "&api_key=API_key&format=json")
            data = resp.json()
            with open("playlist" + artist + "-" + title + ".json", 'w') as outfile:
                json.dump(data, outfile)
            connection_file = open("playlist" + artist + "-" + title + ".json", 'r')
            conn_string = json.load(connection_file)

            with open("playlist.txt", 'a') as playlistFile:
                for track in conn_string['similartracks']['track']:
                    playlistFile.write(track['artist']['name'] + " " + track['name'] + "\n")
            playlistFile.close()
        except:
            QMessageBox.about(self, "Error!", "Some trouble with export title or artist name, try other track")

    def getRecommendedPlaylistFolder(self, song):
        audio = ID3(song)
        title = ''.join(audio['TIT2'].text[0].rsplit('(')[0])
        if title[-1] == ' ':
            title = title[0:-1]
        artist = audio['TPE1'].text[0]
        if artist[-1] == ' ':
            artist = artist[0:-1]
        print(artist + " " + title)
        resp = requests.get("http://ws.audioscrobbler.com/2.0/?method=track.getsimilar&artist=" + artist + "&track=" + title +
                            "&api_key=API_key&format=json")
        data = resp.json()
        with open("playlist" + artist + "-" + title + ".json", 'w') as outfile:
            json.dump(data, outfile)
            connection_file = open("playlist" + artist + "-" + title + ".json", 'r')
        conn_string = json.load(connection_file)
        with open("playlist.txt", 'a') as playlistFile:
            for track in conn_string['similartracks']['track']:
                playlistFile.write(track['artist']['name'] + " " + track['name'] + "\n")
        playlistFile.close()

    def addControls(self):
        wid = QWidget(self)
        self.setCentralWidget(wid)
        # Add song controls
        volumeslider = QSlider(Qt.Horizontal, self)
        volumeslider.setFocusPolicy(Qt.NoFocus)
        volumeslider.valueChanged[int].connect(self.changeVolume)
        volumeslider.setValue(50)

        sldPosition = QSlider(Qt.Horizontal, self)
        sldPosition.setMinimum(0)
        sldPosition.setFocusPolicy(Qt.NoFocus)
        #sldPosition.valueChanged.connect(self.player.setPosition)
        self.player.positionChanged.connect(sldPosition.setValue)
        sldPosition.setMaximum(180000)

        playBtn = QPushButton('Play')  # play button
        pauseBtn = QPushButton('Pause')  # pause button
        stopBtn = QPushButton('Stop')  # stop button
        # Add playlist controls
        prevBtn = QPushButton('Prev')
        shuffleBtn = QPushButton('Shuffle')
        nextBtn = QPushButton('Next')
        playRecommendedBtn = QPushButton('Play Recommended Playlist')
        like = QPushButton('Like')
        dislike = QPushButton('DisLike')

        # Add button layouts
        controlArea = QVBoxLayout()  # centralWidget
        controls = QHBoxLayout()
        playlistCtrlLayout = QHBoxLayout()
        playRec = QHBoxLayout()
        ld = QHBoxLayout()

        # Add buttons to song controls layout
        controls.addWidget(playBtn)
        controls.addWidget(pauseBtn)
        controls.addWidget(stopBtn)
        # Add buttons to playlist controls layout
        playlistCtrlLayout.addWidget(prevBtn)
        playlistCtrlLayout.addWidget(shuffleBtn)
        playlistCtrlLayout.addWidget(nextBtn)
        playRec.addWidget(playRecommendedBtn)
        ld.addWidget(like)
        ld.addWidget(dislike)
        # Add to vertical layout
        controlArea.addWidget(sldPosition)
        controlArea.addWidget(volumeslider)
        controlArea.addLayout(controls)
        controlArea.addLayout(playlistCtrlLayout)
        controlArea.addLayout(playRec)
        controlArea.addLayout(ld)
        wid.setLayout(controlArea)
        # Connect each signal to their appropriate function
        playBtn.clicked.connect(self.playhandler)
        pauseBtn.clicked.connect(self.pausehandler)
        stopBtn.clicked.connect(self.stophandler)

        prevBtn.clicked.connect(self.prevSong)
        shuffleBtn.clicked.connect(self.shufflelist)
        nextBtn.clicked.connect(self.nextSong)

        playRecommendedBtn.clicked.connect(self.playRecommend)

        like.clicked.connect(self.like)
        dislike.clicked.connect(self.dislike)

        self.statusBar()

        self.playlist.currentMediaChanged.connect(self.songChanged)

    def like(self, text):
        QMessageBox.about(self, "Attention!", "You have Liked track!")

    def dislike(self, text):
        QMessageBox.about(self, "Attention!", "You have DisLiked track!")

    def connectYandexMusic(self):
        apple = LoginWindow()
        apple.exec_()

    def openFile(self):
        print("File button clicked!")
        song = QFileDialog.getOpenFileName(self, "Open Song", "~", "Sound Files (*.mp3 *.ogg *.wav *.m4a)")
        print(song[0])

        if song[0] != '':
            url = QUrl.fromLocalFile(song[0])
            if self.playlist.mediaCount() == 0:
                self.playlist.addMedia(QMediaContent(url))
                self.player.setPlaylist(self.playlist)
                self.player.play()
                self.userAction = 1
                print(self.playlist.mediaCount())
            else:
                self.playlist.addMedia(QMediaContent(url))
                print(self.playlist.mediaCount())
            self.getRecommendedPlaylist(song)

    def openFileRec(self, path):
        song = path

        if song != '':
            url = QUrl.fromLocalFile(song)
            if self.playlist.mediaCount() == 0:
                self.playlist.addMedia(QMediaContent(url))
                self.player.setPlaylist(self.playlist)
                self.player.play()
                self.userAction = 1
                print(self.playlist.mediaCount())
            else:
                self.playlist.addMedia(QMediaContent(url))
                print(self.playlist.mediaCount())

    def addFiles(self):
        print("Folder button clicked!")
        if self.playlist.mediaCount() != 0:
            self.folderIterator()
            print(self.playlist.mediaCount())
        else:
            self.folderIterator()
            self.player.setPlaylist(self.playlist)
            self.player.playlist().setCurrentIndex(0)
            self.player.play()
            print(self.playlist.mediaCount())
            self.userAction = 1

    def folderIterator(self):
        folderChosen = QFileDialog.getExistingDirectory(self, 'Open Music Folder', '~')
        if folderChosen != None:
            it = QDirIterator(folderChosen)
            it.next()
            while it.hasNext():
                if it.fileInfo().isDir() == False and it.filePath() != '.':
                    fInfo = it.fileInfo()
                    print(it.filePath(), fInfo.suffix())
                    if fInfo.suffix() in ('mp3', 'ogg', 'wav', 'm4a'):
                        print('added file', fInfo.fileName())
                        self.getRecommendedPlaylistFolder(it.filePath())
                        self.playlist.addMedia(QMediaContent(QUrl.fromLocalFile(it.filePath())))
                it.next()
            if it.fileInfo().isDir() == False and it.filePath() != '.':
                fInfo = it.fileInfo()
                print(it.filePath(), fInfo.suffix())
                if fInfo.suffix() in ('mp3', 'ogg', 'wav', 'm4a'):
                    print('added file', fInfo.fileName())
                    self.getRecommendedPlaylistFolder(it.filePath())
                    self.playlist.addMedia(QMediaContent(QUrl.fromLocalFile(it.filePath())))

    def playhandler(self):
        if self.playlist.mediaCount() == 0:
            self.openFile()
        elif self.playlist.mediaCount() != 0:
            self.player.play()
            print(self.playlist.mediaCount())
            self.userAction = 1

    def pausehandler(self):
        self.userAction = 2
        self.player.pause()

    def stophandler(self):
        self.userAction = 0
        self.player.stop()
        self.playlist.clear()
        print("Playlist cleared!")
        self.statusBar().showMessage("Stopped and cleared playlist")

    def changeVolume(self, value):
        self.player.setVolume(value)

    def changePosition(self, value):
        self.player.setPosition(value)

    def prevSong(self):
        if self.playlist.mediaCount() == 0:
            self.openFile()
        elif self.playlist.mediaCount() != 0:
            self.player.playlist().previous()

    def shufflelist(self):
        self.playlist.shuffle()
        print("Shuffled playlist!")

    def nextSong(self):
        if self.playlist.mediaCount() == 0:
            self.openFile()
        elif self.playlist.mediaCount() != 0:
            self.player.playlist().next()

    def songChanged(self, media):
        if not media.isNull():
            url = media.canonicalUrl()
            self.statusBar().showMessage(url.fileName())

    def toggleColors(self):

        app.setStyle("Fusion")
        palette = QPalette()
        if self.color == 0:
            palette.setColor(QPalette.Window, QColor(53, 53, 53))
            palette.setColor(QPalette.WindowText, Qt.white)
            palette.setColor(QPalette.Base, QColor(25, 25, 25))
            palette.setColor(QPalette.AlternateBase, QColor(53, 53, 53))
            palette.setColor(QPalette.ToolTipBase, Qt.white)
            palette.setColor(QPalette.ToolTipText, Qt.white)
            palette.setColor(QPalette.Text, Qt.white)
            palette.setColor(QPalette.Button, QColor(53, 53, 53))
            palette.setColor(QPalette.ButtonText, Qt.white)
            palette.setColor(QPalette.BrightText, Qt.red)
            palette.setColor(QPalette.Link, QColor(235, 101, 54))
            palette.setColor(QPalette.Highlight, QColor(235, 101, 54))
            palette.setColor(QPalette.HighlightedText, Qt.black)
            app.setPalette(palette)
            self.color = 1
        elif self.color == 1:
            palette.setColor(QPalette.Window, Qt.white)
            palette.setColor(QPalette.WindowText, Qt.black)
            palette.setColor(QPalette.Base, QColor(240, 240, 240))
            palette.setColor(QPalette.AlternateBase, Qt.white)
            palette.setColor(QPalette.ToolTipBase, Qt.white)
            palette.setColor(QPalette.ToolTipText, Qt.white)
            palette.setColor(QPalette.Text, Qt.black)
            palette.setColor(QPalette.Button, Qt.white)
            palette.setColor(QPalette.ButtonText, Qt.black)
            palette.setColor(QPalette.BrightText, Qt.red)
            palette.setColor(QPalette.Link, QColor(66, 155, 248))
            palette.setColor(QPalette.Highlight, QColor(66, 155, 248))
            palette.setColor(QPalette.HighlightedText, Qt.black)
            app.setPalette(palette)
            self.color = 0
Beispiel #3
0
class Ui_Dialog(QMainWindow):

    def __init__(self):
        super().__init__()
        self.player = QMediaPlayer()
        self.playlist = QMediaPlaylist()
        self.palette = QPalette()
        self.VerticalLayout = QVBoxLayout()
        self.userAction = -1  # 0- stopped, 1- playing 2-paused
        self.width = 550
        self.height = 700
        self.PlayerIsActive = 0 # 0 - not active, 1 - active
        self.nameFont = 'Plug_2.png'

        self.msgBox = QMessageBox()

    def setupUi(self, Dialog):
        Dialog.resize(self.width, self.height)
        Dialog.setWindowTitle('MyPlayer')
        Dialog.setWindowIcon(QIcon(self.nameFont))


        # Add MainMenu
        self.mainMenu = QMenuBar(Dialog)
        self.fileMenu = self.mainMenu.addMenu('File')
        self.ChangeThemeMenu = self.mainMenu.addMenu('Change')
        self.DataBaseSongs = self.mainMenu.addMenu('Recommend')
        self.helpMenu = self.mainMenu.addMenu('About')


        # Add In Menu Actions
        self.openAction = QAction('Open File')
        self.openAction.setShortcut('Ctrl+O')
        self.openActions = QAction('Open Directory')
        self.exitAction = QAction('Exit')
        self.exitAction.setShortcut('Ctrl+Q')

        self.loadBackgroung = QAction('Load my background')
        self.changeBlack = QAction('Change Black')
        self.changeWhite = QAction('Change white')

        self.RecommendedDataBase = QAction('Recommended data base of songs')

        self.Developer = QAction('About Developer')
        self.Program = QAction('About Program')
        self.Help_ = QAction('Help')


        # Add to Menus Actions
        self.fileMenu.addAction(self.openAction)
        self.fileMenu.addAction(self.openActions)
        self.fileMenu.addAction(self.exitAction)
        self.ChangeThemeMenu.addAction(self.changeBlack)
        self.ChangeThemeMenu.addAction(self.changeWhite)
        self.ChangeThemeMenu.addAction(self.loadBackgroung)
        self.DataBaseSongs.addAction(self.RecommendedDataBase)
        self.helpMenu.addAction(self.Developer)
        self.helpMenu.addAction(self.Program)
        self.helpMenu.addAction(self.Help_)


        # Create Slider Volume
        self.volumeslider = QSlider(Qt.Horizontal, Dialog)
        self.volumeslider.setFocusPolicy(Qt.NoFocus)
        self.volumeslider.setGeometry(420, 650, 120, 30)
        self.volumeslider.setValue(100)
        self.volumeslider.setTickInterval(20)
        self.volumeslider.setTickPosition(QSlider.TicksBelow)
        self.volumeslider.valueChanged[int].connect(self.changeVolume)

        #Create Slider Status of song
        self.songSlider = QSlider(Qt.Horizontal, Dialog)
        self.songSlider.setGeometry(17, 602, 521, 15)
        self.songSlider.setRange(0, 0)
        self.songSlider.sliderMoved.connect(self.set_position)



        # Add labels
        self.timeInStart = QLabel(Dialog)
        self.timeInStart.setGeometry(10, 612, 70, 25)
        self.AllTimeSong = QLabel(Dialog)
        self.AllTimeSong.setGeometry(500, 610, 70, 25)
        self.PictureAlbum = QLabel(Dialog)
        self.PictureAlbum.setGeometry(20, 170, 300, 300)
        self.showInfoToMusic_1 = QLabel(Dialog)
        self.showInfoToMusic_2 = QLabel(Dialog)
        self.showInfoToMusic_3 = QLabel(Dialog)
        self.showInfoToMusic_4 = QLabel(Dialog)

        # Add labals in Vertical layout widget
        self.verticalLayoutWidget = QtWidgets.QWidget(Dialog)
        self.verticalLayoutWidget.setGeometry(QtCore.QRect(350, 230, 200, 200))
        self.verticalLayout = QtWidgets.QVBoxLayout(self.verticalLayoutWidget)
        self.verticalLayout.setContentsMargins(0, 0, 0, 0)
        self.showInfoToMusic_1 = QtWidgets.QLabel(self.verticalLayoutWidget)
        self.verticalLayout.addWidget(self.showInfoToMusic_1)
        self.showInfoToMusic_1.setFont(QtGui.QFont("Times", 12, QtGui.QFont.Bold))
        self.showInfoToMusic_2 = QtWidgets.QLabel(self.verticalLayoutWidget)
        self.verticalLayout.addWidget(self.showInfoToMusic_2)
        self.showInfoToMusic_2.setFont(QtGui.QFont("Times", 12, QtGui.QFont.Bold))
        self.showInfoToMusic_3 = QtWidgets.QLabel(self.verticalLayoutWidget)
        self.verticalLayout.addWidget(self.showInfoToMusic_3)
        self.showInfoToMusic_3.setFont(QtGui.QFont("Times", 12, QtGui.QFont.Bold))
        self.showInfoToMusic_4 = QtWidgets.QLabel(self.verticalLayoutWidget)
        self.verticalLayout.addWidget(self.showInfoToMusic_4)
        self.showInfoToMusic_4.setFont(QtGui.QFont("Times", 12, QtGui.QFont.Bold))


        #Create buttons
            #initialization
        self.PlayBtn = QPushButton(Dialog)
        self.StopBtn = QPushButton(Dialog)
        self.BreakBtn = QPushButton(Dialog)
        self.NextBtn = QPushButton(Dialog)
        self.PrevBtn = QPushButton(Dialog)
        self.shuffleBtn = QPushButton(Dialog)


            #Show buttons
        self.PlayBtn.setGeometry(QtCore.QRect(245, 630, 60, 60))
        self.PlayBtn.setStyleSheet('''background: transparent;
                                         border-image: url(Play.png) ''')

        self.StopBtn.setGeometry(QtCore.QRect(190, 635, 55, 55))
        self.StopBtn.setStyleSheet('''background: transparent;
                                         border-image: url(Stop.png)''')


        self.BreakBtn.setGeometry(QtCore.QRect(305, 635, 55, 55))
        self.BreakBtn.setStyleSheet('''background: transparent;
                                         border-image: url(Break.png) ''')

        self.NextBtn.setGeometry(QtCore.QRect(355, 635, 55, 55))
        self.NextBtn.setStyleSheet('''background: transparent;
                                         border-image: url(Next_song.png) ''')

        self.PrevBtn.setGeometry(QtCore.QRect(140, 635, 55, 55))
        self.PrevBtn.setStyleSheet('''background: transparent;
                                         border-image: url(Prev_song.png) ''')

        self.shuffleBtn.setGeometry(QtCore.QRect(90, 635, 55, 55))
        self.shuffleBtn.setStyleSheet('''background: transparent;
                                            border-image: url(Shuffle_.png) ''')



        # Events
        self.player.positionChanged.connect(self.position_changed)
        self.player.durationChanged.connect(self.duration_changed)
        self.RecommendedDataBase.triggered.connect(self.connect_list)

        self.exitAction.triggered.connect(self.quit_trigger)
        self.openAction.triggered.connect(self.file_open)
        self.openActions.triggered.connect(self.addFiles)

        self.PlayBtn.clicked.connect(self.playMusic)
        self.BreakBtn.clicked.connect(self.stopMusic)
        self.StopBtn.clicked.connect(self.pauseMusic)

        self.PrevBtn.clicked.connect(self.prevSong)
        self.shuffleBtn.clicked.connect(self.shufflelist)
        self.NextBtn.clicked.connect(self.nextSong)

        self.loadBackgroung.triggered.connect(self.LoadYourBackground)
        self.changeBlack.triggered.connect(self.ChangeBlackTheme)
        self.changeWhite.triggered.connect(self.ChangeWhiteTheme)

        self.Developer.triggered.connect(self.AboutDeveloper)
        self.Program.triggered.connect(self.AboutProgram)
        self.Help_.triggered.connect(self.Help)

        self.ChangeBlackTheme()

        QtCore.QMetaObject.connectSlotsByName(Dialog)


    # Triggered function
    def AboutDeveloper(self):
        textOnDev = open('Developer.txt').read()
        self.msgBox.setStyleSheet('QMessageBox {background-image: url(BlackFont.png)}')
        self.msgBox.setText('About Developer')
        self.msgBox.setInformativeText(textOnDev)
        self.msgBox.setStandardButtons(QMessageBox.Close)
        self.msgBox.show()

    def AboutProgram(self):
        TextOnDev = open('Program.txt').read()
        self.msgBox.setStyleSheet('QMessageBox {background-image: url(BlackFont.png)}')
        self.msgBox.setText('About Program')
        self.msgBox.setInformativeText(TextOnDev)
        self.msgBox.setStandardButtons(QMessageBox.Close)
        self.msgBox.show()

    def Help(self):
        TextOnDev = open('Help.txt').read()
        self.msgBox.setStyleSheet('QMessageBox {background-image: url(BlackFont.png)}')
        self.msgBox.setText('Help')
        self.msgBox.setInformativeText(TextOnDev)
        self.msgBox.setStandardButtons(QMessageBox.Close)
        self.msgBox.show()

    def connect_list(self):
        self.w2 = Window2()
        dic_music = MusicParser.parse()
        x = 550
        y = 50
        for i, j in dic_music.items():
            #h = QLabel(self.w2)
            #h.setGeometry(10,0, x,y)
            verticalLayoutWidget = QtWidgets.QWidget(self.w2)
            verticalLayoutWidget.setGeometry(QtCore.QRect(10, 0, x, y))
            verticalLayout = QtWidgets.QVBoxLayout(verticalLayoutWidget)
            verticalLayout.setContentsMargins(0, 0, 0, 0)
            left_label = QLabel(verticalLayoutWidget)
            verticalLayout.addWidget(left_label)
            left_label.setFont(QtGui.QFont("Times", 9, QtGui.QFont.Bold))
            left_label.setText(i + ' - ' + j)
            y += 60

        self.w2.show()

    def position_changed(self, position):
        self.songSlider.setValue(position)
        self.timeInStart.setText(str(time.strftime("%M:%S", time.gmtime(position / 1000))))

    def duration_changed(self, duration):
        self.songSlider.setRange(0, duration)

    def set_position(self, position):
        self.player.setPosition(position)

    def quit_trigger(self):
        qApp.quit()

    def file_open(self):
        self.song = QFileDialog.getOpenFileName(self, "Open Song", "", "Sound Files (*.mp3 *.ogg *.wav *.m4a)")
        if self.song[0] != '':
            self.PlayerIsActive = 1
            url = QUrl.fromLocalFile(self.song[0])
            if self.playlist.mediaCount() == 0:
                self.playlist.addMedia(QMediaContent(url))
                self.player.setPlaylist(self.playlist)
                self.player.play()
                self.userAction = 1

            else:
                self.playlist.addMedia(QMediaContent(url))

        if self.PlayerIsActive == 1:
            self.showImage()
            self.ShowInfoAboutSong()
            self.showSlider()

    def showSlider(self):
        self.songSlider.setMaximum(self.long)

    def showImage(self):
        self.audioFile = mutagen.File(self.song[0])
        pixmap_1 = QPixmap('Plug_2.png').scaled(300, 300)
        try:
            photo = self.audioFile.tags.getall('APIC')[0].data
            pixmap = QPixmap()
            pixmap.loadFromData(photo)
            pixmap.scaled(300, 300)
            self.PictureAlbum.setPixmap(pixmap)
        except IndexError:
            self.PictureAlbum.setPixmap(pixmap_1)


    def ShowInfoAboutSong(self):
        #Open song in mutagen
        audioFile = mutagen.File(self.song[0])
        #Create time label (all time song)
        self.long = audioFile.info.length

        #Open all info about song and editing
        singer = audioFile.tags.getall('TPE1')
        song_title = audioFile.tags.getall('TIT2')
        YearOfSong = audioFile.tags.getall('TDRC')
        Bitrate = (audioFile.info.bitrate) // 1000
        singer = str(singer[0])
        song_title = str(song_title[0])

        #show all info on labels
        try:
            self.AllTimeSong.setText(str(time.strftime("%M:%S", time.gmtime(round(self.long)))))
            self.showInfoToMusic_1.setToolTip(singer.encode('latin1').decode('cp1251'))
            self.showInfoToMusic_2.setToolTip(song_title.encode('latin1').decode('cp1251'))
            self.showInfoToMusic_1.setText(singer.encode('latin1').decode('cp1251'))
            self.showInfoToMusic_2.setWordWrap(True)
            self.showInfoToMusic_2.setText(song_title.encode('latin1').decode('cp1251'))
            self.showInfoToMusic_2.setWordWrap(True)
            self.showInfoToMusic_3.setText(str(YearOfSong[0]))
            self.showInfoToMusic_4.setText(str(Bitrate) + ' kbps')

        except IndexError:
            self.showInfoToMusic.setText('')
        except UnicodeEncodeError:
            self.showInfoToMusic_2.setText(song_title)
            self.showInfoToMusic_1.setText(singer)


    def show_more_music(self):
        try:
            self.audioFile = mutagen.File(self.sp_songs[self.playlist.currentIndex()])
            pixmap_1 = QPixmap('Plug_2.png').scaled(300, 300)
            try:
                photo = self.audioFile.tags.getall('APIC')[0].data
                pixmap = QPixmap()
                pixmap.loadFromData(photo)
                pixmap.scaled(300, 300)
                self.PictureAlbum.setPixmap(pixmap)
            except IndexError:
                self.PictureAlbum.setPixmap(pixmap_1)

        except IndexError:
            pass
        try:
            self.index = 0
            audioFile = mutagen.File(self.sp_songs[self.playlist.currentIndex()])
            self.long = audioFile.info.length
            singer = audioFile.tags.getall('TPE1')
            song_title = audioFile.tags.getall('TIT2')
            YearOfSong = audioFile.tags.getall('TDRC')
            Bitrate = (audioFile.info.bitrate) // 1000
            singer = str(singer[0])
            song_title = str(song_title[0])
            try:
                self.AllTimeSong.setText(str(time.strftime("%M:%S", time.gmtime(round(self.long)))))
                self.showInfoToMusic_1.setToolTip(singer.encode('latin1').decode('cp1251'))
                self.showInfoToMusic_2.setToolTip(song_title.encode('latin1').decode('cp1251'))
                self.showInfoToMusic_1.setText(singer.encode('latin1').decode('cp1251'))
                self.showInfoToMusic_2.setWordWrap(True)
                self.showInfoToMusic_2.setText(song_title.encode('latin1').decode('cp1251'))
                self.showInfoToMusic_2.setWordWrap(True)
                self.showInfoToMusic_3.setText(str(YearOfSong[0]))
                self.showInfoToMusic_4.setText(str(Bitrate) + ' kbps')
            except IndexError:
                self.showInfoToMusic.setText('')
            except UnicodeEncodeError:
                self.showInfoToMusic_2.setText(song_title)
                self.showInfoToMusic_1.setText(singer)
        except IndexError:
            pass

    def addFiles(self):
        if self.playlist.mediaCount() != 0:
            self.folderIterator()
        else:
            self.folderIterator()
            self.player.setPlaylist(self.playlist)
            self.player.playlist().setCurrentIndex(0)
            self.player.play()
            self.userAction = 1
            self.PlayerIsActive = 1
            self.show_more_music()
            self.playlist.currentIndexChanged.connect(self.show_more_music)


    def folderIterator(self):
        folderChosen = QFileDialog.getExistingDirectory(self, 'Open Music Folder', '')
        if folderChosen != None:
            it = QDirIterator(folderChosen)
            it.next()
            self.sp_songs = []
            while it.hasNext():
                if it.fileInfo().isDir() == False and it.filePath() != '.':
                    fInfo = it.fileInfo()
                    if fInfo.suffix() in ('mp3', 'ogg', 'wav', 'm4a'):
                        self.sp_songs.append(it.filePath())
                        self.playlist.addMedia(QMediaContent(QUrl.fromLocalFile(it.filePath())))
                it.next()
            if it.fileInfo().isDir() == False and it.filePath() != '.':
                self.sp_songs.append(it.filePath())
                fInfo = it.fileInfo()
                if fInfo.suffix() in ('mp3', 'ogg', 'wav', 'm4a'):
                    self.playlist.addMedia(QMediaContent(QUrl.fromLocalFile(it.filePath())))


    def ChangeBlackTheme(self):
        oImage = QImage("BlackFont.png")
        sImage = oImage.scaled(QtCore.QSize(self.width, self.height))
        self.palette.setBrush(QPalette.Window, QBrush(sImage))
        self.palette.setColor(QPalette.Text, Qt.white)
        self.palette.setColor(QPalette.WindowText, Qt.white)
        self.palette.setColor(QPalette.ToolTipText, Qt.white)
        QApplication.setPalette(self.palette)


    def ChangeWhiteTheme(self):
        oImage = QImage("WhiteFont_.jpg")
        sImage = oImage.scaled(QtCore.QSize(self.width, self.height))
        self.palette.setBrush(QPalette.Window, QBrush(sImage))
        self.palette.setColor(QPalette.Text, Qt.black)
        self.palette.setColor(QPalette.WindowText, Qt.black)
        self.palette.setColor(QPalette.ToolTipText, Qt.black)
        QApplication.setPalette(self.palette)


    def LoadYourBackground(self):
        font = QFileDialog.getOpenFileName(self, "Open Image", "", "Image Files (*.png *.jpg *.JPEG )")
        oImage = QImage(font[0])
        sImage = oImage.scaled(QtCore.QSize(self.width, self.height))
        self.palette.setBrush(QPalette.Window, QBrush(sImage))
        self.palette.setColor(QPalette.Text, Qt.white)
        self.palette.setColor(QPalette.WindowText, Qt.white)
        self.palette.setColor(QPalette.ToolTipText, Qt.white)
        QApplication.setPalette(self.palette)


    def playMusic(self):
        if self.playlist.mediaCount() == 0:
            self.file_open()

        elif self.playlist.mediaCount() != 0:
            self.player.play()
            self.userAction = 1
            self.PlayerIsActive = 1

    def pauseMusic(self):
        self.userAction = 2
        self.player.pause()
        self.PlayerIsActive = 0

    def stopMusic(self):
        self.PlayerIsActive = 0
        self.userAction = 0
        self.player.stop()
        self.playlist.clear()

    def changeVolume(self, value):
        self.player.setVolume(value)

    def prevSong(self):
        if self.playlist.mediaCount() == 0:
            self.file_open()
        elif self.playlist.mediaCount() != 0:
            self.player.playlist().previous()
            try:
                self.show_more_music()
            except AttributeError:
                pass

    def shufflelist(self):
        if self.playlist.mediaCount() == 0:
            self.file_open()
        elif self.playlist.mediaCount() != 0:
            try:
                self.show_more_music()
                self.playlist.shuffle()
            except AttributeError:
                pass

    def nextSong(self):
        if self.playlist.mediaCount() == 0:
            self.file_open()
        elif self.playlist.mediaCount() != 0:
            try:
                self.player.playlist().next()
                self.show_more_music()
            except AttributeError:
                pass
class Window(QtWidgets.QDialog):

    def __init__(self):
        super().__init__()
        self.setGeometry(50, 50, 300, 400)
        self.setWindowTitle("Rolev Player")

# LIBRARY ROOT DIR FOLDER
        self.search_label = QtWidgets.QLabel("Select a music folder:", self)
        self.search_label.setGeometry(10, 5, 205, 10)

        self.btn_root_folder = QtWidgets.QPushButton("Browse", self)
        self.btn_root_folder.setGeometry(215, 20, 75, 25)

        # the text field of the currently selected root directory
        self.dir_text_field = QtWidgets.QLineEdit(self)
        self.dir_text_field.setGeometry(10, 20, 200, 25)

        self.btn_root_folder.clicked.connect(self.on_btn_root_folder)

# CURRENT MEDIA LABEL
        self.current_media_label = QtWidgets.QLabel("Now Playing: ", self)
        self.current_media_label.setGeometry(10, 260, 250, 15)

# CURRENT ALBUM COVER
        self.current_album_cover = QtWidgets.QLabel("Image", self)
        self.current_album_cover.setGeometry(10, 180, 75, 75)
        self.current_album_cover.setScaledContents(True)

# ARTIST DROP BOX
        self.artist_select_label = QtWidgets.QLabel("Artist", self)
        self.artist_select_label.setGeometry(10, 50, 250, 25)

        self.artist_select = QtWidgets.QComboBox(self)
        self.artist_select.setGeometry(10, 70, 250, 25)
        self.artist_select.activated[str].connect(self.on_artist_selection)

# ALBUMS DROP BOX
        self.album_select_label = QtWidgets.QLabel("Albums", self)
        self.album_select_label.setGeometry(10, 90, 250, 25)

        self.album_select = QtWidgets.QComboBox(self)
        self.album_select.setGeometry(10, 110, 250, 25)
        self.album_select.activated[str].connect(self.on_album_selection)

# SONGS DROP BOX
        self.song_select_label = QtWidgets.QLabel("Current Playlist", self)
        self.song_select_label.setGeometry(10, 130, 250, 25)

        self.song_select = QtWidgets.QComboBox(self)
        self.song_select.setGeometry(10, 150, 250, 25)
        self.song_select.activated[str].connect(self.on_song_selection)

# PLAYLIST
        self.playlist = QMediaPlaylist()
        self.playlist.currentIndexChanged.connect(self.meta_data_changed)

# MEDIA PLAYER
        self.player = QMediaPlayer()
        self.player.setPlaylist(self.playlist)
        self.player.playlist().setPlaybackMode(QMediaPlaylist.Loop)
        self.player.setVolume(50)

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

# VOLUME SLIDER
        self.slider_volume_label = QtWidgets.QLabel("Volume", self)
        self.slider_volume_label.setGeometry(10, 345, 50, 25)

        self.slider_volume = QtWidgets.QSlider(QtCore.Qt.Horizontal, self)
        self.slider_volume.setGeometry(60, 350, 130, 20)
        self.slider_volume.setRange(0, 100)
        self.slider_volume.setValue(50)
        self.slider_volume.valueChanged.connect(self.volume_change)

# PROGRESS SLIDER
        self.slider_progress_label = QtWidgets.QLabel("Progress", self)
        self.slider_progress_label.setGeometry(10, 315, 50, 25)

        self.slider_progress = QtWidgets.QSlider(QtCore.Qt.Horizontal, self)
        self.slider_progress.setGeometry(60, 320, 130, 20)
        self.slider_progress.sliderMoved.connect(self.progress_change)

# LYRICS SEARCH
        self.btn_lyrics = QtWidgets.QPushButton("Search\n Lyrics", self)
        self.btn_lyrics.setGeometry(220, 310, 70, 80)
        self.btn_lyrics.clicked.connect(self.on_lyrics)

# ALBUM INFO SEARCH
        self.btn_album_info = QtWidgets.QPushButton(
            "Search\nAlbum\nInfo", self)
        self.btn_album_info.setGeometry(105, 180, 75, 75)
        self.btn_album_info.clicked.connect(self.on_album_info)

# ARTIST INFO SEARCH
        self.btn_artist_info = QtWidgets.QPushButton(
            "Search\nArtist\nInfo", self)
        self.btn_artist_info.setGeometry(200, 180, 75, 75)
        self.btn_artist_info.clicked.connect(self.on_artist_info)

# PREV SONG BUTTON
        self.btn_prev = QtWidgets.QPushButton("Prev", self)
        self.btn_prev.setGeometry(10, 280, 75, 25)
        self.btn_prev.clicked.connect(self.on_btn_prev)

# NEXT SONG BUTTON
        self.btn_next = QtWidgets.QPushButton("Next", self)
        self.btn_next.setGeometry(200, 280, 75, 25)
        self.btn_next.clicked.connect(self.on_btn_next)

# PLAY/PAUSE BUTTON
        self.btn_play_pause = QtWidgets.QPushButton("Play", self)
        self.btn_play_pause.setGeometry(105, 280, 75, 30)
        self.btn_play_pause.clicked.connect(self.on_btn_play_pause)

        self.show()

    def on_btn_root_folder(self):
        self.root_dir = QtWidgets.QFileDialog().getExistingDirectory()
        self.dir_text_field.setText(self.root_dir)
        self.library = LibraryLoader.load_music_from_dir(
            self.dir_text_field.text())

        self.artist_select.clear()
        self.album_select.clear()
        self.song_select.clear()
        self.playlist.clear()

        self.btn_play_pause.setText("Play")
        self.artist_select.addItem("All Artists")
        for artist in self.library:
            self.artist_select.addItem(artist)
            for album in self.library[artist]:
                self.album_select.addItem(album)
        self.load_all_songs()

    def on_artist_selection(self):
        current_artist = self.artist_select.currentText()

        self.album_select.clear()
        self.song_select.clear()
        self.playlist.clear()

        self.btn_play_pause.setText("Play")
        self.album_select.addItem("All Albums")
        if current_artist == "All Artists":
            for artist in self.library:
                for album in self.library[artist]:
                    self.album_select.addItem(album)
            self.load_all_songs()
        else:
            for album in self.library[current_artist]:
                self.album_select.addItem(album)
            self.load_all_from_artist(current_artist)

    def load_all_songs(self):
        for artist in self.library:
            for album in self.library[artist]:
                for song in self.library[artist][album]:
                    self.song_select.addItem(song[0])
                    self.playlist.addMedia(
                        QMediaContent(QtCore.QUrl.fromLocalFile(song[1])))

    def load_all_from_artist(self, artist):
        for album in self.library[artist]:
            for song in self.library[artist][album]:
                self.song_select.addItem(song[0])
                self.playlist.addMedia(
                    QMediaContent(QtCore.QUrl.fromLocalFile(song[1])))

    def on_album_selection(self):
        current_artist = self.artist_select.currentText()
        current_album = self.album_select.currentText()
        self.song_select.clear()
        self.playlist.clear()
        self.btn_play_pause.setText("Play")
        if current_album == "All Albums" and current_artist == "All Artists":
            self.load_all_songs()

        elif current_album == "All Albums":
            self.load_all_from_artist(current_artist)

        elif current_artist == "All Artists":
            for artist in self.library:
                for album in self.library[artist]:
                    if album == self.album_select.currentText():
                        for song in self.library[artist][album]:
                            self.song_select.addItem(song[0])
                            self.playlist.addMedia(
                                QMediaContent(
                                    QtCore.QUrl.fromLocalFile(song[1])))
        else:
            for song in self.library[current_artist][current_album]:
                self.song_select.addItem(song[0])
                self.playlist.addMedia(
                    QMediaContent(QtCore.QUrl.fromLocalFile(song[1])))

    def on_song_selection(self):
        index = self.song_select.currentIndex()
        self.playlist.setCurrentIndex(index)

# GETTING THE CURRENT SONG METADATA
    # Returns a SONG OBJECT and not the current song title
    # For the title of the currently playing song use get_current_title()
    def get_current_song(self):
        curr_url = self.playlist.currentMedia().canonicalUrl().toString()[8:]
        if curr_url:
            return LibraryLoader.create_song(curr_url)

    def get_current_artist(self):
        if self.get_current_song() is not None:
            return self.get_current_song().artist

    def get_current_album(self):
        if self.get_current_song() is not None:
            return self.get_current_song().album

    def get_current_path(self):
        if self.get_current_song() is not None:
            return self.get_current_song().path

    def get_current_album_path(self):
        if self.get_current_path() is not None:
            return self.get_current_path().rsplit("/", 1)[0]

    def get_current_title(self):
        if self.get_current_song() is not None:
            return self.get_current_song().name

    def on_lyrics(self):
        if self.get_current_song() is not None:
            curr_artist = self.get_current_artist()
            curr_song = self.get_current_title()

            found_lyrics = RequestLyrics.search_song_lyrics(
                curr_artist, curr_song)
            choice = QtWidgets.QMessageBox.question(
                self, "Lyrics", found_lyrics[0],
                QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No)
            if choice == QtWidgets.QMessageBox.Yes:
                webbrowser.open(found_lyrics[1])
        else:
            QtWidgets.QMessageBox.information(
                self, "Lyrics", "No lyrics found or no media is loaded!")

    def on_album_info(self):
        album = self.get_current_album()
        artist = self.get_current_artist()
        if (album is None) or (artist is None):
            print("Please, load a song first!")
        else:
            artist_info, album_info = AlbumArtwork.album_artist_info(
                artist, album)
            if album_info is not None:
                webbrowser.open(album_info)

    def on_artist_info(self):
        album = self.get_current_album()
        artist = self.get_current_artist()
        if (album is None) or (artist is None):
            print("Please, load a song first!")
        else:
            artist_info, album_info = AlbumArtwork.album_artist_info(
                artist, album)
            if artist_info is not None:
                webbrowser.open(artist_info)

    def on_btn_play_pause(self):
        if self.player.state() in (0, 2):
            self.player.play()
            if self.player.state() == 1:
                self.btn_play_pause.setText("Pause")
        else:
            self.player.pause()
            self.btn_play_pause.setText("Play")

    def on_btn_next(self):
        self.player.playlist().next()

    def on_btn_prev(self):
        self.player.playlist().previous()

    def on_dur_change(self, length):
        self.slider_progress.setMaximum(length)

    def on_pos_change(self, position):
        self.slider_progress.setValue(position)

    def volume_change(self):
        volume = self.slider_volume.value()
        self.player.setVolume(volume)

    def progress_change(self):
        position = self.slider_progress.value()
        self.player.setPosition(position)

    def meta_data_changed(self):

        now_playing = self.get_current_title()
        self.current_media_label.setText("Now Playing: " + now_playing)

        # Updating the currently playing album cover
        curr_album_path = self.get_current_album_path()
        curr_album = self.get_current_album()
        curr_artist = self.get_current_artist()
        cover_url = AlbumArtwork.album_cover(
            curr_album_path, curr_artist, curr_album)

        self.current_album_cover.setPixmap(QPixmap(cover_url))
        Scrobbler.scrobble(self.get_current_artist(), self.get_current_title())
Beispiel #5
0
class App(QMainWindow):

    def __init__(self):
        super().__init__()
        self.player = QMediaPlayer() # 播放器
        self.playlist = QMediaPlaylist() # 播放列表
        self.title = '音乐播放器'
        self.volumeHint = QLabel('音量: 99%')
        self.mInfo = {
            'cover': './default_cover.jpg', 
            'music': '', 
            'singer': '',
            'duration': 0
        }
        self.aboutWin = AboutWindow()
        self.cover = QLabel()
        self.listWid = QListWidget()

        # 设置主窗口位置
        self.left = 200
        self.top = 100
        self.width = 500
        self.height = 430

        self.font = QFont('SansSerif', 10.5)
        self.color = 1  # 0 - 黑色界面, 1 - 白色界面
        self.userAction = 0  # 0 - 停止中, 1 - 播放中 2 - 暂停中
        self.initUI()

    def initUI(self):
        # 添加文件菜单
        menubar = self.menuBar()
        menubar.setNativeMenuBar(False) # 不使用本地菜单栏以获得全平台统一的效果
        filemenu = menubar.addMenu('文件')
        windowmenu = menubar.addMenu('窗口')

        fileAct = QAction('打开文件', self)
        folderAct = QAction('打开文件夹', self)
        themeAct = QAction('切换[亮/暗]主题', self)
        aboutAct = QAction('关于', self)

        fileAct.setShortcut('Ctrl+O')
        folderAct.setShortcut('Ctrl+D')
        themeAct.setShortcut('Ctrl+T')
        aboutAct.setShortcut('Ctrl+H')

        filemenu.addAction(fileAct)
        filemenu.addAction(folderAct)
        windowmenu.addAction(themeAct)
        windowmenu.addAction(aboutAct)

        fileAct.triggered.connect(self.openFile)
        folderAct.triggered.connect(self.addFiles)
        themeAct.triggered.connect(self.toggleColors)
        aboutAct.triggered.connect(self.viewAbout)
        self.listWid.itemDoubleClicked.connect(self.quickplayhandler)

        self.listWid.setFont(self.font)
        self.playlist.setPlaybackMode(2)
        self.setLayout()
        self.setWindowFlags(Qt.WindowMinimizeButtonHint | Qt.WindowCloseButtonHint) # 禁用窗口最大化按钮
        self.setFont(self.font)
        self.setWindowTitle(self.title)
        self.setWindowIcon(QIcon('icon.ico'))
        self.setGeometry(self.left, self.top, self.width, self.height)
        self.setFixedSize(self.width, self.height)
        self.toggleColors()
        self.show()

    def setLayout(self):
        wid = QWidget(self)
        self.setCentralWidget(wid)

        # 添加音量控制
        volumeslider = QSlider(Qt.Horizontal, self)
        volumeslider.setFocusPolicy(Qt.NoFocus)
        volumeslider.valueChanged[int].connect(self.changeVolume)
        volumeslider.setValue(100)

        # 添加歌曲播放控制
        playBtn = QPushButton('播放')  # 播放
        pauseBtn = QPushButton('暂停')  # 暂停
        stopBtn = QPushButton('清空列表')  # 停止
        prevBtn = QPushButton('上一首') # 上一首
        playback = QComboBox() # 回放模式
        nextBtn = QPushButton('下一首') # 下一首

        playback.addItem('      单曲播放')
        playback.addItem('      单曲循环')
        playback.addItem('      列表播放')
        playback.addItem('      列表循环')
        playback.addItem('      列表随机')

        playback.setCurrentIndex(2)

        # 添加封面
        jpg = QPixmap(self.mInfo['cover']).scaled(300, 300)
        self.cover.setPixmap(jpg)

        # 添加布局
        Area = QVBoxLayout()  # centralWidget
        controls = QHBoxLayout()
        showLayout = QHBoxLayout()
        playlistCtrlLayout = QHBoxLayout()

        # 歌曲播放控制布局
        controls.addWidget(playBtn)
        controls.addWidget(pauseBtn)
        controls.addWidget(stopBtn)

        # 播放列表控制布局
        playlistCtrlLayout.addWidget(prevBtn)
        playlistCtrlLayout.addWidget(playback)
        playlistCtrlLayout.addWidget(nextBtn)

        # 显示布局
        showLayout.addWidget(self.cover)
        showLayout.addWidget(self.listWid)

        # 竖直排列
        Area.addStretch(1)
        Area.addLayout(showLayout)
        Area.addWidget(self.volumeHint)
        Area.addWidget(volumeslider)
        Area.addLayout(controls)
        Area.addLayout(playlistCtrlLayout)
        wid.setLayout(Area)

        # 事件绑定
        playBtn.clicked.connect(self.playhandler)
        pauseBtn.clicked.connect(self.pausehandler)
        playback.currentIndexChanged.connect(self.playbackhandler)
        stopBtn.clicked.connect(self.stophandler)

        prevBtn.clicked.connect(self.prevSong)
        nextBtn.clicked.connect(self.nextSong)

        self.statusBar().showMessage('文件-打开文件(夹)-选择-开始播放')
        self.playlist.currentMediaChanged.connect(self.songChanged)

    def openFile(self):
        print("点击了文件按钮")
        song = QFileDialog.getOpenFileName(self, "打开音频", "github-lkxed", "音频文件 (*.mp3 *.ogg *.wav *.m4a)")

        if song[0] != '':
            url = QUrl.fromLocalFile(song[0])
            if self.playlist.mediaCount() == 0:
                self.playlist.addMedia(QMediaContent(url))
                self.player.setPlaylist(self.playlist)
                self.player.play()
                self.userAction = 1
                self.listWid.addItem(song[0].split('/')[-1].split('.')[0])
                print(self.playlist.mediaCount())
            else:
                self.playlist.addMedia(QMediaContent(url))
                print(self.playlist.mediaCount())

    def addFiles(self):
        print("点击了文件夹按钮")
        if self.playlist.mediaCount() != 0:
            self.folderIterator()
            print(self.playlist.mediaCount())
        else:
            self.folderIterator()
            self.player.setPlaylist(self.playlist)
            self.player.playlist().setCurrentIndex(0)
            self.player.play()
            print(self.playlist.mediaCount())
            self.userAction = 1
    
    def folderIterator(self):
        folderChosen = QFileDialog.getExistingDirectory(self, '打开音频文件夹', '.')
        if folderChosen != None:
            it = QDirIterator(folderChosen)
            it.next()
            while it.hasNext():
                if it.fileInfo().isDir() == False and it.filePath() != '.':
                    fInfo = it.fileInfo()
                    print(it.filePath(), fInfo.suffix())
                    if fInfo.suffix() in ('mp3', 'ogg', 'wav', 'm4a'):
                        print('added file', fInfo.fileName())
                        self.listWid.addItem(fInfo.fileName())
                        self.playlist.addMedia(QMediaContent(QUrl.fromLocalFile(it.filePath())))
                it.next()
            if it.fileInfo().isDir() == False and it.filePath() != '.':
                fInfo = it.fileInfo()
                print(it.filePath(), fInfo.suffix())
                if fInfo.suffix() in ('mp3', 'ogg', 'wav', 'm4a'):
                    print('added file', fInfo.fileName())
                    self.listWid.addItem(fInfo.fileName())
                    self.playlist.addMedia(QMediaContent(QUrl.fromLocalFile(it.filePath())))

            # 设置ListItem高度
            for x in range(self.listWid.count()):
                self.listWid.item(x).setSizeHint(QSize(100, 30))

    # 处理双击播放事件
    def quickplayhandler(self, item):
        # 若播放列表没有音频了就跳出打开文件对话框
        if self.playlist.mediaCount() == 0:
            self.openFile()
        # 若播放列表不为空则播放
        elif self.playlist.mediaCount() != 0:
            index = self.listWid.currentRow()
            self.player.playlist().setCurrentIndex(index)
            self.player.play()
            self.userAction = 1

    # 处理按钮播放事件
    def playhandler(self):
        if self.userAction == 2:
            self.player.play()
        elif self.userAction == 0:
            # 若播放列表没有音频了就跳出打开文件对话框
            if self.playlist.mediaCount() == 0:
                self.openFile()
            # 若播放列表不为空则播放
            elif self.playlist.mediaCount() != 0:
                index = self.listWid.currentRow()
                self.player.playlist().setCurrentIndex(index)
                self.player.play()
                self.userAction = 1
        else:
            self.statusBar().showMessage('已经在播放中!')

    # 处理暂停事件
    def pausehandler(self):
        self.userAction = 2
        self.player.pause()

    # 处理清空列表事件
    def stophandler(self):
        self.userAction = 0
        self.player.stop()
        self.playlist.clear()
        self.listWid.clear()
        self.mInfo['cover'] = 'default_cover.jpg'
        jpg = QPixmap(self.mInfo['cover']).scaled(300, 300)
        self.cover.setPixmap(jpg)
        print("Playlist cleared!")
        self.statusBar().showMessage("列表已清空")

    def changeVolume(self, value):
        text = '音量: ' + str(value) + '%'
        self.volumeHint.setText(text)
        self.player.setVolume(value)

    # 上一首事件
    def prevSong(self):
        if self.playlist.currentIndex() == 0:
            self.playlist.setCurrentIndex(self.playlist.mediaCount()-1)
        else:
            self.player.playlist().previous()
    
    # 随机播放事件
    def playbackhandler(self, index):
        self.playlist.setPlaybackMode(index)
        print(self.playlist.playbackMode())

    # 下一首事件
    def nextSong(self):
        if self.playlist.mediaCount() == self.playlist.currentIndex()+1:
            self.playlist.setCurrentIndex(0)
        else:
            self.player.playlist().next()
    
    # 音频切换事件
    def songChanged(self, media):
        if not media.isNull():
            url = media.canonicalUrl()
            self.showInfo(url)
            self.statusBar().showMessage(url.fileName())
            index = self.player.playlist().currentIndex()
            self.listWid.setCurrentRow(index)

    def showInfo(self, url):
        filepath = url.path()[1:]
        filename = url.fileName()[:-4]
        print(filename)
        if filepath[-3:] == 'm4a':
            file = mutagen.MP4(filepath)
            try:
                img = file.tags['covr'][0]
                self.mInfo['cover'] = './cover/'+filename+'.jpg'
                if not os.path.exists('./cover'):
                    os.mkdir('./cover')
                if not os.path.exists(self.mInfo['cover']):
                    with open(self.mInfo['cover'], 'wb') as f:
                        f.write(img)
            except:
                print('找不到封面')
                self.mInfo['cover'] = './default_cover.jpg'

        elif filepath[-3:] == 'mp3':
            file = mutagen.File(filepath)
            try:
                img = file.tags['APIC:'].data
                self.mInfo['cover'] = './cover/'+filename+'.jpg'
                if not os.path.exists('./cover'):
                    os.mkdir('./cover')
                if not os.path.exists(self.mInfo['cover']):
                    with open(self.mInfo['cover'], 'wb') as f:
                        f.write(img)
            except:
                print('找不到封面')
                self.mInfo['cover'] = './default_cover.jpg'
        else:
            print('音频文件不支持提取封面')
            self.mInfo['cover'] = './default_cover.jpg'

        jpg = QPixmap(self.mInfo['cover']).scaled(300, 300)
        self.cover.setPixmap(jpg)


    # 主题切换事件
    def toggleColors(self):

        app.setStyle("Fusion")
        palette = QPalette()

        # 明亮主题
        if self.color == 0:
            palette.setColor(QPalette.Window, QColor(53, 53, 53))
            palette.setColor(QPalette.WindowText, Qt.white)
            palette.setColor(QPalette.Base, QColor(25, 25, 25))
            palette.setColor(QPalette.AlternateBase, QColor(53, 53, 53))
            palette.setColor(QPalette.ToolTipBase, Qt.white)
            palette.setColor(QPalette.ToolTipText, Qt.white)
            palette.setColor(QPalette.Text, Qt.white)
            palette.setColor(QPalette.Button, QColor(53, 53, 53))
            palette.setColor(QPalette.ButtonText, Qt.white)
            palette.setColor(QPalette.BrightText, Qt.red)
            palette.setColor(QPalette.Link, QColor(235, 101, 54))
            palette.setColor(QPalette.Highlight, QColor(235, 101, 54))
            palette.setColor(QPalette.HighlightedText, Qt.black)
            app.setPalette(palette)
            self.color = 1

        # 黑暗主题
        elif self.color == 1:
            palette.setColor(QPalette.Window, Qt.white)
            palette.setColor(QPalette.WindowText, Qt.black)
            palette.setColor(QPalette.Base, QColor(240, 240, 240))
            palette.setColor(QPalette.AlternateBase, Qt.white)
            palette.setColor(QPalette.ToolTipBase, Qt.white)
            palette.setColor(QPalette.ToolTipText, Qt.white)
            palette.setColor(QPalette.Text, Qt.black)
            palette.setColor(QPalette.Button, Qt.white)
            palette.setColor(QPalette.ButtonText, Qt.black)
            palette.setColor(QPalette.BrightText, Qt.red)
            palette.setColor(QPalette.Link, QColor(66, 155, 248))
            palette.setColor(QPalette.Highlight, QColor(66, 155, 248))
            palette.setColor(QPalette.HighlightedText, Qt.black)
            app.setPalette(palette)
            self.color = 0

    def viewAbout(self):
        self.aboutWin.show()
Beispiel #6
0
class App(QMainWindow):
    def __init__(self):
        super().__init__()
        self.player = QMediaPlayer()
        self.playlist = QMediaPlaylist()
        self.title = 'PyTunes'
        self.left = 300
        self.top = 300
        self.width = 300
        self.height = 150
        self.color = 0  # 0- toggle to dark 1- toggle to light
        self.userAction = -1  # 0- stopped, 1- playing 2-paused
        self.initUI()

    def initUI(self):
        # Add file menu
        menubar = self.menuBar()
        filemenu = menubar.addMenu('File')
        windowmenu = menubar.addMenu('Window')

        fileAct = QAction('Open File', self)
        folderAct = QAction('Open Folder', self)
        themeAct = QAction('Toggle light/dark theme', self)

        fileAct.setShortcut('Ctrl+O')
        folderAct.setShortcut('Ctrl+D')
        themeAct.setShortcut('Ctrl+T')

        filemenu.addAction(fileAct)
        filemenu.addAction(folderAct)
        windowmenu.addAction(themeAct)

        fileAct.triggered.connect(self.openFile)
        folderAct.triggered.connect(self.addFiles)
        themeAct.triggered.connect(self.toggleColors)

        self.addControls()

        self.setWindowTitle(self.title)
        self.setGeometry(self.left, self.top, self.width, self.height)
        self.toggleColors()
        self.show()

    def addControls(self):
        wid = QWidget(self)
        self.setCentralWidget(wid)
        # Add song controls
        volumeslider = QSlider(Qt.Horizontal, self)
        volumeslider.setFocusPolicy(Qt.NoFocus)
        volumeslider.valueChanged[int].connect(self.changeVolume)
        volumeslider.setValue(100)
        playBtn = QPushButton('Play')  # play button
        pauseBtn = QPushButton('Pause')  # pause button
        stopBtn = QPushButton('Stop')  # stop button
        # Add playlist controls
        prevBtn = QPushButton('Prev')
        shuffleBtn = QPushButton('Shuffle')
        nextBtn = QPushButton('Next')
        # Add button layouts
        controlArea = QVBoxLayout()  # centralWidget
        controls = QHBoxLayout()
        playlistCtrlLayout = QHBoxLayout()
        # Add buttons to song controls layout
        controls.addWidget(playBtn)
        controls.addWidget(pauseBtn)
        controls.addWidget(stopBtn)
        # Add buttons to playlist controls layout
        playlistCtrlLayout.addWidget(prevBtn)
        playlistCtrlLayout.addWidget(shuffleBtn)
        playlistCtrlLayout.addWidget(nextBtn)
        # Add to vertical layout
        controlArea.addWidget(volumeslider)
        controlArea.addLayout(controls)
        controlArea.addLayout(playlistCtrlLayout)
        wid.setLayout(controlArea)
        # Connect each signal to their appropriate function
        playBtn.clicked.connect(self.playhandler)
        pauseBtn.clicked.connect(self.pausehandler)
        stopBtn.clicked.connect(self.stophandler)

        prevBtn.clicked.connect(self.prevSong)
        shuffleBtn.clicked.connect(self.shufflelist)
        nextBtn.clicked.connect(self.nextSong)

        self.statusBar()
        self.playlist.currentMediaChanged.connect(self.songChanged)

    def openFile(self):
        song = QFileDialog.getOpenFileName(
            self, "Open Song", "~", "Sound Files (*.mp3 *.ogg *.wav *.m4a)")

        if song[0] != '':
            url = QUrl.fromLocalFile(song[0])
            if self.playlist.mediaCount() == 0:
                self.playlist.addMedia(QMediaContent(url))
                self.player.setPlaylist(self.playlist)
                self.player.play()
                self.userAction = 1
            else:
                self.playlist.addMedia(QMediaContent(url))

    def addFiles(self):
        if self.playlist.mediaCount() != 0:
            self.folderIterator()
        else:
            self.folderIterator()
            self.player.setPlaylist(self.playlist)
            self.player.playlist().setCurrentIndex(0)
            self.player.play()
            self.userAction = 1

    def folderIterator(self):
        folderChosen = QFileDialog.getExistingDirectory(
            self, 'Open Music Folder', '~')
        if folderChosen != None:
            it = QDirIterator(folderChosen)
            it.next()
            while it.hasNext():
                if it.fileInfo().isDir() == False and it.filePath() != '.':
                    fInfo = it.fileInfo()
                    if fInfo.suffix() in ('mp3', 'ogg', 'wav', 'm4a'):
                        self.playlist.addMedia(
                            QMediaContent(QUrl.fromLocalFile(it.filePath())))
                it.next()
            if it.fileInfo().isDir() == False and it.filePath() != '.':
                fInfo = it.fileInfo()
                if fInfo.suffix() in ('mp3', 'ogg', 'wav', 'm4a'):
                    self.playlist.addMedia(
                        QMediaContent(QUrl.fromLocalFile(it.filePath())))

    def playhandler(self):
        if self.playlist.mediaCount() == 0:
            self.openFile()
        elif self.playlist.mediaCount() != 0:
            self.player.play()
            self.userAction = 1

    def pausehandler(self):
        self.userAction = 2
        self.player.pause()

    def stophandler(self):
        self.userAction = 0
        self.player.stop()
        self.playlist.clear()
        self.statusBar().showMessage("Stopped and cleared playlist")

    def changeVolume(self, value):
        self.player.setVolume(value)

    def prevSong(self):
        if self.playlist.mediaCount() == 0:
            self.openFile()
        elif self.playlist.mediaCount() != 0:
            self.player.playlist().previous()

    def shufflelist(self):
        self.playlist.shuffle()

    def nextSong(self):
        if self.playlist.mediaCount() == 0:
            self.openFile()
        elif self.playlist.mediaCount() != 0:
            self.player.playlist().next()

    def songChanged(self, media):
        if not media.isNull():
            url = media.canonicalUrl()
            self.statusBar().showMessage(url.fileName())

    def toggleColors(self):

        app.setStyle("Fusion")
        palette = QPalette()
        if self.color == 0:
            palette.setColor(QPalette.Window, QColor(53, 53, 53))
            palette.setColor(QPalette.WindowText, Qt.white)
            palette.setColor(QPalette.Base, QColor(25, 25, 25))
            palette.setColor(QPalette.AlternateBase, QColor(53, 53, 53))
            palette.setColor(QPalette.ToolTipBase, Qt.white)
            palette.setColor(QPalette.ToolTipText, Qt.white)
            palette.setColor(QPalette.Text, Qt.white)
            palette.setColor(QPalette.Button, QColor(53, 53, 53))
            palette.setColor(QPalette.ButtonText, Qt.white)
            palette.setColor(QPalette.BrightText, Qt.red)
            palette.setColor(QPalette.Link, QColor(235, 101, 54))
            palette.setColor(QPalette.Highlight, QColor(235, 101, 54))
            palette.setColor(QPalette.HighlightedText, Qt.black)
            app.setPalette(palette)
            self.color = 1
        elif self.color == 1:
            palette.setColor(QPalette.Window, Qt.white)
            palette.setColor(QPalette.WindowText, Qt.black)
            palette.setColor(QPalette.Base, QColor(240, 240, 240))
            palette.setColor(QPalette.AlternateBase, Qt.white)
            palette.setColor(QPalette.ToolTipBase, Qt.white)
            palette.setColor(QPalette.ToolTipText, Qt.white)
            palette.setColor(QPalette.Text, Qt.black)
            palette.setColor(QPalette.Button, Qt.white)
            palette.setColor(QPalette.ButtonText, Qt.black)
            palette.setColor(QPalette.BrightText, Qt.red)
            palette.setColor(QPalette.Link, QColor(66, 155, 248))
            palette.setColor(QPalette.Highlight, QColor(66, 155, 248))
            palette.setColor(QPalette.HighlightedText, Qt.black)
            app.setPalette(palette)
            self.color = 0
Beispiel #7
0
class MainWindowMusicPlayer(QMainWindow):
    stopState: bool

    def __init__(self):
        super().__init__()
        self.currentPlaylist = QMediaPlaylist()
        self.player = QMediaPlayer()
        self.userAction = -1  # 0 - stopped, 1 - playing 2 - paused
        self.player.mediaStatusChanged.connect(self.qmp_media_status_changed)
        self.player.stateChanged.connect(self.qmp_state_changed)
        self.player.positionChanged.connect(self.qmp_position_changed)
        self.player.volumeChanged.connect(self.qmp_volume_changed)
        self.player.setVolume(60)
        # Status bar
        self.statusBar().showMessage('No Media'
                                     ' :: %d' % self.player.volume())
        self.home_screen()

    def home_screen(self):
        self.setWindowTitle('Music Player')

        self.create_menubar()

        self.create_toolbar()

        controlBar = self.add_controls()

        # need to add both information screen
        # and control bar to the central widget.
        centralWidget = QWidget()
        centralWidget.setLayout(controlBar)
        self.setCentralWidget(centralWidget)

        # Set size of the MainWindow
        self.resize(200, 100)

        self.show()

    def create_menubar(self):
        menubar = self.menuBar()
        file_menu = menubar.addMenu('File')
        file_menu.addAction(self.file_open())
        file_menu.addAction(self.song_info())
        file_menu.addAction(self.folder_open())
        file_menu.addAction(self.exit_action())

    def create_toolbar(self):
        pass

    def add_controls(self):
        controlArea = QVBoxLayout()
        seekSliderLayout = QHBoxLayout()
        controls = QHBoxLayout()
        playlistCtrlLayout = QHBoxLayout()

        # creating buttons
        playBtn = QPushButton('Play')  # play button
        pauseBtn = QPushButton('Pause')  # pause button
        stopBtn = QPushButton('Stop')  # stop button
        volumeDescBtn = QPushButton('V (-)')  # Decrease Volume
        volumeIncBtn = QPushButton('V (+)')  # Increase Volume

        # creating playlist controls
        prevBtn = QPushButton('Prev Song')
        nextBtn = QPushButton('Next Song')

        # creating seek slider
        seekSlider = QSlider()
        seekSlider.setMinimum(0)
        seekSlider.setMaximum(100)
        seekSlider.setOrientation(Qt.Horizontal)
        seekSlider.setTracking(False)
        seekSlider.sliderMoved.connect(self.seek_position)
        # seekSlider.valueChanged.connect(self.seekPosition)

        seekSliderLabel1 = QLabel('0.00')
        seekSliderLabel2 = QLabel('0.00')
        seekSliderLayout.addWidget(seekSliderLabel1)
        seekSliderLayout.addWidget(seekSlider)
        seekSliderLayout.addWidget(seekSliderLabel2)

        # Add handler for each button. Not using the default slots.
        playBtn.clicked.connect(self.play_handler)
        pauseBtn.clicked.connect(self.pause_handler)
        stopBtn.clicked.connect(self.stop_handler)
        volumeDescBtn.clicked.connect(self.decrease_volume)
        volumeIncBtn.clicked.connect(self.increase_volume)

        # Adding to the horizontal layout
        controls.addWidget(volumeDescBtn)
        controls.addWidget(playBtn)
        controls.addWidget(pauseBtn)
        controls.addWidget(stopBtn)
        controls.addWidget(volumeIncBtn)

        # playlist control button handlers
        prevBtn.clicked.connect(self.prev_item_playlist)
        nextBtn.clicked.connect(self.next_item_playlist)
        playlistCtrlLayout.addWidget(prevBtn)
        playlistCtrlLayout.addWidget(nextBtn)

        # Adding to the vertical layout
        controlArea.addLayout(seekSliderLayout)
        controlArea.addLayout(controls)
        controlArea.addLayout(playlistCtrlLayout)
        return controlArea

    # Music playback function
    def play_handler(self):
        self.userAction = 1
        self.statusBar().showMessage('Playing at Volume %d' %
                                     self.player.volume())
        if self.player.state() == QMediaPlayer.StoppedState:
            if self.player.mediaStatus() == QMediaPlayer.NoMedia:
                print(self.currentPlaylist.mediaCount())
                if self.currentPlaylist.mediaCount() == 0:
                    self.open_file()
                if self.currentPlaylist.mediaCount() != 0:
                    self.player.setPlaylist(self.currentPlaylist)
            elif self.player.mediaStatus() ==\
                    QMediaPlayer.LoadedMedia:
                self.player.play()
            elif self.player.mediaStatus() ==\
                    QMediaPlayer.BufferedMedia:
                self.player.play()
        elif self.player.state() == QMediaPlayer.PlayingState:
            pass
        elif self.player.state() == QMediaPlayer.PausedState:
            self.player.play()

    # Music pause function
    def pause_handler(self):
        self.userAction = 2
        self.statusBar().showMessage(
            'Paused %s at position'
            ' %s at Volume %d' %
            (self.player.metaData(QMediaMetaData.Title),
             self.centralWidget().layout().itemAt(0).layout().itemAt(
                 0).widget().text(), self.player.volume()))
        self.player.pause()

    # Music stop function
    def stop_handler(self):
        self.userAction = 0
        self.statusBar().showMessage('Stopped at Volume %d' %
                                     (self.player.volume()))
        if self.player.state() == QMediaPlayer.PlayingState:
            self.stopState = True
            self.player.stop()
        elif self.player.state() == QMediaPlayer.PausedState:
            self.player.stop()
        elif self.player.state() == QMediaPlayer.StoppedState:
            pass

    # Music status change function
    def qmp_media_status_changed(self):
        if self.player.mediaStatus() == QMediaPlayer.LoadedMedia \
                and self.userAction == 1:
            durationT = self.player.duration()
            self.centralWidget().layout().itemAt(0).layout() \
                .itemAt(1).widget().setRange(0, durationT)
            self.centralWidget().layout().itemAt(0).layout() \
                .itemAt(2).widget().setText(
                '%d:%02d' % (int(durationT / 60000),
                             int((durationT / 1000) % 60)))
            self.player.play()

    # Music playing change function
    def qmp_state_changed(self):
        if self.player.state() == QMediaPlayer.StoppedState:
            self.player.stop()

    # Music time change function
    def qmp_position_changed(self, position, senderType=False):
        sliderLayout = self.centralWidget().layout().itemAt(0)\
            .layout()
        if not senderType:
            sliderLayout.itemAt(1).widget().setValue(position)
        # update the text label
        sliderLayout.itemAt(0).widget()\
            .setText('%d:%02d' %
                     (int(position / 60000),
                      int((position / 1000) % 60)))

    def seek_position(self, position):
        sender = self.sender()
        if isinstance(sender, QSlider):
            if self.player.isSeekable():
                self.player.setPosition(position)

    # Music volume change function
    def qmp_volume_changed(self):
        msg = self.statusBar().currentMessage()
        msg = msg[:-2] + str(self.player.volume())
        self.statusBar().showMessage(msg)

    # Music volume + change function
    def increase_volume(self):
        vol = self.player.volume()
        vol = min(vol + 5, 100)
        self.player.setVolume(vol)

    # Music volume - change function
    def decrease_volume(self):
        vol = self.player.volume()
        vol = max(vol - 5, 0)
        self.player.setVolume(vol)

    # File open function
    def file_open(self):
        fileAc = QAction(QIcon('icons\\open.png'), 'Open File', self)
        fileAc.setShortcut('Ctrl+O')
        fileAc.setStatusTip('Open File')
        fileAc.triggered.connect(self.open_file)
        return fileAc

    # File opening function
    def open_file(self):
        file_Chosen = QFileDialog.getOpenFileUrl(self, 'Open Music File',
                                                 expanduser('~'),
                                                 'Audio (*.mp3 *.ogg *.wav)',
                                                 '*.mp3 *.ogg *.wav')
        if file_Chosen is not None:
            self.currentPlaylist.addMedia(QMediaContent(file_Chosen[0]))

    # Folder open function
    def folder_open(self):
        folderAc = QAction(QIcon('icons\\open_fld.png'), 'Open Folder', self)
        folderAc.setShortcut('Ctrl+D')
        folderAc.setStatusTip('Open Folder '
                              '(Will add all the files in'
                              ' the folder)')
        folderAc.triggered.connect(self.add_files)
        return folderAc

    # Folder opening function
    def add_files(self):
        folder_Chosen = QFileDialog\
            .getExistingDirectory(self,
                                  'Open Music Folder',
                                  expanduser('~'))
        if folder_Chosen is not None:
            it = QDirIterator(folder_Chosen)
            it.next()
            while it.hasNext():
                if it.fileInfo().isDir() == False\
                        and it.filePath() != '.':
                    fInfo = it.fileInfo()
                    print(it.filePath(), fInfo.suffix())
                    if fInfo.suffix() in ('mp3', 'ogg', 'wav'):
                        print('added file ', fInfo.fileName())
                        self.currentPlaylist. \
                            addMedia(QMediaContent(
                            QUrl.fromLocalFile(it.filePath())))
                it.next()

    # Song information function
    def song_info(self):
        infoAc = QAction(QIcon('icons\\info.png'), 'Info', self)
        infoAc.setShortcut('Ctrl+I')
        infoAc.setStatusTip('Displays Current Song Information')
        infoAc.triggered.connect(self.display_song_info)
        return infoAc

    # Show song information
    def display_song_info(self):
        metaDataKeyList = self.player.availableMetaData()
        fullText = '<table class="tftable" border="0">'
        for key in metaDataKeyList:
            value = self.player.metaData(key)
            fullText = \
                fullText + '<tr><td>' + key + '</td><td>' + \
                str(value) + '</td></tr>'
        fullText = fullText + '</table>'
        infoBox = QMessageBox(self)
        infoBox.setWindowTitle('Detailed Song Information')
        infoBox.setTextFormat(Qt.RichText)
        infoBox.setText(fullText)
        infoBox.addButton('OK', QMessageBox.AcceptRole)
        infoBox.show()

    # Switch to previous song
    def prev_item_playlist(self):
        self.player.playlist().previous()

    # Switch to next song
    def next_item_playlist(self):
        self.player.playlist().next()

    # exit function
    def exit_action(self):
        exitAc = QAction(QIcon('icons\\exit.png'), '&Exit', self)
        exitAc.setShortcut('Ctrl+Q')
        exitAc.setStatusTip('Exit App')
        exitAc.triggered.connect(self.close)
        return exitAc

    # exiting function
    @staticmethod
    def exit():
        sys.exit(app.exec_())
Beispiel #8
0
class frame(QWidget):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.resize(300, 300)
        self.setFixedSize(300, 300)
        self.playbtn = QPushButton(self)
        self.playbtn.setText("播放")
        self.playbtn.clicked.connect(self.play)
        self.stopbtn = QPushButton(self)
        self.stopbtn.setText("暂停")
        self.stopbtn.clicked.connect(self.stop)
        self.addbtn = QPushButton(self)
        self.addbtn.setText("添加")
        self.addbtn.clicked.connect(self.add)
        self.nextbtn = QPushButton(self)
        self.nextbtn.setText("下一首")
        self.nextbtn.clicked.connect(self.nextsong)
        self.previousbtn = QPushButton(self)
        self.previousbtn.setText("上一首")
        self.previousbtn.clicked.connect(self.previous)
        self.modebtn = QPushButton(self)
        self.modebtn.setText("列表循环")
        self.modebtn.clicked.connect(self.Playback_mode)
        self.deletebtn = QPushButton(self)
        self.deletebtn.setText("删除")
        self.deletebtn.clicked.connect(self.delete)
        self.list = QListWidget()
        self.list.itemDoubleClicked.connect(self.play)
        self.slider = QSlider(Qt.Horizontal, self)  #进度条
        self.slider.setMinimumHeight(5)
        self.slider.setMinimumWidth(250)

        # self.slider.setRange(0, 300)
        # self.slider.setOrientation(Qt.Horizontal) #设置水平方向
        self.timeLabel = QLabel(self)
        self.timeLabel.setText("00:00 / 00:00")

        self.volumeslilder = QSlider(Qt.Horizontal, self)  #音量
        self.volumeslilder.setMaximumHeight(4)
        self.volumeslilder.setMinimumWidth(50)
        self.volumeslilder.setRange(0, 100)
        self.volumeslilder.setValue(25)
        # self.volumeslilder.setOrientation(Qt.Horizontal)
        self.volumeslilder.valueChanged.connect(self.volume)  #滑块值变化信号
        # self.connect(self.volumeslilder, QtCore.SIGNAL('valueChanged(int)'),self.volume)

        self.sound = QLabel(self)
        # self.sound.setFixedWidth(20)
        # self.sound.setFixedHeight(20)
        self.sound.setFixedSize(20, 20)
        self.sound.setPixmap(QPixmap("F:\\untitled\\volume.png"))  #在label上显示图片
        self.sound.setScaledContents(True)  #让图片自适应label大小

        self.soundlayout = QHBoxLayout()
        self.soundlayout.addWidget(self.sound)
        self.soundlayout.addWidget(self.volumeslilder)
        self.soundlayout.addStretch()
        slqW = QWidget()
        slqW.setLayout(self.soundlayout)

        self.timelayout = QVBoxLayout()
        self.timelayout.addWidget(self.slider)
        self.timelayout.addWidget(self.timeLabel)
        self.layout = QHBoxLayout()
        self.layout.addWidget(self.stopbtn)
        self.layout.addWidget(self.playbtn)
        self.layout.addWidget(self.deletebtn)
        self.layout.addWidget(self.addbtn)
        self.la = QHBoxLayout()
        self.la.addWidget(self.previousbtn)
        self.la.addWidget(self.modebtn)
        self.la.addWidget(self.nextbtn)
        qW = QWidget()
        qW.setLayout(self.layout)
        qW2 = QWidget()
        qW2.setLayout(self.la)
        qW3 = QWidget()
        qW3.setLayout(self.timelayout)

        self.layout2 = QVBoxLayout()
        self.layout2.addWidget(self.list)
        self.layout2.addWidget(qW3)
        self.layout2.addWidget(slqW)
        self.layout2.addWidget(qW)
        self.layout2.addWidget(qW2)
        self.setLayout(self.layout2)

        self.player = QMediaPlayer()  # 创建播放媒体
        self.player.setVolume(10)
        self.playlist = QMediaPlaylist()  # 创建播放列表
        self.player.setPlaylist(self.playlist)

        self.timer = QTimer(self)
        self.timer.setInterval(400)
        self.timer.timeout.connect(self.update)

        self.slider.sliderMoved.connect(self.timedate)
        self.slider.sliderReleased.connect(self.SliderMoved)

    def timedate(self):

        pass

    def add(self):
        FileName, FileType = QFileDialog.getOpenFileName(
            self, "添加音乐", "F:\\M",
            "All Files (*);;Mp3 Files (*.mp3);; Wma Files (*.wma);;M4a Files (*.m4a)"
        )
        if FileName:
            search = re.compile(r".*/(.*)")
            SongName = search.search(FileName)
            self.list.addItem(SongName.group(1))
            self.player.playlist().addMedia(
                QMediaContent(QUrl.fromLocalFile(FileName)))  #添加到播放列表
            # self.player.setPlaylist(self.playlist)

        else:
            pass
        # self.playlist.setPlaybackMode(QMediaPlaylist.Sequential)

    def play(self):
        if self.list.currentRow() == -1:
            pass
        else:
            # print(self.list.currentRow())
            self.player.playlist().setPlaybackMode(QMediaPlaylist.Loop)
            self.player.playlist().setCurrentIndex(self.list.currentRow())
            # self.player.positionChanged()
            self.player.play()
            self.timer.start()

    def stop(self):
        if self.player.playlist().currentIndex() == -1:
            pass
        else:
            print(self.player.playlist().currentIndex())
            if self.stopbtn.text() == "暂停":
                self.player.pause()
                self.timer.stop()
                self.stopbtn.setText("继续")
            else:
                self.player.play()
                self.timer.start()
                self.stopbtn.setText("暂停")

    def nextsong(self):  #下一首
        if self.list.currentRow() != -1:
            self.player.playlist().next()

    def previous(self):  #上一首
        print(self.list.currentRow())
        if self.list.currentRow() != -1:
            self.player.playlist().previous()

    def Playback_mode(self):
        if self.modebtn.text() == "列表循环":
            self.player.playlist().setPlaybackMode(
                QMediaPlaylist.CurrentItemInLoop)  # 单曲循环
            self.modebtn.setText("单曲循环")
        else:
            self.player.playlist().setPlaybackMode(QMediaPlaylist.Loop)  #列表循环
            self.modebtn.setText("列表循环")

    def delete(self):
        self.player.playlist().removeMedia(
            self.player.playlist().currentIndex())
        self.list.takeItem(self.list.currentRow())

    def volume(self):  #改变音量

        self.player.setVolume(self.volumeslilder.value() * 2)

    def SliderMoved(self):  #滑动滑块

        self.player.setPosition(self.slider.value())
        self.slider.setSliderPosition(self.player.position())
        self.timer.start()

    def update(self):
        self.slider.setMaximum(self.player.duration())
        self.timeLabel.setText(
            str(
                strftime("%M:%S", localtime(self.player.position() / 1000.0)) +
                " / " + str(
                    strftime("%M:%S", localtime(self.player.duration() /
                                                1000.0))))
        )  #将毫秒转换为分秒(时间戳为秒,需要除以1000.0)
        self.slider.setSliderPosition(self.player.position())
class AudioPlayer(QObject):

    songPositionChanged = pyqtSignal(int)
    songDurationChanged = pyqtSignal(int)
    stateChanged = pyqtSignal(int)
    playlistChanged = pyqtSignal(QMediaPlaylist, int)

    currentSongChanged = pyqtSignal(str, str, bytes)
    currentSelectionChanged = pyqtSignal(UUID, int)

    customPlaylistCreated = pyqtSignal(UUID, str)
    libraryPlaylistCreated = pyqtSignal(UUID)

    addedToLibraryPlaylist = pyqtSignal(UUID, list)
    addedToCustomPlaylist = pyqtSignal(UUID, list)

    updatedLibraryPlaylist = pyqtSignal(UUID, list)

    playlistRemoved = pyqtSignal(UUID)

    def __init__(self, volumeLevel=40, playbackMode=QMediaPlaylist.Sequential,
                 parent=None):
        super(AudioPlayer, self).__init__(parent)

        self.__player = QMediaPlayer()
        self.__player.setVolume(volumeLevel)

        self.__player.currentMediaChanged.connect(self._onMediaChanged)
        self.__player.stateChanged.connect(
            lambda state: self.stateChanged.emit(int(state)))
        self.__player.positionChanged.connect(
            lambda x: self.songPositionChanged.emit(x))
        self.__player.durationChanged.connect(
            lambda x: self.songDurationChanged.emit(x))

        self.__playlistManager = PlaylistManger()

        self.__playlistManager.customPlaylistCreated.connect(
            lambda uuid, name: self.customPlaylistCreated.emit(uuid, name))
        self.__playlistManager.libraryPlaylistCreated.connect(
            lambda p: self.libraryPlaylistCreated.emit(p))
        
        self.__playlistManager.currentPlaylistChanged.connect(
            self._onChangedPlaylist)
        self.__playlistManager.currentPlaylistChanged.connect(
            lambda p, i: self.playlistChanged.emit(p, i))

        self.__playlistManager.playlistRemoved.connect(
            lambda uuid: self.playlistRemoved.emit(uuid))

        self.__playlistManager.addedToLibraryPlaylist.connect(
            lambda uuid, l: self.addedToLibraryPlaylist.emit(uuid, l))
        self.__playlistManager.addedToCustomPlaylist.connect(
            lambda uuid, l: self.addedToCustomPlaylist.emit(uuid, l))

        self.__playlistManager.updatedLibraryPlaylist.connect(
            lambda uuid, l: self.updatedLibraryPlaylist.emit(uuid, l))

    def createCustomPlaylist(self, name=None, urls=None):
        self.__playlistManager.createCustomPlaylist(name, urls)

    def createLibraryPlaylist(self, urls=None):
        self.__playlistManager.createLibraryPlaylist(urls)

    def addToLibraryPlaylist(self, url=None):
        self.__playlistManager.addToLibraryPlaylist(url)

    def updateLibraryPlaylist(self, url=None):
        self.__playlistManager.updateLibraryPlaylist(url)

    def renamePlaylist(self, uuid, newName):
        self.__playlistManager.renamePlaylist(uuid, newName)

    def addSongsToCustomPlaylist(self, uuid, urls=[]):
        self.__playlistManager.addSongsToCustomPlaylist(uuid, urls)

    def removeSong(self, uuid, row):
        self.__playlistManager.removeSong(uuid, row)

    def setPlaylist(self, uuid, index=0):
        if (self.__player.playlist() and
                self.__playlistManager.isCurrentPlaylist(uuid)):
            if index == self.__player.playlist().currentIndex():
                if self.__player.state() == QMediaPlayer.PlayingState:
                    self.__player.pause()
                else:
                    self.__player.play()
            else:
                self.__player.playlist().setCurrentIndex(index)
        else:
            self.__playlistManager.setPlaylist(uuid, index)

    def hasLibraryPlaylist(self):
        return self.__playlistManager.hasLibraryPlaylist()

    def removePlaylist(self, uuid):
        self.__playlistManager.removePlaylist(uuid)

    def getCurrentPlaylist(self):
        self.__playlistManager.getCurrentPlaylist()

    def getCurrentQMediaPlaylist(self):
        self.__player.playlist()

    def isPlayerAvailable(self):
        return self.__player.isAvailable()

    def getDuration(self):
        return self.__player.duration()

    def getPlayer(self):
        return self.__player

    def getState(self):
        return self.__player.state()

    def play(self):
        if self.__player.playlist():
            self.__player.play()

    def pause(self):
        if self.__player.playlist():
            self.__player.pause()

    def stop(self):
        if self.__player.playlist():
            self.__player.stop()

    def previousEnhanced(self, sameSongMillis):
        if self.__player.position() <= sameSongMillis:
            self.previous()
        else:
            self.__player.setPosition(0)

    def previous(self):
        if self.__player.playlist():
            self.__player.playlist().previous()

    def next(self):
        if self.__player.playlist():
            self.__player.playlist().next()

    def setVolume(self, value):
        self.__player.setVolume(value)

    def setPosition(self, milliseconds):
        self.__player.setPosition(milliseconds)

    def playlistCurrentIndex(self):
        if self.__player.playlist():
            return self.__player.playlist().currentIndex()

    def setCurrentPlaylistIndex(self, index):
        if self.__player.playlist():
            self.__player.playlist().setCurrentIndex(index)

    def _onChangedPlaylist(self, playlist, index, playIt=False):
        self.__player.setPlaylist(playlist)
        if playlist:
            playlist.setCurrentIndex(index)
        if playIt:
            self.play()

    def _onMediaChanged(self, media):
        if media.isNull() and self.__player.playlist():
            self.__player.playlist().setCurrentIndex(0)
            media = self.__player.playlist().media(0)
        if media.isNull():
            return

        title, artist, cover = self.__playlistManager.getBasicSongInfo(media)

        self.currentSongChanged.emit(title, artist, cover)

        uuid = self.__playlistManager.getCurrentPlaylistUuid()
        index = self.__playlistManager.getCurrentSongIndex()
        self.currentSelectionChanged.emit(uuid, index)

    # def saveSettings(self):
    #     # settings = QSettings(QSettings.IniFormat, QSettings.UserScope,
    #     #                      QCoreApplication.organizationName(),
    #     #                      QCoreApplication.applicationName())

    #     # settings.beginGroup("music_player")

    #     # # if self.__playlistManager.getLibraryPlaylist():
    #     # #     libraryDirectories = self.__playlistManager.getLibraryPlaylist().getDirectories()
    #     # #     settings.beginWriteArray('library_playlist',
    #     # #                              len(libraryDirectories))
    #     # #     for index, value in enumerate(libraryDirectories):
    #     # #         settings.setArrayIndex(index)
    #     # #         settings.setValue("url", value)
    #     # #     settings.endArray()

    #     # customPlaylists = self.__playlistManager.getCustomPlaylists()
    #     # settings.beginWriteArray('custom_playlists',
    #     #                          len(customPlaylists))
    #     # for index, value in enumerate(customPlaylists):
    #     #     settings.setArrayIndex(index)
    #     #     playlistName = settings.value('name', value.getName())
    #     #     playlistUrls = value.getAddedSongUrls()
    #     #     settings.beginWriteArray(playlistName,
    #     #                              len(playlistUrls))
    #     #     for i, v in enumerate(playlistUrls):
    #     #         settings.setArrayIndex(i)
    #     #         settings.setValue("url", v)
    #     #     settings.endArray()
    #     # settings.endArray()

    #     # settings.endGroup()
    #     # if self.__playlistManager.getLibraryPlaylist():
    #     #     libraryDirectories = self.__playlistManager.getLibraryPlaylist().getDirectories()
    #     #     settings.beginWriteArray('library_playlist',
    #     #                              len(libraryDirectories))
    #     #     for index, value in enumerate(libraryDirectories):
    #     #         settings.setArrayIndex(index)
    #     #         settings.setValue("url", value)
    #     #     settings.endArray()

    #     customPlaylists = self.__playlistManager.getCustomPlaylists()
    #     for playlist in customPlaylists:
    #         playlistName = playlist.getName()
    #         for url in playlist:
    #             pass

    # def restoreSettings(self):
    #     settings = QSettings(QSettings.IniFormat, QSettings.UserScope,
    #                          QCoreApplication.organizationName(),
    #                          QCoreApplication.applicationName())

    #     settings.beginGroup("music_player")

    #     # size = settings.beginReadArray('library_playlist')
    #     # libraryDirectories = []
    #     # for i in range(size):
    #     #     settings.setArrayIndex(i)
    #     #     libraryDirectories.append(settings.value("url"))
    #     # settings.endArray()

    #     customPlaylists = {}
    #     size = settings.beginReadArray('custom_playlists')
    #     for i in range(size):
    #         urls = []
    #         settings.setArrayIndex(i)
    #         playlistName = settings.value('name')
    #         print(playlistName)
    #         size2 = settings.beginReadArray(playlistName)
    #         for j in range(size2):
    #             settings.setArrayIndex(j)
    #             url = settings.value("url")
    #             urls.append(url)
    #         settings.endArray()
    #         customPlaylists[playlistName] = urls
    #     settings.endArray()

    #     settings.endGroup()

    #     print('-------')
    #     print(customPlaylists)





        # settings = QSettings(QCoreApplication.organizationName(),
        #                      QCoreApplication.applicationName())
        # settings.beginGroup("music_player")

        # size = settings.beginReadArray('library_playlist')
        # if not size == 0:
        #     for i in range(0, size):
        #         settings.setArrayIndex(i)
        #         url = settings.value("url")
        # settings.endArray()

        # if url:
        #     from audio.playlist_models import DirectoryPlaylist

        #     playlist = DirectoryPlaylist()
        #     playlist.add_directory(url)
        #     self.addAndSetPlaylist(playlist, 2)

        # settings.endGroup()
        pass
Beispiel #10
0
class DBPlayer(QWidget):
    # signal
    signaltxt = pyqtSignal(str)
    signalnum = pyqtSignal(int)

    def __init__(self):
        super(DBPlayer, self).__init__()
        self.setMaximumSize(16777215, 35)
        # Init Player
        self.messtitle = TITL_PROG
        self.namemedia = ''
        self.albumname = ''
        self.currentPlaylist = QMediaPlaylist()
        self.player = QMediaPlayer()
        self.player.stateChanged.connect(self.qmp_stateChanged)
        self.player.positionChanged.connect(self.qmp_positionChanged)
        self.player.volumeChanged.connect(self.qmp_volumeChanged)
        self.player.durationChanged.connect(self.qmp_durationChanged)
        self.player.setVolume(60)
        # Init GUI
        self.setLayout(self.addControls())
        self.infoBox = None

    def addControls(self):
        # buttons
        self.playBtn = QPushButton()
        self.playBtn.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
        self.playBtn.setStyleSheet('border: 0px;')
        stopBtn = QPushButton()
        stopBtn.setIcon(self.style().standardIcon(QStyle.SP_MediaStop))
        stopBtn.setStyleSheet('border: 0px;')
        prevBtn = QPushButton()
        prevBtn.setIcon(self.style().standardIcon(QStyle.SP_MediaSkipBackward))
        prevBtn.setStyleSheet('border: 0px;')
        nextBtn = QPushButton()
        nextBtn.setIcon(self.style().standardIcon(QStyle.SP_MediaSkipForward))
        nextBtn.setStyleSheet('border: 0px;')
        volumeDescBtn = QPushButton('▼')
        volumeDescBtn.setIcon(self.style().standardIcon(QStyle.SP_MediaVolume))
        volumeDescBtn.setMaximumWidth(30)
        volumeDescBtn.setStyleSheet('border: 0px;')
        volumeIncBtn = QPushButton('▲')
        volumeIncBtn.setIcon(self.style().standardIcon(QStyle.SP_MediaVolume))
        volumeIncBtn.setMaximumWidth(40)
        volumeIncBtn.setStyleSheet('border: 0px;')
        infoBtn = QPushButton()
        infoBtn.setIcon(self.style().standardIcon(
            QStyle.SP_FileDialogContentsView))
        infoBtn.setStyleSheet('border: 0px;')

        # seek slider
        self.seekSlider = QSlider(Qt.Horizontal, self)
        self.seekSlider.setMinimum(0)
        self.seekSlider.setMaximum(100)
        self.seekSlider.setTracking(False)

        # labels position start/end
        self.seekSliderLabel1 = QLabel('0:00')
        self.seekSliderLabel2 = QLabel('0:00')

        # layout
        controlArea = QHBoxLayout()
        controlArea.addWidget(prevBtn)
        controlArea.addWidget(self.playBtn)
        controlArea.addWidget(stopBtn)
        controlArea.addWidget(nextBtn)
        controlArea.addWidget(self.seekSliderLabel1)
        controlArea.addWidget(self.seekSlider)
        controlArea.addWidget(self.seekSliderLabel2)
        controlArea.addWidget(infoBtn)
        controlArea.addWidget(volumeDescBtn)
        controlArea.addWidget(volumeIncBtn)

        # link buttons to media
        self.seekSlider.sliderMoved.connect(self.seekPosition)
        self.playBtn.clicked.connect(self.playHandler)
        stopBtn.clicked.connect(self.stopHandler)
        volumeDescBtn.clicked.connect(self.decreaseVolume)
        volumeIncBtn.clicked.connect(self.increaseVolume)
        prevBtn.clicked.connect(self.prevItemPlaylist)
        nextBtn.clicked.connect(self.nextItemPlaylist)
        infoBtn.clicked.connect(self.displaySongInfo)

        return controlArea

    def playHandler(self):
        if self.player.state() == QMediaPlayer.PlayingState:
            self.player.pause()
            message = (' [Paused at position %s]' %
                       self.seekSliderLabel1.text())
            self.messtitle = self.namemedia + message
            self.signaltxt.emit(self.messtitle)
        else:
            if self.player.state() == QMediaPlayer.StoppedState:
                if self.player.mediaStatus() == QMediaPlayer.NoMedia:
                    if self.currentPlaylist.mediaCount() != 0:
                        self.player.setPlaylist(self.currentPlaylist)
                elif self.player.mediaStatus() == QMediaPlayer.LoadedMedia:
                    self.player.play()
                elif self.player.mediaStatus() == QMediaPlayer.BufferedMedia:
                    self.player.play()
            elif self.player.state() == QMediaPlayer.PlayingState:
                pass
            elif self.player.state() == QMediaPlayer.PausedState:
                self.player.play()
            if self.player.volume() is not None and self.player.state(
            ) == QMediaPlayer.PlayingState:
                message = ' [Volume %d]' % self.player.volume()
                self.messtitle = self.namemedia + message
                self.signaltxt.emit(self.messtitle)

    def stopHandler(self):
        if self.player.state() == QMediaPlayer.PlayingState:
            self.stopState = True
            self.player.stop()
        elif self.player.state() == QMediaPlayer.PausedState:
            self.player.stop()
        elif self.player.state() == QMediaPlayer.StoppedState:
            pass
        if self.player.volume() is not None and self.player.state(
        ) == QMediaPlayer.PlayingState:
            self.messtitle = self.namemedia + (' [Stopped]')
            self.signaltxt.emit(self.messtitle)

    def qmp_stateChanged(self):
        if self.player.state() == QMediaPlayer.StoppedState:
            self.player.stop()
        # buttons icon play/pause change
        if self.player.state() == QMediaPlayer.PlayingState:
            self.playBtn.setIcon(self.style().standardIcon(
                QStyle.SP_MediaPause))
        else:
            self.playBtn.setIcon(self.style().standardIcon(
                QStyle.SP_MediaPlay))

    def qmp_positionChanged(self, position):
        # update position slider
        self.seekSlider.setValue(position)
        # update the text label
        self.seekSliderLabel1.setText(
            '%d:%02d' % (int(position / 60000), int((position / 1000) % 60)))

    def seekPosition(self, position):
        sender = self.sender()
        if isinstance(sender, QSlider):
            if self.player.isSeekable():
                self.player.setPosition(position)

    def qmp_volumeChanged(self):
        if self.player.volume() is not None:
            message = (' [Playing at Volume %d]' % (self.player.volume()))
            if self.namemedia != '':
                self.messtitle = self.namemedia + message
            else:
                self.messtitle = "Initialisation player " + message
            self.signaltxt.emit(self.messtitle)

    def qmp_durationChanged(self, duration):
        self.seekSlider.setRange(0, duration)
        self.seekSliderLabel2.setText(
            '%d:%02d' % (int(duration / 60000), int((duration / 1000) % 60)))
        nummedia = self.currentPlaylist.mediaCount()
        curmedia = self.currentPlaylist.currentIndex()
        #artist = self.player.metaData(QMediaMetaData.Author)
        #tittle = self.player.metaData(QMediaMetaData.Title)
        self.namemedia = path.basename(self.homMed[curmedia])
        self.namemedia = '[%02d/%02d' % (
            curmedia + 1, nummedia) + '] "' + self.namemedia + '"'
        self.buildPlaylist()
        message = (' [Playing at Volume %d]' % (self.player.volume()))
        if self.player.volume() is not None and self.player.state(
        ) == QMediaPlayer.PlayingState:
            self.messtitle = self.namemedia + message
            self.signaltxt.emit(self.messtitle)

    def buildPlaylist(self):
        """Build play list."""
        nummedia = self.currentPlaylist.mediaCount()
        curmedia = self.currentPlaylist.currentIndex() + 1
        compteur = 1
        self.textplaylist = '<b>' + self.albumname + '</b>'
        self.textplaylist += '<table class="tftable" border="0">'
        for namemedia in self.homMed:
            media = path.basename(namemedia)
            media = '[%02d/%02d' % (compteur, nummedia) + '] "' + media + '"'
            if curmedia == compteur:
                self.textplaylist += '<tr><td><b>' + media + '</b></td></tr>'
            else:
                self.textplaylist += '<tr><td>' + media + '</td></tr>'
            compteur += 1
        self.textplaylist = self.textplaylist + '</table>'
        self.playBtn.setToolTip(self.textplaylist)
        self.signalnum.emit(curmedia - 1)

    def increaseVolume(self):
        """Volume +."""
        vol = self.player.volume()
        vol = min(vol + 5, 100)
        self.player.setVolume(vol)

    def decreaseVolume(self):
        """Volume -."""
        vol = self.player.volume()
        vol = max(vol - 5, 0)
        self.player.setVolume(vol)

    def prevItemPlaylist(self):
        self.player.playlist().previous()
        if self.currentPlaylist.currentIndex() == -1:
            self.player.playlist().previous()

    def nextItemPlaylist(self):
        self.player.playlist().next()
        if self.currentPlaylist.currentIndex() == -1:
            self.player.playlist().next()

    def addMediaslist(self, listmedias, position, albumname):
        if self.currentPlaylist.mediaCount() > 0:
            self.currentPlaylist.removeMedia(0,
                                             self.currentPlaylist.mediaCount())
            self.player.stop()
            self.stopHandler()
        self.currentPlaylist.removeMedia(0, self.currentPlaylist.mediaCount())
        self.albumname = albumname
        if listmedias:
            self.homMed = listmedias
            for media in self.homMed:
                self.currentPlaylist.addMedia(
                    QMediaContent(QUrl.fromLocalFile(media)))
            self.currentPlaylist.setCurrentIndex(position)
            self.playHandler()

    def displaySongInfo(self):
        # extract datas
        metaDataKeyList = self.player.availableMetaData()
        fullText = '<table class="tftable" border="0">'
        for key in metaDataKeyList:
            value = str(self.player.metaData(key)).replace("'", "").replace(
                "[", "").replace("]", "")
            if key == 'Duration':
                value = '%d:%02d' % (int(
                    int(value) / 60000), int((int(value) / 1000) % 60))
            fullText = fullText + '<tr><td>' + key + '</td><td>' + value + '</td></tr>'
        fullText = fullText + '</table>'
        # re-init
        if self.infoBox is not None:
            self.infoBox.destroy()
        # infos box
        self.infoBox = QMessageBox(self)
        self.infoBox.setWindowTitle('Detailed Song Information')
        self.infoBox.setTextFormat(Qt.RichText)
        self.infoBox.addButton('OK', QMessageBox.AcceptRole)
        self.infoBox.setText(fullText)
        self.infoBox.show()
class MyWindow(QMainWindow):
    text_update = pyqtSignal(str)

    # Create main window
    def __init__(self, parent=None):
        QMainWindow.__init__(self, parent)

        self.central = QWidget(self)

        self.player = QMediaPlayer()
        self.playlist = QMediaPlaylist()
        self.inference = Inference()
        self.folder_chosen = False
        self.textbox = QTextEdit(self.central)
        self.textbox.setFont(TEXT_FONT)
        self.textbox.setMinimumSize(300, 100)
        self.text_update.connect(self.append_text)
        sys.stdout = self
        print("Camera number %u" % camera_num)
        print("Image size %u x %u" % IMG_SIZE)
        if DISP_SCALE > 1:
            print("Display scale %u:1" % DISP_SCALE)

        self.vlayout = QVBoxLayout()        # Window layout
        self.displays = QHBoxLayout()
        self.disp = ImageWidget(self)
        self.displays.addWidget(self.disp)
        self.vlayout.addLayout(self.displays)
        self.label = QLabel(self)
        self.vlayout.addWidget(self.label)
        self.vlayout.addWidget(self.textbox)

        # TODO provision for allowing song to play
        # DONE
        self.current_song_start_time = datetime.now()

        volumeslider = QSlider(Qt.Horizontal, self)
        volumeslider.setFocusPolicy(Qt.NoFocus)
        volumeslider.valueChanged[int].connect(self.changeVolume)
        volumeslider.setValue(100)

        playBtn = QPushButton('Play')  # play button
        pauseBtn = QPushButton('Pause')  # pause button
        stopBtn = QPushButton('Stop')  # stop button

        # Add playlist controls
        prevBtn = QPushButton('Prev')
        shuffleBtn = QPushButton('Shuffle')
        nextBtn = QPushButton('Next')

        # Add button layouts
        #controlArea = QVBoxLayout()  # centralWidget
        controls = QHBoxLayout()
        playlistCtrlLayout = QHBoxLayout()

        # Add buttons to song controls layout
        controls.addWidget(playBtn)
        controls.addWidget(pauseBtn)
        controls.addWidget(stopBtn)

        # Add buttons to playlist controls layout
        playlistCtrlLayout.addWidget(prevBtn)
        playlistCtrlLayout.addWidget(shuffleBtn)
        playlistCtrlLayout.addWidget(nextBtn)

        # Add to vertical layout
        self.vlayout.addWidget(volumeslider)
        self.vlayout.addLayout(controls)
        self.vlayout.addLayout(playlistCtrlLayout)

        self.central.setLayout(self.vlayout)

        #self.central.setLayout(controlArea)

        self.setCentralWidget(self.central)

        # Connect each signal to their appropriate function
        playBtn.clicked.connect(self.playhandler)
        pauseBtn.clicked.connect(self.pausehandler)
        stopBtn.clicked.connect(self.stophandler)

        prevBtn.clicked.connect(self.prevSong)
        shuffleBtn.clicked.connect(self.shufflelist)
        nextBtn.clicked.connect(self.nextSong)

        self.statusBar()
        self.playlist.currentMediaChanged.connect(self.songChanged)

        self.mainMenu = self.menuBar()      # Menu bar
        exitAction = QAction('&Exit', self)
        exitAction.setShortcut('Ctrl+Q')
        exitAction.triggered.connect(self.close)
        self.fileMenu = self.mainMenu.addMenu('&File')

        fileAct = QAction('Open File', self)
        folderAct = QAction('Open Folder', self)

        fileAct.setShortcut('Ctrl+O')
        folderAct.setShortcut('Ctrl+D')

        self.fileMenu.addAction(fileAct)
        self.fileMenu.addAction(folderAct)

        fileAct.triggered.connect(self.openFile)
        folderAct.triggered.connect(self.addFiles)

        self.fileMenu.addAction(exitAction)


        #self.addControls()

    # Start image capture & display
    def start(self):
        self.timer = QTimer(self)           # Timer to trigger display
        self.timer.timeout.connect(lambda:
                    self.show_image(image_queue, self.disp, DISP_SCALE))
        self.timer.start(DISP_MSEC)
        self.capture_thread = threading.Thread(target=grab_images,
                    args=(camera_num, image_queue))
        self.capture_thread.start()         # Thread to grab images

    # Fetch camera image from queue, and display it
    def show_image(self, imageq, display, scale):
        if not imageq.empty():
            image = imageq.get()
            if image is not None and len(image) > 0:
                img = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

                self.display_image(img, display, scale)

    # Display an image, reduce size if required
    def display_image(self, img, display, scale=1):
        disp_size = img.shape[1]//scale, img.shape[0]//scale
        disp_bpl = disp_size[0] * 3
        if scale > 1:
            img = cv2.resize(img, disp_size,
                             interpolation=cv2.INTER_CUBIC)

            global PREDICTION_STATUS
            if PREDICTION_STATUS != -1:
                # print(PREDICTION_STATUS)
                self.handle_inference(PREDICTION_STATUS)
            # img_try = cv2.imread('test_image.jpg')
            # img_try = cv2.cvtColor(img , cv2.COLOR_BGR2RGB)
            # self.inference.perform_inference(img)
            # if self.inference.network.wait() == 0 :
            #     result = self.inference.network.extract_output()
            #     pred = np.argmax(result[0, :])
            #     print(pred)
            #     self.handle_inference(  pred  )

        qimg = QImage(img.data, disp_size[0], disp_size[1],
                      disp_bpl, IMG_FORMAT)
        display.setImage(qimg)

    # Handle sys.stdout.write: update text display
    def write(self, text):
        self.text_update.emit(str(text))
    def flush(self):
        pass

    def check_song_is_playing(self):
        if  (datetime.now()  - self.current_song_start_time ).seconds >= 4:
            return False
        else:
            return True
    def handle_inference(self, result):
        if self.folder_chosen == True  and self.check_song_is_playing() == False:
            global PREDICTION_STATUS
            if result == 1:
                #self.pausehandler()

                PREDICTION_STATUS = -1
                pass
            elif result == 5:
                self.playhandler()
            elif result == 0:
                #self.stophandler()
                PREDICTION_STATUS = -1
                pass
            elif result == 4:
                PREDICTION_STATUS = -1
            elif result == 2:
                self.prevSong()
            elif result == 3:
                self.nextSong()

    # Append to text display
    def append_text(self, text):
        cur = self.textbox.textCursor()     # Move cursor to end of text
        cur.movePosition(QTextCursor.End)
        s = str(text)
        while s:
            head,sep,s = s.partition("\n")  # Split line at LF
            cur.insertText(head)            # Insert text at cursor
            if sep:                         # New line if LF
                cur.insertBlock()
        self.textbox.setTextCursor(cur)     # Update visible cursor

    # Window is closing: stop video capture
    def closeEvent(self, event):
        global capturing
        capturing = False
        self.capture_thread.join()

    def openFile(self):
        song = QFileDialog.getOpenFileName(self, "Open Song", "~", "Sound Files (*.mp3 *.ogg *.wav *.m4a)")
        if song[0] != '':
            url = QUrl.fromLocalFile(song[0])
            if self.playlist.mediaCount() == 0:
                self.playlist.addMedia(QMediaContent(url))
                self.player.setPlaylist(self.playlist)
                self.player.play()

            else:
                self.playlist.addMedia(QMediaContent(url))


    def addFiles(self):
        if self.playlist.mediaCount() != 0:
            self.folderIterator()
        else:
            self.folderIterator()
            self.player.setPlaylist(self.playlist)
            self.player.playlist().setCurrentIndex(0)
            self.player.play()

    def folderIterator(self):
        folderChosen = QFileDialog.getExistingDirectory(self, 'Open Music Folder', '~')
        if folderChosen != None:
            it = QDirIterator(folderChosen)
            it.next()
            while it.hasNext():
                if it.fileInfo().isDir() == False and it.filePath() != '.':
                    fInfo = it.fileInfo()
                    if fInfo.suffix() in ('mp3', 'ogg', 'wav', 'm4a'):
                        self.playlist.addMedia(QMediaContent(QUrl.fromLocalFile(it.filePath())))
                        self.folder_chosen = True
                it.next()
            self.playlist.setPlaybackMode(QMediaPlaylist.Loop)

            if it.fileInfo().isDir() == False and it.filePath() != '.':
                fInfo = it.fileInfo()
                if fInfo.suffix() in ('mp3', 'ogg', 'wav', 'm4a'):
                    self.playlist.addMedia(QMediaContent(QUrl.fromLocalFile(it.filePath())))
                    self.folder_chosen = True



    def playhandler(self):

        if self.playlist.mediaCount() == 0:
            self.folder_chosen = False
            self.addFiles()

        elif self.playlist.mediaCount() != 0:
            self.player.play()
            self.current_song_start_time = datetime.now()
        global PREDICTION_STATUS
        PREDICTION_STATUS = -1




    def pausehandler(self):
        print('Stopped and cleared playlist')
        self.player.pause()
        global PREDICTION_STATUS
        PREDICTION_STATUS = -1

    def stophandler(self):
        self.folder_chosen = False
        self.player.stop()
        self.playlist.clear()
        print('Stopped and cleared playlist')
        self.statusBar().showMessage("Stopped and cleared playlist")
        global PREDICTION_STATUS
        PREDICTION_STATUS = -1

    def changeVolume(self, value):
        self.player.setVolume(value)

    def prevSong(self):
        print('playing previous song')
        if self.playlist.mediaCount() == 0:
            self.folder_chosen = False
            self.addFiles()
        elif self.playlist.mediaCount() != 0:
            self.player.playlist().previous()
            self.current_song_start_time = datetime.now()
        global PREDICTION_STATUS
        PREDICTION_STATUS = -1

    def shufflelist(self):
        self.playlist.shuffle()


    def nextSong(self):
        print('playing next song')
        if self.playlist.mediaCount() == 0:
            self.folder_chosen = False
            self.addFiles()

        elif self.playlist.mediaCount() != 0:
            self.player.playlist().next()
            self.current_song_start_time = datetime.now()
        global PREDICTION_STATUS
        PREDICTION_STATUS = -1

    def songChanged(self, media):
        if not media.isNull():
            url = media.canonicalUrl()
            print('Now playing  ' +url.fileName())
            self.statusBar().showMessage(url.fileName())
class Music_App(QMainWindow):
    def __init__(self):
        super().__init__()
        self.title = 'Music Player'
        self.left = 20
        self.top = 30
        self.width = 600
        self.height = 400
        self.root_Gui()
        self.song_path = ""
        self.q_path = ""
        #initializing playlist and player

        self.Playlist = QMediaPlaylist()
        self.Player = QMediaPlayer()

        self.button_stat = -1
        #self.sp_st_cam= -1

    def root_Gui(self):
        #base of GUI

        self.setWindowTitle(self.title)
        self.setGeometry(self.left, self.top, self.width, self.height)
        self.menu()
        self.main_buttons()
        self.status_bar()
        self.show()

    def menu(self):
        #menu of GUI

        main_menu = self.menuBar()
        file_menu = main_menu.addMenu('File')
        tools_menu = main_menu.addMenu('Tools')
        help__menu = main_menu.addMenu('Help')
        exit_ = main_menu.addMenu('Exit')

        file_menu.addAction(self.open_file())
        file_menu.addAction(self.exit_button())
        exit_.addAction(self.exit_button())

    def main_buttons(self):
        #different button available in GUI

        play_button = QPushButton('Play', self)
        play_button.setToolTip("To play the song click it.")
        play_button.move(100, 80)
        play_button.clicked.connect(self.play_button)

        pause_button = QPushButton('Pause', self)
        pause_button.setToolTip("To pause the song click it.")
        pause_button.move(200, 80)
        pause_button.clicked.connect(self.pause_button)

        next_button = QPushButton('Next', self)
        next_button.setToolTip('Play Next Song')
        next_button.move(300, 80)
        next_button.clicked.connect(self.next_button)

        prev_button = QPushButton('Prev', self)
        prev_button.setToolTip('Play Previous Song')
        prev_button.move(400, 80)
        prev_button.clicked.connect(self.prev_button)

        plusV_button = QPushButton('+ Vol', self)
        plusV_button.setToolTip('Increase Volume')
        plusV_button.move(100, 110)
        plusV_button.clicked.connect(self.plusV_button)

        minsV_button = QPushButton('- Vol', self)
        minsV_button.setToolTip('Decrease Volume')
        minsV_button.move(200, 110)
        minsV_button.clicked.connect(self.minsV_button)

        stop_button = QPushButton('Stop', self)
        stop_button.setToolTip('Stop Song')
        stop_button.move(300, 110)
        stop_button.clicked.connect(self.stop_button)

        info_button = QPushButton('Song Details', self)
        info_button.setToolTip('Get Song Details')
        info_button.move(400, 110)
        info_button.clicked.connect(self.info_button)

    #play button handler
    def play_button(self):
        print("Playing Music")
        if self.Playlist.mediaCount() == 0:
            self.file_dialog()
        elif self.Playlist.mediaCount() != 0:
            self.button_stat = 1
            self.Player.play()

    #pause button handler
    def pause_button(self):
        print("Pause Music")
        self.button_stat = 2
        self.Player.pause()

    #prev button handler
    def prev_button(self):
        print("Next Song")
        if self.Playlist.mediaCount() == 0:
            self.file_dialog()
        elif self.Playlist.mediaCount != 0:
            self.Player.playlist().previous()

    #next button handler
    def next_button(self):
        print("Prev Song")
        if self.Playlist.mediaCount() == 0:
            self.file_dialog()
        elif self.Playlist.mediaCount() != 0:
            self.Player.playlist().next()

    #info button handler

    def info_button(self):
        print("\n  info button")
        song = eyed3.load(self.song_path)
        artist = song.tag.artist
        album = song.tag.album
        title = song.tag.title

        s_detail = 'Artist : ' + artist + '\n\tAlbum : ' + album + '\n\tTitle : ' + title

        song_det = QMessageBox(self)
        song_det.setWindowTitle('Song Details')
        song_det.setText(s_detail)
        song_det.show()

    #volume button handler
    def plusV_button(self):
        print("Plus Volume")
        vol_ = self.Player.volume()
        vol_ = min(100, vol_ + 5)
        self.Player.setVolume(vol_)

    def minsV_button(self):
        print("Minus Volume")
        vol_ = self.Player.volume()
        vol_ = max(100, vol_ - 5)
        self.Player.setVolume(vol_)

    #stop button handler
    def stop_button(self):
        print("Stopping Music")
        self.button_stat = 3
        self.Player.stop()
        self.Playlist.clear()
        self.statusBar().showMessage("Music Stopped")

    #open file dialog

    def open_file(self):
        fopen_button = QAction('Open File', self)
        #fopen_button.setShortcut('CTRL+O')
        fopen_button.setStatusTip('Open Music File')
        fopen_button.triggered.connect(self.file_dialog)
        return fopen_button

    #EXIT button handler

    def exit_button(self):
        exit_Button = QAction('Exit', self)
        #exit_Button.setShortcut('CTRL+Q')
        exit_Button.setStatusTip('Exit Application')
        exit_Button.triggered.connect(self.close_msg)
        return exit_Button

    def show_qoute(self, q_path):

        q_img = Image.open(q_path)
        q_img.show()

    def song_play(self, song_path):
        self.button_stat = 1
        self.Playlist.addMedia(
            QMediaContent(QUrl.fromLocalFile(self.song_path)))
        self.Player.setPlaylist(self.Playlist)
        self.Player.setVolume(50)
        self.Player.play()

    #file dialog handler
    def file_dialog(self):
        fName = QFileDialog.getOpenFileName(
            self, "Select A Song", "~", "All Files (*) ;;  Mp3 Files(*.mp3)")

        if fName[0] == '':
            print("No file Selected")

        elif self.Playlist.mediaCount() == 0:
            #print(QUrl(fName[0]))

            self.song_path = fName[0]
            self.button_stat = 1
            self.Playlist.addMedia(QMediaContent(QUrl.fromLocalFile(fName[0])))
            self.Player.setPlaylist(self.Playlist)
            self.Player.setVolume(50)
            self.Player.play()

        else:

            self.Playlist.addMedia(QMediaContent(QUrl(fName[0])))

    #close/exit handler
    def close_msg(self):
        msg = QMessageBox.question(self, 'Close Msg', 'Click Yes to Close',
                                   QMessageBox.Yes, QMessageBox.No)

        if msg == QMessageBox.Yes:
            self._obj.change_f(1)
            self.close()
            print('Closing App')
        else:
            print('Not Closing')

    #status  handler
    def status_bar(self):
        self.statusBar().showMessage('ViAna Music Player')
Beispiel #13
0
class VideoWindow(QMainWindow):
    def __init__(self, parent=None):
        super(VideoWindow, self).__init__(parent)
        self.setWindowTitle("PyQt Video Player Widget 2 Screens")
        self.indexScreen = 0

        self.playlist = QMediaPlaylist()
        self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
        self.mediaPlayer.setPlaylist(self.playlist)
        self.nombreVideoActual = ''

        videoWidget = QVideoWidget()

        # Create a widget for window contents
        wid = QWidget(self)
        self.setAutoFillBackground(True)
        p = self.palette()
        p.setColor(self.backgroundRole(), Qt.black)
        self.setPalette(p)
        self.setCentralWidget(wid)

        # Create layouts to place inside widget
        controlLayout = QHBoxLayout()
        controlLayout.setContentsMargins(0, 0, 0, 0)

        layout = QVBoxLayout()
        layout.addWidget(videoWidget)

        # Set widget to contain window contents
        wid.setLayout(layout)

        self.mediaPlayer.setVideoOutput(videoWidget)

        # 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)

    def setControles(self, controles):
        self.controles = controles

    def openFile(self, item=''):
        #fileName, _ = QFileDialog.getOpenFileName(self, "Open Movie",QDir.homePath())
        #QMessageBox.question(self, 'ITEM', item, QMessageBox.Ok)
        if item != '':
            self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile(item)))

    def setIndex(self, index=-1):
        print('setIndex(' + str(index) + ') in ' +
              str(self.mediaPlayer.playlist().mediaCount()))
        if index < 0:
            index = 0
        elif index >= self.count():
            index = self.count() - 1
        if self.count() != 0:
            self.mediaPlayer.playlist().setCurrentIndex(index)
        for x in range(0, self.mediaPlayer.playlist().mediaCount()):
            print(
                self.mediaPlayer.playlist().media(x).canonicalUrl().fileName())

    def addFile(self, filename=''):
        try:
            if filename != '':
                if "\n" in filename:
                    filename = filename.replace("\n", "")
                self.mediaPlayer.playlist().addMedia(
                    QMediaContent(QUrl.fromLocalFile(filename)))
                self.controles.reload()
        except Exception as err:
            QMessageBox.question(self, 'Error', "Formato no compatible.",
                                 QMessageBox.Ok)
            raise

    def addURL(self, urlname=''):
        try:
            if urlname != '':
                self.mediaPlayer.playlist().addMedia(
                    QMediaContent(QUrl(urlname)))
        except Exception as err:
            QMessageBox.question(self, 'Error',
                                 "No se pudo agregar el video " + urlname,
                                 QMessageBox.Ok)
            raise

    def removeFile(self, index=-1):
        if index == -1:
            QMessageBox.question(self, 'Error',
                                 "No se eligio un elemento para borrar.",
                                 QMessageBox.Ok)
        else:
            try:
                self.mediaPlayer.playlist().removeMedia(index)
            except Exception as err:
                print('Error al remover el archivo "' + str(index) +
                      '", total de elementos: ' +
                      str(self.mediaPlayer.playlist().mediaCount()))

    def play(self, index=-1):
        contador = self.count()
        if index != -1:
            self.mediaPlayer.playlist().setCurrentIndex(index)
        if self.mediaPlayer.playlist().currentIndex(
        ) == -1 or self.mediaPlayer.playlist().currentIndex() >= self.count():
            print("index del elemento a reproducir fuera del rango " +
                  str(index) + ", " + str(contador))
            return
        if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
            self.mediaPlayer.pause()
        else:
            self.mediaPlayer.play()

    def pause(self):
        if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
            self.mediaPlayer.pause()

    def stop(self):
        self.mediaPlayer.stop()

    def next(self):
        self.setIndex(self.mediaPlayer.playlist().currentIndex() + 1)

    def prev(self):
        self.setIndex(self.mediaPlayer.playlist().currentIndex() - 1)

    def getListNames(self):
        list = ""
        cont = self.count()
        for x in range(0, self.count()):
            try:
                media = self.mediaPlayer.playlist().media(x)
                name = os.path.splitext(
                    os.path.basename(media.canonicalUrl().fileName()))[0]
                #list.append(name)
                list += name + "||"
            except Exception as err:
                print(err)
        return list

    def getMediaName(self):
        try:
            media = self.mediaPlayer.playlist().currentMedia()
            name = os.path.splitext(
                os.path.basename(media.canonicalUrl().fileName()))[0]
            return str(name)
        except Exception as err:
            print(err)
        return ""

    def FullScreen(self):
        self.showFullScreen()

    def showNormalS(self):
        try:
            #self.monitor = QDesktopWidget().screenGeometry()
            #self.move(monitor.left(), monitor.top())
            self.showNormal()
            self.resize(700, 400)
            self.center()
        except Esception as err:
            print(err)

    def center(self):
        # geometry of the main window
        qr = self.frameGeometry()
        # center point of screen
        #cp = QDesktopWidget().availableGeometry().center()
        cp = QDesktopWidget().screenGeometry(self.indexScreen).center()
        # move rectangle's center point to screen's center point
        qr.moveCenter(cp)
        # top left of rectangle becomes top left of window centering it
        self.move(qr.topLeft())

    def count(self):
        return self.mediaPlayer.playlist().mediaCount()

    def sigPantalla(self):
        try:
            if self.indexScreen == QDesktopWidget().screenCount() - 1:
                self.indexScreen = 0
            else:
                self.indexScreen = self.indexScreen + 1
            monitor = QDesktopWidget().screenGeometry(self.indexScreen)
            self.move(monitor.x(), monitor.y())
            self.FullScreen()
            self.controles.showPlayerButton.setText(
                self.controles.strButtonHide)
        except Exception as err:
            print(str(err))

    def antPantalla(self):
        if self.indexScreen == 0:
            self.indexScreen = QDesktopWidget().screenCount() - 1
        else:
            self.indexScreen = self.indexScreen - 1
        monitor = QDesktopWidget().screenGeometry(self.indexScreen)
        self.setGeometry(monitor)
        self.FullScreen()
        self.controles.showPlayerButton.setText(self.controles.strButtonHide)

    def Visibility(self, state):
        if state:
            self.show()
        else:
            self.hide()
Beispiel #14
0
class MusicApp(QMainWindow):
    def __init__(self):
        super().__init__()
        self.player = QMediaPlayer()
        self.playlist = QMediaPlaylist()
        self.title = 'GestureTunes - player'
        self.left = 300
        self.top = 300
        self.width = 600
        self.height = 340
        self.volume_initial_value = 60
        self.model = QStandardItemModel(0, 1)
        self.song_list = QtWidgets.QTableView()
        self.play_btn = QPushButton('播放')
        self.media_controls = QHBoxLayout()
        # 共享变量
        self.image_to_show = None
        self.rec_res = {
            "set": False,
            "used": True,
            "direction": None,
            "fingers": 0
        }
        # 摄像头窗口
        self.widget = QWidget()
        self.widget.move(1000, 200)
        self.widget.resize(300, 200)
        self.widget.setWindowTitle("GestureTunes - gesture panel")  # 窗口标题
        self.videoFrame = QLabel('正在打开摄像头,请稍等...')
        video_area = QVBoxLayout()
        self.widget.setLayout(video_area)
        video_area.addWidget(self.videoFrame)
        self.widget.show()
        # self.widget.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint)
        # 定时器
        self.timer = QTimer()
        self.timer.setInterval(20)
        self.timer.start()
        self.timer.timeout.connect(self.show_image)
        self.have_song = False
        self.volume_slider = QSlider(Qt.Horizontal, self)
        self.volume_slider.setTracking(True)
        # 播放模式
        self.play_style = '列表循环'
        self.single_img = QIcon('pics/single.png')
        self.loop_img = QIcon('pics/loop.png')
        self.play_style_btn = QPushButton()
        self.play_style_btn.setIcon(self.loop_img)
        self.play_tip = ''

        self.playlist.setPlaybackMode(QMediaPlaylist.Loop)

        # 初始化界面
        self.init_ui()

    def init_ui(self):
        # Add file menu
        menubar = self.menuBar()
        file_menu = menubar.addMenu('文件')

        fileAct = QAction('打开文件', self)
        folderAct = QAction('打开文件夹', self)

        file_menu.addAction(fileAct)
        file_menu.addAction(folderAct)

        fileAct.triggered.connect(self.open_file)
        folderAct.triggered.connect(self.add_files)

        self.add_listener()

        self.setWindowTitle(self.title)
        self.setGeometry(self.left, self.top, self.width, self.height)
        self.show()

    def add_listener(self):
        wid = QWidget(self)
        self.setCentralWidget(wid)

        # 播放控件
        self.volume_slider = QSlider(Qt.Horizontal, self)
        self.volume_slider.setFocusPolicy(Qt.NoFocus)
        self.volume_slider.valueChanged[int].connect(self.change_volume)
        self.volume_slider.setValue(self.volume_initial_value)
        open_btn = QPushButton('打开...')
        prev_btn = QPushButton('上一首')
        next_btn = QPushButton('下一首')
        # 显示播放列表
        self.set_play_list()
        self.song_list.setSelectionBehavior(
            QtWidgets.QAbstractItemView.SelectRows)
        self.song_list.setShowGrid(False)
        self.song_list.setTextElideMode(QtCore.Qt.ElideLeft)

        # 按钮的layout
        control_area = QVBoxLayout()  # centralWidget
        self.media_controls = QHBoxLayout()

        # 将播放控件添加到layout
        self.media_controls.addWidget(open_btn)
        self.media_controls.addWidget(prev_btn)
        self.media_controls.addWidget(self.play_btn)
        self.media_controls.addWidget(next_btn)
        self.media_controls.addWidget(self.play_style_btn)
        self.media_controls.addWidget(self.volume_slider)

        # 将layout添加到界面中
        control_area.addWidget(self.song_list)
        control_area.addLayout(self.media_controls)
        wid.setLayout(control_area)

        # 设置监听
        self.play_btn.clicked.connect(self.start_or_stop)
        open_btn.clicked.connect(self.add_files)
        prev_btn.clicked.connect(self.prev)
        next_btn.clicked.connect(self.next)
        self.song_list.doubleClicked.connect(self.change_song)
        self.play_style_btn.clicked.connect(self.change_play_style)

        self.statusBar()
        self.playlist.currentMediaChanged.connect(self.song_changed)

    def set_play_list(self):
        self.model.clear()
        self.song_list.horizontalHeader().hide()
        # self.song_list.verticalHeader().hide()
        # QHeaderView()
        self.song_list.setModel(self.model)  # 把数据添加至QtableView中
        self.song_list.horizontalHeader().setSectionResizeMode(
            QHeaderView.Stretch)
        self.song_list.setEditTriggers(
            QAbstractItemView.NoEditTriggers)  # 设置不可编辑单元格
        if self.playlist.mediaCount():  # 添加数据
            for index in range(self.playlist.mediaCount()):
                self.model.appendRow([  # 添加一行数据
                    QStandardItem(
                        self.playlist.media(index).canonicalUrl().fileName())
                ])
            self.song_list.selectRow(0)

    def open_file(self):
        song = QFileDialog.getOpenFileName(self, "打开文件", "~",
                                           "音频文件 (*.mp3 *.ogg *.wav *.m4a)")

        if song[0] != '':
            url = QUrl.fromLocalFile(song[0])
            if self.playlist.mediaCount() == 0:
                self.playlist.addMedia(QMediaContent(url))
                self.player.setPlaylist(self.playlist)
                self.player.play()
            else:
                self.playlist.addMedia(QMediaContent(url))
        self.set_play_list()
        self.have_song = True

    def add_files(self):
        if self.playlist.mediaCount() != 0:
            self.playlist.clear()
        self.folder_iterator()
        self.player.setPlaylist(self.playlist)
        self.player.playlist().setCurrentIndex(0)
        self.song_list.selectRow(0)
        self.set_play_list()
        self.player.pause()
        self.play_tip = "暂停:" + self.playlist.currentMedia().canonicalUrl(
        ).fileName()
        self.statusBar().showMessage(self.play_tip + " - " + self.play_style)
        self.have_song = True

    def folder_iterator(self):
        folder_chosen = QFileDialog.getExistingDirectory(self, '打开文件夹', '~')
        if folder_chosen is not None:
            it = QDirIterator(folder_chosen)
            it.next()
            while it.hasNext():
                if (not it.fileInfo().isDir()) and it.filePath() != '.':
                    f_info = it.fileInfo()
                    if f_info.suffix() in ('mp3', 'ogg', 'wav', 'm4a'):
                        self.playlist.addMedia(
                            QMediaContent(QUrl.fromLocalFile(it.filePath())))
                it.next()
            if (not it.fileInfo().isDir()) and it.filePath() != '.':
                f_info = it.fileInfo()
                if f_info.suffix() in ('mp3', 'ogg', 'wav', 'm4a'):
                    self.playlist.addMedia(
                        QMediaContent(QUrl.fromLocalFile(it.filePath())))

    def start_or_stop(self):
        print(self.player.state())
        if self.playlist.mediaCount() == 0:
            self.open_file()
        else:
            if self.player.state() == QMediaPlayer.PlayingState or \
                    (self.player.state() == QMediaPlayer.PlayingState and self.play_btn.text() == '暂停'):
                self.player.pause()
                self.play_btn.setText('播放')
                self.play_tip = "暂停:" + self.playlist.currentMedia(
                ).canonicalUrl().fileName()
            elif self.player.state() == QMediaPlayer.PausedState or \
                    (self.player.state() == QMediaPlayer.PlayingState and self.play_btn.text() == '播放'):
                self.player.play()
                self.play_btn.setText('暂停')
                self.play_tip = "正在播放:" + self.playlist.currentMedia(
                ).canonicalUrl().fileName()
            self.statusBar().showMessage(self.play_tip + " - " +
                                         self.play_style)

    def change_volume(self, value):
        self.player.setVolume(value)

    def volume_up(self):
        volume = self.player.volume(
        ) + 10 if self.player.volume() + 10 <= 100 else 100
        self.player.setVolume(volume)
        self.volume_slider.setTracking(True)
        self.volume_slider.setValue(volume)

    def volume_down(self):
        volume = self.player.volume(
        ) - 10 if self.player.volume() - 10 >= 0 else 0
        self.player.setVolume(volume)
        self.volume_slider.setTracking(True)
        self.volume_slider.setValue(volume)

    def prev(self):
        if self.playlist.mediaCount() == 0:
            self.open_file()
        elif self.playlist.mediaCount() != 0:
            self.player.playlist().previous()

    def shuffle(self):
        self.playlist.shuffle()

    def next(self):
        if self.playlist.mediaCount() == 0:
            self.open_file()
        elif self.playlist.mediaCount() != 0:
            self.player.playlist().next()

    def song_changed(self, media):
        if not media.isNull():
            url = media.canonicalUrl()
            self.play_tip = "正在播放:" + url.fileName()
            self.statusBar().showMessage(self.play_tip + " - " +
                                         self.play_style)
            self.song_list.selectRow(self.playlist.currentIndex())

    def change_song(self):
        index = self.song_list.currentIndex().row()  # 获取双击所在行
        self.playlist.setCurrentIndex(index)

    def change_play_style(self):
        if self.playlist.playbackMode() == QMediaPlaylist.Loop:
            self.playlist.setPlaybackMode(QMediaPlaylist.CurrentItemInLoop)
            self.play_style = "单曲循环"
            self.play_style_btn.setIcon(self.single_img)
        elif self.playlist.playbackMode() == QMediaPlaylist.CurrentItemInLoop:
            self.playlist.setPlaybackMode(QMediaPlaylist.Loop)
            self.play_style = "列表循环"
            self.play_style_btn.setIcon(self.loop_img)
        self.statusBar().showMessage(self.play_tip + " - " + self.play_style)

    def convert_image(self, frame):
        if len(frame.shape) == 2:  # 若是灰度图则转为三通道
            frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2BGR)

        rgb_image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)  # 将BGR转为RGB
        rgb_image = np.asanyarray(rgb_image)
        label_image = QImage(rgb_image.data, rgb_image.shape[1],
                             rgb_image.shape[0],
                             QImage.Format_RGB888)  # 转化为QImage
        self.image_to_show = QPixmap(label_image)

    def show_image(self):
        if self.image_to_show is not None:
            self.videoFrame.setPixmap(self.image_to_show)
        if self.rec_res['set'] and not self.rec_res['used']:
            final_direction = self.rec_res['direction']
            final_fingers = self.rec_res['fingers']
            if final_fingers == 3:
                self.start_or_stop()
                self.rec_res['used'] = True
                return
            if final_fingers == 5:
                self.change_play_style()
                self.rec_res['used'] = True
                return
            if final_direction is not None and final_direction != 'NOT_FOUND':
                if final_direction == "RIGHT":
                    self.next()
                    self.rec_res['used'] = True
                if final_direction == "LEFT":
                    self.prev()
                    self.rec_res['used'] = True
                if final_direction == "UP":
                    self.volume_up()
                    self.rec_res['used'] = True
                if final_direction == "DOWN":
                    self.volume_down()
                    self.rec_res['used'] = True

    def set_rec_res(self, res):
        self.rec_res = res