winamp/Src/external_dependencies/openmpt-trunk/mptrack/Moddoc.cpp

/*
 * 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 &params, 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