def __init__(self):
super().__init__()
if not os.path.exists(PRESETS_DIR):
os.makedirs(PRESETS_DIR, exist_ok=True)
# Entry in mainWindow menu
self.manageAction = QAction(MainWindow())
self.manageAction.triggered.connect(self.__edit_presets)
self.manageAction.setText(translate('Presets', 'Presets'))
self.menu_action = MainWindow().menuTools.addAction(self.manageAction)
self.loadOnCueAction = QAction(None)
self.loadOnCueAction.triggered.connect(self.__load_on_cue)
self.loadOnCueAction.setText(translate('Presets', 'Load preset'))
self.createFromCueAction = QAction(None)
self.createFromCueAction.triggered.connect(self.__create_from_cue)
self.createFromCueAction.setText(translate('Presets',
'Save as preset'))
CueLayout.cm_registry.add_separator()
CueLayout.cm_registry.add_item(self.loadOnCueAction)
CueLayout.cm_registry.add_item(self.createFromCueAction)
CueLayout.cm_registry.add_separator()
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 select_preset_dialog():
try:
presets = tuple(sorted(scan_presets(), key=natural_keys))
if presets:
item, confirm = QInputDialog.getItem(
MainWindow(), translate('Presets', 'Select Preset'), '',
presets)
if confirm:
return item
except OSError as e:
scan_presets_error(e, parent=MainWindow())
def show_info(self, clicked):
media_uri = Application().layout.get_context_cue().media.input_uri()
if not media_uri:
QMessageBox.critical(MainWindow(), translate('MediaInfo', 'Error'),
translate('MediaInfo', 'No info to display'))
else:
gst_info = gst_uri_metadata(media_uri)
info = {'URI': unquote(gst_info.get_uri())}
# Audio streams info
for stream in gst_info.get_audio_streams():
name = stream.get_stream_type_nick().capitalize()
info[name] = {
'Bitrate': str(stream.get_bitrate() // 1000) + ' Kb/s',
'Channels': str(stream.get_channels()),
'Sample rate': str(stream.get_sample_rate()) + ' Hz',
'Sample size': str(stream.get_depth()) + ' bit'
}
# Video streams info
for stream in gst_info.get_video_streams():
name = stream.get_stream_type_nick().capitalize()
info[name] = {
'Height':
str(stream.get_height()) + ' px',
'Width':
str(stream.get_width()) + ' px',
'Framerate':
str(
round(stream.get_framerate_num() /
stream.get_framerate_denom()))
}
# Media tags
info['Tags'] = {}
tags = gst_info.get_tags()
if tags is not None:
tags = gst_parse_tags_list(tags)
for tag in tags:
if type(tags[tag]).__str__ is not object.__str__:
info['Tags'][tag.capitalize()] = str(tags[tag])
if not info['Tags']:
info.pop('Tags')
# Show the dialog
dialog = InfoDialog(MainWindow(), info,
Application().layout.get_context_cue().name)
dialog.exec_()
def __init__(self):
self.syncMenu = QMenu(translate('Synchronizer', 'Synchronization'))
self.menu_action = MainWindow().menuTools.addMenu(self.syncMenu)
self.addPeerAction = QAction(
translate('Synchronizer', 'Manage connected peers'), MainWindow())
self.addPeerAction.triggered.connect(self.manage_peers)
self.syncMenu.addAction(self.addPeerAction)
self.showIpAction = QAction(
translate('Synchronizer', 'Show your IP'), MainWindow())
self.showIpAction.triggered.connect(self.show_ip)
self.syncMenu.addAction(self.showIpAction)
self.peers = []
self.cue_media = {}
def finalize(self):
MainWindow().menuLayout.clear()
# Disconnect menu-actions signals
self.edit_action.triggered.disconnect()
self.remove_action.triggered.disconnect()
self.select_action.triggered.disconnect()
self.play_action.triggered.disconnect()
self.pause_action.triggered.disconnect()
self.stop_action.triggered.disconnect()
self.reset_volume_action.disconnect()
# Remove context-items
self.cm_registry.remove_item(self.edit_action)
self.cm_registry.remove_item(self.sep1)
self.cm_registry.remove_item(self.remove_action)
self.cm_registry.remove_item(self.select_action)
self.cm_registry.remove_item(self.sep2)
self.cm_registry.remove_item(self.play_action)
self.cm_registry.remove_item(self.pause_action)
self.cm_registry.remove_item(self.stop_action)
self.cm_registry.remove_item(self.reset_volume_action)
# Delete the layout
self.deleteLater()
def show_ip(self):
ip = translate('Synchronizer', 'Your IP is:') + ' '
try:
ip += socket.gethostbyname(socket.gethostname())
except OSError:
ip = '127.0.0.1'
QMessageBox.information(MainWindow(), ' ', ip)
def gain(self):
gainUi = GainUi(MainWindow())
gainUi.exec_()
if gainUi.result() == QDialog.Accepted:
files = {}
if gainUi.only_selected():
cues = Application().layout.get_selected_cues(MediaCue)
else:
cues = Application().cue_model.filter(MediaCue)
for cue in cues:
media = cue.media
uri = media.input_uri()
if uri is not None:
if uri not in files:
files[uri] = [media]
else:
files[uri].append(media)
# Gain (main) thread
self._gain_thread = GainMainThread(files, gainUi.threads(),
gainUi.mode(),
gainUi.ref_level(),
gainUi.norm_level())
# Progress dialog
self._progress = GainProgressDialog(len(files))
self._gain_thread.on_progress.connect(self._progress.on_progress,
mode=Connection.QtQueued)
self._progress.show()
self._gain_thread.start()
def __load_on_cue():
preset_name = select_preset_dialog()
if preset_name is not None:
try:
load_on_cue(preset_name,
Application().layout.get_context_cue())
except OSError as e:
load_preset_error(e, preset_name, parent=MainWindow())
def save_preset_dialog(base_name=''):
name, confirm = QInputDialog.getText(MainWindow(),
translate('Presets', 'Presets'),
translate('Presets', 'Preset name'),
text=base_name)
if confirm:
return name
def edit_cue(self, cue):
edit_ui = CueSettings(cue, parent=MainWindow())
def on_apply(settings):
action = UpdateCueAction(settings, cue)
MainActionsHandler.do_action(action)
edit_ui.on_apply.connect(on_apply)
edit_ui.exec_()
def check_override_dialog(preset_name):
answer = QMessageBox.question(MainWindow(),
translate('Presets', 'Presets'),
translate(
'Presets',
'Preset already exists, overwrite?'),
buttons=QMessageBox.Yes | QMessageBox.Cancel)
return answer == QMessageBox.Yes
def testOla(self):
if self.activateBox.isChecked():
try:
client = OlaClient()
del client
except OLADNotRunningException:
QMessageBox.warning(
MainWindow(), translate('TimecodeSettings', 'OLA status'),
translate('TimecodeSettings',
'OLA is not running - start the OLA daemon.'))
def __load_on_selected(self):
item = self.presetsList.currentItem()
if item is not None:
preset_name = item.text()
try:
cues = Application().layout.get_selected_cues()
if cues:
load_on_cues(preset_name, cues)
except OSError as e:
load_preset_error(e, preset_name, parent=MainWindow())
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 show_context_menu(position):
menu_edit = MainWindow().menuEdit
menu_edit.move(position)
menu_edit.show()
# Adjust the menu position
desktop = qApp.desktop().availableGeometry()
menu_rect = menu_edit.geometry()
if menu_rect.bottom() > desktop.bottom():
menu_edit.move(menu_edit.x(), menu_edit.y() - menu_edit.height())
if menu_rect.right() > desktop.right():
menu_edit.move(menu_edit.x() - menu_edit.width(), menu_edit.y())
def __init__(self):
self._gain_thread = None
# Entry in mainWindow menu
self.menu = QMenu(translate('ReplayGain',
'ReplayGain / Normalization'))
self.menu_action = MainWindow().menuTools.addMenu(self.menu)
self.actionGain = QAction(MainWindow())
self.actionGain.triggered.connect(self.gain)
self.actionGain.setText(translate('ReplayGain', 'Calculate'))
self.menu.addAction(self.actionGain)
self.actionReset = QAction(MainWindow())
self.actionReset.triggered.connect(self._reset_all)
self.actionReset.setText(translate('ReplayGain', 'Reset all'))
self.menu.addAction(self.actionReset)
self.actionResetSelected = QAction(MainWindow())
self.actionResetSelected.triggered.connect(self._reset_selected)
self.actionResetSelected.setText(
translate('ReplayGain', 'Reset selected'))
self.menu.addAction(self.actionResetSelected)
def __create_from_cue():
cue = Application().layout.get_context_cue()
name = save_preset_dialog(cue.name)
if name is not None:
if not (preset_exists(name) and not check_override_dialog(name)):
preset = cue.properties(only_changed=True)
# Discard id and index
preset.pop('id')
preset.pop('index')
try:
write_preset(name, preset)
except OSError as e:
write_preset_error(e, name, parent=MainWindow())
def __init__(self):
self._mainWindow = MainWindow()
self._app_conf = {}
self._layout = None
self._memento_model = None
self._cue_model = CueModel()
# Connect mainWindow actions
self._mainWindow.new_session.connect(self.new_session_dialog)
self._mainWindow.save_session.connect(self._save_to_file)
self._mainWindow.open_session.connect(self._load_from_file)
# Register general settings widget
AppSettings.register_settings_widget(AppGeneral)
AppSettings.register_settings_widget(CueAppSettings)
# Show the mainWindow maximized
self._mainWindow.showMaximized()
def terminate(self):
self.stop()
MainWindow().menuTools.removeAction(self.menu_action)
def __edit_presets():
ui = PresetsDialog(parent=MainWindow())
ui.show()
def manage_peers(self):
manager = PeersDialog(self.peers, parent=MainWindow())
manager.exec_()
def show_ip(self):
ip = translate('Synchronizer', 'Your IP is:') + ' ' + str(get_lan_ip())
QMessageBox.information(MainWindow(), ' ', ip)
def __init__(self):
MainWindow().register_cue_menu_action(translate(
'MediaCueMenus', 'Audio cue (from file)'),
self.add_uri_audio_media_cue,
category='Media cues',
shortcut='CTRL+M')
def terminate(self):
MainWindow().menuTools.removeAction(self.menuAction)
def __init__(self):
self.menuAction = QAction(
translate('UriChanger', 'Session URI change'), MainWindow())
self.menuAction.triggered.connect(self.show_dialog)
MainWindow().menuTools.addAction(self.menuAction)
def __init__(self, cue_model, **kwargs):
super().__init__(cue_model=cue_model, **kwargs)
self.tabBar().setObjectName('CartTabBar')
self.__columns = int(config['CartLayout']['GridColumns'])
self.__rows = int(config['CartLayout']['GridRows'])
self.__pages = []
self.__context_widget = None
self._show_seek = config['CartLayout'].getboolean('ShowSeek')
self._show_dbmeter = config['CartLayout'].getboolean('ShowDbMeters')
self._show_volume = config['CartLayout'].getboolean('ShowVolume')
self._accurate_timing = config['CartLayout'].getboolean('ShowAccurate')
self._countdown_mode = config['CartLayout'].getboolean('CountDown')
self._auto_add_page = config['CartLayout'].getboolean('AutoAddPage')
self._model_adapter = CueCartModel(cue_model, self.__rows,
self.__columns)
self._model_adapter.item_added.connect(self.__cue_added,
Connection.QtQueued)
self._model_adapter.item_removed.connect(self.__cue_removed,
Connection.QtQueued)
self._model_adapter.item_moved.connect(self.__cue_moved,
Connection.QtQueued)
self._model_adapter.model_reset.connect(self.__model_reset)
# Add layout-specific menus
self.new_page_action = QAction(self)
self.new_page_action.triggered.connect(self.add_page)
self.new_pages_action = QAction(self)
self.new_pages_action.triggered.connect(self.add_pages)
self.rm_current_page_action = QAction(self)
self.rm_current_page_action.triggered.connect(self.remove_current_page)
self.countdown_mode = QAction(self)
self.countdown_mode.setCheckable(True)
self.countdown_mode.setChecked(self._countdown_mode)
self.countdown_mode.triggered.connect(self.set_countdown_mode)
self.show_seek_action = QAction(self)
self.show_seek_action.setCheckable(True)
self.show_seek_action.setChecked(self._show_seek)
self.show_seek_action.triggered.connect(self.set_seek_visible)
self.show_dbmeter_action = QAction(self)
self.show_dbmeter_action.setCheckable(True)
self.show_dbmeter_action.setChecked(self._show_dbmeter)
self.show_dbmeter_action.triggered.connect(self.set_dbmeter_visible)
self.show_volume_action = QAction(self)
self.show_volume_action.setCheckable(True)
self.show_volume_action.setChecked(self._show_volume)
self.show_volume_action.triggered.connect(self.set_volume_visible)
self.show_accurate_action = QAction(self)
self.show_accurate_action.setCheckable(True)
self.show_accurate_action.setChecked(self._accurate_timing)
self.show_accurate_action.triggered.connect(self.set_accurate)
layoutMenu = MainWindow().menuLayout
layoutMenu.addAction(self.new_page_action)
layoutMenu.addAction(self.new_pages_action)
layoutMenu.addAction(self.rm_current_page_action)
layoutMenu.addSeparator()
layoutMenu.addAction(self.countdown_mode)
layoutMenu.addAction(self.show_seek_action)
layoutMenu.addAction(self.show_dbmeter_action)
layoutMenu.addAction(self.show_volume_action)
layoutMenu.addAction(self.show_accurate_action)
# TODO: maybe can be moved outside the layout
# Add cue preferences widgets
CueSettingsRegistry().add_item(CueGeneralSettings, Cue)
CueSettingsRegistry().add_item(MediaCueSettings, MediaCue)
CueSettingsRegistry().add_item(Appearance)
# Cue(s) context-menu actions
self.edit_action = QAction(self)
self.edit_action.triggered.connect(self._edit_cue_action)
self.cm_registry.add_item(self.edit_action)
self.sep1 = self.cm_registry.add_separator()
self.remove_action = QAction(self)
self.remove_action.triggered.connect(self._remove_cue_action)
self.cm_registry.add_item(self.remove_action)
self.select_action = QAction(self)
self.select_action.triggered.connect(self.select_context_cue)
self.cm_registry.add_item(self.select_action)
self.sep2 = self.cm_registry.add_separator(MediaCue)
# MediaCue(s) context-menu actions
self.play_action = QAction(self)
self.play_action.triggered.connect(self._play_context_cue)
self.cm_registry.add_item(self.play_action, MediaCue)
self.pause_action = QAction(self)
self.pause_action.triggered.connect(self._pause_context_cue)
self.cm_registry.add_item(self.pause_action, MediaCue)
self.stop_action = QAction(self)
self.stop_action.triggered.connect(self._stop_context_cue)
self.cm_registry.add_item(self.stop_action, MediaCue)
self.reset_volume_action = QAction(self)
self.reset_volume_action.triggered.connect(self._reset_cue_volume)
self.cm_registry.add_item(self.reset_volume_action, MediaCue)
self.setAcceptDrops(True)
self.retranslateUi()
self.add_page()
def __init__(self, cue_model, **kwargs):
super().__init__(cue_model=cue_model, **kwargs)
self.setLayout(QGridLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self._model_adapter = CueListModel(self._cue_model)
self._model_adapter.item_added.connect(self.__cue_added)
self._model_adapter.item_removed.connect(self.__cue_removed)
self._playing_model = RunningCueModel(self._cue_model)
self._context_item = None
self._next_cue_index = 0
self._show_dbmeter = config['ListLayout'].getboolean('ShowDbMeters')
self._seek_visible = config['ListLayout'].getboolean('ShowSeek')
self._accurate_time = config['ListLayout'].getboolean('ShowAccurate')
self._auto_continue = config['ListLayout'].getboolean('AutoContinue')
self._show_playing = config['ListLayout'].getboolean('ShowPlaying')
self._go_key = config['ListLayout']['GoKey']
self._go_key_sequence = QKeySequence(self._go_key,
QKeySequence.NativeText)
try:
self._end_list = EndListBehavior(config['ListLayout']['EndList'])
except ValueError:
self._end_list = EndListBehavior.Stop
# Add layout-specific menus
self.showPlayingAction = QAction(self)
self.showPlayingAction.setCheckable(True)
self.showPlayingAction.setChecked(self._show_playing)
self.showPlayingAction.triggered.connect(self.set_playing_visible)
self.showDbMeterAction = QAction(self)
self.showDbMeterAction.setCheckable(True)
self.showDbMeterAction.setChecked(self._show_dbmeter)
self.showDbMeterAction.triggered.connect(self.set_dbmeter_visible)
self.showSeekAction = QAction(self)
self.showSeekAction.setCheckable(True)
self.showSeekAction.setChecked(self._seek_visible)
self.showSeekAction.triggered.connect(self.set_seek_visible)
self.accurateTimingAction = QAction(self)
self.accurateTimingAction.setCheckable(True)
self.accurateTimingAction.setChecked(self._accurate_time)
self.accurateTimingAction.triggered.connect(self.set_accurate_time)
self.autoNextAction = QAction(self)
self.autoNextAction.setCheckable(True)
self.autoNextAction.setChecked(self._auto_continue)
self.autoNextAction.triggered.connect(self.set_auto_next)
MainWindow().menuLayout.addAction(self.showPlayingAction)
MainWindow().menuLayout.addAction(self.showDbMeterAction)
MainWindow().menuLayout.addAction(self.showSeekAction)
MainWindow().menuLayout.addAction(self.accurateTimingAction)
MainWindow().menuLayout.addAction(self.autoNextAction)
# GO-BUTTON (top-left)
self.goButton = QPushButton('GO', self)
self.goButton.setFocusPolicy(Qt.NoFocus)
self.goButton.setFixedWidth(120)
self.goButton.setFixedHeight(100)
self.goButton.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
self.goButton.setStyleSheet('font-size: 48pt;')
self.goButton.clicked.connect(self.__go_slot)
self.layout().addWidget(self.goButton, 0, 0)
# INFO PANEL (top center)
self.infoPanel = InfoPanel()
self.infoPanel.setFixedHeight(100)
self.layout().addWidget(self.infoPanel, 0, 1)
# CONTROL-BUTTONS (top-right)
self.controlButtons = ShowControlButtons(parent=self)
self.controlButtons.setFixedHeight(100)
self.controlButtons.stopButton.clicked.connect(self.stop_all)
self.controlButtons.pauseButton.clicked.connect(self.pause_all)
self.controlButtons.fadeInButton.clicked.connect(self.fadein_all)
self.controlButtons.fadeOutButton.clicked.connect(self.fadeout_all)
self.controlButtons.resumeButton.clicked.connect(self.restart_all)
self.controlButtons.interruptButton.clicked.connect(self.interrupt_all)
self.layout().addWidget(self.controlButtons, 0, 2)
# CUE VIEW (center left)
self.listView = CueListView(self._model_adapter, self)
self.listView.itemDoubleClicked.connect(self.double_clicked)
self.listView.currentItemChanged.connect(self.__current_changed)
self.listView.context_event.connect(self.context_event)
self.listView.key_event.connect(self.onKeyPressEvent)
self.listView.select_cue_event.connect(self.select_event)
self.layout().addWidget(self.listView, 1, 0, 1, 2)
# PLAYING VIEW (center right)
self.playView = RunningCuesListWidget(self._playing_model, parent=self)
self.playView.dbmeter_visible = self._show_dbmeter
self.playView.accurate_time = self._accurate_time
self.playView.seek_visible = self._seek_visible
self.playView.setMinimumWidth(300)
self.playView.setMaximumWidth(300)
self.layout().addWidget(self.playView, 1, 2)
self.set_playing_visible(self._show_playing)
# TODO: maybe can be moved outside the layout
# Add cue preferences widgets
CueSettingsRegistry().add_item(CueGeneralSettings, Cue)
CueSettingsRegistry().add_item(MediaCueSettings, MediaCue)
CueSettingsRegistry().add_item(Appearance)
# Context menu actions
self.edit_action = QAction(self)
self.edit_action.triggered.connect(self.edit_context_cue)
self.remove_action = QAction(self)
self.remove_action.triggered.connect(self.remove_context_cue)
self.select_action = QAction(self)
self.select_action.triggered.connect(self.select_context_cue)
self.cm_registry.add_item(self.edit_action)
self.sep1 = self.cm_registry.add_separator()
self.cm_registry.add_item(self.remove_action)
self.cm_registry.add_item(self.select_action)
self.retranslateUi()
def show_dialog(self):
dialog = UriChangerDialog(parent=MainWindow())
dialog.exec_()
