def __init__(self):
for cue_name, cue_class in ClassesLoader(path.dirname(__file__)):
# Register the action-cue in the cue-factory
CueFactory.register_factory(cue_class.__name__, cue_class)
# Register the menu action for adding the action-cue
add_function = ActionCues.create_add_action_cue_method(cue_class)
MainWindow().register_cue_menu_action(cue_class.Name, add_function, 'Action cues')
logging.debug('ACTION-CUES: Loaded "' + cue_name + '"')
def __init__(self):
for name, cue in load_classes(__package__, path.dirname(__file__)):
# Register the action-cue in the cue-factory
CueFactory.register_factory(cue.__name__, cue)
# Register the menu action for adding the action-cue
add_function = ActionCues.create_add_action_cue_method(cue)
MainWindow().register_cue_menu_action(
translate('CueName', cue.Name),
add_function, 'Action cues')
logging.debug('ACTION-CUES: Loaded "' + name + '"')
def _load_from_file(self, filepath):
''' Loads a saved program from "filepath" '''
try:
# Read the file
with open(filepath, mode='r', encoding='utf-8') as file:
program = json.load(file)
# Get the application settings
self.app_conf = program['application']
# Create the layout
self._create_layout(layouts.get_layout(self.app_conf['layout']))
# Load cues
for cue_conf in program['cues']:
cue = CueFactory.create_cue(cue_conf)
if cue is not None:
self.layout.add_cue(cue, cue['index'])
ActionsHandler().set_saved()
self.mainWindow.update_window_title()
# Load plugins settings
self._load_plugins_settings(program['plugins'])
# Update the main-window
self.mainWindow.file = filepath
self.mainWindow.update()
except Exception:
QMessageBox.critical(None, 'Error', 'Error during file reading')
print(traceback.format_exc(), file=sys.stderr)
self._startup()
def _load_from_file(self, session_file):
""" Load a saved session from file """
try:
with open(session_file, mode='r', encoding='utf-8') as file:
session = json.load(file)
# New session
self._new_session(
layouts.get_layout(session['application']['layout']))
# Get the application settings
self._app_conf = session['application']
# Load cues
for cue_conf in session['cues']:
cue_type = cue_conf.pop('_type_', 'Undefined')
cue_id = cue_conf.pop('id')
try:
cue = CueFactory.create_cue(cue_type, cue_id=cue_id)
cue.update_properties(cue_conf)
self._cue_model.add(cue)
except Exception as e:
elogging.exception('Unable to create the cue', e)
MainActionsHandler.set_saved()
self._mainWindow.update_window_title()
# Load plugins settings
plugins.set_plugins_settings(session['plugins'])
# Update the main-window
self._mainWindow.filename = session_file
self._mainWindow.update()
except Exception as e:
elogging.exception('Error during file reading', e)
self.new_session_dialog()
def _load_from_file(self, session_file):
""" Load a saved session from file """
try:
with open(session_file, mode='r', encoding='utf-8') as file:
session = json.load(file)
# New session
self._new_session(
layouts.get_layout(session['application']['layout']))
# Get the application settings
self._app_conf = session['application']
# Load cues
for cue_conf in session['cues']:
cue_type = cue_conf.pop('_type_', 'Undefined')
try:
cue = CueFactory.create_cue(cue_type)
cue.update_properties(cue_conf)
self._cue_model.add(cue)
except Exception as e:
logging.exception('Unable to create the cue', e)
MainActionsHandler().set_saved()
self._mainWindow.update_window_title()
# Load plugins settings
plugins.set_plugins_settings(session['plugins'])
# Update the main-window
self._mainWindow.filename = session_file
self._mainWindow.update()
except Exception as e:
logging.exception('Error during file reading', e)
self.new_session_dialog()
def add_uri_audio_media_cue():
"""Add audio MediaCue(s) form user-selected files"""
if get_backend() is None:
QMessageBox.critical(MainWindow(), 'Error', 'Backend not loaded')
return
# Default path to system "music" folder
path = QStandardPaths.writableLocation(QStandardPaths.MusicLocation)
# Get the backend extensions and create a filter for the Qt file-dialog
extensions = get_backend().supported_extensions()
filters = qfile_filters(extensions, anyfile=False)
# Display a file-dialog for the user to choose the media-files
files, _ = QFileDialog.getOpenFileNames(
MainWindow(), translate('MediaCueMenus', 'Select media files'),
path, filters)
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
# Create media cues, and add them to the Application cue_model
for file in files:
cue = CueFactory.create_cue('URIAudioCue', uri='file://' + file)
# Use the filename without extension as cue name
cue.name = os.path.splitext(os.path.basename(file))[0]
Application().cue_model.add(cue)
QApplication.restoreOverrideCursor()
def __cue_from_preset(self, preset_name):
try:
preset = load_preset(preset_name)
if preset is not None:
if CueFactory.has_factory(preset.get('_type_')):
cue = CueFactory.create_cue(preset['_type_'])
cue.update_properties(preset)
Application().cue_model.add(cue)
else:
QMessageBox.warning(
self, translate('Presets', 'Warning'),
translate(
'Presets', 'Cannot create a cue from this '
'preset: {}').format(preset_name))
except OSError as e:
load_preset_error(e, preset_name, parent=self)
def _add_cues(self, options_list):
for options in options_list:
try:
cue = CueFactory.create_cue(options)
self.layout.add_cue(cue)
except Exception as e:
message = ' '.join([str(i) for i in e.args])
QMessageBox.critical(None, 'Error', message)
def dropEvent(self, event):
# Decode mimedata information about the drag&drop event, since only
# internal movement are allowed we assume the data format is correct
data = event.mimeData().data('application/x-qabstractitemmodeldatalist')
stream = QDataStream(data, QIODevice.ReadOnly)
# Get the starting-item row
start_index = stream.readInt()
new_index = self.indexAt(event.pos()).row()
if not 0 <= new_index <= len(self._model):
new_index = len(self._model)
if qApp.keyboardModifiers() == Qt.ControlModifier:
cue = self._model.item(start_index)
new_cue = CueFactory.clone_cue(cue)
self._model.insert(new_cue, new_index)
else:
self._model.move(start_index, new_index)
def __edit_preset(self):
item = self.presetsList.currentItem()
if item is not None:
try:
preset = load_preset(item.text())
if preset is not None:
try:
cue_class = CueFactory.create_cue(preset.get('_type_'))
cue_class = cue_class.__class__
except Exception:
cue_class = Cue
edit_dialog = CueSettings(cue_class=cue_class)
edit_dialog.load_settings(preset)
if edit_dialog.exec_() == edit_dialog.Accepted:
preset.update(edit_dialog.get_settings())
try:
write_preset(item.text(), preset)
except OSError as e:
write_preset_error(e, item.text(), parent=self)
except OSError as e:
load_preset_error(e, item.text(), parent=self)
self.pauseMode = QCheckBox(self.group)
self.pauseMode.setText('Pause mode')
self.group.layout().addWidget(self.pauseMode)
self.layout().addWidget(self.group)
self.layout().addSpacing(self.height() - 100)
def enable_check(self, enable):
self.group.setCheckable(enable)
self.group.setChecked(False)
def get_configuration(self):
conf = {}
if not (self.group.isCheckable() and not self.group.isChecked()):
conf['pause_mode'] = self.pauseMode.isChecked()
return conf
def set_configuration(self, conf):
if 'pause_mode' in conf:
self.pauseMode.setChecked(conf['pause_mode'])
CueFactory.register_factory('StopAll', ActionCueFactory)
MainWindow().register_cue_options_ui(StopAll.Name,
lambda: [{'name': StopAll.Name,
'type': 'StopAll'}],
category='Action cues')
CueLayout.add_settings_section(StopAllSettings, StopAll)
def _copy_cue_at(self, old_index, index):
newcue = CueFactory.clone_cue(self._cue_items[old_index].cue)
self.add_cue(newcue, index)
def register_factories():
CueFactory.register_factory('MediaCue', gst_media)
CueFactory.register_factory('URIAudioCue', uri_audio)
CueFactory.register_factory('CaptureAudioCue', capture_audio)
if groups_str[-1] != '':
conf['groups'] = [int(groups_str[-1])]
else:
conf['groups'] = []
conf['groups'] += [int(g) for g in groups_str[:-1]]
if not (checkable and not self.groupAction.isChecked()):
conf['action'] = self.actionsBox.currentText()
return conf
def enable_check(self, enable):
self.groupGroups.setCheckable(enable)
self.groupGroups.setChecked(False)
self.groupAction.setCheckable(enable)
self.groupAction.setChecked(False)
def set_configuration(self, conf):
if 'groups' in conf:
self.editGroups.setText(str(conf['groups'])[1:-1])
if 'action' in conf and conf['action'] in self.ACTIONS:
self.actionsBox.setCurrentIndex(self.ACTIONS.index(conf['action']))
CueFactory.register_factory('GroupsAction', ActionCueFactory)
MainWindow().register_cue_options_ui(GroupsAction.Name,
lambda: [{'name': GroupsAction.Name,
'type': 'GroupsAction'}],
category='Action cues')
CueLayout.add_settings_section(GroupsActionSettings, GroupsAction)
def method():
cue = CueFactory.create_cue(cue_class.__name__)
Application().cue_model.add(cue)
def register_factories():
CueFactory.register_factory('MediaCue', gst_media)
CueFactory.register_factory('URIAudioCue', uri_audio)
CueFactory.register_factory('CaptureAudioCue', capture_audio)
def method():
cue = CueFactory.create_cue(cue_class.__name__)
Application().cue_model.add(cue)
def copy_widget(self, widget, index):
index = self.to_1d_index((self.currentIndex(), index[1], index[2]))
new_cue = CueFactory.clone_cue(widget.cue)
self.add_cue(new_cue, index)
def _copy_widget(self, widget, to_row, to_column):
new_index = self.to_1d_index((self.currentIndex(), to_row, to_column))
new_cue = CueFactory.clone_cue(widget.cue)
self._model_adapter.insert(new_cue, new_index)
def undo(self):
if self._cue.is_finalized():
self._cue = CueFactory.clone_cue(self._cue, same_id=True)
self._layout.__add_cue__(self._cue, self._index)
def _copy_widget(self, widget, to_row, to_column):
new_index = self.to_1d_index((self.currentIndex(), to_row, to_column))
new_cue = CueFactory.clone_cue(widget.cue)
self._model_adapter.insert(new_cue, new_index)