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

/*
 * MainFrm.cpp
 * -----------
 * Purpose: Implementation of OpenMPT's main window code.
 * 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 "ModDocTemplate.h"
#include "openmpt/sounddevice/SoundDevice.hpp"
#include "openmpt/sounddevice/SoundDeviceBuffer.hpp"
#include "openmpt/sounddevice/SoundDeviceManager.hpp"
#include "../soundlib/AudioReadTarget.h"
#include "ImageLists.h"
#include "Moddoc.h"
#include "Childfrm.h"
#include "Dlsbank.h"
#include "Mpdlgs.h"
#include "FolderScanner.h"
#include "KeyConfigDlg.h"
#include "PathConfigDlg.h"
#include "GeneralConfigDlg.h"
#include "ColorConfigDlg.h"
#include "SampleConfigDlg.h"
#include "AdvancedConfigDlg.h"
#include "AutoSaver.h"
#include "Mainfrm.h"
#include "InputHandler.h"
#include "Globals.h"
#include "ChannelManagerDlg.h"
#include "../common/version.h"
#include "UpdateCheck.h"
#include "CloseMainDialog.h"
#include "SelectPluginDialog.h"
#include "PatternClipboard.h"
#include "PatternFont.h"
#include "../common/mptFileIO.h"
#include "../common/FileReader.h"
#include "../common/Profiler.h"
#include "../soundlib/plugins/PlugInterface.h"
#include "../soundlib/plugins/PluginManager.h"
#include "Vstplug.h"
#include "FileDialog.h"
#include "ProgressDialog.h"
#include <HtmlHelp.h>
#include <Dbt.h>  // device change messages
#include "mpt/audio/span.hpp"


OPENMPT_NAMESPACE_BEGIN

#define TIMERID_GUI 1
#define TIMERID_NOTIFY 2

#define MPTTIMER_PERIOD		200


/////////////////////////////////////////////////////////////////////////////
// CMainFrame

IMPLEMENT_DYNAMIC(CMainFrame, CMDIFrameWnd)

BEGIN_MESSAGE_MAP(CMainFrame, CMDIFrameWnd)
	//{{AFX_MSG_MAP(CMainFrame)
	ON_WM_TIMER()
	ON_WM_CLOSE()
	ON_WM_CREATE()
	ON_WM_RBUTTONDOWN()
	ON_WM_DEVICECHANGE()
	ON_WM_DROPFILES()
	ON_WM_QUERYENDSESSION()
	ON_COMMAND(ID_VIEW_OPTIONS,				&CMainFrame::OnViewOptions)

	ON_COMMAND(ID_PLUGIN_SETUP,				&CMainFrame::OnPluginManager)
	ON_COMMAND(ID_CLIPBOARD_MANAGER,		&CMainFrame::OnClipboardManager)
	//ON_COMMAND(ID_HELP,					CMDIFrameWnd::OnHelp)
	ON_COMMAND(ID_REPORT_BUG,				&CMainFrame::OnReportBug)
	ON_COMMAND(ID_NEXTOCTAVE,				&CMainFrame::OnNextOctave)
	ON_COMMAND(ID_PREVOCTAVE,				&CMainFrame::OnPrevOctave)
	ON_COMMAND_RANGE(ID_FILE_OPENTEMPLATE, ID_FILE_OPENTEMPLATE_LASTINRANGE, &CMainFrame::OnOpenTemplateModule)
	ON_COMMAND(ID_ADD_SOUNDBANK,			&CMainFrame::OnAddDlsBank)
	ON_COMMAND(ID_IMPORT_MIDILIB,			&CMainFrame::OnImportMidiLib)
	ON_COMMAND(ID_MIDI_RECORD,				&CMainFrame::OnMidiRecord)
	ON_COMMAND(ID_PANIC,					&CMainFrame::OnPanic)
	ON_COMMAND(ID_PLAYER_PAUSE,				&CMainFrame::OnPlayerPause)
	ON_COMMAND_RANGE(ID_EXAMPLE_MODULES, ID_EXAMPLE_MODULES_LASTINRANGE, &CMainFrame::OnExampleSong)
	ON_COMMAND_EX(IDD_TREEVIEW,				&CMainFrame::OnBarCheck)
	ON_COMMAND_EX(ID_NETLINK_MODPLUG,		&CMainFrame::OnInternetLink)
	ON_COMMAND_EX(ID_NETLINK_TOP_PICKS,		&CMainFrame::OnInternetLink)
	ON_UPDATE_COMMAND_UI(ID_MIDI_RECORD,	&CMainFrame::OnUpdateMidiRecord)
	ON_UPDATE_COMMAND_UI(ID_INDICATOR_TIME,	&CMainFrame::OnUpdateTime)
	ON_UPDATE_COMMAND_UI(ID_INDICATOR_USER,	&CMainFrame::OnUpdateUser)
	ON_UPDATE_COMMAND_UI(ID_INDICATOR_INFO,	&CMainFrame::OnUpdateInfo)
	ON_UPDATE_COMMAND_UI(ID_INDICATOR_XINFO,&CMainFrame::OnUpdateXInfo)
	ON_UPDATE_COMMAND_UI(IDD_TREEVIEW,		&CMainFrame::OnUpdateControlBarMenu)
	ON_MESSAGE(WM_MOD_UPDATEPOSITION,		&CMainFrame::OnUpdatePosition)
	ON_MESSAGE(WM_MOD_INVALIDATEPATTERNS,	&CMainFrame::OnInvalidatePatterns)
	ON_MESSAGE(WM_MOD_KEYCOMMAND,			&CMainFrame::OnCustomKeyMsg)
	ON_MESSAGE(WM_MOD_MIDIMAPPING,			&CMainFrame::OnViewMIDIMapping)
	ON_MESSAGE(WM_MOD_UPDATEVIEWS,			&CMainFrame::OnUpdateViews)
	ON_MESSAGE(WM_MOD_SETMODIFIED,			&CMainFrame::OnSetModified)
#if defined(MPT_ENABLE_UPDATE)
	ON_MESSAGE(WM_MOD_UPDATENOTIFY,			&CMainFrame::OnToolbarUpdateIndicatorClick)
#endif // MPT_ENABLE_UPDATE
	ON_COMMAND(ID_INTERNETUPDATE,			&CMainFrame::OnInternetUpdate)
	ON_COMMAND(ID_UPDATE_AVAILABLE,			&CMainFrame::OnUpdateAvailable)
	ON_COMMAND(ID_HELP_SHOWSETTINGSFOLDER,	&CMainFrame::OnShowSettingsFolder)
#if defined(MPT_ENABLE_UPDATE)
	ON_MESSAGE(MPT_WM_APP_UPDATECHECK_START, &CMainFrame::OnUpdateCheckStart)
	ON_MESSAGE(MPT_WM_APP_UPDATECHECK_PROGRESS, &CMainFrame::OnUpdateCheckProgress)
	ON_MESSAGE(MPT_WM_APP_UPDATECHECK_CANCELED, &CMainFrame::OnUpdateCheckCanceled)
	ON_MESSAGE(MPT_WM_APP_UPDATECHECK_FAILURE, &CMainFrame::OnUpdateCheckFailure)
	ON_MESSAGE(MPT_WM_APP_UPDATECHECK_SUCCESS, &CMainFrame::OnUpdateCheckSuccess)
#endif // MPT_ENABLE_UPDATE
	ON_COMMAND(ID_HELPSHOW,					&CMainFrame::OnHelp)

	ON_COMMAND_RANGE(ID_MRU_LIST_FIRST, ID_MRU_LIST_LAST, &CMainFrame::OnOpenMRUItem)
	ON_UPDATE_COMMAND_UI(ID_MRU_LIST_FIRST,	&CMainFrame::OnUpdateMRUItem)
	//}}AFX_MSG_MAP
	ON_WM_INITMENU()
	ON_WM_KILLFOCUS()
	ON_WM_MOUSEWHEEL()
	ON_WM_SHOWWINDOW()
	ON_WM_ACTIVATEAPP()
END_MESSAGE_MAP()

// Globals
OptionsPage CMainFrame::m_nLastOptionsPage = OPTIONS_PAGE_DEFAULT;
HHOOK CMainFrame::ghKbdHook = NULL;

// GDI
HICON CMainFrame::m_hIcon = NULL;
HFONT CMainFrame::m_hGUIFont = NULL;
HFONT CMainFrame::m_hFixedFont = NULL;
HPEN CMainFrame::penDarkGray = NULL;
HPEN CMainFrame::penGray99 = NULL;
HPEN CMainFrame::penHalfDarkGray = NULL;

HCURSOR CMainFrame::curDragging = NULL;
HCURSOR CMainFrame::curArrow = NULL;
HCURSOR CMainFrame::curNoDrop = NULL;
HCURSOR CMainFrame::curNoDrop2 = NULL;
HCURSOR CMainFrame::curVSplit = NULL;
MODPLUGDIB *CMainFrame::bmpNotes = nullptr;
MODPLUGDIB *CMainFrame::bmpVUMeters = nullptr;
MODPLUGDIB *CMainFrame::bmpPluginVUMeters = nullptr;
COLORREF CMainFrame::gcolrefVuMeter[NUM_VUMETER_PENS*2];

CInputHandler *CMainFrame::m_InputHandler = nullptr;

static UINT indicators[] =
{
	ID_SEPARATOR,			// status line indicator
	ID_INDICATOR_XINFO,
	ID_INDICATOR_INFO,
	ID_INDICATOR_USER,
	ID_INDICATOR_TIME,
};


/////////////////////////////////////////////////////////////////////////////
// CMainFrame construction/destruction
CMainFrame::CMainFrame()
	: SoundDevice::CallbackBufferHandler<DithersOpenMPT>(theApp.PRNG())
	, m_SoundDeviceFillBufferCriticalSection(CriticalSection::InitialState::Unlocked)
{
	m_szUserText[0] = 0;
	m_szInfoText[0] = 0;
	m_szXInfoText[0]= 0;

	MemsetZero(gcolrefVuMeter);

	m_InputHandler = new CInputHandler(this);

}


void CMainFrame::Initialize()
{
	//Adding version number to the frame title
	CString title = GetTitle();
	title += _T(" ") + mpt::cfmt::val(Version::Current());
	#if defined(MPT_BUILD_RETRO)
		title += _T(" RETRO");
	#endif // MPT_BUILD_RETRO
	if(Build::IsDebugBuild())
	{
		title += _T(" DEBUG");
	}
	#ifndef MPT_WITH_VST
		title += _T(" NO_VST");
	#endif
	#ifndef MPT_WITH_DMO
		title += _T(" NO_DMO");
	#endif
	#ifdef NO_PLUGINS
		title += _T(" NO_PLUGINS");
	#endif
	SetTitle(title);
	OnUpdateFrameTitle(false);

	// Check for valid sound device
	SoundDevice::Identifier dev = TrackerSettings::Instance().GetSoundDeviceIdentifier();
	if(!theApp.GetSoundDevicesManager()->FindDeviceInfo(dev).IsValid())
	{
		dev = theApp.GetSoundDevicesManager()->FindDeviceInfoBestMatch(dev).GetIdentifier();
		TrackerSettings::Instance().SetSoundDeviceIdentifier(dev);
	}

	// Setup timer
	OnUpdateUser(NULL);
	m_nTimer = SetTimer(TIMERID_GUI, MPTTIMER_PERIOD, NULL);

	// Setup Keyboard Hook
	ghKbdHook = SetWindowsHookEx(WH_KEYBOARD, KeyboardProc, AfxGetInstanceHandle(), GetCurrentThreadId());

	// Update the tree
	m_wndTree.Init();

	CreateExampleModulesMenu();
	CreateTemplateModulesMenu();
	UpdateMRUList();
}


CMainFrame::~CMainFrame()
{
	delete m_InputHandler;
	CChannelManagerDlg::DestroySharedInstance();
}


int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
	if(CMDIFrameWnd::OnCreate(lpCreateStruct) == -1)
		return -1;
	// Load resources
	m_hIcon = theApp.LoadIcon(IDR_MAINFRAME);

	// Toolbar and other icons
	CDC *dc = GetDC();
	const double scaling = Util::GetDPIx(m_hWnd) / 96.0;
	static constexpr int miscIconsInvert[] = {IMAGE_PATTERNS, IMAGE_OPLINSTRACTIVE, IMAGE_OPLINSTRMUTE};
	static constexpr int patternIconsInvert[] = {TIMAGE_PREVIEW, TIMAGE_MACROEDITOR, TIMAGE_PATTERN_OVERFLOWPASTE, TIMAGE_PATTERN_DETAIL_LO, TIMAGE_PATTERN_DETAIL_MED, TIMAGE_PATTERN_DETAIL_HI, TIMAGE_PATTERN_PLUGINS, TIMAGE_SAMPLE_UNSIGN};
	static constexpr int envelopeIconsInvert[] = {IIMAGE_CHECKED, IIMAGE_VOLSWITCH, IIMAGE_PANSWITCH, IIMAGE_PITCHSWITCH, IIMAGE_FILTERSWITCH, IIMAGE_NOPITCHSWITCH, IIMAGE_NOFILTERSWITCH};
	m_MiscIcons.Create(IDB_IMAGELIST, 16, 16, IMGLIST_NUMIMAGES, 1, dc, scaling, false, miscIconsInvert);
	m_MiscIconsDisabled.Create(IDB_IMAGELIST, 16, 16, IMGLIST_NUMIMAGES, 1, dc, scaling, true, miscIconsInvert);
	m_PatternIcons.Create(IDB_PATTERNS, 16, 16, PATTERNIMG_NUMIMAGES, 1, dc, scaling, false, patternIconsInvert);
	m_PatternIconsDisabled.Create(IDB_PATTERNS, 16, 16, PATTERNIMG_NUMIMAGES, 1, dc, scaling, true, patternIconsInvert);
	m_EnvelopeIcons.Create(IDB_ENVTOOLBAR, 20, 18, ENVIMG_NUMIMAGES, 1, dc, scaling, false, envelopeIconsInvert);
	m_SampleIcons.Create(IDB_SMPTOOLBAR, 20, 18, SAMPLEIMG_NUMIMAGES, 1, dc, scaling, false);
	ReleaseDC(dc);

	NONCLIENTMETRICS metrics;
	metrics.cbSize = sizeof(metrics);
	SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(metrics), &metrics, 0);
	m_hGUIFont = CreateFontIndirect(&metrics.lfMessageFont);

	penDarkGray = ::CreatePen(PS_SOLID, 0, GetSysColor(COLOR_BTNSHADOW));
	penGray99 = ::CreatePen(PS_SOLID,0, RGB(0x99, 0x99, 0x99));
	penHalfDarkGray = ::CreatePen(PS_DOT, 0, GetSysColor(COLOR_BTNSHADOW));

	// Cursors
	curDragging = theApp.LoadCursor(IDC_DRAGGING);
	curArrow = theApp.LoadStandardCursor(IDC_ARROW);
	curNoDrop = theApp.LoadStandardCursor(IDC_NO);
	curNoDrop2 = theApp.LoadCursor(IDC_NODRAG);
	curVSplit = theApp.LoadCursor(AFX_IDC_HSPLITBAR);
	// bitmaps
	bmpNotes = LoadDib(MAKEINTRESOURCE(IDB_PATTERNVIEW));
	bmpVUMeters = LoadDib(MAKEINTRESOURCE(IDB_VUMETERS));
	bmpPluginVUMeters = LoadDib(MAKEINTRESOURCE(IDB_VUMETERS));
	// Toolbars
	EnableDocking(CBRS_ALIGN_ANY);
	if (!m_wndToolBar.Create(this)) return -1;
	if (!m_wndStatusBar.Create(this)) return -1;
	if (!m_wndTree.Create(this, IDD_TREEVIEW, CBRS_LEFT|CBRS_BORDER_RIGHT, IDD_TREEVIEW)) return -1;
	m_wndStatusBar.SetIndicators(indicators, mpt::saturate_cast<int>(std::size(indicators)));
	m_wndStatusBar.SetPaneInfo(0, ID_SEPARATOR, SBPS_STRETCH, 256);
	m_wndToolBar.Init(this);
	m_wndTree.RecalcLayout();

	RemoveControlBar(&m_wndStatusBar); //Removing statusbar because corrupted statusbar inifiledata can crash the program.
	m_wndTree.EnableDocking(0); //To prevent a crash when there's "Docking=1" for treebar in ini-settings.
	// Restore toobar positions
	LoadBarState(_T("Toolbars"));

	AddControlBar(&m_wndStatusBar); //Restore statusbar to mainframe.

	UpdateColors();

	if(TrackerSettings::Instance().m_dwMidiSetup & MIDISETUP_ENABLE_RECORD_DEFAULT) midiOpenDevice(false);

#if MPT_COMPILER_MSVC
#pragma warning(push)
#pragma warning(disable:6387) // '_Param_(2)' could be '0':  this does not adhere to the specification for the function 'HtmlHelpW'
#endif
	::HtmlHelp(m_hWnd, nullptr, HH_INITIALIZE, reinterpret_cast<DWORD_PTR>(&helpCookie));
#if MPT_COMPILER_MSVC
#pragma warning(pop)
#endif

	return 0;
}


BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
	return CMDIFrameWnd::PreCreateWindow(cs);
}


BOOL CMainFrame::DestroyWindow()
{
#if MPT_COMPILER_MSVC
#pragma warning(push)
#pragma warning(disable:6387) // '_Param_(2)' could be '0':  this does not adhere to the specification for the function 'HtmlHelpW'
#endif
	::HtmlHelp(m_hWnd, nullptr, HH_UNINITIALIZE, reinterpret_cast<DWORD_PTR>(&helpCookie));
#if MPT_COMPILER_MSVC
#pragma warning(pop)
#endif

	// Uninstall Keyboard Hook
	if (ghKbdHook)
	{
		UnhookWindowsHookEx(ghKbdHook);
		ghKbdHook = NULL;
	}
	// Kill Timer
	if (m_nTimer)
	{
		KillTimer(m_nTimer);
		m_nTimer = 0;
	}
	if (shMidiIn) midiCloseDevice();
	// Delete bitmaps
	delete bmpNotes;
	bmpNotes = nullptr;
	
	delete bmpVUMeters;
	bmpVUMeters = nullptr;
	
	delete bmpPluginVUMeters;
	bmpPluginVUMeters = nullptr;

	PatternFont::DeleteFontData();

	// Kill GDI Objects
#define DeleteGDIObject(h) ::DeleteObject(h); h = NULL;
	DeleteGDIObject(penDarkGray);
	DeleteGDIObject(m_hGUIFont);
	DeleteGDIObject(m_hFixedFont);
	DeleteGDIObject(penGray99);
#undef DeleteGDIObject

	return CMDIFrameWnd::DestroyWindow();
}


void CMainFrame::OnClose()
{
	MPT_TRACE_SCOPE();
	if(!(TrackerSettings::Instance().m_dwPatternSetup & PATTERN_NOCLOSEDIALOG))
	{
		// Show modified documents window
		CloseMainDialog dlg;
		if(dlg.DoModal() != IDOK)
		{
			return;
		}
	}

	CChildFrame *pMDIActive = (CChildFrame *)MDIGetActive();

	BeginWaitCursor();
	if (IsPlaying()) PauseMod();
	if (pMDIActive) pMDIActive->SavePosition(TRUE);

	if(gpSoundDevice)
	{
		gpSoundDevice->Stop();
		gpSoundDevice->Close();
		delete gpSoundDevice;
		gpSoundDevice = nullptr;
	}

	// Save Settings
	RemoveControlBar(&m_wndStatusBar); // Remove statusbar so that its state won't get saved.
	SaveBarState(_T("Toolbars"));
	AddControlBar(&m_wndStatusBar); // Restore statusbar to mainframe.
	TrackerSettings::Instance().SaveSettings();

	if(m_InputHandler && m_InputHandler->m_activeCommandSet)
	{
		m_InputHandler->m_activeCommandSet->SaveFile(TrackerSettings::Instance().m_szKbdFile);
	}

	EndWaitCursor();
	CMDIFrameWnd::OnClose();
}


BOOL CMainFrame::OnDeviceChange(UINT nEventType, DWORD_PTR dwData)
{
	if(nEventType == DBT_DEVNODES_CHANGED && shMidiIn)
	{
		// Calling this (or most other MIDI input related functions) makes the MIDI driver realize
		// that the connection to USB MIDI devices was lost and send a MIM_CLOSE message.
		// Otherwise, after disconnecting a USB MIDI device, the MIDI callback will stay alive forever but return no data.
		midiInGetNumDevs();
	}
	return CMDIFrameWnd::OnDeviceChange(nEventType, dwData);
}


// Drop files from Windows
void CMainFrame::OnDropFiles(HDROP hDropInfo)
{
	const UINT nFiles = ::DragQueryFileW(hDropInfo, (UINT)-1, NULL, 0);
	CMainFrame::GetMainFrame()->SetForegroundWindow();
	for(UINT f = 0; f < nFiles; f++)
	{
		UINT size = ::DragQueryFile(hDropInfo, f, nullptr, 0) + 1;
		std::vector<TCHAR> fileName(size, L'\0');
		if(::DragQueryFile(hDropInfo, f, fileName.data(), size))
		{
			const mpt::PathString file = mpt::PathString::FromNative(fileName.data());
#ifdef MPT_BUILD_DEBUG
			// Debug Hack: Quickly scan a folder containing module files (without running out of window handles ;)
			if(m_InputHandler->CtrlPressed() && m_InputHandler->AltPressed() && m_InputHandler->ShiftPressed() && file.IsDirectory())
			{
				FolderScanner scanner(file, FolderScanner::kOnlyFiles | FolderScanner::kFindInSubDirectories);
				mpt::PathString scanName;
				size_t failed = 0, total = 0;
				while(scanner.Next(scanName))
				{
					InputFile inputFile(scanName, TrackerSettings::Instance().MiscCacheCompleteFileBeforeLoading);
					if(!inputFile.IsValid())
						continue;
					auto sndFile = std::make_unique<CSoundFile>();
					MPT_LOG_GLOBAL(LogDebug, "info", U_("Loading ") + scanName.ToUnicode());
					if(!sndFile->Create(GetFileReader(inputFile), CSoundFile::loadCompleteModule, nullptr))
					{
						MPT_LOG_GLOBAL(LogDebug, "info", U_("FAILED: ") + scanName.ToUnicode());
						failed++;
					}
					total++;
				}
				Reporting::Information(MPT_UFORMAT("Scanned {} files, {} failed")(total, failed));
				break;
			}
#endif
			theApp.OpenDocumentFile(file.ToCString());
		}
	}
	::DragFinish(hDropInfo);
}


void CMainFrame::OnActivateApp(BOOL active, DWORD /*threadID*/)
{
	// Ensure modifiers are reset when we leave the window (e.g. Alt-Tab)
	if(!active)
		m_InputHandler->SetModifierMask(ModNone);
}


LRESULT CALLBACK CMainFrame::KeyboardProc(int code, WPARAM wParam, LPARAM lParam)
{

	static bool s_KeyboardHookReentryFlag = false; // work-around for https://bugs.openmpt.org/view.php?id=713

	if(mpt::OS::Windows::IsWine()) // work-around for https://bugs.openmpt.org/view.php?id=713
	{
		// TODO: Properly fix this in same way or another.
		if(code < 0)
		{
			return CallNextHookEx(ghKbdHook, code, wParam, lParam); // required by spec
		}
		if(theApp.InGuiThread())
		{
			if(s_KeyboardHookReentryFlag)
			{
				// Exit early without calling our hook when re-entering.
				// We still need to call other hooks though.
				return CallNextHookEx(ghKbdHook, code, wParam, lParam); // required by spec
			}
			s_KeyboardHookReentryFlag = true;
		}
	}

	bool skipFurtherProcessing = false;

	if(code >= 0)
	{
		// Check if textbox has focus
		const bool handledByTextBox = m_InputHandler->IsKeyPressHandledByTextBox(static_cast<DWORD>(wParam), ::GetFocus());
		if(!handledByTextBox && m_InputHandler->GeneralKeyEvent(kCtxAllContexts, code, wParam, lParam) != kcNull)
		{
			if(wParam != VK_ESCAPE)
			{
				// We've handled the keypress. No need to take it further.
				// Unless it was esc, in which case we need it to close Windows
				// (there might be other special cases, we'll see.. )
				skipFurtherProcessing = true;
			}
		}
	}

	LRESULT result = 0;
	if(skipFurtherProcessing)
	{
		result = -1;
	} else
	{
		result = CallNextHookEx(ghKbdHook, code, wParam, lParam);
	}

	if(mpt::OS::Windows::IsWine()) // work-around for https://bugs.openmpt.org/view.php?id=713
	{
		if(theApp.InGuiThread())
		{
			s_KeyboardHookReentryFlag = false;
		}
	}

	return result;
}


BOOL CMainFrame::PreTranslateMessage(MSG* pMsg)
{
	if((pMsg->message == WM_RBUTTONDOWN) || (pMsg->message == WM_NCRBUTTONDOWN))
	{
		CWnd* pWnd = CWnd::FromHandlePermanent(pMsg->hwnd);
		CControlBar* pBar = NULL;
		HWND hwnd = (pWnd) ? pWnd->m_hWnd : NULL;

		if ((hwnd) && (pMsg->message == WM_RBUTTONDOWN)) pBar = DYNAMIC_DOWNCAST(CControlBar, pWnd);
		if ((pBar != NULL) || ((pMsg->message == WM_NCRBUTTONDOWN) && (pMsg->wParam == HTMENU)))
		{
			CMenu Menu;
			CPoint pt;

			GetCursorPos(&pt);
			if (Menu.LoadMenu(IDR_TOOLBARS))
			{
				CMenu* pSubMenu = Menu.GetSubMenu(0);
				if (pSubMenu!=NULL) pSubMenu->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON,pt.x,pt.y,this);
			}
		}
	}
	return CMDIFrameWnd::PreTranslateMessage(pMsg);
}


void CMainFrame::OnUpdateFrameTitle(BOOL bAddToTitle)
{
	if ((GetStyle() & FWS_ADDTOTITLE) == 0)	return;     // leave it alone!

	CMDIChildWnd* pActiveChild = nullptr;
	CDocument* pDocument = GetActiveDocument();
	if (bAddToTitle &&
	  (pActiveChild = MDIGetActive()) != nullptr &&
	  (pActiveChild->GetStyle() & WS_MAXIMIZE) == 0 &&
	  (pDocument != nullptr ||
	   (pDocument = pActiveChild->GetActiveDocument()) != nullptr))
	{
		CString title = pDocument->GetTitle();
		if(pDocument->IsModified())
			title.AppendChar(_T('*'));
		UpdateFrameTitleForDocument(title);
	} else
	{
		LPCTSTR lpstrTitle = nullptr;
		CString strTitle;

		if (pActiveChild != nullptr)
		{
			strTitle = pActiveChild->GetTitle();
			if (!strTitle.IsEmpty())
				lpstrTitle = strTitle;
		}
		UpdateFrameTitleForDocument(lpstrTitle);
	}
}


/////////////////////////////////////////////////////////////////////////////
// CMainFrame Sound Library


void CMainFrame::OnTimerNotify()
{
	MPT_TRACE_SCOPE();
	ASSERT(InGuiThread());
	ASSERT(!InNotifyHandler());
	m_InNotifyHandler = true;
	Notification PendingNotification;
	bool found = false;
	int64 currenttotalsamples = 0;
	if(gpSoundDevice)
	{
		currenttotalsamples = gpSoundDevice->GetStreamPosition().Frames;
	}
	{
		// advance to the newest notification, drop the obsolete ones
		mpt::lock_guard<mpt::mutex> lock(m_NotificationBufferMutex);
		const Notification * pnotify = nullptr;
		const Notification * p = m_NotifyBuffer.peek_p();
		if(p && currenttotalsamples >= p->timestampSamples)
		{
			pnotify = p;
			while(m_NotifyBuffer.peek_next_p() && currenttotalsamples >= m_NotifyBuffer.peek_next_p()->timestampSamples)
			{
				m_NotifyBuffer.pop();
				p = m_NotifyBuffer.peek_p();
				pnotify = p;
			}
		}
		if(pnotify)
		{
			PendingNotification = *pnotify; // copy notification so that we can free the buffer
			found = true;
			{
				m_NotifyBuffer.pop();
			}
		}
	}
	if(found)
	{
		OnUpdatePosition(0, (LPARAM)&PendingNotification);
	}
	m_InNotifyHandler = false;
	ASSERT(!InNotifyHandler());
}


void CMainFrame::SoundDeviceMessage(LogLevel level, const mpt::ustring &str)
{
	MPT_TRACE();
	Reporting::Message(level, str);
}


void CMainFrame::SoundCallbackPreStart()
{
	MPT_TRACE();
	m_SoundDeviceClock.SetResolution(1);
}


void CMainFrame::SoundCallbackPostStop()
{
	MPT_TRACE();
	m_SoundDeviceClock.SetResolution(0);
}


uint64 CMainFrame::SoundCallbackGetReferenceClockNowNanoseconds() const
{
	MPT_TRACE();
	MPT_ASSERT(!InAudioThread());
	return m_SoundDeviceClock.NowNanoseconds();
}


uint64 CMainFrame::SoundCallbackLockedGetReferenceClockNowNanoseconds() const
{
	MPT_TRACE();
	MPT_ASSERT(InAudioThread());
	return m_SoundDeviceClock.NowNanoseconds();
}


bool CMainFrame::SoundCallbackIsLockedByCurrentThread() const
{
	MPT_TRACE();
	return theApp.GetGlobalMutexRef().IsLockedByCurrentThread();
}


void CMainFrame::SoundCallbackLock()
{
	MPT_TRACE_SCOPE();
	m_SoundDeviceFillBufferCriticalSection.Enter();
	MPT_ASSERT_ALWAYS(m_pSndFile != nullptr);
	m_AudioThreadId = GetCurrentThreadId();
	mpt::log::Trace::SetThreadId(mpt::log::Trace::ThreadKindAudio, m_AudioThreadId);
}


void CMainFrame::SoundCallbackUnlock()
{
	MPT_TRACE_SCOPE();
	MPT_ASSERT_ALWAYS(m_pSndFile != nullptr);
	m_AudioThreadId = 0;
	m_SoundDeviceFillBufferCriticalSection.Leave();
}


class BufferInputWrapper
	: public IAudioSource
{
private:
	SoundDevice::CallbackBuffer<DithersOpenMPT> &callbackBuffer;
public:
	inline BufferInputWrapper(SoundDevice::CallbackBuffer<DithersOpenMPT> &callbackBuffer_)
		: callbackBuffer(callbackBuffer_)
	{
		return;
	}
	inline void Process(mpt::audio_span_planar<MixSampleInt> buffer) override
	{
		callbackBuffer.template ReadFixedPoint<MixSampleIntTraits::mix_fractional_bits>(buffer);
	}
	inline void Process(mpt::audio_span_planar<MixSampleFloat> buffer) override
	{
		callbackBuffer.Read(buffer);
	}
};


class BufferOutputWrapper
	: public IAudioTarget
{
private:
	SoundDevice::CallbackBuffer<DithersOpenMPT> &callbackBuffer;
public:
	inline BufferOutputWrapper(SoundDevice::CallbackBuffer<DithersOpenMPT> &callbackBuffer_)
		: callbackBuffer(callbackBuffer_)
	{
		return;
	}
	inline void Process(mpt::audio_span_interleaved<MixSampleInt> buffer) override
	{
		callbackBuffer.template WriteFixedPoint<MixSampleIntTraits::mix_fractional_bits>(buffer);
	}
	inline void Process(mpt::audio_span_interleaved<MixSampleFloat> buffer) override
	{
		callbackBuffer.Write(buffer);
	}
};


void CMainFrame::SoundCallbackLockedProcessPrepare(SoundDevice::TimeInfo timeInfo)
{
	MPT_TRACE_SCOPE();
	MPT_ASSERT(InAudioThread());
	TimingInfo timingInfo;
	timingInfo.OutputLatency = timeInfo.Latency;
	timingInfo.StreamFrames = timeInfo.SyncPointStreamFrames;
	timingInfo.SystemTimestamp = timeInfo.SyncPointSystemTimestamp;
	timingInfo.Speed = timeInfo.Speed;
	m_pSndFile->m_TimingInfo = timingInfo;
}


void CMainFrame::SoundCallbackLockedCallback(SoundDevice::CallbackBuffer<DithersOpenMPT> &buffer)
{
	MPT_TRACE_SCOPE();
	MPT_ASSERT(InAudioThread());
	OPENMPT_PROFILE_FUNCTION(Profiler::Audio);
	BufferInputWrapper source(buffer);
	BufferOutputWrapper target(buffer);
	MPT_ASSERT(buffer.GetNumFrames() <= std::numeric_limits<CSoundFile::samplecount_t>::max());
	CSoundFile::samplecount_t framesToRender = static_cast<CSoundFile::samplecount_t>(buffer.GetNumFrames());
	MPT_ASSERT(framesToRender > 0);
	CSoundFile::samplecount_t renderedFrames = m_pSndFile->Read(framesToRender, target, source, std::ref(m_VUMeterOutput), std::ref(m_VUMeterInput));
	MPT_ASSERT(renderedFrames <= framesToRender);
	[[maybe_unused]] CSoundFile::samplecount_t remainingFrames = framesToRender - renderedFrames;
	MPT_ASSERT(remainingFrames >= 0); // remaining buffer is filled with silence automatically
}


void CMainFrame::SoundCallbackLockedProcessDone(SoundDevice::TimeInfo timeInfo)
{
	MPT_TRACE_SCOPE();
	MPT_ASSERT(InAudioThread());
	OPENMPT_PROFILE_FUNCTION(Profiler::Notify);
	MPT_ASSERT((timeInfo.RenderStreamPositionAfter.Frames - timeInfo.RenderStreamPositionBefore.Frames) < std::numeric_limits<CSoundFile::samplecount_t>::max());
	CSoundFile::samplecount_t framesRendered = static_cast<CSoundFile::samplecount_t>(timeInfo.RenderStreamPositionAfter.Frames - timeInfo.RenderStreamPositionBefore.Frames);
	int64 streamPosition = timeInfo.RenderStreamPositionAfter.Frames;
	DoNotification(framesRendered, streamPosition);
	//m_pSndFile->m_TimingInfo = TimingInfo(); // reset
}


bool CMainFrame::IsAudioDeviceOpen() const
{
	MPT_TRACE_SCOPE();
	return gpSoundDevice && gpSoundDevice->IsOpen();
}


bool CMainFrame::audioOpenDevice()
{
	MPT_TRACE_SCOPE();
	const SoundDevice::Identifier deviceIdentifier = TrackerSettings::Instance().GetSoundDeviceIdentifier();
	if(!TrackerSettings::Instance().GetMixerSettings().IsValid())
	{
		Reporting::Error(MPT_UFORMAT("Unable to open sound device '{}': Invalid mixer settings.")(deviceIdentifier));
		return false;
	}
	if(gpSoundDevice && (gpSoundDevice->GetDeviceInfo().GetIdentifier() != deviceIdentifier))
	{
		gpSoundDevice->Stop();
		gpSoundDevice->Close();
		delete gpSoundDevice;
		gpSoundDevice = nullptr;
	}
	if(IsAudioDeviceOpen())
	{
		return true;
	}
	if(!gpSoundDevice)
	{
		gpSoundDevice = theApp.GetSoundDevicesManager()->CreateSoundDevice(deviceIdentifier);
	}
	if(!gpSoundDevice)
	{
		Reporting::Error(MPT_UFORMAT("Unable to open sound device '{}': Could not find sound device.")(deviceIdentifier));
		return false;
	}
	gpSoundDevice->SetMessageReceiver(this);
	gpSoundDevice->SetCallback(this);
	SoundDevice::Settings deviceSettings = TrackerSettings::Instance().GetSoundDeviceSettings(deviceIdentifier);
	if(!gpSoundDevice->Open(deviceSettings))
	{
		if(!gpSoundDevice->IsAvailable())
		{
			Reporting::Error(MPT_UFORMAT("Unable to open sound device '{}': Device not available.")(gpSoundDevice->GetDeviceInfo().GetDisplayName()));
		} else
		{
			Reporting::Error(MPT_UFORMAT("Unable to open sound device '{}'.")(gpSoundDevice->GetDeviceInfo().GetDisplayName()));
		}
		return false;
	}
	SampleFormat actualSampleFormat = gpSoundDevice->GetActualSampleFormat();
	if(!actualSampleFormat.IsValid())
	{
		Reporting::Error(MPT_UFORMAT("Unable to open sound device '{}': Unknown sample format.")(gpSoundDevice->GetDeviceInfo().GetDisplayName()));
		return false;
	}
	deviceSettings.sampleFormat = actualSampleFormat;
	Dithers().SetMode(deviceSettings.DitherType, deviceSettings.Channels);
	TrackerSettings::Instance().MixerSamplerate = gpSoundDevice->GetSettings().Samplerate;
	TrackerSettings::Instance().SetSoundDeviceSettings(deviceIdentifier, deviceSettings);
	return true;
}


void CMainFrame::audioCloseDevice()
{
	MPT_TRACE_SCOPE();
	if(gpSoundDevice)
	{
		gpSoundDevice->Close();
	}
	if(m_NotifyTimer)
	{
		KillTimer(m_NotifyTimer);
		m_NotifyTimer = 0;
	}
	ResetNotificationBuffer();
}


void VUMeter::Process(Channel &c, MixSampleInt sample)
{
	c.peak = std::max(c.peak, std::abs(sample));
	if(sample < MixSampleIntTraits::mix_clip_min || MixSampleIntTraits::mix_clip_max < sample)
	{
		c.clipped = true;
	}
}


void VUMeter::Process(Channel &c, MixSampleFloat sample)
{
	Process(c, SC::ConvertToFixedPoint<MixSampleInt, MixSampleFloat, MixSampleIntTraits::mix_fractional_bits>()(sample));
}


void VUMeter::Process(mpt::audio_span_interleaved<const MixSampleInt> buffer)
{
	for(std::size_t frame = 0; frame < buffer.size_frames(); ++frame)
	{
		for(std::size_t channel = 0; channel < std::min(buffer.size_channels(), maxChannels); ++channel)
		{
			Process(channels[channel], buffer(channel, frame));
		}
	}
	for(std::size_t channel = std::min(buffer.size_channels(), maxChannels); channel < maxChannels; ++channel)
	{
		channels[channel] = Channel();
	}
}


void VUMeter::Process(mpt::audio_span_interleaved<const MixSampleFloat> buffer)
{
	for(std::size_t frame = 0; frame < buffer.size_frames(); ++frame)
	{
		for(std::size_t channel = 0; channel < std::min(buffer.size_channels(), maxChannels); ++channel)
		{
			Process(channels[channel], buffer(channel, frame));
		}
	}
	for(std::size_t channel = std::min(buffer.size_channels(), maxChannels); channel < maxChannels; ++channel)
	{
		channels[channel] = Channel();
	}
}


void VUMeter::Process(mpt::audio_span_planar<const MixSampleInt> buffer)
{
	for(std::size_t frame = 0; frame < buffer.size_frames(); ++frame)
	{
		for(std::size_t channel = 0; channel < std::min(buffer.size_channels(), maxChannels); ++channel)
		{
			Process(channels[channel], buffer(channel, frame));
		}
	}
	for(std::size_t channel = std::min(buffer.size_channels(), maxChannels); channel < maxChannels; ++channel)
	{
		channels[channel] = Channel();
	}
}


void VUMeter::Process(mpt::audio_span_planar<const MixSampleFloat> buffer)
{
	for(std::size_t frame = 0; frame < buffer.size_frames(); ++frame)
	{
		for(std::size_t channel = 0; channel < std::min(buffer.size_channels(), maxChannels); ++channel)
		{
			Process(channels[channel], buffer(channel, frame));
		}
	}
	for(std::size_t channel = std::min(buffer.size_channels(), maxChannels); channel < maxChannels; ++channel)
	{
		channels[channel] = Channel();
	}
}


const float VUMeter::dynamicRange = 48.0f; // corresponds to the current implementation of the UI widget displaying the result


void VUMeter::SetDecaySpeedDecibelPerSecond(float decibelPerSecond)
{
	float linearDecayRate = decibelPerSecond / dynamicRange;
	decayParam = mpt::saturate_round<int32>(linearDecayRate * static_cast<float>(MixSampleIntTraits::mix_clip_max));
}


void VUMeter::Decay(int32 secondsNum, int32 secondsDen)
{
	int32 decay = Util::muldivr(decayParam, secondsNum, secondsDen);
	for(std::size_t channel = 0; channel < maxChannels; ++channel)
	{
		channels[channel].peak = std::max(channels[channel].peak - decay, 0);
	}
}


void VUMeter::ResetClipped()
{
	for(std::size_t channel = 0; channel < maxChannels; ++channel)
	{
		channels[channel].clipped = false;
	}
}


static void SetVUMeter(std::array<uint32, 4> &masterVU, const VUMeter &vumeter)
{
	for(std::size_t channel = 0; channel < VUMeter::maxChannels; ++channel)
	{
		masterVU[channel] = Clamp(vumeter[channel].peak >> 11, 0, 0x10000);
		if(vumeter[channel].clipped)
		{
			masterVU[channel] |= Notification::ClipVU;
		}
	}
}


bool CMainFrame::DoNotification(DWORD dwSamplesRead, int64 streamPosition)
{
	MPT_TRACE_SCOPE();
	ASSERT(InAudioThread());
	if(!m_pSndFile) return false;

	FlagSet<Notification::Type> notifyType(Notification::Default);
	Notification::Item notifyItem = 0;

	if(m_pSndFile->m_pModDoc)
	{
		notifyType = m_pSndFile->m_pModDoc->GetNotificationType();
		notifyItem = m_pSndFile->m_pModDoc->GetNotificationItem();
	}

	// Add an entry to the notification history

	Notification notification(notifyType, notifyItem, streamPosition, m_pSndFile->m_PlayState.m_nRow, m_pSndFile->m_PlayState.m_nTickCount, m_pSndFile->m_PlayState.TicksOnRow(), m_pSndFile->m_PlayState.m_nCurrentOrder, m_pSndFile->m_PlayState.m_nPattern, m_pSndFile->GetMixStat(), static_cast<uint8>(m_pSndFile->m_MixerSettings.gnChannels), static_cast<uint8>(m_pSndFile->m_MixerSettings.NumInputChannels));

	m_pSndFile->ResetMixStat();

	if(m_pSndFile->m_SongFlags[SONG_ENDREACHED]) notification.type.set(Notification::EOS);

	if(notifyType[Notification::Sample])
	{
		// Sample positions
		const SAMPLEINDEX smp = notifyItem;
		if(smp > 0 && smp <= m_pSndFile->GetNumSamples() && m_pSndFile->GetSample(smp).HasSampleData())
		{
			for(CHANNELINDEX k = 0; k < MAX_CHANNELS; k++)
			{
				const ModChannel &chn = m_pSndFile->m_PlayState.Chn[k];
				if(chn.pModSample == &m_pSndFile->GetSample(smp) && chn.nLength != 0	// Corrent sample is set up on this channel
					&& (!chn.dwFlags[CHN_NOTEFADE] || chn.nFadeOutVol))					// And it hasn't completely faded out yet, so it's still playing
				{
					notification.pos[k] = chn.position.GetInt();
				} else
				{
					notification.pos[k] = Notification::PosInvalid;
				}
			}
		} else
		{
			// Can't generate a valid notification.
			notification.type.reset(Notification::Sample);
		}
	} else if(notifyType[Notification::VolEnv | Notification::PanEnv | Notification::PitchEnv])
	{
		// Instrument envelopes
		const INSTRUMENTINDEX ins = notifyItem;

		EnvelopeType notifyEnv = ENV_VOLUME;
		if(notifyType[Notification::PitchEnv])
			notifyEnv = ENV_PITCH;
		else if(notifyType[Notification::PanEnv])
			notifyEnv = ENV_PANNING;

		if(ins > 0 && ins <= m_pSndFile->GetNumInstruments() && m_pSndFile->Instruments[ins] != nullptr)
		{
			for(CHANNELINDEX k = 0; k < MAX_CHANNELS; k++)
			{
				const ModChannel &chn = m_pSndFile->m_PlayState.Chn[k];
				SmpLength pos = Notification::PosInvalid;

				if(chn.pModInstrument == m_pSndFile->Instruments[ins]				// Correct instrument is set up on this channel
					&& (chn.nLength || chn.pModInstrument->HasValidMIDIChannel())	// And it's playing something (sample or instrument plugin)
					&& (!chn.dwFlags[CHN_NOTEFADE] || chn.nFadeOutVol))				// And it hasn't completely faded out yet, so it's still playing
				{
					const ModChannel::EnvInfo &chnEnv = chn.GetEnvelope(notifyEnv);
					if(chnEnv.flags[ENV_ENABLED])
					{
						pos = chnEnv.nEnvPosition;
						if(m_pSndFile->m_playBehaviour[kITEnvelopePositionHandling])
						{
							// Impulse Tracker envelope handling (see e.g. CSoundFile::IncrementEnvelopePosition in SndMix.cpp for details)
							if(pos > 0)
								pos--;
							else
								pos = Notification::PosInvalid;	// Envelope isn't playing yet (e.g. when disabling it right when triggering a note)
						}
					}
				}
				notification.pos[k] = pos;
			}
		} else
		{
			// Can't generate a valid notification.
			notification.type.reset(Notification::VolEnv | Notification::PanEnv | Notification::PitchEnv);
		}
	} else if(notifyType[Notification::VUMeters])
	{
		// Pattern channel VU meters
		for(CHANNELINDEX k = 0; k < m_pSndFile->GetNumChannels(); k++)
		{
			uint32 vul = m_pSndFile->m_PlayState.Chn[k].nLeftVU;
			uint32 vur = m_pSndFile->m_PlayState.Chn[k].nRightVU;
			notification.pos[k] = (vul << 8) | (vur);
		}
	}

	{
		// Master VU meter
		SetVUMeter(notification.masterVUin, m_VUMeterInput);
		SetVUMeter(notification.masterVUout, m_VUMeterOutput);
		m_VUMeterInput.Decay(dwSamplesRead, m_pSndFile->m_MixerSettings.gdwMixingFreq);
		m_VUMeterOutput.Decay(dwSamplesRead, m_pSndFile->m_MixerSettings.gdwMixingFreq);

	}

	{
		mpt::lock_guard<mpt::mutex> lock(m_NotificationBufferMutex);
		if(m_NotifyBuffer.write_size() == 0)
		{
			ASSERT(0);
			return FALSE; // drop notification
		}
		m_NotifyBuffer.push(notification);
	}

	return true;
}


void CMainFrame::UpdateDspEffects(CSoundFile &sndFile, bool reset)
{
	CriticalSection cs;
#ifndef NO_REVERB
	sndFile.m_Reverb.m_Settings = TrackerSettings::Instance().m_ReverbSettings;
#endif
#ifndef NO_DSP
	sndFile.m_Surround.m_Settings = TrackerSettings::Instance().m_SurroundSettings;
#endif
#ifndef NO_DSP
	sndFile.m_MegaBass.m_Settings = TrackerSettings::Instance().m_MegaBassSettings;
#endif
#ifndef NO_EQ
	sndFile.SetEQGains(TrackerSettings::Instance().m_EqSettings.Gains, TrackerSettings::Instance().m_EqSettings.Freqs, reset);
#endif
#ifndef NO_DSP
	sndFile.m_BitCrush.m_Settings = TrackerSettings::Instance().m_BitCrushSettings;
#endif
	sndFile.SetDspEffects(TrackerSettings::Instance().MixerDSPMask);
	sndFile.InitPlayer(reset);
}


void CMainFrame::UpdateAudioParameters(CSoundFile &sndFile, bool reset)
{
	CriticalSection cs;
	if (TrackerSettings::Instance().m_dwPatternSetup & PATTERN_MUTECHNMODE)
		TrackerSettings::Instance().MixerFlags |= SNDMIX_MUTECHNMODE;
	else
		TrackerSettings::Instance().MixerFlags &= ~SNDMIX_MUTECHNMODE;
	sndFile.SetMixerSettings(TrackerSettings::Instance().GetMixerSettings());
	sndFile.SetResamplerSettings(TrackerSettings::Instance().GetResamplerSettings());
	UpdateDspEffects(sndFile, false); // reset done in next line
	sndFile.InitPlayer(reset);
}


/////////////////////////////////////////////////////////////////////////////
// CMainFrame diagnostics

#ifdef _DEBUG
void CMainFrame::AssertValid() const
{
	CMDIFrameWnd::AssertValid();
}

void CMainFrame::Dump(CDumpContext& dc) const
{
	CMDIFrameWnd::Dump(dc);
}

#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CMainFrame static helpers


void CMainFrame::UpdateColors()
{
	const auto &colors = TrackerSettings::Instance().rgbCustomColors;
	const struct { MODPLUGDIB *bitmap; uint32 lo, med, hi; } meters[] =
	{
		{ bmpVUMeters, MODCOLOR_VUMETER_LO, MODCOLOR_VUMETER_MED, MODCOLOR_VUMETER_HI },
		{ bmpPluginVUMeters, MODCOLOR_VUMETER_LO_VST, MODCOLOR_VUMETER_MED_VST, MODCOLOR_VUMETER_HI_VST },
	};
	for(auto &meter : meters) if(meter.bitmap != nullptr)
	{
		meter.bitmap->bmiColors[7] = rgb2quad(GetSysColor(COLOR_BTNFACE));
		meter.bitmap->bmiColors[8] = rgb2quad(GetSysColor(COLOR_BTNSHADOW));
		meter.bitmap->bmiColors[15] = rgb2quad(GetSysColor(COLOR_BTNHIGHLIGHT));
		meter.bitmap->bmiColors[10] = rgb2quad(colors[meter.lo]);
		meter.bitmap->bmiColors[11] = rgb2quad(colors[meter.med]);
		meter.bitmap->bmiColors[9] = rgb2quad(colors[meter.hi]);
		meter.bitmap->bmiColors[2] = rgb2quad((colors[meter.lo] >> 1) & 0x7F7F7F);
		meter.bitmap->bmiColors[3] = rgb2quad((colors[meter.med] >> 1) & 0x7F7F7F);
		meter.bitmap->bmiColors[1] = rgb2quad((colors[meter.hi] >> 1) & 0x7F7F7F);
	}

	// Generel tab VU meters
	for(UINT i = 0; i < NUM_VUMETER_PENS * 2; i++)
	{
		int r0,g0,b0, r1,g1,b1;
		int r, g, b;
		int y;

		y = (i >= NUM_VUMETER_PENS) ? (i-NUM_VUMETER_PENS) : i;
		if (y < (NUM_VUMETER_PENS/2))
		{
			r0 = GetRValue(colors[MODCOLOR_VUMETER_LO]);
			g0 = GetGValue(colors[MODCOLOR_VUMETER_LO]);
			b0 = GetBValue(colors[MODCOLOR_VUMETER_LO]);
			r1 = GetRValue(colors[MODCOLOR_VUMETER_MED]);
			g1 = GetGValue(colors[MODCOLOR_VUMETER_MED]);
			b1 = GetBValue(colors[MODCOLOR_VUMETER_MED]);
		} else
		{
			y -= (NUM_VUMETER_PENS/2);
			r0 = GetRValue(colors[MODCOLOR_VUMETER_MED]);
			g0 = GetGValue(colors[MODCOLOR_VUMETER_MED]);
			b0 = GetBValue(colors[MODCOLOR_VUMETER_MED]);
			r1 = GetRValue(colors[MODCOLOR_VUMETER_HI]);
			g1 = GetGValue(colors[MODCOLOR_VUMETER_HI]);
			b1 = GetBValue(colors[MODCOLOR_VUMETER_HI]);
		}
		r = r0 + ((r1 - r0) * y) / (NUM_VUMETER_PENS/2);
		g = g0 + ((g1 - g0) * y) / (NUM_VUMETER_PENS/2);
		b = b0 + ((b1 - b0) * y) / (NUM_VUMETER_PENS/2);
		if (i >= NUM_VUMETER_PENS)
		{
			r = (r*2)/5;
			g = (g*2)/5;
			b = (b*2)/5;
		}
		gcolrefVuMeter[i] = RGB(r, g, b);
	}
	CMainFrame *mainFrm = GetMainFrame();
	if(mainFrm != nullptr)
	{
		mainFrm->m_wndToolBar.m_VuMeter.Invalidate();
	}
}


/////////////////////////////////////////////////////////////////////////////
// CMainFrame operations


UINT CMainFrame::GetBaseOctave() const
{
	return m_wndToolBar.GetBaseOctave();
}


void CMainFrame::ResetNotificationBuffer()
{
	MPT_TRACE();
	mpt::lock_guard<mpt::mutex> lock(m_NotificationBufferMutex);
	m_NotifyBuffer.clear();
}


bool CMainFrame::PreparePlayback()
{
	MPT_TRACE_SCOPE();
	// open the audio device to update needed TrackerSettings mixer parameters
	if(!audioOpenDevice()) return false;
	return true;
}


bool CMainFrame::StartPlayback()
{
	MPT_TRACE_SCOPE();
	if(!m_pSndFile) return false; // nothing to play
	if(!IsAudioDeviceOpen()) return false;
	Dithers().Reset();
	if(!gpSoundDevice->Start()) return false;
	if(!m_NotifyTimer)
	{
		if(TrackerSettings::Instance().GUIUpdateInterval.Get() > 0)
		{
			m_NotifyTimer = SetTimer(TIMERID_NOTIFY, TrackerSettings::Instance().GUIUpdateInterval, NULL);
		} else
		{
			m_NotifyTimer = SetTimer(TIMERID_NOTIFY, std::max(int(1), mpt::saturate_round<int>(gpSoundDevice->GetEffectiveBufferAttributes().UpdateInterval * 1000.0)), NULL);
		}
	}
	return true;
}


void CMainFrame::StopPlayback()
{
	MPT_TRACE_SCOPE();
	if(!IsAudioDeviceOpen()) return;
	gpSoundDevice->Stop();
	if(m_NotifyTimer)
	{
		KillTimer(m_NotifyTimer);
		m_NotifyTimer = 0;
	}
	ResetNotificationBuffer();
	if(!gpSoundDevice->GetDeviceCaps().CanKeepDeviceRunning || TrackerSettings::Instance().m_SoundSettingsStopMode == SoundDeviceStopModeClosed)
	{
		audioCloseDevice();
	}
}


bool CMainFrame::RestartPlayback()
{
	MPT_TRACE_SCOPE();
	if(!m_pSndFile) return false; // nothing to play
	if(!IsAudioDeviceOpen()) return false;
	if(!gpSoundDevice->IsPlaying()) return false;
	gpSoundDevice->StopAndAvoidPlayingSilence();
	if(m_NotifyTimer)
	{
		KillTimer(m_NotifyTimer);
		m_NotifyTimer = 0;
	}
	ResetNotificationBuffer();
	return StartPlayback();
}


bool CMainFrame::PausePlayback()
{
	MPT_TRACE_SCOPE();
	if(!IsAudioDeviceOpen()) return false;
	gpSoundDevice->Stop();
	if(m_NotifyTimer)
	{
		KillTimer(m_NotifyTimer);
		m_NotifyTimer = 0;
	}
	ResetNotificationBuffer();
	return true;
}


void CMainFrame::GenerateStopNotification()
{
	Notification mn(Notification::Stop);
	SendMessage(WM_MOD_UPDATEPOSITION, 0, (LPARAM)&mn);
}


void CMainFrame::UnsetPlaybackSoundFile()
{
	MPT_ASSERT_ALWAYS(!gpSoundDevice || !gpSoundDevice->IsPlaying());
	if(m_pSndFile)
	{
		m_pSndFile->SuspendPlugins();
		if(m_pSndFile->GetpModDoc())
		{
			m_wndTree.UpdatePlayPos(m_pSndFile->GetpModDoc(), nullptr);
		}
		m_pSndFile->m_SongFlags.reset(SONG_PAUSED);
		if(m_pSndFile == &m_WaveFile)
		{
			// Unload previewed instrument
			m_WaveFile.Destroy();
		} else
		{
			// Stop sample preview channels
			for(CHANNELINDEX i = m_pSndFile->m_nChannels; i < MAX_CHANNELS; i++)
			{
				if(m_pSndFile->m_PlayState.Chn[i].isPreviewNote)
				{
					m_pSndFile->m_PlayState.Chn[i].nLength = 0;
					m_pSndFile->m_PlayState.Chn[i].position.Set(0);
				}
			}
		}
	}
	m_pSndFile = nullptr;
	m_wndToolBar.SetCurrentSong(nullptr);
	ResetNotificationBuffer();
}


void CMainFrame::SetPlaybackSoundFile(CSoundFile *pSndFile)
{
	MPT_ASSERT_ALWAYS(pSndFile);
	m_pSndFile = pSndFile;
}


bool CMainFrame::PlayMod(CModDoc *pModDoc)
{
	MPT_ASSERT_ALWAYS(!theApp.GetGlobalMutexRef().IsLockedByCurrentThread());
	if(!pModDoc) return false;
	CSoundFile &sndFile = pModDoc->GetSoundFile();
	if(!IsValidSoundFile(sndFile)) return false;

	// if something is playing, pause it
	PausePlayback();
	GenerateStopNotification();

	UnsetPlaybackSoundFile();

	// open audio device if not already open
	if (!PreparePlayback()) return false;

	// set mixing parameters in CSoundFile
	UpdateAudioParameters(sndFile);

	SetPlaybackSoundFile(&sndFile);

	const bool bPaused = m_pSndFile->IsPaused();
	const bool bPatLoop = m_pSndFile->m_SongFlags[SONG_PATTERNLOOP];

	m_pSndFile->m_SongFlags.reset(SONG_FADINGSONG | SONG_ENDREACHED);

	if(!bPatLoop && bPaused) sndFile.m_SongFlags.set(SONG_PAUSED);
	sndFile.SetRepeatCount((TrackerSettings::Instance().gbLoopSong) ? -1 : 0);

	sndFile.InitPlayer(true);
	sndFile.ResumePlugins();

	m_wndToolBar.SetCurrentSong(m_pSndFile);

	m_VUMeterInput = VUMeter();
	m_VUMeterOutput = VUMeter();

	if(!StartPlayback())
	{
		UnsetPlaybackSoundFile();
		return false;
	}

	return true;
}


bool CMainFrame::PauseMod(CModDoc *pModDoc)
{
	MPT_ASSERT_ALWAYS(!theApp.GetGlobalMutexRef().IsLockedByCurrentThread());
	if(pModDoc && (pModDoc != GetModPlaying())) return false;
	if(!IsPlaying()) return true;

	PausePlayback();
	GenerateStopNotification();

	UnsetPlaybackSoundFile();

	StopPlayback();

	return true;
}


bool CMainFrame::StopMod(CModDoc *pModDoc)
{
	MPT_ASSERT_ALWAYS(!theApp.GetGlobalMutexRef().IsLockedByCurrentThread());
	if(pModDoc && (pModDoc != GetModPlaying())) return false;
	if(!IsPlaying()) return true;

	PausePlayback();
	SetElapsedTime(0);
	GenerateStopNotification();

	m_pSndFile->ResetPlayPos();
	m_pSndFile->ResetChannels();
	UnsetPlaybackSoundFile();

	StopPlayback();

	return true;
}


bool CMainFrame::StopSoundFile(CSoundFile *pSndFile)
{
	MPT_ASSERT_ALWAYS(!theApp.GetGlobalMutexRef().IsLockedByCurrentThread());
	if(!IsValidSoundFile(pSndFile)) return false;
	if(pSndFile != m_pSndFile) return false;
	if(!IsPlaying()) return true;

	PausePlayback();
	GenerateStopNotification();

	UnsetPlaybackSoundFile();

	StopPlayback();

	return true;
}


bool CMainFrame::PlaySoundFile(CSoundFile *pSndFile)
{
	MPT_ASSERT_ALWAYS(!theApp.GetGlobalMutexRef().IsLockedByCurrentThread());
	if(!IsValidSoundFile(pSndFile)) return false;

	PausePlayback();
	GenerateStopNotification();

	if(m_pSndFile != pSndFile)
	{
		UnsetPlaybackSoundFile();
	}

	if(!PreparePlayback())
	{
		UnsetPlaybackSoundFile();
		return false;
	}

	UpdateAudioParameters(*pSndFile);

	SetPlaybackSoundFile(pSndFile);

	m_pSndFile->InitPlayer(true);

	if(!StartPlayback())
	{
		UnsetPlaybackSoundFile();
		return false;
	}

	return true;
}


bool CMainFrame::PlayDLSInstrument(const CDLSBank &bank, UINT instr, UINT region, ModCommand::NOTE note, int volume)
{
	bool ok = false;
	BeginWaitCursor();
	{
		CriticalSection cs;
		InitPreview();
		if(bank.ExtractInstrument(m_WaveFile, 1, instr, region))
		{
			PreparePreview(note, volume);
			ok = true;
		}
	}
	EndWaitCursor();
	if(!ok)
	{
		PausePlayback();
		UnsetPlaybackSoundFile();
		StopPlayback();
		return false;
	}
	if(IsPlaying() && (m_pSndFile == &m_WaveFile))
	{
		return true;
	}
	return PlaySoundFile(&m_WaveFile);
}


bool CMainFrame::PlaySoundFile(const mpt::PathString &filename, ModCommand::NOTE note, int volume)
{
	bool ok = false;
	BeginWaitCursor();
	{
		CriticalSection cs;
		static mpt::PathString prevFile;
		// Did we already load this file for previewing? Don't load it again if the preview is still running.
		ok = (prevFile == filename && m_pSndFile == &m_WaveFile);

		if(!ok && !filename.empty())
		{
			InputFile f(filename, TrackerSettings::Instance().MiscCacheCompleteFileBeforeLoading);
			if(f.IsValid())
			{
				FileReader file = GetFileReader(f);
				if(file.IsValid())
				{
					InitPreview();
					m_WaveFile.m_SongFlags.set(SONG_PAUSED);
					// Avoid hanging audio while reading file - we have removed all sample and instrument references before,
					// so it's safe to replace the sample / instrument now.
					cs.Leave();
					ok = m_WaveFile.ReadInstrumentFromFile(1, file, TrackerSettings::Instance().m_MayNormalizeSamplesOnLoad);
					cs.Enter();
					if(!ok)
					{
						// Try reading as sample if reading as instrument fails
						ok = m_WaveFile.ReadSampleFromFile(1, file, TrackerSettings::Instance().m_MayNormalizeSamplesOnLoad);
						m_WaveFile.AllocateInstrument(1, 1);
					}
				}
			}
		}
		if(ok)
		{
			// Write notes to pattern. Also done if we have previously loaded this file, since we might be previewing another note now.
			PreparePreview(note, volume);
			prevFile = filename;
		}
	}
	EndWaitCursor();
	if(!ok)
	{
		PausePlayback();
		UnsetPlaybackSoundFile();
		StopPlayback();
		return false;
	}
	if(IsPlaying() && (m_pSndFile == &m_WaveFile))
	{
		return true;
	}
	return PlaySoundFile(&m_WaveFile);
}


bool CMainFrame::PlaySoundFile(CSoundFile &sndFile, INSTRUMENTINDEX nInstrument, SAMPLEINDEX nSample, ModCommand::NOTE note, int volume)
{
	bool ok = false;
	BeginWaitCursor();
	{
		CriticalSection cs;
		InitPreview();
		m_WaveFile.m_nType = sndFile.GetType();
		if ((nInstrument) && (nInstrument <= sndFile.GetNumInstruments()))
		{
			m_WaveFile.m_nInstruments = 1;
			m_WaveFile.m_nSamples = 32;
		} else
		{
			m_WaveFile.m_nInstruments = 0;
			m_WaveFile.m_nSamples = 1;
		}
		if (nInstrument != INSTRUMENTINDEX_INVALID && nInstrument <= sndFile.GetNumInstruments())
		{
			m_WaveFile.ReadInstrumentFromSong(1, sndFile, nInstrument);
		} else if(nSample != SAMPLEINDEX_INVALID && nSample <= sndFile.GetNumSamples())
		{
			m_WaveFile.ReadSampleFromSong(1, sndFile, nSample);
		}
		PreparePreview(note, volume);
		ok = true;
	}
	EndWaitCursor();
	if(!ok)
	{
		PausePlayback();
		UnsetPlaybackSoundFile();
		StopPlayback();
		return false;
	}
	if(IsPlaying() && (m_pSndFile == &m_WaveFile))
	{
		return true;
	}
	return PlaySoundFile(&m_WaveFile);
}


void CMainFrame::InitPreview()
{
	m_WaveFile.Destroy();
	m_WaveFile.Create(FileReader());
	m_WaveFile.m_nDefaultTempo.Set(125);
	m_WaveFile.m_nDefaultSpeed = 6;
	m_WaveFile.m_nType = MOD_TYPE_MPT;
	m_WaveFile.m_nChannels = 2;
	m_WaveFile.m_nInstruments = 1;
	m_WaveFile.m_nTempoMode = TempoMode::Classic;
	m_WaveFile.Order().assign(1, 0);
	m_WaveFile.Patterns.Insert(0, 2);
	m_WaveFile.m_SongFlags = SONG_LINEARSLIDES;
}


void CMainFrame::PreparePreview(ModCommand::NOTE note, int volume)
{
	m_WaveFile.m_SongFlags.reset(SONG_PAUSED);
	m_WaveFile.SetRepeatCount(-1);
	m_WaveFile.ResetPlayPos();

	const CModDoc *activeDoc = GetActiveDoc();
	if(activeDoc != nullptr && (TrackerSettings::Instance().m_dwPatternSetup & PATTERN_NOEXTRALOUD))
	{
		m_WaveFile.SetMixLevels(activeDoc->GetSoundFile().GetMixLevels());
		m_WaveFile.m_nSamplePreAmp = activeDoc->GetSoundFile().m_nSamplePreAmp;
	} else
	{
		// Preview at 0dB
		m_WaveFile.SetMixLevels(MixLevels::v1_17RC3);
		m_WaveFile.m_nSamplePreAmp = static_cast<uint32>(m_WaveFile.GetPlayConfig().getNormalSamplePreAmp());
	}

	// Avoid global volume ramping when trying samples in the treeview.
	m_WaveFile.m_nDefaultGlobalVolume = m_WaveFile.m_PlayState.m_nGlobalVolume = (volume > 0) ? volume : MAX_GLOBAL_VOLUME;

	if(m_WaveFile.Patterns.IsValidPat(0))
	{
		auto m = m_WaveFile.Patterns[0].GetRow(0);
		if(m_WaveFile.GetNumSamples() > 0)
		{
			m[0].note = note;
			m[0].instr = 1;
		}
		// Infinite loop on second row
		m[1 * 2].command = CMD_POSITIONJUMP;
		m[1 * 2 + 1].command = CMD_PATTERNBREAK;
		m[1 * 2 + 1].param = 1;
	}
	m_WaveFile.InitPlayer(true);
}


HWND CMainFrame::GetFollowSong() const
{
	return GetModPlaying() ? GetModPlaying()->GetFollowWnd() : NULL;
}


void CMainFrame::IdleHandlerSounddevice()
{
	MPT_TRACE_SCOPE();
	if(gpSoundDevice)
	{
		const FlagSet<SoundDevice::RequestFlags> requestFlags = gpSoundDevice->GetRequestFlags();
		if(requestFlags[SoundDevice::RequestFlagClose])
		{
			StopPlayback();
			audioCloseDevice();
		} else if(requestFlags[SoundDevice::RequestFlagReset])
		{
			ResetSoundCard();
		} else if(requestFlags[SoundDevice::RequestFlagRestart])
		{
			RestartPlayback();
		} else
		{
			gpSoundDevice->OnIdle();
		}
	}
}


BOOL CMainFrame::ResetSoundCard()
{
	MPT_TRACE_SCOPE();
	return CMainFrame::SetupSoundCard(TrackerSettings::Instance().GetSoundDeviceSettings(TrackerSettings::Instance().GetSoundDeviceIdentifier()), TrackerSettings::Instance().GetSoundDeviceIdentifier(), TrackerSettings::Instance().m_SoundSettingsStopMode, true);
}


BOOL CMainFrame::SetupSoundCard(SoundDevice::Settings deviceSettings, SoundDevice::Identifier deviceIdentifier, SoundDeviceStopMode stoppedMode, bool forceReset)
{
	MPT_TRACE_SCOPE();
	if(forceReset
		|| (TrackerSettings::Instance().GetSoundDeviceIdentifier() != deviceIdentifier)
		|| (TrackerSettings::Instance().GetSoundDeviceSettings(deviceIdentifier) != deviceSettings)
		|| (TrackerSettings::Instance().m_SoundSettingsStopMode != stoppedMode)
		)
	{
		CModDoc *pActiveMod = nullptr;
		if(IsPlaying())
		{
			if ((m_pSndFile) && (!m_pSndFile->IsPaused())) pActiveMod = GetModPlaying();
			PauseMod();
		}
		if(gpSoundDevice)
		{
			gpSoundDevice->Close();
		}
		TrackerSettings::Instance().m_SoundSettingsStopMode = stoppedMode;
		switch(stoppedMode)
		{
			case SoundDeviceStopModeClosed:
				deviceSettings.KeepDeviceRunning = true;
				break;
			case SoundDeviceStopModeStopped:
				deviceSettings.KeepDeviceRunning = false;
				break;
			case SoundDeviceStopModePlaying:
				deviceSettings.KeepDeviceRunning = true;
				break;
		}
		TrackerSettings::Instance().SetSoundDeviceIdentifier(deviceIdentifier);
		TrackerSettings::Instance().SetSoundDeviceSettings(deviceIdentifier, deviceSettings);
		TrackerSettings::Instance().MixerOutputChannels = deviceSettings.Channels;
		TrackerSettings::Instance().MixerNumInputChannels = deviceSettings.InputChannels;
		TrackerSettings::Instance().MixerSamplerate = deviceSettings.Samplerate;
		if(pActiveMod)
		{
			PlayMod(pActiveMod);
		}
		UpdateWindow();
	} else
	{
		// No need to restart playback
		CriticalSection cs;
		if(GetSoundFilePlaying()) UpdateAudioParameters(*GetSoundFilePlaying(), FALSE);
	}
	return TRUE;
}


BOOL CMainFrame::SetupPlayer()
{
	CriticalSection cs;
	if(GetSoundFilePlaying()) UpdateAudioParameters(*GetSoundFilePlaying(), FALSE);
	return TRUE;
}


BOOL CMainFrame::SetupMiscOptions()
{
	if (TrackerSettings::Instance().m_dwPatternSetup & PATTERN_MUTECHNMODE)
		TrackerSettings::Instance().MixerFlags |= SNDMIX_MUTECHNMODE;
	else
		TrackerSettings::Instance().MixerFlags &= ~SNDMIX_MUTECHNMODE;
	{
		CriticalSection cs;
		if(GetSoundFilePlaying()) UpdateAudioParameters(*GetSoundFilePlaying());
	}

	m_wndToolBar.EnableFlatButtons(TrackerSettings::Instance().m_dwPatternSetup & PATTERN_FLATBUTTONS);

	UpdateTree(nullptr, UpdateHint().MPTOptions());
	UpdateAllViews(UpdateHint().MPTOptions());
	return true;
}


void CMainFrame::SetupMidi(DWORD d, UINT n)
{
	bool deviceChanged = (TrackerSettings::Instance().m_nMidiDevice != n);
	TrackerSettings::Instance().m_dwMidiSetup = d;
	TrackerSettings::Instance().SetMIDIDevice(n);
	if(deviceChanged && shMidiIn)
	{
		// Device has changed, close the old one.
		midiCloseDevice();
		midiOpenDevice();
	}
}


void CMainFrame::UpdateAllViews(UpdateHint hint, CObject *pHint)
{
	CModDocTemplate *pDocTmpl = theApp.GetModDocTemplate();
	if (pDocTmpl)
	{
		for(auto &doc : *pDocTmpl)
		{
			doc->UpdateAllViews(nullptr, hint, pHint);
		}
	}
}


void CMainFrame::SetUserText(LPCTSTR lpszText)
{
	if (lpszText[0] | m_szUserText[0])
	{
		_tcscpy(m_szUserText, lpszText);
		OnUpdateUser(nullptr);
	}
}


void CMainFrame::SetInfoText(LPCTSTR lpszText)
{
	if (lpszText[0] | m_szInfoText[0])
	{
		_tcscpy(m_szInfoText, lpszText);
		OnUpdateInfo(nullptr);
	}
}


void CMainFrame::SetXInfoText(LPCTSTR lpszText)
{
	if (lpszText[0] | m_szXInfoText[0])
	{
		_tcscpy(m_szXInfoText, lpszText);
		OnUpdateInfo(nullptr);
	}
}


void CMainFrame::SetHelpText(LPCTSTR lpszText)
{
	m_wndStatusBar.SetPaneText(0, lpszText);
}


void CMainFrame::OnDocumentCreated(CModDoc *pModDoc)
{
	m_wndTree.OnDocumentCreated(pModDoc);
	UpdateMRUList();
}


void CMainFrame::OnDocumentClosed(CModDoc *pModDoc)
{
	if (pModDoc == GetModPlaying()) PauseMod();

	m_wndTree.OnDocumentClosed(pModDoc);
}


void CMainFrame::UpdateTree(CModDoc *pModDoc, UpdateHint hint, CObject *pHint)
{
	m_wndTree.OnUpdate(pModDoc, hint, pHint);
}


void CMainFrame::RefreshDlsBanks()
{
	m_wndTree.RefreshDlsBanks();
}


/////////////////////////////////////////////////////////////////////////////
// CMainFrame message handlers


void CMainFrame::OnViewOptions()
{
	if (m_bOptionsLocked)
		return;

	CPropertySheet dlg(_T("OpenMPT Setup"), this, m_nLastOptionsPage);
	COptionsGeneral general;
	COptionsSoundcard sounddlg(TrackerSettings::Instance().m_SoundDeviceIdentifier);
	COptionsSampleEditor smpeditor;
	COptionsKeyboard keyboard;
	COptionsColors colors;
	COptionsMixer mixerdlg;
	CMidiSetupDlg mididlg(TrackerSettings::Instance().m_dwMidiSetup, TrackerSettings::Instance().GetCurrentMIDIDevice());
	PathConfigDlg pathsdlg;
#if defined(MPT_ENABLE_UPDATE)
	CUpdateSetupDlg updatedlg;
#endif // MPT_ENABLE_UPDATE
	COptionsAdvanced advanced;
	COptionsWine winedlg;
	dlg.AddPage(&general);
	dlg.AddPage(&sounddlg);
	dlg.AddPage(&mixerdlg);
#if !defined(NO_REVERB) || !defined(NO_DSP) || !defined(NO_EQ) || !defined(NO_AGC)
	COptionsPlayer dspdlg;
	dlg.AddPage(&dspdlg);
#endif
	dlg.AddPage(&smpeditor);
	dlg.AddPage(&keyboard);
	dlg.AddPage(&colors);
	dlg.AddPage(&mididlg);
	dlg.AddPage(&pathsdlg);
#if defined(MPT_ENABLE_UPDATE)
	dlg.AddPage(&updatedlg);
#endif // MPT_ENABLE_UPDATE
	dlg.AddPage(&advanced);
	if(mpt::OS::Windows::IsWine()) dlg.AddPage(&winedlg);
	m_bOptionsLocked = true;
	m_SoundCardOptionsDialog = &sounddlg;
#if defined(MPT_ENABLE_UPDATE)
	m_UpdateOptionsDialog = &updatedlg;
#endif // MPT_ENABLE_UPDATE
	dlg.DoModal();
	m_SoundCardOptionsDialog = nullptr;
#if defined(MPT_ENABLE_UPDATE)
	m_UpdateOptionsDialog = nullptr;
#endif // MPT_ENABLE_UPDATE
	m_bOptionsLocked = false;
	m_wndTree.OnOptionsChanged();
}


void CMainFrame::OnPluginManager()
{
#ifndef NO_PLUGINS
	PLUGINDEX nPlugslot = PLUGINDEX_INVALID;
	CModDoc* pModDoc = GetActiveDoc();

	if (pModDoc)
	{
		CSoundFile &sndFile = pModDoc->GetSoundFile();
		//Find empty plugin slot
		for (PLUGINDEX nPlug = 0; nPlug < MAX_MIXPLUGINS; nPlug++)
		{
			if (sndFile.m_MixPlugins[nPlug].pMixPlugin == nullptr)
			{
				nPlugslot = nPlug;
				break;
			}
		}
	}

	CSelectPluginDlg dlg(GetActiveDoc(), nPlugslot, this);
	if(dlg.DoModal() == IDOK && pModDoc)
	{
		pModDoc->SetModified();
		//Refresh views
		pModDoc->UpdateAllViews(nullptr, PluginHint().Info().Names().ModType());
		//Refresh Controls
		CChildFrame *pActiveChild = (CChildFrame *)MDIGetActive();
		pActiveChild->ForceRefresh();
	}
#endif // NO_PLUGINS
}


void CMainFrame::OnClipboardManager()
{
	PatternClipboardDialog::Show();
}


void CMainFrame::OnAddDlsBank()
{
	FileDialog dlg = OpenFileDialog()
		.AllowMultiSelect()
		.ExtensionFilter("All Sound Banks|*.dls;*.sbk;*.sf2;*.sf3;*.sf4;*.mss|"
			"Downloadable Sounds Banks (*.dls)|*.dls;*.mss|"
			"SoundFont 2.0 Banks (*.sf2)|*.sbk;*.sf2;*.sf3;*.sf4|"
			"All Files (*.*)|*.*||");
	if(!dlg.Show()) return;

	BeginWaitCursor();
	bool ok = true;
	for(const auto &file : dlg.GetFilenames())
	{
		ok &= CTrackApp::AddDLSBank(file);
	}
	if(!ok)
	{
		Reporting::Error("At least one selected file was not a valid sound bank.");
	}
	m_wndTree.RefreshDlsBanks();
	EndWaitCursor();
}


void CMainFrame::OnImportMidiLib()
{
	FileDialog dlg = OpenFileDialog()
		.ExtensionFilter("Text and INI files (*.txt,*.ini)|*.txt;*.ini;*.dls;*.sf2;*.sf3;*.sf4;*.sbk|"
			"Downloadable Sound Banks (*.dls)|*.dls;*.mss|"
			"SoundFont 2.0 banks (*.sf2)|*.sbk;*.sf2;*.sf3;*.sf4|"
			"Gravis UltraSound (ultrasnd.ini)|ultrasnd.ini|"
			"All Files (*.*)|*.*||");
	if(!dlg.Show()) return;

	BeginWaitCursor();
	CTrackApp::ImportMidiConfig(dlg.GetFirstFile());
	m_wndTree.RefreshMidiLibrary();
	EndWaitCursor();
}


void CMainFrame::OnTimer(UINT_PTR timerID)
{
	switch(timerID)
	{
		case TIMERID_GUI:
			OnTimerGUI();
			break;
		case TIMERID_NOTIFY:
			OnTimerNotify();
			break;
	}
}


void CMainFrame::OnTimerGUI()
{
	IdleHandlerSounddevice();

	// Display Time in status bar
	CSoundFile::samplecount_t time = 0;
	if(m_pSndFile != nullptr && m_pSndFile->GetSampleRate() != 0)
	{
		time = m_pSndFile->GetTotalSampleCount() / m_pSndFile->GetSampleRate();
		if(time != m_dwTimeSec)
		{
			m_dwTimeSec = time;
			m_nAvgMixChn = m_nMixChn;
			OnUpdateTime(NULL);
		}
	}

	// Idle Time Check
	DWORD curTime = timeGetTime();

	if(m_AutoSaver.IsEnabled())
	{
		bool success = m_AutoSaver.DoSave(curTime);
		if (!success)		// autosave failure; bring up options.
		{
			CMainFrame::m_nLastOptionsPage = OPTIONS_PAGE_PATHS;
			OnViewOptions();
		}
	}

	if(m_SoundCardOptionsDialog)
	{
		m_SoundCardOptionsDialog->UpdateStatistics();
	}

#ifdef USE_PROFILER
	{
		Profiler::Update();

		CWnd * cwnd = CWnd::FromHandle(this->m_hWndMDIClient);
		CClientDC dc(cwnd);

		int height = 16;
		int width = 256;

		std::vector<std::string> catnames = Profiler::GetCategoryNames();
		std::vector<double> cats = Profiler::DumpCategories();

		for(int i=0; i<Profiler::CategoriesCount; i++)
		{
			dc.FillSolidRect(0, i * height, (int)(width * cats[i]), height, RGB(255,0,0));
			dc.FillSolidRect((int)(width * cats[i]), i * height, width - (int)(width * cats[i]), height, RGB(192,192,192));
			RECT rect;
			cwnd->GetClientRect(&rect);
			rect.left += width;
			rect.top += i * height;
			auto s = mpt::ToCString(mpt::Charset::ASCII, mpt::afmt::right(6, mpt::afmt::fix(cats[i] * 100.0, 3)) + "% " + catnames[i]);
			dc.DrawText(s, s.GetLength(), &rect, DT_LEFT);
		}

		RECT rect;
		cwnd->GetClientRect(&rect);
		rect.top += Profiler::CategoriesCount * height;
		auto s = mpt::ToCString(mpt::Charset::ASCII, Profiler::DumpProfiles());
		dc.DrawText(s, s.GetLength(), &rect, DT_LEFT);

		cwnd->Detach();
	}
#endif

}


CModDoc *CMainFrame::GetActiveDoc() const
{
	CMDIChildWnd *pMDIActive = MDIGetActive();
	if (pMDIActive)
	{
		return static_cast<CModDoc *>(pMDIActive->GetActiveDocument());
	}
	return nullptr;
}


CView *CMainFrame::GetActiveView() const
{
	CMDIChildWnd *pMDIActive = MDIGetActive();
	if (pMDIActive)
	{
		return pMDIActive->GetActiveView();
	}

	return nullptr;
}


void CMainFrame::SwitchToActiveView()
{
	CWnd *wnd = GetActiveView();
	if (wnd)
	{
		// Hack: If the upper view is active, we only get the "container" (the dialog view with the tabs), not the view itself.
		if(!strcmp(wnd->GetRuntimeClass()->m_lpszClassName, "CModControlView"))
		{
			wnd = static_cast<CModControlView *>(wnd)->GetCurrentControlDlg();
		}
		wnd->SetFocus();
	}
}


void CMainFrame::OnUpdateTime(CCmdUI *)
{
	TCHAR s[64];
	wsprintf(s, _T("%u:%02u:%02u"),
		m_dwTimeSec / 3600, (m_dwTimeSec / 60) % 60, m_dwTimeSec % 60);

	if(m_pSndFile != nullptr && m_pSndFile != &m_WaveFile && !m_pSndFile->IsPaused())
	{
		PATTERNINDEX nPat = m_pSndFile->m_PlayState.m_nPattern;
		if(m_pSndFile->Patterns.IsValidIndex(nPat))
		{
			if(nPat < 10) _tcscat(s, _T(" "));
			if(nPat < 100) _tcscat(s, _T(" "));
			wsprintf(s + _tcslen(s), _T(" [%d]"), nPat);
		}
		wsprintf(s + _tcslen(s), _T(" %dch"), m_nAvgMixChn);
	}
	m_wndStatusBar.SetPaneText(m_wndStatusBar.CommandToIndex(ID_INDICATOR_TIME), s, TRUE);
}


void CMainFrame::OnUpdateUser(CCmdUI *)
{
	m_wndStatusBar.SetPaneText(m_wndStatusBar.CommandToIndex(ID_INDICATOR_USER), m_szUserText, TRUE);
}


void CMainFrame::OnUpdateInfo(CCmdUI *)
{
	m_wndStatusBar.SetPaneText(m_wndStatusBar.CommandToIndex(ID_INDICATOR_INFO), m_szInfoText, TRUE);
}


void CMainFrame::OnUpdateXInfo(CCmdUI *)
{
	m_wndStatusBar.SetPaneText(m_wndStatusBar.CommandToIndex(ID_INDICATOR_XINFO), m_szXInfoText, TRUE);
}

void CMainFrame::OnPlayerPause()
{
	if (GetModPlaying())
	{
		GetModPlaying()->OnPlayerPause();
	} else
	{
		PauseMod();
	}
}


void CMainFrame::OpenMenuItemFile(const UINT nId, const bool isTemplateFile)
{
	const UINT nIdBegin = (isTemplateFile) ? ID_FILE_OPENTEMPLATE : ID_EXAMPLE_MODULES;
	const std::vector<mpt::PathString> &vecFilePaths = (isTemplateFile) ? m_TemplateModulePaths : m_ExampleModulePaths;

	const UINT nIndex = nId - nIdBegin;
	if (nIndex < vecFilePaths.size())
	{
		const mpt::PathString& sPath = vecFilePaths[nIndex];
		const bool bExists = sPath.IsFile();
		CDocument *pDoc = nullptr;
		if(bExists)
		{
			pDoc = theApp.GetModDocTemplate()->OpenTemplateFile(sPath, !isTemplateFile);
		}
		if(!pDoc)
		{
			Reporting::Notification(_T("The file '") + sPath.ToCString() + _T("' ") + (bExists ? _T("exists but can't be read.") : _T("does not exist.")));
		}
	} else
	{
		MPT_ASSERT(nId == UINT(isTemplateFile ? ID_FILE_OPENTEMPLATE_LASTINRANGE : ID_EXAMPLE_MODULES_LASTINRANGE));
		FileDialog::PathList files;
		theApp.OpenModulesDialog(files, isTemplateFile ? theApp.GetConfigPath() + P_("TemplateModules") : theApp.GetInstallPath() + P_("ExampleSongs"));
		for(const auto &file : files)
		{
			theApp.OpenDocumentFile(file.ToCString());
		}
	}
}


void CMainFrame::OnOpenTemplateModule(UINT nId)
{
	OpenMenuItemFile(nId, true/*open template menu file*/);
}


void CMainFrame::OnExampleSong(UINT nId)
{
	OpenMenuItemFile(nId, false/*open example menu file*/);
}


void CMainFrame::OnOpenMRUItem(UINT nId)
{
	theApp.OpenDocumentFile(TrackerSettings::Instance().mruFiles[nId - ID_MRU_LIST_FIRST].ToCString());
}


void CMainFrame::OnUpdateMRUItem(CCmdUI *cmd)
{
	cmd->Enable(!TrackerSettings::Instance().mruFiles.empty());
}


LRESULT CMainFrame::OnInvalidatePatterns(WPARAM, LPARAM)
{
	UpdateAllViews(UpdateHint().MPTOptions());
	return TRUE;
}


LRESULT CMainFrame::OnUpdatePosition(WPARAM, LPARAM lParam)
{
	OPENMPT_PROFILE_FUNCTION(Profiler::GUI);
	m_VUMeterOutput.SetDecaySpeedDecibelPerSecond(TrackerSettings::Instance().VuMeterDecaySpeedDecibelPerSecond); // update in notification update in order to avoid querying the settings framework from inside audio thread
	m_VUMeterInput.SetDecaySpeedDecibelPerSecond(TrackerSettings::Instance().VuMeterDecaySpeedDecibelPerSecond); // update in notification update in order to avoid querying the settings framework from inside audio thread
	Notification *pnotify = (Notification *)lParam;
	if (pnotify)
	{
		if(pnotify->type[Notification::EOS])
		{
			PostMessage(WM_COMMAND, ID_PLAYER_STOP);
		}
		//Log("OnUpdatePosition: row=%d time=%lu\n", pnotify->nRow, pnotify->TimestampSamples);
		if(CModDoc *modDoc = GetModPlaying(); modDoc != nullptr)
		{
			m_wndTree.UpdatePlayPos(modDoc, pnotify);
			if (GetFollowSong())
				::SendMessage(GetFollowSong(), WM_MOD_UPDATEPOSITION, 0, lParam);
			if(m_pSndFile->m_pluginDryWetRatioChanged.any())
			{
				for(PLUGINDEX i = 0; i < MAX_MIXPLUGINS; i++)
				{
					if(m_pSndFile->m_pluginDryWetRatioChanged[i])
						modDoc->PostMessageToAllViews(WM_MOD_PLUGINDRYWETRATIOCHANGED, i);
				}
				m_pSndFile->m_pluginDryWetRatioChanged.reset();
			}
		}
		m_nMixChn = pnotify->mixedChannels;

		bool duplicateMono = false;
		if(pnotify->masterVUinChannels == 1 && pnotify->masterVUoutChannels > 1)
		{
			duplicateMono = true;
		} else if(pnotify->masterVUoutChannels == 1 && pnotify->masterVUinChannels > 1)
		{
			duplicateMono = true;
		}
		uint8 countChan = 0;
		uint32 vu[VUMeter::maxChannels * 2];
		MemsetZero(vu);
		std::copy(pnotify->masterVUin.begin(), pnotify->masterVUin.begin() + pnotify->masterVUinChannels, vu + countChan);

		countChan += pnotify->masterVUinChannels;
		if(pnotify->masterVUinChannels == 1 && duplicateMono)
		{
			std::copy(pnotify->masterVUin.begin(), pnotify->masterVUin.begin() + 1, vu + countChan);
			countChan += 1;
		}

		std::copy(pnotify->masterVUout.begin(), pnotify->masterVUout.begin() + pnotify->masterVUoutChannels, vu + countChan);
		countChan += pnotify->masterVUoutChannels;
		if(pnotify->masterVUoutChannels == 1 && duplicateMono)
		{
			std::copy(pnotify->masterVUout.begin(), pnotify->masterVUout.begin() + 1, vu + countChan);
			countChan += 1;
		}

		m_wndToolBar.m_VuMeter.SetVuMeter(countChan, vu, pnotify->type[Notification::Stop]);

		m_wndToolBar.SetCurrentSong(m_pSndFile);
	}
	return 0;
}


LRESULT CMainFrame::OnUpdateViews(WPARAM modDoc, LPARAM hint)
{
	CModDoc *doc = reinterpret_cast<CModDoc *>(modDoc);
	CModDocTemplate *pDocTmpl = theApp.GetModDocTemplate();
	if(pDocTmpl && pDocTmpl->DocumentExists(doc))
	{
		// Since this message is potentially posted, we first need to verify if the document still exists
		doc->UpdateAllViews(nullptr, UpdateHint::FromLPARAM(hint));
	}
	return 0;
}


LRESULT CMainFrame::OnSetModified(WPARAM modDoc, LPARAM)
{
	CModDoc *doc = reinterpret_cast<CModDoc *>(modDoc);
	CModDocTemplate *pDocTmpl = theApp.GetModDocTemplate();
	if(pDocTmpl && pDocTmpl->DocumentExists(doc))
	{
		// Since this message is potentially posted, we first need to verify if the document still exists
		doc->UpdateFrameCounts();
	}
	return 0;
}


void CMainFrame::OnPanic()
{
	// "Panic button." At the moment, it just resets all VSTi and sample notes.
	if(GetModPlaying())
		GetModPlaying()->OnPanic();
}


void CMainFrame::OnPrevOctave()
{
	UINT n = GetBaseOctave();
	if (n > MIN_BASEOCTAVE) m_wndToolBar.SetBaseOctave(n-1);
}


void CMainFrame::OnNextOctave()
{
	UINT n = GetBaseOctave();
	if (n < MAX_BASEOCTAVE) m_wndToolBar.SetBaseOctave(n+1);
}


void CMainFrame::OnReportBug()
{
	CTrackApp::OpenURL(Build::GetURL(Build::Url::Bugtracker));
}


BOOL CMainFrame::OnInternetLink(UINT nID)
{
	mpt::ustring url;
	switch(nID)
	{
	case ID_NETLINK_MODPLUG:	url = Build::GetURL(Build::Url::Website); break;
	case ID_NETLINK_TOP_PICKS:	url = Build::GetURL(Build::Url::TopPicks); break;
	}
	if(!url.empty())
	{
		return CTrackApp::OpenURL(url) ? TRUE : FALSE;
	}
	return FALSE;
}


void CMainFrame::OnRButtonDown(UINT, CPoint pt)
{
	CMenu Menu;
	ClientToScreen(&pt);
	if (Menu.LoadMenu(IDR_TOOLBARS))
	{
		CMenu *pSubMenu = Menu.GetSubMenu(0);
		if (pSubMenu != nullptr) pSubMenu->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, pt.x, pt.y, this);
	}
}


LRESULT CMainFrame::OnCustomKeyMsg(WPARAM wParam, LPARAM lParam)
{
	switch(wParam)
	{
		case kcViewTree: OnBarCheck(IDD_TREEVIEW); break;
		case kcViewOptions: OnViewOptions(); break;
		case kcViewMain: OnBarCheck(59392 /* MAINVIEW */); break;
	 	case kcFileImportMidiLib: OnImportMidiLib(); break;
		case kcFileAddSoundBank: OnAddDlsBank(); break;
		case kcPauseSong:	OnPlayerPause(); break;
		case kcPrevOctave:	OnPrevOctave(); break;
		case kcNextOctave:	OnNextOctave(); break;
		case kcFileNew:		theApp.OnFileNew(); break;
		case kcFileOpen:	theApp.OnFileOpen(); break;
		case kcMidiRecord:	OnMidiRecord(); break;
		case kcHelp: 		OnHelp(); break;
		case kcViewAddPlugin: OnPluginManager(); break;
		case kcNextDocument:	MDINext(); break;
		case kcPrevDocument:	MDIPrev(); break;
		case kcFileCloseAll:	theApp.OnFileCloseAll(); break;


		//D'oh!! moddoc isn't a CWnd so we have to handle its messages and pass them on.

		case kcFileSaveAs:
		case kcFileSaveCopy:
		case kcFileSaveAsWave:
		case kcFileSaveMidi:
		case kcFileSaveOPL:
		case kcFileExportCompat:
		case kcFileClose:
		case kcFileSave:
		case kcViewGeneral:
		case kcViewPattern:
		case kcViewSamples:
		case kcViewInstruments:
		case kcViewComments:
		case kcViewGraph: //rewbs.graph
		case kcViewSongProperties:
		case kcViewTempoSwing:
		case kcViewMIDImapping:
		case kcViewEditHistory:
		case kcViewChannelManager:
		case kcPlayPatternFromCursor:
		case kcPlayPatternFromStart:
		case kcPlaySongFromCursor:
		case kcPlaySongFromStart:
		case kcPlayPauseSong:
		case kcPlaySongFromPattern:
		case kcStopSong:
		case kcToggleLoopSong:
		case kcPanic:
		case kcEstimateSongLength:
		case kcApproxRealBPM:
		case kcTempoIncrease:
		case kcTempoDecrease:
		case kcTempoIncreaseFine:
		case kcTempoDecreaseFine:
		case kcSpeedIncrease:
		case kcSpeedDecrease:
		case kcViewToggle:
			{
				CModDoc *modDoc = GetActiveDoc();
				if (modDoc)
					return GetActiveDoc()->OnCustomKeyMsg(wParam, lParam);
				else if(wParam == kcPlayPauseSong || wParam == kcStopSong)
					StopPreview();
				break;
			}

		case kcSwitchToInstrLibrary:
			if(m_bModTreeHasFocus)
				SwitchToActiveView();
			else
				m_wndTree.SetFocus();
			break;

		//if handled neither by MainFrame nor by ModDoc...
		default:
			//If the treeview has focus, post command to the tree view
			if (m_bModTreeHasFocus)
				return m_wndTree.SendMessageToModTree(WM_MOD_KEYCOMMAND, wParam, lParam);
			if (m_pNoteMapHasFocus)
				return m_pNoteMapHasFocus->SendMessage(WM_MOD_KEYCOMMAND, wParam, lParam);
			if (m_pOrderlistHasFocus)
				return m_pOrderlistHasFocus->SendMessage(WM_MOD_KEYCOMMAND, wParam, lParam);

			//Else send it to the active view
			CMDIChildWnd *pMDIActive = MDIGetActive();
			CWnd *wnd = nullptr;
			if(pMDIActive)
			{
				wnd = pMDIActive->GetActiveView();
				// Hack: If the upper view is active, we only get the "container" (the dialog view with the tabs), not the view itself.
				if(!strcmp(wnd->GetRuntimeClass()->m_lpszClassName, "CModControlView"))
				{
					wnd = static_cast<CModControlView *>(wnd)->GetCurrentControlDlg();
				}
			}
			if(wnd)
				return wnd->SendMessage(WM_MOD_KEYCOMMAND, wParam, lParam);
			return kcNull;
	}

	return wParam;
}


void CMainFrame::OnInitMenu(CMenu* pMenu)
{
	m_InputHandler->SetModifierMask(ModNone);
	CMDIFrameWnd::OnInitMenu(pMenu);

}


BOOL CMainFrame::InitRenderer(CSoundFile* pSndFile)
{
	CriticalSection cs;
	pSndFile->m_bIsRendering = true;
	pSndFile->SuspendPlugins();
	pSndFile->ResumePlugins();
	return true;
}


BOOL CMainFrame::StopRenderer(CSoundFile* pSndFile)
{
	CriticalSection cs;
	pSndFile->SuspendPlugins();
	pSndFile->m_bIsRendering = false;
	return true;
}


// We have switched focus to a new module - might need to update effect keys to reflect module type
bool CMainFrame::UpdateEffectKeys(const CModDoc *modDoc)
{
	if(modDoc != nullptr)
	{
		return m_InputHandler->SetEffectLetters(modDoc->GetSoundFile().GetModSpecifications());
	}
	return false;
}


void CMainFrame::OnKillFocus(CWnd* pNewWnd)
{
	CMDIFrameWnd::OnKillFocus(pNewWnd);

	//rewbs: ensure modifiers are reset when we leave the window (e.g. alt-tab)
	m_InputHandler->SetModifierMask(ModNone);
}


void CMainFrame::OnShowWindow(BOOL bShow, UINT /*nStatus*/)
{
	static bool firstShow = true;
	if (bShow && !IsWindowVisible() && firstShow)
	{
		firstShow = false;
		WINDOWPLACEMENT wpl;
		GetWindowPlacement(&wpl);
		wpl = theApp.GetSettings().Read<WINDOWPLACEMENT>(U_("Display"), U_("WindowPlacement"), wpl);
		SetWindowPlacement(&wpl);
	}
}


void CMainFrame::OnInternetUpdate()
{
#if defined(MPT_ENABLE_UPDATE)
	CUpdateCheck::DoManualUpdateCheck();
#endif // MPT_ENABLE_UPDATE
}


void CMainFrame::OnUpdateAvailable()
{
#if defined(MPT_ENABLE_UPDATE)
	if(m_updateCheckResult)
		CUpdateCheck::ShowSuccessGUI(false, *m_updateCheckResult);
	else
		CUpdateCheck::DoManualUpdateCheck();
#endif  // MPT_ENABLE_UPDATE
}


void CMainFrame::OnShowSettingsFolder()
{
	theApp.OpenDirectory(theApp.GetConfigPath());
}



class CUpdateCheckProgressDialog
	: public CProgressDialog
{
public:
	CUpdateCheckProgressDialog(CWnd *parent)
		: CProgressDialog(parent)
	{
		return;
	}
	void Run() override
	{
	}
};

static std::unique_ptr<CUpdateCheckProgressDialog> g_UpdateCheckProgressDialog = nullptr;


#if defined(MPT_ENABLE_UPDATE)


bool CMainFrame::ShowUpdateIndicator(const UpdateCheckResult &result, const CString &releaseVersion, const CString &infoURL, bool showHighlight)
{
	m_updateCheckResult = std::make_unique<UpdateCheckResult>(result);
	if(m_wndToolBar.IsVisible())
	{
		return m_wndToolBar.ShowUpdateInfo(releaseVersion, infoURL, showHighlight);
	} else
	{
		GetMenu()->RemoveMenu(ID_UPDATE_AVAILABLE, MF_BYCOMMAND);
		GetMenu()->AppendMenu(MF_STRING, ID_UPDATE_AVAILABLE, _T("[Update Available]"));
		DrawMenuBar();
		return true;
	}
}


LRESULT CMainFrame::OnUpdateCheckStart(WPARAM wparam, LPARAM lparam)
{
	GetMenu()->RemoveMenu(ID_UPDATE_AVAILABLE, MF_BYCOMMAND);
	m_wndToolBar.RemoveUpdateInfo();

	const bool isAutoUpdate = CUpdateCheck::IsAutoUpdateFromMessage(wparam, lparam);
	CString updateText = _T("Checking for updates...");
	if(isAutoUpdate)
	{
		SetHelpText(updateText);
	} else if(m_UpdateOptionsDialog)
	{
		m_UpdateOptionsDialog->SetDlgItemText(IDC_LASTUPDATE, updateText);
	} else
	{
		if(!g_UpdateCheckProgressDialog)
		{
			g_UpdateCheckProgressDialog = std::make_unique<CUpdateCheckProgressDialog>(CMainFrame::GetMainFrame());
			g_UpdateCheckProgressDialog->Create(IDD_PROGRESS, CMainFrame::GetMainFrame());
			g_UpdateCheckProgressDialog->SetTitle(_T("Checking for updates..."));
			g_UpdateCheckProgressDialog->SetText(_T("Checking for updates..."));
			g_UpdateCheckProgressDialog->SetAbortText(_T("&Cancel"));
			g_UpdateCheckProgressDialog->SetRange(0, 100);
			g_UpdateCheckProgressDialog->ShowWindow(SW_SHOWDEFAULT);
		}
		if(g_UpdateCheckProgressDialog)
		{
			g_UpdateCheckProgressDialog->SetProgress(0);
		}
	}
	return TRUE;
}


LRESULT CMainFrame::OnUpdateCheckProgress(WPARAM wparam, LPARAM lparam)
{
	bool isAutoUpdate = wparam != 0;
	CString updateText = MPT_CFORMAT("Checking for updates... {}%")(lparam);
	if(isAutoUpdate)
	{
		SetHelpText(updateText);
	} else if(m_UpdateOptionsDialog)
	{
		m_UpdateOptionsDialog->SetDlgItemText(IDC_LASTUPDATE, updateText);
	} else
	{
		if(g_UpdateCheckProgressDialog)
		{
			g_UpdateCheckProgressDialog->SetProgress(lparam);
			if(g_UpdateCheckProgressDialog->m_abort)
			{
				return FALSE;
			}
		}
	}
	return TRUE;
}


LRESULT CMainFrame::OnUpdateCheckCanceled(WPARAM wparam, LPARAM lparam)
{
	m_updateCheckResult.reset();
	bool isAutoUpdate = CUpdateCheck::IsAutoUpdateFromMessage(wparam, lparam);
	CString updateText = _T("Checking for updates... Canceled.");
	if(isAutoUpdate)
	{
		SetHelpText(updateText);
	} else if(m_UpdateOptionsDialog)
	{
		m_UpdateOptionsDialog->SetDlgItemText(IDC_LASTUPDATE, updateText);
		m_UpdateOptionsDialog->SettingChanged(TrackerSettings::Instance().UpdateLastUpdateCheck.GetPath());
	} else
	{
		if(g_UpdateCheckProgressDialog)
		{
			g_UpdateCheckProgressDialog->DestroyWindow();
			g_UpdateCheckProgressDialog = nullptr;
		}
	}
	if(isAutoUpdate)
	{
		SetHelpText(_T(""));
	}
	return TRUE;
}


LRESULT CMainFrame::OnUpdateCheckFailure(WPARAM wparam, LPARAM lparam)
{
	m_updateCheckResult.reset();
	const bool isAutoUpdate = CUpdateCheck::IsAutoUpdateFromMessage(wparam, lparam);
	const CUpdateCheck::Error &error = CUpdateCheck::MessageAsError(wparam, lparam);
	CString updateText = MPT_CFORMAT("Checking for updates failed: {}")(mpt::get_exception_text<mpt::ustring>(error));
	if(isAutoUpdate)
	{
		SetHelpText(updateText);
	} else if(m_UpdateOptionsDialog)
	{
		m_UpdateOptionsDialog->SetDlgItemText(IDC_LASTUPDATE, updateText);
		m_UpdateOptionsDialog->SettingChanged(TrackerSettings::Instance().UpdateLastUpdateCheck.GetPath());
	} else
	{
		if(g_UpdateCheckProgressDialog)
		{
			g_UpdateCheckProgressDialog->DestroyWindow();
			g_UpdateCheckProgressDialog = nullptr;
		}
	}
	CUpdateCheck::ShowFailureGUI(isAutoUpdate, error);
	if(isAutoUpdate)
	{
		SetHelpText(_T(""));
	}
	return TRUE;
}


LRESULT CMainFrame::OnUpdateCheckSuccess(WPARAM wparam, LPARAM lparam)
{
	m_updateCheckResult.reset();
	const bool isAutoUpdate = CUpdateCheck::IsAutoUpdateFromMessage(wparam, lparam);
	const UpdateCheckResult &result = CUpdateCheck::MessageAsResult(wparam, lparam);
	CUpdateCheck::AcknowledgeSuccess(result);
	if(result.CheckTime != time_t{})
		TrackerSettings::Instance().UpdateLastUpdateCheck = mpt::Date::Unix(result.CheckTime);
	if(!isAutoUpdate)
	{
		if(m_UpdateOptionsDialog)
		{
			m_UpdateOptionsDialog->SetDlgItemText(IDC_LASTUPDATE, _T("Checking for updates... Done."));
		} else
		{
			if(g_UpdateCheckProgressDialog)
			{
				g_UpdateCheckProgressDialog->DestroyWindow();
				g_UpdateCheckProgressDialog = nullptr;
			}
			SetHelpText(_T(""));
		}
	}
	CUpdateCheck::ShowSuccessGUI(isAutoUpdate, result);
	if(isAutoUpdate)
	{
		SetHelpText(_T(""));
	}
	return TRUE;
}


LPARAM CMainFrame::OnToolbarUpdateIndicatorClick(WPARAM action, LPARAM)
{
	const auto popAction = static_cast<UpdateToolTip::PopAction>(action);
	if(popAction != UpdateToolTip::PopAction::ClickBubble)
		return 0;

	if(m_updateCheckResult)
		CUpdateCheck::ShowSuccessGUI(false, *m_updateCheckResult);
	else
		CUpdateCheck::DoManualUpdateCheck();
	return 0;
}


#endif // MPT_ENABLE_UPDATE


void CMainFrame::OnHelp()
{
	CView *view = GetActiveView();
	const char *page = "";
	if(m_bOptionsLocked)
	{
		switch(m_nLastOptionsPage)
		{
			case OPTIONS_PAGE_GENERAL:		page = "::/Setup_General.html"; break;
			case OPTIONS_PAGE_SOUNDCARD:	page = "::/Setup_Soundcard.html"; break;
			case OPTIONS_PAGE_MIXER:		page = "::/Setup_Mixer.html"; break;
			case OPTIONS_PAGE_PLAYER:		page = "::/Setup_DSP.html"; break;
			case OPTIONS_PAGE_SAMPLEDITOR:	page = "::/Setup_Samples.html"; break;
			case OPTIONS_PAGE_KEYBOARD:		page = "::/Setup_Keyboard.html"; break;
			case OPTIONS_PAGE_COLORS:		page = "::/Setup_Display.html"; break;
			case OPTIONS_PAGE_MIDI:			page = "::/Setup_MIDI.html"; break;
			case OPTIONS_PAGE_PATHS:		page = "::/Setup_Paths_Auto_Save.html"; break;
			case OPTIONS_PAGE_UPDATE:		page = "::/Setup_Update.html"; break;
			case OPTIONS_PAGE_ADVANCED:		page = "::/Setup_Advanced.html"; break;
			case OPTIONS_PAGE_WINE:			page = "::/Setup_Wine.html"; break;
		}
	} else if(view != nullptr)
	{
		const char *className = view->GetRuntimeClass()->m_lpszClassName;
		if(!strcmp("CViewGlobals", className))
			page = "::/General.html";
		else if(!strcmp("CViewPattern", className))
			page = "::/Patterns.html";
		else if(!strcmp("CViewSample", className))
			page = "::/Samples.html";
		else if(!strcmp("CViewInstrument", className))
			page = "::/Instruments.html";
		else if(!strcmp("CViewComments", className))
			page = "::/Comments.html";
		else if(!strcmp("CModControlView", className))
		{
			switch(static_cast<CModControlView*>(view)->GetActivePage())
			{
				case CModControlView::VIEW_GLOBALS: page = "::/General.html"; break;
				case CModControlView::VIEW_PATTERNS: page = "::/Patterns.html"; break;
				case CModControlView::VIEW_SAMPLES: page = "::/Samples.html"; break;
				case CModControlView::VIEW_INSTRUMENTS: page = "::/Instruments.html"; break;
				case CModControlView::VIEW_COMMENTS: page = "::/Comments.html"; break;
			}
		}
	}

	const mpt::PathString helpFile = theApp.GetInstallPath() + P_("OpenMPT Manual.chm") + mpt::PathString::FromUTF8(page) + P_(">OpenMPT");
	if(!::HtmlHelp(m_hWnd, helpFile.AsNative().c_str(), strcmp(page, "") ? HH_DISPLAY_TOC : HH_DISPLAY_TOPIC, NULL))
	{
		Reporting::Error(_T("Could not find help file:\n") + helpFile.ToCString());
		return;
	}
	//::ShowWindow(hwndHelp, SW_SHOWMAXIMIZED);
}


LRESULT CMainFrame::OnViewMIDIMapping(WPARAM wParam, LPARAM lParam)
{
	static bool inMapper = false;
	if(!inMapper)
	{
		inMapper = true;
		CModDoc *doc = GetActiveDoc();
		if(doc != nullptr)
			doc->ViewMIDIMapping(static_cast<PLUGINDEX>(wParam), static_cast<PlugParamIndex>(lParam));
		inMapper = false;
	}
	return 0;
}


HMENU CMainFrame::CreateFileMenu(const size_t maxCount, std::vector<mpt::PathString>& paths, const mpt::PathString &folderName, const uint16 idRangeBegin)
{
	paths.clear();
	HMENU hMenu = ::CreatePopupMenu();
	ASSERT(hMenu != NULL);
	if (hMenu != NULL)
	{
		UINT_PTR filesAdded = 0;
		for(size_t i = 0; i < 2; i++) // 0: app items, 1: user items
		{
			// To avoid duplicates, check whether app path and config path are the same.
			if (i == 1 && mpt::PathString::CompareNoCase(theApp.GetInstallPath(), theApp.GetConfigPath()) == 0)
				break;

			mpt::PathString basePath;
			basePath = (i == 0) ? theApp.GetInstallPath() : theApp.GetConfigPath();
			basePath += folderName;
			if(!basePath.IsDirectory())
				continue;

			FolderScanner scanner(basePath, FolderScanner::kOnlyFiles);
			mpt::PathString fileName;
			while(filesAdded < maxCount && scanner.Next(fileName))
			{
				paths.push_back(fileName);
				CString file = fileName.GetFullFileName().ToCString();
				file.Replace(_T("&"), _T("&&"));
				AppendMenu(hMenu, MF_STRING, idRangeBegin + filesAdded, file);
				filesAdded++;
			}
		}

		if(filesAdded == 0)
		{
			AppendMenu(hMenu, MF_STRING | MF_GRAYED | MF_DISABLED, 0, _T("No items found"));
		} else
		{
			AppendMenu(hMenu, MF_SEPARATOR, 0, 0);
			AppendMenu(hMenu, MF_STRING, idRangeBegin + maxCount, _T("Browse..."));
		}
	}

	return hMenu;
}


void CMainFrame::CreateExampleModulesMenu()
{
	static_assert(nMaxItemsInExampleModulesMenu == ID_EXAMPLE_MODULES_LASTINRANGE - ID_EXAMPLE_MODULES,
				  "Make sure that there's a proper range for menu commands in resources.");
	HMENU hMenu = CreateFileMenu(nMaxItemsInExampleModulesMenu, m_ExampleModulePaths, P_("ExampleSongs\\"), ID_EXAMPLE_MODULES);
	CMenu* const pMainMenu = GetMenu();
	if (hMenu && pMainMenu && m_InputHandler)
		VERIFY(pMainMenu->ModifyMenu(ID_EXAMPLE_MODULES, MF_BYCOMMAND | MF_POPUP, (UINT_PTR)hMenu, m_InputHandler->GetMenuText(ID_EXAMPLE_MODULES)));
	else
		ASSERT(false);
}


// Hack-ish way to get the file menu (this is necessary because the MDI document icon next to the File menu is a sub menu, too).
CMenu *CMainFrame::GetFileMenu() const
{
	CMenu *mainMenu = GetMenu();
	CMenu *fileMenu = mainMenu ? mainMenu->GetSubMenu(0) : nullptr;
	if(fileMenu)
	{
		if(fileMenu->GetMenuItemID(1) != ID_FILE_OPEN)
			fileMenu = mainMenu->GetSubMenu(1);
		ASSERT(fileMenu->GetMenuItemID(1) == ID_FILE_OPEN);
	}
	ASSERT(fileMenu);
	return fileMenu;
}


void CMainFrame::CreateTemplateModulesMenu()
{
	static_assert(nMaxItemsInTemplateModulesMenu == ID_FILE_OPENTEMPLATE_LASTINRANGE - ID_FILE_OPENTEMPLATE,
				  "Make sure that there's a proper range for menu commands in resources.");
	HMENU hMenu = CreateFileMenu(nMaxItemsInTemplateModulesMenu, m_TemplateModulePaths, P_("TemplateModules\\"), ID_FILE_OPENTEMPLATE);
	CMenu *pFileMenu = GetFileMenu();
	if (hMenu && pFileMenu && m_InputHandler)
	{
		VERIFY(pFileMenu->RemoveMenu(2, MF_BYPOSITION));
		VERIFY(pFileMenu->InsertMenu(2, MF_BYPOSITION | MF_POPUP, (UINT_PTR)hMenu, m_InputHandler->GetMenuText(ID_FILE_OPENTEMPLATE)));
	}
	else
		ASSERT(false);
}


void CMainFrame::UpdateMRUList()
{
	CMenu *pMenu = GetFileMenu();
	if(!pMenu) return;

	static int firstMenu = -1;
	if(firstMenu == -1)
	{
		int numMenus = pMenu->GetMenuItemCount();
		for(int i = 0; i < numMenus; i++)
		{
			if(pMenu->GetMenuItemID(i) == ID_MRU_LIST_FIRST)
			{
				firstMenu = i;
				break;
			}
		}
	}

	for(int i = ID_MRU_LIST_FIRST; i <= ID_MRU_LIST_LAST; i++)
	{
		pMenu->DeleteMenu(i, MF_BYCOMMAND);
	}

	if(TrackerSettings::Instance().mruFiles.empty())
	{
		// MFC will automatically ignore if we set MF_GRAYED here because of CFrameWnd::m_bAutoMenuEnable.
		// So we will have to install a ON_UPDATE_COMMAND_UI callback...
		pMenu->InsertMenu(firstMenu, MF_STRING | MF_BYPOSITION, ID_MRU_LIST_FIRST, _T("Recent File"));
	} else
	{
		const mpt::PathString workDir = TrackerSettings::Instance().PathSongs.GetWorkingDir();
		const int entries = mpt::saturate_cast<int>(TrackerSettings::Instance().mruFiles.size());
		for(int i = 0; i < entries; i++)
		{
			mpt::winstring s = mpt::tfmt::val(i + 1) + _T(" ");
			// Add mnemonics
			if(i < 9)
			{
				s = _T("&") + s;
			} else if(i == 9)
			{
				s = _T("1&0 ");
			}

			const mpt::PathString &pathMPT = TrackerSettings::Instance().mruFiles[i];
			mpt::winstring path = pathMPT.AsNative();
			if(!mpt::PathString::CompareNoCase(workDir, pathMPT.GetPath()))
			{
				// Only show filename
				path = path.substr(workDir.AsNative().length());
			} else if(path.length() > 30)	// Magic number experimentally determined to be equal to MFC's behaviour
			{
				// Shorten path ("C:\Foo\VeryLongString...\Bar.it" => "C:\Foo\...\Bar.it")
				size_t start = path.find_first_of(_T("\\/"), path.find_first_of(_T("\\/")) + 1);
				size_t end = path.find_last_of(_T("\\/"));
				if(start < end)
				{
					path = path.substr(0, start + 1) + _T("...") + path.substr(end);
				}
			}
			path = mpt::String::Replace(path, mpt::winstring(_T("&")), mpt::winstring(_T("&&")));
			s += path;
			pMenu->InsertMenu(firstMenu + i, MF_STRING | MF_BYPOSITION, ID_MRU_LIST_FIRST + i, mpt::ToCString(s));
		}
	}
}


BOOL CMainFrame::OnQueryEndSession()
{
	int modifiedCount = 0;
	for(const auto &modDoc : theApp.GetOpenDocuments())
	{
		if(modDoc->IsModified())
			modifiedCount++;
	}
#if (_WIN32_WINNT >= _WIN32_WINNT_VISTA)
	ShutdownBlockReasonDestroy(m_hWnd);
	if(modifiedCount > 0)
	{
		ShutdownBlockReasonCreate(m_hWnd,
			MPT_WFORMAT("There {} {} unsaved file{}.")(modifiedCount == 1 ? L"is" : L"are", modifiedCount, modifiedCount == 1 ? L"" : L"s").c_str());
	}
#endif
	return modifiedCount ? FALSE : TRUE;
}


void CMainFrame::NotifyAccessibilityUpdate(CWnd &source)
{
	if(!IsPlaying() || m_pSndFile->m_SongFlags[SONG_PAUSED])
		source.NotifyWinEvent(EVENT_OBJECT_NAMECHANGE, OBJID_CLIENT, CHILDID_SELF);
}

// ITfLanguageProfileNotifySink implementation

TfLanguageProfileNotifySink::TfLanguageProfileNotifySink()
{
	HRESULT hr = CoCreateInstance(CLSID_TF_InputProcessorProfiles, NULL, CLSCTX_INPROC_SERVER, IID_ITfInputProcessorProfiles, (void**)&m_pProfiles);
	if(SUCCEEDED(hr))
	{
		hr = m_pProfiles->QueryInterface(IID_ITfSource, (void**)&m_pSource);
		if(SUCCEEDED(hr))
		{
			hr = m_pSource->AdviseSink(IID_ITfLanguageProfileNotifySink,
				static_cast<ITfLanguageProfileNotifySink *>(this),
				&m_dwCookie);
			MPT_ASSERT(SUCCEEDED(hr));
			MPT_ASSERT(m_dwCookie != TF_INVALID_COOKIE);
		}
	}
}


TfLanguageProfileNotifySink::~TfLanguageProfileNotifySink()
{
	if(mpt::OS::Windows::IsWine())
	{
		// Calling UnadviseSink causes a random crash in Wine when computing its function pointer for some reason.
		// Probably a race condition I don't understand, and probably a bug in Wine.
		return;
	}
	if(m_pSource && (m_dwCookie != TF_INVALID_COOKIE))
	{
		m_pSource->UnadviseSink(m_dwCookie);
	}
	m_dwCookie = TF_INVALID_COOKIE;
	if(m_pSource)
	{
		m_pSource->Release();
	}
	m_pSource = nullptr;
	if(m_pProfiles) m_pProfiles->Release();
	m_pProfiles = nullptr;
}


HRESULT TfLanguageProfileNotifySink::OnLanguageChange(LANGID /*langid*/, __RPC__out BOOL *pfAccept)
{
	*pfAccept = TRUE;
	return ResultFromScode(S_OK);
}


HRESULT TfLanguageProfileNotifySink::OnLanguageChanged()
{
	// Input language has changed, so key positions might have changed too.
	CMainFrame *mainFrm = CMainFrame::GetMainFrame();
	if(mainFrm != nullptr)
	{
		mainFrm->UpdateEffectKeys(mainFrm->GetActiveDoc());
		mainFrm->m_InputHandler->SetModifierMask(ModNone);
	}
	return ResultFromScode(S_OK);
}


HRESULT TfLanguageProfileNotifySink::QueryInterface(REFIID riid, void **ppvObject)
{
	if(riid == IID_ITfLanguageProfileNotifySink || riid == IID_IUnknown)
	{
		*ppvObject = static_cast<ITfLanguageProfileNotifySink *>(this);
		AddRef();
		return ResultFromScode(S_OK);
	}
	*ppvObject = nullptr;
	return ResultFromScode(E_NOINTERFACE);
}


ULONG TfLanguageProfileNotifySink::AddRef()
{
	// Don't let COM do anything to this object
	return 1;
}

ULONG TfLanguageProfileNotifySink::Release()
{
	// Don't let COM do anything to this object
	return 1;
}


/////////////////////////////////////////////
//Misc helper functions
/////////////////////////////////////////////

void AddPluginNamesToCombobox(CComboBox &CBox, const SNDMIXPLUGIN *plugarray, const bool libraryName, const PLUGINDEX updatePlug)
{
#ifndef NO_PLUGINS
	int insertAt = CBox.GetCount();
	if(updatePlug != PLUGINDEX_INVALID)
	{
		const int items = insertAt;
		for(insertAt = 0; insertAt < items; insertAt++)
		{
			auto thisPlugin = static_cast<PLUGINDEX>(CBox.GetItemData(insertAt));
			if(thisPlugin == (updatePlug + 1))
				CBox.DeleteString(insertAt);
			if(thisPlugin >= (updatePlug + 1))
				break;
		}
	}

	mpt::tstring str;
	str.reserve(80);
	for(PLUGINDEX plug = 0; plug < MAX_MIXPLUGINS; plug++)
	{
		if(updatePlug != PLUGINDEX_INVALID && plug != updatePlug)
			continue;
		const SNDMIXPLUGIN &plugin = plugarray[plug];
		str.clear();
		str += MPT_TFORMAT("FX{}: ")(plug + 1);
		const auto plugName = plugin.GetName(), libName = plugin.GetLibraryName();
		str += mpt::ToWin(plugName);
		if(libraryName && plugName != libName && !libName.empty())
			str += _T(" (") + mpt::ToWin(libName) + _T(")");
		else if(plugName.empty() && (!libraryName || libName.empty()))
			str += _T("--");
#ifdef MPT_WITH_VST
		auto *vstPlug = dynamic_cast<const CVstPlugin *>(plugin.pMixPlugin);
		if(vstPlug != nullptr && vstPlug->isBridged)
		{
			VSTPluginLib &lib = vstPlug->GetPluginFactory();
			str += MPT_TFORMAT(" ({} Bridged)")(lib.GetDllArchNameUser());
		}
#endif // MPT_WITH_VST

		insertAt = CBox.InsertString(insertAt, str.c_str());
		CBox.SetItemData(insertAt, plug + 1);
		insertAt++;
	}
#endif // NO_PLUGINS
}


void AddPluginParameternamesToCombobox(CComboBox& CBox, SNDMIXPLUGIN& plug)
{
#ifndef NO_PLUGINS
	if(plug.pMixPlugin)
		AddPluginParameternamesToCombobox(CBox, *plug.pMixPlugin);
#endif // NO_PLUGINS
}


void AddPluginParameternamesToCombobox(CComboBox& CBox, IMixPlugin& plug)
{
#ifndef NO_PLUGINS
	const PlugParamIndex numParams = plug.GetNumParameters();
	plug.CacheParameterNames(0, numParams);
	for(PlugParamIndex i = 0; i < numParams; i++)
	{
		CBox.SetItemData(CBox.AddString(plug.GetFormattedParamName(i)), i);
	}
#endif // NO_PLUGINS
}


OPENMPT_NAMESPACE_END