def drawCharts(self, frame: QFrame):
"""вывод графика в рисунок и в frame"""
# logger.debug(self.drawCharts.__doc__)
pic = self.renderToImage(frame.size())
palette = frame.palette()
palette.setBrush(QPalette.Background, QBrush(pic))
frame.setPalette(palette)
frame.setAutoFillBackground(True)
def set_paragraph(self, h2='', h3='', text='', img=None):
if h2 != '':
lbl_h2 = QLabel(h2, self.inner)
fnt = lbl_h2.font()
fnt.setPointSize(self.H2_FONT_SIZE)
lbl_h2.setFont(fnt)
lbl_h2.setFixedHeight(self.H2_HEIGHT)
lbl_h2.setAlignment(Qt.AlignBottom)
lbl_h2.setMargin(self.SIDE_MARGIN)
self.vbox.addWidget(lbl_h2)
frm = QFrame(self.inner)
frm.setFrameShape(QFrame.HLine)
frm.setContentsMargins(self.SIDE_MARGIN, 0, self.SIDE_MARGIN, 0)
plt = frm.palette()
plt.setColor(QPalette.WindowText, Qt.darkGray)
frm.setPalette(plt)
self.vbox.addWidget(frm)
if text != '':
lbl_txt = QLabel(text, self.inner)
lbl_txt.setWordWrap(True)
fnt = lbl_txt.font()
fnt.setPointSize(self.TEXT_FONT_SIZE)
lbl_txt.setFont(fnt)
lbl_txt.setMargin(self.SIDE_MARGIN)
self.vbox.addWidget(lbl_txt)
if img is not None:
if self.params.lang == 'en':
img += '_en.png'
else:
img += '_jp.png'
pixmap = QPixmap(img)
if not pixmap.isNull():
lbl_img = QLabel(self.inner)
lbl_img.setPixmap(pixmap)
self.lbl_img_list.append(lbl_img)
self.pixmap_list.append(pixmap.scaledToWidth(pixmap.width()))
self.vbox.addWidget(lbl_img)
self.inner.setLayout(self.vbox)
def set_paragraph(self, h2='', h3='', text='', img=None):
if h2 != '':
lbl_h2 = QLabel(h2, self.inner)
fnt = lbl_h2.font()
fnt.setPointSize(self.H2_FONT_SIZE)
lbl_h2.setFont(fnt)
lbl_h2.setFixedHeight(self.H2_HEIGHT)
lbl_h2.setAlignment(Qt.AlignBottom)
lbl_h2.setMargin(self.SIDE_MARGIN)
self.vbox.addWidget(lbl_h2)
frm = QFrame(self.inner)
frm.setFrameShape(QFrame.HLine)
frm.setContentsMargins(self.SIDE_MARGIN, 0, self.SIDE_MARGIN, 0)
plt = frm.palette()
plt.setColor(QPalette.WindowText, Qt.darkGray)
frm.setPalette(plt)
self.vbox.addWidget(frm)
if text != '':
lbl_txt = QLabel(text, self.inner)
lbl_txt.setWordWrap(True)
fnt = lbl_txt.font()
fnt.setPointSize(self.TEXT_FONT_SIZE)
lbl_txt.setFont(fnt)
lbl_txt.setMargin(self.SIDE_MARGIN)
self.vbox.addWidget(lbl_txt)
if img is not None:
if self.params.lang == 'en':
img += '_en.png'
else:
img += '_jp.png'
pixmap = QPixmap(img)
if not pixmap.isNull():
lbl_img = QLabel(self.inner)
lbl_img.setPixmap(pixmap)
self.lbl_img_list.append(lbl_img)
self.pixmap_list.append(pixmap.scaledToWidth(pixmap.width()))
self.vbox.addWidget(lbl_img)
self.inner.setLayout(self.vbox)
class VlcPlayer:
def __init__(self):
try:
os.remove('vlc.log')
except:
pass
self.instance = vlc.Instance("--verbose=2 --network-caching=1000 --no-snapshot-preview --no-osd --file-logging --logfile=vlc.log")
self.mediaplayer = self.instance.media_player_new()
def setMedia(self, mediaFile):
if sys.version < '3':
filename = unicode(mediaFile)
else:
filename = mediaFile
self.media = self.instance.media_new(filename)
self.mediaplayer.set_media(self.media)
self.media.parse()
def createWidget(self, parent=None):
self.videoframe = QFrame(parent)
self.videoPalette = self.videoframe.palette()
self.videoPalette.setColor(QPalette.Window,
QColor(0, 0, 0))
self.videoframe.setAutoFillBackground(True)
self.videoframe.setPalette(self.videoPalette)
if sys.platform.startswith('linux'):
self.mediaplayer.set_xwindow(self.videoframe.winId())
elif sys.platform == "win32":
self.mediaplayer.set_hwnd(self.videoframe.winId())
elif sys.platform == "darwin":
self.mediaplayer.set_nsobject(int(self.videoframe.winId()))
return self.videoframe
class Player(QMainWindow):
"""A simple Media Player using VLC and Qt
"""
def __init__(self, master=None):
if '--clear' in sys.argv: os.remove('.cache')
# Read Data
if not os.path.exists('AllChannel.json'):
print('Reffering channel info from server.')
print(
'If you want to customize channel data, generate AllChannel.json file by generate_SKB_channels.py.',
file=sys.stderr)
from generate_SKB_channels import get_channels
channels = dict([(_['ServiceId'], _) for _ in get_channels()])
else:
print('Using AllChannel.json for referring channel info.')
with open('AllChannel.json', encoding='UTF8') as f:
channels = dict([(_['ServiceId'], _)
for _ in json.loads(f.read())])
new_stream_db = read_m3u(sys.argv[1])
old_stream_db = read_m3u(sys.argv[2])
stream_urls = [_['multicast'] for _ in new_stream_db]
if os.path.exists('.cache'):
with open('.cache', 'rb') as f:
cache = pickle.loads(f.read())
else:
cache = {}
# Checking broken stream
global vlc_error_count, vlc_error_check, vlc_handle_mode
instance = vlc.Instance("--verbose=-1")
instance.log_set(vlc_log_callback, None)
mediaplayer = instance.media_player_new()
mediaplayer.video_set_scale(0.1)
print('Checking broken stream...')
for url in tqdm.tqdm(stream_urls):
if not url in cache:
vlc_error_count = 0
vlc_error_check = False
mediaplayer.set_media(instance.media_new(url))
mediaplayer.play()
time.sleep(3)
cache[url] = vlc_error_check
with open('.cache', 'wb') as f:
f.write(pickle.dumps(cache))
mediaplayer.stop()
self.stream_verify = cache
vlc_handle_mode = 1
##############################
playlist = remove_unmapped_channel(old_stream_db, stream_urls)
playlist = fill_unmapped_channel(playlist, channels)
self.channel_info = channels
self.playlist = playlist
self.stream_urls = stream_urls
import pprint
#pprint.pprint(update_db)
print(len(old_stream_db), len(playlist), len(new_stream_db),
len(channels))
# QT Initialize
QMainWindow.__init__(self, master)
self.setWindowTitle("Media Player")
# creating a basic vlc instance
self.instance = vlc.Instance("--verbose=-1")
self.instance.log_set(vlc_log_callback, None)
# creating an empty vlc media player
self.mediaplayer = self.instance.media_player_new()
self.createUI()
def createUI(self):
"""Set up the user interface, signals & slots
"""
self.widget = QWidget(self)
self.setCentralWidget(self.widget)
# In this widget, the video will be drawn
if sys.platform == "darwin": # for MacOS
from PyQt5.QtWidgets import QMacCocoaViewContainer
self.videoframe = QMacCocoaViewContainer(0)
else:
self.videoframe = QFrame()
self.palette = self.videoframe.palette()
self.palette.setColor(QPalette.Window, QColor(0, 0, 0))
self.videoframe.setPalette(self.palette)
self.videoframe.setAutoFillBackground(True)
self.videoframe.setMinimumWidth(720)
self.videoframe.setMinimumHeight(480)
#self.hbuttonbox = QHBoxLayout()
#self.openchannel = QPushButton("Open Channel Data")
#self.hbuttonbox.addWidget(self.openchannel)
#self.openchannel.clicked.connect(self.PlayPause)
self.hcontrolbox = QHBoxLayout()
self.hinfobox = QHBoxLayout()
self.icon = QLabel()
self.icon.setFixedSize(200, 60)
self.icon.setAlignment(Qt.AlignCenter)
self.hinfobox.addWidget(self.icon)
self.vinfobox = QVBoxLayout()
self.ch_name = QLabel("Loading...")
font = QFont()
font.setBold(True)
font.setFamily('Malgun Gothic')
font.setPointSize(16)
self.ch_name.setFont(font)
self.vinfobox.addWidget(self.ch_name)
self.hservicebox = QHBoxLayout()
self.hservicebox.addWidget(QLabel('Service ID '))
self.service_id = QLabel("[#]")
self.hservicebox.addWidget(self.service_id)
self.vinfobox.addLayout(self.hservicebox)
self.hinfobox.addLayout(self.vinfobox)
self.hcontrolbox.addLayout(self.hinfobox)
self.hcontrolbox.addStretch(1)
self.volumeslider = QSlider(Qt.Horizontal, self)
self.volumeslider.setMaximum(100)
self.volumeslider.setValue(self.mediaplayer.audio_get_volume())
self.volumeslider.setToolTip("Volume")
self.hcontrolbox.addWidget(self.volumeslider)
self.volumeslider.valueChanged.connect(self.setVolume)
#
self.channelbox = QVBoxLayout()
self.channellist = QListWidget()
self.channellist.setFixedWidth(320)
self.channellist.itemClicked.connect(self.selectChannel)
self.channelbox.addWidget(self.channellist)
self.channelfilter = QLineEdit()
self.channelfilter.setFixedWidth(320)
self.channelfilter.textChanged.connect(self.find_channel)
self.channelbox.addWidget(self.channelfilter)
self.streambox = QVBoxLayout()
self.streamlist = QListWidget()
self.streamlist.setFixedWidth(320)
self.streamlist.itemClicked.connect(self.selectStream)
self.streambox.addWidget(self.streamlist)
self.mapbutton = QPushButton("Map")
self.mapbutton.clicked.connect(self.map)
self.streambox.addWidget(self.mapbutton)
self.vboxlayout = QVBoxLayout()
self.vboxlayout.addWidget(self.videoframe)
self.vboxlayout.addLayout(self.hcontrolbox)
self.hboxlayout = QHBoxLayout()
self.hboxlayout.addLayout(self.vboxlayout)
self.hboxlayout.addLayout(self.channelbox)
self.hboxlayout.addLayout(self.streambox)
self.widget.setLayout(self.hboxlayout)
export = QAction("&Export", self)
export.triggered.connect(self.ExportFile)
exit = QAction("E&xit", self)
exit.triggered.connect(sys.exit)
menubar = self.menuBar()
filemenu = menubar.addMenu("&File")
filemenu.addAction(export)
filemenu.addSeparator()
filemenu.addAction(exit)
self.updatePlaylist()
def ExportFile(self):
print(os.path.expanduser('~'))
#filename = QFileDialog.getSaveFileName(self, "Save File", os.path.expanduser('~'),)[0]
filename = QFileDialog.getSaveFileName(
self,
"Export Playlist File",
'playlist.m3u',
"M3U Playlist (*.m3u *.m3u8)",
)[0]
if not filename: return
with open(filename, 'wt', encoding='UTF8') as f:
f.write('#EXTM3U\n')
for item in [
self.channellist.item(_)
for _ in range(self.channellist.count())
]:
if item.checkState():
data = item.data(Qt.UserRole)
f.write(
f"#EXTINF:-1 tvg-id=\"{data['tvg-id']}\" tvg-logo=\"{data['tvg-logo']}\" tvg-chno=\"{data['tvh-chnum']}\" tvh-chnum=\"{data['tvh-chnum']}\", {data['ch-name']}\n"
)
f.write(f"{data['multicast']}\n")
filename = QFileDialog.getSaveFileName(
self,
"Export Channel File",
'Channel.json',
"JSON File (*.json)",
)[0]
if not filename: return
channels = []
for item in [
self.channellist.item(_)
for _ in range(self.channellist.count())
]:
if item.checkState():
data = item.data(Qt.UserRole)
channels.append(self.channel_info[data['tvg-id']])
with open(filename, 'wt', encoding='UTF8') as f:
f.write(json.dumps(channels, indent=2))
def setVolume(self, Volume):
"""Set the volume
"""
self.mediaplayer.audio_set_volume(Volume)
def find_channel(self, text):
if text:
for item in [
self.channellist.item(_)
for _ in range(self.channellist.count())
]:
if item.text().lower().find(text.lower()) >= 0:
item.setHidden(False)
else:
item.setHidden(True)
else:
for item in [
self.channellist.item(_)
for _ in range(self.channellist.count())
]:
item.setHidden(False)
def map(self, *args, **kwargs):
item = self.channellist.currentItem()
item.setCheckState(Qt.Checked)
channel = item.data(Qt.UserRole)
sitem = self.streamlist.currentItem()
radio = self.streamlist.itemWidget(sitem)
channel['multicast'] = radio.text()
item.setData(Qt.UserRole, channel)
self.updateMappedInfo()
def playStream(self, stream_url):
global vlc_error_count, vlc_error_check
vlc_error_count = 0
vlc_error_check = False
self.media = self.instance.media_new(stream_url)
# put the media in the media player
self.mediaplayer.set_media(self.media)
# parse the metadata of the file
self.media.parse()
# set the title of the track as window title
self.setWindowTitle(self.media.get_meta(0))
# the media player has to be 'connected' to the QFrame
# (otherwise a video would be displayed in it's own window)
# this is platform specific!
# you have to give the id of the QFrame (or similar object) to
# vlc, different platforms have different functions for this
if sys.platform.startswith('linux'): # for Linux using the X Server
self.mediaplayer.set_xwindow(self.videoframe.winId())
elif sys.platform == "win32": # for Windows
self.mediaplayer.set_hwnd(self.videoframe.winId())
elif sys.platform == "darwin": # for MacOS
self.mediaplayer.set_nsobject(int(self.videoframe.winId()))
self.mediaplayer.play()
def selectChannel(self, item):
global vlc_error_count, vlc_error_check
vlc_error_count = 0
vlc_error_check = False
channel = item.data(Qt.UserRole)
print(channel)
if 'multicast' in channel and channel['multicast']:
streams = dict([(item.data(Qt.UserRole), item) for item in [
self.streamlist.item(_) for _ in range(self.streamlist.count())
]])
if channel['multicast'] in streams:
self.selectStream(streams[channel['multicast']])
else:
item.setCheckState(Qt.Unchecked)
else:
item.setCheckState(Qt.Unchecked)
self.ch_name.setText(channel['ch-name'])
frame = self.getIcon(channel['tvg-logo'])
pixmap = QPixmap()
pixmap.loadFromData(frame)
self.icon.setPixmap(
pixmap.scaled(self.icon.width(), self.icon.height(),
Qt.KeepAspectRatio))
self.service_id.setText(f"[{channel['tvg-id']}]")
def updateStreamRadioState(self, state):
if state:
found = False
for item in [
self.streamlist.item(_)
for _ in range(self.streamlist.count())
]:
radio = self.streamlist.itemWidget(item)
if radio.isChecked():
self.channellist.currentItem().setCheckState(Qt.Checked)
item.setText("")
self.streamlist.setCurrentItem(item)
self.streamlist.update(self.streamlist.currentIndex())
self.selectStreamImpl(item)
found = True
break
if not found:
item = self.streamlist.item(0)
self.streamlist.setCurrentItem(item)
self.selectStreamImpl(item)
def selectStream(self, item):
stream_info = item.data(Qt.UserRole)
radio = self.streamlist.itemWidget(item)
radio.setChecked(True)
def selectStreamImpl(self, item):
global vlc_error_count, vlc_error_check
vlc_error_count = 0
vlc_error_check = False
radio = self.streamlist.itemWidget(item)
url = radio.text()
item.setData(Qt.UserRole, url)
print('URL from Radio :', url)
if url:
self.playStream(url)
#citem = self.channellist.currentItem()
#data = citem.data(Qt.UserRole)
#data['multicast'] = url
#citem.setData(Qt.UserRole, data)
#print('Saved URL :', url)
else:
pass
#self.mediaplayer.pause()
#citem = self.channellist.currentItem()
#data = citem.data(Qt.UserRole)
#data['multicast'] = None
#citem.setData(Qt.UserRole, data)
#print('Saved URL :', None)
self.updateMappedInfo()
def getMappedDict(self):
mapped_dict = {}
for item in [
self.channellist.item(_)
for _ in range(self.channellist.count())
]:
data = item.data(Qt.UserRole)
if data['multicast']:
if data['multicast'] in mapped_dict:
mapped_dict[data['multicast']].append(data['ch-name'])
else:
mapped_dict[data['multicast']] = [data['ch-name']]
return mapped_dict
def updateMappedInfo(self):
print('UpdateMappedInfo')
mapped_dict = self.getMappedDict()
for item in [
self.streamlist.item(_) for _ in range(self.streamlist.count())
]:
url = item.data(Qt.UserRole)
if url == '__BROKEN__':
item.setText("*** BROKEN ***")
elif url in mapped_dict:
item.setText(f"[{','.join(mapped_dict[url])}]"
if mapped_dict[url] else "")
else:
item.setText("")
self.streamlist.update(self.streamlist.indexFromItem(item))
def disableChannel(self):
self.channellist.currentItem().setCheckState(Qt.Unchecked)
self.channellist.update(self.channellist.currentIndex())
data = self.channellist.currentItem().data(Qt.UserRole)
data['multicast'] = None
self.channellist.currentItem().setData(Qt.UserRole, data)
self.streamlist.update(self.streamlist.currentIndex())
self.streamlist.currentItem().setData(Qt.UserRole, '__BROKEN__')
self.updateMappedInfo()
#app.processEvents()
@functools.lru_cache(maxsize=None)
def getIcon(self, url):
req = request.Request(url)
req.add_header(
'User-Agent',
'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0'
)
frame = None
for _ in range(3):
try:
resp = request.urlopen(req)
frame = resp.read()
break
except:
time.sleep(1)
return frame
def attachIcon(self, item):
channel = item.data(Qt.UserRole)
url = channel['tvg-logo']
pixmap = QPixmap()
pixmap.loadFromData(self.getIcon(url))
item.setIcon(QIcon(pixmap))
def asyncCacheIcon(self):
def asyncThread(listwidget):
for item in [
listwidget.item(_) for _ in range(listwidget.count())
]:
channel = item.data(Qt.UserRole)
self.attachIcon(item)
listwidget.update(listwidget.indexFromItem(item))
threading.Thread(target=asyncThread,
args=(self.channellist, ),
daemon=True).start()
def updatePlaylist(self):
self.channellist.clear()
for channel in self.playlist:
item = QListWidgetItem()
item.setData(Qt.UserRole, channel)
item.setText(f"[{channel['tvh-chnum']}] {channel['ch-name']}")
item.setCheckState(Qt.Checked if channel['multicast']
and not self.stream_verify[channel['multicast']]
else Qt.Unchecked)
self.channellist.addItem(item)
item = QListWidgetItem()
item.setData(Qt.UserRole, '')
self.streamlist.addItem(item)
radio = QRadioButton('Unbound Stream URL')
radio.toggled.connect(self.updateStreamRadioState)
self.streamlist.setItemWidget(item, radio)
for url in self.stream_urls:
item = QListWidgetItem()
item.setTextAlignment(Qt.AlignRight)
item.setData(Qt.UserRole,
'__BROKEN__' if self.stream_verify[url] else url)
self.streamlist.addItem(item)
radio = QRadioButton(url)
radio.toggled.connect(self.updateStreamRadioState)
self.streamlist.setItemWidget(item, radio)
self.updateMappedInfo()
self.asyncCacheIcon()
def delayedSelectChannel(n):
time.sleep(n)
self.channellist.setCurrentRow(0)
self.selectChannel(self.channellist.currentItem())
threading.Thread(target=delayedSelectChannel, args=(3, ),
daemon=True).start()
class Player(QMainWindow):
"""A simple Media Player using VLC and Qt
"""
def __init__(self, master=None):
QMainWindow.__init__(self, master)
self.setWindowTitle("Media Player")
# creating a basic vlc instance
self.instance = vlc.Instance()
# creating an empty vlc media player
self.mediaplayer = self.instance.media_player_new()
self.createUI()
self.isPaused = False
def createUI(self):
"""Set up the user interface, signals & slots
"""
self.widget = QWidget(self)
self.setCentralWidget(self.widget)
# In this widget, the video will be drawn
if sys.platform == "darwin": # for MacOS
from PyQt5.QtWidgets import QMacCocoaViewContainer
self.videoframe = QMacCocoaViewContainer(0)
else:
self.videoframe = QFrame()
self.palette = self.videoframe.palette()
self.palette.setColor(QPalette.Window, QColor(0, 0, 0))
self.videoframe.setPalette(self.palette)
self.videoframe.setAutoFillBackground(True)
self.hbuttonbox = QHBoxLayout()
self.playbutton = QPushButton("Play")
self.hbuttonbox.addWidget(self.playbutton)
self.playbutton.clicked.connect(self.PlayPause)
self.stopbutton = QPushButton("Stop")
self.hbuttonbox.addWidget(self.stopbutton)
self.stopbutton.clicked.connect(self.Stop)
self.hbuttonbox.addStretch(1)
self.volumeslider = QSlider(Qt.Horizontal, self)
self.volumeslider.setMaximum(100)
self.volumeslider.setValue(self.mediaplayer.audio_get_volume())
self.volumeslider.setToolTip("Volume")
self.hbuttonbox.addWidget(self.volumeslider)
self.volumeslider.valueChanged.connect(self.setVolume)
self.vboxlayout = QVBoxLayout()
self.vboxlayout.addWidget(self.videoframe)
self.vboxlayout.addLayout(self.hbuttonbox)
self.widget.setLayout(self.vboxlayout)
open = QAction("&Connect", self)
open.triggered.connect(self.OpenStreaming)
exit = QAction("&Exit", self)
exit.triggered.connect(sys.exit)
menubar = self.menuBar()
filemenu = menubar.addMenu("&File")
filemenu.addAction(open)
filemenu.addSeparator()
filemenu.addAction(exit)
def PlayPause(self):
"""Toggle play/pause status
"""
if self.mediaplayer.is_playing():
self.mediaplayer.pause()
self.playbutton.setText("Play")
self.isPaused = True
else:
if self.mediaplayer.play() == -1:
self.OpenStreaming()
return
self.mediaplayer.play()
self.playbutton.setText("Pause")
self.isPaused = False
def Stop(self):
"""Stop player
"""
self.mediaplayer.stop()
self.playbutton.setText("Play")
def OpenStreaming(self, url=None):
"""Open a alert asking the user a URL
"""
print("original url:", url)
if url is None or not url:
url, okPressed = QInputDialog.getText(
self, "RSTP streaming URL", "URL:", QLineEdit.Normal,
"rtsp://127.0.0.1:8554/live.sdp")
if not okPressed or len(url) <= 0:
return
print("used url:", url)
self.mediaplayer.video_set_mouse_input(False)
self.mediaplayer.video_set_key_input(False)
self.mediaplayer.set_mrl(url, "network-caching=300")
self.mediaplayer.audio_set_mute(
False) # change to True if MUTE is necessary!
if sys.platform.startswith('linux'): # for Linux using the X Server
self.mediaplayer.set_xwindow(self.videoframe.winId())
elif sys.platform == "win32": # for Windows
self.mediaplayer.set_hwnd(self.videoframe.winId())
elif sys.platform == "darwin": # for MacOS
self.mediaplayer.set_nsobject(int(self.videoframe.winId()))
self.PlayPause()
def setVolume(self, Volume):
"""Set the volume
"""
self.mediaplayer.audio_set_volume(Volume)
class Player(QMainWindow):
"""
Modification of the simple Media Player using VLC and Qt
to show the mambo stream
The window part of this example was modified from the QT example cited below.
VLC requires windows to create and show the video and this was a cross-platform solution.
VLC will automatically create the windows in linux but not on the mac.
Amy McGovern, [email protected]
Qt example for VLC Python bindings
https://github.com/devos50/vlc-pyqt5-example
Copyright (C) 2009-2010 the VideoLAN team
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
"""
def __init__(self, vlc_player, drone_gui, move, process):
"""
Create a UI window for the VLC player
:param vlc_player: the VLC player (created outside the function)
"""
self.process = process
QMainWindow.__init__(self)
self.move = move
self.setWindowTitle("VLC Drone Video Player")
# save the media player
self.mediaplayer = vlc_player
# need a reference to the main drone vision class
self.drone_vision = drone_gui
# create the GUI
self.createUI()
def set_values(self, yaw, pitch):
pass
# self.yaw_bar.setValue(yaw)
# self.pitch_bar.setValue(pitch)
# here the GUI and all it's buttons are created
def createUI(self):
"""
Set up the window for the VLC viewer
"""
self.widget = QWidget(self)
self.setCentralWidget(self.widget)
# In this widget, the video will be drawn
if sys.platform == "darwin": # for MacOS
from PyQt5.QtWidgets import QMacCocoaViewContainer
self.videoframe = QMacCocoaViewContainer(0)
else:
self.videoframe = QFrame()
self.palette = self.videoframe.palette()
self.palette.setColor(QPalette.Window, QColor(0, 0, 0))
self.videoframe.setPalette(self.palette)
self.videoframe.setAutoFillBackground(True)
self.hbuttonbox = QHBoxLayout()
self.raise_lower_box = QHBoxLayout()
self.forward_box = QHBoxLayout()
self.left_right_box = QHBoxLayout()
self.backward_box = QHBoxLayout()
self.toggle_box = QHBoxLayout()
self.playbutton = QPushButton("Start")
self.hbuttonbox.addWidget(self.playbutton)
self.playbutton.clicked.connect(partial(self.move.restart))
self.landbutton = QPushButton("Land NOW")
self.hbuttonbox.addWidget(self.landbutton)
self.landbutton.clicked.connect(self.drone_vision.land)
self.landsafebutton = QPushButton("Land safe")
self.hbuttonbox.addWidget(self.landsafebutton)
self.landsafebutton.clicked.connect(self.move.kill)
self.stopbutton = QPushButton("Quit")
self.hbuttonbox.addWidget(self.stopbutton)
self.stopbutton.clicked.connect(self.drone_vision.close_exit)
self.raise_button = QPushButton("Raise Drone")
self.raise_lower_box.addWidget(self.raise_button)
self.raise_button.clicked.connect(self.move.raise_drone)
self.lower_button = QPushButton("Lower Drone")
self.raise_lower_box.addWidget(self.lower_button)
self.lower_button.clicked.connect(self.move.lower_drone)
self.forward_button = QPushButton("^")
self.forward_box.addWidget(self.forward_button)
self.forward_button.clicked.connect(self.move.drone_forward)
self.left_button = QPushButton("<")
self.hover_button = QPushButton("o")
self.right_button = QPushButton(">")
self.left_right_box.addWidget(self.left_button)
self.left_right_box.addWidget(self.hover_button)
self.left_right_box.addWidget(self.right_button)
self.left_button.clicked.connect(self.move.drone_left)
self.hover_button.clicked.connect(self.move.drone_hover)
self.right_button.clicked.connect(self.move.drone_right)
self.backward_button = QPushButton("v")
self.backward_box.addWidget(self.backward_button)
self.backward_button.clicked.connect(self.move.drone_right)
self.rotation_button = QPushButton("Rotation Track")
self.toggle_box.addWidget(self.rotation_button)
self.rotation_button.clicked.connect(self.move.rotate_true)
self.fixed_button = QPushButton("Fixed Track")
self.toggle_box.addWidget(self.fixed_button)
self.fixed_button.clicked.connect(self.move.rotate_false)
self.vboxlayout = QVBoxLayout()
self.vboxlayout.addWidget(self.videoframe)
self.vboxlayout.addLayout(self.hbuttonbox)
self.vboxlayout.addLayout(self.raise_lower_box)
self.vboxlayout.addLayout(self.forward_box)
self.vboxlayout.addLayout(self.left_right_box)
self.vboxlayout.addLayout(self.backward_box)
self.vboxlayout.addLayout(self.toggle_box)
# determined how far away from the tracked object the drone should be
sld = QSlider(Qt.Horizontal, self)
sld.setFocusPolicy(Qt.NoFocus)
sld.setGeometry(30, 40, 100, 30)
sld.setValue(60)
sld.valueChanged[int].connect(self.change_box_size_max)
sld1 = QSlider(Qt.Horizontal, self)
sld1.setFocusPolicy(Qt.NoFocus)
sld1.setGeometry(30, 40, 100, 30)
sld1.setValue(40)
sld1.valueChanged[int].connect(self.change_box_size_min)
sld1.move(30, 60)
# shows how much the drone 'wants' to rotate to the left/right
# (this corresponds to where on the x-axis the tracked object is)
# self.yaw_bar = QProgressBar(self)
# self.yaw_bar.setGeometry(30, 40, 200, 25)
# self.yaw_bar.move(0, 100)
#
# # shows how much the drone 'wants' to go forwards/backwards
# # (corresponds to how far away the tracked object is)
# self.pitch_bar = QProgressBar(self)
# self.pitch_bar.setGeometry(30, 40, 200, 25)
# self.pitch_bar.move(0, 200)
# self.pitch_bar.setValue(60)
self.label = QLabel(self)
self.setGeometry(300, 300, 280, 170)
self.setWindowTitle('QSlider')
self.show()
self.widget.setLayout(self.vboxlayout)
# the media player has to be 'connected' to the QFrame
# (otherwise a video would be displayed in it's own window)
# this is platform specific!
# you have to give the id of the QFrame (or similar object) to
# vlc, different platforms have different functions for this
if sys.platform.startswith('linux'): # for Linux using the X Server
self.mediaplayer.set_xwindow(self.videoframe.winId())
elif sys.platform == "win32": # for Windows
self.mediaplayer.set_hwnd(self.videoframe.winId())
elif sys.platform == "darwin": # for MacOS
self.mediaplayer.set_nsobject(int(self.videoframe.winId()))
def change_box_size_max(self, value):
# convert the slider input to 0 to 1 and feed it to the movement function
self.process.set_max_box_size(value / (100))
def change_box_size_min(self, value):
# convert the slider input to 0 to 1 and feed it to the movement function
self.process.set_min_box_size(value / (100))
class Player(QMainWindow):
"""A simple Media Player using VLC and Qt
"""
def __init__(self, master=None):
QMainWindow.__init__(self, master)
self.setWindowTitle("Media Player")
# creating a basic vlc instance
self.instance = vlc.Instance()
# creating an empty vlc media player
self.mediaplayer = self.instance.media_player_new()
self.createUI()
self.isPaused = False
def createUI(self):
"""Set up the user interface, signals & slots
"""
self.widget = QWidget(self)
self.setCentralWidget(self.widget)
# In this widget, the video will be drawn
if sys.platform == "darwin": # for MacOS
from PyQt5.QtWidgets import QMacCocoaViewContainer
self.videoframe = QMacCocoaViewContainer(0)
else:
self.videoframe = QFrame()
self.palette = self.videoframe.palette()
self.palette.setColor (QPalette.Window,
QColor(0,0,0))
self.videoframe.setPalette(self.palette)
self.videoframe.setAutoFillBackground(True)
self.positionslider = QSlider(Qt.Horizontal, self)
self.positionslider.setToolTip("Position")
self.positionslider.setMaximum(1000)
self.positionslider.sliderMoved.connect(self.setPosition)
self.hbuttonbox = QHBoxLayout()
self.playbutton = QPushButton("Play")
self.hbuttonbox.addWidget(self.playbutton)
self.playbutton.clicked.connect(self.PlayPause)
self.stopbutton = QPushButton("Stop")
self.hbuttonbox.addWidget(self.stopbutton)
self.stopbutton.clicked.connect(self.Stop)
self.hbuttonbox.addStretch(1)
self.volumeslider = QSlider(Qt.Horizontal, self)
self.volumeslider.setMaximum(100)
self.volumeslider.setValue(self.mediaplayer.audio_get_volume())
self.volumeslider.setToolTip("Volume")
self.hbuttonbox.addWidget(self.volumeslider)
self.volumeslider.valueChanged.connect(self.setVolume)
self.vboxlayout = QVBoxLayout()
self.vboxlayout.addWidget(self.videoframe)
self.vboxlayout.addWidget(self.positionslider)
self.vboxlayout.addLayout(self.hbuttonbox)
self.widget.setLayout(self.vboxlayout)
open = QAction("&Open", self)
open.triggered.connect(self.OpenFile)
exit = QAction("&Exit", self)
exit.triggered.connect(sys.exit)
menubar = self.menuBar()
filemenu = menubar.addMenu("&File")
filemenu.addAction(open)
filemenu.addSeparator()
filemenu.addAction(exit)
self.timer = QTimer(self)
self.timer.setInterval(200)
self.timer.timeout.connect(self.updateUI)
def PlayPause(self):
"""Toggle play/pause status
"""
if self.mediaplayer.is_playing():
self.mediaplayer.pause()
self.playbutton.setText("Play")
self.isPaused = True
else:
if self.mediaplayer.play() == -1:
self.OpenFile()
return
self.mediaplayer.play()
self.playbutton.setText("Pause")
self.timer.start()
self.isPaused = False
def Stop(self):
"""Stop player
"""
self.mediaplayer.stop()
self.playbutton.setText("Play")
def OpenFile(self, filename=None):
"""Open a media file in a MediaPlayer
"""
if filename is None:
filename = QFileDialog.getOpenFileName(self, "Open File", os.path.expanduser('~'))[0]
if not filename:
return
# create the media
if sys.version < '3':
filename = unicode(filename)
self.media = self.instance.media_new(filename)
# put the media in the media player
self.mediaplayer.set_media(self.media)
# parse the metadata of the file
self.media.parse()
# set the title of the track as window title
self.setWindowTitle(self.media.get_meta(0))
# the media player has to be 'connected' to the QFrame
# (otherwise a video would be displayed in it's own window)
# this is platform specific!
# you have to give the id of the QFrame (or similar object) to
# vlc, different platforms have different functions for this
if sys.platform.startswith('linux'): # for Linux using the X Server
self.mediaplayer.set_xwindow(self.videoframe.winId())
elif sys.platform == "win32": # for Windows
self.mediaplayer.set_hwnd(self.videoframe.winId())
elif sys.platform == "darwin": # for MacOS
self.mediaplayer.set_nsobject(int(self.videoframe.winId()))
self.PlayPause()
def setVolume(self, Volume):
"""Set the volume
"""
self.mediaplayer.audio_set_volume(Volume)
def setPosition(self, position):
"""Set the position
"""
# setting the position to where the slider was dragged
self.mediaplayer.set_position(position / 1000.0)
# the vlc MediaPlayer needs a float value between 0 and 1, Qt
# uses integer variables, so you need a factor; the higher the
# factor, the more precise are the results
# (1000 should be enough)
def updateUI(self):
"""updates the user interface"""
# setting the slider to the desired position
self.positionslider.setValue(self.mediaplayer.get_position() * 1000)
if not self.mediaplayer.is_playing():
# no need to call this function if nothing is played
self.timer.stop()
if not self.isPaused:
# after the video finished, the play button stills shows
# "Pause", not the desired behavior of a media player
# this will fix it
self.Stop()
class Player(QWidget):
"""A simple Media Player using VLC and Qt
"""
def __init__(self, master=None):
QWidget.__init__(self, master)
#self.setWindowTitle("Media Player")
# creating a basic vlc instance
self.instance = vlc.Instance()
# creating an empty vlc media player
self.mediaplayer = self.instance.media_player_new()
self.createUI()
self.isPaused = False
def createUI(self):
"""Set up the user interface, signals & slots
"""
#self.widget = QWidget(self)
#self.setCentralWidget(self.widget)
# In this widget, the video will be drawn
self.videoframe = QFrame()
self.palette = self.videoframe.palette()
self.palette.setColor(QPalette.Window, QColor(0, 0, 0))
self.videoframe.setPalette(self.palette)
self.videoframe.setAutoFillBackground(True)
# self.positionslider = QSlider(Qt.Horizontal, self)
# self.positionslider.setToolTip("Position")
# self.positionslider.setMaximum(1000)
# self.positionslider.sliderMoved.connect(self.setPosition)
# self.hbuttonbox = QHBoxLayout()
# self.playbutton = QPushButton("Play")
# self.hbuttonbox.addWidget(self.playbutton)
# self.playbutton.clicked.connect(self.PlayPause)
# self.stopbutton = QPushButton("Stop")
# self.hbuttonbox.addWidget(self.stopbutton)
# self.stopbutton.clicked.connect(self.Stop)
# self.hbuttonbox.addStretch(1)
# self.volumeslider = QSlider(Qt.Horizontal, self)
# self.volumeslider.setMaximum(100)
# self.volumeslider.setValue(self.mediaplayer.audio_get_volume())
# self.volumeslider.setToolTip("Volume")
# self.hbuttonbox.addWidget(self.volumeslider)
# self.volumeslider.valueChanged.connect(self.setVolume)
self.vboxlayout = QVBoxLayout()
self.vboxlayout.addWidget(self.videoframe)
#self.vboxlayout.addWidget(self.positionslider)
#self.vboxlayout.addLayout(self.hbuttonbox)
self.setLayout(self.vboxlayout)
# open = QAction("&Open", self)
# open.triggered.connect(self.OpenFile)
# exit = QAction("&Exit", self)
# exit.triggered.connect(sys.exit)
#menubar = self.menuBar()
#filemenu = menubar.addMenu("&File")
#filemenu.addAction(open)
#filemenu.addSeparator()
#filemenu.addAction(exit)
self.timer = QTimer(self)
self.timer.setInterval(200)
self.timer.timeout.connect(self.updateUI)
def PlayPause(self):
"""Toggle play/pause status
"""
if self.mediaplayer.is_playing():
self.mediaplayer.pause()
#self.playbutton.setText("Play")
self.isPaused = True
else:
if self.mediaplayer.play() == -1:
self.OpenFile()
return
self.mediaplayer.play()
#self.playbutton.setText("Pause")
self.timer.start()
self.isPaused = False
def Stop(self):
"""Stop player
"""
self.mediaplayer.stop()
#self.playbutton.setText("Play")
def OpenFile(self, filename=None):
"""Open a media file in a MediaPlayer
"""
if filename is None:
filename = QFileDialog.getOpenFileName(self, "Open File",
os.path.expanduser('~'))[0]
if not filename:
return
# create the media
if sys.version < '3':
filename = unicode(filename)
self.media = self.instance.media_new(filename)
# put the media in the media player
self.mediaplayer.set_media(self.media)
# parse the metadata of the file
self.media.parse()
# set the title of the track as window title
self.setWindowTitle(self.media.get_meta(0))
# the media player has to be 'connected' to the QFrame
# (otherwise a video would be displayed in it's own window)
# this is platform specific!
# you have to give the id of the QFrame (or similar object) to
# vlc, different platforms have different functions for this
if sys.platform.startswith('linux'): # for Linux using the X Server
self.mediaplayer.set_xwindow(self.videoframe.winId())
elif sys.platform == "win32": # for Windows
self.mediaplayer.set_hwnd(self.videoframe.winId())
elif sys.platform == "darwin": # for MacOS
self.mediaplayer.set_nsobject(int(self.videoframe.winId()))
self.PlayPause()
def setVolume(self, Volume):
"""Set the volume
"""
self.mediaplayer.audio_set_volume(Volume)
def setPosition(self, position):
"""Set the position
"""
# setting the position to where the slider was dragged
self.mediaplayer.set_position(position / 1000.0)
# the vlc MediaPlayer needs a float value between 0 and 1, Qt
# uses integer variables, so you need a factor; the higher the
# factor, the more precise are the results
# (1000 should be enough)
def updateUI(self):
"""updates the user interface"""
# setting the slider to the desired position
#self.positionslider.setValue(self.mediaplayer.get_position() * 1000)
if not self.mediaplayer.is_playing():
# no need to call this function if nothing is played
self.timer.stop()
if not self.isPaused:
# after the video finished, the play button stills shows
# "Pause", not the desired behavior of a media player
# this will fix it
self.Stop()
class obeeUi(QMainWindow):
def __init__(self, master=None):
QMainWindow.__init__(self, master)
self.setWindowTitle("OBEE Control Center")
# creating a basic vlc instance
self.instance = VLC.Instance()
# creating an empty vlc media player
self.mediaplayer = self.instance.media_player_new()
self.MainUi()
##self.MapLayer()
self.temelmenubar()
self.isPaused = False
self.openQ()
def MainUi(self):
"""
Kullanıcı arayüz yapılandırması-sinyal/slot
"""
#_translate = QtCore.QCoreApplication.translate
self.Main_widget = QtWidgets.QWidget(self)
self.palette = self.Main_widget.palette()
self.palette.setColor (QPalette.Window,QColor(193,193,193))
self.Main_widget.setPalette(self.palette)
self.Main_widget.setAutoFillBackground(True)
self.setObjectName("Main_widget")
self.setCentralWidget(self.Main_widget)
self.setWindowTitle("obee")
#LOGO yu buraya koyduk
self.label_logo = QtWidgets.QLabel(self.Main_widget)
self.label_logo.setGeometry(QtCore.QRect(950, 600, 261, 91))
self.label_logo.setText("")
self.label_logo.setPixmap(QtGui.QPixmap("obee-logo.png"))
self.label_logo.setObjectName("label_logo")
self.label_logo.setCursor(QtGui.QCursor(QtCore.Qt.BlankCursor))
self.label_logo.setMouseTracking(True)
#1.KISIM-RSTPlayer
self.videoframe = QFrame(self.Main_widget)
self.videoframe.setGeometry(QtCore.QRect(0, 0, 900, 600))
self.palette = self.videoframe.palette()
self.palette.setColor (QPalette.Window,QColor(0,0,0))
self.videoframe.setPalette(self.palette)
self.videoframe.setAutoFillBackground(True)
self.RSTPbutton = QPushButton(self.Main_widget)#1.BUTON
self.RSTPbutton.setGeometry(QtCore.QRect(0, 600, 50, 50))
self.RSTPbutton.setText("RSTP")
self.palette = self.RSTPbutton.palette()
self.palette.setColor (QPalette.Window,QColor(0,0,0))
self.RSTPbutton.setPalette(self.palette)
self.RSTPbutton.setAutoFillBackground(True)
self.RSTPbutton.clicked.connect(self.Stream)
self.RSTbutton = QPushButton(self.Main_widget)#2.BUTON
self.RSTbutton.setGeometry(QtCore.QRect(50, 600, 50, 50))
self.RSTbutton.setText("X")
self.palette = self.RSTbutton.palette()
self.palette.setColor (QPalette.Window,QColor(255,255,255))
self.RSTbutton.setPalette(self.palette)
self.RSTbutton.setAutoFillBackground(True)
self.RSbutton = QPushButton(self.Main_widget)#3.BUTON
self.RSbutton.setGeometry(QtCore.QRect(0, 650, 50, 50))
self.RSbutton.setText("Y")
self.palette = self.RSTPbutton.palette()
self.palette.setColor (QPalette.Window,QColor(255,255,255))
self.RSbutton.setPalette(self.palette)
self.RSbutton.setAutoFillBackground(True)
self.Rbutton = QPushButton(self.Main_widget)#4.BUTON
self.Rbutton.setGeometry(QtCore.QRect(50, 650, 50, 50))
self.Rbutton.setText("Z")
self.palette = self.RSTPbutton.palette()
self.palette.setColor (QPalette.Window,QColor(255,255,255))
self.Rbutton.setPalette(self.palette)
self.Rbutton.setAutoFillBackground(True)#---
self.f1button = QtWidgets.QPushButton(self.Main_widget)#1.BUTON
self.f1button.setGeometry(QtCore.QRect(800, 600, 50, 50))
self.f1button.setText("F1")
self.f2button = QtWidgets.QPushButton(self.Main_widget)#2.BUTON
self.f2button.setGeometry(QtCore.QRect(850, 600, 50, 50))
self.f2button.setText("F2")
self.f3button = QPushButton(self.Main_widget)#3.BUTON
self.f3button.setGeometry(QtCore.QRect(800, 650, 50, 50))
self.f3button.setText("F3")
self.f4button = QPushButton(self.Main_widget)#4.BUTON
self.f4button.setGeometry(QtCore.QRect(850, 650, 50, 50))
self.f4button.setText("F4")
self.f1button.clicked.connect(self.openQ)
self.f2button.clicked.connect(self.fopenpre)
#self.f3button.clicked.connect(self.fopendbupdate)
self.f4button.clicked.connect(self.fopenhelp)
#---info function button label---
self.label_f1 = QtWidgets.QLabel(self.Main_widget)
self.label_f1.setGeometry(QtCore.QRect(600, 585, 200, 50))
self.label_f1.setText("*(F1)Quick Access Screen")
self.label_f2 = QtWidgets.QLabel(self.Main_widget)
self.label_f2.setGeometry(QtCore.QRect(600, 605, 200, 50))
self.label_f2.setText("*(F2)Pre-paration DB")
self.label_f3 = QtWidgets.QLabel(self.Main_widget)
self.label_f3.setGeometry(QtCore.QRect(600, 625, 200, 50))
self.label_f3.setText("*(F3)Database Update")
self.label_f4 = QtWidgets.QLabel(self.Main_widget)
self.label_f4.setGeometry(QtCore.QRect(600, 645, 200, 50))
self.label_f4.setText("*(F4)-Help?")
#2.KISIM-Map
self.mapFrame = QFrame(self.Main_widget)
self.mapFrame.setGeometry(QtCore.QRect(900, 0, 350, 450))
self.palette = self.mapFrame.palette()
self.palette.setColor (QPalette.Window,QColor(0,220,0))
self.mapFrame.setPalette(self.palette)
self.mapFrame.setAutoFillBackground(True)
self.mapFrame.setCursor(QtGui.QCursor(QtCore.Qt.CrossCursor))
self.label = QtWidgets.QLabel(self.mapFrame)
self.label.setGeometry(QtCore.QRect(100, 20, 250, 21))
palette = QtGui.QPalette()
brush = QtGui.QBrush(QtGui.QColor(85, 87, 83))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.WindowText, brush)
brush = QtGui.QBrush(QtGui.QColor(85, 87, 83))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.WindowText, brush)
brush = QtGui.QBrush(QtGui.QColor(190, 190, 190))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.WindowText, brush)
self.label.setPalette(palette)
font = QtGui.QFont()
font.setBold(True)
font.setWeight(75)
self.label.setFont(font)
self.label.setObjectName("label")
self.label.setText("BETA***")
self.mapbutton = QPushButton(self.Main_widget)#1.BUTON
self.mapbutton.setGeometry(QtCore.QRect(1250, 400, 50, 50))
self.mapbutton.setText("MAP")
self.mapbutton.setPalette(self.palette)
self.mapbutton.clicked.connect(self.viewhtml)
#3.KISIM-EVENTS
self.eventFrame = QFrame(self.Main_widget)
self.eventFrame.setGeometry(QtCore.QRect(900, 450, 350, 150))
self.palette = self.mapFrame.palette()
self.palette.setColor (QPalette.Window,QColor(220,0,0))
self.eventFrame.setPalette(self.palette)
self.eventFrame.setAutoFillBackground(True)
self.events_textBrowser = QtWidgets.QTextBrowser(self.Main_widget)
self.events_textBrowser.setGeometry(QtCore.QRect(910, 460, 330, 130))
palette = QtGui.QPalette()
brush = QtGui.QBrush(QtGui.QColor(136, 138, 133))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Base, brush)
brush = QtGui.QBrush(QtGui.QColor(136, 138, 133))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Base, brush)
brush = QtGui.QBrush(QtGui.QColor(239, 235, 231))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Base, brush)
self.events_textBrowser.setPalette(palette)
self.eventbutton = QPushButton(self.Main_widget)#1.BUTON
self.eventbutton.setGeometry(QtCore.QRect(1250, 450, 50, 50))
self.eventbutton.setText("EVENT")
self.eventbutton.setPalette(self.palette)
self.eventbutton.clicked.connect(self.Event)
self.resize(1300, 900)
self.show()
def openQ(self):#yeni komut istemi
if sys.platform == "linux": # for Linux
os.system("gnome-terminal -e 'python3 startquick_basic.py'")
elif sys.platform == "win32": # for Windows
os.system("start cmd /c 'python3 startquick_basic.py'")
def fopenpre(self):
import sqlite3
# SQLite DB Name
DB_Name = "dbMQTT.db"
# SQLite DB Table Schema
TableSchema="""
drop table if exists Weather_Data ;
create table weather (
_id_ integer primary key autoincrement,
ID text,
Date_n_Time text,
weather_value text
);
drop table if exists Sensor_Data ;
create table sensor (
_id_ integer primary key autoincrement,
ID text,
Date_n_Time text,
Sensor_value text
);
drop table if exists Location_Data ;
create table location (
loc text
);
"""
#Connect or Create DB File
conn = sqlite3.connect(DB_Name)
curs = conn.cursor()
#Create Tables
sqlite3.complete_statement(TableSchema)
curs.executescript(TableSchema)
#Close DB
curs.close()
conn.close()
QMessageBox.about(self.Main_widget, str("Complete"), str("Database created//but(for error) you should delete or replace old database file"))
def fopenhelp(self):
"""import webbrowser
self.pre..()
webbrowser.open('help.html')"""
def MQTTlayersetupUi(self):
self.MQTTsetup = QtWidgets.QWidget(self)
self.setCentralWidget(self.MQTTsetup)
self.MQTTsetup.setObjectName("MQTTsetup")
#Objeleri yerleştirelim
###1.KISIM###
self.groupBox = QtWidgets.QGroupBox(self.MQTTsetup)
self.palette = self.groupBox.palette()
self.palette.setColor (QPalette.Window,QColor(143,143,143))
self.groupBox.setPalette(self.palette)
self.groupBox.setAutoFillBackground(True)
self.groupBox.setGeometry(QtCore.QRect(10, 10, 511, 71))
font = QtGui.QFont()
font.setBold(True)
font.setWeight(75)
self.groupBox.setFont(font)
self.groupBox.setObjectName("groupBox")
self.label_info = QtWidgets.QLabel(self.groupBox)
self.label_info.setGeometry(QtCore.QRect(77, 50, 282, 20))
font = QtGui.QFont()
font.setPointSize(7)
font.setItalic(True)
self.label_info.setFont(font)
self.label_info.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))
self.label_info.setObjectName("label_info")
self.verticalLayoutWidget = QtWidgets.QWidget(self.groupBox)
self.verticalLayoutWidget.setGeometry(QtCore.QRect(430, 10, 81, 61))
self.verticalLayoutWidget.setObjectName("verticalLayoutWidget")
self.verticalLayout = QtWidgets.QVBoxLayout(self.verticalLayoutWidget)
self.verticalLayout.setContentsMargins(0, 0, 0, 0)
self.verticalLayout.setObjectName("verticalLayout")
self.Connect_pushButton = QtWidgets.QPushButton(self.verticalLayoutWidget)
self.Connect_pushButton.setObjectName("Connect_pushButton")
self.Connect_pushButton.clicked.connect(self.MQTTclient)
self.verticalLayout.addWidget(self.Connect_pushButton)
self.Disconnect_pushButton = QtWidgets.QPushButton(self.verticalLayoutWidget)
self.Disconnect_pushButton.setObjectName("Disconnect_pushButton")
#self.Disconnect_pushButton.clicked.connect(self.MQTTstop)
self.verticalLayout.addWidget(self.Disconnect_pushButton)
self.formLayoutWidget = QtWidgets.QWidget(self.groupBox)
self.formLayoutWidget.setGeometry(QtCore.QRect(0, 20, 261, 22))
self.formLayoutWidget.setObjectName("formLayoutWidget")
self.formLayout_host = QtWidgets.QFormLayout(self.formLayoutWidget)
self.formLayout_host.setContentsMargins(0, 0, 0, 0)
self.formLayout_host.setObjectName("formLayout_host")
self.connectionsetup_host_label = QtWidgets.QLabel(self.formLayoutWidget)
self.connectionsetup_host_label.setObjectName("connectionsetup_host_label")
self.formLayout_host.setWidget(0, QtWidgets.QFormLayout.LabelRole, self.connectionsetup_host_label)
self.Host_linedit = QtWidgets.QLineEdit(self.formLayoutWidget)
self.Host_linedit.setObjectName("Host_linedit")
self.formLayout_host.setWidget(0, QtWidgets.QFormLayout.FieldRole, self.Host_linedit)
self.formLayoutWidget_2 = QtWidgets.QWidget(self.groupBox)
self.formLayoutWidget_2.setGeometry(QtCore.QRect(270, 20, 141, 21))
self.formLayoutWidget_2.setObjectName("formLayoutWidget_2")
self.formLayout_port = QtWidgets.QFormLayout(self.formLayoutWidget_2)
self.formLayout_port.setContentsMargins(0, 0, 0, 0)
self.formLayout_port.setObjectName("formLayout_port")
self.Port_linedit = QtWidgets.QLineEdit(self.formLayoutWidget_2)
self.Port_linedit.setObjectName("Port_linedit")
self.formLayout_port.setWidget(0, QtWidgets.QFormLayout.FieldRole, self.Port_linedit)
self.connectionsetup_port_label = QtWidgets.QLabel(self.formLayoutWidget_2)
self.connectionsetup_port_label.setObjectName("connectionsetup_port_label")
self.formLayout_port.setWidget(0, QtWidgets.QFormLayout.LabelRole, self.connectionsetup_port_label)
###2.KISIM###
self.tabWidget = QtWidgets.QTabWidget(self.MQTTsetup)
self.tabWidget.setGeometry(QtCore.QRect(10, 100, 241, 201))
self.tabWidget.setObjectName("tabWidget")
self.tab_sekme_pub = QtWidgets.QWidget()###SEKME Publish
self.palette = self.tab_sekme_pub.palette()
self.palette.setColor (QPalette.Window,QColor(0,100,10))
self.tab_sekme_pub.setPalette(self.palette)
self.tab_sekme_pub.setAutoFillBackground(True)
self.tab_sekme_pub.setObjectName("tab_sekme_pub")
self.publish_linedit = QtWidgets.QLineEdit(self.tab_sekme_pub)
self.publish_linedit.setEnabled(True)
self.publish_linedit.setGeometry(QtCore.QRect(10, 10, 191, 20))
self.publish_linedit.setWhatsThis("")
self.publish_linedit.setAccessibleDescription("")
self.publish_linedit.setInputMask("")
self.publish_linedit.setClearButtonEnabled(False)
self.publish_linedit.setObjectName("publish_linedit")
self.listWidget = QtWidgets.QListWidget(self.tab_sekme_pub)
self.listWidget.setGeometry(QtCore.QRect(10, 40, 121, 121))
self.listWidget.setObjectName("listWidget")
item = QtWidgets.QListWidgetItem()
self.listWidget.addItem(item)
item = QtWidgets.QListWidgetItem()
self.listWidget.addItem(item)
item = QtWidgets.QListWidgetItem()
self.listWidget.addItem(item)
self.formLayoutWidget_3 = QtWidgets.QWidget(self.tab_sekme_pub)
self.formLayoutWidget_3.setGeometry(QtCore.QRect(130, 40, 83, 61))
self.formLayoutWidget_3.setObjectName("formLayoutWidget_3")
self.formLayout_pub = QtWidgets.QFormLayout(self.formLayoutWidget_3)
self.formLayout_pub.setContentsMargins(0, 0, 0, 0)
self.formLayout_pub.setObjectName("formLayout_pub")
self.publish_add_pushButton = QtWidgets.QPushButton(self.formLayoutWidget_3)
self.publish_add_pushButton.setObjectName("publish_add_pushButton")
self.formLayout_pub.setWidget(0, QtWidgets.QFormLayout.LabelRole, self.publish_add_pushButton)
self.publish_remove_pushButton = QtWidgets.QPushButton(self.formLayoutWidget_3)
self.publish_remove_pushButton.setObjectName("publish_remove_pushButton")
self.formLayout_pub.setWidget(1, QtWidgets.QFormLayout.LabelRole, self.publish_remove_pushButton)
self.tabWidget.addTab(self.tab_sekme_pub, "")
self.tab_sekme_sub = QtWidgets.QWidget()###SEKME Subscribe#yerdeğisti!!!pub-*sub-düzenlenmedi
self.palette = self.tab_sekme_sub.palette()
self.palette.setColor (QPalette.Window,QColor(0,10,110))
self.tab_sekme_sub.setPalette(self.palette)
self.tab_sekme_sub.setAutoFillBackground(True)
self.tab_sekme_sub.setObjectName("tab_sekme_sub")
self.subscribe_linedit = QtWidgets.QLineEdit(self.tab_sekme_sub)
self.subscribe_linedit.setGeometry(QtCore.QRect(10, 10, 191, 20))
self.subscribe_linedit.setObjectName("subscribe_linedit")
self.formLayoutWidget_4 = QtWidgets.QWidget(self.tab_sekme_sub)
self.formLayoutWidget_4.setGeometry(QtCore.QRect(130, 40, 83, 61))
self.formLayoutWidget_4.setObjectName("formLayoutWidget_4")
self.formLayout_sub = QtWidgets.QFormLayout(self.formLayoutWidget_4)
self.formLayout_sub.setContentsMargins(0, 0, 0, 0)
self.formLayout_sub.setObjectName("formLayout_sub")
self.subscribe_add_pushButton = QtWidgets.QPushButton(self.formLayoutWidget_4)
self.subscribe_add_pushButton.setObjectName("subscribe_add_pushButton")
self.formLayout_sub.setWidget(0, QtWidgets.QFormLayout.LabelRole, self.subscribe_add_pushButton)
self.subscribe_remove_pushButton = QtWidgets.QPushButton(self.formLayoutWidget_4)
self.subscribe_remove_pushButton.setObjectName("subscribe_remove_pushButton")
self.formLayout_sub.setWidget(1, QtWidgets.QFormLayout.LabelRole, self.subscribe_remove_pushButton)
self.listWidget_2 = QtWidgets.QListWidget(self.tab_sekme_sub)
self.listWidget_2.setGeometry(QtCore.QRect(10, 40, 121, 121))
self.listWidget_2.setObjectName("listWidget_2")
item = QtWidgets.QListWidgetItem()
self.listWidget_2.addItem(item)
item = QtWidgets.QListWidgetItem()
self.listWidget_2.addItem(item)
#self.tabWidget.addTab(self.tab_sekme_sub, "") ----Sekme pasif
###3.KISIM###
self.groupBox_events = QtWidgets.QGroupBox(self.MQTTsetup)
self.groupBox_events.setGeometry(QtCore.QRect(280, 110, 240, 190))
self.groupBox_events.setObjectName("groupBox_events")
self.palette = self.groupBox_events.palette()
self.palette.setColor (QPalette.Window,QColor(222,0,0))
self.groupBox_events.setPalette(self.palette)
self.groupBox_events.setAutoFillBackground(True)
self.events_textBrowser = QtWidgets.QTextBrowser(self.groupBox_events)
self.events_textBrowser.setGeometry(QtCore.QRect(10, 20, 220, 160))
self.events_textBrowser.setObjectName("events_textBrowser")
self.tabWidget.setCurrentIndex(1)
QtCore.QMetaObject.connectSlotsByName(self.MQTTsetup)
_translate = QtCore.QCoreApplication.translate
self.setWindowTitle(_translate("MQTTsetup", "MQTT Setup"))
self.groupBox.setTitle(_translate("MQTTsetup", "CONNECTION SETUP"))
self.label_info.setText(_translate("MQTTsetup","*Only need to press the connect button using the predefined settings*"))
self.Connect_pushButton.setText(_translate("MQTTsetup", "Connect"))
self.Disconnect_pushButton.setText(_translate("MQTTsetup", "Disconnect"))
self.connectionsetup_host_label.setText(_translate("MQTTsetup", "Broker IP"))
self.connectionsetup_port_label.setText(_translate("MQTTsetup", "PORT"))
__sortingEnabled = self.listWidget.isSortingEnabled()
self.listWidget.setSortingEnabled(False)
item = self.listWidget.item(0)
item.setText(_translate("MQTTsetup", "sensor"))
item = self.listWidget.item(1)
item.setText(_translate("MQTTsetup", "location"))
item = self.listWidget.item(2)
item.setText(_translate("MQTTsetup", "weather"))
self.listWidget.setSortingEnabled(__sortingEnabled)
self.publish_add_pushButton.setText(_translate("MQTTsetup", "OK"))
self.publish_remove_pushButton.setText(_translate("MQTTsetup", "Remove"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_sekme_pub), _translate("MQTTsetup", "SUBSCRIBE"))
self.subscribe_add_pushButton.setText(_translate("MQTTsetup", "OK"))
self.subscribe_remove_pushButton.setText(_translate("MQTTsetup", "Remove"))
__sortingEnabled = self.listWidget_2.isSortingEnabled()
self.listWidget_2.setSortingEnabled(False)
item = self.listWidget_2.item(0)
item.setText(_translate("MQTTsetup", "empty0"))
item = self.listWidget_2.item(1)
item.setText(_translate("MQTTsetup", "empty1"))
self.listWidget_2.setSortingEnabled(__sortingEnabled)
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_sekme_sub), _translate("MQTTsetup", "PUBLISH"))
self.groupBox_events.setTitle(_translate("MQTTsetup", "EVENTS"))
self.resize(540, 350)
self.show()
def MQTTclient(self, MQTTlayersetupUi):
if sys.platform == "linux": # for Linux
os.system("gnome-terminal -e 'python3 MQTTgui.py'")
elif sys.platform == "win32": # for Windows
os.system("start cmd /c 'python3 MQTTgui.py'")
def RSTPlayersetupUi(self):
"""
Kullanıcı arayüz yapılandırması-RSTPlayer ve sinyal/slot
"""
self.RSTPlayer_widget = QtWidgets.QWidget(self)
self.setCentralWidget(self.RSTPlayer_widget)
self.setWindowTitle("Stream")
self.videoframe = QFrame() #videoframe oluşturduk widget içine alacaz sonra
self.palette = self.videoframe.palette()
self.palette.setColor (QPalette.Window,QColor(0,0,0))
self.videoframe.setPalette(self.palette)
self.videoframe.setAutoFillBackground(True)
self.videoframe.setCursor(QtGui.QCursor(QtCore.Qt.CrossCursor))
self.hbuttonbox = QHBoxLayout(self) #butonlar oluşturuyoruz
self.streambutton = QPushButton("Launch Stream") #
self.hbuttonbox.addWidget(self.streambutton) #
self.streambutton.clicked.connect(self.Stream) #
self.stopbutton = QPushButton("Stop") #
self.hbuttonbox.addWidget(self.stopbutton) #
self.stopbutton.clicked.connect(self.Stop) #
self.vboxlayout = QVBoxLayout(self) #Ana pencereye yerleştirmek için
#vboxlayout tanımladık ve sonra kullandık
self.vboxlayout.addWidget(self.videoframe) #VideoFrame ana pencereye eklendi
self.vboxlayout.addLayout(self.hbuttonbox) #hbuttonbox ana pencereye eklendi
#vboxlayout içine koyduk şimdi bunları RSTPlayer_widget'a
self.RSTPlayer_widget.setLayout(self.vboxlayout) #dikkat en son rstpwidget a ekledi,RSTPlayer_widget ayarlandı
#yani enson çuvala koyduk
self.resize(640, 480)
self.show()
def MapLayer(self):
self.MapLayer_widget = QtWidgets.QWidget(self)
self.setCentralWidget(self.MapLayer_widget)
self.setWindowTitle("MAP")
self.mapFrame = QFrame(self.MapLayer_widget)
self.mapFrame.setCursor(QtGui.QCursor(QtCore.Qt.CrossCursor))
self.mapFrame.setGeometry(QtCore.QRect(10, 10, 500, 500))
self.palette = self.mapFrame.palette()
self.palette.setColor (QPalette.Window,QColor(0,220,0))
self.mapFrame.setPalette(self.palette)
self.mapFrame.setAutoFillBackground(True)
self.label = QtWidgets.QLabel(self.mapFrame)
self.label.setGeometry(QtCore.QRect(100, 20, 250, 50))
palette = QtGui.QPalette()
brush = QtGui.QBrush(QtGui.QColor(85, 87, 83))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.WindowText, brush)
brush = QtGui.QBrush(QtGui.QColor(85, 87, 83))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.WindowText, brush)
brush = QtGui.QBrush(QtGui.QColor(190, 190, 190))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.WindowText, brush)
self.label.setPalette(palette)
font = QtGui.QFont()
font.setBold(True)
font.setWeight(75)
self.label.setFont(font)
self.label.setObjectName("label")
self.label.setText("BETA***")
self.MAPbutton = QPushButton(self.MapLayer_widget)#1.BUTON
self.MAPbutton.setGeometry(QtCore.QRect(250, 510, 50, 50))
self.MAPbutton.setText("OK")
self.palette = self.MAPbutton.palette()
self.palette.setColor (QPalette.Window,QColor(0,220,0))
self.MAPbutton.setPalette(self.palette)
self.MAPbutton.setAutoFillBackground(True)
#self.MAPbutton.clicked.connect(self.)
self.Xbutton = QPushButton(self.MapLayer_widget)#2.BUTON
self.Xbutton.setGeometry(QtCore.QRect(200, 510, 50, 50))
self.Xbutton.setText("X")
self.palette = self.Xbutton.palette()
self.palette.setColor (QPalette.Window,QColor(0,220,0))
self.Xbutton.setPalette(self.palette)
self.Xbutton.setAutoFillBackground(True)
self.Ybutton = QPushButton(self.MapLayer_widget)#3.BUTON
self.Ybutton.setGeometry(QtCore.QRect(250, 560, 50, 50))
self.Ybutton.setText("Y")
self.palette = self.Ybutton.palette()
self.palette.setColor (QPalette.Window,QColor(0,220,0))
self.Ybutton.setPalette(self.palette)
self.Ybutton.setAutoFillBackground(True)
self.Zbutton = QPushButton(self.MapLayer_widget)#4.BUTON
self.Zbutton.setGeometry(QtCore.QRect(200, 560, 50, 50))
self.Zbutton.setText("Z")
self.palette = self.Zbutton.palette()
self.palette.setColor (QPalette.Window,QColor(0,220,0))
self.Zbutton.setPalette(self.palette)
self.Zbutton.setAutoFillBackground(True)#---
#self.map = QWebView(self)
#self.openMap = QUrl("http://thomasmansencal.com/Sharing/Others/Google_Maps.html")
#self.map.load( openMap )
#self.MapLayer_widget.addWidget( map )
self.resize(520, 610)
self.show()
def premaps(self):
import sqlite3
import json
import codecs
conn = sqlite3.connect('dbMQTT.db')
cur = conn.cursor()
fhand = codecs.open('where.js','w', "utf-8")
fhand.write("myData = [\n")
count = 0
cur.execute('SELECT * FROM location')
for row in cur :
loc = str(row[0])#0. sutunu okuduk
if loc == 0 : continue
try :
print(loc)
count = count + 1
if count > 1 : fhand.write(",\n")
output = "["+str(loc)+"]"
fhand.write(output)
except:
continue
fhand.write("\n];\n")
cur.close()
fhand.close()
def viewhtml(self):
import webbrowser
self.premaps()
webbrowser.open('where.html')
def temelmenubar(self):
"""
Ana ekran menü bar yapılandırılması
"""
setRSTP = QAction("Setup", self)
setRSTP.triggered.connect(self.Stream)
onlyRSTP = QAction("View", self)
onlyRSTP.triggered.connect(self.RSTPlayersetupUi)
setMQTT = QAction("Setup", self)
setMQTT.triggered.connect(self.MQTTlayersetupUi)
#onlyMQTT = QAction("View", self)
onlyMQTTsub = QAction("Subscribe", self)
onlyMQTTpub = QAction("", self)
setMap = QAction("Setup", self)
setMap.triggered.connect(self.MapLayer)
onlyMap = QAction("View", self)
onlyMap.triggered.connect(self.MapLayer)
home = QAction("Main Page", self)
home.triggered.connect(self.MainUi)
exit = QAction("Exit", self)
exit.triggered.connect(sys.exit)
version = QAction("v1.1-beta", self)
OBEEmenubar = self.menuBar() #Temel menübar oluşturduk
General = OBEEmenubar.addMenu("General")
General.addAction(home)
General.addSeparator()
General.addAction(exit)
RSTPlayermenu = OBEEmenubar.addMenu("RSTP")
aRSTPmenu = RSTPlayermenu.addAction(onlyRSTP)
bRSTPmenu = RSTPlayermenu.addAction(setRSTP)
MQTTlayermenu = OBEEmenubar.addMenu("MQTT")
aMQTTmenu = MQTTlayermenu.addMenu("View")
bMQTTmenu = MQTTlayermenu.addAction(setMQTT)
aaMQTTmenu = aMQTTmenu.addAction(onlyMQTTsub)
abMQTTmenu = aMQTTmenu.addAction(onlyMQTTpub)
MapLayermenu = OBEEmenubar.addMenu("Map")
MapLayermenu.addAction(onlyMap)
MapLayermenu.addAction(setMap)
About = OBEEmenubar.addMenu("About")
About.addAction(version)
def Stream(self, streambutton):
"""
play/pause geçiş yapılandırması
"""
if self.mediaplayer.is_playing():
self.mediaplayer.pause()
self.streambutton.setText("Live")
self.isPaused = True
else:
if self.mediaplayer.play() == -1:
self.OpenFile()
return
self.mediaplayer.play()
self.streambutton.setText("Pause")
self.isPaused = False
def Stop(self):#stop yapılandırması
self.mediaplayer.stop()
self.streambutton.setText("BROADCASTING")
def OpenFile(self,filename=None):
"""
Yürütülen media yapılandırması
"""
if filename is None:
filename = QFileDialog.getOpenFileName(self, "Dosya Seç", os.path.expanduser('~'))[0]
if not filename:
return
# media oluşturuyoruz
if sys.version < '3':
filename = unicode(filename)
self.media = self.instance.media_new(filename)
# MediaPlayer içine koyalım
self.mediaplayer.set_media(self.media)
# Dosyamızın metadata verilerini ayrıştıyoruz
self.media.parse()
"""
MediaPlayer QFrame ye bağlı olması gerekiyor:
Bu durum OS tipine göre değişkenlik göstereceğinden;
ilgili komutları oluşturuyoruz:)
Bu olmazsa player katmanı ana pencerede olmuyor:( *5 satır*
"""
if sys.platform.startswith('linux'): # for Linux using the X Server
self.mediaplayer.set_xwindow(self.videoframe.winId())
elif sys.platform == "win32": # for Windows
self.mediaplayer.set_hwnd(self.videoframe.winId())
self.Stream()
def Event(self):#düzenlenecek
self.Events_widget = QtWidgets.QWidget(self)
self.setWindowTitle("Events")
self.eventsFrame = QFrame(self.Events_widget)
self.eventsFrame.setGeometry(QtCore.QRect(0, 0, 600, 600))
self.palette = self.eventFrame.palette()
self.palette.setColor (QPalette.Window,QColor(0,0,0))
self.eventsFrame.setPalette(self.palette)
self.eventsFrame.setAutoFillBackground(True)
self.eventss_textBrowser = QtWidgets.QTextBrowser(self.Events_widget)
self.eventss_textBrowser.setGeometry(QtCore.QRect(10, 20, 580, 600))
self.eventsbutton = QPushButton(self.Events_widget)#1.BUTON
self.eventsbutton.setGeometry(QtCore.QRect(510, 20, 50, 50))
self.eventsbutton.setText("Events")
self.palette = self.eventsbutton.palette()
self.palette.setColor (QPalette.Window,QColor(220,0,0))
self.eventsbutton.setPalette(self.palette)
self.eventsbutton.setAutoFillBackground(True)
#self.eventbutton.clicked.connect(self.Stream)
self.resize(600, 700)
self.show()
class RSTPlayer(QMainWindow):
def __init__(self, master=None):
QMainWindow.__init__(self, master)
self.setWindowTitle("RSTP Real-Time Streaming Screen")
self.instance = VLC.Instance()
self.mediaplayer = self.instance.media_player_new()
self.RSTPgui()
self.isPaused = False
def RSTPgui(self):
"""
Kullanıcı arayüz yapılandırması-RSTPlayer ve sinyal/slot
"""
self.RSTPlayer_widget = QtWidgets.QWidget(self)
self.setCentralWidget(self.RSTPlayer_widget)
self.setWindowTitle("Stream")
self.videoframe = QFrame(
) #videoframe oluşturduk widget içine alacaz sonra
self.palette = self.videoframe.palette()
self.palette.setColor(QPalette.Window, QColor(0, 0, 0))
self.videoframe.setPalette(self.palette)
self.videoframe.setAutoFillBackground(True)
self.videoframe.setCursor(QtGui.QCursor(QtCore.Qt.CrossCursor))
self.hbuttonbox = QHBoxLayout(self) #butonlar oluşturuyoruz
self.streambutton = QPushButton("Launch Stream") #
self.hbuttonbox.addWidget(self.streambutton) #
self.streambutton.clicked.connect(self.Stream) #
self.stopbutton = QPushButton("Stop") #
self.hbuttonbox.addWidget(self.stopbutton) #
self.stopbutton.clicked.connect(self.Stop) #
self.vboxlayout = QVBoxLayout(self) #Ana pencereye yerleştirmek için
#vboxlayout tanımladık ve sonra kullandık
self.vboxlayout.addWidget(
self.videoframe) #VideoFrame ana pencereye eklendi
self.vboxlayout.addLayout(
self.hbuttonbox) #hbuttonbox ana pencereye eklendi
#vboxlayout içine koyduk şimdi bunları RSTPlayer_widget'a
self.RSTPlayer_widget.setLayout(
self.vboxlayout
) #dikkat en son rstpwidget a ekledi,RSTPlayer_widget ayarlandı
#yani enson çuvala koyduk
self.resize(640, 480)
self.show()
def Stream(self, streambutton):
"""
play/pause geçiş yapılandırması
"""
if self.mediaplayer.is_playing():
self.mediaplayer.pause()
self.streambutton.setText("Live")
self.isPaused = True
else:
if self.mediaplayer.play() == -1:
self.OpenFile()
return
self.mediaplayer.play()
self.streambutton.setText("Pause")
self.isPaused = False
def Stop(self): #stop yapılandırması
self.mediaplayer.stop()
self.streambutton.setText("BROADCASTING")
def OpenFile(self, filename=None):
"""
Yürütülen media yapılandırması
"""
if filename is None:
filename = QFileDialog.getOpenFileName(self, "Dosya Seç",
os.path.expanduser('~'))[0]
if not filename:
return
# media oluşturuyoruz
if sys.version < '3':
filename = unicode(filename)
self.media = self.instance.media_new(filename)
# MediaPlayer içine koyalım
self.mediaplayer.set_media(self.media)
# Dosyamızın metadata verilerini ayrıştıyoruz
self.media.parse()
"""
MediaPlayer QFrame ye bağlı olması gerekiyor:
Bu durum OS tipine göre değişkenlik göstereceğinden;
ilgili komutları oluşturuyoruz:)
Bu olmazsa player katmanı ana pencerede olmuyor:( *5 satır*
"""
if sys.platform.startswith('linux'): # for Linux using the X Server
self.mediaplayer.set_xwindow(self.videoframe.winId())
elif sys.platform == "win32": # for Windows
self.mediaplayer.set_hwnd(self.videoframe.winId())
self.Stream()
class OtherDialog(QDialog):
def __init__(self, inputDict):
super(OtherDialog, self).__init__()
self.setWindowTitle('Other configurations')
mltpl = inputDict['multiple']
thrshld = inputDict['threshold']
msk = inputDict['mask']
vbox = QVBoxLayout()
self.setLayout(vbox)
label = QLabel("(*) Only meant for image inserted by template")
vbox.addWidget(label)
hline = QFrame()
hline.setFrameStyle(hline.HLine)
hline.setLineWidth(1)
vbox.addWidget(hline)
formLayout = QFormLayout()
vbox.addLayout(formLayout)
self.multiple = QCheckBox()
self.multiple.setChecked(mltpl)
formLayout.addRow("Multiple Match (*):", self.multiple)
self.threshold = QDoubleSpinBox()
self.threshold.setDecimals(1)
self.threshold.setRange(0, 1)
self.threshold.setSingleStep(0.1)
self.threshold.setValue(thrshld)
formLayout.addRow("Threshold (*):", self.threshold)
hbox = QHBoxLayout()
colorBtn = QPushButton("Select")
colorBtn.clicked.connect(self.colorBtn_clicked)
hbox.addWidget(colorBtn)
_, red, _, green, _, blue = msk.split(',')
self.backgroundColor = ("background-color: rgb(" + red + "," + green +
"," + blue + ")")
self.borderColor = "border: 1px solid black"
self.frame = QFrame()
self.frame.setStyleSheet(self.borderColor + ";" + self.backgroundColor)
hbox.addWidget(self.frame)
formLayout.addRow("Image background color:", hbox)
self.btns = QDialogButtonBox()
self.btns.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Ok)
vbox.addWidget(self.btns)
self.btns.accepted.connect(self.accept)
self.btns.rejected.connect(self.reject)
def colorBtn_clicked(self):
colorDialog = QColorDialog()
colorDialog.setOption(QColorDialog.ShowAlphaChannel)
color = colorDialog.getColor()
if color.isValid():
self.frame.setStyleSheet(self.borderColor + ";" +
'background-color: %s' % color.name())
return
def getMask(self):
''' Get the background color of the frame. '''
# Get the background color of the frame
frameColor = self.frame.palette().color(QPalette.Background)
red, green, blue, alpha = (frameColor.red(), frameColor.green(),
frameColor.blue(), frameColor.alpha())
# Create a mask list
maskList = []
for c in red, green, blue:
if int(c) == 0:
maskList.append(str(c))
maskList.append(str(int(c) + 2))
elif int(c) == 255:
maskList.append(str(int(c) - 2))
maskList.append(str(c))
else:
maskList.append(str(int(c) - 1))
maskList.append(str(int(c) + 1))
# Join the list with comma
mask = ','.join(maskList)
return mask
def accept(self):
mask = self.getMask()
# Create an empty dictionary
self._output = {}
# Fill the dictionary with values
self._output['multiple'] = self.multiple.isChecked()
self._output['threshold'] = self.threshold.value()
self._output['mask'] = mask
super(OtherDialog, self).accept()
return
def get_output(self):
return self._output
def main():
MAX_INTENSITY = 255
app = QApplication([])
# Create and lay out widgets.
redLabel = QLabel('Red:')
redLabel.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
redLabel.setAutoFillBackground(True)
p = redLabel.palette()
p.setColor(redLabel.backgroundRole(), Qt.red)
redLabel.setPalette(p)
greenLabel = QLabel('Green:')
greenLabel.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
greenLabel.setAutoFillBackground(True)
p = greenLabel.palette()
p.setColor(greenLabel.backgroundRole(), Qt.green)
greenLabel.setPalette(p)
blueLabel = QLabel('Blue:')
blueLabel.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
blueLabel.setAutoFillBackground(True)
p = blueLabel.palette()
p.setColor(blueLabel.backgroundRole(), Qt.blue)
blueLabel.setPalette(p)
redSlider = QSlider(Qt.Horizontal)
redSlider.setMinimum(0)
redSlider.setMaximum(MAX_INTENSITY)
greenSlider = QSlider(Qt.Horizontal)
greenSlider.setMinimum(0)
greenSlider.setMaximum(MAX_INTENSITY)
blueSlider = QSlider(Qt.Horizontal)
blueSlider.setMinimum(0)
blueSlider.setMaximum(MAX_INTENSITY)
redLineEdit = QLineEdit('0')
greenLineEdit = QLineEdit('0')
blueLineEdit = QLineEdit('0')
controlFrameLayout = QGridLayout()
controlFrameLayout.setSpacing(0)
controlFrameLayout.setContentsMargins(0, 0, 0, 0)
controlFrameLayout.setRowStretch(0, 0)
controlFrameLayout.setRowStretch(1, 0)
controlFrameLayout.setRowStretch(2, 0)
controlFrameLayout.setColumnStretch(0, 0)
controlFrameLayout.setColumnStretch(1, 1)
controlFrameLayout.setColumnStretch(2, 0)
controlFrameLayout.addWidget(redLabel, 0, 0)
controlFrameLayout.addWidget(greenLabel, 1, 0)
controlFrameLayout.addWidget(blueLabel, 2, 0)
controlFrameLayout.addWidget(redSlider, 0, 1)
controlFrameLayout.addWidget(greenSlider, 1, 1)
controlFrameLayout.addWidget(blueSlider, 2, 1)
controlFrameLayout.addWidget(redLineEdit, 0, 2)
controlFrameLayout.addWidget(greenLineEdit, 1, 2)
controlFrameLayout.addWidget(blueLineEdit, 2, 2)
controlFrame = QFrame()
controlFrame.setLayout(controlFrameLayout)
colorFrame = QFrame()
colorFrame.setAutoFillBackground(True)
p = colorFrame.palette()
p.setColor(colorFrame.backgroundRole(), Qt.black)
colorFrame.setPalette(p)
centralFrameLayout = QGridLayout()
centralFrameLayout.setSpacing(0)
centralFrameLayout.setContentsMargins(0, 0, 0, 0)
centralFrameLayout.setRowStretch(0, 1)
centralFrameLayout.setRowStretch(1, 0)
centralFrameLayout.setColumnStretch(0, 1)
centralFrameLayout.addWidget(colorFrame, 0, 0)
centralFrameLayout.addWidget(controlFrame, 1, 0)
centralFrame = QFrame()
centralFrame.setLayout(centralFrameLayout)
window = QMainWindow()
window.setWindowTitle('Color Displayer')
window.setCentralWidget(centralFrame)
screenSize = QDesktopWidget().screenGeometry()
window.resize(screenSize.width() // 2, screenSize.height() // 2)
# Handle events for the QSlider objects.
def sliderSlot():
r = redSlider.value()
g = greenSlider.value()
b = blueSlider.value()
redLineEdit.setText(str(r))
greenLineEdit.setText(str(g))
blueLineEdit.setText(str(b))
p = colorFrame.palette()
p.setColor(colorFrame.backgroundRole(), QColor(r, g, b))
colorFrame.setPalette(p)
redSlider.valueChanged.connect(sliderSlot)
greenSlider.valueChanged.connect(sliderSlot)
blueSlider.valueChanged.connect(sliderSlot)
# Handle events for the LineEdit objects.
def lineEditSlot():
try:
r = int(redLineEdit.text())
g = int(greenLineEdit.text())
b = int(blueLineEdit.text())
if (r < 0) or (r > MAX_INTENSITY): raise Exception()
if (g < 0) or (g > MAX_INTENSITY): raise Exception()
if (b < 0) or (b > MAX_INTENSITY): raise Exception()
redSlider.setValue(r)
greenSlider.setValue(g)
blueSlider.setValue(b)
p = colorFrame.palette()
p.setColor(colorFrame.backgroundRole(), QColor(r, g, b))
colorFrame.setPalette(p)
except:
# Use the Slider objects to restore the LineEdit objects.
redLineEdit.setText(str(redSlider.value()))
greenLineEdit.setText(str(greenSlider.value()))
blueLineEdit.setText(str(blueSlider.value()))
redLineEdit.returnPressed.connect(lineEditSlot)
greenLineEdit.returnPressed.connect(lineEditSlot)
blueLineEdit.returnPressed.connect(lineEditSlot)
window.show()
exit(app.exec_())
class MovieLayout(QWidget):
def __init__(self, url, movieID, user):
super().__init__()
self.controller = MovieController(url)
self.url = url
self.user = user
self.setWindowTitle("Movie Player")
self.movieID = movieID
# creating a basic vlc instance
self.instance = vlc.Instance()
# creating an empty vlc media player
self.mediaplayer = self.instance.media_player_new()
self.isPaused = True
# self.moviebox = QVBoxLayout()
# self.moviebox.addWidget(self.widget)
# self.widget.setLayout(self.moviebox)
# print("here")
self.videoframe = QFrame()
self.palette = self.videoframe.palette()
self.palette.setColor(QPalette.Window, QColor(0, 0, 0))
self.videoframe.setPalette(self.palette)
self.videoframe.setAutoFillBackground(True)
self.positionslider = QSlider(Qt.Horizontal, self)
self.positionslider.setToolTip("Position")
self.positionslider.setMaximum(1000)
self.positionslider.sliderMoved.connect(self.setPosition)
self.hbuttonbox = QHBoxLayout()
self.playbutton = QPushButton()
self.playbutton.setObjectName("playbutton")
self.hbuttonbox.addWidget(self.playbutton)
result = self.controller.isMovieForUser(self.movieID, self.user.id)
self.stopbutton = QPushButton()
self.stopbutton.setObjectName("stopbutton")
self.hbuttonbox.addWidget(self.stopbutton)
if (isinstance(self.user, Professor) == True and len(result) > 0):
self.numberofViews = result[0][1]
self.description = result[0][0]
self.numofLikes = result[0][2]
self.infoButton = QPushButton("Statistics")
self.hbuttonbox.addWidget(self.infoButton)
self.infoButton.clicked.connect(lambda: self.openStats())
self.stopbutton.clicked.connect(self.Stop)
self.hbuttonbox.addStretch(1)
self.volumeslider = QSlider(Qt.Horizontal, self)
self.volumeslider.setMaximum(100)
self.volumeslider.setValue(self.mediaplayer.audio_get_volume())
self.volumeslider.setToolTip("Volume")
self.hbuttonbox.addWidget(self.volumeslider)
self.volumeslider.valueChanged.connect(self.setVolume)
self.vboxlayout = QVBoxLayout()
self.vboxlayout.addWidget(self.videoframe)
self.vboxlayout.addWidget(self.positionslider)
self.vboxlayout.addLayout(self.hbuttonbox)
status = self.controller.getLikeStatus(self.movieID, self.user.id)
if (status == 0):
self.likeButton = QPushButton("Like")
else:
self.likeButton = QPushButton("DisLike")
self.likeButton.clicked.connect(lambda: self.LikeDislike())
self.comment = QPlainTextEdit()
self.likehbox = QHBoxLayout()
self.comment.setPlaceholderText("Type Comment Here ...")
self.comment.setObjectName("comment")
self.comment.setFixedHeight(50)
self.commentbox = QVBoxLayout()
self.commentSubmit = QPushButton("Comment")
self.commentSubmit.setObjectName("commentSubmit")
self.commentSubmit.setFixedWidth(200)
self.commentSubmit.clicked.connect(lambda: self.submitComment())
self.commentbox.addWidget(self.comment)
self.likehbox.addWidget(self.commentSubmit)
self.likehbox.addWidget(self.likeButton)
self.commentbox.addLayout(self.likehbox)
self.commentSection = QLabel("Comments:")
self.commentSection.setFixedHeight(50)
self.commentSection.setObjectName("commentSection")
self.commentSection.setFixedHeight(30)
self.commentbox.addWidget(self.commentSection)
self.commentSection_comments = QTextEdit("No Comments Yet")
self.commentSection_comments.setObjectName("commentSection_comments")
self.commentSection_comments.setReadOnly(True)
self.commentSection_comments.setFixedHeight(50)
self.commentbox.addWidget(self.commentSection_comments)
self.vboxlayout.addLayout(self.commentbox)
self.setLayout(self.vboxlayout)
self.playbutton.clicked.connect(lambda: self.PlayPause())
self.stopbutton.clicked.connect(lambda: self.Stop())
self.resize(640, 480)
self.timer = QTimer(self)
self.timer.setInterval(500)
self.timer.timeout.connect(self.updateUI)
self.stats = None
self.loaded = False
self.video = pafy.new(self.url)
self.best = self.video.getbest()
self.media = self.instance.media_new(self.best.url)
self.mediaplayer.set_media(self.media)
if sys.platform.startswith('linux'): # for Linux using the X Server
self.mediaplayer.set_xwindow(self.videoframe.winId())
elif sys.platform == "win32": # for Windows
self.mediaplayer.set_hwnd(self.videoframe.winId())
elif sys.platform == "darwin": # for MacOS
self.mediaplayer.set_nsobject(int(self.videoframe.winId()))
self.LoadComments()
def openStats(self):
if (self.stats != None):
del self.stats
result = self.controller.isMovieForUser(self.movieID, self.user.id)
if (isinstance(self.user, Professor) == True and len(result) > 0):
self.numberofViews = result[0][1]
self.description = result[0][0]
self.numofLikes = result[0][2]
self.stats = self.controller.openStatsLayout(self.numberofViews,
self.description,
self.numofLikes)
self.stats.show()
def LikeDislike(self):
if (self.likeButton.text() == "DisLike"):
self.controller.removieLike(self.movieID, self.user.id)
self.likeButton.setText("Like")
elif (self.likeButton.text() == "Like"):
self.controller.LikeMovie(self.movieID, self.user.id)
self.likeButton.setText("DisLike")
def submitComment(self):
if (self.comment.toPlainText() != ""):
result = self.controller.submitComment(self.movieID,
self.comment.toPlainText(),
self.user.username)
if (result == 1):
self.commentSection_comments.setPlainText(
self.user.username + ": " + self.comment.toPlainText() +
"\n" + self.commentSection_comments.toPlainText())
self.comment.setPlainText("")
def LoadComments(self):
comments = self.controller.getComments(self.movieID)
comment = ""
for i in comments:
comment += i[1] + ": " + i[0] + "\n"
self.commentSection_comments.setPlainText(comment)
#Plays and pauses the movie, same button changes status from play to pause
def PlayPause(self):
print("Play Pause")
if (self.loaded == False):
self.loaded = True
if self.mediaplayer.is_playing():
self.mediaplayer.pause()
#self.playbutton.setText("Play")
self.isPaused = True
else:
self.mediaplayer.play()
#self.playbutton.setText("Pause")
self.timer.start()
self.isPaused = False
#stops the movie, unloads it, pressing this requires loading the movie again
def Stop(self):
self.mediaplayer.stop()
#self.playbutton.setText("Play")
#Opens the movie from youtube and sets it in the appropriate layout item to be showcased
#TODO: add and use param (string youtube_url)
def OpenFile(self, filename=None):
self.video = pafy.new(self.url)
self.best = self.video.getbest()
self.media = self.instance.media_new(self.best.url)
self.mediaplayer.set_media(self.media)
if sys.platform.startswith('linux'): # for Linux using the X Server
self.mediaplayer.set_xwindow(self.videoframe.winId())
elif sys.platform == "win32": # for Windows
self.mediaplayer.set_hwnd(self.videoframe.winId())
elif sys.platform == "darwin": # for MacOS
self.mediaplayer.set_nsobject(int(self.videoframe.winId()))
#Changes the volume of the media player
def setVolume(self, Volume):
#Set the volume
self.mediaplayer.audio_set_volume(Volume)
#Sets the position of the video slider, responsible for going to different times in the movie
def setPosition(self, position):
# setting the position to where the slider was dragged
self.mediaplayer.set_position(position / 1000.0)
# the vlc MediaPlayer needs a float value between 0 and 1, Qt
# uses integer variables, so you need a factor; the higher the
# factor, the more precise are the results
# (1000 should be enough)
#function used by timer to keep the movie's time slider indicator in the right position
def updateUI(self):
# setting the slider to the desired position
self.positionslider.setValue(self.mediaplayer.get_position() * 1000)
class VideoWindow(QMainWindow):
def __init__(self, parent=None):
super(VideoWindow, self).__init__(parent)
self.instance = vlc.Instance()
self.mediaPlayer = self.instance.media_list_player_new()
self.instance = vlc.Instance()
self.mediaPlayer = self.instance.media_player_new()
self.setUpGUI()
self.search_window = SearchWindow()
def setUpGUI(self):
self.resize(800, 480)
self.widget = QWidget(self)
self.setCentralWidget(self.widget)
if sys.platform == "darwin":
from PyQt5.QtWidgets import QMacCocoaViewContainer
self.videoframe = QMacCocoaViewContainer(0)
else:
self.videoframe = QFrame()
self.videoframe.mouseDoubleClickEvent = self.openDialog
self.videoframe.mouseReleaseEvent = self.PlayPause
self.palette = self.videoframe.palette()
self.palette.setColor(QPalette.Window, QColor(0, 0, 0))
self.videoframe.setPalette(self.palette)
self.videoframe.setAutoFillBackground(True)
self.videoframe
self.positionSlider = QSlider(Qt.Horizontal, self)
self.positionSlider.setMaximum(1000)
self.positionSlider.sliderMoved.connect(self.setPosition)
self.hboxLayout = QHBoxLayout()
self.hboxLayout.addWidget(self.positionSlider)
self.hboxLayout.setSpacing(0)
self.hboxLayout.setContentsMargins(0, 0, 0, 0)
self.vboxLayout = QVBoxLayout()
self.vboxLayout.addWidget(self.videoframe)
self.vboxLayout.addLayout(self.hboxLayout)
self.vboxLayout.setSpacing(0)
self.vboxLayout.setContentsMargins(0, 0, 0, 0)
self.widget.setLayout(self.vboxLayout)
_open = QAction("&Open", self)
_open.triggered.connect(sys.exit)
try:
_thread.start_new_thread(self.updateUI, ())
except:
print("error with positionSliderThread")
def openDialog(self, event):
self.search_window.hide() if self.search_window.isVisible(
) else self.search_window.show()
self.search_window.start_listener()
def updateUI(self):
while True:
if self.mediaPlayer.is_playing():
self.positionSlider.setValue(self.mediaPlayer.get_position() *
1000)
def setPosition(self, position):
self.mediaPlayer.set_position(position / 1000.0)
def PlayPause(self, event):
if self.mediaPlayer.is_playing():
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def Stop(self):
self.mediaPlayer.stop()
def PlayVideo(self, videoId):
yt_url = URL + videoId
video = pafy.new(yt_url)
best = video.getbest()
playurl = best.url
self.media = self.instance.media_new(playurl)
self.media.get_mrl()
self.mediaPlayer.set_media(self.media)
if sys.platform.startswith('linux'):
self.mediaPlayer.set_xwindow(self.videoframe.winId())
elif sys.platform == "win32":
self.mediaPlayer.set_hwnd(self.videoframe.winId())
elif sys.platform == "darwin":
self.mediaPlayer.set_nsobject(int(self.videoframe.winId()))
self.mediaPlayer.play()
def setVolume(self, Volume):
self.mediaPlayer.audio_set_volume(Volume)
def setup_qr_icon(self):
pixmap = QPixmap('./src/main/resources/qr.jpg')
self.icon.setPixmap(pixmap)
p = self.geometry().bottomRight() - self.icon.geometry().bottomRight(
) - QPoint(100, 100)
self.icon.move(p)
class F(QWidget):
def __init__(self):
super().__init__()
self.setUI()
def setUI(self):
self.setGeometry(500, 400, 500, 600)
self.setWindowTitle("Table")
self.Qf = QFrame(self)
self.Qf.setGeometry(100, 10, 300, 300)
self.Qs = QSlider(Qt.Horizontal, self)
self.Qs.setGeometry(100, 520, 300, 15)
self.pa = self.Qf.palette()
role = self.Qf.backgroundRole()
self.pa.setColor(role, QColor(255, 255, 255))
self.Qf.setPalette(self.pa)
self.Qf.setAutoFillBackground(True)
self.Qs.valueChanged.connect(self.paint)
self.show()
def paint(self):
R = []
G = []
B = []
for i in range(0, 100):
R.append(random.randrange(0, 256))
G.append(random.randrange(0, 256))
B.append(random.randrange(0, 256))
rang = []
jam = []
slideval = self.Qs.value()
for b in range(0, 100):
rang = [R[b], G[b], B[b]]
jam.append(rang)
print(jam)
self.palette = self.Qf.palette()
r = self.Qf.backgroundRole()
if slideval == 0:
self.x = 255
self.y = 255
self.z = 250
self.palette.setColor(r, QColor(self.x, self.y, self.z))
self.Qf.setPalette(self.palette)
self.Qf.setAutoFillBackground(True)
elif slideval == 99:
self.x = 0
self.y = 0
self.z = 0
self.palette.setColor(r, QColor(self.x, self.y, self.z))
self.Qf.setPalette(self.palette)
self.Qf.setAutoFillBackground(True)
else:
self.x, self.y, self.z = jam[slideval]
self.palette.setColor(r, QColor(self.x, self.y, self.z))
self.Qf.setPalette(self.palette)
self.Qf.setAutoFillBackground(True)
class Player(QMainWindow):
"""
A simple Media Player using VLC and Qt
"""
def __init__(self, master=None):
super().__init__()
self.setWindowTitle("CCTV by @XII")
# creating a basic vlc instance
self.instance = vlc.Instance()
# creating an empty vlc media player
self.mediaplayer = self.instance.media_player_new()
self.path = ''
self.initUI()
self.isPaused = False
self.setStyleSheet(open("style.qss", "r").read())
def initUI(self):
"""
Set up the user interface, signals & slots
For better understaning, I made some shortcuts for variables,
which is the instance of the QtWidgets classes.
List of shortcuts(made):
*btn - QPushButton;
*lbl - QLabel;
*slr - QSlider;
*lyt - Q_lyt;
*ctrl - ctrl;
"""
self.widget = QWidget(self)
self.setCentralWidget(self.widget)
#video widget
self.videoframe = QFrame()
self.palette = self.videoframe.palette()
self.palette.setColor(QtGui.QPalette.Window, QtGui.QColor(0, 0, 0))
self.videoframe.setPalette(self.palette)
self.videoframe.setAutoFillBackground(True)
#time value
self.timevalue = QDateTimeEdit()
self.timevalue.setDisplayFormat('hh:mm:ss')
self.timevalue.setReadOnly(True)
self.timevalue.setFixedSize(80, 30)
#position slider
self.position_slr = QSlider(QtCore.Qt.Horizontal, self)
self.position_slr.setToolTip("Position")
self.position_slr.setMaximum(1000)
self.position_slr.sliderMoved.connect(self.set_position)
#play button
self.play_btn = QPushButton()
self.play_btn.setProperty("onplay", True)
self.play_btn.setObjectName("play")
self.play_btn.clicked.connect(self.play_pause)
#stop button
self.stop_btn = QPushButton()
self.stop_btn.setObjectName('stop')
self.stop_btn.clicked.connect(self.stop)
#analyse button
self.analyse_btn = QPushButton('Analyse')
self.analyse_btn.setObjectName('analyse')
self.analyse_btn.setFixedSize(70, 28)
self.analyse_btn.clicked.connect(self.start_analyse)
self.analyse_window = Analyse(self)
self.analyse_window.off()
self.analyse_btn.setEnabled(False)
self.on_analyse = False
self.details_btn = QPushButton('Details')
self.details_btn.setVisible(False)
self.details_btn.setObjectName('details')
self.details_btn.setFixedSize(70, 28)
self.details_btn.clicked.connect(self.show_details)
self.details_wd = pictureViewer()
self.details_wd.close()
self.threadpool = QtCore.QThreadPool()
self.threadpool.setMaxThreadCount(1)
worker = loadModules(self)
self.threadpool.start(worker)
self.path_input = pathLineEdit(self)
self.path_input.setObjectName('path')
self.folder_btn = QPushButton()
self.folder_btn.setObjectName('folder')
self.folder_btn.clicked.connect(
lambda x: self.select_folder(foldername=''))
self.fileslist_lbl = QLabel('Playlist:')
self.fileslist_lbl.setObjectName('lbl')
self.fileslist_lbl.setIndent(12)
self.fileslist = QListWidget()
self.fileslist.itemClicked.connect(self.select_file)
self.warnings_lbl = QLabel('Warnings time:')
self.warnings_lbl.setObjectName('lbl')
self.warnings_lbl.setIndent(12)
self.warningslist = QListWidget()
#volume slider
self.volume_slr = QSlider(QtCore.Qt.Horizontal, self)
self.volume_slr.setMaximum(100)
self.volume_slr.setValue(self.mediaplayer.audio_get_volume())
self.volume_slr.setToolTip("Volume")
self.volume_slr.valueChanged.connect(self.set_volume)
#setting up layouts
folder_lyt = QHBoxLayout()
folder_lyt.addWidget(self.path_input)
folder_lyt.addWidget(self.folder_btn)
leftside_lyt = QVBoxLayout()
leftside_lyt.setContentsMargins(0, 10, 0, 0)
leftside_lyt.addSpacing(6)
leftside_lyt.addWidget(self.fileslist_lbl)
leftside_lyt.addWidget(self.fileslist)
analyse_btns = QHBoxLayout()
analyse_btns.addWidget(self.details_btn)
analyse_btns.addWidget(self.analyse_btn)
leftside_lyt.addLayout(analyse_btns)
leftside_lyt.addWidget(self.warnings_lbl)
leftside_lyt.addWidget(self.warningslist)
leftside_lyt.addLayout(folder_lyt)
leftside_lyt.addSpacing(6)
self.leftside_bg = QWidget()
self.leftside_bg.setObjectName("leftside_bg")
self.leftside_bg.setLayout(leftside_lyt)
ctrl_lyt = QHBoxLayout()
ctrl_lyt.addSpacing(20)
ctrl_lyt.addWidget(self.play_btn)
ctrl_lyt.setSpacing(0)
ctrl_lyt.addWidget(self.stop_btn)
ctrl_lyt.addStretch(1)
ctrl_lyt.addWidget(self.volume_slr)
ctrl_panel_lyt = QVBoxLayout()
ctrl_panel_lyt.setContentsMargins(60, 12, 60, 12)
ctrl_panel_lyt.addWidget(self.timevalue, 0, QtCore.Qt.AlignLeft)
ctrl_panel_lyt.addWidget(self.position_slr)
ctrl_panel_lyt.addLayout(ctrl_lyt)
rightside_lyt = QVBoxLayout()
rightside_lyt.addWidget(self.videoframe)
rightside_lyt.addLayout(ctrl_panel_lyt)
main_lyt = QHBoxLayout()
main_lyt.setSpacing(0)
main_lyt.setContentsMargins(0, 0, 0, 0)
main_lyt.addWidget(self.leftside_bg)
main_lyt.addLayout(rightside_lyt, 60)
self.widget.setLayout(main_lyt)
self.timer = QtCore.QTimer(self)
self.timer.setInterval(200)
self.timer.timeout.connect(self.updateUI)
#creates connection to db
self.db = db_api.create_connection(
os.path.join(os.getcwd(), 'db', 'data.db'))
def play_pause(self):
"""
Toggle play/pause status
"""
if self.mediaplayer.is_playing():
self.mediaplayer.pause()
self.play_btn.setProperty("onplay", True)
self.play_btn.setStyle(self.play_btn.style())
self.isPaused = True
else:
if self.mediaplayer.play() == -1:
return
self.mediaplayer.play()
self.play_btn.setProperty("onplay", False)
self.play_btn.setStyle(self.play_btn.style())
self.timer.start()
self.isPaused = False
def start_analyse(self):
self.analyse_btn.setEnabled(False)
try:
file = self.fileslist.currentItem().text()
except AttributeError:
self.analyse_btn.setEnabled(True)
QMessageBox.information(self, "Warning!",
"You should to select a file.")
return
if not self.on_analyse:
self.setEnabled(False)
self.analyse_window.on()
try:
worker = AnalyseWorker(file, self)
self.threadpool.start(worker)
except Exception as e:
print(e)
else:
return
def show_details(self):
try:
file = self.fileslist.currentItem().text()
except AttributeError:
self.analyse_btn.setEnabled(True)
QMessageBox.information(self, "Warning!",
"You should to select a file.")
return
item = self.fileslist.currentItem().text()
if os.path.isdir(os.path.join('warnings', os.path.splitext(item)[0])):
self.details_wd.show()
self.details_wd.start(self.fileslist.currentItem().text())
else:
return
def stop_analyse(self):
self.analyse_window.off()
self.setEnabled(True)
self.on_analyse = False
def stop(self):
"""
stop player
"""
if self.mediaplayer.is_playing():
self.timevalue.setTime(QtCore.QTime.fromMSecsSinceStartOfDay(0))
self.mediaplayer.stop()
def select_file(self, item):
self.open_file(filename=self.path + '/' + item.text())
def check_warnings_time(self, filename):
with self.db:
file_id = db_api.select_file(self.db, filename)
if file_id:
#if file in db, then add warning times in list bellow
timelist = db_api.select_time(self.db, file_id)
self.warningslist.clear()
for time in timelist:
self.warningslist.addItem(time[0] + "-" + time[1])
self.details_btn.setVisible(True)
else:
self.details_btn.setVisible(False)
self.warningslist.clear()
self.warningslist.addItem("There is nothing to show.")
def open_file(self, filename=''):
"""
Open a media file in a MediaPlayer
"""
if filename == '':
filename = QFileDialog.getOpenFileName(self, "Open File", './')[0]
if not filename:
return
self.check_warnings_time(os.path.split(filename)[1])
# create the media
self.media = self.instance.media_new(filename)
# put the media in the media player
self.mediaplayer.set_media(self.media)
# parse the metadata of the file
self.media.parse_async()
fullpath = re.escape(filename)
# get video duration
time = os.popen("ffmpeg -i {0}".format(fullpath) +
" 2>&1 | grep Duration | awk '{print $2}' | tr -d ,"
).read().split(':')
self.duration = int(3600000 * int(time[0]) + 60000 * int(time[1]) +
1000 * float(time[2]))
# set the title of the track as window title
self.setWindowTitle("CCTV: " + self.media.get_meta(0))
# the media player has to be 'connected' to the QFrame
# (otherwise a video would be displayed in it's own window)
# this is platform specific!
# you have to give the id of the QFrame (or similar object) to
# vlc, different platforms have diffqerent functions for this
if sys.platform == "linux": # for Linux using the X Server
self.mediaplayer.set_xwindow(self.videoframe.winId())
elif sys.platform == "win32": # for Windows
self.mediaplayer.set_hwnd(self.videoframe.winId())
elif sys.platform == "darwin": # for MacOS
self.mediaplayer.set_agl(self.videoframe.windId())
self.play_pause()
def set_volume(self, Volume):
"""
Set the volume
"""
self.mediaplayer.audio_set_volume(Volume)
def set_position(self, position):
"""
Set the position
"""
# setting the position to where the slider was dragged
self.mediaplayer.set_position(position / 1000.0)
# the vlc MediaPlayer needs a float value between 0 and 1, Qt
# uses integer variables, so you need a factor; the higher the
# factor, the more precise are the results
# (1000 should be enough)
self.timevalue.setTime(
QtCore.QTime.fromMSecsSinceStartOfDay(
self.mediaplayer.get_position() * self.duration))
def set_time(self, time):
"""
Set time to display
"""
self.mediaplayer.set_time(time)
def select_folder(self, foldername=''):
if foldername == '':
foldername = str(
QFileDialog.getExistingDirectory(self, "Select Directory"))
self.path_input.setText(foldername)
self.path = foldername
if not foldername:
return
files = os.listdir(foldername)
self.path = foldername
self.fileslist.clear()
for file in files:
self.fileslist.addItem(file)
def updateUI(self):
"""
updates the user interface
"""
# setting the slider to the desired position
self.position_slr.setValue(self.mediaplayer.get_position() * 1000)
self.timevalue.setTime(
QtCore.QTime.fromMSecsSinceStartOfDay(
self.mediaplayer.get_position() * self.duration))
self.volume_slr.setValue(self.mediaplayer.audio_get_volume())
if not self.mediaplayer.is_playing():
# no need to call this function if nothing is played
self.timer.stop()
if not self.isPaused:
# after the video finished, the play button stills shows
# "Pause", not the desired behavior of a media player
# this will fix it
self.stop()
class Player(QMainWindow):
def __init__(self, f=" ", master=None):
QMainWindow.__init__(self, master)
self.setWindowTitle("Media Player")
self.filename = f
self.instance = vlc.Instance()
self.mediaplayer = self.instance.media_player_new()
self.createUI()
self.isPaused = False
def createUI(self):
self.widget = QWidget(self)
self.setCentralWidget(self.widget)
if sys.platform == "darwin": # for MacOS
from PyQt5.QtWidgets import QMacCocoaViewContainer
self.videoframe = QMacCocoaViewContainer(0)
else:
self.videoframe = QFrame()
self.palette = self.videoframe.palette()
self.palette.setColor(QPalette.Window, QColor(0, 0, 0))
self.videoframe.setPalette(self.palette)
self.videoframe.setAutoFillBackground(True)
self.positionslider = QSlider(Qt.Horizontal, self)
self.positionslider.setToolTip("Position")
self.positionslider.setMaximum(1000)
self.positionslider.sliderMoved.connect(self.setPosition)
self.hbuttonbox = QHBoxLayout()
self.playbutton = QPushButton("Play")
self.hbuttonbox.addWidget(self.playbutton)
self.playbutton.clicked.connect(self.PlayPause)
self.stopbutton = QPushButton("Stop")
self.hbuttonbox.addWidget(self.stopbutton)
self.stopbutton.clicked.connect(self.Stop)
self.hbuttonbox.addStretch(1)
self.volumeslider = QSlider(Qt.Horizontal, self)
self.volumeslider.setMaximum(100)
self.volumeslider.setValue(self.mediaplayer.audio_get_volume())
self.volumeslider.setToolTip("Volume")
self.hbuttonbox.addWidget(self.volumeslider)
self.volumeslider.valueChanged.connect(self.setVolume)
self.vboxlayout = QVBoxLayout()
self.vboxlayout.addWidget(self.videoframe)
self.vboxlayout.addWidget(self.positionslider)
self.vboxlayout.addLayout(self.hbuttonbox)
self.widget.setLayout(self.vboxlayout)
open = QAction("&Open", self)
open.triggered.connect(self.OpenFile)
exit = QAction("&Exit", self)
exit.triggered.connect(sys.exit)
menubar = self.menuBar()
filemenu = menubar.addMenu("&File")
filemenu.addAction(open)
filemenu.addSeparator()
filemenu.addAction(exit)
self.timer = QTimer(self)
self.timer.setInterval(200)
self.timer.timeout.connect(self.updateUI)
def PlayPause(self):
if self.mediaplayer.is_playing():
self.mediaplayer.pause()
self.playbutton.setText("Play")
self.isPaused = True
else:
if self.mediaplayer.play() == -1:
self.OpenFile()
return
self.mediaplayer.play()
self.playbutton.setText("Pause")
self.timer.start()
self.isPaused = False
def Stop(self):
self.mediaplayer.stop()
self.playbutton.setText("Play")
def OpenFile(self, filename=None):
self.media = self.instance.media_new(self.filename)
# put the media in the media player
self.mediaplayer.set_media(self.media)
self.media.parse()
self.setWindowTitle(self.media.get_meta(0))
if sys.platform.startswith('linux'): # for Linux using the X Server
self.mediaplayer.set_xwindow(self.videoframe.winId())
elif sys.platform == "win32": # for Windows
self.mediaplayer.set_hwnd(self.videoframe.winId())
elif sys.platform == "darwin": # for MacOS
self.mediaplayer.set_nsobject(int(self.videoframe.winId()))
self.PlayPause()
def setVolume(self, Volume):
self.mediaplayer.audio_set_volume(Volume)
def setPosition(self, position):
self.mediaplayer.set_position(position / 1000.0)
def updateUI(self):
self.positionslider.setValue(self.mediaplayer.get_position() * 1000)
if not self.mediaplayer.is_playing():
self.timer.stop()
if not self.isPaused:
self.Stop()
def initWin(self):
iptGrid = QGridLayout()
title = Text("TSP", (255, 0, 0), 16, "center")
pic = QPixmap("C:\\tsp.png")
picLbl = QLabel()
picLbl.setPixmap(pic)
picLbl.setScaledContents(True)
titleLayout = QVBoxLayout()
titleLayout.addWidget(title)
titleLayout.addWidget(picLbl)
titleFrame = QFrame()
titleFrame.setFrameShape(QFrame.StyledPanel)
titleFrame.setAutoFillBackground(True)
p5 = titleFrame.palette()
p5.setColor(titleFrame.backgroundRole(), QColor(255, 255, 255))
titleFrame.setPalette(p5)
titleFrame.setLayout(titleLayout)
iptTitle = Text("Program Input", (255, 0, 0), 12, "center")
iptTxt1 = QLabel("Cities No:")
iptTxt1.setFont(QFont("Decorative", 12))
iptTxt2 = QLabel("start:")
iptTxt2.setFont(QFont("Decorative", 12))
self.iptEdt1 = QLineEdit()
self.iptEdt1.textChanged[str].connect(self.get_input)
self.iptEdt2 = QLineEdit()
self.iptEdt2.textChanged[str].connect(self.get_input)
self.iptBtn1 = QPushButton("Build")
self.iptBtn1.clicked.connect(self.bulid_map)
self.iptBtn2 = QPushButton("Rturn")
self.iptBtn2.clicked.connect(self.get_initial)
iptH = QHBoxLayout()
iptH.addWidget(self.iptBtn1)
iptH.addWidget(self.iptBtn2)
iptGrid.addWidget(iptTitle, 1, 0, 1, 5)
iptGrid.addWidget(iptTxt1, 2, 0)
iptGrid.addWidget(self.iptEdt1, 2, 1)
iptGrid.addWidget(iptTxt2, 3, 0)
iptGrid.addWidget(self.iptEdt2, 3, 1)
iptGrid.setVerticalSpacing(10)
iptV = QVBoxLayout()
iptV.addLayout(iptGrid)
iptV.addLayout(iptH)
iptFrame = QFrame()
iptFrame.setAutoFillBackground(True)
p6 = iptFrame.palette()
p6.setColor(iptFrame.backgroundRole(), QColor(220, 225, 255))
iptFrame.setPalette(p6)
iptFrame.setFrameShape(QFrame.StyledPanel)
iptFrame.setLayout(iptV)
srgGrid = QGridLayout()
#srgGrid.setVerticalSpacing(10)
srgTitle = Text("Algorithms", (255, 0, 0), 12, "center")
self.srgBtn1 = QPushButton("Genetic")
self.srgBtn1.clicked.connect(self.run_algorithm)
self.srgBtn2 = QPushButton("Simulated")
self.srgBtn2.clicked.connect(self.run_algorithm)
self.srgBtn3 = QPushButton("Tabu")
self.srgBtn3.clicked.connect(self.run_algorithm)
self.srgBtn4 = QPushButton("reset")
self.srgBtn4.clicked.connect(self.reset)
srgGrid.addWidget(srgTitle, 1, 0, 1, 6)
srgGrid.addWidget(self.srgBtn1, 2, 1, 2, 4)
srgGrid.addWidget(self.srgBtn2, 3, 1, 3, 4)
srgGrid.addWidget(self.srgBtn3, 4, 1, 4, 4)
srgGrid.addWidget(self.srgBtn4, 5, 1, 5, 4)
srgFrame = QFrame()
srgFrame.setFrameShape(QFrame.StyledPanel)
srgFrame.setAutoFillBackground(True)
p7 = srgFrame.palette()
p7.setColor(srgFrame.backgroundRole(), QColor(255, 255, 255))
srgFrame.setPalette(p7)
srgFrame.setLayout(srgGrid)
otpGrid = QGridLayout()
otpTitle = Text("Program Output", (255, 0, 0), 12, "center")
otpTxt1 = QLabel("The Cost")
otpTxt1.setFont(QFont("Decorative", 12))
self.lcd1 = QLCDNumber()
otpGrid.addWidget(otpTitle, 1, 0, 1, 2)
otpGrid.addWidget(otpTxt1, 2, 0)
otpGrid.addWidget(self.lcd1, 2, 1)
otpFrame = QFrame()
otpFrame.setFrameShape(QFrame.StyledPanel)
otpFrame.setAutoFillBackground(True)
p8 = otpFrame.palette()
p8.setColor(otpFrame.backgroundRole(), QColor(220, 225, 255))
otpFrame.setPalette(p8)
otpFrame.setLayout(otpGrid)
splitter1 = QSplitter(Qt.Vertical)
splitter1.addWidget(titleFrame)
splitter1.addWidget(iptFrame)
splitter1.setSizes([240, 135])
splitter2 = QSplitter(Qt.Vertical)
splitter2.addWidget(srgFrame)
splitter2.addWidget(otpFrame)
splitter2.setSizes([200, 92])
splitter3 = QSplitter(Qt.Vertical)
splitter3.addWidget(splitter1)
splitter3.addWidget(splitter2)
splitter3.setSizes([382, 291])
splitter3.resize(260, 685)
splitter3.move(1100, 5)
splitter3.setParent(self)
splitter3.setAutoFillBackground(True)
p3 = splitter3.palette()
p3.setColor(splitter3.backgroundRole(), QColor(255, 255, 255))
splitter3.setPalette(p3)
self.mapFrame = QFrame()
self.mapFrame.setFrameShape(QFrame.StyledPanel)
self.mapFrame.move(5, 5)
self.mapFrame.resize(1090, 685)
self.mapFrame.setParent(self)
self.setAutoFillBackground(True)
p2 = self.palette()
p2.setColor(self.backgroundRole(), QColor(0, 0, 0))
self.setPalette(p2)
self.mapFrame.setParent(self)
self.hint = Text("Click the bulid button to bulid a random map",
(255, 0, 0), 23, "center")
self.hint.move(230, 100)
self.hint.setParent(self)
self.setWindowTitle("TSP")
self.width = QDesktopWidget().availableGeometry().width()
self.height = QDesktopWidget().availableGeometry().height() - 40
self.resize(self.width, self.height)
self.show()
self.nodes = {}
self.points = {}
self.flag = True
class Player(QMainWindow):
"""
Modification of the simple Media Player using VLC and Qt
to show the mambo stream
The window part of this example was modified from the QT example cited below.
VLC requires windows to create and show the video and this was a cross-platform solution.
VLC will automatically create the windows in linux but not on the mac.
Amy McGovern, [email protected]
Qt example for VLC Python bindings
https://github.com/devos50/vlc-pyqt5-example
Copyright (C) 2009-2010 the VideoLAN team
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
"""
def __init__(self, vlc_player, drone_gui):
"""
Create a UI window for the VLC player
:param vlc_player: the VLC player (created outside the function)
"""
QMainWindow.__init__(self)
self.setWindowTitle("VLC Tello Video Player")
# save the media player
self.mediaplayer = vlc_player
# need a reference to the main drone vision class
self.drone_vision = drone_gui
# create the GUI
self.createUI()
def createUI(self):
"""
Set up the window for the VLC viewer
"""
self.widget = QWidget(self)
self.setCentralWidget(self.widget)
# In this widget, the video will be drawn
if sys.platform == "darwin": # for MacOS
from PyQt5.QtWidgets import QMacCocoaViewContainer
self.videoframe = QMacCocoaViewContainer(0)
else:
self.videoframe = QFrame()
self.palette = self.videoframe.palette()
self.palette.setColor(QPalette.Window, QColor(0, 0, 0))
self.videoframe.setPalette(self.palette)
self.videoframe.setAutoFillBackground(True)
self.hbuttonbox = QHBoxLayout()
self.playbutton = QPushButton("Run my program")
self.hbuttonbox.addWidget(self.playbutton)
self.playbutton.clicked.connect(
partial(self.drone_vision.run_user_code, self.playbutton))
self.landbutton = QPushButton("Land NOW")
self.hbuttonbox.addWidget(self.landbutton)
self.landbutton.clicked.connect(self.drone_vision.land)
self.stopbutton = QPushButton("Quit")
self.hbuttonbox.addWidget(self.stopbutton)
self.stopbutton.clicked.connect(self.drone_vision.close_exit)
self.vboxlayout = QVBoxLayout()
self.vboxlayout.addWidget(self.videoframe)
self.vboxlayout.addLayout(self.hbuttonbox)
self.widget.setLayout(self.vboxlayout)
# the media player has to be 'connected' to the QFrame
# (otherwise a video would be displayed in it's own window)
# this is platform specific!
# you have to give the id of the QFrame (or similar object) to
# vlc, different platforms have different functions for this
if sys.platform.startswith('linux'): # for Linux using the X Server
self.mediaplayer.set_xwindow(self.videoframe.winId())
elif sys.platform == "win32": # for Windows
self.mediaplayer.set_hwnd(self.videoframe.winId())
elif sys.platform == "darwin": # for MacOS
self.mediaplayer.set_nsobject(int(self.videoframe.winId()))
class StockDialog(QWidget):
def __init__(self, parent=None):
super(StockDialog, self).__init__(parent)
self.setWindowTitle("QT painter")
mainSplitter = QSplitter(Qt.Horizontal)
mainSplitter.setOpaqueResize(True)
frame = QFrame(mainSplitter)
mainLayout = QGridLayout(frame)
# mainLayout.setMargin(10)
mainLayout.setSpacing(6)
label1 = QLabel("形状：")
label2 = QLabel("画笔线宽：")
label3 = QLabel("画笔颜色：")
label4 = QLabel("画笔风格：")
label5 = QLabel("画笔顶端：")
label6 = QLabel("画笔连接点：")
label7 = QLabel("画刷风格：")
label8 = QLabel("画刷颜色：")
self.shapeComboBox = QComboBox()
self.shapeComboBox.addItem("Line", "Line")
self.shapeComboBox.addItem("Rectangle", "Rectangle")
self.shapeComboBox.addItem('Rounded Rectangle', 'Rounded Rectangle')
self.shapeComboBox.addItem('Ellipse', 'Ellipse')
self.shapeComboBox.addItem('Pie', 'Pie')
self.shapeComboBox.addItem('Chord', 'Chord')
self.shapeComboBox.addItem('Path', 'Path')
self.shapeComboBox.addItem('Polygon', 'Polygon')
self.shapeComboBox.addItem('Polyline', 'Polyline')
self.shapeComboBox.addItem('Arc', 'Arc')
self.shapeComboBox.addItem('Points', 'Points')
self.shapeComboBox.addItem('Text', 'Text')
self.shapeComboBox.addItem('Pixmap', 'Pixmap')
self.widthSpinBox = QSpinBox()
self.widthSpinBox.setRange(0, 20)
self.penColorFrame = QFrame()
self.penColorFrame.setAutoFillBackground(True)
self.penColorFrame.setPalette(QPalette(Qt.blue))
self.penColorPushButton = QPushButton("更改")
self.penStyleComboBox = QComboBox()
self.penStyleComboBox.addItem("Solid", Qt.SolidLine)
self.penStyleComboBox.addItem('Dash', Qt.DashLine)
self.penStyleComboBox.addItem('Dot', Qt.DotLine)
self.penStyleComboBox.addItem('Dash Dot', Qt.DashDotLine)
self.penStyleComboBox.addItem('Dash Dot Dot', Qt.DashDotDotLine)
self.penStyleComboBox.addItem('None', Qt.NoPen)
self.penCapComboBox = QComboBox()
self.penCapComboBox.addItem("Flat", Qt.FlatCap)
self.penCapComboBox.addItem('Square', Qt.SquareCap)
self.penCapComboBox.addItem('Round', Qt.RoundCap)
self.penJoinComboBox = QComboBox()
self.penJoinComboBox.addItem("Miter", Qt.MiterJoin)
self.penJoinComboBox.addItem('Bebel', Qt.BevelJoin)
self.penJoinComboBox.addItem('Round', Qt.RoundJoin)
self.brushStyleComboBox = QComboBox()
self.brushStyleComboBox.addItem("Linear Gradient",
Qt.LinearGradientPattern)
self.brushStyleComboBox.addItem('Radial Gradient',
Qt.RadialGradientPattern)
self.brushStyleComboBox.addItem('Conical Gradient',
Qt.ConicalGradientPattern)
self.brushStyleComboBox.addItem('Texture', Qt.TexturePattern)
self.brushStyleComboBox.addItem('Solid', Qt.SolidPattern)
self.brushStyleComboBox.addItem('Horizontal', Qt.HorPattern)
self.brushStyleComboBox.addItem('Vertical', Qt.VerPattern)
self.brushStyleComboBox.addItem('Cross', Qt.CrossPattern)
self.brushStyleComboBox.addItem('Backward Diagonal', Qt.BDiagPattern)
self.brushStyleComboBox.addItem('Forward Diagonal', Qt.FDiagPattern)
self.brushStyleComboBox.addItem('Diagonal Cross', Qt.DiagCrossPattern)
self.brushStyleComboBox.addItem('Dense 1', Qt.Dense1Pattern)
self.brushStyleComboBox.addItem('Dense 2', Qt.Dense2Pattern)
self.brushStyleComboBox.addItem('Dense 3', Qt.Dense3Pattern)
self.brushStyleComboBox.addItem('Dense 4', Qt.Dense4Pattern)
self.brushStyleComboBox.addItem('Dense 5', Qt.Dense5Pattern)
self.brushStyleComboBox.addItem('Dense 6', Qt.Dense6Pattern)
self.brushStyleComboBox.addItem('Dense 7', Qt.Dense7Pattern)
self.brushStyleComboBox.addItem('None', Qt.NoBrush)
self.brushColorFrame = QFrame()
self.brushColorFrame.setAutoFillBackground(True)
self.brushColorFrame.setPalette(QPalette(Qt.green))
self.brushColorPushButton = QPushButton("更改")
labelCol = 0
contentCol = 1
# 建立布局
mainLayout.addWidget(label1, 1, labelCol)
mainLayout.addWidget(self.shapeComboBox, 1, contentCol)
mainLayout.addWidget(label2, 2, labelCol)
mainLayout.addWidget(self.widthSpinBox, 2, contentCol)
mainLayout.addWidget(label3, 4, labelCol)
mainLayout.addWidget(self.penColorFrame, 4, contentCol)
mainLayout.addWidget(self.penColorPushButton, 4, 3)
mainLayout.addWidget(label4, 6, labelCol)
mainLayout.addWidget(self.penStyleComboBox, 6, contentCol)
mainLayout.addWidget(label5, 8, labelCol)
mainLayout.addWidget(self.penCapComboBox, 8, contentCol)
mainLayout.addWidget(label6, 10, labelCol)
mainLayout.addWidget(self.penJoinComboBox, 10, contentCol)
mainLayout.addWidget(label7, 12, labelCol)
mainLayout.addWidget(self.brushStyleComboBox, 12, contentCol)
mainLayout.addWidget(label8, 14, labelCol)
mainLayout.addWidget(self.brushColorFrame, 14, contentCol)
mainLayout.addWidget(self.brushColorPushButton, 14, 3)
mainSplitter1 = QSplitter(Qt.Horizontal)
mainSplitter1.setOpaqueResize(True)
stack1 = QStackedWidget()
stack1.setFrameStyle(QFrame.Panel | QFrame.Raised)
self.area = PaintArea()
stack1.addWidget(self.area)
frame1 = QFrame(mainSplitter1)
mainLayout1 = QVBoxLayout(frame1)
# mainLayout1.setMargin(10)
mainLayout1.setSpacing(6)
mainLayout1.addWidget(stack1)
layout = QGridLayout(self)
layout.addWidget(mainSplitter1, 0, 0)
layout.addWidget(mainSplitter, 0, 1)
self.setLayout(layout)
# 信号和槽函数
self.shapeComboBox.activated.connect(self.slotShape)
self.widthSpinBox.valueChanged.connect(self.slotPenWidth)
self.penColorPushButton.clicked.connect(self.slotPenColor)
self.penStyleComboBox.activated.connect(self.slotPenStyle)
self.penCapComboBox.activated.connect(self.slotPenCap)
self.penJoinComboBox.activated.connect(self.slotPenJoin)
self.brushStyleComboBox.activated.connect(self.slotBrush)
self.brushColorPushButton.clicked.connect(self.slotBrushColor)
self.slotShape(self.shapeComboBox.currentIndex())
self.slotPenWidth(self.widthSpinBox.value())
self.slotBrush(self.brushStyleComboBox.currentIndex())
def slotShape(self, value):
shape = self.area.Shape[value]
self.area.setShape(shape)
def slotPenWidth(self, value):
color = self.penColorFrame.palette().color(QPalette.Window)
style = Qt.PenStyle(
self.penStyleComboBox.itemData(
self.penStyleComboBox.currentIndex(), Qt.UserRole))
cap = Qt.PenCapStyle(
self.penCapComboBox.itemData(self.penCapComboBox.currentIndex(),
Qt.UserRole))
join = Qt.PenJoinStyle(
self.penJoinComboBox.itemData(self.penJoinComboBox.currentIndex(),
Qt.UserRole))
self.area.setPen(QPen(color, value, style, cap, join))
def slotPenStyle(self, value):
self.slotPenWidth(value)
def slotPenCap(self, value):
self.slotPenWidth(value)
def slotPenJoin(self, value):
self.slotPenWidth(value)
def slotPenColor(self):
color = QColorDialog.getColor(Qt.blue)
self.penColorFrame.setPalette(QPalette(color))
self.area.setPen(QPen(color))
def slotBrushColor(self):
color = QColorDialog.getColor(Qt.blue)
self.brushColorFrame.setPalette(QPalette(color))
self.slotBrush(self.brushStyleComboBox.currentIndex())
def slotBrush(self, value):
color = self.brushColorFrame.palette().color(QPalette.Window)
style = Qt.BrushStyle(
self.brushStyleComboBox.itemData(value, Qt.UserRole))
if (style == Qt.LinearGradientPattern):
linearGradient = QLinearGradient(0, 0, 400, 400)
linearGradient.setColorAt(0.0, Qt.white)
linearGradient.setColorAt(0.2, color)
linearGradient.setColorAt(1.0, Qt.black)
self.area.setBrush(linearGradient)
elif style == Qt.RadialGradientPattern:
radialGradient = QRadialGradient(200, 200, 80, 70, 70)
radialGradient.setColorAt(0.0, Qt.white)
radialGradient.setColorAt(0.2, Qt.green)
radialGradient.setColorAt(1.0, Qt.black)
self.area.setBrush(radialGradient)
elif (style == Qt.ConicalGradientPattern):
conicalGradient = QConicalGradient(200, 200, 30)
conicalGradient.setColorAt(0.0, Qt.white)
conicalGradient.setColorAt(0.2, color)
conicalGradient.setColorAt(1.0, Qt.black)
self.area.setBrush(conicalGradient)
elif (style == Qt.TexturePattern):
self.area.setBrush(QBrush(QPixmap("images/brick.png")))
else:
self.area.setBrush(QBrush(color, style))
class HeaderFrame(QFrame):
""" Clickable frame with title. """
class AbstractHeaderFrameItem(QFrame):
def __init__(self, parent):
super(__class__, self).__init__(parent)
self.setContentsMargins(0, 0, 0, 0)
self.setLayout(QHBoxLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self.layout().setSpacing(0)
def clearLayout(self):
while self.layout().count():
child = self.layout().takeAt(0)
if child.widget():
child.widget().deleteLater()
def setCentralWidget(self, widget: QWidget):
self.clearLayout()
self.layout().addWidget(widget)
def refresh(self):
pass
class VSepItem(AbstractHeaderFrameItem):
def __init__(self, parent):
super(__class__, self).__init__(parent)
self.setCentralWidget(VSep(self))
class HSpacerItem(AbstractHeaderFrameItem):
def __init__(self, parent):
super(__class__, self).__init__(parent)
self.setCentralWidget(HSpacer(self))
arrowClicked = pyqtSignal()
upButtonClicked = pyqtSignal()
downButtonClicked = pyqtSignal()
configButtonClicked = pyqtSignal()
closeButtonClicked = pyqtSignal()
def __init__(self, parent: 'ui.widget.CollapsibleFrame'):
super(__class__, self).__init__(parent)
self._parent = parent
self.setMinimumHeight(26)
self.setMaximumHeight(26)
self.indicateError(False)
self._hlayout = QHBoxLayout()
self._hlayout.setContentsMargins(0, 0, 0, 0)
self._hlayout.setSpacing(0)
self._arrow = None
self._hlayout.addWidget(self._init_header_frame(parent.isCollapsed()))
self.setLayout(self._hlayout)
def _init_header_frame(self, collapsed: bool):
self._frm_header = QFrame(self)
self._frm_header.setMinimumHeight(24)
self._frm_header.setMaximumHeight(24)
frm_header_layout = QHBoxLayout(self)
frm_header_layout.setContentsMargins(0, 0, 0, 0)
frm_header_layout.addWidget(self._init_arrow(collapsed))
background_color = self._frm_header.palette().color(self._frm_header.backgroundRole())
self._frm_header.setStyleSheet("QFrame { border:0px; background:" + background_color.darker(96).name() + "; }")
self._frm_header.setLayout(frm_header_layout)
return self._frm_header
def _init_arrow(self, collapsed):
self._arrow = CollapsibleFrame.Arrow(self, collapsed=collapsed)
self._arrow.setMinimumWidth(24)
self._arrow.setMaximumWidth(24)
self._arrow.setStyleSheet("border:0px")
return self._arrow
def addWidget(self, header_item: AbstractHeaderFrameItem):
self._frm_header.layout().addWidget(header_item)
def refresh(self):
""" Refreshes the header model (e.g. line-count, character-count, etc.). """
for i in range(self._frm_header.layout().count()):
widget = self._frm_header.layout().itemAt(i).widget()
if isinstance(widget, CollapsibleFrame.HeaderFrame.AbstractHeaderFrameItem):
widget.refresh()
def indicateError(self, status: bool):
""" Indicates an error by painting the title-border red. Otherweise black. """
if status:
self.setStyleSheet("QFrame { border:1px solid red; }")
else:
self.setStyleSheet("QFrame { border:1px solid rgb(41, 41, 41); }")
def mouseReleaseEvent(self, event):
if self.underMouse() and event.button() == QtCore.Qt.LeftButton:
# The arrow (or something non-button like) was clicked
self.arrowClicked.emit()
return super(CollapsibleFrame.HeaderFrame, self).mousePressEvent(event)
class Player(QMainWindow):
"""A simple Media Player using VLC and Qt
"""
def __init__(self, master=None):
QMainWindow.__init__(self, master)
self.setWindowTitle("Media Player")
self.isAudio = False
# creating a basic vlc instance
self.instance = vlc.Instance()
# creating an empty vlc media player
self.mediaplayer = self.instance.media_player_new()
self.createUI()
self.isPaused = False
def createUI(self):
"""Set up the user interface, signals & slots
"""
self.widget = QWidget(self)
self.setCentralWidget(self.widget)
# In this widget, the video will be drawn
if sys.platform == "darwin": # for MacOS
from PyQt5.QtWidgets import QMacCocoaViewContainer
self.videoframe = QMacCocoaViewContainer(0)
else:
self.videoframe = QFrame()
self.palette = self.videoframe.palette()
self.palette.setColor(QPalette.Window, QColor(0, 0, 0))
self.videoframe.setPalette(self.palette)
self.videoframe.setAutoFillBackground(True)
self.positionslider = QSlider(Qt.Horizontal, self)
self.positionslider.setToolTip("Position")
self.positionslider.setMaximum(1000)
self.positionslider.sliderMoved.connect(self.setPosition)
self.hbuttonbox = QHBoxLayout()
self.playbutton = QPushButton("►")
self.hbuttonbox.addWidget(self.playbutton)
self.playbutton.clicked.connect(self.PlayPause)
self.stopbutton = QPushButton("⯀")
self.hbuttonbox.addWidget(self.stopbutton)
self.stopbutton.clicked.connect(self.Stop)
self.audiobutton = QPushButton("𝅘𝅥")
self.hbuttonbox.addWidget(self.audiobutton)
self.audiobutton.setToolTip(
"Switch to audio only mode\n(must search again)")
self.audiobutton.clicked.connect(self.AudioVideo)
self.hbuttonbox.addStretch(1)
self.volumeslider = QSlider(Qt.Horizontal, self)
self.volumeslider.setMaximum(100)
self.volumeslider.setValue(self.mediaplayer.audio_get_volume())
self.volumeslider.setToolTip("Volume")
self.hbuttonbox.addWidget(self.volumeslider)
self.volumeslider.valueChanged.connect(self.setVolume)
self.hbuttonbox2 = QHBoxLayout()
self.searchline = QLineEdit()
self.hbuttonbox2.addWidget(self.searchline)
self.searchline.setToolTip("Enter search term here")
self.searchbutton = QPushButton("Search")
self.hbuttonbox2.addWidget(self.searchbutton)
self.searchbutton.setToolTip("Press to search")
self.searchbutton.clicked.connect(self.searchYouTube)
self.searchresult = QHBoxLayout()
#adding QListWidget to the layout causes the video frame
#to disappear and im not sure why
#self.searchresults = QListWidget(self)
#self.searchresult.addWidget(self.searchresults)
#self.searchresults.addItem("testing1")
#self.searchresults.addItem("testing2")
self.vboxlayout = QVBoxLayout()
self.vboxlayout.addWidget(self.videoframe)
self.vboxlayout.addWidget(self.positionslider)
self.vboxlayout.addLayout(self.hbuttonbox)
self.vboxlayout.addLayout(self.hbuttonbox2)
#self.vboxlayout.addLayout(self.searchresult)
self.widget.setLayout(self.vboxlayout)
open = QAction("&Open", self)
open.triggered.connect(lambda: self.OpenFile())
exit = QAction("&Exit", self)
exit.triggered.connect(sys.exit)
download = QAction("&Download", self)
download.triggered.connect(self.downloadFile)
menubar = self.menuBar()
filemenu = menubar.addMenu("&File")
filemenu.addAction(open)
filemenu.addSeparator()
filemenu.addAction(exit)
filemenu.addSeparator()
filemenu.addAction(download)
self.timer = QTimer(self)
self.timer.setInterval(200)
self.timer.timeout.connect(self.updateUI)
def AudioVideo(self):
"""Toggle whether a video is shown or just audio.
requires another search to take effect"""
if self.isAudio == False:
self.isAudio = True
self.audiobutton.setText("🎥")
self.audiobutton.setToolTip(
"Switch to video only mode\n(must search again)")
else:
self.isAudio = False
self.audiobutton.setText("𝅘𝅥")
self.audiobutton.setToolTip(
"Switch to audio only mode\n(must search again)")
def PlayPause(self):
"""Toggle play/pause status
"""
if self.mediaplayer.is_playing():
self.mediaplayer.pause()
self.playbutton.setText("►")
self.isPaused = True
else:
if self.mediaplayer.play() == -1:
self.searchYouTube()
return
self.mediaplayer.play()
self.playbutton.setText("❚❚")
self.timer.start()
self.isPaused = False
def Stop(self):
"""Stop player
"""
self.mediaplayer.stop()
self.playbutton.setText("►")
def OpenFile(self, filename=None):
"""Open a media file in a MediaPlayer
"""
if filename is None:
filename = QFileDialog.getOpenFileName(self, "Open File",
os.path.expanduser('~'))[0]
if not filename:
return
# create the media
if sys.version < '3':
filename = unicode(filename)
self.media = self.instance.media_new(filename)
# put the media in the media player
self.mediaplayer.set_media(self.media)
# parse the metadata of the file
self.media.parse()
# set the title of the track as window title
self.setWindowTitle(self.media.get_meta(0))
# the media player has to be 'connected' to the QFrame
# (otherwise a video would be displayed in it's own window)
# this is platform specific!
# you have to give the id of the QFrame (or similar object) to
# vlc, different platforms have different functions for this
if sys.platform.startswith('linux'): # for Linux using the X Server
self.mediaplayer.set_xwindow(self.videoframe.winId())
elif sys.platform == "win32": # for Windows
self.mediaplayer.set_hwnd(self.videoframe.winId())
elif sys.platform == "darwin": # for MacOS
self.mediaplayer.set_nsobject(int(self.videoframe.winId()))
self.PlayPause()
def searchYouTube(self):
"""Search YouTube with search term and play top video"""
searchTerm = self.searchline.text()
self.searchline.clear()
searchTerm = searchTerm.replace(" ", "+") #For formatting
#request youtube search results and web scrape information
r = requests.get("https://www.youtube.com/results?search_query=" +
searchTerm)
page = r.text
soup = bs(page, 'html.parser')
vids = soup.findAll('a', attrs={'class': 'yt-uix-tile-link'})
self.titlelist = []
self.videolist = []
#create a list with all the links and titles of youtube videos
for v in vids:
tmp = 'https://www.youtube.com' + v['href']
self.videolist.append(tmp)
self.titlelist.append(v['title'])
#currently only the top video will play
url_0 = self.videolist[0]
#use pafy to convert into a VLC playable video
self.video_0 = pafy.new(url_0)
#chooses whether to get video or audio only
if self.isAudio:
self.best = self.video_0.getbestaudio()
else:
self.best = self.video_0.getbest()
#play in VLC
playurl = self.best.url
self.media = self.instance.media_new(playurl)
self.media.get_mrl()
self.mediaplayer.set_media(self.media)
if sys.platform.startswith('linux'): # for Linux using the X Server
self.mediaplayer.set_xwindow(self.videoframe.winId())
elif sys.platform == "win32": # for Windows
self.mediaplayer.set_hwnd(self.videoframe.winId())
elif sys.platform == "darwin": # for MacOS
self.mediaplayer.set_nsobject(int(self.videoframe.winId()))
self.setWindowTitle(self.titlelist[0])
self.PlayPause()
def setVolume(self, Volume):
"""Set the volume
"""
self.mediaplayer.audio_set_volume(Volume)
def setPosition(self, position):
"""Set the position
"""
# setting the position to where the slider was dragged
self.mediaplayer.set_position(position / 1000.0)
# the vlc MediaPlayer needs a float value between 0 and 1, Qt
# uses integer variables, so you need a factor; the higher the
# factor, the more precise are the results
# (1000 should be enough)
def downloadFile(self):
"""downloads the file currently playing, .mp4 for video or .webm for audio
settings can be altered but are left default for now"""
self.best.download()
def updateUI(self):
"""updates the user interface"""
# setting the slider to the desired position
self.positionslider.setValue(self.mediaplayer.get_position() * 1000)
if not self.mediaplayer.is_playing():
# no need to call this function if nothing is played
self.timer.stop()
if not self.isPaused:
# after the video finished, the play button stills shows
# "Pause", not the desired behavior of a media player
# this will fix it
self.Stop()
class GraphicalInterface(QMainWindow, Interface):
def __init__(self, video_player, debug=False):
self.__app = QApplication(sys.argv)
super().__init__()
self.__video_player = video_player
#TODO get in .config the value of the volume by default
self.__video_player.set_volume(100)
# Property of the main window
self.__width = 0
self.__height = 0
# List of all derivated object from the following QWidgets
self.__palette = None
self.__logo_image = None
self.__previousbtn_image = None
self.__skipbtn_image = None
self.__playbtn_image = None
self.__pausebtn_image = None
# List of all the QWidget present in the main window
self.__videotitle = None
self.__searchbtn = None
self.__searchbar = None
self.__mainbox = None
self.__modebox = None
self.__logo = None
self.__video_reader = None
self.__previousbtn_audio = None
self.__playbtn_audio = None
self.__skipbtn_audio = None
self.__previousbtn_video = None
self.__playbtn_video = None
self.__skipbtn_video = None
self.__buttonbar_video = None
# List of all the GraphicalObject in the main window
self.__header = None
self.__footer = None
self.__body = None
self.__gr_videotitle = None
self.__gr_searchbar = None
self.__gr_searchbtn = None
self.__gr_modebox = None
self.__gr_logo = None
self.__gr_video_reader = None
self.__gr_buttonbar_video = None
self.__gr_previousbtn_audio = None
self.__gr_playbtn_audio = None
self.__gr_skipbtn_audio = None
self.__gr_previousbtn_video = None
self.__gr_playbtn_video = None
self.__gr_skipbtn_video = None
self.__object_list = []
self.__debug = debug
def main(self):
"""
Main loop of the graphic interface
"""
self.resize(640, 480)
self.move(0, 0)
self.setWindowTitle('Youtube Reader')
self.setWindowIcon(QIcon('resources/icon.svg'))
content = read_css("./css/main.css")
self.setStyleSheet(content)
self.__mainbox = GraphicalObject(self,
width=640,
height=480,
pos_x=0,
pos_y=0)
self.__header = GraphicalObject(None,
width=100,
height=10,
pos_x=0,
pos_y=0,
parent=self.__mainbox)
self.__searchbar = QLineEdit(self)
self.__searchbar.returnPressed.connect(self.handle_research)
self.__gr_searchbar = GraphicalObject(self.__searchbar,
width=70,
height=60,
pos_x=15,
pos_y=20,
parent=self.__header)
self.__searchbtn = QPushButton('Search', self)
self.__searchbtn.clicked.connect(self.handle_research)
self.__gr_searchbtn = GraphicalObject(self.__searchbtn,
width=10,
height=60,
pos_x=87,
pos_y=20,
parent=self.__header)
self.__logo_image = QPixmap('resources/logo.png')
self.__logo = QLabel(self)
self.__logo.setScaledContents(True)
self.__logo.setPixmap(self.__logo_image)
self.__gr_logo = GraphicalObject(self.__logo,
width=15,
height=60,
pos_x=0,
pos_y=20,
parent=self.__header)
self.__body = GraphicalObject(None,
width=100,
height=80,
pos_x=0,
pos_y=10,
parent=self.__mainbox)
self.create_reader()
self.set_player_mode(self.__video_player.get_mode())
self.__footer = GraphicalObject(None,
width=100,
height=10,
pos_x=0,
pos_y=90,
parent=self.__mainbox)
self.__modebox = ComboDemo(self, self)
self.__modebox.init_combo_box(self.__video_player.get_mode())
self.__gr_modebox = GraphicalObject(self.__modebox,
width=20,
height=100,
pos_x=80,
pos_y=20,
parent=self.__footer)
self.show()
self.__app.exec_()
self.__video_player.stop_stream()
def handle_research(self):
my_string = self.__searchbar.text()
self.__searchbar.clear()
if "www.youtube.com/" in my_string:
self.__video_player.add_url(my_string)
else:
print("Search functionnality not implemented yet. Put url please!")
def create_reader(self):
# code from github.com/devos50/vlc-pyqt5-example.git
# Video UI
if sys.platform == "darwin":
from PyQt5.QtWidgets import QMacCocoaViewContainer
self.__video_reader = QMacCocoaViewContainer(0)
else:
self.__video_reader = QFrame(self)
self.__palette = self.__video_reader.palette()
self.__palette.setColor(QPalette.Window, QColor(0, 0, 0))
self.__video_reader.setPalette(self.__palette)
self.__video_reader.setAutoFillBackground(True)
self.__gr_video_reader = GraphicalObject(self.__video_reader,
width=80,
height=80,
pos_x=10,
pos_y=10,
parent=self.__body)
self.__videotitle = QLabel("No Video!", self)
self.__videotitle.setWordWrap(True)
self.__gr_videotitle = GraphicalObject(self.__videotitle,
width=80,
height=10,
pos_x=10,
pos_y=90,
parent=self.__body)
number_of_button = 3
btn_height = 7
btn_width = 7
ui_origin_x = 0
ui_origin_y = 100 - btn_height
self.__buttonbar_video = QLabel(self)
self.__buttonbar_video.setStyleSheet(
"QLabel { background-color : white; color : blue; }")
self.__gr_buttonbar_video = GraphicalObject(
self.__buttonbar_video,
width=100,
height=btn_height,
pos_x=0,
pos_y=ui_origin_y,
parent=self.__gr_video_reader)
self.__previousbtn_video = TranslucidButton(self)
self.__previousbtn_image = QPixmap('resources/back.svg')
self.__previousbtn_video.setScaledContents(True)
self.__previousbtn_video.setPixmap(self.__previousbtn_image)
self.__gr_previousbtn_video = GraphicalObject(
self.__previousbtn_video,
width=btn_width,
height=btn_height,
pos_x=ui_origin_x + 0 * btn_width,
pos_y=ui_origin_y,
parent=self.__gr_video_reader)
self.__skipbtn_video = TranslucidButton(self)
self.__skipbtn_image = QPixmap('resources/skip.svg')
self.__skipbtn_video.setScaledContents(True)
self.__skipbtn_video.setPixmap(self.__skipbtn_image)
self.__gr_skipbtn_video = GraphicalObject(
self.__skipbtn_video,
width=btn_width,
height=btn_height,
pos_x=ui_origin_x + 2 * btn_width,
pos_y=ui_origin_y,
parent=self.__gr_video_reader)
self.__playbtn_video = TranslucidButton(self)
self.__playbtn_video.clicked.connect(self.video_play_pause)
self.__playbtn_image = QPixmap('resources/play.svg')
self.__playbtn_video.setScaledContents(True)
self.__playbtn_video.setPixmap(self.__playbtn_image)
self.__gr_playbtn_video = GraphicalObject(
self.__playbtn_video,
width=btn_width,
height=btn_height,
pos_x=ui_origin_x + 1 * btn_width,
pos_y=ui_origin_y,
parent=self.__gr_video_reader)
# Audio UI
number_of_button = 3
btn_height = 5
btn_width = 10
ui_origin_x = 30
ui_origin_y = 50 - (btn_height / 2)
self.__previousbtn_audio = QPushButton('Previous', self)
#clicked.connect(self.handle_research)
self.__gr_previousbtn_audio = GraphicalObject(
self.__previousbtn_audio,
width=btn_width,
height=btn_height,
pos_x=ui_origin_x + (0 *
(100 - 2 * ui_origin_x)) / number_of_button,
pos_y=ui_origin_y,
parent=self.__body)
self.__playbtn_audio = QPushButton('Play', self)
self.__playbtn_audio.clicked.connect(self.audio_play_pause)
self.__gr_playbtn_audio = GraphicalObject(
self.__playbtn_audio,
width=btn_width,
height=btn_height,
pos_x=ui_origin_x + (1 *
(100 - 2 * ui_origin_x)) / number_of_button,
pos_y=ui_origin_y,
parent=self.__body)
self.__skipbtn_audio = QPushButton('Skip', self)
self.__skipbtn_audio.clicked.connect(self.__video_player.skip)
self.__gr_skipbtn_audio = GraphicalObject(
self.__skipbtn_audio,
width=btn_width,
height=btn_height,
pos_x=ui_origin_x + (2 *
(100 - 2 * ui_origin_x)) / number_of_button,
pos_y=ui_origin_y,
parent=self.__body)
def set_player_mode(self, value):
self.__video_player.set_mode(value)
if value == 'Video':
self.__video_reader.show()
self.__previousbtn_audio.hide()
self.__playbtn_audio.hide()
self.__skipbtn_audio.hide()
else:
self.__video_reader.hide()
self.__previousbtn_audio.show()
self.__playbtn_audio.show()
self.__skipbtn_audio.show()
def end_of_play_list(self):
print("End of stream")
self.__palette.setColor(QPalette.Window, QColor(0, 0, 0))
self.__video_reader.setPalette(self.__palette)
def update_title(self, title):
self.__videotitle.setText(title)
def audio_play_pause(self):
if self.__video_player.is_running():
self.pause_start()
else:
self.__playbtn_audio.setText('Pause')
self.__video_player.play_stream()
def video_play_pause(self):
print("Play pause")
if self.__video_player.is_running():
self.pause_start()
else:
print("Launching the stream")
if sys.platform.startswith(
'linux'): # for Linux using the X Server
self.__video_player.get_player().set_xwindow(
self.__video_reader.winId())
elif sys.platform == "win32": # for Windows
self.__video_player.get_player().set_hwnd(
self.__video_reader.winId())
elif sys.platform == "darwin": # for MacOS
self.__video_player.get_player().set_nsobject(
int(self.__video_reader.winId()))
#TODO LAPALETTE
self.__video_player.play_stream()
if self.__video_player.is_playing():
self.__palette.setColor(QPalette.Window, QColor(255, 255, 255))
self.__video_reader.setPalette(self.__palette)
self.__video_reader.setAutoFillBackground(True)
def pause_start(self):
if self.__video_player.is_paused():
print("Unpausing the player")
self.__playbtn_audio.setText('Pause')
self.__video_player.resume_stream()
elif self.__video_player.is_playing():
print("Pausing the player")
self.__playbtn_audio.setText('Play')
self.__video_player.pause_stream()
else:
print("Restarting the stream")
self.__playbtn_audio.setText('Pause')
self.__video_player.play_stream()
# Redefinition of the QMainWindow built-in methods
def mousePressEvent(self, event):
# Left click
if event.button() == 1:
if ((event.x() <= (self.__gr_video_reader.getRealWidth() +
self.__gr_video_reader.getRealPosX()))
and (event.x() >= self.__gr_video_reader.getRealPosX())
and (event.y() <= (self.__gr_video_reader.getRealHeight() +
self.__gr_video_reader.getRealPosY()))
and (event.y() >= self.__gr_video_reader.getRealPosY())
and self.__video_player.get_mode() == 'Video'):
print("True")
if self.__video_player.is_running():
self.pause_start()
else:
print("Launching the stream")
if sys.platform.startswith(
'linux'): # for Linux using the X Server
self.__video_player.get_player().set_xwindow(
self.__video_reader.winId())
elif sys.platform == "win32": # for Windows
self.__video_player.get_player().set_hwnd(
self.__video_reader.winId())
elif sys.platform == "darwin": # for MacOS
self.__video_player.get_player().set_nsobject(
int(self.__video_reader.winId()))
#TODO LAPALETTE
self.__video_player.play_stream()
if self.__video_player.is_playing():
self.__palette.setColor(QPalette.Window,
QColor(255, 255, 255))
self.__video_reader.setPalette(self.__palette)
self.__video_reader.setAutoFillBackground(True)
print("Plop X " + str(event.x()) + " Plop Y " + str(event.y()))
print("Glob X " + str(event.globalX()) + " Glob Y " +
str(event.globalY()))
def resizeEvent(self, event):
print("OLD height: " + str(event.oldSize().height()) + " width: " +
str(event.oldSize().width()))
print("NEW height: " + str(event.size().height()) + " width: " +
str(event.oldSize().width()))
self.__width = event.size().width()
self.__height = event.size().height()
self.__mainbox.resize(event.size().width(), event.size().height())
class Ui_VideoWindow(QMainWindow):
Duration = 0
Position = 0
"""A simple Media Player using VLC and Qt
"""
def __init__(self, master=None):
QMainWindow.__init__(self, master)
self.setWindowFlags(QtCore.Qt.CustomizeWindowHint)
self.photo_label = QtWidgets.QLabel(self)
self.photo_label.setAlignment(QtCore.Qt.AlignCenter)
self.photo_label.setGeometry(QtCore.QRect(0, 0, 1024, 631))
self.photo_label.setText("")
self.photo_label.setObjectName("photo_label")
self.photo_label.hide()
self.photo_label.setStyleSheet("QLabel {background-color: black}")
self.setWindowTitle("Media Player")
#QMainWindow.resize(1024, 600)
# creating a basic vlc instance
self.instance = vlc.Instance()
# creating an empty vlc media player
self.mediaplayer = self.instance.media_player_new()
self.resize(1080, 600)
self.createUI()
self.isPaused = False
def createUI(self):
"""Set up the user interface, signals & slots
"""
self.widget = QWidget(self)
self.setCentralWidget(self.widget)
# In this widget, the video will be drawn
if sys.platform == "darwin": # for MacOS
from PyQt5.QtWidgets import QMacCocoaViewContainer
self.videoframe = QMacCocoaViewContainer(0)
else:
self.videoframe = QFrame()
self.palette = self.videoframe.palette()
self.palette.setColor(QPalette.Window, QColor(0, 0, 0))
self.videoframe.setPalette(self.palette)
self.videoframe.setAutoFillBackground(True)
self.label = QtWidgets.QLabel(self.videoframe)
#self.label.setGeometry(QtCore.QRect(0, 0, 1024, 631))
self.label.setText("")
self.label.setScaledContents(True)
self.label.setObjectName("label")
# self.positionslider = QSlider(Qt.Horizontal, self)
# self.positionslider.setToolTip("Position")
# self.positionslider.setMaximum(1000)
# self.positionslider.sliderMoved.connect(self.setPosition)
#
# self.hbuttonbox = QHBoxLayout()
# self.playbutton = QPushButton("Play")
# self.hbuttonbox.addWidget(self.playbutton)
# self.playbutton.clicked.connect(self.PlayPause)
#
# self.stopbutton = QPushButton("Stop")
# self.hbuttonbox.addWidget(self.stopbutton)
# self.stopbutton.clicked.connect(self.Stop)
#
# self.hbuttonbox.addStretch(1)
# self.volumeslider = QSlider(Qt.Horizontal, self)
# self.volumeslider.setMaximum(100)
# self.volumeslider.setValue(self.mediaplayer.audio_get_volume())
# self.volumeslider.setToolTip("Volume")
# self.hbuttonbox.addWidget(self.volumeslider)
# self.volumeslider.valueChanged.connect(self.setVolume)
self.vboxlayout = QVBoxLayout()
self.vboxlayout.setContentsMargins(0, 0, 0, 0)
self.videoframe.setStyleSheet(
"background: black; border: 0px; padding: 0px;")
self.vboxlayout.addWidget(self.videoframe)
# self.vboxlayout.addWidget(self.positionslider)
# self.vboxlayout.addLayout(self.hbuttonbox)
self.widget.setLayout(self.vboxlayout)
# open = QAction("&Open", self)
# open.triggered.connect(self.OpenFile)
# exit = QAction("&Exit", self)
# exit.triggered.connect(sys.exit)
# menubar = self.menuBar()
# filemenu = menubar.addMenu("&File")
# #filemenu.addAction(open)
# filemenu.addSeparator()
# filemenu.addAction(exit)
self.timer = QTimer(self)
self.timer.setInterval(200)
self.timer.timeout.connect(self.updateUI)
def PlayPause(self):
"""Toggle play/pause status
"""
if self.mediaplayer.is_playing():
self.mediaplayer.pause()
self.playbutton.setText("Play")
self.isPaused = True
else:
if self.mediaplayer.play() == -1:
#self.OpenFile()
# self.media = self.instance.media_new("/home/pi/Downloads/data/data/Content/DJVHHUAY.mp4")
# # put the media in the media player
# self.mediaplayer.set_media(self.media)
#
# # parse the metadata of the file
# self.media.parse()
# # set the title of the track as window title
# self.setWindowTitle(self.media.get_meta(0))
#
# self.mediaplayer.set_xwindow(self.videoframe.winId())
# self.PlayPause()
return
self.mediaplayer.play()
self.playbutton.setText("Pause")
self.timer.start()
self.isPaused = False
def Stop(self):
"""Stop player
"""
self.mediaplayer.stop()
self.playbutton.setText("Play")
# def OpenFile(self, filename=None):
# """Open a media file in a MediaPlayer
# """
# if filename is None:
# filename = QFileDialog.getOpenFileName(self, "Open File", os.path.expanduser('~'))[0]
# if not filename:
# return
#
# # create the media
# if sys.version < '3':
# filename = unicode(filename)
# self.media = self.instance.media_new(filename)
# # put the media in the media player
# self.mediaplayer.set_media(self.media)
#
# # parse the metadata of the file
# self.media.parse()
# # set the title of the track as window title
# self.setWindowTitle(self.media.get_meta(0))
#
# # the media player has to be 'connected' to the QFrame
# # (otherwise a video would be displayed in it's own window)
# # this is platform specific!
# # you have to give the id of the QFrame (or similar object) to
# # vlc, different platforms have different functions for this
# if sys.platform.startswith('linux'): # for Linux using the X Server
# self.mediaplayer.set_xwindow(self.videoframe.winId())
# elif sys.platform == "win32": # for Windows
# self.mediaplayer.set_hwnd(self.videoframe.winId())
# elif sys.platform == "darwin": # for MacOS
# self.mediaplayer.set_nsobject(int(self.videoframe.winId()))
# self.PlayPause()
def Path(self, PATH2):
#PATH2 = "/home/pi/Downloads/data/data/Content/DJVHHUAY.mp4"
self.mediaplayer.set_media(self.instance.media_new(PATH2))
self.mediaplayer.set_xwindow(self.videoframe.winId())
def setVolume(self, Volume):
"""Set the volume
"""
self.mediaplayer.audio_set_volume(Volume)
def setPosition(self, position):
"""Set the position
"""
# setting the position to where the slider was dragged
self.mediaplayer.set_position(position / 15)
# the vlc MediaPlayer needs a float value between 0 and 1, Qt
# uses integer variables, so you need a factor; the higher the
# factor, the more precise are the results
# (1000 should be enough)
def updateUI(self):
"""updates the user interface"""
# setting the slider to the desired position
self.positionslider.setValue(self.mediaplayer.get_position() * 1000)
# position = (self.mediaplayer.get_position()* 1000)
# print("position", position)
# Length = self.mediaplayer.get_length()
# print("Length", Length)
if not self.mediaplayer.is_playing():
# no need to call this function if nothing is played
self.timer.stop()
if not self.isPaused:
# after the video finished, the play button stills shows
# "Pause", not the desired behavior of a media player
# this will fix it
self.Stop()
