steve
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/external_dependencies/openmpt-trunk/mptrack/SampleGenerator.cpp

738 lines
21 KiB
C++
Raw Blame History

/*
* SampleGenerator.cpp
* -------------------
* Purpose: Generate samples from math formulas using muParser
* Notes : (currently none)
* Authors: OpenMPT Devs
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
*/
#include "stdafx.h"
#if MPT_DISABLED_CODE
#include "SampleGenerator.h"
#include "modsmp_ctrl.h"
int CSampleGenerator::sample_frequency = 44100;
int CSampleGenerator::sample_length = CSampleGenerator::sample_frequency;
mu::string_type CSampleGenerator::expression = _T("sin(xp * _pi)");
smpgen_clip_methods CSampleGenerator::sample_clipping = smpgen_normalize;
mu::value_type *CSampleGenerator::sample_buffer = nullptr;
size_t CSampleGenerator::samples_written = 0;
CSampleGenerator::CSampleGenerator()
{
// Setup function callbacks
muParser.DefineFun(_T("clip"), &ClipCallback, false);
muParser.DefineFun(_T("pwm"), &PWMCallback, false);
muParser.DefineFun(_T("rnd"), &RndCallback, false);
muParser.DefineFun(_T("smp"), &SampleDataCallback, false);
muParser.DefineFun(_T("tri"), &TriangleCallback, false);
// Setup binary operator callbacks
muParser.DefineOprt(_T("mod"), &ModuloCallback, 0);
//muParser.DefineConst("pi", (mu::value_type)PARSER_CONST_PI);
}
// Open the smpgen dialog
bool CSampleGenerator::ShowDialog()
{
bool isDone = false, result = false;
while(!isDone)
{
CSmpGenDialog dlg(sample_frequency, sample_length, sample_clipping, expression);
dlg.DoModal();
// pressed "OK" button?
if(dlg.CanApply())
{
sample_frequency = dlg.GetFrequency();
sample_length = dlg.GetLength();
sample_clipping = dlg.GetClipping();
expression = dlg.GetExpression();
isDone = CanRenderSample();
if(isDone) isDone = TestExpression(); // show dialog again if the formula can't be parsed.
result = true;
} else
{
isDone = true; // just quit.
result = false;
}
}
return result;
}
// Check if the currently select expression can be parsed by muParser.
bool CSampleGenerator::TestExpression()
{
// reset helper variables
samples_written = 0;
sample_buffer = nullptr;
muParser.SetExpr(expression);
mu::value_type x = 0;
muParser.DefineVar(_T("x"), &x);
muParser.DefineVar(_T("xp"), &x);
muParser.DefineVar(_T("len"), &x);
muParser.DefineVar(_T("lens"), &x);
muParser.DefineVar(_T("freq"), &x);
try
{
muParser.Eval();
}
catch (mu::Parser::exception_type &e)
{
ShowError(&e);
return false;
}
return true;
}
// Check if sample parameters are valid.
bool CSampleGenerator::CanRenderSample() const
{
if(sample_frequency < SMPGEN_MINFREQ || sample_frequency > SMPGEN_MAXFREQ || sample_length < SMPGEN_MINLENGTH || sample_length > SMPGEN_MAXLENGTH) return false;
return true;
}
// Actual render loop.
bool CSampleGenerator::RenderSample(CSoundFile *pSndFile, SAMPLEINDEX nSample)
{
if(!CanRenderSample() || !TestExpression() || (pSndFile == nullptr) || (nSample < 1) || (nSample > pSndFile->m_nSamples)) return false;
// allocate a new buffer
sample_buffer = (mu::value_type *)malloc(sample_length * sizeof(mu::value_type));
if(sample_buffer == nullptr) return false;
memset(sample_buffer, 0, sample_length * sizeof(mu::value_type));
mu::value_type x = 0, xp = 0;
mu::value_type v_len = sample_length, v_freq = sample_frequency, v_lens = v_len / v_freq;
muParser.DefineVar(_T("x"), &x);
muParser.DefineVar(_T("xp"), &xp);
muParser.DefineVar(_T("len"), &v_len);
muParser.DefineVar(_T("lens"), &v_lens);
muParser.DefineVar(_T("freq"), &v_freq);
bool success = true;
mu::value_type minmax = 0;
for(size_t i = 0; i < (size_t)sample_length; i++)
{
samples_written = i;
x = (mu::value_type)i;
xp = x * 100 / sample_length;
try
{
sample_buffer[i] = muParser.Eval();
}
catch (mu::Parser::exception_type &e)
{
// let's just ignore div by zero errors (note: this error code is currently unused (muParser 1.30))
if(e.GetCode() != mu::ecDIV_BY_ZERO)
{
ShowError(&e);
success = false;
break;
}
sample_buffer[i] = 0;
}
// new maximum value?
if(std::abs(sample_buffer[i]) > minmax) minmax = std::abs(sample_buffer[i]);
}
if(success)
{
MODSAMPLE *pModSample = &pSndFile->Samples[nSample];
BEGIN_CRITICAL();
// first, save some memory... (leads to crashes)
//CSoundFile::FreeSample(pModSample->pSample);
//pModSample->pSample = nullptr;
if(minmax == 0) minmax = 1; // avoid division by 0
// convert sample to 16-bit (or whateve rhas been specified)
int16 *pSample = (sampling_type *)CSoundFile::AllocateSample((sample_length + 4) * SMPGEN_MIXBYTES);
for(size_t i = 0; i < (size_t)sample_length; i++)
{
switch(sample_clipping)
{
case smpgen_clip: sample_buffer[i] = CLAMP(sample_buffer[i], -1, 1); break; // option 1: clip
case smpgen_normalize: sample_buffer[i] /= minmax; break; // option 3: normalize
}
pSample[i] = (sampling_type)(sample_buffer[i] * sample_maxvalue);
}
// set new sample proprerties
pModSample->nC5Speed = sample_frequency;
CSoundFile::FrequencyToTranspose(pModSample);
pModSample->uFlags |= CHN_16BIT; // has to be adjusted if SMPGEN_MIXBYTES changes!
pModSample->uFlags &= ~(CHN_STEREO|CHN_SUSTAINLOOP|CHN_PINGPONGSUSTAIN);
pModSample->nLoopStart = 0;
pModSample->nLoopEnd = sample_length;
pModSample->nSustainStart = pModSample->nSustainEnd = 0;
if(sample_length / sample_frequency < 5) // arbitrary limit for automatic sample loop (5 seconds)
pModSample->uFlags |= CHN_LOOP;
else
pModSample->uFlags &= ~(CHN_LOOP|CHN_PINGPONGLOOP);
ctrlSmp::ReplaceSample(*pModSample, (LPSTR)pSample, sample_length, pSndFile);
END_CRITICAL();
}
free(sample_buffer);
sample_buffer = nullptr;
return success;
}
// Callback function to access sample data
mu::value_type CSampleGenerator::SampleDataCallback(mu::value_type v)
{
if(sample_buffer == nullptr) return 0;
v = CLAMP(v, 0, samples_written);
size_t pos = static_cast<size_t>(v);
return sample_buffer[pos];
}
void CSampleGenerator::ShowError(mu::Parser::exception_type *e)
{
std::string errmsg;
errmsg = "The expression\n " + e->GetExpr() + "\ncontains an error ";
if(!e->GetToken().empty())
errmsg += "in the token\n " + e->GetToken() + "\n";
errmsg += "at position " + Stringify(e->GetPos()) + ".\nThe error message was: " + e->GetMsg();
::MessageBox(0, errmsg.c_str(), _T("muParser Sample Generator"), 0);
}
//////////////////////////////////////////////////////////////////////////
// Sample Generator Dialog implementation
#define MAX_SAMPLEGEN_EXPRESSIONS 61
BEGIN_MESSAGE_MAP(CSmpGenDialog, CDialog)
ON_EN_CHANGE(IDC_EDIT_SAMPLE_LENGTH, &CSmpGenDialog::OnSampleLengthChanged)
ON_EN_CHANGE(IDC_EDIT_SAMPLE_LENGTH_SEC, &CSmpGenDialog::OnSampleSecondsChanged)
ON_EN_CHANGE(IDC_EDIT_SAMPLE_FREQ, &CSmpGenDialog::OnSampleFreqChanged)
ON_EN_CHANGE(IDC_EDIT_FORMULA, &CSmpGenDialog::OnExpressionChanged)
ON_COMMAND(IDC_BUTTON_SHOW_EXPRESSIONS, &CSmpGenDialog::OnShowExpressions)
ON_COMMAND(IDC_BUTTON_SAMPLEGEN_PRESETS, &CSmpGenDialog::OnShowPresets)
ON_COMMAND_RANGE(ID_SAMPLE_GENERATOR_MENU, ID_SAMPLE_GENERATOR_MENU + MAX_SAMPLEGEN_EXPRESSIONS - 1, &CSmpGenDialog::OnInsertExpression)
ON_COMMAND_RANGE(ID_SAMPLE_GENERATOR_PRESET_MENU, ID_SAMPLE_GENERATOR_PRESET_MENU + MAX_SAMPLEGEN_PRESETS + 1, &CSmpGenDialog::OnSelectPreset)
END_MESSAGE_MAP()
// List of all possible expression for expression menu
const samplegen_expression menu_descriptions[MAX_SAMPLEGEN_EXPRESSIONS] =
{
{"Variables", ""},
{"Current position (sampling point)", "x"},
{"Current position (percentage)", "xp"},
{"Sample length", "len"},
{"Sample length (seconds)", "lens"},
{"Sampling frequency", "freq"},
{"Constants", ""},
{"Pi", "_pi"},
{"e", "_e"},
{"Trigonometric functions", ""},
{"Sine", "sin(x)"},
{"Cosine", "cos(x)"},
{"Tangens", "tan(x)"},
{"Arcus Sine", "asin(x)"},
{"Arcus Cosine", "acos(x)"},
{"Arcus Tangens", "atan(x)"},
{"Hyperbolic Sine", "sinh(x)"},
{"Hyperbolic Cosine", "cosh(x)"},
{"Hyperbolic Tangens", "tanh(x)"},
{"Hyperbolic Arcus Sine", "asinh(x)"},
{"Hyperbolic Arcus Cosine", "acosh(x)"},
{"Hyperbolic Arcus Tangens", "atanh(x)"},
{"Log, Exp, Root", ""},
{"Logarithm (base 2)", "log2(x)"},
{"Logarithm (base 10)", "log(x)"},
{"Natural Logarithm (base e)", "ln(x)"},
{"e^x", "exp(x)"},
{"Square Root", "sqrt(x)"},
{"Sign and rounding", ""},
{"Sign", "sign(x)"},
{"Absolute value", "abs(x)"},
{"Round to nearest integer", "rint(x)"},
{"Sets", ""},
{"Minimum", "min(x, y, ...)"},
{"Maximum", "max(x, y, ...)"},
{"Sum", "sum(x, y, ...)"},
{"Mean value", "avg(x, y, ...)"},
{"Misc functions", ""},
{"Pulse generator", "pwm(position, duty%, width)"},
{"Triangle", "tri(position, width)"},
{"Random value between 0 and x", "rnd(x)"},
{"Access previous sampling point", "smp(position)"},
{"Clip between values", "clip(value, minclip, maxclip)"},
{"If...Then...Else", "if(condition, statement1, statement2)"},
{"Operators", ""},
{"Assignment", "x = y"},
{"Logical And", "x abd y"},
{"Logical Or", "x or y"},
{"Logical Xor", "x xor y"},
{"Less or equal", "x <= y"},
{"Greater or equal", "x >= y"},
{"Not equal", "x != y"},
{"Equal", "x == y"},
{"Greater than", "x > y"},
{"Less than", "x < y"},
{"Addition", "x + y"},
{"Subtraction", "x - y"},
{"Multiplication", "x * y"},
{"Division", "x / y"},
{"x^y", "x ^ y"},
{"Modulo", "x mod y"},
};
BOOL CSmpGenDialog::OnInitDialog()
{
CDialog::OnInitDialog();
RecalcParameters(false, true);
SetDlgItemText(IDC_EDIT_FORMULA, expression.c_str());
int check = IDC_RADIO_SMPCLIP1;
switch(sample_clipping)
{
case smpgen_clip: check = IDC_RADIO_SMPCLIP1; break;
case smpgen_overflow: check = IDC_RADIO_SMPCLIP2; break;
case smpgen_normalize: check = IDC_RADIO_SMPCLIP3; break;
}
CheckRadioButton(IDC_RADIO_SMPCLIP1, IDC_RADIO_SMPCLIP3, check);
if(presets.GetNumPresets() == 0)
{
CreateDefaultPresets();
}
// Create font for "dropdown" button (Marlett system font)
hButtonFont = CreateFont(14, 0, 0, 0, FW_DONTCARE, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, FF_DONTCARE, TEXT("Marlett"));
::SendMessage(GetDlgItem(IDC_BUTTON_SHOW_EXPRESSIONS)->m_hWnd, WM_SETFONT, (WPARAM)hButtonFont, MAKELPARAM(TRUE, 0));
return TRUE;
}
void CSmpGenDialog::OnOK()
{
CDialog::OnOK();
apply = true;
int check = GetCheckedRadioButton(IDC_RADIO_SMPCLIP1, IDC_RADIO_SMPCLIP3);
switch(check)
{
case IDC_RADIO_SMPCLIP1: sample_clipping = smpgen_clip; break;
case IDC_RADIO_SMPCLIP2: sample_clipping = smpgen_overflow; break;
case IDC_RADIO_SMPCLIP3: sample_clipping = smpgen_normalize; break;
}
DeleteObject(hButtonFont);
}
void CSmpGenDialog::OnCancel()
{
CDialog::OnCancel();
apply = false;
}
// User changed formula
void CSmpGenDialog::OnExpressionChanged()
{
CString result;
GetDlgItemText(IDC_EDIT_FORMULA, result);
expression = result;
}
// User changed sample length field
void CSmpGenDialog::OnSampleLengthChanged()
{
int temp_length = GetDlgItemInt(IDC_EDIT_SAMPLE_LENGTH);
if(temp_length >= SMPGEN_MINLENGTH && temp_length <= SMPGEN_MAXLENGTH)
{
sample_length = temp_length;
RecalcParameters(false);
}
}
// User changed sample length (seconds) field
void CSmpGenDialog::OnSampleSecondsChanged()
{
CString str;
GetDlgItemText(IDC_EDIT_SAMPLE_LENGTH_SEC, str);
double temp_seconds = atof(str);
if(temp_seconds > 0)
{
sample_seconds = temp_seconds;
RecalcParameters(true);
}
}
// User changed sample frequency field
void CSmpGenDialog::OnSampleFreqChanged()
{
int temp_freq = GetDlgItemInt(IDC_EDIT_SAMPLE_FREQ);
if(temp_freq >= SMPGEN_MINFREQ && temp_freq <= SMPGEN_MAXFREQ)
{
sample_frequency = temp_freq;
RecalcParameters(false);
}
}
// Show all expressions that can be input
void CSmpGenDialog::OnShowExpressions()
{
HMENU hMenu = ::CreatePopupMenu(), hSubMenu = NULL;
if(!hMenu) return;
for(int i = 0; i < MAX_SAMPLEGEN_EXPRESSIONS; i++)
{
if(menu_descriptions[i].expression == "")
{
// add sub menu
if(hSubMenu != NULL) ::DestroyMenu(hSubMenu);
hSubMenu = ::CreatePopupMenu();
AppendMenu(hMenu, MF_POPUP, (UINT_PTR)hSubMenu, menu_descriptions[i].description.c_str());
} else
{
// add sub menu entry (formula)
AppendMenu(hSubMenu, MF_STRING, ID_SAMPLE_GENERATOR_MENU + i, menu_descriptions[i].description.c_str());
}
}
// place popup menu below button
RECT button;
GetDlgItem(IDC_BUTTON_SHOW_EXPRESSIONS)->GetWindowRect(&button);
::TrackPopupMenu(hMenu, TPM_LEFTALIGN | TPM_RIGHTBUTTON, button.left, button.bottom, 0, m_hWnd, NULL);
::DestroyMenu(hMenu);
::DestroyMenu(hSubMenu);
}
// Show all expression presets
void CSmpGenDialog::OnShowPresets()
{
HMENU hMenu = ::CreatePopupMenu();
if(!hMenu) return;
bool prestsExist = false;
for(size_t i = 0; i < presets.GetNumPresets(); i++)
{
if(presets.GetPreset(i)->expression != "")
{
AppendMenu(hMenu, MF_STRING, ID_SAMPLE_GENERATOR_PRESET_MENU + i, presets.GetPreset(i)->description.c_str());
prestsExist = true;
}
}
if(prestsExist) AppendMenu(hMenu, MF_SEPARATOR, 0, NULL);
AppendMenu(hMenu, MF_STRING, ID_SAMPLE_GENERATOR_PRESET_MENU + MAX_SAMPLEGEN_PRESETS, _TEXT("Manage..."));
CString result;
GetDlgItemText(IDC_EDIT_FORMULA, result);
if((!result.IsEmpty()) && (presets.GetNumPresets() < MAX_SAMPLEGEN_PRESETS))
{
AppendMenu(hMenu, MF_STRING, ID_SAMPLE_GENERATOR_PRESET_MENU + MAX_SAMPLEGEN_PRESETS + 1, _TEXT("Add current..."));
}
// place popup menu below button
RECT button;
GetDlgItem(IDC_BUTTON_SAMPLEGEN_PRESETS)->GetWindowRect(&button);
::TrackPopupMenu(hMenu, TPM_LEFTALIGN | TPM_RIGHTBUTTON, button.left, button.bottom, 0, m_hWnd, NULL);
::DestroyMenu(hMenu);
}
// Insert expression from context menu
void CSmpGenDialog::OnInsertExpression(UINT nId)
{
if((nId < ID_SAMPLE_GENERATOR_MENU) || (nId >= ID_SAMPLE_GENERATOR_MENU + MAX_SAMPLEGEN_EXPRESSIONS)) return;
expression += " " + menu_descriptions[nId - ID_SAMPLE_GENERATOR_MENU].expression;
SetDlgItemText(IDC_EDIT_FORMULA, expression.c_str());
}
// Select a preset (or manage them, or add one)
void CSmpGenDialog::OnSelectPreset(UINT nId)
{
if((nId < ID_SAMPLE_GENERATOR_PRESET_MENU) || (nId >= ID_SAMPLE_GENERATOR_PRESET_MENU + MAX_SAMPLEGEN_PRESETS + 2)) return;
if(nId - ID_SAMPLE_GENERATOR_PRESET_MENU >= MAX_SAMPLEGEN_PRESETS)
{
// add...
if((nId - ID_SAMPLE_GENERATOR_PRESET_MENU == MAX_SAMPLEGEN_PRESETS + 1))
{
samplegen_expression newPreset;
newPreset.description = newPreset.expression = expression;
presets.AddPreset(newPreset);
// call preset manager now.
}
// manage...
CSmpGenPresetDlg dlg(&presets);
dlg.DoModal();
} else
{
expression = presets.GetPreset(nId - ID_SAMPLE_GENERATOR_PRESET_MENU)->expression;
SetDlgItemText(IDC_EDIT_FORMULA, expression.c_str());
}
}
// Update input fields, depending on what has been chagned
void CSmpGenDialog::RecalcParameters(bool secondsChanged, bool forceRefresh)
{
static bool isLocked = false;
if(isLocked) return;
isLocked = true; // avoid deadlock
if(secondsChanged)
{
// seconds changed => recalc length
sample_length = (int)(sample_seconds * sample_frequency);
if(sample_length < SMPGEN_MINLENGTH || sample_length > SMPGEN_MAXLENGTH) sample_length = SMPGEN_MAXLENGTH;
} else
{
// length/freq changed => recalc seconds
sample_seconds = ((double)sample_length) / ((double)sample_frequency);
}
if(secondsChanged || forceRefresh) SetDlgItemInt(IDC_EDIT_SAMPLE_LENGTH, sample_length);
if(secondsChanged || forceRefresh) SetDlgItemInt(IDC_EDIT_SAMPLE_FREQ, sample_frequency);
CString str;
str.Format("%.4f", sample_seconds);
if(!secondsChanged || forceRefresh) SetDlgItemText(IDC_EDIT_SAMPLE_LENGTH_SEC, str);
int smpsize = sample_length * SMPGEN_MIXBYTES;
if(smpsize < 1024)
{
str.Format("Sample Size: %d Bytes", smpsize);
} else if((smpsize >> 10) < 1024)
{
str.Format("Sample Size: %d KB", smpsize >> 10);
} else
{
str.Format("Sample Size: %d MB", smpsize >> 20);
}
SetDlgItemText(IDC_STATIC_SMPSIZE_KB, str);
isLocked = false;
}
// Create a set of default formla presets
void CSmpGenDialog::CreateDefaultPresets()
{
samplegen_expression preset;
preset.description = "A440";
preset.expression = "sin(xp * _pi / 50 * 440 * len / freq)";
presets.AddPreset(preset);
preset.description = "Brown Noise (kind of)";
preset.expression = "rnd(1) * 0.1 + smp(x - 1) * 0.9";
presets.AddPreset(preset);
preset.description = "Noisy Saw";
preset.expression = "(x mod 800) / 800 - 0.5 + rnd(0.1)";
presets.AddPreset(preset);
preset.description = "PWM Filter";
preset.expression = "pwm(x, 50 + sin(xp * _pi / 100) * 40, 100) + tri(x, 50)";
presets.AddPreset(preset);
preset.description = "Fat PWM Pad";
preset.expression = "pwm(x, xp, 500) + pwm(x, abs(50 - xp), 1000)";
presets.AddPreset(preset);
preset.description = "Dual Square";
preset.expression = "if((x mod 100) < 50, (x mod 200), -x mod 200)";
presets.AddPreset(preset);
preset.description = "Noise Hit";
preset.expression = "exp(-xp) * (rnd(x) - x / 2)";
presets.AddPreset(preset);
preset.description = "Laser";
preset.expression = "sin(xp * _pi * 100 /(xp ^ 2)) * 100 / sqrt(xp)";
presets.AddPreset(preset);
preset.description = "Noisy Laser Hit";
preset.expression = "(sin(sqrt(xp) * 100) + rnd(1) - 0.5) * exp(-xp / 10)";
presets.AddPreset(preset);
preset.description = "Twinkle, Twinkle...";
preset.expression = "sin(xp * _pi * 100 / xp) * 100 / sqrt(xp)";
presets.AddPreset(preset);
preset.description = "FM Tom";
preset.expression = "sin(xp * _pi * 2 + (xp / 5 - 50) ^ 2) * exp(-xp / 10)";
presets.AddPreset(preset);
preset.description = "FM Warp";
preset.expression = "sin(_pi * xp / 2 * (1 + (1 + sin(_pi * xp / 4 * 50)) / 4)) * exp(-(xp / 8) * .6)";
presets.AddPreset(preset);
preset.description = "Weird Noise";
preset.expression = "rnd(1) * 0.1 + smp(x - rnd(xp)) * 0.9";
presets.AddPreset(preset);
}
//////////////////////////////////////////////////////////////////////////
// Sample Generator Preset Dialog implementation
BEGIN_MESSAGE_MAP(CSmpGenPresetDlg, CDialog)
ON_COMMAND(IDC_BUTTON_ADD, &CSmpGenPresetDlg::OnAddPreset)
ON_COMMAND(IDC_BUTTON_REMOVE, &CSmpGenPresetDlg::OnRemovePreset)
ON_EN_CHANGE(IDC_EDIT_PRESET_NAME, &CSmpGenPresetDlg::OnTextChanged)
ON_EN_CHANGE(IDC_EDIT_PRESET_EXPR, &CSmpGenPresetDlg::OnExpressionChanged)
ON_LBN_SELCHANGE(IDC_LIST_SAMPLEGEN_PRESETS, &CSmpGenPresetDlg::OnListSelChange)
END_MESSAGE_MAP()
BOOL CSmpGenPresetDlg::OnInitDialog()
{
CDialog::OnInitDialog();
RefreshList();
return TRUE;
}
void CSmpGenPresetDlg::OnOK()
{
// remove empty presets
for(size_t i = 0; i < presets->GetNumPresets(); i++)
{
if(presets->GetPreset(i)->expression.empty())
{
presets->RemovePreset(i);
}
}
CDialog::OnOK();
}
void CSmpGenPresetDlg::OnListSelChange()
{
currentItem = ((CListBox *)GetDlgItem(IDC_LIST_SAMPLEGEN_PRESETS))->GetCurSel() + 1;
if(currentItem == 0 || currentItem > presets->GetNumPresets()) return;
samplegen_expression *preset = presets->GetPreset(currentItem - 1);
if(preset == nullptr) return;
SetDlgItemText(IDC_EDIT_PRESET_NAME, preset->description.c_str());
SetDlgItemText(IDC_EDIT_PRESET_EXPR, preset->expression.c_str());
}
void CSmpGenPresetDlg::OnTextChanged()
{
if(currentItem == 0 || currentItem > presets->GetNumPresets()) return;
CString result;
GetDlgItemText(IDC_EDIT_PRESET_NAME, result);
samplegen_expression *preset = presets->GetPreset(currentItem - 1);
if(preset == nullptr) return;
preset->description = result;
CListBox *clist = (CListBox *)GetDlgItem(IDC_LIST_SAMPLEGEN_PRESETS);
clist->DeleteString(currentItem - 1);
clist->InsertString(currentItem - 1, (preset->description).c_str());
clist->SetCurSel(currentItem - 1);
}
void CSmpGenPresetDlg::OnExpressionChanged()
{
if(currentItem == 0 || currentItem > presets->GetNumPresets()) return;
CString result;
GetDlgItemText(IDC_EDIT_PRESET_EXPR, result);
samplegen_expression *preset = presets->GetPreset(currentItem - 1);
if(preset != nullptr) preset->expression = result;
}
void CSmpGenPresetDlg::OnAddPreset()
{
samplegen_expression newPreset;
newPreset.description = "New Preset";
newPreset.expression = "";
if(presets->AddPreset(newPreset))
{
currentItem = presets->GetNumPresets();
RefreshList();
}
}
void CSmpGenPresetDlg::OnRemovePreset()
{
if(currentItem == 0 || currentItem > presets->GetNumPresets()) return;
if(presets->RemovePreset(currentItem - 1))
RefreshList();
}
void CSmpGenPresetDlg::RefreshList()
{
CListBox *clist = (CListBox *)GetDlgItem(IDC_LIST_SAMPLEGEN_PRESETS);
clist->SetRedraw(FALSE); //disable lisbox refreshes during fill to avoid flicker
clist->ResetContent();
for(size_t i = 0; i < presets->GetNumPresets(); i++)
{
samplegen_expression *preset = presets->GetPreset(i);
if(preset != nullptr)
clist->AddString((preset->description).c_str());
}
clist->SetRedraw(TRUE); //re-enable lisbox refreshes
if(currentItem == 0 || currentItem > presets->GetNumPresets())
{
currentItem = presets->GetNumPresets();
}
if(currentItem != 0) clist->SetCurSel(currentItem - 1);
OnListSelChange();
}
#endif // MPT_DISABLED_CODE
Reference in New Issue View Git Blame Copy Permalink