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/PatternFindReplaceDlg.cpp

953 lines
28 KiB
C++
Raw Blame History

/*
* PatternFindReplaceDlg.cpp
* -------------------------
* Purpose: The find/replace dialog for pattern data.
* Notes : (currently none)
* Authors: Olivier Lapicque
* OpenMPT Devs
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
*/
#include "stdafx.h"
#include "Mptrack.h"
#include "Mainfrm.h"
#include "View_pat.h"
#include "PatternFindReplace.h"
#include "PatternFindReplaceDlg.h"
OPENMPT_NAMESPACE_BEGIN
// CFindRangeDlg: Find a range of values.
class CFindRangeDlg : public CDialog
{
public:
enum DisplayMode
{
kDecimal,
kHex,
kNotes,
};
protected:
CComboBox m_cbnMin, m_cbnMax;
int m_minVal, m_minDefault;
int m_maxVal, m_maxDefault;
DisplayMode m_displayMode;
public:
CFindRangeDlg(CWnd *parent, int minVal, int minDefault, int maxVal, int maxDefault, DisplayMode displayMode) : CDialog(IDD_FIND_RANGE, parent)
, m_minVal(minVal)
, m_minDefault(minDefault)
, m_maxVal(maxVal)
, m_maxDefault(maxDefault)
, m_displayMode(displayMode)
{ }
int GetMinVal() const { return m_minVal; }
int GetMaxVal() const { return m_maxVal; }
protected:
virtual void DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
DDX_Control(pDX, IDC_COMBO1, m_cbnMin);
DDX_Control(pDX, IDC_COMBO2, m_cbnMax);
}
virtual BOOL OnInitDialog()
{
CDialog::OnInitDialog();
if(m_displayMode == kNotes)
{
AppendNotesToControl(m_cbnMin, static_cast<ModCommand::NOTE>(m_minVal), static_cast<ModCommand::NOTE>(m_maxVal));
AppendNotesToControl(m_cbnMax, static_cast<ModCommand::NOTE>(m_minVal), static_cast<ModCommand::NOTE>(m_maxVal));
} else
{
m_cbnMin.InitStorage(m_minVal - m_maxVal + 1, 4);
m_cbnMax.InitStorage(m_minVal - m_maxVal + 1, 4);
const TCHAR *formatString;
if(m_displayMode == kHex && m_maxVal <= 0x0F)
formatString = _T("%01X");
else if(m_displayMode == kHex)
formatString = _T("%02X");
else
formatString = _T("%d");
for(int i = m_minVal; i <= m_maxVal; i++)
{
TCHAR s[16];
wsprintf(s, formatString, i);
m_cbnMin.SetItemData(m_cbnMin.AddString(s), i);
m_cbnMax.SetItemData(m_cbnMax.AddString(s), i);
}
}
if(m_minDefault < m_minVal || m_minDefault > m_maxDefault)
{
m_minDefault = m_minVal;
m_maxDefault = m_maxVal;
}
m_cbnMin.SetCurSel(m_minDefault - m_minVal);
m_cbnMax.SetCurSel(m_maxDefault - m_minVal);
return TRUE;
}
virtual void OnOK()
{
CDialog::OnOK();
m_minVal = static_cast<int>(m_cbnMin.GetItemData(m_cbnMin.GetCurSel()));
m_maxVal = static_cast<int>(m_cbnMax.GetItemData(m_cbnMax.GetCurSel()));
if(m_maxVal < m_minVal)
std::swap(m_minVal, m_maxVal);
}
};
BEGIN_MESSAGE_MAP(CFindReplaceTab, CPropertyPage)
ON_CBN_SELCHANGE(IDC_COMBO1, &CFindReplaceTab::OnNoteChanged)
ON_CBN_SELCHANGE(IDC_COMBO2, &CFindReplaceTab::OnInstrChanged)
ON_CBN_SELCHANGE(IDC_COMBO3, &CFindReplaceTab::OnVolCmdChanged)
ON_CBN_SELCHANGE(IDC_COMBO4, &CFindReplaceTab::OnVolumeChanged)
ON_CBN_SELCHANGE(IDC_COMBO5, &CFindReplaceTab::OnEffectChanged)
ON_CBN_SELCHANGE(IDC_COMBO6, &CFindReplaceTab::OnParamChanged)
ON_CBN_SELCHANGE(IDC_COMBO7, &CFindReplaceTab::OnPCParamChanged)
ON_CBN_EDITCHANGE(IDC_COMBO4, &CFindReplaceTab::OnVolumeChanged)
ON_CBN_EDITCHANGE(IDC_COMBO6, &CFindReplaceTab::OnParamChanged)
ON_COMMAND(IDC_CHECK1, &CFindReplaceTab::OnCheckNote)
ON_COMMAND(IDC_CHECK2, &CFindReplaceTab::OnCheckInstr)
ON_COMMAND(IDC_CHECK3, &CFindReplaceTab::OnCheckVolCmd)
ON_COMMAND(IDC_CHECK4, &CFindReplaceTab::OnCheckVolume)
ON_COMMAND(IDC_CHECK5, &CFindReplaceTab::OnCheckEffect)
ON_COMMAND(IDC_CHECK6, &CFindReplaceTab::OnCheckParam)
ON_COMMAND(IDC_CHECK7, &CFindReplaceTab::OnCheckChannelSearch)
END_MESSAGE_MAP()
void CFindReplaceTab::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
DDX_Control(pDX, IDC_COMBO1, m_cbnNote);
DDX_Control(pDX, IDC_COMBO2, m_cbnInstr);
DDX_Control(pDX, IDC_COMBO3, m_cbnVolCmd);
DDX_Control(pDX, IDC_COMBO4, m_cbnVolume);
DDX_Control(pDX, IDC_COMBO5, m_cbnCommand);
DDX_Control(pDX, IDC_COMBO6, m_cbnParam);
DDX_Control(pDX, IDC_COMBO7, m_cbnPCParam);
}
BOOL CFindReplaceTab::OnInitDialog()
{
CString s;
CPropertyPage::OnInitDialog();
// Search flags
FlagSet<FindReplace::Flags> flags = m_isReplaceTab ? m_settings.replaceFlags : m_settings.findFlags;
COMBOBOXINFO info;
info.cbSize = sizeof(info);
if(m_cbnVolume.GetComboBoxInfo(&info))
{
::SetWindowLong(info.hwndItem, GWL_STYLE, ::GetWindowLong(info.hwndItem, GWL_STYLE) | ES_NUMBER);
::SendMessage(info.hwndItem, EM_SETLIMITTEXT, 4, 0);
}
if(m_cbnParam.GetComboBoxInfo(&info))
{
// Might need to enter hex values
//::SetWindowLong(info.hwndItem, GWL_STYLE, ::GetWindowLong(info.hwndItem, GWL_STYLE) | ES_NUMBER);
::SendMessage(info.hwndItem, EM_SETLIMITTEXT, 4, 0);
}
CheckDlgButton(IDC_CHECK1, flags[FindReplace::Note] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(IDC_CHECK2, flags[FindReplace::Instr] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(IDC_CHECK3, flags[FindReplace::VolCmd | FindReplace::PCParam] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(IDC_CHECK4, flags[FindReplace::Volume | FindReplace::PCValue] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(IDC_CHECK5, flags[FindReplace::Command] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(IDC_CHECK6, flags[FindReplace::Param] ? BST_CHECKED : BST_UNCHECKED);
if(m_isReplaceTab)
{
CheckDlgButton(IDC_CHECK7, flags[FindReplace::Replace] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(IDC_CHECK8, flags[FindReplace::ReplaceAll] ? BST_CHECKED : BST_UNCHECKED);
} else
{
CheckDlgButton(IDC_CHECK7, flags[FindReplace::InChannels] ? BST_CHECKED : BST_UNCHECKED);
int nButton = IDC_RADIO1;
if(flags[FindReplace::FullSearch])
nButton = IDC_RADIO2;
else if(flags[FindReplace::InPatSelection])
nButton = IDC_RADIO3;
CheckRadioButton(IDC_RADIO1, IDC_RADIO3, nButton);
GetDlgItem(IDC_RADIO3)->EnableWindow(flags[FindReplace::InPatSelection] ? TRUE : FALSE);
SetDlgItemInt(IDC_EDIT1, m_settings.findChnMin + 1);
SetDlgItemInt(IDC_EDIT2, m_settings.findChnMax + 1);
static_cast<CSpinButtonCtrl *>(GetDlgItem(IDC_SPIN1))->SetRange32(1, m_sndFile.GetNumChannels());
static_cast<CSpinButtonCtrl *>(GetDlgItem(IDC_SPIN2))->SetRange32(1, m_sndFile.GetNumChannels());
// Pre-fill with selected pattern data
if(!flags[FindReplace::Note] && m_initialValues.note != NOTE_NONE)
{
m_settings.findNoteMin = m_settings.findNoteMax = m_initialValues.note;
}
if(!flags[FindReplace::Instr] && m_initialValues.instr != 0)
{
m_settings.findInstrMin = m_settings.findInstrMax = m_initialValues.instr;
}
if(IsPCEvent())
{
if(!flags[FindReplace::PCParam] && m_initialValues.GetValueVolCol() != 0)
m_settings.findParamMin = m_settings.findParamMax = m_initialValues.GetValueVolCol();
if(!flags[FindReplace::PCValue] && m_initialValues.GetValueEffectCol() != 0)
m_settings.findVolumeMin = m_settings.findVolumeMax = m_initialValues.GetValueEffectCol();
} else
{
if(!flags[FindReplace::VolCmd] && m_initialValues.volcmd != VOLCMD_NONE)
m_settings.findVolCmd = m_initialValues.volcmd;
if(!flags[FindReplace::Volume] && m_initialValues.volcmd != VOLCMD_NONE)
m_settings.findVolumeMin = m_settings.findVolumeMax = m_initialValues.vol;
if(!flags[FindReplace::Command] && m_initialValues.command != CMD_NONE)
m_settings.findCommand = m_initialValues.command;
if(!flags[FindReplace::Param] && m_initialValues.command != CMD_NONE)
m_settings.findParamMin = m_settings.findParamMax = m_initialValues.param;
}
}
// Note
{
int sel = -1;
m_cbnNote.SetRedraw(FALSE);
m_cbnNote.InitStorage(150, 6);
m_cbnNote.SetItemData(m_cbnNote.AddString(_T("...")), NOTE_NONE);
if (m_isReplaceTab)
{
m_cbnNote.SetItemData(m_cbnNote.AddString(_T("note -1")), kReplaceNoteMinusOne);
m_cbnNote.SetItemData(m_cbnNote.AddString(_T("note +1")), kReplaceNotePlusOne);
m_cbnNote.SetItemData(m_cbnNote.AddString(_T("-1 oct")), kReplaceNoteMinusOctave);
m_cbnNote.SetItemData(m_cbnNote.AddString(_T("+1 oct")), kReplaceNotePlusOctave);
m_cbnNote.SetItemData(m_cbnNote.AddString(_T("Transpose...")), kReplaceRelative);
if(m_settings.replaceNoteAction == FindReplace::ReplaceRelative)
{
switch(m_settings.replaceNote)
{
case -1: sel = 1; break;
case 1: sel = 2; break;
case FindReplace::ReplaceOctaveDown: sel = 3; break;
case FindReplace::ReplaceOctaveUp : sel = 4; break;
default: sel = 5; break;
}
}
} else
{
m_cbnNote.SetItemData(m_cbnNote.AddString(_T("any")), kFindAny);
m_cbnNote.SetItemData(m_cbnNote.AddString(_T("Range...")), kFindRange);
if(m_settings.findNoteMin == NOTE_MIN && m_settings.findNoteMax == NOTE_MAX)
sel = 1;
else if(m_settings.findNoteMin < m_settings.findNoteMax)
sel = 2;
}
AppendNotesToControlEx(m_cbnNote, m_sndFile);
if(sel == -1)
{
DWORD_PTR searchNote = m_isReplaceTab ? m_settings.replaceNote : m_settings.findNoteMin;
int ncount = m_cbnNote.GetCount();
for(int i = 0; i < ncount; i++) if(searchNote == m_cbnNote.GetItemData(i))
{
sel = i;
break;
}
}
m_cbnNote.SetCurSel(sel);
m_cbnNote.SetRedraw(TRUE);
}
// Volume Command
m_cbnVolCmd.SetRedraw(FALSE);
m_cbnVolCmd.InitStorage(m_effectInfo.GetNumVolCmds(), 15);
m_cbnVolCmd.SetItemData(m_cbnVolCmd.AddString(_T(" None")), (DWORD_PTR)-1);
UINT count = m_effectInfo.GetNumVolCmds();
for (UINT n=0; n<count; n++)
{
if(m_effectInfo.GetVolCmdInfo(n, &s) && !s.IsEmpty())
{
m_cbnVolCmd.SetItemData(m_cbnVolCmd.AddString(s), n);
}
}
m_cbnVolCmd.SetCurSel(0);
UINT fxndx = m_effectInfo.GetIndexFromVolCmd(m_isReplaceTab ? m_settings.replaceVolCmd : m_settings.findVolCmd);
for (UINT i=0; i<=count; i++) if (fxndx == m_cbnVolCmd.GetItemData(i))
{
m_cbnVolCmd.SetCurSel(i);
break;
}
m_cbnVolCmd.SetRedraw(TRUE);
m_cbnVolCmd.ShowWindow(SW_SHOW);
m_cbnPCParam.ShowWindow(SW_HIDE);
// Command
{
m_cbnCommand.SetRedraw(FALSE);
m_cbnCommand.InitStorage(m_effectInfo.GetNumEffects(), 20);
m_cbnCommand.SetItemData(m_cbnCommand.AddString(_T(" None")), (DWORD_PTR)-1);
count = m_effectInfo.GetNumEffects();
for (UINT n=0; n<count; n++)
{
if(m_effectInfo.GetEffectInfo(n, &s, true) && !s.IsEmpty())
{
m_cbnCommand.SetItemData(m_cbnCommand.AddString(s), n);
}
}
m_cbnCommand.SetCurSel(0);
fxndx = m_effectInfo.GetIndexFromEffect(m_isReplaceTab ? m_settings.replaceCommand : m_settings.findCommand, static_cast<ModCommand::PARAM>(m_isReplaceTab ? m_settings.replaceParam : m_settings.findParamMin));
for (UINT i=0; i<=count; i++) if (fxndx == m_cbnCommand.GetItemData(i))
{
m_cbnCommand.SetCurSel(i);
break;
}
m_cbnCommand.SetRedraw(TRUE);
}
UpdateInstrumentList();
UpdateVolumeList();
UpdateParamList();
OnCheckChannelSearch();
return TRUE;
}
bool CFindReplaceTab::IsPCEvent() const
{
if(m_isReplaceTab)
{
if(ModCommand::IsPcNote(static_cast<ModCommand::NOTE>(m_settings.replaceNote)))
return true;
else if(m_settings.replaceFlags[FindReplace::Note])
return false;
// If we don't replace the note, still show the PC-related settings if we search for PC events.
}
return ModCommand::IsPcNote(m_settings.findNoteMin);
}
void CFindReplaceTab::UpdateInstrumentList()
{
const bool isPCEvent = IsPCEvent();
if(m_cbnInstr.GetCount() != 0 && !!GetWindowLongPtr(m_cbnInstr.m_hWnd, GWLP_USERDATA) == isPCEvent)
return;
SetWindowLongPtr(m_cbnInstr.m_hWnd, GWLP_USERDATA, isPCEvent);
int oldSelection = (m_isReplaceTab ? m_settings.replaceInstr : m_settings.findInstrMin);
int sel = (oldSelection == 0) ? 0 : -1;
m_cbnInstr.SetRedraw(FALSE);
m_cbnInstr.ResetContent();
m_cbnInstr.InitStorage((isPCEvent ? MAX_MIXPLUGINS : MAX_INSTRUMENTS) + 3, 32);
m_cbnInstr.SetItemData(m_cbnInstr.AddString(_T("..")), 0);
if (m_isReplaceTab)
{
m_cbnInstr.SetItemData(m_cbnInstr.AddString(isPCEvent ? _T("Plugin -1") : _T("Instrument -1")), kReplaceInstrumentMinusOne);
m_cbnInstr.SetItemData(m_cbnInstr.AddString(isPCEvent ? _T("Plugin +1") : _T("Instrument +1")), kReplaceInstrumentPlusOne);
m_cbnInstr.SetItemData(m_cbnInstr.AddString(_T("Other...")), kReplaceRelative);
if(m_settings.replaceInstrAction == FindReplace::ReplaceRelative)
{
switch(m_settings.replaceInstr)
{
case -1: sel = 1; break;
case 1: sel = 2; break;
default: sel = 3; break;
}
}
} else
{
m_cbnInstr.SetItemData(m_cbnInstr.AddString(_T("Range...")), kFindRange);
if(m_settings.findInstrMin < m_settings.findInstrMax)
sel = 1;
}
if(sel == -1)
sel = m_cbnInstr.GetCount() + oldSelection - 1;
if(isPCEvent)
{
AddPluginNamesToCombobox(m_cbnInstr, m_sndFile.m_MixPlugins, false);
} else
{
CString s;
for(INSTRUMENTINDEX n = 1; n < MAX_INSTRUMENTS; n++)
{
s.Format(_T("%03d:"), n);
if(m_sndFile.GetNumInstruments())
s += mpt::ToCString(m_sndFile.GetCharsetInternal(), m_sndFile.GetInstrumentName(n));
else
s += mpt::ToCString(m_sndFile.GetCharsetInternal(), m_sndFile.m_szNames[n]);
m_cbnInstr.SetItemData(m_cbnInstr.AddString(s), n);
}
}
m_cbnInstr.SetCurSel(sel);
m_cbnInstr.SetRedraw(TRUE);
m_cbnInstr.Invalidate(FALSE);
}
void CFindReplaceTab::UpdateParamList()
{
const bool isPCEvent = IsPCEvent();
if(m_cbnInstr.GetCount() == 0 || !!GetWindowLongPtr(m_cbnInstr.m_hWnd, GWLP_USERDATA) != isPCEvent)
{
SetWindowLongPtr(m_cbnInstr.m_hWnd, GWLP_USERDATA, isPCEvent);
}
int effectIndex = static_cast<int>(m_cbnCommand.GetItemData(m_cbnCommand.GetCurSel()));
ModCommand::PARAM n = 0; // unused parameter adjustment
ModCommand::COMMAND cmd = m_effectInfo.GetEffectFromIndex(effectIndex, n);
const UINT mask = m_effectInfo.GetEffectMaskFromIndex(effectIndex);
if(m_isReplaceTab)
m_settings.replaceCommand = cmd;
else
m_settings.findCommand = cmd;
// Update Param range
const bool isExtended = m_effectInfo.IsExtendedEffect(effectIndex);
int sel = -1;
int oldcount = m_cbnParam.GetCount();
int newcount = isExtended ? 16 : 256;
if(oldcount)
oldcount -= m_isReplaceTab ? 2 : 1;
auto findParam = m_isReplaceTab ? m_settings.replaceParam : m_settings.findParamMin;
if(isExtended)
{
findParam &= 0x0F;
if(!m_isReplaceTab && !IsDlgButtonChecked(IDC_CHECK6))
{
m_settings.findParamMin = (m_settings.findParamMin & 0x0F) | mask;
m_settings.findParamMax = (m_settings.findParamMax & 0x0F) | mask;
} else if(m_isReplaceTab)
{
m_settings.replaceParam |= mask;
}
}
if(oldcount != newcount)
{
TCHAR s[16];
int newpos;
if(oldcount && m_cbnParam.GetCurSel() != CB_ERR)
newpos = static_cast<int>(m_cbnParam.GetItemData(m_cbnParam.GetCurSel()));
else
newpos = findParam;
Limit(newpos, 0, newcount - 1);
m_cbnParam.SetRedraw(FALSE);
m_cbnParam.ResetContent();
m_cbnParam.InitStorage(newcount + 2, 4);
if(m_isReplaceTab)
{
wsprintf(s, _T("+ %d"), m_settings.replaceParam);
m_cbnParam.SetItemData(m_cbnParam.AddString(s), kReplaceRelative);
wsprintf(s, _T("* %d%%"), m_settings.replaceParam);
m_cbnParam.SetItemData(m_cbnParam.AddString(s), kReplaceMultiply);
if(m_settings.replaceParamAction == FindReplace::ReplaceRelative)
sel = 0;
else if(m_settings.replaceParamAction == FindReplace::ReplaceMultiply)
sel = 1;
m_settings.replaceParam = newpos;
if(isExtended)
{
m_settings.replaceParam = (m_settings.replaceParam & 0x0F) | mask;
}
} else
{
m_cbnParam.SetItemData(m_cbnParam.AddString(_T("Range")), kFindRange);
if(m_settings.findParamMin < m_settings.findParamMax)
sel = 0;
}
if(sel == -1)
sel = m_cbnParam.GetCount() + newpos;
for(int param = 0; param < newcount; param++)
{
wsprintf(s, (newcount == 256) ? _T("%02X") : _T("%X"), param);
int i = m_cbnParam.AddString(s);
m_cbnParam.SetItemData(i, param);
}
m_cbnParam.SetCurSel(sel);
m_cbnParam.SetRedraw(TRUE);
m_cbnParam.Invalidate(FALSE);
}
}
void CFindReplaceTab::UpdateVolumeList()
{
TCHAR s[256];
const bool isPCEvent = IsPCEvent();
BOOL enable = isPCEvent ? FALSE : TRUE;
GetDlgItem(IDC_CHECK5)->EnableWindow(enable);
GetDlgItem(IDC_CHECK6)->EnableWindow(enable);
m_cbnCommand.EnableWindow(enable);
m_cbnParam.EnableWindow(enable);
// Update plugin parameter list
int plug = static_cast<int>(m_cbnInstr.GetItemData(m_cbnInstr.GetCurSel()));
if(isPCEvent && (m_cbnPCParam.GetCount() == 0 || GetWindowLongPtr(m_cbnPCParam.m_hWnd, GWLP_USERDATA) != plug))
{
SetWindowLongPtr(m_cbnPCParam.m_hWnd, GWLP_USERDATA, plug);
CheckDlgButton(IDC_CHECK5, BST_UNCHECKED);
CheckDlgButton(IDC_CHECK6, BST_UNCHECKED);
int sel = m_isReplaceTab ? m_settings.replaceParam : m_settings.findParamMin;
plug--;
m_cbnPCParam.SetRedraw(FALSE);
m_cbnPCParam.ResetContent();
if(plug >= 0 && plug < MAX_MIXPLUGINS && m_sndFile.m_MixPlugins[plug].pMixPlugin != nullptr)
{
AddPluginParameternamesToCombobox(m_cbnPCParam, *m_sndFile.m_MixPlugins[plug].pMixPlugin);
} else
{
m_cbnPCParam.InitStorage(ModCommand::maxColumnValue, 20);
for(int i = 0; i < ModCommand::maxColumnValue; i++)
{
wsprintf(s, _T("%02u: Parameter %02u"), static_cast<unsigned int>(i), static_cast<unsigned int>(i));
m_cbnPCParam.SetItemData(m_cbnPCParam.AddString(s), i);
}
}
m_cbnPCParam.SetCurSel(sel);
m_cbnPCParam.SetRedraw(TRUE);
m_cbnPCParam.Invalidate(FALSE);
}
m_cbnVolCmd.ShowWindow(isPCEvent ? SW_HIDE : SW_SHOW);
m_cbnPCParam.ShowWindow(isPCEvent ? SW_SHOW : SW_HIDE);
int rangeMin, rangeMax, curVal;
if(isPCEvent)
{
rangeMin = 0;
rangeMax = ModCommand::maxColumnValue;
curVal = (m_isReplaceTab ? m_settings.replaceVolume : m_settings.findVolumeMin);
} else
{
int effectIndex = static_cast<int>(m_cbnVolCmd.GetItemData(m_cbnVolCmd.GetCurSel()));
ModCommand::VOLCMD cmd = m_effectInfo.GetVolCmdFromIndex(effectIndex);
if(m_isReplaceTab)
m_settings.replaceVolCmd = cmd;
else
m_settings.findVolCmd = cmd;
// Update Param range
ModCommand::VOL volMin, volMax;
if(!m_effectInfo.GetVolCmdInfo(effectIndex, nullptr, &volMin, &volMax))
{
volMin = 0;
volMax = 64;
}
rangeMin = volMin;
rangeMax = volMax;
curVal = (m_isReplaceTab ? m_settings.replaceVolume : m_settings.findVolumeMin);
}
int oldcount = m_cbnVolume.GetCount();
int newcount = rangeMax - rangeMin + 1;
if (oldcount != newcount)
{
int sel = -1;
int newpos;
if (oldcount)
newpos = static_cast<int>(m_cbnVolume.GetItemData(m_cbnVolume.GetCurSel()));
else
newpos = curVal;
Limit(newpos, 0, newcount - 1);
m_cbnVolume.SetRedraw(FALSE);
m_cbnVolume.ResetContent();
m_cbnVolume.InitStorage(newcount + 2, 4);
if(m_isReplaceTab)
{
wsprintf(s, _T("+ %d"), m_settings.replaceVolume);
m_cbnVolume.SetItemData(m_cbnVolume.AddString(s), kReplaceRelative);
wsprintf(s, _T("* %d%%"), m_settings.replaceVolume);
m_cbnVolume.SetItemData(m_cbnVolume.AddString(s), kReplaceMultiply);
if(m_settings.replaceVolumeAction == FindReplace::ReplaceRelative)
sel = 0;
else if(m_settings.replaceVolumeAction == FindReplace::ReplaceMultiply)
sel = 1;
} else
{
m_cbnVolume.SetItemData(m_cbnVolume.AddString(_T("Range...")), kFindRange);
if(m_settings.findVolumeMin < m_settings.findVolumeMax)
sel = 0;
}
if(sel == -1)
sel = m_cbnVolume.GetCount() + newpos - rangeMin;
for (int vol = rangeMin; vol <= rangeMax; vol++)
{
wsprintf(s, (rangeMax < 10 || rangeMax > 99) ? _T("%d") : _T("%02d"), vol);
int i = m_cbnVolume.AddString(s);
m_cbnVolume.SetItemData(i, vol);
}
m_cbnVolume.SetCurSel(sel);
m_cbnVolume.SetRedraw(TRUE);
m_cbnVolume.Invalidate(FALSE);
}
}
void CFindReplaceTab::OnNoteChanged()
{
CheckOnChange(IDC_CHECK1);
int item = static_cast<int>(m_cbnNote.GetItemData(m_cbnNote.GetCurSel()));
if(m_isReplaceTab)
{
m_settings.replaceNoteAction = FindReplace::ReplaceRelative;
switch(item)
{
case kReplaceNoteMinusOne: m_settings.replaceNote = -1; break;
case kReplaceNotePlusOne: m_settings.replaceNote = 1; break;
case kReplaceNoteMinusOctave: m_settings.replaceNote = FindReplace::ReplaceOctaveDown; break;
case kReplaceNotePlusOctave: m_settings.replaceNote = FindReplace::ReplaceOctaveUp; break;
case kReplaceRelative:
{
CInputDlg dlg(this, _T("Custom Transpose Amount:"), -120, 120, m_settings.replaceNote);
if(dlg.DoModal() == IDOK)
{
m_settings.replaceNote = dlg.resultAsInt;
} else
{
// TODO undo selection
}
}
break;
default:
m_settings.replaceNote = item;
m_settings.replaceNoteAction = FindReplace::ReplaceValue;
}
} else
{
if(item == kFindRange)
{
CFindRangeDlg dlg(this, NOTE_MIN, m_settings.findNoteMin, NOTE_MAX, m_settings.findNoteMax, CFindRangeDlg::kNotes);
if(dlg.DoModal() == IDOK)
{
m_settings.findNoteMin = static_cast<ModCommand::NOTE>(dlg.GetMinVal());
m_settings.findNoteMax = static_cast<ModCommand::NOTE>(dlg.GetMaxVal());
}
} else if(item == kFindAny)
{
m_settings.findNoteMin = NOTE_MIN;
m_settings.findNoteMax = NOTE_MAX;
} else
{
m_settings.findNoteMin = m_settings.findNoteMax = static_cast<ModCommand::NOTE>(item);
}
}
UpdateInstrumentList();
UpdateVolumeList();
}
void CFindReplaceTab::OnInstrChanged()
{
CheckOnChange(IDC_CHECK2);
int item = static_cast<int>(m_cbnInstr.GetItemData(m_cbnInstr.GetCurSel()));
if(m_isReplaceTab)
{
m_settings.replaceInstrAction = FindReplace::ReplaceRelative;
switch(item)
{
case kReplaceInstrumentMinusOne: m_settings.replaceInstr = -1; break;
case kReplaceInstrumentPlusOne: m_settings.replaceInstr = 1; break;
case kReplaceRelative:
{
CInputDlg dlg(this, _T("Custom Replacement Amount:"), -255, 255, m_settings.replaceInstr);
if(dlg.DoModal() == IDOK)
{
m_settings.replaceInstrAction = FindReplace::ReplaceRelative;
m_settings.replaceInstr = dlg.resultAsInt;
} else
{
// TODO undo selection
}
}
break;
default:
m_settings.replaceInstrAction = FindReplace::ReplaceValue;
m_settings.replaceInstr = item;
break;
}
} else
{
if(item == kFindRange)
{
CFindRangeDlg dlg(this, 1, m_settings.findInstrMin, MAX_INSTRUMENTS - 1, m_settings.findInstrMax, CFindRangeDlg::kDecimal);
if(dlg.DoModal() == IDOK)
{
m_settings.findInstrMin = static_cast<ModCommand::INSTR>(dlg.GetMinVal());
m_settings.findInstrMax = static_cast<ModCommand::INSTR>(dlg.GetMaxVal());
}
} else
{
m_settings.findInstrMin = m_settings.findInstrMax = static_cast<ModCommand::INSTR>(item);
}
}
if(IsPCEvent())
UpdateVolumeList();
}
void CFindReplaceTab::RelativeOrMultiplyPrompt(CComboBox &comboBox, FindReplace::ReplaceMode &action, int &value, int range, bool isHex)
{
int sel = comboBox.GetCurSel();
int item = static_cast<int>(comboBox.GetItemData(sel));
if(sel == CB_ERR)
{
item = 0;
CString s;
comboBox.GetWindowText(s);
s.TrimLeft();
if(s.GetLength() >= 1)
{
TCHAR first = s[0];
if(first == _T('+'))
{
item = kReplaceRelative;
sel = 0;
} else if(first == _T('*'))
{
item = kReplaceMultiply;
sel = 1;
}
}
if(!item)
{
if(isHex)
{
int len = ::GetWindowTextLengthA(m_cbnParam);
std::string sHex(len, 0);
::GetWindowTextA(m_cbnParam, &sHex[0], len + 1);
item = mpt::String::Parse::HexToUnsignedInt(sHex);
} else
{
item = ConvertStrTo<int>(s);
}
}
}
if(item == kReplaceRelative || item == kReplaceMultiply)
{
const TCHAR *prompt, *format;
FindReplace::ReplaceMode act;
if(item == kReplaceRelative)
{
act = FindReplace::ReplaceRelative;
prompt = _T("Amount to add or subtract:");
format = _T("+ %d");
} else
{
act = FindReplace::ReplaceMultiply;
prompt = _T("Multiply by percentage:");
format = _T("* %d%%");
}
range *= 100;
CInputDlg dlg(this, prompt, -range, range, value);
if(dlg.DoModal() == IDOK)
{
value = dlg.resultAsInt;
action = act;
TCHAR s[32];
wsprintf(s, format, value);
comboBox.DeleteString(sel);
comboBox.InsertString(sel, s);
comboBox.SetItemData(sel, item);
comboBox.SetCurSel(sel);
} else
{
// TODO undo selection
}
} else
{
action = FindReplace::ReplaceValue;
value = item;
}
}
void CFindReplaceTab::OnVolumeChanged()
{
CheckOnChange(IDC_CHECK4);
int item = m_cbnVolume.GetCurSel();
if(item != CB_ERR)
item = static_cast<int>(m_cbnVolume.GetItemData(item));
else
item = GetDlgItemInt(IDC_COMBO4);
int rangeMax = IsPCEvent() ? ModCommand::maxColumnValue : 64;
if(m_isReplaceTab)
{
RelativeOrMultiplyPrompt(m_cbnVolume, m_settings.replaceVolumeAction, m_settings.replaceVolume, rangeMax, false);
} else
{
if(item == kFindRange)
{
CFindRangeDlg dlg(this, 0, m_settings.findVolumeMin, rangeMax, m_settings.findVolumeMax, CFindRangeDlg::kDecimal);
if(dlg.DoModal() == IDOK)
{
m_settings.findVolumeMin = dlg.GetMinVal();
m_settings.findVolumeMax = dlg.GetMaxVal();
} else
{
// TODO undo selection
}
} else
{
m_settings.findVolumeMin = m_settings.findVolumeMax = item;
}
}
}
void CFindReplaceTab::OnParamChanged()
{
CheckOnChange(IDC_CHECK6);
int item = m_cbnParam.GetCurSel();
if(item != CB_ERR)
{
item = static_cast<int>(m_cbnParam.GetItemData(item));
} else
{
int len = ::GetWindowTextLengthA(m_cbnParam);
std::string s(len, 0);
::GetWindowTextA(m_cbnParam, &s[0], len + 1);
item = mpt::String::Parse::HexToUnsignedInt(s);
}
// Apply parameter value mask if required (e.g. SDx has mask D0).
int effectIndex = static_cast<int>(m_cbnCommand.GetItemData(m_cbnCommand.GetCurSel()));
UINT mask = (effectIndex > -1) ? m_effectInfo.GetEffectMaskFromIndex(effectIndex) : 0;
if(m_isReplaceTab)
{
RelativeOrMultiplyPrompt(m_cbnParam, m_settings.replaceParamAction, m_settings.replaceParam, 256, true);
if(m_settings.replaceParamAction == FindReplace::ReplaceValue && effectIndex > -1)
{
m_settings.replaceParam |= mask;
}
} else
{
if(item == kFindRange)
{
CFindRangeDlg dlg(this, 0, m_settings.findParamMin & ~mask, m_cbnParam.GetCount() - 2, m_settings.findParamMax & ~mask, CFindRangeDlg::kHex);
if(dlg.DoModal() == IDOK)
{
m_settings.findParamMin = dlg.GetMinVal() | mask;
m_settings.findParamMax = dlg.GetMaxVal() | mask;
} else
{
// TODO undo selection
}
} else
{
m_settings.findParamMin = m_settings.findParamMax = (item | mask);
}
}
}
void CFindReplaceTab::OnPCParamChanged()
{
CheckOnChange(IDC_CHECK3);
int item = static_cast<int>(m_cbnPCParam.GetItemData(m_cbnPCParam.GetCurSel()));
if(m_isReplaceTab)
{
RelativeOrMultiplyPrompt(m_cbnPCParam, m_settings.replaceParamAction, m_settings.replaceParam, 256, false);
} else
{
if(item == kFindRange)
{
CFindRangeDlg dlg(this, 0, m_settings.findParamMin, ModCommand::maxColumnValue, m_settings.findParamMax, CFindRangeDlg::kDecimal);
if(dlg.DoModal() == IDOK)
{
m_settings.findParamMin = dlg.GetMinVal();
m_settings.findParamMax = dlg.GetMaxVal();
} else
{
// TODO undo selection
}
} else
{
m_settings.findParamMin = m_settings.findParamMax = item;
}
}
}
void CFindReplaceTab::OnCheckChannelSearch()
{
if (!m_isReplaceTab)
{
BOOL b = IsDlgButtonChecked(IDC_CHECK7);
GetDlgItem(IDC_EDIT1)->EnableWindow(b);
GetDlgItem(IDC_SPIN1)->EnableWindow(b);
GetDlgItem(IDC_EDIT2)->EnableWindow(b);
GetDlgItem(IDC_SPIN2)->EnableWindow(b);
}
}
void CFindReplaceTab::OnOK()
{
// Search flags
FlagSet<FindReplace::Flags> &flags = m_isReplaceTab ? m_settings.replaceFlags : m_settings.findFlags;
flags.reset();
flags.set(FindReplace::Note, !!IsDlgButtonChecked(IDC_CHECK1));
flags.set(FindReplace::Instr, !!IsDlgButtonChecked(IDC_CHECK2));
if(IsPCEvent())
{
flags.set(FindReplace::PCParam, !!IsDlgButtonChecked(IDC_CHECK3));
flags.set(FindReplace::PCValue, !!IsDlgButtonChecked(IDC_CHECK4));
} else
{
flags.set(FindReplace::VolCmd, !!IsDlgButtonChecked(IDC_CHECK3));
flags.set(FindReplace::Volume, !!IsDlgButtonChecked(IDC_CHECK4));
flags.set(FindReplace::Command, !!IsDlgButtonChecked(IDC_CHECK5));
flags.set(FindReplace::Param, !!IsDlgButtonChecked(IDC_CHECK6));
}
if(m_isReplaceTab)
{
flags.set(FindReplace::Replace, !!IsDlgButtonChecked(IDC_CHECK7));
flags.set(FindReplace::ReplaceAll, !!IsDlgButtonChecked(IDC_CHECK8));
} else
{
flags.set(FindReplace::InChannels, !!IsDlgButtonChecked(IDC_CHECK7));
flags.set(FindReplace::FullSearch, !!IsDlgButtonChecked(IDC_RADIO2));
flags.set(FindReplace::InPatSelection, !!IsDlgButtonChecked(IDC_RADIO3));
}
// Min/Max channels
if (!m_isReplaceTab)
{
m_settings.findChnMin = static_cast<CHANNELINDEX>(GetDlgItemInt(IDC_EDIT1) - 1);
m_settings.findChnMax = static_cast<CHANNELINDEX>(GetDlgItemInt(IDC_EDIT2) - 1);
if (m_settings.findChnMax < m_settings.findChnMin)
{
std::swap(m_settings.findChnMin, m_settings.findChnMax);
}
}
CPropertyPage::OnOK();
}
OPENMPT_NAMESPACE_END
Reference in New Issue View Git Blame Copy Permalink