def OnEditSig(self, widget, event):
"""
Called when the user clicks the time signature box.
This method will show a dialog for changing the time signature.
Parameters:
widget -- reserved for GTK callbacks, don't use it explicitly.
event -- reserved for GTK callbacks, don't use it explicitly.
"""
if event.type == gtk.gdk.BUTTON_PRESS:
if not self.sigDialog:
self.gtk_builder = Globals.LoadGtkBuilderFilename(
"TimeSignatureDialog.ui")
signals = {
"on_spinBeats_value_changed": self.OnNomValueChange,
"on_comboValue_changed": self.OnDenomValueChange,
"on_buttonClose_clicked": self.OnSigDialogClose
}
self.gtk_builder.connect_signals(signals)
# references to GUI widgets
self.sigDialog = self.gtk_builder.get_object(
"TimeSignatureDialog")
self.spinBeats = self.gtk_builder.get_object("spinBeats")
self.comboValue = self.gtk_builder.get_object("comboValue")
# set some properties for the widgets
self.sigDialog.set_icon(self.mainview.icon)
self.spinBeats.set_value(self.project.meter_nom)
self.comboValue.set_active(
int(log(self.project.meter_denom, 2)))
else:
self.sigDialog.present()
def __init__(self, parent):
"""
Creates a new instance of ExtensionManagerDialog.
Parameters:
parent -- the parent MainApp Jokosher window.
"""
self.parent = parent
self.gtk_builder = Globals.LoadGtkBuilderFilename(
"ExtensionManagerDialog.ui")
signals = {
"on_Close_clicked": self.OnClose,
"on_Add_clicked": self.OnAdd,
"on_Remove_clicked": self.OnRemove,
"on_Treeview_selected": self.OnSelect,
"on_Preferences_clicked": self.OnPreferences
}
self.gtk_builder.connect_signals(signals)
self.dlg = self.gtk_builder.get_object("ExtensionManagerDialog")
self.tree = self.gtk_builder.get_object("treeviewExtensions")
self.eb = self.gtk_builder.get_object("descriptionEventBox")
self.description = self.gtk_builder.get_object("ExtensionDescription")
self.prefs_button = self.gtk_builder.get_object("buttonPreferences")
self.AddColumn("Enabled", 0, 'toggle')
self.AddColumn("Name", 1, 'text', 30)
self.AddColumn("Version", 3, 'text', 7)
self.model = gtk.ListStore(bool, str, str, str, str, bool)
self.tree.set_model(self.model)
for extension in self.parent.extensionManager.GetExtensions():
self.model.append(
(extension["enabled"], extension["name"],
extension["description"], extension["version"],
extension["filename"], extension["preferences"]))
self.dlg.set_transient_for(self.parent.window)
self.dlg.show()
def __init__(self, project, parent):
"""
Creates a new instance of InstrumentConnectionsDialog.
Parameters:
project -- the currently active Project.
parent -- reference to the MainApp Jokosher window.
"""
if project:
self.project = project
else:
return
self.gtk_builder = Globals.LoadGtkBuilderFilename(
"InstrumentConnectionsDialog.ui")
self.signals = {
"on_close_clicked": self.OnClose,
"on_change_sound_system": self.OnChangeSoundSystem,
}
self.gtk_builder.connect_signals(self.signals)
self.window = self.gtk_builder.get_object(
"InstrumentConnectionsDialog")
self.vbox = self.gtk_builder.get_object("vbox")
if len(self.project.instruments) > 0:
self.Populate()
else:
self.gtk_builder.get_object("explainLabel").set_text(
_("There are no instruments to connect"))
self.parent = parent
self.window.set_icon(self.parent.icon)
## centre the InstrumentConnectionsDialog on the main jokosher window
self.window.set_transient_for(self.parent.window)
self.window.show_all()
def __init__(self, project, parent, instr=None):
"""
Creates a new instance of AddInstrumentDialog.
Parameters:
project -- the Project to add instruments to.
parent -- parent window of the AddInstrumentDialog (JokosherApp).
instr -- if present, indicates the Instrument whose type wants to be changed.
"""
self.parent = parent
self.project = project
self.instr = instr
self.gtk_builder = Globals.LoadGtkBuilderFilename(
"AddInstrumentDialog.ui")
self.signals = {
"on_OK_clicked": self.OnOK,
"on_Cancel_clicked": self.OnCancel,
"on_instrument_search_changed": self.OnSearchChange,
"on_AddInstrument_configure_event": self.OnResize,
"on_AddInstrument_destroy": self.OnDestroy,
}
self.gtk_builder.connect_signals(self.signals)
self.dlg = self.gtk_builder.get_object("AddInstrumentDialog")
self.tree = self.gtk_builder.get_object("Instruments")
self.search_entry = self.gtk_builder.get_object("instrument_search")
self.search_entry.set_activates_default(True)
self.okbutton = self.gtk_builder.get_object("okButton")
self.okbutton.set_sensitive(False)
self.okbutton.set_flags(gtk.CAN_DEFAULT)
self.okbutton.grab_default()
if self.instr:
self.dlg.set_title(_("Change Instrument Type"))
self.gtk_builder.get_object("instructions").set_text(
_("Choose the new instrument type for %s") % self.instr.name)
self.okbutton.set_label("gtk-ok")
self.tree.connect("item-activated", self.OnSelected)
self.tree.connect("selection-changed", self.OnSelectionChanged)
self.model = gtk.ListStore(str, str, gtk.gdk.Pixbuf)
for instr in Globals.getCachedInstruments():
lineList = [x.center(12) for x in textwrap.wrap(instr[0], 11)]
newList = "\n".join(lineList)
self.model.append((newList, instr[1], instr[2]))
self.tree.set_model(self.model)
self.tree.set_text_column(0)
self.tree.set_pixbuf_column(2)
self.tree.set_orientation(gtk.ORIENTATION_VERTICAL)
if self.instr:
self.tree.set_selection_mode(gtk.SELECTION_SINGLE)
else:
self.tree.set_selection_mode(gtk.SELECTION_MULTIPLE)
self.tree.set_item_width(90)
self.tree.set_size_request(72, -1)
self.width = int(Globals.settings.general["addinstrumentwindowwidth"])
self.height = int(
Globals.settings.general["addinstrumentwindowheight"])
self.dlg.resize(self.width, self.height)
self.dlg.set_icon(self.parent.icon)
self.dlg.set_transient_for(self.parent.window)
self.dlg.show()
def __init__(self, project, mainwindow, icon=None):
"""
Creates a new instance of PreferencesDialog.
Parameters:
project -- the currently active Project.
mainwindow -- the main Jokosher window (MainApp).
icon -- the icon for the window manager to display for this window (optional).
"""
self.project = project
self.mainwindow = mainwindow
#Initialize GTK resources from gtk builder file
self.gtk_builder = Globals.LoadGtkBuilderFilename(
"PreferencesDialog.ui")
self.signals = {
"on_Setting_changed": self.OnSettingChanged,
"on_playbackSink_changed": self.OnPlaybackSinkChanged,
"on_recordingSoundSystem_changed": self.OnRecordingSystemChanged,
"on_Close_clicked": self.OnClose,
}
self.gtk_builder.connect_signals(self.signals)
self.dlg = self.gtk_builder.get_object("PreferencesDialog")
self.dlg.set_icon(icon)
self.recordingFileFormat = self.gtk_builder.get_object(
"recordingFileFormat")
self.recordingCustomPipeline = self.gtk_builder.get_object(
"recordingCustomPipeline")
self.recordingSoundSystem = self.gtk_builder.get_object(
"recordingSoundSystem")
self.samplingRate = self.gtk_builder.get_object("samplingRate")
self.bitRateCombo = self.gtk_builder.get_object("bitRate")
self.bitRateLabel = self.gtk_builder.get_object("bitRateLabel")
self.playbackDevice = self.gtk_builder.get_object("playbackDevice")
self.playbackSink = self.gtk_builder.get_object("playbackSink")
self.customSink = self.gtk_builder.get_object("customSink")
self.radioNewProject = self.gtk_builder.get_object("startupNewProject")
self.radioLastProject = self.gtk_builder.get_object(
"startupLastProject")
self.radioNothing = self.gtk_builder.get_object("startupNothing")
#Load settings - set to True to make sure data isn't saved to file until everything is loaded
self.loadingSettings = True
## Load recording sound system
audioSrcSetting = Globals.settings.recording["audiosrc"]
self.recordingCustomPipeline.set_text(audioSrcSetting)
self.recordingSoundSystem.append_text(_("Custom"))
self.recordingSoundSystem.set_active(0)
for name, element in Globals.CAPTURE_BACKENDS:
self.recordingSoundSystem.append_text(name)
if audioSrcSetting == element:
index = len(self.recordingSoundSystem.get_model()) - 1
self.recordingSoundSystem.set_active(index)
if self.recordingSoundSystem.get_active() == 0:
self.recordingCustomPipeline.set_sensitive(True)
else:
self.recordingCustomPipeline.set_sensitive(False)
## Load playback sound system
audioSinkSetting = Globals.settings.playback["audiosink"]
self.customSink.set_text(audioSinkSetting)
self.playbackSink.append_text(_("Custom"))
self.playbackSink.set_active(0)
for name, element in Globals.PLAYBACK_BACKENDS:
self.playbackSink.append_text(name)
if audioSinkSetting == element:
index = len(self.playbackSink.get_model()) - 1
self.playbackSink.set_active(index)
if self.playbackSink.get_active() == 0:
self.customSink.set_sensitive(True)
else:
self.customSink.set_sensitive(False)
self.ProbeBackendDevices()
#Get available sample rates from ALSA
sample_values = AudioBackend.GetRecordingSampleRate()
i18nText = "%(sample rate)d Hz"
#add tuple of (display string, rate value)
self.sampleRateList = [(_("Autodetect"), 0)]
if type(sample_values) == int:
text = i18nText % {"sample rate": sample_values}
self.sampleRateList.append((text, sample_values))
elif type(sample_values) == list:
for i, rate in enumerate(sample_values):
text = i18nText % {"sample rate": rate}
self.sampleRateList.append((text, rate))
#check if it is an IntRange
elif hasattr(sample_values, "low") and hasattr(sample_values, "high"):
#add the default sample rates if they are within the supported range
for rate in Globals.SAMPLE_RATES:
if sample_values.low <= rate <= sample_values.high:
text = i18nText % {"sample rate": rate}
self.sampleRateList.append((text, rate))
sampleRateSetting = 0
sampleRateSettingIndex = 0
try:
#try to convert the setting string to an int
sampleRateSetting = int(Globals.settings.recording["samplerate"])
except ValueError:
pass
else:
#if they have put in a custom preference which is not ordinarily detected, add it to the list
if sampleRateSetting not in [y for x, y in self.sampleRateList]:
text = i18nText % {"sample rate": sampleRateSetting}
self.sampleRateList.append((text, sampleRateSetting))
for text, value in self.sampleRateList:
self.samplingRate.append_text(text)
if value == sampleRateSetting:
sampleRateSettingIndex = self.sampleRateList.index(
(text, value))
self.samplingRate.set_active(sampleRateSettingIndex)
#Bit rate settings for lossy file formats
try:
bitRateSetting = int(Globals.settings.recording["bitrate"])
if Globals.settings.recording["file_extension"] == "ogg":
# vorbisenc uses bps instead of kbps
bitRateSetting /= 1024
except KeyError:
bitRateSetting = int(Globals.DEFAULT_BIT_RATE)
if bitRateSetting == 0:
bitRateSetting = int(Globals.DEFAULT_BIT_RATE)
for index, bitrate in enumerate(Globals.BIT_RATES):
self.bitRateCombo.append_text("%d kbps" % bitrate)
if bitrate == bitRateSetting:
self.bitRateCombo.set_active(index)
fileFormatSetting = Globals.settings.recording["fileformat"]
fileFormatSettingIndex = 0
setBitRate = False
#get all the encoders from Globals
for exportFormat in Globals.EXPORT_FORMATS:
self.recordingFileFormat.append_text(
"%s (.%s)" %
(exportFormat["description"], exportFormat["extension"]))
if fileFormatSetting == exportFormat["pipeline"]:
fileFormatSettingIndex = Globals.EXPORT_FORMATS.index(
exportFormat)
setBitRate = exportFormat["setBitRate"]
self.recordingFileFormat.set_active(fileFormatSettingIndex)
# configure the application startup radio buttons
startupValue = Globals.settings.general["startupaction"]
if startupValue == STARTUP_LAST_PROJECT:
self.radioLastProject.set_active(True)
elif startupValue == STARTUP_NEW_PROJECT:
self.radioNewProject.set_active(True)
else: #default in case no preference is saved
self.radioNothing.set_active(True)
self.loadingSettings = False
self.dlg.show_all()
self.ShowBitRate(setBitRate)
