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 ); }