def enableKeyboard(self):
self.keyboardStandAlone = KeyboardStandAlone(
self.sequencer.recording,
self.sequencer.adjustDuration,
self.csnd.loopGetTick,
self.sequencer.getPlayState, self.loop)
def enableKeyboard(self):
self.keyboardStandAlone = KeyboardStandAlone(
self.sequencer.recording,
self.sequencer.adjustDuration,
self.csnd.loopGetTick,
self.sequencer.getPlayState, self.loop)
self.add_events(gtk.gdk.BUTTON_PRESS_MASK)
class SimplePianoActivity(activity.Activity):
"""SimplePianoActivity class as specified in activity.info"""
def __init__(self, handle):
activity.Activity.__init__(self, handle)
GLib.unix_signal_add(GLib.PRIORITY_DEFAULT, signal.SIGINT, self.close)
Gst.init(None)
self._what_list = []
self.play_recording_thread = None
self.playing_recording = False
self.firstTime = False
self.playing = False
self.regularity = 0.7
self._drums_store = []
self.recording = False
self.recorded_keys = []
self.is_valid_recording = False
# we do not have collaboration features
# make the share option insensitive
self.max_participants = 1
self.csnd = new_csound_client()
self.rythmInstrument = 'drum1kick'
# toolbar with the new toolbar redesign
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
toolbar_box.toolbar.set_style(Gtk.ToolbarStyle.BOTH_HORIZ)
self.play_index = 0
self.play_recording_button = ToolButton(
icon_name='media-playback-start')
self.play_recording_button.set_property('can-default', True)
self.play_recording_button.show()
self.record_button = ToggleToolButton(icon_name='media-record')
self.record_button.set_property('can-default', True)
self.record_button.show()
self.play_recording_button.set_sensitive(False)
self.record_button.connect('clicked', self.__record_button_click_cb)
self.play_recording_button.connect('clicked',
self.handlePlayRecordingButton)
toolbar_box.toolbar.set_style(Gtk.ToolbarStyle.BOTH_HORIZ)
# TODO: disabe until is implemented with csnd6
# self.createPercussionToolbar(toolbar_box)
toolbar_box.toolbar.insert(Gtk.SeparatorToolItem(), -1)
keybord_labels = RadioToolButton()
keybord_labels.props.icon_name = 'q_key'
keybord_labels.props.group = keybord_labels
keybord_labels.connect('clicked', self.set_keyboard_labels_cb)
toolbar_box.toolbar.insert(keybord_labels, -1)
notes_labels = RadioToolButton()
notes_labels.props.icon_name = 'do_key'
notes_labels.props.group = keybord_labels
notes_labels.connect('clicked', self.set_notes_labels_cb)
toolbar_box.toolbar.insert(notes_labels, -1)
ti_notes_labels = RadioToolButton()
ti_notes_labels.props.icon_name = 'ti_key'
ti_notes_labels.props.group = keybord_labels
ti_notes_labels.connect('clicked', self.set_ti_notes_labels_cb)
toolbar_box.toolbar.insert(ti_notes_labels, -1)
german_labels = RadioToolButton()
german_labels.props.icon_name = 'c_key'
german_labels.props.group = keybord_labels
german_labels.connect('clicked', self.set_german_labels_cb)
toolbar_box.toolbar.insert(german_labels, -1)
no_labels = RadioToolButton()
no_labels.props.icon_name = 'edit-clear'
no_labels.props.group = keybord_labels
no_labels.connect('clicked', self.set_keyboard_no_labels_cb)
toolbar_box.toolbar.insert(no_labels, -1)
self._what_widget = Gtk.ToolItem()
self._what_search_button = FilterToolItem(_('Select Instrument'),
'view-type', _('Piano'),
self._what_widget)
self._what_widget.show()
toolbar_box.toolbar.insert(Gtk.SeparatorToolItem(), -1)
toolbar_box.toolbar.insert(self._what_search_button, -1)
self._what_search_button.show()
self._what_search_button.set_is_important(True)
self._what_widget_contents = None
self._what_drum_widget_contents = None
separator = Gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
toolbar_box.toolbar.insert(self.record_button, -1)
toolbar_box.toolbar.insert(self.play_recording_button, -1)
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self._save_as_audio_bt = ToolButton(icon_name='save-as-audio')
self._save_as_audio_bt.props.tooltip = _('Save as audio')
self._save_as_audio_bt.connect('clicked', self._save_ogg_cb)
self._save_as_audio_bt.show()
self._save_as_audio_bt.set_sensitive(False)
activity_button.page.insert(self._save_as_audio_bt, -1)
self.set_toolbar_box(toolbar_box)
toolbar_box.show_all()
self.keyboard_letters = ['ZSXDCVGBHNJM', 'Q2W3ER5T6Y7U', 'I']
notes = [
'DO', ['DO#', 'REb'], 'RE', ['RE#', 'MIb'], 'MI', 'FA',
['FA#', 'SOLb'], 'SOL', ['SOL#', 'LAb'], 'LA', ['LA#', 'SIb'], 'SI'
]
self.notes_labels = [notes, notes, ['DO']]
# some countries use TI instead of SI
ti_notes = [
'DO', ['DO#', 'REb'], 'RE', ['RE#', 'MIb'], 'MI', 'FA',
['FA#', 'SOLb'], 'SOL', ['SOL#', 'LAb'], 'LA', ['LA#', 'TIb'], 'TI'
]
self.ti_notes_labels = [ti_notes, ti_notes, ['DO']]
german_notes = [
'C', ['C#', 'Db'], 'D', ['D#', 'Eb'], 'E', 'F', ['F#', 'Gb'], 'G',
['G#', 'Ab'], 'A', ['A#', 'Bb'], 'B'
]
self.german_labels = [german_notes, german_notes, ['C']]
self.piano = PianoKeyboard(octaves=2,
add_c=True,
labels=self.keyboard_letters)
# init csound
self.instrumentDB = InstrumentDB.getRef()
self.timeout_ms = 50
self.instVolume = 50
self.drumVolume = 0.5
self.instrument = 'piano'
self.beat = 4
self.reverb = 0.1
self.tempo = PLAYER_TEMPO
self.beatDuration = 60.0 / self.tempo
self.ticksPerSecond = Config.TICKS_PER_BEAT * self.tempo / 60.0
self.sequencer = MiniSequencer(self.recordStateButton,
self.recordOverSensitivity)
self.loop = Loop(self.beat, math.sqrt(self.instVolume * 0.01))
self.drumFillin = Fillin(self.beat, self.tempo, self.rythmInstrument,
self.reverb, self.drumVolume)
self.muteInst = False
self.csnd.setTempo(self.tempo)
self.noteList = []
for i in range(21):
self.csnd.setTrackVolume(100, i)
# TODO commented because apparently are not used in the activity
# for i in range(10):
# self.csnd.load_instrument('guidice' + str(i + 1))
self.volume = 100
self.csnd.setMasterVolume(self.volume)
self.enableKeyboard()
self.setInstrument(self.instrument)
self.connect('key-press-event', self.onKeyPress)
self.connect('key-release-event', self.onKeyRelease)
self.piano.connect('key_pressed', self.__key_pressed_cb)
self.piano.connect('key_released', self.__key_released_cb)
vbox = Gtk.VBox()
vbox.set_homogeneous(False)
self.load_instruments()
self._event_box = Gtk.EventBox()
self._event_box.modify_bg(Gtk.StateType.NORMAL,
style.COLOR_WHITE.get_gdk_color())
vbox.pack_start(self._event_box, False, False, 0)
vbox.pack_end(self.piano, True, True, 0)
vbox.show_all()
self.set_canvas(vbox)
piano_height = Gdk.Screen.width() / 2
self._event_box.set_size_request(
-1,
Gdk.Screen.height() - piano_height - style.GRID_CELL_SIZE)
self.connect('size-allocate', self.__allocate_cb)
# TODO: disabe until is implemented with csnd6
# GLib.idle_add(self.initializePercussion)
def createPercussionToolbar(self, toolbar_box):
self.beats_pm_button = IntensitySelector(range(2, 13), 4,
imagefile('beat3.svg'))
self.tempo_button = \
IntensitySelector(range(PLAYER_TEMPO_LOWER,
PLAYER_TEMPO_UPPER + 1, PLAYER_TEMPO_STEP),
PLAYER_TEMPO, imagefile('tempo5.png'))
self.complexity_button = IntensitySelector(xfrange(0, 1, 0.1),
self.regularity,
imagefile('complex6.svg'))
self._play_percussion_btn = ToolButton(
icon_name='media-playback-start')
self._play_percussion_btn.set_property('can-default', True)
self._play_percussion_btn.show()
self._play_percussion_btn.connect('clicked', self.handlePlayButton)
beats_toolbar = ToolbarBox()
beats_toolbar.toolbar.insert(self._play_percussion_btn, -1)
self._what_drum_widget = Gtk.ToolItem()
self._what_drum_search_button = FilterToolItem(_('Select Drum'),
'view-type',
_('Jazz / Rock Kit'),
self._what_drum_widget)
self._what_drum_search_button.set_widget_icon(
file_name=imagefile("drum1kit.svg"))
self._what_drum_widget.show()
beats_toolbar.toolbar.insert(self._what_drum_search_button, -1)
self._what_drum_search_button.show()
self._what_drum_search_button.set_is_important(True)
beats_toolbar.toolbar.insert(Gtk.SeparatorToolItem(), -1)
beats_toolbar.toolbar.insert(self.complexity_button, -1)
beats_toolbar.toolbar.insert(self.beats_pm_button, -1)
beats_toolbar.toolbar.insert(self.tempo_button, -1)
beats_toolbar_button = ToolbarButton(icon_name='toolbar-drums',
page=beats_toolbar)
beats_toolbar_button.show()
toolbar_box.toolbar.insert(beats_toolbar_button, 1)
self.beats_pm_button.set_tooltip(_("Beats per bar"))
self.beats_pm_button.show()
self.beats_pm_button.connect('changed', self.beatSliderChange, True)
self.tempo_button.connect('changed', self.tempoSliderChange, True)
self.complexity_button.connect('changed', self.handleComplexityChange,
True)
self.complexity_button.set_tooltip(_("Beat complexity"))
self.tempo_button.show()
self.tempo_button.set_tooltip(_('Tempo'))
self.complexity_button.show()
def initializePercussion(self):
self.rythmInstrument = 'drum1kit'
self.csnd.load_drumkit(self.rythmInstrument)
self.csnd.setTempo(self.tempo)
self.beatPickup = False
def flatten(ll):
rval = []
for l in ll:
rval += l
return rval
noteOnsets = []
notePitchs = []
i = 0
self.noteList = []
self.csnd.loopClear()
for x in flatten(
generator(self.rythmInstrument, self.beat, 0.8,
self.regularity, self.reverb)):
x.amplitude = x.amplitude * self.drumVolume
noteOnsets.append(x.onset)
notePitchs.append(x.pitch)
n = Note(0, x.trackId, i, x)
self.noteList.append((x.onset, n))
i = i + 1
self.csnd.loopPlay(n, 1) # add as active
self.csnd.loopSetNumTicks(self.beat * Config.TICKS_PER_BEAT)
self.drumFillin.unavailable(noteOnsets, notePitchs)
if self.playing:
self.csnd.loopStart()
def __allocate_cb(self, widget, rect):
GLib.idle_add(self.resize, rect.width, rect.height)
return False
def resize(self, width, height):
logging.debug('activity.py resize......')
piano_height = width / 2
self._event_box.set_size_request(
-1,
Gdk.Screen.height() - piano_height - style.GRID_CELL_SIZE)
return False
def load_instruments(self):
self._instruments_store = []
# load the images
images_path = os.path.join(activity.get_bundle_path(), 'instruments')
logging.debug('Loading instrument images from %s', images_path)
for file_name in os.listdir(images_path):
image_file_name = os.path.join(images_path, file_name)
pxb = GdkPixbuf.Pixbuf.new_from_file_at_size(
image_file_name, 75, 75)
# instrument_name = image_file_name[image_file_name.rfind('/'):]
instrument_name = image_file_name[image_file_name.rfind('/') + 1:]
instrument_name = instrument_name[:instrument_name.find('.')]
instrument_desc = \
self.instrumentDB.instNamed[instrument_name].nameTooltip
file_path = os.path.join(images_path, file_name)
# set the default icon
if (instrument_name == 'piano'):
self._what_search_button.set_widget_icon(file_name=file_path)
self._instruments_store.append({
"instrument_name":
instrument_name,
"pxb":
pxb,
"instrument_desc":
instrument_desc,
"file_name":
file_path,
"callback":
self.__instrument_iconview_activated_cb
})
self._what_widget_contents = set_palette_list(self._instruments_store)
self._what_widget.add(self._what_widget_contents)
self._what_widget_contents.show()
# TODO: disabe until is implemented with csnd6
"""
for drum_number in range(0, DRUMCOUNT):
drum_name = 'drum%dkit' % (drum_number + 1)
self._drums_store.append({
"instrument_name": drum_name,
"file_name": imagefile(drum_name + '.svg'),
"instrument_desc":
self.instrumentDB.instNamed[drum_name].nameTooltip,
"callback": self.__drum_iconview_activated_cb
})
self._what_drum_widget_contents = set_palette_list(self._drums_store)
self._what_drum_widget.add(self._what_drum_widget_contents)
self._what_drum_widget_contents.show()
"""
def __drum_iconview_activated_cb(self, widget, event, item):
data = item['instrument_name']
self.rythmInstrument = data
self.csnd.load_drumkit(data)
instrumentId = self.instrumentDB.instNamed[data].instrumentId
for (o, n) in self.noteList:
self.csnd.loopUpdate(n, NoteDB.PARAMETER.INSTRUMENT, instrumentId,
-1)
self.drumFillin.setInstrument(self.rythmInstrument)
self._what_drum_search_button.set_widget_label(
label=item['instrument_desc'])
self._what_drum_search_button.set_widget_icon(
file_name=item['file_name'])
def __instrument_iconview_activated_cb(self, widget, event, item):
self.setInstrument(item['instrument_name'])
self._what_search_button.set_widget_icon(file_name=item['file_name'])
self._what_search_button.set_widget_label(
label=item['instrument_desc'])
def set_notes_labels_cb(self, widget):
self.piano.font_size = 16
self.piano.set_labels(self.notes_labels)
def set_ti_notes_labels_cb(self, widget):
self.piano.font_size = 16
self.piano.set_labels(self.ti_notes_labels)
def set_keyboard_labels_cb(self, widget):
self.piano.font_size = 25
self.piano.set_labels(self.keyboard_letters)
def set_german_labels_cb(self, widget):
self.piano.font_size = 25
self.piano.set_labels(self.german_labels)
def beatSliderChange(self, widget, event):
self.beat = int(self.beats_pm_button.get_value())
self.sequencer.beat = self.beat
self.loop.beat = self.beat
self.drumFillin.setBeats(self.beat)
img = int(self.scale(self.beat, 2, 12, 1, 11))
self.beats_pm_button.set_image(imagefile('beat' + str(img) + '.svg'))
self.beatPickup = False
self.regenerate()
self.beatPickup = True
def regenerate(self):
def flatten(ll):
rval = []
for l in ll:
rval += l
return rval
noteOnsets = []
notePitchs = []
i = 0
self.noteList = []
self.csnd.loopClear()
for x in flatten(
generator(self.rythmInstrument, self.beat, 0.8,
self.regularity, self.reverb)):
x.amplitude = x.amplitude * self.drumVolume
noteOnsets.append(x.onset)
notePitchs.append(x.pitch)
n = Note(0, x.trackId, i, x)
self.noteList.append((x.onset, n))
i = i + 1
self.csnd.loopPlay(n, 1) # add as active
self.csnd.loopSetNumTicks(self.beat * Config.TICKS_PER_BEAT)
self.drumFillin.unavailable(noteOnsets, notePitchs)
self.recordOverSensitivity(False)
if self.playing:
self.csnd.loopStart()
def handlePlayRecordingButton(self, val):
if not self.playing_recording:
self.playing_recording = True
self.play_recording_button.props.icon_name = 'media-playback-stop'
self.play_recording_thread = \
GLib.timeout_add(100, self._play_recorded_keys)
else:
self.playing_recording = False
self.play_recording_button.props.icon_name = 'media-playback-start'
def _save_ogg_cb(self, widget):
self._wav_tempfile = tempfile.NamedTemporaryFile(mode='w+b',
suffix='.wav',
dir='/tmp/')
self.csnd.inputMessage(Config.CSOUND_RECORD_PERF %
self._wav_tempfile.name)
self.playing_recording = True
self.play_recording_thread = \
GLib.timeout_add(100, self._play_recorded_keys,
self._save_ogg_end_cb)
def _save_ogg_end_cb(self):
self.csnd.inputMessage(Config.CSOUND_STOP_RECORD_PERF %
self._wav_tempfile.name)
self._ogg_tempfile = tempfile.NamedTemporaryFile(mode='w+b',
suffix='.ogg',
dir='/tmp/')
line = 'filesrc location=%s ! ' \
'wavparse ! audioconvert ! vorbisenc ! oggmux ! ' \
'filesink location=%s' % (self._wav_tempfile.name,
self._ogg_tempfile.name)
pipe = Gst.parse_launch(line)
pipe.get_bus().add_signal_watch()
pipe.get_bus().connect('message::eos', self._save_ogg_eos_cb, pipe)
pipe.set_state(Gst.State.PLAYING)
def _save_ogg_eos_cb(self, bus, message, pipe):
bus.remove_signal_watch()
pipe.set_state(Gst.State.NULL)
title = '%s saved as audio' % self.metadata['title']
jobject = datastore.create()
jobject.metadata['title'] = title
jobject.metadata['keep'] = '0'
jobject.metadata['mime_type'] = 'audio/ogg'
jobject.file_path = self._ogg_tempfile.name
datastore.write(jobject)
self._wav_tempfile.close()
self._ogg_tempfile.close()
alert = NotifyAlert(10)
alert.props.title = _('Audio recorded')
alert.props.msg = _('The audio file was saved in the Journal')
alert.connect('response', self.__alert_response_cb)
self.add_alert(alert)
return False
def __alert_response_cb(self, alert, result):
self.remove_alert(alert)
def __record_button_click_cb(self, button):
if not self.recording:
self.play_recording_button.set_sensitive(False)
self._save_as_audio_bt.set_sensitive(False)
self.recorded_keys = []
self.recording = True
icon = Icon(icon_name='media-record', fill_color='#ff0000')
icon.show()
self.record_button.set_icon_widget(icon)
else:
self.recording = False
icon = Icon(icon_name='media-record', fill_color='#ffffff')
icon.show()
self.record_button.set_icon_widget(icon)
if len(self.recorded_keys) != 0:
self.play_recording_button.set_sensitive(True)
self._save_as_audio_bt.set_sensitive(True)
def tempoSliderChange(self, widget, event):
self._updateTempo(self.tempo_button.get_value())
img = int(
self.scale(self.tempo, PLAYER_TEMPO_LOWER, PLAYER_TEMPO_UPPER, 1,
9))
self.tempo_button.set_image(imagefile('tempo' + str(img) + '.png'))
def _updateTempo(self, val):
self.tempo = val
self.beatDuration = 60.0 / self.tempo
self.ticksPerSecond = Config.TICKS_PER_BEAT * self.tempo / 60.0
self.csnd.setTempo(self.tempo)
self.sequencer.tempo = self.tempo
self.drumFillin.setTempo(self.tempo)
def handlePlayButton(self, val):
if not self.playing:
if not self.firstTime:
self.regenerate()
self.firstTime = True
self.drumFillin.play()
self.csnd.loopSetTick(0)
self.csnd.loopStart()
self.playing = True
self._play_percussion_btn.props.icon_name = 'media-playback-stop'
else:
self.drumFillin.stop()
self.sequencer.stopPlayback()
self.csnd.loopPause()
self.playing = False
self._play_percussion_btn.props.icon_name = 'media-playback-start'
def scale(self, input, input_min, input_max, output_min, output_max):
range_input = input_max - input_min
range_output = output_max - output_min
result = (input - input_min) * range_output / range_input + output_min
if (input_min > input_max and output_min > output_max) or \
(output_min > output_max and input_min < input_max):
if result > output_min:
return output_min
elif result < output_max:
return output_max
else:
return result
if (input_min < input_max and output_min < output_max) or \
(output_min < output_max and input_min > input_max):
if result > output_max:
return output_max
elif result < output_min:
return output_min
else:
return result
def handleComplexityChange(self, widget, event):
self.regularity = self.complexity_button.get_value()
img = int(self.complexity_button.get_value() * 7) + 1
self.complexity_button.set_image(
imagefile('complex' + str(img) + '.svg'))
self.beatPickup = False
self.regenerate()
self.beatPickup = True
"""
def handleBalanceSlider(self, adj):
self.instVolume = int(adj.get_value())
self.drumVolume = sqrt( (100-self.instVolume)*0.01 )
self.adjustDrumVolume()
self.drumFillin.setVolume(self.drumVolume)
instrumentVolume = sqrt( self.instVolume*0.01 )
self.loop.adjustLoopVolume(instrumentVolume)
self.sequencer.adjustSequencerVolume(instrumentVolume)
img = int(self.scale(self.instVolume,100,0,0,4.9))
self._playToolbar.balanceSliderImgLeft.set_from_file(
imagefile('dru' + str(img) + '.png'))
img2 = int(self.scale(self.instVolume,0,100,0,4.9))
self._playToolbar.balanceSliderImgRight.set_from_file(
imagefile('instr' + str(img2) + '.png'))
def handleReverbSlider(self, adj):
self.reverb = adj.get_value()
self.drumFillin.setReverb( self.reverb )
img = int(self.scale(self.reverb,0,1,0,4))
self._playToolbar.reverbSliderImgRight.set_from_file(
imagefile('reverb' + str(img) + '.png'))
self.keyboardStandAlone.setReverb(self.reverb)
"""
def set_keyboard_no_labels_cb(self, widget):
self.piano.font_size = 25
self.piano.set_labels(None)
def enableKeyboard(self):
self.keyboardStandAlone = KeyboardStandAlone(
self.sequencer.recording, self.sequencer.adjustDuration,
self.csnd.loopGetTick, self.sequencer.getPlayState, self.loop)
self.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
def setInstrument(self, instrument):
logging.debug("Set Instrument: %s" % instrument)
self.instrument = instrument
self.keyboardStandAlone.setInstrument(instrument)
self.csnd.load_instrument(instrument)
def recordStateButton(self, button, state):
pass
# if button == 1:
# self._recordToolbar.keyboardRecButton.set_active( state )
# else:
# self._recordToolbar.keyboardRecOverButton.set_active( state )
def recordOverSensitivity(self, state):
pass
# self._recordToolbar.keyboardRecOverButton.set_sensitive( state )
def _play_recorded_keys(self, end_cb=None):
GLib.source_remove(self.play_recording_thread)
letter = self.recorded_keys[self.play_index]
time_difference = 0
if self.play_index == len(self.recorded_keys) - 1:
time_difference = \
self.recorded_keys[self.play_index][0] - \
self.recorded_keys[self.play_index - 1][0]
else:
next_time = self.recorded_keys[self.play_index + 1][0]
time_difference = next_time - letter[0]
if not self.playing_recording:
self.play_recording_button.props.icon_name = 'media-playback-start'
return
if letter[-1] == 1:
self.keyboardStandAlone.do_key_release(
LETTERS_TO_KEY_CODES[letter[3]])
GLib.idle_add(self.piano.physical_key_changed,
LETTERS_TO_KEY_CODES[letter[3]], False)
else:
self.keyboardStandAlone.do_key_press(
LETTERS_TO_KEY_CODES[letter[3]], None,
math.sqrt(self.instVolume * 0.01))
GLib.idle_add(self.piano.physical_key_changed,
LETTERS_TO_KEY_CODES[letter[3]], True)
if self.play_index == len(self.recorded_keys) - 1:
self.play_index = 0
self.play_recording_button.props.icon_name = 'media-playback-start'
self.playing_recording = False
if end_cb is not None:
end_cb()
else:
self.play_index += 1
self.play_recording_thread = \
GLib.timeout_add(int((time_difference) * 1000),
self._play_recorded_keys, end_cb)
def __key_pressed_cb(self, widget, octave_clicked, key_clicked, letter,
physicallKey):
logging.debug('Pressed Octave: %d Key: %d Letter: %s' %
(octave_clicked, key_clicked, letter))
if letter in LETTERS_TO_KEY_CODES.keys():
if self.recording:
self.recorded_keys.append(
[time.time(), octave_clicked, key_clicked, letter])
if not physicallKey:
self.keyboardStandAlone.do_key_press(
LETTERS_TO_KEY_CODES[letter], None,
math.sqrt(self.instVolume * 0.01))
def __key_released_cb(self, widget, octave_clicked, key_clicked, letter,
physicallKey):
if self.recording:
self.recorded_keys.append(
[time.time(), octave_clicked, key_clicked, letter, 1])
if not physicallKey:
if letter in LETTERS_TO_KEY_CODES.keys():
self.keyboardStandAlone.do_key_release(
LETTERS_TO_KEY_CODES[letter])
def onKeyPress(self, widget, event):
if event.state & Gdk.ModifierType.CONTROL_MASK:
return
if event.hardware_keycode == 37:
if self.muteInst:
self.muteInst = False
else:
self.muteInst = True
self.piano.physical_key_changed(event.hardware_keycode, True)
self.keyboardStandAlone.onKeyPress(widget, event,
math.sqrt(self.instVolume * 0.01))
def onKeyRelease(self, widget, event):
self.keyboardStandAlone.onKeyRelease(widget, event)
self.piano.physical_key_changed(event.hardware_keycode, False)
def write_file(self, file_path):
f = open(file_path, 'w')
# substract the initial time to all the saved values
if len(self.recorded_keys) > 0:
initial_time = self.recorded_keys[0][0]
for key in self.recorded_keys:
key[0] = key[0] - initial_time
f.write(json.dumps(self.recorded_keys))
f.close()
def read_file(self, file_path):
f = open(file_path, 'r')
contents = f.read().strip()
self.recorded_keys = json.loads(contents)
if len(self.recorded_keys) != 0:
self.play_recording_button.set_sensitive(True)
self._save_as_audio_bt.set_sensitive(True)
f.close()
def close(self, skip_save=False):
self.csnd.stop() # without which Csound will segfault
activity.Activity.close(self, skip_save=skip_save)
def enableKeyboard(self):
self.keyboardStandAlone = KeyboardStandAlone(
self.sequencer.recording, self.sequencer.adjustDuration,
self.csnd.loopGetTick, self.sequencer.getPlayState, self.loop)
self.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
class miniTamTamMain(Gtk.HBox):
def __init__(self, activity):
Gtk.HBox.__init__(self)
self.instrumentPanel = None
self.activity = activity
self.instrumentDB = InstrumentDB.getRef()
self.firstTime = False
self.playing = False
self.csnd = new_csound_client()
self.timeout_ms = 50
self.instVolume = 50
self.drumVolume = 0.5
self.instrument = 'sarangi'
self.regularity = 0.75
self.beat = 4
self.reverb = 0.1
self.tempo = Config.PLAYER_TEMPO
self.beatDuration = 60.0/self.tempo
self.ticksPerSecond = Config.TICKS_PER_BEAT*self.tempo/60.0
self.rythmInstrument = 'drum1kit'
self.csnd.load_drumkit(self.rythmInstrument)
self.muteInst = False
self.drumFillin = Fillin( self.beat, self.tempo, self.rythmInstrument, self.reverb, self.drumVolume )
self.sequencer= MiniSequencer(self.recordStateButton, self.recordOverSensitivity)
self.loop = Loop(self.beat, sqrt( self.instVolume*0.01 ))
self.csnd.setTempo(self.tempo)
self.noteList = []
time.sleep(0.001) # why?
self.trackpad = Trackpad( self )
for i in range(21):
self.csnd.setTrackVolume( 100, i )
for i in range(10):
r = str(i+1)
self.csnd.load_instrument('guidice' + r)
self.volume = 100
self.csnd.setMasterVolume(self.volume)
self.sequencer.beat = self.beat
self.loop.beat = self.beat
self.leftBox = Gtk.VBox()
self.rightBox = Gtk.VBox()
# TODO: right is at left, and left is at right?
self.pack_start(self.rightBox, False, False, 0)
self.pack_start(self.leftBox, False, False, 0)
self.enableKeyboard()
self.setInstrument(self.instrument)
self.connect('key-press-event', self.onKeyPress)
self.connect('key-release-event', self.onKeyRelease)
self.drawGeneration()
self.show_all()
if 'a good idea' == True:
self.playStartupSound()
self.beatPickup = True
#self.regenerate()
self.heartbeatStart = time.time()
self.syncQueryStart = {}
self.syncTimeout = None
self.network = Net.Network()
self.network.addWatcher( self.networkStatusWatcher )
self.network.connectMessage( Net.HT_SYNC_REPLY, self.processHT_SYNC_REPLY )
self.network.connectMessage( Net.HT_TEMPO_UPDATE, self.processHT_TEMPO_UPDATE )
self.network.connectMessage( Net.PR_SYNC_QUERY, self.processPR_SYNC_QUERY )
self.network.connectMessage( Net.PR_TEMPO_QUERY, self.processPR_TEMPO_QUERY )
self.network.connectMessage( Net.PR_REQUEST_TEMPO_CHANGE, self.processPR_REQUEST_TEMPO_CHANGE )
# data packing classes
self.packer = xdrlib.Packer()
self.unpacker = xdrlib.Unpacker("")
#-- handle forced networking ---------------------------------------
if self.network.isHost():
self.updateSync()
self.syncTimeout = GObject.timeout_add( 1000, self.updateSync )
elif self.network.isPeer():
self.sendTempoQuery()
self.syncTimeout = GObject.timeout_add( 1000, self.updateSync )
#-------------------------------------------------------------------
# Toolbar
if Config.HAVE_TOOLBOX:
from sugar3.graphics.toolbarbox import ToolbarButton
# no sharing
# self.max_participants = 1
self._playToolbar = playToolbar(self)
## Uncomment to show play and record tabs ##
'''
play_toolbar_button = ToolbarButton(label=_('Play'),
page=self._playToolbar,
# Fixme: need an icon
icon_name='activity-start')
self._playToolbar.show()
play_toolbar_button.show()
self.activity.toolbox.toolbar.insert(play_toolbar_button, -1)
self._recordToolbar = recordToolbar(self)
record_toolbar_button = ToolbarButton(label=_('Record'),
page=self._recordToolbar,
# Fixme: need an icon
icon_name='media-record')
self._recordToolbar.show()
record_toolbar_button.show()
self.activity.toolbox.toolbar.insert(record_toolbar_button, -1)
'''
else:
self._playToolbar = playToolbar(self)
## set to 1 to show play and record tabs ##
if 0:
self._recordToolbar = recordToolbar(self)
self.activity.toolbox.add_toolbar(_('Play'), self._playToolbar)
self.activity.toolbox.add_toolbar(_('Record'), self._recordToolbar)
self.activity.toolbox.set_current_toolbar(1)
self._playToolbar.show()
self._recordToolbar.show()
if not Config.HAVE_TOOLBOX:
self.activity.connect( "shared", self.shared )
if os.path.isfile("FORCE_SHARE"): # HOST
#print "::::: Sharing as TTDBG%f :::::" % r
#self.activity.set_title(_("TTDBG%f" % r))
print "::::: Sharing as TamTam :::::"
self.activity.set_title(_("TamTam"))
self.activity.share()
elif self.activity.shared_activity: # PEER
self.activity.shared_activity.connect( "buddy-joined", self.buddy_joined )
self.activity.shared_activity.connect( "buddy-left", self.buddy_left )
self.activity.connect( "joined", self.joined )
self.network.setMode( Net.MD_WAIT )
#self.activity.activity_toolbar.share.hide()
def drawGeneration( self ):
slidersBox = Gtk.VBox()
geneSliderBox = Gtk.VBox()
self.geneSliderBoxImgTop = Gtk.Image()
self.geneSliderBoxImgTop.set_from_file(imagefile('complex6.png'))
self.geneAdjustment = Gtk.Adjustment(value=self.regularity, lower=0, upper=1, step_incr=0.01, page_incr=0, page_size=0)
self.geneSlider = ImageVScale('sliderbutbleu.png',
self.geneAdjustment, 5)
self.geneSlider.set_inverted(False)
self.geneAdjustment.connect("value_changed" , self.handleGenerationSlider)
self.geneSlider.connect("button-release-event", self.handleGenerationSliderRelease)
geneSliderBox.pack_start(self.geneSliderBoxImgTop, False, True, padding=10)
geneSliderBox.pack_start(self.geneSlider, True, True, 20)
self.geneSlider.set_tooltip_text(Tooltips.COMPL)
beatSliderBox = Gtk.VBox()
self.beatSliderBoxImgTop = Gtk.Image()
self.beatSliderBoxImgTop.set_from_file(imagefile('beat3.png'))
self.beatAdjustment = Gtk.Adjustment(value=self.beat, lower=2,
upper=12, step_incr=1, page_incr=0, page_size=0)
self.beatSlider = ImageVScale('sliderbutjaune.png',
self.beatAdjustment, 5, snap=1)
self.beatSlider.set_inverted(True)
self.beatAdjustment.connect("value_changed" , self.handleBeatSlider)
self.beatSlider.connect("button-release-event", self.handleBeatSliderRelease)
beatSliderBox.pack_start(self.beatSliderBoxImgTop, False, True, padding=10)
beatSliderBox.pack_start(self.beatSlider, True, True, 20)
self.beatSlider.set_tooltip_text(Tooltips.BEAT)
self.delayedTempo = 0 # used to store tempo updates while the slider is active
self.tempoSliderActive = False
tempoSliderBox = Gtk.VBox()
self.tempoSliderBoxImgTop = Gtk.Image()
self.tempoSliderBoxImgTop.set_from_file(imagefile('tempo5.png'))
self.tempoAdjustment = Gtk.Adjustment(value=self.tempo, lower=Config.PLAYER_TEMPO_LOWER, upper=Config.PLAYER_TEMPO_UPPER, step_incr=1, page_incr=1, page_size=1)
tempoSlider = ImageVScale('sliderbutvert.png', self.tempoAdjustment, 5)
tempoSlider.set_inverted(True)
self.tempoAdjustmentHandler = self.tempoAdjustment.connect("value_changed" , self.handleTempoSliderChange)
tempoSlider.connect("button-press-event", self.handleTempoSliderPress)
tempoSlider.connect("button-release-event", self.handleTempoSliderRelease)
tempoSliderBox.pack_start(self.tempoSliderBoxImgTop, False, True, padding=10)
tempoSliderBox.pack_start(tempoSlider, True, True, 0)
tempoSlider.set_tooltip_text(Tooltips.TEMPO)
volumeSliderBox = Gtk.VBox()
self.volumeSliderBoxImgTop = Gtk.Image()
self.volumeSliderBoxImgTop.set_from_file(imagefile('volume2.png'))
self.volumeAdjustment = Gtk.Adjustment(value=self.volume, lower=0, upper=200, step_incr=1, page_incr=1, page_size=1)
volumeSlider = ImageVScale('sliderbutbleu.png',
self.volumeAdjustment, 5)
volumeSlider.set_inverted(True)
self.volumeAdjustment.connect("value_changed" , self.handleVolumeSlider)
#volumeSlider.connect("button-release-event", self.handleVolumeSliderRelease)
volumeSliderBox.pack_start(self.volumeSliderBoxImgTop, False, True, padding=10)
volumeSliderBox.pack_start(volumeSlider, True, True, 0)
volumeSlider.set_tooltip_text(Tooltips.VOL)
slidersBoxSub = Gtk.HBox()
slidersBoxSub.pack_start(beatSliderBox, True, True, 0)
slidersBoxSub.pack_start(geneSliderBox, True, True, 0)
slidersBoxSub.pack_start(tempoSliderBox, True, True, 0)
slidersBoxSub.pack_start(volumeSliderBox, True, True, 0)
slidersBox.pack_start(slidersBoxSub, True, True, 0)
generateBtnSub = Gtk.HBox()
self.playButton = ImageToggleButton('miniplay.png', 'stop.png')
self.playButton.connect('clicked',self.handlePlayButton)
generateBtnSub.pack_start(self.playButton, True, True, 0)
self.playButton.set_tooltip_text(_('Play / Stop'))
generateBtn = ImageButton('dice.png', clickImg_path='diceblur.png')
generateBtn.connect('button-press-event', self.handleGenerateBtn)
generateBtnSub.pack_start(generateBtn, True, True, 0)
generateBtn.set_tooltip_text(Tooltips.GEN)
# drums
drum_box = Gtk.VBox()
drum_scroll = VScrolledBox(scroll_policy=Gtk.PolicyType.NEVER)
drum_scroll.set_viewport(drum_box)
drum_scroll.modify_bg(Gtk.StateType.NORMAL,
style.Color(Config.PANEL_BCK_COLOR).get_gdk_color())
drum_i = 0
drum_group = None
for row in range(DRUMCOUNT/2 + DRUMCOUNT%2):
row_box = Gtk.HBox()
drum_box.pack_start(row_box, False, True, 0)
for col in range(2):
if drum_i >= DRUMCOUNT:
break
drum = ImageRadioButton(
group=drum_group,
mainImg_path='drum%dkit.png' % (drum_i + 1),
altImg_path='drum%dkitselgen.png' % (drum_i +1))
drum.connect('clicked', self.handleGenerationDrumBtn,
'drum%dkit' % (drum_i+1))
row_box.pack_start(drum, True, True, 0)
drum_name = 'drum%dkit' % (drum_i + 1)
hint = self.instrumentDB.instNamed[drum_name].nameTooltip
drum.set_tooltip_text(hint)
if not drum_group:
drum_group = drum
drum_i += 1
self.rightBox.pack_start(slidersBox, True, True, 0)
self.rightBox.pack_start(generateBtnSub, True, True, 0)
self.rightBox.pack_start(drum_scroll, False, True, 0)
drum_size = drum_group.get_size_request()
slidersBox.set_size_request(-1, int(drum_size[1] * 2.3))
self.rightBox.set_size_request(int(drum_size[0] * 2.05), -1)
def loopSettingsChannel(self, channel, value):
self.csnd.setChannel(channel, value)
def loopSettingsPlayStop(self, state, loop):
if not state:
if loop:
self.loopSettingsPlaying = True
self.csnd.inputMessage(Config.CSOUND_PLAY_LS_NOTE % 5022)
else:
self.csnd.inputMessage(Config.CSOUND_PLAY_LS_NOTE % 5023)
else:
if loop:
self.loopSettingsPlaying = False
self.csnd.inputMessage(Config.CSOUND_STOP_LS_NOTE)
def load_ls_instrument(self, soundName):
self.csnd.load_ls_instrument(soundName)
def updateInstrumentPanel(self):
if self.instrumentPanel is None:
self.instrumentPanel = InstrumentPanel()
width = Gdk.Screen.width() - self.rightBox.get_size_request()[0]
self.instrumentPanel.configure(self.setInstrument,
self.playInstrumentNote, False, self.micRec, width=width)
self.instrumentPanel.load()
self.leftBox.pack_start(self.instrumentPanel, True, True, 0)
def micRec(self, widget, mic):
self.csnd.inputMessage("i5600 0 4")
OS.arecord(4, "crop.csd", mic)
self.micTimeout = GObject.timeout_add(200, self.loadMicInstrument, mic)
self.instrumentPanel.set_activeInstrument(mic,True)
self.setInstrument(mic)
def recordStateButton( self, button, state ):
if button == 1:
self._recordToolbar.keyboardRecButton.set_active( state )
else:
self._recordToolbar.keyboardRecOverButton.set_active( state )
def recordOverSensitivity( self, state ):
pass
#self._recordToolbar.keyboardRecOverButton.set_sensitive( state )
def loadMicInstrument( self, data ):
self.csnd.load_mic_instrument( data )
def regenerate(self):
def flatten(ll):
rval = []
for l in ll:
rval += l
return rval
if self.beatPickup:
self.pickupNewBeat()
noteOnsets = []
notePitchs = []
i = 0
self.noteList= []
self.csnd.loopClear()
for x in flatten( generator(self.rythmInstrument, self.beat, 0.8, self.regularity, self.reverb) ):
x.amplitude = x.amplitude * self.drumVolume
noteOnsets.append(x.onset)
notePitchs.append(x.pitch)
n = Note(0, x.trackId, i, x)
self.noteList.append( (x.onset, n) )
i = i + 1
self.csnd.loopPlay(n,1) #add as active
self.csnd.loopSetNumTicks( self.beat * Config.TICKS_PER_BEAT)
self.drumFillin.unavailable( noteOnsets, notePitchs )
self.recordOverSensitivity( False )
if self.playing:
self.csnd.loopStart()
def adjustDrumVolume(self):
for n in self.noteList:
self.csnd.loopUpdate(n[1], PARAMETER.AMPLITUDE, n[1].cs.amplitude*self.drumVolume, 1)
def handleClose(self,widget):
if self.playStopButton.get_active() == True:
self.playStopButton.set_active(False)
self.sequencer.clearSequencer()
self.csnd.loopClear()
self.activity.close()
def handleGenerationSlider(self, adj):
img = int(adj.get_value() * 7)+1
self.geneSliderBoxImgTop.set_from_file(
imagefile('complex' + str(img) + '.png'))
def handleGenerationSliderRelease(self, widget, event):
self.regularity = widget.get_adjustment().get_value()
self.beatPickup = False
self.regenerate()
self.beatPickup = True
def pickupNewBeat(self):
self.beat = random.randint(2, 12)
img = self.scale(self.beat,2,12,1,11)
self.beatSliderBoxImgTop.set_from_file(
imagefile('beat' + str(img) + '.png'))
self.beatAdjustment.set_value(self.beat)
self.regularity = random.randint(50, 100) * 0.01
img = int(self.regularity * 7)+1
self.geneSliderBoxImgTop.set_from_file(
imagefile('complex' + str(img) + '.png'))
self.geneAdjustment.set_value(self.regularity)
self.sequencer.beat = self.beat
self.loop.beat = self.beat
self.drumFillin.setBeats( self.beat )
def handleBeatSlider(self, adj):
img = self.scale(int(adj.get_value()),2,12,1,11)
self.beatSliderBoxImgTop.set_from_file(
imagefile('beat' + str(img) + '.png'))
self.sequencer.beat = self.beat
self.loop.beat = self.beat
self.drumFillin.setBeats( self.beat )
def handleBeatSliderRelease(self, widget, event):
self.beat = int(widget.get_adjustment().get_value())
self.sequencer.beat = self.beat
self.loop.beat = self.beat
self.drumFillin.setBeats( self.beat )
self.beatPickup = False
self.regenerate()
self.beatPickup = True
def handleTempoSliderPress(self, widget, event):
self.tempoSliderActive = True
def handleTempoSliderRelease(self, widget, event):
self.tempoSliderActive = False
if self.network.isPeer() and self.delayedTempo != 0:
if self.tempo != self.delayedTempo:
self.tempoAdjustment.handler_block( self.tempoAdjustmentHandler )
self.tempoAdjustment.set_value( self.delayedTempo )
self._updateTempo( self.delayedTempo )
self.tempoAdjustment.handler_unblock( self.tempoAdjustmentHandler )
self.delayedTempo = 0
self.sendSyncQuery()
def handleTempoSliderChange(self,adj):
if self.network.isPeer():
self.requestTempoChange(int(adj.get_value()))
else:
self._updateTempo(int(adj.get_value()))
def _updateTempo( self, val ):
if self.network.isHost():
t = time.time()
percent = self.heartbeatElapsed() / self.beatDuration
self.tempo = val
self.beatDuration = 60.0/self.tempo
self.ticksPerSecond = Config.TICKS_PER_BEAT*self.tempo/60.0
self.csnd.setTempo(self.tempo)
self.sequencer.tempo = self.tempo
self.drumFillin.setTempo(self.tempo)
if self.network.isHost():
self.heatbeatStart = t - percent*self.beatDuration
self.updateSync()
self.sendTempoUpdate()
img = int(self.scale( self.tempo,
Config.PLAYER_TEMPO_LOWER,Config.PLAYER_TEMPO_UPPER,
1,9))
self.tempoSliderBoxImgTop.set_from_file(
imagefile('tempo' + str(img) + '.png'))
def handleBalanceSlider(self, adj):
self.instVolume = int(adj.get_value())
self.drumVolume = sqrt( (100-self.instVolume)*0.01 )
self.adjustDrumVolume()
self.drumFillin.setVolume(self.drumVolume)
instrumentVolume = sqrt( self.instVolume*0.01 )
self.loop.adjustLoopVolume(instrumentVolume)
self.sequencer.adjustSequencerVolume(instrumentVolume)
img = int(self.scale(self.instVolume,100,0,0,4.9))
self._playToolbar.balanceSliderImgLeft.set_from_file(
imagefile('dru' + str(img) + '.png'))
img2 = int(self.scale(self.instVolume,0,100,0,4.9))
self._playToolbar.balanceSliderImgRight.set_from_file(
imagefile('instr' + str(img2) + '.png'))
def handleReverbSlider(self, adj):
self.reverb = adj.get_value()
self.drumFillin.setReverb( self.reverb )
img = int(self.scale(self.reverb,0,1,0,4))
self._playToolbar.reverbSliderImgRight.set_from_file(
imagefile('reverb' + str(img) + '.png'))
self.keyboardStandAlone.setReverb(self.reverb)
def handleVolumeSlider(self, adj):
self.volume = adj.get_value()
self.csnd.setMasterVolume(self.volume)
img = int(self.scale(self.volume,0,200,0,3.9))
self.volumeSliderBoxImgTop.set_from_file(
imagefile('volume' + str(img) + '.png'))
def handlePlayButton(self, widget, data = None):
# use widget.get_active() == False when calling this on 'clicked'
# use widget.get_active() == True when calling this on button-press-event
if widget.get_active() == False:
self.drumFillin.stop()
self.sequencer.stopPlayback()
self.csnd.loopPause()
self.playing = False
else:
if not self.firstTime:
self.regenerate()
self.firstTime = True
self.drumFillin.play()
#self.csnd.loopSetTick(0)
nextInTicks = self.nextHeartbeatInTicks()
#print "play:: next beat in %f ticks. bpb == %d. setting ticks to %d" % (nextInTicks, self.beat, Config.TICKS_PER_BEAT*self.beat - int(round(nextInTicks)))
self.csnd.loopSetTick( Config.TICKS_PER_BEAT*self.beat - int(round(nextInTicks)) )
self.csnd.loopStart()
self.playing = True
def handleGenerationDrumBtn(self , widget , data):
#data is drum1kit, drum2kit, or drum3kit
#print 'HANDLE: Generate Button'
self.rythmInstrument = data
self.csnd.load_drumkit(data)
instrumentId = self.instrumentDB.instNamed[data].instrumentId
for (o,n) in self.noteList :
self.csnd.loopUpdate(n, NoteDB.PARAMETER.INSTRUMENT, instrumentId, -1)
self.drumFillin.setInstrument( self.rythmInstrument )
def handleGenerateBtn(self , widget , data=None):
self.regenerate()
if not self.playButton.get_active():
self.playButton.set_active(True)
#this calls sends a 'clicked' event,
#which might be connected to handlePlayButton
self.playStartupSound()
def enableKeyboard( self ):
self.keyboardStandAlone = KeyboardStandAlone( self.sequencer.recording, self.sequencer.adjustDuration, self.csnd.loopGetTick, self.sequencer.getPlayState, self.loop )
self.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
def setInstrument( self , instrument ):
self.instrument = instrument
self.keyboardStandAlone.setInstrument(instrument)
self.csnd.load_instrument(instrument)
def playInstrumentNote(self , instrument, secs_per_tick = 0.025):
if not self.muteInst:
self.csnd.play(
CSoundNote( onset = 0,
pitch = 36,
amplitude = 1,
pan = 0.5,
duration = 20,
trackId = 1,
instrumentId = self.instrumentDB.instNamed[instrument].instrumentId,
reverbSend = self.reverb,
tied = False,
mode = 'mini'),
secs_per_tick)
def onKeyPress(self, widget, event):
if event.hardware_keycode == 219: #'/*' button to reset drum loop
if self.playStopButton.get_active() == True:
self.handlePlayButton(self.playStopButton)
self.playStopButton.set_active(False)
self.handlePlayButton(self.playStopButton)
self.playStopButton.set_active(True)
if event.hardware_keycode == 37:
if self.muteInst:
self.muteInst = False
else:
self.muteInst = True
if event.hardware_keycode == 65: #what key is this? what feature is this?
pass
#if self.playStopButton.get_active():
#self.playStopButton.set_active(False)
#else:
#self.playStopButton.set_active(True)
self.keyboardStandAlone.onKeyPress(widget, event, sqrt( self.instVolume*0.01 ))
def onKeyRelease(self, widget, event):
self.keyboardStandAlone.onKeyRelease(widget, event)
def playStartupSound(self):
r = str(random.randrange(1,11))
self.playInstrumentNote('guidice' + r)
def onActivate( self, arg ):
self.csnd.loopPause()
self.csnd.loopClear()
def onDeactivate( self ):
SubActivity.onDeactivate( self )
self.csnd.loopPause()
self.csnd.loopClear()
def onDestroy( self ):
self.network.shutdown()
def scale(self, input,input_min,input_max,output_min,output_max):
range_input = input_max - input_min
range_output = output_max - output_min
result = (input - input_min) * range_output / range_input + output_min
if (input_min > input_max and output_min > output_max) or (output_min > output_max and input_min < input_max):
if result > output_min:
return output_min
elif result < output_max:
return output_max
else:
return result
if (input_min < input_max and output_min < output_max) or (output_min < output_max and input_min > input_max):
if result > output_max:
return output_max
elif result < output_min:
return output_min
else:
return result
#-----------------------------------------------------------------------
# Network
#-- Activity -----------------------------------------------------------
def shared( self, activity ):
if Config.DEBUG: print "miniTamTam:: successfully shared, start host mode"
self.activity.shared_activity.connect( "buddy-joined", self.buddy_joined )
self.activity.shared_activity.connect( "buddy-left", self.buddy_left )
self.network.setMode( Net.MD_HOST )
self.updateSync()
self.syncTimeout = GObject.timeout_add( 1000, self.updateSync )
def joined( self, activity ):
print "miniTamTam:: joined activity!!"
for buddy in self.activity.shared_activity.get_joined_buddies():
print buddy.props.ip4_address
def buddy_joined( self, activity, buddy ):
print "buddy joined " + str(buddy)
try:
print buddy.props.ip4_address
except:
print "bad ip4_address"
if self.network.isHost():
# TODO how do I figure out if this buddy is me?
if buddy.props.ip4_address:
self.network.introducePeer( buddy.props.ip4_address )
else:
print "miniTamTam:: new buddy does not have an ip4_address!!"
def buddy_left( self, activity, buddy):
print "buddy left"
#def joined( self, activity ):
# if Config.DEBUG: print "miniTamTam:: successfully joined, wait for host"
# self.net.waitForHost()
#-- Senders ------------------------------------------------------------
def sendSyncQuery( self ):
self.packer.pack_float(random.random())
hash = self.packer.get_buffer()
self.packer.reset()
self.syncQueryStart[hash] = time.time()
self.network.send( Net.PR_SYNC_QUERY, hash)
def sendTempoUpdate( self ):
self.packer.pack_int(self.tempo)
self.network.sendAll( Net.HT_TEMPO_UPDATE, self.packer.get_buffer() )
self.packer.reset()
def sendTempoQuery( self ):
self.network.send( Net.PR_TEMPO_QUERY )
def requestTempoChange( self, val ):
self.packer.pack_int(val)
self.network.send( Net.PR_REQUEST_TEMPO_CHANGE, self.packer.get_buffer() )
self.packer.reset()
#-- Handlers -----------------------------------------------------------
def networkStatusWatcher( self, mode ):
if mode == Net.MD_OFFLINE:
if self.syncTimeout:
GObject.source_remove( self.syncTimeout )
self.syncTimeout = None
if mode == Net.MD_PEER:
self.updateSync()
if not self.syncTimeout:
self.syncTimeout = GObject.timeout_add( 1000, self.updateSync )
self.sendTempoQuery()
def processHT_SYNC_REPLY( self, sock, message, data ):
t = time.time()
hash = data[0:4]
latency = t - self.syncQueryStart[hash]
self.unpacker.reset(data[4:8])
nextBeat = self.unpacker.unpack_float()
#print "mini:: got sync: next beat in %f, latency %d" % (nextBeat, latency*1000)
self.heartbeatStart = t + nextBeat - self.beatDuration - latency/2
self.correctSync()
self.syncQueryStart.pop(hash)
def processHT_TEMPO_UPDATE( self, sock, message, data ):
self.unpacker.reset(data)
val = self.unpacker.unpack_int()
if self.tempoSliderActive:
self.delayedTempo = val
return
self.tempoAdjustment.handler_block( self.tempoAdjustmentHandler )
self.tempoAdjustment.set_value( val )
self._updateTempo( val )
self.tempoAdjustment.handler_unblock( self.tempoAdjustmentHandler )
self.sendSyncQuery()
def processPR_SYNC_QUERY( self, sock, message, data ):
self.packer.pack_float(self.nextHeartbeat())
self.network.send( Net.HT_SYNC_REPLY, data + self.packer.get_buffer(), sock )
self.packer.reset()
def processPR_TEMPO_QUERY( self, sock, message, data ):
self.packer.pack_int(self.tempo)
self.network.send( Net.HT_TEMPO_UPDATE, self.packer.get_buffer(), to = sock )
self.packer.reset()
def processPR_REQUEST_TEMPO_CHANGE( self, sock, message, data ):
if self.tempoSliderActive:
return
self.unpacker.reset(data)
val = self.unpacker.unpack_int()
self.tempoAdjustment.set_value( val )
#-----------------------------------------------------------------------
# Sync
def nextHeartbeat( self ):
delta = time.time() - self.heartbeatStart
return self.beatDuration - (delta % self.beatDuration)
def nextHeartbeatInTicks( self ):
delta = time.time() - self.heartbeatStart
next = self.beatDuration - (delta % self.beatDuration)
return self.ticksPerSecond*next
def heartbeatElapsed( self ):
delta = time.time() - self.heartbeatStart
return delta % self.beatDuration
def heartbeatElapsedTicks( self ):
delta = time.time() - self.heartbeatStart
return self.ticksPerSecond*(delta % self.beatDuration)
def updateSync( self ):
if self.network.isOffline():
return False
elif self.network.isWaiting():
return True
elif self.network.isHost():
self.correctSync()
else:
self.sendSyncQuery()
return True
def correctSync( self ):
curTick = self.csnd.loopGetTick()
curTicksIn = curTick % Config.TICKS_PER_BEAT
ticksIn = self.heartbeatElapsedTicks()
err = curTicksIn - ticksIn
if err > Config.TICKS_PER_BEAT_DIV2:
err -= Config.TICKS_PER_BEAT
elif err < -Config.TICKS_PER_BEAT_DIV2:
err += Config.TICKS_PER_BEAT
correct = curTick - err
ticksPerLoop = Config.TICKS_PER_BEAT*self.beat
if correct > ticksPerLoop:
correct -= ticksPerLoop
elif correct < 0:
correct += ticksPerLoop
#print "correct:: %f ticks, %f ticks in, %f expected, %f err, correct %f" % (curTick, curTicksIn, ticksIn, err, correct)
if abs(err) > 0.25:
self.csnd.adjustTick(-err)
class SimplePianoActivity(activity.Activity):
"""SimplePianoActivity class as specified in activity.info"""
def __init__(self, handle):
activity.Activity.__init__(self, handle)
GLib.unix_signal_add(GLib.PRIORITY_DEFAULT, signal.SIGINT, self.close)
Gst.init(None)
self._what_list = []
self.play_recording_thread = None
self.playing_recording = False
self.firstTime = False
self.playing = False
self.regularity = 0.7
self._drums_store = []
self.recording = False
self.recorded_keys = []
self.is_valid_recording = False
# we do not have collaboration features
# make the share option insensitive
self.max_participants = 1
self.csnd = new_csound_client()
self.rythmInstrument = 'drum1kick'
# toolbar with the new toolbar redesign
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
toolbar_box.toolbar.set_style(Gtk.ToolbarStyle.BOTH_HORIZ)
self.play_index = 0
self.play_recording_button = ToolButton(
icon_name='media-playback-start')
self.play_recording_button.set_property('can-default', True)
self.play_recording_button.show()
self.record_button = ToggleToolButton(icon_name='media-record')
self.record_button.set_property('can-default', True)
self.record_button.show()
self.play_recording_button.set_sensitive(False)
self.record_button.connect('clicked', self.__record_button_click_cb)
self.play_recording_button.connect('clicked',
self.handlePlayRecordingButton)
toolbar_box.toolbar.set_style(Gtk.ToolbarStyle.BOTH_HORIZ)
# TODO: disabe until is implemented with csnd6
# self.createPercussionToolbar(toolbar_box)
toolbar_box.toolbar.insert(Gtk.SeparatorToolItem(), -1)
keybord_labels = RadioToolButton()
keybord_labels.props.icon_name = 'q_key'
keybord_labels.props.group = keybord_labels
keybord_labels.connect('clicked', self.set_keyboard_labels_cb)
toolbar_box.toolbar.insert(keybord_labels, -1)
notes_labels = RadioToolButton()
notes_labels.props.icon_name = 'do_key'
notes_labels.props.group = keybord_labels
notes_labels.connect('clicked', self.set_notes_labels_cb)
toolbar_box.toolbar.insert(notes_labels, -1)
ti_notes_labels = RadioToolButton()
ti_notes_labels.props.icon_name = 'ti_key'
ti_notes_labels.props.group = keybord_labels
ti_notes_labels.connect('clicked', self.set_ti_notes_labels_cb)
toolbar_box.toolbar.insert(ti_notes_labels, -1)
german_labels = RadioToolButton()
german_labels.props.icon_name = 'c_key'
german_labels.props.group = keybord_labels
german_labels.connect('clicked', self.set_german_labels_cb)
toolbar_box.toolbar.insert(german_labels, -1)
no_labels = RadioToolButton()
no_labels.props.icon_name = 'edit-clear'
no_labels.props.group = keybord_labels
no_labels.connect('clicked', self.set_keyboard_no_labels_cb)
toolbar_box.toolbar.insert(no_labels, -1)
self._what_widget = Gtk.ToolItem()
self._what_search_button = FilterToolItem(_('Select Instrument'),
'view-type',
_('Piano'),
self._what_widget)
self._what_widget.show()
toolbar_box.toolbar.insert(Gtk.SeparatorToolItem(), -1)
toolbar_box.toolbar.insert(self._what_search_button, -1)
self._what_search_button.show()
self._what_search_button.set_is_important(True)
self._what_widget_contents = None
self._what_drum_widget_contents = None
separator = Gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
toolbar_box.toolbar.insert(self.record_button, -1)
toolbar_box.toolbar.insert(self.play_recording_button, -1)
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self._save_as_audio_bt = ToolButton(icon_name='save-as-audio')
self._save_as_audio_bt.props.tooltip = _('Save as audio')
self._save_as_audio_bt.connect('clicked', self._save_ogg_cb)
self._save_as_audio_bt.show()
self._save_as_audio_bt.set_sensitive(False)
activity_button.page.insert(self._save_as_audio_bt, -1)
self.set_toolbar_box(toolbar_box)
toolbar_box.show_all()
self.keyboard_letters = ['ZSXDCVGBHNJM', 'Q2W3ER5T6Y7U', 'I']
notes = ['DO', ['DO#', 'REb'], 'RE', ['RE#', 'MIb'], 'MI', 'FA',
['FA#', 'SOLb'], 'SOL',
['SOL#', 'LAb'], 'LA', ['LA#', 'SIb'], 'SI']
self.notes_labels = [notes, notes, ['DO']]
# some countries use TI instead of SI
ti_notes = ['DO', ['DO#', 'REb'], 'RE', ['RE#', 'MIb'], 'MI', 'FA',
['FA#', 'SOLb'], 'SOL',
['SOL#', 'LAb'], 'LA', ['LA#', 'TIb'], 'TI']
self.ti_notes_labels = [ti_notes, ti_notes, ['DO']]
german_notes = ['C', ['C#', 'Db'], 'D', ['D#', 'Eb'], 'E', 'F',
['F#', 'Gb'], 'G',
['G#', 'Ab'], 'A', ['A#', 'Bb'], 'B']
self.german_labels = [german_notes, german_notes, ['C']]
self.piano = PianoKeyboard(octaves=2, add_c=True,
labels=self.keyboard_letters)
# init csound
self.instrumentDB = InstrumentDB.getRef()
self.timeout_ms = 50
self.instVolume = 50
self.drumVolume = 0.5
self.instrument = 'piano'
self.beat = 4
self.reverb = 0.1
self.tempo = PLAYER_TEMPO
self.beatDuration = 60.0 / self.tempo
self.ticksPerSecond = Config.TICKS_PER_BEAT * self.tempo / 60.0
self.sequencer = MiniSequencer(self.recordStateButton,
self.recordOverSensitivity)
self.loop = Loop(self.beat, math.sqrt(self.instVolume * 0.01))
self.drumFillin = Fillin(self.beat,
self.tempo,
self.rythmInstrument,
self.reverb,
self.drumVolume)
self.muteInst = False
self.csnd.setTempo(self.tempo)
self.noteList = []
for i in range(21):
self.csnd.setTrackVolume(100, i)
# TODO commented because apparently are not used in the activity
# for i in range(10):
# self.csnd.load_instrument('guidice' + str(i + 1))
self.volume = 100
self.csnd.setMasterVolume(self.volume)
self.enableKeyboard()
self.setInstrument(self.instrument)
self.connect('key-press-event', self.onKeyPress)
self.connect('key-release-event', self.onKeyRelease)
self.piano.connect('key_pressed', self.__key_pressed_cb)
self.piano.connect('key_released', self.__key_released_cb)
vbox = Gtk.VBox()
vbox.set_homogeneous(False)
self.load_instruments()
self._event_box = Gtk.EventBox()
self._event_box.modify_bg(
Gtk.StateType.NORMAL, style.COLOR_WHITE.get_gdk_color())
vbox.pack_start(self._event_box, False, False, 0)
vbox.pack_end(self.piano, True, True, 0)
vbox.show_all()
self.set_canvas(vbox)
piano_height = Gdk.Screen.width() / 2
self._event_box.set_size_request(
-1, Gdk.Screen.height() - piano_height - style.GRID_CELL_SIZE)
self.connect('size-allocate', self.__allocate_cb)
# TODO: disabe until is implemented with csnd6
# GLib.idle_add(self.initializePercussion)
def createPercussionToolbar(self, toolbar_box):
self.beats_pm_button = IntensitySelector(range(2, 13),
4,
imagefile('beat3.svg'))
self.tempo_button = \
IntensitySelector(range(PLAYER_TEMPO_LOWER,
PLAYER_TEMPO_UPPER + 1, PLAYER_TEMPO_STEP),
PLAYER_TEMPO, imagefile('tempo5.png'))
self.complexity_button = IntensitySelector(xfrange(0, 1, 0.1),
self.regularity,
imagefile('complex6.svg'))
self._play_percussion_btn = ToolButton(
icon_name='media-playback-start')
self._play_percussion_btn.set_property('can-default', True)
self._play_percussion_btn.show()
self._play_percussion_btn.connect('clicked', self.handlePlayButton)
beats_toolbar = ToolbarBox()
beats_toolbar.toolbar.insert(self._play_percussion_btn, -1)
self._what_drum_widget = Gtk.ToolItem()
self._what_drum_search_button = FilterToolItem(
_('Select Drum'), 'view-type', _('Jazz / Rock Kit'),
self._what_drum_widget)
self._what_drum_search_button.set_widget_icon(
file_name=imagefile("drum1kit.svg"))
self._what_drum_widget.show()
beats_toolbar.toolbar.insert(self._what_drum_search_button, -1)
self._what_drum_search_button.show()
self._what_drum_search_button.set_is_important(True)
beats_toolbar.toolbar.insert(Gtk.SeparatorToolItem(), -1)
beats_toolbar.toolbar.insert(self.complexity_button, -1)
beats_toolbar.toolbar.insert(self.beats_pm_button, -1)
beats_toolbar.toolbar.insert(self.tempo_button, -1)
beats_toolbar_button = ToolbarButton(icon_name='toolbar-drums',
page=beats_toolbar)
beats_toolbar_button.show()
toolbar_box.toolbar.insert(beats_toolbar_button, 1)
self.beats_pm_button.set_tooltip(_("Beats per bar"))
self.beats_pm_button.show()
self.beats_pm_button.connect('changed', self.beatSliderChange, True)
self.tempo_button.connect('changed', self.tempoSliderChange, True)
self.complexity_button.connect('changed',
self.handleComplexityChange,
True)
self.complexity_button.set_tooltip(_("Beat complexity"))
self.tempo_button.show()
self.tempo_button.set_tooltip(_('Tempo'))
self.complexity_button.show()
def initializePercussion(self):
self.rythmInstrument = 'drum1kit'
self.csnd.load_drumkit(self.rythmInstrument)
self.csnd.setTempo(self.tempo)
self.beatPickup = False
def flatten(ll):
rval = []
for l in ll:
rval += l
return rval
noteOnsets = []
notePitchs = []
i = 0
self.noteList = []
self.csnd.loopClear()
for x in flatten(
generator(self.rythmInstrument, self.beat,
0.8, self.regularity, self.reverb)):
x.amplitude = x.amplitude * self.drumVolume
noteOnsets.append(x.onset)
notePitchs.append(x.pitch)
n = Note(0, x.trackId, i, x)
self.noteList.append((x.onset, n))
i = i + 1
self.csnd.loopPlay(n, 1) # add as active
self.csnd.loopSetNumTicks(self.beat * Config.TICKS_PER_BEAT)
self.drumFillin.unavailable(noteOnsets, notePitchs)
if self.playing:
self.csnd.loopStart()
def __allocate_cb(self, widget, rect):
GLib.idle_add(self.resize, rect.width, rect.height)
return False
def resize(self, width, height):
logging.debug('activity.py resize......')
piano_height = width / 2
self._event_box.set_size_request(
-1, Gdk.Screen.height() - piano_height - style.GRID_CELL_SIZE)
return False
def load_instruments(self):
self._instruments_store = []
# load the images
images_path = os.path.join(activity.get_bundle_path(),
'instruments')
logging.debug('Loading instrument images from %s', images_path)
for file_name in os.listdir(images_path):
image_file_name = os.path.join(images_path, file_name)
pxb = GdkPixbuf.Pixbuf.new_from_file_at_size(
image_file_name, 75, 75)
# instrument_name = image_file_name[image_file_name.rfind('/'):]
instrument_name = image_file_name[image_file_name.rfind('/') + 1:]
instrument_name = instrument_name[:instrument_name.find('.')]
instrument_desc = \
self.instrumentDB.instNamed[instrument_name].nameTooltip
file_path = os.path.join(images_path, file_name)
# set the default icon
if (instrument_name == 'piano'):
self._what_search_button.set_widget_icon(
file_name=file_path)
self._instruments_store.append(
{"instrument_name": instrument_name,
"pxb": pxb,
"instrument_desc": instrument_desc,
"file_name": file_path,
"callback": self.__instrument_iconview_activated_cb})
self._what_widget_contents = set_palette_list(self._instruments_store)
self._what_widget.add(self._what_widget_contents)
self._what_widget_contents.show()
# TODO: disabe until is implemented with csnd6
"""
for drum_number in range(0, DRUMCOUNT):
drum_name = 'drum%dkit' % (drum_number + 1)
self._drums_store.append({
"instrument_name": drum_name,
"file_name": imagefile(drum_name + '.svg'),
"instrument_desc":
self.instrumentDB.instNamed[drum_name].nameTooltip,
"callback": self.__drum_iconview_activated_cb
})
self._what_drum_widget_contents = set_palette_list(self._drums_store)
self._what_drum_widget.add(self._what_drum_widget_contents)
self._what_drum_widget_contents.show()
"""
def __drum_iconview_activated_cb(self, widget, event, item):
data = item['instrument_name']
self.rythmInstrument = data
self.csnd.load_drumkit(data)
instrumentId = self.instrumentDB.instNamed[data].instrumentId
for (o, n) in self.noteList:
self.csnd.loopUpdate(n, NoteDB.PARAMETER.INSTRUMENT,
instrumentId, -1)
self.drumFillin.setInstrument(self.rythmInstrument)
self._what_drum_search_button.set_widget_label(
label=item['instrument_desc'])
self._what_drum_search_button.set_widget_icon(
file_name=item['file_name'])
def __instrument_iconview_activated_cb(self, widget, event, item):
self.setInstrument(item['instrument_name'])
self._what_search_button.set_widget_icon(file_name=item['file_name'])
self._what_search_button.set_widget_label(
label=item['instrument_desc'])
def set_notes_labels_cb(self, widget):
self.piano.font_size = 16
self.piano.set_labels(self.notes_labels)
def set_ti_notes_labels_cb(self, widget):
self.piano.font_size = 16
self.piano.set_labels(self.ti_notes_labels)
def set_keyboard_labels_cb(self, widget):
self.piano.font_size = 25
self.piano.set_labels(self.keyboard_letters)
def set_german_labels_cb(self, widget):
self.piano.font_size = 25
self.piano.set_labels(self.german_labels)
def beatSliderChange(self, widget, event):
self.beat = int(self.beats_pm_button.get_value())
self.sequencer.beat = self.beat
self.loop.beat = self.beat
self.drumFillin.setBeats(self.beat)
img = int(self.scale(self.beat, 2, 12, 1, 11))
self.beats_pm_button.set_image(imagefile('beat' + str(img) + '.svg'))
self.beatPickup = False
self.regenerate()
self.beatPickup = True
def regenerate(self):
def flatten(ll):
rval = []
for l in ll:
rval += l
return rval
noteOnsets = []
notePitchs = []
i = 0
self.noteList = []
self.csnd.loopClear()
for x in flatten(
generator(self.rythmInstrument,
self.beat, 0.8, self.regularity,
self.reverb)):
x.amplitude = x.amplitude * self.drumVolume
noteOnsets.append(x.onset)
notePitchs.append(x.pitch)
n = Note(0, x.trackId, i, x)
self.noteList.append((x.onset, n))
i = i + 1
self.csnd.loopPlay(n, 1) # add as active
self.csnd.loopSetNumTicks(self.beat * Config.TICKS_PER_BEAT)
self.drumFillin.unavailable(noteOnsets, notePitchs)
self.recordOverSensitivity(False)
if self.playing:
self.csnd.loopStart()
def handlePlayRecordingButton(self, val):
if not self.playing_recording:
self.playing_recording = True
self.play_recording_button.props.icon_name = 'media-playback-stop'
self.play_recording_thread = \
GLib.timeout_add(100, self._play_recorded_keys)
else:
self.playing_recording = False
self.play_recording_button.props.icon_name = 'media-playback-start'
def _save_ogg_cb(self, widget):
self._wav_tempfile = tempfile.NamedTemporaryFile(
mode='w+b', suffix='.wav', dir='/tmp/')
self.csnd.inputMessage(Config.CSOUND_RECORD_PERF %
self._wav_tempfile.name)
self.playing_recording = True
self.play_recording_thread = \
GLib.timeout_add(100, self._play_recorded_keys,
self._save_ogg_end_cb)
def _save_ogg_end_cb(self):
self.csnd.inputMessage(Config.CSOUND_STOP_RECORD_PERF %
self._wav_tempfile.name)
self._ogg_tempfile = tempfile.NamedTemporaryFile(
mode='w+b', suffix='.ogg', dir='/tmp/')
line = 'filesrc location=%s ! ' \
'wavparse ! audioconvert ! vorbisenc ! oggmux ! ' \
'filesink location=%s' % (self._wav_tempfile.name,
self._ogg_tempfile.name)
pipe = Gst.parse_launch(line)
pipe.get_bus().add_signal_watch()
pipe.get_bus().connect('message::eos', self._save_ogg_eos_cb, pipe)
pipe.set_state(Gst.State.PLAYING)
def _save_ogg_eos_cb(self, bus, message, pipe):
bus.remove_signal_watch()
pipe.set_state(Gst.State.NULL)
title = '%s saved as audio' % self.metadata['title']
jobject = datastore.create()
jobject.metadata['title'] = title
jobject.metadata['keep'] = '0'
jobject.metadata['mime_type'] = 'audio/ogg'
jobject.file_path = self._ogg_tempfile.name
datastore.write(jobject)
self._wav_tempfile.close()
self._ogg_tempfile.close()
alert = NotifyAlert(10)
alert.props.title = _('Audio recorded')
alert.props.msg = _('The audio file was saved in the Journal')
alert.connect('response', self.__alert_response_cb)
self.add_alert(alert)
return False
def __alert_response_cb(self, alert, result):
self.remove_alert(alert)
def __record_button_click_cb(self, button):
if not self.recording:
self.play_recording_button.set_sensitive(False)
self._save_as_audio_bt.set_sensitive(False)
self.recorded_keys = []
self.recording = True
icon = Icon(icon_name='media-record', fill_color='#ff0000')
icon.show()
self.record_button.set_icon_widget(icon)
else:
self.recording = False
icon = Icon(icon_name='media-record', fill_color='#ffffff')
icon.show()
self.record_button.set_icon_widget(icon)
if len(self.recorded_keys) != 0:
self.play_recording_button.set_sensitive(True)
self._save_as_audio_bt.set_sensitive(True)
def tempoSliderChange(self, widget, event):
self._updateTempo(self.tempo_button.get_value())
img = int(self.scale(self.tempo, PLAYER_TEMPO_LOWER,
PLAYER_TEMPO_UPPER, 1, 9))
self.tempo_button.set_image(imagefile('tempo' + str(img) + '.png'))
def _updateTempo(self, val):
self.tempo = val
self.beatDuration = 60.0 / self.tempo
self.ticksPerSecond = Config.TICKS_PER_BEAT * self.tempo / 60.0
self.csnd.setTempo(self.tempo)
self.sequencer.tempo = self.tempo
self.drumFillin.setTempo(self.tempo)
def handlePlayButton(self, val):
if not self.playing:
if not self.firstTime:
self.regenerate()
self.firstTime = True
self.drumFillin.play()
self.csnd.loopSetTick(0)
self.csnd.loopStart()
self.playing = True
self._play_percussion_btn.props.icon_name = 'media-playback-stop'
else:
self.drumFillin.stop()
self.sequencer.stopPlayback()
self.csnd.loopPause()
self.playing = False
self._play_percussion_btn.props.icon_name = 'media-playback-start'
def scale(self, input, input_min, input_max,
output_min, output_max):
range_input = input_max - input_min
range_output = output_max - output_min
result = (input - input_min) * range_output / range_input + output_min
if (input_min > input_max and output_min > output_max) or \
(output_min > output_max and input_min < input_max):
if result > output_min:
return output_min
elif result < output_max:
return output_max
else:
return result
if (input_min < input_max and output_min < output_max) or \
(output_min < output_max and input_min > input_max):
if result > output_max:
return output_max
elif result < output_min:
return output_min
else:
return result
def handleComplexityChange(self, widget, event):
self.regularity = self.complexity_button.get_value()
img = int(self.complexity_button.get_value() * 7) + 1
self.complexity_button.set_image(
imagefile('complex' + str(img) + '.svg'))
self.beatPickup = False
self.regenerate()
self.beatPickup = True
"""
def handleBalanceSlider(self, adj):
self.instVolume = int(adj.get_value())
self.drumVolume = sqrt( (100-self.instVolume)*0.01 )
self.adjustDrumVolume()
self.drumFillin.setVolume(self.drumVolume)
instrumentVolume = sqrt( self.instVolume*0.01 )
self.loop.adjustLoopVolume(instrumentVolume)
self.sequencer.adjustSequencerVolume(instrumentVolume)
img = int(self.scale(self.instVolume,100,0,0,4.9))
self._playToolbar.balanceSliderImgLeft.set_from_file(
imagefile('dru' + str(img) + '.png'))
img2 = int(self.scale(self.instVolume,0,100,0,4.9))
self._playToolbar.balanceSliderImgRight.set_from_file(
imagefile('instr' + str(img2) + '.png'))
def handleReverbSlider(self, adj):
self.reverb = adj.get_value()
self.drumFillin.setReverb( self.reverb )
img = int(self.scale(self.reverb,0,1,0,4))
self._playToolbar.reverbSliderImgRight.set_from_file(
imagefile('reverb' + str(img) + '.png'))
self.keyboardStandAlone.setReverb(self.reverb)
"""
def set_keyboard_no_labels_cb(self, widget):
self.piano.font_size = 25
self.piano.set_labels(None)
def enableKeyboard(self):
self.keyboardStandAlone = KeyboardStandAlone(
self.sequencer.recording, self.sequencer.adjustDuration,
self.csnd.loopGetTick, self.sequencer.getPlayState, self.loop)
self.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
def setInstrument(self, instrument):
logging.debug("Set Instrument: %s" % instrument)
self.instrument = instrument
self.keyboardStandAlone.setInstrument(instrument)
self.csnd.load_instrument(instrument)
def recordStateButton(self, button, state):
pass
# if button == 1:
# self._recordToolbar.keyboardRecButton.set_active( state )
# else:
# self._recordToolbar.keyboardRecOverButton.set_active( state )
def recordOverSensitivity(self, state):
pass
# self._recordToolbar.keyboardRecOverButton.set_sensitive( state )
def _play_recorded_keys(self, end_cb=None):
GLib.source_remove(self.play_recording_thread)
letter = self.recorded_keys[self.play_index]
time_difference = 0
if self.play_index == len(self.recorded_keys) - 1:
time_difference = \
self.recorded_keys[self.play_index][0] - \
self.recorded_keys[self.play_index - 1][0]
else:
next_time = self.recorded_keys[self.play_index + 1][0]
time_difference = next_time - letter[0]
if not self.playing_recording:
self.play_recording_button.props.icon_name = 'media-playback-start'
return
if letter[-1] == 1:
self.keyboardStandAlone.do_key_release(
LETTERS_TO_KEY_CODES[letter[3]])
GLib.idle_add(self.piano.physical_key_changed,
LETTERS_TO_KEY_CODES[letter[3]], False)
else:
self.keyboardStandAlone.do_key_press(
LETTERS_TO_KEY_CODES[letter[3]], None,
math.sqrt(self.instVolume * 0.01))
GLib.idle_add(self.piano.physical_key_changed,
LETTERS_TO_KEY_CODES[letter[3]], True)
if self.play_index == len(self.recorded_keys) - 1:
self.play_index = 0
self.play_recording_button.props.icon_name = 'media-playback-start'
self.playing_recording = False
if end_cb is not None:
end_cb()
else:
self.play_index += 1
self.play_recording_thread = \
GLib.timeout_add(int((time_difference) * 1000),
self._play_recorded_keys, end_cb)
def __key_pressed_cb(self, widget, octave_clicked, key_clicked, letter,
physicallKey):
logging.debug(
'Pressed Octave: %d Key: %d Letter: %s' %
(octave_clicked, key_clicked, letter))
if letter in LETTERS_TO_KEY_CODES.keys():
if self.recording:
self.recorded_keys.append(
[time.time(), octave_clicked, key_clicked, letter])
if not physicallKey:
self.keyboardStandAlone.do_key_press(
LETTERS_TO_KEY_CODES[letter], None,
math.sqrt(self.instVolume * 0.01))
def __key_released_cb(self, widget, octave_clicked, key_clicked, letter,
physicallKey):
if self.recording:
self.recorded_keys.append(
[time.time(), octave_clicked, key_clicked, letter, 1])
if not physicallKey:
if letter in LETTERS_TO_KEY_CODES.keys():
self.keyboardStandAlone.do_key_release(
LETTERS_TO_KEY_CODES[letter])
def onKeyPress(self, widget, event):
if event.state & Gdk.ModifierType.CONTROL_MASK:
return
if event.hardware_keycode == 37:
if self.muteInst:
self.muteInst = False
else:
self.muteInst = True
self.piano.physical_key_changed(event.hardware_keycode, True)
self.keyboardStandAlone.onKeyPress(
widget, event, math.sqrt(self.instVolume * 0.01))
def onKeyRelease(self, widget, event):
self.keyboardStandAlone.onKeyRelease(widget, event)
self.piano.physical_key_changed(event.hardware_keycode, False)
def write_file(self, file_path):
f = open(file_path, 'w')
# substract the initial time to all the saved values
if len(self.recorded_keys) > 0:
initial_time = self.recorded_keys[0][0]
for key in self.recorded_keys:
key[0] = key[0] - initial_time
f.write(json.dumps(self.recorded_keys))
f.close()
def read_file(self, file_path):
f = open(file_path, 'r')
contents = f.read().strip()
self.recorded_keys = json.loads(contents)
if len(self.recorded_keys) != 0:
self.play_recording_button.set_sensitive(True)
self._save_as_audio_bt.set_sensitive(True)
f.close()
def close(self, skip_save=False):
self.csnd.stop() # without which Csound will segfault
activity.Activity.close(self, skip_save=skip_save)
class miniTamTamMain(gtk.EventBox):
def __init__(self, activity):
gtk.EventBox.__init__(self)
self.instrumentPanel = None
self.activity = activity
#self.set_border_width(Config.MAIN_WINDOW_PADDING)
#self.set_border_width(0)
self.instrumentDB = InstrumentDB.getRef()
self.firstTime = False
self.playing = False
self.csnd = new_csound_client()
self.timeout_ms = 50
self.instVolume = 50
self.drumVolume = 0.5
self.instrument = 'sarangi'
self.regularity = 0.75
self.beat = 4
self.reverb = 0.1
self.tempo = Config.PLAYER_TEMPO
self.beatDuration = 60.0 / self.tempo
self.ticksPerSecond = Config.TICKS_PER_BEAT * self.tempo / 60.0
self.rythmInstrument = 'drum1kit'
self.csnd.load_drumkit(self.rythmInstrument)
self.muteInst = False
self.drumFillin = Fillin(self.beat, self.tempo, self.rythmInstrument,
self.reverb, self.drumVolume)
self.sequencer = MiniSequencer(self.recordStateButton,
self.recordOverSensitivity)
self.loop = Loop(self.beat, sqrt(self.instVolume * 0.01))
self.csnd.setTempo(self.tempo)
self.noteList = []
time.sleep(0.001) # why?
self.trackpad = Trackpad(self)
for i in range(21):
self.csnd.setTrackVolume(100, i)
for i in range(10):
r = str(i + 1)
self.csnd.load_instrument('guidice' + r)
self.volume = 100
self.csnd.setMasterVolume(self.volume)
self.sequencer.beat = self.beat
self.loop.beat = self.beat
self.tooltips = gtk.Tooltips()
self.mainWindowBox = gtk.HBox()
self.leftBox = gtk.VBox()
self.rightBox = gtk.VBox()
self.mainWindowBox.pack_start(self.rightBox, False, True)
self.mainWindowBox.pack_start(self.leftBox, True, True)
self.add(self.mainWindowBox)
self.enableKeyboard()
self.setInstrument(self.instrument)
self.connect('key-press-event', self.onKeyPress)
self.connect('key-release-event', self.onKeyRelease)
self.drawGeneration()
self.show_all()
if 'a good idea' == True:
self.playStartupSound()
self.beatPickup = True
#self.regenerate()
self.heartbeatStart = time.time()
self.syncQueryStart = {}
self.syncTimeout = None
self.network = Net.Network()
self.network.addWatcher(self.networkStatusWatcher)
self.network.connectMessage(Net.HT_SYNC_REPLY,
self.processHT_SYNC_REPLY)
self.network.connectMessage(Net.HT_TEMPO_UPDATE,
self.processHT_TEMPO_UPDATE)
self.network.connectMessage(Net.PR_SYNC_QUERY,
self.processPR_SYNC_QUERY)
self.network.connectMessage(Net.PR_TEMPO_QUERY,
self.processPR_TEMPO_QUERY)
self.network.connectMessage(Net.PR_REQUEST_TEMPO_CHANGE,
self.processPR_REQUEST_TEMPO_CHANGE)
# data packing classes
self.packer = xdrlib.Packer()
self.unpacker = xdrlib.Unpacker("")
#-- handle forced networking ---------------------------------------
if self.network.isHost():
self.updateSync()
self.syncTimeout = gobject.timeout_add(1000, self.updateSync)
elif self.network.isPeer():
self.sendTempoQuery()
self.syncTimeout = gobject.timeout_add(1000, self.updateSync)
#-------------------------------------------------------------------
# Toolbar
if Config.HAVE_TOOLBOX:
from sugar.graphics.toolbarbox import ToolbarButton
# no sharing
# self.max_participants = 1
self._playToolbar = playToolbar(self)
## Uncomment to show play and record tabs ##
'''
play_toolbar_button = ToolbarButton(label=_('Play'),
page=self._playToolbar,
# Fixme: need an icon
icon_name='activity-start')
self._playToolbar.show()
play_toolbar_button.show()
self.activity.toolbox.toolbar.insert(play_toolbar_button, -1)
self._recordToolbar = recordToolbar(self)
record_toolbar_button = ToolbarButton(label=_('Record'),
page=self._recordToolbar,
# Fixme: need an icon
icon_name='media-record')
self._recordToolbar.show()
record_toolbar_button.show()
self.activity.toolbox.toolbar.insert(record_toolbar_button, -1)
'''
else:
self._playToolbar = playToolbar(self)
## set to 1 to show play and record tabs ##
if 0:
self._recordToolbar = recordToolbar(self)
self.activity.toolbox.add_toolbar(_('Play'), self._playToolbar)
self.activity.toolbox.add_toolbar(_('Record'), self._recordToolbar)
self.activity.toolbox.set_current_toolbar(1)
self._playToolbar.show()
self._recordToolbar.show()
if not Config.HAVE_TOOLBOX:
self.activity.connect("shared", self.shared)
if os.path.isfile("FORCE_SHARE"): # HOST
r = random.random()
#print "::::: Sharing as TTDBG%f :::::" % r
#self.activity.set_title(_("TTDBG%f" % r))
print "::::: Sharing as TamTam :::::"
self.activity.set_title(_("TamTam"))
self.activity.share()
elif self.activity._shared_activity: # PEER
self.activity._shared_activity.connect("buddy-joined",
self.buddy_joined)
self.activity._shared_activity.connect("buddy-left",
self.buddy_left)
self.activity.connect("joined", self.joined)
self.network.setMode(Net.MD_WAIT)
#self.activity.activity_toolbar.share.hide()
def drawGeneration(self):
slidersBox = RoundVBox(fillcolor=Config.PANEL_COLOR,
bordercolor=Config.PANEL_BCK_COLOR,
radius=Config.PANEL_RADIUS)
slidersBox.set_border_width(Config.PANEL_SPACING)
geneSliderBox = gtk.VBox()
self.geneSliderBoxImgTop = gtk.Image()
self.geneSliderBoxImgTop.set_from_file(imagefile('complex6.png'))
self.geneAdjustment = gtk.Adjustment(value=self.regularity,
lower=0,
upper=1,
step_incr=0.01,
page_incr=0,
page_size=0)
self.geneSlider = ImageVScale('sliderbutbleu.png', self.geneAdjustment,
5)
self.geneSlider.set_inverted(False)
self.geneAdjustment.connect("value_changed",
self.handleGenerationSlider)
self.geneSlider.connect("button-release-event",
self.handleGenerationSliderRelease)
geneSliderBox.pack_start(self.geneSliderBoxImgTop, False, padding=10)
geneSliderBox.pack_start(self.geneSlider, True, 20)
self.tooltips.set_tip(self.geneSlider, Tooltips.COMPL)
beatSliderBox = gtk.VBox()
self.beatSliderBoxImgTop = gtk.Image()
self.beatSliderBoxImgTop.set_from_file(imagefile('beat3.png'))
self.beatAdjustment = gtk.Adjustment(value=self.beat,
lower=2,
upper=12,
step_incr=1,
page_incr=0,
page_size=0)
self.beatSlider = ImageVScale('sliderbutjaune.png',
self.beatAdjustment,
5,
snap=1)
self.beatSlider.set_inverted(True)
self.beatAdjustment.connect("value_changed", self.handleBeatSlider)
self.beatSlider.connect("button-release-event",
self.handleBeatSliderRelease)
beatSliderBox.pack_start(self.beatSliderBoxImgTop, False, padding=10)
beatSliderBox.pack_start(self.beatSlider, True, 20)
self.tooltips.set_tip(self.beatSlider, Tooltips.BEAT)
self.delayedTempo = 0 # used to store tempo updates while the slider is active
self.tempoSliderActive = False
tempoSliderBox = gtk.VBox()
self.tempoSliderBoxImgTop = gtk.Image()
self.tempoSliderBoxImgTop.set_from_file(imagefile('tempo5.png'))
self.tempoAdjustment = gtk.Adjustment(value=self.tempo,
lower=Config.PLAYER_TEMPO_LOWER,
upper=Config.PLAYER_TEMPO_UPPER,
step_incr=1,
page_incr=1,
page_size=1)
tempoSlider = ImageVScale('sliderbutvert.png', self.tempoAdjustment, 5)
tempoSlider.set_inverted(True)
self.tempoAdjustmentHandler = self.tempoAdjustment.connect(
"value_changed", self.handleTempoSliderChange)
tempoSlider.connect("button-press-event", self.handleTempoSliderPress)
tempoSlider.connect("button-release-event",
self.handleTempoSliderRelease)
tempoSliderBox.pack_start(self.tempoSliderBoxImgTop, False, padding=10)
tempoSliderBox.pack_start(tempoSlider, True)
self.tooltips.set_tip(tempoSlider, Tooltips.TEMPO)
volumeSliderBox = gtk.VBox()
self.volumeSliderBoxImgTop = gtk.Image()
self.volumeSliderBoxImgTop.set_from_file(imagefile('volume2.png'))
self.volumeAdjustment = gtk.Adjustment(value=self.volume,
lower=0,
upper=200,
step_incr=1,
page_incr=1,
page_size=1)
volumeSlider = ImageVScale('sliderbutbleu.png', self.volumeAdjustment,
5)
volumeSlider.set_inverted(True)
self.volumeAdjustment.connect("value_changed", self.handleVolumeSlider)
#volumeSlider.connect("button-release-event", self.handleVolumeSliderRelease)
volumeSliderBox.pack_start(self.volumeSliderBoxImgTop,
False,
padding=10)
volumeSliderBox.pack_start(volumeSlider, True)
self.tooltips.set_tip(volumeSlider, Tooltips.VOL)
slidersBoxSub = gtk.HBox()
slidersBoxSub.pack_start(beatSliderBox)
slidersBoxSub.pack_start(geneSliderBox)
slidersBoxSub.pack_start(tempoSliderBox)
slidersBoxSub.pack_start(volumeSliderBox)
slidersBox.pack_start(slidersBoxSub)
generateBtnSub = RoundHBox(fillcolor=Config.PANEL_COLOR,
bordercolor=Config.PANEL_BCK_COLOR,
radius=Config.PANEL_RADIUS)
generateBtnSub.set_border_width(Config.PANEL_SPACING)
#playImg = gtk.Image()
#playImg.set_from_icon_name('media-playback-start', gtk.ICON_SIZE_LARGE_TOOLBAR)
self.playButton = ImageToggleButton('miniplay.png', 'stop.png')
#self.playButton.set_relief(gtk.RELIEF_NONE)
#self.playButton.set_image(playImg)
self.playButton.connect('clicked', self.handlePlayButton)
generateBtnSub.pack_start(self.playButton)
#self.playButton.set_tooltip(_('Play / Stop'))
generateBtn = ImageButton('dice.png', clickImg_path='diceblur.png')
generateBtn.connect('button-press-event', self.handleGenerateBtn)
generateBtnSub.pack_start(generateBtn)
self.tooltips.set_tip(generateBtn, Tooltips.GEN)
# drums
drum_box = RoundVBox(fillcolor=Config.PANEL_COLOR,
bordercolor=Config.PANEL_BCK_COLOR,
radius=Config.PANEL_RADIUS)
drum_scroll = VScrolledBox(scroll_policy=gtk.POLICY_NEVER)
drum_scroll.set_viewport(drum_box)
drum_scroll.modify_bg(
gtk.STATE_NORMAL,
style.Color(Config.PANEL_BCK_COLOR).get_gdk_color())
drum_i = 0
drum_group = None
for row in range(DRUMCOUNT / 2 + DRUMCOUNT % 2):
row_box = gtk.HBox()
drum_box.pack_start(row_box, False)
for col in range(2):
if drum_i >= DRUMCOUNT:
break
drum = ImageRadioButton(
group=drum_group,
mainImg_path='drum%dkit.png' % (drum_i + 1),
altImg_path='drum%dkitselgen.png' % (drum_i + 1))
drum.connect('clicked', self.handleGenerationDrumBtn,
'drum%dkit' % (drum_i + 1))
row_box.pack_start(drum)
drum_name = 'drum%dkit' % (drum_i + 1)
hint = self.instrumentDB.instNamed[drum_name].nameTooltip
self.tooltips.set_tip(drum, hint)
if not drum_group:
drum_group = drum
drum_i += 1
self.rightBox.pack_start(slidersBox, False)
self.rightBox.pack_start(generateBtnSub, False)
self.rightBox.pack_start(drum_scroll)
drum_size = drum_group.get_size_request()
slidersBox.set_size_request(-1, int(drum_size[1] * 2.3))
self.rightBox.set_size_request(int(drum_size[0] * 2.05), -1)
def loopSettingsChannel(self, channel, value):
self.csnd.setChannel(channel, value)
def loopSettingsPlayStop(self, state, loop):
if not state:
if loop:
self.loopSettingsPlaying = True
self.csnd.inputMessage(Config.CSOUND_PLAY_LS_NOTE % 5022)
else:
self.csnd.inputMessage(Config.CSOUND_PLAY_LS_NOTE % 5023)
else:
if loop:
self.loopSettingsPlaying = False
self.csnd.inputMessage(Config.CSOUND_STOP_LS_NOTE)
def load_ls_instrument(self, soundName):
self.csnd.load_ls_instrument(soundName)
def updateInstrumentPanel(self):
if self.instrumentPanel is None:
self.instrumentPanel = InstrumentPanel()
self.leftBox.pack_start(self.instrumentPanel)
width = gtk.gdk.screen_width() - self.rightBox.get_size_request()[0]
self.instrumentPanel.configure(self.setInstrument,
self.playInstrumentNote,
False,
self.micRec,
width=width)
self.instrumentPanel.load()
def micRec(self, widget, mic):
self.csnd.inputMessage("i5600 0 4")
OS.arecord(4, "crop.csd", mic)
self.micTimeout = gobject.timeout_add(200, self.loadMicInstrument, mic)
self.instrumentPanel.set_activeInstrument(mic, True)
self.setInstrument(mic)
def recordStateButton(self, button, state):
if button == 1:
self._recordToolbar.keyboardRecButton.set_active(state)
else:
self._recordToolbar.keyboardRecOverButton.set_active(state)
def recordOverSensitivity(self, state):
pass
#self._recordToolbar.keyboardRecOverButton.set_sensitive( state )
def loadMicInstrument(self, data):
self.csnd.load_mic_instrument(data)
def regenerate(self):
def flatten(ll):
rval = []
for l in ll:
rval += l
return rval
if self.beatPickup:
self.pickupNewBeat()
noteOnsets = []
notePitchs = []
i = 0
self.noteList = []
self.csnd.loopClear()
for x in flatten(
generator(self.rythmInstrument, self.beat, 0.8,
self.regularity, self.reverb)):
x.amplitude = x.amplitude * self.drumVolume
noteOnsets.append(x.onset)
notePitchs.append(x.pitch)
n = Note(0, x.trackId, i, x)
self.noteList.append((x.onset, n))
i = i + 1
self.csnd.loopPlay(n, 1) #add as active
self.csnd.loopSetNumTicks(self.beat * Config.TICKS_PER_BEAT)
self.drumFillin.unavailable(noteOnsets, notePitchs)
self.recordOverSensitivity(False)
if self.playing:
self.csnd.loopStart()
def adjustDrumVolume(self):
for n in self.noteList:
self.csnd.loopUpdate(n[1], PARAMETER.AMPLITUDE,
n[1].cs.amplitude * self.drumVolume, 1)
def handleClose(self, widget):
if self.playStopButton.get_active() == True:
self.playStopButton.set_active(False)
self.sequencer.clearSequencer()
self.csnd.loopClear()
self.activity.close()
def handleGenerationSlider(self, adj):
img = int(adj.value * 7) + 1
self.geneSliderBoxImgTop.set_from_file(
imagefile('complex' + str(img) + '.png'))
def handleGenerationSliderRelease(self, widget, event):
self.regularity = widget.get_adjustment().value
self.beatPickup = False
self.regenerate()
self.beatPickup = True
def pickupNewBeat(self):
self.beat = random.randint(2, 12)
img = self.scale(self.beat, 2, 12, 1, 11)
self.beatSliderBoxImgTop.set_from_file(
imagefile('beat' + str(img) + '.png'))
self.beatAdjustment.set_value(self.beat)
self.regularity = random.randint(50, 100) * 0.01
img = int(self.regularity * 7) + 1
self.geneSliderBoxImgTop.set_from_file(
imagefile('complex' + str(img) + '.png'))
self.geneAdjustment.set_value(self.regularity)
self.sequencer.beat = self.beat
self.loop.beat = self.beat
self.drumFillin.setBeats(self.beat)
def handleBeatSlider(self, adj):
img = self.scale(int(adj.value), 2, 12, 1, 11)
self.beatSliderBoxImgTop.set_from_file(
imagefile('beat' + str(img) + '.png'))
self.sequencer.beat = self.beat
self.loop.beat = self.beat
self.drumFillin.setBeats(self.beat)
def handleBeatSliderRelease(self, widget, event):
self.beat = int(widget.get_adjustment().value)
self.sequencer.beat = self.beat
self.loop.beat = self.beat
self.drumFillin.setBeats(self.beat)
self.beatPickup = False
self.regenerate()
self.beatPickup = True
def handleTempoSliderPress(self, widget, event):
self.tempoSliderActive = True
def handleTempoSliderRelease(self, widget, event):
self.tempoSliderActive = False
if self.network.isPeer() and self.delayedTempo != 0:
if self.tempo != self.delayedTempo:
self.tempoAdjustment.handler_block(self.tempoAdjustmentHandler)
self.tempoAdjustment.set_value(self.delayedTempo)
self._updateTempo(self.delayedTempo)
self.tempoAdjustment.handler_unblock(
self.tempoAdjustmentHandler)
self.delayedTempo = 0
self.sendSyncQuery()
def handleTempoSliderChange(self, adj):
if self.network.isPeer():
self.requestTempoChange(int(adj.value))
else:
self._updateTempo(int(adj.value))
def _updateTempo(self, val):
if self.network.isHost():
t = time.time()
percent = self.heartbeatElapsed() / self.beatDuration
self.tempo = val
self.beatDuration = 60.0 / self.tempo
self.ticksPerSecond = Config.TICKS_PER_BEAT * self.tempo / 60.0
self.csnd.setTempo(self.tempo)
self.sequencer.tempo = self.tempo
self.drumFillin.setTempo(self.tempo)
if self.network.isHost():
self.heatbeatStart = t - percent * self.beatDuration
self.updateSync()
self.sendTempoUpdate()
img = int(
self.scale(self.tempo, Config.PLAYER_TEMPO_LOWER,
Config.PLAYER_TEMPO_UPPER, 1, 9))
self.tempoSliderBoxImgTop.set_from_file(
imagefile('tempo' + str(img) + '.png'))
def handleBalanceSlider(self, adj):
self.instVolume = int(adj.value)
self.drumVolume = sqrt((100 - self.instVolume) * 0.01)
self.adjustDrumVolume()
self.drumFillin.setVolume(self.drumVolume)
instrumentVolume = sqrt(self.instVolume * 0.01)
self.loop.adjustLoopVolume(instrumentVolume)
self.sequencer.adjustSequencerVolume(instrumentVolume)
img = int(self.scale(self.instVolume, 100, 0, 0, 4.9))
self._playToolbar.balanceSliderImgLeft.set_from_file(
imagefile('dru' + str(img) + '.png'))
img2 = int(self.scale(self.instVolume, 0, 100, 0, 4.9))
self._playToolbar.balanceSliderImgRight.set_from_file(
imagefile('instr' + str(img2) + '.png'))
def handleReverbSlider(self, adj):
self.reverb = adj.value
self.drumFillin.setReverb(self.reverb)
img = int(self.scale(self.reverb, 0, 1, 0, 4))
self._playToolbar.reverbSliderImgRight.set_from_file(
imagefile('reverb' + str(img) + '.png'))
self.keyboardStandAlone.setReverb(self.reverb)
def handleVolumeSlider(self, adj):
self.volume = adj.value
self.csnd.setMasterVolume(self.volume)
img = int(self.scale(self.volume, 0, 200, 0, 3.9))
self.volumeSliderBoxImgTop.set_from_file(
imagefile('volume' + str(img) + '.png'))
def handlePlayButton(self, widget, data=None):
# use widget.get_active() == False when calling this on 'clicked'
# use widget.get_active() == True when calling this on button-press-event
if widget.get_active() == False:
self.drumFillin.stop()
self.sequencer.stopPlayback()
self.csnd.loopPause()
self.playing = False
else:
if not self.firstTime:
self.regenerate()
self.firstTime = True
self.drumFillin.play()
#self.csnd.loopSetTick(0)
nextInTicks = self.nextHeartbeatInTicks()
#print "play:: next beat in %f ticks. bpb == %d. setting ticks to %d" % (nextInTicks, self.beat, Config.TICKS_PER_BEAT*self.beat - int(round(nextInTicks)))
self.csnd.loopSetTick(Config.TICKS_PER_BEAT * self.beat -
int(round(nextInTicks)))
self.csnd.loopStart()
self.playing = True
def handleGenerationDrumBtn(self, widget, data):
#data is drum1kit, drum2kit, or drum3kit
#print 'HANDLE: Generate Button'
self.rythmInstrument = data
self.csnd.load_drumkit(data)
instrumentId = self.instrumentDB.instNamed[data].instrumentId
for (o, n) in self.noteList:
self.csnd.loopUpdate(n, NoteDB.PARAMETER.INSTRUMENT, instrumentId,
-1)
self.drumFillin.setInstrument(self.rythmInstrument)
def handleGenerateBtn(self, widget, data=None):
self.regenerate()
if not self.playButton.get_active():
self.playButton.set_active(True)
#this calls sends a 'clicked' event,
#which might be connected to handlePlayButton
self.playStartupSound()
def enableKeyboard(self):
self.keyboardStandAlone = KeyboardStandAlone(
self.sequencer.recording, self.sequencer.adjustDuration,
self.csnd.loopGetTick, self.sequencer.getPlayState, self.loop)
self.add_events(gtk.gdk.BUTTON_PRESS_MASK)
def setInstrument(self, instrument):
self.instrument = instrument
self.keyboardStandAlone.setInstrument(instrument)
self.csnd.load_instrument(instrument)
def playInstrumentNote(self, instrument, secs_per_tick=0.025):
if not self.muteInst:
self.csnd.play(
CSoundNote(onset=0,
pitch=36,
amplitude=1,
pan=0.5,
duration=20,
trackId=1,
instrumentId=self.instrumentDB.
instNamed[instrument].instrumentId,
reverbSend=self.reverb,
tied=False,
mode='mini'), secs_per_tick)
def onKeyPress(self, widget, event):
if event.hardware_keycode == 219: #'/*' button to reset drum loop
if self.playStopButton.get_active() == True:
self.handlePlayButton(self.playStopButton)
self.playStopButton.set_active(False)
self.handlePlayButton(self.playStopButton)
self.playStopButton.set_active(True)
if event.hardware_keycode == 37:
if self.muteInst:
self.muteInst = False
else:
self.muteInst = True
if event.hardware_keycode == 65: #what key is this? what feature is this?
pass
#if self.playStopButton.get_active():
#self.playStopButton.set_active(False)
#else:
#self.playStopButton.set_active(True)
self.keyboardStandAlone.onKeyPress(widget, event,
sqrt(self.instVolume * 0.01))
def onKeyRelease(self, widget, event):
self.keyboardStandAlone.onKeyRelease(widget, event)
def playStartupSound(self):
r = str(random.randrange(1, 11))
self.playInstrumentNote('guidice' + r)
def onActivate(self, arg):
self.csnd.loopPause()
self.csnd.loopClear()
def onDeactivate(self):
SubActivity.onDeactivate(self)
self.csnd.loopPause()
self.csnd.loopClear()
def onDestroy(self):
self.network.shutdown()
def scale(self, input, input_min, input_max, output_min, output_max):
range_input = input_max - input_min
range_output = output_max - output_min
result = (input - input_min) * range_output / range_input + output_min
if (input_min > input_max
and output_min > output_max) or (output_min > output_max
and input_min < input_max):
if result > output_min:
return output_min
elif result < output_max:
return output_max
else:
return result
if (input_min < input_max
and output_min < output_max) or (output_min < output_max
and input_min > input_max):
if result > output_max:
return output_max
elif result < output_min:
return output_min
else:
return result
#-----------------------------------------------------------------------
# Network
#-- Activity -----------------------------------------------------------
def shared(self, activity):
if Config.DEBUG:
print "miniTamTam:: successfully shared, start host mode"
self.activity._shared_activity.connect("buddy-joined",
self.buddy_joined)
self.activity._shared_activity.connect("buddy-left", self.buddy_left)
self.network.setMode(Net.MD_HOST)
self.updateSync()
self.syncTimeout = gobject.timeout_add(1000, self.updateSync)
def joined(self, activity):
print "miniTamTam:: joined activity!!"
for buddy in self.activity._shared_activity.get_joined_buddies():
print buddy.props.ip4_address
def buddy_joined(self, activity, buddy):
print "buddy joined " + str(buddy)
try:
print buddy.props.ip4_address
except:
print "bad ip4_address"
if self.network.isHost():
# TODO how do I figure out if this buddy is me?
if buddy.props.ip4_address:
self.network.introducePeer(buddy.props.ip4_address)
else:
print "miniTamTam:: new buddy does not have an ip4_address!!"
def buddy_left(self, activity, buddy):
print "buddy left"
#def joined( self, activity ):
# if Config.DEBUG: print "miniTamTam:: successfully joined, wait for host"
# self.net.waitForHost()
#-- Senders ------------------------------------------------------------
def sendSyncQuery(self):
self.packer.pack_float(random.random())
hash = self.packer.get_buffer()
self.packer.reset()
self.syncQueryStart[hash] = time.time()
self.network.send(Net.PR_SYNC_QUERY, hash)
def sendTempoUpdate(self):
self.packer.pack_int(self.tempo)
self.network.sendAll(Net.HT_TEMPO_UPDATE, self.packer.get_buffer())
self.packer.reset()
def sendTempoQuery(self):
self.network.send(Net.PR_TEMPO_QUERY)
def requestTempoChange(self, val):
self.packer.pack_int(val)
self.network.send(Net.PR_REQUEST_TEMPO_CHANGE,
self.packer.get_buffer())
self.packer.reset()
#-- Handlers -----------------------------------------------------------
def networkStatusWatcher(self, mode):
if mode == Net.MD_OFFLINE:
if self.syncTimeout:
gobject.source_remove(self.syncTimeout)
self.syncTimeout = None
if mode == Net.MD_PEER:
self.updateSync()
if not self.syncTimeout:
self.syncTimeout = gobject.timeout_add(1000, self.updateSync)
self.sendTempoQuery()
def processHT_SYNC_REPLY(self, sock, message, data):
t = time.time()
hash = data[0:4]
latency = t - self.syncQueryStart[hash]
self.unpacker.reset(data[4:8])
nextBeat = self.unpacker.unpack_float()
#print "mini:: got sync: next beat in %f, latency %d" % (nextBeat, latency*1000)
self.heartbeatStart = t + nextBeat - self.beatDuration - latency / 2
self.correctSync()
self.syncQueryStart.pop(hash)
def processHT_TEMPO_UPDATE(self, sock, message, data):
self.unpacker.reset(data)
val = self.unpacker.unpack_int()
if self.tempoSliderActive:
self.delayedTempo = val
return
self.tempoAdjustment.handler_block(self.tempoAdjustmentHandler)
self.tempoAdjustment.set_value(val)
self._updateTempo(val)
self.tempoAdjustment.handler_unblock(self.tempoAdjustmentHandler)
self.sendSyncQuery()
def processPR_SYNC_QUERY(self, sock, message, data):
self.packer.pack_float(self.nextHeartbeat())
self.network.send(Net.HT_SYNC_REPLY, data + self.packer.get_buffer(),
sock)
self.packer.reset()
def processPR_TEMPO_QUERY(self, sock, message, data):
self.packer.pack_int(self.tempo)
self.network.send(Net.HT_TEMPO_UPDATE,
self.packer.get_buffer(),
to=sock)
self.packer.reset()
def processPR_REQUEST_TEMPO_CHANGE(self, sock, message, data):
if self.tempoSliderActive:
return
self.unpacker.reset(data)
val = self.unpacker.unpack_int()
self.tempoAdjustment.set_value(val)
#-----------------------------------------------------------------------
# Sync
def nextHeartbeat(self):
delta = time.time() - self.heartbeatStart
return self.beatDuration - (delta % self.beatDuration)
def nextHeartbeatInTicks(self):
delta = time.time() - self.heartbeatStart
next = self.beatDuration - (delta % self.beatDuration)
return self.ticksPerSecond * next
def heartbeatElapsed(self):
delta = time.time() - self.heartbeatStart
return delta % self.beatDuration
def heartbeatElapsedTicks(self):
delta = time.time() - self.heartbeatStart
return self.ticksPerSecond * (delta % self.beatDuration)
def updateSync(self):
if self.network.isOffline():
return False
elif self.network.isWaiting():
return True
elif self.network.isHost():
self.correctSync()
else:
self.sendSyncQuery()
return True
def correctSync(self):
curTick = self.csnd.loopGetTick()
curTicksIn = curTick % Config.TICKS_PER_BEAT
ticksIn = self.heartbeatElapsedTicks()
err = curTicksIn - ticksIn
if err > Config.TICKS_PER_BEAT_DIV2:
err -= Config.TICKS_PER_BEAT
elif err < -Config.TICKS_PER_BEAT_DIV2:
err += Config.TICKS_PER_BEAT
correct = curTick - err
ticksPerLoop = Config.TICKS_PER_BEAT * self.beat
if correct > ticksPerLoop:
correct -= ticksPerLoop
elif correct < 0:
correct += ticksPerLoop
#print "correct:: %f ticks, %f ticks in, %f expected, %f err, correct %f" % (curTick, curTicksIn, ticksIn, err, correct)
if abs(err) > 0.25:
self.csnd.adjustTick(-err)
class SimplePianoActivity(activity.Activity):
"""SimplePianoActivity class as specified in activity.info"""
def __init__(self, handle):
"""Set up the HelloWorld activity."""
activity.Activity.__init__(self, handle)
# we do not have collaboration features
# make the share option insensitive
self.max_participants = 1
# toolbar with the new toolbar redesign
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
toolbar_box.toolbar.insert(Gtk.SeparatorToolItem(), -1)
keybord_labels = RadioToolButton()
keybord_labels.props.icon_name = 'q_key'
keybord_labels.props.group = keybord_labels
keybord_labels.connect('clicked', self.set_keyboard_labels_cb)
toolbar_box.toolbar.insert(keybord_labels, -1)
notes_labels = RadioToolButton()
notes_labels.props.icon_name = 'do_key'
notes_labels.props.group = keybord_labels
notes_labels.connect('clicked', self.set_notes_labels_cb)
toolbar_box.toolbar.insert(notes_labels, -1)
german_labels = RadioToolButton()
german_labels.props.icon_name = 'c_key'
german_labels.props.group = keybord_labels
german_labels.connect('clicked', self.set_german_labels_cb)
toolbar_box.toolbar.insert(german_labels, -1)
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show_all()
self.keyboard_letters = ['ZSXDCVGBHNJM', 'Q2W3ER5T6Y7U', 'I']
notes = ['DO', 'DO#', 'RE', 'RE#', 'MI', 'FA', 'FA#', 'SOL',
'SOL#', 'LA', 'LA#', 'SI']
self.notes_labels = [notes, notes, ['DO']]
german_notes = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G',
'G#', 'A', 'A#', 'B']
self.german_labels = [german_notes, german_notes, ['C']]
self.piano = PianoKeyboard(octaves=2, add_c=True,
labels=self.keyboard_letters)
# init csound
self.instrumentDB = InstrumentDB.getRef()
self.firstTime = False
self.playing = False
self.csnd = new_csound_client()
self.timeout_ms = 50
self.instVolume = 50
self.drumVolume = 0.5
self.instrument = 'piano'
self.regularity = 0.75
self.beat = 4
self.reverb = 0.1
self.tempo = Config.PLAYER_TEMPO
self.beatDuration = 60.0 / self.tempo
self.ticksPerSecond = Config.TICKS_PER_BEAT * self.tempo / 60.0
#self.rythmInstrument = 'drum1kit'
#self.csnd.load_drumkit(self.rythmInstrument)
self.sequencer = MiniSequencer(self.recordStateButton,
self.recordOverSensitivity)
self.loop = Loop(self.beat, math.sqrt(self.instVolume * 0.01))
self.muteInst = False
self.csnd.setTempo(self.tempo)
self.noteList = []
time.sleep(0.001) # why?
for i in range(21):
self.csnd.setTrackVolume(100, i)
for i in range(10):
r = str(i + 1)
self.csnd.load_instrument('guidice' + r)
self.volume = 100
self.csnd.setMasterVolume(self.volume)
self.enableKeyboard()
self.setInstrument(self.instrument)
self.connect('key-press-event', self.onKeyPress)
self.connect('key-release-event', self.onKeyRelease)
# finish csount init
self.piano.connect('key_pressed', self.__key_pressed_cb)
self.piano.connect('key_released', self.__key_released_cb)
vbox = Gtk.VBox()
vbox.set_homogeneous(False)
self.load_instruments()
vbox.pack_end(self.piano, True, True, 0)
self.scrolled = Gtk.ScrolledWindow()
vbox.pack_start(self.scrolled, False, False, 0)
self.scrolled.add(self.instruments_iconview)
vbox.show_all()
self.set_canvas(vbox)
piano_height = Gdk.Screen.width() / 2
self.scrolled.set_size_request(
-1, Gdk.Screen.height() - piano_height - style.GRID_CELL_SIZE)
self.connect('size-allocate', self.__allocate_cb)
def __allocate_cb(self, widget, rect):
GLib.idle_add(self.resize, rect.width, rect.height)
return False
def resize(self, width, height):
piano_height = width / 2
self.scrolled.set_size_request(
-1, height - piano_height - style.GRID_CELL_SIZE)
return False
def load_instruments(self):
self._instruments_store = Gtk.ListStore(str, GdkPixbuf.Pixbuf, str)
self._instruments_store.set_sort_column_id(0, Gtk.SortType.ASCENDING)
self.instruments_iconview = Gtk.IconView(self._instruments_store)
self.instruments_iconview.set_text_column(2)
self.instruments_iconview.set_pixbuf_column(1)
# load the images
images_path = os.path.join(activity.get_bundle_path(),
'instruments')
logging.error('Loading instrument images from %s', images_path)
for file_name in os.listdir(images_path):
image_file_name = os.path.join(images_path, file_name)
logging.error('Adding %s', image_file_name)
pxb = GdkPixbuf.Pixbuf.new_from_file_at_size(
image_file_name, 75, 75)
#instrument_name = image_file_name[image_file_name.rfind('/'):]
instrument_name = image_file_name[image_file_name.rfind('/') + 1:]
instrument_name = instrument_name[:instrument_name.find('.')]
instrument_desc = \
self.instrumentDB.instNamed[instrument_name].nameTooltip
self._instruments_store.append([instrument_name, pxb,
instrument_desc])
self.instruments_iconview.connect(
'selection-changed', self.__instrument_iconview_activated_cb)
def __instrument_iconview_activated_cb(self, widget):
item = widget.get_selected_items()[0]
model = widget.get_model()
instrument_name = model[item][0]
self.setInstrument(instrument_name)
def set_notes_labels_cb(self, widget):
self.piano.font_size = 16
self.piano.set_labels(self.notes_labels)
def set_keyboard_labels_cb(self, widget):
self.piano.font_size = 25
self.piano.set_labels(self.keyboard_letters)
def set_german_labels_cb(self, widget):
self.piano.font_size = 25
self.piano.set_labels(self.german_labels)
def enableKeyboard(self):
self.keyboardStandAlone = KeyboardStandAlone(
self.sequencer.recording, self.sequencer.adjustDuration,
self.csnd.loopGetTick, self.sequencer.getPlayState, self.loop)
self.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
def setInstrument(self, instrument):
self.instrument = instrument
self.keyboardStandAlone.setInstrument(instrument)
self.csnd.load_instrument(instrument)
def recordStateButton(self, button, state):
pass
# if button == 1:
# self._recordToolbar.keyboardRecButton.set_active( state )
# else:
# self._recordToolbar.keyboardRecOverButton.set_active( state )
def recordOverSensitivity(self, state):
pass
#self._recordToolbar.keyboardRecOverButton.set_sensitive( state )
def __key_pressed_cb(self, widget, octave_clicked, key_clicked, letter):
logging.debug(
'Pressed Octave: %d Key: %d Letter: %s' %
(octave_clicked, key_clicked, letter))
if letter in LETTERS_TO_KEY_CODES.keys():
self.keyboardStandAlone.do_key_press(
LETTERS_TO_KEY_CODES[letter], None,
math.sqrt(self.instVolume * 0.01))
def __key_released_cb(self, widget, octave_clicked, key_clicked, letter):
if letter in LETTERS_TO_KEY_CODES.keys():
self.keyboardStandAlone.do_key_release(
LETTERS_TO_KEY_CODES[letter])
def onKeyPress(self, widget, event):
if event.hardware_keycode == 37:
if self.muteInst:
self.muteInst = False
else:
self.muteInst = True
self.piano.physical_key_changed(event.hardware_keycode, True)
self.keyboardStandAlone.onKeyPress(
widget, event, math.sqrt(self.instVolume * 0.01))
def onKeyRelease(self, widget, event):
self.keyboardStandAlone.onKeyRelease(widget, event)
self.piano.physical_key_changed(event.hardware_keycode, False)
class SimplePianoActivity(activity.Activity):
"""SimplePianoActivity class as specified in activity.info"""
def __init__(self, handle):
"""Set up the HelloWorld activity."""
activity.Activity.__init__(self, handle)
# we do not have collaboration features
# make the share option insensitive
self.max_participants = 1
# toolbar with the new toolbar redesign
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
toolbar_box.toolbar.insert(Gtk.SeparatorToolItem(), -1)
keybord_labels = RadioToolButton()
keybord_labels.props.icon_name = 'q_key'
keybord_labels.props.group = keybord_labels
keybord_labels.connect('clicked', self.set_keyboard_labels_cb)
toolbar_box.toolbar.insert(keybord_labels, -1)
notes_labels = RadioToolButton()
notes_labels.props.icon_name = 'do_key'
notes_labels.props.group = keybord_labels
notes_labels.connect('clicked', self.set_notes_labels_cb)
toolbar_box.toolbar.insert(notes_labels, -1)
ti_notes_labels = RadioToolButton()
ti_notes_labels.props.icon_name = 'ti_key'
ti_notes_labels.props.group = keybord_labels
ti_notes_labels.connect('clicked', self.set_ti_notes_labels_cb)
toolbar_box.toolbar.insert(ti_notes_labels, -1)
german_labels = RadioToolButton()
german_labels.props.icon_name = 'c_key'
german_labels.props.group = keybord_labels
german_labels.connect('clicked', self.set_german_labels_cb)
toolbar_box.toolbar.insert(german_labels, -1)
no_labels = RadioToolButton()
no_labels.props.icon_name = 'edit-clear'
no_labels.props.group = keybord_labels
no_labels.connect('clicked', self.set_keyboard_no_labels_cb)
toolbar_box.toolbar.insert(no_labels, -1)
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show_all()
self.keyboard_letters = ['ZSXDCVGBHNJM', 'Q2W3ER5T6Y7U', 'I']
notes = [
'DO', ['DO#', 'REb'], 'RE', ['RE#', 'MIb'], 'MI', 'FA',
['FA#', 'SOLb'], 'SOL', ['SOL#', 'LAb'], 'LA', ['LA#', 'SIb'], 'SI'
]
self.notes_labels = [notes, notes, ['DO']]
# some countries use TI instead of SI
ti_notes = [
'DO', ['DO#', 'REb'], 'RE', ['RE#', 'MIb'], 'MI', 'FA',
['FA#', 'SOLb'], 'SOL', ['SOL#', 'LAb'], 'LA', ['LA#', 'TIb'], 'TI'
]
self.ti_notes_labels = [ti_notes, ti_notes, ['DO']]
german_notes = [
'C', ['C#', 'Db'], 'D', ['D#', 'Eb'], 'E', 'F', ['F#', 'Gb'], 'G',
['G#', 'Ab'], 'A', ['A#', 'Bb'], 'B'
]
self.german_labels = [german_notes, german_notes, ['C']]
self.piano = PianoKeyboard(octaves=2,
add_c=True,
labels=self.keyboard_letters)
# init csound
self.instrumentDB = InstrumentDB.getRef()
self.firstTime = False
self.playing = False
self.csnd = new_csound_client()
self.timeout_ms = 50
self.instVolume = 50
self.drumVolume = 0.5
self.instrument = 'piano'
self.regularity = 0.75
self.beat = 4
self.reverb = 0.1
self.tempo = Config.PLAYER_TEMPO
self.beatDuration = 60.0 / self.tempo
self.ticksPerSecond = Config.TICKS_PER_BEAT * self.tempo / 60.0
#self.rythmInstrument = 'drum1kit'
#self.csnd.load_drumkit(self.rythmInstrument)
self.sequencer = MiniSequencer(self.recordStateButton,
self.recordOverSensitivity)
self.loop = Loop(self.beat, math.sqrt(self.instVolume * 0.01))
self.muteInst = False
self.csnd.setTempo(self.tempo)
self.noteList = []
time.sleep(0.001) # why?
for i in range(21):
self.csnd.setTrackVolume(100, i)
for i in range(10):
r = str(i + 1)
self.csnd.load_instrument('guidice' + r)
self.volume = 100
self.csnd.setMasterVolume(self.volume)
self.enableKeyboard()
self.setInstrument(self.instrument)
self.connect('key-press-event', self.onKeyPress)
self.connect('key-release-event', self.onKeyRelease)
# finish csount init
self.piano.connect('key_pressed', self.__key_pressed_cb)
self.piano.connect('key_released', self.__key_released_cb)
vbox = Gtk.VBox()
vbox.set_homogeneous(False)
self.load_instruments()
vbox.pack_end(self.piano, True, True, 0)
self.scrolled = Gtk.ScrolledWindow()
vbox.pack_start(self.scrolled, False, False, 0)
self.scrolled.add(self.instruments_iconview)
vbox.show_all()
self.set_canvas(vbox)
piano_height = Gdk.Screen.width() / 2
self.scrolled.set_size_request(
-1,
Gdk.Screen.height() - piano_height - style.GRID_CELL_SIZE)
self.connect('size-allocate', self.__allocate_cb)
def __allocate_cb(self, widget, rect):
GLib.idle_add(self.resize, rect.width, rect.height)
return False
def resize(self, width, height):
piano_height = width / 2
self.scrolled.set_size_request(
-1, height - piano_height - style.GRID_CELL_SIZE)
return False
def load_instruments(self):
self._instruments_store = Gtk.ListStore(str, GdkPixbuf.Pixbuf, str)
self._instruments_store.set_sort_column_id(0, Gtk.SortType.ASCENDING)
self.instruments_iconview = Gtk.IconView(self._instruments_store)
self.instruments_iconview.set_text_column(2)
self.instruments_iconview.set_pixbuf_column(1)
# load the images
images_path = os.path.join(activity.get_bundle_path(), 'instruments')
logging.error('Loading instrument images from %s', images_path)
for file_name in os.listdir(images_path):
image_file_name = os.path.join(images_path, file_name)
logging.error('Adding %s', image_file_name)
pxb = GdkPixbuf.Pixbuf.new_from_file_at_size(
image_file_name, 75, 75)
#instrument_name = image_file_name[image_file_name.rfind('/'):]
instrument_name = image_file_name[image_file_name.rfind('/') + 1:]
instrument_name = instrument_name[:instrument_name.find('.')]
instrument_desc = \
self.instrumentDB.instNamed[instrument_name].nameTooltip
self._instruments_store.append(
[instrument_name, pxb, instrument_desc])
self.instruments_iconview.connect(
'selection-changed', self.__instrument_iconview_activated_cb)
def __instrument_iconview_activated_cb(self, widget):
item = widget.get_selected_items()[0]
model = widget.get_model()
instrument_name = model[item][0]
self.setInstrument(instrument_name)
def set_notes_labels_cb(self, widget):
self.piano.font_size = 16
self.piano.set_labels(self.notes_labels)
def set_ti_notes_labels_cb(self, widget):
self.piano.font_size = 16
self.piano.set_labels(self.ti_notes_labels)
def set_keyboard_labels_cb(self, widget):
self.piano.font_size = 25
self.piano.set_labels(self.keyboard_letters)
def set_german_labels_cb(self, widget):
self.piano.font_size = 25
self.piano.set_labels(self.german_labels)
def set_keyboard_no_labels_cb(self, widget):
self.piano.font_size = 25
self.piano.set_labels(None)
def enableKeyboard(self):
self.keyboardStandAlone = KeyboardStandAlone(
self.sequencer.recording, self.sequencer.adjustDuration,
self.csnd.loopGetTick, self.sequencer.getPlayState, self.loop)
self.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
def setInstrument(self, instrument):
self.instrument = instrument
self.keyboardStandAlone.setInstrument(instrument)
self.csnd.load_instrument(instrument)
def recordStateButton(self, button, state):
pass
# if button == 1:
# self._recordToolbar.keyboardRecButton.set_active( state )
# else:
# self._recordToolbar.keyboardRecOverButton.set_active( state )
def recordOverSensitivity(self, state):
pass
#self._recordToolbar.keyboardRecOverButton.set_sensitive( state )
def __key_pressed_cb(self, widget, octave_clicked, key_clicked, letter):
logging.debug('Pressed Octave: %d Key: %d Letter: %s' %
(octave_clicked, key_clicked, letter))
if letter in LETTERS_TO_KEY_CODES.keys():
self.keyboardStandAlone.do_key_press(
LETTERS_TO_KEY_CODES[letter], None,
math.sqrt(self.instVolume * 0.01))
def __key_released_cb(self, widget, octave_clicked, key_clicked, letter):
if letter in LETTERS_TO_KEY_CODES.keys():
self.keyboardStandAlone.do_key_release(
LETTERS_TO_KEY_CODES[letter])
def onKeyPress(self, widget, event):
if event.hardware_keycode == 37:
if self.muteInst:
self.muteInst = False
else:
self.muteInst = True
self.piano.physical_key_changed(event.hardware_keycode, True)
self.keyboardStandAlone.onKeyPress(widget, event,
math.sqrt(self.instVolume * 0.01))
def onKeyRelease(self, widget, event):
self.keyboardStandAlone.onKeyRelease(widget, event)
self.piano.physical_key_changed(event.hardware_keycode, False)