class VideoMediaView(MediaView):
def __init__(self, media, parent):
super(VideoMediaView, self).__init__(media, parent)
self._widget = QWidget(parent)
self._process = QProcess(self._widget)
self._process.setObjectName('%s-process' % self.objectName())
self._std_out = []
self._errors = []
self._stopping = False
self._mute = False
if 'mute' in self._options:
self._mute = bool(int(self._options['mute']))
self._widget.setGeometry(media['_geometry'])
self.connect(self._process, SIGNAL("error()"), self._process_error)
self.connect(self._process, SIGNAL("finished()"), self.stop)
self.connect(self._process, SIGNAL("readyReadStandardOutput()"),
self.__grep_std_out)
self.set_default_widget_prop()
self._stop_timer = QTimer(self)
self._stop_timer.setSingleShot(True)
self._stop_timer.setInterval(1000)
self._stop_timer.timeout.connect(self._force_stop)
@Slot()
def _force_stop(self):
os.kill(self._process.pid(), signal.SIGTERM)
self._stopping = False
if not self.is_started():
self.started_signal.emit()
super(VideoMediaView, self).stop()
@Slot(object)
def _process_error(self, err):
self._errors.append(err)
self.stop()
@Slot()
def play(self):
self._finished = 0
path = "%s/%s" % (self._save_dir, self._options['uri'])
self._widget.show()
args = [
'-slave', '-identify', '-input',
'nodefault-bindings:conf=/dev/null', '-wid',
str(int(self._widget.winId())), path
]
if self._mute:
args += ['-ao', 'null']
self._process.start('mplayer', args)
self._stop_timer.start()
@Slot()
def stop(self, delete_widget=False):
if self._stopping or self.is_finished():
return False
self._stop_timer.start()
self._stopping = True
if self._process.state() == QProcess.ProcessState.Running:
self._process.write("quit\n")
self._process.waitForFinished(50)
self._process.close()
super(VideoMediaView, self).stop(delete_widget)
self._stopping = False
self._stop_timer.stop()
return True
@Slot()
def __grep_std_out(self):
lines = self._process.readAllStandardOutput().split("\n")
for line in lines:
if not line.isEmpty():
if line.startsWith("Starting playback"):
self._widget.raise_()
self._play_timer.start()
self.started_signal.emit()
self._stop_timer.stop()
else:
part = line.split("=")
if 'ID_LENGTH' == part[0]:
if float(
self._duration
) > 0: # user set the video duration manually.
self._play_timer.setInterval(
int(1000 * float(self._duration)))
else: # use duration found by mplayer.
self._play_timer.setInterval(
int(1000 * float(part[1])))
class CfdConsoleProcess:
""" Class to run a console process asynchronously, printing output and
errors to the FreeCAD console and allowing clean termination in Linux
and Windows """
def __init__(self, finishedHook=None, stdoutHook=None, stderrHook=None):
self.process = QProcess()
self.finishedHook = finishedHook
self.stdoutHook = stdoutHook
self.stderrHook = stderrHook
self.process.finished.connect(self.finished)
self.process.readyReadStandardOutput.connect(self.readStdout)
self.process.readyReadStandardError.connect(self.readStderr)
self.print_next_error_lines = 0
self.print_next_error_file = False
def __del__(self):
self.terminate()
def start(self, cmd, env_vars=None, working_dir=None):
""" Start process and return immediately """
self.print_next_error_lines = 0
self.print_next_error_file = False
env = QtCore.QProcessEnvironment.systemEnvironment()
if env_vars:
for key in env_vars:
env.insert(key, env_vars[key])
self.process.setProcessEnvironment(env)
if working_dir:
self.process.setWorkingDirectory(working_dir)
if platform.system() == "Windows":
# Run through a wrapper process to allow clean termination
cmd = [
os.path.join(FreeCAD.getHomePath(), "bin", "python.exe"),
'-u', # Prevent python from buffering stdout
os.path.join(os.path.dirname(__file__), "WindowsRunWrapper.py")
] + cmd
print("Raw command: ", cmd)
self.process.start(cmd[0], cmd[1:])
def terminate(self):
if platform.system() == "Windows":
# terminate() doesn't operate and kill() doesn't allow cleanup and leaves mpi processes running
# Instead, instruct wrapper program to kill child process and itself cleanly with ctrl-break signal
self.process.write(b"terminate\n")
self.process.waitForBytesWritten() # 'flush'
else:
self.process.terminate()
self.process.waitForFinished()
def finished(self, exit_code):
if self.finishedHook:
self.finishedHook(exit_code)
def readStdout(self):
# Ensure only complete lines are passed on
text = ""
while self.process.canReadLine():
byteArr = self.process.readLine()
text += QTextStream(byteArr).readAll()
if text:
print(text, end='') # Avoid displaying on FreeCAD status bar
if self.stdoutHook:
self.stdoutHook(text)
# Must be at the end as it can cause re-entrance
if FreeCAD.GuiUp:
FreeCAD.Gui.updateGui()
def readStderr(self):
# Ensure only complete lines are passed on
# Print any error output to console
self.process.setReadChannel(QProcess.StandardError)
text = ""
while self.process.canReadLine():
byteArr = self.process.readLine()
text += QTextStream(byteArr).readAll()
if text:
if self.stderrHook:
self.stderrHook(text)
FreeCAD.Console.PrintError(text)
# Must be at the end as it can cause re-entrance
if FreeCAD.GuiUp:
FreeCAD.Gui.updateGui()
self.process.setReadChannel(QProcess.StandardOutput)
def state(self):
return self.process.state()
def waitForStarted(self):
return self.process.waitForStarted()
def waitForFinished(self):
# For some reason waitForFinished doesn't always return - so we resort to a failsafe timeout:
while True:
ret = self.process.waitForFinished(1000)
if self.process.error() != self.process.Timedout:
self.readStdout()
self.readStderr()
return ret
if self.process.state() == self.process.NotRunning:
self.readStdout()
self.readStderr()
return True
def exitCode(self):
return self.process.exitCode()
def processErrorOutput(self, err):
"""
Process standard error text output from OpenFOAM
:param err: Standard error output, single or multiple lines
:return: A message to be printed on console, or None
"""
ret = ""
errlines = err.split('\n')
for errline in errlines:
if len(errline) > 0: # Ignore blanks
if self.print_next_error_lines > 0:
ret += errline + "\n"
self.print_next_error_lines -= 1
if self.print_next_error_file and "file:" in errline:
ret += errline + "\n"
self.print_next_error_file = False
words = errline.split(' ',
1) # Split off first field for parallel
FATAL = "--> FOAM FATAL ERROR"
FATALIO = "--> FOAM FATAL IO ERROR"
if errline.startswith(FATAL) or (len(words) > 1 and
words[1].startswith(FATAL)):
self.print_next_error_lines = 1
ret += "OpenFOAM fatal error:\n"
elif errline.startswith(FATALIO) or (
len(words) > 1 and words[1].startswith(FATALIO)):
self.print_next_error_lines = 1
self.print_next_error_file = True
ret += "OpenFOAM IO error:\n"
if len(ret) > 0:
return ret
else:
return None
class VideoMediaView(MediaView):
def __init__(self, media, parent):
super(VideoMediaView, self).__init__(media, parent)
self.widget = QWidget(parent)
self.process = QProcess(self.widget)
self.process.setObjectName('%s-process' % self.objectName())
self.std_out = []
self.errors = []
self.stopping = False
self.mute = False
self.widget.setGeometry(media['geometry'])
self.connect(self.process, SIGNAL('error()'), self.process_error)
self.connect(self.process, SIGNAL('finished()'), self.process_finished)
self.connect(self.process, SIGNAL('started()'), self.process_started)
self.set_default_widget_prop()
self.stop_timer = QTimer(self)
self.stop_timer.setSingleShot(True)
self.stop_timer.setInterval(1000)
self.stop_timer.timeout.connect(self.process_timeout)
#---- kong ---- for RPi
self.rect = media['geometry']
self.omxplayer = True
#----
@Slot()
def process_timeout(self):
os.kill(self.process.pid(), signal.SIGTERM)
self.stopping = False
if not self.is_started():
self.started_signal.emit()
super(VideoMediaView, self).stop()
@Slot(object)
def process_error(self, err):
print '---- process error ----'
self.errors.append(err)
self.stop()
@Slot()
def process_finished(self):
self.stop()
@Slot()
def process_started(self):
self.stop_timer.stop()
if float(self.duration) > 0:
self.play_timer.setInterval(int(float(self.duration) * 1000))
self.play_timer.start()
self.started_signal.emit()
pass
@Slot()
def play(self):
self.finished = 0
self.widget.show()
self.widget.raise_()
path = '%s/%s' % (self.save_dir, self.options['uri'])
#---- kong ----
if self.omxplayer is True:
left, top, right, bottom = self.rect.getCoords()
rect = '%d,%d,%d,%d' % (left, top, right, bottom)
args = ['--win', rect, '--no-osd', '--layer', self.zindex, path]
self.process.start('omxplayer.bin', args)
self.stop_timer.start()
else:
args = [
'-slave', '-identify', '-input',
'nodefault-bindings:conf=/dev/null', '-wid',
str(int(self.widget.winId())), path
]
self.process.start('mplayer', args)
self.stop_timer.start()
#----
@Slot()
def stop(self, delete_widget=False):
#---- kong ----
if not self.widget:
return False
if self.stopping or self.is_finished():
return False
self.stop_timer.start()
self.stopping = True
if self.process.state() == QProcess.ProcessState.Running:
if self.omxplayer is True:
self.process.write('q')
else:
self.process.write('quit\n')
self.process.waitForFinished()
self.process.close()
super(VideoMediaView, self).stop(delete_widget)
self.stopping = False
self.stop_timer.stop()
return True
class WebMediaView(MediaView):
def __init__(self, media, parent):
super(WebMediaView, self).__init__(media, parent)
self.widget = QWidget(parent)
self.process = QProcess(self.widget)
self.process.setObjectName('%s-process' % self.objectName())
self.std_out = []
self.errors = []
self.stopping = False
self.mute = False
self.widget.setGeometry(media['geometry'])
self.connect(self.process, SIGNAL('error()'), self.process_error)
self.connect(self.process, SIGNAL('finished()'), self.process_finished)
self.connect(self.process, SIGNAL('started()'), self.process_started)
self.set_default_widget_prop()
self.stop_timer = QTimer(self)
self.stop_timer.setSingleShot(True)
self.stop_timer.setInterval(1000)
self.stop_timer.timeout.connect(self.process_timeout)
self.rect = self.widget.geometry()
@Slot()
def process_timeout(self):
os.kill(self.process.pid(), signal.SIGTERM)
self.stopping = False
if not self.is_started():
self.started_signal.emit()
super(WebMediaView, self).stop()
@Slot(object)
def process_error(self, err):
print '---- process error ----'
self.errors.append(err)
self.stop()
@Slot()
def process_finished(self):
self.stop()
@Slot()
def process_started(self):
self.stop_timer.stop()
if float(self.duration) > 0:
self.play_timer.setInterval(int(float(self.duration) * 1000))
self.play_timer.start()
self.started_signal.emit()
pass
@Slot()
def play(self):
self.finished = 0
self.widget.show()
self.widget.raise_()
#---- kong ----
url = self.options['uri']
args = [
#'--kiosk',
str(self.rect.left()),
str(self.rect.top()),
str(self.rect.width()),
str(self.rect.height()),
QUrl.fromPercentEncoding(url)
]
#self.process.start('chromium-browser', args)
self.process.start('./dist/web', args)
self.stop_timer.start()
#----
@Slot()
def stop(self, delete_widget=False):
#---- kong ----
if not self.widget:
return False
if self.stopping or self.is_finished():
return False
self.stop_timer.start()
self.stopping = True
if self.process.state() == QProcess.ProcessState.Running:
#os.system('pkill chromium')
os.system('pkill web')
self.process.waitForFinished()
self.process.close()
super(WebMediaView, self).stop(delete_widget)
self.stopping = False
self.stop_timer.stop()
return True
class VideoMediaView(MediaView):
def __init__(self, media, parent):
super(VideoMediaView, self).__init__(media, parent)
self._widget = QWidget(parent)
self._process = QProcess(self._widget)
self._process.setObjectName('%s-process' % self.objectName())
self._std_out = []
self._errors = []
self._stopping = False
self._mute = False
if 'mute' in self._options:
self._mute = bool(int(self._options['mute']))
self._widget.setGeometry(media['_geometry'])
self.connect(self._process, SIGNAL("error()"), self._process_error)
self.connect(self._process, SIGNAL("finished()"), self.stop)
self.connect(self._process, SIGNAL("readyReadStandardOutput()"), self.__grep_std_out)
self.set_default_widget_prop()
self._stop_timer = QTimer(self)
self._stop_timer.setSingleShot(True)
self._stop_timer.setInterval(1000)
self._stop_timer.timeout.connect(self._force_stop)
@Slot()
def _force_stop(self):
os.kill(self._process.pid(), signal.SIGTERM)
self._stopping = False
if not self.is_started():
self.started_signal.emit()
super(VideoMediaView, self).stop()
@Slot(object)
def _process_error(self, err):
self._errors.append(err)
self.stop()
@Slot()
def play(self):
self._finished = 0
path = "%s/%s" % (self._save_dir, self._options['uri'])
self._widget.show()
args = [
'-slave', '-identify', '-input',
'nodefault-bindings:conf=/dev/null',
'-wid', str(int(self._widget.winId())),
path
]
if self._mute:
args += ['-ao', 'null']
self._process.start('mplayer', args)
self._stop_timer.start()
@Slot()
def stop(self, delete_widget=False):
if self._stopping or self.is_finished():
return False
self._stop_timer.start()
self._stopping = True
if self._process.state() == QProcess.ProcessState.Running:
self._process.write("quit\n")
self._process.waitForFinished(50)
self._process.close()
super(VideoMediaView, self).stop(delete_widget)
self._stopping = False
self._stop_timer.stop()
return True
@Slot()
def __grep_std_out(self):
lines = self._process.readAllStandardOutput().split("\n")
for line in lines:
if not line.isEmpty():
if line.startsWith("Starting playback"):
self._widget.raise_()
self._play_timer.start()
self.started_signal.emit()
self._stop_timer.stop()
else:
part = line.split("=")
if 'ID_LENGTH' == part[0]:
if float(self._duration) > 0: # user set the video duration manually.
self._play_timer.setInterval(int(1000 * float(self._duration)))
else: # use duration found by mplayer.
self._play_timer.setInterval(int(1000 * float(part[1])))
