void WaveformWidgetFactory::setZoomSync(bool sync) {
m_zoomSync = sync;
if (m_config) {
m_config->set(ConfigKey("[Waveform]","ZoomSynchronization"), ConfigValue(m_zoomSync));
}
if (m_waveformWidgetHolders.size() == 0) {
return;
}
int refZoom = m_waveformWidgetHolders[0].m_waveformWidget->getZoomFactor();
for (int i = 1; i < m_waveformWidgetHolders.size(); i++) {
m_waveformWidgetHolders[i].m_waveformViewer->setZoom(refZoom);
}
}
TEST_F(ControllerEngineTest, connectControl_ByLambda) {
// Test that connecting with an anonymous function works.
auto co = std::make_unique<ControlObject>(ConfigKey("[Test]", "co"));
auto pass = std::make_unique<ControlObject>(ConfigKey("[Test]", "passed"));
ScopedTemporaryFile script(makeTemporaryFile(
"var connection = engine.connectControl('[Test]', 'co', function(value) { "
" var pass = engine.getValue('[Test]', 'passed');"
" engine.setValue('[Test]', 'passed', pass + 1.0); });"
"connection.trigger();"
"function disconnect() { "
" connection.disconnect();"
" engine.trigger('[Test]', 'co'); }"));
cEngine->evaluate(script->fileName());
EXPECT_FALSE(cEngine->hasErrors(script->fileName()));
// ControlObjectScript connections are processed via QueuedConnection. Use
// processEvents() to cause Qt to deliver them.
application()->processEvents();
EXPECT_TRUE(execute("disconnect"));
application()->processEvents();
// The counter should have been incremented exactly once.
EXPECT_DOUBLE_EQ(1.0, pass->get());
}
// Update the dialog when the crossfader mode is changed
void DlgPrefCrossfader::slotUpdate() {
if (radioButtonAdditive->isChecked()) {
m_xFaderMode = MIXXX_XFADER_ADDITIVE;
}
if (radioButtonConstantPower->isChecked()) {
m_xFaderMode = MIXXX_XFADER_CONSTPWR;
double sliderTransform = m_config->getValueString(
ConfigKey(kConfigKey, "xFaderCurve")).toDouble();
double sliderVal = SliderXFader->maximum()
/ kXFaderSteepnessCoeff * (sliderTransform - 1.);
SliderXFader->setValue((int)sliderVal);
}
slotUpdateXFader();
}
bool WaveformWidgetFactory::setWidgetType(WaveformWidgetType::Type type) {
if (type == m_type)
return true;
// check if type is acceptable
for (int i = 0; i < m_waveformWidgetHandles.size(); i++) {
WaveformWidgetAbstractHandle& handle = m_waveformWidgetHandles[i];
if (handle.m_type == type) {
// type is acceptable
m_type = type;
if (m_config) {
m_config->set(ConfigKey("[Waveform]","WaveformType"), ConfigValue((int)m_type));
}
return true;
}
}
// fallback
m_type = WaveformWidgetType::EmptyWaveform;
if (m_config) {
m_config->set(ConfigKey("[Waveform]","WaveformType"), ConfigValue((int)m_type));
}
return false;
}
void CueControl::trackLoaded(TrackPointer pTrack) {
QMutexLocker lock(&m_mutex);
if (m_pLoadedTrack)
trackUnloaded(m_pLoadedTrack);
if (!pTrack) {
return;
}
m_pLoadedTrack = pTrack;
connect(pTrack.data(), SIGNAL(cuesUpdated()),
this, SLOT(trackCuesUpdated()),
Qt::DirectConnection);
Cue* loadCue = NULL;
const QList<Cue*>& cuePoints = pTrack->getCuePoints();
QListIterator<Cue*> it(cuePoints);
while (it.hasNext()) {
Cue* pCue = it.next();
if (pCue->getType() == Cue::LOAD) {
loadCue = pCue;
} else if (pCue->getType() != Cue::CUE) {
continue;
}
int hotcue = pCue->getHotCue();
if (hotcue != -1)
attachCue(pCue, hotcue);
}
double loadCuePoint = 0.0;
if (loadCue != NULL) {
m_pCuePoint->set(loadCue->getPosition());
// If cue recall is ON in the prefs, then we're supposed to seek to the cue
// point on song load. Note that [Controls],cueRecall == 0 corresponds to "ON", not OFF.
if (!getConfig()->getValueString(
ConfigKey("[Controls]","CueRecall")).toInt()) {
loadCuePoint = loadCue->getPosition();
}
} else {
// If no cue point is stored, set one at track start
m_pCuePoint->set(0.0);
}
// Need to unlock before emitting any signals to prevent deadlock.
lock.unlock();
seekExact(loadCuePoint);
}
void DlgPrefVinyl::slotUpdate()
{
// Set vinyl control types in the comboboxes
int combo_index = ComboBoxVinylType1->findText(config->getValueString(ConfigKey("[Channel1]","vinylcontrol_vinyl_type")));
if (combo_index != -1)
ComboBoxVinylType1->setCurrentIndex(combo_index);
combo_index = ComboBoxVinylType2->findText(config->getValueString(ConfigKey("[Channel2]","vinylcontrol_vinyl_type")));
if (combo_index != -1)
ComboBoxVinylType2->setCurrentIndex(combo_index);
combo_index = ComboBoxVinylSpeed1->findText(config->getValueString(ConfigKey("[Channel1]","vinylcontrol_speed_type")));
if (combo_index != -1)
ComboBoxVinylSpeed1->setCurrentIndex(combo_index);
combo_index = ComboBoxVinylSpeed2->findText(config->getValueString(ConfigKey("[Channel2]","vinylcontrol_speed_type")));
if (combo_index != -1)
ComboBoxVinylSpeed2->setCurrentIndex(combo_index);
// set lead-in time
LeadinTime->setText (config->getValueString(ConfigKey(VINYL_PREF_KEY,"lead_in_time")) );
// set Relative mode
int iMode = config->getValueString(ConfigKey(VINYL_PREF_KEY,"mode")).toInt();
if (iMode == MIXXX_VCMODE_ABSOLUTE)
AbsoluteMode->setChecked(true);
else if (iMode == MIXXX_VCMODE_RELATIVE)
RelativeMode->setChecked(true);
// Honour the Needle Skip Prevention setting.
NeedleSkipEnable->setChecked( (bool)config->getValueString( ConfigKey(VINYL_PREF_KEY, "needle_skip_prevention") ).toInt() );
SignalQualityEnable->setChecked((bool)config->getValueString(ConfigKey(VINYL_PREF_KEY, "show_signal_quality") ).toInt() );
//set vinyl control gain
VinylGain->setValue( config->getValueString(ConfigKey(VINYL_PREF_KEY,"gain")).toInt());
m_signalWidget1.setVinylActive(m_pVCManager->vinylInputEnabled(0));
m_signalWidget2.setVinylActive(m_pVCManager->vinylInputEnabled(1));
}
long RecordingManager::getFileSplitSize()
{
QString fileSizeStr = m_pConfig->getValueString(ConfigKey(RECORDING_PREF_KEY,"FileSize"));
if(fileSizeStr == SPLIT_650MB)
return SIZE_650MB;
else if(fileSizeStr == SPLIT_700MB)
return SIZE_700MB;
else if(fileSizeStr == SPLIT_1024MB)
return SIZE_1GB;
else if(fileSizeStr == SPLIT_2048MB)
return SIZE_2GB;
else if(fileSizeStr == SPLIT_4096MB)
return SIZE_4GB;
else
return SIZE_650MB;
}
LibraryControl::LibraryControl(QObject* pParent)
: QObject(pParent),
m_pLibraryWidget(NULL),
m_pSidebarWidget(NULL),
m_numDecks("[Master]", "num_decks"),
m_numSamplers("[Master]", "num_samplers"),
m_numPreviewDecks("[Master]", "num_preview_decks") {
slotNumDecksChanged(m_numDecks.get());
slotNumSamplersChanged(m_numSamplers.get());
slotNumPreviewDecksChanged(m_numPreviewDecks.get());
connect(&m_numDecks, SIGNAL(valueChanged(double)),
this, SLOT(slotNumDecksChanged(double)));
connect(&m_numSamplers, SIGNAL(valueChanged(double)),
this, SLOT(slotNumSamplersChanged(double)));
connect(&m_numPreviewDecks, SIGNAL(valueChanged(double)),
this, SLOT(slotNumPreviewDecksChanged(double)));
// Make controls for library navigation and track loading. Leaking all these
// CO's, but oh well?
m_pSelectNextTrack = new ControlPushButton(ConfigKey("[Playlist]", "SelectNextTrack"));
connect(m_pSelectNextTrack, SIGNAL(valueChanged(double)),
this, SLOT(slotSelectNextTrack(double)));
m_pSelectPrevTrack = new ControlPushButton(ConfigKey("[Playlist]", "SelectPrevTrack"));
connect(m_pSelectPrevTrack, SIGNAL(valueChanged(double)),
this, SLOT(slotSelectPrevTrack(double)));
m_pSelectNextPlaylist = new ControlPushButton(ConfigKey("[Playlist]", "SelectNextPlaylist"));
connect(m_pSelectNextPlaylist, SIGNAL(valueChanged(double)),
this, SLOT(slotSelectNextSidebarItem(double)));
m_pSelectPrevPlaylist = new ControlPushButton(ConfigKey("[Playlist]", "SelectPrevPlaylist"));
connect(m_pSelectPrevPlaylist, SIGNAL(valueChanged(double)),
this, SLOT(slotSelectPrevSidebarItem(double)));
m_pToggleSidebarItem = new ControlPushButton(ConfigKey("[Playlist]", "ToggleSelectedSidebarItem"));
connect(m_pToggleSidebarItem, SIGNAL(valueChanged(double)),
this, SLOT(slotToggleSelectedSidebarItem(double)));
m_pLoadSelectedIntoFirstStopped = new ControlPushButton(ConfigKey("[Playlist]","LoadSelectedIntoFirstStopped"));
connect(m_pLoadSelectedIntoFirstStopped, SIGNAL(valueChanged(double)),
this, SLOT(slotLoadSelectedIntoFirstStopped(double)));
m_pSelectTrackKnob = new ControlPushButton(ConfigKey("[Playlist]","SelectTrackKnob"));
connect(m_pSelectTrackKnob, SIGNAL(valueChanged(double)),
this, SLOT(slotSelectTrackKnob(double)));
}
void DlgPrefRecord::slotBrowseRecordingsDir() {
QString fd = QFileDialog::getExistingDirectory(
this, tr("Choose recordings directory"),
m_pConfig->getValueString(ConfigKey(RECORDING_PREF_KEY,
"Directory")));
if (fd != "") {
// The user has picked a new directory via a file dialog. This means the
// system sandboxer (if we are sandboxed) has granted us permission to
// this folder. Create a security bookmark while we have permission so
// that we can access the folder on future runs. We need to canonicalize
// the path so we first wrap the directory string with a QDir.
QDir directory(fd);
Sandbox::createSecurityToken(directory);
LineEditRecordings->setText(fd);
}
}
void EngineMaster::addChannel(EngineChannel* pChannel) {
ChannelInfo* pChannelInfo = new ChannelInfo();
pChannelInfo->m_pChannel = pChannel;
pChannelInfo->m_pVolumeControl = new ControlLogpotmeter(
ConfigKey(pChannel->getGroup(), "volume"), 1.0);
pChannelInfo->m_pVolumeControl->setDefaultValue(1.0);
pChannelInfo->m_pVolumeControl->set(1.0);
pChannelInfo->m_pBuffer = SampleUtil::alloc(MAX_BUFFER_LEN);
SampleUtil::applyGain(pChannelInfo->m_pBuffer, 0, MAX_BUFFER_LEN);
m_channels.push_back(pChannelInfo);
EngineBuffer* pBuffer = pChannelInfo->m_pChannel->getEngineBuffer();
if (pBuffer != NULL) {
pBuffer->bindWorkers(m_pWorkerScheduler);
pBuffer->setEngineMaster(this);
}
}
MidiOutputHandler::MidiOutputHandler(QString group, QString key,
MidiController *controller,
float min, float max,
unsigned char status, unsigned char midino,
unsigned char on, unsigned char off)
: m_pController(controller),
m_cobj(ControlObject::getControl(ConfigKey(group, key))),
m_min(min),
m_max(max),
m_status(status),
m_midino(midino),
m_on(on),
m_off(off),
m_lastVal(0) {
connect(&m_cobj, SIGNAL(valueChanged(double)),
this, SLOT(controlChanged(double)));
}
void DlgPreferences::onShow() {
// init m_geometry
if (m_geometry.length() < 4) {
// load default values (optimum size)
m_geometry = m_pConfig->getValue(
ConfigKey("[Preferences]", "geometry")).split(",");
if (m_geometry.length() < 4) {
// Warning! geometry does NOT include the frame/title.
QRect defaultGeometry = getDefaultGeometry();
m_geometry.clear();
m_geometry.append(QString::number(defaultGeometry.left()));
m_geometry.append(QString::number(defaultGeometry.top()));
m_geometry.append(QString::number(defaultGeometry.width()));
m_geometry.append(QString::number(defaultGeometry.height()));
}
}
int newX = m_geometry[0].toInt();
int newY = m_geometry[1].toInt();
newX = std::max(0, std::min(newX, QApplication::desktop()->screenGeometry().width()- m_geometry[2].toInt()));
newY = std::max(0, std::min(newY, QApplication::desktop()->screenGeometry().height() - m_geometry[3].toInt()));
m_geometry[0] = QString::number(newX);
m_geometry[1] = QString::number(newY);
// Update geometry with last values
#ifdef __WINDOWS__
resize(m_geometry[2].toInt(), m_geometry[3].toInt());
#else
// On linux, when the window is opened for the first time by the window manager, QT does not have
// information about the frame size so the offset is zero. As such, the first time it opens the window
// does not include the offset, so it is moved from the last position it had.
// Excluding the offset from the saved value tries to fix that.
int offsetX = geometry().left() - frameGeometry().left();
int offsetY = geometry().top() - frameGeometry().top();
newX += offsetX;
newY += offsetY;
setGeometry(newX, // x position
newY, // y position
m_geometry[2].toInt(), // width
m_geometry[3].toInt()); // height
#endif
// Move is also needed on linux.
move(newX, newY);
// Notify children that we are about to show.
emit(showDlg());
}
void DlgPrefPlaylist::slotApply() {
m_pconfig->set(ConfigKey("[Promo]","StatTracking"),
ConfigValue((int)checkBoxPromoStats->isChecked()));
m_pconfig->set(ConfigKey("[Library]","RescanOnStartup"),
ConfigValue((int)checkBox_library_scan->isChecked()));
m_pconfig->set(ConfigKey("[Library]","WriteAudioTags"),
ConfigValue((int)checkbox_ID3_sync->isChecked()));
m_pconfig->set(ConfigKey("[Library]","UseRelativePathOnExport"),
ConfigValue((int)checkBox_use_relative_path->isChecked()));
m_pconfig->set(ConfigKey("[Library]","ShowRhythmboxLibrary"),
ConfigValue((int)checkBox_show_rhythmbox->isChecked()));
m_pconfig->set(ConfigKey("[Library]","ShowITunesLibrary"),
ConfigValue((int)checkBox_show_itunes->isChecked()));
m_pconfig->set(ConfigKey("[Library]","ShowTraktorLibrary"),
ConfigValue((int)checkBox_show_traktor->isChecked()));
if (LineEditSongfiles->text() !=
m_pconfig->getValueString(ConfigKey("[Playlist]","Directory"))) {
m_pconfig->set(ConfigKey("[Playlist]","Directory"), LineEditSongfiles->text());
emit(apply());
}
m_pconfig->Save();
}
void TrackCollection::run() {
QThread::currentThread()->setObjectName("TrackCollection");
DBG() << "id=" << QThread::currentThreadId()
<< "name=" << QThread::currentThread()->objectName();
qRegisterMetaType<QSet<int> >("QSet<int>");
DBG() << "Initializing DAOs inside TrackCollection's thread";
createAndPopulateDbConnection();
m_trackDao->initialize();
m_playlistDao->initialize();
m_crateDao->initialize();
m_cueDao->initialize();
m_pCOTPlaylistIsBusy = new ControlObjectThread(ConfigKey("[Playlist]", "isBusy"));
Q_ASSERT(m_pCOTPlaylistIsBusy!=NULL);
emit(initialized()); // to notify that Daos can be used
func lambda;
// main TrackCollection's loop
while (!m_stop) {
if (!m_semLambdasReadyToCall.tryAcquire(1)) {
// no Lambda available, so unlock GUI.
m_pCOTPlaylistIsBusy->set(0.0);
m_semLambdasReadyToCall.acquire(1); // Sleep until new Lambdas have arrived
}
// got lambda on queue (or needness to stop thread)
if (m_stop) {
DBG() << "Need to stop thread";
break;
}
if (!m_lambdas.isEmpty()) {
m_lambdasQueueMutex.lock();
lambda = m_lambdas.dequeue();
m_lambdasQueueMutex.unlock();
lambda();
m_semLambdasFree.release(1);
}
}
deleteLater();
DBG() << " ### Thread ended ###";
}
QString SkinLoader::getConfiguredSkinPath() {
QString qSkinPath = m_pConfig->getResourcePath();
qSkinPath.append("skins/");
QString configSkin = m_pConfig->getValueString(ConfigKey("[Config]","Skin"));
QString qThisSkin = qSkinPath + configSkin;
QDir thisSkin(qThisSkin);
if (configSkin.length() > 0 && thisSkin.exists()) {
qSkinPath = qThisSkin;
} else {
// try developer path
qSkinPath = m_pConfig->getResourcePath();
qSkinPath.append("developer_skins/");
qThisSkin = qSkinPath + configSkin;
thisSkin = qThisSkin;
if (configSkin.length() > 0 && thisSkin.exists()) {
qSkinPath = qThisSkin;
} else {
// Fall back to default skin
QString defaultSkin;
QRect screenGeo = QApplication::desktop()->screenGeometry();
if (screenGeo.width() >= 1280 && screenGeo.height() >= 800) {
defaultSkin = "Deere1280x800-WXGA";
}
else if (screenGeo.width() >= 1024 && screenGeo.height() >= 600) {
defaultSkin = "ShadeDark1024x600-Netbook";
}
else {
defaultSkin = "Outline800x480-WVGA"; // Mixxx's smallest Skin
}
qSkinPath = m_pConfig->getResourcePath();
qSkinPath.append("skins/");
qSkinPath.append(defaultSkin);
}
}
QDir skinPath(qSkinPath);
if (!skinPath.exists()) {
reportCriticalErrorAndQuit("Skin directory does not exist: " + qSkinPath);
}
return qSkinPath;
}
bool BrowseTableModel::isTrackInUse(const QString &track_location) const {
int decks = ControlObject::getControl(
ConfigKey("[Master]", "num_decks"))->get();
// check if file is loaded to a deck
for (int i = 1; i <= decks; ++i) {
TrackPointer loaded_track = PlayerInfo::Instance().getTrackInfo(
QString("[Channel%1]").arg(i));
if (loaded_track && (loaded_track->getLocation() == track_location)) {
return true;
}
}
if (m_pRecordingManager->getRecordingLocation() == track_location) {
return true;
}
return false;
}
void DlgPrefEQ::loadSettings()
{
QString highEqCourse = m_pConfig->getValueString(ConfigKey(CONFIG_KEY, "HiEQFrequency"));
QString highEqPrecise = m_pConfig->getValueString(ConfigKey(CONFIG_KEY, "HiEQFrequencyPrecise"));
QString lowEqCourse = m_pConfig->getValueString(ConfigKey(CONFIG_KEY, "LoEQFrequency"));
QString lowEqPrecise = m_pConfig->getValueString(ConfigKey(CONFIG_KEY, "LoEQFrequencyPrecise"));
double lowEqFreq = 0.0;
double highEqFreq = 0.0;
// Precise takes precedence over course.
lowEqFreq = lowEqCourse.isEmpty() ? lowEqFreq : lowEqCourse.toDouble();
lowEqFreq = lowEqPrecise.isEmpty() ? lowEqFreq : lowEqPrecise.toDouble();
highEqFreq = highEqCourse.isEmpty() ? highEqFreq : highEqCourse.toDouble();
highEqFreq = highEqPrecise.isEmpty() ? highEqFreq : highEqPrecise.toDouble();
if (lowEqFreq == 0.0 || highEqFreq == 0.0 || lowEqFreq == highEqFreq) {
CheckBoxLoFi->setChecked(true);
setDefaultShelves();
lowEqFreq = m_pConfig->getValueString(ConfigKey(CONFIG_KEY, "LoEQFrequencyPrecise")).toDouble();
highEqFreq = m_pConfig->getValueString(ConfigKey(CONFIG_KEY, "HiEQFrequencyPrecise")).toDouble();
}
SliderHiEQ->setValue(
getSliderPosition(highEqFreq,
SliderHiEQ->minimum(),
SliderHiEQ->maximum()));
SliderLoEQ->setValue(
getSliderPosition(lowEqFreq,
SliderLoEQ->minimum(),
SliderLoEQ->maximum()));
CheckBoxLoFi->setChecked(m_pConfig->getValueString(
ConfigKey(CONFIG_KEY, "LoFiEQs")) == QString("yes"));
// Default internal EQs to enabled.
CheckBoxEnbEQ->setChecked(m_pConfig->getValueString(
ConfigKey(CONFIG_KEY, ENABLE_INTERNAL_EQ), "yes") == QString("yes"));
slotUpdate();
slotApply();
}
SoundDevicePortAudio::SoundDevicePortAudio(ConfigObject<ConfigValue> *config, SoundManager *sm,
const PaDeviceInfo *deviceInfo, unsigned int devIndex)
: SoundDevice(config, sm),
m_pStream(NULL),
m_devId(devIndex),
m_deviceInfo(deviceInfo),
m_bSetThreadPriority(false),
m_pMasterUnderflowCount(ControlObject::getControl(
ConfigKey("[Master]", "underflow_count"))),
m_underflowUpdateCount(0) {
// Setting parent class members:
m_hostAPI = Pa_GetHostApiInfo(deviceInfo->hostApi)->name;
m_dSampleRate = deviceInfo->defaultSampleRate;
m_strInternalName = QString("%1, %2").arg(QString::number(m_devId), deviceInfo->name);
m_strDisplayName = QString(deviceInfo->name);
m_iNumInputChannels = m_deviceInfo->maxInputChannels;
m_iNumOutputChannels = m_deviceInfo->maxOutputChannels;
}
void DlgPrefWaveform::slotUpdate() {
WaveformWidgetFactory* factory = WaveformWidgetFactory::instance();
if (factory->isOpenGlAvailable() || factory->isOpenGlesAvailable()) {
openGlStatusIcon->setText(factory->getOpenGLVersion());
} else {
openGlStatusIcon->setText(tr("OpenGL not available") + ": " + factory->getOpenGLVersion());
}
WaveformWidgetType::Type currentType = factory->getType();
int currentIndex = waveformTypeComboBox->findData(currentType);
if (currentIndex != -1 && waveformTypeComboBox->currentIndex() != currentIndex) {
waveformTypeComboBox->setCurrentIndex(currentIndex);
}
frameRateSpinBox->setValue(factory->getFrameRate());
frameRateSlider->setValue(factory->getFrameRate());
endOfTrackWarningTimeSpinBox->setValue(factory->getEndOfTrackWarningTime());
endOfTrackWarningTimeSlider->setValue(factory->getEndOfTrackWarningTime());
synchronizeZoomCheckBox->setChecked(factory->isZoomSync());
allVisualGain->setValue(factory->getVisualGain(WaveformWidgetFactory::All));
lowVisualGain->setValue(factory->getVisualGain(WaveformWidgetFactory::Low));
midVisualGain->setValue(factory->getVisualGain(WaveformWidgetFactory::Mid));
highVisualGain->setValue(factory->getVisualGain(WaveformWidgetFactory::High));
normalizeOverviewCheckBox->setChecked(factory->isOverviewNormalized());
// Round zoom to int to get a default zoom index.
defaultZoomComboBox->setCurrentIndex(static_cast<int>(factory->getDefaultZoom()) - 1);
playMarkerPositionSlider->setValue(factory->getPlayMarkerPosition() * 100);
beatGridAlphaSpinBox->setValue(factory->beatGridAlpha());
beatGridAlphaSlider->setValue(factory->beatGridAlpha());
// By default we set RGB woverview = "2"
int overviewType = m_pConfig->getValue(
ConfigKey("[Waveform]","WaveformOverviewType"), 2);
if (overviewType != waveformOverviewComboBox->currentIndex()) {
waveformOverviewComboBox->setCurrentIndex(overviewType);
}
WaveformSettings waveformSettings(m_pConfig);
enableWaveformCaching->setChecked(waveformSettings.waveformCachingEnabled());
enableWaveformGenerationWithAnalysis->setChecked(
waveformSettings.waveformGenerationWithAnalysisEnabled());
calculateCachedWaveformDiskUsage();
}
void DlgPrefPlaylist::slotUpdate() {
// Library Path
LineEditSongfiles->setText(m_pconfig->getValueString(
ConfigKey("[Playlist]","Directory")));
//Bundled songs stat tracking
checkBoxPromoStats->setChecked((bool)m_pconfig->getValueString(
ConfigKey("[Promo]","StatTracking")).toInt());
checkBox_library_scan->setChecked((bool)m_pconfig->getValueString(
ConfigKey("[Library]","RescanOnStartup")).toInt());
checkbox_ID3_sync->setChecked((bool)m_pconfig->getValueString(
ConfigKey("[Library]","WriteAudioTags")).toInt());
checkBox_use_relative_path->setChecked((bool)m_pconfig->getValueString(
ConfigKey("[Library]","UseRelativePathOnExport")).toInt());
checkBox_show_rhythmbox->setChecked((bool)m_pconfig->getValueString(
ConfigKey("[Library]","ShowRhythmboxLibrary"),"1").toInt());
checkBox_show_itunes->setChecked((bool)m_pconfig->getValueString(
ConfigKey("[Library]","ShowITunesLibrary"),"1").toInt());
checkBox_show_traktor->setChecked((bool)m_pconfig->getValueString(
ConfigKey("[Library]","ShowTraktorLibrary"),"1").toInt());
}
VinylControl::VinylControl(ConfigObject<ConfigValue> * pConfig, QString group)
{
m_pConfig = pConfig;
m_group = group;
iSampleRate = m_pConfig->getValueString(ConfigKey("[Soundcard]","Samplerate")).toULong();
// Get Control objects
playPos = new ControlObjectThread(group, "playposition"); //Range: -.14 to 1.14
trackSamples = new ControlObjectThread(group, "track_samples");
trackSampleRate = new ControlObjectThread(group, "track_samplerate");
vinylSeek = new ControlObjectThread(group, "vinylcontrol_seek");
controlScratch = new ControlObjectThread(group, "scratch2");
rateSlider = new ControlObjectThread(group, "rate"); //Range -1.0 to 1.0
playButton = new ControlObjectThread(group, "play");
reverseButton = new ControlObjectThread(group, "reverse");
duration = new ControlObjectThread(group, "duration");
mode = new ControlObjectThread(group, "vinylcontrol_mode");
enabled = new ControlObjectThread(group, "vinylcontrol_enabled");
wantenabled = new ControlObjectThread(group, "vinylcontrol_wantenabled");
cueing = new ControlObjectThread(group, "vinylcontrol_cueing");
scratching = new ControlObjectThread(group, "vinylcontrol_scratching");
rateRange = new ControlObjectThread(group, "rateRange");
vinylStatus = new ControlObjectThread(group, "vinylcontrol_status");
rateDir = new ControlObjectThread(group, "rate_dir");
loopEnabled = new ControlObjectThread(group, "loop_enabled");
signalenabled = new ControlObjectThread(group, "vinylcontrol_signal_enabled");
dVinylPitch = 0.0f;
dVinylPosition = 0.0f;
dVinylScratch = 0.0f;
dDriftControl = 0.0f;
fRateRange = 0.0f;
m_fTimecodeQuality = 0.0f;
//Get the vinyl type
strVinylType = m_pConfig->getValueString(ConfigKey(group,"vinylcontrol_vinyl_type"));
//Get the vinyl speed
strVinylSpeed = m_pConfig->getValueString(ConfigKey(group,"vinylcontrol_speed_type"));
//Get the lead-in time
iLeadInTime = m_pConfig->getValueString(ConfigKey(VINYL_PREF_KEY,"lead_in_time")).toInt();
//Enabled or not -- load from saved value in case vinyl control is restarting
bIsEnabled = wantenabled->get();
//Gain
ControlObject::set(ConfigKey(VINYL_PREF_KEY, "gain"),
m_pConfig->getValueString(ConfigKey(VINYL_PREF_KEY,"gain")).toInt());
}
// Selects the option by its index. If it is a single-element option,
// index 0 means disabled and 1 enabled.
void EncoderMp3Settings::setGroupOption(QString groupCode, int optionIndex)
{
bool found=false;
for (const auto& group : m_radioList) {
if (groupCode == group.groupCode) {
found=true;
if (optionIndex < group.controlNames.size() || optionIndex == 1) {
m_pConfig->set(ConfigKey(RECORDING_PREF_KEY, ENCODING_MODE_GROUP),
ConfigValue(optionIndex));
} else {
qWarning() << "Received an index out of range for: "
<< groupCode << ", index: " << optionIndex;
}
}
}
if (!found) {
qWarning() << "Received an unknown groupCode on setGroupOption: " << groupCode;
}
}
TEST_F(ControllerEngineTest, automaticReaction) {
ScopedTemporaryFile script(makeTemporaryFile(
"setUp = function() { engine.connectControl('[Channel1]','co','reaction'); }\n"
"reaction = function(value) { if (value == 2.5) print('TEST PASSED: '+value);\n"
"else print('TEST FAILED! TEST FAILED! TEST FAILED: '+value); "
"return value; }\n"));
cEngine->evaluate(script->fileName());
EXPECT_FALSE(cEngine->hasErrors(script->fileName()));
ScopedControl co(new ControlObject(ConfigKey("[Channel1]", "co")));
co->set(0.0);
EXPECT_TRUE(execute("setUp"));
// The actual test
// TODO: Have the JS call a function in this test class so the test framework
// can tell if it actually passed or not
co->set(2.5);
}
EnginePregain::EnginePregain(QString group)
: m_dSpeed(1.0),
m_dOldSpeed(1.0),
m_scratching(false),
m_fPrevGain(1.0),
m_bSmoothFade(false) {
m_pPotmeterPregain = new ControlAudioTaperPot(ConfigKey(group, "pregain"), -12, 12, 0.5);
//Replay Gain things
m_pCOReplayGain = new ControlObject(ConfigKey(group, "replaygain"));
m_pTotalGain = new ControlObject(ConfigKey(group, "total_gain"));
m_pPassthroughEnabled = ControlObject::getControl(ConfigKey(group, "passthrough"));
if (s_pReplayGainBoost == NULL) {
s_pReplayGainBoost = new ControlAudioTaperPot(ConfigKey("[ReplayGain]", "ReplayGainBoost"), -12, 12, 0.5);
s_pDefaultBoost = new ControlAudioTaperPot(ConfigKey("[ReplayGain]", "DefaultBoost"), -12, 12, 0.5);
s_pEnableReplayGain = new ControlObject(ConfigKey("[ReplayGain]", "ReplayGainEnabled"));
}
}
void DlgPrefReplayGain::slotResetToDefaults() {
EnableGain->setChecked(true);
// Turn ReplayGain Analyzer on by default as it does not give appreciable
// delay on recent hardware (<5 years old).
EnableAnalyzer->setChecked(true);
SliderReplayGainBoost->setValue(0);
setLabelCurrentReplayGainBoost(0);
SliderDefaultBoost->setValue(-6);
LabelCurrentDefaultBoost->setText("-6 dB");
int iDefaultBoost = config->getValueString(
ConfigKey(kConfigKey, "InitialDefaultBoost"), "-6").toInt();
SliderDefaultBoost->setValue(iDefaultBoost);
LabelCurrentDefaultBoost->setText(
QString("%1 dB").arg(iDefaultBoost));
slotUpdate();
slotApply();
}
// Return the selected option of the group. If it is a single-element option,
// 0 means disabled and 1 enabled.
int EncoderMp3Settings::getSelectedOption(QString groupCode) const
{
bool found=false;
int value = m_pConfig->getValue(
ConfigKey(RECORDING_PREF_KEY, ENCODING_MODE_GROUP), 0);
for (const auto& group : m_radioList) {
if (groupCode == group.groupCode) {
found=true;
if (value >= group.controlNames.size() && value > 1) {
qWarning() << "Value saved for " << groupCode <<
" on preferences is out of range " << value << ". Returning 0";
value=0;
}
}
}
if (!found) {
qWarning() << "Received an unknown groupCode on getSelectedOption: " << groupCode;
}
return value;
}
EffectsManager::EffectsManager(QObject* pParent, UserSettingsPointer pConfig,
ChannelHandleFactory* pChannelHandleFactory)
: QObject(pParent),
m_pChannelHandleFactory(pChannelHandleFactory),
m_pEffectChainManager(new EffectChainManager(pConfig, this)),
m_nextRequestId(0),
m_pLoEqFreq(NULL),
m_pHiEqFreq(NULL),
m_underDestruction(false) {
qRegisterMetaType<EffectChainInsertionType>("EffectChainInsertionType");
QPair<EffectsRequestPipe*, EffectsResponsePipe*> requestPipes =
TwoWayMessagePipe<EffectsRequest*, EffectsResponse>::makeTwoWayMessagePipe(
kEffectMessagPipeFifoSize, kEffectMessagPipeFifoSize, false, false);
m_pRequestPipe.reset(requestPipes.first);
m_pEngineEffectsManager = new EngineEffectsManager(requestPipes.second);
m_pNumEffectsAvailable = new ControlObject(ConfigKey("[Master]", "num_effectsavailable"));
m_pNumEffectsAvailable->setReadOnly();
}
void ColorSchemeParser::setupLegacyColorSchemes(QDomElement docElem,
ConfigObject<ConfigValue>* pConfig) {
QDomNode colsch = docElem.namedItem("Schemes");
if (!colsch.isNull() && colsch.isElement()) {
QString schname = pConfig->getValueString(ConfigKey("[Config]","Scheme"));
QDomNode sch = colsch.firstChild();
bool found = false;
if (schname.isEmpty()) {
// If no scheme stored, accept the first one in the file
found = true;
}
while (!sch.isNull() && !found) {
QString thisname = XmlParse::selectNodeQString(sch, "Name");
if (thisname == schname) {
found = true;
} else {
sch = sch.nextSibling();
}
}
if (found) {
QSharedPointer<ImgSource> imsrc =
QSharedPointer<ImgSource>(parseFilters(sch.namedItem("Filters")));
WPixmapStore::setLoader(imsrc);
WImageStore::setLoader(imsrc);
WSkinColor::setLoader(imsrc);
} else {
WPixmapStore::setLoader(QSharedPointer<ImgSource>());
WImageStore::setLoader(QSharedPointer<ImgSource>());
WSkinColor::setLoader(QSharedPointer<ImgSource>());
}
} else {
WPixmapStore::setLoader(QSharedPointer<ImgSource>());
WImageStore::setLoader(QSharedPointer<ImgSource>());
WSkinColor::setLoader(QSharedPointer<ImgSource>());
}
}
DlgPrefEffects::DlgPrefEffects(QWidget* pParent,
UserSettingsPointer pConfig,
EffectsManager* pEffectsManager)
: DlgPreferencePage(pParent),
m_pConfig(pConfig),
m_pEffectsManager(pEffectsManager) {
setupUi(this);
m_availableEffectsModel.resetFromEffectManager(pEffectsManager);
for (auto& profile : m_availableEffectsModel.profiles()) {
EffectManifestPointer pManifest = profile->pManifest;
// Users are likely to have lots of external plugins installed and
// many of them are useless for DJing. To avoid cluttering the list
// shown in WEffectSelector, blacklist external plugins by default.
bool defaultValue = (pManifest->backendType() == EffectBackendType::BuiltIn);
bool visible = m_pConfig->getValue<bool>(ConfigKey("[Visible " + pManifest->backendName() + " Effects]",
pManifest->id()), defaultValue);
profile->bIsVisible = visible;
m_pEffectsManager->setEffectVisibility(pManifest, visible);
}
availableEffectsList->setModel(&m_availableEffectsModel);
connect(availableEffectsList->selectionModel(),
SIGNAL(currentRowChanged(const QModelIndex&, const QModelIndex&)),
this,
SLOT(availableEffectsListItemSelected(const QModelIndex&)));
// Highlight first row
availableEffectsList->selectRow(0);
#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
availableEffectsList->horizontalHeader()->setResizeMode(0, QHeaderView::ResizeToContents);
availableEffectsList->setColumnWidth(1, 200);
availableEffectsList->horizontalHeader()->setResizeMode(2, QHeaderView::ResizeToContents);
#else
availableEffectsList->horizontalHeader()->setSectionResizeMode(0, QHeaderView::ResizeToContents);
availableEffectsList->setColumnWidth(1, 200);
availableEffectsList->horizontalHeader()->setSectionResizeMode(2, QHeaderView::ResizeToContents);
#endif // QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
}
EngineMicrophone::EngineMicrophone(const char* pGroup, EffectsManager* pEffectsManager)
: EngineChannel(pGroup, EngineChannel::CENTER),
m_pEngineEffectsManager(pEffectsManager ? pEffectsManager->getEngineEffectsManager() : NULL),
m_clipping(pGroup),
m_vuMeter(pGroup),
m_pEnabled(new ControlObject(ConfigKey(pGroup, "enabled"))),
m_pConversionBuffer(SampleUtil::alloc(MAX_BUFFER_LEN)),
// Need a +1 here because the CircularBuffer only allows its size-1
// items to be held at once (it keeps a blank spot open persistently)
m_sampleBuffer(MAX_BUFFER_LEN+1),
m_wasActive(false) {
if (pEffectsManager != NULL) {
pEffectsManager->registerGroup(getGroup());
}
// You normally don't expect to hear yourself in the headphones. Default PFL
// setting for mic to false. User can over-ride by setting the "pfl" or
// "master" controls.
setMaster(true);
setPFL(false);
}