class WinExecution(QtCore.QObject):
onPreviewClick = QtCore.Signal(object, object, object)
def __init__(self, controller, subscriber):
super(WinExecution, self).__init__()
self.controller = controller
self.subscriber = subscriber
self.shared_info = SharedInfo()
self.mode_edit = False
self.last_index = 0
self.ui = None
self.reload_ui()
self.shared_info.connect(SharedInfo.GLOBAL_MEDIA, self._change_media)
self.shared_info.connect(SharedInfo.GLOBAL_FILTERCHAIN,
self._change_filterchain)
self.shared_info.connect(SharedInfo.GLOBAL_HIST_REC_PATH_MEDIA,
self._change_media_path)
self.subscriber.subscribe(keys.get_key_execution_list(),
self.update_execution_list)
def reload_ui(self):
self.ui = get_ui(self)
self.ui.newButton.clicked.connect(self.new)
self.ui.cancelButton.clicked.connect(self.cancel)
self.ui.executeButton.clicked.connect(self.execute)
self.ui.previewButton.clicked.connect(self.preview)
self.ui.stopButton.clicked.connect(self.stop)
self.ui.lstExecution.currentItemChanged.connect(
self._on_selected_lst_execution_change)
self.ui.lstExecution.itemClicked.connect(self._lst_execution_clicked)
self._update_execution_list()
def preview(self):
# feature, if not into edit mode, we are create a new execution
if not self.mode_edit:
if not self.ui.lstExecution.count():
self._mode_edit(True)
execution_name = self.ui.txtExecution.text()
if not execution_name:
# this case is when no selected item in the list, so select the
# first and restart
self.ui.lstExecution.setCurrentRow(0)
self.preview()
# and select the associated filterchain
self._lst_execution_clicked()
return
else:
execution_name = self.ui.txtExecution.text()
media_name = self.ui.txtMedia.text()
filterchain_name = self.ui.txtFilterchain.text()
first_filterchain_name = filterchain_name
if not filterchain_name:
filterchain_name = keys.get_empty_filterchain_name()
if self.mode_edit or not first_filterchain_name:
if not self._execute(execution_name, media_name, filterchain_name):
return
else:
self._lst_execution_clicked()
self.onPreviewClick.emit(execution_name, media_name, filterchain_name)
def execute(self):
execution_name = self.ui.txtExecution.text()
media_name = self.ui.txtMedia.text()
filterchain_name = self.ui.txtFilterchain.text()
self._execute(execution_name, media_name, filterchain_name)
def stop(self):
# remove an execution
no_line = self.ui.lstExecution.currentRow()
if no_line >= 0:
execution_name = self.ui.txtExecution.text()
self.controller.stop_filterchain_execution(execution_name)
self._enable_stop_button(False)
def new(self):
self._mode_edit(True)
def cancel(self):
self._mode_edit(False)
self._on_selected_lst_execution_change()
#
# PRIVATE FUNCTION ############################
#
def _lst_execution_clicked(self):
execution_name = self.ui.txtExecution.text()
filterchain_name = self.ui.txtFilterchain.text()
media_name = self.ui.txtMedia.text()
self.shared_info.set(SharedInfo.GLOBAL_EXEC,
(execution_name, filterchain_name, media_name))
def _on_selected_lst_execution_change(self):
execution = self._get_selected_list(self.ui.lstExecution)
if execution:
self.ui.previewButton.setEnabled(True)
self.ui.stopButton.setEnabled(True)
else:
self.ui.stopButton.setEnabled(False)
self.ui.txtFilterchain.setText("")
self.ui.txtMedia.setText("")
self.ui.txtExecution.setText("")
return
self.ui.txtExecution.setText(execution)
exec_info = self.controller.get_execution_info(execution)
if not exec_info:
logger.error(
"WinExecution Internal sync error with execution info :(")
return
self.ui.txtFilterchain.setText(exec_info.get("filterchain"))
self.ui.txtMedia.setText(exec_info.get("media"))
def update_execution_list(self, data):
operator = data[0]
execution_name = data[1:]
if operator == "+":
self.ui.lstExecution.addItem(execution_name)
self.ui.lstExecution.setCurrentRow(
self.ui.lstExecution.count() - 1)
elif operator == "-":
self.shared_info.set(SharedInfo.GLOBAL_CLOSE_EXEC, execution_name)
# more easy to update all, like that, the client is protected by
# modification
for row in range(self.ui.lstExecution.count()):
item = self.ui.lstExecution.item(row)
if item and item.text() == execution_name:
self.ui.lstExecution.takeItem(row)
break
self._clear_form(True)
else:
logger.warning("Error in update_execution_list, wrong operator : \
%s" % operator)
def _update_execution_list(self):
self.mode_edit = False
self._mode_edit(self.mode_edit)
self.last_index += 1
self.ui.lstExecution.clear()
exec_list = self.controller.get_execution_list()
for execution_name in exec_list:
self.ui.lstExecution.addItem(execution_name)
@staticmethod
def _get_selected_list(ui_list):
no_line = ui_list.currentRow()
if no_line >= 0:
return ui_list.item(no_line).text()
return
def _is_unique_execution_name(self, execution_name):
for noLine in range(self.ui.lstExecution.count()):
if self.ui.lstExecution.item(noLine).text() == execution_name:
return False
return True
def _execute(self, execution_name, media_name, filterchain_name):
if not self._is_unique_execution_name(execution_name):
QtGui.QMessageBox.warning(self.ui.centralwidget,
"Wrong name",
"The execution name \"%s\" already \
exist." % execution_name,
QtGui.QMessageBox.Ok,
QtGui.QMessageBox.Ok)
return False
file_name = self.shared_info.get(SharedInfo.GLOBAL_PATH_MEDIA)
is_client_manager = media_name == keys.get_media_file_video_name()
status = self.controller.start_filterchain_execution(
execution_name,
media_name,
filterchain_name,
file_name,
is_client_manager
)
if not status:
self.cancel()
return False
self._mode_edit(False)
exec_info = {"media": media_name,
"execution_name": execution_name,
"filterchain_name": filterchain_name,
"file_name": file_name}
self.shared_info.set(SharedInfo.GLOBAL_START_EXEC, exec_info)
self._lst_execution_clicked()
return True
def _mode_edit(self, mode_edit):
self.mode_edit = mode_edit
self.ui.frameEdit.setVisible(mode_edit)
self._clear_form(mode_edit)
self.ui.txtExecution.setReadOnly(not mode_edit)
self.ui.newButton.setEnabled(not mode_edit)
self._enable_stop_button(mode_edit)
self.ui.lstExecution.setEnabled(not mode_edit)
if mode_edit:
filterchain_name = self.shared_info.get(
SharedInfo.GLOBAL_FILTERCHAIN)
if filterchain_name:
self.ui.txtFilterchain.setText(filterchain_name)
self.last_index += 1
self.ui.txtExecution.setText("Execution-%d" % self.last_index)
media_name = self.shared_info.get(SharedInfo.GLOBAL_MEDIA)
if media_name:
self.ui.txtMedia.setText(media_name)
def _enable_stop_button(self, mode_edit):
self.ui.stopButton.setEnabled(
bool(not mode_edit and self.ui.lstExecution.count()))
def _get_selected_execution_name(self):
no_line = self.ui.lstExecution.currentRow()
if no_line >= 0:
return self.ui.lstExecution.item(no_line).text()
return
def _clear_form(self, mode_edit):
if mode_edit:
self.ui.txtExecution.clear()
self.ui.txtMedia.clear()
self.ui.txtFilterchain.clear()
def _change_media(self, value=None):
# Ignore the value
if self.mode_edit:
media_name = self.shared_info.get(SharedInfo.GLOBAL_MEDIA)
if media_name:
self.ui.txtMedia.setText(media_name)
def _change_filterchain(self, value=None):
# Ignore the value
if self.mode_edit:
filterchain_name = self.shared_info.get(
SharedInfo.GLOBAL_FILTERCHAIN)
if filterchain_name:
self.ui.txtFilterchain.setText(filterchain_name)
def _change_media_path(self, value=None):
# TODO validate if not another execution is created with same argument
if self.ui.newButton.isEnabled():
self.new()
self.ui.txtMedia.setText(keys.get_media_file_video_name())
if self.ui.previewButton.isEnabled():
self.preview()
class WinMedia(QtCore.QObject):
def __init__(self, controller, subscriber):
super(WinMedia, self).__init__()
self.resource_icon_path = "SeaGoatVision/client/resource/img/"
self.ui = None
self.controller = controller
self.subscriber = subscriber
self.shared_info = SharedInfo()
self.shared_info.connect(SharedInfo.GLOBAL_START_EXEC, self.set_info)
self.is_recorded = False
self.is_play = False
self.record_icon = QIcon(self.resource_icon_path +
"RecordVideoAction.png")
self.save_record_icon = QIcon(self.resource_icon_path +
"SaveServerImageAction.png")
self.play_icon = QIcon(
"/usr/share/icons/gnome/24x24/actions/player_play.png")
self.pause_icon = QIcon(
"/usr/share/icons/gnome/24x24/actions/player_pause.png")
self.dct_media = None
self.last_value_frame = 0
self.max_frame = 0
self.shared_info.connect(SharedInfo.GLOBAL_START_EXEC,
self._start_execution)
self.shared_info.connect(SharedInfo.GLOBAL_EXEC, self.change_execution)
self.shared_info.connect(SharedInfo.GLOBAL_HIST_REC_PATH_MEDIA,
self._change_hist_media_path)
# TODO optimize starting thread.
self.thread_player = PlayerFile(controller, self._get_actual_no_frame,
self.set_slider_value)
self.thread_player.start()
self.reload_ui()
def stop(self):
if self.thread_player:
self.thread_player.close()
def reload_ui(self):
self.ui = get_ui(self)
self.ui.recordButton.clicked.connect(self.click_record_button)
self.ui.cbMedia.currentIndexChanged.connect(self._change_media)
self.ui.openDirButton.clicked.connect(self.open_directory)
self.ui.openFileButton.clicked.connect(self.open_file)
self.ui.btnplay.clicked.connect(self.play)
self.ui.loopchb.clicked.connect(self.active_loop)
self.ui.movieLineEdit.textChanged.connect(self._movie_changed)
self.ui.slider_frame.valueChanged.connect(self._slider_value_change)
self.ui.txtframe.returnPressed.connect(self._txt_frame_value_change)
self.ui.spin_box_fps.valueChanged.connect(self._change_fps)
self.ui.sliceButton.clicked.connect(self.click_slice_button)
self.ui.cancelButton.clicked.connect(self.click_cancel_button)
self.ui.cutButton.clicked.connect(self.click_cut_button)
self.ui.cleanButton.clicked.connect(self.click_clean_button)
self._set_record_icon()
self._set_play_icon()
self._update_media()
def _update_media(self):
self.ui.cbMedia.currentIndexChanged.disconnect(self._change_media)
self.dct_media = self.controller.get_media_list()
lst_media = sorted(self.dct_media.keys(), key=lambda x: x.lower())
for media in lst_media:
self.ui.cbMedia.addItem(media)
# subscribe to notification
self.subscriber.subscribe("media.%s" % media,
self._subscribe_cb(media))
self._change_media(after_update=True)
self.ui.cbMedia.currentIndexChanged.connect(self._change_media)
default_select_media = config.default_media_selected
if default_select_media not in self.dct_media.keys():
default_select_media = self.controller.get_default_media_name()
self.last_selected_media = default_select_media
self.select_media(default_select_media)
def _subscribe_cb(self, media):
def _cb(data):
if self.ui.cbMedia.currentText() == media:
fps = data.get("fps")
if fps is not None:
self.ui.lblFPS.setText("%s" % fps)
status = data.get("status")
if status is not None:
self.ui.lblStatus.setText("%s" % status)
return _cb
def _change_media(self, index=-1, after_update=False):
media_name = self.ui.cbMedia.currentText()
frame_webcam = self.ui.frame_webcam
frame_slice = self.ui.frame_slice
frame_webcam.setVisible(False)
frame_slice.setVisible(False)
frame_video = self.ui.frame_video
frame_video.setVisible(False)
media_type = self.dct_media.get(media_name, None)
if not media_type:
self.shared_info.set(SharedInfo.GLOBAL_MEDIA, None)
return
if media_type == keys.get_media_type_video_name():
frame_video.setVisible(True)
elif media_type == keys.get_media_type_streaming_name():
frame_webcam.setVisible(True)
self.shared_info.set(SharedInfo.GLOBAL_PATH_MEDIA, None)
self.shared_info.set(SharedInfo.GLOBAL_MEDIA, media_name)
self.set_info()
if not after_update:
self.last_selected_media = media_name
def _movie_changed(self):
self.shared_info.set(SharedInfo.GLOBAL_PATH_MEDIA,
self.ui.movieLineEdit.text())
def set_slider_value(self, value, force_value=False):
last_value = self.ui.slider_frame.value()
if last_value != value:
self.ui.slider_frame.setValue(value)
else:
# force change value in video context
self._slider_value_change(value)
def _slider_value_change(self, value):
self.ui.txtframe.setText(str(value))
self._txt_frame_value_change()
def _txt_frame_value_change(self):
str_value = self.ui.txtframe.text()
try:
value = int(str_value)
except BaseException:
self.ui.txtframe.setText(str(self.last_value_frame))
return
if value < 1 or value > self.max_frame:
self.ui.txtframe.setText(str(self.last_value_frame))
return
self.last_value_frame = value
self.ui.txtframe.setText(str(value))
self.set_frame_video(value)
def _change_fps(self, value):
self.thread_player.set_fps(value)
def _get_actual_no_frame(self):
return self.ui.slider_frame.value()
def _start_execution(self, value=None):
if not value or not isinstance(value, dict):
return
media_name = value.get("media")
if media_name == keys.get_media_file_video_name():
self.set_slider_value(1)
self.is_play = False
self.play()
def click_record_button(self):
if not self.is_recorded:
path = self.ui.txt_name_record.text()
if not path:
path = None
if self.ui.rbn_avi.isChecked():
format_rec = keys.get_key_format_avi()
else:
format_rec = keys.get_key_format_png()
options = {
"compress": self.ui.sb_compress.value(),
"format": format_rec
}
if not self.controller.start_record(self.ui.cbMedia.currentText(),
path, options):
# TODO improve error message
logger.error("Trying start record...")
else:
self.is_recorded = True
else:
if not self.controller.stop_record(self.ui.cbMedia.currentText()):
logger.error("Trying stop record...")
self.is_recorded = False
self.set_info()
def open_directory(self):
filename = QFileDialog.getExistingDirectory()
if len(filename) > 0:
self.ui.movieLineEdit.setText(filename)
def open_file(self):
filename = QFileDialog.getOpenFileName()[0]
if len(filename) > 0:
self.ui.movieLineEdit.setText(filename)
def set_frame_video(self, value):
media_name = self.shared_info.get(SharedInfo.GLOBAL_MEDIA)
if not media_name:
return
self.controller.cmd_to_media(media_name, keys.get_key_media_frame(),
value - 1)
def set_info(self, value=None):
# Ignore the value
media_name = self.shared_info.get(SharedInfo.GLOBAL_MEDIA)
if not media_name:
return
info = self.controller.get_info_media(media_name)
if not info:
logger.warning("WinMedia: info is empty from get_info_media.")
self.max_frame = info.get("nb_frame", -1)
self.ui.lblframe.setText("/%s" % self.max_frame)
self.ui.txtframe.setText(str(self.last_value_frame))
self.ui.slider_frame.setMinimum(1)
self.ui.slider_frame.setMaximum(self.max_frame)
self.thread_player.set_max_frame(self.max_frame)
self.ui.lblFPS.setText("%s" % info.get("fps", "-1"))
self.ui.lblStatus.setText("%s" % info.get("status", "None"))
record_name = info.get("record_file_name", "")
self.ui.txt_name_record.setText("%s" % record_name)
self.is_recorded = bool(record_name)
self._set_record_icon()
def play(self):
# media_name = self.ui.cbMedia.currentText()
if self.is_play:
# if self.controller.cmd_to_media(media_name,
# keys.get_key_media_play()):
self.thread_player.set_pause(True)
self.is_play = False
self._set_play_icon()
else:
# if self.controller.cmd_to_media(media_name,
# keys.get_key_media_pause()):
self.thread_player.set_pause(False)
self.is_play = True
self._set_play_icon()
def active_loop(self):
media_name = self.ui.cbMedia.currentText()
self.controller.cmd_to_media(media_name, keys.get_key_media_loop(),
None)
def _set_play_icon(self):
if not self.is_play:
self.ui.btnplay.setIcon(self.play_icon)
else:
self.ui.btnplay.setIcon(self.pause_icon)
def _set_record_icon(self):
self.ui.sb_compress.setEnabled(not self.is_recorded)
self.ui.rbn_avi.setEnabled(not self.is_recorded)
self.ui.rbn_png.setEnabled(not self.is_recorded)
self.ui.txt_name_record.setReadOnly(self.is_recorded)
if not self.is_recorded:
self.ui.recordButton.setIcon(self.record_icon)
else:
self.ui.recordButton.setIcon(self.save_record_icon)
def get_file_path(self):
item_cbmedia = self.ui.cbMedia.currentText()
media_type = self.dct_media.get(item_cbmedia, None)
if media_type != keys.get_media_type_video_name():
return
return self.ui.movieLineEdit.text()
def change_execution(self, exec_info):
media_name = exec_info[2]
self.select_media(media_name)
def select_media(self, media_name):
# find index
index = self.ui.cbMedia.findText(media_name)
if index < 0:
return False
# TODO Need to re-send signal if it's the same media? Maybe not
# necessary
self.ui.cbMedia.setCurrentIndex(index)
return True
def _change_hist_media_path(self, value=None):
filename = self.shared_info.get(SharedInfo.GLOBAL_HIST_REC_PATH_MEDIA)
if len(filename) > 0:
self.ui.movieLineEdit.setText(filename)
def click_slice_button(self):
self.ui.frame_slice.setVisible(True)
def click_cancel_button(self):
self.ui.frame_slice.setVisible(False)
def click_cut_button(self):
begin = self.ui.beginSpinBox.value()
end = self.ui.endSpinBox.value()
file_name = self.ui.movieLineEdit.text()
cut_file_name = self.ui.nameLineEdit.text()
self.controller.cut_video(file_name, begin, end, cut_file_name)
self.ui.frame_slice.setVisible(False)
def click_clean_button(self):
self.ui.beginSpinBox.setValue(0)
self.ui.endSpinBox.setValue(0)
self.ui.nameLineEdit.setText("")
class WinMedia(QtCore.QObject):
def __init__(self, controller, subscriber):
super(WinMedia, self).__init__()
self.resource_icon_path = "SeaGoatVision/client/resource/img/"
self.ui = None
self.controller = controller
self.subscriber = subscriber
self.shared_info = SharedInfo()
self.shared_info.connect(SharedInfo.GLOBAL_START_EXEC, self.set_info)
self.is_recorded = False
self.is_play = False
self.record_icon = QIcon(
self.resource_icon_path + "RecordVideoAction.png")
self.save_record_icon = QIcon(
self.resource_icon_path + "SaveServerImageAction.png")
self.play_icon = QIcon(
"/usr/share/icons/gnome/24x24/actions/player_play.png")
self.pause_icon = QIcon(
"/usr/share/icons/gnome/24x24/actions/player_pause.png")
self.dct_media = None
self.last_value_frame = 0
self.max_frame = 0
self.shared_info.connect(
SharedInfo.GLOBAL_START_EXEC, self._start_execution)
self.shared_info.connect(SharedInfo.GLOBAL_EXEC, self.change_execution)
self.shared_info.connect(SharedInfo.GLOBAL_HIST_REC_PATH_MEDIA,
self._change_hist_media_path)
# TODO optimize starting thread.
self.thread_player = PlayerFile(controller, self._get_actual_no_frame,
self.set_slider_value)
self.thread_player.start()
self.reload_ui()
def stop(self):
if self.thread_player:
self.thread_player.close()
def reload_ui(self):
self.ui = get_ui(self)
self.ui.recordButton.clicked.connect(self.click_record_button)
self.ui.cbMedia.currentIndexChanged.connect(self._change_media)
self.ui.openDirButton.clicked.connect(self.open_directory)
self.ui.openFileButton.clicked.connect(self.open_file)
self.ui.btnplay.clicked.connect(self.play)
self.ui.loopchb.clicked.connect(self.active_loop)
self.ui.movieLineEdit.textChanged.connect(self._movie_changed)
self.ui.slider_frame.valueChanged.connect(self._slider_value_change)
self.ui.txtframe.returnPressed.connect(self._txt_frame_value_change)
self.ui.spin_box_fps.valueChanged.connect(self._change_fps)
self.ui.sliceButton.clicked.connect(self.click_slice_button)
self.ui.cancelButton.clicked.connect(self.click_cancel_button)
self.ui.cutButton.clicked.connect(self.click_cut_button)
self.ui.cleanButton.clicked.connect(self.click_clean_button)
self._set_record_icon()
self._set_play_icon()
self._update_media()
def _update_media(self):
self.ui.cbMedia.currentIndexChanged.disconnect(self._change_media)
self.dct_media = self.controller.get_media_list()
lst_media = sorted(self.dct_media.keys(), key=lambda x: x.lower())
for media in lst_media:
self.ui.cbMedia.addItem(media)
# subscribe to notification
self.subscriber.subscribe("media.%s" % media,
self._subscribe_cb(media))
self._change_media(after_update=True)
self.ui.cbMedia.currentIndexChanged.connect(self._change_media)
default_select_media = config.default_media_selected
if default_select_media not in self.dct_media.keys():
default_select_media = self.controller.get_default_media_name()
self.last_selected_media = default_select_media
self.select_media(default_select_media)
def _subscribe_cb(self, media):
def _cb(data):
if self.ui.cbMedia.currentText() == media:
fps = data.get("fps")
if fps is not None:
self.ui.lblFPS.setText("%s" % fps)
status = data.get("status")
if status is not None:
self.ui.lblStatus.setText("%s" % status)
return _cb
def _change_media(self, index=-1, after_update=False):
media_name = self.ui.cbMedia.currentText()
frame_webcam = self.ui.frame_webcam
frame_slice = self.ui.frame_slice
frame_webcam.setVisible(False)
frame_slice.setVisible(False)
frame_video = self.ui.frame_video
frame_video.setVisible(False)
media_type = self.dct_media.get(media_name, None)
if not media_type:
self.shared_info.set(SharedInfo.GLOBAL_MEDIA, None)
return
if media_type == keys.get_media_type_video_name():
frame_video.setVisible(True)
elif media_type == keys.get_media_type_streaming_name():
frame_webcam.setVisible(True)
self.shared_info.set(SharedInfo.GLOBAL_PATH_MEDIA, None)
self.shared_info.set(SharedInfo.GLOBAL_MEDIA, media_name)
self.set_info()
if not after_update:
self.last_selected_media = media_name
def _movie_changed(self):
self.shared_info.set(
SharedInfo.GLOBAL_PATH_MEDIA, self.ui.movieLineEdit.text())
def set_slider_value(self, value, force_value=False):
last_value = self.ui.slider_frame.value()
if last_value != value:
self.ui.slider_frame.setValue(value)
else:
# force change value in video context
self._slider_value_change(value)
def _slider_value_change(self, value):
self.ui.txtframe.setText(str(value))
self._txt_frame_value_change()
def _txt_frame_value_change(self):
str_value = self.ui.txtframe.text()
try:
value = int(str_value)
except BaseException:
self.ui.txtframe.setText(str(self.last_value_frame))
return
if value < 1 or value > self.max_frame:
self.ui.txtframe.setText(str(self.last_value_frame))
return
self.last_value_frame = value
self.ui.txtframe.setText(str(value))
self.set_frame_video(value)
def _change_fps(self, value):
self.thread_player.set_fps(value)
def _get_actual_no_frame(self):
return self.ui.slider_frame.value()
def _start_execution(self, value=None):
if not value or not isinstance(value, dict):
return
media_name = value.get("media")
if media_name == keys.get_media_file_video_name():
self.set_slider_value(1)
self.is_play = False
self.play()
def click_record_button(self):
if not self.is_recorded:
path = self.ui.txt_name_record.text()
if not path:
path = None
if self.ui.rbn_avi.isChecked():
format_rec = keys.get_key_format_avi()
else:
format_rec = keys.get_key_format_png()
options = {
"compress": self.ui.sb_compress.value(), "format": format_rec}
if not self.controller.start_record(self.ui.cbMedia.currentText(),
path, options):
# TODO improve error message
logger.error("Trying start record...")
else:
self.is_recorded = True
else:
if not self.controller.stop_record(self.ui.cbMedia.currentText()):
logger.error("Trying stop record...")
self.is_recorded = False
self.set_info()
def open_directory(self):
filename = QFileDialog.getExistingDirectory()
if len(filename) > 0:
self.ui.movieLineEdit.setText(filename)
def open_file(self):
filename = QFileDialog.getOpenFileName()[0]
if len(filename) > 0:
self.ui.movieLineEdit.setText(filename)
def set_frame_video(self, value):
media_name = self.shared_info.get(SharedInfo.GLOBAL_MEDIA)
if not media_name:
return
self.controller.cmd_to_media(
media_name, keys.get_key_media_frame(), value - 1)
def set_info(self, value=None):
# Ignore the value
media_name = self.shared_info.get(SharedInfo.GLOBAL_MEDIA)
if not media_name:
return
info = self.controller.get_info_media(media_name)
if not info:
logger.warning("WinMedia: info is empty from get_info_media.")
self.max_frame = info.get("nb_frame", -1)
self.ui.lblframe.setText("/%s" % self.max_frame)
self.ui.txtframe.setText(str(self.last_value_frame))
self.ui.slider_frame.setMinimum(1)
self.ui.slider_frame.setMaximum(self.max_frame)
self.thread_player.set_max_frame(self.max_frame)
self.ui.lblFPS.setText("%s" % info.get("fps", "-1"))
self.ui.lblStatus.setText("%s" % info.get("status", "None"))
record_name = info.get("record_file_name", "")
self.ui.txt_name_record.setText("%s" % record_name)
self.is_recorded = bool(record_name)
self._set_record_icon()
def play(self):
# media_name = self.ui.cbMedia.currentText()
if self.is_play:
# if self.controller.cmd_to_media(media_name,
# keys.get_key_media_play()):
self.thread_player.set_pause(True)
self.is_play = False
self._set_play_icon()
else:
# if self.controller.cmd_to_media(media_name,
# keys.get_key_media_pause()):
self.thread_player.set_pause(False)
self.is_play = True
self._set_play_icon()
def active_loop(self):
media_name = self.ui.cbMedia.currentText()
self.controller.cmd_to_media(
media_name, keys.get_key_media_loop(), None)
def _set_play_icon(self):
if not self.is_play:
self.ui.btnplay.setIcon(self.play_icon)
else:
self.ui.btnplay.setIcon(self.pause_icon)
def _set_record_icon(self):
self.ui.sb_compress.setEnabled(not self.is_recorded)
self.ui.rbn_avi.setEnabled(not self.is_recorded)
self.ui.rbn_png.setEnabled(not self.is_recorded)
self.ui.txt_name_record.setReadOnly(self.is_recorded)
if not self.is_recorded:
self.ui.recordButton.setIcon(self.record_icon)
else:
self.ui.recordButton.setIcon(self.save_record_icon)
def get_file_path(self):
item_cbmedia = self.ui.cbMedia.currentText()
media_type = self.dct_media.get(item_cbmedia, None)
if media_type != keys.get_media_type_video_name():
return
return self.ui.movieLineEdit.text()
def change_execution(self, exec_info):
media_name = exec_info[2]
self.select_media(media_name)
def select_media(self, media_name):
# find index
index = self.ui.cbMedia.findText(media_name)
if index < 0:
return False
# TODO Need to re-send signal if it's the same media? Maybe not
# necessary
self.ui.cbMedia.setCurrentIndex(index)
return True
def _change_hist_media_path(self, value=None):
filename = self.shared_info.get(SharedInfo.GLOBAL_HIST_REC_PATH_MEDIA)
if len(filename) > 0:
self.ui.movieLineEdit.setText(filename)
def click_slice_button(self):
self.ui.frame_slice.setVisible(True)
def click_cancel_button(self):
self.ui.frame_slice.setVisible(False)
def click_cut_button(self):
begin = self.ui.beginSpinBox.value()
end = self.ui.endSpinBox.value()
file_name = self.ui.movieLineEdit.text()
cut_file_name = self.ui.nameLineEdit.text()
self.controller.cut_video(file_name, begin, end, cut_file_name)
self.ui.frame_slice.setVisible(False)
def click_clean_button(self):
self.ui.beginSpinBox.setValue(0)
self.ui.endSpinBox.setValue(0)
self.ui.nameLineEdit.setText("")
