void MainForm::action_instruments_clearAll()
{
switch(
QMessageBox::information( this,
"Hydrogen",
trUtf8("Clear all instruments?"),
trUtf8("Ok"),
trUtf8("Cancel"),
0, // Enter == button 0
1 )) { // Escape == button 2
case 0:
// ok btn pressed
break;
case 1:
// cancel btn pressed
return;
}
// Remove all layers
Song *pSong = Hydrogen::get_instance()->getSong();
InstrumentList* pList = pSong->get_instrument_list();
for (uint i = pList->size(); i > 0; i--) {
functionDeleteInstrument(i - 1);
}
EventQueue::get_instance()->push_event( EVENT_SELECTED_INSTRUMENT_CHANGED, -1 );
}
DeviceId
Studio::getSpareDeviceId(InstrumentId &baseInstrumentId)
{
InstrumentId highestMidiInstrumentId = MidiInstrumentBase;
bool foundInstrument = false;
std::set<DeviceId> ids;
DeviceListIterator it;
for (it = m_devices.begin(); it != m_devices.end(); it++) {
ids.insert((*it)->getId());
if ((*it)->getType() == Device::Midi) {
InstrumentList il = (*it)->getAllInstruments();
for (size_t i = 0; i < il.size(); ++i) {
if (il[i]->getId() > highestMidiInstrumentId) {
highestMidiInstrumentId = il[i]->getId();
foundInstrument = true;
}
}
}
}
if (!foundInstrument) {
baseInstrumentId = MidiInstrumentBase;
} else {
baseInstrumentId = ((highestMidiInstrumentId / 128) + 1) * 128;
}
DeviceId id = 0;
while (ids.find(id) != ids.end()) ++id;
return id;
}
void
ModifyDeviceCommand::unexecute()
{
Device *device = m_studio->getDevice(m_device);
if (!device) {
std::cerr << "ERROR: ModifyDeviceCommand::unexecute(): no such device as " << m_device << std::endl;
return;
}
MidiDevice *midiDevice = dynamic_cast<MidiDevice *>(device);
if (!midiDevice) {
std::cerr << "ERROR: ModifyDeviceCommand::unexecute(): device " << m_device << " is not a MIDI device" << std::endl;
return;
}
if (m_rename)
midiDevice->setName(m_oldName);
midiDevice->replaceBankList(m_oldBankList);
midiDevice->replaceProgramList(m_oldProgramList);
midiDevice->replaceControlParameters(m_oldControlList);
midiDevice->replaceKeyMappingList(m_oldKeyMappingList);
midiDevice->setLibrarian(m_oldLibrarianName, m_oldLibrarianEmail);
if (m_changeVariation)
midiDevice->setVariationType(m_oldVariationType);
InstrumentList instruments = midiDevice->getAllInstruments();
for (size_t i = 0; i < instruments.size(); ++i) {
instruments[i]->setProgram(m_oldInstrumentPrograms[i]);
}
// ??? Instead of this kludge, we should be calling a Studio::hasChanged()
// which would then notify all observers (e.g. MIPP) who, in turn,
// would update themselves.
RosegardenMainWindow::self()->uiUpdateKludge();
}
void SampleEditor::openDisplays()
{
H2Core::Instrument *pInstrument = NULL;
Song *pSong = Hydrogen::get_instance()->getSong();
if (pSong != NULL) {
InstrumentList *pInstrList = pSong->get_instrument_list();
int nInstr = Hydrogen::get_instance()->getSelectedInstrumentNumber();
if ( nInstr >= static_cast<int>(pInstrList->size()) ) {
nInstr = -1;
}
if (nInstr == -1) {
pInstrument = NULL;
}
else {
pInstrument = pInstrList->get( nInstr );
//INFOLOG( "new instr: " + pInstrument->m_sName );
}
}
// wavedisplays
m_divider = m_pSampleFromFile->get_frames() / 574.0F;
m_pMainSampleWaveDisplay->updateDisplay( m_samplename );
m_pMainSampleWaveDisplay->move( 1, 1 );
m_pSampleAdjustView->updateDisplay( m_samplename );
m_pSampleAdjustView->move( 1, 1 );
m_pTargetSampleView->move( 1, 1 );
}
void CoreMidiDriver::handleQueueAllNoteOff()
{
if (cmH2Dst == NULL ) {
ERRORLOG( "cmH2Dst = NULL " );
return;
}
InstrumentList *instList = Hydrogen::get_instance()->getSong()->get_instrument_list();
unsigned int numInstruments = instList->size();
for (int index = 0; index < numInstruments; ++index) {
Instrument *curInst = instList->get(index);
int channel = curInst->get_midi_out_channel();
if (channel < 0) {
continue;
}
int key = curInst->get_midi_out_note();
MIDIPacketList packetList;
packetList.numPackets = 1;
packetList.packet->timeStamp = 0;
packetList.packet->length = 3;
packetList.packet->data[0] = 0x80 | channel;
packetList.packet->data[1] = key;
packetList.packet->data[2] = 0;
MIDISend(h2OutputRef, cmH2Dst, &packetList);
}
}
void Mixer::soloClicked(MixerLine* ref)
{
Hydrogen *pEngine = Hydrogen::get_instance();
Song *pSong = pEngine->getSong();
InstrumentList *pInstrList = pSong->get_instrument_list();
int nInstruments = pInstrList->size();
int nLine = findMixerLineByRef(ref);
pEngine->setSelectedInstrumentNumber( nLine );
bool isSoloClicked = ref->isSoloClicked();
if (isSoloClicked) {
for ( int i = 0; i < nInstruments; ++i ) {
m_pMixerLine[i]->setSoloClicked( false );
m_pMixerLine[i]->setMuteClicked( true );
pInstrList->get( i )->set_muted( true );
}
m_pMixerLine[nLine]->setSoloClicked( true );
m_pMixerLine[nLine]->setMuteClicked( false );
pInstrList->get( nLine )->set_muted( false );
}
else {
for ( int i = 0; i < nInstruments; ++i ) {
m_pMixerLine[i]->setMuteClicked( false );
m_pMixerLine[i]->setSoloClicked( false );
pInstrList->get( i )->set_muted( false );
}
}
Hydrogen::get_instance()->setSelectedInstrumentNumber(nLine);
}
void
TrackParameterBox::slotPlaybackDeviceChanged(int index)
{
//RG_DEBUG << "slotPlaybackDeviceChanged(" << index << ")";
// If nothing is selected, bail.
if (index < 0)
return;
// Out of range? Bail.
if (index >= static_cast<int>(m_playbackDeviceIds2.size()))
return;
Track *track = getTrack();
if (!track)
return;
// Switch the Track to the same instrument # on this new Device.
DeviceId deviceId = m_playbackDeviceIds2[index];
Device *device = m_doc->getStudio().getDevice(deviceId);
if (!device)
return;
// Query the Studio to get an Instrument for this Device.
InstrumentList instrumentList = device->getPresentationInstruments();
// Try to preserve the Instrument number (channel) if possible.
int instrumentIndex = m_instrument->currentIndex();
if (instrumentIndex >= static_cast<int>(instrumentList.size()))
instrumentIndex = 0;
// Set the Track's Instrument to the new Instrument.
track->setInstrument(instrumentList[instrumentIndex]->getId());
m_doc->slotDocumentModified();
// Notify observers
// This will trigger a call to updateWidgets2().
// ??? Redundant notification. Track::setInstrument() already does
// this. It shouldn't.
Composition &comp = m_doc->getComposition();
comp.notifyTrackChanged(track);
// ??? The following needs to go away.
RosegardenMainWindow::self()->getView()->getTrackEditor()->
getTrackButtons()->selectInstrument(
track, instrumentList[instrumentIndex]);
}
bool Drumkit::save_samples( const QString& dk_dir, bool overwrite )
{
INFOLOG( QString( "Saving drumkit %1 samples into %2" ).arg( __name ).arg( dk_dir ) );
if( !Filesystem::mkdir( dk_dir ) ) {
return false;
}
InstrumentList* instruments = get_instruments();
for( int i = 0; i < instruments->size(); i++ ) {
Instrument* instrument = ( *instruments )[i];
for (std::vector<InstrumentComponent*>::iterator it = instrument->get_components()->begin() ; it != instrument->get_components()->end(); ++it) {
InstrumentComponent* component = *it;
for( int n = 0; n < MAX_LAYERS; n++ ) {
InstrumentLayer* layer = component->get_layer( n );
if( layer ) {
QString src = layer->get_sample()->get_filepath();
QString dst = dk_dir + "/" + layer->get_sample()->get_filename();
if( src != dst ) {
QString original_dst = dst;
// If the destination path does not have an extension and there is a dot in the path, hell will break loose. QFileInfo maybe?
int insertPosition = original_dst.length();
if( original_dst.lastIndexOf(".") > 0 )
insertPosition = original_dst.lastIndexOf(".");
if(overwrite == false)
{
// If the destination path already exists, try to use basename_1, basename_2, etc. instead of basename.
int tries = 0;
while( Filesystem::file_exists( dst, true )) {
tries++;
dst = original_dst;
dst.insert( insertPosition, QString("_%1").arg(tries) );
}
}
layer->get_sample()->set_filename( dst );
if( !Filesystem::file_copy( src, dst ) ) {
return false;
}
}
}
}
}
}
return true;
}
void Mixer::unmuteAll( int selectedInstrument )
{
Hydrogen *pEngine = Hydrogen::get_instance();
Song *pSong = pEngine->getSong();
InstrumentList *pInstrList = pSong->get_instrument_list();
int nInstruments = pInstrList->size();
for ( int i = 0; i < nInstruments; ++i ) {
m_pMixerLine[i]->setMuteClicked( false );
m_pMixerLine[i]->setSoloClicked( false );
pInstrList->get( i )->set_muted( false );
}
// select first instrument after unmute all
Hydrogen::get_instance()->setSelectedInstrumentNumber(selectedInstrument);
}
void InstrumentEditor::rubberbandbpmchangeEvent()
{
if( !Preferences::get_instance()->getRubberBandBatchMode() /*&& Preferences::get_instance()->__usetimeline */){
//we return also if time-line is activated. this wont work.
// INFOLOG( "Tempo change: Recomputing rubberband samples is disabled" );
return;
}
// INFOLOG( "Tempo change: Recomputing rubberband samples." );
Hydrogen *pEngine = Hydrogen::get_instance();
Song *song = pEngine->getSong();
assert(song);
if(song){
InstrumentList *songInstrList = song->get_instrument_list();
assert(songInstrList);
for ( unsigned nInstr = 0; nInstr < songInstrList->size(); ++nInstr ) {
Instrument *pInstr = songInstrList->get( nInstr );
assert( pInstr );
if ( pInstr ){
for ( int nLayer = 0; nLayer < MAX_LAYERS; nLayer++ ) {
InstrumentLayer *pLayer = pInstr->get_layer( nLayer );
if ( pLayer ) {
Sample *pSample = pLayer->get_sample();
if ( pSample ) {
if( pSample->get_rubberband().use ) {
//INFOLOG( QString("Instrument %1 Layer %2" ).arg(nInstr).arg(nLayer));
Sample *newSample = Sample::load(
pSample->get_filepath(),
pSample->get_loops(),
pSample->get_rubberband(),
*pSample->get_velocity_envelope(),
*pSample->get_pan_envelope()
);
if( !newSample ){
continue;
}
delete pSample;
// insert new sample from newInstrument
AudioEngine::get_instance()->lock( RIGHT_HERE );
pLayer->set_sample( newSample );
AudioEngine::get_instance()->unlock();
}
}
}
}
}
}
}
}
void JackAudioDriver::makeTrackOutputs( Song* pSong )
{
// Only execute the body of this function if a per-track
// creation of the output ports is desired.
if( Preferences::get_instance()->m_bJackTrackOuts == false )
return;
InstrumentList * pInstruments = pSong->get_instrument_list();
Instrument * pInstr;
int nInstruments = ( int ) pInstruments->size();
// create dedicated channel output ports
WARNINGLOG( QString( "Creating / renaming %1 ports" ).arg( nInstruments ) );
int nTrackCount = 0;
// Resets the `track_map' matrix.
for( int i = 0 ; i < MAX_INSTRUMENTS ; i++ ){
for ( int j = 0 ; j < MAX_COMPONENTS ; j++ ){
track_map[i][j] = 0;
}
}
// Creates a new output track or reassigns an existing one for
// each component of each instrument and stores the result in
// the `track_map'.
for ( int n = 0; n <= nInstruments - 1; n++ ) {
pInstr = pInstruments->get( n );
for (std::vector<InstrumentComponent*>::iterator it = pInstr->get_components()->begin() ; it != pInstr->get_components()->end(); ++it) {
InstrumentComponent* pCompo = *it;
setTrackOutput( nTrackCount, pInstr, pCompo, pSong);
track_map[pInstr->get_id()][pCompo->get_drumkit_componentID()] = nTrackCount;
nTrackCount++;
}
}
// clean up unused ports
jack_port_t *p_L, *p_R;
for ( int n = nTrackCount; n < track_port_count; n++ ) {
p_L = track_output_ports_L[n];
p_R = track_output_ports_R[n];
track_output_ports_L[n] = 0;
jack_port_unregister( m_pClient, p_L );
track_output_ports_R[n] = 0;
jack_port_unregister( m_pClient, p_R );
}
track_port_count = nTrackCount;
}
/**
* Make sure the number of track outputs match the instruments in @a song , and name the ports.
*/
void JackOutput::makeTrackOutputs( Song * song )
{
/// Disable Track Outputs
if( Preferences::get_instance()->m_bJackTrackOuts == false )
return;
///
InstrumentList * instruments = song->get_instrument_list();
Instrument * instr;
int nInstruments = ( int )instruments->size();
// create dedicated channel output ports
WARNINGLOG( QString( "Creating / renaming %1 ports" ).arg( nInstruments ) );
int p_trackCount = 0;
for( int i = 0 ; i < MAX_INSTRUMENTS ; i++ ){
for ( int j = 0 ; j < MAX_COMPONENTS ; j++ ){
track_map[i][j] = 0;
}
}
for ( int n = nInstruments - 1; n >= 0; n-- ) {
instr = instruments->get( n );
for (std::vector<InstrumentComponent*>::iterator it = instr->get_components()->begin() ; it != instr->get_components()->end(); ++it) {
InstrumentComponent* pCompo = *it;
setTrackOutput( p_trackCount, instr , pCompo, song);
track_map[instr->get_id()][pCompo->get_drumkit_componentID()] = p_trackCount;
p_trackCount++;
}
}
// clean up unused ports
jack_port_t *p_L, *p_R;
for ( int n = p_trackCount; n < track_port_count; n++ ) {
p_L = track_output_ports_L[n];
p_R = track_output_ports_R[n];
track_output_ports_L[n] = 0;
jack_port_unregister( client, p_L );
track_output_ports_R[n] = 0;
jack_port_unregister( client, p_R );
}
track_port_count = p_trackCount;
}
void SampleEditor::createNewLayer()
{
if ( !m_pSampleEditorStatus ){
Sample *editSample = Sample::load( m_samplename, __loops, __rubberband, *m_pTargetSampleView->get_velocity(), *m_pTargetSampleView->get_pan() );
if( editSample == NULL ){
return;
}
AudioEngine::get_instance()->lock( RIGHT_HERE );
H2Core::Instrument *pInstrument = NULL;
Song *pSong = Hydrogen::get_instance()->getSong();
if (pSong != NULL) {
InstrumentList *pInstrList = pSong->get_instrument_list();
int nInstr = Hydrogen::get_instance()->getSelectedInstrumentNumber();
if ( nInstr >= static_cast<int>(pInstrList->size()) ) {
nInstr = -1;
}
if (nInstr == -1) {
pInstrument = NULL;
}
else {
pInstrument = pInstrList->get( nInstr );
}
}
H2Core::InstrumentLayer *pLayer = pInstrument->get_layer( m_pSelectedLayer );
Sample *oldSample = pLayer->get_sample();
delete oldSample;
// insert new sample from newInstrument
pLayer->set_sample( editSample );
AudioEngine::get_instance()->unlock();
m_pTargetSampleView->updateDisplay( pLayer );
}
}
void Mixer::soloClicked(MixerLine* ref)
{
Hydrogen *pEngine = Hydrogen::get_instance();
CoreActionController* pController = pEngine->getCoreActionController();
Song *pSong = pEngine->getSong();
InstrumentList *pInstrList = pSong->get_instrument_list();
int nInstruments = pInstrList->size();
int nLine = findMixerLineByRef(ref);
pController->setStripIsSoloed( nLine, ref->isSoloClicked() );
for ( int i = 0; i < nInstruments; ++i ) {
m_pMixerLine[i]->setSoloClicked( pInstrList->get(i)->is_soloed() );
m_pMixerLine[i]->setMuteClicked( pInstrList->get(i)->is_muted() );
}
Hydrogen::get_instance()->setSelectedInstrumentNumber(nLine);
}
void JackMidiDriver::handleQueueAllNoteOff()
{
InstrumentList *instList = Hydrogen::get_instance()->getSong()->get_instrument_list();
Instrument *curInst;
unsigned int numInstruments = instList->size();
unsigned int i;
int channel;
int key;
for (i = 0; i < numInstruments; i++) {
curInst = instList->get(i);
channel = curInst->get_midi_out_channel();
if (channel < 0 || channel > 15)
continue;
key = curInst->get_midi_out_note();
if (key < 0 || key > 127)
continue;
handleQueueNoteOff(channel, key, 0);
}
}
void MainForm::action_instruments_clearAll()
{
switch(
QMessageBox::information( this,
"Hydrogen",
trUtf8("Clear all instruments?"),
trUtf8("Ok"),
trUtf8("Cancel"),
0, // Enter == button 0
1 )) { // Escape == button 2
case 0:
// ok btn pressed
break;
case 1:
// cancel btn pressed
return;
}
// Remove all layers
// AudioEngine::get_instance()->lock( RIGHT_HERE );
Song *pSong = Hydrogen::get_instance()->getSong();
InstrumentList* pList = pSong->get_instrument_list();
for (uint i = pList->size(); i > 0; i--) {
functionDeleteInstrument(i - 1);
/*
Instrument* pInstr = pList->get( i );
pInstr->set_name( (QString( trUtf8( "Instrument %1" ) ).arg( i + 1 )) );
// remove all layers
for ( int nLayer = 0; nLayer < MAX_LAYERS; nLayer++ ) {
InstrumentLayer* pLayer = pInstr->get_layer( nLayer );
delete pLayer;
pInstr->set_layer( NULL, nLayer );
}
*/
}
// AudioEngine::get_instance()->unlock();
EventQueue::get_instance()->push_event( EVENT_SELECTED_INSTRUMENT_CHANGED, -1 );
}
void LayerPreview::selectedInstrumentChangedEvent()
{
AudioEngine::get_instance()->lock( RIGHT_HERE );
Song *pSong = Hydrogen::get_instance()->getSong();
if (pSong != NULL) {
InstrumentList *pInstrList = pSong->get_instrument_list();
int nInstr = Hydrogen::get_instance()->getSelectedInstrumentNumber();
if ( nInstr >= (int)pInstrList->size() ) {
nInstr = -1;
}
if (nInstr == -1) {
m_pInstrument = NULL;
}
else {
m_pInstrument = pInstrList->get( nInstr );
}
}
else {
m_pInstrument = NULL;
}
AudioEngine::get_instance()->unlock();
// select the last valid layer
if ( m_pInstrument ) {
for (int i = MAX_LAYERS - 1; i >= 0; i-- ) {
if ( m_pInstrument->get_layer( i ) ) {
m_nSelectedLayer = i;
break;
}
}
}
else {
m_nSelectedLayer = 0;
}
update();
}
void PatternEditorPanel::moveDownBtnClicked(Button *)
{
Hydrogen *engine = Hydrogen::get_instance();
int nSelectedInstrument = engine->getSelectedInstrumentNumber();
AudioEngine::get_instance()->lock( RIGHT_HERE );
Song *pSong = engine->getSong();
InstrumentList *pInstrumentList = pSong->get_instrument_list();
if ( ( nSelectedInstrument + 1 ) < (int)pInstrumentList->size() ) {
pInstrumentList->swap( nSelectedInstrument, nSelectedInstrument + 1 );
AudioEngine::get_instance()->unlock();
engine->setSelectedInstrumentNumber( nSelectedInstrument + 1 );
pSong->set_is_modified( true );
}
else {
AudioEngine::get_instance()->unlock();
}
}
void
TrackParameterBox::updateInstrument(const Instrument *instrument)
{
// As with the Device field above, this will rarely change and it is
// expensive to clear and reload. So, we should cache enough info to
// detect a real change. This would be Instrument names and IDs.
const DeviceId deviceId = instrument->getDevice()->getId();
const Device &device = *(m_doc->getStudio().getDevice(deviceId));
const InstrumentList instrumentList = device.getPresentationInstruments();
// Generate local instrument name and ID lists to compare against the
// members.
std::vector<InstrumentId> instrumentIds;
std::vector<QString> instrumentNames;
// For each instrument
for (size_t instrumentIndex = 0;
instrumentIndex < instrumentList.size();
++instrumentIndex) {
const Instrument &loopInstrument = *(instrumentList[instrumentIndex]);
instrumentIds.push_back(loopInstrument.getId());
QString instrumentName(QObject::tr(loopInstrument.getName().c_str()));
QString programName(
QObject::tr(loopInstrument.getProgramName().c_str()));
if (loopInstrument.getType() == Instrument::SoftSynth) {
instrumentName.replace(QObject::tr("Synth plugin"), "");
programName = "";
AudioPluginInstance *plugin =
instrument->getPlugin(Instrument::SYNTH_PLUGIN_POSITION);
if (plugin)
programName = strtoqstr(plugin->getDisplayName());
}
if (programName != "")
instrumentName += " (" + programName + ")";
// cut off the redundant eg. "General MIDI Device" that appears in the
// combo right above here anyway
instrumentName = instrumentName.mid(
instrumentName.indexOf("#"), instrumentName.length());
instrumentNames.push_back(instrumentName);
}
// If there has been an actual change
if (instrumentIds != m_instrumentIds2 ||
instrumentNames != m_instrumentNames2) {
// Update the cache.
m_instrumentIds2 = instrumentIds;
m_instrumentNames2 = instrumentNames;
// Reload the combobox
m_instrument->clear();
// For each instrument, add the name to the combobox.
// ??? If we used a QStringList, we could just call addItems().
for (size_t instrumentIndex = 0;
instrumentIndex < m_instrumentNames2.size();
++instrumentIndex) {
m_instrument->addItem(m_instrumentNames2[instrumentIndex]);
}
}
// Find the current instrument in the instrument ID list.
const InstrumentId instrumentId = instrument->getId();
// Assume not found.
int currentIndex = -1;
// For each Instrument
for (size_t instrumentIndex = 0;
instrumentIndex < m_instrumentIds2.size();
++instrumentIndex) {
// If this is the selected Instrument
if (m_instrumentIds2[instrumentIndex] == instrumentId) {
currentIndex = instrumentIndex;
break;
}
}
// Set the index.
m_instrument->setCurrentIndex(currentIndex);
}
void
ModifyDeviceMappingCommand::execute()
{
Composition::trackcontainer &tracks =
m_composition->getTracks();
Composition::trackcontainer::iterator it = tracks.begin();
Instrument *instr = 0;
int index = 0;
for (; it != tracks.end(); ++it) {
instr = m_studio->getInstrumentById(it->second->getInstrument());
if (!instr || !instr->getDevice())
continue;
if (instr->getDevice()->getId() == m_fromDevice) {
// if source and target are MIDI
if (m_studio->getDevice(m_fromDevice)->getType() ==
Device::Midi &&
m_studio->getDevice(m_toDevice)->getType() ==
Device::Midi) {
// Try to match channels on the target device
//
MidiByte channel = instr->getNaturalChannel();
InstrumentList destList = m_studio->
getDevice(m_toDevice)->getPresentationInstruments();
InstrumentList::iterator dIt = destList.begin();
for (; dIt != destList.end(); ++dIt) {
if ((*dIt)->getNaturalChannel() == channel) {
break;
}
}
// Failure to match anything and there's no Instruments
// at all in the destination. Skip to next source Instrument.
//
if (dIt == destList.end() || destList.size() == 0)
continue;
RG_DEBUG << " Track " << it->first
<< ", setting Instrument to "
<< (*dIt)->getId() << endl;
// store "to" and "from" values
//
m_mapping.push_back(
std::pair < TrackId,
InstrumentId >
(it->first,
instr->getId()));
it->second->setInstrument((*dIt)->getId());
} else // audio is involved in the mapping - use indexes
{
// assign by index numbers
InstrumentList destList = m_studio->
getDevice(m_toDevice)->getPresentationInstruments();
// skip if we can't match
//
if (index > (int)(destList.size() - 1))
continue;
m_mapping.push_back(
std::pair < TrackId,
InstrumentId >
(it->first,
instr->getId()));
it->second->setInstrument(destList[index]->getId());
}
index++;
}
}
}
void SoundLibraryPanel::updateDrumkitList()
{
QString currentSL = Hydrogen::get_instance()->getCurrentDrumkitname();
LocalFileMng mng;
__sound_library_tree->clear();
__system_drumkits_item = new QTreeWidgetItem( __sound_library_tree );
__system_drumkits_item->setText( 0, trUtf8( "System drumkits" ) );
__sound_library_tree->setItemExpanded( __system_drumkits_item, true );
__user_drumkits_item = new QTreeWidgetItem( __sound_library_tree );
__user_drumkits_item->setText( 0, trUtf8( "User drumkits" ) );
__sound_library_tree->setItemExpanded( __user_drumkits_item, true );
for (uint i = 0; i < __system_drumkit_info_list.size(); ++i ) {
delete __system_drumkit_info_list[i];
}
__system_drumkit_info_list.clear();
for (uint i = 0; i < __user_drumkit_info_list.size(); ++i ) {
delete __user_drumkit_info_list[i];
}
__user_drumkit_info_list.clear();
//User drumkit list
QStringList usr_dks = Filesystem::usr_drumkits_list();
for (int i = 0; i < usr_dks.size(); ++i) {
QString absPath = Filesystem::usr_drumkits_dir() + "/" + usr_dks[i];
Drumkit *pInfo = Drumkit::load( absPath );
if (pInfo) {
__user_drumkit_info_list.push_back( pInfo );
QTreeWidgetItem* pDrumkitItem = new QTreeWidgetItem( __user_drumkits_item );
pDrumkitItem->setText( 0, pInfo->get_name() );
if ( QString(pInfo->get_name() ) == currentSL ){
pDrumkitItem->setBackgroundColor( 0, QColor( 50, 50, 50) );
}
InstrumentList *pInstrList = pInfo->get_instruments();
for ( uint nInstr = 0; nInstr < pInstrList->size(); ++nInstr ) {
Instrument *pInstr = pInstrList->get( nInstr );
QTreeWidgetItem* pInstrumentItem = new QTreeWidgetItem( pDrumkitItem );
pInstrumentItem->setText( 0, QString( "[%1] " ).arg( nInstr + 1 ) + pInstr->get_name() );
pInstrumentItem->setToolTip( 0, pInstr->get_name() );
}
}
}
//System drumkit list
QStringList sys_dks = Filesystem::sys_drumkits_list();
for (int i = 0; i < sys_dks.size(); ++i) {
QString absPath = Filesystem::sys_drumkits_dir() + "/" + sys_dks[i];
Drumkit *pInfo = Drumkit::load( absPath );
if (pInfo) {
__system_drumkit_info_list.push_back( pInfo );
QTreeWidgetItem* pDrumkitItem = new QTreeWidgetItem( __system_drumkits_item );
pDrumkitItem->setText( 0, pInfo->get_name() );
if ( QString( pInfo->get_name() ) == currentSL ){
pDrumkitItem->setBackgroundColor( 0, QColor( 50, 50, 50) );
}
InstrumentList *pInstrList = pInfo->get_instruments();
for ( uint nInstr = 0; nInstr < pInstrList->size(); ++nInstr ) {
Instrument *pInstr = pInstrList->get( nInstr );
QTreeWidgetItem* pInstrumentItem = new QTreeWidgetItem( pDrumkitItem );
pInstrumentItem->setText( 0, QString( "[%1] " ).arg( nInstr + 1 ) + pInstr->get_name() );
pInstrumentItem->setToolTip( 0, pInstr->get_name() );
}
}
}
//Songlist
QStringList songs = Filesystem::songs_list();
if ( songs.size() > 0 ) {
__song_item = new QTreeWidgetItem( __sound_library_tree );
__song_item->setText( 0, trUtf8( "Songs" ) );
__song_item->setToolTip( 0, "double click to expand the list" );
__sound_library_tree->setItemExpanded( __song_item, __expand_songs_list );
for (uint i = 0; i < songs.size(); i++) {
QTreeWidgetItem* pSongItem = new QTreeWidgetItem( __song_item );
QString song = songs[i];
pSongItem->setText( 0 , song.left( song.indexOf(".")) );
pSongItem->setToolTip( 0, song );
}
}
//Pattern list
std::vector<QString> patternDirList = mng.getPatternDirList();
if ( patternDirList.size() > 0 ) {
__pattern_item = new QTreeWidgetItem( __sound_library_tree );
__pattern_item->setText( 0, trUtf8( "Patterns" ) );
__pattern_item->setToolTip( 0, "double click to expand the list" );
__sound_library_tree->setItemExpanded( __pattern_item, __expand_pattern_list );
//this is to push the mng.getPatternList in all patterns/drumkit dirs
for (uint i = 0; i < patternDirList.size(); ++i) {
QString absPath = patternDirList[i];
mng.getPatternList( absPath );
}
//this is the second step to push the mng.funktion
//SoundLibraryDatabase::create_instance();
SoundLibraryDatabase* db = SoundLibraryDatabase::get_instance();
soundLibraryInfoVector* allPatternDirList = db->getAllPatterns();
QStringList allCategoryNameList = db->getAllPatternCategories();
//now sorting via category
for (uint i = 0; i < allCategoryNameList.size(); ++i) {
QString categoryName = allCategoryNameList[i];
QTreeWidgetItem* pCategoryItem = new QTreeWidgetItem( __pattern_item );
pCategoryItem->setText( 0, categoryName );
soundLibraryInfoVector::iterator mapIterator;
for( mapIterator=allPatternDirList->begin(); mapIterator != allPatternDirList->end(); mapIterator++ )
{
QString patternCategory = (*mapIterator)->getCategory();
if ( patternCategory == categoryName || patternCategory.isEmpty() && categoryName == "No category" ){
QTreeWidgetItem* pPatternItem = new QTreeWidgetItem( pCategoryItem );
pPatternItem->setText( 0, (*mapIterator)->getName());
pPatternItem->setText( 1, (*mapIterator)->getPath() );
pPatternItem->setToolTip( 0, mng.getDrumkitNameForPattern( (*mapIterator)->getPath() ));
INFOLOG( "Path" + (*mapIterator)->getPath() );
}
}
}
}
}
void
MidiMixerWindow::setupTabs()
{
DeviceListConstIterator it;
MidiDevice *dev = 0;
InstrumentList instruments;
InstrumentList::const_iterator iIt;
int faderCount = 0, deviceCount = 1;
if (m_tabFrame)
delete m_tabFrame;
// Setup m_tabFrame
//
QWidget *blackWidget = new QWidget(this);
setCentralWidget(blackWidget);
QVBoxLayout *centralLayout = new QVBoxLayout;
blackWidget->setLayout(centralLayout);
m_tabWidget = new QTabWidget;
centralLayout->addWidget(m_tabWidget);
connect(m_tabWidget, SIGNAL(currentChanged(QWidget *)),
this, SLOT(slotCurrentTabChanged(QWidget *)));
m_tabWidget->setTabPosition(QTabWidget::South);
setWindowTitle(tr("MIDI Mixer"));
setWindowIcon(IconLoader().loadPixmap("window-midimixer"));
for (it = m_studio->begin(); it != m_studio->end(); ++it) {
dev = dynamic_cast<MidiDevice*>(*it);
if (dev) {
// Get the control parameters that are on the IPB (and hence can
// be shown here too).
//
ControlList controls = getIPBForMidiMixer(dev);
instruments = dev->getPresentationInstruments();
// Don't add a frame for empty devices
//
if (!instruments.size())
continue;
m_tabFrame = new QFrame(m_tabWidget);
m_tabFrame->setContentsMargins(10, 10, 10, 10);
// m_tabFrame->setContentsMargins(5, 5, 5, 5); ???
QGridLayout *mainLayout = new QGridLayout(m_tabFrame);
// MIDI Mixer label
QLabel *label = new QLabel("", m_tabFrame);
mainLayout->addWidget(label, 0, 0, 0, 16, Qt::AlignCenter);
// control labels
for (size_t i = 0; i < controls.size(); ++i) {
label = new QLabel(QObject::tr(controls[i].getName().c_str()), m_tabFrame);
mainLayout->addWidget(label, i + 1, 0, Qt::AlignCenter);
}
// meter label
// (obsolete abandoned code deleted here)
// volume label
label = new QLabel(tr("Volume"), m_tabFrame);
mainLayout->addWidget(label, controls.size() + 2, 0,
Qt::AlignCenter);
// instrument label
label = new QLabel(tr("Instrument"), m_tabFrame);
label->setFixedWidth(80); //!!! this should come from metrics
mainLayout->addWidget(label, controls.size() + 3, 0,
Qt::AlignLeft);
int posCount = 1;
int firstInstrument = -1;
for (iIt = instruments.begin(); iIt != instruments.end(); ++iIt) {
// Add new fader struct
//
m_faders.push_back(new FaderStruct());
// Store the first ID
//
if (firstInstrument == -1)
firstInstrument = (*iIt)->getId();
// Add the controls
//
for (size_t i = 0; i < controls.size(); ++i) {
QColor knobColour = QColor(Qt::white);
if (controls[i].getColourIndex() > 0) {
Colour c =
m_document->getComposition().getGeneralColourMap().
getColourByIndex(controls[i].getColourIndex());
knobColour = QColor(c.getRed(),
c.getGreen(), c.getBlue());
}
Rotary *controller =
new Rotary(m_tabFrame,
controls[i].getMin(),
controls[i].getMax(),
1.0,
5.0,
controls[i].getDefault(),
20,
Rotary::NoTicks,
false,
controls[i].getDefault() == 64); //!!! hacky
controller->setKnobColour(knobColour);
connect(controller, SIGNAL(valueChanged(float)),
this, SLOT(slotControllerChanged(float)));
mainLayout->addWidget(controller, i + 1, posCount,
Qt::AlignCenter);
// Store the rotary
//
m_faders[faderCount]->m_controllerRotaries.push_back(
std::pair<MidiByte, Rotary*>
(controls[i].getControllerValue(), controller));
}
// VU meter
//
MidiMixerVUMeter *meter =
new MidiMixerVUMeter(m_tabFrame,
VUMeter::FixedHeightVisiblePeakHold, 6, 30);
mainLayout->addWidget(meter, controls.size() + 1,
posCount, Qt::AlignCenter);
m_faders[faderCount]->m_vuMeter = meter;
// Volume fader
//
Fader *fader =
new Fader(0, 127, 100, 20, 80, m_tabFrame);
mainLayout->addWidget(fader, controls.size() + 2,
posCount, Qt::AlignCenter);
m_faders[faderCount]->m_volumeFader = fader;
// Label
//
QLabel *idLabel = new QLabel(QString("%1").
arg((*iIt)->getId() - firstInstrument + 1),
m_tabFrame);
idLabel->setObjectName("idLabel");
mainLayout->addWidget(idLabel, controls.size() + 3,
posCount, Qt::AlignCenter);
// store id in struct
m_faders[faderCount]->m_id = (*iIt)->getId();
// Connect them up
//
connect(fader, SIGNAL(faderChanged(float)),
this, SLOT(slotFaderLevelChanged(float)));
// Update all the faders and controllers
//
slotUpdateInstrument((*iIt)->getId());
// Increment counters
//
posCount++;
faderCount++;
}
QString name = QString("%1 (%2)")
.arg(QObject::tr(dev->getName().c_str()))
.arg(deviceCount++);
addTab(m_tabFrame, name);
}
}
}
void
MidiMixerWindow::sendControllerRefresh()
{
//!!! need to know if we have a current external controller device,
// as this is expensive
int tabIndex = m_tabWidget->currentIndex();
RG_DEBUG << "MidiMixerWindow::slotCurrentTabChanged: current is " << tabIndex << endl;
if (tabIndex < 0)
return ;
int i = 0;
for (DeviceList::const_iterator dit = m_studio->begin();
dit != m_studio->end(); ++dit) {
MidiDevice *dev = dynamic_cast<MidiDevice*>(*dit);
RG_DEBUG << "device is " << (*dit)->getId() << ", dev " << dev << endl;
if (!dev)
continue;
if (i != tabIndex) {
++i;
continue;
}
InstrumentList instruments = dev->getPresentationInstruments();
ControlList controls = getIPBForMidiMixer(dev);
RG_DEBUG << "device has " << instruments.size() << " presentation instruments, " << dev->getAllInstruments().size() << " instruments " << endl;
for (InstrumentList::const_iterator iIt =
instruments.begin(); iIt != instruments.end(); ++iIt) {
Instrument *instrument = *iIt;
if (!instrument->hasFixedChannel()) { continue; }
int channel = instrument->getNaturalChannel();
RG_DEBUG << "instrument is " << instrument->getId() << endl;
for (ControlList::const_iterator cIt =
controls.begin(); cIt != controls.end(); ++cIt) {
int controller = (*cIt).getControllerValue();
int value;
try {
value = instrument->getControllerValue(controller);
} catch (std::string s) {
std::cerr << "Exception in MidiMixerWindow::currentChanged: " << s << " (controller " << controller << ", instrument " << instrument->getId() << ")" << std::endl;
value = 0;
}
MappedEvent mE(instrument->getId(),
MappedEvent::MidiController,
controller, value);
mE.setRecordedChannel(channel);
mE.setRecordedDevice(Device::CONTROL_DEVICE);
StudioControl::sendMappedEvent(mE);
}
MappedEvent mE(instrument->getId(),
MappedEvent::MidiController,
MIDI_CONTROLLER_VOLUME,
instrument->getVolume());
mE.setRecordedChannel(channel);
mE.setRecordedDevice(Device::CONTROL_DEVICE);
RG_DEBUG << "sending controller mapped event for channel " << channel << ", volume " << instrument->getVolume() << endl;
StudioControl::sendMappedEvent(mE);
}
break;
}
}
void
ModifyDeviceCommand::execute()
{
Device *device = m_studio->getDevice(m_device);
if (!device) {
std::cerr << "ERROR: ModifyDeviceCommand::execute(): no such device as " << m_device << std::endl;
return;
}
MidiDevice *midiDevice = dynamic_cast<MidiDevice *>(device);
if (!midiDevice) {
std::cerr << "ERROR: ModifyDeviceCommand::execute(): device " << m_device << " is not a MIDI device" << std::endl;
return;
}
// Save Original Values for Undo
// ??? Really wish we could just m_oldDevice = *(midiDevice). See below.
m_oldName = midiDevice->getName();
m_oldBankList = midiDevice->getBanks();
m_oldProgramList = midiDevice->getPrograms();
m_oldControlList = midiDevice->getControlParameters();
m_oldKeyMappingList = midiDevice->getKeyMappings();
m_oldLibrarianName = midiDevice->getLibrarianName();
m_oldLibrarianEmail = midiDevice->getLibrarianEmail();
m_oldVariationType = midiDevice->getVariationType();
InstrumentList instruments = midiDevice->getAllInstruments();
for (size_t i = 0; i < instruments.size(); ++i) {
// ??? Preserving just the programs isn't enough. We need
// to preserve the rest of the Instrument as well. However,
// the auto/fixed channel feature has made it impossible
// to safely make copies of Instrument objects. Also, Instrument
// has an ID. How should that be handled for undo? ISTM
// that we either need to introduce some sort of copyForUndo()
// hack to each object, or develop a set of standards for coding
// objects that are undo-safe. Sounds like a pretty big project.
m_oldInstrumentPrograms.push_back(instruments[i]->getProgram());
}
// Make the Changes
if (m_changeVariation)
midiDevice->setVariationType(m_variationType);
if (m_overwrite) {
if (m_clearBankAndProgramList) {
midiDevice->clearBankList();
midiDevice->clearProgramList();
midiDevice->clearKeyMappingList();
} else {
if (m_changeBanks)
midiDevice->replaceBankList(m_bankList);
if (m_changePrograms)
midiDevice->replaceProgramList(m_programList);
if (m_changeBanks || m_changePrograms) {
// Make sure the instruments make sense.
for (size_t i = 0; i < instruments.size(); ++i) {
instruments[i]->pickFirstProgram(
midiDevice->isPercussionNumber(i));
}
}
}
if (m_changeKeyMappings) {
midiDevice->replaceKeyMappingList(m_keyMappingList);
}
if (m_rename)
midiDevice->setName(m_name);
midiDevice->setLibrarian(m_librarianName, m_librarianEmail);
} else {
if (m_clearBankAndProgramList) {
midiDevice->clearBankList();
midiDevice->clearProgramList();
} else {
if (m_changeBanks)
midiDevice->mergeBankList(m_bankList);
if (m_changePrograms)
midiDevice->mergeProgramList(m_programList);
}
if (m_changeKeyMappings) {
midiDevice->mergeKeyMappingList(m_keyMappingList);
}
if (m_rename) {
std::string mergeName = midiDevice->getName() +
std::string("/") + m_name;
midiDevice->setName(mergeName);
}
}
//!!! merge option?
if (m_changeControls) {
midiDevice->replaceControlParameters(m_controlList);
}
// ??? Instead of this kludge, we should be calling a Studio::hasChanged()
// which would then notify all observers (e.g. MIPP) who, in turn,
// would update themselves.
RosegardenMainWindow::self()->uiUpdateKludge();
}
void SampleEditor::getAllFrameInfos()
{
H2Core::Instrument *pInstrument = NULL;
Sample* pSample = NULL;
Song *pSong = Hydrogen::get_instance()->getSong();
if (pSong != NULL) {
InstrumentList *pInstrList = pSong->get_instrument_list();
int nInstr = Hydrogen::get_instance()->getSelectedInstrumentNumber();
if ( nInstr >= static_cast<int>(pInstrList->size()) ) {
nInstr = -1;
}
if (nInstr == -1) {
pInstrument = NULL;
}
else {
pInstrument = pInstrList->get( nInstr );
//INFOLOG( "new instr: " + pInstrument->m_sName );
}
}
H2Core::InstrumentLayer *pLayer = pInstrument->get_layer( m_pSelectedLayer );
if ( pLayer ) {
pSample = pLayer->get_sample();
}
//this values are needed if we restore a sample from from disk if a new song with sample changes will load
m_sample_is_modified = pSample->get_is_modified();
m_pSamplerate = pSample->get_sample_rate();
__loops = pSample->get_loops();
__rubberband = pSample->get_rubberband();
if ( pSample->get_velocity_envelope()->size()==0 ) {
m_pTargetSampleView->get_velocity()->clear();
m_pTargetSampleView->get_velocity()->push_back( Sample::EnvelopePoint( 0, 0 ) );
m_pTargetSampleView->get_velocity()->push_back( Sample::EnvelopePoint( m_pTargetSampleView->width(), 0 ) );
} else {
*m_pTargetSampleView->get_velocity() = *pSample->get_velocity_envelope();
}
if ( pSample->get_pan_envelope()->size()==0 ) {
m_pTargetSampleView->get_pan()->clear();
m_pTargetSampleView->get_pan()->push_back( Sample::EnvelopePoint( 0, m_pTargetSampleView->height()/2 ) );
m_pTargetSampleView->get_pan()->push_back( Sample::EnvelopePoint( m_pTargetSampleView->width(), m_pTargetSampleView->height()/2 ) );
} else {
*m_pTargetSampleView->get_pan() = *pSample->get_pan_envelope();
}
if (m_sample_is_modified) {
__loops.end_frame = pSample->get_loops().end_frame;
if ( __loops.mode == Sample::Loops::FORWARD )
ProcessingTypeComboBox->setCurrentIndex ( 0 );
if ( __loops.mode == Sample::Loops::REVERSE )
ProcessingTypeComboBox->setCurrentIndex ( 1 );
if ( __loops.mode == Sample::Loops::PINGPONG )
ProcessingTypeComboBox->setCurrentIndex ( 2 );
StartFrameSpinBox->setValue( __loops.start_frame );
LoopFrameSpinBox->setValue( __loops.loop_frame );
EndFrameSpinBox->setValue( __loops.end_frame );
LoopCountSpinBox->setValue( __loops.count );
m_pMainSampleWaveDisplay->m_pStartFramePosition = __loops.start_frame / m_divider + 25 ;
m_pMainSampleWaveDisplay->updateDisplayPointer();
m_pMainSampleWaveDisplay->m_pLoopFramePosition = __loops.loop_frame / m_divider + 25 ;
m_pMainSampleWaveDisplay->updateDisplayPointer();
m_pMainSampleWaveDisplay->m_pEndFramePosition = __loops.end_frame / m_divider + 25 ;
m_pMainSampleWaveDisplay->updateDisplayPointer();
if( !__rubberband.use )rubberComboBox->setCurrentIndex( 0 );
rubberbandCsettingscomboBox->setCurrentIndex( __rubberband.c_settings );
if( !__rubberband.use )rubberbandCsettingscomboBox->setCurrentIndex( 4 );
pitchdoubleSpinBox->setValue( __rubberband.pitch );
if( !__rubberband.use ) pitchdoubleSpinBox->setValue( 0.0 );
if( __rubberband.divider == 1.0/64.0) rubberComboBox->setCurrentIndex( 1 );
else if( __rubberband.divider == 1.0/32.0) rubberComboBox->setCurrentIndex( 2 );
else if( __rubberband.divider == 1.0/16.0) rubberComboBox->setCurrentIndex( 3 );
else if( __rubberband.divider == 1.0/8.0) rubberComboBox->setCurrentIndex( 4 );
else if( __rubberband.divider == 1.0/4.0) rubberComboBox->setCurrentIndex( 5 );
else if( __rubberband.divider == 1.0/2.0) rubberComboBox->setCurrentIndex( 6 );
else if( __rubberband.use && ( __rubberband.divider >= 1.0 ) ) rubberComboBox->setCurrentIndex( (int)(__rubberband.divider + 6) );
setSamplelengthFrames();
checkRatioSettings();
}
m_pTargetSampleView->updateDisplay( pLayer );
connect( StartFrameSpinBox, SIGNAL( valueChanged( int ) ), this, SLOT( valueChangedStartFrameSpinBox(int) ) );
connect( LoopFrameSpinBox, SIGNAL( valueChanged( int ) ), this, SLOT( valueChangedLoopFrameSpinBox(int) ) );
connect( EndFrameSpinBox, SIGNAL( valueChanged( int ) ), this, SLOT( valueChangedEndFrameSpinBox(int) ) );
connect( LoopCountSpinBox, SIGNAL( valueChanged( int ) ), this, SLOT( valueChangedLoopCountSpinBox( int ) ) );
connect( ProcessingTypeComboBox, SIGNAL( currentIndexChanged ( const QString ) ), this, SLOT( valueChangedProcessingTypeComboBox( const QString ) ) );
connect( rubberComboBox, SIGNAL( currentIndexChanged ( const QString ) ), this, SLOT( valueChangedrubberComboBox( const QString ) ) );
connect( rubberbandCsettingscomboBox, SIGNAL( currentIndexChanged ( const QString ) ), this, SLOT( valueChangedrubberbandCsettingscomboBox( const QString ) ) );
connect( pitchdoubleSpinBox, SIGNAL ( valueChanged( double ) ), this, SLOT( valueChangedpitchdoubleSpinBox( double ) ) );
}
void InstrumentEditor::compoChangeAddDelete(QAction* pAction)
{
QString sSelectedAction = pAction->text();
Hydrogen * pEngine = Hydrogen::get_instance();
if( sSelectedAction.compare("add") == 0 ) {
if ( m_pInstrument ) {
bool bIsOkPressed;
QString sNewName = QInputDialog::getText( this, "Hydrogen", trUtf8( "Component name" ), QLineEdit::Normal, "New Component", &bIsOkPressed );
if ( bIsOkPressed ) {
DrumkitComponent* pDrumkitComponent = new DrumkitComponent( findFreeDrumkitComponentId(), sNewName );
pEngine->getSong()->get_components()->push_back( pDrumkitComponent );
//InstrumentComponent* instrument_component = new InstrumentComponent( dm_component->get_id() );
//instrument_component->set_gain( 1.0f );
//m_pInstrument->get_components()->push_back( instrument_component );
m_nSelectedComponent = pDrumkitComponent->get_id();
m_pLayerPreview->set_selected_component( pDrumkitComponent->get_id() );
selectedInstrumentChangedEvent();
// this will force an update...
EventQueue::get_instance()->push_event( EVENT_SELECTED_INSTRUMENT_CHANGED, -1 );
#ifdef H2CORE_HAVE_JACK
pEngine->renameJackPorts(pEngine->getSong());
#endif
}
else {
// user entered nothing or pressed Cancel
}
}
}
else if( sSelectedAction.compare("delete") == 0 ) {
std::vector<DrumkitComponent*>* pDrumkitComponents = pEngine->getSong()->get_components();
if(pDrumkitComponents->size() == 1){
return;
}
DrumkitComponent* pDrumkitComponent = pEngine->getSong()->get_component( m_nSelectedComponent );
InstrumentList* pInstruments = pEngine->getSong()->get_instrument_list();
for ( int n = ( int )pInstruments->size() - 1; n >= 0; n-- ) {
Instrument* pInstrument = pInstruments->get( n );
for( int o = 0 ; o < pInstrument->get_components()->size() ; o++ ) {
InstrumentComponent* pInstrumentComponent = pInstrument->get_components()->at( o );
if( pInstrumentComponent->get_drumkit_componentID() == pDrumkitComponent->get_id() ) {
for( int nLayer = 0; nLayer < MAX_LAYERS; nLayer++ ) {
InstrumentLayer* pLayer = pInstrumentComponent->get_layer( nLayer );
if( pLayer )
delete pLayer;
}
pInstrument->get_components()->erase( pInstrument->get_components()->begin() + o );;
break;
}
}
}
for ( int n = 0 ; n < pDrumkitComponents->size() ; n++ ) {
DrumkitComponent* pTmpDrumkitComponent = pDrumkitComponents->at( n );
if( pTmpDrumkitComponent->get_id() == pDrumkitComponent->get_id() ) {
pDrumkitComponents->erase( pDrumkitComponents->begin() + n );
break;
}
}
m_nSelectedComponent = pDrumkitComponents->front()->get_id();
selectedInstrumentChangedEvent();
// this will force an update...
EventQueue::get_instance()->push_event( EVENT_SELECTED_INSTRUMENT_CHANGED, -1 );
}
else if( sSelectedAction.compare("rename") == 0 ) {
labelCompoClicked( NULL );
}
else {
m_nSelectedComponent = -1;
std::vector<DrumkitComponent*>* pDrumkitComponents = pEngine->getSong()->get_components();
for (std::vector<DrumkitComponent*>::iterator it = pDrumkitComponents->begin() ; it != pDrumkitComponents->end(); ++it) {
DrumkitComponent* pDrumkitComponent = *it;
if( pDrumkitComponent->get_name().compare( sSelectedAction ) == 0) {
m_nSelectedComponent = pDrumkitComponent->get_id();
m_pCompoNameLbl->setText( pDrumkitComponent->get_name() );
break;
}
}
if( m_pInstrument && !m_pInstrument->get_component(m_nSelectedComponent)) {
INFOLOG("Component needs to be added");
InstrumentComponent* pInstrComponent = new InstrumentComponent( m_nSelectedComponent );
pInstrComponent->set_gain( 1.0f );
m_pInstrument->get_components()->push_back( pInstrComponent );
#ifdef H2CORE_HAVE_JACK
pEngine->renameJackPorts(pEngine->getSong());
#endif
}
m_pLayerPreview->set_selected_component(m_nSelectedComponent);
selectedInstrumentChangedEvent();
// this will force an update...
EventQueue::get_instance()->push_event( EVENT_SELECTED_INSTRUMENT_CHANGED, -1 );
}
}
void InstrumentEditor::selectedInstrumentChangedEvent()
{
AudioEngine::get_instance()->lock( RIGHT_HERE );
Song *pSong = Hydrogen::get_instance()->getSong();
if (pSong != NULL) {
InstrumentList *pInstrList = pSong->get_instrument_list();
int nInstr = Hydrogen::get_instance()->getSelectedInstrumentNumber();
if ( nInstr >= (int)pInstrList->size() ) {
nInstr = -1;
}
if (nInstr == -1) {
m_pInstrument = NULL;
}
else {
m_pInstrument = pInstrList->get( nInstr );
//INFOLOG( "new instr: " + m_pInstrument->m_sName );
}
}
else {
m_pInstrument = NULL;
}
AudioEngine::get_instance()->unlock();
// update layer list
if (m_pInstrument) {
m_pNameLbl->setText( m_pInstrument->get_name() );
// ADSR
m_pAttackRotary->setValue( sqrtf(m_pInstrument->get_adsr()->get_attack() / 100000.0) );
m_pDecayRotary->setValue( sqrtf(m_pInstrument->get_adsr()->get_decay() / 100000.0) );
m_pSustainRotary->setValue( m_pInstrument->get_adsr()->get_sustain() );
float fTmp = m_pInstrument->get_adsr()->get_release() - 256.0;
if( fTmp < 0.0 ) {
fTmp = 0.0;
}
m_pReleaseRotary->setValue( sqrtf(fTmp / 100000.0) );
//~ ADSR
// filter
m_pFilterBypassBtn->setPressed( !m_pInstrument->is_filter_active());
m_pCutoffRotary->setValue( m_pInstrument->get_filter_cutoff());
m_pResonanceRotary->setValue( m_pInstrument->get_filter_resonance());
//~ filter
// random pitch
m_pRandomPitchRotary->setValue( m_pInstrument->get_random_pitch_factor());
//Stop Note
m_pIsStopNoteCheckBox->setChecked( m_pInstrument->is_stop_notes() );
// instr gain
char tmp[20];
sprintf( tmp, "%#.2f", m_pInstrument->get_gain());
m_pInstrumentGainLCD->setText( tmp );
m_pInstrumentGain->setValue( m_pInstrument->get_gain()/ 5.0 );
// instr mute group
QString sMuteGroup = QString("%1").arg( m_pInstrument->get_mute_group() );
if (m_pInstrument->get_mute_group() == -1 ) {
sMuteGroup = "Off";
}
m_pMuteGroupLCD->setText( sMuteGroup );
// midi out
QString sMidiOutChannel = QString("%1").arg( m_pInstrument->get_midi_out_channel()+1);
if (m_pInstrument->get_midi_out_channel() == -1 ) {
sMidiOutChannel = "Off";
}
m_pMidiOutChannelLCD->setText( sMidiOutChannel );
// hihat
m_pIsHihat->setChecked( m_pInstrument->is_hihat() );
QString sHiHatMinRange = QString("%1").arg( m_pInstrument->get_lower_cc() );
m_pHihatMinRangeLCD->setText( sHiHatMinRange );
QString sHiHatMaxRange = QString("%1").arg( m_pInstrument->get_higher_cc() );
m_pHihatMaxRangeLCD->setText( sHiHatMaxRange );
//Convert note id into notation
{
int note = m_pInstrument->get_midi_out_note();
int octave = (note / 12) - 2;
const char *noteStrs[12] = { "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B" };
QString sMidiOutNote = QString(noteStrs[note % 12]) + QString::number(octave);
m_pMidiOutNoteLCD->setText( sMidiOutNote );
}
itemsCompo.clear();
std::vector<DrumkitComponent*>* compoList = Hydrogen::get_instance()->getSong()->get_components();
for (std::vector<DrumkitComponent*>::iterator it = compoList->begin() ; it != compoList->end(); ++it) {
DrumkitComponent* p_compo = *it;
if( !itemsCompo.contains( p_compo->get_name() ) )
itemsCompo.append( p_compo->get_name() );
}
itemsCompo.append("--sep--");
itemsCompo.append("add");
itemsCompo.append("delete");
itemsCompo.append("rename");
update();
DrumkitComponent* p_tmpCompo = Hydrogen::get_instance()->getSong()->get_component( m_nSelectedComponent );
assert(p_tmpCompo);
m_pCompoNameLbl->setText( p_tmpCompo->get_name() );
if(m_nSelectedLayer >= 0){
InstrumentComponent* component = m_pInstrument->get_component( m_nSelectedComponent );
if(component) {
char tmp[20];
sprintf( tmp, "%#.2f", component->get_gain());
m_pCompoGainLCD->setText( tmp );
m_pCompoGainRotary->setValue( component->get_gain() / 5.0 );
InstrumentLayer* p_layer = component->get_layer( m_nSelectedLayer );
if(p_layer) {
m_pWaveDisplay->updateDisplay( p_layer );
}
else {
m_pWaveDisplay->updateDisplay( NULL );
}
}
else {
m_pWaveDisplay->updateDisplay( NULL );
}
}
else{
m_pWaveDisplay->updateDisplay( NULL );
}
}
else {
m_pNameLbl->setText( QString( "NULL Instrument..." ) );
m_pWaveDisplay->updateDisplay( NULL );
m_nSelectedLayer = 0;
}
selectLayer( m_nSelectedLayer );
}
void Mixer::updateMixer()
{
Preferences *pPref = Preferences::get_instance();
bool bShowPeaks = pPref->showInstrumentPeaks();
Hydrogen *pEngine = Hydrogen::get_instance();
Song *pSong = pEngine->getSong();
InstrumentList *pInstrList = pSong->get_instrument_list();
std::vector<DrumkitComponent*>* compoList = pSong->get_components();
uint nSelectedInstr = pEngine->getSelectedInstrumentNumber();
float fallOff = pPref->getMixerFalloffSpeed();
uint nMuteClicked = 0;
int nInstruments = pInstrList->size();
int nCompo = compoList->size();
for ( unsigned nInstr = 0; nInstr < MAX_INSTRUMENTS; ++nInstr ) {
if ( nInstr >= nInstruments ) { // unused instrument! let's hide and destroy the mixerline!
if ( m_pMixerLine[ nInstr ] ) {
delete m_pMixerLine[ nInstr ];
m_pMixerLine[ nInstr ] = NULL;
int newWidth = MIXER_STRIP_WIDTH * ( nInstruments + nCompo );
if ( m_pFaderPanel->width() != newWidth ) {
m_pFaderPanel->resize( newWidth, height() );
}
}
continue;
}
else {
if ( m_pMixerLine[ nInstr ] == NULL ) {
// the mixerline doesn't exists..I'll create a new one!
m_pMixerLine[ nInstr ] = createMixerLine( nInstr );
m_pFaderHBox->insertWidget( nInstr, m_pMixerLine[ nInstr ] );
int newWidth = MIXER_STRIP_WIDTH * ( nInstruments + nCompo );
if ( m_pFaderPanel->width() != newWidth ) {
m_pFaderPanel->resize( newWidth, height() );
}
}
MixerLine *pLine = m_pMixerLine[ nInstr ];
Instrument *pInstr = pInstrList->get( nInstr );
assert( pInstr );
float fNewPeak_L = pInstr->get_peak_l();
pInstr->set_peak_l( 0.0f ); // reset instrument peak
float fNewPeak_R = pInstr->get_peak_r();
pInstr->set_peak_r( 0.0f ); // reset instrument peak
float fNewVolume = pInstr->get_volume();
bool bMuted = pInstr->is_muted();
QString sName = pInstr->get_name();
float fPan_L = pInstr->get_pan_l();
float fPan_R = pInstr->get_pan_r();
// fader
float fOldPeak_L = pLine->getPeak_L();
float fOldPeak_R = pLine->getPeak_R();
if (!bShowPeaks) {
fNewPeak_L = 0.0f;
fNewPeak_R = 0.0f;
}
if ( fNewPeak_L >= fOldPeak_L) { // LEFT peak
pLine->setPeak_L( fNewPeak_L );
}
else {
pLine->setPeak_L( fOldPeak_L / fallOff );
}
if ( fNewPeak_R >= fOldPeak_R) { // Right peak
pLine->setPeak_R( fNewPeak_R );
}
else {
pLine->setPeak_R( fOldPeak_R / fallOff );
}
// fader position
pLine->setVolume( fNewVolume );
// mute
if ( bMuted ) {
nMuteClicked++;
}
pLine->setMuteClicked( bMuted );
// instr name
pLine->setName( sName );
// pan
float fPanValue = 0.0;
if (fPan_R == 1.0) {
fPanValue = 1.0 - (fPan_L / 2.0);
}
else {
fPanValue = fPan_R / 2.0;
}
pLine->setPan( fPanValue );
// activity
if ( pLine->getActivity() > 0 ) {
pLine->setActivity( m_pMixerLine[ nInstr ]->getActivity() - 30 );
pLine->setPlayClicked( true );
}
else {
pLine->setPlayClicked( false );
}
for (uint nFX = 0; nFX < MAX_FX; nFX++) {
pLine->setFXLevel( nFX, pInstr->get_fx_level( nFX ) );
}
pLine->setSelected( nInstr == nSelectedInstr );
pLine->updateMixerLine();
}
}
for (std::vector<DrumkitComponent*>::iterator it = compoList->begin() ; it != compoList->end(); ++it) {
DrumkitComponent* p_compo = *it;
if( m_pComponentMixerLine.find(p_compo->get_id()) == m_pComponentMixerLine.end() ) {
// the mixerline doesn't exists..I'll create a new one!
m_pComponentMixerLine[ p_compo->get_id() ] = createComponentMixerLine( p_compo->get_id() );
m_pFaderHBox->addWidget( m_pComponentMixerLine[ p_compo->get_id() ] );
int newWidth = MIXER_STRIP_WIDTH * ( nInstruments + nCompo );
if ( m_pFaderPanel->width() != newWidth ) {
m_pFaderPanel->resize( newWidth, height() );
}
}
ComponentMixerLine *pLine = m_pComponentMixerLine[ p_compo->get_id() ];
float fNewPeak_L = p_compo->get_peak_l();
p_compo->set_peak_l( 0.0f ); // reset instrument peak
float fNewPeak_R = p_compo->get_peak_r();
p_compo->set_peak_r( 0.0f ); // reset instrument peak
float fNewVolume = p_compo->get_volume();
bool bMuted = p_compo->is_muted();
QString sName = p_compo->get_name();
float fOldPeak_L = pLine->getPeak_L();
float fOldPeak_R = pLine->getPeak_R();
if (!bShowPeaks) {
fNewPeak_L = 0.0f;
fNewPeak_R = 0.0f;
}
if ( fNewPeak_L >= fOldPeak_L) { // LEFT peak
pLine->setPeak_L( fNewPeak_L );
}
else {
pLine->setPeak_L( fOldPeak_L / fallOff );
}
if ( fNewPeak_R >= fOldPeak_R) { // Right peak
pLine->setPeak_R( fNewPeak_R );
}
else {
pLine->setPeak_R( fOldPeak_R / fallOff );
}
// fader position
pLine->setVolume( fNewVolume );
// mute
if ( bMuted ) {
nMuteClicked++;
}
pLine->setMuteClicked( bMuted );
// instr name
pLine->setName( sName );
pLine->updateMixerLine();
}
if( compoList->size() < m_pComponentMixerLine.size() ) {
std::vector<int>* p_ids_to_delete = new std::vector<int>();
for (std::map<int, ComponentMixerLine*>::iterator it=m_pComponentMixerLine.begin(); it!=m_pComponentMixerLine.end(); ++it) {
bool p_foundExistingRelatedComponent = false;
for ( std::vector<DrumkitComponent*>::iterator it2 = compoList->begin() ; it2 != compoList->end(); ++it2 ) {
DrumkitComponent* p_compo = *it2;
if( p_compo->get_id() == it->first ) {
p_foundExistingRelatedComponent = true;
break;
}
}
if( !p_foundExistingRelatedComponent )
p_ids_to_delete->push_back( it->first ) ;
}
for ( std::vector<int>::iterator it = p_ids_to_delete->begin() ; it != p_ids_to_delete->end(); ++it ) {
int p_compoID = *it;
delete m_pComponentMixerLine[p_compoID];
m_pComponentMixerLine.erase( p_compoID );
int newWidth = MIXER_STRIP_WIDTH * ( nInstruments + nCompo );
if ( m_pFaderPanel->width() != newWidth ) {
m_pFaderPanel->resize( newWidth, height() );
}
}
}
if (nMuteClicked == nInstruments - 1) {
// find the not muted button
for (uint i = 0; i < nInstruments; i++) {
Instrument *instr = pInstrList->get(i);
if (instr->is_muted() == false) {
m_pMixerLine[i]->setSoloClicked(true);
break;
}
}
}
else {
for (uint i = 0; i < nInstruments; i++) {
m_pMixerLine[i]->setSoloClicked(false);
}
}
// update MasterPeak
float oldPeak_L = m_pMasterLine->getPeak_L();
float newPeak_L = pEngine->getMasterPeak_L();
pEngine->setMasterPeak_L(0.0);
float oldPeak_R = m_pMasterLine->getPeak_R();
float newPeak_R = pEngine->getMasterPeak_R();
pEngine->setMasterPeak_R(0.0);
if (!bShowPeaks) {
newPeak_L = 0.0;
newPeak_R = 0.0;
}
if (newPeak_L >= oldPeak_L) {
m_pMasterLine->setPeak_L( newPeak_L );
}
else {
m_pMasterLine->setPeak_L( oldPeak_L / fallOff );
}
if (newPeak_R >= oldPeak_R) {
m_pMasterLine->setPeak_R(newPeak_R);
}
else {
m_pMasterLine->setPeak_R( oldPeak_R / fallOff );
}
// set master fader position
float newVolume = pSong->get_volume();
float oldVolume = m_pMasterLine->getVolume();
if (oldVolume != newVolume) {
m_pMasterLine->setVolume(newVolume);
}
m_pMasterLine->updateMixerLine();
#ifdef H2CORE_HAVE_LADSPA
// LADSPA
for (uint nFX = 0; nFX < MAX_FX; nFX++) {
LadspaFX *pFX = Effects::get_instance()->getLadspaFX( nFX );
if ( pFX ) {
m_pLadspaFXLine[nFX]->setName( pFX->getPluginName() );
float fNewPeak_L = 0.0;
float fNewPeak_R = 0.0;
float fOldPeak_L = 0.0;
float fOldPeak_R = 0.0;
m_pLadspaFXLine[nFX]->getPeaks( &fOldPeak_L, &fOldPeak_R );
if (fNewPeak_L < fOldPeak_L) fNewPeak_L = fOldPeak_L / fallOff;
if (fNewPeak_R < fOldPeak_R) fNewPeak_R = fOldPeak_R / fallOff;
m_pLadspaFXLine[nFX]->setPeaks( fNewPeak_L, fNewPeak_R );
m_pLadspaFXLine[nFX]->setFxActive( pFX->isEnabled() );
m_pLadspaFXLine[nFX]->setVolume( pFX->getVolume() );
}
else {
m_pLadspaFXLine[nFX]->setName( "No plugin" );
m_pLadspaFXLine[nFX]->setFxActive( false );
m_pLadspaFXLine[nFX]->setVolume( 0.0 );
}
}
// ~LADSPA
#endif
}
void InstrumentEditor::selectedInstrumentChangedEvent()
{
AudioEngine::get_instance()->lock( RIGHT_HERE );
Song *pSong = Hydrogen::get_instance()->getSong();
if (pSong != NULL) {
InstrumentList *pInstrList = pSong->get_instrument_list();
int nInstr = Hydrogen::get_instance()->getSelectedInstrumentNumber();
if ( nInstr >= (int)pInstrList->size() ) {
nInstr = -1;
}
if (nInstr == -1) {
m_pInstrument = NULL;
}
else {
m_pInstrument = pInstrList->get( nInstr );
//INFOLOG( "new instr: " + m_pInstrument->m_sName );
}
}
else {
m_pInstrument = NULL;
}
AudioEngine::get_instance()->unlock();
// update layer list
if (m_pInstrument) {
m_pNameLbl->setText( m_pInstrument->get_name() );
// ADSR
m_pAttackRotary->setValue( sqrtf(m_pInstrument->get_adsr()->get_attack() / 100000.0) );
m_pDecayRotary->setValue( sqrtf(m_pInstrument->get_adsr()->get_decay() / 100000.0) );
m_pSustainRotary->setValue( m_pInstrument->get_adsr()->get_sustain() );
float fTmp = m_pInstrument->get_adsr()->get_release() - 256.0;
if( fTmp < 0.0 ) {
fTmp = 0.0;
}
m_pReleaseRotary->setValue( sqrtf(fTmp / 100000.0) );
//~ ADSR
// filter
m_pFilterBypassBtn->setPressed( !m_pInstrument->is_filter_active());
m_pCutoffRotary->setValue( m_pInstrument->get_filter_cutoff());
m_pResonanceRotary->setValue( m_pInstrument->get_filter_resonance());
//~ filter
// random pitch
m_pRandomPitchRotary->setValue( m_pInstrument->get_random_pitch_factor());
//Stop Note
m_pIsStopNoteCheckBox->setChecked( m_pInstrument->is_stop_notes() );
// instr gain
char tmp[20];
sprintf( tmp, "%#.2f", m_pInstrument->get_gain());
m_pInstrumentGainLCD->setText( tmp );
m_pInstrumentGain->setValue( m_pInstrument->get_gain()/ 5.0 );
// instr mute group
QString sMuteGroup = QString("%1").arg( m_pInstrument->get_mute_group() );
if (m_pInstrument->get_mute_group() == -1 ) {
sMuteGroup = "Off";
}
m_pMuteGroupLCD->setText( sMuteGroup );
// midi out
QString sMidiOutChannel = QString("%1").arg( m_pInstrument->get_midi_out_channel()+1);
if (m_pInstrument->get_midi_out_channel() == -1 ) {
sMidiOutChannel = "Off";
}
m_pMidiOutChannelLCD->setText( sMidiOutChannel );
//Convert note id into notation
{
int note = m_pInstrument->get_midi_out_note();
int octave = (note / 12) - 2;
const char *noteStrs[12] = { "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B" };
QString sMidiOutNote = QString(noteStrs[note % 12]) + QString::number(octave);
m_pMidiOutNoteLCD->setText( sMidiOutNote );
}
// select the last valid layer
for (int i = MAX_LAYERS - 1; i >= 0; i-- ) {
if ( m_pInstrument->get_layer( i ) ) {
m_nSelectedLayer = i;
break;
}
}
m_pWaveDisplay->updateDisplay( m_pInstrument->get_layer( m_nSelectedLayer ) );
}
else {
m_pNameLbl->setText( QString( "NULL Instrument..." ) );
m_pWaveDisplay->updateDisplay( NULL );
m_nSelectedLayer = 0;
}
selectLayer( m_nSelectedLayer );
}
