bool LLFilePickerBase::getLoadFile(ELoadFilter filter, std::string const& folder)
{
if( mLocked )
{
return FALSE;
}
bool success = FALSE;
llutf16string tstring = utf8str_to_utf16str(folder);
mOFN.lpstrInitialDir = (LPCTSTR)tstring.data();
mFilesW[0] = '\0';
mOFN.lpstrFile = mFilesW;
mOFN.nMaxFile = SINGLE_FILENAME_BUFFER_SIZE;
mOFN.Flags = OFN_HIDEREADONLY | OFN_FILEMUSTEXIST | OFN_NOCHANGEDIR ;
mOFN.nFilterIndex = 1;
setupFilter(filter);
reset();
// NOTA BENE: hitting the file dialog triggers a window focus event, destroying the selection manager!!
success = GetOpenFileName(&mOFN);
if (success)
{
std::string filename = utf16str_to_utf8str(llutf16string(mFilesW));
mFiles.push_back(filename);
}
return success;
}
void DTPatientListWidget::slotDBOpened()
{
QString filter("---");
mPatientSearchListModel->setLikeFilter(filter);
mPatientSearchListModel->select();
ui->mPatientsList->setModel(mPatientListModel);
setupFilter();
}
bool LLFilePickerBase::getMultipleLoadFiles(ELoadFilter filter, std::string const& folder)
{
if( mLocked )
{
return FALSE;
}
bool success = FALSE;
llutf16string tstring = utf8str_to_utf16str(folder);
mOFN.lpstrInitialDir = (LPCTSTR)tstring.data();
mFilesW[0] = '\0';
mOFN.lpstrFile = mFilesW;
mOFN.nFilterIndex = 1;
mOFN.nMaxFile = FILENAME_BUFFER_SIZE;
mOFN.Flags = OFN_HIDEREADONLY | OFN_FILEMUSTEXIST | OFN_NOCHANGEDIR |
OFN_EXPLORER | OFN_ALLOWMULTISELECT;
setupFilter(filter);
reset();
// NOTA BENE: hitting the file dialog triggers a window focus event, destroying the selection manager!!
success = GetOpenFileName(&mOFN); // pauses until ok or cancel.
if( success )
{
// The getopenfilename api doesn't tell us if we got more than
// one file, so we have to test manually by checking string
// lengths.
if( wcslen(mOFN.lpstrFile) > mOFN.nFileOffset ) /*Flawfinder: ignore*/
{
std::string filename = utf16str_to_utf8str(llutf16string(mFilesW));
mFiles.push_back(filename);
}
else
{
mLocked = TRUE;
WCHAR* tptrw = mFilesW;
std::string dirname;
while(1)
{
if (*tptrw == 0 && *(tptrw+1) == 0) // double '\0'
break;
if (*tptrw == 0)
tptrw++; // shouldn't happen?
std::string filename = utf16str_to_utf8str(llutf16string(tptrw));
if (dirname.empty())
dirname = filename + "\\";
else
mFiles.push_back(dirname + filename);
tptrw += filename.size();
}
}
}
return success;
}
BOOL LLFilePicker::getOpenFile(ELoadFilter filter, bool blocking)
{
if( mLocked )
{
return FALSE;
}
BOOL success = FALSE;
// if local file browsing is turned off, return without opening dialog
if ( check_local_file_access_enabled() == false )
{
return FALSE;
}
// don't provide default file selection
mFilesW[0] = '\0';
mOFN.hwndOwner = (HWND)gViewerWindow->getPlatformWindow();
mOFN.lpstrFile = mFilesW;
mOFN.nMaxFile = SINGLE_FILENAME_BUFFER_SIZE;
mOFN.Flags = OFN_HIDEREADONLY | OFN_FILEMUSTEXIST | OFN_NOCHANGEDIR ;
mOFN.nFilterIndex = 1;
setupFilter(filter);
if (blocking)
{
// Modal, so pause agent
send_agent_pause();
}
reset();
// NOTA BENE: hitting the file dialog triggers a window focus event, destroying the selection manager!!
success = GetOpenFileName(&mOFN);
if (success)
{
std::string filename = utf16str_to_utf8str(llutf16string(mFilesW));
mFiles.push_back(filename);
}
if (blocking)
{
send_agent_resume();
// Account for the fact that the app has been stalled.
LLFrameTimer::updateFrameTime();
}
return success;
}
ChewingEditor::ChewingEditor(QWidget *parent)
:QMainWindow{parent}
,ui_{new Ui::ChewingEditor}
,model_{new UserphraseModel{this}}
,proxyModel_{new UserphraseSortFilterProxyModel{this}}
,fileDialog_{new QFileDialog{this}}
{
ui_.get()->setupUi(this);
proxyModel_->setSourceModel(model_);
ui_.get()->userphraseView->setModel(proxyModel_);
setupFileSelection();
setupImport();
setupExport();
setupAdd();
setupRemove();
setupRefresh();
setupFilter();
setupAboutWidget();
}
ChewingEditor::ChewingEditor(QWidget *parent)
:QMainWindow{parent}
,ui_{new Ui::ChewingEditor}
,model_{new UserphraseModel{this}}
,proxyModel_{new UserphraseSortFilterProxyModel{this}}
,fileDialog_{new QFileDialog{this}}
{
ui_.get()->setupUi(this);
proxyModel_->setSourceModel(model_);
ui_.get()->userphraseView->setModel(proxyModel_);
setupFileSelection();
setupImport();
setupExport();
setupAdd();
setupRemove();
setupRefresh();
setupUndo();
setupFilter();
setupAboutWidget();
// exit action
shortcut_exit_ = new QShortcut(QKeySequence::Quit, this);
connect(
shortcut_exit_, SIGNAL(activated()),
SLOT(close())
);
connect(
ui_.get()->actionExit, SIGNAL(triggered()),
SLOT(close())
);
// modify action
shortcut_modify_ = new QShortcut(Qt::Key_Return, this);
connect(
shortcut_modify_, SIGNAL(activated()),
ui_.get()->userphraseView, SLOT(showModifyUserphraseDialog())
);
}
// process the image vector **images** and save output to **output_dir**
void
ConsoleBatch::process()
{
CommandLine const& cli = CommandLine::get();
int startFilterIdx = m_ptrStages->fixOrientationFilterIdx();
if (cli.hasStartFilterIdx()) {
unsigned int sf = cli.getStartFilterIdx();
if (sf<0 || sf>=m_ptrStages->filters().size())
throw std::runtime_error("Start filter out of range");
startFilterIdx = sf;
}
int endFilterIdx = m_ptrStages->outputFilterIdx();
if (cli.hasEndFilterIdx()) {
unsigned int ef = cli.getEndFilterIdx();
if (ef<0 || ef>=m_ptrStages->filters().size())
throw std::runtime_error("End filter out of range");
endFilterIdx = ef;
}
for (int j=startFilterIdx; j<=endFilterIdx; j++) {
if (cli.isVerbose())
std::cout << "Filter: " << (j+1) << "\n";
PageSequence page_sequence = m_ptrPages->toPageSequence(PAGE_VIEW);
setupFilter(j, page_sequence.selectAll());
for (unsigned i=0; i<page_sequence.numPages(); i++) {
PageInfo page = page_sequence.pageAt(i);
if (cli.isVerbose())
std::cout << "\tProcessing: " << page.imageId().filePath().toAscii().constData() << "\n";
BackgroundTaskPtr bgTask = createCompositeTask(page, j);
(*bgTask)();
}
}
}
BOOL LLFilePicker::getMultipleOpenFiles(ELoadFilter filter)
{
if( mLocked )
{
return FALSE;
}
BOOL success = FALSE;
// don't provide default file selection
mFilesW[0] = '\0';
mOFN.hwndOwner = (HWND)gViewerWindow->getPlatformWindow();
mOFN.lpstrFile = mFilesW;
mOFN.nFilterIndex = 1;
mOFN.nMaxFile = FILENAME_BUFFER_SIZE;
mOFN.Flags = OFN_HIDEREADONLY | OFN_FILEMUSTEXIST | OFN_NOCHANGEDIR |
OFN_EXPLORER | OFN_ALLOWMULTISELECT;
setupFilter(filter);
reset();
// Modal, so pause agent
send_agent_pause();
// NOTA BENE: hitting the file dialog triggers a window focus event, destroying the selection manager!!
success = GetOpenFileName(&mOFN); // pauses until ok or cancel.
if( success )
{
// The getopenfilename api doesn't tell us if we got more than
// one file, so we have to test manually by checking string
// lengths.
if( wcslen(mOFN.lpstrFile) > mOFN.nFileOffset ) /*Flawfinder: ignore*/
{
std::string filename = utf16str_to_utf8str(llutf16string(mFilesW));
mFiles.push_back(filename);
}
else
{
mLocked = TRUE;
WCHAR* tptrw = mFilesW;
std::string dirname;
while(1)
{
if (*tptrw == 0 && *(tptrw+1) == 0) // double '\0'
break;
if (*tptrw == 0)
tptrw++; // shouldn't happen?
std::string filename = utf16str_to_utf8str(llutf16string(tptrw));
if (dirname.empty())
dirname = filename + "\\";
else
mFiles.push_back(dirname + filename);
tptrw += filename.size();
}
}
}
send_agent_resume();
// Account for the fact that the app has been stalled.
LLFrameTimer::updateFrameTime();
return success;
}
void DRowAudioFilter::processBlock (AudioSampleBuffer& buffer,
MidiBuffer& midiMessages)
{
smoothParameters();
const int numInputChannels = getNumInputChannels();
int numSamples = buffer.getNumSamples();
// set up the parameters to be used
float preDelay = (float)params[PREDELAY].getSmoothedValue();
float earlyDecay = (float)params[EARLYDECAY].getSmoothedNormalisedValue();
earlyDecay = sqrt(sqrt(earlyDecay));
float late = (float)params[EARLYLATEMIX].getSmoothedNormalisedValue();
float early = 1.0f - late;
float fbCoeff = (float)params[FBCOEFF].getSmoothedNormalisedValue();
fbCoeff = -sqrt(sqrt(fbCoeff));
float delayTime = (float)params[DELTIME].getSmoothedValue();
float filterCf = (float)params[FILTERCF].getSmoothedValue();
float allpassCoeff = (float)params[DIFFUSION].getSmoothedNormalisedValue();
float spread1 = (float)params[SPREAD].getSmoothedNormalisedValue();
float spread2 = 1.0f - spread1;
float lowEQGain = (float)decibelsToAbsolute(params[LOWEQ].getSmoothedValue());
float highEQGain = (float)decibelsToAbsolute(params[HIGHEQ].getSmoothedValue());
float wet = (float)params[WETDRYMIX].getSmoothedNormalisedValue();
float dry = 1.0f - wet;
float width = (spread1-0.5f) * 0.1f * delayTime;
// we can only deal with 2-in, 2-out at the moment
if (numInputChannels == 2)
{
// pre-delay section
preDelayFilterL.setDelayTime(currentSampleRate, preDelay);
preDelayFilterR.setDelayTime(currentSampleRate, preDelay);
// early reflections section
int roomShape = roundFloatToInt(params[ROOMSHAPE].getValue());
float delayCoeff = 0.08f * delayTime;
if (roomShape != prevRoomShape)
{
delayLineL.removeAllTaps();
delayLineR.removeAllTaps();
for(int i = 0; i < 5; i++) {
delayLineL.addTapAtTime(earlyReflectionCoeffs[roomShape-3][i], currentSampleRate);
delayLineR.addTapAtTime(earlyReflectionCoeffs[roomShape-3][i], currentSampleRate);
}
// we have to set this here incase the delay time has not changed
delayLineL.setTapSpacingExplicitly(delayCoeff);
delayLineR.setTapSpacingExplicitly(delayCoeff + spread1);
prevRoomShape = roomShape;
}
delayLineL.setTapSpacing(delayCoeff);
delayLineL.scaleFeedbacks(earlyDecay);
delayLineR.setTapSpacing(delayCoeff + spread1);
delayLineR.scaleFeedbacks(earlyDecay);
// comb filter section
for (int i = 0; i < 8; ++i)
{
delayTime *= filterMultCoeffs[i];
delayTime += Random::getSystemRandom().nextInt(100)*0.0001;
setupFilter(combFilterL[i], fbCoeff, delayTime, filterCf);
setupFilter(combFilterR[i], fbCoeff, delayTime + width, filterCf);
}
// allpass section
for (int i = 0; i < 4; ++i)
{
delayTime *= allpassMultCoeffs[i];
delayTime -= Random::getSystemRandom().nextInt(100)*0.0001;
allpassFilterL[i].setGain(allpassCoeff);
allpassFilterL[i].setDelayTime(currentSampleRate, delayTime);
allpassFilterR[i].setGain(allpassCoeff);
allpassFilterR[i].setDelayTime(currentSampleRate, delayTime + width);
}
// final EQ section
lowEQL.makeLowShelf(currentSampleRate, 500, 1, lowEQGain);
lowEQR.makeLowShelf(currentSampleRate, 500, 1, lowEQGain);
highEQL.makeHighShelf(currentSampleRate, 3000, 1, highEQGain);
highEQR.makeHighShelf(currentSampleRate, 3000, 1, highEQGain);
//========================================================================
// Processing
//========================================================================
int noSamples = buffer.getNumSamples();
int noChannels = buffer.getNumChannels();
// create a copy of the input buffer so we can apply a wet/dry mix later
AudioSampleBuffer wetBuffer(noChannels, noSamples);
wetBuffer.copyFrom(0, 0, buffer, 0, 0, noSamples);
wetBuffer.copyFrom(1, 0, buffer, 1, 0, noSamples);
// mono mix wet buffer (used for stereo spread later)
float *pfWetL = wetBuffer.getSampleData(0);
float *pfWetR = wetBuffer.getSampleData(1);
while (--numSamples >= 0)
{
*pfWetL = *pfWetR = (0.5f * (*pfWetL + *pfWetR));
pfWetL++;
pfWetR++;
}
numSamples = buffer.getNumSamples();
// apply the pre-delay to the wet buffer
preDelayFilterL.processSamples(wetBuffer.getSampleData(0), noSamples);
preDelayFilterR.processSamples(wetBuffer.getSampleData(1), noSamples);
// create a buffer to hold the early reflections
AudioSampleBuffer earlyReflections(noChannels, noSamples);
earlyReflections.copyFrom(0, 0, wetBuffer, 0, 0, noSamples);
earlyReflections.copyFrom(1, 0, wetBuffer, 1, 0, noSamples);
// and process the early reflections
delayLineL.processSamples(earlyReflections.getSampleData(0), noSamples);
delayLineR.processSamples(earlyReflections.getSampleData(1), noSamples);
// create a buffer to hold the late reverb
AudioSampleBuffer lateReverb(noChannels, noSamples);
lateReverb.clear();
float *pfLateL = lateReverb.getSampleData(0);
float *pfLateR = lateReverb.getSampleData(1);
pfWetL = wetBuffer.getSampleData(0);
pfWetR = wetBuffer.getSampleData(1);
// comb filter section
for (int i = 0; i < 8; ++i)
{
combFilterL[i].processSamplesAdding(pfWetL, pfLateL, noSamples);
combFilterR[i].processSamplesAdding(pfWetR, pfLateR, noSamples);
}
// allpass filter section
for (int i = 0; i < 4; ++i)
{
allpassFilterL[i].processSamples(lateReverb.getSampleData(0), noSamples);
allpassFilterR[i].processSamples(lateReverb.getSampleData(1), noSamples);
}
// clear wet buffer
wetBuffer.clear();
// add early reflections to wet buffer
wetBuffer.addFrom(0, 0, earlyReflections, 0, 0, noSamples, early);
wetBuffer.addFrom(1, 0, earlyReflections, 1, 0, noSamples, early);
// add late reverb to wet buffer
lateReverb.applyGain(0, noSamples, 0.1f);
wetBuffer.addFrom(0, 0, lateReverb, 0, 0, noSamples, late);
wetBuffer.addFrom(1, 0, lateReverb, 1, 0, noSamples, late);
// final EQ
lowEQL.processSamples(pfWetL, noSamples);
lowEQR.processSamples(pfWetR, noSamples);
highEQL.processSamples(pfWetL, noSamples);
highEQR.processSamples(pfWetR, noSamples);
// create stereo spread
while (--numSamples >= 0)
{
float fLeft = *pfWetL;
float fRight = *pfWetR;
*pfWetL = (fLeft * spread1) + (fRight * spread2);
*pfWetR = (fRight * spread1) + (fLeft * spread2);
pfWetL++;
pfWetR++;
}
numSamples = buffer.getNumSamples();
// apply wet/dry mix gains
wetBuffer.applyGain(0, noSamples, wet);
buffer.applyGain(0, noSamples, dry);
// add wet buffer to output buffer
buffer.addFrom(0, 0, wetBuffer, 0, 0, noSamples);
buffer.addFrom(1, 0, wetBuffer, 1, 0, noSamples);
}
//========================================================================
// in case we have more outputs than inputs, we'll clear any output
// channels that didn't contain input data, (because these aren't
// guaranteed to be empty - they may contain garbage).
for (int i = getNumInputChannels(); i < getNumOutputChannels(); ++i)
{
buffer.clear (i, 0, buffer.getNumSamples());
}
}
