def data(self, index, role):
source_index = self.mapToSource(index)
source_model = self.sourceModel()
if not source_index.isValid():
return QVariant()
source_data = source_model.data(source_index, role)
if role == Qt.DisplayRole:
if index.column() == NetworkTableModel.columns_types.index(
'is_member'):
value = {
True: QT_TRANSLATE_NOOP("NetworkTableModel", 'yes'),
False: QT_TRANSLATE_NOOP("NetworkTableModel", 'no'),
None: QT_TRANSLATE_NOOP("NetworkTableModel", 'offline')
}
return value[source_data]
if index.column() == NetworkTableModel.columns_types.index(
'pubkey'):
return source_data[:5]
if index.column() == NetworkTableModel.columns_types.index(
'current_block'):
if source_data == -1:
return ""
else:
return source_data
if index.column() == NetworkTableModel.columns_types.index('address') \
or index.column() == NetworkTableModel.columns_types.index('port') \
or index.column() == NetworkTableModel.columns_types.index('api'):
return "<p>" + source_data.replace('\n', "<br>") + "</p>"
if index.column() == NetworkTableModel.columns_types.index(
'current_hash'):
return source_data[:10]
if role == Qt.TextAlignmentRole:
if source_index.column() == NetworkTableModel.columns_types.index('address') \
or source_index.column() == self.sourceModel().columns_types.index('current_block'):
return Qt.AlignRight | Qt.AlignVCenter
if source_index.column() == NetworkTableModel.columns_types.index(
'is_member'):
return Qt.AlignCenter
if role == Qt.FontRole:
is_root_col = NetworkTableModel.columns_types.index('is_root')
index_root_col = source_model.index(source_index.row(),
is_root_col)
if source_model.data(index_root_col, Qt.DisplayRole):
font = QFont()
font.setBold(True)
return font
if role == Qt.BackgroundColorRole and self.app.parameters.dark_theme:
return source_data.darker()
return source_data
def __init__(self, parent=None):
super().__init__(parent)
self._data = np.random.randint(0, 100, size=(10, 4)) # type: np.ndarray
self._columns = [
QT_TRANSLATE_NOOP("Model", "First"),
QT_TRANSLATE_NOOP("Model", "Second"),
QT_TRANSLATE_NOOP("Model", "Third"),
QT_TRANSLATE_NOOP("Model", "Fourth"),
]
class MainWindow(QMainWindow):
listEntries = [
QT_TRANSLATE_NOOP("MainWindow", "First"),
QT_TRANSLATE_NOOP("MainWindow", "Second"),
QT_TRANSLATE_NOOP("MainWindow", "Third")
]
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.centralWidget = QWidget()
self.setCentralWidget(self.centralWidget)
self.createGroupBox()
listWidget = QListWidget()
for le in MainWindow.listEntries:
listWidget.addItem(self.tr(le))
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.groupBox)
mainLayout.addWidget(listWidget)
self.centralWidget.setLayout(mainLayout)
exitAction = QAction(self.tr("E&xit"),
self,
triggered=QApplication.instance().quit)
fileMenu = self.menuBar().addMenu(self.tr("&File"))
fileMenu.setPalette(QPalette(Qt.red))
fileMenu.addAction(exitAction)
self.setWindowTitle(self.tr("Language: %s") % self.tr("English"))
self.statusBar().showMessage(self.tr("Internationalization Example"))
if self.tr("LTR") == "RTL":
self.setLayoutDirection(Qt.RightToLeft)
def createGroupBox(self):
self.groupBox = QGroupBox(self.tr("View"))
perspectiveRadioButton = QRadioButton(self.tr("Perspective"))
isometricRadioButton = QRadioButton(self.tr("Isometric"))
obliqueRadioButton = QRadioButton(self.tr("Oblique"))
perspectiveRadioButton.setChecked(True)
self.groupBoxLayout = QVBoxLayout()
self.groupBoxLayout.addWidget(perspectiveRadioButton)
self.groupBoxLayout.addWidget(isometricRadioButton)
self.groupBoxLayout.addWidget(obliqueRadioButton)
self.groupBox.setLayout(self.groupBoxLayout)
def data(self, index, role):
source_index = self.mapToSource(index)
source_model = self.sourceModel()
if not source_index.isValid():
return QVariant()
source_data = source_model.data(source_index, role)
if role == Qt.DisplayRole:
if index.column() == NetworkTableModel.columns_types.index('is_member'):
value = {True: QT_TRANSLATE_NOOP("NetworkTableModel", 'yes'), False: QT_TRANSLATE_NOOP("NetworkTableModel", 'no'), None: QT_TRANSLATE_NOOP("NetworkTableModel", 'offline')}
return value[source_data]
if index.column() == NetworkTableModel.columns_types.index('pubkey'):
return source_data[:5]
if index.column() == NetworkTableModel.columns_types.index('current_block'):
if source_data == -1:
return ""
else:
return source_data
if index.column() == NetworkTableModel.columns_types.index('address') \
or index.column() == NetworkTableModel.columns_types.index('port'):
return "<p>" + source_data.replace('\n', "<br>") + "</p>"
if index.column() == NetworkTableModel.columns_types.index('current_hash') :
return source_data[:10]
if index.column() == NetworkTableModel.columns_types.index('current_time') and source_data:
return QLocale.toString(
QLocale(),
QDateTime.fromTime_t(source_data),
QLocale.dateTimeFormat(QLocale(), QLocale.ShortFormat)
)
if role == Qt.TextAlignmentRole:
if source_index.column() == NetworkTableModel.columns_types.index('address') or source_index.column() == self.sourceModel().columns_types.index('current_block'):
return Qt.AlignRight | Qt.AlignVCenter
if source_index.column() == NetworkTableModel.columns_types.index('is_member'):
return Qt.AlignCenter
if role == Qt.FontRole:
is_root_col = NetworkTableModel.columns_types.index('is_root')
index_root_col = source_model.index(source_index.row(), is_root_col)
if source_model.data(index_root_col, Qt.DisplayRole):
font = QFont()
font.setBold(True)
return font
return source_data
class General(SettingsPage):
Name = QT_TRANSLATE_NOOP('SettingsPageName', 'General')
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.setLayout(QVBoxLayout())
self.layout().setAlignment(Qt.AlignTop)
# Startup layout
self.layoutGroup = QGroupBox(self)
self.layoutGroup.setTitle(
translate('AppGeneralSettings', 'Startup layout'))
self.layoutGroup.setLayout(QVBoxLayout())
self.layout().addWidget(self.layoutGroup)
self.startupDialogCheck = QCheckBox(self.layoutGroup)
self.startupDialogCheck.setText(
translate('AppGeneralSettings', 'Use startup dialog'))
self.layoutGroup.layout().addWidget(self.startupDialogCheck)
self.layoutCombo = QComboBox(self.layoutGroup)
self.layoutCombo.addItems([lay.NAME for lay in layouts.get_layouts()])
self.layoutGroup.layout().addWidget(self.layoutCombo)
self.startupDialogCheck.clicked.connect(
lambda check: self.layoutCombo.setEnabled(not check))
# Application style
self.themeGroup = QGroupBox(self)
self.themeGroup.setTitle(
translate('AppGeneralSettings', 'Application theme'))
self.themeGroup.setLayout(QVBoxLayout())
self.layout().addWidget(self.themeGroup)
self.themeCombo = QComboBox(self.themeGroup)
self.themeCombo.addItems(styles.styles())
self.themeGroup.layout().addWidget(self.themeCombo)
def get_settings(self):
conf = {'Layout': {}, 'Theme': {}}
if self.startupDialogCheck.isChecked():
conf['Layout']['default'] = 'NoDefault'
else:
conf['Layout']['default'] = self.layoutCombo.currentText()
conf['Theme']['theme'] = self.themeCombo.currentText()
styles.apply_style(self.themeCombo.currentText())
return conf
def load_settings(self, settings):
if 'default' in settings['Layout']:
if settings['Layout']['default'].lower() == 'nodefault':
self.startupDialogCheck.setChecked(True)
self.layoutCombo.setEnabled(False)
else:
self.layoutCombo.setCurrentText(settings['Layout']['default'])
if 'theme' in settings['Theme']:
self.themeCombo.setCurrentText(settings['Theme']['theme'])
class Equalizer10(GstMediaElement):
ElementType = ElementType.Plugin
MediaType = MediaType.Audio
Name = QT_TRANSLATE_NOOP('MediaElementName', '10 Bands Equalizer')
band0 = GstProperty('equalizer', default=0)
band1 = GstProperty('equalizer', default=0)
band2 = GstProperty('equalizer', default=0)
band3 = GstProperty('equalizer', default=0)
band4 = GstProperty('equalizer', default=0)
band5 = GstProperty('equalizer', default=0)
band6 = GstProperty('equalizer', default=0)
band7 = GstProperty('equalizer', default=0)
band8 = GstProperty('equalizer', default=0)
band9 = GstProperty('equalizer', default=0)
def __init__(self, pipe):
super().__init__()
self.equalizer = Gst.ElementFactory.make("equalizer-10bands", None)
self.audio_converter = Gst.ElementFactory.make("audioconvert", None)
pipe.add(self.equalizer)
pipe.add(self.audio_converter)
self.equalizer.link(self.audio_converter)
def sink(self):
return self.equalizer
def src(self):
return self.audio_converter
class GstSettings(SettingsPage):
Name = QT_TRANSLATE_NOOP('SettingsPageName', 'GStreamer settings')
def __init__(self, **kwargs):
super().__init__()
self.setLayout(QVBoxLayout())
self.layout().setAlignment(Qt.AlignTop)
self.pipeGroup = QGroupBox(self)
self.pipeGroup.setLayout(QVBoxLayout())
self.layout().addWidget(self.pipeGroup)
self.pipeEdit = GstPipeEdit([], app_mode=True)
self.pipeGroup.layout().addWidget(self.pipeEdit)
self.retranslateUi()
def retranslateUi(self):
self.pipeGroup.setTitle(translate('GstSettings', 'Pipeline'))
def get_settings(self):
return {'Gst': {'pipeline': ', '.join(self.pipeEdit.get_pipe())}}
def load_settings(self, settings):
pipe = tuple(settings['Gst']['pipeline'].replace(' ', '').split(','))
self.pipeEdit.set_pipe(pipe)
def sentry_display(identity):
sentry_text = ""
sentry_symbol = ""
if identity.sentry:
sentry_symbol = "✴ "
sentry_text = QT_TRANSLATE_NOOP("BaseGraph", "(sentry)") + " "
return sentry_symbol, sentry_text
class Speed(GstMediaElement):
ElementType = ElementType.Plugin
MediaType = MediaType.Audio
Name = QT_TRANSLATE_NOOP('MediaElementName', 'Speed')
speed = Property(default=1.0)
def __init__(self, pipeline):
super().__init__()
self.pipeline = pipeline
self.scale_tempo = Gst.ElementFactory.make("scaletempo", None)
self.audio_convert = Gst.ElementFactory.make("audioconvert", None)
self.pipeline.add(self.scale_tempo)
self.pipeline.add(self.audio_convert)
self.scale_tempo.link(self.audio_convert)
bus = self.pipeline.get_bus()
bus.add_signal_watch()
self._handler = bus.connect("message", self.__on_message)
self._old_speed = self.speed
self.changed('speed').connect(self.__prepare_speed)
def __prepare_speed(self, value):
if self._old_speed != value:
self._old_speed = value
if self.pipeline.current_state == Gst.State.PLAYING:
self.__change_speed()
def sink(self):
return self.scale_tempo
def src(self):
return self.audio_convert
def dispose(self):
bus = self.pipeline.get_bus()
bus.remove_signal_watch()
bus.disconnect(self._handler)
def __on_message(self, bus, message):
if (message.type == Gst.MessageType.STATE_CHANGED and
message.src == self.scale_tempo and
message.parse_state_changed()[1] == Gst.State.PLAYING):
self.__change_speed()
def __change_speed(self):
current_position = self.scale_tempo.query_position(Gst.Format.TIME)[1]
self.scale_tempo.seek(self.speed,
Gst.Format.TIME,
Gst.SeekFlags.FLUSH | Gst.SeekFlags.ACCURATE,
Gst.SeekType.SET,
current_position,
Gst.SeekType.NONE,
0)
class StopAll(Cue):
Name = QT_TRANSLATE_NOOP('CueName', 'Stop-All')
action = Property(default=CueAction.Stop.value)
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.name = translate('CueName', self.Name)
def __start__(self, fade=False):
for cue in Application().cue_model:
action = self.__adjust_action(cue, CueAction(self.action))
if action:
cue.execute(action=action)
return False
def __adjust_action(self, cue, action, fade=False):
if action in cue.CueActions:
return action
elif action is CueAction.FadeOutPause:
return self.__adjust_action(cue, CueAction.Pause, True)
elif action is CueAction.Pause and fade:
return self.__adjust_action(cue, CueAction.FadeOutStop)
elif action is CueAction.FadeOutInterrupt:
return self.__adjust_action(cue, CueAction.Interrupt)
elif action is CueAction.FadeOutStop:
return self.__adjust_action(cue, CueAction.Stop)
return None
class CollectionCueSettings(SettingsPage):
Name = QT_TRANSLATE_NOOP('SettingsPageName', 'Edit Collection')
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.setLayout(QVBoxLayout(self))
self.cue_dialog = CueSelectDialog(
cues=Application().cue_model,
selection_mode=QAbstractItemView.ExtendedSelection)
self.collectionModel = CollectionModel()
self.collectionView = CollectionView(self.cue_dialog, parent=self)
self.collectionView.setModel(self.collectionModel)
self.collectionView.setAlternatingRowColors(True)
self.layout().addWidget(self.collectionView)
# Buttons
self.dialogButtons = QDialogButtonBox(self)
self.dialogButtons.setSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Minimum)
self.layout().addWidget(self.dialogButtons)
self.addButton = self.dialogButtons.addButton(
translate('CollectionCue', 'Add'), QDialogButtonBox.ActionRole)
self.addButton.clicked.connect(self._add_dialog)
self.delButton = self.dialogButtons.addButton(
translate('CollectionCue', 'Remove'), QDialogButtonBox.ActionRole)
self.delButton.clicked.connect(self._remove_selected)
def load_settings(self, settings):
for target_id, action in settings.get('targets', []):
target = Application().cue_model.get(target_id)
if target is not None:
self._add_cue(target, CueAction(action))
def get_settings(self):
targets = []
for target_id, action in self.collectionModel.rows:
targets.append((target_id, action.value))
return {'targets': targets}
def _add_cue(self, cue, action):
self.collectionModel.appendRow(cue.__class__, cue.id, action)
self.cue_dialog.remove_cue(cue)
def _add_dialog(self):
if self.cue_dialog.exec_() == QDialog.Accepted:
for target in self.cue_dialog.selected_cues():
self._add_cue(target, target.CueActions[0])
def _remove_selected(self):
row = self.collectionView.currentIndex().row()
cue_id = self.collectionModel.rows[row][0]
self.collectionModel.removeRow(row)
self.cue_dialog.add_cue(Application().cue_model.get(cue_id))
class KeyboardSettings(CueSettingsPage):
Name = QT_TRANSLATE_NOOP('SettingsPageName', 'Keyboard Shortcuts')
def __init__(self, cue_class, **kwargs):
super().__init__(cue_class, **kwargs)
self.setLayout(QVBoxLayout())
self.layout().setAlignment(Qt.AlignTop)
self.keyGroup = QGroupBox(self)
self.keyGroup.setLayout(QGridLayout())
self.layout().addWidget(self.keyGroup)
self.keyboardModel = SimpleTableModel([
translate('ControllerKeySettings', 'Key'),
translate('ControllerKeySettings', 'Action')])
self.keyboardView = KeyboardView(cue_class, parent=self.keyGroup)
self.keyboardView.setModel(self.keyboardModel)
self.keyGroup.layout().addWidget(self.keyboardView, 0, 0, 1, 2)
self.addButton = QPushButton(self.keyGroup)
self.addButton.clicked.connect(self.__new_key)
self.keyGroup.layout().addWidget(self.addButton, 1, 0)
self.removeButton = QPushButton(self.keyGroup)
self.removeButton.clicked.connect(self.__remove_key)
self.keyGroup.layout().addWidget(self.removeButton, 1, 1)
self.retranslateUi()
def retranslateUi(self):
self.keyGroup.setTitle(translate('ControllerKeySettings', 'Shortcuts'))
self.addButton.setText(translate('ControllerSettings', 'Add'))
self.removeButton.setText(translate('ControllerSettings', 'Remove'))
def enable_check(self, enabled):
self.keyGroup.setCheckable(enabled)
self.keyGroup.setChecked(False)
def get_settings(self):
settings = {}
if not (self.keyGroup.isCheckable() and not self.keyGroup.isChecked()):
settings['keyboard'] = self.keyboardModel.rows
return settings
def load_settings(self, settings):
for key, action in settings.get('keyboard', []):
self.keyboardModel.appendRow(key, action)
def __new_key(self):
self.keyboardModel.appendRow('', self._cue_class.CueActions[0].name)
def __remove_key(self):
self.keyboardModel.removeRow(self.keyboardView.currentIndex().row())
def contextMenuEvent(self, event: QGraphicsSceneContextMenuEvent):
"""
Right click on node to show node menu
Except on wallet node
:param event: scene context menu event
"""
# Â no menu on the wallet node
if self.status_wallet:
return None
#Â create node context menus
self.menu = QMenu()
# action show member
QT_TRANSLATE_NOOP('WoT.Node', 'Informations')
self.action_show_member = QAction(
QCoreApplication.translate('WoT.Node', 'Informations'),
self.scene())
self.menu.addAction(self.action_show_member)
self.action_show_member.triggered.connect(self.member_action)
#Â action add identity as contact
QT_TRANSLATE_NOOP('WoT.Node', 'Add as contact')
self.action_contact = QAction(
QCoreApplication.translate('WoT.Node', 'Add as contact'),
self.scene())
self.menu.addAction(self.action_contact)
self.action_contact.triggered.connect(self.contact_action)
#Â action transaction toward identity
QT_TRANSLATE_NOOP('WoT.Node', 'Send money')
self.action_transaction = QAction(
QCoreApplication.translate('WoT.Node', 'Send money'), self.scene())
self.menu.addAction(self.action_transaction)
self.action_transaction.triggered.connect(self.transaction_action)
#Â action sign identity
QT_TRANSLATE_NOOP('WoT.Node', 'Certify identity')
self.action_sign = QAction(
QCoreApplication.translate('WoT.Node', 'Certify identity'),
self.scene())
self.menu.addAction(self.action_sign)
self.action_sign.triggered.connect(self.sign_action)
# run menu
self.menu.exec(event.screenPos())
class AutoSrc(GstSrcElement):
MediaType = MediaType.Audio
Name = QT_TRANSLATE_NOOP('MediaElementName', 'System Input')
def __init__(self, pipe):
super().__init__()
self.auto_src = Gst.ElementFactory.make("autoaudiosrc", "src")
pipe.add(self.auto_src)
def src(self):
return self.auto_src
class CueAppSettings(SettingsPage):
Name = QT_TRANSLATE_NOOP('SettingsPageName', 'Cue Settings')
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.setLayout(QVBoxLayout())
self.layout().setAlignment(Qt.AlignTop)
# Interrupt
self.interruptGroup = QGroupBox(self)
self.interruptGroup.setLayout(QVBoxLayout())
self.layout().addWidget(self.interruptGroup)
self.interruptFadeEdit = FadeEdit(self.interruptGroup)
self.interruptGroup.layout().addWidget(self.interruptFadeEdit)
# Action
self.actionGroup = QGroupBox(self)
self.actionGroup.setLayout(QVBoxLayout())
self.layout().addWidget(self.actionGroup)
self.fadeActionEdit = FadeEdit(self.actionGroup)
self.actionGroup.layout().addWidget(self.fadeActionEdit)
self.retranslateUi()
def retranslateUi(self):
self.interruptGroup.setTitle(translate('CueSettings',
'Interrupt Fade'))
self.actionGroup.setTitle(translate('CueSettings', 'Fade Action'))
def load_settings(self, settings):
# Interrupt
self.interruptFadeEdit.setDuration(
float(settings['Cue'].get('interruptfade', 0)))
self.interruptFadeEdit.setFadeType(settings['Cue'].get(
'interruptfadetype', ''))
# FadeAction
self.fadeActionEdit.setDuration(
float(settings['Cue'].get('fadeactionduration', 0)))
self.fadeActionEdit.setFadeType(settings['Cue'].get(
'fadeactiontype', ''))
def get_settings(self):
return {
'Cue': {
'interruptfade': str(self.interruptFadeEdit.duration()),
'interruptfadetype': self.interruptFadeEdit.fadeType(),
'fadeactionduration': str(self.fadeActionEdit.duration()),
'fadeactiontype': self.fadeActionEdit.fadeType()
}
}
class UriInput(GstSrcElement):
MediaType = MediaType.Audio
Name = QT_TRANSLATE_NOOP('MediaElementName', 'URI Input')
uri = GstProperty('decoder', default='')
download = GstProperty('decoder', default=False)
buffer_size = GstProperty('decoder', default=-1, gst_name='buffer-size')
use_buffering = GstProperty('decoder', default=False,
gst_name='use-buffering')
_mtime = Property(default=-1)
def __init__(self, pipe):
super().__init__()
self.decoder = Gst.ElementFactory.make("uridecodebin", None)
self.audio_convert = Gst.ElementFactory.make("audioconvert", None)
self._handler = self.decoder.connect("pad-added", self.__on_pad_added)
pipe.add(self.decoder)
pipe.add(self.audio_convert)
self.changed('uri').connect(self.__uri_changed)
def input_uri(self):
return self.uri
def dispose(self):
self.decoder.disconnect(self._handler)
def src(self):
return self.audio_convert
def __on_pad_added(self, *args):
self.decoder.link(self.audio_convert)
def __uri_changed(self, value):
# Save the current mtime (file flag for last-change time)
mtime = self._mtime
# If the uri is a file, then update the current mtime
if value.split('://')[0] == 'file':
if path.exists(value.split('//')[1]):
self._mtime = path.getmtime(value.split('//')[1])
else:
mtime = None
# If something is changed or the duration is invalid
if mtime != self._mtime or self.duration < 0:
self.__duration()
@async_in_pool(pool=ThreadPoolExecutor(1))
def __duration(self):
self.duration = gst_uri_duration(self.uri)
class AutoSink(GstMediaElement):
ElementType = ElementType.Output
MediaType = MediaType.Audio
Name = QT_TRANSLATE_NOOP('MediaElementName', 'System Out')
def __init__(self, pipe):
super().__init__()
self.auto_sink = Gst.ElementFactory.make('autoaudiosink', 'sink')
pipe.add(self.auto_sink)
def sink(self):
return self.auto_sink
class ToolbarView(QFrame, Ui_SakiaToolbar):
"""
The model of Navigation component
"""
_action_revoke_uid_text = QT_TRANSLATE_NOOP("ToolbarView", "Publish a revocation document")
def __init__(self, parent):
super().__init__(parent)
self.setupUi(self)
tool_menu = QMenu(self.tr("Tools"), self.toolbutton_menu)
self.toolbutton_menu.setMenu(tool_menu)
self.action_add_connection = QAction(self.tr("Add a connection"), tool_menu)
tool_menu.addAction(self.action_add_connection)
self.action_revoke_uid = QAction(self.tr(ToolbarView._action_revoke_uid_text), self)
tool_menu.addAction(self.action_revoke_uid)
self.action_parameters = QAction(self.tr("Settings"), tool_menu)
tool_menu.addAction(self.action_parameters)
self.action_plugins = QAction(self.tr("Plugins manager"), tool_menu)
tool_menu.addAction(self.action_plugins)
self.action_about = QAction(self.tr("About"), tool_menu)
tool_menu.addAction(self.action_about)
self.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Minimum)
self.setMaximumHeight(60)
async def ask_for_connection(self, connections):
connections_titles = [c.title() for c in connections]
input_dialog = QInputDialog()
input_dialog.setComboBoxItems(connections_titles)
input_dialog.setWindowTitle(self.tr("Membership"))
input_dialog.setLabelText(self.tr("Select a connection"))
await dialog_async_exec(input_dialog)
result = input_dialog.textValue()
if input_dialog.result() == QDialog.Accepted:
for c in connections:
if c.title() == result:
return c
def show_about(self, text):
dialog = QDialog(self)
about_dialog = Ui_AboutPopup()
about_dialog.setupUi(dialog)
about_dialog.label.setText(text)
dialog.exec()
class MediaCueAppSettings(SettingsPage):
Name = QT_TRANSLATE_NOOP('SettingsPageName', 'MediaCue Settings')
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.setLayout(QVBoxLayout())
self.layout().setAlignment(Qt.AlignTop)
self.group = QGroupBox(self)
self.group.setLayout(QGridLayout())
self.layout().addWidget(self.group)
# Fade Duration
self.fadeDurationSpin = QDoubleSpinBox(self.group)
self.fadeDurationSpin.setRange(0, 3600)
self.group.layout().addWidget(self.fadeDurationSpin, 0, 0)
self.fadeDurationLabel = QLabel(self.group)
self.fadeDurationLabel.setAlignment(Qt.AlignCenter)
self.group.layout().addWidget(self.fadeDurationLabel, 0, 1)
# Fade Type
self.fadeTypeCombo = FadeComboBox(self.group)
self.group.layout().addWidget(self.fadeTypeCombo, 1, 0)
self.fadeTypeLabel = QLabel(self.group)
self.fadeTypeLabel.setAlignment(Qt.AlignCenter)
self.group.layout().addWidget(self.fadeTypeLabel, 1, 1)
self.retranslateUi()
def retranslateUi(self):
self.group.setTitle(
translate('MediaCueSettings', 'Interrupt settings'))
self.fadeDurationLabel.setText(
translate('MediaCueSettings', 'Interrupt fade duration'))
self.fadeTypeLabel.setText(
translate('MediaCueSettings', 'Interrupt fade type'))
def load_settings(self, settings):
self.fadeDurationSpin.setValue(
float(settings['MediaCue'].get('interruptfade', 0)))
self.fadeTypeCombo.setCurrentType(
settings['MediaCue'].get('interruptfadetype', ''))
def get_settings(self):
return {'MediaCue': {
'interruptfade': str(self.fadeDurationSpin.value()),
'interruptfadetype': self.fadeTypeCombo.currentType()
}}
class DbMeter(GstMediaElement):
ElementType = ElementType.Plugin
MediaType = MediaType.Audio
Name = QT_TRANSLATE_NOOP('MediaElementName', 'dB Meter')
interval = GstProperty('level', default=50 * Gst.MSECOND)
peak_ttl = GstProperty('level', default=Gst.SECOND, gst_name='peak-ttl')
peak_falloff = GstProperty('level', default=20, gst_name='peak-falloff')
def __init__(self, pipeline):
super().__init__()
self.level_ready = Signal()
self.pipeline = pipeline
self.level = Gst.ElementFactory.make('level', None)
self.level.set_property('post-messages', True)
self.level.set_property('interval', 50 * Gst.MSECOND)
self.level.set_property('peak-ttl', Gst.SECOND)
self.level.set_property('peak-falloff', 20)
self.audio_convert = Gst.ElementFactory.make('audioconvert', None)
self.pipeline.add(self.level)
self.pipeline.add(self.audio_convert)
self.level.link(self.audio_convert)
bus = self.pipeline.get_bus()
bus.add_signal_watch()
self._handler = bus.connect('message::element', self.__on_message)
def dispose(self):
bus = self.pipeline.get_bus()
bus.remove_signal_watch()
bus.disconnect(self._handler)
def sink(self):
return self.level
def src(self):
return self.audio_convert
def __on_message(self, bus, message):
if message.src == self.level:
structure = message.get_structure()
if structure is not None and structure.has_name('level'):
self.level_ready.emit(structure.get_value('peak'),
structure.get_value('rms'),
structure.get_value('decay'))
class PulseSink(GstMediaElement):
ElementType = ElementType.Output
MediaType = MediaType.Audio
Name = QT_TRANSLATE_NOOP('MediaElementName', 'PulseAudio Out')
def __init__(self, pipe):
super().__init__()
self.pulse_sink = Gst.ElementFactory.make('pulsesink', 'sink')
self.pulse_sink.set_property('client-name', 'Linux Show Player')
pipe.add(self.pulse_sink)
def sink(self):
return self.pulse_sink
class AlsaSink(GstMediaElement):
ElementType = ElementType.Output
MediaType = MediaType.Audio
Name = QT_TRANSLATE_NOOP('MediaElementName', 'ALSA Out')
device = GstProperty('alsa_sink', default='')
def __init__(self, pipe):
super().__init__()
self.alsa_sink = Gst.ElementFactory.make('alsasink', 'sink')
pipe.add(self.alsa_sink)
def sink(self):
return self.alsa_sink
class Status(dict):
Keys = ('demo', 'pass', 'owned', 'ordered', 'bidding', 'sold', 'sale',
'wish', 'missing')
Titles = (
QT_TRANSLATE_NOOP("Status", "Demo"),
QT_TRANSLATE_NOOP("Status", "Pass"),
QT_TRANSLATE_NOOP("Status", "Owned"),
QT_TRANSLATE_NOOP("Status", "Ordered"),
QT_TRANSLATE_NOOP("Status", "Bidding"),
QT_TRANSLATE_NOOP("Status", "Sold"),
QT_TRANSLATE_NOOP("Status", "Sale"),
QT_TRANSLATE_NOOP("Status", "Wish"),
QT_TRANSLATE_NOOP("Status", "Missing"),
)
def __init__(self):
for key, value in zip(self.Keys, self.Titles):
dict.__setitem__(self, key, value)
def keys(self):
return self.Keys
def items(self):
result = []
for key in self.Keys:
result.append((key, self.__getitem__(key)))
return result
def values(self):
result = []
for key in self.Keys:
result.append(self.__getitem__(key))
return result
def __getitem__(self, key):
try:
value = dict.__getitem__(self, key)
return QApplication.translate("Status", value)
except KeyError:
return ''
class CollectionCue(Cue):
Name = QT_TRANSLATE_NOOP('CueName', 'Collection Cue')
targets = Property(default=[])
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.name = translate('CueName', self.Name)
def __start__(self, fade=False):
for target_id, action in self.targets:
cue = Application().cue_model.get(target_id)
if cue is not self:
cue.execute(action=CueAction[action])
return False
class SeekCue(Cue):
Name = QT_TRANSLATE_NOOP('CueName', 'Seek Cue')
target_id = Property()
time = Property(default=-1)
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.name = translate('CueName', self.Name)
def __start__(self, fade=False):
cue = Application().cue_model.get(self.target_id)
if isinstance(cue, MediaCue) and self.time >= 0:
cue.media.seek(self.time)
return False
class MidiCue(Cue):
Name = QT_TRANSLATE_NOOP('CueName', 'MIDI Cue')
message = Property(default='')
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.name = translate('CueName', self.Name)
midi_out = MIDIOutput()
if not midi_out.is_open():
midi_out.open()
def __start__(self, fade=False):
if self.message:
MIDIOutput().send_from_str(self.message)
return False
class StopAllSettings(SettingsPage):
Name = QT_TRANSLATE_NOOP('SettingsPageName', 'Stop Settings')
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.setLayout(QVBoxLayout())
self.layout().setAlignment(Qt.AlignTop)
self.group = QGroupBox(self)
self.group.setLayout(QVBoxLayout(self.group))
self.layout().addWidget(self.group)
self.actionCombo = QComboBox(self.group)
for action in [
CueAction.Stop, CueAction.FadeOutStop, CueAction.Pause,
CueAction.FadeOutPause, CueAction.Interrupt,
CueAction.FadeOutInterrupt
]:
self.actionCombo.addItem(translate('CueAction', action.name),
action.value)
self.group.layout().addWidget(self.actionCombo)
self.retranslateUi()
def retranslateUi(self):
self.group.setTitle(translate('StopAll', 'Stop Action'))
def enable_check(self, enabled):
self.group.setCheckable(enabled)
self.group.setChecked(False)
def get_settings(self):
conf = {}
if not (self.group.isCheckable() and not self.group.isChecked()):
conf['action'] = self.actionCombo.currentData()
return conf
def load_settings(self, settings):
self.actionCombo.setCurrentText(
translate('CueAction', settings.get('action', '')))
class Volume(GstMediaElement):
ElementType = ElementType.Plugin
MediaType = MediaType.Audio
Name = QT_TRANSLATE_NOOP('MediaElementName', 'Volume')
mute = GstProperty('gst_volume', default=False)
volume = GstProperty('gst_volume', default=1.0)
normal_volume = GstProperty('gst_normal_volume',
default=1.0,
gst_name='volume')
current_mute = GstRuntimeProperty('gst_volume', 'mute')
current_volume = GstRuntimeProperty('gst_volume', 'volume')
def __init__(self, pipe):
super().__init__()
self.gst_volume = Gst.ElementFactory.make("volume", None)
self.gst_normal_volume = Gst.ElementFactory.make("volume", None)
self.audio_convert = Gst.ElementFactory.make("audioconvert", None)
pipe.add(self.gst_normal_volume)
pipe.add(self.gst_volume)
pipe.add(self.audio_convert)
self.gst_volume.link(self.gst_normal_volume)
self.gst_normal_volume.link(self.audio_convert)
def sink(self):
return self.gst_volume
def src(self):
return self.audio_convert
def stop(self):
self.current_mute = self.mute
self.current_volume = self.volume
def interrupt(self):
self.stop()
class AudioPan(GstMediaElement):
ElementType = ElementType.Plugin
MediaType = MediaType.Audio
Name = QT_TRANSLATE_NOOP('MediaElementName', 'Audio Pan')
pan = GstProperty('panorama', default=.0, gst_name='panorama')
def __init__(self, pipe):
super().__init__()
self.panorama = Gst.ElementFactory.make("audiopanorama", None)
self.audio_convert = Gst.ElementFactory.make("audioconvert", None)
pipe.add(self.panorama)
pipe.add(self.audio_convert)
self.panorama.link(self.audio_convert)
def sink(self):
return self.panorama
def src(self):
return self.audio_convert
class IndexActionCue(Cue):
Name = QT_TRANSLATE_NOOP('CueName', 'Index Action')
target_index = Property(default=-1)
relative = Property(default=True)
action = Property(default=CueAction.Stop.value)
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.name = translate('CueName', self.Name)
def __start__(self, fade=False):
if self.relative:
index = self.index + self.target_index
else:
index = self.target_index
try:
cue = Application().layout.model_adapter.item(index)
if cue is not self:
cue.execute(CueAction(self.action))
except IndexError:
pass
