mirror of
https://github.com/WinampDesktop/winamp.git
synced 2024-12-12 09:31:00 -05:00
3361 lines
97 KiB
C++
3361 lines
97 KiB
C++
/*
|
|
* Moddoc.cpp
|
|
* ----------
|
|
* Purpose: Module document handling in OpenMPT.
|
|
* Notes : (currently none)
|
|
* Authors: 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 "InputHandler.h"
|
|
#include "Moddoc.h"
|
|
#include "ModDocTemplate.h"
|
|
#include "../soundlib/mod_specifications.h"
|
|
#include "../soundlib/plugins/PlugInterface.h"
|
|
#include "Childfrm.h"
|
|
#include "Mpdlgs.h"
|
|
#include "dlg_misc.h"
|
|
#include "TempoSwingDialog.h"
|
|
#include "mod2wave.h"
|
|
#include "ChannelManagerDlg.h"
|
|
#include "MIDIMacroDialog.h"
|
|
#include "MIDIMappingDialog.h"
|
|
#include "StreamEncoderAU.h"
|
|
#include "StreamEncoderFLAC.h"
|
|
#include "StreamEncoderMP3.h"
|
|
#include "StreamEncoderOpus.h"
|
|
#include "StreamEncoderRAW.h"
|
|
#include "StreamEncoderVorbis.h"
|
|
#include "StreamEncoderWAV.h"
|
|
#include "mod2midi.h"
|
|
#include "../common/version.h"
|
|
#include "../tracklib/SampleEdit.h"
|
|
#include "../soundlib/modsmp_ctrl.h"
|
|
#include "CleanupSong.h"
|
|
#include "../common/mptStringBuffer.h"
|
|
#include "../common/mptFileIO.h"
|
|
#include <sstream>
|
|
#include "../common/FileReader.h"
|
|
#include "FileDialog.h"
|
|
#include "ExternalSamples.h"
|
|
#include "Globals.h"
|
|
#include "../soundlib/OPL.h"
|
|
#ifndef NO_PLUGINS
|
|
#include "AbstractVstEditor.h"
|
|
#endif
|
|
#include "mpt/binary/hex.hpp"
|
|
#include "mpt/base/numbers.hpp"
|
|
#include "mpt/io/io.hpp"
|
|
#include "mpt/io/io_stdstream.hpp"
|
|
|
|
|
|
OPENMPT_NAMESPACE_BEGIN
|
|
|
|
|
|
const TCHAR FileFilterMOD[] = _T("ProTracker Modules (*.mod)|*.mod||");
|
|
const TCHAR FileFilterXM[] = _T("FastTracker Modules (*.xm)|*.xm||");
|
|
const TCHAR FileFilterS3M[] = _T("Scream Tracker Modules (*.s3m)|*.s3m||");
|
|
const TCHAR FileFilterIT[] = _T("Impulse Tracker Modules (*.it)|*.it||");
|
|
const TCHAR FileFilterMPT[] = _T("OpenMPT Modules (*.mptm)|*.mptm||");
|
|
const TCHAR FileFilterNone[] = _T("");
|
|
|
|
const CString ModTypeToFilter(const CSoundFile& sndFile)
|
|
{
|
|
const MODTYPE modtype = sndFile.GetType();
|
|
switch(modtype)
|
|
{
|
|
case MOD_TYPE_MOD: return FileFilterMOD;
|
|
case MOD_TYPE_XM: return FileFilterXM;
|
|
case MOD_TYPE_S3M: return FileFilterS3M;
|
|
case MOD_TYPE_IT: return FileFilterIT;
|
|
case MOD_TYPE_MPT: return FileFilterMPT;
|
|
default: return FileFilterNone;
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CModDoc
|
|
|
|
IMPLEMENT_DYNCREATE(CModDoc, CDocument)
|
|
|
|
BEGIN_MESSAGE_MAP(CModDoc, CDocument)
|
|
//{{AFX_MSG_MAP(CModDoc)
|
|
ON_COMMAND(ID_FILE_SAVE_COPY, &CModDoc::OnSaveCopy)
|
|
ON_COMMAND(ID_FILE_SAVEASTEMPLATE, &CModDoc::OnSaveTemplateModule)
|
|
ON_COMMAND(ID_FILE_SAVEASWAVE, &CModDoc::OnFileWaveConvert)
|
|
ON_COMMAND(ID_FILE_SAVEMIDI, &CModDoc::OnFileMidiConvert)
|
|
ON_COMMAND(ID_FILE_SAVEOPL, &CModDoc::OnFileOPLExport)
|
|
ON_COMMAND(ID_FILE_SAVECOMPAT, &CModDoc::OnFileCompatibilitySave)
|
|
ON_COMMAND(ID_FILE_APPENDMODULE, &CModDoc::OnAppendModule)
|
|
ON_COMMAND(ID_PLAYER_PLAY, &CModDoc::OnPlayerPlay)
|
|
ON_COMMAND(ID_PLAYER_PAUSE, &CModDoc::OnPlayerPause)
|
|
ON_COMMAND(ID_PLAYER_STOP, &CModDoc::OnPlayerStop)
|
|
ON_COMMAND(ID_PLAYER_PLAYFROMSTART, &CModDoc::OnPlayerPlayFromStart)
|
|
ON_COMMAND(ID_VIEW_SONGPROPERTIES, &CModDoc::OnSongProperties)
|
|
ON_COMMAND(ID_VIEW_GLOBALS, &CModDoc::OnEditGlobals)
|
|
ON_COMMAND(ID_VIEW_PATTERNS, &CModDoc::OnEditPatterns)
|
|
ON_COMMAND(ID_VIEW_SAMPLES, &CModDoc::OnEditSamples)
|
|
ON_COMMAND(ID_VIEW_INSTRUMENTS, &CModDoc::OnEditInstruments)
|
|
ON_COMMAND(ID_VIEW_COMMENTS, &CModDoc::OnEditComments)
|
|
ON_COMMAND(ID_VIEW_EDITHISTORY, &CModDoc::OnViewEditHistory)
|
|
ON_COMMAND(ID_VIEW_MIDIMAPPING, &CModDoc::OnViewMIDIMapping)
|
|
ON_COMMAND(ID_VIEW_MPTHACKS, &CModDoc::OnViewMPTHacks)
|
|
ON_COMMAND(ID_EDIT_CLEANUP, &CModDoc::OnShowCleanup)
|
|
ON_COMMAND(ID_EDIT_SAMPLETRIMMER, &CModDoc::OnShowSampleTrimmer)
|
|
ON_COMMAND(ID_PATTERN_MIDIMACRO, &CModDoc::OnSetupZxxMacros)
|
|
ON_COMMAND(ID_CHANNEL_MANAGER, &CModDoc::OnChannelManager)
|
|
|
|
ON_COMMAND(ID_ESTIMATESONGLENGTH, &CModDoc::OnEstimateSongLength)
|
|
ON_COMMAND(ID_APPROX_BPM, &CModDoc::OnApproximateBPM)
|
|
ON_COMMAND(ID_PATTERN_PLAY, &CModDoc::OnPatternPlay)
|
|
ON_COMMAND(ID_PATTERN_PLAYNOLOOP, &CModDoc::OnPatternPlayNoLoop)
|
|
ON_COMMAND(ID_PATTERN_RESTART, &CModDoc::OnPatternRestart)
|
|
ON_UPDATE_COMMAND_UI(ID_VIEW_INSTRUMENTS, &CModDoc::OnUpdateXMITMPTOnly)
|
|
ON_UPDATE_COMMAND_UI(ID_PATTERN_MIDIMACRO, &CModDoc::OnUpdateXMITMPTOnly)
|
|
ON_UPDATE_COMMAND_UI(ID_VIEW_MIDIMAPPING, &CModDoc::OnUpdateHasMIDIMappings)
|
|
ON_UPDATE_COMMAND_UI(ID_VIEW_EDITHISTORY, &CModDoc::OnUpdateHasEditHistory)
|
|
ON_UPDATE_COMMAND_UI(ID_FILE_SAVECOMPAT, &CModDoc::OnUpdateCompatExportableOnly)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CModDoc construction/destruction
|
|
|
|
CModDoc::CModDoc()
|
|
: m_notifyType(Notification::Default)
|
|
, m_PatternUndo(*this)
|
|
, m_SampleUndo(*this)
|
|
, m_InstrumentUndo(*this)
|
|
{
|
|
// Set the creation date of this file (or the load time if we're loading an existing file)
|
|
time(&m_creationTime);
|
|
|
|
ReinitRecordState();
|
|
|
|
CMainFrame::UpdateAudioParameters(m_SndFile, true);
|
|
}
|
|
|
|
|
|
CModDoc::~CModDoc()
|
|
{
|
|
ClearLog();
|
|
}
|
|
|
|
|
|
void CModDoc::SetModified(bool modified)
|
|
{
|
|
static_assert(sizeof(long) == sizeof(m_bModified));
|
|
m_modifiedAutosave = modified;
|
|
if(!!InterlockedExchange(reinterpret_cast<long *>(&m_bModified), modified ? TRUE : FALSE) != modified)
|
|
{
|
|
// Update window titles in GUI thread
|
|
CMainFrame::GetMainFrame()->SendNotifyMessage(WM_MOD_SETMODIFIED, reinterpret_cast<WPARAM>(this), 0);
|
|
}
|
|
}
|
|
|
|
|
|
// Return "modified since last autosave" status and reset it until the next SetModified() (as this is only used for polling during autosave)
|
|
bool CModDoc::ModifiedSinceLastAutosave()
|
|
{
|
|
return m_modifiedAutosave.exchange(false);
|
|
}
|
|
|
|
|
|
BOOL CModDoc::OnNewDocument()
|
|
{
|
|
if (!CDocument::OnNewDocument()) return FALSE;
|
|
|
|
m_SndFile.Create(FileReader(), CSoundFile::loadCompleteModule, this);
|
|
m_SndFile.ChangeModTypeTo(CTrackApp::GetDefaultDocType());
|
|
|
|
theApp.GetDefaultMidiMacro(m_SndFile.m_MidiCfg);
|
|
m_SndFile.m_SongFlags.set((SONG_LINEARSLIDES | SONG_ISAMIGA) & m_SndFile.GetModSpecifications().songFlags);
|
|
|
|
ReinitRecordState();
|
|
InitializeMod();
|
|
SetModified(false);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL CModDoc::OnOpenDocument(LPCTSTR lpszPathName)
|
|
{
|
|
const mpt::PathString filename = lpszPathName ? mpt::PathString::FromCString(lpszPathName) : mpt::PathString();
|
|
|
|
ScopedLogCapturer logcapturer(*this);
|
|
|
|
if(filename.empty()) return OnNewDocument();
|
|
|
|
BeginWaitCursor();
|
|
|
|
{
|
|
|
|
MPT_LOG_GLOBAL(LogDebug, "Loader", U_("Open..."));
|
|
|
|
InputFile f(filename, TrackerSettings::Instance().MiscCacheCompleteFileBeforeLoading);
|
|
if (f.IsValid())
|
|
{
|
|
FileReader file = GetFileReader(f);
|
|
MPT_ASSERT(GetPathNameMpt().empty());
|
|
SetPathName(filename, FALSE); // Path is not set yet, but loaders processing external samples/instruments (ITP/MPTM) need this for relative paths.
|
|
try
|
|
{
|
|
if(!m_SndFile.Create(file, CSoundFile::loadCompleteModule, this))
|
|
{
|
|
EndWaitCursor();
|
|
return FALSE;
|
|
}
|
|
} catch(mpt::out_of_memory e)
|
|
{
|
|
mpt::delete_out_of_memory(e);
|
|
EndWaitCursor();
|
|
AddToLog(LogError, U_("Out of Memory"));
|
|
return FALSE;
|
|
} catch(const std::exception &)
|
|
{
|
|
EndWaitCursor();
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
MPT_LOG_GLOBAL(LogDebug, "Loader", U_("Open."));
|
|
|
|
}
|
|
|
|
EndWaitCursor();
|
|
|
|
logcapturer.ShowLog(
|
|
MPT_CFORMAT("File: {}\nLast saved with: {}, you are using OpenMPT {}\n\n")
|
|
(filename, m_SndFile.m_modFormat.madeWithTracker, Version::Current()));
|
|
|
|
if((m_SndFile.m_nType == MOD_TYPE_NONE) || (!m_SndFile.GetNumChannels()))
|
|
return FALSE;
|
|
|
|
const bool noColors = std::find_if(std::begin(m_SndFile.ChnSettings), std::begin(m_SndFile.ChnSettings) + GetNumChannels(), [](const auto &settings) {
|
|
return settings.color != ModChannelSettings::INVALID_COLOR;
|
|
}) == std::begin(m_SndFile.ChnSettings) + GetNumChannels();
|
|
if(noColors)
|
|
{
|
|
SetDefaultChannelColors();
|
|
}
|
|
|
|
// Convert to MOD/S3M/XM/IT
|
|
switch(m_SndFile.GetType())
|
|
{
|
|
case MOD_TYPE_MOD:
|
|
case MOD_TYPE_S3M:
|
|
case MOD_TYPE_XM:
|
|
case MOD_TYPE_IT:
|
|
case MOD_TYPE_MPT:
|
|
break;
|
|
default:
|
|
m_SndFile.ChangeModTypeTo(m_SndFile.GetBestSaveFormat(), false);
|
|
m_SndFile.m_SongFlags.set(SONG_IMPORTED);
|
|
break;
|
|
}
|
|
// If the file was packed in some kind of container (e.g. ZIP, or simply a format like MO3), prompt for new file extension as well
|
|
// Same if MOD_TYPE_XXX does not indicate actual song format
|
|
if(m_SndFile.GetContainerType() != MOD_CONTAINERTYPE_NONE || m_SndFile.m_SongFlags[SONG_IMPORTED])
|
|
{
|
|
m_ShowSavedialog = true;
|
|
}
|
|
|
|
ReinitRecordState();
|
|
|
|
if(TrackerSettings::Instance().rememberSongWindows)
|
|
DeserializeViews();
|
|
|
|
// This is only needed when opening a module with stored window positions.
|
|
// The MDI child is activated before it has an active view and thus there is no CModDoc associated with it.
|
|
CMainFrame::GetMainFrame()->UpdateEffectKeys(this);
|
|
auto instance = CChannelManagerDlg::sharedInstance();
|
|
if(instance != nullptr)
|
|
{
|
|
instance->SetDocument(this);
|
|
}
|
|
|
|
// Show warning if file was made with more recent version of OpenMPT except
|
|
if(m_SndFile.m_dwLastSavedWithVersion.WithoutTestNumber() > Version::Current())
|
|
{
|
|
Reporting::Notification(MPT_UFORMAT("Warning: this song was last saved with a more recent version of OpenMPT.\r\nSong saved with: v{}. Current version: v{}.\r\n")(
|
|
m_SndFile.m_dwLastSavedWithVersion,
|
|
Version::Current()));
|
|
}
|
|
|
|
SetModified(false);
|
|
m_bHasValidPath = true;
|
|
|
|
// Check if there are any missing samples, and if there are, show a dialog to relocate them.
|
|
for(SAMPLEINDEX smp = 1; smp <= GetNumSamples(); smp++)
|
|
{
|
|
if(m_SndFile.IsExternalSampleMissing(smp))
|
|
{
|
|
MissingExternalSamplesDlg dlg(*this, CMainFrame::GetMainFrame());
|
|
dlg.DoModal();
|
|
break;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
bool CModDoc::OnSaveDocument(const mpt::PathString &filename, const bool setPath)
|
|
{
|
|
ScopedLogCapturer logcapturer(*this);
|
|
if(filename.empty())
|
|
return false;
|
|
|
|
bool ok = false;
|
|
BeginWaitCursor();
|
|
m_SndFile.m_dwLastSavedWithVersion = Version::Current();
|
|
try
|
|
{
|
|
mpt::SafeOutputFile sf(filename, std::ios::binary, mpt::FlushModeFromBool(TrackerSettings::Instance().MiscFlushFileBuffersOnSave));
|
|
mpt::ofstream &f = sf;
|
|
if(f)
|
|
{
|
|
if(m_SndFile.m_SongFlags[SONG_IMPORTED] && !(GetModType() & (MOD_TYPE_MOD | MOD_TYPE_S3M)))
|
|
{
|
|
// Check if any non-supported playback behaviours are enabled due to being imported from a different format
|
|
const auto supportedBehaviours = m_SndFile.GetSupportedPlaybackBehaviour(GetModType());
|
|
bool showWarning = true;
|
|
for(size_t i = 0; i < kMaxPlayBehaviours; i++)
|
|
{
|
|
if(m_SndFile.m_playBehaviour[i] && !supportedBehaviours[i])
|
|
{
|
|
if(showWarning)
|
|
{
|
|
AddToLog(LogWarning, mpt::ToUnicode(mpt::Charset::ASCII, MPT_AFORMAT("Some imported Compatibility Settings that are not supported by the {} format have been disabled. Verify that the module still sounds as intended.")
|
|
(mpt::ToUpperCaseAscii(m_SndFile.GetModSpecifications().fileExtension))));
|
|
showWarning = false;
|
|
}
|
|
m_SndFile.m_playBehaviour.reset(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
f.exceptions(f.exceptions() | std::ios::badbit | std::ios::failbit);
|
|
FixNullStrings();
|
|
switch(m_SndFile.GetType())
|
|
{
|
|
case MOD_TYPE_MOD: ok = m_SndFile.SaveMod(f); break;
|
|
case MOD_TYPE_S3M: ok = m_SndFile.SaveS3M(f); break;
|
|
case MOD_TYPE_XM: ok = m_SndFile.SaveXM(f); break;
|
|
case MOD_TYPE_IT: ok = m_SndFile.SaveIT(f, filename); break;
|
|
case MOD_TYPE_MPT: ok = m_SndFile.SaveIT(f, filename); break;
|
|
default: MPT_ASSERT_NOTREACHED();
|
|
}
|
|
}
|
|
} catch(const std::exception &)
|
|
{
|
|
ok = false;
|
|
}
|
|
EndWaitCursor();
|
|
|
|
if(ok)
|
|
{
|
|
if(setPath)
|
|
{
|
|
// Set new path for this file, unless we are saving a template or a copy, in which case we want to keep the old file path.
|
|
SetPathName(filename);
|
|
}
|
|
logcapturer.ShowLog(true);
|
|
if(TrackerSettings::Instance().rememberSongWindows)
|
|
SerializeViews();
|
|
} else
|
|
{
|
|
ErrorBox(IDS_ERR_SAVESONG, CMainFrame::GetMainFrame());
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
|
|
BOOL CModDoc::SaveModified()
|
|
{
|
|
if(m_SndFile.GetType() == MOD_TYPE_MPT && !SaveAllSamples())
|
|
return FALSE;
|
|
return CDocument::SaveModified();
|
|
}
|
|
|
|
|
|
bool CModDoc::SaveAllSamples(bool showPrompt)
|
|
{
|
|
if(showPrompt)
|
|
{
|
|
ModifiedExternalSamplesDlg dlg(*this, CMainFrame::GetMainFrame());
|
|
return dlg.DoModal() == IDOK;
|
|
} else
|
|
{
|
|
bool ok = true;
|
|
for(SAMPLEINDEX smp = 1; smp <= GetNumSamples(); smp++)
|
|
{
|
|
ok &= SaveSample(smp);
|
|
}
|
|
return ok;
|
|
}
|
|
}
|
|
|
|
|
|
bool CModDoc::SaveSample(SAMPLEINDEX smp)
|
|
{
|
|
bool success = false;
|
|
if(smp > 0 && smp <= GetNumSamples())
|
|
{
|
|
const mpt::PathString filename = m_SndFile.GetSamplePath(smp);
|
|
if(!filename.empty())
|
|
{
|
|
auto &sample = m_SndFile.GetSample(smp);
|
|
const auto ext = filename.GetFileExt().ToUnicode().substr(1);
|
|
const auto format = FromSettingValue<SampleEditorDefaultFormat>(ext);
|
|
|
|
try
|
|
{
|
|
mpt::SafeOutputFile sf(filename, std::ios::binary, mpt::FlushModeFromBool(TrackerSettings::Instance().MiscFlushFileBuffersOnSave));
|
|
if(sf)
|
|
{
|
|
mpt::ofstream &f = sf;
|
|
f.exceptions(f.exceptions() | std::ios::badbit | std::ios::failbit);
|
|
|
|
if(sample.uFlags[CHN_ADLIB] || format == dfS3I)
|
|
success = m_SndFile.SaveS3ISample(smp, f);
|
|
else if(format != dfWAV)
|
|
success = m_SndFile.SaveFLACSample(smp, f);
|
|
else
|
|
success = m_SndFile.SaveWAVSample(smp, f);
|
|
}
|
|
} catch(const std::exception &)
|
|
{
|
|
success = false;
|
|
}
|
|
|
|
if(success)
|
|
sample.uFlags.reset(SMP_MODIFIED);
|
|
else
|
|
AddToLog(LogError, MPT_UFORMAT("Unable to save sample {}: {}")(smp, filename));
|
|
}
|
|
}
|
|
return success;
|
|
}
|
|
|
|
|
|
void CModDoc::OnCloseDocument()
|
|
{
|
|
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
|
|
if(pMainFrm) pMainFrm->OnDocumentClosed(this);
|
|
CDocument::OnCloseDocument();
|
|
}
|
|
|
|
|
|
void CModDoc::DeleteContents()
|
|
{
|
|
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
|
|
if (pMainFrm) pMainFrm->StopMod(this);
|
|
m_SndFile.Destroy();
|
|
ReinitRecordState();
|
|
}
|
|
|
|
|
|
BOOL CModDoc::DoSave(const mpt::PathString &filename, bool setPath)
|
|
{
|
|
const mpt::PathString docFileName = GetPathNameMpt();
|
|
const std::string defaultExtension = m_SndFile.GetModSpecifications().fileExtension;
|
|
|
|
switch(m_SndFile.GetBestSaveFormat())
|
|
{
|
|
case MOD_TYPE_MOD:
|
|
MsgBoxHidable(ModSaveHint);
|
|
break;
|
|
case MOD_TYPE_S3M:
|
|
break;
|
|
case MOD_TYPE_XM:
|
|
MsgBoxHidable(XMCompatibilityExportTip);
|
|
break;
|
|
case MOD_TYPE_IT:
|
|
MsgBoxHidable(ItCompatibilityExportTip);
|
|
break;
|
|
case MOD_TYPE_MPT:
|
|
break;
|
|
default:
|
|
ErrorBox(IDS_ERR_SAVESONG, CMainFrame::GetMainFrame());
|
|
return FALSE;
|
|
}
|
|
|
|
mpt::PathString ext = P_(".") + mpt::PathString::FromUTF8(defaultExtension);
|
|
|
|
mpt::PathString saveFileName;
|
|
|
|
if(filename.empty() || m_ShowSavedialog)
|
|
{
|
|
mpt::PathString drive = docFileName.GetDrive();
|
|
mpt::PathString dir = docFileName.GetDir();
|
|
mpt::PathString fileName = docFileName.GetFileName();
|
|
if(fileName.empty())
|
|
{
|
|
fileName = mpt::PathString::FromCString(GetTitle()).SanitizeComponent();
|
|
}
|
|
mpt::PathString defaultSaveName = drive + dir + fileName + ext;
|
|
|
|
FileDialog dlg = SaveFileDialog()
|
|
.DefaultExtension(defaultExtension)
|
|
.DefaultFilename(defaultSaveName)
|
|
.ExtensionFilter(ModTypeToFilter(m_SndFile))
|
|
.WorkingDirectory(TrackerSettings::Instance().PathSongs.GetWorkingDir());
|
|
if(!dlg.Show()) return FALSE;
|
|
|
|
TrackerSettings::Instance().PathSongs.SetWorkingDir(dlg.GetWorkingDirectory());
|
|
|
|
saveFileName = dlg.GetFirstFile();
|
|
} else
|
|
{
|
|
saveFileName = filename;
|
|
}
|
|
|
|
// Do we need to create a backup file ?
|
|
if((TrackerSettings::Instance().CreateBackupFiles)
|
|
&& (IsModified()) && (!mpt::PathString::CompareNoCase(saveFileName, docFileName)))
|
|
{
|
|
if(saveFileName.IsFile())
|
|
{
|
|
mpt::PathString backupFileName = saveFileName.ReplaceExt(P_(".bak"));
|
|
if(backupFileName.IsFile())
|
|
{
|
|
DeleteFile(backupFileName.AsNative().c_str());
|
|
}
|
|
MoveFile(saveFileName.AsNative().c_str(), backupFileName.AsNative().c_str());
|
|
}
|
|
}
|
|
if(OnSaveDocument(saveFileName, setPath))
|
|
{
|
|
SetModified(false);
|
|
m_SndFile.m_SongFlags.reset(SONG_IMPORTED);
|
|
m_bHasValidPath = true;
|
|
m_ShowSavedialog = false;
|
|
CMainFrame::GetMainFrame()->UpdateTree(this, GeneralHint().General()); // Update treeview (e.g. filename might have changed)
|
|
return TRUE;
|
|
} else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
void CModDoc::OnAppendModule()
|
|
{
|
|
FileDialog::PathList files;
|
|
CTrackApp::OpenModulesDialog(files);
|
|
|
|
ScopedLogCapturer logcapture(*this, _T("Append Failures"));
|
|
try
|
|
{
|
|
auto source = std::make_unique<CSoundFile>();
|
|
for(const auto &file : files)
|
|
{
|
|
InputFile f(file, TrackerSettings::Instance().MiscCacheCompleteFileBeforeLoading);
|
|
if(!f.IsValid())
|
|
{
|
|
AddToLog("Unable to open source file!");
|
|
continue;
|
|
}
|
|
try
|
|
{
|
|
if(!source->Create(GetFileReader(f), CSoundFile::loadCompleteModule))
|
|
{
|
|
AddToLog("Unable to open source file!");
|
|
continue;
|
|
}
|
|
} catch(const std::exception &)
|
|
{
|
|
AddToLog("Unable to open source file!");
|
|
continue;
|
|
}
|
|
AppendModule(*source);
|
|
source->Destroy();
|
|
SetModified();
|
|
}
|
|
} catch(mpt::out_of_memory e)
|
|
{
|
|
mpt::delete_out_of_memory(e);
|
|
AddToLog("Out of memory.");
|
|
return;
|
|
}
|
|
|
|
UpdateAllViews(nullptr, SequenceHint().Data().ModType());
|
|
}
|
|
|
|
|
|
void CModDoc::InitializeMod()
|
|
{
|
|
// New module ?
|
|
if (!m_SndFile.m_nChannels)
|
|
{
|
|
switch(GetModType())
|
|
{
|
|
case MOD_TYPE_MOD:
|
|
m_SndFile.m_nChannels = 4;
|
|
break;
|
|
case MOD_TYPE_S3M:
|
|
m_SndFile.m_nChannels = 16;
|
|
break;
|
|
default:
|
|
m_SndFile.m_nChannels = 32;
|
|
break;
|
|
}
|
|
|
|
SetDefaultChannelColors();
|
|
|
|
if(GetModType() == MOD_TYPE_MPT)
|
|
{
|
|
m_SndFile.m_nTempoMode = TempoMode::Modern;
|
|
m_SndFile.m_SongFlags.set(SONG_EXFILTERRANGE);
|
|
}
|
|
m_SndFile.SetDefaultPlaybackBehaviour(GetModType());
|
|
|
|
// Refresh mix levels now that the correct mod type has been set
|
|
m_SndFile.SetMixLevels(m_SndFile.GetModSpecifications().defaultMixLevels);
|
|
|
|
m_SndFile.Order().assign(1, 0);
|
|
if (!m_SndFile.Patterns.IsValidPat(0))
|
|
{
|
|
m_SndFile.Patterns.Insert(0, 64);
|
|
}
|
|
|
|
Clear(m_SndFile.m_szNames);
|
|
|
|
m_SndFile.m_PlayState.m_nMusicTempo.Set(125);
|
|
m_SndFile.m_nDefaultTempo.Set(125);
|
|
m_SndFile.m_PlayState.m_nMusicSpeed = m_SndFile.m_nDefaultSpeed = 6;
|
|
|
|
// Set up mix levels
|
|
m_SndFile.m_PlayState.m_nGlobalVolume = m_SndFile.m_nDefaultGlobalVolume = MAX_GLOBAL_VOLUME;
|
|
m_SndFile.m_nSamplePreAmp = m_SndFile.m_nVSTiVolume = 48;
|
|
|
|
for (CHANNELINDEX nChn = 0; nChn < MAX_BASECHANNELS; nChn++)
|
|
{
|
|
m_SndFile.ChnSettings[nChn].dwFlags.reset();
|
|
m_SndFile.ChnSettings[nChn].nVolume = 64;
|
|
m_SndFile.ChnSettings[nChn].nPan = 128;
|
|
m_SndFile.m_PlayState.Chn[nChn].nGlobalVol = 64;
|
|
}
|
|
// Setup LRRL panning scheme for MODs
|
|
m_SndFile.SetupMODPanning();
|
|
}
|
|
if (!m_SndFile.m_nSamples)
|
|
{
|
|
m_SndFile.m_szNames[1] = "untitled";
|
|
m_SndFile.m_nSamples = (GetModType() == MOD_TYPE_MOD) ? 31 : 1;
|
|
|
|
SampleEdit::ResetSamples(m_SndFile, SampleEdit::SmpResetInit);
|
|
|
|
m_SndFile.GetSample(1).Initialize(m_SndFile.GetType());
|
|
|
|
if ((!m_SndFile.m_nInstruments) && (m_SndFile.GetType() & MOD_TYPE_XM))
|
|
{
|
|
if(m_SndFile.AllocateInstrument(1, 1))
|
|
{
|
|
m_SndFile.m_nInstruments = 1;
|
|
InitializeInstrument(m_SndFile.Instruments[1]);
|
|
}
|
|
}
|
|
if (m_SndFile.GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT | MOD_TYPE_XM))
|
|
{
|
|
m_SndFile.m_SongFlags.set(SONG_LINEARSLIDES);
|
|
}
|
|
}
|
|
m_SndFile.ResetPlayPos();
|
|
m_SndFile.m_songArtist = TrackerSettings::Instance().defaultArtist;
|
|
}
|
|
|
|
|
|
bool CModDoc::SetDefaultChannelColors(CHANNELINDEX minChannel, CHANNELINDEX maxChannel)
|
|
{
|
|
LimitMax(minChannel, GetNumChannels());
|
|
LimitMax(maxChannel, GetNumChannels());
|
|
if(maxChannel < minChannel)
|
|
std::swap(minChannel, maxChannel);
|
|
bool modified = false;
|
|
if(TrackerSettings::Instance().defaultRainbowChannelColors != DefaultChannelColors::NoColors)
|
|
{
|
|
const bool rainbow = TrackerSettings::Instance().defaultRainbowChannelColors == DefaultChannelColors::Rainbow;
|
|
CHANNELINDEX numGroups = 0;
|
|
if(rainbow)
|
|
{
|
|
for(CHANNELINDEX i = minChannel + 1u; i < maxChannel; i++)
|
|
{
|
|
if(m_SndFile.ChnSettings[i].szName.empty() || m_SndFile.ChnSettings[i].szName != m_SndFile.ChnSettings[i - 1].szName)
|
|
numGroups++;
|
|
}
|
|
}
|
|
const double hueFactor = rainbow ? (1.5 * mpt::numbers::pi) / std::max(1, numGroups - 1) : 1000.0; // Three quarters of the color wheel, red to purple
|
|
for(CHANNELINDEX i = minChannel, group = minChannel; i < maxChannel; i++)
|
|
{
|
|
if(i > minChannel && (m_SndFile.ChnSettings[i].szName.empty() || m_SndFile.ChnSettings[i].szName != m_SndFile.ChnSettings[i - 1].szName))
|
|
group++;
|
|
const double hue = group * hueFactor; // 0...2pi
|
|
const double saturation = 0.3; // 0...2/3
|
|
const double brightness = 1.2; // 0...4/3
|
|
const double r = brightness * (1 + saturation * (std::cos(hue) - 1.0));
|
|
const double g = brightness * (1 + saturation * (std::cos(hue - 2.09439) - 1.0));
|
|
const double b = brightness * (1 + saturation * (std::cos(hue + 2.09439) - 1.0));
|
|
const auto color = RGB(mpt::saturate_round<uint8>(r * 255), mpt::saturate_round<uint8>(g * 255), mpt::saturate_round<uint8>(b * 255));
|
|
if(m_SndFile.ChnSettings[i].color != color)
|
|
{
|
|
m_SndFile.ChnSettings[i].color = color;
|
|
modified = true;
|
|
}
|
|
}
|
|
} else
|
|
{
|
|
for(CHANNELINDEX i = minChannel; i < maxChannel; i++)
|
|
{
|
|
if(m_SndFile.ChnSettings[i].color != ModChannelSettings::INVALID_COLOR)
|
|
{
|
|
m_SndFile.ChnSettings[i].color = ModChannelSettings::INVALID_COLOR;
|
|
modified = true;
|
|
}
|
|
}
|
|
}
|
|
return modified;
|
|
}
|
|
|
|
|
|
void CModDoc::PostMessageToAllViews(UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
POSITION pos = GetFirstViewPosition();
|
|
while(pos != nullptr)
|
|
{
|
|
if(CView *pView = GetNextView(pos); pView != nullptr)
|
|
pView->PostMessage(uMsg, wParam, lParam);
|
|
}
|
|
}
|
|
|
|
|
|
void CModDoc::SendNotifyMessageToAllViews(UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
POSITION pos = GetFirstViewPosition();
|
|
while(pos != nullptr)
|
|
{
|
|
if(CView *pView = GetNextView(pos); pView != nullptr)
|
|
pView->SendNotifyMessage(uMsg, wParam, lParam);
|
|
}
|
|
}
|
|
|
|
|
|
void CModDoc::SendMessageToActiveView(UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
if(auto *lastActiveFrame = CChildFrame::LastActiveFrame(); lastActiveFrame != nullptr)
|
|
{
|
|
lastActiveFrame->SendMessageToDescendants(uMsg, wParam, lParam);
|
|
}
|
|
}
|
|
|
|
|
|
void CModDoc::ViewPattern(UINT nPat, UINT nOrd)
|
|
{
|
|
SendMessageToActiveView(WM_MOD_ACTIVATEVIEW, IDD_CONTROL_PATTERNS, ((nPat+1) << 16) | nOrd);
|
|
}
|
|
|
|
|
|
void CModDoc::ViewSample(UINT nSmp)
|
|
{
|
|
SendMessageToActiveView(WM_MOD_ACTIVATEVIEW, IDD_CONTROL_SAMPLES, nSmp);
|
|
}
|
|
|
|
|
|
void CModDoc::ViewInstrument(UINT nIns)
|
|
{
|
|
SendMessageToActiveView(WM_MOD_ACTIVATEVIEW, IDD_CONTROL_INSTRUMENTS, nIns);
|
|
}
|
|
|
|
|
|
ScopedLogCapturer::ScopedLogCapturer(CModDoc &modDoc, const CString &title, CWnd *parent, bool showLog) :
|
|
m_modDoc(modDoc), m_oldLogMode(m_modDoc.GetLogMode()), m_title(title), m_pParent(parent), m_showLog(showLog)
|
|
{
|
|
m_modDoc.SetLogMode(LogModeGather);
|
|
}
|
|
|
|
|
|
void ScopedLogCapturer::ShowLog(bool force)
|
|
{
|
|
if(force || m_oldLogMode == LogModeInstantReporting)
|
|
{
|
|
m_modDoc.ShowLog(m_title, m_pParent);
|
|
m_modDoc.ClearLog();
|
|
}
|
|
}
|
|
|
|
|
|
void ScopedLogCapturer::ShowLog(const std::string &preamble, bool force)
|
|
{
|
|
if(force || m_oldLogMode == LogModeInstantReporting)
|
|
{
|
|
m_modDoc.ShowLog(mpt::ToCString(mpt::Charset::Locale, preamble), m_title, m_pParent);
|
|
m_modDoc.ClearLog();
|
|
}
|
|
}
|
|
|
|
|
|
void ScopedLogCapturer::ShowLog(const CString &preamble, bool force)
|
|
{
|
|
if(force || m_oldLogMode == LogModeInstantReporting)
|
|
{
|
|
m_modDoc.ShowLog(preamble, m_title, m_pParent);
|
|
m_modDoc.ClearLog();
|
|
}
|
|
}
|
|
|
|
|
|
void ScopedLogCapturer::ShowLog(const mpt::ustring &preamble, bool force)
|
|
{
|
|
if(force || m_oldLogMode == LogModeInstantReporting)
|
|
{
|
|
m_modDoc.ShowLog(mpt::ToCString(preamble), m_title, m_pParent);
|
|
m_modDoc.ClearLog();
|
|
}
|
|
}
|
|
|
|
|
|
ScopedLogCapturer::~ScopedLogCapturer()
|
|
{
|
|
if(m_showLog)
|
|
ShowLog();
|
|
else
|
|
m_modDoc.ClearLog();
|
|
m_modDoc.SetLogMode(m_oldLogMode);
|
|
}
|
|
|
|
|
|
void CModDoc::AddToLog(LogLevel level, const mpt::ustring &text) const
|
|
{
|
|
if(m_LogMode == LogModeGather)
|
|
{
|
|
m_Log.push_back(LogEntry(level, text));
|
|
} else
|
|
{
|
|
if(level < LogDebug)
|
|
{
|
|
Reporting::Message(level, text);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
mpt::ustring CModDoc::GetLogString() const
|
|
{
|
|
mpt::ustring ret;
|
|
for(const auto &i : m_Log)
|
|
{
|
|
ret += i.message;
|
|
ret += U_("\r\n");
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
LogLevel CModDoc::GetMaxLogLevel() const
|
|
{
|
|
LogLevel retval = LogInformation;
|
|
// find the most severe loglevel
|
|
for(const auto &i : m_Log)
|
|
{
|
|
retval = std::min(retval, i.level);
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
|
|
void CModDoc::ClearLog()
|
|
{
|
|
m_Log.clear();
|
|
}
|
|
|
|
|
|
UINT CModDoc::ShowLog(const CString &preamble, const CString &title, CWnd *parent)
|
|
{
|
|
if(!parent) parent = CMainFrame::GetMainFrame();
|
|
if(GetLog().size() > 0)
|
|
{
|
|
LogLevel level = GetMaxLogLevel();
|
|
if(level < LogDebug)
|
|
{
|
|
CString text = preamble + mpt::ToCString(GetLogString());
|
|
CString actualTitle = (title.GetLength() == 0) ? CString(MAINFRAME_TITLE) : title;
|
|
Reporting::Message(level, text, actualTitle, parent);
|
|
return IDOK;
|
|
}
|
|
}
|
|
return IDCANCEL;
|
|
}
|
|
|
|
|
|
void CModDoc::ProcessMIDI(uint32 midiData, INSTRUMENTINDEX ins, IMixPlugin *plugin, InputTargetContext ctx)
|
|
{
|
|
static uint8 midiVolume = 127;
|
|
|
|
MIDIEvents::EventType event = MIDIEvents::GetTypeFromEvent(midiData);
|
|
const uint8 channel = MIDIEvents::GetChannelFromEvent(midiData);
|
|
const uint8 midiByte1 = MIDIEvents::GetDataByte1FromEvent(midiData);
|
|
const uint8 midiByte2 = MIDIEvents::GetDataByte2FromEvent(midiData);
|
|
uint8 note = midiByte1 + NOTE_MIN;
|
|
int vol = midiByte2;
|
|
|
|
if((event == MIDIEvents::evNoteOn) && !vol)
|
|
event = MIDIEvents::evNoteOff; //Convert event to note-off if req'd
|
|
|
|
PLUGINDEX mappedIndex = 0;
|
|
PlugParamIndex paramIndex = 0;
|
|
uint16 paramValue = 0;
|
|
bool captured = m_SndFile.GetMIDIMapper().OnMIDImsg(midiData, mappedIndex, paramIndex, paramValue);
|
|
|
|
// Handle MIDI messages assigned to shortcuts
|
|
CInputHandler *ih = CMainFrame::GetInputHandler();
|
|
if(ih->HandleMIDIMessage(ctx, midiData) != kcNull
|
|
|| ih->HandleMIDIMessage(kCtxAllContexts, midiData) != kcNull)
|
|
{
|
|
// Mapped to a command, no need to pass message on.
|
|
captured = true;
|
|
}
|
|
|
|
if(captured)
|
|
{
|
|
// Event captured by MIDI mapping or shortcut, no need to pass message on.
|
|
return;
|
|
}
|
|
|
|
switch(event)
|
|
{
|
|
case MIDIEvents::evNoteOff:
|
|
if(m_midiSustainActive[channel])
|
|
{
|
|
m_midiSustainBuffer[channel].push_back(midiData);
|
|
return;
|
|
}
|
|
if(ins > 0 && ins <= GetNumInstruments())
|
|
{
|
|
LimitMax(note, NOTE_MAX);
|
|
if(m_midiPlayingNotes[channel][note])
|
|
m_midiPlayingNotes[channel][note] = false;
|
|
NoteOff(note, false, ins, m_noteChannel[note - NOTE_MIN]);
|
|
return;
|
|
} else if(plugin != nullptr)
|
|
{
|
|
plugin->MidiSend(midiData);
|
|
}
|
|
break;
|
|
|
|
case MIDIEvents::evNoteOn:
|
|
if(ins > 0 && ins <= GetNumInstruments())
|
|
{
|
|
LimitMax(note, NOTE_MAX);
|
|
vol = CMainFrame::ApplyVolumeRelatedSettings(midiData, midiVolume);
|
|
PlayNote(PlayNoteParam(note).Instrument(ins).Volume(vol).CheckNNA(m_midiPlayingNotes[channel]), &m_noteChannel);
|
|
return;
|
|
} else if(plugin != nullptr)
|
|
{
|
|
plugin->MidiSend(midiData);
|
|
}
|
|
break;
|
|
|
|
case MIDIEvents::evControllerChange:
|
|
switch(midiByte1)
|
|
{
|
|
case MIDIEvents::MIDICC_Volume_Coarse:
|
|
midiVolume = midiByte2;
|
|
break;
|
|
case MIDIEvents::MIDICC_HoldPedal_OnOff:
|
|
m_midiSustainActive[channel] = (midiByte2 >= 0x40);
|
|
if(!m_midiSustainActive[channel])
|
|
{
|
|
// Release all notes
|
|
for(const auto offEvent : m_midiSustainBuffer[channel])
|
|
{
|
|
ProcessMIDI(offEvent, ins, plugin, ctx);
|
|
}
|
|
m_midiSustainBuffer[channel].clear();
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if((TrackerSettings::Instance().m_dwMidiSetup & MIDISETUP_MIDITOPLUG) && CMainFrame::GetMainFrame()->GetModPlaying() == this && plugin != nullptr)
|
|
{
|
|
plugin->MidiSend(midiData);
|
|
// Sending midi may modify the plug. For now, if MIDI data is not active sensing or aftertouch messages, set modified.
|
|
if(midiData != MIDIEvents::System(MIDIEvents::sysActiveSense)
|
|
&& event != MIDIEvents::evPolyAftertouch && event != MIDIEvents::evChannelAftertouch
|
|
&& event != MIDIEvents::evPitchBend
|
|
&& m_SndFile.GetModSpecifications().supportsPlugins)
|
|
{
|
|
SetModified();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
CHANNELINDEX CModDoc::PlayNote(PlayNoteParam ¶ms, NoteToChannelMap *noteChannel)
|
|
{
|
|
CHANNELINDEX channel = GetNumChannels();
|
|
|
|
ModCommand::NOTE note = params.m_note;
|
|
if(ModCommand::IsNote(ModCommand::NOTE(note)))
|
|
{
|
|
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
|
|
if(pMainFrm == nullptr || note == NOTE_NONE) return CHANNELINDEX_INVALID;
|
|
if (pMainFrm->GetModPlaying() != this)
|
|
{
|
|
// All notes off when resuming paused playback
|
|
m_SndFile.ResetChannels();
|
|
|
|
m_SndFile.m_SongFlags.set(SONG_PAUSED);
|
|
pMainFrm->PlayMod(this);
|
|
}
|
|
|
|
CriticalSection cs;
|
|
|
|
if(params.m_notesPlaying)
|
|
CheckNNA(note, params.m_instr, *params.m_notesPlaying);
|
|
|
|
// Find a channel to play on
|
|
channel = FindAvailableChannel();
|
|
ModChannel &chn = m_SndFile.m_PlayState.Chn[channel];
|
|
|
|
// reset channel properties; in theory the chan is completely unused anyway.
|
|
chn.Reset(ModChannel::resetTotal, m_SndFile, CHANNELINDEX_INVALID, CHN_MUTE);
|
|
chn.nNewNote = chn.nLastNote = static_cast<uint8>(note);
|
|
chn.nVolume = 256;
|
|
|
|
if(params.m_instr)
|
|
{
|
|
// Set instrument (or sample if there are no instruments)
|
|
chn.ResetEnvelopes();
|
|
m_SndFile.InstrumentChange(chn, params.m_instr);
|
|
} else if(params.m_sample > 0 && params.m_sample <= GetNumSamples()) // Or set sample explicitely
|
|
{
|
|
ModSample &sample = m_SndFile.GetSample(params.m_sample);
|
|
chn.pCurrentSample = sample.samplev();
|
|
chn.pModInstrument = nullptr;
|
|
chn.pModSample = &sample;
|
|
chn.nFineTune = sample.nFineTune;
|
|
chn.nC5Speed = sample.nC5Speed;
|
|
chn.nLoopStart = sample.nLoopStart;
|
|
chn.nLoopEnd = sample.nLoopEnd;
|
|
chn.dwFlags = (sample.uFlags & (CHN_SAMPLEFLAGS & ~CHN_MUTE));
|
|
chn.nPan = 128;
|
|
if(sample.uFlags[CHN_PANNING]) chn.nPan = sample.nPan;
|
|
chn.UpdateInstrumentVolume(&sample, nullptr);
|
|
}
|
|
chn.nFadeOutVol = 0x10000;
|
|
chn.isPreviewNote = true;
|
|
if(params.m_currentChannel != CHANNELINDEX_INVALID)
|
|
chn.nMasterChn = params.m_currentChannel + 1;
|
|
else
|
|
chn.nMasterChn = 0;
|
|
|
|
if(chn.dwFlags[CHN_ADLIB] && chn.pModSample && m_SndFile.m_opl)
|
|
{
|
|
m_SndFile.m_opl->Patch(channel, chn.pModSample->adlib);
|
|
}
|
|
|
|
m_SndFile.NoteChange(chn, note, false, true, true, channel);
|
|
if(params.m_volume >= 0) chn.nVolume = std::min(params.m_volume, 256);
|
|
|
|
// Handle sample looping.
|
|
// Changed line to fix http://forum.openmpt.org/index.php?topic=1700.0
|
|
//if ((loopstart + 16 < loopend) && (loopstart >= 0) && (loopend <= (LONG)pchn.nLength))
|
|
if ((params.m_loopStart + 16 < params.m_loopEnd) && (params.m_loopStart >= 0) && (chn.pModSample != nullptr))
|
|
{
|
|
chn.position.Set(params.m_loopStart);
|
|
chn.nLoopStart = params.m_loopStart;
|
|
chn.nLoopEnd = params.m_loopEnd;
|
|
chn.nLength = std::min(params.m_loopEnd, chn.pModSample->nLength);
|
|
}
|
|
|
|
// Handle extra-loud flag
|
|
chn.dwFlags.set(CHN_EXTRALOUD, !(TrackerSettings::Instance().m_dwPatternSetup & PATTERN_NOEXTRALOUD) && params.m_sample);
|
|
|
|
// Handle custom start position
|
|
if(params.m_sampleOffset > 0 && chn.pModSample)
|
|
{
|
|
chn.position.Set(params.m_sampleOffset);
|
|
// If start position is after loop end, set loop end to sample end so that the sample starts
|
|
// playing.
|
|
if(chn.nLoopEnd < params.m_sampleOffset)
|
|
chn.nLength = chn.nLoopEnd = chn.pModSample->nLength;
|
|
}
|
|
|
|
// VSTi preview
|
|
if(params.m_instr > 0 && params.m_instr <= m_SndFile.GetNumInstruments())
|
|
{
|
|
const ModInstrument *pIns = m_SndFile.Instruments[params.m_instr];
|
|
if (pIns && pIns->HasValidMIDIChannel()) // instro sends to a midi chan
|
|
{
|
|
PLUGINDEX nPlugin = 0;
|
|
if (chn.pModInstrument)
|
|
nPlugin = chn.pModInstrument->nMixPlug; // First try instrument plugin
|
|
if ((!nPlugin || nPlugin > MAX_MIXPLUGINS) && params.m_currentChannel != CHANNELINDEX_INVALID)
|
|
nPlugin = m_SndFile.ChnSettings[params.m_currentChannel].nMixPlugin; // Then try channel plugin
|
|
|
|
if ((nPlugin) && (nPlugin <= MAX_MIXPLUGINS))
|
|
{
|
|
IMixPlugin *pPlugin = m_SndFile.m_MixPlugins[nPlugin - 1].pMixPlugin;
|
|
if(pPlugin != nullptr)
|
|
{
|
|
pPlugin->MidiCommand(*pIns, pIns->NoteMap[note - NOTE_MIN], static_cast<uint16>(chn.nVolume), channel);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Remove channel from list of mixed channels to fix https://bugs.openmpt.org/view.php?id=209
|
|
// This is required because a previous note on the same channel might have just stopped playing,
|
|
// but the channel is still in the mix list.
|
|
// Since the channel volume / etc is only updated every tick in CSoundFile::ReadNote, and we
|
|
// do not want to duplicate mixmode-dependant logic here, CSoundFile::CreateStereoMix may already
|
|
// try to mix our newly set up channel at volume 0 if we don't remove it from the list.
|
|
auto mixBegin = std::begin(m_SndFile.m_PlayState.ChnMix);
|
|
auto mixEnd = std::remove(mixBegin, mixBegin + m_SndFile.m_nMixChannels, channel);
|
|
m_SndFile.m_nMixChannels = static_cast<CHANNELINDEX>(std::distance(mixBegin, mixEnd));
|
|
|
|
if(noteChannel)
|
|
{
|
|
noteChannel->at(note - NOTE_MIN) = channel;
|
|
}
|
|
} else
|
|
{
|
|
CriticalSection cs;
|
|
// Apply note cut / off / fade (also on preview channels)
|
|
m_SndFile.NoteChange(m_SndFile.m_PlayState.Chn[channel], note);
|
|
for(CHANNELINDEX c = m_SndFile.GetNumChannels(); c < MAX_CHANNELS; c++)
|
|
{
|
|
ModChannel &chn = m_SndFile.m_PlayState.Chn[c];
|
|
if(chn.isPreviewNote && (chn.pModSample || chn.pModInstrument))
|
|
{
|
|
m_SndFile.NoteChange(chn, note);
|
|
}
|
|
}
|
|
}
|
|
return channel;
|
|
}
|
|
|
|
|
|
bool CModDoc::NoteOff(UINT note, bool fade, INSTRUMENTINDEX ins, CHANNELINDEX currentChn)
|
|
{
|
|
CriticalSection cs;
|
|
|
|
if(ins != INSTRUMENTINDEX_INVALID && ins <= m_SndFile.GetNumInstruments() && ModCommand::IsNote(ModCommand::NOTE(note)))
|
|
{
|
|
const ModInstrument *pIns = m_SndFile.Instruments[ins];
|
|
if(pIns && pIns->HasValidMIDIChannel()) // instro sends to a midi chan
|
|
{
|
|
PLUGINDEX plug = pIns->nMixPlug; // First try intrument VST
|
|
if((!plug || plug > MAX_MIXPLUGINS) // No good plug yet
|
|
&& currentChn < MAX_BASECHANNELS) // Chan OK
|
|
{
|
|
plug = m_SndFile.ChnSettings[currentChn].nMixPlugin;// Then try Channel VST
|
|
}
|
|
|
|
if(plug && plug <= MAX_MIXPLUGINS)
|
|
{
|
|
IMixPlugin *pPlugin = m_SndFile.m_MixPlugins[plug - 1].pMixPlugin;
|
|
if(pPlugin)
|
|
{
|
|
pPlugin->MidiCommand(*pIns, pIns->NoteMap[note - NOTE_MIN] + NOTE_KEYOFF, 0, currentChn);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
const FlagSet<ChannelFlags> mask = (fade ? CHN_NOTEFADE : (CHN_NOTEFADE | CHN_KEYOFF));
|
|
const CHANNELINDEX startChn = currentChn != CHANNELINDEX_INVALID ? currentChn : m_SndFile.m_nChannels;
|
|
const CHANNELINDEX endChn = currentChn != CHANNELINDEX_INVALID ? currentChn + 1 : MAX_CHANNELS;
|
|
ModChannel *pChn = &m_SndFile.m_PlayState.Chn[startChn];
|
|
for(CHANNELINDEX i = startChn; i < endChn; i++, pChn++)
|
|
{
|
|
// Fade all channels > m_nChannels which are playing this note and aren't NNA channels.
|
|
if((pChn->isPreviewNote || i < m_SndFile.GetNumChannels())
|
|
&& !pChn->dwFlags[mask]
|
|
&& (pChn->nLength || pChn->dwFlags[CHN_ADLIB])
|
|
&& (note == pChn->nNewNote || note == NOTE_NONE))
|
|
{
|
|
m_SndFile.KeyOff(*pChn);
|
|
if (!m_SndFile.m_nInstruments) pChn->dwFlags.reset(CHN_LOOP | CHN_PINGPONGFLAG);
|
|
if (fade) pChn->dwFlags.set(CHN_NOTEFADE);
|
|
// Instantly stop samples that would otherwise play forever
|
|
if (pChn->pModInstrument && !pChn->pModInstrument->nFadeOut)
|
|
pChn->nFadeOutVol = 0;
|
|
if(pChn->dwFlags[CHN_ADLIB] && m_SndFile.m_opl)
|
|
{
|
|
m_SndFile.m_opl->NoteOff(i);
|
|
}
|
|
if (note) break;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// Apply DNA/NNA settings for note preview. It will also set the specified note to be playing in the playingNotes set.
|
|
void CModDoc::CheckNNA(ModCommand::NOTE note, INSTRUMENTINDEX ins, std::bitset<128> &playingNotes)
|
|
{
|
|
if(ins > GetNumInstruments() || m_SndFile.Instruments[ins] == nullptr || note >= playingNotes.size())
|
|
{
|
|
return;
|
|
}
|
|
const ModInstrument *pIns = m_SndFile.Instruments[ins];
|
|
for(CHANNELINDEX chn = GetNumChannels(); chn < MAX_CHANNELS; chn++)
|
|
{
|
|
const ModChannel &channel = m_SndFile.m_PlayState.Chn[chn];
|
|
if(channel.pModInstrument == pIns && channel.isPreviewNote && ModCommand::IsNote(channel.nLastNote)
|
|
&& (channel.nLength || pIns->HasValidMIDIChannel()) && !playingNotes[channel.nLastNote])
|
|
{
|
|
CHANNELINDEX nnaChn = m_SndFile.CheckNNA(chn, ins, note, false);
|
|
if(nnaChn != CHANNELINDEX_INVALID)
|
|
{
|
|
// Keep the new NNA channel playing in the same channel slot.
|
|
// That way, we do not need to touch the ChnMix array, and we avoid the same channel being checked twice.
|
|
if(nnaChn != chn)
|
|
{
|
|
m_SndFile.m_PlayState.Chn[chn] = std::move(m_SndFile.m_PlayState.Chn[nnaChn]);
|
|
m_SndFile.m_PlayState.Chn[nnaChn] = {};
|
|
}
|
|
// Avoid clicks if the channel wasn't ramping before.
|
|
m_SndFile.m_PlayState.Chn[chn].dwFlags.set(CHN_FASTVOLRAMP);
|
|
m_SndFile.ProcessRamping(m_SndFile.m_PlayState.Chn[chn]);
|
|
}
|
|
}
|
|
}
|
|
playingNotes.set(note);
|
|
}
|
|
|
|
|
|
// Check if a given note of an instrument or sample is playing from the editor.
|
|
// If note == 0, just check if an instrument or sample is playing.
|
|
bool CModDoc::IsNotePlaying(UINT note, SAMPLEINDEX nsmp, INSTRUMENTINDEX nins)
|
|
{
|
|
ModChannel *pChn = &m_SndFile.m_PlayState.Chn[m_SndFile.GetNumChannels()];
|
|
for (CHANNELINDEX i = m_SndFile.GetNumChannels(); i < MAX_CHANNELS; i++, pChn++) if (pChn->isPreviewNote)
|
|
{
|
|
if(pChn->nLength != 0 && !pChn->dwFlags[CHN_NOTEFADE | CHN_KEYOFF| CHN_MUTE]
|
|
&& (note == pChn->nNewNote || note == NOTE_NONE)
|
|
&& (pChn->pModSample == &m_SndFile.GetSample(nsmp) || !nsmp)
|
|
&& (pChn->pModInstrument == m_SndFile.Instruments[nins] || !nins)) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
bool CModDoc::MuteToggleModifiesDocument() const
|
|
{
|
|
return (m_SndFile.GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT | MOD_TYPE_S3M)) && TrackerSettings::Instance().MiscSaveChannelMuteStatus;
|
|
}
|
|
|
|
|
|
bool CModDoc::MuteChannel(CHANNELINDEX nChn, bool doMute)
|
|
{
|
|
if (nChn >= m_SndFile.GetNumChannels())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Mark channel as muted in channel settings
|
|
m_SndFile.ChnSettings[nChn].dwFlags.set(CHN_MUTE, doMute);
|
|
|
|
const bool success = UpdateChannelMuteStatus(nChn);
|
|
if(success && MuteToggleModifiesDocument())
|
|
{
|
|
SetModified();
|
|
}
|
|
|
|
return success;
|
|
}
|
|
|
|
|
|
bool CModDoc::UpdateChannelMuteStatus(CHANNELINDEX nChn)
|
|
{
|
|
const ChannelFlags muteType = CSoundFile::GetChannelMuteFlag();
|
|
|
|
if (nChn >= m_SndFile.GetNumChannels())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const bool doMute = m_SndFile.ChnSettings[nChn].dwFlags[CHN_MUTE];
|
|
|
|
// Mute pattern channel
|
|
if (doMute)
|
|
{
|
|
m_SndFile.m_PlayState.Chn[nChn].dwFlags.set(muteType);
|
|
if(m_SndFile.m_opl) m_SndFile.m_opl->NoteCut(nChn);
|
|
// Kill VSTi notes on muted channel.
|
|
PLUGINDEX nPlug = m_SndFile.GetBestPlugin(m_SndFile.m_PlayState, nChn, PrioritiseInstrument, EvenIfMuted);
|
|
if ((nPlug) && (nPlug<=MAX_MIXPLUGINS))
|
|
{
|
|
IMixPlugin *pPlug = m_SndFile.m_MixPlugins[nPlug - 1].pMixPlugin;
|
|
const ModInstrument* pIns = m_SndFile.m_PlayState.Chn[nChn].pModInstrument;
|
|
if (pPlug && pIns)
|
|
{
|
|
pPlug->MidiCommand(*pIns, NOTE_KEYOFF, 0, nChn);
|
|
}
|
|
}
|
|
} else
|
|
{
|
|
// On unmute alway cater for both mute types - this way there's no probs if user changes mute mode.
|
|
m_SndFile.m_PlayState.Chn[nChn].dwFlags.reset(CHN_SYNCMUTE | CHN_MUTE);
|
|
}
|
|
|
|
// Mute any NNA'd channels
|
|
for (CHANNELINDEX i = m_SndFile.GetNumChannels(); i < MAX_CHANNELS; i++)
|
|
{
|
|
if (m_SndFile.m_PlayState.Chn[i].nMasterChn == nChn + 1u)
|
|
{
|
|
if (doMute)
|
|
{
|
|
m_SndFile.m_PlayState.Chn[i].dwFlags.set(muteType);
|
|
if(m_SndFile.m_opl) m_SndFile.m_opl->NoteCut(i);
|
|
} else
|
|
{
|
|
// On unmute alway cater for both mute types - this way there's no probs if user changes mute mode.
|
|
m_SndFile.m_PlayState.Chn[i].dwFlags.reset(CHN_SYNCMUTE | CHN_MUTE);
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool CModDoc::IsChannelSolo(CHANNELINDEX nChn) const
|
|
{
|
|
if (nChn >= m_SndFile.m_nChannels) return true;
|
|
return m_SndFile.ChnSettings[nChn].dwFlags[CHN_SOLO];
|
|
}
|
|
|
|
bool CModDoc::SoloChannel(CHANNELINDEX nChn, bool bSolo)
|
|
{
|
|
if (nChn >= m_SndFile.m_nChannels) return false;
|
|
if (MuteToggleModifiesDocument()) SetModified();
|
|
m_SndFile.ChnSettings[nChn].dwFlags.set(CHN_SOLO, bSolo);
|
|
return true;
|
|
}
|
|
|
|
|
|
bool CModDoc::IsChannelNoFx(CHANNELINDEX nChn) const
|
|
{
|
|
if (nChn >= m_SndFile.m_nChannels) return true;
|
|
return m_SndFile.ChnSettings[nChn].dwFlags[CHN_NOFX];
|
|
}
|
|
|
|
|
|
bool CModDoc::NoFxChannel(CHANNELINDEX nChn, bool bNoFx, bool updateMix)
|
|
{
|
|
if (nChn >= m_SndFile.m_nChannels) return false;
|
|
m_SndFile.ChnSettings[nChn].dwFlags.set(CHN_NOFX, bNoFx);
|
|
if(updateMix) m_SndFile.m_PlayState.Chn[nChn].dwFlags.set(CHN_NOFX, bNoFx);
|
|
return true;
|
|
}
|
|
|
|
|
|
RecordGroup CModDoc::GetChannelRecordGroup(CHANNELINDEX channel) const
|
|
{
|
|
if(channel >= GetNumChannels())
|
|
return RecordGroup::NoGroup;
|
|
if(m_bsMultiRecordMask[channel])
|
|
return RecordGroup::Group1;
|
|
if(m_bsMultiSplitRecordMask[channel])
|
|
return RecordGroup::Group2;
|
|
return RecordGroup::NoGroup;
|
|
}
|
|
|
|
|
|
void CModDoc::SetChannelRecordGroup(CHANNELINDEX channel, RecordGroup recordGroup)
|
|
{
|
|
if(channel >= GetNumChannels())
|
|
return;
|
|
m_bsMultiRecordMask.set(channel, recordGroup == RecordGroup::Group1);
|
|
m_bsMultiSplitRecordMask.set(channel, recordGroup == RecordGroup::Group2);
|
|
}
|
|
|
|
|
|
void CModDoc::ToggleChannelRecordGroup(CHANNELINDEX channel, RecordGroup recordGroup)
|
|
{
|
|
if(channel >= GetNumChannels())
|
|
return;
|
|
if(recordGroup == RecordGroup::Group1)
|
|
{
|
|
m_bsMultiRecordMask.flip(channel);
|
|
m_bsMultiSplitRecordMask.reset(channel);
|
|
} else if(recordGroup == RecordGroup::Group2)
|
|
{
|
|
m_bsMultiRecordMask.reset(channel);
|
|
m_bsMultiSplitRecordMask.flip(channel);
|
|
}
|
|
}
|
|
|
|
|
|
void CModDoc::ReinitRecordState(bool unselect)
|
|
{
|
|
if(unselect)
|
|
{
|
|
m_bsMultiRecordMask.reset();
|
|
m_bsMultiSplitRecordMask.reset();
|
|
} else
|
|
{
|
|
m_bsMultiRecordMask.set();
|
|
m_bsMultiSplitRecordMask.set();
|
|
}
|
|
}
|
|
|
|
|
|
bool CModDoc::MuteSample(SAMPLEINDEX nSample, bool bMute)
|
|
{
|
|
if ((nSample < 1) || (nSample > m_SndFile.GetNumSamples())) return false;
|
|
m_SndFile.GetSample(nSample).uFlags.set(CHN_MUTE, bMute);
|
|
return true;
|
|
}
|
|
|
|
|
|
bool CModDoc::MuteInstrument(INSTRUMENTINDEX nInstr, bool bMute)
|
|
{
|
|
if ((nInstr < 1) || (nInstr > m_SndFile.GetNumInstruments()) || (!m_SndFile.Instruments[nInstr])) return false;
|
|
m_SndFile.Instruments[nInstr]->dwFlags.set(INS_MUTE, bMute);
|
|
return true;
|
|
}
|
|
|
|
|
|
bool CModDoc::SurroundChannel(CHANNELINDEX nChn, bool surround)
|
|
{
|
|
if(nChn >= m_SndFile.GetNumChannels()) return false;
|
|
|
|
if(!(m_SndFile.GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT))) surround = false;
|
|
|
|
if(surround != m_SndFile.ChnSettings[nChn].dwFlags[CHN_SURROUND])
|
|
{
|
|
// Update channel configuration
|
|
if(m_SndFile.GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT)) SetModified();
|
|
|
|
m_SndFile.ChnSettings[nChn].dwFlags.set(CHN_SURROUND, surround);
|
|
if(surround)
|
|
{
|
|
m_SndFile.ChnSettings[nChn].nPan = 128;
|
|
}
|
|
}
|
|
|
|
// Update playing channel
|
|
m_SndFile.m_PlayState.Chn[nChn].dwFlags.set(CHN_SURROUND, surround);
|
|
if(surround)
|
|
{
|
|
m_SndFile.m_PlayState.Chn[nChn].nPan = 128;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
bool CModDoc::SetChannelGlobalVolume(CHANNELINDEX nChn, uint16 nVolume)
|
|
{
|
|
bool ok = false;
|
|
if(nChn >= m_SndFile.GetNumChannels() || nVolume > 64) return false;
|
|
if(m_SndFile.ChnSettings[nChn].nVolume != nVolume)
|
|
{
|
|
m_SndFile.ChnSettings[nChn].nVolume = nVolume;
|
|
if(m_SndFile.GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT)) SetModified();
|
|
ok = true;
|
|
}
|
|
m_SndFile.m_PlayState.Chn[nChn].nGlobalVol = nVolume;
|
|
return ok;
|
|
}
|
|
|
|
|
|
bool CModDoc::SetChannelDefaultPan(CHANNELINDEX nChn, uint16 nPan)
|
|
{
|
|
bool ok = false;
|
|
if(nChn >= m_SndFile.GetNumChannels() || nPan > 256) return false;
|
|
if(m_SndFile.ChnSettings[nChn].nPan != nPan || m_SndFile.ChnSettings[nChn].dwFlags[CHN_SURROUND])
|
|
{
|
|
m_SndFile.ChnSettings[nChn].nPan = nPan;
|
|
m_SndFile.ChnSettings[nChn].dwFlags.reset(CHN_SURROUND);
|
|
if(m_SndFile.GetType() & (MOD_TYPE_S3M | MOD_TYPE_IT | MOD_TYPE_MPT)) SetModified();
|
|
ok = true;
|
|
}
|
|
m_SndFile.m_PlayState.Chn[nChn].nPan = nPan;
|
|
m_SndFile.m_PlayState.Chn[nChn].dwFlags.reset(CHN_SURROUND);
|
|
return ok;
|
|
}
|
|
|
|
|
|
bool CModDoc::IsChannelMuted(CHANNELINDEX nChn) const
|
|
{
|
|
if(nChn >= m_SndFile.GetNumChannels()) return true;
|
|
return m_SndFile.ChnSettings[nChn].dwFlags[CHN_MUTE];
|
|
}
|
|
|
|
|
|
bool CModDoc::IsSampleMuted(SAMPLEINDEX nSample) const
|
|
{
|
|
if(!nSample || nSample > m_SndFile.GetNumSamples()) return false;
|
|
return m_SndFile.GetSample(nSample).uFlags[CHN_MUTE];
|
|
}
|
|
|
|
|
|
bool CModDoc::IsInstrumentMuted(INSTRUMENTINDEX nInstr) const
|
|
{
|
|
if(!nInstr || nInstr > m_SndFile.GetNumInstruments() || !m_SndFile.Instruments[nInstr]) return false;
|
|
return m_SndFile.Instruments[nInstr]->dwFlags[INS_MUTE];
|
|
}
|
|
|
|
|
|
UINT CModDoc::GetPatternSize(PATTERNINDEX nPat) const
|
|
{
|
|
if(m_SndFile.Patterns.IsValidIndex(nPat)) return m_SndFile.Patterns[nPat].GetNumRows();
|
|
return 0;
|
|
}
|
|
|
|
|
|
void CModDoc::SetFollowWnd(HWND hwnd)
|
|
{
|
|
m_hWndFollow = hwnd;
|
|
}
|
|
|
|
|
|
bool CModDoc::IsChildSample(INSTRUMENTINDEX nIns, SAMPLEINDEX nSmp) const
|
|
{
|
|
return m_SndFile.IsSampleReferencedByInstrument(nSmp, nIns);
|
|
}
|
|
|
|
|
|
// Find an instrument that references the given sample.
|
|
// If no such instrument is found, INSTRUMENTINDEX_INVALID is returned.
|
|
INSTRUMENTINDEX CModDoc::FindSampleParent(SAMPLEINDEX sample) const
|
|
{
|
|
if(sample == 0)
|
|
{
|
|
return INSTRUMENTINDEX_INVALID;
|
|
}
|
|
for(INSTRUMENTINDEX i = 1; i <= m_SndFile.GetNumInstruments(); i++)
|
|
{
|
|
const ModInstrument *pIns = m_SndFile.Instruments[i];
|
|
if(pIns != nullptr)
|
|
{
|
|
for(size_t j = 0; j < NOTE_MAX; j++)
|
|
{
|
|
if(pIns->Keyboard[j] == sample)
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return INSTRUMENTINDEX_INVALID;
|
|
}
|
|
|
|
|
|
SAMPLEINDEX CModDoc::FindInstrumentChild(INSTRUMENTINDEX nIns) const
|
|
{
|
|
if ((!nIns) || (nIns > m_SndFile.GetNumInstruments())) return 0;
|
|
const ModInstrument *pIns = m_SndFile.Instruments[nIns];
|
|
if (pIns)
|
|
{
|
|
for (auto n : pIns->Keyboard)
|
|
{
|
|
if ((n) && (n <= m_SndFile.GetNumSamples())) return n;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
LRESULT CModDoc::ActivateView(UINT nIdView, DWORD dwParam)
|
|
{
|
|
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
|
|
if (!pMainFrm) return 0;
|
|
CMDIChildWnd *pMDIActive = pMainFrm->MDIGetActive();
|
|
if (pMDIActive)
|
|
{
|
|
CView *pView = pMDIActive->GetActiveView();
|
|
if ((pView) && (pView->GetDocument() == this))
|
|
{
|
|
return ((CChildFrame *)pMDIActive)->ActivateView(nIdView, dwParam);
|
|
}
|
|
}
|
|
POSITION pos = GetFirstViewPosition();
|
|
while (pos != NULL)
|
|
{
|
|
CView *pView = GetNextView(pos);
|
|
if ((pView) && (pView->GetDocument() == this))
|
|
{
|
|
CChildFrame *pChildFrm = (CChildFrame *)pView->GetParentFrame();
|
|
pChildFrm->MDIActivate();
|
|
return pChildFrm->ActivateView(nIdView, dwParam);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
// Activate document's window.
|
|
void CModDoc::ActivateWindow()
|
|
{
|
|
|
|
CChildFrame *pChildFrm = GetChildFrame();
|
|
if(pChildFrm) pChildFrm->MDIActivate();
|
|
}
|
|
|
|
|
|
void CModDoc::UpdateAllViews(CView *pSender, UpdateHint hint, CObject *pHint)
|
|
{
|
|
// Tunnel our UpdateHint into an LPARAM
|
|
CDocument::UpdateAllViews(pSender, hint.AsLPARAM(), pHint);
|
|
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
|
|
if (pMainFrm) pMainFrm->UpdateTree(this, hint, pHint);
|
|
|
|
if(hint.GetType()[HINT_MODCHANNELS | HINT_MODTYPE])
|
|
{
|
|
auto instance = CChannelManagerDlg::sharedInstance();
|
|
if(instance != nullptr && pHint != instance && instance->GetDocument() == this)
|
|
instance->Update(hint, pHint);
|
|
}
|
|
#ifndef NO_PLUGINS
|
|
if(hint.GetType()[HINT_MIXPLUGINS | HINT_PLUGINNAMES])
|
|
{
|
|
for(auto &plug : m_SndFile.m_MixPlugins)
|
|
{
|
|
auto mixPlug = plug.pMixPlugin;
|
|
if(mixPlug != nullptr && mixPlug->GetEditor())
|
|
{
|
|
mixPlug->GetEditor()->UpdateView(hint);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
void CModDoc::UpdateAllViews(UpdateHint hint)
|
|
{
|
|
CMainFrame::GetMainFrame()->SendNotifyMessage(WM_MOD_UPDATEVIEWS, reinterpret_cast<WPARAM>(this), hint.AsLPARAM());
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CModDoc commands
|
|
|
|
void CModDoc::OnFileWaveConvert()
|
|
{
|
|
OnFileWaveConvert(ORDERINDEX_INVALID, ORDERINDEX_INVALID);
|
|
}
|
|
|
|
|
|
void CModDoc::OnFileWaveConvert(ORDERINDEX nMinOrder, ORDERINDEX nMaxOrder, const std::vector<EncoderFactoryBase*> &encFactories)
|
|
{
|
|
ASSERT(!encFactories.empty());
|
|
|
|
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
|
|
|
|
if ((!pMainFrm) || (!m_SndFile.GetType()) || encFactories.empty()) return;
|
|
|
|
CWaveConvert wsdlg(pMainFrm, nMinOrder, nMaxOrder, m_SndFile.Order().GetLengthTailTrimmed() - 1, m_SndFile, encFactories);
|
|
{
|
|
BypassInputHandler bih;
|
|
if (wsdlg.DoModal() != IDOK) return;
|
|
}
|
|
|
|
EncoderFactoryBase *encFactory = wsdlg.m_Settings.GetEncoderFactory();
|
|
|
|
const mpt::PathString extension = encFactory->GetTraits().fileExtension;
|
|
|
|
FileDialog dlg = SaveFileDialog()
|
|
.DefaultExtension(extension)
|
|
.DefaultFilename(GetPathNameMpt().GetFileName() + P_(".") + extension)
|
|
.ExtensionFilter(encFactory->GetTraits().fileDescription + U_(" (*.") + extension.ToUnicode() + U_(")|*.") + extension.ToUnicode() + U_("||"))
|
|
.WorkingDirectory(TrackerSettings::Instance().PathExport.GetWorkingDir());
|
|
if(!wsdlg.m_Settings.outputToSample && !dlg.Show()) return;
|
|
|
|
// will set default dir here because there's no setup option for export dir yet (feel free to add one...)
|
|
TrackerSettings::Instance().PathExport.SetDefaultDir(dlg.GetWorkingDirectory(), true);
|
|
|
|
mpt::PathString drive, dir, name, ext;
|
|
dlg.GetFirstFile().SplitPath(&drive, &dir, &name, &ext);
|
|
const mpt::PathString fileName = drive + dir + name;
|
|
const mpt::PathString fileExt = ext;
|
|
|
|
const ORDERINDEX currentOrd = m_SndFile.m_PlayState.m_nCurrentOrder;
|
|
const ROWINDEX currentRow = m_SndFile.m_PlayState.m_nRow;
|
|
|
|
int nRenderPasses = 1;
|
|
// Channel mode
|
|
std::vector<bool> usedChannels;
|
|
std::vector<FlagSet<ChannelFlags>> channelFlags;
|
|
// Instrument mode
|
|
std::vector<bool> instrMuteState;
|
|
|
|
// CHN_SYNCMUTE is used with formats where CHN_MUTE would stop processing global effects and could thus mess synchronization between exported channels
|
|
const ChannelFlags muteFlag = m_SndFile.m_playBehaviour[kST3NoMutedChannels] ? CHN_SYNCMUTE : CHN_MUTE;
|
|
|
|
// Channel mode: save song in multiple wav files (one for each enabled channels)
|
|
if(wsdlg.m_bChannelMode)
|
|
{
|
|
// Don't save empty channels
|
|
CheckUsedChannels(usedChannels);
|
|
|
|
nRenderPasses = m_SndFile.GetNumChannels();
|
|
channelFlags.resize(nRenderPasses, ChannelFlags(0));
|
|
for(CHANNELINDEX i = 0; i < m_SndFile.GetNumChannels(); i++)
|
|
{
|
|
// Save channels' flags
|
|
channelFlags[i] = m_SndFile.ChnSettings[i].dwFlags;
|
|
// Ignore muted channels
|
|
if(channelFlags[i][CHN_MUTE]) usedChannels[i] = false;
|
|
// Mute each channel
|
|
m_SndFile.ChnSettings[i].dwFlags.set(muteFlag);
|
|
}
|
|
}
|
|
// Instrument mode: Same as channel mode, but renders per instrument (or sample)
|
|
if(wsdlg.m_bInstrumentMode)
|
|
{
|
|
if(m_SndFile.GetNumInstruments() == 0)
|
|
{
|
|
nRenderPasses = m_SndFile.GetNumSamples();
|
|
instrMuteState.resize(nRenderPasses, false);
|
|
for(SAMPLEINDEX i = 0; i < m_SndFile.GetNumSamples(); i++)
|
|
{
|
|
instrMuteState[i] = IsSampleMuted(i + 1);
|
|
MuteSample(i + 1, true);
|
|
}
|
|
} else
|
|
{
|
|
nRenderPasses = m_SndFile.GetNumInstruments();
|
|
instrMuteState.resize(nRenderPasses, false);
|
|
for(INSTRUMENTINDEX i = 0; i < m_SndFile.GetNumInstruments(); i++)
|
|
{
|
|
instrMuteState[i] = IsInstrumentMuted(i + 1);
|
|
MuteInstrument(i + 1, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
pMainFrm->PauseMod(this);
|
|
int oldRepeat = m_SndFile.GetRepeatCount();
|
|
|
|
const SEQUENCEINDEX currentSeq = m_SndFile.Order.GetCurrentSequenceIndex();
|
|
for(SEQUENCEINDEX seq = wsdlg.m_Settings.minSequence; seq <= wsdlg.m_Settings.maxSequence; seq++)
|
|
{
|
|
m_SndFile.Order.SetSequence(seq);
|
|
mpt::ustring fileNameAdd;
|
|
for(int i = 0; i < nRenderPasses; i++)
|
|
{
|
|
mpt::PathString thisName = fileName;
|
|
CString caption = _T("file");
|
|
fileNameAdd.clear();
|
|
if(wsdlg.m_Settings.minSequence != wsdlg.m_Settings.maxSequence)
|
|
{
|
|
fileNameAdd = MPT_UFORMAT("-{}")(mpt::ufmt::dec0<2>(seq + 1));
|
|
mpt::ustring seqName = m_SndFile.Order(seq).GetName();
|
|
if(!seqName.empty())
|
|
{
|
|
fileNameAdd += UL_("-") + seqName;
|
|
}
|
|
}
|
|
|
|
// Channel mode
|
|
if(wsdlg.m_bChannelMode)
|
|
{
|
|
// Re-mute previously processed channel
|
|
if(i > 0)
|
|
m_SndFile.ChnSettings[i - 1].dwFlags.set(muteFlag);
|
|
|
|
// Was this channel actually muted? Don't process it then.
|
|
if(!usedChannels[i])
|
|
continue;
|
|
|
|
// Add channel number & name (if available) to path string
|
|
if(!m_SndFile.ChnSettings[i].szName.empty())
|
|
{
|
|
fileNameAdd += MPT_UFORMAT("-{}_{}")(mpt::ufmt::dec0<3>(i + 1), mpt::ToUnicode(m_SndFile.GetCharsetInternal(), m_SndFile.ChnSettings[i].szName));
|
|
caption = MPT_CFORMAT("{}: {}")(i + 1, mpt::ToCString(m_SndFile.GetCharsetInternal(), m_SndFile.ChnSettings[i].szName));
|
|
} else
|
|
{
|
|
fileNameAdd += MPT_UFORMAT("-{}")(mpt::ufmt::dec0<3>(i + 1));
|
|
caption = MPT_CFORMAT("channel {}")(i + 1);
|
|
}
|
|
// Unmute channel to process
|
|
m_SndFile.ChnSettings[i].dwFlags.reset(muteFlag);
|
|
}
|
|
// Instrument mode
|
|
if(wsdlg.m_bInstrumentMode)
|
|
{
|
|
if(m_SndFile.GetNumInstruments() == 0)
|
|
{
|
|
// Re-mute previously processed sample
|
|
if(i > 0) MuteSample(static_cast<SAMPLEINDEX>(i), true);
|
|
|
|
if(!m_SndFile.GetSample(static_cast<SAMPLEINDEX>(i + 1)).HasSampleData() || !IsSampleUsed(static_cast<SAMPLEINDEX>(i + 1), false) || instrMuteState[i])
|
|
continue;
|
|
|
|
// Add sample number & name (if available) to path string
|
|
if(!m_SndFile.m_szNames[i + 1].empty())
|
|
{
|
|
fileNameAdd += MPT_UFORMAT("-{}_{}")(mpt::ufmt::dec0<3>(i + 1), mpt::ToUnicode(m_SndFile.GetCharsetInternal(), m_SndFile.m_szNames[i + 1]));
|
|
caption = MPT_CFORMAT("{}: {}")(i + 1, mpt::ToCString(m_SndFile.GetCharsetInternal(), m_SndFile.m_szNames[i + 1]));
|
|
} else
|
|
{
|
|
fileNameAdd += MPT_UFORMAT("-{}")(mpt::ufmt::dec0<3>(i + 1));
|
|
caption = MPT_CFORMAT("sample {}")(i + 1);
|
|
}
|
|
// Unmute sample to process
|
|
MuteSample(static_cast<SAMPLEINDEX>(i + 1), false);
|
|
} else
|
|
{
|
|
// Re-mute previously processed instrument
|
|
if(i > 0) MuteInstrument(static_cast<INSTRUMENTINDEX>(i), true);
|
|
|
|
if(m_SndFile.Instruments[i + 1] == nullptr || !IsInstrumentUsed(static_cast<SAMPLEINDEX>(i + 1), false) || instrMuteState[i])
|
|
continue;
|
|
|
|
if(!m_SndFile.Instruments[i + 1]->name.empty())
|
|
{
|
|
fileNameAdd += MPT_UFORMAT("-{}_{}")(mpt::ufmt::dec0<3>(i + 1), mpt::ToUnicode(m_SndFile.GetCharsetInternal(), m_SndFile.Instruments[i + 1]->name));
|
|
caption = MPT_CFORMAT("{}: {}")(i + 1, mpt::ToCString(m_SndFile.GetCharsetInternal(), m_SndFile.Instruments[i + 1]->name));
|
|
} else
|
|
{
|
|
fileNameAdd += MPT_UFORMAT("-{}")(mpt::ufmt::dec0<3>(i + 1));
|
|
caption = MPT_CFORMAT("instrument {}")(i + 1);
|
|
}
|
|
// Unmute instrument to process
|
|
MuteInstrument(static_cast<SAMPLEINDEX>(i + 1), false);
|
|
}
|
|
}
|
|
|
|
if(!fileNameAdd.empty())
|
|
{
|
|
SanitizeFilename(fileNameAdd);
|
|
thisName += mpt::PathString::FromUnicode(fileNameAdd);
|
|
}
|
|
thisName += fileExt;
|
|
if(wsdlg.m_Settings.outputToSample)
|
|
{
|
|
thisName = mpt::CreateTempFileName(P_("OpenMPT"));
|
|
// Ensure this temporary file is marked as temporary in the file system, to increase the chance it will never be written to disk
|
|
HANDLE hFile = ::CreateFile(thisName.AsNative().c_str(), GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_TEMPORARY, NULL);
|
|
if(hFile != INVALID_HANDLE_VALUE)
|
|
{
|
|
::CloseHandle(hFile);
|
|
}
|
|
}
|
|
|
|
// Render song (or current channel, or current sample/instrument)
|
|
bool cancel = true;
|
|
try
|
|
{
|
|
mpt::SafeOutputFile safeFileStream(thisName, std::ios::binary, mpt::FlushModeFromBool(TrackerSettings::Instance().MiscFlushFileBuffersOnSave));
|
|
mpt::ofstream &f = safeFileStream;
|
|
f.exceptions(f.exceptions() | std::ios::badbit | std::ios::failbit);
|
|
|
|
if(!f)
|
|
{
|
|
Reporting::Error("Could not open file for writing. Is it open in another application?");
|
|
} else
|
|
{
|
|
BypassInputHandler bih;
|
|
CDoWaveConvert dwcdlg(m_SndFile, f, caption, wsdlg.m_Settings, pMainFrm);
|
|
dwcdlg.m_bGivePlugsIdleTime = wsdlg.m_bGivePlugsIdleTime;
|
|
dwcdlg.m_dwSongLimit = wsdlg.m_dwSongLimit;
|
|
cancel = dwcdlg.DoModal() != IDOK;
|
|
}
|
|
} catch(const std::exception &)
|
|
{
|
|
Reporting::Error(_T("Error while writing file!"));
|
|
}
|
|
|
|
if(wsdlg.m_Settings.outputToSample)
|
|
{
|
|
if(!cancel)
|
|
{
|
|
InputFile f(thisName, TrackerSettings::Instance().MiscCacheCompleteFileBeforeLoading);
|
|
if(f.IsValid())
|
|
{
|
|
FileReader file = GetFileReader(f);
|
|
SAMPLEINDEX smp = wsdlg.m_Settings.sampleSlot;
|
|
if(smp == 0 || smp > GetNumSamples()) smp = m_SndFile.GetNextFreeSample();
|
|
if(smp == SAMPLEINDEX_INVALID)
|
|
{
|
|
Reporting::Error(_T("Too many samples!"));
|
|
cancel = true;
|
|
}
|
|
if(!cancel)
|
|
{
|
|
if(GetNumSamples() < smp) m_SndFile.m_nSamples = smp;
|
|
GetSampleUndo().PrepareUndo(smp, sundo_replace, "Render To Sample");
|
|
if(m_SndFile.ReadSampleFromFile(smp, file, false))
|
|
{
|
|
m_SndFile.m_szNames[smp] = "Render To Sample" + mpt::ToCharset(m_SndFile.GetCharsetInternal(), fileNameAdd);
|
|
UpdateAllViews(nullptr, SampleHint().Info().Data().Names());
|
|
if(m_SndFile.GetNumInstruments() && !IsSampleUsed(smp))
|
|
{
|
|
// Insert new instrument for the generated sample in case it is not referenced by any instruments yet.
|
|
// It should only be already referenced if the user chose to export to an existing sample slot.
|
|
InsertInstrument(smp);
|
|
UpdateAllViews(nullptr, InstrumentHint().Info().Names());
|
|
}
|
|
SetModified();
|
|
} else
|
|
{
|
|
GetSampleUndo().RemoveLastUndoStep(smp);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Always clean up after ourselves
|
|
for(int retry = 0; retry < 10; retry++)
|
|
{
|
|
// stupid virus scanners
|
|
if(DeleteFile(thisName.AsNative().c_str()) != EACCES)
|
|
{
|
|
break;
|
|
}
|
|
Sleep(10);
|
|
}
|
|
}
|
|
|
|
if(cancel) break;
|
|
}
|
|
}
|
|
|
|
// Restore channels' flags
|
|
if(wsdlg.m_bChannelMode)
|
|
{
|
|
for(CHANNELINDEX i = 0; i < m_SndFile.GetNumChannels(); i++)
|
|
{
|
|
m_SndFile.ChnSettings[i].dwFlags = channelFlags[i];
|
|
}
|
|
}
|
|
// Restore instruments' / samples' flags
|
|
if(wsdlg.m_bInstrumentMode)
|
|
{
|
|
for(size_t i = 0; i < instrMuteState.size(); i++)
|
|
{
|
|
if(m_SndFile.GetNumInstruments() == 0)
|
|
MuteSample(static_cast<SAMPLEINDEX>(i + 1), instrMuteState[i]);
|
|
else
|
|
MuteInstrument(static_cast<INSTRUMENTINDEX>(i + 1), instrMuteState[i]);
|
|
}
|
|
}
|
|
|
|
m_SndFile.Order.SetSequence(currentSeq);
|
|
m_SndFile.SetRepeatCount(oldRepeat);
|
|
m_SndFile.GetLength(eAdjust, GetLengthTarget(currentOrd, currentRow));
|
|
m_SndFile.m_PlayState.m_nNextOrder = currentOrd;
|
|
m_SndFile.m_PlayState.m_nNextRow = currentRow;
|
|
CMainFrame::UpdateAudioParameters(m_SndFile, true);
|
|
}
|
|
|
|
|
|
void CModDoc::OnFileWaveConvert(ORDERINDEX nMinOrder, ORDERINDEX nMaxOrder)
|
|
{
|
|
WAVEncoder wavencoder;
|
|
FLACEncoder flacencoder;
|
|
AUEncoder auencoder;
|
|
OggOpusEncoder opusencoder;
|
|
VorbisEncoder vorbisencoder;
|
|
MP3Encoder mp3lame(MP3EncoderLame);
|
|
MP3Encoder mp3lamecompatible(MP3EncoderLameCompatible);
|
|
RAWEncoder rawencoder;
|
|
std::vector<EncoderFactoryBase*> encoders;
|
|
if(wavencoder.IsAvailable()) encoders.push_back(&wavencoder);
|
|
if(flacencoder.IsAvailable()) encoders.push_back(&flacencoder);
|
|
if(auencoder.IsAvailable()) encoders.push_back(&auencoder);
|
|
if(rawencoder.IsAvailable()) encoders.push_back(&rawencoder);
|
|
if(opusencoder.IsAvailable()) encoders.push_back(&opusencoder);
|
|
if(vorbisencoder.IsAvailable()) encoders.push_back(&vorbisencoder);
|
|
if(mp3lame.IsAvailable())
|
|
{
|
|
encoders.push_back(&mp3lame);
|
|
}
|
|
if(mp3lamecompatible.IsAvailable()) encoders.push_back(&mp3lamecompatible);
|
|
OnFileWaveConvert(nMinOrder, nMaxOrder, encoders);
|
|
}
|
|
|
|
|
|
void CModDoc::OnFileMidiConvert()
|
|
{
|
|
#ifndef NO_PLUGINS
|
|
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
|
|
|
|
if ((!pMainFrm) || (!m_SndFile.GetType())) return;
|
|
|
|
mpt::PathString filename = GetPathNameMpt().ReplaceExt(P_(".mid"));
|
|
|
|
FileDialog dlg = SaveFileDialog()
|
|
.DefaultExtension("mid")
|
|
.DefaultFilename(filename)
|
|
.ExtensionFilter("MIDI Files (*.mid)|*.mid||");
|
|
if(!dlg.Show()) return;
|
|
|
|
CModToMidi mididlg(m_SndFile, pMainFrm);
|
|
BypassInputHandler bih;
|
|
if(mididlg.DoModal() == IDOK)
|
|
{
|
|
try
|
|
{
|
|
mpt::SafeOutputFile sf(dlg.GetFirstFile(), std::ios::binary, mpt::FlushModeFromBool(TrackerSettings::Instance().MiscFlushFileBuffersOnSave));
|
|
mpt::ofstream &f = sf;
|
|
f.exceptions(f.exceptions() | std::ios::badbit | std::ios::failbit);
|
|
|
|
if(!f.good())
|
|
{
|
|
Reporting::Error("Could not open file for writing. Is it open in another application?");
|
|
return;
|
|
}
|
|
|
|
CDoMidiConvert doconv(m_SndFile, f, mididlg.m_instrMap);
|
|
doconv.DoModal();
|
|
} catch(const std::exception &)
|
|
{
|
|
Reporting::Error(_T("Error while writing file!"));
|
|
}
|
|
}
|
|
#else
|
|
Reporting::Error("In order to use MIDI export, OpenMPT must be built with plugin support.");
|
|
#endif // NO_PLUGINS
|
|
}
|
|
|
|
//HACK: This is a quick fix. Needs to be better integrated into player and GUI.
|
|
void CModDoc::OnFileCompatibilitySave()
|
|
{
|
|
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
|
|
if (!pMainFrm) return;
|
|
|
|
CString pattern;
|
|
|
|
const MODTYPE type = m_SndFile.GetType();
|
|
switch(type)
|
|
{
|
|
case MOD_TYPE_IT:
|
|
pattern = FileFilterIT;
|
|
MsgBoxHidable(CompatExportDefaultWarning);
|
|
break;
|
|
case MOD_TYPE_XM:
|
|
pattern = FileFilterXM;
|
|
MsgBoxHidable(CompatExportDefaultWarning);
|
|
break;
|
|
default:
|
|
// Not available for this format.
|
|
return;
|
|
}
|
|
|
|
const std::string ext = m_SndFile.GetModSpecifications().fileExtension;
|
|
|
|
mpt::PathString filename;
|
|
|
|
{
|
|
mpt::PathString drive;
|
|
mpt::PathString dir;
|
|
mpt::PathString fileName;
|
|
GetPathNameMpt().SplitPath(&drive, &dir, &fileName, nullptr);
|
|
|
|
filename = drive;
|
|
filename += dir;
|
|
filename += fileName;
|
|
if(!strstr(fileName.ToUTF8().c_str(), "compat"))
|
|
filename += P_(".compat.");
|
|
else
|
|
filename += P_(".");
|
|
filename += mpt::PathString::FromUTF8(ext);
|
|
}
|
|
|
|
FileDialog dlg = SaveFileDialog()
|
|
.DefaultExtension(ext)
|
|
.DefaultFilename(filename)
|
|
.ExtensionFilter(pattern)
|
|
.WorkingDirectory(TrackerSettings::Instance().PathSongs.GetWorkingDir());
|
|
if(!dlg.Show()) return;
|
|
|
|
filename = dlg.GetFirstFile();
|
|
|
|
bool ok = false;
|
|
BeginWaitCursor();
|
|
try
|
|
{
|
|
mpt::SafeOutputFile sf(filename, std::ios::binary, mpt::FlushModeFromBool(TrackerSettings::Instance().MiscFlushFileBuffersOnSave));
|
|
mpt::ofstream &f = sf;
|
|
if(f)
|
|
{
|
|
f.exceptions(f.exceptions() | std::ios::badbit | std::ios::failbit);
|
|
ScopedLogCapturer logcapturer(*this);
|
|
FixNullStrings();
|
|
switch(type)
|
|
{
|
|
case MOD_TYPE_XM: ok = m_SndFile.SaveXM(f, true); break;
|
|
case MOD_TYPE_IT: ok = m_SndFile.SaveIT(f, filename, true); break;
|
|
default: MPT_ASSERT_NOTREACHED();
|
|
}
|
|
}
|
|
} catch(const std::exception &)
|
|
{
|
|
ok = false;
|
|
}
|
|
EndWaitCursor();
|
|
|
|
if(!ok)
|
|
{
|
|
ErrorBox(IDS_ERR_SAVESONG, CMainFrame::GetMainFrame());
|
|
}
|
|
}
|
|
|
|
|
|
void CModDoc::OnPlayerPlay()
|
|
{
|
|
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
|
|
if (pMainFrm)
|
|
{
|
|
CChildFrame *pChildFrm = GetChildFrame();
|
|
if (strcmp("CViewPattern", pChildFrm->GetCurrentViewClassName()) == 0)
|
|
{
|
|
//User has sent play song command: set loop pattern checkbox to false.
|
|
pChildFrm->SendViewMessage(VIEWMSG_PATTERNLOOP, 0);
|
|
}
|
|
|
|
bool isPlaying = (pMainFrm->GetModPlaying() == this);
|
|
if(isPlaying && !m_SndFile.m_SongFlags[SONG_PAUSED | SONG_STEP/*|SONG_PATTERNLOOP*/])
|
|
{
|
|
OnPlayerPause();
|
|
return;
|
|
}
|
|
|
|
CriticalSection cs;
|
|
|
|
// Kill editor voices
|
|
for(CHANNELINDEX i = m_SndFile.GetNumChannels(); i < MAX_CHANNELS; i++) if (m_SndFile.m_PlayState.Chn[i].isPreviewNote)
|
|
{
|
|
m_SndFile.m_PlayState.Chn[i].dwFlags.set(CHN_NOTEFADE | CHN_KEYOFF);
|
|
if (!isPlaying) m_SndFile.m_PlayState.Chn[i].nLength = 0;
|
|
}
|
|
|
|
m_SndFile.m_PlayState.m_bPositionChanged = true;
|
|
|
|
if(isPlaying)
|
|
{
|
|
m_SndFile.StopAllVsti();
|
|
}
|
|
|
|
cs.Leave();
|
|
|
|
m_SndFile.m_SongFlags.reset(SONG_STEP | SONG_PAUSED | SONG_PATTERNLOOP);
|
|
pMainFrm->PlayMod(this);
|
|
}
|
|
}
|
|
|
|
|
|
void CModDoc::OnPlayerPause()
|
|
{
|
|
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
|
|
if (pMainFrm)
|
|
{
|
|
if (pMainFrm->GetModPlaying() == this)
|
|
{
|
|
bool isLooping = m_SndFile.m_SongFlags[SONG_PATTERNLOOP];
|
|
PATTERNINDEX nPat = m_SndFile.m_PlayState.m_nPattern;
|
|
ROWINDEX nRow = m_SndFile.m_PlayState.m_nRow;
|
|
ROWINDEX nNextRow = m_SndFile.m_PlayState.m_nNextRow;
|
|
pMainFrm->PauseMod();
|
|
|
|
if ((isLooping) && (nPat < m_SndFile.Patterns.Size()))
|
|
{
|
|
CriticalSection cs;
|
|
|
|
if ((m_SndFile.m_PlayState.m_nCurrentOrder < m_SndFile.Order().GetLength()) && (m_SndFile.Order()[m_SndFile.m_PlayState.m_nCurrentOrder] == nPat))
|
|
{
|
|
m_SndFile.m_PlayState.m_nNextOrder = m_SndFile.m_PlayState.m_nCurrentOrder;
|
|
m_SndFile.m_PlayState.m_nNextRow = nNextRow;
|
|
m_SndFile.m_PlayState.m_nRow = nRow;
|
|
} else
|
|
{
|
|
for (ORDERINDEX nOrd = 0; nOrd < m_SndFile.Order().GetLength(); nOrd++)
|
|
{
|
|
if (m_SndFile.Order()[nOrd] == m_SndFile.Order.GetInvalidPatIndex()) break;
|
|
if (m_SndFile.Order()[nOrd] == nPat)
|
|
{
|
|
m_SndFile.m_PlayState.m_nCurrentOrder = nOrd;
|
|
m_SndFile.m_PlayState.m_nNextOrder = nOrd;
|
|
m_SndFile.m_PlayState.m_nNextRow = nNextRow;
|
|
m_SndFile.m_PlayState.m_nRow = nRow;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else
|
|
{
|
|
pMainFrm->PauseMod();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CModDoc::OnPlayerStop()
|
|
{
|
|
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
|
|
if (pMainFrm) pMainFrm->StopMod();
|
|
}
|
|
|
|
|
|
void CModDoc::OnPlayerPlayFromStart()
|
|
{
|
|
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
|
|
if (pMainFrm)
|
|
{
|
|
CChildFrame *pChildFrm = GetChildFrame();
|
|
if (strcmp("CViewPattern", pChildFrm->GetCurrentViewClassName()) == 0)
|
|
{
|
|
//User has sent play song command: set loop pattern checkbox to false.
|
|
pChildFrm->SendViewMessage(VIEWMSG_PATTERNLOOP, 0);
|
|
}
|
|
|
|
pMainFrm->PauseMod();
|
|
CriticalSection cs;
|
|
m_SndFile.m_SongFlags.reset(SONG_STEP | SONG_PATTERNLOOP);
|
|
m_SndFile.ResetPlayPos();
|
|
//m_SndFile.visitedSongRows.Initialize(true);
|
|
|
|
m_SndFile.m_PlayState.m_bPositionChanged = true;
|
|
|
|
cs.Leave();
|
|
|
|
pMainFrm->PlayMod(this);
|
|
}
|
|
}
|
|
|
|
|
|
void CModDoc::OnEditGlobals()
|
|
{
|
|
SendMessageToActiveView(WM_MOD_ACTIVATEVIEW, IDD_CONTROL_GLOBALS);
|
|
}
|
|
|
|
|
|
void CModDoc::OnEditPatterns()
|
|
{
|
|
SendMessageToActiveView(WM_MOD_ACTIVATEVIEW, IDD_CONTROL_PATTERNS, -1);
|
|
}
|
|
|
|
|
|
void CModDoc::OnEditSamples()
|
|
{
|
|
SendMessageToActiveView(WM_MOD_ACTIVATEVIEW, IDD_CONTROL_SAMPLES, -1);
|
|
}
|
|
|
|
|
|
void CModDoc::OnEditInstruments()
|
|
{
|
|
SendMessageToActiveView(WM_MOD_ACTIVATEVIEW, IDD_CONTROL_INSTRUMENTS, -1);
|
|
}
|
|
|
|
|
|
void CModDoc::OnEditComments()
|
|
{
|
|
SendMessageToActiveView(WM_MOD_ACTIVATEVIEW, IDD_CONTROL_COMMENTS);
|
|
}
|
|
|
|
|
|
void CModDoc::OnShowCleanup()
|
|
{
|
|
CModCleanupDlg dlg(*this, CMainFrame::GetMainFrame());
|
|
dlg.DoModal();
|
|
}
|
|
|
|
|
|
void CModDoc::OnSetupZxxMacros()
|
|
{
|
|
CMidiMacroSetup dlg(m_SndFile);
|
|
if(dlg.DoModal() == IDOK)
|
|
{
|
|
if(m_SndFile.m_MidiCfg != dlg.m_MidiCfg)
|
|
{
|
|
m_SndFile.m_MidiCfg = dlg.m_MidiCfg;
|
|
SetModified();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Enable menu item only module types that support MIDI Mappings
|
|
void CModDoc::OnUpdateHasMIDIMappings(CCmdUI *p)
|
|
{
|
|
if(p)
|
|
p->Enable((m_SndFile.GetModSpecifications().MIDIMappingDirectivesMax > 0) ? TRUE : FALSE);
|
|
}
|
|
|
|
|
|
// Enable menu item only for IT / MPTM / XM files
|
|
void CModDoc::OnUpdateXMITMPTOnly(CCmdUI *p)
|
|
{
|
|
if (p)
|
|
p->Enable((m_SndFile.GetType() & (MOD_TYPE_XM | MOD_TYPE_IT | MOD_TYPE_MPT)) ? TRUE : FALSE);
|
|
}
|
|
|
|
|
|
// Enable menu item only for IT / MPTM files
|
|
void CModDoc::OnUpdateHasEditHistory(CCmdUI *p)
|
|
{
|
|
if (p)
|
|
p->Enable(((m_SndFile.GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT)) || !m_SndFile.GetFileHistory().empty()) ? TRUE : FALSE);
|
|
}
|
|
|
|
|
|
// Enable menu item if current module type supports compatibility export
|
|
void CModDoc::OnUpdateCompatExportableOnly(CCmdUI *p)
|
|
{
|
|
if(p)
|
|
p->Enable((m_SndFile.GetType() & (MOD_TYPE_XM | MOD_TYPE_IT)) ? TRUE : FALSE);
|
|
}
|
|
|
|
|
|
static CString FormatSongLength(double length)
|
|
{
|
|
length = mpt::round(length);
|
|
double minutes = std::floor(length / 60.0), seconds = std::fmod(length, 60.0);
|
|
CString s;
|
|
s.Format(_T("%.0fmn%02.0fs"), minutes, seconds);
|
|
return s;
|
|
}
|
|
|
|
|
|
void CModDoc::OnEstimateSongLength()
|
|
{
|
|
CString s = _T("Approximate song length: ");
|
|
const auto subSongs = m_SndFile.GetAllSubSongs();
|
|
if (subSongs.empty())
|
|
{
|
|
Reporting::Information(_T("No patterns found!"));
|
|
return;
|
|
}
|
|
|
|
std::vector<uint32> songsPerSequence(m_SndFile.Order.GetNumSequences(), 0);
|
|
SEQUENCEINDEX prevSeq = subSongs[0].sequence;
|
|
for(const auto &song : subSongs)
|
|
{
|
|
songsPerSequence[song.sequence]++;
|
|
if(prevSeq != song.sequence)
|
|
prevSeq = SEQUENCEINDEX_INVALID;
|
|
}
|
|
|
|
double totalLength = 0.0;
|
|
uint32 songCount = 0;
|
|
// If there are multiple sequences, indent their subsongs
|
|
const TCHAR *indent = (prevSeq == SEQUENCEINDEX_INVALID) ? _T("\t") : _T("");
|
|
for(const auto &song : subSongs)
|
|
{
|
|
double songLength = song.duration;
|
|
if(subSongs.size() > 1)
|
|
{
|
|
totalLength += songLength;
|
|
if(prevSeq != song.sequence)
|
|
{
|
|
songCount = 0;
|
|
prevSeq = song.sequence;
|
|
if(m_SndFile.Order(prevSeq).GetName().empty())
|
|
s.AppendFormat(_T("\nSequence %u:"), prevSeq + 1u);
|
|
else
|
|
s.AppendFormat(_T("\nSequence %u (%s):"), prevSeq + 1u, mpt::ToWin(m_SndFile.Order(prevSeq).GetName()).c_str());
|
|
}
|
|
songCount++;
|
|
if(songsPerSequence[song.sequence] > 1)
|
|
s.AppendFormat(_T("\n%sSong %u, starting at order %u:\t"), indent, songCount, song.startOrder);
|
|
else
|
|
s.AppendChar(_T('\t'));
|
|
}
|
|
if(songLength != std::numeric_limits<double>::infinity())
|
|
{
|
|
songLength = mpt::round(songLength);
|
|
s += FormatSongLength(songLength);
|
|
} else
|
|
{
|
|
s += _T("Song too long!");
|
|
}
|
|
}
|
|
if(subSongs.size() > 1 && totalLength != std::numeric_limits<double>::infinity())
|
|
{
|
|
s += _T("\n\nTotal length:\t") + FormatSongLength(totalLength);
|
|
}
|
|
|
|
Reporting::Information(s);
|
|
}
|
|
|
|
|
|
void CModDoc::OnApproximateBPM()
|
|
{
|
|
if(CMainFrame::GetMainFrame()->GetModPlaying() != this)
|
|
{
|
|
m_SndFile.m_PlayState.m_nCurrentRowsPerBeat = m_SndFile.m_nDefaultRowsPerBeat;
|
|
m_SndFile.m_PlayState.m_nCurrentRowsPerMeasure = m_SndFile.m_nDefaultRowsPerMeasure;
|
|
}
|
|
m_SndFile.RecalculateSamplesPerTick();
|
|
const double bpm = m_SndFile.GetCurrentBPM();
|
|
|
|
CString s;
|
|
switch(m_SndFile.m_nTempoMode)
|
|
{
|
|
case TempoMode::Alternative:
|
|
s.Format(_T("Using alternative tempo interpretation.\n\nAssuming:\n. %.8g ticks per second\n. %u ticks per row\n. %u rows per beat\nthe tempo is approximately: %.8g BPM"),
|
|
m_SndFile.m_PlayState.m_nMusicTempo.ToDouble(), m_SndFile.m_PlayState.m_nMusicSpeed, m_SndFile.m_PlayState.m_nCurrentRowsPerBeat, bpm);
|
|
break;
|
|
|
|
case TempoMode::Modern:
|
|
s.Format(_T("Using modern tempo interpretation.\n\nThe tempo is: %.8g BPM"), bpm);
|
|
break;
|
|
|
|
case TempoMode::Classic:
|
|
default:
|
|
s.Format(_T("Using standard tempo interpretation.\n\nAssuming:\n. A mod tempo (tick duration factor) of %.8g\n. %u ticks per row\n. %u rows per beat\nthe tempo is approximately: %.8g BPM"),
|
|
m_SndFile.m_PlayState.m_nMusicTempo.ToDouble(), m_SndFile.m_PlayState.m_nMusicSpeed, m_SndFile.m_PlayState.m_nCurrentRowsPerBeat, bpm);
|
|
break;
|
|
}
|
|
|
|
Reporting::Information(s);
|
|
}
|
|
|
|
|
|
CChildFrame *CModDoc::GetChildFrame()
|
|
{
|
|
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
|
|
if (!pMainFrm) return nullptr;
|
|
CMDIChildWnd *pMDIActive = pMainFrm->MDIGetActive();
|
|
if (pMDIActive)
|
|
{
|
|
CView *pView = pMDIActive->GetActiveView();
|
|
if ((pView) && (pView->GetDocument() == this))
|
|
return static_cast<CChildFrame *>(pMDIActive);
|
|
}
|
|
POSITION pos = GetFirstViewPosition();
|
|
while (pos != NULL)
|
|
{
|
|
CView *pView = GetNextView(pos);
|
|
if ((pView) && (pView->GetDocument() == this))
|
|
return static_cast<CChildFrame *>(pView->GetParentFrame());
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
|
|
// Get the currently edited pattern position. Note that ord might be ORDERINDEX_INVALID when editing a pattern that is not present in the order list.
|
|
void CModDoc::GetEditPosition(ROWINDEX &row, PATTERNINDEX &pat, ORDERINDEX &ord)
|
|
{
|
|
CChildFrame *pChildFrm = GetChildFrame();
|
|
|
|
if(strcmp("CViewPattern", pChildFrm->GetCurrentViewClassName()) == 0) // dirty HACK
|
|
{
|
|
PATTERNVIEWSTATE patternViewState;
|
|
pChildFrm->SendViewMessage(VIEWMSG_SAVESTATE, (LPARAM)(&patternViewState));
|
|
|
|
pat = patternViewState.nPattern;
|
|
row = patternViewState.cursor.GetRow();
|
|
ord = patternViewState.nOrder;
|
|
} else
|
|
{
|
|
//patern editor object does not exist (i.e. is not active) - use saved state.
|
|
PATTERNVIEWSTATE &patternViewState = pChildFrm->GetPatternViewState();
|
|
|
|
pat = patternViewState.nPattern;
|
|
row = patternViewState.cursor.GetRow();
|
|
ord = patternViewState.nOrder;
|
|
}
|
|
|
|
const auto &order = m_SndFile.Order();
|
|
if(order.empty())
|
|
{
|
|
ord = ORDERINDEX_INVALID;
|
|
pat = 0;
|
|
row = 0;
|
|
} else if(ord >= order.size())
|
|
{
|
|
ord = 0;
|
|
pat = m_SndFile.Order()[ord];
|
|
}
|
|
if(!m_SndFile.Patterns.IsValidPat(pat))
|
|
{
|
|
pat = 0;
|
|
row = 0;
|
|
} else if(row >= m_SndFile.Patterns[pat].GetNumRows())
|
|
{
|
|
row = 0;
|
|
}
|
|
|
|
//ensure order correlates with pattern.
|
|
if(ord >= order.size() || order[ord] != pat)
|
|
{
|
|
ord = order.FindOrder(pat);
|
|
}
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////
|
|
// Playback
|
|
|
|
|
|
void CModDoc::OnPatternRestart(bool loop)
|
|
{
|
|
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
|
|
CChildFrame *pChildFrm = GetChildFrame();
|
|
|
|
if ((pMainFrm) && (pChildFrm))
|
|
{
|
|
if (strcmp("CViewPattern", pChildFrm->GetCurrentViewClassName()) == 0)
|
|
{
|
|
//User has sent play pattern command: set loop pattern checkbox to true.
|
|
pChildFrm->SendViewMessage(VIEWMSG_PATTERNLOOP, loop ? 1 : 0);
|
|
}
|
|
|
|
ROWINDEX nRow;
|
|
PATTERNINDEX nPat;
|
|
ORDERINDEX nOrd;
|
|
GetEditPosition(nRow, nPat, nOrd);
|
|
CModDoc *pModPlaying = pMainFrm->GetModPlaying();
|
|
|
|
CriticalSection cs;
|
|
|
|
// Cut instruments/samples
|
|
for(auto &chn : m_SndFile.m_PlayState.Chn)
|
|
{
|
|
chn.nPatternLoopCount = 0;
|
|
chn.nPatternLoop = 0;
|
|
chn.nFadeOutVol = 0;
|
|
chn.dwFlags.set(CHN_NOTEFADE | CHN_KEYOFF);
|
|
}
|
|
if ((nOrd < m_SndFile.Order().size()) && (m_SndFile.Order()[nOrd] == nPat)) m_SndFile.m_PlayState.m_nCurrentOrder = m_SndFile.m_PlayState.m_nNextOrder = nOrd;
|
|
m_SndFile.m_SongFlags.reset(SONG_PAUSED | SONG_STEP);
|
|
if(loop)
|
|
m_SndFile.LoopPattern(nPat);
|
|
else
|
|
m_SndFile.LoopPattern(PATTERNINDEX_INVALID);
|
|
|
|
// set playback timer in the status bar (and update channel status)
|
|
SetElapsedTime(nOrd, 0, true);
|
|
|
|
if(pModPlaying == this)
|
|
{
|
|
m_SndFile.StopAllVsti();
|
|
}
|
|
|
|
cs.Leave();
|
|
|
|
if(pModPlaying != this)
|
|
{
|
|
SetNotifications(m_notifyType | Notification::Position | Notification::VUMeters, m_notifyItem);
|
|
SetFollowWnd(pChildFrm->GetHwndView());
|
|
pMainFrm->PlayMod(this); //rewbs.fix2977
|
|
}
|
|
}
|
|
//SwitchToView();
|
|
}
|
|
|
|
void CModDoc::OnPatternPlay()
|
|
{
|
|
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
|
|
CChildFrame *pChildFrm = GetChildFrame();
|
|
|
|
if ((pMainFrm) && (pChildFrm))
|
|
{
|
|
if (strcmp("CViewPattern", pChildFrm->GetCurrentViewClassName()) == 0)
|
|
{
|
|
//User has sent play pattern command: set loop pattern checkbox to true.
|
|
pChildFrm->SendViewMessage(VIEWMSG_PATTERNLOOP, 1);
|
|
}
|
|
|
|
ROWINDEX nRow;
|
|
PATTERNINDEX nPat;
|
|
ORDERINDEX nOrd;
|
|
GetEditPosition(nRow, nPat, nOrd);
|
|
CModDoc *pModPlaying = pMainFrm->GetModPlaying();
|
|
|
|
CriticalSection cs;
|
|
|
|
// Cut instruments/samples
|
|
for(CHANNELINDEX i = m_SndFile.GetNumChannels(); i < MAX_CHANNELS; i++)
|
|
{
|
|
m_SndFile.m_PlayState.Chn[i].dwFlags.set(CHN_NOTEFADE | CHN_KEYOFF);
|
|
}
|
|
if ((nOrd < m_SndFile.Order().size()) && (m_SndFile.Order()[nOrd] == nPat)) m_SndFile.m_PlayState.m_nCurrentOrder = m_SndFile.m_PlayState.m_nNextOrder = nOrd;
|
|
m_SndFile.m_SongFlags.reset(SONG_PAUSED | SONG_STEP);
|
|
m_SndFile.LoopPattern(nPat);
|
|
|
|
// set playback timer in the status bar (and update channel status)
|
|
SetElapsedTime(nOrd, nRow, true);
|
|
|
|
if(pModPlaying == this)
|
|
{
|
|
m_SndFile.StopAllVsti();
|
|
}
|
|
|
|
cs.Leave();
|
|
|
|
if(pModPlaying != this)
|
|
{
|
|
SetNotifications(m_notifyType | Notification::Position | Notification::VUMeters, m_notifyItem);
|
|
SetFollowWnd(pChildFrm->GetHwndView());
|
|
pMainFrm->PlayMod(this); //rewbs.fix2977
|
|
}
|
|
}
|
|
//SwitchToView();
|
|
|
|
}
|
|
|
|
void CModDoc::OnPatternPlayNoLoop()
|
|
{
|
|
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
|
|
CChildFrame *pChildFrm = GetChildFrame();
|
|
|
|
if ((pMainFrm) && (pChildFrm))
|
|
{
|
|
if (strcmp("CViewPattern", pChildFrm->GetCurrentViewClassName()) == 0)
|
|
{
|
|
//User has sent play song command: set loop pattern checkbox to false.
|
|
pChildFrm->SendViewMessage(VIEWMSG_PATTERNLOOP, 0);
|
|
}
|
|
|
|
ROWINDEX nRow;
|
|
PATTERNINDEX nPat;
|
|
ORDERINDEX nOrd;
|
|
GetEditPosition(nRow, nPat, nOrd);
|
|
CModDoc *pModPlaying = pMainFrm->GetModPlaying();
|
|
|
|
CriticalSection cs;
|
|
// Cut instruments/samples
|
|
for(CHANNELINDEX i = m_SndFile.GetNumChannels(); i < MAX_CHANNELS; i++)
|
|
{
|
|
m_SndFile.m_PlayState.Chn[i].dwFlags.set(CHN_NOTEFADE | CHN_KEYOFF);
|
|
}
|
|
m_SndFile.m_SongFlags.reset(SONG_PAUSED | SONG_STEP);
|
|
m_SndFile.SetCurrentOrder(nOrd);
|
|
if(nOrd < m_SndFile.Order().size() && m_SndFile.Order()[nOrd] == nPat)
|
|
m_SndFile.DontLoopPattern(nPat, nRow);
|
|
else
|
|
m_SndFile.LoopPattern(nPat);
|
|
|
|
// set playback timer in the status bar (and update channel status)
|
|
SetElapsedTime(nOrd, nRow, true);
|
|
|
|
if(pModPlaying == this)
|
|
{
|
|
m_SndFile.StopAllVsti();
|
|
}
|
|
|
|
cs.Leave();
|
|
|
|
if(pModPlaying != this)
|
|
{
|
|
SetNotifications(m_notifyType | Notification::Position | Notification::VUMeters, m_notifyItem);
|
|
SetFollowWnd(pChildFrm->GetHwndView());
|
|
pMainFrm->PlayMod(this); //rewbs.fix2977
|
|
}
|
|
}
|
|
//SwitchToView();
|
|
}
|
|
|
|
|
|
void CModDoc::OnViewEditHistory()
|
|
{
|
|
CEditHistoryDlg dlg(CMainFrame::GetMainFrame(), *this);
|
|
dlg.DoModal();
|
|
}
|
|
|
|
|
|
void CModDoc::OnViewMPTHacks()
|
|
{
|
|
ScopedLogCapturer logcapturer(*this);
|
|
if(!HasMPTHacks())
|
|
{
|
|
AddToLog("No hacks found.");
|
|
}
|
|
}
|
|
|
|
|
|
void CModDoc::OnViewTempoSwingSettings()
|
|
{
|
|
if(m_SndFile.m_nDefaultRowsPerBeat > 0 && m_SndFile.m_nTempoMode == TempoMode::Modern)
|
|
{
|
|
TempoSwing tempoSwing = m_SndFile.m_tempoSwing;
|
|
tempoSwing.resize(m_SndFile.m_nDefaultRowsPerBeat, TempoSwing::Unity);
|
|
CTempoSwingDlg dlg(CMainFrame::GetMainFrame(), tempoSwing, m_SndFile);
|
|
if(dlg.DoModal() == IDOK)
|
|
{
|
|
SetModified();
|
|
m_SndFile.m_tempoSwing = dlg.m_tempoSwing;
|
|
}
|
|
} else if(GetModType() == MOD_TYPE_MPT)
|
|
{
|
|
Reporting::Error(_T("Modern tempo mode needs to be enabled in order to edit tempo swing settings."));
|
|
OnSongProperties();
|
|
}
|
|
}
|
|
|
|
|
|
LRESULT CModDoc::OnCustomKeyMsg(WPARAM wParam, LPARAM /*lParam*/)
|
|
{
|
|
const auto &modSpecs = m_SndFile.GetModSpecifications();
|
|
switch(wParam)
|
|
{
|
|
case kcViewGeneral: OnEditGlobals(); break;
|
|
case kcViewPattern: OnEditPatterns(); break;
|
|
case kcViewSamples: OnEditSamples(); break;
|
|
case kcViewInstruments: OnEditInstruments(); break;
|
|
case kcViewComments: OnEditComments(); break;
|
|
case kcViewSongProperties: OnSongProperties(); break;
|
|
case kcViewTempoSwing: OnViewTempoSwingSettings(); break;
|
|
case kcShowMacroConfig: OnSetupZxxMacros(); break;
|
|
case kcViewMIDImapping: OnViewMIDIMapping(); break;
|
|
case kcViewEditHistory: OnViewEditHistory(); break;
|
|
case kcViewChannelManager: OnChannelManager(); break;
|
|
|
|
case kcFileSaveAsWave: OnFileWaveConvert(); break;
|
|
case kcFileSaveMidi: OnFileMidiConvert(); break;
|
|
case kcFileSaveOPL: OnFileOPLExport(); break;
|
|
case kcFileExportCompat: OnFileCompatibilitySave(); break;
|
|
case kcEstimateSongLength: OnEstimateSongLength(); break;
|
|
case kcApproxRealBPM: OnApproximateBPM(); break;
|
|
case kcFileSave: DoSave(GetPathNameMpt()); break;
|
|
case kcFileSaveAs: DoSave(mpt::PathString()); break;
|
|
case kcFileSaveCopy: OnSaveCopy(); break;
|
|
case kcFileSaveTemplate: OnSaveTemplateModule(); break;
|
|
case kcFileClose: SafeFileClose(); break;
|
|
case kcFileAppend: OnAppendModule(); break;
|
|
|
|
case kcPlayPatternFromCursor: OnPatternPlay(); break;
|
|
case kcPlayPatternFromStart: OnPatternRestart(); break;
|
|
case kcPlaySongFromCursor: OnPatternPlayNoLoop(); break;
|
|
case kcPlaySongFromStart: OnPlayerPlayFromStart(); break;
|
|
case kcPlayPauseSong: OnPlayerPlay(); break;
|
|
case kcPlaySongFromPattern: OnPatternRestart(false); break;
|
|
case kcStopSong: OnPlayerStop(); break;
|
|
case kcPanic: OnPanic(); break;
|
|
case kcToggleLoopSong: SetLoopSong(!TrackerSettings::Instance().gbLoopSong); break;
|
|
|
|
case kcTempoIncreaseFine:
|
|
if(!modSpecs.hasFractionalTempo)
|
|
break;
|
|
[[fallthrough]];
|
|
case kcTempoIncrease:
|
|
if(auto tempo = m_SndFile.m_PlayState.m_nMusicTempo; tempo < modSpecs.GetTempoMax())
|
|
m_SndFile.m_PlayState.m_nMusicTempo = std::min(modSpecs.GetTempoMax(), tempo + TEMPO(wParam == kcTempoIncrease ? 1.0 : 0.1));
|
|
break;
|
|
case kcTempoDecreaseFine:
|
|
if(!modSpecs.hasFractionalTempo)
|
|
break;
|
|
[[fallthrough]];
|
|
case kcTempoDecrease:
|
|
if(auto tempo = m_SndFile.m_PlayState.m_nMusicTempo; tempo > modSpecs.GetTempoMin())
|
|
m_SndFile.m_PlayState.m_nMusicTempo = std::max(modSpecs.GetTempoMin(), tempo - TEMPO(wParam == kcTempoDecrease ? 1.0 : 0.1));
|
|
break;
|
|
case kcSpeedIncrease:
|
|
if(auto speed = m_SndFile.m_PlayState.m_nMusicSpeed; speed < modSpecs.speedMax)
|
|
m_SndFile.m_PlayState.m_nMusicSpeed = speed + 1;
|
|
break;
|
|
case kcSpeedDecrease:
|
|
if(auto speed = m_SndFile.m_PlayState.m_nMusicSpeed; speed > modSpecs.speedMin)
|
|
m_SndFile.m_PlayState.m_nMusicSpeed = speed - 1;
|
|
break;
|
|
|
|
case kcViewToggle:
|
|
if(auto *lastActiveFrame = CChildFrame::LastActiveFrame(); lastActiveFrame != nullptr)
|
|
lastActiveFrame->ToggleViews();
|
|
break;
|
|
|
|
default: return kcNull;
|
|
}
|
|
|
|
return wParam;
|
|
}
|
|
|
|
|
|
void CModDoc::TogglePluginEditor(UINT plugin, bool onlyThisEditor)
|
|
{
|
|
if(plugin < MAX_MIXPLUGINS)
|
|
{
|
|
IMixPlugin *pPlugin = m_SndFile.m_MixPlugins[plugin].pMixPlugin;
|
|
if(pPlugin != nullptr)
|
|
{
|
|
if(onlyThisEditor)
|
|
{
|
|
int32 posX = int32_min, posY = int32_min;
|
|
for(PLUGINDEX i = 0; i < MAX_MIXPLUGINS; i++)
|
|
{
|
|
SNDMIXPLUGIN &otherPlug = m_SndFile.m_MixPlugins[i];
|
|
if(i != plugin && otherPlug.pMixPlugin != nullptr && otherPlug.pMixPlugin->GetEditor() != nullptr)
|
|
{
|
|
otherPlug.pMixPlugin->CloseEditor();
|
|
if(otherPlug.editorX != int32_min)
|
|
{
|
|
posX = otherPlug.editorX;
|
|
posY = otherPlug.editorY;
|
|
}
|
|
}
|
|
}
|
|
if(posX != int32_min)
|
|
{
|
|
m_SndFile.m_MixPlugins[plugin].editorX = posX;
|
|
m_SndFile.m_MixPlugins[plugin].editorY = posY;
|
|
}
|
|
}
|
|
|
|
pPlugin->ToggleEditor();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CModDoc::SetLoopSong(bool loop)
|
|
{
|
|
TrackerSettings::Instance().gbLoopSong = loop;
|
|
m_SndFile.SetRepeatCount(loop ? -1 : 0);
|
|
CMainFrame::GetMainFrame()->UpdateAllViews(UpdateHint().MPTOptions());
|
|
}
|
|
|
|
|
|
void CModDoc::ChangeFileExtension(MODTYPE nNewType)
|
|
{
|
|
//Not making path if path is empty(case only(?) for new file)
|
|
if(!GetPathNameMpt().empty())
|
|
{
|
|
mpt::PathString drive;
|
|
mpt::PathString dir;
|
|
mpt::PathString fname;
|
|
mpt::PathString fext;
|
|
GetPathNameMpt().SplitPath(&drive, &dir, &fname, &fext);
|
|
|
|
mpt::PathString newPath = drive + dir;
|
|
|
|
// Catch case where we don't have a filename yet.
|
|
if(fname.empty())
|
|
{
|
|
newPath += mpt::PathString::FromCString(GetTitle()).SanitizeComponent();
|
|
} else
|
|
{
|
|
newPath += fname;
|
|
}
|
|
|
|
newPath += P_(".") + mpt::PathString::FromUTF8(CSoundFile::GetModSpecifications(nNewType).fileExtension);
|
|
|
|
// Forcing save dialog to appear after extension change - otherwise unnotified file overwriting may occur.
|
|
m_ShowSavedialog = true;
|
|
|
|
SetPathName(newPath, FALSE);
|
|
}
|
|
|
|
UpdateAllViews(NULL, UpdateHint().ModType());
|
|
}
|
|
|
|
|
|
CHANNELINDEX CModDoc::FindAvailableChannel() const
|
|
{
|
|
CHANNELINDEX chn = m_SndFile.GetNNAChannel(CHANNELINDEX_INVALID);
|
|
if(chn != CHANNELINDEX_INVALID)
|
|
return chn;
|
|
else
|
|
return GetNumChannels();
|
|
}
|
|
|
|
|
|
void CModDoc::RecordParamChange(PLUGINDEX plugSlot, PlugParamIndex paramIndex)
|
|
{
|
|
::SendNotifyMessage(m_hWndFollow, WM_MOD_RECORDPARAM, plugSlot, paramIndex);
|
|
}
|
|
|
|
|
|
void CModDoc::LearnMacro(int macroToSet, PlugParamIndex paramToUse)
|
|
{
|
|
if(macroToSet < 0 || macroToSet > kSFxMacros)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// If macro already exists for this param, inform user and return
|
|
if(auto macro = m_SndFile.m_MidiCfg.FindMacroForParam(paramToUse); macro >= 0)
|
|
{
|
|
CString message;
|
|
message.Format(_T("Parameter %i can already be controlled with macro %X."), static_cast<int>(paramToUse), macro);
|
|
Reporting::Information(message, _T("Macro exists for this parameter"));
|
|
return;
|
|
}
|
|
|
|
// Set new macro
|
|
if(paramToUse < 384)
|
|
{
|
|
m_SndFile.m_MidiCfg.CreateParameteredMacro(macroToSet, kSFxPlugParam, paramToUse);
|
|
} else
|
|
{
|
|
CString message;
|
|
message.Format(_T("Parameter %i beyond controllable range. Use Parameter Control Events to automate this parameter."), static_cast<int>(paramToUse));
|
|
Reporting::Information(message, _T("Macro not assigned for this parameter"));
|
|
return;
|
|
}
|
|
|
|
CString message;
|
|
message.Format(_T("Parameter %i can now be controlled with macro %X."), static_cast<int>(paramToUse), macroToSet);
|
|
Reporting::Information(message, _T("Macro assigned for this parameter"));
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
void CModDoc::OnSongProperties()
|
|
{
|
|
const bool wasUsingFrequencies = m_SndFile.PeriodsAreFrequencies();
|
|
CModTypeDlg dlg(m_SndFile, CMainFrame::GetMainFrame());
|
|
if(dlg.DoModal() == IDOK)
|
|
{
|
|
UpdateAllViews(nullptr, GeneralHint().General());
|
|
ScopedLogCapturer logcapturer(*this, _T("Conversion Status"));
|
|
bool showLog = false;
|
|
if(dlg.m_nType != GetModType())
|
|
{
|
|
if(!ChangeModType(dlg.m_nType))
|
|
return;
|
|
showLog = true;
|
|
}
|
|
|
|
CHANNELINDEX newChannels = Clamp(dlg.m_nChannels, m_SndFile.GetModSpecifications().channelsMin, m_SndFile.GetModSpecifications().channelsMax);
|
|
if(newChannels != GetNumChannels())
|
|
{
|
|
const bool showCancelInRemoveDlg = m_SndFile.GetModSpecifications().channelsMax >= m_SndFile.GetNumChannels();
|
|
if(ChangeNumChannels(newChannels, showCancelInRemoveDlg))
|
|
showLog = true;
|
|
|
|
// Force update of pattern highlights / num channels
|
|
UpdateAllViews(nullptr, PatternHint().Data());
|
|
UpdateAllViews(nullptr, GeneralHint().Channels());
|
|
}
|
|
|
|
if(wasUsingFrequencies != m_SndFile.PeriodsAreFrequencies())
|
|
{
|
|
for(auto &chn : m_SndFile.m_PlayState.Chn)
|
|
{
|
|
chn.nPeriod = 0;
|
|
}
|
|
}
|
|
|
|
SetModified();
|
|
}
|
|
}
|
|
|
|
|
|
void CModDoc::ViewMIDIMapping(PLUGINDEX plugin, PlugParamIndex param)
|
|
{
|
|
CMIDIMappingDialog dlg(CMainFrame::GetMainFrame(), m_SndFile);
|
|
if(plugin != PLUGINDEX_INVALID)
|
|
{
|
|
dlg.m_Setting.SetPlugIndex(plugin + 1);
|
|
dlg.m_Setting.SetParamIndex(param);
|
|
}
|
|
dlg.DoModal();
|
|
}
|
|
|
|
|
|
void CModDoc::OnChannelManager()
|
|
{
|
|
CChannelManagerDlg *instance = CChannelManagerDlg::sharedInstanceCreate();
|
|
if(instance != nullptr)
|
|
{
|
|
if(instance->IsDisplayed())
|
|
instance->Hide();
|
|
else
|
|
{
|
|
instance->SetDocument(this);
|
|
instance->Show();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Sets playback timer to playback time at given position.
|
|
// At the same time, the playback parameters (global volume, channel volume and stuff like that) are calculated for this position.
|
|
// Sample channels positions are only updated if setSamplePos is true *and* the user has chosen to update sample play positions on seek.
|
|
void CModDoc::SetElapsedTime(ORDERINDEX nOrd, ROWINDEX nRow, bool setSamplePos)
|
|
{
|
|
if(nOrd == ORDERINDEX_INVALID) return;
|
|
|
|
double t = m_SndFile.GetPlaybackTimeAt(nOrd, nRow, true, setSamplePos && (TrackerSettings::Instance().m_dwPatternSetup & PATTERN_SYNCSAMPLEPOS) != 0);
|
|
if(t < 0)
|
|
{
|
|
// Position is never played regularly, but we may want to continue playing from here nevertheless.
|
|
m_SndFile.m_PlayState.m_nCurrentOrder = m_SndFile.m_PlayState.m_nNextOrder = nOrd;
|
|
m_SndFile.m_PlayState.m_nRow = m_SndFile.m_PlayState.m_nNextRow = nRow;
|
|
}
|
|
|
|
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
|
|
if(pMainFrm != nullptr) pMainFrm->SetElapsedTime(std::max(0.0, t));
|
|
}
|
|
|
|
|
|
CString CModDoc::GetPatternViewInstrumentName(INSTRUMENTINDEX nInstr,
|
|
bool bEmptyInsteadOfNoName /* = false*/,
|
|
bool bIncludeIndex /* = true*/) const
|
|
{
|
|
if(nInstr >= MAX_INSTRUMENTS || m_SndFile.GetNumInstruments() == 0 || m_SndFile.Instruments[nInstr] == nullptr)
|
|
return CString();
|
|
|
|
CString displayName, instrumentName, pluginName;
|
|
|
|
// Get instrument name.
|
|
instrumentName = mpt::ToCString(m_SndFile.GetCharsetInternal(), m_SndFile.GetInstrumentName(nInstr));
|
|
|
|
// If instrument name is empty, use name of the sample mapped to C-5.
|
|
if (instrumentName.IsEmpty())
|
|
{
|
|
const SAMPLEINDEX nSmp = m_SndFile.Instruments[nInstr]->Keyboard[NOTE_MIDDLEC - 1];
|
|
if (nSmp <= m_SndFile.GetNumSamples() && m_SndFile.GetSample(nSmp).HasSampleData())
|
|
instrumentName = _T("s: ") + mpt::ToCString(m_SndFile.GetCharsetInternal(), m_SndFile.GetSampleName(nSmp));
|
|
}
|
|
|
|
// Get plugin name.
|
|
const PLUGINDEX nPlug = m_SndFile.Instruments[nInstr]->nMixPlug;
|
|
if (nPlug > 0 && nPlug < MAX_MIXPLUGINS)
|
|
pluginName = mpt::ToCString(m_SndFile.m_MixPlugins[nPlug-1].GetName());
|
|
|
|
if (pluginName.IsEmpty())
|
|
{
|
|
if(bEmptyInsteadOfNoName && instrumentName.IsEmpty())
|
|
return TEXT("");
|
|
if(instrumentName.IsEmpty())
|
|
instrumentName = _T("(no name)");
|
|
if (bIncludeIndex)
|
|
displayName.Format(_T("%02d: %s"), nInstr, instrumentName.GetString());
|
|
else
|
|
displayName = instrumentName;
|
|
} else
|
|
{
|
|
if (bIncludeIndex)
|
|
displayName.Format(TEXT("%02d: %s (%s)"), nInstr, instrumentName.GetString(), pluginName.GetString());
|
|
else
|
|
displayName.Format(TEXT("%s (%s)"), instrumentName.GetString(), pluginName.GetString());
|
|
}
|
|
return displayName;
|
|
}
|
|
|
|
|
|
void CModDoc::SafeFileClose()
|
|
{
|
|
// Verify that the main window has the focus. This saves us a lot of trouble because active modal dialogs cannot know if their pSndFile pointers are still valid.
|
|
if(GetActiveWindow() == CMainFrame::GetMainFrame()->m_hWnd)
|
|
OnFileClose();
|
|
}
|
|
|
|
|
|
// "Panic button". This resets all VSTi, OPL and sample notes.
|
|
void CModDoc::OnPanic()
|
|
{
|
|
CriticalSection cs;
|
|
m_SndFile.ResetChannels();
|
|
m_SndFile.StopAllVsti();
|
|
}
|
|
|
|
|
|
// Before saving, make sure that every char after the terminating null char is also null.
|
|
// Else, garbage might end up in various text strings that wasn't supposed to be there.
|
|
void CModDoc::FixNullStrings()
|
|
{
|
|
// Macros
|
|
m_SndFile.m_MidiCfg.Sanitize();
|
|
}
|
|
|
|
|
|
void CModDoc::OnSaveCopy()
|
|
{
|
|
DoSave(mpt::PathString(), false);
|
|
}
|
|
|
|
|
|
void CModDoc::OnSaveTemplateModule()
|
|
{
|
|
// Create template folder if doesn't exist already.
|
|
const mpt::PathString templateFolder = TrackerSettings::Instance().PathUserTemplates.GetDefaultDir();
|
|
if (!templateFolder.IsDirectory())
|
|
{
|
|
if (!CreateDirectory(templateFolder.AsNative().c_str(), nullptr))
|
|
{
|
|
Reporting::Notification(MPT_CFORMAT("Error: Unable to create template folder '{}'")( templateFolder));
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Generate file name candidate.
|
|
mpt::PathString sName;
|
|
for(size_t i = 0; i < 1000; ++i)
|
|
{
|
|
sName += P_("newTemplate") + mpt::PathString::FromUnicode(mpt::ufmt::val(i));
|
|
sName += P_(".") + mpt::PathString::FromUTF8(m_SndFile.GetModSpecifications().fileExtension);
|
|
if (!(templateFolder + sName).FileOrDirectoryExists())
|
|
break;
|
|
}
|
|
|
|
// Ask file name from user.
|
|
FileDialog dlg = SaveFileDialog()
|
|
.DefaultExtension(m_SndFile.GetModSpecifications().fileExtension)
|
|
.DefaultFilename(sName)
|
|
.ExtensionFilter(ModTypeToFilter(m_SndFile))
|
|
.WorkingDirectory(templateFolder);
|
|
if(!dlg.Show())
|
|
return;
|
|
|
|
if (OnSaveDocument(dlg.GetFirstFile(), false))
|
|
{
|
|
// Update template menu.
|
|
CMainFrame::GetMainFrame()->CreateTemplateModulesMenu();
|
|
}
|
|
}
|
|
|
|
|
|
// Create an undo point that stores undo data for all existing patterns
|
|
void CModDoc::PrepareUndoForAllPatterns(bool storeChannelInfo, const char *description)
|
|
{
|
|
bool linkUndo = false;
|
|
|
|
PATTERNINDEX lastPat = 0;
|
|
for(PATTERNINDEX pat = 0; pat < m_SndFile.Patterns.Size(); pat++)
|
|
{
|
|
if(m_SndFile.Patterns.IsValidPat(pat)) lastPat = pat;
|
|
}
|
|
|
|
for(PATTERNINDEX pat = 0; pat <= lastPat; pat++)
|
|
{
|
|
if(m_SndFile.Patterns.IsValidPat(pat))
|
|
{
|
|
GetPatternUndo().PrepareUndo(pat, 0, 0, GetNumChannels(), m_SndFile.Patterns[pat].GetNumRows(), description, linkUndo, storeChannelInfo && pat == lastPat);
|
|
linkUndo = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
CString CModDoc::LinearToDecibels(double value, double valueAtZeroDB)
|
|
{
|
|
if (value == 0) return _T("-inf");
|
|
|
|
double changeFactor = value / valueAtZeroDB;
|
|
double dB = 20.0 * std::log10(changeFactor);
|
|
|
|
CString s = (dB >= 0) ? _T("+") : _T("");
|
|
s.AppendFormat(_T("%.2f dB"), dB);
|
|
return s;
|
|
}
|
|
|
|
|
|
CString CModDoc::PanningToString(int32 value, int32 valueAtCenter)
|
|
{
|
|
if(value == valueAtCenter)
|
|
return _T("Center");
|
|
|
|
CString s;
|
|
s.Format(_T("%i%% %s"), (std::abs(static_cast<int>(value) - valueAtCenter) * 100) / valueAtCenter, value < valueAtCenter ? _T("Left") : _T("Right"));
|
|
return s;
|
|
}
|
|
|
|
|
|
// Apply OPL patch changes to live playback
|
|
void CModDoc::UpdateOPLInstrument(SAMPLEINDEX smp)
|
|
{
|
|
const ModSample &sample = m_SndFile.GetSample(smp);
|
|
if(!sample.uFlags[CHN_ADLIB] || !m_SndFile.m_opl || CMainFrame::GetMainFrame()->GetModPlaying() != this)
|
|
return;
|
|
|
|
CriticalSection cs;
|
|
const auto &patch = sample.adlib;
|
|
for(CHANNELINDEX chn = 0; chn < MAX_CHANNELS; chn++)
|
|
{
|
|
const auto &c = m_SndFile.m_PlayState.Chn[chn];
|
|
if(c.pModSample == &sample && c.IsSamplePlaying())
|
|
{
|
|
m_SndFile.m_opl->Patch(chn, patch);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Store all view positions t settings file
|
|
void CModDoc::SerializeViews() const
|
|
{
|
|
const mpt::PathString pathName = theApp.IsPortableMode() ? GetPathNameMpt().AbsolutePathToRelative(theApp.GetInstallPath()) : GetPathNameMpt();
|
|
if(pathName.empty())
|
|
{
|
|
return;
|
|
}
|
|
std::ostringstream f(std::ios::out | std::ios::binary);
|
|
|
|
CRect mdiRect;
|
|
::GetClientRect(CMainFrame::GetMainFrame()->m_hWndMDIClient, &mdiRect);
|
|
const int width = mdiRect.Width();
|
|
const int height = mdiRect.Height();
|
|
|
|
const int cxScreen = GetSystemMetrics(SM_CXVIRTUALSCREEN), cyScreen = GetSystemMetrics(SM_CYVIRTUALSCREEN);
|
|
|
|
// Document view positions and sizes
|
|
POSITION pos = GetFirstViewPosition();
|
|
while(pos != nullptr && !mdiRect.IsRectEmpty())
|
|
{
|
|
CModControlView *pView = dynamic_cast<CModControlView *>(GetNextView(pos));
|
|
if(pView)
|
|
{
|
|
CChildFrame *pChildFrm = (CChildFrame *)pView->GetParentFrame();
|
|
WINDOWPLACEMENT wnd;
|
|
wnd.length = sizeof(WINDOWPLACEMENT);
|
|
pChildFrm->GetWindowPlacement(&wnd);
|
|
const CRect rect = wnd.rcNormalPosition;
|
|
|
|
// Write size information
|
|
uint8 windowState = 0;
|
|
if(wnd.showCmd == SW_SHOWMAXIMIZED) windowState = 1;
|
|
else if(wnd.showCmd == SW_SHOWMINIMIZED) windowState = 2;
|
|
mpt::IO::WriteIntLE<uint8>(f, 0); // Window type
|
|
mpt::IO::WriteIntLE<uint8>(f, windowState);
|
|
mpt::IO::WriteIntLE<int32>(f, Util::muldivr(rect.left, 1 << 30, width));
|
|
mpt::IO::WriteIntLE<int32>(f, Util::muldivr(rect.top, 1 << 30, height));
|
|
mpt::IO::WriteIntLE<int32>(f, Util::muldivr(rect.Width(), 1 << 30, width));
|
|
mpt::IO::WriteIntLE<int32>(f, Util::muldivr(rect.Height(), 1 << 30, height));
|
|
|
|
std::string s = pChildFrm->SerializeView();
|
|
mpt::IO::WriteVarInt(f, s.size());
|
|
f << s;
|
|
}
|
|
}
|
|
// Plugin window positions
|
|
for(PLUGINDEX i = 0; i < MAX_MIXPLUGINS; i++)
|
|
{
|
|
if(m_SndFile.m_MixPlugins[i].IsValidPlugin() && m_SndFile.m_MixPlugins[i].editorX != int32_min && cxScreen && cyScreen)
|
|
{
|
|
// Translate screen position into percentage (to make it independent of the actual screen resolution)
|
|
int32 editorX = Util::muldivr(m_SndFile.m_MixPlugins[i].editorX, 1 << 30, cxScreen);
|
|
int32 editorY = Util::muldivr(m_SndFile.m_MixPlugins[i].editorY, 1 << 30, cyScreen);
|
|
|
|
mpt::IO::WriteIntLE<uint8>(f, 1); // Window type
|
|
mpt::IO::WriteIntLE<uint8>(f, 0); // Version
|
|
mpt::IO::WriteVarInt(f, i);
|
|
mpt::IO::WriteIntLE<int32>(f, editorX);
|
|
mpt::IO::WriteIntLE<int32>(f, editorY);
|
|
}
|
|
}
|
|
|
|
SettingsContainer &settings = theApp.GetSongSettings();
|
|
const std::string s = f.str();
|
|
settings.Write(U_("WindowSettings"), pathName.GetFullFileName().ToUnicode(), pathName);
|
|
settings.Write(U_("WindowSettings"), pathName.ToUnicode(), mpt::encode_hex(mpt::as_span(s)));
|
|
}
|
|
|
|
|
|
// Restore all view positions from settings file
|
|
void CModDoc::DeserializeViews()
|
|
{
|
|
mpt::PathString pathName = GetPathNameMpt();
|
|
if(pathName.empty()) return;
|
|
|
|
SettingsContainer &settings = theApp.GetSongSettings();
|
|
mpt::ustring s = settings.Read<mpt::ustring>(U_("WindowSettings"), pathName.ToUnicode());
|
|
if(s.size() < 2)
|
|
{
|
|
// Try relative path
|
|
pathName = pathName.RelativePathToAbsolute(theApp.GetInstallPath());
|
|
s = settings.Read<mpt::ustring>(U_("WindowSettings"), pathName.ToUnicode());
|
|
if(s.size() < 2)
|
|
{
|
|
// Try searching for filename instead of full path name
|
|
const mpt::ustring altName = settings.Read<mpt::ustring>(U_("WindowSettings"), pathName.GetFullFileName().ToUnicode());
|
|
s = settings.Read<mpt::ustring>(U_("WindowSettings"), altName);
|
|
if(s.size() < 2) return;
|
|
}
|
|
}
|
|
std::vector<std::byte> bytes = mpt::decode_hex(s);
|
|
|
|
FileReader file(mpt::as_span(bytes));
|
|
|
|
CRect mdiRect;
|
|
::GetWindowRect(CMainFrame::GetMainFrame()->m_hWndMDIClient, &mdiRect);
|
|
const int width = mdiRect.Width();
|
|
const int height = mdiRect.Height();
|
|
|
|
const int cxScreen = GetSystemMetrics(SM_CXVIRTUALSCREEN), cyScreen = GetSystemMetrics(SM_CYVIRTUALSCREEN);
|
|
|
|
POSITION pos = GetFirstViewPosition();
|
|
CChildFrame *pChildFrm = nullptr;
|
|
if(pos != nullptr) pChildFrm = dynamic_cast<CChildFrame *>(GetNextView(pos)->GetParentFrame());
|
|
|
|
bool anyMaximized = false;
|
|
while(file.CanRead(1))
|
|
{
|
|
const uint8 windowType = file.ReadUint8();
|
|
if(windowType == 0)
|
|
{
|
|
// Document view positions and sizes
|
|
const uint8 windowState = file.ReadUint8();
|
|
CRect rect;
|
|
rect.left = Util::muldivr(file.ReadInt32LE(), width, 1 << 30);
|
|
rect.top = Util::muldivr(file.ReadInt32LE(), height, 1 << 30);
|
|
rect.right = rect.left + Util::muldivr(file.ReadInt32LE(), width, 1 << 30);
|
|
rect.bottom = rect.top + Util::muldivr(file.ReadInt32LE(), height, 1 << 30);
|
|
size_t dataSize;
|
|
file.ReadVarInt(dataSize);
|
|
FileReader data = file.ReadChunk(dataSize);
|
|
|
|
if(pChildFrm == nullptr)
|
|
{
|
|
CModDocTemplate *pTemplate = static_cast<CModDocTemplate *>(GetDocTemplate());
|
|
ASSERT_VALID(pTemplate);
|
|
pChildFrm = static_cast<CChildFrame *>(pTemplate->CreateNewFrame(this, nullptr));
|
|
if(pChildFrm != nullptr)
|
|
{
|
|
pTemplate->InitialUpdateFrame(pChildFrm, this);
|
|
}
|
|
}
|
|
if(pChildFrm != nullptr)
|
|
{
|
|
if(!mdiRect.IsRectEmpty())
|
|
{
|
|
WINDOWPLACEMENT wnd;
|
|
wnd.length = sizeof(wnd);
|
|
pChildFrm->GetWindowPlacement(&wnd);
|
|
wnd.showCmd = SW_SHOWNOACTIVATE;
|
|
if(windowState == 1 || anyMaximized)
|
|
{
|
|
// Once a window has been maximized, all following windows have to be marked as maximized as well.
|
|
wnd.showCmd = SW_MAXIMIZE;
|
|
anyMaximized = true;
|
|
} else if(windowState == 2)
|
|
{
|
|
wnd.showCmd = SW_MINIMIZE;
|
|
}
|
|
if(rect.left < width && rect.right > 0 && rect.top < height && rect.bottom > 0)
|
|
{
|
|
wnd.rcNormalPosition = CRect(rect.left, rect.top, rect.right, rect.bottom);
|
|
}
|
|
pChildFrm->SetWindowPlacement(&wnd);
|
|
}
|
|
pChildFrm->DeserializeView(data);
|
|
pChildFrm = nullptr;
|
|
}
|
|
} else if(windowType == 1)
|
|
{
|
|
if(file.ReadUint8() != 0)
|
|
break;
|
|
// Plugin window positions
|
|
PLUGINDEX plug = 0;
|
|
if(file.ReadVarInt(plug) && plug < MAX_MIXPLUGINS)
|
|
{
|
|
int32 editorX = file.ReadInt32LE();
|
|
int32 editorY = file.ReadInt32LE();
|
|
if(editorX != int32_min && editorY != int32_min)
|
|
{
|
|
m_SndFile.m_MixPlugins[plug].editorX = Util::muldivr(editorX, cxScreen, 1 << 30);
|
|
m_SndFile.m_MixPlugins[plug].editorY = Util::muldivr(editorY, cyScreen, 1 << 30);
|
|
}
|
|
}
|
|
} else
|
|
{
|
|
// Unknown type
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
OPENMPT_NAMESPACE_END
|