2414 lines
67 KiB
C++
2414 lines
67 KiB
C++
/*
|
|
* MPTrack.cpp
|
|
* -----------
|
|
* Purpose: OpenMPT core application class.
|
|
* 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 "IPCWindow.h"
|
|
#include "InputHandler.h"
|
|
#include "Childfrm.h"
|
|
#include "Moddoc.h"
|
|
#include "ModDocTemplate.h"
|
|
#include "Globals.h"
|
|
#include "../soundlib/Dlsbank.h"
|
|
#include "../common/version.h"
|
|
#include "../test/test.h"
|
|
#include "UpdateCheck.h"
|
|
#include "../common/mptStringBuffer.h"
|
|
#include "ExceptionHandler.h"
|
|
#include "CloseMainDialog.h"
|
|
#include "PlugNotFoundDlg.h"
|
|
#include "AboutDialog.h"
|
|
#include "AutoSaver.h"
|
|
#include "FileDialog.h"
|
|
#include "Image.h"
|
|
#include "BuildVariants.h"
|
|
#include "../common/ComponentManager.h"
|
|
#include "WelcomeDialog.h"
|
|
#include "openmpt/sounddevice/SoundDeviceManager.hpp"
|
|
#include "WineSoundDeviceStub.h"
|
|
#include "../soundlib/plugins/PluginManager.h"
|
|
#include "MPTrackWine.h"
|
|
#include "MPTrackUtil.h"
|
|
#if MPT_MSVC_AT_LEAST(2022, 2) && MPT_MSVC_BEFORE(2022, 3)
|
|
// Work-around <https://developercommunity.visualstudio.com/t/warning-C4311-in-MFC-header-afxrecovery/10041328>,
|
|
// see <https://developercommunity.visualstudio.com/t/Compiler-warnings-after-upgrading-to-17/10036311#T-N10061908>.
|
|
template <class ARG_KEY>
|
|
AFX_INLINE UINT AFXAPI HashKey(ARG_KEY key);
|
|
template <>
|
|
AFX_INLINE UINT AFXAPI HashKey<CDocument*>(CDocument *key)
|
|
{
|
|
// (algorithm copied from STL hash in xfunctional)
|
|
#pragma warning(suppress: 4302) // 'type cast' : truncation
|
|
#pragma warning(suppress: 4311) // pointer truncation
|
|
ldiv_t HashVal = ldiv((long)(CDocument*)key, 127773);
|
|
HashVal.rem = 16807 * HashVal.rem - 2836 * HashVal.quot;
|
|
if(HashVal.rem < 0)
|
|
HashVal.rem += 2147483647;
|
|
return ((UINT)HashVal.rem);
|
|
}
|
|
#endif
|
|
#include <afxdatarecovery.h>
|
|
|
|
// GDI+
|
|
#include <atlbase.h>
|
|
#define max(a, b) (((a) > (b)) ? (a) : (b))
|
|
#define min(a, b) (((a) < (b)) ? (a) : (b))
|
|
#if MPT_COMPILER_MSVC
|
|
#pragma warning(push)
|
|
#pragma warning(disable : 4458) // declaration of 'x' hides class member
|
|
#endif
|
|
#include <gdiplus.h>
|
|
#if MPT_COMPILER_MSVC
|
|
#pragma warning(pop)
|
|
#endif
|
|
#undef min
|
|
#undef max
|
|
|
|
#if MPT_COMPILER_MSVC
|
|
#define _CRTDBG_MAP_ALLOC
|
|
#include <stdlib.h>
|
|
#include <crtdbg.h>
|
|
#endif
|
|
|
|
|
|
OPENMPT_NAMESPACE_BEGIN
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// The one and only CTrackApp object
|
|
|
|
CTrackApp theApp;
|
|
|
|
const TCHAR *szSpecialNoteNamesMPT[] = {_T("PCs"), _T("PC"), _T("~~ (Note Fade)"), _T("^^ (Note Cut)"), _T("== (Note Off)")};
|
|
const TCHAR *szSpecialNoteShortDesc[] = {_T("Param Control (Smooth)"), _T("Param Control"), _T("Note Fade"), _T("Note Cut"), _T("Note Off")};
|
|
|
|
// Make sure that special note arrays include string for every note.
|
|
static_assert(NOTE_MAX_SPECIAL - NOTE_MIN_SPECIAL + 1 == mpt::array_size<decltype(szSpecialNoteNamesMPT)>::size);
|
|
static_assert(mpt::array_size<decltype(szSpecialNoteShortDesc)>::size == mpt::array_size<decltype(szSpecialNoteNamesMPT)>::size);
|
|
|
|
const char *szHexChar = "0123456789ABCDEF";
|
|
|
|
|
|
#ifdef MPT_WITH_ASIO
|
|
class ComponentASIO
|
|
: public ComponentBuiltin
|
|
{
|
|
MPT_DECLARE_COMPONENT_MEMBERS(ComponentASIO, "ASIO")
|
|
public:
|
|
ComponentASIO() = default;
|
|
virtual ~ComponentASIO() = default;
|
|
};
|
|
#endif // MPT_WITH_ASIO
|
|
|
|
#if defined(MPT_WITH_DIRECTSOUND)
|
|
class ComponentDirectSound
|
|
: public ComponentBuiltin
|
|
{
|
|
MPT_DECLARE_COMPONENT_MEMBERS(ComponentDirectSound, "DirectSound")
|
|
public:
|
|
ComponentDirectSound() = default;
|
|
virtual ~ComponentDirectSound() = default;
|
|
};
|
|
#endif // MPT_WITH_DIRECTSOUND
|
|
|
|
#if defined(MPT_WITH_PORTAUDIO)
|
|
class ComponentPortAudio
|
|
: public ComponentBuiltin
|
|
{
|
|
MPT_DECLARE_COMPONENT_MEMBERS(ComponentPortAudio, "PortAudio")
|
|
public:
|
|
ComponentPortAudio() = default;
|
|
virtual ~ComponentPortAudio() = default;
|
|
};
|
|
#endif // MPT_WITH_PORTAUDIO
|
|
|
|
#if defined(MPT_WITH_PULSEAUDIO)
|
|
class ComponentPulseaudio
|
|
: public ComponentBuiltin
|
|
{
|
|
MPT_DECLARE_COMPONENT_MEMBERS(ComponentPulseaudio, "Pulseaudio")
|
|
public:
|
|
ComponentPulseaudio() = default;
|
|
virtual ~ComponentPulseaudio() = default;
|
|
};
|
|
#endif // MPT_WITH_PULSEAUDIO
|
|
|
|
#if defined(MPT_WITH_PULSEAUDIO) && defined(MPT_WITH_PULSEAUDIOSIMPLE)
|
|
class ComponentPulseaudioSimple
|
|
: public ComponentBuiltin
|
|
{
|
|
MPT_DECLARE_COMPONENT_MEMBERS(ComponentPulseaudioSimple, "PulseaudioSimple")
|
|
public:
|
|
ComponentPulseaudioSimple() = default;
|
|
virtual ~ComponentPulseaudioSimple() = default;
|
|
};
|
|
#endif // MPT_WITH_PULSEAUDIO && MPT_WITH_PULSEAUDIOSIMPLE
|
|
|
|
#if defined(MPT_WITH_RTAUDIO)
|
|
class ComponentRtAudio
|
|
: public ComponentBuiltin
|
|
{
|
|
MPT_DECLARE_COMPONENT_MEMBERS(ComponentRtAudio, "RtAudio")
|
|
public:
|
|
ComponentRtAudio() = default;
|
|
virtual ~ComponentRtAudio() = default;
|
|
};
|
|
#endif // MPT_WITH_RTAUDIO
|
|
|
|
#if MPT_OS_WINDOWS
|
|
class ComponentWaveOut
|
|
: public ComponentBuiltin
|
|
{
|
|
MPT_DECLARE_COMPONENT_MEMBERS(ComponentWaveOut, "WaveOut")
|
|
public:
|
|
ComponentWaveOut() = default;
|
|
virtual ~ComponentWaveOut() = default;
|
|
};
|
|
#endif // MPT_OS_WINDOWS
|
|
|
|
struct AllSoundDeviceComponents
|
|
{
|
|
#if defined(MPT_WITH_PULSEAUDIO) && defined(MPT_ENABLE_PULSEAUDIO_FULL)
|
|
ComponentHandle<ComponentPulseaudio> m_Pulseaudio;
|
|
#endif // MPT_WITH_PULSEAUDIO && MPT_ENABLE_PULSEAUDIO_FULL
|
|
#if defined(MPT_WITH_PULSEAUDIO) && defined(MPT_WITH_PULSEAUDIOSIMPLE)
|
|
ComponentHandle<ComponentPulseaudioSimple> m_PulseaudioSimple;
|
|
#endif // MPT_WITH_PULSEAUDIO && MPT_WITH_PULSEAUDIOSIMPLE
|
|
#if MPT_OS_WINDOWS
|
|
ComponentHandle<ComponentWaveOut> m_WaveOut;
|
|
#endif // MPT_OS_WINDOWS
|
|
#if defined(MPT_WITH_DIRECTSOUND)
|
|
ComponentHandle<ComponentDirectSound> m_DirectSound;
|
|
#endif // MPT_WITH_DIRECTSOUND
|
|
#ifdef MPT_WITH_ASIO
|
|
ComponentHandle<ComponentASIO> m_ASIO;
|
|
#endif // MPT_WITH_ASIO
|
|
#ifdef MPT_WITH_PORTAUDIO
|
|
ComponentHandle<ComponentPortAudio> m_PortAudio;
|
|
#endif // MPT_WITH_PORTAUDIO
|
|
#ifdef MPT_WITH_RTAUDIO
|
|
ComponentHandle<ComponentRtAudio> m_RtAudio;
|
|
#endif // MPT_WITH_RTAUDIO
|
|
operator SoundDevice::EnabledBackends() const
|
|
{
|
|
SoundDevice::EnabledBackends result;
|
|
#if defined(MPT_WITH_PULSEAUDIO) && defined(MPT_ENABLE_PULSEAUDIO_FULL)
|
|
result.Pulseaudio = IsComponentAvailable(m_PulseAudio);
|
|
#endif // MPT_WITH_PULSEAUDIO && MPT_ENABLE_PULSEAUDIO_FULL
|
|
#if defined(MPT_WITH_PULSEAUDIO) && defined(MPT_WITH_PULSEAUDIOSIMPLE)
|
|
result.PulseaudioSimple = IsComponentAvailable(m_PulseAudioSimple);
|
|
#endif // MPT_WITH_PULSEAUDIO && MPT_WITH_PULSEAUDIOSIMPLE
|
|
#if MPT_OS_WINDOWS
|
|
result.WaveOut = IsComponentAvailable(m_WaveOut);
|
|
#endif // MPT_OS_WINDOWS
|
|
#if defined(MPT_WITH_DIRECTSOUND)
|
|
result.DirectSound = IsComponentAvailable(m_DirectSound);
|
|
#endif // MPT_WITH_DIRECTSOUND
|
|
#ifdef MPT_WITH_ASIO
|
|
result.ASIO = IsComponentAvailable(m_ASIO);
|
|
#endif // MPT_WITH_ASIO
|
|
#ifdef MPT_WITH_PORTAUDIO
|
|
result.PortAudio = IsComponentAvailable(m_PortAudio);
|
|
#endif // MPT_WITH_PORTAUDIO
|
|
#ifdef MPT_WITH_RTAUDIO
|
|
result.RtAudio = IsComponentAvailable(m_RtAudio);
|
|
#endif // MPT_WITH_RTAUDIO
|
|
return result;
|
|
}
|
|
};
|
|
|
|
|
|
void CTrackApp::OnFileCloseAll()
|
|
{
|
|
if(!(TrackerSettings::Instance().m_dwPatternSetup & PATTERN_NOCLOSEDIALOG))
|
|
{
|
|
// Show modified documents window
|
|
CloseMainDialog dlg;
|
|
if(dlg.DoModal() != IDOK)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
for(auto &doc : GetOpenDocuments())
|
|
{
|
|
doc->SafeFileClose();
|
|
}
|
|
}
|
|
|
|
|
|
void CTrackApp::OnUpdateAnyDocsOpen(CCmdUI *cmd)
|
|
{
|
|
cmd->Enable(!GetModDocTemplate()->empty());
|
|
}
|
|
|
|
|
|
int CTrackApp::GetOpenDocumentCount() const
|
|
{
|
|
return static_cast<int>(GetModDocTemplate()->size());
|
|
}
|
|
|
|
|
|
// Retrieve a list of all open modules.
|
|
std::vector<CModDoc *> CTrackApp::GetOpenDocuments() const
|
|
{
|
|
std::vector<CModDoc *> documents;
|
|
if(auto *pDocTmpl = GetModDocTemplate())
|
|
{
|
|
POSITION pos = pDocTmpl->GetFirstDocPosition();
|
|
CDocument *pDoc;
|
|
while((pos != nullptr) && ((pDoc = pDocTmpl->GetNextDoc(pos)) != nullptr))
|
|
{
|
|
documents.push_back(dynamic_cast<CModDoc *>(pDoc));
|
|
}
|
|
}
|
|
|
|
return documents;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Command Line options
|
|
|
|
class CMPTCommandLineInfo: public CCommandLineInfo
|
|
{
|
|
public:
|
|
std::vector<mpt::PathString> m_fileNames;
|
|
bool m_noDls = false, m_noPlugins = false, m_noAssembly = false, m_noSysCheck = false, m_noWine = false,
|
|
m_portable = false, m_noCrashHandler = false, m_debugCrashHandler = false, m_sharedInstance = false;
|
|
#ifdef ENABLE_TESTS
|
|
bool m_noTests = false;
|
|
#endif
|
|
|
|
public:
|
|
void ParseParam(LPCTSTR param, BOOL isFlag, BOOL isLast) override
|
|
{
|
|
if(isFlag)
|
|
{
|
|
if(!lstrcmpi(param, _T("nologo"))) { m_bShowSplash = FALSE; return; }
|
|
if(!lstrcmpi(param, _T("nodls"))) { m_noDls = true; return; }
|
|
if(!lstrcmpi(param, _T("noplugs"))) { m_noPlugins = true; return; }
|
|
if(!lstrcmpi(param, _T("portable"))) { m_portable = true; return; }
|
|
if(!lstrcmpi(param, _T("fullMemDump"))) { ExceptionHandler::fullMemDump = true; return; }
|
|
if(!lstrcmpi(param, _T("noAssembly"))) { m_noAssembly = true; return; }
|
|
if(!lstrcmpi(param, _T("noSysCheck"))) { m_noSysCheck = true; return; }
|
|
if(!lstrcmpi(param, _T("noWine"))) { m_noWine = true; return; }
|
|
if(!lstrcmpi(param, _T("noCrashHandler"))) { m_noCrashHandler = true; return; }
|
|
if(!lstrcmpi(param, _T("DebugCrashHandler"))) { m_debugCrashHandler = true; return; }
|
|
if(!lstrcmpi(param, _T("shared"))) { m_sharedInstance = true; return; }
|
|
#ifdef ENABLE_TESTS
|
|
if (!lstrcmpi(param, _T("noTests"))) { m_noTests = true; return; }
|
|
#endif
|
|
} else
|
|
{
|
|
m_fileNames.push_back(mpt::PathString::FromNative(param));
|
|
if(m_nShellCommand == FileNew) m_nShellCommand = FileOpen;
|
|
}
|
|
CCommandLineInfo::ParseParam(param, isFlag, isLast);
|
|
}
|
|
};
|
|
|
|
|
|
// Splash Screen
|
|
|
|
static void StartSplashScreen();
|
|
static void StopSplashScreen();
|
|
static void TimeoutSplashScreen();
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Midi Library
|
|
|
|
MidiLibrary CTrackApp::midiLibrary;
|
|
|
|
void CTrackApp::ImportMidiConfig(const mpt::PathString &filename, bool hideWarning)
|
|
{
|
|
if(filename.empty()) return;
|
|
|
|
if(CDLSBank::IsDLSBank(filename))
|
|
{
|
|
ConfirmAnswer result = cnfYes;
|
|
if(!hideWarning)
|
|
{
|
|
result = Reporting::Confirm("You are about to replace the current MIDI library:\n"
|
|
"Do you want to replace only the missing instruments? (recommended)",
|
|
"Warning", true);
|
|
}
|
|
if(result == cnfCancel) return;
|
|
const bool replaceAll = (result == cnfNo);
|
|
CDLSBank dlsbank;
|
|
if (dlsbank.Open(filename))
|
|
{
|
|
for(uint32 ins = 0; ins < 256; ins++)
|
|
{
|
|
if(replaceAll || midiLibrary[ins].empty())
|
|
{
|
|
uint32 prog = (ins < 128) ? ins : 0xFF;
|
|
uint32 key = (ins < 128) ? 0xFF : ins & 0x7F;
|
|
uint32 bank = (ins < 128) ? 0 : F_INSTRUMENT_DRUMS;
|
|
if (dlsbank.FindInstrument(ins >= 128, bank, prog, key))
|
|
{
|
|
midiLibrary[ins] = filename;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
IniFileSettingsContainer file(filename);
|
|
ImportMidiConfig(file, filename.GetPath());
|
|
}
|
|
|
|
|
|
static mpt::PathString GetUltraSoundPatchDir(SettingsContainer &file, const mpt::ustring &iniSection, const mpt::PathString &path, bool forgetSettings)
|
|
{
|
|
mpt::PathString patchDir = file.Read<mpt::PathString>(iniSection, U_("PatchDir"), {});
|
|
if(forgetSettings)
|
|
file.Forget(U_("Ultrasound"), U_("PatchDir"));
|
|
if(patchDir.empty() || patchDir == P_(".\\"))
|
|
patchDir = path;
|
|
if(!patchDir.empty())
|
|
patchDir.EnsureTrailingSlash();
|
|
return patchDir;
|
|
}
|
|
|
|
void CTrackApp::ImportMidiConfig(SettingsContainer &file, const mpt::PathString &path, bool forgetSettings)
|
|
{
|
|
const mpt::PathString patchDir = GetUltraSoundPatchDir(file, U_("Ultrasound"), path, forgetSettings);
|
|
for(uint32 prog = 0; prog < 256; prog++)
|
|
{
|
|
mpt::ustring key = MPT_UFORMAT("{}{}")((prog < 128) ? U_("Midi") : U_("Perc"), prog & 0x7F);
|
|
mpt::PathString filename = file.Read<mpt::PathString>(U_("Midi Library"), key, mpt::PathString());
|
|
// Check for ULTRASND.INI
|
|
if(filename.empty())
|
|
{
|
|
mpt::ustring section = (prog < 128) ? UL_("Melodic Patches") : UL_("Drum Patches");
|
|
key = mpt::ufmt::val(prog & 0x7f);
|
|
filename = file.Read<mpt::PathString>(section, key, mpt::PathString());
|
|
if(forgetSettings) file.Forget(section, key);
|
|
if(filename.empty())
|
|
{
|
|
section = (prog < 128) ? UL_("Melodic Bank 0") : UL_("Drum Bank 0");
|
|
filename = file.Read<mpt::PathString>(section, key, mpt::PathString());
|
|
if(forgetSettings) file.Forget(section, key);
|
|
}
|
|
const mpt::PathString localPatchDir = GetUltraSoundPatchDir(file, section, patchDir, forgetSettings);
|
|
if(!filename.empty())
|
|
{
|
|
filename = localPatchDir + filename + P_(".pat");
|
|
}
|
|
}
|
|
if(!filename.empty())
|
|
{
|
|
filename = theApp.PathInstallRelativeToAbsolute(filename);
|
|
midiLibrary[prog] = filename;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CTrackApp::ExportMidiConfig(const mpt::PathString &filename)
|
|
{
|
|
if(filename.empty()) return;
|
|
IniFileSettingsContainer file(filename);
|
|
ExportMidiConfig(file);
|
|
}
|
|
|
|
void CTrackApp::ExportMidiConfig(SettingsContainer &file)
|
|
{
|
|
for(uint32 prog = 0; prog < 256; prog++) if (!midiLibrary[prog].empty())
|
|
{
|
|
mpt::PathString szFileName = midiLibrary[prog];
|
|
|
|
if(!szFileName.empty())
|
|
{
|
|
if(theApp.IsPortableMode())
|
|
szFileName = theApp.PathAbsoluteToInstallRelative(szFileName);
|
|
|
|
mpt::ustring key = MPT_UFORMAT("{}{}")((prog < 128) ? U_("Midi") : U_("Perc"), prog & 0x7F);
|
|
file.Write<mpt::PathString>(U_("Midi Library"), key, szFileName);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// DLS Banks support
|
|
|
|
std::vector<std::unique_ptr<CDLSBank>> CTrackApp::gpDLSBanks;
|
|
|
|
|
|
struct CompareLessPathStringNoCase
|
|
{
|
|
inline bool operator()(const mpt::PathString &l, const mpt::PathString &r) const
|
|
{
|
|
return mpt::PathString::CompareNoCase(l, r) < 0;
|
|
}
|
|
};
|
|
|
|
std::future<std::vector<std::unique_ptr<CDLSBank>>> CTrackApp::LoadDefaultDLSBanks()
|
|
{
|
|
std::set<mpt::PathString, CompareLessPathStringNoCase> paths;
|
|
|
|
uint32 numBanks = theApp.GetSettings().Read<uint32>(U_("DLS Banks"), U_("NumBanks"), 0);
|
|
for(uint32 i = 0; i < numBanks; i++)
|
|
{
|
|
mpt::PathString path = theApp.GetSettings().Read<mpt::PathString>(U_("DLS Banks"), MPT_UFORMAT("Bank{}")(i + 1), mpt::PathString());
|
|
paths.insert(theApp.PathInstallRelativeToAbsolute(path));
|
|
}
|
|
|
|
HKEY key;
|
|
if(RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("Software\\Microsoft\\DirectMusic"), 0, KEY_READ, &key) == ERROR_SUCCESS)
|
|
{
|
|
DWORD dwRegType = REG_SZ;
|
|
DWORD dwSize = 0;
|
|
if(RegQueryValueEx(key, _T("GMFilePath"), NULL, &dwRegType, nullptr, &dwSize) == ERROR_SUCCESS && dwSize > 0)
|
|
{
|
|
std::vector<TCHAR> filenameT(dwSize / sizeof(TCHAR));
|
|
if(RegQueryValueEx(key, _T("GMFilePath"), NULL, &dwRegType, reinterpret_cast<LPBYTE>(filenameT.data()), &dwSize) == ERROR_SUCCESS)
|
|
{
|
|
mpt::winstring filenamestr = ParseMaybeNullTerminatedStringFromBufferWithSizeInBytes<mpt::winstring>(filenameT.data(), dwSize);
|
|
std::vector<TCHAR> filenameExpanded(::ExpandEnvironmentStrings(filenamestr.c_str(), nullptr, 0));
|
|
::ExpandEnvironmentStrings(filenamestr.c_str(), filenameExpanded.data(), static_cast<DWORD>(filenameExpanded.size()));
|
|
auto filename = mpt::PathString::FromNative(filenameExpanded.data());
|
|
ImportMidiConfig(filename, true);
|
|
paths.insert(std::move(filename));
|
|
}
|
|
}
|
|
RegCloseKey(key);
|
|
}
|
|
|
|
if(paths.empty())
|
|
return {};
|
|
|
|
return std::async(std::launch::async, [paths = std::move(paths)]()
|
|
{
|
|
std::vector<std::unique_ptr<CDLSBank>> banks;
|
|
banks.reserve(paths.size());
|
|
for(const auto &filename : paths)
|
|
{
|
|
if(filename.empty() || !CDLSBank::IsDLSBank(filename))
|
|
continue;
|
|
try
|
|
{
|
|
auto bank = std::make_unique<CDLSBank>();
|
|
if(bank->Open(filename))
|
|
{
|
|
banks.push_back(std::move(bank));
|
|
continue;
|
|
}
|
|
} catch(mpt::out_of_memory e)
|
|
{
|
|
mpt::delete_out_of_memory(e);
|
|
} catch(const std::exception &)
|
|
{
|
|
}
|
|
}
|
|
// Avoid the overhead of future::wait_for(0) until future::is_ready is finally non-experimental
|
|
theApp.m_scannedDlsBanksAvailable = true;
|
|
return banks;
|
|
});
|
|
}
|
|
|
|
|
|
void CTrackApp::SaveDefaultDLSBanks()
|
|
{
|
|
uint32 nBanks = 0;
|
|
for(const auto &bank : gpDLSBanks)
|
|
{
|
|
if(!bank || bank->GetFileName().empty())
|
|
continue;
|
|
|
|
mpt::PathString path = bank->GetFileName();
|
|
if(theApp.IsPortableMode())
|
|
{
|
|
path = theApp.PathAbsoluteToInstallRelative(path);
|
|
}
|
|
|
|
mpt::ustring key = MPT_UFORMAT("Bank{}")(nBanks + 1);
|
|
theApp.GetSettings().Write<mpt::PathString>(U_("DLS Banks"), key, path);
|
|
nBanks++;
|
|
|
|
}
|
|
theApp.GetSettings().Write<uint32>(U_("DLS Banks"), U_("NumBanks"), nBanks);
|
|
}
|
|
|
|
|
|
void CTrackApp::RemoveDLSBank(UINT nBank)
|
|
{
|
|
if(nBank < gpDLSBanks.size())
|
|
gpDLSBanks[nBank] = nullptr;
|
|
}
|
|
|
|
|
|
bool CTrackApp::AddDLSBank(const mpt::PathString &filename)
|
|
{
|
|
if(filename.empty() || !CDLSBank::IsDLSBank(filename)) return false;
|
|
// Check for dupes
|
|
for(const auto &bank : gpDLSBanks)
|
|
{
|
|
if(bank && !mpt::PathString::CompareNoCase(filename, bank->GetFileName()))
|
|
return true;
|
|
}
|
|
try
|
|
{
|
|
auto bank = std::make_unique<CDLSBank>();
|
|
if(bank->Open(filename))
|
|
{
|
|
gpDLSBanks.push_back(std::move(bank));
|
|
return true;
|
|
}
|
|
} catch(mpt::out_of_memory e)
|
|
{
|
|
mpt::delete_out_of_memory(e);
|
|
} catch(const std::exception &)
|
|
{
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
size_t CTrackApp::AddScannedDLSBanks()
|
|
{
|
|
if(!m_scannedDlsBanks.valid())
|
|
return 0;
|
|
|
|
size_t numAdded = 0;
|
|
auto scannedBanks = m_scannedDlsBanks.get();
|
|
gpDLSBanks.reserve(gpDLSBanks.size() + scannedBanks.size());
|
|
const size_t existingBanks = gpDLSBanks.size();
|
|
for(auto &bank : scannedBanks)
|
|
{
|
|
if(std::find_if(gpDLSBanks.begin(), gpDLSBanks.begin() + existingBanks, [&bank](const auto &other) { return other && *bank == *other; }) == gpDLSBanks.begin() + existingBanks)
|
|
{
|
|
gpDLSBanks.push_back(std::move(bank));
|
|
numAdded++;
|
|
}
|
|
}
|
|
return numAdded;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CTrackApp
|
|
|
|
MODTYPE CTrackApp::m_nDefaultDocType = MOD_TYPE_IT;
|
|
|
|
BEGIN_MESSAGE_MAP(CTrackApp, CWinApp)
|
|
//{{AFX_MSG_MAP(CTrackApp)
|
|
ON_COMMAND(ID_FILE_NEW, &CTrackApp::OnFileNew)
|
|
ON_COMMAND(ID_FILE_NEWMOD, &CTrackApp::OnFileNewMOD)
|
|
ON_COMMAND(ID_FILE_NEWS3M, &CTrackApp::OnFileNewS3M)
|
|
ON_COMMAND(ID_FILE_NEWXM, &CTrackApp::OnFileNewXM)
|
|
ON_COMMAND(ID_FILE_NEWIT, &CTrackApp::OnFileNewIT)
|
|
ON_COMMAND(ID_NEW_MPT, &CTrackApp::OnFileNewMPT)
|
|
ON_COMMAND(ID_FILE_OPEN, &CTrackApp::OnFileOpen)
|
|
ON_COMMAND(ID_FILE_CLOSEALL, &CTrackApp::OnFileCloseAll)
|
|
ON_COMMAND(ID_APP_ABOUT, &CTrackApp::OnAppAbout)
|
|
ON_UPDATE_COMMAND_UI(ID_FILE_CLOSEALL, &CTrackApp::OnUpdateAnyDocsOpen)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CTrackApp construction
|
|
|
|
CTrackApp::CTrackApp()
|
|
{
|
|
m_dwRestartManagerSupportFlags = AFX_RESTART_MANAGER_SUPPORT_RESTART | AFX_RESTART_MANAGER_REOPEN_PREVIOUS_FILES;
|
|
}
|
|
|
|
|
|
class OpenMPTDataRecoveryHandler
|
|
: public CDataRecoveryHandler
|
|
{
|
|
public:
|
|
OpenMPTDataRecoveryHandler(_In_ DWORD dwRestartManagerSupportFlags, _In_ int nAutosaveInterval)
|
|
: CDataRecoveryHandler(dwRestartManagerSupportFlags, nAutosaveInterval)
|
|
{
|
|
return;
|
|
}
|
|
~OpenMPTDataRecoveryHandler() override = default;
|
|
|
|
BOOL SaveOpenDocumentList() override
|
|
{
|
|
BOOL bRet = TRUE; // return FALSE if document list non-empty and not saved
|
|
|
|
POSITION posAutosave = m_mapDocNameToAutosaveName.GetStartPosition();
|
|
if (posAutosave != NULL)
|
|
{
|
|
bRet = FALSE;
|
|
|
|
// Save the open document list and associated autosave info to the registry
|
|
IniFileSettingsBackend ini(theApp.GetConfigPath() + P_("restart.") + mpt::PathString::FromCString(GetRestartIdentifier()) + P_(".ini"));
|
|
ini.ConvertToUnicode();
|
|
int32 count = 0;
|
|
while (posAutosave != NULL)
|
|
{
|
|
CString strDocument, strAutosave;
|
|
m_mapDocNameToAutosaveName.GetNextAssoc(posAutosave, strDocument, strAutosave);
|
|
|
|
ini.WriteSetting({ U_("RestartDocument"), mpt::ufmt::val(count) }, SettingValue(mpt::ToUnicode(strDocument)));
|
|
ini.WriteSetting({ U_("RestartAutosave"), mpt::ufmt::val(count) }, SettingValue(mpt::ToUnicode(strAutosave)));
|
|
count++;
|
|
}
|
|
ini.WriteSetting({ U_("Restart"), U_("Count") }, SettingValue(count));
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
BOOL ReadOpenDocumentList() override
|
|
{
|
|
BOOL bRet = FALSE; // return TRUE only if at least one document was found
|
|
|
|
{
|
|
IniFileSettingsBackend ini(theApp.GetConfigPath() + P_("restart.") + mpt::PathString::FromCString(GetRestartIdentifier()) + P_(".ini"));
|
|
int32 count = ini.ReadSetting({ U_("Restart"), U_("Count") }, SettingValue(0));
|
|
|
|
for(int32 index = 0; index < count; ++index)
|
|
{
|
|
mpt::ustring document = ini.ReadSetting({ U_("RestartDocument"), mpt::ufmt::val(index) }, SettingValue(U_("")));
|
|
mpt::ustring autosave = ini.ReadSetting({ U_("RestartAutosave"), mpt::ufmt::val(index) }, SettingValue(U_("")));
|
|
if(!document.empty())
|
|
{
|
|
m_mapDocNameToAutosaveName[mpt::ToCString(document)] = mpt::ToCString(autosave);
|
|
bRet = TRUE;
|
|
}
|
|
}
|
|
|
|
ini.RemoveSection(U_("Restart"));
|
|
ini.RemoveSection(U_("RestartDocument"));
|
|
ini.RemoveSection(U_("RestartAutosave"));
|
|
|
|
}
|
|
|
|
DeleteFile((theApp.GetConfigPath() + P_("restart.") + mpt::PathString::FromCString(GetRestartIdentifier()) + P_(".ini")).AsNative().c_str());
|
|
|
|
return bRet;
|
|
}
|
|
|
|
};
|
|
|
|
|
|
CDataRecoveryHandler *CTrackApp::GetDataRecoveryHandler()
|
|
{
|
|
static BOOL bTriedOnce = FALSE;
|
|
|
|
// Since the application restart and application recovery are supported only on Windows
|
|
// Vista and above, we don't need a recovery handler on Windows versions less than Vista.
|
|
if (SupportsRestartManager() || SupportsApplicationRecovery())
|
|
{
|
|
if (!bTriedOnce && m_pDataRecoveryHandler == NULL)
|
|
{
|
|
m_pDataRecoveryHandler = new OpenMPTDataRecoveryHandler(m_dwRestartManagerSupportFlags, m_nAutosaveInterval);
|
|
if (!m_pDataRecoveryHandler->Initialize())
|
|
{
|
|
delete m_pDataRecoveryHandler;
|
|
m_pDataRecoveryHandler = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
bTriedOnce = TRUE;
|
|
return m_pDataRecoveryHandler;
|
|
}
|
|
|
|
|
|
void CTrackApp::AddToRecentFileList(LPCTSTR lpszPathName)
|
|
{
|
|
AddToRecentFileList(mpt::PathString::FromCString(lpszPathName));
|
|
}
|
|
|
|
|
|
void CTrackApp::AddToRecentFileList(const mpt::PathString &path)
|
|
{
|
|
RemoveMruItem(path);
|
|
TrackerSettings::Instance().mruFiles.insert(TrackerSettings::Instance().mruFiles.begin(), path);
|
|
if(TrackerSettings::Instance().mruFiles.size() > TrackerSettings::Instance().mruListLength)
|
|
{
|
|
TrackerSettings::Instance().mruFiles.resize(TrackerSettings::Instance().mruListLength);
|
|
}
|
|
CMainFrame::GetMainFrame()->UpdateMRUList();
|
|
}
|
|
|
|
|
|
void CTrackApp::RemoveMruItem(const size_t item)
|
|
{
|
|
if(item < TrackerSettings::Instance().mruFiles.size())
|
|
{
|
|
TrackerSettings::Instance().mruFiles.erase(TrackerSettings::Instance().mruFiles.begin() + item);
|
|
CMainFrame::GetMainFrame()->UpdateMRUList();
|
|
}
|
|
}
|
|
|
|
|
|
void CTrackApp::RemoveMruItem(const mpt::PathString &path)
|
|
{
|
|
auto &mruFiles = TrackerSettings::Instance().mruFiles;
|
|
for(auto i = mruFiles.begin(); i != mruFiles.end(); i++)
|
|
{
|
|
if(!mpt::PathString::CompareNoCase(*i, path))
|
|
{
|
|
mruFiles.erase(i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CTrackApp initialization
|
|
|
|
|
|
namespace Tracker
|
|
{
|
|
mpt::recursive_mutex_with_lock_count & GetGlobalMutexRef()
|
|
{
|
|
return theApp.GetGlobalMutexRef();
|
|
}
|
|
} // namespace Tracker
|
|
|
|
|
|
class ComponentManagerSettings
|
|
: public IComponentManagerSettings
|
|
{
|
|
private:
|
|
TrackerSettings &conf;
|
|
mpt::PathString configPath;
|
|
public:
|
|
ComponentManagerSettings(TrackerSettings &conf, const mpt::PathString &configPath)
|
|
: conf(conf)
|
|
, configPath(configPath)
|
|
{
|
|
return;
|
|
}
|
|
bool LoadOnStartup() const override
|
|
{
|
|
return conf.ComponentsLoadOnStartup;
|
|
}
|
|
bool KeepLoaded() const override
|
|
{
|
|
return conf.ComponentsKeepLoaded;
|
|
}
|
|
bool IsBlocked(const std::string &key) const override
|
|
{
|
|
return conf.IsComponentBlocked(key);
|
|
}
|
|
mpt::PathString Path() const override
|
|
{
|
|
if(mpt::OS::Windows::Name(mpt::OS::Windows::GetProcessArchitecture()).empty())
|
|
{
|
|
return mpt::PathString();
|
|
}
|
|
return configPath + P_("Components\\") + mpt::PathString::FromUnicode(mpt::OS::Windows::Name(mpt::OS::Windows::GetProcessArchitecture())) + P_("\\");
|
|
}
|
|
};
|
|
|
|
|
|
// Move a config file called fileName from the App's directory (or one of its sub directories specified by subDir) to
|
|
// %APPDATA%. If specified, it will be renamed to newFileName. Existing files are never overwritten.
|
|
// Returns true on success.
|
|
bool CTrackApp::MoveConfigFile(const mpt::PathString &fileName, mpt::PathString subDir, mpt::PathString newFileName)
|
|
{
|
|
const mpt::PathString oldPath = GetInstallPath() + subDir + fileName;
|
|
mpt::PathString newPath = GetConfigPath() + subDir;
|
|
if(!newFileName.empty())
|
|
newPath += newFileName;
|
|
else
|
|
newPath += fileName;
|
|
|
|
if(!newPath.IsFile() && oldPath.IsFile())
|
|
{
|
|
return MoveFile(oldPath.AsNative().c_str(), newPath.AsNative().c_str()) != 0;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
// Set up paths were configuration data is written to. Set overridePortable to true if application's own directory should always be used.
|
|
void CTrackApp::SetupPaths(bool overridePortable)
|
|
{
|
|
|
|
// First, determine if the executable is installed in multi-arch mode or in the old standard mode.
|
|
bool modeMultiArch = false;
|
|
bool modeSourceProject = false;
|
|
const mpt::PathString exePath = mpt::GetExecutablePath();
|
|
auto exePathComponents = mpt::String::Split<mpt::ustring>(exePath.GetDir().WithoutTrailingSlash().ToUnicode(), P_("\\").ToUnicode());
|
|
if(exePathComponents.size() >= 2)
|
|
{
|
|
if(exePathComponents[exePathComponents.size()-1] == mpt::OS::Windows::Name(mpt::OS::Windows::GetProcessArchitecture()))
|
|
{
|
|
if(exePathComponents[exePathComponents.size()-2] == U_("bin"))
|
|
{
|
|
modeMultiArch = true;
|
|
}
|
|
}
|
|
}
|
|
// Check if we are running from the source tree.
|
|
if(!modeMultiArch && exePathComponents.size() >= 4)
|
|
{
|
|
if(exePathComponents[exePathComponents.size()-1] == mpt::OS::Windows::Name(mpt::OS::Windows::GetProcessArchitecture()))
|
|
{
|
|
if(exePathComponents[exePathComponents.size()-4] == U_("bin"))
|
|
{
|
|
modeSourceProject = true;
|
|
}
|
|
}
|
|
}
|
|
if(modeSourceProject)
|
|
{
|
|
m_InstallPath = mpt::GetAbsolutePath(exePath + P_("..\\") + P_("..\\") + P_("..\\") + P_("..\\"));
|
|
m_InstallBinPath = mpt::GetAbsolutePath(exePath + P_("..\\"));
|
|
m_InstallBinArchPath = exePath;
|
|
m_InstallPkgPath = mpt::GetAbsolutePath(exePath + P_("..\\") + P_("..\\") + P_("..\\") + P_("..\\packageTemplate\\"));
|
|
} else if(modeMultiArch)
|
|
{
|
|
m_InstallPath = mpt::GetAbsolutePath(exePath + P_("..\\") + P_("..\\"));
|
|
m_InstallBinPath = mpt::GetAbsolutePath(exePath + P_("..\\"));
|
|
m_InstallBinArchPath = exePath;
|
|
m_InstallPkgPath = mpt::GetAbsolutePath(exePath + P_("..\\") + P_("..\\"));
|
|
} else
|
|
{
|
|
m_InstallPath = exePath;
|
|
m_InstallBinPath = exePath;
|
|
m_InstallBinArchPath = exePath;
|
|
m_InstallPkgPath = exePath;
|
|
}
|
|
|
|
// Determine paths, portable mode, first run. Do not yet update any state.
|
|
mpt::PathString configPathPortable = (modeSourceProject ? exePath : m_InstallPath); // config path in portable mode
|
|
mpt::PathString configPathUser; // config path in default non-portable mode
|
|
{
|
|
// Try to find a nice directory where we should store our settings (default: %APPDATA%)
|
|
TCHAR dir[MAX_PATH] = { 0 };
|
|
if((SHGetFolderPath(NULL, CSIDL_APPDATA, NULL, SHGFP_TYPE_CURRENT, dir) == S_OK)
|
|
|| (SHGetFolderPath(NULL, CSIDL_MYDOCUMENTS, NULL, SHGFP_TYPE_CURRENT, dir) == S_OK))
|
|
{
|
|
// Store our app settings in %APPDATA% or "My Documents"
|
|
configPathUser = mpt::PathString::FromNative(dir) + P_("\\OpenMPT\\");
|
|
}
|
|
}
|
|
|
|
// Check if the user has configured portable mode.
|
|
bool configInstallPortable = false;
|
|
mpt::PathString portableFlagFilename = (configPathPortable + P_("OpenMPT.portable"));
|
|
bool configPortableFlag = portableFlagFilename.IsFile();
|
|
configInstallPortable = configInstallPortable || configPortableFlag;
|
|
// before 1.29.00.13:
|
|
configInstallPortable = configInstallPortable || (GetPrivateProfileInt(_T("Paths"), _T("UseAppDataDirectory"), 1, (configPathPortable + P_("mptrack.ini")).AsNative().c_str()) == 0);
|
|
// convert to new style
|
|
if(configInstallPortable && !configPortableFlag)
|
|
{
|
|
mpt::SafeOutputFile f(portableFlagFilename);
|
|
}
|
|
|
|
// Determine portable mode.
|
|
bool portableMode = overridePortable || configInstallPortable || configPathUser.empty();
|
|
|
|
// Update config dir
|
|
m_ConfigPath = portableMode ? configPathPortable : configPathUser;
|
|
|
|
// Set up default file locations
|
|
m_szConfigFileName = m_ConfigPath + P_("mptrack.ini"); // config file
|
|
m_szPluginCacheFileName = m_ConfigPath + P_("plugin.cache"); // plugin cache
|
|
|
|
// Force use of custom ini file rather than windowsDir\executableName.ini
|
|
if(m_pszProfileName)
|
|
{
|
|
free((void *)m_pszProfileName);
|
|
}
|
|
m_pszProfileName = _tcsdup(m_szConfigFileName.ToCString());
|
|
|
|
m_bInstallerMode = !modeSourceProject && !portableMode;
|
|
m_bPortableMode = portableMode;
|
|
m_bSourceTreeMode = modeSourceProject;
|
|
|
|
}
|
|
|
|
|
|
void CTrackApp::CreatePaths()
|
|
{
|
|
// Create missing diretories
|
|
if(!IsPortableMode())
|
|
{
|
|
if(!m_ConfigPath.IsDirectory())
|
|
{
|
|
CreateDirectory(m_ConfigPath.AsNative().c_str(), 0);
|
|
}
|
|
}
|
|
if(!(GetConfigPath() + P_("Components")).IsDirectory())
|
|
{
|
|
CreateDirectory((GetConfigPath() + P_("Components")).AsNative().c_str(), 0);
|
|
}
|
|
if(!(GetConfigPath() + P_("Components\\") + mpt::PathString::FromUnicode(mpt::OS::Windows::Name(mpt::OS::Windows::GetProcessArchitecture()))).IsDirectory())
|
|
{
|
|
CreateDirectory((GetConfigPath() + P_("Components\\") + mpt::PathString::FromUnicode(mpt::OS::Windows::Name(mpt::OS::Windows::GetProcessArchitecture()))).AsNative().c_str(), 0);
|
|
}
|
|
|
|
// Handle updates from old versions.
|
|
|
|
if(!IsPortableMode())
|
|
{
|
|
|
|
// Move the config files if they're still in the old place.
|
|
MoveConfigFile(P_("mptrack.ini"));
|
|
MoveConfigFile(P_("plugin.cache"));
|
|
|
|
// Import old tunings
|
|
const mpt::PathString oldTunings = GetInstallPath() + P_("tunings\\");
|
|
|
|
if(oldTunings.IsDirectory())
|
|
{
|
|
const mpt::PathString searchPattern = oldTunings + P_("*.*");
|
|
WIN32_FIND_DATA FindFileData;
|
|
HANDLE hFind;
|
|
hFind = FindFirstFile(searchPattern.AsNative().c_str(), &FindFileData);
|
|
if(hFind != INVALID_HANDLE_VALUE)
|
|
{
|
|
do
|
|
{
|
|
MoveConfigFile(mpt::PathString::FromNative(FindFileData.cFileName), P_("tunings\\"));
|
|
} while(FindNextFile(hFind, &FindFileData) != 0);
|
|
}
|
|
FindClose(hFind);
|
|
RemoveDirectory(oldTunings.AsNative().c_str());
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
#if !defined(MPT_BUILD_RETRO)
|
|
|
|
bool CTrackApp::CheckSystemSupport()
|
|
{
|
|
const mpt::ustring lf = U_("\n");
|
|
const mpt::ustring url = Build::GetURL(Build::Url::Download);
|
|
if(!BuildVariants::ProcessorCanRunCurrentBuild())
|
|
{
|
|
mpt::ustring text;
|
|
text += U_("Your CPU is too old to run this variant of OpenMPT.") + lf;
|
|
text += U_("OpenMPT will exit now.") + lf;
|
|
Reporting::Error(text, "OpenMPT");
|
|
return false;
|
|
}
|
|
if(BuildVariants::IsKnownSystem() && !BuildVariants::SystemCanRunCurrentBuild())
|
|
{
|
|
mpt::ustring text;
|
|
text += U_("Your system does not meet the minimum requirements for this variant of OpenMPT.") + lf;
|
|
if(mpt::OS::Windows::IsOriginal())
|
|
{
|
|
text += U_("OpenMPT will exit now.") + lf;
|
|
}
|
|
Reporting::Error(text, "OpenMPT");
|
|
if(mpt::OS::Windows::IsOriginal())
|
|
{
|
|
return false;
|
|
} else
|
|
{
|
|
return true; // may work though
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
#endif // !MPT_BUILD_RETRO
|
|
|
|
|
|
BOOL CTrackApp::InitInstanceEarly(CMPTCommandLineInfo &cmdInfo)
|
|
{
|
|
// The first step of InitInstance, always executed without any crash handler.
|
|
|
|
#ifndef UNICODE
|
|
if(MessageBox(NULL,
|
|
_T("STOP!!!") _T("\n")
|
|
_T("This is an ANSI (as opposed to a UNICODE) build of OpenMPT.") _T("\n")
|
|
_T("\n")
|
|
_T("ANSI builds are NOT SUPPORTED and WILL CAUSE CORRUPTION of the OpenMPT configuration and exhibit other unintended behaviour.") _T("\n")
|
|
_T("\n")
|
|
_T("Please use an official build of OpenMPT or compile 'OpenMPT.sln' instead of 'OpenMPT-ANSI.sln'.") _T("\n")
|
|
_T("\n")
|
|
_T("Continue starting OpenMPT anyway?") _T("\n"),
|
|
_T("OpenMPT"), MB_ICONSTOP | MB_YESNO| MB_DEFBUTTON2)
|
|
!= IDYES)
|
|
{
|
|
ExitProcess(1);
|
|
}
|
|
#endif
|
|
|
|
// Call the base class.
|
|
// This is required for MFC RestartManager integration.
|
|
if(!CWinApp::InitInstance())
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
#if MPT_COMPILER_MSVC
|
|
_CrtSetDebugFillThreshold(0); // Disable buffer filling in secure enhanced CRT functions.
|
|
#endif
|
|
|
|
// Avoid e.g. audio APIs trying to load wdmaud.drv from arbitrary working directory
|
|
::SetCurrentDirectory(mpt::GetExecutablePath().AsNative().c_str());
|
|
|
|
// Initialize OLE MFC support
|
|
BOOL oleinit = AfxOleInit();
|
|
ASSERT(oleinit != FALSE); // no MPT_ASSERT here!
|
|
|
|
// Parse command line for standard shell commands, DDE, file open
|
|
ParseCommandLine(cmdInfo);
|
|
|
|
// Set up paths to store configuration in
|
|
SetupPaths(cmdInfo.m_portable);
|
|
|
|
if(cmdInfo.m_sharedInstance && IPCWindow::SendToIPC(cmdInfo.m_fileNames))
|
|
{
|
|
ExitProcess(0);
|
|
}
|
|
|
|
// Initialize DocManager (for DDE)
|
|
// requires mpt::PathString
|
|
ASSERT(nullptr == m_pDocManager); // no MPT_ASSERT here!
|
|
m_pDocManager = new CModDocManager();
|
|
|
|
if(IsDebuggerPresent() && cmdInfo.m_debugCrashHandler)
|
|
{
|
|
ExceptionHandler::useAnyCrashHandler = true;
|
|
ExceptionHandler::useImplicitFallbackSEH = false;
|
|
ExceptionHandler::useExplicitSEH = true;
|
|
ExceptionHandler::handleStdTerminate = true;
|
|
ExceptionHandler::handleMfcExceptions = true;
|
|
ExceptionHandler::debugExceptionHandler = true;
|
|
} else if(IsDebuggerPresent() || cmdInfo.m_noCrashHandler)
|
|
{
|
|
ExceptionHandler::useAnyCrashHandler = false;
|
|
ExceptionHandler::useImplicitFallbackSEH = false;
|
|
ExceptionHandler::useExplicitSEH = false;
|
|
ExceptionHandler::handleStdTerminate = false;
|
|
ExceptionHandler::handleMfcExceptions = false;
|
|
ExceptionHandler::debugExceptionHandler = false;
|
|
} else
|
|
{
|
|
ExceptionHandler::useAnyCrashHandler = true;
|
|
ExceptionHandler::useImplicitFallbackSEH = true;
|
|
ExceptionHandler::useExplicitSEH = true;
|
|
ExceptionHandler::handleStdTerminate = true;
|
|
ExceptionHandler::handleMfcExceptions = true;
|
|
ExceptionHandler::debugExceptionHandler = false;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL CTrackApp::InitInstanceImpl(CMPTCommandLineInfo &cmdInfo)
|
|
{
|
|
|
|
m_GuiThreadId = GetCurrentThreadId();
|
|
|
|
mpt::log::Trace::SetThreadId(mpt::log::Trace::ThreadKindGUI, m_GuiThreadId);
|
|
|
|
if(ExceptionHandler::useAnyCrashHandler)
|
|
{
|
|
ExceptionHandler::Register();
|
|
}
|
|
|
|
// Start loading
|
|
BeginWaitCursor();
|
|
|
|
MPT_LOG_GLOBAL(LogInformation, "", U_("OpenMPT Start"));
|
|
|
|
// create the tracker-global random device
|
|
m_RD = std::make_unique<mpt::random_device>();
|
|
// make the device available to non-tracker-only code
|
|
mpt::set_global_random_device(m_RD.get());
|
|
// create and seed the traker-global best PRNG with the random device
|
|
m_PRNG = std::make_unique<mpt::thread_safe_prng<mpt::default_prng> >(mpt::make_prng<mpt::default_prng>(RandomDevice()));
|
|
// make the best PRNG available to non-tracker-only code
|
|
mpt::set_global_prng(m_PRNG.get());
|
|
// additionally, seed the C rand() PRNG, just in case any third party library calls rand()
|
|
mpt::crand::reseed(RandomDevice());
|
|
|
|
m_Gdiplus = std::make_unique<GdiplusRAII>();
|
|
|
|
if(cmdInfo.m_noWine)
|
|
{
|
|
mpt::OS::Windows::PreventWineDetection();
|
|
}
|
|
|
|
#ifdef MPT_ENABLE_ARCH_INTRINSICS
|
|
if(!cmdInfo.m_noAssembly)
|
|
{
|
|
CPU::EnableAvailableFeatures();
|
|
}
|
|
#endif // MPT_ENABLE_ARCH_INTRINSICS
|
|
|
|
if(mpt::OS::Windows::IsWine())
|
|
{
|
|
SetWineVersion(std::make_shared<mpt::OS::Wine::VersionContext>());
|
|
}
|
|
|
|
// Create paths to store configuration in
|
|
CreatePaths();
|
|
|
|
m_pSettingsIniFile = new IniFileSettingsBackend(m_szConfigFileName);
|
|
m_pSettings = new SettingsContainer(m_pSettingsIniFile);
|
|
|
|
m_pDebugSettings = new DebugSettings(*m_pSettings);
|
|
|
|
m_pTrackerSettings = new TrackerSettings(*m_pSettings);
|
|
|
|
MPT_LOG_GLOBAL(LogInformation, "", U_("OpenMPT settings initialized."));
|
|
|
|
if(ExceptionHandler::useAnyCrashHandler)
|
|
{
|
|
ExceptionHandler::ConfigureSystemHandler();
|
|
}
|
|
|
|
if(TrackerSettings::Instance().MiscUseSingleInstance && IPCWindow::SendToIPC(cmdInfo.m_fileNames))
|
|
{
|
|
ExitProcess(0);
|
|
}
|
|
|
|
IPCWindow::Open(m_hInstance);
|
|
|
|
m_pSongSettingsIniFile = new IniFileSettingsBackend(GetConfigPath() + P_("SongSettings.ini"));
|
|
m_pSongSettings = new SettingsContainer(m_pSongSettingsIniFile);
|
|
|
|
m_pComponentManagerSettings = new ComponentManagerSettings(TrackerSettings::Instance(), GetConfigPath());
|
|
|
|
m_pPluginCache = new IniFileSettingsContainer(m_szPluginCacheFileName);
|
|
|
|
// Load standard INI file options (without MRU)
|
|
// requires SetupPaths+CreatePaths called
|
|
LoadStdProfileSettings(0);
|
|
|
|
// Set process priority class
|
|
#ifndef _DEBUG
|
|
SetPriorityClass(GetCurrentProcess(), TrackerSettings::Instance().MiscProcessPriorityClass);
|
|
#endif
|
|
|
|
// Dynamic DPI-awareness. Some users might want to disable DPI-awareness because of their DPI-unaware VST plugins.
|
|
bool setDPI = false;
|
|
// For Windows 10, Creators Update (1703) and newer
|
|
{
|
|
mpt::Library user32(mpt::LibraryPath::System(P_("user32")));
|
|
if (user32.IsValid())
|
|
{
|
|
enum MPT_DPI_AWARENESS_CONTEXT
|
|
{
|
|
MPT_DPI_AWARENESS_CONTEXT_UNAWARE = -1,
|
|
MPT_DPI_AWARENESS_CONTEXT_SYSTEM_AWARE = -2,
|
|
MPT_DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE = -3,
|
|
MPT_DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2 = -4,
|
|
MPT_DPI_AWARENESS_CONTEXT_UNAWARE_GDISCALED = -5, // 1809 update and newer
|
|
};
|
|
using PSETPROCESSDPIAWARENESSCONTEXT = BOOL(WINAPI *)(HANDLE);
|
|
PSETPROCESSDPIAWARENESSCONTEXT SetProcessDpiAwarenessContext = nullptr;
|
|
if(user32.Bind(SetProcessDpiAwarenessContext, "SetProcessDpiAwarenessContext"))
|
|
{
|
|
if (TrackerSettings::Instance().highResUI)
|
|
{
|
|
setDPI = (SetProcessDpiAwarenessContext(HANDLE(MPT_DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2)) == TRUE);
|
|
} else
|
|
{
|
|
if (SetProcessDpiAwarenessContext(HANDLE(MPT_DPI_AWARENESS_CONTEXT_UNAWARE_GDISCALED)) == TRUE)
|
|
setDPI = true;
|
|
else
|
|
setDPI = (SetProcessDpiAwarenessContext(HANDLE(MPT_DPI_AWARENESS_CONTEXT_UNAWARE)) == TRUE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// For Windows 8.1 and newer
|
|
if(!setDPI)
|
|
{
|
|
mpt::Library shcore(mpt::LibraryPath::System(P_("SHCore")));
|
|
if(shcore.IsValid())
|
|
{
|
|
using PSETPROCESSDPIAWARENESS = HRESULT (WINAPI *)(int);
|
|
PSETPROCESSDPIAWARENESS SetProcessDPIAwareness = nullptr;
|
|
if(shcore.Bind(SetProcessDPIAwareness, "SetProcessDpiAwareness"))
|
|
{
|
|
setDPI = (SetProcessDPIAwareness(TrackerSettings::Instance().highResUI ? 2 : 0) == S_OK);
|
|
}
|
|
}
|
|
}
|
|
// For Vista and newer
|
|
if(!setDPI && TrackerSettings::Instance().highResUI)
|
|
{
|
|
mpt::Library user32(mpt::LibraryPath::System(P_("user32")));
|
|
if(user32.IsValid())
|
|
{
|
|
using PSETPROCESSDPIAWARE = BOOL (WINAPI *)();
|
|
PSETPROCESSDPIAWARE SetProcessDPIAware = nullptr;
|
|
if(user32.Bind(SetProcessDPIAware, "SetProcessDPIAware"))
|
|
{
|
|
SetProcessDPIAware();
|
|
}
|
|
}
|
|
}
|
|
|
|
// create main MDI Frame window
|
|
CMainFrame* pMainFrame = new CMainFrame();
|
|
if(!pMainFrame->LoadFrame(IDR_MAINFRAME)) return FALSE;
|
|
m_pMainWnd = pMainFrame;
|
|
|
|
// Show splash screen
|
|
if(cmdInfo.m_bShowSplash && TrackerSettings::Instance().m_ShowSplashScreen)
|
|
{
|
|
StartSplashScreen();
|
|
}
|
|
|
|
// create component manager
|
|
ComponentManager::Init(*m_pComponentManagerSettings);
|
|
|
|
// load components
|
|
ComponentManager::Instance()->Startup();
|
|
|
|
// Wine Support
|
|
if(mpt::OS::Windows::IsWine())
|
|
{
|
|
WineIntegration::Initialize();
|
|
WineIntegration::Load();
|
|
}
|
|
|
|
// Register document templates
|
|
m_pModTemplate = new CModDocTemplate(
|
|
IDR_MODULETYPE,
|
|
RUNTIME_CLASS(CModDoc),
|
|
RUNTIME_CLASS(CChildFrame), // custom MDI child frame
|
|
RUNTIME_CLASS(CModControlView));
|
|
AddDocTemplate(m_pModTemplate);
|
|
|
|
// Load Midi Library
|
|
ImportMidiConfig(theApp.GetSettings(), {}, true);
|
|
|
|
// Enable DDE Execute open
|
|
// requires m_pDocManager
|
|
EnableShellOpen();
|
|
|
|
// Enable drag/drop open
|
|
m_pMainWnd->DragAcceptFiles();
|
|
|
|
// Load sound APIs
|
|
// requires TrackerSettings
|
|
m_pAllSoundDeviceComponents = std::make_unique<AllSoundDeviceComponents>();
|
|
auto GetSysInfo = [&]()
|
|
{
|
|
if(mpt::OS::Windows::IsWine())
|
|
{
|
|
return SoundDevice::SysInfo(mpt::osinfo::get_class(), mpt::OS::Windows::Version::Current(), mpt::OS::Windows::IsWine(), GetWineVersion()->HostClass(), GetWineVersion()->Version());
|
|
}
|
|
return SoundDevice::SysInfo(mpt::osinfo::get_class(), mpt::OS::Windows::Version::Current(), mpt::OS::Windows::IsWine(), mpt::osinfo::osclass::Unknown, mpt::osinfo::windows::wine::version());
|
|
};
|
|
SoundDevice::SysInfo sysInfo = GetSysInfo();
|
|
SoundDevice::AppInfo appInfo;
|
|
appInfo.SetName(U_("OpenMPT"));
|
|
appInfo.SetHWND(*m_pMainWnd);
|
|
appInfo.BoostedThreadPriorityXP = TrackerSettings::Instance().SoundBoostedThreadPriority;
|
|
appInfo.BoostedThreadMMCSSClassVista = TrackerSettings::Instance().SoundBoostedThreadMMCSSClass;
|
|
appInfo.BoostedThreadRealtimePosix = TrackerSettings::Instance().SoundBoostedThreadRealtimePosix;
|
|
appInfo.BoostedThreadNicenessPosix = TrackerSettings::Instance().SoundBoostedThreadNicenessPosix;
|
|
appInfo.BoostedThreadRtprioPosix = TrackerSettings::Instance().SoundBoostedThreadRtprioPosix;
|
|
appInfo.MaskDriverCrashes = TrackerSettings::Instance().SoundMaskDriverCrashes;
|
|
appInfo.AllowDeferredProcessing = TrackerSettings::Instance().SoundAllowDeferredProcessing;
|
|
std::vector<std::shared_ptr<SoundDevice::IDevicesEnumerator>> deviceEnumerators = SoundDevice::Manager::GetEnabledEnumerators(*m_pAllSoundDeviceComponents);
|
|
deviceEnumerators.push_back(std::static_pointer_cast<SoundDevice::IDevicesEnumerator>(std::make_shared<SoundDevice::DevicesEnumerator<SoundDevice::SoundDeviceStub>>()));
|
|
m_pSoundDevicesManager = std::make_unique<SoundDevice::Manager>(m_GlobalLogger, sysInfo, appInfo, std::move(deviceEnumerators));
|
|
m_pTrackerSettings->MigrateOldSoundDeviceSettings(*m_pSoundDevicesManager);
|
|
|
|
// Set default note names
|
|
CSoundFile::SetDefaultNoteNames();
|
|
|
|
// Load DLS Banks
|
|
if (!cmdInfo.m_noDls)
|
|
m_scannedDlsBanks = LoadDefaultDLSBanks();
|
|
|
|
// Initialize Plugins
|
|
if (!cmdInfo.m_noPlugins) InitializeDXPlugins();
|
|
|
|
// Initialize CMainFrame
|
|
pMainFrame->Initialize();
|
|
InitCommonControls();
|
|
pMainFrame->m_InputHandler->UpdateMainMenu();
|
|
|
|
// Dispatch commands specified on the command line
|
|
if(cmdInfo.m_nShellCommand == CCommandLineInfo::FileNew)
|
|
{
|
|
// When not asked to open any existing file,
|
|
// we do not want to open an empty new one on startup.
|
|
cmdInfo.m_nShellCommand = CCommandLineInfo::FileNothing;
|
|
}
|
|
bool shellSuccess = false;
|
|
if(cmdInfo.m_fileNames.empty())
|
|
{
|
|
shellSuccess = ProcessShellCommand(cmdInfo) != FALSE;
|
|
} else
|
|
{
|
|
cmdInfo.m_nShellCommand = CCommandLineInfo::FileOpen;
|
|
for(const auto &filename : cmdInfo.m_fileNames)
|
|
{
|
|
cmdInfo.m_strFileName = filename.ToCString();
|
|
shellSuccess |= ProcessShellCommand(cmdInfo) != FALSE;
|
|
}
|
|
}
|
|
if(!shellSuccess)
|
|
{
|
|
EndWaitCursor();
|
|
StopSplashScreen();
|
|
return FALSE;
|
|
}
|
|
|
|
pMainFrame->ShowWindow(m_nCmdShow);
|
|
pMainFrame->UpdateWindow();
|
|
|
|
EndWaitCursor();
|
|
|
|
|
|
// Perform startup tasks.
|
|
|
|
#if !defined(MPT_BUILD_RETRO)
|
|
// Check whether we are running the best build for the given system.
|
|
if(!cmdInfo.m_noSysCheck)
|
|
{
|
|
if(!CheckSystemSupport())
|
|
{
|
|
StopSplashScreen();
|
|
return FALSE;
|
|
}
|
|
}
|
|
#endif // !MPT_BUILD_RETRO
|
|
|
|
if(TrackerSettings::Instance().FirstRun)
|
|
{
|
|
// On high-DPI devices, automatically upscale pattern font
|
|
FontSetting font = TrackerSettings::Instance().patternFont;
|
|
font.size = Clamp(Util::GetDPIy(m_pMainWnd->m_hWnd) / 96 - 1, 0, 9);
|
|
TrackerSettings::Instance().patternFont = font;
|
|
new WelcomeDlg(m_pMainWnd);
|
|
} else
|
|
{
|
|
#if !defined(MPT_BUILD_RETRO)
|
|
bool deprecatedSoundDevice = GetSoundDevicesManager()->FindDeviceInfo(TrackerSettings::Instance().GetSoundDeviceIdentifier()).IsDeprecated();
|
|
bool showSettings = deprecatedSoundDevice && !TrackerSettings::Instance().m_SoundDeprecatedDeviceWarningShown && (Reporting::Confirm(
|
|
U_("You have currently selected a sound device which is deprecated. MME/WaveOut support will be removed in a future OpenMPT version.\n") +
|
|
U_("The recommended sound device type is WASAPI.\n") +
|
|
U_("Do you want to change your sound device settings now?"),
|
|
U_("OpenMPT - Deprecated sound device")
|
|
) == cnfYes);
|
|
if(showSettings)
|
|
{
|
|
TrackerSettings::Instance().m_SoundDeprecatedDeviceWarningShown = true;
|
|
m_pMainWnd->PostMessage(WM_COMMAND, ID_VIEW_OPTIONS);
|
|
}
|
|
#endif // !MPT_BUILD_RETRO
|
|
}
|
|
|
|
#ifdef ENABLE_TESTS
|
|
if(!cmdInfo.m_noTests)
|
|
Test::DoTests();
|
|
#endif
|
|
|
|
if(TrackerSettings::Instance().m_SoundSettingsOpenDeviceAtStartup)
|
|
{
|
|
pMainFrame->InitPreview();
|
|
pMainFrame->PreparePreview(NOTE_NOTECUT, 0);
|
|
pMainFrame->PlayPreview();
|
|
}
|
|
|
|
if(!TrackerSettings::Instance().FirstRun)
|
|
{
|
|
#if defined(MPT_ENABLE_UPDATE)
|
|
if(CUpdateCheck::IsSuitableUpdateMoment())
|
|
{
|
|
CUpdateCheck::DoAutoUpdateCheck();
|
|
}
|
|
#endif // MPT_ENABLE_UPDATE
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL CTrackApp::InitInstance()
|
|
{
|
|
CMPTCommandLineInfo cmdInfo;
|
|
if(!InitInstanceEarly(cmdInfo))
|
|
{
|
|
return FALSE;
|
|
}
|
|
return InitInstanceLate(cmdInfo);
|
|
}
|
|
|
|
|
|
BOOL CTrackApp::InitInstanceLate(CMPTCommandLineInfo &cmdInfo)
|
|
{
|
|
BOOL result = FALSE;
|
|
if(ExceptionHandler::useExplicitSEH)
|
|
{
|
|
// https://support.microsoft.com/en-us/kb/173652
|
|
__try
|
|
{
|
|
result = InitInstanceImpl(cmdInfo);
|
|
} __except(ExceptionHandler::ExceptionFilter(GetExceptionInformation()))
|
|
{
|
|
std::abort();
|
|
}
|
|
} else
|
|
{
|
|
result = InitInstanceImpl(cmdInfo);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
int CTrackApp::Run()
|
|
{
|
|
int result = 255;
|
|
if(ExceptionHandler::useExplicitSEH)
|
|
{
|
|
// https://support.microsoft.com/en-us/kb/173652
|
|
__try
|
|
{
|
|
result = CWinApp::Run();
|
|
} __except(ExceptionHandler::ExceptionFilter(GetExceptionInformation()))
|
|
{
|
|
std::abort();
|
|
}
|
|
} else
|
|
{
|
|
result = CWinApp::Run();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
LRESULT CTrackApp::ProcessWndProcException(CException * e, const MSG * pMsg)
|
|
{
|
|
if(ExceptionHandler::handleMfcExceptions)
|
|
{
|
|
LRESULT result = 0L; // as per documentation
|
|
if(pMsg)
|
|
{
|
|
if(pMsg->message == WM_COMMAND)
|
|
{
|
|
result = (LRESULT)TRUE; // as per documentation
|
|
}
|
|
}
|
|
if(dynamic_cast<CMemoryException*>(e))
|
|
{
|
|
e->ReportError();
|
|
//ExceptionHandler::UnhandledMFCException(e, pMsg);
|
|
} else
|
|
{
|
|
ExceptionHandler::UnhandledMFCException(e, pMsg);
|
|
}
|
|
return result;
|
|
} else
|
|
{
|
|
return CWinApp::ProcessWndProcException(e, pMsg);
|
|
}
|
|
}
|
|
|
|
|
|
int CTrackApp::ExitInstance()
|
|
{
|
|
int result = 0;
|
|
if(ExceptionHandler::useExplicitSEH)
|
|
{
|
|
// https://support.microsoft.com/en-us/kb/173652
|
|
__try
|
|
{
|
|
result = ExitInstanceImpl();
|
|
} __except(ExceptionHandler::ExceptionFilter(GetExceptionInformation()))
|
|
{
|
|
std::abort();
|
|
}
|
|
} else
|
|
{
|
|
result = ExitInstanceImpl();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
int CTrackApp::ExitInstanceImpl()
|
|
{
|
|
IPCWindow::Close();
|
|
|
|
m_pSoundDevicesManager = nullptr;
|
|
m_pAllSoundDeviceComponents = nullptr;
|
|
ExportMidiConfig(theApp.GetSettings());
|
|
AddScannedDLSBanks();
|
|
SaveDefaultDLSBanks();
|
|
gpDLSBanks.clear();
|
|
|
|
// Uninitialize Plugins
|
|
UninitializeDXPlugins();
|
|
|
|
ComponentManager::Release();
|
|
|
|
delete m_pPluginCache;
|
|
m_pPluginCache = nullptr;
|
|
delete m_pComponentManagerSettings;
|
|
m_pComponentManagerSettings = nullptr;
|
|
delete m_pTrackerSettings;
|
|
m_pTrackerSettings = nullptr;
|
|
delete m_pDebugSettings;
|
|
m_pDebugSettings = nullptr;
|
|
delete m_pSettings;
|
|
m_pSettings = nullptr;
|
|
delete m_pSettingsIniFile;
|
|
m_pSettingsIniFile = nullptr;
|
|
delete m_pSongSettings;
|
|
m_pSongSettings = nullptr;
|
|
delete m_pSongSettingsIniFile;
|
|
m_pSongSettingsIniFile = nullptr;
|
|
|
|
if(mpt::OS::Windows::IsWine())
|
|
{
|
|
SetWineVersion(nullptr);
|
|
}
|
|
|
|
m_Gdiplus.reset();
|
|
|
|
mpt::set_global_prng(nullptr);
|
|
m_PRNG.reset();
|
|
mpt::set_global_random_device(nullptr);
|
|
m_RD.reset();
|
|
|
|
if(ExceptionHandler::useAnyCrashHandler)
|
|
{
|
|
ExceptionHandler::UnconfigureSystemHandler();
|
|
ExceptionHandler::Unregister();
|
|
}
|
|
|
|
return CWinApp::ExitInstance();
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// App Messages
|
|
|
|
|
|
CModDoc *CTrackApp::NewDocument(MODTYPE newType)
|
|
{
|
|
// Build from template
|
|
if(newType == MOD_TYPE_NONE)
|
|
{
|
|
const mpt::PathString templateFile = TrackerSettings::Instance().defaultTemplateFile;
|
|
if(TrackerSettings::Instance().defaultNewFileAction == nfDefaultTemplate && !templateFile.empty())
|
|
{
|
|
// Template file can be either a filename inside one of the preset and user TemplateModules folders, or a full path.
|
|
const mpt::PathString dirs[] = { GetConfigPath() + P_("TemplateModules\\"), GetInstallPath() + P_("TemplateModules\\"), mpt::PathString() };
|
|
for(const auto &dir : dirs)
|
|
{
|
|
if((dir + templateFile).IsFile())
|
|
{
|
|
if(CModDoc *modDoc = static_cast<CModDoc *>(m_pModTemplate->OpenTemplateFile(dir + templateFile)))
|
|
{
|
|
return modDoc;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Default module type
|
|
newType = TrackerSettings::Instance().defaultModType;
|
|
|
|
// Get active document to make the new module of the same type
|
|
CModDoc *pModDoc = CMainFrame::GetMainFrame()->GetActiveDoc();
|
|
if(pModDoc != nullptr && TrackerSettings::Instance().defaultNewFileAction == nfSameAsCurrent)
|
|
{
|
|
newType = pModDoc->GetSoundFile().GetBestSaveFormat();
|
|
}
|
|
}
|
|
|
|
SetDefaultDocType(newType);
|
|
return static_cast<CModDoc *>(m_pModTemplate->OpenDocumentFile(_T("")));
|
|
}
|
|
|
|
|
|
void CTrackApp::OpenModulesDialog(std::vector<mpt::PathString> &files, const mpt::PathString &overridePath)
|
|
{
|
|
files.clear();
|
|
|
|
static constexpr std::string_view commonExts[] = {"mod", "s3m", "xm", "it", "mptm", "mo3", "oxm", "nst", "stk", "m15", "pt36", "mid", "rmi", "smf", "wav", "mdz", "s3z", "xmz", "itz", "mdr"};
|
|
std::string exts, extsWithoutCommon;
|
|
for(const auto &ext : CSoundFile::GetSupportedExtensions(true))
|
|
{
|
|
const auto filter = std::string("*.") + ext + std::string(";");
|
|
exts += filter;
|
|
if(!mpt::contains(commonExts, ext))
|
|
extsWithoutCommon += filter;
|
|
}
|
|
|
|
static int nFilterIndex = 0;
|
|
FileDialog dlg = OpenFileDialog()
|
|
.AllowMultiSelect()
|
|
.ExtensionFilter("All Modules (*.mptm,*.mod,*.xm,*.s3m,*.it,...)|" + exts + ";mod.*"
|
|
"|"
|
|
"Compressed Modules (*.mdz,*.s3z,*.xmz,*.itz,*.mo3,*.oxm,...)|*.mdz;*.s3z;*.xmz;*.itz;*.mdr;*.zip;*.rar;*.lha;*.pma;*.lzs;*.gz;*.mo3;*.oxm"
|
|
"|"
|
|
"ProTracker Modules (*.mod,*.nst)|*.mod;mod.*;*.mdz;*.nst;*.m15;*.stk;*.pt36|"
|
|
"Scream Tracker Modules (*.s3m,*.stm)|*.s3m;*.stm;*.s3z;*.stx|"
|
|
"FastTracker Modules (*.xm)|*.xm;*.xmz|"
|
|
"Impulse Tracker Modules (*.it)|*.it;*.itz|"
|
|
"OpenMPT Modules (*.mptm)|*.mptm;*.mptmz|"
|
|
"Other Modules (*.mtm,*.okt,*.mdl,*.669,*.far,...)|" + extsWithoutCommon + "|"
|
|
"Wave Files (*.wav)|*.wav|"
|
|
"MIDI Files (*.mid,*.rmi)|*.mid;*.rmi;*.smf|"
|
|
"All Files (*.*)|*.*||")
|
|
.WorkingDirectory(overridePath.empty() ? TrackerSettings::Instance().PathSongs.GetWorkingDir() : overridePath)
|
|
.FilterIndex(&nFilterIndex);
|
|
if(!dlg.Show()) return;
|
|
|
|
if(overridePath.empty())
|
|
TrackerSettings::Instance().PathSongs.SetWorkingDir(dlg.GetWorkingDirectory());
|
|
|
|
files = dlg.GetFilenames();
|
|
}
|
|
|
|
|
|
void CTrackApp::OnFileOpen()
|
|
{
|
|
FileDialog::PathList files;
|
|
OpenModulesDialog(files);
|
|
for(const auto &file : files)
|
|
{
|
|
OpenDocumentFile(file.ToCString());
|
|
}
|
|
}
|
|
|
|
|
|
// App command to run the dialog
|
|
void CTrackApp::OnAppAbout()
|
|
{
|
|
if (CAboutDlg::instance) return;
|
|
CAboutDlg::instance = new CAboutDlg();
|
|
CAboutDlg::instance->Create(IDD_ABOUTBOX, m_pMainWnd);
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Splash Screen
|
|
|
|
class CSplashScreen: public CDialog
|
|
{
|
|
protected:
|
|
std::unique_ptr<Gdiplus::Image> m_Image;
|
|
|
|
public:
|
|
~CSplashScreen();
|
|
BOOL OnInitDialog() override;
|
|
void OnOK() override;
|
|
void OnCancel() override { OnOK(); }
|
|
void OnPaint();
|
|
BOOL OnEraseBkgnd(CDC *) { return TRUE; }
|
|
|
|
DECLARE_MESSAGE_MAP()
|
|
};
|
|
|
|
BEGIN_MESSAGE_MAP(CSplashScreen, CDialog)
|
|
ON_WM_PAINT()
|
|
ON_WM_ERASEBKGND()
|
|
END_MESSAGE_MAP()
|
|
|
|
static CSplashScreen *gpSplashScreen = NULL;
|
|
|
|
static DWORD64 gSplashScreenStartTime = 0;
|
|
|
|
|
|
CSplashScreen::~CSplashScreen()
|
|
{
|
|
gpSplashScreen = nullptr;
|
|
}
|
|
|
|
|
|
void CSplashScreen::OnPaint()
|
|
{
|
|
CPaintDC dc(this);
|
|
Gdiplus::Graphics gfx(dc);
|
|
|
|
CRect rect;
|
|
GetClientRect(&rect);
|
|
gfx.SetInterpolationMode(Gdiplus::InterpolationModeHighQuality);
|
|
gfx.SetSmoothingMode(Gdiplus::SmoothingModeHighQuality);
|
|
gfx.DrawImage(m_Image.get(), 0, 0, rect.right, rect.bottom);
|
|
|
|
CDialog::OnPaint();
|
|
}
|
|
|
|
|
|
BOOL CSplashScreen::OnInitDialog()
|
|
{
|
|
CDialog::OnInitDialog();
|
|
|
|
try
|
|
{
|
|
m_Image = GDIP::LoadPixelImage(GetResource(MAKEINTRESOURCE(IDB_SPLASHNOFOLDFIN), _T("PNG")));
|
|
} catch(const bad_image &)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
CRect rect;
|
|
GetWindowRect(&rect);
|
|
const int width = Util::ScalePixels(m_Image->GetWidth(), m_hWnd) / 2;
|
|
const int height = Util::ScalePixels(m_Image->GetHeight(), m_hWnd) / 2;
|
|
SetWindowPos(nullptr,
|
|
rect.left - ((width - rect.Width()) / 2),
|
|
rect.top - ((height - rect.Height()) / 2),
|
|
width,
|
|
height,
|
|
SWP_NOZORDER | SWP_NOCOPYBITS);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void CSplashScreen::OnOK()
|
|
{
|
|
StopSplashScreen();
|
|
}
|
|
|
|
|
|
static void StartSplashScreen()
|
|
{
|
|
if(!gpSplashScreen)
|
|
{
|
|
gpSplashScreen = new CSplashScreen();
|
|
gpSplashScreen->Create(IDD_SPLASHSCREEN, theApp.m_pMainWnd);
|
|
gpSplashScreen->ShowWindow(SW_SHOW);
|
|
gpSplashScreen->UpdateWindow();
|
|
gpSplashScreen->BeginWaitCursor();
|
|
gSplashScreenStartTime = Util::GetTickCount64();
|
|
}
|
|
}
|
|
|
|
|
|
static void StopSplashScreen()
|
|
{
|
|
if(gpSplashScreen)
|
|
{
|
|
gpSplashScreen->EndWaitCursor();
|
|
gpSplashScreen->DestroyWindow();
|
|
delete gpSplashScreen;
|
|
gpSplashScreen = nullptr;
|
|
}
|
|
}
|
|
|
|
|
|
static void TimeoutSplashScreen()
|
|
{
|
|
if(gpSplashScreen)
|
|
{
|
|
if(Util::GetTickCount64() - gSplashScreenStartTime > 100)
|
|
{
|
|
StopSplashScreen();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Idle-time processing
|
|
|
|
BOOL CTrackApp::OnIdle(LONG lCount)
|
|
{
|
|
BOOL b = CWinApp::OnIdle(lCount);
|
|
|
|
TimeoutSplashScreen();
|
|
|
|
if(CMainFrame::GetMainFrame())
|
|
{
|
|
CMainFrame::GetMainFrame()->IdleHandlerSounddevice();
|
|
|
|
if(m_scannedDlsBanksAvailable)
|
|
{
|
|
if(AddScannedDLSBanks())
|
|
CMainFrame::GetMainFrame()->RefreshDlsBanks();
|
|
}
|
|
}
|
|
|
|
// Call plugins idle routine for open editor
|
|
if (m_pPluginManager)
|
|
{
|
|
DWORD curTime = timeGetTime();
|
|
//rewbs.vstCompliance: call @ 50Hz
|
|
if (curTime - m_dwLastPluginIdleCall > 20 || curTime < m_dwLastPluginIdleCall)
|
|
{
|
|
m_pPluginManager->OnIdle();
|
|
m_dwLastPluginIdleCall = curTime;
|
|
}
|
|
}
|
|
|
|
return b;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// DIB
|
|
|
|
|
|
RGBQUAD rgb2quad(COLORREF c)
|
|
{
|
|
RGBQUAD r;
|
|
r.rgbBlue = GetBValue(c);
|
|
r.rgbGreen = GetGValue(c);
|
|
r.rgbRed = GetRValue(c);
|
|
r.rgbReserved = 0;
|
|
return r;
|
|
}
|
|
|
|
|
|
void DibBlt(HDC hdc, int x, int y, int sizex, int sizey, int srcx, int srcy, MODPLUGDIB *lpdib)
|
|
{
|
|
if (!lpdib) return;
|
|
SetDIBitsToDevice( hdc,
|
|
x,
|
|
y,
|
|
sizex,
|
|
sizey,
|
|
srcx,
|
|
lpdib->bmiHeader.biHeight - srcy - sizey,
|
|
0,
|
|
lpdib->bmiHeader.biHeight,
|
|
lpdib->lpDibBits,
|
|
(LPBITMAPINFO)lpdib,
|
|
DIB_RGB_COLORS);
|
|
}
|
|
|
|
|
|
MODPLUGDIB *LoadDib(LPCTSTR lpszName)
|
|
{
|
|
mpt::const_byte_span data = GetResource(lpszName, RT_BITMAP);
|
|
if(!data.data())
|
|
{
|
|
return nullptr;
|
|
}
|
|
LPBITMAPINFO p = (LPBITMAPINFO)data.data();
|
|
MODPLUGDIB *pmd = new MODPLUGDIB;
|
|
pmd->bmiHeader = p->bmiHeader;
|
|
for (int i=0; i<16; i++) pmd->bmiColors[i] = p->bmiColors[i];
|
|
LPBYTE lpDibBits = (LPBYTE)p;
|
|
lpDibBits += p->bmiHeader.biSize + 16 * sizeof(RGBQUAD);
|
|
pmd->lpDibBits = lpDibBits;
|
|
return pmd;
|
|
}
|
|
|
|
int DrawTextT(HDC hdc, const wchar_t *lpchText, int cchText, LPRECT lprc, UINT format)
|
|
{
|
|
return ::DrawTextW(hdc, lpchText, cchText, lprc, format);
|
|
}
|
|
|
|
int DrawTextT(HDC hdc, const char *lpchText, int cchText, LPRECT lprc, UINT format)
|
|
{
|
|
return ::DrawTextA(hdc, lpchText, cchText, lprc, format);
|
|
}
|
|
|
|
template<typename Tchar>
|
|
static void DrawButtonRectImpl(HDC hdc, CRect rect, const Tchar *lpszText, bool disabled, bool pushed, DWORD textFlags, uint32 topMargin)
|
|
{
|
|
int width = Util::ScalePixels(1, WindowFromDC(hdc));
|
|
if(width != 1)
|
|
{
|
|
// Draw "real" buttons in Hi-DPI mode
|
|
DrawFrameControl(hdc, rect, DFC_BUTTON, pushed ? (DFCS_PUSHED | DFCS_BUTTONPUSH) : DFCS_BUTTONPUSH);
|
|
} else
|
|
{
|
|
const auto colorHighlight = GetSysColor(COLOR_BTNHIGHLIGHT), colorShadow = GetSysColor(COLOR_BTNSHADOW);
|
|
auto oldpen = SelectPen(hdc, GetStockObject(DC_PEN));
|
|
::SetDCPenColor(hdc, pushed ? colorShadow : colorHighlight);
|
|
::FillRect(hdc, rect, GetSysColorBrush(COLOR_BTNFACE));
|
|
::MoveToEx(hdc, rect.left, rect.bottom - 1, nullptr);
|
|
::LineTo(hdc, rect.left, rect.top);
|
|
::LineTo(hdc, rect.right - 1, rect.top);
|
|
::SetDCPenColor(hdc, pushed ? colorHighlight : colorShadow);
|
|
::LineTo(hdc, rect.right - 1, rect.bottom - 1);
|
|
::LineTo(hdc, rect.left, rect.bottom - 1);
|
|
SelectPen(hdc, oldpen);
|
|
}
|
|
|
|
if(lpszText && lpszText[0])
|
|
{
|
|
rect.DeflateRect(width, width);
|
|
if(pushed)
|
|
{
|
|
rect.top += width;
|
|
rect.left += width;
|
|
}
|
|
::SetTextColor(hdc, GetSysColor(disabled ? COLOR_GRAYTEXT : COLOR_BTNTEXT));
|
|
::SetBkMode(hdc, TRANSPARENT);
|
|
rect.top += topMargin;
|
|
auto oldfont = SelectFont(hdc, CMainFrame::GetGUIFont());
|
|
DrawTextT(hdc, lpszText, -1, &rect, textFlags | DT_SINGLELINE | DT_NOPREFIX);
|
|
SelectFont(hdc, oldfont);
|
|
}
|
|
}
|
|
|
|
|
|
void DrawButtonRect(HDC hdc, const RECT *lpRect, LPCSTR lpszText, BOOL bDisabled, BOOL bPushed, DWORD dwFlags, uint32 topMargin)
|
|
{
|
|
DrawButtonRectImpl(hdc, *lpRect, lpszText, bDisabled, bPushed, dwFlags, topMargin);
|
|
}
|
|
|
|
|
|
void DrawButtonRect(HDC hdc, const RECT *lpRect, LPCWSTR lpszText, BOOL bDisabled, BOOL bPushed, DWORD dwFlags, uint32 topMargin)
|
|
{
|
|
DrawButtonRectImpl(hdc, *lpRect, lpszText, bDisabled, bPushed, dwFlags, topMargin);
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////
|
|
// Misc functions
|
|
|
|
|
|
void ErrorBox(UINT nStringID, CWnd *parent)
|
|
{
|
|
CString str;
|
|
BOOL resourceLoaded = str.LoadString(nStringID);
|
|
if(!resourceLoaded)
|
|
{
|
|
str.Format(_T("Resource string %u not found."), nStringID);
|
|
}
|
|
MPT_ASSERT(resourceLoaded);
|
|
Reporting::CustomNotification(str, _T("Error!"), MB_OK | MB_ICONERROR, parent);
|
|
}
|
|
|
|
|
|
CString GetWindowTextString(const CWnd &wnd)
|
|
{
|
|
CString result;
|
|
wnd.GetWindowText(result);
|
|
return result;
|
|
}
|
|
|
|
|
|
mpt::ustring GetWindowTextUnicode(const CWnd &wnd)
|
|
{
|
|
return mpt::ToUnicode(GetWindowTextString(wnd));
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// CFastBitmap 8-bit output / 4-bit input
|
|
// useful for lots of small blits with color mapping
|
|
// combined in one big blit
|
|
|
|
void CFastBitmap::Init(MODPLUGDIB *lpTextDib)
|
|
{
|
|
m_nBlendOffset = 0;
|
|
m_pTextDib = lpTextDib;
|
|
MemsetZero(m_Dib.bmiHeader);
|
|
m_nTextColor = 0;
|
|
m_nBkColor = 1;
|
|
m_Dib.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
|
|
m_Dib.bmiHeader.biWidth = 0; // Set later
|
|
m_Dib.bmiHeader.biHeight = 0; // Ditto
|
|
m_Dib.bmiHeader.biPlanes = 1;
|
|
m_Dib.bmiHeader.biBitCount = 8;
|
|
m_Dib.bmiHeader.biCompression = BI_RGB;
|
|
m_Dib.bmiHeader.biSizeImage = 0;
|
|
m_Dib.bmiHeader.biXPelsPerMeter = 96;
|
|
m_Dib.bmiHeader.biYPelsPerMeter = 96;
|
|
m_Dib.bmiHeader.biClrUsed = 0;
|
|
m_Dib.bmiHeader.biClrImportant = 256; // MAX_MODPALETTECOLORS;
|
|
m_n4BitPalette[0] = (BYTE)m_nTextColor;
|
|
m_n4BitPalette[4] = MODCOLOR_SEPSHADOW;
|
|
m_n4BitPalette[12] = MODCOLOR_SEPFACE;
|
|
m_n4BitPalette[14] = MODCOLOR_SEPHILITE;
|
|
m_n4BitPalette[15] = (BYTE)m_nBkColor;
|
|
}
|
|
|
|
|
|
void CFastBitmap::Blit(HDC hdc, int x, int y, int cx, int cy)
|
|
{
|
|
SetDIBitsToDevice( hdc,
|
|
x,
|
|
y,
|
|
cx,
|
|
cy,
|
|
0,
|
|
m_Dib.bmiHeader.biHeight - cy,
|
|
0,
|
|
m_Dib.bmiHeader.biHeight,
|
|
&m_Dib.DibBits[0],
|
|
(LPBITMAPINFO)&m_Dib,
|
|
DIB_RGB_COLORS);
|
|
}
|
|
|
|
|
|
void CFastBitmap::SetColor(UINT nIndex, COLORREF cr)
|
|
{
|
|
if (nIndex < 256)
|
|
{
|
|
m_Dib.bmiColors[nIndex].rgbRed = GetRValue(cr);
|
|
m_Dib.bmiColors[nIndex].rgbGreen = GetGValue(cr);
|
|
m_Dib.bmiColors[nIndex].rgbBlue = GetBValue(cr);
|
|
}
|
|
}
|
|
|
|
|
|
void CFastBitmap::SetAllColors(UINT nBaseIndex, UINT nColors, COLORREF *pcr)
|
|
{
|
|
for (UINT i=0; i<nColors; i++)
|
|
{
|
|
SetColor(nBaseIndex+i, pcr[i]);
|
|
}
|
|
}
|
|
|
|
|
|
void CFastBitmap::SetBlendColor(COLORREF cr)
|
|
{
|
|
UINT r = GetRValue(cr);
|
|
UINT g = GetGValue(cr);
|
|
UINT b = GetBValue(cr);
|
|
for (UINT i=0; i<BLEND_OFFSET; i++)
|
|
{
|
|
UINT m = (m_Dib.bmiColors[i].rgbRed >> 2)
|
|
+ (m_Dib.bmiColors[i].rgbGreen >> 1)
|
|
+ (m_Dib.bmiColors[i].rgbBlue >> 2);
|
|
m_Dib.bmiColors[i|BLEND_OFFSET].rgbRed = static_cast<BYTE>((m + r)>>1);
|
|
m_Dib.bmiColors[i|BLEND_OFFSET].rgbGreen = static_cast<BYTE>((m + g)>>1);
|
|
m_Dib.bmiColors[i|BLEND_OFFSET].rgbBlue = static_cast<BYTE>((m + b)>>1);
|
|
}
|
|
}
|
|
|
|
|
|
// Monochrome 4-bit bitmap (0=text, !0 = back)
|
|
void CFastBitmap::TextBlt(int x, int y, int cx, int cy, int srcx, int srcy, MODPLUGDIB *lpdib)
|
|
{
|
|
const uint8 *psrc;
|
|
BYTE *pdest;
|
|
UINT x1, x2;
|
|
int srcwidth, srcinc;
|
|
|
|
m_n4BitPalette[0] = (BYTE)m_nTextColor;
|
|
m_n4BitPalette[15] = (BYTE)m_nBkColor;
|
|
if (x < 0)
|
|
{
|
|
cx += x;
|
|
x = 0;
|
|
}
|
|
if (y < 0)
|
|
{
|
|
cy += y;
|
|
y = 0;
|
|
}
|
|
if ((x >= m_Dib.bmiHeader.biWidth) || (y >= m_Dib.bmiHeader.biHeight)) return;
|
|
if (x+cx >= m_Dib.bmiHeader.biWidth) cx = m_Dib.bmiHeader.biWidth - x;
|
|
if (y+cy >= m_Dib.bmiHeader.biHeight) cy = m_Dib.bmiHeader.biHeight - y;
|
|
if (!lpdib) lpdib = m_pTextDib;
|
|
if ((cx <= 0) || (cy <= 0) || (!lpdib)) return;
|
|
srcwidth = (lpdib->bmiHeader.biWidth+1) >> 1;
|
|
srcinc = srcwidth;
|
|
if (((int)lpdib->bmiHeader.biHeight) > 0)
|
|
{
|
|
srcy = lpdib->bmiHeader.biHeight - 1 - srcy;
|
|
srcinc = -srcinc;
|
|
}
|
|
x1 = srcx & 1;
|
|
x2 = x1 + cx;
|
|
pdest = &m_Dib.DibBits[((m_Dib.bmiHeader.biHeight - 1 - y) << m_nXShiftFactor) + x];
|
|
psrc = lpdib->lpDibBits + (srcx >> 1) + (srcy * srcwidth);
|
|
for (int iy=0; iy<cy; iy++)
|
|
{
|
|
uint8 *p = pdest;
|
|
UINT ix = x1;
|
|
if (ix&1)
|
|
{
|
|
UINT b = psrc[ix >> 1];
|
|
*p++ = m_n4BitPalette[b & 0x0F]+m_nBlendOffset;
|
|
ix++;
|
|
}
|
|
while (ix+1 < x2)
|
|
{
|
|
UINT b = psrc[ix >> 1];
|
|
p[0] = m_n4BitPalette[b >> 4]+m_nBlendOffset;
|
|
p[1] = m_n4BitPalette[b & 0x0F]+m_nBlendOffset;
|
|
ix+=2;
|
|
p+=2;
|
|
}
|
|
if (x2&1)
|
|
{
|
|
UINT b = psrc[ix >> 1];
|
|
*p++ = m_n4BitPalette[b >> 4]+m_nBlendOffset;
|
|
}
|
|
pdest -= m_Dib.bmiHeader.biWidth;
|
|
psrc += srcinc;
|
|
}
|
|
}
|
|
|
|
|
|
void CFastBitmap::SetSize(int x, int y)
|
|
{
|
|
if(x > 4)
|
|
{
|
|
// Compute the required shift factor for obtaining a power-of-two bitmap width
|
|
m_nXShiftFactor = 1;
|
|
x--;
|
|
while(x >>= 1)
|
|
{
|
|
m_nXShiftFactor++;
|
|
}
|
|
} else
|
|
{
|
|
// Bitmaps rows are aligned to 4 bytes, so let this bitmap be exactly 4 pixels wide.
|
|
m_nXShiftFactor = 2;
|
|
}
|
|
|
|
x = (1 << m_nXShiftFactor);
|
|
if(m_Dib.DibBits.size() != static_cast<size_t>(y << m_nXShiftFactor)) m_Dib.DibBits.resize(y << m_nXShiftFactor);
|
|
m_Dib.bmiHeader.biWidth = x;
|
|
m_Dib.bmiHeader.biHeight = y;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// DirectX Plugins
|
|
//
|
|
|
|
void CTrackApp::InitializeDXPlugins()
|
|
{
|
|
m_pPluginManager = new CVstPluginManager;
|
|
const size_t numPlugins = GetSettings().Read<int32>(U_("VST Plugins"), U_("NumPlugins"), 0);
|
|
|
|
bool maskCrashes = TrackerSettings::Instance().BrokenPluginsWorkaroundVSTMaskAllCrashes;
|
|
|
|
std::vector<VSTPluginLib *> nonFoundPlugs;
|
|
const mpt::PathString failedPlugin = GetSettings().Read<mpt::PathString>(U_("VST Plugins"), U_("FailedPlugin"), P_(""));
|
|
|
|
CDialog pluginScanDlg;
|
|
CWnd *textWnd = nullptr;
|
|
DWORD64 scanStart = Util::GetTickCount64();
|
|
|
|
// Read tags for built-in plugins
|
|
for(auto plug : *m_pPluginManager)
|
|
{
|
|
mpt::ustring key = MPT_UFORMAT("Plugin{}{}.Tags")(mpt::ufmt::HEX0<8>(plug->pluginId1), mpt::ufmt::HEX0<8>(plug->pluginId2));
|
|
plug->tags = GetSettings().Read<mpt::ustring>(U_("VST Plugins"), key, mpt::ustring());
|
|
}
|
|
|
|
// Restructured plugin cache
|
|
if(TrackerSettings::Instance().PreviousSettingsVersion < MPT_V("1.27.00.15"))
|
|
{
|
|
DeleteFile(m_szPluginCacheFileName.AsNative().c_str());
|
|
GetPluginCache().ForgetAll();
|
|
}
|
|
|
|
m_pPluginManager->reserve(numPlugins);
|
|
auto plugIDFormat = MPT_UFORMAT("Plugin{}");
|
|
auto scanFormat = MPT_CFORMAT("Scanning Plugin {} / {}...\n{}");
|
|
auto tagFormat = MPT_UFORMAT("Plugin{}.Tags");
|
|
for(size_t plug = 0; plug < numPlugins; plug++)
|
|
{
|
|
mpt::PathString plugPath = GetSettings().Read<mpt::PathString>(U_("VST Plugins"), plugIDFormat(plug), mpt::PathString());
|
|
if(!plugPath.empty())
|
|
{
|
|
plugPath = PathInstallRelativeToAbsolute(plugPath);
|
|
|
|
if(!pluginScanDlg.m_hWnd && Util::GetTickCount64() >= scanStart + 2000)
|
|
{
|
|
// If this is taking too long, show the user what they're waiting for.
|
|
pluginScanDlg.Create(IDD_SCANPLUGINS, gpSplashScreen);
|
|
pluginScanDlg.ShowWindow(SW_SHOW);
|
|
pluginScanDlg.CenterWindow(gpSplashScreen);
|
|
textWnd = pluginScanDlg.GetDlgItem(IDC_SCANTEXT);
|
|
} else if(pluginScanDlg.m_hWnd && Util::GetTickCount64() >= scanStart + 30)
|
|
{
|
|
textWnd->SetWindowText(scanFormat(plug + 1, numPlugins + 1, plugPath));
|
|
MSG msg;
|
|
while(::PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
|
|
{
|
|
::TranslateMessage(&msg);
|
|
::DispatchMessage(&msg);
|
|
}
|
|
scanStart = Util::GetTickCount64();
|
|
}
|
|
|
|
if(plugPath == failedPlugin)
|
|
{
|
|
GetSettings().Remove(U_("VST Plugins"), U_("FailedPlugin"));
|
|
const CString text = _T("The following plugin has previously crashed OpenMPT during initialisation:\n\n") + failedPlugin.ToCString() + _T("\n\nDo you still want to load it?");
|
|
if(Reporting::Confirm(text, false, true, &pluginScanDlg) == cnfNo)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
|
|
mpt::ustring plugTags = GetSettings().Read<mpt::ustring>(U_("VST Plugins"), tagFormat(plug), mpt::ustring());
|
|
|
|
bool plugFound = true;
|
|
VSTPluginLib *lib = m_pPluginManager->AddPlugin(plugPath, maskCrashes, plugTags, true, &plugFound);
|
|
if(!plugFound && lib != nullptr)
|
|
{
|
|
nonFoundPlugs.push_back(lib);
|
|
}
|
|
if(lib != nullptr && lib->libraryName == P_("MIDI Input Output") && lib->pluginId1 == PLUGMAGIC('V','s','t','P') && lib->pluginId2 == PLUGMAGIC('M','M','I','D'))
|
|
{
|
|
// This appears to be an old version of our MIDI I/O plugin, which is now built right into the main executable.
|
|
m_pPluginManager->RemovePlugin(lib);
|
|
}
|
|
}
|
|
}
|
|
GetPluginCache().Flush();
|
|
if(pluginScanDlg.m_hWnd)
|
|
{
|
|
pluginScanDlg.DestroyWindow();
|
|
}
|
|
if(!nonFoundPlugs.empty())
|
|
{
|
|
PlugNotFoundDialog(nonFoundPlugs, nullptr).DoModal();
|
|
}
|
|
}
|
|
|
|
|
|
void CTrackApp::UninitializeDXPlugins()
|
|
{
|
|
if(!m_pPluginManager) return;
|
|
|
|
#ifndef NO_PLUGINS
|
|
|
|
size_t plugIndex = 0;
|
|
for(auto plug : *m_pPluginManager)
|
|
{
|
|
if(!plug->isBuiltIn)
|
|
{
|
|
mpt::PathString plugPath = plug->dllPath;
|
|
if(theApp.IsPortableMode())
|
|
{
|
|
plugPath = PathAbsoluteToInstallRelative(plugPath);
|
|
}
|
|
theApp.GetSettings().Write<mpt::PathString>(U_("VST Plugins"), MPT_UFORMAT("Plugin{}")(plugIndex), plugPath);
|
|
|
|
theApp.GetSettings().Write(U_("VST Plugins"), MPT_UFORMAT("Plugin{}.Tags")(plugIndex), plug->tags);
|
|
|
|
plugIndex++;
|
|
} else
|
|
{
|
|
mpt::ustring key = MPT_UFORMAT("Plugin{}{}.Tags")(mpt::ufmt::HEX0<8>(plug->pluginId1), mpt::ufmt::HEX0<8>(plug->pluginId2));
|
|
theApp.GetSettings().Write(U_("VST Plugins"), key, plug->tags);
|
|
}
|
|
}
|
|
theApp.GetSettings().Write(U_("VST Plugins"), U_("NumPlugins"), static_cast<uint32>(plugIndex));
|
|
#endif // NO_PLUGINS
|
|
|
|
delete m_pPluginManager;
|
|
m_pPluginManager = nullptr;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
// Internet-related functions
|
|
|
|
bool CTrackApp::OpenURL(const char *url)
|
|
{
|
|
if(!url) return false;
|
|
return OpenURL(mpt::PathString::FromUTF8(url));
|
|
}
|
|
|
|
bool CTrackApp::OpenURL(const std::string &url)
|
|
{
|
|
return OpenURL(mpt::PathString::FromUTF8(url));
|
|
}
|
|
|
|
bool CTrackApp::OpenURL(const CString &url)
|
|
{
|
|
return OpenURL(mpt::ToUnicode(url));
|
|
}
|
|
|
|
bool CTrackApp::OpenURL(const mpt::ustring &url)
|
|
{
|
|
return OpenURL(mpt::PathString::FromUnicode(url));
|
|
}
|
|
|
|
bool CTrackApp::OpenURL(const mpt::PathString &lpszURL)
|
|
{
|
|
if(!lpszURL.empty() && theApp.m_pMainWnd)
|
|
{
|
|
if(reinterpret_cast<INT_PTR>(ShellExecute(
|
|
theApp.m_pMainWnd->m_hWnd,
|
|
_T("open"),
|
|
lpszURL.AsNative().c_str(),
|
|
NULL,
|
|
NULL,
|
|
SW_SHOW)) >= 32)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
CString CTrackApp::GetResamplingModeName(ResamplingMode mode, int length, bool addTaps)
|
|
{
|
|
CString result;
|
|
switch(mode)
|
|
{
|
|
case SRCMODE_NEAREST:
|
|
result = (length > 1) ? _T("No Interpolation") : _T("None") ;
|
|
break;
|
|
case SRCMODE_LINEAR:
|
|
result = _T("Linear");
|
|
break;
|
|
case SRCMODE_CUBIC:
|
|
result = _T("Cubic");
|
|
break;
|
|
case SRCMODE_SINC8:
|
|
result = _T("Sinc");
|
|
break;
|
|
case SRCMODE_SINC8LP:
|
|
result = _T("Sinc");
|
|
break;
|
|
default:
|
|
MPT_ASSERT_NOTREACHED();
|
|
break;
|
|
}
|
|
if(Resampling::HasAA(mode))
|
|
{
|
|
result += (length > 1) ? _T(" + Low-Pass") : _T(" + LP");
|
|
}
|
|
if(addTaps)
|
|
{
|
|
result += MPT_CFORMAT(" ({} tap{})")(Resampling::Length(mode), (Resampling::Length(mode) != 1) ? CString(_T("s")) : CString(_T("")));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
mpt::ustring CTrackApp::GetFriendlyMIDIPortName(const mpt::ustring &deviceName, bool isInputPort, bool addDeviceName)
|
|
{
|
|
auto friendlyName = GetSettings().Read<mpt::ustring>(isInputPort ? U_("MIDI Input Ports") : U_("MIDI Output Ports"), deviceName, deviceName);
|
|
if(friendlyName.empty())
|
|
return deviceName;
|
|
else if(addDeviceName && friendlyName != deviceName)
|
|
return friendlyName + UL_(" (") + deviceName + UL_(")");
|
|
else
|
|
return friendlyName;
|
|
}
|
|
|
|
|
|
CString CTrackApp::GetFriendlyMIDIPortName(const CString &deviceName, bool isInputPort, bool addDeviceName)
|
|
{
|
|
return mpt::ToCString(GetFriendlyMIDIPortName(mpt::ToUnicode(deviceName), isInputPort, addDeviceName));
|
|
}
|
|
|
|
|
|
OPENMPT_NAMESPACE_END
|