3258 lines
89 KiB
C++
3258 lines
89 KiB
C++
/*
|
|
* 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
|