def __init__(self):
super(mainWindow, self).__init__()
#setup tray
self.trayIcon = SystemTrayIcon(self)
traySignal = "activated(QSystemTrayIcon::ActivationReason)"
QtCore.QObject.connect(self.trayIcon, QtCore.SIGNAL(traySignal), self.__icon_activated)
#instance class ( second thread call in first thread)
#start from first thread
self.vcdx = vietcodex()
#self.vcdx.mainWin = self #reference instance
self.elearning = Elearning(parent=self.vcdx) #instance vietcode before
#receive data from second thread
self.vcdx.updateText.connect(self._handleTextUpdate)
self.vcdx.invokeCallback.connect(self._handle_callback)
#first to send data (start thread)
self.vcdx.update_list("testing send data for updating ui",None)
#init thread to invoke callback
self.vcdx.call_func(None)
#move this object to thread
#self.objThread = QtCore.QThread()
#self.moveToThread(self.objThread) #note Widgets cannot be moved to a new thread
self.initUI()
#init
self.init()
class mainWindow(QtGui.QMainWindow): #QWidget
title = "VietcodeX.com"
def _handleTextUpdate(self,_str):
#print _str
#_str.mainWin=self
self.log(_str)
pass
def _handle_callback(self,func):
if hasattr(func, '__call__'):
func()
print "invoke function"
pass
def __init__(self):
super(mainWindow, self).__init__()
#setup tray
self.trayIcon = SystemTrayIcon(self)
traySignal = "activated(QSystemTrayIcon::ActivationReason)"
QtCore.QObject.connect(self.trayIcon, QtCore.SIGNAL(traySignal), self.__icon_activated)
#instance class ( second thread call in first thread)
#start from first thread
self.vcdx = vietcodex()
#self.vcdx.mainWin = self #reference instance
self.elearning = Elearning(parent=self.vcdx) #instance vietcode before
#receive data from second thread
self.vcdx.updateText.connect(self._handleTextUpdate)
self.vcdx.invokeCallback.connect(self._handle_callback)
#first to send data (start thread)
self.vcdx.update_list("testing send data for updating ui",None)
#init thread to invoke callback
self.vcdx.call_func(None)
#move this object to thread
#self.objThread = QtCore.QThread()
#self.moveToThread(self.objThread) #note Widgets cannot be moved to a new thread
self.initUI()
#init
self.init()
def __icon_activated(self,reason):
if reason == QtGui.QSystemTrayIcon.DoubleClick:
self.show() #show window when hit double mouse click on icon
pass
"""
write log
"""
def log(self,_str):
def setLog():
if isinstance(self.logOutput,QtGui.QTextEdit):
#self.logOutput.setText(self.logOutput.toHtml() + "\n" + str(_str))
self.logOutput.append(str(_str))
self.logOutput.verticalScrollBar().setValue(self.logOutput.verticalScrollBar().maximum())
#thread.start_new_thread(setLog,()) #can' run thread on thread
setLog()
"""
f=open("log.txt","w") #create new file
f.truncate()
f.write(str)
f.close()
"""
"""
current window close event, override method
"""
def closeEvent(self, event):
#msg = QtGui.QMessageBox.question(self, 'Thong bao',
# "App still running, see window tray", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
"""
if msg == QtGui.QMessageBox.Ok:
event.accept()
else:
event.ignore()
"""
if False:#self.okayToClose():
#user asked for exit
self.trayIcon.hide()
event.accept()
else:
#"minimize"
self.hide()
self.trayIcon.show() #thanks @mojo
event.ignore()
"""
destroy everthing before quit app keep nginx server
"""
def stopEverything(self):
### ffmpeg
#stop server also stop stream
self.vcdx.stop_stream()
#stop ffmpeg thread
if hasattr(self, 'startffmpeg_thread'):
self.startffmpeg_thread.stop()
#self.check_ffmpeg_thread.terminate() #can use this
### red5
self.vcdx.stop_red5_server()
if hasattr(self,'startRed5_thread'):
self.startRed5_thread.stop() #stop startRed5 server thread
#you still want keepping nginx server
#verify livestream server
self.check_to_go_livestream_client_website()
pass
"""
start red5 live stream server
"""
def _start_stream_server(self):
self.btn_startMedia_server.setDisabled(True)
self.btn_stopMedia_server.setDisabled(False)
self.btn_startMedia_server.setText("working..")
def _callback(msg):
self.log( "startRed5_thread finished...exiting")
pass
"""
self.red5_Thread = MyThread1()#
self.startRed5_thread=hQtObject()
self.startRed5_thread.add_job = self.vcdx.start_red5_server
self.startRed5_thread.moveToThread(self.red5_Thread)
self.startRed5_thread.finished.connect(self.red5_Thread.quit)
self.red5_Thread.started.connect(self.startRed5_thread.longRunning)
self.red5_Thread.finished.connect(_callback)
self.red5_Thread.start()
"""
#stop thread if found
if hasattr(self,'startRed5_thread'):
self.startRed5_thread.stop() #stop startRed5 server thread
#i don't know but _broadcast_livestream use this way. Because i switch to above code my stream nerver start successful
self.startRed5_thread = StoppableThread(target=self.vcdx.start_red5_server,args = (10, ))
self.startRed5_thread.start()
#self.startRed5_thread.join()
#self.log( "startRed5_thread finished...exiting") #nerver meet, long running
#thread.start_new_thread(self.vcdx.start_red5_server, (False,_callback))
def _start_red5():
time.sleep(5) #CHECK for 5 seconds
self.btn_startMedia_server.setDisabled(False) #this menu alway enable
if len(myFuncs.get_pid_by_commandline("org.red5.server.Bootstrap","java.exe"))==0:
self.menu_item_red5_start_Action.setEnabled(True)
self.btn_stopMedia_server.setDisabled(True)
#myFuncs.msgBox(self,"Error to create stream.")
self.vcdx.log ("\nUnable to start Red5, do it again.")
#do not call self.log method
else:
self.menu_item_red5_start_Action.setEnabled(False)
self.btn_stopMedia_server.setDisabled(False)
self.btn_startMedia_server.setText("Start media server")
pass
self.check_red5_thread = MyThread1()
self.red5_thread=hQtObject()
self.red5_thread.add_job = _start_red5
self.red5_thread.moveToThread(self.check_red5_thread)
self.check_red5_thread.trigger.connect(self.pdialog)
self.check_red5_thread.finished.connect(self.check_red5_thread.quit)
self.check_red5_thread.started.connect(self.red5_thread.longRunning)
#self.objThread.finished.connect(_callback)
self.check_red5_thread.start()
"""
stop media server
"""
def _stop_stream_server(self,event):
#self.vcdx.start_red5_server()
reply = QtGui.QMessageBox.question(self, self.title,
"Turn off red5 server?", QtGui.QMessageBox.Yes |
QtGui.QMessageBox.No, QtGui.QMessageBox.No)
if reply == QtGui.QMessageBox.Yes:
self.stop_stream_server()
pass
def stop_stream_server(self):
self.btn_startMedia_server.setDisabled(False)
self.menu_item_red5_start_Action.setEnabled(True)
self.btn_stopMedia_server.setDisabled(True)
self.btn_stopStream.setDisabled(True) #also stop stream
self.btn_startStream.setDisabled(False)
stopRed5_thread = threading.Thread(target=self.stopEverything)
stopRed5_thread.start()
#stopRed5_thread.join()
self.log("Stop red5 thread " )
pass
"""
check red5 server status
"""
def red5_server_status_event(self):
def check_netstat():
time.sleep(3)
pids = myFuncs.get_pid_by_commandline("org.red5.server.Bootstrap","java.exe")
if len(pids)>0:
self.vcdx.log("Exists stream server")
self.btn_stopMedia_server.setEnabled(True)
else:
self.vcdx.log("Not found stream server")
self.menu_item_red5_start_Action.setEnabled(True)
self.btn_stopMedia_server.setEnabled(False)
pass
#self.vcdx.do_method(check_netstat) #do not put heavy task
thread.start_new_thread(check_netstat, ())
self.vcdx.log( "red5 server checking...")
pass
"""
stream status check
"""
def ffmpeg_stream_status_event(self):
def check_netstat():
time.sleep(3)
pids = myFuncs.get_pid_by_name("ffmpeg.exe")
if len(pids)>0:
self.vcdx.log("Exists live stream")
self.btn_stopStream.setEnabled(True)
else:
self.vcdx.log("Not found live stream")
self.menu_item_broadcast_stream_Action.setEnabled(True)
self.btn_stopStream.setEnabled(False)
pass
#self.vcdx.do_method(check_netstat) #do not put heavy task
thread.start_new_thread(check_netstat, ())
self.vcdx.log( "live stream checking...")
pass
"""
nginx status checker
"""
def nginx_status_event(self):
def check_netstat():
time.sleep(3)
pids = myFuncs.get_pid_by_name("nginx.exe")
if len(pids)>0:
self.vcdx.log("nginx server started.")
self.btn_stopNginx.setEnabled(True)
else:
self.vcdx.log("nginx has not started.")
self.menu_item_nginx_Action.setEnabled(True)
self.btn_stopNginx.setEnabled(False)
pass
#self.vcdx.do_method(check_netstat) #do not put heavy task
thread.start_new_thread(check_netstat, ())
self.vcdx.log( "nginx state checking...")
pass
"""
when start all threads
"""
def pdialog(self):
print "pdialog"
if hasattr(self, 'end__broadcast_livestream_thread') and self.end__broadcast_livestream_thread:
self.check_ffmpeg_thread.terminate()
if hasattr(self, 'end__start_stream_server_thread') and self.end__start_stream_server_thread:
self.check_red5_thread.terminate()
pass
if hasattr(self, 'end__start_nginx_thread') and self.end__start_nginx_thread:
self.check_nginx_thread.terminate()
pass
pass
"""
start _broadcast_livestream thread
"""
def _broadcast_livestream_thread(self):
self.end__broadcast_livestream_thread = True
self._broadcast_livestream()
pass
"""
start _start_nginx thread
"""
def _start_nginx_thread(self):
self.end__start_nginx_thread = True
self._start_nginx()
pass
"""
start _start_stream_server thread
"""
def _start_stream_server_thread(self):
self.end__start_stream_server_thread = True
self._start_stream_server()
pass
"""
start boardcast live stream to server
"""
def _broadcast_livestream(self):
self.btn_startStream.setDisabled(True) #disable start stream button
self.btn_startStream.setText("working..")
self.btn_stopStream.setDisabled(True) #enable stop stream button
#heavy job
def start_ffmpeg():
time.sleep(7) #CHECK for 5 seconds
if len(myFuncs.get_pid_by_name("ffmpeg.exe"))==0:
self.btn_startStream.setDisabled(False)
self.btn_stopStream.setDisabled(True)
#myFuncs.msgBox(self,"Error to create stream.")
self.vcdx.log ("\nUnable to create stream, check Red5 server for ready\nYou can restart Red5 server or restart live stream more times (up to 3).")
#do not call self.log method
else:
self.btn_startStream.setDisabled(False) #this menu alway enable
self.menu_item_broadcast_stream_Action.setEnabled(False)
self.btn_stopStream.setDisabled(False)
self.btn_startStream.setText("Start stream")
pass
#thread.start_new_thread(self.vcdx.start_screencast_ffmpeg,())
self.startffmpeg_thread = StoppableThread(target=self.vcdx.start_screencast_ffmpeg,args=())
self.startffmpeg_thread.start()
#check ffmpeg already
if hasattr(self, 'check_ffmpeg_thread')==True: #and self.check_ffmpeg_thread.isRunning():
#self.check_ffmpeg_thread.exit()
#self.check_ffmpeg_thread.terminate()
pass
self.check_ffmpeg_thread = MyThread1()
self.ffmpeg_thread=hQtObject()
self.ffmpeg_thread.add_job = start_ffmpeg
self.ffmpeg_thread.moveToThread(self.check_ffmpeg_thread)
self.check_ffmpeg_thread.trigger.connect(self.pdialog)
self.check_ffmpeg_thread.finished.connect(self.check_ffmpeg_thread.quit)
self.check_ffmpeg_thread.started.connect(self.ffmpeg_thread.longRunning)
#self.objThread.finished.connect(_callback)
self.check_ffmpeg_thread.start()
#check_ffmpeg_thread = StoppableThread(target=start_ffmpeg,args=())
#self.moveToThread(check_ffmpeg_thread)
#check_ffmpeg_thread.start()
#thread.start_new_thread(start_ffmpeg,())
pass
"""
stop boardcast live stream
"""
def _stop_broadcast_livestream(self,event=None):
reply = QtGui.QMessageBox.question(self, self.title,
"Turn off live stream ?", QtGui.QMessageBox.Yes |
QtGui.QMessageBox.No, QtGui.QMessageBox.No)
if reply == QtGui.QMessageBox.Yes:
self.stop_broadcast_livestream()
pass
def stop_broadcast_livestream(self):
self.btn_stopStream.setDisabled(True)
self.menu_item_broadcast_stream_Action.setEnabled(True)
self.btn_startStream.setDisabled(False)
stopffmpeg_thread = threading.Thread(target=self.vcdx.stop_stream)
stopffmpeg_thread.start()
if hasattr(self, 'startffmpeg_thread'):
self.startffmpeg_thread.stop() #end thread for ffmpeg
pass
"""
start nginx server
"""
def _start_nginx(self):
self.btn_startNginx.setDisabled(True)
self.btn_stopNginx.setDisabled(False)
self.btn_startNginx.setText("working..")
def start_nginx():
self.vcdx.nginx_server(True) #start nginx with thread wrapper
pass
self.start_nginx_thread = StoppableThread(target=start_nginx ,args=())
self.start_nginx_thread.start()
def _start_nginx_server():
time.sleep(3) #CHECK for 3 seconds
self.btn_startNginx.setDisabled(False) #this menu alway enable
if len(myFuncs.get_pid_by_name("nginx.exe"))==0:
self.menu_item_nginx_Action.setEnabled(True)
self.btn_stopNginx.setDisabled(True)
#myFuncs.msgBox(self,"Error to create stream.")
self.vcdx.log ("\nUnable to start Nginx server, do it again.")
#do not call self.log method
else:
self.menu_item_nginx_Action.setEnabled(False)
self.btn_startNginx.setDisabled(False)
self.btn_startNginx.setText("Start nginx")
pass
self.check_nginx_thread = MyThread1()
self.nginx_thread=hQtObject()
self.nginx_thread.add_job = _start_nginx_server
self.nginx_thread.moveToThread(self.check_nginx_thread)
self.check_nginx_thread.trigger.connect(self.pdialog)
self.check_nginx_thread.finished.connect(self.check_nginx_thread.quit)
self.check_nginx_thread.started.connect(self.nginx_thread.longRunning)
#self.objThread.finished.connect(_callback)
self.check_nginx_thread.start()
pass
"""
stop nginx server
"""
def _stop_nginx(self,event):
reply = QtGui.QMessageBox.question(self, self.title,
"Stop nginx server ?", QtGui.QMessageBox.Yes |
QtGui.QMessageBox.No, QtGui.QMessageBox.No)
if reply == QtGui.QMessageBox.Yes:
self.btn_startNginx.setDisabled(False)
self.menu_item_nginx_Action.setEnabled(True)
self.btn_stopNginx.setDisabled(True)
self.vcdx.nginx_server(False)
if hasattr(self, 'start_nginx_thread'):
self.start_nginx_thread.stop()
pass
"""
bootstrap
"""
def init(self):
#valid red5.properties
self.vcdx.modify_red5_properties()
#make sure server, livestream, nginx are working
status= self.verify_servers4livestream()
#check red5 server for ready
#red5_pid = myFuncs.get_pid_by_commandline("org.red5.server.Bootstrap","java.exe")
if status['red5']:
self.menu_item_red5_start_Action.setEnabled(False)
self.btn_stopMedia_server.setDisabled(False)
else:
self.menu_item_red5_start_Action.setEnabled(True)
self.btn_stopMedia_server.setDisabled(True)
#check ffmpeg stream
#ffmpeg_pids = myFuncs.get_pid_by_name("ffmpeg.exe")
if status['ffmpeg']:
self.menu_item_broadcast_stream_Action.setEnabled(False)
self.btn_stopStream.setDisabled(False)
else:
self.menu_item_broadcast_stream_Action.setEnabled(True)
self.btn_stopStream.setDisabled(True)
#check nginx server for ready
#nginx = myFuncs.get_pid_by_name("nginx.exe")
if status['nginx']:
self.menu_item_nginx_Action.setEnabled(False)
self.btn_stopNginx.setDisabled(False)
else:
self.menu_item_nginx_Action.setEnabled(True)
self.btn_stopNginx.setDisabled(True)
if status['red5'] and status['ffmpeg'] :#and status['nginx']: #we dont use nginx
self.btn_go_site.setEnabled(True)
else:
#self.btn_go_site.setEnabled(False) #no, shoulh click to check
pass
pass
"""
help dialog
"""
def view_help_button_event(self,event):
if hasattr(self, 'help')==False:
self.help=hwDlgHelp(self)
self.help.show()
self.help.raise_()
pass
"""
go local site for playing live stream
"""
def go_livestream_client_website(self):
self.btn_go_site.setEnabled(False) #disable while processing
self.btn_go_site.setText("checking...")
thread.start_new_thread(self.check_to_go_livestream_client_website, ())
pass
"""
kill all servers for live streaming
"""
def kill_all_livestream(self):
reply = QtGui.QMessageBox.question(self, self.title,
"Are you sure to kill all servers?", QtGui.QMessageBox.Yes |
QtGui.QMessageBox.No, QtGui.QMessageBox.No)
def force_kill():
self.stopEverything()
###force
#find out pid for java.exe with red5 arguments
red5_pid = myFuncs.get_pid_by_commandline("org.red5.server.Bootstrap","java.exe")
if len(red5_pid):
self.vcdx.killprocess(red5_pid)
pass
if reply == QtGui.QMessageBox.Yes:
thread.start_new_thread( force_kill,())
else:
pass
pass
"""
check whether all server,emit livestream,apache are working
"""
def verify_servers4livestream(self):
#check red5 server for ready
red5_pid = myFuncs.get_pid_by_commandline("org.red5.server.Bootstrap","java.exe")
#check ffmpeg stream
ffmpeg_pids = myFuncs.get_pid_by_name("ffmpeg.exe")
#check nginx server for ready
nginx = myFuncs.get_pid_by_name("nginx.exe")
#make sure server, livestream, nginx are working
return {"red5":len(red5_pid), "ffmpeg": len(ffmpeg_pids), "nginx": len(nginx)}
"""
create go_livestream_client_website thread
"""
def check_to_go_livestream_client_website(self):
import webbrowser
#make sure server, livestream, nginx are working
status = self.verify_servers4livestream()
if status['red5'] and status['ffmpeg'] : #and status['nginx']: #do not need nginx server
#store processor local IP on database
self.elearning.storeLocalIP()
self.elearning.activeElearning_site("1") #active client site
webbrowser.open(self.elearning.livestream_client_site)
else:
self.vcdx.log("No any servers found, \nYou need to start necessary servers before go elearning site.")
self.elearning.activeElearning_site("0")
self.btn_go_site.setEnabled(True) #enable button
self.btn_go_site.setText("Go E-Learning Site") #resume button label
pass
"""
open task manager
"""
def open_processes_manager(self):
#from subprocess import Popen
process = os.startfile('third-party\ProcessExplorer\procexp.exe')
pass
"""
init UI controls
"""
def initUI(self):
"""
exitAction = QtGui.QAction(QtGui.QIcon('images/icon_menu_left.png'), '&Exit', self)
exitAction.setShortcut('Ctrl+Q')
exitAction.setStatusTip('Exit application')
exitAction.setToolTip("heloos<b>dfsdf</b>")
exitAction.triggered.connect(QtGui.qApp.quit)
"""
self.central_widget = QtGui.QWidget()
self.setCentralWidget(self.central_widget)
"""
init buttons
"""
#connect button
self.btn_startMedia_server = QtGui.QPushButton('Start media Server')
self.btn_startMedia_server.setToolTip('Start livestream server')
#btn.resize(btn.sizeHint())
red5_menu = QtGui.QMenu()
self.menu_item_red5_start_Action = QtGui.QAction(QtGui.QIcon(''), '&Start', self)
self.menu_item_red5_start_Action.triggered.connect(self._start_stream_server_thread)
#menu.addAction('Start', self._broadcast_livestream_thread)
red5_menu.addAction(self.menu_item_red5_start_Action)
red5_menu.addAction('Check exists', self.red5_server_status_event)
self.btn_startMedia_server.setMenu(red5_menu)
#self.btn_startMedia_server.clicked.connect(self._start_stream_server)
#stop media server
self.btn_stopMedia_server = QtGui.QPushButton('Stop media Server')
self.btn_stopMedia_server.setToolTip('Stop livestream server')
self.btn_stopMedia_server.clicked.connect(self._stop_stream_server)
#broadcast screen
self.btn_startStream = QtGui.QPushButton('Start stream')
self.btn_startStream.setToolTip('Broadcast live stream to server')
#self.btn_startStream.clicked.connect(self._broadcast_livestream)
stream_menu = QtGui.QMenu()
self.menu_item_broadcast_stream_Action = QtGui.QAction(QtGui.QIcon(''), '&Start', self)
self.menu_item_broadcast_stream_Action.triggered.connect(self._broadcast_livestream_thread)
#menu.addAction('Start', self._broadcast_livestream_thread)
stream_menu.addAction(self.menu_item_broadcast_stream_Action)
stream_menu.addAction('Check exists', self.ffmpeg_stream_status_event)
self.btn_startStream.setMenu(stream_menu)
#stop broadcast screen
self.btn_stopStream = QtGui.QPushButton('Stop stream')
self.btn_stopStream.setToolTip('Stop Broadcast live stream to server')
self.btn_stopStream.clicked.connect(self._stop_broadcast_livestream)
#start nginx server
self.btn_startNginx = QtGui.QPushButton('Start nginx')
self.btn_startNginx.setToolTip('Start nginx server')
#self.btn_startNginx.clicked.connect(self._start_nginx)
#self.btn_startNginx.setEnabled(False) #never use this button
nginx_menu = QtGui.QMenu()
self.menu_item_nginx_Action = QtGui.QAction(QtGui.QIcon(''), '&Start nginx', self)
self.menu_item_nginx_Action.triggered.connect(self._start_nginx_thread)
nginx_menu.addAction(self.menu_item_nginx_Action)
nginx_menu.addAction('Check exists', self.nginx_status_event)
self.btn_startNginx.setMenu(nginx_menu)
#start nginx server
self.btn_stopNginx = QtGui.QPushButton('Stop nginx')
self.btn_stopNginx.setToolTip('Stop nginx server')
self.btn_stopNginx.clicked.connect(self._stop_nginx)
#self.btn_stopNginx.setEnabled(False) #never use this button
self.lbl_status = QtGui.QLabel('@Copyright Vietcodex.edu.vn')
#self.lbl_status.move(15, 10)
#log output
self.logOutput = QtGui.QTextBrowser(self) #QTextEdit
self.logOutput.setReadOnly(True)
#self.logOutput.setLineWrapMode(QtGui.QTextBrowser.wordWrapMode())
#self.logOutput.setText("hello")
#self.logOutput.setText(self.logOutput.toHtml() +"\ndfgdhfg")
#hoang.txtLog = self.logOutput #reference log output handle
#guide tip
lbl_tip = QtGui.QLabel()
lbl_tip.setText(myFuncs.readFileContent('data/guide_tip.txt'))
#help button
btn_help = QtGui.QPushButton()
btn_help.setText("HUONG DAN")
btn_help.clicked.connect(self.view_help_button_event)
#kill all servers
self.btn_kill_livestream = QtGui.QPushButton()
self.btn_kill_livestream.setText("Kill servers")
self.btn_kill_livestream.clicked.connect(self.kill_all_livestream)
#go class button
self.btn_go_site= QtGui.QPushButton()
self.btn_go_site.setText("Active E-Learing site")
self.btn_go_site.clicked.connect(self.go_livestream_client_website)
#self.btn_go_site.setEnabled(False)
#open ProcessExplorer program
self.btn_open_procexp = QtGui.QPushButton()
self.btn_open_procexp.setText("Task manager")
self.btn_open_procexp.clicked.connect(self.open_processes_manager)
#-------------------Layout----------------------
vbox_left = QtGui.QVBoxLayout()
vbox_left.addStretch(1)
vbox_left.addWidget(self.btn_startMedia_server)
vbox_left.addWidget(self.btn_stopMedia_server)
vbox_left.addWidget(self.btn_startStream)
vbox_left.addWidget(self.btn_stopStream)
vbox_left.addWidget(self.btn_startNginx)
vbox_left.addWidget(self.btn_stopNginx)
vbox_left.addWidget(self.lbl_status) #status
#hbox.addWidget(exitAction)
vbox_right = QtGui.QVBoxLayout()
vbox_right.addStretch(1)
vbox_right.addWidget(self.logOutput)
hbox = QtGui.QHBoxLayout()
hbox.addStretch(1)
hbox.addLayout(vbox_left)
hbox.addLayout(vbox_right)
mvbox = QtGui.QVBoxLayout()
mvbox.addStretch(1)
#horizontal box to hold buttons
hbox_buttons = QtGui.QHBoxLayout()
mvbox.addLayout(hbox_buttons)
hbox_buttons.addWidget(btn_help)
hbox_buttons.addWidget(self.btn_kill_livestream)
hbox_buttons.addWidget(self.btn_open_procexp)
hbox_buttons.addWidget(self.btn_go_site)
mvbox.addWidget(lbl_tip)
mvbox.addLayout(hbox)
self.central_widget.setLayout(mvbox)
QtGui.QToolTip.setFont(QtGui.QFont('tahoma', 10))
#self.statusBar().showMessage('sdfsfldhgdfhgoshdposg')
#self.setLayout(self.central_widget)
#self.toolbar1 = self.addToolBar('Exit')
#self.toolbar1.addAction(exitAction)
#menubar = self.menuBar()
#fileMenu = menubar.addMenu('&File')
#fileMenu.addAction(exitAction)
#status bar
localip = socket.gethostbyname(socket.gethostname())
self.statusBar().showMessage("IP: " +localip+ " | Network:" + myFuncs.get_current_network())
self.setGeometry(300, 300, 400, 150)
self.setWindowTitle(self.title)
icon = QtGui.QIcon((':icons/icon.ico'))
#set window icon
self.setWindowIcon(icon)
self.resize(400, 200)
self.center()
self.show()
"""
def getpid(self,process_name):
import os
return [item.split()[1] for item in os.popen('tasklist').read().splitlines()[4:] if process_name in item.split()]
def runCmd(self):
import subprocess
from subprocess import call
import os
#call("cmd")
#call(["CURL HTTP://localhost"], shell=True)
#print subprocess.check_output(["red5-shutdown.bat"],shell=True)
# you can convert batch file to exe or run red5 as service
print self.getpid("cmd.exe")
#print subprocess.check_output(["red5.bat"],shell=True)
#print subprocess.check_output(["red5-shutdown.bat"],shell=True)
#other way
from subprocess import Popen
#p = Popen("red5-shutdown.bat")
#stdout, stderr = p.communicate()
import os
#t=os.system('curl http://localhost')
#print t
pass
"""
def api(self):
import httplib
self.runCmd()
"""
h=httplib.HTTPConnection("localhost","80")
#load url
h.request("GET","/1.php") #(method,path)
r=h.getresponse()
for x in r.getheaders():
print "%s:%s"%x
"""
def clickEvent1(self,event):
#QtCore.QCoreApplication.instance().quit
import thread
import threading
thread.start_new_thread(self.api,())
pass
def center(self):
qr = self.frameGeometry()
cp = QtGui.QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
